36065 2010-03-12 11:12:15 -0800 Add Support for Reference Tests (aka reftests) to existing Layout Test harness 2011-12-21 14:06:46 -0800 1 1 1 Unclassified WebKit Tools / Tests 528+ (Nightly build) All All RESOLVED FIXED P2 Enhancement --- 58302 49431 49835 49951 50362 51091 55457 55652 55654 55657 55936 56076 56450 59078 59188 60605 73453 1 dglazkov hayato ap aroben darin diegohcg dpranke eric.carlson fred.wang hamaji hayato krit mitz mjs morrita ojan simon.fraser tonikitoo vestbo yuzo oldest_to_newest 199141 0 dglazkov 2010-03-12 11:12:15 -0800 This is a master bug and a place of discussion for implementing reftests. After poking at it a bit, I am going to attempt implementing this in a way that would support using Mozilla's existig reftests out of the box, only if a subset at first. Reading material: http://mxr.mozilla.org/mozilla-central/source/layout/tools/reftest/ https://developer.mozilla.org/en/Creating_reftest-based_unit_tests http://weblogs.mozillazine.org/roc/archives/2009/01/invalidation_re.html https://library.mozilla.org/@api/deki/files/88/=Creating_a_reftest.pdf https://lists.webkit.org/pipermail/webkit-dev/2010-March/011856.html 199143 1 dglazkov 2010-03-12 11:20:32 -0800 Also http://mxr.mozilla.org/mozilla-central/source/layout/reftests/ 212890 2 dglazkov 2010-04-15 09:39:25 -0700 Initial approach: * Use Mozilla's manifest approach to minimize the need to change tests when importing/reusing. This does mean we'll have two different test frameworks, but given that W3C Testing Task Force is going to use Mozilla reftests, it seems counterintuitive to invent our own adaptation of reftests. * Place reftests into a special directory, like top-level ReferenceTests or LayoutTests/reference/ to avoid testing frameworks stepping on each other's toes. * Write harness in python, integrated with new-run-webkit-tests, not worrying about old-run-webkit-tests. * At first, use unmodified DRT (well, maybe pass a flag to mute render tree dump) to produce pixel results in the harness. Later, teach DRT to dump+compare two files to improve performance. Thoughts? 212937 3 ap 2010-04-15 11:08:45 -0700 > * Place reftests into a special directory, like top-level ReferenceTests or > LayoutTests/reference/ to avoid testing frameworks stepping on each other's > toes. It seems easy to ignore tests that have expected results in reftest format in scripts that don't support those. Also, it may be a good idea to run those (to at least catch crashes). There is some use in having tests organized logically - people sometimes run only a subset of tests during iterative development, to run the whole suite before submitting a patch. > * Write harness in python, integrated with new-run-webkit-tests, not worrying > about old-run-webkit-tests. I'm not sure about this. Last time I heard about it, there was no plan to make new-run-webkit-tests run on Tiger, which means that it probably won't obsolete the existing script in foreseeable future. 212994 4 dglazkov 2010-04-15 13:13:10 -0700 (In reply to comment #3) > > * Place reftests into a special directory, like top-level ReferenceTests or > > LayoutTests/reference/ to avoid testing frameworks stepping on each other's > > toes. > > It seems easy to ignore tests that have expected results in reftest format in > scripts that don't support those. Also, it may be a good idea to run those (to > at least catch crashes). I agree -- I didn't state anywhere (my bad!) that run-webkit-tests always runs both types of tests. > There is some use in having tests organized logically - people sometimes run > only a subset of tests during iterative development, to run the whole suite > before submitting a patch. That's a good point. I'll think of an idea here. > > * Write harness in python, integrated with new-run-webkit-tests, not worrying > > about old-run-webkit-tests. > > I'm not sure about this. Last time I heard about it, there was no plan to make > new-run-webkit-tests run on Tiger, which means that it probably won't obsolete > the existing script in foreseeable future. Well, that stinks :( -- I'll talk w/dpranke+eseidel about this. 247465 5 hayato 2010-07-07 03:55:12 -0700 As discussed in other threads, we've decided to add support for RefTest. Here is a draft plan to support RefTest in WebKit. https://docs.google.com/document/edit?id=1bwAzqOKfyB97rSIyLQ5ER6YG6-cEUa34xJ8KKgvdc0o&hl=en&authkey=CL39hMMB Any suggestions and advice are welcome. 247519 6 vestbo 2010-07-07 06:02:38 -0700 (In reply to comment #5) > As discussed in other threads, we've decided to add support for RefTest. > Here is a draft plan to support RefTest in WebKit. > https://docs.google.com/document/edit?id=1bwAzqOKfyB97rSIyLQ5ER6YG6-cEUa34xJ8KKgvdc0o&hl=en&authkey=CL39hMMB > > Any suggestions and advice are welcome. Great effort! Could we use the "-ref.html" (or reference) postfix like we now have -expected.txt to allow new tests written as reftests to be placed into the existing hierarchy of tests (together with the -expected.checksum and -expected.png)? That would allow easy transition from -expected.txt with render-tree-output to a -ref.html + png/checksum. Imported tests (mozilla, W3C) would of course have their own folder, possibly in a subfolder of LayoutTests if they only deal with css for example. 248351 7 darin 2010-07-08 11:13:11 -0700 (In reply to comment #6) > Could we use the "-ref.html" (or reference) postfix like we now have -expected.txt to allow new tests written as reftests to be placed into the existing hierarchy of tests (together with the -expected.checksum and -expected.png)? > > That would allow easy transition from -expected.txt with render-tree-output to a -ref.html + png/checksum. > > Imported tests (mozilla, W3C) would of course have their own folder, possibly in a subfolder of LayoutTests if they only deal with css for example. I like these suggestions. I don’t think we want separate testing frameworks. 248452 8 dpranke 2010-07-08 12:52:42 -0700 +1 to -ref.html and integrating tightly into new-run-webkit-tests. I don't think we should have a separate tool or a separate top level directory either. 248700 9 hayato 2010-07-08 20:24:34 -0700 (In reply to comment #8) > +1 to -ref.html and integrating tightly into new-run-webkit-tests. I don't think we should have a separate tool or a separate top level directory either. Thank you for the comments. I agree. In fact, a typical manifest file used in Mozilla is like: == appendsingle.html appendsingle-ref.html == appendmultiple.html appendmultiple-ref.html == insertsingle.html insertsingle-ref.html == insertmultiple.html insertmultiple-ref.html They use convention as: == SOME-TEST.html SOME-TEST-ref.html We should follow their convention unless there is a strong reason against it. As for directory location for reftests, it looks good to me that we reuse existing LayoutTest directory unless there is a significant maintenance issue. 248711 10 simon.fraser 2010-07-08 21:24:44 -0700 (In reply to comment #9) > == appendsingle.html appendsingle-ref.html > == appendmultiple.html appendmultiple-ref.html > == insertsingle.html insertsingle-ref.html > == insertmultiple.html insertmultiple-ref.html > > They use convention as: > == SOME-TEST.html SOME-TEST-ref.html Note also that you can re-use the same reference for multiple tests, so don't assume that each test has a corresponding ref. Also, it's possible to test that the rendering does NOT match the ref, which can also be useful. 248764 11 darin 2010-07-08 23:29:52 -0700 The current tests work without a separate manifest file, and I’d like to see that continue with the ref tests. Or if we switch to a manifest file, I’d like to do it for all the tests. I don’t think matching Mozilla’s convention is as important as matching our own convention! 248783 12 hayato 2010-07-09 00:09:03 -0700 (In reply to comment #11) > The current tests work without a separate manifest file, and I’d like to see that continue with the ref tests. Or if we switch to a manifest file, I’d like to do it for all the tests. > > I don’t think matching Mozilla’s convention is as important as matching our own convention! Thank you for the comment. Okay. I am planning to support both options, a manifest-file based and simple file-naming-convention based. Let me explain that. 1. file-naming-convention based Suppose we have the following html files in a directory: - foo-test-a.html - foo-test-b.html - foo-test-ref.html - bar-test-hello.html - bar-test-world.html - bar-test-fail-ref.html And we don't have files named 'foo-test-a-expected.html', 'foo-test-b-expected.html' and so on, we should consider them as reftests as if they were explicitly specified with manifest file, like: == foo-test-a.html foo-test-ref.html == foo-test-b.html foo-test-ref.html != bar-test-hello.html bar-test-fail-ref.html != bar-test-world.html bar-test-fail-ref.html 2. Manifest based There remains the cases in reftests that we cannot express easily by such a simple naming convention. In that case, we use a manifest files as a last resort. We should try to avoid using manifest file as possible as we can. It might be challenging that making good file-naming convention because reftests used in Mozilla support many kinds of reftests. But I believe we can cover most cases by simple naming conventions. 249029 13 simon.fraser 2010-07-09 08:45:14 -0700 (In reply to comment #11) > I don’t think matching Mozilla’s convention is as important as matching our own convention! Matching Mozilla's convention may be useful if we get large test suites from W3C working groups which use that convention. It would be nice to be able to just share these unchanged. I don't think Manifest maintenance is a burden, and Manifests allow for more testing options. 249034 14 darin 2010-07-09 09:00:56 -0700 (In reply to comment #13) > I don't think Manifest maintenance is a burden, and Manifests allow for more testing options. If we like manifests, I suggest switching the layout test system to use manifests. What I want to avoid is arbitrary combinations and multiple subtly different testing systems. 250980 15 hayato 2010-07-13 22:47:30 -0700 (In reply to comment #14) > (In reply to comment #13) > > I don't think Manifest maintenance is a burden, and Manifests allow for more testing options. > > If we like manifests, I suggest switching the layout test system to use manifests. What I want to avoid is arbitrary combinations and multiple subtly different testing systems. I've tried parsing manifest files used in Mozilla and found that most reftests in Mozilla are 'simple'. I mean about 90 percent of reftests (4263 out of 4710 reftests) are being specified in either == AAAA.html BBBB-ref.html or != CCCC.html DDDD-ref.html. So I am moving to adding a support for simple filename-convention based reftests at first. Note that I am not saying that we don't support a manifest file. It'll be supported later so that we can run reftests imported from Mozilla as is. 256017 16 hayato 2010-07-26 06:35:34 -0700 I am planning to adapt the following naming convention for reftests: 1. foo.html and foo-ref.html We use this naming for a reftest which is expected to match. That corresponds to '= foo.html foo-ref.html' in Mozilla's manifest. 2. foo.html and foo-noref.html We use this naming for a reftest which is expected not to match. That corresponds to '!= foo.html foo-noref.html'. These conventions are commonly used in Mozilla's reftest. (In reply to comment #15) > (In reply to comment #14) > > (In reply to comment #13) > > > I don't think Manifest maintenance is a burden, and Manifests allow for more testing options. > > > > If we like manifests, I suggest switching the layout test system to use manifests. What I want to avoid is arbitrary combinations and multiple subtly different testing systems. > > I've tried parsing manifest files used in Mozilla and found that most reftests in Mozilla are 'simple'. > I mean about 90 percent of reftests (4263 out of 4710 reftests) are being specified in either > == AAAA.html BBBB-ref.html > or > != CCCC.html DDDD-ref.html. > > So I am moving to adding a support for simple filename-convention based reftests at first. > Note that I am not saying that we don't support a manifest file. It'll be supported later so that we can run reftests imported from Mozilla as is. 256021 17 hayato 2010-07-26 06:37:20 -0700 Correction. (In reply to comment #16) > I am planning to adapt the following naming convention for reftests: > > 1. foo.html and foo-ref.html > We use this naming for a reftest which is expected to match. That corresponds to '= foo.html foo-ref.html' in Mozilla's manifest. > > 2. foo.html and foo-noref.html > We use this naming for a reftest which is expected not to match. That corresponds to '!= foo.html foo-noref.html'. '2. foo.html and foo-notref.html' is a correct naming. > > These conventions are commonly used in Mozilla's reftest. > > > (In reply to comment #15) > > (In reply to comment #14) > > > (In reply to comment #13) > > > > I don't think Manifest maintenance is a burden, and Manifests allow for more testing options. > > > > > > If we like manifests, I suggest switching the layout test system to use manifests. What I want to avoid is arbitrary combinations and multiple subtly different testing systems. > > > > I've tried parsing manifest files used in Mozilla and found that most reftests in Mozilla are 'simple'. > > I mean about 90 percent of reftests (4263 out of 4710 reftests) are being specified in either > > == AAAA.html BBBB-ref.html > > or > > != CCCC.html DDDD-ref.html. > > > > So I am moving to adding a support for simple filename-convention based reftests at first. > > Note that I am not saying that we don't support a manifest file. It'll be supported later so that we can run reftests imported from Mozilla as is. 256077 18 mitz 2010-07-26 09:53:33 -0700 Will it upset the tools too much if the ref, noref, etc. were part of the extension instead of part of the filename, e.g. foo.html-ref, foo.html-ref-!= ? 256090 19 aroben 2010-07-26 10:18:35 -0700 (In reply to comment #18) > Will it upset the tools too much if the ref, noref, etc. were part of the extension instead of part of the filename, e.g. foo.html-ref, foo.html-ref-!= ? Would that make it harder to open them in a browser (e.g., by double-clicking in Finder or Windows Explorer)? 256091 20 mitz 2010-07-26 10:19:26 -0700 (In reply to comment #19) > (In reply to comment #18) > > Will it upset the tools too much if the ref, noref, etc. were part of the extension instead of part of the filename, e.g. foo.html-ref, foo.html-ref-!= ? > > Would that make it harder to open them in a browser (e.g., by double-clicking in Finder or Windows Explorer)? Of course it would :( 256445 21 hayato 2010-07-27 01:45:52 -0700 Thank you for the comment. (In reply to comment #18) > Will it upset the tools too much if the ref, noref, etc. were part of the extension instead of part of the filename, e.g. foo.html-ref, foo.html-ref-!= ? Yes, adding xx-{ref,notref}.html to LayoutTest directory will upsets existing tools. Because we will add reftest support to only new-run-webkit-test in the current plan, we have to update other existing tools so that they should ignore such html files related to reftests. If it will take long time to make new-run-webkit-test default test runner, we might reconsider our plan. 256479 22 yuzo 2010-07-27 03:04:03 -0700 It seems that only WebKitTools/Scripts/{old-run-webkit-tests,prepare-ChangeLog} need to be changed to ignore -{not,}ref.html. (See supportedFileExtensions) Because the needed change seems to be simple, I'd recommend just changing those files and going ahead, rather than waiting for new-run-webkit-test. (In reply to comment #21) > Thank you for the comment. > > (In reply to comment #18) > > Will it upset the tools too much if the ref, noref, etc. were part of the extension instead of part of the filename, e.g. foo.html-ref, foo.html-ref-!= ? > > Yes, adding xx-{ref,notref}.html to LayoutTest directory will upsets existing tools. > Because we will add reftest support to only new-run-webkit-test in the current plan, we have to update other existing tools so that they should ignore such html files related to reftests. > > If it will take long time to make new-run-webkit-test default test runner, we might reconsider our plan. 256481 23 yuzo 2010-07-27 03:07:28 -0700 (In reply to comment #22) > It seems that only WebKitTools/Scripts/{old-run-webkit-tests,prepare-ChangeLog} and WebKitTools/Scripts/webkitpy/layout_tests/layout_package/test_files.py > need to be changed to ignore -{not,}ref.html. (See supportedFileExtensions) > > Because the needed change seems to be simple, I'd recommend just changing those files > and going ahead, rather than waiting for new-run-webkit-test. > > (In reply to comment #21) > > Thank you for the comment. > > > > (In reply to comment #18) > > > Will it upset the tools too much if the ref, noref, etc. were part of the extension instead of part of the filename, e.g. foo.html-ref, foo.html-ref-!= ? > > > > Yes, adding xx-{ref,notref}.html to LayoutTest directory will upsets existing tools. > > Because we will add reftest support to only new-run-webkit-test in the current plan, we have to update other existing tools so that they should ignore such html files related to reftests. > > > > If it will take long time to make new-run-webkit-test default test runner, we might reconsider our plan. 260361 24 hayato 2010-08-04 20:26:41 -0700 Update on file naming convention: I've changed my mind to use the following naming conventions for reftests: 1. foo.html and foo-expected.html Which are used for reftests where both rendering results are expected to be equal. 2. foo.html and foo-expected-notequal.html Which are used for reftests where both rendering results are expected to be different. The motivation of this naming is to match existing file name conventions. There are already conventions in WebKit Tests such as , 'xxx-expected.txt', 'xxx-expected.png' and 'xxx-expected.checksum'. So it looks natural for me to use 'xxx-expected.YYY' naming pattern for reftests. 260629 25 dglazkov 2010-08-05 08:39:27 -0700 (In reply to comment #24) > Update on file naming convention: > > I've changed my mind to use the following naming conventions for reftests: > > 1. foo.html and foo-expected.html > Which are used for reftests where both rendering results are expected to be equal. > > 2. foo.html and foo-expected-notequal.html > Which are used for reftests where both rendering results are expected to be different. > > The motivation of this naming is to match existing file name conventions. There are already conventions in WebKit Tests such as , 'xxx-expected.txt', 'xxx-expected.png' and 'xxx-expected.checksum'. So it looks natural for me to use 'xxx-expected.YYY' naming pattern for reftests. Sounds good. 260709 26 darin 2010-08-05 11:13:26 -0700 (In reply to comment #24) > 2. foo.html and foo-expected-notequal.html > Which are used for reftests where both rendering results are expected to be different. I don’t think you should merge the words "not" and "equal" into "notequal". If you can’t think of a better phrase, then I suggest "expected-not-equal.html" but the phrase "expected not equal" is not good grammar, so maybe we can come up with a better phrase. Generally speaking, an entire test that only says "these must not be identical" seems like a pretty blunt tool. I mean, it's good to make sure that bolding actually does something, but an entire test of this sort can only test one thing! That seems to be a general downside of ref tests. Each test can only effectively check one thing. Unlike dumpAsText tests, where we can test a lot of things in a single test. 260717 27 dpranke 2010-08-05 11:25:47 -0700 (In reply to comment #26) > (In reply to comment #24) > > 2. foo.html and foo-expected-notequal.html > > Which are used for reftests where both rendering results are expected to be different. > > I don’t think you should merge the words "not" and "equal" into "notequal". > > If you can’t think of a better phrase, then I suggest "expected-not-equal.html" but the phrase "expected not equal" is not good grammar, so maybe we can come up with a better phrase. > Perhaps "expected-mismatch" or "expected-different" ? 260761 28 darin 2010-08-05 12:18:27 -0700 (In reply to comment #27) > Perhaps "expected-mismatch" or "expected-different" ? I like expected-mismatch. 260784 29 dglazkov 2010-08-05 12:46:28 -0700 (In reply to comment #28) > (In reply to comment #27) > > Perhaps "expected-mismatch" or "expected-different" ? > > I like expected-mismatch. Me too. 262985 30 hayato 2010-08-10 21:11:58 -0700 Thank you for comments. I like xx-expected-mismatch.html too. I'll use that convention. (In reply to comment #29) > (In reply to comment #28) > > (In reply to comment #27) > > > Perhaps "expected-mismatch" or "expected-different" ? > > > > I like expected-mismatch. > > Me too. 287846 31 simon.fraser 2010-09-30 14:43:59 -0700 Any progress here? 288042 32 hayato 2010-09-30 20:45:57 -0700 In progress. I am actually working on adding reftest support. I think I can submit an initial patch in a week or later for an early review. That might have a coule of rooms to be improved, but I need early feedbacks and reviews. (In reply to comment #31) > Any progress here? 296627 33 71245 hayato 2010-10-19 21:25:15 -0700 Created attachment 71245 snapshot 296629 34 hayato 2010-10-19 21:28:19 -0700 The attachment is not for the review. That needs to be polished for the review. I am preparing a patch as an initial effort. (In reply to comment #33) > Created an attachment (id=71245) [details] > snapshot 296637 35 71245 hamaji 2010-10-19 22:05:51 -0700 Comment on attachment 71245 snapshot View in context: https://bugs.webkit.org/attachment.cgi?id=71245&action=review The overall approach looks fine. What is still missing? Maybe reftest_diff.py needs more work? I'm very glad to see reftest is becoming a real! > WebKitTools/Scripts/old-run-webkit-tests:2254 > + if ($filename =~ /-expected(-mismatch)?\.html$/) { expectedTag? Also, we may want to consider adding mismatchTag for consistency? > WebKitTools/Scripts/old-run-webkit-tests:2273 > + if (exists $supportedFileExtensions{$extension}) { I'd say exists $supportedFileExtensions($extension) && !isUsedInReftest($filename) > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:90 > + """Receives the output from a DumpRenderTree process, subjects it to a It would be better to have a summary in the first line of a docstring. PEP257 says "Multi-line docstrings consist of a summary line just like a one-line docstring, followed by a blank line, followed by a more elaborate description.". http://www.python.org/dev/peps/pep-0257/ It's not a strict rule for us, but we are trying to apply style-related PEPs as possible. > WebKitTools/Scripts/webkitpy/layout_tests/port/test_files.py:54 > +_reftest_expected_suffixes = set(['-expected.html', 'expected-mismatch.html']) -expected-mismatch maybe? > WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests.py:141 > + def __repr__(self): Do we need this? For many objects, eval(repr(obj)) should be equal to obj but this definition doesn't satisfy this convention. 296657 36 hayato 2010-10-19 23:54:06 -0700 Thank you for the quick review. I should have added a comment, 'please don't take a look at the attachment in details. The attachment is only for showing an overall approach. That contains a lot of stuff which are only used for debugging' :) It was my fault. I am now polishing my patch for the review. Anyway, thank you for the review. That is helpful. I'll reflect your comments in following patch. (In reply to comment #35) > (From update of attachment 71245 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=71245&action=review > > The overall approach looks fine. What is still missing? Maybe reftest_diff.py needs more work? > > I'm very glad to see reftest is becoming a real! > > > WebKitTools/Scripts/old-run-webkit-tests:2254 > > + if ($filename =~ /-expected(-mismatch)?\.html$/) { > > expectedTag? > > Also, we may want to consider adding mismatchTag for consistency? > > > WebKitTools/Scripts/old-run-webkit-tests:2273 > > + if (exists $supportedFileExtensions{$extension}) { > > I'd say > > exists $supportedFileExtensions($extension) && !isUsedInReftest($filename) > > > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:90 > > + """Receives the output from a DumpRenderTree process, subjects it to a > > It would be better to have a summary in the first line of a docstring. PEP257 says "Multi-line docstrings consist of a summary line just like a one-line docstring, followed by a blank line, followed by a more elaborate description.". > > http://www.python.org/dev/peps/pep-0257/ > > It's not a strict rule for us, but we are trying to apply style-related PEPs as possible. > > > WebKitTools/Scripts/webkitpy/layout_tests/port/test_files.py:54 > > +_reftest_expected_suffixes = set(['-expected.html', 'expected-mismatch.html']) > > -expected-mismatch maybe? > > > WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests.py:141 > > + def __repr__(self): > > Do we need this? For many objects, eval(repr(obj)) should be equal to obj but this definition doesn't satisfy this convention. 296660 37 hamaji 2010-10-20 00:02:33 -0700 > I should have added a comment, 'please don't take a look at the attachment in details. The attachment is only for showing an overall approach. That contains a lot of stuff which are only used for debugging' :) > It was my fault. Yeah, I knew this patch isn't for review. Actually, I didn't review the patch in detail. I put some comments just because I found them while I'm looking your overall approach. 304620 38 72932 hayato 2010-11-04 06:28:37 -0700 Created attachment 72932 snapshot2 304627 39 hayato 2010-11-04 06:54:37 -0700 I've updated my patch. I am aware that this patch is incomplete, such as missing ChangeLog, including unnecessary sample reftests and so on. I'd like to keep this patch as small as possible for easy reviews. So I don't plan to add any features to this patch. Following patches should take care of other necessary changes. By this patch, we can run reftests by adding '--run-reftest' option to new-run-webkit-test . Without '--run-reftests', there should be no impacts to existing LayoutTest infrastructure. I'd like to commit patches incrementally until reftests becomes completely ready status. Early reviews are highly welcome. (In reply to comment #38) > Created an attachment (id=72932) [details] > snapshot2 305245 40 73060 hayato 2010-11-05 06:45:25 -0700 Created attachment 73060 for-review 306087 41 73060 hamaji 2010-11-08 05:07:43 -0800 Comment on attachment 73060 for-review View in context: https://bugs.webkit.org/attachment.cgi?id=73060&action=review Overall this patch looks good. Putting r- because I think you might want to address some of my comments. Also, I think you can make the patch be applicable to ToT ? > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:79 > + # TODO(hayato): It might be better to increase the timeout two times when Please use FIXME instead of TODO > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:81 > + return _milliseconds_to_seconds( Do we really need this line break? > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:108 > test_types: A list of TestType objects to run the test output How about adding "layout" for this comment? "A list of TestType objects to run the *layout* test output" It might be clearer. > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/single_test_runner.py:30 > +"""A test runner which runs a single test file.""" I'd say we'll run either a layout test or a reftest. Runs a single test file (either a layout test or a reftest) or something like this. > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/single_test_runner.py:59 > + test_types, reftest_types): It's nice if we have a docstring with an Args section. > WebKitTools/Scripts/webkitpy/layout_tests/port/webkit.py:142 > + if tolerance is not None: A usual idiom for an optional parameter is if opt_param is None: opt_param = something So, I'd slightly prefer if tolerance is None: if self.get_option('tolerance') is not None: tolerance = self.... else tolerance = 0.1 > WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests.py:125 > + self.expected_mismatch_html_filename = None I think it's very easy to check the case where we have both foo-expected.html and foo-expected-mismatch.html ? Using _log.error would be nice. > WebKitTools/Scripts/webkitpy/layout_tests/test_types/reference_diff.py:50 > + if test_info.expected_html_filename: How about expected = None if test_info.expected_html_filename: ... expected = reference_image_contents else: ... self.write_output_files(...) ? > WebKitTools/Scripts/webkitpy/layout_tests/test_types/test_type_base.py:96 > + """Copies result files into the output directory with appropriate The first line of a docstring should be one line. I think "with appropriate names" has almost no information so I'd remove this. I guess the Args will tell what name is appropriate? 307138 42 73454 hayato 2010-11-09 20:12:52 -0800 Created attachment 73454 synced-to-tot 307142 43 hayato 2010-11-09 20:20:03 -0800 Thank you for the review. I've addressed all your comments. I also synched and rebased my patch to ToT. I've confirmed that all tests run by WebKitTools/Scripts/test-webkit-scripts passed even after applying this patch. I think I need to add more tests to test-webkit-scripts. But it would be in another patch. (In reply to comment #41) > (From update of attachment 73060 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=73060&action=review > > Overall this patch looks good. Putting r- because I think you might want to address some of my comments. Also, I think you can make the patch be applicable to ToT ? > > > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:79 > > + # TODO(hayato): It might be better to increase the timeout two times when > > Please use FIXME instead of TODO > > > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:81 > > + return _milliseconds_to_seconds( > > Do we really need this line break? > > > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:108 > > test_types: A list of TestType objects to run the test output > > How about adding "layout" for this comment? "A list of TestType objects to run the *layout* test output" It might be clearer. > > > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/single_test_runner.py:30 > > +"""A test runner which runs a single test file.""" > > I'd say we'll run either a layout test or a reftest. > > Runs a single test file (either a layout test or a reftest) > > or something like this. > > > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/single_test_runner.py:59 > > + test_types, reftest_types): > > It's nice if we have a docstring with an Args section. > > > WebKitTools/Scripts/webkitpy/layout_tests/port/webkit.py:142 > > + if tolerance is not None: > > A usual idiom for an optional parameter is > > if opt_param is None: > opt_param = something > > So, I'd slightly prefer > > if tolerance is None: > if self.get_option('tolerance') is not None: > tolerance = self.... > else > tolerance = 0.1 > > > WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests.py:125 > > + self.expected_mismatch_html_filename = None > > I think it's very easy to check the case where we have both foo-expected.html and foo-expected-mismatch.html ? Using _log.error would be nice. > > > WebKitTools/Scripts/webkitpy/layout_tests/test_types/reference_diff.py:50 > > + if test_info.expected_html_filename: > > How about > > expected = None > if test_info.expected_html_filename: > ... > expected = reference_image_contents > else: > ... > self.write_output_files(...) > > ? > > > WebKitTools/Scripts/webkitpy/layout_tests/test_types/test_type_base.py:96 > > + """Copies result files into the output directory with appropriate > > The first line of a docstring should be one line. I think "with appropriate names" has almost no information so I'd remove this. I guess the Args will tell what name is appropriate? 307147 44 hayato 2010-11-09 20:33:50 -0800 One more note: This patch is adding new test_result_type in json result file as follows: test_expectations.REFERENCE_MISMATCH: "R", test_expectations.REFERENCE_MATCH: "M", So I guess buildbots will need to understand these kinds of test result. (In reply to comment #43) > Thank you for the review. > > I've addressed all your comments. I also synched and rebased my patch to ToT. > I've confirmed that all tests run by WebKitTools/Scripts/test-webkit-scripts passed even after applying this patch. > > I think I need to add more tests to test-webkit-scripts. But it would be in another patch. > > > (In reply to comment #41) > > (From update of attachment 73060 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=73060&action=review > > > > Overall this patch looks good. Putting r- because I think you might want to address some of my comments. Also, I think you can make the patch be applicable to ToT ? > > > > > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:79 > > > + # TODO(hayato): It might be better to increase the timeout two times when > > > > Please use FIXME instead of TODO > > > > > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:81 > > > + return _milliseconds_to_seconds( > > > > Do we really need this line break? > > > > > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/dump_render_tree_thread.py:108 > > > test_types: A list of TestType objects to run the test output > > > > How about adding "layout" for this comment? "A list of TestType objects to run the *layout* test output" It might be clearer. > > > > > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/single_test_runner.py:30 > > > +"""A test runner which runs a single test file.""" > > > > I'd say we'll run either a layout test or a reftest. > > > > Runs a single test file (either a layout test or a reftest) > > > > or something like this. > > > > > WebKitTools/Scripts/webkitpy/layout_tests/layout_package/single_test_runner.py:59 > > > + test_types, reftest_types): > > > > It's nice if we have a docstring with an Args section. > > > > > WebKitTools/Scripts/webkitpy/layout_tests/port/webkit.py:142 > > > + if tolerance is not None: > > > > A usual idiom for an optional parameter is > > > > if opt_param is None: > > opt_param = something > > > > So, I'd slightly prefer > > > > if tolerance is None: > > if self.get_option('tolerance') is not None: > > tolerance = self.... > > else > > tolerance = 0.1 > > > > > WebKitTools/Scripts/webkitpy/layout_tests/run_webkit_tests.py:125 > > > + self.expected_mismatch_html_filename = None > > > > I think it's very easy to check the case where we have both foo-expected.html and foo-expected-mismatch.html ? Using _log.error would be nice. > > > > > WebKitTools/Scripts/webkitpy/layout_tests/test_types/reference_diff.py:50 > > > + if test_info.expected_html_filename: > > > > How about > > > > expected = None > > if test_info.expected_html_filename: > > ... > > expected = reference_image_contents > > else: > > ... > > self.write_output_files(...) > > > > ? > > > > > WebKitTools/Scripts/webkitpy/layout_tests/test_types/test_type_base.py:96 > > > + """Copies result files into the output directory with appropriate > > > > The first line of a docstring should be one line. I think "with appropriate names" has almost no information so I'd remove this. I guess the Args will tell what name is appropriate? 307220 45 dpranke 2010-11-10 00:45:01 -0800 Hi Ito-san, It's great that you're getting so close, and I apologize for not getting to look at this earlier. I will post more detailed comments tomorrow afternoon, but here's some initial thoughts on the general approach. 1) this is not going to be a pretty merge with the changes I'm making to restructure the code to use processes instead of threads, but it shouldn't be horrible, either. One amusing side effect is that you've moved all of the real testing work out of dump_render_tree_thread and into single_test_runner; My patch moves all of the non-testing work out of dump_render_tree_thread. It'll probably be easier if you keep the two files combined for now. 2) I'm not sure that we want to expose the concept of a reftest as an alternative to a regular test; I'm wondering if we can instead restructure things so that port.expected_text/expected_checksum/expected_image returns the output of the reftest run if there's a reftest, and the checked-in output otherwise. Of course, we'd have to replace the three routines with a single routine that returned all of the types of output. I'm guessing you've already thought about this approach and rejected it in favor of the approach you have now? As you correctly note somewhere in the patch, it would be weird to have both reference tests and reference output, so we should make that impossible. 3) I wonder if it makes sense to have reftests that produce only text output, or should they always produce both text and images? Or does it make sense if they *only* produce an image? Will the render tree be different for the reference and the test? The same? Either/or? Do we need to support all of the possibilities? Anyway, more tomorrow ... 307226 46 dpranke 2010-11-10 00:47:43 -0800 Caveat - I didn't actually read through the whole bug again before reading the patch (or any of the referenced links), so I may have asked questions that have already been answered. I will read through everything again tomorrow, so if it makes sense, you can hold off on pointing out my stupidity until I can catch it myself :) 307725 47 hayato 2010-11-10 21:33:46 -0800 Hi Dirk, Thank you for comments, I appreciate that! (In reply to comment #45) > Hi Ito-san, > > It's great that you're getting so close, and I apologize for not getting to look at this earlier. I will post more detailed comments tomorrow afternoon, but here's some initial thoughts on the general approach. > > 1) this is not going to be a pretty merge with the changes I'm making to restructure the code to use processes instead of threads, but it shouldn't be horrible, either. One amusing side effect is that you've moved all of the real testing work out of dump_render_tree_thread and into single_test_runner; My patch moves all of the non-testing work out of dump_render_tree_thread. It'll probably be easier if you keep the two files combined for now. > Thank you for letting me know it. I'll try to merge that later if needed. That should not be a problem, I think. > 2) I'm not sure that we want to expose the concept of a reftest as an alternative to a regular test; I'm wondering if we can instead restructure things so that port.expected_text/expected_checksum/expected_image returns the output of the reftest run if there's a reftest, and the checked-in output otherwise. Of course, we'd have to replace the three routines with a single routine that returned all of the types of output. > > I'm guessing you've already thought about this approach and rejected it in favor of the approach you have now? Exactly! I feel happy to hear you thought the same thing as I thought:) In fact, I tried to take that approach at first, which seems a natural expansion. Let me explain briefly. At first attempt, I tried to simply add a test type of ReferenceDiff and put it to test_types and run each test_type against both existing layout tests and reftests. I'd like to treat them uniformly. But I abandoned this idea due to the following reasons as far as I remember: - It requires many tweaks to handle each combination of results from each test type (a list of test_failures). The code became messy. - I tried to get expected_image for reftest on demand within compare_output(), but that need to run 'driver' again. My impression on current code base tells that when we call _process_output (and compare_output() that follows), we should finish all time-consuming tasks by then. I'd like to avoid calling DumpRenderTree again there. It doesn't look good to me. I found that there are some 'gaps' between both tests than I expected initially. So instead of struggling to apply compare_output() function to reftests for consistency, I just introduced new compare function, compare_actual_output_with_reference(). The overall code became simple by early branching codepath between layout tests and reftests. I am aware that this patch is not ideal from the point of view in OO design. Actually there is no significant reason that a test type of ReferenceDiff is a subtype of TestBaseType. Sigh. > > As you correctly note somewhere in the patch, it would be weird to have both reference tests and reference output, so we should make that impossible. > > 3) I wonder if it makes sense to have reftests that produce only text output, or should they always produce both text and images? Or does it make sense if they *only* produce an image? Will the render tree be different for the reference and the test? The same? Either/or? Do we need to support all of the possibilities? Nice point. I tried to use one test file for both layout tests and reftest, supporting all of the combinations. But I have no confidence that there are enough use cases for that. So until we found that many developers really want to use one test file for both tests and found a nice way to treat them together, I'd like to be conservative and separate existing layout tests and reftests. I am looking forward to your more feed backs. Thank you! > > Anyway, more tomorrow ... 307727 48 hamaji 2010-11-10 21:47:07 -0800 > > 2) I'm not sure that we want to expose the concept of a reftest as an alternative to a regular test; I'm wondering if we can instead restructure things so that port.expected_text/expected_checksum/expected_image returns the output of the reftest run if there's a reftest, and the checked-in output otherwise. Of course, we'd have to replace the three routines with a single routine that returned all of the types of output. > > > > I'm guessing you've already thought about this approach and rejected it in favor of the approach you have now? > > Exactly! I feel happy to hear you thought the same thing as I thought:) In fact, I tried to take that approach at first, which seems a natural expansion. Let me explain briefly. > > At first attempt, I tried to simply add a test type of ReferenceDiff and put it to test_types and run each test_type against both existing layout tests and reftests. I'd like to treat them uniformly. > But I abandoned this idea due to the following reasons as far as I remember: > > - It requires many tweaks to handle each combination of results from each test type (a list of test_failures). The code became messy. > - I tried to get expected_image for reftest on demand within compare_output(), but that need to run 'driver' again. > My impression on current code base tells that when we call _process_output (and compare_output() that follows), we should finish all time-consuming tasks by then. I'd like to avoid calling DumpRenderTree again there. It doesn't look good to me. > > I found that there are some 'gaps' between both tests than I expected initially. So instead of struggling to apply compare_output() function to reftests for consistency, I just introduced new compare function, compare_actual_output_with_reference(). > The overall code became simple by early branching codepath between layout tests and reftests. > > I am aware that this patch is not ideal from the point of view in OO design. Actually there is no significant reason that a test type of ReferenceDiff is a subtype of TestBaseType. Sigh. I'm not sure if I understand this discussion well, but I'd like to mention supporting "expected-mismatch" would make reusing existing code a bit more difficult. > > 3) I wonder if it makes sense to have reftests that produce only text output, or should they always produce both text and images? Or does it make sense if they *only* produce an image? Will the render tree be different for the reference and the test? The same? Either/or? Do we need to support all of the possibilities? > > Nice point. I tried to use one test file for both layout tests and reftest, supporting all of the combinations. But I have no confidence that there are enough use cases for that. > So until we found that many developers really want to use one test file for both tests and found a nice way to treat them together, I'd like to be conservative and separate existing layout tests and reftests. I think text diff is pretty useful and we need text diff soon or later. The images DRT output only have 800x600 pixels so some mismatch could be ignored if an HTML is big. 307747 49 dpranke 2010-11-10 23:40:50 -0800 Okay, it is later than I had hoped for and I didn't have time to review all of the Mozilla documentation. So, as far as Mozilla-compatibility goes, I will say for the moment that I think we need to burn some serious brain cycles on how we can develop interoperable test suites. But, I think that that should be viewed as a separate effort from getting reftests working initially in WebKit. I plan to follow up on this w/ Hixie and Tab Atkins and can happily involve whomever is cc'ed on this list who is interested - let me know off-bug. 307753 50 dpranke 2010-11-11 00:10:14 -0800 (In reply to comment #47) > At first attempt, I tried to simply add a test type of ReferenceDiff and put it to test_types and run each test_type against both existing layout tests and reftests. I'd like to treat them uniformly. > But I abandoned this idea due to the following reasons as far as I remember: > > - It requires many tweaks to handle each combination of results from each test type (a list of test_failures). The code became messy. > - I tried to get expected_image for reftest on demand within compare_output(), but that need to run 'driver' again. > My impression on current code base tells that when we call _process_output (and compare_output() that follows), we should finish all time-consuming tasks by then. I'd like to avoid calling DumpRenderTree again there. It doesn't look good to me. > I don't think I expressed myself well in the previous comment. What I was trying to say is that I think reftests are just a way of generating the expected output that we should compare the actual output to. They aren't actually a different kind of test. So, you don't need to create ReferenceDiffs or add different reference test result types or expectations. I think virtually all, if not all, of the changes can (or perhaps should) be confined to dump_render_tree_thread.py . The major implication of this is that the test_types classes need to be refactored to have the expected output passed in to them. I have also been considering pulling all of the --new-baseline logic out of test_types, because it feels wrong to be there as well, but I go off on a tangent. You are definitely correct that _process_output and _compare_output should be fast and stable, and so we definitely shouldn't call out to DRT again inside them. The method signatures are also really clumsy. Part of the refactoring I hope to land in the next couple days will introduce something like a TestResult class that holds many of the arguments passed to process_output() current (and that also becomes a method on TestShellThread, much like you've done in SingleTestRunner). I realize that this'll play substantial havoc with your patch, but it feels pretty strongly to me at the moment that it's the right thing to do. I'll cc you on the other patches so you can see the changes I'm talking about. Note that what I'm saying implies that, for a given test, we can only do regular tests against checked-in output or tests against an -expected.html file, not both. I think that this is fine and preferable in the long run. I don't think there will be much of an issue here, because we don't have any existing ref tests that we need to support. We can just start adding new ones. Does this sound good? Are there issues that you've run into that I'm not yet seeing? > > 3) I wonder if it makes sense to have reftests that produce only text output, or should they always produce both text and images? Or does it make sense if they *only* produce an image? Will the render tree be different for the reference and the test? The same? Either/or? Do we need to support all of the possibilities? > > Nice point. I tried to use one test file for both layout tests and reftest, supporting all of the combinations. But I have no confidence that there are enough use cases for that. I'm not sure if we understood each other here, but I'm not sure if it matters. Let me explain why ... from conversations today with Dimitri and Darin, I think we agreed that there are only two kinds of reftests that matter. The first is a text-only test (dumpAsText or dumpAsMarkup). The second is an image-only test, where we care about the pixels being rendered but don't care at all about the render tree. I *think* in the first case any two text-only sets of output could probably be rewritten as a single test that produced text only output (you could merge the test.html and test-expected.html into one single test file that produced an -expected.txt text-only output). Conservatively, even if we don't do this, it still reduces to comparing two text files, which of course we support now. Similarly, comparing two image files is already supported. There's nothing special about the fact that the one image was generated from a -expected.html file instead of checked in as -expected.png. So I think, to answer my own questions, we don't need to support any possibilities with reftests beyond what we already have (and, in fact, we probably have fewer combinations, since we won't have IMAGE+TEXT). I will also note that Hamaji-san raises a good point - I can't forget about -expected-mismatch.html, so compare_output probably needs to grow a match/mismatch bool. Or, maybe better, when we create the new TestResult object we pass in the flag and it inverts the result of test_failures.determine_result_type() as necessary. 307776 51 hayato 2010-11-11 00:57:18 -0800 Hi Dirk, Thank you for comments. I appreciate that. In short answer, I agree. I agree that a refrest is a just yet another way to generate expected image or text. I had noticed that indeed. But I also found that it was difficult to realize that in current codebase without an aggressive refactoring. It seems that I should have refactored the code base more eagerly without *fear*. Maybe I am a little bit biased to reusing existing codebase as soon as possible. If such a refactoring is a way to go, I'd like to do it. Maybe I should wait for your patch in the next couple of days. (In reply to comment #50) > (In reply to comment #47) > > At first attempt, I tried to simply add a test type of ReferenceDiff and put it to test_types and run each test_type against both existing layout tests and reftests. I'd like to treat them uniformly. > > But I abandoned this idea due to the following reasons as far as I remember: > > > > - It requires many tweaks to handle each combination of results from each test type (a list of test_failures). The code became messy. > > - I tried to get expected_image for reftest on demand within compare_output(), but that need to run 'driver' again. > > My impression on current code base tells that when we call _process_output (and compare_output() that follows), we should finish all time-consuming tasks by then. I'd like to avoid calling DumpRenderTree again there. It doesn't look good to me. > > > > I don't think I expressed myself well in the previous comment. What I was trying to say is that I think reftests are just a way of generating the expected output that we should compare the actual output to. They aren't actually a different kind of test. So, you don't need to create ReferenceDiffs or add different reference test result types or expectations. I think virtually all, if not all, of the changes can (or perhaps should) be confined to dump_render_tree_thread.py . > > The major implication of this is that the test_types classes need to be refactored to have the expected output passed in to them. I have also been considering pulling all of the --new-baseline logic out of test_types, because it feels wrong to be there as well, but I go off on a tangent. > > You are definitely correct that _process_output and _compare_output should be fast and stable, and so we definitely shouldn't call out to DRT again inside them. The method signatures are also really clumsy. > > Part of the refactoring I hope to land in the next couple days will introduce something like a TestResult class that holds many of the arguments passed to process_output() current (and that also becomes a method on TestShellThread, much like you've done in SingleTestRunner). I realize that this'll play substantial havoc with your patch, but it feels pretty strongly to me at the moment that it's the right thing to do. I'll cc you on the other patches so you can see the changes I'm talking about. > > Note that what I'm saying implies that, for a given test, we can only do regular tests against checked-in output or tests against an -expected.html file, not both. I think that this is fine and preferable in the long run. I don't think there will be much of an issue here, because we don't have any existing ref tests that we need to support. We can just start adding new ones. > > Does this sound good? Are there issues that you've run into that I'm not yet seeing? > > > > 3) I wonder if it makes sense to have reftests that produce only text output, or should they always produce both text and images? Or does it make sense if they *only* produce an image? Will the render tree be different for the reference and the test? The same? Either/or? Do we need to support all of the possibilities? > > > > Nice point. I tried to use one test file for both layout tests and reftest, supporting all of the combinations. But I have no confidence that there are enough use cases for that. > > I'm not sure if we understood each other here, but I'm not sure if it matters. Let me explain why ... > from conversations today with Dimitri and Darin, I think we agreed that there are only two kinds of reftests that matter. The first is a text-only test (dumpAsText or dumpAsMarkup). The second is an image-only test, where we care about the pixels being rendered but don't care at all about the render tree. > > I *think* in the first case any two text-only sets of output could probably be rewritten as a single test that produced text only output (you could merge the test.html and test-expected.html into one single test file that produced an -expected.txt text-only output). Conservatively, even if we don't do this, it still reduces to comparing two text files, which of course we support now. > > Similarly, comparing two image files is already supported. There's nothing special about the fact that the one image was generated from a -expected.html file instead of checked in as -expected.png. So I think, to answer my own questions, we don't need to support any possibilities with reftests beyond what we already have (and, in fact, we probably have fewer combinations, since we won't have IMAGE+TEXT). > > I will also note that Hamaji-san raises a good point - I can't forget about -expected-mismatch.html, so compare_output probably needs to grow a match/mismatch bool. Or, maybe better, when we create the new TestResult object we pass in the flag and it inverts the result of test_failures.determine_result_type() as necessary. 308027 52 dpranke 2010-11-11 11:41:34 -0800 (In reply to comment #51) > Hi Dirk, > Thank you for comments. I appreciate that. > > In short answer, I agree. > > I agree that a refrest is a just yet another way to generate expected image or text. > I had noticed that indeed. But I also found that it was difficult to realize that in current codebase without an aggressive refactoring. > It could be that I know this codebase well, or it could be that I'm just overly aggressive, but I have no fear of this :) The good news is that this code is very well tested, so you can make changes without too much concern. run_webkit_tests_unittest.py is your friend. > If such a refactoring is a way to go, I'd like to do it. Terrific! Having thought abou this overnight, I think you can make most of the changes without colliding too much with the changes I'm working on. I suggest approaching this by working on a completely separate patch that refactors the code as it's currently checked in, and create a TestOutput POD (plain old data) class that is returned from port.Driver.run_test(), and then create a separate instance for the"expected" results, and then pass the two to _process_output() and the test_types routines. Once you do that, adding in reftest support to generate a different expected output instance should be straightforward. 308450 53 hayato 2010-11-12 02:04:50 -0800 (In reply to comment #52) Hi Dirk, Thank you for the commet. I've refactored the current code as a completely separate patch. Please see: https://bugs.webkit.org/show_bug.cgi?id=49431 Could you review this patch? > Having thought abou this overnight, I think you can make most of the changes without colliding too much with the changes I'm working on. I suggest approaching this by working on a completely separate patch that refactors the code as it's currently checked in, and create a TestOutput POD (plain old data) class that is returned from port.Driver.run_test(), and then create a separate instance for the"expected" results, and then pass the two to _process_output() and the test_types routines. 359763 54 hayato 2011-03-01 02:28:53 -0800 Let me update the current status. Now, I've finished the necessary refactoring for new-run-webkit-tests, I just started to work on adding reftests support. I hope I can post a patch in a few days. 364333 55 hayato 2011-03-08 23:28:37 -0800 I am starting to write Wiki page about how to use reftests. https://trac.webkit.org/wiki/Writing%20Reftests 364389 56 hayato 2011-03-09 02:21:46 -0800 I am aiming to add reftest support to new-run-webkit-tests in this quarter. But I think new-run-webkit-tests has not replaced old-run-webkit-tests yet. I am updating old-run-webkit-tests so that it ignores reftests: https://bugs.webkit.org/show_bug.cgi?id=55936 But I am not sure which means that we can check in reftests in LayoutTests directory. Should we refrain us from checking in reftests until new-run-webkit-tests replaces old-run-webkit-tests? Ojan gave me an idea: .. we might be able to get away with adding a mode to new-run-webkit-tests to run just the reftests and then shelling out from run-webkit-tests to new-run-webkit-tests or just requiring people to run both until new-run-webkit-tests replaces old-run-webkit-tests. But I am not sure what is the best way. Could someone summarize where old-run-webkit-tests is used? 364449 57 aroben 2011-03-09 05:28:38 -0800 (In reply to comment #56) > Could someone summarize where old-run-webkit-tests is used? No one uses new-run-webkit-tests by default. See Tools/Scripts/run-webkit-tests, which decides whether NRWT or ORWT is used. I think there are a few configurations that explicitly use NRWT (Chromium?) on their bots. My understanding is that NRWT does not work at all on some platforms, and thus shelling out to it is not an option. Dirk Pranke would know more, though. 364699 58 dpranke 2011-03-09 12:34:32 -0800 (In reply to comment #57) > (In reply to comment #56) > > Could someone summarize where old-run-webkit-tests is used? > > No one uses new-run-webkit-tests by default. See Tools/Scripts/run-webkit-tests, which decides whether NRWT or ORWT is used. I think there are a few configurations that explicitly use NRWT (Chromium?) on their bots. Well, Chromium uses NRWT by default ;) ORWT doesn't even work w/ Chromium. > > My understanding is that NRWT does not work at all on some platforms, and thus shelling out to it is not an option. Dirk Pranke would know more, though. NRWT works everywhere but on the base Win platform AFAIK. I believe GTK team has a bot that runs NRWT regularly. As soon as I wrap up my current project (should happen this week), I plan to start the push to get NRWT working and running everywhere by default. I'd like to use reftests as one of the carrots for this, along with the speed increases and the fact that it's being actively maintained. So, I suggest we do the minimal amount of work on ORWT necessary to not break things. I'm not expecting a huge influx of reftests over the next few weeks, so hopefully this is the right strategy. 364701 59 darin 2011-03-09 12:37:15 -0800 (In reply to comment #58) > NRWT works everywhere but on the base Win platform AFAIK. I am surprised to hear it has WebKit2 support. 364705 60 dpranke 2011-03-09 12:39:58 -0800 (In reply to comment #59) > (In reply to comment #58) > > NRWT works everywhere but on the base Win platform AFAIK. > > I am surprised to hear it has WebKit2 support. Ah, right. Yeah, it doesn't work with WebKit2, either. I haven't yet looked into how hard it will be to add that, but I expect it should be pretty trivial. 365015 61 hayato 2011-03-09 23:33:53 -0800 Thank you for the info. Giving that new-run-webkit-tests doesn't run on all platforms, it might not be worth adding a 'reftest' mode, which runs only reftests, to new-run-webkit-tests because that won't improve the situations at all. So for a while, reftests will be only available to platforms which run new-run-webkit-tests. To choose reftests or not to choose is a test writer's freedom, but they should be aware that old-run-webkit-tests skips reftests when choosing reftests in writing new tests, I think. (In reply to comment #57) > (In reply to comment #56) > > Could someone summarize where old-run-webkit-tests is used? > > No one uses new-run-webkit-tests by default. See Tools/Scripts/run-webkit-tests, which decides whether NRWT or ORWT is used. I think there are a few configurations that explicitly use NRWT (Chromium?) on their bots. > > My understanding is that NRWT does not work at all on some platforms, and thus shelling out to it is not an option. Dirk Pranke would know more, though. 365522 62 darin 2011-03-10 14:04:32 -0800 I think it was great when we renamed Chromium’s test runner to new-run-webkit-tests and renamed the old test runner to old-run-webkit-tests, implying that some day we would all switch to it the Chromium one. As long as it’s only used by Chromium, though, that name change isn’t so significant. When will the transition happen? Who is maintaining the list of things we need to do to new-run-webkit-tests before we can switch everyone to it? Is there a bug tracking this effort? 365541 63 mihaip 2011-03-10 14:31:10 -0800 (In reply to comment #62) > When will the transition happen? Who is maintaining the list of things we need to do to new-run-webkit-tests before we can switch everyone to it? Is there a bug tracking this effort? Bug 34984 is the master bug for switching to NRWT, it depends on a bunch of others. 365638 64 dpranke 2011-03-10 16:29:47 -0800 (In reply to comment #63) > (In reply to comment #62) > > When will the transition happen? Who is maintaining the list of things we need to do to new-run-webkit-tests before we can switch everyone to it? Is there a bug tracking this effort? > > Bug 34984 is the master bug for switching to NRWT, it depends on a bunch of others. Darin, I've added you to that bug, taken ownership of it, and added a comment. I will be putting together a better list of the remaining tasks soon. 368720 65 hayato 2011-03-16 18:58:15 -0700 Let me update the status. - new-run-webkit-tests now supports reftest. https://bugs.webkit.org/show_bug.cgi?id=55457 was landed. - old-run-webkit-tests now ignores reftests. https://bugs.webkit.org/show_bug.cgi?id=55936 was landed. I think that I had done all required changes so that we can check in reftests to the LayoutTests directory. All build bots or dashboard shouldn't be upset even if reftests are checked-in. I tried to maintain compatibility with that existing LayoutTest infrastructure as possible as I can. In order to know what will happen and what additional supports we should add, I'll check-in the first minimum sample reftest here: https://bugs.webkit.org/show_bug.cgi?id=56450 If I am missing something, please let me know. 375123 66 hayato 2011-03-29 02:02:26 -0700 I confirmed that the first reftest didn't upset any build bots. So I think it is ready to check-in reftests as long as test writers are aware that reftests work only with new-run-webkit-tests. I've updated the Wiki, https://trac.webkit.org/wiki/Writing%20Reftests, so that it emphasizes this limitation. Also I'd like to know what changes are nice to have in flakiness dashboard. That should work as is. But I think there are some areas to be improved in flakiness dashboard for reftests. (In reply to comment #65) > Let me update the status. > > - new-run-webkit-tests now supports reftest. > https://bugs.webkit.org/show_bug.cgi?id=55457 was landed. > > - old-run-webkit-tests now ignores reftests. > https://bugs.webkit.org/show_bug.cgi?id=55936 was landed. > > I think that I had done all required changes so that we can check in reftests to the LayoutTests directory. > > All build bots or dashboard shouldn't be upset even if reftests are checked-in. I tried to maintain compatibility with that existing LayoutTest infrastructure as possible as I can. > > In order to know what will happen and what additional supports we should add, I'll check-in the first minimum sample reftest here: > https://bugs.webkit.org/show_bug.cgi?id=56450 > > > If I am missing something, please let me know. 376093 67 ojan 2011-03-30 00:11:31 -0700 You'll need to update http://codesearch.google.com/codesearch/p#OAMlx_jo-ck/tools/dashboards/flakiness_dashboard.html&l=2292 to load the -mismatch.html and -expected.html files when showing results, e.g. at http://test-results.appspot.com/dashboards/flakiness_dashboard.html#tests=fast%2Fharness%2Ffont-weight-bold.html&showExpectations=true 381178 68 hayato 2011-04-07 01:28:59 -0700 Hi, Ojan Thank for the info. I filed it as http://code.google.com/p/chromium/issues/detail?id=78698. (In reply to comment #67) > You'll need to update http://codesearch.google.com/codesearch/p#OAMlx_jo-ck/tools/dashboards/flakiness_dashboard.html&l=2292 to load the -mismatch.html and -expected.html files when showing results, e.g. at http://test-results.appspot.com/dashboards/flakiness_dashboard.html#tests=fast%2Fharness%2Ffont-weight-bold.html&showExpectations=true 525559 69 dpranke 2011-12-21 14:06:21 -0800 can we close this now? 525561 70 darin 2011-12-21 14:06:46 -0800 I am going to do that. 71245 2010-10-19 21:25:15 -0700 2010-11-04 06:28:29 -0700 snapshot bug-36065-20101020132513.patch text/plain 58980 hayato ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC9iYWQtcmVmdGVzdC1leHBlY3RlZC5odG1s IGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2JhZC1yZWZ0ZXN0LWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uMTNkOGFmMzk5OGU3MjBmMjQ4MWE2MDRiYWZjNzExODQ5OTUyZGEyNgotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL215dGVzdC9iYWQtcmVmdGVzdC1leHBlY3RlZC5odG1sCkBAIC0w LDAgKzEgQEAKK0hlbGxvbwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L2JhZC1yZWZ0 ZXN0Lmh0bWwgYi9MYXlvdXRUZXN0cy9teXRlc3QvYmFkLXJlZnRlc3QuaHRtbApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5lOTY1MDQ3YWQ3YzU3ODY1ODIzYzdkOTkyYjFkMDQ2ZWE2NmVkZjc4Ci0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2JhZC1yZWZ0ZXN0Lmh0bWwKQEAgLTAsMCArMSBAQAor SGVsbG8KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC9iYWQtcmVmdGVzdDItZXhwZWN0 ZWQuaHRtbCBiL0xheW91dFRlc3RzL215dGVzdC9iYWQtcmVmdGVzdDItZXhwZWN0ZWQuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi40YTc0NzYxZDY5OGZkYjYzNzhjOWI5NWJkMmE4MTY5ZDkzMDhiMTE5Ci0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2JhZC1yZWZ0ZXN0Mi1leHBlY3RlZC5o dG1sCkBAIC0wLDAgKzEgQEAKK21ZIG5hbWUgaXMgQmFyLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvbXl0ZXN0L2JhZC1yZWZ0ZXN0Mi5odG1sIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2JhZC1yZWZ0 ZXN0Mi5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjlmMDIwNTIzMjkyY2M3ZmFhZjUyMWI4OGQ2NTBjYTJlNmFj OTYzN2QKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9teXRlc3QvYmFkLXJlZnRlc3Qy Lmh0bWwKQEAgLTAsMCArMSBAQAorTXkgbmFtZSBpcyBGb28uCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9teXRlc3QvY29leGlzdC1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2Nv ZXhpc3QtZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40OTBkMjdlNzEyZDBmNWYzZWU2MWNkZDM1 YmExNGFiM2Q2NWEzNThhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2Nv ZXhpc3QtZXhwZWN0ZWQuaHRtbApAQCAtMCwwICsxLDQgQEAKKzxwPgorICAgIFN1Y2Nlc3MgVGVz dCBIb28KKzwvcD4KKzxkaXYgaWQ9InRhcmdldCIgc3R5bGU9ImRpc3BsYXk6IG5vbmU7Ij48L2Rp dj4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC9jb2V4aXN0LWV4cGVjdGVkLnR4dCBi L0xheW91dFRlc3RzL215dGVzdC9jb2V4aXN0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lYzMx MDM0OGRmZGFhODhjYjVjYmVjZTE3MjdmYjhiZjJjYmQ5NzlmCi0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvbXl0ZXN0L2NvZXhpc3QtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEgQEAKK1N1 Y2Nlc3MgVGVzdApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L2NvZXhpc3QuaHRtbCBi L0xheW91dFRlc3RzL215dGVzdC9jb2V4aXN0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNGNiMTMxZDQxYmY3 NDYwOGQ3ZDA0ZWQ2MzJmNDFkY2U1ODVlZjUyZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRl c3RzL215dGVzdC9jb2V4aXN0Lmh0bWwKQEAgLTAsMCArMSw4IEBACis8cD4KKyAgICBTdWNjZXNz IFRlc3QKKzwvcD4KKzxkaXYgaWQ9InRhcmdldCIgc3R5bGU9ImRpc3BsYXk6IG5vbmU7Ij48L2Rp dj4KKzwhLS0gPHNjcmlwdD4gLS0+Cis8IS0tICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250 cm9sbGVyKSAtLT4KKzwhLS0gICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0 KCk7IC0tPgorPCEtLSA8L3NjcmlwdD4gLS0+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9teXRl c3QvZ29vZC1yZWZ0ZXN0LWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRUZXN0cy9teXRlc3QvZ29vZC1y ZWZ0ZXN0LWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNTU3ZGIwM2RlOTk3Yzg2YTRhMDI4ZTFl YmQzYTFjZWIyMjViZTIzOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL215dGVzdC9n b29kLXJlZnRlc3QtZXhwZWN0ZWQuaHRtbApAQCAtMCwwICsxIEBACitIZWxsbyBXb3JsZApkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L2dvb2QtcmVmdGVzdC5odG1sIGIvTGF5b3V0VGVz dHMvbXl0ZXN0L2dvb2QtcmVmdGVzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjU1N2RiMDNkZTk5N2M4NmE0 YTAyOGUxZWJkM2ExY2ViMjI1YmUyMzgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9t eXRlc3QvZ29vZC1yZWZ0ZXN0Lmh0bWwKQEAgLTAsMCArMSBAQAorSGVsbG8gV29ybGQKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL215dGVzdC9nb29kLXJlZnRlc3QyLWV4cGVjdGVkLmh0bWwgYi9M YXlvdXRUZXN0cy9teXRlc3QvZ29vZC1yZWZ0ZXN0Mi1leHBlY3RlZC5odG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjEwZGRkNmQyNTdlMDEzNDlkNTE0NTQxOTgxYWVlY2VhNmIyZTc0MWQKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9teXRlc3QvZ29vZC1yZWZ0ZXN0Mi1leHBlY3RlZC5odG1sCkBAIC0w LDAgKzEgQEAKK0hlbGxvIQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L2dvb2QtcmVm dGVzdDIuaHRtbCBiL0xheW91dFRlc3RzL215dGVzdC9nb29kLXJlZnRlc3QyLmh0bWwKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uMTBkZGQ2ZDI1N2UwMTM0OWQ1MTQ1NDE5ODFhZWVjZWE2YjJlNzQxZAotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL215dGVzdC9nb29kLXJlZnRlc3QyLmh0bWwKQEAgLTAsMCAr MSBAQAorSGVsbG8hCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9teXRlc3QvcG5nLXRlc3QtZXhw ZWN0ZWQuY2hlY2tzdW0gYi9MYXlvdXRUZXN0cy9teXRlc3QvcG5nLXRlc3QtZXhwZWN0ZWQuY2hl Y2tzdW0KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uYzg3YjgwYjJhYmMzMTEwNmY0NGMyNTQwMTBkYjI0Yzc1ZTQ1ZTJm YwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL215dGVzdC9wbmctdGVzdC1leHBlY3Rl ZC5jaGVja3N1bQpAQCAtMCwwICsxIEBACitmNzRhNzcxNTg3ZjBhYzg1NzZkMmQ3MzNmYTEyNDIx YgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215 dGVzdC9wbmctdGVzdC1leHBlY3RlZC5wbmcgYi9MYXlvdXRUZXN0cy9teXRlc3QvcG5nLXRlc3Qt ZXhwZWN0ZWQucG5nCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjBjZjkwMzVmNjZmN2VmOWVmN2UzNzE0MTM0ZjllM2Ey MzM0ZWM4MzIKR0lUIGJpbmFyeSBwYXRjaApsaXRlcmFsIDExMjc0CnpjbWVITmRwTUw/ODJgUjhq Zm9MVFhxRm5ucUtIQ1R4NnptayU0SV5pcXsmazJIaj48TEFJaTB1QX5NeUEqdik7Rwp6cjRtbipT aG1QVTN8U1BhRWg1JEFaZzt4eWBGbyRJfElWTjFKbT5kKj1ZN0JUZWIwTS0/QDZ8YEhXdzJpaWEt en4Kelc8ZktmTHkhOyZmLW5kMUlLZDElSVBTUCRGeiFYNipqaTkxQi08MUlONDxQS0F0KTMrWlF0 JiomUXhrcWs2SEFXCnpCSHIwJk89VCFjKFpaP1pDK2NJcDF4YUB3TGZAdHVEJDhTc01LQEQjYlg9 dm5GbGw3eWtAXjdqT2BoPC0kajAhdQp6OUB7S1dKNXlCJE4+dHRSV0hjdCpuMHNwcVV2blF1emFR OCs1Iz04fDIjS0JPKEJVSzQ1d1RgXnpORDlMPFprY3oKekJxJUxed1cqRz5MKkpPUzYzI1J9YTM8 bnFQcT11aml7cmhCeHNifGBHSW1EfFRsbXhoYEtkWChTRGlCPDZDbVFXCno3TCNOK241V2khNTxm V0heS0xBQ212dmFeLUQ+ZUlNdllGMmt6YCRzaGNXd1o/ciY0PkIqKVlBR3gtNUA8SUI5JQp6T3JF XjM3eFU7SkVmViFNdFkyPW9qK2VPU1VBRiRYaEU7IyVMJHIwKGZOX0lEZ1hvNGJsUlk9ans+KHFx V2lvVysKelM7MzNPMVMyX0YtNER9QF4qNHdgKTRCfihoYjh1WHBLbCt+dDBee2x2MyRZdG9uX297 bWl+UUBCU0BlIyY0I3leCnpJYkVCJERvVGE3dTN7Kn0oZTdEVGBucUVTa05ZUjZQY1JpKVl2Yyg7 MCRZcWBEPyFCYHh5WjM0Q20wZzdidCtHbwp6WSVhbGxtbDNmJk5YaCY1TnE0aX5PZTZJRUhvOVJ+ Jn5MYj9zdSsrLXNtN241SChnWShffHhXaip2dGMwUExKYk0Kelg0eGZuP1lwTjJQMHc+fjVqWE5X VFpSTW94a1gtaDlHcjIkSmdZUDt5cEJDYUcjTlhQdF5GY1NIQHp7Q0dkSFBtCnpfKEUmOCs4TD4p VlRicHh0eGczd1l3c00pXl5Hd3c4cSNkbnRuTG1oT0hTU0NjcSNrWGY7VmskeXRwcG9nfk49RQp6 OC1IXkNTWDwrZEx1JVM4ITZgMmxsQ3pzTUMocmotbTUyXjh7Rj9Ec0UrblhSXz8/P28+UzhlMWJe TDlJT2s2X2kKel9yd3RSYzl8UG1KTTVGRVZqOSN2Ymd0WjU8M0YzOypFfXlYR0xgWiZSfjU2KF9p ME5gdD42QkQzNWgoPExTfHEmCnpNJnswPXNKQXN0cEtIPGpeVm94aUNETFZkLUNSLX5FRWsqQHpW UlFtaT1BMG5aTSoxK1RYUXBOVSleYDd4N3prbQp6PXlhWWsmKGxofUQjeVk3UmQ3I0VyI3c/R1pg YmFyIyRQUXhHaUVDJEJ7PlRtYHBpcnp5Kkp2TCpkM2NhPig4eFEKenBtSVl+bE9jISVTKHVzSGhy KTBBd1Y0PEBEYXhiMG5OZ2JeamojRzU7fTJacm9mWGR4UFU9V2clalh0bUNLYnBDCnoxWUB2eDJA KUNNIW0pIXc/UWlqNGhvOSU/TVAqNUQqY0NIcnQ3Uz5lKk51e3ZRNGxRRFhzfVg+SFlfd0VUUC1Y cAp6a29he0cwfF4hV3tEbSlMZUg4e0dja0xyLWgxNWwzTiFSdyMmZkxoUnNpfUsrM30jYURQYm4/ SVhgPDdzbG56eDQKenFZYGB0ZHZKLU9RSV9QQk5nNTJLVV5HWj5OZlJobTB+WWNxNSUpcWQxKi1f R2xsNXR2bSF5KDckXyZKcHVPTm5FCnplbjtUKjwtQzl8I2B2Xz04WjNjVFc/WD5VaCRYRT4/JUBC Qnd5Wm9pM3hPLVU1X00yYTJMP3kwYiEkZW8/XiZ4dwp6dTk7O2VFTXYmZFQqIWhxcyprR2dnMkE7 b1p0RDItNTVCQ1QzOVNBcVQ7NjxITDUzOTw+VX5XaXE4S2smMnA5enoKejxeT3EjPihwRztkVyNq X2dlfUhJISRvP2RueTc9dDMhSVhucmllUTdickQlbypVXjN8PlhmIXpYdjA+ajV7aHd2CnpnJGth Ty1iU08yQWklXklDWWRjYHVCdE4tYCU2SkdYdztic0I5JFhgNCNuNkRCR3RRVVR5WkhGTkxzMjRn cGo0VQp6N1IzfUpGeHt7RjVFXndqMHA+Mjw0OF8+NCpDSDNVKXV0ey05cnIyJVokRnFxTG92a3w5 SWVfWjFYV08wTntmdU0KemwxeUk0a1I3LVhGYlhnVkBEdjF1anwyKGk2YnUkNVN8fUVyS0h4fGUp STZZMGZucWBOTWd8b3Y3N3htTjd6Nkc7CnpXQ3BrcE5gUEIzaX4tYUUwO21KTDFtSUlKMCR2U31P bmBYPClQYUR6MT1JbmM0Z0BTZVZEa1pXQVpZQ1g+VldpKAp6c1JQU19zMnZjNWZBSHhvMEJEU1ha WHN4KWcxJDF+WXJrPlExJkowVVQ5OWJKT2BfJEJtZDEofkp1JXNtRXFMUCMKTlN4fkxiJTZCdjN7 c1NYWGczSkhfCgpsaXRlcmFsIDAKSGNtVj9kMDAwMDEKCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9teXRlc3QvcG5nLXRlc3QuaHRtbCBiL0xheW91dFRlc3RzL215dGVzdC9wbmctdGVzdC5odG1s Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLmRhYzFkNDIzYWVmNDkzNWQ2YzBhZTJiMDhkMzE4NTFkYmE4MGMwZTkKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9teXRlc3QvcG5nLXRlc3QuaHRtbApAQCAtMCww ICsxLDEyIEBACis8c3R5bGU+CisgICAgI3RhcmdldCB7IGZvbnQtZmFtaWx5OiBhaGVtOyBmb250 LXNpemU6IDUwcHg7IGJhY2tncm91bmQtY29sb3I6IGdyZWVuOyBoZWlnaHQ6IDUwcHg7IHdpZHRo OiA1MHB4OyB9CisgICAgI3RhcmdldDpmaXJzdC1sZXR0ZXIgeyBjb2xvcjogcmVkOyB9Cis8L3N0 eWxlPgorPGRpdiBpZD0idGFyZ2V0Ij5Mb3JlbTwvZGl2PgorPHNjcmlwdD4KKyAgICB2YXIgdGFy Z2V0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRhcmdldCIpOworICAgIHRhcmdldC5vZmZz ZXRUb3A7CisgICAgdmFyIHRleHQgPSB0YXJnZXQuZmlyc3RDaGlsZDsKKyAgICB0YXJnZXQuaW5u ZXJIVE1MID0gImlwc3VtIjsKKyAgICB0YXJnZXQucmVtb3ZlQ2hpbGQodGFyZ2V0LmZpcnN0Q2hp bGQpOworPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9teXRlc3QvdHh0LWFuZC1w bmctdGVzdC1leHBlY3RlZC5jaGVja3N1bSBiL0xheW91dFRlc3RzL215dGVzdC90eHQtYW5kLXBu Zy10ZXN0LWV4cGVjdGVkLmNoZWNrc3VtCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmM4N2I4MGIyYWJjMzExMDZmNDRj MjU0MDEwZGIyNGM3NWU0NWUyZmMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9teXRl c3QvdHh0LWFuZC1wbmctdGVzdC1leHBlY3RlZC5jaGVja3N1bQpAQCAtMCwwICsxIEBACitmNzRh NzcxNTg3ZjBhYzg1NzZkMmQ3MzNmYTEyNDIxYgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC90eHQtYW5kLXBuZy10ZXN0LWV4cGVjdGVk LnBuZyBiL0xheW91dFRlc3RzL215dGVzdC90eHQtYW5kLXBuZy10ZXN0LWV4cGVjdGVkLnBuZwpu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi4wY2Y5MDM1ZjY2ZjdlZjllZjdlMzcxNDEzNGY5ZTNhMjMzNGVjODMyCkdJVCBi aW5hcnkgcGF0Y2gKbGl0ZXJhbCAxMTI3NAp6Y21lSE5kcE1MPzgyYFI4amZvTFRYcUZubnFLSENU eDZ6bWslNEleaXF7JmsySGo+PExBSWkwdUF+TXlBKnYpO0cKenI0bW4qU2htUFUzfFNQYUVoNSRB Wmc7eHlgRm8kSXxJVk4xSm0+ZCo9WTdCVGViME0tP0A2fGBIV3cyaWlhLXp+CnpXPGZLZkx5ITsm Zi1uZDFJS2QxJUlQU1AkRnohWDYqamk5MUItPDFJTjQ8UEtBdCkzK1pRdCYqJlF4a3FrNkhBVwp6 QkhyMCZPPVQhYyhaWj9aQytjSXAxeGFAd0xmQHR1RCQ4U3NNS0BEI2JYPXZuRmxsN3lrQF43ak9g aDwtJGowIXUKejlAe0tXSjV5QiROPnR0UldIY3QqbjBzcHFVdm5RdXphUTgrNSM9OHwyI0tCTyhC VUs0NXdUYF56TkQ5TDxaa2N6CnpCcSVMXndXKkc+TCpKT1M2MyNSfWEzPG5xUHE9dWppe3JoQnhz YnxgR0ltRHxUbG14aGBLZFgoU0RpQjw2Q21RVwp6N0wjTituNVdpITU8ZldIXktMQUNtdnZhXi1E PmVJTXZZRjJremAkc2hjV3daP3ImND5CKilZQUd4LTVAPElCOSUKek9yRV4zN3hVO0pFZlYhTXRZ Mj1vaitlT1NVQUYkWGhFOyMlTCRyMChmTl9JRGdYbzRibFJZPWp7PihxcVdpb1crCnpTOzMzTzFT Ml9GLTREfUBeKjR3YCk0Qn4oaGI4dVhwS2wrfnQwXntsdjMkWXRvbl9ve21pflFAQlNAZSMmNCN5 Xgp6SWJFQiREb1RhN3Uzeyp9KGU3RFRgbnFFU2tOWVI2UGNSaSlZdmMoOzAkWXFgRD8hQmB4eVoz NENtMGc3YnQrR28KelklYWxsbWwzZiZOWGgmNU5xNGl+T2U2SUVIbzlSfiZ+TGI/c3UrKy1zbTdu NUgoZ1koX3x4V2oqdnRjMFBMSmJNCnpYNHhmbj9ZcE4yUDB3Pn41alhOV1RaUk1veGtYLWg5R3Iy JEpnWVA7eXBCQ2FHI05YUHReRmNTSEB6e0NHZEhQbQp6XyhFJjgrOEw+KVZUYnB4dHhnM3dZd3NN KV5eR3d3OHEjZG50bkxtaE9IU1NDY3Eja1hmO1ZrJHl0cHBvZ35OPUUKejgtSF5DU1g8K2RMdSVT OCE2YDJsbEN6c01DKHJqLW01Ml44e0Y/RHNFK25YUl8/Pz9vPlM4ZTFiXkw5SU9rNl9pCnpfcnd0 UmM5fFBtSk01RkVWajkjdmJndFo1PDNGMzsqRX15WEdMYFomUn41NihfaTBOYHQ+NkJEMzVoKDxM U3xxJgp6TSZ7MD1zSkFzdHBLSDxqXlZveGlDRExWZC1DUi1+RUVrKkB6VlJRbWk9QTBuWk0qMStU WFFwTlUpXmA3eDd6a20Kej15YVlrJihsaH1EI3lZN1JkNyNFciN3P0daYGJhciMkUFF4R2lFQyRC ez5UbWBwaXJ6eSpKdkwqZDNjYT4oOHhRCnpwbUlZfmxPYyElUyh1c0hocikwQXdWNDxARGF4YjBu TmdiXmpqI0c1O30yWnJvZlhkeFBVPVdnJWpYdG1DS2JwQwp6MVlAdngyQClDTSFtKSF3P1FpajRo bzklP01QKjVEKmNDSHJ0N1M+ZSpOdXt2UTRsUURYc31YPkhZX3dFVFAtWHAKemtvYXtHMHxeIVd7 RG0pTGVIOHtHY2tMci1oMTVsM04hUncjJmZMaFJzaX1LKzN9I2FEUGJuP0lYYDw3c2xueng0Cnpx WWBgdGR2Si1PUUlfUEJOZzUyS1VeR1o+TmZSaG0wflljcTUlKXFkMSotX0dsbDV0dm0heSg3JF8m SnB1T05uRQp6ZW47VCo8LUM5fCNgdl89OFozY1RXP1g+VWgkWEU+PyVAQkJ3eVpvaTN4Ty1VNV9N MmEyTD95MGIhJGVvP14meHcKenU5OztlRU12JmRUKiFocXMqa0dnZzJBO29adEQyLTU1QkNUMzlT QXFUOzY8SEw1Mzk8PlV+V2lxOEtrJjJwOXp6Cno8Xk9xIz4ocEc7ZFcjal9nZX1ISSEkbz9kbnk3 PXQzIUlYbnJpZVE3YnJEJW8qVV4zfD5YZiF6WHYwPmo1e2h3dgp6ZyRrYU8tYlNPMkFpJV5JQ1lk Y2B1QnROLWAlNkpHWHc7YnNCOSRYYDQjbjZEQkd0UVVUeVpIRk5MczI0Z3BqNFUKejdSM31KRnh7 e0Y1RV53ajBwPjI8NDhfPjQqQ0gzVSl1dHstOXJyMiVaJEZxcUxvdmt8OUllX1oxWFdPME57ZnVN CnpsMXlJNGtSNy1YRmJYZ1ZARHYxdWp8MihpNmJ1JDVTfH1FcktIeHxlKUk2WTBmbnFgTk1nfG92 Nzd4bU43ejZHOwp6V0Nwa3BOYFBCM2l+LWFFMDttSkwxbUlJSjAkdlN9T25gWDwpUGFEejE9SW5j NGdAU2VWRGtaV0FaWUNYPlZXaSgKenNSUFNfczJ2YzVmQUh4bzBCRFNYWlhzeClnMSQxfllyaz5R MSZKMFVUOTliSk9gXyRCbWQxKH5KdSVzbUVxTFAjCk5TeH5MYiU2QnYze3NTWFhnM0pIXwoKbGl0 ZXJhbCAwCkhjbVY/ZDAwMDAxCgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC1h bmQtcG5nLXRlc3QtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC1hbmQtcG5n LXRlc3QtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmNmYjFhMjU3MDliN2M5YTFlN2RlMTgxYjI4 OWUzODhhNDliMDhmZTMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9teXRlc3QvdHh0 LWFuZC1wbmctdGVzdC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw2IEBACitsYXllciBhdCAoMCww KSBzaXplIDgwMHg2MDAKKyAgUmVuZGVyVmlldyBhdCAoMCwwKSBzaXplIDgwMHg2MDAKK2xheWVy IGF0ICgwLDApIHNpemUgODAweDYwMAorICBSZW5kZXJCbG9jayB7SFRNTH0gYXQgKDAsMCkgc2l6 ZSA4MDB4NjAwCisgICAgUmVuZGVyQm9keSB7Qk9EWX0gYXQgKDgsOCkgc2l6ZSA3ODR4NTg0Cisg ICAgICBSZW5kZXJCbG9jayB7RElWfSBhdCAoMCwwKSBzaXplIDUweDUwIFtiZ2NvbG9yPSMwMDgw MDBdCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9teXRlc3QvdHh0LWFuZC1wbmctdGVzdC5odG1s IGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC1hbmQtcG5nLXRlc3QuaHRtbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5k YWMxZDQyM2FlZjQ5MzVkNmMwYWUyYjA4ZDMxODUxZGJhODBjMGU5Ci0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC1hbmQtcG5nLXRlc3QuaHRtbApAQCAtMCwwICsxLDEy IEBACis8c3R5bGU+CisgICAgI3RhcmdldCB7IGZvbnQtZmFtaWx5OiBhaGVtOyBmb250LXNpemU6 IDUwcHg7IGJhY2tncm91bmQtY29sb3I6IGdyZWVuOyBoZWlnaHQ6IDUwcHg7IHdpZHRoOiA1MHB4 OyB9CisgICAgI3RhcmdldDpmaXJzdC1sZXR0ZXIgeyBjb2xvcjogcmVkOyB9Cis8L3N0eWxlPgor PGRpdiBpZD0idGFyZ2V0Ij5Mb3JlbTwvZGl2PgorPHNjcmlwdD4KKyAgICB2YXIgdGFyZ2V0ID0g ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRhcmdldCIpOworICAgIHRhcmdldC5vZmZzZXRUb3A7 CisgICAgdmFyIHRleHQgPSB0YXJnZXQuZmlyc3RDaGlsZDsKKyAgICB0YXJnZXQuaW5uZXJIVE1M ID0gImlwc3VtIjsKKyAgICB0YXJnZXQucmVtb3ZlQ2hpbGQodGFyZ2V0LmZpcnN0Q2hpbGQpOwor PC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9teXRlc3QvdHh0LXRlc3QtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC10ZXN0LWV4cGVjdGVkLnR4dApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi5lYzMxMDM0OGRmZGFhODhjYjVjYmVjZTE3MjdmYjhiZjJjYmQ5NzlmCi0tLSAvZGV2L251 bGwKKysrIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC10ZXN0LWV4cGVjdGVkLnR4dApAQCAtMCww ICsxIEBACitTdWNjZXNzIFRlc3QKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC90eHQt dGVzdC5odG1sIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC10ZXN0Lmh0bWwKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u YjZkNjQzNGQzODNmODBkZjdlYjYzMTFlZmE1MTE0OGUxNjY0NmE1YQotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL215dGVzdC90eHQtdGVzdC5odG1sCkBAIC0wLDAgKzEsOCBAQAorPHA+ CisgICAgU3VjY2VzcyBUZXN0Cis8L3A+Cis8ZGl2IGlkPSJ0YXJnZXQiIHN0eWxlPSJkaXNwbGF5 OiBub25lOyI+PC9kaXY+Cis8c2NyaXB0PgorICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRy b2xsZXIpCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKzwvc2Ny aXB0PgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy9vbGQtcnVuLXdlYmtpdC10ZXN0 cyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvb2xkLXJ1bi13ZWJraXQtdGVzdHMKaW5kZXggODg2YjRh ODFiZTlmYjdkZTU3MDQxMTIzM2M4YjU5YjE2NTQ4MGI4ZS4uMWRhMmU1ZGIzNmUxMmRhNzRmOGY3 MDRmYWU4NjQ5NzM1NjcyNDNhOSAxMDA3NTUKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy9vbGQt cnVuLXdlYmtpdC10ZXN0cworKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL29sZC1ydW4td2Via2l0 LXRlc3RzCkBAIC0yMjQ3LDYgKzIyNDcsMTcgQEAgc3ViIHJlYWRTa2lwcGVkRmlsZXMoJCkKIAog bXkgQHRlc3RzRm91bmQ7CiAKK3N1YiBpc1VzZWRJblJlZnRlc3QKK3sKKyAgICAjIElnbm9yZXMg ZmlsZXMgd2hpY2ggYXJlIHVzZWQgaW4gcmVmdGVzdC4KKyAgICBteSAkZmlsZW5hbWUgPSAkXzsK KyAgICBpZiAoJGZpbGVuYW1lID1+IC8tZXhwZWN0ZWQoLW1pc21hdGNoKT9cLmh0bWwkLykgewor ICAgICAgICByZXR1cm4gMTsKKyAgICB9CisgICAgbXkgJGJhc2UgPSBzdHJpcEV4dGVuc2lvbigk ZmlsZW5hbWUpOworICAgIHJldHVybiAoLWYgIiRiYXNlLSRleHBlY3RlZFRhZy5odG1sIiB8fCAt ZiAiJGJhc2UtJGV4cGVjdGVkVGFnLW1pc21hdGNoLmh0bWwiKTsKK30KKwogc3ViIGRpcmVjdG9y eUZpbHRlcgogewogICAgIHJldHVybiAoKSBpZiBleGlzdHMgJGlnbm9yZWRMb2NhbERpcmVjdG9y aWVze2Jhc2VuYW1lKCRGaWxlOjpGaW5kOjpkaXIpfTsKQEAgLTIyNTgsNyArMjI2OSwxMSBAQCBz dWIgZmlsZUZpbHRlcgogewogICAgIG15ICRmaWxlbmFtZSA9ICRfOwogICAgIGlmICgkZmlsZW5h bWUgPX4gL1wuKFteLl0rKSQvKSB7Ci0gICAgICAgIGlmIChleGlzdHMgJHN1cHBvcnRlZEZpbGVF eHRlbnNpb25zeyQxfSkgeworICAgICAgICBteSAkZXh0ZW5zaW9uID0gJDE7CisgICAgICAgIGlm IChleGlzdHMgJHN1cHBvcnRlZEZpbGVFeHRlbnNpb25zeyRleHRlbnNpb259KSB7CisgICAgICAg ICAgICBpZiAoaXNVc2VkSW5SZWZ0ZXN0KCRmaWxlbmFtZSkpIHsKKyAgICAgICAgICAgICAgICBy ZXR1cm47CisgICAgICAgICAgICB9CiAgICAgICAgICAgICBteSAkcGF0aCA9IEZpbGU6OlNwZWMt PmFiczJyZWwoY2F0ZmlsZSgkRmlsZTo6RmluZDo6ZGlyLCAkZmlsZW5hbWUpLCAkdGVzdERpcmVj dG9yeSk7CiAgICAgICAgICAgICBwdXNoIEB0ZXN0c0ZvdW5kLCAkcGF0aCBpZiAhZXhpc3RzICRp Z25vcmVkRmlsZXN7JHBhdGh9OwogICAgICAgICB9CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9kdW1wX3JlbmRlcl90 cmVlX3RocmVhZC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L2xheW91dF9wYWNrYWdlL2R1bXBfcmVuZGVyX3RyZWVfdGhyZWFkLnB5CmluZGV4IDk3MGRlNjBj YzYxYzBmZDMzYWQ5YzJkYmNmZmYxNDM2OGVhZjU2MjUuLjBhNzQxNDVkMzI1YTZjYTYyYThhMjIz YmJkMmM3YWFiYTZkNDZjODkgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2R1bXBfcmVuZGVyX3RyZWVfdGhyZWFkLnB5 CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9w YWNrYWdlL2R1bXBfcmVuZGVyX3RyZWVfdGhyZWFkLnB5CkBAIC03Miw2ICs3Miw2NyBAQCBkZWYg bG9nX3N0YWNrKHN0YWNrKToKICAgICAgICAgICAgIF9sb2cuZXJyb3IoJyAgJXMnICUgbGluZS5z dHJpcCgpKQogCiAKKyMgRklYTUU6IFdlIGhhdmUgc2VwYXJldGUgZnVuY3Rpb25zIF9wcm9jZXNz X3JlZnRlc3Rfb3V0cHV0IGFuZCBfcHJvY2Vzc19vdXRwdXQuCisjIEl0IHdvdWxkIGJlIG5pY2Ug dG8gbWVyZ2UgdGhlbS4KKyMgQnV0IHRoZXJlIGlzIGEgZ2FwIGJldHdlZW4gcmVmdGVzdCBhbmQg ZXhpdGluZyBsYXlvdXR0ZXN0cyB0byBoYW5kbGUgdGhlIG91dHB1dHMuCitkZWYgX3Byb2Nlc3Nf cmVmdGVzdF9vdXRwdXQocG9ydCwgb3B0aW9ucywgdGVzdF9pbmZvLCByZWZ0ZXN0X3R5cGVzLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFjdHVhbF9jcmFzaCwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICBhY3R1YWxfdGltZW91dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICBhY3R1YWxfaW1hZ2VfaGFzaCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBhY3R1YWxf aW1hZ2VfY29udGVudHMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgYWN0dWFsX2Vycm9y LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlZmVyZW5jZV9jcmFzaCwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICByZWZlcmVuY2VfdGltZW91dCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICByZWZlcmVuY2VfaW1hZ2VfaGFzaCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICByZWZlcmVuY2VfaW1hZ2VfY29udGVudHMsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgcmVmZXJlbmNlX2Vycm9yLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRlc3RfcnVu X3RpbWUpOgorICAgICIiIlJlY2VpdmVzIHRoZSBvdXRwdXQgZnJvbSBhIER1bXBSZW5kZXJUcmVl IHByb2Nlc3MsIHN1YmplY3RzIGl0IHRvIGEKKyAgICBudW1iZXIgb2YgdGVzdHMsIGFuZCByZXR1 cm5zIGEgbGlzdCBvZiBmYWlsdXJlIHR5cGVzIHRoZSB0ZXN0IHByb2R1Y2VkLgorCisgICAgQXJn czoKKyAgICAgIHBvcnQ6IHBvcnQtc3BlY2lmaWMgaG9va3MKKyAgICAgIG9wdGlvbnM6IGNvbW1h bmQgbGluZSBvcHRpb25zIGFyZ3VtZW50IGZyb20gb3B0cGFyc2UKKyAgICAgIHRlc3RfaW5mbzog T2JqZWN0IGNvbnRhaW5pbmcgdGhlIHRlc3QgZmlsZW5hbWUsIHVyaSBhbmQgdGltZW91dAorICAg ICAgdGVzdF90eXBlczogbGlzdCBvZiB0ZXN0IHR5cGVzIHRvIHN1YmplY3QgdGhlIG91dHB1dCB0 bworICAgICAgYWN0dWFsX3Jlc3VsdDogcmVzdWx0IG9mIGQKKworICAgIFJldHVybnM6IGEgVGVz dFJlc3VsdCBvYmplY3QKKyAgICAiIiIKKyAgICAjIEZJWE1FOiBEZXRlY3QgYW4gaW52YWxpZCB0 ZXN0IHdoaWNoIGhhcyB3cm9uZyBjb21iaW5hdGlvbiBvZiBleHBlY3RhdGlvbnMsCisgICAgIyBz dWNoIGFzIC1leHBlY3RlZC5odG1sIGFuZCAtZXhwZWN0ZWQudHh0LgorCisgICAgZmFpbHVyZXMg PSBbXQorCisgICAgc3RhcnRfdGltZSA9IHRpbWUudGltZSgpCisgICAgdGltZV9mb3JfZGlmZnMg PSB7fQorCisgICAgZm9yIHRlc3RfdHlwZSBpbiByZWZ0ZXN0X3R5cGVzOgorICAgICAgICBzdGFy dF9kaWZmX3RpbWUgPSB0aW1lLnRpbWUoKQorICAgICAgICBuZXdfZmFpbHVyZXMgPSB0ZXN0X3R5 cGUuY29tcGFyZV9yZWZ0ZXN0X291dHB1dCgKKyAgICAgICAgICAgIHBvcnQsIHRlc3RfaW5mbywK KyAgICAgICAgICAgIGFjdHVhbF9pbWFnZV9oYXNoLCBhY3R1YWxfaW1hZ2VfY29udGVudHMsCisg ICAgICAgICAgICByZWZlcmVuY2VfaW1hZ2VfaGFzaCwgcmVmZXJlbmNlX2ltYWdlX2NvbnRlbnRz LAorICAgICAgICAgICAgKQorCisgICAgICAgICMgRklYTUU6IEhhbmRsZSBjcmFzaCBjYXNlLgor ICAgICAgICAjIGlmIG5vdCBjcmFzaDoKKyAgICAgICAgIyAgICAgZmFpbHVyZXMuZXh0ZW5kKG5l d19mYWlsdXJlcykKKyAgICAgICAgZmFpbHVyZXMuZXh0ZW5kKG5ld19mYWlsdXJlcykKKworICAg ICAgICB0aW1lX2Zvcl9kaWZmc1t0ZXN0X3R5cGUuX19jbGFzc19fLl9fbmFtZV9fXSA9ICgKKyAg ICAgICAgICAgIHRpbWUudGltZSgpIC0gc3RhcnRfZGlmZl90aW1lKQorCisgICAgdG90YWxfdGlt ZV9mb3JfYWxsX2RpZmZzID0gdGltZS50aW1lKCkgLSBzdGFydF9kaWZmX3RpbWUKKyAgICByZXR1 cm4gVGVzdFJlc3VsdCh0ZXN0X2luZm8uZmlsZW5hbWUsIGZhaWx1cmVzLCB0ZXN0X3J1bl90aW1l LAorICAgICAgICAgICAgICAgICAgICAgIHRvdGFsX3RpbWVfZm9yX2FsbF9kaWZmcywgdGltZV9m b3JfZGlmZnMpCisKKworIyBGSVhNRTogSW1wbGVtZW50IHRoaXMKK2RlZiBfcHJvY2Vzc19jcmFz aCgpOgorICAgIHBhc3MKKworCiBkZWYgX3Byb2Nlc3Nfb3V0cHV0KHBvcnQsIG9wdGlvbnMsIHRl c3RfaW5mbywgdGVzdF90eXBlcywgdGVzdF9hcmdzLAogICAgICAgICAgICAgICAgICAgICBjcmFz aCwgdGltZW91dCwgdGVzdF9ydW5fdGltZSwgYWN0dWFsX2NoZWNrc3VtLAogICAgICAgICAgICAg ICAgICAgICBvdXRwdXQsIGVycm9yKToKQEAgLTExOCw2ICsxNzksMTAgQEAgZGVmIF9wcm9jZXNz X291dHB1dChwb3J0LCBvcHRpb25zLCB0ZXN0X2luZm8sIHRlc3RfdHlwZXMsIHRlc3RfYXJncywK ICAgICAjIENoZWNrIHRoZSBvdXRwdXQgYW5kIHNhdmUgdGhlIHJlc3VsdHMuCiAgICAgc3RhcnRf dGltZSA9IHRpbWUudGltZSgpCiAgICAgdGltZV9mb3JfZGlmZnMgPSB7fQorCisgICAgIyBGSVhN RShoYXlhdG8pOiBEZWxldGUgZm9yIHJldmlld3MuCisgICAgX2xvZy5pbmZvKCd0ZXN0X3R5cGVz OiAlcycsIHRlc3RfdHlwZXMpCisKICAgICBmb3IgdGVzdF90eXBlIGluIHRlc3RfdHlwZXM6CiAg ICAgICAgIHN0YXJ0X2RpZmZfdGltZSA9IHRpbWUudGltZSgpCiAgICAgICAgIG5ld19mYWlsdXJl cyA9IHRlc3RfdHlwZS5jb21wYXJlX291dHB1dChwb3J0LCB0ZXN0X2luZm8uZmlsZW5hbWUsCkBA IC0yMDMsNyArMjY4LDcgQEAgY2xhc3MgU2luZ2xlVGVzdFRocmVhZCh0aHJlYWRpbmcuVGhyZWFk KToKICAgICAgICAgc2VsZi5fdGVzdF9yZXN1bHQgPSBfcHJvY2Vzc19vdXRwdXQoc2VsZi5fcG9y dCwgc2VsZi5fb3B0aW9ucywKICAgICAgICAgICAgIHRlc3RfaW5mbywgc2VsZi5fdGVzdF90eXBl cywgc2VsZi5fdGVzdF9hcmdzLAogICAgICAgICAgICAgY3Jhc2gsIHRpbWVvdXQsIGVuZCAtIHN0 YXJ0LAotICAgICAgICAgICAgYWN0dWFsX2NoZWNrc3VtLCBvdXRwdXQsIGVycm9yKQorICAgICAg ICAgICAgYWN0dWFsX2NoZWNrc3VtLCBvdXRwdXQsIGVycm9yLCBkcml2ZXIpCiAgICAgICAgIHNl bGYuX2RyaXZlci5zdG9wKCkKIAogICAgIGRlZiBnZXRfdGVzdF9yZXN1bHQoc2VsZik6CkBAIC0y NDcsNyArMzEyLDcgQEAgY2xhc3MgV2F0Y2hhYmxlVGhyZWFkKHRocmVhZGluZy5UaHJlYWQpOgog CiBjbGFzcyBUZXN0U2hlbGxUaHJlYWQoV2F0Y2hhYmxlVGhyZWFkKToKICAgICBkZWYgX19pbml0 X18oc2VsZiwgcG9ydCwgb3B0aW9ucywgZmlsZW5hbWVfbGlzdF9xdWV1ZSwgcmVzdWx0X3F1ZXVl LAotICAgICAgICAgICAgICAgICB0ZXN0X3R5cGVzLCB0ZXN0X2FyZ3MpOgorICAgICAgICAgICAg ICAgICB0ZXN0X3R5cGVzLCByZWZ0ZXN0X3R5cGVzLCB0ZXN0X2FyZ3MpOgogICAgICAgICAiIiJJ bml0aWFsaXplIGFsbCB0aGUgbG9jYWwgc3RhdGUgZm9yIHRoaXMgRHVtcFJlbmRlclRyZWUgdGhy ZWFkLgogCiAgICAgICAgIEFyZ3M6CkBAIC0yNTksNiArMzI0LDggQEAgY2xhc3MgVGVzdFNoZWxs VGhyZWFkKFdhdGNoYWJsZVRocmVhZCk6CiAgICAgICAgICAgICAgICh0ZXN0LCBmYWlsdXJlIGxp c3RzKSBmb3IgdGhlIHRlc3QgcmVzdWx0cy4KICAgICAgICAgICB0ZXN0X3R5cGVzOiBBIGxpc3Qg b2YgVGVzdFR5cGUgb2JqZWN0cyB0byBydW4gdGhlIHRlc3Qgb3V0cHV0CiAgICAgICAgICAgICAg IGFnYWluc3QuCisgICAgICAgICAgcmVmdGVzdF90eXBlczogQSBsaXN0IG9mIFRlc3RUeXBlIG9i amVjdHMgdG8gcnVuIHRoZSByZWZ0ZXN0IG91dHB1dAorICAgICAgICAgICAgICBhZ2FpbnN0Lgog ICAgICAgICAgIHRlc3RfYXJnczogQSBUZXN0QXJndW1lbnRzIG9iamVjdCB0byBwYXNzIHRvIGVh Y2ggVGVzdFR5cGUuCiAKICAgICAgICAgIiIiCkBAIC0yNjksNiArMzM2LDcgQEAgY2xhc3MgVGVz dFNoZWxsVGhyZWFkKFdhdGNoYWJsZVRocmVhZCk6CiAgICAgICAgIHNlbGYuX3Jlc3VsdF9xdWV1 ZSA9IHJlc3VsdF9xdWV1ZQogICAgICAgICBzZWxmLl9maWxlbmFtZV9saXN0ID0gW10KICAgICAg ICAgc2VsZi5fdGVzdF90eXBlcyA9IHRlc3RfdHlwZXMKKyAgICAgICAgc2VsZi5fcmVmdGVzdF90 eXBlcyA9IHJlZnRlc3RfdHlwZXMKICAgICAgICAgc2VsZi5fdGVzdF9hcmdzID0gdGVzdF9hcmdz CiAgICAgICAgIHNlbGYuX2RyaXZlciA9IE5vbmUKICAgICAgICAgc2VsZi5fZGlyZWN0b3J5X3Rp bWluZ19zdGF0cyA9IHt9CkBAIC00NjUsNiArNTMzLDE0IEBAIGNsYXNzIFRlc3RTaGVsbFRocmVh ZChXYXRjaGFibGVUaHJlYWQpOgogCiAgICAgICAgIHJldHVybiByZXN1bHQKIAorCisgICAgZGVm IF9vdXRwdXRfaW1hZ2VfY29udGVudHMoc2VsZik6CisgICAgICAgIHBuZ19wYXRoID0gc2VsZi5f dGVzdF9hcmdzLnBuZ19wYXRoCisgICAgICAgIGFzc2VydChvcy5wYXRoLmlzZmlsZShwbmdfcGF0 aCkpCisgICAgICAgIHdpdGggb3BlbihwbmdfcGF0aCwgJ3JiJykgYXMgaW1hZ2VfZmlsZToKKyAg ICAgICAgICAgIHJldHVybiBpbWFnZV9maWxlLnJlYWQoKQorCisKICAgICBkZWYgX3J1bl90ZXN0 KHNlbGYsIHRlc3RfaW5mbyk6CiAgICAgICAgICIiIlJ1biBhIHNpbmdsZSB0ZXN0IGZpbGUgdXNp bmcgYSBzaGFyZWQgRHVtcFJlbmRlclRyZWUgcHJvY2Vzcy4KIApAQCAtNDc2LDYgKzU1Miw2MSBA QCBjbGFzcyBUZXN0U2hlbGxUaHJlYWQoV2F0Y2hhYmxlVGhyZWFkKToKIAogICAgICAgICAiIiIK ICAgICAgICAgc2VsZi5fZW5zdXJlX2R1bXBfcmVuZGVyX3RyZWVfaXNfcnVubmluZygpCisKKyAg ICAgICAgaWYgdGVzdF9pbmZvLmlzX3JlZnRlc3Q6CisgICAgICAgICAgICByZXR1cm4gc2VsZi5f cnVuX3JlZnRlc3QodGVzdF9pbmZvKQorICAgICAgICByZXR1cm4gc2VsZi5fcnVuX2xheW91dF90 ZXN0KHRlc3RfaW5mbykKKworCisgICAgZGVmIF9ydW5fcmVmdGVzdChzZWxmLCB0ZXN0X2luZm8p OgorICAgICAgICBhc3NlcnQgdGVzdF9pbmZvLmlzX3JlZnRlc3QKKworICAgICAgICBzdGFydCA9 IHRpbWUudGltZSgpCisKKyAgICAgICAgYWN0dWFsX3Jlc3VsdCA9IHNlbGYuX2RyaXZlci5ydW5f dGVzdCgKKyAgICAgICAgICAgIHRlc3RfaW5mby51cmksIHRlc3RfaW5mby50aW1lb3V0LCBpbWFn ZV9oYXNoPSIiKQorCisgICAgICAgIGFjdHVhbF9jcmFzaCwgYWN0dWFsX3RpbWVvdXQsIGFjdHVh bF9pbWFnZV9oYXNoLCBhY3R1YWxfb3V0cHV0LCBhY3R1YWxfZXJyb3IgPSBcCisgICAgICAgICAg ICBzZWxmLl9kcml2ZXIucnVuX3Rlc3QodGVzdF9pbmZvLnVyaSwgdGVzdF9pbmZvLnRpbWVvdXQs IGltYWdlX2hhc2g9IiIpCisKKyAgICAgICAgYWN0dWFsX2ltYWdlX2NvbnRlbnRzID0gc2VsZi5f b3V0cHV0X2ltYWdlX2NvbnRlbnRzKCkKKworICAgICAgICAjIEZJWE1FOiBBdm9pZCBhY2Nlc3Np bmcgYW4gZWxlbWVudCBieSBpbmRleC4gVGhlIHJlc3VsdAorICAgICAgICAjIGFjdHVhbF9pbWFn ZV9oYXNoID0gYWN0dWFsX3Jlc3VsdFsyXQorCisKKyAgICAgICAgcmVmZXJlbmNlX2NyYXNoLCBy ZWZlcmVuY2VfdGltZW91dCwgcmVmZXJlbmNlX2ltYWdlX2hhc2gsIHJlZmVyZW5jZV9vdXRwdXQs IHJlZmVyZW5jZV9lcnJvciA9IFwKKyAgICAgICAgICAgIHNlbGYuX2RyaXZlci5ydW5fdGVzdCh0 ZXN0X2luZm8uZXhwZWN0ZWRfaHRtbF9maWxlbmFtZSBvciB0ZXN0X2luZm8uZXhwZWN0ZWRfbWlz bWF0Y2hfaHRtbF9maWxlbmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0 ZXN0X2luZm8udGltZW91dCwgYWN0dWFsX2ltYWdlX2hhc2gpCisKKyAgICAgICAgaWYgYWN0dWFs X2ltYWdlX2hhc2ggPT0gcmVmZXJlbmNlX2ltYWdlX2hhc2g6CisgICAgICAgICAgICByZWZlcmVu Y2VfaW1hZ2VfY29udGVudHMgPSBhY3R1YWxfaW1hZ2VfY29udGVudHMKKyAgICAgICAgZWxzZToK KyAgICAgICAgICAgIHJlZmVyZW5jZV9pbWFnZV9jb250ZW50cyA9IHNlbGYuX291dHB1dF9pbWFn ZV9jb250ZW50cygpCisKKyAgICAgICAgZW5kID0gdGltZS50aW1lKCkKKyAgICAgICAgcmVzdWx0 ID0gX3Byb2Nlc3NfcmVmdGVzdF9vdXRwdXQoCisgICAgICAgICAgICBzZWxmLl9wb3J0LCBzZWxm Ll9vcHRpb25zLCB0ZXN0X2luZm8sIHNlbGYuX3JlZnRlc3RfdHlwZXMsCisgICAgICAgICAgICBh Y3R1YWxfY3Jhc2gsIGFjdHVhbF90aW1lb3V0LCBhY3R1YWxfaW1hZ2VfaGFzaCwgYWN0dWFsX2lt YWdlX2NvbnRlbnRzLAorICAgICAgICAgICAgYWN0dWFsX2Vycm9yLAorICAgICAgICAgICAgcmVm ZXJlbmNlX2NyYXNoLCByZWZlcmVuY2VfdGltZW91dCwgcmVmZXJlbmNlX2ltYWdlX2hhc2gsIHJl ZmVyZW5jZV9pbWFnZV9jb250ZW50cywKKyAgICAgICAgICAgIHJlZmVyZW5jZV9lcnJvciwKKyAg ICAgICAgICAgIGVuZCAtIHN0YXJ0KQorICAgICAgICBzZWxmLl90ZXN0X3Jlc3VsdHMuYXBwZW5k KHJlc3VsdCkKKyAgICAgICAgcmV0dXJuIHJlc3VsdAorCisKKyAgICBkZWYgX3J1bl9sYXlvdXRf dGVzdChzZWxmLCB0ZXN0X2luZm8pOgorICAgICAgICAiIiJSdW4gYSBzaW5nbGUgdGVzdCBmaWxl IHVzaW5nIGEgc2hhcmVkIER1bXBSZW5kZXJUcmVlIHByb2Nlc3MuCisKKyAgICAgICAgQXJnczoK KyAgICAgICAgICB0ZXN0X2luZm86IE9iamVjdCBjb250YWluaW5nIHRoZSB0ZXN0IGZpbGVuYW1l LCB1cmkgYW5kIHRpbWVvdXQKKworICAgICAgICBSZXR1cm5zOgorICAgICAgICAgIEEgbGlzdCBv ZiBUZXN0RmFpbHVyZSBvYmplY3RzIGRlc2NyaWJpbmcgdGhlIGVycm9yLgorCisgICAgICAgICIi IgorCiAgICAgICAgICMgVGhlIHBpeGVsX2hhc2ggaXMgdXNlZCB0byBhdm9pZCBkb2luZyBhbiBp bWFnZSBkdW1wIGlmIHRoZQogICAgICAgICAjIGNoZWNrc3VtcyBtYXRjaCwgc28gaXQgc2hvdWxk IGJlIHNldCB0byBhIGJsYW5rIHZhbHVlIGlmIHdlCiAgICAgICAgICMgYXJlIGdlbmVyYXRpbmcg YSBuZXcgYmFzZWxpbmUuICAoT3RoZXJ3aXNlLCBhbiBpbWFnZSBmcm9tIGEKQEAgLTQ5MSw2ICs2 MjIsNyBAQCBjbGFzcyBUZXN0U2hlbGxUaHJlYWQoV2F0Y2hhYmxlVGhyZWFkKToKICAgICAgICAg ICAgICBfcGFkX3RpbWVvdXQoaW50KHRlc3RfaW5mby50aW1lb3V0KSkpCiAgICAgICAgIHNlbGYu X25leHRfdGltZW91dCA9IHN0YXJ0ICsgdGhyZWFkX3RpbWVvdXQKIAorCiAgICAgICAgIGNyYXNo LCB0aW1lb3V0LCBhY3R1YWxfY2hlY2tzdW0sIG91dHB1dCwgZXJyb3IgPSBcCiAgICAgICAgICAg IHNlbGYuX2RyaXZlci5ydW5fdGVzdCh0ZXN0X2luZm8udXJpLCB0ZXN0X2luZm8udGltZW91dCwg aW1hZ2VfaGFzaCkKICAgICAgICAgZW5kID0gdGltZS50aW1lKCkKZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2pzb25f bGF5b3V0X3Jlc3VsdHNfZ2VuZXJhdG9yLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvanNvbl9sYXlvdXRfcmVzdWx0c19nZW5lcmF0 b3IucHkKaW5kZXggYzZjMzA2NmYzNTViZDdjMTIxYThlZWY2NTMwZGZhNmViMGRkOWVmZC4uYTdi NzU2YzM1MmIwYmRlN2VmYTNiMmQ0YTY0MGQ2ZTYzYWJkOTgwZSAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvanNvbl9s YXlvdXRfcmVzdWx0c19nZW5lcmF0b3IucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJr aXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvanNvbl9sYXlvdXRfcmVzdWx0c19nZW5l cmF0b3IucHkKQEAgLTUyLDYgKzUyLDcgQEAgY2xhc3MgSlNPTkxheW91dFJlc3VsdHNHZW5lcmF0 b3IoanNvbl9yZXN1bHRzX2dlbmVyYXRvci5KU09OUmVzdWx0c0dlbmVyYXRvckJhc2UKICAgICAg ICAgICAgICAgICAgICAgICAgdGVzdF9leHBlY3RhdGlvbnMuSU1BR0U6ICJJIiwKICAgICAgICAg ICAgICAgICAgICAgICAgdGVzdF9leHBlY3RhdGlvbnMuVEVYVDogIkYiLAogICAgICAgICAgICAg ICAgICAgICAgICB0ZXN0X2V4cGVjdGF0aW9ucy5NSVNTSU5HOiAiTyIsCisgICAgICAgICAgICAg ICAgICAgICAgIHRlc3RfZXhwZWN0YXRpb25zLlJFRlRFU1RfTUlTTUFUQ0g6ICJSIiwKICAgICAg ICAgICAgICAgICAgICAgICAgdGVzdF9leHBlY3RhdGlvbnMuSU1BR0VfUExVU19URVhUOiAiWiJ9 CiAKICAgICBkZWYgX19pbml0X18oc2VsZiwgcG9ydCwgYnVpbGRlcl9uYW1lLCBidWlsZF9uYW1l LCBidWlsZF9udW1iZXIsCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9yZWZ0ZXN0c191bml0dGVzdC5weSBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL3JlZnRl c3RzX3VuaXR0ZXN0LnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjYwZDU3ZGM3MWJmMTk3YzFmMjkxOWMyN2ZmYjFh YWU1MzMxYWIwZDAKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9yZWZ0ZXN0c191bml0dGVzdC5weQpAQCAt MCwwICsxLDE5NSBAQAorIyEvdXNyL2Jpbi9weXRob24KKyMgQ29weXJpZ2h0IChDKSAyMDEwIEdv b2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMgYXJlCisjIG1ldDoKKyMKKyMgICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorIyAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisjIGNvcHly aWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIKKyMgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZQorIyBkaXN0cmlidXRpb24uCisjICAgICAqIE5laXRoZXIgdGhlIG5h bWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyMgY29udHJpYnV0b3JzIG1h eSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyMg dGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4K KyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMg QU5EIENPTlRSSUJVVE9SUworIyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyMgQSBQQVJUSUNV TEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklH SFQKKyMgT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsCisjIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQg T0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisjIERBVEEsIE9S IFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWQorIyBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCisjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorCisiIiJV bml0IHRlc3RzIGZvciByZWZ0ZXN0cy4iIiIKKworaW1wb3J0IGNvZGVjcworaW1wb3J0IG9zCitp bXBvcnQgc3lzCitpbXBvcnQgdW5pdHRlc3QKKworZnJvbSB3ZWJraXRweS5jb21tb24gaW1wb3J0 IGFycmF5X3N0cmVhbQorZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMgaW1wb3J0IHBvcnQKK2Zy b20gd2Via2l0cHkubGF5b3V0X3Rlc3RzIGltcG9ydCBydW5fd2Via2l0X3Rlc3RzCisKK2Zyb20g d2Via2l0cHkudGhpcmRwYXJ0eS5tb2NrIGltcG9ydCBNb2NrCisKKworZGVmIHBhc3NpbmdfcnVu KGFyZ3MsIHBvcnRfb2JqPU5vbmUsIGxvZ2dpbmdfaW5jbHVkZWQ9RmFsc2UpOgorICAgIGlmIG5v dCBsb2dnaW5nX2luY2x1ZGVkOgorICAgICAgICBhcmdzLmV4dGVuZChbJy0tcHJpbnQnLCAnbm90 aGluZyddKQorICAgIG9wdGlvbnMsIGFyZ3MgPSBydW5fd2Via2l0X3Rlc3RzLnBhcnNlX2FyZ3Mo YXJncykKKyAgICBpZiBwb3J0X29iaiBpcyBOb25lOgorICAgICAgICBwb3J0X29iaiA9IHBvcnQu Z2V0KG9wdGlvbnMucGxhdGZvcm0sIG9wdGlvbnMpCisgICAgcmVzID0gcnVuX3dlYmtpdF90ZXN0 cy5ydW4ocG9ydF9vYmosIG9wdGlvbnMsIGFyZ3MpCisgICAgcmV0dXJuIHJlcyA9PSAwCisKK2Rl ZiBsb2dnaW5nX3J1bihhcmdzKToKKyAgICBvcHRpb25zLCBhcmdzID0gcnVuX3dlYmtpdF90ZXN0 cy5wYXJzZV9hcmdzKGFyZ3MpCisgICAgcG9ydF9vYmogPSBwb3J0LmdldChvcHRpb25zLnBsYXRm b3JtLCBvcHRpb25zKQorICAgIGJ1aWxkYm90X291dHB1dCA9IGFycmF5X3N0cmVhbS5BcnJheVN0 cmVhbSgpCisgICAgcmVndWxhcl9vdXRwdXQgPSBhcnJheV9zdHJlYW0uQXJyYXlTdHJlYW0oKQor ICAgIHJlcyA9IHJ1bl93ZWJraXRfdGVzdHMucnVuKHBvcnRfb2JqLCBvcHRpb25zLCBhcmdzLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJ1aWxkYm90X291dHB1dD1idWlsZGJvdF9v dXRwdXQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVndWxhcl9vdXRwdXQ9cmVn dWxhcl9vdXRwdXQpCisgICAgcmV0dXJuIChyZXMsIGJ1aWxkYm90X291dHB1dCwgcmVndWxhcl9v dXRwdXQpCisKKworY2xhc3MgTWFpblRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgorICAgIGRlZiB0 ZXN0X2Zhc3Qoc2VsZik6CisgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShwYXNzaW5nX3J1bihbJy0t cGxhdGZvcm0nLCAndGVzdCddKSkKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHBhc3NpbmdfcnVu KFsnLS1wbGF0Zm9ybScsICd0ZXN0JywgJy0tcnVuLXNpbmdseSddKSkKKyAgICAgICAgc2VsZi5h c3NlcnRUcnVlKHBhc3NpbmdfcnVuKFsnLS1wbGF0Zm9ybScsICd0ZXN0JywKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAndGV4dC9hcnRpY2xlLWVsZW1lbnQuaHRtbCddKSkK KyAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHBhc3NpbmdfcnVuKFsnLS1wbGF0Zm9ybScsICd0ZXN0 JywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICctLWNoaWxkLXByb2Nlc3Nl cycsICcxJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnLS1wcmludCcs ICd1bmV4cGVjdGVkJ10pKQorCisgICAgZGVmIHRlc3RfY2hpbGRfcHJvY2Vzc2VzKHNlbGYpOgor ICAgICAgICAocmVzLCBidWlsZGJvdF9vdXRwdXQsIHJlZ3VsYXJfb3V0cHV0KSA9IGxvZ2dpbmdf cnVuKAorICAgICAgICAgICAgIFsnLS1wbGF0Zm9ybScsICd0ZXN0JywgJy0tcHJpbnQnLCAnY29u ZmlnJywgJy0tY2hpbGQtcHJvY2Vzc2VzJywKKyAgICAgICAgICAgICAgJzEnXSkKKyAgICAgICAg c2VsZi5hc3NlcnRUcnVlKCdSdW5uaW5nIG9uZSBEdW1wUmVuZGVyVHJlZVxuJworICAgICAgICAg ICAgICAgICAgICAgICAgaW4gcmVndWxhcl9vdXRwdXQuZ2V0KCkpCisKKyAgICAgICAgKHJlcywg YnVpbGRib3Rfb3V0cHV0LCByZWd1bGFyX291dHB1dCkgPSBsb2dnaW5nX3J1bigKKyAgICAgICAg ICAgICBbJy0tcGxhdGZvcm0nLCAndGVzdCcsICctLXByaW50JywgJ2NvbmZpZycsICctLWNoaWxk LXByb2Nlc3NlcycsCisgICAgICAgICAgICAgICcyJ10pCisgICAgICAgIHNlbGYuYXNzZXJ0VHJ1 ZSgnUnVubmluZyAyIER1bXBSZW5kZXJUcmVlcyBpbiBwYXJhbGxlbFxuJworICAgICAgICAgICAg ICAgICAgICAgICAgaW4gcmVndWxhcl9vdXRwdXQuZ2V0KCkpCisKKyAgICBkZWYgdGVzdF9sYXN0 X3Jlc3VsdHMoc2VsZik6CisgICAgICAgIHBhc3NpbmdfcnVuKFsnLS1wbGF0Zm9ybScsICd0ZXN0 J10pCisgICAgICAgIChyZXMsIGJ1aWxkYm90X291dHB1dCwgcmVndWxhcl9vdXRwdXQpID0gbG9n Z2luZ19ydW4oCisgICAgICAgICAgICBbJy0tcGxhdGZvcm0nLCAndGVzdCcsICctLXByaW50LWxh c3QtZmFpbHVyZXMnXSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChyZWd1bGFyX291dHB1dC5n ZXQoKSwgWydcblxuJ10pCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoYnVpbGRib3Rfb3V0cHV0 LmdldCgpLCBbXSkKKworCitkZWYgX21vY2tlZF9vcGVuKG9yaWdpbmFsX29wZW4sIGZpbGVfbGlz dCk6CisgICAgZGVmIF93cmFwcGVyKG5hbWUsIG1vZGUsIGVuY29kaW5nKToKKyAgICAgICAgaWYg bmFtZS5maW5kKCItZXhwZWN0ZWQuIikgIT0gLTEgYW5kIG1vZGUgPT0gInciOgorICAgICAgICAg ICAgIyB3ZSBkb24ndCB3YW50IHRvIGFjdHVhbGx5IHdyaXRlIG5ldyBiYXNlbGluZXMsIHNvIHN0 dWIgdGhlc2Ugb3V0CisgICAgICAgICAgICBuYW1lLnJlcGxhY2UoJ1xcJywgJy8nKQorICAgICAg ICAgICAgZmlsZV9saXN0LmFwcGVuZChuYW1lKQorICAgICAgICAgICAgcmV0dXJuIG9yaWdpbmFs X29wZW4ob3MuZGV2bnVsbCwgbW9kZSwgZW5jb2RpbmcpCisgICAgICAgIHJldHVybiBvcmlnaW5h bF9vcGVuKG5hbWUsIG1vZGUsIGVuY29kaW5nKQorICAgIHJldHVybiBfd3JhcHBlcgorCisKK2Ns YXNzIFJlYmFzZWxpbmVUZXN0KHVuaXR0ZXN0LlRlc3RDYXNlKToKKyAgICBkZWYgYXNzZXJ0QmFz ZWxpbmVzKHNlbGYsIGZpbGVfbGlzdCwgZmlsZSk6CisgICAgICAgICJhc3NlcnQgdGhhdCB0aGUg ZmlsZV9saXN0IGNvbnRhaW5zIHRoZSBiYXNlbGluZXMuIiIiCisgICAgICAgIGZvciBleHQgaW4g WyIudHh0IiwgIi5wbmciLCAiLmNoZWNrc3VtIl06CisgICAgICAgICAgICBiYXNlbGluZSA9IGZp bGUgKyAiLWV4cGVjdGVkIiArIGV4dAorICAgICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKGFueShm LmZpbmQoYmFzZWxpbmUpICE9IC0xIGZvciBmIGluIGZpbGVfbGlzdCkpCisKKyAgICBkZWYgdGVz dF9yZXNldF9yZXN1bHRzKHNlbGYpOgorICAgICAgICBmaWxlX2xpc3QgPSBbXQorICAgICAgICBv cmlnaW5hbF9vcGVuID0gY29kZWNzLm9wZW4KKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgIyBU ZXN0IHRoYXQgd2UgdXBkYXRlIGV4cGVjdGF0aW9ucyBpbiBwbGFjZS4gSWYgdGhlIGV4cGVjdGF0 aW9uCisgICAgICAgICAgICAjIGlzIG1zc2luZywgdXBkYXRlIHRoZSBleHBlY3RlZCBnZW5lcmlj IGxvY2F0aW9uLgorICAgICAgICAgICAgZmlsZV9saXN0ID0gW10KKyAgICAgICAgICAgIGNvZGVj cy5vcGVuID0gX21vY2tlZF9vcGVuKG9yaWdpbmFsX29wZW4sIGZpbGVfbGlzdCkKKyAgICAgICAg ICAgIHBhc3NpbmdfcnVuKFsnLS1wbGF0Zm9ybScsICd0ZXN0JywgJy0tcGl4ZWwtdGVzdHMnLAor ICAgICAgICAgICAgICAgICAgICAgICAgICctLXJlc2V0LXJlc3VsdHMnLAorICAgICAgICAgICAg ICAgICAgICAgICAgICdpbWFnZS9jYW52YXMtYmcuaHRtbCcsCisgICAgICAgICAgICAgICAgICAg ICAgICAgJ2ltYWdlL2NhbnZhcy16b29tLmh0bWwnLAorICAgICAgICAgICAgICAgICAgICAgICAg ICdtaXNjL21pc3NpbmctZXhwZWN0YXRpb24uaHRtbCddKQorICAgICAgICAgICAgc2VsZi5hc3Nl cnRFcXVhbChsZW4oZmlsZV9saXN0KSwgOSkKKyAgICAgICAgICAgIHNlbGYuYXNzZXJ0QmFzZWxp bmVzKGZpbGVfbGlzdCwKKyAgICAgICAgICAgICAgICAiZGF0YS9pbWFnZS9jYW52YXMtem9vbSIp CisgICAgICAgICAgICBzZWxmLmFzc2VydEJhc2VsaW5lcyhmaWxlX2xpc3QsCisgICAgICAgICAg ICAgICAgImRhdGEvcGxhdGZvcm0vdGVzdC9pbWFnZS9jYW52YXMtYmciKQorICAgICAgICAgICAg c2VsZi5hc3NlcnRCYXNlbGluZXMoZmlsZV9saXN0LAorICAgICAgICAgICAgICAgICJkYXRhL21p c2MvbWlzc2luZy1leHBlY3RhdGlvbiIpCisgICAgICAgIGZpbmFsbHk6CisgICAgICAgICAgICBj b2RlY3Mub3BlbiA9IG9yaWdpbmFsX29wZW4KKworICAgIGRlZiB0ZXN0X25ld19iYXNlbGluZShz ZWxmKToKKyAgICAgICAgZmlsZV9saXN0ID0gW10KKyAgICAgICAgb3JpZ2luYWxfb3BlbiA9IGNv ZGVjcy5vcGVuCisgICAgICAgIHRyeToKKyAgICAgICAgICAgICMgVGVzdCB0aGF0IHdlIHVwZGF0 ZSB0aGUgcGxhdGZvcm0gZXhwZWN0YXRpb25zLiBJZiB0aGUgZXhwZWN0YXRpb24KKyAgICAgICAg ICAgICMgaXMgbXNzaW5nLCB0aGVuIGNyZWF0ZSBhIG5ldyBleHBlY3RhdGlvbiBpbiB0aGUgcGxh dGZvcm0gZGlyLgorICAgICAgICAgICAgZmlsZV9saXN0ID0gW10KKyAgICAgICAgICAgIGNvZGVj cy5vcGVuID0gX21vY2tlZF9vcGVuKG9yaWdpbmFsX29wZW4sIGZpbGVfbGlzdCkKKyAgICAgICAg ICAgIHBhc3NpbmdfcnVuKFsnLS1wbGF0Zm9ybScsICd0ZXN0JywgJy0tcGl4ZWwtdGVzdHMnLAor ICAgICAgICAgICAgICAgICAgICAgICAgICctLW5ldy1iYXNlbGluZScsCisgICAgICAgICAgICAg ICAgICAgICAgICAgJ2ltYWdlL2NhbnZhcy16b29tLmh0bWwnLAorICAgICAgICAgICAgICAgICAg ICAgICAgICdpbWFnZS9jYW52YXMtYmcuaHRtbCcsCisgICAgICAgICAgICAgICAgICAgICAgICAg J21pc2MvbWlzc2luZy1leHBlY3RhdGlvbi5odG1sJ10pCisgICAgICAgICAgICBzZWxmLmFzc2Vy dEVxdWFsKGxlbihmaWxlX2xpc3QpLCA5KQorICAgICAgICAgICAgc2VsZi5hc3NlcnRCYXNlbGlu ZXMoZmlsZV9saXN0LAorICAgICAgICAgICAgICAgICJkYXRhL3BsYXRmb3JtL3Rlc3QvaW1hZ2Uv Y2FudmFzLXpvb20iKQorICAgICAgICAgICAgc2VsZi5hc3NlcnRCYXNlbGluZXMoZmlsZV9saXN0 LAorICAgICAgICAgICAgICAgICJkYXRhL3BsYXRmb3JtL3Rlc3QvaW1hZ2UvY2FudmFzLWJnIikK KyAgICAgICAgICAgIHNlbGYuYXNzZXJ0QmFzZWxpbmVzKGZpbGVfbGlzdCwKKyAgICAgICAgICAg ICAgICAiZGF0YS9wbGF0Zm9ybS90ZXN0L21pc2MvbWlzc2luZy1leHBlY3RhdGlvbiIpCisgICAg ICAgIGZpbmFsbHk6CisgICAgICAgICAgICBjb2RlY3Mub3BlbiA9IG9yaWdpbmFsX29wZW4KKwor Y2xhc3MgVGVzdFJ1bm5lclRlc3QodW5pdHRlc3QuVGVzdENhc2UpOgorICAgIGRlZiB0ZXN0X3Jl c3VsdHNfaHRtbChzZWxmKToKKyAgICAgICAgbW9ja19wb3J0ID0gTW9jaygpCisgICAgICAgIG1v Y2tfcG9ydC5yZWxhdGl2ZV90ZXN0X2ZpbGVuYW1lID0gbGFtYmRhIG5hbWU6IG5hbWUKKyAgICAg ICAgbW9ja19wb3J0LmZpbGVuYW1lX3RvX3VyaSA9IGxhbWJkYSBuYW1lOiBuYW1lCisKKyAgICAg ICAgcnVubmVyID0gcnVuX3dlYmtpdF90ZXN0cy5UZXN0UnVubmVyKHBvcnQ9bW9ja19wb3J0LCBv cHRpb25zPU1vY2soKSwgcHJpbnRlcj1Nb2NrKCkpCisgICAgICAgIGV4cGVjdGVkX2h0bWwgPSB1 IiIiPGh0bWw+CisgIDxoZWFkPgorICAgIDx0aXRsZT5MYXlvdXQgVGVzdCBSZXN1bHRzICh0aW1l KTwvdGl0bGU+CisgIDwvaGVhZD4KKyAgPGJvZHk+CisgICAgPGgyPlRpdGxlICh0aW1lKTwvaDI+ CisgICAgICAgIDxwPjxhIGhyZWY9J3Rlc3RfcGF0aCc+dGVzdF9wYXRoPC9hPjxiciAvPgorPC9w PgorPC9ib2R5PjwvaHRtbD4KKyIiIgorICAgICAgICBodG1sID0gcnVubmVyLl9yZXN1bHRzX2h0 bWwoWyJ0ZXN0X3BhdGgiXSwge30sICJUaXRsZSIsIG92ZXJyaWRlX3RpbWU9InRpbWUiKQorICAg ICAgICBzZWxmLmFzc2VydEVxdWFsKGh0bWwsIGV4cGVjdGVkX2h0bWwpCisKKworY2xhc3MgRHJ5 cnVuVGVzdCh1bml0dGVzdC5UZXN0Q2FzZSk6CisgICAgZGVmIHRlc3RfYmFzaWNzKHNlbGYpOgor ICAgICAgICAjIEZJWE1FOiBpdCdzIGhhcmQgdG8ga25vdyB3aGljaCBwbGF0Zm9ybXMgYXJlIHNh ZmUgdG8gdGVzdDsgdGhlCisgICAgICAgICMgY2hyb21pdW0gcGxhdGZvcm1zIHJlcXVpcmUgYSBj aHJvbWl1bSBjaGVja291dCwgYW5kIHRoZSBtYWMgcGxhdGZvcm0KKyAgICAgICAgIyByZXF1aXJl cyBmY250bCwgc28gaXQgY2FuJ3QgYmUgdGVzdGVkIG9uIHdpbjMyLCBldGMuIFRoZXJlIGlzCisg ICAgICAgICMgcHJvYmFibHkgYSBiZXR0ZXIgd2F5IG9mIGhhbmRsaW5nIHRoaXMuCisgICAgICAg IGlmIHN5cy5wbGF0Zm9ybSAhPSAibWFjIjoKKyAgICAgICAgICAgIHJldHVybgorICAgICAgICBz ZWxmLmFzc2VydFRydWUocGFzc2luZ19ydW4oWyctLXBsYXRmb3JtJywgJ2RyeXJ1bicsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ2Zhc3QvaHRtbCddKSkKKyAgICAgICAg c2VsZi5hc3NlcnRUcnVlKHBhc3NpbmdfcnVuKFsnLS1wbGF0Zm9ybScsICdkcnlydW4tbWFjJywK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnZmFzdC9odG1sJ10pKQorCisK K2lmIF9fbmFtZV9fID09ICdfX21haW5fXyc6CisgICAgdW5pdHRlc3QubWFpbigpCmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFj a2FnZS90ZXN0X2V4cGVjdGF0aW9ucy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL3Rlc3RfZXhwZWN0YXRpb25zLnB5CmluZGV4IDUw OGE2YWQ3N2VkY2QwMTA5YzJkYTIxODQ3M2UyM2UzMTY3ZWE4ZGEuLjFiM2ZmMDNkZWMxMjgzNzM2 ZWRiZmNiMmU0NzI4N2FlZGNmOGE1MGUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL3Rlc3RfZXhwZWN0YXRpb25zLnB5 CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9w YWNrYWdlL3Rlc3RfZXhwZWN0YXRpb25zLnB5CkBAIC00Miw4ICs0Miw4IEBAIF9sb2cgPSBsb2dn aW5nLmdldExvZ2dlcigid2Via2l0cHkubGF5b3V0X3Rlc3RzLmxheW91dF9wYWNrYWdlLiIKICAg ICAgICAgICAgICAgICAgICAgICAgICAidGVzdF9leHBlY3RhdGlvbnMiKQogCiAjIFRlc3QgZXhw ZWN0YXRpb24gYW5kIG1vZGlmaWVyIGNvbnN0YW50cy4KLShQQVNTLCBGQUlMLCBURVhULCBJTUFH RSwgSU1BR0VfUExVU19URVhULCBUSU1FT1VULCBDUkFTSCwgU0tJUCwgV09OVEZJWCwKLSBERUZF UiwgU0xPVywgUkVCQVNFTElORSwgTUlTU0lORywgRkxBS1ksIE5PVywgTk9ORSkgPSByYW5nZSgx NikKKyhQQVNTLCBGQUlMLCBURVhULCBJTUFHRSwgSU1BR0VfUExVU19URVhULCBSRUZURVNUX01J U01BVENILCBUSU1FT1VULCBDUkFTSCwgU0tJUCwgV09OVEZJWCwKKyBERUZFUiwgU0xPVywgUkVC QVNFTElORSwgTUlTU0lORywgRkxBS1ksIE5PVywgTk9ORSkgPSByYW5nZSgxNykKIAogIyBUZXN0 IGV4cGVjdGF0aW9uIGZpbGUgdXBkYXRlIGFjdGlvbiBjb25zdGFudHMKIChOT19DSEFOR0UsIFJF TU9WRV9URVNULCBSRU1PVkVfUExBVEZPUk0sIEFERF9QTEFURk9STVNfRVhDRVBUX1RISVMpID0g cmFuZ2UoNCkKQEAgLTEzMiw3ICsxMzIsNyBAQCBjbGFzcyBUZXN0RXhwZWN0YXRpb25zOgogICAg ICAgICByZXR1cm4gc2VsZi5fZXhwZWN0ZWRfZmFpbHVyZXMuZ2V0X2V4cGVjdGF0aW9ucyh0ZXN0 KQogCiAgICAgZGVmIGdldF9leHBlY3RhdGlvbnNfc3RyaW5nKHNlbGYsIHRlc3QpOgotICAgICAg ICAiIiJSZXR1cm5zIHRoZSBleHBlY3RhdG9ucyBmb3IgdGhlIGdpdmVuIHRlc3QgYXMgYW4gdXBw ZXJjYXNlIHN0cmluZy4KKyAgICAgICAgIiIiUmV0dXJucyB0aGUgZXhwZWN0YXRpb25zIGZvciB0 aGUgZ2l2ZW4gdGVzdCBhcyBhbiB1cHBlcmNhc2Ugc3RyaW5nLgogICAgICAgICBJZiB0aGVyZSBh cmUgbm8gZXhwZWN0YXRpb25zIGZvciB0aGUgdGVzdCwgdGhlbiAiUEFTUyIgaXMgcmV0dXJuZWQu IiIiCiAgICAgICAgIGV4cGVjdGF0aW9ucyA9IHNlbGYuZ2V0X2V4cGVjdGF0aW9ucyh0ZXN0KQog ICAgICAgICByZXR2YWwgPSBbXQpAQCAtMjU3LDYgKzI1Nyw3IEBAIGNsYXNzIFRlc3RFeHBlY3Rh dGlvbnNGaWxlOgogICAgICAgICAgICAgICAgICAgICAndGV4dCc6IFRFWFQsCiAgICAgICAgICAg ICAgICAgICAgICdpbWFnZSc6IElNQUdFLAogICAgICAgICAgICAgICAgICAgICAnaW1hZ2UrdGV4 dCc6IElNQUdFX1BMVVNfVEVYVCwKKyAgICAgICAgICAgICAgICAgICAgJ3JlZnRlc3QnOiBSRUZU RVNUX01JU01BVENILAogICAgICAgICAgICAgICAgICAgICAndGltZW91dCc6IFRJTUVPVVQsCiAg ICAgICAgICAgICAgICAgICAgICdjcmFzaCc6IENSQVNILAogICAgICAgICAgICAgICAgICAgICAn bWlzc2luZyc6IE1JU1NJTkd9CkBAIC0yNjksNiArMjcwLDggQEAgY2xhc3MgVGVzdEV4cGVjdGF0 aW9uc0ZpbGU6CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIElNQUdFOiAoJ2ltYWdl IG1pc21hdGNoJywgJ2ltYWdlIG1pc21hdGNoJyksCiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIElNQUdFX1BMVVNfVEVYVDogKCdpbWFnZSBhbmQgdGV4dCBtaXNtYXRjaCcsCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdpbWFnZSBhbmQg dGV4dCBtaXNtYXRjaCcpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBSRUZURVNU X01JU01BVENIOiAoJ3JlZnRlc3QgbWlzbWF0Y2gnLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgJ3JlZnRlc3QgbWlzbWF0Y2gnKSwKICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgQ1JBU0g6ICgnRHVtcFJlbmRlclRyZWUgY3Jhc2gnLAog ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdEdW1wUmVuZGVyVHJlZSBj cmFzaGVzJyksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFRJTUVPVVQ6ICgndGVz dCB0aW1lZCBvdXQnLCAndGVzdHMgdGltZWQgb3V0JyksCmRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS90ZXN0X2ZhaWx1 cmVzLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0 X3BhY2thZ2UvdGVzdF9mYWlsdXJlcy5weQppbmRleCAzNDBkMDc1M2JiMTBmM2E3OTVlYzhiODg3 M2FiZjJiODFiMmYzZjM1Li5lNzFlMzdiNDNjMDkyZDBjZDU0NzAxYjg1OTdiNmFjZGMxMDJiNjhl IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9s YXlvdXRfcGFja2FnZS90ZXN0X2ZhaWx1cmVzLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL3Rlc3RfZmFpbHVyZXMucHkKQEAg LTYyLDYgKzYyLDggQEAgZGVmIGRldGVybWluZV9yZXN1bHRfdHlwZShmYWlsdXJlX2xpc3QpOgog ICAgICAgICAgICAgcmV0dXJuIHRlc3RfZXhwZWN0YXRpb25zLlRFWFQKICAgICAgICAgZWxpZiBp c19pbWFnZV9mYWlsdXJlOgogICAgICAgICAgICAgcmV0dXJuIHRlc3RfZXhwZWN0YXRpb25zLklN QUdFCisgICAgICAgIGVsaWYgRmFpbHVyZVJlZnRlc3RNaXNtYXRjaCBpbiBmYWlsdXJlX3R5cGVz OgorICAgICAgICAgICAgcmV0dXJuIHRlc3RfZXhwZWN0YXRpb25zLlJFRlRFU1RfTUlTTUFUQ0gK ICAgICAgICAgZWxzZToKICAgICAgICAgICAgIHJhaXNlIFZhbHVlRXJyb3IoInVuY2xhc3NpZmlh YmxlIHNldCBvZiBmYWlsdXJlczogIgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICArIHN0 cihmYWlsdXJlX3R5cGVzKSkKQEAgLTI2MCwzICsyNjIsMjAgQEAgY2xhc3MgRmFpbHVyZUltYWdl SGFzaEluY29ycmVjdChGYWlsdXJlV2l0aFR5cGUpOgogCiAgICAgZGVmIHJlc3VsdF9odG1sX291 dHB1dChzZWxmLCBmaWxlbmFtZSk6CiAgICAgICAgIHJldHVybiAiPHN0cm9uZz4lczwvc3Ryb25n PiIgJSBzZWxmLm1lc3NhZ2UoKQorCisKK2NsYXNzIEZhaWx1cmVSZWZ0ZXN0TWlzbWF0Y2goRmFp bHVyZVdpdGhUeXBlKToKKyAgICAiIiJUaGUgcmVuZGVyaW5nIG1pc21hdGNoZWQgdGhlIHJlZmVy ZW5jZSByZW5kZXJpbmcuIiIiCisgICAgT1VUX0ZJTEVOQU1FUyA9IFsiLWFjdHVhbC5wbmciLCAi LWV4cGVjdGVkLmh0bWwiLCAiLWV4cGVjdGVkLnBuZyIsICAiLWRpZmYucG5nIl0KKworICAgIEBz dGF0aWNtZXRob2QKKyAgICBkZWYgbWVzc2FnZSgpOgorICAgICAgICByZXR1cm4gIlJlZmVyZW5j ZSBtaXNtYXRjaCIKKworICAgIGRlZiBvdXRwdXRfbGlua3Moc2VsZiwgZmlsZW5hbWUsIG91dF9u YW1lcyk6CisgICAgICAgIGxpbmtzID0gWycnXQorICAgICAgICB1cmlzID0gW3NlbGYucmVsYXRp dmVfb3V0cHV0X2ZpbGVuYW1lKGZpbGVuYW1lLCBmbikgZm9yCisgICAgICAgICAgICAgICAgZm4g aW4gb3V0X25hbWVzXQorICAgICAgICBmb3IgdGV4dCwgdXJpIGluIHppcChbJ2FjdHVhbCcsICdy ZWZlcmVuY2UnLCAncmVmZXJlbmNlIHJlbmRlcmluZycsICdkaWZmJ10sIHVyaXMpOgorICAgICAg ICAgICAgbGlua3MuYXBwZW5kKCI8YSBocmVmPSclcyc+JXM8L2E+IiAlICh1cmksIHRleHQpKQor ICAgICAgICByZXR1cm4gJyAnLmpvaW4obGlua3MpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkgYi9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKaW5kZXggMzJhNGUxNzI5 NjUwMTYwZWE0ZDc3YmU2OTZhNGIxMzlmMTVmMjY3Yy4uMDAwMGVmYTQzNmIzYTUwMDcwYmI4ZDgz NGM0NGE5MDFhNWM0OGYzZiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZS5weQpAQCAtMjgwLDYgKzI4MCwxNCBAQCBjbGFz cyBQb3J0KG9iamVjdCk6CiAgICAgICAgICAgICByZXR1cm4gJycKICAgICAgICAgcmV0dXJuIHRl eHQuc3RyaXAoIlxyXG4iKS5yZXBsYWNlKCJcclxuIiwgIlxuIikgKyAiXG4iCiAKKyAgICBkZWYg ZXhwZWN0ZWRfaHRtbF9maWxlbmFtZShzZWxmLCBmaWxlbmFtZSk6CisgICAgICAgICMgRklYTUUo aGF5YXRvKTogQWRkIGEgY29tbWVudAorICAgICAgICByZXR1cm4gc2VsZi5leHBlY3RlZF9maWxl bmFtZShmaWxlbmFtZSwgJy5odG1sJykKKworICAgIGRlZiBleHBlY3RlZF9taXNtYXRjaF9odG1s X2ZpbGVuYW1lKHNlbGYsIGZpbGVuYW1lKToKKyAgICAgICAgIyBGSVhNRShoYXlhdG8pOiBBZGQg YSBjb21tZW50CisgICAgICAgIHJldHVybiBzZWxmLmV4cGVjdGVkX2ZpbGVuYW1lKGZpbGVuYW1l LCAnLW1pc21hdGNoLmh0bWwnKQorCiAgICAgZGVmIGZpbGVuYW1lX3RvX3VyaShzZWxmLCBmaWxl bmFtZSk6CiAgICAgICAgICIiIkNvbnZlcnQgYSB0ZXN0IGZpbGUgdG8gYSBVUkkuIiIiCiAgICAg ICAgIExBWU9VVFRFU1RfSFRUUF9ESVIgPSAiaHR0cC90ZXN0cy8iCmRpZmYgLS1naXQgYS9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3Rlc3RfZmlsZXMucHkg Yi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3Rlc3RfZmls ZXMucHkKaW5kZXggM2ZhMGZiMzY0YmIzMTk2MDJlNjE5YWRmNWRkNTFkMzJiMGY1N2E1Mi4uOWI0 YWVjNjE3ZDVkNTI4MGU2NmFiOWQxYjA3YjVjOGRjYTIwOGE0MyAxMDA2NDQKLS0tIGEvV2ViS2l0 VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0X2ZpbGVzLnB5Cisr KyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvdGVzdF9m aWxlcy5weQpAQCAtNTAsNiArNTAsOSBAQCBfc3VwcG9ydGVkX2ZpbGVfZXh0ZW5zaW9ucyA9IHNl dChbJy5odG1sJywgJy5zaHRtbCcsICcueG1sJywgJy54aHRtbCcsICcueGh0bWxtcAogIyBXaGVu IGNvbGxlY3RpbmcgdGVzdCBjYXNlcywgc2tpcCB0aGVzZSBkaXJlY3RvcmllcwogX3NraXBwZWRf ZGlyZWN0b3JpZXMgPSBzZXQoWycuc3ZuJywgJ19zdm4nLCAncmVzb3VyY2VzJywgJ3NjcmlwdC10 ZXN0cyddKQogCisjIFdoZW4gY29sbGVjdGluZyB0ZXN0IGNhc2VzLCBza2lwIGZpbGVzIHdpdGgg dGhlc2Ugc3VmZml4ZXMuCitfcmVmdGVzdF9leHBlY3RlZF9zdWZmaXhlcyA9IHNldChbJy1leHBl Y3RlZC5odG1sJywgJ2V4cGVjdGVkLW1pc21hdGNoLmh0bWwnXSkKKwogCiBkZWYgZmluZChwb3J0 LCBwYXRocyk6CiAgICAgIiIiRmluZHMgdGhlIHNldCBvZiB0ZXN0cyB1bmRlciBwb3J0LmxheW91 dF90ZXN0c19kaXIoKS4KQEAgLTc4LDcgKzgxLDcgQEAgZGVmIGZpbmQocG9ydCwgcGF0aHMpOgog ICAgICMgTm93IHdhbGsgYWxsIHRoZSBwYXRocyBwYXNzZWQgaW4gb24gdGhlIGNvbW1hbmQgbGlu ZSBhbmQgZ2V0IGZpbGVuYW1lcwogICAgIHRlc3RfZmlsZXMgPSBzZXQoKQogICAgIGZvciBwYXRo IGluIHBhdGhzX3RvX3dhbGs6Ci0gICAgICAgIGlmIG9zLnBhdGguaXNmaWxlKHBhdGgpIGFuZCBf aGFzX3N1cHBvcnRlZF9leHRlbnNpb24ocGF0aCk6CisgICAgICAgIGlmIG9zLnBhdGguaXNmaWxl KHBhdGgpIGFuZCBfaXNfdGVzdF9maWxlKHBhdGgpOgogICAgICAgICAgICAgdGVzdF9maWxlcy5h ZGQob3MucGF0aC5ub3JtcGF0aChwYXRoKSkKICAgICAgICAgICAgIGNvbnRpbnVlCiAKQEAgLTk1 LDcgKzk4LDcgQEAgZGVmIGZpbmQocG9ydCwgcGF0aHMpOgogICAgICAgICAgICAgICAgICAgICBk aXJzLnJlbW92ZShkaXJlY3RvcnkpCiAKICAgICAgICAgICAgIGZvciBmaWxlbmFtZSBpbiBmaWxl czoKLSAgICAgICAgICAgICAgICBpZiBfaGFzX3N1cHBvcnRlZF9leHRlbnNpb24oZmlsZW5hbWUp OgorICAgICAgICAgICAgICAgIGlmIF9pc190ZXN0X2ZpbGUoZmlsZW5hbWUpOgogICAgICAgICAg ICAgICAgICAgICBmaWxlbmFtZSA9IG9zLnBhdGguam9pbihyb290LCBmaWxlbmFtZSkKICAgICAg ICAgICAgICAgICAgICAgZmlsZW5hbWUgPSBvcy5wYXRoLm5vcm1wYXRoKGZpbGVuYW1lKQogICAg ICAgICAgICAgICAgICAgICB0ZXN0X2ZpbGVzLmFkZChmaWxlbmFtZSkKQEAgLTEwNiw4ICsxMDks MTIgQEAgZGVmIGZpbmQocG9ydCwgcGF0aHMpOgogICAgIHJldHVybiB0ZXN0X2ZpbGVzCiAKIAot ZGVmIF9oYXNfc3VwcG9ydGVkX2V4dGVuc2lvbihmaWxlbmFtZSk6Ci0gICAgIiIiUmV0dXJuIHRy dWUgaWYgZmlsZW5hbWUgaXMgb25lIG9mIHRoZSBmaWxlIGV4dGVuc2lvbnMgd2Ugd2FudCB0byBy dW4gYQotICAgIHRlc3Qgb24uIiIiCitkZWYgX2lzX3Rlc3RfZmlsZShmaWxlbmFtZSk6CisgICAg IiIiUmV0dXJuIHRydWUgaWYgZmlsZW5hbWUgcmVwcmVzZW50cyB0ZXN0IGNhc2VzIHdlIHdhbnQg dG8gcnVuIGEgdGVzdCBvbi4iIiIKICAgICBleHRlbnNpb24gPSBvcy5wYXRoLnNwbGl0ZXh0KGZp bGVuYW1lKVsxXQotICAgIHJldHVybiBleHRlbnNpb24gaW4gX3N1cHBvcnRlZF9maWxlX2V4dGVu c2lvbnMKKyAgICBpZiBleHRlbnNpb24gbm90IGluIF9zdXBwb3J0ZWRfZmlsZV9leHRlbnNpb25z OgorICAgICAgICByZXR1cm4gRmFsc2UKKyAgICBmb3Igc3VmZml4IGluIF9yZWZ0ZXN0X2V4cGVj dGVkX3N1ZmZpeGVzOgorICAgICAgICBpZiBmaWxlbmFtZS5lbmRzd2l0aChzdWZmaXgpOgorICAg ICAgICAgICAgcmV0dXJuIEZhbHNlCisgICAgcmV0dXJuIFRydWUKZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkg Yi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rl c3RzLnB5CmluZGV4IDUxOTNkYmRjZjNlM2NjMzdiNjMwYmJkYmQwZjQ3NzA0NGE5ZWVhYjIuLmI3 ZTY1ODBlMjdkZGNlOWE2NWJmMzliZTFiNDRkODBlNzMyZDNjYmMgMTAwNzU1Ci0tLSBhL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkK KysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtp dF90ZXN0cy5weQpAQCAtNTMsNyArNTMsOSBAQCBpbXBvcnQgbG9nZ2luZwogaW1wb3J0IG1hdGgK IGltcG9ydCBvcHRwYXJzZQogaW1wb3J0IG9zCitpbXBvcnQgcGRiCiBpbXBvcnQgcGxhdGZvcm0K K2ltcG9ydCBwcHJpbnQKIGltcG9ydCBRdWV1ZQogaW1wb3J0IHJhbmRvbQogaW1wb3J0IHJlCkBA IC03MCw2ICs3Miw3IEBAIGZyb20gbGF5b3V0X3BhY2thZ2UgaW1wb3J0IHRlc3RfZXhwZWN0YXRp b25zCiBmcm9tIGxheW91dF9wYWNrYWdlIGltcG9ydCB0ZXN0X2ZhaWx1cmVzCiBmcm9tIGxheW91 dF9wYWNrYWdlIGltcG9ydCB0ZXN0X3Jlc3VsdHNfdXBsb2FkZXIKIGZyb20gdGVzdF90eXBlcyBp bXBvcnQgaW1hZ2VfZGlmZgorZnJvbSB0ZXN0X3R5cGVzIGltcG9ydCByZWZ0ZXN0X2RpZmYKIGZy b20gdGVzdF90eXBlcyBpbXBvcnQgdGV4dF9kaWZmCiBmcm9tIHRlc3RfdHlwZXMgaW1wb3J0IHRl c3RfdHlwZV9iYXNlCiAKQEAgLTg2LDYgKzg5LDcgQEAgQlVJTERFUl9CQVNFX1VSTCA9ICJodHRw Oi8vYnVpbGQuY2hyb21pdW0ub3JnL2J1aWxkYm90L2xheW91dF90ZXN0X3Jlc3VsdHMvIgogVGVz dEV4cGVjdGF0aW9uc0ZpbGUgPSB0ZXN0X2V4cGVjdGF0aW9ucy5UZXN0RXhwZWN0YXRpb25zRmls ZQogCiAKKwogY2xhc3MgVGVzdEluZm86CiAgICAgIiIiR3JvdXBzIGluZm9ybWF0aW9uIGFib3V0 IGEgdGVzdCBmb3IgZWFzeSBwYXNzaW5nIG9mIGRhdGEuIiIiCiAKQEAgLTEwMSw2ICsxMDUsMjIg QEAgY2xhc3MgVGVzdEluZm86CiAgICAgICAgIHNlbGYudGltZW91dCA9IHRpbWVvdXQKICAgICAg ICAgc2VsZi5faW1hZ2VfY2hlY2tzdW0gPSAtMQogCisgICAgICAgIHNlbGYuaXNfcmVmdGVzdCA9 IEZhbHNlCisKKyAgICAgICAgZXhwZWN0ZWRfaHRtbF9maWxlbmFtZSA9IHBvcnQuZXhwZWN0ZWRf aHRtbF9maWxlbmFtZShmaWxlbmFtZSkKKyAgICAgICAgaWYgb3MucGF0aC5pc2ZpbGUoZXhwZWN0 ZWRfaHRtbF9maWxlbmFtZSk6CisgICAgICAgICAgICBzZWxmLmlzX3JlZnRlc3QgPSBUcnVlCisg ICAgICAgICAgICBzZWxmLmV4cGVjdGVkX2h0bWxfZmlsZW5hbWUgPSBleHBlY3RlZF9odG1sX2Zp bGVuYW1lCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBzZWxmLmV4cGVjdGVkX2h0bWxfZmls ZW5hbWUgPSBOb25lCisKKyAgICAgICAgZXhwZWN0ZWRfbWlzbWF0Y2hfaHRtbF9maWxlbmFtZSA9 IHBvcnQuZXhwZWN0ZWRfbWlzbWF0Y2hfaHRtbF9maWxlbmFtZShmaWxlbmFtZSkKKyAgICAgICAg aWYgb3MucGF0aC5pc2ZpbGUoZXhwZWN0ZWRfbWlzbWF0Y2hfaHRtbF9maWxlbmFtZSk6CisgICAg ICAgICAgICBzZWxmLmlzX3JlZnRlc3QgPSBUcnVlCisgICAgICAgICAgICBzZWxmLmV4cGVjdGVk X21pc21hdGNoX2h0bWxfZmlsZW5hbWUgPSBleHBlY3RlZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1l CisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBzZWxmLmV4cGVjdGVkX21pc21hdGNoX2h0bWxf ZmlsZW5hbWUgPSBOb25lCisKICAgICBkZWYgaW1hZ2VfaGFzaChzZWxmKToKICAgICAgICAgIyBS ZWFkIHRoZSBpbWFnZV9oYXNoIGxhemlseSB0byByZWR1Y2Ugc3RhcnR1cCB0aW1lLgogICAgICAg ICAjIFRoaXMgY2xhc3MgaXMgYWNjZXNzZWQgYWNyb3NzIHRocmVhZHMsIGJ1dCBvbmx5IG9uZSB0 aHJlYWQgc2hvdWxkCkBAIC0xMTIsNiArMTMyLDE1IEBAIGNsYXNzIFRlc3RJbmZvOgogICAgICAg ICAgICAgc2VsZi5faW1hZ2VfY2hlY2tzdW0gPSBzZWxmLl9wb3J0LmV4cGVjdGVkX2NoZWNrc3Vt KHNlbGYuZmlsZW5hbWUpCiAgICAgICAgIHJldHVybiBzZWxmLl9pbWFnZV9jaGVja3N1bQogCisg ICAgZGVmIF9fc3RyX18oc2VsZik6CisgICAgICAgIHJldHVybiAoJ2ZpbGVuYW1lOiAlcywgdXJp OiAlcywgdGltZW91dDogJXMsJworICAgICAgICAgICAgICAgICcgaXNfcmVmdGVzdDogJXMnCisg ICAgICAgICAgICAgICAgJSAoc2VsZi5maWxlbmFtZSwgc2VsZi51cmksIHNlbGYudGltZW91dCwK KyAgICAgICAgICAgICAgICAgICBzZWxmLmlzX3JlZnRlc3QpKQorCisgICAgZGVmIF9fcmVwcl9f KHNlbGYpOgorICAgICAgICByZXR1cm4gc3RyKHNlbGYpCisKIAogY2xhc3MgUmVzdWx0U3VtbWFy eShvYmplY3QpOgogICAgICIiIkEgY2xhc3MgZm9yIHBhcnRpdGlvbmluZyB0aGUgdGVzdCByZXN1 bHRzIHdlIGdldCBpbnRvIGJ1Y2tldHMuCkBAIC0xMjUsNiArMTU0LDcgQEAgY2xhc3MgUmVzdWx0 U3VtbWFyeShvYmplY3QpOgogICAgICAgICBzZWxmLmV4cGVjdGF0aW9ucyA9IGV4cGVjdGF0aW9u cwogICAgICAgICBzZWxmLmV4cGVjdGVkID0gMAogICAgICAgICBzZWxmLnVuZXhwZWN0ZWQgPSAw CisgICAgICAgICMgVE9ETyhoYXlhdG8pOiBVcGRhdGUgdGVzdHNfYnlfZXhwZWN0YXRpb24KICAg ICAgICAgc2VsZi50ZXN0c19ieV9leHBlY3RhdGlvbiA9IHt9CiAgICAgICAgIHNlbGYudGVzdHNf YnlfdGltZWxpbmUgPSB7fQogICAgICAgICBzZWxmLnJlc3VsdHMgPSB7fQpAQCAtMjY3LDYgKzI5 NywxMCBAQCBjbGFzcyBUZXN0UnVubmVyOgogICAgICAgICBpZiBvcHRpb25zLnBpeGVsX3Rlc3Rz OgogICAgICAgICAgICAgc2VsZi5fdGVzdF90eXBlcy5hcHBlbmQoaW1hZ2VfZGlmZi5JbWFnZURp ZmYpCiAKKyAgICAgICAgc2VsZi5fcmVmdGVzdF90eXBlcyA9IFtdCisgICAgICAgIGlmIG9wdGlv bnMucnVuX3JlZnRlc3RzOgorICAgICAgICAgICAgc2VsZi5fcmVmdGVzdF90eXBlcy5hcHBlbmQo cmVmdGVzdF9kaWZmLlJlZnRlc3REaWZmKQorCiAgICAgICAgICMgYSBzZXQgb2YgdGVzdCBmaWxl cywgYW5kIHRoZSBzYW1lIHRlc3RzIGFzIGEgbGlzdAogICAgICAgICBzZWxmLl90ZXN0X2ZpbGVz ID0gc2V0KCkKICAgICAgICAgc2VsZi5fdGVzdF9maWxlc19saXN0ID0gTm9uZQpAQCAtMjg3LDYg KzMyMSw4IEBAIGNsYXNzIFRlc3RSdW5uZXI6CiAgICAgICAgICAgICBwYXRocyArPSByZWFkX3Rl c3RfZmlsZXMoc2VsZi5fb3B0aW9ucy50ZXN0X2xpc3QpCiAgICAgICAgIHNlbGYuX3Rlc3RfZmls ZXMgPSBzZWxmLl9wb3J0LnRlc3RzKHBhdGhzKQogCisgICAgICAgIF9sb2cuaW5mbygndGVzdF9m aWxlczogJXMnICUgc2VsZi5fdGVzdF9maWxlcykKKwogICAgIGRlZiBsaW50KHNlbGYpOgogICAg ICAgICAjIENyZWF0aW5nIHRoZSBleHBlY2F0aW9ucyBmb3IgZWFjaCBwbGF0Zm9ybS9jb25maWd1 cmF0aW9uIHBhaXIgZG9lcwogICAgICAgICAjIGFsbCB0aGUgdGVzdCBsaXN0IHBhcnNpbmcgYW5k IGVuc3VyZXMgaXQncyBjb3JyZWN0IHN5bnRheCAoZS5nLiBubwpAQCAtNDkzLDYgKzUyOSw3IEBA IGNsYXNzIFRlc3RSdW5uZXI6CiAgICAgICAgICIiIlJldHVybnMgdGhlIGFwcHJvcHJpYXRlIFRl c3RJbmZvIG9iamVjdCBmb3IgdGhlIGZpbGUuIE1vc3RseSB0aGlzCiAgICAgICAgIGlzIHVzZWQg Zm9yIGxvb2tpbmcgdXAgdGhlIHRpbWVvdXQgdmFsdWUgKGluIG1zKSB0byB1c2UgZm9yIHRoZSBn aXZlbgogICAgICAgICB0ZXN0LiIiIgorICAgICAgICAjIEZJWE1FOiBTdXBwb3J0IHJlZiB0ZXN0 Lmh0bWwKICAgICAgICAgaWYgc2VsZi5fZXhwZWN0YXRpb25zLmhhc19tb2RpZmllcih0ZXN0X2Zp bGUsIHRlc3RfZXhwZWN0YXRpb25zLlNMT1cpOgogICAgICAgICAgICAgcmV0dXJuIFRlc3RJbmZv KHNlbGYuX3BvcnQsIHRlc3RfZmlsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxm Ll9vcHRpb25zLnNsb3dfdGltZV9vdXRfbXMpCkBAIC01NjEsNyArNTk4LDcgQEAgY2xhc3MgVGVz dFJ1bm5lcjoKICAgICAgICAgIiIiUmV0dXJucyB0aGUgdHVwbGUgb2YgYXJndW1lbnRzIGZvciB0 ZXN0cyBhbmQgZm9yIER1bXBSZW5kZXJUcmVlLiIiIgogICAgICAgICB0ZXN0X2FyZ3MgPSB0ZXN0 X3R5cGVfYmFzZS5UZXN0QXJndW1lbnRzKCkKICAgICAgICAgdGVzdF9hcmdzLnBuZ19wYXRoID0g Tm9uZQotICAgICAgICBpZiBzZWxmLl9vcHRpb25zLnBpeGVsX3Rlc3RzOgorICAgICAgICBpZiBz ZWxmLl9vcHRpb25zLnBpeGVsX3Rlc3RzIG9yIHNlbGYuX29wdGlvbnMucnVuX3JlZnRlc3RzOgog ICAgICAgICAgICAgcG5nX3BhdGggPSBvcy5wYXRoLmpvaW4oc2VsZi5fb3B0aW9ucy5yZXN1bHRz X2RpcmVjdG9yeSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJwbmdfcmVz dWx0JXMucG5nIiAlIGluZGV4KQogICAgICAgICAgICAgdGVzdF9hcmdzLnBuZ19wYXRoID0gcG5n X3BhdGgKQEAgLTU4Nyw2ICs2MjQsNyBAQCBjbGFzcyBUZXN0UnVubmVyOgogCiAgICAgICAgICMg SW5zdGFudGlhdGUgVGVzdFNoZWxsVGhyZWFkcyBhbmQgc3RhcnQgdGhlbS4KICAgICAgICAgdGhy ZWFkcyA9IFtdCisgICAgICAgIF9sb2cuaW5mbygnY2hpbGRfcHJvY2Vzc2VzOiAlcycgJSBzZWxm Ll9vcHRpb25zLmNoaWxkX3Byb2Nlc3NlcykKICAgICAgICAgZm9yIGkgaW4geHJhbmdlKGludChz ZWxmLl9vcHRpb25zLmNoaWxkX3Byb2Nlc3NlcykpOgogICAgICAgICAgICAgIyBDcmVhdGUgc2Vw YXJhdGUgVGVzdFR5cGVzIGluc3RhbmNlcyBmb3IgZWFjaCB0aHJlYWQuCiAgICAgICAgICAgICB0 ZXN0X3R5cGVzID0gW10KQEAgLTU5NCwxMCArNjMyLDIwIEBAIGNsYXNzIFRlc3RSdW5uZXI6CiAg ICAgICAgICAgICAgICAgdGVzdF90eXBlcy5hcHBlbmQodGVzdF90eXBlKHNlbGYuX3BvcnQsCiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxmLl9vcHRpb25zLnJlc3VsdHNf ZGlyZWN0b3J5KSkKIAorICAgICAgICAgICAgcmVmdGVzdF90eXBlcyA9IFtdCisgICAgICAgICAg ICBmb3IgdGVzdF90eXBlIGluIHNlbGYuX3JlZnRlc3RfdHlwZXM6CisgICAgICAgICAgICAgICAg cmVmdGVzdF90eXBlcy5hcHBlbmQodGVzdF90eXBlKHNlbGYuX3BvcnQsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBzZWxmLl9vcHRpb25zLnJlc3VsdHNfZGlyZWN0b3J5KSkK KwogICAgICAgICAgICAgdGVzdF9hcmdzID0gc2VsZi5fZ2V0X3Rlc3RfYXJncyhpKQorCisgICAg ICAgICAgICBfbG9nLmluZm8oJ3Rlc3RfYXJnczogJXMnLCB0ZXN0X2FyZ3MpCisKKyAgICAgICAg ICAgICMgT3V0cHV0IGluIGNhc2Ugb2YgaSA9PSAwCisgICAgICAgICAgICAnJycxMDA3MTMgMTY6 NDQ6MTYgcnVuX3dlYmtpdF90ZXN0cy5weTo2MjcgIElORk8gdGVzdF9hcmdzOiA8d2Via2l0cHku bGF5b3V0X3Rlc3RzLnRlc3RfdHlwZXMudGVzdF90eXBlX2Jhc2UuVGVzdEFyZ3VtZW50cyBvYmpl Y3QgYXQgMHgxMWI3MTUwPiwgcG5nX3BhdGg6IC91c3IvbG9jYWwvZ29vZ2xlL2hvbWUvaGF5YXRv L3dlYmtpdC9XZWJLaXQvV2ViS2l0L2Nocm9taXVtL3dlYmtpdC9EZWJ1Zy9sYXlvdXQtdGVzdC1y ZXN1bHRzL3BuZ19yZXN1bHQwLnBuZywgc2hlbGxfYXJnczogWyctLXBpeGVsLXRlc3RzPS91c3Iv bG9jYWwvZ29vZ2xlL2hvbWUvaGF5YXRvL3dlYmtpdC9XZWJLaXQvV2ViS2l0L2Nocm9taXVtL3dl YmtpdC9EZWJ1Zy9sYXlvdXQtdGVzdC1yZXN1bHRzL3BuZ19yZXN1bHQwLnBuZyddJycnCiAgICAg ICAgICAgICB0aHJlYWQgPSBkdW1wX3JlbmRlcl90cmVlX3RocmVhZC5UZXN0U2hlbGxUaHJlYWQo c2VsZi5fcG9ydCwKICAgICAgICAgICAgICAgICBzZWxmLl9vcHRpb25zLCBmaWxlbmFtZV9xdWV1 ZSwgc2VsZi5fcmVzdWx0X3F1ZXVlLAotICAgICAgICAgICAgICAgIHRlc3RfdHlwZXMsIHRlc3Rf YXJncykKKyAgICAgICAgICAgICAgICB0ZXN0X3R5cGVzLCByZWZ0ZXN0X3R5cGVzLCB0ZXN0X2Fy Z3MpCiAgICAgICAgICAgICBpZiBzZWxmLl9pc19zaW5nbGVfdGhyZWFkZWQoKToKICAgICAgICAg ICAgICAgICB0aHJlYWQucnVuX2luX21haW5fdGhyZWFkKHNlbGYsIHJlc3VsdF9zdW1tYXJ5KQog ICAgICAgICAgICAgZWxzZToKQEAgLTc5Nyw2ICs4NDUsOCBAQCBjbGFzcyBUZXN0UnVubmVyOgog ICAgICAgICAgICAgc2VsZi5fZXhwZWN0YXRpb25zLCByZXN1bHRfc3VtbWFyeSwgcmV0cnlfc3Vt bWFyeSkKICAgICAgICAgc2VsZi5fcHJpbnRlci5wcmludF91bmV4cGVjdGVkX3Jlc3VsdHModW5l eHBlY3RlZF9yZXN1bHRzKQogCisgICAgICAgIF9sb2cuaW5mbygncmVzdWx0X3N1bW1hcnkuZmFp bHVyZXM6XG4gJXMnLCBwcHJpbnQucGZvcm1hdChyZXN1bHRfc3VtbWFyeS5mYWlsdXJlcykpCisK ICAgICAgICAgaWYgc2VsZi5fb3B0aW9ucy5yZWNvcmRfcmVzdWx0czoKICAgICAgICAgICAgICMg V3JpdGUgdGhlIHNhbWUgZGF0YSB0byBsb2cgZmlsZXMuCiAgICAgICAgICAgICBzZWxmLl93cml0 ZV9qc29uX2ZpbGVzKHVuZXhwZWN0ZWRfcmVzdWx0cywgcmVzdWx0X3N1bW1hcnksCkBAIC0xMDUx LDIzICsxMTAxLDE3IEBAIGNsYXNzIFRlc3RSdW5uZXI6CiAgICAgICAgICAgaW5kaXZpZHVhbF90 ZXN0X3RpbWluZ3M6IExpc3Qgb2YgZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQuVGVzdFN0YXRzCiAg ICAgICAgICAgICAgIGZvciBhbGwgdGVzdHMuCiAgICAgICAgICIiIgotICAgICAgICB0ZXN0X3R5 cGVzID0gW10gICMgVW5pdCB0ZXN0cyBkb24ndCBhY3R1YWxseSBwcm9kdWNlIGFueSB0aW1pbmdz LgotICAgICAgICBpZiBpbmRpdmlkdWFsX3Rlc3RfdGltaW5nczoKLSAgICAgICAgICAgIHRlc3Rf dHlwZXMgPSBpbmRpdmlkdWFsX3Rlc3RfdGltaW5nc1swXS50aW1lX2Zvcl9kaWZmcy5rZXlzKCkK ICAgICAgICAgdGltZXNfZm9yX2R1bXBfcmVuZGVyX3RyZWUgPSBbXQogICAgICAgICB0aW1lc19m b3JfZGlmZl9wcm9jZXNzaW5nID0gW10KICAgICAgICAgdGltZXNfcGVyX3Rlc3RfdHlwZSA9IHt9 Ci0gICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gdGVzdF90eXBlczoKLSAgICAgICAgICAgIHRpbWVz X3Blcl90ZXN0X3R5cGVbdGVzdF90eXBlXSA9IFtdCiAKICAgICAgICAgZm9yIHRlc3Rfc3RhdHMg aW4gaW5kaXZpZHVhbF90ZXN0X3RpbWluZ3M6CiAgICAgICAgICAgICB0aW1lc19mb3JfZHVtcF9y ZW5kZXJfdHJlZS5hcHBlbmQodGVzdF9zdGF0cy50ZXN0X3J1bl90aW1lKQogICAgICAgICAgICAg dGltZXNfZm9yX2RpZmZfcHJvY2Vzc2luZy5hcHBlbmQoCiAgICAgICAgICAgICAgICAgdGVzdF9z dGF0cy50b3RhbF90aW1lX2Zvcl9hbGxfZGlmZnMpCiAgICAgICAgICAgICB0aW1lX2Zvcl9kaWZm cyA9IHRlc3Rfc3RhdHMudGltZV9mb3JfZGlmZnMKLSAgICAgICAgICAgIGZvciB0ZXN0X3R5cGUg aW4gdGVzdF90eXBlczoKLSAgICAgICAgICAgICAgICB0aW1lc19wZXJfdGVzdF90eXBlW3Rlc3Rf dHlwZV0uYXBwZW5kKAotICAgICAgICAgICAgICAgICAgICB0aW1lX2Zvcl9kaWZmc1t0ZXN0X3R5 cGVdKQorICAgICAgICAgICAgZm9yIHRlc3RfdHlwZSwgdGltZSBpbiB0aW1lX2Zvcl9kaWZmcy5p dGVyaXRlbXMoKToKKyAgICAgICAgICAgICAgICB0aW1lc19wZXJfdGVzdF90eXBlLmdldCh0ZXN0 X3R5cGUsIFtdKS5hcHBlbmQodGltZSkKIAogICAgICAgICBzZWxmLl9wcmludF9zdGF0aXN0aWNz X2Zvcl90ZXN0X3RpbWluZ3MoCiAgICAgICAgICAgICAiUEVSIFRFU1QgVElNRSBJTiBURVNUU0hF TEwgKHNlY29uZHMpOiIsCkBAIC0xMDc1LDEwICsxMTE5LDkgQEAgY2xhc3MgVGVzdFJ1bm5lcjoK ICAgICAgICAgc2VsZi5fcHJpbnRfc3RhdGlzdGljc19mb3JfdGVzdF90aW1pbmdzKAogICAgICAg ICAgICAgIlBFUiBURVNUIERJRkYgUFJPQ0VTU0lORyBUSU1FUyAoc2Vjb25kcyk6IiwKICAgICAg ICAgICAgIHRpbWVzX2Zvcl9kaWZmX3Byb2Nlc3NpbmcpCi0gICAgICAgIGZvciB0ZXN0X3R5cGUg aW4gdGVzdF90eXBlczoKKyAgICAgICAgZm9yIHRlc3RfdHlwZSwgdGltZSBpbiB0aW1lc19wZXJf dGVzdF90eXBlLml0ZXJpdGVtcygpOgogICAgICAgICAgICAgc2VsZi5fcHJpbnRfc3RhdGlzdGlj c19mb3JfdGVzdF90aW1pbmdzKAotICAgICAgICAgICAgICAgICJQRVIgVEVTVCBUSU1FUyBCWSBU RVNUIFRZUEU6ICVzIiAlIHRlc3RfdHlwZSwKLSAgICAgICAgICAgICAgICB0aW1lc19wZXJfdGVz dF90eXBlW3Rlc3RfdHlwZV0pCisgICAgICAgICAgICAgICAgIlBFUiBURVNUIFRJTUVTIEJZIFRF U1QgVFlQRTogJXMiICUgdGVzdF90eXBlLCB0aW1lKQogCiAgICAgZGVmIF9wcmludF9pbmRpdmlk dWFsX3Rlc3RfdGltZXMoc2VsZiwgaW5kaXZpZHVhbF90ZXN0X3RpbWluZ3MsCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgcmVzdWx0X3N1bW1hcnkpOgpAQCAtMTY1MCw2ICsxNjkz LDkgQEAgZGVmIHBhcnNlX2FyZ3MoYXJncz1Ob25lKToKICAgICAgICAgb3B0cGFyc2UubWFrZV9v cHRpb24oIi0tbm8tcmV0cnktZmFpbHVyZXMiLCBhY3Rpb249InN0b3JlX2ZhbHNlIiwKICAgICAg ICAgICAgIGRlc3Q9InJldHJ5X2ZhaWx1cmVzIiwKICAgICAgICAgICAgIGhlbHA9IkRvbid0IHJl LXRyeSBhbnkgdGVzdHMgdGhhdCBwcm9kdWNlIHVuZXhwZWN0ZWQgcmVzdWx0cy4iKSwKKyAgICAg ICAgb3B0cGFyc2UubWFrZV9vcHRpb24oIi0tcnVuLXJlZnRlc3RzIiwgYWN0aW9uPSJzdG9yZV90 cnVlIiwKKyAgICAgICAgICAgIGRlc3Q9InJ1bl9yZWZ0ZXN0cyIsCisgICAgICAgICAgICBoZWxw PSJSdW4gYWxzbyByZWZ0ZXN0cy4iKSwKICAgICBdCiAKICAgICBtaXNjX29wdGlvbnMgPSBbCmRp ZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0 X3R5cGVzL2ltYWdlX2RpZmYucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy90ZXN0X3R5cGVzL2ltYWdlX2RpZmYucHkKaW5kZXggMWFkMGZlNjlhNjk2NzA3ZDRh MmU0YmUwZGJhYWFhNGVhMWEzZjk4Yy4uMTYyOTg1NTc2OTE1Zjg5Yzg4YjNmMGMzNDQ4NjRhYjc5 NDVmNTE0MiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvdGVzdF90eXBlcy9pbWFnZV9kaWZmLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvaW1hZ2VfZGlmZi5weQpAQCAtNTQsMjEg KzU0LDYgQEAgX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMu dGVzdF90eXBlcy5pbWFnZV9kaWZmIikKIAogY2xhc3MgSW1hZ2VEaWZmKHRlc3RfdHlwZV9iYXNl LlRlc3RUeXBlQmFzZSk6CiAKLSAgICBkZWYgX2NvcHlfb3V0cHV0X3BuZyhzZWxmLCB0ZXN0X2Zp bGVuYW1lLCBzb3VyY2VfaW1hZ2UsIGV4dGVuc2lvbik6Ci0gICAgICAgICIiIkNvcGllcyByZXN1 bHQgZmlsZXMgaW50byB0aGUgb3V0cHV0IGRpcmVjdG9yeSB3aXRoIGFwcHJvcHJpYXRlCi0gICAg ICAgIG5hbWVzLgotCi0gICAgICAgIEFyZ3M6Ci0gICAgICAgICAgdGVzdF9maWxlbmFtZTogdGhl IHRlc3QgZmlsZW5hbWUKLSAgICAgICAgICBzb3VyY2VfZmlsZTogcGF0aCB0byB0aGUgaW1hZ2Ug ZmlsZSAoZWl0aGVyIGFjdHVhbCBvciBleHBlY3RlZCkKLSAgICAgICAgICBleHRlbnNpb246IGV4 dGVuc2lvbiB0byBpbmRpY2F0ZSAtYWN0dWFsLnBuZyBvciAtZXhwZWN0ZWQucG5nCi0gICAgICAg ICIiIgotICAgICAgICBzZWxmLl9tYWtlX291dHB1dF9kaXJlY3RvcnkodGVzdF9maWxlbmFtZSkK LSAgICAgICAgZGVzdF9pbWFnZSA9IHNlbGYub3V0cHV0X2ZpbGVuYW1lKHRlc3RfZmlsZW5hbWUs IGV4dGVuc2lvbikKLQotICAgICAgICBpZiBvcy5wYXRoLmV4aXN0cyhzb3VyY2VfaW1hZ2UpOgot ICAgICAgICAgICAgc2h1dGlsLmNvcHlmaWxlKHNvdXJjZV9pbWFnZSwgZGVzdF9pbWFnZSkKLQog ICAgIGRlZiBfc2F2ZV9iYXNlbGluZV9maWxlcyhzZWxmLCBmaWxlbmFtZSwgcG5nX3BhdGgsIGNo ZWNrc3VtLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnZW5lcmF0ZV9uZXdfYmFzZWxp bmUpOgogICAgICAgICAiIiJTYXZlcyBuZXcgYmFzZWxpbmVzIGZvciB0aGUgUE5HIGFuZCBjaGVj a3N1bS4KQEAgLTEzNyw3ICsxMjIsNyBAQCBjbGFzcyBJbWFnZURpZmYodGVzdF90eXBlX2Jhc2Uu VGVzdFR5cGVCYXNlKToKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRlc3Rf YXJncy5oYXNoLCBleHBlY3RlZF9oYXNoLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgZW5jb2Rpbmc9ImFzY2lpIiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHByaW50X3RleHRfZGlmZnM9RmFsc2UpCi0gICAgICAgICAgICBzZWxmLl9jb3B5X291dHB1 dF9wbmcoZmlsZW5hbWUsIHRlc3RfYXJncy5wbmdfcGF0aCwgJy1hY3R1YWwucG5nJykKKyAgICAg ICAgICAgIHNlbGYuX2NvcHlfb3V0cHV0KGZpbGVuYW1lLCB0ZXN0X2FyZ3MucG5nX3BhdGgsICct YWN0dWFsLnBuZycpCiAgICAgICAgICAgICBmYWlsdXJlcy5hcHBlbmQodGVzdF9mYWlsdXJlcy5G YWlsdXJlTWlzc2luZ0ltYWdlKCkpCiAgICAgICAgICAgICByZXR1cm4gZmFpbHVyZXMKICAgICAg ICAgZWxpZiB0ZXN0X2FyZ3MuaGFzaCA9PSBleHBlY3RlZF9oYXNoOgpAQCAtMTUwLDcgKzEzNSw3 IEBAIGNsYXNzIEltYWdlRGlmZih0ZXN0X3R5cGVfYmFzZS5UZXN0VHlwZUJhc2UpOgogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBwcmludF90ZXh0X2RpZmZzPUZhbHNlKQogCiAgICAg ICAgICMgRklYTUU6IGNvbWJpbmUgbmV4dCB0d28gbGluZXMKLSAgICAgICAgc2VsZi5fY29weV9v dXRwdXRfcG5nKGZpbGVuYW1lLCB0ZXN0X2FyZ3MucG5nX3BhdGgsICctYWN0dWFsLnBuZycpCisg ICAgICAgIHNlbGYuX2NvcHlfb3V0cHV0KGZpbGVuYW1lLCB0ZXN0X2FyZ3MucG5nX3BhdGgsICct YWN0dWFsLnBuZycpCiAgICAgICAgIHNlbGYud3JpdGVfb3V0cHV0X2ZpbGVzKGZpbGVuYW1lLCAn LnBuZycsIG91dHB1dD1Ob25lLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBleHBl Y3RlZD1leHBlY3RlZF9wbmcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVuY29k aW5nPU5vbmUsIHByaW50X3RleHRfZGlmZnM9RmFsc2UpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL3JlZnRlc3RfZGlmZi5w eSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMv cmVmdGVzdF9kaWZmLnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmYxOWY5ZmI1NzM0YWFiMDJkOTNmNzdjMThiMzAz NzczZTRlZTA4MjYKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL3JlZnRlc3RfZGlmZi5weQpAQCAtMCwwICsxLDE2 OSBAQAorIyEvdXNyL2Jpbi9lbnYgcHl0aG9uCisjIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorIworIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyMgbW9kaWZpY2F0aW9u LCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFy ZQorIyBtZXQ6CisjCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisjIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgICAgICogUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorIyBjb3B5cmlnaHQg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyCisjIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlk ZWQgd2l0aCB0aGUKKyMgZGlzdHJpYnV0aW9uLgorIyAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9m IEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisjIGNvbnRyaWJ1dG9ycyBtYXkgYmUg dXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisjIHRoaXMg c29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisjCisj IFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBD T05UUklCVVRPUlMKKyMgIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5U SUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisjIEEgUEFSVElDVUxBUiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisj IE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLAorIyBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFN QUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorIyBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkK KyMgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJ TElUWSwgT1IgVE9SVAorIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklT SU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJ RiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKworIiIiQ29tcGFy ZXMgdGhlIHRleHQgb3V0cHV0IG9mIGEgdGVzdCB0byB0aGUgZXhwZWN0ZWQgdGV4dCBvdXRwdXQu CisKK0lmIHRoZSBvdXRwdXQgZG9lc24ndCBtYXRjaCwgcmV0dXJucyBGYWlsdXJlVGV4dE1pc21h dGNoIGFuZCBvdXRwdXRzIHRoZSBkaWZmCitmaWxlcyBpbnRvIHRoZSBsYXlvdXQgdGVzdCByZXN1 bHRzIGRpcmVjdG9yeS4KKyIiIgorCitmcm9tIF9fZnV0dXJlX18gaW1wb3J0IHdpdGhfc3RhdGVt ZW50CisKK2ltcG9ydCBjb2RlY3MKK2ltcG9ydCBlcnJubworaW1wb3J0IGxvZ2dpbmcKK2ltcG9y dCBvcy5wYXRoCitpbXBvcnQgc2h1dGlsCisKKworIyBjaXJjdWxhciBkZXBlbmRlbmN5Citmcm9t IHdlYmtpdHB5LmxheW91dF90ZXN0cy5sYXlvdXRfcGFja2FnZSBpbXBvcnQgdGVzdF9mYWlsdXJl cworCisKK2Zyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLnRlc3RfdHlwZXMgaW1wb3J0IHRlc3Rf dHlwZV9iYXNlCisKK19sb2cgPSBsb2dnaW5nLmdldExvZ2dlcigid2Via2l0cHkubGF5b3V0X3Rl c3RzLnRlc3RfdHlwZXMucmVmdGVzdF9kaWZmIikKKworCitkZWYgaXNfcmVmdGVzdF90eXBlKHRl c3RfdHlwZSk6CisgICAgcmV0dXJuIGlzaW5zdGFuY2UodGVzdF90eXBlLCBSZWZ0ZXN0RGlmZikK KworZGVmIGlzX3JlZnRlc3QodGVzdF90eXBlcywgcG9ydCwgZmlsZW5hbWUpOgorICAgICIiIgor ICAgIENoZWNrIHdoZXRlciBleHBlY3RhdGlvbiBhbmQKKyAgICBpZiB4eCBoYXMgeHgtZXhwZWN0 YXRpb24uaHRtbDoKKyAgICAsIHRoZW4gcmV0dXJuIHNldChSZWZ0ZXN0RGlmZikuCisgICAgZWxz ZToKKyAgICAgIHJldHVybiBUZXh0CisKKyAgICAiIiIKKyAgICBmb3IgdGVzdF90eXBlIGluIHRl c3RfdHlwZXM6CisgICAgICAgIGlmIGlzX3JlZnRlc3RfdHlwZSh0ZXN0X3R5cGUpIGFuZCB0ZXN0 X3R5cGUuaGFzX2V4cGVjdGF0aW9uKHBvcnQsIGZpbGVuYW1lKToKKyAgICAgICAgICAgIHJldHVy biBUcnVlCisgICAgcmV0dXJuIEZhbHNlCisKKworY2xhc3MgUmVmdGVzdERpZmYodGVzdF90eXBl X2Jhc2UuVGVzdFR5cGVCYXNlKToKKworICAgIGRlZiBnZXRfZXhwZWN0ZWRfaHRtbF9maWxlKHNl bGYsIGZpbGVuYW1lKToKKyAgICAgICAgIyBmb28tZXhwZWN0ZWQuaHRtbAorICAgICAgICByZXR1 cm4gc2VsZi5fcG9ydC5leHBlY3RlZF9maWxlbmFtZShmaWxlbmFtZSwgJy5odG1sJykKKworICAg IGRlZiBnZXRfZXhwZWN0ZWRfaW1hZ2Vfb3V0cHV0X3BhdGhfZnJvbV9hY3R1YWxfaW1hZ2Vfb3V0 cHV0X3BhdGgoc2VsZiwgcG5nX3BhdGgpOgorICAgICAgICAnJydyZXN1bHQtZXhwZWN0ZWQtaHRt bC5wbmcnJycKKyAgICAgICAgIyBGSVhNRTogUmVmaW5lCisgICAgICAgIHJldHVybiBwbmdfcGF0 aCArICctcmVmdGVzdC1leHBlY3RlZC5wbmcnCisKKyAgICBkZWYgZ2VuZXJhdGVfZXhwZWN0ZWRf aW1hZ2Uoc2VsZiwgZmlsZW5hbWUsIG91dHB1dF9wbmdfcGF0aCwgZHJpdmVyKToKKyAgICAgICAg IiIiR2VuZXJldGUgaW1hZ2UgYW5kIHJldHVybiB0aGUgZmlsZXBhdGggdG8gaXQuIiIiCisgICAg ICAgICMgRklYTUU6IEF2b2lkIG91dHB1dGluZyBpbWFnZSB0byBkaXNrLiBSZXR1cm4gaW4tbWVt b3J5IGltYWdlCisKKworICAgICAgICBfbG9nLmRlYnVnKCdnZW5lcmF0ZV9leHBlY3RlZF9pbWFn ZV9mb3I6ICVzLCAlcycsIGZpbGVuYW1lLCBvdXRwdXRfcG5nX3BhdGgpCisKKyAgICAgICAgIyBG SVhNRTogcGFzcyB0aGVzZSB2YWx1ZXMuCisgICAgICAgICMgdXJpID0gdGVzdF9pbmZvLnVyaS5z dHJpcCgpCisgICAgICAgIHVyaSA9IGZpbGVuYW1lCisgICAgICAgIHRpbWVvdXQgPSAxMDAwCisg ICAgICAgIGltYWdlX2hhc2ggPSAnJworCisgICAgICAgIGltcG9ydCBwZGIKKyAgICAgICAgcGRi LnNldF90cmFjZSgpCisKKyAgICAgICAgY3Jhc2gsIHRpbWVvdXQsIGFjdHVhbF9jaGVja3N1bSwg b3V0cHV0LCBlcnJvciA9IFwKKyAgICAgICAgICAgIGRyaXZlci5ydW5fdGVzdCh1cmksCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgdGltZW91dCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICBpbWFnZV9oYXNoLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIG91dHB1dF9wbmdf cGF0aCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICApCisgICAgICAgIHJldHVybiBvdXRw dXQKKworICAgIGRlZiBnZXRfZXhwZWN0ZWRfaGFzaChzZWxmLCBwbmdfZmlsZSk6CisgICAgICAg IHJldHVybiAnJworCisKKyAgICAjIEZJWE1FOiBHb29kIG5hbWluZworICAgICMgZGVmIGNvbXBh cmVfcmVmdGVzdF9vdXRwdXQoc2VsZiwgcG9ydCwgdGVzdF9pbmZvLCBvdXRwdXQsIHRlc3RfYXJn cywgY29uZmlndXJhdGlvbik6CisgICAgZGVmIGNvbXBhcmVfcmVmdGVzdF9vdXRwdXQoc2VsZiwg cG9ydCwgdGVzdF9pbmZvLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFjdHVhbF9p bWFnZV9oYXNoLCBhY3R1YWxfaW1hZ2VfY29udGVudHMsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgcmVmZXJlbmNlX2ltYWdlX2hhc2gsIHJlZmVyZW5jZV9pbWFnZV9jb250ZW50cyk6 CisgICAgICAgIGZhaWx1cmVzID0gW10KKworICAgICAgICBpZiB0ZXN0X2luZm8uZXhwZWN0ZWRf aHRtbF9maWxlbmFtZToKKyAgICAgICAgICAgIGlmIGFjdHVhbF9pbWFnZV9oYXNoID09IHJlZmVy ZW5jZV9pbWFnZV9oYXNoOgorICAgICAgICAgICAgICAgIHJldHVybiBmYWlsdXJlcworCisgICAg ICAgICAgICBmYWlsdXJlcy5hcHBlbmQodGVzdF9mYWlsdXJlcy5GYWlsdXJlUmVmdGVzdE1pc21h dGNoKCkpCisKKyAgICAgICAgICAgIGRpZmZfZmlsZW5hbWUgPSBzZWxmLm91dHB1dF9maWxlbmFt ZSh0ZXN0X2luZm8uZmlsZW5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgc2VsZi5GSUxFTkFNRV9TVUZGSVhfQ09NUEFSRSkKKyAgICAgICAgICAg IHBvcnQuZGlmZl9pbWFnZShyZWZlcmVuY2VfaW1hZ2VfY29udGVudHMsIGFjdHVhbF9pbWFnZV9j b250ZW50cywgZGlmZl9maWxlbmFtZSkKKworICAgICAgICAgICAgIyBDb3B5IGltYWdlIGZvciBs YXRlciByZXBvcnRpbmcuCisgICAgICAgICAgICBzZWxmLl9jb3B5X291dHB1dCh0ZXN0X2luZm8u ZmlsZW5hbWUsIHRlc3RfaW5mby5leHBlY3RlZF9odG1sX2ZpbGVuYW1lLCAnLWV4cGVjdGVkLmh0 bWwnKQorICAgICAgICAgICAgc2VsZi53cml0ZV9vdXRwdXRfZmlsZXModGVzdF9pbmZvLmZpbGVu YW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmlsZV90eXBlPScucG5n JywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG91dHB1dD1hY3R1YWxfaW1h Z2VfY29udGVudHMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBleHBlY3Rl ZD1yZWZlcmVuY2VfaW1hZ2VfY29udGVudHMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBlbmNvZGluZz1Ob25lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgcHJpbnRfdGV4dF9kaWZmcz1GYWxzZSkKKyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIGFz c2VydCB0ZXN0X2luZm8uZXhwZWN0ZWRfbWlzbWF0Y2hfaHRtbF9maWxlbmFtZQorICAgICAgICAg ICAgaWYgYWN0dWFsX2ltYWdlX2hhc2ggIT0gcmVmZXJlbmNlX2ltYWdlX2hhc2g6CisgICAgICAg ICAgICAgICAgIyBGSVhNRTogU2hvdWxkIHdlIHNhdmUgaW1hZ2VfZGlmZiBpbiB0aGlzIGNhc2U/ CisgICAgICAgICAgICAgICAgcmV0dXJuIGZhaWx1cmVzCisgICAgICAgICAgICAjIC4uCisgICAg ICAgICAgICAjIEZJWE1FKGhheWF0byk6CisgICAgICAgICAgICBmYWlsdXJlcy5hcHBlbmQodGVz dF9mYWlsdXJlcy5GYWlsdXJlUmVmdGVzdE5vRGlmZmVyZW5jZSgpKQorCisgICAgICAgIHJldHVy biBmYWlsdXJlcworCisKKyAgICBkZWYgcmVhZF9pbWFnZShmaWxlKToKKyAgICAgICAgcmV0dXJu ICcnCisKKyAgICBkZWYgZGlmZl9maWxlcyhzZWxmLCBwb3J0LCBmaWxlMSwgZmlsZTIpOgorICAg ICAgICAiIiJEaWZmIHR3byBpbWFnZSBmaWxlcyBleGFjdGx5LgorCisgICAgICAgIEFyZ3M6Cisg ICAgICAgICAgZmlsZTEsIGZpbGUyOiBmdWxsIHBhdGhzIG9mIHRoZSBmaWxlcyB0byBjb21wYXJl LgorCisgICAgICAgIFJldHVybnM6CisgICAgICAgICAgVHJ1ZSBpZiB0d28gZmlsZXMgYXJlIGRp ZmZlcmVudC4KKyAgICAgICAgICBGYWxzZSBvdGhlcndpc2UuCisgICAgICAgICIiIgorICAgICAg ICB0cnk6CisgICAgICAgICAgICBpbXBvcnQgcGRiCisgICAgICAgICAgICBwZGIuc2V0X3RyYWNl KCkKKyAgICAgICAgICAgIGltYWdlMSA9IHJlYWRfaW1hZ2UoZmlsZTEpCisgICAgICAgICAgICBp bWFnZTIgPSByZWFkX2lhbWdlKGZpbGUyKQorICAgICAgICAgICAgZGlmZl9maWxlbmFtZSA9IE5v bmUKKyAgICAgICAgICAgIHJldHVybiBwb3J0LmRpZmZfaW1hZ2UoaW1hZ2UxLCBpbWFnZTIsIGRp ZmZfZmlsZW5hbWUsIDApCisgICAgICAgIGV4Y2VwdCBWYWx1ZUVycm9yLCBlOgorICAgICAgICAg ICAgcmV0dXJuIFRydWUKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvdGVzdF90eXBlX2Jhc2UucHkgYi9XZWJLaXRUb29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL3Rlc3RfdHlwZV9iYXNlLnB5 CmluZGV4IDNhNmU5MmI3ZDUzM2JjOTA2MGU5NDg5MGQ0NDJjMzVhMTJjZWNjYmIuLjlmOTU1YzJi YWUxNzRhOThiODYxMzZmNDAzNWEwMzU1ZjM5NzZlNDQgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvdGVzdF90eXBlX2Jhc2Uu cHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90 eXBlcy90ZXN0X3R5cGVfYmFzZS5weQpAQCAtMzksNiArMzksNyBAQCBpbXBvcnQgY2dpCiBpbXBv cnQgZXJybm8KIGltcG9ydCBsb2dnaW5nCiBpbXBvcnQgb3MucGF0aAoraW1wb3J0IHNodXRpbAog CiBfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy50ZXN0X3R5 cGVzLnRlc3RfdHlwZV9iYXNlIikKIApAQCAtOTAsNiArOTEsNDkgQEAgY2xhc3MgVGVzdFR5cGVC YXNlKG9iamVjdCk6CiAgICAgICAgICAgICBzZWxmLl9wb3J0LnJlbGF0aXZlX3Rlc3RfZmlsZW5h bWUoZmlsZW5hbWUpKQogICAgICAgICBzZWxmLl9wb3J0Lm1heWJlX21ha2VfZGlyZWN0b3J5KG9z LnBhdGguc3BsaXQob3V0cHV0X2ZpbGVuYW1lKVswXSkKIAorICAgIGRlZiBfY29weV9vdXRwdXQo c2VsZiwgdGVzdF9maWxlbmFtZSwgc291cmNlX2ZpbGVuYW1lLAorICAgICAgICAgICAgICAgICAg ICAgZGVzdGluYXRpb25fZXh0ZW5zaW9uKToKKyAgICAgICAgIiIiQ29waWVzIHJlc3VsdCBmaWxl cyBpbnRvIHRoZSBvdXRwdXQgZGlyZWN0b3J5IHdpdGggYXBwcm9wcmlhdGUKKyAgICAgICAgbmFt ZXMuCisKKyAgICAgICAgQXJnczoKKyAgICAgICAgICB0ZXN0X2ZpbGVuYW1lOiB0aGUgdGVzdCBm aWxlbmFtZQorICAgICAgICAgIHNvdXJjZV9maWxlbmFtZTogcGF0aCB0byB0aGUgc291cmNlIGZp bGUgKGVpdGhlciBhY3R1YWwgb3IgZXhwZWN0ZWQpCisgICAgICAgICAgZGVzdGludGlvbl9leHRl bnNpb246IGV4dGVuc2lvbiB1c2VkIGluIGRlc3RpbmF0aW9uJ3MgZmlsZW5hbWUuCisgICAgICAg ICIiIgorICAgICAgICBzZWxmLl9tYWtlX291dHB1dF9kaXJlY3RvcnkodGVzdF9maWxlbmFtZSkK KyAgICAgICAgZGVzdF9maWxlbmFtZSA9IHNlbGYub3V0cHV0X2ZpbGVuYW1lKHRlc3RfZmlsZW5h bWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBkZXN0aW5h dGlvbl9leHRlbnNpb24pCisKKyAgICAgICAgYXNzZXJ0IG9zLnBhdGguZXhpc3RzKHNvdXJjZV9m aWxlbmFtZSkKKyAgICAgICAgaWYgb3MucGF0aC5leGlzdHMoc291cmNlX2ZpbGVuYW1lKToKKyAg ICAgICAgICAgIHNodXRpbC5jb3B5ZmlsZShzb3VyY2VfZmlsZW5hbWUsIGRlc3RfZmlsZW5hbWUp CisKKyAgICAjIEZJWE1FOiBNb3ZlIHRoaXMgbWV0aG9kIHRvIGFwcHJvcHJpYXRlIHBsYWNlIGJl Y2F1c2UgdGhpcyBpcyB1c2VkIG9ubHkKKyAgICAjIGZyb20gdGVzdCB0eXBlcyB3aGljaCBoYW5k bGUgaW1hZ2UuCisgICAgZGVmIF9jcmVhdGVfaW1hZ2VfZGlmZihzZWxmLCBwb3J0LCBmaWxlbmFt ZSwgY29uZmlndXJhdGlvbik6CisgICAgICAgIGRpZmZfZmlsZW5hbWUgPSBzZWxmLm91dHB1dF9m aWxlbmFtZShmaWxlbmFtZSwKKyAgICAgICAgICAiLWRpZmYucG5nIikKKyAgICAgICAgYWN0dWFs X2ZpbGVuYW1lID0gc2VsZi5vdXRwdXRfZmlsZW5hbWUoZmlsZW5hbWUsCisgICAgICAgICAgc2Vs Zi5GSUxFTkFNRV9TVUZGSVhfQUNUVUFMICsgJy5wbmcnKQorICAgICAgICBleHBlY3RlZF9maWxl bmFtZSA9IHNlbGYub3V0cHV0X2ZpbGVuYW1lKGZpbGVuYW1lLAorICAgICAgICAgIHNlbGYuRklM RU5BTUVfU1VGRklYX0VYUEVDVEVEICsgJy5wbmcnKQorICAgICAgICByZXN1bHQgPSBUcnVlCisg ICAgICAgIHRyeToKKyAgICAgICAgICAgIF9jb21wYXJlX2F2YWlsYWJsZSA9IFRydWUKKyAgICAg ICAgICAgIHJlc3VsdCA9IHBvcnQuZGlmZl9pbWFnZShleHBlY3RlZF9maWxlbmFtZSwgYWN0dWFs X2ZpbGVuYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRpZmZfZmls ZW5hbWUpCisgICAgICAgIGV4Y2VwdCBWYWx1ZUVycm9yOgorICAgICAgICAgICAgX2NvbXBhcmVf YXZhaWxhYmxlID0gRmFsc2UKKworICAgICAgICBnbG9iYWwgX2NvbXBhcmVfbXNnX3ByaW50ZWQK KyAgICAgICAgaWYgbm90IF9jb21wYXJlX2F2YWlsYWJsZSBhbmQgbm90IF9jb21wYXJlX21zZ19w cmludGVkOgorICAgICAgICAgICAgX2NvbXBhcmVfbXNnX3ByaW50ZWQgPSBUcnVlCisgICAgICAg ICAgICBwcmludCgnaW1hZ2VfZGlmZiBub3QgZm91bmQuIE1ha2Ugc3VyZSB5b3UgaGF2ZSBhICcg KworICAgICAgICAgICAgICAgICAgY29uZmlndXJhdGlvbiArICcgYnVpbGQgb2YgdGhlIGltYWdl X2RpZmYgZXhlY3V0YWJsZS4nKQorCisgICAgICAgIHJldHVybiByZXN1bHQKKwogICAgIGRlZiBf c2F2ZV9iYXNlbGluZV9kYXRhKHNlbGYsIGZpbGVuYW1lLCBkYXRhLCBtb2RpZmllciwgZW5jb2Rp bmcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2VuZXJhdGVfbmV3X2Jhc2VsaW5lPVRy dWUpOgogICAgICAgICAiIiJTYXZlcyBhIG5ldyBiYXNlbGluZSBmaWxlIGludG8gdGhlIHBvcnQn cyBiYXNlbGluZSBkaXJlY3RvcnkuCkBAIC0xNDAsNiArMTg0LDE4IEBAIGNsYXNzIFRlc3RUeXBl QmFzZShvYmplY3QpOgogICAgICAgICAgICAgc2VsZi5fcG9ydC5yZWxhdGl2ZV90ZXN0X2ZpbGVu YW1lKGZpbGVuYW1lKSkKICAgICAgICAgcmV0dXJuIG9zLnBhdGguc3BsaXRleHQob3V0cHV0X2Zp bGVuYW1lKVswXSArIG1vZGlmaWVyCiAKKyAgICBkZWYgaGFzX2V4cGVjdGF0aW9uKHNlbGYsIHBv cnQsIGZpbGVuYW1lKToKKyAgICAgICAgIiIiUmV0dXJucyB0cnVlIGlmIHRoaXMgdGVzdCBoYXMg YW4gZXhwZWN0YXRpb24uCisKKyAgICAgICAgQXJnczoKKyAgICAgICAgICBmaWxlbmFtZTogYWJz b2x1dGUgZmlsZW5hbWUgdG8gdGVzdCBmaWxlCisgICAgICAgICAgcG9ydDogb2JqZWN0IGltcGxl bWVudGluZyBwb3J0LXNwZWNpZmljIGluZm9ybWF0aW9uIGFuZCBtZXRob2RzCisKKyAgICAgICAg UmV0dXJuOgorICAgICAgICAgIHRydWUgaWYgdGhlcmUgaXMgYW4gZXhwZWN0YXRpb24uCisgICAg ICAgICIiIgorICAgICAgICByYWlzZSBOb3RJbXBsZW1lbnRlZAorCiAgICAgZGVmIGNvbXBhcmVf b3V0cHV0KHNlbGYsIHBvcnQsIGZpbGVuYW1lLCBvdXRwdXQsIHRlc3RfYXJncywgY29uZmlndXJh dGlvbik6CiAgICAgICAgICIiIk1ldGhvZCB0aGF0IGNvbXBhcmVzIHRoZSBvdXRwdXQgZnJvbSB0 aGUgdGVzdCB3aXRoIHRoZQogICAgICAgICBleHBlY3RlZCB2YWx1ZS4K 72932 2010-11-04 06:28:37 -0700 2010-11-05 06:45:18 -0700 snapshot2 bug-36065-20101104222835.patch text/plain 97764 hayato ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC9iYWQtaW1hZ2UtZXhwZWN0ZWQuY2hlY2tz dW0gYi9MYXlvdXRUZXN0cy9teXRlc3QvYmFkLWltYWdlLWV4cGVjdGVkLmNoZWNrc3VtCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLmZjMTY4OTI0MmViYWRkOTdjNWEwNGI4NzIwZjBiMmM2NmUzNzdhMWIKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9teXRlc3QvYmFkLWltYWdlLWV4cGVjdGVkLmNoZWNrc3Vt CkBAIC0wLDAgKzEgQEAKK2M3OTVhYzVlODVmYTkxOWVmNjUyM2I3Mjg2MmE1ZDI4ClwgTm8gbmV3 bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L2JhZC1p bWFnZS1leHBlY3RlZC5wbmcgYi9MYXlvdXRUZXN0cy9teXRlc3QvYmFkLWltYWdlLWV4cGVjdGVk LnBuZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi5lYWQxOWU5MWViMWFmYzAyZGQ1NWM0ZmRjMjE3OTZlZDRhYTYxMjQ3 CkdJVCBiaW5hcnkgcGF0Y2gKbGl0ZXJhbCAxMzA4Mwp6Y21lSE9gQ0YxezdlPXpRKVlQZE4laVA5 UnZ2TTU2V20zPjdFMn5rbih1QD08JV8mU1dPKSopdG5yelhxdlFSUF4KelRjK3RWISkwN1VhN3gy T3I4MzJHS3x7Y0RLfG9aSDwkSW1hOFRrfER5MXdAcEVfZ1VFPVJEYFZAOHtnbGQwd3NyCnpgdExB VldWcnxlZnRkTDErIWgzWiUoSF8pcGElXlgwMygjZF5RVkNpcWJJZyo0Zk5aKCloX1QxPUo8KTJD PHB8cgp6X3NmMGBkV3B8Y2pjZT9hSH0tfnkoMkdtNFNAd1JSZytLZWdjVTdBb01IX2U3UmBfTmB5 NythKHgoPCE1RFN2YyUKejtNM2RueX1seV8ySEk0Y2I3UFRDeU04KDN5Uk5yei1PJlB6amdwcXdK ciQzPilVXl8xeT40UFdDWG9qKklyRENfCnpKWEw/ZGdjV3EoezZxfXkkQ0lrZGtuOHNzYGZPZihw bGpIRilkSFVqQHJvMnQ9US0wZldibihCPjc+JTZCRmVpOAp6aW9yIy1jaSNAbWh4TnJgaT9+SWhV cUxUPkAoTFZTMzVHbT1yKnhSKTtoJjhDdil0NnR0M0sybz1NQ0d+TzhsdjYKelUoNHo/PytaS0t2 Km1GP0BJM0NkWV83R3ppUCs8PjhxSTEwdlZNRXNKWCgwUEFrVGtkYWFRZlVhZXt3WUZaeyl+CnpG Tn5IS0ErfWQjPUYybk01dWM5cUtOUXdxXjBIYjY4PXMyIXkzK0U9NnpzKVBsLVc7ZkA5JlRNdSpw UHteR3FFcQp6LUY1elNtVX5tPWs8fERASXxJMFRWeTl9LT1pfUZLbShWXlgxQEctb0NNfThYZWN2 UFl7UnBMZng3Z2EpKHdKaGgKekd0a1VlfDQyQDhwIVgkRE9YdG17WEFtbjM3cCVDSV44TUxXQyFa JUEtQiNrMDtAYSgxeCVYakByKUhnZlQ9diMtCnohPCNBfSYzZkFGMDcwXlhlWW0oWWNydkBfRX5R ND14MX5YbFRXeDg+WkVOSm17fWhoOXtYWCRsJGN7VHRsaDRzOQp6ITxMQlE1VkV1SUpkOUt5VXB5 X0BoYFFaT2NGMClUeiZ7fVN2aXN1TUwoWG5JWTdCOVUqUVpVS1AzMFomTU9VdTUKejE+WXF7dDU1 RW45e21zZm1oZ1pnQVkzantNWXElK2B7ZHhmQ2hAQjErYmlVVE9fSDBQeTk8cHpNVncrOC1uKUl0 Cno7b1llbCUybitWNWZyLUlER1koYylAfjtuJWxCcTRaK15HYCR8VWl7YHBDYHFzdXlGRnElTX1x VnFvJkJoYEo4eQp6Nnd9dzNUWFNrKG9ZPEAmPlFRWGBHcEdnZ0VxPCZiN1g1KFd1Rl5sflNAPXkr NVI3VV4qUng3WUtXOClPa2tmWU8KelBLIXJTYFVkSyluJEp4fmdQSEBvd2d2QHBTOTdDd2VeWnV3 O09PVlgmZkdUWlNnUWgkQTFDVns/fjF5bXEpRSgrCnopeHwqeSNuWWU8MWJAcXBHX24jP01fMnBT VlhzfCpLPHByWCtrRXo4Xit0TS16WUVYU3ZMd3t3UUl4JDszYSh0Owp6PzJHKyUkeFE9JGdZdio7 YCR1KHVseF9EdFpnJEBPJG9YeUltVno2cj13X3lGO1hoeVV5Pm4+cW4oWVJUSFF5T08KekBqUTAm cStvUUNtdHcreG8yektYI2tsc1BlWSFrdzQ3My1jIWFebnQ8K3ladHM+UClLM2xLZjF6TSt8JmNQ ajcoCno9QFpkYUd6UDtob0V5P04reUk1djZBa35kKEtuMk4+RkpmV3xCbkF3JDRkWFFjRVI3ajAr QEU1Z2hDPz1fZkckKQp6YkQ1ITspQDBWdCV4SDFEeko2b3lnTmF7c0U7RjshdG9VQ2ZlX2E8KnhY PmBHWCMwcWZgUHxAYCozd1JeNStQVV4Kejt4dGw9bil8fUxaQHp1O1lseHlYaVEjaEhRYCVWNDtA WHY9cDV6aHA2NWpkb0FLMG5+cnxRP2pvbSZ4Rm1FYEB0CnpmSyVxfTlLdUFJTUNpcyQmTzZpT3op OUFRVjJDTUphck5lR1pkbHB6bWE0dzxNKX5tfmktbUpCUGw/U3RXQX5aTAp6ZCZHb0U/QzBJNjl+ amQ7O19DcWY9YEg+clpUPzdxZzUoLTE8QU56MXRDRXRMUl4tRUhVakdKZkRJO2o+PTl5WmgKelRQ Sm8td098T2NyQFh0Jik5PzUwJFJ5VmVOQVhqNSk0bEdKYFgjSyMyPSEtQ3g1OEhecjx4UmZTQX10 LURrUW5SCnpGdVl1fnE5eGlWN35WVm5uX0syYGJHTSNed2s5VnBLMjx4I0xnWShpP0ZhPnpzVlA/ X0pSaGw4KEd+bD1LZlBGYgp6SGJoZ2NqRUA7NXhsTGc2M0NobmM+VnlmTWB3XjI/d316X3M7ZilB NHsmb2lvbjlfM3J2THFOSWJvcipUQyRVUmYKencydkV9R0V5fm98Sm9mKTU5S2IpQ001PDMlK0Nz TiZ7WllNUGtCV25zKXRJezZKMGJvWjsrJU5PR2ppfWI3RWtkCnphfUdYRjlHUUFZV140ezB6aSpM QSE7aGYoMHc8emszZG82UFlefVVRUXE5NH48fFBZcipga2x7YDV4LT1IV29UdQp6TXV9ckB0anF7 dUQlPCVSRzBBTkFmdmx+c3cpOUdfT1VPKUI2aSF9PHZQTmhYOTJRU0FRN010cmg8S31uSCRFJXkK ejhIOEpOXylSbDBpVjA1YmokPksjbjtkQ1lOait6fFJtdn1ndHAwUmMjd2ZCPk5YQU5FdVZ3OWtP Sy0jfTFaMWJRCnp1Xy09QFJLfGcpOUZBeyt1fiR5ajhOaUZfbWoqN19zYF8jYD1aQzlCYE54PlJ7 S2coMiNZc1khP198aDdaTyNvQQp6IzA/Z3RVa0F7JWdVeWA9Q2haQj1OSnZnNEYyQEYqbWJEJllN ND8mTU4hXjJkMSVSdCt7V3IkQkREe15SZShKbyUKeiVQe3lNQm4hd1dPbFVOS20/JEFfKUd9bDtv WH5+Mzk3eWYobHYrJGdnZSNndG89ckJZdlVUUlBFI2Y2bEo4czM1CnolQCt8aEdBaGdYMjImJWFA dnA0U1VqfEBYVE8rdUpRaGt6V0NZaSkkNDJOUjdNTkY0ZiR5JkZOWk02ZXk1ekR6Swp6cUJANz5r WlVWTCh5cWdtZzk2clBaRjB8MGNxUlFiZW1maDtSMyZ9OzBBOEhKbzhzR1EtQ04hSDhHQGt9Pyhm WioKekNscUV5M0NvMmtHPThMNUNTdXt6KVgkIWUpfkstSitEViZgdShSI2I8WERENjgyOGV8RXUk eGlod259aSpZZVg1Cnpze1Q/NVFIUmYreFVgbDxTcWNoPzFIe2gxPmlGem57PSV5MShkVDNVJD5B dHhZQyg9VDB8dmJFWVF9LUFNKnlyewp6JCRtaGdlVnhvLSFKRXA2SFdnTz5SNzQyI2xhNnREVnRg PkJfbWw/NUBEZGc3KXIoZyk5SUtXdFRMQXEtcW9UQDcKendkeFRKaVUyMyNVJWxRUEYxO3hyJTlm Sz9WQ1pyNWt5OTlDPD5XamFSPUVhNWxyaVJgPCZYMWVKdnFEfTdeKkR9CnowN35YMFczclp3O2Mj KXkrPG5hJE93SVZhLUsrcWp2UTVDJWp6MzBaMHpxVHNqfUg+KWdne1NwQGZCMUs9aXlWMAp6UlV5 JGN6LT01VzZ5eTdpUHpRVTF1IzgoPSsrIUwqXiZAb0lKI2lraCtfT1ZydVRUV24hRjk1TkNGb2JV ZGtlYFoKeiNZK3ZZd3FCS2tkOW5yTj0hfVloR3UwPkxFSHJCUnFYM3lCTTZjQHx5WDV2JVE+NSpq VlgpQlI5dUp4YkFsUWpfCnp2PmJwO2hNMV9HOTxwSj5yLSNlN3oyfDgpbFZfYz5zbDFPY1lQLWo5 QHltYDgpeSNATSVsRVh5Y0ZKI184cldiWAp6NmQ4YFpsUTgxPEd2MjtOR2gmWWxPYjI5ZzgoRCl1 V355PTdDQTk0ais0aE5TeUczUUlXeV5tdGEteUheZDJwOSMKenF7SWJCdTghelh6dFhCQjFWaGhN QGZzPTR5NktBPWN1Xl51UD94S3UlUzhPblBKUy13MU93ZlhRTHJ6LT51bGNYCno3WW9fd1VCTmFs KThYUjxnME56Xns3RkVqZmkzUUlhdHFyLWw7O3d6UmRRKjJSSnMmeVM9dCR5K1JYTEIyXj4rTwp6 QERXYDQ2TlRIYSUlTCN4cTJBdlRIQWlwXi14MXZPTX1AT2lUQm9TSSVTcE9NO2NSRzVkUThFZndy RCtncDxqP1oKeldyeUBzQ34mKlBJcFR7aj5ncnNjYXgqVSF0dEtobGlmT28+PHYrK3FsMC0leUx8 dEVjM0RZQk45XiFqbT0xP2huCno2QjBWbTluWX5nTVgxS3kwUz9ePmZIQ0xDRnFSUnZsQTslfHlF I2NVNnJSNTt8N1hVNmZpa0xrU1E7QkhiMHo+Tgp6SiFzUX4rdGBTXnA7WH55eG5KNHBGMForRHUz RXlIekdOK09OPzVqMWhIPDlhJTFvN29PbHZlOD19Z18qOEFUNGUKejZUUVAjQi1aOy1OXkg+TER9 PmNIOU9GRGIyfC1BPGt+SyhXNEtpNXxPfnw3JnEjc0YmanUqMHEzRTkxcDt9NTVGCnpZRi0zO3pH a0lmc2xZVVBENkJQbHxNOGUrVz1OISpnJWRfR2RjK2hNSSNecTN5SlhJTyUrcnRfRil4eEtZc1Zx YAp6QytRK0RIZ2MjbmBqbjd8QlEhZytIZlUzOVYoXlJwI3RaPFNqd1JTWDdjP2cxKERaVk5DNERP UCpXNzFlTCFsKE8KemhDakElJld1eDhYWV8tMks0dVM8cT1VRmpxWm55ZXVgNkxUTnZERl5XZj5W fWJ2TkRBdT96QX0lfSNDQXYxeSNJCnp6Y1YoPFp3fGZRNHRDelZ5aFM+PjllX2V0UmhGKiRPU0Fr bntPZUxQeVZid08mJjh5Rk1vO2YxR1c0c3R4ZCQjWAp6JT0rcSQkM0srTmdJMT9QVUtlZjlAd15X M3lsXm0yQyVEN2pzUk99eGJVYkg2cCUzKkZ7Qj9yY1dhb1h4YWtxfT0KelUzeiohJj56OyQxIXJl clc+PFpDd1R8YVVzU3BSZmRwYjc7T3ZfQTAhTCRIYzZHWTFsfDNER31FMDtJOHdnQnJZCnp4YTB6 KkJuXy1ZS290ZkheaH11cWJxbGJXMF9FSUhuRkxpWHBxTjFNS2VNI31fZTMqXzNFVjBJV2ZJJiQm blBDYQp6dT5oMXd1KDFGKDdHQGh5VX1GSm5FWD1rayFOJFQyQztwdntnPCRoKDd6QVM0SkBZS1VZ ITRaZmNBJkpJSiNoZX4KejlWcVEpJGB+bF5XKl5HfCZ5MnRgcXVFMVZAWFFFMkduIVJRfDR3Tksl REd0OzFJanMyJmRzVkFQfGtzSlpuaT03CmZ8SSg9JkwhQDc8eU5hS0xEfWdffks+VTNEdz58cVk7 ezFPQilBc0dACgpsaXRlcmFsIDAKSGNtVj9kMDAwMDEKCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9teXRlc3QvYmFkLWltYWdlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL215dGVzdC9iYWQt aW1hZ2UtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmRmMjMzMzE3NmY2MDg2NGZjMjBjYzZlODNm MzQzMDViZTk1MDlkNTkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9teXRlc3QvYmFk LWltYWdlLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDcgQEAKK2xheWVyIGF0ICgwLDApIHNpemUg ODAweDYwMAorICBSZW5kZXJWaWV3IGF0ICgwLDApIHNpemUgODAweDYwMAorbGF5ZXIgYXQgKDAs MCkgc2l6ZSA4MDB4NjAwCisgIFJlbmRlckJsb2NrIHtIVE1MfSBhdCAoMCwwKSBzaXplIDgwMHg2 MDAKKyAgICBSZW5kZXJCb2R5IHtCT0RZfSBhdCAoOCw4KSBzaXplIDc4NHg1ODQKKyAgICAgIFJl bmRlclRleHQgeyN0ZXh0fSBhdCAoMCwwKSBzaXplIDExMHgxOAorICAgICAgICB0ZXh0IHJ1biBh dCAoMCwwKSB3aWR0aCAxMTA6ICJCYWQgSW1hZ2UgTm9pc2UiCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9teXRlc3QvYmFkLWltYWdlLmh0bWwgYi9MYXlvdXRUZXN0cy9teXRlc3QvYmFkLWltYWdl Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uZWMwYWVmOTVlNGQ1MDBlNmZhYjFkNDBmZmVhNjUzZjQ0MzIzMjcw OQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL215dGVzdC9iYWQtaW1hZ2UuaHRtbApA QCAtMCwwICsxLDEwIEBACitCYWQgSW1hZ2UgTm9pc2UKK0JhZCBJbWFnZSBOb2lzZQorQmFkIElt YWdlIE5vaXNlCitCYWQgSW1hZ2UgTm9pc2UKK0JhZCBJbWFnZSBOb2lzZQorQmFkIEltYWdlIE5v aXNlCitCYWQgSW1hZ2UgTm9pc2UKK0JhZCBJbWFnZSBOb2lzZQorQmFkIEltYWdlIE5vaXNlCitC YWQgSW1hZ2UgTm9pc2UKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC9iYWQtcmVmdGVz dC1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2JhZC1yZWZ0ZXN0LWV4cGVjdGVk Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uMTNkOGFmMzk5OGU3MjBmMjQ4MWE2MDRiYWZjNzExODQ5OTUyZGEy NgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL215dGVzdC9iYWQtcmVmdGVzdC1leHBl Y3RlZC5odG1sCkBAIC0wLDAgKzEgQEAKK0hlbGxvbwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv bXl0ZXN0L2JhZC1yZWZ0ZXN0Lmh0bWwgYi9MYXlvdXRUZXN0cy9teXRlc3QvYmFkLXJlZnRlc3Qu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi5lOTY1MDQ3YWQ3YzU3ODY1ODIzYzdkOTkyYjFkMDQ2ZWE2NmVkZjc4 Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2JhZC1yZWZ0ZXN0Lmh0bWwK QEAgLTAsMCArMSBAQAorSGVsbG8KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC9iYWQt cmVmdGVzdDItZXhwZWN0ZWQtbWlzbWF0Y2guaHRtbCBiL0xheW91dFRlc3RzL215dGVzdC9iYWQt cmVmdGVzdDItZXhwZWN0ZWQtbWlzbWF0Y2guaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45ZjAyMDUyMzI5MmNj N2ZhYWY1MjFiODhkNjUwY2EyZTZhYzk2MzdkCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvbXl0ZXN0L2JhZC1yZWZ0ZXN0Mi1leHBlY3RlZC1taXNtYXRjaC5odG1sCkBAIC0wLDAgKzEg QEAKK015IG5hbWUgaXMgRm9vLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L2JhZC1y ZWZ0ZXN0Mi5odG1sIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2JhZC1yZWZ0ZXN0Mi5odG1sCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjlmMDIwNTIzMjkyY2M3ZmFhZjUyMWI4OGQ2NTBjYTJlNmFjOTYzN2QKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9teXRlc3QvYmFkLXJlZnRlc3QyLmh0bWwKQEAgLTAsMCAr MSBAQAorTXkgbmFtZSBpcyBGb28uCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9teXRlc3QvYmFz aWMvYm9yZGVyLWltYWdlLTAxLWV4cGVjdGVkLmNoZWNrc3VtIGIvTGF5b3V0VGVzdHMvbXl0ZXN0 L2Jhc2ljL2JvcmRlci1pbWFnZS0wMS1leHBlY3RlZC5jaGVja3N1bQpuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zZTgx ZTMxOGZhZjNiYjYwOWMzZWEzNDA0MzFmYjgzMDkwZDM4YjU5Ci0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvbXl0ZXN0L2Jhc2ljL2JvcmRlci1pbWFnZS0wMS1leHBlY3RlZC5jaGVja3N1 bQpAQCAtMCwwICsxIEBACis4NjA4ZTNkN2U2YzNhNWU1N2VhNWE2MTg3ZTkxOTViMgpcIE5vIG5l d2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC9iYXNp Yy9ib3JkZXItaW1hZ2UtMDEtZXhwZWN0ZWQucG5nIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2Jhc2lj L2JvcmRlci1pbWFnZS0wMS1leHBlY3RlZC5wbmcKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uY2EyOTRmY2Q4ZGVhODQ2 Yjg5ZmQxYWE1MGFhYmE3OGE0YjcyODEwZQpHSVQgYmluYXJ5IHBhdGNoCmxpdGVyYWwgMjc3MzYK emNtZDQzYnlVPUVAR25qWmg/SWxeNXxZdmkwQDRkOFVEQXo4eDglfWNma0JzdWZXKj9VXmE0dyRE QldFUCh6IzE1CnppXlJmalJaemFhXlNTNHFiTnsmS3s9P3pDUylUVmleVU8yem53aSheWWJefiRs Rk18THY5UGQ2bCRHdmxWYDFTawp6VmAxU0s1PztiUWBRWktSRGR2SE15fVoxWnZiO1JBbWI8SHN5 Xn1RLW1KanlKY3ZaVjBFdmk/aUAzQHstS0ZoMTMKemlUQCRAd3Z0YEM/flRAXmVicT5lK3g0Uzlt YlNZZHdzaCkzY2Ftd0Qhail2RjR2Z1E+R2xqcTlvfENLN2RJfTxyCnprejAzc2kwMX1rMzZ+U3Fa YUwrRXQ4d2NLdXBQTWYxb3k3TCFxT3d0aUxgdWhfdDk3bnc3biRIZHUxITYrNlBCMwp6UGdifV9g Xyp6Sz1oZFVZOURWNiFARzMrcitxenUyPDtAPCRgPTZFMGR1WXxEQyE2Yk9zS2N+X0x0al42ZW9D QS0KejNoUXMyS0FXKFVVOCo8T1h8SXBWVD8pNmR5cF9OcXY3aTlxOUc3akJIVUJgZXtWMDYhdDU4 VVJoPWNwOWN8aT47Cnp7OTJIbW0zN3l7YStoNTc2aUlmdGVlZDwwUzc/UXhIbHgwbGdlZEd7JEIr akNKa3s3XypCZ2s3ajRqSDlocD41JAp6TGQqRTVDd3NHSG1fWGlCb2xmSCRWTEFtX01YVTFwTkRy eWZwTERsOXMmbyYlM1V4byFjSGJ6UFBxd0MtJF49X0sKej8lLWswNkNMYVIqKUM9cnt5WiV9a045 YnYkQSQmWUgtNDs5ODYwez50V0dBfSpMMHQzMzBSaUxVN2p2fT1qeT48CnpYJW92ZTZPeERANjxJ JkBFPjJiQ3NkU21OYX5hWjMxUmR+ZWRjNVNFJTJYMXk5T0hpNGI3SWAkVXNkVyl3JHB5WAp6dml0 KCNwT19IaVNyQXVvVXVnMCRtTD9WMjk8a3QwPiFCJUg4Iz0xbjB2bl8rRSR7Q0Y/JklCOXR0aF9O YEBuKDQKejMtI3oyRHx3ckd4THQ4a2t9YjtUYCpYbkBTREQwI0I8OWg8R3w5QkwlSWJYayl2Ml49 diRWP2tNTUNsbitlU2ZmCnpucG5ZMmFSPGJgI01BREk+TmJ4WHVrZiljTUsocTV2aH1+Yl8ySXxv MmMpIXFZVFJuWkFkNWJTdWclKnsrPGFedQp6UCtzbzN0ej5gY0JZJXhncEo5U1FPcXApKT9rMkxA OVpIfjZQODZFKlhab0FXXjlBbmVPMHBzejRxazZNUElhQGsKekZeWUljS1hoeHBeVFZeQm1rT1A4 Tjk3Vm45LUdUKm5qNmhmbUdFMHk8T30lVU9fbiEocnh7ajltNyU3Ny1BWiEyCnpZTkp1OWBYfFM2 Zlg2dF4yZ1dMYTlfanFUMTs0Q0ZoVUI2a0h4V30zJEoyXyFNKzQ9QlRNSDQ8e0YwNnRDMz5SeQp6 Rm8oQnd4RjcwTm9wbnJ4SDUlYyVgJDw1Z3lGUTBUeGw3Vjs/JTRCKUw4UUokb3VDUWNETldGd1Yq eEtCbGJXMjIKel9GJWlPLVBVVFZLTz12am4xRChMMD4+b1NGUjRpYVIzIypedSRaeHdANX0xP1V+ ai1rcURfWWJtKGRvem98O2lNCnpjTG5HZ3E1eE53RjVPSWRqamZZZENRR1A8WnolQmY0bGwyRWIj Xz5CaCl6NDVZZlAxfHNWd189bTNoVkRfeHp1YQp6VSM3bWBkKE89ZlYoRlY3ZSh6UDtsXm10PD5x Mml7SXVXeGA1SCkxPGNoKXpkYzRaKD9Uak1PK0ozdkgoNm5hTlcKend8QktNNUZ4YzNnck0qYDRN Zno2Q1lHflojVVclNCE4LXBETyVWRDxhIThpPzs8Snp0UDVfcGlBXi1+O2tOb1VNCnpYZ3Z7bSRV Py0ySHxHejJ7VjQ/Tmg0akNiRnUoYXlHR24jVjNzY3tgXyFPSGtAV01qYWNzbT5idFhOUzhabj13 Mwp6YW1XdzxpdUNLQjd0fStyKmokSG5VdER+TyRCZ19aNSQzbkg2ZkE2fD5BWlp4aSUkc3dFNFVY bzZEXjkzNko3c00Kemh2SXo0em1fS3Q9Xzl6ZjZKfVEmSlo5Z2w5RzFUdSN3Xks8bHxnbnZRejN3 OUpWTDtaZzhHQXQlYWZENntnanowCnptI0BvUilMb1ghTExVRDgyXn1NMldGLWgkc05fclJLN1gp Y2ZMfVgqX3dzS01MakBAYWBMTnUrRDg4Um4+Pj5ySQp6cV85WGB4I1BeQUFednFKe2YwbTlWeClI RT5tY0RxKk9ObVJkc059SnAzJDRMP0hgYzt4TE9vJk9OWmQlQ1ZWaDUKemQqV1NgXyYqZ1FteDRR WSVjNlI7cFhfJDN7bWhJTF99YSM+M3dSd3E+Pzl5I3Vob2pnMT9PfVM4TFVIR2BBMEFOCnp0TWoj UnFyQFhxd3F5ISpeZThWWXFkJE82a1ZGaTN5VXEwWkF4PzI2ZVpzfiRZcjk0MVZETzU7TnB7dS02 Zl5gcgp6JmV4X3BKQXRvUDM1QnJeYlI2fDIqXkhOUnMtJk5RXzVCLWMxZSZtd3FKblpJX0FFX3lr TH0rIStGYGQxWD1KPUAKemh6emRpZGpkUH50Iz1KQjVTbm9RdXBlY0RBfGsjallCeTNkdio+eWct STRBVTl8KHkqT3B3dTJWZnx4TDA3SU9OCnpPVShSaUQ/T0RQPy11IXpfaj9WNEF7czdqQigoOUcj SjUrWjNvJnNmNDZreS1NLX1WS2lSZnFUMjR5QnpRSDtnPwp6RnUjdGskPUQhUTUpK3k0S2JvQ3Uj P31xPDwhJDFyZ1oxZTcrTVooMSRtaV9nNThGb1NMYD1FKU91fGIrZD87OCQKemJ4IyFYUXZ3aHF5 N29ZKmZpKXh4RzgrPCUqKWBVRz8+YWVVdXdlUyp7PFRUfXJtUCFjZztCZkojO1djYlojMXA9Cno4 NERuaz5vJnY7VXpOWGBET01ALSh1VVJ5NSNPQ15XajhMVXdXYWxYN3c9SElgRWxrRlJCOVdERl4t I1VMO35ULQp6NlNvSDFVZzApb1NSQ05MRTc/cmNaclVrU0BqV3xnTGQ4YzhseCFSaUF4SDMzLUNI PFdpZG1ZXkRNaCVHWTExYl8KejRDWSVtaS0oNzhAcCZqcUswcEslX1Nzelp3RUpLRGBxMD9YQEMj XyR3S0wtLXVMSTw8R0d7O3tOdFgwfSs8X0ozCnozYjhWayU8JnoqRChQfTAmTVR0QVVvaW1yPSNG IyNkMW5xazA4N3ZkOGYjTH4mMGo7T0tJem9oUl5BXn5GYVBLYgp6NHppSHpZWj1gaXlKWTdrQTc/ aj0rb05qO3c9OCRtO156KTZfQWBeM18lTURmOTttK2dLdT5SQjVAaGl9THZyPTkKek8xXzE8VW9L YnBuU0UxVVJgYlVhT25eUjh1TXJLUFEyTnlTSE9jYD5IaUdJeGNRVEluWkkxSllpaW9UODQxI2xy CnpmPDhLXj0zN0ttYDE3OW9rOH5WZ0IwJGYrQmw3dmtrSUJ9MF9zdmc+OT5LU3lMcUQlSGx5S2Jv IVJKam1HKyhEYQp6USpKXkI5ViVFeSlAYi1gNV5ze0I5Uyk8RXhsbzB4MXxhLUREdjdUS25CenE2 cVVxbytkdiQ/Yj5qOWpKcHVsXlgKejZWTWtAeU9PRH5HPl9FY1ZfN1hzM3BaQ255Szt+QUtyeCZ6 LSU7SFA3ZXlBWE4/IXF1Z0w2ejA0az49UyVVZlFkCnpoOF4xMUMxfkclcnxOaG04MWRSRFo2TjNO MmEjRWtDI2Q/ajFOcDNLWHJsST5MbHpFK3JDSERQaXQzYzMoNGQ2RQp6SkJRTjJmc25nTCErQzYq WFRGSmYyRkk1Y3lNMTVkQT1BWitQbkNvNWR5ZzVmOE5kQUo5UmJSaCR3VDU3OSRWKkwKekBOMmkh TGJhQWRzRndIIzNVMS09KyN6Nz1LdmxyTVFpYSE5UCVvSmVhe29FbzQqNXJPQ01AY1lQanpuZyZf KzJ8CnpFM2MlO1A1cm9jTF48Z2MqUWM1alk1JChMZWpMV2xlNW1WJD1KdHpPYVR4UmM1aDdBbS1M YzNJNT1uNHJkWlE3Owp6Y1htNUpBSz15Q3RwfHQpZyM4bD8zbnYzMypeNz8kbUo1T2JlZ3Q1ZypZ ZT0zI0Y8VjEpKkdRNyNfOCo3aGBoU14Kei1eLU5EU1lxajxHWiRrREFQKjtGOHNCaiRrd2pKQyp3 X0lnMDZyfXB5NVpoN0lPKFB+R3Q7MGI1dFk3TzA5TmttCnpgYFYmVlowSGw/Vm02aDErcStiRUUm NVdHPDBlXlVwKyFONW40eCtGIys/eC08JWA/V3k4YiExLSVeQ2pGfjhnMAp6LUd3LTZgN0lvMjdi Zl9Ad1RTYGx5I2MqVk85VE5ETVp2eWtybUQ0clFPO1l5eEN6bGY/Rng+Yy10S1F6TDZJQk4KenNG bVMjU3BMenp0PDNUUXBKcENmaCN0cHAoSjJhWUF6cio9QkBlYFUhcGl0b2tlYWlfezxIMmloTUR+ aXlSRVcwCnpqO2dASmBNVWFReGR0Pl4rO2k/eiZ+Wj9MamhmZWRAfTNHUCgpNSo7JjNuc0VtfiRO djVmWCZsQzgqaktDTUtIewp6U15HVz1UI3d7dmsjJXFJaVRiTkZAKTdfTlRkNC0jP05xRiljXnBU dDxGPXxaNWpASVMjZkZ3MCkqQ2ppZXA9ZmcKek5TeU9BTDR7IStfd0pCQG9gKzdWTllReEZyWkx2 c1VDaz9gVi1gNWsrdXNlKFYtRiFTYDcxITFrbDxJbDBrLVA/CnpVPEVMdmRYb1EtOXYrMmZRT1pT UDJQYDElUnlfWllNUVR4c0BDaiUkdjI9RC0tMn4zbml6d3NhV3ZYU3VAUiNjMgp6SSpaZ0VIVlg0 UCsrSiMqY0U9KTNfQl44XjA8M1VxYFBMZ1ZjLX5mc3MrRVRFRCpTfjd4OSoyI04tYmAqKmBZfHIK em92VD8/RmZhMHZiZTdgR1JAPSUqYm9SNDVEQnBmbGNJOTh9NTdvbG9AZ3F1MWN9JVdSYUR4ezZB ZkB7R3RrY2ZOCno7Jj5IPzwmRjF7Tjl6cFchZXRNV0w1dTMqIUJKR0JYcG4zbyVSaXQobyhWOT1q bE9TS14/bGlYez0pJkl7R3tVfgp6R05BIyUjYWU0YCplYy0lJiVjSlBvai1JM1RYcUh6Umo+Pnpn Y2xtdVVuTyVqMFZoRUBaZ29BbVY5MFY7K3QlMykKeiQpcWBsbXFofDFrcXp7QC1aTFAye28+KW41 IVpGRCQ/NHxGNlA0WilMeSYqYzxSeVIyUmdmOWo/eF9EcUZFJj8jCnp4Tz08ZTQwTWFQV0t1c14p ektXPCE7dU1EdDZPRj1JNU9NYz04YjtISHZSNyF5eEAlPCNtZV5UZUxuKEAmSXk8dwp6RXFMai0o QEQwe2t9Njw3JipTVmN4JSl2bnkjaWUmQjZrJWojPnx9ey1ja3lVWVRxYmRiS0ZhblZDdmhrWlJD UjIKelQzQWQzI3hZdjcyU29GZGlUIW1rZkV0e0IwJXJaQHhSZWNRN3dEa0xUVCMyX2kxaHdMTjd3 JDBHLSsyT21OZWJMCnpjTWZgQy1uOW09aGh8c0RKWSowbV9WVUtBMyFDSyRRUVRGbHtWfjFZY1hE OS12Png7S0JDNTNZV0pTYjV2bCV4WAp6alp8PkdEXyRWSjFQTCZ5ZnJjZFJAZ148anlibGM1KTl2 V0F5emB4aG8yc0lJVjhgY3lXYXtLSDlXP1FkT1JlZl4KeilBWGVNYWgkZTZANmxSMHRsZTNZI1hR JX5wSV83UGxxJVBhQXBhYjgkV2V0JFYtYn49UTk1KEdhRWhzSlArTWQ2CnpufFpmbXkmQXFgPmtz RVF3PUVpbzshandqYGVFZWE7Ry1sakdSaCQ9bksjJUY9KGooX20wRGkhXyo1ekU9dSg1Xgp6Q0Ap USspPm1fTGJFQUEoSnZ8amVeVkI/VF50KEZHdzdlbUZ1aSptNzZiTHlwUmprJX1ecTllVXJXb2pT UFlDVXEKej5gQX0ybWJsSlphZ0V5VT17KkxHcTFSXkBRUjVSRTRtcWl7QDh1Y19hXk8rdTJAVlYk QU12IzJob3o0bDBGQiQ9Cnp1KD52TDFjUWtXJWpEcm9xMFE0S2t0KzEpQEskYzs+QDAxKT9WN2NN IWlNXm1YWH1sSStRUUEkQjhlPkJPeDE4Pgp6Z2FVb0pGVCM4MGJVR3NCI15AYWhAPjxyMV42a1Zf RiFsMT9ybGdfc2E1ez90eEcoMTBebXE2ayotb0ZMOGomVCMKek0/XnB4YjdwJXhKRlAmcG5mcE88 cWQ5e2xZPEFIRiYjRWFScV41cFEwVDRNczd+YmlqXkQtaHhjY09GQWpzNzRICnpwMS1yUmMwVkgw aV87MHUlSkE5PGQofGg3ezh2Xn0jREwzfEtXcShjZHAxVClQKE1DYUM7PEc5Z3ladnVLWnBfawp6 MWhNVnxie1dzbT9sb3BDdTNie0NOfm8oJGFafGE7VkotWiN0JkRZVzQlIz55PjUyfFNyOzIrWU43 d29IdFV6KzEKeiRZV0AwejJ3LTk9dTBXTWZfQUt8Qnl+P18pJWFYS1g4NipDKk8+Sio9SXF9aVU0 aHxodUdjb3RjVlZ3TzM9fXhKCnpHV3hwb0JDRiNqJmI7PzBhdHVKZkpiU0N9KGtWX2RNS3J7enlZ VSR2SHRwODRzS18ybEBxaHZ5KkJmRio3SEtRVQp6cmVORlIqPUgkNkM+MC04Q0kpbn55Q3Z0aVlI MUkqSTNKVEJEfDJnV2VnR29vUVNVc2haUU1EXjIlViRCPjsqQXoKekZqQ3cqdCNXVV9NfEJXO1pw cnJ3TmUqWDlgYkskN2xuI1M8SyVHdkwjOSZyclhxVUNWX2NiMjlAclZwUWEwU3NxCnp3QHxEKGY8 SHE9fEM8N1dPOEJFblJDZGkyT3R5M0pkQXw3R20we3p3cH1BTXdQLTZZTWBwTTFKPkhRKnpuZVkr Xwp6dkA0elNAXiQ9IyNQbz0zJiZTeGhwc1lDV1I8UDBiKkJWM0tOcHRyelhZKmI8UjB9dEhaMFJZ R3R5Kms+Qnl6QlIKekFVe2g+PDNYIXo8ZGN9eC1WeTYrMzdDTmUyPzs3NkdNeyhKOFBWRH0mJC11 KENmTGhhYmN0LThNUlpYZXludW08CnpHc1pJYGt7d0ZHIXwtYzh7aC05JihpVHp1bWltQShqd0p1 a3V0aSlFd313SlVYUSN2Xk83R0RrPEp3fnU9Jj9oUAp6YGMjVkp0aX4kd1ZqaWQ5RFFFMzBZakND c0o7Qn52c1oqMHYlWUZLUm5CY3hmTTBaX3tHfDxuRmlzNn5fbldxSm0KejV4JEBjJHJnRERuZEU9 Mz8wbmhuYFRYNShkP3R7Tjt0NSMoamRSLWM7RVdze3clZUNoekB+bGJuc25DOCRCbGRZCno8JUtG S1kwaDg1OUJsR1NHQmxGLVlYRDNzWDFUYG49PVpKP2JNQ0h7JT9pWSgoPXZVemdDYkdpN0M4eUhr czgzNAp6TnhmaW95QnNOa1p9PzB2QDgoMkg7T3hBdiNhOzZPLSQ0dVQzKmlYJSRqSCF+eGwleSNX c0ZHaWA4VDB2KWl8cjIKenBoR3pKYkdXVmVAVVUtMz1NZSNIcDJFIUNRcGtIZVZSNyZFQzleKDVA Wmw+ekdhRlc+LUJ8QT05JUF0K1Qlb316CnpNJGFyLVJKem9vekwoYiQ2NVFDfjg2T2FsaEM7PHRy WThEUSpMOEhmPGt+d3R2RjUldXQmKDZEVl9SejE1NVVDNwp6NUpTVD95OEwpJFolY2M4ZjZUcXRg KzB0T3R1Z3Ryd2hoNVk3PlZqPGQ/d1VfbD5majNUZ3xZYntwcCh3UWJDNEkKej4oIUklRDVNUnk4 KEhmfFRkPVgybVZfJE13RWpMJWltaVFoSCtKb31ySTQ8a2NVSFBhQSt4ZG1ITkdJVCRWS2chCnpf X1JkQ2EjTUNuXjR2TSZBXy1Qfj9ncko+K3x1cVFsWEFwPip4YHIqYUJAYkpkOE5YJlJpZzAraEhL Pm5nMGJnZAp6RXdsKU9IVDlwfXpARVkzQ3Y7MHY5VmIqJCUjRXleQm48en5oVVZ3cmp5K258YXxC PGEkSWMoXlh0YEFVITkpUEsKemBXfjlBaHFAfjBGQStOeDk7UnhKOzMlPDtITEtVNzsqIUQ8XnN2 SkZDaFhWOCpycyVqLXxAPEV2VFd+LXZvOD1iCnotekxKQSRrKFd+SyF4NDRZdVc7bTxha2N0TURh cnBKRXJ9KD57JUsxcylYWHp4YHJmRUJvVDw5I2I+MFY0QTRGVwp6e3NCSkg2VWJNUmRCZTNlYCtm ZVZTZXJ0QVgmOGl2dStoUV5gI2RlaFVgVjNnU2lYZH41SG1YS3twbCladEl1ZngKeihzfWJ7JkVq Xk5JNUk5QDZmS3RDV0YxYSQ3bl9Ra2MrZyo0RFN3c3kwYlc2V0BIQlUmUmBaR2dkdiVBUV99SU9Q Cno2QUFkUF9sNil9SVZVOVVwTjI0U0Q/Qnh+VmFwTHlKKnEheCo3aihGQVhlZWBheUI9b3ZyPTFv ZVU1YkYtZTxndwp6aCVoZU9WdTk3dyplQDYjWT47WlEzbllrZEt6IWo3TjRXNUVpUlB0Z3N3KD50 Pk49WlEhQ0c0ND9Eb3I2M0lPZnIKendveEh0WXZXdWk3KFpQUzVueV9JUX58SXRRYWVyJi05RG9B WnQqJWNTNCk7YyR7K1hGMkwzSGFndyMlOHt4RTkyCnpOfGdfKlUyMiE0NjVNPjRHPHkyNUZmQk9u U0BCZGhOPEFHSjxkKmo3R2FGNWszZDZWPXl1Vk5lczxYZUA4YFJUbwp6bEJSV0pEfXNtWTcmb1ZG QE01SnkwRTczVis4NCg9MyNaekJzLSF9fEVqU2NPd3dnVn5PNkB1RmE0MiU9NWhUZD4Keip2eXFG c21HKXcqKGY+fD1JREo2JGNfb2BHbGgoV3dgUXVue2FVfVZAVXppQztkdkNiWGcrKzlYPl9yUWRK Vm9nCnpubjZqaEhAe3o0UHlneGclWE8xIy1MKkN0XyNFaHRyajJmOHJPVl8rZlFAe3tzdmlvSkdA MWJLLVhWPSRfbk97IQp6eCFaZTVqKystNDhuITtlNH01RTtHUjlDJDdmYU5ncFJYO1MwND55OE9A RG5sMmhffUctT0RpLXRMWVcwbmNXWVAKekt8YSlVWjliTyRnRHlpZXNXRkoqXl4yVlU2TSRTZERN fUlZUEMjVVA7SSNzUCtabTU3bkhGMlEjbkxAcFJqUVVFCnpkTzl1akBjVEEwTyVPK1dQNE9kSXtg VSglSHYheChGezVwZll5SFJgPjhIIW90WTUtVFZLVGpSenJadX15e0cwPAp6YioxQWJzbGQ8Wmt1 P1dtQzhaTzU/ZG1ydksqVWx8JX5ZVXdgeXYrPEE3MHVwbTE8WWYqJnZ7YilFdzsjO2pWeigKekVO TWBDWWZJamp4UlBONWBEMmRuJVlWSmRKMzx3dT4tK3M8Y3ZgZDsyNWF7VEdmdWh7clhrOD1xU1Rs biktWHt8CnpZZDYjQEJHbTJSeDNFRWc+NXRoU3MyTV5VeTZ9djI2UkwpZ1BWeTVNOUxsMmY3UUhS Tl9wXytQYEdlVVN3Q20pfAp6VFpVLTwwXzl6NF5HRmhGJkhWdHgwb3htbDhPXzVUT25RbTlDPEY0 V1F5N2dLbyQ4PFBybzBHdyVoTilTP1BrZj8KeiU+VDJyJjJsWDVOZzUrQTdyZTd7aVpKfXpZY1d2 O3ooKlhTdm00cSVYdG1yS1g+X0J6YnQ4ZkgzJmRQWjVOQWkhCnpuYyVzciVNPjM1enQxQitSIT91 JmBBSXtCKGJralZmekYlJF5WZkt2ZmQpbE9lPns4cmVtXn1XMEZtak5XR255Zgp6QnFMcX1pQ1RZ WmtlJnFYMSpQI1Bgek1xKkg/bFJQbjdPWFA3QF5CVD1XaXIkcWlBISlpWHwrcHt3ZThmRGx7YDAK elE5Vzl7JUh0MnlRRShxRGpSWWJpQzhLV2NyemtnSnR8YGFaWS0xPitVTjYqTyh4QSRSb3BITF9U bVkhOVJyQzI4Cnp2X0lAUCpYY2RRRjJZYUd7JkRMVl5wViNYPyZiWXo7Q2NrQlpUKGFye35tSFJW U2lQaTxpeWlZRylnaXpYPnpjNAp6blFJU2liOSZ9SjlfYEB4SHNHeSlTPFhKM3NfdT95MWtNajNw cXxZSVJtTC1pJlFqS3N7eXZpeXRLLXkjb30yRUkKemsyYmopRCVZdTxXJDJFQG1fZ2MjezBBJWtL KjFaTSZWQH1OVlgmRGtXeHQ2UlkmV1Y5VTJebVdWWj1OclRDIz1CCnolR30mNi1ZQGlOYGhHZ2l4 VTxnQCsje2RVNzA+RlkhNzl1T0ZNRWhnXnlwOG57eTgzUmhjMldOS3w5eiZ6MXNPYgp6KkU5WCZ8 MXpOdnZ7ZHRJbHU1KUslWjg2MndDSzx7YUpoJHxAO0tSNSNVQy02PFVOeiFZQ3RtQDVXUWh8LSNj azEKeikqbXVkNilkZ3F0MCRSfVF9PUBBRjJ+KjVAM3I7NzUkJVQzUnVFd1hUelhZXyopdmxrdGpe JnNMX0VYbGZtKCZyCnp5fXJkYlcmWTF9PCtVMzhLdTI5JntkY0JJIW5KJkFJZitqQHVIP1NiaSF1 QlpIOGlAMHNpZlBWbU8oclo9V0sqdQp6MnBgZ0YyI3NHcE9KZFpyZW1UUzh0cHlKTTJXNF5GbXot PDFnXll2WWVCd2ljJWZyIyhvV29YLWxPb2RmN3JEQT8KelRiPilXT2g4Y088RX1FcD5ZYXhtNWgt eVNgfFdfci1FRGlOMVJBMG1hIzJ2U3UrVXp7T0R8T0U3alpveFgjeEJ4CnojTDczPUI2bExIJHIp US1aV0d4JStIMCR+P3BkVjBUZ2JpRnxIP3I/Q2IpVCFsfHg9NnReeFNTQE9mZUBwUGpQZAp6KjFV VUM1akIzb0UycGJ8XzFvTyZSJGBpIVBVeV50cyV3eDFLfXBSK3pSK05qVFkwZVRKTGVUVDBQYFVo OCheTFQKej5NK0c5VUd2VFNWVUJoX3Q0aH1EMVBie00kRlI1ekRVKTlDQXxqK3FFJF8qI1Moc3Jf MmMhN1BLeHlpYGVOVGBnCnpLeDNrPGJ2RGhNLUc1Kmc7MXtULTFuait2S34qODVtJGZyJDB5VzAz aFpuTC1hTD8lKFZnPFZeMCElJlhEV1Y2Twp6YzhhaFQ+fmEyUkBIP3k0UmN4ajByLUs4eEBUUC1p X0A4JCRUck01fCE5KHZIIXQkbzBXIXo+OztoeFFpaH5lRW4KenVue2lvZ1RaKj1md3pEJGE4d2s/ VzFGOzNpZD0wfGNGWTV2Jj8qYSk0ekpmTkFfUipqP3ByVXBeQWRCYGA/QnpsCnpVRHZlO2o+M0ZT Zjk8fTdIb3QzdXZmYVRIVUZUclo8MyZmTmhGNit2biZOQzlVfFRuWjMpRktybmstVzk2PUBGZgp6 Qk4xMGNeM31EQHROa2oqQXowYmpXVWpzJlEmQjtENGFwSyRvfEp1VkhaYW5QJjRxekFNKUdfU0ZY XjB8dnxZYSsKejg2UUx2T1ZsbTROS2FRTWIhdkwwXiRXfWRzU2R5OTdNQEA/ZiFnLSY/dUB0QkIj eUUjeTMtNG1DQmRwa2J8Ui1XCno3Xkhsc0l5RmcjPkA3d0VZVXswS2kkfjA9dzVsK3YkYXxpbmF0 TUN4KUtrVG1gbGc8UmB+eDAtQDwmS1c2U2BKfQp6eDZ5ZkZXRV83JD5xRj5TNG1payRzaGdeQT5D JmYjJnx7MEdMQiZMKXFtUlZxX1Q1cm1OTFJGQSZRNURFQUdeRCUKemNReGdIKUZzJmxUKGsmSXRj JGc/ZFZ9flk5PWBERmVQM3k1bChIUiQ5QldefWNaJEI0MyZAUTc4WHJZNSNkbTY2Cno9XjhMJFEw fDE2XlEzSUs3cjNfaFojX21gRWVaJHJFLSFmfjA7VVI5ZTtwYHhuSV59WktlYWluN0VIbS1JJCVy SAp6ZFFAfSM8N05lO3lGSnNDe25MfEpHczEqcUdIbzVSIXRjOWdLT2cyUlVeMDxsaX1hLVp2RXp0 Jj88fjl8dmhoV3wKemhRSlghUm5EK0VLaGNyRzU9NGF9Sy0/ZWRgRUJXfj1SfjlEeEtxQEdAeEc+ VE1vWTNBeUhuKEFENiN7ZXhmV0xqCno8dSk8YyN7UVVecXxPdDg/QC0wODAmNXpVZkhsKz1hN18z YjQ+cz1KSitKZHt1dyEoQCNjYFJze0lmSlljNiV4Zwp6MztueWNePTJZP2tBNllYb3lfPjl1MUxv e01hbmU8eXVaSlBsdXlFYXNCO0ZzSHE0YF8qfHZ4bFZhaTQkLVNsKkkKeipSczJAI2cwI1dKT0hu cE5SYDBkKmZJRF8yX0t9dTNVM3xQRTNMZEU9bjhsbSFXZUN5TjZVJGV1KHNaOHlubE1xCnpUdils cyp7aVpDMTc+MTYwQHBkTFgzOUJtSkQoIzJgKExlJCpVcUZzZmhRXlEoPzlOWV5RNE1qaEN7YThO P0RCOwp6NmFZT2N6RChHNmpeNnV8KjZDVilgNyhGbE9feFRlSi0tXmFSPnF1SkNLeEM/X1JpLUo4 OEVpd2dCJjlhUSRASCEKel9ZbmNYUGlPK1oyflZhODRMbzlITSh+XlB8R1pBP2R+Yz99X3J4VnpK KCs/V2VBcT4obCRJanJiPjslSktLPCU7Cno8ZzNyWkxCdXhOenNzYGY5JHlxIWhoaz5sTSY3Vj4r UCE7OE5gTFBTYEBvdThXWl9hSUVkPyFET31BNj5EKUMpagp6QEVlMGsre0AxUVNgP0hIPWQwQGMr UzBIR2BzVTNUbXN8PVpyWVlYfmxIRWg8TG52YUFzVT51NEExVylgKH1jN3wKejx5OVJFPyspVDVa PitUNVdlbU9YTVRQR0ApVlI8O2A9d3Npc2NMP1NRTz5hSGZhMXprey0lIVlJbGV6YFZ2K0IqCnpV JHhkVz18KjR+KEhRTWQrZmspLUl4eCZ6YyZJSUl5N2ZxVXo/dnBOSCshPjV4U3xFfHc5NCspcCkt RlFKTU1EXwp6cWxxaytQSiNfRk16ZHJ8MnA2S0FrdmhUY2grWVNUJm9uR0RKR0Y9cVdBeiNxWU4j SmM/OVB2am5pe0NTalQ0PE0Kej9SUXx+WXxkZiFMez9qKkl9UHwmMVlBM0hSUHorRXZHTD9RQUhM Oyo+R2NWMlZtKkshY2B2fmcwUXl2T3ElfnFVCno2QUx5RDd9Wn1SenBkKiE3Xis/KFNsa0pzTjhn aXJMXjtJUXRMfW8jRHJkUXcpWEtNJnIpPkQ/YVY8U09lM0J7WQp6bnZGX1MyPURkNThZRSUoMTly Q2E7dlRiTjJvQFdgYXxxI21fOChHXkRJOCleZV53Zkx7ZWNLaSE/Y3RxY1pmd3kKelgqPWdkIzko RzJ6dFdTQWh1MnZkWUtzQDgmVm15MlpERVhqYEwkJjxJNDV8I3JGblUzUVNXTHhvNEdsSzNCRDFW CnopY1grdmpAQCs1WWcoNUxGeilTWDZiVD5DOWM8Q14qO3J6WmZgUEt8e2JaVCpZQkU1Sz1vaUEp O31GMWZSfEA7cgp6V3E1X2QwJmU9ZHclIVIwLWUtaE0yRE0xSTIqMEteOXZqUH1DS2ViZGV3KDdl djNeTWA1MlBJP1duJShHb2RCU1IKemlzXmxEKCtAVWc4SUNta2x1QHNWMlVIRU97Vmt8STY4dSNM ZF9LVEJsVm5fcyE1MHFMTns1JFo8TG9DMTslUF5rCno+UUFES19tMDtvPER0cyU2ek9+OyReZVBs Py0pP3g/ZHAkUT5xUUtxazFFblZiYG0qPFBMZkhtOHtEZn5QMHAydwp6eCVlIzw4MkRYQTV3KT0h SDVsYlVwRyZQez1vdjc+bGw3KGJQMEEyekhFTWxsO19ARDlmNCVTWl5UWHtVSi1VWFEKekReJVIy ZFlEcjlSRC02P0UzeFYrU2RSWlA+NThJRXVva15WI2E1fHZtYnF5bDFZITUmMkhXVnt7Y3t5ejtt bHNmCno9OysxZGJrfDU3QHwjVFU5cUpAJDVFPlkkdHZiTUBZbz1GaE9gSjV6UX1MKzcydmdYVjJG Um5lZyhzV2d8N3ppNQp6eVdIUGk4cVBtMnF4ITI5V34kST1UZE5sWEliX3BIcj9kQHpjZzszSkNC V0ItcUB7ZnhGdEs5PEI9UXpCTkBrM2oKenJ+LXl2M3M3P09zPXtaKG1gQHVoJkVjRjJhTW5gQyM+ PUYtKWs4cn1vS2x8SyFMIXUkdF8xQHwtVUY3KTckOXFfCnpqUHdVPmM8dkA2ZiR8MTR3eXk2Vmty fT1GVGlAM1QkOWRyMkYmQCp1S2AoeXYqeVM8SEY5NG9neCVWK3pASnBDKwp6Xj1paFZXU081TlhY MXJZRjtEY1VZVSRMSz1URWc0K1gmbGNEakJaVyN3fE82YmwyfEx3JHxnRFoyRmk8ckI4bDEKekRS KWs3dGxuP2ZDTkJUQ1ZYUlBjZDwtJlZgJnomIXR3fSVId1NScldkQD17VDttam0yU1R4VmpmRXMj Pm01JmlUCno8ZGY/cyNvPUFWRmlNWmx7Qjs8bGMobGB1bEZIYEp4JFI+cj9LZz1RX08yRVlxe3Bw ISZgVD5HUERraUtId1E9eAp6TTtycHpBJCMlOG8zcVpyQVh8Zj9mcmRgIT1NQX5ZZmY5cEN3QjZR bjJxcG9qVUM3IXJeUCV9S3NPdi0xY0kpYlMKeiN8JmR6YXhAclJLVHYwQHdyLSVMKTQxKDhFR0tv YU5aPmkmbFReOCNBV3tZUVJaczY3S1FYNGlOcHlJRjlNYzFfCno5RH11NWNebUNqOXJtUD4qJlBW WSNHfEliMGBOeFZENm9+WlFleFBSZWBqd1J4YElueUlOUHB7eCh0RD43SnNMJgp6b05laX5Mc3Zt b3ZeM0tweWNDKVJfNmspNl4zYldtYCtzNU8mMF42VjtDUDIoIVVTQHEmMzVfJXBAMk4kU0QhfGcK enVYbygjQkVWeTxqYCh9akEpZzZ8VUk9UyEkP2szYWJ0MW84N1IpJjA7QEI1ZGl5PSZXViZuaFBr d1FiUXtgUFlaCno/eU5wXjd0bHQzMT4hcWNTN3BIPG1OXik+ZFoxZiFRLVc7Yzt8Tk9ZeXcpRnxo TjxxWEc3UUV9V35tcD9BX2o2cwp6cUQ4Tn0/QjtrbV44WHdJP2twKExpJlJaOHVxbUJpQ19wI3tN Y2pOK29eT1lEOXM2flFtIU9GP298VHxWezhgWSUKem1jYzJEWFA0bm8oLW9uNHRCJDFaUjVmSklN aEluKXFhRVp2I0diSU0xP2RnPVl+MSlHSCRGZjQ4bGxwPzNebjdmCno/P1U7eWx9Vytob317U2VN UVk2e1MtXnhYekY/ISpya1oxJDhjcGlaWW8+YU1YTm0oejxKQSFCT1VMS3F7eWk0Vgp6bk0tMTBe bF5xPHxIJTQocEZvbCE5b3w9VXhXSClORGdZYGQ9bnU1MykyZHNWKlk+ak1TNCFxc01XdWw5Z2BY SGcKeiZCd0NMUXVQaDB4ZUprVkdmO3A1ZkJRJjBgYm1MciU7PXE7WTM0dFYoKHtDdEFMKH0yWWNV LXk9c0E/QTdOJD9fCnojeGo2VzZfSDU+T05VV35WIVNRK0pJaDYpMUdXbUopJVRrXnUqSHwxVWoj eTQ5MWU+KUB0JTI+Jl5HKVdaJHhtSwp6NGc0c2s2MHRpXld5czNscnxlSi1SX0xmeWc0MlhfKGRH VW01VEZ8PmpGUVljR1U/XjM0TyhZZlokRnwqSjlAZHYKens9aShabXFNIUNDQUVqJHB9IWhwLVk+ PG93cVkxQjk2NEljby1PUlItNTJGNEAzQ1VgWlU1bUBvX0VPUEdSSHgxCnolTnJ8YyNXQTMyb2By Znk+djx6QVQjRmcwVDYocUooe2E/UEVNemA5Oz89UXImWXBNVlFCbE9abnN+bWZhVUJNPAp6a31J Y0NkSmttZD1TUnxwcylyVTlHQllNeUx4WT1aUik+WTNnV3VMZ3pObD1ZR3xhTXtLbyFFamJNaDhG JX51YWIKekheWmkoX1hUeUhiYjIkMFM2aiV5c3Zwbz9HajxwQE5PI195cnY5NGxsJThSc2Vxd2lq PGhNQkhhanxFbk9QJlo9CnohQihuJXl0bklBKzVBZXY8JUhFKiF3d2B5R1ZhPmt6MEJ2Sno1Q3tT LVJqTyRORDghU3VFYThpfEReQSNTeH5iZAp6ST01PUlwI1dUNihlX2JTVylueGEqRFRYPF5TfWRe Zn0hZjxvb29uLWViMHNTcCp2JihKcChhJFhoTnt3JG9VIU0KelUldX1oKnF2LVM7Sj5NU3gqdUZP R3Mhb3U0QnpYX25kc1VEMTJfNyg3X1EmVFh8PWV3TXJ8NUFJPiUpYEJKM3ZoCnotS19OeyEmRVE7 eDlQWnE1ciNtT0p5PGA1Yj07OWlBciVvUEotI25zVUQ4KGZ3MmI1LXdQQntrZmVkczE5JkJMTQp6 OzYlXnB7NFY1aGxOKF9UOUcwNCRTYzA3PDk2ald4ai16ZjNHKChQcT5HQjtxVGNWZU9LZihzKU8w eDdFMXgmPXQKejx4TThkYHghY1coakdVVyVYLSZReHRlelZqKSYhaWkzSFdGeXtfU0Y7U3FQZ0A2 I1Y5eEMlWlAxKit5KzkyaSlXCnpvSHJmezA5SHdscypjTWwoWHtxfmVzWkNTbFZscUxPejkzbnkt bXxocjtBSnVsTktjXipaaDdHIU0wdylHUDwkYgp6TUAqLUBEcCVHZylBfm5HPyolIyFxeHRwQEpC VkZ2ZnFiY3UpVkBad3R5dS03IylpZVRLRTtAeGxCVypvN0BgZDwKemF+JXBBMVJvY2NVcG4pMllJ QEEmU1BQanZwaC1rQFQ3YTEhXkkpQ3BGJF9ia2xteTBYdkt5NHRzX2g+cSRAQz9VCnolRHteITU0 JndFPWkjQGpCYDR4QlRZZG1KNHdGRjZGYXwzTk5YTGBQRmBtcU1iVkx4MHgmI2AjPUFiJn02allz IQp6X2tMOFlGfkhFemQ9O0JeZl5ZcnolaEAyWiM2b2MmSmQlN2o7ciNrU0p4MTNiJCMkPkV2eWU3 MnhuS3puNmw0fTwKeiQ+WSpTLWx3VUQ8Mk1aNkRMMnJ6ZkNMKW1mS1FPP3Qxbzk3YjshX0wwRkJW RXs7RXdvekdgeHRQei1NKnBne1hQCnohfnxUdkZHNjUtV0k0YkRrNTFkK2tqZ2E/NChAcUJHN2Jk Sk5ZYHoyTnczUHR1KjJxZVVHJD5AUHNIRypaJWU4bgp6SWgrfCN6N29VUmJubzdjK307Q1hFWGRw Vz8jbFI0d2NgU0pwKWs8aUk8KyRSTzhiPGZPcz9+S1E9WFVpam1CRTwKenRkcX1hYDBnSHxsRW1N SDZNfUA3TGUlRmhmN3xhYytqWHZJWFRqJHQoRj4qIXQyRXA+bSV1JDtLantofSg9P3cmCnpzY0lS Ynk7OXR5TWNTcDhOTldsTEEremZFKkBuc2d2TnRRTypESCg2S3V0YkJiP1RnellvMUdkSCY+aF90 Yn0yJgp6aHN5TFBGKk8+ezFTXz9GczZAOGkkc2QkRFU0TVl5KC1FREIwfm1YQ1VPUDNIKHdyOUJw KnIlTXdmfnZvJSFLWGAKejRaO3c9UipuKX0pJUROcyg8ZS01MGV6eChUV0BgRz1WYi1SKTZ2UEp4 PFVRJVVGV2FQWEt7bWN7KVBVMFYydCFxCnp8QT1aNm8jciYhenRkblEwYClUejA+clRKPTcmMjQm I2JwQzNRKklHY1ZJNzZicy12dTBBZXNhNnteK0h0bnU/YAp6aHRVTDg3QThSNlZIQlNEMmZ6T0Jl R3AociMhezQqUn5tTT5jJCM3VEo9fm56Kl8tU2dKJShRQjMweUlWKmBabHoKeiszZzJrYzVrKChg ZzF8N1M7JnBDdl5tVC1JNChqMXlrRiEmRVQ1dShnYm9hWklLaXxeazl7QVdYQilxKGstdkQ2Cnpj JUxveEUmejQlRWx2UXxUPF9hfjNwISFgI3IkTiRWbDJHQ28oS3QlIUd6I29eWjAtQzRGREZWM1dD UnN5PTYjIQp6RjtwTDhoQD9Ndkd3PVJTMntIWWRrayoyV0ZaclB2ZzdxIV44dDRLdTJZQCopWSRZ czd7UmZ6a2Y4S3Q8NCN2RlgKenIyZl9nKDFlQTlqb0JUfWsyM0N5RlpvSHlqSjNWfCEyYUtWOypr P0YxRilgUU1kQDk5JD4oJHw+fkktQGJIP0hDCno+d3F5cm9hcTBEUlFMQHxvbkdWbDtLNTRfQmpw P1omenVGa0N1USRuZ0B2KWcxUD1BRz4reCYxMUNXSyFycmhaTQp6RnZJfUtnZkQxOVlKUllHWkwh KUFGb1Y+cy1MRF5TRUA/Ml9QU3ZsUzB6S1gxOThFTHFVO3g9c3FQZE17JTFpezMKemZgcS1CNCRm YDxmRCZVcyQze0FvN3UwRGpmYXl9QSUmQFI3c0I7SG5FM3E8OzR1M20pPGJZMmJfYG1xNFlgXila CnolPk9fQkRMN0FDMSghfWd3PiMhfi1faERBcW5CXighamdjTSNxMURiPkdLcn4zOEFXPktjSVZp JE17SW5mKktfcQp6eWpud2FTXik8UmB4YjBLXmtKRXJFMSFac3tSYn08U3MxVjx5bW5zNFM7M2Jo MGh8bT9PcDNlfmZsP3dCSC07VSsKenFab3o9bVM3UiUtWiZSM3hAVXpYYnRyZ0whdGVWfC1rYFF3 OT0mST1ZMiZ3TlFOd1JjdXd0OUFiQU9YbSp9UWpoCnptJiMzbVliUzE8KHZNfjVFX0t1R0x5ITVn RWgzQnUhM3Vtbj1ZK1RLVDt2V3xKQztII0pALURBKXdBIU8mfn0yJAp6TW5mOHxDUkBLMV5oSjNy Uyp7cD9ZJGdvOWZ2UkRUaTN6bikmPVc3Mz1vKWdueVJ+bDdEI1dDdylBcVNqdHc8QXIKejhFZ09E PzEtZUFgaUh4b0cxN0MzTiNsbEptPHI3S2ZoS2gyJmdsJmdBUHArP1F0eExNTnF0ezY+P0deMk1X ZHBeCnpuK2hVbXRaRzZ3WnhUfjlKI3lBJCVCOEVGLX0yNlJZX2I5TWNUUXptbUYzd35hVUZWRlg5 ODUpeSs/QFZfNlh0NAp6IWZhclJeejFnaChQMTlLdlR9KShiP3JITjNsRUlQQEwyVUNjMUkkX3Zq ekI3Q1pQQ0M8ZDsyLWU2QigkRntQX3oKek9yZT54cF9EQ2YmY007fmBXfFlBX3NGR2olXy1lb3o/ ZCN+JkU4Ymt4ITZRZGB4SXBVWDt6eFE+YHJwKzImI1lSCnomUUE1ME0jdCgrNXhhXjtOOT1IN1Nx JmZBRX5JKCpnQzt0JGAtM01yQHJUMmVtSUclZCl1R0U9PylZclZqdiF3UAp6UGEjU25UfnlXaipx ZEV3VUkkd0ZoaD10SF52TD5uWj5RR05RKiswTiQxNmhNdyVeQDE0SGdraSFNdFk8Qko+dVgKejkw VF8yJXVwd3hWNFNFYGVXX0kxZ1FyejR7Zz8qV05rTU1UUnE5VWAyYGkhMj1lQEhgRWJLT19TcnhZ YDUkRiR4Cnp5VXJCe0VTKEI2SkVXbXBtOzFtdWdzbCNMKyo1cXNGWUtjfTspckM0WSVoX20mQkxv K15NY3hyamRVJUl0fiZZJgp6NmNuKGBAVDBsaT1hZGIhUkx+OXM2NiYmTmNqVWQrcVkyI1R5dj05 QXZ1VjVFI2MlPj9mXjtWWE9SSEBXN08ydEAKenw2WHNnKygjNj1wRGRfKldWdH4+ZGlNJHtAcVY5 Nz1wMSNNRHdjYnJNSGJVdD1wVHghVVZZYHU7aGxiZXZzQURkCno7PzVnNFNkT2NHZ2hBMTtpfUE0 IVc3LUd6TWlLUjYyREhQSWx6PjI7SCl3N1BAMWZeXjk5aXc8MSRIZDQ4RWAqQgp6QUI8VjUybCZM T2duKVoyaDt5VSolVzhaam1TeUlHaV9TLWwoS1FKXz1HfkteSz5HI2RvOHowcnRocEJJYCk7P28K emdNP3VQTHd+NC1mUENVXytLRkdzKzZ7VFZkenliZmF+aFNSeCghbTc2P3IoWWp1XnJvdmBeP1hR K1poK0JVYmxiCnppal5JYzIwbmc/RUZgakxJbWszVSlNTjg7SXhqSkJ1dHo2UkxAUVVsa2h8I3F3 UlNMV29qb3t3ezlKanphS0wzdQp6YDdRZnRCdEdBSHpLSyFucnYtZXVSOXgqSDxCY0M7STB4QD4t OERlR3d8cW5NamBaNGIlYikqUWxCKUZjSF59YEQKemEjPzItKlZuX3BZTj1HSCstUVN3LV9JTndr Tz8rVmpJaHBeN3RMYFJ5flYxMyhfUWEzeV92cGVBfV9YQXhGSD5QCnpQQ3BPQXVmZ01LbmpYNDlR M1YoZ1cwPCNsdiRvM0BxRFVKVTZSQ240QD00Q0Y3QTlKU21qOXY8dHZDMWZvR3RlMgp6SyV5LSRm I3Vqd2h5SjIjPHMpQStEe1Y9KmshYiQyWVJKWEh7UGJ+dGE8cnshJk4xKGVwXl5yZnpMS0RQPyVj MEEKek1nfVYlVVV1ckhSPW01JkZ1aXtoISFRLVJeX3ZBP2ReIVE1MzBYKXhQJCpNJCtMZ3FTXjRx aDt4Rz9sUW1BJFZWCnpKYm5DPShSeyU3aSElPmp1WjlPbmVzd1U2d3w4YksoeXZKNkI0IWg2ekZ+ cko4TylJSkhgNlJLaitAcT5SQT9CUgp6bVJOK0J2c3tvbD9wSHhDUyZpcGI5NUQzTkE7YGd7UE1k empOdUw5K3xNaSM5ZGRUejN8OCYhI2lhRXNrJG87bHkKejR4WWpKaGZvd15pJDV4RVdOal57RUBz cEJrRDMwbFJWdGtSVWQtKHNiYG1RNlkkQFJ+SlNiSntBb1hFLURBOC1DCnpGOUdATGJCV1ZHOVBy fjk9YzlZdE9zLVh2XlNhbmc+dHwkRFBKe0JETmVMVGA8KEJ7Sz5MdSYxTGZIR3FUSzVRbwp6Jmdx fmU0a28hXmNwJiZHb3VjWXJQPVRrUyZrVipeVmdYa3JZfV9IWFphdXVAcnpeRS0/cmJxVV9wNDV8 elVPWG0KekU1KE5PLV56cSl3fCpfbjdAJCRtPilkZjspbkRgdCFIPmxjMy1BVzFQWT5LKylyVGc9 eUF4Z182YipXI1FsflcmCnpue2BwUHAkcVdxVDdTbjx3MVJNYThSRzA8dGpAaUc0RllhUEJTX0NX dExsa0FiV05xOzM2R302JHxMeE9EMjY4VQp6bSRkcVZwQnpwMnJfMT9yOGhLbXZ7bEhkVndEV0NI WHZTa05HTC0rcEJXfT8ybSZkaHxxVGVePGkhIXklOFEqZjUKektnQFcpbjJefVlHcSpZPUp2dF9B PnhNRD4pNGdlcGBFK3NUOFhnZGRyRSNnI1Z3UUB0cEomJj0qVjhlVnE8NkokCnpBNnR5YDN6JDwo Rm00VDBsRDBvPWVYOGJ1PGNyfkE5dV96KD9pb1pyK2FOZmJhS1hsTiRJbTFLeEk2T24/ZFErbAp6 QnBMcjBLRDZ+b1Y7ezgmKTUtUGgqZVVzUGxMMH1HKz9tUjBlTH00PSo0ZkYhQmItJkJMZXlERXNh S0h4RnNYKyEKenEzJTxPQG0/WXt7di11VEp4eUArZExuQVZ0aUVTVkxBcC0mZ0hES1Q/Y3lOI2x+ LWpUV1YmcCYzcHI+I3BqY2h2CnpRWSRVIXwxazdZU2cwUXAmLXFvd0tzTkdiM3x9ZFhTbyY0aXI2 SE5WTFI1KUghd2pyZzJtTV5VWipYKDV3azFMMgp6a1JuUU5MUC0lK0Z5fVVgWFc7Sn1mdTVNV3Jk bldBXlItMWdgPUdobnRQPStRSXhZIzZzMyt0MnAjWWUwcmJLQGMKenAmWHlVMnIpKDI9RWhLZzh6 WFU1SUtDYzAhfSpVZ1JleyRiZjw7UzVodnspOW5GaSY2NEcxKVdLREc0TjxGMmdDCnp7Rnt7JihP RHVtYjMwU0lrRiVIKFEwfjR7M2VwYiMxQC1tZjUzPypgTUQqQ1NCUUwjX2BTTyR0WnFufUtNQl5O WAp6TiZ9UExZJkphYkpoa3glcFJQJl97YHZyakFLT3UzTDkqVko0RCYwciM1OWR1bl9nWTVHOFZF OGcmeyl6JlAtK0YKemNXbCkmcWY/d0xmXiNEb1dVPil5TFdsNUdleUxOJDlSVl5DZzZ1QyNBeSsy YWwlQUl1LXFVJFlaKT14XiZ3fCh+CnorO3wmI0VqRU9xI2xUeHQyR1NqZih4THFrRWgxSWI5cS1Y Wio5UnA/OH1TSGhPfnhHPCZlans5RX4/QVZENXA4fAp6MU0hfiN3M25EeXYraHxYbmJpS3MlRyFO Rm4hWXdmdVNtTHsjM18hO195bC1XeXdqWT5icztNJip3QUh6JjdWbUIKemIzfXotM0JVJCNmek0+ YksjUEBtYVNaJjZmOVhNe3dTPUJ4b3NQaDFJZTJ3R1pLYWlpVkAofVc8STU9amU2QFh2Cno2WThg dXVOeXwxanVfaFBMRlFSOWRuNn5vek5fZDd2MzBJSDtyUTtwJVQ5dS09RVlLJSNZaH1wJHNLNiZm Jk1xOwp6NjJ0N0BCLVBDYzxVXylHcmQ1M0VvTDNELW51SkVMXlFaM0w7WndeVm4lPUdzQD5xJT0r TWBkY2x4WGpNPDNhSWMKejxySGctYE9sVWdhQVZOaylrKUtfJWtzfHkqV21YR1dLKWpISGgoSWtw UHRHIyp3PzFheVZYYnRDNVMhYjZUV0x3CnpjfUomdnVjezlIUmpoN2todGBgISYoZ1o5R3RBayZf TGA1T15kblgtdmojS3M9e3hVQnAqRilFaWBUeyU0UiMmcAp6cnAtZDlAKHFTSytzbkVpaiVxej45 bnE+dCtFZCRTWGk9JVBQKUdnbW5Ve3hGNUVaZEFATncoR0ZSdGlOJlFeRlAKenEwTi1RRnNBcG9C Mn15ZHZxaCVGRilXKlY+KURINXRAPEdeVCVrTHZtOCpLcV5peCFLaUI1NHVQIX1ZOSRfeD9WCnpK cUU3aC0oKkBEdzE+dWJ7cytuTzszcihQaXRCWHJyYUdgc01+UmdnR3kmIX41KWNSQ0VsXyQ4M35p ZlJgVkRzeAp6d3BsXnN8SD4yaU9QO1RiRGktfDF1NExEcFdDcnN+ZFVWWEVXbVh0MW10JjdlVkVv WVhkZz1hOCNCfVI9R2d7ekkKenJ2KiMlMGZmNz90WVh5emlkOTlqeThiSWl5Xk9iNHpQfDB+c0VP VXExfVlYTT4ke1pqNio5aWQmJlRqY3RpYGUxCnpFR2V4O3EjeWc2bDQ3Um5QYDZyblYwYCYtKHgo eHNpKm4+cCF1NXs/ekw5Mk95PVZTWiVOKW09SmZ0Uz56UTVjRAp6c2hDZHt4JDtmXm82KFZzR0RT MDlsVztHOEtPeDBRZSZ+UnR8TTEkZzM4VDlDSWQ8YzVOITFFeChsJk5YJkJvaD8KekV2cDBQTzQz d3dIeEp5TUg7SjNLUDA1Z2FQQz1lZGAlWlV0S0hLdnxYbkI/MWNGYmhkKWVzKzNjNFN6UEBibmlv CnplYkl0T25eKTMpe2Q4djhvTDFLIT1YV3c5bUglYz48LVl8b15XdURxYU9hfU9VUkBjQUB1dFR2 ZCFJZT9vISM5MQp6TileaFhscEAtJSp2WUF7cG14dGE+MVUwPHY5LVduOEhCWjYzaWxoazBGWksy c0dXYkJCX1JSfT9YWiFkNWYjI2YKem5UbHxtQSk5ekV0JFpGdDBRISVSVTFIR2UxJFQpOTx5d25K emxmTEx5I0tldk9YdEx4eDBNdlp0ciVlM0B9e1BqCnorUXB8Jitkdlp2SlY+fX07PGRmbnMyKCFQ YzUpVnswSEs4T0wwQ19jNnZpOFhlMXg+Nm9hdG4xS0JKfGk2TzxgWQp6bEx3WC1PQzhid054YWsr Vk5aU1d4ZlV+RT1BckpTWXxZRXliaT9eSDczSXMkS2JaTXB5TT9eZkVjTkMyKjxKZTgKenNxe1dN e1IjJG9IfiokIU8xbHR3amY4ZHtZcDBlPUpYKHdsRi0rY3xAKVg0cDk5NTkhZkE3ZjM/N2NwPExE KilMCnohdTZXJGA5IyR8IUd0eU5NbyRCbSEoYjdRWFpLZlljY0k1aGFoVVdWZzdaNkpuLTRlZDl+ dks0PTxnMVlMfSYxPwp6JClNckdHanozNyV8XkJmM3g5UEtJMENRaXRWbEFiam12VEgqRHtYNFhX e1FueUtmWThSck4zTytSKlEkYlU1dzAKejxobyR7KGJkUzQ1JkxsWFIhO2BYJStJNkxxKUdDbTFv Q3ZYZSheJnhJIXdnKTlxQGQ2RWpheUFpaVJYXzF3UmpaCnppXldaPGBzPEIjO3htPm97Nz5AWmp7 QVBDdTh5RWtTSkAmJGd5RkRhYm5qYiVAVCFeZldadCNPM0xya3VhMDhpZAp6KH43fXokTyhvVnhx NXAxQiMhWkR1WDdxR2RPVz9VKl9eajUqOFN3WHI5PjRDSzs1VmhgOU5pKyEqS3x6OCZDa20KelYo MUNLOEZoNFBOZD5qNUQkYSUjTSM8IyZJV0gtPzViTGkmbmJ1REYhM3RzeDZ3JitNWXVEYXx5dnpL WFJyWHZCCnpLZTx7fFFJSWxDPH5gZzlCaiVDWFooYy1Ic1BiISQ3dDRqZzdaS00jbT5+ajxHSnw2 Z3VRd0NEO2ptZFZNbyFFTwp6cXEtTSs5aSQoVHhHc1AhdGFTVSRjeXgxdVROX0owUGt6dmtsQ0Y7 WTB9ezgxO2BPbFIoazZhclB7OXNqSSReZCsKenJoVCk0TiRzI0BaT3RmbmpoXk95V3g8fUVwQytX fT12NGBDO1dZVSlNR2h3RVd1I3J9Q3hVaTxPcmk8VTl+SjNsCnpNOH0/TUoweWZDZXdiX2Rldj5a clBTb1JUMGZxfkFvSFh4Zk11bzxzdFBMLVk5fEBrd3N5eiR8NjI4MncwSGBPTgp6O2RfRS1NZktg QG1EPz1RcWhpZUNKVkZXJXlfNTlVKVZ8ZjlQQXp5YF5ReDdrZX1XX2ZkMWdXXiFrfngwOEdAQzIK emspeS1Bd1oqRzJyJDAjNDQoTkxyTnJRSDklQns2Uj0rI3ZwIzNKV1BBVmAtZSpsek9RO0ohZShB ZElFRlAqdUhRCnpacXhra0ojZSY4Zzs9Nng4byNpYVFMNl5oVjFrKS1tfHNNQTxtWDtzRTx6OHRz YHZiQTMtOWV1bX13LVAtZnlEbwp6SnMjeFE5SkRZK3VPYlo7KCpgQD93azxwQD1YS0lzbVpBMEwm LVErSlhiMUE2ZW5ERHBHUDJKe0FyPUs7VlAyV0cKemZRSHg3ZDw2d3NPQGFMQWc9YS1JRSslTmNW cWRzO084OWlhZFJuazQ5MClWOz84Vl80cWxneVZGcWtINitYNEBxCnoyNEU9NT0rbFZPdXNeMSlD aUBGenVjekpOR21VOTlsXmklKUBXSFNKVlVeZGp4em5fQyU7YnBhREN3QE48cmo8dwp6Tms5VkhU eDJGRTB8eStaUl9+e2hkSldzVFYwaVUhLXJKMHFNcyN3PCl6QE9sSCYyXllQU0heKFBfcmlhcz1F LSEKejwrRmJqWX5RZGMwMXBFWjBmNWYqZ1BoN2BPaCZ0fT9pWE9+KT1pTDFWeylpaE9efSpFX1RR OTN3YSU0Z0JsVVVRCnpHazhONHsrQ2p5SzFuKzE2IW5IeS0oTitAKFBtQWFjenNBcUZMJGord3Ul OWYkaCowQHU2d2klO2RgWENsNnJEKgp6Y3U/ZSE4bVo/SHF6OTZvKDFJXjZ5QjV1VGJ2b3cpMW8/ ZmxZT15XZEMleGo+d15NYDlNPGspX1JqV0drMjFtKGoKejs7RGZPZU1fYSlTP35CZz09Kk59VClu KiN2VChhRT8wPn19TTVIdFNDQWkra2JnUUg3Wkw2YEU2UXtjYEZhQHkrCnp4WUl+VVUlfDhVYjl0 bjIreUBrLU4leFc1PDhmJk8xTThNQGJeZUxyI0x9MVFBNFhzUDQpXkcyMGhzYytjKFIjSQp6Uno4 bjYjbSM5UWJedXdWNGtscXBnSHVWPGdpMnpqe1hVVSsjQWtXYUJiSEQ+TFZ5QkwlN3lpWWtSdkBX LU82WkQKenM3clVAIyY3YENIVi1QMTxuSX5VPX0mT3p4diszRnQlNFNjYit9UDU+ZWRPZkhtckt4 KFkwdHVxdjVsQS0/YTJqCnpVZ0hVKXokUWJ7KENmeCooYG50ZnpNV2QoIzlWPnE0fmF+eDRHcClA R09tLWU8ekVXPXQkPyhLPDk0X2ZTKmszNwp6aWNLQWg+Un1UVl53UVoxUmpjdm57WCl2SHoxSV5q N3E9VzBgU0NXLV4zTyomcTItcVcxIyFYLVk1cDBQPXU/SkYKendqMT51PWY2Z30pUnNqLTtFT3Z0 c2tYPlkkYyhtRXJiPmkmYHZfdXV3PzRwSXV3PkNveHpAQjwxWlh3cEJILVl3Cno9JGFkdUNXJTxn eXxoKmRjNUYxQUY4YCN6VVNnYlFPbmlUOykodkl0cyhoMzljeDd9VHJNOCl3IyFAO1UwaVhUbQp6 czhJalhpYjFXUU9IR3k+NH1ZRUJ3TjxmKGpLSVVtbkc7aWJud2d4c3NWRFZ7ZjcwMnxhX1U9IVNa cHFGZVlQVnQKejZ3JE59Oz0tUzVRTkJTLWVZVHFWODB8VVpFITAzTnQ4Pmc1bmlGWDVVJEw5TExk PlF1eWpFcX0/Q21AOTIlTUNACnpBejYlV0NGQHdeeWt4VWw5R1NnezhEM0ZXeUVpUGxBbXMqMnJI OVZFUlBIQ2xFUjNZK2JlYlgyZFowNjBWKjt7Ugp6RU1KSFdzYWdFWjghWW9HITlMZCpXPk9ifXlN My1MVDlyKEteR2s7MzQpfkFyYmhCWGlnLXpoelBKZ0c5bWhDakAKeitKSDhHQEVXfTBeOyk2Xj5H d1VDQV9GclJXXn08NTwtSG8tZVFtWEo5YTg2JXNPVmhHcy1FWCZWQGl9X0ltZUlkCnpqOyh8c0wh eDQrR0N5LWsrXyNsbDc/NTVOe1pXeW4qMGRBMyhxYD4/JksmJDxgajxJNGEwR2lmbU5qPFA/STY2 Kgp6ckRjdkM0aldmVjVNRHxpXyZEeFhkfTFkRFltZ0czN3wqYSlqUHlIem5sPDw+dGBPRE0mbiFL IU9xVldzXkZ9NEwKelFqOXJsaFJLeipFeEg/ZndNdlkrezcwNXsjcXpNN257I1NuU0lJK3BGVktF cHZsSUUlI1pjYTU9Z2tVPT1xV0RkCnphIz88Zjh3YVkkTFc9ZDZkMiktKTtMfTtYaU5pUXMoMD0t OFIyMTY0dGplPXJOJGl+NDBYWDxJUTFuZ1luc3wxRQp6e0lAQk9KYGYhLUROUWVBNUh1N2ByPHR4 QmctO1FZdXUyVEhgOEpzUXV2dyV2dDV4QmlzZUFCYjE5MTY+dmY+QTgKeiR2RW1gM30mTG40TEkp cHJMXyhHYj1nR3QyZTdQclFLRHQ7akNqWmUzLVVAX1hPbikxLTBMQz9ocDU9I1N6UnNFCnpgQk4+ IyNfSXJKPmJQdUdUI3t2TiZ1S1JVVV5wYjVnPiVFRzVWQG9Bc2kxYTUpYWNzVVA1KDx1QD0td0FD fT1VbAp6Q3UjUnZKd2Q7MztVdUIqcEBzcDhtJTh6VVJXRUlSTihRSig/fUw0KW5tM1lsWkh1fGV6 Rnorb1Bfa3VtcHpATmAKenJNZjR0RUIpJFVidSRSRDIlMEQ3Ql88ZCllWWx8bXFVa2EjOStuI1RU RmAkQShqRGE7VHdgQmxeKDBFTlA+K24mCnp7XlJvRkZAeVF6YTxtJjg8NTBVVmlWeXRPNCFZPXwm Qkt8clltaSN6cSReaG50bkgpZl8/U3dVZUxTc3FybzNRcgp6UXJ6NzBEQTYxaFYoOXxzdWVGXnA0 fjRZP1RSLTFvejchbj5yckpIYkEjNWQ9cW1IP1QyajF5c3RicT5vc2Excz0KejNUYTVgPkhRZGZw NE9tKkF3X3xpcVZDUllSbzxVSElwZSE3e1klMTB7IUdfO1FkNzs7eyRMMCE5QlkyOTdWS35hCnpV bSZ+QCNPPmR4c0tYKjlFMFJEcjY4bDlLVj59OG44ZjBVNVVZI0NzXnlzYElyTTUqa1ZvOFVxRzxK cHYxJktMUwp6PnRjMnxKfD1ERFZKV2R1TmZDZXNCYHsoZS1NKWx6dHhwfmp7ZExBfDZ0Xn1wKUlw WWA1cjNDamQ+UiomMDxUQz4Kekh2TVdUcmExRzIjO0hheXZETWtWNHZOKUAmKV5kT0pTTmhWWXVY bWA5U2xaOWY0UGw3T3JAfCk+TkMjVUh5eX5mCnphT2teU2NXbjxxe2grRj1EanVfPz83PklHYnRJ NDlVaz1PPE9iNHVHbUI3V1NuZjtvWUYzNkglUXopMzZrT2swbQp6SWtVQ3k5OU1HeGhSdTVlIzch REFVcn5vLXNALWJRP15feSReMzQyJEtiZkl2Mz5QYWkmdHtVZy1gQ3VybipQYEUKenlVKzVrJT1x RE5uWHoyZSRANTdsVzVaI0VneEJlYm5AWGkqMkNDUG91Z0k8TyQ9XmEzcmg0XzU9KU1mJlZffmNH Cno7RXpGZ2p8fG1xQzNHbTEmUy10fCFLa2A0IXp6eDM8bXcyJnZJWmJgaVdTMyE5dW8pT3VsS0l6 WHgmYzdBPXkoTQp6cDdJMyE7X0ltcVc+VFZWUTJvIVRiTWxiO2A2aXp5SFN9e0B2O05ecTZjekEp ZShiJnM9OEYrVkQmU25pbEdYRzIKelFuMH4taypybTlDIT44NUdpQkhKPCh4ZUtjQ0RybnFTTW5a bVNDRCtva3BxNkBsJmYpTTVeKjVyKyg2dXRXRFQ/CnpAaH12Sj5ldXt0Klg+JiQ4QjVReC1LRERF TCsxd2ZCQ149ZSlRP2RGSkJGQnQjVEdMPHBATXE8dmZNSGRTRT9XbAp6MihBVkBZKis5OWhINTxW Pko9MGh4QnErVEtjblQ9emVkWnk8OEhhREAxVWpgYCFmRnZmd2ZpdWNEJTNUb3Bhe04KelpeP3cj TT1EbiRWeWMlTHI7fT1VOXNSYDMxV2xhKGtsKFVwZW91cz55OzFiJVJgO3Z3RV9XP0YyPUFNTms5 JUIkCnpvVTFySlFhfiUwPG9DUzluQClZe2Z9dEc2Ul5DT3szJEBAYDtzcX19dyZTSVcyTndoPHpy fSZFLXpWYjZsXjQzZgp6cCk5ezlnbS1ZMmNLPy0hRiZfK0ZTcXtQTCErZ3lJQWYhc3dmQXxsNUVm Q1pZbSl0Tig+bns0cUxWZTEpMXl6X3oKejtIX2MkLXUxOEF4ZF5FfHZDOHdTeWU+bV44NEVGaykt JnlLKUAybmJhKT9YRiFxP0Y1djdvQl9WRmFgNi12bkVaCno+ZWRSQDN5VDdJJCQ8eTtUbmQxayVe IURnMU9yaCtlO1N7RntMOC1eOUpQa0xHJVlxYDNOYmA0aDV8WEo5MW4rSQp6Kyt7flU3KHkzaFo7 emRvR3ljRSEmT0lLZ3tFZyM4JWExT3NzOTIwUG0yIzs+djE/Kz01RiorayhXc0V5VV5rWmAKekhQ Zl83c0NCNmptRUBMVE9vVEdidXEjYjklS2JXUyNoN05zQWRHMmxXeypwb2V9NGJ8VWNYKkRmMWRM Py0qYjdzCno9WHQpTEBBR30xPU99b0JJK1QtdGgxeyprTmMzfmpHWmJlJDdMUWspITVvYllQTmtn Nns2blNjOyVZaElFLXFNbwp6cmNqRSFWKTEwUEZOJFJFc3tZa01EO1Q7M3FoWEUjP2g4NU52b2dV OStQeFhEO09pYUUtK2YoRTA2SXEqU1VRaFEKenglbzlJNDd5ekoxR0xfamR3QkNvYF4jSGptZkVA allXanVtU2JQYUAwaj0tZV99PSU2NEh3UH4rNWxZVSpyczBqCno2PHNSdDAwbmkoREg5WiZDUT40 V0U/QkhPaj5MZDRHTCE1KD9eXiVwbzAmJXFPQG9CS0BiNFV7KXRGMCpzNj9fcAp6NHN2UEpyOCo0 JXk0cnE9PTdDRTNKdnpheUNzamY0YShjN3p0LXlPO2xRaVI3cyh9d3coPHpGRVllfEowPWpYUkcK em82SSlCakV5P1Q7T0lNPHRUeUkkWm1rY3dTWDQ0WHlIaDxzNjhLSyokKlB7UjYhNCtDJT11aHIy dkVVZ1ByJmtvCnptOXx9cFVvOXFTQTdPekh0e1lXbndBaX5teT0zQjJVPioyTyVCU2w8VzNLente MHl9fGEmRXM5UWs2eGxBITEyRwp6RDUtZXBMRiQ4ez9NN1VXTnVqK09tZSNJKWl7aHFWKCZtUlJv akc0ZWpuQktkMWozemM/dXw7VUI2NUlscyt8NEUKekFCclB1LXg9dU9TYCpfP2NeYTlBQ2IhVGwm aDFyJUB8JH04bmtfRWQodXl8Qkw4KTQobkpvODZ7UnZEOXkyQCM1CnpKRktNbHRUYjZpVj1hJjNh QXlTdiRJfXdvYzJDWn4rIT1oa3p9MnArRnBTJXFwUCM7O0M2NHlOUlJMJW1zcl5EVwp6PmVFWjJg RF88ZEdAVHZORjZOPSNtQEYyWk1IJmlpWW4pTW1eSyF9aio9QyMjMlZteXs8N2hHTG5JblJOMktl dnIKel95RDJ6UU97OVc5a2pXRT9NNio+SSZ0RT9PViZJO3U3LSQ9X2JHVWgjeEBUfSlTKEUkaVRa e1c5YXViPUkhNEBlCnpePFhieDt6d1NwNU9tKCE8eHNVZDBARVVzajV5QXVfeGlgSk1mTUFBLXJR QGszc1d5MlFWVzZLeGwjT15CWFBfaQp6dSZ1VCt0VyVnezlTQVF3cC1uKUx6QEpqYExJfEQmPTI/ eCh2Zj0hd3drQFpHSWwyVmxINGZoP3MyeHt8Y2ElSFUKemQrQmpENXxjP2NZXn4lOXQwI2B5PSQt cnA5ZUVlZyVWPVZfd0hGPCVuZzk/dFp8O3BSWCojOSptT2tDeF9zcTV0Cnp4ZXNSMTt6OXYmQW9Z Rit5aVQ4PmBKVygpPStmYHo5MkFpM0hxVEdNTil1eUJqKkhUP3FYZl80KFRzPWIrRXc7ZAp6Z0Yj TisyaGVhQWdQXmVfJm51UHZWRVNaZ2BSZlZKTzY7eUhwcH1uKWNFMEhpPDg8eXd6MDw3QVNWRD43 TXllN0YKenFzeGNzWGVJK1U2cXskfnZFKHlBdClFd2BsRHAjQSk3bWs8P2VIdig0YGIqSjd5OWEw Nzl1dVU1STNfd2pJb05iCno5eys/QHNwajk5bm4kVzdJMlJpal4+PCheKCt4Qk8yRF9APCFwWUBO e1czeik8MSsqaUwjMXlwbFFmUXtWU0BRSAp6OFZaeHdmdXpiaFp8UGRTYHpWLUgjPWZRUm5LOStj KlklfFdjOzFYJWJ3KEM1c3Rtb0szUXZVYGQ/TjBFVDlAQVUKej0mNGRuWipDPXJ4YSswdyQ5bWFe em9aUUgjWHlfYzJYPj9maUlvfGwkZiUjRCQ1d31OVnF3fkB4aW9GS1lpPj0qCnpUez4tRDxUY19K bllxVEVOQkJeSVZnVEtufEtYV08xbHBlWDJmTEBaP3p4JHRFdFkrQ0V9eDc9UHo/QlVYKXl9Rgp6 Wlk3X0QwYENjckRjRzx+e2FfI30qVDtwUTdYaUh8LUUzMkMhPEQ0YXo2YT0kTnFzNHZrKU1pIzs0 dTRYUnhhVkMKemBsWEt2eGBhe2gjTDZlODE7dW8/REJkeEBMTT92I3E0VF81YDBOJW1US0VpKFZo O2FDezUwLVZpfkU4MWBLKmE0Cnp1Qit4YE5wJEMpJUJJcSg9eyshcTJDfnx+d0R2PmBqb1k3LV5w PDNgQUJCVWhNfUlPS0srbTh4MHd7ZXJDemMjbgp6SHsxKFJPJHhAbSFwZGRDbm4jY35gcHUqQmhX Rkx3Yyh2alNzdWYrblB9UTs8dF4tciprUSVqZitmMysmR2xOdmsKeiROZjkzb1ZVaXokTXdIcHRI JnRDUVU+VUlpYjZzOEJaWUN7UXo5IVBXVllndTUmaj8qaEhtK0F1K2N8TldOfDVpCnokKk13OVc7 P1N7N1F8NjFsOXs4ZV4kTypZWSRnZ010aFdhV3gtbmV5UUE7NyY/aThxOElobWJ3MW51TGRYRily OQp6IU97MyN3KCslZ1FWa1ZxVGgzU317aylOeG5XZj5jdj5jeXtAUjhVcUM8SlNBSSRlaG8mNUop U2IwTnFwJkoqbTYKekV5QXtaRDB1Rnd8RntqMl81QkMlTXJkRUAmRj9IP2g5WjNucUkhLT5QcWUp O3VnT0Y+JGs1PmV2dFNSZ0hTWCFpCnopWjBvOGpAK0RuYStjeiNKRSpqMWJ7REBoITtvVUxKWC1B N2k8eSMxOWB7Nkthbz4tanFGIXQxbShkajRXVmsrSAp6S1N+ZG9aNj0pe240NjFsbzsyUU5sTkU4 RiorbVZsalR5OEheeT8xIyh8Ni01bnRodDdLUE11UWN5WGRoMGYlc1cKekx5Sng4Z0ZhLWhKRiM5 RVBaQ1pNJVJlYDBVM0l3PyF1K293cGVYJlVGViZgUT1pXmU/dE8peVhVJTtCQmslKj9GCnpXYmR4 dj9kRHlVQG1IQDQhS0JLSkl0WX4yYSFzWjdSTEAqQzRHc2k9MHxteHplen4zWSVyUWRxUlpiZ3pU VkRLVgp6OygzTiElNWEoVV41YlJQd3RPJTg8elVnZDxOdGBGMShCMkI0Nkk2VE4+VUdBMGtBIV5U YGd+IUZrOWI+U1pAMTIKekpyRU0zYmpJNGN2RXRgN2Mtc057TjQqbXxuMStVaWxuRilBUE01KGV7 WlV7KCV4ZERtJV9UTVMmX05jV1ghKyh2Cno7PXRqaEIqTE9iMDAyRENFMmBmaC16R3I+ZnZRYFVm TUFuUW1KKDJQIUopclpQKnZpezU9VU5LcjtgeHBPWTtTWgp6QlFJKkhlPFFSbmlHfX5oU1hlSX1M VFVCXmVebWdqNXJ+NkFLdTxaUm5RRjRLdylKN1VmV1ZWcEJgZEU0dksmQFgKejAlZk5JKWQzY183 SXNAJVVZN21ZP2QhSElTWHoySStGYj9vUGFgR0NOeHByWHhHTS1OcUA/NjQ3WEE/Kz4yOFMmCnVO V3l8NyUxSSk+V0hnaXY/aD9XQ3wxQVBCKChhQXBRIzxTKF44c3h1YjtSMjdhNEY+VW1BP1Z3Ty0m VTUKCmxpdGVyYWwgMApIY21WP2QwMDAwMQoKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVz dC9iYXNpYy9ib3JkZXItaW1hZ2UtMDEtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvbXl0ZXN0 L2Jhc2ljL2JvcmRlci1pbWFnZS0wMS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMzc5MjdhYWQ4 NDc3N2FiODMxYTVlM2Y0NWE2YmIyMTNmNzQ3YmMzMQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL215dGVzdC9iYXNpYy9ib3JkZXItaW1hZ2UtMDEtZXhwZWN0ZWQudHh0CkBAIC0wLDAg KzEsMTcgQEAKK2xheWVyIGF0ICgwLDApIHNpemUgODAweDYwMAorICBSZW5kZXJWaWV3IGF0ICgw LDApIHNpemUgODAweDYwMAorbGF5ZXIgYXQgKDAsMCkgc2l6ZSA4MDB4NjAwCisgIFJlbmRlckJs b2NrIHtIVE1MfSBhdCAoMCwwKSBzaXplIDgwMHg2MDAKKyAgICBSZW5kZXJCb2R5IHtCT0RZfSBh dCAoOCw4KSBzaXplIDc4NHg1ODQKKyAgICAgIFJlbmRlckJsb2NrIHtESVZ9IGF0ICgxMCwxMCkg c2l6ZSAxMjZ4MTI2IFtib3JkZXI6ICgyMXB4IG5vbmUgIzAwMDAwMCkgKDMwcHggbm9uZSAjMDAw MDAwKSAoMjFweCBub25lICMwMDAwMDApXQorICAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgx NDYsMTMyKSBzaXplIDR4MTgKKyAgICAgICAgdGV4dCBydW4gYXQgKDE0NiwxMzIpIHdpZHRoIDQ6 ICIgIgorICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQgKDE2MCwxMCkgc2l6ZSAxMjZ4MTI2IFti b3JkZXI6ICgyMXB4IG5vbmUgIzAwMDAwMCkgKDMwcHggbm9uZSAjMDAwMDAwKSAoMjFweCBub25l ICMwMDAwMDApXQorICAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgyOTYsMTMyKSBzaXplIDR4 MTgKKyAgICAgICAgdGV4dCBydW4gYXQgKDI5NiwxMzIpIHdpZHRoIDQ6ICIgIgorICAgICAgUmVu ZGVyQlIge0JSfSBhdCAoMCwwKSBzaXplIDB4MAorICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQg KDEwLDE2MCkgc2l6ZSAxMjZ4MTI2IFtib3JkZXI6ICgyMXB4IG5vbmUgIzAwMDAwMCkgKDMwcHgg bm9uZSAjMDAwMDAwKSAoMjFweCBub25lICMwMDAwMDApXQorICAgICAgUmVuZGVyVGV4dCB7I3Rl eHR9IGF0ICgxNDYsMjgyKSBzaXplIDR4MTgKKyAgICAgICAgdGV4dCBydW4gYXQgKDE0NiwyODIp IHdpZHRoIDQ6ICIgIgorICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQgKDE2MCwxNjApIHNpemUg MTI2eDEyNiBbYm9yZGVyOiAoMjFweCBub25lICMwMDAwMDApICgzMHB4IG5vbmUgIzAwMDAwMCkg KDIxcHggbm9uZSAjMDAwMDAwKV0KKyAgICAgIFJlbmRlclRleHQgeyN0ZXh0fSBhdCAoMCwwKSBz aXplIDB4MApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L2Jhc2ljL2JvcmRlci1pbWFn ZS0wMS5odG1sIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2Jhc2ljL2JvcmRlci1pbWFnZS0wMS5odG1s Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLmZmZDhjMWY5NjcxODk5MGQ2NDdkZjMxNTYyMGJhODdjMTQyMjQxMDYKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9teXRlc3QvYmFzaWMvYm9yZGVyLWltYWdlLTAx Lmh0bWwKQEAgLTAsMCArMSwzNiBAQAorPGh0bWw+Cis8aGVhZD4KKyAgICA8c3R5bGU+CisgICAg ICAgIGRpdiB7CisgICAgICAgICAgICBib3JkZXItd2lkdGg6IDIxcHggMzBweCAzMHB4IDIxcHg7 CisgICAgICAgICAgICB3aWR0aDogNzVweDsKKyAgICAgICAgICAgIGhlaWdodDogNzVweDsKKyAg ICAgICAgICAgIG1hcmdpbjogMTBweDsKKyAgICAgICAgICAgIGRpc3BsYXk6IGlubGluZS1ibG9j azsKKyAgICAgICAgfQorCisgICAgICAgIGRpdi5yciB7CisgICAgICAgICAgICAtd2Via2l0LWJv cmRlci1pbWFnZTogdXJsKCJyZXNvdXJjZXMvYm9yZGVyLWltYWdlLnBuZyIpIDIxIDMwIDMwIDIx IHJlcGVhdCByZXBlYXQ7CisgICAgICAgIH0KKworICAgICAgICBkaXYucnMgeworICAgICAgICAg ICAgLXdlYmtpdC1ib3JkZXItaW1hZ2U6IHVybCgicmVzb3VyY2VzL2JvcmRlci1pbWFnZS5wbmci KSAyMSAzMCAzMCAyMSByZXBlYXQgc3RyZXRjaDsKKyAgICAgICAgfQorCisgICAgICAgIGRpdi5z ciB7CisgICAgICAgICAgICAtd2Via2l0LWJvcmRlci1pbWFnZTogdXJsKCJyZXNvdXJjZXMvYm9y ZGVyLWltYWdlLnBuZyIpIDIxIDMwIDMwIDIxIHN0cmV0Y2ggcmVwZWF0OworICAgICAgICB9CisK KyAgICAgICAgZGl2LnNzIHsKKyAgICAgICAgICAgIC13ZWJraXQtYm9yZGVyLWltYWdlOiB1cmwo InJlc291cmNlcy9ib3JkZXItaW1hZ2UucG5nIikgMjEgMzAgMzAgMjEgc3RyZXRjaCBzdHJldGNo OworICAgICAgICB9CisgICAgPC9zdHlsZT4KKzwvaGVhZD4KKzxib2R5PgorICAgIDxkaXYgY2xh c3M9InJyIj48L2Rpdj4KKyAgICA8ZGl2IGNsYXNzPSJycyI+PC9kaXY+CisgICAgPGJyPgorICAg IDxkaXYgY2xhc3M9InNyIj48L2Rpdj4KKyAgICA8ZGl2IGNsYXNzPSJzcyI+PC9kaXY+Cis8L2Jv ZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9teXRlc3QvYmFzaWMvcXVpcmst cGVyY2VudC1oZWlnaHQtdGFibGUtY2VsbC1leHBlY3RlZC5jaGVja3N1bSBiL0xheW91dFRlc3Rz L215dGVzdC9iYXNpYy9xdWlyay1wZXJjZW50LWhlaWdodC10YWJsZS1jZWxsLWV4cGVjdGVkLmNo ZWNrc3VtCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLmRhMDkyNWJhNmVmMDEzZjRiZTEyZmMwZWQ4NmM3ODk3MmNmODdh ZTMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9teXRlc3QvYmFzaWMvcXVpcmstcGVy Y2VudC1oZWlnaHQtdGFibGUtY2VsbC1leHBlY3RlZC5jaGVja3N1bQpAQCAtMCwwICsxIEBACis0 Mjc0YTkxYTg1ZTllM2JmNjRhOGVhY2Y3ZDUzYzQ3ZApcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZp bGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC9iYXNpYy9xdWlyay1wZXJjZW50LWhl aWdodC10YWJsZS1jZWxsLWV4cGVjdGVkLnBuZyBiL0xheW91dFRlc3RzL215dGVzdC9iYXNpYy9x dWlyay1wZXJjZW50LWhlaWdodC10YWJsZS1jZWxsLWV4cGVjdGVkLnBuZwpuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4z ZWY1NTkyZGEyZTJkNDM4MDczYzAwZDFjYTg5MzVmZjJjZDRkYzk3CkdJVCBiaW5hcnkgcGF0Y2gK bGl0ZXJhbCAxMTc5OAp6Y21lSE5ZZEJRPDkkdkU9SE9WIX4mYUZgaDZ9dyVpPDEoWChzOWRyT3A8 SzMtaDduQGlHQmI5JEJzRmM8cX49SCsKenJ6MXclQS1QTztIRmxDNldrQGNlTURFdWElczJ+SyVa S3lmZF5wZHUmLTNneC17JHFkdHA5Smw/PmolZy0jXn5ZCnpYMX1Ea3FCc0JtbDIoQGM+O1lmfTlz b2NtKyk0PF4yI0chbWVIcnYyaz9nRVVCKW5hcXwweTVlbEs+RWt4cDxfRwp6RU4zUCFHTjljMVYt d0RxRUw5bEYrKz1rdV9xNiQyMUVIKVpTKXlmUWt2WT9BciZTfXg7T241fnFxfWs0b297czcKeiVt PWJvJkN5bEVoclJSO1R5IT9xWVJsRX4ldT83c1FjRjJoYmhuVDVJJT0lVmFPa3skTklNYElTaWZ0 Nmpfc0RACnorVFdKLUByflNqVztQREVhKGxKZUV7JnJ0e1dqXz0mMytDTk1EI1I7T0VYKj9ldjZv KTdFPCN2PldlWn5UQFZzRwp6X0dkS2Y2YnZaQGgjeS1FI3U+TH5YPi1yditQailZYD4qYj8yQDhH dE5QNFR1dnR5ZWdpVGN9TCkydkg9dGtxfkIKenslcEJCY19QNXhHP1NOKiV1YHdBTHBrLUxUQmg4 VmBIdl5CMjZIe0xHSG9XTW5CX09lcWlpMHduTzNQKXQ9VylBCnp1cWE4cUhGNWJKcTB7NXpvekty PU9xOVJWQUxxTlREXnxTNipSUFV5bGQ7fSVgJCN+dXVIO0MxelIrUnhLPWZKVwp6P3c0TDNeZE0o VFRpemlHemNnMHR5ZTNiTS1BUSNnezR3bVJvT2ojWCkqPHV2QXAzaE02JHdSJjNgdDhuOEZRPmgK emRWdzc9IyNuTDN1RUlkVj1HPkpeTmZBRTt0RGt2dCZVND1idmp+Rl5DZEcmRXY+Sj1GSFUlVjs5 XnJuT0g1Mkt1CnpmNEJWPENhN15PWG1YZkomYnlJT0lAKTNNe0x9VHZpbUpTWj5hSE5gNk9rIXpM eXtjI3JgYF8+RlUjbXhCPWtGYAp6P2Y0dzZmQXZ7ViFPWH5aeDBGfEQrTHpeQGNPNHo7SjlyYDNk NTIqOyVhPitrKHkzZGdgPX5KfUZGd0swO1lPT2IKekBRbWZtO0o/YX1KfDdqPm98cVYhXnsjI1BR PlhTMCY1JW55WVZtMiRid18/X0krKGtyKTdfN1l5T3xRQlVHSH5vCnpUSyUyN2RxJnhXLWZAQ1VY dEBQVlYmWlZ9aEZBNFI7LV9kO0kkcGJPSzk9Jkl6U19jX1JwXzMmKVdneU9eP1c8Mwp6dWIyQSQ3 JShLMGJARERIQz84YSlkfjwlZGgoZ1llK0M3VlBHUnxGfVhScHR+bXRtQWNWIzhJeFhzMCklcnE9 R1UKemtLTSpmRCghdmdZNSZUdWc9QkJmKThMJnZ4Yz1ld3FuXkRYUDFoUyNEOVR4VF9EKCZeSWRD IypubXI8MEFTfCNLCnoyPTNjQU43KlBnR1NhNX5JYn1qflBHfnxyME4/P3VlUCV+T0YkMWswZiU0 VDRFKnxjN0grcjhxbmNYV3FaUnBIMgp6dTQwZ08lOU1ofmImVVFkTz8kPChQVklYO15LblMrMXl6 cVcjfi1hQjNgUG00V3BoZVZUP2EjSFM9dHk3aTw3fDwKej0+UF9GKUVaYE9veX59fWYpT240ISQw WjM8MlNMdittVF5CRWolJVE8WT1UZEdLX01CTmROSFZ4Njx8U1k3RFp4Cno0NCVpPXNuQTN3OHRV TVFseVEmYTNEOTFQYjI8OXJJM191QW90eFllMHgqPTtAaVBYNEFHPTJKdEdsfFNFNjRBLQp6QHRa ZldvV0JeLUVJV0Y4ZHV6dFYjJHJ2c2w5MF82TDI1NThaZGhNUm04SzslTjRnKzYrcDk3KUgzZlEy JVZ5Zm4KenA5Pm81cX1rejhrWk14JGI/eEYmQXQrcnd1MDQ4VUc5Zn1abXRIQTRQMjtfdUQpK0Em OVYyV1doQ1dHekhgNj00CnpuLTZAT2swKkF0Z08mMWxjQk96dV5aeHRIYnw7WilSVkN8Rm8kejYk fDUlVCZwWE5kWXA9R1BWM2JDejkweFd6Vwp6NDUpI0AqaGx7dzFEX2dUWXtMQF51aTFWSmB9fDRs KjI+XkRFWGhsNlZxcU9uOWJFPkU0YSVHVVJ0JkBYdn5JNGcKenQxZUIqUGhkQF8pWnwxSndgWXBv eF49NjxtX1g9fW88PTBlQVpRSntVYEQ0V2o3PzJOUHhXZzBpYTJDQy13ZjhlCnp5RUNXUS1NVyVL d2k9ZWB3emQyTDAhQmJOTjJBUk5iM3xoPXY4dC03dnNVaj8lSCNFN3piVSltY3QtPGZSUSRgKAp6 ZGVAJTA0YWFwd2wtbDVtJWpgPV9lfENnYzlYS0NoeE1qJkpATW0zI2JtYzhuSlp1KD5hdUQ8eVlJ KDg7TEFwUyYKemQtdmxOJGZOWUhsZmcle3g3OHd1dlZzaHJgQDQhSWFzVzBSWHI3cyoqdVkzZjJf NHZER2V8Xy1JNkAzdC1Cd0h1CnpMSiUmNTFPJT1eRVY1fVVvO1g9aWVuU3A2JkUyfHE7Kn0mTENo VFJMNkJ0YjQpSWUoe2YmXmVOZnRlb3xeVV9eQgp6PXA8ekY8XkRzVDUjLTdtOUo4eGlOKnhZRmZn X1JMa0E/PCU+dTZ+SCpRe31LYWpia29fQUFVJDh5PkIxQD8zPlQKekUxeW9sXm9HQjtmS0B7MDco ckBOUVFuTSowJFUxI2NmUl40IUx1O241RHYkcnAxbG43OHo9SnhWdDlVekEzfF9rCnoqPUQ8JFYp eWZjbiN6QDVSZUJpTFhwKVVVPjFKNTYoYV9HVGk3JUUtN3tfOFE+KnwrZk9XMF5TZkRYWi1hYW12 fAp6TmBgcD5xR1VrSHUje0R4V0xWNmVQLWo0JDBadjZ3R041RVkkJCUhLVhyaEVCTkAke2x7eSZX dDVmPHVfczIhcXEKel8qYntYaVh3K3s8QkRHJG5uPz4+U2paQU5pUTtAWXJxWCNRLVheI2RlPk0+ K2ZoeEtePWswXlhieXpeMWZrZX4kCnpXTGRab1ArfGQ5YDRpY2w8WWcxSHBAfGs3OHl+PzVEOSR5 VHFjYFZMcHFvfXg5MSVISiREQFZMakZIUV9LZUt4Vwp6VEZRaWlRKnU8ZTdtX1o9ellCeSNNVHNV O0RudHMrVHJTdDJLbm85X29+IUgwfEpjbzE5aCQ+fT9rX0NXV2ZAa08Kel9HdFprTCV2R0AyQ1R1 RmomSCQzam8mJTx1K1VLYz1wP1VBR2BuJSp4TzZ0eT05QXExNXc1aW9XSkA5aEdoRXYhCnpWWElz Q09yOG1RV0pLdWx1dVcoayF4YnhRU2wkNF5MWXU2a1V4dXI7UEAjNzxqKE98dXZkJVhTaUB+aEBR LStMSQp6NEQwe15hbytyMGZkOGxHTFo0KyhILTgjMns/aUwhdXN1WHNCY0IyVmZBbURnIUwyJWco RihHcG1fMG9gdDxqWEYKenN9aGpKSWs5NHFZWl96a01Jd0RaZktld3RKSVNKZFhtNilZYGN8QCp0 I0p+WnpnZ2xHOz8yezVPQCEhZjJ7ayg8CnpwQmttWTEzOGRtNnBwLVd5XmJKRUk8TyZ7eCgjbHZG ZCp5az5kSmt4Nkc3QjRtPjtsMVBLZUJ2QVMtJnxOY0JiIwp6NTtPX2RfNWp2NSkmVDBwQihldXpC UztKdVRQOyllNkN6fF49eXI7ZFRrQX4oayR7d343UnBgTHtEaUsjNyp2IVIKekE8ZlY0cGkzSTA7 Vlp9fjNsMDxNekxDTEhgMEB3LWR2IWM5cmJGYypZQFAxZVAkIW4oSCtUcF5FUXhkcEclI3BqCno3 RDxqV1c8a2xRbG9vOWZeX1RAJkdAPDZaej15eDt1YWFvWks7TzkpIXxje2M9KU5+I1dwMS1DZjNK Sj16WDVMbgpCal42K1AKCmxpdGVyYWwgMApIY21WP2QwMDAwMQoKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL215dGVzdC9iYXNpYy9xdWlyay1wZXJjZW50LWhlaWdodC10YWJsZS1jZWxsLWV4cGVj dGVkLnR4dCBiL0xheW91dFRlc3RzL215dGVzdC9iYXNpYy9xdWlyay1wZXJjZW50LWhlaWdodC10 YWJsZS1jZWxsLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hM2VhMDY3MzFjOWMyMjUwZjBmMWY5 NDk0MDZmNDZhNTdlYTU2NmRlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvbXl0ZXN0 L2Jhc2ljL3F1aXJrLXBlcmNlbnQtaGVpZ2h0LXRhYmxlLWNlbGwtZXhwZWN0ZWQudHh0CkBAIC0w LDAgKzEsMTcgQEAKK2xheWVyIGF0ICgwLDApIHNpemUgODAweDYwMAorICBSZW5kZXJWaWV3IGF0 ICgwLDApIHNpemUgODAweDYwMAorbGF5ZXIgYXQgKDAsMCkgc2l6ZSA4MDB4NjAwCisgIFJlbmRl ckJsb2NrIHtIVE1MfSBhdCAoMCwwKSBzaXplIDgwMHg2MDAKKyAgICBSZW5kZXJCb2R5IHtCT0RZ fSBhdCAoOCw4KSBzaXplIDc4NHg1ODQKKyAgICAgIFJlbmRlclRhYmxlIHtUQUJMRX0gYXQgKDAs MCkgc2l6ZSAxMjB4NDI2IFtib3JkZXI6ICgxcHggb3V0c2V0ICM4MDgwODApXQorICAgICAgICBS ZW5kZXJUYWJsZVNlY3Rpb24ge1RCT0RZfSBhdCAoMSwxKSBzaXplIDExOHg0MjQKKyAgICAgICAg ICBSZW5kZXJUYWJsZVJvdyB7VFJ9IGF0ICgwLDIpIHNpemUgMTE4eDQyMAorICAgICAgICAgICAg UmVuZGVyVGFibGVDZWxsIHtURH0gYXQgKDIsLTQ4KSBzaXplIDExNHg1MjAgW2JvcmRlcjogKDFw eCBpbnNldCAjODA4MDgwKV0gW3I9MCBjPTAgcnM9MSBjcz0xXQorICAgICAgICAgICAgICBSZW5k ZXJCbG9jayB7RElWfSBhdCAoMiwyKSBzaXplIDIweDEwMCBbYmdjb2xvcj0jRkZGRjAwXQorICAg ICAgICAgICAgICBSZW5kZXJUYWJsZSB7VEFCTEV9IGF0ICgyLDEwMikgc2l6ZSAxMTB4NDE2IFti b3JkZXI6ICgxcHggb3V0c2V0ICM4MDgwODApXQorICAgICAgICAgICAgICAgIFJlbmRlclRhYmxl U2VjdGlvbiB7VEJPRFl9IGF0ICgxLDEpIHNpemUgMTA4eDQxNAorICAgICAgICAgICAgICAgICAg UmVuZGVyVGFibGVSb3cge1RSfSBhdCAoMCwyKSBzaXplIDEwOHg0MTAKKyAgICAgICAgICAgICAg ICAgICAgUmVuZGVyVGFibGVDZWxsIHtURH0gYXQgKDIsNTIpIHNpemUgMTA0eDMxMCBbYm9yZGVy OiAoMXB4IGluc2V0ICM4MDgwODApXSBbcj0wIGM9MCBycz0xIGNzPTFdCisgICAgICAgICAgICAg ICAgICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQgKDIsMikgc2l6ZSAxMDB4NgorICAgICAgICAg ICAgICAgICAgICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQgKDAsMCkgc2l6ZSAxMDB4NiBbYm9y ZGVyOiAoM3B4IHNvbGlkICMwMDAwRkYpXQorICAgICAgICAgICAgICAgICAgICAgIFJlbmRlckJs b2NrIHtESVZ9IGF0ICgyLDgpIHNpemUgMTAweDMwMCBbYmdjb2xvcj0jMDA4MDAwXQpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L2Jhc2ljL3F1aXJrLXBlcmNlbnQtaGVpZ2h0LXRhYmxl LWNlbGwuaHRtbCBiL0xheW91dFRlc3RzL215dGVzdC9iYXNpYy9xdWlyay1wZXJjZW50LWhlaWdo dC10YWJsZS1jZWxsLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNTUzMDAwYTVmMjkxNDM0NTFmM2YzMDA0ODQ3 MmE4ZDc4N2JkZWVmOQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL215dGVzdC9iYXNp Yy9xdWlyay1wZXJjZW50LWhlaWdodC10YWJsZS1jZWxsLmh0bWwKQEAgLTAsMCArMSwxNyBAQAor PHRhYmxlIGJvcmRlcj0iIj4KKyAgICA8dHI+ICAgIAorICAgICAgICA8dGQgc3R5bGU9ImhlaWdo dDogMjAwcHg7Ij4KKyAgICAgICAgICAgIDxkaXYgc3R5bGU9ImhlaWdodDogMTAwcHg7IGJhY2tn cm91bmQtY29sb3I6IHllbGxvdzsgd2lkdGg6IDIwcHg7Ij48L2Rpdj4KKyAgICAgICAgICAgIDx0 YWJsZSBib3JkZXI9IiIgc3R5bGU9ImhlaWdodDogMTAwJTsiPgorICAgICAgICAgICAgICAgIDx0 cj4KKyAgICAgICAgICAgICAgICAgICAgPHRkPgorICAgICAgICAgICAgICAgICAgICAgICAgPGRp dj4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDEwMCU7 IGJvcmRlcjogc29saWQgYmx1ZTsiPjwvZGl2PgorICAgICAgICAgICAgICAgICAgICAgICAgPC9k aXY+CisgICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IHN0eWxlPSJoZWlnaHQ6IDMwMHB4OyBi YWNrZ3JvdW5kLWNvbG9yOiBncmVlbjsgd2lkdGg6IDEwMHB4OyI+PC9kaXY+CisgICAgICAgICAg ICAgICAgICAgIDwvdGQ+CisgICAgICAgICAgICAgICAgPC90cj4KKyAgICAgICAgICAgIDwvdGFi bGU+CisgICAgICAgIDwvdGQ+CisgICAgPC90cj4KKzwvdGFibGU+CmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9teXRlc3QvZ29vZC1yZWZ0ZXN0LWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRUZXN0cy9t eXRlc3QvZ29vZC1yZWZ0ZXN0LWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNTU3ZGIwM2RlOTk3 Yzg2YTRhMDI4ZTFlYmQzYTFjZWIyMjViZTIzOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRl c3RzL215dGVzdC9nb29kLXJlZnRlc3QtZXhwZWN0ZWQuaHRtbApAQCAtMCwwICsxIEBACitIZWxs byBXb3JsZApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L2dvb2QtcmVmdGVzdC5odG1s IGIvTGF5b3V0VGVzdHMvbXl0ZXN0L2dvb2QtcmVmdGVzdC5odG1sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjU1N2Ri MDNkZTk5N2M4NmE0YTAyOGUxZWJkM2ExY2ViMjI1YmUyMzgKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9teXRlc3QvZ29vZC1yZWZ0ZXN0Lmh0bWwKQEAgLTAsMCArMSBAQAorSGVsbG8g V29ybGQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC9nb29kLXJlZnRlc3QyLWV4cGVj dGVkLW1pc21hdGNoLmh0bWwgYi9MYXlvdXRUZXN0cy9teXRlc3QvZ29vZC1yZWZ0ZXN0Mi1leHBl Y3RlZC1taXNtYXRjaC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjc5ODNjYTNkOWRjZDExMjhhNjA4NTQ1ZDI0 ZTJjMGJhZmFlMWU4YjIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9teXRlc3QvZ29v ZC1yZWZ0ZXN0Mi1leHBlY3RlZC1taXNtYXRjaC5odG1sCkBAIC0wLDAgKzEgQEAKK0hlbGxvIFdv cmxkIE1NTQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L2dvb2QtcmVmdGVzdDIuaHRt bCBiL0xheW91dFRlc3RzL215dGVzdC9nb29kLXJlZnRlc3QyLmh0bWwKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNTU3 ZGIwM2RlOTk3Yzg2YTRhMDI4ZTFlYmQzYTFjZWIyMjViZTIzOAotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL215dGVzdC9nb29kLXJlZnRlc3QyLmh0bWwKQEAgLTAsMCArMSBAQAorSGVs bG8gV29ybGQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC9zaG91bGQtZmFpbC1leHBl Y3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3Nob3VsZC1mYWlsLWV4cGVjdGVkLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uOTdhOGE3OTJlMjBhM2EzYjkxZDY1MjJhNTNmZDE3NDVmOWRkYWM0NwotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL215dGVzdC9zaG91bGQtZmFpbC1leHBlY3RlZC5o dG1sCkBAIC0wLDAgKzEgQEAKK0hlbGxvIEZhaWwKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215 dGVzdC9zaG91bGQtZmFpbC5odG1sIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3Nob3VsZC1mYWlsLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZTk2NTA0N2FkN2M1Nzg2NTgyM2M3ZDk5MmIxZDA0NmVhNjZlZGY3OAot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL215dGVzdC9zaG91bGQtZmFpbC5odG1sCkBA IC0wLDAgKzEgQEAKK0hlbGxvCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9teXRlc3QvdHh0LWFu ZC1wbmctdGVzdC1leHBlY3RlZC5jaGVja3N1bSBiL0xheW91dFRlc3RzL215dGVzdC90eHQtYW5k LXBuZy10ZXN0LWV4cGVjdGVkLmNoZWNrc3VtCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmM4N2I4MGIyYWJjMzExMDZm NDRjMjU0MDEwZGIyNGM3NWU0NWUyZmMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9t eXRlc3QvdHh0LWFuZC1wbmctdGVzdC1leHBlY3RlZC5jaGVja3N1bQpAQCAtMCwwICsxIEBACitm NzRhNzcxNTg3ZjBhYzg1NzZkMmQ3MzNmYTEyNDIxYgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZp bGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC90eHQtYW5kLXBuZy10ZXN0LWV4cGVj dGVkLnBuZyBiL0xheW91dFRlc3RzL215dGVzdC90eHQtYW5kLXBuZy10ZXN0LWV4cGVjdGVkLnBu ZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi4wY2Y5MDM1ZjY2ZjdlZjllZjdlMzcxNDEzNGY5ZTNhMjMzNGVjODMyCkdJ VCBiaW5hcnkgcGF0Y2gKbGl0ZXJhbCAxMTI3NAp6Y21lSE5kcE1MPzgyYFI4amZvTFRYcUZubnFL SENUeDZ6bWslNEleaXF7JmsySGo+PExBSWkwdUF+TXlBKnYpO0cKenI0bW4qU2htUFUzfFNQYUVo NSRBWmc7eHlgRm8kSXxJVk4xSm0+ZCo9WTdCVGViME0tP0A2fGBIV3cyaWlhLXp+CnpXPGZLZkx5 ITsmZi1uZDFJS2QxJUlQU1AkRnohWDYqamk5MUItPDFJTjQ8UEtBdCkzK1pRdCYqJlF4a3FrNkhB Vwp6QkhyMCZPPVQhYyhaWj9aQytjSXAxeGFAd0xmQHR1RCQ4U3NNS0BEI2JYPXZuRmxsN3lrQF43 ak9gaDwtJGowIXUKejlAe0tXSjV5QiROPnR0UldIY3QqbjBzcHFVdm5RdXphUTgrNSM9OHwyI0tC TyhCVUs0NXdUYF56TkQ5TDxaa2N6CnpCcSVMXndXKkc+TCpKT1M2MyNSfWEzPG5xUHE9dWppe3Jo QnhzYnxgR0ltRHxUbG14aGBLZFgoU0RpQjw2Q21RVwp6N0wjTituNVdpITU8ZldIXktMQUNtdnZh Xi1EPmVJTXZZRjJremAkc2hjV3daP3ImND5CKilZQUd4LTVAPElCOSUKek9yRV4zN3hVO0pFZlYh TXRZMj1vaitlT1NVQUYkWGhFOyMlTCRyMChmTl9JRGdYbzRibFJZPWp7PihxcVdpb1crCnpTOzMz TzFTMl9GLTREfUBeKjR3YCk0Qn4oaGI4dVhwS2wrfnQwXntsdjMkWXRvbl9ve21pflFAQlNAZSMm NCN5Xgp6SWJFQiREb1RhN3Uzeyp9KGU3RFRgbnFFU2tOWVI2UGNSaSlZdmMoOzAkWXFgRD8hQmB4 eVozNENtMGc3YnQrR28KelklYWxsbWwzZiZOWGgmNU5xNGl+T2U2SUVIbzlSfiZ+TGI/c3UrKy1z bTduNUgoZ1koX3x4V2oqdnRjMFBMSmJNCnpYNHhmbj9ZcE4yUDB3Pn41alhOV1RaUk1veGtYLWg5 R3IyJEpnWVA7eXBCQ2FHI05YUHReRmNTSEB6e0NHZEhQbQp6XyhFJjgrOEw+KVZUYnB4dHhnM3dZ d3NNKV5eR3d3OHEjZG50bkxtaE9IU1NDY3Eja1hmO1ZrJHl0cHBvZ35OPUUKejgtSF5DU1g8K2RM dSVTOCE2YDJsbEN6c01DKHJqLW01Ml44e0Y/RHNFK25YUl8/Pz9vPlM4ZTFiXkw5SU9rNl9pCnpf cnd0UmM5fFBtSk01RkVWajkjdmJndFo1PDNGMzsqRX15WEdMYFomUn41NihfaTBOYHQ+NkJEMzVo KDxMU3xxJgp6TSZ7MD1zSkFzdHBLSDxqXlZveGlDRExWZC1DUi1+RUVrKkB6VlJRbWk9QTBuWk0q MStUWFFwTlUpXmA3eDd6a20Kej15YVlrJihsaH1EI3lZN1JkNyNFciN3P0daYGJhciMkUFF4R2lF QyRCez5UbWBwaXJ6eSpKdkwqZDNjYT4oOHhRCnpwbUlZfmxPYyElUyh1c0hocikwQXdWNDxARGF4 YjBuTmdiXmpqI0c1O30yWnJvZlhkeFBVPVdnJWpYdG1DS2JwQwp6MVlAdngyQClDTSFtKSF3P1Fp ajRobzklP01QKjVEKmNDSHJ0N1M+ZSpOdXt2UTRsUURYc31YPkhZX3dFVFAtWHAKemtvYXtHMHxe IVd7RG0pTGVIOHtHY2tMci1oMTVsM04hUncjJmZMaFJzaX1LKzN9I2FEUGJuP0lYYDw3c2xueng0 CnpxWWBgdGR2Si1PUUlfUEJOZzUyS1VeR1o+TmZSaG0wflljcTUlKXFkMSotX0dsbDV0dm0heSg3 JF8mSnB1T05uRQp6ZW47VCo8LUM5fCNgdl89OFozY1RXP1g+VWgkWEU+PyVAQkJ3eVpvaTN4Ty1V NV9NMmEyTD95MGIhJGVvP14meHcKenU5OztlRU12JmRUKiFocXMqa0dnZzJBO29adEQyLTU1QkNU MzlTQXFUOzY8SEw1Mzk8PlV+V2lxOEtrJjJwOXp6Cno8Xk9xIz4ocEc7ZFcjal9nZX1ISSEkbz9k bnk3PXQzIUlYbnJpZVE3YnJEJW8qVV4zfD5YZiF6WHYwPmo1e2h3dgp6ZyRrYU8tYlNPMkFpJV5J Q1lkY2B1QnROLWAlNkpHWHc7YnNCOSRYYDQjbjZEQkd0UVVUeVpIRk5MczI0Z3BqNFUKejdSM31K Rnh7e0Y1RV53ajBwPjI8NDhfPjQqQ0gzVSl1dHstOXJyMiVaJEZxcUxvdmt8OUllX1oxWFdPME57 ZnVNCnpsMXlJNGtSNy1YRmJYZ1ZARHYxdWp8MihpNmJ1JDVTfH1FcktIeHxlKUk2WTBmbnFgTk1n fG92Nzd4bU43ejZHOwp6V0Nwa3BOYFBCM2l+LWFFMDttSkwxbUlJSjAkdlN9T25gWDwpUGFEejE9 SW5jNGdAU2VWRGtaV0FaWUNYPlZXaSgKenNSUFNfczJ2YzVmQUh4bzBCRFNYWlhzeClnMSQxflly az5RMSZKMFVUOTliSk9gXyRCbWQxKH5KdSVzbUVxTFAjCk5TeH5MYiU2QnYze3NTWFhnM0pIXwoK bGl0ZXJhbCAwCkhjbVY/ZDAwMDAxCgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4 dC1hbmQtcG5nLXRlc3QtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC1hbmQt cG5nLXRlc3QtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmNmYjFhMjU3MDliN2M5YTFlN2RlMTgx YjI4OWUzODhhNDliMDhmZTMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9teXRlc3Qv dHh0LWFuZC1wbmctdGVzdC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw2IEBACitsYXllciBhdCAo MCwwKSBzaXplIDgwMHg2MDAKKyAgUmVuZGVyVmlldyBhdCAoMCwwKSBzaXplIDgwMHg2MDAKK2xh eWVyIGF0ICgwLDApIHNpemUgODAweDYwMAorICBSZW5kZXJCbG9jayB7SFRNTH0gYXQgKDAsMCkg c2l6ZSA4MDB4NjAwCisgICAgUmVuZGVyQm9keSB7Qk9EWX0gYXQgKDgsOCkgc2l6ZSA3ODR4NTg0 CisgICAgICBSZW5kZXJCbG9jayB7RElWfSBhdCAoMCwwKSBzaXplIDUweDUwIFtiZ2NvbG9yPSMw MDgwMDBdCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9teXRlc3QvdHh0LWFuZC1wbmctdGVzdC5o dG1sIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC1hbmQtcG5nLXRlc3QuaHRtbApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5kYWMxZDQyM2FlZjQ5MzVkNmMwYWUyYjA4ZDMxODUxZGJhODBjMGU5Ci0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC1hbmQtcG5nLXRlc3QuaHRtbApAQCAtMCwwICsx LDEyIEBACis8c3R5bGU+CisgICAgI3RhcmdldCB7IGZvbnQtZmFtaWx5OiBhaGVtOyBmb250LXNp emU6IDUwcHg7IGJhY2tncm91bmQtY29sb3I6IGdyZWVuOyBoZWlnaHQ6IDUwcHg7IHdpZHRoOiA1 MHB4OyB9CisgICAgI3RhcmdldDpmaXJzdC1sZXR0ZXIgeyBjb2xvcjogcmVkOyB9Cis8L3N0eWxl PgorPGRpdiBpZD0idGFyZ2V0Ij5Mb3JlbTwvZGl2PgorPHNjcmlwdD4KKyAgICB2YXIgdGFyZ2V0 ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRhcmdldCIpOworICAgIHRhcmdldC5vZmZzZXRU b3A7CisgICAgdmFyIHRleHQgPSB0YXJnZXQuZmlyc3RDaGlsZDsKKyAgICB0YXJnZXQuaW5uZXJI VE1MID0gImlwc3VtIjsKKyAgICB0YXJnZXQucmVtb3ZlQ2hpbGQodGFyZ2V0LmZpcnN0Q2hpbGQp OworPC9zY3JpcHQ+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9teXRlc3QvdHh0LXRlc3QtZXhw ZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC10ZXN0LWV4cGVjdGVkLnR4dApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi5lYzMxMDM0OGRmZGFhODhjYjVjYmVjZTE3MjdmYjhiZjJjYmQ5NzlmCi0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC10ZXN0LWV4cGVjdGVkLnR4dApAQCAt MCwwICsxIEBACitTdWNjZXNzIFRlc3QKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL215dGVzdC90 eHQtdGVzdC5odG1sIGIvTGF5b3V0VGVzdHMvbXl0ZXN0L3R4dC10ZXN0Lmh0bWwKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uYjZkNjQzNGQzODNmODBkZjdlYjYzMTFlZmE1MTE0OGUxNjY0NmE1YQotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL215dGVzdC90eHQtdGVzdC5odG1sCkBAIC0wLDAgKzEsOCBAQAor PHA+CisgICAgU3VjY2VzcyBUZXN0Cis8L3A+Cis8ZGl2IGlkPSJ0YXJnZXQiIHN0eWxlPSJkaXNw bGF5OiBub25lOyI+PC9kaXY+Cis8c2NyaXB0PgorICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENv bnRyb2xsZXIpCisgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKzwv c2NyaXB0PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL3Rlc3RfZXhwZWN0 YXRpb25zLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy90ZXN0X2V4cGVjdGF0aW9ucy50 eHQKaW5kZXggZDlhNTc3YTczYmM0Y2IzNDU1N2U1MDE4Y2ZkYTkzMjkwNjVkNDQzOC4uMjE2ZTIy ZjZiMDY1Y2Y3NWZiZDVlMjIxYjZiMTI0NjViZTM4MjI1ZiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVz dHMvcGxhdGZvcm0vbWFjL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAorKysgYi9MYXlvdXRUZXN0cy9w bGF0Zm9ybS9tYWMvdGVzdF9leHBlY3RhdGlvbnMudHh0CkBAIC0xMDcsMyArMTA3LDYgQEAgQlVH MzcyNTUgOiBmYXN0L3JlcGFpbnQvcmVuZGVyZXItZGVzdHJ1Y3Rpb24tYnktaW52YWxpZGF0ZVNl bGVjdGlvbi1jcmFzaC5odG1sID0KIEJVRzM3MjU2IDogZmFzdC90ZXh0L2ludGVybmF0aW9uYWwv dGhhaS1saW5lLWJyZWFrcy5odG1sID0gUEFTUyBURVhUCiBCVUczNzI1OSA6IGZhc3QvZG9tL1Nl bGVjdG9yQVBJL2R1bXBOb2RlTGlzdC1hbG1vc3Qtc3RyaWN0Lmh0bWwgPSBQQVNTIFRFWFQKIEJV RzM3MjU5IDogZmFzdC9kb20vU2VsZWN0b3JBUEkvZHVtcE5vZGVMaXN0Lmh0bWwgPSBQQVNTIFRF WFQKKworCitCVUc5OTk5IDogbXl0ZXN0L3Nob3VsZC1mYWlsLmh0bWwgPSBSRUZFUkVOQ0VfTUlT TUFUQ0gKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvb2xkLXJ1bi13ZWJraXQtdGVz dHMgYi9XZWJLaXRUb29scy9TY3JpcHRzL29sZC1ydW4td2Via2l0LXRlc3RzCmluZGV4IDJjZWYx OGIzN2JhNmUxZGZmN2Q1MTZkMWM2ODI3YTc3OWYzNTIwNmQuLjVmOTZkZTNkZjRkMTliMWEyNDM0 M2Y5YzYzMDE4NjViY2I0ZTM4NjAgMTAwNzU1Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvb2xk LXJ1bi13ZWJraXQtdGVzdHMKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy9vbGQtcnVuLXdlYmtp dC10ZXN0cwpAQCAtMTg0LDYgKzE4NCw3IEBAICR0ZXN0SFRUUCA9IDAgaWYgKGlzV3goKSk7CiBt eSAkcGVybEludGVycHJldGVyID0gInBlcmwiOwogCiBteSAkZXhwZWN0ZWRUYWcgPSAiZXhwZWN0 ZWQiOworbXkgJG1pc21hdGNoVGFnID0gIm1pc21hdGNoIjsKIG15ICRhY3R1YWxUYWcgPSAiYWN0 dWFsIjsKIG15ICRwcmV0dHlEaWZmVGFnID0gInByZXR0eS1kaWZmIjsKIG15ICRkaWZmc1RhZyA9 ICJkaWZmcyI7CkBAIC0yMjkyLDYgKzIyOTMsMTYgQEAgc3ViIHJlYWRTa2lwcGVkRmlsZXMoJCkK IAogbXkgQHRlc3RzRm91bmQ7CiAKK3N1YiBpc1VzZWRJblJlZnRlc3QKK3sKKyAgICBteSAkZmls ZW5hbWUgPSAkXzsKKyAgICBpZiAoJGZpbGVuYW1lID1+IC8tJGV4cGVjdGVkVGFnKC0kbWlzbWF0 Y2hUYWcpP1wuaHRtbCQvKSB7CisgICAgICAgIHJldHVybiAxOworICAgIH0KKyAgICBteSAkYmFz ZSA9IHN0cmlwRXh0ZW5zaW9uKCRmaWxlbmFtZSk7CisgICAgcmV0dXJuICgtZiAiJGJhc2UtJGV4 cGVjdGVkVGFnLmh0bWwiIHx8IC1mICIkYmFzZS0kZXhwZWN0ZWRUYWctJG1pc21hdGNoVGFnLmh0 bWwiKTsKK30KKwogc3ViIGRpcmVjdG9yeUZpbHRlcgogewogICAgIHJldHVybiAoKSBpZiBleGlz dHMgJGlnbm9yZWRMb2NhbERpcmVjdG9yaWVze2Jhc2VuYW1lKCRGaWxlOjpGaW5kOjpkaXIpfTsK QEAgLTIzMDMsNyArMjMxNCw4IEBAIHN1YiBmaWxlRmlsdGVyCiB7CiAgICAgbXkgJGZpbGVuYW1l ID0gJF87CiAgICAgaWYgKCRmaWxlbmFtZSA9fiAvXC4oW14uXSspJC8pIHsKLSAgICAgICAgaWYg KGV4aXN0cyAkc3VwcG9ydGVkRmlsZUV4dGVuc2lvbnN7JDF9KSB7CisgICAgICAgIG15ICRleHRl bnNpb24gPSAkMTsKKyAgICAgICAgaWYgKGV4aXN0cyAkc3VwcG9ydGVkRmlsZUV4dGVuc2lvbnN7 JGV4dGVuc2lvbn0gJiYgIWlzVXNlZEluUmVmdGVzdCgkZmlsZW5hbWUpKSB7CiAgICAgICAgICAg ICBteSAkcGF0aCA9IEZpbGU6OlNwZWMtPmFiczJyZWwoY2F0ZmlsZSgkRmlsZTo6RmluZDo6ZGly LCAkZmlsZW5hbWUpLCAkdGVzdERpcmVjdG9yeSk7CiAgICAgICAgICAgICBwdXNoIEB0ZXN0c0Zv dW5kLCAkcGF0aCBpZiAhZXhpc3RzICRpZ25vcmVkRmlsZXN7JHBhdGh9OwogICAgICAgICB9CmRp ZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlv dXRfcGFja2FnZS9kdW1wX3JlbmRlcl90cmVlX3RocmVhZC5weSBiL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2R1bXBfcmVuZGVyX3RyZWVf dGhyZWFkLnB5CmluZGV4IDNlM2JhMGIxNjc3MDQ1MDAzNmY3MzE1YWMxNjFlZjFmYjliN2Q3MzUu LjgwMTRiMjZhMjJmM2Y2ZDE3MzhkMzkxZmQyYTJkMTYxZGM5YjA5MGUgMTAwNjQ0Ci0tLSBhL1dl YktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2R1 bXBfcmVuZGVyX3RyZWVfdGhyZWFkLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2R1bXBfcmVuZGVyX3RyZWVfdGhyZWFkLnB5 CkBAIC01MCw3ICs1MCw4IEBAIGltcG9ydCB0aHJlYWRpbmcKIGltcG9ydCB0aW1lCiBpbXBvcnQg dHJhY2ViYWNrCiAKLWltcG9ydCB0ZXN0X2ZhaWx1cmVzCitmcm9tIHNpbmdsZV90ZXN0X3J1bm5l ciBpbXBvcnQgU2luZ2xlVGVzdFJ1bm5lcgoraW1wb3J0IHRlc3RfcmVzdWx0cwogaW1wb3J0IHRl c3RfcmVzdWx0cwogCiBfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90 ZXN0cy5sYXlvdXRfcGFja2FnZS4iCkBAIC03NCw5NiArNzUsMTAgQEAgZGVmIGxvZ19zdGFjayhz dGFjayk6CiAgICAgICAgICAgICBfbG9nLmVycm9yKCcgICVzJyAlIGxpbmUuc3RyaXAoKSkKIAog Ci1kZWYgX3Byb2Nlc3Nfb3V0cHV0KHBvcnQsIG9wdGlvbnMsIHRlc3RfaW5mbywgdGVzdF90eXBl cywgdGVzdF9hcmdzLAotICAgICAgICAgICAgICAgICAgICBjcmFzaCwgdGltZW91dCwgdGVzdF9y dW5fdGltZSwgYWN0dWFsX2NoZWNrc3VtLAotICAgICAgICAgICAgICAgICAgICBvdXRwdXQsIGVy cm9yKToKLSAgICAiIiJSZWNlaXZlcyB0aGUgb3V0cHV0IGZyb20gYSBEdW1wUmVuZGVyVHJlZSBw cm9jZXNzLCBzdWJqZWN0cyBpdCB0byBhCi0gICAgbnVtYmVyIG9mIHRlc3RzLCBhbmQgcmV0dXJu cyBhIGxpc3Qgb2YgZmFpbHVyZSB0eXBlcyB0aGUgdGVzdCBwcm9kdWNlZC4KLQotICAgIEFyZ3M6 Ci0gICAgICBwb3J0OiBwb3J0LXNwZWNpZmljIGhvb2tzCi0gICAgICBvcHRpb25zOiBjb21tYW5k IGxpbmUgb3B0aW9ucyBhcmd1bWVudCBmcm9tIG9wdHBhcnNlCi0gICAgICBwcm9jOiBhbiBhY3Rp dmUgRHVtcFJlbmRlclRyZWUgcHJvY2VzcwotICAgICAgdGVzdF9pbmZvOiBPYmplY3QgY29udGFp bmluZyB0aGUgdGVzdCBmaWxlbmFtZSwgdXJpIGFuZCB0aW1lb3V0Ci0gICAgICB0ZXN0X3R5cGVz OiBsaXN0IG9mIHRlc3QgdHlwZXMgdG8gc3ViamVjdCB0aGUgb3V0cHV0IHRvCi0gICAgICB0ZXN0 X2FyZ3M6IGFyZ3VtZW50cyB0byBiZSBwYXNzZWQgdG8gZWFjaCB0ZXN0Ci0KLSAgICBSZXR1cm5z OiBhIFRlc3RSZXN1bHQgb2JqZWN0Ci0gICAgIiIiCi0gICAgZmFpbHVyZXMgPSBbXQotCi0gICAg IyBTb21lIHRlc3QgYXJncywgc3VjaCBhcyB0aGUgaW1hZ2UgaGFzaCwgbWF5IGJlIGFkZGVkIG9y IGNoYW5nZWQgb24gYQotICAgICMgdGVzdC1ieS10ZXN0IGJhc2lzLgotICAgIGxvY2FsX3Rlc3Rf YXJncyA9IGNvcHkuY29weSh0ZXN0X2FyZ3MpCi0KLSAgICBsb2NhbF90ZXN0X2FyZ3MuaGFzaCA9 IGFjdHVhbF9jaGVja3N1bQotCi0gICAgaWYgY3Jhc2g6Ci0gICAgICAgIGZhaWx1cmVzLmFwcGVu ZCh0ZXN0X2ZhaWx1cmVzLkZhaWx1cmVDcmFzaCgpKQotICAgIGlmIHRpbWVvdXQ6Ci0gICAgICAg IGZhaWx1cmVzLmFwcGVuZCh0ZXN0X2ZhaWx1cmVzLkZhaWx1cmVUaW1lb3V0KCkpCi0KLSAgICBp ZiBjcmFzaDoKLSAgICAgICAgX2xvZy5kZWJ1ZygiU3RhY2t0cmFjZSBmb3IgJXM6XG4lcyIgJSAo dGVzdF9pbmZvLmZpbGVuYW1lLCBlcnJvcikpCi0gICAgICAgICMgU3RyaXAgb2ZmICJmaWxlOi8v IiBzaW5jZSBSZWxhdGl2ZVRlc3RGaWxlbmFtZSBleHBlY3RzCi0gICAgICAgICMgZmlsZXN5c3Rl bSBwYXRocy4KLSAgICAgICAgZmlsZW5hbWUgPSBvcy5wYXRoLmpvaW4ob3B0aW9ucy5yZXN1bHRz X2RpcmVjdG9yeSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcG9ydC5yZWxhdGl2 ZV90ZXN0X2ZpbGVuYW1lKAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0ZXN0X2lu Zm8uZmlsZW5hbWUpKQotICAgICAgICBmaWxlbmFtZSA9IG9zLnBhdGguc3BsaXRleHQoZmlsZW5h bWUpWzBdICsgIi1zdGFjay50eHQiCi0gICAgICAgIHBvcnQubWF5YmVfbWFrZV9kaXJlY3Rvcnko b3MucGF0aC5zcGxpdChmaWxlbmFtZSlbMF0pCi0gICAgICAgIHdpdGggY29kZWNzLm9wZW4oZmls ZW5hbWUsICJ3YiIsICJ1dGYtOCIpIGFzIGZpbGU6Ci0gICAgICAgICAgICBmaWxlLndyaXRlKGVy cm9yKQotICAgIGVsaWYgZXJyb3I6Ci0gICAgICAgIF9sb2cuZGVidWcoIlByZXZpb3VzIHRlc3Qg b3V0cHV0IHN0ZGVyciBsaW5lczpcbiVzIiAlIGVycm9yKQotCi0gICAgIyBDaGVjayB0aGUgb3V0 cHV0IGFuZCBzYXZlIHRoZSByZXN1bHRzLgotICAgIHN0YXJ0X3RpbWUgPSB0aW1lLnRpbWUoKQot ICAgIHRpbWVfZm9yX2RpZmZzID0ge30KLSAgICBmb3IgdGVzdF90eXBlIGluIHRlc3RfdHlwZXM6 Ci0gICAgICAgIHN0YXJ0X2RpZmZfdGltZSA9IHRpbWUudGltZSgpCi0gICAgICAgIG5ld19mYWls dXJlcyA9IHRlc3RfdHlwZS5jb21wYXJlX291dHB1dChwb3J0LCB0ZXN0X2luZm8uZmlsZW5hbWUs Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBvdXRwdXQs IGxvY2FsX3Rlc3RfYXJncywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIG9wdGlvbnMuY29uZmlndXJhdGlvbikKLSAgICAgICAgIyBEb24ndCBhZGQgYW55 IG1vcmUgZmFpbHVyZXMgaWYgd2UgYWxyZWFkeSBoYXZlIGEgY3Jhc2gsIHNvIHdlIGRvbid0Ci0g ICAgICAgICMgZG91YmxlLXJlcG9ydCB0aG9zZSB0ZXN0cy4gV2UgZG8gZG91YmxlLXJlcG9ydCBm b3IgdGltZW91dHMgc2luY2UKLSAgICAgICAgIyB3ZSBzdGlsbCB3YW50IHRvIHNlZSB0aGUgdGV4 dCBhbmQgaW1hZ2Ugb3V0cHV0LgotICAgICAgICBpZiBub3QgY3Jhc2g6Ci0gICAgICAgICAgICBm YWlsdXJlcy5leHRlbmQobmV3X2ZhaWx1cmVzKQotICAgICAgICB0aW1lX2Zvcl9kaWZmc1t0ZXN0 X3R5cGUuX19jbGFzc19fLl9fbmFtZV9fXSA9ICgKLSAgICAgICAgICAgIHRpbWUudGltZSgpIC0g c3RhcnRfZGlmZl90aW1lKQotCi0gICAgdG90YWxfdGltZV9mb3JfYWxsX2RpZmZzID0gdGltZS50 aW1lKCkgLSBzdGFydF9kaWZmX3RpbWUKLSAgICByZXR1cm4gdGVzdF9yZXN1bHRzLlRlc3RSZXN1 bHQodGVzdF9pbmZvLmZpbGVuYW1lLCBmYWlsdXJlcywgdGVzdF9ydW5fdGltZSwKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgdG90YWxfdGltZV9mb3JfYWxsX2RpZmZzLCB0aW1l X2Zvcl9kaWZmcykKLQotCi1kZWYgX3BhZF90aW1lb3V0KHRpbWVvdXQpOgotICAgICIiIlJldHVy bnMgYSBzYWZlIG11bHRpcGxlIG9mIHRoZSBwZXItdGVzdCB0aW1lb3V0IHZhbHVlIHRvIHVzZQot ICAgIHRvIGRldGVjdCBodW5nIHRlc3QgdGhyZWFkcy4KLQotICAgICIiIgotICAgICMgV2hlbiB3 ZSdyZSBydW5uaW5nIG9uZSB0ZXN0IHBlciBEdW1wUmVuZGVyVHJlZSBwcm9jZXNzLCB3ZSBjYW4K LSAgICAjIGVuZm9yY2UgYSBoYXJkIHRpbWVvdXQuICBUaGUgRHVtcFJlbmRlclRyZWUgd2F0Y2hk b2cgdXNlcyAyLjV4Ci0gICAgIyB0aGUgdGltZW91dDsgd2Ugd2FudCB0byBiZSBsYXJnZXIgdGhh biB0aGF0LgotICAgIHJldHVybiB0aW1lb3V0ICogMwotCi0KLWRlZiBfbWlsbGlzZWNvbmRzX3Rv X3NlY29uZHMobXNlY3MpOgotICAgIHJldHVybiBmbG9hdChtc2VjcykgLyAxMDAwLjAKLQotCi1k ZWYgX2ltYWdlX2hhc2godGVzdF9pbmZvLCB0ZXN0X2FyZ3MsIG9wdGlvbnMpOgotICAgICIiIlJl dHVybnMgdGhlIGltYWdlIGhhc2ggb2YgdGhlIHRlc3QgaWYgaXQncyBuZWVkZWQsIG90aGVyd2lz ZSBOb25lLiIiIgotICAgIGlmICh0ZXN0X2FyZ3MubmV3X2Jhc2VsaW5lIG9yIHRlc3RfYXJncy5y ZXNldF9yZXN1bHRzIG9yIG5vdCBvcHRpb25zLnBpeGVsX3Rlc3RzKToKLSAgICAgICAgcmV0dXJu IE5vbmUKLSAgICByZXR1cm4gdGVzdF9pbmZvLmltYWdlX2hhc2goKQotCi0KIGNsYXNzIFNpbmds ZVRlc3RUaHJlYWQodGhyZWFkaW5nLlRocmVhZCk6CiAgICAgIiIiVGhyZWFkIHdyYXBwZXIgZm9y IHJ1bm5pbmcgYSBzaW5nbGUgdGVzdCBmaWxlLiIiIgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYs IHBvcnQsIG9wdGlvbnMsIHRlc3RfaW5mbywgdGVzdF90eXBlcywgdGVzdF9hcmdzKToKKyAgICBk ZWYgX19pbml0X18oc2VsZiwgcG9ydCwgb3B0aW9ucywgdGVzdF9pbmZvLCB0ZXN0X3R5cGVzLCBy ZWZ0ZXN0X3R5cGVzLCB0ZXN0X2FyZ3MpOgogICAgICAgICAiIiIKICAgICAgICAgQXJnczoKICAg ICAgICAgICBwb3J0OiBvYmplY3QgaW1wbGVtZW50aW5nIHBvcnQtc3BlY2lmaWMgaG9va3MKQEAg LTE3MSw2ICs4Niw4IEBAIGNsYXNzIFNpbmdsZVRlc3RUaHJlYWQodGhyZWFkaW5nLlRocmVhZCk6 CiAgICAgICAgICAgdGVzdF9pbmZvOiBPYmplY3QgY29udGFpbmluZyB0aGUgdGVzdCBmaWxlbmFt ZSwgdXJpIGFuZCB0aW1lb3V0CiAgICAgICAgICAgdGVzdF90eXBlczogQSBsaXN0IG9mIFRlc3RU eXBlIG9iamVjdHMgdG8gcnVuIHRoZSB0ZXN0IG91dHB1dAogICAgICAgICAgICAgICBhZ2FpbnN0 LgorICAgICAgICAgIHJlZnRlc3RfdHlwZXM6IEEgbGlzdCBvZiBUZXN0VHlwZSBvYmplY3RzIHRv IHJ1biB0aGUgcmVmdGVzdCBvdXRwdXQKKyAgICAgICAgICAgICAgYWdhaW5zdC4KICAgICAgICAg ICB0ZXN0X2FyZ3M6IEEgVGVzdEFyZ3VtZW50cyBvYmplY3QgdG8gcGFzcyB0byBlYWNoIFRlc3RU eXBlLgogICAgICAgICAiIiIKIApAQCAtMTc5LDYgKzk2LDcgQEAgY2xhc3MgU2luZ2xlVGVzdFRo cmVhZCh0aHJlYWRpbmcuVGhyZWFkKToKICAgICAgICAgc2VsZi5fb3B0aW9ucyA9IG9wdGlvbnMK ICAgICAgICAgc2VsZi5fdGVzdF9pbmZvID0gdGVzdF9pbmZvCiAgICAgICAgIHNlbGYuX3Rlc3Rf dHlwZXMgPSB0ZXN0X3R5cGVzCisgICAgICAgIHNlbGYuX3JlZnRlc3RfdHlwZXMgPSByZWZ0ZXN0 X3R5cGVzCiAgICAgICAgIHNlbGYuX3Rlc3RfYXJncyA9IHRlc3RfYXJncwogICAgICAgICBzZWxm Ll9kcml2ZXIgPSBOb25lCiAKQEAgLTE5MiwxNiArMTEwLDEwIEBAIGNsYXNzIFNpbmdsZVRlc3RU aHJlYWQodGhyZWFkaW5nLlRocmVhZCk6CiAgICAgICAgIHNlbGYuX2RyaXZlciA9IHNlbGYuX3Bv cnQuY3JlYXRlX2RyaXZlcihzZWxmLl90ZXN0X2FyZ3MucG5nX3BhdGgsCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxmLl9vcHRpb25zKQogICAgICAg ICBzZWxmLl9kcml2ZXIuc3RhcnQoKQotICAgICAgICBpbWFnZV9oYXNoID0gX2ltYWdlX2hhc2go dGVzdF9pbmZvLCBzZWxmLl90ZXN0X2FyZ3MsIHNlbGYuX29wdGlvbnMpCi0gICAgICAgIHN0YXJ0 ID0gdGltZS50aW1lKCkKLSAgICAgICAgY3Jhc2gsIHRpbWVvdXQsIGFjdHVhbF9jaGVja3N1bSwg b3V0cHV0LCBlcnJvciA9IFwKLSAgICAgICAgICAgIHNlbGYuX2RyaXZlci5ydW5fdGVzdCh0ZXN0 X2luZm8udXJpLnN0cmlwKCksIHRlc3RfaW5mby50aW1lb3V0LAotICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGltYWdlX2hhc2gpCi0gICAgICAgIGVuZCA9IHRpbWUudGltZSgpCi0g ICAgICAgIHNlbGYuX3Rlc3RfcmVzdWx0ID0gX3Byb2Nlc3Nfb3V0cHV0KHNlbGYuX3BvcnQsIHNl bGYuX29wdGlvbnMsCi0gICAgICAgICAgICB0ZXN0X2luZm8sIHNlbGYuX3Rlc3RfdHlwZXMsIHNl bGYuX3Rlc3RfYXJncywKLSAgICAgICAgICAgIGNyYXNoLCB0aW1lb3V0LCBlbmQgLSBzdGFydCwK LSAgICAgICAgICAgIGFjdHVhbF9jaGVja3N1bSwgb3V0cHV0LCBlcnJvcikKKyAgICAgICAgcnVu bmVyID0gU2luZ2xlVGVzdFJ1bm5lcih0ZXN0X2luZm8sIHNlbGYuX3Rlc3RfYXJncywgc2VsZi5f ZHJpdmVyLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYuX3BvcnQsIHNl bGYuX29wdGlvbnMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VsZi5fdGVz dF90eXBlcywgc2VsZi5fcmVmdGVzdF90eXBlcykKKyAgICAgICAgc2VsZi5fdGVzdF9yZXN1bHQg PSBydW5uZXIucnVuX3Rlc3QoKQogICAgICAgICBzZWxmLl9kcml2ZXIuc3RvcCgpCiAKICAgICBk ZWYgZ2V0X3Rlc3RfcmVzdWx0KHNlbGYpOgpAQCAtMjQ1LDcgKzE1Nyw3IEBAIGNsYXNzIFdhdGNo YWJsZVRocmVhZCh0aHJlYWRpbmcuVGhyZWFkKToKIAogY2xhc3MgVGVzdFNoZWxsVGhyZWFkKFdh dGNoYWJsZVRocmVhZCk6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQsIG9wdGlvbnMsIGZp bGVuYW1lX2xpc3RfcXVldWUsIHJlc3VsdF9xdWV1ZSwKLSAgICAgICAgICAgICAgICAgdGVzdF90 eXBlcywgdGVzdF9hcmdzKToKKyAgICAgICAgICAgICAgICAgdGVzdF90eXBlcywgcmVmdGVzdF90 eXBlcywgdGVzdF9hcmdzKToKICAgICAgICAgIiIiSW5pdGlhbGl6ZSBhbGwgdGhlIGxvY2FsIHN0 YXRlIGZvciB0aGlzIER1bXBSZW5kZXJUcmVlIHRocmVhZC4KIAogICAgICAgICBBcmdzOgpAQCAt MjU3LDYgKzE2OSw4IEBAIGNsYXNzIFRlc3RTaGVsbFRocmVhZChXYXRjaGFibGVUaHJlYWQpOgog ICAgICAgICAgICAgICBzZXJpYWxpemVkIFRlc3RSZXN1bHQgb2JqZWN0cy4KICAgICAgICAgICB0 ZXN0X3R5cGVzOiBBIGxpc3Qgb2YgVGVzdFR5cGUgb2JqZWN0cyB0byBydW4gdGhlIHRlc3Qgb3V0 cHV0CiAgICAgICAgICAgICAgIGFnYWluc3QuCisgICAgICAgICAgcmVmdGVzdF90eXBlczogQSBs aXN0IG9mIFRlc3RUeXBlIG9iamVjdHMgdG8gcnVuIHRoZSByZWZ0ZXN0IG91dHB1dAorICAgICAg ICAgICAgICBhZ2FpbnN0LgogICAgICAgICAgIHRlc3RfYXJnczogQSBUZXN0QXJndW1lbnRzIG9i amVjdCB0byBwYXNzIHRvIGVhY2ggVGVzdFR5cGUuCiAKICAgICAgICAgIiIiCkBAIC0yNjcsNiAr MTgxLDcgQEAgY2xhc3MgVGVzdFNoZWxsVGhyZWFkKFdhdGNoYWJsZVRocmVhZCk6CiAgICAgICAg IHNlbGYuX3Jlc3VsdF9xdWV1ZSA9IHJlc3VsdF9xdWV1ZQogICAgICAgICBzZWxmLl9maWxlbmFt ZV9saXN0ID0gW10KICAgICAgICAgc2VsZi5fdGVzdF90eXBlcyA9IHRlc3RfdHlwZXMKKyAgICAg ICAgc2VsZi5fcmVmdGVzdF90eXBlcyA9IHJlZnRlc3RfdHlwZXMKICAgICAgICAgc2VsZi5fdGVz dF9hcmdzID0gdGVzdF9hcmdzCiAgICAgICAgIHNlbGYuX2RyaXZlciA9IE5vbmUKICAgICAgICAg c2VsZi5fdGVzdF9ncm91cF90aW1pbmdfc3RhdHMgPSB7fQpAQCAtNTA4LDI4ICs0MjMsMTMgQEAg Y2xhc3MgVGVzdFNoZWxsVGhyZWFkKFdhdGNoYWJsZVRocmVhZCk6CiAgICAgICAgIFJldHVybnM6 IGEgVGVzdFJlc3VsdCBvYmplY3QuCiAgICAgICAgICIiIgogICAgICAgICBzZWxmLl9lbnN1cmVf ZHVtcF9yZW5kZXJfdHJlZV9pc19ydW5uaW5nKCkKLSAgICAgICAgIyBUaGUgcGl4ZWxfaGFzaCBp cyB1c2VkIHRvIGF2b2lkIGRvaW5nIGFuIGltYWdlIGR1bXAgaWYgdGhlCi0gICAgICAgICMgY2hl Y2tzdW1zIG1hdGNoLCBzbyBpdCBzaG91bGQgYmUgc2V0IHRvIGEgYmxhbmsgdmFsdWUgaWYgd2UK LSAgICAgICAgIyBhcmUgZ2VuZXJhdGluZyBhIG5ldyBiYXNlbGluZS4gIChPdGhlcndpc2UsIGFu IGltYWdlIGZyb20gYQotICAgICAgICAjIHByZXZpb3VzIHJ1biB3aWxsIGJlIGNvcGllZCBpbnRv IHRoZSBiYXNlbGluZS4pCi0gICAgICAgIGltYWdlX2hhc2ggPSBfaW1hZ2VfaGFzaCh0ZXN0X2lu Zm8sIHNlbGYuX3Rlc3RfYXJncywgc2VsZi5fb3B0aW9ucykKLSAgICAgICAgc3RhcnQgPSB0aW1l LnRpbWUoKQotCi0gICAgICAgIHRocmVhZF90aW1lb3V0ID0gX21pbGxpc2Vjb25kc190b19zZWNv bmRzKAotICAgICAgICAgICAgIF9wYWRfdGltZW91dChpbnQodGVzdF9pbmZvLnRpbWVvdXQpKSkK LSAgICAgICAgc2VsZi5fbmV4dF90aW1lb3V0ID0gc3RhcnQgKyB0aHJlYWRfdGltZW91dAotCi0g ICAgICAgIGNyYXNoLCB0aW1lb3V0LCBhY3R1YWxfY2hlY2tzdW0sIG91dHB1dCwgZXJyb3IgPSBc Ci0gICAgICAgICAgIHNlbGYuX2RyaXZlci5ydW5fdGVzdCh0ZXN0X2luZm8udXJpLCB0ZXN0X2lu Zm8udGltZW91dCwgaW1hZ2VfaGFzaCkKLSAgICAgICAgZW5kID0gdGltZS50aW1lKCkKLQotICAg ICAgICByZXN1bHQgPSBfcHJvY2Vzc19vdXRwdXQoc2VsZi5fcG9ydCwgc2VsZi5fb3B0aW9ucywK LSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRlc3RfaW5mbywgc2VsZi5fdGVzdF90 eXBlcywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYuX3Rlc3RfYXJncywg Y3Jhc2gsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aW1lb3V0LCBlbmQgLSBz dGFydCwgYWN0dWFsX2NoZWNrc3VtLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg b3V0cHV0LCBlcnJvcikKLSAgICAgICAgc2VsZi5fdGVzdF9yZXN1bHRzLmFwcGVuZChyZXN1bHQp Ci0gICAgICAgIHJldHVybiByZXN1bHQKKyAgICAgICAgcnVubmVyID0gU2luZ2xlVGVzdFJ1bm5l cih0ZXN0X2luZm8sIHNlbGYuX3Rlc3RfYXJncywgc2VsZi5fZHJpdmVyLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHNlbGYuX3BvcnQsIHNlbGYuX29wdGlvbnMsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VsZi5fdGVzdF90eXBlcywgc2VsZi5fcmVmdGVz dF90eXBlcykKKyAgICAgICAgdGVzdF9yZXN1bHQgPSBydW5uZXIucnVuX3Rlc3QoKQorICAgICAg ICBzZWxmLl90ZXN0X3Jlc3VsdHMuYXBwZW5kKHRlc3RfcmVzdWx0KQorICAgICAgICBzZWxmLl9u ZXh0X3RpbWVvdXQgPSBydW5uZXIubmV4dF90aW1lb3V0KCkKKyAgICAgICAgcmV0dXJuIHRlc3Rf cmVzdWx0CiAKICAgICBkZWYgX2Vuc3VyZV9kdW1wX3JlbmRlcl90cmVlX2lzX3J1bm5pbmcoc2Vs Zik6CiAgICAgICAgICIiIlN0YXJ0IHRoZSBzaGFyZWQgRHVtcFJlbmRlclRyZWUsIGlmIGl0J3Mg bm90IHJ1bm5pbmcuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9qc29uX2xheW91dF9yZXN1bHRzX2dlbmVyYXRvci5w eSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNr YWdlL2pzb25fbGF5b3V0X3Jlc3VsdHNfZ2VuZXJhdG9yLnB5CmluZGV4IDFjZjg4ZWY1OTdmNDU3 M2VlYzY5MWZlMDljNjRiYTU1ODQ4MzkzNmIuLjQ3OWY0MDk1NWNiNjAwMjkyNWZlZDYzMDEzNDYy YzhhZWQ1YmViOGIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2pzb25fbGF5b3V0X3Jlc3VsdHNfZ2VuZXJhdG9yLnB5 CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9w YWNrYWdlL2pzb25fbGF5b3V0X3Jlc3VsdHNfZ2VuZXJhdG9yLnB5CkBAIC01MSw2ICs1MSw4IEBA IGNsYXNzIEpTT05MYXlvdXRSZXN1bHRzR2VuZXJhdG9yKGpzb25fcmVzdWx0c19nZW5lcmF0b3Iu SlNPTlJlc3VsdHNHZW5lcmF0b3JCYXNlCiAgICAgICAgICAgICAgICAgICAgICAgIHRlc3RfZXhw ZWN0YXRpb25zLklNQUdFOiAiSSIsCiAgICAgICAgICAgICAgICAgICAgICAgIHRlc3RfZXhwZWN0 YXRpb25zLlRFWFQ6ICJGIiwKICAgICAgICAgICAgICAgICAgICAgICAgdGVzdF9leHBlY3RhdGlv bnMuTUlTU0lORzogIk8iLAorICAgICAgICAgICAgICAgICAgICAgICB0ZXN0X2V4cGVjdGF0aW9u cy5SRUZFUkVOQ0VfTUlTTUFUQ0g6ICJSIiwKKyAgICAgICAgICAgICAgICAgICAgICAgdGVzdF9l eHBlY3RhdGlvbnMuUkVGRVJFTkNFX01BVENIOiAiTSIsCiAgICAgICAgICAgICAgICAgICAgICAg IHRlc3RfZXhwZWN0YXRpb25zLklNQUdFX1BMVVNfVEVYVDogIloifQogCiAgICAgZGVmIF9faW5p dF9fKHNlbGYsIHBvcnQsIGJ1aWxkZXJfbmFtZSwgYnVpbGRfbmFtZSwgYnVpbGRfbnVtYmVyLApk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5 b3V0X3BhY2thZ2Uvc2luZ2xlX3Rlc3RfcnVubmVyLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2Uvc2luZ2xlX3Rlc3RfcnVubmVyLnB5 Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjFhNzhiNjIxZmFlMjE4MjlkOTg3ZDJkNWE3NDhkZTQ5NGIzZGViZGUKLS0t IC9kZXYvbnVsbAorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9sYXlvdXRfcGFja2FnZS9zaW5nbGVfdGVzdF9ydW5uZXIucHkKQEAgLTAsMCArMSwyMzYgQEAK KyMhL3Vzci9iaW4vZW52IHB5dGhvbgorIyBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xlIEluYy4g QWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyMg bWV0OgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29weXJpZ2h0IG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgor IyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisjIGRpc3RyaWJ1dGlvbi4KKyMgICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29n bGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworIyBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQg dG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorIyB0aGlzIHNvZnR3 YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorIworIyBUSElT IFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJ QlVUT1JTCisjICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorIyBBIFBBUlRJQ1VMQVIgUFVSUE9T RSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorIyBPV05F UiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwKKyMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMg KElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyMgREFUQSwgT1IgUFJPRklUUzsg T1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisjIFRI RU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFks IE9SIFRPUlQKKyMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisKKyIiIkEgdGVzdCBydW5u ZXIgd2hpY2ggcnVucyBhIHNpbmdsZSB0ZXN0IGZpbGUuIiIiCisKK2Zyb20gX19mdXR1cmVfXyBp bXBvcnQgd2l0aF9zdGF0ZW1lbnQKKworaW1wb3J0IGNvcHkKK2ltcG9ydCBsb2dnaW5nCitpbXBv cnQgb3MKK2ltcG9ydCBzeXMKK2ltcG9ydCB0aW1lCisKK2ltcG9ydCB0ZXN0X2ZhaWx1cmVzCitp bXBvcnQgdGVzdF9yZXN1bHRzCisKK19sb2cgPSBsb2dnaW5nLmdldExvZ2dlcigid2Via2l0cHku bGF5b3V0X3Rlc3RzLmxheW91dF9wYWNrYWdlLiIKKyAgICAgICAgICAgICAgICAgICAgICAgICAi c2luZ2xlX3Rlc3RfcnVubmVyIikKKworCitkZWYgX3BhZF90aW1lb3V0KHRpbWVvdXQpOgorICAg ICIiIlJldHVybnMgYSBzYWZlIG11bHRpcGxlIG9mIHRoZSBwZXItdGVzdCB0aW1lb3V0IHZhbHVl IHRvIHVzZQorICAgIHRvIGRldGVjdCBodW5nIHRlc3QgdGhyZWFkcy4KKworICAgICIiIgorICAg ICMgV2hlbiB3ZSdyZSBydW5uaW5nIG9uZSB0ZXN0IHBlciBEdW1wUmVuZGVyVHJlZSBwcm9jZXNz LCB3ZSBjYW4KKyAgICAjIGVuZm9yY2UgYSBoYXJkIHRpbWVvdXQuICBUaGUgRHVtcFJlbmRlclRy ZWUgd2F0Y2hkb2cgdXNlcyAyLjV4CisgICAgIyB0aGUgdGltZW91dDsgd2Ugd2FudCB0byBiZSBs YXJnZXIgdGhhbiB0aGF0LgorICAgIHJldHVybiB0aW1lb3V0ICogMworCisKK2RlZiBfbWlsbGlz ZWNvbmRzX3RvX3NlY29uZHMobXNlY3MpOgorICAgIHJldHVybiBmbG9hdChtc2VjcykgLyAxMDAw LjAKKworCitkZWYgX2ltYWdlX2hhc2godGVzdF9pbmZvLCB0ZXN0X2FyZ3MsIG9wdGlvbnMpOgor ICAgICIiIlJldHVybnMgdGhlIGltYWdlIGhhc2ggb2YgdGhlIHRlc3QgaWYgaXQncyBuZWVkZWQs IG90aGVyd2lzZSBOb25lLiIiIgorICAgIGlmICh0ZXN0X2FyZ3MubmV3X2Jhc2VsaW5lIG9yIHRl c3RfYXJncy5yZXNldF9yZXN1bHRzIG9yIG5vdCBvcHRpb25zLnBpeGVsX3Rlc3RzKToKKyAgICAg ICAgcmV0dXJuIE5vbmUKKyAgICByZXR1cm4gdGVzdF9pbmZvLmltYWdlX2hhc2goKQorCisKK2Ns YXNzIFNpbmdsZVRlc3RSdW5uZXIob2JqZWN0KToKKyAgICAiIiJBbiBhYnN0cmFjdGlvbiBmb3Ig cnVubmluZyBhIHNpbmdsZSB0ZXN0LgorCisgICAgQSB0eXBpY2FsIHVzYWdlIGlzOgorICAgICAg IyBJbnN0YW50aWF0ZSB3aXRoIG5lY2Vzc2FyeSB0ZXN0IGluZm9ybWF0aW9uLgorICAgICAgcnVu bmVyID0gU2luZ2xlVGVzdFJ1bm5lcih0ZXN0X2luZm8sIHRlc3RfYXJncywgLi4uLikKKyAgICAg ICMgUnVuIGFuZCBnZXQgYSBUZXN0UmVzdWx0IG9iamVjdCBieSBjYWxpbmcgcnVuX3Rlc3QoKS4K KyAgICAgIHRlc3RfcmVzdWx0ID0gcnVubmVyLnJ1bl90ZXN0KCkKKyAgICAiIiIKKworICAgIGRl ZiBfX2luaXRfXyhzZWxmLCB0ZXN0X2luZm8sIHRlc3RfYXJncywgZHJpdmVyLCBwb3J0LCBvcHRp b25zLAorICAgICAgICAgICAgICAgICB0ZXN0X3R5cGVzLCByZWZ0ZXN0X3R5cGVzKToKKyAgICAg ICAgc2VsZi5fdGVzdF9pbmZvID0gdGVzdF9pbmZvCisgICAgICAgIHNlbGYuX3Rlc3RfYXJncyA9 IHRlc3RfYXJncworICAgICAgICBzZWxmLl9kcml2ZXIgPSBkcml2ZXIKKyAgICAgICAgc2VsZi5f cG9ydCA9IHBvcnQKKyAgICAgICAgc2VsZi5fb3B0aW9ucyA9IG9wdGlvbnMKKyAgICAgICAgc2Vs Zi5fdGVzdF90eXBlcyA9IHRlc3RfdHlwZXMKKyAgICAgICAgc2VsZi5fcmVmdGVzdF90eXBlcyA9 IHJlZnRlc3RfdHlwZXMKKyAgICAgICAgc2VsZi5fbmV4dF90aW1lb3V0ID0gTm9uZQorCisgICAg ZGVmIG5leHRfdGltZW91dChzZWxmKToKKyAgICAgICAgIiIiUmV0dXJuIHRoZSB0aW1lIHRoZSB0 ZXN0IGlzIHN1cHBvc2VkIHRvIGZpbmlzaCBieS4iIiIKKyAgICAgICAgcmV0dXJuIHNlbGYuX25l eHRfdGltZW91dAorCisgICAgZGVmIF91cGRhdGVfbmV4dF90aW1lb3V0KHNlbGYsIHN0YXJ0KToK KyAgICAgICAgdGhyZWFkX3RpbWVvdXQgPSBfbWlsbGlzZWNvbmRzX3RvX3NlY29uZHMoCisgICAg ICAgICAgICAgX3BhZF90aW1lb3V0KGludChzZWxmLl90ZXN0X2luZm8udGltZW91dCkpKQorICAg ICAgICBzZWxmLl9uZXh0X3RpbWVvdXQgPSBzdGFydCArIHRocmVhZF90aW1lb3V0CisKKyAgICBk ZWYgcnVuX3Rlc3Qoc2VsZik6CisgICAgICAgICIiIlJ1biBhIHNpbmdsZSB0ZXN0IGZpbGUgdXNp bmcgYSBzaGFyZWQgRHVtcFJlbmRlclRyZWUgcHJvY2Vzcy4KKworICAgICAgICBBcyBzaWRlIGVm ZmVjdHMsIHByZXNlcnZlcyB0aGUgcmVuZGVyaW5nIHJlc3VsdChzKSBhbmQgZXhwZWN0ZWQgb25l KHMpCisgICAgICAgIGFuZCBzbyBvbiBpbiB0aGUgb3V0cHV0IGRpcmVjdG9yeSBmb3IgbGF0ZXIg cmVwb3J0aW5nIGlmIG5lY2Vzc2FueS4KKworICAgICAgICBSZXR1cm5zOgorICAgICAgICAgIEEg bGlzdCBvZiBUZXN0RmFpbHVyZSBvYmplY3RzIGRlc2NyaWJpbmcgdGhlIGVycm9yLgorICAgICAg ICAiIiIKKyAgICAgICAgaWYgc2VsZi5fdGVzdF9pbmZvLmlzX3JlZnRlc3Q6CisgICAgICAgICAg ICByZXR1cm4gc2VsZi5fcnVuX3JlZnRlc3QoKQorICAgICAgICByZXR1cm4gc2VsZi5fcnVuX2xh eW91dF90ZXN0KCkKKworICAgIGRlZiBfcnVuX2xheW91dF90ZXN0KHNlbGYpOgorICAgICAgICAj IFRoZSBwaXhlbF9oYXNoIGlzIHVzZWQgdG8gYXZvaWQgZG9pbmcgYW4gaW1hZ2UgZHVtcCBpZiB0 aGUKKyAgICAgICAgIyBjaGVja3N1bXMgbWF0Y2gsIHNvIGl0IHNob3VsZCBiZSBzZXQgdG8gYSBi bGFuayB2YWx1ZSBpZiB3ZQorICAgICAgICAjIGFyZSBnZW5lcmF0aW5nIGEgbmV3IGJhc2VsaW5l LiAgKE90aGVyd2lzZSwgYW4gaW1hZ2UgZnJvbSBhCisgICAgICAgICMgcHJldmlvdXMgcnVuIHdp bGwgYmUgY29waWVkIGludG8gdGhlIGJhc2VsaW5lLikKKyAgICAgICAgaW1hZ2VfaGFzaCA9IF9p bWFnZV9oYXNoKHNlbGYuX3Rlc3RfaW5mbywgc2VsZi5fdGVzdF9hcmdzLCBzZWxmLl9vcHRpb25z KQorICAgICAgICBzdGFydCA9IHRpbWUudGltZSgpCisgICAgICAgIHNlbGYuX3VwZGF0ZV9uZXh0 X3RpbWVvdXQoc3RhcnQpCisKKyAgICAgICAgY3Jhc2gsIHRpbWVvdXQsIGFjdHVhbF9jaGVja3N1 bSwgb3V0cHV0LCBlcnJvciA9IFwKKyAgICAgICAgICAgc2VsZi5fZHJpdmVyLnJ1bl90ZXN0KHNl bGYuX3Rlc3RfaW5mby51cmksIHNlbGYuX3Rlc3RfaW5mby50aW1lb3V0LAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgaW1hZ2VfaGFzaCkKKyAgICAgICAgZW5kID0gdGltZS50aW1l KCkKKworICAgICAgICAjIFByb2Nlc3Mgb3V0cHV0cy4KKyAgICAgICAgZmFpbHVyZXMgPSBbXQor ICAgICAgICBmYWlsdXJlcy5leHRlbmQoCisgICAgICAgICAgICBzZWxmLl9wcm9jZXNzX2Vycm9y KHNlbGYuX3Rlc3RfaW5mby5maWxlbmFtZSwgY3Jhc2gsIHRpbWVvdXQsIGVycm9yKSkKKworICAg ICAgICAjIFNvbWUgdGVzdCBhcmdzLCBzdWNoIGFzIHRoZSBpbWFnZSBoYXNoLCBtYXkgYmUgYWRk ZWQgb3IgY2hhbmdlZCBvbiBhCisgICAgICAgICMgdGVzdC1ieS10ZXN0IGJhc2lzLgorICAgICAg ICBsb2NhbF90ZXN0X2FyZ3MgPSBjb3B5LmNvcHkoc2VsZi5fdGVzdF9hcmdzKQorICAgICAgICBs b2NhbF90ZXN0X2FyZ3MuaGFzaCA9IGFjdHVhbF9jaGVja3N1bQorCisgICAgICAgICMgQ2hlY2sg dGhlIG91dHB1dCBhbmQgc2F2ZSB0aGUgcmVzdWx0cy4KKyAgICAgICAgdGltZV9mb3JfZGlmZnMg PSB7fQorICAgICAgICBmb3IgdGVzdF90eXBlIGluIHNlbGYuX3Rlc3RfdHlwZXM6CisgICAgICAg ICAgICBzdGFydF9kaWZmX3RpbWUgPSB0aW1lLnRpbWUoKQorICAgICAgICAgICAgbmV3X2ZhaWx1 cmVzID0gdGVzdF90eXBlLmNvbXBhcmVfb3V0cHV0KHNlbGYuX3BvcnQsIHNlbGYuX3Rlc3RfaW5m by5maWxlbmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBvdXRwdXQsIGxvY2FsX3Rlc3RfYXJncywKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxmLl9vcHRpb25zLmNvbmZpZ3VyYXRpb24p CisgICAgICAgICAgICAjIERvbid0IGFkZCBhbnkgbW9yZSBmYWlsdXJlcyBpZiB3ZSBhbHJlYWR5 IGhhdmUgYSBjcmFzaCwgc28gd2UgZG9uJ3QKKyAgICAgICAgICAgICMgZG91YmxlLXJlcG9ydCB0 aG9zZSB0ZXN0cy4gV2UgZG8gZG91YmxlLXJlcG9ydCBmb3IgdGltZW91dHMgc2luY2UKKyAgICAg ICAgICAgICMgd2Ugc3RpbGwgd2FudCB0byBzZWUgdGhlIHRleHQgYW5kIGltYWdlIG91dHB1dC4K KyAgICAgICAgICAgIGlmIG5vdCBjcmFzaDoKKyAgICAgICAgICAgICAgICBmYWlsdXJlcy5leHRl bmQobmV3X2ZhaWx1cmVzKQorICAgICAgICAgICAgdGltZV9mb3JfZGlmZnNbdGVzdF90eXBlLl9f Y2xhc3NfXy5fX25hbWVfX10gPSAoCisgICAgICAgICAgICAgICAgdGltZS50aW1lKCkgLSBzdGFy dF9kaWZmX3RpbWUpCisKKyAgICAgICAgdG90YWxfdGltZV9mb3JfYWxsX2RpZmZzID0gdGltZS50 aW1lKCkgLSBzdGFydF9kaWZmX3RpbWUKKyAgICAgICAgcmV0dXJuIHRlc3RfcmVzdWx0cy5UZXN0 UmVzdWx0KHNlbGYuX3Rlc3RfaW5mby5maWxlbmFtZSwgZmFpbHVyZXMsIGVuZCAtIHN0YXJ0LAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdG90YWxfdGltZV9mb3JfYWxs X2RpZmZzLCB0aW1lX2Zvcl9kaWZmcykKKworICAgIGRlZiBfb3V0cHV0X2ltYWdlX2NvbnRlbnRz X2Zyb21fZHJpdmVyKHNlbGYpOgorICAgICAgICBwbmdfcGF0aCA9IHNlbGYuX3Rlc3RfYXJncy5w bmdfcGF0aAorICAgICAgICBhc3NlcnQob3MucGF0aC5pc2ZpbGUocG5nX3BhdGgpKQorICAgICAg ICB3aXRoIG9wZW4ocG5nX3BhdGgsICdyYicpIGFzIGltYWdlX2ZpbGU6CisgICAgICAgICAgICBy ZXR1cm4gaW1hZ2VfZmlsZS5yZWFkKCkKKworICAgIGRlZiBfcnVuX3JlZnRlc3Qoc2VsZik6Cisg ICAgICAgIHN0YXJ0ID0gdGltZS50aW1lKCkKKyAgICAgICAgc2VsZi5fdXBkYXRlX25leHRfdGlt ZW91dChzdGFydCkKKworICAgICAgICAjIFdlIHNob3VsZCBjYWxsIGRyaXZlcidzIHJ1bl90ZXN0 IG1ldGhvZCB0d28gdGltZXMuIE9uZSBpcyBmb3IgdGhlIHRlc3QgZmlsZS4KKyAgICAgICAgIyBU aGUgb3RoZXIgaXMgZm9yIHRoZSByZWZlcmVuY2UgZmlsZS4KKworICAgICAgICAjIEdldHMgYSBy ZW5kZXJpbmcgaW1hZ2UgZm9yIHRoZSB0ZXN0IGZpbGUuCisgICAgICAgIChhY3R1YWxfY3Jhc2gs IGFjdHVhbF90aW1lb3V0LCBhY3R1YWxfaW1hZ2VfaGFzaCwgYWN0dWFsX291dHB1dCwKKyAgICAg ICAgIGFjdHVhbF9lcnJvcikgPSBcCisgICAgICAgICAgICBzZWxmLl9kcml2ZXIucnVuX3Rlc3Qo c2VsZi5fdGVzdF9pbmZvLnVyaSwgc2VsZi5fdGVzdF9pbmZvLnRpbWVvdXQsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgaW1hZ2VfaGFzaD0iIikKKyAgICAgICAgYWN0dWFsX2lt YWdlX2NvbnRlbnRzID0gc2VsZi5fb3V0cHV0X2ltYWdlX2NvbnRlbnRzX2Zyb21fZHJpdmVyKCkK KworICAgICAgICAjIEdldHMgYSByZW5kZXJpbmcgaW1hZ2UgZm9yIHRoZSByZWZlcmVuY2UgZmls ZS4KKyAgICAgICAgcmVmZXJlbmNlX2ZpbGVuYW1lID0gKHNlbGYuX3Rlc3RfaW5mby5leHBlY3Rl ZF9odG1sX2ZpbGVuYW1lCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBvciBzZWxmLl90 ZXN0X2luZm8uZXhwZWN0ZWRfbWlzbWF0Y2hfaHRtbF9maWxlbmFtZSkKKyAgICAgICAgKHJlZmVy ZW5jZV9jcmFzaCwgcmVmZXJlbmNlX3RpbWVvdXQsIHJlZmVyZW5jZV9pbWFnZV9oYXNoLAorICAg ICAgICAgcmVmZXJlbmNlX291dHB1dCwgcmVmZXJlbmNlX2Vycm9yKSA9IFwKKyAgICAgICAgICAg IHNlbGYuX2RyaXZlci5ydW5fdGVzdChyZWZlcmVuY2VfZmlsZW5hbWUsIHNlbGYuX3Rlc3RfaW5m by50aW1lb3V0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGFjdHVhbF9pbWFn ZV9oYXNoKQorCisgICAgICAgIGlmIGFjdHVhbF9pbWFnZV9oYXNoID09IHJlZmVyZW5jZV9pbWFn ZV9oYXNoOgorICAgICAgICAgICAgcmVmZXJlbmNlX2ltYWdlX2NvbnRlbnRzID0gYWN0dWFsX2lt YWdlX2NvbnRlbnRzCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICByZWZlcmVuY2VfaW1hZ2Vf Y29udGVudHMgPSBzZWxmLl9vdXRwdXRfaW1hZ2VfY29udGVudHNfZnJvbV9kcml2ZXIoKQorCisg ICAgICAgIGVuZCA9IHRpbWUudGltZSgpCisKKyAgICAgICAgIyBQcm9jZXNzIG91dHB1dHMuCisg ICAgICAgIGZhaWx1cmVzID0gW10KKyAgICAgICAgZmFpbHVyZXMuZXh0ZW5kKAorICAgICAgICAg ICAgc2VsZi5fcHJvY2Vzc19lcnJvcihzZWxmLl90ZXN0X2luZm8uZXhwZWN0ZWRfaHRtbF9maWxl bmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYWN0dWFsX2NyYXNoLCBhY3R1 YWxfdGltZW91dCwgYWN0dWFsX2Vycm9yKSkKKyAgICAgICAgZmFpbHVyZXMuZXh0ZW5kKAorICAg ICAgICAgICAgc2VsZi5fcHJvY2Vzc19lcnJvcihzZWxmLl90ZXN0X2luZm8uZXhwZWN0ZWRfbWlz bWF0Y2hfaHRtbF9maWxlbmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVm ZXJlbmNlX2NyYXNoLCByZWZlcmVuY2VfdGltZW91dCwgcmVmZXJlbmNlX2Vycm9yKSkKKworICAg ICAgICB0aW1lX2Zvcl9kaWZmcyA9IHt9CisgICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gc2VsZi5f cmVmdGVzdF90eXBlczoKKyAgICAgICAgICAgIHN0YXJ0X2RpZmZfdGltZSA9IHRpbWUudGltZSgp CisgICAgICAgICAgICBuZXdfZmFpbHVyZXMgPSB0ZXN0X3R5cGUuY29tcGFyZV9vdXRwdXRfd2l0 aF9yZWZlcmVuY2UoCisgICAgICAgICAgICAgICAgc2VsZi5fcG9ydCwgc2VsZi5fdGVzdF9pbmZv LCBhY3R1YWxfaW1hZ2VfaGFzaCwgYWN0dWFsX2ltYWdlX2NvbnRlbnRzLAorICAgICAgICAgICAg ICAgIHJlZmVyZW5jZV9pbWFnZV9oYXNoLCByZWZlcmVuY2VfaW1hZ2VfY29udGVudHMpCisKKyAg ICAgICAgICAgIGlmIG5vdCBhY3R1YWxfY3Jhc2ggYW5kIG5vdCByZWZlcmVuY2VfY3Jhc2g6Cisg ICAgICAgICAgICAgICAgZmFpbHVyZXMuZXh0ZW5kKG5ld19mYWlsdXJlcykKKworICAgICAgICAg ICAgdGltZV9mb3JfZGlmZnNbdGVzdF90eXBlLl9fY2xhc3NfXy5fX25hbWVfX10gPSAoCisgICAg ICAgICAgICAgICAgdGltZS50aW1lKCkgLSBzdGFydF9kaWZmX3RpbWUpCisKKyAgICAgICAgdG90 YWxfdGltZV9mb3JfYWxsX2RpZmZzID0gdGltZS50aW1lKCkgLSBzdGFydF9kaWZmX3RpbWUKKyAg ICAgICAgcmV0dXJuIHRlc3RfcmVzdWx0cy5UZXN0UmVzdWx0KHNlbGYuX3Rlc3RfaW5mby5maWxl bmFtZSwgZmFpbHVyZXMsIGVuZCAtIHN0YXJ0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgdG90YWxfdGltZV9mb3JfYWxsX2RpZmZzLCB0aW1lX2Zvcl9kaWZmcykKKwor ICAgIGRlZiBfcHJvY2Vzc19lcnJvcihzZWxmLCBmaWxlbmFtZSwgY3Jhc2gsIHRpbWVvdXQsIGVy cm9yKToKKyAgICAgICAgZmFpbHVyZXMgPSBbXQorICAgICAgICBpZiBjcmFzaDoKKyAgICAgICAg ICAgIGZhaWx1cmVzLmFwcGVuZCh0ZXN0X2ZhaWx1cmVzLkZhaWx1cmVDcmFzaCgpKQorICAgICAg ICBpZiB0aW1lb3V0OgorICAgICAgICAgICAgZmFpbHVyZXMuYXBwZW5kKHRlc3RfZmFpbHVyZXMu RmFpbHVyZVRpbWVvdXQoKSkKKworICAgICAgICBpZiBjcmFzaDoKKyAgICAgICAgICAgIF9sb2cu ZGVidWcoIlN0YWNrdHJhY2UgZm9yICVzOlxuJXMiICUgKGZpbGVuYW1lLCBlcnJvcikpCisgICAg ICAgICAgICAjIFN0cmlwIG9mZiAiZmlsZTovLyIgc2luY2UgUmVsYXRpdmVUZXN0RmlsZW5hbWUg ZXhwZWN0cworICAgICAgICAgICAgIyBmaWxlc3lzdGVtIHBhdGhzLgorICAgICAgICAgICAgZmls ZW5hbWUgPSBvcy5wYXRoLmpvaW4oc2VsZi5fb3B0aW9ucy5yZXN1bHRzX2RpcmVjdG9yeSwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYuX3BvcnQucmVsYXRpdmVfdGVz dF9maWxlbmFtZSgKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYuX3Rl c3RfaW5mby5maWxlbmFtZSkpCisgICAgICAgICAgICBmaWxlbmFtZSA9IG9zLnBhdGguc3BsaXRl eHQoZmlsZW5hbWUpWzBdICsgIi1zdGFjay50eHQiCisgICAgICAgICAgICBwb3J0Lm1heWJlX21h a2VfZGlyZWN0b3J5KG9zLnBhdGguc3BsaXQoZmlsZW5hbWUpWzBdKQorICAgICAgICAgICAgd2l0 aCBjb2RlY3Mub3BlbihmaWxlbmFtZSwgIndiIiwgInV0Zi04IikgYXMgZmlsZToKKyAgICAgICAg ICAgICAgICBmaWxlLndyaXRlKGVycm9yKQorICAgICAgICBlbGlmIGVycm9yOgorICAgICAgICAg ICAgX2xvZy5kZWJ1ZygiUHJldmlvdXMgdGVzdCBvdXRwdXQgc3RkZXJyIGxpbmVzOlxuJXMiICUg ZXJyb3IpCisgICAgICAgIHJldHVybiBmYWlsdXJlcwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvdGVzdF9leHBlY3Rh dGlvbnMucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlv dXRfcGFja2FnZS90ZXN0X2V4cGVjdGF0aW9ucy5weQppbmRleCA2Nzg3M2E4Y2MwYWIzMTc5Yzdk ZTM1ZDVjOTgxNmNlMzQwZDM0Y2I5Li40MDM2YzBkNDRjY2Q4MDNjYzY4ZGI3YTFkNWE5NWRhYzBk YThjMjRjIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9sYXlvdXRfcGFja2FnZS90ZXN0X2V4cGVjdGF0aW9ucy5weQorKysgYi9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS90ZXN0X2V4cGVj dGF0aW9ucy5weQpAQCAtNDIsOCArNDIsOSBAQCBfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndl YmtpdHB5LmxheW91dF90ZXN0cy5sYXlvdXRfcGFja2FnZS4iCiAgICAgICAgICAgICAgICAgICAg ICAgICAgInRlc3RfZXhwZWN0YXRpb25zIikKIAogIyBUZXN0IGV4cGVjdGF0aW9uIGFuZCBtb2Rp ZmllciBjb25zdGFudHMuCi0oUEFTUywgRkFJTCwgVEVYVCwgSU1BR0UsIElNQUdFX1BMVVNfVEVY VCwgVElNRU9VVCwgQ1JBU0gsIFNLSVAsIFdPTlRGSVgsCi0gU0xPVywgUkVCQVNFTElORSwgTUlT U0lORywgRkxBS1ksIE5PVywgTk9ORSkgPSByYW5nZSgxNSkKKyhQQVNTLCBGQUlMLCBURVhULCBJ TUFHRSwgSU1BR0VfUExVU19URVhULCBSRUZFUkVOQ0VfTUlTTUFUQ0gsIFJFRkVSRU5DRV9NQVRD SCwKKyBUSU1FT1VULCBDUkFTSCwgU0tJUCwgV09OVEZJWCwgU0xPVywgUkVCQVNFTElORSwgTUlT U0lORywgRkxBS1ksIE5PVywKKyBOT05FKSA9IHJhbmdlKDE3KQogCiAjIFRlc3QgZXhwZWN0YXRp b24gZmlsZSB1cGRhdGUgYWN0aW9uIGNvbnN0YW50cwogKE5PX0NIQU5HRSwgUkVNT1ZFX1RFU1Qs IFJFTU9WRV9QTEFURk9STSwgQUREX1BMQVRGT1JNU19FWENFUFRfVEhJUykgPSByYW5nZSg0KQpA QCAtNTksNyArNjAsOSBAQCBkZWYgcmVzdWx0X3dhc19leHBlY3RlZChyZXN1bHQsIGV4cGVjdGVk X3Jlc3VsdHMsIHRlc3RfbmVlZHNfcmViYXNlbGluaW5nLAogICAgICAgICB0ZXN0X2lzX3NraXBw ZWQ6IHdoZXRoZXIgdGVzdCB3YXMgbWFya2VkIGFzIFNLSVAiIiIKICAgICBpZiByZXN1bHQgaW4g ZXhwZWN0ZWRfcmVzdWx0czoKICAgICAgICAgcmV0dXJuIFRydWUKLSAgICBpZiByZXN1bHQgaW4g KElNQUdFLCBURVhULCBJTUFHRV9QTFVTX1RFWFQpIGFuZCBGQUlMIGluIGV4cGVjdGVkX3Jlc3Vs dHM6CisgICAgaWYgKHJlc3VsdCBpbiAoSU1BR0UsIFRFWFQsIElNQUdFX1BMVVNfVEVYVCwgUkVG RVJFTkNFX01JU01BVENILAorICAgICAgICAgICAgICAgICAgIFJFRkVSRU5DRV9NQVRDSCkKKyAg ICAgICAgYW5kIEZBSUwgaW4gZXhwZWN0ZWRfcmVzdWx0cyk6CiAgICAgICAgIHJldHVybiBUcnVl CiAgICAgaWYgcmVzdWx0ID09IE1JU1NJTkcgYW5kIHRlc3RfbmVlZHNfcmViYXNlbGluaW5nOgog ICAgICAgICByZXR1cm4gVHJ1ZQpAQCAtMjU1LDYgKzI1OCw4IEBAIGNsYXNzIFRlc3RFeHBlY3Rh dGlvbnNGaWxlOgogICAgICAgICAgICAgICAgICAgICAndGV4dCc6IFRFWFQsCiAgICAgICAgICAg ICAgICAgICAgICdpbWFnZSc6IElNQUdFLAogICAgICAgICAgICAgICAgICAgICAnaW1hZ2UrdGV4 dCc6IElNQUdFX1BMVVNfVEVYVCwKKyAgICAgICAgICAgICAgICAgICAgJ3JlZmVyZW5jZV9taXNt YXRjaCc6IFJFRkVSRU5DRV9NSVNNQVRDSCwKKyAgICAgICAgICAgICAgICAgICAgJ3JlZmVyZW5j ZV9tYXRjaCc6IFJFRkVSRU5DRV9NQVRDSCwKICAgICAgICAgICAgICAgICAgICAgJ3RpbWVvdXQn OiBUSU1FT1VULAogICAgICAgICAgICAgICAgICAgICAnY3Jhc2gnOiBDUkFTSCwKICAgICAgICAg ICAgICAgICAgICAgJ21pc3NpbmcnOiBNSVNTSU5HfQpAQCAtMjY3LDYgKzI3MiwxMCBAQCBjbGFz cyBUZXN0RXhwZWN0YXRpb25zRmlsZToKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg SU1BR0U6ICgnaW1hZ2UgbWlzbWF0Y2gnLCAnaW1hZ2UgbWlzbWF0Y2gnKSwKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgSU1BR0VfUExVU19URVhUOiAoJ2ltYWdlIGFuZCB0ZXh0IG1p c21hdGNoJywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgJ2ltYWdlIGFuZCB0ZXh0IG1pc21hdGNoJyksCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFJFRkVSRU5DRV9NSVNNQVRDSDogKCdyZWZlcmVuY2UgbWlzbWF0Y2gnLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ3JlZmVyZW5jZSBt aXNtYXRjaCcpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBSRUZFUkVOQ0VfTUFU Q0g6ICgncmVmZXJlbmNlIG1hdGNoJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICdyZWZlcmVuY2UgbWF0Y2gnKSwKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgQ1JBU0g6ICgnRHVtcFJlbmRlclRyZWUgY3Jhc2gnLAogICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdEdW1wUmVuZGVyVHJlZSBjcmFzaGVzJyks CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFRJTUVPVVQ6ICgndGVzdCB0aW1lZCBv dXQnLCAndGVzdHMgdGltZWQgb3V0JyksCkBAIC0yNzQsNyArMjgzLDcgQEAgY2xhc3MgVGVzdEV4 cGVjdGF0aW9uc0ZpbGU6CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAnbm8gZXhwZWN0ZWQgcmVzdWx0cyBmb3VuZCcpfQogCiAgICAgRVhQRUNUQVRJT05fT1JERVIg PSAoUEFTUywgQ1JBU0gsIFRJTUVPVVQsIE1JU1NJTkcsIElNQUdFX1BMVVNfVEVYVCwKLSAgICAg ICBURVhULCBJTUFHRSwgRkFJTCwgU0tJUCkKKyAgICAgICBURVhULCBJTUFHRSwgUkVGRVJFTkNF X01JU01BVENILCBSRUZFUkVOQ0VfTUFUQ0gsIEZBSUwsIFNLSVApCiAKICAgICBCVUlMRF9UWVBF UyA9ICgnZGVidWcnLCAncmVsZWFzZScpCiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL3Rlc3RfZmFpbHVyZXMucHkg Yi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2Fn ZS90ZXN0X2ZhaWx1cmVzLnB5CmluZGV4IDZkNTU3NjEwZmJmMWI2MzY0ZTQ4ZTgyNGQwMjFiNTJm Zjc5YzcxZjguLjAxZDc5MGFiM2JiMTYyMzI5ODJhZDU4NDRjYzJkNmFhNGZmNWMwYjIgMTAwNjQ0 Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9w YWNrYWdlL3Rlc3RfZmFpbHVyZXMucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRw eS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvdGVzdF9mYWlsdXJlcy5weQpAQCAtNjQsNiAr NjQsMTAgQEAgZGVmIGRldGVybWluZV9yZXN1bHRfdHlwZShmYWlsdXJlX2xpc3QpOgogICAgICAg ICAgICAgcmV0dXJuIHRlc3RfZXhwZWN0YXRpb25zLlRFWFQKICAgICAgICAgZWxpZiBpc19pbWFn ZV9mYWlsdXJlOgogICAgICAgICAgICAgcmV0dXJuIHRlc3RfZXhwZWN0YXRpb25zLklNQUdFCisg ICAgICAgIGVsaWYgRmFpbHVyZVJlZmVyZW5jZU1pc21hdGNoIGluIGZhaWx1cmVfdHlwZXM6Cisg ICAgICAgICAgICByZXR1cm4gdGVzdF9leHBlY3RhdGlvbnMuUkVGRVJFTkNFX01JU01BVENICisg ICAgICAgIGVsaWYgRmFpbHVyZVJlZmVyZW5jZU1hdGNoIGluIGZhaWx1cmVfdHlwZXM6CisgICAg ICAgICAgICByZXR1cm4gdGVzdF9leHBlY3RhdGlvbnMuUkVGRVJFTkNFX01BVENICiAgICAgICAg IGVsc2U6CiAgICAgICAgICAgICByYWlzZSBWYWx1ZUVycm9yKCJ1bmNsYXNzaWZpYWJsZSBzZXQg b2YgZmFpbHVyZXM6ICIKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKyBzdHIoZmFpbHVy ZV90eXBlcykpCkBAIC0yNzQsNiArMjc4LDQ0IEBAIGNsYXNzIEZhaWx1cmVJbWFnZUhhc2hJbmNv cnJlY3QoRmFpbHVyZVdpdGhUeXBlKToKICAgICBkZWYgcmVzdWx0X2h0bWxfb3V0cHV0KHNlbGYs IGZpbGVuYW1lKToKICAgICAgICAgcmV0dXJuICI8c3Ryb25nPiVzPC9zdHJvbmc+IiAlIHNlbGYu bWVzc2FnZSgpCiAKKworY2xhc3MgRmFpbHVyZVJlZmVyZW5jZU1pc21hdGNoKEZhaWx1cmVXaXRo VHlwZSk6CisgICAgIiIiVGhlIHJlc3VsdCBkaWRuJ3QgbWF0Y2ggdGhlIHJlZmVyZW5jZSByZW5k ZXJpbmcuIiIiCisgICAgT1VUX0ZJTEVOQU1FUyA9ICgiLWFjdHVhbC5wbmciLCAiLWV4cGVjdGVk Lmh0bWwiLCAiLWV4cGVjdGVkLnBuZyIsCisgICAgICAgICAgICAgICAgICAgICAiLWRpZmYucG5n IiwpCisKKyAgICBAc3RhdGljbWV0aG9kCisgICAgZGVmIG1lc3NhZ2UoKToKKyAgICAgICAgcmV0 dXJuICJSZWZlcmVuY2UgbWlzbWF0Y2giCisKKyAgICBkZWYgb3V0cHV0X2xpbmtzKHNlbGYsIGZp bGVuYW1lLCBvdXRfbmFtZXMpOgorICAgICAgICBsaW5rcyA9IFsnJ10KKyAgICAgICAgdXJpcyA9 IFtzZWxmLnJlbGF0aXZlX291dHB1dF9maWxlbmFtZShmaWxlbmFtZSwgZm4pIGZvcgorICAgICAg ICAgICAgICAgIGZuIGluIG91dF9uYW1lc10KKyAgICAgICAgZm9yIHRleHQsIHVyaSBpbiB6aXAo WydhY3R1YWwtaW1hZ2UnLCAncmVmZXJlbmNlLWh0bWwnLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgJ3JlZmVyZW5jZS1pbWFnZScsICdkaWZmJ10sIHVyaXMpOgorICAgICAgICAgICAg bGlua3MuYXBwZW5kKCI8YSBocmVmPSclcyc+JXM8L2E+IiAlICh1cmksIHRleHQpKQorICAgICAg ICByZXR1cm4gJyAnLmpvaW4obGlua3MpCisKKworY2xhc3MgRmFpbHVyZVJlZmVyZW5jZU1hdGNo KEZhaWx1cmVXaXRoVHlwZSk6CisgICAgIiIiVW5leHBlY3RlZCBtYXRjaCBiZXR3ZWVuIHRoZSBy ZXN1bHQgYW5kIHRoZSByZWZlcmVuY2UgcmVuZGVyaW5nLiIiIgorICAgIE9VVF9GSUxFTkFNRVMg PSAoIi1hY3R1YWwucG5nIiwgIi1leHBlY3RlZC1taXNtYXRjaC5odG1sIiwpCisKKyAgICBAc3Rh dGljbWV0aG9kCisgICAgZGVmIG1lc3NhZ2UoKToKKyAgICAgICAgcmV0dXJuICgiVGhlcmUgd2Fz IG5vIGRpZmZlcmVuY2UgYmV0d2VlbiB0aGUgcmVzdWx0IGFuZCB0aGUgcmVmZXJlbmNlIgorICAg ICAgICAgICAgICAgICIgcmVuZGVyaW5nIikKKworICAgIGRlZiBvdXRwdXRfbGlua3Moc2VsZiwg ZmlsZW5hbWUsIG91dF9uYW1lcyk6CisgICAgICAgIGxpbmtzID0gWycnXQorICAgICAgICB1cmlz ID0gW3NlbGYucmVsYXRpdmVfb3V0cHV0X2ZpbGVuYW1lKGZpbGVuYW1lLCBmbikgZm9yCisgICAg ICAgICAgICAgICAgZm4gaW4gb3V0X25hbWVzXQorICAgICAgICBmb3IgdGV4dCwgdXJpIGluIHpp cChbJ2ltYWdlJywgJ3JlZmVyZW5jZS1odG1sJ10sIHVyaXMpOgorICAgICAgICAgICAgbGlua3Mu YXBwZW5kKCI8YSBocmVmPSclcyc+JXM8L2E+IiAlICh1cmksIHRleHQpKQorICAgICAgICByZXR1 cm4gJyAnLmpvaW4obGlua3MpCisKKwogIyBDb252ZW5pZW50IGNvbGxlY3Rpb24gb2YgYWxsIGZh aWx1cmUgY2xhc3NlcyBmb3IgYW55dGhpbmcgdGhhdCBtaWdodAogIyBuZWVkIHRvIGVudW1lcmF0 ZSBvdmVyIHRoZW0gYWxsLgogQUxMX0ZBSUxVUkVfQ0xBU1NFUyA9IChGYWlsdXJlVGltZW91dCwg RmFpbHVyZUNyYXNoLCBGYWlsdXJlTWlzc2luZ1Jlc3VsdCwKZGlmZiAtLWdpdCBhL1dlYktpdFRv b2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZS5weSBiL1dlYktpdFRv b2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZS5weQppbmRleCBjZDdk NjYzOTAzNDA0YTVkNWUwNGQ5NjgwZjcyODhhOTViNTRhYjdiLi5hZmVmNGFhNWMwMzIwNmRlODE5 ZmEzOGIxZTU2ZWQxMzZjMzI3OTgxIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dl YmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlLnB5CkBAIC0zMzQsNiArMzM0LDE1IEBA IGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgICAgIHJldHVybiAnJwogICAgICAgICByZXR1 cm4gdGV4dC5zdHJpcCgiXHJcbiIpLnJlcGxhY2UoIlxyXG4iLCAiXG4iKSArICJcbiIKIAorICAg IGRlZiBleHBlY3RlZF9odG1sX2ZpbGVuYW1lKHNlbGYsIGZpbGVuYW1lKToKKyAgICAgICAgIiIi UmV0dXJuIHRoZSBmaWxlbmFtZSBvZiByZWZlcmVuY2UgSFRNTCB3ZSBleHBlY3QgdGhlIHRlc3Qg bWF0Y2hlcy4iIiIKKyAgICAgICAgcmV0dXJuIHNlbGYuZXhwZWN0ZWRfZmlsZW5hbWUoZmlsZW5h bWUsICcuaHRtbCcpCisKKyAgICBkZWYgZXhwZWN0ZWRfbWlzbWF0Y2hfaHRtbF9maWxlbmFtZShz ZWxmLCBmaWxlbmFtZSk6CisgICAgICAgICIiIlJldHVybiB0aGUgZmlsZW5hbWUgb2YgcmVmZXJl bmNlIEhUTUwgd2UgZG9uJ3QgZXhwZWN0IHRoZSB0ZXN0CisgICAgICAgIG1hdGNoZXMuIiIiCisg ICAgICAgIHJldHVybiBzZWxmLmV4cGVjdGVkX2ZpbGVuYW1lKGZpbGVuYW1lLCAnLW1pc21hdGNo Lmh0bWwnKQorCiAgICAgZGVmIGZpbGVuYW1lX3RvX3VyaShzZWxmLCBmaWxlbmFtZSk6CiAgICAg ICAgICIiIkNvbnZlcnQgYSB0ZXN0IGZpbGUgKHdoaWNoIGlzIGFuIGFic29sdXRlIHBhdGgpIHRv IGEgVVJJLiIiIgogICAgICAgICBMQVlPVVRURVNUX0hUVFBfRElSID0gImh0dHAvdGVzdHMvIgpk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9y dC90ZXN0X2ZpbGVzLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvcG9ydC90ZXN0X2ZpbGVzLnB5CmluZGV4IDNmYTBmYjM2NGJiMzE5NjAyZTYxOWFkZjVkZDUx ZDMyYjBmNTdhNTIuLmQ2YjI4MzY2NjUzY2JmNTM4ODM4Zjc5Y2QyNTk2NGNlMzExYTg3ZWIgMTAw NjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv dGVzdF9maWxlcy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90 ZXN0cy9wb3J0L3Rlc3RfZmlsZXMucHkKQEAgLTUwLDYgKzUwLDkgQEAgX3N1cHBvcnRlZF9maWxl X2V4dGVuc2lvbnMgPSBzZXQoWycuaHRtbCcsICcuc2h0bWwnLCAnLnhtbCcsICcueGh0bWwnLCAn LnhodG1sbXAKICMgV2hlbiBjb2xsZWN0aW5nIHRlc3QgY2FzZXMsIHNraXAgdGhlc2UgZGlyZWN0 b3JpZXMKIF9za2lwcGVkX2RpcmVjdG9yaWVzID0gc2V0KFsnLnN2bicsICdfc3ZuJywgJ3Jlc291 cmNlcycsICdzY3JpcHQtdGVzdHMnXSkKIAorIyBXaGVuIGNvbGxlY3RpbmcgdGVzdCBjYXNlcywg c2tpcCBmaWxlcyB3aXRoIHRoZXNlIHN1ZmZpeGVzLgorX3NraXBwZWRfc3VmZml4ZXMgPSBzZXQo WyctZXhwZWN0ZWQuaHRtbCcsICdleHBlY3RlZC1taXNtYXRjaC5odG1sJ10pCisKIAogZGVmIGZp bmQocG9ydCwgcGF0aHMpOgogICAgICIiIkZpbmRzIHRoZSBzZXQgb2YgdGVzdHMgdW5kZXIgcG9y dC5sYXlvdXRfdGVzdHNfZGlyKCkuCkBAIC03OCw3ICs4MSw3IEBAIGRlZiBmaW5kKHBvcnQsIHBh dGhzKToKICAgICAjIE5vdyB3YWxrIGFsbCB0aGUgcGF0aHMgcGFzc2VkIGluIG9uIHRoZSBjb21t YW5kIGxpbmUgYW5kIGdldCBmaWxlbmFtZXMKICAgICB0ZXN0X2ZpbGVzID0gc2V0KCkKICAgICBm b3IgcGF0aCBpbiBwYXRoc190b193YWxrOgotICAgICAgICBpZiBvcy5wYXRoLmlzZmlsZShwYXRo KSBhbmQgX2hhc19zdXBwb3J0ZWRfZXh0ZW5zaW9uKHBhdGgpOgorICAgICAgICBpZiBvcy5wYXRo LmlzZmlsZShwYXRoKSBhbmQgX2lzX3Rlc3RfZmlsZShwYXRoKToKICAgICAgICAgICAgIHRlc3Rf ZmlsZXMuYWRkKG9zLnBhdGgubm9ybXBhdGgocGF0aCkpCiAgICAgICAgICAgICBjb250aW51ZQog CkBAIC05NSw3ICs5OCw3IEBAIGRlZiBmaW5kKHBvcnQsIHBhdGhzKToKICAgICAgICAgICAgICAg ICAgICAgZGlycy5yZW1vdmUoZGlyZWN0b3J5KQogCiAgICAgICAgICAgICBmb3IgZmlsZW5hbWUg aW4gZmlsZXM6Ci0gICAgICAgICAgICAgICAgaWYgX2hhc19zdXBwb3J0ZWRfZXh0ZW5zaW9uKGZp bGVuYW1lKToKKyAgICAgICAgICAgICAgICBpZiBfaXNfdGVzdF9maWxlKGZpbGVuYW1lKToKICAg ICAgICAgICAgICAgICAgICAgZmlsZW5hbWUgPSBvcy5wYXRoLmpvaW4ocm9vdCwgZmlsZW5hbWUp CiAgICAgICAgICAgICAgICAgICAgIGZpbGVuYW1lID0gb3MucGF0aC5ub3JtcGF0aChmaWxlbmFt ZSkKICAgICAgICAgICAgICAgICAgICAgdGVzdF9maWxlcy5hZGQoZmlsZW5hbWUpCkBAIC0xMTEs MyArMTE0LDE1IEBAIGRlZiBfaGFzX3N1cHBvcnRlZF9leHRlbnNpb24oZmlsZW5hbWUpOgogICAg IHRlc3Qgb24uIiIiCiAgICAgZXh0ZW5zaW9uID0gb3MucGF0aC5zcGxpdGV4dChmaWxlbmFtZSlb MV0KICAgICByZXR1cm4gZXh0ZW5zaW9uIGluIF9zdXBwb3J0ZWRfZmlsZV9leHRlbnNpb25zCisK KworZGVmIF9pc19za2lwcGVkX2ZpbGUoZmlsZW5hbWUpOgorICAgICIiIlJldHVybiB0cnVlIGlm IGZpbGVuYW1lIHNob3VsZCBiZSBza2lwcGVkLiIiIgorICAgIHJldHVybiBhbnkoZmlsZW5hbWUu ZW5kc3dpdGgoc2tpcHBlZF9zdWZmaXgpIGZvciBza2lwcGVkX3N1ZmZpeAorICAgICAgICAgICAg ICAgaW4gX3NraXBwZWRfc3VmZml4ZXMpCisKKworZGVmIF9pc190ZXN0X2ZpbGUoZmlsZW5hbWUp OgorICAgICIiIlJldHVybiB0cnVlIGlmIGZpbGVuYW1lIHJlcHJlc2VudHMgdGVzdCBjYXNlcyB3 ZSB3YW50IHRvIHJ1biBhIHRlc3QKKyAgICBvbi4iIiIKKyAgICByZXR1cm4gX2hhc19zdXBwb3J0 ZWRfZXh0ZW5zaW9uKGZpbGVuYW1lKSBhbmQgbm90IF9pc19za2lwcGVkX2ZpbGUoZmlsZW5hbWUp CmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9w b3J0L3dlYmtpdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3BvcnQvd2Via2l0LnB5CmluZGV4IDBkMGQzZTAwMWI3OTkzNTdkYjQ5NTY1MWRjYTc1YjhlZDI3 YWE4NzkuLmNlYTI0MDRhOTY2OWM3MDE1MTMxOWJjNzFhYzYwMjE5ZDNkYzk0ZGIgMTAwNjQ0Ci0t LSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0 LnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQv d2Via2l0LnB5CkBAIC0xMjIsNyArMTIyLDcgQEAgY2xhc3MgV2ViS2l0UG9ydChiYXNlLlBvcnQp OgogICAgICAgICByZXR1cm4gVHJ1ZQogCiAgICAgZGVmIGRpZmZfaW1hZ2Uoc2VsZiwgZXhwZWN0 ZWRfY29udGVudHMsIGFjdHVhbF9jb250ZW50cywKLSAgICAgICAgICAgICAgICAgICBkaWZmX2Zp bGVuYW1lPU5vbmUpOgorICAgICAgICAgICAgICAgICAgIGRpZmZfZmlsZW5hbWU9Tm9uZSwgdG9s ZXJhbmNlPU5vbmUpOgogICAgICAgICAiIiJSZXR1cm4gVHJ1ZSBpZiB0aGUgdHdvIGZpbGVzIGFy ZSBkaWZmZXJlbnQuIEFsc28gd3JpdGUgYSBkZWx0YQogICAgICAgICBpbWFnZSBvZiB0aGUgdHdv IGltYWdlcyBpbnRvIHxkaWZmX2ZpbGVuYW1lfCBpZiBpdCBpcyBub3QgTm9uZS4iIiIKIApAQCAt MTMwLDE0ICsxMzAsMTggQEAgY2xhc3MgV2ViS2l0UG9ydChiYXNlLlBvcnQpOgogICAgICAgICBp ZiBub3QgYWN0dWFsX2NvbnRlbnRzOgogICAgICAgICAgICAgcmV0dXJuIFRydWUKIAotICAgICAg ICBzcCA9IHNlbGYuX2RpZmZfaW1hZ2VfcmVxdWVzdChleHBlY3RlZF9jb250ZW50cywgYWN0dWFs X2NvbnRlbnRzKQorICAgICAgICBzcCA9IHNlbGYuX2RpZmZfaW1hZ2VfcmVxdWVzdChleHBlY3Rl ZF9jb250ZW50cywgYWN0dWFsX2NvbnRlbnRzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB0b2xlcmFuY2UpCiAgICAgICAgIHJldHVybiBzZWxmLl9kaWZmX2ltYWdlX3Jl cGx5KHNwLCBkaWZmX2ZpbGVuYW1lKQogCi0gICAgZGVmIF9kaWZmX2ltYWdlX3JlcXVlc3Qoc2Vs ZiwgZXhwZWN0ZWRfY29udGVudHMsIGFjdHVhbF9jb250ZW50cyk6CisgICAgZGVmIF9kaWZmX2lt YWdlX3JlcXVlc3Qoc2VsZiwgZXhwZWN0ZWRfY29udGVudHMsIGFjdHVhbF9jb250ZW50cywKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICB0b2xlcmFuY2U9Tm9uZSk6CiAgICAgICAgICMgRklY TUU6IHVzZSBzZWxmLmdldF9vcHRpb24oJ3RvbGVyYW5jZScpIGFuZAogICAgICAgICAjIHNlbGYu c2V0X29wdGlvbl9kZWZhdWx0KCd0b2xlcmFuY2UnLCAwLjEpIG9uY2UgdGhhdCBiZWhhdmVzIGNv cnJlY3RseQogICAgICAgICAjIHdpdGggZGVmYXVsdCB2YWx1ZXMuCi0gICAgICAgIGlmIHNlbGYu Z2V0X29wdGlvbigndG9sZXJhbmNlJykgaXMgbm90IE5vbmU6CisgICAgICAgIGlmIHRvbGVyYW5j ZSBpcyBub3QgTm9uZToKKyAgICAgICAgICAgIHBhc3MKKyAgICAgICAgZWxpZiBzZWxmLmdldF9v cHRpb24oJ3RvbGVyYW5jZScpIGlzIG5vdCBOb25lOgogICAgICAgICAgICAgdG9sZXJhbmNlID0g c2VsZi5nZXRfb3B0aW9uKCd0b2xlcmFuY2UnKQogICAgICAgICBlbHNlOgogICAgICAgICAgICAg dG9sZXJhbmNlID0gMC4xCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQppbmRleCBmMTAzYmNkNmQ3 ZDkwNmMwM2Q3NzIzOWUzYmIzZDNkOTA0NzkwNTk5Li45OGQyZGUwYTcxMjQ3MWQ5MmQwYmYwN2Q5 ZDAyMWQwNmJmYjQ5OGY1IDEwMDc1NQotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5CisrKyBiL1dlYktpdFRvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKQEAgLTcyLDYgKzcy LDcgQEAgZnJvbSBsYXlvdXRfcGFja2FnZSBpbXBvcnQgdGVzdF9mYWlsdXJlcwogZnJvbSBsYXlv dXRfcGFja2FnZSBpbXBvcnQgdGVzdF9yZXN1bHRzCiBmcm9tIGxheW91dF9wYWNrYWdlIGltcG9y dCB0ZXN0X3Jlc3VsdHNfdXBsb2FkZXIKIGZyb20gdGVzdF90eXBlcyBpbXBvcnQgaW1hZ2VfZGlm ZgorZnJvbSB0ZXN0X3R5cGVzIGltcG9ydCByZWZlcmVuY2VfZGlmZgogZnJvbSB0ZXN0X3R5cGVz IGltcG9ydCB0ZXh0X2RpZmYKIGZyb20gdGVzdF90eXBlcyBpbXBvcnQgdGVzdF90eXBlX2Jhc2UK IApAQCAtMTA1LDYgKzEwNiwyNCBAQCBjbGFzcyBUZXN0SW5mbzoKICAgICAgICAgc2VsZi50aW1l b3V0ID0gdGltZW91dAogICAgICAgICBzZWxmLl9pbWFnZV9jaGVja3N1bSA9IC0xCiAKKyAgICAg ICAgIyBGSVhNRTogRGV0ZWN0IGFuZCByZXBvcnQgYW4gdGVzdCB3aGljaCBoYXMgYSB3cm9uZyBj b21iaW5hdGlvbiBvZgorICAgICAgICAjIGV4cGVjdGF0aW9uIGZpbGVzLiBGb3IgZXhhbXBsZSwg aWYgJ2Zvby5odG1sJyBoYXMgdHdvIGV4cGVjdGF0aW9uIGZpbGVzLAorICAgICAgICAjICdmb28t ZXhwZWN0ZWQuaHRtbCcgYW5kICdmb28tZXhwZWN0ZWQudHh0Jywgd2Ugc2hvdWxkIHdhcm4gdXNl cnMuCisgICAgICAgIHNlbGYuaXNfcmVmdGVzdCA9IEZhbHNlCisgICAgICAgIGV4cGVjdGVkX2h0 bWxfZmlsZW5hbWUgPSBwb3J0LmV4cGVjdGVkX2h0bWxfZmlsZW5hbWUoZmlsZW5hbWUpCisgICAg ICAgIGlmIG9zLnBhdGguaXNmaWxlKGV4cGVjdGVkX2h0bWxfZmlsZW5hbWUpOgorICAgICAgICAg ICAgc2VsZi5pc19yZWZ0ZXN0ID0gVHJ1ZQorICAgICAgICAgICAgc2VsZi5leHBlY3RlZF9odG1s X2ZpbGVuYW1lID0gZXhwZWN0ZWRfaHRtbF9maWxlbmFtZQorICAgICAgICBlbHNlOgorICAgICAg ICAgICAgc2VsZi5leHBlY3RlZF9odG1sX2ZpbGVuYW1lID0gTm9uZQorCisgICAgICAgIGV4cGVj dGVkX21pc21hdGNoX2h0bWxfZmlsZW5hbWUgPSBwb3J0LmV4cGVjdGVkX21pc21hdGNoX2h0bWxf ZmlsZW5hbWUoZmlsZW5hbWUpCisgICAgICAgIGlmIG9zLnBhdGguaXNmaWxlKGV4cGVjdGVkX21p c21hdGNoX2h0bWxfZmlsZW5hbWUpOgorICAgICAgICAgICAgc2VsZi5pc19yZWZ0ZXN0ID0gVHJ1 ZQorICAgICAgICAgICAgc2VsZi5leHBlY3RlZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1lID0gZXhw ZWN0ZWRfbWlzbWF0Y2hfaHRtbF9maWxlbmFtZQorICAgICAgICBlbHNlOgorICAgICAgICAgICAg c2VsZi5leHBlY3RlZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1lID0gTm9uZQorCiAgICAgZGVmIGlt YWdlX2hhc2goc2VsZik6CiAgICAgICAgICMgUmVhZCB0aGUgaW1hZ2VfaGFzaCBsYXppbHkgdG8g cmVkdWNlIHN0YXJ0dXAgdGltZS4KICAgICAgICAgIyBUaGlzIGNsYXNzIGlzIGFjY2Vzc2VkIGFj cm9zcyB0aHJlYWRzLCBidXQgb25seSBvbmUgdGhyZWFkIHNob3VsZApAQCAtMjcxLDYgKzI5MCwx MCBAQCBjbGFzcyBUZXN0UnVubmVyOgogICAgICAgICBpZiBvcHRpb25zLnBpeGVsX3Rlc3RzOgog ICAgICAgICAgICAgc2VsZi5fdGVzdF90eXBlcy5hcHBlbmQoaW1hZ2VfZGlmZi5JbWFnZURpZmYp CiAKKyAgICAgICAgc2VsZi5fcmVmdGVzdF90eXBlcyA9IFtdCisgICAgICAgIGlmIG9wdGlvbnMu cnVuX3JlZnRlc3RzOgorICAgICAgICAgICAgc2VsZi5fcmVmdGVzdF90eXBlcy5hcHBlbmQocmVm ZXJlbmNlX2RpZmYuUmVmZXJlbmNlRGlmZikKKwogICAgICAgICAjIGEgc2V0IG9mIHRlc3QgZmls ZXMsIGFuZCB0aGUgc2FtZSB0ZXN0cyBhcyBhIGxpc3QKICAgICAgICAgc2VsZi5fdGVzdF9maWxl cyA9IHNldCgpCiAgICAgICAgIHNlbGYuX3Rlc3RfZmlsZXNfbGlzdCA9IE5vbmUKQEAgLTUzMiw2 ICs1NTUsOCBAQCBjbGFzcyBUZXN0UnVubmVyOgogICAgICAgICAgICAgc2VsZi5faXNfc2luZ2xl X3RocmVhZGVkKCkpOgogICAgICAgICAgICAgZm9yIHRlc3RfZmlsZSBpbiB0ZXN0X2ZpbGVzOgog ICAgICAgICAgICAgICAgIHRlc3RfaW5mbyA9IHNlbGYuX2dldF90ZXN0X2luZm9fZm9yX2ZpbGUo dGVzdF9maWxlKQorICAgICAgICAgICAgICAgIGlmIG5vdCBzZWxmLl9vcHRpb25zLnJ1bl9yZWZ0 ZXN0cyBhbmQgdGVzdF9pbmZvLmlzX3JlZnRlc3Q6CisgICAgICAgICAgICAgICAgICAgIGNvbnRp bnVlCiAgICAgICAgICAgICAgICAgaWYgc2VsZi5fdGVzdF9yZXF1aXJlc19sb2NrKHRlc3RfZmls ZSk6CiAgICAgICAgICAgICAgICAgICAgIHRlc3RzX3RvX2h0dHBfbG9jay5hcHBlbmQodGVzdF9p bmZvKQogICAgICAgICAgICAgICAgIGVsc2U6CkBAIC01NDEsNiArNTY2LDkgQEAgY2xhc3MgVGVz dFJ1bm5lcjoKICAgICAgICAgICAgIGZvciB0ZXN0X2ZpbGUgaW4gdGVzdF9maWxlczoKICAgICAg ICAgICAgICAgICBkaXJlY3RvcnkgPSBzZWxmLl9nZXRfZGlyX2Zvcl90ZXN0X2ZpbGUodGVzdF9m aWxlKQogICAgICAgICAgICAgICAgIHRlc3RfaW5mbyA9IHNlbGYuX2dldF90ZXN0X2luZm9fZm9y X2ZpbGUodGVzdF9maWxlKQorCisgICAgICAgICAgICAgICAgaWYgbm90IHNlbGYuX29wdGlvbnMu cnVuX3JlZnRlc3RzIGFuZCB0ZXN0X2luZm8uaXNfcmVmdGVzdDoKKyAgICAgICAgICAgICAgICAg ICAgY29udGludWUKICAgICAgICAgICAgICAgICBpZiBzZWxmLl90ZXN0X3JlcXVpcmVzX2xvY2so dGVzdF9maWxlKToKICAgICAgICAgICAgICAgICAgICAgdGVzdHNfdG9faHR0cF9sb2NrLmFwcGVu ZCh0ZXN0X2luZm8pCiAgICAgICAgICAgICAgICAgZWxzZToKQEAgLTU3Nyw3ICs2MDUsNyBAQCBj bGFzcyBUZXN0UnVubmVyOgogICAgICAgICAiIiJSZXR1cm5zIHRoZSB0dXBsZSBvZiBhcmd1bWVu dHMgZm9yIHRlc3RzIGFuZCBmb3IgRHVtcFJlbmRlclRyZWUuIiIiCiAgICAgICAgIHRlc3RfYXJn cyA9IHRlc3RfdHlwZV9iYXNlLlRlc3RBcmd1bWVudHMoKQogICAgICAgICB0ZXN0X2FyZ3MucG5n X3BhdGggPSBOb25lCi0gICAgICAgIGlmIHNlbGYuX29wdGlvbnMucGl4ZWxfdGVzdHM6CisgICAg ICAgIGlmIHNlbGYuX29wdGlvbnMucGl4ZWxfdGVzdHMgb3Igc2VsZi5fb3B0aW9ucy5ydW5fcmVm dGVzdHM6CiAgICAgICAgICAgICBwbmdfcGF0aCA9IG9zLnBhdGguam9pbihzZWxmLl9vcHRpb25z LnJlc3VsdHNfZGlyZWN0b3J5LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg InBuZ19yZXN1bHQlcy5wbmciICUgaW5kZXgpCiAgICAgICAgICAgICB0ZXN0X2FyZ3MucG5nX3Bh dGggPSBwbmdfcGF0aApAQCAtNjA1LDE1ICs2MzMsMTUgQEAgY2xhc3MgVGVzdFJ1bm5lcjoKICAg ICAgICAgdGhyZWFkcyA9IFtdCiAgICAgICAgIGZvciBpIGluIHhyYW5nZShpbnQoc2VsZi5fb3B0 aW9ucy5jaGlsZF9wcm9jZXNzZXMpKToKICAgICAgICAgICAgICMgQ3JlYXRlIHNlcGFyYXRlIFRl c3RUeXBlcyBpbnN0YW5jZXMgZm9yIGVhY2ggdGhyZWFkLgotICAgICAgICAgICAgdGVzdF90eXBl cyA9IFtdCi0gICAgICAgICAgICBmb3IgdGVzdF90eXBlIGluIHNlbGYuX3Rlc3RfdHlwZXM6Ci0g ICAgICAgICAgICAgICAgdGVzdF90eXBlcy5hcHBlbmQodGVzdF90eXBlKHNlbGYuX3BvcnQsCi0g ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxmLl9vcHRpb25zLnJlc3VsdHNf ZGlyZWN0b3J5KSkKKyAgICAgICAgICAgIHRlc3RfdHlwZXMgPSBbdGVzdF90eXBlKHNlbGYuX3Bv cnQsIHNlbGYuX29wdGlvbnMucmVzdWx0c19kaXJlY3RvcnkpCisgICAgICAgICAgICAgICAgICAg ICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gc2VsZi5fdGVzdF90eXBlc10KKyAgICAgICAgICAgIHJl ZnRlc3RfdHlwZXMgPSBbdGVzdF90eXBlKHNlbGYuX3BvcnQsIHNlbGYuX29wdGlvbnMucmVzdWx0 c19kaXJlY3RvcnkpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZvciB0ZXN0X3R5cGUg aW4gc2VsZi5fcmVmdGVzdF90eXBlc10KIAogICAgICAgICAgICAgdGVzdF9hcmdzID0gc2VsZi5f Z2V0X3Rlc3RfYXJncyhpKQogICAgICAgICAgICAgdGhyZWFkID0gZHVtcF9yZW5kZXJfdHJlZV90 aHJlYWQuVGVzdFNoZWxsVGhyZWFkKHNlbGYuX3BvcnQsCiAgICAgICAgICAgICAgICAgc2VsZi5f b3B0aW9ucywgZmlsZW5hbWVfcXVldWUsIHNlbGYuX3Jlc3VsdF9xdWV1ZSwKLSAgICAgICAgICAg ICAgICB0ZXN0X3R5cGVzLCB0ZXN0X2FyZ3MpCisgICAgICAgICAgICAgICAgdGVzdF90eXBlcywg cmVmdGVzdF90eXBlcywgdGVzdF9hcmdzKQogICAgICAgICAgICAgaWYgc2VsZi5faXNfc2luZ2xl X3RocmVhZGVkKCk6CiAgICAgICAgICAgICAgICAgdGhyZWFkLnJ1bl9pbl9tYWluX3RocmVhZChz ZWxmLCByZXN1bHRfc3VtbWFyeSkKICAgICAgICAgICAgIGVsc2U6CkBAIC0xMDc3LDIzICsxMTA1 LDE3IEBAIGNsYXNzIFRlc3RSdW5uZXI6CiAgICAgICAgICAgaW5kaXZpZHVhbF90ZXN0X3RpbWlu Z3M6IExpc3Qgb2YgZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQuVGVzdFN0YXRzCiAgICAgICAgICAg ICAgIGZvciBhbGwgdGVzdHMuCiAgICAgICAgICIiIgotICAgICAgICB0ZXN0X3R5cGVzID0gW10g ICMgVW5pdCB0ZXN0cyBkb24ndCBhY3R1YWxseSBwcm9kdWNlIGFueSB0aW1pbmdzLgotICAgICAg ICBpZiBpbmRpdmlkdWFsX3Rlc3RfdGltaW5nczoKLSAgICAgICAgICAgIHRlc3RfdHlwZXMgPSBp bmRpdmlkdWFsX3Rlc3RfdGltaW5nc1swXS50aW1lX2Zvcl9kaWZmcy5rZXlzKCkKICAgICAgICAg dGltZXNfZm9yX2R1bXBfcmVuZGVyX3RyZWUgPSBbXQogICAgICAgICB0aW1lc19mb3JfZGlmZl9w cm9jZXNzaW5nID0gW10KICAgICAgICAgdGltZXNfcGVyX3Rlc3RfdHlwZSA9IHt9Ci0gICAgICAg IGZvciB0ZXN0X3R5cGUgaW4gdGVzdF90eXBlczoKLSAgICAgICAgICAgIHRpbWVzX3Blcl90ZXN0 X3R5cGVbdGVzdF90eXBlXSA9IFtdCiAKICAgICAgICAgZm9yIHRlc3Rfc3RhdHMgaW4gaW5kaXZp ZHVhbF90ZXN0X3RpbWluZ3M6CiAgICAgICAgICAgICB0aW1lc19mb3JfZHVtcF9yZW5kZXJfdHJl ZS5hcHBlbmQodGVzdF9zdGF0cy50ZXN0X3J1bl90aW1lKQogICAgICAgICAgICAgdGltZXNfZm9y X2RpZmZfcHJvY2Vzc2luZy5hcHBlbmQoCiAgICAgICAgICAgICAgICAgdGVzdF9zdGF0cy50b3Rh bF90aW1lX2Zvcl9hbGxfZGlmZnMpCiAgICAgICAgICAgICB0aW1lX2Zvcl9kaWZmcyA9IHRlc3Rf c3RhdHMudGltZV9mb3JfZGlmZnMKLSAgICAgICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gdGVzdF90 eXBlczoKLSAgICAgICAgICAgICAgICB0aW1lc19wZXJfdGVzdF90eXBlW3Rlc3RfdHlwZV0uYXBw ZW5kKAotICAgICAgICAgICAgICAgICAgICB0aW1lX2Zvcl9kaWZmc1t0ZXN0X3R5cGVdKQorICAg ICAgICAgICAgZm9yIHRlc3RfdHlwZSwgdGltZSBpbiB0aW1lX2Zvcl9kaWZmcy5pdGVyaXRlbXMo KToKKyAgICAgICAgICAgICAgICB0aW1lc19wZXJfdGVzdF90eXBlLmdldCh0ZXN0X3R5cGUsIFtd KS5hcHBlbmQodGltZSkKIAogICAgICAgICBzZWxmLl9wcmludF9zdGF0aXN0aWNzX2Zvcl90ZXN0 X3RpbWluZ3MoCiAgICAgICAgICAgICAiUEVSIFRFU1QgVElNRSBJTiBURVNUU0hFTEwgKHNlY29u ZHMpOiIsCkBAIC0xMTAxLDEwICsxMTIzLDkgQEAgY2xhc3MgVGVzdFJ1bm5lcjoKICAgICAgICAg c2VsZi5fcHJpbnRfc3RhdGlzdGljc19mb3JfdGVzdF90aW1pbmdzKAogICAgICAgICAgICAgIlBF UiBURVNUIERJRkYgUFJPQ0VTU0lORyBUSU1FUyAoc2Vjb25kcyk6IiwKICAgICAgICAgICAgIHRp bWVzX2Zvcl9kaWZmX3Byb2Nlc3NpbmcpCi0gICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gdGVzdF90 eXBlczoKKyAgICAgICAgZm9yIHRlc3RfdHlwZSwgdGltZSBpbiB0aW1lc19wZXJfdGVzdF90eXBl Lml0ZXJpdGVtcygpOgogICAgICAgICAgICAgc2VsZi5fcHJpbnRfc3RhdGlzdGljc19mb3JfdGVz dF90aW1pbmdzKAotICAgICAgICAgICAgICAgICJQRVIgVEVTVCBUSU1FUyBCWSBURVNUIFRZUEU6 ICVzIiAlIHRlc3RfdHlwZSwKLSAgICAgICAgICAgICAgICB0aW1lc19wZXJfdGVzdF90eXBlW3Rl c3RfdHlwZV0pCisgICAgICAgICAgICAgICAgIlBFUiBURVNUIFRJTUVTIEJZIFRFU1QgVFlQRTog JXMiICUgdGVzdF90eXBlLCB0aW1lKQogCiAgICAgZGVmIF9wcmludF9pbmRpdmlkdWFsX3Rlc3Rf dGltZXMoc2VsZiwgaW5kaXZpZHVhbF90ZXN0X3RpbWluZ3MsCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgcmVzdWx0X3N1bW1hcnkpOgpAQCAtMTY4OSw2ICsxNzEwLDkgQEAgZGVm IHBhcnNlX2FyZ3MoYXJncz1Ob25lKToKICAgICAgICAgb3B0cGFyc2UubWFrZV9vcHRpb24oIi0t bm8tcmV0cnktZmFpbHVyZXMiLCBhY3Rpb249InN0b3JlX2ZhbHNlIiwKICAgICAgICAgICAgIGRl c3Q9InJldHJ5X2ZhaWx1cmVzIiwKICAgICAgICAgICAgIGhlbHA9IkRvbid0IHJlLXRyeSBhbnkg dGVzdHMgdGhhdCBwcm9kdWNlIHVuZXhwZWN0ZWQgcmVzdWx0cy4iKSwKKyAgICAgICAgb3B0cGFy c2UubWFrZV9vcHRpb24oIi0tcnVuLXJlZnRlc3RzIiwgYWN0aW9uPSJzdG9yZV90cnVlIiwKKyAg ICAgICAgICAgIGhlbHA9KCJSdW4gYWxzbyByZWZ0ZXN0cyAoZXhwZXJpbWVudGFsKS4gRG9uJ3Qg Y29tbWl0IGFueSByZWZ0ZXN0cyAiCisgICAgICAgICAgICAgICAgICAidG8gYSByZXBvc2l0cnkg dW50aWwgcmVmdGVzdHMgaXMgZnVsbHkgc3VwcG9ydGVkLiIpKSwKICAgICBdCiAKICAgICBtaXNj X29wdGlvbnMgPSBbCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy90ZXN0X3R5cGVzL2ltYWdlX2RpZmYucHkgYi9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL2ltYWdlX2RpZmYucHkKaW5kZXggMGIw NTgwMjBjMDhmNGY1MWMxMTYyMDRkYzU0Y2JmNWQ5YzNlN2M2Zi4uZTg4YTY4NDc5NDdjYjlhM2I3 MGRkMTRhNzlkOTlkYzhlNzhkMzdhZSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93 ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90eXBlcy9pbWFnZV9kaWZmLnB5CisrKyBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvaW1hZ2VfZGlm Zi5weQpAQCAtNTQsMjEgKzU0LDYgQEAgX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRw eS5sYXlvdXRfdGVzdHMudGVzdF90eXBlcy5pbWFnZV9kaWZmIikKIAogY2xhc3MgSW1hZ2VEaWZm KHRlc3RfdHlwZV9iYXNlLlRlc3RUeXBlQmFzZSk6CiAKLSAgICBkZWYgX2NvcHlfb3V0cHV0X3Bu ZyhzZWxmLCB0ZXN0X2ZpbGVuYW1lLCBzb3VyY2VfaW1hZ2UsIGV4dGVuc2lvbik6Ci0gICAgICAg ICIiIkNvcGllcyByZXN1bHQgZmlsZXMgaW50byB0aGUgb3V0cHV0IGRpcmVjdG9yeSB3aXRoIGFw cHJvcHJpYXRlCi0gICAgICAgIG5hbWVzLgotCi0gICAgICAgIEFyZ3M6Ci0gICAgICAgICAgdGVz dF9maWxlbmFtZTogdGhlIHRlc3QgZmlsZW5hbWUKLSAgICAgICAgICBzb3VyY2VfZmlsZTogcGF0 aCB0byB0aGUgaW1hZ2UgZmlsZSAoZWl0aGVyIGFjdHVhbCBvciBleHBlY3RlZCkKLSAgICAgICAg ICBleHRlbnNpb246IGV4dGVuc2lvbiB0byBpbmRpY2F0ZSAtYWN0dWFsLnBuZyBvciAtZXhwZWN0 ZWQucG5nCi0gICAgICAgICIiIgotICAgICAgICBzZWxmLl9tYWtlX291dHB1dF9kaXJlY3Rvcnko dGVzdF9maWxlbmFtZSkKLSAgICAgICAgZGVzdF9pbWFnZSA9IHNlbGYub3V0cHV0X2ZpbGVuYW1l KHRlc3RfZmlsZW5hbWUsIGV4dGVuc2lvbikKLQotICAgICAgICBpZiBvcy5wYXRoLmV4aXN0cyhz b3VyY2VfaW1hZ2UpOgotICAgICAgICAgICAgc2h1dGlsLmNvcHlmaWxlKHNvdXJjZV9pbWFnZSwg ZGVzdF9pbWFnZSkKLQogICAgIGRlZiBfc2F2ZV9iYXNlbGluZV9maWxlcyhzZWxmLCBmaWxlbmFt ZSwgcG5nX3BhdGgsIGNoZWNrc3VtLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBnZW5l cmF0ZV9uZXdfYmFzZWxpbmUpOgogICAgICAgICAiIiJTYXZlcyBuZXcgYmFzZWxpbmVzIGZvciB0 aGUgUE5HIGFuZCBjaGVja3N1bS4KQEAgLTEzNyw3ICsxMjIsOCBAQCBjbGFzcyBJbWFnZURpZmYo dGVzdF90eXBlX2Jhc2UuVGVzdFR5cGVCYXNlKToKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHRlc3RfYXJncy5oYXNoLCBleHBlY3RlZF9oYXNoLAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZW5jb2Rpbmc9ImFzY2lpIiwKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHByaW50X3RleHRfZGlmZnM9RmFsc2UpCi0gICAgICAgICAgICBz ZWxmLl9jb3B5X291dHB1dF9wbmcoZmlsZW5hbWUsIHRlc3RfYXJncy5wbmdfcGF0aCwgJy1hY3R1 YWwucG5nJykKKyAgICAgICAgICAgIHNlbGYuX2NvcHlfb3V0cHV0X3RvX3Jlc3VsdF9kaXJlY3Rv cnkoZmlsZW5hbWUsIHRlc3RfYXJncy5wbmdfcGF0aCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgJy1hY3R1YWwucG5nJykKICAgICAgICAgICAgIGZh aWx1cmVzLmFwcGVuZCh0ZXN0X2ZhaWx1cmVzLkZhaWx1cmVNaXNzaW5nSW1hZ2UoKSkKICAgICAg ICAgICAgIHJldHVybiBmYWlsdXJlcwogICAgICAgICBlbGlmIHRlc3RfYXJncy5oYXNoID09IGV4 cGVjdGVkX2hhc2g6CkBAIC0xNTAsNyArMTM2LDggQEAgY2xhc3MgSW1hZ2VEaWZmKHRlc3RfdHlw ZV9iYXNlLlRlc3RUeXBlQmFzZSk6CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBy aW50X3RleHRfZGlmZnM9RmFsc2UpCiAKICAgICAgICAgIyBGSVhNRTogY29tYmluZSBuZXh0IHR3 byBsaW5lcwotICAgICAgICBzZWxmLl9jb3B5X291dHB1dF9wbmcoZmlsZW5hbWUsIHRlc3RfYXJn cy5wbmdfcGF0aCwgJy1hY3R1YWwucG5nJykKKyAgICAgICAgc2VsZi5fY29weV9vdXRwdXRfdG9f cmVzdWx0X2RpcmVjdG9yeShmaWxlbmFtZSwgdGVzdF9hcmdzLnBuZ19wYXRoLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICctYWN0dWFsLnBuZycpCiAgICAg ICAgIHNlbGYud3JpdGVfb3V0cHV0X2ZpbGVzKGZpbGVuYW1lLCAnLnBuZycsIG91dHB1dD1Ob25l LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBleHBlY3RlZD1leHBlY3RlZF9wbmcs CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVuY29kaW5nPU5vbmUsIHByaW50X3Rl eHRfZGlmZnM9RmFsc2UpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL3JlZmVyZW5jZV9kaWZmLnB5IGIvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90eXBlcy9yZWZlcmVuY2VfZGlmZi5w eQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi41NmU2Mzk2MDE5NGViZDEzNGMxZThmZjU1MzQ3NmU0YjNhMDA3OTZiCi0t LSAvZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvdGVzdF90eXBlcy9yZWZlcmVuY2VfZGlmZi5weQpAQCAtMCwwICsxLDg5IEBACisjIS91c3Iv YmluL2VudiBweXRob24KKyMgQ29weXJpZ2h0IChDKSAyMDEwIEdvb2dsZSBJbmMuIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisjIG1ldDoKKyMK KyMgICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyMgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisjIGNvcHlyaWdodCBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyMgaW4gdGhl IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQor IyBkaXN0cmlidXRpb24uCisjICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xlIEluYy4g bm9yIHRoZSBuYW1lcyBvZiBpdHMKKyMgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9y c2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyMgdGhpcyBzb2Z0d2FyZSB3aXRo b3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyMKKyMgVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUwor IyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElO RywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyMgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyMgT1dORVIgT1IgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws CisjIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisjIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lO RVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorIyBUSEVPUlkgT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU CisjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdB WSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorCisiIiJDb21wYXJlcyB0aGUgaW1hZ2Ug b3V0cHV0IG9mIGEgdGVzdCB0byB0aGUgaW1hZ2Ugb3V0cHV0IG9mIGEgcmVmZXJlbmNlIGZpbGUu CisiIiIKKworZnJvbSBfX2Z1dHVyZV9fIGltcG9ydCB3aXRoX3N0YXRlbWVudAorCitpbXBvcnQg bG9nZ2luZworCitmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0cy5sYXlvdXRfcGFja2FnZSBpbXBv cnQgdGVzdF9mYWlsdXJlcworZnJvbSB3ZWJraXRweS5sYXlvdXRfdGVzdHMudGVzdF90eXBlcyBp bXBvcnQgdGVzdF90eXBlX2Jhc2UKKworX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRw eS5sYXlvdXRfdGVzdHMudGVzdF90eXBlcy5yZWZlcmVuY2VfZGlmZiIpCisKKworY2xhc3MgUmVm ZXJlbmNlRGlmZih0ZXN0X3R5cGVfYmFzZS5UZXN0VHlwZUJhc2UpOgorCisgICAgZGVmIGNvbXBh cmVfb3V0cHV0X3dpdGhfcmVmZXJlbmNlKHNlbGYsIHBvcnQsIHRlc3RfaW5mbywKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYWN0dWFsX2ltYWdlX2hhc2gsIGFjdHVhbF9p bWFnZV9jb250ZW50cywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVm ZXJlbmNlX2ltYWdlX2hhc2gsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHJlZmVyZW5jZV9pbWFnZV9jb250ZW50cyk6CisgICAgICAgIGZhaWx1cmVzID0gW10KKyAgICAg ICAgaWYgdGVzdF9pbmZvLmV4cGVjdGVkX2h0bWxfZmlsZW5hbWU6CisgICAgICAgICAgICBpZiBh Y3R1YWxfaW1hZ2VfaGFzaCA9PSByZWZlcmVuY2VfaW1hZ2VfaGFzaDoKKyAgICAgICAgICAgICAg ICByZXR1cm4gZmFpbHVyZXMKKyAgICAgICAgICAgIGZhaWx1cmVzLmFwcGVuZCh0ZXN0X2ZhaWx1 cmVzLkZhaWx1cmVSZWZlcmVuY2VNaXNtYXRjaCgpKQorCisgICAgICAgICAgICBkaWZmX2ZpbGVu YW1lID0gc2VsZi5vdXRwdXRfZmlsZW5hbWUodGVzdF9pbmZvLmZpbGVuYW1lLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYuRklMRU5BTUVfU1VG RklYX0NPTVBBUkUpCisgICAgICAgICAgICAjIFNldCB0b2xlcmFuY2UgdG8gJ3plcm8nIHRvIGRl dGVjdCBhbnkgZGlmZmVyZW5jZXMuCisgICAgICAgICAgICBwb3J0LmRpZmZfaW1hZ2UocmVmZXJl bmNlX2ltYWdlX2NvbnRlbnRzLCBhY3R1YWxfaW1hZ2VfY29udGVudHMsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgZGlmZl9maWxlbmFtZSwgdG9sZXJhbmNlPTApCisKKyAgICAgICAgICAg ICMgQ29weSBmaWxlcyBmb3IgbGF0ZXIgcmVwb3J0aW5nLgorICAgICAgICAgICAgc2VsZi5fY29w eV9vdXRwdXRfdG9fcmVzdWx0X2RpcmVjdG9yeSgKKyAgICAgICAgICAgICAgICB0ZXN0X2luZm8u ZmlsZW5hbWUsCisgICAgICAgICAgICAgICAgdGVzdF9pbmZvLmV4cGVjdGVkX2h0bWxfZmlsZW5h bWUsCisgICAgICAgICAgICAgICAgJy1leHBlY3RlZC5odG1sJykKKyAgICAgICAgICAgIHNlbGYu d3JpdGVfb3V0cHV0X2ZpbGVzKHRlc3RfaW5mby5maWxlbmFtZSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGZpbGVfdHlwZT0nLnBuZycsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBvdXRwdXQ9YWN0dWFsX2ltYWdlX2NvbnRlbnRzLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgZXhwZWN0ZWQ9cmVmZXJlbmNlX2ltYWdlX2NvbnRl bnRzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZW5jb2Rpbmc9Tm9uZSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHByaW50X3RleHRfZGlmZnM9RmFs c2UpCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBhc3NlcnQgdGVzdF9pbmZvLmV4cGVjdGVk X21pc21hdGNoX2h0bWxfZmlsZW5hbWUKKyAgICAgICAgICAgIGlmIGFjdHVhbF9pbWFnZV9oYXNo ICE9IHJlZmVyZW5jZV9pbWFnZV9oYXNoOgorICAgICAgICAgICAgICAgIHJldHVybiBmYWlsdXJl cworICAgICAgICAgICAgZmFpbHVyZXMuYXBwZW5kKHRlc3RfZmFpbHVyZXMuRmFpbHVyZVJlZmVy ZW5jZU1hdGNoKCkpCisKKyAgICAgICAgICAgICMgQ29weSBmaWxlcyBmb3IgbGF0ZXIgcmVwb3J0 aW5nLgorICAgICAgICAgICAgc2VsZi5fY29weV9vdXRwdXRfdG9fcmVzdWx0X2RpcmVjdG9yeSgK KyAgICAgICAgICAgICAgICB0ZXN0X2luZm8uZmlsZW5hbWUsCisgICAgICAgICAgICAgICAgdGVz dF9pbmZvLmV4cGVjdGVkX21pc21hdGNoX2h0bWxfZmlsZW5hbWUsCisgICAgICAgICAgICAgICAg Jy1leHBlY3RlZC1taXNtYXRjaC5odG1sJykKKyAgICAgICAgICAgIHNlbGYud3JpdGVfb3V0cHV0 X2ZpbGVzKHRlc3RfaW5mby5maWxlbmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGZpbGVfdHlwZT0nLnBuZycsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBvdXRwdXQ9YWN0dWFsX2ltYWdlX2NvbnRlbnRzLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgZXhwZWN0ZWQ9Tm9uZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGVuY29kaW5nPU5vbmUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBwcmludF90ZXh0X2RpZmZzPUZhbHNlKQorICAgICAgICByZXR1cm4gZmFpbHVyZXMKZGlm ZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Rlc3Rf dHlwZXMvdGVzdF90eXBlX2Jhc2UucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xh eW91dF90ZXN0cy90ZXN0X3R5cGVzL3Rlc3RfdHlwZV9iYXNlLnB5CmluZGV4IGRjYzY0YTM1YjMz OWRmOTg4MGFhYzA1MzhmN2U4NTU5NzI1ODBiMTMuLjM5ZjAxZWQ3ODdiMjdhNzllNzdmMjJjMWZi N2I0MWMzMTEzOTQ3NGMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvdGVzdF90eXBlX2Jhc2UucHkKKysrIGIvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90eXBlcy90ZXN0X3R5cGVfYmFz ZS5weQpAQCAtMzksNiArMzksNyBAQCBpbXBvcnQgY2dpCiBpbXBvcnQgZXJybm8KIGltcG9ydCBs b2dnaW5nCiBpbXBvcnQgb3MucGF0aAoraW1wb3J0IHNodXRpbAogCiBfbG9nID0gbG9nZ2luZy5n ZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy50ZXN0X3R5cGVzLnRlc3RfdHlwZV9iYXNl IikKIApAQCAtOTAsNiArOTEsMjMgQEAgY2xhc3MgVGVzdFR5cGVCYXNlKG9iamVjdCk6CiAgICAg ICAgICAgICBzZWxmLl9wb3J0LnJlbGF0aXZlX3Rlc3RfZmlsZW5hbWUoZmlsZW5hbWUpKQogICAg ICAgICBzZWxmLl9wb3J0Lm1heWJlX21ha2VfZGlyZWN0b3J5KG9zLnBhdGguc3BsaXQob3V0cHV0 X2ZpbGVuYW1lKVswXSkKIAorICAgIGRlZiBfY29weV9vdXRwdXRfdG9fcmVzdWx0X2RpcmVjdG9y eShzZWxmLCB0ZXN0X2ZpbGVuYW1lLCBzb3VyY2VfZmlsZW5hbWUsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGRlc3RpbmF0aW9uX2V4dGVuc2lvbik6CisgICAgICAg ICIiIkNvcGllcyByZXN1bHQgZmlsZXMgaW50byB0aGUgb3V0cHV0IGRpcmVjdG9yeSB3aXRoIGFw cHJvcHJpYXRlCisgICAgICAgIG5hbWVzLgorCisgICAgICAgIEFyZ3M6CisgICAgICAgICAgdGVz dF9maWxlbmFtZTogdGhlIHRlc3QgZmlsZW5hbWUKKyAgICAgICAgICBzb3VyY2VfZmlsZW5hbWU6 IHBhdGggdG8gdGhlIHNvdXJjZSBmaWxlIChlaXRoZXIgYWN0dWFsIG9yIGV4cGVjdGVkKQorICAg ICAgICAgIGRlc3RpbnRpb25fZXh0ZW5zaW9uOiBleHRlbnNpb24gdXNlZCBpbiBkZXN0aW5hdGlv bidzIGZpbGVuYW1lLgorICAgICAgICAiIiIKKyAgICAgICAgc2VsZi5fbWFrZV9vdXRwdXRfZGly ZWN0b3J5KHRlc3RfZmlsZW5hbWUpCisgICAgICAgIGRlc3RfZmlsZW5hbWUgPSBzZWxmLm91dHB1 dF9maWxlbmFtZSh0ZXN0X2ZpbGVuYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgZGVzdGluYXRpb25fZXh0ZW5zaW9uKQorCisgICAgICAgIGlmIG9zLnBh dGguZXhpc3RzKHNvdXJjZV9maWxlbmFtZSk6CisgICAgICAgICAgICBzaHV0aWwuY29weWZpbGUo c291cmNlX2ZpbGVuYW1lLCBkZXN0X2ZpbGVuYW1lKQorCiAgICAgZGVmIF9zYXZlX2Jhc2VsaW5l X2RhdGEoc2VsZiwgZmlsZW5hbWUsIGRhdGEsIG1vZGlmaWVyLCBlbmNvZGluZywKICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBnZW5lcmF0ZV9uZXdfYmFzZWxpbmU9VHJ1ZSk6CiAgICAgICAg ICIiIlNhdmVzIGEgbmV3IGJhc2VsaW5lIGZpbGUgaW50byB0aGUgcG9ydCdzIGJhc2VsaW5lIGRp cmVjdG9yeS4K 73060 2010-11-05 06:45:25 -0700 2010-11-09 20:12:45 -0800 for-review bug-36065-20101105224523.patch text/plain 51808 hayato ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCA4NmI2NjI0MzM3M2MzYzI1NTE1MGNmMTgzZmYxMzRmZWUyODQ3ZWM5Li5jZjFmM2Nh NWExZTJiMDdiOTgxNjJmMjI5MTUxNjRjMjMyMmE3ZWQxIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQgQEAK KzIwMTAtMTEtMDQgIEhheWF0byBJdG8gIDxoYXlhdG9AY2hyb21pdW0ub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBzdXBwb3J0IFJlZmVy ZW5jZSBUZXN0cyAoYWthIHJlZnRlc3RzKSB0byBleGlzdGluZyBMYXlvdXQgVGVzdCBoYXJuZXNz LgorCisgICAgICAgIEFuIGluaXRpYWwgZWZmb3J0IHRvIHN1cHBvcnQgcmVmdGVzdHMuIFJlZnRl c3RzIHN1cHBvcnQgaXMgYW4gZXhwZXJpbWVudGFsCisgICAgICAgIGFuZCBpcyBub3QgcHJvZHVj dGlvbi1yZWFkeSB5ZXQuCisKKyAgICAgICAgWW91IGNhbiBydW4gcmVmdGVzdHMgYnkgdXNpbmcg b3B0aW9uICctLXJ1bi1yZWZ0ZXN0Jy4KKworICAgICAgICBBIHJlZmVyZW5jZSBodG1sIGZpbGUg aXMgbmFtZWQgJ3h4eC1leHBlY3RlZC5odG1sJyBpZiBhIHRlc3QgaXMgZXhwZWN0ZWQKKyAgICAg ICAgdG8gbWF0Y2ggdGhlIHJlZmVyZW5jZSwgb3IgJ3h4eC1leHBlY3RlZC1taXNtYXRjaC5odG1s JyBpZiBhIHRlc3QgaXMKKyAgICAgICAgZXhwZWN0ZWQgbm90IHRvIG1hdGNoIHRoZSByZWZlcmVu Y2UuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM2 MDY1CisKKyAgICAgICAgKiBTY3JpcHRzL29sZC1ydW4td2Via2l0LXRlc3RzOgorICAgICAgICAq IFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2R1bXBfcmVuZGVy X3RyZWVfdGhyZWFkLnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L2xheW91dF9wYWNrYWdlL2pzb25fbGF5b3V0X3Jlc3VsdHNfZ2VuZXJhdG9yLnB5OgorICAgICAg ICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL3NpbmdsZV90 ZXN0X3J1bm5lci5weTogQWRkZWQuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvbGF5b3V0X3BhY2thZ2UvdGVzdF9leHBlY3RhdGlvbnMucHk6CisgICAgICAgICogU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvdGVzdF9mYWlsdXJlcy5w eToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHk6 CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0X2ZpbGVz LnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Via2l0 LnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRf dGVzdHMucHk6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90 eXBlcy9pbWFnZV9kaWZmLnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3Rlc3RfdHlwZXMvcmVmZXJlbmNlX2RpZmYucHk6IEFkZGVkLgorICAgICAgICAqIFNjcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvdGVzdF90eXBlX2Jhc2UucHk6CisK IDIwMTAtMTEtMDMgIEdlb3JnZSBHdW8gIDxHZW9yZ2UuR3VvQE5va2lhLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBBbmRyZWFzIEtsaW5nLgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2Ny aXB0cy9vbGQtcnVuLXdlYmtpdC10ZXN0cyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvb2xkLXJ1bi13 ZWJraXQtdGVzdHMKaW5kZXggMmNlZjE4YjM3YmE2ZTFkZmY3ZDUxNmQxYzY4MjdhNzc5ZjM1MjA2 ZC4uNWY5NmRlM2RmNGQxOWIxYTI0MzQzZjljNjMwMTg2NWJjYjRlMzg2MCAxMDA3NTUKLS0tIGEv V2ViS2l0VG9vbHMvU2NyaXB0cy9vbGQtcnVuLXdlYmtpdC10ZXN0cworKysgYi9XZWJLaXRUb29s cy9TY3JpcHRzL29sZC1ydW4td2Via2l0LXRlc3RzCkBAIC0xODQsNiArMTg0LDcgQEAgJHRlc3RI VFRQID0gMCBpZiAoaXNXeCgpKTsKIG15ICRwZXJsSW50ZXJwcmV0ZXIgPSAicGVybCI7CiAKIG15 ICRleHBlY3RlZFRhZyA9ICJleHBlY3RlZCI7CitteSAkbWlzbWF0Y2hUYWcgPSAibWlzbWF0Y2gi OwogbXkgJGFjdHVhbFRhZyA9ICJhY3R1YWwiOwogbXkgJHByZXR0eURpZmZUYWcgPSAicHJldHR5 LWRpZmYiOwogbXkgJGRpZmZzVGFnID0gImRpZmZzIjsKQEAgLTIyOTIsNiArMjI5MywxNiBAQCBz dWIgcmVhZFNraXBwZWRGaWxlcygkKQogCiBteSBAdGVzdHNGb3VuZDsKIAorc3ViIGlzVXNlZElu UmVmdGVzdAoreworICAgIG15ICRmaWxlbmFtZSA9ICRfOworICAgIGlmICgkZmlsZW5hbWUgPX4g Ly0kZXhwZWN0ZWRUYWcoLSRtaXNtYXRjaFRhZyk/XC5odG1sJC8pIHsKKyAgICAgICAgcmV0dXJu IDE7CisgICAgfQorICAgIG15ICRiYXNlID0gc3RyaXBFeHRlbnNpb24oJGZpbGVuYW1lKTsKKyAg ICByZXR1cm4gKC1mICIkYmFzZS0kZXhwZWN0ZWRUYWcuaHRtbCIgfHwgLWYgIiRiYXNlLSRleHBl Y3RlZFRhZy0kbWlzbWF0Y2hUYWcuaHRtbCIpOworfQorCiBzdWIgZGlyZWN0b3J5RmlsdGVyCiB7 CiAgICAgcmV0dXJuICgpIGlmIGV4aXN0cyAkaWdub3JlZExvY2FsRGlyZWN0b3JpZXN7YmFzZW5h bWUoJEZpbGU6OkZpbmQ6OmRpcil9OwpAQCAtMjMwMyw3ICsyMzE0LDggQEAgc3ViIGZpbGVGaWx0 ZXIKIHsKICAgICBteSAkZmlsZW5hbWUgPSAkXzsKICAgICBpZiAoJGZpbGVuYW1lID1+IC9cLihb Xi5dKykkLykgewotICAgICAgICBpZiAoZXhpc3RzICRzdXBwb3J0ZWRGaWxlRXh0ZW5zaW9uc3sk MX0pIHsKKyAgICAgICAgbXkgJGV4dGVuc2lvbiA9ICQxOworICAgICAgICBpZiAoZXhpc3RzICRz dXBwb3J0ZWRGaWxlRXh0ZW5zaW9uc3skZXh0ZW5zaW9ufSAmJiAhaXNVc2VkSW5SZWZ0ZXN0KCRm aWxlbmFtZSkpIHsKICAgICAgICAgICAgIG15ICRwYXRoID0gRmlsZTo6U3BlYy0+YWJzMnJlbChj YXRmaWxlKCRGaWxlOjpGaW5kOjpkaXIsICRmaWxlbmFtZSksICR0ZXN0RGlyZWN0b3J5KTsKICAg ICAgICAgICAgIHB1c2ggQHRlc3RzRm91bmQsICRwYXRoIGlmICFleGlzdHMgJGlnbm9yZWRGaWxl c3skcGF0aH07CiAgICAgICAgIH0KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2R1bXBfcmVuZGVyX3RyZWVfdGhyZWFk LnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3Bh Y2thZ2UvZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQucHkKaW5kZXggM2UzYmEwYjE2NzcwNDUwMDM2 ZjczMTVhYzE2MWVmMWZiOWI3ZDczNS4uMTQ0YTQ1ZTgwMzc3ZTc1ZDRjYWY0MWI5ZDNiZjFkMmIy Y2I4MTFhYyAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvbGF5b3V0X3BhY2thZ2UvZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQucHkKKysrIGIvV2Vi S2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvZHVt cF9yZW5kZXJfdHJlZV90aHJlYWQucHkKQEAgLTUwLDcgKzUwLDcgQEAgaW1wb3J0IHRocmVhZGlu ZwogaW1wb3J0IHRpbWUKIGltcG9ydCB0cmFjZWJhY2sKIAotaW1wb3J0IHRlc3RfZmFpbHVyZXMK K2ltcG9ydCBzaW5nbGVfdGVzdF9ydW5uZXIKIGltcG9ydCB0ZXN0X3Jlc3VsdHMKIAogX2xvZyA9 IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMubGF5b3V0X3BhY2thZ2Uu IgpAQCAtNzQsNzQgKzc0LDE3IEBAIGRlZiBsb2dfc3RhY2soc3RhY2spOgogICAgICAgICAgICAg X2xvZy5lcnJvcignICAlcycgJSBsaW5lLnN0cmlwKCkpCiAKIAotZGVmIF9wcm9jZXNzX291dHB1 dChwb3J0LCBvcHRpb25zLCB0ZXN0X2luZm8sIHRlc3RfdHlwZXMsIHRlc3RfYXJncywKLSAgICAg ICAgICAgICAgICAgICAgY3Jhc2gsIHRpbWVvdXQsIHRlc3RfcnVuX3RpbWUsIGFjdHVhbF9jaGVj a3N1bSwKLSAgICAgICAgICAgICAgICAgICAgb3V0cHV0LCBlcnJvcik6Ci0gICAgIiIiUmVjZWl2 ZXMgdGhlIG91dHB1dCBmcm9tIGEgRHVtcFJlbmRlclRyZWUgcHJvY2Vzcywgc3ViamVjdHMgaXQg dG8gYQotICAgIG51bWJlciBvZiB0ZXN0cywgYW5kIHJldHVybnMgYSBsaXN0IG9mIGZhaWx1cmUg dHlwZXMgdGhlIHRlc3QgcHJvZHVjZWQuCi0KLSAgICBBcmdzOgotICAgICAgcG9ydDogcG9ydC1z cGVjaWZpYyBob29rcwotICAgICAgb3B0aW9uczogY29tbWFuZCBsaW5lIG9wdGlvbnMgYXJndW1l bnQgZnJvbSBvcHRwYXJzZQotICAgICAgcHJvYzogYW4gYWN0aXZlIER1bXBSZW5kZXJUcmVlIHBy b2Nlc3MKLSAgICAgIHRlc3RfaW5mbzogT2JqZWN0IGNvbnRhaW5pbmcgdGhlIHRlc3QgZmlsZW5h bWUsIHVyaSBhbmQgdGltZW91dAotICAgICAgdGVzdF90eXBlczogbGlzdCBvZiB0ZXN0IHR5cGVz IHRvIHN1YmplY3QgdGhlIG91dHB1dCB0bwotICAgICAgdGVzdF9hcmdzOiBhcmd1bWVudHMgdG8g YmUgcGFzc2VkIHRvIGVhY2ggdGVzdAotCi0gICAgUmV0dXJuczogYSBUZXN0UmVzdWx0IG9iamVj dAotICAgICIiIgotICAgIGZhaWx1cmVzID0gW10KLQotICAgICMgU29tZSB0ZXN0IGFyZ3MsIHN1 Y2ggYXMgdGhlIGltYWdlIGhhc2gsIG1heSBiZSBhZGRlZCBvciBjaGFuZ2VkIG9uIGEKLSAgICAj IHRlc3QtYnktdGVzdCBiYXNpcy4KLSAgICBsb2NhbF90ZXN0X2FyZ3MgPSBjb3B5LmNvcHkodGVz dF9hcmdzKQotCi0gICAgbG9jYWxfdGVzdF9hcmdzLmhhc2ggPSBhY3R1YWxfY2hlY2tzdW0KLQot ICAgIGlmIGNyYXNoOgotICAgICAgICBmYWlsdXJlcy5hcHBlbmQodGVzdF9mYWlsdXJlcy5GYWls dXJlQ3Jhc2goKSkKLSAgICBpZiB0aW1lb3V0OgotICAgICAgICBmYWlsdXJlcy5hcHBlbmQodGVz dF9mYWlsdXJlcy5GYWlsdXJlVGltZW91dCgpKQotCi0gICAgaWYgY3Jhc2g6Ci0gICAgICAgIF9s b2cuZGVidWcoIlN0YWNrdHJhY2UgZm9yICVzOlxuJXMiICUgKHRlc3RfaW5mby5maWxlbmFtZSwg ZXJyb3IpKQotICAgICAgICAjIFN0cmlwIG9mZiAiZmlsZTovLyIgc2luY2UgUmVsYXRpdmVUZXN0 RmlsZW5hbWUgZXhwZWN0cwotICAgICAgICAjIGZpbGVzeXN0ZW0gcGF0aHMuCi0gICAgICAgIGZp bGVuYW1lID0gb3MucGF0aC5qb2luKG9wdGlvbnMucmVzdWx0c19kaXJlY3RvcnksCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHBvcnQucmVsYXRpdmVfdGVzdF9maWxlbmFtZSgKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGVzdF9pbmZvLmZpbGVuYW1lKSkKLSAgICAg ICAgZmlsZW5hbWUgPSBvcy5wYXRoLnNwbGl0ZXh0KGZpbGVuYW1lKVswXSArICItc3RhY2sudHh0 IgotICAgICAgICBwb3J0Lm1heWJlX21ha2VfZGlyZWN0b3J5KG9zLnBhdGguc3BsaXQoZmlsZW5h bWUpWzBdKQotICAgICAgICB3aXRoIGNvZGVjcy5vcGVuKGZpbGVuYW1lLCAid2IiLCAidXRmLTgi KSBhcyBmaWxlOgotICAgICAgICAgICAgZmlsZS53cml0ZShlcnJvcikKLSAgICBlbGlmIGVycm9y OgotICAgICAgICBfbG9nLmRlYnVnKCJQcmV2aW91cyB0ZXN0IG91dHB1dCBzdGRlcnIgbGluZXM6 XG4lcyIgJSBlcnJvcikKLQotICAgICMgQ2hlY2sgdGhlIG91dHB1dCBhbmQgc2F2ZSB0aGUgcmVz dWx0cy4KLSAgICBzdGFydF90aW1lID0gdGltZS50aW1lKCkKLSAgICB0aW1lX2Zvcl9kaWZmcyA9 IHt9Ci0gICAgZm9yIHRlc3RfdHlwZSBpbiB0ZXN0X3R5cGVzOgotICAgICAgICBzdGFydF9kaWZm X3RpbWUgPSB0aW1lLnRpbWUoKQotICAgICAgICBuZXdfZmFpbHVyZXMgPSB0ZXN0X3R5cGUuY29t cGFyZV9vdXRwdXQocG9ydCwgdGVzdF9pbmZvLmZpbGVuYW1lLAotICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb3V0cHV0LCBsb2NhbF90ZXN0X2FyZ3MsCi0g ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBvcHRpb25zLmNv bmZpZ3VyYXRpb24pCi0gICAgICAgICMgRG9uJ3QgYWRkIGFueSBtb3JlIGZhaWx1cmVzIGlmIHdl IGFscmVhZHkgaGF2ZSBhIGNyYXNoLCBzbyB3ZSBkb24ndAotICAgICAgICAjIGRvdWJsZS1yZXBv cnQgdGhvc2UgdGVzdHMuIFdlIGRvIGRvdWJsZS1yZXBvcnQgZm9yIHRpbWVvdXRzIHNpbmNlCi0g ICAgICAgICMgd2Ugc3RpbGwgd2FudCB0byBzZWUgdGhlIHRleHQgYW5kIGltYWdlIG91dHB1dC4K LSAgICAgICAgaWYgbm90IGNyYXNoOgotICAgICAgICAgICAgZmFpbHVyZXMuZXh0ZW5kKG5ld19m YWlsdXJlcykKLSAgICAgICAgdGltZV9mb3JfZGlmZnNbdGVzdF90eXBlLl9fY2xhc3NfXy5fX25h bWVfX10gPSAoCi0gICAgICAgICAgICB0aW1lLnRpbWUoKSAtIHN0YXJ0X2RpZmZfdGltZSkKLQot ICAgIHRvdGFsX3RpbWVfZm9yX2FsbF9kaWZmcyA9IHRpbWUudGltZSgpIC0gc3RhcnRfZGlmZl90 aW1lCi0gICAgcmV0dXJuIHRlc3RfcmVzdWx0cy5UZXN0UmVzdWx0KHRlc3RfaW5mby5maWxlbmFt ZSwgZmFpbHVyZXMsIHRlc3RfcnVuX3RpbWUsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHRvdGFsX3RpbWVfZm9yX2FsbF9kaWZmcywgdGltZV9mb3JfZGlmZnMpCitkZWYgX3Ro cmVhZF90aW1lb3V0KHRlc3RfaW5mbyk6CisgICAgIiIiUmV0dXJuIHRoZSBkdXJhdGF0aW9uIHRo ZSB0ZXN0IGlzIHN1cHBvc2VkIHRvIGZpbmlzaCB3aXRoaW4uIiIiCisgICAgIyBUT0RPKGhheWF0 byk6IEl0IG1pZ2h0IGJlIGJldHRlciB0byBpbmNyZWFzZSB0aGUgdGltZW91dCB0d28gdGltZXMg d2hlbgorICAgICMgd2UgYXJlIHJ1bm5pbmcgYSByZWZ0ZXN0LgorICAgIHJldHVybiBfbWlsbGlz ZWNvbmRzX3RvX3NlY29uZHMoCisgICAgICAgIF9wYWRfdGltZW91dChpbnQodGVzdF9pbmZvLnRp bWVvdXQpKSkKIAogCiBkZWYgX3BhZF90aW1lb3V0KHRpbWVvdXQpOgogICAgICIiIlJldHVybnMg YSBzYWZlIG11bHRpcGxlIG9mIHRoZSBwZXItdGVzdCB0aW1lb3V0IHZhbHVlIHRvIHVzZQogICAg IHRvIGRldGVjdCBodW5nIHRlc3QgdGhyZWFkcy4KLQogICAgICIiIgogICAgICMgV2hlbiB3ZSdy ZSBydW5uaW5nIG9uZSB0ZXN0IHBlciBEdW1wUmVuZGVyVHJlZSBwcm9jZXNzLCB3ZSBjYW4KICAg ICAjIGVuZm9yY2UgYSBoYXJkIHRpbWVvdXQuICBUaGUgRHVtcFJlbmRlclRyZWUgd2F0Y2hkb2cg dXNlcyAyLjV4CkBAIC0xNTMsMTcgKzk2LDEwIEBAIGRlZiBfbWlsbGlzZWNvbmRzX3RvX3NlY29u ZHMobXNlY3MpOgogICAgIHJldHVybiBmbG9hdChtc2VjcykgLyAxMDAwLjAKIAogCi1kZWYgX2lt YWdlX2hhc2godGVzdF9pbmZvLCB0ZXN0X2FyZ3MsIG9wdGlvbnMpOgotICAgICIiIlJldHVybnMg dGhlIGltYWdlIGhhc2ggb2YgdGhlIHRlc3QgaWYgaXQncyBuZWVkZWQsIG90aGVyd2lzZSBOb25l LiIiIgotICAgIGlmICh0ZXN0X2FyZ3MubmV3X2Jhc2VsaW5lIG9yIHRlc3RfYXJncy5yZXNldF9y ZXN1bHRzIG9yIG5vdCBvcHRpb25zLnBpeGVsX3Rlc3RzKToKLSAgICAgICAgcmV0dXJuIE5vbmUK LSAgICByZXR1cm4gdGVzdF9pbmZvLmltYWdlX2hhc2goKQotCi0KIGNsYXNzIFNpbmdsZVRlc3RU aHJlYWQodGhyZWFkaW5nLlRocmVhZCk6CiAgICAgIiIiVGhyZWFkIHdyYXBwZXIgZm9yIHJ1bm5p bmcgYSBzaW5nbGUgdGVzdCBmaWxlLiIiIgogCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQs IG9wdGlvbnMsIHRlc3RfaW5mbywgdGVzdF90eXBlcywgdGVzdF9hcmdzKToKKyAgICBkZWYgX19p bml0X18oc2VsZiwgcG9ydCwgb3B0aW9ucywgdGVzdF9pbmZvLCB0ZXN0X3R5cGVzLCByZWZ0ZXN0 X3R5cGVzLCB0ZXN0X2FyZ3MpOgogICAgICAgICAiIiIKICAgICAgICAgQXJnczoKICAgICAgICAg ICBwb3J0OiBvYmplY3QgaW1wbGVtZW50aW5nIHBvcnQtc3BlY2lmaWMgaG9va3MKQEAgLTE3MSw2 ICsxMDcsOCBAQCBjbGFzcyBTaW5nbGVUZXN0VGhyZWFkKHRocmVhZGluZy5UaHJlYWQpOgogICAg ICAgICAgIHRlc3RfaW5mbzogT2JqZWN0IGNvbnRhaW5pbmcgdGhlIHRlc3QgZmlsZW5hbWUsIHVy aSBhbmQgdGltZW91dAogICAgICAgICAgIHRlc3RfdHlwZXM6IEEgbGlzdCBvZiBUZXN0VHlwZSBv YmplY3RzIHRvIHJ1biB0aGUgdGVzdCBvdXRwdXQKICAgICAgICAgICAgICAgYWdhaW5zdC4KKyAg ICAgICAgICByZWZ0ZXN0X3R5cGVzOiBBIGxpc3Qgb2YgVGVzdFR5cGUgb2JqZWN0cyB0byBydW4g dGhlIHJlZnRlc3Qgb3V0cHV0CisgICAgICAgICAgICAgIGFnYWluc3QuCiAgICAgICAgICAgdGVz dF9hcmdzOiBBIFRlc3RBcmd1bWVudHMgb2JqZWN0IHRvIHBhc3MgdG8gZWFjaCBUZXN0VHlwZS4K ICAgICAgICAgIiIiCiAKQEAgLTE3OSw2ICsxMTcsNyBAQCBjbGFzcyBTaW5nbGVUZXN0VGhyZWFk KHRocmVhZGluZy5UaHJlYWQpOgogICAgICAgICBzZWxmLl9vcHRpb25zID0gb3B0aW9ucwogICAg ICAgICBzZWxmLl90ZXN0X2luZm8gPSB0ZXN0X2luZm8KICAgICAgICAgc2VsZi5fdGVzdF90eXBl cyA9IHRlc3RfdHlwZXMKKyAgICAgICAgc2VsZi5fcmVmdGVzdF90eXBlcyA9IHJlZnRlc3RfdHlw ZXMKICAgICAgICAgc2VsZi5fdGVzdF9hcmdzID0gdGVzdF9hcmdzCiAgICAgICAgIHNlbGYuX2Ry aXZlciA9IE5vbmUKIApAQCAtMTg4LDIwICsxMjcsMTMgQEAgY2xhc3MgU2luZ2xlVGVzdFRocmVh ZCh0aHJlYWRpbmcuVGhyZWFkKToKICAgICBkZWYgX2NvdmVyZWRfcnVuKHNlbGYpOgogICAgICAg ICAjIEZJWE1FOiB0aGlzIGlzIGEgc2VwYXJhdGUgcm91dGluZSB0byB3b3JrIGFyb3VuZCBhIGJ1 ZwogICAgICAgICAjIGluIGNvdmVyYWdlOiBzZWUgaHR0cDovL2JpdGJ1Y2tldC5vcmcvbmVkL2Nv dmVyYWdlcHkvaXNzdWUvODUuCi0gICAgICAgIHRlc3RfaW5mbyA9IHNlbGYuX3Rlc3RfaW5mbwog ICAgICAgICBzZWxmLl9kcml2ZXIgPSBzZWxmLl9wb3J0LmNyZWF0ZV9kcml2ZXIoc2VsZi5fdGVz dF9hcmdzLnBuZ19wYXRoLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgc2VsZi5fb3B0aW9ucykKICAgICAgICAgc2VsZi5fZHJpdmVyLnN0YXJ0KCkKLSAg ICAgICAgaW1hZ2VfaGFzaCA9IF9pbWFnZV9oYXNoKHRlc3RfaW5mbywgc2VsZi5fdGVzdF9hcmdz LCBzZWxmLl9vcHRpb25zKQotICAgICAgICBzdGFydCA9IHRpbWUudGltZSgpCi0gICAgICAgIGNy YXNoLCB0aW1lb3V0LCBhY3R1YWxfY2hlY2tzdW0sIG91dHB1dCwgZXJyb3IgPSBcCi0gICAgICAg ICAgICBzZWxmLl9kcml2ZXIucnVuX3Rlc3QodGVzdF9pbmZvLnVyaS5zdHJpcCgpLCB0ZXN0X2lu Zm8udGltZW91dCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbWFnZV9oYXNo KQotICAgICAgICBlbmQgPSB0aW1lLnRpbWUoKQotICAgICAgICBzZWxmLl90ZXN0X3Jlc3VsdCA9 IF9wcm9jZXNzX291dHB1dChzZWxmLl9wb3J0LCBzZWxmLl9vcHRpb25zLAotICAgICAgICAgICAg dGVzdF9pbmZvLCBzZWxmLl90ZXN0X3R5cGVzLCBzZWxmLl90ZXN0X2FyZ3MsCi0gICAgICAgICAg ICBjcmFzaCwgdGltZW91dCwgZW5kIC0gc3RhcnQsCi0gICAgICAgICAgICBhY3R1YWxfY2hlY2tz dW0sIG91dHB1dCwgZXJyb3IpCisgICAgICAgIHJ1bm5lciA9IHNpbmdsZV90ZXN0X3J1bm5lci5T aW5nbGVUZXN0UnVubmVyKAorICAgICAgICAgICAgc2VsZi5fdGVzdF9pbmZvLCBzZWxmLl90ZXN0 X2FyZ3MsIHNlbGYuX2RyaXZlciwgc2VsZi5fcG9ydCwgc2VsZi5fb3B0aW9ucywKKyAgICAgICAg ICAgIHNlbGYuX3Rlc3RfdHlwZXMsIHNlbGYuX3JlZnRlc3RfdHlwZXMpCisgICAgICAgIHNlbGYu X3Rlc3RfcmVzdWx0ID0gcnVubmVyLnJ1bl90ZXN0KCkKICAgICAgICAgc2VsZi5fZHJpdmVyLnN0 b3AoKQogCiAgICAgZGVmIGdldF90ZXN0X3Jlc3VsdChzZWxmKToKQEAgLTI0NSw3ICsxNzcsNyBA QCBjbGFzcyBXYXRjaGFibGVUaHJlYWQodGhyZWFkaW5nLlRocmVhZCk6CiAKIGNsYXNzIFRlc3RT aGVsbFRocmVhZChXYXRjaGFibGVUaHJlYWQpOgogICAgIGRlZiBfX2luaXRfXyhzZWxmLCBwb3J0 LCBvcHRpb25zLCBmaWxlbmFtZV9saXN0X3F1ZXVlLCByZXN1bHRfcXVldWUsCi0gICAgICAgICAg ICAgICAgIHRlc3RfdHlwZXMsIHRlc3RfYXJncyk6CisgICAgICAgICAgICAgICAgIHRlc3RfdHlw ZXMsIHJlZnRlc3RfdHlwZXMsIHRlc3RfYXJncyk6CiAgICAgICAgICIiIkluaXRpYWxpemUgYWxs IHRoZSBsb2NhbCBzdGF0ZSBmb3IgdGhpcyBEdW1wUmVuZGVyVHJlZSB0aHJlYWQuCiAKICAgICAg ICAgQXJnczoKQEAgLTI1Nyw2ICsxODksOCBAQCBjbGFzcyBUZXN0U2hlbGxUaHJlYWQoV2F0Y2hh YmxlVGhyZWFkKToKICAgICAgICAgICAgICAgc2VyaWFsaXplZCBUZXN0UmVzdWx0IG9iamVjdHMu CiAgICAgICAgICAgdGVzdF90eXBlczogQSBsaXN0IG9mIFRlc3RUeXBlIG9iamVjdHMgdG8gcnVu IHRoZSB0ZXN0IG91dHB1dAogICAgICAgICAgICAgICBhZ2FpbnN0LgorICAgICAgICAgIHJlZnRl c3RfdHlwZXM6IEEgbGlzdCBvZiBUZXN0VHlwZSBvYmplY3RzIHRvIHJ1biB0aGUgcmVmdGVzdCBv dXRwdXQKKyAgICAgICAgICAgICAgYWdhaW5zdC4KICAgICAgICAgICB0ZXN0X2FyZ3M6IEEgVGVz dEFyZ3VtZW50cyBvYmplY3QgdG8gcGFzcyB0byBlYWNoIFRlc3RUeXBlLgogCiAgICAgICAgICIi IgpAQCAtMjY3LDYgKzIwMSw3IEBAIGNsYXNzIFRlc3RTaGVsbFRocmVhZChXYXRjaGFibGVUaHJl YWQpOgogICAgICAgICBzZWxmLl9yZXN1bHRfcXVldWUgPSByZXN1bHRfcXVldWUKICAgICAgICAg c2VsZi5fZmlsZW5hbWVfbGlzdCA9IFtdCiAgICAgICAgIHNlbGYuX3Rlc3RfdHlwZXMgPSB0ZXN0 X3R5cGVzCisgICAgICAgIHNlbGYuX3JlZnRlc3RfdHlwZXMgPSByZWZ0ZXN0X3R5cGVzCiAgICAg ICAgIHNlbGYuX3Rlc3RfYXJncyA9IHRlc3RfYXJncwogICAgICAgICBzZWxmLl9kcml2ZXIgPSBO b25lCiAgICAgICAgIHNlbGYuX3Rlc3RfZ3JvdXBfdGltaW5nX3N0YXRzID0ge30KQEAgLTQ2Niwx MiArNDAxLDEyIEBAIGNsYXNzIFRlc3RTaGVsbFRocmVhZChXYXRjaGFibGVUaHJlYWQpOgogICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYuX29wdGlvbnMsCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgdGVzdF9pbmZvLAogICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHNlbGYuX3Rlc3RfdHlwZXMsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgc2VsZi5fcmVmdGVzdF90eXBlcywKICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBzZWxmLl90ZXN0X2FyZ3MpCiAKICAgICAgICAgd29ya2VyLnN0YXJ0KCkKIAotICAg ICAgICB0aHJlYWRfdGltZW91dCA9IF9taWxsaXNlY29uZHNfdG9fc2Vjb25kcygKLSAgICAgICAg ICAgIF9wYWRfdGltZW91dChpbnQodGVzdF9pbmZvLnRpbWVvdXQpKSkKKyAgICAgICAgdGhyZWFk X3RpbWVvdXQgPSBfdGhyZWFkX3RpbWVvdXQodGVzdF9pbmZvKQogICAgICAgICB0aHJlYWQuX25l eHRfdGltZW91dCA9IHRpbWUudGltZSgpICsgdGhyZWFkX3RpbWVvdXQKICAgICAgICAgd29ya2Vy LmpvaW4odGhyZWFkX3RpbWVvdXQpCiAgICAgICAgIGlmIHdvcmtlci5pc0FsaXZlKCk6CkBAIC01 MDgsMjggKzQ0MywxMyBAQCBjbGFzcyBUZXN0U2hlbGxUaHJlYWQoV2F0Y2hhYmxlVGhyZWFkKToK ICAgICAgICAgUmV0dXJuczogYSBUZXN0UmVzdWx0IG9iamVjdC4KICAgICAgICAgIiIiCiAgICAg ICAgIHNlbGYuX2Vuc3VyZV9kdW1wX3JlbmRlcl90cmVlX2lzX3J1bm5pbmcoKQotICAgICAgICAj IFRoZSBwaXhlbF9oYXNoIGlzIHVzZWQgdG8gYXZvaWQgZG9pbmcgYW4gaW1hZ2UgZHVtcCBpZiB0 aGUKLSAgICAgICAgIyBjaGVja3N1bXMgbWF0Y2gsIHNvIGl0IHNob3VsZCBiZSBzZXQgdG8gYSBi bGFuayB2YWx1ZSBpZiB3ZQotICAgICAgICAjIGFyZSBnZW5lcmF0aW5nIGEgbmV3IGJhc2VsaW5l LiAgKE90aGVyd2lzZSwgYW4gaW1hZ2UgZnJvbSBhCi0gICAgICAgICMgcHJldmlvdXMgcnVuIHdp bGwgYmUgY29waWVkIGludG8gdGhlIGJhc2VsaW5lLikKLSAgICAgICAgaW1hZ2VfaGFzaCA9IF9p bWFnZV9oYXNoKHRlc3RfaW5mbywgc2VsZi5fdGVzdF9hcmdzLCBzZWxmLl9vcHRpb25zKQotICAg ICAgICBzdGFydCA9IHRpbWUudGltZSgpCi0KLSAgICAgICAgdGhyZWFkX3RpbWVvdXQgPSBfbWls bGlzZWNvbmRzX3RvX3NlY29uZHMoCi0gICAgICAgICAgICAgX3BhZF90aW1lb3V0KGludCh0ZXN0 X2luZm8udGltZW91dCkpKQotICAgICAgICBzZWxmLl9uZXh0X3RpbWVvdXQgPSBzdGFydCArIHRo cmVhZF90aW1lb3V0Ci0KLSAgICAgICAgY3Jhc2gsIHRpbWVvdXQsIGFjdHVhbF9jaGVja3N1bSwg b3V0cHV0LCBlcnJvciA9IFwKLSAgICAgICAgICAgc2VsZi5fZHJpdmVyLnJ1bl90ZXN0KHRlc3Rf aW5mby51cmksIHRlc3RfaW5mby50aW1lb3V0LCBpbWFnZV9oYXNoKQotICAgICAgICBlbmQgPSB0 aW1lLnRpbWUoKQotCi0gICAgICAgIHJlc3VsdCA9IF9wcm9jZXNzX291dHB1dChzZWxmLl9wb3J0 LCBzZWxmLl9vcHRpb25zLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGVzdF9p bmZvLCBzZWxmLl90ZXN0X3R5cGVzLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg c2VsZi5fdGVzdF9hcmdzLCBjcmFzaCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHRpbWVvdXQsIGVuZCAtIHN0YXJ0LCBhY3R1YWxfY2hlY2tzdW0sCi0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBvdXRwdXQsIGVycm9yKQotICAgICAgICBzZWxmLl90ZXN0X3Jlc3Vs dHMuYXBwZW5kKHJlc3VsdCkKLSAgICAgICAgcmV0dXJuIHJlc3VsdAorICAgICAgICBzZWxmLl9u ZXh0X3RpbWVvdXQgPSB0aW1lLnRpbWUoKSArIF90aHJlYWRfdGltZW91dCh0ZXN0X2luZm8pCisg ICAgICAgIHJ1bm5lciA9IHNpbmdsZV90ZXN0X3J1bm5lci5TaW5nbGVUZXN0UnVubmVyKAorICAg ICAgICAgICAgdGVzdF9pbmZvLCBzZWxmLl90ZXN0X2FyZ3MsIHNlbGYuX2RyaXZlciwgc2VsZi5f cG9ydCwgc2VsZi5fb3B0aW9ucywKKyAgICAgICAgICAgIHNlbGYuX3Rlc3RfdHlwZXMsIHNlbGYu X3JlZnRlc3RfdHlwZXMpCisgICAgICAgIHRlc3RfcmVzdWx0ID0gcnVubmVyLnJ1bl90ZXN0KCkK KyAgICAgICAgc2VsZi5fdGVzdF9yZXN1bHRzLmFwcGVuZCh0ZXN0X3Jlc3VsdCkKKyAgICAgICAg cmV0dXJuIHRlc3RfcmVzdWx0CiAKICAgICBkZWYgX2Vuc3VyZV9kdW1wX3JlbmRlcl90cmVlX2lz X3J1bm5pbmcoc2VsZik6CiAgICAgICAgICIiIlN0YXJ0IHRoZSBzaGFyZWQgRHVtcFJlbmRlclRy ZWUsIGlmIGl0J3Mgbm90IHJ1bm5pbmcuCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9qc29uX2xheW91dF9yZXN1bHRz X2dlbmVyYXRvci5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L2xheW91dF9wYWNrYWdlL2pzb25fbGF5b3V0X3Jlc3VsdHNfZ2VuZXJhdG9yLnB5CmluZGV4IDFj Zjg4ZWY1OTdmNDU3M2VlYzY5MWZlMDljNjRiYTU1ODQ4MzkzNmIuLjQ3OWY0MDk1NWNiNjAwMjky NWZlZDYzMDEzNDYyYzhhZWQ1YmViOGIgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2pzb25fbGF5b3V0X3Jlc3VsdHNf Z2VuZXJhdG9yLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL2xheW91dF9wYWNrYWdlL2pzb25fbGF5b3V0X3Jlc3VsdHNfZ2VuZXJhdG9yLnB5CkBAIC01 MSw2ICs1MSw4IEBAIGNsYXNzIEpTT05MYXlvdXRSZXN1bHRzR2VuZXJhdG9yKGpzb25fcmVzdWx0 c19nZW5lcmF0b3IuSlNPTlJlc3VsdHNHZW5lcmF0b3JCYXNlCiAgICAgICAgICAgICAgICAgICAg ICAgIHRlc3RfZXhwZWN0YXRpb25zLklNQUdFOiAiSSIsCiAgICAgICAgICAgICAgICAgICAgICAg IHRlc3RfZXhwZWN0YXRpb25zLlRFWFQ6ICJGIiwKICAgICAgICAgICAgICAgICAgICAgICAgdGVz dF9leHBlY3RhdGlvbnMuTUlTU0lORzogIk8iLAorICAgICAgICAgICAgICAgICAgICAgICB0ZXN0 X2V4cGVjdGF0aW9ucy5SRUZFUkVOQ0VfTUlTTUFUQ0g6ICJSIiwKKyAgICAgICAgICAgICAgICAg ICAgICAgdGVzdF9leHBlY3RhdGlvbnMuUkVGRVJFTkNFX01BVENIOiAiTSIsCiAgICAgICAgICAg ICAgICAgICAgICAgIHRlc3RfZXhwZWN0YXRpb25zLklNQUdFX1BMVVNfVEVYVDogIloifQogCiAg ICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQsIGJ1aWxkZXJfbmFtZSwgYnVpbGRfbmFtZSwgYnVp bGRfbnVtYmVyLApkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvbGF5b3V0X3BhY2thZ2Uvc2luZ2xlX3Rlc3RfcnVubmVyLnB5IGIvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2Uvc2luZ2xlX3Rl c3RfcnVubmVyLnB5Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjdhYWM5M2E1NjUzZWY5ZDFiMWZiM2I0YjA1ZmJlNjM0 M2I5YjJhOTQKLS0tIC9kZXYvbnVsbAorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9zaW5nbGVfdGVzdF9ydW5uZXIucHkKQEAgLTAs MCArMSwyMDkgQEAKKyMhL3Vzci9iaW4vZW52IHB5dGhvbgorIyBDb3B5cmlnaHQgKEMpIDIwMTAg R29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyMKKyMgUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisjIG1vZGlm aWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0 aW9ucyBhcmUKKyMgbWV0OgorIworIyAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorIyBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisjICAgICAqIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyMgY29w eXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lcgorIyBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlCisjIGRpc3RyaWJ1dGlvbi4KKyMgICAgICogTmVpdGhlciB0aGUg bmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworIyBjb250cmlidXRvcnMg bWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQor IyB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9u LgorIworIyBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVS UyBBTkQgQ09OVFJJQlVUT1JTCisjICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFRIRSBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorIyBBIFBBUlRJ Q1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlS SUdIVAorIyBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwKKyMgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyMgREFUQSwg T1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04gQU5ZCisjIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQKKyMgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisjIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisKKyIi IkEgdGVzdCBydW5uZXIgd2hpY2ggcnVucyBhIHNpbmdsZSB0ZXN0IGZpbGUuIiIiCisKK2Zyb20g X19mdXR1cmVfXyBpbXBvcnQgd2l0aF9zdGF0ZW1lbnQKKworaW1wb3J0IGNvZGVjcworaW1wb3J0 IGNvcHkKK2ltcG9ydCBsb2dnaW5nCitpbXBvcnQgb3MKK2ltcG9ydCBzeXMKK2ltcG9ydCB0aW1l CisKK2ltcG9ydCB0ZXN0X2ZhaWx1cmVzCitpbXBvcnQgdGVzdF9yZXN1bHRzCisKK19sb2cgPSBs b2dnaW5nLmdldExvZ2dlcigid2Via2l0cHkubGF5b3V0X3Rlc3RzLmxheW91dF9wYWNrYWdlLiIK KyAgICAgICAgICAgICAgICAgICAgICAgICAic2luZ2xlX3Rlc3RfcnVubmVyIikKKworCitjbGFz cyBTaW5nbGVUZXN0UnVubmVyKG9iamVjdCk6CisgICAgIiIiQW4gYWJzdHJhY3Rpb24gZm9yIHJ1 bm5pbmcgYSBzaW5nbGUgdGVzdC4KKworICAgIEEgdHlwaWNhbCB1c2FnZSBpczoKKyAgICAgICMg SW5zdGFudGlhdGUgd2l0aCBuZWNlc3NhcnkgdGVzdCBpbmZvcm1hdGlvbi4KKyAgICAgIHJ1bm5l ciA9IFNpbmdsZVRlc3RSdW5uZXIodGVzdF9pbmZvLCB0ZXN0X2FyZ3MsIC4uLi4pCisgICAgICAj IFJ1biBhbmQgZ2V0IGEgVGVzdFJlc3VsdCBvYmplY3QgYnkgY2FsaW5nIHJ1bl90ZXN0KCkuCisg ICAgICB0ZXN0X3Jlc3VsdCA9IHJ1bm5lci5ydW5fdGVzdCgpCisgICAgIiIiCisKKyAgICBkZWYg X19pbml0X18oc2VsZiwgdGVzdF9pbmZvLCB0ZXN0X2FyZ3MsIGRyaXZlciwgcG9ydCwgb3B0aW9u cywKKyAgICAgICAgICAgICAgICAgdGVzdF90eXBlcywgcmVmdGVzdF90eXBlcyk6CisgICAgICAg IHNlbGYuX3Rlc3RfaW5mbyA9IHRlc3RfaW5mbworICAgICAgICBzZWxmLl90ZXN0X2FyZ3MgPSB0 ZXN0X2FyZ3MKKyAgICAgICAgc2VsZi5fZHJpdmVyID0gZHJpdmVyCisgICAgICAgIHNlbGYuX3Bv cnQgPSBwb3J0CisgICAgICAgIHNlbGYuX29wdGlvbnMgPSBvcHRpb25zCisgICAgICAgIHNlbGYu X3Rlc3RfdHlwZXMgPSB0ZXN0X3R5cGVzCisgICAgICAgIHNlbGYuX3JlZnRlc3RfdHlwZXMgPSBy ZWZ0ZXN0X3R5cGVzCisKKyAgICBkZWYgcnVuX3Rlc3Qoc2VsZik6CisgICAgICAgICIiIlJ1biBh IHNpbmdsZSB0ZXN0IGZpbGUgdXNpbmcgYSBzaGFyZWQgRHVtcFJlbmRlclRyZWUgcHJvY2Vzcy4K KworICAgICAgICBBcyBzaWRlIGVmZmVjdHMsIHByZXNlcnZlcyB0aGUgcmVuZGVyaW5nIHJlc3Vs dChzKSBhbmQgZXhwZWN0ZWQgb25lKHMpCisgICAgICAgIGFuZCBzbyBvbiBpbiB0aGUgb3V0cHV0 IGRpcmVjdG9yeSBmb3IgbGF0ZXIgcmVwb3J0aW5nIGlmIG5lY2Vzc2FueS4KKworICAgICAgICBS ZXR1cm5zOgorICAgICAgICAgIEEgbGlzdCBvZiBUZXN0RmFpbHVyZSBvYmplY3RzIGRlc2NyaWJp bmcgdGhlIGVycm9yLgorICAgICAgICAiIiIKKyAgICAgICAgaWYgc2VsZi5fdGVzdF9pbmZvLmlz X3JlZnRlc3Q6CisgICAgICAgICAgICByZXR1cm4gc2VsZi5fcnVuX3JlZnRlc3QoKQorICAgICAg ICByZXR1cm4gc2VsZi5fcnVuX2xheW91dF90ZXN0KCkKKworICAgIGRlZiBfaW1hZ2VfaGFzaChz ZWxmKToKKyAgICAgICAgIiIiUmV0dXJucyB0aGUgaW1hZ2UgaGFzaCBvZiB0aGUgdGVzdCBpZiBp dCdzIG5lZWRlZCwgb3RoZXJ3aXNlIE5vbmUuIiIiCisgICAgICAgIGlmIChzZWxmLl90ZXN0X2Fy Z3MubmV3X2Jhc2VsaW5lIG9yIHNlbGYuX3Rlc3RfYXJncy5yZXNldF9yZXN1bHRzIG9yCisgICAg ICAgICAgICBub3Qgc2VsZi5fb3B0aW9ucy5waXhlbF90ZXN0cyk6CisgICAgICAgICAgICByZXR1 cm4gTm9uZQorICAgICAgICByZXR1cm4gc2VsZi5fdGVzdF9pbmZvLmltYWdlX2hhc2goKQorCisg ICAgZGVmIF9ydW5fbGF5b3V0X3Rlc3Qoc2VsZik6CisgICAgICAgICMgVGhlIHBpeGVsX2hhc2gg aXMgdXNlZCB0byBhdm9pZCBkb2luZyBhbiBpbWFnZSBkdW1wIGlmIHRoZQorICAgICAgICAjIGNo ZWNrc3VtcyBtYXRjaCwgc28gaXQgc2hvdWxkIGJlIHNldCB0byBhIGJsYW5rIHZhbHVlIGlmIHdl CisgICAgICAgICMgYXJlIGdlbmVyYXRpbmcgYSBuZXcgYmFzZWxpbmUuICAoT3RoZXJ3aXNlLCBh biBpbWFnZSBmcm9tIGEKKyAgICAgICAgIyBwcmV2aW91cyBydW4gd2lsbCBiZSBjb3BpZWQgaW50 byB0aGUgYmFzZWxpbmUuKQorICAgICAgICBpbWFnZV9oYXNoID0gc2VsZi5faW1hZ2VfaGFzaCgp CisgICAgICAgIHN0YXJ0ID0gdGltZS50aW1lKCkKKworICAgICAgICBjcmFzaCwgdGltZW91dCwg YWN0dWFsX2NoZWNrc3VtLCBvdXRwdXQsIGVycm9yID0gXAorICAgICAgICAgICBzZWxmLl9kcml2 ZXIucnVuX3Rlc3Qoc2VsZi5fdGVzdF9pbmZvLnVyaSwgc2VsZi5fdGVzdF9pbmZvLnRpbWVvdXQs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbWFnZV9oYXNoKQorICAgICAgICBl bmQgPSB0aW1lLnRpbWUoKQorCisgICAgICAgICMgUHJvY2VzcyBvdXRwdXRzLgorICAgICAgICBm YWlsdXJlcyA9IFtdCisgICAgICAgIGZhaWx1cmVzLmV4dGVuZCgKKyAgICAgICAgICAgIHNlbGYu X3Byb2Nlc3NfZXJyb3Ioc2VsZi5fdGVzdF9pbmZvLmZpbGVuYW1lLCBjcmFzaCwgdGltZW91dCwg ZXJyb3IpKQorCisgICAgICAgICMgU29tZSB0ZXN0IGFyZ3MsIHN1Y2ggYXMgdGhlIGltYWdlIGhh c2gsIG1heSBiZSBhZGRlZCBvciBjaGFuZ2VkIG9uIGEKKyAgICAgICAgIyB0ZXN0LWJ5LXRlc3Qg YmFzaXMuCisgICAgICAgIGxvY2FsX3Rlc3RfYXJncyA9IGNvcHkuY29weShzZWxmLl90ZXN0X2Fy Z3MpCisgICAgICAgIGxvY2FsX3Rlc3RfYXJncy5oYXNoID0gYWN0dWFsX2NoZWNrc3VtCisKKyAg ICAgICAgIyBDaGVjayB0aGUgb3V0cHV0IGFuZCBzYXZlIHRoZSByZXN1bHRzLgorICAgICAgICB0 aW1lX2Zvcl9kaWZmcyA9IHt9CisgICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gc2VsZi5fdGVzdF90 eXBlczoKKyAgICAgICAgICAgIHN0YXJ0X2RpZmZfdGltZSA9IHRpbWUudGltZSgpCisgICAgICAg ICAgICBuZXdfZmFpbHVyZXMgPSB0ZXN0X3R5cGUuY29tcGFyZV9vdXRwdXQoc2VsZi5fcG9ydCwg c2VsZi5fdGVzdF9pbmZvLmZpbGVuYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIG91dHB1dCwgbG9jYWxfdGVzdF9hcmdzLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYuX29wdGlvbnMu Y29uZmlndXJhdGlvbikKKyAgICAgICAgICAgICMgRG9uJ3QgYWRkIGFueSBtb3JlIGZhaWx1cmVz IGlmIHdlIGFscmVhZHkgaGF2ZSBhIGNyYXNoLCBzbyB3ZSBkb24ndAorICAgICAgICAgICAgIyBk b3VibGUtcmVwb3J0IHRob3NlIHRlc3RzLiBXZSBkbyBkb3VibGUtcmVwb3J0IGZvciB0aW1lb3V0 cyBzaW5jZQorICAgICAgICAgICAgIyB3ZSBzdGlsbCB3YW50IHRvIHNlZSB0aGUgdGV4dCBhbmQg aW1hZ2Ugb3V0cHV0LgorICAgICAgICAgICAgaWYgbm90IGNyYXNoOgorICAgICAgICAgICAgICAg IGZhaWx1cmVzLmV4dGVuZChuZXdfZmFpbHVyZXMpCisgICAgICAgICAgICB0aW1lX2Zvcl9kaWZm c1t0ZXN0X3R5cGUuX19jbGFzc19fLl9fbmFtZV9fXSA9ICgKKyAgICAgICAgICAgICAgICB0aW1l LnRpbWUoKSAtIHN0YXJ0X2RpZmZfdGltZSkKKworICAgICAgICB0b3RhbF90aW1lX2Zvcl9hbGxf ZGlmZnMgPSB0aW1lLnRpbWUoKSAtIHN0YXJ0X2RpZmZfdGltZQorICAgICAgICByZXR1cm4gdGVz dF9yZXN1bHRzLlRlc3RSZXN1bHQoc2VsZi5fdGVzdF9pbmZvLmZpbGVuYW1lLCBmYWlsdXJlcywg ZW5kIC0gc3RhcnQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0b3Rh bF90aW1lX2Zvcl9hbGxfZGlmZnMsIHRpbWVfZm9yX2RpZmZzKQorCisgICAgZGVmIF9vdXRwdXRf aW1hZ2VfY29udGVudHNfZnJvbV9kcml2ZXIoc2VsZik6CisgICAgICAgIHBuZ19wYXRoID0gc2Vs Zi5fdGVzdF9hcmdzLnBuZ19wYXRoCisgICAgICAgIGFzc2VydChvcy5wYXRoLmlzZmlsZShwbmdf cGF0aCkpCisgICAgICAgIHdpdGggb3BlbihwbmdfcGF0aCwgJ3JiJykgYXMgaW1hZ2VfZmlsZToK KyAgICAgICAgICAgIHJldHVybiBpbWFnZV9maWxlLnJlYWQoKQorCisgICAgZGVmIF9ydW5fcmVm dGVzdChzZWxmKToKKyAgICAgICAgc3RhcnQgPSB0aW1lLnRpbWUoKQorICAgICAgICAjIFdlIHNo b3VsZCBjYWxsIGRyaXZlcidzIHJ1bl90ZXN0IG1ldGhvZCB0d28gdGltZXMuIE9uZSBpcyBmb3Ig dGhlIHRlc3QgZmlsZS4KKyAgICAgICAgIyBUaGUgb3RoZXIgaXMgZm9yIHRoZSByZWZlcmVuY2Ug ZmlsZS4KKworICAgICAgICAjIDEuIEdldHMgYSByZW5kZXJpbmcgaW1hZ2UgZm9yIHRoZSB0ZXN0 IGZpbGUuCisgICAgICAgIChhY3R1YWxfY3Jhc2gsIGFjdHVhbF90aW1lb3V0LCBhY3R1YWxfaW1h Z2VfaGFzaCwgYWN0dWFsX291dHB1dCwKKyAgICAgICAgIGFjdHVhbF9lcnJvcikgPSBcCisgICAg ICAgICAgICBzZWxmLl9kcml2ZXIucnVuX3Rlc3Qoc2VsZi5fdGVzdF9pbmZvLnVyaSwgc2VsZi5f dGVzdF9pbmZvLnRpbWVvdXQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW1h Z2VfaGFzaD0iIikKKyAgICAgICAgYWN0dWFsX2ltYWdlX2NvbnRlbnRzID0gc2VsZi5fb3V0cHV0 X2ltYWdlX2NvbnRlbnRzX2Zyb21fZHJpdmVyKCkKKworICAgICAgICAjIDIuIEdldHMgYSByZW5k ZXJpbmcgaW1hZ2UgZm9yIHRoZSByZWZlcmVuY2UgZmlsZS4KKyAgICAgICAgcmVmZXJlbmNlX2Zp bGVuYW1lID0gKHNlbGYuX3Rlc3RfaW5mby5leHBlY3RlZF9odG1sX2ZpbGVuYW1lCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBvciBzZWxmLl90ZXN0X2luZm8uZXhwZWN0ZWRfbWlzbWF0 Y2hfaHRtbF9maWxlbmFtZSkKKyAgICAgICAgKHJlZmVyZW5jZV9jcmFzaCwgcmVmZXJlbmNlX3Rp bWVvdXQsIHJlZmVyZW5jZV9pbWFnZV9oYXNoLAorICAgICAgICAgcmVmZXJlbmNlX291dHB1dCwg cmVmZXJlbmNlX2Vycm9yKSA9IFwKKyAgICAgICAgICAgIHNlbGYuX2RyaXZlci5ydW5fdGVzdChy ZWZlcmVuY2VfZmlsZW5hbWUsIHNlbGYuX3Rlc3RfaW5mby50aW1lb3V0LAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGFjdHVhbF9pbWFnZV9oYXNoKQorCisgICAgICAgIGlmIGFj dHVhbF9pbWFnZV9oYXNoID09IHJlZmVyZW5jZV9pbWFnZV9oYXNoOgorICAgICAgICAgICAgcmVm ZXJlbmNlX2ltYWdlX2NvbnRlbnRzID0gYWN0dWFsX2ltYWdlX2NvbnRlbnRzCisgICAgICAgIGVs c2U6CisgICAgICAgICAgICByZWZlcmVuY2VfaW1hZ2VfY29udGVudHMgPSBzZWxmLl9vdXRwdXRf aW1hZ2VfY29udGVudHNfZnJvbV9kcml2ZXIoKQorCisgICAgICAgIGVuZCA9IHRpbWUudGltZSgp CisKKyAgICAgICAgIyBQcm9jZXNzIGFjdHVhbCBhbmQgcmVmZXJlbmNlIG91dHB1dHMuCisgICAg ICAgIGZhaWx1cmVzID0gW10KKyAgICAgICAgZmFpbHVyZXMuZXh0ZW5kKAorICAgICAgICAgICAg c2VsZi5fcHJvY2Vzc19lcnJvcihzZWxmLl90ZXN0X2luZm8uZXhwZWN0ZWRfaHRtbF9maWxlbmFt ZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYWN0dWFsX2NyYXNoLCBhY3R1YWxf dGltZW91dCwgYWN0dWFsX2Vycm9yKSkKKyAgICAgICAgZmFpbHVyZXMuZXh0ZW5kKAorICAgICAg ICAgICAgc2VsZi5fcHJvY2Vzc19lcnJvcihzZWxmLl90ZXN0X2luZm8uZXhwZWN0ZWRfbWlzbWF0 Y2hfaHRtbF9maWxlbmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVmZXJl bmNlX2NyYXNoLCByZWZlcmVuY2VfdGltZW91dCwgcmVmZXJlbmNlX2Vycm9yKSkKKworICAgICAg ICB0aW1lX2Zvcl9kaWZmcyA9IHt9CisgICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gc2VsZi5fcmVm dGVzdF90eXBlczoKKyAgICAgICAgICAgIHN0YXJ0X2RpZmZfdGltZSA9IHRpbWUudGltZSgpCisg ICAgICAgICAgICBuZXdfZmFpbHVyZXMgPSB0ZXN0X3R5cGUuY29tcGFyZV9vdXRwdXRfd2l0aF9y ZWZlcmVuY2UoCisgICAgICAgICAgICAgICAgc2VsZi5fcG9ydCwgc2VsZi5fdGVzdF9pbmZvLCBh Y3R1YWxfaW1hZ2VfaGFzaCwgYWN0dWFsX2ltYWdlX2NvbnRlbnRzLAorICAgICAgICAgICAgICAg IHJlZmVyZW5jZV9pbWFnZV9oYXNoLCByZWZlcmVuY2VfaW1hZ2VfY29udGVudHMpCisKKyAgICAg ICAgICAgIGlmIG5vdCBhY3R1YWxfY3Jhc2ggYW5kIG5vdCByZWZlcmVuY2VfY3Jhc2g6CisgICAg ICAgICAgICAgICAgZmFpbHVyZXMuZXh0ZW5kKG5ld19mYWlsdXJlcykKKworICAgICAgICAgICAg dGltZV9mb3JfZGlmZnNbdGVzdF90eXBlLl9fY2xhc3NfXy5fX25hbWVfX10gPSAoCisgICAgICAg ICAgICAgICAgdGltZS50aW1lKCkgLSBzdGFydF9kaWZmX3RpbWUpCisKKyAgICAgICAgdG90YWxf dGltZV9mb3JfYWxsX2RpZmZzID0gdGltZS50aW1lKCkgLSBzdGFydF9kaWZmX3RpbWUKKyAgICAg ICAgcmV0dXJuIHRlc3RfcmVzdWx0cy5UZXN0UmVzdWx0KHNlbGYuX3Rlc3RfaW5mby5maWxlbmFt ZSwgZmFpbHVyZXMsIGVuZCAtIHN0YXJ0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgdG90YWxfdGltZV9mb3JfYWxsX2RpZmZzLCB0aW1lX2Zvcl9kaWZmcykKKworICAg IGRlZiBfcHJvY2Vzc19lcnJvcihzZWxmLCBmaWxlbmFtZSwgY3Jhc2gsIHRpbWVvdXQsIGVycm9y KToKKyAgICAgICAgZmFpbHVyZXMgPSBbXQorICAgICAgICBpZiBjcmFzaDoKKyAgICAgICAgICAg IGZhaWx1cmVzLmFwcGVuZCh0ZXN0X2ZhaWx1cmVzLkZhaWx1cmVDcmFzaCgpKQorICAgICAgICBp ZiB0aW1lb3V0OgorICAgICAgICAgICAgZmFpbHVyZXMuYXBwZW5kKHRlc3RfZmFpbHVyZXMuRmFp bHVyZVRpbWVvdXQoKSkKKworICAgICAgICBpZiBjcmFzaDoKKyAgICAgICAgICAgIF9sb2cuZGVi dWcoIlN0YWNrdHJhY2UgZm9yICVzOlxuJXMiICUgKGZpbGVuYW1lLCBlcnJvcikpCisgICAgICAg ICAgICAjIFN0cmlwIG9mZiAiZmlsZTovLyIgc2luY2UgUmVsYXRpdmVUZXN0RmlsZW5hbWUgZXhw ZWN0cworICAgICAgICAgICAgIyBmaWxlc3lzdGVtIHBhdGhzLgorICAgICAgICAgICAgZmlsZW5h bWUgPSBvcy5wYXRoLmpvaW4oc2VsZi5fb3B0aW9ucy5yZXN1bHRzX2RpcmVjdG9yeSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYuX3BvcnQucmVsYXRpdmVfdGVzdF9m aWxlbmFtZSgKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYuX3Rlc3Rf aW5mby5maWxlbmFtZSkpCisgICAgICAgICAgICBmaWxlbmFtZSA9IG9zLnBhdGguc3BsaXRleHQo ZmlsZW5hbWUpWzBdICsgIi1zdGFjay50eHQiCisgICAgICAgICAgICBzZWxmLl9wb3J0Lm1heWJl X21ha2VfZGlyZWN0b3J5KG9zLnBhdGguc3BsaXQoZmlsZW5hbWUpWzBdKQorICAgICAgICAgICAg d2l0aCBjb2RlY3Mub3BlbihmaWxlbmFtZSwgIndiIiwgInV0Zi04IikgYXMgZmlsZToKKyAgICAg ICAgICAgICAgICBmaWxlLndyaXRlKGVycm9yKQorICAgICAgICBlbGlmIGVycm9yOgorICAgICAg ICAgICAgX2xvZy5kZWJ1ZygiUHJldmlvdXMgdGVzdCBvdXRwdXQgc3RkZXJyIGxpbmVzOlxuJXMi ICUgZXJyb3IpCisgICAgICAgIHJldHVybiBmYWlsdXJlcwpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvdGVzdF9leHBl Y3RhdGlvbnMucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9s YXlvdXRfcGFja2FnZS90ZXN0X2V4cGVjdGF0aW9ucy5weQppbmRleCA2Nzg3M2E4Y2MwYWIzMTc5 YzdkZTM1ZDVjOTgxNmNlMzQwZDM0Y2I5Li40MDM2YzBkNDRjY2Q4MDNjYzY4ZGI3YTFkNWE5NWRh YzBkYThjMjRjIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9sYXlvdXRfcGFja2FnZS90ZXN0X2V4cGVjdGF0aW9ucy5weQorKysgYi9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS90ZXN0X2V4 cGVjdGF0aW9ucy5weQpAQCAtNDIsOCArNDIsOSBAQCBfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIo IndlYmtpdHB5LmxheW91dF90ZXN0cy5sYXlvdXRfcGFja2FnZS4iCiAgICAgICAgICAgICAgICAg ICAgICAgICAgInRlc3RfZXhwZWN0YXRpb25zIikKIAogIyBUZXN0IGV4cGVjdGF0aW9uIGFuZCBt b2RpZmllciBjb25zdGFudHMuCi0oUEFTUywgRkFJTCwgVEVYVCwgSU1BR0UsIElNQUdFX1BMVVNf VEVYVCwgVElNRU9VVCwgQ1JBU0gsIFNLSVAsIFdPTlRGSVgsCi0gU0xPVywgUkVCQVNFTElORSwg TUlTU0lORywgRkxBS1ksIE5PVywgTk9ORSkgPSByYW5nZSgxNSkKKyhQQVNTLCBGQUlMLCBURVhU LCBJTUFHRSwgSU1BR0VfUExVU19URVhULCBSRUZFUkVOQ0VfTUlTTUFUQ0gsIFJFRkVSRU5DRV9N QVRDSCwKKyBUSU1FT1VULCBDUkFTSCwgU0tJUCwgV09OVEZJWCwgU0xPVywgUkVCQVNFTElORSwg TUlTU0lORywgRkxBS1ksIE5PVywKKyBOT05FKSA9IHJhbmdlKDE3KQogCiAjIFRlc3QgZXhwZWN0 YXRpb24gZmlsZSB1cGRhdGUgYWN0aW9uIGNvbnN0YW50cwogKE5PX0NIQU5HRSwgUkVNT1ZFX1RF U1QsIFJFTU9WRV9QTEFURk9STSwgQUREX1BMQVRGT1JNU19FWENFUFRfVEhJUykgPSByYW5nZSg0 KQpAQCAtNTksNyArNjAsOSBAQCBkZWYgcmVzdWx0X3dhc19leHBlY3RlZChyZXN1bHQsIGV4cGVj dGVkX3Jlc3VsdHMsIHRlc3RfbmVlZHNfcmViYXNlbGluaW5nLAogICAgICAgICB0ZXN0X2lzX3Nr aXBwZWQ6IHdoZXRoZXIgdGVzdCB3YXMgbWFya2VkIGFzIFNLSVAiIiIKICAgICBpZiByZXN1bHQg aW4gZXhwZWN0ZWRfcmVzdWx0czoKICAgICAgICAgcmV0dXJuIFRydWUKLSAgICBpZiByZXN1bHQg aW4gKElNQUdFLCBURVhULCBJTUFHRV9QTFVTX1RFWFQpIGFuZCBGQUlMIGluIGV4cGVjdGVkX3Jl c3VsdHM6CisgICAgaWYgKHJlc3VsdCBpbiAoSU1BR0UsIFRFWFQsIElNQUdFX1BMVVNfVEVYVCwg UkVGRVJFTkNFX01JU01BVENILAorICAgICAgICAgICAgICAgICAgIFJFRkVSRU5DRV9NQVRDSCkK KyAgICAgICAgYW5kIEZBSUwgaW4gZXhwZWN0ZWRfcmVzdWx0cyk6CiAgICAgICAgIHJldHVybiBU cnVlCiAgICAgaWYgcmVzdWx0ID09IE1JU1NJTkcgYW5kIHRlc3RfbmVlZHNfcmViYXNlbGluaW5n OgogICAgICAgICByZXR1cm4gVHJ1ZQpAQCAtMjU1LDYgKzI1OCw4IEBAIGNsYXNzIFRlc3RFeHBl Y3RhdGlvbnNGaWxlOgogICAgICAgICAgICAgICAgICAgICAndGV4dCc6IFRFWFQsCiAgICAgICAg ICAgICAgICAgICAgICdpbWFnZSc6IElNQUdFLAogICAgICAgICAgICAgICAgICAgICAnaW1hZ2Ur dGV4dCc6IElNQUdFX1BMVVNfVEVYVCwKKyAgICAgICAgICAgICAgICAgICAgJ3JlZmVyZW5jZV9t aXNtYXRjaCc6IFJFRkVSRU5DRV9NSVNNQVRDSCwKKyAgICAgICAgICAgICAgICAgICAgJ3JlZmVy ZW5jZV9tYXRjaCc6IFJFRkVSRU5DRV9NQVRDSCwKICAgICAgICAgICAgICAgICAgICAgJ3RpbWVv dXQnOiBUSU1FT1VULAogICAgICAgICAgICAgICAgICAgICAnY3Jhc2gnOiBDUkFTSCwKICAgICAg ICAgICAgICAgICAgICAgJ21pc3NpbmcnOiBNSVNTSU5HfQpAQCAtMjY3LDYgKzI3MiwxMCBAQCBj bGFzcyBUZXN0RXhwZWN0YXRpb25zRmlsZToKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgSU1BR0U6ICgnaW1hZ2UgbWlzbWF0Y2gnLCAnaW1hZ2UgbWlzbWF0Y2gnKSwKICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgSU1BR0VfUExVU19URVhUOiAoJ2ltYWdlIGFuZCB0ZXh0 IG1pc21hdGNoJywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgJ2ltYWdlIGFuZCB0ZXh0IG1pc21hdGNoJyksCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIFJFRkVSRU5DRV9NSVNNQVRDSDogKCdyZWZlcmVuY2UgbWlzbWF0Y2gnLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ3JlZmVyZW5j ZSBtaXNtYXRjaCcpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBSRUZFUkVOQ0Vf TUFUQ0g6ICgncmVmZXJlbmNlIG1hdGNoJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICdyZWZlcmVuY2UgbWF0Y2gnKSwKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgQ1JBU0g6ICgnRHVtcFJlbmRlclRyZWUgY3Jhc2gnLAogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdEdW1wUmVuZGVyVHJlZSBjcmFzaGVz JyksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFRJTUVPVVQ6ICgndGVzdCB0aW1l ZCBvdXQnLCAndGVzdHMgdGltZWQgb3V0JyksCkBAIC0yNzQsNyArMjgzLDcgQEAgY2xhc3MgVGVz dEV4cGVjdGF0aW9uc0ZpbGU6CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAnbm8gZXhwZWN0ZWQgcmVzdWx0cyBmb3VuZCcpfQogCiAgICAgRVhQRUNUQVRJT05fT1JE RVIgPSAoUEFTUywgQ1JBU0gsIFRJTUVPVVQsIE1JU1NJTkcsIElNQUdFX1BMVVNfVEVYVCwKLSAg ICAgICBURVhULCBJTUFHRSwgRkFJTCwgU0tJUCkKKyAgICAgICBURVhULCBJTUFHRSwgUkVGRVJF TkNFX01JU01BVENILCBSRUZFUkVOQ0VfTUFUQ0gsIEZBSUwsIFNLSVApCiAKICAgICBCVUlMRF9U WVBFUyA9ICgnZGVidWcnLCAncmVsZWFzZScpCiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL3Rlc3RfZmFpbHVyZXMu cHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFj a2FnZS90ZXN0X2ZhaWx1cmVzLnB5CmluZGV4IDZkNTU3NjEwZmJmMWI2MzY0ZTQ4ZTgyNGQwMjFi NTJmZjc5YzcxZjguLjAxZDc5MGFiM2JiMTYyMzI5ODJhZDU4NDRjYzJkNmFhNGZmNWMwYjIgMTAw NjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91 dF9wYWNrYWdlL3Rlc3RfZmFpbHVyZXMucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJr aXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvdGVzdF9mYWlsdXJlcy5weQpAQCAtNjQs NiArNjQsMTAgQEAgZGVmIGRldGVybWluZV9yZXN1bHRfdHlwZShmYWlsdXJlX2xpc3QpOgogICAg ICAgICAgICAgcmV0dXJuIHRlc3RfZXhwZWN0YXRpb25zLlRFWFQKICAgICAgICAgZWxpZiBpc19p bWFnZV9mYWlsdXJlOgogICAgICAgICAgICAgcmV0dXJuIHRlc3RfZXhwZWN0YXRpb25zLklNQUdF CisgICAgICAgIGVsaWYgRmFpbHVyZVJlZmVyZW5jZU1pc21hdGNoIGluIGZhaWx1cmVfdHlwZXM6 CisgICAgICAgICAgICByZXR1cm4gdGVzdF9leHBlY3RhdGlvbnMuUkVGRVJFTkNFX01JU01BVENI CisgICAgICAgIGVsaWYgRmFpbHVyZVJlZmVyZW5jZU1hdGNoIGluIGZhaWx1cmVfdHlwZXM6Cisg ICAgICAgICAgICByZXR1cm4gdGVzdF9leHBlY3RhdGlvbnMuUkVGRVJFTkNFX01BVENICiAgICAg ICAgIGVsc2U6CiAgICAgICAgICAgICByYWlzZSBWYWx1ZUVycm9yKCJ1bmNsYXNzaWZpYWJsZSBz ZXQgb2YgZmFpbHVyZXM6ICIKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKyBzdHIoZmFp bHVyZV90eXBlcykpCkBAIC0yNzQsNiArMjc4LDQ0IEBAIGNsYXNzIEZhaWx1cmVJbWFnZUhhc2hJ bmNvcnJlY3QoRmFpbHVyZVdpdGhUeXBlKToKICAgICBkZWYgcmVzdWx0X2h0bWxfb3V0cHV0KHNl bGYsIGZpbGVuYW1lKToKICAgICAgICAgcmV0dXJuICI8c3Ryb25nPiVzPC9zdHJvbmc+IiAlIHNl bGYubWVzc2FnZSgpCiAKKworY2xhc3MgRmFpbHVyZVJlZmVyZW5jZU1pc21hdGNoKEZhaWx1cmVX aXRoVHlwZSk6CisgICAgIiIiVGhlIHJlc3VsdCBkaWRuJ3QgbWF0Y2ggdGhlIHJlZmVyZW5jZSBy ZW5kZXJpbmcuIiIiCisgICAgT1VUX0ZJTEVOQU1FUyA9ICgiLWFjdHVhbC5wbmciLCAiLWV4cGVj dGVkLmh0bWwiLCAiLWV4cGVjdGVkLnBuZyIsCisgICAgICAgICAgICAgICAgICAgICAiLWRpZmYu cG5nIiwpCisKKyAgICBAc3RhdGljbWV0aG9kCisgICAgZGVmIG1lc3NhZ2UoKToKKyAgICAgICAg cmV0dXJuICJSZWZlcmVuY2UgbWlzbWF0Y2giCisKKyAgICBkZWYgb3V0cHV0X2xpbmtzKHNlbGYs IGZpbGVuYW1lLCBvdXRfbmFtZXMpOgorICAgICAgICBsaW5rcyA9IFsnJ10KKyAgICAgICAgdXJp cyA9IFtzZWxmLnJlbGF0aXZlX291dHB1dF9maWxlbmFtZShmaWxlbmFtZSwgZm4pIGZvcgorICAg ICAgICAgICAgICAgIGZuIGluIG91dF9uYW1lc10KKyAgICAgICAgZm9yIHRleHQsIHVyaSBpbiB6 aXAoWydhY3R1YWwtaW1hZ2UnLCAncmVmZXJlbmNlLWh0bWwnLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgJ3JlZmVyZW5jZS1pbWFnZScsICdkaWZmJ10sIHVyaXMpOgorICAgICAgICAg ICAgbGlua3MuYXBwZW5kKCI8YSBocmVmPSclcyc+JXM8L2E+IiAlICh1cmksIHRleHQpKQorICAg ICAgICByZXR1cm4gJyAnLmpvaW4obGlua3MpCisKKworY2xhc3MgRmFpbHVyZVJlZmVyZW5jZU1h dGNoKEZhaWx1cmVXaXRoVHlwZSk6CisgICAgIiIiVW5leHBlY3RlZCBtYXRjaCBiZXR3ZWVuIHRo ZSByZXN1bHQgYW5kIHRoZSByZWZlcmVuY2UgcmVuZGVyaW5nLiIiIgorICAgIE9VVF9GSUxFTkFN RVMgPSAoIi1hY3R1YWwucG5nIiwgIi1leHBlY3RlZC1taXNtYXRjaC5odG1sIiwpCisKKyAgICBA c3RhdGljbWV0aG9kCisgICAgZGVmIG1lc3NhZ2UoKToKKyAgICAgICAgcmV0dXJuICgiVGhlcmUg d2FzIG5vIGRpZmZlcmVuY2UgYmV0d2VlbiB0aGUgcmVzdWx0IGFuZCB0aGUgcmVmZXJlbmNlIgor ICAgICAgICAgICAgICAgICIgcmVuZGVyaW5nIikKKworICAgIGRlZiBvdXRwdXRfbGlua3Moc2Vs ZiwgZmlsZW5hbWUsIG91dF9uYW1lcyk6CisgICAgICAgIGxpbmtzID0gWycnXQorICAgICAgICB1 cmlzID0gW3NlbGYucmVsYXRpdmVfb3V0cHV0X2ZpbGVuYW1lKGZpbGVuYW1lLCBmbikgZm9yCisg ICAgICAgICAgICAgICAgZm4gaW4gb3V0X25hbWVzXQorICAgICAgICBmb3IgdGV4dCwgdXJpIGlu IHppcChbJ2ltYWdlJywgJ3JlZmVyZW5jZS1odG1sJ10sIHVyaXMpOgorICAgICAgICAgICAgbGlu a3MuYXBwZW5kKCI8YSBocmVmPSclcyc+JXM8L2E+IiAlICh1cmksIHRleHQpKQorICAgICAgICBy ZXR1cm4gJyAnLmpvaW4obGlua3MpCisKKwogIyBDb252ZW5pZW50IGNvbGxlY3Rpb24gb2YgYWxs IGZhaWx1cmUgY2xhc3NlcyBmb3IgYW55dGhpbmcgdGhhdCBtaWdodAogIyBuZWVkIHRvIGVudW1l cmF0ZSBvdmVyIHRoZW0gYWxsLgogQUxMX0ZBSUxVUkVfQ0xBU1NFUyA9IChGYWlsdXJlVGltZW91 dCwgRmFpbHVyZUNyYXNoLCBGYWlsdXJlTWlzc2luZ1Jlc3VsdCwKZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZS5weSBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZS5weQppbmRleCBj ZDdkNjYzOTAzNDA0YTVkNWUwNGQ5NjgwZjcyODhhOTViNTRhYjdiLi5hZmVmNGFhNWMwMzIwNmRl ODE5ZmEzOGIxZTU2ZWQxMzZjMzI3OTgxIDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKKysrIGIvV2ViS2l0VG9vbHMvU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9iYXNlLnB5CkBAIC0zMzQsNiArMzM0LDE1 IEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgICAgIHJldHVybiAnJwogICAgICAgICBy ZXR1cm4gdGV4dC5zdHJpcCgiXHJcbiIpLnJlcGxhY2UoIlxyXG4iLCAiXG4iKSArICJcbiIKIAor ICAgIGRlZiBleHBlY3RlZF9odG1sX2ZpbGVuYW1lKHNlbGYsIGZpbGVuYW1lKToKKyAgICAgICAg IiIiUmV0dXJuIHRoZSBmaWxlbmFtZSBvZiByZWZlcmVuY2UgSFRNTCB3ZSBleHBlY3QgdGhlIHRl c3QgbWF0Y2hlcy4iIiIKKyAgICAgICAgcmV0dXJuIHNlbGYuZXhwZWN0ZWRfZmlsZW5hbWUoZmls ZW5hbWUsICcuaHRtbCcpCisKKyAgICBkZWYgZXhwZWN0ZWRfbWlzbWF0Y2hfaHRtbF9maWxlbmFt ZShzZWxmLCBmaWxlbmFtZSk6CisgICAgICAgICIiIlJldHVybiB0aGUgZmlsZW5hbWUgb2YgcmVm ZXJlbmNlIEhUTUwgd2UgZG9uJ3QgZXhwZWN0IHRoZSB0ZXN0CisgICAgICAgIG1hdGNoZXMuIiIi CisgICAgICAgIHJldHVybiBzZWxmLmV4cGVjdGVkX2ZpbGVuYW1lKGZpbGVuYW1lLCAnLW1pc21h dGNoLmh0bWwnKQorCiAgICAgZGVmIGZpbGVuYW1lX3RvX3VyaShzZWxmLCBmaWxlbmFtZSk6CiAg ICAgICAgICIiIkNvbnZlcnQgYSB0ZXN0IGZpbGUgKHdoaWNoIGlzIGFuIGFic29sdXRlIHBhdGgp IHRvIGEgVVJJLiIiIgogICAgICAgICBMQVlPVVRURVNUX0hUVFBfRElSID0gImh0dHAvdGVzdHMv IgpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC90ZXN0X2ZpbGVzLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC90ZXN0X2ZpbGVzLnB5CmluZGV4IDNmYTBmYjM2NGJiMzE5NjAyZTYxOWFkZjVk ZDUxZDMyYjBmNTdhNTIuLmQ2YjI4MzY2NjUzY2JmNTM4ODM4Zjc5Y2QyNTk2NGNlMzExYTg3ZWIg MTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvdGVzdF9maWxlcy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L3Rlc3RfZmlsZXMucHkKQEAgLTUwLDYgKzUwLDkgQEAgX3N1cHBvcnRlZF9m aWxlX2V4dGVuc2lvbnMgPSBzZXQoWycuaHRtbCcsICcuc2h0bWwnLCAnLnhtbCcsICcueGh0bWwn LCAnLnhodG1sbXAKICMgV2hlbiBjb2xsZWN0aW5nIHRlc3QgY2FzZXMsIHNraXAgdGhlc2UgZGly ZWN0b3JpZXMKIF9za2lwcGVkX2RpcmVjdG9yaWVzID0gc2V0KFsnLnN2bicsICdfc3ZuJywgJ3Jl c291cmNlcycsICdzY3JpcHQtdGVzdHMnXSkKIAorIyBXaGVuIGNvbGxlY3RpbmcgdGVzdCBjYXNl cywgc2tpcCBmaWxlcyB3aXRoIHRoZXNlIHN1ZmZpeGVzLgorX3NraXBwZWRfc3VmZml4ZXMgPSBz ZXQoWyctZXhwZWN0ZWQuaHRtbCcsICdleHBlY3RlZC1taXNtYXRjaC5odG1sJ10pCisKIAogZGVm IGZpbmQocG9ydCwgcGF0aHMpOgogICAgICIiIkZpbmRzIHRoZSBzZXQgb2YgdGVzdHMgdW5kZXIg cG9ydC5sYXlvdXRfdGVzdHNfZGlyKCkuCkBAIC03OCw3ICs4MSw3IEBAIGRlZiBmaW5kKHBvcnQs IHBhdGhzKToKICAgICAjIE5vdyB3YWxrIGFsbCB0aGUgcGF0aHMgcGFzc2VkIGluIG9uIHRoZSBj b21tYW5kIGxpbmUgYW5kIGdldCBmaWxlbmFtZXMKICAgICB0ZXN0X2ZpbGVzID0gc2V0KCkKICAg ICBmb3IgcGF0aCBpbiBwYXRoc190b193YWxrOgotICAgICAgICBpZiBvcy5wYXRoLmlzZmlsZShw YXRoKSBhbmQgX2hhc19zdXBwb3J0ZWRfZXh0ZW5zaW9uKHBhdGgpOgorICAgICAgICBpZiBvcy5w YXRoLmlzZmlsZShwYXRoKSBhbmQgX2lzX3Rlc3RfZmlsZShwYXRoKToKICAgICAgICAgICAgIHRl c3RfZmlsZXMuYWRkKG9zLnBhdGgubm9ybXBhdGgocGF0aCkpCiAgICAgICAgICAgICBjb250aW51 ZQogCkBAIC05NSw3ICs5OCw3IEBAIGRlZiBmaW5kKHBvcnQsIHBhdGhzKToKICAgICAgICAgICAg ICAgICAgICAgZGlycy5yZW1vdmUoZGlyZWN0b3J5KQogCiAgICAgICAgICAgICBmb3IgZmlsZW5h bWUgaW4gZmlsZXM6Ci0gICAgICAgICAgICAgICAgaWYgX2hhc19zdXBwb3J0ZWRfZXh0ZW5zaW9u KGZpbGVuYW1lKToKKyAgICAgICAgICAgICAgICBpZiBfaXNfdGVzdF9maWxlKGZpbGVuYW1lKToK ICAgICAgICAgICAgICAgICAgICAgZmlsZW5hbWUgPSBvcy5wYXRoLmpvaW4ocm9vdCwgZmlsZW5h bWUpCiAgICAgICAgICAgICAgICAgICAgIGZpbGVuYW1lID0gb3MucGF0aC5ub3JtcGF0aChmaWxl bmFtZSkKICAgICAgICAgICAgICAgICAgICAgdGVzdF9maWxlcy5hZGQoZmlsZW5hbWUpCkBAIC0x MTEsMyArMTE0LDE1IEBAIGRlZiBfaGFzX3N1cHBvcnRlZF9leHRlbnNpb24oZmlsZW5hbWUpOgog ICAgIHRlc3Qgb24uIiIiCiAgICAgZXh0ZW5zaW9uID0gb3MucGF0aC5zcGxpdGV4dChmaWxlbmFt ZSlbMV0KICAgICByZXR1cm4gZXh0ZW5zaW9uIGluIF9zdXBwb3J0ZWRfZmlsZV9leHRlbnNpb25z CisKKworZGVmIF9pc19za2lwcGVkX2ZpbGUoZmlsZW5hbWUpOgorICAgICIiIlJldHVybiB0cnVl IGlmIGZpbGVuYW1lIHNob3VsZCBiZSBza2lwcGVkLiIiIgorICAgIHJldHVybiBhbnkoZmlsZW5h bWUuZW5kc3dpdGgoc2tpcHBlZF9zdWZmaXgpIGZvciBza2lwcGVkX3N1ZmZpeAorICAgICAgICAg ICAgICAgaW4gX3NraXBwZWRfc3VmZml4ZXMpCisKKworZGVmIF9pc190ZXN0X2ZpbGUoZmlsZW5h bWUpOgorICAgICIiIlJldHVybiB0cnVlIGlmIGZpbGVuYW1lIHJlcHJlc2VudHMgdGVzdCBjYXNl cyB3ZSB3YW50IHRvIHJ1biBhIHRlc3QKKyAgICBvbi4iIiIKKyAgICByZXR1cm4gX2hhc19zdXBw b3J0ZWRfZXh0ZW5zaW9uKGZpbGVuYW1lKSBhbmQgbm90IF9pc19za2lwcGVkX2ZpbGUoZmlsZW5h bWUpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L3dlYmtpdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvd2Via2l0LnB5CmluZGV4IDBkMGQzZTAwMWI3OTkzNTdkYjQ5NTY1MWRjYTc1Yjhl ZDI3YWE4NzkuLmNlYTI0MDRhOTY2OWM3MDE1MTMxOWJjNzFhYzYwMjE5ZDNkYzk0ZGIgMTAwNjQ0 Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Vi a2l0LnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvd2Via2l0LnB5CkBAIC0xMjIsNyArMTIyLDcgQEAgY2xhc3MgV2ViS2l0UG9ydChiYXNlLlBv cnQpOgogICAgICAgICByZXR1cm4gVHJ1ZQogCiAgICAgZGVmIGRpZmZfaW1hZ2Uoc2VsZiwgZXhw ZWN0ZWRfY29udGVudHMsIGFjdHVhbF9jb250ZW50cywKLSAgICAgICAgICAgICAgICAgICBkaWZm X2ZpbGVuYW1lPU5vbmUpOgorICAgICAgICAgICAgICAgICAgIGRpZmZfZmlsZW5hbWU9Tm9uZSwg dG9sZXJhbmNlPU5vbmUpOgogICAgICAgICAiIiJSZXR1cm4gVHJ1ZSBpZiB0aGUgdHdvIGZpbGVz IGFyZSBkaWZmZXJlbnQuIEFsc28gd3JpdGUgYSBkZWx0YQogICAgICAgICBpbWFnZSBvZiB0aGUg dHdvIGltYWdlcyBpbnRvIHxkaWZmX2ZpbGVuYW1lfCBpZiBpdCBpcyBub3QgTm9uZS4iIiIKIApA QCAtMTMwLDE0ICsxMzAsMTggQEAgY2xhc3MgV2ViS2l0UG9ydChiYXNlLlBvcnQpOgogICAgICAg ICBpZiBub3QgYWN0dWFsX2NvbnRlbnRzOgogICAgICAgICAgICAgcmV0dXJuIFRydWUKIAotICAg ICAgICBzcCA9IHNlbGYuX2RpZmZfaW1hZ2VfcmVxdWVzdChleHBlY3RlZF9jb250ZW50cywgYWN0 dWFsX2NvbnRlbnRzKQorICAgICAgICBzcCA9IHNlbGYuX2RpZmZfaW1hZ2VfcmVxdWVzdChleHBl Y3RlZF9jb250ZW50cywgYWN0dWFsX2NvbnRlbnRzLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB0b2xlcmFuY2UpCiAgICAgICAgIHJldHVybiBzZWxmLl9kaWZmX2ltYWdl X3JlcGx5KHNwLCBkaWZmX2ZpbGVuYW1lKQogCi0gICAgZGVmIF9kaWZmX2ltYWdlX3JlcXVlc3Qo c2VsZiwgZXhwZWN0ZWRfY29udGVudHMsIGFjdHVhbF9jb250ZW50cyk6CisgICAgZGVmIF9kaWZm X2ltYWdlX3JlcXVlc3Qoc2VsZiwgZXhwZWN0ZWRfY29udGVudHMsIGFjdHVhbF9jb250ZW50cywK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICB0b2xlcmFuY2U9Tm9uZSk6CiAgICAgICAgICMg RklYTUU6IHVzZSBzZWxmLmdldF9vcHRpb24oJ3RvbGVyYW5jZScpIGFuZAogICAgICAgICAjIHNl bGYuc2V0X29wdGlvbl9kZWZhdWx0KCd0b2xlcmFuY2UnLCAwLjEpIG9uY2UgdGhhdCBiZWhhdmVz IGNvcnJlY3RseQogICAgICAgICAjIHdpdGggZGVmYXVsdCB2YWx1ZXMuCi0gICAgICAgIGlmIHNl bGYuZ2V0X29wdGlvbigndG9sZXJhbmNlJykgaXMgbm90IE5vbmU6CisgICAgICAgIGlmIHRvbGVy YW5jZSBpcyBub3QgTm9uZToKKyAgICAgICAgICAgIHBhc3MKKyAgICAgICAgZWxpZiBzZWxmLmdl dF9vcHRpb24oJ3RvbGVyYW5jZScpIGlzIG5vdCBOb25lOgogICAgICAgICAgICAgdG9sZXJhbmNl ID0gc2VsZi5nZXRfb3B0aW9uKCd0b2xlcmFuY2UnKQogICAgICAgICBlbHNlOgogICAgICAgICAg ICAgdG9sZXJhbmNlID0gMC4xCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQppbmRleCBmMTAzYmNk NmQ3ZDkwNmMwM2Q3NzIzOWUzYmIzZDNkOTA0NzkwNTk5Li45OGQyZGUwYTcxMjQ3MWQ5MmQwYmYw N2Q5ZDAyMWQwNmJmYjQ5OGY1IDEwMDc1NQotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5CisrKyBiL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKQEAgLTcyLDYg KzcyLDcgQEAgZnJvbSBsYXlvdXRfcGFja2FnZSBpbXBvcnQgdGVzdF9mYWlsdXJlcwogZnJvbSBs YXlvdXRfcGFja2FnZSBpbXBvcnQgdGVzdF9yZXN1bHRzCiBmcm9tIGxheW91dF9wYWNrYWdlIGlt cG9ydCB0ZXN0X3Jlc3VsdHNfdXBsb2FkZXIKIGZyb20gdGVzdF90eXBlcyBpbXBvcnQgaW1hZ2Vf ZGlmZgorZnJvbSB0ZXN0X3R5cGVzIGltcG9ydCByZWZlcmVuY2VfZGlmZgogZnJvbSB0ZXN0X3R5 cGVzIGltcG9ydCB0ZXh0X2RpZmYKIGZyb20gdGVzdF90eXBlcyBpbXBvcnQgdGVzdF90eXBlX2Jh c2UKIApAQCAtMTA1LDYgKzEwNiwyNCBAQCBjbGFzcyBUZXN0SW5mbzoKICAgICAgICAgc2VsZi50 aW1lb3V0ID0gdGltZW91dAogICAgICAgICBzZWxmLl9pbWFnZV9jaGVja3N1bSA9IC0xCiAKKyAg ICAgICAgIyBGSVhNRTogRGV0ZWN0IGFuZCByZXBvcnQgYW4gdGVzdCB3aGljaCBoYXMgYSB3cm9u ZyBjb21iaW5hdGlvbiBvZgorICAgICAgICAjIGV4cGVjdGF0aW9uIGZpbGVzLiBGb3IgZXhhbXBs ZSwgaWYgJ2Zvby5odG1sJyBoYXMgdHdvIGV4cGVjdGF0aW9uIGZpbGVzLAorICAgICAgICAjICdm b28tZXhwZWN0ZWQuaHRtbCcgYW5kICdmb28tZXhwZWN0ZWQudHh0Jywgd2Ugc2hvdWxkIHdhcm4g dXNlcnMuCisgICAgICAgIHNlbGYuaXNfcmVmdGVzdCA9IEZhbHNlCisgICAgICAgIGV4cGVjdGVk X2h0bWxfZmlsZW5hbWUgPSBwb3J0LmV4cGVjdGVkX2h0bWxfZmlsZW5hbWUoZmlsZW5hbWUpCisg ICAgICAgIGlmIG9zLnBhdGguaXNmaWxlKGV4cGVjdGVkX2h0bWxfZmlsZW5hbWUpOgorICAgICAg ICAgICAgc2VsZi5pc19yZWZ0ZXN0ID0gVHJ1ZQorICAgICAgICAgICAgc2VsZi5leHBlY3RlZF9o dG1sX2ZpbGVuYW1lID0gZXhwZWN0ZWRfaHRtbF9maWxlbmFtZQorICAgICAgICBlbHNlOgorICAg ICAgICAgICAgc2VsZi5leHBlY3RlZF9odG1sX2ZpbGVuYW1lID0gTm9uZQorCisgICAgICAgIGV4 cGVjdGVkX21pc21hdGNoX2h0bWxfZmlsZW5hbWUgPSBwb3J0LmV4cGVjdGVkX21pc21hdGNoX2h0 bWxfZmlsZW5hbWUoZmlsZW5hbWUpCisgICAgICAgIGlmIG9zLnBhdGguaXNmaWxlKGV4cGVjdGVk X21pc21hdGNoX2h0bWxfZmlsZW5hbWUpOgorICAgICAgICAgICAgc2VsZi5pc19yZWZ0ZXN0ID0g VHJ1ZQorICAgICAgICAgICAgc2VsZi5leHBlY3RlZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1lID0g ZXhwZWN0ZWRfbWlzbWF0Y2hfaHRtbF9maWxlbmFtZQorICAgICAgICBlbHNlOgorICAgICAgICAg ICAgc2VsZi5leHBlY3RlZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1lID0gTm9uZQorCiAgICAgZGVm IGltYWdlX2hhc2goc2VsZik6CiAgICAgICAgICMgUmVhZCB0aGUgaW1hZ2VfaGFzaCBsYXppbHkg dG8gcmVkdWNlIHN0YXJ0dXAgdGltZS4KICAgICAgICAgIyBUaGlzIGNsYXNzIGlzIGFjY2Vzc2Vk IGFjcm9zcyB0aHJlYWRzLCBidXQgb25seSBvbmUgdGhyZWFkIHNob3VsZApAQCAtMjcxLDYgKzI5 MCwxMCBAQCBjbGFzcyBUZXN0UnVubmVyOgogICAgICAgICBpZiBvcHRpb25zLnBpeGVsX3Rlc3Rz OgogICAgICAgICAgICAgc2VsZi5fdGVzdF90eXBlcy5hcHBlbmQoaW1hZ2VfZGlmZi5JbWFnZURp ZmYpCiAKKyAgICAgICAgc2VsZi5fcmVmdGVzdF90eXBlcyA9IFtdCisgICAgICAgIGlmIG9wdGlv bnMucnVuX3JlZnRlc3RzOgorICAgICAgICAgICAgc2VsZi5fcmVmdGVzdF90eXBlcy5hcHBlbmQo cmVmZXJlbmNlX2RpZmYuUmVmZXJlbmNlRGlmZikKKwogICAgICAgICAjIGEgc2V0IG9mIHRlc3Qg ZmlsZXMsIGFuZCB0aGUgc2FtZSB0ZXN0cyBhcyBhIGxpc3QKICAgICAgICAgc2VsZi5fdGVzdF9m aWxlcyA9IHNldCgpCiAgICAgICAgIHNlbGYuX3Rlc3RfZmlsZXNfbGlzdCA9IE5vbmUKQEAgLTUz Miw2ICs1NTUsOCBAQCBjbGFzcyBUZXN0UnVubmVyOgogICAgICAgICAgICAgc2VsZi5faXNfc2lu Z2xlX3RocmVhZGVkKCkpOgogICAgICAgICAgICAgZm9yIHRlc3RfZmlsZSBpbiB0ZXN0X2ZpbGVz OgogICAgICAgICAgICAgICAgIHRlc3RfaW5mbyA9IHNlbGYuX2dldF90ZXN0X2luZm9fZm9yX2Zp bGUodGVzdF9maWxlKQorICAgICAgICAgICAgICAgIGlmIG5vdCBzZWxmLl9vcHRpb25zLnJ1bl9y ZWZ0ZXN0cyBhbmQgdGVzdF9pbmZvLmlzX3JlZnRlc3Q6CisgICAgICAgICAgICAgICAgICAgIGNv bnRpbnVlCiAgICAgICAgICAgICAgICAgaWYgc2VsZi5fdGVzdF9yZXF1aXJlc19sb2NrKHRlc3Rf ZmlsZSk6CiAgICAgICAgICAgICAgICAgICAgIHRlc3RzX3RvX2h0dHBfbG9jay5hcHBlbmQodGVz dF9pbmZvKQogICAgICAgICAgICAgICAgIGVsc2U6CkBAIC01NDEsNiArNTY2LDkgQEAgY2xhc3Mg VGVzdFJ1bm5lcjoKICAgICAgICAgICAgIGZvciB0ZXN0X2ZpbGUgaW4gdGVzdF9maWxlczoKICAg ICAgICAgICAgICAgICBkaXJlY3RvcnkgPSBzZWxmLl9nZXRfZGlyX2Zvcl90ZXN0X2ZpbGUodGVz dF9maWxlKQogICAgICAgICAgICAgICAgIHRlc3RfaW5mbyA9IHNlbGYuX2dldF90ZXN0X2luZm9f Zm9yX2ZpbGUodGVzdF9maWxlKQorCisgICAgICAgICAgICAgICAgaWYgbm90IHNlbGYuX29wdGlv bnMucnVuX3JlZnRlc3RzIGFuZCB0ZXN0X2luZm8uaXNfcmVmdGVzdDoKKyAgICAgICAgICAgICAg ICAgICAgY29udGludWUKICAgICAgICAgICAgICAgICBpZiBzZWxmLl90ZXN0X3JlcXVpcmVzX2xv Y2sodGVzdF9maWxlKToKICAgICAgICAgICAgICAgICAgICAgdGVzdHNfdG9faHR0cF9sb2NrLmFw cGVuZCh0ZXN0X2luZm8pCiAgICAgICAgICAgICAgICAgZWxzZToKQEAgLTU3Nyw3ICs2MDUsNyBA QCBjbGFzcyBUZXN0UnVubmVyOgogICAgICAgICAiIiJSZXR1cm5zIHRoZSB0dXBsZSBvZiBhcmd1 bWVudHMgZm9yIHRlc3RzIGFuZCBmb3IgRHVtcFJlbmRlclRyZWUuIiIiCiAgICAgICAgIHRlc3Rf YXJncyA9IHRlc3RfdHlwZV9iYXNlLlRlc3RBcmd1bWVudHMoKQogICAgICAgICB0ZXN0X2FyZ3Mu cG5nX3BhdGggPSBOb25lCi0gICAgICAgIGlmIHNlbGYuX29wdGlvbnMucGl4ZWxfdGVzdHM6Cisg ICAgICAgIGlmIHNlbGYuX29wdGlvbnMucGl4ZWxfdGVzdHMgb3Igc2VsZi5fb3B0aW9ucy5ydW5f cmVmdGVzdHM6CiAgICAgICAgICAgICBwbmdfcGF0aCA9IG9zLnBhdGguam9pbihzZWxmLl9vcHRp b25zLnJlc3VsdHNfZGlyZWN0b3J5LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgInBuZ19yZXN1bHQlcy5wbmciICUgaW5kZXgpCiAgICAgICAgICAgICB0ZXN0X2FyZ3MucG5n X3BhdGggPSBwbmdfcGF0aApAQCAtNjA1LDE1ICs2MzMsMTUgQEAgY2xhc3MgVGVzdFJ1bm5lcjoK ICAgICAgICAgdGhyZWFkcyA9IFtdCiAgICAgICAgIGZvciBpIGluIHhyYW5nZShpbnQoc2VsZi5f b3B0aW9ucy5jaGlsZF9wcm9jZXNzZXMpKToKICAgICAgICAgICAgICMgQ3JlYXRlIHNlcGFyYXRl IFRlc3RUeXBlcyBpbnN0YW5jZXMgZm9yIGVhY2ggdGhyZWFkLgotICAgICAgICAgICAgdGVzdF90 eXBlcyA9IFtdCi0gICAgICAgICAgICBmb3IgdGVzdF90eXBlIGluIHNlbGYuX3Rlc3RfdHlwZXM6 Ci0gICAgICAgICAgICAgICAgdGVzdF90eXBlcy5hcHBlbmQodGVzdF90eXBlKHNlbGYuX3BvcnQs Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxmLl9vcHRpb25zLnJlc3Vs dHNfZGlyZWN0b3J5KSkKKyAgICAgICAgICAgIHRlc3RfdHlwZXMgPSBbdGVzdF90eXBlKHNlbGYu X3BvcnQsIHNlbGYuX29wdGlvbnMucmVzdWx0c19kaXJlY3RvcnkpCisgICAgICAgICAgICAgICAg ICAgICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gc2VsZi5fdGVzdF90eXBlc10KKyAgICAgICAgICAg IHJlZnRlc3RfdHlwZXMgPSBbdGVzdF90eXBlKHNlbGYuX3BvcnQsIHNlbGYuX29wdGlvbnMucmVz dWx0c19kaXJlY3RvcnkpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZvciB0ZXN0X3R5 cGUgaW4gc2VsZi5fcmVmdGVzdF90eXBlc10KIAogICAgICAgICAgICAgdGVzdF9hcmdzID0gc2Vs Zi5fZ2V0X3Rlc3RfYXJncyhpKQogICAgICAgICAgICAgdGhyZWFkID0gZHVtcF9yZW5kZXJfdHJl ZV90aHJlYWQuVGVzdFNoZWxsVGhyZWFkKHNlbGYuX3BvcnQsCiAgICAgICAgICAgICAgICAgc2Vs Zi5fb3B0aW9ucywgZmlsZW5hbWVfcXVldWUsIHNlbGYuX3Jlc3VsdF9xdWV1ZSwKLSAgICAgICAg ICAgICAgICB0ZXN0X3R5cGVzLCB0ZXN0X2FyZ3MpCisgICAgICAgICAgICAgICAgdGVzdF90eXBl cywgcmVmdGVzdF90eXBlcywgdGVzdF9hcmdzKQogICAgICAgICAgICAgaWYgc2VsZi5faXNfc2lu Z2xlX3RocmVhZGVkKCk6CiAgICAgICAgICAgICAgICAgdGhyZWFkLnJ1bl9pbl9tYWluX3RocmVh ZChzZWxmLCByZXN1bHRfc3VtbWFyeSkKICAgICAgICAgICAgIGVsc2U6CkBAIC0xMDc3LDIzICsx MTA1LDE3IEBAIGNsYXNzIFRlc3RSdW5uZXI6CiAgICAgICAgICAgaW5kaXZpZHVhbF90ZXN0X3Rp bWluZ3M6IExpc3Qgb2YgZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQuVGVzdFN0YXRzCiAgICAgICAg ICAgICAgIGZvciBhbGwgdGVzdHMuCiAgICAgICAgICIiIgotICAgICAgICB0ZXN0X3R5cGVzID0g W10gICMgVW5pdCB0ZXN0cyBkb24ndCBhY3R1YWxseSBwcm9kdWNlIGFueSB0aW1pbmdzLgotICAg ICAgICBpZiBpbmRpdmlkdWFsX3Rlc3RfdGltaW5nczoKLSAgICAgICAgICAgIHRlc3RfdHlwZXMg PSBpbmRpdmlkdWFsX3Rlc3RfdGltaW5nc1swXS50aW1lX2Zvcl9kaWZmcy5rZXlzKCkKICAgICAg ICAgdGltZXNfZm9yX2R1bXBfcmVuZGVyX3RyZWUgPSBbXQogICAgICAgICB0aW1lc19mb3JfZGlm Zl9wcm9jZXNzaW5nID0gW10KICAgICAgICAgdGltZXNfcGVyX3Rlc3RfdHlwZSA9IHt9Ci0gICAg ICAgIGZvciB0ZXN0X3R5cGUgaW4gdGVzdF90eXBlczoKLSAgICAgICAgICAgIHRpbWVzX3Blcl90 ZXN0X3R5cGVbdGVzdF90eXBlXSA9IFtdCiAKICAgICAgICAgZm9yIHRlc3Rfc3RhdHMgaW4gaW5k aXZpZHVhbF90ZXN0X3RpbWluZ3M6CiAgICAgICAgICAgICB0aW1lc19mb3JfZHVtcF9yZW5kZXJf dHJlZS5hcHBlbmQodGVzdF9zdGF0cy50ZXN0X3J1bl90aW1lKQogICAgICAgICAgICAgdGltZXNf Zm9yX2RpZmZfcHJvY2Vzc2luZy5hcHBlbmQoCiAgICAgICAgICAgICAgICAgdGVzdF9zdGF0cy50 b3RhbF90aW1lX2Zvcl9hbGxfZGlmZnMpCiAgICAgICAgICAgICB0aW1lX2Zvcl9kaWZmcyA9IHRl c3Rfc3RhdHMudGltZV9mb3JfZGlmZnMKLSAgICAgICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gdGVz dF90eXBlczoKLSAgICAgICAgICAgICAgICB0aW1lc19wZXJfdGVzdF90eXBlW3Rlc3RfdHlwZV0u YXBwZW5kKAotICAgICAgICAgICAgICAgICAgICB0aW1lX2Zvcl9kaWZmc1t0ZXN0X3R5cGVdKQor ICAgICAgICAgICAgZm9yIHRlc3RfdHlwZSwgdGltZSBpbiB0aW1lX2Zvcl9kaWZmcy5pdGVyaXRl bXMoKToKKyAgICAgICAgICAgICAgICB0aW1lc19wZXJfdGVzdF90eXBlLmdldCh0ZXN0X3R5cGUs IFtdKS5hcHBlbmQodGltZSkKIAogICAgICAgICBzZWxmLl9wcmludF9zdGF0aXN0aWNzX2Zvcl90 ZXN0X3RpbWluZ3MoCiAgICAgICAgICAgICAiUEVSIFRFU1QgVElNRSBJTiBURVNUU0hFTEwgKHNl Y29uZHMpOiIsCkBAIC0xMTAxLDEwICsxMTIzLDkgQEAgY2xhc3MgVGVzdFJ1bm5lcjoKICAgICAg ICAgc2VsZi5fcHJpbnRfc3RhdGlzdGljc19mb3JfdGVzdF90aW1pbmdzKAogICAgICAgICAgICAg IlBFUiBURVNUIERJRkYgUFJPQ0VTU0lORyBUSU1FUyAoc2Vjb25kcyk6IiwKICAgICAgICAgICAg IHRpbWVzX2Zvcl9kaWZmX3Byb2Nlc3NpbmcpCi0gICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gdGVz dF90eXBlczoKKyAgICAgICAgZm9yIHRlc3RfdHlwZSwgdGltZSBpbiB0aW1lc19wZXJfdGVzdF90 eXBlLml0ZXJpdGVtcygpOgogICAgICAgICAgICAgc2VsZi5fcHJpbnRfc3RhdGlzdGljc19mb3Jf dGVzdF90aW1pbmdzKAotICAgICAgICAgICAgICAgICJQRVIgVEVTVCBUSU1FUyBCWSBURVNUIFRZ UEU6ICVzIiAlIHRlc3RfdHlwZSwKLSAgICAgICAgICAgICAgICB0aW1lc19wZXJfdGVzdF90eXBl W3Rlc3RfdHlwZV0pCisgICAgICAgICAgICAgICAgIlBFUiBURVNUIFRJTUVTIEJZIFRFU1QgVFlQ RTogJXMiICUgdGVzdF90eXBlLCB0aW1lKQogCiAgICAgZGVmIF9wcmludF9pbmRpdmlkdWFsX3Rl c3RfdGltZXMoc2VsZiwgaW5kaXZpZHVhbF90ZXN0X3RpbWluZ3MsCiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmVzdWx0X3N1bW1hcnkpOgpAQCAtMTY4OSw2ICsxNzEwLDkgQEAg ZGVmIHBhcnNlX2FyZ3MoYXJncz1Ob25lKToKICAgICAgICAgb3B0cGFyc2UubWFrZV9vcHRpb24o Ii0tbm8tcmV0cnktZmFpbHVyZXMiLCBhY3Rpb249InN0b3JlX2ZhbHNlIiwKICAgICAgICAgICAg IGRlc3Q9InJldHJ5X2ZhaWx1cmVzIiwKICAgICAgICAgICAgIGhlbHA9IkRvbid0IHJlLXRyeSBh bnkgdGVzdHMgdGhhdCBwcm9kdWNlIHVuZXhwZWN0ZWQgcmVzdWx0cy4iKSwKKyAgICAgICAgb3B0 cGFyc2UubWFrZV9vcHRpb24oIi0tcnVuLXJlZnRlc3RzIiwgYWN0aW9uPSJzdG9yZV90cnVlIiwK KyAgICAgICAgICAgIGhlbHA9KCJSdW4gYWxzbyByZWZ0ZXN0cyAoZXhwZXJpbWVudGFsKS4gRG9u J3QgY29tbWl0IGFueSByZWZ0ZXN0cyAiCisgICAgICAgICAgICAgICAgICAidG8gYSByZXBvc2l0 cnkgdW50aWwgcmVmdGVzdHMgaXMgZnVsbHkgc3VwcG9ydGVkLiIpKSwKICAgICBdCiAKICAgICBt aXNjX29wdGlvbnMgPSBbCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX3VuaXR0ZXN0LnB5IGIvV2ViS2l0VG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0c191bml0dGVzdC5w eQppbmRleCAyNjcyNTA4NGE5NmZkNTM3NDI3M2QyZGQ3ZGU1N2IwMDBmMmNhOTRlLi5iNTBlMzJk OWU5YjFiZjgzNjNmOTExYzA3MzZlN2YwZjg5MzFmMjU3IDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzX3VuaXR0ZXN0 LnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93 ZWJraXRfdGVzdHNfdW5pdHRlc3QucHkKQEAgLTI3Miw3ICsyNzIsOCBAQCBjbGFzcyBNYWluVGVz dCh1bml0dGVzdC5UZXN0Q2FzZSk6CiAKICAgICAgICAgZGVmIGdldF9wb3J0X2Zvcl9ydW4oYXJn cyk6CiAgICAgICAgICAgICBvcHRpb25zLCBwYXJzZWRfYXJncyA9IHJ1bl93ZWJraXRfdGVzdHMu cGFyc2VfYXJncyhhcmdzKQotICAgICAgICAgICAgdGVzdF9wb3J0ID0gSW1hZ2VEaWZmVGVzdFBv cnQob3B0aW9ucz1vcHRpb25zLCB1c2VyPU1vY2tVc2VyKCkpCisgICAgICAgICAgICB0ZXN0X3Bv cnQgPSBJbWFnZURpZmZUZXN0UG9ydChvcHRpb25zPW9wdGlvbnMsIHVzZXI9TW9ja1VzZXIoKSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBvcnRfbmFtZT0ndGVz dCcpCiAgICAgICAgICAgICBwYXNzaW5nX3J1bihhcmdzPWFyZ3MsIHBvcnRfb2JqPXRlc3RfcG9y dCwgdGVzdHNfaW5jbHVkZWQ9VHJ1ZSkKICAgICAgICAgICAgIHJldHVybiB0ZXN0X3BvcnQKIApk aWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVz dF90eXBlcy9pbWFnZV9kaWZmLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvdGVzdF90eXBlcy9pbWFnZV9kaWZmLnB5CmluZGV4IDBiMDU4MDIwYzA4ZjRmNTFj MTE2MjA0ZGM1NGNiZjVkOWMzZTdjNmYuLmU4OGE2ODQ3OTQ3Y2I5YTNiNzBkZDE0YTc5ZDk5ZGM4 ZTc4ZDM3YWUgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0 X3Rlc3RzL3Rlc3RfdHlwZXMvaW1hZ2VfZGlmZi5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL2ltYWdlX2RpZmYucHkKQEAgLTU0LDIx ICs1NCw2IEBAIF9sb2cgPSBsb2dnaW5nLmdldExvZ2dlcigid2Via2l0cHkubGF5b3V0X3Rlc3Rz LnRlc3RfdHlwZXMuaW1hZ2VfZGlmZiIpCiAKIGNsYXNzIEltYWdlRGlmZih0ZXN0X3R5cGVfYmFz ZS5UZXN0VHlwZUJhc2UpOgogCi0gICAgZGVmIF9jb3B5X291dHB1dF9wbmcoc2VsZiwgdGVzdF9m aWxlbmFtZSwgc291cmNlX2ltYWdlLCBleHRlbnNpb24pOgotICAgICAgICAiIiJDb3BpZXMgcmVz dWx0IGZpbGVzIGludG8gdGhlIG91dHB1dCBkaXJlY3Rvcnkgd2l0aCBhcHByb3ByaWF0ZQotICAg ICAgICBuYW1lcy4KLQotICAgICAgICBBcmdzOgotICAgICAgICAgIHRlc3RfZmlsZW5hbWU6IHRo ZSB0ZXN0IGZpbGVuYW1lCi0gICAgICAgICAgc291cmNlX2ZpbGU6IHBhdGggdG8gdGhlIGltYWdl IGZpbGUgKGVpdGhlciBhY3R1YWwgb3IgZXhwZWN0ZWQpCi0gICAgICAgICAgZXh0ZW5zaW9uOiBl eHRlbnNpb24gdG8gaW5kaWNhdGUgLWFjdHVhbC5wbmcgb3IgLWV4cGVjdGVkLnBuZwotICAgICAg ICAiIiIKLSAgICAgICAgc2VsZi5fbWFrZV9vdXRwdXRfZGlyZWN0b3J5KHRlc3RfZmlsZW5hbWUp Ci0gICAgICAgIGRlc3RfaW1hZ2UgPSBzZWxmLm91dHB1dF9maWxlbmFtZSh0ZXN0X2ZpbGVuYW1l LCBleHRlbnNpb24pCi0KLSAgICAgICAgaWYgb3MucGF0aC5leGlzdHMoc291cmNlX2ltYWdlKToK LSAgICAgICAgICAgIHNodXRpbC5jb3B5ZmlsZShzb3VyY2VfaW1hZ2UsIGRlc3RfaW1hZ2UpCi0K ICAgICBkZWYgX3NhdmVfYmFzZWxpbmVfZmlsZXMoc2VsZiwgZmlsZW5hbWUsIHBuZ19wYXRoLCBj aGVja3N1bSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2VuZXJhdGVfbmV3X2Jhc2Vs aW5lKToKICAgICAgICAgIiIiU2F2ZXMgbmV3IGJhc2VsaW5lcyBmb3IgdGhlIFBORyBhbmQgY2hl Y2tzdW0uCkBAIC0xMzcsNyArMTIyLDggQEAgY2xhc3MgSW1hZ2VEaWZmKHRlc3RfdHlwZV9iYXNl LlRlc3RUeXBlQmFzZSk6CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0ZXN0 X2FyZ3MuaGFzaCwgZXhwZWN0ZWRfaGFzaCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGVuY29kaW5nPSJhc2NpaSIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBwcmludF90ZXh0X2RpZmZzPUZhbHNlKQotICAgICAgICAgICAgc2VsZi5fY29weV9vdXRw dXRfcG5nKGZpbGVuYW1lLCB0ZXN0X2FyZ3MucG5nX3BhdGgsICctYWN0dWFsLnBuZycpCisgICAg ICAgICAgICBzZWxmLl9jb3B5X291dHB1dF90b19yZXN1bHRfZGlyZWN0b3J5KGZpbGVuYW1lLCB0 ZXN0X2FyZ3MucG5nX3BhdGgsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICctYWN0dWFsLnBuZycpCiAgICAgICAgICAgICBmYWlsdXJlcy5hcHBlbmQo dGVzdF9mYWlsdXJlcy5GYWlsdXJlTWlzc2luZ0ltYWdlKCkpCiAgICAgICAgICAgICByZXR1cm4g ZmFpbHVyZXMKICAgICAgICAgZWxpZiB0ZXN0X2FyZ3MuaGFzaCA9PSBleHBlY3RlZF9oYXNoOgpA QCAtMTUwLDcgKzEzNiw4IEBAIGNsYXNzIEltYWdlRGlmZih0ZXN0X3R5cGVfYmFzZS5UZXN0VHlw ZUJhc2UpOgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwcmludF90ZXh0X2RpZmZz PUZhbHNlKQogCiAgICAgICAgICMgRklYTUU6IGNvbWJpbmUgbmV4dCB0d28gbGluZXMKLSAgICAg ICAgc2VsZi5fY29weV9vdXRwdXRfcG5nKGZpbGVuYW1lLCB0ZXN0X2FyZ3MucG5nX3BhdGgsICct YWN0dWFsLnBuZycpCisgICAgICAgIHNlbGYuX2NvcHlfb3V0cHV0X3RvX3Jlc3VsdF9kaXJlY3Rv cnkoZmlsZW5hbWUsIHRlc3RfYXJncy5wbmdfcGF0aCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAnLWFjdHVhbC5wbmcnKQogICAgICAgICBzZWxmLndyaXRl X291dHB1dF9maWxlcyhmaWxlbmFtZSwgJy5wbmcnLCBvdXRwdXQ9Tm9uZSwKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZXhwZWN0ZWQ9ZXhwZWN0ZWRfcG5nLAogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBlbmNvZGluZz1Ob25lLCBwcmludF90ZXh0X2RpZmZzPUZhbHNl KQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv dGVzdF90eXBlcy9yZWZlcmVuY2VfZGlmZi5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0 cHkvbGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvcmVmZXJlbmNlX2RpZmYucHkKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u NTZlNjM5NjAxOTRlYmQxMzRjMWU4ZmY1NTM0NzZlNGIzYTAwNzk2YgotLS0gL2Rldi9udWxsCisr KyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMv cmVmZXJlbmNlX2RpZmYucHkKQEAgLTAsMCArMSw4OSBAQAorIyEvdXNyL2Jpbi9lbnYgcHl0aG9u CisjIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor IworIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRo YXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorIyBtZXQ6CisjCisjICAgICAqIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisjIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lci4KKyMgICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZQorIyBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisjIGluIHRoZSBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyMgZGlzdHJpYnV0aW9u LgorIyAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMg b2YgaXRzCisjIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUg cHJvZHVjdHMgZGVyaXZlZCBmcm9tCisjIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBw cmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisjCisjIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQg QlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyMgIkFTIElTIiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyMg TElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SCisjIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisjIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBM SUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorIyBTUEVDSUFMLCBF WEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisj IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLAorIyBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyMgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorIyAoSU5DTFVESU5H IE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBV U0UKKyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KKworIiIiQ29tcGFyZXMgdGhlIGltYWdlIG91dHB1dCBvZiBhIHRl c3QgdG8gdGhlIGltYWdlIG91dHB1dCBvZiBhIHJlZmVyZW5jZSBmaWxlLgorIiIiCisKK2Zyb20g X19mdXR1cmVfXyBpbXBvcnQgd2l0aF9zdGF0ZW1lbnQKKworaW1wb3J0IGxvZ2dpbmcKKworZnJv bSB3ZWJraXRweS5sYXlvdXRfdGVzdHMubGF5b3V0X3BhY2thZ2UgaW1wb3J0IHRlc3RfZmFpbHVy ZXMKK2Zyb20gd2Via2l0cHkubGF5b3V0X3Rlc3RzLnRlc3RfdHlwZXMgaW1wb3J0IHRlc3RfdHlw ZV9iYXNlCisKK19sb2cgPSBsb2dnaW5nLmdldExvZ2dlcigid2Via2l0cHkubGF5b3V0X3Rlc3Rz LnRlc3RfdHlwZXMucmVmZXJlbmNlX2RpZmYiKQorCisKK2NsYXNzIFJlZmVyZW5jZURpZmYodGVz dF90eXBlX2Jhc2UuVGVzdFR5cGVCYXNlKToKKworICAgIGRlZiBjb21wYXJlX291dHB1dF93aXRo X3JlZmVyZW5jZShzZWxmLCBwb3J0LCB0ZXN0X2luZm8sCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGFjdHVhbF9pbWFnZV9oYXNoLCBhY3R1YWxfaW1hZ2VfY29udGVudHMs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlZmVyZW5jZV9pbWFnZV9o YXNoLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWZlcmVuY2VfaW1h Z2VfY29udGVudHMpOgorICAgICAgICBmYWlsdXJlcyA9IFtdCisgICAgICAgIGlmIHRlc3RfaW5m by5leHBlY3RlZF9odG1sX2ZpbGVuYW1lOgorICAgICAgICAgICAgaWYgYWN0dWFsX2ltYWdlX2hh c2ggPT0gcmVmZXJlbmNlX2ltYWdlX2hhc2g6CisgICAgICAgICAgICAgICAgcmV0dXJuIGZhaWx1 cmVzCisgICAgICAgICAgICBmYWlsdXJlcy5hcHBlbmQodGVzdF9mYWlsdXJlcy5GYWlsdXJlUmVm ZXJlbmNlTWlzbWF0Y2goKSkKKworICAgICAgICAgICAgZGlmZl9maWxlbmFtZSA9IHNlbGYub3V0 cHV0X2ZpbGVuYW1lKHRlc3RfaW5mby5maWxlbmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxmLkZJTEVOQU1FX1NVRkZJWF9DT01QQVJFKQor ICAgICAgICAgICAgIyBTZXQgdG9sZXJhbmNlIHRvICd6ZXJvJyB0byBkZXRlY3QgYW55IGRpZmZl cmVuY2VzLgorICAgICAgICAgICAgcG9ydC5kaWZmX2ltYWdlKHJlZmVyZW5jZV9pbWFnZV9jb250 ZW50cywgYWN0dWFsX2ltYWdlX2NvbnRlbnRzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg IGRpZmZfZmlsZW5hbWUsIHRvbGVyYW5jZT0wKQorCisgICAgICAgICAgICAjIENvcHkgZmlsZXMg Zm9yIGxhdGVyIHJlcG9ydGluZy4KKyAgICAgICAgICAgIHNlbGYuX2NvcHlfb3V0cHV0X3RvX3Jl c3VsdF9kaXJlY3RvcnkoCisgICAgICAgICAgICAgICAgdGVzdF9pbmZvLmZpbGVuYW1lLAorICAg ICAgICAgICAgICAgIHRlc3RfaW5mby5leHBlY3RlZF9odG1sX2ZpbGVuYW1lLAorICAgICAgICAg ICAgICAgICctZXhwZWN0ZWQuaHRtbCcpCisgICAgICAgICAgICBzZWxmLndyaXRlX291dHB1dF9m aWxlcyh0ZXN0X2luZm8uZmlsZW5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBmaWxlX3R5cGU9Jy5wbmcnLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgb3V0cHV0PWFjdHVhbF9pbWFnZV9jb250ZW50cywKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGV4cGVjdGVkPXJlZmVyZW5jZV9pbWFnZV9jb250ZW50cywKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVuY29kaW5nPU5vbmUsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBwcmludF90ZXh0X2RpZmZzPUZhbHNlKQorICAgICAgICBl bHNlOgorICAgICAgICAgICAgYXNzZXJ0IHRlc3RfaW5mby5leHBlY3RlZF9taXNtYXRjaF9odG1s X2ZpbGVuYW1lCisgICAgICAgICAgICBpZiBhY3R1YWxfaW1hZ2VfaGFzaCAhPSByZWZlcmVuY2Vf aW1hZ2VfaGFzaDoKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFpbHVyZXMKKyAgICAgICAgICAg IGZhaWx1cmVzLmFwcGVuZCh0ZXN0X2ZhaWx1cmVzLkZhaWx1cmVSZWZlcmVuY2VNYXRjaCgpKQor CisgICAgICAgICAgICAjIENvcHkgZmlsZXMgZm9yIGxhdGVyIHJlcG9ydGluZy4KKyAgICAgICAg ICAgIHNlbGYuX2NvcHlfb3V0cHV0X3RvX3Jlc3VsdF9kaXJlY3RvcnkoCisgICAgICAgICAgICAg ICAgdGVzdF9pbmZvLmZpbGVuYW1lLAorICAgICAgICAgICAgICAgIHRlc3RfaW5mby5leHBlY3Rl ZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1lLAorICAgICAgICAgICAgICAgICctZXhwZWN0ZWQtbWlz bWF0Y2guaHRtbCcpCisgICAgICAgICAgICBzZWxmLndyaXRlX291dHB1dF9maWxlcyh0ZXN0X2lu Zm8uZmlsZW5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmaWxlX3R5 cGU9Jy5wbmcnLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb3V0cHV0PWFj dHVhbF9pbWFnZV9jb250ZW50cywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGV4cGVjdGVkPU5vbmUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbmNv ZGluZz1Ob25lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcHJpbnRfdGV4 dF9kaWZmcz1GYWxzZSkKKyAgICAgICAgcmV0dXJuIGZhaWx1cmVzCmRpZmYgLS1naXQgYS9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL3Rlc3RfdHlw ZV9iYXNlLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVz dF90eXBlcy90ZXN0X3R5cGVfYmFzZS5weQppbmRleCBkY2M2NGEzNWIzMzlkZjk4ODBhYWMwNTM4 ZjdlODU1OTcyNTgwYjEzLi4zOWYwMWVkNzg3YjI3YTc5ZTc3ZjIyYzFmYjdiNDFjMzExMzk0NzRj IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90 ZXN0X3R5cGVzL3Rlc3RfdHlwZV9iYXNlLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvbGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvdGVzdF90eXBlX2Jhc2UucHkKQEAgLTM5LDYg KzM5LDcgQEAgaW1wb3J0IGNnaQogaW1wb3J0IGVycm5vCiBpbXBvcnQgbG9nZ2luZwogaW1wb3J0 IG9zLnBhdGgKK2ltcG9ydCBzaHV0aWwKIAogX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJr aXRweS5sYXlvdXRfdGVzdHMudGVzdF90eXBlcy50ZXN0X3R5cGVfYmFzZSIpCiAKQEAgLTkwLDYg KzkxLDIzIEBAIGNsYXNzIFRlc3RUeXBlQmFzZShvYmplY3QpOgogICAgICAgICAgICAgc2VsZi5f cG9ydC5yZWxhdGl2ZV90ZXN0X2ZpbGVuYW1lKGZpbGVuYW1lKSkKICAgICAgICAgc2VsZi5fcG9y dC5tYXliZV9tYWtlX2RpcmVjdG9yeShvcy5wYXRoLnNwbGl0KG91dHB1dF9maWxlbmFtZSlbMF0p CiAKKyAgICBkZWYgX2NvcHlfb3V0cHV0X3RvX3Jlc3VsdF9kaXJlY3Rvcnkoc2VsZiwgdGVzdF9m aWxlbmFtZSwgc291cmNlX2ZpbGVuYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBkZXN0aW5hdGlvbl9leHRlbnNpb24pOgorICAgICAgICAiIiJDb3BpZXMgcmVz dWx0IGZpbGVzIGludG8gdGhlIG91dHB1dCBkaXJlY3Rvcnkgd2l0aCBhcHByb3ByaWF0ZQorICAg ICAgICBuYW1lcy4KKworICAgICAgICBBcmdzOgorICAgICAgICAgIHRlc3RfZmlsZW5hbWU6IHRo ZSB0ZXN0IGZpbGVuYW1lCisgICAgICAgICAgc291cmNlX2ZpbGVuYW1lOiBwYXRoIHRvIHRoZSBz b3VyY2UgZmlsZSAoZWl0aGVyIGFjdHVhbCBvciBleHBlY3RlZCkKKyAgICAgICAgICBkZXN0aW50 aW9uX2V4dGVuc2lvbjogZXh0ZW5zaW9uIHVzZWQgaW4gZGVzdGluYXRpb24ncyBmaWxlbmFtZS4K KyAgICAgICAgIiIiCisgICAgICAgIHNlbGYuX21ha2Vfb3V0cHV0X2RpcmVjdG9yeSh0ZXN0X2Zp bGVuYW1lKQorICAgICAgICBkZXN0X2ZpbGVuYW1lID0gc2VsZi5vdXRwdXRfZmlsZW5hbWUodGVz dF9maWxlbmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGRlc3RpbmF0aW9uX2V4dGVuc2lvbikKKworICAgICAgICBpZiBvcy5wYXRoLmV4aXN0cyhzb3Vy Y2VfZmlsZW5hbWUpOgorICAgICAgICAgICAgc2h1dGlsLmNvcHlmaWxlKHNvdXJjZV9maWxlbmFt ZSwgZGVzdF9maWxlbmFtZSkKKwogICAgIGRlZiBfc2F2ZV9iYXNlbGluZV9kYXRhKHNlbGYsIGZp bGVuYW1lLCBkYXRhLCBtb2RpZmllciwgZW5jb2RpbmcsCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgZ2VuZXJhdGVfbmV3X2Jhc2VsaW5lPVRydWUpOgogICAgICAgICAiIiJTYXZlcyBhIG5l dyBiYXNlbGluZSBmaWxlIGludG8gdGhlIHBvcnQncyBiYXNlbGluZSBkaXJlY3RvcnkuCg== 73454 2010-11-09 20:12:52 -0800 2010-12-14 23:26:07 -0800 synced-to-tot bug-36065-20101110131250.patch text/plain 53132 hayato ZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL0NoYW5nZUxvZyBiL1dlYktpdFRvb2xzL0NoYW5nZUxv ZwppbmRleCBjODhjZTNlZDc5Y2JiOWFmYmE1NzNhNmViMWJkMzBkMDA1OWE5NmFmLi41YmNkZjYz OGMzNTdmZWI0YzZmYjQ3ZjJhM2M5ZWFkODg3N2YzNjkwIDEwMDY0NAotLS0gYS9XZWJLaXRUb29s cy9DaGFuZ2VMb2cKKysrIGIvV2ViS2l0VG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUgQEAK KzIwMTAtMTEtMDkgIEhheWF0byBJdG8gIDxoYXlhdG9AY2hyb21pdW0ub3JnPgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBzdXBwb3J0IFJlZmVy ZW5jZSBUZXN0cyAoYWthIHJlZnRlc3RzKSB0byBleGlzdGluZyBMYXlvdXQgVGVzdCBoYXJuZXNz LgorCisgICAgICAgIEFuIGluaXRpYWwgZWZmb3J0IHRvIHN1cHBvcnQgcmVmdGVzdHMuIFJlZnRl c3RzIHN1cHBvcnQgaXMgYW4gZXhwZXJpbWVudGFsCisgICAgICAgIGFuZCBpcyBub3QgcHJvZHVj dGlvbi1yZWFkeSB5ZXQuCisKKyAgICAgICAgWW91IGNhbiBydW4gcmVmdGVzdHMgYnkgdXNpbmcg b3B0aW9uICctLXJ1bi1yZWZ0ZXN0Jy4KKworICAgICAgICBBIHJlZmVyZW5jZSBodG1sIGZpbGUg aXMgbmFtZWQgJ3h4eC1leHBlY3RlZC5odG1sJyBpZiBhIHRlc3QgaXMgZXhwZWN0ZWQKKyAgICAg ICAgdG8gbWF0Y2ggdGhlIHJlZmVyZW5jZSwgb3IgJ3h4eC1leHBlY3RlZC1taXNtYXRjaC5odG1s JyBpZiBhIHRlc3QgaXMKKyAgICAgICAgZXhwZWN0ZWQgbm90IHRvIG1hdGNoIHRoZSByZWZlcmVu Y2UuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM2 MDY1CisKKyAgICAgICAgKiBTY3JpcHRzL29sZC1ydW4td2Via2l0LXRlc3RzOgorICAgICAgICAq IFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2R1bXBfcmVuZGVy X3RyZWVfdGhyZWFkLnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L2xheW91dF9wYWNrYWdlL2pzb25fbGF5b3V0X3Jlc3VsdHNfZ2VuZXJhdG9yLnB5OgorICAgICAg ICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL3NpbmdsZV90 ZXN0X3J1bm5lci5weTogQWRkZWQuCisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvbGF5b3V0X3BhY2thZ2UvdGVzdF9leHBlY3RhdGlvbnMucHk6CisgICAgICAgICogU2Ny aXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvdGVzdF9mYWlsdXJlcy5w eToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHk6 CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0LnB5Ogor ICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvdGVzdF9maWxlcy5w eToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3dlYmtpdC5w eToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rl c3RzLnB5OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Rlc3RfdHlw ZXMvaW1hZ2VfZGlmZi5weToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy90ZXN0X3R5cGVzL3JlZmVyZW5jZV9kaWZmLnB5OiBBZGRlZC4KKyAgICAgICAgKiBTY3JpcHRz L3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL3Rlc3RfdHlwZV9iYXNlLnB5OgorCiAy MDEwLTExLTA4ICBOaWNvbGFzIER1ZnJlc25lICA8bmljb2xhcy5kdWZyZXNuZUBjb2xsYWJvcmEu Y28udWs+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTWFydGluIFJvYmluc29uLgpkaWZmIC0tZ2l0 IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy9vbGQtcnVuLXdlYmtpdC10ZXN0cyBiL1dlYktpdFRvb2xz L1NjcmlwdHMvb2xkLXJ1bi13ZWJraXQtdGVzdHMKaW5kZXggMmNlZjE4YjM3YmE2ZTFkZmY3ZDUx NmQxYzY4MjdhNzc5ZjM1MjA2ZC4uNWY5NmRlM2RmNGQxOWIxYTI0MzQzZjljNjMwMTg2NWJjYjRl Mzg2MCAxMDA3NTUKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy9vbGQtcnVuLXdlYmtpdC10ZXN0 cworKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL29sZC1ydW4td2Via2l0LXRlc3RzCkBAIC0xODQs NiArMTg0LDcgQEAgJHRlc3RIVFRQID0gMCBpZiAoaXNXeCgpKTsKIG15ICRwZXJsSW50ZXJwcmV0 ZXIgPSAicGVybCI7CiAKIG15ICRleHBlY3RlZFRhZyA9ICJleHBlY3RlZCI7CitteSAkbWlzbWF0 Y2hUYWcgPSAibWlzbWF0Y2giOwogbXkgJGFjdHVhbFRhZyA9ICJhY3R1YWwiOwogbXkgJHByZXR0 eURpZmZUYWcgPSAicHJldHR5LWRpZmYiOwogbXkgJGRpZmZzVGFnID0gImRpZmZzIjsKQEAgLTIy OTIsNiArMjI5MywxNiBAQCBzdWIgcmVhZFNraXBwZWRGaWxlcygkKQogCiBteSBAdGVzdHNGb3Vu ZDsKIAorc3ViIGlzVXNlZEluUmVmdGVzdAoreworICAgIG15ICRmaWxlbmFtZSA9ICRfOworICAg IGlmICgkZmlsZW5hbWUgPX4gLy0kZXhwZWN0ZWRUYWcoLSRtaXNtYXRjaFRhZyk/XC5odG1sJC8p IHsKKyAgICAgICAgcmV0dXJuIDE7CisgICAgfQorICAgIG15ICRiYXNlID0gc3RyaXBFeHRlbnNp b24oJGZpbGVuYW1lKTsKKyAgICByZXR1cm4gKC1mICIkYmFzZS0kZXhwZWN0ZWRUYWcuaHRtbCIg fHwgLWYgIiRiYXNlLSRleHBlY3RlZFRhZy0kbWlzbWF0Y2hUYWcuaHRtbCIpOworfQorCiBzdWIg ZGlyZWN0b3J5RmlsdGVyCiB7CiAgICAgcmV0dXJuICgpIGlmIGV4aXN0cyAkaWdub3JlZExvY2Fs RGlyZWN0b3JpZXN7YmFzZW5hbWUoJEZpbGU6OkZpbmQ6OmRpcil9OwpAQCAtMjMwMyw3ICsyMzE0 LDggQEAgc3ViIGZpbGVGaWx0ZXIKIHsKICAgICBteSAkZmlsZW5hbWUgPSAkXzsKICAgICBpZiAo JGZpbGVuYW1lID1+IC9cLihbXi5dKykkLykgewotICAgICAgICBpZiAoZXhpc3RzICRzdXBwb3J0 ZWRGaWxlRXh0ZW5zaW9uc3skMX0pIHsKKyAgICAgICAgbXkgJGV4dGVuc2lvbiA9ICQxOworICAg ICAgICBpZiAoZXhpc3RzICRzdXBwb3J0ZWRGaWxlRXh0ZW5zaW9uc3skZXh0ZW5zaW9ufSAmJiAh aXNVc2VkSW5SZWZ0ZXN0KCRmaWxlbmFtZSkpIHsKICAgICAgICAgICAgIG15ICRwYXRoID0gRmls ZTo6U3BlYy0+YWJzMnJlbChjYXRmaWxlKCRGaWxlOjpGaW5kOjpkaXIsICRmaWxlbmFtZSksICR0 ZXN0RGlyZWN0b3J5KTsKICAgICAgICAgICAgIHB1c2ggQHRlc3RzRm91bmQsICRwYXRoIGlmICFl eGlzdHMgJGlnbm9yZWRGaWxlc3skcGF0aH07CiAgICAgICAgIH0KZGlmZiAtLWdpdCBhL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL2R1bXBf cmVuZGVyX3RyZWVfdGhyZWFkLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQucHkKaW5kZXgg OWYyZGU3ZTQ3NmI3YjVjMGI3ZjExZWRjNDZlODgyNTQ3NGYzZjg1Zi4uNWQ5OGQ3YjQzNmFhNDBh YzFhMTk5MDc2MzRkYzgzNmRlNDBmODI5YSAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvZHVtcF9yZW5kZXJfdHJlZV90 aHJlYWQucHkKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv bGF5b3V0X3BhY2thZ2UvZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQucHkKQEAgLTUwLDcgKzUwLDcg QEAgaW1wb3J0IHRocmVhZGluZwogaW1wb3J0IHRpbWUKIGltcG9ydCB0cmFjZWJhY2sKIAotaW1w b3J0IHRlc3RfZmFpbHVyZXMKK2ltcG9ydCBzaW5nbGVfdGVzdF9ydW5uZXIKIGltcG9ydCB0ZXN0 X3Jlc3VsdHMKIAogX2xvZyA9IGxvZ2dpbmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVz dHMubGF5b3V0X3BhY2thZ2UuIgpAQCAtNzQsNzQgKzc0LDE2IEBAIGRlZiBsb2dfc3RhY2soc3Rh Y2spOgogICAgICAgICAgICAgX2xvZy5lcnJvcignICAlcycgJSBsaW5lLnN0cmlwKCkpCiAKIAot ZGVmIF9wcm9jZXNzX291dHB1dChwb3J0LCBvcHRpb25zLCB0ZXN0X2luZm8sIHRlc3RfdHlwZXMs IHRlc3RfYXJncywKLSAgICAgICAgICAgICAgICAgICAgY3Jhc2gsIHRpbWVvdXQsIHRlc3RfcnVu X3RpbWUsIGFjdHVhbF9jaGVja3N1bSwKLSAgICAgICAgICAgICAgICAgICAgb3V0cHV0LCBlcnJv cik6Ci0gICAgIiIiUmVjZWl2ZXMgdGhlIG91dHB1dCBmcm9tIGEgRHVtcFJlbmRlclRyZWUgcHJv Y2Vzcywgc3ViamVjdHMgaXQgdG8gYQotICAgIG51bWJlciBvZiB0ZXN0cywgYW5kIHJldHVybnMg YSBsaXN0IG9mIGZhaWx1cmUgdHlwZXMgdGhlIHRlc3QgcHJvZHVjZWQuCi0KLSAgICBBcmdzOgot ICAgICAgcG9ydDogcG9ydC1zcGVjaWZpYyBob29rcwotICAgICAgb3B0aW9uczogY29tbWFuZCBs aW5lIG9wdGlvbnMgYXJndW1lbnQgZnJvbSBvcHRwYXJzZQotICAgICAgcHJvYzogYW4gYWN0aXZl IER1bXBSZW5kZXJUcmVlIHByb2Nlc3MKLSAgICAgIHRlc3RfaW5mbzogT2JqZWN0IGNvbnRhaW5p bmcgdGhlIHRlc3QgZmlsZW5hbWUsIHVyaSBhbmQgdGltZW91dAotICAgICAgdGVzdF90eXBlczog bGlzdCBvZiB0ZXN0IHR5cGVzIHRvIHN1YmplY3QgdGhlIG91dHB1dCB0bwotICAgICAgdGVzdF9h cmdzOiBhcmd1bWVudHMgdG8gYmUgcGFzc2VkIHRvIGVhY2ggdGVzdAotCi0gICAgUmV0dXJuczog YSBUZXN0UmVzdWx0IG9iamVjdAotICAgICIiIgotICAgIGZhaWx1cmVzID0gW10KLQotICAgICMg U29tZSB0ZXN0IGFyZ3MsIHN1Y2ggYXMgdGhlIGltYWdlIGhhc2gsIG1heSBiZSBhZGRlZCBvciBj aGFuZ2VkIG9uIGEKLSAgICAjIHRlc3QtYnktdGVzdCBiYXNpcy4KLSAgICBsb2NhbF90ZXN0X2Fy Z3MgPSBjb3B5LmNvcHkodGVzdF9hcmdzKQotCi0gICAgbG9jYWxfdGVzdF9hcmdzLmhhc2ggPSBh Y3R1YWxfY2hlY2tzdW0KLQotICAgIGlmIGNyYXNoOgotICAgICAgICBmYWlsdXJlcy5hcHBlbmQo dGVzdF9mYWlsdXJlcy5GYWlsdXJlQ3Jhc2goKSkKLSAgICBpZiB0aW1lb3V0OgotICAgICAgICBm YWlsdXJlcy5hcHBlbmQodGVzdF9mYWlsdXJlcy5GYWlsdXJlVGltZW91dCgpKQotCi0gICAgaWYg Y3Jhc2g6Ci0gICAgICAgIF9sb2cuZGVidWcoIlN0YWNrdHJhY2UgZm9yICVzOlxuJXMiICUgKHRl c3RfaW5mby5maWxlbmFtZSwgZXJyb3IpKQotICAgICAgICAjIFN0cmlwIG9mZiAiZmlsZTovLyIg c2luY2UgUmVsYXRpdmVUZXN0RmlsZW5hbWUgZXhwZWN0cwotICAgICAgICAjIGZpbGVzeXN0ZW0g cGF0aHMuCi0gICAgICAgIGZpbGVuYW1lID0gb3MucGF0aC5qb2luKG9wdGlvbnMucmVzdWx0c19k aXJlY3RvcnksCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBvcnQucmVsYXRpdmVf dGVzdF9maWxlbmFtZSgKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGVzdF9pbmZv LmZpbGVuYW1lKSkKLSAgICAgICAgZmlsZW5hbWUgPSBvcy5wYXRoLnNwbGl0ZXh0KGZpbGVuYW1l KVswXSArICItc3RhY2sudHh0IgotICAgICAgICBwb3J0Lm1heWJlX21ha2VfZGlyZWN0b3J5KG9z LnBhdGguc3BsaXQoZmlsZW5hbWUpWzBdKQotICAgICAgICB3aXRoIGNvZGVjcy5vcGVuKGZpbGVu YW1lLCAid2IiLCAidXRmLTgiKSBhcyBmaWxlOgotICAgICAgICAgICAgZmlsZS53cml0ZShlcnJv cikKLSAgICBlbGlmIGVycm9yOgotICAgICAgICBfbG9nLmRlYnVnKCJQcmV2aW91cyB0ZXN0IG91 dHB1dCBzdGRlcnIgbGluZXM6XG4lcyIgJSBlcnJvcikKLQotICAgICMgQ2hlY2sgdGhlIG91dHB1 dCBhbmQgc2F2ZSB0aGUgcmVzdWx0cy4KLSAgICBzdGFydF90aW1lID0gdGltZS50aW1lKCkKLSAg ICB0aW1lX2Zvcl9kaWZmcyA9IHt9Ci0gICAgZm9yIHRlc3RfdHlwZSBpbiB0ZXN0X3R5cGVzOgot ICAgICAgICBzdGFydF9kaWZmX3RpbWUgPSB0aW1lLnRpbWUoKQotICAgICAgICBuZXdfZmFpbHVy ZXMgPSB0ZXN0X3R5cGUuY29tcGFyZV9vdXRwdXQocG9ydCwgdGVzdF9pbmZvLmZpbGVuYW1lLAot ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb3V0cHV0LCBs b2NhbF90ZXN0X2FyZ3MsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBvcHRpb25zLmNvbmZpZ3VyYXRpb24pCi0gICAgICAgICMgRG9uJ3QgYWRkIGFueSBt b3JlIGZhaWx1cmVzIGlmIHdlIGFscmVhZHkgaGF2ZSBhIGNyYXNoLCBzbyB3ZSBkb24ndAotICAg ICAgICAjIGRvdWJsZS1yZXBvcnQgdGhvc2UgdGVzdHMuIFdlIGRvIGRvdWJsZS1yZXBvcnQgZm9y IHRpbWVvdXRzIHNpbmNlCi0gICAgICAgICMgd2Ugc3RpbGwgd2FudCB0byBzZWUgdGhlIHRleHQg YW5kIGltYWdlIG91dHB1dC4KLSAgICAgICAgaWYgbm90IGNyYXNoOgotICAgICAgICAgICAgZmFp bHVyZXMuZXh0ZW5kKG5ld19mYWlsdXJlcykKLSAgICAgICAgdGltZV9mb3JfZGlmZnNbdGVzdF90 eXBlLl9fY2xhc3NfXy5fX25hbWVfX10gPSAoCi0gICAgICAgICAgICB0aW1lLnRpbWUoKSAtIHN0 YXJ0X2RpZmZfdGltZSkKLQotICAgIHRvdGFsX3RpbWVfZm9yX2FsbF9kaWZmcyA9IHRpbWUudGlt ZSgpIC0gc3RhcnRfZGlmZl90aW1lCi0gICAgcmV0dXJuIHRlc3RfcmVzdWx0cy5UZXN0UmVzdWx0 KHRlc3RfaW5mby5maWxlbmFtZSwgZmFpbHVyZXMsIHRlc3RfcnVuX3RpbWUsCi0gICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHRvdGFsX3RpbWVfZm9yX2FsbF9kaWZmcywgdGltZV9m b3JfZGlmZnMpCitkZWYgX3RocmVhZF90aW1lb3V0KHRlc3RfaW5mbyk6CisgICAgIiIiUmV0dXJu IHRoZSBkdXJhdGF0aW9uIHRoZSB0ZXN0IGlzIHN1cHBvc2VkIHRvIGZpbmlzaCB3aXRoaW4uIiIi CisgICAgIyBGSVhNRTogUmVmdGVzdHMgbWlnaHQgbmVlZCBhIGxvbmdlciB0aW1lb3V0IHZhbHVl IGJlY2F1c2UgcmVmdGVzdHMgaGF2ZSB0bworICAgICMgY2FsbCBEdW1wUmVuZGVyVHJlZSB0d28g dGltZXMuCisgICAgcmV0dXJuIF9taWxsaXNlY29uZHNfdG9fc2Vjb25kcyhfcGFkX3RpbWVvdXQo aW50KHRlc3RfaW5mby50aW1lb3V0KSkpCiAKIAogZGVmIF9wYWRfdGltZW91dCh0aW1lb3V0KToK ICAgICAiIiJSZXR1cm5zIGEgc2FmZSBtdWx0aXBsZSBvZiB0aGUgcGVyLXRlc3QgdGltZW91dCB2 YWx1ZSB0byB1c2UKICAgICB0byBkZXRlY3QgaHVuZyB0ZXN0IHRocmVhZHMuCi0KICAgICAiIiIK ICAgICAjIFdoZW4gd2UncmUgcnVubmluZyBvbmUgdGVzdCBwZXIgRHVtcFJlbmRlclRyZWUgcHJv Y2Vzcywgd2UgY2FuCiAgICAgIyBlbmZvcmNlIGEgaGFyZCB0aW1lb3V0LiAgVGhlIER1bXBSZW5k ZXJUcmVlIHdhdGNoZG9nIHVzZXMgMi41eApAQCAtMTUzLDIzICs5NSwxOCBAQCBkZWYgX21pbGxp c2Vjb25kc190b19zZWNvbmRzKG1zZWNzKToKICAgICByZXR1cm4gZmxvYXQobXNlY3MpIC8gMTAw MC4wCiAKIAotZGVmIF9pbWFnZV9oYXNoKHRlc3RfaW5mbywgdGVzdF9hcmdzLCBvcHRpb25zKToK LSAgICAiIiJSZXR1cm5zIHRoZSBpbWFnZSBoYXNoIG9mIHRoZSB0ZXN0IGlmIGl0J3MgbmVlZGVk LCBvdGhlcndpc2UgTm9uZS4iIiIKLSAgICBpZiAodGVzdF9hcmdzLm5ld19iYXNlbGluZSBvciB0 ZXN0X2FyZ3MucmVzZXRfcmVzdWx0cyBvciBub3Qgb3B0aW9ucy5waXhlbF90ZXN0cyk6Ci0gICAg ICAgIHJldHVybiBOb25lCi0gICAgcmV0dXJuIHRlc3RfaW5mby5pbWFnZV9oYXNoKCkKLQotCiBj bGFzcyBTaW5nbGVUZXN0VGhyZWFkKHRocmVhZGluZy5UaHJlYWQpOgogICAgICIiIlRocmVhZCB3 cmFwcGVyIGZvciBydW5uaW5nIGEgc2luZ2xlIHRlc3QgZmlsZS4iIiIKIAotICAgIGRlZiBfX2lu aXRfXyhzZWxmLCBwb3J0LCBvcHRpb25zLCB0ZXN0X2luZm8sIHRlc3RfdHlwZXMsIHRlc3RfYXJn cyk6CisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQsIG9wdGlvbnMsIHRlc3RfaW5mbywgdGVz dF90eXBlcywgcmVmdGVzdF90eXBlcywgdGVzdF9hcmdzKToKICAgICAgICAgIiIiCiAgICAgICAg IEFyZ3M6CiAgICAgICAgICAgcG9ydDogb2JqZWN0IGltcGxlbWVudGluZyBwb3J0LXNwZWNpZmlj IGhvb2tzCiAgICAgICAgICAgb3B0aW9uczogY29tbWFuZCBsaW5lIGFyZ3VtZW50IG9iamVjdCBm cm9tIG9wdHBhcnNlCiAgICAgICAgICAgdGVzdF9pbmZvOiBPYmplY3QgY29udGFpbmluZyB0aGUg dGVzdCBmaWxlbmFtZSwgdXJpIGFuZCB0aW1lb3V0Ci0gICAgICAgICAgdGVzdF90eXBlczogQSBs aXN0IG9mIFRlc3RUeXBlIG9iamVjdHMgdG8gcnVuIHRoZSB0ZXN0IG91dHB1dAorICAgICAgICAg IHRlc3RfdHlwZXM6IEEgbGlzdCBvZiBUZXN0VHlwZSBvYmplY3RzIHRvIHJ1biB0aGUgbGF5b3V0 IHRlc3Qgb3V0cHV0CisgICAgICAgICAgICAgIGFnYWluc3QuCisgICAgICAgICAgcmVmdGVzdF90 eXBlczogQSBsaXN0IG9mIFRlc3RUeXBlIG9iamVjdHMgdG8gcnVuIHRoZSByZWZ0ZXN0IG91dHB1 dAogICAgICAgICAgICAgICBhZ2FpbnN0LgogICAgICAgICAgIHRlc3RfYXJnczogQSBUZXN0QXJn dW1lbnRzIG9iamVjdCB0byBwYXNzIHRvIGVhY2ggVGVzdFR5cGUuCiAgICAgICAgICIiIgpAQCAt MTc5LDYgKzExNiw3IEBAIGNsYXNzIFNpbmdsZVRlc3RUaHJlYWQodGhyZWFkaW5nLlRocmVhZCk6 CiAgICAgICAgIHNlbGYuX29wdGlvbnMgPSBvcHRpb25zCiAgICAgICAgIHNlbGYuX3Rlc3RfaW5m byA9IHRlc3RfaW5mbwogICAgICAgICBzZWxmLl90ZXN0X3R5cGVzID0gdGVzdF90eXBlcworICAg ICAgICBzZWxmLl9yZWZ0ZXN0X3R5cGVzID0gcmVmdGVzdF90eXBlcwogICAgICAgICBzZWxmLl90 ZXN0X2FyZ3MgPSB0ZXN0X2FyZ3MKICAgICAgICAgc2VsZi5fZHJpdmVyID0gTm9uZQogCkBAIC0x ODgsMjAgKzEyNiwxMyBAQCBjbGFzcyBTaW5nbGVUZXN0VGhyZWFkKHRocmVhZGluZy5UaHJlYWQp OgogICAgIGRlZiBfY292ZXJlZF9ydW4oc2VsZik6CiAgICAgICAgICMgRklYTUU6IHRoaXMgaXMg YSBzZXBhcmF0ZSByb3V0aW5lIHRvIHdvcmsgYXJvdW5kIGEgYnVnCiAgICAgICAgICMgaW4gY292 ZXJhZ2U6IHNlZSBodHRwOi8vYml0YnVja2V0Lm9yZy9uZWQvY292ZXJhZ2VweS9pc3N1ZS84NS4K LSAgICAgICAgdGVzdF9pbmZvID0gc2VsZi5fdGVzdF9pbmZvCiAgICAgICAgIHNlbGYuX2RyaXZl ciA9IHNlbGYuX3BvcnQuY3JlYXRlX2RyaXZlcihzZWxmLl90ZXN0X2FyZ3MucG5nX3BhdGgsCiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxmLl9vcHRp b25zKQogICAgICAgICBzZWxmLl9kcml2ZXIuc3RhcnQoKQotICAgICAgICBpbWFnZV9oYXNoID0g X2ltYWdlX2hhc2godGVzdF9pbmZvLCBzZWxmLl90ZXN0X2FyZ3MsIHNlbGYuX29wdGlvbnMpCi0g ICAgICAgIHN0YXJ0ID0gdGltZS50aW1lKCkKLSAgICAgICAgY3Jhc2gsIHRpbWVvdXQsIGFjdHVh bF9jaGVja3N1bSwgb3V0cHV0LCBlcnJvciA9IFwKLSAgICAgICAgICAgIHNlbGYuX2RyaXZlci5y dW5fdGVzdCh0ZXN0X2luZm8udXJpLnN0cmlwKCksIHRlc3RfaW5mby50aW1lb3V0LAotICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGltYWdlX2hhc2gpCi0gICAgICAgIGVuZCA9IHRp bWUudGltZSgpCi0gICAgICAgIHNlbGYuX3Rlc3RfcmVzdWx0ID0gX3Byb2Nlc3Nfb3V0cHV0KHNl bGYuX3BvcnQsIHNlbGYuX29wdGlvbnMsCi0gICAgICAgICAgICB0ZXN0X2luZm8sIHNlbGYuX3Rl c3RfdHlwZXMsIHNlbGYuX3Rlc3RfYXJncywKLSAgICAgICAgICAgIGNyYXNoLCB0aW1lb3V0LCBl bmQgLSBzdGFydCwKLSAgICAgICAgICAgIGFjdHVhbF9jaGVja3N1bSwgb3V0cHV0LCBlcnJvcikK KyAgICAgICAgcnVubmVyID0gc2luZ2xlX3Rlc3RfcnVubmVyLlNpbmdsZVRlc3RSdW5uZXIoCisg ICAgICAgICAgICBzZWxmLl90ZXN0X2luZm8sIHNlbGYuX3Rlc3RfYXJncywgc2VsZi5fZHJpdmVy LCBzZWxmLl9wb3J0LCBzZWxmLl9vcHRpb25zLAorICAgICAgICAgICAgc2VsZi5fdGVzdF90eXBl cywgc2VsZi5fcmVmdGVzdF90eXBlcykKKyAgICAgICAgc2VsZi5fdGVzdF9yZXN1bHQgPSBydW5u ZXIucnVuX3Rlc3QoKQogICAgICAgICBzZWxmLl9kcml2ZXIuc3RvcCgpCiAKICAgICBkZWYgZ2V0 X3Rlc3RfcmVzdWx0KHNlbGYpOgpAQCAtMjQ1LDcgKzE3Niw3IEBAIGNsYXNzIFdhdGNoYWJsZVRo cmVhZCh0aHJlYWRpbmcuVGhyZWFkKToKIAogY2xhc3MgVGVzdFNoZWxsVGhyZWFkKFdhdGNoYWJs ZVRocmVhZCk6CiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIHBvcnQsIG9wdGlvbnMsIGZpbGVuYW1l X2xpc3RfcXVldWUsIHJlc3VsdF9xdWV1ZSwKLSAgICAgICAgICAgICAgICAgdGVzdF90eXBlcywg dGVzdF9hcmdzKToKKyAgICAgICAgICAgICAgICAgdGVzdF90eXBlcywgcmVmdGVzdF90eXBlcywg dGVzdF9hcmdzKToKICAgICAgICAgIiIiSW5pdGlhbGl6ZSBhbGwgdGhlIGxvY2FsIHN0YXRlIGZv ciB0aGlzIER1bXBSZW5kZXJUcmVlIHRocmVhZC4KIAogICAgICAgICBBcmdzOgpAQCAtMjU3LDYg KzE4OCw4IEBAIGNsYXNzIFRlc3RTaGVsbFRocmVhZChXYXRjaGFibGVUaHJlYWQpOgogICAgICAg ICAgICAgICBzZXJpYWxpemVkIFRlc3RSZXN1bHQgb2JqZWN0cy4KICAgICAgICAgICB0ZXN0X3R5 cGVzOiBBIGxpc3Qgb2YgVGVzdFR5cGUgb2JqZWN0cyB0byBydW4gdGhlIHRlc3Qgb3V0cHV0CiAg ICAgICAgICAgICAgIGFnYWluc3QuCisgICAgICAgICAgcmVmdGVzdF90eXBlczogQSBsaXN0IG9m IFRlc3RUeXBlIG9iamVjdHMgdG8gcnVuIHRoZSByZWZ0ZXN0IG91dHB1dAorICAgICAgICAgICAg ICBhZ2FpbnN0LgogICAgICAgICAgIHRlc3RfYXJnczogQSBUZXN0QXJndW1lbnRzIG9iamVjdCB0 byBwYXNzIHRvIGVhY2ggVGVzdFR5cGUuCiAKICAgICAgICAgIiIiCkBAIC0yNjcsNiArMjAwLDcg QEAgY2xhc3MgVGVzdFNoZWxsVGhyZWFkKFdhdGNoYWJsZVRocmVhZCk6CiAgICAgICAgIHNlbGYu X3Jlc3VsdF9xdWV1ZSA9IHJlc3VsdF9xdWV1ZQogICAgICAgICBzZWxmLl9maWxlbmFtZV9saXN0 ID0gW10KICAgICAgICAgc2VsZi5fdGVzdF90eXBlcyA9IHRlc3RfdHlwZXMKKyAgICAgICAgc2Vs Zi5fcmVmdGVzdF90eXBlcyA9IHJlZnRlc3RfdHlwZXMKICAgICAgICAgc2VsZi5fdGVzdF9hcmdz ID0gdGVzdF9hcmdzCiAgICAgICAgIHNlbGYuX2RyaXZlciA9IE5vbmUKICAgICAgICAgc2VsZi5f dGVzdF9ncm91cF90aW1pbmdfc3RhdHMgPSB7fQpAQCAtNDU4LDEyICszOTIsMTIgQEAgY2xhc3Mg VGVzdFNoZWxsVGhyZWFkKFdhdGNoYWJsZVRocmVhZCk6CiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgc2VsZi5fb3B0aW9ucywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB0ZXN0X2luZm8sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VsZi5f dGVzdF90eXBlcywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxmLl9yZWZ0 ZXN0X3R5cGVzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYuX3Rlc3Rf YXJncykKIAogICAgICAgICB3b3JrZXIuc3RhcnQoKQogCi0gICAgICAgIHRocmVhZF90aW1lb3V0 ID0gX21pbGxpc2Vjb25kc190b19zZWNvbmRzKAotICAgICAgICAgICAgX3BhZF90aW1lb3V0KGlu dCh0ZXN0X2luZm8udGltZW91dCkpKQorICAgICAgICB0aHJlYWRfdGltZW91dCA9IF90aHJlYWRf dGltZW91dCh0ZXN0X2luZm8pCiAgICAgICAgIHRocmVhZC5fbmV4dF90aW1lb3V0ID0gdGltZS50 aW1lKCkgKyB0aHJlYWRfdGltZW91dAogICAgICAgICB3b3JrZXIuam9pbih0aHJlYWRfdGltZW91 dCkKICAgICAgICAgaWYgd29ya2VyLmlzQWxpdmUoKToKQEAgLTUwMCwyOCArNDM0LDEzIEBAIGNs YXNzIFRlc3RTaGVsbFRocmVhZChXYXRjaGFibGVUaHJlYWQpOgogICAgICAgICBSZXR1cm5zOiBh IFRlc3RSZXN1bHQgb2JqZWN0LgogICAgICAgICAiIiIKICAgICAgICAgc2VsZi5fZW5zdXJlX2R1 bXBfcmVuZGVyX3RyZWVfaXNfcnVubmluZygpCi0gICAgICAgICMgVGhlIHBpeGVsX2hhc2ggaXMg dXNlZCB0byBhdm9pZCBkb2luZyBhbiBpbWFnZSBkdW1wIGlmIHRoZQotICAgICAgICAjIGNoZWNr c3VtcyBtYXRjaCwgc28gaXQgc2hvdWxkIGJlIHNldCB0byBhIGJsYW5rIHZhbHVlIGlmIHdlCi0g ICAgICAgICMgYXJlIGdlbmVyYXRpbmcgYSBuZXcgYmFzZWxpbmUuICAoT3RoZXJ3aXNlLCBhbiBp bWFnZSBmcm9tIGEKLSAgICAgICAgIyBwcmV2aW91cyBydW4gd2lsbCBiZSBjb3BpZWQgaW50byB0 aGUgYmFzZWxpbmUuKQotICAgICAgICBpbWFnZV9oYXNoID0gX2ltYWdlX2hhc2godGVzdF9pbmZv LCBzZWxmLl90ZXN0X2FyZ3MsIHNlbGYuX29wdGlvbnMpCi0gICAgICAgIHN0YXJ0ID0gdGltZS50 aW1lKCkKLQotICAgICAgICB0aHJlYWRfdGltZW91dCA9IF9taWxsaXNlY29uZHNfdG9fc2Vjb25k cygKLSAgICAgICAgICAgICBfcGFkX3RpbWVvdXQoaW50KHRlc3RfaW5mby50aW1lb3V0KSkpCi0g ICAgICAgIHNlbGYuX25leHRfdGltZW91dCA9IHN0YXJ0ICsgdGhyZWFkX3RpbWVvdXQKLQotICAg ICAgICBjcmFzaCwgdGltZW91dCwgYWN0dWFsX2NoZWNrc3VtLCBvdXRwdXQsIGVycm9yID0gXAot ICAgICAgICAgICBzZWxmLl9kcml2ZXIucnVuX3Rlc3QodGVzdF9pbmZvLnVyaSwgdGVzdF9pbmZv LnRpbWVvdXQsIGltYWdlX2hhc2gpCi0gICAgICAgIGVuZCA9IHRpbWUudGltZSgpCi0KLSAgICAg ICAgcmVzdWx0ID0gX3Byb2Nlc3Nfb3V0cHV0KHNlbGYuX3BvcnQsIHNlbGYuX29wdGlvbnMsCi0g ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0ZXN0X2luZm8sIHNlbGYuX3Rlc3RfdHlw ZXMsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxmLl90ZXN0X2FyZ3MsIGNy YXNoLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdGltZW91dCwgZW5kIC0gc3Rh cnQsIGFjdHVhbF9jaGVja3N1bSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG91 dHB1dCwgZXJyb3IpCi0gICAgICAgIHNlbGYuX3Rlc3RfcmVzdWx0cy5hcHBlbmQocmVzdWx0KQot ICAgICAgICByZXR1cm4gcmVzdWx0CisgICAgICAgIHNlbGYuX25leHRfdGltZW91dCA9IHRpbWUu dGltZSgpICsgX3RocmVhZF90aW1lb3V0KHRlc3RfaW5mbykKKyAgICAgICAgcnVubmVyID0gc2lu Z2xlX3Rlc3RfcnVubmVyLlNpbmdsZVRlc3RSdW5uZXIoCisgICAgICAgICAgICB0ZXN0X2luZm8s IHNlbGYuX3Rlc3RfYXJncywgc2VsZi5fZHJpdmVyLCBzZWxmLl9wb3J0LCBzZWxmLl9vcHRpb25z LAorICAgICAgICAgICAgc2VsZi5fdGVzdF90eXBlcywgc2VsZi5fcmVmdGVzdF90eXBlcykKKyAg ICAgICAgdGVzdF9yZXN1bHQgPSBydW5uZXIucnVuX3Rlc3QoKQorICAgICAgICBzZWxmLl90ZXN0 X3Jlc3VsdHMuYXBwZW5kKHRlc3RfcmVzdWx0KQorICAgICAgICByZXR1cm4gdGVzdF9yZXN1bHQK IAogICAgIGRlZiBfZW5zdXJlX2R1bXBfcmVuZGVyX3RyZWVfaXNfcnVubmluZyhzZWxmKToKICAg ICAgICAgIiIiU3RhcnQgdGhlIHNoYXJlZCBEdW1wUmVuZGVyVHJlZSwgaWYgaXQncyBub3QgcnVu bmluZy4KZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL2xheW91dF9wYWNrYWdlL2pzb25fbGF5b3V0X3Jlc3VsdHNfZ2VuZXJhdG9yLnB5IGIvV2Vi S2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvanNv bl9sYXlvdXRfcmVzdWx0c19nZW5lcmF0b3IucHkKaW5kZXggMWNmODhlZjU5N2Y0NTczZWVjNjkx ZmUwOWM2NGJhNTU4NDgzOTM2Yi4uNDc5ZjQwOTU1Y2I2MDAyOTI1ZmVkNjMwMTM0NjJjOGFlZDVi ZWI4YiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvbGF5b3V0X3BhY2thZ2UvanNvbl9sYXlvdXRfcmVzdWx0c19nZW5lcmF0b3IucHkKKysrIGIv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2Uv anNvbl9sYXlvdXRfcmVzdWx0c19nZW5lcmF0b3IucHkKQEAgLTUxLDYgKzUxLDggQEAgY2xhc3Mg SlNPTkxheW91dFJlc3VsdHNHZW5lcmF0b3IoanNvbl9yZXN1bHRzX2dlbmVyYXRvci5KU09OUmVz dWx0c0dlbmVyYXRvckJhc2UKICAgICAgICAgICAgICAgICAgICAgICAgdGVzdF9leHBlY3RhdGlv bnMuSU1BR0U6ICJJIiwKICAgICAgICAgICAgICAgICAgICAgICAgdGVzdF9leHBlY3RhdGlvbnMu VEVYVDogIkYiLAogICAgICAgICAgICAgICAgICAgICAgICB0ZXN0X2V4cGVjdGF0aW9ucy5NSVNT SU5HOiAiTyIsCisgICAgICAgICAgICAgICAgICAgICAgIHRlc3RfZXhwZWN0YXRpb25zLlJFRkVS RU5DRV9NSVNNQVRDSDogIlIiLAorICAgICAgICAgICAgICAgICAgICAgICB0ZXN0X2V4cGVjdGF0 aW9ucy5SRUZFUkVOQ0VfTUFUQ0g6ICJNIiwKICAgICAgICAgICAgICAgICAgICAgICAgdGVzdF9l eHBlY3RhdGlvbnMuSU1BR0VfUExVU19URVhUOiAiWiJ9CiAKICAgICBkZWYgX19pbml0X18oc2Vs ZiwgcG9ydCwgYnVpbGRlcl9uYW1lLCBidWlsZF9uYW1lLCBidWlsZF9udW1iZXIsCmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFj a2FnZS9zaW5nbGVfdGVzdF9ydW5uZXIucHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5 L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS9zaW5nbGVfdGVzdF9ydW5uZXIucHkKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uZTExMzYxYjE5ZWRiYzgxYjUyNTExOTFkNzVhNTZmZTY4NjE5MGRiYQotLS0gL2Rldi9u dWxsCisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91 dF9wYWNrYWdlL3NpbmdsZV90ZXN0X3J1bm5lci5weQpAQCAtMCwwICsxLDIyMSBAQAorIyEvdXNy L2Jpbi9lbnYgcHl0aG9uCisjIENvcHlyaWdodCAoQykgMjAxMCBHb29nbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgorIworIyBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQg YmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyMgbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorIyBtZXQ6Cisj CisjICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisjIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyMgICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorIyBjb3B5cmlnaHQgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisjIGluIHRo ZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUK KyMgZGlzdHJpYnV0aW9uLgorIyAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMu IG5vciB0aGUgbmFtZXMgb2YgaXRzCisjIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRv cnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisjIHRoaXMgc29mdHdhcmUgd2l0 aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisjCisjIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMK KyMgIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisjIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBE SVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisjIE9XTkVSIE9SIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LAorIyBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UCisjIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorIyBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyMgVEhFT1JZIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VAorIyAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UKKyMgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9G IFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKworIiIiQSB0ZXN0IHJ1bm5lciB3aGlj aCBydW5zIGEgc2luZ2xlIHRlc3QgZmlsZSAoZWl0aGVyIGEgbGF5b3V0IHRlc3Qgb3IgYSByZWZ0 ZXN0KSIiIgorCitmcm9tIF9fZnV0dXJlX18gaW1wb3J0IHdpdGhfc3RhdGVtZW50CisKK2ltcG9y dCBjb2RlY3MKK2ltcG9ydCBjb3B5CitpbXBvcnQgbG9nZ2luZworaW1wb3J0IG9zCitpbXBvcnQg c3lzCitpbXBvcnQgdGltZQorCitpbXBvcnQgdGVzdF9mYWlsdXJlcworaW1wb3J0IHRlc3RfcmVz dWx0cworCitfbG9nID0gbG9nZ2luZy5nZXRMb2dnZXIoIndlYmtpdHB5LmxheW91dF90ZXN0cy5s YXlvdXRfcGFja2FnZS4iCisgICAgICAgICAgICAgICAgICAgICAgICAgInNpbmdsZV90ZXN0X3J1 bm5lciIpCisKKworY2xhc3MgU2luZ2xlVGVzdFJ1bm5lcihvYmplY3QpOgorICAgICIiIkFuIGFi c3RyYWN0aW9uIGZvciBydW5uaW5nIGEgc2luZ2xlIHRlc3QuCisKKyAgICBBIHR5cGljYWwgdXNh Z2UgaXM6CisgICAgICAjIEluc3RhbnRpYXRlIHdpdGggbmVjZXNzYXJ5IHRlc3QgaW5mb3JtYXRp b24uCisgICAgICBydW5uZXIgPSBTaW5nbGVUZXN0UnVubmVyKHRlc3RfaW5mbywgdGVzdF9hcmdz LCAuLi4uKQorICAgICAgIyBSdW4gYW5kIGdldCBhIFRlc3RSZXN1bHQgb2JqZWN0IGJ5IGNhbGxp bmcgcnVuX3Rlc3QoKS4KKyAgICAgIHRlc3RfcmVzdWx0ID0gcnVubmVyLnJ1bl90ZXN0KCkKKyAg ICAiIiIKKworICAgIGRlZiBfX2luaXRfXyhzZWxmLCB0ZXN0X2luZm8sIHRlc3RfYXJncywgZHJp dmVyLCBwb3J0LCBvcHRpb25zLAorICAgICAgICAgICAgICAgICB0ZXN0X3R5cGVzLCByZWZ0ZXN0 X3R5cGVzKToKKyAgICAgICAgIiIiCisgICAgICAgIEFyZ3M6CisgICAgICAgICAgdGVzdF9pbmZv OiBPYmplY3QgY29udGFpbmluZyB0aGUgdGVzdCBpbmZvcm1hdGlvbiBzdWNoIGFzIGZpbGVuYW1l CisgICAgICAgICAgdGVzdF9hcmdzOiBBIFRlc3RBcmd1bWVudHMgb2JqZWN0IHRvIHBhc3MgdG8g ZWFjaCBUZXN0VHlwZS4KKyAgICAgICAgICBkcml2ZXI6IEEgdGVzdCBkcml2ZXIgKER1bXBSZW5k ZXJUcmVlKQorICAgICAgICAgIHBvcnQ6IG9iamVjdCBpbXBsZW1lbnRpbmcgcG9ydC1zcGVjaWZp YyBob29rcworICAgICAgICAgIG9wdGlvbnM6IGNvbW1hbmQgbGluZSBhcmd1bWVudCBvYmplY3Qg ZnJvbSBvcHRwYXJzZQorICAgICAgICAgIHRlc3RfdHlwZXM6IEEgbGlzdCBvZiBUZXN0VHlwZSBv YmplY3RzIHRvIHJ1biB0aGUgbGF5b3V0IHRlc3Qgb3V0cHV0CisgICAgICAgICAgICAgIGFnYWlu c3QuCisgICAgICAgICAgcmVmdGVzdF90eXBlczogQSBsaXN0IG9mIFRlc3RUeXBlIG9iamVjdHMg dG8gcnVuIHRoZSByZWZ0ZXN0IG91dHB1dAorICAgICAgICAgICAgICBhZ2FpbnN0LgorICAgICAg ICAiIiIKKyAgICAgICAgc2VsZi5fdGVzdF9pbmZvID0gdGVzdF9pbmZvCisgICAgICAgIHNlbGYu X3Rlc3RfYXJncyA9IHRlc3RfYXJncworICAgICAgICBzZWxmLl9kcml2ZXIgPSBkcml2ZXIKKyAg ICAgICAgc2VsZi5fcG9ydCA9IHBvcnQKKyAgICAgICAgc2VsZi5fb3B0aW9ucyA9IG9wdGlvbnMK KyAgICAgICAgc2VsZi5fdGVzdF90eXBlcyA9IHRlc3RfdHlwZXMKKyAgICAgICAgc2VsZi5fcmVm dGVzdF90eXBlcyA9IHJlZnRlc3RfdHlwZXMKKworICAgIGRlZiBydW5fdGVzdChzZWxmKToKKyAg ICAgICAgIiIiUnVuIGEgc2luZ2xlIHRlc3QgZmlsZSB1c2luZyBhIHNoYXJlZCBEdW1wUmVuZGVy VHJlZSBwcm9jZXNzLgorCisgICAgICAgIEFzIHNpZGUgZWZmZWN0cywgcHJlc2VydmVzIHRoZSBy ZW5kZXJpbmcgcmVzdWx0KHMpIGFuZCBleHBlY3RlZCBvbmUocykKKyAgICAgICAgYW5kIHNvIG9u IGluIHRoZSBvdXRwdXQgZGlyZWN0b3J5IGZvciBsYXRlciByZXBvcnRpbmcgaWYgbmVjZXNzYW55 LgorCisgICAgICAgIFJldHVybnM6CisgICAgICAgICAgQSBsaXN0IG9mIFRlc3RGYWlsdXJlIG9i amVjdHMgZGVzY3JpYmluZyB0aGUgZXJyb3IuCisgICAgICAgICIiIgorICAgICAgICBpZiBzZWxm Ll90ZXN0X2luZm8uaXNfcmVmdGVzdDoKKyAgICAgICAgICAgIHJldHVybiBzZWxmLl9ydW5fcmVm dGVzdCgpCisgICAgICAgIHJldHVybiBzZWxmLl9ydW5fbGF5b3V0X3Rlc3QoKQorCisgICAgZGVm IF9pbWFnZV9oYXNoKHNlbGYpOgorICAgICAgICAiIiJSZXR1cm5zIHRoZSBpbWFnZSBoYXNoIG9m IHRoZSB0ZXN0IGlmIGl0J3MgbmVlZGVkLCBvdGhlcndpc2UgTm9uZS4iIiIKKyAgICAgICAgaWYg KHNlbGYuX3Rlc3RfYXJncy5uZXdfYmFzZWxpbmUgb3Igc2VsZi5fdGVzdF9hcmdzLnJlc2V0X3Jl c3VsdHMgb3IKKyAgICAgICAgICAgIG5vdCBzZWxmLl9vcHRpb25zLnBpeGVsX3Rlc3RzKToKKyAg ICAgICAgICAgIHJldHVybiBOb25lCisgICAgICAgIHJldHVybiBzZWxmLl90ZXN0X2luZm8uaW1h Z2VfaGFzaCgpCisKKyAgICBkZWYgX3J1bl9sYXlvdXRfdGVzdChzZWxmKToKKyAgICAgICAgIyBU aGUgcGl4ZWxfaGFzaCBpcyB1c2VkIHRvIGF2b2lkIGRvaW5nIGFuIGltYWdlIGR1bXAgaWYgdGhl CisgICAgICAgICMgY2hlY2tzdW1zIG1hdGNoLCBzbyBpdCBzaG91bGQgYmUgc2V0IHRvIGEgYmxh bmsgdmFsdWUgaWYgd2UKKyAgICAgICAgIyBhcmUgZ2VuZXJhdGluZyBhIG5ldyBiYXNlbGluZS4g IChPdGhlcndpc2UsIGFuIGltYWdlIGZyb20gYQorICAgICAgICAjIHByZXZpb3VzIHJ1biB3aWxs IGJlIGNvcGllZCBpbnRvIHRoZSBiYXNlbGluZS4pCisgICAgICAgIGltYWdlX2hhc2ggPSBzZWxm Ll9pbWFnZV9oYXNoKCkKKyAgICAgICAgc3RhcnQgPSB0aW1lLnRpbWUoKQorCisgICAgICAgIGNy YXNoLCB0aW1lb3V0LCBhY3R1YWxfY2hlY2tzdW0sIG91dHB1dCwgZXJyb3IgPSBcCisgICAgICAg ICAgIHNlbGYuX2RyaXZlci5ydW5fdGVzdChzZWxmLl90ZXN0X2luZm8udXJpLCBzZWxmLl90ZXN0 X2luZm8udGltZW91dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGltYWdlX2hh c2gpCisgICAgICAgIGVuZCA9IHRpbWUudGltZSgpCisKKyAgICAgICAgIyBQcm9jZXNzIG91dHB1 dHMuCisgICAgICAgIGZhaWx1cmVzID0gW10KKyAgICAgICAgZmFpbHVyZXMuZXh0ZW5kKAorICAg ICAgICAgICAgc2VsZi5fcHJvY2Vzc19lcnJvcihzZWxmLl90ZXN0X2luZm8uZmlsZW5hbWUsIGNy YXNoLCB0aW1lb3V0LCBlcnJvcikpCisKKyAgICAgICAgIyBTb21lIHRlc3QgYXJncywgc3VjaCBh cyB0aGUgaW1hZ2UgaGFzaCwgbWF5IGJlIGFkZGVkIG9yIGNoYW5nZWQgb24gYQorICAgICAgICAj IHRlc3QtYnktdGVzdCBiYXNpcy4KKyAgICAgICAgbG9jYWxfdGVzdF9hcmdzID0gY29weS5jb3B5 KHNlbGYuX3Rlc3RfYXJncykKKyAgICAgICAgbG9jYWxfdGVzdF9hcmdzLmhhc2ggPSBhY3R1YWxf Y2hlY2tzdW0KKworICAgICAgICAjIENoZWNrIHRoZSBvdXRwdXQgYW5kIHNhdmUgdGhlIHJlc3Vs dHMuCisgICAgICAgIHRpbWVfZm9yX2RpZmZzID0ge30KKyAgICAgICAgZm9yIHRlc3RfdHlwZSBp biBzZWxmLl90ZXN0X3R5cGVzOgorICAgICAgICAgICAgc3RhcnRfZGlmZl90aW1lID0gdGltZS50 aW1lKCkKKyAgICAgICAgICAgIG5ld19mYWlsdXJlcyA9IHRlc3RfdHlwZS5jb21wYXJlX291dHB1 dChzZWxmLl9wb3J0LCBzZWxmLl90ZXN0X2luZm8uZmlsZW5hbWUsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb3V0cHV0LCBsb2NhbF90ZXN0X2Fy Z3MsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg c2VsZi5fb3B0aW9ucy5jb25maWd1cmF0aW9uKQorICAgICAgICAgICAgIyBEb24ndCBhZGQgYW55 IG1vcmUgZmFpbHVyZXMgaWYgd2UgYWxyZWFkeSBoYXZlIGEgY3Jhc2gsIHNvIHdlIGRvbid0Cisg ICAgICAgICAgICAjIGRvdWJsZS1yZXBvcnQgdGhvc2UgdGVzdHMuIFdlIGRvIGRvdWJsZS1yZXBv cnQgZm9yIHRpbWVvdXRzIHNpbmNlCisgICAgICAgICAgICAjIHdlIHN0aWxsIHdhbnQgdG8gc2Vl IHRoZSB0ZXh0IGFuZCBpbWFnZSBvdXRwdXQuCisgICAgICAgICAgICBpZiBub3QgY3Jhc2g6Cisg ICAgICAgICAgICAgICAgZmFpbHVyZXMuZXh0ZW5kKG5ld19mYWlsdXJlcykKKyAgICAgICAgICAg IHRpbWVfZm9yX2RpZmZzW3Rlc3RfdHlwZS5fX2NsYXNzX18uX19uYW1lX19dID0gKAorICAgICAg ICAgICAgICAgIHRpbWUudGltZSgpIC0gc3RhcnRfZGlmZl90aW1lKQorCisgICAgICAgIHRvdGFs X3RpbWVfZm9yX2FsbF9kaWZmcyA9IHRpbWUudGltZSgpIC0gc3RhcnRfZGlmZl90aW1lCisgICAg ICAgIHJldHVybiB0ZXN0X3Jlc3VsdHMuVGVzdFJlc3VsdChzZWxmLl90ZXN0X2luZm8uZmlsZW5h bWUsIGZhaWx1cmVzLCBlbmQgLSBzdGFydCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHRvdGFsX3RpbWVfZm9yX2FsbF9kaWZmcywgdGltZV9mb3JfZGlmZnMpCisKKyAg ICBkZWYgX291dHB1dF9pbWFnZV9jb250ZW50c19mcm9tX2RyaXZlcihzZWxmKToKKyAgICAgICAg cG5nX3BhdGggPSBzZWxmLl90ZXN0X2FyZ3MucG5nX3BhdGgKKyAgICAgICAgYXNzZXJ0KG9zLnBh dGguaXNmaWxlKHBuZ19wYXRoKSkKKyAgICAgICAgd2l0aCBvcGVuKHBuZ19wYXRoLCAncmInKSBh cyBpbWFnZV9maWxlOgorICAgICAgICAgICAgcmV0dXJuIGltYWdlX2ZpbGUucmVhZCgpCisKKyAg ICBkZWYgX3J1bl9yZWZ0ZXN0KHNlbGYpOgorICAgICAgICBzdGFydCA9IHRpbWUudGltZSgpCisg ICAgICAgICMgV2Ugc2hvdWxkIGNhbGwgZHJpdmVyJ3MgcnVuX3Rlc3QgbWV0aG9kIHR3byB0aW1l cy4gT25lIGlzIGZvciB0aGUgdGVzdCBmaWxlLgorICAgICAgICAjIFRoZSBvdGhlciBpcyBmb3Ig dGhlIHJlZmVyZW5jZSBmaWxlLgorCisgICAgICAgICMgMS4gR2V0cyBhIHJlbmRlcmluZyBpbWFn ZSBmb3IgdGhlIHRlc3QgZmlsZS4KKyAgICAgICAgKGFjdHVhbF9jcmFzaCwgYWN0dWFsX3RpbWVv dXQsIGFjdHVhbF9pbWFnZV9oYXNoLCBhY3R1YWxfb3V0cHV0LAorICAgICAgICAgYWN0dWFsX2Vy cm9yKSA9IFwKKyAgICAgICAgICAgIHNlbGYuX2RyaXZlci5ydW5fdGVzdChzZWxmLl90ZXN0X2lu Zm8udXJpLCBzZWxmLl90ZXN0X2luZm8udGltZW91dCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBpbWFnZV9oYXNoPSIiKQorICAgICAgICBhY3R1YWxfaW1hZ2VfY29udGVudHMg PSBzZWxmLl9vdXRwdXRfaW1hZ2VfY29udGVudHNfZnJvbV9kcml2ZXIoKQorCisgICAgICAgICMg Mi4gR2V0cyBhIHJlbmRlcmluZyBpbWFnZSBmb3IgdGhlIHJlZmVyZW5jZSBmaWxlLgorICAgICAg ICByZWZlcmVuY2VfZmlsZW5hbWUgPSAoc2VsZi5fdGVzdF9pbmZvLmV4cGVjdGVkX2h0bWxfZmls ZW5hbWUKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG9yIHNlbGYuX3Rlc3RfaW5mby5l eHBlY3RlZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1lKQorICAgICAgICAocmVmZXJlbmNlX2NyYXNo LCByZWZlcmVuY2VfdGltZW91dCwgcmVmZXJlbmNlX2ltYWdlX2hhc2gsCisgICAgICAgICByZWZl cmVuY2Vfb3V0cHV0LCByZWZlcmVuY2VfZXJyb3IpID0gXAorICAgICAgICAgICAgc2VsZi5fZHJp dmVyLnJ1bl90ZXN0KHJlZmVyZW5jZV9maWxlbmFtZSwgc2VsZi5fdGVzdF9pbmZvLnRpbWVvdXQs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYWN0dWFsX2ltYWdlX2hhc2gpCisK KyAgICAgICAgaWYgYWN0dWFsX2ltYWdlX2hhc2ggPT0gcmVmZXJlbmNlX2ltYWdlX2hhc2g6Cisg ICAgICAgICAgICByZWZlcmVuY2VfaW1hZ2VfY29udGVudHMgPSBhY3R1YWxfaW1hZ2VfY29udGVu dHMKKyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIHJlZmVyZW5jZV9pbWFnZV9jb250ZW50cyA9 IHNlbGYuX291dHB1dF9pbWFnZV9jb250ZW50c19mcm9tX2RyaXZlcigpCisKKyAgICAgICAgZW5k ID0gdGltZS50aW1lKCkKKworICAgICAgICAjIFByb2Nlc3MgYWN0dWFsIGFuZCByZWZlcmVuY2Ug b3V0cHV0cy4KKyAgICAgICAgZmFpbHVyZXMgPSBbXQorICAgICAgICBmYWlsdXJlcy5leHRlbmQo CisgICAgICAgICAgICBzZWxmLl9wcm9jZXNzX2Vycm9yKHNlbGYuX3Rlc3RfaW5mby5leHBlY3Rl ZF9odG1sX2ZpbGVuYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhY3R1YWxf Y3Jhc2gsIGFjdHVhbF90aW1lb3V0LCBhY3R1YWxfZXJyb3IpKQorICAgICAgICBmYWlsdXJlcy5l eHRlbmQoCisgICAgICAgICAgICBzZWxmLl9wcm9jZXNzX2Vycm9yKHNlbGYuX3Rlc3RfaW5mby5l eHBlY3RlZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZWZlcmVuY2VfY3Jhc2gsIHJlZmVyZW5jZV90aW1lb3V0LCByZWZlcmVuY2VfZXJy b3IpKQorCisgICAgICAgIHRpbWVfZm9yX2RpZmZzID0ge30KKyAgICAgICAgZm9yIHRlc3RfdHlw ZSBpbiBzZWxmLl9yZWZ0ZXN0X3R5cGVzOgorICAgICAgICAgICAgc3RhcnRfZGlmZl90aW1lID0g dGltZS50aW1lKCkKKyAgICAgICAgICAgIG5ld19mYWlsdXJlcyA9IHRlc3RfdHlwZS5jb21wYXJl X291dHB1dF93aXRoX3JlZmVyZW5jZSgKKyAgICAgICAgICAgICAgICBzZWxmLl9wb3J0LCBzZWxm Ll90ZXN0X2luZm8sIGFjdHVhbF9pbWFnZV9oYXNoLCBhY3R1YWxfaW1hZ2VfY29udGVudHMsCisg ICAgICAgICAgICAgICAgcmVmZXJlbmNlX2ltYWdlX2hhc2gsIHJlZmVyZW5jZV9pbWFnZV9jb250 ZW50cykKKworICAgICAgICAgICAgaWYgbm90IGFjdHVhbF9jcmFzaCBhbmQgbm90IHJlZmVyZW5j ZV9jcmFzaDoKKyAgICAgICAgICAgICAgICBmYWlsdXJlcy5leHRlbmQobmV3X2ZhaWx1cmVzKQor CisgICAgICAgICAgICB0aW1lX2Zvcl9kaWZmc1t0ZXN0X3R5cGUuX19jbGFzc19fLl9fbmFtZV9f XSA9ICgKKyAgICAgICAgICAgICAgICB0aW1lLnRpbWUoKSAtIHN0YXJ0X2RpZmZfdGltZSkKKwor ICAgICAgICB0b3RhbF90aW1lX2Zvcl9hbGxfZGlmZnMgPSB0aW1lLnRpbWUoKSAtIHN0YXJ0X2Rp ZmZfdGltZQorICAgICAgICByZXR1cm4gdGVzdF9yZXN1bHRzLlRlc3RSZXN1bHQoc2VsZi5fdGVz dF9pbmZvLmZpbGVuYW1lLCBmYWlsdXJlcywgZW5kIC0gc3RhcnQsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB0b3RhbF90aW1lX2Zvcl9hbGxfZGlmZnMsIHRpbWVfZm9y X2RpZmZzKQorCisgICAgZGVmIF9wcm9jZXNzX2Vycm9yKHNlbGYsIGZpbGVuYW1lLCBjcmFzaCwg dGltZW91dCwgZXJyb3IpOgorICAgICAgICBmYWlsdXJlcyA9IFtdCisgICAgICAgIGlmIGNyYXNo OgorICAgICAgICAgICAgZmFpbHVyZXMuYXBwZW5kKHRlc3RfZmFpbHVyZXMuRmFpbHVyZUNyYXNo KCkpCisgICAgICAgIGlmIHRpbWVvdXQ6CisgICAgICAgICAgICBmYWlsdXJlcy5hcHBlbmQodGVz dF9mYWlsdXJlcy5GYWlsdXJlVGltZW91dCgpKQorCisgICAgICAgIGlmIGNyYXNoOgorICAgICAg ICAgICAgX2xvZy5kZWJ1ZygiU3RhY2t0cmFjZSBmb3IgJXM6XG4lcyIgJSAoZmlsZW5hbWUsIGVy cm9yKSkKKyAgICAgICAgICAgICMgU3RyaXAgb2ZmICJmaWxlOi8vIiBzaW5jZSBSZWxhdGl2ZVRl c3RGaWxlbmFtZSBleHBlY3RzCisgICAgICAgICAgICAjIGZpbGVzeXN0ZW0gcGF0aHMuCisgICAg ICAgICAgICBmaWxlbmFtZSA9IG9zLnBhdGguam9pbihzZWxmLl9vcHRpb25zLnJlc3VsdHNfZGly ZWN0b3J5LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VsZi5fcG9ydC5y ZWxhdGl2ZV90ZXN0X2ZpbGVuYW1lKAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgc2VsZi5fdGVzdF9pbmZvLmZpbGVuYW1lKSkKKyAgICAgICAgICAgIGZpbGVuYW1lID0gb3Mu cGF0aC5zcGxpdGV4dChmaWxlbmFtZSlbMF0gKyAiLXN0YWNrLnR4dCIKKyAgICAgICAgICAgIHNl bGYuX3BvcnQubWF5YmVfbWFrZV9kaXJlY3Rvcnkob3MucGF0aC5zcGxpdChmaWxlbmFtZSlbMF0p CisgICAgICAgICAgICB3aXRoIGNvZGVjcy5vcGVuKGZpbGVuYW1lLCAid2IiLCAidXRmLTgiKSBh cyBmaWxlOgorICAgICAgICAgICAgICAgIGZpbGUud3JpdGUoZXJyb3IpCisgICAgICAgIGVsaWYg ZXJyb3I6CisgICAgICAgICAgICBfbG9nLmRlYnVnKCJQcmV2aW91cyB0ZXN0IG91dHB1dCBzdGRl cnIgbGluZXM6XG4lcyIgJSBlcnJvcikKKyAgICAgICAgcmV0dXJuIGZhaWx1cmVzCmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFj a2FnZS90ZXN0X2V4cGVjdGF0aW9ucy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkv bGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL3Rlc3RfZXhwZWN0YXRpb25zLnB5CmluZGV4IDY3 ODczYThjYzBhYjMxNzljN2RlMzVkNWM5ODE2Y2UzNDBkMzRjYjkuLjQwMzZjMGQ0NGNjZDgwM2Nj NjhkYjdhMWQ1YTk1ZGFjMGRhOGMyNGMgMTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9wYWNrYWdlL3Rlc3RfZXhwZWN0YXRpb25zLnB5 CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2xheW91dF9w YWNrYWdlL3Rlc3RfZXhwZWN0YXRpb25zLnB5CkBAIC00Miw4ICs0Miw5IEBAIF9sb2cgPSBsb2dn aW5nLmdldExvZ2dlcigid2Via2l0cHkubGF5b3V0X3Rlc3RzLmxheW91dF9wYWNrYWdlLiIKICAg ICAgICAgICAgICAgICAgICAgICAgICAidGVzdF9leHBlY3RhdGlvbnMiKQogCiAjIFRlc3QgZXhw ZWN0YXRpb24gYW5kIG1vZGlmaWVyIGNvbnN0YW50cy4KLShQQVNTLCBGQUlMLCBURVhULCBJTUFH RSwgSU1BR0VfUExVU19URVhULCBUSU1FT1VULCBDUkFTSCwgU0tJUCwgV09OVEZJWCwKLSBTTE9X LCBSRUJBU0VMSU5FLCBNSVNTSU5HLCBGTEFLWSwgTk9XLCBOT05FKSA9IHJhbmdlKDE1KQorKFBB U1MsIEZBSUwsIFRFWFQsIElNQUdFLCBJTUFHRV9QTFVTX1RFWFQsIFJFRkVSRU5DRV9NSVNNQVRD SCwgUkVGRVJFTkNFX01BVENILAorIFRJTUVPVVQsIENSQVNILCBTS0lQLCBXT05URklYLCBTTE9X LCBSRUJBU0VMSU5FLCBNSVNTSU5HLCBGTEFLWSwgTk9XLAorIE5PTkUpID0gcmFuZ2UoMTcpCiAK ICMgVGVzdCBleHBlY3RhdGlvbiBmaWxlIHVwZGF0ZSBhY3Rpb24gY29uc3RhbnRzCiAoTk9fQ0hB TkdFLCBSRU1PVkVfVEVTVCwgUkVNT1ZFX1BMQVRGT1JNLCBBRERfUExBVEZPUk1TX0VYQ0VQVF9U SElTKSA9IHJhbmdlKDQpCkBAIC01OSw3ICs2MCw5IEBAIGRlZiByZXN1bHRfd2FzX2V4cGVjdGVk KHJlc3VsdCwgZXhwZWN0ZWRfcmVzdWx0cywgdGVzdF9uZWVkc19yZWJhc2VsaW5pbmcsCiAgICAg ICAgIHRlc3RfaXNfc2tpcHBlZDogd2hldGhlciB0ZXN0IHdhcyBtYXJrZWQgYXMgU0tJUCIiIgog ICAgIGlmIHJlc3VsdCBpbiBleHBlY3RlZF9yZXN1bHRzOgogICAgICAgICByZXR1cm4gVHJ1ZQot ICAgIGlmIHJlc3VsdCBpbiAoSU1BR0UsIFRFWFQsIElNQUdFX1BMVVNfVEVYVCkgYW5kIEZBSUwg aW4gZXhwZWN0ZWRfcmVzdWx0czoKKyAgICBpZiAocmVzdWx0IGluIChJTUFHRSwgVEVYVCwgSU1B R0VfUExVU19URVhULCBSRUZFUkVOQ0VfTUlTTUFUQ0gsCisgICAgICAgICAgICAgICAgICAgUkVG RVJFTkNFX01BVENIKQorICAgICAgICBhbmQgRkFJTCBpbiBleHBlY3RlZF9yZXN1bHRzKToKICAg ICAgICAgcmV0dXJuIFRydWUKICAgICBpZiByZXN1bHQgPT0gTUlTU0lORyBhbmQgdGVzdF9uZWVk c19yZWJhc2VsaW5pbmc6CiAgICAgICAgIHJldHVybiBUcnVlCkBAIC0yNTUsNiArMjU4LDggQEAg Y2xhc3MgVGVzdEV4cGVjdGF0aW9uc0ZpbGU6CiAgICAgICAgICAgICAgICAgICAgICd0ZXh0Jzog VEVYVCwKICAgICAgICAgICAgICAgICAgICAgJ2ltYWdlJzogSU1BR0UsCiAgICAgICAgICAgICAg ICAgICAgICdpbWFnZSt0ZXh0JzogSU1BR0VfUExVU19URVhULAorICAgICAgICAgICAgICAgICAg ICAncmVmZXJlbmNlX21pc21hdGNoJzogUkVGRVJFTkNFX01JU01BVENILAorICAgICAgICAgICAg ICAgICAgICAncmVmZXJlbmNlX21hdGNoJzogUkVGRVJFTkNFX01BVENILAogICAgICAgICAgICAg ICAgICAgICAndGltZW91dCc6IFRJTUVPVVQsCiAgICAgICAgICAgICAgICAgICAgICdjcmFzaCc6 IENSQVNILAogICAgICAgICAgICAgICAgICAgICAnbWlzc2luZyc6IE1JU1NJTkd9CkBAIC0yNjcs NiArMjcyLDEwIEBAIGNsYXNzIFRlc3RFeHBlY3RhdGlvbnNGaWxlOgogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBJTUFHRTogKCdpbWFnZSBtaXNtYXRjaCcsICdpbWFnZSBtaXNtYXRj aCcpLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJTUFHRV9QTFVTX1RFWFQ6ICgn aW1hZ2UgYW5kIHRleHQgbWlzbWF0Y2gnLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAnaW1hZ2UgYW5kIHRleHQgbWlzbWF0Y2gnKSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgUkVGRVJFTkNFX01JU01BVENIOiAoJ3JlZmVyZW5jZSBt aXNtYXRjaCcsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAncmVmZXJlbmNlIG1pc21hdGNoJyksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFJFRkVSRU5DRV9NQVRDSDogKCdyZWZlcmVuY2UgbWF0Y2gnLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ3JlZmVyZW5jZSBtYXRjaCcpLAog ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDUkFTSDogKCdEdW1wUmVuZGVyVHJlZSBj cmFzaCcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ0R1bXBSZW5k ZXJUcmVlIGNyYXNoZXMnKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVElNRU9V VDogKCd0ZXN0IHRpbWVkIG91dCcsICd0ZXN0cyB0aW1lZCBvdXQnKSwKQEAgLTI3NCw3ICsyODMs NyBAQCBjbGFzcyBUZXN0RXhwZWN0YXRpb25zRmlsZToKICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICdubyBleHBlY3RlZCByZXN1bHRzIGZvdW5kJyl9CiAKICAgICBF WFBFQ1RBVElPTl9PUkRFUiA9IChQQVNTLCBDUkFTSCwgVElNRU9VVCwgTUlTU0lORywgSU1BR0Vf UExVU19URVhULAotICAgICAgIFRFWFQsIElNQUdFLCBGQUlMLCBTS0lQKQorICAgICAgIFRFWFQs IElNQUdFLCBSRUZFUkVOQ0VfTUlTTUFUQ0gsIFJFRkVSRU5DRV9NQVRDSCwgRkFJTCwgU0tJUCkK IAogICAgIEJVSUxEX1RZUEVTID0gKCdkZWJ1ZycsICdyZWxlYXNlJykKIApkaWZmIC0tZ2l0IGEv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvbGF5b3V0X3BhY2thZ2Uv dGVzdF9mYWlsdXJlcy5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL2xheW91dF9wYWNrYWdlL3Rlc3RfZmFpbHVyZXMucHkKaW5kZXggNmQ1NTc2MTBmYmYxYjYz NjRlNDhlODI0ZDAyMWI1MmZmNzljNzFmOC4uMDFkNzkwYWIzYmIxNjIzMjk4MmFkNTg0NGNjMmQ2 YWE0ZmY1YzBiMiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlv dXRfdGVzdHMvbGF5b3V0X3BhY2thZ2UvdGVzdF9mYWlsdXJlcy5weQorKysgYi9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9sYXlvdXRfcGFja2FnZS90ZXN0X2ZhaWx1 cmVzLnB5CkBAIC02NCw2ICs2NCwxMCBAQCBkZWYgZGV0ZXJtaW5lX3Jlc3VsdF90eXBlKGZhaWx1 cmVfbGlzdCk6CiAgICAgICAgICAgICByZXR1cm4gdGVzdF9leHBlY3RhdGlvbnMuVEVYVAogICAg ICAgICBlbGlmIGlzX2ltYWdlX2ZhaWx1cmU6CiAgICAgICAgICAgICByZXR1cm4gdGVzdF9leHBl Y3RhdGlvbnMuSU1BR0UKKyAgICAgICAgZWxpZiBGYWlsdXJlUmVmZXJlbmNlTWlzbWF0Y2ggaW4g ZmFpbHVyZV90eXBlczoKKyAgICAgICAgICAgIHJldHVybiB0ZXN0X2V4cGVjdGF0aW9ucy5SRUZF UkVOQ0VfTUlTTUFUQ0gKKyAgICAgICAgZWxpZiBGYWlsdXJlUmVmZXJlbmNlTWF0Y2ggaW4gZmFp bHVyZV90eXBlczoKKyAgICAgICAgICAgIHJldHVybiB0ZXN0X2V4cGVjdGF0aW9ucy5SRUZFUkVO Q0VfTUFUQ0gKICAgICAgICAgZWxzZToKICAgICAgICAgICAgIHJhaXNlIFZhbHVlRXJyb3IoInVu Y2xhc3NpZmlhYmxlIHNldCBvZiBmYWlsdXJlczogIgogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICArIHN0cihmYWlsdXJlX3R5cGVzKSkKQEAgLTI3NCw2ICsyNzgsNDQgQEAgY2xhc3MgRmFp bHVyZUltYWdlSGFzaEluY29ycmVjdChGYWlsdXJlV2l0aFR5cGUpOgogICAgIGRlZiByZXN1bHRf aHRtbF9vdXRwdXQoc2VsZiwgZmlsZW5hbWUpOgogICAgICAgICByZXR1cm4gIjxzdHJvbmc+JXM8 L3N0cm9uZz4iICUgc2VsZi5tZXNzYWdlKCkKIAorCitjbGFzcyBGYWlsdXJlUmVmZXJlbmNlTWlz bWF0Y2goRmFpbHVyZVdpdGhUeXBlKToKKyAgICAiIiJUaGUgcmVzdWx0IGRpZG4ndCBtYXRjaCB0 aGUgcmVmZXJlbmNlIHJlbmRlcmluZy4iIiIKKyAgICBPVVRfRklMRU5BTUVTID0gKCItYWN0dWFs LnBuZyIsICItZXhwZWN0ZWQuaHRtbCIsICItZXhwZWN0ZWQucG5nIiwKKyAgICAgICAgICAgICAg ICAgICAgICItZGlmZi5wbmciLCkKKworICAgIEBzdGF0aWNtZXRob2QKKyAgICBkZWYgbWVzc2Fn ZSgpOgorICAgICAgICByZXR1cm4gIlJlZmVyZW5jZSBtaXNtYXRjaCIKKworICAgIGRlZiBvdXRw dXRfbGlua3Moc2VsZiwgZmlsZW5hbWUsIG91dF9uYW1lcyk6CisgICAgICAgIGxpbmtzID0gWycn XQorICAgICAgICB1cmlzID0gW3NlbGYucmVsYXRpdmVfb3V0cHV0X2ZpbGVuYW1lKGZpbGVuYW1l LCBmbikgZm9yCisgICAgICAgICAgICAgICAgZm4gaW4gb3V0X25hbWVzXQorICAgICAgICBmb3Ig dGV4dCwgdXJpIGluIHppcChbJ2FjdHVhbC1pbWFnZScsICdyZWZlcmVuY2UtaHRtbCcsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAncmVmZXJlbmNlLWltYWdlJywgJ2RpZmYnXSwgdXJp cyk6CisgICAgICAgICAgICBsaW5rcy5hcHBlbmQoIjxhIGhyZWY9JyVzJz4lczwvYT4iICUgKHVy aSwgdGV4dCkpCisgICAgICAgIHJldHVybiAnICcuam9pbihsaW5rcykKKworCitjbGFzcyBGYWls dXJlUmVmZXJlbmNlTWF0Y2goRmFpbHVyZVdpdGhUeXBlKToKKyAgICAiIiJVbmV4cGVjdGVkIG1h dGNoIGJldHdlZW4gdGhlIHJlc3VsdCBhbmQgdGhlIHJlZmVyZW5jZSByZW5kZXJpbmcuIiIiCisg ICAgT1VUX0ZJTEVOQU1FUyA9ICgiLWFjdHVhbC5wbmciLCAiLWV4cGVjdGVkLW1pc21hdGNoLmh0 bWwiLCkKKworICAgIEBzdGF0aWNtZXRob2QKKyAgICBkZWYgbWVzc2FnZSgpOgorICAgICAgICBy ZXR1cm4gKCJUaGVyZSB3YXMgbm8gZGlmZmVyZW5jZSBiZXR3ZWVuIHRoZSByZXN1bHQgYW5kIHRo ZSByZWZlcmVuY2UiCisgICAgICAgICAgICAgICAgIiByZW5kZXJpbmciKQorCisgICAgZGVmIG91 dHB1dF9saW5rcyhzZWxmLCBmaWxlbmFtZSwgb3V0X25hbWVzKToKKyAgICAgICAgbGlua3MgPSBb JyddCisgICAgICAgIHVyaXMgPSBbc2VsZi5yZWxhdGl2ZV9vdXRwdXRfZmlsZW5hbWUoZmlsZW5h bWUsIGZuKSBmb3IKKyAgICAgICAgICAgICAgICBmbiBpbiBvdXRfbmFtZXNdCisgICAgICAgIGZv ciB0ZXh0LCB1cmkgaW4gemlwKFsnaW1hZ2UnLCAncmVmZXJlbmNlLWh0bWwnXSwgdXJpcyk6Cisg ICAgICAgICAgICBsaW5rcy5hcHBlbmQoIjxhIGhyZWY9JyVzJz4lczwvYT4iICUgKHVyaSwgdGV4 dCkpCisgICAgICAgIHJldHVybiAnICcuam9pbihsaW5rcykKKworCiAjIENvbnZlbmllbnQgY29s bGVjdGlvbiBvZiBhbGwgZmFpbHVyZSBjbGFzc2VzIGZvciBhbnl0aGluZyB0aGF0IG1pZ2h0CiAj IG5lZWQgdG8gZW51bWVyYXRlIG92ZXIgdGhlbSBhbGwuCiBBTExfRkFJTFVSRV9DTEFTU0VTID0g KEZhaWx1cmVUaW1lb3V0LCBGYWlsdXJlQ3Jhc2gsIEZhaWx1cmVNaXNzaW5nUmVzdWx0LApkaWZm IC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9i YXNlLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC9i YXNlLnB5CmluZGV4IDRhMjk3MGUzMjAzYzYwMGY1ZTI4OWY4ZTgzZGQ4YWE0MjkwMGExYjQuLmQw MGJjYWRjNGFiYzEzM2M0NWNlOTVjMDg4MDVjZTRlODEwMDdjMDIgMTAwNjQ0Ci0tLSBhL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvYmFzZS5weQorKysgYi9X ZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L2Jhc2UucHkKQEAg LTMzMiw2ICszMzIsMTUgQEAgY2xhc3MgUG9ydChvYmplY3QpOgogICAgICAgICB0ZXh0ID0gc2Vs Zi5fZmlsZXN5c3RlbS5yZWFkX2JpbmFyeV9maWxlKHBhdGgpCiAgICAgICAgIHJldHVybiB0ZXh0 LnN0cmlwKCJcclxuIikucmVwbGFjZSgiXHJcbiIsICJcbiIpICsgIlxuIgogCisgICAgZGVmIGV4 cGVjdGVkX2h0bWxfZmlsZW5hbWUoc2VsZiwgZmlsZW5hbWUpOgorICAgICAgICAiIiJSZXR1cm4g dGhlIGZpbGVuYW1lIG9mIHJlZmVyZW5jZSBIVE1MIHdlIGV4cGVjdCB0aGUgdGVzdCBtYXRjaGVz LiIiIgorICAgICAgICByZXR1cm4gc2VsZi5leHBlY3RlZF9maWxlbmFtZShmaWxlbmFtZSwgJy5o dG1sJykKKworICAgIGRlZiBleHBlY3RlZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1lKHNlbGYsIGZp bGVuYW1lKToKKyAgICAgICAgIiIiUmV0dXJuIHRoZSBmaWxlbmFtZSBvZiByZWZlcmVuY2UgSFRN TCB3ZSBkb24ndCBleHBlY3QgdGhlIHRlc3QKKyAgICAgICAgbWF0Y2hlcy4iIiIKKyAgICAgICAg cmV0dXJuIHNlbGYuZXhwZWN0ZWRfZmlsZW5hbWUoZmlsZW5hbWUsICctbWlzbWF0Y2guaHRtbCcp CisKICAgICBkZWYgZmlsZW5hbWVfdG9fdXJpKHNlbGYsIGZpbGVuYW1lKToKICAgICAgICAgIiIi Q29udmVydCBhIHRlc3QgZmlsZSAod2hpY2ggaXMgYW4gYWJzb2x1dGUgcGF0aCkgdG8gYSBVUkku IiIiCiAgICAgICAgIExBWU9VVFRFU1RfSFRUUF9ESVIgPSAiaHR0cC90ZXN0cy8iCmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3Rlc3Qu cHkgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9wb3J0L3Rlc3Qu cHkKaW5kZXggZmY0MDg2Yzc0ZGMxODJiYTg0NzEyM2U2MzU1MDBkMTQ0MTFkOTkzZS4uNTcyNGM4 NmNkZGFiNjE0MWM2ZDVkYTQ3Y2VjM2Q5OGEyMWJjY2ViYiAxMDA2NDQKLS0tIGEvV2ViS2l0VG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcG9ydC90ZXN0LnB5CisrKyBiL1dlYktp dFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvdGVzdC5weQpAQCAtMTI3 LDggKzEyNyw5IEBAIGNsYXNzIFRlc3RQb3J0KGJhc2UuUG9ydCk6CiAgICAgICAgIHNlbGYuX3Rl c3RzID0gdGVzdHMKIAogICAgIGRlZiBiYXNlbGluZV9wYXRoKHNlbGYpOgorICAgICAgICBuYW1l ID0gc2VsZi5uYW1lKCkgb3IgJ3Vua25vd25wb3J0JwogICAgICAgICByZXR1cm4gb3MucGF0aC5q b2luKHNlbGYubGF5b3V0X3Rlc3RzX2RpcigpLCAncGxhdGZvcm0nLAotICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHNlbGYubmFtZSgpICsgc2VsZi52ZXJzaW9uKCkpCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgbmFtZSArIHNlbGYudmVyc2lvbigpKQogCiAgICAgZGVmIGJhc2VsaW5l X3NlYXJjaF9wYXRoKHNlbGYpOgogICAgICAgICByZXR1cm4gW3NlbGYuYmFzZWxpbmVfcGF0aCgp XQpkaWZmIC0tZ2l0IGEvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cG9ydC90ZXN0X2ZpbGVzLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvcG9ydC90ZXN0X2ZpbGVzLnB5CmluZGV4IDNmYTBmYjM2NGJiMzE5NjAyZTYxOWFkZjVk ZDUxZDMyYjBmNTdhNTIuLmQ2YjI4MzY2NjUzY2JmNTM4ODM4Zjc5Y2QyNTk2NGNlMzExYTg3ZWIg MTAwNjQ0Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvdGVzdF9maWxlcy5weQorKysgYi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9wb3J0L3Rlc3RfZmlsZXMucHkKQEAgLTUwLDYgKzUwLDkgQEAgX3N1cHBvcnRlZF9m aWxlX2V4dGVuc2lvbnMgPSBzZXQoWycuaHRtbCcsICcuc2h0bWwnLCAnLnhtbCcsICcueGh0bWwn LCAnLnhodG1sbXAKICMgV2hlbiBjb2xsZWN0aW5nIHRlc3QgY2FzZXMsIHNraXAgdGhlc2UgZGly ZWN0b3JpZXMKIF9za2lwcGVkX2RpcmVjdG9yaWVzID0gc2V0KFsnLnN2bicsICdfc3ZuJywgJ3Jl c291cmNlcycsICdzY3JpcHQtdGVzdHMnXSkKIAorIyBXaGVuIGNvbGxlY3RpbmcgdGVzdCBjYXNl cywgc2tpcCBmaWxlcyB3aXRoIHRoZXNlIHN1ZmZpeGVzLgorX3NraXBwZWRfc3VmZml4ZXMgPSBz ZXQoWyctZXhwZWN0ZWQuaHRtbCcsICdleHBlY3RlZC1taXNtYXRjaC5odG1sJ10pCisKIAogZGVm IGZpbmQocG9ydCwgcGF0aHMpOgogICAgICIiIkZpbmRzIHRoZSBzZXQgb2YgdGVzdHMgdW5kZXIg cG9ydC5sYXlvdXRfdGVzdHNfZGlyKCkuCkBAIC03OCw3ICs4MSw3IEBAIGRlZiBmaW5kKHBvcnQs IHBhdGhzKToKICAgICAjIE5vdyB3YWxrIGFsbCB0aGUgcGF0aHMgcGFzc2VkIGluIG9uIHRoZSBj b21tYW5kIGxpbmUgYW5kIGdldCBmaWxlbmFtZXMKICAgICB0ZXN0X2ZpbGVzID0gc2V0KCkKICAg ICBmb3IgcGF0aCBpbiBwYXRoc190b193YWxrOgotICAgICAgICBpZiBvcy5wYXRoLmlzZmlsZShw YXRoKSBhbmQgX2hhc19zdXBwb3J0ZWRfZXh0ZW5zaW9uKHBhdGgpOgorICAgICAgICBpZiBvcy5w YXRoLmlzZmlsZShwYXRoKSBhbmQgX2lzX3Rlc3RfZmlsZShwYXRoKToKICAgICAgICAgICAgIHRl c3RfZmlsZXMuYWRkKG9zLnBhdGgubm9ybXBhdGgocGF0aCkpCiAgICAgICAgICAgICBjb250aW51 ZQogCkBAIC05NSw3ICs5OCw3IEBAIGRlZiBmaW5kKHBvcnQsIHBhdGhzKToKICAgICAgICAgICAg ICAgICAgICAgZGlycy5yZW1vdmUoZGlyZWN0b3J5KQogCiAgICAgICAgICAgICBmb3IgZmlsZW5h bWUgaW4gZmlsZXM6Ci0gICAgICAgICAgICAgICAgaWYgX2hhc19zdXBwb3J0ZWRfZXh0ZW5zaW9u KGZpbGVuYW1lKToKKyAgICAgICAgICAgICAgICBpZiBfaXNfdGVzdF9maWxlKGZpbGVuYW1lKToK ICAgICAgICAgICAgICAgICAgICAgZmlsZW5hbWUgPSBvcy5wYXRoLmpvaW4ocm9vdCwgZmlsZW5h bWUpCiAgICAgICAgICAgICAgICAgICAgIGZpbGVuYW1lID0gb3MucGF0aC5ub3JtcGF0aChmaWxl bmFtZSkKICAgICAgICAgICAgICAgICAgICAgdGVzdF9maWxlcy5hZGQoZmlsZW5hbWUpCkBAIC0x MTEsMyArMTE0LDE1IEBAIGRlZiBfaGFzX3N1cHBvcnRlZF9leHRlbnNpb24oZmlsZW5hbWUpOgog ICAgIHRlc3Qgb24uIiIiCiAgICAgZXh0ZW5zaW9uID0gb3MucGF0aC5zcGxpdGV4dChmaWxlbmFt ZSlbMV0KICAgICByZXR1cm4gZXh0ZW5zaW9uIGluIF9zdXBwb3J0ZWRfZmlsZV9leHRlbnNpb25z CisKKworZGVmIF9pc19za2lwcGVkX2ZpbGUoZmlsZW5hbWUpOgorICAgICIiIlJldHVybiB0cnVl IGlmIGZpbGVuYW1lIHNob3VsZCBiZSBza2lwcGVkLiIiIgorICAgIHJldHVybiBhbnkoZmlsZW5h bWUuZW5kc3dpdGgoc2tpcHBlZF9zdWZmaXgpIGZvciBza2lwcGVkX3N1ZmZpeAorICAgICAgICAg ICAgICAgaW4gX3NraXBwZWRfc3VmZml4ZXMpCisKKworZGVmIF9pc190ZXN0X2ZpbGUoZmlsZW5h bWUpOgorICAgICIiIlJldHVybiB0cnVlIGlmIGZpbGVuYW1lIHJlcHJlc2VudHMgdGVzdCBjYXNl cyB3ZSB3YW50IHRvIHJ1biBhIHRlc3QKKyAgICBvbi4iIiIKKyAgICByZXR1cm4gX2hhc19zdXBw b3J0ZWRfZXh0ZW5zaW9uKGZpbGVuYW1lKSBhbmQgbm90IF9pc19za2lwcGVkX2ZpbGUoZmlsZW5h bWUpCmRpZmYgLS1naXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9wb3J0L3dlYmtpdC5weSBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rl c3RzL3BvcnQvd2Via2l0LnB5CmluZGV4IDUxZjU3YzQwZTY2NjE2N2IxOGNkZjUyZDY0MjAxODc1 OTY1MjQ3ZTguLmUyNmRlZTE0MmUyMDUxZDQ4MTIwMzcwOGJhOTllZjcxOTQ2YzcwYjEgMTAwNjQ0 Ci0tLSBhL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3BvcnQvd2Vi a2l0LnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Bv cnQvd2Via2l0LnB5CkBAIC0xMTUsNyArMTE1LDcgQEAgY2xhc3MgV2ViS2l0UG9ydChiYXNlLlBv cnQpOgogICAgICAgICByZXR1cm4gVHJ1ZQogCiAgICAgZGVmIGRpZmZfaW1hZ2Uoc2VsZiwgZXhw ZWN0ZWRfY29udGVudHMsIGFjdHVhbF9jb250ZW50cywKLSAgICAgICAgICAgICAgICAgICBkaWZm X2ZpbGVuYW1lPU5vbmUpOgorICAgICAgICAgICAgICAgICAgIGRpZmZfZmlsZW5hbWU9Tm9uZSwg dG9sZXJhbmNlPU5vbmUpOgogICAgICAgICAiIiJSZXR1cm4gVHJ1ZSBpZiB0aGUgdHdvIGZpbGVz IGFyZSBkaWZmZXJlbnQuIEFsc28gd3JpdGUgYSBkZWx0YQogICAgICAgICBpbWFnZSBvZiB0aGUg dHdvIGltYWdlcyBpbnRvIHxkaWZmX2ZpbGVuYW1lfCBpZiBpdCBpcyBub3QgTm9uZS4iIiIKIApA QCAtMTIzLDE3ICsxMjMsMjAgQEAgY2xhc3MgV2ViS2l0UG9ydChiYXNlLlBvcnQpOgogICAgICAg ICBpZiBub3QgYWN0dWFsX2NvbnRlbnRzOgogICAgICAgICAgICAgcmV0dXJuIFRydWUKIAotICAg ICAgICBzcCA9IHNlbGYuX2RpZmZfaW1hZ2VfcmVxdWVzdChleHBlY3RlZF9jb250ZW50cywgYWN0 dWFsX2NvbnRlbnRzKQorICAgICAgICBzcCA9IHNlbGYuX2RpZmZfaW1hZ2VfcmVxdWVzdChleHBl Y3RlZF9jb250ZW50cywgYWN0dWFsX2NvbnRlbnRzLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB0b2xlcmFuY2UpCiAgICAgICAgIHJldHVybiBzZWxmLl9kaWZmX2ltYWdl X3JlcGx5KHNwLCBkaWZmX2ZpbGVuYW1lKQogCi0gICAgZGVmIF9kaWZmX2ltYWdlX3JlcXVlc3Qo c2VsZiwgZXhwZWN0ZWRfY29udGVudHMsIGFjdHVhbF9jb250ZW50cyk6CisgICAgZGVmIF9kaWZm X2ltYWdlX3JlcXVlc3Qoc2VsZiwgZXhwZWN0ZWRfY29udGVudHMsIGFjdHVhbF9jb250ZW50cywK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICB0b2xlcmFuY2U9Tm9uZSk6CiAgICAgICAgICMg RklYTUU6IHVzZSBzZWxmLmdldF9vcHRpb24oJ3RvbGVyYW5jZScpIGFuZAogICAgICAgICAjIHNl bGYuc2V0X29wdGlvbl9kZWZhdWx0KCd0b2xlcmFuY2UnLCAwLjEpIG9uY2UgdGhhdCBiZWhhdmVz IGNvcnJlY3RseQogICAgICAgICAjIHdpdGggZGVmYXVsdCB2YWx1ZXMuCi0gICAgICAgIGlmIHNl bGYuZ2V0X29wdGlvbigndG9sZXJhbmNlJykgaXMgbm90IE5vbmU6Ci0gICAgICAgICAgICB0b2xl cmFuY2UgPSBzZWxmLmdldF9vcHRpb24oJ3RvbGVyYW5jZScpCi0gICAgICAgIGVsc2U6Ci0gICAg ICAgICAgICB0b2xlcmFuY2UgPSAwLjEKKyAgICAgICAgaWYgdG9sZXJhbmNlIGlzIE5vbmU6Cisg ICAgICAgICAgICBpZiBzZWxmLmdldF9vcHRpb24oJ3RvbGVyYW5jZScpIGlzIG5vdCBOb25lOgor ICAgICAgICAgICAgICAgIHRvbGVyYW5jZSA9IHNlbGYuZ2V0X29wdGlvbigndG9sZXJhbmNlJykK KyAgICAgICAgICAgIGVsc2U6CisgICAgICAgICAgICAgICAgdG9sZXJhbmNlID0gMC4xCiAgICAg ICAgIGNvbW1hbmQgPSBbc2VsZi5fcGF0aF90b19pbWFnZV9kaWZmKCksICctLXRvbGVyYW5jZScs IHN0cih0b2xlcmFuY2UpXQogICAgICAgICBzcCA9IHNlcnZlcl9wcm9jZXNzLlNlcnZlclByb2Nl c3Moc2VsZiwgJ0ltYWdlRGlmZicsIGNvbW1hbmQpCiAKZGlmZiAtLWdpdCBhL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkgYi9XZWJL aXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5 CmluZGV4IGYzNjBhZGM5YTY1M2M1OGYwYzdmY2MzNzE2NGVkOWMzOGQ5ZWI4NDQuLmRiYTE2ZDdl NzZmOTFmOWNiMDc0ZTY4ZDJlOTc0Y2ZkY2Y1NWVkZGIgMTAwNzU1Ci0tLSBhL1dlYktpdFRvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKKysrIGIv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0 cy5weQpAQCAtNzIsNiArNzIsNyBAQCBmcm9tIGxheW91dF9wYWNrYWdlIGltcG9ydCB0ZXN0X2Zh aWx1cmVzCiBmcm9tIGxheW91dF9wYWNrYWdlIGltcG9ydCB0ZXN0X3Jlc3VsdHMKIGZyb20gbGF5 b3V0X3BhY2thZ2UgaW1wb3J0IHRlc3RfcmVzdWx0c191cGxvYWRlcgogZnJvbSB0ZXN0X3R5cGVz IGltcG9ydCBpbWFnZV9kaWZmCitmcm9tIHRlc3RfdHlwZXMgaW1wb3J0IHJlZmVyZW5jZV9kaWZm CiBmcm9tIHRlc3RfdHlwZXMgaW1wb3J0IHRleHRfZGlmZgogZnJvbSB0ZXN0X3R5cGVzIGltcG9y dCB0ZXN0X3R5cGVfYmFzZQogCkBAIC0xMDUsNiArMTA2LDMxIEBAIGNsYXNzIFRlc3RJbmZvOgog ICAgICAgICBzZWxmLnRpbWVvdXQgPSB0aW1lb3V0CiAgICAgICAgIHNlbGYuX2ltYWdlX2NoZWNr c3VtID0gLTEKIAorICAgICAgICBzZWxmLmlzX3JlZnRlc3QgPSBGYWxzZQorICAgICAgICBzZWxm LmV4cGVjdGVkX2h0bWxfZmlsZW5hbWUgPSBOb25lCisgICAgICAgIHNlbGYuZXhwZWN0ZWRfbWlz bWF0Y2hfaHRtbF9maWxlbmFtZSA9IE5vbmUKKworICAgICAgICAjIEZJWE1FOiBEZXRlY3QgYW5k IHJlcG9ydCBhIHRlc3Qgd2hpY2ggaGFzIGEgd3JvbmcgY29tYmluYXRpb24gb2YKKyAgICAgICAg IyBleHBlY3RhdGlvbiBmaWxlcy4gRm9yIGV4YW1wbGUsIGlmICdmb28uaHRtbCcgaGFzIHR3byBl eHBlY3RhdGlvbiBmaWxlcywKKyAgICAgICAgIyAnZm9vLWV4cGVjdGVkLmh0bWwnIGFuZCAnZm9v LWV4cGVjdGVkLnR4dCcsIHdlIHNob3VsZCB3YXJuIHVzZXJzLgorICAgICAgICAjIE9uZSB0ZXN0 IGZpbGUgbXVzdCBiZSB1c2VkIGV4Y2x1c2l2ZWx5IGluIGVpdGhlciBsYXlvdXQgdGVzdHMgb3IK KyAgICAgICAgIyByZWZ0ZXN0cywgbm90IGluIGJvdGguCisgICAgICAgIGV4cGVjdGVkX2h0bWxf ZmlsZW5hbWUgPSBwb3J0LmV4cGVjdGVkX2h0bWxfZmlsZW5hbWUoZmlsZW5hbWUpCisgICAgICAg IGlmIG9zLnBhdGguaXNmaWxlKGV4cGVjdGVkX2h0bWxfZmlsZW5hbWUpOgorICAgICAgICAgICAg c2VsZi5pc19yZWZ0ZXN0ID0gVHJ1ZQorICAgICAgICAgICAgc2VsZi5leHBlY3RlZF9odG1sX2Zp bGVuYW1lID0gZXhwZWN0ZWRfaHRtbF9maWxlbmFtZQorCisgICAgICAgIGV4cGVjdGVkX21pc21h dGNoX2h0bWxfZmlsZW5hbWUgPSBwb3J0LmV4cGVjdGVkX21pc21hdGNoX2h0bWxfZmlsZW5hbWUo ZmlsZW5hbWUpCisgICAgICAgIGlmIG9zLnBhdGguaXNmaWxlKGV4cGVjdGVkX21pc21hdGNoX2h0 bWxfZmlsZW5hbWUpOgorICAgICAgICAgICAgaWYgc2VsZi5pc19yZWZ0ZXN0OgorICAgICAgICAg ICAgICAgIF9sb2cuZXJyb3IoJ0l0IGlzIG5vdCBhbGxvd2VkIHRoYXQgb25lIHJlZnRlc3QgZmls ZSBoYXMgYm90aCcKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICcgZXhwZWN0ZWQtaHRtbCBm aWxlIGFuZCBleHBlY3RlZC1taXNtYXRjaC5odG1sIGZpbGUnCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAnIGF0IHRoZSBzYW1lIHRpbWUuIFBsZWFzZSByZW1vdmUgZWl0aGVyICVzIG9yICVz LicsCisgICAgICAgICAgICAgICAgICAgICAgICAgICBleHBlY3RlZF9odG1sX2ZpbGVuYW1lLCBl eHBlY3RlZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1lKQorICAgICAgICAgICAgZWxzZToKKyAgICAg ICAgICAgICAgICBzZWxmLmlzX3JlZnRlc3QgPSBUcnVlCisgICAgICAgICAgICAgICAgc2VsZi5l eHBlY3RlZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1lID0gZXhwZWN0ZWRfbWlzbWF0Y2hfaHRtbF9m aWxlbmFtZQorCiAgICAgZGVmIGltYWdlX2hhc2goc2VsZik6CiAgICAgICAgICMgUmVhZCB0aGUg aW1hZ2VfaGFzaCBsYXppbHkgdG8gcmVkdWNlIHN0YXJ0dXAgdGltZS4KICAgICAgICAgIyBUaGlz IGNsYXNzIGlzIGFjY2Vzc2VkIGFjcm9zcyB0aHJlYWRzLCBidXQgb25seSBvbmUgdGhyZWFkIHNo b3VsZApAQCAtMjcxLDYgKzI5NywxMCBAQCBjbGFzcyBUZXN0UnVubmVyOgogICAgICAgICBpZiBv cHRpb25zLnBpeGVsX3Rlc3RzOgogICAgICAgICAgICAgc2VsZi5fdGVzdF90eXBlcy5hcHBlbmQo aW1hZ2VfZGlmZi5JbWFnZURpZmYpCiAKKyAgICAgICAgc2VsZi5fcmVmdGVzdF90eXBlcyA9IFtd CisgICAgICAgIGlmIG9wdGlvbnMucnVuX3JlZnRlc3RzOgorICAgICAgICAgICAgc2VsZi5fcmVm dGVzdF90eXBlcy5hcHBlbmQocmVmZXJlbmNlX2RpZmYuUmVmZXJlbmNlRGlmZikKKwogICAgICAg ICAjIGEgc2V0IG9mIHRlc3QgZmlsZXMsIGFuZCB0aGUgc2FtZSB0ZXN0cyBhcyBhIGxpc3QKICAg ICAgICAgc2VsZi5fdGVzdF9maWxlcyA9IHNldCgpCiAgICAgICAgIHNlbGYuX3Rlc3RfZmlsZXNf bGlzdCA9IE5vbmUKQEAgLTUzMSw2ICs1NjEsOCBAQCBjbGFzcyBUZXN0UnVubmVyOgogICAgICAg ICAgICAgc2VsZi5faXNfc2luZ2xlX3RocmVhZGVkKCkpOgogICAgICAgICAgICAgZm9yIHRlc3Rf ZmlsZSBpbiB0ZXN0X2ZpbGVzOgogICAgICAgICAgICAgICAgIHRlc3RfaW5mbyA9IHNlbGYuX2dl dF90ZXN0X2luZm9fZm9yX2ZpbGUodGVzdF9maWxlKQorICAgICAgICAgICAgICAgIGlmIG5vdCBz ZWxmLl9vcHRpb25zLnJ1bl9yZWZ0ZXN0cyBhbmQgdGVzdF9pbmZvLmlzX3JlZnRlc3Q6CisgICAg ICAgICAgICAgICAgICAgIGNvbnRpbnVlCiAgICAgICAgICAgICAgICAgaWYgc2VsZi5fdGVzdF9y ZXF1aXJlc19sb2NrKHRlc3RfZmlsZSk6CiAgICAgICAgICAgICAgICAgICAgIHRlc3RzX3RvX2h0 dHBfbG9jay5hcHBlbmQodGVzdF9pbmZvKQogICAgICAgICAgICAgICAgIGVsc2U6CkBAIC01NDAs NiArNTcyLDkgQEAgY2xhc3MgVGVzdFJ1bm5lcjoKICAgICAgICAgICAgIGZvciB0ZXN0X2ZpbGUg aW4gdGVzdF9maWxlczoKICAgICAgICAgICAgICAgICBkaXJlY3RvcnkgPSBzZWxmLl9nZXRfZGly X2Zvcl90ZXN0X2ZpbGUodGVzdF9maWxlKQogICAgICAgICAgICAgICAgIHRlc3RfaW5mbyA9IHNl bGYuX2dldF90ZXN0X2luZm9fZm9yX2ZpbGUodGVzdF9maWxlKQorCisgICAgICAgICAgICAgICAg aWYgbm90IHNlbGYuX29wdGlvbnMucnVuX3JlZnRlc3RzIGFuZCB0ZXN0X2luZm8uaXNfcmVmdGVz dDoKKyAgICAgICAgICAgICAgICAgICAgY29udGludWUKICAgICAgICAgICAgICAgICBpZiBzZWxm Ll90ZXN0X3JlcXVpcmVzX2xvY2sodGVzdF9maWxlKToKICAgICAgICAgICAgICAgICAgICAgdGVz dHNfdG9faHR0cF9sb2NrLmFwcGVuZCh0ZXN0X2luZm8pCiAgICAgICAgICAgICAgICAgZWxzZToK QEAgLTU3Niw3ICs2MTEsNyBAQCBjbGFzcyBUZXN0UnVubmVyOgogICAgICAgICAiIiJSZXR1cm5z IHRoZSB0dXBsZSBvZiBhcmd1bWVudHMgZm9yIHRlc3RzIGFuZCBmb3IgRHVtcFJlbmRlclRyZWUu IiIiCiAgICAgICAgIHRlc3RfYXJncyA9IHRlc3RfdHlwZV9iYXNlLlRlc3RBcmd1bWVudHMoKQog ICAgICAgICB0ZXN0X2FyZ3MucG5nX3BhdGggPSBOb25lCi0gICAgICAgIGlmIHNlbGYuX29wdGlv bnMucGl4ZWxfdGVzdHM6CisgICAgICAgIGlmIHNlbGYuX29wdGlvbnMucGl4ZWxfdGVzdHMgb3Ig c2VsZi5fb3B0aW9ucy5ydW5fcmVmdGVzdHM6CiAgICAgICAgICAgICBwbmdfcGF0aCA9IG9zLnBh dGguam9pbihzZWxmLl9vcHRpb25zLnJlc3VsdHNfZGlyZWN0b3J5LAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgInBuZ19yZXN1bHQlcy5wbmciICUgaW5kZXgpCiAgICAgICAg ICAgICB0ZXN0X2FyZ3MucG5nX3BhdGggPSBwbmdfcGF0aApAQCAtNjA0LDE1ICs2MzksMTUgQEAg Y2xhc3MgVGVzdFJ1bm5lcjoKICAgICAgICAgdGhyZWFkcyA9IFtdCiAgICAgICAgIGZvciBpIGlu IHhyYW5nZShpbnQoc2VsZi5fb3B0aW9ucy5jaGlsZF9wcm9jZXNzZXMpKToKICAgICAgICAgICAg ICMgQ3JlYXRlIHNlcGFyYXRlIFRlc3RUeXBlcyBpbnN0YW5jZXMgZm9yIGVhY2ggdGhyZWFkLgot ICAgICAgICAgICAgdGVzdF90eXBlcyA9IFtdCi0gICAgICAgICAgICBmb3IgdGVzdF90eXBlIGlu IHNlbGYuX3Rlc3RfdHlwZXM6Ci0gICAgICAgICAgICAgICAgdGVzdF90eXBlcy5hcHBlbmQodGVz dF90eXBlKHNlbGYuX3BvcnQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBz ZWxmLl9vcHRpb25zLnJlc3VsdHNfZGlyZWN0b3J5KSkKKyAgICAgICAgICAgIHRlc3RfdHlwZXMg PSBbdGVzdF90eXBlKHNlbGYuX3BvcnQsIHNlbGYuX29wdGlvbnMucmVzdWx0c19kaXJlY3Rvcnkp CisgICAgICAgICAgICAgICAgICAgICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gc2VsZi5fdGVzdF90 eXBlc10KKyAgICAgICAgICAgIHJlZnRlc3RfdHlwZXMgPSBbdGVzdF90eXBlKHNlbGYuX3BvcnQs IHNlbGYuX29wdGlvbnMucmVzdWx0c19kaXJlY3RvcnkpCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gc2VsZi5fcmVmdGVzdF90eXBlc10KIAogICAgICAgICAg ICAgdGVzdF9hcmdzID0gc2VsZi5fZ2V0X3Rlc3RfYXJncyhpKQogICAgICAgICAgICAgdGhyZWFk ID0gZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQuVGVzdFNoZWxsVGhyZWFkKHNlbGYuX3BvcnQsCiAg ICAgICAgICAgICAgICAgc2VsZi5fb3B0aW9ucywgZmlsZW5hbWVfcXVldWUsIHNlbGYuX3Jlc3Vs dF9xdWV1ZSwKLSAgICAgICAgICAgICAgICB0ZXN0X3R5cGVzLCB0ZXN0X2FyZ3MpCisgICAgICAg ICAgICAgICAgdGVzdF90eXBlcywgcmVmdGVzdF90eXBlcywgdGVzdF9hcmdzKQogICAgICAgICAg ICAgaWYgc2VsZi5faXNfc2luZ2xlX3RocmVhZGVkKCk6CiAgICAgICAgICAgICAgICAgdGhyZWFk LnJ1bl9pbl9tYWluX3RocmVhZChzZWxmLCByZXN1bHRfc3VtbWFyeSkKICAgICAgICAgICAgIGVs c2U6CkBAIC0xMDYwLDIzICsxMDk1LDE3IEBAIGNsYXNzIFRlc3RSdW5uZXI6CiAgICAgICAgICAg aW5kaXZpZHVhbF90ZXN0X3RpbWluZ3M6IExpc3Qgb2YgZHVtcF9yZW5kZXJfdHJlZV90aHJlYWQu VGVzdFN0YXRzCiAgICAgICAgICAgICAgIGZvciBhbGwgdGVzdHMuCiAgICAgICAgICIiIgotICAg ICAgICB0ZXN0X3R5cGVzID0gW10gICMgVW5pdCB0ZXN0cyBkb24ndCBhY3R1YWxseSBwcm9kdWNl IGFueSB0aW1pbmdzLgotICAgICAgICBpZiBpbmRpdmlkdWFsX3Rlc3RfdGltaW5nczoKLSAgICAg ICAgICAgIHRlc3RfdHlwZXMgPSBpbmRpdmlkdWFsX3Rlc3RfdGltaW5nc1swXS50aW1lX2Zvcl9k aWZmcy5rZXlzKCkKICAgICAgICAgdGltZXNfZm9yX2R1bXBfcmVuZGVyX3RyZWUgPSBbXQogICAg ICAgICB0aW1lc19mb3JfZGlmZl9wcm9jZXNzaW5nID0gW10KICAgICAgICAgdGltZXNfcGVyX3Rl c3RfdHlwZSA9IHt9Ci0gICAgICAgIGZvciB0ZXN0X3R5cGUgaW4gdGVzdF90eXBlczoKLSAgICAg ICAgICAgIHRpbWVzX3Blcl90ZXN0X3R5cGVbdGVzdF90eXBlXSA9IFtdCiAKICAgICAgICAgZm9y IHRlc3Rfc3RhdHMgaW4gaW5kaXZpZHVhbF90ZXN0X3RpbWluZ3M6CiAgICAgICAgICAgICB0aW1l c19mb3JfZHVtcF9yZW5kZXJfdHJlZS5hcHBlbmQodGVzdF9zdGF0cy50ZXN0X3J1bl90aW1lKQog ICAgICAgICAgICAgdGltZXNfZm9yX2RpZmZfcHJvY2Vzc2luZy5hcHBlbmQoCiAgICAgICAgICAg ICAgICAgdGVzdF9zdGF0cy50b3RhbF90aW1lX2Zvcl9hbGxfZGlmZnMpCiAgICAgICAgICAgICB0 aW1lX2Zvcl9kaWZmcyA9IHRlc3Rfc3RhdHMudGltZV9mb3JfZGlmZnMKLSAgICAgICAgICAgIGZv ciB0ZXN0X3R5cGUgaW4gdGVzdF90eXBlczoKLSAgICAgICAgICAgICAgICB0aW1lc19wZXJfdGVz dF90eXBlW3Rlc3RfdHlwZV0uYXBwZW5kKAotICAgICAgICAgICAgICAgICAgICB0aW1lX2Zvcl9k aWZmc1t0ZXN0X3R5cGVdKQorICAgICAgICAgICAgZm9yIHRlc3RfdHlwZSwgdGltZSBpbiB0aW1l X2Zvcl9kaWZmcy5pdGVyaXRlbXMoKToKKyAgICAgICAgICAgICAgICB0aW1lc19wZXJfdGVzdF90 eXBlLmdldCh0ZXN0X3R5cGUsIFtdKS5hcHBlbmQodGltZSkKIAogICAgICAgICBzZWxmLl9wcmlu dF9zdGF0aXN0aWNzX2Zvcl90ZXN0X3RpbWluZ3MoCiAgICAgICAgICAgICAiUEVSIFRFU1QgVElN RSBJTiBURVNUU0hFTEwgKHNlY29uZHMpOiIsCkBAIC0xMDg0LDEwICsxMTEzLDkgQEAgY2xhc3Mg VGVzdFJ1bm5lcjoKICAgICAgICAgc2VsZi5fcHJpbnRfc3RhdGlzdGljc19mb3JfdGVzdF90aW1p bmdzKAogICAgICAgICAgICAgIlBFUiBURVNUIERJRkYgUFJPQ0VTU0lORyBUSU1FUyAoc2Vjb25k cyk6IiwKICAgICAgICAgICAgIHRpbWVzX2Zvcl9kaWZmX3Byb2Nlc3NpbmcpCi0gICAgICAgIGZv ciB0ZXN0X3R5cGUgaW4gdGVzdF90eXBlczoKKyAgICAgICAgZm9yIHRlc3RfdHlwZSwgdGltZSBp biB0aW1lc19wZXJfdGVzdF90eXBlLml0ZXJpdGVtcygpOgogICAgICAgICAgICAgc2VsZi5fcHJp bnRfc3RhdGlzdGljc19mb3JfdGVzdF90aW1pbmdzKAotICAgICAgICAgICAgICAgICJQRVIgVEVT VCBUSU1FUyBCWSBURVNUIFRZUEU6ICVzIiAlIHRlc3RfdHlwZSwKLSAgICAgICAgICAgICAgICB0 aW1lc19wZXJfdGVzdF90eXBlW3Rlc3RfdHlwZV0pCisgICAgICAgICAgICAgICAgIlBFUiBURVNU IFRJTUVTIEJZIFRFU1QgVFlQRTogJXMiICUgdGVzdF90eXBlLCB0aW1lKQogCiAgICAgZGVmIF9w cmludF9pbmRpdmlkdWFsX3Rlc3RfdGltZXMoc2VsZiwgaW5kaXZpZHVhbF90ZXN0X3RpbWluZ3Ms CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVzdWx0X3N1bW1hcnkpOgpAQCAt MTY2OSw2ICsxNjk3LDkgQEAgZGVmIHBhcnNlX2FyZ3MoYXJncz1Ob25lKToKICAgICAgICAgb3B0 cGFyc2UubWFrZV9vcHRpb24oIi0tbm8tcmV0cnktZmFpbHVyZXMiLCBhY3Rpb249InN0b3JlX2Zh bHNlIiwKICAgICAgICAgICAgIGRlc3Q9InJldHJ5X2ZhaWx1cmVzIiwKICAgICAgICAgICAgIGhl bHA9IkRvbid0IHJlLXRyeSBhbnkgdGVzdHMgdGhhdCBwcm9kdWNlIHVuZXhwZWN0ZWQgcmVzdWx0 cy4iKSwKKyAgICAgICAgb3B0cGFyc2UubWFrZV9vcHRpb24oIi0tcnVuLXJlZnRlc3RzIiwgYWN0 aW9uPSJzdG9yZV90cnVlIiwKKyAgICAgICAgICAgIGhlbHA9KCJSdW4gYWxzbyByZWZ0ZXN0cyAo ZXhwZXJpbWVudGFsKS4gRG9uJ3QgY29tbWl0IGFueSByZWZ0ZXN0cyAiCisgICAgICAgICAgICAg ICAgICAidG8gYSByZXBvc2l0cnkgdW50aWwgcmVmdGVzdHMgaXMgZnVsbHkgc3VwcG9ydGVkLiIp KSwKICAgICBdCiAKICAgICBtaXNjX29wdGlvbnMgPSBbCmRpZmYgLS1naXQgYS9XZWJLaXRUb29s cy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL2ltYWdlX2RpZmYucHkg Yi9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL2lt YWdlX2RpZmYucHkKaW5kZXggMGIwNTgwMjBjMDhmNGY1MWMxMTYyMDRkYzU0Y2JmNWQ5YzNlN2M2 Zi4uZTg4YTY4NDc5NDdjYjlhM2I3MGRkMTRhNzlkOTlkYzhlNzhkMzdhZSAxMDA2NDQKLS0tIGEv V2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90eXBlcy9pbWFn ZV9kaWZmLnB5CisrKyBiL1dlYktpdFRvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3Rlc3RfdHlwZXMvaW1hZ2VfZGlmZi5weQpAQCAtNTQsMjEgKzU0LDYgQEAgX2xvZyA9IGxvZ2dp bmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMudGVzdF90eXBlcy5pbWFnZV9kaWZm IikKIAogY2xhc3MgSW1hZ2VEaWZmKHRlc3RfdHlwZV9iYXNlLlRlc3RUeXBlQmFzZSk6CiAKLSAg ICBkZWYgX2NvcHlfb3V0cHV0X3BuZyhzZWxmLCB0ZXN0X2ZpbGVuYW1lLCBzb3VyY2VfaW1hZ2Us IGV4dGVuc2lvbik6Ci0gICAgICAgICIiIkNvcGllcyByZXN1bHQgZmlsZXMgaW50byB0aGUgb3V0 cHV0IGRpcmVjdG9yeSB3aXRoIGFwcHJvcHJpYXRlCi0gICAgICAgIG5hbWVzLgotCi0gICAgICAg IEFyZ3M6Ci0gICAgICAgICAgdGVzdF9maWxlbmFtZTogdGhlIHRlc3QgZmlsZW5hbWUKLSAgICAg ICAgICBzb3VyY2VfZmlsZTogcGF0aCB0byB0aGUgaW1hZ2UgZmlsZSAoZWl0aGVyIGFjdHVhbCBv ciBleHBlY3RlZCkKLSAgICAgICAgICBleHRlbnNpb246IGV4dGVuc2lvbiB0byBpbmRpY2F0ZSAt YWN0dWFsLnBuZyBvciAtZXhwZWN0ZWQucG5nCi0gICAgICAgICIiIgotICAgICAgICBzZWxmLl9t YWtlX291dHB1dF9kaXJlY3RvcnkodGVzdF9maWxlbmFtZSkKLSAgICAgICAgZGVzdF9pbWFnZSA9 IHNlbGYub3V0cHV0X2ZpbGVuYW1lKHRlc3RfZmlsZW5hbWUsIGV4dGVuc2lvbikKLQotICAgICAg ICBpZiBvcy5wYXRoLmV4aXN0cyhzb3VyY2VfaW1hZ2UpOgotICAgICAgICAgICAgc2h1dGlsLmNv cHlmaWxlKHNvdXJjZV9pbWFnZSwgZGVzdF9pbWFnZSkKLQogICAgIGRlZiBfc2F2ZV9iYXNlbGlu ZV9maWxlcyhzZWxmLCBmaWxlbmFtZSwgcG5nX3BhdGgsIGNoZWNrc3VtLAogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBnZW5lcmF0ZV9uZXdfYmFzZWxpbmUpOgogICAgICAgICAiIiJTYXZl cyBuZXcgYmFzZWxpbmVzIGZvciB0aGUgUE5HIGFuZCBjaGVja3N1bS4KQEAgLTEzNyw3ICsxMjIs OCBAQCBjbGFzcyBJbWFnZURpZmYodGVzdF90eXBlX2Jhc2UuVGVzdFR5cGVCYXNlKToKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRlc3RfYXJncy5oYXNoLCBleHBlY3RlZF9o YXNoLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZW5jb2Rpbmc9ImFzY2lp IiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHByaW50X3RleHRfZGlmZnM9 RmFsc2UpCi0gICAgICAgICAgICBzZWxmLl9jb3B5X291dHB1dF9wbmcoZmlsZW5hbWUsIHRlc3Rf YXJncy5wbmdfcGF0aCwgJy1hY3R1YWwucG5nJykKKyAgICAgICAgICAgIHNlbGYuX2NvcHlfb3V0 cHV0X3RvX3Jlc3VsdF9kaXJlY3RvcnkoZmlsZW5hbWUsIHRlc3RfYXJncy5wbmdfcGF0aCwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJy1hY3R1YWwu cG5nJykKICAgICAgICAgICAgIGZhaWx1cmVzLmFwcGVuZCh0ZXN0X2ZhaWx1cmVzLkZhaWx1cmVN aXNzaW5nSW1hZ2UoKSkKICAgICAgICAgICAgIHJldHVybiBmYWlsdXJlcwogICAgICAgICBlbGlm IHRlc3RfYXJncy5oYXNoID09IGV4cGVjdGVkX2hhc2g6CkBAIC0xNTAsNyArMTM2LDggQEAgY2xh c3MgSW1hZ2VEaWZmKHRlc3RfdHlwZV9iYXNlLlRlc3RUeXBlQmFzZSk6CiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHByaW50X3RleHRfZGlmZnM9RmFsc2UpCiAKICAgICAgICAgIyBG SVhNRTogY29tYmluZSBuZXh0IHR3byBsaW5lcwotICAgICAgICBzZWxmLl9jb3B5X291dHB1dF9w bmcoZmlsZW5hbWUsIHRlc3RfYXJncy5wbmdfcGF0aCwgJy1hY3R1YWwucG5nJykKKyAgICAgICAg c2VsZi5fY29weV9vdXRwdXRfdG9fcmVzdWx0X2RpcmVjdG9yeShmaWxlbmFtZSwgdGVzdF9hcmdz LnBuZ19wYXRoLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICctYWN0dWFsLnBuZycpCiAgICAgICAgIHNlbGYud3JpdGVfb3V0cHV0X2ZpbGVzKGZpbGVuYW1l LCAnLnBuZycsIG91dHB1dD1Ob25lLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBl eHBlY3RlZD1leHBlY3RlZF9wbmcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVu Y29kaW5nPU5vbmUsIHByaW50X3RleHRfZGlmZnM9RmFsc2UpCmRpZmYgLS1naXQgYS9XZWJLaXRU b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVzL3JlZmVyZW5jZV9k aWZmLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90 eXBlcy9yZWZlcmVuY2VfZGlmZi5weQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5kYTQxNjBkODdhNjIxMzE3Yzk0NDVk ZmUxYzRiNWIzZTEyM2QwZmE0Ci0tLSAvZGV2L251bGwKKysrIGIvV2ViS2l0VG9vbHMvU2NyaXB0 cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvdGVzdF90eXBlcy9yZWZlcmVuY2VfZGlmZi5weQpAQCAt MCwwICsxLDg1IEBACisjIS91c3IvYmluL2VudiBweXRob24KKyMgQ29weXJpZ2h0IChDKSAyMDEw IEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisjCisjIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorIyBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMgYXJlCisjIG1ldDoKKyMKKyMgICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBj b2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyMgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorIyAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisjIGNv cHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIKKyMgaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZQorIyBkaXN0cmlidXRpb24uCisjICAgICAqIE5laXRoZXIgdGhl IG5hbWUgb2YgR29vZ2xlIEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyMgY29udHJpYnV0b3Jz IG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20K KyMgdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lv bi4KKyMKKyMgVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERF UlMgQU5EIENPTlRSSUJVVE9SUworIyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVE IFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorIyBMSU1JVEVEIFRPLCBUSEUgSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyMgQSBQQVJU SUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZ UklHSFQKKyMgT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsCisjIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVO VElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyMgTElNSVRFRCBUTywgUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisjIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWQorIyBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUCisjIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJ U0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorIyBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorCisi IiJDb21wYXJlcyB0aGUgaW1hZ2Ugb3V0cHV0IG9mIGEgdGVzdCB0byB0aGUgaW1hZ2Ugb3V0cHV0 IG9mIGEgcmVmZXJlbmNlIGZpbGUuCisiIiIKKworZnJvbSBfX2Z1dHVyZV9fIGltcG9ydCB3aXRo X3N0YXRlbWVudAorCitpbXBvcnQgbG9nZ2luZworCitmcm9tIHdlYmtpdHB5LmxheW91dF90ZXN0 cy5sYXlvdXRfcGFja2FnZSBpbXBvcnQgdGVzdF9mYWlsdXJlcworZnJvbSB3ZWJraXRweS5sYXlv dXRfdGVzdHMudGVzdF90eXBlcyBpbXBvcnQgdGVzdF90eXBlX2Jhc2UKKworX2xvZyA9IGxvZ2dp bmcuZ2V0TG9nZ2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMudGVzdF90eXBlcy5yZWZlcmVuY2Vf ZGlmZiIpCisKKworY2xhc3MgUmVmZXJlbmNlRGlmZih0ZXN0X3R5cGVfYmFzZS5UZXN0VHlwZUJh c2UpOgorCisgICAgZGVmIGNvbXBhcmVfb3V0cHV0X3dpdGhfcmVmZXJlbmNlKHNlbGYsIHBvcnQs IHRlc3RfaW5mbywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYWN0dWFs X2ltYWdlX2hhc2gsIGFjdHVhbF9pbWFnZV9jb250ZW50cywKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmVmZXJlbmNlX2ltYWdlX2hhc2gsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHJlZmVyZW5jZV9pbWFnZV9jb250ZW50cyk6CisgICAgICAg IGZhaWx1cmVzID0gW10KKyAgICAgICAgaWYgdGVzdF9pbmZvLmV4cGVjdGVkX2h0bWxfZmlsZW5h bWU6CisgICAgICAgICAgICBpZiBhY3R1YWxfaW1hZ2VfaGFzaCA9PSByZWZlcmVuY2VfaW1hZ2Vf aGFzaDoKKyAgICAgICAgICAgICAgICByZXR1cm4gZmFpbHVyZXMKKyAgICAgICAgICAgIGZhaWx1 cmVzLmFwcGVuZCh0ZXN0X2ZhaWx1cmVzLkZhaWx1cmVSZWZlcmVuY2VNaXNtYXRjaCgpKQorCisg ICAgICAgICAgICBkaWZmX2ZpbGVuYW1lID0gc2VsZi5vdXRwdXRfZmlsZW5hbWUodGVzdF9pbmZv LmZpbGVuYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHNlbGYuRklMRU5BTUVfU1VGRklYX0NPTVBBUkUpCisgICAgICAgICAgICAjIFNldCB0b2xl cmFuY2UgdG8gJ3plcm8nIHRvIGRldGVjdCBhbnkgZGlmZmVyZW5jZXMuCisgICAgICAgICAgICBw b3J0LmRpZmZfaW1hZ2UocmVmZXJlbmNlX2ltYWdlX2NvbnRlbnRzLCBhY3R1YWxfaW1hZ2VfY29u dGVudHMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgZGlmZl9maWxlbmFtZSwgdG9sZXJh bmNlPTApCisKKyAgICAgICAgICAgIHJlZmVyZW5jZV9maWxlbmFtZSA9IHRlc3RfaW5mby5leHBl Y3RlZF9odG1sX2ZpbGVuYW1lCisgICAgICAgICAgICBzdWZmaXhfb2Zfb3V0cHV0X2ZpbGUgPSAn LWV4cGVjdGVkLmh0bWwnCisgICAgICAgICAgICByZWZlcmVuY2VfaW1hZ2VfdG9fYmVfY29waWVk ID0gcmVmZXJlbmNlX2ltYWdlX2NvbnRlbnRzCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBh c3NlcnQgdGVzdF9pbmZvLmV4cGVjdGVkX21pc21hdGNoX2h0bWxfZmlsZW5hbWUKKyAgICAgICAg ICAgIGlmIGFjdHVhbF9pbWFnZV9oYXNoICE9IHJlZmVyZW5jZV9pbWFnZV9oYXNoOgorICAgICAg ICAgICAgICAgIHJldHVybiBmYWlsdXJlcworICAgICAgICAgICAgZmFpbHVyZXMuYXBwZW5kKHRl c3RfZmFpbHVyZXMuRmFpbHVyZVJlZmVyZW5jZU1hdGNoKCkpCisKKyAgICAgICAgICAgIHJlZmVy ZW5jZV9maWxlbmFtZSA9IHRlc3RfaW5mby5leHBlY3RlZF9taXNtYXRjaF9odG1sX2ZpbGVuYW1l CisgICAgICAgICAgICBzdWZmaXhfb2Zfb3V0cHV0X2ZpbGUgPSAnLWV4cGVjdGVkLW1pc21hdGNo Lmh0bWwnCisgICAgICAgICAgICByZWZlcmVuY2VfaW1hZ2VfdG9fYmVfY29waWVkID0gTm9uZQor CisgICAgICAgICMgQ29weSBmaWxlcyBmb3IgbGF0ZXIgcmVwb3J0aW5nLgorICAgICAgICBzZWxm Ll9jb3B5X291dHB1dF90b19yZXN1bHRfZGlyZWN0b3J5KHRlc3RfaW5mby5maWxlbmFtZSwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWZlcmVuY2VfZmls ZW5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3Vm Zml4X29mX291dHB1dF9maWxlKQorICAgICAgICBzZWxmLndyaXRlX291dHB1dF9maWxlcyh0ZXN0 X2luZm8uZmlsZW5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZpbGVfdHlw ZT0nLnBuZycsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG91dHB1dD1hY3R1YWxf aW1hZ2VfY29udGVudHMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGV4cGVjdGVk PXJlZmVyZW5jZV9pbWFnZV90b19iZV9jb3BpZWQsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGVuY29kaW5nPU5vbmUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBy aW50X3RleHRfZGlmZnM9RmFsc2UpCisKKyAgICAgICAgcmV0dXJuIGZhaWx1cmVzCmRpZmYgLS1n aXQgYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy90ZXN0X3R5cGVz L3Rlc3RfdHlwZV9iYXNlLnB5IGIvV2ViS2l0VG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvdGVzdF90eXBlcy90ZXN0X3R5cGVfYmFzZS5weQppbmRleCBkY2M2NGEzNWIzMzlkZjk4 ODBhYWMwNTM4ZjdlODU1OTcyNTgwYjEzLi40NDU1ZDkyZTExNjg1MTE1NWM0N2JjZTU0ODJhZjA4 ZWU0NGFjY2Y1IDEwMDY0NAotLS0gYS9XZWJLaXRUb29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy90ZXN0X3R5cGVzL3Rlc3RfdHlwZV9iYXNlLnB5CisrKyBiL1dlYktpdFRvb2xzL1Nj cmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3Rlc3RfdHlwZXMvdGVzdF90eXBlX2Jhc2UucHkK QEAgLTM5LDYgKzM5LDcgQEAgaW1wb3J0IGNnaQogaW1wb3J0IGVycm5vCiBpbXBvcnQgbG9nZ2lu ZwogaW1wb3J0IG9zLnBhdGgKK2ltcG9ydCBzaHV0aWwKIAogX2xvZyA9IGxvZ2dpbmcuZ2V0TG9n Z2VyKCJ3ZWJraXRweS5sYXlvdXRfdGVzdHMudGVzdF90eXBlcy50ZXN0X3R5cGVfYmFzZSIpCiAK QEAgLTkwLDYgKzkxLDI2IEBAIGNsYXNzIFRlc3RUeXBlQmFzZShvYmplY3QpOgogICAgICAgICAg ICAgc2VsZi5fcG9ydC5yZWxhdGl2ZV90ZXN0X2ZpbGVuYW1lKGZpbGVuYW1lKSkKICAgICAgICAg c2VsZi5fcG9ydC5tYXliZV9tYWtlX2RpcmVjdG9yeShvcy5wYXRoLnNwbGl0KG91dHB1dF9maWxl bmFtZSlbMF0pCiAKKyAgICBkZWYgX2NvcHlfb3V0cHV0X3RvX3Jlc3VsdF9kaXJlY3Rvcnkoc2Vs ZiwgdGVzdF9maWxlbmFtZSwgc291cmNlX2ZpbGVuYW1lLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBkZXN0aW5hdGlvbl9leHRlbnNpb24pOgorICAgICAgICAiIiJD b3BpZXMgYSB0ZXN0IGZpbGUgaW50byB0aGUgb3V0cHV0IGRpcmVjdG9yeS4KKworICAgICAgICBG b3IgZXhhbXBsZSwgaWYgdGVzdF9maWxlbmFtZSBpcyAuLi4vZmFzdC9kb20vZm9vLmh0bWwgYW5k IGRlc3RpbmF0aW9uX2V4dGVuc2lvbiBpcworICAgICAgICAiLWV4cGVjdGVkLnR4dCIsIGEgc291 cmNlIGZpbGUgaXMgY29waWVkIHRvCisgICAgICAgIC4uLi9sYXlvdXQtdGVzdC1yZXN1bHRzL2Zh c3QvZG9tL2Zvby1leHBlY3RlZC50eHQuCisKKyAgICAgICAgQXJnczoKKyAgICAgICAgICB0ZXN0 X2ZpbGVuYW1lOiB0aGUgdGVzdCBmaWxlbmFtZQorICAgICAgICAgIHNvdXJjZV9maWxlbmFtZTog cGF0aCB0byB0aGUgc291cmNlIGZpbGUgKGVpdGhlciBhY3R1YWwgb3IgZXhwZWN0ZWQpCisgICAg ICAgICAgZGVzdGludGlvbl9leHRlbnNpb246IGV4dGVuc2lvbiB1c2VkIGluIGRlc3RpbmF0aW9u J3MgZmlsZW5hbWUuCisgICAgICAgICIiIgorICAgICAgICBzZWxmLl9tYWtlX291dHB1dF9kaXJl Y3RvcnkodGVzdF9maWxlbmFtZSkKKyAgICAgICAgZGVzdF9maWxlbmFtZSA9IHNlbGYub3V0cHV0 X2ZpbGVuYW1lKHRlc3RfZmlsZW5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBkZXN0aW5hdGlvbl9leHRlbnNpb24pCisKKyAgICAgICAgaWYgb3MucGF0 aC5leGlzdHMoc291cmNlX2ZpbGVuYW1lKToKKyAgICAgICAgICAgIHNodXRpbC5jb3B5ZmlsZShz b3VyY2VfZmlsZW5hbWUsIGRlc3RfZmlsZW5hbWUpCisKICAgICBkZWYgX3NhdmVfYmFzZWxpbmVf ZGF0YShzZWxmLCBmaWxlbmFtZSwgZGF0YSwgbW9kaWZpZXIsIGVuY29kaW5nLAogICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGdlbmVyYXRlX25ld19iYXNlbGluZT1UcnVlKToKICAgICAgICAg IiIiU2F2ZXMgYSBuZXcgYmFzZWxpbmUgZmlsZSBpbnRvIHRoZSBwb3J0J3MgYmFzZWxpbmUgZGly ZWN0b3J5Lgo=