64591 2011-07-15 03:55:46 -0700 Use requestAnimationFrame callbacks to pump CSS animations 2017-02-01 12:57:43 -0800 1 1 1 Unclassified WebKit CSS 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 67171 1 alex cmarrin abarth cmarrin dglazkov dino efidler jamesr jchaffraix jgw mihnea nduca ojan peter sabouhallawa simon.fraser tonikitoo vangelis webkit-bug-importer webkit.review.bot oldest_to_newest 437651 0 alex 2011-07-15 03:55:46 -0700 Ports which currently use the default AnimationController have their CSS animations pumped by a timer that runs every 25ms, meaning they top out at ~40fps. Going faster is problematic as we recalc style on every frame (potentially). ENABLE(REQUEST_ANIMATION_FRAME) provides an out. Initial patch forthcoming. 437809 1 100998 alex 2011-07-15 09:55:16 -0700 Created attachment 100998 Patch 437820 2 100998 simon.fraser 2011-07-15 10:20:12 -0700 Comment on attachment 100998 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100998&action=review > Source/WebCore/page/animation/AnimationController.h:69 > + void pumpAnimations(); I don't really like "pump". serviceAnimations()? > Source/WebCore/page/animation/AnimationControllerPrivate.h:75 > + void callbackFired(); This needs a more specific name than "callback". 437831 3 jamesr 2011-07-15 11:03:25 -0700 State transition events (animationstart, animationend, animationiteration) still need to fire for non-visible tabs, even though requestAnimationFrame callbacks aren't invoked. 437928 4 100998 dino 2011-07-15 13:00:10 -0700 Comment on attachment 100998 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100998&action=review >> Source/WebCore/page/animation/AnimationControllerPrivate.h:75 >> + void callbackFired(); > > This needs a more specific name than "callback". scheduleAnimationsIfNecessary()? or something like that. 438137 5 100998 webkit.review.bot 2011-07-16 04:42:36 -0700 Comment on attachment 100998 Patch Attachment 100998 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/9093717 New failing tests: animations/animation-drt-api.html animations/animation-end-event-short-iterations.html fast/selectors/unqualified-hover-strict.html animations/play-state.html animations/change-keyframes-name.html animations/transition-and-animation-3.html animations/animation-hit-test.html animations/animation-drt-api-multiple-keyframes.html animations/animation-end-event-destroy-renderer.html animations/animation-start-event-destroy-renderer.html animations/longhand-timing-function.html fast/forms/input-spinbutton-capturing.html fast/forms/input-number-large-padding.html animations/animation-hit-test-transform.html fast/forms/input-number-events.html animations/unanimated-style.html animations/suspend-transform-animation.html fast/forms/implicit-submission.html animations/state-at-end-event.html 443266 6 100998 jamesr 2011-07-27 18:37:14 -0700 Comment on attachment 100998 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=100998&action=review R- for naming nits and because I don't think this handles state transition events (animationstart, animationend, animationiteration) correctly for background tabs. I believe that they should all still fire at the expected times even when requestAnimationFrame isn't pumping at all. To do this you might need to set some explicit Timers in addition to the requestAnimationFrame mechanism just for animation state transitions, and use requestAnimationFrame() just for intermediate ticks. > Source/WebCore/ChangeLog:8 > + No new tests. (OOPS!) You'll need to edit or remove this line 501153 7 cmarrin 2011-11-11 15:16:56 -0800 (In reply to comment #3) > State transition events (animationstart, animationend, animationiteration) still need to fire for non-visible tabs, even though requestAnimationFrame callbacks aren't invoked. Right. For hardware animations we still use the Timer to fire these events. It's pretty efficient because the Timer only fires when needed rather than every frame. So we can use that same mechanism and have the Timer fire the events, while rAF drives the actual animation. (as you might be able to tell, I'm working on this now…) 533198 8 simon.fraser 2012-01-10 10:59:20 -0800 <rdar://problem/10240395> 533214 9 cmarrin 2012-01-10 11:11:53 -0800 I've put this bug aside for now. I've gotten disappointing results, the animation is not smooth. I've tried printing lots of info during the animation, but it looks like we are often missing a cycle in rAF, possibly due to the expense of style resolution, etc. So I'm not sure it will be possible to use rAF to get smooth animation. It might still be a good idea to do it. It would make it possible to run software animations a bit faster (60hz vs 40hz) and animations would automatically suspend using the rAF suspend logic. But we already suspend software animations using other mechanisms on some platforms, so I'm not sure doing this work is very compelling I would be happy to be proved wrong 533219 10 jgw 2012-01-10 11:16:27 -0800 A marquee example that makes the problem pretty obvious: http://www.page.ca/~wes/bugs/jerky-marquee/ 533925 11 cmarrin 2012-01-11 08:47:06 -0800 (In reply to comment #10) > A marquee example that makes the problem pretty obvious: > http://www.page.ca/~wes/bugs/jerky-marquee/ I see that the example is jerky. But do you think that's due to the current animation timer implementation? From what I have seen with the rAF based implementation the same jerkiness is there. That leads me to believe it might be dues to layout or style resolution and rAF wouldn't help that. 533932 12 jgw 2012-01-11 08:55:33 -0800 (In reply to comment #11) > (In reply to comment #10) > > A marquee example that makes the problem pretty obvious: > > http://www.page.ca/~wes/bugs/jerky-marquee/ > > I see that the example is jerky. But do you think that's due to the current animation timer implementation? From what I have seen with the rAF based implementation the same jerkiness is there. That leads me to believe it might be dues to layout or style resolution and rAF wouldn't help that. My patch for this is not quite ready (it's still failing some tests because of some corner-cases starting animations under some circumstances). But so far this sample (as well as others I've been testing with) is greatly smoothed out. The strategy is fairly simple (not all that different from Alex's July patch, though it covers extra situations, like making sure events still fire when rAF() doesn't, e.g., for background tabs). The timer is still used to fire all js events, but the rAF callback is used to pump visible changes. This means that events won't necessarily be fired *precisely* when the visual change occurs, but my understanding is that this is already the case when CoreAnimation is used in Safari. Making this more precise is possible, but rather trickier. Note that it's still possible to have jerky animations if layouts triggered by each step take too long. There's probably little that can be done about this for animating properties that trigger layout, but it shouldn't be a problem for animation of accelerated properties (transform, opacity). 533936 13 cmarrin 2012-01-11 09:02:19 -0800 (In reply to comment #12) > (In reply to comment #11) > > (In reply to comment #10) > > > A marquee example that makes the problem pretty obvious: > > > http://www.page.ca/~wes/bugs/jerky-marquee/ > > > > I see that the example is jerky. But do you think that's due to the current animation timer implementation? From what I have seen with the rAF based implementation the same jerkiness is there. That leads me to believe it might be dues to layout or style resolution and rAF wouldn't help that. > > My patch for this is not quite ready (it's still failing some tests because of some corner-cases starting animations under some circumstances). But so far this sample (as well as others I've been testing with) is greatly smoothed out. > > The strategy is fairly simple (not all that different from Alex's July patch, though it covers extra situations, like making sure events still fire when rAF() doesn't, e.g., for background tabs). The timer is still used to fire all js events, but the rAF callback is used to pump visible changes. This means that events won't necessarily be fired *precisely* when the visual change occurs, but my understanding is that this is already the case when CoreAnimation is used in Safari. Making this more precise is possible, but rather trickier. > > Note that it's still possible to have jerky animations if layouts triggered by each step take too long. There's probably little that can be done about this for animating properties that trigger layout, but it shouldn't be a problem for animation of accelerated properties (transform, opacity). I'll be very interested in seeing the patch. My results showed that even simple animations were jerky. It would be great if your implementation smoothed everything out! 533937 14 jgw 2012-01-11 09:04:11 -0800 (In reply to comment #13) > I'll be very interested in seeing the patch. My results showed that even simple animations were jerky. It would be great if your implementation smoothed everything out! Hopefully I haven't missed anything important. I guess we'll know soon :) I'm trying to get something up for review this week, barring unforeseen difficulties fixing some tests. 534132 15 122071 jamesr 2012-01-11 12:25:33 -0800 Created attachment 122071 Simple marquee using CSS animation on the "left" property 534134 16 122073 jamesr 2012-01-11 12:26:07 -0800 Created attachment 122073 Simple marquee driven by rAF javascript animating the "left" style property 534136 17 jamesr 2012-01-11 12:29:49 -0800 For me, the rAF+javascript driven animation looks significantly smoother in Chrome. This is not too surprising - the first marquee runs at 40fps and the second runs at 60fps. In a WebKit nightly, rAF seems very buggy but when it's working correctly it looks a lot better. 534179 18 simon.fraser 2012-01-11 13:05:38 -0800 (In reply to comment #17) > In a WebKit nightly, rAF seems very buggy How so? 534243 19 cmarrin 2012-01-11 14:12:22 -0800 (In reply to comment #17) > For me, the rAF+javascript driven animation looks significantly smoother in Chrome. This is not too surprising - the first marquee runs at 40fps and the second runs at 60fps. In a WebKit nightly, rAF seems very buggy but when it's working correctly it looks a lot better. I agree that it is obviously running at a higher framerate. But I still see significant jerkiness to the animation. That's what I was seeing in my implementation. But I agree that jerky animation at 60Hz is better than jerky animation at 40hz! 534275 20 jamesr 2012-01-11 14:36:32 -0800 (In reply to comment #18) > (In reply to comment #17) > > In a WebKit nightly, rAF seems very buggy > How so? With r104705 it would sometimes just get stuck and stop ticking sometimes (but not often). I couldn't find a reliable way to repro. Additionally it doesn't look as smooth as Chrome's rAF implementation. It should be possible to quantify this exactly with careful instrumentation. 535869 21 122477 jgw 2012-01-13 11:55:36 -0800 Created attachment 122477 First pass at fixing this without breaking animation events 535871 22 122477 simon.fraser 2012-01-13 12:01:43 -0800 Comment on attachment 122477 First pass at fixing this without breaking animation events View in context: https://bugs.webkit.org/attachment.cgi?id=122477&action=review Not a full review. > Source/WebCore/page/animation/AnimationController.cpp:208 > + double needsService = updateAnimations(true); needsService sounds like a boolean. Why is it a double? > Source/WebCore/page/animation/AnimationController.cpp:226 > updateAnimationTimer(true); Mysterious boolean argument. > Source/WebCore/page/animation/AnimationControllerPrivate.h:60 > + double updateAnimations(bool callSetChanged); What does the return value mean? Maybe the method should be renamed 535876 23 jgw 2012-01-13 12:09:32 -0800 (In reply to comment #21) > Created an attachment (id=122477) [details] > First pass at fixing this without breaking animation events I believe this patch is on the right track. It continues to use the timer for all the "logical" work (firing events, dispatching node changes triggered by AnimationBase's state machine), but uses the rAF callback to trigger visible changes via node->setNeedsStyleRecalc(). Visually it appears to make animations nice and smooth, with no tearing or jerking (on my Ubuntu desktop, at least). I've also compared it to simply cranking the animation timer up to 60fps, and you can still tell the difference (tearing artifacts). It's not quite ready to commit, though, as it appears to be causing some flakiness in layout tests. The really strange thing I'm seeing is that, when I do any significant work (such as setting a couple of nodes' NeedsStyleRecalc()) in the rAF callback, setTimeout() becomes unreliable in test_shell -- e.g., a 500ms timer might fire anywhere from 500-2000ms later. Oddly, this doesn't seem to affect Chrome (just test_shell), and it doesn't seem to be pegging the CPU (it's doing about 50% more work, because of the increase from 40-60fps, but that's expected). There's something odd and subtle going on here -- if anyone has seen behavior like this before, please feel free to chime in. 535877 24 jgw 2012-01-13 12:10:52 -0800 (In reply to comment #22) > (From update of attachment 122477 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=122477&action=review > > Not a full review. > > > Source/WebCore/page/animation/AnimationController.cpp:208 > > + double needsService = updateAnimations(true); > > needsService sounds like a boolean. Why is it a double? > > > Source/WebCore/page/animation/AnimationController.cpp:226 > > updateAnimationTimer(true); > > Mysterious boolean argument. > > > Source/WebCore/page/animation/AnimationControllerPrivate.h:60 > > + double updateAnimations(bool callSetChanged); > > What does the return value mean? Maybe the method should be renamed Thanks, Simon. Once I figure out what's going on with the flaky timers I'll come back and clean this up -- all of the above weirdness is a result of me trying to disturb as little as possible with my change. 535922 25 122477 gyuyoung.kim 2012-01-13 13:00:06 -0800 Comment on attachment 122477 First pass at fixing this without breaking animation events Attachment 122477 did not pass efl-ews (efl): Output: http://queues.webkit.org/results/11157720 535971 26 122477 webkit.review.bot 2012-01-13 14:08:24 -0800 Comment on attachment 122477 First pass at fixing this without breaking animation events Attachment 122477 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/11149732 New failing tests: animations/animation-drt-api.html animations/animation-end-event-short-iterations.html animations/3d/change-transform-in-end-event.html compositing/repaint/become-overlay-composited-layer.html animations/3d/transform-perspective.html animations/3d/matrix-transform-type-animation.html animations/animation-direction.html animations/3d/transform-origin-vs-functions.html animations/animation-drt-api-multiple-keyframes.html compositing/animation/state-at-end-event-transform-layer.html animations/animation-end-event-destroy-renderer.html compositing/animation/animation-compositing.html animations/animation-add-events-in-handler.html animations/additive-transform-animations.html animations/animation-hit-test-transform.html animations/3d/replace-filling-transform.html animations/3d/state-at-end-event-transform.html animations/animation-direction-normal.html animations/animation-hit-test.html compositing/reflections/nested-reflection-animated.html 537355 27 122813 jgw 2012-01-17 14:28:50 -0800 Created attachment 122813 Fixed broken animation events 537360 28 122813 gyuyoung.kim 2012-01-17 14:38:59 -0800 Comment on attachment 122813 Fixed broken animation events Attachment 122813 did not pass efl-ews (efl): Output: http://queues.webkit.org/results/11267356 537367 29 122817 jgw 2012-01-17 14:52:21 -0800 Created attachment 122817 Removed old FIXME comment; fixed build by adding missing #if guard 537505 30 122817 webkit.review.bot 2012-01-17 17:48:53 -0800 Comment on attachment 122817 Removed old FIXME comment; fixed build by adding missing #if guard Attachment 122817 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/11117437 New failing tests: compositing/repaint/become-overlay-composited-layer.html 539730 31 ojan 2012-01-20 13:01:01 -0800 Possibly related bug 76730. 539788 32 jgw 2012-01-20 14:21:39 -0800 @simon.fraser: I'm trying to track down a single failing test: become-overlay-composited-layer.html If I'm reading it correctly, it looks like this test subtly depends upon the update-rate of animations -- the opacity-animating #fader in its expected.png is actually at rgb(38,38,38), which is very close to what you'd expect if it had been animated one tick at 40f/s. Given that this patch changes the rate at which animations are re-evaluated, it now produces a slightly different image, but I'm not sure it's going to be 100% stable, since it depends upon when rAF() fires. If I understand the purpose of the test correctly, it seems to be ensuring that there's not repaint garbage when the box/fader are moved into their own layers. So removing the { document.getElementById("container").className = ""; } line, while making the test more stable, would seem to no longer test what you intended. Does that make sense, and can you think of another way to do this without making it dependent upon the animation frame rate? 544245 33 jgw 2012-01-27 12:08:55 -0800 Just to be clear, I tested this in Safari and it has no noticeable impact (either on tests or, afaict, the behavior of animation in the browser). I expected as much, but thought it worthwhile to be sure. 544249 34 122817 jamesr 2012-01-27 12:17:45 -0800 Comment on attachment 122817 Removed old FIXME comment; fixed build by adding missing #if guard View in context: https://bugs.webkit.org/attachment.cgi?id=122817&action=review > Source/WebCore/ChangeLog:8 > + No new tests. (OOPS!) this will fail an svn presubmit check - for a patch like this that changes the implementation of already-tested code but doesn't change behavior, then the normal thing is to describe the change here and list the test(s) that apply. For this I think listing the directories of the animation layout tests that exercise this code is probably the right thing to do. > Source/WebCore/page/animation/AnimationController.cpp:207 > + double needsService = updateAnimations(true); needsService sounds like the name of a bool, and it used like a bool, so why is it a double? > Source/WebCore/page/animation/AnimationControllerPrivate.h:61 > + double updateAnimations(bool callSetChanged = false); we typically prefer using two-state enums for this to make the callsites more readable. it's a lot easier to see what: updateAnimations(CallSetChanged) means than updateAnimations(true) without having to go find and read the header where updateAnimations() is defined. I see that updateAnimationTimer() below doesn't follow good style here, but I think it's worth doing for new code. 544280 35 jgw 2012-01-27 12:53:23 -0800 (In reply to comment #34) > (From update of attachment 122817 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=122817&action=review > > > Source/WebCore/ChangeLog:8 > > + No new tests. (OOPS!) > > this will fail an svn presubmit check - for a patch like this that changes the implementation of already-tested code but doesn't change behavior, then the normal thing is to describe the change here and list the test(s) that apply. For this I think listing the directories of the animation layout tests that exercise this code is probably the right thing to do. Thanks, done. > > Source/WebCore/page/animation/AnimationController.cpp:207 > > + double needsService = updateAnimations(true); > > needsService sounds like the name of a bool, and it used like a bool, so why is it a double? Yeah, that was the original obscure name. I've renamed it to 'timeToNextService' which is significantly more accurate. > > Source/WebCore/page/animation/AnimationControllerPrivate.h:61 > > + double updateAnimations(bool callSetChanged = false); > > we typically prefer using two-state enums for this to make the callsites more readable. it's a lot easier to see what: > > updateAnimations(CallSetChanged) > > means than > > updateAnimations(true) > > without having to go find and read the header where updateAnimations() is defined. > > I see that updateAnimationTimer() below doesn't follow good style here, but I think it's worth doing for new code. Ok, done. Hard to come up with a reasonable name for this kind of thing, but the call sites are clearer now. I haven't uploaded a new patch yet, because I still have to chase down that failing test. I'll try to bug Simon again on Monday to see if there's another way to write that test such that it's not so dependent upon precisely when the animation is updated. In the meantime, if you have any other ideas, please feel free to chime in. 544288 36 simon.fraser 2012-01-27 12:56:28 -0800 > > > Source/WebCore/page/animation/AnimationController.cpp:207 > > > + double needsService = updateAnimations(true); > > > > needsService sounds like the name of a bool, and it used like a bool, so why is it a double? > > Yeah, that was the original obscure name. I've renamed it to 'timeToNextService' which is significantly more accurate. That name doesn't very well communicate what the method does though; it sounds like a simple getter, but the method does more than that. > I haven't uploaded a new patch yet, because I still have to chase down that failing test. I'll try to bug Simon again on Monday to see if there's another way to write that test such that it's not so dependent upon precisely when the animation is updated. In the meantime, if you have any other ideas, please feel free to chime in. I don't have any good ideas here, alas. 544298 37 jgw 2012-01-27 13:05:32 -0800 (In reply to comment #36) > > > > Source/WebCore/page/animation/AnimationController.cpp:207 > > > > + double needsService = updateAnimations(true); > > > > > > needsService sounds like the name of a bool, and it used like a bool, so why is it a double? > > > > Yeah, that was the original obscure name. I've renamed it to 'timeToNextService' which is significantly more accurate. > > That name doesn't very well communicate what the method does though; it sounds like a simple getter, but the method does more than that. I'm a little confused here -- we're talking about the local 'needsService' (which feels like a boolean, but isn't) vs. 'timeToNextService', right? I think this name's pretty clear -- it contains the time until the next animation needs to be serviced, or a negative value if none are upcoming. Am I completely misunderstanding your point? > > I haven't uploaded a new patch yet, because I still have to chase down that failing test. I'll try to bug Simon again on Monday to see if there's another way to write that test such that it's not so dependent upon precisely when the animation is updated. In the meantime, if you have any other ideas, please feel free to chime in. > > I don't have any good ideas here, alas. No worries, I'll see what I can come up with. As I understand it, the salient issue is that the elements being animated switch from and to being backed by composited layers, and that that leave no garbage behind. One thought: Might I be able to get a similar effect by just applying a 3D -webkit-transform to these elements? Not quite the same, but might be close enough. 544637 38 simon.fraser 2012-01-28 01:11:21 -0800 (In reply to comment #37) > I'm a little confused here -- we're talking about the local 'needsService' (which feels like a boolean, but isn't) vs. 'timeToNextService', right? I think this name's pretty clear -- it contains the time until the next animation needs to be serviced, or a negative value if none are upcoming. Am I completely misunderstanding your point? Sorry, I was working from memory here. Now I realize this is local variable. The name is fine. 546426 39 124808 jgw 2012-01-31 13:20:36 -0800 Created attachment 124808 Renamed a few things for clarity. Updated become-overlay-composited-layer test to not be flaky. Updated test expectations in anticipation of rebaselining. 546428 40 webkit.review.bot 2012-01-31 13:22:45 -0800 Attachment 124808 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/compositing/repaint/become-ove..." exit_code: 1 Source/WebCore/page/animation/AnimationController.cpp:99: Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons. [readability/comparison_to_zero] [5] Source/WebCore/page/animation/AnimationController.cpp:123: Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons. [readability/comparison_to_zero] [5] Traceback (most recent call last): File "Tools/Scripts/check-webkit-style", line 48, in <module> sys.exit(CheckWebKitStyle().main()) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/main.py", line 154, in main patch_checker.check(patch) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/patchreader.py", line 66, in check self._text_file_reader.process_file(file_path=path, line_numbers=line_numbers) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/filereader.py", line 130, in process_file self._processor.process(lines, file_path, **kwargs) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/checker.py", line 826, in process checker.check(lines) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/checkers/test_expectations.py", line 119, in check overrides=overrides) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/checkers/test_expectations.py", line 96, in check_test_expectations is_lint_mode=True, overrides=overrides) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/layout_tests/models/test_expectations.py", line 726, in __init__ self._add_skipped_tests(port.skipped_tests(tests)) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/layout_tests/port/webkit.py", line 376, in skipped_tests return self.skipped_layout_tests(test_list) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/layout_tests/port/webkit.py", line 372, in skipped_layout_tests tests_to_skip.update(self._skipped_tests_for_unsupported_features(test_list)) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/layout_tests/port/webkit.py", line 319, in _skipped_tests_for_unsupported_features if self._has_test_in_directories(self._missing_feature_to_skipped_tests().values(), test_list): File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/layout_tests/port/webkit.py", line 311, in _has_test_in_directories for directory, test in itertools.product(directories, test_list): TypeError: 'NoneType' object is not iterable If any of these errors are false positives, please file a bug against check-webkit-style. 546432 41 jgw 2012-01-31 13:27:18 -0800 Finally got around to updating this bug. I *believe* my change to the broken test should still cover the case it's intended to, but in a less flaky way (it references a rdar: bug, so it's a bit hard to be sure). This requires a change to the expectations -- I've added the chromium-linux expectations to the patch, and marked it PASS FAIL to avoid breaking builds. 546439 42 124809 jgw 2012-01-31 13:30:47 -0800 Created attachment 124809 Fixing pedantic presumbit check on (doubleValue == 0) expression. 546445 43 webkit.review.bot 2012-01-31 13:35:42 -0800 Attachment 124809 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/compositing/repaint/become-ove..." exit_code: 1 Traceback (most recent call last): File "Tools/Scripts/check-webkit-style", line 48, in <module> sys.exit(CheckWebKitStyle().main()) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/main.py", line 154, in main patch_checker.check(patch) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/patchreader.py", line 66, in check self._text_file_reader.process_file(file_path=path, line_numbers=line_numbers) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/filereader.py", line 130, in process_file self._processor.process(lines, file_path, **kwargs) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/checker.py", line 826, in process checker.check(lines) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/checkers/test_expectations.py", line 119, in check overrides=overrides) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/checkers/test_expectations.py", line 96, in check_test_expectations is_lint_mode=True, overrides=overrides) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/layout_tests/models/test_expectations.py", line 726, in __init__ self._add_skipped_tests(port.skipped_tests(tests)) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/layout_tests/port/webkit.py", line 376, in skipped_tests return self.skipped_layout_tests(test_list) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/layout_tests/port/webkit.py", line 372, in skipped_layout_tests tests_to_skip.update(self._skipped_tests_for_unsupported_features(test_list)) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/layout_tests/port/webkit.py", line 319, in _skipped_tests_for_unsupported_features if self._has_test_in_directories(self._missing_feature_to_skipped_tests().values(), test_list): File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/layout_tests/port/webkit.py", line 311, in _has_test_in_directories for directory, test in itertools.product(directories, test_list): TypeError: 'NoneType' object is not iterable If any of these errors are false positives, please file a bug against check-webkit-style. 553367 44 124809 jamesr 2012-02-09 11:39:02 -0800 Comment on attachment 124809 Fixing pedantic presumbit check on (doubleValue == 0) expression. R=me this looks great. To Simon's earlier concern, if it turns out that animations don't look better on some platforms's implementations of rAF then I think the way to address that is to add an ENABLE to control whether software-driven animations use rAF or a 40Hz timer. I feel that we've done sufficient experimentation in chromium to know that we definitely prefer the rAF mechanism to a 40Hz timer. 553668 45 124809 abarth 2012-02-09 18:02:22 -0800 Comment on attachment 124809 Fixing pedantic presumbit check on (doubleValue == 0) expression. This patch broke the commit-queue. 553670 46 abarth 2012-02-09 18:03:17 -0800 I'm 100% sure what the problem is, but you're using the test_expecations.txt file for a bunch of ports that normally use Skipped lists (e.g., windows). 553707 47 jchaffraix 2012-02-09 18:37:43 -0800 (In reply to comment #46) > I'm 100% sure what the problem is, but you're using the test_expecations.txt file for a bunch of ports that normally use Skipped lists (e.g., windows). Probably hitting bug 78260 (basically changing win test_expectations.txt is broken). 554232 48 126541 jgw 2012-02-10 11:15:55 -0800 Created attachment 126541 Rebasing on top of expectation changes. 554234 49 webkit.review.bot 2012-02-10 11:19:21 -0800 Attachment 126541 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/compositing/repaint/become-ove..." exit_code: 1 Traceback (most recent call last): File "Tools/Scripts/check-webkit-style", line 48, in <module> sys.exit(CheckWebKitStyle().main()) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/main.py", line 154, in main patch_checker.check(patch) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/patchreader.py", line 66, in check self._text_file_reader.process_file(file_path=path, line_numbers=line_numbers) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/filereader.py", line 130, in process_file self._processor.process(lines, file_path, **kwargs) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/checker.py", line 833, in process checker.check(lines) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/checkers/test_expectations.py", line 103, in check overrides = self._port_obj.test_expectations_overrides() AttributeError: 'NoneType' object has no attribute 'test_expectations_overrides' If any of these errors are false positives, please file a bug against check-webkit-style. 554282 50 126549 jgw 2012-02-10 12:15:26 -0800 Created attachment 126549 Fixing review-by line. 554287 51 webkit.review.bot 2012-02-10 12:19:19 -0800 Attachment 126549 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/compositing/repaint/become-ove..." exit_code: 1 Traceback (most recent call last): File "Tools/Scripts/check-webkit-style", line 48, in <module> sys.exit(CheckWebKitStyle().main()) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/main.py", line 154, in main patch_checker.check(patch) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/patchreader.py", line 66, in check self._text_file_reader.process_file(file_path=path, line_numbers=line_numbers) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/filereader.py", line 130, in process_file self._processor.process(lines, file_path, **kwargs) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/checker.py", line 833, in process checker.check(lines) File "/mnt/git/webkit-style-queue/Tools/Scripts/webkitpy/style/checkers/test_expectations.py", line 103, in check overrides = self._port_obj.test_expectations_overrides() AttributeError: 'NoneType' object has no attribute 'test_expectations_overrides' If any of these errors are false positives, please file a bug against check-webkit-style. 554299 52 jamesr 2012-02-10 12:32:06 -0800 I think that editing test_expectations.txt for non-chromium ports is not gonna work, they just don't really work :/ 554307 53 126559 jgw 2012-02-10 12:41:32 -0800 Created attachment 126559 Removing non-chromium test-expectations changes. 555292 54 126559 webkit.review.bot 2012-02-13 08:39:53 -0800 Comment on attachment 126559 Removing non-chromium test-expectations changes. Clearing flags on attachment: 126559 Committed r107575: <http://trac.webkit.org/changeset/107575> 555294 55 webkit.review.bot 2012-02-13 08:40:04 -0800 All reviewed patches have been landed. Closing bug. 1272212 56 simon.fraser 2017-02-01 11:20:53 -0800 This was rolled out in http://trac.webkit.org/r110262 1272229 57 sabouhallawa 2017-02-01 12:15:13 -0800 (In reply to comment #56) > This was rolled out in http://trac.webkit.org/r110262 This patch was not completely rolled out. Almost all the changes do still exist in the code as there were submitted expect the change in the FrameView.cpp. http://trac.webkit.org/r110262 rolled out https://trac.webkit.org/changeset/108616 which was a fix for https://bugs.webkit.org/show_bug.cgi?id=38025. The rolling change of this bug is https://trac.webkit.org/changeset/110889 which rolls out the change in FrameView.cpp only. Unfortunately the ChangeLogs of https://trac.webkit.org/changeset/107575 and https://trac.webkit.org/changeset/110889 did not say a single word explaining what these patches were doing. 1272240 58 sabouhallawa 2017-02-01 12:57:43 -0800 (In reply to comment #57) > (In reply to comment #56) > > This was rolled out in http://trac.webkit.org/r110262 > > This patch was not completely rolled out. Almost all the changes do still > exist in the code as there were submitted expect the change in the > FrameView.cpp. > > http://trac.webkit.org/r110262 rolled out > https://trac.webkit.org/changeset/108616 which was a fix for > https://bugs.webkit.org/show_bug.cgi?id=38025. > > The rolling change of this bug is https://trac.webkit.org/changeset/110889 > which rolls out the change in FrameView.cpp only. > > Unfortunately the ChangeLogs of https://trac.webkit.org/changeset/107575 and > https://trac.webkit.org/changeset/110889 did not say a single word > explaining what these patches were doing. I was wrong about the rolling part in FrameView.cpp. This change was not rolled out either. So closing this bug as fixed although I do not think the patch did what the title is saying. 100998 2011-07-15 09:55:16 -0700 2012-01-13 11:55:32 -0800 Patch bug-64591-20110715175514.patch text/plain 6428 alex U3VidmVyc2lvbiBSZXZpc2lvbjogOTEwNjAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBhYmI5ZTg0ODY5Yjc2NjVk Y2RiMGNmODE3ODJiODlmYjMyNmI4Mzc0Li5hOWUzOGMxZDgyZTJlNDkyNzg4MGVlNDJlNGMwOWY1 NzU4YjFkYzIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTEtMDctMTUgIEFsZXgg UnVzc2VsbCAgPHNsaWdodGx5b2ZmQGNocm9taXVtLm9yZz4KKworICAgICAgICBVc2UgcmVxdWVz dEFuaW1hdGlvbkZyYW1lIGNhbGxiYWNrcyB0byBwdW1wIENTUyBhbmltYXRpb25zCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD02NDU5MQorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cy4gKE9P UFMhKQorCisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 RnJhbWVWaWV3OjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRpb25zKTogQ2FsbCBiYWNrIGludG8gdGhl IENTUyBhbmltYXRpb24gY29kZSB3aGVuIFJBRiBpcyBlbmFibGVkCisgICAgICAgICogcGFnZS9h bmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpBbmlt YXRpb25Db250cm9sbGVyUHJpdmF0ZTo6Y2FsbGJhY2tGaXJlZCk6IE5ldyBtZXRob2QgdG8gc2Vy dmljZSBhbmltYXRpb24gZnJhbWVzIHdoZW4gcHVtcGVkIGJ5IHRoZSBSQUYgY2FsbGJhY2sKKyAg ICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXI6OnVwZGF0ZUFuaW1hdGlvbnMpOiBT Y2hlZHVsZSBuZXcgd29yayBvbiB0aGUgUkFGIGNhbGxiYWNrIHN5c3RlbSBhbmQgbm90IHRoZSBv bGQgdGltZXItYmFzZWQgc3lzdGVtCisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250cm9s bGVyOjpwdW1wQW5pbWF0aW9ucyk6IFB1YmxpYyBjYWxsYmFjayBoYW5kbGVyLgorICAgICAgICAq IHBhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuaDogQWRkIHNpZ25hdHVyZSBmb3Ig cHVtcEFuaW1hdGlvbnMoKQorICAgICAgICAqIHBhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRy b2xsZXJQcml2YXRlLmg6IEFkZCBzaWduYXR1cmUgZm9yIGNhbGxiYWNrRmlyZWQoKQorCiAyMDEx LTA3LTE1ICBKb25hdGhhbiBEb25nICA8am9uYXRoYW4uZG9uZ0B0b3JjaG1vYmlsZS5jb20uY24+ CiAKICAgICAgICAgTG9jYWxTdG9yYWdlOiBDaGFuZ2VkIHRoZSB2YWx1ZSB0eXBlIG9mIEl0ZW1U YWJsZSBmcm9tIFRFWFQgdG8gQkxPQgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9G cmFtZVZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IGZj MzMwOThkNzEzN2VhZTAzYzVmMmNiYWY0ZDU4NjdmMGYyZTY1YjEuLjcwYWZmMjUyMTRlNTVkMTgw Y2ZhNGUyMjVlN2Y2ZWE3Yzk2ODRiNDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv RnJhbWVWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAg LTE4NjksOCArMTg2OSwxMCBAQCB2b2lkIEZyYW1lVmlldzo6dW5zY2hlZHVsZVJlbGF5b3V0KCkK ICNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCiB2b2lkIEZyYW1lVmlldzo6c2Vy dmljZVNjcmlwdGVkQW5pbWF0aW9ucyhET01UaW1lU3RhbXAgdGltZSkKIHsKLSAgICBmb3IgKEZy YW1lKiBmcmFtZSA9IG1fZnJhbWUuZ2V0KCk7IGZyYW1lOyBmcmFtZSA9IGZyYW1lLT50cmVlKCkt PnRyYXZlcnNlTmV4dCgpKQorICAgIGZvciAoRnJhbWUqIGZyYW1lID0gbV9mcmFtZS5nZXQoKTsg ZnJhbWU7IGZyYW1lID0gZnJhbWUtPnRyZWUoKS0+dHJhdmVyc2VOZXh0KCkpIHsKICAgICAgICAg ZnJhbWUtPmRvY3VtZW50KCktPnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnModGltZSk7CisgICAg ICAgIGZyYW1lLT5hbmltYXRpb24oKS0+cHVtcEFuaW1hdGlvbnMoKTsKKyAgICB9CiB9CiAjZW5k aWYKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9u Q29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25D b250cm9sbGVyLmNwcAppbmRleCBiNDQzYTEwNDc5YTg4ZmQ3YmRjNjg0Y2VlMzk4NTFhNDFiM2E3 MTUxLi41ZDg4OGUzZmE3OGVmZGU4Yzc3MWFlZDVlYjM0ZGE2MjdjNGY5MmZjIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmNw cApAQCAtMzUsNiArMzUsNyBAQAogI2luY2x1ZGUgIkNvbXBvc2l0ZUFuaW1hdGlvbi5oIgogI2lu Y2x1ZGUgIkV2ZW50TmFtZXMuaCIKICNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1l Vmlldy5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNpbmNsdWRlICJXZWJLaXRBbmltYXRp b25FdmVudC5oIgogI2luY2x1ZGUgIldlYktpdEFuaW1hdGlvbkxpc3QuaCIKQEAgLTQ0LDcgKzQ1 LDcgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi0vLyBGSVhNRTogV2h5IGlzbid0IHRoaXMg c2V0IHRvIDYwZnBzIG9yIHNvbWV0aGluZz8KKy8vIEZJWE1FOiBXaHkgaXNuJ3QgdGhpcyBzZXQg dG8gNjBmcHMgKDAuMDE2KSBvciBzb21ldGhpbmc/CiBzdGF0aWMgY29uc3QgZG91YmxlIGNBbmlt YXRpb25UaW1lckRlbGF5ID0gMC4wMjU7CiBzdGF0aWMgY29uc3QgZG91YmxlIGNCZWdpbkFuaW1h dGlvblVwZGF0ZVRpbWVOb3RTZXQgPSAtMTsKIApAQCAtMTk0LDYgKzE5NSwzMyBAQCB2b2lkIEFu aW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjphZGROb2RlQ2hhbmdlVG9EaXNwYXRjaChQYXNzUmVm UHRyPE5vZGU+IG5vZGUpCiAgICAgc3RhcnRVcGRhdGVTdHlsZUlmTmVlZGVkRGlzcGF0Y2hlcigp OwogfQogCisjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQordm9pZCBBbmltYXRp b25Db250cm9sbGVyUHJpdmF0ZTo6Y2FsbGJhY2tGaXJlZCgpCit7CisgICAgLy8gV2Ugc2hvdWxk bid0IGJlIHJ1bm5pbmcgYW55IHRpbWVycyBpbiB0aGlzIG1vZGUKKyAgICBtX2FuaW1hdGlvblRp bWVyLnN0b3AoKTsKKworICAgIC8vIERldGVybWluZSBpZiBhbnkgYW5pbWF0aW9ucyBzdGlsbCBu ZWVkIHRvIGJlIHB1bXBlZC4gU3RvcCBzY2hlZHVsaW5nIGlmIHdlIGRvbid0LgorICAgIGJvb2wg cHVtcCA9IGZhbHNlOworICAgIFJlbmRlck9iamVjdEFuaW1hdGlvbk1hcDo6Y29uc3RfaXRlcmF0 b3IgYW5pbWF0aW9uc0VuZCA9IG1fY29tcG9zaXRlQW5pbWF0aW9ucy5lbmQoKTsKKyAgICBmb3Ig KFJlbmRlck9iamVjdEFuaW1hdGlvbk1hcDo6Y29uc3RfaXRlcmF0b3IgaXQgPSBtX2NvbXBvc2l0 ZUFuaW1hdGlvbnMuYmVnaW4oKTsgaXQgIT0gYW5pbWF0aW9uc0VuZDsgKytpdCkgeworICAgICAg ICBDb21wb3NpdGVBbmltYXRpb24qIGNvbXBBbmltID0gaXQtPnNlY29uZC5nZXQoKTsKKyAgICAg ICAgaWYgKCFjb21wQW5pbS0+c3VzcGVuZGVkKCkgJiYgY29tcEFuaW0tPmhhc0FuaW1hdGlvbnMo KSkgeworICAgICAgICAgICAgTm9kZSogbm9kZSA9IGl0LT5maXJzdC0+bm9kZSgpOworICAgICAg ICAgICAgbm9kZS0+c2V0TmVlZHNTdHlsZVJlY2FsYyhTeW50aGV0aWNTdHlsZUNoYW5nZSk7Cisg ICAgICAgICAgICBwdW1wID0gdHJ1ZTsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICBpZiAo cHVtcCkgeworICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT52aWV3KCktPnNjaGVkdWxlQW5p bWF0aW9uKCk7CisgICAgICAgIGZpcmVFdmVudHNBbmRVcGRhdGVTdHlsZSgpOworICAgICAgICBt X2ZyYW1lLT5kb2N1bWVudCgpLT51cGRhdGVTdHlsZUlmTmVlZGVkKCk7CisgICAgfQorICAgIAor fQorI2VuZGlmCisKIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmFuaW1hdGlvblRp bWVyRmlyZWQoVGltZXI8QW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU+KikKIHsKICAgICAvLyBN YWtlIHN1cmUgYW5pbWF0aW9uVXBkYXRlVGltZSBpcyB1cGRhdGVkLCBzbyB0aGF0IGl0IGlzIGN1 cnJlbnQgZXZlbiBpZiBubwpAQCAtNTAwLDcgKzUyOCwxMiBAQCBQYXNzUmVmUHRyPFJlbmRlclN0 eWxlPiBBbmltYXRpb25Db250cm9sbGVyOjp1cGRhdGVBbmltYXRpb25zKFJlbmRlck9iamVjdCog cmVuZAogICAgIFJlZlB0cjxDb21wb3NpdGVBbmltYXRpb24+IHJlbmRlcmVyQW5pbWF0aW9ucyA9 IG1fZGF0YS0+YWNjZXNzQ29tcG9zaXRlQW5pbWF0aW9uKHJlbmRlcmVyKTsKICAgICBSZWZQdHI8 UmVuZGVyU3R5bGU+IGJsZW5kZWRTdHlsZSA9IHJlbmRlcmVyQW5pbWF0aW9ucy0+YW5pbWF0ZShy ZW5kZXJlciwgb2xkU3R5bGUsIG5ld1N0eWxlKTsKIAorI2lmICFFTkFCTEUoUkVRVUVTVF9BTklN QVRJT05fRlJBTUUpCiAgICAgbV9kYXRhLT51cGRhdGVBbmltYXRpb25UaW1lcigpOworI2Vsc2UK KyAgICBpZiAoRnJhbWVWaWV3KiB2aWV3ID0gcmVuZGVyZXItPmRvY3VtZW50KCktPnZpZXcoKSkK KyAgICAgICAgdmlldy0+c2NoZWR1bGVBbmltYXRpb24oKTsKKyNlbmRpZgogCiAgICAgaWYgKGJs ZW5kZWRTdHlsZSAhPSBuZXdTdHlsZSkgewogICAgICAgICAvLyBJZiB0aGUgYW5pbWF0aW9ucy90 cmFuc2l0aW9ucyBjaGFuZ2Ugb3BhY2l0eSBvciB0cmFuc2Zvcm0sIHdlIG5lZWQgdG8gdXBkYXRl CkBAIC01NTcsNiArNTkwLDEzIEBAIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlcjo6cmVzdW1lQW5p bWF0aW9ucygpCiAgICAgbV9kYXRhLT5yZXN1bWVBbmltYXRpb25zKCk7CiB9CiAKKyNpZiBFTkFC TEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCit2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXI6OnB1 bXBBbmltYXRpb25zKCkKK3sKKyAgICBtX2RhdGEtPmNhbGxiYWNrRmlyZWQoKTsKK30KKyNlbmRp ZgorCiB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXI6OnN1c3BlbmRBbmltYXRpb25zRm9yRG9jdW1l bnQoRG9jdW1lbnQqIGRvY3VtZW50KQogewogICAgIG1fZGF0YS0+c3VzcGVuZEFuaW1hdGlvbnNG b3JEb2N1bWVudChkb2N1bWVudCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2Fu aW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1h dGlvbi9BbmltYXRpb25Db250cm9sbGVyLmgKaW5kZXggZWZlNmQwNGViOTNlZDRkZThhYzBjNjQw ZjEzMGU3MjEyM2EzNzhmZi4uMDI5N2UzMzAwOWFiZjk2NTlmZjA2ODM0Y2Y2MGRiNWY5OWE1ZTQz NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29u dHJvbGxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNv bnRyb2xsZXIuaApAQCAtNjUsNiArNjUsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHN1c3BlbmRB bmltYXRpb25zKCk7CiAgICAgdm9pZCByZXN1bWVBbmltYXRpb25zKCk7CisjaWYgRU5BQkxFKFJF UVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQorICAgIHZvaWQgcHVtcEFuaW1hdGlvbnMoKTsKKyNlbmRp ZgogCiAgICAgdm9pZCBzdXNwZW5kQW5pbWF0aW9uc0ZvckRvY3VtZW50KERvY3VtZW50Kik7CiAg ICAgdm9pZCByZXN1bWVBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1lbnQqKTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2 YXRlLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVy UHJpdmF0ZS5oCmluZGV4IDQxZWViZmYxNmRmNWM5M2QyYWNmYTg1YmU0OTkxN2ExZDQ4ZmUwOGUu LjA4NzczZDc4OTk0YWQ4ZDc1MjczMTIyZjI5OGUwMDVhYTE3ZGU4MzAgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmgK KysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlclBy aXZhdGUuaApAQCAtNzEsNiArNzEsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHN1c3BlbmRBbmlt YXRpb25zKCk7CiAgICAgdm9pZCByZXN1bWVBbmltYXRpb25zKCk7CisjaWYgRU5BQkxFKFJFUVVF U1RfQU5JTUFUSU9OX0ZSQU1FKQorICAgIHZvaWQgY2FsbGJhY2tGaXJlZCgpOworI2VuZGlmCiAK ICAgICB2b2lkIHN1c3BlbmRBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1lbnQqKTsKICAgICB2 b2lkIHJlc3VtZUFuaW1hdGlvbnNGb3JEb2N1bWVudChEb2N1bWVudCopOwo= 122071 2012-01-11 12:25:33 -0800 2012-01-11 12:25:33 -0800 Simple marquee using CSS animation on the "left" property marquee.html text/html 333 jamesr PCFET0NUWVBFIGh0bWw+CjxzdHlsZT4KQC13ZWJraXQta2V5ZnJhbWVzIG1hcnF1ZWUgewpmcm9t IHsKbGVmdDoxMDAlOwp9CnRvIHsKbGVmdDowJTsKfQp9Ci5tYXJxdWVlIHsKLXdlYmtpdC1hbmlt YXRpb24tbmFtZTogbWFycXVlZTsKLXdlYmtpdC1hbmltYXRpb24tZHVyYXRpb246IDEwczsKLXdl YmtpdC1hbmltYXRpb24taXRlcmF0aW9uLWNvdW50OiAxMDAwMDsKLXdlYmtpdC1hbmltYXRpb24t dGltaW5nLWZ1bmN0aW9uOiBsaW5lYXI7CnBvc2l0aW9uOmFic29sdXRlOwpsZWZ0OjBweDsKfQo8 L3N0eWxlPgo8ZGl2IGNsYXNzPSJtYXJxdWVlIj5IZWxsbyB3b3JsZCE8L2Rpdj4K 122073 2012-01-11 12:26:07 -0800 2012-01-11 12:26:07 -0800 Simple marquee driven by rAF javascript animating the "left" style property marquee-raf.html text/html 438 jamesr PCFET0NUWVBFIGh0bWw+CjxzdHlsZT4KLm1hcnF1ZWUgewpwb3NpdGlvbjphYnNvbHV0ZTsKLXdl YmtpdC10cmFuc2Zvcm06IHRyYW5zbGF0ZVooMCk7Cn0KPC9zdHlsZT4KPGRpdiBjbGFzcz0ibWFy cXVlZSIgc3R5bGU9ImxlZnQ6MTAwJSI+SGVsbG8gd29ybGQhPC9kaXY+CjxzY3JpcHQ+CnZhciBt ID0gZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiLm1hcnF1ZWUiKTsKdmFyIHN0YXJ0ID0gRGF0ZS5u b3coKTsKZnVuY3Rpb24gdGljaygpIHsKICAgIHZhciBwY3QgPSAxMDAgLSAoKERhdGUubm93KCkg LSBzdGFydCkpIC8gMTAwICUgMTAwOwogICAgbS5zdHlsZS5sZWZ0ID0gcGN0ICsgIiUiOwogICAg d2luZG93LndlYmtpdFJlcXVlc3RBbmltYXRpb25GcmFtZSh0aWNrKTsKfQp3aW5kb3cud2Via2l0 UmVxdWVzdEFuaW1hdGlvbkZyYW1lKHRpY2spOwo8L3NjcmlwdD4K 122477 2012-01-13 11:55:36 -0800 2012-01-17 14:28:44 -0800 First pass at fixing this without breaking animation events bug-64591-20120113145535.patch text/plain 8595 jgw U3VidmVyc2lvbiBSZXZpc2lvbjogMTA0ODQzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODAzMGU3ZjkxZmM1ZDA2 NjNkMTI2N2Q5YWZlZmYxZDAxYzhjMDYyNi4uNTY1Y2Q5NjcyYzFmNTU2NGQ1YmZjMWU2ZDMzZmEx ZjMyZDFiM2JkYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDEyLTAxLTEzICBKb2Vs IFdlYmJlciAgPGpnd0Bnb29nbGUuY29tPgorCisgICAgICAgIFVzZSByZXF1ZXN0QW5pbWF0aW9u RnJhbWUgY2FsbGJhY2tzIHRvIHB1bXAgQ1NTIGFuaW1hdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTkxCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLiAoT09QUyEpCisKKyAg ICAgICAgKiBwYWdlL0ZyYW1lVmlldy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZVZpZXc6 OnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMpOgorICAgICAgICAqIHBhZ2UvYW5pbWF0aW9uL0Fu aW1hdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0aW9uQ29udHJv bGxlclByaXZhdGU6OnVwZGF0ZUFuaW1hdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0 aW9uQ29udHJvbGxlclByaXZhdGU6OnVwZGF0ZUFuaW1hdGlvblRpbWVyKToKKyAgICAgICAgKFdl YkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjpmaXJlRXZlbnRzQW5kVXBkYXRlU3R5 bGUpOgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmFuaW1h dGlvbkZyYW1lQ2FsbGJhY2tGaXJlZCk6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250 cm9sbGVyUHJpdmF0ZTo6YW5pbWF0aW9uVGltZXJGaXJlZCk6CisgICAgICAgIChXZWJDb3JlOjpB bmltYXRpb25Db250cm9sbGVyOjp1cGRhdGVBbmltYXRpb25zKToKKyAgICAgICAgKFdlYkNvcmU6 OkFuaW1hdGlvbkNvbnRyb2xsZXI6OnNlcnZpY2VBbmltYXRpb25zKToKKyAgICAgICAgKiBwYWdl L2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmg6CisgICAgICAgICogcGFnZS9hbmltYXRp b24vQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUuaDoKKwogMjAxMi0wMS0xMiAgQW5kZXJzIENh cmxzc29uICA8YW5kZXJzY2FAYXBwbGUuY29tPgogCiAgICAgICAgIE1vdmUgc25hcFJ1YmJlckJh bmRUaW1lckZpcmVkIHRvIFNjcm9sbEVsYXN0aWNpdHlDb250cm9sbGVyCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0Zy YW1lVmlldy5jcHAKaW5kZXggNTZmNmM2MGMyNzgxOTM3YmYwYTM2ZWIzY2QzMzFhZjU0YTk4MWYy NS4uYTdiNTU1NTNlMGM2Mzg2ZmZhZGNlMGI1ZTFmZjYzZDY3YzI0MzdmOCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvRnJhbWVWaWV3LmNwcApAQCAtMjExMCw4ICsyMTEwLDExIEBAIHZvaWQgRnJhbWVWaWV3Ojp1 bnNjaGVkdWxlUmVsYXlvdXQoKQogI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkK IHZvaWQgRnJhbWVWaWV3OjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRpb25zKERPTVRpbWVTdGFtcCB0 aW1lKQogewotICAgIFZlY3RvcjxSZWZQdHI8RG9jdW1lbnQ+ID4gZG9jdW1lbnRzOworICAgIFZl Y3RvcjxBbmltYXRpb25Db250cm9sbGVyKj4gYW5pbWF0aW9uczsKKyAgICBmb3IgKEZyYW1lKiBm cmFtZSA9IG1fZnJhbWUuZ2V0KCk7IGZyYW1lOyBmcmFtZSA9IGZyYW1lLT50cmVlKCktPnRyYXZl cnNlTmV4dCgpKQorICAgICAgICBmcmFtZS0+YW5pbWF0aW9uKCktPnNlcnZpY2VBbmltYXRpb25z KCk7CiAKKyAgICBWZWN0b3I8UmVmUHRyPERvY3VtZW50PiA+IGRvY3VtZW50czsKICAgICBmb3Ig KEZyYW1lKiBmcmFtZSA9IG1fZnJhbWUuZ2V0KCk7IGZyYW1lOyBmcmFtZSA9IGZyYW1lLT50cmVl KCktPnRyYXZlcnNlTmV4dCgpKQogICAgICAgICBkb2N1bWVudHMuYXBwZW5kKGZyYW1lLT5kb2N1 bWVudCgpKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5p bWF0aW9uQ29udHJvbGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9Bbmlt YXRpb25Db250cm9sbGVyLmNwcAppbmRleCA3NDVkNTE0NmI5MThlZDA1MGY3OGYxYjQyYTI5MmI1 YTFmYTRkYWEwLi5hYmZkYmFiMWRkYjFiNjA5NDViODIwYzEwZTYzNzYzN2Y1Yzc3MzFjIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVy LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9s bGVyLmNwcApAQCAtMzUsNiArMzUsNyBAQAogI2luY2x1ZGUgIkNvbXBvc2l0ZUFuaW1hdGlvbi5o IgogI2luY2x1ZGUgIkV2ZW50TmFtZXMuaCIKICNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUg IkZyYW1lVmlldy5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNpbmNsdWRlICJXZWJLaXRB bmltYXRpb25FdmVudC5oIgogI2luY2x1ZGUgIldlYktpdEFuaW1hdGlvbkxpc3QuaCIKQEAgLTg0 LDcgKzg1LDcgQEAgYm9vbCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6Y2xlYXIoUmVuZGVy T2JqZWN0KiByZW5kZXJlcikKICAgICByZXR1cm4gYW5pbWF0aW9uLT5zdXNwZW5kZWQoKTsKIH0K IAotdm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIo Ym9vbCBjYWxsU2V0Q2hhbmdlZC8qID0gZmFsc2UqLykKK2RvdWJsZSBBbmltYXRpb25Db250cm9s bGVyUHJpdmF0ZTo6dXBkYXRlQW5pbWF0aW9ucyhib29sIGNhbGxTZXRDaGFuZ2VkKQogewogICAg IGRvdWJsZSBuZWVkc1NlcnZpY2UgPSAtMTsKICAgICBib29sIGNhbGxlZFNldENoYW5nZWQgPSBm YWxzZTsKQEAgLTEwOCwxMCArMTA5LDE3IEBAIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZh dGU6OnVwZGF0ZUFuaW1hdGlvblRpbWVyKGJvb2wgY2FsbFNldENoYW5nZWQvKiA9IGZhCiAgICAg ICAgICAgICB9CiAgICAgICAgIH0KICAgICB9Ci0gICAgCisKICAgICBpZiAoY2FsbGVkU2V0Q2hh bmdlZCkKICAgICAgICAgbV9mcmFtZS0+ZG9jdW1lbnQoKS0+dXBkYXRlU3R5bGVJZk5lZWRlZCgp OwotICAgIAorCisgICAgcmV0dXJuIG5lZWRzU2VydmljZTsKK30KKwordm9pZCBBbmltYXRpb25D b250cm9sbGVyUHJpdmF0ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0Q2hhbmdl ZC8qID0gZmFsc2UqLykKK3sKKyAgICBkb3VibGUgbmVlZHNTZXJ2aWNlID0gdXBkYXRlQW5pbWF0 aW9ucyhjYWxsU2V0Q2hhbmdlZCk7CisKICAgICAvLyBJZiB3ZSB3YW50IHNlcnZpY2UgaW1tZWRp YXRlbHksIHdlIHN0YXJ0IGEgcmVwZWF0aW5nIHRpbWVyIHRvIHJlZHVjZSB0aGUgb3ZlcmhlYWQg b2Ygc3RhcnRpbmcKICAgICBpZiAobmVlZHNTZXJ2aWNlID09IDApIHsKICAgICAgICAgaWYgKCFt X2FuaW1hdGlvblRpbWVyLmlzQWN0aXZlKCkgfHwgbV9hbmltYXRpb25UaW1lci5yZXBlYXRJbnRl cnZhbCgpID09IDApCkBAIC0xNDMsNyArMTUxLDcgQEAgdm9pZCBBbmltYXRpb25Db250cm9sbGVy UHJpdmF0ZTo6ZmlyZUV2ZW50c0FuZFVwZGF0ZVN0eWxlKCkKICAgICBSZWZQdHI8RnJhbWU+IHBy b3RlY3RvciA9IG1fZnJhbWU7CiAKICAgICBib29sIHVwZGF0ZVN0eWxlID0gIW1fZXZlbnRzVG9E aXNwYXRjaC5pc0VtcHR5KCkgfHwgIW1fbm9kZUNoYW5nZXNUb0Rpc3BhdGNoLmlzRW1wdHkoKTsK LSAgICAKKwogICAgIC8vIGZpcmUgYWxsIHRoZSBldmVudHMKICAgICBWZWN0b3I8RXZlbnRUb0Rp c3BhdGNoPiBldmVudHNUb0Rpc3BhdGNoID0gbV9ldmVudHNUb0Rpc3BhdGNoOwogICAgIG1fZXZl bnRzVG9EaXNwYXRjaC5jbGVhcigpOwpAQCAtMTU0LDE0ICsxNjIsMTQgQEAgdm9pZCBBbmltYXRp b25Db250cm9sbGVyUHJpdmF0ZTo6ZmlyZUV2ZW50c0FuZFVwZGF0ZVN0eWxlKCkKICAgICAgICAg ZWxzZQogICAgICAgICAgICAgaXQtPmVsZW1lbnQtPmRpc3BhdGNoRXZlbnQoV2ViS2l0QW5pbWF0 aW9uRXZlbnQ6OmNyZWF0ZShpdC0+ZXZlbnRUeXBlLCBpdC0+bmFtZSwgaXQtPmVsYXBzZWRUaW1l KSk7CiAgICAgfQotICAgIAorCiAgICAgLy8gY2FsbCBzZXRDaGFuZ2VkIG9uIGFsbCB0aGUgZWxl bWVudHMKICAgICBWZWN0b3I8UmVmUHRyPE5vZGU+ID46OmNvbnN0X2l0ZXJhdG9yIG5vZGVDaGFu Z2VzVG9EaXNwYXRjaEVuZCA9IG1fbm9kZUNoYW5nZXNUb0Rpc3BhdGNoLmVuZCgpOwogICAgIGZv ciAoVmVjdG9yPFJlZlB0cjxOb2RlPiA+Ojpjb25zdF9pdGVyYXRvciBpdCA9IG1fbm9kZUNoYW5n ZXNUb0Rpc3BhdGNoLmJlZ2luKCk7IGl0ICE9IG5vZGVDaGFuZ2VzVG9EaXNwYXRjaEVuZDsgKytp dCkKICAgICAgICAgKCppdCktPnNldE5lZWRzU3R5bGVSZWNhbGMoU3ludGhldGljU3R5bGVDaGFu Z2UpOwotICAgIAorCiAgICAgbV9ub2RlQ2hhbmdlc1RvRGlzcGF0Y2guY2xlYXIoKTsKLSAgICAK KwogICAgIGlmICh1cGRhdGVTdHlsZSAmJiBtX2ZyYW1lKQogICAgICAgICBtX2ZyYW1lLT5kb2N1 bWVudCgpLT51cGRhdGVTdHlsZUlmTmVlZGVkKCk7CiB9CkBAIC0xOTQsNiArMjAyLDE2IEBAIHZv aWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmFkZE5vZGVDaGFuZ2VUb0Rpc3BhdGNoKFBh c3NSZWZQdHI8Tm9kZT4gbm9kZSkKICAgICBzdGFydFVwZGF0ZVN0eWxlSWZOZWVkZWREaXNwYXRj aGVyKCk7CiB9CiAKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCit2b2lkIEFu aW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjphbmltYXRpb25GcmFtZUNhbGxiYWNrRmlyZWQoKQor eworICAgIGRvdWJsZSBuZWVkc1NlcnZpY2UgPSB1cGRhdGVBbmltYXRpb25zKHRydWUpOworCisg ICAgaWYgKG5lZWRzU2VydmljZSA+PSAwKQorICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT52 aWV3KCktPnNjaGVkdWxlQW5pbWF0aW9uKCk7Cit9CisjZW5kaWYKKwogdm9pZCBBbmltYXRpb25D b250cm9sbGVyUHJpdmF0ZTo6YW5pbWF0aW9uVGltZXJGaXJlZChUaW1lcjxBbmltYXRpb25Db250 cm9sbGVyUHJpdmF0ZT4qKQogewogICAgIC8vIE1ha2Ugc3VyZSBhbmltYXRpb25VcGRhdGVUaW1l IGlzIHVwZGF0ZWQsIHNvIHRoYXQgaXQgaXMgY3VycmVudCBldmVuIGlmIG5vCkBAIC0yMDIsNyAr MjIwLDExIEBAIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmFuaW1hdGlvblRpbWVy RmlyZWQoVGltZXI8QW5pbWF0aW9uQ29udHJvbGxlclByCiAKICAgICAvLyBXaGVuIHRoZSB0aW1l ciBmaXJlcywgYWxsIHdlIGRvIGlzIGNhbGwgc2V0Q2hhbmdlZCBvbiBhbGwgRE9NIG5vZGVzIHdp dGggcnVubmluZyBhbmltYXRpb25zIGFuZCB0aGVuIGRvIGFuIGltbWVkaWF0ZQogICAgIC8vIHVw ZGF0ZVN0eWxlSWZOZWVkZWQuICBJdCB3aWxsIHRoZW4gY2FsbCBiYWNrIHRvIHVzIHdpdGggbmV3 IGluZm9ybWF0aW9uLgorI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKKyAgICB1 cGRhdGVBbmltYXRpb25UaW1lcigpOworI2Vsc2UKICAgICB1cGRhdGVBbmltYXRpb25UaW1lcih0 cnVlKTsKKyNlbmRpZgogCiAgICAgLy8gRmlyZSBldmVudHMgcmlnaHQgYXdheSwgdG8gYXZvaWQg YSBmbGFzaCBvZiB1bmFuaW1hdGVkIHN0eWxlIGFmdGVyIGFuIGFuaW1hdGlvbiBjb21wbGV0ZXMs IGFuZCBiZWZvcmUKICAgICAvLyB0aGUgJ2VuZCcgZXZlbnQgZmlyZXMuCkBAIC00OTksOCArNTIx LDExIEBAIFBhc3NSZWZQdHI8UmVuZGVyU3R5bGU+IEFuaW1hdGlvbkNvbnRyb2xsZXI6OnVwZGF0 ZUFuaW1hdGlvbnMoUmVuZGVyT2JqZWN0KiByZW5kCiAgICAgUmVmUHRyPENvbXBvc2l0ZUFuaW1h dGlvbj4gcmVuZGVyZXJBbmltYXRpb25zID0gbV9kYXRhLT5hY2Nlc3NDb21wb3NpdGVBbmltYXRp b24ocmVuZGVyZXIpOwogICAgIFJlZlB0cjxSZW5kZXJTdHlsZT4gYmxlbmRlZFN0eWxlID0gcmVu ZGVyZXJBbmltYXRpb25zLT5hbmltYXRlKHJlbmRlcmVyLCBvbGRTdHlsZSwgbmV3U3R5bGUpOwog Ci0gICAgaWYgKHJlbmRlcmVyLT5wYXJlbnQoKSB8fCBuZXdTdHlsZS0+YW5pbWF0aW9ucygpIHx8 IChvbGRTdHlsZSAmJiBvbGRTdHlsZS0+YW5pbWF0aW9ucygpKSkKKyAgICBpZiAocmVuZGVyZXIt PnBhcmVudCgpIHx8IG5ld1N0eWxlLT5hbmltYXRpb25zKCkgfHwgKG9sZFN0eWxlICYmIG9sZFN0 eWxlLT5hbmltYXRpb25zKCkpKSB7CiAgICAgICAgIG1fZGF0YS0+dXBkYXRlQW5pbWF0aW9uVGlt ZXIoKTsKKyAgICAgICAgaWYgKEZyYW1lVmlldyogdmlldyA9IHJlbmRlcmVyLT5kb2N1bWVudCgp LT52aWV3KCkpCisgICAgICAgICAgICB2aWV3LT5zY2hlZHVsZUFuaW1hdGlvbigpOworICAgIH0K IAogICAgIGlmIChibGVuZGVkU3R5bGUgIT0gbmV3U3R5bGUpIHsKICAgICAgICAgLy8gSWYgdGhl IGFuaW1hdGlvbnMvdHJhbnNpdGlvbnMgY2hhbmdlIG9wYWNpdHkgb3IgdHJhbnNmb3JtLCB3ZSBu ZWVkIHRvIHVwZGF0ZQpAQCAtNTU3LDYgKzU4MiwxMyBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xs ZXI6OnJlc3VtZUFuaW1hdGlvbnMoKQogICAgIG1fZGF0YS0+cmVzdW1lQW5pbWF0aW9ucygpOwog fQogCisjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQordm9pZCBBbmltYXRpb25D b250cm9sbGVyOjpzZXJ2aWNlQW5pbWF0aW9ucygpCit7CisgICAgbV9kYXRhLT5hbmltYXRpb25G cmFtZUNhbGxiYWNrRmlyZWQoKTsKK30KKyNlbmRpZgorCiB2b2lkIEFuaW1hdGlvbkNvbnRyb2xs ZXI6OnN1c3BlbmRBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1lbnQqIGRvY3VtZW50KQogewog ICAgIG1fZGF0YS0+c3VzcGVuZEFuaW1hdGlvbnNGb3JEb2N1bWVudChkb2N1bWVudCk7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVy LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmgK aW5kZXggY2NkYzZjNGE0MmQ3YTFiMzUwMmQ3NzA3ODA3MDE2Njk1ZTM2NGI0OC4uMTg3NzJkZDU5 Mzk0YWI4MDQ2MGZkOTY1NGRmNGY3OWQ1NmViZWFlZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5oCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuaApAQCAtNjYsNiArNjYsOSBA QCBwdWJsaWM6CiAKICAgICB2b2lkIHN1c3BlbmRBbmltYXRpb25zKCk7CiAgICAgdm9pZCByZXN1 bWVBbmltYXRpb25zKCk7CisjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQorICAg IHZvaWQgc2VydmljZUFuaW1hdGlvbnMoKTsKKyNlbmRpZgogCiAgICAgdm9pZCBzdXNwZW5kQW5p bWF0aW9uc0ZvckRvY3VtZW50KERvY3VtZW50Kik7CiAgICAgdm9pZCByZXN1bWVBbmltYXRpb25z Rm9yRG9jdW1lbnQoRG9jdW1lbnQqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv YW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmggYi9Tb3VyY2UvV2ViQ29yZS9w YWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZS5oCmluZGV4IDQxZWViZmYx NmRmNWM5M2QyYWNmYTg1YmU0OTkxN2ExZDQ4ZmUwOGUuLjY5YWM2ZGEzODc0Njc2N2E1MzQ3MmJl NDBjZmU5YjllYTY1ZTY0ZjcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0 aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFn ZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUuaApAQCAtNTcsNiArNTcsNyBA QCBwdWJsaWM6CiAgICAgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUoRnJhbWUqKTsKICAgICB+ QW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUoKTsKIAorICAgIGRvdWJsZSB1cGRhdGVBbmltYXRp b25zKGJvb2wgY2FsbFNldENoYW5nZWQpOwogICAgIHZvaWQgdXBkYXRlQW5pbWF0aW9uVGltZXIo Ym9vbCBjYWxsU2V0Q2hhbmdlZCA9IGZhbHNlKTsKIAogICAgIFBhc3NSZWZQdHI8Q29tcG9zaXRl QW5pbWF0aW9uPiBhY2Nlc3NDb21wb3NpdGVBbmltYXRpb24oUmVuZGVyT2JqZWN0Kik7CkBAIC03 MSw2ICs3Miw5IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgc3VzcGVuZEFuaW1hdGlvbnMoKTsKICAg ICB2b2lkIHJlc3VtZUFuaW1hdGlvbnMoKTsKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05f RlJBTUUpCisgICAgdm9pZCBhbmltYXRpb25GcmFtZUNhbGxiYWNrRmlyZWQoKTsKKyNlbmRpZgog CiAgICAgdm9pZCBzdXNwZW5kQW5pbWF0aW9uc0ZvckRvY3VtZW50KERvY3VtZW50Kik7CiAgICAg dm9pZCByZXN1bWVBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1lbnQqKTsK 122813 2012-01-17 14:28:50 -0800 2012-01-17 14:52:13 -0800 Fixed broken animation events bug-64591-20120117172848.patch text/plain 8548 jgw U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1MTUxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzI2NjliYmFhOWMyMTZh MjBmMGY3YzQyYmUyNjc0YzE0Zjk1YjBjZi4uOTMyZmVlOWJhMjkwOTdiM2ZlNjVhZjMzNzUyYjIz OGFmMjQ0NWI4MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEyLTAxLTE3ICBKb2Vs IFdlYmJlciAgPGpnd0Bnb29nbGUuY29tPgorCisgICAgICAgIFVzZSByZXF1ZXN0QW5pbWF0aW9u RnJhbWUgY2FsbGJhY2tzIHRvIHB1bXAgQ1NTIGFuaW1hdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTkxCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLiAoT09QUyEpCisKKyAg ICAgICAgKiBwYWdlL0ZyYW1lVmlldy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZVZpZXc6 OnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMpOgorICAgICAgICAqIHBhZ2UvYW5pbWF0aW9uL0Fu aW1hdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0aW9uQ29udHJv bGxlclByaXZhdGU6OnVwZGF0ZUFuaW1hdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0 aW9uQ29udHJvbGxlclByaXZhdGU6OnVwZGF0ZUFuaW1hdGlvblRpbWVyKToKKyAgICAgICAgKFdl YkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjpmaXJlRXZlbnRzQW5kVXBkYXRlU3R5 bGUpOgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmFuaW1h dGlvbkZyYW1lQ2FsbGJhY2tGaXJlZCk6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250 cm9sbGVyOjp1cGRhdGVBbmltYXRpb25zKToKKyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNv bnRyb2xsZXI6OnNlcnZpY2VBbmltYXRpb25zKToKKyAgICAgICAgKiBwYWdlL2FuaW1hdGlvbi9B bmltYXRpb25Db250cm9sbGVyLmg6CisgICAgICAgICogcGFnZS9hbmltYXRpb24vQW5pbWF0aW9u Q29udHJvbGxlclByaXZhdGUuaDoKKwogMjAxMi0wMS0xNyAgTmlrb2xhcyBaaW1tZXJtYW5uICA8 bnppbW1lcm1hbm5AcmltLmNvbT4KIAogICAgICAgICBMYXJnZSBTVkcgdGV4dCBsYXlvdXQgcGVy Zm9ybWFuY2UgcmVncmVzc2lvbiBpbiByODExNjgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvRnJhbWVWaWV3LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcApp bmRleCAxN2M5ZGVjZjBiOWRiYmUzNWZkNDJkZWIwNjM4NjMyNTQ0OWMzODhlLi42ZTBjYjBmNWE4 NTNhYjg4OTYyOTQ0MjU3N2NjMWIwY2FmZTE1MTU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wYWdlL0ZyYW1lVmlldy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcu Y3BwCkBAIC0yMTA1LDggKzIxMDUsMTEgQEAgdm9pZCBGcmFtZVZpZXc6OnVuc2NoZWR1bGVSZWxh eW91dCgpCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQogdm9pZCBGcmFtZVZp ZXc6OnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMoRE9NVGltZVN0YW1wIHRpbWUpCiB7Ci0gICAg VmVjdG9yPFJlZlB0cjxEb2N1bWVudD4gPiBkb2N1bWVudHM7CisgICAgVmVjdG9yPEFuaW1hdGlv bkNvbnRyb2xsZXIqPiBhbmltYXRpb25zOworICAgIGZvciAoRnJhbWUqIGZyYW1lID0gbV9mcmFt ZS5nZXQoKTsgZnJhbWU7IGZyYW1lID0gZnJhbWUtPnRyZWUoKS0+dHJhdmVyc2VOZXh0KCkpCisg ICAgICAgIGZyYW1lLT5hbmltYXRpb24oKS0+c2VydmljZUFuaW1hdGlvbnMoKTsKIAorICAgIFZl Y3RvcjxSZWZQdHI8RG9jdW1lbnQ+ID4gZG9jdW1lbnRzOwogICAgIGZvciAoRnJhbWUqIGZyYW1l ID0gbV9mcmFtZS5nZXQoKTsgZnJhbWU7IGZyYW1lID0gZnJhbWUtPnRyZWUoKS0+dHJhdmVyc2VO ZXh0KCkpCiAgICAgICAgIGRvY3VtZW50cy5hcHBlbmQoZnJhbWUtPmRvY3VtZW50KCkpOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9s bGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xs ZXIuY3BwCmluZGV4IDc0NWQ1MTQ2YjkxOGVkMDUwZjc4ZjFiNDJhMjkyYjVhMWZhNGRhYTAuLjFm YmFkNmRlYWZmNzhjNzE0YTA2OGQ3NGIzY2Q4MDZkMmVhNjgyNjQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuY3BwCkBAIC0z NSw2ICszNSw3IEBACiAjaW5jbHVkZSAiQ29tcG9zaXRlQW5pbWF0aW9uLmgiCiAjaW5jbHVkZSAi RXZlbnROYW1lcy5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiRnJhbWVWaWV3Lmgi CiAjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgogI2luY2x1ZGUgIldlYktpdEFuaW1hdGlvbkV2ZW50 LmgiCiAjaW5jbHVkZSAiV2ViS2l0QW5pbWF0aW9uTGlzdC5oIgpAQCAtODQsNyArODUsNyBAQCBi b29sIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjpjbGVhcihSZW5kZXJPYmplY3QqIHJlbmRl cmVyKQogICAgIHJldHVybiBhbmltYXRpb24tPnN1c3BlbmRlZCgpOwogfQogCi12b2lkIEFuaW1h dGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmltYXRpb25UaW1lcihib29sIGNhbGxTZXRD aGFuZ2VkLyogPSBmYWxzZSovKQorZG91YmxlIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1 cGRhdGVBbmltYXRpb25zKGJvb2wgY2FsbFNldENoYW5nZWQvKiA9IGZhbHNlKi8pCiB7CiAgICAg ZG91YmxlIG5lZWRzU2VydmljZSA9IC0xOwogICAgIGJvb2wgY2FsbGVkU2V0Q2hhbmdlZCA9IGZh bHNlOwpAQCAtMTA4LDI0ICsxMDksMzEgQEAgdm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0 ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0Q2hhbmdlZC8qID0gZmEKICAgICAg ICAgICAgIH0KICAgICAgICAgfQogICAgIH0KLSAgICAKKwogICAgIGlmIChjYWxsZWRTZXRDaGFu Z2VkKQogICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT51cGRhdGVTdHlsZUlmTmVlZGVkKCk7 Ci0gICAgCisKKyAgICByZXR1cm4gbmVlZHNTZXJ2aWNlOworfQorCit2b2lkIEFuaW1hdGlvbkNv bnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmltYXRpb25UaW1lcihib29sIGNhbGxTZXRDaGFuZ2Vk LyogPSBmYWxzZSovKQoreworICAgIGRvdWJsZSBuZWVkc1NlcnZpY2UgPSB1cGRhdGVBbmltYXRp b25zKGNhbGxTZXRDaGFuZ2VkKTsKKwogICAgIC8vIElmIHdlIHdhbnQgc2VydmljZSBpbW1lZGlh dGVseSwgd2Ugc3RhcnQgYSByZXBlYXRpbmcgdGltZXIgdG8gcmVkdWNlIHRoZSBvdmVyaGVhZCBv ZiBzdGFydGluZwogICAgIGlmIChuZWVkc1NlcnZpY2UgPT0gMCkgewogICAgICAgICBpZiAoIW1f YW5pbWF0aW9uVGltZXIuaXNBY3RpdmUoKSB8fCBtX2FuaW1hdGlvblRpbWVyLnJlcGVhdEludGVy dmFsKCkgPT0gMCkKICAgICAgICAgICAgIG1fYW5pbWF0aW9uVGltZXIuc3RhcnRSZXBlYXRpbmco Y0FuaW1hdGlvblRpbWVyRGVsYXkpOwogICAgICAgICByZXR1cm47CiAgICAgfQotICAgIAorCiAg ICAgLy8gSWYgd2UgZG9uJ3QgbmVlZCBzZXJ2aWNlLCB3ZSB3YW50IHRvIG1ha2Ugc3VyZSB0aGUg dGltZXIgaXMgbm8gbG9uZ2VyIHJ1bm5pbmcKICAgICBpZiAobmVlZHNTZXJ2aWNlIDwgMCkgewog ICAgICAgICBpZiAobV9hbmltYXRpb25UaW1lci5pc0FjdGl2ZSgpKQogICAgICAgICAgICAgbV9h bmltYXRpb25UaW1lci5zdG9wKCk7CiAgICAgICAgIHJldHVybjsKICAgICB9Ci0gICAgCisKICAg ICAvLyBPdGhlcndpc2UsIHdlIHdhbnQgdG8gc3RhcnQgYSBvbmUtc2hvdCB0aW1lciBzbyB3ZSBn ZXQgaGVyZSBhZ2FpbgogICAgIGlmIChtX2FuaW1hdGlvblRpbWVyLmlzQWN0aXZlKCkpCiAgICAg ICAgIG1fYW5pbWF0aW9uVGltZXIuc3RvcCgpOwpAQCAtMTQzLDcgKzE1MSw3IEBAIHZvaWQgQW5p bWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmZpcmVFdmVudHNBbmRVcGRhdGVTdHlsZSgpCiAgICAg UmVmUHRyPEZyYW1lPiBwcm90ZWN0b3IgPSBtX2ZyYW1lOwogCiAgICAgYm9vbCB1cGRhdGVTdHls ZSA9ICFtX2V2ZW50c1RvRGlzcGF0Y2guaXNFbXB0eSgpIHx8ICFtX25vZGVDaGFuZ2VzVG9EaXNw YXRjaC5pc0VtcHR5KCk7Ci0gICAgCisKICAgICAvLyBmaXJlIGFsbCB0aGUgZXZlbnRzCiAgICAg VmVjdG9yPEV2ZW50VG9EaXNwYXRjaD4gZXZlbnRzVG9EaXNwYXRjaCA9IG1fZXZlbnRzVG9EaXNw YXRjaDsKICAgICBtX2V2ZW50c1RvRGlzcGF0Y2guY2xlYXIoKTsKQEAgLTE1NCwxNCArMTYyLDE0 IEBAIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmZpcmVFdmVudHNBbmRVcGRhdGVT dHlsZSgpCiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIGl0LT5lbGVtZW50LT5kaXNwYXRjaEV2 ZW50KFdlYktpdEFuaW1hdGlvbkV2ZW50OjpjcmVhdGUoaXQtPmV2ZW50VHlwZSwgaXQtPm5hbWUs IGl0LT5lbGFwc2VkVGltZSkpOwogICAgIH0KLSAgICAKKwogICAgIC8vIGNhbGwgc2V0Q2hhbmdl ZCBvbiBhbGwgdGhlIGVsZW1lbnRzCiAgICAgVmVjdG9yPFJlZlB0cjxOb2RlPiA+Ojpjb25zdF9p dGVyYXRvciBub2RlQ2hhbmdlc1RvRGlzcGF0Y2hFbmQgPSBtX25vZGVDaGFuZ2VzVG9EaXNwYXRj aC5lbmQoKTsKICAgICBmb3IgKFZlY3RvcjxSZWZQdHI8Tm9kZT4gPjo6Y29uc3RfaXRlcmF0b3Ig aXQgPSBtX25vZGVDaGFuZ2VzVG9EaXNwYXRjaC5iZWdpbigpOyBpdCAhPSBub2RlQ2hhbmdlc1Rv RGlzcGF0Y2hFbmQ7ICsraXQpCiAgICAgICAgICgqaXQpLT5zZXROZWVkc1N0eWxlUmVjYWxjKFN5 bnRoZXRpY1N0eWxlQ2hhbmdlKTsKLSAgICAKKwogICAgIG1fbm9kZUNoYW5nZXNUb0Rpc3BhdGNo LmNsZWFyKCk7Ci0gICAgCisKICAgICBpZiAodXBkYXRlU3R5bGUgJiYgbV9mcmFtZSkKICAgICAg ICAgbV9mcmFtZS0+ZG9jdW1lbnQoKS0+dXBkYXRlU3R5bGVJZk5lZWRlZCgpOwogfQpAQCAtMTk0 LDYgKzIwMiwxNiBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjphZGROb2RlQ2hh bmdlVG9EaXNwYXRjaChQYXNzUmVmUHRyPE5vZGU+IG5vZGUpCiAgICAgc3RhcnRVcGRhdGVTdHls ZUlmTmVlZGVkRGlzcGF0Y2hlcigpOwogfQogCisjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9O X0ZSQU1FKQordm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6YW5pbWF0aW9uRnJhbWVD YWxsYmFja0ZpcmVkKCkKK3sKKyAgICBkb3VibGUgbmVlZHNTZXJ2aWNlID0gdXBkYXRlQW5pbWF0 aW9ucyh0cnVlKTsKKworICAgIGlmIChuZWVkc1NlcnZpY2UgPj0gMCkKKyAgICAgICAgbV9mcmFt ZS0+ZG9jdW1lbnQoKS0+dmlldygpLT5zY2hlZHVsZUFuaW1hdGlvbigpOworfQorI2VuZGlmCisK IHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmFuaW1hdGlvblRpbWVyRmlyZWQoVGlt ZXI8QW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU+KikKIHsKICAgICAvLyBNYWtlIHN1cmUgYW5p bWF0aW9uVXBkYXRlVGltZSBpcyB1cGRhdGVkLCBzbyB0aGF0IGl0IGlzIGN1cnJlbnQgZXZlbiBp ZiBubwpAQCAtNDk5LDggKzUxNywxMSBAQCBQYXNzUmVmUHRyPFJlbmRlclN0eWxlPiBBbmltYXRp b25Db250cm9sbGVyOjp1cGRhdGVBbmltYXRpb25zKFJlbmRlck9iamVjdCogcmVuZAogICAgIFJl ZlB0cjxDb21wb3NpdGVBbmltYXRpb24+IHJlbmRlcmVyQW5pbWF0aW9ucyA9IG1fZGF0YS0+YWNj ZXNzQ29tcG9zaXRlQW5pbWF0aW9uKHJlbmRlcmVyKTsKICAgICBSZWZQdHI8UmVuZGVyU3R5bGU+ IGJsZW5kZWRTdHlsZSA9IHJlbmRlcmVyQW5pbWF0aW9ucy0+YW5pbWF0ZShyZW5kZXJlciwgb2xk U3R5bGUsIG5ld1N0eWxlKTsKIAotICAgIGlmIChyZW5kZXJlci0+cGFyZW50KCkgfHwgbmV3U3R5 bGUtPmFuaW1hdGlvbnMoKSB8fCAob2xkU3R5bGUgJiYgb2xkU3R5bGUtPmFuaW1hdGlvbnMoKSkp CisgICAgaWYgKHJlbmRlcmVyLT5wYXJlbnQoKSB8fCBuZXdTdHlsZS0+YW5pbWF0aW9ucygpIHx8 IChvbGRTdHlsZSAmJiBvbGRTdHlsZS0+YW5pbWF0aW9ucygpKSkgewogICAgICAgICBtX2RhdGEt PnVwZGF0ZUFuaW1hdGlvblRpbWVyKCk7CisgICAgICAgIGlmIChGcmFtZVZpZXcqIHZpZXcgPSBy ZW5kZXJlci0+ZG9jdW1lbnQoKS0+dmlldygpKQorICAgICAgICAgICAgdmlldy0+c2NoZWR1bGVB bmltYXRpb24oKTsKKyAgICB9CiAKICAgICBpZiAoYmxlbmRlZFN0eWxlICE9IG5ld1N0eWxlKSB7 CiAgICAgICAgIC8vIElmIHRoZSBhbmltYXRpb25zL3RyYW5zaXRpb25zIGNoYW5nZSBvcGFjaXR5 IG9yIHRyYW5zZm9ybSwgd2UgbmVlZCB0byB1cGRhdGUKQEAgLTU1Nyw2ICs1NzgsMTMgQEAgdm9p ZCBBbmltYXRpb25Db250cm9sbGVyOjpyZXN1bWVBbmltYXRpb25zKCkKICAgICBtX2RhdGEtPnJl c3VtZUFuaW1hdGlvbnMoKTsKIH0KIAorI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFN RSkKK3ZvaWQgQW5pbWF0aW9uQ29udHJvbGxlcjo6c2VydmljZUFuaW1hdGlvbnMoKQoreworICAg IG1fZGF0YS0+YW5pbWF0aW9uRnJhbWVDYWxsYmFja0ZpcmVkKCk7Cit9CisjZW5kaWYKKwogdm9p ZCBBbmltYXRpb25Db250cm9sbGVyOjpzdXNwZW5kQW5pbWF0aW9uc0ZvckRvY3VtZW50KERvY3Vt ZW50KiBkb2N1bWVudCkKIHsKICAgICBtX2RhdGEtPnN1c3BlbmRBbmltYXRpb25zRm9yRG9jdW1l bnQoZG9jdW1lbnQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24v QW5pbWF0aW9uQ29udHJvbGxlci5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5p bWF0aW9uQ29udHJvbGxlci5oCmluZGV4IGNjZGM2YzRhNDJkN2ExYjM1MDJkNzcwNzgwNzAxNjY5 NWUzNjRiNDguLjE4NzcyZGQ1OTM5NGFiODA0NjBmZDk2NTRkZjRmNzlkNTZlYmVhZWYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVy LmgKQEAgLTY2LDYgKzY2LDkgQEAgcHVibGljOgogCiAgICAgdm9pZCBzdXNwZW5kQW5pbWF0aW9u cygpOwogICAgIHZvaWQgcmVzdW1lQW5pbWF0aW9ucygpOworI2lmIEVOQUJMRShSRVFVRVNUX0FO SU1BVElPTl9GUkFNRSkKKyAgICB2b2lkIHNlcnZpY2VBbmltYXRpb25zKCk7CisjZW5kaWYKIAog ICAgIHZvaWQgc3VzcGVuZEFuaW1hdGlvbnNGb3JEb2N1bWVudChEb2N1bWVudCopOwogICAgIHZv aWQgcmVzdW1lQW5pbWF0aW9uc0ZvckRvY3VtZW50KERvY3VtZW50Kik7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZS5o IGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlclByaXZh dGUuaAppbmRleCA0MWVlYmZmMTZkZjVjOTNkMmFjZmE4NWJlNDk5MTdhMWQ0OGZlMDhlLi45Y2Ex NDIwYTEyODkxY2NiZjUxMDcwNDBlMmFmNzAyMGIxN2RjNzdjIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZS5oCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRl LmgKQEAgLTU3LDYgKzU3LDggQEAgcHVibGljOgogICAgIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2 YXRlKEZyYW1lKik7CiAgICAgfkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlKCk7CiAKKyAgICAv LyBSZXR1cm5zIHRoZSB0aW1lIHVudGlsIHRoZSBuZXh0IGFuaW1hdGlvbiBuZWVkcyB0byBiZSBz ZXJ2aWNlZCwgb3IgLTEgaWYgdGhlcmUgYXJlIG5vbmUuCisgICAgZG91YmxlIHVwZGF0ZUFuaW1h dGlvbnMoYm9vbCBjYWxsU2V0Q2hhbmdlZCA9IGZhbHNlKTsKICAgICB2b2lkIHVwZGF0ZUFuaW1h dGlvblRpbWVyKGJvb2wgY2FsbFNldENoYW5nZWQgPSBmYWxzZSk7CiAKICAgICBQYXNzUmVmUHRy PENvbXBvc2l0ZUFuaW1hdGlvbj4gYWNjZXNzQ29tcG9zaXRlQW5pbWF0aW9uKFJlbmRlck9iamVj dCopOwpAQCAtNzEsNiArNzMsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHN1c3BlbmRBbmltYXRp b25zKCk7CiAgICAgdm9pZCByZXN1bWVBbmltYXRpb25zKCk7CisjaWYgRU5BQkxFKFJFUVVFU1Rf QU5JTUFUSU9OX0ZSQU1FKQorICAgIHZvaWQgYW5pbWF0aW9uRnJhbWVDYWxsYmFja0ZpcmVkKCk7 CisjZW5kaWYKIAogICAgIHZvaWQgc3VzcGVuZEFuaW1hdGlvbnNGb3JEb2N1bWVudChEb2N1bWVu dCopOwogICAgIHZvaWQgcmVzdW1lQW5pbWF0aW9uc0ZvckRvY3VtZW50KERvY3VtZW50Kik7Cg== 122817 2012-01-17 14:52:21 -0800 2012-01-31 13:20:30 -0800 Removed old FIXME comment; fixed build by adding missing #if guard bug-64591-20120117175220.patch text/plain 8801 jgw U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1MTUxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzI2NjliYmFhOWMyMTZh MjBmMGY3YzQyYmUyNjc0YzE0Zjk1YjBjZi4uOTMyZmVlOWJhMjkwOTdiM2ZlNjVhZjMzNzUyYjIz OGFmMjQ0NWI4MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEyLTAxLTE3ICBKb2Vs IFdlYmJlciAgPGpnd0Bnb29nbGUuY29tPgorCisgICAgICAgIFVzZSByZXF1ZXN0QW5pbWF0aW9u RnJhbWUgY2FsbGJhY2tzIHRvIHB1bXAgQ1NTIGFuaW1hdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTkxCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLiAoT09QUyEpCisKKyAg ICAgICAgKiBwYWdlL0ZyYW1lVmlldy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpGcmFtZVZpZXc6 OnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMpOgorICAgICAgICAqIHBhZ2UvYW5pbWF0aW9uL0Fu aW1hdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0aW9uQ29udHJv bGxlclByaXZhdGU6OnVwZGF0ZUFuaW1hdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0 aW9uQ29udHJvbGxlclByaXZhdGU6OnVwZGF0ZUFuaW1hdGlvblRpbWVyKToKKyAgICAgICAgKFdl YkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjpmaXJlRXZlbnRzQW5kVXBkYXRlU3R5 bGUpOgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmFuaW1h dGlvbkZyYW1lQ2FsbGJhY2tGaXJlZCk6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250 cm9sbGVyOjp1cGRhdGVBbmltYXRpb25zKToKKyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNv bnRyb2xsZXI6OnNlcnZpY2VBbmltYXRpb25zKToKKyAgICAgICAgKiBwYWdlL2FuaW1hdGlvbi9B bmltYXRpb25Db250cm9sbGVyLmg6CisgICAgICAgICogcGFnZS9hbmltYXRpb24vQW5pbWF0aW9u Q29udHJvbGxlclByaXZhdGUuaDoKKwogMjAxMi0wMS0xNyAgTmlrb2xhcyBaaW1tZXJtYW5uICA8 bnppbW1lcm1hbm5AcmltLmNvbT4KIAogICAgICAgICBMYXJnZSBTVkcgdGV4dCBsYXlvdXQgcGVy Zm9ybWFuY2UgcmVncmVzc2lvbiBpbiByODExNjgKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvRnJhbWVWaWV3LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcApp bmRleCAxN2M5ZGVjZjBiOWRiYmUzNWZkNDJkZWIwNjM4NjMyNTQ0OWMzODhlLi42ZTBjYjBmNWE4 NTNhYjg4OTYyOTQ0MjU3N2NjMWIwY2FmZTE1MTU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wYWdlL0ZyYW1lVmlldy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcu Y3BwCkBAIC0yMTA1LDggKzIxMDUsMTEgQEAgdm9pZCBGcmFtZVZpZXc6OnVuc2NoZWR1bGVSZWxh eW91dCgpCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQogdm9pZCBGcmFtZVZp ZXc6OnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMoRE9NVGltZVN0YW1wIHRpbWUpCiB7Ci0gICAg VmVjdG9yPFJlZlB0cjxEb2N1bWVudD4gPiBkb2N1bWVudHM7CisgICAgVmVjdG9yPEFuaW1hdGlv bkNvbnRyb2xsZXIqPiBhbmltYXRpb25zOworICAgIGZvciAoRnJhbWUqIGZyYW1lID0gbV9mcmFt ZS5nZXQoKTsgZnJhbWU7IGZyYW1lID0gZnJhbWUtPnRyZWUoKS0+dHJhdmVyc2VOZXh0KCkpCisg ICAgICAgIGZyYW1lLT5hbmltYXRpb24oKS0+c2VydmljZUFuaW1hdGlvbnMoKTsKIAorICAgIFZl Y3RvcjxSZWZQdHI8RG9jdW1lbnQ+ID4gZG9jdW1lbnRzOwogICAgIGZvciAoRnJhbWUqIGZyYW1l ID0gbV9mcmFtZS5nZXQoKTsgZnJhbWU7IGZyYW1lID0gZnJhbWUtPnRyZWUoKS0+dHJhdmVyc2VO ZXh0KCkpCiAgICAgICAgIGRvY3VtZW50cy5hcHBlbmQoZnJhbWUtPmRvY3VtZW50KCkpOwogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9s bGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xs ZXIuY3BwCmluZGV4IDc0NWQ1MTQ2YjkxOGVkMDUwZjc4ZjFiNDJhMjkyYjVhMWZhNGRhYTAuLjYx ZTgxOTZlNjc3MDU2OTMwZmZkZDBmNGQ5MDhhOTU4YjIzZTBmNjAgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuY3BwCkBAIC0z NSw2ICszNSw3IEBACiAjaW5jbHVkZSAiQ29tcG9zaXRlQW5pbWF0aW9uLmgiCiAjaW5jbHVkZSAi RXZlbnROYW1lcy5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiRnJhbWVWaWV3Lmgi CiAjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgogI2luY2x1ZGUgIldlYktpdEFuaW1hdGlvbkV2ZW50 LmgiCiAjaW5jbHVkZSAiV2ViS2l0QW5pbWF0aW9uTGlzdC5oIgpAQCAtNDQsNyArNDUsNiBAQAog CiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLS8vIEZJWE1FOiBXaHkgaXNuJ3QgdGhpcyBzZXQgdG8g NjBmcHMgb3Igc29tZXRoaW5nPwogc3RhdGljIGNvbnN0IGRvdWJsZSBjQW5pbWF0aW9uVGltZXJE ZWxheSA9IDAuMDI1Owogc3RhdGljIGNvbnN0IGRvdWJsZSBjQmVnaW5BbmltYXRpb25VcGRhdGVU aW1lTm90U2V0ID0gLTE7CiAKQEAgLTg0LDcgKzg0LDcgQEAgYm9vbCBBbmltYXRpb25Db250cm9s bGVyUHJpdmF0ZTo6Y2xlYXIoUmVuZGVyT2JqZWN0KiByZW5kZXJlcikKICAgICByZXR1cm4gYW5p bWF0aW9uLT5zdXNwZW5kZWQoKTsKIH0KIAotdm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0 ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0Q2hhbmdlZC8qID0gZmFsc2UqLykK K2RvdWJsZSBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6dXBkYXRlQW5pbWF0aW9ucyhib29s IGNhbGxTZXRDaGFuZ2VkLyogPSBmYWxzZSovKQogewogICAgIGRvdWJsZSBuZWVkc1NlcnZpY2Ug PSAtMTsKICAgICBib29sIGNhbGxlZFNldENoYW5nZWQgPSBmYWxzZTsKQEAgLTEwOCwyNCArMTA4 LDMxIEBAIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OnVwZGF0ZUFuaW1hdGlvblRp bWVyKGJvb2wgY2FsbFNldENoYW5nZWQvKiA9IGZhCiAgICAgICAgICAgICB9CiAgICAgICAgIH0K ICAgICB9Ci0gICAgCisKICAgICBpZiAoY2FsbGVkU2V0Q2hhbmdlZCkKICAgICAgICAgbV9mcmFt ZS0+ZG9jdW1lbnQoKS0+dXBkYXRlU3R5bGVJZk5lZWRlZCgpOwotICAgIAorCisgICAgcmV0dXJu IG5lZWRzU2VydmljZTsKK30KKwordm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6dXBk YXRlQW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0Q2hhbmdlZC8qID0gZmFsc2UqLykKK3sKKyAg ICBkb3VibGUgbmVlZHNTZXJ2aWNlID0gdXBkYXRlQW5pbWF0aW9ucyhjYWxsU2V0Q2hhbmdlZCk7 CisKICAgICAvLyBJZiB3ZSB3YW50IHNlcnZpY2UgaW1tZWRpYXRlbHksIHdlIHN0YXJ0IGEgcmVw ZWF0aW5nIHRpbWVyIHRvIHJlZHVjZSB0aGUgb3ZlcmhlYWQgb2Ygc3RhcnRpbmcKICAgICBpZiAo bmVlZHNTZXJ2aWNlID09IDApIHsKICAgICAgICAgaWYgKCFtX2FuaW1hdGlvblRpbWVyLmlzQWN0 aXZlKCkgfHwgbV9hbmltYXRpb25UaW1lci5yZXBlYXRJbnRlcnZhbCgpID09IDApCiAgICAgICAg ICAgICBtX2FuaW1hdGlvblRpbWVyLnN0YXJ0UmVwZWF0aW5nKGNBbmltYXRpb25UaW1lckRlbGF5 KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KLSAgICAKKwogICAgIC8vIElmIHdlIGRvbid0IG5l ZWQgc2VydmljZSwgd2Ugd2FudCB0byBtYWtlIHN1cmUgdGhlIHRpbWVyIGlzIG5vIGxvbmdlciBy dW5uaW5nCiAgICAgaWYgKG5lZWRzU2VydmljZSA8IDApIHsKICAgICAgICAgaWYgKG1fYW5pbWF0 aW9uVGltZXIuaXNBY3RpdmUoKSkKICAgICAgICAgICAgIG1fYW5pbWF0aW9uVGltZXIuc3RvcCgp OwogICAgICAgICByZXR1cm47CiAgICAgfQotICAgIAorCiAgICAgLy8gT3RoZXJ3aXNlLCB3ZSB3 YW50IHRvIHN0YXJ0IGEgb25lLXNob3QgdGltZXIgc28gd2UgZ2V0IGhlcmUgYWdhaW4KICAgICBp ZiAobV9hbmltYXRpb25UaW1lci5pc0FjdGl2ZSgpKQogICAgICAgICBtX2FuaW1hdGlvblRpbWVy LnN0b3AoKTsKQEAgLTE0Myw3ICsxNTAsNyBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2 YXRlOjpmaXJlRXZlbnRzQW5kVXBkYXRlU3R5bGUoKQogICAgIFJlZlB0cjxGcmFtZT4gcHJvdGVj dG9yID0gbV9mcmFtZTsKIAogICAgIGJvb2wgdXBkYXRlU3R5bGUgPSAhbV9ldmVudHNUb0Rpc3Bh dGNoLmlzRW1wdHkoKSB8fCAhbV9ub2RlQ2hhbmdlc1RvRGlzcGF0Y2guaXNFbXB0eSgpOwotICAg IAorCiAgICAgLy8gZmlyZSBhbGwgdGhlIGV2ZW50cwogICAgIFZlY3RvcjxFdmVudFRvRGlzcGF0 Y2g+IGV2ZW50c1RvRGlzcGF0Y2ggPSBtX2V2ZW50c1RvRGlzcGF0Y2g7CiAgICAgbV9ldmVudHNU b0Rpc3BhdGNoLmNsZWFyKCk7CkBAIC0xNTQsMTQgKzE2MSwxNCBAQCB2b2lkIEFuaW1hdGlvbkNv bnRyb2xsZXJQcml2YXRlOjpmaXJlRXZlbnRzQW5kVXBkYXRlU3R5bGUoKQogICAgICAgICBlbHNl CiAgICAgICAgICAgICBpdC0+ZWxlbWVudC0+ZGlzcGF0Y2hFdmVudChXZWJLaXRBbmltYXRpb25F dmVudDo6Y3JlYXRlKGl0LT5ldmVudFR5cGUsIGl0LT5uYW1lLCBpdC0+ZWxhcHNlZFRpbWUpKTsK ICAgICB9Ci0gICAgCisKICAgICAvLyBjYWxsIHNldENoYW5nZWQgb24gYWxsIHRoZSBlbGVtZW50 cwogICAgIFZlY3RvcjxSZWZQdHI8Tm9kZT4gPjo6Y29uc3RfaXRlcmF0b3Igbm9kZUNoYW5nZXNU b0Rpc3BhdGNoRW5kID0gbV9ub2RlQ2hhbmdlc1RvRGlzcGF0Y2guZW5kKCk7CiAgICAgZm9yIChW ZWN0b3I8UmVmUHRyPE5vZGU+ID46OmNvbnN0X2l0ZXJhdG9yIGl0ID0gbV9ub2RlQ2hhbmdlc1Rv RGlzcGF0Y2guYmVnaW4oKTsgaXQgIT0gbm9kZUNoYW5nZXNUb0Rpc3BhdGNoRW5kOyArK2l0KQog ICAgICAgICAoKml0KS0+c2V0TmVlZHNTdHlsZVJlY2FsYyhTeW50aGV0aWNTdHlsZUNoYW5nZSk7 Ci0gICAgCisKICAgICBtX25vZGVDaGFuZ2VzVG9EaXNwYXRjaC5jbGVhcigpOwotICAgIAorCiAg ICAgaWYgKHVwZGF0ZVN0eWxlICYmIG1fZnJhbWUpCiAgICAgICAgIG1fZnJhbWUtPmRvY3VtZW50 KCktPnVwZGF0ZVN0eWxlSWZOZWVkZWQoKTsKIH0KQEAgLTE5NCw2ICsyMDEsMTYgQEAgdm9pZCBB bmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6YWRkTm9kZUNoYW5nZVRvRGlzcGF0Y2goUGFzc1Jl ZlB0cjxOb2RlPiBub2RlKQogICAgIHN0YXJ0VXBkYXRlU3R5bGVJZk5lZWRlZERpc3BhdGNoZXIo KTsKIH0KIAorI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKK3ZvaWQgQW5pbWF0 aW9uQ29udHJvbGxlclByaXZhdGU6OmFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tGaXJlZCgpCit7Cisg ICAgZG91YmxlIG5lZWRzU2VydmljZSA9IHVwZGF0ZUFuaW1hdGlvbnModHJ1ZSk7CisKKyAgICBp ZiAobmVlZHNTZXJ2aWNlID49IDApCisgICAgICAgIG1fZnJhbWUtPmRvY3VtZW50KCktPnZpZXco KS0+c2NoZWR1bGVBbmltYXRpb24oKTsKK30KKyNlbmRpZgorCiB2b2lkIEFuaW1hdGlvbkNvbnRy b2xsZXJQcml2YXRlOjphbmltYXRpb25UaW1lckZpcmVkKFRpbWVyPEFuaW1hdGlvbkNvbnRyb2xs ZXJQcml2YXRlPiopCiB7CiAgICAgLy8gTWFrZSBzdXJlIGFuaW1hdGlvblVwZGF0ZVRpbWUgaXMg dXBkYXRlZCwgc28gdGhhdCBpdCBpcyBjdXJyZW50IGV2ZW4gaWYgbm8KQEAgLTQ5OSw4ICs1MTYs MTMgQEAgUGFzc1JlZlB0cjxSZW5kZXJTdHlsZT4gQW5pbWF0aW9uQ29udHJvbGxlcjo6dXBkYXRl QW5pbWF0aW9ucyhSZW5kZXJPYmplY3QqIHJlbmQKICAgICBSZWZQdHI8Q29tcG9zaXRlQW5pbWF0 aW9uPiByZW5kZXJlckFuaW1hdGlvbnMgPSBtX2RhdGEtPmFjY2Vzc0NvbXBvc2l0ZUFuaW1hdGlv bihyZW5kZXJlcik7CiAgICAgUmVmUHRyPFJlbmRlclN0eWxlPiBibGVuZGVkU3R5bGUgPSByZW5k ZXJlckFuaW1hdGlvbnMtPmFuaW1hdGUocmVuZGVyZXIsIG9sZFN0eWxlLCBuZXdTdHlsZSk7CiAK LSAgICBpZiAocmVuZGVyZXItPnBhcmVudCgpIHx8IG5ld1N0eWxlLT5hbmltYXRpb25zKCkgfHwg KG9sZFN0eWxlICYmIG9sZFN0eWxlLT5hbmltYXRpb25zKCkpKQorICAgIGlmIChyZW5kZXJlci0+ cGFyZW50KCkgfHwgbmV3U3R5bGUtPmFuaW1hdGlvbnMoKSB8fCAob2xkU3R5bGUgJiYgb2xkU3R5 bGUtPmFuaW1hdGlvbnMoKSkpIHsKICAgICAgICAgbV9kYXRhLT51cGRhdGVBbmltYXRpb25UaW1l cigpOworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKKyAgICAgICAgaWYgKEZy YW1lVmlldyogdmlldyA9IHJlbmRlcmVyLT5kb2N1bWVudCgpLT52aWV3KCkpCisgICAgICAgICAg ICB2aWV3LT5zY2hlZHVsZUFuaW1hdGlvbigpOworI2VuZGlmCisgICAgfQogCiAgICAgaWYgKGJs ZW5kZWRTdHlsZSAhPSBuZXdTdHlsZSkgewogICAgICAgICAvLyBJZiB0aGUgYW5pbWF0aW9ucy90 cmFuc2l0aW9ucyBjaGFuZ2Ugb3BhY2l0eSBvciB0cmFuc2Zvcm0sIHdlIG5lZWQgdG8gdXBkYXRl CkBAIC01NTcsNiArNTc5LDEzIEBAIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlcjo6cmVzdW1lQW5p bWF0aW9ucygpCiAgICAgbV9kYXRhLT5yZXN1bWVBbmltYXRpb25zKCk7CiB9CiAKKyNpZiBFTkFC TEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCit2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXI6OnNl cnZpY2VBbmltYXRpb25zKCkKK3sKKyAgICBtX2RhdGEtPmFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tG aXJlZCgpOworfQorI2VuZGlmCisKIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlcjo6c3VzcGVuZEFu aW1hdGlvbnNGb3JEb2N1bWVudChEb2N1bWVudCogZG9jdW1lbnQpCiB7CiAgICAgbV9kYXRhLT5z dXNwZW5kQW5pbWF0aW9uc0ZvckRvY3VtZW50KGRvY3VtZW50KTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuaCBiL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuaAppbmRleCBjY2RjNmM0 YTQyZDdhMWIzNTAyZDc3MDc4MDcwMTY2OTVlMzY0YjQ4Li4xODc3MmRkNTkzOTRhYjgwNDYwZmQ5 NjU0ZGY0Zjc5ZDU2ZWJlYWVmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1h dGlvbi9BbmltYXRpb25Db250cm9sbGVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmlt YXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5oCkBAIC02Niw2ICs2Niw5IEBAIHB1YmxpYzoKIAog ICAgIHZvaWQgc3VzcGVuZEFuaW1hdGlvbnMoKTsKICAgICB2b2lkIHJlc3VtZUFuaW1hdGlvbnMo KTsKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCisgICAgdm9pZCBzZXJ2aWNl QW5pbWF0aW9ucygpOworI2VuZGlmCiAKICAgICB2b2lkIHN1c3BlbmRBbmltYXRpb25zRm9yRG9j dW1lbnQoRG9jdW1lbnQqKTsKICAgICB2b2lkIHJlc3VtZUFuaW1hdGlvbnNGb3JEb2N1bWVudChE b2N1bWVudCopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5p bWF0aW9uQ29udHJvbGxlclByaXZhdGUuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9u L0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmgKaW5kZXggNDFlZWJmZjE2ZGY1YzkzZDJhY2Zh ODViZTQ5OTE3YTFkNDhmZTA4ZS4uOWNhMTQyMGExMjg5MWNjYmY1MTA3MDQwZTJhZjcwMjBiMTdk Yzc3YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9u Q29udHJvbGxlclByaXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9B bmltYXRpb25Db250cm9sbGVyUHJpdmF0ZS5oCkBAIC01Nyw2ICs1Nyw4IEBAIHB1YmxpYzoKICAg ICBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZShGcmFtZSopOwogICAgIH5BbmltYXRpb25Db250 cm9sbGVyUHJpdmF0ZSgpOwogCisgICAgLy8gUmV0dXJucyB0aGUgdGltZSB1bnRpbCB0aGUgbmV4 dCBhbmltYXRpb24gbmVlZHMgdG8gYmUgc2VydmljZWQsIG9yIC0xIGlmIHRoZXJlIGFyZSBub25l LgorICAgIGRvdWJsZSB1cGRhdGVBbmltYXRpb25zKGJvb2wgY2FsbFNldENoYW5nZWQgPSBmYWxz ZSk7CiAgICAgdm9pZCB1cGRhdGVBbmltYXRpb25UaW1lcihib29sIGNhbGxTZXRDaGFuZ2VkID0g ZmFsc2UpOwogCiAgICAgUGFzc1JlZlB0cjxDb21wb3NpdGVBbmltYXRpb24+IGFjY2Vzc0NvbXBv c2l0ZUFuaW1hdGlvbihSZW5kZXJPYmplY3QqKTsKQEAgLTcxLDYgKzczLDkgQEAgcHVibGljOgog CiAgICAgdm9pZCBzdXNwZW5kQW5pbWF0aW9ucygpOwogICAgIHZvaWQgcmVzdW1lQW5pbWF0aW9u cygpOworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKKyAgICB2b2lkIGFuaW1h dGlvbkZyYW1lQ2FsbGJhY2tGaXJlZCgpOworI2VuZGlmCiAKICAgICB2b2lkIHN1c3BlbmRBbmlt YXRpb25zRm9yRG9jdW1lbnQoRG9jdW1lbnQqKTsKICAgICB2b2lkIHJlc3VtZUFuaW1hdGlvbnNG b3JEb2N1bWVudChEb2N1bWVudCopOwo= 124808 2012-01-31 13:20:36 -0800 2012-01-31 13:30:40 -0800 Renamed a few things for clarity. Updated become-overlay-composited-layer test to not be flaky. Updated test expectations in anticipation of rebaselining. bug-64591-20120131162035.patch text/plain 31933 jgw U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2MzgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMmNiNWU0NWZjMDAyNDkx MWM3NDg2MWFiMWU3ZTczOTM2Zjc1NDgzZS4uMDc5OTNlY2M3Y2QyOTVjNTdmZjMzNDljMTFkOGZi ZTAzMDUyMWJkOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEyLTAxLTMxICBKb2Vs IFdlYmJlciAgPGpnd0Bnb29nbGUuY29tPgorCisgICAgICAgIFVzZSByZXF1ZXN0QW5pbWF0aW9u RnJhbWUgY2FsbGJhY2tzIHRvIHB1bXAgQ1NTIGFuaW1hdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTkxCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIG5lZWRlZCAoY292ZXJl ZCBieSB0ZXN0cyBpbiBhbmltYXRpb25zLyopLgorCisgICAgICAgICogcGFnZS9GcmFtZVZpZXcu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVWaWV3OjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRp b25zKToKKyAgICAgICAgKiBwYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmlt YXRpb25zKToKKyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1 cGRhdGVBbmltYXRpb25UaW1lcik6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250cm9s bGVyUHJpdmF0ZTo6ZmlyZUV2ZW50c0FuZFVwZGF0ZVN0eWxlKToKKyAgICAgICAgKFdlYkNvcmU6 OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjphbmltYXRpb25GcmFtZUNhbGxiYWNrRmlyZWQp OgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0aW9uQ29udHJvbGxlcjo6dXBkYXRlQW5pbWF0aW9u cyk6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250cm9sbGVyOjpzZXJ2aWNlQW5pbWF0 aW9ucyk6CisgICAgICAgICogcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5oOgor ICAgICAgICAqIHBhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmg6CisK IDIwMTItMDEtMzEgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAg Q3Jhc2ggaW4gRGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJhbERlbGV0ZSB3aGVu IGF0dGVtcHRpbmcgdG8gZGVsZXRlIHRoZSBzdGFydCBibG9jawpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZp ZXcuY3BwCmluZGV4IGFjY2VkYWQ5ZWMxOTNmMzI3MmRlYjZlYjI1ZjJjMGYxYWJlYzU4ZmUuLjhj NGZiYTg2M2EzNjQ1ZDliOTliMzAyMDFjMzE2NTNlZjA3YjE3NjIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0Zy YW1lVmlldy5jcHAKQEAgLTIwOTcsOCArMjA5NywxMSBAQCB2b2lkIEZyYW1lVmlldzo6dW5zY2hl ZHVsZVJlbGF5b3V0KCkKICNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCiB2b2lk IEZyYW1lVmlldzo6c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyhET01UaW1lU3RhbXAgdGltZSkK IHsKLSAgICBWZWN0b3I8UmVmUHRyPERvY3VtZW50PiA+IGRvY3VtZW50czsKKyAgICBWZWN0b3I8 QW5pbWF0aW9uQ29udHJvbGxlcio+IGFuaW1hdGlvbnM7CisgICAgZm9yIChGcmFtZSogZnJhbWUg PSBtX2ZyYW1lLmdldCgpOyBmcmFtZTsgZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50cmF2ZXJzZU5l eHQoKSkKKyAgICAgICAgZnJhbWUtPmFuaW1hdGlvbigpLT5zZXJ2aWNlQW5pbWF0aW9ucygpOwog CisgICAgVmVjdG9yPFJlZlB0cjxEb2N1bWVudD4gPiBkb2N1bWVudHM7CiAgICAgZm9yIChGcmFt ZSogZnJhbWUgPSBtX2ZyYW1lLmdldCgpOyBmcmFtZTsgZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50 cmF2ZXJzZU5leHQoKSkKICAgICAgICAgZG9jdW1lbnRzLmFwcGVuZChmcmFtZS0+ZG9jdW1lbnQo KSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlv bkNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9u Q29udHJvbGxlci5jcHAKaW5kZXggNzQ1ZDUxNDZiOTE4ZWQwNTBmNzhmMWI0MmEyOTJiNWExZmE0 ZGFhMC4uZWI2ZmFkZWIxY2MwMzkxNTEwNzNhMjE1NDQyNmFhNjYyZjAwZjc0MCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5j cHAKQEAgLTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlICJDb21wb3NpdGVBbmltYXRpb24uaCIKICNp bmNsdWRlICJFdmVudE5hbWVzLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFt ZVZpZXcuaCIKICNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCiAjaW5jbHVkZSAiV2ViS2l0QW5pbWF0 aW9uRXZlbnQuaCIKICNpbmNsdWRlICJXZWJLaXRBbmltYXRpb25MaXN0LmgiCkBAIC00NCw3ICs0 NSw2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotLy8gRklYTUU6IFdoeSBpc24ndCB0aGlz IHNldCB0byA2MGZwcyBvciBzb21ldGhpbmc/CiBzdGF0aWMgY29uc3QgZG91YmxlIGNBbmltYXRp b25UaW1lckRlbGF5ID0gMC4wMjU7CiBzdGF0aWMgY29uc3QgZG91YmxlIGNCZWdpbkFuaW1hdGlv blVwZGF0ZVRpbWVOb3RTZXQgPSAtMTsKIApAQCAtODQsOSArODQsOSBAQCBib29sIEFuaW1hdGlv bkNvbnRyb2xsZXJQcml2YXRlOjpjbGVhcihSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogICAgIHJl dHVybiBhbmltYXRpb24tPnN1c3BlbmRlZCgpOwogfQogCi12b2lkIEFuaW1hdGlvbkNvbnRyb2xs ZXJQcml2YXRlOjp1cGRhdGVBbmltYXRpb25UaW1lcihib29sIGNhbGxTZXRDaGFuZ2VkLyogPSBm YWxzZSovKQorZG91YmxlIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmltYXRp b25zKFNldENoYW5nZWQgY2FsbFNldENoYW5nZWQvKiA9IERvTm90Q2FsbFNldENoYW5nZWQqLykK IHsKLSAgICBkb3VibGUgbmVlZHNTZXJ2aWNlID0gLTE7CisgICAgZG91YmxlIHRpbWVUb05leHRT ZXJ2aWNlID0gLTE7CiAgICAgYm9vbCBjYWxsZWRTZXRDaGFuZ2VkID0gZmFsc2U7CiAKICAgICBS ZW5kZXJPYmplY3RBbmltYXRpb25NYXA6OmNvbnN0X2l0ZXJhdG9yIGFuaW1hdGlvbnNFbmQgPSBt X2NvbXBvc2l0ZUFuaW1hdGlvbnMuZW5kKCk7CkBAIC05NCwxMCArOTQsMTAgQEAgdm9pZCBBbmlt YXRpb25Db250cm9sbGVyUHJpdmF0ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0 Q2hhbmdlZC8qID0gZmEKICAgICAgICAgQ29tcG9zaXRlQW5pbWF0aW9uKiBjb21wQW5pbSA9IGl0 LT5zZWNvbmQuZ2V0KCk7CiAgICAgICAgIGlmICghY29tcEFuaW0tPnN1c3BlbmRlZCgpICYmIGNv bXBBbmltLT5oYXNBbmltYXRpb25zKCkpIHsKICAgICAgICAgICAgIGRvdWJsZSB0ID0gY29tcEFu aW0tPnRpbWVUb05leHRTZXJ2aWNlKCk7Ci0gICAgICAgICAgICBpZiAodCAhPSAtMSAmJiAodCA8 IG5lZWRzU2VydmljZSB8fCBuZWVkc1NlcnZpY2UgPT0gLTEpKQotICAgICAgICAgICAgICAgIG5l ZWRzU2VydmljZSA9IHQ7Ci0gICAgICAgICAgICBpZiAobmVlZHNTZXJ2aWNlID09IDApIHsKLSAg ICAgICAgICAgICAgICBpZiAoY2FsbFNldENoYW5nZWQpIHsKKyAgICAgICAgICAgIGlmICh0ICE9 IC0xICYmICh0IDwgdGltZVRvTmV4dFNlcnZpY2UgfHwgdGltZVRvTmV4dFNlcnZpY2UgPT0gLTEp KQorICAgICAgICAgICAgICAgIHRpbWVUb05leHRTZXJ2aWNlID0gdDsKKyAgICAgICAgICAgIGlm ICh0aW1lVG9OZXh0U2VydmljZSA9PSAwKSB7CisgICAgICAgICAgICAgICAgaWYgKGNhbGxTZXRD aGFuZ2VkID09IENhbGxTZXRDaGFuZ2VkKSB7CiAgICAgICAgICAgICAgICAgICAgIE5vZGUqIG5v ZGUgPSBpdC0+Zmlyc3QtPm5vZGUoKTsKICAgICAgICAgICAgICAgICAgICAgQVNTRVJUKCFub2Rl IHx8IChub2RlLT5kb2N1bWVudCgpICYmICFub2RlLT5kb2N1bWVudCgpLT5pblBhZ2VDYWNoZSgp KSk7CiAgICAgICAgICAgICAgICAgICAgIG5vZGUtPnNldE5lZWRzU3R5bGVSZWNhbGMoU3ludGhl dGljU3R5bGVDaGFuZ2UpOwpAQCAtMTA4LDI4ICsxMDgsMzUgQEAgdm9pZCBBbmltYXRpb25Db250 cm9sbGVyUHJpdmF0ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0Q2hhbmdlZC8q ID0gZmEKICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KLSAgICAKKwogICAgIGlmIChj YWxsZWRTZXRDaGFuZ2VkKQogICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT51cGRhdGVTdHls ZUlmTmVlZGVkKCk7Ci0gICAgCisKKyAgICByZXR1cm4gdGltZVRvTmV4dFNlcnZpY2U7Cit9CisK K3ZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OnVwZGF0ZUFuaW1hdGlvblRpbWVyKFNl dENoYW5nZWQgY2FsbFNldENoYW5nZWQvKiA9IERvTm90Q2FsbFNldENoYW5nZWQqLykKK3sKKyAg ICBkb3VibGUgdGltZVRvTmV4dFNlcnZpY2UgPSB1cGRhdGVBbmltYXRpb25zKGNhbGxTZXRDaGFu Z2VkKTsKKwogICAgIC8vIElmIHdlIHdhbnQgc2VydmljZSBpbW1lZGlhdGVseSwgd2Ugc3RhcnQg YSByZXBlYXRpbmcgdGltZXIgdG8gcmVkdWNlIHRoZSBvdmVyaGVhZCBvZiBzdGFydGluZwotICAg IGlmIChuZWVkc1NlcnZpY2UgPT0gMCkgeworICAgIGlmICh0aW1lVG9OZXh0U2VydmljZSA9PSAw KSB7CiAgICAgICAgIGlmICghbV9hbmltYXRpb25UaW1lci5pc0FjdGl2ZSgpIHx8IG1fYW5pbWF0 aW9uVGltZXIucmVwZWF0SW50ZXJ2YWwoKSA9PSAwKQogICAgICAgICAgICAgbV9hbmltYXRpb25U aW1lci5zdGFydFJlcGVhdGluZyhjQW5pbWF0aW9uVGltZXJEZWxheSk7CiAgICAgICAgIHJldHVy bjsKICAgICB9Ci0gICAgCisKICAgICAvLyBJZiB3ZSBkb24ndCBuZWVkIHNlcnZpY2UsIHdlIHdh bnQgdG8gbWFrZSBzdXJlIHRoZSB0aW1lciBpcyBubyBsb25nZXIgcnVubmluZwotICAgIGlmIChu ZWVkc1NlcnZpY2UgPCAwKSB7CisgICAgaWYgKHRpbWVUb05leHRTZXJ2aWNlIDwgMCkgewogICAg ICAgICBpZiAobV9hbmltYXRpb25UaW1lci5pc0FjdGl2ZSgpKQogICAgICAgICAgICAgbV9hbmlt YXRpb25UaW1lci5zdG9wKCk7CiAgICAgICAgIHJldHVybjsKICAgICB9Ci0gICAgCisKICAgICAv LyBPdGhlcndpc2UsIHdlIHdhbnQgdG8gc3RhcnQgYSBvbmUtc2hvdCB0aW1lciBzbyB3ZSBnZXQg aGVyZSBhZ2FpbgogICAgIGlmIChtX2FuaW1hdGlvblRpbWVyLmlzQWN0aXZlKCkpCiAgICAgICAg IG1fYW5pbWF0aW9uVGltZXIuc3RvcCgpOwotICAgIG1fYW5pbWF0aW9uVGltZXIuc3RhcnRPbmVT aG90KG5lZWRzU2VydmljZSk7CisgICAgbV9hbmltYXRpb25UaW1lci5zdGFydE9uZVNob3QodGlt ZVRvTmV4dFNlcnZpY2UpOwogfQogCiB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1 cGRhdGVTdHlsZUlmTmVlZGVkRGlzcGF0Y2hlckZpcmVkKFRpbWVyPEFuaW1hdGlvbkNvbnRyb2xs ZXJQcml2YXRlPiopCkBAIC0xNDMsNyArMTUwLDcgQEAgdm9pZCBBbmltYXRpb25Db250cm9sbGVy UHJpdmF0ZTo6ZmlyZUV2ZW50c0FuZFVwZGF0ZVN0eWxlKCkKICAgICBSZWZQdHI8RnJhbWU+IHBy b3RlY3RvciA9IG1fZnJhbWU7CiAKICAgICBib29sIHVwZGF0ZVN0eWxlID0gIW1fZXZlbnRzVG9E aXNwYXRjaC5pc0VtcHR5KCkgfHwgIW1fbm9kZUNoYW5nZXNUb0Rpc3BhdGNoLmlzRW1wdHkoKTsK LSAgICAKKwogICAgIC8vIGZpcmUgYWxsIHRoZSBldmVudHMKICAgICBWZWN0b3I8RXZlbnRUb0Rp c3BhdGNoPiBldmVudHNUb0Rpc3BhdGNoID0gbV9ldmVudHNUb0Rpc3BhdGNoOwogICAgIG1fZXZl bnRzVG9EaXNwYXRjaC5jbGVhcigpOwpAQCAtMTU0LDE0ICsxNjEsMTQgQEAgdm9pZCBBbmltYXRp b25Db250cm9sbGVyUHJpdmF0ZTo6ZmlyZUV2ZW50c0FuZFVwZGF0ZVN0eWxlKCkKICAgICAgICAg ZWxzZQogICAgICAgICAgICAgaXQtPmVsZW1lbnQtPmRpc3BhdGNoRXZlbnQoV2ViS2l0QW5pbWF0 aW9uRXZlbnQ6OmNyZWF0ZShpdC0+ZXZlbnRUeXBlLCBpdC0+bmFtZSwgaXQtPmVsYXBzZWRUaW1l KSk7CiAgICAgfQotICAgIAorCiAgICAgLy8gY2FsbCBzZXRDaGFuZ2VkIG9uIGFsbCB0aGUgZWxl bWVudHMKICAgICBWZWN0b3I8UmVmUHRyPE5vZGU+ID46OmNvbnN0X2l0ZXJhdG9yIG5vZGVDaGFu Z2VzVG9EaXNwYXRjaEVuZCA9IG1fbm9kZUNoYW5nZXNUb0Rpc3BhdGNoLmVuZCgpOwogICAgIGZv ciAoVmVjdG9yPFJlZlB0cjxOb2RlPiA+Ojpjb25zdF9pdGVyYXRvciBpdCA9IG1fbm9kZUNoYW5n ZXNUb0Rpc3BhdGNoLmJlZ2luKCk7IGl0ICE9IG5vZGVDaGFuZ2VzVG9EaXNwYXRjaEVuZDsgKytp dCkKICAgICAgICAgKCppdCktPnNldE5lZWRzU3R5bGVSZWNhbGMoU3ludGhldGljU3R5bGVDaGFu Z2UpOwotICAgIAorCiAgICAgbV9ub2RlQ2hhbmdlc1RvRGlzcGF0Y2guY2xlYXIoKTsKLSAgICAK KwogICAgIGlmICh1cGRhdGVTdHlsZSAmJiBtX2ZyYW1lKQogICAgICAgICBtX2ZyYW1lLT5kb2N1 bWVudCgpLT51cGRhdGVTdHlsZUlmTmVlZGVkKCk7CiB9CkBAIC0xOTQsNiArMjAxLDE2IEBAIHZv aWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmFkZE5vZGVDaGFuZ2VUb0Rpc3BhdGNoKFBh c3NSZWZQdHI8Tm9kZT4gbm9kZSkKICAgICBzdGFydFVwZGF0ZVN0eWxlSWZOZWVkZWREaXNwYXRj aGVyKCk7CiB9CiAKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCit2b2lkIEFu aW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjphbmltYXRpb25GcmFtZUNhbGxiYWNrRmlyZWQoKQor eworICAgIGRvdWJsZSB0aW1lVG9OZXh0U2VydmljZSA9IHVwZGF0ZUFuaW1hdGlvbnMoQ2FsbFNl dENoYW5nZWQpOworCisgICAgaWYgKHRpbWVUb05leHRTZXJ2aWNlID49IDApCisgICAgICAgIG1f ZnJhbWUtPmRvY3VtZW50KCktPnZpZXcoKS0+c2NoZWR1bGVBbmltYXRpb24oKTsKK30KKyNlbmRp ZgorCiB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjphbmltYXRpb25UaW1lckZpcmVk KFRpbWVyPEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlPiopCiB7CiAgICAgLy8gTWFrZSBzdXJl IGFuaW1hdGlvblVwZGF0ZVRpbWUgaXMgdXBkYXRlZCwgc28gdGhhdCBpdCBpcyBjdXJyZW50IGV2 ZW4gaWYgbm8KQEAgLTIwMiw3ICsyMTksNyBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2 YXRlOjphbmltYXRpb25UaW1lckZpcmVkKFRpbWVyPEFuaW1hdGlvbkNvbnRyb2xsZXJQcgogCiAg ICAgLy8gV2hlbiB0aGUgdGltZXIgZmlyZXMsIGFsbCB3ZSBkbyBpcyBjYWxsIHNldENoYW5nZWQg b24gYWxsIERPTSBub2RlcyB3aXRoIHJ1bm5pbmcgYW5pbWF0aW9ucyBhbmQgdGhlbiBkbyBhbiBp bW1lZGlhdGUKICAgICAvLyB1cGRhdGVTdHlsZUlmTmVlZGVkLiAgSXQgd2lsbCB0aGVuIGNhbGwg YmFjayB0byB1cyB3aXRoIG5ldyBpbmZvcm1hdGlvbi4KLSAgICB1cGRhdGVBbmltYXRpb25UaW1l cih0cnVlKTsKKyAgICB1cGRhdGVBbmltYXRpb25UaW1lcihDYWxsU2V0Q2hhbmdlZCk7CiAKICAg ICAvLyBGaXJlIGV2ZW50cyByaWdodCBhd2F5LCB0byBhdm9pZCBhIGZsYXNoIG9mIHVuYW5pbWF0 ZWQgc3R5bGUgYWZ0ZXIgYW4gYW5pbWF0aW9uIGNvbXBsZXRlcywgYW5kIGJlZm9yZQogICAgIC8v IHRoZSAnZW5kJyBldmVudCBmaXJlcy4KQEAgLTQ5OSw4ICs1MTYsMTMgQEAgUGFzc1JlZlB0cjxS ZW5kZXJTdHlsZT4gQW5pbWF0aW9uQ29udHJvbGxlcjo6dXBkYXRlQW5pbWF0aW9ucyhSZW5kZXJP YmplY3QqIHJlbmQKICAgICBSZWZQdHI8Q29tcG9zaXRlQW5pbWF0aW9uPiByZW5kZXJlckFuaW1h dGlvbnMgPSBtX2RhdGEtPmFjY2Vzc0NvbXBvc2l0ZUFuaW1hdGlvbihyZW5kZXJlcik7CiAgICAg UmVmUHRyPFJlbmRlclN0eWxlPiBibGVuZGVkU3R5bGUgPSByZW5kZXJlckFuaW1hdGlvbnMtPmFu aW1hdGUocmVuZGVyZXIsIG9sZFN0eWxlLCBuZXdTdHlsZSk7CiAKLSAgICBpZiAocmVuZGVyZXIt PnBhcmVudCgpIHx8IG5ld1N0eWxlLT5hbmltYXRpb25zKCkgfHwgKG9sZFN0eWxlICYmIG9sZFN0 eWxlLT5hbmltYXRpb25zKCkpKQorICAgIGlmIChyZW5kZXJlci0+cGFyZW50KCkgfHwgbmV3U3R5 bGUtPmFuaW1hdGlvbnMoKSB8fCAob2xkU3R5bGUgJiYgb2xkU3R5bGUtPmFuaW1hdGlvbnMoKSkp IHsKICAgICAgICAgbV9kYXRhLT51cGRhdGVBbmltYXRpb25UaW1lcigpOworI2lmIEVOQUJMRShS RVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKKyAgICAgICAgaWYgKEZyYW1lVmlldyogdmlldyA9IHJl bmRlcmVyLT5kb2N1bWVudCgpLT52aWV3KCkpCisgICAgICAgICAgICB2aWV3LT5zY2hlZHVsZUFu aW1hdGlvbigpOworI2VuZGlmCisgICAgfQogCiAgICAgaWYgKGJsZW5kZWRTdHlsZSAhPSBuZXdT dHlsZSkgewogICAgICAgICAvLyBJZiB0aGUgYW5pbWF0aW9ucy90cmFuc2l0aW9ucyBjaGFuZ2Ug b3BhY2l0eSBvciB0cmFuc2Zvcm0sIHdlIG5lZWQgdG8gdXBkYXRlCkBAIC01NTcsNiArNTc5LDEz IEBAIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlcjo6cmVzdW1lQW5pbWF0aW9ucygpCiAgICAgbV9k YXRhLT5yZXN1bWVBbmltYXRpb25zKCk7CiB9CiAKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJ T05fRlJBTUUpCit2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXI6OnNlcnZpY2VBbmltYXRpb25zKCkK K3sKKyAgICBtX2RhdGEtPmFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tGaXJlZCgpOworfQorI2VuZGlm CisKIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlcjo6c3VzcGVuZEFuaW1hdGlvbnNGb3JEb2N1bWVu dChEb2N1bWVudCogZG9jdW1lbnQpCiB7CiAgICAgbV9kYXRhLT5zdXNwZW5kQW5pbWF0aW9uc0Zv ckRvY3VtZW50KGRvY3VtZW50KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5p bWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0 aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuaAppbmRleCBjY2RjNmM0YTQyZDdhMWIzNTAyZDc3MDc4 MDcwMTY2OTVlMzY0YjQ4Li4xODc3MmRkNTkzOTRhYjgwNDYwZmQ5NjU0ZGY0Zjc5ZDU2ZWJlYWVm IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250 cm9sbGVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29u dHJvbGxlci5oCkBAIC02Niw2ICs2Niw5IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgc3VzcGVuZEFu aW1hdGlvbnMoKTsKICAgICB2b2lkIHJlc3VtZUFuaW1hdGlvbnMoKTsKKyNpZiBFTkFCTEUoUkVR VUVTVF9BTklNQVRJT05fRlJBTUUpCisgICAgdm9pZCBzZXJ2aWNlQW5pbWF0aW9ucygpOworI2Vu ZGlmCiAKICAgICB2b2lkIHN1c3BlbmRBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1lbnQqKTsK ICAgICB2b2lkIHJlc3VtZUFuaW1hdGlvbnNGb3JEb2N1bWVudChEb2N1bWVudCopOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlclBy aXZhdGUuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xs ZXJQcml2YXRlLmgKaW5kZXggNDFlZWJmZjE2ZGY1YzkzZDJhY2ZhODViZTQ5OTE3YTFkNDhmZTA4 ZS4uMmMyMDUxZWZmNjBiOTNjMTI0YjcwMDdiZmU2NGI3YjJhMTRhOGM5MCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVy UHJpdmF0ZS5oCkBAIC01MSwxMyArNTEsMjAgQEAgY2xhc3MgUmVuZGVyT2JqZWN0OwogY2xhc3Mg UmVuZGVyU3R5bGU7CiBjbGFzcyBXZWJLaXRBbmltYXRpb25MaXN0OwogCitlbnVtIFNldENoYW5n ZWQgeworICAgIERvTm90Q2FsbFNldENoYW5nZWQgPSAwLAorICAgIENhbGxTZXRDaGFuZ2VkID0g MQorfTsKKwogY2xhc3MgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUgewogICAgIFdURl9NQUtF X05PTkNPUFlBQkxFKEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlKTsgV1RGX01BS0VfRkFTVF9B TExPQ0FURUQ7CiBwdWJsaWM6CiAgICAgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUoRnJhbWUq KTsKICAgICB+QW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUoKTsKIAotICAgIHZvaWQgdXBkYXRl QW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0Q2hhbmdlZCA9IGZhbHNlKTsKKyAgICAvLyBSZXR1 cm5zIHRoZSB0aW1lIHVudGlsIHRoZSBuZXh0IGFuaW1hdGlvbiBuZWVkcyB0byBiZSBzZXJ2aWNl ZCwgb3IgLTEgaWYgdGhlcmUgYXJlIG5vbmUuCisgICAgZG91YmxlIHVwZGF0ZUFuaW1hdGlvbnMo U2V0Q2hhbmdlZCBjYWxsU2V0Q2hhbmdlZCA9IERvTm90Q2FsbFNldENoYW5nZWQpOworICAgIHZv aWQgdXBkYXRlQW5pbWF0aW9uVGltZXIoU2V0Q2hhbmdlZCBjYWxsU2V0Q2hhbmdlZCA9IERvTm90 Q2FsbFNldENoYW5nZWQpOwogCiAgICAgUGFzc1JlZlB0cjxDb21wb3NpdGVBbmltYXRpb24+IGFj Y2Vzc0NvbXBvc2l0ZUFuaW1hdGlvbihSZW5kZXJPYmplY3QqKTsKICAgICBib29sIGNsZWFyKFJl bmRlck9iamVjdCopOwpAQCAtNzEsNiArNzgsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHN1c3Bl bmRBbmltYXRpb25zKCk7CiAgICAgdm9pZCByZXN1bWVBbmltYXRpb25zKCk7CisjaWYgRU5BQkxF KFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQorICAgIHZvaWQgYW5pbWF0aW9uRnJhbWVDYWxsYmFj a0ZpcmVkKCk7CisjZW5kaWYKIAogICAgIHZvaWQgc3VzcGVuZEFuaW1hdGlvbnNGb3JEb2N1bWVu dChEb2N1bWVudCopOwogICAgIHZvaWQgcmVzdW1lQW5pbWF0aW9uc0ZvckRvY3VtZW50KERvY3Vt ZW50Kik7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9jb21wb3NpdGluZy9yZXBhaW50L2JlY29t ZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIuaHRtbCBiL0xheW91dFRlc3RzL2NvbXBvc2l0aW5n L3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci5odG1sCmluZGV4IGQ1MTEw NmZjMzNiNGJmNzZlODZhNzIxMWZmNWE4YTM3YjEzZDBhNTYuLmNhZjczMDliZjBlZWJkMGIwMDlh MTZlM2M5Y2I3NGEyMzMxZjFmMDIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2NvbXBvc2l0aW5n L3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci5odG1sCisrKyBiL0xheW91 dFRlc3RzL2NvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXll ci5odG1sCkBAIC01MSw4ICs1MSwxMCBAQAogICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgiY29udGFpbmVyIikuY2xhc3NOYW1lID0gInJpZ2h0IjsKICAgICAgICAgd2luZG93LnNldFRp bWVvdXQoZnVuY3Rpb24oKSB7CiAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNv bnRhaW5lciIpLmNsYXNzTmFtZSA9ICIiOwotICAgICAgICAgIGlmICh3aW5kb3cubGF5b3V0VGVz dENvbnRyb2xsZXIpCi0gICAgICAgICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25l KCk7CisgICAgICAgICAgd2luZG93LnNldFRpbWVvdXQoZnVuY3Rpb24oKSB7CisgICAgICAgICAg ICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICAgICAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CisgICAgICAgICAgfSwgMjUwKTsKICAgICAgICAg fSwgMjUwKTsKICAgICAgIH0KIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hy b21pdW0tbGludXgvY29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVk LWxheWVyLWV4cGVjdGVkLnBuZyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWxpbnV4 L2NvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci1leHBl Y3RlZC5wbmcKaW5kZXggYTdjZGVjYzE3NmQ1N2FmNThmZDM5ZTM3M2UwMTk3NDJiNTg2MDBiNS4u NjRmYWE5NjYwMDQwMjI2YTEzN2E3MzAxOWVkOWZmOGM2NGQ4ZWM5ZiAxMDA2NDQKR0lUIGJpbmFy eSBwYXRjaApsaXRlcmFsIDc5OTAKemNtZUkxWDtfb2p3I1FSI2l4YmpiRF9sajBSKnJ+PkFmdEBZ UWwqcTNEZ3NKP2ZKfFotV1E7JXs8djM3OVA9a08+Cnokd2RXWjQwOHd9MzFYUUE0Zz9aSU5Gcmx8 S29+TVckYUcpTno0ejtWJmdZKGYlSmMzZyZ6cnMxYG1nby11Ym9HaQp6LUpSNjs5TnEmMGZ6K0xV YFN+Z2N3RFR3a3dCITEmOWwqLUw5fWVtUjl8ckxrdWczQDczSkY1UUJ9OVZFMUFfdUIKeiUmYVVl JlcyaENud3BwZm5jaDVtJmd5MX1OeXlwWTVVWlAoWk1jYGBLX0p+ZT1idFpKeUlaYCVqKHB9UlBW SFJaCnpgRDBodDttaGEwWXlLWDVeeigxdVUzaXg8cDhmb2dpXnFTPTI0Q3RBd3M5fWRYKCYleEQ7 O2duMntKMnI4U2dySgp6R3xQRl5iP01VOHphQFZDKnkyJlErSzBYQyQ0PjFzKiFCMiVGbVk0Ukk2 XmB+O1p5VW1XYSNOWlhxSEhMJHA2VCYKentVJXo7RF41WERyJjVySV4yKTxeZlgpfEJnR0ZEMUst cmMlX0pXU1M/QSFzYGIpcF53YHVwekZweCotaXphYDUqCnpJKC1PciRldCY4clIrXyNpYUA9fjlo Kk5eWkJjTiVBb3ZQJUEyKyNMTVotbEVvalomQ2FGKkZzWHpvVDQqVmE4Ywp6NWEmQG9DIWtVKitD dDljcE1sWlM8bT0zYXBlQXA+M0hwQFg4cm5mMyhuSEcjSXROYjdVQ0o2cm4+aXBPTTZEUnQKelFJ KkAtRnwpQj8jalFjKHZ7NyVIajkmMW4/Zmk/V0BrKEx+QjRzYmFHSUJ9VkAtJDJtIy0qaERpNm9N PTYkSVJOCnpgdT41YV9RaTU8Y3h1QU9gYW93KTRVNz1nXlc+MEk/NVcjWGNqa19SMS1lezxqP1ZQ Z1R8RCZsbyVHNEFuTX5zfQp6PDN0OUZsfHBsfmEoaWhLKm1aeG1ZUXREJStMdUNSZTJjRGM7MUR0 ZE08PVdgJj1EUkZVT1U8Nzw+LWd5PSRTUmsKej5hTEg5dDxXQG9xRnR+KSZOdFBSUjw1M2t4bWFj djVoY0pgO3BkNkc/Y0B9aUsjO0MzPXg3cVV6O0JQdFpeTSUtCnpxcWp2PDkjRjkrOWxjO0NeUjhR LXEoWCoqeDJZU3NsMG9CV3FaK0UxbygtSk0jJTlkNVRzM1RLOCNYaj5ral9ubgp6XiR6NnZ0Kms2 WXJfcnBVe1JjQ1JCP3N3TFg9b2F+Vy04QX0+UE9uKFZPZm5TTkMhN3NRTUJNPWIwcTs4O0p3SmwK el5CfElqXmNhYk5FbjlvOXZDMU9nJWdSRUEzTjAjZFkwMTs0YUh4JWJONk9TVXZ+c3M8bzM2UzNv VHFvQC1tYDwrCnplRHJ5e156WTJePGlDN3R3P1BLZWJJSjMwRm5YT0lZaXcrVGhFc3x9RyQ7aDQo RVg7JVNkcWVXSDIyKVBiNykzYgp6UmMpdmZPRkhlPnU3YXFWRHFAclJabzRofmFebDd7b0EpRUFQ IShHNEIjanR4QWVBLTYxeFFPWCtFcHtnNjBOK2EKendyNk0pN1dFWGV5XmcoJk4zck1QSzdJRU9u dDNXSSZOaD44Nn05WndlQ3VkbTZvbllue1d4N193fDBKMC03NVl+CnpfX2w8bEQydis/QVo/QERE X19eNmRKY3MoNlRsSTRFJnNjdllaRmI/KSU7ITVDLWxTOWVOT0gpNW1gSVFnITleUQp6RkhSTXh6 UXlyZHVYNDgrazdLZHZWWkIjYD5hc2Y7WmB1XmtwaF84Zj45KDhyRSVFb1kzeHtUNF9qYDQkbnFf fVcKelAzQDthSH5vP3E4JHQlMVVlU1hlK1YjSTBKTERqfiNec09+YkdgRk01QGl6aytSbV87Xl9k YENZVF9xMFN2YWh7Cnp6TiZJcSVic3FIbHkreDZ0dTNCdDhqLU01UiRxMilGZXNLKVpBIVYmRFQw K31kPlcjPnlMd1M4PipRJjhaMiN7bgp6PHRqKGR4IW09VDdhKHc1ekYlVy1mTHRvJTtyJlJoY1dG Yyh3eH5RRHF0fm1teldDT24+LWtncFFaPTY5Ylg7UkIKekNIfmc1NUt7OU1tdF5RYTBnRU9sRUkw ST9YdSZVSjN7VUkrdk02ITFtNGY+IXQ4Rkc7Rlp8ZjBSX1Q+ZzN1Qm5ZCnpnK19IaHU1LT81PGRy YjRVWUdWQXc+SngwPSpiPjN3QEE9fUFLNHkjKzc3aWZ2Ynk8bT0rZ01Je2JzeDs4UTcoSQp6aHB0 ZFdCakB7R3JGNWpGaj9+O0I0aSg4M0s3QHpnPmEqSmxLJGNrN19fT1ZrVmtMaFpYZnBLSE1IIXVS SGliR2MKelo0cThrUSpGeV5CbyZid1NsVlEha24+b1ZvKF9NJnZLdTJ8bHloNmRDREkzYlZjT2Jl NVAyWk81SEFga1ZWTmRJCnpFTzFndHJAfn4hayhTZyZtejZrUHRHUSpVcGhOaG4rRColRSt5QDBT YWlheWtIPGg5YSVOT2hYcX5Xd2l0fT5BKQp6UyY+cT10NkxXcT8lfVFIZ15OSHZQKnQqUXUmVHxy YnxLNFoxMV9LR3RpR0k7UnAxLS1pTmE9dzJMKHdIdkNJZ1MKenZ3biF8VGgwfCVRaFIkOyt3e1hT bTs1TCRnJlotYz1pRDAyYndEZlNKdn17T2A2c24qYWtWIWRZblFhfk5GVW80CnpKM2xhISpXRylH OE4yVFApTlo1aUx4RVh1d2huODJ7Rj9OPDQ8VSpUSmZtZVN1SyU1UC0oK1FGWkV7a2dPVzNLKQp6 TDE0cT5gMmo8R08+ckMkaXpjQkVyOz5qamVIfUp9Qn1jTWF5OVU2RCZyVEkzaUljeTdmNHRuaUJ6 ZVNzdmokRzMKem43Ql9IUlV6dCM8IWNPeGR8SmJFKXhZKCVKYE5SMnVlbVlYbFNQc1ZOUHtPWF5Z OENWYGU7Kk8/fkppUCg4clM+CnooaHRgIXh0X3ZyT3x+RkxaMV4/WFQ1cHhQd1JTNklXPkN6Vjw9 YkJGSFRDPzFoRi0zUD04R018Vk04Nl85b2xlLQp6dD0xWGVqfl9wN3kkMzdUYT1yWnZZPnxTRzRN QlhuYD92aXolZ2Y4UiludDxoZDxqfTlKP0BrKHBXLTxuKkt7Xl8Kem8meDlQPUdQMk1KYUpLQ3Uq cDU8PzYjTzZIZE5TPkJ3Vm5MVFFEfl94NyslM0ZXMWIjX0ktRHpLbVZDd2clOGhRCnpfcjl3YG9y VU1sN1U+bEBmJGdgbEtPVFVKezl+UUAqKmVtUVIrV1RobzRGRlpSN25LZDhKV0Q7bFNLfmQzOWpO MAp6SzcqQnx2dFUoMlEkKjYobitReT5TS2FkTUBJYExKYXJFZkxUOEp0TUl1Vm5tOzhPPEFBUj9t I1ghJHpsRE4wWFAKejRMP1hkQUZQWTJDejAqaHR3eio0ZnFYfWUxVEJWXlc+ajEwWWBSKUlzZUxT Z3BSOCNkPHdsRGljPTZANndNKWFICnpHUEktI3lGU31BbjIhdUdSY0twXisrUk1jRW5leEA0PVhC Y1hSJkJUdSNLa0JgTkcwKTZXMmVPa0BzcGdGTW9XRgp6cDNSY3lRPlBxSWNOYVFrZFckKHckcURD JDdhcC14bTRkXz5ISmw1XzFWN1htc3F5ektZWS00Q19fYyZAMXlAaEUKem4hNT81QG1wJmZvd3Np PFE1RmhZOCpgfkxfTnQoNUhhanteU1ZUZ3VvfmQpaTFXUHlPbkd1UEtaRT1vMSlaeHlyCno9dX5E JXpKLSspTTdjRSFtaTlUTmlMMnBkO3E3c307VGFeSTBZe1RmPiM9dWQ5PVYoJDFfUUVXTW8xKkFY dVJDZwp6RUBhP0VtcTQ8QEF8JFIlP21scDBvYXlIeVF+Vy0mdHFtd1lUfX03JSgkV3w0JlU5eilI R34yVSh2T3JWbVBtbTUKempyczhNWTxRdWltNmg/MCN5M3EoV15PYk5oalRHZ0dYYVRZdzVLcSRi eH57WUJvWVpBVms2KFN3YkJnVFF6aHFYCno1MTdzY1IlMF88UFk4NElzQ2cxczVlMCo+IVhQcHgw Izl4d2s+dH0/NVM+K0tsXnJ0PV8qWiM1YlQkVU8+e21qKAp6PipJO0JIeEtCJHlKRkA+b3hydDZo JGh2WiltfFlAT3FebWxZX3w2KW9QdFVeaztBTUhiV34ocXA1VWtULTdCJEEKek50X1BXJSNJZyo5 P2NDU3dmWFcoVkYrMGpsPD58alV9LWdHPzJSKTNlX3Z1RnomcyFyVDdMMVBCV1JfdEB4czlICnpv cHJsJG80RzJGVEgjMV5mWFF1IzJkNXlOQHpXMSNWVEFwdFk1PnpOKEpNPjh1OUVOdyFCayQ/ZkRK ZyFyPiRQaAp6cGI4OU9RUEY2SVdDWCVSRSkpPWI7eXgxTjBgXnlYQ0UoKFFJfHFIcmlYeGQ5ZmMm VmA+N0E8JkFuTkpgPTVEcSYKemAjRjtnPFE7MXFxfE1pYzZfam49bVpee1pZYC1+YEh2P0Rrc21V anghXjJxaSMhNTYmbFI7PUhXNUJ0fSZZZihQCnoyd0d3bUk+KSh0OUdCTUBEKVl0Kns1I3NqdWZh cFBDOW12THdxNC09cD4xcEZBJUVoSEtxU2w4PWsrQ3Boez8yVgp6KzdrWiRkQEs+QFdYaTJ4aHtH TEElKzZreDY+NGooWXZYfkllO2M1WnU4a19zPlMxZU1hYnVRQ2UmJHtQbmJZKUkKelNZfUc0K3ti dE9Ue2VZNjhNRD1tTVYzQTBANU5hZS1AMHx7QnpyVjxsV20wKk93SHVNbF5na1IpT3hxTTghbWFO Cnp2TThFRFJJJnxgRlVvPEEzdEpjfV41JWIzR3BseW81OThhdDJ+UXJmVkFOYzFtPzx4YzhzS3Jv RkRvR2Q2OXcxJgp6Kk4yQ1AtXmBkTGc/d3BDTXNNdl9UNlI+Ji1iYEA3amdPOUFOJGBAUWwrUUZ1 MmZpZFg2OExUTjglfEVXJXJLbXYKekhFdH00UDdMLVc7SjQjI1l0JnBQPnt8KGh7M3hNWklEJClC Qzx3WHRxR1dtfD4xeyV2WFRfPWRQckR7a19UK1hDCnplSThZVjdhNVFmZ2JOZ0A1RWV4eCRNTlo/ bjI/RmlmJSRFSHcqZ0hHOz5EVCNORz5mJDd3SWRHeHM/NmsyU19LSQp6P3Y+aHYjbTB9bi00SiZo QSM/KWZXMTBKKT1aPiojKX1qSUBuS3gyOWpadmo1VHhIfmNDRkJfKVFsI19nPVNhZmcKelZUaTFX S0NsOHVIQUsoI0ErdT1nNT4zdiMofWxLI2NgLXdjLVhaWngxOVVWN2xXbVhYeERSTUA5Y3g1QStS P0BGCnpXNm87WClkU3dEPWZ8QmlBd097R151KCF7LVUoKH5uQE9faEdaeTNJSUR6a1c8b0hjb2Nu ciYlPl9gIzxyWFpUQwp6a05fJnhCdXE3aiheP3EqTWRnYlYtZiNzRjJMPl52bU1JYTVvKmNIUWli JFAhZWB1cT1XIVNOPjlBSDtlTDxFWGcKemc1M1lsc3paTlkmOVFsRDJvcENtX1M4N0tOMGBMOXRG Mz1tbUNXV3RTS0lrQHF9Z29TTmZyeTd7SkhlZTBldzJvCnp3Wno0OHN+PTM/OEVPS30hKHlAVGls P19UZHtyPyFfNi1Hb08+WWN8RVY1TVpYZER8RyF8NEB0djl4RnZ5Z200Ywp6NiYzPnlzbjw8dzw1 ZzhseXc3TzA4bUQ9M0RmVztzX3VUeVFHNG0yMkZ3K0BvdHQ9OGpIUmJ7e3ZgVSROSyQlZiUKemVh dj91JkZNbzcmXnNISmZVeEpFWDJSUn5RWCUpQ08/Vip5UVU+TzRHTVVEazttQE41SD1sKHhETUY1 VXskcCRtCnpwcHNmfEthYntHWmtNWVJ0bEI4V2E1YVltbDYmQklIWSgwKHV+eXFrcTZ6SXZAN0xk Q0JqTXxLblBkZ2w4MEBAVwp6Sn5wJnhGSGpKdlRoa2RETTtJSXpWeyZ1YjF5JVl6WFV2OzVmNnNP USE4e2B0NWFhYU13K3h+I1Rqc288XnooNkIKeilYNmtOWnsqOzkmQDZ9SXtPPU0meFJsaGc8SGV+ R0NhZzhXQWwyPkY1KnNsajBaUSM7biZuJU8leCEtNnw3QWhUCnpfcytYYiR8ZjAjLWxwWmdvJmVY IW9eYWUlXlVqeDlSWUNURzlSVyZVfDYwQjdQdkk/bWV7YH1qU3YyPFFWJjxpKwp6IXhsazNQdD4o NyRBTDVgYm0/PU1oOG9ofUR1dXhZbSkzd0AmaWhje2ZpNHpaJk55QkZpRntkVEFYK0dyPmgtQCsK enh+QyZLaWAxPGRkS2hqYzY1JkVzaW5JMGxUPztTKD1Ldz1pWGtuaXM1cGZmfDhFZXg4KzFhTnlq a2ZzSURDI1B1CnpaZVpUckVre297Zm9+PFdtSUwyYHJ6SWd1KEAqc1IxOyhNZDU4N3x+MD4pUzI0 UUVUXyFreHo3WEMyRDkoTmFhSwp6SFRwdT1mRDQxfDNISVRJMCF8NE88MndEYG1BaUdSU0Z3byVJ K35qcyt1T0grZFk2eTJTQS1XKjZwODRWcSFGeEEKenVZWSttKlNLZ31DNU50eDdLel5laS1WeXVK ZiojTT5udlUmcWc3eSskbEZWOy1JKn1mdU1UXn1rRCQjUVI5dnI4Cno1JEB1bUIyWHJ6e20/dz4t Jj5IO0RsTilDQiRARGk9N3tMJSFYWmdUXyNgOVdWZilyZE5QZGZeQGdMVF89SDttWgp6XmglNEk4 S3hvRXQkQyMjeT9qIWsqZEpiYSFyQW9wXyo+RXsjV3R0ayt7JWlaJSYhRy15LUc3QHc7O1NSZE1U MSsKelhQVCU0JCNLVGE0T3d3clhgK0hLdG8yR1c0VnhrJGwyYlBHbHIrYC0xTWIoVVh7blkpTSlJ K35OezxRd2hpdlBOCnpBI2pxYk99ZV9aO1BVMEJrPUItJFIwU1VuI1JMeiRGZXN5KU1CUz5hQ2xS PTV2UyVkaXZwNF9mJDxpTD1CcFJAMQp6dHRqaFJ2UTtYend6anNpYWBDWlktTl5fT2ZXQ21FVFZe KSM+UFVqYWZWcHQkSilnPH1fNlpEYytlVTxgdDRGR3EKeiplK1J6JXQ5eHNKUj42azFWX1ReMUt6 YktAQ1F5QFBXdEpnVHx9KzA5I0ZVO3pONHxTKCFoLWRJNjMzQV5+fEI2CnpwP2dPRntkd1o9UFhD XmAlSkpqPkZNXntmKG9sP15hbVUoRV5BazEyKjhed2syOF9RYGJIQlMtdnVFJjJKVFNxRwp6ST0+ Y296eUQjY2J6SkU1NEU8e0koRjYmTW18OSFHSWAraWAyNFZFemlZMEZ0NDdSejxqRlptaWRxNERI OXkpYH4KenNMSnB+UkMoZXNvdTRNOCRsJnN8dVU1dSNqajI7I0ZrMCErMW8kaiQlcTJsWFp9T1BB QUVsJFpeaks1QzEoITFuCnoyKk9MeXFpdVU/Nn1EeTJ3TWRJMkM4fj1xRVhEPlI0WlkkbSUhQTlf dzcwSk87Uzt4fCskOG02NFowVSNqMStnYgp6N0tUellIQ3dXZTZjbV9NbCRsaHx1PWc0fXdYfk1J PE97Jm9yZUBLY1BVIWJ9OUc/VlkjS1o4eUkkdmhPJXA8MEEKeiZpLUx3djxTLVh8TTJwO2pJLUpQ N31EIyMyRiNnZ1h9K3hZTiZnZF9CSH5oJnFJLW0+VEV3O0wjPD96UiY2P3JsCnohRihETkVVJWZz c2lleDh4KlI9Xj9PIUtlS2F+S3JycFNUeE19RTk0ejJ7RHgoZihhNithXmdOVzwoUmBeSX5SdQp6 aE9xWGV0KX4wXlV4Zl5ZN3BBRlhUKERLdClDJlUtRlRCNnNrJCkhSkVjOFAhTTdhKndIQ3pKeU1q M1V4d0VvP28KekYlYDg/NWF3UURsa29uYmRSVEV4UHRhMylGVXpkPWxrQ1FqIUplbUopZ1dCaU5J d2NsJFIrPWJqJjx4REsjYSRiCnp2PSk/ZjxLZUBILXxXPyNpelZKQDNUNUEmJjNZaWxsTztZRnkk OF5fQUZoIzhEdTtAIWpENERLJkdrS3hUbGlxMAp6PiQzUnVEUU1yYmpNQGE8clEmQUN7bnhFP3Mk UDNtTz9mTjZVP1g0c2RhP3o9WlRXP1ZkIT9PVU9RXi1takxTWVQKelk+bExQeilifE08QUpmSyV2 aG9NIXV+WDNnJUIoQU53SiMpO0VANyYrM3Y+Jil6I0kzK1hoNFY0YENDdT52ciRPCno4YnRhdm0k MWZMcXB6eFpfbH09RVRgVEx9T2ZgJFJadDIjR3t6bnI/TiE9TyhaYWspQFA+V154QyE4QE9KYjJR NAp6RjVvezhJe2MoYGl1emM4RVJDJlAoPXxvP1hWJSs8X3d8OXkle1gwZnBZQnRLOX1qLX1ySHRC RVQzTWtaKnduN3cKemBwdkRhNCRgP0Nae0xgMUhUejBPNzZ9PVIoT2N+aHg9JXcpWkJCIzc5M05e X0xMUGg5S01wVWBfLShXSUk1NkNtCnp0ZkZ7amBUazNNek84dU4xMHRAM3ZKK1g2diVSVlleekt0 fj9uLXx0TV9SayZuQjJFXk96aWFpYnI4clk9YT4/SAp6OXxSaXpAbjU9MGB4byFxVWVWUmYhaUde MC1kQ05uUChIbURFYylUb05wR2B5ajI9PEImRjIhNV9IaHl6ZXchRGQKej45MyFtRlIhVHtXIVFH YEl4Zy00ZWRpa1I3M2t7Jnp7Y0t2dHFENEJsSyN6fmE0RipGNSpFLVArY3pWMWZkcmBJCnp7fCUx KCYkTWJeO2s2YytnO0FufkFrZXduYCY/K0VkKVM/eiZNVno4SyFBVlplRSZPV2BtWnpvWTFgRmJz ckBVcApsZXxqZVdDR3ZqKmt0O1BpMi1oenJBTld4WF8jKyhUZTlgXnF4fU82NntAPDcoVVYjN3IK CmxpdGVyYWwgODAwMAp6Y21lSE1jfkZ6KnpEfjZqPmpMZEBLfURiKlE3V3F2NUxyVW5RY0Zgc2RT blMyQVMlMElrdEdCU09IcU1WNmNDaUsKekNEQlNpKn1AYCgwNyg+TiREfE5RMz9VI09PSVEqaUJ0 WHtsZEN0dUpeUFkyTz8jI0omcmhqR2YmTnBBKV9qI1krCnpeRXwmX2UqNWA/JWtDWUFjN1E7ai1M TjBPelgkP3R7UiN4eTs9TyRmdShFSU9LNGFrSE1DQDdiU3BTZWZlXmQtUQp6OUF4VnM1Tkxoc15m bUNjUT5VekwhMndyb3RuQlEtKlIxUlVQeCtzQDNPQGJvVXR7bHFLbjZwd0A0eGtrRklnNloKej1Y Z3EhVWFvQllZa1R7bEA0eHh0I21ia3J3Nn1rYEh9U3tpMUJHP2ckNCpAY2RVKEVVST41ZnJJQEJP QkJzUSUzCno/Um4kbGB0SF8wYGRfcnBZa0E7dFVxQUpsPiRSMG5CO1dufl5qNk5UI3xMMmZTaDBu bzRaRlY5PjEpQU55c2xUPwp6YDRMSy0/M141bihhZmJWc2hJVkM4VX1ZWXdDRmVwXiFpfSgzKlpQ aHM9bzlGZm5JJk9BTjAtMSlYelgpb1dKcjMKej0raXlfJX5JYD1aSlooLThvUWpiWW5pVDVGalNx MmQ8JmdSKXhDJEFNd3h2PDgjMkMlczBgcjB7KjV9Ril4ViFwCno4b0Y4P2lGUGUxRDdIR2J7JkZq JSg+I1Y2RDskI1RhVTAwZUZRJjt4bmBVUUlISWxrPTw0cnpleCF+angrdl5ATwp6ZT92WWNATFdv aTNQJkc0NzJ6WjVGcFN2anczUG9lX3Ura0JRYUxgcSp4clY2NkNIVz1QNVNQbmpgWUJPXl4oQSQK ekhna01Ab1NkfGJuKG9lS1l8YSlWdkNFQkRKSk9IQT5Wd2BDM0VBYV8lOyhRKys5JElVcEo1JVpJ b0o8O2V1dCZXCnoqO2R1SzV7VURhQmA/KWJEQ0BKdWslV18xK3dYazdNP0hnNzJqO0JiV2I5VTdA ejx9KjVQZGFicjtgJXFwNjJnagp6WjxKPm9vTSF9bnB8QylYT0tucndlcEpWUmE+Q14jRHxYckxx fTtQNGE5RChoPXM9bEMpME4tRXZQR2lRLUorSUMKeiR4ZFZsWWV0U3RyaXVyXkYpVCttIWR2cyla NWRKYko4RlYlb2hRYHYhQUhxMDZeKnMoQ2NlRUZTdE9rUTVuUU5sCno2KWx3NWYjS2RNaWUtSU11 aD5SUEliK2p4VnZLNVROZ0laSFlkRENfTFUyczY/SG9vbGZWfVotZX5zXl53UUQ0bQp6PGxtNyNL QSE0SmlmbnRKPjJjWkMjY0sjPTluRSZFJEI0KUNeWWduNnV1RH05T2NTM09jUSoqUzJpSk9LXmhL enIKek9NenA7PmVWYSZvbjckN19sSVhjKXoqfDRHSm5abnRVSV5WUV5zI0RFe3MkbkU/LVdUdnh4 Klc9VGIoKWcjUn1pCnpxIWRsIUZKKEluJjcyZWMmfWZvIzFuJF41blFBVVk9SjgqUV8kaGI7SUh3 fDheRUdpZlZYaVNZUFRMSHN5cz9mewp6Y0dCQmRLUXw2JlkxemkxUHxCYVcxbUE1aSFCNCpham59 PmspeC1veHNwTH1IUEY/TCFkRkdUQEdvO2ZFcUwkJGoKemVXZmVRK0kxcUtvRHIpJXBeQkokVn5n M0YmdkheTSR6KXNLdzFsJEQrVHBDNG53ayEhKW4oTTM0bnNSdl9JbCp8CnpTTWZ3YF5GKCFxXiph VG92KGpGKiM+VT48TSRxcGJ1dzhQNzxWP3cmb2k8KDYheWBvdHIoKFhHM15fUTN4TU4mJAp6QGBk NzlRY2BhTk9YZUhaeGYwbClAc3R5Zz8lNGJMJl9PNTNgM1Y5PFh2Mk5UaXNMc2FLZDZHRTI3akw+ clg7QDsKeiZ+e29MVUorfVlLNGVYRHN5RU1PV3wyIXFCJj5BLVd9PXtkbH1rVGUoWDlTR15NXjEm ayk7YFFHZUF0aldxb2FpCnpPeTJ4ZXFaV0BGIU9HNGJecz4ofENkflZgI2F+ZS1OTUBgM1hmNSZW JnZib3ElMGhGRWoxUzklfEtQODM2aClARgp6OW5+MzkjRCt7dHByeE5vRmlpYk1fPnFoeDx4MDE0 Qlk5U2ZgTlpIeXEwSEd+KGA5RFo2YVVYK1JlMVdMSUJOcTEKejQtb1Y9KUtLWUNucl9veEZESDJq Pil0X1hvaj0mc1JuViFNay1ZWCkxWk1XIUtrJVQ/LVVjaENgRmVgNkxlZkBwCnp4MSVDVkpjR2tv bDcwRSRuNHBPMUU7X0ZQYXA7aGg0ckpJalNpOH4tP001aHBZYCROKnlIQ3ErPVRFcjxZYDFsMAp6 TnVpI3QxKHBSN1VxWDclRlAoPWZjdWoqKCEze3g7OXw2IyZgQDFCK3kyYWAwOHFpNjNEX3k4ZWlr Vz9KUHJzTmQKenJxfWZHbDRycjskY150NUMzZmNiPy0jYTs+XzEjKmxXPE1AQy0kRmIkRyl2Uz8/ ZnlNWkhXbV45KH1QeVZGOys8Cnoyc0skPFFCQj1eaU1wX3YqcGQqVjdIakMhLUI4aG0kXl4rOTxz MjBIIU5rTWd8MlImc0lUQ3t6ZWUxMCpAO1N7PAp6PXt2IXJyKCpXOTBtQTQtd25nPms5XipIS29B UncteCM5ZSNIXnNLKHkxRXJEPSpHOEVzdFY3Xzw4RmsrKW1+JD0KemNpciNKZmglPT9Zd35JMUtG eE5yX3dUd189aWh6VyM+VWVyaGZ7UzQ0MUF3WiVQNnxZIzMrQ04+NztjNUpRIW9SCnorMmdWVU9Q d3UzbmF1ZUJTUyVAKmZ9c3ZLKlhBIVoxY2VKKThmI1p3cHpeX2shNm0xeno1ZXlOZC0qczNKJklk bgp6ZSRQRVZiM3dqSHdwMj1XUVp9NE5UNS0kcyFnMzxQRUBya2xZRmIye0JoLUlCWT02WXJwb3Rt a21peFowK25gZHEKenRKPnp1TlRHK3slMTktZ2ghcygjbU9yYVo1ZWNLYGYoYkAyLWJodTZfZj44 YCZYUTt5SStVakM9V1FRN1MqR3QwCnpYWGFofDcmdlZQUjVAOG1yclFUSU9NcFhoNjFJPURoK0pK PXI4K1Z4N3M7M2gkZVZSfHZ5aGNJYF9lKEFATl9hVwp6d1ktRjF1NT1QQ0soQjBUPXgjKURuSSgy SChfUXhneHJxbn5pSnlPeFZHP3tYRTxJRDEjeUpBTig4elRFJVlvOU8KelJHWC00cihzc3YoQnlh ZWI+KU53bnNTeDElJE0tT0gyUnA+e3JzNlZjOG1qTjdLPiN8N3FRKjxkT2N7N2dIV1kmCnpIJnBF KCV2JnZtQHItKF95YXp7eWg4UmckXzBUeSlpZHNVYm17IVdVTnBMXmo9LThPJWVJQ3RGezw5M3VG aUI0Qgp6YWF7V3VnVD1PPlE2SV5jVkpOYnd1ezBadF93VC1+Nk5mPlFmUW00P0pYfTtKZTBidkhZ a2hlNUghe3NxRnZKLUQKeig2XzB8Ryo1YDYpTGAyMGd3Mkd4TDJVVEwhLTg9XyNDUXFPNCRLfDR1 RmFleUVhSVZ6SyFyP005NjhIUyZkNFNeCnp6PXtjRDcle29VN0c/I3dsdEx3KmtZeEVDYVJiflVG K09PZCFzST8wRDVeKlg8T2MzcTlWeFZrUm87PC0pQURrNgp6VXpjKHprRSlkZGFXWkJPazRjc2tQ bURGOTs4QjZPTSphRWJ7WHE9Pzh9TldVdEtIPmByc1RHSURzezhobjVnX0MKeiEpZEomc1dOZTgx NlIxMChFekJVLWxKNk11KUNYWV41elZtNjNHZmB6Pkd6PyV1cHN6eFI+cFhxWDdDMyg4OF9ZCno8 UClaN1hqSlU3bXBjKFplUDczRTt8ZChrRXdWeEZIXjEhUm9nZiNNaV5yJTk2YmM1QVYxVW1zXzZz VUNWUCZjbAp6a0g/MT0keihETXBYUz11KT5lKzdLV148MFhQcmgwQn5zOVdlcyR8SjlZRVFJcEkq bzM5TU01WTlSc1dpJCUhK2oKejZEa3BnS1JXODk2MXEqPz0tNGR+JTs7b2EtcyoqaSZGcilFIVAp RTFLWlo5Z2dqJS1WQksxR29RK3lgc1RDUHp4CnpSMkBJbGxYamB2aGlYOylNKlhvYGdyI307PTd7 ez4wOFRYbXR+dWYlWjgyUUM2OHhzZl5Hc3BkUUdMa0cqY3FPTQp6MV40RFdYT3pDYzRuTF89QWpn KGloaEVHekdXRHRvMkBVMVpsTjJQSnBJayFKdzF3cj1nTUEhejhudmtsOSphdGUKei1ocTJYWmNx QWpQV25jfTdXMil3UEF0U3cpa0JFWm1MWXskVG0mdkIpeiZqSmkyS2IjUjhxMntGUTNuIVhpI05a CnolSjRCNFlCLTFFbUpTcWpeZ1I7SDV1cVJJeUBXeDQ3dGIteGs7c2pnKmh4Mk09aXsjSXRnTmpS bk47N0tJajNXVwp6VzZHTVJ3VT8lem0qMkUoZW9XZm5ZVUVAPlooYWkraWlydzd6RWNfPUUoOCpm YHJVMVRYM1kpSEV9dDd1MVFZWG4KemYpdyFUMS19PjFxI2NJTE5CR3xidCVgSFZ6dnd4ZmMzMGtt cWZqQGVldyM2dCRydCY2SCFxT3kldFRYPG95JThsCnpiVko4ZVBVb3QrYEw+QjBBS0YpcztlNmAt eVIrST9geVFGSHBjLVpVe2QyZz9vajlOOVVJNXAtKnlxYTJLSnImdAp6YlVKOz0hNXxoeHkxVGZP WGxvZX42N3NjUlBfO2UqMXRlaUFBRXtvJkEjVnl2KX4+e2EqK043Rm04MkchVmpoK1cKelhXdGFo RzRZN1N3XzQhSit1RGRsJEl7VDdEazt8ek5tbH15aWE5cVNEUj5WM3IhRnk+JStlYHZMWkkkNV4m fDZWCnpqPzBaKER4PEhWb3J1R09nTVVNTlo2Pk44PnBiYU9PI2I2YElQbHhubXQwKUI2WHgpNkpL fDZSaFpeOFhBPEpWTwp6TzB+fDlLJDw4TlQhZHNRKH49T3d2PHRsYjVJO0dVQENAREtTI0RETT8m SnR8JERfX1NeTWhKYCNWMlRKel4pUGAKem1xcERfV0JUKEdxWElgPl9SWXdSVUhrVWFRNGNMfTtT PW1VIWoxMndROW9vMj8xakQqYUotVGwyIXo8LVhSRmRxCnpiQ212LW5QfWR3P3JjXypie25EfkYz IXZGTGt0bjZwcnEpOTs3UkJCZWhHbkpGK1pqfG1iJDdqVDdtT2goNmR7Rwp6T3ZociUoPWFEOVg5 cSRQcnRoY1BrUW9GYnpAcyR8b3hiK2F5fW9uKDNzVntwUHxIaUFgXyQ3RnQwTzd6ZG1lUF4KemJX JDF7QGkqRShOMXdLXnhNdSlxRFN0b3N2bE8rR2dNcClTcnQoUnJCZ1cxfGo8LTM4bio5TXk9cnAk dGRrYSpQCnpFZGFDdCY4Mk5qV3VpclhzM3ImbV43TSFNQ0ozYlRNIUk4SXdJcnVaMiQ8SSlKLXJG UWlrdUpDRX1VT0x6T0pCWAp6Ji1Rc2kwTyVKVkA2ajc1VlNucCpyXjBWdCZRP3Q2R1U1Uk4wPGVX REtYbUxkekVBfSV3OHc+ZyRiKihANE99NloKejBrNk1wKkNFeFJzOzU2YVB+XlA1M2Mlb1cqbiMq ITV7VSRiUyoxfWRuVH13MWQ+fjNadTlsfXRkeVljNWV5IXdhCnpZSGlYPXJNeE04bGg7dCRYOG92 NDJwRF58cWdBYmQwOHpueDF9e14yV3YpcWBJJGBeYHhWVD1vPGNzUVUqRzZYUQp6NF9mJU9rej1g JVMoPFV8a1RuZlIyQSFHZlFuNEV6aCFMRyVeIz57WHpwSHBtQjU4aWwpVmBPO0RsYV5yVjRAT0MK enBwfWFaP1pvM3RURzA4SG5mJENGMWVZdX1DKWBveHhyckRXXiVRYmxCeHNGYW5WTkRYNzRPP1dK NVZVO0lod3IkCnp0JTFPT3FSdkwkUjsjcX5qOWA8cmlZWiNZZz5NVmNLZDQqPUZPRUc5SkQlflBe K25OOyEreUI+eSlwRUpTcVZAOAp6WCpoJlRCdFkxPTB9UTFBZm8rSXVSNTRFRGd4UTlWZE1Md3c3 T29mZj9YaH0pNkB8flJjRDFCJE9vQH1rU2ZjWDEKenY4aFdYXnZjWm5eZT88YFF8bXE1dSs+ZHg9 M2cleWVzPV9OWFhyWVlyZTU7ezxVNEpyWnFefjI+KyZfPkJCIzAlCnp4Q1JCSnZ7eDV5dT1hYGpU PF50dT8+PVN9MDtFLWFNKSpxbSh2Pz89QyRzTUopcyQ2Tz9nPHJzaTxyKCY7UlJOKwp6cGM4eWZl ekl5JkFDX0JhYiojOGQqY2A+e0hkeTQqU35hNTkpXnJfS1leKD0wQCljNXBSO2JvN28pK2J5TU1q MD4KejxWSVNmalIxSjJxVm4/Mi01eiQjNz96WH1eQDlqI1hrPCU1aE56YFU3a04xVHd+JkU/MFlM ZnklPnZUeXJVYiNNCno2MmpRQSs/dkdQZkV8V0dALUFDQGdaUmctKSNsO1g3d0diWnEpcjR6RU9L TTc7VzZeZXsjTU1vRilWMH5uYUpBKAp6R15SSU1qXks0NTB8RlRVJjI4S1ZvbyRSbiRfS3pTdH1u TUs8Wm1jTXVnZW9CU3NlIXZBJCZgKjM9YjcqSTIzIVIKemRTdyt9Myt6V1RIYUQ4UWw5P0tgeXpK VipRKEw8IzxVYCR0VihNeGlYRGFRQ013emVndW5KVGxSTlIoMmFvYVBOCno/VyN7PU9kTjQjOF5N MEtlK2JRanRPR3RaSjNHc2RYa0Fgc1hwKU1gOTVBQnV4ZDh4QUxXfTRNUTdiSUJQMEIlcAp6N0NF aHQjUlFpYGI/dmxsc3x7dW1oRW45JmhTMjJZKE1EY2EofSMwTSVQLSh0MEdsPn5qVkNMWCtxZEk8 PDlIR1AKemUtMXxgQzh0MXVZakgxb2M7VkBYQyF9YEtJS1k/TnFLTWJPZSEwamNUVm5hNyp6QWRv RT9hfjZjZDFRSE89Vj9lCnpLbjgyNmVGYkRacGlgPzh2fD5JTVolMmxYYz5jZ00qMmpHVS1DR049 ciVZIzA4dXN9cXxFPytAWUpHS2VJNnhIMQp6OTFHYkg8alZXaCNIfVlNcVoofXh4QVpwWmpTYmhA IyljRitJeX02IyR4NUxFWmwxSCVpJj9zYCYrX25LamNAQzkKei1eYUs4Y29wVFVZUmRSZXhkSDRs KkdLUyU9eGJeQlRUS3w+RUl9dHA0Skt5ZGFoZH14N3c+QEsqclBxa2lmP3R8Cnp5NnpvSiVTNDxM clZqSFdYSm4wcDIoNkAteU1uU3x4cngkQldPI1ZFZlFEVzdnIV82UHlkRF9iOUIpdXo1TUJNOwp6 RTlzeyN4OFpYVzQrYDcwVVl2dXxTQVV3WW58b2gmO1l8JktpPFItSEs9JVZzaCp3e2VvPDUtNUde aEcjMWA0VWcKejVldmBTQX03blkxMXpEJCV6YjB7Jl9Yd2tsOSZLQGJgQmJTayFwQ2gkfGdnYyFh JDhSRjlBN2pDXzV1Xj5ARFRTCnopeTE5JWcrUTBHcXJxZ0hfOTVCPmc9emB0cjlVX2RqK3hVfD8h NzlrX1FkckU2X2czQD8oO1AhbWYpPzBGTCR4Ngp6QSlAQWlINmN9O002VFMzTiZIT1EjQDY2Y3NG NDhDLV97a1AkTzU+c0xfdClDRT1GfCtVVHsxbVM7P2pWeT1OLXgKenZUQm5rSFdrXiF0Vm09Smgm ckFIPjt0LSlIYGFvRjFmNzNxTj42UnBKaj01a2tEdWxzQksyKH0jO1B0Zys9WlNpCnpTYntmfGxu RFhTc2lMTzRUbm51Tk09Q3IhcWVLQWRmSUNmR2R1a3xYM2ctaFVBMGUrYStAYVVEK0dqZGY2Mmx5 Ugp6PyNgYDdVfVVedD0qc0lvZiRURy0wKDBNJXdiSHhgQClec05PUTsrVWhYVndGZHghMCFNUHQt WEwmb0sldXVJTykKejltLThmNDBVWHY1RkZWZUVOaG9Aa3NuI3ZaWENTPig1JklFYCtCKy1LNCty ZV9XLWozLUUzMHFtUGZfYEpzbGktCno5clQ2S1o/JnBRVT9ZUGpvfXg8aXF3MVRae29CbEZNVUJW Zk1ubFV6MntvNCs0aD1ZZVVFTTZ3ZzFrTHZLYHFfagp6YzZEX1A7Z1dhdThSUiQwNVkoaDwycTBT RTA/MlYjZWQ2WTdkVWB0MHJ8KE8/K3ByTDdNd3BhbV9ARjlDOzdpUm4KenU4dkg5d3MwVnlxbmc2 TC1sZG9DJUZmR0BuZjs9JXtGc0tWWkVjWkpvJT4rOT88SmRYV0Q8SV5KdU5MZU5BcDFNCnpibDkm KjNiWis2bSpNd0V1TTE5d2RDUHVlUENyeyhkMypIWSl0bmtZYzBUc1NLd2sjVGdkKVNrbFluU1Qx e1IrfQp6cDVOdi0xaVIlTGlScEBuTnZNXiprPk1aQz17bkQjY2oye25MckZUbjlHeEM/RjtwPXpi amZQSjwrQGFnUG5IWGIKejg/VEtjNyVDWTZ3Nz0jcjl2Y2pQLWZmeCRGYH43V0dyNHNrYD4oWWlQ fVZWTEMxZCsxcGw0X1EpZkRhRG8zO0pwCnpzaiU7Pl5AMFdwcUt4Sn5kSEgyU1YxTkVvJFkqRHxN c2AmaCFQMGxAI2w0PEE2PD0lez1gYHZOKzVreiEhRHFJIwp6byEkTyMlPD12UUpOVEN+IVQtPl4h b0o3elBlK2E/ek1sT0FiWXRNZGooPlpHYDUpVHZ7fVBWMVUhbyg1UGZoPm8Keng7NHZRMkxvIX5i Jm1hbDZUVCU9MThvWWs4d0c+ajloZnJ6NClue0ZFanZNOTZ9O1I2K0l9M009Qj59b3sjXlMxCnpp XlNWbll1OVlxVkwpT3xfYFVrYE84K0dIcEVkb2J5OFM4WWY3O3ZzMXlAJVlQQT5WU0UlbDZpezdX MUpKQTJ7IwpKbih3YU1gYTRlbCZpPz1hCgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vY2hyb21pdW0tbGludXgvY29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21w b3NpdGVkLWxheWVyLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVt LWxpbnV4L2NvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXll ci1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDJiZTZiZDc5ZDBkNjE4NDFiOGZhNjFmNTI2ZGQ3 MWQwZDgyNGE5NgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9t aXVtLWxpbnV4L2NvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1s YXllci1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwxNyBAQAorbGF5ZXIgYXQgKDAsMCkgc2l6ZSA4 MDB4NjAwCisgIFJlbmRlclZpZXcgYXQgKDAsMCkgc2l6ZSA4MDB4NjAwCitsYXllciBhdCAoMCww KSBzaXplIDgwMHg2MDAKKyAgUmVuZGVyQmxvY2sge0hUTUx9IGF0ICgwLDApIHNpemUgODAweDYw MAorICAgIFJlbmRlckJvZHkge0JPRFl9IGF0ICg4LDgpIHNpemUgNzg0eDU4NAorICAgICAgUmVu ZGVyQmxvY2sge1B9IGF0ICgwLDApIHNpemUgNzg0eDIwCisgICAgICAgIFJlbmRlcklubGluZSB7 QX0gYXQgKDAsMCkgc2l6ZSAxNDZ4MTkgW2NvbG9yPSMwMDAwRUVdCisgICAgICAgICAgUmVuZGVy VGV4dCB7I3RleHR9IGF0ICgwLDApIHNpemUgMTQ2eDE5CisgICAgICAgICAgICB0ZXh0IHJ1biBh dCAoMCwwKSB3aWR0aCAxNDY6ICJyZGFyOi8vcHJvYmxlbS82OTgzMjA3IgorICAgICAgICBSZW5k ZXJUZXh0IHsjdGV4dH0gYXQgKDE0NiwwKSBzaXplIDM3NHgxOQorICAgICAgICAgIHRleHQgcnVu IGF0ICgxNDYsMCkgd2lkdGggMzc0OiAiU2hvdWxkIG5vdCBsZWF2ZSBibHVlIGJveCBiZWhpbmQg YWZ0ZXIgbW92aW5nIHRvIHRoZSB0b3AgcmlnaHQuIgorbGF5ZXIgYXQgKDgsNDQpIHNpemUgNTAy eDEwMgorICBSZW5kZXJCbG9jayAocmVsYXRpdmUgcG9zaXRpb25lZCkge0RJVn0gYXQgKDAsMzYp IHNpemUgNTAyeDEwMiBbYm9yZGVyOiAoMXB4IHNvbGlkICMwMDAwMDApXQorbGF5ZXIgYXQgKDI1 OSw0NSkgc2l6ZSAyNTB4MTAwCisgIFJlbmRlckJsb2NrIChwb3NpdGlvbmVkKSB7RElWfSBhdCAo MjUxLDEpIHNpemUgMjUweDEwMCBbYmdjb2xvcj0jMDAwMEZGXQorbGF5ZXIgYXQgKDksNDUpIHNp emUgNTB4NTAKKyAgUmVuZGVyQmxvY2sgKHBvc2l0aW9uZWQpIHtESVZ9IGF0ICgxLDEpIHNpemUg NTB4NTAgW2JnY29sb3I9IzAwMDAwMF0KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3Jt L2Nocm9taXVtL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2No cm9taXVtL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAppbmRleCAwZWRhMTJjNzgwNzk0MmY2ZTRkOGVm MWQ5YzgwZjQzYWQzYmM4Y2Y3Li4yNzE5YTEzZmVjYzQ4MTQyYjQ0ZTBlNmZhM2VmNWMwNTcxYzBk YmIyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4cGVj dGF0aW9ucy50eHQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vdGVzdF9leHBl Y3RhdGlvbnMudHh0CkBAIC04NzQsNiArODc0LDkgQEAgQlVHQ1I2MjQzMyBXSU4gOiBmYXN0L2lt YWdlcy9naWYtbG9vcC1jb3VudC5odG1sID0gSU1BR0UKIC8vIFNWRyBURVNUUwogLy8gLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0KIAorLy8gTmVlZCByZWJhc2VsaW5pbmcgYWZ0ZXIgYnVnIDY0NTkxCitCVUdXSzY0NTkxIDog Y29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVkLWxheWVyLmh0bWwg PSBQQVNTIEZBSUwKKwogQlVHQ1I4NzYzIE1BQyA6IHN2Zy9jdXN0b20vdXNlLW9uLWctY29udGFp bmluZy1mb3JlaWduT2JqZWN0LWFuZC1pbWFnZS5zdmcgPSBJTUFHRQogCiAKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL3BsYXRmb3JtL2VmbC90ZXN0X2V4cGVjdGF0aW9ucy50eHQgYi9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9lZmwvdGVzdF9leHBlY3RhdGlvbnMudHh0CmluZGV4IDRkNTRmOWE3MTZm YmQ1ZTIwODUwMGExZGY5NDJjZTI5MzQ5NjExZGIuLjNlNWVjMjQyNDNjODhiZGY4OWMwOGJmYzk3 YTc1YWU5ZWViOWM2OGYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2VmbC90ZXN0 X2V4cGVjdGF0aW9ucy50eHQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZWZsL3Rlc3RfZXhw ZWN0YXRpb25zLnR4dApAQCAtMiw2ICsyLDkgQEAKIC8vCiAvLyBTZWUgaHR0cDovL3RyYWMud2Vi a2l0Lm9yZy93aWtpL1Rlc3RFeHBlY3RhdGlvbnMgZm9yIG1vcmUgaW5mb3JtYXRpb24gb24gdGhp cyBmaWxlLgogCisvLyBOZWVkIHJlYmFzZWxpbmluZyBhZnRlciBidWcgNjQ1OTEKK0JVR1dLNjQ1 OTEgOiBjb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIu aHRtbCA9IFBBU1MgRkFJTAorCiAvLyBOZWVkcyBFTkFCTEVfU0hBRE9XX0RPTQogQlVHV0s3NjQz OSBERUJVRyA6IGZhc3QvZG9tL3NoYWRvdy9jb250ZW50LWVsZW1lbnQtYXBpLmh0bWwgPSBURVhU CiBCVUdXSzc2NDM5IERFQlVHIDogZmFzdC9kb20vc2hhZG93L2NvbnRlbnQtZWxlbWVudC1vdXRz aWRlLXNoYWRvdy5odG1sID0gVEVYVApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0v Z3RrL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay90ZXN0 X2V4cGVjdGF0aW9ucy50eHQKaW5kZXggZDc4YjY4ZGQzNDUzM2I1NzUyM2I5NGJkM2VjNjFiMDNm NjQ3OGJjNy4uZDNmYmJiZTAzYTVlMTQ0OTcyMzc0Y2JiYmYyMzdkMzU0OTA1NzNkYSAxMDA2NDQK LS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAorKysg Yi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvdGVzdF9leHBlY3RhdGlvbnMudHh0CkBAIC0xMyw2 ICsxMyw5IEBAIEJVR1dLNzY4MTQgREVCVUcgOiBmYXN0L3htbGh0dHByZXF1ZXN0L3htbGh0dHBy ZXF1ZXN0LWdldC54aHRtbCA9IENSQVNICiBCVUdXSzc2ODE1IERFQlVHIDogZWRpdGluZy9pbnNl cnRpbmcvNDk2MDEyMC0yLmh0bWwgPSBDUkFTSAogQlVHV0s3NjgxNSBERUJVRyA6IGVkaXRpbmcv ZXhlY0NvbW1hbmQvMTk0NTUuaHRtbCA9IENSQVNICiAKKy8vIE5lZWQgcmViYXNlbGluaW5nIGFm dGVyIGJ1ZyA2NDU5MQorQlVHV0s2NDU5MSA6IGNvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92 ZXJsYXktY29tcG9zaXRlZC1sYXllci5odG1sID0gUEFTUyBGQUlMCisKIC8vIEZsYWt5IHRlc3Rz CiAKIEJVR1dLNjg4NzggOiBtZWRpYS92aWRlby1wbGF5aW5nLWFuZC1wYXVzZS5odG1sID0gUEFT UyBURVhUCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvdGVzdF9leHBlY3Rh dGlvbnMudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL3Rlc3RfZXhwZWN0YXRpb25zLnR4 dAppbmRleCAwMjIwMmEwZmY2NjIyNzFlNGU3NDVlMzVkMzc3OTVlMjc1MjhlNmNlLi42ZmQ2NmJh ZWJjY2U4ZjRhYTlmZGUzYTIzYmUwOWEwNDNiMGY0YjFmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9tYWMvdGVzdF9leHBlY3RhdGlvbnMudHh0CisrKyBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL21hYy90ZXN0X2V4cGVjdGF0aW9ucy50eHQKQEAgLTQ0LDYgKzQ0LDkgQEAgQlVHV0s3 Mzc2NiA6IGNzczMvdW5pY29kZS1iaWRpLWlzb2xhdGUtYWhhcm9uLWZhaWxpbmcuaHRtbCA9IEZB SUwKIC8vIFRoZSB0ZXN0IGhpdHMgYW4gQVNTRVJUIGluIERlYnVnLgogQlVHV0s2ODg1OSBERUJV RyA6IGZhc3QvZHluYW1pYy9jcmFzaC1wYWludC1uby1kb2N1bWVudEVsZW1lbnQtcmVuZGVyZXIu aHRtbCA9IENSQVNICiAKKy8vIE5lZWQgcmViYXNlbGluaW5nIGFmdGVyIGJ1ZyA2NDU5MQorQlVH V0s2NDU5MSA6IGNvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1s YXllci5odG1sID0gUEFTUyBGQUlMCisKIC8vIE5lZWQgcmViYXNlbGluaW5nIGFmdGVyIDcxMjQ0 CiBCVUdXSzc0NDMyIDogY3NzMi4xLzIwMTEwMzIzL2JvcmRlci1jb25mbGljdC1zdHlsZS0wNzku aHRtID0gSU1BR0UKIEJVR1dLNzQ0MzIgOiBjc3MyLjEvMjAxMTAzMjMvZmxvYXRpbmctcmVwbGFj ZWQtaGVpZ2h0LTAwOC5odG0gPSBJTUFHRQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vcXQvdGVzdF9leHBlY3RhdGlvbnMudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQvdGVz dF9leHBlY3RhdGlvbnMudHh0CmluZGV4IGM2YWEzMzRkNDM1OGE1MDNiMzNhMWE3NmZkN2I1ZDUy ODdiMDM2YTUuLmRhMjA0NTc5YzUyMzUzOTc0NmU4NzZkN2RmYzcwZGVhZWNmZjcyYWUgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0L3Rlc3RfZXhwZWN0YXRpb25zLnR4dAorKysg Yi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC90ZXN0X2V4cGVjdGF0aW9ucy50eHQKQEAgLTI1LDUg KzI1LDggQEAgQlVHV0s3NDI3MCA6IGZhc3QvZm9ybXMvYmFzaWMtc2VsZWN0cy5odG1sID0gRkFJ TAogLy8gVGhlIHRlc3QgaGl0cyBhbiBBU1NFUlQgaW4gRGVidWcuCiBCVUdXSzY4ODU5IERFQlVH IDogZmFzdC9keW5hbWljL2NyYXNoLXBhaW50LW5vLWRvY3VtZW50RWxlbWVudC1yZW5kZXJlci5o dG1sID0gQ1JBU0gKIAorLy8gTmVlZCByZWJhc2VsaW5pbmcgYWZ0ZXIgYnVnIDY0NTkxCitCVUdX SzY0NTkxIDogY29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVkLWxh eWVyLmh0bWwgPSBQQVNTIEZBSUwKKwogLy8gTmVlZHMgYmFzZWxpbmUKIEJVR1dLNzYxMTggOiBm YXN0L2Nzcy90ZXh0LW92ZXJmbG93LWlucHV0Lmh0bWwgPSBNSVNTSU5HCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vdGVzdF9leHBlY3RhdGlvbnMudHh0IGIvTGF5b3V0VGVz dHMvcGxhdGZvcm0vd2luL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAppbmRleCA2ZGQyMDUwZDBhNjc3 Mzc4ZjA1NGYxMWI5ZTc1ZjA0NDUxMGYxMDVhLi4wZGQ1MWY4ZmM1YTIwNGM1YTNhMThhNTE5NjFh ZWMwNWRmMjlhYmRiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vdGVzdF9l eHBlY3RhdGlvbnMudHh0CisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi90ZXN0X2V4cGVj dGF0aW9ucy50eHQKQEAgLTIwLDYgKzIwLDkgQEAgQlVHV0s3NDI3MCA6IGZhc3QvZm9ybXMvYmFz aWMtc2VsZWN0cy5odG1sID0gRkFJTAogLy8gVGhlIHRlc3QgaGl0cyBhbiBBU1NFUlQgaW4gRGVi dWcuCiBCVUdXSzY4ODU5IERFQlVHIDogZmFzdC9keW5hbWljL2NyYXNoLXBhaW50LW5vLWRvY3Vt ZW50RWxlbWVudC1yZW5kZXJlci5odG1sID0gQ1JBU0gKIAorLy8gTmVlZCByZWJhc2VsaW5pbmcg YWZ0ZXIgYnVnIDY0NTkxCitCVUdXSzY0NTkxIDogY29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUt b3ZlcmxheS1jb21wb3NpdGVkLWxheWVyLmh0bWwgPSBQQVNTIEZBSUwKKwogLy8gUmViYXNlbGlu ZSBhZnRlciBidWcgNzE3MDUuIEFsbCBkaWZmZXJlbmNlcyBhcmUgZHVlIHRvIHRoZSBmYWN0IHRo YXQgdGFibGUgY2FwdGlvbnMgbm93CiAvLyBleHBhbmQgdG8gdGhlIGZ1bGwgd2lkdGggb2YgdGhl IHRhYmxlLgogQlVHV0s3NDg4OCA6IHRhYmxlcy9tb3ppbGxhL2J1Z3MvYnVnMTE2My0xLmh0bWwg PSBJTUFHRStURVhUCg== 124809 2012-01-31 13:30:47 -0800 2012-02-10 11:15:49 -0800 Fixing pedantic presumbit check on (doubleValue == 0) expression. bug-64591-20120131163046.patch text/plain 31925 jgw U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2MzgxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMmNiNWU0NWZjMDAyNDkx MWM3NDg2MWFiMWU3ZTczOTM2Zjc1NDgzZS4uMDc5OTNlY2M3Y2QyOTVjNTdmZjMzNDljMTFkOGZi ZTAzMDUyMWJkOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEyLTAxLTMxICBKb2Vs IFdlYmJlciAgPGpnd0Bnb29nbGUuY29tPgorCisgICAgICAgIFVzZSByZXF1ZXN0QW5pbWF0aW9u RnJhbWUgY2FsbGJhY2tzIHRvIHB1bXAgQ1NTIGFuaW1hdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTkxCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIG5lZWRlZCAoY292ZXJl ZCBieSB0ZXN0cyBpbiBhbmltYXRpb25zLyopLgorCisgICAgICAgICogcGFnZS9GcmFtZVZpZXcu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVWaWV3OjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRp b25zKToKKyAgICAgICAgKiBwYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmlt YXRpb25zKToKKyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1 cGRhdGVBbmltYXRpb25UaW1lcik6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250cm9s bGVyUHJpdmF0ZTo6ZmlyZUV2ZW50c0FuZFVwZGF0ZVN0eWxlKToKKyAgICAgICAgKFdlYkNvcmU6 OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjphbmltYXRpb25GcmFtZUNhbGxiYWNrRmlyZWQp OgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0aW9uQ29udHJvbGxlcjo6dXBkYXRlQW5pbWF0aW9u cyk6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250cm9sbGVyOjpzZXJ2aWNlQW5pbWF0 aW9ucyk6CisgICAgICAgICogcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5oOgor ICAgICAgICAqIHBhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmg6CisK IDIwMTItMDEtMzEgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CiAKICAgICAgICAg Q3Jhc2ggaW4gRGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6aGFuZGxlR2VuZXJhbERlbGV0ZSB3aGVu IGF0dGVtcHRpbmcgdG8gZGVsZXRlIHRoZSBzdGFydCBibG9jawpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZp ZXcuY3BwCmluZGV4IGFjY2VkYWQ5ZWMxOTNmMzI3MmRlYjZlYjI1ZjJjMGYxYWJlYzU4ZmUuLjhj NGZiYTg2M2EzNjQ1ZDliOTliMzAyMDFjMzE2NTNlZjA3YjE3NjIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0Zy YW1lVmlldy5jcHAKQEAgLTIwOTcsOCArMjA5NywxMSBAQCB2b2lkIEZyYW1lVmlldzo6dW5zY2hl ZHVsZVJlbGF5b3V0KCkKICNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCiB2b2lk IEZyYW1lVmlldzo6c2VydmljZVNjcmlwdGVkQW5pbWF0aW9ucyhET01UaW1lU3RhbXAgdGltZSkK IHsKLSAgICBWZWN0b3I8UmVmUHRyPERvY3VtZW50PiA+IGRvY3VtZW50czsKKyAgICBWZWN0b3I8 QW5pbWF0aW9uQ29udHJvbGxlcio+IGFuaW1hdGlvbnM7CisgICAgZm9yIChGcmFtZSogZnJhbWUg PSBtX2ZyYW1lLmdldCgpOyBmcmFtZTsgZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50cmF2ZXJzZU5l eHQoKSkKKyAgICAgICAgZnJhbWUtPmFuaW1hdGlvbigpLT5zZXJ2aWNlQW5pbWF0aW9ucygpOwog CisgICAgVmVjdG9yPFJlZlB0cjxEb2N1bWVudD4gPiBkb2N1bWVudHM7CiAgICAgZm9yIChGcmFt ZSogZnJhbWUgPSBtX2ZyYW1lLmdldCgpOyBmcmFtZTsgZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50 cmF2ZXJzZU5leHQoKSkKICAgICAgICAgZG9jdW1lbnRzLmFwcGVuZChmcmFtZS0+ZG9jdW1lbnQo KSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlv bkNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9u Q29udHJvbGxlci5jcHAKaW5kZXggNzQ1ZDUxNDZiOTE4ZWQwNTBmNzhmMWI0MmEyOTJiNWExZmE0 ZGFhMC4uODEyZDE4ZDg2OTA4ZGM2NmUxMDAyMmU2MGQyYmU5MGYzMmVhZmVkNCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5j cHAKQEAgLTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlICJDb21wb3NpdGVBbmltYXRpb24uaCIKICNp bmNsdWRlICJFdmVudE5hbWVzLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFt ZVZpZXcuaCIKICNpbmNsdWRlICJSZW5kZXJWaWV3LmgiCiAjaW5jbHVkZSAiV2ViS2l0QW5pbWF0 aW9uRXZlbnQuaCIKICNpbmNsdWRlICJXZWJLaXRBbmltYXRpb25MaXN0LmgiCkBAIC00NCw3ICs0 NSw2IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAotLy8gRklYTUU6IFdoeSBpc24ndCB0aGlz IHNldCB0byA2MGZwcyBvciBzb21ldGhpbmc/CiBzdGF0aWMgY29uc3QgZG91YmxlIGNBbmltYXRp b25UaW1lckRlbGF5ID0gMC4wMjU7CiBzdGF0aWMgY29uc3QgZG91YmxlIGNCZWdpbkFuaW1hdGlv blVwZGF0ZVRpbWVOb3RTZXQgPSAtMTsKIApAQCAtODQsOSArODQsOSBAQCBib29sIEFuaW1hdGlv bkNvbnRyb2xsZXJQcml2YXRlOjpjbGVhcihSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogICAgIHJl dHVybiBhbmltYXRpb24tPnN1c3BlbmRlZCgpOwogfQogCi12b2lkIEFuaW1hdGlvbkNvbnRyb2xs ZXJQcml2YXRlOjp1cGRhdGVBbmltYXRpb25UaW1lcihib29sIGNhbGxTZXRDaGFuZ2VkLyogPSBm YWxzZSovKQorZG91YmxlIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmltYXRp b25zKFNldENoYW5nZWQgY2FsbFNldENoYW5nZWQvKiA9IERvTm90Q2FsbFNldENoYW5nZWQqLykK IHsKLSAgICBkb3VibGUgbmVlZHNTZXJ2aWNlID0gLTE7CisgICAgZG91YmxlIHRpbWVUb05leHRT ZXJ2aWNlID0gLTE7CiAgICAgYm9vbCBjYWxsZWRTZXRDaGFuZ2VkID0gZmFsc2U7CiAKICAgICBS ZW5kZXJPYmplY3RBbmltYXRpb25NYXA6OmNvbnN0X2l0ZXJhdG9yIGFuaW1hdGlvbnNFbmQgPSBt X2NvbXBvc2l0ZUFuaW1hdGlvbnMuZW5kKCk7CkBAIC05NCwxMCArOTQsMTAgQEAgdm9pZCBBbmlt YXRpb25Db250cm9sbGVyUHJpdmF0ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0 Q2hhbmdlZC8qID0gZmEKICAgICAgICAgQ29tcG9zaXRlQW5pbWF0aW9uKiBjb21wQW5pbSA9IGl0 LT5zZWNvbmQuZ2V0KCk7CiAgICAgICAgIGlmICghY29tcEFuaW0tPnN1c3BlbmRlZCgpICYmIGNv bXBBbmltLT5oYXNBbmltYXRpb25zKCkpIHsKICAgICAgICAgICAgIGRvdWJsZSB0ID0gY29tcEFu aW0tPnRpbWVUb05leHRTZXJ2aWNlKCk7Ci0gICAgICAgICAgICBpZiAodCAhPSAtMSAmJiAodCA8 IG5lZWRzU2VydmljZSB8fCBuZWVkc1NlcnZpY2UgPT0gLTEpKQotICAgICAgICAgICAgICAgIG5l ZWRzU2VydmljZSA9IHQ7Ci0gICAgICAgICAgICBpZiAobmVlZHNTZXJ2aWNlID09IDApIHsKLSAg ICAgICAgICAgICAgICBpZiAoY2FsbFNldENoYW5nZWQpIHsKKyAgICAgICAgICAgIGlmICh0ICE9 IC0xICYmICh0IDwgdGltZVRvTmV4dFNlcnZpY2UgfHwgdGltZVRvTmV4dFNlcnZpY2UgPT0gLTEp KQorICAgICAgICAgICAgICAgIHRpbWVUb05leHRTZXJ2aWNlID0gdDsKKyAgICAgICAgICAgIGlm ICghdGltZVRvTmV4dFNlcnZpY2UpIHsKKyAgICAgICAgICAgICAgICBpZiAoY2FsbFNldENoYW5n ZWQgPT0gQ2FsbFNldENoYW5nZWQpIHsKICAgICAgICAgICAgICAgICAgICAgTm9kZSogbm9kZSA9 IGl0LT5maXJzdC0+bm9kZSgpOwogICAgICAgICAgICAgICAgICAgICBBU1NFUlQoIW5vZGUgfHwg KG5vZGUtPmRvY3VtZW50KCkgJiYgIW5vZGUtPmRvY3VtZW50KCktPmluUGFnZUNhY2hlKCkpKTsK ICAgICAgICAgICAgICAgICAgICAgbm9kZS0+c2V0TmVlZHNTdHlsZVJlY2FsYyhTeW50aGV0aWNT dHlsZUNoYW5nZSk7CkBAIC0xMDgsMjggKzEwOCwzNSBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xs ZXJQcml2YXRlOjp1cGRhdGVBbmltYXRpb25UaW1lcihib29sIGNhbGxTZXRDaGFuZ2VkLyogPSBm YQogICAgICAgICAgICAgfQogICAgICAgICB9CiAgICAgfQotICAgIAorCiAgICAgaWYgKGNhbGxl ZFNldENoYW5nZWQpCiAgICAgICAgIG1fZnJhbWUtPmRvY3VtZW50KCktPnVwZGF0ZVN0eWxlSWZO ZWVkZWQoKTsKLSAgICAKKworICAgIHJldHVybiB0aW1lVG9OZXh0U2VydmljZTsKK30KKwordm9p ZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIoU2V0Q2hh bmdlZCBjYWxsU2V0Q2hhbmdlZC8qID0gRG9Ob3RDYWxsU2V0Q2hhbmdlZCovKQoreworICAgIGRv dWJsZSB0aW1lVG9OZXh0U2VydmljZSA9IHVwZGF0ZUFuaW1hdGlvbnMoY2FsbFNldENoYW5nZWQp OworCiAgICAgLy8gSWYgd2Ugd2FudCBzZXJ2aWNlIGltbWVkaWF0ZWx5LCB3ZSBzdGFydCBhIHJl cGVhdGluZyB0aW1lciB0byByZWR1Y2UgdGhlIG92ZXJoZWFkIG9mIHN0YXJ0aW5nCi0gICAgaWYg KG5lZWRzU2VydmljZSA9PSAwKSB7CisgICAgaWYgKCF0aW1lVG9OZXh0U2VydmljZSkgewogICAg ICAgICBpZiAoIW1fYW5pbWF0aW9uVGltZXIuaXNBY3RpdmUoKSB8fCBtX2FuaW1hdGlvblRpbWVy LnJlcGVhdEludGVydmFsKCkgPT0gMCkKICAgICAgICAgICAgIG1fYW5pbWF0aW9uVGltZXIuc3Rh cnRSZXBlYXRpbmcoY0FuaW1hdGlvblRpbWVyRGVsYXkpOwogICAgICAgICByZXR1cm47CiAgICAg fQotICAgIAorCiAgICAgLy8gSWYgd2UgZG9uJ3QgbmVlZCBzZXJ2aWNlLCB3ZSB3YW50IHRvIG1h a2Ugc3VyZSB0aGUgdGltZXIgaXMgbm8gbG9uZ2VyIHJ1bm5pbmcKLSAgICBpZiAobmVlZHNTZXJ2 aWNlIDwgMCkgeworICAgIGlmICh0aW1lVG9OZXh0U2VydmljZSA8IDApIHsKICAgICAgICAgaWYg KG1fYW5pbWF0aW9uVGltZXIuaXNBY3RpdmUoKSkKICAgICAgICAgICAgIG1fYW5pbWF0aW9uVGlt ZXIuc3RvcCgpOwogICAgICAgICByZXR1cm47CiAgICAgfQotICAgIAorCiAgICAgLy8gT3RoZXJ3 aXNlLCB3ZSB3YW50IHRvIHN0YXJ0IGEgb25lLXNob3QgdGltZXIgc28gd2UgZ2V0IGhlcmUgYWdh aW4KICAgICBpZiAobV9hbmltYXRpb25UaW1lci5pc0FjdGl2ZSgpKQogICAgICAgICBtX2FuaW1h dGlvblRpbWVyLnN0b3AoKTsKLSAgICBtX2FuaW1hdGlvblRpbWVyLnN0YXJ0T25lU2hvdChuZWVk c1NlcnZpY2UpOworICAgIG1fYW5pbWF0aW9uVGltZXIuc3RhcnRPbmVTaG90KHRpbWVUb05leHRT ZXJ2aWNlKTsKIH0KIAogdm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6dXBkYXRlU3R5 bGVJZk5lZWRlZERpc3BhdGNoZXJGaXJlZChUaW1lcjxBbmltYXRpb25Db250cm9sbGVyUHJpdmF0 ZT4qKQpAQCAtMTQzLDcgKzE1MCw3IEBAIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6 OmZpcmVFdmVudHNBbmRVcGRhdGVTdHlsZSgpCiAgICAgUmVmUHRyPEZyYW1lPiBwcm90ZWN0b3Ig PSBtX2ZyYW1lOwogCiAgICAgYm9vbCB1cGRhdGVTdHlsZSA9ICFtX2V2ZW50c1RvRGlzcGF0Y2gu aXNFbXB0eSgpIHx8ICFtX25vZGVDaGFuZ2VzVG9EaXNwYXRjaC5pc0VtcHR5KCk7Ci0gICAgCisK ICAgICAvLyBmaXJlIGFsbCB0aGUgZXZlbnRzCiAgICAgVmVjdG9yPEV2ZW50VG9EaXNwYXRjaD4g ZXZlbnRzVG9EaXNwYXRjaCA9IG1fZXZlbnRzVG9EaXNwYXRjaDsKICAgICBtX2V2ZW50c1RvRGlz cGF0Y2guY2xlYXIoKTsKQEAgLTE1NCwxNCArMTYxLDE0IEBAIHZvaWQgQW5pbWF0aW9uQ29udHJv bGxlclByaXZhdGU6OmZpcmVFdmVudHNBbmRVcGRhdGVTdHlsZSgpCiAgICAgICAgIGVsc2UKICAg ICAgICAgICAgIGl0LT5lbGVtZW50LT5kaXNwYXRjaEV2ZW50KFdlYktpdEFuaW1hdGlvbkV2ZW50 OjpjcmVhdGUoaXQtPmV2ZW50VHlwZSwgaXQtPm5hbWUsIGl0LT5lbGFwc2VkVGltZSkpOwogICAg IH0KLSAgICAKKwogICAgIC8vIGNhbGwgc2V0Q2hhbmdlZCBvbiBhbGwgdGhlIGVsZW1lbnRzCiAg ICAgVmVjdG9yPFJlZlB0cjxOb2RlPiA+Ojpjb25zdF9pdGVyYXRvciBub2RlQ2hhbmdlc1RvRGlz cGF0Y2hFbmQgPSBtX25vZGVDaGFuZ2VzVG9EaXNwYXRjaC5lbmQoKTsKICAgICBmb3IgKFZlY3Rv cjxSZWZQdHI8Tm9kZT4gPjo6Y29uc3RfaXRlcmF0b3IgaXQgPSBtX25vZGVDaGFuZ2VzVG9EaXNw YXRjaC5iZWdpbigpOyBpdCAhPSBub2RlQ2hhbmdlc1RvRGlzcGF0Y2hFbmQ7ICsraXQpCiAgICAg ICAgICgqaXQpLT5zZXROZWVkc1N0eWxlUmVjYWxjKFN5bnRoZXRpY1N0eWxlQ2hhbmdlKTsKLSAg ICAKKwogICAgIG1fbm9kZUNoYW5nZXNUb0Rpc3BhdGNoLmNsZWFyKCk7Ci0gICAgCisKICAgICBp ZiAodXBkYXRlU3R5bGUgJiYgbV9mcmFtZSkKICAgICAgICAgbV9mcmFtZS0+ZG9jdW1lbnQoKS0+ dXBkYXRlU3R5bGVJZk5lZWRlZCgpOwogfQpAQCAtMTk0LDYgKzIwMSwxNiBAQCB2b2lkIEFuaW1h dGlvbkNvbnRyb2xsZXJQcml2YXRlOjphZGROb2RlQ2hhbmdlVG9EaXNwYXRjaChQYXNzUmVmUHRy PE5vZGU+IG5vZGUpCiAgICAgc3RhcnRVcGRhdGVTdHlsZUlmTmVlZGVkRGlzcGF0Y2hlcigpOwog fQogCisjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQordm9pZCBBbmltYXRpb25D b250cm9sbGVyUHJpdmF0ZTo6YW5pbWF0aW9uRnJhbWVDYWxsYmFja0ZpcmVkKCkKK3sKKyAgICBk b3VibGUgdGltZVRvTmV4dFNlcnZpY2UgPSB1cGRhdGVBbmltYXRpb25zKENhbGxTZXRDaGFuZ2Vk KTsKKworICAgIGlmICh0aW1lVG9OZXh0U2VydmljZSA+PSAwKQorICAgICAgICBtX2ZyYW1lLT5k b2N1bWVudCgpLT52aWV3KCktPnNjaGVkdWxlQW5pbWF0aW9uKCk7Cit9CisjZW5kaWYKKwogdm9p ZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6YW5pbWF0aW9uVGltZXJGaXJlZChUaW1lcjxB bmltYXRpb25Db250cm9sbGVyUHJpdmF0ZT4qKQogewogICAgIC8vIE1ha2Ugc3VyZSBhbmltYXRp b25VcGRhdGVUaW1lIGlzIHVwZGF0ZWQsIHNvIHRoYXQgaXQgaXMgY3VycmVudCBldmVuIGlmIG5v CkBAIC0yMDIsNyArMjE5LDcgQEAgdm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6YW5p bWF0aW9uVGltZXJGaXJlZChUaW1lcjxBbmltYXRpb25Db250cm9sbGVyUHIKIAogICAgIC8vIFdo ZW4gdGhlIHRpbWVyIGZpcmVzLCBhbGwgd2UgZG8gaXMgY2FsbCBzZXRDaGFuZ2VkIG9uIGFsbCBE T00gbm9kZXMgd2l0aCBydW5uaW5nIGFuaW1hdGlvbnMgYW5kIHRoZW4gZG8gYW4gaW1tZWRpYXRl CiAgICAgLy8gdXBkYXRlU3R5bGVJZk5lZWRlZC4gIEl0IHdpbGwgdGhlbiBjYWxsIGJhY2sgdG8g dXMgd2l0aCBuZXcgaW5mb3JtYXRpb24uCi0gICAgdXBkYXRlQW5pbWF0aW9uVGltZXIodHJ1ZSk7 CisgICAgdXBkYXRlQW5pbWF0aW9uVGltZXIoQ2FsbFNldENoYW5nZWQpOwogCiAgICAgLy8gRmly ZSBldmVudHMgcmlnaHQgYXdheSwgdG8gYXZvaWQgYSBmbGFzaCBvZiB1bmFuaW1hdGVkIHN0eWxl IGFmdGVyIGFuIGFuaW1hdGlvbiBjb21wbGV0ZXMsIGFuZCBiZWZvcmUKICAgICAvLyB0aGUgJ2Vu ZCcgZXZlbnQgZmlyZXMuCkBAIC00OTksOCArNTE2LDEzIEBAIFBhc3NSZWZQdHI8UmVuZGVyU3R5 bGU+IEFuaW1hdGlvbkNvbnRyb2xsZXI6OnVwZGF0ZUFuaW1hdGlvbnMoUmVuZGVyT2JqZWN0KiBy ZW5kCiAgICAgUmVmUHRyPENvbXBvc2l0ZUFuaW1hdGlvbj4gcmVuZGVyZXJBbmltYXRpb25zID0g bV9kYXRhLT5hY2Nlc3NDb21wb3NpdGVBbmltYXRpb24ocmVuZGVyZXIpOwogICAgIFJlZlB0cjxS ZW5kZXJTdHlsZT4gYmxlbmRlZFN0eWxlID0gcmVuZGVyZXJBbmltYXRpb25zLT5hbmltYXRlKHJl bmRlcmVyLCBvbGRTdHlsZSwgbmV3U3R5bGUpOwogCi0gICAgaWYgKHJlbmRlcmVyLT5wYXJlbnQo KSB8fCBuZXdTdHlsZS0+YW5pbWF0aW9ucygpIHx8IChvbGRTdHlsZSAmJiBvbGRTdHlsZS0+YW5p bWF0aW9ucygpKSkKKyAgICBpZiAocmVuZGVyZXItPnBhcmVudCgpIHx8IG5ld1N0eWxlLT5hbmlt YXRpb25zKCkgfHwgKG9sZFN0eWxlICYmIG9sZFN0eWxlLT5hbmltYXRpb25zKCkpKSB7CiAgICAg ICAgIG1fZGF0YS0+dXBkYXRlQW5pbWF0aW9uVGltZXIoKTsKKyNpZiBFTkFCTEUoUkVRVUVTVF9B TklNQVRJT05fRlJBTUUpCisgICAgICAgIGlmIChGcmFtZVZpZXcqIHZpZXcgPSByZW5kZXJlci0+ ZG9jdW1lbnQoKS0+dmlldygpKQorICAgICAgICAgICAgdmlldy0+c2NoZWR1bGVBbmltYXRpb24o KTsKKyNlbmRpZgorICAgIH0KIAogICAgIGlmIChibGVuZGVkU3R5bGUgIT0gbmV3U3R5bGUpIHsK ICAgICAgICAgLy8gSWYgdGhlIGFuaW1hdGlvbnMvdHJhbnNpdGlvbnMgY2hhbmdlIG9wYWNpdHkg b3IgdHJhbnNmb3JtLCB3ZSBuZWVkIHRvIHVwZGF0ZQpAQCAtNTU3LDYgKzU3OSwxMyBAQCB2b2lk IEFuaW1hdGlvbkNvbnRyb2xsZXI6OnJlc3VtZUFuaW1hdGlvbnMoKQogICAgIG1fZGF0YS0+cmVz dW1lQW5pbWF0aW9ucygpOwogfQogCisjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1F KQordm9pZCBBbmltYXRpb25Db250cm9sbGVyOjpzZXJ2aWNlQW5pbWF0aW9ucygpCit7CisgICAg bV9kYXRhLT5hbmltYXRpb25GcmFtZUNhbGxiYWNrRmlyZWQoKTsKK30KKyNlbmRpZgorCiB2b2lk IEFuaW1hdGlvbkNvbnRyb2xsZXI6OnN1c3BlbmRBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1l bnQqIGRvY3VtZW50KQogewogICAgIG1fZGF0YS0+c3VzcGVuZEFuaW1hdGlvbnNGb3JEb2N1bWVu dChkb2N1bWVudCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9B bmltYXRpb25Db250cm9sbGVyLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9Bbmlt YXRpb25Db250cm9sbGVyLmgKaW5kZXggY2NkYzZjNGE0MmQ3YTFiMzUwMmQ3NzA3ODA3MDE2Njk1 ZTM2NGI0OC4uMTg3NzJkZDU5Mzk0YWI4MDQ2MGZkOTY1NGRmNGY3OWQ1NmViZWFlZiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIu aApAQCAtNjYsNiArNjYsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHN1c3BlbmRBbmltYXRpb25z KCk7CiAgICAgdm9pZCByZXN1bWVBbmltYXRpb25zKCk7CisjaWYgRU5BQkxFKFJFUVVFU1RfQU5J TUFUSU9OX0ZSQU1FKQorICAgIHZvaWQgc2VydmljZUFuaW1hdGlvbnMoKTsKKyNlbmRpZgogCiAg ICAgdm9pZCBzdXNwZW5kQW5pbWF0aW9uc0ZvckRvY3VtZW50KERvY3VtZW50Kik7CiAgICAgdm9p ZCByZXN1bWVBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1lbnQqKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmgg Yi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyUHJpdmF0 ZS5oCmluZGV4IDQxZWViZmYxNmRmNWM5M2QyYWNmYTg1YmU0OTkxN2ExZDQ4ZmUwOGUuLjJjMjA1 MWVmZjYwYjkzYzEyNGI3MDA3YmZlNjRiN2IyYTE0YThjOTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUu aApAQCAtNTEsMTMgKzUxLDIwIEBAIGNsYXNzIFJlbmRlck9iamVjdDsKIGNsYXNzIFJlbmRlclN0 eWxlOwogY2xhc3MgV2ViS2l0QW5pbWF0aW9uTGlzdDsKIAorZW51bSBTZXRDaGFuZ2VkIHsKKyAg ICBEb05vdENhbGxTZXRDaGFuZ2VkID0gMCwKKyAgICBDYWxsU2V0Q2hhbmdlZCA9IDEKK307CisK IGNsYXNzIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlIHsKICAgICBXVEZfTUFLRV9OT05DT1BZ QUJMRShBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZSk7IFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVE OwogcHVibGljOgogICAgIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlKEZyYW1lKik7CiAgICAg fkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlKCk7CiAKLSAgICB2b2lkIHVwZGF0ZUFuaW1hdGlv blRpbWVyKGJvb2wgY2FsbFNldENoYW5nZWQgPSBmYWxzZSk7CisgICAgLy8gUmV0dXJucyB0aGUg dGltZSB1bnRpbCB0aGUgbmV4dCBhbmltYXRpb24gbmVlZHMgdG8gYmUgc2VydmljZWQsIG9yIC0x IGlmIHRoZXJlIGFyZSBub25lLgorICAgIGRvdWJsZSB1cGRhdGVBbmltYXRpb25zKFNldENoYW5n ZWQgY2FsbFNldENoYW5nZWQgPSBEb05vdENhbGxTZXRDaGFuZ2VkKTsKKyAgICB2b2lkIHVwZGF0 ZUFuaW1hdGlvblRpbWVyKFNldENoYW5nZWQgY2FsbFNldENoYW5nZWQgPSBEb05vdENhbGxTZXRD aGFuZ2VkKTsKIAogICAgIFBhc3NSZWZQdHI8Q29tcG9zaXRlQW5pbWF0aW9uPiBhY2Nlc3NDb21w b3NpdGVBbmltYXRpb24oUmVuZGVyT2JqZWN0Kik7CiAgICAgYm9vbCBjbGVhcihSZW5kZXJPYmpl Y3QqKTsKQEAgLTcxLDYgKzc4LDkgQEAgcHVibGljOgogCiAgICAgdm9pZCBzdXNwZW5kQW5pbWF0 aW9ucygpOwogICAgIHZvaWQgcmVzdW1lQW5pbWF0aW9ucygpOworI2lmIEVOQUJMRShSRVFVRVNU X0FOSU1BVElPTl9GUkFNRSkKKyAgICB2b2lkIGFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tGaXJlZCgp OworI2VuZGlmCiAKICAgICB2b2lkIHN1c3BlbmRBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1l bnQqKTsKICAgICB2b2lkIHJlc3VtZUFuaW1hdGlvbnNGb3JEb2N1bWVudChEb2N1bWVudCopOwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvY29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3Zlcmxh eS1jb21wb3NpdGVkLWxheWVyLmh0bWwgYi9MYXlvdXRUZXN0cy9jb21wb3NpdGluZy9yZXBhaW50 L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIuaHRtbAppbmRleCBkNTExMDZmYzMzYjRi Zjc2ZTg2YTcyMTFmZjVhOGEzN2IxM2QwYTU2Li5jYWY3MzA5YmYwZWViZDBiMDA5YTE2ZTNjOWNi NzRhMjMzMWYxZjAyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9jb21wb3NpdGluZy9yZXBhaW50 L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9j b21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIuaHRtbApA QCAtNTEsOCArNTEsMTAgQEAKICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnRh aW5lciIpLmNsYXNzTmFtZSA9ICJyaWdodCI7CiAgICAgICAgIHdpbmRvdy5zZXRUaW1lb3V0KGZ1 bmN0aW9uKCkgewogICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb250YWluZXIi KS5jbGFzc05hbWUgPSAiIjsKLSAgICAgICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKQotICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAg ICAgICAgIHdpbmRvdy5zZXRUaW1lb3V0KGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgaWYgKHdp bmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRy b2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgIH0sIDI1MCk7CiAgICAgICAgIH0sIDI1MCk7 CiAgICAgICB9CiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWxp bnV4L2NvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci1l eHBlY3RlZC5wbmcgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1saW51eC9jb21wb3Np dGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXItZXhwZWN0ZWQucG5n CmluZGV4IGE3Y2RlY2MxNzZkNTdhZjU4ZmQzOWUzNzNlMDE5NzQyYjU4NjAwYjUuLjY0ZmFhOTY2 MDA0MDIyNmExMzdhNzMwMTllZDlmZjhjNjRkOGVjOWYgMTAwNjQ0CkdJVCBiaW5hcnkgcGF0Y2gK bGl0ZXJhbCA3OTkwCnpjbWVJMVg7X29qdyNRUiNpeGJqYkRfbGowUipyfj5BZnRAWVFsKnEzRGdz Sj9mSnxaLVdROyV7PHYzNzlQPWtPPgp6JHdkV1o0MDh3fTMxWFFBNGc/WklORnJsfEtvfk1XJGFH KU56NHo7ViZnWShmJUpjM2cmenJzMWBtZ28tdWJvR2kKei1KUjY7OU5xJjBmeitMVWBTfmdjd0RU d2t3QiExJjlsKi1MOX1lbVI5fHJMa3VnM0A3M0pGNVFCfTlWRTFBX3VCCnolJmFVZSZXMmhDbndw cGZuY2g1bSZneTF9Tnl5cFk1VVpQKFpNY2BgS19KfmU9YnRaSnlJWmAlaihwfVJQVkhSWgp6YEQw aHQ7bWhhMFl5S1g1XnooMXVVM2l4PHA4Zm9naV5xUz0yNEN0QXdzOX1kWCgmJXhEOztnbjJ7SjJy OFNnckoKekd8UEZeYj9NVTh6YUBWQyp5MiZRK0swWEMkND4xcyohQjIlRm1ZNFJJNl5gfjtaeVVt V2EjTlpYcUhITCRwNlQmCnp7VSV6O0ReNVhEciY1ckleMik8XmZYKXxCZ0dGRDFLLXJjJV9KV1NT P0Ehc2BiKXBed2B1cHpGcHgqLWl6YWA1Kgp6SSgtT3IkZXQmOHJSK18jaWFAPX45aCpOXlpCY04l QW92UCVBMisjTE1aLWxFb2paJkNhRipGc1h6b1Q0KlZhOGMKejVhJkBvQyFrVSorQ3Q5Y3BNbFpT PG09M2FwZUFwPjNIcEBYOHJuZjMobkhHI0l0TmI3VUNKNnJuPmlwT002RFJ0CnpRSSpALUZ8KUI/ I2pRYyh2ezclSGo5JjFuP2ZpP1dAayhMfkI0c2JhR0lCfVZALSQybSMtKmhEaTZvTT02JElSTgp6 YHU+NWFfUWk1PGN4dUFPYGFvdyk0VTc9Z15XPjBJPzVXI1hjamtfUjEtZXs8aj9WUGdUfEQmbG8l RzRBbk1+c30KejwzdDlGbHxwbH5hKGloSyptWnhtWVF0RCUrTHVDUmUyY0RjOzFEdGRNPD1XYCY9 RFJGVU9VPDc8Pi1neT0kU1JrCno+YUxIOXQ8V0BvcUZ0fikmTnRQUlI8NTNreG1hY3Y1aGNKYDtw ZDZHP2NAfWlLIztDMz14N3FVejtCUHRaXk0lLQp6cXFqdjw5I0Y5KzlsYztDXlI4US1xKFgqKngy WVNzbDBvQldxWitFMW8oLUpNIyU5ZDVUczNUSzgjWGo+a2pfbm4Kel4kejZ2dCprNllyX3JwVXtS Y0NSQj9zd0xYPW9hflctOEF9PlBPbihWT2ZuU05DITdzUU1CTT1iMHE7ODtKd0psCnpeQnxJal5j YWJORW45bzl2QzFPZyVnUkVBM04wI2RZMDE7NGFIeCViTjZPU1V2fnNzPG8zNlMzb1Rxb0AtbWA8 Kwp6ZURyeXteelkyXjxpQzd0dz9QS2ViSUozMEZuWE9JWWl3K1RoRXN8fUckO2g0KEVYOyVTZHFl V0gyMilQYjcpM2IKelJjKXZmT0ZIZT51N2FxVkRxQHJSWm80aH5hXmw3e29BKUVBUCEoRzRCI2p0 eEFlQS02MXhRT1grRXB7ZzYwTithCnp3cjZNKTdXRVhleV5nKCZOM3JNUEs3SUVPbnQzV0kmTmg+ ODZ9OVp3ZUN1ZG02b25ZbntXeDdfd3wwSjAtNzVZfgp6X19sPGxEMnYrP0FaP0BERF9fXjZkSmNz KDZUbEk0RSZzY3ZZWkZiPyklOyE1Qy1sUzllTk9IKTVtYElRZyE5XlEKekZIUk14elF5cmR1WDQ4 K2s3S2R2VlpCI2A+YXNmO1pgdV5rcGhfOGY+OSg4ckUlRW9ZM3h7VDRfamA0JG5xX31XCnpQM0A7 YUh+bz9xOCR0JTFVZVNYZStWI0kwSkxEan4jXnNPfmJHYEZNNUBpemsrUm1fO15fZGBDWVRfcTBT dmFoewp6ek4mSXElYnNxSGx5K3g2dHUzQnQ4ai1NNVIkcTIpRmVzSylaQSFWJkRUMCt9ZD5XIz55 THdTOD4qUSY4WjIje24Kejx0aihkeCFtPVQ3YSh3NXpGJVctZkx0byU7ciZSaGNXRmMod3h+UURx dH5tbXpXQ09uPi1rZ3BRWj02OWJYO1JCCnpDSH5nNTVLezlNbXReUWEwZ0VPbEVJMEk/WHUmVUoz e1VJK3ZNNiExbTRmPiF0OEZHO0ZafGYwUl9UPmczdUJuWQp6ZytfSGh1NS0/NTxkcmI0VVlHVkF3 Pkp4MD0qYj4zd0BBPX1BSzR5Iys3N2lmdmJ5PG09K2dNSXtic3g7OFE3KEkKemhwdGRXQmpAe0dy RjVqRmo/fjtCNGkoODNLN0B6Zz5hKkpsSyRjazdfX09Wa1ZrTGhaWGZwS0hNSCF1UkhpYkdjCnpa NHE4a1EqRnleQm8mYndTbFZRIWtuPm9WbyhfTSZ2S3UyfGx5aDZkQ0RJM2JWY09iZTVQMlpPNUhB YGtWVk5kSQp6RU8xZ3RyQH5+IWsoU2cmbXo2a1B0R1EqVXBoTmhuK0QqJUUreUAwU2FpYXlrSDxo OWElTk9oWHF+V3dpdH0+QSkKelMmPnE9dDZMV3E/JX1RSGdeTkh2UCp0KlF1JlR8cmJ8SzRaMTFf S0d0aUdJO1JwMS0taU5hPXcyTCh3SHZDSWdTCnp2d24hfFRoMHwlUWhSJDsrd3tYU207NUwkZyZa LWM9aUQwMmJ3RGZTSnZ9e09gNnNuKmFrViFkWW5RYX5ORlVvNAp6SjNsYSEqV0cpRzhOMlRQKU5a NWlMeEVYdXdobjgye0Y/Tjw0PFUqVEpmbWVTdUslNVAtKCtRRlpFe2tnT1czSykKekwxNHE+YDJq PEdPPnJDJGl6Y0JFcjs+amplSH1KfUJ9Y01heTlVNkQmclRJM2lJY3k3ZjR0bmlCemVTc3ZqJEcz CnpuN0JfSFJVenQjPCFjT3hkfEpiRSl4WSglSmBOUjJ1ZW1ZWGxTUHNWTlB7T1heWThDVmBlOypP P35KaVAoOHJTPgp6KGh0YCF4dF92ck98fkZMWjFeP1hUNXB4UHdSUzZJVz5DelY8PWJCRkhUQz8x aEYtM1A9OEdNfFZNODZfOW9sZS0KenQ9MVhlan5fcDd5JDM3VGE9clp2WT58U0c0TUJYbmA/dml6 JWdmOFIpbnQ8aGQ8an05Sj9AayhwVy08bipLe15fCnpvJng5UD1HUDJNSmFKS0N1KnA1PD82I082 SGROUz5Cd1ZuTFRRRH5feDcrJTNGVzFiI19JLUR6S21WQ3dnJThoUQp6X3I5d2BvclVNbDdVPmxA ZiRnYGxLT1RVSns5flFAKiplbVFSK1dUaG80RkZaUjduS2Q4SldEO2xTS35kMzlqTjAKeks3KkJ8 dnRVKDJRJCo2KG4rUXk+U0thZE1ASWBMSmFyRWZMVDhKdE1JdVZubTs4TzxBQVI/bSNYISR6bERO MFhQCno0TD9YZEFGUFkyQ3owKmh0d3oqNGZxWH1lMVRCVl5XPmoxMFlgUilJc2VMU2dwUjgjZDx3 bERpYz02QDZ3TSlhSAp6R1BJLSN5RlN9QW4yIXVHUmNLcF4rK1JNY0VuZXhAND1YQmNYUiZCVHUj S2tCYE5HMCk2VzJlT2tAc3BnRk1vV0YKenAzUmN5UT5QcUljTmFRa2RXJCh3JHFEQyQ3YXAteG00 ZF8+SEpsNV8xVjdYbXNxeXpLWVktNENfX2MmQDF5QGhFCnpuITU/NUBtcCZmb3dzaTxRNUZoWTgq YH5MX050KDVIYWp7XlNWVGd1b35kKWkxV1B5T25HdVBLWkU9bzEpWnh5cgp6PXV+RCV6Si0rKU03 Y0UhbWk5VE5pTDJwZDtxN3N9O1RhXkkwWXtUZj4jPXVkOT1WKCQxX1FFV01vMSpBWHVSQ2cKekVA YT9FbXE0PEBBfCRSJT9tbHAwb2F5SHlRflctJnRxbXdZVH19NyUoJFd8NCZVOXopSEd+MlUodk9y Vm1QbW01CnpqcnM4TVk8UXVpbTZoPzAjeTNxKFdeT2JOaGpUR2dHWGFUWXc1S3EkYnh+e1lCb1la QVZrNihTd2JCZ1RRemhxWAp6NTE3c2NSJTBfPFBZODRJc0NnMXM1ZTAqPiFYUHB4MCM5eHdrPnR9 PzVTPitLbF5ydD1fKlojNWJUJFVPPnttaigKej4qSTtCSHhLQiR5SkZAPm94cnQ2aCRodlopbXxZ QE9xXm1sWV98NilvUHRVXms7QU1IYld+KHFwNVVrVC03QiRBCnpOdF9QVyUjSWcqOT9jQ1N3ZlhX KFZGKzBqbDw+fGpVfS1nRz8yUikzZV92dUZ6JnMhclQ3TDFQQldSX3RAeHM5SAp6b3BybCRvNEcy RlRIIzFeZlhRdSMyZDV5TkB6VzEjVlRBcHRZNT56TihKTT44dTlFTnchQmskP2ZESmchcj4kUGgK enBiODlPUVBGNklXQ1glUkUpKT1iO3l4MU4wYF55WENFKChRSXxxSHJpWHhkOWZjJlZgPjdBPCZB bk5KYD01RHEmCnpgI0Y7ZzxROzFxcXxNaWM2X2puPW1aXntaWWAtfmBIdj9Ea3NtVWp4IV4ycWkj ITU2JmxSOz1IVzVCdH0mWWYoUAp6MndHd21JPikodDlHQk1ARClZdCp7NSNzanVmYXBQQzltdkx3 cTQtPXA+MXBGQSVFaEhLcVNsOD1rK0NwaHs/MlYKeis3a1okZEBLPkBXWGkyeGh7R0xBJSs2a3g2 PjRqKFl2WH5JZTtjNVp1OGtfcz5TMWVNYWJ1UUNlJiR7UG5iWSlJCnpTWX1HNCt7YnRPVHtlWTY4 TUQ9bU1WM0EwQDVOYWUtQDB8e0J6clY8bFdtMCpPd0h1TWxeZ2tSKU94cU04IW1hTgp6dk04RURS SSZ8YEZVbzxBM3RKY31eNSViM0dwbHlvNTk4YXQyflFyZlZBTmMxbT88eGM4c0tyb0ZEb0dkNjl3 MSYKeipOMkNQLV5gZExnP3dwQ01zTXZfVDZSPiYtYmBAN2pnTzlBTiRgQFFsK1FGdTJmaWRYNjhM VE44JXxFVyVyS212CnpIRXR9NFA3TC1XO0o0IyNZdCZwUD57fChoezN4TVpJRCQpQkM8d1h0cUdX bXw+MXsldlhUXz1kUHJEe2tfVCtYQwp6ZUk4WVY3YTVRZmdiTmdANUVleHgkTU5aP24yP0ZpZiUk RUh3KmdIRzs+RFQjTkc+ZiQ3d0lkR3hzPzZrMlNfS0kKej92Pmh2I20wfW4tNEomaEEjPylmVzEw Sik9Wj4qIyl9aklAbkt4MjlqWnZqNVR4SH5jQ0ZCXylRbCNfZz1TYWZnCnpWVGkxV0tDbDh1SEFL KCNBK3U9ZzU+M3YjKH1sSyNjYC13Yy1YWlp4MTlVVjdsV21YWHhEUk1AOWN4NUErUj9ARgp6VzZv O1gpZFN3RD1mfEJpQXdPe0dedSghey1VKCh+bkBPX2hHWnkzSUlEemtXPG9IY29jbnImJT5fYCM8 clhaVEMKemtOXyZ4QnVxN2ooXj9xKk1kZ2JWLWYjc0YyTD5edm1NSWE1bypjSFFpYiRQIWVgdXE9 VyFTTj45QUg7ZUw8RVhnCnpnNTNZbHN6Wk5ZJjlRbEQyb3BDbV9TODdLTjBgTDl0RjM9bW1DV1d0 U0tJa0BxfWdvU05mcnk3e0pIZWUwZXcybwp6d1p6NDhzfj0zPzhFT0t9ISh5QFRpbD9fVGR7cj8h XzYtR29PPlljfEVWNU1aWGREfEchfDRAdHY5eEZ2eWdtNGMKejYmMz55c248PHc8NWc4bHl3N08w OG1EPTNEZlc7c191VHlRRzRtMjJGdytAb3R0PThqSFJie3t2YFUkTkskJWYlCnplYXY/dSZGTW83 Jl5zSEpmVXhKRVgyUlJ+UVglKUNPP1YqeVFVPk80R01VRGs7bUBONUg9bCh4RE1GNVV7JHAkbQp6 cHBzZnxLYWJ7R1prTVlSdGxCOFdhNWFZbWw2JkJJSFkoMCh1fnlxa3E2ekl2QDdMZENCak18S25Q ZGdsODBAQFcKekp+cCZ4RkhqSnZUaGtkRE07SUl6VnsmdWIxeSVZelhVdjs1ZjZzT1EhOHtgdDVh YWFNdyt4fiNUanNvPF56KDZCCnopWDZrTlp7Kjs5JkA2fUl7Tz1NJnhSbGhnPEhlfkdDYWc4V0Fs Mj5GNSpzbGowWlEjO24mbiVPJXghLTZ8N0FoVAp6X3MrWGIkfGYwIy1scFpnbyZlWCFvXmFlJV5V ang5UllDVEc5UlcmVXw2MEI3UHZJP21le2B9alN2MjxRViY8aSsKeiF4bGszUHQ+KDckQUw1YGJt Pz1NaDhvaH1EdXV4WW0pM3dAJmloY3tmaTR6WiZOeUJGaUZ7ZFRBWCtHcj5oLUArCnp4fkMmS2lg MTxkZEtoamM2NSZFc2luSTBsVD87Uyg9S3c9aVhrbmlzNXBmZnw4RWV4OCsxYU55amtmc0lEQyNQ dQp6WmVaVHJFa3tve2ZvfjxXbUlMMmByeklndShAKnNSMTsoTWQ1ODd8fjA+KVMyNFFFVF8ha3h6 N1hDMkQ5KE5hYUsKekhUcHU9ZkQ0MXwzSElUSTAhfDRPPDJ3RGBtQWlHUlNGd28lSSt+anMrdU9I K2RZNnkyU0EtVyo2cDg0VnEhRnhBCnp1WVkrbSpTS2d9QzVOdHg3S3peZWktVnl1SmYqI00+bnZV JnFnN3krJGxGVjstSSp9ZnVNVF59a0QkI1FSOXZyOAp6NSRAdW1CMlhyenttP3c+LSY+SDtEbE4p Q0IkQERpPTd7TCUhWFpnVF8jYDlXVmYpcmROUGRmXkBnTFRfPUg7bVoKel5oJTRJOEt4b0V0JEMj I3k/aiFrKmRKYmEhckFvcF8qPkV7I1d0dGsreyVpWiUmIUcteS1HN0B3OztTUmRNVDErCnpYUFQl NCQjS1RhNE93d3JYYCtIS3RvMkdXNFZ4ayRsMmJQR2xyK2AtMU1iKFVYe25ZKU0pSSt+Tns8UXdo aXZQTgp6QSNqcWJPfWVfWjtQVTBCaz1CLSRSMFNVbiNSTHokRmVzeSlNQlM+YUNsUj01dlMlZGl2 cDRfZiQ8aUw9QnBSQDEKenR0amhSdlE7WHp3empzaWFgQ1pZLU5eX09mV0NtRVRWXikjPlBVamFm VnB0JEopZzx9XzZaRGMrZVU8YHQ0RkdxCnoqZStSeiV0OXhzSlI+NmsxVl9UXjFLemJLQENReUBQ V3RKZ1R8fSswOSNGVTt6TjR8UyghaC1kSTYzM0FefnxCNgp6cD9nT0Z7ZHdaPVBYQ15gJUpKaj5G TV57ZihvbD9eYW1VKEVeQWsxMio4XndrMjhfUWBiSEJTLXZ1RSYySlRTcUcKekk9PmNvenlEI2Ni ekpFNTRFPHtJKEY2Jk1tfDkhR0lgK2lgMjRWRXppWTBGdDQ3Uno8akZabWlkcTRESDl5KWB+Cnpz TEpwflJDKGVzb3U0TTgkbCZzfHVVNXUjamoyOyNGazAhKzFvJGokJXEybFhafU9QQUFFbCRaXmpL NUMxKCExbgp6MipPTHlxaXVVPzZ9RHkyd01kSTJDOH49cUVYRD5SNFpZJG0lIUE5X3c3MEpPO1M7 eHwrJDhtNjRaMFUjajErZ2IKejdLVHpZSEN3V2U2Y21fTWwkbGh8dT1nNH13WH5NSTxPeyZvcmVA S2NQVSFifTlHP1ZZI0taOHlJJHZoTyVwPDBBCnomaS1Md3Y8Uy1YfE0ycDtqSS1KUDd9RCMjMkYj Z2dYfSt4WU4mZ2RfQkh+aCZxSS1tPlRFdztMIzw/elImNj9ybAp6IUYoRE5FVSVmc3NpZXg4eCpS PV4/TyFLZUthfktycnBTVHhNfUU5NHoye0R4KGYoYTYrYV5nTlc8KFJgXkl+UnUKemhPcVhldCl+ MF5VeGZeWTdwQUZYVChES3QpQyZVLUZUQjZzayQpIUpFYzhQIU03YSp3SEN6SnlNajNVeHdFbz9v CnpGJWA4PzVhd1FEbGtvbmJkUlRFeFB0YTMpRlV6ZD1sa0NRaiFKZW1KKWdXQmlOSXdjbCRSKz1i aiY8eERLI2EkYgp6dj0pP2Y8S2VASC18Vz8jaXpWSkAzVDVBJiYzWWlsbE87WUZ5JDheX0FGaCM4 RHU7QCFqRDRESyZHa0t4VGxpcTAKej4kM1J1RFFNcmJqTUBhPHJRJkFDe254RT9zJFAzbU8/Zk42 VT9YNHNkYT96PVpUVz9WZCE/T1VPUV4tbWpMU1lUCnpZPmxMUHopYnxNPEFKZksldmhvTSF1flgz ZyVCKEFOd0ojKTtFQDcmKzN2PiYpeiNJMytYaDRWNGBDQ3U+dnIkTwp6OGJ0YXZtJDFmTHFwenha X2x9PUVUYFRMfU9mYCRSWnQyI0d7em5yP04hPU8oWmFrKUBQPldeeEMhOEBPSmIyUTQKekY1b3s4 SXtjKGBpdXpjOEVSQyZQKD18bz9YViUrPF93fDl5JXtYMGZwWUJ0Szl9ai19ckh0QkVUM01rWip3 bjd3CnpgcHZEYTQkYD9DWntMYDFIVHowTzc2fT1SKE9jfmh4PSV3KVpCQiM3OTNOXl9MTFBoOUtN cFVgXy0oV0lJNTZDbQp6dGZGe2pgVGszTXpPOHVOMTB0QDN2SitYNnYlUlZZXnpLdH4/bi18dE1f UmsmbkIyRV5PemlhaWJyOHJZPWE+P0gKejl8Uml6QG41PTBgeG8hcVVlVlJmIWlHXjAtZENOblAo SG1ERWMpVG9OcEdgeWoyPTxCJkYyITVfSGh5emV3IURkCno+OTMhbUZSIVR7VyFRR2BJeGctNGVk aWtSNzNreyZ6e2NLdnRxRDRCbEsjen5hNEYqRjUqRS1QK2N6VjFmZHJgSQp6e3wlMSgmJE1iXjtr NmMrZztBbn5Ba2V3bmAmPytFZClTP3omTVZ6OEshQVZaZUUmT1dgbVp6b1kxYEZic3JAVXAKbGV8 amVXQ0d2aiprdDtQaTItaHpyQU5XeFhfIysoVGU5YF5xeH1PNjZ7QDw3KFVWIzdyCgpsaXRlcmFs IDgwMDAKemNtZUhNY35Geip6RH42aj5qTGRAS31EYipRN1dxdjVMclVuUWNGYHNkU25TMkFTJTBJ a3RHQlNPSHFNVjZjQ2lLCnpDREJTaSp9QGAoMDcoPk4kRHxOUTM/VSNPT0lRKmlCdFh7bGRDdHVK XlBZMk8/IyNKJnJoakdmJk5wQSlfaiNZKwp6XkV8Jl9lKjVgPyVrQ1lBYzdRO2otTE4wT3pYJD90 e1IjeHk7PU8kZnUoRUlPSzRha0hNQ0A3YlNwU2VmZV5kLVEKejlBeFZzNU5MaHNeZm1DY1E+VXpM ITJ3cm90bkJRLSpSMVJVUHgrc0AzT0Bib1V0e2xxS242cHdANHhra0ZJZzZaCno9WGdxIVVhb0JZ WWtUe2xANHh4dCNtYmtydzZ9a2BIfVN7aTFCRz9nJDQqQGNkVShFVUk+NWZySUBCT0JCc1ElMwp6 P1JuJGxgdEhfMGBkX3JwWWtBO3RVcUFKbD4kUjBuQjtXbn5eajZOVCN8TDJmU2gwbm80WkZWOT4x KUFOeXNsVD8KemA0TEstPzNeNW4oYWZiVnNoSVZDOFV9WVl3Q0ZlcF4haX0oMypaUGhzPW85RmZu SSZPQU4wLTEpWHpYKW9XSnIzCno9K2l5XyV+SWA9WkpaKC04b1FqYlluaVQ1RmpTcTJkPCZnUil4 QyRBTXd4djw4IzJDJXMwYHIweyo1fUYpeFYhcAp6OG9GOD9pRlBlMUQ3SEdieyZGaiUoPiNWNkQ7 JCNUYVUwMGVGUSY7eG5gVVFJSElsaz08NHJ6ZXghfmp4K3ZeQE8KemU/dlljQExXb2kzUCZHNDcy elo1RnBTdmp3M1BvZV91K2tCUWFMYHEqeHJWNjZDSFc9UDVTUG5qYFlCT15eKEEkCnpIZ2tNQG9T ZHxibihvZUtZfGEpVnZDRUJESkpPSEE+VndgQzNFQWFfJTsoUSsrOSRJVXBKNSVaSW9KPDtldXQm Vwp6KjtkdUs1e1VEYUJgPyliRENASnVrJVdfMSt3WGs3TT9IZzcyajtCYldiOVU3QHo8fSo1UGRh YnI7YCVxcDYyZ2oKelo8Sj5vb00hfW5wfEMpWE9LbnJ3ZXBKVlJhPkNeI0R8WHJMcX07UDRhOUQo aD1zPWxDKTBOLUV2UEdpUS1KK0lDCnokeGRWbFlldFN0cml1cl5GKVQrbSFkdnMpWjVkSmJKOEZW JW9oUWB2IUFIcTA2XipzKENjZUVGU3RPa1E1blFObAp6NilsdzVmI0tkTWllLUlNdWg+UlBJYitq eFZ2SzVUTmdJWkhZZERDX0xVMnM2P0hvb2xmVn1aLWV+c15ed1FENG0KejxsbTcjS0EhNEppZm50 Sj4yY1pDI2NLIz05bkUmRSRCNClDXllnbjZ1dUR9OU9jUzNPY1EqKlMyaUpPS15oS3pyCnpPTXpw Oz5lVmEmb243JDdfbElYYyl6Knw0R0puWm50VUleVlFecyNERXtzJG5FPy1XVHZ4eCpXPVRiKCln I1J9aQp6cSFkbCFGSihJbiY3MmVjJn1mbyMxbiReNW5RQVVZPUo4KlFfJGhiO0lId3w4XkVHaWZW WGlTWVBUTEhzeXM/ZnsKemNHQkJkS1F8NiZZMXppMVB8QmFXMW1BNWkhQjQqYWpufT5rKXgtb3hz cEx9SFBGP0whZEZHVEBHbztmRXFMJCRqCnplV2ZlUStJMXFLb0RyKSVwXkJKJFZ+ZzNGJnZIXk0k eilzS3cxbCREK1RwQzRud2shISluKE0zNG5zUnZfSWwqfAp6U01md2BeRighcV4qYVRvdihqRioj PlU+PE0kcXBidXc4UDc8Vj93Jm9pPCg2IXlgb3RyKChYRzNeX1EzeE1OJiQKekBgZDc5UWNgYU5P WGVIWnhmMGwpQHN0eWc/JTRiTCZfTzUzYDNWOTxYdjJOVGlzTHNhS2Q2R0UyN2pMPnJYO0A7Cnom fntvTFVKK31ZSzRlWERzeUVNT1d8MiFxQiY+QS1XfT17ZGx9a1RlKFg5U0deTV4xJmspO2BRR2VB dGpXcW9haQp6T3kyeGVxWldARiFPRzRiXnM+KHxDZH5WYCNhfmUtTk1AYDNYZjUmViZ2Ym9xJTBo RkVqMVM5JXxLUDgzNmgpQEYKejlufjM5I0Qre3RwcnhOb0ZpaWJNXz5xaHg8eDAxNEJZOVNmYE5a SHlxMEhHfihgOURaNmFVWCtSZTFXTElCTnExCno0LW9WPSlLS1lDbnJfb3hGREgyaj4pdF9Yb2o9 JnNSblYhTWstWVgpMVpNVyFLayVUPy1VY2hDYEZlYDZMZWZAcAp6eDElQ1ZKY0drb2w3MEUkbjRw TzFFO19GUGFwO2hoNHJKSWpTaTh+LT9NNWhwWWAkTip5SENxKz1URXI8WWAxbDAKek51aSN0MShw UjdVcVg3JUZQKD1mY3VqKighM3t4Ozl8NiMmYEAxQit5MmFgMDhxaTYzRF95OGVpa1c/SlByc05k CnpycX1mR2w0cnI7JGNedDVDM2ZjYj8tI2E7Pl8xIypsVzxNQEMtJEZiJEcpdlM/P2Z5TVpIV21e OSh9UHlWRjsrPAp6MnNLJDxRQkI9XmlNcF92KnBkKlY3SGpDIS1COGhtJF5eKzk8czIwSCFOa01n fDJSJnNJVEN7emVlMTAqQDtTezwKej17diFycigqVzkwbUE0LXduZz5rOV4qSEtvQVJ3LXgjOWUj SF5zSyh5MUVyRD0qRzhFc3RWN188OEZrKyltfiQ9CnpjaXIjSmZoJT0/WXd+STFLRnhOcl93VHdf PWloelcjPlVlcmhme1M0NDFBd1olUDZ8WSMzK0NOPjc7YzVKUSFvUgp6KzJnVlVPUHd1M25hdWVC U1MlQCpmfXN2SypYQSFaMWNlSik4ZiNad3B6Xl9rITZtMXp6NWV5TmQtKnMzSiZJZG4KemUkUEVW YjN3akh3cDI9V1FafTROVDUtJHMhZzM8UEVAcmtsWUZiMntCaC1JQlk9NllycG90bWttaXhaMCtu YGRxCnp0Sj56dU5URyt7JTE5LWdoIXMoI21PcmFaNWVjS2BmKGJAMi1iaHU2X2Y+OGAmWFE7eUkr VWpDPVdRUTdTKkd0MAp6WFhhaHw3JnZWUFI1QDhtcnJRVElPTXBYaDYxST1EaCtKSj1yOCtWeDdz OzNoJGVWUnx2eWhjSWBfZShBQE5fYVcKendZLUYxdTU9UENLKEIwVD14IylEbkkoMkgoX1F4Z3hy cW5+aUp5T3hWRz97WEU8SUQxI3lKQU4oOHpURSVZbzlPCnpSR1gtNHIoc3N2KEJ5YWViPilOd25z U3gxJSRNLU9IMlJwPntyczZWYzhtak43Sz4jfDdxUSo8ZE9jezdnSFdZJgp6SCZwRSgldiZ2bUBy LShfeWF6e3loOFJnJF8wVHkpaWRzVWJteyFXVU5wTF5qPS04TyVlSUN0Rns8OTN1RmlCNEIKemFh e1d1Z1Q9Tz5RNkleY1ZKTmJ3dXswWnRfd1QtfjZOZj5RZlFtND9KWH07SmUwYnZIWWtoZTVIIXtz cUZ2Si1ECnooNl8wfEcqNWA2KUxgMjBndzJHeEwyVVRMIS04PV8jQ1FxTzQkS3w0dUZhZXlFYUlW ekshcj9NOTY4SFMmZDRTXgp6ej17Y0Q3JXtvVTdHPyN3bHRMdyprWXhFQ2FSYn5VRitPT2Qhc0k/ MEQ1XipYPE9jM3E5VnhWa1JvOzwtKUFEazYKelV6Yyh6a0UpZGRhV1pCT2s0Y3NrUG1ERjk7OEI2 T00qYUVie1hxPT84fU5XVXRLSD5gcnNUR0lEc3s4aG41Z19DCnohKWRKJnNXTmU4MTZSMTAoRXpC VS1sSjZNdSlDWFleNXpWbTYzR2Zgej5Hej8ldXBzenhSPnBYcVg3QzMoODhfWQp6PFApWjdYakpV N21wYyhaZVA3M0U7fGQoa0V3VnhGSF4xIVJvZ2YjTWleciU5NmJjNUFWMVVtc182c1VDVlAmY2wK emtIPzE9JHooRE1wWFM9dSk+ZSs3S1dePDBYUHJoMEJ+czlXZXMkfEo5WUVRSXBJKm8zOU1NNVk5 UnNXaSQlIStqCno2RGtwZ0tSVzg5NjFxKj89LTRkfiU7O29hLXMqKmkmRnIpRSFQKUUxS1paOWdn aiUtVkJLMUdvUSt5YHNUQ1B6eAp6UjJASWxsWGpgdmhpWDspTSpYb2BnciN9Oz03e3s+MDhUWG10 fnVmJVo4MlFDNjh4c2ZeR3NwZFFHTGtHKmNxT00KejFeNERXWE96Q2M0bkxfPUFqZyhpaGhFR3pH V0R0bzJAVTFabE4yUEpwSWshSncxd3I9Z01BIXo4bnZrbDkqYXRlCnotaHEyWFpjcUFqUFduY303 VzIpd1BBdFN3KWtCRVptTFl7JFRtJnZCKXomakppMktiI1I4cTJ7RlEzbiFYaSNOWgp6JUo0QjRZ Qi0xRW1KU3FqXmdSO0g1dXFSSXlAV3g0N3RiLXhrO3NqZypoeDJNPWl7I0l0Z05qUm5OOzdLSWoz V1cKelc2R01Sd1U/JXptKjJFKGVvV2ZuWVVFQD5aKGFpK2lpcnc3ekVjXz1FKDgqZmByVTFUWDNZ KUhFfXQ3dTFRWVhuCnpmKXchVDEtfT4xcSNjSUxOQkd8YnQlYEhWenZ3eGZjMzBrbXFmakBlZXcj NnQkcnQmNkghcU95JXRUWDxveSU4bAp6YlZKOGVQVW90K2BMPkIwQUtGKXM7ZTZgLXlSK0k/YHlR RkhwYy1aVXtkMmc/b2o5TjlVSTVwLSp5cWEyS0pyJnQKemJVSjs9ITV8aHh5MVRmT1hsb2V+Njdz Y1JQXztlKjF0ZWlBQUV7byZBI1Z5dil+PnthKitON0ZtODJHIVZqaCtXCnpYV3RhaEc0WTdTd180 IUordURkbCRJe1Q3RGs7fHpObWx9eWlhOXFTRFI+VjNyIUZ5PiUrZWB2TFpJJDVeJnw2Vgp6aj8w WihEeDxIVm9ydUdPZ01VTU5aNj5OOD5wYmFPTyNiNmBJUGx4bm10MClCNlh4KTZKS3w2UmhaXjhY QTxKVk8Kek8wfnw5SyQ8OE5UIWRzUSh+PU93djx0bGI1STtHVUBDQERLUyNERE0/Jkp0fCREX19T Xk1oSmAjVjJUSnpeKVBgCnptcXBEX1dCVChHcVhJYD5fUll3UlVIa1VhUTRjTH07Uz1tVSFqMTJ3 UTlvbzI/MWpEKmFKLVRsMiF6PC1YUkZkcQp6YkNtdi1uUH1kdz9yY18qYntuRH5GMyF2RkxrdG42 cHJxKTk7N1JCQmVoR25KRitaanxtYiQ3alQ3bU9oKDZke0cKek92aHIlKD1hRDlYOXEkUHJ0aGNQ a1FvRmJ6QHMkfG94YitheX1vbigzc1Z7cFB8SGlBYF8kN0Z0ME83emRtZVBeCnpiVyQxe0BpKkUo TjF3S154TXUpcURTdG9zdmxPK0dnTXApU3J0KFJyQmdXMXxqPC0zOG4qOU15PXJwJHRka2EqUAp6 RWRhQ3QmODJOald1aXJYczNyJm1eN00hTUNKM2JUTSFJOEl3SXJ1WjIkPEkpSi1yRlFpa3VKQ0V9 VU9Mek9KQlgKeiYtUXNpME8lSlZANmo3NVZTbnAqcl4wVnQmUT90NkdVNVJOMDxlV0RLWG1MZHpF QX0ldzh3PmckYiooQDRPfTZaCnowazZNcCpDRXhSczs1NmFQfl5QNTNjJW9XKm4jKiE1e1UkYlMq MX1kblR9dzFkPn4zWnU5bH10ZHlZYzVleSF3YQp6WUhpWD1yTXhNOGxoO3QkWDhvdjQycERefHFn QWJkMDh6bngxfXteMld2KXFgSSRgXmB4VlQ9bzxjc1FVKkc2WFEKejRfZiVPa3o9YCVTKDxVfGtU bmZSMkEhR2ZRbjRFemghTEclXiM+e1h6cEhwbUI1OGlsKVZgTztEbGFeclY0QE9DCnpwcH1hWj9a bzN0VEcwOEhuZiRDRjFlWXV9Qylgb3h4cnJEV14lUWJsQnhzRmFuVk5EWDc0Tz9XSjVWVTtJaHdy JAp6dCUxT09xUnZMJFI7I3F+ajlgPHJpWVojWWc+TVZjS2Q0Kj1GT0VHOUpEJX5QXituTjshK3lC PnkpcEVKU3FWQDgKelgqaCZUQnRZMT0wfVExQWZvK0l1UjU0RURneFE5VmRNTHd3N09vZmY/WGh9 KTZAfH5SY0QxQiRPb0B9a1NmY1gxCnp2OGhXWF52Y1puXmU/PGBRfG1xNXUrPmR4PTNnJXllcz1f TlhYcllZcmU1O3s8VTRKclpxXn4yPismXz5CQiMwJQp6eENSQkp2e3g1eXU9YWBqVDxedHU/Pj1T fTA7RS1hTSkqcW0odj8/PUMkc01KKXMkNk8/Zzxyc2k8cigmO1JSTisKenBjOHlmZXpJeSZBQ19C YWIqIzhkKmNgPntIZHk0KlN+YTU5KV5yX0tZXig9MEApYzVwUjtibzdvKStieU1NajA+Cno8VklT ZmpSMUoycVZuPzItNXokIzc/elh9XkA5aiNYazwlNWhOemBVN2tOMVR3fiZFPzBZTGZ5JT52VHly VWIjTQp6NjJqUUErP3ZHUGZFfFdHQC1BQ0BnWlJnLSkjbDtYN3dHYlpxKXI0ekVPS003O1c2XmV7 I01Nb0YpVjB+bmFKQSgKekdeUklNal5LNDUwfEZUVSYyOEtWb28kUm4kX0t6U3R9bk1LPFptY011 Z2VvQlNzZSF2QSQmYCozPWI3KkkyMyFSCnpkU3crfTMreldUSGFEOFFsOT9LYHl6SlYqUShMPCM8 VWAkdFYoTXhpWERhUUNNd3plZ3VuSlRsUk5SKDJhb2FQTgp6P1cjez1PZE40IzheTTBLZStiUWp0 T0d0WkozR3NkWGtBYHNYcClNYDk1QUJ1eGQ4eEFMV300TVE3YklCUDBCJXAKejdDRWh0I1JRaWBi P3ZsbHN8e3VtaEVuOSZoUzIyWShNRGNhKH0jME0lUC0odDBHbD5+alZDTFgrcWRJPDw5SEdQCnpl LTF8YEM4dDF1WWpIMW9jO1ZAWEMhfWBLSUtZP05xS01iT2UhMGpjVFZuYTcqekFkb0U/YX42Y2Qx UUhPPVY/ZQp6S244MjZlRmJEWnBpYD84dnw+SU1aJTJsWGM+Y2dNKjJqR1UtQ0dOPXIlWSMwOHVz fXF8RT8rQFlKR0tlSTZ4SDEKejkxR2JIPGpWV2gjSH1ZTXFaKH14eEFacFpqU2JoQCMpY0YrSXl9 NiMkeDVMRVpsMUglaSY/c2AmK19uS2pjQEM5CnotXmFLOGNvcFRVWVJkUmV4ZEg0bCpHS1MlPXhi XkJUVEt8PkVJfXRwNEpLeWRhaGR9eDd3PkBLKnJQcWtpZj90fAp6eTZ6b0olUzQ8THJWakhXWEpu MHAyKDZALXlNblN8eHJ4JEJXTyNWRWZRRFc3ZyFfNlB5ZERfYjlCKXV6NU1CTTsKekU5c3sjeDha WFc0K2A3MFVZdnV8U0FVd1lufG9oJjtZfCZLaTxSLUhLPSVWc2gqd3tlbzw1LTVHXmhHIzFgNFVn Cno1ZXZgU0F9N25ZMTF6RCQlemIweyZfWHdrbDkmS0BiYEJiU2shcENoJHxnZ2MhYSQ4UkY5QTdq Q181dV4+QERUUwp6KXkxOSVnK1EwR3FycWdIXzk1Qj5nPXpgdHI5VV9kait4VXw/ITc5a19RZHJF Nl9nM0A/KDtQIW1mKT8wRkwkeDYKekEpQEFpSDZjfTtNNlRTM04mSE9RI0A2NmNzRjQ4Qy1fe2tQ JE81PnNMX3QpQ0U9RnwrVVR7MW1TOz9qVnk9Ti14Cnp2VEJua0hXa14hdFZtPUpoJnJBSD47dC0p SGBhb0YxZjczcU4+NlJwSmo9NWtrRHVsc0JLMih9IztQdGcrPVpTaQp6U2J7ZnxsbkRYU3NpTE80 VG5udU5NPUNyIXFlS0FkZklDZkdkdWt8WDNnLWhVQTBlK2ErQGFVRCtHamRmNjJseVIKej8jYGA3 VX1VXnQ9KnNJb2YkVEctMCgwTSV3Ykh4YEApXnNOT1E7K1VoWFZ3RmR4ITAhTVB0LVhMJm9LJXV1 SU8pCno5bS04ZjQwVVh2NUZGVmVFTmhvQGtzbiN2WlhDUz4oNSZJRWArQistSzQrcmVfVy1qMy1F MzBxbVBmX2BKc2xpLQp6OXJUNktaPyZwUVU/WVBqb314PGlxdzFUWntvQmxGTVVCVmZNbmxVejJ7 bzQrNGg9WWVVRU02d2cxa0x2S2BxX2oKemM2RF9QO2dXYXU4UlIkMDVZKGg8MnEwU0UwPzJWI2Vk Nlk3ZFVgdDByfChPPytwckw3TXdwYW1fQEY5Qzs3aVJuCnp1OHZIOXdzMFZ5cW5nNkwtbGRvQyVG ZkdAbmY7PSV7RnNLVlpFY1pKbyU+Kzk/PEpkWFdEPEleSnVOTGVOQXAxTQp6Ymw5JiozYlorNm0q TXdFdU0xOXdkQ1B1ZVBDcnsoZDMqSFkpdG5rWWMwVHNTS3drI1RnZClTa2xZblNUMXtSK30KenA1 TnYtMWlSJUxpUnBAbk52TV4qaz5NWkM9e25EI2NqMntuTHJGVG45R3hDP0Y7cD16YmpmUEo8K0Bh Z1BuSFhiCno4P1RLYzclQ1k2dzc9I3I5dmNqUC1mZngkRmB+N1dHcjRza2A+KFlpUH1WVkxDMWQr MXBsNF9RKWZEYURvMztKcAp6c2olOz5eQDBXcHFLeEp+ZEhIMlNWMU5FbyRZKkR8TXNgJmghUDBs QCNsNDxBNjw9JXs9YGB2Tis1a3ohIURxSSMKem8hJE8jJTw9dlFKTlRDfiFULT5eIW9KN3pQZSth P3pNbE9BYll0TWRqKD5aR2A1KVR2e31QVjFVIW8oNVBmaD5vCnp4OzR2UTJMbyF+YiZtYWw2VFQl PTE4b1lrOHdHPmo5aGZyejQpbntGRWp2TTk2fTtSNitJfTNNPUI+fW97I15TMQp6aV5TVm5ZdTlZ cVZMKU98X2BVa2BPOCtHSHBFZG9ieThTOFlmNzt2czF5QCVZUEE+VlNFJWw2aXs3VzFKSkEyeyMK Sm4od2FNYGE0ZWwmaT89YQoKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9t aXVtLWxpbnV4L2NvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1s YXllci1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1saW51eC9j b21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXItZXhwZWN0 ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjQyYmU2YmQ3OWQwZDYxODQxYjhmYTYxZjUyNmRkNzFkMGQ4MjRh OTYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1saW51 eC9jb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXItZXhw ZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTcgQEAKK2xheWVyIGF0ICgwLDApIHNpemUgODAweDYwMAor ICBSZW5kZXJWaWV3IGF0ICgwLDApIHNpemUgODAweDYwMAorbGF5ZXIgYXQgKDAsMCkgc2l6ZSA4 MDB4NjAwCisgIFJlbmRlckJsb2NrIHtIVE1MfSBhdCAoMCwwKSBzaXplIDgwMHg2MDAKKyAgICBS ZW5kZXJCb2R5IHtCT0RZfSBhdCAoOCw4KSBzaXplIDc4NHg1ODQKKyAgICAgIFJlbmRlckJsb2Nr IHtQfSBhdCAoMCwwKSBzaXplIDc4NHgyMAorICAgICAgICBSZW5kZXJJbmxpbmUge0F9IGF0ICgw LDApIHNpemUgMTQ2eDE5IFtjb2xvcj0jMDAwMEVFXQorICAgICAgICAgIFJlbmRlclRleHQgeyN0 ZXh0fSBhdCAoMCwwKSBzaXplIDE0NngxOQorICAgICAgICAgICAgdGV4dCBydW4gYXQgKDAsMCkg d2lkdGggMTQ2OiAicmRhcjovL3Byb2JsZW0vNjk4MzIwNyIKKyAgICAgICAgUmVuZGVyVGV4dCB7 I3RleHR9IGF0ICgxNDYsMCkgc2l6ZSAzNzR4MTkKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMTQ2 LDApIHdpZHRoIDM3NDogIlNob3VsZCBub3QgbGVhdmUgYmx1ZSBib3ggYmVoaW5kIGFmdGVyIG1v dmluZyB0byB0aGUgdG9wIHJpZ2h0LiIKK2xheWVyIGF0ICg4LDQ0KSBzaXplIDUwMngxMDIKKyAg UmVuZGVyQmxvY2sgKHJlbGF0aXZlIHBvc2l0aW9uZWQpIHtESVZ9IGF0ICgwLDM2KSBzaXplIDUw MngxMDIgW2JvcmRlcjogKDFweCBzb2xpZCAjMDAwMDAwKV0KK2xheWVyIGF0ICgyNTksNDUpIHNp emUgMjUweDEwMAorICBSZW5kZXJCbG9jayAocG9zaXRpb25lZCkge0RJVn0gYXQgKDI1MSwxKSBz aXplIDI1MHgxMDAgW2JnY29sb3I9IzAwMDBGRl0KK2xheWVyIGF0ICg5LDQ1KSBzaXplIDUweDUw CisgIFJlbmRlckJsb2NrIChwb3NpdGlvbmVkKSB7RElWfSBhdCAoMSwxKSBzaXplIDUweDUwIFti Z2NvbG9yPSMwMDAwMDBdCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1 bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS90 ZXN0X2V4cGVjdGF0aW9ucy50eHQKaW5kZXggMGVkYTEyYzc4MDc5NDJmNmU0ZDhlZjFkOWM4MGY0 M2FkM2JjOGNmNy4uMjcxOWExM2ZlY2M0ODE0MmI0NGUwZTZmYTNlZjVjMDU3MWMwZGJiMiAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vdGVzdF9leHBlY3RhdGlvbnMu dHh0CisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL3Rlc3RfZXhwZWN0YXRpb25z LnR4dApAQCAtODc0LDYgKzg3NCw5IEBAIEJVR0NSNjI0MzMgV0lOIDogZmFzdC9pbWFnZXMvZ2lm LWxvb3AtY291bnQuaHRtbCA9IElNQUdFCiAvLyBTVkcgVEVTVFMKIC8vIC0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKKy8v IE5lZWQgcmViYXNlbGluaW5nIGFmdGVyIGJ1ZyA2NDU5MQorQlVHV0s2NDU5MSA6IGNvbXBvc2l0 aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci5odG1sID0gUEFTUyBG QUlMCisKIEJVR0NSODc2MyBNQUMgOiBzdmcvY3VzdG9tL3VzZS1vbi1nLWNvbnRhaW5pbmctZm9y ZWlnbk9iamVjdC1hbmQtaW1hZ2Uuc3ZnID0gSU1BR0UKIAogCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9lZmwvdGVzdF9leHBlY3RhdGlvbnMudHh0IGIvTGF5b3V0VGVzdHMvcGxh dGZvcm0vZWZsL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAppbmRleCA0ZDU0ZjlhNzE2ZmJkNWUyMDg1 MDBhMWRmOTQyY2UyOTM0OTYxMWRiLi4zZTVlYzI0MjQzYzg4YmRmODljMDhiZmM5N2E3NWFlOWVl YjljNjhmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9lZmwvdGVzdF9leHBlY3Rh dGlvbnMudHh0CisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2VmbC90ZXN0X2V4cGVjdGF0aW9u cy50eHQKQEAgLTIsNiArMiw5IEBACiAvLwogLy8gU2VlIGh0dHA6Ly90cmFjLndlYmtpdC5vcmcv d2lraS9UZXN0RXhwZWN0YXRpb25zIGZvciBtb3JlIGluZm9ybWF0aW9uIG9uIHRoaXMgZmlsZS4K IAorLy8gTmVlZCByZWJhc2VsaW5pbmcgYWZ0ZXIgYnVnIDY0NTkxCitCVUdXSzY0NTkxIDogY29t cG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVkLWxheWVyLmh0bWwgPSBQ QVNTIEZBSUwKKwogLy8gTmVlZHMgRU5BQkxFX1NIQURPV19ET00KIEJVR1dLNzY0MzkgREVCVUcg OiBmYXN0L2RvbS9zaGFkb3cvY29udGVudC1lbGVtZW50LWFwaS5odG1sID0gVEVYVAogQlVHV0s3 NjQzOSBERUJVRyA6IGZhc3QvZG9tL3NoYWRvdy9jb250ZW50LWVsZW1lbnQtb3V0c2lkZS1zaGFk b3cuaHRtbCA9IFRFWFQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay90ZXN0 X2V4cGVjdGF0aW9ucy50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvdGVzdF9leHBlY3Rh dGlvbnMudHh0CmluZGV4IGQ3OGI2OGRkMzQ1MzNiNTc1MjNiOTRiZDNlYzYxYjAzZjY0NzhiYzcu LmQzZmJiYmUwM2E1ZTE0NDk3MjM3NGNiYmJmMjM3ZDM1NDkwNTczZGEgMTAwNjQ0Ci0tLSBhL0xh eW91dFRlc3RzL3BsYXRmb3JtL2d0ay90ZXN0X2V4cGVjdGF0aW9ucy50eHQKKysrIGIvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vZ3RrL3Rlc3RfZXhwZWN0YXRpb25zLnR4dApAQCAtMTMsNiArMTMsOSBA QCBCVUdXSzc2ODE0IERFQlVHIDogZmFzdC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVzdC1n ZXQueGh0bWwgPSBDUkFTSAogQlVHV0s3NjgxNSBERUJVRyA6IGVkaXRpbmcvaW5zZXJ0aW5nLzQ5 NjAxMjAtMi5odG1sID0gQ1JBU0gKIEJVR1dLNzY4MTUgREVCVUcgOiBlZGl0aW5nL2V4ZWNDb21t YW5kLzE5NDU1Lmh0bWwgPSBDUkFTSAogCisvLyBOZWVkIHJlYmFzZWxpbmluZyBhZnRlciBidWcg NjQ1OTEKK0JVR1dLNjQ1OTEgOiBjb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNv bXBvc2l0ZWQtbGF5ZXIuaHRtbCA9IFBBU1MgRkFJTAorCiAvLyBGbGFreSB0ZXN0cwogCiBCVUdX SzY4ODc4IDogbWVkaWEvdmlkZW8tcGxheWluZy1hbmQtcGF1c2UuaHRtbCA9IFBBU1MgVEVYVApk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL3Rlc3RfZXhwZWN0YXRpb25zLnR4 dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy90ZXN0X2V4cGVjdGF0aW9ucy50eHQKaW5kZXgg MDIyMDJhMGZmNjYyMjcxZTRlNzQ1ZTM1ZDM3Nzk1ZTI3NTI4ZTZjZS4uNmZkNjZiYWViY2NlOGY0 YWE5ZmRlM2EyM2JlMDlhMDQzYjBmNGIxZiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vbWFjL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9t YWMvdGVzdF9leHBlY3RhdGlvbnMudHh0CkBAIC00NCw2ICs0NCw5IEBAIEJVR1dLNzM3NjYgOiBj c3MzL3VuaWNvZGUtYmlkaS1pc29sYXRlLWFoYXJvbi1mYWlsaW5nLmh0bWwgPSBGQUlMCiAvLyBU aGUgdGVzdCBoaXRzIGFuIEFTU0VSVCBpbiBEZWJ1Zy4KIEJVR1dLNjg4NTkgREVCVUcgOiBmYXN0 L2R5bmFtaWMvY3Jhc2gtcGFpbnQtbm8tZG9jdW1lbnRFbGVtZW50LXJlbmRlcmVyLmh0bWwgPSBD UkFTSAogCisvLyBOZWVkIHJlYmFzZWxpbmluZyBhZnRlciBidWcgNjQ1OTEKK0JVR1dLNjQ1OTEg OiBjb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIuaHRt bCA9IFBBU1MgRkFJTAorCiAvLyBOZWVkIHJlYmFzZWxpbmluZyBhZnRlciA3MTI0NAogQlVHV0s3 NDQzMiA6IGNzczIuMS8yMDExMDMyMy9ib3JkZXItY29uZmxpY3Qtc3R5bGUtMDc5Lmh0bSA9IElN QUdFCiBCVUdXSzc0NDMyIDogY3NzMi4xLzIwMTEwMzIzL2Zsb2F0aW5nLXJlcGxhY2VkLWhlaWdo dC0wMDguaHRtID0gSU1BR0UKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0L3Rl c3RfZXhwZWN0YXRpb25zLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0L3Rlc3RfZXhwZWN0 YXRpb25zLnR4dAppbmRleCBjNmFhMzM0ZDQzNThhNTAzYjMzYTFhNzZmZDdiNWQ1Mjg3YjAzNmE1 Li5kYTIwNDU3OWM1MjM1Mzk3NDZlODc2ZDdkZmM3MGRlYWVjZmY3MmFlIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC90ZXN0X2V4cGVjdGF0aW9ucy50eHQKKysrIGIvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vcXQvdGVzdF9leHBlY3RhdGlvbnMudHh0CkBAIC0yNSw1ICsyNSw4IEBA IEJVR1dLNzQyNzAgOiBmYXN0L2Zvcm1zL2Jhc2ljLXNlbGVjdHMuaHRtbCA9IEZBSUwKIC8vIFRo ZSB0ZXN0IGhpdHMgYW4gQVNTRVJUIGluIERlYnVnLgogQlVHV0s2ODg1OSBERUJVRyA6IGZhc3Qv ZHluYW1pYy9jcmFzaC1wYWludC1uby1kb2N1bWVudEVsZW1lbnQtcmVuZGVyZXIuaHRtbCA9IENS QVNICiAKKy8vIE5lZWQgcmViYXNlbGluaW5nIGFmdGVyIGJ1ZyA2NDU5MQorQlVHV0s2NDU5MSA6 IGNvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci5odG1s ID0gUEFTUyBGQUlMCisKIC8vIE5lZWRzIGJhc2VsaW5lCiBCVUdXSzc2MTE4IDogZmFzdC9jc3Mv dGV4dC1vdmVyZmxvdy1pbnB1dC5odG1sID0gTUlTU0lORwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvcGxhdGZvcm0vd2luL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCBiL0xheW91dFRlc3RzL3BsYXRm b3JtL3dpbi90ZXN0X2V4cGVjdGF0aW9ucy50eHQKaW5kZXggNmRkMjA1MGQwYTY3NzM3OGYwNTRm MTFiOWU3NWYwNDQ1MTBmMTA1YS4uMGRkNTFmOGZjNWEyMDRjNWEzYTE4YTUxOTYxYWVjMDVkZjI5 YWJkYiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2luL3Rlc3RfZXhwZWN0YXRp b25zLnR4dAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vdGVzdF9leHBlY3RhdGlvbnMu dHh0CkBAIC0yMCw2ICsyMCw5IEBAIEJVR1dLNzQyNzAgOiBmYXN0L2Zvcm1zL2Jhc2ljLXNlbGVj dHMuaHRtbCA9IEZBSUwKIC8vIFRoZSB0ZXN0IGhpdHMgYW4gQVNTRVJUIGluIERlYnVnLgogQlVH V0s2ODg1OSBERUJVRyA6IGZhc3QvZHluYW1pYy9jcmFzaC1wYWludC1uby1kb2N1bWVudEVsZW1l bnQtcmVuZGVyZXIuaHRtbCA9IENSQVNICiAKKy8vIE5lZWQgcmViYXNlbGluaW5nIGFmdGVyIGJ1 ZyA2NDU5MQorQlVHV0s2NDU5MSA6IGNvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXkt Y29tcG9zaXRlZC1sYXllci5odG1sID0gUEFTUyBGQUlMCisKIC8vIFJlYmFzZWxpbmUgYWZ0ZXIg YnVnIDcxNzA1LiBBbGwgZGlmZmVyZW5jZXMgYXJlIGR1ZSB0byB0aGUgZmFjdCB0aGF0IHRhYmxl IGNhcHRpb25zIG5vdwogLy8gZXhwYW5kIHRvIHRoZSBmdWxsIHdpZHRoIG9mIHRoZSB0YWJsZS4K IEJVR1dLNzQ4ODggOiB0YWJsZXMvbW96aWxsYS9idWdzL2J1ZzExNjMtMS5odG1sID0gSU1BR0Ur VEVYVAo= 126541 2012-02-10 11:15:55 -0800 2012-02-10 12:15:19 -0800 Rebasing on top of expectation changes. bug-64591-20120210141554.patch text/plain 31823 jgw U3VidmVyc2lvbiBSZXZpc2lvbjogMTA3NDA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzcwYWE3MmQyODkyNThl MDllMDcxNWZkMWNiZTQxYzI2ZGRjM2UxYy4uYzBhMzBiZGVkMDNkMDdiMGU3ZGIwYThiOTcxODY0 YzkxODQ2NzNiYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEyLTAyLTA5ICBKb2Vs IFdlYmJlciAgPGpnd0Bnb29nbGUuY29tPgorCisgICAgICAgIFVzZSByZXF1ZXN0QW5pbWF0aW9u RnJhbWUgY2FsbGJhY2tzIHRvIHB1bXAgQ1NTIGFuaW1hdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTkxCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIG5lZWRlZCAoY292ZXJl ZCBieSB0ZXN0cyBpbiBhbmltYXRpb25zLyopLgorCisgICAgICAgICogcGFnZS9GcmFtZVZpZXcu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVWaWV3OjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRp b25zKToKKyAgICAgICAgKiBwYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmlt YXRpb25zKToKKyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1 cGRhdGVBbmltYXRpb25UaW1lcik6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250cm9s bGVyUHJpdmF0ZTo6ZmlyZUV2ZW50c0FuZFVwZGF0ZVN0eWxlKToKKyAgICAgICAgKFdlYkNvcmU6 OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjphbmltYXRpb25GcmFtZUNhbGxiYWNrRmlyZWQp OgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0aW9uQ29udHJvbGxlcjo6dXBkYXRlQW5pbWF0aW9u cyk6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250cm9sbGVyOjpzZXJ2aWNlQW5pbWF0 aW9ucyk6CisgICAgICAgICogcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5oOgor ICAgICAgICAqIHBhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmg6CisK IDIwMTItMDItMTAgIEFsZXhhbmRlciBQYXZsb3YgIDxhcGF2bG92QGNocm9taXVtLm9yZz4KIAog ICAgICAgICBXZWIgSW5zcGVjdG9yOiBbVGV4dFByb21wdF0gVEFCIHNob3VsZCBjb21wbGV0ZSBz dWdnZXN0aW9ucyB1cCB0byB0aGVpciBjb21tb24gcHJlZml4IGluIENvbnNvbGUKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvRnJhbWVWaWV3LmNwcAppbmRleCBjMGI4NTg3MWZmZTAyYzg4M2RiZTgyM2IwZTM1NjlmNzY2 YmVmYjA2Li5mYjBiNTY2OWE1NmVmZDgxNGU2N2YwYWU3OWRmN2NiNjIzOThkZTBlIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvcGFnZS9GcmFtZVZpZXcuY3BwCkBAIC0yMDk5LDggKzIwOTksMTEgQEAgdm9pZCBGcmFtZVZp ZXc6OnVuc2NoZWR1bGVSZWxheW91dCgpCiAjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZS QU1FKQogdm9pZCBGcmFtZVZpZXc6OnNlcnZpY2VTY3JpcHRlZEFuaW1hdGlvbnMoRE9NVGltZVN0 YW1wIHRpbWUpCiB7Ci0gICAgVmVjdG9yPFJlZlB0cjxEb2N1bWVudD4gPiBkb2N1bWVudHM7Cisg ICAgVmVjdG9yPEFuaW1hdGlvbkNvbnRyb2xsZXIqPiBhbmltYXRpb25zOworICAgIGZvciAoRnJh bWUqIGZyYW1lID0gbV9mcmFtZS5nZXQoKTsgZnJhbWU7IGZyYW1lID0gZnJhbWUtPnRyZWUoKS0+ dHJhdmVyc2VOZXh0KCkpCisgICAgICAgIGZyYW1lLT5hbmltYXRpb24oKS0+c2VydmljZUFuaW1h dGlvbnMoKTsKIAorICAgIFZlY3RvcjxSZWZQdHI8RG9jdW1lbnQ+ID4gZG9jdW1lbnRzOwogICAg IGZvciAoRnJhbWUqIGZyYW1lID0gbV9mcmFtZS5nZXQoKTsgZnJhbWU7IGZyYW1lID0gZnJhbWUt PnRyZWUoKS0+dHJhdmVyc2VOZXh0KCkpCiAgICAgICAgIGRvY3VtZW50cy5hcHBlbmQoZnJhbWUt PmRvY3VtZW50KCkpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlv bi9BbmltYXRpb25Db250cm9sbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9u L0FuaW1hdGlvbkNvbnRyb2xsZXIuY3BwCmluZGV4IDc0NWQ1MTQ2YjkxOGVkMDUwZjc4ZjFiNDJh MjkyYjVhMWZhNGRhYTAuLjgxMmQxOGQ4NjkwOGRjNjZlMTAwMjJlNjBkMmJlOTBmMzJlYWZlZDQg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRy b2xsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNv bnRyb2xsZXIuY3BwCkBAIC0zNSw2ICszNSw3IEBACiAjaW5jbHVkZSAiQ29tcG9zaXRlQW5pbWF0 aW9uLmgiCiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCisjaW5j bHVkZSAiRnJhbWVWaWV3LmgiCiAjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgogI2luY2x1ZGUgIldl YktpdEFuaW1hdGlvbkV2ZW50LmgiCiAjaW5jbHVkZSAiV2ViS2l0QW5pbWF0aW9uTGlzdC5oIgpA QCAtNDQsNyArNDUsNiBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLS8vIEZJWE1FOiBXaHkg aXNuJ3QgdGhpcyBzZXQgdG8gNjBmcHMgb3Igc29tZXRoaW5nPwogc3RhdGljIGNvbnN0IGRvdWJs ZSBjQW5pbWF0aW9uVGltZXJEZWxheSA9IDAuMDI1Owogc3RhdGljIGNvbnN0IGRvdWJsZSBjQmVn aW5BbmltYXRpb25VcGRhdGVUaW1lTm90U2V0ID0gLTE7CiAKQEAgLTg0LDkgKzg0LDkgQEAgYm9v bCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6Y2xlYXIoUmVuZGVyT2JqZWN0KiByZW5kZXJl cikKICAgICByZXR1cm4gYW5pbWF0aW9uLT5zdXNwZW5kZWQoKTsKIH0KIAotdm9pZCBBbmltYXRp b25Db250cm9sbGVyUHJpdmF0ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0Q2hh bmdlZC8qID0gZmFsc2UqLykKK2RvdWJsZSBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6dXBk YXRlQW5pbWF0aW9ucyhTZXRDaGFuZ2VkIGNhbGxTZXRDaGFuZ2VkLyogPSBEb05vdENhbGxTZXRD aGFuZ2VkKi8pCiB7Ci0gICAgZG91YmxlIG5lZWRzU2VydmljZSA9IC0xOworICAgIGRvdWJsZSB0 aW1lVG9OZXh0U2VydmljZSA9IC0xOwogICAgIGJvb2wgY2FsbGVkU2V0Q2hhbmdlZCA9IGZhbHNl OwogCiAgICAgUmVuZGVyT2JqZWN0QW5pbWF0aW9uTWFwOjpjb25zdF9pdGVyYXRvciBhbmltYXRp b25zRW5kID0gbV9jb21wb3NpdGVBbmltYXRpb25zLmVuZCgpOwpAQCAtOTQsMTAgKzk0LDEwIEBA IHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OnVwZGF0ZUFuaW1hdGlvblRpbWVyKGJv b2wgY2FsbFNldENoYW5nZWQvKiA9IGZhCiAgICAgICAgIENvbXBvc2l0ZUFuaW1hdGlvbiogY29t cEFuaW0gPSBpdC0+c2Vjb25kLmdldCgpOwogICAgICAgICBpZiAoIWNvbXBBbmltLT5zdXNwZW5k ZWQoKSAmJiBjb21wQW5pbS0+aGFzQW5pbWF0aW9ucygpKSB7CiAgICAgICAgICAgICBkb3VibGUg dCA9IGNvbXBBbmltLT50aW1lVG9OZXh0U2VydmljZSgpOwotICAgICAgICAgICAgaWYgKHQgIT0g LTEgJiYgKHQgPCBuZWVkc1NlcnZpY2UgfHwgbmVlZHNTZXJ2aWNlID09IC0xKSkKLSAgICAgICAg ICAgICAgICBuZWVkc1NlcnZpY2UgPSB0OwotICAgICAgICAgICAgaWYgKG5lZWRzU2VydmljZSA9 PSAwKSB7Ci0gICAgICAgICAgICAgICAgaWYgKGNhbGxTZXRDaGFuZ2VkKSB7CisgICAgICAgICAg ICBpZiAodCAhPSAtMSAmJiAodCA8IHRpbWVUb05leHRTZXJ2aWNlIHx8IHRpbWVUb05leHRTZXJ2 aWNlID09IC0xKSkKKyAgICAgICAgICAgICAgICB0aW1lVG9OZXh0U2VydmljZSA9IHQ7CisgICAg ICAgICAgICBpZiAoIXRpbWVUb05leHRTZXJ2aWNlKSB7CisgICAgICAgICAgICAgICAgaWYgKGNh bGxTZXRDaGFuZ2VkID09IENhbGxTZXRDaGFuZ2VkKSB7CiAgICAgICAgICAgICAgICAgICAgIE5v ZGUqIG5vZGUgPSBpdC0+Zmlyc3QtPm5vZGUoKTsKICAgICAgICAgICAgICAgICAgICAgQVNTRVJU KCFub2RlIHx8IChub2RlLT5kb2N1bWVudCgpICYmICFub2RlLT5kb2N1bWVudCgpLT5pblBhZ2VD YWNoZSgpKSk7CiAgICAgICAgICAgICAgICAgICAgIG5vZGUtPnNldE5lZWRzU3R5bGVSZWNhbGMo U3ludGhldGljU3R5bGVDaGFuZ2UpOwpAQCAtMTA4LDI4ICsxMDgsMzUgQEAgdm9pZCBBbmltYXRp b25Db250cm9sbGVyUHJpdmF0ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0Q2hh bmdlZC8qID0gZmEKICAgICAgICAgICAgIH0KICAgICAgICAgfQogICAgIH0KLSAgICAKKwogICAg IGlmIChjYWxsZWRTZXRDaGFuZ2VkKQogICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT51cGRh dGVTdHlsZUlmTmVlZGVkKCk7Ci0gICAgCisKKyAgICByZXR1cm4gdGltZVRvTmV4dFNlcnZpY2U7 Cit9CisKK3ZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OnVwZGF0ZUFuaW1hdGlvblRp bWVyKFNldENoYW5nZWQgY2FsbFNldENoYW5nZWQvKiA9IERvTm90Q2FsbFNldENoYW5nZWQqLykK K3sKKyAgICBkb3VibGUgdGltZVRvTmV4dFNlcnZpY2UgPSB1cGRhdGVBbmltYXRpb25zKGNhbGxT ZXRDaGFuZ2VkKTsKKwogICAgIC8vIElmIHdlIHdhbnQgc2VydmljZSBpbW1lZGlhdGVseSwgd2Ug c3RhcnQgYSByZXBlYXRpbmcgdGltZXIgdG8gcmVkdWNlIHRoZSBvdmVyaGVhZCBvZiBzdGFydGlu ZwotICAgIGlmIChuZWVkc1NlcnZpY2UgPT0gMCkgeworICAgIGlmICghdGltZVRvTmV4dFNlcnZp Y2UpIHsKICAgICAgICAgaWYgKCFtX2FuaW1hdGlvblRpbWVyLmlzQWN0aXZlKCkgfHwgbV9hbmlt YXRpb25UaW1lci5yZXBlYXRJbnRlcnZhbCgpID09IDApCiAgICAgICAgICAgICBtX2FuaW1hdGlv blRpbWVyLnN0YXJ0UmVwZWF0aW5nKGNBbmltYXRpb25UaW1lckRlbGF5KTsKICAgICAgICAgcmV0 dXJuOwogICAgIH0KLSAgICAKKwogICAgIC8vIElmIHdlIGRvbid0IG5lZWQgc2VydmljZSwgd2Ug d2FudCB0byBtYWtlIHN1cmUgdGhlIHRpbWVyIGlzIG5vIGxvbmdlciBydW5uaW5nCi0gICAgaWYg KG5lZWRzU2VydmljZSA8IDApIHsKKyAgICBpZiAodGltZVRvTmV4dFNlcnZpY2UgPCAwKSB7CiAg ICAgICAgIGlmIChtX2FuaW1hdGlvblRpbWVyLmlzQWN0aXZlKCkpCiAgICAgICAgICAgICBtX2Fu aW1hdGlvblRpbWVyLnN0b3AoKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KLSAgICAKKwogICAg IC8vIE90aGVyd2lzZSwgd2Ugd2FudCB0byBzdGFydCBhIG9uZS1zaG90IHRpbWVyIHNvIHdlIGdl dCBoZXJlIGFnYWluCiAgICAgaWYgKG1fYW5pbWF0aW9uVGltZXIuaXNBY3RpdmUoKSkKICAgICAg ICAgbV9hbmltYXRpb25UaW1lci5zdG9wKCk7Ci0gICAgbV9hbmltYXRpb25UaW1lci5zdGFydE9u ZVNob3QobmVlZHNTZXJ2aWNlKTsKKyAgICBtX2FuaW1hdGlvblRpbWVyLnN0YXJ0T25lU2hvdCh0 aW1lVG9OZXh0U2VydmljZSk7CiB9CiAKIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6 OnVwZGF0ZVN0eWxlSWZOZWVkZWREaXNwYXRjaGVyRmlyZWQoVGltZXI8QW5pbWF0aW9uQ29udHJv bGxlclByaXZhdGU+KikKQEAgLTE0Myw3ICsxNTAsNyBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xs ZXJQcml2YXRlOjpmaXJlRXZlbnRzQW5kVXBkYXRlU3R5bGUoKQogICAgIFJlZlB0cjxGcmFtZT4g cHJvdGVjdG9yID0gbV9mcmFtZTsKIAogICAgIGJvb2wgdXBkYXRlU3R5bGUgPSAhbV9ldmVudHNU b0Rpc3BhdGNoLmlzRW1wdHkoKSB8fCAhbV9ub2RlQ2hhbmdlc1RvRGlzcGF0Y2guaXNFbXB0eSgp OwotICAgIAorCiAgICAgLy8gZmlyZSBhbGwgdGhlIGV2ZW50cwogICAgIFZlY3RvcjxFdmVudFRv RGlzcGF0Y2g+IGV2ZW50c1RvRGlzcGF0Y2ggPSBtX2V2ZW50c1RvRGlzcGF0Y2g7CiAgICAgbV9l dmVudHNUb0Rpc3BhdGNoLmNsZWFyKCk7CkBAIC0xNTQsMTQgKzE2MSwxNCBAQCB2b2lkIEFuaW1h dGlvbkNvbnRyb2xsZXJQcml2YXRlOjpmaXJlRXZlbnRzQW5kVXBkYXRlU3R5bGUoKQogICAgICAg ICBlbHNlCiAgICAgICAgICAgICBpdC0+ZWxlbWVudC0+ZGlzcGF0Y2hFdmVudChXZWJLaXRBbmlt YXRpb25FdmVudDo6Y3JlYXRlKGl0LT5ldmVudFR5cGUsIGl0LT5uYW1lLCBpdC0+ZWxhcHNlZFRp bWUpKTsKICAgICB9Ci0gICAgCisKICAgICAvLyBjYWxsIHNldENoYW5nZWQgb24gYWxsIHRoZSBl bGVtZW50cwogICAgIFZlY3RvcjxSZWZQdHI8Tm9kZT4gPjo6Y29uc3RfaXRlcmF0b3Igbm9kZUNo YW5nZXNUb0Rpc3BhdGNoRW5kID0gbV9ub2RlQ2hhbmdlc1RvRGlzcGF0Y2guZW5kKCk7CiAgICAg Zm9yIChWZWN0b3I8UmVmUHRyPE5vZGU+ID46OmNvbnN0X2l0ZXJhdG9yIGl0ID0gbV9ub2RlQ2hh bmdlc1RvRGlzcGF0Y2guYmVnaW4oKTsgaXQgIT0gbm9kZUNoYW5nZXNUb0Rpc3BhdGNoRW5kOyAr K2l0KQogICAgICAgICAoKml0KS0+c2V0TmVlZHNTdHlsZVJlY2FsYyhTeW50aGV0aWNTdHlsZUNo YW5nZSk7Ci0gICAgCisKICAgICBtX25vZGVDaGFuZ2VzVG9EaXNwYXRjaC5jbGVhcigpOwotICAg IAorCiAgICAgaWYgKHVwZGF0ZVN0eWxlICYmIG1fZnJhbWUpCiAgICAgICAgIG1fZnJhbWUtPmRv Y3VtZW50KCktPnVwZGF0ZVN0eWxlSWZOZWVkZWQoKTsKIH0KQEAgLTE5NCw2ICsyMDEsMTYgQEAg dm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6YWRkTm9kZUNoYW5nZVRvRGlzcGF0Y2go UGFzc1JlZlB0cjxOb2RlPiBub2RlKQogICAgIHN0YXJ0VXBkYXRlU3R5bGVJZk5lZWRlZERpc3Bh dGNoZXIoKTsKIH0KIAorI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKK3ZvaWQg QW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tGaXJlZCgp Cit7CisgICAgZG91YmxlIHRpbWVUb05leHRTZXJ2aWNlID0gdXBkYXRlQW5pbWF0aW9ucyhDYWxs U2V0Q2hhbmdlZCk7CisKKyAgICBpZiAodGltZVRvTmV4dFNlcnZpY2UgPj0gMCkKKyAgICAgICAg bV9mcmFtZS0+ZG9jdW1lbnQoKS0+dmlldygpLT5zY2hlZHVsZUFuaW1hdGlvbigpOworfQorI2Vu ZGlmCisKIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmFuaW1hdGlvblRpbWVyRmly ZWQoVGltZXI8QW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU+KikKIHsKICAgICAvLyBNYWtlIHN1 cmUgYW5pbWF0aW9uVXBkYXRlVGltZSBpcyB1cGRhdGVkLCBzbyB0aGF0IGl0IGlzIGN1cnJlbnQg ZXZlbiBpZiBubwpAQCAtMjAyLDcgKzIxOSw3IEBAIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclBy aXZhdGU6OmFuaW1hdGlvblRpbWVyRmlyZWQoVGltZXI8QW5pbWF0aW9uQ29udHJvbGxlclByCiAK ICAgICAvLyBXaGVuIHRoZSB0aW1lciBmaXJlcywgYWxsIHdlIGRvIGlzIGNhbGwgc2V0Q2hhbmdl ZCBvbiBhbGwgRE9NIG5vZGVzIHdpdGggcnVubmluZyBhbmltYXRpb25zIGFuZCB0aGVuIGRvIGFu IGltbWVkaWF0ZQogICAgIC8vIHVwZGF0ZVN0eWxlSWZOZWVkZWQuICBJdCB3aWxsIHRoZW4gY2Fs bCBiYWNrIHRvIHVzIHdpdGggbmV3IGluZm9ybWF0aW9uLgotICAgIHVwZGF0ZUFuaW1hdGlvblRp bWVyKHRydWUpOworICAgIHVwZGF0ZUFuaW1hdGlvblRpbWVyKENhbGxTZXRDaGFuZ2VkKTsKIAog ICAgIC8vIEZpcmUgZXZlbnRzIHJpZ2h0IGF3YXksIHRvIGF2b2lkIGEgZmxhc2ggb2YgdW5hbmlt YXRlZCBzdHlsZSBhZnRlciBhbiBhbmltYXRpb24gY29tcGxldGVzLCBhbmQgYmVmb3JlCiAgICAg Ly8gdGhlICdlbmQnIGV2ZW50IGZpcmVzLgpAQCAtNDk5LDggKzUxNiwxMyBAQCBQYXNzUmVmUHRy PFJlbmRlclN0eWxlPiBBbmltYXRpb25Db250cm9sbGVyOjp1cGRhdGVBbmltYXRpb25zKFJlbmRl ck9iamVjdCogcmVuZAogICAgIFJlZlB0cjxDb21wb3NpdGVBbmltYXRpb24+IHJlbmRlcmVyQW5p bWF0aW9ucyA9IG1fZGF0YS0+YWNjZXNzQ29tcG9zaXRlQW5pbWF0aW9uKHJlbmRlcmVyKTsKICAg ICBSZWZQdHI8UmVuZGVyU3R5bGU+IGJsZW5kZWRTdHlsZSA9IHJlbmRlcmVyQW5pbWF0aW9ucy0+ YW5pbWF0ZShyZW5kZXJlciwgb2xkU3R5bGUsIG5ld1N0eWxlKTsKIAotICAgIGlmIChyZW5kZXJl ci0+cGFyZW50KCkgfHwgbmV3U3R5bGUtPmFuaW1hdGlvbnMoKSB8fCAob2xkU3R5bGUgJiYgb2xk U3R5bGUtPmFuaW1hdGlvbnMoKSkpCisgICAgaWYgKHJlbmRlcmVyLT5wYXJlbnQoKSB8fCBuZXdT dHlsZS0+YW5pbWF0aW9ucygpIHx8IChvbGRTdHlsZSAmJiBvbGRTdHlsZS0+YW5pbWF0aW9ucygp KSkgewogICAgICAgICBtX2RhdGEtPnVwZGF0ZUFuaW1hdGlvblRpbWVyKCk7CisjaWYgRU5BQkxF KFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQorICAgICAgICBpZiAoRnJhbWVWaWV3KiB2aWV3ID0g cmVuZGVyZXItPmRvY3VtZW50KCktPnZpZXcoKSkKKyAgICAgICAgICAgIHZpZXctPnNjaGVkdWxl QW5pbWF0aW9uKCk7CisjZW5kaWYKKyAgICB9CiAKICAgICBpZiAoYmxlbmRlZFN0eWxlICE9IG5l d1N0eWxlKSB7CiAgICAgICAgIC8vIElmIHRoZSBhbmltYXRpb25zL3RyYW5zaXRpb25zIGNoYW5n ZSBvcGFjaXR5IG9yIHRyYW5zZm9ybSwgd2UgbmVlZCB0byB1cGRhdGUKQEAgLTU1Nyw2ICs1Nzks MTMgQEAgdm9pZCBBbmltYXRpb25Db250cm9sbGVyOjpyZXN1bWVBbmltYXRpb25zKCkKICAgICBt X2RhdGEtPnJlc3VtZUFuaW1hdGlvbnMoKTsKIH0KIAorI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1B VElPTl9GUkFNRSkKK3ZvaWQgQW5pbWF0aW9uQ29udHJvbGxlcjo6c2VydmljZUFuaW1hdGlvbnMo KQoreworICAgIG1fZGF0YS0+YW5pbWF0aW9uRnJhbWVDYWxsYmFja0ZpcmVkKCk7Cit9CisjZW5k aWYKKwogdm9pZCBBbmltYXRpb25Db250cm9sbGVyOjpzdXNwZW5kQW5pbWF0aW9uc0ZvckRvY3Vt ZW50KERvY3VtZW50KiBkb2N1bWVudCkKIHsKICAgICBtX2RhdGEtPnN1c3BlbmRBbmltYXRpb25z Rm9yRG9jdW1lbnQoZG9jdW1lbnQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9h bmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmlt YXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5oCmluZGV4IGNjZGM2YzRhNDJkN2ExYjM1MDJkNzcw NzgwNzAxNjY5NWUzNjRiNDguLjE4NzcyZGQ1OTM5NGFiODA0NjBmZDk2NTRkZjRmNzlkNTZlYmVh ZWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNv bnRyb2xsZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25D b250cm9sbGVyLmgKQEAgLTY2LDYgKzY2LDkgQEAgcHVibGljOgogCiAgICAgdm9pZCBzdXNwZW5k QW5pbWF0aW9ucygpOwogICAgIHZvaWQgcmVzdW1lQW5pbWF0aW9ucygpOworI2lmIEVOQUJMRShS RVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKKyAgICB2b2lkIHNlcnZpY2VBbmltYXRpb25zKCk7Cisj ZW5kaWYKIAogICAgIHZvaWQgc3VzcGVuZEFuaW1hdGlvbnNGb3JEb2N1bWVudChEb2N1bWVudCop OwogICAgIHZvaWQgcmVzdW1lQW5pbWF0aW9uc0ZvckRvY3VtZW50KERvY3VtZW50Kik7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVy UHJpdmF0ZS5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJv bGxlclByaXZhdGUuaAppbmRleCA0MWVlYmZmMTZkZjVjOTNkMmFjZmE4NWJlNDk5MTdhMWQ0OGZl MDhlLi4yYzIwNTFlZmY2MGI5M2MxMjRiNzAwN2JmZTY0YjdiMmExNGE4YzkwIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyUHJpdmF0 ZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xs ZXJQcml2YXRlLmgKQEAgLTUxLDEzICs1MSwyMCBAQCBjbGFzcyBSZW5kZXJPYmplY3Q7CiBjbGFz cyBSZW5kZXJTdHlsZTsKIGNsYXNzIFdlYktpdEFuaW1hdGlvbkxpc3Q7CiAKK2VudW0gU2V0Q2hh bmdlZCB7CisgICAgRG9Ob3RDYWxsU2V0Q2hhbmdlZCA9IDAsCisgICAgQ2FsbFNldENoYW5nZWQg PSAxCit9OworCiBjbGFzcyBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZSB7CiAgICAgV1RGX01B S0VfTk9OQ09QWUFCTEUoQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUpOyBXVEZfTUFLRV9GQVNU X0FMTE9DQVRFRDsKIHB1YmxpYzoKICAgICBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZShGcmFt ZSopOwogICAgIH5BbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZSgpOwogCi0gICAgdm9pZCB1cGRh dGVBbmltYXRpb25UaW1lcihib29sIGNhbGxTZXRDaGFuZ2VkID0gZmFsc2UpOworICAgIC8vIFJl dHVybnMgdGhlIHRpbWUgdW50aWwgdGhlIG5leHQgYW5pbWF0aW9uIG5lZWRzIHRvIGJlIHNlcnZp Y2VkLCBvciAtMSBpZiB0aGVyZSBhcmUgbm9uZS4KKyAgICBkb3VibGUgdXBkYXRlQW5pbWF0aW9u cyhTZXRDaGFuZ2VkIGNhbGxTZXRDaGFuZ2VkID0gRG9Ob3RDYWxsU2V0Q2hhbmdlZCk7CisgICAg dm9pZCB1cGRhdGVBbmltYXRpb25UaW1lcihTZXRDaGFuZ2VkIGNhbGxTZXRDaGFuZ2VkID0gRG9O b3RDYWxsU2V0Q2hhbmdlZCk7CiAKICAgICBQYXNzUmVmUHRyPENvbXBvc2l0ZUFuaW1hdGlvbj4g YWNjZXNzQ29tcG9zaXRlQW5pbWF0aW9uKFJlbmRlck9iamVjdCopOwogICAgIGJvb2wgY2xlYXIo UmVuZGVyT2JqZWN0Kik7CkBAIC03MSw2ICs3OCw5IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgc3Vz cGVuZEFuaW1hdGlvbnMoKTsKICAgICB2b2lkIHJlc3VtZUFuaW1hdGlvbnMoKTsKKyNpZiBFTkFC TEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCisgICAgdm9pZCBhbmltYXRpb25GcmFtZUNhbGxi YWNrRmlyZWQoKTsKKyNlbmRpZgogCiAgICAgdm9pZCBzdXNwZW5kQW5pbWF0aW9uc0ZvckRvY3Vt ZW50KERvY3VtZW50Kik7CiAgICAgdm9pZCByZXN1bWVBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9j dW1lbnQqKTsKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2NvbXBvc2l0aW5nL3JlcGFpbnQvYmVj b21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci5odG1sIGIvTGF5b3V0VGVzdHMvY29tcG9zaXRp bmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVkLWxheWVyLmh0bWwKaW5kZXggZDUx MTA2ZmMzM2I0YmY3NmU4NmE3MjExZmY1YThhMzdiMTNkMGE1Ni4uY2FmNzMwOWJmMGVlYmQwYjAw OWExNmUzYzljYjc0YTIzMzFmMWYwMiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvY29tcG9zaXRp bmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVkLWxheWVyLmh0bWwKKysrIGIvTGF5 b3V0VGVzdHMvY29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVkLWxh eWVyLmh0bWwKQEAgLTUxLDggKzUxLDEwIEBACiAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJjb250YWluZXIiKS5jbGFzc05hbWUgPSAicmlnaHQiOwogICAgICAgICB3aW5kb3cuc2V0 VGltZW91dChmdW5jdGlvbigpIHsKICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi Y29udGFpbmVyIikuY2xhc3NOYW1lID0gIiI7Ci0gICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKLSAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLm5vdGlmeURv bmUoKTsKKyAgICAgICAgICB3aW5kb3cuc2V0VGltZW91dChmdW5jdGlvbigpIHsKKyAgICAgICAg ICAgIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgICAgICAgIGxheW91 dFRlc3RDb250cm9sbGVyLm5vdGlmeURvbmUoKTsKKyAgICAgICAgICB9LCAyNTApOwogICAgICAg ICB9LCAyNTApOwogICAgICAgfQogCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9j aHJvbWl1bS1saW51eC9jb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0 ZWQtbGF5ZXItZXhwZWN0ZWQucG5nIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0tbGlu dXgvY29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVkLWxheWVyLWV4 cGVjdGVkLnBuZwppbmRleCBhN2NkZWNjMTc2ZDU3YWY1OGZkMzllMzczZTAxOTc0MmI1ODYwMGI1 Li42NGZhYTk2NjAwNDAyMjZhMTM3YTczMDE5ZWQ5ZmY4YzY0ZDhlYzlmIDEwMDY0NApHSVQgYmlu YXJ5IHBhdGNoCmxpdGVyYWwgNzk5MAp6Y21lSTFYO19vancjUVIjaXhiamJEX2xqMFIqcn4+QWZ0 QFlRbCpxM0Rnc0o/Zkp8Wi1XUTslezx2Mzc5UD1rTz4KeiR3ZFdaNDA4d30zMVhRQTRnP1pJTkZy bHxLb35NVyRhRylOejR6O1YmZ1koZiVKYzNnJnpyczFgbWdvLXVib0dpCnotSlI2OzlOcSYwZnor TFVgU35nY3dEVHdrd0IhMSY5bCotTDl9ZW1SOXxyTGt1ZzNANzNKRjVRQn05VkUxQV91Qgp6JSZh VWUmVzJoQ253cHBmbmNoNW0mZ3kxfU55eXBZNVVaUChaTWNgYEtfSn5lPWJ0Wkp5SVpgJWoocH1S UFZIUloKemBEMGh0O21oYTBZeUtYNV56KDF1VTNpeDxwOGZvZ2lecVM9MjRDdEF3czl9ZFgoJiV4 RDs7Z24ye0oycjhTZ3JKCnpHfFBGXmI/TVU4emFAVkMqeTImUStLMFhDJDQ+MXMqIUIyJUZtWTRS STZeYH47WnlVbVdhI05aWHFISEwkcDZUJgp6e1UlejtEXjVYRHImNXJJXjIpPF5mWCl8QmdHRkQx Sy1yYyVfSldTUz9BIXNgYilwXndgdXB6RnB4Ki1pemFgNSoKekkoLU9yJGV0JjhyUitfI2lhQD1+ OWgqTl5aQmNOJUFvdlAlQTIrI0xNWi1sRW9qWiZDYUYqRnNYem9UNCpWYThjCno1YSZAb0Mha1Uq K0N0OWNwTWxaUzxtPTNhcGVBcD4zSHBAWDhybmYzKG5IRyNJdE5iN1VDSjZybj5pcE9NNkRSdAp6 UUkqQC1GfClCPyNqUWModns3JUhqOSYxbj9maT9XQGsoTH5CNHNiYUdJQn1WQC0kMm0jLSpoRGk2 b009NiRJUk4KemB1PjVhX1FpNTxjeHVBT2Bhb3cpNFU3PWdeVz4wST81VyNYY2prX1IxLWV7PGo/ VlBnVHxEJmxvJUc0QW5NfnN9Cno8M3Q5Rmx8cGx+YShpaEsqbVp4bVlRdEQlK0x1Q1JlMmNEYzsx RHRkTTw9V2AmPURSRlVPVTw3PD4tZ3k9JFNSawp6PmFMSDl0PFdAb3FGdH4pJk50UFJSPDUza3ht YWN2NWhjSmA7cGQ2Rz9jQH1pSyM7QzM9eDdxVXo7QlB0Wl5NJS0KenFxanY8OSNGOSs5bGM7Q15S OFEtcShYKip4MllTc2wwb0JXcVorRTFvKC1KTSMlOWQ1VHMzVEs4I1hqPmtqX25uCnpeJHo2dnQq azZZcl9ycFV7UmNDUkI/c3dMWD1vYX5XLThBfT5QT24oVk9mblNOQyE3c1FNQk09YjBxOzg7SndK bAp6XkJ8SWpeY2FiTkVuOW85dkMxT2clZ1JFQTNOMCNkWTAxOzRhSHglYk42T1NVdn5zczxvMzZT M29UcW9ALW1gPCsKemVEcnl7XnpZMl48aUM3dHc/UEtlYklKMzBGblhPSVlpdytUaEVzfH1HJDto NChFWDslU2RxZVdIMjIpUGI3KTNiCnpSYyl2Zk9GSGU+dTdhcVZEcUByUlpvNGh+YV5sN3tvQSlF QVAhKEc0QiNqdHhBZUEtNjF4UU9YK0Vwe2c2ME4rYQp6d3I2TSk3V0VYZXleZygmTjNyTVBLN0lF T250M1dJJk5oPjg2fTlad2VDdWRtNm9uWW57V3g3X3d8MEowLTc1WX4Kel9fbDxsRDJ2Kz9BWj9A RERfX142ZEpjcyg2VGxJNEUmc2N2WVpGYj8pJTshNUMtbFM5ZU5PSCk1bWBJUWchOV5RCnpGSFJN eHpReXJkdVg0OCtrN0tkdlZaQiNgPmFzZjtaYHVea3BoXzhmPjkoOHJFJUVvWTN4e1Q0X2pgNCRu cV99Vwp6UDNAO2FIfm8/cTgkdCUxVWVTWGUrViNJMEpMRGp+I15zT35iR2BGTTVAaXprK1JtXzte X2RgQ1lUX3EwU3ZhaHsKenpOJklxJWJzcUhseSt4NnR1M0J0OGotTTVSJHEyKUZlc0spWkEhViZE VDArfWQ+VyM+eUx3Uzg+KlEmOFoyI3tuCno8dGooZHghbT1UN2EodzV6RiVXLWZMdG8lO3ImUmhj V0ZjKHd4flFEcXR+bW16V0NPbj4ta2dwUVo9NjliWDtSQgp6Q0h+ZzU1S3s5TW10XlFhMGdFT2xF STBJP1h1JlVKM3tVSSt2TTYhMW00Zj4hdDhGRztGWnxmMFJfVD5nM3VCblkKemcrX0hodTUtPzU8 ZHJiNFVZR1ZBdz5KeDA9KmI+M3dAQT19QUs0eSMrNzdpZnZieTxtPStnTUl7YnN4OzhRNyhJCnpo cHRkV0JqQHtHckY1akZqP347QjRpKDgzSzdAemc+YSpKbEskY2s3X19PVmtWa0xoWlhmcEtITUgh dVJIaWJHYwp6WjRxOGtRKkZ5XkJvJmJ3U2xWUSFrbj5vVm8oX00mdkt1MnxseWg2ZENESTNiVmNP YmU1UDJaTzVIQWBrVlZOZEkKekVPMWd0ckB+fiFrKFNnJm16NmtQdEdRKlVwaE5obitEKiVFK3lA MFNhaWF5a0g8aDlhJU5PaFhxfld3aXR9PkEpCnpTJj5xPXQ2TFdxPyV9UUhnXk5IdlAqdCpRdSZU fHJifEs0WjExX0tHdGlHSTtScDEtLWlOYT13Mkwod0h2Q0lnUwp6dnduIXxUaDB8JVFoUiQ7K3d7 WFNtOzVMJGcmWi1jPWlEMDJid0RmU0p2fXtPYDZzbipha1YhZFluUWF+TkZVbzQKekozbGEhKldH KUc4TjJUUClOWjVpTHhFWHV3aG44MntGP048NDxVKlRKZm1lU3VLJTVQLSgrUUZaRXtrZ09XM0sp CnpMMTRxPmAyajxHTz5yQyRpemNCRXI7PmpqZUh9Sn1CfWNNYXk5VTZEJnJUSTNpSWN5N2Y0dG5p QnplU3N2aiRHMwp6bjdCX0hSVXp0IzwhY094ZHxKYkUpeFkoJUpgTlIydWVtWVhsU1BzVk5Qe09Y Xlk4Q1ZgZTsqTz9+SmlQKDhyUz4KeihodGAheHRfdnJPfH5GTFoxXj9YVDVweFB3UlM2SVc+Q3pW PD1iQkZIVEM/MWhGLTNQPThHTXxWTTg2XzlvbGUtCnp0PTFYZWp+X3A3eSQzN1RhPXJadlk+fFNH NE1CWG5gP3ZpeiVnZjhSKW50PGhkPGp9OUo/QGsocFctPG4qS3teXwp6byZ4OVA9R1AyTUphSktD dSpwNTw/NiNPNkhkTlM+QndWbkxUUUR+X3g3KyUzRlcxYiNfSS1EekttVkN3ZyU4aFEKel9yOXdg b3JVTWw3VT5sQGYkZ2BsS09UVUp7OX5RQCoqZW1RUitXVGhvNEZGWlI3bktkOEpXRDtsU0t+ZDM5 ak4wCnpLNypCfHZ0VSgyUSQqNihuK1F5PlNLYWRNQElgTEphckVmTFQ4SnRNSXVWbm07OE88QUFS P20jWCEkemxETjBYUAp6NEw/WGRBRlBZMkN6MCpodHd6KjRmcVh9ZTFUQlZeVz5qMTBZYFIpSXNl TFNncFI4I2Q8d2xEaWM9NkA2d00pYUgKekdQSS0jeUZTfUFuMiF1R1JjS3BeKytSTWNFbmV4QDQ9 WEJjWFImQlR1I0trQmBORzApNlcyZU9rQHNwZ0ZNb1dGCnpwM1JjeVE+UHFJY05hUWtkVyQodyRx REMkN2FwLXhtNGRfPkhKbDVfMVY3WG1zcXl6S1lZLTRDX19jJkAxeUBoRQp6biE1PzVAbXAmZm93 c2k8UTVGaFk4KmB+TF9OdCg1SGFqe15TVlRndW9+ZClpMVdQeU9uR3VQS1pFPW8xKVp4eXIKej11 fkQlekotKylNN2NFIW1pOVROaUwycGQ7cTdzfTtUYV5JMFl7VGY+Iz11ZDk9VigkMV9RRVdNbzEq QVh1UkNnCnpFQGE/RW1xNDxAQXwkUiU/bWxwMG9heUh5UX5XLSZ0cW13WVR9fTclKCRXfDQmVTl6 KUhHfjJVKHZPclZtUG1tNQp6anJzOE1ZPFF1aW02aD8wI3kzcShXXk9iTmhqVEdnR1hhVFl3NUtx JGJ4fntZQm9ZWkFWazYoU3diQmdUUXpocVgKejUxN3NjUiUwXzxQWTg0SXNDZzFzNWUwKj4hWFBw eDAjOXh3az50fT81Uz4rS2xecnQ9XypaIzViVCRVTz57bWooCno+Kkk7Qkh4S0IkeUpGQD5veHJ0 NmgkaHZaKW18WUBPcV5tbFlffDYpb1B0VV5rO0FNSGJXfihxcDVVa1QtN0IkQQp6TnRfUFclI0ln Kjk/Y0NTd2ZYVyhWRiswamw8PnxqVX0tZ0c/MlIpM2VfdnVGeiZzIXJUN0wxUEJXUl90QHhzOUgK em9wcmwkbzRHMkZUSCMxXmZYUXUjMmQ1eU5AelcxI1ZUQXB0WTU+ek4oSk0+OHU5RU53IUJrJD9m REpnIXI+JFBoCnpwYjg5T1FQRjZJV0NYJVJFKSk9Yjt5eDFOMGBeeVhDRSgoUUl8cUhyaVh4ZDlm YyZWYD43QTwmQW5OSmA9NURxJgp6YCNGO2c8UTsxcXF8TWljNl9qbj1tWl57WllgLX5gSHY/RGtz bVVqeCFeMnFpIyE1NiZsUjs9SFc1QnR9JllmKFAKejJ3R3dtST4pKHQ5R0JNQEQpWXQqezUjc2p1 ZmFwUEM5bXZMd3E0LT1wPjFwRkElRWhIS3FTbDg9aytDcGh7PzJWCnorN2taJGRASz5AV1hpMnho e0dMQSUrNmt4Nj40aihZdlh+SWU7YzVadThrX3M+UzFlTWFidVFDZSYke1BuYlkpSQp6U1l9RzQr e2J0T1R7ZVk2OE1EPW1NVjNBMEA1TmFlLUAwfHtCenJWPGxXbTAqT3dIdU1sXmdrUilPeHFNOCFt YU4KenZNOEVEUkkmfGBGVW88QTN0SmN9XjUlYjNHcGx5bzU5OGF0Mn5RcmZWQU5jMW0/PHhjOHNL cm9GRG9HZDY5dzEmCnoqTjJDUC1eYGRMZz93cENNc012X1Q2Uj4mLWJgQDdqZ085QU4kYEBRbCtR RnUyZmlkWDY4TFROOCV8RVclckttdgp6SEV0fTRQN0wtVztKNCMjWXQmcFA+e3woaHszeE1aSUQk KUJDPHdYdHFHV218PjF7JXZYVF89ZFByRHtrX1QrWEMKemVJOFlWN2E1UWZnYk5nQDVFZXh4JE1O Wj9uMj9GaWYlJEVIdypnSEc7PkRUI05HPmYkN3dJZEd4cz82azJTX0tJCno/dj5odiNtMH1uLTRK JmhBIz8pZlcxMEopPVo+KiMpfWpJQG5LeDI5alp2ajVUeEh+Y0NGQl8pUWwjX2c9U2FmZwp6VlRp MVdLQ2w4dUhBSygjQSt1PWc1PjN2Iyh9bEsjY2Atd2MtWFpaeDE5VVY3bFdtWFh4RFJNQDljeDVB K1I/QEYKelc2bztYKWRTd0Q9ZnxCaUF3T3tHXnUoIXstVSgofm5AT19oR1p5M0lJRHprVzxvSGNv Y25yJiU+X2AjPHJYWlRDCnprTl8meEJ1cTdqKF4/cSpNZGdiVi1mI3NGMkw+XnZtTUlhNW8qY0hR aWIkUCFlYHVxPVchU04+OUFIO2VMPEVYZwp6ZzUzWWxzelpOWSY5UWxEMm9wQ21fUzg3S04wYEw5 dEYzPW1tQ1dXdFNLSWtAcX1nb1NOZnJ5N3tKSGVlMGV3Mm8KendaejQ4c349Mz84RU9LfSEoeUBU aWw/X1Rke3I/IV82LUdvTz5ZY3xFVjVNWlhkRHxHIXw0QHR2OXhGdnlnbTRjCno2JjM+eXNuPDx3 PDVnOGx5dzdPMDhtRD0zRGZXO3NfdVR5UUc0bTIyRncrQG90dD04akhSYnt7dmBVJE5LJCVmJQp6 ZWF2P3UmRk1vNyZec0hKZlV4SkVYMlJSflFYJSlDTz9WKnlRVT5PNEdNVURrO21ATjVIPWwoeERN RjVVeyRwJG0KenBwc2Z8S2Fie0daa01ZUnRsQjhXYTVhWW1sNiZCSUhZKDAodX55cWtxNnpJdkA3 TGRDQmpNfEtuUGRnbDgwQEBXCnpKfnAmeEZIakp2VGhrZERNO0lJelZ7JnViMXklWXpYVXY7NWY2 c09RITh7YHQ1YWFhTXcreH4jVGpzbzxeeig2Qgp6KVg2a05aeyo7OSZANn1Je089TSZ4UmxoZzxI ZX5HQ2FnOFdBbDI+RjUqc2xqMFpRIztuJm4lTyV4IS02fDdBaFQKel9zK1hiJHxmMCMtbHBaZ28m ZVghb15hZSVeVWp4OVJZQ1RHOVJXJlV8NjBCN1B2ST9tZXtgfWpTdjI8UVYmPGkrCnoheGxrM1B0 Pig3JEFMNWBibT89TWg4b2h9RHV1eFltKTN3QCZpaGN7Zmk0elomTnlCRmlGe2RUQVgrR3I+aC1A Kwp6eH5DJktpYDE8ZGRLaGpjNjUmRXNpbkkwbFQ/O1MoPUt3PWlYa25pczVwZmZ8OEVleDgrMWFO eWprZnNJREMjUHUKelplWlRyRWt7b3tmb348V21JTDJgcnpJZ3UoQCpzUjE7KE1kNTg3fH4wPilT MjRRRVRfIWt4ejdYQzJEOShOYWFLCnpIVHB1PWZENDF8M0hJVEkwIXw0Tzwyd0RgbUFpR1JTRndv JUkrfmpzK3VPSCtkWTZ5MlNBLVcqNnA4NFZxIUZ4QQp6dVlZK20qU0tnfUM1TnR4N0t6XmVpLVZ5 dUpmKiNNPm52VSZxZzd5KyRsRlY7LUkqfWZ1TVRefWtEJCNRUjl2cjgKejUkQHVtQjJYcnp7bT93 Pi0mPkg7RGxOKUNCJEBEaT03e0wlIVhaZ1RfI2A5V1ZmKXJkTlBkZl5AZ0xUXz1IO21aCnpeaCU0 SThLeG9FdCRDIyN5P2ohaypkSmJhIXJBb3BfKj5FeyNXdHRrK3slaVolJiFHLXktRzdAdzs7U1Jk TVQxKwp6WFBUJTQkI0tUYTRPd3dyWGArSEt0bzJHVzRWeGskbDJiUEdscitgLTFNYihVWHtuWSlN KUkrfk57PFF3aGl2UE4KekEjanFiT31lX1o7UFUwQms9Qi0kUjBTVW4jUkx6JEZlc3kpTUJTPmFD bFI9NXZTJWRpdnA0X2YkPGlMPUJwUkAxCnp0dGpoUnZRO1h6d3pqc2lhYENaWS1OXl9PZldDbUVU Vl4pIz5QVWphZlZwdCRKKWc8fV82WkRjK2VVPGB0NEZHcQp6KmUrUnoldDl4c0pSPjZrMVZfVF4x S3piS0BDUXlAUFd0SmdUfH0rMDkjRlU7ek40fFMoIWgtZEk2MzNBXn58QjYKenA/Z09Ge2R3Wj1Q WENeYCVKSmo+Rk1ee2Yob2w/XmFtVShFXkFrMTIqOF53azI4X1FgYkhCUy12dUUmMkpUU3FHCnpJ PT5jb3p5RCNjYnpKRTU0RTx7SShGNiZNbXw5IUdJYCtpYDI0VkV6aVkwRnQ0N1J6PGpGWm1pZHE0 REg5eSlgfgp6c0xKcH5SQyhlc291NE04JGwmc3x1VTV1I2pqMjsjRmswISsxbyRqJCVxMmxYWn1P UEFBRWwkWl5qSzVDMSghMW4KejIqT0x5cWl1VT82fUR5MndNZEkyQzh+PXFFWEQ+UjRaWSRtJSFB OV93NzBKTztTO3h8KyQ4bTY0WjBVI2oxK2diCno3S1R6WUhDd1dlNmNtX01sJGxofHU9ZzR9d1h+ TUk8T3smb3JlQEtjUFUhYn05Rz9WWSNLWjh5SSR2aE8lcDwwQQp6JmktTHd2PFMtWHxNMnA7akkt SlA3fUQjIzJGI2dnWH0reFlOJmdkX0JIfmgmcUktbT5URXc7TCM8P3pSJjY/cmwKeiFGKERORVUl ZnNzaWV4OHgqUj1eP08hS2VLYX5LcnJwU1R4TX1FOTR6MntEeChmKGE2K2FeZ05XPChSYF5JflJ1 CnpoT3FYZXQpfjBeVXhmXlk3cEFGWFQoREt0KUMmVS1GVEI2c2skKSFKRWM4UCFNN2Eqd0hDekp5 TWozVXh3RW8/bwp6RiVgOD81YXdRRGxrb25iZFJURXhQdGEzKUZVemQ9bGtDUWohSmVtSilnV0Jp Tkl3Y2wkUis9YmomPHhESyNhJGIKenY9KT9mPEtlQEgtfFc/I2l6VkpAM1Q1QSYmM1lpbGxPO1lG eSQ4Xl9BRmgjOER1O0AhakQ0REsmR2tLeFRsaXEwCno+JDNSdURRTXJiak1AYTxyUSZBQ3tueEU/ cyRQM21PP2ZONlU/WDRzZGE/ej1aVFc/VmQhP09VT1FeLW1qTFNZVAp6WT5sTFB6KWJ8TTxBSmZL JXZob00hdX5YM2clQihBTndKIyk7RUA3Jiszdj4mKXojSTMrWGg0VjRgQ0N1PnZyJE8KejhidGF2 bSQxZkxxcHp4Wl9sfT1FVGBUTH1PZmAkUlp0MiNHe3pucj9OIT1PKFphaylAUD5XXnhDIThAT0pi MlE0CnpGNW97OEl7YyhgaXV6YzhFUkMmUCg9fG8/WFYlKzxfd3w5eSV7WDBmcFlCdEs5fWotfXJI dEJFVDNNa1oqd243dwp6YHB2RGE0JGA/Q1p7TGAxSFR6ME83Nn09UihPY35oeD0ldylaQkIjNzkz Tl5fTExQaDlLTXBVYF8tKFdJSTU2Q20KenRmRntqYFRrM016Tzh1TjEwdEAzdkorWDZ2JVJWWV56 S3R+P24tfHRNX1JrJm5CMkVeT3ppYWlicjhyWT1hPj9ICno5fFJpekBuNT0wYHhvIXFVZVZSZiFp R14wLWRDTm5QKEhtREVjKVRvTnBHYHlqMj08QiZGMiE1X0hoeXpldyFEZAp6PjkzIW1GUiFUe1ch UUdgSXhnLTRlZGlrUjcza3smentjS3Z0cUQ0QmxLI3p+YTRGKkY1KkUtUCtjelYxZmRyYEkKent8 JTEoJiRNYl47azZjK2c7QW5+QWtld25gJj8rRWQpUz96Jk1WejhLIUFWWmVFJk9XYG1aem9ZMWBG YnNyQFVwCmxlfGplV0NHdmoqa3Q7UGkyLWh6ckFOV3hYXyMrKFRlOWBecXh9TzY2e0A8NyhVViM3 cgoKbGl0ZXJhbCA4MDAwCnpjbWVITWN+RnoqekR+Nmo+akxkQEt9RGIqUTdXcXY1THJVblFjRmBz ZFNuUzJBUyUwSWt0R0JTT0hxTVY2Y0NpSwp6Q0RCU2kqfUBgKDA3KD5OJER8TlEzP1UjT09JUSpp QnRYe2xkQ3R1Sl5QWTJPPyMjSiZyaGpHZiZOcEEpX2ojWSsKel5FfCZfZSo1YD8la0NZQWM3UTtq LUxOME96WCQ/dHtSI3h5Oz1PJGZ1KEVJT0s0YWtITUNAN2JTcFNlZmVeZC1RCno5QXhWczVOTGhz XmZtQ2NRPlV6TCEyd3JvdG5CUS0qUjFSVVB4K3NAM09AYm9VdHtscUtuNnB3QDR4a2tGSWc2Wgp6 PVhncSFVYW9CWVlrVHtsQDR4eHQjbWJrcnc2fWtgSH1Te2kxQkc/ZyQ0KkBjZFUoRVVJPjVmcklA Qk9CQnNRJTMKej9SbiRsYHRIXzBgZF9ycFlrQTt0VXFBSmw+JFIwbkI7V25+Xmo2TlQjfEwyZlNo MG5vNFpGVjk+MSlBTnlzbFQ/CnpgNExLLT8zXjVuKGFmYlZzaElWQzhVfVlZd0NGZXBeIWl9KDMq WlBocz1vOUZmbkkmT0FOMC0xKVh6WClvV0pyMwp6PStpeV8lfklgPVpKWigtOG9RamJZbmlUNUZq U3EyZDwmZ1IpeEMkQU13eHY8OCMyQyVzMGByMHsqNX1GKXhWIXAKejhvRjg/aUZQZTFEN0hHYnsm RmolKD4jVjZEOyQjVGFVMDBlRlEmO3huYFVRSUhJbGs9PDRyemV4IX5qeCt2XkBPCnplP3ZZY0BM V29pM1AmRzQ3MnpaNUZwU3ZqdzNQb2VfdStrQlFhTGBxKnhyVjY2Q0hXPVA1U1BuamBZQk9eXihB JAp6SGdrTUBvU2R8Ym4ob2VLWXxhKVZ2Q0VCREpKT0hBPlZ3YEMzRUFhXyU7KFErKzkkSVVwSjUl WklvSjw7ZXV0JlcKeio7ZHVLNXtVRGFCYD8pYkRDQEp1ayVXXzErd1hrN00/SGc3Mmo7QmJXYjlV N0B6PH0qNVBkYWJyO2AlcXA2MmdqCnpaPEo+b29NIX1ucHxDKVhPS25yd2VwSlZSYT5DXiNEfFhy THF9O1A0YTlEKGg9cz1sQykwTi1FdlBHaVEtSitJQwp6JHhkVmxZZXRTdHJpdXJeRilUK20hZHZz KVo1ZEpiSjhGViVvaFFgdiFBSHEwNl4qcyhDY2VFRlN0T2tRNW5RTmwKejYpbHc1ZiNLZE1pZS1J TXVoPlJQSWIranhWdks1VE5nSVpIWWREQ19MVTJzNj9Ib29sZlZ9Wi1lfnNeXndRRDRtCno8bG03 I0tBITRKaWZudEo+MmNaQyNjSyM9OW5FJkUkQjQpQ15ZZ242dXVEfTlPY1MzT2NRKipTMmlKT0te aEt6cgp6T016cDs+ZVZhJm9uNyQ3X2xJWGMpeip8NEdKblpudFVJXlZRXnMjREV7cyRuRT8tV1R2 eHgqVz1UYigpZyNSfWkKenEhZGwhRkooSW4mNzJlYyZ9Zm8jMW4kXjVuUUFVWT1KOCpRXyRoYjtJ SHd8OF5FR2lmVlhpU1lQVExIc3lzP2Z7CnpjR0JCZEtRfDYmWTF6aTFQfEJhVzFtQTVpIUI0KmFq bn0+ayl4LW94c3BMfUhQRj9MIWRGR1RAR287ZkVxTCQkagp6ZVdmZVErSTFxS29EciklcF5CSiRW fmczRiZ2SF5NJHopc0t3MWwkRCtUcEM0bndrISEpbihNMzRuc1J2X0lsKnwKelNNZndgXkYoIXFe KmFUb3YoakYqIz5VPjxNJHFwYnV3OFA3PFY/dyZvaTwoNiF5YG90cigoWEczXl9RM3hNTiYkCnpA YGQ3OVFjYGFOT1hlSFp4ZjBsKUBzdHlnPyU0YkwmX081M2AzVjk8WHYyTlRpc0xzYUtkNkdFMjdq TD5yWDtAOwp6Jn57b0xVSit9WUs0ZVhEc3lFTU9XfDIhcUImPkEtV309e2RsfWtUZShYOVNHXk1e MSZrKTtgUUdlQXRqV3FvYWkKek95MnhlcVpXQEYhT0c0Yl5zPih8Q2R+VmAjYX5lLU5NQGAzWGY1 JlYmdmJvcSUwaEZFajFTOSV8S1A4MzZoKUBGCno5bn4zOSNEK3t0cHJ4Tm9GaWliTV8+cWh4PHgw MTRCWTlTZmBOWkh5cTBIR34oYDlEWjZhVVgrUmUxV0xJQk5xMQp6NC1vVj0pS0tZQ25yX294RkRI Mmo+KXRfWG9qPSZzUm5WIU1rLVlYKTFaTVchS2slVD8tVWNoQ2BGZWA2TGVmQHAKengxJUNWSmNH a29sNzBFJG40cE8xRTtfRlBhcDtoaDRySklqU2k4fi0/TTVocFlgJE4qeUhDcSs9VEVyPFlgMWww CnpOdWkjdDEocFI3VXFYNyVGUCg9ZmN1aiooITN7eDs5fDYjJmBAMUIreTJhYDA4cWk2M0RfeThl aWtXP0pQcnNOZAp6cnF9ZkdsNHJyOyRjXnQ1QzNmY2I/LSNhOz5fMSMqbFc8TUBDLSRGYiRHKXZT Pz9meU1aSFdtXjkofVB5VkY7KzwKejJzSyQ8UUJCPV5pTXBfdipwZCpWN0hqQyEtQjhobSReXis5 PHMyMEghTmtNZ3wyUiZzSVRDe3plZTEwKkA7U3s8Cno9e3YhcnIoKlc5MG1BNC13bmc+azleKkhL b0FSdy14IzllI0hec0soeTFFckQ9Kkc4RXN0VjdfPDhGayspbX4kPQp6Y2lyI0pmaCU9P1l3fkkx S0Z4TnJfd1R3Xz1paHpXIz5VZXJoZntTNDQxQXdaJVA2fFkjMytDTj43O2M1SlEhb1IKeisyZ1ZV T1B3dTNuYXVlQlNTJUAqZn1zdksqWEEhWjFjZUopOGYjWndwel5fayE2bTF6ejVleU5kLSpzM0om SWRuCnplJFBFVmIzd2pId3AyPVdRWn00TlQ1LSRzIWczPFBFQHJrbFlGYjJ7QmgtSUJZPTZZcnBv dG1rbWl4WjArbmBkcQp6dEo+enVOVEcreyUxOS1naCFzKCNtT3JhWjVlY0tgZihiQDItYmh1Nl9m PjhgJlhRO3lJK1VqQz1XUVE3UypHdDAKelhYYWh8NyZ2VlBSNUA4bXJyUVRJT01wWGg2MUk9RGgr Sko9cjgrVng3czszaCRlVlJ8dnloY0lgX2UoQUBOX2FXCnp3WS1GMXU1PVBDSyhCMFQ9eCMpRG5J KDJIKF9ReGd4cnFufmlKeU94Vkc/e1hFPElEMSN5SkFOKDh6VEUlWW85Twp6UkdYLTRyKHNzdihC eWFlYj4pTnduc1N4MSUkTS1PSDJScD57cnM2VmM4bWpON0s+I3w3cVEqPGRPY3s3Z0hXWSYKekgm cEUoJXYmdm1Aci0oX3lhent5aDhSZyRfMFR5KWlkc1VibXshV1VOcExeaj0tOE8lZUlDdEZ7PDkz dUZpQjRCCnphYXtXdWdUPU8+UTZJXmNWSk5id3V7MFp0X3dULX42TmY+UWZRbTQ/Slh9O0plMGJ2 SFlraGU1SCF7c3FGdkotRAp6KDZfMHxHKjVgNilMYDIwZ3cyR3hMMlVUTCEtOD1fI0NRcU80JEt8 NHVGYWV5RWFJVnpLIXI/TTk2OEhTJmQ0U14Keno9e2NENyV7b1U3Rz8jd2x0THcqa1l4RUNhUmJ+ VUYrT09kIXNJPzBENV4qWDxPYzNxOVZ4VmtSbzs8LSlBRGs2CnpVemMoemtFKWRkYVdaQk9rNGNz a1BtREY5OzhCNk9NKmFFYntYcT0/OH1OV1V0S0g+YHJzVEdJRHN7OGhuNWdfQwp6ISlkSiZzV05l ODE2UjEwKEV6QlUtbEo2TXUpQ1hZXjV6Vm02M0dmYHo+R3o/JXVwc3p4Uj5wWHFYN0MzKDg4X1kK ejxQKVo3WGpKVTdtcGMoWmVQNzNFO3xkKGtFd1Z4RkheMSFSb2dmI01pXnIlOTZiYzVBVjFVbXNf NnNVQ1ZQJmNsCnprSD8xPSR6KERNcFhTPXUpPmUrN0tXXjwwWFByaDBCfnM5V2VzJHxKOVlFUUlw SSpvMzlNTTVZOVJzV2kkJSEragp6NkRrcGdLUlc4OTYxcSo/PS00ZH4lOztvYS1zKippJkZyKUUh UClFMUtaWjlnZ2olLVZCSzFHb1EreWBzVENQengKelIyQElsbFhqYHZoaVg7KU0qWG9gZ3IjfTs9 N3t7PjA4VFhtdH51ZiVaODJRQzY4eHNmXkdzcGRRR0xrRypjcU9NCnoxXjREV1hPekNjNG5MXz1B amcoaWhoRUd6R1dEdG8yQFUxWmxOMlBKcElrIUp3MXdyPWdNQSF6OG52a2w5KmF0ZQp6LWhxMlha Y3FBalBXbmN9N1cyKXdQQXRTdylrQkVabUxZeyRUbSZ2Qil6JmpKaTJLYiNSOHEye0ZRM24hWGkj TloKeiVKNEI0WUItMUVtSlNxal5nUjtINXVxUkl5QFd4NDd0Yi14aztzamcqaHgyTT1peyNJdGdO alJuTjs3S0lqM1dXCnpXNkdNUndVPyV6bSoyRShlb1dmbllVRUA+WihhaStpaXJ3N3pFY189RSg4 KmZgclUxVFgzWSlIRX10N3UxUVlYbgp6Zil3IVQxLX0+MXEjY0lMTkJHfGJ0JWBIVnp2d3hmYzMw a21xZmpAZWV3IzZ0JHJ0JjZIIXFPeSV0VFg8b3klOGwKemJWSjhlUFVvdCtgTD5CMEFLRilzO2U2 YC15UitJP2B5UUZIcGMtWlV7ZDJnP29qOU45VUk1cC0qeXFhMktKciZ0CnpiVUo7PSE1fGh4eTFU Zk9YbG9lfjY3c2NSUF87ZSoxdGVpQUFFe28mQSNWeXYpfj57YSorTjdGbTgyRyFWamgrVwp6WFd0 YWhHNFk3U3dfNCFKK3VEZGwkSXtUN0RrO3x6Tm1sfXlpYTlxU0RSPlYzciFGeT4lK2VgdkxaSSQ1 XiZ8NlYKemo/MFooRHg8SFZvcnVHT2dNVU1OWjY+Tjg+cGJhT08jYjZgSVBseG5tdDApQjZYeCk2 Skt8NlJoWl44WEE8SlZPCnpPMH58OUskPDhOVCFkc1Eofj1Pd3Y8dGxiNUk7R1VAQ0BES1MjRERN PyZKdHwkRF9fU15NaEpgI1YyVEp6XilQYAp6bXFwRF9XQlQoR3FYSWA+X1JZd1JVSGtVYVE0Y0x9 O1M9bVUhajEyd1E5b28yPzFqRCphSi1UbDIhejwtWFJGZHEKemJDbXYtblB9ZHc/cmNfKmJ7bkR+ RjMhdkZMa3RuNnBycSk5OzdSQkJlaEduSkYrWmp8bWIkN2pUN21PaCg2ZHtHCnpPdmhyJSg9YUQ5 WDlxJFBydGhjUGtRb0ZiekBzJHxveGIrYXl9b24oM3NWe3BQfEhpQWBfJDdGdDBPN3pkbWVQXgp6 YlckMXtAaSpFKE4xd0teeE11KXFEU3Rvc3ZsTytHZ01wKVNydChSckJnVzF8ajwtMzhuKjlNeT1y cCR0ZGthKlAKekVkYUN0JjgyTmpXdWlyWHMzciZtXjdNIU1DSjNiVE0hSThJd0lydVoyJDxJKUot ckZRaWt1SkNFfVVPTHpPSkJYCnomLVFzaTBPJUpWQDZqNzVWU25wKnJeMFZ0JlE/dDZHVTVSTjA8 ZVdES1htTGR6RUF9JXc4dz5nJGIqKEA0T302Wgp6MGs2TXAqQ0V4UnM7NTZhUH5eUDUzYyVvVypu IyohNXtVJGJTKjF9ZG5UfXcxZD5+M1p1OWx9dGR5WWM1ZXkhd2EKellIaVg9ck14TThsaDt0JFg4 b3Y0MnBEXnxxZ0FiZDA4em54MX17XjJXdilxYEkkYF5geFZUPW88Y3NRVSpHNlhRCno0X2YlT2t6 PWAlUyg8VXxrVG5mUjJBIUdmUW40RXpoIUxHJV4jPntYenBIcG1CNThpbClWYE87RGxhXnJWNEBP Qwp6cHB9YVo/Wm8zdFRHMDhIbmYkQ0YxZVl1fUMpYG94eHJyRFdeJVFibEJ4c0ZhblZORFg3NE8/ V0o1VlU7SWh3ciQKenQlMU9PcVJ2TCRSOyNxfmo5YDxyaVlaI1lnPk1WY0tkNCo9Rk9FRzlKRCV+ UF4rbk47ISt5Qj55KXBFSlNxVkA4CnpYKmgmVEJ0WTE9MH1RMUFmbytJdVI1NEVEZ3hROVZkTUx3 dzdPb2ZmP1hofSk2QHx+UmNEMUIkT29AfWtTZmNYMQp6djhoV1hedmNabl5lPzxgUXxtcTV1Kz5k eD0zZyV5ZXM9X05YWHJZWXJlNTt7PFU0SnJacV5+Mj4rJl8+QkIjMCUKenhDUkJKdnt4NXl1PWFg alQ8XnR1Pz49U30wO0UtYU0pKnFtKHY/Pz1DJHNNSilzJDZPP2c8cnNpPHIoJjtSUk4rCnpwYzh5 ZmV6SXkmQUNfQmFiKiM4ZCpjYD57SGR5NCpTfmE1OSlecl9LWV4oPTBAKWM1cFI7Ym83bykrYnlN TWowPgp6PFZJU2ZqUjFKMnFWbj8yLTV6JCM3P3pYfV5AOWojWGs8JTVoTnpgVTdrTjFUd34mRT8w WUxmeSU+dlR5clViI00KejYyalFBKz92R1BmRXxXR0AtQUNAZ1pSZy0pI2w7WDd3R2JacSlyNHpF T0tNNztXNl5leyNNTW9GKVYwfm5hSkEoCnpHXlJJTWpeSzQ1MHxGVFUmMjhLVm9vJFJuJF9LelN0 fW5NSzxabWNNdWdlb0JTc2UhdkEkJmAqMz1iNypJMjMhUgp6ZFN3K30zK3pXVEhhRDhRbDk/S2B5 ekpWKlEoTDwjPFVgJHRWKE14aVhEYVFDTXd6ZWd1bkpUbFJOUigyYW9hUE4Kej9XI3s9T2RONCM4 Xk0wS2UrYlFqdE9HdFpKM0dzZFhrQWBzWHApTWA5NUFCdXhkOHhBTFd9NE1RN2JJQlAwQiVwCno3 Q0VodCNSUWlgYj92bGxzfHt1bWhFbjkmaFMyMlkoTURjYSh9IzBNJVAtKHQwR2w+fmpWQ0xYK3Fk STw8OUhHUAp6ZS0xfGBDOHQxdVlqSDFvYztWQFhDIX1gS0lLWT9OcUtNYk9lITBqY1RWbmE3KnpB ZG9FP2F+NmNkMVFITz1WP2UKektuODI2ZUZiRFpwaWA/OHZ8PklNWiUybFhjPmNnTSoyakdVLUNH Tj1yJVkjMDh1c31xfEU/K0BZSkdLZUk2eEgxCno5MUdiSDxqVldoI0h9WU1xWih9eHhBWnBaalNi aEAjKWNGK0l5fTYjJHg1TEVabDFIJWkmP3NgJitfbktqY0BDOQp6LV5hSzhjb3BUVVlSZFJleGRI NGwqR0tTJT14Yl5CVFRLfD5FSX10cDRKS3lkYWhkfXg3dz5ASypyUHFraWY/dHwKenk2em9KJVM0 PExyVmpIV1hKbjBwMig2QC15TW5TfHhyeCRCV08jVkVmUURXN2chXzZQeWREX2I5Qil1ejVNQk07 CnpFOXN7I3g4WlhXNCtgNzBVWXZ1fFNBVXdZbnxvaCY7WXwmS2k8Ui1ISz0lVnNoKnd7ZW88NS01 R15oRyMxYDRVZwp6NWV2YFNBfTduWTExekQkJXpiMHsmX1h3a2w5JktAYmBCYlNrIXBDaCR8Z2dj IWEkOFJGOUE3akNfNXVePkBEVFMKeil5MTklZytRMEdxcnFnSF85NUI+Zz16YHRyOVVfZGoreFV8 PyE3OWtfUWRyRTZfZzNAPyg7UCFtZik/MEZMJHg2CnpBKUBBaUg2Y307TTZUUzNOJkhPUSNANjZj c0Y0OEMtX3trUCRPNT5zTF90KUNFPUZ8K1VUezFtUzs/alZ5PU4teAp6dlRCbmtIV2teIXRWbT1K aCZyQUg+O3QtKUhgYW9GMWY3M3FOPjZScEpqPTVra0R1bHNCSzIofSM7UHRnKz1aU2kKelNie2Z8 bG5EWFNzaUxPNFRubnVOTT1DciFxZUtBZGZJQ2ZHZHVrfFgzZy1oVUEwZSthK0BhVUQrR2pkZjYy bHlSCno/I2BgN1V9VV50PSpzSW9mJFRHLTAoME0ld2JIeGBAKV5zTk9ROytVaFhWd0ZkeCEwIU1Q dC1YTCZvSyV1dUlPKQp6OW0tOGY0MFVYdjVGRlZlRU5ob0Brc24jdlpYQ1M+KDUmSUVgK0IrLUs0 K3JlX1ctajMtRTMwcW1QZl9gSnNsaS0KejlyVDZLWj8mcFFVP1lQam99eDxpcXcxVFp7b0JsRk1V QlZmTW5sVXoye280KzRoPVllVUVNNndnMWtMdktgcV9qCnpjNkRfUDtnV2F1OFJSJDA1WShoPDJx MFNFMD8yViNlZDZZN2RVYHQwcnwoTz8rcHJMN013cGFtX0BGOUM7N2lSbgp6dTh2SDl3czBWeXFu ZzZMLWxkb0MlRmZHQG5mOz0le0ZzS1ZaRWNaSm8lPis5PzxKZFhXRDxJXkp1TkxlTkFwMU0KemJs OSYqM2JaKzZtKk13RXVNMTl3ZENQdWVQQ3J7KGQzKkhZKXRua1ljMFRzU0t3ayNUZ2QpU2tsWW5T VDF7Uit9CnpwNU52LTFpUiVMaVJwQG5Odk1eKms+TVpDPXtuRCNjajJ7bkxyRlRuOUd4Qz9GO3A9 emJqZlBKPCtAYWdQbkhYYgp6OD9US2M3JUNZNnc3PSNyOXZjalAtZmZ4JEZgfjdXR3I0c2tgPihZ aVB9VlZMQzFkKzFwbDRfUSlmRGFEbzM7SnAKenNqJTs+XkAwV3BxS3hKfmRISDJTVjFORW8kWSpE fE1zYCZoIVAwbEAjbDQ8QTY8PSV7PWBgdk4rNWt6ISFEcUkjCnpvISRPIyU8PXZRSk5UQ34hVC0+ XiFvSjd6UGUrYT96TWxPQWJZdE1kaig+WkdgNSlUdnt9UFYxVSFvKDVQZmg+bwp6eDs0dlEyTG8h fmImbWFsNlRUJT0xOG9Zazh3Rz5qOWhmcno0KW57RkVqdk05Nn07UjYrSX0zTT1CPn1veyNeUzEK emleU1ZuWXU5WXFWTClPfF9gVWtgTzgrR0hwRWRvYnk4UzhZZjc7dnMxeUAlWVBBPlZTRSVsNml7 N1cxSkpBMnsjCkpuKHdhTWBhNGVsJmk/PWEKCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0 Zm9ybS9jaHJvbWl1bS1saW51eC9jb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNv bXBvc2l0ZWQtbGF5ZXItZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21p dW0tbGludXgvY29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVkLWxh eWVyLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40MmJlNmJkNzlkMGQ2MTg0MWI4ZmE2MWY1MjZk ZDcxZDBkODI0YTk2Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hy b21pdW0tbGludXgvY29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVk LWxheWVyLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDE3IEBACitsYXllciBhdCAoMCwwKSBzaXpl IDgwMHg2MDAKKyAgUmVuZGVyVmlldyBhdCAoMCwwKSBzaXplIDgwMHg2MDAKK2xheWVyIGF0ICgw LDApIHNpemUgODAweDYwMAorICBSZW5kZXJCbG9jayB7SFRNTH0gYXQgKDAsMCkgc2l6ZSA4MDB4 NjAwCisgICAgUmVuZGVyQm9keSB7Qk9EWX0gYXQgKDgsOCkgc2l6ZSA3ODR4NTg0CisgICAgICBS ZW5kZXJCbG9jayB7UH0gYXQgKDAsMCkgc2l6ZSA3ODR4MjAKKyAgICAgICAgUmVuZGVySW5saW5l IHtBfSBhdCAoMCwwKSBzaXplIDE0NngxOSBbY29sb3I9IzAwMDBFRV0KKyAgICAgICAgICBSZW5k ZXJUZXh0IHsjdGV4dH0gYXQgKDAsMCkgc2l6ZSAxNDZ4MTkKKyAgICAgICAgICAgIHRleHQgcnVu IGF0ICgwLDApIHdpZHRoIDE0NjogInJkYXI6Ly9wcm9ibGVtLzY5ODMyMDciCisgICAgICAgIFJl bmRlclRleHQgeyN0ZXh0fSBhdCAoMTQ2LDApIHNpemUgMzc0eDE5CisgICAgICAgICAgdGV4dCBy dW4gYXQgKDE0NiwwKSB3aWR0aCAzNzQ6ICJTaG91bGQgbm90IGxlYXZlIGJsdWUgYm94IGJlaGlu ZCBhZnRlciBtb3ZpbmcgdG8gdGhlIHRvcCByaWdodC4iCitsYXllciBhdCAoOCw0NCkgc2l6ZSA1 MDJ4MTAyCisgIFJlbmRlckJsb2NrIChyZWxhdGl2ZSBwb3NpdGlvbmVkKSB7RElWfSBhdCAoMCwz Nikgc2l6ZSA1MDJ4MTAyIFtib3JkZXI6ICgxcHggc29saWQgIzAwMDAwMCldCitsYXllciBhdCAo MjU5LDQ1KSBzaXplIDI1MHgxMDAKKyAgUmVuZGVyQmxvY2sgKHBvc2l0aW9uZWQpIHtESVZ9IGF0 ICgyNTEsMSkgc2l6ZSAyNTB4MTAwIFtiZ2NvbG9yPSMwMDAwRkZdCitsYXllciBhdCAoOSw0NSkg c2l6ZSA1MHg1MAorICBSZW5kZXJCbG9jayAocG9zaXRpb25lZCkge0RJVn0gYXQgKDEsMSkgc2l6 ZSA1MHg1MCBbYmdjb2xvcj0jMDAwMDAwXQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vY2hyb21pdW0vdGVzdF9leHBlY3RhdGlvbnMudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0v Y2hyb21pdW0vdGVzdF9leHBlY3RhdGlvbnMudHh0CmluZGV4IDc1YjliNDA4ZDc0NDRhNWZlYmY4 NDQ3ODdjMDljM2UyNjRiYzE1OTAuLmFlNWMyNzUyODk1MDBlOTFjMThhMDQzOWVlZmI5YzdjYjJm ZGIxMmUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL3Rlc3RfZXhw ZWN0YXRpb25zLnR4dAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4 cGVjdGF0aW9ucy50eHQKQEAgLTk5Niw2ICs5OTYsOSBAQCBCVUdDUjYyNDMzIFdJTiA6IGZhc3Qv aW1hZ2VzL2dpZi1sb29wLWNvdW50Lmh0bWwgPSBJTUFHRQogLy8gU1ZHIFRFU1RTCiAvLyAtLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQogCisvLyBOZWVkIHJlYmFzZWxpbmluZyBhZnRlciBidWcgNjQ1OTEKK0JVR1dLNjQ1OTEg OiBjb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIuaHRt bCA9IFBBU1MgRkFJTAorCiBCVUdDUjg3NjMgTUFDIDogc3ZnL2N1c3RvbS91c2Utb24tZy1jb250 YWluaW5nLWZvcmVpZ25PYmplY3QtYW5kLWltYWdlLnN2ZyA9IElNQUdFCiAKIApkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZWZsL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCBiL0xheW91 dFRlc3RzL3BsYXRmb3JtL2VmbC90ZXN0X2V4cGVjdGF0aW9ucy50eHQKaW5kZXggNGQ1NGY5YTcx NmZiZDVlMjA4NTAwYTFkZjk0MmNlMjkzNDk2MTFkYi4uM2U1ZWMyNDI0M2M4OGJkZjg5YzA4YmZj OTdhNzVhZTllZWI5YzY4ZiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZWZsL3Rl c3RfZXhwZWN0YXRpb25zLnR4dAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9lZmwvdGVzdF9l eHBlY3RhdGlvbnMudHh0CkBAIC0yLDYgKzIsOSBAQAogLy8KIC8vIFNlZSBodHRwOi8vdHJhYy53 ZWJraXQub3JnL3dpa2kvVGVzdEV4cGVjdGF0aW9ucyBmb3IgbW9yZSBpbmZvcm1hdGlvbiBvbiB0 aGlzIGZpbGUuCiAKKy8vIE5lZWQgcmViYXNlbGluaW5nIGFmdGVyIGJ1ZyA2NDU5MQorQlVHV0s2 NDU5MSA6IGNvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXll ci5odG1sID0gUEFTUyBGQUlMCisKIC8vIE5lZWRzIEVOQUJMRV9TSEFET1dfRE9NCiBCVUdXSzc2 NDM5IERFQlVHIDogZmFzdC9kb20vc2hhZG93L2NvbnRlbnQtZWxlbWVudC1hcGkuaHRtbCA9IFRF WFQKIEJVR1dLNzY0MzkgREVCVUcgOiBmYXN0L2RvbS9zaGFkb3cvY29udGVudC1lbGVtZW50LW91 dHNpZGUtc2hhZG93Lmh0bWwgPSBURVhUCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9ndGsvdGVzdF9leHBlY3RhdGlvbnMudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL3Rl c3RfZXhwZWN0YXRpb25zLnR4dAppbmRleCAzNGNjZWU0OTQ3NmM5NmM1Nzc3MmNhY2U2M2QxYWYy MDc4OGUyYTY4Li4zMGM1ZjZjOTQ4Njg3MDYyMWQ5ZTkxMGY5MmFmZDI3OGE4ZGUxNjA0IDEwMDY0 NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvdGVzdF9leHBlY3RhdGlvbnMudHh0Cisr KyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay90ZXN0X2V4cGVjdGF0aW9ucy50eHQKQEAgLTEx LDYgKzExLDkgQEAgQlVHV0s2ODg1OSBERUJVRyA6IGZhc3QvZHluYW1pYy9jcmFzaC1wYWludC1u by1kb2N1bWVudEVsZW1lbnQtcmVuZGVyZXIuaHRtbCA9IEMKIAogQlVHV0s3NjgxNCBERUJVRyA6 IGZhc3QveG1saHR0cHJlcXVlc3QveG1saHR0cHJlcXVlc3QtZ2V0LnhodG1sID0gQ1JBU0gKIAor Ly8gTmVlZCByZWJhc2VsaW5pbmcgYWZ0ZXIgYnVnIDY0NTkxCitCVUdXSzY0NTkxIDogY29tcG9z aXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVkLWxheWVyLmh0bWwgPSBQQVNT IEZBSUwKKwogLy8gRmxha3kgdGVzdHMKIAogQlVHV0s2ODg3OCA6IG1lZGlhL3ZpZGVvLXBsYXlp bmctYW5kLXBhdXNlLmh0bWwgPSBQQVNTIFRFWFQKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3Bs YXRmb3JtL21hYy90ZXN0X2V4cGVjdGF0aW9ucy50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9t YWMvdGVzdF9leHBlY3RhdGlvbnMudHh0CmluZGV4IDAyMjAyYTBmZjY2MjI3MWU0ZTc0NWUzNWQz Nzc5NWUyNzUyOGU2Y2UuLjZmZDY2YmFlYmNjZThmNGFhOWZkZTNhMjNiZTA5YTA0M2IwZjRiMWYg MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy90ZXN0X2V4cGVjdGF0aW9ucy50 eHQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL3Rlc3RfZXhwZWN0YXRpb25zLnR4dApA QCAtNDQsNiArNDQsOSBAQCBCVUdXSzczNzY2IDogY3NzMy91bmljb2RlLWJpZGktaXNvbGF0ZS1h aGFyb24tZmFpbGluZy5odG1sID0gRkFJTAogLy8gVGhlIHRlc3QgaGl0cyBhbiBBU1NFUlQgaW4g RGVidWcuCiBCVUdXSzY4ODU5IERFQlVHIDogZmFzdC9keW5hbWljL2NyYXNoLXBhaW50LW5vLWRv Y3VtZW50RWxlbWVudC1yZW5kZXJlci5odG1sID0gQ1JBU0gKIAorLy8gTmVlZCByZWJhc2VsaW5p bmcgYWZ0ZXIgYnVnIDY0NTkxCitCVUdXSzY0NTkxIDogY29tcG9zaXRpbmcvcmVwYWludC9iZWNv bWUtb3ZlcmxheS1jb21wb3NpdGVkLWxheWVyLmh0bWwgPSBQQVNTIEZBSUwKKwogLy8gTmVlZCBy ZWJhc2VsaW5pbmcgYWZ0ZXIgNzEyNDQKIEJVR1dLNzQ0MzIgOiBjc3MyLjEvMjAxMTAzMjMvYm9y ZGVyLWNvbmZsaWN0LXN0eWxlLTA3OS5odG0gPSBJTUFHRQogQlVHV0s3NDQzMiA6IGNzczIuMS8y MDExMDMyMy9mbG9hdGluZy1yZXBsYWNlZC1oZWlnaHQtMDA4Lmh0bSA9IElNQUdFCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9xdC90ZXN0X2V4cGVjdGF0aW9ucy50eHQgYi9MYXlv dXRUZXN0cy9wbGF0Zm9ybS9xdC90ZXN0X2V4cGVjdGF0aW9ucy50eHQKaW5kZXggYzZhYTMzNGQ0 MzU4YTUwM2IzM2ExYTc2ZmQ3YjVkNTI4N2IwMzZhNS4uZGEyMDQ1NzljNTIzNTM5NzQ2ZTg3NmQ3 ZGZjNzBkZWFlY2ZmNzJhZSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vcXQvdGVz dF9leHBlY3RhdGlvbnMudHh0CisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0L3Rlc3RfZXhw ZWN0YXRpb25zLnR4dApAQCAtMjUsNSArMjUsOCBAQCBCVUdXSzc0MjcwIDogZmFzdC9mb3Jtcy9i YXNpYy1zZWxlY3RzLmh0bWwgPSBGQUlMCiAvLyBUaGUgdGVzdCBoaXRzIGFuIEFTU0VSVCBpbiBE ZWJ1Zy4KIEJVR1dLNjg4NTkgREVCVUcgOiBmYXN0L2R5bmFtaWMvY3Jhc2gtcGFpbnQtbm8tZG9j dW1lbnRFbGVtZW50LXJlbmRlcmVyLmh0bWwgPSBDUkFTSAogCisvLyBOZWVkIHJlYmFzZWxpbmlu ZyBhZnRlciBidWcgNjQ1OTEKK0JVR1dLNjQ1OTEgOiBjb21wb3NpdGluZy9yZXBhaW50L2JlY29t ZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIuaHRtbCA9IFBBU1MgRkFJTAorCiAvLyBOZWVkcyBi YXNlbGluZQogQlVHV0s3NjExOCA6IGZhc3QvY3NzL3RleHQtb3ZlcmZsb3ctaW5wdXQuaHRtbCA9 IE1JU1NJTkcKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi90ZXN0X2V4cGVj dGF0aW9ucy50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vdGVzdF9leHBlY3RhdGlvbnMu dHh0CmluZGV4IDRmNzczYzQ1ZTUzNGNiODRkZGYxZWY3YWYwMTBmODdiZjNmNDMxZWYuLmUzNDBk NmM0NGM0YTJhYzM1NTk3ZTM5OTJkY2E0NjM4MjBjYWMyYTIgMTAwNjQ0Ci0tLSBhL0xheW91dFRl c3RzL3BsYXRmb3JtL3dpbi90ZXN0X2V4cGVjdGF0aW9ucy50eHQKKysrIGIvTGF5b3V0VGVzdHMv cGxhdGZvcm0vd2luL3Rlc3RfZXhwZWN0YXRpb25zLnR4dApAQCAtMjAsNiArMjAsOSBAQCBCVUdX Szc0MjcwIDogZmFzdC9mb3Jtcy9iYXNpYy1zZWxlY3RzLmh0bWwgPSBGQUlMCiAvLyBUaGUgdGVz dCBoaXRzIGFuIEFTU0VSVCBpbiBEZWJ1Zy4KIEJVR1dLNjg4NTkgREVCVUcgOiBmYXN0L2R5bmFt aWMvY3Jhc2gtcGFpbnQtbm8tZG9jdW1lbnRFbGVtZW50LXJlbmRlcmVyLmh0bWwgPSBDUkFTSAog CisvLyBOZWVkIHJlYmFzZWxpbmluZyBhZnRlciBidWcgNjQ1OTEKK0JVR1dLNjQ1OTEgOiBjb21w b3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIuaHRtbCA9IFBB U1MgRkFJTAorCiAvLyBOZXcgdGVzdCwgbmVlZHMgaW1hZ2UgcmVzdWx0cyBhZGRlZC4KIEJVR1dL NzU1NzAgOiBodHRwL3Rlc3RzL21lZGlhL3ZpZGVvLWJ1ZmZlcmluZy1yZXBhaW50cy1jb250cm9s cy5odG1sID0gSU1BR0UKIAo= 126549 2012-02-10 12:15:26 -0800 2012-02-10 12:41:25 -0800 Fixing review-by line. bug-64591-20120210151525.patch text/plain 31789 jgw U3VidmVyc2lvbiBSZXZpc2lvbjogMTA3NDI1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMThlYTkzNWI4NzQ0MzIw YzQ2YTIxMzA0NjFiMDE1NDAxNTZiMzRhMC4uNDQ3YjNmYjk5MTUyMDBjYzBlNDYzZDliZjg4ZTFm YTc4YTNkYzdkYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEyLTAyLTEwICBKb2Vs IFdlYmJlciAgPGpnd0Bnb29nbGUuY29tPgorCisgICAgICAgIFVzZSByZXF1ZXN0QW5pbWF0aW9u RnJhbWUgY2FsbGJhY2tzIHRvIHB1bXAgQ1NTIGFuaW1hdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTkxCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgSmFtZXMgUm9iaW5zb24uCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIG5lZWRlZCAoY292ZXJl ZCBieSB0ZXN0cyBpbiBhbmltYXRpb25zLyopLgorCisgICAgICAgICogcGFnZS9GcmFtZVZpZXcu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVWaWV3OjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRp b25zKToKKyAgICAgICAgKiBwYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmlt YXRpb25zKToKKyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1 cGRhdGVBbmltYXRpb25UaW1lcik6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250cm9s bGVyUHJpdmF0ZTo6ZmlyZUV2ZW50c0FuZFVwZGF0ZVN0eWxlKToKKyAgICAgICAgKFdlYkNvcmU6 OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjphbmltYXRpb25GcmFtZUNhbGxiYWNrRmlyZWQp OgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0aW9uQ29udHJvbGxlcjo6dXBkYXRlQW5pbWF0aW9u cyk6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250cm9sbGVyOjpzZXJ2aWNlQW5pbWF0 aW9ucyk6CisgICAgICAgICogcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5oOgor ICAgICAgICAqIHBhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmg6CisK IDIwMTItMDItMTAgIEFuZGVycyBDYXJsc3NvbiAgPGFuZGVyc2NhQGFwcGxlLmNvbT4KIAogICAg ICAgICBVcGRhdGUgdGhlIG5vbi1mYXN0LXNjcm9sbGFibGUgcmVnaW9uIGZvciBzdWJmcmFtZSBs YXlvdXQgYXMgd2VsbApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcu Y3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IGMwYjg1ODcxZmZl MDJjODgzZGJlODIzYjBlMzU2OWY3NjZiZWZiMDYuLmZiMGI1NjY5YTU2ZWZkODE0ZTY3ZjBhZTc5 ZGY3Y2I2MjM5OGRlMGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTIwOTksOCAr MjA5OSwxMSBAQCB2b2lkIEZyYW1lVmlldzo6dW5zY2hlZHVsZVJlbGF5b3V0KCkKICNpZiBFTkFC TEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCiB2b2lkIEZyYW1lVmlldzo6c2VydmljZVNjcmlw dGVkQW5pbWF0aW9ucyhET01UaW1lU3RhbXAgdGltZSkKIHsKLSAgICBWZWN0b3I8UmVmUHRyPERv Y3VtZW50PiA+IGRvY3VtZW50czsKKyAgICBWZWN0b3I8QW5pbWF0aW9uQ29udHJvbGxlcio+IGFu aW1hdGlvbnM7CisgICAgZm9yIChGcmFtZSogZnJhbWUgPSBtX2ZyYW1lLmdldCgpOyBmcmFtZTsg ZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50cmF2ZXJzZU5leHQoKSkKKyAgICAgICAgZnJhbWUtPmFu aW1hdGlvbigpLT5zZXJ2aWNlQW5pbWF0aW9ucygpOwogCisgICAgVmVjdG9yPFJlZlB0cjxEb2N1 bWVudD4gPiBkb2N1bWVudHM7CiAgICAgZm9yIChGcmFtZSogZnJhbWUgPSBtX2ZyYW1lLmdldCgp OyBmcmFtZTsgZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50cmF2ZXJzZU5leHQoKSkKICAgICAgICAg ZG9jdW1lbnRzLmFwcGVuZChmcmFtZS0+ZG9jdW1lbnQoKSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuY3BwIGIvU291cmNl L1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5jcHAKaW5kZXggNzQ1 ZDUxNDZiOTE4ZWQwNTBmNzhmMWI0MmEyOTJiNWExZmE0ZGFhMC4uODEyZDE4ZDg2OTA4ZGM2NmUx MDAyMmU2MGQyYmU5MGYzMmVhZmVkNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9h bmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFn ZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5jcHAKQEAgLTM1LDYgKzM1LDcgQEAKICNp bmNsdWRlICJDb21wb3NpdGVBbmltYXRpb24uaCIKICNpbmNsdWRlICJFdmVudE5hbWVzLmgiCiAj aW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJSZW5k ZXJWaWV3LmgiCiAjaW5jbHVkZSAiV2ViS2l0QW5pbWF0aW9uRXZlbnQuaCIKICNpbmNsdWRlICJX ZWJLaXRBbmltYXRpb25MaXN0LmgiCkBAIC00NCw3ICs0NSw2IEBACiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAotLy8gRklYTUU6IFdoeSBpc24ndCB0aGlzIHNldCB0byA2MGZwcyBvciBzb21ldGhp bmc/CiBzdGF0aWMgY29uc3QgZG91YmxlIGNBbmltYXRpb25UaW1lckRlbGF5ID0gMC4wMjU7CiBz dGF0aWMgY29uc3QgZG91YmxlIGNCZWdpbkFuaW1hdGlvblVwZGF0ZVRpbWVOb3RTZXQgPSAtMTsK IApAQCAtODQsOSArODQsOSBAQCBib29sIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjpjbGVh cihSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogICAgIHJldHVybiBhbmltYXRpb24tPnN1c3BlbmRl ZCgpOwogfQogCi12b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmltYXRp b25UaW1lcihib29sIGNhbGxTZXRDaGFuZ2VkLyogPSBmYWxzZSovKQorZG91YmxlIEFuaW1hdGlv bkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmltYXRpb25zKFNldENoYW5nZWQgY2FsbFNldENo YW5nZWQvKiA9IERvTm90Q2FsbFNldENoYW5nZWQqLykKIHsKLSAgICBkb3VibGUgbmVlZHNTZXJ2 aWNlID0gLTE7CisgICAgZG91YmxlIHRpbWVUb05leHRTZXJ2aWNlID0gLTE7CiAgICAgYm9vbCBj YWxsZWRTZXRDaGFuZ2VkID0gZmFsc2U7CiAKICAgICBSZW5kZXJPYmplY3RBbmltYXRpb25NYXA6 OmNvbnN0X2l0ZXJhdG9yIGFuaW1hdGlvbnNFbmQgPSBtX2NvbXBvc2l0ZUFuaW1hdGlvbnMuZW5k KCk7CkBAIC05NCwxMCArOTQsMTAgQEAgdm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6 dXBkYXRlQW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0Q2hhbmdlZC8qID0gZmEKICAgICAgICAg Q29tcG9zaXRlQW5pbWF0aW9uKiBjb21wQW5pbSA9IGl0LT5zZWNvbmQuZ2V0KCk7CiAgICAgICAg IGlmICghY29tcEFuaW0tPnN1c3BlbmRlZCgpICYmIGNvbXBBbmltLT5oYXNBbmltYXRpb25zKCkp IHsKICAgICAgICAgICAgIGRvdWJsZSB0ID0gY29tcEFuaW0tPnRpbWVUb05leHRTZXJ2aWNlKCk7 Ci0gICAgICAgICAgICBpZiAodCAhPSAtMSAmJiAodCA8IG5lZWRzU2VydmljZSB8fCBuZWVkc1Nl cnZpY2UgPT0gLTEpKQotICAgICAgICAgICAgICAgIG5lZWRzU2VydmljZSA9IHQ7Ci0gICAgICAg ICAgICBpZiAobmVlZHNTZXJ2aWNlID09IDApIHsKLSAgICAgICAgICAgICAgICBpZiAoY2FsbFNl dENoYW5nZWQpIHsKKyAgICAgICAgICAgIGlmICh0ICE9IC0xICYmICh0IDwgdGltZVRvTmV4dFNl cnZpY2UgfHwgdGltZVRvTmV4dFNlcnZpY2UgPT0gLTEpKQorICAgICAgICAgICAgICAgIHRpbWVU b05leHRTZXJ2aWNlID0gdDsKKyAgICAgICAgICAgIGlmICghdGltZVRvTmV4dFNlcnZpY2UpIHsK KyAgICAgICAgICAgICAgICBpZiAoY2FsbFNldENoYW5nZWQgPT0gQ2FsbFNldENoYW5nZWQpIHsK ICAgICAgICAgICAgICAgICAgICAgTm9kZSogbm9kZSA9IGl0LT5maXJzdC0+bm9kZSgpOwogICAg ICAgICAgICAgICAgICAgICBBU1NFUlQoIW5vZGUgfHwgKG5vZGUtPmRvY3VtZW50KCkgJiYgIW5v ZGUtPmRvY3VtZW50KCktPmluUGFnZUNhY2hlKCkpKTsKICAgICAgICAgICAgICAgICAgICAgbm9k ZS0+c2V0TmVlZHNTdHlsZVJlY2FsYyhTeW50aGV0aWNTdHlsZUNoYW5nZSk7CkBAIC0xMDgsMjgg KzEwOCwzNSBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmltYXRp b25UaW1lcihib29sIGNhbGxTZXRDaGFuZ2VkLyogPSBmYQogICAgICAgICAgICAgfQogICAgICAg ICB9CiAgICAgfQotICAgIAorCiAgICAgaWYgKGNhbGxlZFNldENoYW5nZWQpCiAgICAgICAgIG1f ZnJhbWUtPmRvY3VtZW50KCktPnVwZGF0ZVN0eWxlSWZOZWVkZWQoKTsKLSAgICAKKworICAgIHJl dHVybiB0aW1lVG9OZXh0U2VydmljZTsKK30KKwordm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJp dmF0ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIoU2V0Q2hhbmdlZCBjYWxsU2V0Q2hhbmdlZC8qID0g RG9Ob3RDYWxsU2V0Q2hhbmdlZCovKQoreworICAgIGRvdWJsZSB0aW1lVG9OZXh0U2VydmljZSA9 IHVwZGF0ZUFuaW1hdGlvbnMoY2FsbFNldENoYW5nZWQpOworCiAgICAgLy8gSWYgd2Ugd2FudCBz ZXJ2aWNlIGltbWVkaWF0ZWx5LCB3ZSBzdGFydCBhIHJlcGVhdGluZyB0aW1lciB0byByZWR1Y2Ug dGhlIG92ZXJoZWFkIG9mIHN0YXJ0aW5nCi0gICAgaWYgKG5lZWRzU2VydmljZSA9PSAwKSB7Cisg ICAgaWYgKCF0aW1lVG9OZXh0U2VydmljZSkgewogICAgICAgICBpZiAoIW1fYW5pbWF0aW9uVGlt ZXIuaXNBY3RpdmUoKSB8fCBtX2FuaW1hdGlvblRpbWVyLnJlcGVhdEludGVydmFsKCkgPT0gMCkK ICAgICAgICAgICAgIG1fYW5pbWF0aW9uVGltZXIuc3RhcnRSZXBlYXRpbmcoY0FuaW1hdGlvblRp bWVyRGVsYXkpOwogICAgICAgICByZXR1cm47CiAgICAgfQotICAgIAorCiAgICAgLy8gSWYgd2Ug ZG9uJ3QgbmVlZCBzZXJ2aWNlLCB3ZSB3YW50IHRvIG1ha2Ugc3VyZSB0aGUgdGltZXIgaXMgbm8g bG9uZ2VyIHJ1bm5pbmcKLSAgICBpZiAobmVlZHNTZXJ2aWNlIDwgMCkgeworICAgIGlmICh0aW1l VG9OZXh0U2VydmljZSA8IDApIHsKICAgICAgICAgaWYgKG1fYW5pbWF0aW9uVGltZXIuaXNBY3Rp dmUoKSkKICAgICAgICAgICAgIG1fYW5pbWF0aW9uVGltZXIuc3RvcCgpOwogICAgICAgICByZXR1 cm47CiAgICAgfQotICAgIAorCiAgICAgLy8gT3RoZXJ3aXNlLCB3ZSB3YW50IHRvIHN0YXJ0IGEg b25lLXNob3QgdGltZXIgc28gd2UgZ2V0IGhlcmUgYWdhaW4KICAgICBpZiAobV9hbmltYXRpb25U aW1lci5pc0FjdGl2ZSgpKQogICAgICAgICBtX2FuaW1hdGlvblRpbWVyLnN0b3AoKTsKLSAgICBt X2FuaW1hdGlvblRpbWVyLnN0YXJ0T25lU2hvdChuZWVkc1NlcnZpY2UpOworICAgIG1fYW5pbWF0 aW9uVGltZXIuc3RhcnRPbmVTaG90KHRpbWVUb05leHRTZXJ2aWNlKTsKIH0KIAogdm9pZCBBbmlt YXRpb25Db250cm9sbGVyUHJpdmF0ZTo6dXBkYXRlU3R5bGVJZk5lZWRlZERpc3BhdGNoZXJGaXJl ZChUaW1lcjxBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZT4qKQpAQCAtMTQzLDcgKzE1MCw3IEBA IHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmZpcmVFdmVudHNBbmRVcGRhdGVTdHls ZSgpCiAgICAgUmVmUHRyPEZyYW1lPiBwcm90ZWN0b3IgPSBtX2ZyYW1lOwogCiAgICAgYm9vbCB1 cGRhdGVTdHlsZSA9ICFtX2V2ZW50c1RvRGlzcGF0Y2guaXNFbXB0eSgpIHx8ICFtX25vZGVDaGFu Z2VzVG9EaXNwYXRjaC5pc0VtcHR5KCk7Ci0gICAgCisKICAgICAvLyBmaXJlIGFsbCB0aGUgZXZl bnRzCiAgICAgVmVjdG9yPEV2ZW50VG9EaXNwYXRjaD4gZXZlbnRzVG9EaXNwYXRjaCA9IG1fZXZl bnRzVG9EaXNwYXRjaDsKICAgICBtX2V2ZW50c1RvRGlzcGF0Y2guY2xlYXIoKTsKQEAgLTE1NCwx NCArMTYxLDE0IEBAIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmZpcmVFdmVudHNB bmRVcGRhdGVTdHlsZSgpCiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIGl0LT5lbGVtZW50LT5k aXNwYXRjaEV2ZW50KFdlYktpdEFuaW1hdGlvbkV2ZW50OjpjcmVhdGUoaXQtPmV2ZW50VHlwZSwg aXQtPm5hbWUsIGl0LT5lbGFwc2VkVGltZSkpOwogICAgIH0KLSAgICAKKwogICAgIC8vIGNhbGwg c2V0Q2hhbmdlZCBvbiBhbGwgdGhlIGVsZW1lbnRzCiAgICAgVmVjdG9yPFJlZlB0cjxOb2RlPiA+ Ojpjb25zdF9pdGVyYXRvciBub2RlQ2hhbmdlc1RvRGlzcGF0Y2hFbmQgPSBtX25vZGVDaGFuZ2Vz VG9EaXNwYXRjaC5lbmQoKTsKICAgICBmb3IgKFZlY3RvcjxSZWZQdHI8Tm9kZT4gPjo6Y29uc3Rf aXRlcmF0b3IgaXQgPSBtX25vZGVDaGFuZ2VzVG9EaXNwYXRjaC5iZWdpbigpOyBpdCAhPSBub2Rl Q2hhbmdlc1RvRGlzcGF0Y2hFbmQ7ICsraXQpCiAgICAgICAgICgqaXQpLT5zZXROZWVkc1N0eWxl UmVjYWxjKFN5bnRoZXRpY1N0eWxlQ2hhbmdlKTsKLSAgICAKKwogICAgIG1fbm9kZUNoYW5nZXNU b0Rpc3BhdGNoLmNsZWFyKCk7Ci0gICAgCisKICAgICBpZiAodXBkYXRlU3R5bGUgJiYgbV9mcmFt ZSkKICAgICAgICAgbV9mcmFtZS0+ZG9jdW1lbnQoKS0+dXBkYXRlU3R5bGVJZk5lZWRlZCgpOwog fQpAQCAtMTk0LDYgKzIwMSwxNiBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjph ZGROb2RlQ2hhbmdlVG9EaXNwYXRjaChQYXNzUmVmUHRyPE5vZGU+IG5vZGUpCiAgICAgc3RhcnRV cGRhdGVTdHlsZUlmTmVlZGVkRGlzcGF0Y2hlcigpOwogfQogCisjaWYgRU5BQkxFKFJFUVVFU1Rf QU5JTUFUSU9OX0ZSQU1FKQordm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6YW5pbWF0 aW9uRnJhbWVDYWxsYmFja0ZpcmVkKCkKK3sKKyAgICBkb3VibGUgdGltZVRvTmV4dFNlcnZpY2Ug PSB1cGRhdGVBbmltYXRpb25zKENhbGxTZXRDaGFuZ2VkKTsKKworICAgIGlmICh0aW1lVG9OZXh0 U2VydmljZSA+PSAwKQorICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT52aWV3KCktPnNjaGVk dWxlQW5pbWF0aW9uKCk7Cit9CisjZW5kaWYKKwogdm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJp dmF0ZTo6YW5pbWF0aW9uVGltZXJGaXJlZChUaW1lcjxBbmltYXRpb25Db250cm9sbGVyUHJpdmF0 ZT4qKQogewogICAgIC8vIE1ha2Ugc3VyZSBhbmltYXRpb25VcGRhdGVUaW1lIGlzIHVwZGF0ZWQs IHNvIHRoYXQgaXQgaXMgY3VycmVudCBldmVuIGlmIG5vCkBAIC0yMDIsNyArMjE5LDcgQEAgdm9p ZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6YW5pbWF0aW9uVGltZXJGaXJlZChUaW1lcjxB bmltYXRpb25Db250cm9sbGVyUHIKIAogICAgIC8vIFdoZW4gdGhlIHRpbWVyIGZpcmVzLCBhbGwg d2UgZG8gaXMgY2FsbCBzZXRDaGFuZ2VkIG9uIGFsbCBET00gbm9kZXMgd2l0aCBydW5uaW5nIGFu aW1hdGlvbnMgYW5kIHRoZW4gZG8gYW4gaW1tZWRpYXRlCiAgICAgLy8gdXBkYXRlU3R5bGVJZk5l ZWRlZC4gIEl0IHdpbGwgdGhlbiBjYWxsIGJhY2sgdG8gdXMgd2l0aCBuZXcgaW5mb3JtYXRpb24u Ci0gICAgdXBkYXRlQW5pbWF0aW9uVGltZXIodHJ1ZSk7CisgICAgdXBkYXRlQW5pbWF0aW9uVGlt ZXIoQ2FsbFNldENoYW5nZWQpOwogCiAgICAgLy8gRmlyZSBldmVudHMgcmlnaHQgYXdheSwgdG8g YXZvaWQgYSBmbGFzaCBvZiB1bmFuaW1hdGVkIHN0eWxlIGFmdGVyIGFuIGFuaW1hdGlvbiBjb21w bGV0ZXMsIGFuZCBiZWZvcmUKICAgICAvLyB0aGUgJ2VuZCcgZXZlbnQgZmlyZXMuCkBAIC00OTks OCArNTE2LDEzIEBAIFBhc3NSZWZQdHI8UmVuZGVyU3R5bGU+IEFuaW1hdGlvbkNvbnRyb2xsZXI6 OnVwZGF0ZUFuaW1hdGlvbnMoUmVuZGVyT2JqZWN0KiByZW5kCiAgICAgUmVmUHRyPENvbXBvc2l0 ZUFuaW1hdGlvbj4gcmVuZGVyZXJBbmltYXRpb25zID0gbV9kYXRhLT5hY2Nlc3NDb21wb3NpdGVB bmltYXRpb24ocmVuZGVyZXIpOwogICAgIFJlZlB0cjxSZW5kZXJTdHlsZT4gYmxlbmRlZFN0eWxl ID0gcmVuZGVyZXJBbmltYXRpb25zLT5hbmltYXRlKHJlbmRlcmVyLCBvbGRTdHlsZSwgbmV3U3R5 bGUpOwogCi0gICAgaWYgKHJlbmRlcmVyLT5wYXJlbnQoKSB8fCBuZXdTdHlsZS0+YW5pbWF0aW9u cygpIHx8IChvbGRTdHlsZSAmJiBvbGRTdHlsZS0+YW5pbWF0aW9ucygpKSkKKyAgICBpZiAocmVu ZGVyZXItPnBhcmVudCgpIHx8IG5ld1N0eWxlLT5hbmltYXRpb25zKCkgfHwgKG9sZFN0eWxlICYm IG9sZFN0eWxlLT5hbmltYXRpb25zKCkpKSB7CiAgICAgICAgIG1fZGF0YS0+dXBkYXRlQW5pbWF0 aW9uVGltZXIoKTsKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCisgICAgICAg IGlmIChGcmFtZVZpZXcqIHZpZXcgPSByZW5kZXJlci0+ZG9jdW1lbnQoKS0+dmlldygpKQorICAg ICAgICAgICAgdmlldy0+c2NoZWR1bGVBbmltYXRpb24oKTsKKyNlbmRpZgorICAgIH0KIAogICAg IGlmIChibGVuZGVkU3R5bGUgIT0gbmV3U3R5bGUpIHsKICAgICAgICAgLy8gSWYgdGhlIGFuaW1h dGlvbnMvdHJhbnNpdGlvbnMgY2hhbmdlIG9wYWNpdHkgb3IgdHJhbnNmb3JtLCB3ZSBuZWVkIHRv IHVwZGF0ZQpAQCAtNTU3LDYgKzU3OSwxMyBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXI6OnJl c3VtZUFuaW1hdGlvbnMoKQogICAgIG1fZGF0YS0+cmVzdW1lQW5pbWF0aW9ucygpOwogfQogCisj aWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQordm9pZCBBbmltYXRpb25Db250cm9s bGVyOjpzZXJ2aWNlQW5pbWF0aW9ucygpCit7CisgICAgbV9kYXRhLT5hbmltYXRpb25GcmFtZUNh bGxiYWNrRmlyZWQoKTsKK30KKyNlbmRpZgorCiB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXI6OnN1 c3BlbmRBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1lbnQqIGRvY3VtZW50KQogewogICAgIG1f ZGF0YS0+c3VzcGVuZEFuaW1hdGlvbnNGb3JEb2N1bWVudChkb2N1bWVudCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmggYi9T b3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmgKaW5kZXgg Y2NkYzZjNGE0MmQ3YTFiMzUwMmQ3NzA3ODA3MDE2Njk1ZTM2NGI0OC4uMTg3NzJkZDU5Mzk0YWI4 MDQ2MGZkOTY1NGRmNGY3OWQ1NmViZWFlZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFn ZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuaApAQCAtNjYsNiArNjYsOSBAQCBwdWJs aWM6CiAKICAgICB2b2lkIHN1c3BlbmRBbmltYXRpb25zKCk7CiAgICAgdm9pZCByZXN1bWVBbmlt YXRpb25zKCk7CisjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQorICAgIHZvaWQg c2VydmljZUFuaW1hdGlvbnMoKTsKKyNlbmRpZgogCiAgICAgdm9pZCBzdXNwZW5kQW5pbWF0aW9u c0ZvckRvY3VtZW50KERvY3VtZW50Kik7CiAgICAgdm9pZCByZXN1bWVBbmltYXRpb25zRm9yRG9j dW1lbnQoRG9jdW1lbnQqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0 aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2Fu aW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZS5oCmluZGV4IDQxZWViZmYxNmRmNWM5 M2QyYWNmYTg1YmU0OTkxN2ExZDQ4ZmUwOGUuLjJjMjA1MWVmZjYwYjkzYzEyNGI3MDA3YmZlNjRi N2IyYTE0YThjOTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0Fu aW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmlt YXRpb24vQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUuaApAQCAtNTEsMTMgKzUxLDIwIEBAIGNs YXNzIFJlbmRlck9iamVjdDsKIGNsYXNzIFJlbmRlclN0eWxlOwogY2xhc3MgV2ViS2l0QW5pbWF0 aW9uTGlzdDsKIAorZW51bSBTZXRDaGFuZ2VkIHsKKyAgICBEb05vdENhbGxTZXRDaGFuZ2VkID0g MCwKKyAgICBDYWxsU2V0Q2hhbmdlZCA9IDEKK307CisKIGNsYXNzIEFuaW1hdGlvbkNvbnRyb2xs ZXJQcml2YXRlIHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShBbmltYXRpb25Db250cm9sbGVy UHJpdmF0ZSk7IFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwogcHVibGljOgogICAgIEFuaW1hdGlv bkNvbnRyb2xsZXJQcml2YXRlKEZyYW1lKik7CiAgICAgfkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2 YXRlKCk7CiAKLSAgICB2b2lkIHVwZGF0ZUFuaW1hdGlvblRpbWVyKGJvb2wgY2FsbFNldENoYW5n ZWQgPSBmYWxzZSk7CisgICAgLy8gUmV0dXJucyB0aGUgdGltZSB1bnRpbCB0aGUgbmV4dCBhbmlt YXRpb24gbmVlZHMgdG8gYmUgc2VydmljZWQsIG9yIC0xIGlmIHRoZXJlIGFyZSBub25lLgorICAg IGRvdWJsZSB1cGRhdGVBbmltYXRpb25zKFNldENoYW5nZWQgY2FsbFNldENoYW5nZWQgPSBEb05v dENhbGxTZXRDaGFuZ2VkKTsKKyAgICB2b2lkIHVwZGF0ZUFuaW1hdGlvblRpbWVyKFNldENoYW5n ZWQgY2FsbFNldENoYW5nZWQgPSBEb05vdENhbGxTZXRDaGFuZ2VkKTsKIAogICAgIFBhc3NSZWZQ dHI8Q29tcG9zaXRlQW5pbWF0aW9uPiBhY2Nlc3NDb21wb3NpdGVBbmltYXRpb24oUmVuZGVyT2Jq ZWN0Kik7CiAgICAgYm9vbCBjbGVhcihSZW5kZXJPYmplY3QqKTsKQEAgLTcxLDYgKzc4LDkgQEAg cHVibGljOgogCiAgICAgdm9pZCBzdXNwZW5kQW5pbWF0aW9ucygpOwogICAgIHZvaWQgcmVzdW1l QW5pbWF0aW9ucygpOworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKKyAgICB2 b2lkIGFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tGaXJlZCgpOworI2VuZGlmCiAKICAgICB2b2lkIHN1 c3BlbmRBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1lbnQqKTsKICAgICB2b2lkIHJlc3VtZUFu aW1hdGlvbnNGb3JEb2N1bWVudChEb2N1bWVudCopOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv Y29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVkLWxheWVyLmh0bWwg Yi9MYXlvdXRUZXN0cy9jb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0 ZWQtbGF5ZXIuaHRtbAppbmRleCBkNTExMDZmYzMzYjRiZjc2ZTg2YTcyMTFmZjVhOGEzN2IxM2Qw YTU2Li5jYWY3MzA5YmYwZWViZDBiMDA5YTE2ZTNjOWNiNzRhMjMzMWYxZjAyIDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9jb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0 ZWQtbGF5ZXIuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9jb21wb3NpdGluZy9yZXBhaW50L2JlY29t ZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIuaHRtbApAQCAtNTEsOCArNTEsMTAgQEAKICAgICAg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnRhaW5lciIpLmNsYXNzTmFtZSA9ICJyaWdo dCI7CiAgICAgICAgIHdpbmRvdy5zZXRUaW1lb3V0KGZ1bmN0aW9uKCkgewogICAgICAgICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb250YWluZXIiKS5jbGFzc05hbWUgPSAiIjsKLSAgICAg ICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQotICAgICAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgIHdpbmRvdy5zZXRUaW1lb3V0 KGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxl cikKKyAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAg ICAgICAgIH0sIDI1MCk7CiAgICAgICAgIH0sIDI1MCk7CiAgICAgICB9CiAKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWxpbnV4L2NvbXBvc2l0aW5nL3JlcGFpbnQv YmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci1leHBlY3RlZC5wbmcgYi9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9jaHJvbWl1bS1saW51eC9jb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVy bGF5LWNvbXBvc2l0ZWQtbGF5ZXItZXhwZWN0ZWQucG5nCmluZGV4IGE3Y2RlY2MxNzZkNTdhZjU4 ZmQzOWUzNzNlMDE5NzQyYjU4NjAwYjUuLjY0ZmFhOTY2MDA0MDIyNmExMzdhNzMwMTllZDlmZjhj NjRkOGVjOWYgMTAwNjQ0CkdJVCBiaW5hcnkgcGF0Y2gKbGl0ZXJhbCA3OTkwCnpjbWVJMVg7X29q dyNRUiNpeGJqYkRfbGowUipyfj5BZnRAWVFsKnEzRGdzSj9mSnxaLVdROyV7PHYzNzlQPWtPPgp6 JHdkV1o0MDh3fTMxWFFBNGc/WklORnJsfEtvfk1XJGFHKU56NHo7ViZnWShmJUpjM2cmenJzMWBt Z28tdWJvR2kKei1KUjY7OU5xJjBmeitMVWBTfmdjd0RUd2t3QiExJjlsKi1MOX1lbVI5fHJMa3Vn M0A3M0pGNVFCfTlWRTFBX3VCCnolJmFVZSZXMmhDbndwcGZuY2g1bSZneTF9Tnl5cFk1VVpQKFpN Y2BgS19KfmU9YnRaSnlJWmAlaihwfVJQVkhSWgp6YEQwaHQ7bWhhMFl5S1g1XnooMXVVM2l4PHA4 Zm9naV5xUz0yNEN0QXdzOX1kWCgmJXhEOztnbjJ7SjJyOFNnckoKekd8UEZeYj9NVTh6YUBWQyp5 MiZRK0swWEMkND4xcyohQjIlRm1ZNFJJNl5gfjtaeVVtV2EjTlpYcUhITCRwNlQmCnp7VSV6O0Re NVhEciY1ckleMik8XmZYKXxCZ0dGRDFLLXJjJV9KV1NTP0Ehc2BiKXBed2B1cHpGcHgqLWl6YWA1 Kgp6SSgtT3IkZXQmOHJSK18jaWFAPX45aCpOXlpCY04lQW92UCVBMisjTE1aLWxFb2paJkNhRipG c1h6b1Q0KlZhOGMKejVhJkBvQyFrVSorQ3Q5Y3BNbFpTPG09M2FwZUFwPjNIcEBYOHJuZjMobkhH I0l0TmI3VUNKNnJuPmlwT002RFJ0CnpRSSpALUZ8KUI/I2pRYyh2ezclSGo5JjFuP2ZpP1dAayhM fkI0c2JhR0lCfVZALSQybSMtKmhEaTZvTT02JElSTgp6YHU+NWFfUWk1PGN4dUFPYGFvdyk0VTc9 Z15XPjBJPzVXI1hjamtfUjEtZXs8aj9WUGdUfEQmbG8lRzRBbk1+c30KejwzdDlGbHxwbH5hKGlo SyptWnhtWVF0RCUrTHVDUmUyY0RjOzFEdGRNPD1XYCY9RFJGVU9VPDc8Pi1neT0kU1JrCno+YUxI OXQ8V0BvcUZ0fikmTnRQUlI8NTNreG1hY3Y1aGNKYDtwZDZHP2NAfWlLIztDMz14N3FVejtCUHRa Xk0lLQp6cXFqdjw5I0Y5KzlsYztDXlI4US1xKFgqKngyWVNzbDBvQldxWitFMW8oLUpNIyU5ZDVU czNUSzgjWGo+a2pfbm4Kel4kejZ2dCprNllyX3JwVXtSY0NSQj9zd0xYPW9hflctOEF9PlBPbihW T2ZuU05DITdzUU1CTT1iMHE7ODtKd0psCnpeQnxJal5jYWJORW45bzl2QzFPZyVnUkVBM04wI2RZ MDE7NGFIeCViTjZPU1V2fnNzPG8zNlMzb1Rxb0AtbWA8Kwp6ZURyeXteelkyXjxpQzd0dz9QS2Vi SUozMEZuWE9JWWl3K1RoRXN8fUckO2g0KEVYOyVTZHFlV0gyMilQYjcpM2IKelJjKXZmT0ZIZT51 N2FxVkRxQHJSWm80aH5hXmw3e29BKUVBUCEoRzRCI2p0eEFlQS02MXhRT1grRXB7ZzYwTithCnp3 cjZNKTdXRVhleV5nKCZOM3JNUEs3SUVPbnQzV0kmTmg+ODZ9OVp3ZUN1ZG02b25ZbntXeDdfd3ww SjAtNzVZfgp6X19sPGxEMnYrP0FaP0BERF9fXjZkSmNzKDZUbEk0RSZzY3ZZWkZiPyklOyE1Qy1s UzllTk9IKTVtYElRZyE5XlEKekZIUk14elF5cmR1WDQ4K2s3S2R2VlpCI2A+YXNmO1pgdV5rcGhf OGY+OSg4ckUlRW9ZM3h7VDRfamA0JG5xX31XCnpQM0A7YUh+bz9xOCR0JTFVZVNYZStWI0kwSkxE an4jXnNPfmJHYEZNNUBpemsrUm1fO15fZGBDWVRfcTBTdmFoewp6ek4mSXElYnNxSGx5K3g2dHUz QnQ4ai1NNVIkcTIpRmVzSylaQSFWJkRUMCt9ZD5XIz55THdTOD4qUSY4WjIje24Kejx0aihkeCFt PVQ3YSh3NXpGJVctZkx0byU7ciZSaGNXRmMod3h+UURxdH5tbXpXQ09uPi1rZ3BRWj02OWJYO1JC CnpDSH5nNTVLezlNbXReUWEwZ0VPbEVJMEk/WHUmVUoze1VJK3ZNNiExbTRmPiF0OEZHO0ZafGYw Ul9UPmczdUJuWQp6ZytfSGh1NS0/NTxkcmI0VVlHVkF3Pkp4MD0qYj4zd0BBPX1BSzR5Iys3N2lm dmJ5PG09K2dNSXtic3g7OFE3KEkKemhwdGRXQmpAe0dyRjVqRmo/fjtCNGkoODNLN0B6Zz5hKkps SyRjazdfX09Wa1ZrTGhaWGZwS0hNSCF1UkhpYkdjCnpaNHE4a1EqRnleQm8mYndTbFZRIWtuPm9W byhfTSZ2S3UyfGx5aDZkQ0RJM2JWY09iZTVQMlpPNUhBYGtWVk5kSQp6RU8xZ3RyQH5+IWsoU2cm bXo2a1B0R1EqVXBoTmhuK0QqJUUreUAwU2FpYXlrSDxoOWElTk9oWHF+V3dpdH0+QSkKelMmPnE9 dDZMV3E/JX1RSGdeTkh2UCp0KlF1JlR8cmJ8SzRaMTFfS0d0aUdJO1JwMS0taU5hPXcyTCh3SHZD SWdTCnp2d24hfFRoMHwlUWhSJDsrd3tYU207NUwkZyZaLWM9aUQwMmJ3RGZTSnZ9e09gNnNuKmFr ViFkWW5RYX5ORlVvNAp6SjNsYSEqV0cpRzhOMlRQKU5aNWlMeEVYdXdobjgye0Y/Tjw0PFUqVEpm bWVTdUslNVAtKCtRRlpFe2tnT1czSykKekwxNHE+YDJqPEdPPnJDJGl6Y0JFcjs+amplSH1KfUJ9 Y01heTlVNkQmclRJM2lJY3k3ZjR0bmlCemVTc3ZqJEczCnpuN0JfSFJVenQjPCFjT3hkfEpiRSl4 WSglSmBOUjJ1ZW1ZWGxTUHNWTlB7T1heWThDVmBlOypPP35KaVAoOHJTPgp6KGh0YCF4dF92ck98 fkZMWjFeP1hUNXB4UHdSUzZJVz5DelY8PWJCRkhUQz8xaEYtM1A9OEdNfFZNODZfOW9sZS0KenQ9 MVhlan5fcDd5JDM3VGE9clp2WT58U0c0TUJYbmA/dml6JWdmOFIpbnQ8aGQ8an05Sj9AayhwVy08 bipLe15fCnpvJng5UD1HUDJNSmFKS0N1KnA1PD82I082SGROUz5Cd1ZuTFRRRH5feDcrJTNGVzFi I19JLUR6S21WQ3dnJThoUQp6X3I5d2BvclVNbDdVPmxAZiRnYGxLT1RVSns5flFAKiplbVFSK1dU aG80RkZaUjduS2Q4SldEO2xTS35kMzlqTjAKeks3KkJ8dnRVKDJRJCo2KG4rUXk+U0thZE1ASWBM SmFyRWZMVDhKdE1JdVZubTs4TzxBQVI/bSNYISR6bEROMFhQCno0TD9YZEFGUFkyQ3owKmh0d3oq NGZxWH1lMVRCVl5XPmoxMFlgUilJc2VMU2dwUjgjZDx3bERpYz02QDZ3TSlhSAp6R1BJLSN5RlN9 QW4yIXVHUmNLcF4rK1JNY0VuZXhAND1YQmNYUiZCVHUjS2tCYE5HMCk2VzJlT2tAc3BnRk1vV0YK enAzUmN5UT5QcUljTmFRa2RXJCh3JHFEQyQ3YXAteG00ZF8+SEpsNV8xVjdYbXNxeXpLWVktNENf X2MmQDF5QGhFCnpuITU/NUBtcCZmb3dzaTxRNUZoWTgqYH5MX050KDVIYWp7XlNWVGd1b35kKWkx V1B5T25HdVBLWkU9bzEpWnh5cgp6PXV+RCV6Si0rKU03Y0UhbWk5VE5pTDJwZDtxN3N9O1RhXkkw WXtUZj4jPXVkOT1WKCQxX1FFV01vMSpBWHVSQ2cKekVAYT9FbXE0PEBBfCRSJT9tbHAwb2F5SHlR flctJnRxbXdZVH19NyUoJFd8NCZVOXopSEd+MlUodk9yVm1QbW01CnpqcnM4TVk8UXVpbTZoPzAj eTNxKFdeT2JOaGpUR2dHWGFUWXc1S3EkYnh+e1lCb1laQVZrNihTd2JCZ1RRemhxWAp6NTE3c2NS JTBfPFBZODRJc0NnMXM1ZTAqPiFYUHB4MCM5eHdrPnR9PzVTPitLbF5ydD1fKlojNWJUJFVPPntt aigKej4qSTtCSHhLQiR5SkZAPm94cnQ2aCRodlopbXxZQE9xXm1sWV98NilvUHRVXms7QU1IYld+ KHFwNVVrVC03QiRBCnpOdF9QVyUjSWcqOT9jQ1N3ZlhXKFZGKzBqbDw+fGpVfS1nRz8yUikzZV92 dUZ6JnMhclQ3TDFQQldSX3RAeHM5SAp6b3BybCRvNEcyRlRIIzFeZlhRdSMyZDV5TkB6VzEjVlRB cHRZNT56TihKTT44dTlFTnchQmskP2ZESmchcj4kUGgKenBiODlPUVBGNklXQ1glUkUpKT1iO3l4 MU4wYF55WENFKChRSXxxSHJpWHhkOWZjJlZgPjdBPCZBbk5KYD01RHEmCnpgI0Y7ZzxROzFxcXxN aWM2X2puPW1aXntaWWAtfmBIdj9Ea3NtVWp4IV4ycWkjITU2JmxSOz1IVzVCdH0mWWYoUAp6MndH d21JPikodDlHQk1ARClZdCp7NSNzanVmYXBQQzltdkx3cTQtPXA+MXBGQSVFaEhLcVNsOD1rK0Nw aHs/MlYKeis3a1okZEBLPkBXWGkyeGh7R0xBJSs2a3g2PjRqKFl2WH5JZTtjNVp1OGtfcz5TMWVN YWJ1UUNlJiR7UG5iWSlJCnpTWX1HNCt7YnRPVHtlWTY4TUQ9bU1WM0EwQDVOYWUtQDB8e0J6clY8 bFdtMCpPd0h1TWxeZ2tSKU94cU04IW1hTgp6dk04RURSSSZ8YEZVbzxBM3RKY31eNSViM0dwbHlv NTk4YXQyflFyZlZBTmMxbT88eGM4c0tyb0ZEb0dkNjl3MSYKeipOMkNQLV5gZExnP3dwQ01zTXZf VDZSPiYtYmBAN2pnTzlBTiRgQFFsK1FGdTJmaWRYNjhMVE44JXxFVyVyS212CnpIRXR9NFA3TC1X O0o0IyNZdCZwUD57fChoezN4TVpJRCQpQkM8d1h0cUdXbXw+MXsldlhUXz1kUHJEe2tfVCtYQwp6 ZUk4WVY3YTVRZmdiTmdANUVleHgkTU5aP24yP0ZpZiUkRUh3KmdIRzs+RFQjTkc+ZiQ3d0lkR3hz PzZrMlNfS0kKej92Pmh2I20wfW4tNEomaEEjPylmVzEwSik9Wj4qIyl9aklAbkt4MjlqWnZqNVR4 SH5jQ0ZCXylRbCNfZz1TYWZnCnpWVGkxV0tDbDh1SEFLKCNBK3U9ZzU+M3YjKH1sSyNjYC13Yy1Y Wlp4MTlVVjdsV21YWHhEUk1AOWN4NUErUj9ARgp6VzZvO1gpZFN3RD1mfEJpQXdPe0dedSghey1V KCh+bkBPX2hHWnkzSUlEemtXPG9IY29jbnImJT5fYCM8clhaVEMKemtOXyZ4QnVxN2ooXj9xKk1k Z2JWLWYjc0YyTD5edm1NSWE1bypjSFFpYiRQIWVgdXE9VyFTTj45QUg7ZUw8RVhnCnpnNTNZbHN6 Wk5ZJjlRbEQyb3BDbV9TODdLTjBgTDl0RjM9bW1DV1d0U0tJa0BxfWdvU05mcnk3e0pIZWUwZXcy bwp6d1p6NDhzfj0zPzhFT0t9ISh5QFRpbD9fVGR7cj8hXzYtR29PPlljfEVWNU1aWGREfEchfDRA dHY5eEZ2eWdtNGMKejYmMz55c248PHc8NWc4bHl3N08wOG1EPTNEZlc7c191VHlRRzRtMjJGdytA b3R0PThqSFJie3t2YFUkTkskJWYlCnplYXY/dSZGTW83Jl5zSEpmVXhKRVgyUlJ+UVglKUNPP1Yq eVFVPk80R01VRGs7bUBONUg9bCh4RE1GNVV7JHAkbQp6cHBzZnxLYWJ7R1prTVlSdGxCOFdhNWFZ bWw2JkJJSFkoMCh1fnlxa3E2ekl2QDdMZENCak18S25QZGdsODBAQFcKekp+cCZ4RkhqSnZUaGtk RE07SUl6VnsmdWIxeSVZelhVdjs1ZjZzT1EhOHtgdDVhYWFNdyt4fiNUanNvPF56KDZCCnopWDZr Tlp7Kjs5JkA2fUl7Tz1NJnhSbGhnPEhlfkdDYWc4V0FsMj5GNSpzbGowWlEjO24mbiVPJXghLTZ8 N0FoVAp6X3MrWGIkfGYwIy1scFpnbyZlWCFvXmFlJV5Vang5UllDVEc5UlcmVXw2MEI3UHZJP21l e2B9alN2MjxRViY8aSsKeiF4bGszUHQ+KDckQUw1YGJtPz1NaDhvaH1EdXV4WW0pM3dAJmloY3tm aTR6WiZOeUJGaUZ7ZFRBWCtHcj5oLUArCnp4fkMmS2lgMTxkZEtoamM2NSZFc2luSTBsVD87Uyg9 S3c9aVhrbmlzNXBmZnw4RWV4OCsxYU55amtmc0lEQyNQdQp6WmVaVHJFa3tve2ZvfjxXbUlMMmBy eklndShAKnNSMTsoTWQ1ODd8fjA+KVMyNFFFVF8ha3h6N1hDMkQ5KE5hYUsKekhUcHU9ZkQ0MXwz SElUSTAhfDRPPDJ3RGBtQWlHUlNGd28lSSt+anMrdU9IK2RZNnkyU0EtVyo2cDg0VnEhRnhBCnp1 WVkrbSpTS2d9QzVOdHg3S3peZWktVnl1SmYqI00+bnZVJnFnN3krJGxGVjstSSp9ZnVNVF59a0Qk I1FSOXZyOAp6NSRAdW1CMlhyenttP3c+LSY+SDtEbE4pQ0IkQERpPTd7TCUhWFpnVF8jYDlXVmYp cmROUGRmXkBnTFRfPUg7bVoKel5oJTRJOEt4b0V0JEMjI3k/aiFrKmRKYmEhckFvcF8qPkV7I1d0 dGsreyVpWiUmIUcteS1HN0B3OztTUmRNVDErCnpYUFQlNCQjS1RhNE93d3JYYCtIS3RvMkdXNFZ4 ayRsMmJQR2xyK2AtMU1iKFVYe25ZKU0pSSt+Tns8UXdoaXZQTgp6QSNqcWJPfWVfWjtQVTBCaz1C LSRSMFNVbiNSTHokRmVzeSlNQlM+YUNsUj01dlMlZGl2cDRfZiQ8aUw9QnBSQDEKenR0amhSdlE7 WHp3empzaWFgQ1pZLU5eX09mV0NtRVRWXikjPlBVamFmVnB0JEopZzx9XzZaRGMrZVU8YHQ0Rkdx CnoqZStSeiV0OXhzSlI+NmsxVl9UXjFLemJLQENReUBQV3RKZ1R8fSswOSNGVTt6TjR8UyghaC1k STYzM0FefnxCNgp6cD9nT0Z7ZHdaPVBYQ15gJUpKaj5GTV57ZihvbD9eYW1VKEVeQWsxMio4Xndr MjhfUWBiSEJTLXZ1RSYySlRTcUcKekk9PmNvenlEI2NiekpFNTRFPHtJKEY2Jk1tfDkhR0lgK2lg MjRWRXppWTBGdDQ3Uno8akZabWlkcTRESDl5KWB+CnpzTEpwflJDKGVzb3U0TTgkbCZzfHVVNXUj amoyOyNGazAhKzFvJGokJXEybFhafU9QQUFFbCRaXmpLNUMxKCExbgp6MipPTHlxaXVVPzZ9RHky d01kSTJDOH49cUVYRD5SNFpZJG0lIUE5X3c3MEpPO1M7eHwrJDhtNjRaMFUjajErZ2IKejdLVHpZ SEN3V2U2Y21fTWwkbGh8dT1nNH13WH5NSTxPeyZvcmVAS2NQVSFifTlHP1ZZI0taOHlJJHZoTyVw PDBBCnomaS1Md3Y8Uy1YfE0ycDtqSS1KUDd9RCMjMkYjZ2dYfSt4WU4mZ2RfQkh+aCZxSS1tPlRF dztMIzw/elImNj9ybAp6IUYoRE5FVSVmc3NpZXg4eCpSPV4/TyFLZUthfktycnBTVHhNfUU5NHoy e0R4KGYoYTYrYV5nTlc8KFJgXkl+UnUKemhPcVhldCl+MF5VeGZeWTdwQUZYVChES3QpQyZVLUZU QjZzayQpIUpFYzhQIU03YSp3SEN6SnlNajNVeHdFbz9vCnpGJWA4PzVhd1FEbGtvbmJkUlRFeFB0 YTMpRlV6ZD1sa0NRaiFKZW1KKWdXQmlOSXdjbCRSKz1iaiY8eERLI2EkYgp6dj0pP2Y8S2VASC18 Vz8jaXpWSkAzVDVBJiYzWWlsbE87WUZ5JDheX0FGaCM4RHU7QCFqRDRESyZHa0t4VGxpcTAKej4k M1J1RFFNcmJqTUBhPHJRJkFDe254RT9zJFAzbU8/Zk42VT9YNHNkYT96PVpUVz9WZCE/T1VPUV4t bWpMU1lUCnpZPmxMUHopYnxNPEFKZksldmhvTSF1flgzZyVCKEFOd0ojKTtFQDcmKzN2PiYpeiNJ MytYaDRWNGBDQ3U+dnIkTwp6OGJ0YXZtJDFmTHFwenhaX2x9PUVUYFRMfU9mYCRSWnQyI0d7em5y P04hPU8oWmFrKUBQPldeeEMhOEBPSmIyUTQKekY1b3s4SXtjKGBpdXpjOEVSQyZQKD18bz9YViUr PF93fDl5JXtYMGZwWUJ0Szl9ai19ckh0QkVUM01rWip3bjd3CnpgcHZEYTQkYD9DWntMYDFIVHow Tzc2fT1SKE9jfmh4PSV3KVpCQiM3OTNOXl9MTFBoOUtNcFVgXy0oV0lJNTZDbQp6dGZGe2pgVGsz TXpPOHVOMTB0QDN2SitYNnYlUlZZXnpLdH4/bi18dE1fUmsmbkIyRV5PemlhaWJyOHJZPWE+P0gK ejl8Uml6QG41PTBgeG8hcVVlVlJmIWlHXjAtZENOblAoSG1ERWMpVG9OcEdgeWoyPTxCJkYyITVf SGh5emV3IURkCno+OTMhbUZSIVR7VyFRR2BJeGctNGVkaWtSNzNreyZ6e2NLdnRxRDRCbEsjen5h NEYqRjUqRS1QK2N6VjFmZHJgSQp6e3wlMSgmJE1iXjtrNmMrZztBbn5Ba2V3bmAmPytFZClTP3om TVZ6OEshQVZaZUUmT1dgbVp6b1kxYEZic3JAVXAKbGV8amVXQ0d2aiprdDtQaTItaHpyQU5XeFhf IysoVGU5YF5xeH1PNjZ7QDw3KFVWIzdyCgpsaXRlcmFsIDgwMDAKemNtZUhNY35Geip6RH42aj5q TGRAS31EYipRN1dxdjVMclVuUWNGYHNkU25TMkFTJTBJa3RHQlNPSHFNVjZjQ2lLCnpDREJTaSp9 QGAoMDcoPk4kRHxOUTM/VSNPT0lRKmlCdFh7bGRDdHVKXlBZMk8/IyNKJnJoakdmJk5wQSlfaiNZ Kwp6XkV8Jl9lKjVgPyVrQ1lBYzdRO2otTE4wT3pYJD90e1IjeHk7PU8kZnUoRUlPSzRha0hNQ0A3 YlNwU2VmZV5kLVEKejlBeFZzNU5MaHNeZm1DY1E+VXpMITJ3cm90bkJRLSpSMVJVUHgrc0AzT0Bi b1V0e2xxS242cHdANHhra0ZJZzZaCno9WGdxIVVhb0JZWWtUe2xANHh4dCNtYmtydzZ9a2BIfVN7 aTFCRz9nJDQqQGNkVShFVUk+NWZySUBCT0JCc1ElMwp6P1JuJGxgdEhfMGBkX3JwWWtBO3RVcUFK bD4kUjBuQjtXbn5eajZOVCN8TDJmU2gwbm80WkZWOT4xKUFOeXNsVD8KemA0TEstPzNeNW4oYWZi VnNoSVZDOFV9WVl3Q0ZlcF4haX0oMypaUGhzPW85RmZuSSZPQU4wLTEpWHpYKW9XSnIzCno9K2l5 XyV+SWA9WkpaKC04b1FqYlluaVQ1RmpTcTJkPCZnUil4QyRBTXd4djw4IzJDJXMwYHIweyo1fUYp eFYhcAp6OG9GOD9pRlBlMUQ3SEdieyZGaiUoPiNWNkQ7JCNUYVUwMGVGUSY7eG5gVVFJSElsaz08 NHJ6ZXghfmp4K3ZeQE8KemU/dlljQExXb2kzUCZHNDcyelo1RnBTdmp3M1BvZV91K2tCUWFMYHEq eHJWNjZDSFc9UDVTUG5qYFlCT15eKEEkCnpIZ2tNQG9TZHxibihvZUtZfGEpVnZDRUJESkpPSEE+ VndgQzNFQWFfJTsoUSsrOSRJVXBKNSVaSW9KPDtldXQmVwp6KjtkdUs1e1VEYUJgPyliRENASnVr JVdfMSt3WGs3TT9IZzcyajtCYldiOVU3QHo8fSo1UGRhYnI7YCVxcDYyZ2oKelo8Sj5vb00hfW5w fEMpWE9LbnJ3ZXBKVlJhPkNeI0R8WHJMcX07UDRhOUQoaD1zPWxDKTBOLUV2UEdpUS1KK0lDCnok eGRWbFlldFN0cml1cl5GKVQrbSFkdnMpWjVkSmJKOEZWJW9oUWB2IUFIcTA2XipzKENjZUVGU3RP a1E1blFObAp6NilsdzVmI0tkTWllLUlNdWg+UlBJYitqeFZ2SzVUTmdJWkhZZERDX0xVMnM2P0hv b2xmVn1aLWV+c15ed1FENG0KejxsbTcjS0EhNEppZm50Sj4yY1pDI2NLIz05bkUmRSRCNClDXlln bjZ1dUR9OU9jUzNPY1EqKlMyaUpPS15oS3pyCnpPTXpwOz5lVmEmb243JDdfbElYYyl6Knw0R0pu Wm50VUleVlFecyNERXtzJG5FPy1XVHZ4eCpXPVRiKClnI1J9aQp6cSFkbCFGSihJbiY3MmVjJn1m byMxbiReNW5RQVVZPUo4KlFfJGhiO0lId3w4XkVHaWZWWGlTWVBUTEhzeXM/ZnsKemNHQkJkS1F8 NiZZMXppMVB8QmFXMW1BNWkhQjQqYWpufT5rKXgtb3hzcEx9SFBGP0whZEZHVEBHbztmRXFMJCRq CnplV2ZlUStJMXFLb0RyKSVwXkJKJFZ+ZzNGJnZIXk0keilzS3cxbCREK1RwQzRud2shISluKE0z NG5zUnZfSWwqfAp6U01md2BeRighcV4qYVRvdihqRiojPlU+PE0kcXBidXc4UDc8Vj93Jm9pPCg2 IXlgb3RyKChYRzNeX1EzeE1OJiQKekBgZDc5UWNgYU5PWGVIWnhmMGwpQHN0eWc/JTRiTCZfTzUz YDNWOTxYdjJOVGlzTHNhS2Q2R0UyN2pMPnJYO0A7CnomfntvTFVKK31ZSzRlWERzeUVNT1d8MiFx QiY+QS1XfT17ZGx9a1RlKFg5U0deTV4xJmspO2BRR2VBdGpXcW9haQp6T3kyeGVxWldARiFPRzRi XnM+KHxDZH5WYCNhfmUtTk1AYDNYZjUmViZ2Ym9xJTBoRkVqMVM5JXxLUDgzNmgpQEYKejlufjM5 I0Qre3RwcnhOb0ZpaWJNXz5xaHg8eDAxNEJZOVNmYE5aSHlxMEhHfihgOURaNmFVWCtSZTFXTElC TnExCno0LW9WPSlLS1lDbnJfb3hGREgyaj4pdF9Yb2o9JnNSblYhTWstWVgpMVpNVyFLayVUPy1V Y2hDYEZlYDZMZWZAcAp6eDElQ1ZKY0drb2w3MEUkbjRwTzFFO19GUGFwO2hoNHJKSWpTaTh+LT9N NWhwWWAkTip5SENxKz1URXI8WWAxbDAKek51aSN0MShwUjdVcVg3JUZQKD1mY3VqKighM3t4Ozl8 NiMmYEAxQit5MmFgMDhxaTYzRF95OGVpa1c/SlByc05kCnpycX1mR2w0cnI7JGNedDVDM2ZjYj8t I2E7Pl8xIypsVzxNQEMtJEZiJEcpdlM/P2Z5TVpIV21eOSh9UHlWRjsrPAp6MnNLJDxRQkI9XmlN cF92KnBkKlY3SGpDIS1COGhtJF5eKzk8czIwSCFOa01nfDJSJnNJVEN7emVlMTAqQDtTezwKej17 diFycigqVzkwbUE0LXduZz5rOV4qSEtvQVJ3LXgjOWUjSF5zSyh5MUVyRD0qRzhFc3RWN188OEZr KyltfiQ9CnpjaXIjSmZoJT0/WXd+STFLRnhOcl93VHdfPWloelcjPlVlcmhme1M0NDFBd1olUDZ8 WSMzK0NOPjc7YzVKUSFvUgp6KzJnVlVPUHd1M25hdWVCU1MlQCpmfXN2SypYQSFaMWNlSik4ZiNa d3B6Xl9rITZtMXp6NWV5TmQtKnMzSiZJZG4KemUkUEVWYjN3akh3cDI9V1FafTROVDUtJHMhZzM8 UEVAcmtsWUZiMntCaC1JQlk9NllycG90bWttaXhaMCtuYGRxCnp0Sj56dU5URyt7JTE5LWdoIXMo I21PcmFaNWVjS2BmKGJAMi1iaHU2X2Y+OGAmWFE7eUkrVWpDPVdRUTdTKkd0MAp6WFhhaHw3JnZW UFI1QDhtcnJRVElPTXBYaDYxST1EaCtKSj1yOCtWeDdzOzNoJGVWUnx2eWhjSWBfZShBQE5fYVcK endZLUYxdTU9UENLKEIwVD14IylEbkkoMkgoX1F4Z3hycW5+aUp5T3hWRz97WEU8SUQxI3lKQU4o OHpURSVZbzlPCnpSR1gtNHIoc3N2KEJ5YWViPilOd25zU3gxJSRNLU9IMlJwPntyczZWYzhtak43 Sz4jfDdxUSo8ZE9jezdnSFdZJgp6SCZwRSgldiZ2bUByLShfeWF6e3loOFJnJF8wVHkpaWRzVWJt eyFXVU5wTF5qPS04TyVlSUN0Rns8OTN1RmlCNEIKemFhe1d1Z1Q9Tz5RNkleY1ZKTmJ3dXswWnRf d1QtfjZOZj5RZlFtND9KWH07SmUwYnZIWWtoZTVIIXtzcUZ2Si1ECnooNl8wfEcqNWA2KUxgMjBn dzJHeEwyVVRMIS04PV8jQ1FxTzQkS3w0dUZhZXlFYUlWekshcj9NOTY4SFMmZDRTXgp6ej17Y0Q3 JXtvVTdHPyN3bHRMdyprWXhFQ2FSYn5VRitPT2Qhc0k/MEQ1XipYPE9jM3E5VnhWa1JvOzwtKUFE azYKelV6Yyh6a0UpZGRhV1pCT2s0Y3NrUG1ERjk7OEI2T00qYUVie1hxPT84fU5XVXRLSD5gcnNU R0lEc3s4aG41Z19DCnohKWRKJnNXTmU4MTZSMTAoRXpCVS1sSjZNdSlDWFleNXpWbTYzR2Zgej5H ej8ldXBzenhSPnBYcVg3QzMoODhfWQp6PFApWjdYakpVN21wYyhaZVA3M0U7fGQoa0V3VnhGSF4x IVJvZ2YjTWleciU5NmJjNUFWMVVtc182c1VDVlAmY2wKemtIPzE9JHooRE1wWFM9dSk+ZSs3S1de PDBYUHJoMEJ+czlXZXMkfEo5WUVRSXBJKm8zOU1NNVk5UnNXaSQlIStqCno2RGtwZ0tSVzg5NjFx Kj89LTRkfiU7O29hLXMqKmkmRnIpRSFQKUUxS1paOWdnaiUtVkJLMUdvUSt5YHNUQ1B6eAp6UjJA SWxsWGpgdmhpWDspTSpYb2BnciN9Oz03e3s+MDhUWG10fnVmJVo4MlFDNjh4c2ZeR3NwZFFHTGtH KmNxT00KejFeNERXWE96Q2M0bkxfPUFqZyhpaGhFR3pHV0R0bzJAVTFabE4yUEpwSWshSncxd3I9 Z01BIXo4bnZrbDkqYXRlCnotaHEyWFpjcUFqUFduY303VzIpd1BBdFN3KWtCRVptTFl7JFRtJnZC KXomakppMktiI1I4cTJ7RlEzbiFYaSNOWgp6JUo0QjRZQi0xRW1KU3FqXmdSO0g1dXFSSXlAV3g0 N3RiLXhrO3NqZypoeDJNPWl7I0l0Z05qUm5OOzdLSWozV1cKelc2R01Sd1U/JXptKjJFKGVvV2Zu WVVFQD5aKGFpK2lpcnc3ekVjXz1FKDgqZmByVTFUWDNZKUhFfXQ3dTFRWVhuCnpmKXchVDEtfT4x cSNjSUxOQkd8YnQlYEhWenZ3eGZjMzBrbXFmakBlZXcjNnQkcnQmNkghcU95JXRUWDxveSU4bAp6 YlZKOGVQVW90K2BMPkIwQUtGKXM7ZTZgLXlSK0k/YHlRRkhwYy1aVXtkMmc/b2o5TjlVSTVwLSp5 cWEyS0pyJnQKemJVSjs9ITV8aHh5MVRmT1hsb2V+NjdzY1JQXztlKjF0ZWlBQUV7byZBI1Z5dil+ PnthKitON0ZtODJHIVZqaCtXCnpYV3RhaEc0WTdTd180IUordURkbCRJe1Q3RGs7fHpObWx9eWlh OXFTRFI+VjNyIUZ5PiUrZWB2TFpJJDVeJnw2Vgp6aj8wWihEeDxIVm9ydUdPZ01VTU5aNj5OOD5w YmFPTyNiNmBJUGx4bm10MClCNlh4KTZKS3w2UmhaXjhYQTxKVk8Kek8wfnw5SyQ8OE5UIWRzUSh+ PU93djx0bGI1STtHVUBDQERLUyNERE0/Jkp0fCREX19TXk1oSmAjVjJUSnpeKVBgCnptcXBEX1dC VChHcVhJYD5fUll3UlVIa1VhUTRjTH07Uz1tVSFqMTJ3UTlvbzI/MWpEKmFKLVRsMiF6PC1YUkZk cQp6YkNtdi1uUH1kdz9yY18qYntuRH5GMyF2RkxrdG42cHJxKTk7N1JCQmVoR25KRitaanxtYiQ3 alQ3bU9oKDZke0cKek92aHIlKD1hRDlYOXEkUHJ0aGNQa1FvRmJ6QHMkfG94YitheX1vbigzc1Z7 cFB8SGlBYF8kN0Z0ME83emRtZVBeCnpiVyQxe0BpKkUoTjF3S154TXUpcURTdG9zdmxPK0dnTXAp U3J0KFJyQmdXMXxqPC0zOG4qOU15PXJwJHRka2EqUAp6RWRhQ3QmODJOald1aXJYczNyJm1eN00h TUNKM2JUTSFJOEl3SXJ1WjIkPEkpSi1yRlFpa3VKQ0V9VU9Mek9KQlgKeiYtUXNpME8lSlZANmo3 NVZTbnAqcl4wVnQmUT90NkdVNVJOMDxlV0RLWG1MZHpFQX0ldzh3PmckYiooQDRPfTZaCnowazZN cCpDRXhSczs1NmFQfl5QNTNjJW9XKm4jKiE1e1UkYlMqMX1kblR9dzFkPn4zWnU5bH10ZHlZYzVl eSF3YQp6WUhpWD1yTXhNOGxoO3QkWDhvdjQycERefHFnQWJkMDh6bngxfXteMld2KXFgSSRgXmB4 VlQ9bzxjc1FVKkc2WFEKejRfZiVPa3o9YCVTKDxVfGtUbmZSMkEhR2ZRbjRFemghTEclXiM+e1h6 cEhwbUI1OGlsKVZgTztEbGFeclY0QE9DCnpwcH1hWj9abzN0VEcwOEhuZiRDRjFlWXV9Qylgb3h4 cnJEV14lUWJsQnhzRmFuVk5EWDc0Tz9XSjVWVTtJaHdyJAp6dCUxT09xUnZMJFI7I3F+ajlgPHJp WVojWWc+TVZjS2Q0Kj1GT0VHOUpEJX5QXituTjshK3lCPnkpcEVKU3FWQDgKelgqaCZUQnRZMT0w fVExQWZvK0l1UjU0RURneFE5VmRNTHd3N09vZmY/WGh9KTZAfH5SY0QxQiRPb0B9a1NmY1gxCnp2 OGhXWF52Y1puXmU/PGBRfG1xNXUrPmR4PTNnJXllcz1fTlhYcllZcmU1O3s8VTRKclpxXn4yPism Xz5CQiMwJQp6eENSQkp2e3g1eXU9YWBqVDxedHU/Pj1TfTA7RS1hTSkqcW0odj8/PUMkc01KKXMk Nk8/Zzxyc2k8cigmO1JSTisKenBjOHlmZXpJeSZBQ19CYWIqIzhkKmNgPntIZHk0KlN+YTU5KV5y X0tZXig9MEApYzVwUjtibzdvKStieU1NajA+Cno8VklTZmpSMUoycVZuPzItNXokIzc/elh9XkA5 aiNYazwlNWhOemBVN2tOMVR3fiZFPzBZTGZ5JT52VHlyVWIjTQp6NjJqUUErP3ZHUGZFfFdHQC1B Q0BnWlJnLSkjbDtYN3dHYlpxKXI0ekVPS003O1c2XmV7I01Nb0YpVjB+bmFKQSgKekdeUklNal5L NDUwfEZUVSYyOEtWb28kUm4kX0t6U3R9bk1LPFptY011Z2VvQlNzZSF2QSQmYCozPWI3KkkyMyFS CnpkU3crfTMreldUSGFEOFFsOT9LYHl6SlYqUShMPCM8VWAkdFYoTXhpWERhUUNNd3plZ3VuSlRs Uk5SKDJhb2FQTgp6P1cjez1PZE40IzheTTBLZStiUWp0T0d0WkozR3NkWGtBYHNYcClNYDk1QUJ1 eGQ4eEFMV300TVE3YklCUDBCJXAKejdDRWh0I1JRaWBiP3ZsbHN8e3VtaEVuOSZoUzIyWShNRGNh KH0jME0lUC0odDBHbD5+alZDTFgrcWRJPDw5SEdQCnplLTF8YEM4dDF1WWpIMW9jO1ZAWEMhfWBL SUtZP05xS01iT2UhMGpjVFZuYTcqekFkb0U/YX42Y2QxUUhPPVY/ZQp6S244MjZlRmJEWnBpYD84 dnw+SU1aJTJsWGM+Y2dNKjJqR1UtQ0dOPXIlWSMwOHVzfXF8RT8rQFlKR0tlSTZ4SDEKejkxR2JI PGpWV2gjSH1ZTXFaKH14eEFacFpqU2JoQCMpY0YrSXl9NiMkeDVMRVpsMUglaSY/c2AmK19uS2pj QEM5CnotXmFLOGNvcFRVWVJkUmV4ZEg0bCpHS1MlPXhiXkJUVEt8PkVJfXRwNEpLeWRhaGR9eDd3 PkBLKnJQcWtpZj90fAp6eTZ6b0olUzQ8THJWakhXWEpuMHAyKDZALXlNblN8eHJ4JEJXTyNWRWZR RFc3ZyFfNlB5ZERfYjlCKXV6NU1CTTsKekU5c3sjeDhaWFc0K2A3MFVZdnV8U0FVd1lufG9oJjtZ fCZLaTxSLUhLPSVWc2gqd3tlbzw1LTVHXmhHIzFgNFVnCno1ZXZgU0F9N25ZMTF6RCQlemIweyZf WHdrbDkmS0BiYEJiU2shcENoJHxnZ2MhYSQ4UkY5QTdqQ181dV4+QERUUwp6KXkxOSVnK1EwR3Fy cWdIXzk1Qj5nPXpgdHI5VV9kait4VXw/ITc5a19RZHJFNl9nM0A/KDtQIW1mKT8wRkwkeDYKekEp QEFpSDZjfTtNNlRTM04mSE9RI0A2NmNzRjQ4Qy1fe2tQJE81PnNMX3QpQ0U9RnwrVVR7MW1TOz9q Vnk9Ti14Cnp2VEJua0hXa14hdFZtPUpoJnJBSD47dC0pSGBhb0YxZjczcU4+NlJwSmo9NWtrRHVs c0JLMih9IztQdGcrPVpTaQp6U2J7ZnxsbkRYU3NpTE80VG5udU5NPUNyIXFlS0FkZklDZkdkdWt8 WDNnLWhVQTBlK2ErQGFVRCtHamRmNjJseVIKej8jYGA3VX1VXnQ9KnNJb2YkVEctMCgwTSV3Ykh4 YEApXnNOT1E7K1VoWFZ3RmR4ITAhTVB0LVhMJm9LJXV1SU8pCno5bS04ZjQwVVh2NUZGVmVFTmhv QGtzbiN2WlhDUz4oNSZJRWArQistSzQrcmVfVy1qMy1FMzBxbVBmX2BKc2xpLQp6OXJUNktaPyZw UVU/WVBqb314PGlxdzFUWntvQmxGTVVCVmZNbmxVejJ7bzQrNGg9WWVVRU02d2cxa0x2S2BxX2oK emM2RF9QO2dXYXU4UlIkMDVZKGg8MnEwU0UwPzJWI2VkNlk3ZFVgdDByfChPPytwckw3TXdwYW1f QEY5Qzs3aVJuCnp1OHZIOXdzMFZ5cW5nNkwtbGRvQyVGZkdAbmY7PSV7RnNLVlpFY1pKbyU+Kzk/ PEpkWFdEPEleSnVOTGVOQXAxTQp6Ymw5JiozYlorNm0qTXdFdU0xOXdkQ1B1ZVBDcnsoZDMqSFkp dG5rWWMwVHNTS3drI1RnZClTa2xZblNUMXtSK30KenA1TnYtMWlSJUxpUnBAbk52TV4qaz5NWkM9 e25EI2NqMntuTHJGVG45R3hDP0Y7cD16YmpmUEo8K0BhZ1BuSFhiCno4P1RLYzclQ1k2dzc9I3I5 dmNqUC1mZngkRmB+N1dHcjRza2A+KFlpUH1WVkxDMWQrMXBsNF9RKWZEYURvMztKcAp6c2olOz5e QDBXcHFLeEp+ZEhIMlNWMU5FbyRZKkR8TXNgJmghUDBsQCNsNDxBNjw9JXs9YGB2Tis1a3ohIURx SSMKem8hJE8jJTw9dlFKTlRDfiFULT5eIW9KN3pQZSthP3pNbE9BYll0TWRqKD5aR2A1KVR2e31Q VjFVIW8oNVBmaD5vCnp4OzR2UTJMbyF+YiZtYWw2VFQlPTE4b1lrOHdHPmo5aGZyejQpbntGRWp2 TTk2fTtSNitJfTNNPUI+fW97I15TMQp6aV5TVm5ZdTlZcVZMKU98X2BVa2BPOCtHSHBFZG9ieThT OFlmNzt2czF5QCVZUEE+VlNFJWw2aXs3VzFKSkEyeyMKSm4od2FNYGE0ZWwmaT89YQoKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWxpbnV4L2NvbXBvc2l0aW5nL3Jl cGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci1leHBlY3RlZC50eHQgYi9MYXlv dXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1saW51eC9jb21wb3NpdGluZy9yZXBhaW50L2JlY29t ZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXItZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQyYmU2 YmQ3OWQwZDYxODQxYjhmYTYxZjUyNmRkNzFkMGQ4MjRhOTYKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1saW51eC9jb21wb3NpdGluZy9yZXBhaW50L2Jl Y29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXItZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTcg QEAKK2xheWVyIGF0ICgwLDApIHNpemUgODAweDYwMAorICBSZW5kZXJWaWV3IGF0ICgwLDApIHNp emUgODAweDYwMAorbGF5ZXIgYXQgKDAsMCkgc2l6ZSA4MDB4NjAwCisgIFJlbmRlckJsb2NrIHtI VE1MfSBhdCAoMCwwKSBzaXplIDgwMHg2MDAKKyAgICBSZW5kZXJCb2R5IHtCT0RZfSBhdCAoOCw4 KSBzaXplIDc4NHg1ODQKKyAgICAgIFJlbmRlckJsb2NrIHtQfSBhdCAoMCwwKSBzaXplIDc4NHgy MAorICAgICAgICBSZW5kZXJJbmxpbmUge0F9IGF0ICgwLDApIHNpemUgMTQ2eDE5IFtjb2xvcj0j MDAwMEVFXQorICAgICAgICAgIFJlbmRlclRleHQgeyN0ZXh0fSBhdCAoMCwwKSBzaXplIDE0Nngx OQorICAgICAgICAgICAgdGV4dCBydW4gYXQgKDAsMCkgd2lkdGggMTQ2OiAicmRhcjovL3Byb2Js ZW0vNjk4MzIwNyIKKyAgICAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgxNDYsMCkgc2l6ZSAz NzR4MTkKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMTQ2LDApIHdpZHRoIDM3NDogIlNob3VsZCBu b3QgbGVhdmUgYmx1ZSBib3ggYmVoaW5kIGFmdGVyIG1vdmluZyB0byB0aGUgdG9wIHJpZ2h0LiIK K2xheWVyIGF0ICg4LDQ0KSBzaXplIDUwMngxMDIKKyAgUmVuZGVyQmxvY2sgKHJlbGF0aXZlIHBv c2l0aW9uZWQpIHtESVZ9IGF0ICgwLDM2KSBzaXplIDUwMngxMDIgW2JvcmRlcjogKDFweCBzb2xp ZCAjMDAwMDAwKV0KK2xheWVyIGF0ICgyNTksNDUpIHNpemUgMjUweDEwMAorICBSZW5kZXJCbG9j ayAocG9zaXRpb25lZCkge0RJVn0gYXQgKDI1MSwxKSBzaXplIDI1MHgxMDAgW2JnY29sb3I9IzAw MDBGRl0KK2xheWVyIGF0ICg5LDQ1KSBzaXplIDUweDUwCisgIFJlbmRlckJsb2NrIChwb3NpdGlv bmVkKSB7RElWfSBhdCAoMSwxKSBzaXplIDUweDUwIFtiZ2NvbG9yPSMwMDAwMDBdCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQg Yi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQKaW5k ZXggNmFlN2IyNTBmOTA4NzE0ODE2YWM2NDYzOTFkMDM3NWVjZDNlYTdjNi4uZTc1MWNhOTgzZGFk MjNmZjhiNjczYTIwZmU3ZmMwMTJjMzVhNWJiMCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxh dGZvcm0vY2hyb21pdW0vdGVzdF9leHBlY3RhdGlvbnMudHh0CisrKyBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL2Nocm9taXVtL3Rlc3RfZXhwZWN0YXRpb25zLnR4dApAQCAtOTk3LDYgKzk5Nyw5IEBA IEJVR0NSNjI0MzMgV0lOIDogZmFzdC9pbWFnZXMvZ2lmLWxvb3AtY291bnQuaHRtbCA9IElNQUdF CiAvLyBTVkcgVEVTVFMKIC8vIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKKy8vIE5lZWQgcmViYXNlbGluaW5nIGFmdGVy IGJ1ZyA2NDU5MQorQlVHV0s2NDU5MSA6IGNvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJs YXktY29tcG9zaXRlZC1sYXllci5odG1sID0gUEFTUyBGQUlMCisKIEJVR0NSODc2MyBNQUMgOiBz dmcvY3VzdG9tL3VzZS1vbi1nLWNvbnRhaW5pbmctZm9yZWlnbk9iamVjdC1hbmQtaW1hZ2Uuc3Zn ID0gSU1BR0UKIAogCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9lZmwvdGVzdF9l eHBlY3RhdGlvbnMudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZWZsL3Rlc3RfZXhwZWN0YXRp b25zLnR4dAppbmRleCA0ZDU0ZjlhNzE2ZmJkNWUyMDg1MDBhMWRmOTQyY2UyOTM0OTYxMWRiLi4z ZTVlYzI0MjQzYzg4YmRmODljMDhiZmM5N2E3NWFlOWVlYjljNjhmIDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9wbGF0Zm9ybS9lZmwvdGVzdF9leHBlY3RhdGlvbnMudHh0CisrKyBiL0xheW91dFRl c3RzL3BsYXRmb3JtL2VmbC90ZXN0X2V4cGVjdGF0aW9ucy50eHQKQEAgLTIsNiArMiw5IEBACiAv LwogLy8gU2VlIGh0dHA6Ly90cmFjLndlYmtpdC5vcmcvd2lraS9UZXN0RXhwZWN0YXRpb25zIGZv ciBtb3JlIGluZm9ybWF0aW9uIG9uIHRoaXMgZmlsZS4KIAorLy8gTmVlZCByZWJhc2VsaW5pbmcg YWZ0ZXIgYnVnIDY0NTkxCitCVUdXSzY0NTkxIDogY29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUt b3ZlcmxheS1jb21wb3NpdGVkLWxheWVyLmh0bWwgPSBQQVNTIEZBSUwKKwogLy8gTmVlZHMgRU5B QkxFX1NIQURPV19ET00KIEJVR1dLNzY0MzkgREVCVUcgOiBmYXN0L2RvbS9zaGFkb3cvY29udGVu dC1lbGVtZW50LWFwaS5odG1sID0gVEVYVAogQlVHV0s3NjQzOSBERUJVRyA6IGZhc3QvZG9tL3No YWRvdy9jb250ZW50LWVsZW1lbnQtb3V0c2lkZS1zaGFkb3cuaHRtbCA9IFRFWFQKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay90ZXN0X2V4cGVjdGF0aW9ucy50eHQgYi9MYXlv dXRUZXN0cy9wbGF0Zm9ybS9ndGsvdGVzdF9leHBlY3RhdGlvbnMudHh0CmluZGV4IDM0Y2NlZTQ5 NDc2Yzk2YzU3NzcyY2FjZTYzZDFhZjIwNzg4ZTJhNjguLjMwYzVmNmM5NDg2ODcwNjIxZDllOTEw ZjkyYWZkMjc4YThkZTE2MDQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2d0ay90 ZXN0X2V4cGVjdGF0aW9ucy50eHQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vZ3RrL3Rlc3Rf ZXhwZWN0YXRpb25zLnR4dApAQCAtMTEsNiArMTEsOSBAQCBCVUdXSzY4ODU5IERFQlVHIDogZmFz dC9keW5hbWljL2NyYXNoLXBhaW50LW5vLWRvY3VtZW50RWxlbWVudC1yZW5kZXJlci5odG1sID0g QwogCiBCVUdXSzc2ODE0IERFQlVHIDogZmFzdC94bWxodHRwcmVxdWVzdC94bWxodHRwcmVxdWVz dC1nZXQueGh0bWwgPSBDUkFTSAogCisvLyBOZWVkIHJlYmFzZWxpbmluZyBhZnRlciBidWcgNjQ1 OTEKK0JVR1dLNjQ1OTEgOiBjb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBv c2l0ZWQtbGF5ZXIuaHRtbCA9IFBBU1MgRkFJTAorCiAvLyBGbGFreSB0ZXN0cwogCiBCVUdXSzY4 ODc4IDogbWVkaWEvdmlkZW8tcGxheWluZy1hbmQtcGF1c2UuaHRtbCA9IFBBU1MgVEVYVApkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCBi L0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy90ZXN0X2V4cGVjdGF0aW9ucy50eHQKaW5kZXggMDIy MDJhMGZmNjYyMjcxZTRlNzQ1ZTM1ZDM3Nzk1ZTI3NTI4ZTZjZS4uNmZkNjZiYWViY2NlOGY0YWE5 ZmRlM2EyM2JlMDlhMDQzYjBmNGIxZiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0v bWFjL3Rlc3RfZXhwZWN0YXRpb25zLnR4dAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMv dGVzdF9leHBlY3RhdGlvbnMudHh0CkBAIC00NCw2ICs0NCw5IEBAIEJVR1dLNzM3NjYgOiBjc3Mz L3VuaWNvZGUtYmlkaS1pc29sYXRlLWFoYXJvbi1mYWlsaW5nLmh0bWwgPSBGQUlMCiAvLyBUaGUg dGVzdCBoaXRzIGFuIEFTU0VSVCBpbiBEZWJ1Zy4KIEJVR1dLNjg4NTkgREVCVUcgOiBmYXN0L2R5 bmFtaWMvY3Jhc2gtcGFpbnQtbm8tZG9jdW1lbnRFbGVtZW50LXJlbmRlcmVyLmh0bWwgPSBDUkFT SAogCisvLyBOZWVkIHJlYmFzZWxpbmluZyBhZnRlciBidWcgNjQ1OTEKK0JVR1dLNjQ1OTEgOiBj b21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIuaHRtbCA9 IFBBU1MgRkFJTAorCiAvLyBOZWVkIHJlYmFzZWxpbmluZyBhZnRlciA3MTI0NAogQlVHV0s3NDQz MiA6IGNzczIuMS8yMDExMDMyMy9ib3JkZXItY29uZmxpY3Qtc3R5bGUtMDc5Lmh0bSA9IElNQUdF CiBCVUdXSzc0NDMyIDogY3NzMi4xLzIwMTEwMzIzL2Zsb2F0aW5nLXJlcGxhY2VkLWhlaWdodC0w MDguaHRtID0gSU1BR0UKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0L3Rlc3Rf ZXhwZWN0YXRpb25zLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3F0L3Rlc3RfZXhwZWN0YXRp b25zLnR4dAppbmRleCBjNmFhMzM0ZDQzNThhNTAzYjMzYTFhNzZmZDdiNWQ1Mjg3YjAzNmE1Li5k YTIwNDU3OWM1MjM1Mzk3NDZlODc2ZDdkZmM3MGRlYWVjZmY3MmFlIDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy9wbGF0Zm9ybS9xdC90ZXN0X2V4cGVjdGF0aW9ucy50eHQKKysrIGIvTGF5b3V0VGVz dHMvcGxhdGZvcm0vcXQvdGVzdF9leHBlY3RhdGlvbnMudHh0CkBAIC0yNSw1ICsyNSw4IEBAIEJV R1dLNzQyNzAgOiBmYXN0L2Zvcm1zL2Jhc2ljLXNlbGVjdHMuaHRtbCA9IEZBSUwKIC8vIFRoZSB0 ZXN0IGhpdHMgYW4gQVNTRVJUIGluIERlYnVnLgogQlVHV0s2ODg1OSBERUJVRyA6IGZhc3QvZHlu YW1pYy9jcmFzaC1wYWludC1uby1kb2N1bWVudEVsZW1lbnQtcmVuZGVyZXIuaHRtbCA9IENSQVNI CiAKKy8vIE5lZWQgcmViYXNlbGluaW5nIGFmdGVyIGJ1ZyA2NDU5MQorQlVHV0s2NDU5MSA6IGNv bXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci5odG1sID0g UEFTUyBGQUlMCisKIC8vIE5lZWRzIGJhc2VsaW5lCiBCVUdXSzc2MTE4IDogZmFzdC9jc3MvdGV4 dC1vdmVyZmxvdy1pbnB1dC5odG1sID0gTUlTU0lORwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv cGxhdGZvcm0vd2luL3Rlc3RfZXhwZWN0YXRpb25zLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3Jt L3dpbi90ZXN0X2V4cGVjdGF0aW9ucy50eHQKaW5kZXggNGY3NzNjNDVlNTM0Y2I4NGRkZjFlZjdh ZjAxMGY4N2JmM2Y0MzFlZi4uZTM0MGQ2YzQ0YzRhMmFjMzU1OTdlMzk5MmRjYTQ2MzgyMGNhYzJh MiAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vd2luL3Rlc3RfZXhwZWN0YXRpb25z LnR4dAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vdGVzdF9leHBlY3RhdGlvbnMudHh0 CkBAIC0yMCw2ICsyMCw5IEBAIEJVR1dLNzQyNzAgOiBmYXN0L2Zvcm1zL2Jhc2ljLXNlbGVjdHMu aHRtbCA9IEZBSUwKIC8vIFRoZSB0ZXN0IGhpdHMgYW4gQVNTRVJUIGluIERlYnVnLgogQlVHV0s2 ODg1OSBERUJVRyA6IGZhc3QvZHluYW1pYy9jcmFzaC1wYWludC1uby1kb2N1bWVudEVsZW1lbnQt cmVuZGVyZXIuaHRtbCA9IENSQVNICiAKKy8vIE5lZWQgcmViYXNlbGluaW5nIGFmdGVyIGJ1ZyA2 NDU5MQorQlVHV0s2NDU5MSA6IGNvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJsYXktY29t cG9zaXRlZC1sYXllci5odG1sID0gUEFTUyBGQUlMCisKIC8vIE5ldyB0ZXN0LCBuZWVkcyBpbWFn ZSByZXN1bHRzIGFkZGVkLgogQlVHV0s3NTU3MCA6IGh0dHAvdGVzdHMvbWVkaWEvdmlkZW8tYnVm ZmVyaW5nLXJlcGFpbnRzLWNvbnRyb2xzLmh0bWwgPSBJTUFHRQogCg== 126559 2012-02-10 12:41:32 -0800 2012-02-13 08:39:53 -0800 Removing non-chromium test-expectations changes. bug-64591-20120210154131.patch text/plain 28114 jgw U3VidmVyc2lvbiBSZXZpc2lvbjogMTA3NDI1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMThlYTkzNWI4NzQ0MzIw YzQ2YTIxMzA0NjFiMDE1NDAxNTZiMzRhMC4uNDQ3YjNmYjk5MTUyMDBjYzBlNDYzZDliZjg4ZTFm YTc4YTNkYzdkYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDEyLTAyLTEwICBKb2Vs IFdlYmJlciAgPGpnd0Bnb29nbGUuY29tPgorCisgICAgICAgIFVzZSByZXF1ZXN0QW5pbWF0aW9u RnJhbWUgY2FsbGJhY2tzIHRvIHB1bXAgQ1NTIGFuaW1hdGlvbnMKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTY0NTkxCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgSmFtZXMgUm9iaW5zb24uCisKKyAgICAgICAgTm8gbmV3IHRlc3RzIG5lZWRlZCAoY292ZXJl ZCBieSB0ZXN0cyBpbiBhbmltYXRpb25zLyopLgorCisgICAgICAgICogcGFnZS9GcmFtZVZpZXcu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVWaWV3OjpzZXJ2aWNlU2NyaXB0ZWRBbmltYXRp b25zKToKKyAgICAgICAgKiBwYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmlt YXRpb25zKToKKyAgICAgICAgKFdlYkNvcmU6OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1 cGRhdGVBbmltYXRpb25UaW1lcik6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250cm9s bGVyUHJpdmF0ZTo6ZmlyZUV2ZW50c0FuZFVwZGF0ZVN0eWxlKToKKyAgICAgICAgKFdlYkNvcmU6 OkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjphbmltYXRpb25GcmFtZUNhbGxiYWNrRmlyZWQp OgorICAgICAgICAoV2ViQ29yZTo6QW5pbWF0aW9uQ29udHJvbGxlcjo6dXBkYXRlQW5pbWF0aW9u cyk6CisgICAgICAgIChXZWJDb3JlOjpBbmltYXRpb25Db250cm9sbGVyOjpzZXJ2aWNlQW5pbWF0 aW9ucyk6CisgICAgICAgICogcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5oOgor ICAgICAgICAqIHBhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmg6CisK IDIwMTItMDItMTAgIEFuZGVycyBDYXJsc3NvbiAgPGFuZGVyc2NhQGFwcGxlLmNvbT4KIAogICAg ICAgICBVcGRhdGUgdGhlIG5vbi1mYXN0LXNjcm9sbGFibGUgcmVnaW9uIGZvciBzdWJmcmFtZSBs YXlvdXQgYXMgd2VsbApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcu Y3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IGMwYjg1ODcxZmZl MDJjODgzZGJlODIzYjBlMzU2OWY3NjZiZWZiMDYuLmZiMGI1NjY5YTU2ZWZkODE0ZTY3ZjBhZTc5 ZGY3Y2I2MjM5OGRlMGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTIwOTksOCAr MjA5OSwxMSBAQCB2b2lkIEZyYW1lVmlldzo6dW5zY2hlZHVsZVJlbGF5b3V0KCkKICNpZiBFTkFC TEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCiB2b2lkIEZyYW1lVmlldzo6c2VydmljZVNjcmlw dGVkQW5pbWF0aW9ucyhET01UaW1lU3RhbXAgdGltZSkKIHsKLSAgICBWZWN0b3I8UmVmUHRyPERv Y3VtZW50PiA+IGRvY3VtZW50czsKKyAgICBWZWN0b3I8QW5pbWF0aW9uQ29udHJvbGxlcio+IGFu aW1hdGlvbnM7CisgICAgZm9yIChGcmFtZSogZnJhbWUgPSBtX2ZyYW1lLmdldCgpOyBmcmFtZTsg ZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50cmF2ZXJzZU5leHQoKSkKKyAgICAgICAgZnJhbWUtPmFu aW1hdGlvbigpLT5zZXJ2aWNlQW5pbWF0aW9ucygpOwogCisgICAgVmVjdG9yPFJlZlB0cjxEb2N1 bWVudD4gPiBkb2N1bWVudHM7CiAgICAgZm9yIChGcmFtZSogZnJhbWUgPSBtX2ZyYW1lLmdldCgp OyBmcmFtZTsgZnJhbWUgPSBmcmFtZS0+dHJlZSgpLT50cmF2ZXJzZU5leHQoKSkKICAgICAgICAg ZG9jdW1lbnRzLmFwcGVuZChmcmFtZS0+ZG9jdW1lbnQoKSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuY3BwIGIvU291cmNl L1dlYkNvcmUvcGFnZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5jcHAKaW5kZXggNzQ1 ZDUxNDZiOTE4ZWQwNTBmNzhmMWI0MmEyOTJiNWExZmE0ZGFhMC4uODEyZDE4ZDg2OTA4ZGM2NmUx MDAyMmU2MGQyYmU5MGYzMmVhZmVkNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9h bmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFn ZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5jcHAKQEAgLTM1LDYgKzM1LDcgQEAKICNp bmNsdWRlICJDb21wb3NpdGVBbmltYXRpb24uaCIKICNpbmNsdWRlICJFdmVudE5hbWVzLmgiCiAj aW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJSZW5k ZXJWaWV3LmgiCiAjaW5jbHVkZSAiV2ViS2l0QW5pbWF0aW9uRXZlbnQuaCIKICNpbmNsdWRlICJX ZWJLaXRBbmltYXRpb25MaXN0LmgiCkBAIC00NCw3ICs0NSw2IEBACiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKIAotLy8gRklYTUU6IFdoeSBpc24ndCB0aGlzIHNldCB0byA2MGZwcyBvciBzb21ldGhp bmc/CiBzdGF0aWMgY29uc3QgZG91YmxlIGNBbmltYXRpb25UaW1lckRlbGF5ID0gMC4wMjU7CiBz dGF0aWMgY29uc3QgZG91YmxlIGNCZWdpbkFuaW1hdGlvblVwZGF0ZVRpbWVOb3RTZXQgPSAtMTsK IApAQCAtODQsOSArODQsOSBAQCBib29sIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjpjbGVh cihSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogICAgIHJldHVybiBhbmltYXRpb24tPnN1c3BlbmRl ZCgpOwogfQogCi12b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmltYXRp b25UaW1lcihib29sIGNhbGxTZXRDaGFuZ2VkLyogPSBmYWxzZSovKQorZG91YmxlIEFuaW1hdGlv bkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmltYXRpb25zKFNldENoYW5nZWQgY2FsbFNldENo YW5nZWQvKiA9IERvTm90Q2FsbFNldENoYW5nZWQqLykKIHsKLSAgICBkb3VibGUgbmVlZHNTZXJ2 aWNlID0gLTE7CisgICAgZG91YmxlIHRpbWVUb05leHRTZXJ2aWNlID0gLTE7CiAgICAgYm9vbCBj YWxsZWRTZXRDaGFuZ2VkID0gZmFsc2U7CiAKICAgICBSZW5kZXJPYmplY3RBbmltYXRpb25NYXA6 OmNvbnN0X2l0ZXJhdG9yIGFuaW1hdGlvbnNFbmQgPSBtX2NvbXBvc2l0ZUFuaW1hdGlvbnMuZW5k KCk7CkBAIC05NCwxMCArOTQsMTAgQEAgdm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6 dXBkYXRlQW5pbWF0aW9uVGltZXIoYm9vbCBjYWxsU2V0Q2hhbmdlZC8qID0gZmEKICAgICAgICAg Q29tcG9zaXRlQW5pbWF0aW9uKiBjb21wQW5pbSA9IGl0LT5zZWNvbmQuZ2V0KCk7CiAgICAgICAg IGlmICghY29tcEFuaW0tPnN1c3BlbmRlZCgpICYmIGNvbXBBbmltLT5oYXNBbmltYXRpb25zKCkp IHsKICAgICAgICAgICAgIGRvdWJsZSB0ID0gY29tcEFuaW0tPnRpbWVUb05leHRTZXJ2aWNlKCk7 Ci0gICAgICAgICAgICBpZiAodCAhPSAtMSAmJiAodCA8IG5lZWRzU2VydmljZSB8fCBuZWVkc1Nl cnZpY2UgPT0gLTEpKQotICAgICAgICAgICAgICAgIG5lZWRzU2VydmljZSA9IHQ7Ci0gICAgICAg ICAgICBpZiAobmVlZHNTZXJ2aWNlID09IDApIHsKLSAgICAgICAgICAgICAgICBpZiAoY2FsbFNl dENoYW5nZWQpIHsKKyAgICAgICAgICAgIGlmICh0ICE9IC0xICYmICh0IDwgdGltZVRvTmV4dFNl cnZpY2UgfHwgdGltZVRvTmV4dFNlcnZpY2UgPT0gLTEpKQorICAgICAgICAgICAgICAgIHRpbWVU b05leHRTZXJ2aWNlID0gdDsKKyAgICAgICAgICAgIGlmICghdGltZVRvTmV4dFNlcnZpY2UpIHsK KyAgICAgICAgICAgICAgICBpZiAoY2FsbFNldENoYW5nZWQgPT0gQ2FsbFNldENoYW5nZWQpIHsK ICAgICAgICAgICAgICAgICAgICAgTm9kZSogbm9kZSA9IGl0LT5maXJzdC0+bm9kZSgpOwogICAg ICAgICAgICAgICAgICAgICBBU1NFUlQoIW5vZGUgfHwgKG5vZGUtPmRvY3VtZW50KCkgJiYgIW5v ZGUtPmRvY3VtZW50KCktPmluUGFnZUNhY2hlKCkpKTsKICAgICAgICAgICAgICAgICAgICAgbm9k ZS0+c2V0TmVlZHNTdHlsZVJlY2FsYyhTeW50aGV0aWNTdHlsZUNoYW5nZSk7CkBAIC0xMDgsMjgg KzEwOCwzNSBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjp1cGRhdGVBbmltYXRp b25UaW1lcihib29sIGNhbGxTZXRDaGFuZ2VkLyogPSBmYQogICAgICAgICAgICAgfQogICAgICAg ICB9CiAgICAgfQotICAgIAorCiAgICAgaWYgKGNhbGxlZFNldENoYW5nZWQpCiAgICAgICAgIG1f ZnJhbWUtPmRvY3VtZW50KCktPnVwZGF0ZVN0eWxlSWZOZWVkZWQoKTsKLSAgICAKKworICAgIHJl dHVybiB0aW1lVG9OZXh0U2VydmljZTsKK30KKwordm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJp dmF0ZTo6dXBkYXRlQW5pbWF0aW9uVGltZXIoU2V0Q2hhbmdlZCBjYWxsU2V0Q2hhbmdlZC8qID0g RG9Ob3RDYWxsU2V0Q2hhbmdlZCovKQoreworICAgIGRvdWJsZSB0aW1lVG9OZXh0U2VydmljZSA9 IHVwZGF0ZUFuaW1hdGlvbnMoY2FsbFNldENoYW5nZWQpOworCiAgICAgLy8gSWYgd2Ugd2FudCBz ZXJ2aWNlIGltbWVkaWF0ZWx5LCB3ZSBzdGFydCBhIHJlcGVhdGluZyB0aW1lciB0byByZWR1Y2Ug dGhlIG92ZXJoZWFkIG9mIHN0YXJ0aW5nCi0gICAgaWYgKG5lZWRzU2VydmljZSA9PSAwKSB7Cisg ICAgaWYgKCF0aW1lVG9OZXh0U2VydmljZSkgewogICAgICAgICBpZiAoIW1fYW5pbWF0aW9uVGlt ZXIuaXNBY3RpdmUoKSB8fCBtX2FuaW1hdGlvblRpbWVyLnJlcGVhdEludGVydmFsKCkgPT0gMCkK ICAgICAgICAgICAgIG1fYW5pbWF0aW9uVGltZXIuc3RhcnRSZXBlYXRpbmcoY0FuaW1hdGlvblRp bWVyRGVsYXkpOwogICAgICAgICByZXR1cm47CiAgICAgfQotICAgIAorCiAgICAgLy8gSWYgd2Ug ZG9uJ3QgbmVlZCBzZXJ2aWNlLCB3ZSB3YW50IHRvIG1ha2Ugc3VyZSB0aGUgdGltZXIgaXMgbm8g bG9uZ2VyIHJ1bm5pbmcKLSAgICBpZiAobmVlZHNTZXJ2aWNlIDwgMCkgeworICAgIGlmICh0aW1l VG9OZXh0U2VydmljZSA8IDApIHsKICAgICAgICAgaWYgKG1fYW5pbWF0aW9uVGltZXIuaXNBY3Rp dmUoKSkKICAgICAgICAgICAgIG1fYW5pbWF0aW9uVGltZXIuc3RvcCgpOwogICAgICAgICByZXR1 cm47CiAgICAgfQotICAgIAorCiAgICAgLy8gT3RoZXJ3aXNlLCB3ZSB3YW50IHRvIHN0YXJ0IGEg b25lLXNob3QgdGltZXIgc28gd2UgZ2V0IGhlcmUgYWdhaW4KICAgICBpZiAobV9hbmltYXRpb25U aW1lci5pc0FjdGl2ZSgpKQogICAgICAgICBtX2FuaW1hdGlvblRpbWVyLnN0b3AoKTsKLSAgICBt X2FuaW1hdGlvblRpbWVyLnN0YXJ0T25lU2hvdChuZWVkc1NlcnZpY2UpOworICAgIG1fYW5pbWF0 aW9uVGltZXIuc3RhcnRPbmVTaG90KHRpbWVUb05leHRTZXJ2aWNlKTsKIH0KIAogdm9pZCBBbmlt YXRpb25Db250cm9sbGVyUHJpdmF0ZTo6dXBkYXRlU3R5bGVJZk5lZWRlZERpc3BhdGNoZXJGaXJl ZChUaW1lcjxBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZT4qKQpAQCAtMTQzLDcgKzE1MCw3IEBA IHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmZpcmVFdmVudHNBbmRVcGRhdGVTdHls ZSgpCiAgICAgUmVmUHRyPEZyYW1lPiBwcm90ZWN0b3IgPSBtX2ZyYW1lOwogCiAgICAgYm9vbCB1 cGRhdGVTdHlsZSA9ICFtX2V2ZW50c1RvRGlzcGF0Y2guaXNFbXB0eSgpIHx8ICFtX25vZGVDaGFu Z2VzVG9EaXNwYXRjaC5pc0VtcHR5KCk7Ci0gICAgCisKICAgICAvLyBmaXJlIGFsbCB0aGUgZXZl bnRzCiAgICAgVmVjdG9yPEV2ZW50VG9EaXNwYXRjaD4gZXZlbnRzVG9EaXNwYXRjaCA9IG1fZXZl bnRzVG9EaXNwYXRjaDsKICAgICBtX2V2ZW50c1RvRGlzcGF0Y2guY2xlYXIoKTsKQEAgLTE1NCwx NCArMTYxLDE0IEBAIHZvaWQgQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGU6OmZpcmVFdmVudHNB bmRVcGRhdGVTdHlsZSgpCiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIGl0LT5lbGVtZW50LT5k aXNwYXRjaEV2ZW50KFdlYktpdEFuaW1hdGlvbkV2ZW50OjpjcmVhdGUoaXQtPmV2ZW50VHlwZSwg aXQtPm5hbWUsIGl0LT5lbGFwc2VkVGltZSkpOwogICAgIH0KLSAgICAKKwogICAgIC8vIGNhbGwg c2V0Q2hhbmdlZCBvbiBhbGwgdGhlIGVsZW1lbnRzCiAgICAgVmVjdG9yPFJlZlB0cjxOb2RlPiA+ Ojpjb25zdF9pdGVyYXRvciBub2RlQ2hhbmdlc1RvRGlzcGF0Y2hFbmQgPSBtX25vZGVDaGFuZ2Vz VG9EaXNwYXRjaC5lbmQoKTsKICAgICBmb3IgKFZlY3RvcjxSZWZQdHI8Tm9kZT4gPjo6Y29uc3Rf aXRlcmF0b3IgaXQgPSBtX25vZGVDaGFuZ2VzVG9EaXNwYXRjaC5iZWdpbigpOyBpdCAhPSBub2Rl Q2hhbmdlc1RvRGlzcGF0Y2hFbmQ7ICsraXQpCiAgICAgICAgICgqaXQpLT5zZXROZWVkc1N0eWxl UmVjYWxjKFN5bnRoZXRpY1N0eWxlQ2hhbmdlKTsKLSAgICAKKwogICAgIG1fbm9kZUNoYW5nZXNU b0Rpc3BhdGNoLmNsZWFyKCk7Ci0gICAgCisKICAgICBpZiAodXBkYXRlU3R5bGUgJiYgbV9mcmFt ZSkKICAgICAgICAgbV9mcmFtZS0+ZG9jdW1lbnQoKS0+dXBkYXRlU3R5bGVJZk5lZWRlZCgpOwog fQpAQCAtMTk0LDYgKzIwMSwxNiBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlOjph ZGROb2RlQ2hhbmdlVG9EaXNwYXRjaChQYXNzUmVmUHRyPE5vZGU+IG5vZGUpCiAgICAgc3RhcnRV cGRhdGVTdHlsZUlmTmVlZGVkRGlzcGF0Y2hlcigpOwogfQogCisjaWYgRU5BQkxFKFJFUVVFU1Rf QU5JTUFUSU9OX0ZSQU1FKQordm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6YW5pbWF0 aW9uRnJhbWVDYWxsYmFja0ZpcmVkKCkKK3sKKyAgICBkb3VibGUgdGltZVRvTmV4dFNlcnZpY2Ug PSB1cGRhdGVBbmltYXRpb25zKENhbGxTZXRDaGFuZ2VkKTsKKworICAgIGlmICh0aW1lVG9OZXh0 U2VydmljZSA+PSAwKQorICAgICAgICBtX2ZyYW1lLT5kb2N1bWVudCgpLT52aWV3KCktPnNjaGVk dWxlQW5pbWF0aW9uKCk7Cit9CisjZW5kaWYKKwogdm9pZCBBbmltYXRpb25Db250cm9sbGVyUHJp dmF0ZTo6YW5pbWF0aW9uVGltZXJGaXJlZChUaW1lcjxBbmltYXRpb25Db250cm9sbGVyUHJpdmF0 ZT4qKQogewogICAgIC8vIE1ha2Ugc3VyZSBhbmltYXRpb25VcGRhdGVUaW1lIGlzIHVwZGF0ZWQs IHNvIHRoYXQgaXQgaXMgY3VycmVudCBldmVuIGlmIG5vCkBAIC0yMDIsNyArMjE5LDcgQEAgdm9p ZCBBbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZTo6YW5pbWF0aW9uVGltZXJGaXJlZChUaW1lcjxB bmltYXRpb25Db250cm9sbGVyUHIKIAogICAgIC8vIFdoZW4gdGhlIHRpbWVyIGZpcmVzLCBhbGwg d2UgZG8gaXMgY2FsbCBzZXRDaGFuZ2VkIG9uIGFsbCBET00gbm9kZXMgd2l0aCBydW5uaW5nIGFu aW1hdGlvbnMgYW5kIHRoZW4gZG8gYW4gaW1tZWRpYXRlCiAgICAgLy8gdXBkYXRlU3R5bGVJZk5l ZWRlZC4gIEl0IHdpbGwgdGhlbiBjYWxsIGJhY2sgdG8gdXMgd2l0aCBuZXcgaW5mb3JtYXRpb24u Ci0gICAgdXBkYXRlQW5pbWF0aW9uVGltZXIodHJ1ZSk7CisgICAgdXBkYXRlQW5pbWF0aW9uVGlt ZXIoQ2FsbFNldENoYW5nZWQpOwogCiAgICAgLy8gRmlyZSBldmVudHMgcmlnaHQgYXdheSwgdG8g YXZvaWQgYSBmbGFzaCBvZiB1bmFuaW1hdGVkIHN0eWxlIGFmdGVyIGFuIGFuaW1hdGlvbiBjb21w bGV0ZXMsIGFuZCBiZWZvcmUKICAgICAvLyB0aGUgJ2VuZCcgZXZlbnQgZmlyZXMuCkBAIC00OTks OCArNTE2LDEzIEBAIFBhc3NSZWZQdHI8UmVuZGVyU3R5bGU+IEFuaW1hdGlvbkNvbnRyb2xsZXI6 OnVwZGF0ZUFuaW1hdGlvbnMoUmVuZGVyT2JqZWN0KiByZW5kCiAgICAgUmVmUHRyPENvbXBvc2l0 ZUFuaW1hdGlvbj4gcmVuZGVyZXJBbmltYXRpb25zID0gbV9kYXRhLT5hY2Nlc3NDb21wb3NpdGVB bmltYXRpb24ocmVuZGVyZXIpOwogICAgIFJlZlB0cjxSZW5kZXJTdHlsZT4gYmxlbmRlZFN0eWxl ID0gcmVuZGVyZXJBbmltYXRpb25zLT5hbmltYXRlKHJlbmRlcmVyLCBvbGRTdHlsZSwgbmV3U3R5 bGUpOwogCi0gICAgaWYgKHJlbmRlcmVyLT5wYXJlbnQoKSB8fCBuZXdTdHlsZS0+YW5pbWF0aW9u cygpIHx8IChvbGRTdHlsZSAmJiBvbGRTdHlsZS0+YW5pbWF0aW9ucygpKSkKKyAgICBpZiAocmVu ZGVyZXItPnBhcmVudCgpIHx8IG5ld1N0eWxlLT5hbmltYXRpb25zKCkgfHwgKG9sZFN0eWxlICYm IG9sZFN0eWxlLT5hbmltYXRpb25zKCkpKSB7CiAgICAgICAgIG1fZGF0YS0+dXBkYXRlQW5pbWF0 aW9uVGltZXIoKTsKKyNpZiBFTkFCTEUoUkVRVUVTVF9BTklNQVRJT05fRlJBTUUpCisgICAgICAg IGlmIChGcmFtZVZpZXcqIHZpZXcgPSByZW5kZXJlci0+ZG9jdW1lbnQoKS0+dmlldygpKQorICAg ICAgICAgICAgdmlldy0+c2NoZWR1bGVBbmltYXRpb24oKTsKKyNlbmRpZgorICAgIH0KIAogICAg IGlmIChibGVuZGVkU3R5bGUgIT0gbmV3U3R5bGUpIHsKICAgICAgICAgLy8gSWYgdGhlIGFuaW1h dGlvbnMvdHJhbnNpdGlvbnMgY2hhbmdlIG9wYWNpdHkgb3IgdHJhbnNmb3JtLCB3ZSBuZWVkIHRv IHVwZGF0ZQpAQCAtNTU3LDYgKzU3OSwxMyBAQCB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXI6OnJl c3VtZUFuaW1hdGlvbnMoKQogICAgIG1fZGF0YS0+cmVzdW1lQW5pbWF0aW9ucygpOwogfQogCisj aWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQordm9pZCBBbmltYXRpb25Db250cm9s bGVyOjpzZXJ2aWNlQW5pbWF0aW9ucygpCit7CisgICAgbV9kYXRhLT5hbmltYXRpb25GcmFtZUNh bGxiYWNrRmlyZWQoKTsKK30KKyNlbmRpZgorCiB2b2lkIEFuaW1hdGlvbkNvbnRyb2xsZXI6OnN1 c3BlbmRBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1lbnQqIGRvY3VtZW50KQogewogICAgIG1f ZGF0YS0+c3VzcGVuZEFuaW1hdGlvbnNGb3JEb2N1bWVudChkb2N1bWVudCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmggYi9T b3VyY2UvV2ViQ29yZS9wYWdlL2FuaW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyLmgKaW5kZXgg Y2NkYzZjNGE0MmQ3YTFiMzUwMmQ3NzA3ODA3MDE2Njk1ZTM2NGI0OC4uMTg3NzJkZDU5Mzk0YWI4 MDQ2MGZkOTY1NGRmNGY3OWQ1NmViZWFlZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFn ZS9hbmltYXRpb24vQW5pbWF0aW9uQ29udHJvbGxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvYW5pbWF0aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXIuaApAQCAtNjYsNiArNjYsOSBAQCBwdWJs aWM6CiAKICAgICB2b2lkIHN1c3BlbmRBbmltYXRpb25zKCk7CiAgICAgdm9pZCByZXN1bWVBbmlt YXRpb25zKCk7CisjaWYgRU5BQkxFKFJFUVVFU1RfQU5JTUFUSU9OX0ZSQU1FKQorICAgIHZvaWQg c2VydmljZUFuaW1hdGlvbnMoKTsKKyNlbmRpZgogCiAgICAgdm9pZCBzdXNwZW5kQW5pbWF0aW9u c0ZvckRvY3VtZW50KERvY3VtZW50Kik7CiAgICAgdm9pZCByZXN1bWVBbmltYXRpb25zRm9yRG9j dW1lbnQoRG9jdW1lbnQqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0 aW9uL0FuaW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL2Fu aW1hdGlvbi9BbmltYXRpb25Db250cm9sbGVyUHJpdmF0ZS5oCmluZGV4IDQxZWViZmYxNmRmNWM5 M2QyYWNmYTg1YmU0OTkxN2ExZDQ4ZmUwOGUuLjJjMjA1MWVmZjYwYjkzYzEyNGI3MDA3YmZlNjRi N2IyYTE0YThjOTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvYW5pbWF0aW9uL0Fu aW1hdGlvbkNvbnRyb2xsZXJQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9hbmlt YXRpb24vQW5pbWF0aW9uQ29udHJvbGxlclByaXZhdGUuaApAQCAtNTEsMTMgKzUxLDIwIEBAIGNs YXNzIFJlbmRlck9iamVjdDsKIGNsYXNzIFJlbmRlclN0eWxlOwogY2xhc3MgV2ViS2l0QW5pbWF0 aW9uTGlzdDsKIAorZW51bSBTZXRDaGFuZ2VkIHsKKyAgICBEb05vdENhbGxTZXRDaGFuZ2VkID0g MCwKKyAgICBDYWxsU2V0Q2hhbmdlZCA9IDEKK307CisKIGNsYXNzIEFuaW1hdGlvbkNvbnRyb2xs ZXJQcml2YXRlIHsKICAgICBXVEZfTUFLRV9OT05DT1BZQUJMRShBbmltYXRpb25Db250cm9sbGVy UHJpdmF0ZSk7IFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOwogcHVibGljOgogICAgIEFuaW1hdGlv bkNvbnRyb2xsZXJQcml2YXRlKEZyYW1lKik7CiAgICAgfkFuaW1hdGlvbkNvbnRyb2xsZXJQcml2 YXRlKCk7CiAKLSAgICB2b2lkIHVwZGF0ZUFuaW1hdGlvblRpbWVyKGJvb2wgY2FsbFNldENoYW5n ZWQgPSBmYWxzZSk7CisgICAgLy8gUmV0dXJucyB0aGUgdGltZSB1bnRpbCB0aGUgbmV4dCBhbmlt YXRpb24gbmVlZHMgdG8gYmUgc2VydmljZWQsIG9yIC0xIGlmIHRoZXJlIGFyZSBub25lLgorICAg IGRvdWJsZSB1cGRhdGVBbmltYXRpb25zKFNldENoYW5nZWQgY2FsbFNldENoYW5nZWQgPSBEb05v dENhbGxTZXRDaGFuZ2VkKTsKKyAgICB2b2lkIHVwZGF0ZUFuaW1hdGlvblRpbWVyKFNldENoYW5n ZWQgY2FsbFNldENoYW5nZWQgPSBEb05vdENhbGxTZXRDaGFuZ2VkKTsKIAogICAgIFBhc3NSZWZQ dHI8Q29tcG9zaXRlQW5pbWF0aW9uPiBhY2Nlc3NDb21wb3NpdGVBbmltYXRpb24oUmVuZGVyT2Jq ZWN0Kik7CiAgICAgYm9vbCBjbGVhcihSZW5kZXJPYmplY3QqKTsKQEAgLTcxLDYgKzc4LDkgQEAg cHVibGljOgogCiAgICAgdm9pZCBzdXNwZW5kQW5pbWF0aW9ucygpOwogICAgIHZvaWQgcmVzdW1l QW5pbWF0aW9ucygpOworI2lmIEVOQUJMRShSRVFVRVNUX0FOSU1BVElPTl9GUkFNRSkKKyAgICB2 b2lkIGFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tGaXJlZCgpOworI2VuZGlmCiAKICAgICB2b2lkIHN1 c3BlbmRBbmltYXRpb25zRm9yRG9jdW1lbnQoRG9jdW1lbnQqKTsKICAgICB2b2lkIHJlc3VtZUFu aW1hdGlvbnNGb3JEb2N1bWVudChEb2N1bWVudCopOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv Y29tcG9zaXRpbmcvcmVwYWludC9iZWNvbWUtb3ZlcmxheS1jb21wb3NpdGVkLWxheWVyLmh0bWwg Yi9MYXlvdXRUZXN0cy9jb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0 ZWQtbGF5ZXIuaHRtbAppbmRleCBkNTExMDZmYzMzYjRiZjc2ZTg2YTcyMTFmZjVhOGEzN2IxM2Qw YTU2Li5jYWY3MzA5YmYwZWViZDBiMDA5YTE2ZTNjOWNiNzRhMjMzMWYxZjAyIDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9jb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVybGF5LWNvbXBvc2l0 ZWQtbGF5ZXIuaHRtbAorKysgYi9MYXlvdXRUZXN0cy9jb21wb3NpdGluZy9yZXBhaW50L2JlY29t ZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXIuaHRtbApAQCAtNTEsOCArNTEsMTAgQEAKICAgICAg ICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImNvbnRhaW5lciIpLmNsYXNzTmFtZSA9ICJyaWdo dCI7CiAgICAgICAgIHdpbmRvdy5zZXRUaW1lb3V0KGZ1bmN0aW9uKCkgewogICAgICAgICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJjb250YWluZXIiKS5jbGFzc05hbWUgPSAiIjsKLSAgICAg ICAgICBpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQotICAgICAgICAgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAgICAgICAgIHdpbmRvdy5zZXRUaW1lb3V0 KGZ1bmN0aW9uKCkgeworICAgICAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxl cikKKyAgICAgICAgICAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIubm90aWZ5RG9uZSgpOworICAg ICAgICAgIH0sIDI1MCk7CiAgICAgICAgIH0sIDI1MCk7CiAgICAgICB9CiAKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWxpbnV4L2NvbXBvc2l0aW5nL3JlcGFpbnQv YmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci1leHBlY3RlZC5wbmcgYi9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9jaHJvbWl1bS1saW51eC9jb21wb3NpdGluZy9yZXBhaW50L2JlY29tZS1vdmVy bGF5LWNvbXBvc2l0ZWQtbGF5ZXItZXhwZWN0ZWQucG5nCmluZGV4IGE3Y2RlY2MxNzZkNTdhZjU4 ZmQzOWUzNzNlMDE5NzQyYjU4NjAwYjUuLjY0ZmFhOTY2MDA0MDIyNmExMzdhNzMwMTllZDlmZjhj NjRkOGVjOWYgMTAwNjQ0CkdJVCBiaW5hcnkgcGF0Y2gKbGl0ZXJhbCA3OTkwCnpjbWVJMVg7X29q dyNRUiNpeGJqYkRfbGowUipyfj5BZnRAWVFsKnEzRGdzSj9mSnxaLVdROyV7PHYzNzlQPWtPPgp6 JHdkV1o0MDh3fTMxWFFBNGc/WklORnJsfEtvfk1XJGFHKU56NHo7ViZnWShmJUpjM2cmenJzMWBt Z28tdWJvR2kKei1KUjY7OU5xJjBmeitMVWBTfmdjd0RUd2t3QiExJjlsKi1MOX1lbVI5fHJMa3Vn M0A3M0pGNVFCfTlWRTFBX3VCCnolJmFVZSZXMmhDbndwcGZuY2g1bSZneTF9Tnl5cFk1VVpQKFpN Y2BgS19KfmU9YnRaSnlJWmAlaihwfVJQVkhSWgp6YEQwaHQ7bWhhMFl5S1g1XnooMXVVM2l4PHA4 Zm9naV5xUz0yNEN0QXdzOX1kWCgmJXhEOztnbjJ7SjJyOFNnckoKekd8UEZeYj9NVTh6YUBWQyp5 MiZRK0swWEMkND4xcyohQjIlRm1ZNFJJNl5gfjtaeVVtV2EjTlpYcUhITCRwNlQmCnp7VSV6O0Re NVhEciY1ckleMik8XmZYKXxCZ0dGRDFLLXJjJV9KV1NTP0Ehc2BiKXBed2B1cHpGcHgqLWl6YWA1 Kgp6SSgtT3IkZXQmOHJSK18jaWFAPX45aCpOXlpCY04lQW92UCVBMisjTE1aLWxFb2paJkNhRipG c1h6b1Q0KlZhOGMKejVhJkBvQyFrVSorQ3Q5Y3BNbFpTPG09M2FwZUFwPjNIcEBYOHJuZjMobkhH I0l0TmI3VUNKNnJuPmlwT002RFJ0CnpRSSpALUZ8KUI/I2pRYyh2ezclSGo5JjFuP2ZpP1dAayhM fkI0c2JhR0lCfVZALSQybSMtKmhEaTZvTT02JElSTgp6YHU+NWFfUWk1PGN4dUFPYGFvdyk0VTc9 Z15XPjBJPzVXI1hjamtfUjEtZXs8aj9WUGdUfEQmbG8lRzRBbk1+c30KejwzdDlGbHxwbH5hKGlo SyptWnhtWVF0RCUrTHVDUmUyY0RjOzFEdGRNPD1XYCY9RFJGVU9VPDc8Pi1neT0kU1JrCno+YUxI OXQ8V0BvcUZ0fikmTnRQUlI8NTNreG1hY3Y1aGNKYDtwZDZHP2NAfWlLIztDMz14N3FVejtCUHRa Xk0lLQp6cXFqdjw5I0Y5KzlsYztDXlI4US1xKFgqKngyWVNzbDBvQldxWitFMW8oLUpNIyU5ZDVU czNUSzgjWGo+a2pfbm4Kel4kejZ2dCprNllyX3JwVXtSY0NSQj9zd0xYPW9hflctOEF9PlBPbihW T2ZuU05DITdzUU1CTT1iMHE7ODtKd0psCnpeQnxJal5jYWJORW45bzl2QzFPZyVnUkVBM04wI2RZ MDE7NGFIeCViTjZPU1V2fnNzPG8zNlMzb1Rxb0AtbWA8Kwp6ZURyeXteelkyXjxpQzd0dz9QS2Vi SUozMEZuWE9JWWl3K1RoRXN8fUckO2g0KEVYOyVTZHFlV0gyMilQYjcpM2IKelJjKXZmT0ZIZT51 N2FxVkRxQHJSWm80aH5hXmw3e29BKUVBUCEoRzRCI2p0eEFlQS02MXhRT1grRXB7ZzYwTithCnp3 cjZNKTdXRVhleV5nKCZOM3JNUEs3SUVPbnQzV0kmTmg+ODZ9OVp3ZUN1ZG02b25ZbntXeDdfd3ww SjAtNzVZfgp6X19sPGxEMnYrP0FaP0BERF9fXjZkSmNzKDZUbEk0RSZzY3ZZWkZiPyklOyE1Qy1s UzllTk9IKTVtYElRZyE5XlEKekZIUk14elF5cmR1WDQ4K2s3S2R2VlpCI2A+YXNmO1pgdV5rcGhf OGY+OSg4ckUlRW9ZM3h7VDRfamA0JG5xX31XCnpQM0A7YUh+bz9xOCR0JTFVZVNYZStWI0kwSkxE an4jXnNPfmJHYEZNNUBpemsrUm1fO15fZGBDWVRfcTBTdmFoewp6ek4mSXElYnNxSGx5K3g2dHUz QnQ4ai1NNVIkcTIpRmVzSylaQSFWJkRUMCt9ZD5XIz55THdTOD4qUSY4WjIje24Kejx0aihkeCFt PVQ3YSh3NXpGJVctZkx0byU7ciZSaGNXRmMod3h+UURxdH5tbXpXQ09uPi1rZ3BRWj02OWJYO1JC CnpDSH5nNTVLezlNbXReUWEwZ0VPbEVJMEk/WHUmVUoze1VJK3ZNNiExbTRmPiF0OEZHO0ZafGYw Ul9UPmczdUJuWQp6ZytfSGh1NS0/NTxkcmI0VVlHVkF3Pkp4MD0qYj4zd0BBPX1BSzR5Iys3N2lm dmJ5PG09K2dNSXtic3g7OFE3KEkKemhwdGRXQmpAe0dyRjVqRmo/fjtCNGkoODNLN0B6Zz5hKkps SyRjazdfX09Wa1ZrTGhaWGZwS0hNSCF1UkhpYkdjCnpaNHE4a1EqRnleQm8mYndTbFZRIWtuPm9W byhfTSZ2S3UyfGx5aDZkQ0RJM2JWY09iZTVQMlpPNUhBYGtWVk5kSQp6RU8xZ3RyQH5+IWsoU2cm bXo2a1B0R1EqVXBoTmhuK0QqJUUreUAwU2FpYXlrSDxoOWElTk9oWHF+V3dpdH0+QSkKelMmPnE9 dDZMV3E/JX1RSGdeTkh2UCp0KlF1JlR8cmJ8SzRaMTFfS0d0aUdJO1JwMS0taU5hPXcyTCh3SHZD SWdTCnp2d24hfFRoMHwlUWhSJDsrd3tYU207NUwkZyZaLWM9aUQwMmJ3RGZTSnZ9e09gNnNuKmFr ViFkWW5RYX5ORlVvNAp6SjNsYSEqV0cpRzhOMlRQKU5aNWlMeEVYdXdobjgye0Y/Tjw0PFUqVEpm bWVTdUslNVAtKCtRRlpFe2tnT1czSykKekwxNHE+YDJqPEdPPnJDJGl6Y0JFcjs+amplSH1KfUJ9 Y01heTlVNkQmclRJM2lJY3k3ZjR0bmlCemVTc3ZqJEczCnpuN0JfSFJVenQjPCFjT3hkfEpiRSl4 WSglSmBOUjJ1ZW1ZWGxTUHNWTlB7T1heWThDVmBlOypPP35KaVAoOHJTPgp6KGh0YCF4dF92ck98 fkZMWjFeP1hUNXB4UHdSUzZJVz5DelY8PWJCRkhUQz8xaEYtM1A9OEdNfFZNODZfOW9sZS0KenQ9 MVhlan5fcDd5JDM3VGE9clp2WT58U0c0TUJYbmA/dml6JWdmOFIpbnQ8aGQ8an05Sj9AayhwVy08 bipLe15fCnpvJng5UD1HUDJNSmFKS0N1KnA1PD82I082SGROUz5Cd1ZuTFRRRH5feDcrJTNGVzFi I19JLUR6S21WQ3dnJThoUQp6X3I5d2BvclVNbDdVPmxAZiRnYGxLT1RVSns5flFAKiplbVFSK1dU aG80RkZaUjduS2Q4SldEO2xTS35kMzlqTjAKeks3KkJ8dnRVKDJRJCo2KG4rUXk+U0thZE1ASWBM SmFyRWZMVDhKdE1JdVZubTs4TzxBQVI/bSNYISR6bEROMFhQCno0TD9YZEFGUFkyQ3owKmh0d3oq NGZxWH1lMVRCVl5XPmoxMFlgUilJc2VMU2dwUjgjZDx3bERpYz02QDZ3TSlhSAp6R1BJLSN5RlN9 QW4yIXVHUmNLcF4rK1JNY0VuZXhAND1YQmNYUiZCVHUjS2tCYE5HMCk2VzJlT2tAc3BnRk1vV0YK enAzUmN5UT5QcUljTmFRa2RXJCh3JHFEQyQ3YXAteG00ZF8+SEpsNV8xVjdYbXNxeXpLWVktNENf X2MmQDF5QGhFCnpuITU/NUBtcCZmb3dzaTxRNUZoWTgqYH5MX050KDVIYWp7XlNWVGd1b35kKWkx V1B5T25HdVBLWkU9bzEpWnh5cgp6PXV+RCV6Si0rKU03Y0UhbWk5VE5pTDJwZDtxN3N9O1RhXkkw WXtUZj4jPXVkOT1WKCQxX1FFV01vMSpBWHVSQ2cKekVAYT9FbXE0PEBBfCRSJT9tbHAwb2F5SHlR flctJnRxbXdZVH19NyUoJFd8NCZVOXopSEd+MlUodk9yVm1QbW01CnpqcnM4TVk8UXVpbTZoPzAj eTNxKFdeT2JOaGpUR2dHWGFUWXc1S3EkYnh+e1lCb1laQVZrNihTd2JCZ1RRemhxWAp6NTE3c2NS JTBfPFBZODRJc0NnMXM1ZTAqPiFYUHB4MCM5eHdrPnR9PzVTPitLbF5ydD1fKlojNWJUJFVPPntt aigKej4qSTtCSHhLQiR5SkZAPm94cnQ2aCRodlopbXxZQE9xXm1sWV98NilvUHRVXms7QU1IYld+ KHFwNVVrVC03QiRBCnpOdF9QVyUjSWcqOT9jQ1N3ZlhXKFZGKzBqbDw+fGpVfS1nRz8yUikzZV92 dUZ6JnMhclQ3TDFQQldSX3RAeHM5SAp6b3BybCRvNEcyRlRIIzFeZlhRdSMyZDV5TkB6VzEjVlRB cHRZNT56TihKTT44dTlFTnchQmskP2ZESmchcj4kUGgKenBiODlPUVBGNklXQ1glUkUpKT1iO3l4 MU4wYF55WENFKChRSXxxSHJpWHhkOWZjJlZgPjdBPCZBbk5KYD01RHEmCnpgI0Y7ZzxROzFxcXxN aWM2X2puPW1aXntaWWAtfmBIdj9Ea3NtVWp4IV4ycWkjITU2JmxSOz1IVzVCdH0mWWYoUAp6MndH d21JPikodDlHQk1ARClZdCp7NSNzanVmYXBQQzltdkx3cTQtPXA+MXBGQSVFaEhLcVNsOD1rK0Nw aHs/MlYKeis3a1okZEBLPkBXWGkyeGh7R0xBJSs2a3g2PjRqKFl2WH5JZTtjNVp1OGtfcz5TMWVN YWJ1UUNlJiR7UG5iWSlJCnpTWX1HNCt7YnRPVHtlWTY4TUQ9bU1WM0EwQDVOYWUtQDB8e0J6clY8 bFdtMCpPd0h1TWxeZ2tSKU94cU04IW1hTgp6dk04RURSSSZ8YEZVbzxBM3RKY31eNSViM0dwbHlv NTk4YXQyflFyZlZBTmMxbT88eGM4c0tyb0ZEb0dkNjl3MSYKeipOMkNQLV5gZExnP3dwQ01zTXZf VDZSPiYtYmBAN2pnTzlBTiRgQFFsK1FGdTJmaWRYNjhMVE44JXxFVyVyS212CnpIRXR9NFA3TC1X O0o0IyNZdCZwUD57fChoezN4TVpJRCQpQkM8d1h0cUdXbXw+MXsldlhUXz1kUHJEe2tfVCtYQwp6 ZUk4WVY3YTVRZmdiTmdANUVleHgkTU5aP24yP0ZpZiUkRUh3KmdIRzs+RFQjTkc+ZiQ3d0lkR3hz PzZrMlNfS0kKej92Pmh2I20wfW4tNEomaEEjPylmVzEwSik9Wj4qIyl9aklAbkt4MjlqWnZqNVR4 SH5jQ0ZCXylRbCNfZz1TYWZnCnpWVGkxV0tDbDh1SEFLKCNBK3U9ZzU+M3YjKH1sSyNjYC13Yy1Y Wlp4MTlVVjdsV21YWHhEUk1AOWN4NUErUj9ARgp6VzZvO1gpZFN3RD1mfEJpQXdPe0dedSghey1V KCh+bkBPX2hHWnkzSUlEemtXPG9IY29jbnImJT5fYCM8clhaVEMKemtOXyZ4QnVxN2ooXj9xKk1k Z2JWLWYjc0YyTD5edm1NSWE1bypjSFFpYiRQIWVgdXE9VyFTTj45QUg7ZUw8RVhnCnpnNTNZbHN6 Wk5ZJjlRbEQyb3BDbV9TODdLTjBgTDl0RjM9bW1DV1d0U0tJa0BxfWdvU05mcnk3e0pIZWUwZXcy bwp6d1p6NDhzfj0zPzhFT0t9ISh5QFRpbD9fVGR7cj8hXzYtR29PPlljfEVWNU1aWGREfEchfDRA dHY5eEZ2eWdtNGMKejYmMz55c248PHc8NWc4bHl3N08wOG1EPTNEZlc7c191VHlRRzRtMjJGdytA b3R0PThqSFJie3t2YFUkTkskJWYlCnplYXY/dSZGTW83Jl5zSEpmVXhKRVgyUlJ+UVglKUNPP1Yq eVFVPk80R01VRGs7bUBONUg9bCh4RE1GNVV7JHAkbQp6cHBzZnxLYWJ7R1prTVlSdGxCOFdhNWFZ bWw2JkJJSFkoMCh1fnlxa3E2ekl2QDdMZENCak18S25QZGdsODBAQFcKekp+cCZ4RkhqSnZUaGtk RE07SUl6VnsmdWIxeSVZelhVdjs1ZjZzT1EhOHtgdDVhYWFNdyt4fiNUanNvPF56KDZCCnopWDZr Tlp7Kjs5JkA2fUl7Tz1NJnhSbGhnPEhlfkdDYWc4V0FsMj5GNSpzbGowWlEjO24mbiVPJXghLTZ8 N0FoVAp6X3MrWGIkfGYwIy1scFpnbyZlWCFvXmFlJV5Vang5UllDVEc5UlcmVXw2MEI3UHZJP21l e2B9alN2MjxRViY8aSsKeiF4bGszUHQ+KDckQUw1YGJtPz1NaDhvaH1EdXV4WW0pM3dAJmloY3tm aTR6WiZOeUJGaUZ7ZFRBWCtHcj5oLUArCnp4fkMmS2lgMTxkZEtoamM2NSZFc2luSTBsVD87Uyg9 S3c9aVhrbmlzNXBmZnw4RWV4OCsxYU55amtmc0lEQyNQdQp6WmVaVHJFa3tve2ZvfjxXbUlMMmBy eklndShAKnNSMTsoTWQ1ODd8fjA+KVMyNFFFVF8ha3h6N1hDMkQ5KE5hYUsKekhUcHU9ZkQ0MXwz SElUSTAhfDRPPDJ3RGBtQWlHUlNGd28lSSt+anMrdU9IK2RZNnkyU0EtVyo2cDg0VnEhRnhBCnp1 WVkrbSpTS2d9QzVOdHg3S3peZWktVnl1SmYqI00+bnZVJnFnN3krJGxGVjstSSp9ZnVNVF59a0Qk I1FSOXZyOAp6NSRAdW1CMlhyenttP3c+LSY+SDtEbE4pQ0IkQERpPTd7TCUhWFpnVF8jYDlXVmYp cmROUGRmXkBnTFRfPUg7bVoKel5oJTRJOEt4b0V0JEMjI3k/aiFrKmRKYmEhckFvcF8qPkV7I1d0 dGsreyVpWiUmIUcteS1HN0B3OztTUmRNVDErCnpYUFQlNCQjS1RhNE93d3JYYCtIS3RvMkdXNFZ4 ayRsMmJQR2xyK2AtMU1iKFVYe25ZKU0pSSt+Tns8UXdoaXZQTgp6QSNqcWJPfWVfWjtQVTBCaz1C LSRSMFNVbiNSTHokRmVzeSlNQlM+YUNsUj01dlMlZGl2cDRfZiQ8aUw9QnBSQDEKenR0amhSdlE7 WHp3empzaWFgQ1pZLU5eX09mV0NtRVRWXikjPlBVamFmVnB0JEopZzx9XzZaRGMrZVU8YHQ0Rkdx CnoqZStSeiV0OXhzSlI+NmsxVl9UXjFLemJLQENReUBQV3RKZ1R8fSswOSNGVTt6TjR8UyghaC1k STYzM0FefnxCNgp6cD9nT0Z7ZHdaPVBYQ15gJUpKaj5GTV57ZihvbD9eYW1VKEVeQWsxMio4Xndr MjhfUWBiSEJTLXZ1RSYySlRTcUcKekk9PmNvenlEI2NiekpFNTRFPHtJKEY2Jk1tfDkhR0lgK2lg MjRWRXppWTBGdDQ3Uno8akZabWlkcTRESDl5KWB+CnpzTEpwflJDKGVzb3U0TTgkbCZzfHVVNXUj amoyOyNGazAhKzFvJGokJXEybFhafU9QQUFFbCRaXmpLNUMxKCExbgp6MipPTHlxaXVVPzZ9RHky d01kSTJDOH49cUVYRD5SNFpZJG0lIUE5X3c3MEpPO1M7eHwrJDhtNjRaMFUjajErZ2IKejdLVHpZ SEN3V2U2Y21fTWwkbGh8dT1nNH13WH5NSTxPeyZvcmVAS2NQVSFifTlHP1ZZI0taOHlJJHZoTyVw PDBBCnomaS1Md3Y8Uy1YfE0ycDtqSS1KUDd9RCMjMkYjZ2dYfSt4WU4mZ2RfQkh+aCZxSS1tPlRF dztMIzw/elImNj9ybAp6IUYoRE5FVSVmc3NpZXg4eCpSPV4/TyFLZUthfktycnBTVHhNfUU5NHoy e0R4KGYoYTYrYV5nTlc8KFJgXkl+UnUKemhPcVhldCl+MF5VeGZeWTdwQUZYVChES3QpQyZVLUZU QjZzayQpIUpFYzhQIU03YSp3SEN6SnlNajNVeHdFbz9vCnpGJWA4PzVhd1FEbGtvbmJkUlRFeFB0 YTMpRlV6ZD1sa0NRaiFKZW1KKWdXQmlOSXdjbCRSKz1iaiY8eERLI2EkYgp6dj0pP2Y8S2VASC18 Vz8jaXpWSkAzVDVBJiYzWWlsbE87WUZ5JDheX0FGaCM4RHU7QCFqRDRESyZHa0t4VGxpcTAKej4k M1J1RFFNcmJqTUBhPHJRJkFDe254RT9zJFAzbU8/Zk42VT9YNHNkYT96PVpUVz9WZCE/T1VPUV4t bWpMU1lUCnpZPmxMUHopYnxNPEFKZksldmhvTSF1flgzZyVCKEFOd0ojKTtFQDcmKzN2PiYpeiNJ MytYaDRWNGBDQ3U+dnIkTwp6OGJ0YXZtJDFmTHFwenhaX2x9PUVUYFRMfU9mYCRSWnQyI0d7em5y P04hPU8oWmFrKUBQPldeeEMhOEBPSmIyUTQKekY1b3s4SXtjKGBpdXpjOEVSQyZQKD18bz9YViUr PF93fDl5JXtYMGZwWUJ0Szl9ai19ckh0QkVUM01rWip3bjd3CnpgcHZEYTQkYD9DWntMYDFIVHow Tzc2fT1SKE9jfmh4PSV3KVpCQiM3OTNOXl9MTFBoOUtNcFVgXy0oV0lJNTZDbQp6dGZGe2pgVGsz TXpPOHVOMTB0QDN2SitYNnYlUlZZXnpLdH4/bi18dE1fUmsmbkIyRV5PemlhaWJyOHJZPWE+P0gK ejl8Uml6QG41PTBgeG8hcVVlVlJmIWlHXjAtZENOblAoSG1ERWMpVG9OcEdgeWoyPTxCJkYyITVf SGh5emV3IURkCno+OTMhbUZSIVR7VyFRR2BJeGctNGVkaWtSNzNreyZ6e2NLdnRxRDRCbEsjen5h NEYqRjUqRS1QK2N6VjFmZHJgSQp6e3wlMSgmJE1iXjtrNmMrZztBbn5Ba2V3bmAmPytFZClTP3om TVZ6OEshQVZaZUUmT1dgbVp6b1kxYEZic3JAVXAKbGV8amVXQ0d2aiprdDtQaTItaHpyQU5XeFhf IysoVGU5YF5xeH1PNjZ7QDw3KFVWIzdyCgpsaXRlcmFsIDgwMDAKemNtZUhNY35Geip6RH42aj5q TGRAS31EYipRN1dxdjVMclVuUWNGYHNkU25TMkFTJTBJa3RHQlNPSHFNVjZjQ2lLCnpDREJTaSp9 QGAoMDcoPk4kRHxOUTM/VSNPT0lRKmlCdFh7bGRDdHVKXlBZMk8/IyNKJnJoakdmJk5wQSlfaiNZ Kwp6XkV8Jl9lKjVgPyVrQ1lBYzdRO2otTE4wT3pYJD90e1IjeHk7PU8kZnUoRUlPSzRha0hNQ0A3 YlNwU2VmZV5kLVEKejlBeFZzNU5MaHNeZm1DY1E+VXpMITJ3cm90bkJRLSpSMVJVUHgrc0AzT0Bi b1V0e2xxS242cHdANHhra0ZJZzZaCno9WGdxIVVhb0JZWWtUe2xANHh4dCNtYmtydzZ9a2BIfVN7 aTFCRz9nJDQqQGNkVShFVUk+NWZySUBCT0JCc1ElMwp6P1JuJGxgdEhfMGBkX3JwWWtBO3RVcUFK bD4kUjBuQjtXbn5eajZOVCN8TDJmU2gwbm80WkZWOT4xKUFOeXNsVD8KemA0TEstPzNeNW4oYWZi VnNoSVZDOFV9WVl3Q0ZlcF4haX0oMypaUGhzPW85RmZuSSZPQU4wLTEpWHpYKW9XSnIzCno9K2l5 XyV+SWA9WkpaKC04b1FqYlluaVQ1RmpTcTJkPCZnUil4QyRBTXd4djw4IzJDJXMwYHIweyo1fUYp eFYhcAp6OG9GOD9pRlBlMUQ3SEdieyZGaiUoPiNWNkQ7JCNUYVUwMGVGUSY7eG5gVVFJSElsaz08 NHJ6ZXghfmp4K3ZeQE8KemU/dlljQExXb2kzUCZHNDcyelo1RnBTdmp3M1BvZV91K2tCUWFMYHEq eHJWNjZDSFc9UDVTUG5qYFlCT15eKEEkCnpIZ2tNQG9TZHxibihvZUtZfGEpVnZDRUJESkpPSEE+ VndgQzNFQWFfJTsoUSsrOSRJVXBKNSVaSW9KPDtldXQmVwp6KjtkdUs1e1VEYUJgPyliRENASnVr JVdfMSt3WGs3TT9IZzcyajtCYldiOVU3QHo8fSo1UGRhYnI7YCVxcDYyZ2oKelo8Sj5vb00hfW5w fEMpWE9LbnJ3ZXBKVlJhPkNeI0R8WHJMcX07UDRhOUQoaD1zPWxDKTBOLUV2UEdpUS1KK0lDCnok eGRWbFlldFN0cml1cl5GKVQrbSFkdnMpWjVkSmJKOEZWJW9oUWB2IUFIcTA2XipzKENjZUVGU3RP a1E1blFObAp6NilsdzVmI0tkTWllLUlNdWg+UlBJYitqeFZ2SzVUTmdJWkhZZERDX0xVMnM2P0hv b2xmVn1aLWV+c15ed1FENG0KejxsbTcjS0EhNEppZm50Sj4yY1pDI2NLIz05bkUmRSRCNClDXlln bjZ1dUR9OU9jUzNPY1EqKlMyaUpPS15oS3pyCnpPTXpwOz5lVmEmb243JDdfbElYYyl6Knw0R0pu Wm50VUleVlFecyNERXtzJG5FPy1XVHZ4eCpXPVRiKClnI1J9aQp6cSFkbCFGSihJbiY3MmVjJn1m byMxbiReNW5RQVVZPUo4KlFfJGhiO0lId3w4XkVHaWZWWGlTWVBUTEhzeXM/ZnsKemNHQkJkS1F8 NiZZMXppMVB8QmFXMW1BNWkhQjQqYWpufT5rKXgtb3hzcEx9SFBGP0whZEZHVEBHbztmRXFMJCRq CnplV2ZlUStJMXFLb0RyKSVwXkJKJFZ+ZzNGJnZIXk0keilzS3cxbCREK1RwQzRud2shISluKE0z NG5zUnZfSWwqfAp6U01md2BeRighcV4qYVRvdihqRiojPlU+PE0kcXBidXc4UDc8Vj93Jm9pPCg2 IXlgb3RyKChYRzNeX1EzeE1OJiQKekBgZDc5UWNgYU5PWGVIWnhmMGwpQHN0eWc/JTRiTCZfTzUz YDNWOTxYdjJOVGlzTHNhS2Q2R0UyN2pMPnJYO0A7CnomfntvTFVKK31ZSzRlWERzeUVNT1d8MiFx QiY+QS1XfT17ZGx9a1RlKFg5U0deTV4xJmspO2BRR2VBdGpXcW9haQp6T3kyeGVxWldARiFPRzRi XnM+KHxDZH5WYCNhfmUtTk1AYDNYZjUmViZ2Ym9xJTBoRkVqMVM5JXxLUDgzNmgpQEYKejlufjM5 I0Qre3RwcnhOb0ZpaWJNXz5xaHg8eDAxNEJZOVNmYE5aSHlxMEhHfihgOURaNmFVWCtSZTFXTElC TnExCno0LW9WPSlLS1lDbnJfb3hGREgyaj4pdF9Yb2o9JnNSblYhTWstWVgpMVpNVyFLayVUPy1V Y2hDYEZlYDZMZWZAcAp6eDElQ1ZKY0drb2w3MEUkbjRwTzFFO19GUGFwO2hoNHJKSWpTaTh+LT9N NWhwWWAkTip5SENxKz1URXI8WWAxbDAKek51aSN0MShwUjdVcVg3JUZQKD1mY3VqKighM3t4Ozl8 NiMmYEAxQit5MmFgMDhxaTYzRF95OGVpa1c/SlByc05kCnpycX1mR2w0cnI7JGNedDVDM2ZjYj8t I2E7Pl8xIypsVzxNQEMtJEZiJEcpdlM/P2Z5TVpIV21eOSh9UHlWRjsrPAp6MnNLJDxRQkI9XmlN cF92KnBkKlY3SGpDIS1COGhtJF5eKzk8czIwSCFOa01nfDJSJnNJVEN7emVlMTAqQDtTezwKej17 diFycigqVzkwbUE0LXduZz5rOV4qSEtvQVJ3LXgjOWUjSF5zSyh5MUVyRD0qRzhFc3RWN188OEZr KyltfiQ9CnpjaXIjSmZoJT0/WXd+STFLRnhOcl93VHdfPWloelcjPlVlcmhme1M0NDFBd1olUDZ8 WSMzK0NOPjc7YzVKUSFvUgp6KzJnVlVPUHd1M25hdWVCU1MlQCpmfXN2SypYQSFaMWNlSik4ZiNa d3B6Xl9rITZtMXp6NWV5TmQtKnMzSiZJZG4KemUkUEVWYjN3akh3cDI9V1FafTROVDUtJHMhZzM8 UEVAcmtsWUZiMntCaC1JQlk9NllycG90bWttaXhaMCtuYGRxCnp0Sj56dU5URyt7JTE5LWdoIXMo I21PcmFaNWVjS2BmKGJAMi1iaHU2X2Y+OGAmWFE7eUkrVWpDPVdRUTdTKkd0MAp6WFhhaHw3JnZW UFI1QDhtcnJRVElPTXBYaDYxST1EaCtKSj1yOCtWeDdzOzNoJGVWUnx2eWhjSWBfZShBQE5fYVcK endZLUYxdTU9UENLKEIwVD14IylEbkkoMkgoX1F4Z3hycW5+aUp5T3hWRz97WEU8SUQxI3lKQU4o OHpURSVZbzlPCnpSR1gtNHIoc3N2KEJ5YWViPilOd25zU3gxJSRNLU9IMlJwPntyczZWYzhtak43 Sz4jfDdxUSo8ZE9jezdnSFdZJgp6SCZwRSgldiZ2bUByLShfeWF6e3loOFJnJF8wVHkpaWRzVWJt eyFXVU5wTF5qPS04TyVlSUN0Rns8OTN1RmlCNEIKemFhe1d1Z1Q9Tz5RNkleY1ZKTmJ3dXswWnRf d1QtfjZOZj5RZlFtND9KWH07SmUwYnZIWWtoZTVIIXtzcUZ2Si1ECnooNl8wfEcqNWA2KUxgMjBn dzJHeEwyVVRMIS04PV8jQ1FxTzQkS3w0dUZhZXlFYUlWekshcj9NOTY4SFMmZDRTXgp6ej17Y0Q3 JXtvVTdHPyN3bHRMdyprWXhFQ2FSYn5VRitPT2Qhc0k/MEQ1XipYPE9jM3E5VnhWa1JvOzwtKUFE azYKelV6Yyh6a0UpZGRhV1pCT2s0Y3NrUG1ERjk7OEI2T00qYUVie1hxPT84fU5XVXRLSD5gcnNU R0lEc3s4aG41Z19DCnohKWRKJnNXTmU4MTZSMTAoRXpCVS1sSjZNdSlDWFleNXpWbTYzR2Zgej5H ej8ldXBzenhSPnBYcVg3QzMoODhfWQp6PFApWjdYakpVN21wYyhaZVA3M0U7fGQoa0V3VnhGSF4x IVJvZ2YjTWleciU5NmJjNUFWMVVtc182c1VDVlAmY2wKemtIPzE9JHooRE1wWFM9dSk+ZSs3S1de PDBYUHJoMEJ+czlXZXMkfEo5WUVRSXBJKm8zOU1NNVk5UnNXaSQlIStqCno2RGtwZ0tSVzg5NjFx Kj89LTRkfiU7O29hLXMqKmkmRnIpRSFQKUUxS1paOWdnaiUtVkJLMUdvUSt5YHNUQ1B6eAp6UjJA SWxsWGpgdmhpWDspTSpYb2BnciN9Oz03e3s+MDhUWG10fnVmJVo4MlFDNjh4c2ZeR3NwZFFHTGtH KmNxT00KejFeNERXWE96Q2M0bkxfPUFqZyhpaGhFR3pHV0R0bzJAVTFabE4yUEpwSWshSncxd3I9 Z01BIXo4bnZrbDkqYXRlCnotaHEyWFpjcUFqUFduY303VzIpd1BBdFN3KWtCRVptTFl7JFRtJnZC KXomakppMktiI1I4cTJ7RlEzbiFYaSNOWgp6JUo0QjRZQi0xRW1KU3FqXmdSO0g1dXFSSXlAV3g0 N3RiLXhrO3NqZypoeDJNPWl7I0l0Z05qUm5OOzdLSWozV1cKelc2R01Sd1U/JXptKjJFKGVvV2Zu WVVFQD5aKGFpK2lpcnc3ekVjXz1FKDgqZmByVTFUWDNZKUhFfXQ3dTFRWVhuCnpmKXchVDEtfT4x cSNjSUxOQkd8YnQlYEhWenZ3eGZjMzBrbXFmakBlZXcjNnQkcnQmNkghcU95JXRUWDxveSU4bAp6 YlZKOGVQVW90K2BMPkIwQUtGKXM7ZTZgLXlSK0k/YHlRRkhwYy1aVXtkMmc/b2o5TjlVSTVwLSp5 cWEyS0pyJnQKemJVSjs9ITV8aHh5MVRmT1hsb2V+NjdzY1JQXztlKjF0ZWlBQUV7byZBI1Z5dil+ PnthKitON0ZtODJHIVZqaCtXCnpYV3RhaEc0WTdTd180IUordURkbCRJe1Q3RGs7fHpObWx9eWlh OXFTRFI+VjNyIUZ5PiUrZWB2TFpJJDVeJnw2Vgp6aj8wWihEeDxIVm9ydUdPZ01VTU5aNj5OOD5w YmFPTyNiNmBJUGx4bm10MClCNlh4KTZKS3w2UmhaXjhYQTxKVk8Kek8wfnw5SyQ8OE5UIWRzUSh+ PU93djx0bGI1STtHVUBDQERLUyNERE0/Jkp0fCREX19TXk1oSmAjVjJUSnpeKVBgCnptcXBEX1dC VChHcVhJYD5fUll3UlVIa1VhUTRjTH07Uz1tVSFqMTJ3UTlvbzI/MWpEKmFKLVRsMiF6PC1YUkZk cQp6YkNtdi1uUH1kdz9yY18qYntuRH5GMyF2RkxrdG42cHJxKTk7N1JCQmVoR25KRitaanxtYiQ3 alQ3bU9oKDZke0cKek92aHIlKD1hRDlYOXEkUHJ0aGNQa1FvRmJ6QHMkfG94YitheX1vbigzc1Z7 cFB8SGlBYF8kN0Z0ME83emRtZVBeCnpiVyQxe0BpKkUoTjF3S154TXUpcURTdG9zdmxPK0dnTXAp U3J0KFJyQmdXMXxqPC0zOG4qOU15PXJwJHRka2EqUAp6RWRhQ3QmODJOald1aXJYczNyJm1eN00h TUNKM2JUTSFJOEl3SXJ1WjIkPEkpSi1yRlFpa3VKQ0V9VU9Mek9KQlgKeiYtUXNpME8lSlZANmo3 NVZTbnAqcl4wVnQmUT90NkdVNVJOMDxlV0RLWG1MZHpFQX0ldzh3PmckYiooQDRPfTZaCnowazZN cCpDRXhSczs1NmFQfl5QNTNjJW9XKm4jKiE1e1UkYlMqMX1kblR9dzFkPn4zWnU5bH10ZHlZYzVl eSF3YQp6WUhpWD1yTXhNOGxoO3QkWDhvdjQycERefHFnQWJkMDh6bngxfXteMld2KXFgSSRgXmB4 VlQ9bzxjc1FVKkc2WFEKejRfZiVPa3o9YCVTKDxVfGtUbmZSMkEhR2ZRbjRFemghTEclXiM+e1h6 cEhwbUI1OGlsKVZgTztEbGFeclY0QE9DCnpwcH1hWj9abzN0VEcwOEhuZiRDRjFlWXV9Qylgb3h4 cnJEV14lUWJsQnhzRmFuVk5EWDc0Tz9XSjVWVTtJaHdyJAp6dCUxT09xUnZMJFI7I3F+ajlgPHJp WVojWWc+TVZjS2Q0Kj1GT0VHOUpEJX5QXituTjshK3lCPnkpcEVKU3FWQDgKelgqaCZUQnRZMT0w fVExQWZvK0l1UjU0RURneFE5VmRNTHd3N09vZmY/WGh9KTZAfH5SY0QxQiRPb0B9a1NmY1gxCnp2 OGhXWF52Y1puXmU/PGBRfG1xNXUrPmR4PTNnJXllcz1fTlhYcllZcmU1O3s8VTRKclpxXn4yPism Xz5CQiMwJQp6eENSQkp2e3g1eXU9YWBqVDxedHU/Pj1TfTA7RS1hTSkqcW0odj8/PUMkc01KKXMk Nk8/Zzxyc2k8cigmO1JSTisKenBjOHlmZXpJeSZBQ19CYWIqIzhkKmNgPntIZHk0KlN+YTU5KV5y X0tZXig9MEApYzVwUjtibzdvKStieU1NajA+Cno8VklTZmpSMUoycVZuPzItNXokIzc/elh9XkA5 aiNYazwlNWhOemBVN2tOMVR3fiZFPzBZTGZ5JT52VHlyVWIjTQp6NjJqUUErP3ZHUGZFfFdHQC1B Q0BnWlJnLSkjbDtYN3dHYlpxKXI0ekVPS003O1c2XmV7I01Nb0YpVjB+bmFKQSgKekdeUklNal5L NDUwfEZUVSYyOEtWb28kUm4kX0t6U3R9bk1LPFptY011Z2VvQlNzZSF2QSQmYCozPWI3KkkyMyFS CnpkU3crfTMreldUSGFEOFFsOT9LYHl6SlYqUShMPCM8VWAkdFYoTXhpWERhUUNNd3plZ3VuSlRs Uk5SKDJhb2FQTgp6P1cjez1PZE40IzheTTBLZStiUWp0T0d0WkozR3NkWGtBYHNYcClNYDk1QUJ1 eGQ4eEFMV300TVE3YklCUDBCJXAKejdDRWh0I1JRaWBiP3ZsbHN8e3VtaEVuOSZoUzIyWShNRGNh KH0jME0lUC0odDBHbD5+alZDTFgrcWRJPDw5SEdQCnplLTF8YEM4dDF1WWpIMW9jO1ZAWEMhfWBL SUtZP05xS01iT2UhMGpjVFZuYTcqekFkb0U/YX42Y2QxUUhPPVY/ZQp6S244MjZlRmJEWnBpYD84 dnw+SU1aJTJsWGM+Y2dNKjJqR1UtQ0dOPXIlWSMwOHVzfXF8RT8rQFlKR0tlSTZ4SDEKejkxR2JI PGpWV2gjSH1ZTXFaKH14eEFacFpqU2JoQCMpY0YrSXl9NiMkeDVMRVpsMUglaSY/c2AmK19uS2pj QEM5CnotXmFLOGNvcFRVWVJkUmV4ZEg0bCpHS1MlPXhiXkJUVEt8PkVJfXRwNEpLeWRhaGR9eDd3 PkBLKnJQcWtpZj90fAp6eTZ6b0olUzQ8THJWakhXWEpuMHAyKDZALXlNblN8eHJ4JEJXTyNWRWZR RFc3ZyFfNlB5ZERfYjlCKXV6NU1CTTsKekU5c3sjeDhaWFc0K2A3MFVZdnV8U0FVd1lufG9oJjtZ fCZLaTxSLUhLPSVWc2gqd3tlbzw1LTVHXmhHIzFgNFVnCno1ZXZgU0F9N25ZMTF6RCQlemIweyZf WHdrbDkmS0BiYEJiU2shcENoJHxnZ2MhYSQ4UkY5QTdqQ181dV4+QERUUwp6KXkxOSVnK1EwR3Fy cWdIXzk1Qj5nPXpgdHI5VV9kait4VXw/ITc5a19RZHJFNl9nM0A/KDtQIW1mKT8wRkwkeDYKekEp QEFpSDZjfTtNNlRTM04mSE9RI0A2NmNzRjQ4Qy1fe2tQJE81PnNMX3QpQ0U9RnwrVVR7MW1TOz9q Vnk9Ti14Cnp2VEJua0hXa14hdFZtPUpoJnJBSD47dC0pSGBhb0YxZjczcU4+NlJwSmo9NWtrRHVs c0JLMih9IztQdGcrPVpTaQp6U2J7ZnxsbkRYU3NpTE80VG5udU5NPUNyIXFlS0FkZklDZkdkdWt8 WDNnLWhVQTBlK2ErQGFVRCtHamRmNjJseVIKej8jYGA3VX1VXnQ9KnNJb2YkVEctMCgwTSV3Ykh4 YEApXnNOT1E7K1VoWFZ3RmR4ITAhTVB0LVhMJm9LJXV1SU8pCno5bS04ZjQwVVh2NUZGVmVFTmhv QGtzbiN2WlhDUz4oNSZJRWArQistSzQrcmVfVy1qMy1FMzBxbVBmX2BKc2xpLQp6OXJUNktaPyZw UVU/WVBqb314PGlxdzFUWntvQmxGTVVCVmZNbmxVejJ7bzQrNGg9WWVVRU02d2cxa0x2S2BxX2oK emM2RF9QO2dXYXU4UlIkMDVZKGg8MnEwU0UwPzJWI2VkNlk3ZFVgdDByfChPPytwckw3TXdwYW1f QEY5Qzs3aVJuCnp1OHZIOXdzMFZ5cW5nNkwtbGRvQyVGZkdAbmY7PSV7RnNLVlpFY1pKbyU+Kzk/ PEpkWFdEPEleSnVOTGVOQXAxTQp6Ymw5JiozYlorNm0qTXdFdU0xOXdkQ1B1ZVBDcnsoZDMqSFkp dG5rWWMwVHNTS3drI1RnZClTa2xZblNUMXtSK30KenA1TnYtMWlSJUxpUnBAbk52TV4qaz5NWkM9 e25EI2NqMntuTHJGVG45R3hDP0Y7cD16YmpmUEo8K0BhZ1BuSFhiCno4P1RLYzclQ1k2dzc9I3I5 dmNqUC1mZngkRmB+N1dHcjRza2A+KFlpUH1WVkxDMWQrMXBsNF9RKWZEYURvMztKcAp6c2olOz5e QDBXcHFLeEp+ZEhIMlNWMU5FbyRZKkR8TXNgJmghUDBsQCNsNDxBNjw9JXs9YGB2Tis1a3ohIURx SSMKem8hJE8jJTw9dlFKTlRDfiFULT5eIW9KN3pQZSthP3pNbE9BYll0TWRqKD5aR2A1KVR2e31Q VjFVIW8oNVBmaD5vCnp4OzR2UTJMbyF+YiZtYWw2VFQlPTE4b1lrOHdHPmo5aGZyejQpbntGRWp2 TTk2fTtSNitJfTNNPUI+fW97I15TMQp6aV5TVm5ZdTlZcVZMKU98X2BVa2BPOCtHSHBFZG9ieThT OFlmNzt2czF5QCVZUEE+VlNFJWw2aXs3VzFKSkEyeyMKSm4od2FNYGE0ZWwmaT89YQoKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtLWxpbnV4L2NvbXBvc2l0aW5nL3Jl cGFpbnQvYmVjb21lLW92ZXJsYXktY29tcG9zaXRlZC1sYXllci1leHBlY3RlZC50eHQgYi9MYXlv dXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1saW51eC9jb21wb3NpdGluZy9yZXBhaW50L2JlY29t ZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXItZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQyYmU2 YmQ3OWQwZDYxODQxYjhmYTYxZjUyNmRkNzFkMGQ4MjRhOTYKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS1saW51eC9jb21wb3NpdGluZy9yZXBhaW50L2Jl Y29tZS1vdmVybGF5LWNvbXBvc2l0ZWQtbGF5ZXItZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTcg QEAKK2xheWVyIGF0ICgwLDApIHNpemUgODAweDYwMAorICBSZW5kZXJWaWV3IGF0ICgwLDApIHNp emUgODAweDYwMAorbGF5ZXIgYXQgKDAsMCkgc2l6ZSA4MDB4NjAwCisgIFJlbmRlckJsb2NrIHtI VE1MfSBhdCAoMCwwKSBzaXplIDgwMHg2MDAKKyAgICBSZW5kZXJCb2R5IHtCT0RZfSBhdCAoOCw4 KSBzaXplIDc4NHg1ODQKKyAgICAgIFJlbmRlckJsb2NrIHtQfSBhdCAoMCwwKSBzaXplIDc4NHgy MAorICAgICAgICBSZW5kZXJJbmxpbmUge0F9IGF0ICgwLDApIHNpemUgMTQ2eDE5IFtjb2xvcj0j MDAwMEVFXQorICAgICAgICAgIFJlbmRlclRleHQgeyN0ZXh0fSBhdCAoMCwwKSBzaXplIDE0Nngx OQorICAgICAgICAgICAgdGV4dCBydW4gYXQgKDAsMCkgd2lkdGggMTQ2OiAicmRhcjovL3Byb2Js ZW0vNjk4MzIwNyIKKyAgICAgICAgUmVuZGVyVGV4dCB7I3RleHR9IGF0ICgxNDYsMCkgc2l6ZSAz NzR4MTkKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMTQ2LDApIHdpZHRoIDM3NDogIlNob3VsZCBu b3QgbGVhdmUgYmx1ZSBib3ggYmVoaW5kIGFmdGVyIG1vdmluZyB0byB0aGUgdG9wIHJpZ2h0LiIK K2xheWVyIGF0ICg4LDQ0KSBzaXplIDUwMngxMDIKKyAgUmVuZGVyQmxvY2sgKHJlbGF0aXZlIHBv c2l0aW9uZWQpIHtESVZ9IGF0ICgwLDM2KSBzaXplIDUwMngxMDIgW2JvcmRlcjogKDFweCBzb2xp ZCAjMDAwMDAwKV0KK2xheWVyIGF0ICgyNTksNDUpIHNpemUgMjUweDEwMAorICBSZW5kZXJCbG9j ayAocG9zaXRpb25lZCkge0RJVn0gYXQgKDI1MSwxKSBzaXplIDI1MHgxMDAgW2JnY29sb3I9IzAw MDBGRl0KK2xheWVyIGF0ICg5LDQ1KSBzaXplIDUweDUwCisgIFJlbmRlckJsb2NrIChwb3NpdGlv bmVkKSB7RElWfSBhdCAoMSwxKSBzaXplIDUweDUwIFtiZ2NvbG9yPSMwMDAwMDBdCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQg Yi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS90ZXN0X2V4cGVjdGF0aW9ucy50eHQKaW5k ZXggNmFlN2IyNTBmOTA4NzE0ODE2YWM2NDYzOTFkMDM3NWVjZDNlYTdjNi4uZTc1MWNhOTgzZGFk MjNmZjhiNjczYTIwZmU3ZmMwMTJjMzVhNWJiMCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxh dGZvcm0vY2hyb21pdW0vdGVzdF9leHBlY3RhdGlvbnMudHh0CisrKyBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL2Nocm9taXVtL3Rlc3RfZXhwZWN0YXRpb25zLnR4dApAQCAtOTk3LDYgKzk5Nyw5IEBA IEJVR0NSNjI0MzMgV0lOIDogZmFzdC9pbWFnZXMvZ2lmLWxvb3AtY291bnQuaHRtbCA9IElNQUdF CiAvLyBTVkcgVEVTVFMKIC8vIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKKy8vIE5lZWQgcmViYXNlbGluaW5nIGFmdGVy IGJ1ZyA2NDU5MQorQlVHV0s2NDU5MSA6IGNvbXBvc2l0aW5nL3JlcGFpbnQvYmVjb21lLW92ZXJs YXktY29tcG9zaXRlZC1sYXllci5odG1sID0gUEFTUyBGQUlMCisKIEJVR0NSODc2MyBNQUMgOiBz dmcvY3VzdG9tL3VzZS1vbi1nLWNvbnRhaW5pbmctZm9yZWlnbk9iamVjdC1hbmQtaW1hZ2Uuc3Zn ID0gSU1BR0UKIAogCg==