86021 2012-05-09 15:05:54 -0700 performance tests should be able to measure runs/sec rather than time 2012-05-14 12:29:48 -0700 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 77037 1 tony rniwa abarth dpranke haraken kling koivisto mjs morrita ojan rniwa tomz webkit.review.bot oldest_to_newest 619890 0 tony 2012-05-09 15:05:54 -0700 It is helpful to measure runs/sec for a fixed time because as we speed up tests and hardware gets faster, the precision of measurement gets worse. I think Morita did a one off change to support Dromaeo tests (which measure hertz), but we should roll this ability directly into PerformanceTests/resources/runner.js so non-Dromaeo tests can also use hertz. 622246 1 141553 rniwa 2012-05-11 23:55:29 -0700 Created attachment 141553 Adds PerfTestRunner.runPerSecond and converts flexbox tests 622385 2 141553 ojan 2012-05-12 10:31:42 -0700 Comment on attachment 141553 Adds PerfTestRunner.runPerSecond and converts flexbox tests View in context: https://bugs.webkit.org/attachment.cgi?id=141553&action=review > PerformanceTests/ChangeLog:17 > + By default, runPerSecond runs the test for at least 750 milliseconds in each run, and executes > + 21 runs, yielding the total run time of roughly 18 seconds. This is significantly faster than Do we really need to run 21 times to get the variance down? Seems excessive to me. Have you looked at what V8 does? They've have lots of time to tweak their test runner to reduce variance, but still be fast. With every test taking 18 seconds, the cycle time for the bots will be huge as people add tests and it will be harder to tell which patch caused a regression. > PerformanceTests/resources/runner.js:79 > + result.unit = unit || "ms"; Looks like you always set unit, so do you need this ||? > PerformanceTests/resources/runner.js:167 > +PerfTestRunner.runPerSecond = function (test) { It's up to you, but I would call this method run and call the other method runTime or something like that. Whichever method is called run is the one naive test writers will use. > PerformanceTests/resources/runner.js:179 > + this._runCount = test.runCount || 21; > + this._doneFunction = function () { if (test.done) test.done(); }; > + this._completedRuns = 0; > + this._callsPerIteration = 1; > + this.customRunFunction = null; > + this.unit = 'runs/s'; > + this._results = []; > + > + this._test = test; > + this._runner = this._perSecondRunner; > + this.log("Running " + this._runCount + " times"); > + this._runLoop(); Looks like this duplicates a lot of code in PerfTestRunner.run. Could they both call a shared helper function? PerfTestRunner._resetState or something? > PerformanceTests/resources/runner.js:195 > + totalTime += this._perSecondRunnerIterator(callsPerIteration); > + i += callsPerIteration; > + if (this._completedRuns <= 0 && totalTime < 100) > + callsPerIteration = Math.max(10, 2 * callsPerIteration); Again, it would be good to see what the V8 test harness does for this loop. > PerformanceTests/resources/runner.js:212 > + var startTime = new Date(); > + for (var i = 0; i < callsPerIteration; i++) > + this._test.run(); > + return new Date() - startTime; Nit: s/new Date()/Date.now()/. Saves the cost of instantiating a Date object, which is most of the cost. 622405 3 141553 rniwa 2012-05-12 13:00:33 -0700 Comment on attachment 141553 Adds PerfTestRunner.runPerSecond and converts flexbox tests View in context: https://bugs.webkit.org/attachment.cgi?id=141553&action=review Thanks for the review! >> PerformanceTests/ChangeLog:17 >> + 21 runs, yielding the total run time of roughly 18 seconds. This is significantly faster than > > Do we really need to run 21 times to get the variance down? Seems excessive to me. Have you looked at what V8 does? They've have lots of time to tweak their test runner to reduce variance, but still be fast. With every test taking 18 seconds, the cycle time for the bots will be huge as people add tests and it will be harder to tell which patch caused a regression. I think each test taking 18s is an improvement over the current situation where we spend well over a minute on some tests. I did look into what v8 benchmark and dom_perf do. According to http://code.google.com/p/v8/source/browse/trunk/benchmarks/base.js#201, V8's benchmark runs for at least 1s or 32 runs. So 750ms is even smaller than that. We spend 18 seconds because we're getting 21 samples. We can tweak and reduce the time if we wanted to in the future but we definitely need at least 20 samples. (I wanted 100 samples but that takes too long so we're already compromising on that end) >> PerformanceTests/resources/runner.js:79 >> + result.unit = unit || "ms"; > > Looks like you always set unit, so do you need this ||? No, there are tests that directly calls computeStatistics. >> PerformanceTests/resources/runner.js:167 >> +PerfTestRunner.runPerSecond = function (test) { > > It's up to you, but I would call this method run and call the other method runTime or something like that. Whichever method is called run is the one naive test writers will use. Yeah, I'm planning to do that once I've converted some test and seen how they behave over time. >> PerformanceTests/resources/runner.js:179 >> + this._runLoop(); > > Looks like this duplicates a lot of code in PerfTestRunner.run. Could they both call a shared helper function? PerfTestRunner._resetState or something? I thought about it but then most of initializations are slightly different between the two :( The only code they can share is this.customRunFunction = null; this._results = []; this.log("Running " + this._runCount + " times"); this._runLoop(); Do you have a suggestion as to how to create a shared helper? >> PerformanceTests/resources/runner.js:195 >> + callsPerIteration = Math.max(10, 2 * callsPerIteration); > > Again, it would be good to see what the V8 test harness does for this loop. What they're doing is pretty naive: http://code.google.com/p/v8/source/browse/trunk/benchmarks/base.js#205 They're doing "new Date();" between each run even though they're expecting to have 32 or more runs per second. >> PerformanceTests/resources/runner.js:212 >> + return new Date() - startTime; > > Nit: s/new Date()/Date.now()/. Saves the cost of instantiating a Date object, which is most of the cost. Good catch. Will fix. 622473 4 141553 ojan 2012-05-12 22:49:00 -0700 Comment on attachment 141553 Adds PerfTestRunner.runPerSecond and converts flexbox tests View in context: https://bugs.webkit.org/attachment.cgi?id=141553&action=review >>> PerformanceTests/ChangeLog:17 >>> + 21 runs, yielding the total run time of roughly 18 seconds. This is significantly faster than >> >> Do we really need to run 21 times to get the variance down? Seems excessive to me. Have you looked at what V8 does? They've have lots of time to tweak their test runner to reduce variance, but still be fast. With every test taking 18 seconds, the cycle time for the bots will be huge as people add tests and it will be harder to tell which patch caused a regression. > > I think each test taking 18s is an improvement over the current situation where we spend well over a minute on some tests. > > I did look into what v8 benchmark and dom_perf do. According to http://code.google.com/p/v8/source/browse/trunk/benchmarks/base.js#201, > V8's benchmark runs for at least 1s or 32 runs. So 750ms is even smaller than that. We spend 18 seconds because we're getting 21 samples. > > We can tweak and reduce the time if we wanted to in the future but we definitely need at least 20 samples. > (I wanted 100 samples but that takes too long so we're already compromising on that end) I actually prefer how the V8 benchmark code does this. It looks much simpler to me and is less likely to have test harness-induced variance. 1. It doesn't do anything special to try to deal with Date objects being slow. I think if you're running for 1 second and using Date.now, you don't need to do this thing with callsPerIteration. It's too complicated and could lead to high accidental variance. How about we drop that for now and see what the results look like before complicating the test harness? 2. The V8 code does 1 second or 32 runs, but it only does it once. I don't see what benefit we get from running it 21 times. If we need something to reduce the variance, we can increase the measurement time to higher than 1 second or the minimum runs to more than 32. Running multiple times just makes for more complicated, harder to reason about code. 622516 5 141553 ojan 2012-05-13 11:32:45 -0700 Comment on attachment 141553 Adds PerfTestRunner.runPerSecond and converts flexbox tests View in context: https://bugs.webkit.org/attachment.cgi?id=141553&action=review >>>> PerformanceTests/ChangeLog:17 >>>> + 21 runs, yielding the total run time of roughly 18 seconds. This is significantly faster than >>> >>> Do we really need to run 21 times to get the variance down? Seems excessive to me. Have you looked at what V8 does? They've have lots of time to tweak their test runner to reduce variance, but still be fast. With every test taking 18 seconds, the cycle time for the bots will be huge as people add tests and it will be harder to tell which patch caused a regression. >> >> I think each test taking 18s is an improvement over the current situation where we spend well over a minute on some tests. >> >> I did look into what v8 benchmark and dom_perf do. According to http://code.google.com/p/v8/source/browse/trunk/benchmarks/base.js#201, >> V8's benchmark runs for at least 1s or 32 runs. So 750ms is even smaller than that. We spend 18 seconds because we're getting 21 samples. >> >> We can tweak and reduce the time if we wanted to in the future but we definitely need at least 20 samples. >> (I wanted 100 samples but that takes too long so we're already compromising on that end) > > I actually prefer how the V8 benchmark code does this. It looks much simpler to me and is less likely to have test harness-induced variance. > > 1. It doesn't do anything special to try to deal with Date objects being slow. I think if you're running for 1 second and using Date.now, you don't need to do this thing with callsPerIteration. It's too complicated and could lead to high accidental variance. How about we drop that for now and see what the results look like before complicating the test harness? > > 2. The V8 code does 1 second or 32 runs, but it only does it once. I don't see what benefit we get from running it 21 times. If we need something to reduce the variance, we can increase the measurement time to higher than 1 second or the minimum runs to more than 32. Running multiple times just makes for more complicated, harder to reason about code. I remembered that magnitude-perf.js does something similar to the code you have here. I wonder actually if that contributes to some of the flakiness we see in the LayoutTest/perf tests. Might be worth trying locally to simplify that logic and see if things get less flaky. 622580 6 141617 rniwa 2012-05-13 16:58:36 -0700 Created attachment 141617 Flebox Perf. Test Experiment - function call per iteration is adjusted 622581 7 141618 rniwa 2012-05-13 16:59:08 -0700 Created attachment 141618 Flebox Perf. Test Experiment - function call per iteration is 1 622584 8 rniwa 2012-05-13 17:11:18 -0700 Okay, I was curious about this so I did some experiments. I've ran run-perf-tests on Google-issued MacBookPro (6,2, OS X: 10.6.8, CPU: Core i5 2.53GHz, RAM: 4GB DDR3 1067MHz) with two variants of runner.js one where callsPerIteration = 1 and another where callsPerIteration is adjusted in the patch. To minimize the noise, I did: - disabled anti-virus software during the experiment - used each variant of runner.js in turn so that if there had been some permanent environment changes, then both results would get affected - not use keyboard or mouse while run-perf-tests was running. First, I hypothesized that adjusting the function calls per iteration will only benefit fast run functions while it does not affect slow run functions. To confirm (or rather to refute if possible) the latter null-hypothesis (i.e. it does not affect slow run functions), I used flexbox performance added by Tony as modified in the attached patch, and ran the tests 10 times each, and mean, median, stdev, min, and max values were recorded. CallsPerIteartion = 1: https://bug-86021-attachments.webkit.org/attachment.cgi?id=141618 CallsPerIteration adjusted: https://bug-86021-attachments.webkit.org/attachment.cgi?id=141617 From the graph, I could not observe any statistically significant differences between the two approach. 622585 9 rniwa 2012-05-13 17:14:26 -0700 Here is the average of standard deviations I observed in two approaches: CallsPerIteration = 1 test flexbox-column-nowrap flexbox-column-wrap flexbox-row-nowrap flexbox-row-wrap avg stdev 10.013323 9.466342569 5.057115346 7.981334236 CallsPerIteration adjusted test flexbox-column-nowrap flexbox-column-wrap flexbox-row-nowrap flexbox-row-wrap avg stdev 11.21493623 8.05499943 9.153795006 6.051266683 622588 10 rniwa 2012-05-13 17:35:01 -0700 Now for the formar null-hypothesis that the adjustment will benefit fast run functions, and addresses ojan's point 1, I've created a following test: <!DOCTYPE html> <html> <body> <script src="../resources/runner.js"></script> <script> PerfTestRunner.runPerSecond({run: function () { document.createElement('div'); }}); </script> </body> </html> And took 20 samples with both approaches. The result can be seen at https://docs.google.com/spreadsheet/ccc?key=0AqvOKf8yeFVCdG1PRnJsYnBUWUg4SW5lZFJyN0M1bWc The result is that the average standard deviation for CallsWithIteration is roughly 1.35% (or 1.07% if we get rid of one off value), and it is 2.02% when CallsWithIteration is 1. That is, we have 50%-100% more variance when CallsWithIteration is always 1. Furthermore, the results when CallsWithIteration is 1 was 14% slower, indicating that calls to Date.now() significantly affected the results. Thus, I'm strongly include to refute Ojan's null-hypothesis in comment #4 that "if you're running for 1 second and using Date.now, you don't need to do this thing with callsPerIteration" although my experiments ran for 750ms per iteration. 622591 11 rniwa 2012-05-13 17:48:39 -0700 Now let us test the second null-hypothesis Ojan suggested: (In reply to comment #4) > 2. The V8 code does 1 second or 32 runs, but it only does it once. I don't see what benefit we get from running it 21 times. If we need something to reduce the variance, we can increase the measurement time to higher than 1 second or the minimum runs to more than 32. Running multiple times just makes for more complicated, harder to reason about code. Looking at the test results posted in comment #10, we see that even when CallsPerIteration is adjusted, (avg max - avg min) / (avg min) is staggering 6.3% even though standard deviation in each run stayed within 1-2% range. Similarly, the values for flexbox perf. tests were around 4-5% even though standard deviations in each run, again, stayed within 0.5-2% range. (See https://docs.google.com/spreadsheet/ccc?key=0AqvOKf8yeFVCdFNvT2s0ZjJRQmhXc3EwTDhQejQ3aFE for flexbox experiment results) Thus, I conclude that running the tests for 750ms once is definitely inadequate given we would like to catch performance regressions in the order of 5-10% 622624 12 141631 rniwa 2012-05-13 20:55:44 -0700 Created attachment 141631 Patch for landing 622649 13 141631 webkit.review.bot 2012-05-13 22:22:55 -0700 Comment on attachment 141631 Patch for landing Clearing flags on attachment: 141631 Committed r116916: <http://trac.webkit.org/changeset/116916> 622650 14 webkit.review.bot 2012-05-13 22:23:01 -0700 All reviewed patches have been landed. Closing bug. 623212 15 rniwa 2012-05-14 12:29:48 -0700 Build fix landed in http://trac.webkit.org/changeset/116976. 141553 2012-05-11 23:55:29 -0700 2012-05-13 20:55:36 -0700 Adds PerfTestRunner.runPerSecond and converts flexbox tests bug-86021-20120511235528.patch text/plain 14891 rniwa SW5kZXg6IFBlcmZvcm1hbmNlVGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFBlcmZvcm1h bmNlVGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiAxMTY4MzkpCisrKyBQZXJmb3JtYW5jZVRlc3Rz L0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDM3IEBACisyMDEyLTA1LTExICBS eW9zdWtlIE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgorCisgICAgICAgIHBlcmZvcm1hbmNlIHRl c3RzIHNob3VsZCBiZSBhYmxlIHRvIG1lYXN1cmUgcnVucy9zZWMgcmF0aGVyIHRoYW4gdGltZQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODYwMjEKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgUGVyZlRl c3RSdW5uZXIucnVuUGVyU2Vjb25kLiBJdCB1c2VzIF9ydW5Mb29wIGJ1dCByZXBsYWNlcyBfcnVu bmVyIGJ5IF9wZXJTZWNvbmRSdW5uZXIKKyAgICAgICAgdG8gY29tcHV0ZSBydW5zL3Mgb2YgcnVu RnVuY3Rpb24uCisKKyAgICAgICAgV2hlbiBfcGVyU2Vjb25kUnVubmVyIGlzIGNhbGxlZCBmb3Ig dGhlIGZpcnN0IHRpbWUsIGkuZS4gX2NvbXBsZXRlZFJ1bnMgaXMgMCAobm90aWNlIHRoaXMgaXMg LTEKKyAgICAgICAgaW4gcmVndWxhciBydW4vX3J1bm5lciksIGl0IHNsb3dseSBpbmNyZWFzZXMg dGhlIG51bWJlciBvZiBmdW5jdGlvbiBjYWxscyB0byBydW5GdW5jdGlvbiBiZXR3ZWVuCisgICAg ICAgIHRpbWUgbWVhc3VyZW1lbnRzIGluIG9yZGVyIHRvIGRpc2NvdW50IHRoZSB0aW1lIHVzZWQg YnkgbmV3IERhdGUoKSBjYWxscyB0aGVtc2VsdmVzIHVudGlsIHRoZQorICAgICAgICB0b3RhbCB0 aW1lIHNwZW50IHJlYWNoZXMgMTAwIG1pbGxpc2Vjb25kcy4KKworICAgICAgICBCeSBkZWZhdWx0 LCBydW5QZXJTZWNvbmQgcnVucyB0aGUgdGVzdCBmb3IgYXQgbGVhc3QgNzUwIG1pbGxpc2Vjb25k cyBpbiBlYWNoIHJ1biwgYW5kIGV4ZWN1dGVzCisgICAgICAgIDIxIHJ1bnMsIHlpZWxkaW5nIHRo ZSB0b3RhbCBydW4gdGltZSBvZiByb3VnaGx5IDE4IHNlY29uZHMuIFRoaXMgaXMgc2lnbmlmaWNh bnRseSBmYXN0ZXIgdGhhbgorICAgICAgICBtb3N0IG9mIGV4aXN0aW5nIHBlcmZvcm1hbmNlIHRl c3RzLiBBbHNvIHNlZSBodHRwOi8vZWpvaG4ub3JnL2Jsb2cvYWNjdXJhY3ktb2YtamF2YXNjcmlw dC10aW1lLy4KKworICAgICAgICBGaW5hbGx5LCByZWZhY3RvcmVkIHRoZSBleGlzdGluZyBtZXRo b2RzIG9mIFBlcmZUZXN0UnVubmVyIHRvIGFsbG93ICJydW5zL3MiIHVuaXQgYW5kIHNoYXJlIGNv ZGUuCisKKyAgICAgICAgKiBMYXlvdXQvZmxleGJveC1jb2x1bW4tbm93cmFwLmh0bWw6CisgICAg ICAgICogTGF5b3V0L2ZsZXhib3gtY29sdW1uLXdyYXAuaHRtbDoKKyAgICAgICAgKiBMYXlvdXQv ZmxleGJveC1yb3ctbm93cmFwLmh0bWw6CisgICAgICAgICogTGF5b3V0L2ZsZXhib3gtcm93LXdy YXAuaHRtbDoKKyAgICAgICAgKiByZXNvdXJjZXMvcnVubmVyLmpzOgorICAgICAgICAoUGVyZlRl c3RSdW5uZXIuY29tcHV0ZVN0YXRpc3RpY3MpOiBUYWtlcyB1bml0LgorICAgICAgICAoUGVyZlRl c3RSdW5uZXIubG9nU3RhdGlzdGljcyk6IERpdHRvLgorICAgICAgICAoUGVyZlRlc3RSdW5uZXIu X3J1bkxvb3ApOgorICAgICAgICAoUGVyZlRlc3RSdW5uZXIuX3J1bm5lcik6CisgICAgICAgIChQ ZXJmVGVzdFJ1bm5lci5ydW5QZXJTZWNvbmQpOiBBZGRlZC4KKyAgICAgICAgKFBlcmZUZXN0UnVu bmVyLl9wZXJTZWNvbmRSdW5uZXIpOiBBZGRlZC4gQ2FsbGVkIGJ5IF9ydW5Mb29wLgorICAgICAg ICAoUGVyZlRlc3RSdW5uZXIuX3BlclNlY29uZFJ1bm5lckl0ZXJhdG9yKTogQWRkZWQuCisKIDIw MTItMDUtMDkgIFRvbnkgQ2hhbmcgIDx0b255QGNocm9taXVtLm9yZz4KIAogICAgICAgICBhZGQg c29tZSBiYXNpYyBwZXJmLW8tbWF0aWMgdGVzdHMgZm9yIGZsZXhib3gKSW5kZXg6IFBlcmZvcm1h bmNlVGVzdHMvTGF5b3V0L2ZsZXhib3gtY29sdW1uLW5vd3JhcC5odG1sCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFBlcmZvcm1hbmNlVGVzdHMvTGF5b3V0L2ZsZXhib3gtY29sdW1uLW5vd3JhcC5odG1sCShyZXZp c2lvbiAxMTY4MjEpCisrKyBQZXJmb3JtYW5jZVRlc3RzL0xheW91dC9mbGV4Ym94LWNvbHVtbi1u b3dyYXAuaHRtbAkod29ya2luZyBjb3B5KQpAQCAtMjgsOCArMjgsOCBAQCBmdW5jdGlvbiBydW5U ZXN0KCkKICAgICBkb2N1bWVudC5ib2R5LmNsaWVudEhlaWdodDsKIH0KIAotUGVyZlRlc3RSdW5u ZXIucnVuKHJ1blRlc3QsIDE4MCwgMjAsIGZ1bmN0aW9uKCkgeworUGVyZlRlc3RSdW5uZXIucnVu UGVyU2Vjb25kKHtydW46IHJ1blRlc3QsIGRvbmU6IGZ1bmN0aW9uKCkgewogICAgIGRvY3VtZW50 LmdldEVsZW1lbnRCeUlkKCJmbGV4Ym94Iikuc3R5bGUuZGlzcGxheSA9ICdub25lJzsKLX0pOwor fX0pOwogPC9zY3JpcHQ+CiA8L2h0bWw+CkluZGV4OiBQZXJmb3JtYW5jZVRlc3RzL0xheW91dC9m bGV4Ym94LWNvbHVtbi13cmFwLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gUGVyZm9ybWFuY2VUZXN0cy9M YXlvdXQvZmxleGJveC1jb2x1bW4td3JhcC5odG1sCShyZXZpc2lvbiAxMTY4MjEpCisrKyBQZXJm b3JtYW5jZVRlc3RzL0xheW91dC9mbGV4Ym94LWNvbHVtbi13cmFwLmh0bWwJKHdvcmtpbmcgY29w eSkKQEAgLTI4LDggKzI4LDggQEAgZnVuY3Rpb24gcnVuVGVzdCgpCiAgICAgZG9jdW1lbnQuYm9k eS5jbGllbnRIZWlnaHQ7CiB9CiAKLVBlcmZUZXN0UnVubmVyLnJ1bihydW5UZXN0LCAxODAsIDIw LCBmdW5jdGlvbigpIHsKK1BlcmZUZXN0UnVubmVyLnJ1blBlclNlY29uZCh7cnVuOiBydW5UZXN0 LCBkb25lOmZ1bmN0aW9uKCkgewogICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJmbGV4Ym94 Iikuc3R5bGUuZGlzcGxheSA9ICdub25lJzsKLX0pOworfX0pOwogPC9zY3JpcHQ+CiA8L2h0bWw+ CkluZGV4OiBQZXJmb3JtYW5jZVRlc3RzL0xheW91dC9mbGV4Ym94LXJvdy1ub3dyYXAuaHRtbAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBQZXJmb3JtYW5jZVRlc3RzL0xheW91dC9mbGV4Ym94LXJvdy1ub3dyYXAu aHRtbAkocmV2aXNpb24gMTE2ODIxKQorKysgUGVyZm9ybWFuY2VUZXN0cy9MYXlvdXQvZmxleGJv eC1yb3ctbm93cmFwLmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTI4LDggKzI4LDggQEAgZnVuY3Rp b24gcnVuVGVzdCgpCiAgICAgZG9jdW1lbnQuYm9keS5jbGllbnRIZWlnaHQ7CiB9CiAKLVBlcmZU ZXN0UnVubmVyLnJ1bihydW5UZXN0LCAxMDAsIDIwLCBmdW5jdGlvbigpIHsKK1BlcmZUZXN0UnVu bmVyLnJ1blBlclNlY29uZCh7cnVuOnJ1blRlc3QsIGRvbmU6ZnVuY3Rpb24oKSB7CiAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoImZsZXhib3giKS5zdHlsZS5kaXNwbGF5ID0gJ25vbmUnOwot fSk7Cit9fSk7CiA8L3NjcmlwdD4KIDwvaHRtbD4KSW5kZXg6IFBlcmZvcm1hbmNlVGVzdHMvTGF5 b3V0L2ZsZXhib3gtcm93LXdyYXAuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBQZXJmb3JtYW5jZVRlc3Rz L0xheW91dC9mbGV4Ym94LXJvdy13cmFwLmh0bWwJKHJldmlzaW9uIDExNjgyMSkKKysrIFBlcmZv cm1hbmNlVGVzdHMvTGF5b3V0L2ZsZXhib3gtcm93LXdyYXAuaHRtbAkod29ya2luZyBjb3B5KQpA QCAtMjgsOCArMjgsOCBAQCBmdW5jdGlvbiBydW5UZXN0KCkKICAgICBkb2N1bWVudC5ib2R5LmNs aWVudEhlaWdodDsKIH0KIAotUGVyZlRlc3RSdW5uZXIucnVuKHJ1blRlc3QsIDEwMCwgMjAsIGZ1 bmN0aW9uKCkgeworUGVyZlRlc3RSdW5uZXIucnVuUGVyU2Vjb25kKHtydW46IHJ1blRlc3QsIGRv bmU6ZnVuY3Rpb24oKSB7CiAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImZsZXhib3giKS5z dHlsZS5kaXNwbGF5ID0gJ25vbmUnOwotfSk7Cit9fSk7CiA8L3NjcmlwdD4KIDwvaHRtbD4KSW5k ZXg6IFBlcmZvcm1hbmNlVGVzdHMvcmVzb3VyY2VzL3J1bm5lci5qcwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBQ ZXJmb3JtYW5jZVRlc3RzL3Jlc291cmNlcy9ydW5uZXIuanMJKHJldmlzaW9uIDExNjgyMSkKKysr IFBlcmZvcm1hbmNlVGVzdHMvcmVzb3VyY2VzL3J1bm5lci5qcwkod29ya2luZyBjb3B5KQpAQCAt NDksNyArNDksNyBAQCBQZXJmVGVzdFJ1bm5lci5sb2FkRmlsZSA9IGZ1bmN0aW9uIChwYXRoCiAg ICAgcmV0dXJuIHhoci5yZXNwb25zZVRleHQ7CiB9CiAKLVBlcmZUZXN0UnVubmVyLmNvbXB1dGVT dGF0aXN0aWNzID0gZnVuY3Rpb24gKHRpbWVzKSB7CitQZXJmVGVzdFJ1bm5lci5jb21wdXRlU3Rh dGlzdGljcyA9IGZ1bmN0aW9uICh0aW1lcywgdW5pdCkgewogICAgIHZhciBkYXRhID0gdGltZXMu c2xpY2UoKTsKIAogICAgIC8vIEFkZCB2YWx1ZXMgZnJvbSB0aGUgc21hbGxlc3QgdG8gdGhlIGxh cmdlc3QgdG8gYXZvaWQgdGhlIGxvc3Mgb2Ygc2lnbmlmaWNhbmNlCkBAIC03NiwxNCArNzYsMTQg QEAgUGVyZlRlc3RSdW5uZXIuY29tcHV0ZVN0YXRpc3RpY3MgPSBmdW5jdAogICAgIH0KICAgICBy ZXN1bHQudmFyaWFuY2UgPSBzcXVhcmVTdW0gLyBkYXRhLmxlbmd0aDsKICAgICByZXN1bHQuc3Rk ZXYgPSBNYXRoLnNxcnQocmVzdWx0LnZhcmlhbmNlKTsKLSAgICByZXN1bHQudW5pdCA9ICJtcyI7 CisgICAgcmVzdWx0LnVuaXQgPSB1bml0IHx8ICJtcyI7CiAKICAgICByZXR1cm4gcmVzdWx0Owog fQogCiBQZXJmVGVzdFJ1bm5lci5sb2dTdGF0aXN0aWNzID0gZnVuY3Rpb24gKHRpbWVzKSB7CiAg ICAgdGhpcy5sb2coIiIpOwotICAgIHZhciBzdGF0aXN0aWNzID0gdGhpcy5jb21wdXRlU3RhdGlz dGljcyh0aW1lcyk7CisgICAgdmFyIHN0YXRpc3RpY3MgPSB0aGlzLmNvbXB1dGVTdGF0aXN0aWNz KHRpbWVzLCB0aGlzLnVuaXQpOwogICAgIHRoaXMucHJpbnRTdGF0aXN0aWNzKHN0YXRpc3RpY3Mp OwogfQogCkBAIC0xMTcsNyArMTE3LDcgQEAgUGVyZlRlc3RSdW5uZXIuX3J1bkxvb3AgPSBmdW5j dGlvbiAoKSB7CiAgICAgICAgIHRoaXMuZ2MoKTsKICAgICAgICAgd2luZG93LnNldFRpbWVvdXQo ZnVuY3Rpb24gKCkgeyBQZXJmVGVzdFJ1bm5lci5fcnVubmVyKCk7IH0sIDApOwogICAgIH0gZWxz ZSB7Ci0gICAgICAgIHRoaXMubG9nU3RhdGlzdGljcyh0aGlzLl90aW1lcyk7CisgICAgICAgIHRo aXMubG9nU3RhdGlzdGljcyh0aGlzLl9yZXN1bHRzKTsKICAgICAgICAgdGhpcy5fZG9uZUZ1bmN0 aW9uKCk7CiAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCiAgICAgICAg ICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CkBAIC0xNDQsNyArMTQ0LDcg QEAgUGVyZlRlc3RSdW5uZXIuX3J1bm5lciA9IGZ1bmN0aW9uICgpIHsKICAgICBpZiAodGhpcy5f Y29tcGxldGVkUnVucyA8PSAwKQogICAgICAgICB0aGlzLmxvZygiSWdub3Jpbmcgd2FybS11cCBy dW4gKCIgKyB0aW1lICsgIikiKTsKICAgICBlbHNlIHsKLSAgICAgICAgdGhpcy5fdGltZXMucHVz aCh0aW1lKTsKKyAgICAgICAgdGhpcy5fcmVzdWx0cy5wdXNoKHRpbWUpOwogICAgICAgICB0aGlz LmxvZyh0aW1lKTsKICAgICB9CiAgICAgdGhpcy5fcnVuTG9vcCgpOwpAQCAtMTU3LDEyICsxNTcs NjEgQEAgUGVyZlRlc3RSdW5uZXIucnVuID0gZnVuY3Rpb24gKHJ1bkZ1bmN0aQogICAgIHRoaXMu X2RvbmVGdW5jdGlvbiA9IGRvbmVGdW5jdGlvbiB8fCBmdW5jdGlvbiAoKSB7fTsKICAgICB0aGlz Ll9jb21wbGV0ZWRSdW5zID0gLTE7CiAgICAgdGhpcy5jdXN0b21SdW5GdW5jdGlvbiA9IG51bGw7 Ci0gICAgdGhpcy5fdGltZXMgPSBbXTsKKyAgICB0aGlzLnVuaXQgPSAnbXMnOworICAgIHRoaXMu X3Jlc3VsdHMgPSBbXTsKIAogICAgIHRoaXMubG9nKCJSdW5uaW5nICIgKyB0aGlzLl9ydW5Db3Vu dCArICIgdGltZXMiKTsKICAgICB0aGlzLl9ydW5Mb29wKCk7CiB9CiAKK1BlcmZUZXN0UnVubmVy LnJ1blBlclNlY29uZCA9IGZ1bmN0aW9uICh0ZXN0KSB7CisgICAgdGhpcy5fcnVuQ291bnQgPSB0 ZXN0LnJ1bkNvdW50IHx8IDIxOworICAgIHRoaXMuX2RvbmVGdW5jdGlvbiA9IGZ1bmN0aW9uICgp IHsgaWYgKHRlc3QuZG9uZSkgdGVzdC5kb25lKCk7IH07CisgICAgdGhpcy5fY29tcGxldGVkUnVu cyA9IDA7CisgICAgdGhpcy5fY2FsbHNQZXJJdGVyYXRpb24gPSAxOworICAgIHRoaXMuY3VzdG9t UnVuRnVuY3Rpb24gPSBudWxsOworICAgIHRoaXMudW5pdCA9ICdydW5zL3MnOworICAgIHRoaXMu X3Jlc3VsdHMgPSBbXTsKKworICAgIHRoaXMuX3Rlc3QgPSB0ZXN0OworICAgIHRoaXMuX3J1bm5l ciA9IHRoaXMuX3BlclNlY29uZFJ1bm5lcjsKKyAgICB0aGlzLmxvZygiUnVubmluZyAiICsgdGhp cy5fcnVuQ291bnQgKyAiIHRpbWVzIik7CisgICAgdGhpcy5fcnVuTG9vcCgpOworfQorCitQZXJm VGVzdFJ1bm5lci5fcGVyU2Vjb25kUnVubmVyID0gZnVuY3Rpb24gKCkgeworICAgIHZhciB0aW1l VG9SdW4gPSB0aGlzLl90ZXN0LnRpbWVUb1J1biB8fCA3NTA7CisgICAgdmFyIHRvdGFsVGltZSA9 IDA7CisgICAgdmFyIGkgPSAwOworICAgIHZhciBjYWxsc1Blckl0ZXJhdGlvbiA9IHRoaXMuX2Nh bGxzUGVySXRlcmF0aW9uOworCisgICAgaWYgKHRoaXMuX3Rlc3Quc2V0dXApCisgICAgICAgIHRo aXMuX3Rlc3Quc2V0dXAoKTsKKworICAgIHdoaWxlICh0b3RhbFRpbWUgPCB0aW1lVG9SdW4pIHsK KyAgICAgICAgdG90YWxUaW1lICs9IHRoaXMuX3BlclNlY29uZFJ1bm5lckl0ZXJhdG9yKGNhbGxz UGVySXRlcmF0aW9uKTsKKyAgICAgICAgaSArPSBjYWxsc1Blckl0ZXJhdGlvbjsKKyAgICAgICAg aWYgKHRoaXMuX2NvbXBsZXRlZFJ1bnMgPD0gMCAmJiB0b3RhbFRpbWUgPCAxMDApCisgICAgICAg ICAgICBjYWxsc1Blckl0ZXJhdGlvbiA9IE1hdGgubWF4KDEwLCAyICogY2FsbHNQZXJJdGVyYXRp b24pOworICAgIH0KKworICAgIHZhciBydW5zUGVyU2Vjb25kID0gaSAqIDEwMDAgLyB0b3RhbFRp bWU7CisgICAgdGhpcy5sb2cocnVuc1BlclNlY29uZCArICcgcnVucy9zJyk7CisKKyAgICB0aGlz Ll9yZXN1bHRzLnB1c2gocnVuc1BlclNlY29uZCk7CisgICAgdGhpcy5fY2FsbHNQZXJJdGVyYXRp b24gPSBjYWxsc1Blckl0ZXJhdGlvbjsKKworICAgIHRoaXMuX2NvbXBsZXRlZFJ1bnMrKzsKKyAg ICB0aGlzLl9ydW5Mb29wKCk7Cit9CisKK1BlcmZUZXN0UnVubmVyLl9wZXJTZWNvbmRSdW5uZXJJ dGVyYXRvciA9IGZ1bmN0aW9uIChjYWxsc1Blckl0ZXJhdGlvbikgeworICAgIHZhciBzdGFydFRp bWUgPSBuZXcgRGF0ZSgpOworICAgIGZvciAodmFyIGkgPSAwOyBpIDwgY2FsbHNQZXJJdGVyYXRp b247IGkrKykKKyAgICAgICAgdGhpcy5fdGVzdC5ydW4oKTsKKyAgICByZXR1cm4gbmV3IERhdGUo KSAtIHN0YXJ0VGltZTsKK30KKwogaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikgewog ICAgIGxheW91dFRlc3RDb250cm9sbGVyLndhaXRVbnRpbERvbmUoKTsKICAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CkluZGV4OiBUb29scy9DaGFuZ2VMb2cKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gVG9vbHMvQ2hhbmdlTG9nCShyZXZpc2lvbiAxMTY4MzkpCisrKyBUb29scy9DaGFuZ2VM b2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNSBAQAorMjAxMi0wNS0xMSAgUnlvc3VrZSBO aXdhICA8cm5pd2FAd2Via2l0Lm9yZz4KKworICAgICAgICBwZXJmb3JtYW5jZSB0ZXN0cyBzaG91 bGQgYmUgYWJsZSB0byBtZWFzdXJlIHJ1bnMvc2VjIHJhdGhlciB0aGFuIHRpbWUKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg2MDIxCisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWxsb3cgIiBydW5zL3MiIG9y ICIgbXMiIHRvIGFwcGVhciBhZnRlciBudW1lcmljYWwgdmFsdWVzIGluIHRlc3RzLgorCisgICAg ICAgICogU2NyaXB0cy93ZWJraXRweS9wZXJmb3JtYW5jZV90ZXN0cy9wZXJmdGVzdC5weToKKyAg ICAgICAgKFBlcmZUZXN0KToKKwogMjAxMi0wNS0xMSAgT2phbiBWYWZhaSAgPG9qYW5AY2hyb21p dW0ub3JnPgogCiAgICAgICAgIEFkZCBwcmV2aW91cy9uZXh0IGJ1dHRvbnMgdGhlIGdhcmRlbi1v LW1hdGljcyBwZXJmIHBhbmVsCkluZGV4OiBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BlcmZvcm1h bmNlX3Rlc3RzL3BlcmZ0ZXN0LnB5Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvcGVyZm9ybWFuY2VfdGVzdHMvcGVyZnRlc3QucHkJKHJldmlzaW9uIDExNjgyMSkKKysrIFRv b2xzL1NjcmlwdHMvd2Via2l0cHkvcGVyZm9ybWFuY2VfdGVzdHMvcGVyZnRlc3QucHkJKHdvcmtp bmcgY29weSkKQEAgLTc0LDcgKzc0LDcgQEAgY2xhc3MgUGVyZlRlc3Qob2JqZWN0KToKICAgICAg ICAgcmUuY29tcGlsZShyJ15SdW5uaW5nIFxkKyB0aW1lcyQnKSwKICAgICAgICAgcmUuY29tcGls ZShyJ15JZ25vcmluZyB3YXJtLXVwICcpLAogICAgICAgICByZS5jb21waWxlKHInXkluZm86Jyks Ci0gICAgICAgIHJlLmNvbXBpbGUocideXGQrKC5cZCspPyQnKSwKKyAgICAgICAgcmUuY29tcGls ZShyJ15cZCsoLlxkKyk/KFxzKihydW5zXC9zfG1zKSk/JCcpLAogICAgICAgICAjIEZvbGxvd2lu ZyBhcmUgZm9yIGhhbmRsZSBleGlzdGluZyB0ZXN0IGxpa2UgRHJvbWFlbwogICAgICAgICByZS5j b21waWxlKHJlLmVzY2FwZSgiIiJtYWluIGZyYW1lIC0gaGFzIDEgb251bmxvYWQgaGFuZGxlcihz KSIiIikpLAogICAgICAgICByZS5jb21waWxlKHJlLmVzY2FwZSgiIiJmcmFtZSAiPCEtLWZyYW1l UGF0aCAvLzwhLS1mcmFtZTAtLT4tLT4iIC0gaGFzIDEgb251bmxvYWQgaGFuZGxlcihzKSIiIikp LApJbmRleDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3Rz L0NoYW5nZUxvZwkocmV2aXNpb24gMTE2ODM5KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3 b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTItMDUtMTEgIFJ5b3N1a2UgTml3YSAg PHJuaXdhQHdlYmtpdC5vcmc+CisKKyAgICAgICAgcGVyZm9ybWFuY2UgdGVzdHMgc2hvdWxkIGJl IGFibGUgdG8gbWVhc3VyZSBydW5zL3NlYyByYXRoZXIgdGhhbiB0aW1lCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NjAyMQorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCB0ZXN0cyBmb3IgUGVyZlRlc3RS dW5uZXIucnVuUGVyU2Vjb25kLgorCisgICAgICAgICogZmFzdC9oYXJuZXNzL3BlcmZ0ZXN0cy9y dW5zLXBlci1zZWNvbmQtaXRlcmF0aW9ucy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAq IGZhc3QvaGFybmVzcy9wZXJmdGVzdHMvcnVucy1wZXItc2Vjb25kLWl0ZXJhdGlvbnMuaHRtbDog QWRkZWQuCisgICAgICAgICogZmFzdC9oYXJuZXNzL3BlcmZ0ZXN0cy9ydW5zLXBlci1zZWNvbmQt bG9nLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9oYXJuZXNzL3BlcmZ0ZXN0 cy9ydW5zLXBlci1zZWNvbmQtbG9nLmh0bWw6IEFkZGVkLgorCiAyMDEyLTA1LTExICBOb2VsIEdv cmRvbiAgPG5vZWwuZ29yZG9uQGdtYWlsLmNvbT4KIAogICAgICAgICBPcHRpbWlzZSBhbmQgdXBk YXRlIHRlc3QgZXhwZWN0YXRpb25zIGFmdGVyIHIxMTY2MzYKSW5kZXg6IExheW91dFRlc3RzL2Zh c3QvaGFybmVzcy9wZXJmdGVzdHMvcnVucy1wZXItc2Vjb25kLWl0ZXJhdGlvbnMtZXhwZWN0ZWQu dHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvaGFybmVzcy9wZXJmdGVzdHMvcnVu cy1wZXItc2Vjb25kLWl0ZXJhdGlvbnMtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5 b3V0VGVzdHMvZmFzdC9oYXJuZXNzL3BlcmZ0ZXN0cy9ydW5zLXBlci1zZWNvbmQtaXRlcmF0aW9u cy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTUgQEAKK1RoaXMgdGVzdCB2 ZXJpZmllcyBQZXJmVGVzdFJ1bm5lci5ydW5QZXJTZWNvbmQoKSBjYWxscyBydW5GdW5jdGlvbiBh cyBtYW55IHRpbWVzIGFzIGV4cGVjdGVkLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBz ZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisK K1JldHVybmluZyB0aW1lczogWzAsIDEwLCAzMCwgNjAsIDEwMCwgMTAwLCAxMDAsIDEwMF0KK1BB U1MgY2FsbHNJbkl0ZXJhdGlvbnNbMF0gaXMgMQorUEFTUyBjYWxsc0luSXRlcmF0aW9uc1sxXSBp cyAxMAorUEFTUyBjYWxsc0luSXRlcmF0aW9uc1sxXSArIDUgPCBjYWxsc0luSXRlcmF0aW9uc1sy XSBpcyB0cnVlCitQQVNTIGNhbGxzSW5JdGVyYXRpb25zWzJdICsgMTAgPCBjYWxsc0luSXRlcmF0 aW9uc1szXSBpcyB0cnVlCitQQVNTIGNhbGxzSW5JdGVyYXRpb25zWzNdIGlzIGNhbGxzSW5JdGVy YXRpb25zWzRdCitQQVNTIGNhbGxzSW5JdGVyYXRpb25zWzRdIGlzIGNhbGxzSW5JdGVyYXRpb25z WzVdCitQQVNTIGNhbGxzSW5JdGVyYXRpb25zWzVdIGlzIGNhbGxzSW5JdGVyYXRpb25zWzZdCitQ QVNTIGNhbGxzSW5JdGVyYXRpb25zWzZdIGlzIGNhbGxzSW5JdGVyYXRpb25zWzddCitQQVNTIGNh bGxzSW5JdGVyYXRpb25zWzhdIGlzIHVuZGVmaW5lZC4KKwpJbmRleDogTGF5b3V0VGVzdHMvZmFz dC9oYXJuZXNzL3BlcmZ0ZXN0cy9ydW5zLXBlci1zZWNvbmQtaXRlcmF0aW9ucy5odG1sCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvaGFybmVzcy9wZXJmdGVzdHMvcnVucy1wZXItc2Vj b25kLWl0ZXJhdGlvbnMuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvaGFy bmVzcy9wZXJmdGVzdHMvcnVucy1wZXItc2Vjb25kLWl0ZXJhdGlvbnMuaHRtbAkocmV2aXNpb24g MCkKQEAgLTAsMCArMSw0NiBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxib2R5PgorPGRp diBpZD0iZGVzY3JpcHRpb24iPjwvZGl2PgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8c2Ny aXB0IHNyYz0iLi4vLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2Ny aXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uLy4uLy4uL1BlcmZvcm1hbmNlVGVzdHMvcmVzb3VyY2Vz L3J1bm5lci5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+CisK K2Rlc2NyaXB0aW9uKCJUaGlzIHRlc3QgdmVyaWZpZXMgUGVyZlRlc3RSdW5uZXIucnVuUGVyU2Vj b25kKCkgY2FsbHMgcnVuRnVuY3Rpb24gYXMgbWFueSB0aW1lcyBhcyBleHBlY3RlZC4iKTsKKwor dmFyIGl0ZXJhdGlvbiA9IDA7CisKK3ZhciBjYWxsc0luSXRlcmF0aW9ucyA9IFtdOwordmFyIHRp bWVzSW5JdGVyYXRpb25zID0gWzAsIDEwLCAzMCwgNjAsIDEwMCwgMTAwLCAxMDAsIDEwMF07Cit2 YXIgbG9nTGluZXMgPSBbXTsKKworUGVyZlRlc3RSdW5uZXIubG9nID0gZnVuY3Rpb24gKGxpbmUp IHsgbG9nTGluZXMucHVzaChsaW5lKTsgfQorUGVyZlRlc3RSdW5uZXIuX3BlclNlY29uZFJ1bm5l ckl0ZXJhdG9yID0gZnVuY3Rpb24gKGNhbGxzUGVySXRlcmF0aW9uKSB7CisgICAgY2FsbHNJbkl0 ZXJhdGlvbnNbaXRlcmF0aW9uXSA9IGNhbGxzUGVySXRlcmF0aW9uOworICAgIHJldHVybiB0aW1l c0luSXRlcmF0aW9uc1tpdGVyYXRpb24rK107Cit9CisKK1BlcmZUZXN0UnVubmVyLnJ1blBlclNl Y29uZCh7CisgICAgcnVuOiBmdW5jdGlvbiAoKSB7IH0sCisgICAgcnVuQ291bnQ6IDEsCisgICAg dGltZVRvUnVuOiA1MDAsCisgICAgZG9uZTogZnVuY3Rpb24gKCkgeworICAgICAgICBkZWJ1Zygi UmV0dXJuaW5nIHRpbWVzOiBbIiArIHRpbWVzSW5JdGVyYXRpb25zLmpvaW4oIiwgIikgKyAiXSIp OworICAgICAgICBzaG91bGRFdmFsdWF0ZVRvKCJjYWxsc0luSXRlcmF0aW9uc1swXSIsIDEpOwor ICAgICAgICBzaG91bGRFdmFsdWF0ZVRvKCJjYWxsc0luSXRlcmF0aW9uc1sxXSIsIDEwKTsKKyAg ICAgICAgc2hvdWxkQmVUcnVlKCJjYWxsc0luSXRlcmF0aW9uc1sxXSArIDUgPCBjYWxsc0luSXRl cmF0aW9uc1syXSIpOworICAgICAgICBzaG91bGRCZVRydWUoImNhbGxzSW5JdGVyYXRpb25zWzJd ICsgMTAgPCBjYWxsc0luSXRlcmF0aW9uc1szXSIpOworICAgICAgICBzaG91bGRCZSgiY2FsbHNJ bkl0ZXJhdGlvbnNbM10iLCAiY2FsbHNJbkl0ZXJhdGlvbnNbNF0iKTsKKyAgICAgICAgc2hvdWxk QmUoImNhbGxzSW5JdGVyYXRpb25zWzRdIiwgImNhbGxzSW5JdGVyYXRpb25zWzVdIik7CisgICAg ICAgIHNob3VsZEJlKCJjYWxsc0luSXRlcmF0aW9uc1s1XSIsICJjYWxsc0luSXRlcmF0aW9uc1s2 XSIpOworICAgICAgICBzaG91bGRCZSgiY2FsbHNJbkl0ZXJhdGlvbnNbNl0iLCAiY2FsbHNJbkl0 ZXJhdGlvbnNbN10iKTsKKyAgICAgICAgc2hvdWxkQmVVbmRlZmluZWQoImNhbGxzSW5JdGVyYXRp b25zWzhdIik7CisgICAgfX0pOworCit2YXIganNUZXN0SXNBc3luYyA9IHRydWU7CisKKzwvc2Ny aXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9z dC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0 L2hhcm5lc3MvcGVyZnRlc3RzL3J1bnMtcGVyLXNlY29uZC1sb2ctZXhwZWN0ZWQudHh0Cj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvaGFybmVzcy9wZXJmdGVzdHMvcnVucy1wZXItc2Vj b25kLWxvZy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9mYXN0L2hh cm5lc3MvcGVyZnRlc3RzL3J1bnMtcGVyLXNlY29uZC1sb2ctZXhwZWN0ZWQudHh0CShyZXZpc2lv biAwKQpAQCAtMCwwICsxLDE2IEBACitUaGlzIHRlc3QgdmVyaWZpZXMgUGVyZlRlc3RSdW5uZXIu cnVuUGVyU2Vjb25kKCkgb3V0cHV0cyBsb2cgYXMgZXhwZWN0ZWQuCisKK1J1bm5pbmcgNSB0aW1l cworMSBydW5zL3MKKzIgcnVucy9zCiszIHJ1bnMvcworNCBydW5zL3MKKzUgcnVucy9zCisKKwor YXZnIDMgcnVucy9zCittZWRpYW4gMyBydW5zL3MKK3N0ZGV2IDEuNDEgcnVucy9zCittaW4gMSBy dW5zL3MKK21heCA1IHJ1bnMvcworCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2hhcm5lc3MvcGVy ZnRlc3RzL3J1bnMtcGVyLXNlY29uZC1sb2cuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9mYXN0L2hhcm5lc3MvcGVyZnRlc3RzL3J1bnMtcGVyLXNlY29uZC1sb2cuaHRtbAkocmV2aXNp b24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvaGFybmVzcy9wZXJmdGVzdHMvcnVucy1wZXItc2Vj b25kLWxvZy5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDMxIEBACis8IURPQ1RZUEUgaHRt bD4KKzxodG1sPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRpb24iPlRoaXMgdGVzdCB2ZXJpZmll cyBQZXJmVGVzdFJ1bm5lci5ydW5QZXJTZWNvbmQoKSBvdXRwdXRzIGxvZyBhcyBleHBlY3RlZC48 L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQgc3JjPSIuLi8uLi8uLi8uLi9Q ZXJmb3JtYW5jZVRlc3RzL3Jlc291cmNlcy9ydW5uZXIuanMiPjwvc2NyaXB0PgorPHNjcmlwdCB0 eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorCit2YXIgbG9nTGluZXMgPSBbXTsKK1BlcmZUZXN0UnVu bmVyLnRpbWVUb1J1biA9IDUwMDsKK3ZhciBydW5zID0gMDsKKworUGVyZlRlc3RSdW5uZXIuX3Bl clNlY29uZFJ1bm5lckl0ZXJhdG9yID0gZnVuY3Rpb24gKGNhbGxzUGVySXRlcmF0aW9uKSB7Cisg ICAgcmV0dXJuIDEwMDAgLyBydW5zOworfQorCit2YXIgcHJpbnRTdGF0aXN0aWNzID0gUGVyZlRl c3RSdW5uZXIucHJpbnRTdGF0aXN0aWNzOworUGVyZlRlc3RSdW5uZXIucHJpbnRTdGF0aXN0aWNz ID0gZnVuY3Rpb24gKHN0YXRpc3RpY3MpIHsKKyAgICBzdGF0aXN0aWNzLnN0ZGV2ID0gc3RhdGlz dGljcy5zdGRldi50b1ByZWNpc2lvbigzKTsKKyAgICByZXR1cm4gcHJpbnRTdGF0aXN0aWNzLmNh bGwoUGVyZlRlc3RSdW5uZXIsIHN0YXRpc3RpY3MpOworfQorCitQZXJmVGVzdFJ1bm5lci5ydW5Q ZXJTZWNvbmQoeworICAgIHNldHVwOiBmdW5jdGlvbiAoKSB7IHJ1bnMrKzsgfSwKKyAgICBydW46 IGZ1bmN0aW9uICgpIHsgfSwKKyAgICBydW5Db3VudDogNQorfSk7CisKKzwvc2NyaXB0PgorPC9i b2R5PgorPC9odG1sPgo= 141617 2012-05-13 16:58:36 -0700 2012-05-13 16:58:50 -0700 Flebox Perf. Test Experiment - function call per iteration is adjusted adjusted-calls-per-iteration.png image/png 0 rniwa 141618 2012-05-13 16:59:08 -0700 2012-05-13 16:59:08 -0700 Flebox Perf. Test Experiment - function call per iteration is 1 constant-calls-per-iteration.png image/png 12155 rniwa iVBORw0KGgoAAAANSUhEUgAAAqUAAAIoCAIAAADflAVjAAAACXBIWXMAAAsTAAALEwEAmpwYAAAK T2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUIIFJCi4AU kSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuja9a89+bN/rXX Pues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMBAPh+PDwrIsAHvgAB eNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCdmCZTAKAEAGDLY2LjAFAt AGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgwABRmS8Q5ANgtADBJV2ZIALC3 AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88SuuEOcqAAB4mbI8uSQ5RYFbCC1xB1dX Lh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHgg/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+ 5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgugdfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk 5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7iJIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd 0yLESWK5WCoU41EScY5EmozzMqUiiUKSKcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA 4vcAAPK7b8HUKAgDgGiD4c93/+8//UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzA BhzBBdzBC/xgNoRCJMTCQhBCCmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/ph CJ7BKLyBCQRByAgTYSHaiAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5 h1xGupE7yAAygvyGvEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+ Q8cwwOgYBzPEbDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhM WE7YSKggHCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQ AkmxpFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+Io UspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgXaPdp r+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1QwNzHrmOeZ D5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnUlqtVqp1Q61Mb U2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1gTXEJrHN2Xx2KruY /R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIpG6Y0TLkxZVxrqpaXllir SKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acKpxZNPTr1ri6qa6UbobtEd79u p+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsMzhg8xTVxbzwdL8fb8VFDXcNAQ6Vh lWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZLTepN7ppSTbmmKaY7TDtMx83MzaLN1pk1 mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnutrxuhVo5WaVYVVpds0atna0l1rutu6cRp7lO k06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFnYhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7Ry FDpWOt6azpzuP33F9JbpL2dYzxDP2DPjthPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3I veRKdPVxXeF60vWdm7Obwu2o26/uNu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+B Z7XnIy9jL5FXrdewt6V3qvdh7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/ 0QCngCUBZwOJgUGBWwL7+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5p DoVQfujW0Adh5mGLw34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5q PNo3ujS6P8YuZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIs OpZATIhOOJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5 hCepkLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQ rAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0dWOa9 rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWFfevc1+1d T1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebeLZ5bDpaql+aX Dm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ27tLdtWHX+G7R7ht7 vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHtxwPSA/0HIw6217nU1R3S PVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTradox7rOEH0x92HWcdL2pCmvKa RptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLTk2fyz4ydlZ19fi753GDborZ752PO 32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86X23qdOo8/pPTT8e7nLuarrlca7nuer21 e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/XfFt1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfV P1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9DBY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i /suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8 IH8o/2j5sfVT0Kf7kxmTk/8EA5jz/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADq YAAAOpgAABdvkl/FRgAAJKZJREFUeNrs3W1sY+tBJ/Dn3M60t6UvKxW2t1Qwd4s9QsGICpBgbfXq RkgFe1bdaFcEdqh2VlDZ1UqVjaoRm92IqihqtJr9YKMiiKnYzocO2lBVETS21N0lt9CYqlUpUN9I xK7KtHtbLivKwm6ZqvNy9sOxHSdxOjP3xk5y8vtpPjhPzttzfHL+z8uxJ4rjOAAAqXYhhPA7v/M7 L774onMBAOnzpje96Rd/8RcvhBBefPHFpaUlZwQA0md1dTWE8IQTAQCpJ+8BQN4DAPIeAJD3AIC8 BwDkPQAg7wEAeQ8AvLS8b1eiKCo0+nsl/UYhSowXtyvR4dKJhQDAacr7diWKNhZa5f2FN3aW4ziO 41491K4lMd5vFErdem9/6cRCAOCU5X1xLY7XiocKB0W9nU5+8UomhNDfXO+Ul6uZEELIVJfLnfXN /uRCAGDaLhzLVvqNQrbWCSGUW3ES5yGE/Fz28JITCw+7devW7du3947ywoV79+55twAOu3Tp0tWr V50HZpH3mep2XA2DefyN1uERgMd14NpdXV31P/gBwEt2vM/nZ6rL5dDdTQbpOzu9sV/lLmeOLAQA Tn3etyujR+3bG80kxDNXFvPNleGjeyvN/Fz2iEIA4LTlffLJu1IzdGrZ4UfqitcX17PJZ+xK3Xov GczPVG/WQy0bRVGUreVa29XMUYUAwJQ97vz9cKb+4YWPsygAcJr69wCAvAcA5D0AIO8BAHkPAMh7 AEDeA4C8BwDkPQAg7wEAec8JmZ+fj/abn593WgDOjwtOwXmwtbWVvIiiKI5jJwRA/x4AkPcAgLwH AOQ9ACDvOeNm/FkAHz0AkPdC8QRsbW3FcZx8CiB5Mfp0wFnfnbaFvzU4u3we78RCMXnhA3LeNbxr oH+fZp8pv3vrXxT/8MrPbP2L4mfK71a1l7OvZHcpO406poC8T8Pt9c7XXnji4sXk352vvZCmMznL qs34NM6yKWOqAjhGxvP33V6TF8b9+M7Ni9FrFz+gfw8cw1iCqQpA//5se8WTr77/rTuj16rmNJ7s WMJnyu++87UXkqmKV3/vW36y+WHDCSDvU9udSu6qSXdqqve7EMIzH/v4zO53Ka5asq+Z7U7zApD3 7neqln6zbMpoWwPHyPz9yRjNXybhkab5yxlXLcVn8hVPvvrB3bvJv1SOJaTywymgf88+U/3KuXNV tVnubn5+/rnnnkteJy2MZ599dnoHYKoCkPfud6qmlTaV5oWpCpD36Tfj7pSqoW2tAQryHs67WU4f pHuqApD3cHrNcvog3VMVQPB8PgDI+/MlxZ/sAn9rcM4Zz99jSBNS+bc2y68KBnkPcDJ8vyQE4/kA IO8BgDQwng+knK/3AXkPpJ+vCoZgPB8A5D0AIO8BAHnPKeHrzADOOc/rnQu+OhBA/x4AkPcAgLwH AOQ9ACDvAQB5DwDIewBA3gOAvHcKAEDeAwDyHgCQ9wAnyH8WBQn/Xw6QZv6zKNC/BwB5DwDIewBA 3gMA8h4AkPcAgLwHAOQ9ACDvAUDeAwDyHgCQ9wCAvAcA5D0AIO8BgOnmfbsSRVGh0d8r6TcKUWK8 uF2JDpdOLAQATlPetytRtLHQKu8vvLG+2IvjOO7VQ+1aEuP9RqHUrR8onVgIAJyyvC+uxfFa8VDh djUTQgiZy7lhj39zvVNeHpRWl8ud9c3+5EIAYNouHOvW2hvN/GIvk/yQn8seXmJi4WG3bt26ffv2 6McoilZXV71bAIddunTp6tWrzgOzy/t2pdSt99Yyx7CpA9fu6urq0tKSdwsAXppjez6/3yiUQmsw rh9CCKGz0xv7fe5y5shCAOAM5H27EmV3lscn9jNXFvPNleGjeyvN/Fz2iEIA4LTlffLJu1IzdGrZ 4Ufq+o2VZgjN0r7P2WWqN+uhlo2iKMrWcoOO/8RCAGDKHnf+PlPdjquPUHZU8RHLAgCnqH+fZvPz 89F+8/PzTgsA57B/n2ZbW1vJiyiK4jh2QgDQvwcA5D0AIO8BAHmfcp4NBGCWPK93MjwbCID+PQAg 7wEAeQ8AyHsAkPcAgLwHAOQ9ACDvAQB5DwDIewBA3gMA8h4A5D0AIO8BAHkPAMh7AEDeAwDynlNu fn4+2m9+ft5pAZD359c3v3XvR3/2V7/5rXtpqtTW1lYcx3EchxCSF1tbW5oXAPL+/Ib9+z78ubfM PfO+D38uZZGf4ubFLGnKAPJ+ihm8uv7Fi0++dgb7WvrI57/+jTtPPBF9/Rt3lj7y+ZQlRyqHLjRl AHmfng73n+z8TeGXfn0GQVVbmHv9ay7GIX79ay7WFuamnRz/787dD/63v7j45GtnkByGLs5cA9RY Asj7c2TU4X79P7007Q53COGtT73uA+96253/+/cfeNfb3vrU69LUlJnl0EWY7ahMWhugxhJA3p8j ow73P/7D3067wz2K/P/+X/71tMN+9k2ZWQ5dzDIUZ9wJnvG7Bsj78yLpcH/Xqy5+9qNLM8jgFDdl Zjl0MctQnHEnePYN0Jk9dWH6AOT9yUf+rV955h/++kuaMmdl6CLFoTjjd22WT12YPgB5j6aMUDyZ d23GT13MjLEEkPfnyOiWF0JI3y1PKB6LWT51EWb4lKWxBJD358joljcyvVteutsWMw7FGTeb0vqB keALIUDec6bbFukOxdm3nNL6gRFfCAHyHk5vKKa45TTjpyxTPAsD8p7zIt3TByluM83yKcsUz8KA vOe8SPf0Qbojf2ZPWc5yFgbkPRhLULWTbF7MZhYG5D0YS1C1E2hemPGBxAWnAJh98yKV+wL9ewBA 3gMA8h4AkPcAgLwHAHkPAMh7AEDe8/h8BwgAs+T7dk6G7wABQP8eAJD3AIC8BwDkPQDIewBA3gMA 8h4AkPenle/AASCtfN/OHt+BA4D+PQAg7wEAeQ8AyHsAQN4DAPIeAJD3ACDvAQB5DwDIewBA3gMA 8h4AOF15365EUVRo9B9W2K5EA2PlEwsBgNOU9+1KFG0stMoPLew3CqVuvRfHcdyrh9q1Rv+oQgDg lOV9cS2O14oPL+xvrnfKy9VMCCFkqsvlzvpmf3IhADBtF6a36fxc9hELD7t169bt27dHP0ZRtLq6 6t0COOzSpUtXr151HjixvH85Dly7q6urS0tL3i0AeGmm+Hx+Z6c39lPucubIQgDgTOZ95spivrmS PI/Xb6w083PZIwoBgNOW9/1GIYqiUjN0atnRR+omFWaqN+uhlo2iKMrWcq3tauaoQgBgyh53/j5T 3Y6rj1T4OIsCAKepfw8AyHsAQN4DAPIeAJD3AIC8BwDkPQDIewBA3gMA8h4AkPcAgLwHAOQ9ACDv AQB5DwDyHgCQ9wCAvAcA5D0AIO8BAHkPAMh7AEDeA4C8BwDkPQAg7wEAeQ8AyHsAQN4DAPIeAJD3 ACDvAQB5DwDIewBA3gMA8h4AkPcAgLwHAOQ9AMh7AEDeAwDyHgCQ9wCAvAcA5D0AIO8BAHkPAPIe AJD3AIC8B+Ac6jcKURRFhUa/XYkq7cdY83GXf5lmvDt5D0CKtG/Ucq04jrerGSdD3gOQ0t79btdJ kPcApMI3v3Vvdf2L3/zWvQNh3yhka53QLEVRodHf1+uvRAODIfR+ozB8uW9cfTeZDYjGivbWHRQe te74cRzY3eGN7D+4YVm/URgcebsSVRqD7RQa/f7ey4O/nTgrcMQCk+oyPFXtyvjZKTT6oV2JKpXK cOGxWo1X/zsehrwH4GWE/fs+/Lk/2fmb9334c/sjP1Pd7tXzodzaP5zfbxRW5npxHMdx3AqlSjuE kKnerHdLlXZoV0qhtVYcLNpcDzfjOI57yS9D6DcKpW49WXlYeMS6e7u7lkwpxHEcrxWP2MgjGBxM rx5q2ezO8uDljfaB3+abK/sbN+GIBSbW5XKus77ZDyH0d0M+393thxD6m+ud3OVMCCE0u3O9QTUy 1e1BpXr17miXh86YvAfgWCx95PNf/8adJ56Ivv6NO0sf+fzDV+jtdDq1bNIJLTVDkmmD1I5K3fr1 vcQuLyfthMyVxST7ejudYVnIXFnMNzfaE9YddX0LjX7o7XTKC8UDBzBhIw81WCdzORfyyY5GhzX2 2yuL+XDoGCYtMPkwigvlzk4vhP7melhezq1vDio9qMFohfHRgWyt09npHXHG5D0Ax6K2MPf611yM Q/z611ysLcw90jrlYX97/Em+3k7nYesd+TjA/nVHXd/taubwKrN5pmD8GB6nLsWFcnOjHXo7uYVi cSG30wvtjeaBBssg7YejA716/tgOW94DMNlbn3rdB971tu961cUPvOttb33qdQ9fITs3ach7EF+t XO3a3u+Gy7Vv1Dq5y5mkGzxct32jNuj3Tlx3mLuHOvBHbGTcoGfcvlHrTO28HXUYxYVyc6Oy0Z3L hpCd6240druT4j6EEJJB/v7m+t5RHjxjj+uCCxqA7xD5t37lmcfo+bZ2omxUG/X114pJYq9lQrhe X8lea1xJesXl3E42igZLFQ+um6/3tovDtD+07t7ubtYLg60kO5u0kfEe9vX6SjYb1UIot1rl7u4U RwAmHkZxoVwqdeu9TAjhymI3W8u14kkDAdfrK0m1yuXy3sjJYrgWRZ29M/aYojiOV1dXl5aWTvMF d/qPEACmpl2JNhbiteJLWjnJUOP5AJB+xvMB4JQrrsXFl7kJ/XsASD95DwDyHgCQ9wCAvAcA5D0A IO8BAHkPAMh7AEDeA4C8BwDOa963K1EUFfb9T8TtSjQwVv7ohQDAacr7diWKNhZa5fGyfqNQ6tZ7 cRzHvXqoXWv0H6sQADhleV9ciw/+B7z9zfVOebmaCSGETHW53Fnf7D9GIQBnUr9RGAzWtitRpf14 XcfHWv5lmvHuTqnj+f9w83PZl1N42K1bt27fvj36MYqi1dVVf1wAh126dOnq1auz32/7Ri3XireL IYR2xdtwTvL+2B24dldXV5eWlrxbALP0mfK773ztheT1q7/3LT/Z/PB47363G8KCk3RmHM/z+Z2d 3thPucuZxysE4BS687UXnrh4Mfk3Cv4k7BuFbK0TmqVDz17vPZQ9GELvNwrDl/vG1XeT2YBorGhv 3UHhUeuOH8eB3R3eyP6DG5b1G4XBkbcrUaUx2E6h0e/vvTz42wlHsLeZ0K6M17nQ6Id2JapUKsMV x451vFLfYeOnLu8zVxbzzZWkvv3GSjM/l32cQgDOmkx1u1fPh3IrjrermfH0W5nrxXEcx3ErlCrt EEKmerPeLVXaoV0phdboAbDmeriZPLzdTZYbe6B7VHjEunu7u1bLtZLdJY+WTdrIIxgcTK8eatns zvLg5Y32gd+OEmzsRFzODR5F6++GfL672w/JY22D/myzO9cbHFymuj041F69O9rQofNwavI+aZ+U mqFTyw6bP5nqzXqoZaMoirK1XCt57x+9EIB06O10Osk9PopKzZCk3yC1o1K3fn0vsUcPb19ZTFKy tzN6oDvpHW60J6w76iQXGv3Q2+mUF4oHDmDCRh5qsE7mci7kkx2NDmvst1cW8+HQMRQXyp2dXgj9 zfWwvJxb3xxUZXBco6MZH3rI1jqjwe5D5+HU5P1e+ySO95p1Y6V77a9HLwTgFHrFk69+cPdu8u8V T776kdYptw5nROjtdB7am9ztHtmGmBRC29XM4VWO3MhxD26M1a+4UG5utENvJ7dQLC7kdnqhvdE8 0AwZpP3eB9LzJ/Bu+n49ACZ75mMfn/9EO/n3zMc+/vAVsnMThryHQdfKjX/rynC59o1aJ3c5s2/C N7Rv1AY95InrDnP3UAf+iI2MG/Sh2zdqnWM6S8WFcnOjstGdy4aQnetuNHa7k+I+hOFDa/3N9b19 HzwP8h6AUy9T3W7lhgP6gyfQ2pVSt36zmgnF6+Pfs1bO7WSTYf9yMjE/vm6pW++tFY9cd293N+vd 0vjOJm1kPJqvD+eUD35x3MsN/GZ38UomhMyVxW6tlpsY98Xrg4PN7uT29l1eDNf2nYepieI4Pv2f dvN5PABSp12JNhamP7udZKj+PQCk3wWnAABOQnEtnt2T6/r3AJB+8h4A5D0AIO8BAHkPAMh7AEDe AwDyHgCQ9wCAvAcAeQ8AyHsAQN4DkFr9RiGKoqjQ6LcryX8//6ged3nkPQAnpH2jlmvFcbxdzTgZ 8h6As+z+g7t/+MVfv//g7uHe/W7X6ZH3AKRC9yvtL/11p/uVA6Pv/UYhW+uEZimKCo3+vl5/JRoY jNj3G4Xhy33D+LvJbEA0VrS37qDwqHXHVqhUKmMbmbSF4QG2K+PHdOCwQ7sSVRqPdkhHb3D/8fSH m9t3fJP2Iu8BONnO/Re+vBFF0Re+vLG/i5+pbvfq+VBu7R/O7zcKK3O9OI7jOG6FUqUdQshUb9a7 pUo7tCul0ForDhZtroebcRzHveSXIfQbhVK3nqw8LDxi3XHN7lwvjuO14hFbuJzrrG/2Qwj93ZDP d3f7IYT+5nond/nQLMTgkHr1fHOl0Q8vbYNjx5OpbienIu7VuyvD9sWhist7AE68cx/H90KI4vje oS7+JL2dTqeWTXqvpWZIwnCQ2lGpW7++l9jl5aSdkLmymIRmb6czLAuZK4v55kZ7wrqjPvOwkz1a 54gtFBfKnZ1eCP3N9bC8nFvfHOxqoXjUpjJXFvMvaYMHj2dvdCBb63R2ekdUXN4DcLKe/+onv33v zv0Hd799787zX/3kI61TbsUjo65/b6fzsPWOfBxg/7qjPvPhpwSP2EJxodzcaIfeTm6hWFzI7fRC e6NZXih+p029tA0e1K4MRwd69fzJv5vyHoDJrr79Q5V3/F7y7+rbP/TwFbJzw6HwCbnXytWu7f1u uFz7Rq2Tu5xJ+s/Ddds3aoMO88R1JztiC0k+Vza6c9kQsnPdjcZud1I6T2WDySB/f3N9r81ysOIz c8EFDcDxyFS3WztRNqqN+vprxSSx1zIhXK+vZK81riTd6XJuJxtFg6WKB9fN13vbxWHaH1r3UfY+ 2MIgn0ulbr2XCSFcWexma7lW/PjVefwNFq/XV5I6lsvlvQGQxXAtijp7FZ+VKI7j1dXVpaWl03wJ nf4jBICHaVeijYV4rTjbvSYZajwfANLPeD4AzEZxLS6e1L717wEg/eQ9AMh7AEDeAwDyHgCQ9wCA vAcA5D0AIO8BAHkPAPIeAJD3AIC8ByC1+o1CFEVRodFvV6JK+zHWfNzlkfcAnJD2jVquFcfxdjXj ZMh7AM6yL3y6/5vv/4NP/f6f37t7/0Dvfrfr9Mh7AM6+7Xa39dHPvvjC333qE19sffSz42HfKGRr ndAsRVGh0d/X669EA4MR+36jMHy5bxh/N5kNiMaK9tYdFB617tgKlUplbCOTtjA8wHZl/Jj2H/Z3 XGz/XvrD496310rjcHXkPQBnwh+3n793934URXEc/+mnx/MxU93u1fOh3No/nN9vFFbmenEcx3Hc CqVKO4SQqd6sd0uVdmhXSqG1Vhws2lwPN+M4jnvJL0PoNwqlbj1ZeVh4xLrjmt25XhzHa8UjtnA5 11nf7IcQ+rshn+/u9kMI/c31Tu7y+CzEwxYb20umup1UMO7VuyvDVsOh6sh7AM6KuR/9/hBFIYT4 QfyWp9/48BV6O51OLZv0c0vNkMTmILWjUrd+fS+xy8tJOyFzZTGJ195OZ1gWMlcW882N9oR1R73r YXd8tM4RWygulDs7vRD6m+theTm3vjnY1UJx36aOXuzgXvYGEbK1Tmend0R15D0AZ8U7Fn/sB37o zffvPXjjm17/s+955pHWKbfikVHXv7fTedh6Rz4OsH/dUe/68FOCR2yhuFBubrRDbye3UCwu5HZ6 ob3RLC8UD2zqyMUOaleGgwi9ev4svZvyHoDJnnzNK99V+6lf+6/X3vvBhX/y3a99+ArZuXxzpdGf nJCtXO3a3u+Gy7Vv1Dq5y5mkQz5ct32jNuhaT1x3siO2kCR5ZaM7lw0hO9fdaOx2J+X4Iy4WQgjJ IH9/c32vJXKwOqfQBRc0AMcjU91u7UTZqDbq668Vk8Rey4Rwvb6Svda4kvTMy7mdbBQNlioeXDdf 720Xh2l/aN1H2ftgC4MkL5W69V4mhHBlsZut5Vrx5IGAR1rsen0lOfJyubw3rLEYrkVRZ686p08U x/Hq6urS0tJpvoRO/xECcF61K9HGQrxWPK3Hl2So8XwASD/j+QDwchTX4uLpP0r9ewBIP3kPAPIe AJD3AIC8BwDkPQAg7wEAeQ8AyHsAQN4DgLwHAOQ9ACDvAQB5DwDIewBA3gMA8h4AkPcAIO8BAHkP AJynvO83ClGi0OiPStuV6HDpxEIA4LTnfbuSreVacRzHcStXy1bagyZAqVvvxXEc9+qhdq3RP6oQ ADj9ed/f7YbyQjGEEEJxoRy6u/0Q+pvrnfJyNRNCCJnqcrmzvtmfXAgATNuFl7+JzOVcWN/th2Im hJCdy3d2eiFkQ8jPZQ8vPLHwsFu3bt2+fXv0YxRFq6ur3i2Awy5dunT16lXngannfSher69ks1Ft GOn17Mve5IFrd3V1dWlpybsFAC/NsTyvl6luxwOtcshdzoQQQujs9MaWGZROLAQATn/ej7QrpWYy lZ+5sphvriTP4/UbK838XPaIQgDgLOT93qfxSqEVrxUHff6b9VDLRlEUZWu51nY1c1QhADBlxzF/ n6lux9VHLD5iWQDglPfvAQB5DwDIewBA3gMA8h4AkPcAIO8BAHkPAMh7AEDeAwDyHgCQ9wCAvAcA 5D0AIO8BQN4DAPIeAJD3AIC8BwDkPQAg7wEAeQ8AyHsAkPcAgLwHAOQ9ACDvAQB5DwDIewBA3gMA 8h4A5D0AIO8BAHkPAMh7AEDeAwDyHgCQ9wCAvAcAeQ9nwfz8fLTf/Py80wJwwAWngDNta2sreRFF URzHTgiA/j0AyHsAQN5zdpnkBpD37Ln/4O4ffvHX7z+4m7J6bW1txXGcTG8nL0bT3qABCvL+3N2D Sj/3w7sv/HHp53542veg5H73ylddePd//MlXvuqC+x0TL5LxKyRNF4kGKMj7k/Q//ucn/82/z1+4 cOFnfv4H793/9lTvQcn97nN/+fEff+b7PveXH5/B/S4Zurj4yld4o89KK21ra+tzf/nxn5h/ev6d mWmH4uw73DO7II0lgLw/qPuVdhzfCyG6+MoL3a+0p727+w/ufuHLGxcuXPjClzdmMIPQ/Ur7S3/d mX9nxht9VlppyRUSRdHP/PwPTvsKSap27/63f2npJ6bd2J3xBWksAeT9Qc9/9ZPfvnfn/oO7F18V Pf/VT86seRHH96bdvJhlcqR7qmKWrbQZN0CTPf74M983s8bubC7I0R5/aekn0vdoDsj7l+K3f/X5 9/z0x5J/v/DMb0x7/v4Tf/RbSfPi2/fufOKPfmuqoTjL5Ej3VMUsW2kzboBqykC6+X69fUF1gvv6 T/926skRQkiS40eefufMkiP3/cVXPHFx2rfymU1VjM7k/Qd3p30mf/tXn3/uuedGP/5C+I1nn312 elfpgabMVKuW7gsS5D0n5urbP5S8mM2Xzs4yOQ6MDE/7Vp6cydmcxhlPM8+yKZPiCxJOLeP5TCs5 kqmKaQ9Ez3JkePSkdxJUKXs04erbP1R5x++956c/VnnH743yOB1ncpYXJOjfc17Mz8+Pj0KHEH77 2een11Wd5chwip/rHn/Xkhie6tzBjM/kLEdlQN5zXu7mJ3IrdzfXlDklTRmQ97ibg4sfToz5ewCQ 9wCAvAcA5D0AIO8BAHkPAMh7AEDeAwDyHgDkPZx26f4/bACOi+/T5WzzbakA+vcAgLwHAHkPAMh7 AEDeAwDyHgA4S3nfbxSigUKjPyxtVx61EAA47Xnfb1yr5VpxHMdxrx5qN9qDJkCpW+8NC681+kcV AgBnon8/oQ2wud4pL1czIYSQqS6XO+ub/cmFAMC0Hcf362Wq261K8oWmodyK14pJcX4ue3jZiYWH 3bp16/bt26MfoyhaXV31bgEcdunSpatXrzoPTD/vQ2hvNEO+3lveyZZKlYVR4r90B67d1dXVpaUl 7xYAnFzetyul0Iq3iyGEuDdXyFba8Vo2hM5OL4TMcKHc5UwIRxQCAFN1DPP3/d1u6O4OJuJ7O50Q QgiZK4v55kryPF6/sdLMz2WPKAQAzkD/PlO9WV/PZqNa8mO5FRcPlpZbcTVzVCEAcPrzPoRMdTuu Plrp5EUBgGny/XoAIO8BAHkPAMh7AEDeAwDyHgCQ9wCAvAcA5D0AyHsAQN4DAPIeAJD3AIC8BwDk PQAg7wEAeQ8A8h4AkPcAgLwHAOQ9ACDvAQB5DwDIewBA3gOAvAcA5D0AIO8BAHkPAMh7AEDeAwDy HgCQ9wAg7wEAeQ/wUs3Pz0f7zc/POy0g70EopioUt7a24jiO4ziEkLzY2tryjsNUXXAK4NSGYvIi iqIkGgH07wEAef8IzClybq8QVYPUM56/x/Dpcd1en3vuufGSZ599Nh2zsym+QlQN9O/Ply98uv+b 7/+Dt//IO+/dvZ+mPscsdzfjR7H03o73+i+/89c+9ft/Pu3rX9VA//4kbbe7z/3+X9y9e++Zt/3L 1kc/+85/989T0+fQe+MRr/83f8+lT33ii3//jX+c6vWvaqB/f5L+uP38vbv3oyi6ePHin366n7I+ x8yGLk6k65bWqp3I9R/H8Wyuf1UDeX8y5n70+0MUhRDiB/Fbnn7jDPocrY9+NulztD762Rns68UX /i4ZukhZrzStVZtxU2bG13+Kqwby/rR7x+KP/cAPvfn+vQf/++++9rPveSZNfY7ZD13MvuuWvlGZ GTdlRtf/G9/0+mlf/ymuGpxa5u/3PPmaV76r9lMhhCiKfuPj/2EGfY4vbH8phDh+EL/ln313avZ1 IBQLxdyFi69ITdVmORN8oCkz7Vnn5PqfzWMQKa4a6N9zkn2OGQ9dzHKqIsWjMrMchR59zCFp7077 Yw4prhro33OSfY4ZD10cCMWp9t5SPCrzjsUf+4f/84+7f/6//vbvv177z/9qqvua8RckpLhqIO/P gPEvikl6A9P7ophf/uVf/rM/+7PRfkMITz311O/+7u+m40zOfvpg9kH1PW9+w7SHE2bclJl9YzeV VQN5fwbMsh9QrVb/6q/+KoTw/ve/Pyl56qmnhOIpb6UFM8GAvOexPP30008//XQqhy5mHIpGawHk PUIRgBA8nw8A8h4AkPdwnvgkN3B2mb+HR+UxCED/HjhmKR5OMFIC+vek4VY+y8/+pViKT5rrAeQ9 buUAHD/j+QAg7wEAeQ8AyHsAQN4DAPIeAJD3AIC8BwDkPQDIewBA3gMA8h4AkPcAgLwHAE5L3rcr 0T6V9sHyQqN/eOGxQgDgtOd9cS0eaZVDeaEYQug3CqVuvRfHcdyrh9q1Rv+oQgDgDOT9nn5jpTmI +831Tnm5mgkhhEx1udxZ3+xPLgQApu3CcW6sfaMW6r3i4Kf8XPbwIhMLD7t169bt27dHP0ZRtLq6 6t0COOy1r33te9/7XueBmeV9v7HSLC/HmePY1tWrV8d/XF1dXVpaSuUboGqqpmqq9vKrJsx4qOMb z2/fqHWSsfyBzk5v7Ne5y5kjCwGAs5H37Y1mvn59FPeZK4v55kryPF6/sdLMz2WPKAQApu2YxvMP j+Vnqjfr69lsVAshhHIrrmaOKnwEb3jDG9L6BqiaqqmaqqkaMxDFcZziaS0AOOeSlPf9egCQfvIe AOQ9ACDvAQB5DwDIewBA3gMA8h4AkPcAgLwHAHkPAMh7AEDev1ztSjRQSP4X3dToNwoprdl4/Srt dNYrilJXubGKpeeKbFcOVSctt5TDVUv7LYV0532/USh16704juNePdSupekibt9YX0xnzQZv3bX1 xXo5dX8t7Up28L7FcbxWTNUbVsu14uEVeaOdhvcqijYWWuUU3lImVS3ttxRSnvf9zfVOebmaCSGE THW53FnfTM81XFzbHtTsci6Ffftrtdxy9XL66rXSHF6RnP4/sUNNsrTcUiZULeW3FNLfvw8hP5dN +/lvbzTzi1dSFSHtG7VcK02d36HeTic0S6kczs9Ut1shqVp2ZzlO47vnlgKe1zvRP81KqVu/maoe Y7tSCq3U5kW+PhjNb5WbpVQlfnujGfL1XqscUlYxtxQYunCaD66z0wthdOXmLqfrIu43CqXQitP1 p9neaIZmM2oOfmxG3XpvOyVVzM7lR6+LC+WwkbJWWrxdDCHEvblCttJOaR/fLQX9+9Moc2Ux31xJ njvpN1aa6RqJa1fSOXBaXIuHWuVQbsXb6bn5ZC7nhjO+Kbsg+7vd0N0dzGX3djopvdm5pXDexXH8 wQ9+MD6VevVRh6rcilNkrGIhjI0Sp0qS96mrUyovyP1XZCrqtv9vbPgnlopbyqSqnYtbCi9dkvJR HMerq6tLS0uaPgCQPknKe14PANJP3gOAvAcA5D0AIO8BAHkPAMh7AEDeAwDyHgCQ9wAg7wEAeQ8A yHsAQN4DAPIeAJD3AIC8BwBCCOFCCOHJJ59cXV11LgAgfZ588skQQhTHsXMBAOn2/wcA4RrQvfbn +N8AAAAASUVORK5CYII= 141631 2012-05-13 20:55:44 -0700 2012-05-13 22:22:55 -0700 Patch for landing bug-86021-20120513205542.patch text/plain 15602 rniwa SW5kZXg6IFBlcmZvcm1hbmNlVGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFBlcmZvcm1h bmNlVGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiAxMTY4MzkpCisrKyBQZXJmb3JtYW5jZVRlc3Rz L0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDM3IEBACisyMDEyLTA1LTExICBS eW9zdWtlIE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgorCisgICAgICAgIHBlcmZvcm1hbmNlIHRl c3RzIHNob3VsZCBiZSBhYmxlIHRvIG1lYXN1cmUgcnVucy9zZWMgcmF0aGVyIHRoYW4gdGltZQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODYwMjEKKwor ICAgICAgICBSZXZpZXdlZCBieSBPamFuIFZhZmFpLgorCisgICAgICAgIEFkZCBQZXJmVGVzdFJ1 bm5lci5ydW5QZXJTZWNvbmQuIEl0IHVzZXMgX3J1bkxvb3AgYnV0IHJlcGxhY2VzIF9ydW5uZXIg YnkgX3BlclNlY29uZFJ1bm5lcgorICAgICAgICB0byBjb21wdXRlIHJ1bnMvcyBvZiBydW5GdW5j dGlvbi4KKworICAgICAgICBXaGVuIF9wZXJTZWNvbmRSdW5uZXIgaXMgY2FsbGVkIGZvciB0aGUg Zmlyc3QgdGltZSwgaS5lLiBfY29tcGxldGVkUnVucyBpcyAwIChub3RpY2UgdGhpcyBpcyAtMQor ICAgICAgICBpbiByZWd1bGFyIHJ1bi9fcnVubmVyKSwgaXQgc2xvd2x5IGluY3JlYXNlcyB0aGUg bnVtYmVyIG9mIGZ1bmN0aW9uIGNhbGxzIHRvIHJ1bkZ1bmN0aW9uIGJldHdlZW4KKyAgICAgICAg dGltZSBtZWFzdXJlbWVudHMgaW4gb3JkZXIgdG8gZGlzY291bnQgdGhlIHRpbWUgdXNlZCBieSBu ZXcgRGF0ZSgpIGNhbGxzIHRoZW1zZWx2ZXMgdW50aWwgdGhlCisgICAgICAgIHRvdGFsIHRpbWUg c3BlbnQgcmVhY2hlcyAxMDAgbWlsbGlzZWNvbmRzLgorCisgICAgICAgIEJ5IGRlZmF1bHQsIHJ1 blBlclNlY29uZCBydW5zIHRoZSB0ZXN0IGZvciBhdCBsZWFzdCA3NTAgbWlsbGlzZWNvbmRzIGlu IGVhY2ggcnVuLCBhbmQgZXhlY3V0ZXMKKyAgICAgICAgMjEgcnVucywgeWllbGRpbmcgdGhlIHRv dGFsIHJ1biB0aW1lIG9mIHJvdWdobHkgMTggc2Vjb25kcy4gVGhpcyBpcyBzaWduaWZpY2FudGx5 IGZhc3RlciB0aGFuCisgICAgICAgIG1vc3Qgb2YgZXhpc3RpbmcgcGVyZm9ybWFuY2UgdGVzdHMu IEFsc28gc2VlIGh0dHA6Ly9lam9obi5vcmcvYmxvZy9hY2N1cmFjeS1vZi1qYXZhc2NyaXB0LXRp bWUvLgorCisgICAgICAgIEZpbmFsbHksIHJlZmFjdG9yZWQgdGhlIGV4aXN0aW5nIG1ldGhvZHMg b2YgUGVyZlRlc3RSdW5uZXIgdG8gYWxsb3cgInJ1bnMvcyIgdW5pdCBhbmQgc2hhcmUgY29kZS4K KworICAgICAgICAqIExheW91dC9mbGV4Ym94LWNvbHVtbi1ub3dyYXAuaHRtbDoKKyAgICAgICAg KiBMYXlvdXQvZmxleGJveC1jb2x1bW4td3JhcC5odG1sOgorICAgICAgICAqIExheW91dC9mbGV4 Ym94LXJvdy1ub3dyYXAuaHRtbDoKKyAgICAgICAgKiBMYXlvdXQvZmxleGJveC1yb3ctd3JhcC5o dG1sOgorICAgICAgICAqIHJlc291cmNlcy9ydW5uZXIuanM6CisgICAgICAgIChQZXJmVGVzdFJ1 bm5lci5jb21wdXRlU3RhdGlzdGljcyk6IFRha2VzIHVuaXQuCisgICAgICAgIChQZXJmVGVzdFJ1 bm5lci5sb2dTdGF0aXN0aWNzKTogRGl0dG8uCisgICAgICAgIChQZXJmVGVzdFJ1bm5lci5fcnVu TG9vcCk6CisgICAgICAgIChQZXJmVGVzdFJ1bm5lci5fcnVubmVyKToKKyAgICAgICAgKFBlcmZU ZXN0UnVubmVyLnJ1blBlclNlY29uZCk6IEFkZGVkLgorICAgICAgICAoUGVyZlRlc3RSdW5uZXIu X3BlclNlY29uZFJ1bm5lcik6IEFkZGVkLiBDYWxsZWQgYnkgX3J1bkxvb3AuCisgICAgICAgIChQ ZXJmVGVzdFJ1bm5lci5fcGVyU2Vjb25kUnVubmVySXRlcmF0b3IpOiBBZGRlZC4KKwogMjAxMi0w NS0wOSAgVG9ueSBDaGFuZyAgPHRvbnlAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIGFkZCBzb21l IGJhc2ljIHBlcmYtby1tYXRpYyB0ZXN0cyBmb3IgZmxleGJveApJbmRleDogUGVyZm9ybWFuY2VU ZXN0cy9MYXlvdXQvZmxleGJveC1jb2x1bW4tbm93cmFwLmh0bWwKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gUGVy Zm9ybWFuY2VUZXN0cy9MYXlvdXQvZmxleGJveC1jb2x1bW4tbm93cmFwLmh0bWwJKHJldmlzaW9u IDExNjgyMSkKKysrIFBlcmZvcm1hbmNlVGVzdHMvTGF5b3V0L2ZsZXhib3gtY29sdW1uLW5vd3Jh cC5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC0yOCw4ICsyOCw4IEBAIGZ1bmN0aW9uIHJ1blRlc3Qo KQogICAgIGRvY3VtZW50LmJvZHkuY2xpZW50SGVpZ2h0OwogfQogCi1QZXJmVGVzdFJ1bm5lci5y dW4ocnVuVGVzdCwgMTgwLCAyMCwgZnVuY3Rpb24oKSB7CitQZXJmVGVzdFJ1bm5lci5ydW5QZXJT ZWNvbmQoe3J1bjogcnVuVGVzdCwgZG9uZTogZnVuY3Rpb24oKSB7CiAgICAgZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoImZsZXhib3giKS5zdHlsZS5kaXNwbGF5ID0gJ25vbmUnOwotfSk7Cit9fSk7 CiA8L3NjcmlwdD4KIDwvaHRtbD4KSW5kZXg6IFBlcmZvcm1hbmNlVGVzdHMvTGF5b3V0L2ZsZXhi b3gtY29sdW1uLXdyYXAuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBQZXJmb3JtYW5jZVRlc3RzL0xheW91 dC9mbGV4Ym94LWNvbHVtbi13cmFwLmh0bWwJKHJldmlzaW9uIDExNjgyMSkKKysrIFBlcmZvcm1h bmNlVGVzdHMvTGF5b3V0L2ZsZXhib3gtY29sdW1uLXdyYXAuaHRtbAkod29ya2luZyBjb3B5KQpA QCAtMjgsOCArMjgsOCBAQCBmdW5jdGlvbiBydW5UZXN0KCkKICAgICBkb2N1bWVudC5ib2R5LmNs aWVudEhlaWdodDsKIH0KIAotUGVyZlRlc3RSdW5uZXIucnVuKHJ1blRlc3QsIDE4MCwgMjAsIGZ1 bmN0aW9uKCkgeworUGVyZlRlc3RSdW5uZXIucnVuUGVyU2Vjb25kKHtydW46IHJ1blRlc3QsIGRv bmU6ZnVuY3Rpb24oKSB7CiAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImZsZXhib3giKS5z dHlsZS5kaXNwbGF5ID0gJ25vbmUnOwotfSk7Cit9fSk7CiA8L3NjcmlwdD4KIDwvaHRtbD4KSW5k ZXg6IFBlcmZvcm1hbmNlVGVzdHMvTGF5b3V0L2ZsZXhib3gtcm93LW5vd3JhcC5odG1sCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFBlcmZvcm1hbmNlVGVzdHMvTGF5b3V0L2ZsZXhib3gtcm93LW5vd3JhcC5odG1s CShyZXZpc2lvbiAxMTY4MjEpCisrKyBQZXJmb3JtYW5jZVRlc3RzL0xheW91dC9mbGV4Ym94LXJv dy1ub3dyYXAuaHRtbAkod29ya2luZyBjb3B5KQpAQCAtMjgsOCArMjgsOCBAQCBmdW5jdGlvbiBy dW5UZXN0KCkKICAgICBkb2N1bWVudC5ib2R5LmNsaWVudEhlaWdodDsKIH0KIAotUGVyZlRlc3RS dW5uZXIucnVuKHJ1blRlc3QsIDEwMCwgMjAsIGZ1bmN0aW9uKCkgeworUGVyZlRlc3RSdW5uZXIu cnVuUGVyU2Vjb25kKHtydW46cnVuVGVzdCwgZG9uZTpmdW5jdGlvbigpIHsKICAgICBkb2N1bWVu dC5nZXRFbGVtZW50QnlJZCgiZmxleGJveCIpLnN0eWxlLmRpc3BsYXkgPSAnbm9uZSc7Ci19KTsK K319KTsKIDwvc2NyaXB0PgogPC9odG1sPgpJbmRleDogUGVyZm9ybWFuY2VUZXN0cy9MYXlvdXQv ZmxleGJveC1yb3ctd3JhcC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFBlcmZvcm1hbmNlVGVzdHMvTGF5 b3V0L2ZsZXhib3gtcm93LXdyYXAuaHRtbAkocmV2aXNpb24gMTE2ODIxKQorKysgUGVyZm9ybWFu Y2VUZXN0cy9MYXlvdXQvZmxleGJveC1yb3ctd3JhcC5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC0y OCw4ICsyOCw4IEBAIGZ1bmN0aW9uIHJ1blRlc3QoKQogICAgIGRvY3VtZW50LmJvZHkuY2xpZW50 SGVpZ2h0OwogfQogCi1QZXJmVGVzdFJ1bm5lci5ydW4ocnVuVGVzdCwgMTAwLCAyMCwgZnVuY3Rp b24oKSB7CitQZXJmVGVzdFJ1bm5lci5ydW5QZXJTZWNvbmQoe3J1bjogcnVuVGVzdCwgZG9uZTpm dW5jdGlvbigpIHsKICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiZmxleGJveCIpLnN0eWxl LmRpc3BsYXkgPSAnbm9uZSc7Ci19KTsKK319KTsKIDwvc2NyaXB0PgogPC9odG1sPgpJbmRleDog UGVyZm9ybWFuY2VUZXN0cy9yZXNvdXJjZXMvcnVubmVyLmpzCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFBlcmZv cm1hbmNlVGVzdHMvcmVzb3VyY2VzL3J1bm5lci5qcwkocmV2aXNpb24gMTE2ODIxKQorKysgUGVy Zm9ybWFuY2VUZXN0cy9yZXNvdXJjZXMvcnVubmVyLmpzCSh3b3JraW5nIGNvcHkpCkBAIC00OSw3 ICs0OSw3IEBAIFBlcmZUZXN0UnVubmVyLmxvYWRGaWxlID0gZnVuY3Rpb24gKHBhdGgKICAgICBy ZXR1cm4geGhyLnJlc3BvbnNlVGV4dDsKIH0KIAotUGVyZlRlc3RSdW5uZXIuY29tcHV0ZVN0YXRp c3RpY3MgPSBmdW5jdGlvbiAodGltZXMpIHsKK1BlcmZUZXN0UnVubmVyLmNvbXB1dGVTdGF0aXN0 aWNzID0gZnVuY3Rpb24gKHRpbWVzLCB1bml0KSB7CiAgICAgdmFyIGRhdGEgPSB0aW1lcy5zbGlj ZSgpOwogCiAgICAgLy8gQWRkIHZhbHVlcyBmcm9tIHRoZSBzbWFsbGVzdCB0byB0aGUgbGFyZ2Vz dCB0byBhdm9pZCB0aGUgbG9zcyBvZiBzaWduaWZpY2FuY2UKQEAgLTc2LDE0ICs3NiwxNCBAQCBQ ZXJmVGVzdFJ1bm5lci5jb21wdXRlU3RhdGlzdGljcyA9IGZ1bmN0CiAgICAgfQogICAgIHJlc3Vs dC52YXJpYW5jZSA9IHNxdWFyZVN1bSAvIGRhdGEubGVuZ3RoOwogICAgIHJlc3VsdC5zdGRldiA9 IE1hdGguc3FydChyZXN1bHQudmFyaWFuY2UpOwotICAgIHJlc3VsdC51bml0ID0gIm1zIjsKKyAg ICByZXN1bHQudW5pdCA9IHVuaXQgfHwgIm1zIjsKIAogICAgIHJldHVybiByZXN1bHQ7CiB9CiAK IFBlcmZUZXN0UnVubmVyLmxvZ1N0YXRpc3RpY3MgPSBmdW5jdGlvbiAodGltZXMpIHsKICAgICB0 aGlzLmxvZygiIik7Ci0gICAgdmFyIHN0YXRpc3RpY3MgPSB0aGlzLmNvbXB1dGVTdGF0aXN0aWNz KHRpbWVzKTsKKyAgICB2YXIgc3RhdGlzdGljcyA9IHRoaXMuY29tcHV0ZVN0YXRpc3RpY3ModGlt ZXMsIHRoaXMudW5pdCk7CiAgICAgdGhpcy5wcmludFN0YXRpc3RpY3Moc3RhdGlzdGljcyk7CiB9 CiAKQEAgLTExNyw3ICsxMTcsNyBAQCBQZXJmVGVzdFJ1bm5lci5fcnVuTG9vcCA9IGZ1bmN0aW9u ICgpIHsKICAgICAgICAgdGhpcy5nYygpOwogICAgICAgICB3aW5kb3cuc2V0VGltZW91dChmdW5j dGlvbiAoKSB7IFBlcmZUZXN0UnVubmVyLl9ydW5uZXIoKTsgfSwgMCk7CiAgICAgfSBlbHNlIHsK LSAgICAgICAgdGhpcy5sb2dTdGF0aXN0aWNzKHRoaXMuX3RpbWVzKTsKKyAgICAgICAgdGhpcy5s b2dTdGF0aXN0aWNzKHRoaXMuX3Jlc3VsdHMpOwogICAgICAgICB0aGlzLl9kb25lRnVuY3Rpb24o KTsKICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKICAgICAgICAgICAg IGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKQEAgLTE0MCwxMyArMTQwLDI3IEBA IFBlcmZUZXN0UnVubmVyLl9ydW5uZXIgPSBmdW5jdGlvbiAoKSB7CiAgICAgLy8gQXNzdW1lIHRv dGFsVGltZSBjYW4gbmV2ZXIgYmUgemVybyB3aGVuIF9ydW5GdW5jdGlvbiByZXR1cm5zIGEgbnVt YmVyLgogICAgIHZhciB0aW1lID0gdG90YWxUaW1lID8gdG90YWxUaW1lIDogRGF0ZS5ub3coKSAt IHN0YXJ0OwogCisgICAgdGhpcy5pZ25vcmVXYXJtVXBBbmRMb2codGltZSk7CisgICAgdGhpcy5f cnVuTG9vcCgpOworfQorCitQZXJmVGVzdFJ1bm5lci5pZ25vcmVXYXJtVXBBbmRMb2cgPSBmdW5j dGlvbiAocmVzdWx0KSB7CiAgICAgdGhpcy5fY29tcGxldGVkUnVucysrOworCisgICAgdmFyIGxh YmVsZWRSZXN1bHQgPSByZXN1bHQgKyAiICIgKyB0aGlzLnVuaXQ7CiAgICAgaWYgKHRoaXMuX2Nv bXBsZXRlZFJ1bnMgPD0gMCkKLSAgICAgICAgdGhpcy5sb2coIklnbm9yaW5nIHdhcm0tdXAgcnVu ICgiICsgdGltZSArICIpIik7CisgICAgICAgIHRoaXMubG9nKCJJZ25vcmluZyB3YXJtLXVwIHJ1 biAoIiArIGxhYmVsZWRSZXN1bHQgKyAiKSIpOwogICAgIGVsc2UgewotICAgICAgICB0aGlzLl90 aW1lcy5wdXNoKHRpbWUpOwotICAgICAgICB0aGlzLmxvZyh0aW1lKTsKKyAgICAgICAgdGhpcy5f cmVzdWx0cy5wdXNoKHJlc3VsdCk7CisgICAgICAgIHRoaXMubG9nKGxhYmVsZWRSZXN1bHQpOwog ICAgIH0KK30KKworUGVyZlRlc3RSdW5uZXIuaW5pdEFuZFN0YXJ0TG9vcCA9IGZ1bmN0aW9uKCkg eworICAgIHRoaXMuX2NvbXBsZXRlZFJ1bnMgPSAtMTsKKyAgICB0aGlzLmN1c3RvbVJ1bkZ1bmN0 aW9uID0gbnVsbDsKKyAgICB0aGlzLl9yZXN1bHRzID0gW107CisgICAgdGhpcy5sb2coIlJ1bm5p bmcgIiArIHRoaXMuX3J1bkNvdW50ICsgIiB0aW1lcyIpOwogICAgIHRoaXMuX3J1bkxvb3AoKTsK IH0KIApAQCAtMTU1LDE0ICsxNjksNDkgQEAgUGVyZlRlc3RSdW5uZXIucnVuID0gZnVuY3Rpb24g KHJ1bkZ1bmN0aQogICAgIHRoaXMuX2xvb3BzUGVyUnVuID0gbG9vcHNQZXJSdW4gfHwgMTA7CiAg ICAgdGhpcy5fcnVuQ291bnQgPSBydW5Db3VudCB8fCAyMDsKICAgICB0aGlzLl9kb25lRnVuY3Rp b24gPSBkb25lRnVuY3Rpb24gfHwgZnVuY3Rpb24gKCkge307Ci0gICAgdGhpcy5fY29tcGxldGVk UnVucyA9IC0xOwotICAgIHRoaXMuY3VzdG9tUnVuRnVuY3Rpb24gPSBudWxsOwotICAgIHRoaXMu X3RpbWVzID0gW107CisgICAgdGhpcy51bml0ID0gJ21zJzsKKyAgICB0aGlzLmluaXRBbmRTdGFy dExvb3AoKTsKK30KIAotICAgIHRoaXMubG9nKCJSdW5uaW5nICIgKyB0aGlzLl9ydW5Db3VudCAr ICIgdGltZXMiKTsKK1BlcmZUZXN0UnVubmVyLnJ1blBlclNlY29uZCA9IGZ1bmN0aW9uICh0ZXN0 KSB7CisgICAgdGhpcy5fZG9uZUZ1bmN0aW9uID0gZnVuY3Rpb24gKCkgeyBpZiAodGVzdC5kb25l KSB0ZXN0LmRvbmUoKTsgfTsKKyAgICB0aGlzLl9ydW5Db3VudCA9IHRlc3QucnVuQ291bnQgfHwg MjA7CisgICAgdGhpcy5fY2FsbHNQZXJJdGVyYXRpb24gPSAxOworICAgIHRoaXMudW5pdCA9ICdy dW5zL3MnOworCisgICAgdGhpcy5fdGVzdCA9IHRlc3Q7CisgICAgdGhpcy5fcnVubmVyID0gdGhp cy5fcGVyU2Vjb25kUnVubmVyOworICAgIHRoaXMuaW5pdEFuZFN0YXJ0TG9vcCgpOworfQorCitQ ZXJmVGVzdFJ1bm5lci5fcGVyU2Vjb25kUnVubmVyID0gZnVuY3Rpb24gKCkgeworICAgIHZhciB0 aW1lVG9SdW4gPSB0aGlzLl90ZXN0LnRpbWVUb1J1biB8fCA3NTA7CisgICAgdmFyIHRvdGFsVGlt ZSA9IDA7CisgICAgdmFyIGkgPSAwOworICAgIHZhciBjYWxsc1Blckl0ZXJhdGlvbiA9IHRoaXMu X2NhbGxzUGVySXRlcmF0aW9uOworCisgICAgaWYgKHRoaXMuX3Rlc3Quc2V0dXApCisgICAgICAg IHRoaXMuX3Rlc3Quc2V0dXAoKTsKKworICAgIHdoaWxlICh0b3RhbFRpbWUgPCB0aW1lVG9SdW4p IHsKKyAgICAgICAgdG90YWxUaW1lICs9IHRoaXMuX3BlclNlY29uZFJ1bm5lckl0ZXJhdG9yKGNh bGxzUGVySXRlcmF0aW9uKTsKKyAgICAgICAgaSArPSBjYWxsc1Blckl0ZXJhdGlvbjsKKyAgICAg ICAgaWYgKHRoaXMuX2NvbXBsZXRlZFJ1bnMgPD0gMCAmJiB0b3RhbFRpbWUgPCAxMDApCisgICAg ICAgICAgICBjYWxsc1Blckl0ZXJhdGlvbiA9IE1hdGgubWF4KDEwLCAyICogY2FsbHNQZXJJdGVy YXRpb24pOworICAgIH0KKyAgICB0aGlzLl9jYWxsc1Blckl0ZXJhdGlvbiA9IGNhbGxzUGVySXRl cmF0aW9uOworCisgICAgdGhpcy5pZ25vcmVXYXJtVXBBbmRMb2coaSAqIDEwMDAgLyB0b3RhbFRp bWUpOwogICAgIHRoaXMuX3J1bkxvb3AoKTsKIH0KIAorUGVyZlRlc3RSdW5uZXIuX3BlclNlY29u ZFJ1bm5lckl0ZXJhdG9yID0gZnVuY3Rpb24gKGNhbGxzUGVySXRlcmF0aW9uKSB7CisgICAgdmFy IHN0YXJ0VGltZSA9IERhdGUubm93KCk7CisgICAgZm9yICh2YXIgaSA9IDA7IGkgPCBjYWxsc1Bl ckl0ZXJhdGlvbjsgaSsrKQorICAgICAgICB0aGlzLl90ZXN0LnJ1bigpOworICAgIHJldHVybiBE YXRlLm5vdygpIC0gc3RhcnRUaW1lOworfQorCiBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKSB7CiAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGlsRG9uZSgpOwogICAgIGxh eW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKSW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJldmlzaW9uIDExNjgzOSkKKysrIFRvb2xz L0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE1IEBACisyMDEyLTA1LTExICBS eW9zdWtlIE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgorCisgICAgICAgIHBlcmZvcm1hbmNlIHRl c3RzIHNob3VsZCBiZSBhYmxlIHRvIG1lYXN1cmUgcnVucy9zZWMgcmF0aGVyIHRoYW4gdGltZQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODYwMjEKKwor ICAgICAgICBSZXZpZXdlZCBieSBPamFuIFZhZmFpLgorCisgICAgICAgIEFsbG93ICIgcnVucy9z IiBvciAiIG1zIiB0byBhcHBlYXIgYWZ0ZXIgbnVtZXJpY2FsIHZhbHVlcyBpbiB0ZXN0cy4KKwor ICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvcGVyZm9ybWFuY2VfdGVzdHMvcGVyZnRlc3QucHk6 CisgICAgICAgIChQZXJmVGVzdCk6CisKIDIwMTItMDUtMTEgIE9qYW4gVmFmYWkgIDxvamFuQGNo cm9taXVtLm9yZz4KIAogICAgICAgICBBZGQgcHJldmlvdXMvbmV4dCBidXR0b25zIHRoZSBnYXJk ZW4tby1tYXRpY3MgcGVyZiBwYW5lbApJbmRleDogVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wZXJm b3JtYW5jZV90ZXN0cy9wZXJmdGVzdC5weQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9TY3JpcHRzL3dl YmtpdHB5L3BlcmZvcm1hbmNlX3Rlc3RzL3BlcmZ0ZXN0LnB5CShyZXZpc2lvbiAxMTY4MjEpCisr KyBUb29scy9TY3JpcHRzL3dlYmtpdHB5L3BlcmZvcm1hbmNlX3Rlc3RzL3BlcmZ0ZXN0LnB5CSh3 b3JraW5nIGNvcHkpCkBAIC03NCw3ICs3NCw3IEBAIGNsYXNzIFBlcmZUZXN0KG9iamVjdCk6CiAg ICAgICAgIHJlLmNvbXBpbGUocideUnVubmluZyBcZCsgdGltZXMkJyksCiAgICAgICAgIHJlLmNv bXBpbGUocideSWdub3Jpbmcgd2FybS11cCAnKSwKICAgICAgICAgcmUuY29tcGlsZShyJ15JbmZv OicpLAotICAgICAgICByZS5jb21waWxlKHInXlxkKyguXGQrKT8kJyksCisgICAgICAgIHJlLmNv bXBpbGUocideXGQrKC5cZCspPyhccyoocnVuc1wvc3xtcykpPyQnKSwKICAgICAgICAgIyBGb2xs b3dpbmcgYXJlIGZvciBoYW5kbGUgZXhpc3RpbmcgdGVzdCBsaWtlIERyb21hZW8KICAgICAgICAg cmUuY29tcGlsZShyZS5lc2NhcGUoIiIibWFpbiBmcmFtZSAtIGhhcyAxIG9udW5sb2FkIGhhbmRs ZXIocykiIiIpKSwKICAgICAgICAgcmUuY29tcGlsZShyZS5lc2NhcGUoIiIiZnJhbWUgIjwhLS1m cmFtZVBhdGggLy88IS0tZnJhbWUwLS0+LS0+IiAtIGhhcyAxIG9udW5sb2FkIGhhbmRsZXIocyki IiIpKSwKSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRU ZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDExNjgzOSkKKysrIExheW91dFRlc3RzL0NoYW5nZUxv Zwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE3IEBACisyMDEyLTA1LTExICBSeW9zdWtlIE5p d2EgIDxybml3YUB3ZWJraXQub3JnPgorCisgICAgICAgIHBlcmZvcm1hbmNlIHRlc3RzIHNob3Vs ZCBiZSBhYmxlIHRvIG1lYXN1cmUgcnVucy9zZWMgcmF0aGVyIHRoYW4gdGltZQorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODYwMjEKKworICAgICAgICBS ZXZpZXdlZCBieSBPamFuIFZhZmFpLgorCisgICAgICAgIEFkZCB0ZXN0cyBmb3IgUGVyZlRlc3RS dW5uZXIucnVuUGVyU2Vjb25kLgorCisgICAgICAgICogZmFzdC9oYXJuZXNzL3BlcmZ0ZXN0cy9y dW5zLXBlci1zZWNvbmQtaXRlcmF0aW9ucy1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAq IGZhc3QvaGFybmVzcy9wZXJmdGVzdHMvcnVucy1wZXItc2Vjb25kLWl0ZXJhdGlvbnMuaHRtbDog QWRkZWQuCisgICAgICAgICogZmFzdC9oYXJuZXNzL3BlcmZ0ZXN0cy9ydW5zLXBlci1zZWNvbmQt bG9nLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9oYXJuZXNzL3BlcmZ0ZXN0 cy9ydW5zLXBlci1zZWNvbmQtbG9nLmh0bWw6IEFkZGVkLgorCiAyMDEyLTA1LTExICBOb2VsIEdv cmRvbiAgPG5vZWwuZ29yZG9uQGdtYWlsLmNvbT4KIAogICAgICAgICBPcHRpbWlzZSBhbmQgdXBk YXRlIHRlc3QgZXhwZWN0YXRpb25zIGFmdGVyIHIxMTY2MzYKSW5kZXg6IExheW91dFRlc3RzL2Zh c3QvaGFybmVzcy9wZXJmdGVzdHMvcnVucy1wZXItc2Vjb25kLWl0ZXJhdGlvbnMtZXhwZWN0ZWQu dHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvaGFybmVzcy9wZXJmdGVzdHMvcnVu cy1wZXItc2Vjb25kLWl0ZXJhdGlvbnMtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5 b3V0VGVzdHMvZmFzdC9oYXJuZXNzL3BlcmZ0ZXN0cy9ydW5zLXBlci1zZWNvbmQtaXRlcmF0aW9u cy1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTYgQEAKK1RoaXMgdGVzdCB2 ZXJpZmllcyBQZXJmVGVzdFJ1bm5lci5ydW5QZXJTZWNvbmQoKSBjYWxscyBydW5GdW5jdGlvbiBh cyBtYW55IHRpbWVzIGFzIGV4cGVjdGVkLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBz ZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisK K1JldHVybmluZyB0aW1lczogWzAsIDEwLCAzMCwgNjAsIDEwMCwgMTAwLCAxMDAsIDEwMCwgNTAw XQorUEFTUyBjYWxsc0luSXRlcmF0aW9uc1swXSBpcyAxCitQQVNTIGNhbGxzSW5JdGVyYXRpb25z WzFdIGlzIDEwCitQQVNTIGNhbGxzSW5JdGVyYXRpb25zWzFdICsgNSA8IGNhbGxzSW5JdGVyYXRp b25zWzJdIGlzIHRydWUKK1BBU1MgY2FsbHNJbkl0ZXJhdGlvbnNbMl0gKyAxMCA8IGNhbGxzSW5J dGVyYXRpb25zWzNdIGlzIHRydWUKK1BBU1MgY2FsbHNJbkl0ZXJhdGlvbnNbM10gaXMgY2FsbHNJ bkl0ZXJhdGlvbnNbNF0KK1BBU1MgY2FsbHNJbkl0ZXJhdGlvbnNbNF0gaXMgY2FsbHNJbkl0ZXJh dGlvbnNbNV0KK1BBU1MgY2FsbHNJbkl0ZXJhdGlvbnNbNV0gaXMgY2FsbHNJbkl0ZXJhdGlvbnNb Nl0KK1BBU1MgY2FsbHNJbkl0ZXJhdGlvbnNbNl0gaXMgY2FsbHNJbkl0ZXJhdGlvbnNbN10KK1BB U1MgY2FsbHNJbkl0ZXJhdGlvbnNbN10gaXMgY2FsbHNJbkl0ZXJhdGlvbnNbOF0KK1BBU1MgY2Fs bHNJbkl0ZXJhdGlvbnNbOV0gaXMgdW5kZWZpbmVkLgorCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0 L2hhcm5lc3MvcGVyZnRlc3RzL3J1bnMtcGVyLXNlY29uZC1pdGVyYXRpb25zLmh0bWwKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNzL3BlcmZ0ZXN0cy9ydW5zLXBlci1zZWNv bmQtaXRlcmF0aW9ucy5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9oYXJu ZXNzL3BlcmZ0ZXN0cy9ydW5zLXBlci1zZWNvbmQtaXRlcmF0aW9ucy5odG1sCShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDQ3IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGJvZHk+Cis8ZGl2 IGlkPSJkZXNjcmlwdGlvbiI+PC9kaXY+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3Jp cHQgc3JjPSIuLi8uLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3Jp cHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vLi4vLi4vUGVyZm9ybWFuY2VUZXN0cy9yZXNvdXJjZXMv cnVubmVyLmpzIj48L3NjcmlwdD4KKzxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KKwor ZGVzY3JpcHRpb24oIlRoaXMgdGVzdCB2ZXJpZmllcyBQZXJmVGVzdFJ1bm5lci5ydW5QZXJTZWNv bmQoKSBjYWxscyBydW5GdW5jdGlvbiBhcyBtYW55IHRpbWVzIGFzIGV4cGVjdGVkLiIpOworCit2 YXIgaXRlcmF0aW9uID0gMDsKKwordmFyIGNhbGxzSW5JdGVyYXRpb25zID0gW107Cit2YXIgdGlt ZXNJbkl0ZXJhdGlvbnMgPSBbMCwgMTAsIDMwLCA2MCwgMTAwLCAxMDAsIDEwMCwgMTAwLCA1MDBd OwordmFyIGxvZ0xpbmVzID0gW107CisKK1BlcmZUZXN0UnVubmVyLmxvZyA9IGZ1bmN0aW9uIChs aW5lKSB7IGxvZ0xpbmVzLnB1c2gobGluZSk7IH0KK1BlcmZUZXN0UnVubmVyLl9wZXJTZWNvbmRS dW5uZXJJdGVyYXRvciA9IGZ1bmN0aW9uIChjYWxsc1Blckl0ZXJhdGlvbikgeworICAgIGNhbGxz SW5JdGVyYXRpb25zW2l0ZXJhdGlvbl0gPSBjYWxsc1Blckl0ZXJhdGlvbjsKKyAgICByZXR1cm4g dGltZXNJbkl0ZXJhdGlvbnNbaXRlcmF0aW9uKytdOworfQorCitQZXJmVGVzdFJ1bm5lci5ydW5Q ZXJTZWNvbmQoeworICAgIHJ1bjogZnVuY3Rpb24gKCkgeyB9LAorICAgIHJ1bkNvdW50OiAxLAor ICAgIHRpbWVUb1J1bjogNTAwLAorICAgIGRvbmU6IGZ1bmN0aW9uICgpIHsKKyAgICAgICAgZGVi dWcoIlJldHVybmluZyB0aW1lczogWyIgKyB0aW1lc0luSXRlcmF0aW9ucy5qb2luKCIsICIpICsg Il0iKTsKKyAgICAgICAgc2hvdWxkRXZhbHVhdGVUbygiY2FsbHNJbkl0ZXJhdGlvbnNbMF0iLCAx KTsKKyAgICAgICAgc2hvdWxkRXZhbHVhdGVUbygiY2FsbHNJbkl0ZXJhdGlvbnNbMV0iLCAxMCk7 CisgICAgICAgIHNob3VsZEJlVHJ1ZSgiY2FsbHNJbkl0ZXJhdGlvbnNbMV0gKyA1IDwgY2FsbHNJ bkl0ZXJhdGlvbnNbMl0iKTsKKyAgICAgICAgc2hvdWxkQmVUcnVlKCJjYWxsc0luSXRlcmF0aW9u c1syXSArIDEwIDwgY2FsbHNJbkl0ZXJhdGlvbnNbM10iKTsKKyAgICAgICAgc2hvdWxkQmUoImNh bGxzSW5JdGVyYXRpb25zWzNdIiwgImNhbGxzSW5JdGVyYXRpb25zWzRdIik7CisgICAgICAgIHNo b3VsZEJlKCJjYWxsc0luSXRlcmF0aW9uc1s0XSIsICJjYWxsc0luSXRlcmF0aW9uc1s1XSIpOwor ICAgICAgICBzaG91bGRCZSgiY2FsbHNJbkl0ZXJhdGlvbnNbNV0iLCAiY2FsbHNJbkl0ZXJhdGlv bnNbNl0iKTsKKyAgICAgICAgc2hvdWxkQmUoImNhbGxzSW5JdGVyYXRpb25zWzZdIiwgImNhbGxz SW5JdGVyYXRpb25zWzddIik7CisgICAgICAgIHNob3VsZEJlKCJjYWxsc0luSXRlcmF0aW9uc1s3 XSIsICJjYWxsc0luSXRlcmF0aW9uc1s4XSIpOworICAgICAgICBzaG91bGRCZVVuZGVmaW5lZCgi Y2FsbHNJbkl0ZXJhdGlvbnNbOV0iKTsKKyAgICB9fSk7CisKK3ZhciBqc1Rlc3RJc0FzeW5jID0g dHJ1ZTsKKworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vLi4vZmFzdC9qcy9yZXNvdXJj ZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KSW5kZXg6IExh eW91dFRlc3RzL2Zhc3QvaGFybmVzcy9wZXJmdGVzdHMvcnVucy1wZXItc2Vjb25kLWxvZy1leHBl Y3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNzL3BlcmZ0ZXN0 cy9ydW5zLXBlci1zZWNvbmQtbG9nLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91 dFRlc3RzL2Zhc3QvaGFybmVzcy9wZXJmdGVzdHMvcnVucy1wZXItc2Vjb25kLWxvZy1leHBlY3Rl ZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTcgQEAKK1RoaXMgdGVzdCB2ZXJpZmllcyBQ ZXJmVGVzdFJ1bm5lci5ydW5QZXJTZWNvbmQoKSBvdXRwdXRzIGxvZyBhcyBleHBlY3RlZC4KKwor UnVubmluZyA1IHRpbWVzCitJZ25vcmluZyB3YXJtLXVwIHJ1biAoMCBydW5zL3MpCisxIHJ1bnMv cworMiBydW5zL3MKKzMgcnVucy9zCis0IHJ1bnMvcworNSBydW5zL3MKKworCithdmcgMyBydW5z L3MKK21lZGlhbiAzIHJ1bnMvcworc3RkZXYgMS40MSBydW5zL3MKK21pbiAxIHJ1bnMvcworbWF4 IDUgcnVucy9zCisKSW5kZXg6IExheW91dFRlc3RzL2Zhc3QvaGFybmVzcy9wZXJmdGVzdHMvcnVu cy1wZXItc2Vjb25kLWxvZy5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3QvaGFy bmVzcy9wZXJmdGVzdHMvcnVucy1wZXItc2Vjb25kLWxvZy5odG1sCShyZXZpc2lvbiAwKQorKysg TGF5b3V0VGVzdHMvZmFzdC9oYXJuZXNzL3BlcmZ0ZXN0cy9ydW5zLXBlci1zZWNvbmQtbG9nLmh0 bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMzcgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+ Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+VGhpcyB0ZXN0IHZlcmlmaWVzIFBlcmZUZXN0 UnVubmVyLnJ1blBlclNlY29uZCgpIG91dHB1dHMgbG9nIGFzIGV4cGVjdGVkLjwvcD4KKzxkaXYg aWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9Ii4uLy4uLy4uLy4uL1BlcmZvcm1hbmNl VGVzdHMvcmVzb3VyY2VzL3J1bm5lci5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHR5cGU9InRleHQv amF2YXNjcmlwdCI+CisKK3ZhciBsb2dMaW5lcyA9IFtdOwordmFyIGluaXRpYWwgPSB0cnVlOwor dmFyIHJ1bnMgPSAwOworCitQZXJmVGVzdFJ1bm5lci5fcGVyU2Vjb25kUnVubmVySXRlcmF0b3Ig PSBmdW5jdGlvbiAoY2FsbHNQZXJJdGVyYXRpb24pIHsKKyAgICByZXR1cm4gMTAwMCAvIHJ1bnM7 Cit9CisKK3ZhciBwcmludFN0YXRpc3RpY3MgPSBQZXJmVGVzdFJ1bm5lci5wcmludFN0YXRpc3Rp Y3M7CitQZXJmVGVzdFJ1bm5lci5wcmludFN0YXRpc3RpY3MgPSBmdW5jdGlvbiAoc3RhdGlzdGlj cykgeworICAgIHN0YXRpc3RpY3Muc3RkZXYgPSBzdGF0aXN0aWNzLnN0ZGV2LnRvUHJlY2lzaW9u KDMpOworICAgIHJldHVybiBwcmludFN0YXRpc3RpY3MuY2FsbChQZXJmVGVzdFJ1bm5lciwgc3Rh dGlzdGljcyk7Cit9CisKK1BlcmZUZXN0UnVubmVyLnJ1blBlclNlY29uZCh7CisgICAgc2V0dXA6 IGZ1bmN0aW9uICgpIHsKKyAgICAgICAgaWYgKGluaXRpYWwpCisgICAgICAgICAgICBpbml0aWFs ID0gZmFsc2U7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHJ1bnMrKzsKKyAgICB9LAorICAg IHJ1bjogZnVuY3Rpb24gKCkgeyB9LAorICAgIHJ1bkNvdW50OiA1LAorICAgIHRpbWVUb1J1bjog NTAwLAorfSk7CisKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgo=