Kevin Kenny$Revision: 1.4 $

Tcl users on the Windows platform have long been at a disadvantage in attempting to do code timing studies, owing to the poor resolution of the Windows system clock. The time command, the clock clicks command, and all related functions are limited to a resolution of (typically) 10 milliseconds. This proposal offers a solution based on the Windows performance counter. It presents a means of disciplining this counter to the system clock so that TclpGetTime (the underlying call that the above commands use) can return times to microsecond precision with accuracy in the tens of microseconds.

2 November 2000: Modified the TIP to discuss the issues surrounding the fact that some multiprocessor kernels on Windows NT use the CPU timestamp counter as a performance counter. Modified the proposed patch to test for the two frequencies in common use on 8254-compatible real-time clocks, and enable using the performance counter only if its frequency matches one of them. Included the proposed patch inline for review rather than as a pointer off to dejanews.

The Windows implementation of TclpGetTime, as of Tcl 8.3.2, uses the ftime call in the C library to extract the current system clock in seconds and milliseconds. While this time value has millisecond precision, its actual resolution is limited by the tick rate of the Windows system clock, normally 100 Hz. Similarly, TclpGetClicks uses the GetTickCount function of kernel32.dll to get the number of milliseconds since bootload; once again, the actual resolution of this call is limited to the tick rate of the system clock. The Windows Platform APIs offer several timers of different accuracy. The most precise of these is QueryPerformanceCounter, which operates at an unspecified frequency (returned by QueryPerformanceFrequency) that is typically about 1.19 MHz. [] has details of the call, with sample code. The documentation for Windows suggests that this function is available only on certain versions of the operating system; in fact, it is implemented in every extant version of Win32 with the exception of Win32s and Windows CE 1.0. Since Visual C++ 6, on which the Tcl distribution depends, will no longer compile code for those two platforms, I assert that they may be safely ignored. The documentation for Windows also states that QueryPerformanceCounter is available only on certain hardware. In practice, this is not an issue; I have never encountered a Windows implementation on an x86 platform that lacks it, and Alpha has it as well. In any case, the reference implementation tests for the success or failure of the system calls in question, and falls back on the old way of getting time should they return an error indication. Users of any platform on which the performance counter is not supported should therefore be no worse off than they have ever been. A worse problem with the performance counter is that its frequency is poorly calibrated, and is frequently off by as much as 200 parts per million. Moreover, the frequency drifts over time, frequently having a sensitive dependency to temperatures inside the computer's case. This problem is not insurmountable. The fix is to maintain the observed frequency of the performance counter (calibrated against the system clock) as a variable at run time, and use that variable together with the value of the performance counter to derive Tcl's concept of the time. This technique is well known to electronic engineers as the "phase locked loop" and is used in network protocols such as NTP[]. One problem that is apparently insurmountable is that certain multiprocessor systems have hardware abstraction layers that derive the performance counter from the CPU timestamp counter in place of a real-time clock reference. This implementation causes the performance counter on one CPU to drift with respect to the other over time; if a thread is moved from one processor to another, it cannot derive a meaningful result from comparing two successive values of the counter. Moreover, if the CPU clock uses a "gearshift" technique for power management (as on Intel SpeedStep or Transmeta machines), the CPU timestamp counter ticks at a non-constant rate. The proposed implementation addresses the problem by using the performance counter only if its nominal frequency is either 1.193182 MHz or 3.579545 MHz. These two frquencies are the common rates when 8254-compatible real-time clock chips are used; virtually all PCI bus controllers have such chips on board. This solution therefore adapts to the vast majority of workstation-class Windows boxes, and is virtually certain to exclude implementations derived from the CPU clock since no modern CPU is that slow. The patch has been tested on several desktop and laptop machines from Compaq, Dell, Gateway, HP, Micron, and Packard Bell, with processors ranging from a 50 MHz 486 to a 750 MHz Pentium III, including laptops using SpeedStep technology. It passes the clock-related test cases on all these platforms; it falls back to the old clocks with 10-ms precision on multiprocessor servers from Compaq and HP. (Using the performance counter actually would have worked on the HP server, which apparently has some way of making sure that the results of QueryPerformanceCounter are consistent from one CPU to another. The performance counter on the Compaq machine was observed to be inconsistent between the two CPU's.)

This document proposes the following changes to the Tcl core: (tclWinTime.c) Add to the static data a set of variables that manage the phase-locked techniques, including a CRITICAL_SECTION to guard them so that multi-threaded code is stable. (tclWinTime.c) Modify TclpGetSeconds to call TclpGetTime and return the 'seconds' portion of the result. This change is necessary to make sure that the two times are consistent near the rollover from one second to another. (tclWinTime.c) Modify TclpGetClicks to use TclpGetTime to determine the click count as a number of microseconds. (tclWinTime.c) Modify TclpGetTime to return the time as M*Q+B, where Q is the result of QueryPerformanceCounter, and M and B are variables maintained by the phase-locked loop to keep the result as close as possible to the system clock. The TclpGetTime call will also launch the phase-lock management in a separate thread the first time that it is invoked. If the performance counter is unavailable, or if its frequency is not one of the two common 8254-compatible rates, then TclpGetTime will return the result of ftime as it does in Tcl 8.3.2. (tclWinTime.c) Add the clock calibration procedure. The calibration is somewhat complex; to save space, the reader is referred to the reference implementation for the details of how the time base and frequency are maintained. (tclWinNotify.c) Modify Tcl_Sleep to test that the process has, in fact, slept for the requisite time by calling TclpGetTime and comparing with the desired time. Otherwise, roundoff errors may cause the process to awaken early. (tclWinTest.c) Add a testwinclock command. This command returns a four element list comprising the seconds and microseconds portions of the system clock and the seconds and microseconds portions of the Tcl clock. (winTime.test) Add to the test suite a test that makes sure that the Tcl clock stays within 1.1 ms of the system clock over the duration of the test.

This change was submitted as a patch to the old bug-tracking system at Scriptics []. It is being recycled as a TIP now that the Tcl Core Team is in place, since the process for advancing the old patches to the Core is not well defined. The link above should not be used to retrieve the current version of the patch, which appears below as an Appendix. Tests on several Wintel boxes have shown that the initial startup transient is less than about 10 seconds (during which time the Tcl clock may be running 500 ppm fast or slow to bring it into step); following this period, the motion of the Tcl clock is highly repeatable and uniform. If the system clock changes by more than 1 second during a run, as when the operator sets it using the eyeball-and-wristwatch method, the method of adjusting the performance frequency to preserve monotonicity and accuracy of interval measurements is hopeless. This is the only case where the Tcl clock is allowed to jump. The startup of the calibration loop does not introduce new instabilities in the behavior of [clock clocks] or TclpGetTime. [clock clicks] and other times that derive from TclpGetTime also ought to be reliable from the beginning - assuming that QueryPerformanceFrequency actually matches the crystal. The worst case while the initial calibration is going on ought to be that the Tcl clock runs 0.1% fast or slow. The point of the calibration loop is to correct for long-term drift. The problem, otherwise, is that QueryPerformanceFrequency may be off by some tens of parts per million with respect to the system clock. Over a period of days, that would cause the Tcl clock to veer off from the system clock. For instance, once my machine is warmed up (temperature is significant, believe it or not), QueryPerformanceFrequency is consistently 0.99985 of the correct value; without calibration, the performance-counter-derived clock drifts 13 seconds per day. The capture transient of the calibration loop is a little different every time, but the one shown below is typical. The Tcl time starts out 2 ms fast with respect to the system time, and the initial estimate of performance frequency is off, too. At 2 seconds in, the calibration loop takes over and makes the clock run 0.1% slow to bring it in line; by 5 seconds in, it's lined up. There's some phase noise over the next 40 seconds or so, by which time the performance frequency is locked on quite closely. The outliers above the line represent the fact that [after] events sometimes arrive late because of various other things going on in Windows. The script that gathered the raw data plotted above appears below. Zm9yZWFjaCB7IHN5c3NlY3Mgc3lzdXNlYyB0Y2xzZWNzIHRjbHVzZWMgfSBbdGVzdHdpbmNsb2NrXSB7fQ==c2V0IGJhc2VzZWNzICRzeXNzZWNzc2V0IGJhc2V1c2VjICRzeXN1c2Vjc2V0IG5UcmlhbHMgMTAwMDA=Zm9yIHsgc2V0IGkgMCB9IHsgJGkgPCAkblRyaWFscyB9IHsgaW5jciBpIH0gew==ICAgIHNldCB2YWx1ZXMge30=ICAgIGZvciB7IHNldCBqIDAgfSB7ICRqIDwgNSB9IHsgaW5jciBqIH0gew==CWZvcmVhY2ggeyBzeXNzZWNzIHN5c3VzZWMgdGNsc2VjcyB0Y2x1c2VjIH0gW3Rlc3R3aW5jbG9ja10ge30=CXNldCBzeXN0aW1lIFtleHByIHsgKCRzeXNzZWNzIC0gJGJhc2VzZWNzKQ==CQkJICAgICsgMS4wZS02ICogJHN5c3VzZWMgLSAxLjBlLTYgKiAkYmFzZXVzZWMgfV0=CXNldCB0Y2x0aW1lIFtleHByIHsgKCR0Y2xzZWNzIC0gJGJhc2VzZWNzKQ==CQkJICAgICsgMS4wZS02ICogJHRjbHVzZWMgLSAxLjBlLTYgKiAkYmFzZXVzZWMgfV0=CXNldCB0aW1lZGlmZiBbZXhwciB7ICR0Y2x0aW1lIC0gJHN5c3RpbWUgfV0=CWxhcHBlbmQgdmFsdWVzIFtsaXN0ICRzeXN0aW1lICR0aW1lZGlmZiAkdGNsdGltZV0=CWFmdGVyIDE=ICAgIH0=ICAgIGZvcmVhY2ggeyBlbGFwc2VkIHRpbWVkaWZmIHRjbHRpbWUgfSBcCVtsaW5kZXggW2xzb3J0IC1yZWFsIC1pbmRleCAxICR2YWx1ZXNdIDBdIHt9ICAgIGxhcHBlbmQgaGlzdG9yeSAkZWxhcHNlZCAkdGltZWRpZmYgJHRjbHRpbWU=fQ==c2V0IGYgW29wZW4gfi90ZXN0Mi5kYXQgd10=Zm9yZWFjaCB7IGVsYXBzZWQgdGltZWRpZmYgdGNsdGltZX0gJGhpc3Rvcnkgew==ICAgIHB1dHMgJGYgIiRlbGFwc2VkXHQkdGltZWRpZmZcdCR0Y2x0aW1lIg==fQ==Y2xvc2UgJGY= To quantify how reproducible the measurements are, I threw a patched tclsh the torture test of executing [time {}] ten million times, and made a histogram of the results. The figure below shows the results. The dots represent individual sample bins, and the solid line is the cumulative count of samples. The vast majority of samples show either five or six microseconds. 99.9% take fewer than nine. There are many samples that take longer, owing to either servicing interrupts or losing the processor to other processes. The lines at 21, 31 and 42 microseconds show up in repeated runs on my machine; I suspect that they represent time spent servicing different sorts of video interrupts. It's less clear to me what the other outliers might be; Windows has a tremendous amount of stuff going on even when it's apparently idle. All tests in the test suite continue to pass with the patch applied.

If you care about time to the absolute precision that this change can achieve, it is of course necessary to discipline the Windows system clock as well. Perhaps the best way is to use one of the available NTP packages ([] for further information).

This document has been placed in the public domain.

The proposed set of patches to the Tcl 8.3.2 code base appears here. KioqIC4uL3RjbDguMy4yYmFzZS9zcmMvdGNsOC4zLjIvd2luL3RjbFdpbk5vdGlmeS5jIEZyaSBKdWwgIDIgMTg6MDg6MzAgMTk5OQ==LS0tIC4vc3JjL3RjbDguMy4yL3dpbi90Y2xXaW5Ob3RpZnkuYyBUaHUgQXVnIDI0IDIzOjI5OjEyIDIwMDA=KioqKioqKioqKioqKioqKioqIDUxMCw1MTQgKioqKg==ICBUY2xfU2xlZXAobXMpICAgICAgaW50IG1zOwkJCS8qIE51bWJlciBvZiBtaWxsaXNlY29uZHMgdG8gc2xlZXAuICovICB7ISAgICAgU2xlZXAobXMpOw==ICB9LS0tIDUxMCw1NDggLS0tLQ==ICBUY2xfU2xlZXAobXMpICAgICAgaW50IG1zOwkJCS8qIE51bWJlciBvZiBtaWxsaXNlY29uZHMgdG8gc2xlZXAuICovICB7ISAgICAgLyo=ISAgICAgICogU2ltcGx5IGNhbGxpbmcgJ1NsZWVwJyBmb3IgdGhlIHJlcXVpc2l0ZSBudW1iZXIgb2YgbWlsbGlzZWNvbmRzISAgICAgICogY2FuIG1ha2UgdGhlIHByb2Nlc3MgYXBwZWFyIHRvIHdha2UgdXAgZWFybHkgYmVjYXVzZSBpdCBpc24ndA==ISAgICAgICogc3luY2hyb25pemVkIHdpdGggdGhlIENQVSBwZXJmb3JtYW5jZSBjb3VudGVyIHRoYXQgaXMgdXNlZCBpbg==ISAgICAgICogdGNsV2luVGltZS5jLiAgVGhpcyBiZWhhdmlvciBpcyBwcm9iYWJseSBiZW5pZ24sIGJ1dCBtZXNzZXM=ISAgICAgICogdXAgc29tZSBvZiB0aGUgY29ybmVyIGNhc2VzIGluIHRoZSB0ZXN0IHN1aXRlLiAgV2UgZ2V0IGFyb3VuZA==ISAgICAgICogdGhpcyBwcm9ibGVtIGJ5IHJlcGVhdGluZyB0aGUgJ1NsZWVwJyBjYWxsIGFzIG1hbnkgdGltZXM=ISAgICAgICogYXMgbmVjZXNzYXJ5IHRvIG1ha2UgdGhlIGNsb2NrIGFkdmFuY2UgYnkgdGhlIHJlcXVpc2l0ZSBhbW91bnQuISAgICAgICovISA=ISAgICAgVGNsX1RpbWUgbm93OwkJLyogQ3VycmVudCB3YWxsIGNsb2NrIHRpbWUgKi8=ISAgICAgVGNsX1RpbWUgZGVzaXJlZDsJCS8qIERlc2lyZWQgd2FrZXVwIHRpbWUgKi8=ISAgICAgaW50IHNsZWVwVGltZSA9IG1zOwkJLyogVGltZSB0byBzbGVlcCAqLw==ISA=ISAgICAgVGNscEdldFRpbWUoICZub3cgKTs=ISAgICAgZGVzaXJlZC5zZWMgPSBub3cuc2VjICsgKCBtcyAvIDEwMDAgKTs=ISAgICAgZGVzaXJlZC51c2VjID0gbm93LnVzZWMgKyAxMDAwICogKCBtcyAlIDEwMDAgKTs=ISAgICAgaWYgKCBkZXNpcmVkLnVzZWMgPiAxMDAwMDAwICkgew==ISAJKytkZXNpcmVkLnNlYzs=ISAJZGVzaXJlZC51c2VjIC09IDEwMDAwMDA7ISAgICAgfQ==ISAJISAgICAgZm9yICggOyA7ICkgew==ISAJU2xlZXAoIHNsZWVwVGltZSApOw==ISAJVGNscEdldFRpbWUoICZub3cgKTs=ISAJaWYgKCBub3cuc2VjID4gZGVzaXJlZC5zZWMgKSB7ISAJICAgIGJyZWFrOw==ISAJfSBlbHNlIGlmICggKCBub3cuc2VjID09IGRlc2lyZWQuc2VjICk=ISAJICAgICAmJiAoIG5vdy51c2VjID49IGRlc2lyZWQudXNlYyApICkgew==ISAJICAgIGJyZWFrOw==ISAJfQ==ISAJc2xlZXBUaW1lID0gKCAoIDEwMDAgKiAoIGRlc2lyZWQuc2VjIC0gbm93LnNlYyApICk=ISAJCSAgICAgICsgKCAoIGRlc2lyZWQudXNlYyAtIG5vdy51c2VjICkgLyAxMDAwICkgKTs=ISAgICAgfQ==ISA=ICB9KioqIC4uL3RjbDguMy4yYmFzZS9zcmMvdGNsOC4zLjIvd2luL3RjbFdpblRlc3QuYyBUaHUgT2N0IDI4IDIzOjA1OjE0IDE5OTk=LS0tIC4vc3JjL3RjbDguMy4yL3dpbi90Y2xXaW5UZXN0LmMgTW9uIFNlcCAgNCAyMjo0NTo1NiAyMDAwKioqKioqKioqKioqKioqKioqIDIyLDI3ICoqKio=LS0tIDIyLDMxIC0tLS0=ICBzdGF0aWMgaW50CVRlc3R2b2x1bWV0eXBlQ21kIF9BTlNJX0FSR1NfKChDbGllbnREYXRhIGR1bW15LA==CSBUY2xfSW50ZXJwICppbnRlcnAsIGludCBvYmpjLA==CSBUY2xfT2JqICpDT05TVCBvYmp2W10pKTs=KyBzdGF0aWMgaW50ICAgICAgVGVzdHdpbmNsb2NrQ21kIF9BTlNJX0FSR1NfKCggQ2xpZW50RGF0YSBkdW1teSw=KyAJCQkJCSAgICAgIFRjbF9JbnRlcnAqIGludGVycCw=KyAJCQkJCSAgICAgIGludCBvYmpjLA==KyAJCQkJCSAgICAgIFRjbF9PYmogKkNPTlNUIG9ianZbXSApKTs=ICAMICAvKg==ICAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0=KioqKioqKioqKioqKioqKioqIDUyLDU3ICoqKio=LS0tIDU2LDYzIC0tLS0=CSAgICAgICAoQ2xpZW50RGF0YSkgMCwgKFRjbF9DbWREZWxldGVQcm9jICopIE5VTEwpOw==ICAgICAgVGNsX0NyZWF0ZU9iakNvbW1hbmQoaW50ZXJwLCAidGVzdHZvbHVtZXR5cGUiLCBUZXN0dm9sdW1ldHlwZUNtZCw=CSAgICAgICAoQ2xpZW50RGF0YSkgMCwgKFRjbF9DbWREZWxldGVQcm9jICopIE5VTEwpOw==KyAgICAgVGNsX0NyZWF0ZU9iakNvbW1hbmQoaW50ZXJwLCAidGVzdHdpbmNsb2NrIiwgVGVzdHdpbmNsb2NrQ21kLA==KyAgICAgICAgICAgICAoQ2xpZW50RGF0YSkgMCwgKFRjbF9DbWREZWxldGVQcm9jICopIE5VTEwpOw==ICAgICAgcmV0dXJuIFRDTF9PSzs=ICB9ICAMKioqKioqKioqKioqKioqKioqIDE4NywxOTAgKioqKg==LS0tIDE5MywyNjcgLS0tLQ==ICAgICAgVGNsX1NldFJlc3VsdChpbnRlcnAsIHZvbFR5cGUsIFRDTF9WT0xBVElMRSk7ICAgICAgcmV0dXJuIFRDTF9PSzs=ICAjdW5kZWYgVk9MX0JVRl9TSVpFKyB9KyAMKyAvKg==KyAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0=KyAgKg==KyAgKiBUZXN0Y2xvY2tDbWQgLS0=KyAgKg==KyAgKglDb21tYW5kIHRoYXQgcmV0dXJucyB0aGUgc2Vjb25kcyBhbmQgbWljcm9zZWNvbmRzIHBvcnRpb25zIG9mKyAgKgl0aGUgc3lzdGVtIGNsb2NrIGFuZCBvZiB0aGUgVGNsIGNsb2NrIHNvIHRoYXQgdGhleSBjYW4gYmU=KyAgKgljb21wYXJlZCB0byB2YWxpZGF0ZSB0aGF0IHRoZSBUY2wgY2xvY2sgaXMgc3RheWluZyBpbiBzeW5jLg==KyAgKg==KyAgKiBVc2FnZTo=KyAgKgl0ZXN0Y2xvY2s=KyAgKg==KyAgKiBQYXJhbWV0ZXJzOg==KyAgKglOb25lLg==KyAgKg==KyAgKiBSZXN1bHRzOg==KyAgKglSZXR1cm5zIGEgc3RhbmRhcmQgVGNsIHJlc3VsdCBjb21wcmlzaW5nIGEgZm91ci1lbGVtZW50IGxpc3Q6KyAgKgl0aGUgc2Vjb25kcyBhbmQgbWljcm9zZWNvbmRzIHBvcnRpb25zIG9mIHRoZSBzeXN0ZW0gY2xvY2ssKyAgKglhbmQgdGhlIHNlY29uZHMgYW5kIG1pY3Jvc2Vjb25kcyBwb3J0aW9ucyBvZiB0aGUgVGNsIGNsb2NrLg==KyAgKg==KyAgKiBTaWRlIGVmZmVjdHM6KyAgKglOb25lLg==KyAgKg==KyAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0=KyAgKi8=KyA=KyBzdGF0aWMgaW50KyBUZXN0d2luY2xvY2tDbWQoIENsaWVudERhdGEgZHVtbXksKyAJCQkJLyogVW51c2VkICovKyAJCSBUY2xfSW50ZXJwKiBpbnRlcnAsKyAJCQkJLyogVGNsIGludGVycHJldGVyICovKyAJCSBpbnQgb2JqYyw=KyAJCQkJLyogQXJndW1lbnQgY291bnQgKi8=KyAJCSBUY2xfT2JqICpDT05TVCBvYmp2W10gKQ==KyAJCQkJLyogQXJndW1lbnQgdmVjdG9yICovKyB7KyAgICAgQ09OU1Qgc3RhdGljIEZJTEVUSU1FIHBvc2l4RXBvY2ggPSB7IDB4RDUzRTgwMDAsIDB4MDE5REIxREUgfTs=KyAJCQkJLyogVGhlIFBvc2l4IGVwb2NoLCBleHByZXNzZWQgYXMgYQ==KyAJCQkJICogV2luZG93cyBGSUxFVElNRSAqLw==KyAgICAgVGNsX1RpbWUgdGNsVGltZTsJCS8qIFRjbCBjbG9jayAqLw==KyAgICAgRklMRVRJTUUgc3lzVGltZTsJCS8qIFN5c3RlbSBjbG9jayAqLw==KyAgICAgVGNsX09iaiogcmVzdWx0OwkJLyogUmVzdWx0IG9mIHRoZSBjb21tYW5kICovKyAgICAgTEFSR0VfSU5URUdFUiB0MSwgdDI7KyA=KyAgICAgaWYgKCBvYmpjICE9IDEgKSB7KyAJVGNsX1dyb25nTnVtQXJncyggaW50ZXJwLCAxLCBvYmp2LCAiIiApOw==KyAJcmV0dXJuIFRDTF9FUlJPUjs=KyAgICAgfQ==KyA=KyAgICAgVGNscEdldFRpbWUoICZ0Y2xUaW1lICk7KyAgICAgR2V0U3lzdGVtVGltZUFzRmlsZVRpbWUoICZzeXNUaW1lICk7KyAgICAgdDEuTG93UGFydCA9IHBvc2l4RXBvY2guZHdMb3dEYXRlVGltZTs=KyAgICAgdDEuSGlnaFBhcnQgPSBwb3NpeEVwb2NoLmR3SGlnaERhdGVUaW1lOw==KyAgICAgdDIuTG93UGFydCA9IHN5c1RpbWUuZHdMb3dEYXRlVGltZTs=KyAgICAgdDIuSGlnaFBhcnQgPSBzeXNUaW1lLmR3SGlnaERhdGVUaW1lOw==KyAgICAgdDIuUXVhZFBhcnQgLT0gdDEuUXVhZFBhcnQ7KyA=KyAgICAgcmVzdWx0ID0gVGNsX05ld09iaigpOw==KyAgICAgVGNsX0xpc3RPYmpBcHBlbmRFbGVtZW50KyAJKCBpbnRlcnAsIHJlc3VsdCwgVGNsX05ld0ludE9iaiggKGludCkgKHQyLlF1YWRQYXJ0IC8gMTAwMDAwMDAgKSApICk7KyAgICAgVGNsX0xpc3RPYmpBcHBlbmRFbGVtZW50KyAJKCBpbnRlcnAsIHJlc3VsdCw=KyAJICBUY2xfTmV3SW50T2JqKCAoaW50KSAoICh0Mi5RdWFkUGFydCAvIDEwICkgJSAxMDAwMDAwICkgKSApOw==KyAgICAgVGNsX0xpc3RPYmpBcHBlbmRFbGVtZW50KCBpbnRlcnAsIHJlc3VsdCwgVGNsX05ld0ludE9iaiggdGNsVGltZS5zZWMgKSApOw==KyAgICAgVGNsX0xpc3RPYmpBcHBlbmRFbGVtZW50KCBpbnRlcnAsIHJlc3VsdCwgVGNsX05ld0ludE9iaiggdGNsVGltZS51c2VjICkgKTs=KyA=KyAgICAgVGNsX1NldE9ialJlc3VsdCggaW50ZXJwLCByZXN1bHQgKTs=KyA=KyAgICAgcmV0dXJuIFRDTF9PSzs=ICB9KioqIC4uL3RjbDguMy4yYmFzZS9zcmMvdGNsOC4zLjIvd2luL3RjbFdpblRpbWUuYyBUdWUgTm92IDMwIDE5OjA4OjQ0IDE5OTk=LS0tIC4vc3JjL3RjbDguMy4yL3dpbi90Y2xXaW5UaW1lLmMgVGh1IE5vdiAgMiAxNDoyNTo1NiAyMDAwKioqKioqKioqKioqKioqKioqIDM4LDQ3ICoqKio=LS0tIDM4LDExNCAtLS0tICBzdGF0aWMgVGNsX1RocmVhZERhdGFLZXkgZGF0YUtleTs=ICA=ICAvKg==KyAgKiBDYWxpYnJhdGlvbiBpbnRlcnZhbCBmb3IgdGhlIGhpZ2gtcmVzb2x1dGlvbiB0aW1lciwgaW4gbXNlYw==KyAgKi8=KyA=KyBzdGF0aWMgQ09OU1QgdW5zaWduZWQgbG9uZyBjbG9ja0NhbGlicmF0ZVdha2V1cEludGVydmFsID0gMTAwMDA7KyAJCQkJLyogRklYTUU6IDEwIHMgLS0gc2hvdWxkIGJlIGFib3V0IDEwIG1pbiEgKi8=KyA=KyAvKg==KyAgKiBEYXRhIGZvciBtYW5hZ2luZyBoaWdoLXJlc29sdXRpb24gdGltZXJzLg==KyAgKi8=KyA=KyB0eXBlZGVmIHN0cnVjdCBUaW1lSW5mbyB7KyA=KyAgICAgQ1JJVElDQUxfU0VDVElPTiBjczsJLyogTXV0ZXggZ3VhcmRpbmcgdGhpcyBzdHJ1Y3R1cmUgKi8=KyA=KyAgICAgaW50IGluaXRpYWxpemVkOwkJLyogRmxhZyA9PSAxIGlmIHRoaXMgc3RydWN0dXJlIGlzKyAJCQkJICogaW5pdGlhbGl6ZWQuICovKyA=KyAgICAgaW50IHBlcmZDb3VudGVyQXZhaWxhYmxlOwkvKiBGbGFnID09IDEgaWYgdGhlIGhhcmR3YXJlIGhhcyBhKyAJCQkJICogcGVyZm9ybWFuY2UgY291bnRlciAqLw==KyA=KyAgICAgSEFORExFIGNhbGlicmF0aW9uVGhyZWFkOwkvKiBIYW5kbGUgdG8gdGhlIHRocmVhZCB0aGF0IGtlZXBzIHRoZQ==KyAJCQkJICogdmlydHVhbCBjbG9jayBjYWxpYnJhdGVkLiAqLw==KyA=KyAgICAgSEFORExFIHJlYWR5RXZlbnQ7CQkvKiBTeXN0ZW0gZXZlbnQgdXNlZCB0bw==KyAJCQkJICogdHJpZ2dlciB0aGUgcmVxdWVzdGluZyB0aHJlYWQ=KyAJCQkJICogd2hlbiB0aGUgY2xvY2sgY2FsaWJyYXRpb24gcHJvY2VkdXJlKyAJCQkJICogaXMgaW5pdGlhbGl6ZWQgZm9yIHRoZSBmaXJzdCB0aW1lICovKyA=KyAgICAgLyo=KyAgICAgICogVGhlIGZvbGxvd2luZyB2YWx1ZXMgYXJlIHVzZWQgZm9yIGNhbGN1bGF0aW5nIHZpcnR1YWwgdGltZS4=KyAgICAgICogVmlydHVhbCB0aW1lIGlzIGFsd2F5cyBlcXVhbCB0bzo=KyAgICAgICogICAgbGFzdEZpbGVUaW1lICsgKGN1cnJlbnQgcGVyZiBjb3VudGVyIC0gbGFzdENvdW50ZXIpIA==KyAgICAgICoJCQkJKiAxMDAwMDAwMCAvIGN1ckNvdW50ZXJGcmVxKyAgICAgICogYW5kIGxhc3RGaWxlVGltZSBhbmQgbGFzdENvdW50ZXIgYXJlIHVwZGF0ZWQgYW55IHRpbWUgdGhhdA==KyAgICAgICogdmlydHVhbCB0aW1lIGlzIHJldHVybmVkIHRvIGEgY2FsbGVyLg==KyAgICAgICovKyA=KyAgICAgVUxBUkdFX0lOVEVHRVIgbGFzdEZpbGVUaW1lOw==KyAgICAgTEFSR0VfSU5URUdFUiBsYXN0Q291bnRlcjs=KyAgICAgTEFSR0VfSU5URUdFUiBjdXJDb3VudGVyRnJlcTs=KyA=KyAgICAgLyogKyAgICAgICogVGhlIG5leHQgdHdvIHZhbHVlcyBhcmUgdXNlZCBvbmx5IGluIHRoZSBjYWxpYnJhdGlvbiB0aHJlYWQsIHRvIHRyYWNrKyAgICAgICogdGhlIGZyZXF1ZW5jeSBvZiB0aGUgcGVyZm9ybWFuY2UgY291bnRlci4=KyAgICAgICovKyA=KyAgICAgTE9OR0xPTkcgbGFzdFBlcmZDb3VudGVyOwkvKiBQZXJmb3JtYW5jZSBjb3VudGVyIHRoZSBsYXN0IHRpbWU=KyAJCQkJICogdGhhdCBVcGRhdGVDbG9ja0VhY2hTZWNvbmQgd2FzIGNhbGxlZCAqLw==KyAgICAgTE9OR0xPTkcgbGFzdFN5c1RpbWU7CS8qIFN5c3RlbSBjbG9jayBhdCB0aGUgbGFzdCB0aW1lKyAJCQkJICogdGhhdCBVcGRhdGVDbG9ja0VhY2hTZWNvbmQgd2FzIGNhbGxlZCAqLw==KyAgICAgTE9OR0xPTkcgZXN0UGVyZkNvdW50ZXJGcmVxOw==KyAJCQkJLyogQ3VycmVudCBlc3RpbWF0ZSBvZiB0aGUgY291bnRlciBmcmVxdWVuY3k=KyAJCQkJICogdXNpbmcgdGhlIHN5c3RlbSBjbG9jayBhcyB0aGUgc3RhbmRhcmQgKi8=KyA=KyB9IFRpbWVJbmZvOw==KyA=KyBzdGF0aWMgVGltZUluZm8gdGltZUluZm8gPSB7KyAgICAgTlVMTCwgMCwgMCwgTlVMTCwgTlVMTCwgMCwgMCwgMCwgMCwgMA==KyB9Ow==KyA=KyBDT05TVCBzdGF0aWMgRklMRVRJTUUgcG9zaXhFcG9jaCA9IHsgMHhENTNFODAwMCwgMHgwMTlEQjFERSB9Ow==KyAgICAgKyAvKg==ICAgKiBEZWNsYXJhdGlvbnMgZm9yIGZ1bmN0aW9ucyBkZWZpbmVkIGxhdGVyIGluIHRoaXMgZmlsZS4=ICAgKi8=ICA=ICBzdGF0aWMgc3RydWN0IHRtICoJQ29tcHV0ZUdNVCBfQU5TSV9BUkdTXygoY29uc3QgdGltZV90ICp0cCkpOw==KyA=KyBzdGF0aWMgRFdPUkQgV0lOQVBJICAgICBDYWxpYnJhdGlvblRocmVhZCBfQU5TSV9BUkdTXygoIExQVk9JRCBhcmcgKSk7KyA=KyBzdGF0aWMgdm9pZCAJCVVwZGF0ZVRpbWVFYWNoU2Vjb25kIF9BTlNJX0FSR1NfKCggdm9pZCApKTs=ICAMICAvKg==ICAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0=KioqKioqKioqKioqKioqKioqIDYzLDY5ICoqKio=ICB1bnNpZ25lZCBsb25nICBUY2xwR2V0U2Vjb25kcygpICB7ISAgICAgcmV0dXJuICh1bnNpZ25lZCBsb25nKSB0aW1lKCh0aW1lX3QgKikgTlVMTCk7ICB9ICAMICAvKg==LS0tIDEzMCwxMzggLS0tLQ==ICB1bnNpZ25lZCBsb25nICBUY2xwR2V0U2Vjb25kcygpICB7ISAgICAgVGNsX1RpbWUgdDs=ISAgICAgVGNscEdldFRpbWUoICZ0ICk7ISAgICAgcmV0dXJuIHQuc2VjOw==ICB9ICAMICAvKg==KioqKioqKioqKioqKioqKioqIDg5LDk1ICoqKio=ICB1bnNpZ25lZCBsb25nICBUY2xwR2V0Q2xpY2tzKCk=ICB7ISAgICAgcmV0dXJuIEdldFRpY2tDb3VudCgpOw==ICB9ICAMICAvKg==LS0tIDE1OCwxNzUgLS0tLQ==ICB1bnNpZ25lZCBsb25nICBUY2xwR2V0Q2xpY2tzKCk=ICB7ISAgICAgLyo=ISAgICAgICogVXNlIHRoZSBUY2xwR2V0VGltZSBhYnN0cmFjdGlvbiB0byBnZXQgdGhlIHRpbWUgaW4gbWljcm9zZWNvbmRzLA==ISAgICAgICogYXMgbmVhcmx5IGFzIHdlIGNhbiwgYW5kIHJldHVybiBpdC4=ISAgICAgICovISA=ISAgICAgVGNsX1RpbWUgbm93OwkJLyogQ3VycmVudCBUY2wgdGltZSAqLw==ISAgICAgdW5zaWduZWQgbG9uZyByZXR2YWw7CS8qIFZhbHVlIHRvIHJldHVybiAqLw==ISA=ISAgICAgVGNscEdldFRpbWUoICZub3cgKTs=ISAgICAgcmV0dmFsID0gKCBub3cuc2VjICogMTAwMDAwMCApICsgbm93LnVzZWM7ISAgICAgcmV0dXJuIHJldHZhbDs=ISA=ICB9ICAMICAvKg==KioqKioqKioqKioqKioqKioqIDEzNCwxNDAgKioqKg==ICAgKglSZXR1cm5zIHRoZSBjdXJyZW50IHRpbWUgaW4gdGltZVB0ci4=ICAgKg==ICAgKiBTaWRlIGVmZmVjdHM6ISAgKglOb25lLg==ICAgKg==ICAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0=ICAgKi8=LS0tIDIxNCwyMjYgLS0tLQ==ICAgKglSZXR1cm5zIHRoZSBjdXJyZW50IHRpbWUgaW4gdGltZVB0ci4=ICAgKg==ICAgKiBTaWRlIGVmZmVjdHM6ISAgKglPbiB0aGUgZmlyc3QgY2FsbCwgaW5pdGlhbGl6ZXMgYSBzZXQgb2Ygc3RhdGljIHZhcmlhYmxlcyB0bw==ISAgKglrZWVwIHRyYWNrIG9mIHRoZSBiYXNlIHZhbHVlIG9mIHRoZSBwZXJmb3JtYW5jZSBjb3VudGVyLCB0aGU=ISAgKgljb3JyZXNwb25kaW5nIHdhbGwgY2xvY2sgKG9idGFpbmVkIHRocm91Z2ggZnRpbWUpIGFuZCB0aGU=ISAgKglmcmVxdWVuY3kgb2YgdGhlIHBlcmZvcm1hbmNlIGNvdW50ZXIuICBBbHNvIHNwaW5zIGEgdGhyZWFkISAgKgl3aG9zZSBmdW5jdGlvbiBpcyB0byB3YWtlIHVwIHBlcmlvZGljYWxseSBhbmQgbW9uaXRvciB0aGVzZQ==ISAgKgl2YWx1ZXMsIGFkanVzdGluZyB0aGVtIGFzIG5lY2Vzc2FyeSB0byBjb3JyZWN0IGZvciBkcmlmdA==ISAgKglpbiB0aGUgcGVyZm9ybWFuY2UgY291bnRlcidzIG9zY2lsbGF0b3IuICAgKg==ICAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0=ICAgKi8=KioqKioqKioqKioqKioqKioqIDE0MywxNTMgKioqKg==ICBUY2xwR2V0VGltZSh0aW1lUHRyKQ==ICAgICAgVGNsX1RpbWUgKnRpbWVQdHI7CQkvKiBMb2NhdGlvbiB0byBzdG9yZSB0aW1lIGluZm9ybWF0aW9uLiAqLw==ICB7ICAgICAgc3RydWN0IHRpbWViIHQ7ICA=ISAgICAgZnRpbWUoJnQpOw==ISAgICAgdGltZVB0ci0+c2VjID0gdC50aW1lOw==ISAgICAgdGltZVB0ci0+dXNlYyA9IHQubWlsbGl0bSAqIDEwMDA7ICB9ICAMICAvKg==LS0tIDIyOSwzNDIgLS0tLQ==ICBUY2xwR2V0VGltZSh0aW1lUHRyKQ==ICAgICAgVGNsX1RpbWUgKnRpbWVQdHI7CQkvKiBMb2NhdGlvbiB0byBzdG9yZSB0aW1lIGluZm9ybWF0aW9uLiAqLw==ICB7KyAJICAgICAgc3RydWN0IHRpbWViIHQ7ICA=ISAgICAgLyogSW5pdGlhbGl6ZSBzdGF0aWMgc3RvcmFnZSBvbiB0aGUgZmlyc3QgdHJpcCB0aHJvdWdoLiAqLw==ISA=ISAgICAgLyo=ISAgICAgICogTm90ZTogT3V0ZXIgY2hlY2sgZm9yICdpbml0aWFsaXplZCcgaXMgYSBwZXJmb3JtYW5jZSB3aW4=ISAgICAgICogc2luY2UgaXQgYXZvaWRzIGFuIGV4dHJhIG11dGV4IGxvY2sgaW4gdGhlIGNvbW1vbiBjYXNlLg==ISAgICAgICovISA=ISAgICAgaWYgKCAhdGltZUluZm8uaW5pdGlhbGl6ZWQgKSB7IA==ISAJVGNscEluaXRMb2NrKCk7ISAJaWYgKCAhdGltZUluZm8uaW5pdGlhbGl6ZWQgKSB7ISAJICAgIHRpbWVJbmZvLnBlcmZDb3VudGVyQXZhaWxhYmxlISAJCT0gUXVlcnlQZXJmb3JtYW5jZUZyZXF1ZW5jeSggJnRpbWVJbmZvLmN1ckNvdW50ZXJGcmVxICk7ISA=ISAJICAgIC8qISAJICAgICAqIFNvbWUgaGFyZHdhcmUgYWJzdHJhY3Rpb24gbGF5ZXJzIHVzZSB0aGUgQ1BVIGNsb2NrISAJICAgICAqIGluIHBsYWNlIG9mIHRoZSByZWFsLXRpbWUgY2xvY2sgYXMgYSBwZXJmb3JtYW5jZSBjb3VudGVyISAJICAgICAqIHJlZmVyZW5jZS4gIFRoaXMgcmVzdWx0cyBpbjo=ISAJICAgICAqICAgIC0gaW5jb25zaXN0ZW50IHJlc3VsdHMgYW1vbmcgdGhlIHByb2Nlc3NvcnMgb24=ISAJICAgICAqICAgICAgbXVsdGktcHJvY2Vzc29yIHN5c3RlbXMuISAJICAgICAqICAgIC0gdW5wcmVkaWN0YWJsZSBjaGFuZ2VzIGluIHBlcmZvcm1hbmNlIGNvdW50ZXIgZnJlcXVlbmN5ISAJICAgICAqICAgICAgb24gImdlYXJzaGlmdCIgcHJvY2Vzc29ycyBzdWNoIGFzIFRyYW5zbWV0YSBhbmQ=ISAJICAgICAqICAgICAgU3BlZWRTdGVwLg==ISAJICAgICAqIFRoZXJlIHNlZW1zIHRvIGJlIG5vIHdheSB0byB0ZXN0IHdoZXRoZXIgdGhlIHBlcmZvcm1hbmNlISAJICAgICAqIGNvdW50ZXIgaXMgcmVsaWFibGUsIGJ1dCBhIHVzZWZ1bCBoZXVyaXN0aWMgaXMgdGhhdA==ISAJICAgICAqIGlmIGl0cyBmcmVxdWVuY3kgaXMgMS4xOTMxODIgTUh6IG9yIDMuNTc5NTQ1IE1IeiwgaXQncw==ISAJICAgICAqIGRlcml2ZWQgZnJvbSBhIGNvbG9yYnVyc3QgY3J5c3RhbCBhbmQgaXMgdGhlcmVmb3JlISAJICAgICAqIHRoZSBSVEMgcmF0aGVyIHRoYW4gdGhlIFRTQy4gIElmIGl0J3MgYW55dGhpbmcgZWxzZSwgd2U=ISAJICAgICAqIHByZXN1bWUgdGhhdCB0aGUgcGVyZm9ybWFuY2UgY291bnRlciBpcyB1bnJlbGlhYmxlLg==ISAJICAgICAqLw==ISA=ISAJICAgIGlmICggdGltZUluZm8ucGVyZkNvdW50ZXJBdmFpbGFibGU=ISAJCSAmJiB0aW1lSW5mby5jdXJDb3VudGVyRnJlcS5RdWFkUGFydCAhPSAxMTkzMTgydWk2NA==ISAJCSAmJiB0aW1lSW5mby5jdXJDb3VudGVyRnJlcS5RdWFkUGFydCAhPSAzNTc5NTQ1dWk2NCApIHs=ISAJCXRpbWVJbmZvLnBlcmZDb3VudGVyQXZhaWxhYmxlID0gRkFMU0U7ISAJICAgIH0=ISA=ISAJICAgIC8qISAJICAgICAqIElmIHRoZSBwZXJmb3JtYW5jZSBjb3VudGVyIGlzIGF2YWlsYWJsZSwgc3RhcnQgYSB0aHJlYWQgdG8=ISAJICAgICAqIGNhbGlicmF0ZSBpdC4=ISAJICAgICAqLw==ISA=ISAJICAgIGlmICggdGltZUluZm8ucGVyZkNvdW50ZXJBdmFpbGFibGUgKSB7ISAJCURXT1JEIGlkOw==ISAJCUluaXRpYWxpemVDcml0aWNhbFNlY3Rpb24oICZ0aW1lSW5mby5jcyApOw==ISAJCXRpbWVJbmZvLnJlYWR5RXZlbnQgPSBDcmVhdGVFdmVudCggTlVMTCwgRkFMU0UsIEZBTFNFLCBOVUxMICk7ISAJCXRpbWVJbmZvLmNhbGlicmF0aW9uVGhyZWFkID0gQ3JlYXRlVGhyZWFkKCBOVUxMLA==ISAJCQkJCQkJICAgODE5Miw=ISAJCQkJCQkJICAgQ2FsaWJyYXRpb25UaHJlYWQsISAJCQkJCQkJICAgKExQVk9JRCkgTlVMTCw=ISAJCQkJCQkJICAgMCw=ISAJCQkJCQkJICAgJmlkICk7ISAJCVNldFRocmVhZFByaW9yaXR5KCB0aW1lSW5mby5jYWxpYnJhdGlvblRocmVhZCw=ISAJCQkJICAgVEhSRUFEX1BSSU9SSVRZX0hJR0hFU1QgKTs=ISAJCVdhaXRGb3JTaW5nbGVPYmplY3QoIHRpbWVJbmZvLnJlYWR5RXZlbnQsIElORklOSVRFICk7ISAJCUNsb3NlSGFuZGxlKCB0aW1lSW5mby5yZWFkeUV2ZW50ICk7ISAJICAgIH0=ISAJICAgIHRpbWVJbmZvLmluaXRpYWxpemVkID0gVFJVRTs=ISAJfQ==ISAJVGNscEluaXRVbmxvY2soKTs=ISAgICAgfQ==ISA=ISAgICAgaWYgKCB0aW1lSW5mby5wZXJmQ291bnRlckF2YWlsYWJsZSApIHs=ISAJISAJLyo=ISAJICogUXVlcnkgdGhlIHBlcmZvcm1hbmNlIGNvdW50ZXIgYW5kIHVzZSBpdCB0byBjYWxjdWxhdGUgdGhlISAJICogY3VycmVudCB0aW1lLg==ISAJICovISA=ISAJTEFSR0VfSU5URUdFUiBjdXJDb3VudGVyOw==ISAJCQkJLyogQ3VycmVudCBwZXJmb3JtYW5jZSBjb3VudGVyICovISA=ISAJTE9OR0xPTkcgY3VyRmlsZVRpbWU7ISAJCQkJLyogQ3VycmVudCBlc3RpbWF0ZWQgdGltZSwgZXhwcmVzc2VkISAJCQkJICogYXMgMTAwLW5zIHRpY2tzIHNpbmNlIHRoZSBXaW5kb3dzIGVwb2NoICovISA=ISAJc3RhdGljIGNvbnN0IExBUkdFX0lOVEVHRVIgcG9zaXhFcG9jaCA9IHsgMHhENTNFODAwMCwgMHgwMTlEQjFERSB9Ow==ISAJCQkJLyogUG9zaXggZXBvY2ggZXhwcmVzc2VkIGFzIDEwMC1ucyB0aWNrcw==ISAJCQkJICogc2luY2UgdGhlIHdpbmRvd3MgZXBvY2ggKi8=ISA=ISAJTE9OR0xPTkcgdXNlY1NpbmNlUG9zaXhFcG9jaDs=ISAJCQkJLyogQ3VycmVudCBtaWNyb3NlY29uZHMgc2luY2UgUG9zaXggZXBvY2ggKi8=ISA=ISAJRW50ZXJDcml0aWNhbFNlY3Rpb24oICZ0aW1lSW5mby5jcyApOw==ISA=ISAJUXVlcnlQZXJmb3JtYW5jZUNvdW50ZXIoICZjdXJDb3VudGVyICk7ISAJY3VyRmlsZVRpbWUgPSB0aW1lSW5mby5sYXN0RmlsZVRpbWUuUXVhZFBhcnQ=ISAJICAgICsgKCAoIGN1ckNvdW50ZXIuUXVhZFBhcnQgLSB0aW1lSW5mby5sYXN0Q291bnRlci5RdWFkUGFydCApISAJCSogMTAwMDAwMDAgLyB0aW1lSW5mby5jdXJDb3VudGVyRnJlcS5RdWFkUGFydCApOw==ISAJdGltZUluZm8ubGFzdEZpbGVUaW1lLlF1YWRQYXJ0ID0gY3VyRmlsZVRpbWU7ISAJdGltZUluZm8ubGFzdENvdW50ZXIuUXVhZFBhcnQgPSBjdXJDb3VudGVyLlF1YWRQYXJ0Ow==ISAJdXNlY1NpbmNlUG9zaXhFcG9jaCA9ICggY3VyRmlsZVRpbWUgLSBwb3NpeEVwb2NoLlF1YWRQYXJ0ICkgLyAxMDs=ISAJdGltZVB0ci0+c2VjID0gKHRpbWVfdCkgKCB1c2VjU2luY2VQb3NpeEVwb2NoIC8gMTAwMDAwMCApOw==ISAJdGltZVB0ci0+dXNlYyA9ICh1bnNpZ25lZCBsb25nICkgKCB1c2VjU2luY2VQb3NpeEVwb2NoICUgMTAwMDAwMCApOw==ISAJISAJTGVhdmVDcml0aWNhbFNlY3Rpb24oICZ0aW1lSW5mby5jcyApOw==ISA=ISAJISAgICAgfSBlbHNlIHs=ISAJISAJLyogSGlnaCByZXNvbHV0aW9uIHRpbWVyIGlzIG5vdCBhdmFpbGFibGUuICBKdXN0IHVzZSBmdGltZSAqLw==ISAJISAJZnRpbWUoJnQpOw==ISAJdGltZVB0ci0+c2VjID0gdC50aW1lOw==ISAJdGltZVB0ci0+dXNlYyA9IHQubWlsbGl0bSAqIDEwMDA7ISAgICAgfQ==ICB9ICAMICAvKg==KioqKioqKioqKioqKioqKioqIDQzOSw0NDIgKioqKg==LS0tIDYyOCw4NDMgLS0tLQ==ICAgICAgfQ==ICA=ICAgICAgcmV0dXJuIHRtUHRyOw==KyB9KyAMKyAvKg==KyAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0=KyAgKg==KyAgKiBDYWxpYnJhdGlvblRocmVhZCAtLQ==KyAgKg==KyAgKglUaHJlYWQgdGhhdCBtYW5hZ2VzIGNhbGlicmF0aW9uIG9mIHRoZSBoaS1yZXNvbHV0aW9uIHRpbWU=KyAgKglkZXJpdmVkIGZyb20gdGhlIHBlcmZvcm1hbmNlIGNvdW50ZXIsIHRvIGtlZXAgaXQgc3luY2hyb25pemVkKyAgKgl3aXRoIHRoZSBzeXN0ZW0gY2xvY2suKyAgKg==KyAgKiBQYXJhbWV0ZXJzOg==KyAgKglhcmcgLS0gQ2xpZW50IGRhdGEgZnJvbSB0aGUgQ3JlYXRlVGhyZWFkIGNhbGwuICBUaGlzIHBhcmFtZXRlcg==KyAgKiAgICAgICAgICAgICBwb2ludHMgdG8gdGhlIHN0YXRpYyBUaW1lSW5mbyBzdHJ1Y3R1cmUuKyAgKg==KyAgKiBSZXR1cm4gdmFsdWU6KyAgKglOb25lLiAgVGhpcyB0aHJlYWQgZW1iZWRzIGFuIGluZmluaXRlIGxvb3AuKyAgKg==KyAgKiBTaWRlIGVmZmVjdHM6KyAgKglBdCBhbiBpbnRlcnZhbCBvZiBjbG9ja0NhbGlicmF0ZVdha2V1cEludGVydmFsIG1zLCB0aGlzIHRocmVhZA==KyAgKglwZXJmb3JtcyB2aXJ0dWFsIHRpbWUgZGlzY2lwbGluZS4=KyAgKg==KyAgKiBOb3RlOiBXaGVuIHRoaXMgdGhyZWFkIGlzIGVudGVyZWQsIFRjbHBJbml0TG9jayBoYXMgYmVlbiBjYWxsZWQ=KyAgKiB0byBzYWZlZ3VhcmQgdGhlIHN0YXRpYyBzdG9yYWdlLiAgVGhlcmUgaXMgdGhlcmVmb3JlIG5vIHN5bmNocm9uaXphdGlvbg==KyAgKiBpbiB0aGUgYm9keSBvZiB0aGlzIHByb2NlZHVyZS4=KyAgKg==KyAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0=KyAgKi8=KyA=KyBzdGF0aWMgRFdPUkQgV0lOQVBJKyBDYWxpYnJhdGlvblRocmVhZCggTFBWT0lEIGFyZyApKyB7KyAgICAgRklMRVRJTUUgY3VyRmlsZVRpbWU7KyA=KyAgICAgLyogR2V0IGluaXRpYWwgc3lzdGVtIHRpbWUgYW5kIHBlcmZvcm1hbmNlIGNvdW50ZXIgKi8=KyA=KyAgICAgR2V0U3lzdGVtVGltZUFzRmlsZVRpbWUoICZjdXJGaWxlVGltZSApOw==KyAgICAgUXVlcnlQZXJmb3JtYW5jZUNvdW50ZXIoICZ0aW1lSW5mby5sYXN0Q291bnRlciApOw==KyAgICAgUXVlcnlQZXJmb3JtYW5jZUZyZXF1ZW5jeSggJnRpbWVJbmZvLmN1ckNvdW50ZXJGcmVxICk7KyAgICAgdGltZUluZm8ubGFzdEZpbGVUaW1lLkxvd1BhcnQgPSBjdXJGaWxlVGltZS5kd0xvd0RhdGVUaW1lOw==KyAgICAgdGltZUluZm8ubGFzdEZpbGVUaW1lLkhpZ2hQYXJ0ID0gY3VyRmlsZVRpbWUuZHdIaWdoRGF0ZVRpbWU7KyA=KyAgICAgLyogSW5pdGlhbGl6ZSB0aGUgd29ya2luZyBzdG9yYWdlIGZvciB0aGUgY2FsaWJyYXRpb24gY2FsbGJhY2sgKi8=KyA=KyAgICAgdGltZUluZm8ubGFzdFBlcmZDb3VudGVyID0gdGltZUluZm8ubGFzdENvdW50ZXIuUXVhZFBhcnQ7KyAgICAgdGltZUluZm8uZXN0UGVyZkNvdW50ZXJGcmVxID0gdGltZUluZm8uY3VyQ291bnRlckZyZXEuUXVhZFBhcnQ7KyA=KyAgICAgLyo=KyAgICAgICogV2FrZSB1cCB0aGUgY2FsbGluZyB0aHJlYWQuICBXaGVuIGl0IHdha2VzIHVwLCBpdCB3aWxsIHJlbGVhc2UgdGhlKyAgICAgICogaW5pdGlhbGl6YXRpb24gbG9jay4=KyAgICAgICovKyA=KyAgICAgU2V0RXZlbnQoIHRpbWVJbmZvLnJlYWR5RXZlbnQgKTs=KyA=KyAgICAgLyogUnVuIHRoZSBjYWxpYnJhdGlvbiBvbmNlIGEgc2Vjb25kICovKyA=KyAgICAgZm9yICggOyA7ICkgew==KyA=KyAJU2xlZXAoIDEwMDAgKTs=KyAJVXBkYXRlVGltZUVhY2hTZWNvbmQoKTs=KyAJKyAgICAgfQ==KyB9KyAMKyAvKg==KyAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0=KyAgKg==KyAgKiBVcGRhdGVUaW1lRWFjaFNlY29uZCAtLQ==KyAgKg==KyAgKglDYWxsYmFjayBmcm9tIHRoZSB3YWl0YWJsZSB0aW1lciBpbiB0aGUgY2xvY2sgY2FsaWJyYXRpb24gdGhyZWFkKyAgKgl0aGF0IHVwZGF0ZXMgc3lzdGVtIHRpbWUuKyAgKg==KyAgKiBQYXJhbWV0ZXJzOg==KyAgKglpbmZvIC0tIFBvaW50ZXIgdG8gdGhlIHN0YXRpYyBUaW1lSW5mbyBzdHJ1Y3R1cmU=KyAgKg==KyAgKiBSZXN1bHRzOg==KyAgKglOb25lLg==KyAgKg==KyAgKiBTaWRlIGVmZmVjdHM6KyAgKglQZXJmb3JtcyB2aXJ0dWFsIHRpbWUgY2FsaWJyYXRpb24gZGlzY2lwbGluZS4=KyAgKg==KyAgKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0=KyAgKi8=KyA=KyBzdGF0aWMgdm9pZA==KyBVcGRhdGVUaW1lRWFjaFNlY29uZCgpKyB7KyA=KyAgICAgTEFSR0VfSU5URUdFUiBjdXJQZXJmQ291bnRlcjs=KyAJCQkJLyogQ3VycmVudCB2YWx1ZSByZXR1cm5lZCBmcm9tKyAJCQkJICogUXVlcnlQZXJmb3JtYW5jZUNvdW50ZXIgKi8=KyA=KyAgICAgTE9OR0xPTkcgcGVyZkNvdW50ZXJEaWZmOwkvKiBEaWZmZXJlbmNlIGJldHdlZW4gdGhlIGN1cnJlbnQgdmFsdWU=KyAJCQkJICogYW5kIHRoZSB2YWx1ZSBvZiAxIHNlY29uZCBhZ28gKi8=KyA=KyAgICAgRklMRVRJTUUgY3VyU3lzVGltZTsJLyogQ3VycmVudCBzeXN0ZW0gdGltZSAqLw==KyA=KyAgICAgTEFSR0VfSU5URUdFUiBjdXJGaWxlVGltZTsJLyogRmlsZSB0aW1lIGF0IHRoZSB0aW1lIHRoaXMgY2FsbGJhY2s=KyAJCQkJICogd2FzIHNjaGVkdWxlZC4gKi8=KyA=KyAgICAgTE9OR0xPTkcgZmlsZVRpbWVEaWZmOwkvKiBFbGFwc2VkIHRpbWUgb24gdGhlIHN5c3RlbSBjbG9jaw==KyAJCQkJICogc2luY2UgdGhlIGxhc3QgdGltZSB0aGlzIHByb2NlZHVyZQ==KyAJCQkJICogd2FzIGNhbGxlZCAqLw==KyA=KyAgICAgTE9OR0xPTkcgaW5zdGFudEZyZXE7CS8qIEluc3RhbnRhbmVvdXMgZXN0aW1hdGUgb2YgdGhlKyAJCQkJICogcGVyZm9ybWFuY2UgY291bnRlciBmcmVxdWVuY3kgKi8=KyA=KyAgICAgTE9OR0xPTkcgZGVsdGE7CQkvKiBJbmNyZW1lbnQgdG8gYWRkIHRvIHRoZSBlc3RpbWF0ZWQ=KyAJCQkJICogcGVyZm9ybWFuY2UgY291bnRlciBmcmVxdWVuY3kgaW4gdGhlKyAJCQkJICogbG9vcCBmaWx0ZXIgKi8=KyA=KyAgICAgTE9OR0xPTkcgZnV6ejsJCS8qIFRvbGVyYW5jZSBmb3IgdGhlIHBlcmYgY291bnRlciBmcmVxdWVuY3kgKi8=KyA=KyAgICAgTE9OR0xPTkcgbG93Qm91bmQ7CQkvKiBMb3dlciBib3VuZCBmb3IgdGhlIGZyZXF1ZW5jeSBhc3N1bWluZw==KyAJCQkJICogMTAwMCBwcG0gdG9sZXJhbmNlICovKyA=KyAgICAgTE9OR0xPTkcgaGlCb3VuZDsJCS8qIFVwcGVyIGJvdW5kIGZvciB0aGUgZnJlcXVlbmN5ICovKyA=KyAgICAgLyo=KyAgICAgICogR2V0IGN1cnJlbnQgcGVyZm9ybWFuY2UgY291bnRlciBhbmQgc3lzdGVtIHRpbWUuKyAgICAgICovKyA=KyAgICAgUXVlcnlQZXJmb3JtYW5jZUNvdW50ZXIoICZjdXJQZXJmQ291bnRlciApOw==KyAgICAgR2V0U3lzdGVtVGltZUFzRmlsZVRpbWUoICZjdXJTeXNUaW1lICk7KyAgICAgY3VyRmlsZVRpbWUuTG93UGFydCA9IGN1clN5c1RpbWUuZHdMb3dEYXRlVGltZTs=KyAgICAgY3VyRmlsZVRpbWUuSGlnaFBhcnQgPSBjdXJTeXNUaW1lLmR3SGlnaERhdGVUaW1lOw==KyA=KyAgICAgRW50ZXJDcml0aWNhbFNlY3Rpb24oICZ0aW1lSW5mby5jcyApOw==KyA=KyAgICAgLyo=KyAgICAgICogRmluZCBvdXQgaG93IG1hbnkgdGlja3Mgb2YgdGhlIHBlcmZvcm1hbmNlIGNvdW50ZXIgYW5kIHRoZQ==KyAgICAgICogc3lzdGVtIGNsb2NrIGhhdmUgZWxhcHNlZCBzaW5jZSB3ZSBnb3QgaW50byB0aGlzIHByb2NlZHVyZS4=KyAgICAgICogRXN0aW1hdGUgdGhlIGN1cnJlbnQgZnJlcXVlbmN5Lg==KyAgICAgICovKyA=KyAgICAgcGVyZkNvdW50ZXJEaWZmID0gY3VyUGVyZkNvdW50ZXIuUXVhZFBhcnQgLSB0aW1lSW5mby5sYXN0UGVyZkNvdW50ZXI7KyAgICAgdGltZUluZm8ubGFzdFBlcmZDb3VudGVyID0gY3VyUGVyZkNvdW50ZXIuUXVhZFBhcnQ7KyAgICAgZmlsZVRpbWVEaWZmID0gY3VyRmlsZVRpbWUuUXVhZFBhcnQgLSB0aW1lSW5mby5sYXN0U3lzVGltZTs=KyAgICAgdGltZUluZm8ubGFzdFN5c1RpbWUgPSBjdXJGaWxlVGltZS5RdWFkUGFydDs=KyAgICAgaW5zdGFudEZyZXEgPSAoIDEwMDAwMDAwICogcGVyZkNvdW50ZXJEaWZmIC8gZmlsZVRpbWVEaWZmICk7KyA=KyAgICAgLyo=KyAgICAgICogQ29uc2lkZXIgdGhpcyBhIHRpbWluZyBnbGl0Y2ggaWYgaW5zdGFudCBmcmVxdWVuY3kgdmFyaWVzKyAgICAgICogc2lnbmlmaWNhbnRseSBmcm9tIHRoZSBjdXJyZW50IGVzdGltYXRlLg==KyAgICAgICovKyA=KyAgICAgZnV6eiA9IHRpbWVJbmZvLmVzdFBlcmZDb3VudGVyRnJlcSA+PiAxMDs=KyAgICAgbG93Qm91bmQgPSB0aW1lSW5mby5lc3RQZXJmQ291bnRlckZyZXEgLSBmdXp6Ow==KyAgICAgaGlCb3VuZCA9IHRpbWVJbmZvLmVzdFBlcmZDb3VudGVyRnJlcSArIGZ1eno7KyAgICAgaWYgKCBpbnN0YW50RnJlcSA8IGxvd0JvdW5kIHx8IGluc3RhbnRGcmVxID4gaGlCb3VuZCApIHs=KyAJTGVhdmVDcml0aWNhbFNlY3Rpb24oICZ0aW1lSW5mby5jcyApOw==KyAJcmV0dXJuOw==KyAgICAgfQ==KyA=KyAgICAgLyo=KyAgICAgICogVXBkYXRlIHRoZSBjdXJyZW50IGVzdGltYXRlIG9mIHBlcmZvcm1hbmNlIGNvdW50ZXIgZnJlcXVlbmN5Lg==KyAgICAgICogVGhpcyBjb2RlIGlzIGVxdWl2YWxlbnQgdG8gdGhlIGxvb3AgZmlsdGVyIG9mIGEgcGhhc2UgbG9ja2VkKyAgICAgICogbG9vcC4=KyAgICAgICovKyA=KyAgICAgZGVsdGEgPSAoIGluc3RhbnRGcmVxIC0gdGltZUluZm8uZXN0UGVyZkNvdW50ZXJGcmVxICkgPj4gNjs=KyAgICAgdGltZUluZm8uZXN0UGVyZkNvdW50ZXJGcmVxICs9IGRlbHRhOw==KyA=KyAgICAgLyo=KyAgICAgICogVXBkYXRlIHRoZSBjdXJyZW50IHZpcnR1YWwgdGltZS4=KyAgICAgICovKyA=KyAgICAgdGltZUluZm8ubGFzdEZpbGVUaW1lLlF1YWRQYXJ0KyAJKz0gKCAoIGN1clBlcmZDb3VudGVyLlF1YWRQYXJ0IC0gdGltZUluZm8ubGFzdENvdW50ZXIuUXVhZFBhcnQgKQ==KyAJICAgICAqIDEwMDAwMDAwIC8gdGltZUluZm8uY3VyQ291bnRlckZyZXEuUXVhZFBhcnQgKTs=KyAgICAgdGltZUluZm8ubGFzdENvdW50ZXIuUXVhZFBhcnQgPSBjdXJQZXJmQ291bnRlci5RdWFkUGFydDs=KyA=KyAgICAgZGVsdGEgPSBjdXJGaWxlVGltZS5RdWFkUGFydCAtIHRpbWVJbmZvLmxhc3RGaWxlVGltZS5RdWFkUGFydDs=KyAgICAgaWYgKCBkZWx0YSA+IDEwMDAwMDAwIHx8IGRlbHRhIDwgLTEwMDAwMDAwICkgew==KyA=KyAJLyo=KyAJICogSWYgdGhlIHZpcnR1YWwgdGltZSBzbGlwIGV4Y2VlZHMgb25lIHNlY29uZCwgdGhlbiBhZGp1c3Rpbmc=KyAJICogdGhlIGNvdW50ZXIgZnJlcXVlbmN5IGlzIGhvcGVsZXNzIChpdCdsbCB0YWtlIG92ZXIgZmlmdGVlbg==KyAJICogbWludXRlcyB0byBsaW5lIHVwIHdpdGggdGhlIHN5c3RlbSBjbG9jaykuICBUaGUgbW9zdCBsaWtlbHk=KyAJICogY2F1c2Ugb2YgdGhpcyBsYXJnZSBhIHNsaXAgaXMgYSBzdWRkZW4gY2hhbmdlIHRvIHRoZSBzeXN0ZW0=KyAJICogY2xvY2ssIHBlcmhhcHMgYmVjYXVzZSBpdCB3YXMgYmVpbmcgY29ycmVjdGVkIGJ5IHdyaXN0d2F0Y2g=KyAJICogYW5kIGV5ZWJhbGwuICBBY2NlcHQgdGhlIHN5c3RlbSB0aW1lLCBhbmQgc2V0IHRoZSBwZXJmb3JtYW5jZQ==KyAJICogY291bnRlciBmcmVxdWVuY3kgdG8gdGhlIGN1cnJlbnQgZXN0aW1hdGUuKyAJICovKyA=KyAJdGltZUluZm8ubGFzdEZpbGVUaW1lLlF1YWRQYXJ0ID0gY3VyRmlsZVRpbWUuUXVhZFBhcnQ7KyAJdGltZUluZm8uY3VyQ291bnRlckZyZXEuUXVhZFBhcnQgPSB0aW1lSW5mby5lc3RQZXJmQ291bnRlckZyZXE7KyA=KyAgICAgfSBlbHNlIHs=KyA=KyAJLyo=KyAJICogQ29tcHV0ZSBhIGNvdW50ZXIgZnJlcXVlbmN5IHRoYXQgd2lsbCBjYXVzZSB2aXJ0dWFsIHRpbWUgdG8gbGluZQ==KyAJICogdXAgd2l0aCBzeXN0ZW0gdGltZSBvbmUgc2Vjb25kIGZyb20gbm93LCBhc3N1bWluZyB0aGF0IHRoZQ==KyAJICogcGVyZm9ybWFuY2UgY291bnRlciBjb250aW51ZXMgdG8gdGljayBhdCB0aW1lSW5mby5lc3RQZXJmQ291bnRlckZyZXEuKyAJICovKyAJKyAJdGltZUluZm8uY3VyQ291bnRlckZyZXEuUXVhZFBhcnQ=KyAJICAgID0gMTAwMDAwMDAgKiB0aW1lSW5mby5lc3RQZXJmQ291bnRlckZyZXEgLyAoIGRlbHRhICsgMTAwMDAwMDAgKTs=KyA=KyAJLyo=KyAJICogTGltaXQgZnJlcXVlbmN5IGV4Y3Vyc2lvbnMgdG8gMTAwMCBwcG0gZnJvbSBlc3RpbWF0ZQ==KyAJICovKyAJKyAJaWYgKCB0aW1lSW5mby5jdXJDb3VudGVyRnJlcS5RdWFkUGFydCA8IGxvd0JvdW5kICkgew==KyAJICAgIHRpbWVJbmZvLmN1ckNvdW50ZXJGcmVxLlF1YWRQYXJ0ID0gbG93Qm91bmQ7KyAJfSBlbHNlIGlmICggdGltZUluZm8uY3VyQ291bnRlckZyZXEuUXVhZFBhcnQgPiBoaUJvdW5kICkgew==KyAJICAgIHRpbWVJbmZvLmN1ckNvdW50ZXJGcmVxLlF1YWRQYXJ0ID0gaGlCb3VuZDs=KyAJfQ==KyAgICAgfQ==KyA=KyAgICAgTGVhdmVDcml0aWNhbFNlY3Rpb24oICZ0aW1lSW5mby5jcyApOw==KyA=ICB9KioqIC4uL3RjbDguMy4yYmFzZS9zcmMvdGNsOC4zLjIvdGVzdC93aW5UaW1lLnRlc3QgTW9uIEFwciAxMCAxMzoxOTowOCAyMDAwLS0tIC4vdGNsOC4zLjIvc3JjL3RjbDguMy4yL3Rlc3Qvd2luVGltZS50ZXN0IFdlZCBTZXAgIDYgMTQ6NTU6MzAgMjAwMA==KioqKioqKioqKioqKioqKioqIDMzLDM4ICoqKio=LS0tIDMzLDY0IC0tLS0=ICAgICAgc2V0IHJlc3VsdA==ICB9IHsxOTY5fQ==ICA=KyAjIE5leHQgdGVzdCB0cmllcyB0byBtYWtlIHN1cmUgdGhhdCB0aGUgVGNsIGNsb2NrIHN0YXlzIGluIHN0ZXA=KyAjIHdpdGggdGhlIFdpbmRvd3MgY2xvY2suICAzMDAwIGl0ZXJhdGlvbnMgcmVhbGx5IGlzbid0IGVub3VnaCw=KyAjIGJ1dCBob3cgbWFueSBkb2VzIGEgdGVzdGVyIGhhdmUgcGF0aWVuY2UgZm9yPw==KyA=KyB0ZXN0IHdpblRpbWUtMi4xIHtTeW5jaHJvbml6YXRpb24gb2YgVGNsIGFuZCBXaW5kb3dzIGNsb2Nrc30ge3BjT25seX0gew==KyAgICAgc2V0IGZhaWxlZCAwKyAgICAgZm9yZWFjaCB7IHN5c19zZWMgc3lzX3VzZWMgdGNsX3NlYyB0Y2xfdXNlYyB9IFt0ZXN0d2luY2xvY2tdIHt9KyAgICAgc2V0IG9sZGRpZmYgW2V4cHIgeyBhYnMgKCAkdGNsX3NlYyAtICRzeXNfc2VjKyAJCQkgICArIDEuMGUtNiAqICggJHRjbF91c2VjIC0gJHN5c191c2VjICkgKSB9XQ==KyAgICAgc2V0IG9rIDE=KyAgICAgZm9yIHsgc2V0IGkgMCB9IHsgJGkgPCAzMDAwIH0geyBpbmNyIGkgfSB7KyAJZm9yZWFjaCB7IHN5c19zZWMgc3lzX3VzZWMgdGNsX3NlYyB0Y2xfdXNlYyB9IFt0ZXN0d2luY2xvY2tdIHt9KyAJc2V0IGRpZmYgW2V4cHIgeyBhYnMgKCAkdGNsX3NlYyAtICRzeXNfc2VjKyAJCQkgICAgICAgKyAxLjBlLTYgKiAoICR0Y2xfdXNlYyAtICRzeXNfdXNlYyApICkgfV0=KyAJaWYgeyAoICRkaWZmID4gJG9sZGRpZmYgKyAxMDAwICk=KyAJICAgICB8fCAoICRkaWZmID4gMTEwMDAgKSB9IHs=KyAJICAgIHNldCBmYWlsZWQgMQ==KyAJICAgIGJyZWFrKyAJfSBlbHNlIHs=KyAJICAgIHNldCBvbGRkaWZmICRkaWZmKyAJICAgIGFmdGVyIDE=KyAJfQ==KyAgICAgfQ==KyAgICAgc2V0IGZhaWxlZA==KyB9IHswfQ==KyA=ICAjIGNsZWFudXA=ICA6OnRjbHRlc3Q6OmNsZWFudXBUZXN0cw==ICByZXR1cm4=