38213 2010-04-27 13:23:00 -0700 Page up / page down moves edited content for the entire height 2010-05-26 21:55:08 -0700 1 1 1 Unclassified WebKit Frames 528+ (Nightly build) All Linux RESOLVED FIXED P2 Normal --- 1 zelidrag webkit-unassigned abarth ap commit-queue dglazkov enrica eric jamesr levin ojan tony webkit.review.bot oldest_to_newest 217881 0 zelidrag 2010-04-27 13:23:00 -0700 Frame page up / page down scroll height calculation seems to be broken in EditorCommand.cpp. Function verticalScrollDistance() assumes that the scrolling distance for these operations is the entire client height instead of the visible portion of it. Repro Steps: 1. Load a Google Doc, or any other page hosting an iframe that has vertical scrollbar. 2. Select the frame content, then press Page Down to page down through the doc, one page at a time. Expect to page one page at a time. Instead, it the page scrolls almost the entire content height instead. Check out http://crosbug.com/2562 for further details. 217904 1 ojan 2010-04-27 13:47:26 -0700 I don't see this on Chromium 5.0.391.0 (Developer Build 45722) on Mac. I don't see it in Google Docs and I don't see it on a test page that just has an iframe. Can you include more detailed steps? What browsers have you tested in? What versions? 218068 2 tony 2010-04-27 17:18:14 -0700 A test case attached to the bug would be awesome. 218084 3 zelidrag 2010-04-27 17:31:32 -0700 I've seen this in 5.0.375.17 dev on Windows and it is also detected in the current tip of the trunk which we pulled into ChromeOS. Please take a look at the example in WK layout test at LayoutTests/editing/input/option-page-up-down.html Currently, this layout test seems to be rigged to pass around this bug. 218098 4 tony 2010-04-27 17:53:22 -0700 You're right, it looks like we're moving the cursor to the wrong place (although we seem to be scrolling the right amount). I'll investigate. 218102 5 zelidrag 2010-04-27 17:56:45 -0700 Actually, we don't even scroll properly by page there (if the edit box is focused). I have a fix for this being prepared for the upload. 218114 6 54490 zelidrag 2010-04-27 18:16:47 -0700 Created attachment 54490 Fix for scroll height calc for page up/down key handling in Editor Fix for scroll height calc for page up/down key handling in Editor. 218116 7 webkit.review.bot 2010-04-27 18:21:23 -0700 Attachment 54490 did not pass style-queue: Failed to run "['WebKitTools/Scripts/check-webkit-style', '--no-squash']" exit_code: 1 WebCore/ChangeLog:6: Line contains tab character. [whitespace/tab] [5] WebCore/ChangeLog:7: Line contains tab character. [whitespace/tab] [5] WebCore/ChangeLog:9: Line contains tab character. [whitespace/tab] [5] Total errors found: 3 in 6 files If any of these errors are false positives, please file a bug against check-webkit-style. 218120 8 54491 zelidrag 2010-04-27 18:24:50 -0700 Created attachment 54491 Fix for scroll height calc for page up/down key handling in Editor removed tabs from ChangeLogs 218133 9 tony 2010-04-27 18:57:26 -0700 Thanks for the patch! A few comments: - This doesn't link on Mac because WebCore::SelectionController::setSelection is in the list of exported symbols. I think you need to update WebCore.base.exp. - The change to setSelection is so you can scroll to iframe so the cursor is the first selected line. In TextEdit on mac, I don't see that behavior. In TextEdit, the frame scrolls so that the cursor is in the middle. This is probably a platform specific behavior. - The existing layout test doesn't really tell you how the view scrolled. We probably need to add a layout test to verify that we scrolled the right amount. 219320 10 54491 levin 2010-04-29 18:37:34 -0700 Comment on attachment 54491 Fix for scroll height calc for page up/down key handling in Editor This looks like it is heading on a good path. I have some general comments and when they are done either I or someone else should verify the patch in greater detail. Ideally, the ChangeLog should have per function comments to explain why the change was done in that function. For example, I don't know why the code in verticalScrollDistance changed and the ChangeLog should explain this. When you find yourself adding a bool and then passing in true/false for it, it is a bad sign. It is especially bad if it is with a bunch of other bools. Please change the bool to an enum that describes the desired behavior (something like alignToTop or alignToEdgeIfNeeded?). Also, it looks like Tony had a bunch of good comments which should be addressed. 219647 11 54833 zelidrag 2010-04-30 16:24:07 -0700 Created attachment 54833 fixed mac link and behavior, other comments addressed - fixes WebCore::SelectionController::setSelection definition in WebCore.base.exp - made cursor align consistent with other apps on Mac - replaced cursor align control param with enum (instead of bool) in SelectionController::moveTo/setSelection and related calls - added better descriptions to ChangeLogs 219648 12 54834 zelidrag 2010-04-30 16:33:41 -0700 Created attachment 54834 fixed mac link and behavior, other comments addressed - fixes WebCore::SelectionController::setSelection definition in WebCore.base.exp - made cursor align consistent with other apps on Mac - replaced cursor align control param with enum (instead of bool) in SelectionController::moveTo/setSelection and related calls - added better descriptions to ChangeLogs - compared to previous patch, it has the correct scroll #if logic for Mac vs. the rest 219659 13 54838 zelidrag 2010-04-30 17:20:08 -0700 Created attachment 54838 fixed mac link issues and scroll behavior, other comments addressed - fixes WebCore::SelectionController::setSelection definition in WebCore.base.exp - made cursor align consistent with how other apps work on Mac - replaced cursor align control param with enum (instead of bool) in SelectionController::moveTo/setSelection and related calls - added better descriptions to ChangeLogs - compared to previous patches, this cl used #if OS(DARWIN) properly 219717 14 tony 2010-05-01 07:51:06 -0700 (In reply to comment #13) > Created an attachment (id=54838) [details] I think the code changes look good. It would be great if you could add another test to verify the scroll behavior (center align vs top align). Alternately, maybe you could make the existing test check this. One way would be to use JS to read the scroll offset (maybe give it a range of pixels to be tolerant of font differences). 220229 15 54949 zelidrag 2010-05-03 11:59:35 -0700 Created attachment 54949 added additional test for testing visual viewport of scrolled frame 221440 16 tony 2010-05-05 19:29:36 -0700 This LGTM, but I am not a reviewer. 221782 17 54949 levin 2010-05-06 10:23:38 -0700 Comment on attachment 54949 added additional test for testing visual viewport of scrolled frame Unfortunately, this comment from last time was not addressed: Ideally, the ChangeLog should have per function comments to explain why the change was done in that function. For example, I don't know why the code in verticalScrollDistance changed and the ChangeLog should explain this. (Actually, I think I get it now....but the ChangeLog should still explain it.) Also if there were per function comments, it would hopefully tell me why a particular place became "align always" when before it was "align if needed". Note that if you were to say the same thing more than once in a row then "Ditto." suffices the second time. > Index: WebCore/ChangeLog > =================================================================== > --- WebCore/ChangeLog (revision 58689) > +++ WebCore/ChangeLog (working copy) > @@ -1,3 +1,32 @@ > +2010-05-03 Zelidrag Hornung <zelidrag@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + Fixed frame page up/down scrolling calculation, made sure that the It should be a . instead of a , You're doing three separate things in this patch. A well focused patch that only does one thing would be smaller, quicker to review, get committed faster, and most importantly reviewed better because of the focused nature. It also would help folks in the future to not have to understand what each part of this patch is doing (but once again per function comments in the ChangeLog woudl also help with this). It may take you slightly longer, but there are far more committers than reviewers, so it is nice to optimize for reviewer time. You don't need to break this one up at this point but it is something to keep in mind. (I'd guess that we would have had two of these committed at this point had that course been taken.) > + cursor moves with page up/down as well. Please note that now OS(DARWIN) > + implementation will now center the center the cursor on page up/down Is the cursor behavior tested anywhere? (And where is the mac vs other platforms behavior of the cursor tested?) Is there a test to verify that the cursor isn't moved (on OS(DARWIN)) when alt isn't pressed? > + while other platforms will align the cursor with the top of displayed > + frame. > + https://bugs.webkit.org/show_bug.cgi?id=38213 > + * editing/SelectionController.h: > + (WebCore::SelectionController::): This should be a function name. prepare-ChangeLog messed this up but you should fix it ideally. > Index: WebCore/editing/EditorCommand.cpp Now that you have removed the one call to renderbox in this file, will it build with the "#include "RenderBox.h"" be removed? > Index: WebCore/editing/SelectionController.h > =================================================================== > --- WebCore/editing/SelectionController.h (revision 58684) > +++ WebCore/editing/SelectionController.h (working copy) > @@ -45,6 +45,7 @@ class SelectionController : public Nonco > public: > enum EAlteration { MOVE, EXTEND }; > enum EDirection { FORWARD, BACKWARD, RIGHT, LEFT }; > + enum EScrollCursorAlignment { ALIGN_IF_NEEDED, ALIGN_ALWAYS }; The enum is oddly named with the "E" prefix. The enums themselves (while consistent with the other enums here) are not ConsistentWithTheStyleGuide. The enum names do not stand on their own: ALIGN_IF_NEEDED -- align what if needed? When I see it in the code, it looks like this SelectionController::ALIGN_IF_NEEDED. This makes one think that the selection or selection controller is being aligned with something. > > SelectionController(Frame* = 0, bool isDragCaretController = false); > > @@ -54,14 +55,14 @@ public: > Node* shadowTreeRootNode() const { return m_selection.shadowTreeRootNode(); } > > void moveTo(const Range*, EAffinity, bool userTriggered = false); > - void moveTo(const VisiblePosition&, bool userTriggered = false); > + void moveTo(const VisiblePosition&, bool userTriggered = false, EScrollCursorAlignment cursorAlignment = ALIGN_IF_NEEDED); There is no need for the param to be named here ("cursorAlignment") because it adds no new information. > + void setSelection(const VisibleSelection&, bool closeTyping = true, bool clearTypingStyle = true, bool userTriggered = false, EScrollCursorAlignment cursorAlignment = ALIGN_IF_NEEDED, TextGranularity = CharacterGranularity); Ditto. > + bool modify(EAlteration, int verticalDistance, bool userTriggered = false, EScrollCursorAlignment cursorAlignment = ALIGN_IF_NEEDED); Ditto. > Index: LayoutTests/editing/input/scroll-viewport-page-up-down.html > +function runTest() { > + var tolerance = 10; > + var frame = frames[0]; > + var doc = frame.document; > + var body = doc.body; > + for (var i = 0; i < 10; ++i) > + body.innerHTML += "<p>line " + i + "</p>\n"; > + frame.focus(); > + frame.getSelection().setPosition(body.firstChild, 0); > + > + var onMacPlatform = navigator.userAgent.search(/\bMac OS X\b/) != -1; > + var modifiers = onMacPlatform ? ["altKey"] : []; > + > + if (onMacPlatform) > + offsets = [ 51, 159 ]; > + else > + offsets = [ 116, 218 ]; > + > + if (!window.eventSender) > + return; > + > + eventSender.keyDown("pageDown", modifiers); > + if (Math.abs(frame.pageYOffset - offsets[0]) > tolerance) { > + throw "Frame viewport should be around " + offsets[0] + > + "px , not at " + frame.pageYOffset; > + } > + > + eventSender.keyDown("pageDown", modifiers); > + var line = frame.getSelection().baseNode.nodeValue; > + if (Math.abs(frame.pageYOffset - offsets[1]) > tolerance) { > + throw "Frame viewport should be around " + offsets[1] + > + "px , not " + frame.pageYOffset; > + } > + > + eventSender.keyDown("pageUp", modifiers); > + var line = frame.getSelection().baseNode.nodeValue; > + if (Math.abs(frame.pageYOffset - offsets[0]) > tolerance) { > + throw "Frame viewport should be around " + offsets[0] + > + "px , not at " + frame.pageYOffset; > + } > + > + document.getElementById("results").innerText = "PASS"; > +} > +</script> > + > +<div>On Mac, option+pagedown should move the frame mouse cursor in the middle of the frame viewport in text areas. > +On other platforms, pagedown should move the mouse cursor at the top of the viewport while scroll in text areas. This talks about the cursor but the test doesn't test the cursor at all from what I can see. > +This test requires DRT to pass.</div> Instead of saying that it requires the DRT to pass, ideally it would tell someone how to manually repro the test if possible. 221965 18 54949 ojan 2010-05-06 14:25:45 -0700 Comment on attachment 54949 added additional test for testing visual viewport of scrolled frame WebCore/editing/SelectionController.cpp:165 + #if OS(DARWIN) This should use settings->editingBehavior() == EditingMacBehavior. That way it's a runtime setting and once https://bugs.webkit.org/show_bug.cgi?id=38603 is completed, we can change the setting on the fly in layout tests. eventSender.keyDown("pageDown", modifiers); if (Math.abs(frame.pageYOffset - offsets[0]) > tolerance) { throw "Frame viewport should be around " + offsets[0] + "px , not at " + frame.pageYOffset; } You don't have to, but if you want to make this test a bit more complete, you could also add verification that the selection is in the right place (e.g. it should be centered on mac except at the bounds of the scroll region).You can get the selection bounding box with window.getSelection().getBoundingClientRect(). 221983 19 levin 2010-05-06 14:53:01 -0700 (In reply to comment #18) > (From update of attachment 54949 [details]) > You don't have to, but if you want to make this test a bit more complete, you > could also add verification that the selection is in the right place (e.g. it > should be centered on mac except at the bounds of the scroll region). Actually, this appears to be part of the changes being done, so it should be tested as I noted above (and it should be trivial to test). 222699 20 55433 zelidrag 2010-05-07 16:50:06 -0700 Created attachment 55433 Addressed the latest set of comments Please note that test scroll-viewport-page-up-down.html covers platform differences in scroll view between mac and other platforms while option-page-up-down.html actually ensures that the cursor it on the same line on page up/down event regardless of the platform. * (re)added somehow dropped per-function comments into ChangeLog * renames SelectionController::CursorAlignOnScroll enum and its values to give more details about what they do * removed #include "RenderBox.h" from WebCore/editing/EditorCommand.cpp * renames cursorAlignment param * changed #if OS(DARWIN) to settings->editingBehavior() == EditingMacBehavior in SelectionController.cpp 222716 21 55433 ojan 2010-05-07 17:16:47 -0700 Comment on attachment 55433 Addressed the latest set of comments WebCore/editing/SelectionController.cpp:168 + if (m_frame->settings()->editingBehavior() == EditingMacBehavior) You should use the settings pointer you got in line 165. Also, you need to nullcheck settings here. WebCore/editing/EditorCommand.cpp:262 + int height = frame->view()->visibleHeight(); This doesn't look right to me. We're scrolling a renderer here that has overflow (i.e. the scrollbars are on that box, not the frame). Can you maybe add a case to your test (or another test) where you test scrolling in a div with overflow:auto? WebCore/editing/EditorCommand.cpp:260 + if (!(style->overflowY() == OSCROLL || style->overflowY() == OAUTO || focusedNode->isContentEditable())) This is only tangentially related to your code, so feel free to ignore, but this if-statement doesn't look right to me. If we're in a contentEditable element that's overflow:visible, I think we probably want to early return here. 222764 22 55433 levin 2010-05-07 19:30:25 -0700 Comment on attachment 55433 Addressed the latest set of comments I think you did some changes that didn't make it in this patch. Sorry if I sound like I'm repeating myself in these comments. I may have missed something so let me know if somehow I thought you should do something and you already did. Thanks! > Index: WebCore/ChangeLog > +2010-05-07 Zelidrag Hornung <zelidrag@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + Fixed frame page up/down scrolling calculation. Made sure that the > + cursor moves with page up/down as well. Please note that now OS(DARWIN) OS(DARWIN) doesn't match the code anymore. > + implementation will now center the center the cursor on page up/down > + while other platforms will align the cursor with the top of displayed > + frame. > + https://bugs.webkit.org/show_bug.cgi?id=38213 > + > + Test: editing/input/option-page-up-down.html (fixed) > + Test: editing/input/scroll-viewport-page-up-down.html (added) > + > + * WebCore.base.exp: > + * editing/EditorCommand.cpp: > + (WebCore::verticalScrollDistance): Fixed page scroll calculation. Now scroll height is calculated only from the visible portion not the entire frame height. > + (WebCore::executeMovePageDown): Now it can tell SelectionController to move the cursor with the page scroll up/down events. > Index: WebCore/editing/SelectionController.cpp > + if (userTriggered) { > + Settings* settings = m_frame ? m_frame->settings() : 0; settings is unused. > + ScrollAlignment alignment; > + if (m_frame->settings()->editingBehavior() == EditingMacBehavior) > + alignment = (align == ALIGN_CURSOR_ON_SCROLL_ALWAYS) ? ScrollAlignment::alignCenterAlways : ScrollAlignment::alignCenterIfNeeded; > + else > + alignment = (align == ALIGN_CURSOR_ON_SCROLL_ALWAYS) ? ScrollAlignment::alignTopAlways : ScrollAlignment::alignToEdgeIfNeeded; > + > + m_frame->revealSelection(alignment, true); If m_frame may be 0, then this will crash. (You check for m_frame being 0 above.) I don't see how m_frame can be 0, since this is checked for on line 121 of "SelectionController::setSelection" and the code returns there. Also this code always has used m_frame without doing a 0 check before. > Index: WebCore/editing/SelectionController.h > + enum CursorAlignOnScroll { ALIGN_CURSOR_ON_SCROLL_IF_NEEDED, > + ALIGN_CURSOR_ON_SCROLL_ALWAYS }; (I tried to mention this before but I must not have been clear... sorry.) Enum members should user InterCaps with an initial capital letter. In other words, it should look like this: enum CursorAlignOnScroll { AlignCursorOnScrollAlwaysIfNeeded, AlignCursorOnScrollAlways }; (You may wrap the line if you wish but you don't have to.) > + void moveTo(const VisiblePosition&, bool userTriggered = false, CursorAlignOnScroll align = ALIGN_CURSOR_ON_SCROLL_IF_NEEDED); (I mentioned this before but I must not have made it clear what I meant.) Please don't include the param name "align" since it add no information. In other words, the line should look like this: void moveTo(const VisiblePosition&, bool userTriggered = false, CursorAlignOnScroll = ALIGN_CURSOR_ON_SCROLL_IF_NEEDED); > + void setSelection(const VisibleSelection&, bool closeTyping = true, bool clearTypingStyle = true, bool userTriggered = false, CursorAlignOnScroll align = ALIGN_CURSOR_ON_SCROLL_IF_NEEDED, TextGranularity = CharacterGranularity); Ditto. > + bool modify(EAlteration, int verticalDistance, bool userTriggered = false, CursorAlignOnScroll align = ALIGN_CURSOR_ON_SCROLL_IF_NEEDED); Ditto. > Index: LayoutTests/ChangeLog > +2010-05-07 Zelidrag Hornung <zelidrag@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + Fixed page up/down scrolling expectations for bug: > + https://bugs.webkit.org/show_bug.cgi?id=38213 > + Added a new test that verifies how visible portion of frame changes > + while scrolling the frame. The test will check for different value on > + OS(DARWIN) than other platforms since edit frame scroll there will OS(DARWIN) doesn't match the code anymore. > + center the cursor on page up/down while it will align it with the top > + on other platforms. > + > + * editing/input/option-page-up-down.html: Fixed rigged test that was masking scrolling and cursor move errors. Added tests to make sure the cursor does not move on Mac if [option] is not pressed. Thx! But I don't see that change in this patch? > Index: LayoutTests/editing/input/scroll-viewport-page-up-down.html > +function runTest() { > + var tolerance = 10; > + var frame = frames[0]; > + var doc = frame.document; > + var body = doc.body; > + for (var i = 0; i < 10; ++i) > + body.innerHTML += "<p>line " + i + "</p>\n"; > + frame.focus(); > + frame.getSelection().setPosition(body.firstChild, 0); > + > + var onMacPlatform = navigator.userAgent.search(/\bMac OS X\b/) != -1; > + var modifiers = onMacPlatform ? ["altKey"] : []; > + > + if (onMacPlatform) > + offsets = [ 51, 159 ]; > + else > + offsets = [ 116, 218 ]; > + > + if (!window.eventSender) > + return; > + > + eventSender.keyDown("pageDown", modifiers); > + if (Math.abs(frame.pageYOffset - offsets[0]) > tolerance) { > + throw "Frame viewport should be around " + offsets[0] + > + "px , not at " + frame.pageYOffset; > + } > + > + eventSender.keyDown("pageDown", modifiers); > + var line = frame.getSelection().baseNode.nodeValue; > + if (Math.abs(frame.pageYOffset - offsets[1]) > tolerance) { > + throw "Frame viewport should be around " + offsets[1] + > + "px , not " + frame.pageYOffset; > + } > + > + eventSender.keyDown("pageUp", modifiers); > + var line = frame.getSelection().baseNode.nodeValue; > + if (Math.abs(frame.pageYOffset - offsets[0]) > tolerance) { > + throw "Frame viewport should be around " + offsets[0] + > + "px , not at " + frame.pageYOffset; > + } > + > + document.getElementById("results").innerText = "PASS"; > +} > +</script> I don't see how this "ensures that the cursor [is] on the same line on page up/down event regardless of the platform. " > > +<div>On Mac, option+pagedown should move the frame mouse cursor in the middle of the frame viewport in text areas. > +On other platforms, pagedown should move the mouse cursor at the top of the viewport while scroll in text areas. As noted previously, I don't understand why this talks about the cursor moving when it doesn't seem to verify that. > +This test requires DRT to pass.</div> (As noted previously) Instead of saying that it requires the DRT to pass, ideally it would tell someone how to manually repro the test if possible. 223118 23 tony 2010-05-09 17:50:56 -0700 (In reply to comment #21) > (From update of attachment 55433 [details]) > WebCore/editing/EditorCommand.cpp:260 > + if (!(style->overflowY() == OSCROLL || style->overflowY() == OAUTO || focusedNode->isContentEditable())) > This is only tangentially related to your code, so feel free to ignore, but this if-statement doesn't look right to me. If we're in a contentEditable element that's overflow:visible, I think we probably want to early return here. This is correct. I added it to fix the bug where we weren't moving the cursor in contentEditable. The code reads: if the node is not contentEditable, then don't move the cursor (i.e., move the cursor 0 lines). 223119 24 tony 2010-05-09 17:54:09 -0700 (In reply to comment #23) > (In reply to comment #21) > > (From update of attachment 55433 [details] [details]) > > WebCore/editing/EditorCommand.cpp:260 > > + if (!(style->overflowY() == OSCROLL || style->overflowY() == OAUTO || focusedNode->isContentEditable())) > > This is only tangentially related to your code, so feel free to ignore, but this if-statement doesn't look right to me. If we're in a contentEditable element that's overflow:visible, I think we probably want to early return here. > > This is correct. I added it to fix the bug where we weren't moving the cursor in contentEditable. The code reads: if the node is not contentEditable, then don't move the cursor (i.e., move the cursor 0 lines). I'm sorry, my last comment was confusing. You're asking about contentEditable+overflow:visible. In that case, we should not return early because we do want to move the cursor (I think). 225962 25 56100 zelidrag 2010-05-14 13:06:44 -0700 Created attachment 56100 Review comment fixed, handling of non-iframe contenteditable cases - more tests added to cover non-iframe contenteditable scroll/cursor handling - addressed other review comments 227530 26 56100 levin 2010-05-18 15:52:46 -0700 Comment on attachment 56100 Review comment fixed, handling of non-iframe contenteditable cases Thanks for your efforts and patiently addressing all of the feedback! 227548 27 56100 ojan 2010-05-18 16:42:15 -0700 Comment on attachment 56100 Review comment fixed, handling of non-iframe contenteditable cases I have a few things I'd like to see fixed. Putting my thoughts together now. I'll r+/r- appropriately with my comments. 227549 28 56100 levin 2010-05-18 16:46:21 -0700 Comment on attachment 56100 Review comment fixed, handling of non-iframe contenteditable cases Switching back to r? for Ojan comments. 227562 29 56100 ojan 2010-05-18 17:09:43 -0700 Comment on attachment 56100 Review comment fixed, handling of non-iframe contenteditable cases Thanks for adding all the extra testing. Just a few more things before committing this. Thanks for being patient. > Index: WebCore/editing/SelectionController.cpp > @@ -161,8 +161,15 @@ void SelectionController::setSelection(c > + if (userTriggered) { > + ScrollAlignment alignment; > + if (m_frame->settings()->editingBehavior() == EditingMacBehavior) You're fine not null-checking m_frame, but I think settings() still needs a null-check. Specifically, if m_frame's m_page is nulled out, then settings() returns null. > Index: LayoutTests/editing/input/option-page-up-down-inpage.html > Index: LayoutTests/editing/input/option-page-up-down.html Can you combine these two into one test? See my example below for a similar case. > Index: LayoutTests/editing/input/scroll-viewport-page-up-down.html > Index: LayoutTests/editing/input/scroll-viewport-page-up-down-div.html I think you could combine these two into one test without much work. More importantly, I don't see what scroll-viewport-page-up-down-div.html tests that scroll-viewport-page-up-down.html doesn't. I see that there are extra contentEditable divs there, but they're not actually the ones getting scrolled. Also, these tests shouldn't need a fudge factor. If the issue is text rendering, you should be able to get around it by using the "ahem" font-family. That font is specifically for testing. Every character has the same width/height. How about something like this? I haven't actually ran this, so I'm sure I got some bits wrong. <div>Page up/down (option+page up/down on Mac) should move the move cursor and scroll the content in contenteditable elements. This sample covers scroll position test of iframe element containing contenteditable body. Even though the cursor will move exactly to the same location on all platforms (covered by test option-page-up-down.html), please note that Mac will scroll the visible area by placing the cursor position in the middle. All other platforms will scroll by keeping the cursor aligned with the top edge of the visible area. </div> <div id="editable" contenteditable="true" style="height:150px;overflow:auto;"></div> <iframe src="../resources/contenteditable-iframe-src.html"></iframe> <div id="results">FAIL</div> <script> if (window.layoutTestController) layoutTestController.dumpAsText(); function runTest(scrollable) { var tolerance = 10; for (var i = 0; i < 10; ++i) scrollable.innerHTML += "<p>line " + i + "</p>\n"; frame.focus(); frame.getSelection().setPosition(scrollable.firstChild, 0); var onMacPlatform = navigator.userAgent.search(/\bMac OS X\b/) != -1; var modifiers = onMacPlatform ? ["altKey"] : []; if (onMacPlatform) offsets = [ 51, 159 ]; else offsets = [ 116, 218 ]; if (!window.eventSender) return; eventSender.keyDown("pageDown", modifiers); if (Math.abs(scrollable.scrollTop - offsets[0]) > tolerance) { throw "Frame viewport should be around " + offsets[0] + "px , not at " + scrollable.scrollTop; } eventSender.keyDown("pageDown", modifiers); var line = frame.getSelection().baseNode.nodeValue; if (Math.abs(scrollable.scrollTop - offsets[1]) > tolerance) { throw "Frame viewport should be around " + offsets[1] + "px , not " + scrollable.scrollTop; } eventSender.keyDown("pageUp", modifiers); var line = frame.getSelection().baseNode.nodeValue; if (Math.abs(scrollable.scrollTop - offsets[0]) > tolerance) { throw "Frame viewport should be around " + offsets[0] + "px , not at " + scrollable.scrollTop; } document.getElementById("results").innerText += "PASS<br>"; } runTest(document.getElementById('editable')); runTest(frames[0].document.body); </script> > +<body onload="runTest()"> > +<iframe src="../resources/contenteditable-iframe-src.html" onload="runTest()"></iframe> This isn't relevant if you change the test as I suggested above, but for future reference, there is a race condition here. runTest() can get called twice before the test finishes. 229061 30 56740 zelidrag 2010-05-21 13:08:40 -0700 Created attachment 56740 latest comments addressed, merged cursor/scroll tests, ahem fonts... * added check for m_frame->settings() * merged iframe and div tests into the same files * ahem-ized fonts used across these tests 229062 31 56740 commit-queue 2010-05-21 13:10:41 -0700 Comment on attachment 56740 latest comments addressed, merged cursor/scroll tests, ahem fonts... Rejecting patch 56740 from review queue. zelidrag@chromium.org does not have reviewer permissions according to http://trac.webkit.org/browser/trunk/WebKitTools/Scripts/webkitpy/common/config/committers.py. - If you do not have reviewer rights please read http://webkit.org/coding/contributing.html for instructions on how to use bugzilla flags. - If you have reviewer rights please correct the error in WebKitTools/Scripts/webkitpy/common/config/committers.py by adding yourself to the file (no review needed). Due to bug 30084 the commit-queue will require a restart after your change. Please contact eseidel@chromium.org to request a commit-queue restart. After restart the commit-queue will correctly respect your reviewer rights. 229063 32 56740 zelidrag 2010-05-21 13:12:36 -0700 Comment on attachment 56740 latest comments addressed, merged cursor/scroll tests, ahem fonts... wrong flags 229072 33 56740 ojan 2010-05-21 13:31:13 -0700 Comment on attachment 56740 latest comments addressed, merged cursor/scroll tests, ahem fonts... r=me with the change below. Thanks for being patient with all this. WebCore/editing/SelectionController.cpp:174 + if (macStyleScroll) If settings is null, that means we're in a state where it doesn't matter what editing behavior we use (e.g. a page transition). The null check is just to avoid crashing. So you can get rid of the macStyleScroll variable and just do something like this: if (m_frame->settings() && m_frame->settings()->editingBehavior() == EditingMacBehavior) 229121 34 56750 zelidrag 2010-05-21 15:08:10 -0700 Created attachment 56750 Changes m_frame->settings() check changed m_frame->settings() check per latest comment. 229453 35 56750 commit-queue 2010-05-23 04:45:26 -0700 Comment on attachment 56750 Changes m_frame->settings() check Rejecting patch 56750 from commit-queue. Failed to run "['WebKitTools/Scripts/run-webkit-tests', '--no-launch-safari', '--exit-after-n-failures=1', '--ignore-tests', 'compositing', '--quiet']" exit_code: 1 Last 500 characters of output: tree Compiling Java tests make: Nothing to be done for `default'. Running tests from /Users/eseidel/Projects/CommitQueue/LayoutTests Skipped list contained 'compositing/iframes/composited-iframe.html', but no file of that name could be found Testing 18294 test cases. editing/input/option-page-up-down.html -> failed Exiting early after 1 failures. 3778 tests run. 53.45s total testing time 3777 test cases (99%) succeeded 1 test case (<1%) had incorrect layout 1 test case (<1%) had stderr output Full output: http://webkit-commit-queue.appspot.com/results/2362077 229603 36 tony 2010-05-23 22:22:14 -0700 I ran the tests on my mac. The two new tests both failed because they need an extra blank line in the end of the results. However, platform/mac/editing/selection/25228.html also fails, but as mentioned in the test, this is probably expected. The test expects us to scroll such that the cursor is barely exposed, but this change causes the cursor to be centered. This seems to match TextEdit behavior. 229606 37 56847 tony 2010-05-23 22:32:45 -0700 Created attachment 56847 Patch 229618 38 tony 2010-05-24 00:13:29 -0700 I've uploaded a diff with the updated test expectations. While the new results for platform/mac/editing/selection/25228.html are correct, but it makes the test no longer test what it's supposed to test. I tried to come up with a new test that tests r42583, but I'm having a hard time. 230536 39 56847 ojan 2010-05-25 17:34:08 -0700 Comment on attachment 56847 Patch I find the horizontal centering to be a bit weird, but TextEdit does it and it's better than the old behavior of aligning to the left. I would r+ except for platform/mac/editing/selection/25228.html. I feel like we should either fix it so it's actually testing what it claims to or delete the test. The only thing I can think of for testing this would be to do the following: 1. Use the "ahem" font-family so that character widths are fixed. I think they're all 15px. 2. Make the div wide (e.g. 1000px) 3. Put the cursor in the middle of the first line. 4. Move the cursor backward one character. 5. Assert that there is a specific scrollLeft value on the body. If http://trac.webkit.org/changeset/42583 ever regressed, the scrollLeft would change. It's harder than the old test to verify correctness visually, but at least should keep testing that code path and we'll know if it ever changes. 230622 40 57081 tony 2010-05-26 02:24:57 -0700 Created attachment 57081 Patch 230623 41 tony 2010-05-26 02:26:12 -0700 I've updated the test such that rolling out r42583 will cause platform/mac/editing/selection/25228.html to fail. 230690 42 57081 ojan 2010-05-26 06:42:25 -0700 Comment on attachment 57081 Patch Thanks for following up on this. 231065 43 tony 2010-05-26 21:18:25 -0700 Committed r60268: <http://trac.webkit.org/changeset/60268> 231102 44 webkit.review.bot 2010-05-26 21:55:08 -0700 http://trac.webkit.org/changeset/60268 might have broken GTK Linux 32-bit Release 54490 2010-04-27 18:16:47 -0700 2010-04-27 18:25:25 -0700 Fix for scroll height calc for page up/down key handling in Editor WK_38213.diff text/plain 11143 zelidrag SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1ODM2MikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjYgQEAKKzIwMTAtMDQtMjcgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgRml4ZWQgZnJhbWUgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBjYWxjdWxhdGlvbiwgbWFk ZSBzdXJlIHRoYXQgdGhlCisJY3Vyc29yIG1vdmVzIHdpdGggcGFnZSB1cC9kb3duIGFzIHdlbGwu CisJaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4MjEzCisKKwlUZXN0 OiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbCAgKGZpeGVkKQorCisgICAg ICAgICogZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnZlcnRp Y2FsU2Nyb2xsRGlzdGFuY2UpOgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZU1vdmVQYWdlRG93 bik6CisgICAgICAgIChXZWJDb3JlOjpleGVjdXRlTW92ZVBhZ2VEb3duQW5kTW9kaWZ5U2VsZWN0 aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVNb3ZlUGFnZVVwKToKKyAgICAgICAgKFdl YkNvcmU6OmV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2VsZWN0aW9uKToKKyAgICAgICAgKiBl ZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0 aW9uQ29udHJvbGxlcjo6bW92ZVRvKToKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRy b2xsZXI6OnNldFNlbGVjdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9s bGVyOjptb2RpZnkpOgorICAgICAgICAqIGVkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oOgor ICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToKKwog MjAxMC0wNC0yNyAgSmVucyBBbGZrZSAgPHNuZWpAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFJl dmlld2VkIGJ5IERhcmluIEZpc2hlci4KSW5kZXg6IFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21t YW5kLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAJ KHJldmlzaW9uIDU4MzE5KQorKysgV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCSh3 b3JraW5nIGNvcHkpCkBAIC00MSw2ICs0MSw3IEBACiAjaW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgi CiAjaW5jbHVkZSAiRm9ybWF0QmxvY2tDb21tYW5kLmgiCiAjaW5jbHVkZSAiRnJhbWUuaCIKKyNp bmNsdWRlICJGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJIVE1MRm9udEVsZW1lbnQuaCIKICNpbmNs dWRlICJIVE1MSFJFbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRNTEltYWdlRWxlbWVudC5oIgpAQCAt MjU5LDcgKzI2MCw3IEBAIHN0YXRpYyBpbnQgdmVydGljYWxTY3JvbGxEaXN0YW5jZShGcmFtZSoK ICAgICAgICAgcmV0dXJuIDA7CiAgICAgaWYgKCEoc3R5bGUtPm92ZXJmbG93WSgpID09IE9TQ1JP TEwgfHwgc3R5bGUtPm92ZXJmbG93WSgpID09IE9BVVRPIHx8IGZvY3VzZWROb2RlLT5pc0NvbnRl bnRFZGl0YWJsZSgpKSkKICAgICAgICAgcmV0dXJuIDA7Ci0gICAgaW50IGhlaWdodCA9IHRvUmVu ZGVyQm94KHJlbmRlcmVyKS0+Y2xpZW50SGVpZ2h0KCk7CisgICAgaW50IGhlaWdodCA9IGZyYW1l LT52aWV3KCktPnZpc2libGVIZWlnaHQoKTsKICAgICByZXR1cm4gbWF4KG1heDxpbnQ+KGhlaWdo dCAqIFNjcm9sbGJhcjo6bWluRnJhY3Rpb25Ub1N0ZXBXaGVuUGFnaW5nKCksIGhlaWdodCAtIFNj cm9sbGJhcjo6bWF4T3ZlcmxhcEJldHdlZW5QYWdlcygpKSwgMSk7CiB9CiAKQEAgLTY0Niw3ICs2 NDcsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VEb3duKEZyYW1lKiBmCiAgICAgaW50 IGRpc3RhbmNlID0gdmVydGljYWxTY3JvbGxEaXN0YW5jZShmcmFtZSk7CiAgICAgaWYgKCFkaXN0 YW5jZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9u KCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpNT1ZFLCBkaXN0YW5jZSwgdHJ1ZSk7Cisg ICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6 Ok1PVkUsIGRpc3RhbmNlLCB0cnVlLCB0cnVlKTsKIH0KIAogc3RhdGljIGJvb2wgZXhlY3V0ZU1v dmVQYWdlRG93bkFuZE1vZGlmeVNlbGVjdGlvbihGcmFtZSogZnJhbWUsIEV2ZW50KiwgRWRpdG9y Q29tbWFuZFNvdXJjZSwgY29uc3QgU3RyaW5nJikKQEAgLTY1NCw3ICs2NTUsNyBAQCBzdGF0aWMg Ym9vbCBleGVjdXRlTW92ZVBhZ2VEb3duQW5kTW9kaWZ5CiAgICAgaW50IGRpc3RhbmNlID0gdmVy dGljYWxTY3JvbGxEaXN0YW5jZShmcmFtZSk7CiAgICAgaWYgKCFkaXN0YW5jZSkKICAgICAgICAg cmV0dXJuIGZhbHNlOwotICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxl Y3Rpb25Db250cm9sbGVyOjpFWFRFTkQsIGRpc3RhbmNlLCB0cnVlKTsKKyAgICByZXR1cm4gZnJh bWUtPnNlbGVjdGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCBkaXN0 YW5jZSwgdHJ1ZSwgdHJ1ZSk7CiB9CiAKIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwKEZy YW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpA QCAtNjYyLDcgKzY2Myw3IEBAIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwKEZyYW1lKiBm cmEKICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKGZyYW1lKTsKICAg ICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1l LT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1kaXN0YW5j ZSwgdHJ1ZSk7CisgICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlv bkNvbnRyb2xsZXI6Ok1PVkUsIC1kaXN0YW5jZSwgdHJ1ZSwgdHJ1ZSk7CiB9CiAKIHN0YXRpYyBi b29sIGV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2VsZWN0aW9uKEZyYW1lKiBmcmFtZSwgRXZl bnQqLCBFZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpAQCAtNjcwLDcgKzY3MSw3 IEBAIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2UKICAgICBpbnQgZGlz dGFuY2UgPSB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAoIWRpc3RhbmNl KQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+ bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6OkVYVEVORCwgLWRpc3RhbmNlLCB0cnVlKTsKKyAg ICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6 RVhURU5ELCAtZGlzdGFuY2UsIHRydWUsIHRydWUpOwogfQogCiBzdGF0aWMgYm9vbCBleGVjdXRl TW92ZVJpZ2h0KEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDb21tYW5kU291cmNlLCBjb25z dCBTdHJpbmcmKQpJbmRleDogV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAko cmV2aXNpb24gNTgzMTkpCisrKyBXZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTc5LDkgKzc5LDkgQEAgU2VsZWN0aW9uQ29udHJvbGxlcjo6 U2VsZWN0aW9uQ29udHJvbGxlcgogICAgIHNldElzRGlyZWN0aW9uYWwoZmFsc2UpOwogfQogCi12 b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vdmVUbyhjb25zdCBWaXNpYmxlUG9zaXRpb24gJnBv cywgYm9vbCB1c2VyVHJpZ2dlcmVkKQordm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjptb3ZlVG8o Y29uc3QgVmlzaWJsZVBvc2l0aW9uICZwb3MsIGJvb2wgdXNlclRyaWdnZXJlZCwgYm9vbCBmb3Jj ZUFsaWduVG9wKQogewotICAgIHNldFNlbGVjdGlvbihWaXNpYmxlU2VsZWN0aW9uKHBvcy5kZWVw RXF1aXZhbGVudCgpLCBwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmFmZmluaXR5KCkpLCB0cnVl LCB0cnVlLCB1c2VyVHJpZ2dlcmVkKTsKKyAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlv bihwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmRlZXBFcXVpdmFsZW50KCksIHBvcy5hZmZpbml0 eSgpKSwgdHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCwgZm9yY2VBbGlnblRvcCk7CiB9CiAKIHZv aWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlvbiAmYmFz ZSwgY29uc3QgVmlzaWJsZVBvc2l0aW9uICZleHRlbnQsIGJvb2wgdXNlclRyaWdnZXJlZCkKQEAg LTkxLDIxICs5MSwyMSBAQCB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vdmVUbyhjb25zdCBW CiAKIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0IFBvc2l0aW9uICZwb3Ms IEVBZmZpbml0eSBhZmZpbml0eSwgYm9vbCB1c2VyVHJpZ2dlcmVkKQogewotICAgIHNldFNlbGVj dGlvbihWaXNpYmxlU2VsZWN0aW9uKHBvcywgYWZmaW5pdHkpLCB0cnVlLCB0cnVlLCB1c2VyVHJp Z2dlcmVkKTsKKyAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlvbihwb3MsIGFmZmluaXR5 KSwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIHVzZXJUcmlnZ2VyZWQpOwogfQogCiB2b2lkIFNlbGVjdGlv bkNvbnRyb2xsZXI6Om1vdmVUbyhjb25zdCBSYW5nZSAqciwgRUFmZmluaXR5IGFmZmluaXR5LCBi b29sIHVzZXJUcmlnZ2VyZWQpCiB7CiAgICAgVmlzaWJsZVNlbGVjdGlvbiBzZWxlY3Rpb24gPSBy ID8gVmlzaWJsZVNlbGVjdGlvbihyLT5zdGFydFBvc2l0aW9uKCksIHItPmVuZFBvc2l0aW9uKCks IGFmZmluaXR5KSA6IFZpc2libGVTZWxlY3Rpb24oUG9zaXRpb24oKSwgUG9zaXRpb24oKSwgYWZm aW5pdHkpOwotICAgIHNldFNlbGVjdGlvbihzZWxlY3Rpb24sIHRydWUsIHRydWUsIHVzZXJUcmln Z2VyZWQpOworICAgIHNldFNlbGVjdGlvbihzZWxlY3Rpb24sIHRydWUsIHRydWUsIGZhbHNlLCB1 c2VyVHJpZ2dlcmVkKTsKIH0KIAogdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjptb3ZlVG8oY29u c3QgUG9zaXRpb24gJmJhc2UsIGNvbnN0IFBvc2l0aW9uICZleHRlbnQsIEVBZmZpbml0eSBhZmZp bml0eSwgYm9vbCB1c2VyVHJpZ2dlcmVkKQogewotICAgIHNldFNlbGVjdGlvbihWaXNpYmxlU2Vs ZWN0aW9uKGJhc2UsIGV4dGVudCwgYWZmaW5pdHkpLCB0cnVlLCB0cnVlLCB1c2VyVHJpZ2dlcmVk KTsKKyAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlvbihiYXNlLCBleHRlbnQsIGFmZmlu aXR5KSwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIHVzZXJUcmlnZ2VyZWQpOwogfQogCi12b2lkIFNlbGVj dGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzLCBi b29sIGNsb3NlVHlwaW5nLCBib29sIGNsZWFyVHlwaW5nU3R5bGUsIGJvb2wgdXNlclRyaWdnZXJl ZCwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5KQordm9pZCBTZWxlY3Rpb25Db250cm9sbGVy OjpzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgcywgYm9vbCBjbG9zZVR5cGlu ZywgYm9vbCBjbGVhclR5cGluZ1N0eWxlLCBib29sIHVzZXJUcmlnZ2VyZWQsIGJvb2wgZm9yY2VB bGlnblRvcCwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5KQogewogICAgIG1fZ3JhbnVsYXJp dHkgPSBncmFudWxhcml0eTsKIApAQCAtMTYyLDcgKzE2Miw3IEBAIHZvaWQgU2VsZWN0aW9uQ29u dHJvbGxlcjo6c2V0U2VsZWN0aW9uKGMKICAgICBtX2ZyYW1lLT5ub3RpZnlSZW5kZXJlck9mU2Vs ZWN0aW9uQ2hhbmdlKHVzZXJUcmlnZ2VyZWQpOwogICAgIG1fZnJhbWUtPnJlc3BvbmRUb0NoYW5n ZWRTZWxlY3Rpb24ob2xkU2VsZWN0aW9uLCBjbG9zZVR5cGluZyk7CiAgICAgaWYgKHVzZXJUcmln Z2VyZWQpCi0gICAgICAgIG1fZnJhbWUtPnJldmVhbFNlbGVjdGlvbihTY3JvbGxBbGlnbm1lbnQ6 OmFsaWduVG9FZGdlSWZOZWVkZWQsIHRydWUpOworICAgICAgICBtX2ZyYW1lLT5yZXZlYWxTZWxl Y3Rpb24oZm9yY2VBbGlnblRvcCA/IFNjcm9sbEFsaWdubWVudDo6YWxpZ25Ub3BBbHdheXMgOiBT Y3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9FZGdlSWZOZWVkZWQsIHRydWUpOwogCiAgICAgbm90aWZ5 QWNjZXNzaWJpbGl0eUZvclNlbGVjdGlvbkNoYW5nZSgpOwogfQpAQCAtNzE0LDcgKzcxNCw3IEBA IHN0YXRpYyBib29sIGFic29sdXRlQ2FyZXRZKGNvbnN0IFZpc2libGUKICAgICByZXR1cm4gdHJ1 ZTsKIH0KIAotYm9vbCBTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkoRUFsdGVyYXRpb24gYWx0 ZXIsIGludCB2ZXJ0aWNhbERpc3RhbmNlLCBib29sIHVzZXJUcmlnZ2VyZWQpCitib29sIFNlbGVj dGlvbkNvbnRyb2xsZXI6Om1vZGlmeShFQWx0ZXJhdGlvbiBhbHRlciwgaW50IHZlcnRpY2FsRGlz dGFuY2UsIGJvb2wgdXNlclRyaWdnZXJlZCwgYm9vbCBmb3JjZUFsaWduVG9wKQogewogICAgIGlm ICh2ZXJ0aWNhbERpc3RhbmNlID09IDApCiAgICAgICAgIHJldHVybiBmYWxzZTsKQEAgLTc4Miw3 ICs3ODIsNyBAQCBib29sIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vZGlmeShFQWx0ZXJhCiAKICAg ICBzd2l0Y2ggKGFsdGVyKSB7CiAgICAgICAgIGNhc2UgTU9WRToKLSAgICAgICAgICAgIG1vdmVU byhyZXN1bHQsIHVzZXJUcmlnZ2VyZWQpOworICAgICAgICAgICAgbW92ZVRvKHJlc3VsdCwgdXNl clRyaWdnZXJlZCwgZm9yY2VBbGlnblRvcCk7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAg Y2FzZSBFWFRFTkQ6CiAgICAgICAgICAgICBzZXRFeHRlbnQocmVzdWx0LCB1c2VyVHJpZ2dlcmVk KTsKSW5kZXg6IFdlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuaAkocmV2aXNpb24gNTgz MTkpCisrKyBXZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oCSh3b3JraW5nIGNv cHkpCkBAIC01NCwxNCArNTQsMTQgQEAgcHVibGljOgogICAgIE5vZGUqIHNoYWRvd1RyZWVSb290 Tm9kZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uLnNoYWRvd1RyZWVSb290Tm9kZSgpOyB9 CiAgICAgIAogICAgIHZvaWQgbW92ZVRvKGNvbnN0IFJhbmdlKiwgRUFmZmluaXR5LCBib29sIHVz ZXJUcmlnZ2VyZWQgPSBmYWxzZSk7Ci0gICAgdm9pZCBtb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0 aW9uJiwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOworICAgIHZvaWQgbW92ZVRvKGNvbnN0 IFZpc2libGVQb3NpdGlvbiYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBib29sIGZvcmNl QWxpZ25Ub3AgPSBmYWxzZSk7CiAgICAgdm9pZCBtb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9u JiwgY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwog ICAgIHZvaWQgbW92ZVRvKGNvbnN0IFBvc2l0aW9uJiwgRUFmZmluaXR5LCBib29sIHVzZXJUcmln Z2VyZWQgPSBmYWxzZSk7CiAgICAgdm9pZCBtb3ZlVG8oY29uc3QgUG9zaXRpb24mLCBjb25zdCBQ b3NpdGlvbiYsIEVBZmZpbml0eSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwogCiAgICAg Y29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uKCkgY29uc3QgeyByZXR1cm4gbV9zZWxl Y3Rpb247IH0KLSAgICB2b2lkIHNldFNlbGVjdGlvbihjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiwg Ym9vbCBjbG9zZVR5cGluZyA9IHRydWUsIGJvb2wgY2xlYXJUeXBpbmdTdHlsZSA9IHRydWUsIGJv b2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBUZXh0R3JhbnVsYXJpdHkgPSBDaGFyYWN0ZXJHcmFu dWxhcml0eSk7Ci0gICAgdm9pZCBzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYg c2VsZWN0aW9uLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkpIHsgc2V0U2VsZWN0aW9uKHNl bGVjdGlvbiwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIGdyYW51bGFyaXR5KTsgfQorICAgIHZvaWQgc2V0 U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mLCBib29sIGNsb3NlVHlwaW5nID0gdHJ1 ZSwgYm9vbCBjbGVhclR5cGluZ1N0eWxlID0gdHJ1ZSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFs c2UsIGJvb2wgZm9yY2VBbGlnblRvcCA9IGZhbHNlLCBUZXh0R3JhbnVsYXJpdHkgPSBDaGFyYWN0 ZXJHcmFudWxhcml0eSk7CisgICAgdm9pZCBzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVj dGlvbiYgc2VsZWN0aW9uLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkpIHsgc2V0U2VsZWN0 aW9uKHNlbGVjdGlvbiwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIGZhbHNlLCBncmFudWxhcml0eSk7IH0K ICAgICBib29sIHNldFNlbGVjdGVkUmFuZ2UoUmFuZ2UqLCBFQWZmaW5pdHksIGJvb2wgY2xvc2VU eXBpbmcpOwogICAgIHZvaWQgc2VsZWN0QWxsKCk7CiAgICAgdm9pZCBjbGVhcigpOwpAQCAtNzYs NyArNzYsNyBAQCBwdWJsaWM6CiAgICAgRUFmZmluaXR5IGFmZmluaXR5KCkgY29uc3QgeyByZXR1 cm4gbV9zZWxlY3Rpb24uYWZmaW5pdHkoKTsgfQogCiAgICAgYm9vbCBtb2RpZnkoRUFsdGVyYXRp b24sIEVEaXJlY3Rpb24sIFRleHRHcmFudWxhcml0eSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFs c2UpOwotICAgIGJvb2wgbW9kaWZ5KEVBbHRlcmF0aW9uLCBpbnQgdmVydGljYWxEaXN0YW5jZSwg Ym9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOworICAgIGJvb2wgbW9kaWZ5KEVBbHRlcmF0aW9u LCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UsIGJvb2wg Zm9yY2VBbGlnblRvcCA9IGZhbHNlKTsKICAgICBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHko KSBjb25zdCB7IHJldHVybiBtX2dyYW51bGFyaXR5OyB9CiAKICAgICB2b2lkIHNldFN0YXJ0KGNv bnN0IFZpc2libGVQb3NpdGlvbiAmLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CkluZGV4 OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCShyZXZpc2lvbiA1ODM2MikKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBj b3B5KQpAQCAtMSwzICsxLDEyIEBACisyMDEwLTA0LTI3ICBaZWxpZHJhZyBIb3JudW5nICA8emVs aWRyYWdAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIEZpeGVkIHBhZ2UgdXAvZG93biBzY3JvbGxpbmcgZXhwZWN0YXRpb25zIGZv ciBidWc6CisJaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4MjEzCisK KyAgICAgICAgKiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbDoKKwogMjAx MC0wNC0yNyAgRXZhbiBNYXJ0aW4gIDxldmFuQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZp ZXdlZCBieSBEYXZpZCBMZXZpbi4KSW5kZXg6IExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0 aW9uLXBhZ2UtdXAtZG93bi5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcv aW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sCShyZXZpc2lvbiA1ODMxOSkKKysrIExheW91 dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sCSh3b3JraW5nIGNv cHkpCkBAIC0yMCwxOCArMjAsMTggQEAgZnVuY3Rpb24gcnVuVGVzdCgpCiAKICAgICBldmVudFNl bmRlci5rZXlEb3duKCJwYWdlRG93biIsIG1vZGlmaWVycyk7CiAgICAgdmFyIGxpbmUgPSBmcmFt ZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7Ci0gICAgaWYgKGxpbmUgIT0gImxp bmUgOCIpCi0gICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgOCwgbm90ICIg KyBsaW5lOworICAgIGlmIChsaW5lICE9ICJsaW5lIDMiKQorICAgICAgICB0aHJvdyAiY3Vyc29y IHNob3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGluZTsKIAogICAgIGV2ZW50U2VuZGVyLmtl eURvd24oInBhZ2VEb3duIiwgbW9kaWZpZXJzKTsKICAgICB2YXIgbGluZSA9IGZyYW1lLmdldFNl bGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKLSAgICBpZiAobGluZSAhPSAibGluZSA5IikK LSAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSA5LCBub3QgIiArIGxpbmU7 CisgICAgaWYgKGxpbmUgIT0gImxpbmUgNiIpCisgICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxk IGJlIGF0IGxpbmUgNiwgbm90ICIgKyBsaW5lOwogCiAgICAgZXZlbnRTZW5kZXIua2V5RG93bigi cGFnZVVwIiwgbW9kaWZpZXJzKTsKICAgICB2YXIgbGluZSA9IGZyYW1lLmdldFNlbGVjdGlvbigp LmJhc2VOb2RlLm5vZGVWYWx1ZTsKLSAgICBpZiAobGluZSAhPSAibGluZSAxIikKLSAgICAgICAg dGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAxLCBub3QgIiArIGxpbmU7CisgICAgaWYg KGxpbmUgIT0gImxpbmUgMyIpCisgICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxp bmUgMywgbm90ICIgKyBsaW5lOwogCiAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3Vs dHMiKS5pbm5lclRleHQgPSAiUEFTUyI7CiB9Cg== 54491 2010-04-27 18:24:50 -0700 2010-04-30 16:24:07 -0700 Fix for scroll height calc for page up/down key handling in Editor WK_38213.diff text/plain 11171 zelidrag SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1ODM2MikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjYgQEAKKzIwMTAtMDQtMjcgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgRml4ZWQgZnJhbWUgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBjYWxjdWxhdGlvbiwgbWFk ZSBzdXJlIHRoYXQgdGhlCisgICAgICAgIGN1cnNvciBtb3ZlcyB3aXRoIHBhZ2UgdXAvZG93biBh cyB3ZWxsLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MzgyMTMKKworICAgICAgICBUZXN0OiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24u aHRtbCAgKGZpeGVkKQorCisgICAgICAgICogZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OnZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UpOgorICAgICAgICAoV2ViQ29y ZTo6ZXhlY3V0ZU1vdmVQYWdlRG93bik6CisgICAgICAgIChXZWJDb3JlOjpleGVjdXRlTW92ZVBh Z2VEb3duQW5kTW9kaWZ5U2VsZWN0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVNb3Zl UGFnZVVwKToKKyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2Vs ZWN0aW9uKToKKyAgICAgICAgKiBlZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKToKKyAgICAgICAgKFdl YkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbik6CisgICAgICAgIChXZWJD b3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgorICAgICAgICAqIGVkaXRpbmcvU2Vs ZWN0aW9uQ29udHJvbGxlci5oOgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxl cjo6c2V0U2VsZWN0aW9uKToKKwogMjAxMC0wNC0yNyAgSmVucyBBbGZrZSAgPHNuZWpAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEZpc2hlci4KSW5kZXg6IFdlYkNv cmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2VkaXRp bmcvRWRpdG9yQ29tbWFuZC5jcHAJKHJldmlzaW9uIDU4MzE5KQorKysgV2ViQ29yZS9lZGl0aW5n L0VkaXRvckNvbW1hbmQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00MSw2ICs0MSw3IEBACiAjaW5j bHVkZSAiRXZlbnRIYW5kbGVyLmgiCiAjaW5jbHVkZSAiRm9ybWF0QmxvY2tDb21tYW5kLmgiCiAj aW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJIVE1M Rm9udEVsZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MSFJFbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRN TEltYWdlRWxlbWVudC5oIgpAQCAtMjU5LDcgKzI2MCw3IEBAIHN0YXRpYyBpbnQgdmVydGljYWxT Y3JvbGxEaXN0YW5jZShGcmFtZSoKICAgICAgICAgcmV0dXJuIDA7CiAgICAgaWYgKCEoc3R5bGUt Pm92ZXJmbG93WSgpID09IE9TQ1JPTEwgfHwgc3R5bGUtPm92ZXJmbG93WSgpID09IE9BVVRPIHx8 IGZvY3VzZWROb2RlLT5pc0NvbnRlbnRFZGl0YWJsZSgpKSkKICAgICAgICAgcmV0dXJuIDA7Ci0g ICAgaW50IGhlaWdodCA9IHRvUmVuZGVyQm94KHJlbmRlcmVyKS0+Y2xpZW50SGVpZ2h0KCk7Cisg ICAgaW50IGhlaWdodCA9IGZyYW1lLT52aWV3KCktPnZpc2libGVIZWlnaHQoKTsKICAgICByZXR1 cm4gbWF4KG1heDxpbnQ+KGhlaWdodCAqIFNjcm9sbGJhcjo6bWluRnJhY3Rpb25Ub1N0ZXBXaGVu UGFnaW5nKCksIGhlaWdodCAtIFNjcm9sbGJhcjo6bWF4T3ZlcmxhcEJldHdlZW5QYWdlcygpKSwg MSk7CiB9CiAKQEAgLTY0Niw3ICs2NDcsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VE b3duKEZyYW1lKiBmCiAgICAgaW50IGRpc3RhbmNlID0gdmVydGljYWxTY3JvbGxEaXN0YW5jZShm cmFtZSk7CiAgICAgaWYgKCFkaXN0YW5jZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIHJl dHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpNT1ZF LCBkaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5 KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIGRpc3RhbmNlLCB0cnVlLCB0cnVlKTsKIH0KIAog c3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlmeVNlbGVjdGlvbihGcmFtZSog ZnJhbWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3QgU3RyaW5nJikKQEAgLTY1 NCw3ICs2NTUsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VEb3duQW5kTW9kaWZ5CiAg ICAgaW50IGRpc3RhbmNlID0gdmVydGljYWxTY3JvbGxEaXN0YW5jZShmcmFtZSk7CiAgICAgaWYg KCFkaXN0YW5jZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIHJldHVybiBmcmFtZS0+c2Vs ZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpFWFRFTkQsIGRpc3RhbmNlLCB0 cnVlKTsKKyAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29u dHJvbGxlcjo6RVhURU5ELCBkaXN0YW5jZSwgdHJ1ZSwgdHJ1ZSk7CiB9CiAKIHN0YXRpYyBib29s IGV4ZWN1dGVNb3ZlUGFnZVVwKEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDb21tYW5kU291 cmNlLCBjb25zdCBTdHJpbmcmKQpAQCAtNjYyLDcgKzY2Myw3IEBAIHN0YXRpYyBib29sIGV4ZWN1 dGVNb3ZlUGFnZVVwKEZyYW1lKiBmcmEKICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNjcm9s bERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4gZmFs c2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRy b2xsZXI6Ok1PVkUsIC1kaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rp b24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1kaXN0YW5jZSwgdHJ1ZSwg dHJ1ZSk7CiB9CiAKIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2VsZWN0 aW9uKEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJp bmcmKQpAQCAtNjcwLDcgKzY3MSw3IEBAIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwQW5k TW9kaWZ5U2UKICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKGZyYW1l KTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJu IGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6OkVYVEVORCwg LWRpc3RhbmNlLCB0cnVlKTsKKyAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2RpZnko U2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCAtZGlzdGFuY2UsIHRydWUsIHRydWUpOwogfQog CiBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVJpZ2h0KEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0 b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpJbmRleDogV2ViQ29yZS9lZGl0aW5nL1Nl bGVjdGlvbkNvbnRyb2xsZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZWRpdGluZy9TZWxl Y3Rpb25Db250cm9sbGVyLmNwcAkocmV2aXNpb24gNTgzMTkpCisrKyBXZWJDb3JlL2VkaXRpbmcv U2VsZWN0aW9uQ29udHJvbGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTc5LDkgKzc5LDkgQEAg U2VsZWN0aW9uQ29udHJvbGxlcjo6U2VsZWN0aW9uQ29udHJvbGxlcgogICAgIHNldElzRGlyZWN0 aW9uYWwoZmFsc2UpOwogfQogCi12b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vdmVUbyhjb25z dCBWaXNpYmxlUG9zaXRpb24gJnBvcywgYm9vbCB1c2VyVHJpZ2dlcmVkKQordm9pZCBTZWxlY3Rp b25Db250cm9sbGVyOjptb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZwb3MsIGJvb2wgdXNl clRyaWdnZXJlZCwgYm9vbCBmb3JjZUFsaWduVG9wKQogewotICAgIHNldFNlbGVjdGlvbihWaXNp YmxlU2VsZWN0aW9uKHBvcy5kZWVwRXF1aXZhbGVudCgpLCBwb3MuZGVlcEVxdWl2YWxlbnQoKSwg cG9zLmFmZmluaXR5KCkpLCB0cnVlLCB0cnVlLCB1c2VyVHJpZ2dlcmVkKTsKKyAgICBzZXRTZWxl Y3Rpb24oVmlzaWJsZVNlbGVjdGlvbihwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmRlZXBFcXVp dmFsZW50KCksIHBvcy5hZmZpbml0eSgpKSwgdHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCwgZm9y Y2VBbGlnblRvcCk7CiB9CiAKIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0 IFZpc2libGVQb3NpdGlvbiAmYmFzZSwgY29uc3QgVmlzaWJsZVBvc2l0aW9uICZleHRlbnQsIGJv b2wgdXNlclRyaWdnZXJlZCkKQEAgLTkxLDIxICs5MSwyMSBAQCB2b2lkIFNlbGVjdGlvbkNvbnRy b2xsZXI6Om1vdmVUbyhjb25zdCBWCiAKIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRv KGNvbnN0IFBvc2l0aW9uICZwb3MsIEVBZmZpbml0eSBhZmZpbml0eSwgYm9vbCB1c2VyVHJpZ2dl cmVkKQogewotICAgIHNldFNlbGVjdGlvbihWaXNpYmxlU2VsZWN0aW9uKHBvcywgYWZmaW5pdHkp LCB0cnVlLCB0cnVlLCB1c2VyVHJpZ2dlcmVkKTsKKyAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNl bGVjdGlvbihwb3MsIGFmZmluaXR5KSwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIHVzZXJUcmlnZ2VyZWQp OwogfQogCiB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vdmVUbyhjb25zdCBSYW5nZSAqciwg RUFmZmluaXR5IGFmZmluaXR5LCBib29sIHVzZXJUcmlnZ2VyZWQpCiB7CiAgICAgVmlzaWJsZVNl bGVjdGlvbiBzZWxlY3Rpb24gPSByID8gVmlzaWJsZVNlbGVjdGlvbihyLT5zdGFydFBvc2l0aW9u KCksIHItPmVuZFBvc2l0aW9uKCksIGFmZmluaXR5KSA6IFZpc2libGVTZWxlY3Rpb24oUG9zaXRp b24oKSwgUG9zaXRpb24oKSwgYWZmaW5pdHkpOwotICAgIHNldFNlbGVjdGlvbihzZWxlY3Rpb24s IHRydWUsIHRydWUsIHVzZXJUcmlnZ2VyZWQpOworICAgIHNldFNlbGVjdGlvbihzZWxlY3Rpb24s IHRydWUsIHRydWUsIGZhbHNlLCB1c2VyVHJpZ2dlcmVkKTsKIH0KIAogdm9pZCBTZWxlY3Rpb25D b250cm9sbGVyOjptb3ZlVG8oY29uc3QgUG9zaXRpb24gJmJhc2UsIGNvbnN0IFBvc2l0aW9uICZl eHRlbnQsIEVBZmZpbml0eSBhZmZpbml0eSwgYm9vbCB1c2VyVHJpZ2dlcmVkKQogewotICAgIHNl dFNlbGVjdGlvbihWaXNpYmxlU2VsZWN0aW9uKGJhc2UsIGV4dGVudCwgYWZmaW5pdHkpLCB0cnVl LCB0cnVlLCB1c2VyVHJpZ2dlcmVkKTsKKyAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlv bihiYXNlLCBleHRlbnQsIGFmZmluaXR5KSwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIHVzZXJUcmlnZ2Vy ZWQpOwogfQogCi12b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihjb25zdCBW aXNpYmxlU2VsZWN0aW9uJiBzLCBib29sIGNsb3NlVHlwaW5nLCBib29sIGNsZWFyVHlwaW5nU3R5 bGUsIGJvb2wgdXNlclRyaWdnZXJlZCwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5KQordm9p ZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlv biYgcywgYm9vbCBjbG9zZVR5cGluZywgYm9vbCBjbGVhclR5cGluZ1N0eWxlLCBib29sIHVzZXJU cmlnZ2VyZWQsIGJvb2wgZm9yY2VBbGlnblRvcCwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5 KQogewogICAgIG1fZ3JhbnVsYXJpdHkgPSBncmFudWxhcml0eTsKIApAQCAtMTYyLDcgKzE2Miw3 IEBAIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKGMKICAgICBtX2ZyYW1l LT5ub3RpZnlSZW5kZXJlck9mU2VsZWN0aW9uQ2hhbmdlKHVzZXJUcmlnZ2VyZWQpOwogICAgIG1f ZnJhbWUtPnJlc3BvbmRUb0NoYW5nZWRTZWxlY3Rpb24ob2xkU2VsZWN0aW9uLCBjbG9zZVR5cGlu Zyk7CiAgICAgaWYgKHVzZXJUcmlnZ2VyZWQpCi0gICAgICAgIG1fZnJhbWUtPnJldmVhbFNlbGVj dGlvbihTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9FZGdlSWZOZWVkZWQsIHRydWUpOworICAgICAg ICBtX2ZyYW1lLT5yZXZlYWxTZWxlY3Rpb24oZm9yY2VBbGlnblRvcCA/IFNjcm9sbEFsaWdubWVu dDo6YWxpZ25Ub3BBbHdheXMgOiBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9FZGdlSWZOZWVkZWQs IHRydWUpOwogCiAgICAgbm90aWZ5QWNjZXNzaWJpbGl0eUZvclNlbGVjdGlvbkNoYW5nZSgpOwog fQpAQCAtNzE0LDcgKzcxNCw3IEBAIHN0YXRpYyBib29sIGFic29sdXRlQ2FyZXRZKGNvbnN0IFZp c2libGUKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAotYm9vbCBTZWxlY3Rpb25Db250cm9sbGVyOjpt b2RpZnkoRUFsdGVyYXRpb24gYWx0ZXIsIGludCB2ZXJ0aWNhbERpc3RhbmNlLCBib29sIHVzZXJU cmlnZ2VyZWQpCitib29sIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vZGlmeShFQWx0ZXJhdGlvbiBh bHRlciwgaW50IHZlcnRpY2FsRGlzdGFuY2UsIGJvb2wgdXNlclRyaWdnZXJlZCwgYm9vbCBmb3Jj ZUFsaWduVG9wKQogewogICAgIGlmICh2ZXJ0aWNhbERpc3RhbmNlID09IDApCiAgICAgICAgIHJl dHVybiBmYWxzZTsKQEAgLTc4Miw3ICs3ODIsNyBAQCBib29sIFNlbGVjdGlvbkNvbnRyb2xsZXI6 Om1vZGlmeShFQWx0ZXJhCiAKICAgICBzd2l0Y2ggKGFsdGVyKSB7CiAgICAgICAgIGNhc2UgTU9W RToKLSAgICAgICAgICAgIG1vdmVUbyhyZXN1bHQsIHVzZXJUcmlnZ2VyZWQpOworICAgICAgICAg ICAgbW92ZVRvKHJlc3VsdCwgdXNlclRyaWdnZXJlZCwgZm9yY2VBbGlnblRvcCk7CiAgICAgICAg ICAgICBicmVhazsKICAgICAgICAgY2FzZSBFWFRFTkQ6CiAgICAgICAgICAgICBzZXRFeHRlbnQo cmVzdWx0LCB1c2VyVHJpZ2dlcmVkKTsKSW5kZXg6IFdlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25D b250cm9sbGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRy b2xsZXIuaAkocmV2aXNpb24gNTgzMTkpCisrKyBXZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29u dHJvbGxlci5oCSh3b3JraW5nIGNvcHkpCkBAIC01NCwxNCArNTQsMTQgQEAgcHVibGljOgogICAg IE5vZGUqIHNoYWRvd1RyZWVSb290Tm9kZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uLnNo YWRvd1RyZWVSb290Tm9kZSgpOyB9CiAgICAgIAogICAgIHZvaWQgbW92ZVRvKGNvbnN0IFJhbmdl KiwgRUFmZmluaXR5LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7Ci0gICAgdm9pZCBtb3Zl VG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwor ICAgIHZvaWQgbW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlvbiYsIGJvb2wgdXNlclRyaWdnZXJl ZCA9IGZhbHNlLCBib29sIGZvcmNlQWxpZ25Ub3AgPSBmYWxzZSk7CiAgICAgdm9pZCBtb3ZlVG8o Y29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgYm9vbCB1c2Vy VHJpZ2dlcmVkID0gZmFsc2UpOwogICAgIHZvaWQgbW92ZVRvKGNvbnN0IFBvc2l0aW9uJiwgRUFm ZmluaXR5LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CiAgICAgdm9pZCBtb3ZlVG8oY29u c3QgUG9zaXRpb24mLCBjb25zdCBQb3NpdGlvbiYsIEVBZmZpbml0eSwgYm9vbCB1c2VyVHJpZ2dl cmVkID0gZmFsc2UpOwogCiAgICAgY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uKCkg Y29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb247IH0KLSAgICB2b2lkIHNldFNlbGVjdGlvbihjb25z dCBWaXNpYmxlU2VsZWN0aW9uJiwgYm9vbCBjbG9zZVR5cGluZyA9IHRydWUsIGJvb2wgY2xlYXJU eXBpbmdTdHlsZSA9IHRydWUsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBUZXh0R3JhbnVs YXJpdHkgPSBDaGFyYWN0ZXJHcmFudWxhcml0eSk7Ci0gICAgdm9pZCBzZXRTZWxlY3Rpb24oY29u c3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJp dHkpIHsgc2V0U2VsZWN0aW9uKHNlbGVjdGlvbiwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIGdyYW51bGFy aXR5KTsgfQorICAgIHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mLCBi b29sIGNsb3NlVHlwaW5nID0gdHJ1ZSwgYm9vbCBjbGVhclR5cGluZ1N0eWxlID0gdHJ1ZSwgYm9v bCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UsIGJvb2wgZm9yY2VBbGlnblRvcCA9IGZhbHNlLCBUZXh0 R3JhbnVsYXJpdHkgPSBDaGFyYWN0ZXJHcmFudWxhcml0eSk7CisgICAgdm9pZCBzZXRTZWxlY3Rp b24oY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uLCBUZXh0R3JhbnVsYXJpdHkgZ3Jh bnVsYXJpdHkpIHsgc2V0U2VsZWN0aW9uKHNlbGVjdGlvbiwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIGZh bHNlLCBncmFudWxhcml0eSk7IH0KICAgICBib29sIHNldFNlbGVjdGVkUmFuZ2UoUmFuZ2UqLCBF QWZmaW5pdHksIGJvb2wgY2xvc2VUeXBpbmcpOwogICAgIHZvaWQgc2VsZWN0QWxsKCk7CiAgICAg dm9pZCBjbGVhcigpOwpAQCAtNzYsNyArNzYsNyBAQCBwdWJsaWM6CiAgICAgRUFmZmluaXR5IGFm ZmluaXR5KCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24uYWZmaW5pdHkoKTsgfQogCiAgICAg Ym9vbCBtb2RpZnkoRUFsdGVyYXRpb24sIEVEaXJlY3Rpb24sIFRleHRHcmFudWxhcml0eSwgYm9v bCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwotICAgIGJvb2wgbW9kaWZ5KEVBbHRlcmF0aW9uLCBp bnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOworICAgIGJv b2wgbW9kaWZ5KEVBbHRlcmF0aW9uLCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJp Z2dlcmVkID0gZmFsc2UsIGJvb2wgZm9yY2VBbGlnblRvcCA9IGZhbHNlKTsKICAgICBUZXh0R3Jh bnVsYXJpdHkgZ3JhbnVsYXJpdHkoKSBjb25zdCB7IHJldHVybiBtX2dyYW51bGFyaXR5OyB9CiAK ICAgICB2b2lkIHNldFN0YXJ0KGNvbnN0IFZpc2libGVQb3NpdGlvbiAmLCBib29sIHVzZXJUcmln Z2VyZWQgPSBmYWxzZSk7CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA1ODM2MikKKysrIExheW91dFRlc3Rz L0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDEyIEBACisyMDEwLTA0LTI3ICBa ZWxpZHJhZyBIb3JudW5nICA8emVsaWRyYWdAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEZpeGVkIHBhZ2UgdXAvZG93biBzY3Jv bGxpbmcgZXhwZWN0YXRpb25zIGZvciBidWc6CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0zODIxMworCisgICAgICAgICogZWRpdGluZy9pbnB1dC9vcHRp b24tcGFnZS11cC1kb3duLmh0bWw6CisKIDIwMTAtMDQtMjcgIEV2YW4gTWFydGluICA8ZXZhbkBj aHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGF2aWQgTGV2aW4uCkluZGV4OiBM YXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRt bAkocmV2aXNpb24gNTgzMTkpCisrKyBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L29wdGlvbi1w YWdlLXVwLWRvd24uaHRtbAkod29ya2luZyBjb3B5KQpAQCAtMjAsMTggKzIwLDE4IEBAIGZ1bmN0 aW9uIHJ1blRlc3QoKQogCiAgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBtb2Rp ZmllcnMpOwogICAgIHZhciBsaW5lID0gZnJhbWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9k ZVZhbHVlOwotICAgIGlmIChsaW5lICE9ICJsaW5lIDgiKQotICAgICAgICB0aHJvdyAiY3Vyc29y IHNob3VsZCBiZSBhdCBsaW5lIDgsIG5vdCAiICsgbGluZTsKKyAgICBpZiAobGluZSAhPSAibGlu ZSAzIikKKyAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiAr IGxpbmU7CiAKICAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIsIG1vZGlmaWVycyk7 CiAgICAgdmFyIGxpbmUgPSBmcmFtZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7 Ci0gICAgaWYgKGxpbmUgIT0gImxpbmUgOSIpCi0gICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxk IGJlIGF0IGxpbmUgOSwgbm90ICIgKyBsaW5lOworICAgIGlmIChsaW5lICE9ICJsaW5lIDYiKQor ICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDYsIG5vdCAiICsgbGluZTsK IAogICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VVcCIsIG1vZGlmaWVycyk7CiAgICAgdmFy IGxpbmUgPSBmcmFtZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7Ci0gICAgaWYg KGxpbmUgIT0gImxpbmUgMSIpCi0gICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxp bmUgMSwgbm90ICIgKyBsaW5lOworICAgIGlmIChsaW5lICE9ICJsaW5lIDMiKQorICAgICAgICB0 aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGluZTsKIAogICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHRzIikuaW5uZXJUZXh0ID0gIlBBU1MiOwogfQo= 54833 2010-04-30 16:24:07 -0700 2010-04-30 16:33:41 -0700 fixed mac link and behavior, other comments addressed WK_38213.patch text/plain 12475 zelidrag SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1ODU5NykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjYgQEAKKzIwMTAtMDQtMzAgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgRml4ZWQgZnJhbWUgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBjYWxjdWxhdGlvbiwgbWFk ZSBzdXJlIHRoYXQgdGhlCisgICAgICAgIGN1cnNvciBtb3ZlcyB3aXRoIHBhZ2UgdXAvZG93biBh cyB3ZWxsLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MzgyMTMKKworICAgICAgICBUZXN0OiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24u aHRtbCAgKGZpeGVkKQorCisgICAgICAgICogZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OnZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UpOiBGaXhlZCBwYWdlIHNjcm9s bCBjYWxjdWxhdGlvbi4gTm93IHNjcm9sbCBoZWlnaHQgaXMgY2FsY3VsYXRlZCBvbmx5IGZyb20g dGhlIHZpc2libGUgcG9ydGlvbiBub3QgdGhlIGVudGlyZSBmcmFtZSBoZWlnaHQuCisgICAgICAg IChXZWJDb3JlOjpleGVjdXRlTW92ZVBhZ2VEb3duKTogTm93IHRlbGxzIFNlbGVjdGlvbkNvbnRy b2xsZXIgdG8gbW92ZSB0aGUgY3Vyc29yIHdpdGggdGhlIHBhZ2Ugc2Nyb2xsIHVwL2Rvd24uCisg ICAgICAgIChXZWJDb3JlOjpleGVjdXRlTW92ZVBhZ2VEb3duQW5kTW9kaWZ5U2VsZWN0aW9uKToK KyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVNb3ZlUGFnZVVwKToKKyAgICAgICAgKFdlYkNvcmU6 OmV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2VsZWN0aW9uKToKKyAgICAgICAgKiBlZGl0aW5n L1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOiBFeHBvc2VkIGEgcGFyYW0gdGhhdCBsZXRzIEVkaXRv ckNvbW1hbmQuY3BwIGNvbnRyb2wgaG93IGN1cnNvciBwb3NpdGlvbiB3aWxsIGJlIGFsaWduZWQg d2hlbiBwYWdlIG1vdmVzLgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6 bW92ZVRvKToKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVj dGlvbik6CisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgor ICAgICAgICAqIGVkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oOgorICAgICAgICAoV2ViQ29y ZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToKKwogMjAxMC0wNC0zMCAgU2hl cmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZp ZXdlZCwgcm9sbGluZyBvdXQgcjU4NTY5LgpJbmRleDogV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS5iYXNlLmV4cAkocmV2aXNpb24gNTg1OTcp CisrKyBXZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAJKHdvcmtpbmcgY29weSkKQEAgLTQxNSw3ICs0 MTUsNyBAQCBfX1pON1dlYkNvcmUxOUFuaW1hdGlvbkNvbnRyb2xsZXIyMXBhdXNlCiBfX1pON1dl YkNvcmUxOUNTU1N0eWxlRGVjbGFyYXRpb24xMXNldFByb3BlcnR5RVJLTlNfNlN0cmluZ0VTM19S aQogX19aTjdXZWJDb3JlMTlJbnNwZWN0b3JDb250cm9sbGVyMzRpbnNwZWN0b3JTdGFydHNBdHRh Y2hlZFNldHRpbmdOYW1lRXYKIF9fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjEwc2V0 Rm9jdXNlZEViCi1fX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIxMnNldFNlbGVjdGlv bkVSS05TXzE2VmlzaWJsZVNlbGVjdGlvbkViYmJOU18xNVRleHRHcmFudWxhcml0eUUKK19fWk43 V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjEyc2V0U2VsZWN0aW9uRVJLTlNfMTZWaXNpYmxl U2VsZWN0aW9uRWJiYk5TMF8yMkVTY3JvbGxDdXJzb3JBbGlnbm1lbnRFTlNfMTVUZXh0R3JhbnVs YXJpdHlFCiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIxNnNldFNlbGVjdGVkUmFu Z2VFUE5TXzVSYW5nZUVOU185RUFmZmluaXR5RWIKIF9fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29u dHJvbGxlcjVjbGVhckV2CiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXI2bW9kaWZ5 RU5TMF8xMUVBbHRlcmF0aW9uRU5TMF8xMEVEaXJlY3Rpb25FTlNfMTVUZXh0R3JhbnVsYXJpdHlF YgpJbmRleDogV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcAkocmV2aXNpb24gNTg1OTcpCisrKyBX ZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQxLDYg KzQxLDcgQEAKICNpbmNsdWRlICJFdmVudEhhbmRsZXIuaCIKICNpbmNsdWRlICJGb3JtYXRCbG9j a0NvbW1hbmQuaCIKICNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lVmlldy5oIgog I2luY2x1ZGUgIkhUTUxGb250RWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxIUkVsZW1lbnQuaCIK ICNpbmNsdWRlICJIVE1MSW1hZ2VFbGVtZW50LmgiCkBAIC0yNTksNyArMjYwLDcgQEAgc3RhdGlj IGludCB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKEZyYW1lKgogICAgICAgICByZXR1cm4gMDsKICAg ICBpZiAoIShzdHlsZS0+b3ZlcmZsb3dZKCkgPT0gT1NDUk9MTCB8fCBzdHlsZS0+b3ZlcmZsb3dZ KCkgPT0gT0FVVE8gfHwgZm9jdXNlZE5vZGUtPmlzQ29udGVudEVkaXRhYmxlKCkpKQogICAgICAg ICByZXR1cm4gMDsKLSAgICBpbnQgaGVpZ2h0ID0gdG9SZW5kZXJCb3gocmVuZGVyZXIpLT5jbGll bnRIZWlnaHQoKTsKKyAgICBpbnQgaGVpZ2h0ID0gZnJhbWUtPnZpZXcoKS0+dmlzaWJsZUhlaWdo dCgpOwogICAgIHJldHVybiBtYXgobWF4PGludD4oaGVpZ2h0ICogU2Nyb2xsYmFyOjptaW5GcmFj dGlvblRvU3RlcFdoZW5QYWdpbmcoKSwgaGVpZ2h0IC0gU2Nyb2xsYmFyOjptYXhPdmVybGFwQmV0 d2VlblBhZ2VzKCkpLCAxKTsKIH0KIApAQCAtNjQ2LDcgKzY0Nyw3IEBAIHN0YXRpYyBib29sIGV4 ZWN1dGVNb3ZlUGFnZURvd24oRnJhbWUqIGYKICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNj cm9sbERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4g ZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNv bnRyb2xsZXI6Ok1PVkUsIGRpc3RhbmNlLCB0cnVlKTsKKyAgICByZXR1cm4gZnJhbWUtPnNlbGVj dGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6TU9WRSwgZGlzdGFuY2UsIHRydWUs IFNlbGVjdGlvbkNvbnRyb2xsZXI6OkFMSUdOX0FMV0FZUyk7CiB9CiAKIHN0YXRpYyBib29sIGV4 ZWN1dGVNb3ZlUGFnZURvd25BbmRNb2RpZnlTZWxlY3Rpb24oRnJhbWUqIGZyYW1lLCBFdmVudCos IEVkaXRvckNvbW1hbmRTb3VyY2UsIGNvbnN0IFN0cmluZyYpCkBAIC02NTQsNyArNjU1LDcgQEAg c3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlmeQogICAgIGludCBkaXN0YW5j ZSA9IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoZnJhbWUpOwogICAgIGlmICghZGlzdGFuY2UpCiAg ICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2Rp ZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCBkaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0 dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6OkVYVEVO RCwgZGlzdGFuY2UsIHRydWUsIFNlbGVjdGlvbkNvbnRyb2xsZXI6OkFMSUdOX0FMV0FZUyk7CiB9 CiAKIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwKEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBF ZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpAQCAtNjYyLDcgKzY2Myw3IEBAIHN0 YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwKEZyYW1lKiBmcmEKICAgICBpbnQgZGlzdGFuY2Ug PSB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAg ICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5 KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1kaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0dXJu IGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1k aXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6QUxJR05fQUxXQVlTKTsKIH0KIAog c3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlVXBBbmRNb2RpZnlTZWxlY3Rpb24oRnJhbWUqIGZy YW1lLCBFdmVudCosIEVkaXRvckNvbW1hbmRTb3VyY2UsIGNvbnN0IFN0cmluZyYpCkBAIC02NzAs NyArNjcxLDcgQEAgc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlVXBBbmRNb2RpZnlTZQogICAg IGludCBkaXN0YW5jZSA9IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoZnJhbWUpOwogICAgIGlmICgh ZGlzdGFuY2UpCiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVj dGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCAtZGlzdGFuY2UsIHRy dWUpOworICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250 cm9sbGVyOjpFWFRFTkQsIC1kaXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6QUxJ R05fQUxXQVlTKTsKIH0KIAogc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVSaWdodChGcmFtZSogZnJh bWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3QgU3RyaW5nJikKSW5kZXg6IFdl YkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAJKHJldmlzaW9uIDU4NTk3KQorKysg V2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC03OSw5ICs3OSw5IEBAIFNlbGVjdGlvbkNvbnRyb2xsZXI6OlNlbGVjdGlvbkNvbnRyb2xsZXIK ICAgICBzZXRJc0RpcmVjdGlvbmFsKGZhbHNlKTsKIH0KIAotdm9pZCBTZWxlY3Rpb25Db250cm9s bGVyOjptb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZwb3MsIGJvb2wgdXNlclRyaWdnZXJl ZCkKK3ZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlv biAmcG9zLCBib29sIHVzZXJUcmlnZ2VyZWQsIEVTY3JvbGxDdXJzb3JBbGlnbm1lbnQgY3Vyc29y QWxpZ25tZW50KQogewotICAgIHNldFNlbGVjdGlvbihWaXNpYmxlU2VsZWN0aW9uKHBvcy5kZWVw RXF1aXZhbGVudCgpLCBwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmFmZmluaXR5KCkpLCB0cnVl LCB0cnVlLCB1c2VyVHJpZ2dlcmVkKTsKKyAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlv bihwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmRlZXBFcXVpdmFsZW50KCksIHBvcy5hZmZpbml0 eSgpKSwgdHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCwgY3Vyc29yQWxpZ25tZW50KTsKIH0KIAog dm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjptb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZi YXNlLCBjb25zdCBWaXNpYmxlUG9zaXRpb24gJmV4dGVudCwgYm9vbCB1c2VyVHJpZ2dlcmVkKQpA QCAtMTA1LDcgKzEwNSw3IEBAIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0 IFAKICAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlvbihiYXNlLCBleHRlbnQsIGFmZmlu aXR5KSwgdHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCk7CiB9CiAKLXZvaWQgU2VsZWN0aW9uQ29u dHJvbGxlcjo6c2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHMsIGJvb2wgY2xv c2VUeXBpbmcsIGJvb2wgY2xlYXJUeXBpbmdTdHlsZSwgYm9vbCB1c2VyVHJpZ2dlcmVkLCBUZXh0 R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkpCit2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNl bGVjdGlvbihjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzLCBib29sIGNsb3NlVHlwaW5nLCBib29s IGNsZWFyVHlwaW5nU3R5bGUsIGJvb2wgdXNlclRyaWdnZXJlZCwgRVNjcm9sbEN1cnNvckFsaWdu bWVudCBjdXJzb3JBbGlnbm1lbnQsIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSkKIHsKICAg ICBtX2dyYW51bGFyaXR5ID0gZ3JhbnVsYXJpdHk7CiAKQEAgLTE2MSw4ICsxNjEsMTQgQEAgdm9p ZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb24oYwogICAgIHNlbGVjdEZyYW1lRWxl bWVudEluUGFyZW50SWZGdWxseVNlbGVjdGVkKCk7CiAgICAgbV9mcmFtZS0+bm90aWZ5UmVuZGVy ZXJPZlNlbGVjdGlvbkNoYW5nZSh1c2VyVHJpZ2dlcmVkKTsKICAgICBtX2ZyYW1lLT5yZXNwb25k VG9DaGFuZ2VkU2VsZWN0aW9uKG9sZFNlbGVjdGlvbiwgY2xvc2VUeXBpbmcpOwotICAgIGlmICh1 c2VyVHJpZ2dlcmVkKQotICAgICAgICBtX2ZyYW1lLT5yZXZlYWxTZWxlY3Rpb24oU2Nyb2xsQWxp Z25tZW50OjphbGlnblRvRWRnZUlmTmVlZGVkLCB0cnVlKTsKKyAgICBpZiAodXNlclRyaWdnZXJl ZCkgeworI2lmICFQTEFURk9STShNQUMpCisgICAgICAgIGNvbnN0IFNjcm9sbEFsaWdubWVudCYg YWxpZ25tZW50ID0gKGN1cnNvckFsaWdubWVudCA9PSBBTElHTl9BTFdBWVMpID8gU2Nyb2xsQWxp Z25tZW50OjphbGlnbkNlbnRlckFsd2F5cyA6IFNjcm9sbEFsaWdubWVudDo6YWxpZ25DZW50ZXJJ Zk5lZWRlZDsKKyNlbHNlCisgICAgICAgIGNvbnN0IFNjcm9sbEFsaWdubWVudCYgYWxpZ25tZW50 ID0gKGN1cnNvckFsaWdubWVudCA9PSBBTElHTl9BTFdBWVMpID8gU2Nyb2xsQWxpZ25tZW50Ojph bGlnblRvcEFsd2F5cyA6IFNjcm9sbEFsaWdubWVudDo6YWxpZ25Ub0VkZ2VJZk5lZWRlZDsKKyNl bmRpZgorICAgICAgICBtX2ZyYW1lLT5yZXZlYWxTZWxlY3Rpb24oYWxpZ25tZW50LCB0cnVlKTsK KyAgICB9CiAKICAgICBub3RpZnlBY2Nlc3NpYmlsaXR5Rm9yU2VsZWN0aW9uQ2hhbmdlKCk7CiB9 CkBAIC03MTQsNyArNzIwLDcgQEAgc3RhdGljIGJvb2wgYWJzb2x1dGVDYXJldFkoY29uc3QgVmlz aWJsZQogICAgIHJldHVybiB0cnVlOwogfQogCi1ib29sIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1v ZGlmeShFQWx0ZXJhdGlvbiBhbHRlciwgaW50IHZlcnRpY2FsRGlzdGFuY2UsIGJvb2wgdXNlclRy aWdnZXJlZCkKK2Jvb2wgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVBbHRlcmF0aW9uIGFs dGVyLCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dlcmVkLCBFU2Nyb2xsQ3Vy c29yQWxpZ25tZW50IGN1cnNvckFsaWdubWVudCkKIHsKICAgICBpZiAodmVydGljYWxEaXN0YW5j ZSA9PSAwKQogICAgICAgICByZXR1cm4gZmFsc2U7CkBAIC03ODIsNyArNzg4LDcgQEAgYm9vbCBT ZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkoRUFsdGVyYQogCiAgICAgc3dpdGNoIChhbHRlcikg ewogICAgICAgICBjYXNlIE1PVkU6Ci0gICAgICAgICAgICBtb3ZlVG8ocmVzdWx0LCB1c2VyVHJp Z2dlcmVkKTsKKyAgICAgICAgICAgIG1vdmVUbyhyZXN1bHQsIHVzZXJUcmlnZ2VyZWQsIGN1cnNv ckFsaWdubWVudCk7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2FzZSBFWFRFTkQ6CiAg ICAgICAgICAgICBzZXRFeHRlbnQocmVzdWx0LCB1c2VyVHJpZ2dlcmVkKTsKSW5kZXg6IFdlYkNv cmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9l ZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuaAkocmV2aXNpb24gNTg1OTcpCisrKyBXZWJDb3Jl L2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oCSh3b3JraW5nIGNvcHkpCkBAIC00NSw2ICs0 NSw3IEBAIGNsYXNzIFNlbGVjdGlvbkNvbnRyb2xsZXIgOiBwdWJsaWMgTm9uY28KIHB1YmxpYzoK ICAgICBlbnVtIEVBbHRlcmF0aW9uIHsgTU9WRSwgRVhURU5EIH07CiAgICAgZW51bSBFRGlyZWN0 aW9uIHsgRk9SV0FSRCwgQkFDS1dBUkQsIFJJR0hULCBMRUZUIH07CisgICAgZW51bSBFU2Nyb2xs Q3Vyc29yQWxpZ25tZW50IHsgQUxJR05fSUZfTkVFREVELCBBTElHTl9BTFdBWVMgfTsKIAogICAg IFNlbGVjdGlvbkNvbnRyb2xsZXIoRnJhbWUqID0gMCwgYm9vbCBpc0RyYWdDYXJldENvbnRyb2xs ZXIgPSBmYWxzZSk7CiAKQEAgLTU0LDE0ICs1NSwxNCBAQCBwdWJsaWM6CiAgICAgTm9kZSogc2hh ZG93VHJlZVJvb3ROb2RlKCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24uc2hhZG93VHJlZVJv b3ROb2RlKCk7IH0KICAgICAgCiAgICAgdm9pZCBtb3ZlVG8oY29uc3QgUmFuZ2UqLCBFQWZmaW5p dHksIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKLSAgICB2b2lkIG1vdmVUbyhjb25zdCBW aXNpYmxlUG9zaXRpb24mLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CisgICAgdm9pZCBt b3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2Us IEVTY3JvbGxDdXJzb3JBbGlnbm1lbnQgY3Vyc29yQWxpZ25tZW50ID0gQUxJR05fSUZfTkVFREVE KTsKICAgICB2b2lkIG1vdmVUbyhjb25zdCBWaXNpYmxlUG9zaXRpb24mLCBjb25zdCBWaXNpYmxl UG9zaXRpb24mLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CiAgICAgdm9pZCBtb3ZlVG8o Y29uc3QgUG9zaXRpb24mLCBFQWZmaW5pdHksIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsK ICAgICB2b2lkIG1vdmVUbyhjb25zdCBQb3NpdGlvbiYsIGNvbnN0IFBvc2l0aW9uJiwgRUFmZmlu aXR5LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CiAKICAgICBjb25zdCBWaXNpYmxlU2Vs ZWN0aW9uJiBzZWxlY3Rpb24oKSBjb25zdCB7IHJldHVybiBtX3NlbGVjdGlvbjsgfQotICAgIHZv aWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mLCBib29sIGNsb3NlVHlwaW5n ID0gdHJ1ZSwgYm9vbCBjbGVhclR5cGluZ1N0eWxlID0gdHJ1ZSwgYm9vbCB1c2VyVHJpZ2dlcmVk ID0gZmFsc2UsIFRleHRHcmFudWxhcml0eSA9IENoYXJhY3RlckdyYW51bGFyaXR5KTsKLSAgICB2 b2lkIHNldFNlbGVjdGlvbihjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzZWxlY3Rpb24sIFRleHRH cmFudWxhcml0eSBncmFudWxhcml0eSkgeyBzZXRTZWxlY3Rpb24oc2VsZWN0aW9uLCB0cnVlLCB0 cnVlLCBmYWxzZSwgZ3JhbnVsYXJpdHkpOyB9CisgICAgdm9pZCBzZXRTZWxlY3Rpb24oY29uc3Qg VmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgY2xvc2VUeXBpbmcgPSB0cnVlLCBib29sIGNsZWFyVHlw aW5nU3R5bGUgPSB0cnVlLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSwgRVNjcm9sbEN1cnNv ckFsaWdubWVudCBjdXJzb3JBbGlnbm1lbnQgPSBBTElHTl9JRl9ORUVERUQsIFRleHRHcmFudWxh cml0eSA9IENoYXJhY3RlckdyYW51bGFyaXR5KTsKKyAgICB2b2lkIHNldFNlbGVjdGlvbihjb25z dCBWaXNpYmxlU2VsZWN0aW9uJiBzZWxlY3Rpb24sIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0 eSkgeyBzZXRTZWxlY3Rpb24oc2VsZWN0aW9uLCB0cnVlLCB0cnVlLCBmYWxzZSwgQUxJR05fSUZf TkVFREVELCBncmFudWxhcml0eSk7IH0KICAgICBib29sIHNldFNlbGVjdGVkUmFuZ2UoUmFuZ2Uq LCBFQWZmaW5pdHksIGJvb2wgY2xvc2VUeXBpbmcpOwogICAgIHZvaWQgc2VsZWN0QWxsKCk7CiAg ICAgdm9pZCBjbGVhcigpOwpAQCAtNzYsNyArNzcsNyBAQCBwdWJsaWM6CiAgICAgRUFmZmluaXR5 IGFmZmluaXR5KCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24uYWZmaW5pdHkoKTsgfQogCiAg ICAgYm9vbCBtb2RpZnkoRUFsdGVyYXRpb24sIEVEaXJlY3Rpb24sIFRleHRHcmFudWxhcml0eSwg Ym9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwotICAgIGJvb2wgbW9kaWZ5KEVBbHRlcmF0aW9u LCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOworICAg IGJvb2wgbW9kaWZ5KEVBbHRlcmF0aW9uLCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2Vy VHJpZ2dlcmVkID0gZmFsc2UsIEVTY3JvbGxDdXJzb3JBbGlnbm1lbnQgY3Vyc29yQWxpZ25tZW50 ID0gQUxJR05fSUZfTkVFREVEKTsKICAgICBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkoKSBj b25zdCB7IHJldHVybiBtX2dyYW51bGFyaXR5OyB9CiAKICAgICB2b2lkIHNldFN0YXJ0KGNvbnN0 IFZpc2libGVQb3NpdGlvbiAmLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CkluZGV4OiBM YXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9n CShyZXZpc2lvbiA1ODU5NykKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5 KQpAQCAtMSwzICsxLDEyIEBACisyMDEwLTA0LTMwICBaZWxpZHJhZyBIb3JudW5nICA8emVsaWRy YWdAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEZpeGVkIHBhZ2UgdXAvZG93biBzY3JvbGxpbmcgZXhwZWN0YXRpb25zIGZvciBi dWc6CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zODIx MworCisgICAgICAgICogZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLmh0bWw6CisK IDIwMTAtMDQtMzAgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJldmlldy5ib3RAZ21haWwuY29tPgog CiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHI1ODU2OS4KSW5kZXg6IExheW91dFRl c3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sCShyZXZp c2lvbiA1ODU5NykKKysrIExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAt ZG93bi5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC0yMCwxOCArMjAsMTggQEAgZnVuY3Rpb24gcnVu VGVzdCgpCiAKICAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIsIG1vZGlmaWVycyk7 CiAgICAgdmFyIGxpbmUgPSBmcmFtZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7 Ci0gICAgaWYgKGxpbmUgIT0gImxpbmUgOCIpCi0gICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxk IGJlIGF0IGxpbmUgOCwgbm90ICIgKyBsaW5lOworICAgIGlmIChsaW5lICE9ICJsaW5lIDMiKQor ICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGluZTsK IAogICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3duIiwgbW9kaWZpZXJzKTsKICAgICB2 YXIgbGluZSA9IGZyYW1lLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKLSAgICBp ZiAobGluZSAhPSAibGluZSA5IikKLSAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQg bGluZSA5LCBub3QgIiArIGxpbmU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUgNiIpCisgICAgICAg IHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgNiwgbm90ICIgKyBsaW5lOwogCiAgICAg ZXZlbnRTZW5kZXIua2V5RG93bigicGFnZVVwIiwgbW9kaWZpZXJzKTsKICAgICB2YXIgbGluZSA9 IGZyYW1lLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKLSAgICBpZiAobGluZSAh PSAibGluZSAxIikKLSAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAxLCBu b3QgIiArIGxpbmU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUgMyIpCisgICAgICAgIHRocm93ICJj dXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMywgbm90ICIgKyBsaW5lOwogCiAgICAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lclRleHQgPSAiUEFTUyI7CiB9Cg== 54834 2010-04-30 16:33:41 -0700 2010-04-30 17:20:08 -0700 fixed mac link and behavior, other comments addressed WK_38213.patch text/plain 12474 zelidrag SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1ODU5NykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjYgQEAKKzIwMTAtMDQtMzAgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgRml4ZWQgZnJhbWUgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBjYWxjdWxhdGlvbiwgbWFk ZSBzdXJlIHRoYXQgdGhlCisgICAgICAgIGN1cnNvciBtb3ZlcyB3aXRoIHBhZ2UgdXAvZG93biBh cyB3ZWxsLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MzgyMTMKKworICAgICAgICBUZXN0OiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24u aHRtbCAgKGZpeGVkKQorCisgICAgICAgICogZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OnZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UpOiBGaXhlZCBwYWdlIHNjcm9s bCBjYWxjdWxhdGlvbi4gTm93IHNjcm9sbCBoZWlnaHQgaXMgY2FsY3VsYXRlZCBvbmx5IGZyb20g dGhlIHZpc2libGUgcG9ydGlvbiBub3QgdGhlIGVudGlyZSBmcmFtZSBoZWlnaHQuCisgICAgICAg IChXZWJDb3JlOjpleGVjdXRlTW92ZVBhZ2VEb3duKTogTm93IHRlbGxzIFNlbGVjdGlvbkNvbnRy b2xsZXIgdG8gbW92ZSB0aGUgY3Vyc29yIHdpdGggdGhlIHBhZ2Ugc2Nyb2xsIHVwL2Rvd24uCisg ICAgICAgIChXZWJDb3JlOjpleGVjdXRlTW92ZVBhZ2VEb3duQW5kTW9kaWZ5U2VsZWN0aW9uKToK KyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVNb3ZlUGFnZVVwKToKKyAgICAgICAgKFdlYkNvcmU6 OmV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2VsZWN0aW9uKToKKyAgICAgICAgKiBlZGl0aW5n L1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOiBFeHBvc2VkIGEgcGFyYW0gdGhhdCBsZXRzIEVkaXRv ckNvbW1hbmQuY3BwIGNvbnRyb2wgaG93IGN1cnNvciBwb3NpdGlvbiB3aWxsIGJlIGFsaWduZWQg d2hlbiBwYWdlIG1vdmVzLgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6 bW92ZVRvKToKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVj dGlvbik6CisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgor ICAgICAgICAqIGVkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oOgorICAgICAgICAoV2ViQ29y ZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToKKwogMjAxMC0wNC0zMCAgU2hl cmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZp ZXdlZCwgcm9sbGluZyBvdXQgcjU4NTY5LgpJbmRleDogV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS5iYXNlLmV4cAkocmV2aXNpb24gNTg1OTcp CisrKyBXZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAJKHdvcmtpbmcgY29weSkKQEAgLTQxNSw3ICs0 MTUsNyBAQCBfX1pON1dlYkNvcmUxOUFuaW1hdGlvbkNvbnRyb2xsZXIyMXBhdXNlCiBfX1pON1dl YkNvcmUxOUNTU1N0eWxlRGVjbGFyYXRpb24xMXNldFByb3BlcnR5RVJLTlNfNlN0cmluZ0VTM19S aQogX19aTjdXZWJDb3JlMTlJbnNwZWN0b3JDb250cm9sbGVyMzRpbnNwZWN0b3JTdGFydHNBdHRh Y2hlZFNldHRpbmdOYW1lRXYKIF9fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjEwc2V0 Rm9jdXNlZEViCi1fX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIxMnNldFNlbGVjdGlv bkVSS05TXzE2VmlzaWJsZVNlbGVjdGlvbkViYmJOU18xNVRleHRHcmFudWxhcml0eUUKK19fWk43 V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjEyc2V0U2VsZWN0aW9uRVJLTlNfMTZWaXNpYmxl U2VsZWN0aW9uRWJiYk5TMF8yMkVTY3JvbGxDdXJzb3JBbGlnbm1lbnRFTlNfMTVUZXh0R3JhbnVs YXJpdHlFCiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIxNnNldFNlbGVjdGVkUmFu Z2VFUE5TXzVSYW5nZUVOU185RUFmZmluaXR5RWIKIF9fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29u dHJvbGxlcjVjbGVhckV2CiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXI2bW9kaWZ5 RU5TMF8xMUVBbHRlcmF0aW9uRU5TMF8xMEVEaXJlY3Rpb25FTlNfMTVUZXh0R3JhbnVsYXJpdHlF YgpJbmRleDogV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcAkocmV2aXNpb24gNTg1OTcpCisrKyBX ZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQxLDYg KzQxLDcgQEAKICNpbmNsdWRlICJFdmVudEhhbmRsZXIuaCIKICNpbmNsdWRlICJGb3JtYXRCbG9j a0NvbW1hbmQuaCIKICNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lVmlldy5oIgog I2luY2x1ZGUgIkhUTUxGb250RWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxIUkVsZW1lbnQuaCIK ICNpbmNsdWRlICJIVE1MSW1hZ2VFbGVtZW50LmgiCkBAIC0yNTksNyArMjYwLDcgQEAgc3RhdGlj IGludCB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKEZyYW1lKgogICAgICAgICByZXR1cm4gMDsKICAg ICBpZiAoIShzdHlsZS0+b3ZlcmZsb3dZKCkgPT0gT1NDUk9MTCB8fCBzdHlsZS0+b3ZlcmZsb3dZ KCkgPT0gT0FVVE8gfHwgZm9jdXNlZE5vZGUtPmlzQ29udGVudEVkaXRhYmxlKCkpKQogICAgICAg ICByZXR1cm4gMDsKLSAgICBpbnQgaGVpZ2h0ID0gdG9SZW5kZXJCb3gocmVuZGVyZXIpLT5jbGll bnRIZWlnaHQoKTsKKyAgICBpbnQgaGVpZ2h0ID0gZnJhbWUtPnZpZXcoKS0+dmlzaWJsZUhlaWdo dCgpOwogICAgIHJldHVybiBtYXgobWF4PGludD4oaGVpZ2h0ICogU2Nyb2xsYmFyOjptaW5GcmFj dGlvblRvU3RlcFdoZW5QYWdpbmcoKSwgaGVpZ2h0IC0gU2Nyb2xsYmFyOjptYXhPdmVybGFwQmV0 d2VlblBhZ2VzKCkpLCAxKTsKIH0KIApAQCAtNjQ2LDcgKzY0Nyw3IEBAIHN0YXRpYyBib29sIGV4 ZWN1dGVNb3ZlUGFnZURvd24oRnJhbWUqIGYKICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNj cm9sbERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4g ZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNv bnRyb2xsZXI6Ok1PVkUsIGRpc3RhbmNlLCB0cnVlKTsKKyAgICByZXR1cm4gZnJhbWUtPnNlbGVj dGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6TU9WRSwgZGlzdGFuY2UsIHRydWUs IFNlbGVjdGlvbkNvbnRyb2xsZXI6OkFMSUdOX0FMV0FZUyk7CiB9CiAKIHN0YXRpYyBib29sIGV4 ZWN1dGVNb3ZlUGFnZURvd25BbmRNb2RpZnlTZWxlY3Rpb24oRnJhbWUqIGZyYW1lLCBFdmVudCos IEVkaXRvckNvbW1hbmRTb3VyY2UsIGNvbnN0IFN0cmluZyYpCkBAIC02NTQsNyArNjU1LDcgQEAg c3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlmeQogICAgIGludCBkaXN0YW5j ZSA9IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoZnJhbWUpOwogICAgIGlmICghZGlzdGFuY2UpCiAg ICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2Rp ZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCBkaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0 dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6OkVYVEVO RCwgZGlzdGFuY2UsIHRydWUsIFNlbGVjdGlvbkNvbnRyb2xsZXI6OkFMSUdOX0FMV0FZUyk7CiB9 CiAKIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwKEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBF ZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpAQCAtNjYyLDcgKzY2Myw3IEBAIHN0 YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwKEZyYW1lKiBmcmEKICAgICBpbnQgZGlzdGFuY2Ug PSB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAg ICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5 KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1kaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0dXJu IGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1k aXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6QUxJR05fQUxXQVlTKTsKIH0KIAog c3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlVXBBbmRNb2RpZnlTZWxlY3Rpb24oRnJhbWUqIGZy YW1lLCBFdmVudCosIEVkaXRvckNvbW1hbmRTb3VyY2UsIGNvbnN0IFN0cmluZyYpCkBAIC02NzAs NyArNjcxLDcgQEAgc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlVXBBbmRNb2RpZnlTZQogICAg IGludCBkaXN0YW5jZSA9IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoZnJhbWUpOwogICAgIGlmICgh ZGlzdGFuY2UpCiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVj dGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCAtZGlzdGFuY2UsIHRy dWUpOworICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250 cm9sbGVyOjpFWFRFTkQsIC1kaXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6QUxJ R05fQUxXQVlTKTsKIH0KIAogc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVSaWdodChGcmFtZSogZnJh bWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3QgU3RyaW5nJikKSW5kZXg6IFdl YkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAJKHJldmlzaW9uIDU4NTk3KQorKysg V2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC03OSw5ICs3OSw5IEBAIFNlbGVjdGlvbkNvbnRyb2xsZXI6OlNlbGVjdGlvbkNvbnRyb2xsZXIK ICAgICBzZXRJc0RpcmVjdGlvbmFsKGZhbHNlKTsKIH0KIAotdm9pZCBTZWxlY3Rpb25Db250cm9s bGVyOjptb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZwb3MsIGJvb2wgdXNlclRyaWdnZXJl ZCkKK3ZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlv biAmcG9zLCBib29sIHVzZXJUcmlnZ2VyZWQsIEVTY3JvbGxDdXJzb3JBbGlnbm1lbnQgY3Vyc29y QWxpZ25tZW50KQogewotICAgIHNldFNlbGVjdGlvbihWaXNpYmxlU2VsZWN0aW9uKHBvcy5kZWVw RXF1aXZhbGVudCgpLCBwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmFmZmluaXR5KCkpLCB0cnVl LCB0cnVlLCB1c2VyVHJpZ2dlcmVkKTsKKyAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlv bihwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmRlZXBFcXVpdmFsZW50KCksIHBvcy5hZmZpbml0 eSgpKSwgdHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCwgY3Vyc29yQWxpZ25tZW50KTsKIH0KIAog dm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjptb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZi YXNlLCBjb25zdCBWaXNpYmxlUG9zaXRpb24gJmV4dGVudCwgYm9vbCB1c2VyVHJpZ2dlcmVkKQpA QCAtMTA1LDcgKzEwNSw3IEBAIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0 IFAKICAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlvbihiYXNlLCBleHRlbnQsIGFmZmlu aXR5KSwgdHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCk7CiB9CiAKLXZvaWQgU2VsZWN0aW9uQ29u dHJvbGxlcjo6c2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHMsIGJvb2wgY2xv c2VUeXBpbmcsIGJvb2wgY2xlYXJUeXBpbmdTdHlsZSwgYm9vbCB1c2VyVHJpZ2dlcmVkLCBUZXh0 R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkpCit2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNl bGVjdGlvbihjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzLCBib29sIGNsb3NlVHlwaW5nLCBib29s IGNsZWFyVHlwaW5nU3R5bGUsIGJvb2wgdXNlclRyaWdnZXJlZCwgRVNjcm9sbEN1cnNvckFsaWdu bWVudCBjdXJzb3JBbGlnbm1lbnQsIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSkKIHsKICAg ICBtX2dyYW51bGFyaXR5ID0gZ3JhbnVsYXJpdHk7CiAKQEAgLTE2MSw4ICsxNjEsMTQgQEAgdm9p ZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb24oYwogICAgIHNlbGVjdEZyYW1lRWxl bWVudEluUGFyZW50SWZGdWxseVNlbGVjdGVkKCk7CiAgICAgbV9mcmFtZS0+bm90aWZ5UmVuZGVy ZXJPZlNlbGVjdGlvbkNoYW5nZSh1c2VyVHJpZ2dlcmVkKTsKICAgICBtX2ZyYW1lLT5yZXNwb25k VG9DaGFuZ2VkU2VsZWN0aW9uKG9sZFNlbGVjdGlvbiwgY2xvc2VUeXBpbmcpOwotICAgIGlmICh1 c2VyVHJpZ2dlcmVkKQotICAgICAgICBtX2ZyYW1lLT5yZXZlYWxTZWxlY3Rpb24oU2Nyb2xsQWxp Z25tZW50OjphbGlnblRvRWRnZUlmTmVlZGVkLCB0cnVlKTsKKyAgICBpZiAodXNlclRyaWdnZXJl ZCkgeworI2lmIFBMQVRGT1JNKE1BQykKKyAgICAgICAgY29uc3QgU2Nyb2xsQWxpZ25tZW50JiBh bGlnbm1lbnQgPSAoY3Vyc29yQWxpZ25tZW50ID09IEFMSUdOX0FMV0FZUykgPyBTY3JvbGxBbGln bm1lbnQ6OmFsaWduQ2VudGVyQWx3YXlzIDogU2Nyb2xsQWxpZ25tZW50OjphbGlnbkNlbnRlcklm TmVlZGVkOworI2Vsc2UKKyAgICAgICAgY29uc3QgU2Nyb2xsQWxpZ25tZW50JiBhbGlnbm1lbnQg PSAoY3Vyc29yQWxpZ25tZW50ID09IEFMSUdOX0FMV0FZUykgPyBTY3JvbGxBbGlnbm1lbnQ6OmFs aWduVG9wQWx3YXlzIDogU2Nyb2xsQWxpZ25tZW50OjphbGlnblRvRWRnZUlmTmVlZGVkOworI2Vu ZGlmCisgICAgICAgIG1fZnJhbWUtPnJldmVhbFNlbGVjdGlvbihhbGlnbm1lbnQsIHRydWUpOwor ICAgIH0KIAogICAgIG5vdGlmeUFjY2Vzc2liaWxpdHlGb3JTZWxlY3Rpb25DaGFuZ2UoKTsKIH0K QEAgLTcxNCw3ICs3MjAsNyBAQCBzdGF0aWMgYm9vbCBhYnNvbHV0ZUNhcmV0WShjb25zdCBWaXNp YmxlCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKLWJvb2wgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW9k aWZ5KEVBbHRlcmF0aW9uIGFsdGVyLCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJp Z2dlcmVkKQorYm9vbCBTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkoRUFsdGVyYXRpb24gYWx0 ZXIsIGludCB2ZXJ0aWNhbERpc3RhbmNlLCBib29sIHVzZXJUcmlnZ2VyZWQsIEVTY3JvbGxDdXJz b3JBbGlnbm1lbnQgY3Vyc29yQWxpZ25tZW50KQogewogICAgIGlmICh2ZXJ0aWNhbERpc3RhbmNl ID09IDApCiAgICAgICAgIHJldHVybiBmYWxzZTsKQEAgLTc4Miw3ICs3ODgsNyBAQCBib29sIFNl bGVjdGlvbkNvbnRyb2xsZXI6Om1vZGlmeShFQWx0ZXJhCiAKICAgICBzd2l0Y2ggKGFsdGVyKSB7 CiAgICAgICAgIGNhc2UgTU9WRToKLSAgICAgICAgICAgIG1vdmVUbyhyZXN1bHQsIHVzZXJUcmln Z2VyZWQpOworICAgICAgICAgICAgbW92ZVRvKHJlc3VsdCwgdXNlclRyaWdnZXJlZCwgY3Vyc29y QWxpZ25tZW50KTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIEVYVEVORDoKICAg ICAgICAgICAgIHNldEV4dGVudChyZXN1bHQsIHVzZXJUcmlnZ2VyZWQpOwpJbmRleDogV2ViQ29y ZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2Vk aXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oCShyZXZpc2lvbiA1ODU5NykKKysrIFdlYkNvcmUv ZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTQ1LDYgKzQ1 LDcgQEAgY2xhc3MgU2VsZWN0aW9uQ29udHJvbGxlciA6IHB1YmxpYyBOb25jbwogcHVibGljOgog ICAgIGVudW0gRUFsdGVyYXRpb24geyBNT1ZFLCBFWFRFTkQgfTsKICAgICBlbnVtIEVEaXJlY3Rp b24geyBGT1JXQVJELCBCQUNLV0FSRCwgUklHSFQsIExFRlQgfTsKKyAgICBlbnVtIEVTY3JvbGxD dXJzb3JBbGlnbm1lbnQgeyBBTElHTl9JRl9ORUVERUQsIEFMSUdOX0FMV0FZUyB9OwogCiAgICAg U2VsZWN0aW9uQ29udHJvbGxlcihGcmFtZSogPSAwLCBib29sIGlzRHJhZ0NhcmV0Q29udHJvbGxl ciA9IGZhbHNlKTsKIApAQCAtNTQsMTQgKzU1LDE0IEBAIHB1YmxpYzoKICAgICBOb2RlKiBzaGFk b3dUcmVlUm9vdE5vZGUoKSBjb25zdCB7IHJldHVybiBtX3NlbGVjdGlvbi5zaGFkb3dUcmVlUm9v dE5vZGUoKTsgfQogICAgICAKICAgICB2b2lkIG1vdmVUbyhjb25zdCBSYW5nZSosIEVBZmZpbml0 eSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwotICAgIHZvaWQgbW92ZVRvKGNvbnN0IFZp c2libGVQb3NpdGlvbiYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKKyAgICB2b2lkIG1v dmVUbyhjb25zdCBWaXNpYmxlUG9zaXRpb24mLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSwg RVNjcm9sbEN1cnNvckFsaWdubWVudCBjdXJzb3JBbGlnbm1lbnQgPSBBTElHTl9JRl9ORUVERUQp OwogICAgIHZvaWQgbW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlvbiYsIGNvbnN0IFZpc2libGVQ b3NpdGlvbiYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKICAgICB2b2lkIG1vdmVUbyhj b25zdCBQb3NpdGlvbiYsIEVBZmZpbml0eSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwog ICAgIHZvaWQgbW92ZVRvKGNvbnN0IFBvc2l0aW9uJiwgY29uc3QgUG9zaXRpb24mLCBFQWZmaW5p dHksIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKIAogICAgIGNvbnN0IFZpc2libGVTZWxl Y3Rpb24mIHNlbGVjdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uOyB9Ci0gICAgdm9p ZCBzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgY2xvc2VUeXBpbmcg PSB0cnVlLCBib29sIGNsZWFyVHlwaW5nU3R5bGUgPSB0cnVlLCBib29sIHVzZXJUcmlnZ2VyZWQg PSBmYWxzZSwgVGV4dEdyYW51bGFyaXR5ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHkpOwotICAgIHZv aWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHNlbGVjdGlvbiwgVGV4dEdy YW51bGFyaXR5IGdyYW51bGFyaXR5KSB7IHNldFNlbGVjdGlvbihzZWxlY3Rpb24sIHRydWUsIHRy dWUsIGZhbHNlLCBncmFudWxhcml0eSk7IH0KKyAgICB2b2lkIHNldFNlbGVjdGlvbihjb25zdCBW aXNpYmxlU2VsZWN0aW9uJiwgYm9vbCBjbG9zZVR5cGluZyA9IHRydWUsIGJvb2wgY2xlYXJUeXBp bmdTdHlsZSA9IHRydWUsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBFU2Nyb2xsQ3Vyc29y QWxpZ25tZW50IGN1cnNvckFsaWdubWVudCA9IEFMSUdOX0lGX05FRURFRCwgVGV4dEdyYW51bGFy aXR5ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHkpOworICAgIHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0 IFZpc2libGVTZWxlY3Rpb24mIHNlbGVjdGlvbiwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5 KSB7IHNldFNlbGVjdGlvbihzZWxlY3Rpb24sIHRydWUsIHRydWUsIGZhbHNlLCBBTElHTl9JRl9O RUVERUQsIGdyYW51bGFyaXR5KTsgfQogICAgIGJvb2wgc2V0U2VsZWN0ZWRSYW5nZShSYW5nZSos IEVBZmZpbml0eSwgYm9vbCBjbG9zZVR5cGluZyk7CiAgICAgdm9pZCBzZWxlY3RBbGwoKTsKICAg ICB2b2lkIGNsZWFyKCk7CkBAIC03Niw3ICs3Nyw3IEBAIHB1YmxpYzoKICAgICBFQWZmaW5pdHkg YWZmaW5pdHkoKSBjb25zdCB7IHJldHVybiBtX3NlbGVjdGlvbi5hZmZpbml0eSgpOyB9CiAKICAg ICBib29sIG1vZGlmeShFQWx0ZXJhdGlvbiwgRURpcmVjdGlvbiwgVGV4dEdyYW51bGFyaXR5LCBi b29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7Ci0gICAgYm9vbCBtb2RpZnkoRUFsdGVyYXRpb24s IGludCB2ZXJ0aWNhbERpc3RhbmNlLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CisgICAg Ym9vbCBtb2RpZnkoRUFsdGVyYXRpb24sIGludCB2ZXJ0aWNhbERpc3RhbmNlLCBib29sIHVzZXJU cmlnZ2VyZWQgPSBmYWxzZSwgRVNjcm9sbEN1cnNvckFsaWdubWVudCBjdXJzb3JBbGlnbm1lbnQg PSBBTElHTl9JRl9ORUVERUQpOwogICAgIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSgpIGNv bnN0IHsgcmV0dXJuIG1fZ3JhbnVsYXJpdHk7IH0KIAogICAgIHZvaWQgc2V0U3RhcnQoY29uc3Qg VmlzaWJsZVBvc2l0aW9uICYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKSW5kZXg6IExh eW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJ KHJldmlzaW9uIDU4NTk3KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkp CkBAIC0xLDMgKzEsMTIgQEAKKzIwMTAtMDQtMzAgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJh Z0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgRml4ZWQgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBleHBlY3RhdGlvbnMgZm9yIGJ1 ZzoKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4MjEz CisKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbDoKKwog MjAxMC0wNC0zMCAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAK ICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjU4NTY5LgpJbmRleDogTGF5b3V0VGVz dHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLmh0bWwKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g TGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLmh0bWwJKHJldmlz aW9uIDU4NTk3KQorKysgTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1k b3duLmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTIwLDE4ICsyMCwxOCBAQCBmdW5jdGlvbiBydW5U ZXN0KCkKIAogICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3duIiwgbW9kaWZpZXJzKTsK ICAgICB2YXIgbGluZSA9IGZyYW1lLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsK LSAgICBpZiAobGluZSAhPSAibGluZSA4IikKLSAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQg YmUgYXQgbGluZSA4LCBub3QgIiArIGxpbmU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUgMyIpCisg ICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMywgbm90ICIgKyBsaW5lOwog CiAgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBtb2RpZmllcnMpOwogICAgIHZh ciBsaW5lID0gZnJhbWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOwotICAgIGlm IChsaW5lICE9ICJsaW5lIDkiKQotICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBs aW5lIDksIG5vdCAiICsgbGluZTsKKyAgICBpZiAobGluZSAhPSAibGluZSA2IikKKyAgICAgICAg dGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSA2LCBub3QgIiArIGxpbmU7CiAKICAgICBl dmVudFNlbmRlci5rZXlEb3duKCJwYWdlVXAiLCBtb2RpZmllcnMpOwogICAgIHZhciBsaW5lID0g ZnJhbWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOwotICAgIGlmIChsaW5lICE9 ICJsaW5lIDEiKQotICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDEsIG5v dCAiICsgbGluZTsKKyAgICBpZiAobGluZSAhPSAibGluZSAzIikKKyAgICAgICAgdGhyb3cgImN1 cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7CiAKICAgICBkb2N1bWVudC5n ZXRFbGVtZW50QnlJZCgicmVzdWx0cyIpLmlubmVyVGV4dCA9ICJQQVNTIjsKIH0K 54838 2010-04-30 17:20:08 -0700 2010-05-03 11:59:35 -0700 fixed mac link issues and scroll behavior, other comments addressed WK_38213.patch text/plain 12471 zelidrag SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1ODU5NykKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjYgQEAKKzIwMTAtMDQtMzAgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgRml4ZWQgZnJhbWUgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBjYWxjdWxhdGlvbiwgbWFk ZSBzdXJlIHRoYXQgdGhlCisgICAgICAgIGN1cnNvciBtb3ZlcyB3aXRoIHBhZ2UgdXAvZG93biBh cyB3ZWxsLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MzgyMTMKKworICAgICAgICBUZXN0OiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24u aHRtbCAgKGZpeGVkKQorCisgICAgICAgICogZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcDoKKyAg ICAgICAgKFdlYkNvcmU6OnZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UpOiBGaXhlZCBwYWdlIHNjcm9s bCBjYWxjdWxhdGlvbi4gTm93IHNjcm9sbCBoZWlnaHQgaXMgY2FsY3VsYXRlZCBvbmx5IGZyb20g dGhlIHZpc2libGUgcG9ydGlvbiBub3QgdGhlIGVudGlyZSBmcmFtZSBoZWlnaHQuCisgICAgICAg IChXZWJDb3JlOjpleGVjdXRlTW92ZVBhZ2VEb3duKTogTm93IHRlbGxzIFNlbGVjdGlvbkNvbnRy b2xsZXIgdG8gbW92ZSB0aGUgY3Vyc29yIHdpdGggdGhlIHBhZ2Ugc2Nyb2xsIHVwL2Rvd24uCisg ICAgICAgIChXZWJDb3JlOjpleGVjdXRlTW92ZVBhZ2VEb3duQW5kTW9kaWZ5U2VsZWN0aW9uKToK KyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVNb3ZlUGFnZVVwKToKKyAgICAgICAgKFdlYkNvcmU6 OmV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2VsZWN0aW9uKToKKyAgICAgICAgKiBlZGl0aW5n L1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOiBFeHBvc2VkIGEgcGFyYW0gdGhhdCBsZXRzIEVkaXRv ckNvbW1hbmQuY3BwIGNvbnRyb2wgaG93IGN1cnNvciBwb3NpdGlvbiB3aWxsIGJlIGFsaWduZWQg d2hlbiBwYWdlIG1vdmVzLgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6 bW92ZVRvKToKKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVj dGlvbik6CisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOgor ICAgICAgICAqIGVkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oOgorICAgICAgICAoV2ViQ29y ZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKToKKwogMjAxMC0wNC0zMCAgU2hl cmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZp ZXdlZCwgcm9sbGluZyBvdXQgcjU4NTY5LgpJbmRleDogV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS5iYXNlLmV4cAkocmV2aXNpb24gNTg1OTcp CisrKyBXZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAJKHdvcmtpbmcgY29weSkKQEAgLTQxNSw3ICs0 MTUsNyBAQCBfX1pON1dlYkNvcmUxOUFuaW1hdGlvbkNvbnRyb2xsZXIyMXBhdXNlCiBfX1pON1dl YkNvcmUxOUNTU1N0eWxlRGVjbGFyYXRpb24xMXNldFByb3BlcnR5RVJLTlNfNlN0cmluZ0VTM19S aQogX19aTjdXZWJDb3JlMTlJbnNwZWN0b3JDb250cm9sbGVyMzRpbnNwZWN0b3JTdGFydHNBdHRh Y2hlZFNldHRpbmdOYW1lRXYKIF9fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjEwc2V0 Rm9jdXNlZEViCi1fX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIxMnNldFNlbGVjdGlv bkVSS05TXzE2VmlzaWJsZVNlbGVjdGlvbkViYmJOU18xNVRleHRHcmFudWxhcml0eUUKK19fWk43 V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjEyc2V0U2VsZWN0aW9uRVJLTlNfMTZWaXNpYmxl U2VsZWN0aW9uRWJiYk5TMF8yMkVTY3JvbGxDdXJzb3JBbGlnbm1lbnRFTlNfMTVUZXh0R3JhbnVs YXJpdHlFCiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIxNnNldFNlbGVjdGVkUmFu Z2VFUE5TXzVSYW5nZUVOU185RUFmZmluaXR5RWIKIF9fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29u dHJvbGxlcjVjbGVhckV2CiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXI2bW9kaWZ5 RU5TMF8xMUVBbHRlcmF0aW9uRU5TMF8xMEVEaXJlY3Rpb25FTlNfMTVUZXh0R3JhbnVsYXJpdHlF YgpJbmRleDogV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcAkocmV2aXNpb24gNTg1OTcpCisrKyBX ZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQxLDYg KzQxLDcgQEAKICNpbmNsdWRlICJFdmVudEhhbmRsZXIuaCIKICNpbmNsdWRlICJGb3JtYXRCbG9j a0NvbW1hbmQuaCIKICNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lVmlldy5oIgog I2luY2x1ZGUgIkhUTUxGb250RWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxIUkVsZW1lbnQuaCIK ICNpbmNsdWRlICJIVE1MSW1hZ2VFbGVtZW50LmgiCkBAIC0yNTksNyArMjYwLDcgQEAgc3RhdGlj IGludCB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKEZyYW1lKgogICAgICAgICByZXR1cm4gMDsKICAg ICBpZiAoIShzdHlsZS0+b3ZlcmZsb3dZKCkgPT0gT1NDUk9MTCB8fCBzdHlsZS0+b3ZlcmZsb3dZ KCkgPT0gT0FVVE8gfHwgZm9jdXNlZE5vZGUtPmlzQ29udGVudEVkaXRhYmxlKCkpKQogICAgICAg ICByZXR1cm4gMDsKLSAgICBpbnQgaGVpZ2h0ID0gdG9SZW5kZXJCb3gocmVuZGVyZXIpLT5jbGll bnRIZWlnaHQoKTsKKyAgICBpbnQgaGVpZ2h0ID0gZnJhbWUtPnZpZXcoKS0+dmlzaWJsZUhlaWdo dCgpOwogICAgIHJldHVybiBtYXgobWF4PGludD4oaGVpZ2h0ICogU2Nyb2xsYmFyOjptaW5GcmFj dGlvblRvU3RlcFdoZW5QYWdpbmcoKSwgaGVpZ2h0IC0gU2Nyb2xsYmFyOjptYXhPdmVybGFwQmV0 d2VlblBhZ2VzKCkpLCAxKTsKIH0KIApAQCAtNjQ2LDcgKzY0Nyw3IEBAIHN0YXRpYyBib29sIGV4 ZWN1dGVNb3ZlUGFnZURvd24oRnJhbWUqIGYKICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNj cm9sbERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4g ZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNv bnRyb2xsZXI6Ok1PVkUsIGRpc3RhbmNlLCB0cnVlKTsKKyAgICByZXR1cm4gZnJhbWUtPnNlbGVj dGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6TU9WRSwgZGlzdGFuY2UsIHRydWUs IFNlbGVjdGlvbkNvbnRyb2xsZXI6OkFMSUdOX0FMV0FZUyk7CiB9CiAKIHN0YXRpYyBib29sIGV4 ZWN1dGVNb3ZlUGFnZURvd25BbmRNb2RpZnlTZWxlY3Rpb24oRnJhbWUqIGZyYW1lLCBFdmVudCos IEVkaXRvckNvbW1hbmRTb3VyY2UsIGNvbnN0IFN0cmluZyYpCkBAIC02NTQsNyArNjU1LDcgQEAg c3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlmeQogICAgIGludCBkaXN0YW5j ZSA9IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoZnJhbWUpOwogICAgIGlmICghZGlzdGFuY2UpCiAg ICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2Rp ZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCBkaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0 dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6OkVYVEVO RCwgZGlzdGFuY2UsIHRydWUsIFNlbGVjdGlvbkNvbnRyb2xsZXI6OkFMSUdOX0FMV0FZUyk7CiB9 CiAKIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwKEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBF ZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpAQCAtNjYyLDcgKzY2Myw3IEBAIHN0 YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwKEZyYW1lKiBmcmEKICAgICBpbnQgZGlzdGFuY2Ug PSB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAg ICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5 KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1kaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0dXJu IGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1k aXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6QUxJR05fQUxXQVlTKTsKIH0KIAog c3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlVXBBbmRNb2RpZnlTZWxlY3Rpb24oRnJhbWUqIGZy YW1lLCBFdmVudCosIEVkaXRvckNvbW1hbmRTb3VyY2UsIGNvbnN0IFN0cmluZyYpCkBAIC02NzAs NyArNjcxLDcgQEAgc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlVXBBbmRNb2RpZnlTZQogICAg IGludCBkaXN0YW5jZSA9IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoZnJhbWUpOwogICAgIGlmICgh ZGlzdGFuY2UpCiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVj dGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCAtZGlzdGFuY2UsIHRy dWUpOworICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250 cm9sbGVyOjpFWFRFTkQsIC1kaXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6QUxJ R05fQUxXQVlTKTsKIH0KIAogc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVSaWdodChGcmFtZSogZnJh bWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3QgU3RyaW5nJikKSW5kZXg6IFdl YkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAJKHJldmlzaW9uIDU4NTk3KQorKysg V2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC03OSw5ICs3OSw5IEBAIFNlbGVjdGlvbkNvbnRyb2xsZXI6OlNlbGVjdGlvbkNvbnRyb2xsZXIK ICAgICBzZXRJc0RpcmVjdGlvbmFsKGZhbHNlKTsKIH0KIAotdm9pZCBTZWxlY3Rpb25Db250cm9s bGVyOjptb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZwb3MsIGJvb2wgdXNlclRyaWdnZXJl ZCkKK3ZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlv biAmcG9zLCBib29sIHVzZXJUcmlnZ2VyZWQsIEVTY3JvbGxDdXJzb3JBbGlnbm1lbnQgY3Vyc29y QWxpZ25tZW50KQogewotICAgIHNldFNlbGVjdGlvbihWaXNpYmxlU2VsZWN0aW9uKHBvcy5kZWVw RXF1aXZhbGVudCgpLCBwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmFmZmluaXR5KCkpLCB0cnVl LCB0cnVlLCB1c2VyVHJpZ2dlcmVkKTsKKyAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlv bihwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmRlZXBFcXVpdmFsZW50KCksIHBvcy5hZmZpbml0 eSgpKSwgdHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCwgY3Vyc29yQWxpZ25tZW50KTsKIH0KIAog dm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjptb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZi YXNlLCBjb25zdCBWaXNpYmxlUG9zaXRpb24gJmV4dGVudCwgYm9vbCB1c2VyVHJpZ2dlcmVkKQpA QCAtMTA1LDcgKzEwNSw3IEBAIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0 IFAKICAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlvbihiYXNlLCBleHRlbnQsIGFmZmlu aXR5KSwgdHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCk7CiB9CiAKLXZvaWQgU2VsZWN0aW9uQ29u dHJvbGxlcjo6c2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHMsIGJvb2wgY2xv c2VUeXBpbmcsIGJvb2wgY2xlYXJUeXBpbmdTdHlsZSwgYm9vbCB1c2VyVHJpZ2dlcmVkLCBUZXh0 R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkpCit2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNl bGVjdGlvbihjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzLCBib29sIGNsb3NlVHlwaW5nLCBib29s IGNsZWFyVHlwaW5nU3R5bGUsIGJvb2wgdXNlclRyaWdnZXJlZCwgRVNjcm9sbEN1cnNvckFsaWdu bWVudCBjdXJzb3JBbGlnbm1lbnQsIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSkKIHsKICAg ICBtX2dyYW51bGFyaXR5ID0gZ3JhbnVsYXJpdHk7CiAKQEAgLTE2MSw4ICsxNjEsMTQgQEAgdm9p ZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb24oYwogICAgIHNlbGVjdEZyYW1lRWxl bWVudEluUGFyZW50SWZGdWxseVNlbGVjdGVkKCk7CiAgICAgbV9mcmFtZS0+bm90aWZ5UmVuZGVy ZXJPZlNlbGVjdGlvbkNoYW5nZSh1c2VyVHJpZ2dlcmVkKTsKICAgICBtX2ZyYW1lLT5yZXNwb25k VG9DaGFuZ2VkU2VsZWN0aW9uKG9sZFNlbGVjdGlvbiwgY2xvc2VUeXBpbmcpOwotICAgIGlmICh1 c2VyVHJpZ2dlcmVkKQotICAgICAgICBtX2ZyYW1lLT5yZXZlYWxTZWxlY3Rpb24oU2Nyb2xsQWxp Z25tZW50OjphbGlnblRvRWRnZUlmTmVlZGVkLCB0cnVlKTsKKyAgICBpZiAodXNlclRyaWdnZXJl ZCkgeworI2lmIE9TKERBUldJTikKKyAgICAgICAgY29uc3QgU2Nyb2xsQWxpZ25tZW50JiBhbGln bm1lbnQgPSAoY3Vyc29yQWxpZ25tZW50ID09IEFMSUdOX0FMV0FZUykgPyBTY3JvbGxBbGlnbm1l bnQ6OmFsaWduQ2VudGVyQWx3YXlzIDogU2Nyb2xsQWxpZ25tZW50OjphbGlnbkNlbnRlcklmTmVl ZGVkOworI2Vsc2UKKyAgICAgICAgY29uc3QgU2Nyb2xsQWxpZ25tZW50JiBhbGlnbm1lbnQgPSAo Y3Vyc29yQWxpZ25tZW50ID09IEFMSUdOX0FMV0FZUykgPyBTY3JvbGxBbGlnbm1lbnQ6OmFsaWdu VG9wQWx3YXlzIDogU2Nyb2xsQWxpZ25tZW50OjphbGlnblRvRWRnZUlmTmVlZGVkOworI2VuZGlm CisgICAgICAgIG1fZnJhbWUtPnJldmVhbFNlbGVjdGlvbihhbGlnbm1lbnQsIHRydWUpOworICAg IH0KIAogICAgIG5vdGlmeUFjY2Vzc2liaWxpdHlGb3JTZWxlY3Rpb25DaGFuZ2UoKTsKIH0KQEAg LTcxNCw3ICs3MjAsNyBAQCBzdGF0aWMgYm9vbCBhYnNvbHV0ZUNhcmV0WShjb25zdCBWaXNpYmxl CiAgICAgcmV0dXJuIHRydWU7CiB9CiAKLWJvb2wgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5 KEVBbHRlcmF0aW9uIGFsdGVyLCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dl cmVkKQorYm9vbCBTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkoRUFsdGVyYXRpb24gYWx0ZXIs IGludCB2ZXJ0aWNhbERpc3RhbmNlLCBib29sIHVzZXJUcmlnZ2VyZWQsIEVTY3JvbGxDdXJzb3JB bGlnbm1lbnQgY3Vyc29yQWxpZ25tZW50KQogewogICAgIGlmICh2ZXJ0aWNhbERpc3RhbmNlID09 IDApCiAgICAgICAgIHJldHVybiBmYWxzZTsKQEAgLTc4Miw3ICs3ODgsNyBAQCBib29sIFNlbGVj dGlvbkNvbnRyb2xsZXI6Om1vZGlmeShFQWx0ZXJhCiAKICAgICBzd2l0Y2ggKGFsdGVyKSB7CiAg ICAgICAgIGNhc2UgTU9WRToKLSAgICAgICAgICAgIG1vdmVUbyhyZXN1bHQsIHVzZXJUcmlnZ2Vy ZWQpOworICAgICAgICAgICAgbW92ZVRvKHJlc3VsdCwgdXNlclRyaWdnZXJlZCwgY3Vyc29yQWxp Z25tZW50KTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIEVYVEVORDoKICAgICAg ICAgICAgIHNldEV4dGVudChyZXN1bHQsIHVzZXJUcmlnZ2VyZWQpOwpJbmRleDogV2ViQ29yZS9l ZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2VkaXRp bmcvU2VsZWN0aW9uQ29udHJvbGxlci5oCShyZXZpc2lvbiA1ODU5NykKKysrIFdlYkNvcmUvZWRp dGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmgJKHdvcmtpbmcgY29weSkKQEAgLTQ1LDYgKzQ1LDcg QEAgY2xhc3MgU2VsZWN0aW9uQ29udHJvbGxlciA6IHB1YmxpYyBOb25jbwogcHVibGljOgogICAg IGVudW0gRUFsdGVyYXRpb24geyBNT1ZFLCBFWFRFTkQgfTsKICAgICBlbnVtIEVEaXJlY3Rpb24g eyBGT1JXQVJELCBCQUNLV0FSRCwgUklHSFQsIExFRlQgfTsKKyAgICBlbnVtIEVTY3JvbGxDdXJz b3JBbGlnbm1lbnQgeyBBTElHTl9JRl9ORUVERUQsIEFMSUdOX0FMV0FZUyB9OwogCiAgICAgU2Vs ZWN0aW9uQ29udHJvbGxlcihGcmFtZSogPSAwLCBib29sIGlzRHJhZ0NhcmV0Q29udHJvbGxlciA9 IGZhbHNlKTsKIApAQCAtNTQsMTQgKzU1LDE0IEBAIHB1YmxpYzoKICAgICBOb2RlKiBzaGFkb3dU cmVlUm9vdE5vZGUoKSBjb25zdCB7IHJldHVybiBtX3NlbGVjdGlvbi5zaGFkb3dUcmVlUm9vdE5v ZGUoKTsgfQogICAgICAKICAgICB2b2lkIG1vdmVUbyhjb25zdCBSYW5nZSosIEVBZmZpbml0eSwg Ym9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwotICAgIHZvaWQgbW92ZVRvKGNvbnN0IFZpc2li bGVQb3NpdGlvbiYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKKyAgICB2b2lkIG1vdmVU byhjb25zdCBWaXNpYmxlUG9zaXRpb24mLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSwgRVNj cm9sbEN1cnNvckFsaWdubWVudCBjdXJzb3JBbGlnbm1lbnQgPSBBTElHTl9JRl9ORUVERUQpOwog ICAgIHZvaWQgbW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlvbiYsIGNvbnN0IFZpc2libGVQb3Np dGlvbiYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKICAgICB2b2lkIG1vdmVUbyhjb25z dCBQb3NpdGlvbiYsIEVBZmZpbml0eSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwogICAg IHZvaWQgbW92ZVRvKGNvbnN0IFBvc2l0aW9uJiwgY29uc3QgUG9zaXRpb24mLCBFQWZmaW5pdHks IGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKIAogICAgIGNvbnN0IFZpc2libGVTZWxlY3Rp b24mIHNlbGVjdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uOyB9Ci0gICAgdm9pZCBz ZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgY2xvc2VUeXBpbmcgPSB0 cnVlLCBib29sIGNsZWFyVHlwaW5nU3R5bGUgPSB0cnVlLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBm YWxzZSwgVGV4dEdyYW51bGFyaXR5ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHkpOwotICAgIHZvaWQg c2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHNlbGVjdGlvbiwgVGV4dEdyYW51 bGFyaXR5IGdyYW51bGFyaXR5KSB7IHNldFNlbGVjdGlvbihzZWxlY3Rpb24sIHRydWUsIHRydWUs IGZhbHNlLCBncmFudWxhcml0eSk7IH0KKyAgICB2b2lkIHNldFNlbGVjdGlvbihjb25zdCBWaXNp YmxlU2VsZWN0aW9uJiwgYm9vbCBjbG9zZVR5cGluZyA9IHRydWUsIGJvb2wgY2xlYXJUeXBpbmdT dHlsZSA9IHRydWUsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBFU2Nyb2xsQ3Vyc29yQWxp Z25tZW50IGN1cnNvckFsaWdubWVudCA9IEFMSUdOX0lGX05FRURFRCwgVGV4dEdyYW51bGFyaXR5 ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHkpOworICAgIHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZp c2libGVTZWxlY3Rpb24mIHNlbGVjdGlvbiwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5KSB7 IHNldFNlbGVjdGlvbihzZWxlY3Rpb24sIHRydWUsIHRydWUsIGZhbHNlLCBBTElHTl9JRl9ORUVE RUQsIGdyYW51bGFyaXR5KTsgfQogICAgIGJvb2wgc2V0U2VsZWN0ZWRSYW5nZShSYW5nZSosIEVB ZmZpbml0eSwgYm9vbCBjbG9zZVR5cGluZyk7CiAgICAgdm9pZCBzZWxlY3RBbGwoKTsKICAgICB2 b2lkIGNsZWFyKCk7CkBAIC03Niw3ICs3Nyw3IEBAIHB1YmxpYzoKICAgICBFQWZmaW5pdHkgYWZm aW5pdHkoKSBjb25zdCB7IHJldHVybiBtX3NlbGVjdGlvbi5hZmZpbml0eSgpOyB9CiAKICAgICBi b29sIG1vZGlmeShFQWx0ZXJhdGlvbiwgRURpcmVjdGlvbiwgVGV4dEdyYW51bGFyaXR5LCBib29s IHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7Ci0gICAgYm9vbCBtb2RpZnkoRUFsdGVyYXRpb24sIGlu dCB2ZXJ0aWNhbERpc3RhbmNlLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CisgICAgYm9v bCBtb2RpZnkoRUFsdGVyYXRpb24sIGludCB2ZXJ0aWNhbERpc3RhbmNlLCBib29sIHVzZXJUcmln Z2VyZWQgPSBmYWxzZSwgRVNjcm9sbEN1cnNvckFsaWdubWVudCBjdXJzb3JBbGlnbm1lbnQgPSBB TElHTl9JRl9ORUVERUQpOwogICAgIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSgpIGNvbnN0 IHsgcmV0dXJuIG1fZ3JhbnVsYXJpdHk7IH0KIAogICAgIHZvaWQgc2V0U3RhcnQoY29uc3QgVmlz aWJsZVBvc2l0aW9uICYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKSW5kZXg6IExheW91 dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDU4NTk3KQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMTIgQEAKKzIwMTAtMDQtMzAgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgRml4ZWQgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBleHBlY3RhdGlvbnMgZm9yIGJ1ZzoK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4MjEzCisK KyAgICAgICAgKiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbDoKKwogMjAx MC0wNC0zMCAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAg ICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjU4NTY5LgpJbmRleDogTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLmh0bWwKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLmh0bWwJKHJldmlzaW9u IDU4NTk3KQorKysgTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3du Lmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTIwLDE4ICsyMCwxOCBAQCBmdW5jdGlvbiBydW5UZXN0 KCkKIAogICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3duIiwgbW9kaWZpZXJzKTsKICAg ICB2YXIgbGluZSA9IGZyYW1lLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKLSAg ICBpZiAobGluZSAhPSAibGluZSA4IikKLSAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUg YXQgbGluZSA4LCBub3QgIiArIGxpbmU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUgMyIpCisgICAg ICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMywgbm90ICIgKyBsaW5lOwogCiAg ICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBtb2RpZmllcnMpOwogICAgIHZhciBs aW5lID0gZnJhbWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOwotICAgIGlmIChs aW5lICE9ICJsaW5lIDkiKQotICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5l IDksIG5vdCAiICsgbGluZTsKKyAgICBpZiAobGluZSAhPSAibGluZSA2IikKKyAgICAgICAgdGhy b3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSA2LCBub3QgIiArIGxpbmU7CiAKICAgICBldmVu dFNlbmRlci5rZXlEb3duKCJwYWdlVXAiLCBtb2RpZmllcnMpOwogICAgIHZhciBsaW5lID0gZnJh bWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOwotICAgIGlmIChsaW5lICE9ICJs aW5lIDEiKQotICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDEsIG5vdCAi ICsgbGluZTsKKyAgICBpZiAobGluZSAhPSAibGluZSAzIikKKyAgICAgICAgdGhyb3cgImN1cnNv ciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7CiAKICAgICBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgicmVzdWx0cyIpLmlubmVyVGV4dCA9ICJQQVNTIjsKIH0K 54949 2010-05-03 11:59:35 -0700 2010-05-07 16:50:06 -0700 added additional test for testing visual viewport of scrolled frame WK_38213.patch text/plain 0 zelidrag 55433 2010-05-07 16:50:06 -0700 2010-05-14 13:06:44 -0700 Addressed the latest set of comments WK_38213.patch text/plain 16802 zelidrag SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1ODk2MikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzEgQEAKKzIwMTAtMDUtMDcgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgRml4ZWQgZnJhbWUgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBjYWxjdWxhdGlvbi4gTWFk ZSBzdXJlIHRoYXQgdGhlCisgICAgICAgIGN1cnNvciBtb3ZlcyB3aXRoIHBhZ2UgdXAvZG93biBh cyB3ZWxsLiBQbGVhc2Ugbm90ZSB0aGF0IG5vdyBPUyhEQVJXSU4pCisgICAgICAgIGltcGxlbWVu dGF0aW9uIHdpbGwgbm93IGNlbnRlciB0aGUgY2VudGVyIHRoZSBjdXJzb3Igb24gcGFnZSB1cC9k b3duCisgICAgICAgIHdoaWxlIG90aGVyIHBsYXRmb3JtcyB3aWxsIGFsaWduIHRoZSBjdXJzb3Ig d2l0aCB0aGUgdG9wIG9mIGRpc3BsYXllZAorICAgICAgICBmcmFtZS4KKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4MjEzCisKKyAgICAgICAgVGVzdDog ZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLmh0bWwgKGZpeGVkKQorICAgICAgICBU ZXN0OiBlZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24uaHRtbCAoYWRk ZWQpCisKKyAgICAgICAgKiBXZWJDb3JlLmJhc2UuZXhwOgorICAgICAgICAqIGVkaXRpbmcvRWRp dG9yQ29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjp2ZXJ0aWNhbFNjcm9sbERpc3RhbmNl KTogRml4ZWQgcGFnZSBzY3JvbGwgY2FsY3VsYXRpb24uIE5vdyBzY3JvbGwgaGVpZ2h0IGlzIGNh bGN1bGF0ZWQgb25seSBmcm9tIHRoZSB2aXNpYmxlIHBvcnRpb24gbm90IHRoZSBlbnRpcmUgZnJh bWUgaGVpZ2h0LgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZU1vdmVQYWdlRG93bik6IE5vdyBp dCBjYW4gdGVsbCBTZWxlY3Rpb25Db250cm9sbGVyIHRvIG1vdmUgdGhlIGN1cnNvciB3aXRoIHRo ZSBwYWdlIHNjcm9sbCB1cC9kb3duIGV2ZW50cy4KKyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVN b3ZlUGFnZURvd25BbmRNb2RpZnlTZWxlY3Rpb24pOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6 OmV4ZWN1dGVNb3ZlUGFnZVVwKTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpleGVjdXRlTW92 ZVBhZ2VVcEFuZE1vZGlmeVNlbGVjdGlvbik6IERpdHRvLgorICAgICAgICAqIGVkaXRpbmcvU2Vs ZWN0aW9uQ29udHJvbGxlci5jcHA6IEV4cG9zZWQgYW4gZW51bSBwYXJhbSB0aGF0IGxldHMgRWRp dG9yQ29tbWFuZC5jcHAgY29udHJvbCBob3cgY3Vyc29yIHBvc2l0aW9uIHdpbGwgYmUgYWxpZ25l ZCB3aGVuIHBhZ2UgbW92ZXMuCisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVy Ojptb3ZlVG8pOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6 OnNldFNlbGVjdGlvbik6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJv bGxlcjo6bW9kaWZ5KTogRGl0dG8uCisgICAgICAgICogZWRpdGluZy9TZWxlY3Rpb25Db250cm9s bGVyLmg6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0 U2VsZWN0aW9uKTogRGl0dG8uCisKIDIwMTAtMDUtMDcgIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZy YXNlckBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFuIEJlcm5zdGVpbi4KSW5k ZXg6IFdlYkNvcmUvV2ViQ29yZS5iYXNlLmV4cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL1dlYkNv cmUuYmFzZS5leHAJKHJldmlzaW9uIDU4OTYyKQorKysgV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhw CSh3b3JraW5nIGNvcHkpCkBAIC00MTUsNyArNDE1LDcgQEAgX19aTjdXZWJDb3JlMTlBbmltYXRp b25Db250cm9sbGVyMjFwYXVzZQogX19aTjdXZWJDb3JlMTlDU1NTdHlsZURlY2xhcmF0aW9uMTFz ZXRQcm9wZXJ0eUVSS05TXzZTdHJpbmdFUzNfUmkKIF9fWk43V2ViQ29yZTE5SW5zcGVjdG9yQ29u dHJvbGxlcjM0aW5zcGVjdG9yU3RhcnRzQXR0YWNoZWRTZXR0aW5nTmFtZUV2CiBfX1pON1dlYkNv cmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIxMHNldEZvY3VzZWRFYgotX19aTjdXZWJDb3JlMTlTZWxl Y3Rpb25Db250cm9sbGVyMTJzZXRTZWxlY3Rpb25FUktOU18xNlZpc2libGVTZWxlY3Rpb25FYmJi TlNfMTVUZXh0R3JhbnVsYXJpdHlFCitfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIx MnNldFNlbGVjdGlvbkVSS05TXzE2VmlzaWJsZVNlbGVjdGlvbkViYmJOUzBfMjJFU2Nyb2xsQ3Vy c29yQWxpZ25tZW50RU5TXzE1VGV4dEdyYW51bGFyaXR5RQogX19aTjdXZWJDb3JlMTlTZWxlY3Rp b25Db250cm9sbGVyMTZzZXRTZWxlY3RlZFJhbmdlRVBOU181UmFuZ2VFTlNfOUVBZmZpbml0eUVi CiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXI1Y2xlYXJFdgogX19aTjdXZWJDb3Jl MTlTZWxlY3Rpb25Db250cm9sbGVyNm1vZGlmeUVOUzBfMTFFQWx0ZXJhdGlvbkVOUzBfMTBFRGly ZWN0aW9uRU5TXzE1VGV4dEdyYW51bGFyaXR5RWIKSW5kZXg6IFdlYkNvcmUvZWRpdGluZy9FZGl0 b3JDb21tYW5kLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFu ZC5jcHAJKHJldmlzaW9uIDU4OTYyKQorKysgV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC00MSwxMyArNDEsMTMgQEAKICNpbmNsdWRlICJFdmVudEhh bmRsZXIuaCIKICNpbmNsdWRlICJGb3JtYXRCbG9ja0NvbW1hbmQuaCIKICNpbmNsdWRlICJGcmFt ZS5oIgorI2luY2x1ZGUgIkZyYW1lVmlldy5oIgogI2luY2x1ZGUgIkhUTUxGb250RWxlbWVudC5o IgogI2luY2x1ZGUgIkhUTUxIUkVsZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MSW1hZ2VFbGVtZW50 LmgiCiAjaW5jbHVkZSAiSW5kZW50T3V0ZGVudENvbW1hbmQuaCIKICNpbmNsdWRlICJJbnNlcnRM aXN0Q29tbWFuZC5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKLSNpbmNsdWRlICJSZW5kZXJCb3guaCIK ICNpbmNsdWRlICJSZXBsYWNlU2VsZWN0aW9uQ29tbWFuZC5oIgogI2luY2x1ZGUgIlNjcm9sbGJh ci5oIgogI2luY2x1ZGUgIlNldHRpbmdzLmgiCkBAIC0yNTksNyArMjU5LDcgQEAgc3RhdGljIGlu dCB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKEZyYW1lKgogICAgICAgICByZXR1cm4gMDsKICAgICBp ZiAoIShzdHlsZS0+b3ZlcmZsb3dZKCkgPT0gT1NDUk9MTCB8fCBzdHlsZS0+b3ZlcmZsb3dZKCkg PT0gT0FVVE8gfHwgZm9jdXNlZE5vZGUtPmlzQ29udGVudEVkaXRhYmxlKCkpKQogICAgICAgICBy ZXR1cm4gMDsKLSAgICBpbnQgaGVpZ2h0ID0gdG9SZW5kZXJCb3gocmVuZGVyZXIpLT5jbGllbnRI ZWlnaHQoKTsKKyAgICBpbnQgaGVpZ2h0ID0gZnJhbWUtPnZpZXcoKS0+dmlzaWJsZUhlaWdodCgp OwogICAgIHJldHVybiBtYXgobWF4PGludD4oaGVpZ2h0ICogU2Nyb2xsYmFyOjptaW5GcmFjdGlv blRvU3RlcFdoZW5QYWdpbmcoKSwgaGVpZ2h0IC0gU2Nyb2xsYmFyOjptYXhPdmVybGFwQmV0d2Vl blBhZ2VzKCkpLCAxKTsKIH0KIApAQCAtNjQ2LDcgKzY0Niw3IEBAIHN0YXRpYyBib29sIGV4ZWN1 dGVNb3ZlUGFnZURvd24oRnJhbWUqIGYKICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNjcm9s bERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4gZmFs c2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRy b2xsZXI6Ok1PVkUsIGRpc3RhbmNlLCB0cnVlKTsKKyAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlv bigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6TU9WRSwgZGlzdGFuY2UsIHRydWUsIFNl bGVjdGlvbkNvbnRyb2xsZXI6OkFMSUdOX0NVUlNPUl9PTl9TQ1JPTExfQUxXQVlTKTsKIH0KIAog c3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlmeVNlbGVjdGlvbihGcmFtZSog ZnJhbWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3QgU3RyaW5nJikKQEAgLTY1 NCw3ICs2NTQsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VEb3duQW5kTW9kaWZ5CiAg ICAgaW50IGRpc3RhbmNlID0gdmVydGljYWxTY3JvbGxEaXN0YW5jZShmcmFtZSk7CiAgICAgaWYg KCFkaXN0YW5jZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIHJldHVybiBmcmFtZS0+c2Vs ZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpFWFRFTkQsIGRpc3RhbmNlLCB0 cnVlKTsKKyAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29u dHJvbGxlcjo6RVhURU5ELCBkaXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6QUxJ R05fQ1VSU09SX09OX1NDUk9MTF9BTFdBWVMpOwogfQogCiBzdGF0aWMgYm9vbCBleGVjdXRlTW92 ZVBhZ2VVcChGcmFtZSogZnJhbWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3Qg U3RyaW5nJikKQEAgLTY2Miw3ICs2NjIsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VV cChGcmFtZSogZnJhCiAgICAgaW50IGRpc3RhbmNlID0gdmVydGljYWxTY3JvbGxEaXN0YW5jZShm cmFtZSk7CiAgICAgaWYgKCFkaXN0YW5jZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIHJl dHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpNT1ZF LCAtZGlzdGFuY2UsIHRydWUpOworICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlm eShTZWxlY3Rpb25Db250cm9sbGVyOjpNT1ZFLCAtZGlzdGFuY2UsIHRydWUsIFNlbGVjdGlvbkNv bnRyb2xsZXI6OkFMSUdOX0NVUlNPUl9PTl9TQ1JPTExfQUxXQVlTKTsKIH0KIAogc3RhdGljIGJv b2wgZXhlY3V0ZU1vdmVQYWdlVXBBbmRNb2RpZnlTZWxlY3Rpb24oRnJhbWUqIGZyYW1lLCBFdmVu dCosIEVkaXRvckNvbW1hbmRTb3VyY2UsIGNvbnN0IFN0cmluZyYpCkBAIC02NzAsNyArNjcwLDcg QEAgc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlVXBBbmRNb2RpZnlTZQogICAgIGludCBkaXN0 YW5jZSA9IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoZnJhbWUpOwogICAgIGlmICghZGlzdGFuY2Up CiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5t b2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCAtZGlzdGFuY2UsIHRydWUpOworICAg IHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpF WFRFTkQsIC1kaXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6QUxJR05fQ1VSU09S X09OX1NDUk9MTF9BTFdBWVMpOwogfQogCiBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVJpZ2h0KEZy YW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpJ bmRleDogV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAkocmV2aXNpb24gNTg5 NjIpCisrKyBXZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTc5LDkgKzc5LDkgQEAgU2VsZWN0aW9uQ29udHJvbGxlcjo6U2VsZWN0aW9uQ29u dHJvbGxlcgogICAgIHNldElzRGlyZWN0aW9uYWwoZmFsc2UpOwogfQogCi12b2lkIFNlbGVjdGlv bkNvbnRyb2xsZXI6Om1vdmVUbyhjb25zdCBWaXNpYmxlUG9zaXRpb24gJnBvcywgYm9vbCB1c2Vy VHJpZ2dlcmVkKQordm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjptb3ZlVG8oY29uc3QgVmlzaWJs ZVBvc2l0aW9uICZwb3MsIGJvb2wgdXNlclRyaWdnZXJlZCwgQ3Vyc29yQWxpZ25PblNjcm9sbCBh bGlnbikKIHsKLSAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlvbihwb3MuZGVlcEVxdWl2 YWxlbnQoKSwgcG9zLmRlZXBFcXVpdmFsZW50KCksIHBvcy5hZmZpbml0eSgpKSwgdHJ1ZSwgdHJ1 ZSwgdXNlclRyaWdnZXJlZCk7CisgICAgc2V0U2VsZWN0aW9uKFZpc2libGVTZWxlY3Rpb24ocG9z LmRlZXBFcXVpdmFsZW50KCksIHBvcy5kZWVwRXF1aXZhbGVudCgpLCBwb3MuYWZmaW5pdHkoKSks IHRydWUsIHRydWUsIHVzZXJUcmlnZ2VyZWQsIGFsaWduKTsKIH0KIAogdm9pZCBTZWxlY3Rpb25D b250cm9sbGVyOjptb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZiYXNlLCBjb25zdCBWaXNp YmxlUG9zaXRpb24gJmV4dGVudCwgYm9vbCB1c2VyVHJpZ2dlcmVkKQpAQCAtMTA1LDcgKzEwNSw3 IEBAIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0IFAKICAgICBzZXRTZWxl Y3Rpb24oVmlzaWJsZVNlbGVjdGlvbihiYXNlLCBleHRlbnQsIGFmZmluaXR5KSwgdHJ1ZSwgdHJ1 ZSwgdXNlclRyaWdnZXJlZCk7CiB9CiAKLXZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2Vs ZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHMsIGJvb2wgY2xvc2VUeXBpbmcsIGJvb2wg Y2xlYXJUeXBpbmdTdHlsZSwgYm9vbCB1c2VyVHJpZ2dlcmVkLCBUZXh0R3JhbnVsYXJpdHkgZ3Jh bnVsYXJpdHkpCit2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihjb25zdCBW aXNpYmxlU2VsZWN0aW9uJiBzLCBib29sIGNsb3NlVHlwaW5nLCBib29sIGNsZWFyVHlwaW5nU3R5 bGUsIGJvb2wgdXNlclRyaWdnZXJlZCwgQ3Vyc29yQWxpZ25PblNjcm9sbCBhbGlnbiwgVGV4dEdy YW51bGFyaXR5IGdyYW51bGFyaXR5KQogewogICAgIG1fZ3JhbnVsYXJpdHkgPSBncmFudWxhcml0 eTsKIApAQCAtMTYxLDggKzE2MSwxNyBAQCB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNl bGVjdGlvbihjCiAgICAgc2VsZWN0RnJhbWVFbGVtZW50SW5QYXJlbnRJZkZ1bGx5U2VsZWN0ZWQo KTsKICAgICBtX2ZyYW1lLT5ub3RpZnlSZW5kZXJlck9mU2VsZWN0aW9uQ2hhbmdlKHVzZXJUcmln Z2VyZWQpOwogICAgIG1fZnJhbWUtPnJlc3BvbmRUb0NoYW5nZWRTZWxlY3Rpb24ob2xkU2VsZWN0 aW9uLCBjbG9zZVR5cGluZyk7Ci0gICAgaWYgKHVzZXJUcmlnZ2VyZWQpCi0gICAgICAgIG1fZnJh bWUtPnJldmVhbFNlbGVjdGlvbihTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9FZGdlSWZOZWVkZWQs IHRydWUpOworICAgIGlmICh1c2VyVHJpZ2dlcmVkKSB7CisgICAgICAgIFNldHRpbmdzKiBzZXR0 aW5ncyA9IG1fZnJhbWUgPyBtX2ZyYW1lLT5zZXR0aW5ncygpIDogMDsKKworICAgICAgICBTY3Jv bGxBbGlnbm1lbnQgYWxpZ25tZW50OworICAgICAgICBpZiAobV9mcmFtZS0+c2V0dGluZ3MoKS0+ ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ01hY0JlaGF2aW9yKQorICAgICAgICAgICAgYWxp Z25tZW50ID0gKGFsaWduID09IEFMSUdOX0NVUlNPUl9PTl9TQ1JPTExfQUxXQVlTKSA/IFNjcm9s bEFsaWdubWVudDo6YWxpZ25DZW50ZXJBbHdheXMgOiBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduQ2Vu dGVySWZOZWVkZWQ7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIGFsaWdubWVudCA9IChhbGln biA9PSBBTElHTl9DVVJTT1JfT05fU0NST0xMX0FMV0FZUykgPyBTY3JvbGxBbGlnbm1lbnQ6OmFs aWduVG9wQWx3YXlzIDogU2Nyb2xsQWxpZ25tZW50OjphbGlnblRvRWRnZUlmTmVlZGVkOworCisg ICAgICAgIG1fZnJhbWUtPnJldmVhbFNlbGVjdGlvbihhbGlnbm1lbnQsIHRydWUpOworICAgIH0K IAogICAgIG5vdGlmeUFjY2Vzc2liaWxpdHlGb3JTZWxlY3Rpb25DaGFuZ2UoKTsKIH0KQEAgLTcx NCw3ICs3MjMsNyBAQCBzdGF0aWMgYm9vbCBhYnNvbHV0ZUNhcmV0WShjb25zdCBWaXNpYmxlCiAg ICAgcmV0dXJuIHRydWU7CiB9CiAKLWJvb2wgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVB bHRlcmF0aW9uIGFsdGVyLCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dlcmVk KQorYm9vbCBTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkoRUFsdGVyYXRpb24gYWx0ZXIsIGlu dCB2ZXJ0aWNhbERpc3RhbmNlLCBib29sIHVzZXJUcmlnZ2VyZWQsIEN1cnNvckFsaWduT25TY3Jv bGwgYWxpZ24pCiB7CiAgICAgaWYgKHZlcnRpY2FsRGlzdGFuY2UgPT0gMCkKICAgICAgICAgcmV0 dXJuIGZhbHNlOwpAQCAtNzgyLDcgKzc5MSw3IEBAIGJvb2wgU2VsZWN0aW9uQ29udHJvbGxlcjo6 bW9kaWZ5KEVBbHRlcmEKIAogICAgIHN3aXRjaCAoYWx0ZXIpIHsKICAgICAgICAgY2FzZSBNT1ZF OgotICAgICAgICAgICAgbW92ZVRvKHJlc3VsdCwgdXNlclRyaWdnZXJlZCk7CisgICAgICAgICAg ICBtb3ZlVG8ocmVzdWx0LCB1c2VyVHJpZ2dlcmVkLCBhbGlnbik7CiAgICAgICAgICAgICBicmVh azsKICAgICAgICAgY2FzZSBFWFRFTkQ6CiAgICAgICAgICAgICBzZXRFeHRlbnQocmVzdWx0LCB1 c2VyVHJpZ2dlcmVkKTsKSW5kZXg6IFdlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVy LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuaAko cmV2aXNpb24gNTg5NjIpCisrKyBXZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5o CSh3b3JraW5nIGNvcHkpCkBAIC00NSw2ICs0NSw4IEBAIGNsYXNzIFNlbGVjdGlvbkNvbnRyb2xs ZXIgOiBwdWJsaWMgTm9uY28KIHB1YmxpYzoKICAgICBlbnVtIEVBbHRlcmF0aW9uIHsgTU9WRSwg RVhURU5EIH07CiAgICAgZW51bSBFRGlyZWN0aW9uIHsgRk9SV0FSRCwgQkFDS1dBUkQsIFJJR0hU LCBMRUZUIH07CisgICAgZW51bSBDdXJzb3JBbGlnbk9uU2Nyb2xsIHsgQUxJR05fQ1VSU09SX09O X1NDUk9MTF9JRl9ORUVERUQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQUxJR05f Q1VSU09SX09OX1NDUk9MTF9BTFdBWVMgfTsKIAogICAgIFNlbGVjdGlvbkNvbnRyb2xsZXIoRnJh bWUqID0gMCwgYm9vbCBpc0RyYWdDYXJldENvbnRyb2xsZXIgPSBmYWxzZSk7CiAKQEAgLTU0LDE0 ICs1NiwxNCBAQCBwdWJsaWM6CiAgICAgTm9kZSogc2hhZG93VHJlZVJvb3ROb2RlKCkgY29uc3Qg eyByZXR1cm4gbV9zZWxlY3Rpb24uc2hhZG93VHJlZVJvb3ROb2RlKCk7IH0KICAgICAgCiAgICAg dm9pZCBtb3ZlVG8oY29uc3QgUmFuZ2UqLCBFQWZmaW5pdHksIGJvb2wgdXNlclRyaWdnZXJlZCA9 IGZhbHNlKTsKLSAgICB2b2lkIG1vdmVUbyhjb25zdCBWaXNpYmxlUG9zaXRpb24mLCBib29sIHVz ZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CisgICAgdm9pZCBtb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0 aW9uJiwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UsIEN1cnNvckFsaWduT25TY3JvbGwgYWxp Z24gPSBBTElHTl9DVVJTT1JfT05fU0NST0xMX0lGX05FRURFRCk7CiAgICAgdm9pZCBtb3ZlVG8o Y29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgYm9vbCB1c2Vy VHJpZ2dlcmVkID0gZmFsc2UpOwogICAgIHZvaWQgbW92ZVRvKGNvbnN0IFBvc2l0aW9uJiwgRUFm ZmluaXR5LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CiAgICAgdm9pZCBtb3ZlVG8oY29u c3QgUG9zaXRpb24mLCBjb25zdCBQb3NpdGlvbiYsIEVBZmZpbml0eSwgYm9vbCB1c2VyVHJpZ2dl cmVkID0gZmFsc2UpOwogCiAgICAgY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uKCkg Y29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb247IH0KLSAgICB2b2lkIHNldFNlbGVjdGlvbihjb25z dCBWaXNpYmxlU2VsZWN0aW9uJiwgYm9vbCBjbG9zZVR5cGluZyA9IHRydWUsIGJvb2wgY2xlYXJU eXBpbmdTdHlsZSA9IHRydWUsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBUZXh0R3JhbnVs YXJpdHkgPSBDaGFyYWN0ZXJHcmFudWxhcml0eSk7Ci0gICAgdm9pZCBzZXRTZWxlY3Rpb24oY29u c3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJp dHkpIHsgc2V0U2VsZWN0aW9uKHNlbGVjdGlvbiwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIGdyYW51bGFy aXR5KTsgfQorICAgIHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mLCBi b29sIGNsb3NlVHlwaW5nID0gdHJ1ZSwgYm9vbCBjbGVhclR5cGluZ1N0eWxlID0gdHJ1ZSwgYm9v bCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UsIEN1cnNvckFsaWduT25TY3JvbGwgYWxpZ24gPSBBTElH Tl9DVVJTT1JfT05fU0NST0xMX0lGX05FRURFRCwgVGV4dEdyYW51bGFyaXR5ID0gQ2hhcmFjdGVy R3JhbnVsYXJpdHkpOworICAgIHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rp b24mIHNlbGVjdGlvbiwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5KSB7IHNldFNlbGVjdGlv bihzZWxlY3Rpb24sIHRydWUsIHRydWUsIGZhbHNlLCBBTElHTl9DVVJTT1JfT05fU0NST0xMX0lG X05FRURFRCwgZ3JhbnVsYXJpdHkpOyB9CiAgICAgYm9vbCBzZXRTZWxlY3RlZFJhbmdlKFJhbmdl KiwgRUFmZmluaXR5LCBib29sIGNsb3NlVHlwaW5nKTsKICAgICB2b2lkIHNlbGVjdEFsbCgpOwog ICAgIHZvaWQgY2xlYXIoKTsKQEAgLTc2LDcgKzc4LDcgQEAgcHVibGljOgogICAgIEVBZmZpbml0 eSBhZmZpbml0eSgpIGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uLmFmZmluaXR5KCk7IH0KIAog ICAgIGJvb2wgbW9kaWZ5KEVBbHRlcmF0aW9uLCBFRGlyZWN0aW9uLCBUZXh0R3JhbnVsYXJpdHks IGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKLSAgICBib29sIG1vZGlmeShFQWx0ZXJhdGlv biwgaW50IHZlcnRpY2FsRGlzdGFuY2UsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKKyAg ICBib29sIG1vZGlmeShFQWx0ZXJhdGlvbiwgaW50IHZlcnRpY2FsRGlzdGFuY2UsIGJvb2wgdXNl clRyaWdnZXJlZCA9IGZhbHNlLCBDdXJzb3JBbGlnbk9uU2Nyb2xsIGFsaWduID0gQUxJR05fQ1VS U09SX09OX1NDUk9MTF9JRl9ORUVERUQpOwogICAgIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0 eSgpIGNvbnN0IHsgcmV0dXJuIG1fZ3JhbnVsYXJpdHk7IH0KIAogICAgIHZvaWQgc2V0U3RhcnQo Y29uc3QgVmlzaWJsZVBvc2l0aW9uICYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKSW5k ZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFu Z2VMb2cJKHJldmlzaW9uIDU4OTYyKQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTAtMDUtMDcgIFplbGlkcmFnIEhvcm51bmcgIDx6 ZWxpZHJhZ0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgRml4ZWQgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBleHBlY3RhdGlvbnMg Zm9yIGJ1ZzoKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTM4MjEzCisgICAgICAgIEFkZGVkIGEgbmV3IHRlc3QgdGhhdCB2ZXJpZmllcyBob3cgdmlzaWJs ZSBwb3J0aW9uIG9mIGZyYW1lIGNoYW5nZXMKKyAgICAgICAgd2hpbGUgc2Nyb2xsaW5nIHRoZSBm cmFtZS4gVGhlIHRlc3Qgd2lsbCBjaGVjayBmb3IgZGlmZmVyZW50IHZhbHVlIG9uCisgICAgICAg IE9TKERBUldJTikgdGhhbiBvdGhlciBwbGF0Zm9ybXMgc2luY2UgZWRpdCBmcmFtZSBzY3JvbGwg dGhlcmUgd2lsbAorICAgICAgICBjZW50ZXIgdGhlIGN1cnNvciBvbiBwYWdlIHVwL2Rvd24gd2hp bGUgaXQgd2lsbCBhbGlnbiBpdCB3aXRoIHRoZSB0b3AKKyAgICAgICAgb24gb3RoZXIgcGxhdGZv cm1zLgorICAgICAgICAKKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRv d24uaHRtbDogRml4ZWQgcmlnZ2VkIHRlc3QgdGhhdCB3YXMgbWFza2luZyBzY3JvbGxpbmcgYW5k IGN1cnNvciBtb3ZlIGVycm9ycy4gQWRkZWQgdGVzdHMgdG8gbWFrZSBzdXJlIHRoZSBjdXJzb3Ig ZG9lcyBub3QgbW92ZSBvbiBNYWMgaWYgW29wdGlvbl0gaXMgbm90IHByZXNzZWQuCisgICAgICAg ICogZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4 dDogQWRkZWQsIHNlZSBjaGFuZ2VsaXN0IGRlc2NyaXB0aW9uIGFib3ZlLiAKKyAgICAgICAgKiBl ZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24uaHRtbDogQWRkZWQuCisK IDIwMTAtMDUtMDcgIEFsZXhleSBQcm9za3VyeWFrb3YgIDxhcEBhcHBsZS5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgQWRlbGUgUGV0ZXJzb24uCkluZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5n L2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9lZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbAkocmV2aXNpb24gNTg5NjIp CisrKyBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbAko d29ya2luZyBjb3B5KQpAQCAtMjAsMTggKzIwLDE4IEBAIGZ1bmN0aW9uIHJ1blRlc3QoKQogCiAg ICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBtb2RpZmllcnMpOwogICAgIHZhciBs aW5lID0gZnJhbWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOwotICAgIGlmIChs aW5lICE9ICJsaW5lIDgiKQotICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5l IDgsIG5vdCAiICsgbGluZTsKKyAgICBpZiAobGluZSAhPSAibGluZSAzIikKKyAgICAgICAgdGhy b3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7CiAKICAgICBldmVu dFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIsIG1vZGlmaWVycyk7CiAgICAgdmFyIGxpbmUgPSBm cmFtZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7Ci0gICAgaWYgKGxpbmUgIT0g ImxpbmUgOSIpCi0gICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgOSwgbm90 ICIgKyBsaW5lOworICAgIGlmIChsaW5lICE9ICJsaW5lIDYiKQorICAgICAgICB0aHJvdyAiY3Vy c29yIHNob3VsZCBiZSBhdCBsaW5lIDYsIG5vdCAiICsgbGluZTsKIAogICAgIGV2ZW50U2VuZGVy LmtleURvd24oInBhZ2VVcCIsIG1vZGlmaWVycyk7CiAgICAgdmFyIGxpbmUgPSBmcmFtZS5nZXRT ZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7Ci0gICAgaWYgKGxpbmUgIT0gImxpbmUgMSIp Ci0gICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMSwgbm90ICIgKyBsaW5l OworICAgIGlmIChsaW5lICE9ICJsaW5lIDMiKQorICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3Vs ZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGluZTsKIAogICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCJyZXN1bHRzIikuaW5uZXJUZXh0ID0gIlBBU1MiOwogfQpJbmRleDogTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1w YWdlLXVwLWRvd24tZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZWRp dGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dAkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSwzIEBACitPbiBNYWMsIG9wdGlvbitwYWdlZG93biBzaG91bGQg bW92ZSB0aGUgZnJhbWUgbW91c2UgY3Vyc29yIGluIHRoZSBtaWRkbGUgb2YgdGhlIGZyYW1lIHZp ZXdwb3J0IGluIHRleHQgYXJlYXMuIE9uIG90aGVyIHBsYXRmb3JtcywgcGFnZWRvd24gc2hvdWxk IG1vdmUgdGhlIG1vdXNlIGN1cnNvciBhdCB0aGUgdG9wIG9mIHRoZSB2aWV3cG9ydCB3aGlsZSBz Y3JvbGwgaW4gdGV4dCBhcmVhcy4gVGhpcyB0ZXN0IHJlcXVpcmVzIERSVCB0byBwYXNzLgorCitQ QVNTCkluZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdl LXVwLWRvd24uaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3Nj cm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24uaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRl c3RzL2VkaXRpbmcvaW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAtZG93bi5odG1sCShyZXZp c2lvbiAwKQpAQCAtMCwwICsxLDU0IEBACis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0 Q29udHJvbGxlcikKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKK2Z1 bmN0aW9uIHJ1blRlc3QoKSB7CisgICAgdmFyIHRvbGVyYW5jZSA9IDEwOworICAgIHZhciBmcmFt ZSA9IGZyYW1lc1swXTsKKyAgICB2YXIgZG9jID0gZnJhbWUuZG9jdW1lbnQ7CisgICAgdmFyIGJv ZHkgPSBkb2MuYm9keTsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IDEwOyArK2kpCisgICAgICAg IGJvZHkuaW5uZXJIVE1MICs9ICI8cD5saW5lICIgKyBpICsgIjwvcD5cbiI7CisgICAgZnJhbWUu Zm9jdXMoKTsKKyAgICBmcmFtZS5nZXRTZWxlY3Rpb24oKS5zZXRQb3NpdGlvbihib2R5LmZpcnN0 Q2hpbGQsIDApOworCisgICAgdmFyIG9uTWFjUGxhdGZvcm0gPSBuYXZpZ2F0b3IudXNlckFnZW50 LnNlYXJjaCgvXGJNYWMgT1MgWFxiLykgIT0gLTE7CisgICAgdmFyIG1vZGlmaWVycyA9IG9uTWFj UGxhdGZvcm0gPyBbImFsdEtleSJdIDogW107CisgICAgCisgICAgaWYgKG9uTWFjUGxhdGZvcm0p CisgICAgICAgIG9mZnNldHMgPSBbIDUxLCAxNTkgXTsKKyAgICBlbHNlIAorICAgICAgICBvZmZz ZXRzID0gWyAxMTYsIDIxOCBdOworCisgICAgaWYgKCF3aW5kb3cuZXZlbnRTZW5kZXIpCisgICAg ICAgIHJldHVybjsKKworICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3duIiwgbW9kaWZp ZXJzKTsKKyAgICBpZiAoTWF0aC5hYnMoZnJhbWUucGFnZVlPZmZzZXQgLSBvZmZzZXRzWzBdKSA+ IHRvbGVyYW5jZSkgeworICAgICAgICB0aHJvdyAiRnJhbWUgdmlld3BvcnQgc2hvdWxkIGJlIGFy b3VuZCAiICsgb2Zmc2V0c1swXSArCisgICAgICAgICAgICAicHggLCBub3QgYXQgIiArIGZyYW1l LnBhZ2VZT2Zmc2V0OworICAgIH0KKworICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3du IiwgbW9kaWZpZXJzKTsKKyAgICB2YXIgbGluZSA9IGZyYW1lLmdldFNlbGVjdGlvbigpLmJhc2VO b2RlLm5vZGVWYWx1ZTsKKyAgICBpZiAoTWF0aC5hYnMoZnJhbWUucGFnZVlPZmZzZXQgLSBvZmZz ZXRzWzFdKSA+IHRvbGVyYW5jZSkgeworICAgICAgICB0aHJvdyAiRnJhbWUgdmlld3BvcnQgc2hv dWxkIGJlIGFyb3VuZCAiICsgb2Zmc2V0c1sxXSArCisgICAgICAgICAgICAicHggLCBub3QgIiAr IGZyYW1lLnBhZ2VZT2Zmc2V0OworICAgIH0KKworICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBh Z2VVcCIsIG1vZGlmaWVycyk7CisgICAgdmFyIGxpbmUgPSBmcmFtZS5nZXRTZWxlY3Rpb24oKS5i YXNlTm9kZS5ub2RlVmFsdWU7CisgICAgaWYgKE1hdGguYWJzKGZyYW1lLnBhZ2VZT2Zmc2V0IC0g b2Zmc2V0c1swXSkgPiB0b2xlcmFuY2UpIHsKKyAgICAgICAgdGhyb3cgIkZyYW1lIHZpZXdwb3J0 IHNob3VsZCBiZSBhcm91bmQgIiArIG9mZnNldHNbMF0gKworICAgICAgICAgICAgInB4ICwgbm90 IGF0ICIgKyBmcmFtZS5wYWdlWU9mZnNldDsKKyAgICB9CisKKyAgICBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgicmVzdWx0cyIpLmlubmVyVGV4dCA9ICJQQVNTIjsKK30KKzwvc2NyaXB0PgorCis8 ZGl2Pk9uIE1hYywgb3B0aW9uK3BhZ2Vkb3duIHNob3VsZCBtb3ZlIHRoZSBmcmFtZSBtb3VzZSBj dXJzb3IgaW4gdGhlIG1pZGRsZSBvZiB0aGUgZnJhbWUgdmlld3BvcnQgaW4gdGV4dCBhcmVhcy4K K09uIG90aGVyIHBsYXRmb3JtcywgcGFnZWRvd24gc2hvdWxkIG1vdmUgdGhlIG1vdXNlIGN1cnNv ciBhdCB0aGUgdG9wIG9mIHRoZSB2aWV3cG9ydCB3aGlsZSBzY3JvbGwgaW4gdGV4dCBhcmVhcy4K K1RoaXMgdGVzdCByZXF1aXJlcyBEUlQgdG8gcGFzcy48L2Rpdj4KKzxpZnJhbWUgc3JjPSIuLi9y ZXNvdXJjZXMvY29udGVudGVkaXRhYmxlLWlmcmFtZS1zcmMuaHRtbCIgb25sb2FkPSJydW5UZXN0 KCkiPjwvaWZyYW1lPgorPGRpdiBpZD0icmVzdWx0cyI+RkFJTDwvZGl2Pgo= 56100 2010-05-14 13:06:44 -0700 2010-05-21 13:08:40 -0700 Review comment fixed, handling of non-iframe contenteditable cases WK_38213.patch text/plain 27047 zelidrag SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1OTQ4MSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzQgQEAKKzIwMTAtMDUtMTQgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgRml4ZWQgZnJhbWUgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBjYWxjdWxhdGlvbi4gTWFk ZSBzdXJlIHRoYXQgdGhlCisgICAgICAgIGN1cnNvciBtb3ZlcyB3aXRoIHBhZ2UgdXAvZG93biBl dmVudC4gUGxlYXNlIG5vdGUgdGhhdCBub3cgZm9yIG1hYworICAgICAgICBlZGl0aW5nIGJlaGF2 aW9yIHdlIHdpbGwgc2Nyb2xsIHRoZSBjb250ZW50IHRvIGNlbnRlciB0aGUgY3Vyc29yIG9uCisg ICAgICAgIHBhZ2UgdXAvZG93biB3aGlsZSBvdGhlciBwbGF0Zm9ybXMgd2lsbCBhbGlnbiB0aGUg Y3Vyc29yIHdpdGggdGhlIHRvcCBvZgorICAgICAgICBkaXNwbGF5ZWQgZnJhbWUuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zODIxMworCisgICAgICAg IFRlc3RzOiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbCAoZml4ZWQpCisg ICAgICAgICAgICAgICBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24taW5wYWdlLmh0 bWwKKyAgICAgICAgICAgICAgIGVkaXRpbmcvaW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAt ZG93bi1kaXYuaHRtbAorICAgICAgICAgICAgICAgZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3Bv cnQtcGFnZS11cC1kb3duLmh0bWwKKworICAgICAgICAqIFdlYkNvcmUuYmFzZS5leHA6CisgICAg ICAgICogZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnZlcnRp Y2FsU2Nyb2xsRGlzdGFuY2UpOiBGaXhlZCBwYWdlIHNjcm9sbCBjYWxjdWxhdGlvbi4gTm93IHNj cm9sbCBoZWlnaHQgaXMgY2FsY3VsYXRlZCBvbmx5IGZyb20gdGhlIHZpc2libGUgcG9ydGlvbiBu b3QgdGhlIGVudGlyZSBmcmFtZSBoZWlnaHQuCisgICAgICAgIChXZWJDb3JlOjpleGVjdXRlTW92 ZVBhZ2VEb3duKTogTm93IGl0IGNhbiB0ZWxsIFNlbGVjdGlvbkNvbnRyb2xsZXIgdG8gbW92ZSB0 aGUgY3Vyc29yIHdpdGggdGhlIHBhZ2Ugc2Nyb2xsIHVwL2Rvd24gZXZlbnRzLgorICAgICAgICAo V2ViQ29yZTo6ZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlmeVNlbGVjdGlvbik6IERpdHRvLgor ICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZU1vdmVQYWdlVXApOiBEaXR0by4KKyAgICAgICAgKFdl YkNvcmU6OmV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2VsZWN0aW9uKTogRGl0dG8uCisgICAg ICAgICogZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcDoKKyAgICAgICAgKiBlZGl0aW5n L1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOiBFeHBvc2VkIGFuIGVudW0gcGFyYW0gdGhhdCBsZXRz IEVkaXRvckNvbW1hbmQuY3BwIGNvbnRyb2wgaG93IGN1cnNvciBwb3NpdGlvbiB3aWxsIGJlIGFs aWduZWQgd2hlbiBwYWdlIG1vdmVzLgorICAgICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJv bGxlcjo6c2V0U2VsZWN0aW9uKTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25D b250cm9sbGVyOjptb2RpZnkpOiBEaXR0by4KKyAgICAgICAgKiBlZGl0aW5nL1NlbGVjdGlvbkNv bnRyb2xsZXIuaDogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVy OjopOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNl bGVjdGlvbik6IERpdHRvLgorCiAyMDEwLTA1LTE0ICBCcmlhbiBXZWluc3RlaW4gIDxid2VpbnN0 ZWluQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBBZGFtIFJvYmVuLgpJbmRleDog V2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS5i YXNlLmV4cAkocmV2aXNpb24gNTk0NzcpCisrKyBXZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAJKHdv cmtpbmcgY29weSkKQEAgLTQxOCw3ICs0MTgsNyBAQCBfX1pON1dlYkNvcmUxOUFuaW1hdGlvbkNv bnRyb2xsZXIyMXBhdXNlCiBfX1pON1dlYkNvcmUxOUNTU1N0eWxlRGVjbGFyYXRpb24xMXNldFBy b3BlcnR5RVJLTlNfNlN0cmluZ0VTM19SaQogX19aTjdXZWJDb3JlMTlJbnNwZWN0b3JDb250cm9s bGVyMzRpbnNwZWN0b3JTdGFydHNBdHRhY2hlZFNldHRpbmdOYW1lRXYKIF9fWk43V2ViQ29yZTE5 U2VsZWN0aW9uQ29udHJvbGxlcjEwc2V0Rm9jdXNlZEViCi1fX1pON1dlYkNvcmUxOVNlbGVjdGlv bkNvbnRyb2xsZXIxMnNldFNlbGVjdGlvbkVSS05TXzE2VmlzaWJsZVNlbGVjdGlvbkViYmJOU18x NVRleHRHcmFudWxhcml0eUUKK19fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjEyc2V0 U2VsZWN0aW9uRVJLTlNfMTZWaXNpYmxlU2VsZWN0aW9uRWJiYk5TMF8xOUN1cnNvckFsaWduT25T Y3JvbGxFTlNfMTVUZXh0R3JhbnVsYXJpdHlFCiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRy b2xsZXIxNnNldFNlbGVjdGVkUmFuZ2VFUE5TXzVSYW5nZUVOU185RUFmZmluaXR5RWIKIF9fWk43 V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjVjbGVhckV2CiBfX1pON1dlYkNvcmUxOVNlbGVj dGlvbkNvbnRyb2xsZXI2bW9kaWZ5RU5TMF8xMUVBbHRlcmF0aW9uRU5TMF8xMEVEaXJlY3Rpb25F TlNfMTVUZXh0R3JhbnVsYXJpdHlFYgpJbmRleDogV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1h bmQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcAko cmV2aXNpb24gNTk0NzcpCisrKyBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTQxLDEzICs0MSwxMyBAQAogI2luY2x1ZGUgIkV2ZW50SGFuZGxlci5o IgogI2luY2x1ZGUgIkZvcm1hdEJsb2NrQ29tbWFuZC5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCisj aW5jbHVkZSAiRnJhbWVWaWV3LmgiCiAjaW5jbHVkZSAiSFRNTEZvbnRFbGVtZW50LmgiCiAjaW5j bHVkZSAiSFRNTEhSRWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxJbWFnZUVsZW1lbnQuaCIKICNp bmNsdWRlICJJbmRlbnRPdXRkZW50Q29tbWFuZC5oIgogI2luY2x1ZGUgIkluc2VydExpc3RDb21t YW5kLmgiCiAjaW5jbHVkZSAiUGFnZS5oIgotI2luY2x1ZGUgIlJlbmRlckJveC5oIgogI2luY2x1 ZGUgIlJlcGxhY2VTZWxlY3Rpb25Db21tYW5kLmgiCiAjaW5jbHVkZSAiU2Nyb2xsYmFyLmgiCiAj aW5jbHVkZSAiU2V0dGluZ3MuaCIKQEAgLTI1OSw3ICsyNTksOCBAQCBzdGF0aWMgaW50IHZlcnRp Y2FsU2Nyb2xsRGlzdGFuY2UoRnJhbWUqCiAgICAgICAgIHJldHVybiAwOwogICAgIGlmICghKHN0 eWxlLT5vdmVyZmxvd1koKSA9PSBPU0NST0xMIHx8IHN0eWxlLT5vdmVyZmxvd1koKSA9PSBPQVVU TyB8fCBmb2N1c2VkTm9kZS0+aXNDb250ZW50RWRpdGFibGUoKSkpCiAgICAgICAgIHJldHVybiAw OwotICAgIGludCBoZWlnaHQgPSB0b1JlbmRlckJveChyZW5kZXJlciktPmNsaWVudEhlaWdodCgp OworICAgIGludCBoZWlnaHQgPSBzdGQ6Om1pbjxpbnQ+KHRvUmVuZGVyQm94KHJlbmRlcmVyKS0+ Y2xpZW50SGVpZ2h0KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZnJhbWUtPnZp ZXcoKS0+dmlzaWJsZUhlaWdodCgpKTsKICAgICByZXR1cm4gbWF4KG1heDxpbnQ+KGhlaWdodCAq IFNjcm9sbGJhcjo6bWluRnJhY3Rpb25Ub1N0ZXBXaGVuUGFnaW5nKCksIGhlaWdodCAtIFNjcm9s bGJhcjo6bWF4T3ZlcmxhcEJldHdlZW5QYWdlcygpKSwgMSk7CiB9CiAKQEAgLTY0Niw3ICs2NDcs NyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VEb3duKEZyYW1lKiBmCiAgICAgaW50IGRp c3RhbmNlID0gdmVydGljYWxTY3JvbGxEaXN0YW5jZShmcmFtZSk7CiAgICAgaWYgKCFkaXN0YW5j ZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCkt Pm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpNT1ZFLCBkaXN0YW5jZSwgdHJ1ZSk7CisgICAg cmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1P VkUsIGRpc3RhbmNlLCB0cnVlLCBTZWxlY3Rpb25Db250cm9sbGVyOjpBbGlnbkN1cnNvck9uU2Ny b2xsQWx3YXlzKTsKIH0KIAogc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlm eVNlbGVjdGlvbihGcmFtZSogZnJhbWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29u c3QgU3RyaW5nJikKQEAgLTY1NCw3ICs2NTUsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBh Z2VEb3duQW5kTW9kaWZ5CiAgICAgaW50IGRpc3RhbmNlID0gdmVydGljYWxTY3JvbGxEaXN0YW5j ZShmcmFtZSk7CiAgICAgaWYgKCFkaXN0YW5jZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAg IHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpF WFRFTkQsIGRpc3RhbmNlLCB0cnVlKTsKKyAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5t b2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCBkaXN0YW5jZSwgdHJ1ZSwgU2VsZWN0 aW9uQ29udHJvbGxlcjo6QWxpZ25DdXJzb3JPblNjcm9sbEFsd2F5cyk7CiB9CiAKIHN0YXRpYyBi b29sIGV4ZWN1dGVNb3ZlUGFnZVVwKEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDb21tYW5k U291cmNlLCBjb25zdCBTdHJpbmcmKQpAQCAtNjYyLDcgKzY2Myw3IEBAIHN0YXRpYyBib29sIGV4 ZWN1dGVNb3ZlUGFnZVVwKEZyYW1lKiBmcmEKICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNj cm9sbERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4g ZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNv bnRyb2xsZXI6Ok1PVkUsIC1kaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0dXJuIGZyYW1lLT5zZWxl Y3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1kaXN0YW5jZSwgdHJ1 ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6QWxpZ25DdXJzb3JPblNjcm9sbEFsd2F5cyk7CiB9CiAK IHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2VsZWN0aW9uKEZyYW1lKiBm cmFtZSwgRXZlbnQqLCBFZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpAQCAtNjcw LDcgKzY3MSw3IEBAIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2UKICAg ICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAo IWRpc3RhbmNlKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxl Y3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6OkVYVEVORCwgLWRpc3RhbmNlLCB0 cnVlKTsKKyAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29u dHJvbGxlcjo6RVhURU5ELCAtZGlzdGFuY2UsIHRydWUsIFNlbGVjdGlvbkNvbnRyb2xsZXI6OkFs aWduQ3Vyc29yT25TY3JvbGxBbHdheXMpOwogfQogCiBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVJp Z2h0KEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJp bmcmKQpJbmRleDogV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAkocmV2aXNp b24gNTk0NzcpCisrKyBXZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTc5LDkgKzc5LDkgQEAgU2VsZWN0aW9uQ29udHJvbGxlcjo6U2VsZWN0 aW9uQ29udHJvbGxlcgogICAgIHNldElzRGlyZWN0aW9uYWwoZmFsc2UpOwogfQogCi12b2lkIFNl bGVjdGlvbkNvbnRyb2xsZXI6Om1vdmVUbyhjb25zdCBWaXNpYmxlUG9zaXRpb24gJnBvcywgYm9v bCB1c2VyVHJpZ2dlcmVkKQordm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjptb3ZlVG8oY29uc3Qg VmlzaWJsZVBvc2l0aW9uICZwb3MsIGJvb2wgdXNlclRyaWdnZXJlZCwgQ3Vyc29yQWxpZ25PblNj cm9sbCBhbGlnbikKIHsKLSAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlvbihwb3MuZGVl cEVxdWl2YWxlbnQoKSwgcG9zLmRlZXBFcXVpdmFsZW50KCksIHBvcy5hZmZpbml0eSgpKSwgdHJ1 ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCk7CisgICAgc2V0U2VsZWN0aW9uKFZpc2libGVTZWxlY3Rp b24ocG9zLmRlZXBFcXVpdmFsZW50KCksIHBvcy5kZWVwRXF1aXZhbGVudCgpLCBwb3MuYWZmaW5p dHkoKSksIHRydWUsIHRydWUsIHVzZXJUcmlnZ2VyZWQsIGFsaWduKTsKIH0KIAogdm9pZCBTZWxl Y3Rpb25Db250cm9sbGVyOjptb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZiYXNlLCBjb25z dCBWaXNpYmxlUG9zaXRpb24gJmV4dGVudCwgYm9vbCB1c2VyVHJpZ2dlcmVkKQpAQCAtMTA1LDcg KzEwNSw3IEBAIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0IFAKICAgICBz ZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlvbihiYXNlLCBleHRlbnQsIGFmZmluaXR5KSwgdHJ1 ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCk7CiB9CiAKLXZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6 c2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHMsIGJvb2wgY2xvc2VUeXBpbmcs IGJvb2wgY2xlYXJUeXBpbmdTdHlsZSwgYm9vbCB1c2VyVHJpZ2dlcmVkLCBUZXh0R3JhbnVsYXJp dHkgZ3JhbnVsYXJpdHkpCit2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihj b25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzLCBib29sIGNsb3NlVHlwaW5nLCBib29sIGNsZWFyVHlw aW5nU3R5bGUsIGJvb2wgdXNlclRyaWdnZXJlZCwgQ3Vyc29yQWxpZ25PblNjcm9sbCBhbGlnbiwg VGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5KQogewogICAgIG1fZ3JhbnVsYXJpdHkgPSBncmFu dWxhcml0eTsKIApAQCAtMTYxLDggKzE2MSwxNSBAQCB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6 OnNldFNlbGVjdGlvbihjCiAgICAgc2VsZWN0RnJhbWVFbGVtZW50SW5QYXJlbnRJZkZ1bGx5U2Vs ZWN0ZWQoKTsKICAgICBtX2ZyYW1lLT5ub3RpZnlSZW5kZXJlck9mU2VsZWN0aW9uQ2hhbmdlKHVz ZXJUcmlnZ2VyZWQpOwogICAgIG1fZnJhbWUtPnJlc3BvbmRUb0NoYW5nZWRTZWxlY3Rpb24ob2xk U2VsZWN0aW9uLCBjbG9zZVR5cGluZyk7Ci0gICAgaWYgKHVzZXJUcmlnZ2VyZWQpCi0gICAgICAg IG1fZnJhbWUtPnJldmVhbFNlbGVjdGlvbihTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9FZGdlSWZO ZWVkZWQsIHRydWUpOworICAgIGlmICh1c2VyVHJpZ2dlcmVkKSB7CisgICAgICAgIFNjcm9sbEFs aWdubWVudCBhbGlnbm1lbnQ7CisgICAgICAgIGlmIChtX2ZyYW1lLT5zZXR0aW5ncygpLT5lZGl0 aW5nQmVoYXZpb3IoKSA9PSBFZGl0aW5nTWFjQmVoYXZpb3IpCisgICAgICAgICAgICBhbGlnbm1l bnQgPSAoYWxpZ24gPT0gQWxpZ25DdXJzb3JPblNjcm9sbEFsd2F5cykgPyBTY3JvbGxBbGlnbm1l bnQ6OmFsaWduQ2VudGVyQWx3YXlzIDogU2Nyb2xsQWxpZ25tZW50OjphbGlnbkNlbnRlcklmTmVl ZGVkOworICAgICAgICBlbHNlCisgICAgICAgICAgICBhbGlnbm1lbnQgPSAoYWxpZ24gPT0gQWxp Z25DdXJzb3JPblNjcm9sbEFsd2F5cykgPyBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9wQWx3YXlz IDogU2Nyb2xsQWxpZ25tZW50OjphbGlnblRvRWRnZUlmTmVlZGVkOworCisgICAgICAgIG1fZnJh bWUtPnJldmVhbFNlbGVjdGlvbihhbGlnbm1lbnQsIHRydWUpOworICAgIH0KIAogICAgIG5vdGlm eUFjY2Vzc2liaWxpdHlGb3JTZWxlY3Rpb25DaGFuZ2UoKTsKIH0KQEAgLTcxNCw3ICs3MjEsNyBA QCBzdGF0aWMgYm9vbCBhYnNvbHV0ZUNhcmV0WShjb25zdCBWaXNpYmxlCiAgICAgcmV0dXJuIHRy dWU7CiB9CiAKLWJvb2wgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVBbHRlcmF0aW9uIGFs dGVyLCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dlcmVkKQorYm9vbCBTZWxl Y3Rpb25Db250cm9sbGVyOjptb2RpZnkoRUFsdGVyYXRpb24gYWx0ZXIsIGludCB2ZXJ0aWNhbERp c3RhbmNlLCBib29sIHVzZXJUcmlnZ2VyZWQsIEN1cnNvckFsaWduT25TY3JvbGwgYWxpZ24pCiB7 CiAgICAgaWYgKHZlcnRpY2FsRGlzdGFuY2UgPT0gMCkKICAgICAgICAgcmV0dXJuIGZhbHNlOwpA QCAtNzgyLDcgKzc4OSw3IEBAIGJvb2wgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVBbHRl cmEKIAogICAgIHN3aXRjaCAoYWx0ZXIpIHsKICAgICAgICAgY2FzZSBNT1ZFOgotICAgICAgICAg ICAgbW92ZVRvKHJlc3VsdCwgdXNlclRyaWdnZXJlZCk7CisgICAgICAgICAgICBtb3ZlVG8ocmVz dWx0LCB1c2VyVHJpZ2dlcmVkLCBhbGlnbik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAg Y2FzZSBFWFRFTkQ6CiAgICAgICAgICAgICBzZXRFeHRlbnQocmVzdWx0LCB1c2VyVHJpZ2dlcmVk KTsKSW5kZXg6IFdlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuaAkocmV2aXNpb24gNTk0 NzcpCisrKyBXZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oCSh3b3JraW5nIGNv cHkpCkBAIC00NSw2ICs0NSw4IEBAIGNsYXNzIFNlbGVjdGlvbkNvbnRyb2xsZXIgOiBwdWJsaWMg Tm9uY28KIHB1YmxpYzoKICAgICBlbnVtIEVBbHRlcmF0aW9uIHsgTU9WRSwgRVhURU5EIH07CiAg ICAgZW51bSBFRGlyZWN0aW9uIHsgRk9SV0FSRCwgQkFDS1dBUkQsIFJJR0hULCBMRUZUIH07Cisg ICAgZW51bSBDdXJzb3JBbGlnbk9uU2Nyb2xsIHsgQWxpZ25DdXJzb3JPblNjcm9sbElmTmVlZGVk LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFsaWduQ3Vyc29yT25TY3JvbGxBbHdh eXMgfTsKIAogICAgIFNlbGVjdGlvbkNvbnRyb2xsZXIoRnJhbWUqID0gMCwgYm9vbCBpc0RyYWdD YXJldENvbnRyb2xsZXIgPSBmYWxzZSk7CiAKQEAgLTU0LDE0ICs1NiwxNCBAQCBwdWJsaWM6CiAg ICAgTm9kZSogc2hhZG93VHJlZVJvb3ROb2RlKCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24u c2hhZG93VHJlZVJvb3ROb2RlKCk7IH0KICAgICAgCiAgICAgdm9pZCBtb3ZlVG8oY29uc3QgUmFu Z2UqLCBFQWZmaW5pdHksIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKLSAgICB2b2lkIG1v dmVUbyhjb25zdCBWaXNpYmxlUG9zaXRpb24mLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7 CisgICAgdm9pZCBtb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgYm9vbCB1c2VyVHJpZ2dl cmVkID0gZmFsc2UsIEN1cnNvckFsaWduT25TY3JvbGwgPSBBbGlnbkN1cnNvck9uU2Nyb2xsSWZO ZWVkZWQpOwogICAgIHZvaWQgbW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlvbiYsIGNvbnN0IFZp c2libGVQb3NpdGlvbiYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKICAgICB2b2lkIG1v dmVUbyhjb25zdCBQb3NpdGlvbiYsIEVBZmZpbml0eSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFs c2UpOwogICAgIHZvaWQgbW92ZVRvKGNvbnN0IFBvc2l0aW9uJiwgY29uc3QgUG9zaXRpb24mLCBF QWZmaW5pdHksIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKIAogICAgIGNvbnN0IFZpc2li bGVTZWxlY3Rpb24mIHNlbGVjdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uOyB9Ci0g ICAgdm9pZCBzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgY2xvc2VU eXBpbmcgPSB0cnVlLCBib29sIGNsZWFyVHlwaW5nU3R5bGUgPSB0cnVlLCBib29sIHVzZXJUcmln Z2VyZWQgPSBmYWxzZSwgVGV4dEdyYW51bGFyaXR5ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHkpOwot ICAgIHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHNlbGVjdGlvbiwg VGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5KSB7IHNldFNlbGVjdGlvbihzZWxlY3Rpb24sIHRy dWUsIHRydWUsIGZhbHNlLCBncmFudWxhcml0eSk7IH0KKyAgICB2b2lkIHNldFNlbGVjdGlvbihj b25zdCBWaXNpYmxlU2VsZWN0aW9uJiwgYm9vbCBjbG9zZVR5cGluZyA9IHRydWUsIGJvb2wgY2xl YXJUeXBpbmdTdHlsZSA9IHRydWUsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBDdXJzb3JB bGlnbk9uU2Nyb2xsID0gQWxpZ25DdXJzb3JPblNjcm9sbElmTmVlZGVkLCBUZXh0R3JhbnVsYXJp dHkgPSBDaGFyYWN0ZXJHcmFudWxhcml0eSk7CisgICAgdm9pZCBzZXRTZWxlY3Rpb24oY29uc3Qg VmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkp IHsgc2V0U2VsZWN0aW9uKHNlbGVjdGlvbiwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIEFsaWduQ3Vyc29y T25TY3JvbGxJZk5lZWRlZCwgZ3JhbnVsYXJpdHkpOyB9CiAgICAgYm9vbCBzZXRTZWxlY3RlZFJh bmdlKFJhbmdlKiwgRUFmZmluaXR5LCBib29sIGNsb3NlVHlwaW5nKTsKICAgICB2b2lkIHNlbGVj dEFsbCgpOwogICAgIHZvaWQgY2xlYXIoKTsKQEAgLTc2LDcgKzc4LDcgQEAgcHVibGljOgogICAg IEVBZmZpbml0eSBhZmZpbml0eSgpIGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uLmFmZmluaXR5 KCk7IH0KIAogICAgIGJvb2wgbW9kaWZ5KEVBbHRlcmF0aW9uLCBFRGlyZWN0aW9uLCBUZXh0R3Jh bnVsYXJpdHksIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKLSAgICBib29sIG1vZGlmeShF QWx0ZXJhdGlvbiwgaW50IHZlcnRpY2FsRGlzdGFuY2UsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZh bHNlKTsKKyAgICBib29sIG1vZGlmeShFQWx0ZXJhdGlvbiwgaW50IHZlcnRpY2FsRGlzdGFuY2Us IGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBDdXJzb3JBbGlnbk9uU2Nyb2xsID0gQWxpZ25D dXJzb3JPblNjcm9sbElmTmVlZGVkKTsKICAgICBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHko KSBjb25zdCB7IHJldHVybiBtX2dyYW51bGFyaXR5OyB9CiAKICAgICB2b2lkIHNldFN0YXJ0KGNv bnN0IFZpc2libGVQb3NpdGlvbiAmLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CkluZGV4 OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCShyZXZpc2lvbiA1OTQ4MSkKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBj b3B5KQpAQCAtMSwzICsxLDI1IEBACisyMDEwLTA1LTE0ICBaZWxpZHJhZyBIb3JudW5nICA8emVs aWRyYWdAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIFRoZSB0ZXN0cyBlbnN1cmUgdGhhdCBwYWdlIHVwL2Rvd24gKG9wdGlvbitw YWdlIHVwL2Rvd24gb24gTWFjKSBtb3ZlcworICAgICAgICB0aGUgbW92ZSBjdXJzb3IgKG9wdGlv bi1wYWdlLXVwLWRvd24qKSBhbmQgc2Nyb2xscyB0aGUgY29udGVudAorICAgICAgICAoc2Nyb2xs LXZpZXdwb3J0LXBhZ2UtdXAtZG93biopIHByb3Blcmx5IGluIGNvbnRlbnRlZGl0YWJsZSBlbGVt ZW50cy4KKyAgICAgICAgRXZlbiB0aG91Z2ggdGhlIGN1cnNvciB3aWxsIG1vdmUgZXhhY3RseSB0 byB0aGUgc2FtZSBsb2NhdGlvbiBvbiBhbGwKKyAgICAgICAgcGxhdGZvcm1zLCBwbGVhc2Ugbm90 ZSB0aGF0IE1hYyB3aWxsIHNjcm9sbCB0aGUgdmlzaWJsZSBhcmVhIGJ5IHBsYWNpbmcKKyAgICAg ICAgdGhlIGN1cnNvciBwb3NpdGlvbiBpbiB0aGUgbWlkZGxlLiBBbGwgb3RoZXIgcGxhdGZvcm1z IHdpbGwgc2Nyb2xsIGJ5CisgICAgICAgIGtlZXBpbmcgdGhlIGN1cnNvciBhbGlnbmVkIHdpdGgg dGhlIHRvcCBlZGdlIG9mIHRoZSB2aXNpYmxlIGFyZWEuIAorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzgyMTMKKworICAgICAgICAqIGVkaXRpbmcvaW5w dXQvb3B0aW9uLXBhZ2UtdXAtZG93bi1leHBlY3RlZC50eHQ6IEZpeGVkIHJpZ2dlZCBzY3JvbGwg dGVzdC4KKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbDog RGl0dG8uCisgICAgICAgICogZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLWlucGFn ZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvaW5wdXQvb3B0aW9uLXBh Z2UtdXAtZG93bi1pbnBhZ2UuaHRtbDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9pbnB1dC9z Y3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWRpdi1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAg ICAgICAqIGVkaXRpbmcvaW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAtZG93bi1kaXYuaHRt bDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11 cC1kb3duLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9pbnB1dC9zY3Jv bGwtdmlld3BvcnQtcGFnZS11cC1kb3duLmh0bWw6IEFkZGVkLgorCiAyMDEwLTA1LTE0ICBaaGVu eWFvIE1vICA8em1vQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlk ZWwuCkluZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24t ZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0 aW9uLXBhZ2UtdXAtZG93bi1leHBlY3RlZC50eHQJKHJldmlzaW9uIDU5NDc3KQorKysgTGF5b3V0 VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dAkod29y a2luZyBjb3B5KQpAQCAtMSwzICsxLDMgQEAKLU9uIE1hYywgb3B0aW9uK3BhZ2Vkb3duIHNob3Vs ZCBtb3ZlIHRoZSBtb3VzZSBjdXJzb3IgYW5kIHNjcm9sbCBpbiB0ZXh0IGFyZWFzLiBPbiBvdGhl ciBwbGF0Zm9ybXMsIHBhZ2Vkb3duIHNob3VsZCBtb3ZlIHRoZSBtb3VzZSBjdXJzb3IgYW5kIHNj cm9sbCBpbiB0ZXh0IGFyZWFzLiBUaGlzIHRlc3QgcmVxdWlyZXMgRFJUIHRvIHBhc3MuCitQYWdl IHVwL2Rvd24gKG9wdGlvbitwYWdlIHVwL2Rvd24gb24gTWFjKSBzaG91bGQgbW92ZSB0aGUgbW92 ZSBjdXJzb3IgYW5kIHNjcm9sbCB0aGUgY29udGVudCBpbiBjb250ZW50ZWRpdGFibGUgZWxlbWVu dHMuIFRoaXMgc2FtcGxlIGNvdmVycyBjdXJzb3IgcG9zaXRpb24gbW92ZSB0ZXN0IG9mIGlmcmFt ZSBlbGVtZW50IGNvbnRhaW5pbmcgY29udGVudGVkaXRhYmxlIGJvZHkuCiAKIFBBU1MKSW5kZXg6 IExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi1pbnBhZ2UtZXhw ZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9u LXBhZ2UtdXAtZG93bi1pbnBhZ2UtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0 VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLWlucGFnZS1leHBlY3RlZC50 eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjIgQEAKK1BhZ2UgdXAvZG93biAob3B0aW9uK3Bh Z2UgdXAvZG93biBvbiBNYWMpIHNob3VsZCBtb3ZlIHRoZSBtb3ZlIGN1cnNvciBhbmQgc2Nyb2xs IHRoZSBjb250ZW50IGluIGNvbnRlbnRlZGl0YWJsZSBlbGVtZW50cy4gVGhpcyBzYW1wbGUgY292 ZXJzIGN1cnNvciBwb3NpdGlvbiBtb3ZlIHRlc3Qgb2YgY29udGVudGVkaXRhYmxlIGRpdiBlbGVt ZW50IHdpdGhpbiB0aGUgcGFnZS4KK2xpbmUgMAorCitsaW5lIDEKKworbGluZSAyCisKK2xpbmUg MworCitsaW5lIDQKKworbGluZSA1CisKK2xpbmUgNgorCitsaW5lIDcKKworbGluZSA4CisKK2xp bmUgOQorCitQQVNTCkluZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L29wdGlvbi1wYWdl LXVwLWRvd24taW5wYWdlLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy9p bnB1dC9vcHRpb24tcGFnZS11cC1kb3duLWlucGFnZS5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5 b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLWlucGFnZS5odG1sCShy ZXZpc2lvbiAwKQpAQCAtMCwwICsxLDY3IEBACis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRU ZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisK K2Z1bmN0aW9uIHJ1blRlc3QoKQoreworICAgIHZhciBlZGl0YWJsZSA9IGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCdlZGl0YWJsZScpOworICAgIHZhciBjb250ZW50ID0gIiI7CisgICAgZm9yICh2 YXIgaSA9IDA7IGkgPCAxMDsgKytpKQorICAgICAgICBjb250ZW50ICs9ICI8cD5saW5lICIgKyBp ICsgIjwvcD5cbiI7CisgICAgZWRpdGFibGUuaW5uZXJIVE1MID0gY29udGVudDsKKyAgICBlZGl0 YWJsZS5mb2N1cygpOworICAgIHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5zZXRQb3NpdGlvbihlZGl0 YWJsZSwgMCk7CisKKyAgICB2YXIgb25NYWNQbGF0Zm9ybSA9IG5hdmlnYXRvci51c2VyQWdlbnQu c2VhcmNoKC9cYk1hYyBPUyBYXGIvKSAhPSAtMTsKKyAgICB2YXIgbW9kaWZpZXJzID0gb25NYWNQ bGF0Zm9ybSA/IFsiYWx0S2V5Il0gOiBbXTsKKworICAgIGlmICghd2luZG93LmV2ZW50U2VuZGVy KQorICAgICAgICByZXR1cm47CisKKyAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIs IG1vZGlmaWVycyk7CisgICAgdmFyIGxpbmUgPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuYmFzZU5v ZGUubm9kZVZhbHVlOworICAgIGlmIChsaW5lICE9ICJsaW5lIDMiKSB7CisgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHRzIikuaW5uZXJUZXh0ID0gImN1cnNvciBzaG91bGQg YmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7CisgICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxk IGJlIGF0IGxpbmUgMywgbm90ICIgKyBsaW5lOworICAgIH0KKworICAgIGV2ZW50U2VuZGVyLmtl eURvd24oInBhZ2VEb3duIiwgbW9kaWZpZXJzKTsKKyAgICB2YXIgbGluZSA9IHdpbmRvdy5nZXRT ZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUgNiIp IHsKKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lclRleHQg PSAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDYsIG5vdCAiICsgbGluZTsKKyAgICAgICAgdGhy b3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSA2LCBub3QgIiArIGxpbmU7CisgICAgfQorCisg ICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZVVwIiwgbW9kaWZpZXJzKTsKKyAgICB2YXIgbGlu ZSA9IHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgaWYgKGxp bmUgIT0gImxpbmUgMyIpIHsKKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3Vs dHMiKS5pbm5lclRleHQgPSAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGlu ZTsKKyAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxp bmU7CisgICAgfQorCisgICAgLy8gVGVzdCB0aGF0IG9uIE1hYyBwYWdlRG93bi9wYWdlVXAgZG9l cyBub3QgbW92ZSB0aGUgY3Vyc29yIGF0IGFsbC4KKyAgICBpZiAob25NYWNQbGF0Zm9ybSkgewor ICAgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBbXSk7CisgICAgICB2YXIgbGlu ZSA9IHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgICBpZiAo bGluZSAhPSAibGluZSAzIikgeworICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJy ZXN1bHRzIikuaW5uZXJUZXh0ID0gImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiAr IGxpbmU7CisgICAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3Qg IiArIGxpbmU7CisgICAgICB9CisKKyAgICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VVcCIs IFtdKTsKKyAgICAgIHZhciBsaW5lID0gd2luZG93LmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5v ZGVWYWx1ZTsKKyAgICAgIGlmIChsaW5lICE9ICJsaW5lIDMiKSB7CisgICAgICAgICAgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lclRleHQgPSAiY3Vyc29yIHNob3VsZCBi ZSBhdCBsaW5lIDMsIG5vdCAiICsgbGluZTsKKyAgICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3Vs ZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGluZTsKKyAgICAgIH0KKyAgICB9CisgICAgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lclRleHQgPSAiUEFTUyI7Cit9Cis8L3Nj cmlwdD4KKzxib2R5IG9ubG9hZD0icnVuVGVzdCgpIj4KKzxkaXY+UGFnZSB1cC9kb3duIChvcHRp b24rcGFnZSB1cC9kb3duIG9uIE1hYykgc2hvdWxkIG1vdmUgdGhlIG1vdmUgY3Vyc29yIGFuZCBz Y3JvbGwgdGhlIGNvbnRlbnQKK2luIGNvbnRlbnRlZGl0YWJsZSBlbGVtZW50cy4gVGhpcyBzYW1w bGUgY292ZXJzIGN1cnNvciBwb3NpdGlvbiBtb3ZlIHRlc3Qgb2YgY29udGVudGVkaXRhYmxlCitk aXYgZWxlbWVudCB3aXRoaW4gdGhlIHBhZ2UuPC9kaXY+Cis8ZGl2IGlkPSJlZGl0YWJsZSIgY29u dGVudGVkaXRhYmxlPSJ0cnVlIiBzdHlsZT0iaGVpZ2h0OjE1MHB4O292ZXJmbG93OmF1dG87Ij48 L2Rpdj4KKzxkaXYgaWQ9InJlc3VsdHMiPkZBSUw8L2Rpdj4KKzwvYm9keT4KSW5kZXg6IExheW91 dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sCShy ZXZpc2lvbiA1OTQ3NykKKysrIExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2Ut dXAtZG93bi5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC0yMCwyNSArMjAsNDIgQEAgZnVuY3Rpb24g cnVuVGVzdCgpCiAKICAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIsIG1vZGlmaWVy cyk7CiAgICAgdmFyIGxpbmUgPSBmcmFtZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFs dWU7Ci0gICAgaWYgKGxpbmUgIT0gImxpbmUgOCIpCi0gICAgICAgIHRocm93ICJjdXJzb3Igc2hv dWxkIGJlIGF0IGxpbmUgOCwgbm90ICIgKyBsaW5lOworICAgIGlmIChsaW5lICE9ICJsaW5lIDMi KQorICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGlu ZTsKIAogICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3duIiwgbW9kaWZpZXJzKTsKICAg ICB2YXIgbGluZSA9IGZyYW1lLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKLSAg ICBpZiAobGluZSAhPSAibGluZSA5IikKLSAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUg YXQgbGluZSA5LCBub3QgIiArIGxpbmU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUgNiIpCisgICAg ICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgNiwgbm90ICIgKyBsaW5lOwogCiAg ICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZVVwIiwgbW9kaWZpZXJzKTsKICAgICB2YXIgbGlu ZSA9IGZyYW1lLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKLSAgICBpZiAobGlu ZSAhPSAibGluZSAxIikKLSAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAx LCBub3QgIiArIGxpbmU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUgMyIpCisgICAgICAgIHRocm93 ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMywgbm90ICIgKyBsaW5lOworCisgICAgLy8gVGVz dCB0aGF0IG9uIE1hYyBwYWdlRG93bi9wYWdlVXAgZG9lcyBub3QgbW92ZSB0aGUgY3Vyc29yIGF0 IGFsbC4KKyAgICBpZiAob25NYWNQbGF0Zm9ybSkgeworICAgICAgZXZlbnRTZW5kZXIua2V5RG93 bigicGFnZURvd24iLCBbXSk7CisgICAgICB2YXIgbGluZSA9IGZyYW1lLmdldFNlbGVjdGlvbigp LmJhc2VOb2RlLm5vZGVWYWx1ZTsKKyAgICAgIGlmIChsaW5lICE9ICJsaW5lIDMiKSB7CisgICAg ICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lclRleHQgPSAiY3Vy c29yIHNob3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGluZTsKKyAgICAgICAgICB0aHJvdyAi Y3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGluZTsKKyAgICAgIH0KKworICAg ICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZVVwIiwgW10pOworICAgICAgdmFyIGxpbmUgPSBm cmFtZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgICBpZiAobGluZSAh PSAibGluZSAzIikgeworICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHRz IikuaW5uZXJUZXh0ID0gImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7 CisgICAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxp bmU7CisgICAgICB9CisgICAgfQogCiAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3Vs dHMiKS5pbm5lclRleHQgPSAiUEFTUyI7CiB9CiA8L3NjcmlwdD4KIAotPGRpdj5PbiBNYWMsIG9w dGlvbitwYWdlZG93biBzaG91bGQgbW92ZSB0aGUgbW91c2UgY3Vyc29yIGFuZCBzY3JvbGwgaW4g dGV4dCBhcmVhcy4gIE9uCi1vdGhlciBwbGF0Zm9ybXMsIHBhZ2Vkb3duIHNob3VsZCBtb3ZlIHRo ZSBtb3VzZSBjdXJzb3IgYW5kIHNjcm9sbCBpbiB0ZXh0IGFyZWFzLiAgVGhpcwotdGVzdCByZXF1 aXJlcyBEUlQgdG8gcGFzcy48L2Rpdj4KKzxkaXY+UGFnZSB1cC9kb3duIChvcHRpb24rcGFnZSB1 cC9kb3duIG9uIE1hYykgc2hvdWxkIG1vdmUgdGhlIG1vdmUgY3Vyc29yIGFuZCBzY3JvbGwgdGhl IGNvbnRlbnQKK2luIGNvbnRlbnRlZGl0YWJsZSBlbGVtZW50cy4gVGhpcyBzYW1wbGUgY292ZXJz IGN1cnNvciBwb3NpdGlvbiBtb3ZlIHRlc3Qgb2YgaWZyYW1lIGVsZW1lbnQKK2NvbnRhaW5pbmcg Y29udGVudGVkaXRhYmxlIGJvZHkuPC9kaXY+CiA8aWZyYW1lIHNyYz0iLi4vcmVzb3VyY2VzL2Nv bnRlbnRlZGl0YWJsZS1pZnJhbWUtc3JjLmh0bWwiIG9ubG9hZD0icnVuVGVzdCgpIj48L2lmcmFt ZT4KIDxkaXYgaWQ9InJlc3VsdHMiPkZBSUw8L2Rpdj4KSW5kZXg6IExheW91dFRlc3RzL2VkaXRp bmcvaW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAtZG93bi1kaXYtZXhwZWN0ZWQudHh0Cj09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBh Z2UtdXAtZG93bi1kaXYtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWRpdi1leHBlY3RlZC50 eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMyBAQAorUGFnZSB1cC9kb3duIChvcHRpb24rcGFn ZSB1cC9kb3duIG9uIE1hYykgc2hvdWxkIG1vdmUgdGhlIG1vdmUgY3Vyc29yIGFuZCBzY3JvbGwg dGhlIGNvbnRlbnQgaW4gY29udGVudGVkaXRhYmxlIGVsZW1lbnRzLiBUaGlzIHNhbXBsZSBjb3Zl cnMgc2Nyb2xsIHBvc2l0aW9uIHRlc3Qgb2YgaWZyYW1lIGVsZW1lbnQgY29udGFpbmluZyBjb250 ZW50ZWRpdGFibGUgYm9keS4gRXZlbiB0aG91Z2ggdGhlIGN1cnNvciB3aWxsIG1vdmUgZXhhY3Rs eSB0byB0aGUgc2FtZSBsb2NhdGlvbiBvbiBhbGwgcGxhdGZvcm1zIChjb3ZlcmVkIGJ5IHRlc3Qg b3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sKSwgcGxlYXNlIG5vdGUgdGhhdCBNYWMgd2lsbCBzY3Jv bGwgdGhlIHZpc2libGUgYXJlYSBieSBwbGFjaW5nIHRoZSBjdXJzb3IgcG9zaXRpb24gaW4gdGhl IG1pZGRsZS4gQWxsIG90aGVyIHBsYXRmb3JtcyB3aWxsIHNjcm9sbCBieSBrZWVwaW5nIHRoZSBj dXJzb3IgYWxpZ25lZCB3aXRoIHRoZSB0b3AgZWRnZSBvZiB0aGUgdmlzaWJsZSBhcmVhLgorCitQ QVNTCkluZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdl LXVwLWRvd24tZGl2Lmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1 dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWRpdi5odG1sCShyZXZpc2lvbiAwKQorKysg TGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWRp di5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDYxIEBACis8c2NyaXB0PgoraWYgKHdpbmRv dy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNU ZXh0KCk7CisKK2Z1bmN0aW9uIHJ1blRlc3QoKSB7CisgICAgdmFyIHRvbGVyYW5jZSA9IDEwOwor ICAgIHZhciBmcmFtZSA9IGZyYW1lc1swXTsKKyAgICB2YXIgZG9jID0gZnJhbWUuZG9jdW1lbnQ7 CisgICAgdmFyIGJvZHkgPSBkb2MuYm9keTsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IDEwOyAr K2kpCisgICAgICAgIGJvZHkuaW5uZXJIVE1MICs9ICI8cD5saW5lICIgKyBpICsgIjwvcD5cbiI7 CisgICAgZnJhbWUuZm9jdXMoKTsKKyAgICBmcmFtZS5nZXRTZWxlY3Rpb24oKS5zZXRQb3NpdGlv bihib2R5LmZpcnN0Q2hpbGQsIDApOworCisgICAgdmFyIG9uTWFjUGxhdGZvcm0gPSBuYXZpZ2F0 b3IudXNlckFnZW50LnNlYXJjaCgvXGJNYWMgT1MgWFxiLykgIT0gLTE7CisgICAgdmFyIG1vZGlm aWVycyA9IG9uTWFjUGxhdGZvcm0gPyBbImFsdEtleSJdIDogW107CisgICAgCisgICAgaWYgKG9u TWFjUGxhdGZvcm0pCisgICAgICAgIG9mZnNldHMgPSBbIDUxLCAxNTkgXTsKKyAgICBlbHNlIAor ICAgICAgICBvZmZzZXRzID0gWyAxMTYsIDIxOCBdOworCisgICAgaWYgKCF3aW5kb3cuZXZlbnRT ZW5kZXIpCisgICAgICAgIHJldHVybjsKKworICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VE b3duIiwgbW9kaWZpZXJzKTsKKyAgICBpZiAoTWF0aC5hYnMoZnJhbWUucGFnZVlPZmZzZXQgLSBv ZmZzZXRzWzBdKSA+IHRvbGVyYW5jZSkgeworICAgICAgICB0aHJvdyAiRnJhbWUgdmlld3BvcnQg c2hvdWxkIGJlIGFyb3VuZCAiICsgb2Zmc2V0c1swXSArCisgICAgICAgICAgICAicHggLCBub3Qg YXQgIiArIGZyYW1lLnBhZ2VZT2Zmc2V0OworICAgIH0KKworICAgIGV2ZW50U2VuZGVyLmtleURv d24oInBhZ2VEb3duIiwgbW9kaWZpZXJzKTsKKyAgICB2YXIgbGluZSA9IGZyYW1lLmdldFNlbGVj dGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKKyAgICBpZiAoTWF0aC5hYnMoZnJhbWUucGFnZVlP ZmZzZXQgLSBvZmZzZXRzWzFdKSA+IHRvbGVyYW5jZSkgeworICAgICAgICB0aHJvdyAiRnJhbWUg dmlld3BvcnQgc2hvdWxkIGJlIGFyb3VuZCAiICsgb2Zmc2V0c1sxXSArCisgICAgICAgICAgICAi cHggLCBub3QgIiArIGZyYW1lLnBhZ2VZT2Zmc2V0OworICAgIH0KKworICAgIGV2ZW50U2VuZGVy LmtleURvd24oInBhZ2VVcCIsIG1vZGlmaWVycyk7CisgICAgdmFyIGxpbmUgPSBmcmFtZS5nZXRT ZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgaWYgKE1hdGguYWJzKGZyYW1lLnBh Z2VZT2Zmc2V0IC0gb2Zmc2V0c1swXSkgPiB0b2xlcmFuY2UpIHsKKyAgICAgICAgdGhyb3cgIkZy YW1lIHZpZXdwb3J0IHNob3VsZCBiZSBhcm91bmQgIiArIG9mZnNldHNbMF0gKworICAgICAgICAg ICAgInB4ICwgbm90IGF0ICIgKyBmcmFtZS5wYWdlWU9mZnNldDsKKyAgICB9CisKKyAgICBkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgicmVzdWx0cyIpLmlubmVyVGV4dCA9ICJQQVNTIjsKK30KKzwv c2NyaXB0PgorPGJvZHkgb25sb2FkPSJydW5UZXN0KCkiPgorPGRpdj5QYWdlIHVwL2Rvd24gKG9w dGlvbitwYWdlIHVwL2Rvd24gb24gTWFjKSBzaG91bGQgbW92ZSB0aGUgbW92ZSBjdXJzb3IgYW5k IHNjcm9sbCB0aGUgY29udGVudAoraW4gY29udGVudGVkaXRhYmxlIGVsZW1lbnRzLiBUaGlzIHNh bXBsZSBjb3ZlcnMgc2Nyb2xsIHBvc2l0aW9uIHRlc3Qgb2YgaWZyYW1lIGVsZW1lbnQgY29udGFp bmluZworY29udGVudGVkaXRhYmxlIGJvZHkuIEV2ZW4gdGhvdWdoIHRoZSBjdXJzb3Igd2lsbCBt b3ZlIGV4YWN0bHkgdG8gdGhlIHNhbWUgbG9jYXRpb24gb24gYWxsIHBsYXRmb3JtcworKGNvdmVy ZWQgYnkgdGVzdCBvcHRpb24tcGFnZS11cC1kb3duLmh0bWwpLCBwbGVhc2Ugbm90ZSB0aGF0IE1h YyB3aWxsIHNjcm9sbCB0aGUgdmlzaWJsZSBhcmVhCitieSBwbGFjaW5nIHRoZSBjdXJzb3IgcG9z aXRpb24gaW4gdGhlIG1pZGRsZS4gQWxsIG90aGVyIHBsYXRmb3JtcyB3aWxsIHNjcm9sbCBieQor a2VlcGluZyB0aGUgY3Vyc29yIGFsaWduZWQgd2l0aCB0aGUgdG9wIGVkZ2Ugb2YgdGhlIHZpc2li bGUgYXJlYS4gCis8L2Rpdj4KKzxkaXYgaWQ9ImVkaXRhYmxlIiBjb250ZW50ZWRpdGFibGU9InRy dWUiIHN0eWxlPSJoZWlnaHQ6MTUwcHg7b3ZlcmZsb3c6YXV0bzsiPjwvZGl2PgorPGlmcmFtZSBz cmM9Ii4uL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUtaWZyYW1lLXNyYy5odG1sIiBvbmxvYWQ9 InJ1blRlc3QoKSI+PC9pZnJhbWU+Cis8ZGl2IGlkPSJlZGl0YWJsZSIgY29udGVudGVkaXRhYmxl PSJ0cnVlIiBzdHlsZT0iaGVpZ2h0OjE1MHB4O292ZXJmbG93OmF1dG87Ij48L2Rpdj4KKzxkaXYg aWQ9InJlc3VsdHMiPkZBSUw8L2Rpdj4KKzwvYm9keT4KSW5kZXg6IExheW91dFRlc3RzL2VkaXRp bmcvaW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAtZG93bi1leHBlY3RlZC50eHQKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11 cC1kb3duLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2VkaXRpbmcv aW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAtZG93bi1leHBlY3RlZC50eHQJKHJldmlzaW9u IDApCkBAIC0wLDAgKzEsMyBAQAorUGFnZSB1cC9kb3duIChvcHRpb24rcGFnZSB1cC9kb3duIG9u IE1hYykgc2hvdWxkIG1vdmUgdGhlIG1vdmUgY3Vyc29yIGFuZCBzY3JvbGwgdGhlIGNvbnRlbnQg aW4gY29udGVudGVkaXRhYmxlIGVsZW1lbnRzLiBUaGlzIHNhbXBsZSBjb3ZlcnMgc2Nyb2xsIHBv c2l0aW9uIHRlc3Qgb2YgaWZyYW1lIGVsZW1lbnQgY29udGFpbmluZyBjb250ZW50ZWRpdGFibGUg Ym9keS4gRXZlbiB0aG91Z2ggdGhlIGN1cnNvciB3aWxsIG1vdmUgZXhhY3RseSB0byB0aGUgc2Ft ZSBsb2NhdGlvbiBvbiBhbGwgcGxhdGZvcm1zIChjb3ZlcmVkIGJ5IHRlc3Qgb3B0aW9uLXBhZ2Ut dXAtZG93bi5odG1sKSwgcGxlYXNlIG5vdGUgdGhhdCBNYWMgd2lsbCBzY3JvbGwgdGhlIHZpc2li bGUgYXJlYSBieSBwbGFjaW5nIHRoZSBjdXJzb3IgcG9zaXRpb24gaW4gdGhlIG1pZGRsZS4gQWxs IG90aGVyIHBsYXRmb3JtcyB3aWxsIHNjcm9sbCBieSBrZWVwaW5nIHRoZSBjdXJzb3IgYWxpZ25l ZCB3aXRoIHRoZSB0b3AgZWRnZSBvZiB0aGUgdmlzaWJsZSBhcmVhLgorCitQQVNTCkluZGV4OiBM YXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24uaHRt bAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9y dC1wYWdlLXVwLWRvd24uaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2VkaXRpbmcv aW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAtZG93bi5odG1sCShyZXZpc2lvbiAwKQpAQCAt MCwwICsxLDU3IEBACis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikK KyAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKK2Z1bmN0aW9uIHJ1blRl c3QoKSB7CisgICAgdmFyIHRvbGVyYW5jZSA9IDEwOworICAgIHZhciBmcmFtZSA9IGZyYW1lc1sw XTsKKyAgICB2YXIgZG9jID0gZnJhbWUuZG9jdW1lbnQ7CisgICAgdmFyIGJvZHkgPSBkb2MuYm9k eTsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IDEwOyArK2kpCisgICAgICAgIGJvZHkuaW5uZXJI VE1MICs9ICI8cD5saW5lICIgKyBpICsgIjwvcD5cbiI7CisgICAgZnJhbWUuZm9jdXMoKTsKKyAg ICBmcmFtZS5nZXRTZWxlY3Rpb24oKS5zZXRQb3NpdGlvbihib2R5LmZpcnN0Q2hpbGQsIDApOwor CisgICAgdmFyIG9uTWFjUGxhdGZvcm0gPSBuYXZpZ2F0b3IudXNlckFnZW50LnNlYXJjaCgvXGJN YWMgT1MgWFxiLykgIT0gLTE7CisgICAgdmFyIG1vZGlmaWVycyA9IG9uTWFjUGxhdGZvcm0gPyBb ImFsdEtleSJdIDogW107CisgICAgCisgICAgaWYgKG9uTWFjUGxhdGZvcm0pCisgICAgICAgIG9m ZnNldHMgPSBbIDUxLCAxNTkgXTsKKyAgICBlbHNlIAorICAgICAgICBvZmZzZXRzID0gWyAxMTYs IDIxOCBdOworCisgICAgaWYgKCF3aW5kb3cuZXZlbnRTZW5kZXIpCisgICAgICAgIHJldHVybjsK KworICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3duIiwgbW9kaWZpZXJzKTsKKyAgICBp ZiAoTWF0aC5hYnMoZnJhbWUucGFnZVlPZmZzZXQgLSBvZmZzZXRzWzBdKSA+IHRvbGVyYW5jZSkg eworICAgICAgICB0aHJvdyAiRnJhbWUgdmlld3BvcnQgc2hvdWxkIGJlIGFyb3VuZCAiICsgb2Zm c2V0c1swXSArCisgICAgICAgICAgICAicHggLCBub3QgYXQgIiArIGZyYW1lLnBhZ2VZT2Zmc2V0 OworICAgIH0KKworICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3duIiwgbW9kaWZpZXJz KTsKKyAgICB2YXIgbGluZSA9IGZyYW1lLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1 ZTsKKyAgICBpZiAoTWF0aC5hYnMoZnJhbWUucGFnZVlPZmZzZXQgLSBvZmZzZXRzWzFdKSA+IHRv bGVyYW5jZSkgeworICAgICAgICB0aHJvdyAiRnJhbWUgdmlld3BvcnQgc2hvdWxkIGJlIGFyb3Vu ZCAiICsgb2Zmc2V0c1sxXSArCisgICAgICAgICAgICAicHggLCBub3QgIiArIGZyYW1lLnBhZ2VZ T2Zmc2V0OworICAgIH0KKworICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VVcCIsIG1vZGlm aWVycyk7CisgICAgdmFyIGxpbmUgPSBmcmFtZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2Rl VmFsdWU7CisgICAgaWYgKE1hdGguYWJzKGZyYW1lLnBhZ2VZT2Zmc2V0IC0gb2Zmc2V0c1swXSkg PiB0b2xlcmFuY2UpIHsKKyAgICAgICAgdGhyb3cgIkZyYW1lIHZpZXdwb3J0IHNob3VsZCBiZSBh cm91bmQgIiArIG9mZnNldHNbMF0gKworICAgICAgICAgICAgInB4ICwgbm90IGF0ICIgKyBmcmFt ZS5wYWdlWU9mZnNldDsKKyAgICB9CisKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicmVz dWx0cyIpLmlubmVyVGV4dCA9ICJQQVNTIjsKK30KKzwvc2NyaXB0PgorCis8ZGl2PlBhZ2UgdXAv ZG93biAob3B0aW9uK3BhZ2UgdXAvZG93biBvbiBNYWMpIHNob3VsZCBtb3ZlIHRoZSBtb3ZlIGN1 cnNvciBhbmQgc2Nyb2xsIHRoZSBjb250ZW50CitpbiBjb250ZW50ZWRpdGFibGUgZWxlbWVudHMu IFRoaXMgc2FtcGxlIGNvdmVycyBzY3JvbGwgcG9zaXRpb24gdGVzdCBvZiBpZnJhbWUgZWxlbWVu dCBjb250YWluaW5nCitjb250ZW50ZWRpdGFibGUgYm9keS4gRXZlbiB0aG91Z2ggdGhlIGN1cnNv ciB3aWxsIG1vdmUgZXhhY3RseSB0byB0aGUgc2FtZSBsb2NhdGlvbiBvbiBhbGwgcGxhdGZvcm1z CisoY292ZXJlZCBieSB0ZXN0IG9wdGlvbi1wYWdlLXVwLWRvd24uaHRtbCksIHBsZWFzZSBub3Rl IHRoYXQgTWFjIHdpbGwgc2Nyb2xsIHRoZSB2aXNpYmxlIGFyZWEKK2J5IHBsYWNpbmcgdGhlIGN1 cnNvciBwb3NpdGlvbiBpbiB0aGUgbWlkZGxlLiBBbGwgb3RoZXIgcGxhdGZvcm1zIHdpbGwgc2Ny b2xsIGJ5CitrZWVwaW5nIHRoZSBjdXJzb3IgYWxpZ25lZCB3aXRoIHRoZSB0b3AgZWRnZSBvZiB0 aGUgdmlzaWJsZSBhcmVhLiA8L2Rpdj4KKzxpZnJhbWUgc3JjPSIuLi9yZXNvdXJjZXMvY29udGVu dGVkaXRhYmxlLWlmcmFtZS1zcmMuaHRtbCIgb25sb2FkPSJydW5UZXN0KCkiPjwvaWZyYW1lPgor PGRpdiBpZD0icmVzdWx0cyI+RkFJTDwvZGl2Pgo= 56740 2010-05-21 13:08:40 -0700 2010-05-21 15:08:10 -0700 latest comments addressed, merged cursor/scroll tests, ahem fonts... WK_38213.patch text/plain 23429 zelidrag SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1OTk0NCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzIgQEAKKzIwMTAtMDUtMjEgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgRml4ZWQgZnJhbWUgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBjYWxjdWxhdGlvbi4gTWFk ZSBzdXJlIHRoYXQgdGhlCisgICAgICAgIGN1cnNvciBtb3ZlcyB3aXRoIHBhZ2UgdXAvZG93biBl dmVudC4gUGxlYXNlIG5vdGUgdGhhdCBub3cgZm9yIG1hYworICAgICAgICBlZGl0aW5nIGJlaGF2 aW9yIHdlIHdpbGwgc2Nyb2xsIHRoZSBjb250ZW50IHRvIGNlbnRlciB0aGUgY3Vyc29yIG9uCisg ICAgICAgIHBhZ2UgdXAvZG93biB3aGlsZSBvdGhlciBwbGF0Zm9ybXMgd2lsbCBhbGlnbiB0aGUg Y3Vyc29yIHdpdGggdGhlIHRvcCBvZgorICAgICAgICBkaXNwbGF5ZWQgZnJhbWUuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zODIxMworCisgICAgICAg IFRlc3RzOiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbCAoZml4ZWQpCisg ICAgICAgICAgICAgICBlZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24u aHRtbAorCisgICAgICAgICogV2ViQ29yZS5iYXNlLmV4cDoKKyAgICAgICAgKiBlZGl0aW5nL0Vk aXRvckNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6dmVydGljYWxTY3JvbGxEaXN0YW5j ZSk6IEZpeGVkIHBhZ2Ugc2Nyb2xsIGNhbGN1bGF0aW9uLiBOb3cgc2Nyb2xsIGhlaWdodCBpcyBj YWxjdWxhdGVkIG9ubHkgZnJvbSB0aGUgdmlzaWJsZSBwb3J0aW9uIG5vdCB0aGUgZW50aXJlIGZy YW1lIGhlaWdodC4KKyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVNb3ZlUGFnZURvd24pOiBOb3cg aXQgY2FuIHRlbGwgU2VsZWN0aW9uQ29udHJvbGxlciB0byBtb3ZlIHRoZSBjdXJzb3Igd2l0aCB0 aGUgcGFnZSBzY3JvbGwgdXAvZG93biBldmVudHMuCisgICAgICAgIChXZWJDb3JlOjpleGVjdXRl TW92ZVBhZ2VEb3duQW5kTW9kaWZ5U2VsZWN0aW9uKTogRGl0dG8uCisgICAgICAgIChXZWJDb3Jl OjpleGVjdXRlTW92ZVBhZ2VVcCk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZU1v dmVQYWdlVXBBbmRNb2RpZnlTZWxlY3Rpb24pOiBEaXR0by4KKyAgICAgICAgKiBlZGl0aW5nL1Nl bGVjdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAqIGVkaXRpbmcvU2VsZWN0aW9uQ29udHJv bGxlci5jcHA6IEV4cG9zZWQgYW4gZW51bSBwYXJhbSB0aGF0IGxldHMgRWRpdG9yQ29tbWFuZC5j cHAgY29udHJvbCBob3cgY3Vyc29yIHBvc2l0aW9uIHdpbGwgYmUgYWxpZ25lZCB3aGVuIHBhZ2Ug bW92ZXMuCisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rp b24pOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vZGlm eSk6IERpdHRvLgorICAgICAgICAqIGVkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oOiBEaXR0 by4KKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6Oik6IERpdHRvLgorICAg ICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKTogRGl0dG8u CisKIDIwMTAtMDUtMjEgIEdlb2ZmcmV5IEdhcmVuICA8Z2dhcmVuQGFwcGxlLmNvbT4KIAogICAg ICAgICBSZXZpZXdlZCBieSBPbGl2ZXIgSHVudC4KSW5kZXg6IFdlYkNvcmUvV2ViQ29yZS5iYXNl LmV4cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAJKHJldmlzaW9uIDU5 OTQyKQorKysgV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhwCSh3b3JraW5nIGNvcHkpCkBAIC00MjAs NyArNDIwLDcgQEAgX19aTjdXZWJDb3JlMTlBbmltYXRpb25Db250cm9sbGVyMjFwYXVzZQogX19a TjdXZWJDb3JlMTlDU1NTdHlsZURlY2xhcmF0aW9uMTFzZXRQcm9wZXJ0eUVSS05TXzZTdHJpbmdF UzNfUmkKIF9fWk43V2ViQ29yZTE5SW5zcGVjdG9yQ29udHJvbGxlcjM0aW5zcGVjdG9yU3RhcnRz QXR0YWNoZWRTZXR0aW5nTmFtZUV2CiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIx MHNldEZvY3VzZWRFYgotX19aTjdXZWJDb3JlMTlTZWxlY3Rpb25Db250cm9sbGVyMTJzZXRTZWxl Y3Rpb25FUktOU18xNlZpc2libGVTZWxlY3Rpb25FYmJiTlNfMTVUZXh0R3JhbnVsYXJpdHlFCitf X1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIxMnNldFNlbGVjdGlvbkVSS05TXzE2Vmlz aWJsZVNlbGVjdGlvbkViYmJOUzBfMTlDdXJzb3JBbGlnbk9uU2Nyb2xsRU5TXzE1VGV4dEdyYW51 bGFyaXR5RQogX19aTjdXZWJDb3JlMTlTZWxlY3Rpb25Db250cm9sbGVyMTZzZXRTZWxlY3RlZFJh bmdlRVBOU181UmFuZ2VFTlNfOUVBZmZpbml0eUViCiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNv bnRyb2xsZXI1Y2xlYXJFdgogX19aTjdXZWJDb3JlMTlTZWxlY3Rpb25Db250cm9sbGVyNm1vZGlm eUVOUzBfMTFFQWx0ZXJhdGlvbkVOUzBfMTBFRGlyZWN0aW9uRU5TXzE1VGV4dEdyYW51bGFyaXR5 RWIKSW5kZXg6IFdlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAJKHJldmlzaW9uIDU5OTQyKQorKysg V2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00MSwx MyArNDEsMTMgQEAKICNpbmNsdWRlICJFdmVudEhhbmRsZXIuaCIKICNpbmNsdWRlICJGb3JtYXRC bG9ja0NvbW1hbmQuaCIKICNpbmNsdWRlICJGcmFtZS5oIgorI2luY2x1ZGUgIkZyYW1lVmlldy5o IgogI2luY2x1ZGUgIkhUTUxGb250RWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxIUkVsZW1lbnQu aCIKICNpbmNsdWRlICJIVE1MSW1hZ2VFbGVtZW50LmgiCiAjaW5jbHVkZSAiSW5kZW50T3V0ZGVu dENvbW1hbmQuaCIKICNpbmNsdWRlICJJbnNlcnRMaXN0Q29tbWFuZC5oIgogI2luY2x1ZGUgIlBh Z2UuaCIKLSNpbmNsdWRlICJSZW5kZXJCb3guaCIKICNpbmNsdWRlICJSZXBsYWNlU2VsZWN0aW9u Q29tbWFuZC5oIgogI2luY2x1ZGUgIlNjcm9sbGJhci5oIgogI2luY2x1ZGUgIlNldHRpbmdzLmgi CkBAIC0yNTksNyArMjU5LDggQEAgc3RhdGljIGludCB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKEZy YW1lKgogICAgICAgICByZXR1cm4gMDsKICAgICBpZiAoIShzdHlsZS0+b3ZlcmZsb3dZKCkgPT0g T1NDUk9MTCB8fCBzdHlsZS0+b3ZlcmZsb3dZKCkgPT0gT0FVVE8gfHwgZm9jdXNlZE5vZGUtPmlz Q29udGVudEVkaXRhYmxlKCkpKQogICAgICAgICByZXR1cm4gMDsKLSAgICBpbnQgaGVpZ2h0ID0g dG9SZW5kZXJCb3gocmVuZGVyZXIpLT5jbGllbnRIZWlnaHQoKTsKKyAgICBpbnQgaGVpZ2h0ID0g c3RkOjptaW48aW50Pih0b1JlbmRlckJveChyZW5kZXJlciktPmNsaWVudEhlaWdodCgpLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZyYW1lLT52aWV3KCktPnZpc2libGVIZWlnaHQo KSk7CiAgICAgcmV0dXJuIG1heChtYXg8aW50PihoZWlnaHQgKiBTY3JvbGxiYXI6Om1pbkZyYWN0 aW9uVG9TdGVwV2hlblBhZ2luZygpLCBoZWlnaHQgLSBTY3JvbGxiYXI6Om1heE92ZXJsYXBCZXR3 ZWVuUGFnZXMoKSksIDEpOwogfQogCkBAIC02NDYsNyArNjQ3LDcgQEAgc3RhdGljIGJvb2wgZXhl Y3V0ZU1vdmVQYWdlRG93bihGcmFtZSogZgogICAgIGludCBkaXN0YW5jZSA9IHZlcnRpY2FsU2Ny b2xsRGlzdGFuY2UoZnJhbWUpOwogICAgIGlmICghZGlzdGFuY2UpCiAgICAgICAgIHJldHVybiBm YWxzZTsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29u dHJvbGxlcjo6TU9WRSwgZGlzdGFuY2UsIHRydWUpOworICAgIHJldHVybiBmcmFtZS0+c2VsZWN0 aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpNT1ZFLCBkaXN0YW5jZSwgdHJ1ZSwg U2VsZWN0aW9uQ29udHJvbGxlcjo6QWxpZ25DdXJzb3JPblNjcm9sbEFsd2F5cyk7CiB9CiAKIHN0 YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZURvd25BbmRNb2RpZnlTZWxlY3Rpb24oRnJhbWUqIGZy YW1lLCBFdmVudCosIEVkaXRvckNvbW1hbmRTb3VyY2UsIGNvbnN0IFN0cmluZyYpCkBAIC02NTQs NyArNjU1LDcgQEAgc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlmeQogICAg IGludCBkaXN0YW5jZSA9IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoZnJhbWUpOwogICAgIGlmICgh ZGlzdGFuY2UpCiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVj dGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCBkaXN0YW5jZSwgdHJ1 ZSk7CisgICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRy b2xsZXI6OkVYVEVORCwgZGlzdGFuY2UsIHRydWUsIFNlbGVjdGlvbkNvbnRyb2xsZXI6OkFsaWdu Q3Vyc29yT25TY3JvbGxBbHdheXMpOwogfQogCiBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VV cChGcmFtZSogZnJhbWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3QgU3RyaW5n JikKQEAgLTY2Miw3ICs2NjMsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VVcChGcmFt ZSogZnJhCiAgICAgaW50IGRpc3RhbmNlID0gdmVydGljYWxTY3JvbGxEaXN0YW5jZShmcmFtZSk7 CiAgICAgaWYgKCFkaXN0YW5jZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIHJldHVybiBm cmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpNT1ZFLCAtZGlz dGFuY2UsIHRydWUpOworICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxl Y3Rpb25Db250cm9sbGVyOjpNT1ZFLCAtZGlzdGFuY2UsIHRydWUsIFNlbGVjdGlvbkNvbnRyb2xs ZXI6OkFsaWduQ3Vyc29yT25TY3JvbGxBbHdheXMpOwogfQogCiBzdGF0aWMgYm9vbCBleGVjdXRl TW92ZVBhZ2VVcEFuZE1vZGlmeVNlbGVjdGlvbihGcmFtZSogZnJhbWUsIEV2ZW50KiwgRWRpdG9y Q29tbWFuZFNvdXJjZSwgY29uc3QgU3RyaW5nJikKQEAgLTY3MCw3ICs2NzEsNyBAQCBzdGF0aWMg Ym9vbCBleGVjdXRlTW92ZVBhZ2VVcEFuZE1vZGlmeVNlCiAgICAgaW50IGRpc3RhbmNlID0gdmVy dGljYWxTY3JvbGxEaXN0YW5jZShmcmFtZSk7CiAgICAgaWYgKCFkaXN0YW5jZSkKICAgICAgICAg cmV0dXJuIGZhbHNlOwotICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxl Y3Rpb25Db250cm9sbGVyOjpFWFRFTkQsIC1kaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0dXJuIGZy YW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6OkVYVEVORCwgLWRp c3RhbmNlLCB0cnVlLCBTZWxlY3Rpb25Db250cm9sbGVyOjpBbGlnbkN1cnNvck9uU2Nyb2xsQWx3 YXlzKTsKIH0KIAogc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVSaWdodChGcmFtZSogZnJhbWUsIEV2 ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3QgU3RyaW5nJikKSW5kZXg6IFdlYkNvcmUv ZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2Vk aXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAJKHJldmlzaW9uIDU5OTQyKQorKysgV2ViQ29y ZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC03OSw5 ICs3OSw5IEBAIFNlbGVjdGlvbkNvbnRyb2xsZXI6OlNlbGVjdGlvbkNvbnRyb2xsZXIKICAgICBz ZXRJc0RpcmVjdGlvbmFsKGZhbHNlKTsKIH0KIAotdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjpt b3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZwb3MsIGJvb2wgdXNlclRyaWdnZXJlZCkKK3Zv aWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlvbiAmcG9z LCBib29sIHVzZXJUcmlnZ2VyZWQsIEN1cnNvckFsaWduT25TY3JvbGwgYWxpZ24pCiB7Ci0gICAg c2V0U2VsZWN0aW9uKFZpc2libGVTZWxlY3Rpb24ocG9zLmRlZXBFcXVpdmFsZW50KCksIHBvcy5k ZWVwRXF1aXZhbGVudCgpLCBwb3MuYWZmaW5pdHkoKSksIHRydWUsIHRydWUsIHVzZXJUcmlnZ2Vy ZWQpOworICAgIHNldFNlbGVjdGlvbihWaXNpYmxlU2VsZWN0aW9uKHBvcy5kZWVwRXF1aXZhbGVu dCgpLCBwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmFmZmluaXR5KCkpLCB0cnVlLCB0cnVlLCB1 c2VyVHJpZ2dlcmVkLCBhbGlnbik7CiB9CiAKIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92 ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlvbiAmYmFzZSwgY29uc3QgVmlzaWJsZVBvc2l0aW9uICZl eHRlbnQsIGJvb2wgdXNlclRyaWdnZXJlZCkKQEAgLTEwNSw3ICsxMDUsNyBAQCB2b2lkIFNlbGVj dGlvbkNvbnRyb2xsZXI6Om1vdmVUbyhjb25zdCBQCiAgICAgc2V0U2VsZWN0aW9uKFZpc2libGVT ZWxlY3Rpb24oYmFzZSwgZXh0ZW50LCBhZmZpbml0eSksIHRydWUsIHRydWUsIHVzZXJUcmlnZ2Vy ZWQpOwogfQogCi12b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihjb25zdCBW aXNpYmxlU2VsZWN0aW9uJiBzLCBib29sIGNsb3NlVHlwaW5nLCBib29sIGNsZWFyVHlwaW5nU3R5 bGUsIGJvb2wgdXNlclRyaWdnZXJlZCwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5KQordm9p ZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlv biYgcywgYm9vbCBjbG9zZVR5cGluZywgYm9vbCBjbGVhclR5cGluZ1N0eWxlLCBib29sIHVzZXJU cmlnZ2VyZWQsIEN1cnNvckFsaWduT25TY3JvbGwgYWxpZ24sIFRleHRHcmFudWxhcml0eSBncmFu dWxhcml0eSkKIHsKICAgICBtX2dyYW51bGFyaXR5ID0gZ3JhbnVsYXJpdHk7CiAKQEAgLTE2MSw4 ICsxNjEsMjMgQEAgdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb24oYwogICAg IHNlbGVjdEZyYW1lRWxlbWVudEluUGFyZW50SWZGdWxseVNlbGVjdGVkKCk7CiAgICAgbV9mcmFt ZS0+bm90aWZ5UmVuZGVyZXJPZlNlbGVjdGlvbkNoYW5nZSh1c2VyVHJpZ2dlcmVkKTsKICAgICBt X2ZyYW1lLT5yZXNwb25kVG9DaGFuZ2VkU2VsZWN0aW9uKG9sZFNlbGVjdGlvbiwgY2xvc2VUeXBp bmcpOwotICAgIGlmICh1c2VyVHJpZ2dlcmVkKQotICAgICAgICBtX2ZyYW1lLT5yZXZlYWxTZWxl Y3Rpb24oU2Nyb2xsQWxpZ25tZW50OjphbGlnblRvRWRnZUlmTmVlZGVkLCB0cnVlKTsKKyAgICBp ZiAodXNlclRyaWdnZXJlZCkgeworICAgICAgICBTY3JvbGxBbGlnbm1lbnQgYWxpZ25tZW50Owor I2lmIE9TKERBUldJTikKKyAgICAgICAgYm9vbCBtYWNTdHlsZVNjcm9sbCA9IHRydWU7CisjZWxz ZQorICAgICAgICBib29sIG1hY1N0eWxlU2Nyb2xsID0gZmFsc2U7CisjZW5kaWYKKyAgICAgICAg aWYgKG1fZnJhbWUtPnNldHRpbmdzKCkpCisgICAgICAgICAgICBtYWNTdHlsZVNjcm9sbCA9IG1f ZnJhbWUtPnNldHRpbmdzKCktPmVkaXRpbmdCZWhhdmlvcigpID09IEVkaXRpbmdNYWNCZWhhdmlv cjsKKworICAgICAgICBpZiAobWFjU3R5bGVTY3JvbGwpCisgICAgICAgICAgICBhbGlnbm1lbnQg PSAoYWxpZ24gPT0gQWxpZ25DdXJzb3JPblNjcm9sbEFsd2F5cykgPyBTY3JvbGxBbGlnbm1lbnQ6 OmFsaWduQ2VudGVyQWx3YXlzIDogU2Nyb2xsQWxpZ25tZW50OjphbGlnbkNlbnRlcklmTmVlZGVk OworICAgICAgICBlbHNlCisgICAgICAgICAgICBhbGlnbm1lbnQgPSAoYWxpZ24gPT0gQWxpZ25D dXJzb3JPblNjcm9sbEFsd2F5cykgPyBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9wQWx3YXlzIDog U2Nyb2xsQWxpZ25tZW50OjphbGlnblRvRWRnZUlmTmVlZGVkOworCisgICAgICAgIG1fZnJhbWUt PnJldmVhbFNlbGVjdGlvbihhbGlnbm1lbnQsIHRydWUpOworICAgIH0KIAogICAgIG5vdGlmeUFj Y2Vzc2liaWxpdHlGb3JTZWxlY3Rpb25DaGFuZ2UoKTsKIH0KQEAgLTcxNCw3ICs3MjksNyBAQCBz dGF0aWMgYm9vbCBhYnNvbHV0ZUNhcmV0WShjb25zdCBWaXNpYmxlCiAgICAgcmV0dXJuIHRydWU7 CiB9CiAKLWJvb2wgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVBbHRlcmF0aW9uIGFsdGVy LCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dlcmVkKQorYm9vbCBTZWxlY3Rp b25Db250cm9sbGVyOjptb2RpZnkoRUFsdGVyYXRpb24gYWx0ZXIsIGludCB2ZXJ0aWNhbERpc3Rh bmNlLCBib29sIHVzZXJUcmlnZ2VyZWQsIEN1cnNvckFsaWduT25TY3JvbGwgYWxpZ24pCiB7CiAg ICAgaWYgKHZlcnRpY2FsRGlzdGFuY2UgPT0gMCkKICAgICAgICAgcmV0dXJuIGZhbHNlOwpAQCAt NzgyLDcgKzc5Nyw3IEBAIGJvb2wgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVBbHRlcmEK IAogICAgIHN3aXRjaCAoYWx0ZXIpIHsKICAgICAgICAgY2FzZSBNT1ZFOgotICAgICAgICAgICAg bW92ZVRvKHJlc3VsdCwgdXNlclRyaWdnZXJlZCk7CisgICAgICAgICAgICBtb3ZlVG8ocmVzdWx0 LCB1c2VyVHJpZ2dlcmVkLCBhbGlnbik7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgY2Fz ZSBFWFRFTkQ6CiAgICAgICAgICAgICBzZXRFeHRlbnQocmVzdWx0LCB1c2VyVHJpZ2dlcmVkKTsK SW5kZXg6IFdlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmgKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuaAkocmV2aXNpb24gNTk5NDIp CisrKyBXZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oCSh3b3JraW5nIGNvcHkp CkBAIC00NSw2ICs0NSw4IEBAIGNsYXNzIFNlbGVjdGlvbkNvbnRyb2xsZXIgOiBwdWJsaWMgTm9u Y28KIHB1YmxpYzoKICAgICBlbnVtIEVBbHRlcmF0aW9uIHsgTU9WRSwgRVhURU5EIH07CiAgICAg ZW51bSBFRGlyZWN0aW9uIHsgRk9SV0FSRCwgQkFDS1dBUkQsIFJJR0hULCBMRUZUIH07CisgICAg ZW51bSBDdXJzb3JBbGlnbk9uU2Nyb2xsIHsgQWxpZ25DdXJzb3JPblNjcm9sbElmTmVlZGVkLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFsaWduQ3Vyc29yT25TY3JvbGxBbHdheXMg fTsKIAogICAgIFNlbGVjdGlvbkNvbnRyb2xsZXIoRnJhbWUqID0gMCwgYm9vbCBpc0RyYWdDYXJl dENvbnRyb2xsZXIgPSBmYWxzZSk7CiAKQEAgLTU0LDE0ICs1NiwxNCBAQCBwdWJsaWM6CiAgICAg Tm9kZSogc2hhZG93VHJlZVJvb3ROb2RlKCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24uc2hh ZG93VHJlZVJvb3ROb2RlKCk7IH0KICAgICAgCiAgICAgdm9pZCBtb3ZlVG8oY29uc3QgUmFuZ2Uq LCBFQWZmaW5pdHksIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKLSAgICB2b2lkIG1vdmVU byhjb25zdCBWaXNpYmxlUG9zaXRpb24mLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7Cisg ICAgdm9pZCBtb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgYm9vbCB1c2VyVHJpZ2dlcmVk ID0gZmFsc2UsIEN1cnNvckFsaWduT25TY3JvbGwgPSBBbGlnbkN1cnNvck9uU2Nyb2xsSWZOZWVk ZWQpOwogICAgIHZvaWQgbW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlvbiYsIGNvbnN0IFZpc2li bGVQb3NpdGlvbiYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKICAgICB2b2lkIG1vdmVU byhjb25zdCBQb3NpdGlvbiYsIEVBZmZpbml0eSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2Up OwogICAgIHZvaWQgbW92ZVRvKGNvbnN0IFBvc2l0aW9uJiwgY29uc3QgUG9zaXRpb24mLCBFQWZm aW5pdHksIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKIAogICAgIGNvbnN0IFZpc2libGVT ZWxlY3Rpb24mIHNlbGVjdGlvbigpIGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uOyB9Ci0gICAg dm9pZCBzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgY2xvc2VUeXBp bmcgPSB0cnVlLCBib29sIGNsZWFyVHlwaW5nU3R5bGUgPSB0cnVlLCBib29sIHVzZXJUcmlnZ2Vy ZWQgPSBmYWxzZSwgVGV4dEdyYW51bGFyaXR5ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHkpOwotICAg IHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHNlbGVjdGlvbiwgVGV4 dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5KSB7IHNldFNlbGVjdGlvbihzZWxlY3Rpb24sIHRydWUs IHRydWUsIGZhbHNlLCBncmFudWxhcml0eSk7IH0KKyAgICB2b2lkIHNldFNlbGVjdGlvbihjb25z dCBWaXNpYmxlU2VsZWN0aW9uJiwgYm9vbCBjbG9zZVR5cGluZyA9IHRydWUsIGJvb2wgY2xlYXJU eXBpbmdTdHlsZSA9IHRydWUsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBDdXJzb3JBbGln bk9uU2Nyb2xsID0gQWxpZ25DdXJzb3JPblNjcm9sbElmTmVlZGVkLCBUZXh0R3JhbnVsYXJpdHkg PSBDaGFyYWN0ZXJHcmFudWxhcml0eSk7CisgICAgdm9pZCBzZXRTZWxlY3Rpb24oY29uc3QgVmlz aWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkpIHsg c2V0U2VsZWN0aW9uKHNlbGVjdGlvbiwgdHJ1ZSwgdHJ1ZSwgZmFsc2UsIEFsaWduQ3Vyc29yT25T Y3JvbGxJZk5lZWRlZCwgZ3JhbnVsYXJpdHkpOyB9CiAgICAgYm9vbCBzZXRTZWxlY3RlZFJhbmdl KFJhbmdlKiwgRUFmZmluaXR5LCBib29sIGNsb3NlVHlwaW5nKTsKICAgICB2b2lkIHNlbGVjdEFs bCgpOwogICAgIHZvaWQgY2xlYXIoKTsKQEAgLTc2LDcgKzc4LDcgQEAgcHVibGljOgogICAgIEVB ZmZpbml0eSBhZmZpbml0eSgpIGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uLmFmZmluaXR5KCk7 IH0KIAogICAgIGJvb2wgbW9kaWZ5KEVBbHRlcmF0aW9uLCBFRGlyZWN0aW9uLCBUZXh0R3JhbnVs YXJpdHksIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKLSAgICBib29sIG1vZGlmeShFQWx0 ZXJhdGlvbiwgaW50IHZlcnRpY2FsRGlzdGFuY2UsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNl KTsKKyAgICBib29sIG1vZGlmeShFQWx0ZXJhdGlvbiwgaW50IHZlcnRpY2FsRGlzdGFuY2UsIGJv b2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBDdXJzb3JBbGlnbk9uU2Nyb2xsID0gQWxpZ25DdXJz b3JPblNjcm9sbElmTmVlZGVkKTsKICAgICBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkoKSBj b25zdCB7IHJldHVybiBtX2dyYW51bGFyaXR5OyB9CiAKICAgICB2b2lkIHNldFN0YXJ0KGNvbnN0 IFZpc2libGVQb3NpdGlvbiAmLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CkluZGV4OiBM YXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9n CShyZXZpc2lvbiA1OTk0NCkKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5 KQpAQCAtMSwzICsxLDIwIEBACisyMDEwLTA1LTIxICBaZWxpZHJhZyBIb3JudW5nICA8emVsaWRy YWdAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEZpeGVkIGZyYW1lIHBhZ2UgdXAvZG93biBzY3JvbGxpbmcgY2FsY3VsYXRpb24u IE1hZGUgc3VyZSB0aGF0IHRoZQorICAgICAgICBjdXJzb3IgbW92ZXMgd2l0aCBwYWdlIHVwL2Rv d24gZXZlbnQuIFBsZWFzZSBub3RlIHRoYXQgbm93IGZvciBtYWMKKyAgICAgICAgZWRpdGluZyBi ZWhhdmlvciB3ZSB3aWxsIHNjcm9sbCB0aGUgY29udGVudCB0byBjZW50ZXIgdGhlIGN1cnNvciBv bgorICAgICAgICBwYWdlIHVwL2Rvd24gd2hpbGUgb3RoZXIgcGxhdGZvcm1zIHdpbGwgYWxpZ24g dGhlIGN1cnNvciB3aXRoIHRoZSB0b3Agb2YKKyAgICAgICAgZGlzcGxheWVkIGZyYW1lLgorICAg ICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzgyMTMKKyAgICAg ICAgCisgICAgICAgICogZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLWV4cGVjdGVk LnR4dDogRml4ZWQgcGFnZSBzY3JvbGwgY2FsY3VsYXRpb24uIE5vdyBzY3JvbGwgaGVpZ2h0IGlz IGNhbGN1bGF0ZWQgb25seSBmcm9tIHRoZSB2aXNpYmxlIHBvcnRpb24gbm90IHRoZSBlbnRpcmUg ZnJhbWUgaGVpZ2h0LgorICAgICAgICAqIGVkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93 bi5odG1sOiBEaXR0by4KKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1w YWdlLXVwLWRvd24tZXhwZWN0ZWQudHh0OiBTY3JvbGxpbmcgdGVzdCBvZiBjb250ZW50ZWRpdGFi bGUgaWZyYW1lIGFuZCBkaXYuCisgICAgICAgICogZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3Bv cnQtcGFnZS11cC1kb3duLmh0bWw6IERpdHRvLgorICAgICAgICAqIGVkaXRpbmcvcmVzb3VyY2Vz L2NvbnRlbnRlZGl0YWJsZS1pZnJhbWUtZml4ZWQtc2l6ZS1zcmMuaHRtbDogUmVzb3VyY2UgZm9y IHRoZSBzY3JvbGxpbmcgdGVzdCBhYm92ZS4KKwogMjAxMC0wNS0yMSAgT2xpdmVyIEh1bnQgIDxv bGl2ZXJAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEdlb2ZmcmV5IEdhcmVuLgpJ bmRleDogTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLWV4cGVj dGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L29wdGlvbi1w YWdlLXVwLWRvd24tZXhwZWN0ZWQudHh0CShyZXZpc2lvbiA1OTk0MikKKysrIExheW91dFRlc3Rz L2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi1leHBlY3RlZC50eHQJKHdvcmtpbmcg Y29weSkKQEAgLTEsMyArMSwyNCBAQAotT24gTWFjLCBvcHRpb24rcGFnZWRvd24gc2hvdWxkIG1v dmUgdGhlIG1vdXNlIGN1cnNvciBhbmQgc2Nyb2xsIGluIHRleHQgYXJlYXMuIE9uIG90aGVyIHBs YXRmb3JtcywgcGFnZWRvd24gc2hvdWxkIG1vdmUgdGhlIG1vdXNlIGN1cnNvciBhbmQgc2Nyb2xs IGluIHRleHQgYXJlYXMuIFRoaXMgdGVzdCByZXF1aXJlcyBEUlQgdG8gcGFzcy4KK1BhZ2UgdXAv ZG93biAob3B0aW9uK3BhZ2UgdXAvZG93biBvbiBNYWMpIHNob3VsZCBtb3ZlIHRoZSBtb3ZlIGN1 cnNvciBhbmQgc2Nyb2xsIHRoZSBjb250ZW50IGluIGNvbnRlbnRlZGl0YWJsZSBlbGVtZW50cy4g VGhpcyBzYW1wbGUgY292ZXJzIGN1cnNvciBwb3NpdGlvbiBtb3ZlIHRlc3Qgb2YgYSkgaWZyYW1l IGVsZW1lbnQgY29udGFpbmluZyBjb250ZW50ZWRpdGFibGUgYm9keSwgYW5kIGIpIGNvbnRlbnQg ZWRpdGFibGUgZGl2IGVsZW1lbnQuCiAKLVBBU1MKK2xpbmUgMAorCitsaW5lIDEKKworbGluZSAy CisKK2xpbmUgMworCitsaW5lIDQKKworbGluZSA1CisKK2xpbmUgNgorCitsaW5lIDcKKworbGlu ZSA4CisKK2xpbmUgOQorCitpZnJhbWUgUEFTUworZGl2IFBBU1MKSW5kZXg6IExheW91dFRlc3Rz L2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExh eW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sCShyZXZpc2lv biA1OTk0MikKKysrIExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93 bi5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC0xLDE3ICsxLDQzIEBACis8aGVhZD4KKzxzdHlsZSB0 eXBlPSJ0ZXh0L2NzcyI+CisgIC5haGVtIHsgZm9udDogMjBweCBBaGVtOyB9Cis8L3N0eWxlPgog PHNjcmlwdD4KIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCiAgICAgbGF5b3V0VGVz dENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOwogCi1mdW5jdGlvbiBydW5UZXN0KCkKLXsKK2Z1bmN0 aW9uIHJ1blRlc3QoKSB7CisgIHJ1bkZyYW1lQ3Vyc29yTW92ZVRlc3QoKTsKKyAgcnVuRGl2Q3Vy c29yTW92ZVRlc3QoKTsKK30KKworZnVuY3Rpb24gZ2VuZXJhdGVDb250ZW50KCkgeworICAgIHZh ciBjb250ZW50ID0gIiI7CisgICAgZm9yICh2YXIgaSA9IDA7IGkgPCAxMDsgKytpKQorICAgICAg ICBjb250ZW50ICs9ICI8cD5saW5lICIgKyBpICsgIjwvcD5cbiI7CisgICAgcmV0dXJuIGNvbnRl bnQ7Cit9CisKK2Z1bmN0aW9uIHJ1bkZyYW1lQ3Vyc29yTW92ZVRlc3QoKSB7CiAgICAgdmFyIGZy YW1lID0gZnJhbWVzWzBdOwogICAgIHZhciBkb2MgPSBmcmFtZS5kb2N1bWVudDsKICAgICB2YXIg Ym9keSA9IGRvYy5ib2R5OwotICAgIGZvciAodmFyIGkgPSAwOyBpIDwgMTA7ICsraSkKLSAgICAg ICAgYm9keS5pbm5lckhUTUwgKz0gIjxwPmxpbmUgIiArIGkgKyAiPC9wPlxuIjsKKyAgICBib2R5 LmlubmVySFRNTCA9IGdlbmVyYXRlQ29udGVudCgpOwogICAgIGZyYW1lLmZvY3VzKCk7CiAgICAg ZnJhbWUuZ2V0U2VsZWN0aW9uKCkuc2V0UG9zaXRpb24oYm9keS5maXJzdENoaWxkLCAwKTsKKyAg ICBydW5DdXJzb3JNb3ZlVGVzdCgiaWZyYW1lIiwgZnJhbWUsIGZyYW1lKTsKK30KKworZnVuY3Rp b24gcnVuRGl2Q3Vyc29yTW92ZVRlc3QoKSB7CisgICAgdmFyIGVkaXRhYmxlID0gZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ2VkaXRhYmxlJyk7CisgICAgZWRpdGFibGUuaW5uZXJIVE1MID0gZ2Vu ZXJhdGVDb250ZW50KCk7CisgICAgZWRpdGFibGUuZm9jdXMoKTsKKyAgICB3aW5kb3cuZ2V0U2Vs ZWN0aW9uKCkuc2V0UG9zaXRpb24oZWRpdGFibGUsIDApOworICAgIHJ1bkN1cnNvck1vdmVUZXN0 KCJkaXYiLCBlZGl0YWJsZSwgd2luZG93KTsKK30KIAorZnVuY3Rpb24gcnVuQ3Vyc29yTW92ZVRl c3QodGVzdE5hbWUsIGZyYW1lLCBzZWxlY3Rpb25Tb3VyY2UpCit7CiAgICAgdmFyIG9uTWFjUGxh dGZvcm0gPSBuYXZpZ2F0b3IudXNlckFnZW50LnNlYXJjaCgvXGJNYWMgT1MgWFxiLykgIT0gLTE7 CiAgICAgdmFyIG1vZGlmaWVycyA9IG9uTWFjUGxhdGZvcm0gPyBbImFsdEtleSJdIDogW107CiAK QEAgLTE5LDI2ICs0NSw0NiBAQCBmdW5jdGlvbiBydW5UZXN0KCkKICAgICAgICAgcmV0dXJuOwog CiAgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBtb2RpZmllcnMpOwotICAgIHZh ciBsaW5lID0gZnJhbWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOwotICAgIGlm IChsaW5lICE9ICJsaW5lIDgiKQotICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBs aW5lIDgsIG5vdCAiICsgbGluZTsKKyAgICB2YXIgbGluZSA9IHNlbGVjdGlvblNvdXJjZS5nZXRT ZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUgMyIp CisgICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMywgbm90ICIgKyBsaW5l OwogCiAgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBtb2RpZmllcnMpOwotICAg IHZhciBsaW5lID0gZnJhbWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOwotICAg IGlmIChsaW5lICE9ICJsaW5lIDkiKQotICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBh dCBsaW5lIDksIG5vdCAiICsgbGluZTsKKyAgICB2YXIgbGluZSA9IHNlbGVjdGlvblNvdXJjZS5n ZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUg NiIpCisgICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgNiwgbm90ICIgKyBs aW5lOwogCiAgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZVVwIiwgbW9kaWZpZXJzKTsKLSAg ICB2YXIgbGluZSA9IGZyYW1lLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKLSAg ICBpZiAobGluZSAhPSAibGluZSAxIikKLSAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUg YXQgbGluZSAxLCBub3QgIiArIGxpbmU7CisgICAgdmFyIGxpbmUgPSBzZWxlY3Rpb25Tb3VyY2Uu Z2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOworICAgIGlmIChsaW5lICE9ICJsaW5l IDMiKQorICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsg bGluZTsKKworICAgIC8vIFRlc3QgdGhhdCBvbiBNYWMgcGFnZURvd24vcGFnZVVwIGRvZXMgbm90 IG1vdmUgdGhlIGN1cnNvciBhdCBhbGwuCisgICAgaWYgKG9uTWFjUGxhdGZvcm0pIHsKKyAgICAg IGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3duIiwgW10pOworICAgICAgdmFyIGxpbmUgPSBz ZWxlY3Rpb25Tb3VyY2UuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOworICAgICAg aWYgKGxpbmUgIT0gImxpbmUgMyIpIHsKKyAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgicmVzdWx0cyIpLmlubmVyVGV4dCA9ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMywgbm90 ICIgKyBsaW5lOworICAgICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMywg bm90ICIgKyBsaW5lOworICAgICAgfQorCisgICAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdl VXAiLCBbXSk7CisgICAgICB2YXIgbGluZSA9IHNlbGVjdGlvblNvdXJjZS5nZXRTZWxlY3Rpb24o KS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgICBpZiAobGluZSAhPSAibGluZSAzIikgeworICAg ICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHRzIikuaW5uZXJUZXh0ID0gImN1 cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7CisgICAgICAgICAgdGhyb3cg ImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7CisgICAgICB9CisgICAg fQogCi0gICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lclRleHQgPSAi UEFTUyI7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lckhUTUwg Kz0gdGVzdE5hbWUgKyAiIFBBU1M8YnIvPiI7CiB9CiA8L3NjcmlwdD4KLQotPGRpdj5PbiBNYWMs IG9wdGlvbitwYWdlZG93biBzaG91bGQgbW92ZSB0aGUgbW91c2UgY3Vyc29yIGFuZCBzY3JvbGwg aW4gdGV4dCBhcmVhcy4gIE9uCi1vdGhlciBwbGF0Zm9ybXMsIHBhZ2Vkb3duIHNob3VsZCBtb3Zl IHRoZSBtb3VzZSBjdXJzb3IgYW5kIHNjcm9sbCBpbiB0ZXh0IGFyZWFzLiAgVGhpcwotdGVzdCBy ZXF1aXJlcyBEUlQgdG8gcGFzcy48L2Rpdj4KLTxpZnJhbWUgc3JjPSIuLi9yZXNvdXJjZXMvY29u dGVudGVkaXRhYmxlLWlmcmFtZS1zcmMuaHRtbCIgb25sb2FkPSJydW5UZXN0KCkiPjwvaWZyYW1l PgotPGRpdiBpZD0icmVzdWx0cyI+RkFJTDwvZGl2PgorPC9oZWFkPgorPGJvZHk+Cis8ZGl2PlBh Z2UgdXAvZG93biAob3B0aW9uK3BhZ2UgdXAvZG93biBvbiBNYWMpIHNob3VsZCBtb3ZlIHRoZSBt b3ZlIGN1cnNvciBhbmQgc2Nyb2xsIHRoZSBjb250ZW50CitpbiBjb250ZW50ZWRpdGFibGUgZWxl bWVudHMuIFRoaXMgc2FtcGxlIGNvdmVycyBjdXJzb3IgcG9zaXRpb24gbW92ZSB0ZXN0IG9mIGEp IGlmcmFtZSBlbGVtZW50IGNvbnRhaW5pbmcKK2NvbnRlbnRlZGl0YWJsZSBib2R5LCBhbmQgYikg Y29udGVudCBlZGl0YWJsZSBkaXYgZWxlbWVudC48L2Rpdj4KKzxpZnJhbWUgc3JjPSIuLi9yZXNv dXJjZXMvY29udGVudGVkaXRhYmxlLWlmcmFtZS1maXhlZC1zaXplLXNyYy5odG1sIiBvbmxvYWQ9 InJ1blRlc3QoKSI+PC9pZnJhbWU+Cis8ZGl2IGlkPSJlZGl0YWJsZSIgY29udGVudGVkaXRhYmxl PSJ0cnVlIiBjbGFzcz0iYWhlbSIgc3R5bGU9ImhlaWdodDoxNTBweDsgb3ZlcmZsb3c6YXV0bzsi PjwvZGl2PgorPGRpdiBpZD0icmVzdWx0cyI+PC9kaXY+Cis8L2JvZHk+ClwgTm8gbmV3bGluZSBh dCBlbmQgb2YgZmlsZQpJbmRleDogTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3JvbGwtdmll d3BvcnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9lZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24tZXhwZWN0ZWQudHh0 CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3Bv cnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyNCBA QAorUGFnZSB1cC9kb3duIChvcHRpb24rcGFnZSB1cC9kb3duIG9uIE1hYykgc2hvdWxkIG1vdmUg dGhlIG1vdmUgY3Vyc29yIGFuZCBzY3JvbGwgdGhlIGNvbnRlbnQgaW4gY29udGVudGVkaXRhYmxl IGVsZW1lbnRzLiBUaGlzIHNhbXBsZSBjb3ZlcnMgc2Nyb2xsIHBvc2l0aW9uIHRlc3Qgb2YgYSkg aWZyYW1lIGVsZW1lbnQgY29udGFpbmluZyBjb250ZW50ZWRpdGFibGUgYm9keSBhbmQgYikgY29u dGVudCBlZGl0YWJsZSBkaXYgZWxlbWVudC4gRXZlbiB0aG91Z2ggdGhlIGN1cnNvciB3aWxsIG1v dmUgZXhhY3RseSB0byB0aGUgc2FtZSBsb2NhdGlvbiBvbiBhbGwgcGxhdGZvcm1zIChjb3ZlcmVk IGJ5IHRlc3Qgb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sKSwgcGxlYXNlIG5vdGUgdGhhdCBNYWMg d2lsbCBzY3JvbGwgdGhlIHZpc2libGUgYXJlYSBieSBwbGFjaW5nIHRoZSBjdXJzb3IgcG9zaXRp b24gaW4gdGhlIG1pZGRsZS4gQWxsIG90aGVyIHBsYXRmb3JtcyB3aWxsIHNjcm9sbCBieSBrZWVw aW5nIHRoZSBjdXJzb3IgYWxpZ25lZCB3aXRoIHRoZSB0b3AgZWRnZSBvZiB0aGUgdmlzaWJsZSBh cmVhLgorCitsaW5lIDAKKworbGluZSAxCisKK2xpbmUgMgorCitsaW5lIDMKKworbGluZSA0CisK K2xpbmUgNQorCitsaW5lIDYKKworbGluZSA3CisKK2xpbmUgOAorCitsaW5lIDkKKworaWZyYW1l IFBBU1MKK2RpdiBQQVNTCkluZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3Njcm9sbC12 aWV3cG9ydC1wYWdlLXVwLWRvd24uaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0 aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24uaHRtbAkocmV2aXNpb24gMCkK KysrIExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAtZG93 bi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDg5IEBACis8aGVhZD4KKzxzdHlsZSB0eXBl PSJ0ZXh0L2NzcyI+CisgIC5haGVtIHsgZm9udDogMjBweCBBaGVtOyB9Cis8L3N0eWxlPgorPHNj cmlwdD4KKworaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKK3ZhciBvbk1hY1BsYXRmb3JtID0gbmF2aWdhdG9y LnVzZXJBZ2VudC5zZWFyY2goL1xiTWFjIE9TIFhcYi8pICE9IC0xOworCitmdW5jdGlvbiBydW5U ZXN0KCkgeworICAgIHJ1bkZyYW1lU2Nyb2xsVGVzdCgpOworICAgIHJ1bkRpdlNjcm9sbFRlc3Qo KTsKK30KKworZnVuY3Rpb24gZ2VuZXJhdGVDb250ZW50KCkgeworICAgIHZhciBjb250ZW50ID0g IiI7CisgICAgZm9yICh2YXIgaSA9IDA7IGkgPCAxMDsgKytpKQorICAgICAgICBjb250ZW50ICs9 ICI8cD5saW5lICIgKyBpICsgIjwvcD5cbiI7CisgICAgcmV0dXJuIGNvbnRlbnQ7Cit9CisKK2Z1 bmN0aW9uIHJ1bkZyYW1lU2Nyb2xsVGVzdCgpIHsKKyAgICB2YXIgZnJhbWUgPSBmcmFtZXNbMF07 CisgICAgdmFyIGRvYyA9IGZyYW1lLmRvY3VtZW50OworICAgIHZhciBib2R5ID0gZG9jLmJvZHk7 CisgICAgYm9keS5pbm5lckhUTUwgPSBnZW5lcmF0ZUNvbnRlbnQoKTsKKyAgICBmcmFtZS5mb2N1 cygpOworICAgIGZyYW1lLmdldFNlbGVjdGlvbigpLnNldFBvc2l0aW9uKGJvZHkuZmlyc3RDaGls ZCwgMCk7CisgICAgaWYgKG9uTWFjUGxhdGZvcm0pCisgICAgICAgIG9mZnNldHMgPSBbIDU1LCAx NzUgXTsKKyAgICBlbHNlIAorICAgICAgICBvZmZzZXRzID0gWyAxMjAsIDI0MCBdOworICAgIHJ1 blNjcm9sbGluZ1Rlc3QoImlmcmFtZSIsIGZyYW1lLCBvZmZzZXRzLCBmdW5jdGlvbigpIHsgcmV0 dXJuIGZyYW1lLnBhZ2VZT2Zmc2V0OyB9KTsKK30KKworZnVuY3Rpb24gcnVuRGl2U2Nyb2xsVGVz dCgpIHsKKyAgICB2YXIgZWRpdGFibGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZWRpdGFi bGUnKTsKKyAgICBlZGl0YWJsZS5pbm5lckhUTUwgPSBnZW5lcmF0ZUNvbnRlbnQoKTsKKyAgICBl ZGl0YWJsZS5mb2N1cygpOworICAgIHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5zZXRQb3NpdGlvbihl ZGl0YWJsZSwgMCk7CisgICAgaWYgKG9uTWFjUGxhdGZvcm0pCisgICAgICAgIG9mZnNldHMgPSBb IDc1LCAxOTUgXTsKKyAgICBlbHNlIAorICAgICAgICBvZmZzZXRzID0gWyAxNDAsIDI2MCBdOwor ICAgIHJ1blNjcm9sbGluZ1Rlc3QoImRpdiIsIGVkaXRhYmxlLCBvZmZzZXRzLCBmdW5jdGlvbigp IHsgcmV0dXJuIGVkaXRhYmxlLnNjcm9sbFRvcDsgfSk7Cit9CisKK2Z1bmN0aW9uIHJ1blNjcm9s bGluZ1Rlc3QodGVzdE5hbWUsIGZyYW1lLCBvZmZzZXRzLCBzY3JvbGxGdW5jdGlvbikgeworICAg IHZhciB0b2xlcmFuY2UgPSAwOworICAgIHZhciBtb2RpZmllcnMgPSBvbk1hY1BsYXRmb3JtID8g WyJhbHRLZXkiXSA6IFtdOworICAgIAorICAgIGlmICghd2luZG93LmV2ZW50U2VuZGVyKQorICAg ICAgICByZXR1cm47CisKKyAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIsIG1vZGlm aWVycyk7CisgICAgaWYgKE1hdGguYWJzKHNjcm9sbEZ1bmN0aW9uKCkgLSBvZmZzZXRzWzBdKSA+ IHRvbGVyYW5jZSkgeworICAgICAgICB0aHJvdyAiRnJhbWUgdmlld3BvcnQgc2hvdWxkIGJlIGFy b3VuZCAiICsgb2Zmc2V0c1swXSArCisgICAgICAgICAgICAicHggLCBub3QgYXQgIiArIHNjcm9s bEZ1bmN0aW9uKCk7CisgICAgfQorCisgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24i LCBtb2RpZmllcnMpOworICAgIGlmIChNYXRoLmFicyhzY3JvbGxGdW5jdGlvbigpIC0gb2Zmc2V0 c1sxXSkgPiB0b2xlcmFuY2UpIHsKKyAgICAgICAgdGhyb3cgIkZyYW1lIHZpZXdwb3J0IHNob3Vs ZCBiZSBhcm91bmQgIiArIG9mZnNldHNbMV0gKworICAgICAgICAgICAgInB4ICwgbm90ICIgKyBz Y3JvbGxGdW5jdGlvbigpOworICAgIH0KKworICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VV cCIsIG1vZGlmaWVycyk7CisgICAgaWYgKE1hdGguYWJzKHNjcm9sbEZ1bmN0aW9uKCkgLSBvZmZz ZXRzWzBdKSA+IHRvbGVyYW5jZSkgeworICAgICAgICB0aHJvdyAiRnJhbWUgdmlld3BvcnQgc2hv dWxkIGJlIGFyb3VuZCAiICsgb2Zmc2V0c1swXSArCisgICAgICAgICAgICAicHggLCBub3QgYXQg IiArIHNjcm9sbEZ1bmN0aW9uKCk7CisgICAgfQorCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInJlc3VsdHMiKS5pbm5lckhUTUwgKz0gdGVzdE5hbWUgKyAiIFBBU1M8YnIvPiI7Cit9Cis8 L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPGRpdj5QYWdlIHVwL2Rvd24gKG9wdGlvbitwYWdl IHVwL2Rvd24gb24gTWFjKSBzaG91bGQgbW92ZSB0aGUgbW92ZSBjdXJzb3IgYW5kIHNjcm9sbCB0 aGUgY29udGVudAoraW4gY29udGVudGVkaXRhYmxlIGVsZW1lbnRzLiBUaGlzIHNhbXBsZSBjb3Zl cnMgc2Nyb2xsIHBvc2l0aW9uIHRlc3Qgb2YgYSkgaWZyYW1lIGVsZW1lbnQgY29udGFpbmluZwor Y29udGVudGVkaXRhYmxlIGJvZHkgYW5kIGIpIGNvbnRlbnQgZWRpdGFibGUgZGl2IGVsZW1lbnQu IEV2ZW4gdGhvdWdoIHRoZSBjdXJzb3Igd2lsbCBtb3ZlIGV4YWN0bHkgdG8KK3RoZSBzYW1lIGxv Y2F0aW9uIG9uIGFsbCBwbGF0Zm9ybXMgKGNvdmVyZWQgYnkgdGVzdCBvcHRpb24tcGFnZS11cC1k b3duLmh0bWwpLCBwbGVhc2Ugbm90ZSB0aGF0IE1hYyB3aWxsCitzY3JvbGwgdGhlIHZpc2libGUg YXJlYSBieSBwbGFjaW5nIHRoZSBjdXJzb3IgcG9zaXRpb24gaW4gdGhlIG1pZGRsZS4gQWxsIG90 aGVyIHBsYXRmb3JtcyB3aWxsIHNjcm9sbCBieQora2VlcGluZyB0aGUgY3Vyc29yIGFsaWduZWQg d2l0aCB0aGUgdG9wIGVkZ2Ugb2YgdGhlIHZpc2libGUgYXJlYS4gPC9kaXY+Cis8aWZyYW1lIHNy Yz0iLi4vcmVzb3VyY2VzL2NvbnRlbnRlZGl0YWJsZS1pZnJhbWUtZml4ZWQtc2l6ZS1zcmMuaHRt bCIgb25sb2FkPSJydW5UZXN0KCkiIHN0eWxlPSJoZWlnaHQ6MTUwcHg7IHBhZGRpbmc6IDBweDsi PjwvaWZyYW1lPgorPGRpdiBpZD0iZWRpdGFibGUiIGNvbnRlbnRlZGl0YWJsZT0idHJ1ZSIgY2xh c3M9ImFoZW0iIHN0eWxlPSJoZWlnaHQ6MTUwcHg7IG92ZXJmbG93OmF1dG87IHBhZGRpbmc6IDBw eDsgbWFyZ2luOiAwcHg7Ij48L2Rpdj4KKzxkaXYgaWQ9InJlc3VsdHMiPjwvZGl2PgorPC9ib2R5 PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKSW5kZXg6IExheW91dFRlc3RzL2VkaXRpbmcv cmVzb3VyY2VzL2NvbnRlbnRlZGl0YWJsZS1pZnJhbWUtZml4ZWQtc2l6ZS1zcmMuaHRtbAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUt aWZyYW1lLWZpeGVkLXNpemUtc3JjLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9l ZGl0aW5nL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUtaWZyYW1lLWZpeGVkLXNpemUtc3JjLmh0 bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNiBAQAorPHN0eWxlIHR5cGU9InRleHQvY3NzIj4K KyAgLmFoZW0geyBmb250OiAyMHB4IEFoZW07IH0KKzwvc3R5bGU+Cis8Ym9keSBiZ2NvbG9yPSJs aWdodHllbGxvdyIgY29udGVudGVkaXRhYmxlIGNsYXNzPSJhaGVtIiBzdHlsZT0icGFkZGluZzog MHB4OyBtYXJnaW46IDBweDsiPgorCis8L2JvZHk+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmls ZQo= 56750 2010-05-21 15:08:10 -0700 2010-05-23 22:32:36 -0700 Changes m_frame->settings() check WK_38213.patch text/plain 23258 zelidrag SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1OTk1MSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzIgQEAKKzIwMTAtMDUtMjEgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0Bj aHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgRml4ZWQgZnJhbWUgcGFnZSB1cC9kb3duIHNjcm9sbGluZyBjYWxjdWxhdGlvbi4gTWFk ZSBzdXJlIHRoYXQgdGhlCisgICAgICAgIGN1cnNvciBtb3ZlcyB3aXRoIHBhZ2UgdXAvZG93biBl dmVudC4gUGxlYXNlIG5vdGUgdGhhdCBub3cgZm9yIG1hYworICAgICAgICBlZGl0aW5nIGJlaGF2 aW9yIHdlIHdpbGwgc2Nyb2xsIHRoZSBjb250ZW50IHRvIGNlbnRlciB0aGUgY3Vyc29yIG9uCisg ICAgICAgIHBhZ2UgdXAvZG93biB3aGlsZSBvdGhlciBwbGF0Zm9ybXMgd2lsbCBhbGlnbiB0aGUg Y3Vyc29yIHdpdGggdGhlIHRvcCBvZgorICAgICAgICBkaXNwbGF5ZWQgZnJhbWUuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zODIxMworCisgICAgICAg IFRlc3RzOiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbCAoZml4ZWQpCisg ICAgICAgICAgICAgICBlZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24u aHRtbAorCisgICAgICAgICogV2ViQ29yZS5iYXNlLmV4cDoKKyAgICAgICAgKiBlZGl0aW5nL0Vk aXRvckNvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6dmVydGljYWxTY3JvbGxEaXN0YW5j ZSk6IEZpeGVkIHBhZ2Ugc2Nyb2xsIGNhbGN1bGF0aW9uLiBOb3cgc2Nyb2xsIGhlaWdodCBpcyBj YWxjdWxhdGVkIG9ubHkgZnJvbSB0aGUgdmlzaWJsZSBwb3J0aW9uIG5vdCB0aGUgZW50aXJlIGZy YW1lIGhlaWdodC4KKyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVNb3ZlUGFnZURvd24pOiBOb3cg aXQgY2FuIHRlbGwgU2VsZWN0aW9uQ29udHJvbGxlciB0byBtb3ZlIHRoZSBjdXJzb3Igd2l0aCB0 aGUgcGFnZSBzY3JvbGwgdXAvZG93biBldmVudHMuCisgICAgICAgIChXZWJDb3JlOjpleGVjdXRl TW92ZVBhZ2VEb3duQW5kTW9kaWZ5U2VsZWN0aW9uKTogRGl0dG8uCisgICAgICAgIChXZWJDb3Jl OjpleGVjdXRlTW92ZVBhZ2VVcCk6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZU1v dmVQYWdlVXBBbmRNb2RpZnlTZWxlY3Rpb24pOiBEaXR0by4KKyAgICAgICAgKiBlZGl0aW5nL1Nl bGVjdGlvbkNvbnRyb2xsZXIuY3BwOgorICAgICAgICAqIGVkaXRpbmcvU2VsZWN0aW9uQ29udHJv bGxlci5jcHA6IEV4cG9zZWQgYW4gZW51bSBwYXJhbSB0aGF0IGxldHMgRWRpdG9yQ29tbWFuZC5j cHAgY29udHJvbCBob3cgY3Vyc29yIHBvc2l0aW9uIHdpbGwgYmUgYWxpZ25lZCB3aGVuIHBhZ2Ug bW92ZXMuCisgICAgICAgIChXZWJDb3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rp b24pOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vZGlm eSk6IERpdHRvLgorICAgICAgICAqIGVkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oOiBEaXR0 by4KKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6Oik6IERpdHRvLgorICAg ICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKTogRGl0dG8u CisKIDIwMTAtMDUtMjEgIEJldGggRGFraW4gIDxiZGFraW5AYXBwbGUuY29tPgogCiAgICAgICAg IFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpJbmRleDogV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS5iYXNlLmV4cAkocmV2aXNpb24gNTk5NTEp CisrKyBXZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAJKHdvcmtpbmcgY29weSkKQEAgLTQyMCw3ICs0 MjAsNyBAQCBfX1pON1dlYkNvcmUxOUFuaW1hdGlvbkNvbnRyb2xsZXIyMXBhdXNlCiBfX1pON1dl YkNvcmUxOUNTU1N0eWxlRGVjbGFyYXRpb24xMXNldFByb3BlcnR5RVJLTlNfNlN0cmluZ0VTM19S aQogX19aTjdXZWJDb3JlMTlJbnNwZWN0b3JDb250cm9sbGVyMzRpbnNwZWN0b3JTdGFydHNBdHRh Y2hlZFNldHRpbmdOYW1lRXYKIF9fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjEwc2V0 Rm9jdXNlZEViCi1fX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIxMnNldFNlbGVjdGlv bkVSS05TXzE2VmlzaWJsZVNlbGVjdGlvbkViYmJOU18xNVRleHRHcmFudWxhcml0eUUKK19fWk43 V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjEyc2V0U2VsZWN0aW9uRVJLTlNfMTZWaXNpYmxl U2VsZWN0aW9uRWJiYk5TMF8xOUN1cnNvckFsaWduT25TY3JvbGxFTlNfMTVUZXh0R3JhbnVsYXJp dHlFCiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIxNnNldFNlbGVjdGVkUmFuZ2VF UE5TXzVSYW5nZUVOU185RUFmZmluaXR5RWIKIF9fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJv bGxlcjVjbGVhckV2CiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXI2bW9kaWZ5RU5T MF8xMUVBbHRlcmF0aW9uRU5TMF8xMEVEaXJlY3Rpb25FTlNfMTVUZXh0R3JhbnVsYXJpdHlFYgpJ bmRleDogV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcAkocmV2aXNpb24gNTk5NTEpCisrKyBXZWJD b3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQxLDEzICs0 MSwxMyBAQAogI2luY2x1ZGUgIkV2ZW50SGFuZGxlci5oIgogI2luY2x1ZGUgIkZvcm1hdEJsb2Nr Q29tbWFuZC5oIgogI2luY2x1ZGUgIkZyYW1lLmgiCisjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCiAj aW5jbHVkZSAiSFRNTEZvbnRFbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRNTEhSRWxlbWVudC5oIgog I2luY2x1ZGUgIkhUTUxJbWFnZUVsZW1lbnQuaCIKICNpbmNsdWRlICJJbmRlbnRPdXRkZW50Q29t bWFuZC5oIgogI2luY2x1ZGUgIkluc2VydExpc3RDb21tYW5kLmgiCiAjaW5jbHVkZSAiUGFnZS5o IgotI2luY2x1ZGUgIlJlbmRlckJveC5oIgogI2luY2x1ZGUgIlJlcGxhY2VTZWxlY3Rpb25Db21t YW5kLmgiCiAjaW5jbHVkZSAiU2Nyb2xsYmFyLmgiCiAjaW5jbHVkZSAiU2V0dGluZ3MuaCIKQEAg LTI1OSw3ICsyNTksOCBAQCBzdGF0aWMgaW50IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoRnJhbWUq CiAgICAgICAgIHJldHVybiAwOwogICAgIGlmICghKHN0eWxlLT5vdmVyZmxvd1koKSA9PSBPU0NS T0xMIHx8IHN0eWxlLT5vdmVyZmxvd1koKSA9PSBPQVVUTyB8fCBmb2N1c2VkTm9kZS0+aXNDb250 ZW50RWRpdGFibGUoKSkpCiAgICAgICAgIHJldHVybiAwOwotICAgIGludCBoZWlnaHQgPSB0b1Jl bmRlckJveChyZW5kZXJlciktPmNsaWVudEhlaWdodCgpOworICAgIGludCBoZWlnaHQgPSBzdGQ6 Om1pbjxpbnQ+KHRvUmVuZGVyQm94KHJlbmRlcmVyKS0+Y2xpZW50SGVpZ2h0KCksCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgZnJhbWUtPnZpZXcoKS0+dmlzaWJsZUhlaWdodCgpKTsK ICAgICByZXR1cm4gbWF4KG1heDxpbnQ+KGhlaWdodCAqIFNjcm9sbGJhcjo6bWluRnJhY3Rpb25U b1N0ZXBXaGVuUGFnaW5nKCksIGhlaWdodCAtIFNjcm9sbGJhcjo6bWF4T3ZlcmxhcEJldHdlZW5Q YWdlcygpKSwgMSk7CiB9CiAKQEAgLTY0Niw3ICs2NDcsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRl TW92ZVBhZ2VEb3duKEZyYW1lKiBmCiAgICAgaW50IGRpc3RhbmNlID0gdmVydGljYWxTY3JvbGxE aXN0YW5jZShmcmFtZSk7CiAgICAgaWYgKCFkaXN0YW5jZSkKICAgICAgICAgcmV0dXJuIGZhbHNl OwotICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9s bGVyOjpNT1ZFLCBkaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24o KS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIGRpc3RhbmNlLCB0cnVlLCBTZWxl Y3Rpb25Db250cm9sbGVyOjpBbGlnbkN1cnNvck9uU2Nyb2xsQWx3YXlzKTsKIH0KIAogc3RhdGlj IGJvb2wgZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlmeVNlbGVjdGlvbihGcmFtZSogZnJhbWUs IEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3QgU3RyaW5nJikKQEAgLTY1NCw3ICs2 NTUsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VEb3duQW5kTW9kaWZ5CiAgICAgaW50 IGRpc3RhbmNlID0gdmVydGljYWxTY3JvbGxEaXN0YW5jZShmcmFtZSk7CiAgICAgaWYgKCFkaXN0 YW5jZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9u KCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpFWFRFTkQsIGRpc3RhbmNlLCB0cnVlKTsK KyAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxl cjo6RVhURU5ELCBkaXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6QWxpZ25DdXJz b3JPblNjcm9sbEFsd2F5cyk7CiB9CiAKIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwKEZy YW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpA QCAtNjYyLDcgKzY2Myw3IEBAIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZVVwKEZyYW1lKiBm cmEKICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKGZyYW1lKTsKICAg ICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1l LT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1kaXN0YW5j ZSwgdHJ1ZSk7CisgICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlv bkNvbnRyb2xsZXI6Ok1PVkUsIC1kaXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6 QWxpZ25DdXJzb3JPblNjcm9sbEFsd2F5cyk7CiB9CiAKIHN0YXRpYyBib29sIGV4ZWN1dGVNb3Zl UGFnZVVwQW5kTW9kaWZ5U2VsZWN0aW9uKEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDb21t YW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpAQCAtNjcwLDcgKzY3MSw3IEBAIHN0YXRpYyBib29s IGV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2UKICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNh bFNjcm9sbERpc3RhbmNlKGZyYW1lKTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1 cm4gZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlv bkNvbnRyb2xsZXI6OkVYVEVORCwgLWRpc3RhbmNlLCB0cnVlKTsKKyAgICByZXR1cm4gZnJhbWUt PnNlbGVjdGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCAtZGlzdGFu Y2UsIHRydWUsIFNlbGVjdGlvbkNvbnRyb2xsZXI6OkFsaWduQ3Vyc29yT25TY3JvbGxBbHdheXMp OwogfQogCiBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVJpZ2h0KEZyYW1lKiBmcmFtZSwgRXZlbnQq LCBFZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpJbmRleDogV2ViQ29yZS9lZGl0 aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZWRpdGlu Zy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcAkocmV2aXNpb24gNTk5NTEpCisrKyBXZWJDb3JlL2Vk aXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTc5LDkgKzc5 LDkgQEAgU2VsZWN0aW9uQ29udHJvbGxlcjo6U2VsZWN0aW9uQ29udHJvbGxlcgogICAgIHNldElz RGlyZWN0aW9uYWwoZmFsc2UpOwogfQogCi12b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vdmVU byhjb25zdCBWaXNpYmxlUG9zaXRpb24gJnBvcywgYm9vbCB1c2VyVHJpZ2dlcmVkKQordm9pZCBT ZWxlY3Rpb25Db250cm9sbGVyOjptb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZwb3MsIGJv b2wgdXNlclRyaWdnZXJlZCwgQ3Vyc29yQWxpZ25PblNjcm9sbCBhbGlnbikKIHsKLSAgICBzZXRT ZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlvbihwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmRlZXBF cXVpdmFsZW50KCksIHBvcy5hZmZpbml0eSgpKSwgdHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCk7 CisgICAgc2V0U2VsZWN0aW9uKFZpc2libGVTZWxlY3Rpb24ocG9zLmRlZXBFcXVpdmFsZW50KCks IHBvcy5kZWVwRXF1aXZhbGVudCgpLCBwb3MuYWZmaW5pdHkoKSksIHRydWUsIHRydWUsIHVzZXJU cmlnZ2VyZWQsIGFsaWduKTsKIH0KIAogdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjptb3ZlVG8o Y29uc3QgVmlzaWJsZVBvc2l0aW9uICZiYXNlLCBjb25zdCBWaXNpYmxlUG9zaXRpb24gJmV4dGVu dCwgYm9vbCB1c2VyVHJpZ2dlcmVkKQpAQCAtMTA1LDcgKzEwNSw3IEBAIHZvaWQgU2VsZWN0aW9u Q29udHJvbGxlcjo6bW92ZVRvKGNvbnN0IFAKICAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVj dGlvbihiYXNlLCBleHRlbnQsIGFmZmluaXR5KSwgdHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCk7 CiB9CiAKLXZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKGNvbnN0IFZpc2li bGVTZWxlY3Rpb24mIHMsIGJvb2wgY2xvc2VUeXBpbmcsIGJvb2wgY2xlYXJUeXBpbmdTdHlsZSwg Ym9vbCB1c2VyVHJpZ2dlcmVkLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkpCit2b2lkIFNl bGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBz LCBib29sIGNsb3NlVHlwaW5nLCBib29sIGNsZWFyVHlwaW5nU3R5bGUsIGJvb2wgdXNlclRyaWdn ZXJlZCwgQ3Vyc29yQWxpZ25PblNjcm9sbCBhbGlnbiwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFy aXR5KQogewogICAgIG1fZ3JhbnVsYXJpdHkgPSBncmFudWxhcml0eTsKIApAQCAtMTYxLDggKzE2 MSwxNiBAQCB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihjCiAgICAgc2Vs ZWN0RnJhbWVFbGVtZW50SW5QYXJlbnRJZkZ1bGx5U2VsZWN0ZWQoKTsKICAgICBtX2ZyYW1lLT5u b3RpZnlSZW5kZXJlck9mU2VsZWN0aW9uQ2hhbmdlKHVzZXJUcmlnZ2VyZWQpOwogICAgIG1fZnJh bWUtPnJlc3BvbmRUb0NoYW5nZWRTZWxlY3Rpb24ob2xkU2VsZWN0aW9uLCBjbG9zZVR5cGluZyk7 Ci0gICAgaWYgKHVzZXJUcmlnZ2VyZWQpCi0gICAgICAgIG1fZnJhbWUtPnJldmVhbFNlbGVjdGlv bihTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9FZGdlSWZOZWVkZWQsIHRydWUpOworICAgIGlmICh1 c2VyVHJpZ2dlcmVkKSB7CisgICAgICAgIFNjcm9sbEFsaWdubWVudCBhbGlnbm1lbnQ7CisKKyAg ICAgICAgaWYgKG1fZnJhbWUtPnNldHRpbmdzKCkgJiYgbV9mcmFtZS0+c2V0dGluZ3MoKS0+ZWRp dGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ01hY0JlaGF2aW9yKQorICAgICAgICAgICAgYWxpZ25t ZW50ID0gKGFsaWduID09IEFsaWduQ3Vyc29yT25TY3JvbGxBbHdheXMpID8gU2Nyb2xsQWxpZ25t ZW50OjphbGlnbkNlbnRlckFsd2F5cyA6IFNjcm9sbEFsaWdubWVudDo6YWxpZ25DZW50ZXJJZk5l ZWRlZDsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgYWxpZ25tZW50ID0gKGFsaWduID09IEFs aWduQ3Vyc29yT25TY3JvbGxBbHdheXMpID8gU2Nyb2xsQWxpZ25tZW50OjphbGlnblRvcEFsd2F5 cyA6IFNjcm9sbEFsaWdubWVudDo6YWxpZ25Ub0VkZ2VJZk5lZWRlZDsKKworICAgICAgICBtX2Zy YW1lLT5yZXZlYWxTZWxlY3Rpb24oYWxpZ25tZW50LCB0cnVlKTsKKyAgICB9CiAKICAgICBub3Rp ZnlBY2Nlc3NpYmlsaXR5Rm9yU2VsZWN0aW9uQ2hhbmdlKCk7CiB9CkBAIC03MTQsNyArNzIyLDcg QEAgc3RhdGljIGJvb2wgYWJzb2x1dGVDYXJldFkoY29uc3QgVmlzaWJsZQogICAgIHJldHVybiB0 cnVlOwogfQogCi1ib29sIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vZGlmeShFQWx0ZXJhdGlvbiBh bHRlciwgaW50IHZlcnRpY2FsRGlzdGFuY2UsIGJvb2wgdXNlclRyaWdnZXJlZCkKK2Jvb2wgU2Vs ZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVBbHRlcmF0aW9uIGFsdGVyLCBpbnQgdmVydGljYWxE aXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dlcmVkLCBDdXJzb3JBbGlnbk9uU2Nyb2xsIGFsaWduKQog ewogICAgIGlmICh2ZXJ0aWNhbERpc3RhbmNlID09IDApCiAgICAgICAgIHJldHVybiBmYWxzZTsK QEAgLTc4Miw3ICs3OTAsNyBAQCBib29sIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vZGlmeShFQWx0 ZXJhCiAKICAgICBzd2l0Y2ggKGFsdGVyKSB7CiAgICAgICAgIGNhc2UgTU9WRToKLSAgICAgICAg ICAgIG1vdmVUbyhyZXN1bHQsIHVzZXJUcmlnZ2VyZWQpOworICAgICAgICAgICAgbW92ZVRvKHJl c3VsdCwgdXNlclRyaWdnZXJlZCwgYWxpZ24pOwogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAg IGNhc2UgRVhURU5EOgogICAgICAgICAgICAgc2V0RXh0ZW50KHJlc3VsdCwgdXNlclRyaWdnZXJl ZCk7CkluZGV4OiBXZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmgJKHJldmlzaW9uIDU5 OTUxKQorKysgV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuaAkod29ya2luZyBj b3B5KQpAQCAtNDUsNiArNDUsOCBAQCBjbGFzcyBTZWxlY3Rpb25Db250cm9sbGVyIDogcHVibGlj IE5vbmNvCiBwdWJsaWM6CiAgICAgZW51bSBFQWx0ZXJhdGlvbiB7IE1PVkUsIEVYVEVORCB9Owog ICAgIGVudW0gRURpcmVjdGlvbiB7IEZPUldBUkQsIEJBQ0tXQVJELCBSSUdIVCwgTEVGVCB9Owor ICAgIGVudW0gQ3Vyc29yQWxpZ25PblNjcm9sbCB7IEFsaWduQ3Vyc29yT25TY3JvbGxJZk5lZWRl ZCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBBbGlnbkN1cnNvck9uU2Nyb2xsQWx3 YXlzIH07CiAKICAgICBTZWxlY3Rpb25Db250cm9sbGVyKEZyYW1lKiA9IDAsIGJvb2wgaXNEcmFn Q2FyZXRDb250cm9sbGVyID0gZmFsc2UpOwogCkBAIC01NCwxNCArNTYsMTQgQEAgcHVibGljOgog ICAgIE5vZGUqIHNoYWRvd1RyZWVSb290Tm9kZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9u LnNoYWRvd1RyZWVSb290Tm9kZSgpOyB9CiAgICAgIAogICAgIHZvaWQgbW92ZVRvKGNvbnN0IFJh bmdlKiwgRUFmZmluaXR5LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7Ci0gICAgdm9pZCBt b3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2Up OworICAgIHZvaWQgbW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlvbiYsIGJvb2wgdXNlclRyaWdn ZXJlZCA9IGZhbHNlLCBDdXJzb3JBbGlnbk9uU2Nyb2xsID0gQWxpZ25DdXJzb3JPblNjcm9sbElm TmVlZGVkKTsKICAgICB2b2lkIG1vdmVUbyhjb25zdCBWaXNpYmxlUG9zaXRpb24mLCBjb25zdCBW aXNpYmxlUG9zaXRpb24mLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CiAgICAgdm9pZCBt b3ZlVG8oY29uc3QgUG9zaXRpb24mLCBFQWZmaW5pdHksIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZh bHNlKTsKICAgICB2b2lkIG1vdmVUbyhjb25zdCBQb3NpdGlvbiYsIGNvbnN0IFBvc2l0aW9uJiwg RUFmZmluaXR5LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CiAKICAgICBjb25zdCBWaXNp YmxlU2VsZWN0aW9uJiBzZWxlY3Rpb24oKSBjb25zdCB7IHJldHVybiBtX3NlbGVjdGlvbjsgfQot ICAgIHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mLCBib29sIGNsb3Nl VHlwaW5nID0gdHJ1ZSwgYm9vbCBjbGVhclR5cGluZ1N0eWxlID0gdHJ1ZSwgYm9vbCB1c2VyVHJp Z2dlcmVkID0gZmFsc2UsIFRleHRHcmFudWxhcml0eSA9IENoYXJhY3RlckdyYW51bGFyaXR5KTsK LSAgICB2b2lkIHNldFNlbGVjdGlvbihjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzZWxlY3Rpb24s IFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSkgeyBzZXRTZWxlY3Rpb24oc2VsZWN0aW9uLCB0 cnVlLCB0cnVlLCBmYWxzZSwgZ3JhbnVsYXJpdHkpOyB9CisgICAgdm9pZCBzZXRTZWxlY3Rpb24o Y29uc3QgVmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgY2xvc2VUeXBpbmcgPSB0cnVlLCBib29sIGNs ZWFyVHlwaW5nU3R5bGUgPSB0cnVlLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSwgQ3Vyc29y QWxpZ25PblNjcm9sbCA9IEFsaWduQ3Vyc29yT25TY3JvbGxJZk5lZWRlZCwgVGV4dEdyYW51bGFy aXR5ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHkpOworICAgIHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0 IFZpc2libGVTZWxlY3Rpb24mIHNlbGVjdGlvbiwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5 KSB7IHNldFNlbGVjdGlvbihzZWxlY3Rpb24sIHRydWUsIHRydWUsIGZhbHNlLCBBbGlnbkN1cnNv ck9uU2Nyb2xsSWZOZWVkZWQsIGdyYW51bGFyaXR5KTsgfQogICAgIGJvb2wgc2V0U2VsZWN0ZWRS YW5nZShSYW5nZSosIEVBZmZpbml0eSwgYm9vbCBjbG9zZVR5cGluZyk7CiAgICAgdm9pZCBzZWxl Y3RBbGwoKTsKICAgICB2b2lkIGNsZWFyKCk7CkBAIC03Niw3ICs3OCw3IEBAIHB1YmxpYzoKICAg ICBFQWZmaW5pdHkgYWZmaW5pdHkoKSBjb25zdCB7IHJldHVybiBtX3NlbGVjdGlvbi5hZmZpbml0 eSgpOyB9CiAKICAgICBib29sIG1vZGlmeShFQWx0ZXJhdGlvbiwgRURpcmVjdGlvbiwgVGV4dEdy YW51bGFyaXR5LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7Ci0gICAgYm9vbCBtb2RpZnko RUFsdGVyYXRpb24sIGludCB2ZXJ0aWNhbERpc3RhbmNlLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBm YWxzZSk7CisgICAgYm9vbCBtb2RpZnkoRUFsdGVyYXRpb24sIGludCB2ZXJ0aWNhbERpc3RhbmNl LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSwgQ3Vyc29yQWxpZ25PblNjcm9sbCA9IEFsaWdu Q3Vyc29yT25TY3JvbGxJZk5lZWRlZCk7CiAgICAgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5 KCkgY29uc3QgeyByZXR1cm4gbV9ncmFudWxhcml0eTsgfQogCiAgICAgdm9pZCBzZXRTdGFydChj b25zdCBWaXNpYmxlUG9zaXRpb24gJiwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwpJbmRl eDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5n ZUxvZwkocmV2aXNpb24gNTk5NTEpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcg Y29weSkKQEAgLTEsMyArMSwyMCBAQAorMjAxMC0wNS0yMSAgWmVsaWRyYWcgSG9ybnVuZyAgPHpl bGlkcmFnQGNocm9taXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBGaXhlZCBmcmFtZSBwYWdlIHVwL2Rvd24gc2Nyb2xsaW5nIGNhbGN1bGF0 aW9uLiBNYWRlIHN1cmUgdGhhdCB0aGUKKyAgICAgICAgY3Vyc29yIG1vdmVzIHdpdGggcGFnZSB1 cC9kb3duIGV2ZW50LiBQbGVhc2Ugbm90ZSB0aGF0IG5vdyBmb3IgbWFjCisgICAgICAgIGVkaXRp bmcgYmVoYXZpb3Igd2Ugd2lsbCBzY3JvbGwgdGhlIGNvbnRlbnQgdG8gY2VudGVyIHRoZSBjdXJz b3Igb24KKyAgICAgICAgcGFnZSB1cC9kb3duIHdoaWxlIG90aGVyIHBsYXRmb3JtcyB3aWxsIGFs aWduIHRoZSBjdXJzb3Igd2l0aCB0aGUgdG9wIG9mCisgICAgICAgIGRpc3BsYXllZCBmcmFtZS4K KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4MjEzCisg ICAgICAgIAorICAgICAgICAqIGVkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi1leHBl Y3RlZC50eHQ6IEZpeGVkIHBhZ2Ugc2Nyb2xsIGNhbGN1bGF0aW9uLiBOb3cgc2Nyb2xsIGhlaWdo dCBpcyBjYWxjdWxhdGVkIG9ubHkgZnJvbSB0aGUgdmlzaWJsZSBwb3J0aW9uIG5vdCB0aGUgZW50 aXJlIGZyYW1lIGhlaWdodC4KKyAgICAgICAgKiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVw LWRvd24uaHRtbDogRGl0dG8uCisgICAgICAgICogZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3Bv cnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dDogU2Nyb2xsaW5nIHRlc3Qgb2YgY29udGVudGVk aXRhYmxlIGlmcmFtZSBhbmQgZGl2LgorICAgICAgICAqIGVkaXRpbmcvaW5wdXQvc2Nyb2xsLXZp ZXdwb3J0LXBhZ2UtdXAtZG93bi5odG1sOiBEaXR0by4KKyAgICAgICAgKiBlZGl0aW5nL3Jlc291 cmNlcy9jb250ZW50ZWRpdGFibGUtaWZyYW1lLWZpeGVkLXNpemUtc3JjLmh0bWw6IFJlc291cmNl IGZvciB0aGUgc2Nyb2xsaW5nIHRlc3QgYWJvdmUuCisKIDIwMTAtMDUtMjEgIEJldGggRGFraW4g IDxiZGFraW5AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpJ bmRleDogTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLWV4cGVj dGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L29wdGlvbi1w YWdlLXVwLWRvd24tZXhwZWN0ZWQudHh0CShyZXZpc2lvbiA1OTk1MSkKKysrIExheW91dFRlc3Rz L2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi1leHBlY3RlZC50eHQJKHdvcmtpbmcg Y29weSkKQEAgLTEsMyArMSwyNCBAQAotT24gTWFjLCBvcHRpb24rcGFnZWRvd24gc2hvdWxkIG1v dmUgdGhlIG1vdXNlIGN1cnNvciBhbmQgc2Nyb2xsIGluIHRleHQgYXJlYXMuIE9uIG90aGVyIHBs YXRmb3JtcywgcGFnZWRvd24gc2hvdWxkIG1vdmUgdGhlIG1vdXNlIGN1cnNvciBhbmQgc2Nyb2xs IGluIHRleHQgYXJlYXMuIFRoaXMgdGVzdCByZXF1aXJlcyBEUlQgdG8gcGFzcy4KK1BhZ2UgdXAv ZG93biAob3B0aW9uK3BhZ2UgdXAvZG93biBvbiBNYWMpIHNob3VsZCBtb3ZlIHRoZSBtb3ZlIGN1 cnNvciBhbmQgc2Nyb2xsIHRoZSBjb250ZW50IGluIGNvbnRlbnRlZGl0YWJsZSBlbGVtZW50cy4g VGhpcyBzYW1wbGUgY292ZXJzIGN1cnNvciBwb3NpdGlvbiBtb3ZlIHRlc3Qgb2YgYSkgaWZyYW1l IGVsZW1lbnQgY29udGFpbmluZyBjb250ZW50ZWRpdGFibGUgYm9keSwgYW5kIGIpIGNvbnRlbnQg ZWRpdGFibGUgZGl2IGVsZW1lbnQuCiAKLVBBU1MKK2xpbmUgMAorCitsaW5lIDEKKworbGluZSAy CisKK2xpbmUgMworCitsaW5lIDQKKworbGluZSA1CisKK2xpbmUgNgorCitsaW5lIDcKKworbGlu ZSA4CisKK2xpbmUgOQorCitpZnJhbWUgUEFTUworZGl2IFBBU1MKSW5kZXg6IExheW91dFRlc3Rz L2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExh eW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sCShyZXZpc2lv biA1OTk1MSkKKysrIExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93 bi5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC0xLDE3ICsxLDQzIEBACis8aGVhZD4KKzxzdHlsZSB0 eXBlPSJ0ZXh0L2NzcyI+CisgIC5haGVtIHsgZm9udDogMjBweCBBaGVtOyB9Cis8L3N0eWxlPgog PHNjcmlwdD4KIGlmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCiAgICAgbGF5b3V0VGVz dENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOwogCi1mdW5jdGlvbiBydW5UZXN0KCkKLXsKK2Z1bmN0 aW9uIHJ1blRlc3QoKSB7CisgIHJ1bkZyYW1lQ3Vyc29yTW92ZVRlc3QoKTsKKyAgcnVuRGl2Q3Vy c29yTW92ZVRlc3QoKTsKK30KKworZnVuY3Rpb24gZ2VuZXJhdGVDb250ZW50KCkgeworICAgIHZh ciBjb250ZW50ID0gIiI7CisgICAgZm9yICh2YXIgaSA9IDA7IGkgPCAxMDsgKytpKQorICAgICAg ICBjb250ZW50ICs9ICI8cD5saW5lICIgKyBpICsgIjwvcD5cbiI7CisgICAgcmV0dXJuIGNvbnRl bnQ7Cit9CisKK2Z1bmN0aW9uIHJ1bkZyYW1lQ3Vyc29yTW92ZVRlc3QoKSB7CiAgICAgdmFyIGZy YW1lID0gZnJhbWVzWzBdOwogICAgIHZhciBkb2MgPSBmcmFtZS5kb2N1bWVudDsKICAgICB2YXIg Ym9keSA9IGRvYy5ib2R5OwotICAgIGZvciAodmFyIGkgPSAwOyBpIDwgMTA7ICsraSkKLSAgICAg ICAgYm9keS5pbm5lckhUTUwgKz0gIjxwPmxpbmUgIiArIGkgKyAiPC9wPlxuIjsKKyAgICBib2R5 LmlubmVySFRNTCA9IGdlbmVyYXRlQ29udGVudCgpOwogICAgIGZyYW1lLmZvY3VzKCk7CiAgICAg ZnJhbWUuZ2V0U2VsZWN0aW9uKCkuc2V0UG9zaXRpb24oYm9keS5maXJzdENoaWxkLCAwKTsKKyAg ICBydW5DdXJzb3JNb3ZlVGVzdCgiaWZyYW1lIiwgZnJhbWUsIGZyYW1lKTsKK30KKworZnVuY3Rp b24gcnVuRGl2Q3Vyc29yTW92ZVRlc3QoKSB7CisgICAgdmFyIGVkaXRhYmxlID0gZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ2VkaXRhYmxlJyk7CisgICAgZWRpdGFibGUuaW5uZXJIVE1MID0gZ2Vu ZXJhdGVDb250ZW50KCk7CisgICAgZWRpdGFibGUuZm9jdXMoKTsKKyAgICB3aW5kb3cuZ2V0U2Vs ZWN0aW9uKCkuc2V0UG9zaXRpb24oZWRpdGFibGUsIDApOworICAgIHJ1bkN1cnNvck1vdmVUZXN0 KCJkaXYiLCBlZGl0YWJsZSwgd2luZG93KTsKK30KIAorZnVuY3Rpb24gcnVuQ3Vyc29yTW92ZVRl c3QodGVzdE5hbWUsIGZyYW1lLCBzZWxlY3Rpb25Tb3VyY2UpCit7CiAgICAgdmFyIG9uTWFjUGxh dGZvcm0gPSBuYXZpZ2F0b3IudXNlckFnZW50LnNlYXJjaCgvXGJNYWMgT1MgWFxiLykgIT0gLTE7 CiAgICAgdmFyIG1vZGlmaWVycyA9IG9uTWFjUGxhdGZvcm0gPyBbImFsdEtleSJdIDogW107CiAK QEAgLTE5LDI2ICs0NSw0NiBAQCBmdW5jdGlvbiBydW5UZXN0KCkKICAgICAgICAgcmV0dXJuOwog CiAgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBtb2RpZmllcnMpOwotICAgIHZh ciBsaW5lID0gZnJhbWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOwotICAgIGlm IChsaW5lICE9ICJsaW5lIDgiKQotICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBs aW5lIDgsIG5vdCAiICsgbGluZTsKKyAgICB2YXIgbGluZSA9IHNlbGVjdGlvblNvdXJjZS5nZXRT ZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUgMyIp CisgICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMywgbm90ICIgKyBsaW5l OwogCiAgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBtb2RpZmllcnMpOwotICAg IHZhciBsaW5lID0gZnJhbWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOwotICAg IGlmIChsaW5lICE9ICJsaW5lIDkiKQotICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBh dCBsaW5lIDksIG5vdCAiICsgbGluZTsKKyAgICB2YXIgbGluZSA9IHNlbGVjdGlvblNvdXJjZS5n ZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUg NiIpCisgICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgNiwgbm90ICIgKyBs aW5lOwogCiAgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZVVwIiwgbW9kaWZpZXJzKTsKLSAg ICB2YXIgbGluZSA9IGZyYW1lLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKLSAg ICBpZiAobGluZSAhPSAibGluZSAxIikKLSAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUg YXQgbGluZSAxLCBub3QgIiArIGxpbmU7CisgICAgdmFyIGxpbmUgPSBzZWxlY3Rpb25Tb3VyY2Uu Z2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOworICAgIGlmIChsaW5lICE9ICJsaW5l IDMiKQorICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsg bGluZTsKKworICAgIC8vIFRlc3QgdGhhdCBvbiBNYWMgcGFnZURvd24vcGFnZVVwIGRvZXMgbm90 IG1vdmUgdGhlIGN1cnNvciBhdCBhbGwuCisgICAgaWYgKG9uTWFjUGxhdGZvcm0pIHsKKyAgICAg IGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3duIiwgW10pOworICAgICAgdmFyIGxpbmUgPSBz ZWxlY3Rpb25Tb3VyY2UuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOworICAgICAg aWYgKGxpbmUgIT0gImxpbmUgMyIpIHsKKyAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgicmVzdWx0cyIpLmlubmVyVGV4dCA9ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMywgbm90 ICIgKyBsaW5lOworICAgICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMywg bm90ICIgKyBsaW5lOworICAgICAgfQorCisgICAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdl VXAiLCBbXSk7CisgICAgICB2YXIgbGluZSA9IHNlbGVjdGlvblNvdXJjZS5nZXRTZWxlY3Rpb24o KS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgICBpZiAobGluZSAhPSAibGluZSAzIikgeworICAg ICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHRzIikuaW5uZXJUZXh0ID0gImN1 cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7CisgICAgICAgICAgdGhyb3cg ImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7CisgICAgICB9CisgICAg fQogCi0gICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lclRleHQgPSAi UEFTUyI7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lckhUTUwg Kz0gdGVzdE5hbWUgKyAiIFBBU1M8YnIvPiI7CiB9CiA8L3NjcmlwdD4KLQotPGRpdj5PbiBNYWMs IG9wdGlvbitwYWdlZG93biBzaG91bGQgbW92ZSB0aGUgbW91c2UgY3Vyc29yIGFuZCBzY3JvbGwg aW4gdGV4dCBhcmVhcy4gIE9uCi1vdGhlciBwbGF0Zm9ybXMsIHBhZ2Vkb3duIHNob3VsZCBtb3Zl IHRoZSBtb3VzZSBjdXJzb3IgYW5kIHNjcm9sbCBpbiB0ZXh0IGFyZWFzLiAgVGhpcwotdGVzdCBy ZXF1aXJlcyBEUlQgdG8gcGFzcy48L2Rpdj4KLTxpZnJhbWUgc3JjPSIuLi9yZXNvdXJjZXMvY29u dGVudGVkaXRhYmxlLWlmcmFtZS1zcmMuaHRtbCIgb25sb2FkPSJydW5UZXN0KCkiPjwvaWZyYW1l PgotPGRpdiBpZD0icmVzdWx0cyI+RkFJTDwvZGl2PgorPC9oZWFkPgorPGJvZHk+Cis8ZGl2PlBh Z2UgdXAvZG93biAob3B0aW9uK3BhZ2UgdXAvZG93biBvbiBNYWMpIHNob3VsZCBtb3ZlIHRoZSBt b3ZlIGN1cnNvciBhbmQgc2Nyb2xsIHRoZSBjb250ZW50CitpbiBjb250ZW50ZWRpdGFibGUgZWxl bWVudHMuIFRoaXMgc2FtcGxlIGNvdmVycyBjdXJzb3IgcG9zaXRpb24gbW92ZSB0ZXN0IG9mIGEp IGlmcmFtZSBlbGVtZW50IGNvbnRhaW5pbmcKK2NvbnRlbnRlZGl0YWJsZSBib2R5LCBhbmQgYikg Y29udGVudCBlZGl0YWJsZSBkaXYgZWxlbWVudC48L2Rpdj4KKzxpZnJhbWUgc3JjPSIuLi9yZXNv dXJjZXMvY29udGVudGVkaXRhYmxlLWlmcmFtZS1maXhlZC1zaXplLXNyYy5odG1sIiBvbmxvYWQ9 InJ1blRlc3QoKSI+PC9pZnJhbWU+Cis8ZGl2IGlkPSJlZGl0YWJsZSIgY29udGVudGVkaXRhYmxl PSJ0cnVlIiBjbGFzcz0iYWhlbSIgc3R5bGU9ImhlaWdodDoxNTBweDsgb3ZlcmZsb3c6YXV0bzsi PjwvZGl2PgorPGRpdiBpZD0icmVzdWx0cyI+PC9kaXY+Cis8L2JvZHk+ClwgTm8gbmV3bGluZSBh dCBlbmQgb2YgZmlsZQpJbmRleDogTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3JvbGwtdmll d3BvcnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9lZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24tZXhwZWN0ZWQudHh0 CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3Bv cnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyNCBA QAorUGFnZSB1cC9kb3duIChvcHRpb24rcGFnZSB1cC9kb3duIG9uIE1hYykgc2hvdWxkIG1vdmUg dGhlIG1vdmUgY3Vyc29yIGFuZCBzY3JvbGwgdGhlIGNvbnRlbnQgaW4gY29udGVudGVkaXRhYmxl IGVsZW1lbnRzLiBUaGlzIHNhbXBsZSBjb3ZlcnMgc2Nyb2xsIHBvc2l0aW9uIHRlc3Qgb2YgYSkg aWZyYW1lIGVsZW1lbnQgY29udGFpbmluZyBjb250ZW50ZWRpdGFibGUgYm9keSBhbmQgYikgY29u dGVudCBlZGl0YWJsZSBkaXYgZWxlbWVudC4gRXZlbiB0aG91Z2ggdGhlIGN1cnNvciB3aWxsIG1v dmUgZXhhY3RseSB0byB0aGUgc2FtZSBsb2NhdGlvbiBvbiBhbGwgcGxhdGZvcm1zIChjb3ZlcmVk IGJ5IHRlc3Qgb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sKSwgcGxlYXNlIG5vdGUgdGhhdCBNYWMg d2lsbCBzY3JvbGwgdGhlIHZpc2libGUgYXJlYSBieSBwbGFjaW5nIHRoZSBjdXJzb3IgcG9zaXRp b24gaW4gdGhlIG1pZGRsZS4gQWxsIG90aGVyIHBsYXRmb3JtcyB3aWxsIHNjcm9sbCBieSBrZWVw aW5nIHRoZSBjdXJzb3IgYWxpZ25lZCB3aXRoIHRoZSB0b3AgZWRnZSBvZiB0aGUgdmlzaWJsZSBh cmVhLgorCitsaW5lIDAKKworbGluZSAxCisKK2xpbmUgMgorCitsaW5lIDMKKworbGluZSA0CisK K2xpbmUgNQorCitsaW5lIDYKKworbGluZSA3CisKK2xpbmUgOAorCitsaW5lIDkKKworaWZyYW1l IFBBU1MKK2RpdiBQQVNTCkluZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3Njcm9sbC12 aWV3cG9ydC1wYWdlLXVwLWRvd24uaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0 aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24uaHRtbAkocmV2aXNpb24gMCkK KysrIExheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAtZG93 bi5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDg5IEBACis8aGVhZD4KKzxzdHlsZSB0eXBl PSJ0ZXh0L2NzcyI+CisgIC5haGVtIHsgZm9udDogMjBweCBBaGVtOyB9Cis8L3N0eWxlPgorPHNj cmlwdD4KKworaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRUZXN0 Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CisKK3ZhciBvbk1hY1BsYXRmb3JtID0gbmF2aWdhdG9y LnVzZXJBZ2VudC5zZWFyY2goL1xiTWFjIE9TIFhcYi8pICE9IC0xOworCitmdW5jdGlvbiBydW5U ZXN0KCkgeworICAgIHJ1bkZyYW1lU2Nyb2xsVGVzdCgpOworICAgIHJ1bkRpdlNjcm9sbFRlc3Qo KTsKK30KKworZnVuY3Rpb24gZ2VuZXJhdGVDb250ZW50KCkgeworICAgIHZhciBjb250ZW50ID0g IiI7CisgICAgZm9yICh2YXIgaSA9IDA7IGkgPCAxMDsgKytpKQorICAgICAgICBjb250ZW50ICs9 ICI8cD5saW5lICIgKyBpICsgIjwvcD5cbiI7CisgICAgcmV0dXJuIGNvbnRlbnQ7Cit9CisKK2Z1 bmN0aW9uIHJ1bkZyYW1lU2Nyb2xsVGVzdCgpIHsKKyAgICB2YXIgZnJhbWUgPSBmcmFtZXNbMF07 CisgICAgdmFyIGRvYyA9IGZyYW1lLmRvY3VtZW50OworICAgIHZhciBib2R5ID0gZG9jLmJvZHk7 CisgICAgYm9keS5pbm5lckhUTUwgPSBnZW5lcmF0ZUNvbnRlbnQoKTsKKyAgICBmcmFtZS5mb2N1 cygpOworICAgIGZyYW1lLmdldFNlbGVjdGlvbigpLnNldFBvc2l0aW9uKGJvZHkuZmlyc3RDaGls ZCwgMCk7CisgICAgaWYgKG9uTWFjUGxhdGZvcm0pCisgICAgICAgIG9mZnNldHMgPSBbIDU1LCAx NzUgXTsKKyAgICBlbHNlIAorICAgICAgICBvZmZzZXRzID0gWyAxMjAsIDI0MCBdOworICAgIHJ1 blNjcm9sbGluZ1Rlc3QoImlmcmFtZSIsIGZyYW1lLCBvZmZzZXRzLCBmdW5jdGlvbigpIHsgcmV0 dXJuIGZyYW1lLnBhZ2VZT2Zmc2V0OyB9KTsKK30KKworZnVuY3Rpb24gcnVuRGl2U2Nyb2xsVGVz dCgpIHsKKyAgICB2YXIgZWRpdGFibGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZWRpdGFi bGUnKTsKKyAgICBlZGl0YWJsZS5pbm5lckhUTUwgPSBnZW5lcmF0ZUNvbnRlbnQoKTsKKyAgICBl ZGl0YWJsZS5mb2N1cygpOworICAgIHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5zZXRQb3NpdGlvbihl ZGl0YWJsZSwgMCk7CisgICAgaWYgKG9uTWFjUGxhdGZvcm0pCisgICAgICAgIG9mZnNldHMgPSBb IDc1LCAxOTUgXTsKKyAgICBlbHNlIAorICAgICAgICBvZmZzZXRzID0gWyAxNDAsIDI2MCBdOwor ICAgIHJ1blNjcm9sbGluZ1Rlc3QoImRpdiIsIGVkaXRhYmxlLCBvZmZzZXRzLCBmdW5jdGlvbigp IHsgcmV0dXJuIGVkaXRhYmxlLnNjcm9sbFRvcDsgfSk7Cit9CisKK2Z1bmN0aW9uIHJ1blNjcm9s bGluZ1Rlc3QodGVzdE5hbWUsIGZyYW1lLCBvZmZzZXRzLCBzY3JvbGxGdW5jdGlvbikgeworICAg IHZhciB0b2xlcmFuY2UgPSAwOworICAgIHZhciBtb2RpZmllcnMgPSBvbk1hY1BsYXRmb3JtID8g WyJhbHRLZXkiXSA6IFtdOworICAgIAorICAgIGlmICghd2luZG93LmV2ZW50U2VuZGVyKQorICAg ICAgICByZXR1cm47CisKKyAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIsIG1vZGlm aWVycyk7CisgICAgaWYgKE1hdGguYWJzKHNjcm9sbEZ1bmN0aW9uKCkgLSBvZmZzZXRzWzBdKSA+ IHRvbGVyYW5jZSkgeworICAgICAgICB0aHJvdyAiRnJhbWUgdmlld3BvcnQgc2hvdWxkIGJlIGFy b3VuZCAiICsgb2Zmc2V0c1swXSArCisgICAgICAgICAgICAicHggLCBub3QgYXQgIiArIHNjcm9s bEZ1bmN0aW9uKCk7CisgICAgfQorCisgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24i LCBtb2RpZmllcnMpOworICAgIGlmIChNYXRoLmFicyhzY3JvbGxGdW5jdGlvbigpIC0gb2Zmc2V0 c1sxXSkgPiB0b2xlcmFuY2UpIHsKKyAgICAgICAgdGhyb3cgIkZyYW1lIHZpZXdwb3J0IHNob3Vs ZCBiZSBhcm91bmQgIiArIG9mZnNldHNbMV0gKworICAgICAgICAgICAgInB4ICwgbm90ICIgKyBz Y3JvbGxGdW5jdGlvbigpOworICAgIH0KKworICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VV cCIsIG1vZGlmaWVycyk7CisgICAgaWYgKE1hdGguYWJzKHNjcm9sbEZ1bmN0aW9uKCkgLSBvZmZz ZXRzWzBdKSA+IHRvbGVyYW5jZSkgeworICAgICAgICB0aHJvdyAiRnJhbWUgdmlld3BvcnQgc2hv dWxkIGJlIGFyb3VuZCAiICsgb2Zmc2V0c1swXSArCisgICAgICAgICAgICAicHggLCBub3QgYXQg IiArIHNjcm9sbEZ1bmN0aW9uKCk7CisgICAgfQorCisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInJlc3VsdHMiKS5pbm5lckhUTUwgKz0gdGVzdE5hbWUgKyAiIFBBU1M8YnIvPiI7Cit9Cis8 L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5PgorPGRpdj5QYWdlIHVwL2Rvd24gKG9wdGlvbitwYWdl IHVwL2Rvd24gb24gTWFjKSBzaG91bGQgbW92ZSB0aGUgbW92ZSBjdXJzb3IgYW5kIHNjcm9sbCB0 aGUgY29udGVudAoraW4gY29udGVudGVkaXRhYmxlIGVsZW1lbnRzLiBUaGlzIHNhbXBsZSBjb3Zl cnMgc2Nyb2xsIHBvc2l0aW9uIHRlc3Qgb2YgYSkgaWZyYW1lIGVsZW1lbnQgY29udGFpbmluZwor Y29udGVudGVkaXRhYmxlIGJvZHkgYW5kIGIpIGNvbnRlbnQgZWRpdGFibGUgZGl2IGVsZW1lbnQu IEV2ZW4gdGhvdWdoIHRoZSBjdXJzb3Igd2lsbCBtb3ZlIGV4YWN0bHkgdG8KK3RoZSBzYW1lIGxv Y2F0aW9uIG9uIGFsbCBwbGF0Zm9ybXMgKGNvdmVyZWQgYnkgdGVzdCBvcHRpb24tcGFnZS11cC1k b3duLmh0bWwpLCBwbGVhc2Ugbm90ZSB0aGF0IE1hYyB3aWxsCitzY3JvbGwgdGhlIHZpc2libGUg YXJlYSBieSBwbGFjaW5nIHRoZSBjdXJzb3IgcG9zaXRpb24gaW4gdGhlIG1pZGRsZS4gQWxsIG90 aGVyIHBsYXRmb3JtcyB3aWxsIHNjcm9sbCBieQora2VlcGluZyB0aGUgY3Vyc29yIGFsaWduZWQg d2l0aCB0aGUgdG9wIGVkZ2Ugb2YgdGhlIHZpc2libGUgYXJlYS4gPC9kaXY+Cis8aWZyYW1lIHNy Yz0iLi4vcmVzb3VyY2VzL2NvbnRlbnRlZGl0YWJsZS1pZnJhbWUtZml4ZWQtc2l6ZS1zcmMuaHRt bCIgb25sb2FkPSJydW5UZXN0KCkiIHN0eWxlPSJoZWlnaHQ6MTUwcHg7IHBhZGRpbmc6IDBweDsi PjwvaWZyYW1lPgorPGRpdiBpZD0iZWRpdGFibGUiIGNvbnRlbnRlZGl0YWJsZT0idHJ1ZSIgY2xh c3M9ImFoZW0iIHN0eWxlPSJoZWlnaHQ6MTUwcHg7IG92ZXJmbG93OmF1dG87IHBhZGRpbmc6IDBw eDsgbWFyZ2luOiAwcHg7Ij48L2Rpdj4KKzxkaXYgaWQ9InJlc3VsdHMiPjwvZGl2PgorPC9ib2R5 PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKSW5kZXg6IExheW91dFRlc3RzL2VkaXRpbmcv cmVzb3VyY2VzL2NvbnRlbnRlZGl0YWJsZS1pZnJhbWUtZml4ZWQtc2l6ZS1zcmMuaHRtbAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUt aWZyYW1lLWZpeGVkLXNpemUtc3JjLmh0bWwJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9l ZGl0aW5nL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUtaWZyYW1lLWZpeGVkLXNpemUtc3JjLmh0 bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNiBAQAorPHN0eWxlIHR5cGU9InRleHQvY3NzIj4K KyAgLmFoZW0geyBmb250OiAyMHB4IEFoZW07IH0KKzwvc3R5bGU+Cis8Ym9keSBiZ2NvbG9yPSJs aWdodHllbGxvdyIgY29udGVudGVkaXRhYmxlIGNsYXNzPSJhaGVtIiBzdHlsZT0icGFkZGluZzog MHB4OyBtYXJnaW46IDBweDsiPgorCis8L2JvZHk+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmls ZQo= 56847 2010-05-23 22:32:45 -0700 2010-05-26 02:24:47 -0700 Patch bug-38213-20100524143243.patch text/plain 125664 tony ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCAxMDdjMTYyOWJiNDM2OWJiNzg0MWM1YWFhODVlMGYyYTk3NjQ5ODM0Li45MDEzNGQ3 OTlhMDE1MDYxZTk1NDY5MDEzYjgxN2VhNTlkMWUyOThjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAK KzIwMTAtMDUtMjMgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0BjaHJvbWl1bS5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgT2phbiBWYWZhaS4KKworICAgICAgICBGaXhlZCBmcmFtZSBw YWdlIHVwL2Rvd24gc2Nyb2xsaW5nIGNhbGN1bGF0aW9uLiBNYWRlIHN1cmUgdGhhdCB0aGUKKyAg ICAgICAgY3Vyc29yIG1vdmVzIHdpdGggcGFnZSB1cC9kb3duIGV2ZW50LiBQbGVhc2Ugbm90ZSB0 aGF0IG5vdyBmb3IgbWFjCisgICAgICAgIGVkaXRpbmcgYmVoYXZpb3Igd2Ugd2lsbCBzY3JvbGwg dGhlIGNvbnRlbnQgdG8gY2VudGVyIHRoZSBjdXJzb3Igb24KKyAgICAgICAgcGFnZSB1cC9kb3du IHdoaWxlIG90aGVyIHBsYXRmb3JtcyB3aWxsIGFsaWduIHRoZSBjdXJzb3Igd2l0aCB0aGUgdG9w IG9mCisgICAgICAgIGRpc3BsYXllZCBmcmFtZS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTM4MjEzCisgICAgICAgIAorICAgICAgICAqIGVkaXRpbmcv aW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi1leHBlY3RlZC50eHQ6IEZpeGVkIHBhZ2Ugc2Nyb2xs IGNhbGN1bGF0aW9uLiBOb3cgc2Nyb2xsIGhlaWdodCBpcyBjYWxjdWxhdGVkIG9ubHkgZnJvbSB0 aGUgdmlzaWJsZSBwb3J0aW9uIG5vdCB0aGUgZW50aXJlIGZyYW1lIGhlaWdodC4KKyAgICAgICAg KiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbDogRGl0dG8uCisgICAgICAg ICogZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4 dDogU2Nyb2xsaW5nIHRlc3Qgb2YgY29udGVudGVkaXRhYmxlIGlmcmFtZSBhbmQgZGl2LgorICAg ICAgICAqIGVkaXRpbmcvaW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAtZG93bi5odG1sOiBE aXR0by4KKyAgICAgICAgKiBlZGl0aW5nL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUtaWZyYW1l LWZpeGVkLXNpemUtc3JjLmh0bWw6IFJlc291cmNlIGZvciB0aGUgc2Nyb2xsaW5nIHRlc3QgYWJv dmUuCisgICAgICAgICogcGxhdGZvcm0vbWFjL2VkaXRpbmcvc2VsZWN0aW9uLzI1MjI4Lmh0bWw6 IFJlYmFzZWxpbmVkIGJlY2F1c2Ugd2Ugbm93IGNlbnRlcgorICAgICAgICAgICAgICB3aGVuIGJy aW5naW5nIHRoZSBjdXJzb3IgaW50byB2aWV3LgorCiAyMDEwLTA1LTIzICBNT1JJVEEgSGFqaW1l ICA8bW9ycml0YUBnb29nbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbnQgVGFtdXJh LgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1k b3duLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2Ut dXAtZG93bi1leHBlY3RlZC50eHQKaW5kZXggOThhNWJlMDBhY2Y0Y2ZjNzUzODM4MTNhZjRjOGVh MDJlNDM0MWVjMi4uMmVhODE5NDUxZmMxYzMxZjk5NWU5NTI2YjBmZDg1MWZkMjY5NmYyZCAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLWV4 cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVw LWRvd24tZXhwZWN0ZWQudHh0CkBAIC0xLDMgKzEsMjUgQEAKLU9uIE1hYywgb3B0aW9uK3BhZ2Vk b3duIHNob3VsZCBtb3ZlIHRoZSBtb3VzZSBjdXJzb3IgYW5kIHNjcm9sbCBpbiB0ZXh0IGFyZWFz LiBPbiBvdGhlciBwbGF0Zm9ybXMsIHBhZ2Vkb3duIHNob3VsZCBtb3ZlIHRoZSBtb3VzZSBjdXJz b3IgYW5kIHNjcm9sbCBpbiB0ZXh0IGFyZWFzLiBUaGlzIHRlc3QgcmVxdWlyZXMgRFJUIHRvIHBh c3MuCitQYWdlIHVwL2Rvd24gKG9wdGlvbitwYWdlIHVwL2Rvd24gb24gTWFjKSBzaG91bGQgbW92 ZSB0aGUgbW92ZSBjdXJzb3IgYW5kIHNjcm9sbCB0aGUgY29udGVudCBpbiBjb250ZW50ZWRpdGFi bGUgZWxlbWVudHMuIFRoaXMgc2FtcGxlIGNvdmVycyBjdXJzb3IgcG9zaXRpb24gbW92ZSB0ZXN0 IG9mIGEpIGlmcmFtZSBlbGVtZW50IGNvbnRhaW5pbmcgY29udGVudGVkaXRhYmxlIGJvZHksIGFu ZCBiKSBjb250ZW50IGVkaXRhYmxlIGRpdiBlbGVtZW50LgorCitsaW5lIDAKKworbGluZSAxCisK K2xpbmUgMgorCitsaW5lIDMKKworbGluZSA0CisKK2xpbmUgNQorCitsaW5lIDYKKworbGluZSA3 CisKK2xpbmUgOAorCitsaW5lIDkKKworaWZyYW1lIFBBU1MKK2RpdiBQQVNTCiAKLVBBU1MKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5o dG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLmh0bWwK aW5kZXggODZlNTRlYWNiZTdkNmI3ZTRmNmNkYzU5YTZhZjk5Zjg2NWY4OWVlMS4uMWI2NjVmYjUx ODU0ZjZjOGZlMDc1Mzg3ZWQ0OTU4YjUwMmI2YTM2OSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMv ZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLmh0bWwKQEAgLTEsMTcgKzEsNDMgQEAK KzxoZWFkPgorPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgLmFoZW0geyBmb250OiAyMHB4IEFo ZW07IH0KKzwvc3R5bGU+CiA8c2NyaXB0PgogaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxl cikKICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7CiAKLWZ1bmN0aW9uIHJ1 blRlc3QoKQoteworZnVuY3Rpb24gcnVuVGVzdCgpIHsKKyAgcnVuRnJhbWVDdXJzb3JNb3ZlVGVz dCgpOworICBydW5EaXZDdXJzb3JNb3ZlVGVzdCgpOworfQorCitmdW5jdGlvbiBnZW5lcmF0ZUNv bnRlbnQoKSB7CisgICAgdmFyIGNvbnRlbnQgPSAiIjsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8 IDEwOyArK2kpCisgICAgICAgIGNvbnRlbnQgKz0gIjxwPmxpbmUgIiArIGkgKyAiPC9wPlxuIjsK KyAgICByZXR1cm4gY29udGVudDsKK30KKworZnVuY3Rpb24gcnVuRnJhbWVDdXJzb3JNb3ZlVGVz dCgpIHsKICAgICB2YXIgZnJhbWUgPSBmcmFtZXNbMF07CiAgICAgdmFyIGRvYyA9IGZyYW1lLmRv Y3VtZW50OwogICAgIHZhciBib2R5ID0gZG9jLmJvZHk7Ci0gICAgZm9yICh2YXIgaSA9IDA7IGkg PCAxMDsgKytpKQotICAgICAgICBib2R5LmlubmVySFRNTCArPSAiPHA+bGluZSAiICsgaSArICI8 L3A+XG4iOworICAgIGJvZHkuaW5uZXJIVE1MID0gZ2VuZXJhdGVDb250ZW50KCk7CiAgICAgZnJh bWUuZm9jdXMoKTsKICAgICBmcmFtZS5nZXRTZWxlY3Rpb24oKS5zZXRQb3NpdGlvbihib2R5LmZp cnN0Q2hpbGQsIDApOworICAgIHJ1bkN1cnNvck1vdmVUZXN0KCJpZnJhbWUiLCBmcmFtZSwgZnJh bWUpOworfQorCitmdW5jdGlvbiBydW5EaXZDdXJzb3JNb3ZlVGVzdCgpIHsKKyAgICB2YXIgZWRp dGFibGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZWRpdGFibGUnKTsKKyAgICBlZGl0YWJs ZS5pbm5lckhUTUwgPSBnZW5lcmF0ZUNvbnRlbnQoKTsKKyAgICBlZGl0YWJsZS5mb2N1cygpOwor ICAgIHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5zZXRQb3NpdGlvbihlZGl0YWJsZSwgMCk7CisgICAg cnVuQ3Vyc29yTW92ZVRlc3QoImRpdiIsIGVkaXRhYmxlLCB3aW5kb3cpOworfQogCitmdW5jdGlv biBydW5DdXJzb3JNb3ZlVGVzdCh0ZXN0TmFtZSwgZnJhbWUsIHNlbGVjdGlvblNvdXJjZSkKK3sK ICAgICB2YXIgb25NYWNQbGF0Zm9ybSA9IG5hdmlnYXRvci51c2VyQWdlbnQuc2VhcmNoKC9cYk1h YyBPUyBYXGIvKSAhPSAtMTsKICAgICB2YXIgbW9kaWZpZXJzID0gb25NYWNQbGF0Zm9ybSA/IFsi YWx0S2V5Il0gOiBbXTsKIApAQCAtMTksMjYgKzQ1LDQ2IEBAIGZ1bmN0aW9uIHJ1blRlc3QoKQog ICAgICAgICByZXR1cm47CiAKICAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIsIG1v ZGlmaWVycyk7Ci0gICAgdmFyIGxpbmUgPSBmcmFtZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5u b2RlVmFsdWU7Ci0gICAgaWYgKGxpbmUgIT0gImxpbmUgOCIpCi0gICAgICAgIHRocm93ICJjdXJz b3Igc2hvdWxkIGJlIGF0IGxpbmUgOCwgbm90ICIgKyBsaW5lOworICAgIHZhciBsaW5lID0gc2Vs ZWN0aW9uU291cmNlLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKKyAgICBpZiAo bGluZSAhPSAibGluZSAzIikKKyAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGlu ZSAzLCBub3QgIiArIGxpbmU7CiAKICAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIs IG1vZGlmaWVycyk7Ci0gICAgdmFyIGxpbmUgPSBmcmFtZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9k ZS5ub2RlVmFsdWU7Ci0gICAgaWYgKGxpbmUgIT0gImxpbmUgOSIpCi0gICAgICAgIHRocm93ICJj dXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgOSwgbm90ICIgKyBsaW5lOworICAgIHZhciBsaW5lID0g c2VsZWN0aW9uU291cmNlLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKKyAgICBp ZiAobGluZSAhPSAibGluZSA2IikKKyAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQg bGluZSA2LCBub3QgIiArIGxpbmU7CiAKICAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlVXAi LCBtb2RpZmllcnMpOwotICAgIHZhciBsaW5lID0gZnJhbWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5v ZGUubm9kZVZhbHVlOwotICAgIGlmIChsaW5lICE9ICJsaW5lIDEiKQotICAgICAgICB0aHJvdyAi Y3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDEsIG5vdCAiICsgbGluZTsKKyAgICB2YXIgbGluZSA9 IHNlbGVjdGlvblNvdXJjZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAg aWYgKGxpbmUgIT0gImxpbmUgMyIpCisgICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0 IGxpbmUgMywgbm90ICIgKyBsaW5lOwogCi0gICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJl c3VsdHMiKS5pbm5lclRleHQgPSAiUEFTUyI7CisgICAgLy8gVGVzdCB0aGF0IG9uIE1hYyBwYWdl RG93bi9wYWdlVXAgZG9lcyBub3QgbW92ZSB0aGUgY3Vyc29yIGF0IGFsbC4KKyAgICBpZiAob25N YWNQbGF0Zm9ybSkgeworICAgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBbXSk7 CisgICAgICB2YXIgbGluZSA9IHNlbGVjdGlvblNvdXJjZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9k ZS5ub2RlVmFsdWU7CisgICAgICBpZiAobGluZSAhPSAibGluZSAzIikgeworICAgICAgICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHRzIikuaW5uZXJUZXh0ID0gImN1cnNvciBzaG91 bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7CisgICAgICAgICAgdGhyb3cgImN1cnNvciBz aG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7CisgICAgICB9CisKKyAgICAgIGV2ZW50 U2VuZGVyLmtleURvd24oInBhZ2VVcCIsIFtdKTsKKyAgICAgIHZhciBsaW5lID0gc2VsZWN0aW9u U291cmNlLmdldFNlbGVjdGlvbigpLmJhc2VOb2RlLm5vZGVWYWx1ZTsKKyAgICAgIGlmIChsaW5l ICE9ICJsaW5lIDMiKSB7CisgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3Vs dHMiKS5pbm5lclRleHQgPSAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGlu ZTsKKyAgICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsg bGluZTsKKyAgICAgIH0KKyAgICB9CisKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicmVz dWx0cyIpLmlubmVySFRNTCArPSB0ZXN0TmFtZSArICIgUEFTUzxici8+IjsKIH0KIDwvc2NyaXB0 PgotCi08ZGl2Pk9uIE1hYywgb3B0aW9uK3BhZ2Vkb3duIHNob3VsZCBtb3ZlIHRoZSBtb3VzZSBj dXJzb3IgYW5kIHNjcm9sbCBpbiB0ZXh0IGFyZWFzLiAgT24KLW90aGVyIHBsYXRmb3JtcywgcGFn ZWRvd24gc2hvdWxkIG1vdmUgdGhlIG1vdXNlIGN1cnNvciBhbmQgc2Nyb2xsIGluIHRleHQgYXJl YXMuICBUaGlzCi10ZXN0IHJlcXVpcmVzIERSVCB0byBwYXNzLjwvZGl2PgotPGlmcmFtZSBzcmM9 Ii4uL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUtaWZyYW1lLXNyYy5odG1sIiBvbmxvYWQ9InJ1 blRlc3QoKSI+PC9pZnJhbWU+Ci08ZGl2IGlkPSJyZXN1bHRzIj5GQUlMPC9kaXY+Cis8L2hlYWQ+ Cis8Ym9keT4KKzxkaXY+UGFnZSB1cC9kb3duIChvcHRpb24rcGFnZSB1cC9kb3duIG9uIE1hYykg c2hvdWxkIG1vdmUgdGhlIG1vdmUgY3Vyc29yIGFuZCBzY3JvbGwgdGhlIGNvbnRlbnQKK2luIGNv bnRlbnRlZGl0YWJsZSBlbGVtZW50cy4gVGhpcyBzYW1wbGUgY292ZXJzIGN1cnNvciBwb3NpdGlv biBtb3ZlIHRlc3Qgb2YgYSkgaWZyYW1lIGVsZW1lbnQgY29udGFpbmluZworY29udGVudGVkaXRh YmxlIGJvZHksIGFuZCBiKSBjb250ZW50IGVkaXRhYmxlIGRpdiBlbGVtZW50LjwvZGl2PgorPGlm cmFtZSBzcmM9Ii4uL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUtaWZyYW1lLWZpeGVkLXNpemUt c3JjLmh0bWwiIG9ubG9hZD0icnVuVGVzdCgpIj48L2lmcmFtZT4KKzxkaXYgaWQ9ImVkaXRhYmxl IiBjb250ZW50ZWRpdGFibGU9InRydWUiIGNsYXNzPSJhaGVtIiBzdHlsZT0iaGVpZ2h0OjE1MHB4 OyBvdmVyZmxvdzphdXRvOyI+PC9kaXY+Cis8ZGl2IGlkPSJyZXN1bHRzIj48L2Rpdj4KKzwvYm9k eT4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9l ZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24tZXhwZWN0ZWQudHh0IGIv TGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWV4 cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zMDhkNjdhNmEyNDdiNjg3NWQxNmViOTg1ZjU3NzhiN2Q2 NDA2NjIxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3Jv bGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dApAQCAtMCwwICsxLDI1IEBACitQ YWdlIHVwL2Rvd24gKG9wdGlvbitwYWdlIHVwL2Rvd24gb24gTWFjKSBzaG91bGQgbW92ZSB0aGUg bW92ZSBjdXJzb3IgYW5kIHNjcm9sbCB0aGUgY29udGVudCBpbiBjb250ZW50ZWRpdGFibGUgZWxl bWVudHMuIFRoaXMgc2FtcGxlIGNvdmVycyBzY3JvbGwgcG9zaXRpb24gdGVzdCBvZiBhKSBpZnJh bWUgZWxlbWVudCBjb250YWluaW5nIGNvbnRlbnRlZGl0YWJsZSBib2R5IGFuZCBiKSBjb250ZW50 IGVkaXRhYmxlIGRpdiBlbGVtZW50LiBFdmVuIHRob3VnaCB0aGUgY3Vyc29yIHdpbGwgbW92ZSBl eGFjdGx5IHRvIHRoZSBzYW1lIGxvY2F0aW9uIG9uIGFsbCBwbGF0Zm9ybXMgKGNvdmVyZWQgYnkg dGVzdCBvcHRpb24tcGFnZS11cC1kb3duLmh0bWwpLCBwbGVhc2Ugbm90ZSB0aGF0IE1hYyB3aWxs IHNjcm9sbCB0aGUgdmlzaWJsZSBhcmVhIGJ5IHBsYWNpbmcgdGhlIGN1cnNvciBwb3NpdGlvbiBp biB0aGUgbWlkZGxlLiBBbGwgb3RoZXIgcGxhdGZvcm1zIHdpbGwgc2Nyb2xsIGJ5IGtlZXBpbmcg dGhlIGN1cnNvciBhbGlnbmVkIHdpdGggdGhlIHRvcCBlZGdlIG9mIHRoZSB2aXNpYmxlIGFyZWEu CisKK2xpbmUgMAorCitsaW5lIDEKKworbGluZSAyCisKK2xpbmUgMworCitsaW5lIDQKKworbGlu ZSA1CisKK2xpbmUgNgorCitsaW5lIDcKKworbGluZSA4CisKK2xpbmUgOQorCitpZnJhbWUgUEFT UworZGl2IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3Jv bGwtdmlld3BvcnQtcGFnZS11cC1kb3duLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0 L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24uaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4xNGI3YWU4ZWFi NzAzYmE5ZWRlNjY4MzVmY2ZjOGExZWI0MmEyNmJkCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLmh0bWwKQEAg LTAsMCArMSw4OSBAQAorPGhlYWQ+Cis8c3R5bGUgdHlwZT0idGV4dC9jc3MiPgorICAuYWhlbSB7 IGZvbnQ6IDIwcHggQWhlbTsgfQorPC9zdHlsZT4KKzxzY3JpcHQ+CisKK2lmICh3aW5kb3cubGF5 b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgp OworCit2YXIgb25NYWNQbGF0Zm9ybSA9IG5hdmlnYXRvci51c2VyQWdlbnQuc2VhcmNoKC9cYk1h YyBPUyBYXGIvKSAhPSAtMTsKKworZnVuY3Rpb24gcnVuVGVzdCgpIHsKKyAgICBydW5GcmFtZVNj cm9sbFRlc3QoKTsKKyAgICBydW5EaXZTY3JvbGxUZXN0KCk7Cit9CisKK2Z1bmN0aW9uIGdlbmVy YXRlQ29udGVudCgpIHsKKyAgICB2YXIgY29udGVudCA9ICIiOworICAgIGZvciAodmFyIGkgPSAw OyBpIDwgMTA7ICsraSkKKyAgICAgICAgY29udGVudCArPSAiPHA+bGluZSAiICsgaSArICI8L3A+ XG4iOworICAgIHJldHVybiBjb250ZW50OworfQorCitmdW5jdGlvbiBydW5GcmFtZVNjcm9sbFRl c3QoKSB7CisgICAgdmFyIGZyYW1lID0gZnJhbWVzWzBdOworICAgIHZhciBkb2MgPSBmcmFtZS5k b2N1bWVudDsKKyAgICB2YXIgYm9keSA9IGRvYy5ib2R5OworICAgIGJvZHkuaW5uZXJIVE1MID0g Z2VuZXJhdGVDb250ZW50KCk7CisgICAgZnJhbWUuZm9jdXMoKTsKKyAgICBmcmFtZS5nZXRTZWxl Y3Rpb24oKS5zZXRQb3NpdGlvbihib2R5LmZpcnN0Q2hpbGQsIDApOworICAgIGlmIChvbk1hY1Bs YXRmb3JtKQorICAgICAgICBvZmZzZXRzID0gWyA1NSwgMTc1IF07CisgICAgZWxzZSAKKyAgICAg ICAgb2Zmc2V0cyA9IFsgMTIwLCAyNDAgXTsKKyAgICBydW5TY3JvbGxpbmdUZXN0KCJpZnJhbWUi LCBmcmFtZSwgb2Zmc2V0cywgZnVuY3Rpb24oKSB7IHJldHVybiBmcmFtZS5wYWdlWU9mZnNldDsg fSk7Cit9CisKK2Z1bmN0aW9uIHJ1bkRpdlNjcm9sbFRlc3QoKSB7CisgICAgdmFyIGVkaXRhYmxl ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2VkaXRhYmxlJyk7CisgICAgZWRpdGFibGUuaW5u ZXJIVE1MID0gZ2VuZXJhdGVDb250ZW50KCk7CisgICAgZWRpdGFibGUuZm9jdXMoKTsKKyAgICB3 aW5kb3cuZ2V0U2VsZWN0aW9uKCkuc2V0UG9zaXRpb24oZWRpdGFibGUsIDApOworICAgIGlmIChv bk1hY1BsYXRmb3JtKQorICAgICAgICBvZmZzZXRzID0gWyA3NSwgMTk1IF07CisgICAgZWxzZSAK KyAgICAgICAgb2Zmc2V0cyA9IFsgMTQwLCAyNjAgXTsKKyAgICBydW5TY3JvbGxpbmdUZXN0KCJk aXYiLCBlZGl0YWJsZSwgb2Zmc2V0cywgZnVuY3Rpb24oKSB7IHJldHVybiBlZGl0YWJsZS5zY3Jv bGxUb3A7IH0pOworfQorCitmdW5jdGlvbiBydW5TY3JvbGxpbmdUZXN0KHRlc3ROYW1lLCBmcmFt ZSwgb2Zmc2V0cywgc2Nyb2xsRnVuY3Rpb24pIHsKKyAgICB2YXIgdG9sZXJhbmNlID0gMDsKKyAg ICB2YXIgbW9kaWZpZXJzID0gb25NYWNQbGF0Zm9ybSA/IFsiYWx0S2V5Il0gOiBbXTsKKyAgICAK KyAgICBpZiAoIXdpbmRvdy5ldmVudFNlbmRlcikKKyAgICAgICAgcmV0dXJuOworCisgICAgZXZl bnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBtb2RpZmllcnMpOworICAgIGlmIChNYXRoLmFi cyhzY3JvbGxGdW5jdGlvbigpIC0gb2Zmc2V0c1swXSkgPiB0b2xlcmFuY2UpIHsKKyAgICAgICAg dGhyb3cgIkZyYW1lIHZpZXdwb3J0IHNob3VsZCBiZSBhcm91bmQgIiArIG9mZnNldHNbMF0gKwor ICAgICAgICAgICAgInB4ICwgbm90IGF0ICIgKyBzY3JvbGxGdW5jdGlvbigpOworICAgIH0KKwor ICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VEb3duIiwgbW9kaWZpZXJzKTsKKyAgICBpZiAo TWF0aC5hYnMoc2Nyb2xsRnVuY3Rpb24oKSAtIG9mZnNldHNbMV0pID4gdG9sZXJhbmNlKSB7Cisg ICAgICAgIHRocm93ICJGcmFtZSB2aWV3cG9ydCBzaG91bGQgYmUgYXJvdW5kICIgKyBvZmZzZXRz WzFdICsKKyAgICAgICAgICAgICJweCAsIG5vdCAiICsgc2Nyb2xsRnVuY3Rpb24oKTsKKyAgICB9 CisKKyAgICBldmVudFNlbmRlci5rZXlEb3duKCJwYWdlVXAiLCBtb2RpZmllcnMpOworICAgIGlm IChNYXRoLmFicyhzY3JvbGxGdW5jdGlvbigpIC0gb2Zmc2V0c1swXSkgPiB0b2xlcmFuY2UpIHsK KyAgICAgICAgdGhyb3cgIkZyYW1lIHZpZXdwb3J0IHNob3VsZCBiZSBhcm91bmQgIiArIG9mZnNl dHNbMF0gKworICAgICAgICAgICAgInB4ICwgbm90IGF0ICIgKyBzY3JvbGxGdW5jdGlvbigpOwor ICAgIH0KKworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHRzIikuaW5uZXJIVE1M ICs9IHRlc3ROYW1lICsgIiBQQVNTPGJyLz4iOworfQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9k eT4KKzxkaXY+UGFnZSB1cC9kb3duIChvcHRpb24rcGFnZSB1cC9kb3duIG9uIE1hYykgc2hvdWxk IG1vdmUgdGhlIG1vdmUgY3Vyc29yIGFuZCBzY3JvbGwgdGhlIGNvbnRlbnQKK2luIGNvbnRlbnRl ZGl0YWJsZSBlbGVtZW50cy4gVGhpcyBzYW1wbGUgY292ZXJzIHNjcm9sbCBwb3NpdGlvbiB0ZXN0 IG9mIGEpIGlmcmFtZSBlbGVtZW50IGNvbnRhaW5pbmcKK2NvbnRlbnRlZGl0YWJsZSBib2R5IGFu ZCBiKSBjb250ZW50IGVkaXRhYmxlIGRpdiBlbGVtZW50LiBFdmVuIHRob3VnaCB0aGUgY3Vyc29y IHdpbGwgbW92ZSBleGFjdGx5IHRvCit0aGUgc2FtZSBsb2NhdGlvbiBvbiBhbGwgcGxhdGZvcm1z IChjb3ZlcmVkIGJ5IHRlc3Qgb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sKSwgcGxlYXNlIG5vdGUg dGhhdCBNYWMgd2lsbAorc2Nyb2xsIHRoZSB2aXNpYmxlIGFyZWEgYnkgcGxhY2luZyB0aGUgY3Vy c29yIHBvc2l0aW9uIGluIHRoZSBtaWRkbGUuIEFsbCBvdGhlciBwbGF0Zm9ybXMgd2lsbCBzY3Jv bGwgYnkKK2tlZXBpbmcgdGhlIGN1cnNvciBhbGlnbmVkIHdpdGggdGhlIHRvcCBlZGdlIG9mIHRo ZSB2aXNpYmxlIGFyZWEuIDwvZGl2PgorPGlmcmFtZSBzcmM9Ii4uL3Jlc291cmNlcy9jb250ZW50 ZWRpdGFibGUtaWZyYW1lLWZpeGVkLXNpemUtc3JjLmh0bWwiIG9ubG9hZD0icnVuVGVzdCgpIiBz dHlsZT0iaGVpZ2h0OjE1MHB4OyBwYWRkaW5nOiAwcHg7Ij48L2lmcmFtZT4KKzxkaXYgaWQ9ImVk aXRhYmxlIiBjb250ZW50ZWRpdGFibGU9InRydWUiIGNsYXNzPSJhaGVtIiBzdHlsZT0iaGVpZ2h0 OjE1MHB4OyBvdmVyZmxvdzphdXRvOyBwYWRkaW5nOiAwcHg7IG1hcmdpbjogMHB4OyI+PC9kaXY+ Cis8ZGl2IGlkPSJyZXN1bHRzIj48L2Rpdj4KKzwvYm9keT4KXCBObyBuZXdsaW5lIGF0IGVuZCBv ZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3Jlc291cmNlcy9jb250ZW50 ZWRpdGFibGUtaWZyYW1lLWZpeGVkLXNpemUtc3JjLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUtaWZyYW1lLWZpeGVkLXNpemUtc3JjLmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZDJkNzZhMDliZjQ3MTdmOTIwNzdkNzI2ODgwYWUxNGQyOTY1NTQ0ZAotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvcmVzb3VyY2VzL2NvbnRlbnRlZGl0YWJs ZS1pZnJhbWUtZml4ZWQtc2l6ZS1zcmMuaHRtbApAQCAtMCwwICsxLDYgQEAKKzxzdHlsZSB0eXBl PSJ0ZXh0L2NzcyI+CisgIC5haGVtIHsgZm9udDogMjBweCBBaGVtOyB9Cis8L3N0eWxlPgorPGJv ZHkgYmdjb2xvcj0ibGlnaHR5ZWxsb3ciIGNvbnRlbnRlZGl0YWJsZSBjbGFzcz0iYWhlbSIgc3R5 bGU9InBhZGRpbmc6IDBweDsgbWFyZ2luOiAwcHg7Ij4KKworPC9ib2R5PgpcIE5vIG5ld2xpbmUg YXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9lZGl0 aW5nL3NlbGVjdGlvbi8yNTIyOC1leHBlY3RlZC5jaGVja3N1bSBiL0xheW91dFRlc3RzL3BsYXRm b3JtL21hYy9lZGl0aW5nL3NlbGVjdGlvbi8yNTIyOC1leHBlY3RlZC5jaGVja3N1bQppbmRleCAz MjU1MGYwNDE5OTFjYWQxNDYxZTAxN2EyN2NkYzIxMTlmZmIxZDg0Li45YWJiMzcxMDQ0NDNiNjhl ODExZjk1YTZlZGViNjQ1ZDVhZmQ4YjhlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9tYWMvZWRpdGluZy9zZWxlY3Rpb24vMjUyMjgtZXhwZWN0ZWQuY2hlY2tzdW0KKysrIGIvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vbWFjL2VkaXRpbmcvc2VsZWN0aW9uLzI1MjI4LWV4cGVjdGVkLmNo ZWNrc3VtCkBAIC0xICsxIEBACi1kNGFkMzYzZTU5ZDIyNjU4OGFkNGNmZjhhMWEzNTQ5ZApcIE5v IG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKKzA5ZTU1NmFlNGNjZDY2NDdhYjA0NjljNTkyMzk4MWU0 ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxh dGZvcm0vbWFjL2VkaXRpbmcvc2VsZWN0aW9uLzI1MjI4LWV4cGVjdGVkLnBuZyBiL0xheW91dFRl c3RzL3BsYXRmb3JtL21hYy9lZGl0aW5nL3NlbGVjdGlvbi8yNTIyOC1leHBlY3RlZC5wbmcKaW5k ZXggM2EyY2MyZTAzNzBjYTkwNTAxNGJlMGYxOGIyMTY5OGY5NjNhNzZkMy4uMjdhZDgyNmI3NjYz OTMyMWQ1YjI5ZTAyNGM3NzFhZWJhNmY4YWQxOSAxMDA2NDQKR0lUIGJpbmFyeSBwYXRjaApsaXRl cmFsIDQ3Nzg0CnpjbVpefldtc0Vudz4xaS1jIUJvOGl4bnlxKlchZDBETngqazFga3E3YUNmSUBE YUVhWnlTb017M0dOUVQtNmVxbAp6Q3c8PCUmKU1odF9McmFRJEd2alRJbzdsPj00VytQY0BtPGhM fDlsQEIjSHtNbnBqdmsmIzxyXz1uPiN5b317fTYKeko3T00pK3NlcU9FNlRfYFErSVotdmkkX2Mh dCVycGA9KD93cC12SGdBSHg9MDZJQFZCXj0oQnV5NT1RZEJ1YWhXCnp3c3REUGlSTmE2PCZVNj9e LX5vQXpCRjI8TlFITGBEMSNfRXJwUmRhUnB9O20kNlZxQj17LUEqaGZjWEhrPCFBTgp6ejR4eVVs LVlxaUZIcGB5MG1GT1lTVU99e2FUYW9kclpZcCR7YmRGMitzQT0qbykyXmktbzB0aTRCeDZAe3Ba Rm4KejQreipRLT5GeXM0WCNxYGprO2grTWJfOX4rJHpQSkFNSXNkVVQzNE95JlQ/ZmxSdD1oelpk blghfCl7O1VXQEsmCnplQGtOaVd+OE9YPiFlclc+K2tEWFhXekJHR2ZwUXRGXndHVzUocTMzYHNm X0sjOzxDTCtuOCUoMl9EZD5nNTt9WQp6Tlc0Ni05ajNfKHprVG9qTX1NUkBESVVBakU+TW4jcVlq JmxyakB3RnpAK2xjMVVBUF9QJGRgVHtQMXJucmQ7PDAKel9AfitaMig2LURCfDk+Tz1Qcl5KJGZ2 dzZ3YzZLaSNvRm5PZ1krZTlYPCYrbHBYRmRQN3t7eyQ7aDh+WHpvPGNFCnpOVmN5SXYxNmprelI4 MWJabWVtazJYdV5CYTMtQTNQcnFCXnZ1dz5tOTU7SHtoSCR0NGh+fFI/I0peMW8/T25UPAp6WDMy QlpLO35eQTZQbjRuQ35oXkVGeEd7aTNjP21NPzJiY3MyRTlKRDYrVUZBe2RYKXxxNGhxPU5lUWsr aVBmP0sKel5WZVVndllQdjIqTGBTUilQeCZAcm5QJCkkTFQ3bk1oODV1OUA2aHJteD5JX2VQblVG Ryh9XmpvbHM4cCVXcGAkCnppMStMWDttPm9CTn1meDNIYShzI2tzWW41IWdXPWJNWjFmalJSb3BA JFN8RGZgeVd0ITx2JFlwY3FvIzVLVWlKJgp6JEF2eHw3bkB3QE5KI0wtWHhRdVlsQDIqbFQ1bn1g V3JKTGtrJmopX2xYaUJsN3FEaGRfTkw9QkFIYT18PmkzUkMKemV0KUspUEJEVlgmdXk7N1ohXy1S dy0rdnR3aV80bjJ4PzBfS2h6a2ZYLTgpe2Z2eG1vVzlUTWN1ZmZ4VWskQT1TCnpgUDAoTFEpYjVS KVF0NilEYXlEbE9iVTU/MWsrQFVWJD5wPEQxSW9iJnsjXiQqNnoweylGRUc/ZU8rZCQoaXYtYwp6 aDUmYGQ+KXlaTzd9ODRvb3JIYD8/Q3pfSk9+PE49a0puP3JhNyk8ekRBTiV4VD5LY19ncD1OK1dV cG03c29IaisKemVVOypJP2hKZ1RTX01nJiUlMkh+OVh8KUVIdGAhaXlyPVQjTC1WKjE4YUN3cD1u dF56OFUhbVZBPiZwcW5MSEZ3CnpKWktXXkZpSHwlQzI/XnF0WT10P3ZoVEQjdkc9bkc3cCR1JWsh S1JhcDlXJlVgeVhqKks1YFRoKkc/Rkc8QnJsUwp6RHc+RUduXkdPIXdKUVpfQz5jYDc/YzVaQktq bFdQJUMramk/TXl4dHlOMExpd3VrZDYtRUMjMHhvcT89eXR1a2MKei10cjMxN35aO3E1MmBxMGVx Uz5aR2MoV2lvYnNHVmFHdyRoUXJOczZRVUN0cXR4UW4oZ2ExNHpQeldrNlo8fHhqCno1fVM7bjZD UF4wbUArKFUlK0skT2RITXp4TCZNa2doellRT3g/WSVgdyQ0K19JVUZNYClfYjI9QDs/dndBMUI1 PQp6ZlFGTEBERGt3YD12JD9NbF5xPCl5fCVKRTJITmokOVIkMmlFdmVyaCh9KzQtR0tVc21vbzs0 MHFgJHxxTylkQ2UKemsyMFdtYH5CX2xOYDY7d0R4YnZ3b2tJKWE7Uz18X2t1dkhDZDJlQHhWezd1 YWNgRWYqdW9+TFVXZH05IzxAQ2FGCno+an4qUiNmQVU+KSZCRihJeDx5KTVQcSN6PmxLVXdSdWpB QGEkbU9oYzY2Ql5LQjhvUSUheCNKPUlgcTYyT2V2Zwp6Sio0Rjl4XyRVS0coSkVyJkZiIUdTITxE dSs0NEdPR2czazdxd3hRMHVLI2h7QlBYS3NpeTthQzZeKzJjRmBhOz4KekpPMllfKzQhJCghPk4y d2JvPjMpe1hxTk8xeUI5akpIM0R9QTg7d01ad1IwNWAjJHJQNVZveUNfMGVlIVdONzZqCnp7JEpl RUdXP3A/K2NIUHJidHlxfXVhUUtZMSMwT2IheXB8Jl5oXyZIblU5PVIpJTV7RUZrVWt+ejUxM0Iw alcrJgp6MGFqTld7c1YkOGRgSi1BXjhzSSV0My17M282WWs3KXdXbU14T2J2bj4wVW0mdUJfQXA7 PTx6M3tQMlFndnhxMU8Kem4xJl48R1FFeUZAZHRrXkNKc3A1cXRyYWA5QF47PGI1O2JSUmA4ezRy aUAldnN7Z1A9aShHSnFDaXs9IVNfMitTCnomIUZCU148M0skdGVqQTklS3JFRms+TUkmWiY5Mylw PkNKa2R6dk9vc3VCSk44cytJaV9VV2p6b2NtQXk5eWQ5SQp6bDRfVWZUZCNQYGoyWjVuMWYwMW9z QXc7dl50VUo1KHxkQjc3OX4qWWlCXmQhTFZPJmhIREJsNz82M3dwdHs0c2IKelItNlNMUzF6I3B4 filwemBmb0o8NUJIR1pGNn5qSUJKO2QldlVYSWwtVD8/bXY/PiNXPHxmX2hDMlMkeW1ZSDdlCnp5 ST1EPm1KbjleNjMrKSkmSz9PdjwrKG9QI2F1X0NadFVWeVpITW4/bTBNNVY9U1JLcU08ZWdWcFll JH49WWlaPgp6JXglLUp7P3srNTFeK2NLe0hJUllze25zd2BEWEhjUi1jNDgqbEUxRjxGeD5BRDAp RVpoKE1zNi1YTz1pPzF8TjMKekxhUDw+Zm44ZXRKeiR9UV9rYFEhe2BSVWxuKXYxKmFHbDZAbUZ8 RTBOXk0/dVY0cTF6Ti1qdVRsO2YlbDJTVyFXCnomSVR3WEhqXnlxKkVWVXZvM3hVITBtJi1gZnNZ TlQrWUkkPlVJJXk3MUl6YiE5Iz93QGZ+V0BVNk5pOHNMeUc8VAp6K3ZXU1R7MllJPXImOGFaOH5k WmNYRSkzRE9EJmdrYn50Z2JUeXNiOXBpVU1xeHVAJUpWJnxwcVBVOExUZTtfKTQKej4odHdQRElQ YTtYYSMybitAV2t2V0QxdlUjZTJSbWVEcUVKPHlYUU9hc3JxZDhsaClBMGRiYipicG1oNSlnKnAm Cno4ciklRyVJPGtedjg2WDZqTV8+bThKLWlKS2dmJV9CZmpKWUNCZ09ZUzxmOXlATlUxb29LR3Io YiZsVE85bz82Rwp6dDVmfCs/PVRzcGxicjBweWxta1hhLXVSLTF4SjQ9R2klXmZ0NnlAbkxxR2le TXNqZ14yJU9KZHNTXk8/dVN+XlMKemx6NSV2SFhpdCVEXncjNHFTRlRmbTRXKEAmeV88REZpOyU/ Wj5JYWlxKilLeDJwbCF3NHgpKjx0YT4+YyE8JTFiCnowU3h1QV5nbVZoNDVZTjN6ZFdsZ19aIVNJ SEd3cDQ0Q3VDQj5zMFVMV2kkbkl3O3wyWE96dG1DIWQ9X1o4JDc/PAp6a087Qj5vNE9fTUpzWSVv dGpPKjhfQElPVDhKKTE2T0pNa3J1PSppJkoySUBBPHY4YWFtNGw7V3NXRWc9ellPdWUKem5PX0Vl b00jIXdsQkQtTj9oR2YoNjY9ej5uSHxROTF4Q3J8LXh9U1J4Sn5NODt4SGl0TUszMF9lI3cjTGBj djBzCnojSmVXKGIqbjhPWXwkU3lnWngyQUd4N1Qhd0UrR1l5ODAjV1ZwSkQobzJtUHBFdnQxUkx4 WSg/SjB+Zkh8R292Mgp6Zlh7d3EjSiQqIUAzUC1qVENES1czfUByfCpFclV6Yz9ZU2gkYGdUWCQx Y0psaXN6ZCZDPGNFZExlNzt0ZmNxeyEKejBSMFBmY2gmOXlYK1lxKVQrVWkmZlpTKCRvfFVaVihY NUcyRGhraF91Y3pEWkNqQkRGI1BAbDFtb0tKR21WSX0lCnphLTVUR29HO0xyWWNpJE8oSmlsMElC WG44XipuZDwtUVkwY3FrfWEzNUl2fEZBSkRoWDB0Mm9aaHRweig9ND0hTwp6KmAlQW81cWheeEN2 QXBuKHtDcWlFOVAlNyhPKVJUcHs8ZWI3dHFBZD9GP2hmQCVfZkY+PigtNG15WWpCTl58PFkKemMr R18lcFdLWX0kRyFhK1p9cFRzd0lIM1pyRSZHe244bT07SFRqR3UmfjxjUTF3aTJBPypofTw/RC1m KmkqPSgmCnpLNFJgMHpBS2R1Ml85PjRxTns7ITtlKX5XN1czaTgzKjBVOFdJS1khJm0mUGFuIW19 YjRTO3g7RWEqTHhgPytrTgp6ISR4ay1MPkcreGBseUBgQXRpWitgbXd8Jik9LXc3YE10N2M/aE5q dj8+YVA5T19xaCNrTFE5PzY0OGFgUDU7enkKenxCTj1FYiF+bmlqKDQ4dkdFflhgZ1hnRDxKPjho X0JrRGwwPDdXZVEoLTtGaF97emxpJGJkNF5iJSQ5dUFDcHN1Cnp7a08hSUtQTkxASGJkJUVDPHMz diYkQV9TX2dQb15FXyZ6dUB+ZW0wPDNlVkpzQF9gV18rOUdiPzxWT1FTMn5OQQp6Zj9JbVNZIXtW fCRvIytkWEk7SXpNUEJjZiYrYFBKO0ZwS1pNfEQrMTRndSZqcmU9cX05fSRjT21ZRVY+UllgSzMK ekheKSNpPlVRQkpQaVc4OT5ERFNYT0s/TEhYIW1EfTQ1P14kUkVKP2BrTWkjJU1PblVOPkw+T1Jr NnlMPXBHMkZ1CnozaEpKdC11SEt6amBtJnlIc0w/UkQ2M058d18hKW5sTld1NE4hWV81VUkqdTlJ a2NobitpbmkrZFJBNTJfd3pISQp6cWRAK3NqaGp8RyoyaCExbHpQa3tzM1FsajtveH1iTmlpZ0Fj ZntANHtDdkokPFFtaTZGfWBwKCVCNEklK1p6X2cKekNeOzh2O2xDOCpVblVOeTU2djA0Um9adyFI bldqcDB2VXxib3MkZVd7Vmo+Z09XOGt9Wm5xM0BvUEBpRnRtVnx0CnpxeFdeMVp2cz9uQG8lVCpl alYwY0JKb1JaPEU4WTMtLUVuJmFfZGU+fERleD9uSkFPJT0wMCtxam1HOz1ecE1kQgp6bGBQOVdI X084eVlKTGAqYlhtIS1PSU1EREs+IUhROCFUUylPPVk5O1p7a1BaLT9aUGAlXlojcVlnPC11Q3sz TTsKenZsM2M0Wio4YWQ4X1JDKDc3QC00TiFfRSoxfkc7JURfPHkwe3QmWGRRNDtaYCV9aGkmcnxV VW96VDt1Ym5kPFhJCnoyKzMwXjNINiR5VkN4eyQ0NjtUczUrKj4pJTVjP0J3MTB8U01pdHNeRFIr Q2RLQyRjM0lPYSRjOV8pdyRVP3dAPQp6RFROMWp1d0pSd3gqZEByWXkzJU48b0hoYjVeJnNzISVk JigjPExNbSQoMmRLRj1YKFdTUX18XjZ7TkZNSjhlODQKekxvM2pgVXApLTQzWm4kX21Md05oTTBg Q3RPdGE0QlRrOWMkJHBjUUdqTTY1OWBKNVdqamhAR05MSzFuVGhVYUhQCno7XmxhUXtCVFlTV1Vg eUhhSEFHbDxDKj4lMCl3QXUwZWkpcVVPcXN6bXtNelRnWClVMFA8RlJ4Rl9FZy0oPmQyXgp6a2NY VDJKWnFOZypFSj1uIU1tRnkyY1dTUl8rQUctNDBmfXspbC08fVRfNzRAX2t3TnlxWFVuTld2Z145 P3NeJSgKeiZ7UXxLMWFeeEA3Kzx6TWw0cjwzZGtzZWImWTkwbjtzWHtJZTIhWWRyY0hPOyFobVZ9 S0tDYl47PjshXzBgNytaCnowY0IzMFN4dTNlWVJWUE5leTNHKD5ROElmREZkSFhIJGZ4SDJ5KEdh Y1BJb3tzTCFwIWBZUWRrZjAkSlkpejNuaAp6PXZGdEdWKF5ob25ELUErWDAlTkZrLVhHKGcxJWo4 WkIkTUJePDtVPmVzO3NWTF45bnBAdntNZUw5WTQqXlJtWHgKenJgN1kyVz9GcmEoeyZDJHk8XzBL S2djNVgmR2stWWF3bGhxTWx2XyZlSzBYTXVSTWQ+d3toI2NMeXZZbE9TIT85CnpAM3Q9SW0rJEp7 V20jc30qRXRRWmdzc1crY1FmYiZ7KXp8ODlWNnUzcDFEcEN4O0BscTZSYiklUUtzbH1lVG9NTgp6 O2k3SS13fEBBWG89SHBGdkVjYig2aHwyXjJMMkk/P212OCgxSilOWXJFcU0/diRSMj5gR0hURSUo dk9GN0FMQGgKenU+MHh7WG1Ec2dzSm1UeTU/TzFuVTsrc0MmbHErOE16fDB7RCkjNDNRSDtMJT1h LXFARE9DVTFrIWBDKlRybko1CnpVWCopTWhCcXF+KGA0aUZwRV9QbD5OZE59dys4aU42KV9RVylx SyY/cFNUTnIrTDxxUHlKT0NnIW5ILUNoOWVHUwp6Wjh5cXBCcH5xYSV1b2hFRjxGTXZRRCZNYktv YE4rb343djtiMypIeD1WJXZwWHRvSU47K3ltTWIpLVNYe3prYkAKeiZyfGZJbzFGTllyWGNCam5z TmQyNTN5KlVvIXBlbk0laW1LZUZPYmxmI3ZJfGBofHZ5dDBmPENySSp8bUp5SGArCnoyJmQmckp0 KGdCdURicUxOYFpYLT5lVlFZYlZCbDFIc0FLPjNlbG9TcXNYd1J3RVllYGVVTTlWe0MqQTE/eTkm QQp6T2VGTitkWlpSNiNwV00tdXtZenZrX19saEkqdD1Sdj8rTjAoUDE2UlM5ZVY7QDN4WFYpe0Vx KVJ9KSNJXzIxSSsKenFxPXpPZEQ/K1A9RWAwfUZ6RE9mRiEzbVloPDkxNiV8eks3UFFQc0hjSlBn SVk2RWt8PilZZ2ZuN1Z8ZmY2TmVICnpIYkh4a25UVCpvV1VSPnc0UENfRTFmTVd6eEdRY0I0YXNo dU42OF9kS2ApRjhUM0pGT1lIQCpGaSpLJStqYU03eAp6a2sydDxga3VMZnFfPmwyPk1ON255OT9x QkpkUylFZTUkU0hraSFgamlOendkNmtUOCV7YHJ8RWZoITlhV3RuUisKeipzNl8lZ3pOYFZHRT9K alFMKHtqTzckbUBxS3NpKHpNUEd0cVdhb2IjcFdjIU0manNoVFFDZEFHNm5rJj81JU89CnpFeHRa aUhOVG1BeCRJYyYma1hCWFpWUnxSZkVOZmNzQnZjTyRUUGo+KSFhY2xkJVh3MDEzLUgwVT0oS2sj X3FHPQp6TGs0OHpRZmJvWFIke25uRVkhTW81P0RRTD57RlZRKUZEa0c5clVNQGZueTgyWihxTi1Z MFRpWW8mYkRSezhUYzcKekMoKjRMIyRLJHFsWCtSemR7fWo9UTlsdmt5JUtxKXYpcUJ9TSZNUTtR e2ZsO0h5eTZ2YSEzYkx3JVZ3UzRLczxtCno/fCkpPEQ2RCV+dCt2ZElVWEE4eUQhbGB6ZlRteV9y Ym1yaWoydlF7c15IKzchYj5ELUh+X01OQlVqYitgU0hBMwp6WSF7aEZCOUtqamMtPjBVY2E9UDZK SFAwNDs9YE1aQF88JV9TQlgzdiFKbW9xSjx9Z0hpdjNgSnstNyU0Qn5Cc08KelAjWkxKPGpHVyps LUp7cylMd2o/VEJqOGkjfEQ1U0BiMjhVUmopSlFxaXk0VVdQbCY+RTModG03ZG1gfitnKXI9CnpR KTtXPmZfdzJUSl9vZmEjN1ZpfWZ5ZGFMSnU9cTI3aXEpM3k8cXtAPDJoblVAKUx9M3w2YCtWOGFW Z35FYjhxNwp6UFpTXmloM2YzZiR8X0dWKm07KTY3XmYwbD0tSTJZJWdpSktNezx4ZXMyQyY5WW85 IVMtQHNTa3hnJEJUa3dlaioKemNrTVJvQCEoPTxyaFpWUyhvPVNsPGMpWiolanwzPXwwdnQ0ciRV ayVuJHxrZ09rPWNqVj1OQ2ojLXR7XzFpUjF8Cnp7YmQycEFHayVmZVJsakxDJklOIVFsK3I5bntT YVRCWGx8cShHUkBYKTB9IT08JiVRRyEtM304KFdzNiNtUGx5Nwp6aEJ8eV84WEExNXh1Kk14ZXJT fWhnZERMVHZPV0dyRT0yNGd0SF82eiVqRml7bW10UkhLM1o+UzF+djlYZ2U3fUQKekp1e3E1czZI LWpWbjY+ZCR+dWt6bilNQiFaJSpVSFpaQFNVMSV9SmB3d00wdzJtSWpPbVh5Nig8SWQ2TEx5Yjxj CnopQVc+c2E4YGdySk5pdWJmYnNzI0I7JT5MVUhsRGBvdG9kazlNZiZUbV5Wej8lWi14TEhXVVZk YkplQDxAfEFRdQp6bmtzVkBSJEw0Z3JLfXY5R0FtWWpocXkrcmJeUGpXcjAmZjVwdSZJUlFMSX4l VHskPUdFKXxpV0tSRGN9UDFFVDUKelp1QjtJKzlhVExlKUoxcm82bTYzQmcxWm0hJXozczsrO2Zz MWRsY2BKeiZjYDs+JXxiRFZrR2shRFZFeEZ3eHxqCnppSEJjYHZ7WVl9THoyRU1lcUQ9flRHRSRY e1owfExjVVRKdnRwdXpAQEhEUmZRX3JHQ1p7Tlg5Uk9+Kis8fmNjUgp6IylwNlg8JnxxPy1LNDkz VEZXQEV4WnQ7KmNZM0lmVylMcnNVSGBNK2RWPjdkZ0kpdj1QLVV7UkQxSkEqaXhtMk0KemtFKFJ7 bkI+NGBUdCEkXkVNeSN5P3Z0dFBHcT9IQ1ArTXtMVk1uJVhjZnhmWjlhYUArOEkxcEBSYWV4e3Jp JGVxCnpwV0t9QU5lbnQmQnNTfXs7Xk8hKT16UHp4SXxBQ3ZKa3pRPHZSbj5mck5RNVJFPCEzTHQt QzB2RmUpLU5XRlJhbQp6Vjt2e0ROa2pjOzlRSEdPekxGdmMrNUBGQ3s4U2xjPCN1YjIzSH0wPUlt KHlPSFA7PGNedndsa15sTWxWcU8rOFkKeiFqUjFRb2wlSzRDVjA2bVkqanZ2ZSNhZTBvaUtkYXwy VHhuPUNzU1lDR1lNaDlNcDJnV1ByJF9gN2UwWmxEYj5MCnorVXg7dyo4fXpPSTlLfnQpa1ZyVDZ+ JCVUSSZGQ3hRYnxJNkRJRnN4RlY7KHFhKn0jdmdzdTRVc15QV0IpI3pyZwp6a1VCRHNEVXE9YXFo PkloWj5mPyMtS1oyfGFwdWF6dFEkPnsxJjNLMktLOTRDYnhkbE17ZStIK2deRyRMUGpVJjkKemV3 RSl6fE1AUUtRZ3lPNUNSeWg/V3AjVHghRmZCUz5kUzVrVk8yJjZhNyNmcSUkVihae3JXQSRIP0g9 Vk5ra2NkCnpONW8qRis8VHFIQnwtMV5fcm1lZypXZSRpbFhpS3tJWnYoP0dxO1UpWT5CcnlKQlAm RXZENVNmYyNFRV51QXpgNAp6ZF5DY3lBS3ZUTzxeal8zNHYqe3JWcDYtSD9iUT5EWEsjbTdLWU5r cGJeWGNSR2pZQ3VvS288ZWVaPkw0eW0yI34KemBeaGVrTkdqSkcoX25tWk1fMTEkdUx7VHdLZTRl a3wwN3BaUjlQc2RfVC02SVY0YnJfTyhkQEhMOyNGbDFmaExECnpzYGwlQTRLITJOYTwmSExidCtJ U1NiSyFla2E1cl9iYGJRR0VJNmkjY2k7dnhUMTEqJTtRZ21sLUAxdTVeS3AlMwp6WldtJEU5UDND QFo/NU91JVA7TGxTJnQjPSg7Nz03elFfXjRxPiVwezVHQ0djO1YtX2l5fWg9M3JjYiVCSkYtfnIK enVgNFFucXJGNUFMYnYkWnhOP3FPPkN0X3xZMlohYChVfV51PzNOWHYzUTQ2ZUl2Y09AZ20jNTRa eXs5ZEBpe3F1CnoxVjZuJlpCKypIOzRoSXBoP2s8QmEtS3xDYlljeXhDWktGR3kzPj5STkt0QHdC S2EyaUM4UjJNM1NweCpeeTZEMgp6NUdsWCZQJEl7fjx5SCk+eDt+YklmRDNEcFVlbkYkMig5KFMz b3FYK1RAZmpMYDxxdWNrXmkqI0sxSF9aPFBLbCYKejFjak9BQ2NrbiFBJm9XPiNlXnVMPCNNSCZf Y30wajV3TCZNJn5HdzBNK2wtRlhMYFlpTWFhTFc3dmE5UXl8eUxBCnowbiFwSTcrLTJeaWx8WGVE KXdaTGQpa2A8UXE4e2ByV0k7aUdncFN7fDVeMmsrazRwaGRZV2hjMiZlSHhiU2pSdAp6NSZKcldj P2BlMHh6TzJBakUtPFQ0Xz1MQ1p1bCgwNSokZ3VlMG52K0lqRm05UF5LPldtT3lJJlEjeCR7dWwh JGMKemRabzM8KlpgYClzJncpdGNAMEc3dWNgKWVQMXpydj04aCRHUEleQE5aTXpuWjkhITc2WDN+ MjImdVdwX0JLRkc0Cnp0MVZNc1ktYW9yMjMkUEswTzxyNjZoQkpHPkQ3KHZobGRTU3BWQGhOYjdS KD9uX1A5WXMrcExFbmteTXRxPVlOUgp6c2RnM0ReJlI8TmlGPnJZTHhoXzdtSFglMD5RSmk5Zyl7 SURYcFJGaG9uaEkwbil3Qk9yPnV1bWhkfCVCMHJkcloKend8bj1FTTdKdFMpMUBmMlVCPHRESHh0 KiV7YmRyKi1aMSYyblhHeCZoNHcocCVmPEVOJSR5JWNfVzk9TXFMR3d5CnpGbDFRMWRTNXZ1JnJC fCFpSFM2YT1SQj5Tc1deYkl1anMtdjRaU01NJmBJeXF7cDlfR2BaZD5CIT1JSVNtdythagp6R0wx JWJBdTxRTyZVKUJGPkdfTTVZJCZzUmJ3QmUrKjZta0wjWVVnbypNUXkySitZbHhXPXcjbFpxaHNI Y19HfHYKemJzbkkrSVVTVnBBIUFLeEpIS1Voe09jQ0dwVX1Xc0w+ZHxhZCNFR0RGbm99bGR1O0J1 QlRMSUJXYH1hUzY/NklRCnpoLVJtWTVTUXojVkVpeW1MOSR5VGU3clh5c1orTEVCPVMrQFQ9WjtV UiZ7OUgqKHdKMjk1U2l8QUJyOVImMCpJIQp6VmBQQUVBNF9vfEk7QERHS2o5cjs3cmJeOSU+WEVx e3Y+MDFSc1M3TWA/d05qKlVlSSUjPCNudXhlU1cpemdpNUcKekcpdWAhNShSI21kNzI/O2AmQ1Fz R3hQVWR7ZXRIVW9APXAoeWhWOShGbW56dWRAWnh9Rn00TU1yYitleyQzS2I7CnpNWTFiempWU3dH JGREQ28oWD41Y29EYk1mTU1oTSFOcDAkTnRfUU5zWFpaVCtYVD56O3JXbnR1ZH5AUnZPZks3Ugp6 OW4pUndzJVl5PXNlWE1KRDgkakdHYXVyKjRgN3g+YlhFQSFxVFJqJWJ4eVA/eHtZZF5yUVJSQ0Z6 dClhQkdSciMKekdaYXYkYWQwbTQ2cTckLT1wc0YpamRBOWw1LUw2UWkwYlFkRkgoeyhSbmwxfjhV ckR3UFQpNG5nPjhNaU92alRRCno0P1J6dUVacGMpZXBWX3lNa05ZSjUyPyQmbT5iITg1X1JpKlRj ZypGXk0wU3pTfWJhUC19fjY8bEkrYEYmPz9KbAp6MzRaVkcydlVKTmZIVjZES2hjPmxMNyQ9O04t RXdVN0lxK0dLJCNsVnkoRSo1JSFqbT5DMSY/aWdjSkVqR3xAQEMKeip5M0gtNkZiKGxiQDVkKyVW SmNrRjwhNl9jOEFKUWdEbG1feEx4UzZkVVk2PlY1WjJVfE1LZE1oXyt2dWMqPTJLCnpgSGFXe0l8 SjA4WVU8czhxSWEzJG0zQ3VQQG9FOHItXjYxSnh3JT8yaEFEZmlzeXRLWmF4NHlMTFoqfGgyeHcy cQp6cH1HUUdDakMlP0MoX34zcm9tViZyeDgxZTROdE5zNVJ5T3shVXhqbSYqWkdoUjtIUlVmT042 MHd2U0pvM1VWcjwKemRjT1o/eTR+SiktWFcmZU9BQFYxbyNCclZVRlZINm9KRmghVj9wS2RfdWcl KjxZVEheYnhASWs1Uj12TXE8NXdCCnpVfGBIcmojd1I8N0EtdCROcSFZb0QlIXIzdUlqZ194PUNk S2RIdm9xbXxJIXNiQDlOQ0pDb0QpYHA+JVh4cmUwaAp6KS1VSEJKVmJ1fUIyd3xpZWdNfitVX3ol Si14UjVuMjN8JEg/ZiNnYWxlMjkhZXxgU2FmZCZzUkk5O3FuY1Z1JmYKellaOV84NkN5UkZ5VChT YEVQRmM1V3NyTXBYJFR9bWlCVWY4ITcmRE5CPFh4YGU8dzYhaVgrUz88MkZKcTtafER9CnpsVFFn T1F0aj4odUF5dUdUbVZDST9EKTZpN3wjZCs0KnZAaU5+MyV8KTtmO0F7Qj9Gej1oKFVCWnJwRk8p cUppNgp6JCEmWm1qNzdBMXkkSWgzcjJwaSpBZWgoUjMpY3x+PXpPNn15ekp5SmVXPmxJRlQjWChV dll9KD9+RU1kR09GO0AKenhZV3wmNVQpTjZUSTBKTGFuTlYoVz9efGlhRmk7YCZQOTlHcHN2SjR0 bSgpZSEwbkhqdWV3WClNci1YTmQ3c3l5CnpjQn1VSCQ4PGZKVC09YlhKPmB4NUJ3WGt0Uz88PCZw NTxybXpVdWV0YFElUyhBRSQ9TShge1JffDFBYShvfnZoTwp6TmRSS0NQTTYoMyF9YVA2TVErTk1H ZDxTQXkmZzhJPSlNNFMxYnEyKFJhYUF9eT57LVNvVSliTzJyYnVGX0lpdioKelhhYGY4R1g5aGlm Vl4/UTtiWGM4ISRKIVB7ck9JTUl5QV4pQF5XWldAOzVsezUpZTBGcmRRQmBJJHZ3eVRjWihJCnpZ Pkx6aUdad3g2e2FAdlBqRE8mcndgS2s+YDJvLWNPSVJjd3pgUC1LO2ViNGByNnFDak5yS1B9PyNA eypZMSM7Tgp6Kj9HOylmV1MtYyppVVBRcVRnQmhWPURSNnModn5eej82QV5qI08pLVloUUMze09O PDZocksxV1hvaT1zJVVGVkkKejtqczFUamxLdXVSS31LK0Z4WU96T0dhV1ltS0JPKUgyJno4OF9N I1Q+cmAyViFaVnomS0NCJH1WTGgpbmlAR3I9CnpZfmJXYjleIz80UV8qWXJJcGtkSVVeY2lyRCRu RXdFVVh5bCFUcWRmK2h1Xk8zajklOEtxKj9SPUJ6JTN1UFh0VQp6VXlLXnI7RWQ4PilsaFR0c3hX I3ZWRWxVPXBLb2lBR2xicXtmTnk5bnNlblJ7YzB6Q3QpYj12YmhAPEUrQEQmQC0KelU3UW9CUktY dG5UKyhmWGlGIyl3YFNnVSU2aUxSZnBzejllK0lWOXdJVFlZbXNYIUg7aV87X3FrNHZHWEIqOUZM Cnp7cCVXNV8kTUtIOSRsS21Fa1IqNG9iTDtXcClFKFJOO04mckxDVD4tOTNoRTZ3fHdWdDtCMzMh cWZldlNweiRZeQp6UEs5RWxMTiU7dCZJaEdRe25eQ3UlaWB1by0xe0NpVU5iXz5obyM1PU16Tl5U Tn1gLXgjfU1FeUNYa0t5cCh6Z2YKenAqPGM0PWRFOFp0N3M2dHF9TjVNRktWa0FHYD1WUWJrWX0z T2dORHBhJkd8UzJnMWdUeSo4NDdMcCZtSW91NlZoCnpKLSszMUh8czBTUiFZfCs/X09RXihFUEg5 XikxTTlsVzhOMmlQajVBQXBBdjEkITJ8YDVWVk9JTihSWiQ+WGwjJQp6Qnt6M3hJPD5kU0tiOy1p NXcxSGE4XytASXUlbjt1Tzs7WXRhe0FINmBQd3l4UVlke25XOzRzYUorZ1ZrREE2R3QKej5FMERa eUMlKWExPHdFNVY8OShAJVUmeWEqUE99RTVhSzEkcj4kVilYSSk5ditJaD03RmxxISR8M096KGRn ezh7CnopSndVQG54QmQqb1NxNEluM34yUFI1MW0tPFdmc3xHTndjSWduZUFKbTs2cm5pYFg+K1Fg TmxyVGgtN3JLKmgjLQp6OD1YZS1JbkZ7VCR+Rjl4RmNtSGM2MnhRUXRsYkVSKUFSVn1gRz5McS1m KlcqUnd9Rj55PHFUQWMmKlRLdTRrfC0KeitxTCElUFRgNUBXRT4hX0hWNkZhYnJQfH0rYWFRPHs4 dXdGey17akp3ZDlvakxnRHNMQHJ7dDVpPnY0RHZzcGE7CnpnTkg1JHUwSEZhc1hNKEdoUCE8KXlK MjZ+Slc5XmYzb0xvT1hJdDQ+ZzBtOD1Rc0BuOz8wSFUoXzY7aTlnSFBBcQp6e2VvV2VmTVdITVpr T1otdHpyUnRFc3NQdm5BJWs3STlgKz5EPHBGeHJkQGFgLSpiY1hRUSlKUXEjeWc+P28pTSsKenhU R2hHeX10az4lb3tVYSFGVUVIUWUydjEjUj90N1dAYWYyNDM1NykwYUx5PXJjdypoSkw8ck4waTQ7 UUg4NyRLCno8eGtLODhALSlrTE51P3FiX3ZiKjQzKlp+SV58bVk3V30xJlhkUj5icCl9ci1qYTgy akFqYHh7dWpFTWBsWiVIRQp6bVg3WWxhRVowOTxBSGpDZCR7TFp5eExeSG4ob0d8MTBBTFlISThX NGxJWk87WUcyZW0wTzVMIXR2ZUYkKDEjWiUKenxKdT40YWl+OEV0Qktnc19hbypTJjkkTjU+c3VM UzdoZnhHLV47cj1eXyM9SlY3UHdlcj5ldG5EfGpGZ2ZgNEoyCnpGRF5WKXQzXyUtZSspbWlfUGBR emhWWDFpYHg4UDdUZzs1Z096UDlLPiZ6I1VMRl9SUiQ2U191WihRQUFZUHFvfAp6RkVfJjA2ZURw RU1tYno/XjByXilLaWM1SlUkV00jZ2RwYEw+fjZPOEYlKCUpdjc2PCR0NmpXRCZNdSM7UEtzZTcK ek0pYHg5WXRLWiZUfSExeSpibE9iI2xiaCtJKmBhO0lwcnt5Q2A+JENVK0xASlZuMFg/MFg8ekZ4 NSY7eVp0Z249Cnp7bFZLNmFrJCpqbDI0UGxIMTZUNy1GX2BGYyRycGpkM0poZW90S0pCTz1IKkY0 Xz9OOHtvaClFYFQmMUVRJnlzOQp6UndXQ0JIXzA9PG8zPktSOCt7aD1iZylLPTFwUGhPMHlwcU5O bDNBOE5VSi1JdTB4RzIoX316SVg3M0trVVdmaiEKemFAQVFiI1FPUD5RUmpAcnZJJUpXPThGaHZQ dH5TJjZHfmJgTDY9SjJHTUMyfSNJY34qPG9YWT1eZ35PO0tRNCEpCnpAOWgwVmJ3P1dobj5TVFp7 fm5JemR8YTw5MW1eQDhhRHB5VT5vLUpCN3VENEdoLTJ0MWRJeUVlMyUqfmFkVWEjMQp6KFRIWVdV MFBiKUlaaH5KJUwtT015KXc/blk4dUtVPkBlYT5oVSMmZHo2b1dCT0ZoT2A4RkFgUEMlTD9BLTFe TkIKejVnR15aKHk4dHxfJV5BITFoayEwTyo7eH1hYmFLVmEoUipraUI9dVVPe0A/RDRVMXdrUWM9 O0tuTlF0c2hLZFBfCnoyPm1ObkZqZGZlT1NMYStvUkZtYGRjLUhBeWlkQzQwO353e3J+THhaKmhn JjMkOUVeWjJSI3Bie2M7SGtwcTV+RQp6SmpVKmdCMW48UmRxfGM7TEJNPUsjTUEqNUJnZTBDQWBx bDZkS3kqNlVfakR5e2ZJKTlXRCYtO19eJi1nPnk4ZlUKenktbStzTEdWMkh7fTgpMG88eHF4R0ck bk56JnJKZWpib0ghIWd+P2RDNjEjV21VNG9aMCVTaXErPjsoWUp9MDNRCnp3JHtSOEBJQ3haIXhA Ml43NDBEckQmMz9JMy1jNm1DMSZGbl8+WitrPmp2bGwrciYxbikjRCM1Kz9Yd0BZJWZHfAp6USRK RDdWQlVJWE1mN3NVTyloRkJGUzFiSjI7JG58N292Q1ohQT97N3xJfSZOeWd0Nm0zcERhcnZha303 UVB8ZzQKem1kQTF1e3Q+O3g5NUwzMnk/NmtBX0liY0w3VkdEP2ZeNz8mPnoofFp2USUlISNNJnMx JWtten0lPEF4djRlQ1NvCnpvalJ6dXVJRj4tZGJuP1UkOGFxfHtpazF5d097dUJge297KWVTUWhl O0AoNnF4JjMlLVE+eyEyV0Z2TnpqdCp0aQp6NzdpN29ucmJhLXBsTTxFKHl8VHo9bzVORDB4YzlI dXs2ck04QEZ3I1NQa0Q4Z2ZzYFM9ZyhpSENhIUVEVGdmZD4Kei1pfCFpamZXdDMmbG8+RlZlfEgw ZyFEWiskKiZ9NW5QKnghNHE1MSYxWmNAVil8ZSlFX1RoNkJBZj81PV48cylyCnppd3NmKWJkPHl9 dEJacSsxUHJNbj50a0p6PUBqQE01JkhIJU14UklBb2diNnFERVlXR1d0VE0kb0I1b04tbGBCUgp6 c3R3XyQoSHFCTVp0fX5JY0tCTjJeTnUjJmpCMGIwXkV9KTBfZzcrV0pLRlFFT159MDtUdGhHVF9U V28hRHM0KmgKeituOXduOD1OTWkpQ34+WFRkPFhsUXwoeCRzRG1keyFqRSlJNE84UWtqJEM3bXs0 T1IzaDEqZG85K2peRURIYy0pCnphSk9yPE5UcGA4Zm1qJm08KU1Ue2JBPWBmemJLUH1ecipncHpU TSpePWI7ZUQ8em18a0hLbSMmQFQ+fWxyN2V2UQp6PFN2IWhBNkQrM3gwXikzc0lfc1M/T05GKXZw dGlAWkx8fmlkX1I0RlNydGVVTU5IVG5SPCFfeFkmYFIqQDk/MDIKemZRLVBvQmNQYnFSS0BnK1k1 PiU0TmVuWiptfXtmKyplPkYzODh6Z3d8REZ6MGlLVWsxNiZtNzsmY3ZHQGFSYW92CnpjZV9TPjdm KVU2TVlMX3laZV9CJCo3fHxsLXxQfUE3TDJhaE1NN08yYT1FaT9HQWJaQ2p5ZEd4cTM2anIwOFot Vwp6QWA3RTZlbSp8TXZodUl+MVV6WFhQaVJsYSlhfk9kRmEoIUlrTDk8eGcjMFhiZ01gRHZ7QX1s eFQtZX01UHhGRWQKeiQxTitxMDV3eHg3SDQyWGJmNjFyRXwjZ2xkOUxUSV5feGBSUTVIPSFlejAr KV9lOXNiT2AlLXBBYmVSSzc3MWpSCnpfNU16TSVPXkZ8MHNPTG5rbz4/WnpzPERXOCkwYFRQUUx6 aWNmTTN8PWJoYSFEJXdaXmBLT3VzaU10PHVENnhzVAp6Pmg5eXtxVDZnQDxGP2JKYSsqZkpSYCg/ XytJOFQ+RUh7NGYqTERhPCVlN2RPKFJPIzB6MX4qclI8Z0NeNktXJWMKengpPkxfS29wPjc2PV9t QC1ZM0JtcjxCe15AcT5ZU1JodF5mO3I0fHQ1NSVgeXxLSnlRdyVkNSRUdCM5SDU0MTRwCnpsRUFB amg3fUdZVDFNVExlI2smPjxjLX1wTGl3U04zVikkdklnZk5CYzJXLThufE9ucFB2LTx+cCZaTUlN cC1gVAp6OE9hdnVlRkkhPDQ2VGhLTShGZ0Q9ZHJFajBfVUhIRX4rKlYtSWB5TiE+UHJEYzBGKWdX PG1HSkp9S2s5PkAyYXsKemUxPHVqckstQjxRUTAkQlNoPDAhekJzVncyU2drZ0NaMy1jSj0mNko7 Z29OeUhGYTAlP2JAX0l5Vjk+c08wMWBxCnpaIW44V2gyJXZZUEtzOUBAVHJnbns1ZzUtZnQ2TUxP bHl9Pnk4VXskY3lYfHl6PV93PiNQXzc8dXg/OTVjKEpCbwp6YFc7WXNmb3ItYypCZGpqTyhqPHE9 PihheFBFVGg8Rm5Ta3NQeiNpN1cmNCFmKDNHQFomaF99Klc4YXtna0pfM00KenN8OX4pdCl1e3Fk VnV5XmljRGskPnZ7MnBScVVJbypGJnRDVVlsdip7RnNUX3pic20jeXs3Vj9RJH4qLU4/bm1SCnpY XzhrOTw2LWE+bSVTQFlfdkp0O2FyX3BWWWhwQU9Ab35eKVNhUiNzayZqN3V5TkNnV2smZTdjJVR9 KE0xR19KSQp6U3l2eW0tSzc1fCFFJlZ6OGBkJXZqcW5BTChXOWp3XlpeQTs0YVNiMHhRQW8hPklO R0cqMXlQKm9eKDxVXlAjMSQKendUfD0qdjZYP3oxTkNoZVRzVH5wT0ZqO05IOGElVVo8MUpLSSNH JExWKlB+YXRsNklDMzdwfHRgZ0dGPlc/MER7CnpZPG1UMmxnclomJVJ5YiV4Nyg4Zmtmem1gX2Nt RGZyfnNLM3tKOGk0U01hR1Z2Nl9ebTU3U0pUM3JKMVpaQFUhMAp6N3lZZ2wlaGRpZGE7algyUkVz IWA8MShoP2koN2lLMm5vOGllaFFQTVNndUFQTE83Ul8zMD98T3o5U219M3Q0M28KeigkLVY4Ujs4 PklqYFpzYUI/S3s0IShocjZsXjgpcEN1aF80JnV9SGgzKU5AVzBBYkhQeGs5JHwtZk0zS2A3Wklw CnpoRkBNdE04c2Uob3h9ZHpYT0N9IzkmKEB9UEwqSCY/RG42MGlNJjNhaDE+fjBvR0hBXis3cFAl SU89bWBSJDtoQwp6QHB7RXcxbzQ4QmMmKGluMUpGKnckdX5PfGZeaW8pNmJITWZkR1l3ZVg3Zjkj YVEjM2luYlpQaj9TIVYpTXZeVyEKekdGNV5Qe2gxaDRsJTxmdCZOPnlSZ0E4LWxhYHteMVgwdV45 cjgyezJ7M2taY1oycXhvWT4oTT5RO1gxLUhQY0FECnpgWSFXX0BScEZAJTxNcXRPUVJ0XyN9fT1g JUMpVmgjdU1mMWArZWRwenJYeDtXV2xCV09MaXBfQ0h3TzNiMnNtNgp6eyFWKGc3LWMpaiFwUzd8 bSl3Q2ZPS34pUHl7d3l1eEZEWCNPTj5Qd3VWI2FGSSQ8dypDQ153QntXdXMoM0hDenYKekVvWDQ0 Xmc3QmdeZ1R2flI5PF90VW1ZKl5Rc0c+JmxzQkJSYTAxcG5uVlRUdiQzMmZjU3UwaHhwJHI5Sz0r SkJYCnpscWY5cVB5SCNLKVZIRnxUfF51V0lvbnI7WHtqQG14PDtjPlpgVnhRRmg+RGoxLXAwUlFv QUJfUDVkek1sWFpANgp6cGhRNCgxMkVMcXYoX1hYNWYxIz4xQFVfeHhxNWFtcz19YT9hYE5HOSpt MzhLej5vK09DT19ZKmdwaHhiYkh8ZCMKekl2LVd7N15JN3pRdW4pYko9fm17YHpCPWhjVmhHRihM UHQjWj1hKTg1Wlk2e1plOWhDc1BENzM2VUJ7ZXRsYTwlCno9VUdTN0o0eiQoTHRUQWwhNn5BVE18 OTMteFghZ3dSJGEhQl82aU44MlJRK0VVS3xgcjd6UXVKP04qKE5yZXB6Twp6b316Qz4rdCprMTN+ XjI0dDBKWGJEPDJtamxaYHc1ZzttUXA+OFlXbnkoWHxNMllARldNJSluTE8xM0FSS0MmX1EKellI fHZVeldZbXB4KCU+JTJ1JH1gS0tUUCVSbj42WWp7Wm8mRWpMYyNrUmJmS1VmSD5uXkswWHNDYFFk LXNFekJKCnohcDskenFDYGlSNlMjSiFgTnl2REZUVlchJlBCdE9LLVp9QW08d3ohZnNIK3kjJksy Z1N6P30rNXFfcEdYVX45Iwp6RE9EM3twdHhTTWB+Sn1+JHxZXjFpTDNjSWtLKGVYQX1CKkdmMTB3 UGNDTUBjN3BSRkA1dENpTWshWWNOTmYlRnsKenNOJG03MVM7OCQrJnp4XnlZMHZRN2ZWfG5VNSVC Z2cxWktZK011V1NsenF2KnNJdEg4Nm1QSDJTc34lJm1tRGR1CnpTe3ZmJWErQCVxS0VlZCQoTDVC TlUyaF8/TWNFQUIoQXhLfSpTbXJHbHU5QnI/Q3hjSmRtbyhZT25JU3RoMTwqXgp6Typea3hsYipN SnNfNFhmfDFpWWRDaik5I0dQTD9XaFE+X2N7O3duP3RQKFcqNWtEQDg0NENeeCFISGZYeHY5YlcK ekswWFFQJklIczRRK2ZvMXhqd0IyIUhGYmB6NHZZWTNOMWBFTFd3VVlRMWRPbi1wQjZkMHxjanlU cXFJeiRkWXxuCnpIX1E9MS03RnI+KTdIPmo2UiVeTT5Ed0pjQEIrN3U8PU07ZSNJM0pOKyltQkg1 e1Z1T2EjVCkmLS1iR2h7a2lgSQp6U2NnSTk8Z20kUVd8IUpIJDFTKlBwT2lWTmJgcz5WeEIqPDFV MiZaS1F7NipsXyZSZGQqT1UwcFk/N2tTP0VOK2oKejlMMUlpbj9vLTc5TDI4WTtAVTk/RT0xKTdZ dmw4UTAmWHdERFohQSt6UkZmdSZsbWNAYzh0enJ2NiYqTGBRZWZZCnpYcygpSEJfUG5GUTZBNUd0 c1RTYkt2PSlGNElWeUg0TmJFMlNAI3JLKkMjdHo8P0dSSHRiOTUzcz96ejUteTtaNwp6JF4qbnhH TSljYFheM1dGa2d2Rjh6PStBQkZMNXkqcW1KcytoJllQRSVzY1o2K2w9Ml53VUx6d1I+NUlLTkFD MFgKelRrYWNnP0Vmb1plZUBrZSE8M2xJSD9CUihoRnwrJFhmO2dhPTUlJChVdG1rQTlIeVAzYH59 P3EzWDMtfV5IfXpoCnohfnxpdkhVMWdWeCFTR19AUF5JMj9MeDk0I0NGUWlMOSN4aEhARUYkWWJF SmpwKnQpb0BuYXU1YGZHYVBMP01wbgp6KVBMY3E8SU5sUWV+eX5qRWg9LWBEMj9kfm9KUlZwR2xy fFlGPGpKVD5KI1UrbD90O35YVGwhP3k2YXZkISQjN3QKej53bT00R3EtQ1RuUVExe0EkKXVHJUco YklzPXdZUSRUSz4xO2dkNWpycHdrLSUxMjBFJlJDRiRIU3txQnZ9Qy1rCnolbkdCIUZtRE4yPFgz I0EoTUltJW5SbzVja00yeHEjSi04V0dYTGNCUXdrT3pQbkNiQ2FpVTMwTl9Fe2ZLISEqUgp6TSp8 KUslIWAwUHN2SVM/VFhrSXhjfFVYRSgrMz55PiNNM3s3SFM/eyRTaWFAYTxfTUJOSlRMMUQxPDIw UWEqVHwKeiRUQ1V0TzB3bWI3dlc3QEN6aFIyOD88VEFfaVMrTV50VE9Gb2Y4cEg3IXk9eHRyKkVo PDk3WWVGNTYjZTJmMEx6CnpRTFlATjlVeHUpd3lCMWQkP2FxaFhCbnZxPDs0NUtKOz9+Sig3Yzg3 TH5Mb19aMWhzS2xRSihuPTJgdVpnQ0Z9Ugp6SWRhJk9jYWZtN2tRRVIhNXFrWEg4MnRgMV9gcW5H KylGQlFeXktrcmwyUDE5WlIyQ3JsVmx0IXZ7VChhTXdzTioKekhHflBlZ0k4QD10ekEoWE1JfjZ1 VXluNGA2MXl+dlNAeUA8S2lwckFDclcrZFN0P1hRajFrPlpLdVhBTGQ/YCliCnokdWhrS2NMeFdV VWE0ajhiNldOdk0hfThxQ0k2XzB4eDBCKW1vV096S1JKcmY0OykzUUZgJV4kZXY1UiZgZkh6YAp6 XyVENGkoWSRSfFckMzZMc3hRZj9DX1dBenRCcVFRPV4zUj08MmxvcFhsflZ3S2VQTihFYExlQmFJ a2dDRDtAZDsKeiFJSnRjRmNOS2N7UT9ybz5aYVg5JGs0NlZYdHJeZCh2SHJoNj9aU3VfZ0hpejVo cWZwQzN3fHpeQ018UkNKMXRZCnpRUlF0NmA1K1VJRigxcnVzailAZTdlJEkjbUhhPUFmNW1iS2ZD e1pBRjgrUGR4d0w8LWU5PERoIUhgI3ZxT2Z3VQp6Nj0yNS1xb3RnO1pgPExCe0J5TmhOKThrQjN+ S0NyMHZkMytfaWBUZ1VSeDJaZHo8WWRnOEhvR1kxPjRAX3wmOUYKenQrUVl9I2QzYTVJYTZkYnQ1 dGZYJVBjQjY+KyRNdFEmU0MzTlBIeiR5WkBjUSZSJmY/RXFiRWE9cTklfWBTR3h9CnpYZzZ2SHpP dzFxLSR9TTZKfVNnSzBQSiQ+RTIpVEtjUXZEcTdYYmEkQyglbEoqVSRub2haRmY0VFhlamxMM1VJ PQp6dUdyQyhGaWFlVjlifXR0WU0xYlU7aXIyXlReenl5PzdwcCtPcHlFPTU3THlQXkUwUTN0dHg9 fU1zcTMzRlh3Vm8Kem5hJXBTczhZd0ZjMnV2d3VeJEJFOH5GRFV5P0hqcS1SWW4jSkp2QVR2dzdQ LT9mV3Q8ZTg9SzV1RHdfTEt1X2xQCnpoRCNwaW9Nb0VKa29iXjdGP1g+dGQzUH55T1o/eHxoMDs/ TDtxZiQoWWZITXtZUU8oa3MoamJRe3BVUHdrRUZ+fgp6ampJM0diTCtQWTN7UGdYeDYtbTZPO3BU Q1UrRz8/YXFjMmNEJGJsZ2xOQ0tKayooQmB2S0BRRCtQJHRNdFpMSkUKeihvNDdhTHNEZnBuUnxZ SlNLNXR4NkBUMiFCTzV3Si19Y1g8aXAhJGd3QWByVEN8OX5JKjdLczN7QndDcF85PFkmCnojal9n byQ9XnxsWFpWb2ZDQUh6ZTVGJlpYT2Y8aXlyPiQ2Tk5Wd3NOM3ZiY29PUTIkNDUze2Z2IVI3SEFy YEA3Ywp6RlZHd1p5MnlYPXZWY2Y7SmE+KnF4TmR6OzdPcmtHLW5Xd0hzNnBkfkYwJDlFRSMzUWVr WTZmYmcraVMtNWBvc34KejZYP2lMU2pFP3JDQHJ0T1Y9QVZBTT9qP041YyQqSWU/JWg/I2AmPCp2 eTtwWjhCY1I0OyFlTVlQbk9UTXp3c01WCnpMdWZ8JG5+N0VlOV9KTzRQaTNpNUBqR0R6RTFtWkwr SSZIOEsxXmdYREM9WVhWK2FpLXBDS3F8Y2lDPEN5UWp8Vwp6LT13S3lUcDtFU1dRYjB9MU4kZGt5 Wmd7e0xXfUs9V15UVjJPM0M2U24zVTU/KWdTaU5oQyhlX1chSWxQZjJ4MCYKekZFYTdaK2phSDBg OCUtQVhWNGNDcF96YHRpMGBCdSM3fld8IWZxVEkyU2BDYDQ8RlhDcjNzcUw/VlpBVEpXalMqCnpU QCooI05vJUpJIURMdW4pRmhXI1ctd3wpeipwaklfQyNxSXVSO1lxQVRacDM5WVFFJmJxOHNgYjxi fnkoTE5ZRQp6R1hAZGxUb0RsSjwpfXYtYShFVSRSfGMoKkI+RSZOMSZxQUk3cDwqVTV0ezhUZTNH aj9uNzk0anRGZWtneyRnKTYKek84dT9xeHxhT1NQNlNJdGojX3xjbkJyU34heFBCKnBNPWVDVEI9 U3haeW9TLWZEQUxxV0RHXiNDMHwjby0zRGp6CnpPVlo0T1VQTmZrVkNwTFpVcmFeRTZMT0t4LSo8 PiVka25KRkBOPD8wOFFWWGFtfEd7clE7TD1Dcyo3OWw8RWtOPwp6ZUdsdStLeXhAYm1zamBAPGQ9 JW11cDskaT9yQkMqTXA3QEteP3ZPZUd1KVIjNys9NU9vS19xNTNnZDVKR3kweVAKej1GdyNhXjR3 fT53QDxYJmA/NEl3R3tyVEk9aG4tKTUmXz1hbVMpdH0peChhY25AfEw/SkgqeGRkWEhPSWUybn1V CnpFfHcoPXprUFA3UV5mZlg1PHxqaXQmdXpXOGs8V1QmO1I7eEtVN04lRT5RYUdgaWBAYG9MJDM0 S0Z6LU80NksyJQp6T2A4fmNaay1ka3ZrSCN0VF8/T3pxeF9vJHp2WGcmNjVvN1lsT3h0OENmfD1K X2QzPShrbzdJZkchb3hMek1PMnwKem80fVRFKHJFYFRoSndQVm9ofFoqazkyeGgoYG9+Kis5ezNx RT03PnM/bHtMVWlVUngmcj4oPDNRPj0hQHdpJGEtCnpuYU10VW9GSkxgWT5aPCNqQ2BsZkYqa3A0 QHhqfUtabFdgVHZ+X0JwelktRVhSM3dFTnF2aEt3N05aOEdnV3RkTwp6YE8wbk5gaisqLWNMZ1ZH dU51dENSYVJZbTFVcC1VU0kybXl1cik1NnoxQnpTRDktfXFCIUdnSkopdjVBSy1hWSEKemtPVHBE T1RJR2FESDxhdF9XKUx7XkVOXmEtQn4hM1N0fWZNQFIqODBVNXwlP1ElY0dWOWgxbj9sNE1NezxN KEl1CnpNJXo4V3J1YHBDenJHdn5JbWJ2JGtIJGklclAzNChNSHw1MlF7YVJtbGNwPHF3YTt1NzEq dCNDc0V9dFd4a0UjXwp6dFZzd0xAOEZMKHBRMjVyQ3h4QnZqPDMrfmZUR2Z9bWVVV3FPZDUqU0tq KkM1JnZTVmlQZDVUSE89NEh8TC1qbkUKelNzRn49O1lXaVRDPGd6Xm9ORVNVXnRqMHBiRmpYdTRt bD52aCgxc0BmJERMOz12TDwxUGlabG0+eWglWWxzeytOCnp6djJ6XzVsJlB+bWlVOEZBNTdXLURY Vjd7QiMzNlFuaDJoWDtKVnszO153Oy11TGByPTFhPilfR3Zpb2dWfHp+YAp6ZUlKJChlQUhtPEtY THExe1dEI1pQRTkoViMteUtBLX1SR1h0KWQ+YztPVGh1d0c5UjJRT2NMWSR8aU5EPF5SO34Kejc2 eTl0c2AyX0B1eDFWbzI7Q0hBUCgrem5iSHtOLTU2e0AkdEt1RFhERVVjSlk0YldGRVVRK1Fae3g1 X1B4WldBCnp4VSNEMjYzM1g2T1FFbHFiPUI4K2IkJV5DQ05OYG54elhYRFY7TzJfRjZwZ2hMT3px RSo3Q3N3NGNwdWtBbkN7RQp6bFhuQkY7JiNAflJedzQtIzgrOXBXNTE4ZzEtV2trMnxSTW0/dyhw c3J9S3Z4NFlkYzUxO0xAdVRkZkU5TUBBR2wKek1CQ1ctJGpjbmJBK2ExXm5AQlVHbjJhZ003SEVg RWppUVFLVm01dzd7X3JNM0BnQ3hwdzVRX21ZYWE7YlJNVDJMCnopTllYeC0lcjkkM2h2UlMmMyVr ak5MZG9YPDJSSjtHQjR9MWRHdTtGNXQ0M01GTHZoT1Vhdz9Ran1NWjlHViZ5cwp6NUJaUEhWVnJZ bXQ9NExYVFp9S2xwWFBXdHRDJT9HYXRid3BBUX1nJlA3TlVtcXJ1ViUtS0V9RC1sZUt8Pmg8WlIK elgzTyRGQ2t9TW5wTiFtQ2hHbGBVK0AlU3N0M2NEKChVWThZe1VWbXo7O3ROaXQ9aGplZmlzO2xQ UkhYT0g/JGM/CnozclFWQzQ+PyNUMzxuNkdsND14RjdDZXNOWndqLTs2VWdsMWAzdDJMK3pEbklv XjI+PytQNHJMZUhHfGV5PV9nQQp6Rms4YT5XMV91ZDcpTjxTUnZXKWFyM1o2Tm04O25AQT1IZX57 YzdiMytedVEyejU2JHhMfkx3eXh5P1Z2PVpXRjUKelloUmVyJXZDYDwzO0t+bFh0QEVJT35afEto NFdLeGEwZjdeUX5OfihHTUM3Szg3OUAhODB2Szw2SmBpUmMzbng2Cnp5aDAtTFY1ajUlTmgwNDtx JkB2YkNmamRhYitXWUB2fnpQelJMalV9X31eYjItKT5SRi1uIW5vZmFXSUlldG5vbgp6SEI0WUsy ckhBLXRQOTVoS18+ZyhJeDNMJWEqYkV7c29QP3gzTjQjKWZ3PW8tdVgoOCF0WHktTXJkODkrKEVn c0gKenRoJVFedUQ2PGVJVE9WRmM9aiFXXj1fTio/cldFMDQ9TTl4Jj9qeUk9dylocy1lc3khY0dn RiMpQnVQODxqIWtRCnpNMDhhV18tUSZPKihZUTl1QWF8PjlgeSNRPlN+V0lPS2d2cHpeJTlwc2B4 P3UkKEZSRiY5Uj9aRUk4S2ctJVl+fgp6XiZmOHF0Vm9pUVpIX1UhU3piaGZ4Nk5tUWVyaHIkJXpe WVQ5e2t+dDkocX4tQmxAa191anojPXZ8I20hdVNLYFAKejRoPGpCdzBwTnVAMGs0RnpIdTJmYnU+ KXpSLX1CWGZtPFVHWVBgVGMjSF9eVyFDZEtWd2M/VTxXQXhuRF80NmpsCnolLT1EKUt8YmJQd1dg Z3B0WXcwSnMwUVQpa1g9eHZ5UFR7b2slZnt+K0pEUiZ1NWVhJDROclJvKD5pQEV7UFdCaAp6cUNs T1l0fGlIIzdtR0Y0YkdpOUlfI3hAUXF4Jl9jZCZpV2dMZH1lejdvSXB4ZXxPc0lVWFI0KytiNUx3 RlF9VTsKelhubyZWbVRCX1p7SXM2OysmZ2xGU3R6c1FLdyRqSStaVFomZEBCMVF0PFVkWHw5PFJX WlM8RndYai0/fTIpeG1ICnpJe2x4O01BNHVKZ1E7Jj1ZY3hZRldQK3cla0RNUChaQk1PIyg4Nzhy XlhPUjJNZlZTbEtzVXZhcHU0bz80Tmh9YQp6My10UndNVCtXISl1LTUmdU5jenJ8MzR6KGYyP3FS KWE7bnNgM1pSZ1Jxbkh5akE2dH4zfTN5Xi0mZGFHY3B7TSgKek1aciVBO0BtJE9hO2BuWjkjc3hH dSNrfig9YUImfFF+KX5zVUxONWAqZ0tVKD0oenBmOGYoNVBoRlowITkmJkpWCnpEfjxsKHclNGpL Kmw9SzRjMUpjJW9AJSokVCpYVXl6JF9KdGZMSThSWSRRJFFDO0hXMzhsdSlVPDdhQCZrT1RCZAp6 eyhPViRGRF5lY3pUS24hX3BNRWZSNUc7d0I4UTt9aW8/dj1TVyhWPnZtZmw2JkxAPz1jUT44ZiVZ Q15wN2N5fU0Kejc5WUxKOzVUNkpAPVRuQjNiWTlSWVBRRFVLV35AYmAwUz8pY3BYTWFwP0BAWTds OCg3OCRgZUxneXxpKk1ISlJ4CnpuJmc0Vio0Kzt9TiNjVCFzOHlxNHc/NkRGK2tJQSp4XitGdlNW czJ9PTNeRUZISnheaF4oRlZsPks9dlBtcj5xYgp6b0B8KF9IYDt2JXc/VDQhbmVONGdYKUZWSUhX K0M8TXFnV25TM1p0TityYFhIQyhAOEBtfVlxfEBZNUlgMXdtZ1UKekZhMyluUHNpX1lqXmVsWkgj WWpUQXQkUGI4JjE/R0ZoQXhINFBUOHNza2AtRklFeipeKmBme25hWHtsKiFOeTUtCnomJk0+I002 cigxNTszYUZpUzwkNnUwcWMwJm8jXm5mXiojcT1qcTViOyFRa2ZgNH5+O08yfCFhZjZ0Vz9KPmVz Rgp6KVJVVWlhPURwYHN4Pn5ocU5KPyY5amxeazxKUlolak58TGFfYCNwRWFubntBcV8/Snl5T05B V2c1TF5zWEQtTT4KekhxPEBqRTUhY04wPU9RMHJkMkdYTV4jWTBDUShHSUZBWmsyI2JgKlkhfkk8 eHZ4VVc7QTVpfHtuXzxBPiVYRCpgCnoxKVpJSykoeU9AanhiLTFsc2ZETnxJUXtmREJLfmd7UHFF flhAWUF4TGd6fUt2cyspRWlAbUJKI09zfnthJWJ4QAp6QEJNY0BPMEwxbkNpWStOUGtqZHR6WnV5 RygqSEFed2Z9MzxacGohe0s/KXZlcHg1cHpzelMwSzZANFFRKEd0Mz0KeiE2YDR2ZH5EMSpVLWp0 VHl8PzQ+Ymsla0RsM1NIPUM0VyhpTHE0Z18zWW03Zzt7cVgrbmJCRHshdzw3PGRTRVNlCnpxdDZq TmUqMUYrSy0wWWJScH5OPXRnUVgrSSQ1ZEVzUylZbCE0bE5UOVV4Uj1kMXR+LT9NWm1TKGp+Kj0q Xy1WTgp6VHxXNGBEQWF6UmsrT2V7a3VsZSFQPEVGWV9pcSola3IpfkNTMiUmMVNKJkx5SV9YWjlg JnxFNWhkKVB3M1g7fXwKekUkaElHRzVFSFhreytVYCFWRFUtOzBqOXJzJH07Y3JzMVNVJnxsUmp0 O2tMdnc0MjhobEhpPigqUUxEaXlleCp0Cnoqe2k0Kjl5QG48YGU3cCl2Iy09PEdSNUR2e2kxYUQp UHVILSZzUkQ8V2lsNm54e2NIbHMyQiNeTTgtUHVrdW98Tgp6K1Nld2J3JmtVc2UkSHwraTh2VlBQ eWcwUWllaTRgUUg4RSpxdmFAbkdfQVUjKipuY2dGUSNFazh7QHRRMVYmVWoKekg+Q2IrJV88TG5J dnA7MjV3SUlrVShVJXxwVH5LI2V6KnppSmIhbzJOIXQrMzNfQk5tRjg1PEFaMF5VUz82JV4+Cnp3 d05XTntQOHhtVz5xTWp2QkVHZmVSOThDWmdGV3tkaEAjMnpFK0J7Y1ZSUUhTMlMxTT5uZ3c3SnJt Jis2YVBseQp6dDxgQWQmaz4jNlFiN2huQUglb3huYm5teTc5c31iRTVxTVI+VVg5JDsmaT1wVHsw dDQwKWVxKmZySkN+P1lIKnoKejgjVnQ8KERoJEJJPEIqT1JiJSF5R2pQWnhNalNeOyplVSsqeHt3 JHU/djlqOHRPVmk9VjJDUXFETHNxVz9NN25tCno5VUxtZEBBd1JeVWxNZFl0R29ZRXFGR3VLTiRn T2AjX2E3UjZIOCRocFI2I0dkNFZjdFF3JD9PRG5vO0pzdU5xMwp6ZTFQUjBWNGR4aSpTTHt2SVBo bEwkTzFFUzV8OzdQYSghbVV5QGNiQz9ZK3c7fE13cFpDdC1zY2MtQXFDVDAmJSEKej1VPHhORjxn QUpoIWdEdiVQezt1WWB1a0JSQmhrKXRFaEJkZlBrYztBbCtSbUNESnYzYlc3KlpBdnd8QFFjQHhA CnooJXMkQyhrJT1fIV9ZQWQ0N2BpJGUocT1RZWVDeFM7MjM3anh6PjVFWit3MmNfdk9sbVR1WHAx NEJIO3wkUHNsRwp6LT4+SyVSJCRJdG0mNUA0Zn1lNkMrND9YZHNUPTMmREdrTG1wbWpHZDRoWWNi d2VBTjs3Yn01KiV0dH09QSs9M3AKemhNSGIpQ2h5SVo4XkYqSiskKlYkRW9TMmBvO24yanFEY3ds RXt3JjVSKjJlSmtkX2l8M1h0VzRYaSp5aUtFfiMrCnorKm51OT1fUSEhQDheKXZkME1ufDgtc2Rl byVTKV9tRHBeMyhKRyFKJnYlSVU9c2F0Q0FSdmc5em1GN3RfMWBRMgp6T35BVVUkYiFeSEkxIzww PGtmJmAoQFBmZGNhLTtLenh6SmdMMGBoWFUmRyQ4OGhsP09Rb1A3KzB2OWRAY0pqOysKekhkWW0l I1pkMFkzITBgOXlAb1VJSSMoQGp7b0w5NTE/NFQrRztrY3w5TG53ajFULXkje0J6PytxX1l1e3hF Vy16CnpsfSQ7PD53eEomTEVDSHd7XjNXSF9eK04meUVyMVd2VUd3PlZ9biRnZm14e28yVW1MK0lP SXFOd1JBQSE4ZFBkNQp6c2N2REVHfkpjXmBlZmJPZCVAWGp2fT5CQGsrc3RKe2trWUpJIW97O0RF Yyo8eUpaY2RhPHBKMllXaipQUkN0UU8KekVyKTtoSDhMMi0mMlpCO1dBPUJpUEZpdCteSSsjI0ZW d3tJI3BwJChAYzUjKyt9Wmg7KW1nZyszWDQ+NnFBazR7CnpCIW9jN1k5MEczPUh2c1pMY1ZqcEtG MlJgMVokK3kjWGl0TCpfO15jKnM2bkN0UX5nUU9PI2YwO1R8eTRHcVRhbgp6bHtLdElmfHdBcHNR V01CNWI/PEZ1PVRSZXdYSXxEWlRVfW9mM00/U2lwJnBGUllSUDFWTFNWUGkpQyk5O2JeJnIKemAx KyZsZDJvQ1pQTUIzP3tZcnE/OyE2Kn0lPXk9cW08V20jYzItWEVAMXdIVClydjd3MGxBZVo4NXA8 JkRRMDl2CnpeajNEQC12SHBac2g9V20rNCVmeiolVSVzUXUzK01wKjhVS0crVl9vdldjWnNoSD8p b0Nya2FLQDI0WD9NIyNnUgp6QG4lY3ZaaG18TmM9eiFmem45U3MwbXIjP056dSZtT3tNKiVFd3hS KzNiYUhVcX1NeDkwMD56ck51JDt8a2RwWDAKejhiZm9oN0dUTVBMUnJ+RmhzdTg0eURFY0o4OShR PSg2NG51ZjRuSGdaVUpITHYyKTV8ZGpGYmBgLU1LY3hJb1FZCnpgQ2VRRnwwWipBdDJxZ1IrK148 UXVYQStJWnRjO0dwcW9OQnd6anBPTlZOd3ZabUIme29aTEc0PEd3cG9tUVFWTgp6IVA5bGxGPmgx KCFoVnF+YUpwMStgOE00YSFmRlkxUl96UkRsOWMpdUNiWi0lSil9eDI0JWxSaXclantnZWZHVDkK ejgoWXBYRnw9UzVpNnpRVXhrMXlQT3FZajc2VSt1em09ZT1tZm1SVEhEPHVANT5UXykpMHslRn1I KittdjR5bittCnpCfm1Ed1A7WTs4NDlqMEFqYj1LVntCdzJtV3pSeEM5MEBUdXBeOC0lS2JHMDQk Nms3ODtKd3ZNY15KPjZVOUtoZQp6NFRoWEVrOSpaIyVPWlh3PmkhZGJnTXVRdDBwa3l5MSg9b1ZF I0crMkU+UU07Xz1lUWImJDE5aXlMbmxHbn5eYCkKenlSZn1MJiVmVCNecjhIPGZ5RDJ7dFYlYklO cngld0o5PlN8OGpUJTgoWDJeVlE7JlRzZXdtPD1ePDQ5JHZRUEdZCno7Y3pYK3NHeT9JZ0lERFh0 cFIrP2JPRlYre2RXVGtlQSlqOWx0NU9ySkJ1dkJGTSgzN1B8NEpgRSM7emFeRmRSdwp6ekEwSChg aERaS2Y/KVc5MVdWcktnb2lJcXtOIyk4KTZVK34qSE5FV3lZampSQTUpeT1uOEN6QU5LMFpjeDcy WmoKellRdC1oZEp+SXlrRTRlN0B9Y1BndGluR2IqN3RVKStqYjc1WF9ASG1rOE5nXnp4YSlIbDkh dTE1UjRZOGF6QkFfCnp3d19JZHFtO2gkN2RFaGtpYilHY19jQFpwOFp2dlpUVTQzJSNaWCZZMWti MnFXWlJXQk1zZ1JNIzdXJlloPCRyKwp6TD9TcitEI2MqcGEwV35XOGFFUE5jejtIXz82eDFyQT9H bDgtP0twc3N1M2F9OCViNHltZS09O3thOzhKaGxTZFgKelc4UmZ3cm15RXxyeGF5eCVZVFFeMmg1 ZTh4aXNJPGBSPkR6S1VBbzw3U3dFVmskSFhfYyo+LT80enhGRkArVmkrCnooaG15VEAtM2teRyRS QVdWNFJgeWNqWD8oaW0pO2w/Vn4/NiRvLWowSlVxdVVtZXdmZFVTcUowVmcyM0Q0XlFGZgp6YHoy T0IoSUBIT1ckal93al9sPVhHU3QmanF1bGU/NCZpUjRGWE9lay1xQ0MqPSZLTSN6YVA/VW57ajRG ZVp1WTYKelN8MFRKPlpFTj9Hd28hcWkmWitiSilXQ2NpUE9iUD9fOTFhe3R2WWp4bHVgbVJ3bG53 VEtTUEgweUx3bGRCazV2Cno+UUdxV0NxP3NVWGhBdmora3tnPipMYWhpRX1IRHsofDZyZzRUTUBh cWN7bipRXypTO2N3NmgqMjVzaC0rR1cjcgp6d1ZDYzktaFItdVhGRjB+YXw3fXhkNjQtYkJ8RSMz SX5FVj5jQVRkO3E4Knt5Tk9OUTBod0goLV9IVkEkPEJpWXIKejJwV0VSQWxTTi09bTM8NWBCd2d3 TjhKeUplTz57KD5ZdEghY3BPdTROWnQ4UG8qPkghJXhjIXw2VDBWKjYwTDxwCnpEWU9EQU1uayUt RiRTNz52MXMmeUlEZFh0LUk3KWchdHZGOGlsWipGKjNBT1pNe1NocWQjTH1xe0JiQHd7dWFiagp6 P1M5aEgpTCs1KlhUPFpGUmFkckttNz07fEpVXz13czI+eXpxZkhGZFJ6OHxVait5dHphcyhHJGdm QmNUZFI4ZkQKemlLbFpWJjNFbV5wdz1aTXdDdFdwLURDTW1IU3Z9SVdBNFg0Zm0/Z0B3QFFLdHVw PChINV9mQXskX04lby1rODt0CnpoUntGOF9JYG5YP2EhdUFwX2l+ZUhvbnhxJXZGeHRkVUhtbU43 MnAte3VMfmI0SD0qJHklc0hWRyNzM2AtbmNAaQp6KUQoS1c0I193Rk1PM3tuZzRONihjTmVRYmdo OVI9PEVsMnYhVCRSb0ZaPDx7KHA0ZVA7I2RaLUx4b1F4PGk5RUMKendWaWd+QjZZQWxhT0RSLSlW bG1tKUUrIXt4IUNLZj9rbEE0eU4xbW4zdkpBfXl8UmxFSDtNZWlRaXsjckNsYmVvCnpsTjskWk94 SjFZPUJWbGdjdDRMVm8jNT5rVFpOX1UlfD19b2RTSlVLPChHJVpMbDt6U1htU2srcCVucThleHpn Jgp6JmBtRmVAZSlUMSU5fE4qRXJOJDcrPlhDPDNGPUhFUT9vO3xxdkFSZGJHfXJ6ekNDeyYlYTNm ejRjXlVKN1l3TCYKem9rKWBfMD1qRn53TWBsajJiJkxlYHpQenlXMiU/eEdAeytfMUE4YFQjMiZx ZVhFPVQ4dHNFUkg1XlliRk0oRzFaCnpKJVp4MXtaUiZQKmE4UE5yNnxNdGM2PH5UWCFNdzVfVD5H WilZaSQxMlJZVnI5UV99ZEY+dSZxU2VpREVPbyhPMgp6RT1zQ0xUfWtPaVRlUUZjT0RBaF97Mzw4 YU96dyoqMXhKYDdjMEgqPjkoUXFfR1ZLa1MyTlg+K1ZoLU1VKn03MFQKenNuKkc7MTJNUThzZykp U1V+UXdGVFd0aztwXmN8Zjg5YD5ebU00PSVMb3hGXzJBYnliWjBPZzB2ITw9UDlWIyZGCnpDRWV2 TlVLfH5rZFJ5QVRSbWtDQnBYI1ZRT2stb0pGZnFDQ3NBeCs0R3x3K0E8JTZeVmJae3RYNXxfaVJD NlRTIwp6UUxKWXxyJkRAb25aUEdgeWJNPUcoak9DKi1Wd31wOEdJR1hfeGV2bl80N3VyNXNMSTtU ZmdCa1Y0THE+XzFKSXkKemxjTzJ7PkxIeFJQaCt0XkowR21aV158PHMmSHJKI3JrYSU5PFhLTzNy WDBid14mc094PVVXRF82MnJWRzZYKHthCnozOytRJVBIUXo/dnJnV3NPfkIrb1pwbmA9MXVKVUct dWMyOSVSVG9felVoTDl1d0d4I2F7SXlxKnAkNzFTSiRpQAp6IT9lV2VteiFZfU0lJGloODdpej5w OWE2cTI0TEJIdSpwek5mRSNxdjN5JDhyPkZSaVo2JDFXQE0tbmp8ciUwd1EKejN6VllUdFBmZyZQ LTljeWc+JENoZmR3Xi1hVlFjMzZHZXUzaTs8TVFKSm1INVJWZXFeb2xwPXJ5T3x+byZeYGcjCnpL eGleMzQ+Q1dHYlArJlUpVVNKVi0tfmV5U1Y1aFlWYHhqeWF3Jn09O05uTU9WZGgxU3JmSCRZLX1H dzxhaSNoZwp6RH5+bCNkanx7a3B+T1o+cVBBSno9KTFYd0NrcyNCSDNUJGhlPVA5b2hadFdOKVlF RzA2dEN1LTlxPnotKkF4ZFEKenMtfnl9a29xLUxUOG9mY3VjSUxFc3YrKnRaWnphM292JGQkb3oy fn1XOCR0dmtjfipuQzYoNUNpS0BsdDc/NGs8CnpSTDI8KXgoPyphVFBRZiM4ODBsWFExXlh9elZW Si1eNUchNUkjRXQ9PWZWX0l5OFc4Yl5KJng4eDNvUzFOJnptJAp6KjkpXnRNVVFSeWxvJUBNeH5a QHY7NXB1WV5iaDR9bFdCdz56NEkwfSRyWEt4ckQ9IStHJUAjTlNLUzxJLUBQdDgKekVgSXdobjUq UyFyKmZlUCE9Sy0jJSo+JUNVPX4+anRHbnhhQDQjPH1LPCohbXJvOVM7X0tqMkQhdzFARkVMezBs CnpfYUUydnluRXU8UHdVQ1F7UkZOVklKI3g+OU00V2lJMjd2Pkd9YylLdHVWdylCPktIJEd4fVgq OEhATldLcVA1ZQp6WXhKakVVPHtvfEtFZyQkNzEwK0gqcSN2amAqXitFY1YlYE5aej9qKmsxK35G Z0NTOT5ZJE40dVYtJGErV0VhVXcKeiQrOFpDbGgzYUhJQF5DdktIV3tvNFZAZXZMYURrIUo7Vk1r Jj4raTd0fTFtQ3Q1Pk1ePlQtTyQ9OGYjRmZuZ1cjCno/JTlmZyohckxmRUdxPFlgVXM1Ty02Q3ht IX1JLV5FSzBYY2RkdSpAKzlnVy0qN3JfQyEwTEo8LT8/fCsrYUFBbwp6RzQ1VTRmZmxga3dJN34w dU1Ua1BrISY1eGBnYT0mTkBRaThIajE5Tmd2U3g3NV5nZkotI3Uzeit9LUhqSk0rPkgKelo8b1Jo UntkZ0xUJSZZTXhSS3xAS1RHJkx3KHpWbDBGekYjUm98dzQlOE1rfEZqbWtNVUYxaTQ7e3gjc0d5 UigrCnooeHhaNkhRX2JkV3A8OD5YU0FEMllDMXhpNjIrYCtUbFMlKSR1WCg/c0NpOGNLfSNaVDBt Oz9MaSNNJVc0JShnTwp6UExNPiZBbTdZd0NrVzVLXnEhNlFyciQ2emRFb2V7PDZ8UmlUdS1MISNX JE1VTjtCNDN5YDwtU1BoJXthfExQZloKeipwa25yU3AwT3tTUEhOSEFAaHNgeDghfXFzTStVVl41 QE9OVk99Yyg0N1FmUkhrU0V8a3V9PyNWViU0e0w4N2c2CnpLVTclUS1+cjxuSHYzVHorNHJhdmcr fXNlWmNrSHU4PCl6ZTJxO1pYY3ktM0JNNFhocmNackxmaEFyLWQpKUIwLQp6U1NLNTZ7JlJuREBl Rj43VDNPblN4I29+UFJxdjRaeituZWYkazI5JDx5WSZLaktyJWo7ZXlXNEM4O2NSX3dhIVgKeip7 QUg8dSFgXzEwN30mJEtBfjVGOWVMMjJ4KGBteXROPH53RitNSCsjfXpwP05RTFdyNEB1eU1XJCRZ VStnYkl+Cnp4SjZnRHl4UjBDYnpnbTw3aFUlOTMreUBWKDczXncyblJwO3F6ZyFFRlhJJiNtQzR0 MCgjYXBBVTAqV0wmY1pgXgp6R2xMQVVCTCRjU2daU1JfWH1LRGxyekBXeGlLT1p1ZDB9Xk5NVipk R05odk5DQTtXR3M5dk1fUUNCZGpxMXBGUm4Kel9rVEs9ZUlqe3NQMnZBU3d3JT9VLWoyTyQoVUo/ dWdUK1Y3PmYoY1JNWXdtaUljKTwjIX05dmBENlRje19wb3VVCnpvWDApKl4+OCordXBmOGl3JEAj dE1oWnJ9XyFPZjMjYj8+WXdAPnhIQjl0MGdtTmR+SG8tKDNoKztyX0RWdGpTQQp6em4qPiE1TG82 alp+QTI7NSoxbzRJfmNXO2lielI7X3NgOX1aUGRPZHZHSCNedSVMaDlmIzB0c2NDJHYmeyg1NlQK ekVBdk01KkRJTXBvJk1BVC02eFVfV05+P1lmQ1hKQitObyM+eDVWWkdfM0tKYXFZNGtaZnM9UyZw SzJnSnlJbm9WCnpNIzB+I0NHbERnM1d5SDxUMFRnb2E0Y2NlU0Bfe0BvdzA0cGAqRl4yJjFoQVBt Q3oleClNdUIhXyo5Ky1FcU8rSQp6cj1APU9UcD8qKzhGJiRlMkgtYGpDRXNxPm5XWldMMm8tOEx5 ODJmMCpmbV40T2IyMGdnKGZiMjdHSWVVKmFqIVgKemZOYzxQLVhke2I3amFSZCYlQmBOPGxYQ2Rj YmJCenpkT0J+S1V7ZntUeUY2VTx5UUltOUI3LVBkcnVFUGNKNGxtCnojV3h3MTVWTldCUnRaMjNh ZnNMSmZkWW0mY3Q1Sld7QFNxb2ZiZj0rYW1JMzI2eDI4JDBJeSk9SGpCK25QekFeVQp6MmE9ZENM RFQ5bmBRO35WdykyKTFmMFhmRU9tdHEjTEphKSRNNl8yYnxMSmZmVEAwOXRZV35NaEtHOTUxazso WFcKekZGOUs7cTJTaWlBXkUyckYzfCR7amYqTCoqfH5Xd2ZneVA2XyFsMnJldyFqfTRMWjV5dkde O1JpXzlhPG40K0RSCno2NDliSy10eGg0QSFuQVl5aFM1cCRRRFl0P3RuI2Yodk9VNDJ5IW07Xz8/ djktQVgoNlpBM3hePTttXjx1VXNMMgp6O0VtZVNaPFc4QjlaYiE8ZWAlbEVrPUk1cGxxPUhDdT5m eVhyJGR1bFQ4KUxHOVlsPXN2SFpXfWl7OyklJWUlc0AKemkpZkJZPylRfFUqYms2el5qKFZpdWdh RUJHPiNWWUVoOVpPSHZaQU0tJT5RYUxlSSgrJEw3MmVhdCgyemxueDdNCnpyaz5UbHp0d2hxZFVM NW16NU9USntgY3BlQHtmZHo8WU92K1pYUyhxRUZPViU5bmRGKnh4PVF7e3lseXNMNShzeQp6TWcx K1dwcE9zeTlnRmxuMSRoclFUPWtgMV4rJH43ZFBrPXorQ09XM14rN21MYy1MLXAqWC1VUUtvcGVJ UzhKKz4KejxmciVZU054WjdfVTg1SEteIylPbEllan4/RUowamhNRXx+PWl7d31oSjAyS0dPQVNX VTNTWHdQTXMqYk4xQ3BoCnpBRWJsJHBKPjJrTVhnRTJFTUJZMEtlIyR6d1RjTG5QYitsJiQ5eW5h QF50MENzPSZ6JmRLflg5dElLQ3FHUkwxTAp6Wj9EQExeVDcyPz4wI2JpQHsqdkptPW5oVW4oJGp8 anhVM1k/ViM7ez48UWxfak1WRFFSVDFsTG5idiRRPGN8WW0KeilJYGIkOXJTa3wtJkdONVBKMV9A WCpXbjhwdH02VXJobH5aU1VHfFV4Mkc+a3NnQjhxRnV5fS1AeEFNV15yK1ZsCnpKXl5XXlcwaUUl NFE5ezRfbzwjVmMtZD83WVJfQ1R6SEZsITl+SVg7ZyFsYFMle1RtNHp+M2YoQXstd25FNlZ3egp6 QylzYmZTQnZtRmtDPEhMTDkwQnUlSUtLTDxZXzlPbEwyNjAkT1gtTEBrfH1yQU1NfmpEYW14U254 bkUzbF4zKSsKelltbU8tbFg+dj1EM3ZKfk9OPiNvbDZyJm85bGF+WUA3YXg/amVQP0QoO1ZwTlA8 cyQxV0gkVkJxdzcwUXYqa28+CnpNZ3BHcXwwNFJOZ0RAb2EtTWBlQkk+ZT4ldyQzVXN2JHh4dmo3 bWczMjxCZCs4VWlPKmhHUUhNNWRMMnxjZiZTaAp6I0hRVll2SGVxcHBmYUJTQyFkVlN2e0IpSEQ7 dCM9JiUpPUY+fDkmeVBWfUIhXmg7cT9OIy00Xl5aTzc3fEFVQjYKek9HPnlWJEdae0NTem8/QlQ3 PkNSTF5YT1dHR1IlOTlPciNhdH1kVF4lZVVFfU9fcHBoRkwyPj03PVIqU3R1bmJQCnpDc3RJM3VJ QjFWWlN3PkhJdEZfZTIqKmpxPDdmOG1vUTklZGhiSDRme2dCS2VWX2Q+Wnc9WXlDLUwlOWFMYn5v NAp6PHNSUFZ1bTZiM3QleTFoaG03eEJoUm58KHJZdSFAbj0/aTA2RGdZTzRsQUMjVTxGTkQpU0VZ bjU2QTB8TGw9eV4Kenhwc0E0ZH5WXmhPT1lBY05xckQoKF5wI21fYW0lcy0+bmt7bHtfenU/WGFi YWM+WWEmLXpHaUlmOFgzSFBVN05xCnpGRH5nUEt2aGtCT0MrfHJWM1c+eldXRXU4KmI4Y0ctZEVh fWdRej0lbHtmOU9kVmFvYChvfVc4OCZ3K30/c2N4PQp6IUA2IzAhQjZ+YzVFKGxDZzdaeVJASHBg RFZKfHZ3QiVNYUxJKWlCMT9FN2kzdmo0Ukc4bGVHb0A9UTA5R3p2aSoKektzWW5JeiFscitATlNp OXR8IyZiKCVrSj1CVGg/UXVuJW1kU19YT2ckPGBJeWM/fnQpKUZIfXRqbkR6WmotZk9UCnplQnpy a3NNTkc9bnk3PUMjcUxTQk5qPG9ESSRpVkZ2OT5NcXd+K0slM0d3UiEqOH1PJUFjanotQnE+Z0o4 UDA/cwp6elJjN3chdUM9aHlyNihJTzFuSCtlQGZwbGtjMHoqVFdQJUVKYVlCP2BGa1RXfEsmVSYj RXhodmElZXc7YSZfMGkKekhlSyNPelJKKXhkZ0NXO24/cU53O35DQVMweDR5VjspeTRgbFJ2O1B7 RWFoTHoxIyNtRz1BNjl0XiRMVDlwdWBDCnpBe1NVXyVHaDxfKXVeTiZeUChOWTQoIXhtK09ecW1j MWljIVVpJEt5WFNTczIkXzJiQGl9bFBscFNIXzJ7OU9afgp6cCQya3U4YGlJcjw1V312ZzFoPzd1 YFUlfGFsX2JDRnZafEp1MGRyOUwrczFKVSRPJlZ8NH0lJGZlMnh5Jm4kZmEKemFDZWFBcVd6amxt RUpDa0IqOHhAcUM2Pkd8RFE+c2dzPG92cDRAZWdHNzMhKGcxMDJCTFl2Vm92LWx8LUIjIVVzCnpD NiUlKWJ1M2ExYmM5PyhaeyU4fFkhb3JEQ3pROFM4TmRMb2gtdlhYR0tZOyNOTktYcjg5S09qa19E cE88WnZuUgp6YUM+TXgrYEZCPmdSWDtwV2k5I3BUWTNCMEApJWR0U216LVkxTC1mXlYkUzc7KVFW X3AtdEM1PUIzR082Y1E9eVAKemA8a3tHK0FmUT4jaWpXNEAmPyteP0VaUzduO2dpS2JeNj4pcEFr VU5SZzIpNSZPQCEwRFdCVGlZeVUrRSQlRiNqCno/RUhDfmlyREtHO0MmJjdUe1JObz5PNlNUeDIq eEh5QnA8VmxhSCVIbEtHPXVNYjkoZigoUkkmdGJDITJMaSl7Nwp6RjVzSmdWUXNJZGFOU1F4WT9G anNZYzdWaUgmNFkrZjUka2tPPkskSFYmK2s/PihyYCNKQkpxdSpBSHo7JEg+P0kKek1me081I1pR ZmtmOElfPExXSWctSDxQOTB2MSVBTEJ6ZT1vKntyJUk9Y1RFNCRQPiU3N19qS24tZjlZbHt8RilF CnpieWFTPz1UK2UheEAtJkkwb0RpYXwwP3tMM1luI0lLPDIlaCp2TyQ0STlsTjM2bmt8JSM3WUdh ZnhrO0NgPEBOKAp6KFdrLXpEYntVZGZIfldLIz5tJH1Ne2JAemd+eFI0Yn5TYFphTThYeCMjZ1NX KkZ9XjRWeHE3Y1h5cWF0RldQYEEKemZ6PX5ZSG51MGVmKCQyWEsjRyl5SW0wPSlTO1ErN0ppfkt1 MX1KKiRtRFk9WHIxTSUwSSshdD9gWlZ7IXxEYlVUCnptd1RKZUVhX2hXN3ItV35aQGp5YGoldHtE PFdwREBUfHIlU0dSUWA4YDc2fUhaOE9iVWJtQFFqVmZrQGdGfkFGSwp6ViE0WGAqRFQpNGR2fkI+ O3NRVHcqVVd2PTQ/XnBhRHpjTjhtX2drODBoSHpvbXw2dEl2cXdQXzU9czxvJn1oe0wKendaZHBt NFJJSVg3JUUwNSY1QEE0czI9ejZRJStiJCgtZVNvK3h2NCpPPGR4eytgQE15cjI4UTluNDI+fmJH R299CnpYUT4lfnh3Skl1VzM7TjdJMjdDJmNkb2RtMGFtVWhEZit6UnxNc2VadCpvS3p5IVNzUGpO NllwPV9+PHA8MWc4cAp6cXEmJXNRdld6RHkmfCRpdzQ5RHcwaiY8T0lYN0dvaiRKJmxZaiFxUkQ7 O2FwY28+PnxjK0VyaUxiOzV5dklVbF4KelY+ISRMRlE8XyhKTFctWUsjTEhXaW9tMFcyQz0pRXVx eiFNYkR1cmJ0Vlo2bShGakc+aVBhOWJuaVFaLWFDXjN2CnpnantmPkJvSVREWi1AK0hiQCtvejJs amQjNWFyTU9PUmgrQDJqITkhdSpmMXd8M010TClyYE9LPTQ1RU88eXExYAp6YkdGfnRKamRJZiR8 c3UoQXZeIW8kcjlmNjVZWTIxb2VjPVMma3BzSzRUMT1gZCVQdTkhRGFxeDQkRGVJN1BNWF4Kej08 SktzeDJeaGh5e01SQEYhbWNDSk9+R25tNm9NYCpvYj14ZjVSWCtEWHhCcTRLaUF5YmJ8bnBabl87 IWZLKSF1CnpSQyR0Nl5EaCsobFhGZGBzUU1sfG5IMX5yWnhMYVV2IVZrN0w8bmkqeDZXYDBDeDZ+ QTVvS1goYFNzJl5RYmFTawp6Nj14VWYwUyRARHpkblBKZE5fWTFgUDwpTm1jMSlVZkp4OVQ1QmdU Ql5qTSh6KVpCOHo8bnF5ckFpeXpMakJJT2IKejF5blBHRElpfUF6YGJefWpRIThHfDVIJSN0MD18 KTtzTncjWUZeK3NjLT9tQnhmMl92Uj57cylYSX45bE08UzAqCnpyP3F1ejBjZEpkbDB0YVcrd1JD IW9lbm07YmluITNQeH1eWDY2czh0OWhffTlndDErTXdma2FNQmVgaD5KWnBGbgp6TFZ4b2tVO0k8 e1B3TSVONk9SNXNAaEh3UkkyWHclX0QyJG5Rb2pld2RAVzQwKC1KQUB7NlE4dERhbmkjSlFGYX4K em08RjdfdkRIZzIwdjlqOyZCTDJzM21jTEdyIU9XTnA/bCYwXlNPeExVZG9BaWt4bE5qaVRfKENA QkVmQCo2QU1VCnpVUF8rQWJuUz1zRm5WQ3lvQkp0QGBVP2JZSCh1PD0kK25hJTNUZlVMS0BZemo9 ZDxxKjNteSFqaTl3LTZrb0k1dQp6amdsfCRnaDB7JUc8ZFQzQnJyQDlfQ1U5anUydGUhSlh6Pm83 IzQ5QjBfIWU/K0QtRSZET2E4e2A9P1hwI2MyTT4KenYxejEtJFE8Qig/bm5kaDxae3tUcFI7M3Zp KkVKWEdIPTBzXkd6KWVaXiVsRXwzQz0/ek5OVFRiIT8mcDk3QFZRCnpQKX5LezYyXlUmLVdQam9Q XjZsTmF3JUtFWHg4KjJFWG5FMFclPlNqRTFjU0tKM3QpJWlBXjF4UFBLajNKYDRsNgp6bGpTc2Vz YTJicnIyRWc/e1lKQX5oNz5RUih2OW8tNFRRIVdUfkk2Z3FaSTh7bXlJNHg1K3xIQyNkb3pBKT9A bTwKem80R1RRczJ7Smd4dVZHNERJaHlvYk5zeDlEY1gqbkZlPmVQaF8yQCVKUzZHNypHWnR5VUw9 MDxKZCEhUl9wbHZiCno5byRFJCpgbl5AV083c198MTNxfnV6OGg7I3NWel55QERnMTllJHBzN3tH dzZGZysqZUg/PVFwbVpPbGdleF9AZwp6RyFXdzNVJCs3ZitJQnJgP29wSFZMdFFHNXRlOzVVVTV6 em87Kms3YHliPHBpOVBCKjZsRUsqQyVEcFJQPCs7Wl8KemRmeSFQOH1nRlczPEswaHhQNjEwUzg3 eXlYd0k7dnM+SF5jck4lKj9GXlJCMnNzbjxmWm12ckxkUnc+VHMjcHltCnpaNXgrYVJ0dS11SVVu SUpWaFQ0SSh1R2o8Xns+dl9Dfl96PSE1bz1DWW9xQEthRnNVITAoaGMzQmkqeUVLdyoqdwp6ezRG fH0mKn5NVSk7YlNTUlZVUExnJV9zc096V2diTmsxJTNtVmpKKXVob0tkTjdySmhQJDdWeiFQd1FI MzRYNFcKeklhanpCejktfEd8SCZ2TjlLWiVUKXJ+PktxMyNqcWlaT0JiJVp2UE5uWHojeVV8NjhT WVZtSkMqSCtPaGR1TiV2CnpaNURudypNazE8byg5dF9eeUVBcCtHVHstSCZNM29PVjBleW4hMFpz aHw3R31HU3UreT1IVXxCKyhmZDs1Kl57Zwp6JkNnMEZ7fSRHMEJlYFhwJD9TTEcmOCtedlJrTTgj RmYoNzVqfCVJajAyXlcxeUtHVHB7YFJiKzBqPkQlKGZlSm8KejlOflZIT2NESlNpbGFpVGNQbnlC WkZRVlh4eCk9MEh1Njw8NyFPbTtVO1d+aHBBeipMTm9sbXJ6Q0tTZ3RzO0hWCnpGU1UrKlEhYWlQ JHB6ME42SVolMXgrKk13YDhocnt7Q01tK19rNVV8ZVdIIXVvWSR7RzZUKXdKaThuMXVPS1JrKAp6 S009fEYwQmkhPzM+SG0zKmpJTVIpa1ROOyV6Mmw3K1U1UXZLOVVAMVdnSyNmJDMkU0BWaWZxd3l1 I301Q29QQz0KeilZYTJBeCNyRyFndDFfSmRxTkA5UzxxJD1GSmstKUNDNWxEZi0he2h4RSE1fWpx OUNIdmVCJHUhYiFhNXpIM249CnpfeG5uPDdNIUJGe31OcHY/YllPVzBXYGw3JCl+b3l6aDBAIU1M WVVvKkdMSFBKXmNYP2NfaiYmMXwpM3RpZzB5aAp6OXVwUDF6Vz48QTN+T2M7QDY8fk49eHhoczEm PXdxbm84PEtiOTVJV2IlXzd7OE1Ubzt7cXM8VDVAWHdFUXJUbmEKeis2KFZad1R8QD49e3kxRD8/ fnkoPEZPKWc0Kzc5NmtfUH1oXzYwUzNgNXNMOTA+Q3poc2REKm1ieChSfmA9Nmw5Cnp7Z0loUnV6 MTBsNkBgPXtNTlkyY28yZjk8en5SenZXOEFTenc1ISk0IzIrPGRiRXZoej5YLVZ7NVZ5e2xEQCR4 MQp6O0A5K0drKk5MeV5YZTM+SE9ubFE4MjxKQmVuZ0klPld2Y3hjVGU5eDZZfDxmS040bUM0YlZU ODZ1YF98ej97b20KekpMTUprcnMhQGFeIzgwMHhlKW96Rnc2bkNYYX45JjY/KHI5TCFXIyFzZkN4 Jiste1F4Tm1+Iz50LT5CbXU7fno4Cno0RW9rbyR0ZTAyOTRnUXJqP1VPNjR9Vy1gMiVVUVRxMy1L MkFianBLIVM+fUM3Kl92ISEzcFo0ZzFxTmhmZzUoegp6amNxd35PZ2h5Pj9lajVrIzh0Q2U+eG9j VkY9RWNvYz45KiZkMDd6flRRVHtaSkx7UzluQ0twUnxMZmE0aE9pO3YKej9iSEhVSVJ4a0g8e0gp Y1p4KjJhRUBSTUdmRD88MHFJX2VATDIoMnNTek1zPk0+bm1qY2JqUmtAXzs+SWxrSWR+CnpBYjUy RHRFbjg8aFNeNW0zRFFOfERfRkYwRj9eYkp3KmohTG99bWJlNnx0Rj83dGx3P199UDBrSTxjR0pQ ckNVXwp6V01mSV5MKGNmdmRtcjsteTJKfHNHcHp1SzdKdkhNMSFhJD13ZjRCdnJGPl4lbiMwVC00 e19FJjVFcVB1eHZmTnkKejVwQz4jOVpjX0xpJmowPmlLVDF3O3dWPH1nLShFQS1EQylqM1VaeHU7 Q0U/eSVZM3hJRFYlPSlUZXk9LUlZM3poCnp7PUsmaiMxZ3RvR1hzYGJCejAmWXhOIXhheC1me0kk ITBXZi1qSlcjaGM+PFM0NXFNPyskVEM0LUEtdCUtdyp2bAp6IztjU1VDcktoMUZYcj1kUkctNTJA TTlOczt0IWZLMC1ieis2TH1oISY7JlEpKFgqbUpWUz9KVWR3OzskT09kdU4KeiphX2ZTNkZpal5k dV9sQ050Mm9xVz5Xc1gmZzNpYHRWaT88I0FDQm5RNlQjRyE3NH4jezI1eUByIzwyRnA2Tyl+Cnpl eUszeUpnPisoayhIZVJHbiFYR2tVb0laWG1aOXphUmgkTilwOFdQTlcxcE9FN0l9VFB7SXJwRlFo I35wMCRIIwp6LW4xKDJKMUo+b3Mkdm87MEZvI2xCejQ4P25lVWduSF9PS01ILXFTbF5rOVNUeF5o Qlktfn4yV1VeNll6YUUjdEUKekwtV2RLN2RpQSRzYHI5X0ktemNpIWtEeT1QOX5peE5naDM9VmM2 KCkyTzE3bjw0SVpPaCN6VWk2SCNZe2hjZEFjCno0ZS1FKndtfnNjPGFUaEprKW05OT5pPX5vdFE3 QEpPWGxycDFfKjhFWkdpMUVNI2hfMXtoUHdGWFdFTzUkPlQpRAp6em9KeXVrOEpEZEp0TjErJDh0 Snl3TGYoUU9RdnZ7eVc4WigyeF4+Uk8+ZGNtOGEhTmNsPWNMJFlqb1kkPiU+aigKej1+Xz4rWGkz UHYzNGJYWVVCbjtQYW1tSk02OztfOGRoMlN2OU89MHx7dUFeOVFmMlRKUF9pY1VIY1dlb3ZgZy1i CnpmOyghWTB9fU1fPWZ3NmFMUCRBPD8+QGAyUGFpQG1pb1MtJWNNU3k2aD5tPiZuQjxDMDY/Z3Il eXRFSDltQjdFaQp6cnY3I1MpIShJREUkfj03aGQmY2xTeWp7bHFDXkcpNWhjVTsjaWNeTFZEY0sl RWAwd34keyM3RWdiTzUpNUdEZ3cKeiZwe1N3MU5WLX1keXZfRSRMTWNaOzFtdyFGODF7fnt2dX01 Qk19K0lWP2lkPzk2WSRAaygmY203bjczTUZYPSRDCnpZMDtAczRSPj1xeDNsZVdQN2VMSGpKP2l9 QnYwRiZKM3tOVzJkZyMxV3VJPD9IWj9YTDxWTEdAZDFgeVZCamolNAp6UX5BfFpmbWhYdU4hXmg3 V3tPQX1fVSojYjUpT2JCSUhqQXRgWDkmTmNFJWN+P1A+WHJiTWt6aiV7UHJ6ZUZxJHIKeiRwN2J7 TUV4QjNRJm97M1c8WD9+dSk9JihgNzVhbkN6ZEIqWSZeODM0Yk1CaXB+QV5McFpGdjFXfkswWXYy PW9ACnpFWjNTUTsqRFJkUUojVzdeQjB7SWMjZjgjdEc5R2hVZiZXfjtLbnZkQTlQekUrTng8JmQ7 fWJpU21xVzRjWGY4OAp6Kjs5RU8tPF91Sko8WTZYNXJ4fit7ezIxUGd6TWk/TmZeKzBfJk41UHl8 MVd2MHV5fW50RENYI0BVZGs5Tn5WaysKemBremckO35BXj9fZ3RJPy10NW1wWTFaWj5jQ1VwRyY9 dElCaWUqfHAhPFB2KmxVQXVWRlQ1RE9GXzM+QEszc1MwCnpAYE1KU090PTlKMF8jQF5Mfi1Ofkl8 aE0xVmRsUzNxOFQlRjN9IUo+a2ZjWFB5ezx2UnY/MUZyMiZEOSokP0t7QAp6VXA9aHFnPlhZbjN0 M1JsVX1XdSheaGRveUg9N18/ayZkcUtCcn55blFBc2NMLXF4OVk3Iyh+KEdXZDhucFd1JHAKenw0 aU41NmJEYldnSCRgVFlhKiM2VDM/O1FaS2tEWC03SXhGJW5+Znw1cnBmM3QlT09lZ1FYcitGKEhE dU5BJjNrCnomVlhme2YkO1pjaUdgX2hHJTh9JVZuYU5wOHZoQnFEUWsrezZtIVkxQmkrVk5WfG9U KEFMKkU/Zzl3a3NATHVaOQp6ZThzOG57VE5HPVRJWl9MSF9tMkhven0yR2YzdTFlK3FQUGUtMCM7 QmFDNWJsb2dKIyRybUsoUUtHIyFYNUd5d1IKeipFZilTM0hTeXxDa0YxM2o9V2JARk1jOyhnYjRO Y1JneW9QK3o3JHNScmhkVWV3UigyKnZIQXZEbXdaaEpoP1FXCnpoXkRkQ01eR34yU1ZjUTR7X1RY QmZGa1Z+MFk/UTFXY21ma2hrYys4bEJaeU94PE0wPilFISFlbWliWlh5NGY0YQp6WkphbEJ7MElr bFFiJXVzWkJwNTB3O0pQXyZDeWpLNEJaXmc/azZfcjM2cSk9Q3dxS2RlcT1yVmd2fGtfRTM7QksK ekRPQmhkeCNHdEUre2xvTURFWnQwTVQoWFZKaXxqaVN0fGErSGNoenReKFZ6S3VuPjtoNnB4OX42 NTEoUk10VlFDCnpGRDFVcCM7JkpRIT9+UEMjPUdNViZ2ZXN2cCgydD48RlAqWkNadmJXVEomcXc7 cFlsU1d5MWRDU2k2cDByY0FPfgp6Uj1FOX53UUl9NmVWUzZ1R3hlcFQ7I0sqa0RiRnxqQCleREkr YW9QNzBFekRjUVVGQkgzSyM4VFZEJGtvQyZ5dWgKemIyeko4elJKbSE4Vm9wMlFCcTZ+czZTQGdH NypAZ0hBYT5JbipScSlIZUNwTW0rTjkqLT8kRE1NUDVTY15xO0UwCnpNUzJRKWxGbCFyUjtzQ2dB elIhRShhUk9fcylUdV5IaEI2R2pqN2ZEMSZfcT5URE0qLVhiQFl9eCYoTGd0ZW82eAp6KDBWIT47 WiFGd00zfGhJbDAqKFZSPVpwKWRqenNAaT1GbWc8elNxTi0pJiZFb0RMJCRSS3gzMSpFdVRSP1R+ I2UKekVeaUhiXy1FQE5QdWh1Wkk9bTR7b1drbWB2dD4jU0lUPjF6a1FKSXNPM0dGLUBKVkNzPy0j aHRmYTc/dSV9cn1pCnpncjdeP3s7VGdOb3ZlN0c4ZGQmdCZNa0JgN3VVJSotclA+S1clUEpEWE9t WUIrSlRteWpnWWxOS1ljQ01wXlApKQp6dHwjS05zK2JzUlV8fHZeekAobjRHRC15ayMwemdIXlM2 NkJKKGRxO3E5SHw3dWFiM0tPNHFpS2ZYWlh3X2VDMEQKenVJNEtybzAyYyZuP1FzflJuQnYmJlMx QHM2OUI4dE1GMWF5b1dnO0FEc15AfSEjVCQzIz5IdytVa1IjTTtAKmQ9CnpMKnpBOWFQR1NUI3Bz NGZLZ24taXtQS3l9PXpWTHNyKDJuXzxHa05KKS0kJj9CKmN6Szx+Sn1CMiZQPkFVSk9CRgp6ZDll O19CZE9Zdk9JQWhwby1Hb3N7WSZVIUVrNEojI3RvcnREKDFSdTtSND16cjR7QlZpR3U1WkdsQTF5 dTdMMz0KeiQ8V3ZiWU8+Z0I+bCVgenUyVGdYRCUjaipDZj07MmVMM3hPaztOSzcqTmZIZnZten1s PFpTZ1AjeWU7aihKR3NMCnope3BfRzxnakt3MlU/dXY7UnspenNibWRyR19VSmVwe3VKbThjQ3l5 PzgzVjBzdnVHJTVJYE9fOVVETWZIVGNVRgp6eVJ7bTV2V2gzVC0xdEEjbEZaeXBZNShXcWp1bXxS Pjd7KnEjbyZVPjJ1Vyl6WmwpeCkhd1M8MkdYbDRmVDhlQWMKemEkMChtan0tO1B3ITVERj91Ql4k eVFmbXBnWXBlPUotK2I0d0NHdEM+RCVfMEdHRFhOPXlXQE9RTyRJWW97QH5FCnpAcWd6QmB+JGBS fEk1alNabE0xNmE+fGlEUDUjNmVgP2pLaVVuYD9fUWcrIWtKVjc2MnZHdD1ydnB2fnYtPlMlSAp6 MDRKby1iQHVfUlhDOXN6PUtrdjg8REcwaVlAZCkqd0w8MypgVHgjazhxUnh3I1ZjfGhzXmBYelVs clVwaVlNQ0QKeklIMW5fWD5RPUskN0Q5Ml5vKXw3a15xNGpiKXd3KE5Gbkh3RzI0N05KWSp9UV5s OCVBe0FkRTxPTFRYWWs0IUA8CnpYQkRKWSFmTm8kTkNmTUo+NkhzJSYlTU9vbDtuQlN4SWw9VjlD cjVOdCV3d2l1c3QrUDI9LXJkZj5JcFVkRjNBcgp6RVVVcGdmWnBHTHItSnFGPSs4Nkg2RVU3U0BW TXdtTTFYWCZOYWdnaWo2SUUyXnpTVzd4RzVDcHsxczs8b3JYIyUKejBoPGB6b2FUMlBeUUpVYiRl KSEyaGQ3JTxDREtsZFJJJCZKJTQtRSlrVXdtUSZuQldafDJ2OWB5TjJibmd4NWg5Cno3NT9sRkBW I2EleHdtSHJjJlFoX1Uld05TPGFgTGExbylHTWN6az0oO31JbjZyLWI/cEZCcF4pbXQlSysrNmk9 QAp6cjRgb2N7RWIyLT4yfjs3JnV+VnA4NHV4P1RpTT9IX2p+KypDSUxPZTlWVjd3ZG1MR3FhVUpp KmZjOyFeQmhLem8Kenl5REM0elhSZCNWTkktYE8kPnZZeGtWOEBPNGIpO3AoLWc/MFlTNVhvdWpZ flNRV3BOU29jSEJwRSModkJLfDsyCnp2WChAaTdic2A7UiN6Y0NSeUlEfTgweyo4X3JCJlRpYDUp NT9SeTtVVEt6UytEX0BqYz9nOVRXXzRIWXl7QitaLQp6X3R6dlkyKXJ4VGVzUzFYbXtfbHtzSjdh d15zdXF+WjMqKnZEI15qY3NabkY3OFlrX3lFbS0kQG5qJl5EX1d0fEkKek9XcH4tP0ZFNXtwXjZW Z1VlKjk8TGVHcCUxTzhjcDIzbVB7IWJmdXw9PnpedTJkakhQMDhoUGVDZTt4QE4ldDt8CnpZJFdt RzJndn5jQnxkc21SY2QrcFlpeFltIzBOST02c1AyVGhZZHNXWFlEQntqbSMjazlBITNzVz5xMjZg YmY/Qwp6UXwrQlFAQih4Wk4lLTxjQzY0LTBnbTMtT0doQjAlWTAqSmleI2NzeSM+KmVKJHhNZFFM Njx+Tmg8VnAlOEpsU2oKekY1SjgrcFRHTzxPcmt7bXJYbHBfeSV3d2l4dCFBemJ1czZ4eEFFdzVp RTBTIVpadjRLVDZiKyVgUnIpb01mTTNnCnoodlZNZ2VkaHx4IT5ZVz9VNVE9Tld9eDc+UTA0QkN3 bWR1RCk1N3ZzKzhNfnQ4ZzF5bFlgXnBPYlFaUUd0WW8jUAp6JnR+TyF0bVY0ZShDWHotbiNHfSU5 Mk54XnpEb3hrN2heMjtVJC02XjxsakxNbGRTJCp7NjB4QilZN2VsME9wNyQKekkpQGglPGJjPXNY TDMyJlB7MlIyRVRgaS0wejt4fGEtMzAmcTRvWHF3ZmArRWNlVjB6U2NIVGM1e0h0NHxLXyVSCnp4 WmR7QTF9bipsUkliRnJDKWlZT2hYX2BsUCZTVVluMHZrQGQkVztheVdFaG0pdygqa0pOX1p2Rz1R fDx8QjxieAp6Ukd6QXlTZSp0NHlNRWJ1VDUjNllGSm92b1peelluPEhGTU9EKVMtXnMwdFdXKlhe Z2s7QmI5UjtoN1ctV0o7MUkKenJrTE1Xdz5gTldfOVc0NHNiWnVjVmw1PlkwWExZekxMO1pEUm1a Zk5TWH5nUz5pS3NlQXVFIUkyX2JETEZzTGVjCnpRTj0oejtGckR9di1nYEokNjV6SmdRNTtmUmBW WS0mNTxqRzklblklYEFiYTcobX5IdkE5X2dqezMtaiowTXgrWQp6VFFneyVVVjB8Nj1QJStZJEE3 eUBsYDhyKmUkKlUzO2MzNEhwZmU0TlY4RVUjVEM+TU9yMzBGNWxfXzQ5ekd2VmAKelZzPEpwWiQj fDMxWWhjaEE9PzM8UWV3QjY5VD5vRGYzTVBTLWZRdnFxNU5qJkZ5SHE4ZGozaGhaRkZTIWVMRFg+ CnpHPStzVXpDKSNtMDIldXd0a351Y1k2dVpuREN0c0lndSFyY24xQ1dAVzFpe1BlcVlRNDtBTzN7 O1Z9PVd6VHpLKQp6b0JKVVM0R0lfMkk+cnRhMTEkQC0jY0I3V3IjNjluYlIlaGBabSpTbzhaOSps U15USEtAJUVtbHYpe0I9UjtGQGEKelY5Pmp0Km8zfVpJZHB1fUN3SztBbjlNWTRWeTc4UHhMezs3 WFFvNz0rWUh1Oy1geFFoSytXYVU3bnt3I3t+cW5+Cno+YUVpYUZkKWFYTkVnVUszZiMtVyNqMGlZ Xlp8eWJnISs8XmBIdzR9RUI+QGB7PWxwcjl2dVVoRnA7JHtqMlItNgp6ME0yTlpZZUZKcjhzfXlS Nl9JXilLUVFFNUZPMj1iVllUWnlsRERfTlFXV3FCekNZUktfNF5WJVBIREojJmomRiEKelgzYlNw PzxmSUU5VVQmVmR6UmNvQ1A8MTVOdWFxP3dpMH1Pa0Q4QWFLWTNyRGBmJWtRSVlRJXFIb2tlXlZZ cWlCCnpPdEFffUlIT3J+QGxCT3JfV3pgJE8mOX1IU3Ekcy1RK19IRk59Y3JlbUZRVlNQR2xsPT19 VU54SGc9UEN0MFU3PAp6ej48TGl3P2tzQylBRUp0XyYxKURgfXpTSyU+dkNabGV+Y3VROFRzUXZ6 fG41az87ezl1dzFfRzlGUWRWeyhTbnIKelVaWnUoeD19eSlzNUYpX15JJTJWNTxreS1fbCNtZmBX bT5uRCthKWpvckFARyR8aGlETDw1aCtDSGkrUV4lMz1+CnpubmBUbFhNNGYzMGlzSDJMMWA7bz5a KVpQcjgtRnFobE9SU0ZBVGllMGIhJkhFelY7fmV2Xk4xZXpSUjw9bz5wcgp6biQ5MHFSREN5PFdx M1Y3M203c1dDUUswTWAjdkIlSWNAO05SYFRJTmk7bjszQHpoTjx5bX1RO29LMyVjTkFzNn4KenZ+ d3diRU4zWTtwTUFBJW5wWDE+SyYzemNJQHdtMXVgZmJeamlPU3d2MnI0ZU1kdlp5SiNEOXZkKms7 IVk0Zn5RCnpkZ0Jvd3Jgemkybm0pT19NbVBvOVpBZ0N0ZXAxPEhVPkhtelFnXylQQEE0ajdyQjdv Mj99VXVNZ1EzMyVNYVZBTQp6b0I3S0FALXxsVEtLdkkmPGJOezJvTEY9R1cpWEEoT3VFUGRKJndi YEtTJUVCd0N7R1llMXpgNC00dTFlakZGe3UKengxMW5VV1VtWkc0X2l5WnlEUzMoI1F0ZHFNdD57 LXQ5cDVgXiRBRTQxMnA9VTREcSF7OG9RWWp0PktfVEQ/YGl+CnpgNkplflFsSTJ2cigzYUlnezkl aVhGVmQ8a2l2fWxUQElyeVdKNXtwM3d3JkleVWkqVkMoQVI0ZTw5JipmSmtCOAp6aHQ0ejgqU0VY KHFsckxUSXtRRntWR3MzPFgwNylBdD1rWm94bWJjTjNWSkdMQWpZR0B7V2xjK2ExPEV4V3pJJjUK emZwcjRoJDhQNGgtbn5hYno5fk5tYTVSdTQrMFV2cURtNEFNZ15iaTRpO04yRTd8SVY5ZFVJOW94 YV9qWXtQKmV0CnppI1ZzZXk5dEVjckFucFR8SXJwOXhIeHJsaH5GemxlOyZhXyFzUiN2JWx6S2Qw Z0VQQGt0Tkh2SGMlNmkhO00rNgp6aXk0fih6aD53UHg4IXNJbWFKWipiJDwtJHBOQT5lMGVLND8/ OFBgaldSJmk+emJ8V242RitmY3VhPSNwS3FzQncKempAdzFYQkdVcTJwd0t7O2B7Y3shPjlvTT1X PHlreSM1UmlSMHRvPHJ0YCtRbkJqck4yZ2U1e24zfUc+I3F3b2FKCnphTzZJUHReaEV6WTUwPipW dzZ6SnRPdWJ1cSlXQ3VZPkIjfXVvb3FOQCtiWlJJRi0lZ2V0TXk3V0RtMX1WQXs5dQp6X3NeZ2VM fkJ0fG11JiR5YWFhP1g3e1RTVFhMZDY+V3E5QVFMWDY+Mlh5WkxpQ3g8N2toTFc+JS1oRVBlZDR1 REcKemhxdDV4VyhJYWtfYDNxKztxZ1UoWT5VRHhxekZjWko/d09+JkItNUEtfCtyIVNmJkNzMDhn bztvMDZOVk1jeyNQCnpETkYtIWkzKS0tQDdEP0pmcDtLX0ZmWCE2K1c9N0QyXlh3XilXREh6aWo9 TEc/ZiFxXkg7bG5XaSNCUig5fUJBbAp6JTJEOCo2eCZudlQpQV5pWTc1VTdKJGdnaCMmQXQlMGYq dFNWOzRQSU9JSVVZbUUtWj5scmkwSFNgPmpDJStueHwKelI5dEJuP0xjNVlrQjVKOW5AVj1EKD1v dD5sWFV8Oylgcnt1bTxyKnZrfHNtS0shYTVZXkRwZExOODVlVHZRUERUCno1RmRXTz59LVd8JHgk bTRjYjU7UWw4MHBPaEUjbnYqTU82STw/a2xoOyp9PWVLVW5KVEFUMCZMSj1eO0FYaWFjVgp6MzFG KkBFZF5YN2RLJl9QPSUhNDZ1PnRpdXMlVkJ8NkJzeCkydFlXKnt8cEwkVGBMNCNkcn4+THk0eVZR PFkxbm0KeiY7KERtPGMjP1g0Wm9WdnYhPDtOPXxnc1ZlSUR8YyhtKl4tbyghZU45YWJsYyZtPkk0 WSs4O3I4dDtDX3ZgRE1sCnpgSGFjPjROMy0kWW5sdG1CdiF+UmAtPU5DQ0h2MH5Lb2tANiMxayEm LUBmS01tTEopY3Jib3F4Syk4eH5eQzN+MQp6SHVKSFUrNm9WdGlteEpiUHRpbz1XNiRLeTBqdT8/ WWNSeDBPX3hYI2A2R1Bed1dBUjdCVURldXB1fn1MO2AkTEwKenQ2N0lkUm90NiErK2F+NGE3bllQ YVghdThXLUtKdE1Ua01ZKnNlPTB5KCRWZ3ZeMmw5PHtOI0chdWhLfFQ+Qzx1CnpmVSpmbyllbT9u TFpienJ1RkZkKlRDTS03MEg/T2NnT2peQFBiWiRRMjMhNmVXQmJHVj15d01pTCtMVnlBOT4kdQp6 e0NOMzI9O2ZQPXBTbCt6UHE0bmg5PjA4WXJUcGZkQiRET3I0PWhHNWpCbntyOSM9ZVBVPzhTYGBV V1NNbCQ2LTQKekd4PjJrd248T1QrYVB8OSNHandPJlYqNE1TRklhYWQwMlY0d3RkV1dMRGNnfU5I bUstNn1jaCpHd0koeysqWERICnpkbiUpXndYfSZ3TnxET2YtXih3Pl9tKmRxVlhuST5yOz8qWDRT IXBEezJjLW87UDh2TmhMfWFWbUVEe0E5aX49TAp6YG4we2tMUThCcHl6JkArKyg9N1FOXjkpWDZX PD9xTUFCP2lgJj1eSDwhOShJY1VpV0JTPDVqVHpHTD5OclBPKT4Kem9qOVdoVXI9fE9Ybk0pakA4 d1RFQ1NjUlopY1Z2eGFgQWopU2wofS1XX20ycHM0TytFITcyQjcrPXxobVYxUWwhCnpVaSpBaTU5 WClQP3tpNWZjKmUtQ3FoN1dCbmZtZEh6aSN6K1JGaSVucCg1JV9SWCVqeVJAfTNjUUBYaWJBQnpk IQp6VTAyREtOKmNLN3Z5ez9OLSh2YksyZzw7dyVwQ2dFUXBXdmRUQEpgMmg/TXdKR31qfDI2O3JG QHE+PlgyaDclfWcKenVKXzA3PEtJVmkrc0VFZkEhQSMxRHdMeU52PThJcFFmb0FfRSh8YEAxLUp9 NkNxVV48PTxJekBBKD1VJmAwY35xCnp3dTVtfSpLMCg1eSRgaks+YSUoZTV1JCNPeXw5YkZOZWMj NW9LQ2FhKDAkSTZDaCh0WXVZT2BFZUBzQHFtO0hDcwp6Uj84QElTdnNAYT1ORmNAJVBaKCo4MiE4 I29HREpzI3swQmt1Tkltbj5FcDlEbW9uRWJhKj5eI0VwPDJPRDJTKlQKejt3ZTwyTmhENDJMaWQt Q0FUTkF8WVVrayYteGJEfGBfa043PWclaEZIV1JhUUI/T0hNNmljdD1USDxFWXZwclU3CnpYNyR0 Vj5YdVQ+bXU7MiEwJHFZYmoqOy1pSj58UTVGISstOVJfM2RWIVo/QnlXTDJJNmNadHhnJiF4aXwm MTZhUwp6TyE0ZU5gVVQleUFIQXthJEZkUWxEM3tDenxINHozIXRBQDc4fHRnZzxEYWViZHJ+JWZX KClWbjRuTHI7TW45N1IKelBBU2N5YUFANnstKXxkMm1seiRLQGRQQHBgPG1vI0lGeWZBOVRxQz1N VDUrOXc8dVRjPFFpJnhDTTZIOGhHdXBoCnotMkt0I3Zua2p3JEdlM194T2MkbVJ6N2ZJdVdIPCQh Kz9eUlE8NzxwdH0yYmgtek8pSFJSJHNRcDxqaVMpbXdgJAp6cl9KQXQtb3BQO3M+Szd7PW8rfjVf MVE/bkl9Unl+eWlEaU5NRik0bkd7ZHg1emlPWCpoKCg2dm9wUmVPJV9ZNGcKejxjQHB2WHB4dkx4 Nlc2NmlHc1JtazZAZ1hJSWchNz9DPlI/Xz4/NWhMRDBVJi1uJlR7RE5nN1M2SmlZMllnR1JECnoq VEE+K2ZgNCs+ZUAqZCpGXjF0RTJ+fiR3ZWdyN2xUcTZASGNucCsyOCY/SkYjLXcoOWElWHV8YEYw eGJlPmk2NAp6X0lXJEghXn4yQWhjdi1ydkJKJWJ3eiZTPCNoZDhFXnZ3JjxSPWRSNWhIbXx7JD45 fUhlPyhUTkZ0ITlDWl9MPWgKell9LVhgWTRWKE5FOG1FeVRgdSREcHRXPUJ2JjNZKDNBK1M0ISU7 dGotN1RySFp0OFFDWUJoVWhtYmx4ZFFpUzFVCnp6JWZOMiYpREQ7Oyh4QW51RzVzUyQ7NysqUypy PE8raUl7fUcwJT9vZzFKK3VWekJfP1JPTXFHJFppNWBVKkQ1Twp6Pns3SExzRCElWCojWDs0SFp2 VjFsbF93TmwrP19YJU1mTX5vQ1R0NmAwYiVhQUBUXmtGVURgXjElWio3Q3o/OzwKenVfO31jNS04 VXd6eGI/UEliIytlR3ZrbiQmam12bmZBcU1KUnxhfkJCe1BDOU4qOEA1OG5SSlMmflQ/Q3hUdUgy Cno3anZRQXc9KX45aHlJNjA4Ukh8QD54cnNfKVE+ODhOVWsmYyUwJG1pK0RgVmBafSs8QW1DZiRQ MSQmNjNkZ21TMgp6P0EzVUJgczlEcUpUSGoqT3hpNnNHfUdyVzNseVhHbyVzVXpJZ3tEbWZyaDIw QkNkWDY8cnIyZCZnNS00Mj12ZFUKekBjTyZJPkw9b3J5RkIhSUJEfldtcSN0V3pUPHRYaWsyWkR6 ckJRWVgzMVkwSms1NThYPDB1PnU5cyN1R3l8bUBCCnopSVhPIT85eXhTOWQzQCNLe3JnVG49czFq JGJQP0c5PzlkWipoPlRJSzFyN3F1ZTNGPT94RVg2MGo7c1RTSmI3bAp6eztrZDVlczhNJl45OTg1 T149QHtaPi1KUSl1T2V7U0g8RiR2aT5ubUJEdWZMNjVOSEc0U2pQQjY3blR0ZVJzb2YKekh5UXYz aVc1aDxBUGwjUnhRNjM5OU1lP05lT2I8NSg/Mj97TkVedyFUQ35wO0Q3PilCP29gKy05IWEpaSVU NkNrCnppJk1QMSpfeVRmPmNxWVVHUClae2V6bmBuPkJYfVdoPWNeezJBdH56M0xHcHJyPUM0aUlA S0VxPikoczlEYWJ5JQp6UVRMdGpee3V8XzBMP1BDTzBHRENnSUJGVVNLdyQ1e2xneEZAQ0Q8e2xT KGwme0ItblA+UkQ2byo+TzljJnUtaUcKekB9Yj0xOCRpZih6ViUmMU5xSTEtd0NNWHY/NEcteGct I3ZCJjdvcWkmOG1HfVpxU2JDMHV1K18lVEpmMGhLTXhFCnooS0VGO3Z+RFJoK3B2XkFlajI0M24w anktYUNpeVkzdTtwTHQpK3txe01jP3ViNUpodnMjdUB8fDhtd2A5SkQ4dQp6STMzZCRnUl9mP3d2 fkFBUEFONWRwZTVhLSMoYUEtPEFrMVo0bitTVHZkO2NSTyk0IW1gaVRAdzU2cUIqNFVAU1AKemx6 ODFYRSV3P2pRXz5XflJmRERwJlNDaFZUNnMlPihGJF93bkw7Y00hZGZQZCNSZEUrWUglKyV5WHRi MXh4aS1iCnpFJUJQSSNIT2pSdjw1bkMzZyQ1IUQ2ejQ8VjNDO1k+NSU2R0MlUm9GO2BCeH1gM340 Rm16byRqSG5maHJzZVgpbwp6YzNYRyRlTDhTRyM5X0pDdlgramExIWRRTVZiQEpIdXA4dC1GYH5N fTZGfEdTNkFZPC0oQFFtST5yNkhKNyh9I2cKelQteUpYO0lOVzFGeFQ9K2VfdUJVNFhtTDFVT19u RGNMMkBeRTxWcmh3TUFxNDNvb2k/b0xqVkJvX1ZHMWEoWXQtCnpzUHZzdUE5ZjQ3PkhBc2pjMj9S UVBBZVMzVzBHQUFnZEYzeHRvaCkmUzt5OGFsR09kWFI5aUZHOExCPjYhZyRraQp6PDxsP3NqJDdu bmopfj01Rms1cnc8STRLJVBKbW59ZnBycEleI1o5IyMqXlgkQTdSUUZmK209Zjk8YSNILSRgaDEK ejkoZ0h8clpsQWs3YkJza1YpUGVPX3dOfjYkbVo2fU5hJi1yMUlUeTZ4KzNlVD1OZ0pOJVg3bEQ3 ZiMqIV5teHZ6CnpWZC1qYWE3KEl2Y0lgWkV5P0pgSi1MYi08QSl0JnArQWZPTGRkYmNqJiFDeGFk MlQ7WUU/UlBAYHVrdk1eV1Jpewp6SDIrdiY7YkQtWFVmZGJWdWJwWnA9PWhgWndSZVFlOXZ5TUY5 PXtZWSU5cD96N0IhbV9LSUhYQGtfbW5IZyskUEkKemRDbEcqT2NYVn0wdH1Vd0dYNyhYQSpDRkkz VXBnRztRa0t2Y3Y+PWNKSTFVTmMpY2ZPZkwxbFdoVjJJNHRWbiVDCnpRezB7Sk9iNER6ODV5QUtA QWo1PDFDZjJaeUlYZlk7UGR1YksyITlUKDtaeHwhc0AzQWRQXkxDI1RWeDhVMVlSfAp6VDkmXnwm TXI7eUc7U0A9Q3wrXnd1Wko5cShZc2BIQktePWpyZV8jM0lgLX5Fe2hkM0I7Ul43K2xBWiVZbSU4 dWIKekooOUN+dj8pQXZUc3toR1M4PW58TSNeRzZeP3dxUkljNmlBc0A4X3peWW0ySnomVEk2Titv USg3bGprY3BsTk5sCnplRHBxeXU5KnN4aitQPSEoPlUhdWt0NDkkMnElUEBAd0d4WGU+dk8+cjck S3o9YWRXVnk3em0taW5EQi1PM05xQAp6K04jX3x6aEdxN2t3NVAwUj8oWTImYVVRKVlESClTUTky cUprZm01VERvfkklWDQ0O21NI0ZVbTtRbXhBWlQrYT8KekVSPnNZcj52T29xRSlTNmRiYDQyJCV3 N2YyQV49NXo9Jig8PDtRNWRYZVotY0tiZUApZlpQNiFSeHpkalcmeV5pCno+eEU4Nzs3Jjd0P2Uq NCNhJV9Mb2poZlp5bUQ8cD9GT0JXeXRLNy04VzZrSyMrJEB3X1ctWnVmQ2ZKcVNBTzFXRwp6SVpK MGkqYEJTSWNDfENqdjJZYzBVeUR7bXJveD82ZiVtY3p6PmJGWGkwKDwwVXRgfVM7IWNHT3Z8cnY3 TSFDSG0KeiFGMmV0dlQ7M289YiY/U2RBRkpEaWE3VGoobT1xM0hNeGkrVUZyPEw+dU1zZHl8K0ht UXdBY3NNQnsoOyN+OXI8CnpFbS0xaUZQeSZKcW03bHctOzVxTU9sT1M+Smo4aFhjTH0zMWhzcmVm TGQlRmQqUUtyajJeKmNleWU8e0NwV1dDKwp6ZjBUSTtWPC1uI3ZPSTF9LTR0JjdkK0pfei1pcFBr ZUU9MjlvSkJ6UTQoR1l2bmsrbXhHNEBDYl5jPl5aJFExYjgKeiF3RGpKYjktfiM+cEdvdUpxVGtY TkBnUU91d29IcjU7MGcpZTdIKkl4ezxwQVN8KWwwbDZXKChoTU4/eWk1WlNHCnpOeHA8Z3o7IW1e Pi1hOW9aQWRIZXclVGFfeU9rbXNCU1piMz4keldJan0wOCZhVmwpQ3pSWXBWS2BZc1U8PHE4Iwp6 bnpAKXE+PW1PXylxZm5jKT5QO2N5YGlAPDFxKU5wNDlAMl9GKUwpODdhNElPU2NsSHpNfSF+RSUl a3VxVTZMMigKelBUeFBjVnJqRj1gdS1xRDY2M2YjbXFkOFk5UnxEKkUqJndaSUJsJHNmMi1TYnQ9 LXNqQGR3X0ozMzM+bFp1VGstCnpDOT5BQ1lZSHdxcSp5TWdGRCM3ZWdgemNiZ2M5QzdqekdJOVpY OU13PW1CJW4rZyQ2aTIjVHxBWT15fVdDbm40WQp6WHY3QSkoeW1iRXEwUEhgUlVmPUo4ZEQoNGl7 YFR6SX5lWn47WEszKVomcGlSc2A+ZzJ3Zm5KKzlET0AmR0VBYD4Kej58SHRlMWxjM0k/OW4+a2Y0 NjlQTUNXREtfU0xBcWVzajtOT3o3I0NXaiZfYCpVRnBUWm11Sz1kNUBIQ3RnUnRNCnpXKnN8WEp4 KihpKFFqY192PlJ2ZEdIQ1k8XmdnQz9tRVdNZEg9MG9De3d+cG9DbDQqIVpZXk47WHE8Q09CWipk bgp6MEhpSH50cXwpNkMyLX42ZTB+NWQwYz5LZ1lpdD85RlhGX34+bWsyITtMa212T15EX0U4LSg9 djdSJjk4ezYrXiUKelYmaEx4cWZaKUYpT2smXzc9PW5vcUdlO3JSRVg1dD4+ckFOdnJtbCZOYnRz TFg5eHZteXh9PT9eNzFmPz9iPjRgCnpJVj9adiNLMzxvdGF8SG1fbkIxQUJKZUB+e1h+MT9BWis+ c3RRUW5BbDN5fm8+QzdsZjs/T3EtQyVeZzFReyt8bQp6Kl9rKTNBZzYhRnJ1WmdDaHVOb0JifFRA QCQlOHZyamw4RV9qMm9NMT4lbUklYGVZPCtHb0hfenBVNEZDPkJlYFQKejkrVnNOUSMreC1jXkdk MVojflpjZWlISEFFZTQ2P2U/SklsNSRyWCFaWENvLWs0OW57diZPWiM9Q3VUSDVAUDdGCnpZJGIw RntoIykoSilZX0l7WDBKRDVyI3IkdnJJP2xKVUtILShZR2luciMze0E5SCVUSGhuX05ybT4kUE1D NiMoRwp6JjZ5Y3RuUjFyJVBeUDdaWF50XzYtKUROQitWfVZXP35tVz5IR2deU3djVmZselY3UzM0 KV5ESnpwdzZ4Um1HbDUKektLY1FTdUd2fmFnc05pTGhsRTNzM00lWlNuTDVxTHNSdlhvcXI9OUlj S1c1KVlxTzlxTSlvWUVaeGlFTVJMeEJ4Cnp3fkc4ZWVNeEBoej1xJSRKfUhydWglYldKN1EtVWNL OWBMYWB4Y2oqNWY7bnFGYUpDZykwKDJ2VVRjQHdSJTIlcAp6eW95fFlaQj4hNyglNEluMykkOXVS M3hYUDdnRC03XjhtY2E4Z2h+RGFHTiU4YmI0OHI+LVZxbElPXmpJMlR7VUcKejg/fXxmJSZuVmAr KW0waXlxPWFoZGlDK0BGc3BIUV8rOU9BU209ISNSU3lHflBFU3UpaFU8TUUyTFBkfXAtVzdOCnpi ditvZDc8UiRzS1pXdmRDSyRFbnlYYkNRPDNfIz81a1QpTDc8PlN4UUppeDw7U0g5aDw5ckwzRTco c1VNe2VWOwp6UFBDJkdPIzQpckNMRT50X2gkdXJKMjh8dlNhKlleQ2B7NnAjQGVFWWp2Wl5ydUlr SkdAP1lRY1EzNzRhNjs5aiYKekRhX3QwWkNWX292I0VNTk1pfihqTzdiaUhVSGFjS0w5aXJZcChO RU9Se3Rte0BWVGlqS21TdjNWRlRCYkZZQHklCnokNngwOVFLeXdELWA4WExucGA3MG4pMUM+OHNo clZIRUVEKGI9UUhEVHFEYlhjKz5nRTYhNF9PKDtlViZeRz88ZQp6JEg9b2dKZ2ZZfWNiTXs9Izd+ ZFVhfXFvISFFK000O0IrJSk8YzAzTU9hY2cmY3pNPnBtbmtxXzdSckB3XkQrcnUKekNjIVZqYX1x byEhRStNNHQ0ZEFeJC1CdHF5MFBZNmJOX21rejtoQmpDLU1LKk4kbU57WUtEKGJYNm1eNDtqX0dW CnpUUiMrO2NUZFE+QztZIz9DO1ZKfSZNeEM7ZzJmbCp0TWFQNCtLQ3AoOUlsRjJwQyZrYiN9RV9w TUpgZm5jZE4/JQp6Kz41QU1mJDsjWCs3WXdrTXhuIXI2dEBefVcwPkZfMVh0NFBiSlNKZ2ZZVjBA TjVgdGl4PSh4S0RPN2c+JVFJLU0Keng2IVlBMVBWUUtoMnR5eihqa1ZKbD43SlptcCNQa1NmN01Q cDB4NVl8Sy16ISV3UGc8cmx6S3h7NEdrOyk2PW8rCnp3NndKN1o8NkM+RmUlKWRITUZGdVM8fXla MUpnKWdSMDh8bD9LbD94b1o0O2s0dldkUG1gT1JCN1hRVTcmVHkkOwp6QDVWSntGN3cwOUVRa0ch QT1CJHlfVzg7ZFIlJGQqMjFgNyNRWCFeSWZCQTk2N3E0RXY5digqTy0mfnAzYlFaZTEKenl1NiVh cTNsTmlqcFomUm5ham1+TGolKyZmazFVSVJvRUxlaXslcEpPSlN3UkVkOHNPKVVKSVJLbH10ejRf QSttCnprRWVmbm85d1p+OUhEcFM5MSY+bGQzUXx0Klc2dH1HMDtUc0IydX4wVCZ3bnhuV2x5WXYl dn5+bXNuUlIoeXFkTwp6YyEmdiZ1dGdjNXY0OCg2S01uUCZDaVlrVDBCR1BaUT16KyFTYyFCXzVk I0dwPk43dyhBa2Q2UTUmSVpgNDVwcTMKejBuOEFBMDBvYSZmMVkpQXdfeCN9UHJ2PSNPTVpiZlRn aXRmJntZNWRRY0lNZSRoKyZjYko/PiV3e28kPSU5eXF4Cno7YEpIT1grUDNKLXo/QXFHMiNtKCo0 QG1sUX1FeXAhYWM2JVVsdCZVKzlCTmxudERvTj5LYzB+e21WIVVecXlXSAp6OThhbUJVUEZgSWhY WFF5aUgyVndiMVFpZUtlViVtbVZ4Nj8wM21fP0FkTGo1KjdTRTRAYFF3P094R1NSc2hvK0QKekZ7 SyRgQzxlamJLN3gjekArTiU4JHkjdlZQUWgrdkItYmArbVlGaT9GYCMxNGopeGFrd2tRemQ/TD90 IUcyfWwxCnpEVS1SUzM9Pmp2Q0AzaHspfnxNdnlvUSEzeihQYXpgSDNHZih5MWs5M3BDI1ZNe3BJ c1IwPjYqWFBUcj44UUloVgp6LTVTeT02Rio5bGxuVjJuQ2hVenczS1ZrK3VsfHs1JjRfVDV2MEB0 eVU7elVBZz9+TmE7eHhHeyowNT4oY2JIV1IKenIkcEBFWj1Uc3wtZjt9cylUaiMoVDtAIWBuVn5D Ul5JSEN0RnNZTz1hKzxMKSFpPTNvPEQkMylCYHF8QmhXTXVGCnomR2lDc3dLXkYrK1BYJT5hdGxY YHl6P2V+SXBhNnsqWjg3JExsMUhJMEF+UmJOfGRKV1pDcF9wVH1BZnhVdmR8bwp6S1RuU14rQ0wr bGVFSHxCZnF5PV9NZnJ6fmdCdjl6cG9zN3F2Vj4mMFU+azdBU14kV2pVWTN7JjZJYkgpTWtBTlAK emJZZU5JSSNvbEg7KkNkK2FEYFpWZnIxazBnNXNhKzZXVzRRZysoSExYd1lBNDdCYmtuMSh4bGF5 OEc5ajAjQmBxCnpwOXolVWw4bGchNEE0UDlIZF5yQWMmb2pyc0hsZ1JtKUd+UGRaMW49UmVHOz0z WlUyRz17TVBuc1lrSGxzZzxMMwp6NWdWc1peOT5JNCFucXpAMDF1ZXxWJmhyd00wdGJhYG5jdztr Yj5hc3AzdVhzO3k8NGtINFJNRFhUclh9U259VTMKejFPK0RwXllreTRCflNlbCZfS0lAeFk+dkhC REBGdT1qPU9lVCFWc3dVVzlMfkV1fE5RRlhablkwP3hHdUJAeG17Cnptd3hvIXliNTZjKCNRfXJo UkZ0U09Ja0MqUjgmIW0zQXNMT2xjPUJ7U2JxXmNHLTViWVFffFluaVZVZFozKl5VZwp6cFVCTHU8 fWMoIzt6Xi1QWCNsUX5lVHhrYzlwVDMrNUtWYDdHayU5PGVodGFgcjZmX0pMTnBQUEBxPHRrMDls JDIKenBpan0ybExHe0lkYW1OeTdibjxHRVF0U04hRHNHRHApKl9XaE1Fb3VhajV5Q0dhcyRiPWUy T0dFOGs5Pk81YDdFCnp7YWxqc2FkYUlmTipjb2UtcFk8blh7ajdJUDtTYj8jTEAocyhfKmNEJF4l RzhyUkEzViVzVlJxPFBgUkc3dn13eQp6Rip0dFFnI1lRPUQoLVc5QVN5TEF3YWh0VGk7Uzs+bGFz dkpHM041KzMrOC1Zd3NAYCttKk0yOVZCcSVUdmM8anwKemZLQlpXTDhOZ2t7IXF8dW9FJHwkKHpA K2BJZmgmMmxmOFBPaSQxWH1aPEZgN2UwYHNYUmZPRmdEVyp9anp7QUt2CnpxV2M3NW1iakpkeWlB Tk0zI2psPDt+O0RTK3gobzJ4MGZgKSUjNU5pJXdmbVI2QkYxO2pBNDdzanhsJnNIYWkhdwp6bDZ6 MkJTMnRecSVDV248cjJlQ3ZZSSYkSWJobTk9THFvJlJPJmM7R2ZUJE05bjF6IUMxI1hiLTY7eWlR bD9RMj8Keit1fGI8SFE8MW97PGF1I2FOV00jY2RrNGVpWXY/VUV3TTAhRHBwWVNyZE5RajRmYHhg UH5XekFlNkY4U2ZBSGx3Cno+MyZIUVBBe3hQI25KQlJEb1lpX29IanpjXzQ0aHdqS1Q2KEhYT2Jk NEdGfW8mK19DPGRwaE9lcHlUQDNvdkp7Rgp6azVIPD84RmJDQD9BWEJHU35jVUJfcUt3OSFKPTlE RHYxdHh5K0xqM1JuR3omUXsoQzcqVkFWU2szT0pBZ0dOVGoKenp7dzhpTUVrJH0tUFBpKUlWYWcp SSFaPjRXfXZnflBCYmNpbE01anBJQChiV1Y1SEJCRTFEU2pSOGFJLWI7VCRwCnpJV2xPeGcwSHgx cXgoI3JidChXbzRNN2NObV59QWhwang2TXd4SntEITt0Tm92WkNuS0AybV5RREI0dyhsQDNzVgp6 b180a2pha0ZPaT5qd3FaUSNGYCNnSnU1cSVpbEN5JmlSPj8qQ2BDSmxjN2xsK0U9eGJSbXYpIWB1 JmsyUHJtZkkKei1LRD11QlZSa3s2OHVoWVJUbDJKb3Q/QGhmS35uZXo/UFRrbURLc3dudXpqXjNE MVJ8S3U1Z0ZwQUwkdXN0OzhuCnptWnNqJCUxWUZvVTA9LTZycit+KSowPih3XkRHUH44Xm8lZ0Ns JX4/eVEhKUU7SFpKdXtAYFVhMWlYVGQxeFghMgp6QV48UGp4WH16U1g1SlZHZUxQMGkzQ2s9Vz5C bSMzT1ZoUExQZFRyRmJebUQkJHRFR1YjI20tPEl9d0VmN1UqQHIKeileX1NxPzxKRTQzY3h5ZXU5 b0V+a3pSeGRzU05YSFJVZj9DaShHRVQ3VlRGZ0V9Un1EZFk0Qmh1OU9Ce3V4Rmc/CnpuTEA5Silm ekpKK2EqbUlLXzJAYDdGZHVIbWVuT09JWU81V0NFdzxtd1pydzl6WWB1RFchJWlDYDtmRzxCbkNF RAp6eC1qODY9REo0OXNjbUIyenxEQVppZSFyP253aGZeb1FsI2VYflBwWXpDRHw1X20rS1VIS1R0 VEdkKjt1QWRfK1YKendAdTZZWUZnTj4oTGByPFQjQkBfRHsqcWIjNk1rNm5GaGRRUlliJVVfNXNF VXllSlB1SytuQV5iUXxMdTQtRG5WCnpXK3FTPk8rbmtWQjw/QXlkJiooejxJR3FjQ1lLQ2tiVEd0 fiNmbSFBSSprUlBobnw9QHBkQlBRX09VKmp7PHEzIQp6dGteQWpINX4rJk5QWTJKVCNXb1ApanBW d3U0NDNLTGhpJSEtV0ctRDtGZzBuN0l6enVEcVNXSVghKCtXWVVEXnkKejJFUih6TG9IKiglJWg2 PjNEMXx8djFiclcjTG83SjwkJilXIX1KNCFQdzh2dm9gPkZ+VFEwQS0pSDtQVHptSHZiCnpxY3tE SWFQSGNWKm0zbDQwa3VmclklOEs2NU1rRGE9SGotUGp7IWdvSGsmO1ltTilnR3RgMiMlP1UxKWk5 fn1WcQp6YDVGVj1fdmlyYnlmKUAzTUR3OXlDQlRLLSFaRT4lJW57PF4+M25kJXE/d1d+Y3xLamNo bT8wSWBwbCZfV0BPTD0Kekd2UzBuKUA7dyQ+dUNAeXFwM2F6TWVrZitvfjZDRGI9RUkpM05eKX40 OVh2am97a3lIQSlGMT5STkFpQSYlX09sCnorMnE7P0J8JnlDbEgoUT11VENVV3w4cU8zSHplITBr cXlab3k8N1pSa3d8Z1JYfTZIQFEzUTJrPyZfdE5jdWBFJgp6IyY1ZXIlKlJWTXk1SUgmZXRBOW8k fmw7WG1zbkA4NFdtPWYmJVoweklPZGptO2ZIc2tJPVUqRDRuPlU/aVlSMDEKejt3VmVnUjkmUHF6 X30/IUw2ZzF3Qzc/IT9HRy00dEk2O05mMXRtLXdmTm5EQldqWWk2ZzhHQD8teklSSjYjWURhCnpg flcjfFQqTCR4ZG4wRFRDK0VgPiQ+JWxoPmVpX3t3KGpwZnRETnVmYzs1O216YkgreVcxfVNTPDQx ZlRKcUlYOAp6cERHWX0pUkQ1VylNRzBxdmsrRVdCOGd9aCE0MTRUcHJjSGEhJEI0QGFMZF87b342 Pk9NZVczMzNrVTclMkQxdnMKekY1YWxaP0N4ITtsRDhIKGgjN0g7Vn4yTlp8NSFWRlpmXkUlTkw7 UE0pZ0ZIWnlMUj43QWsrQzxze01RaVRgb1B6CnpGVTFeKyp5eVIzQjFTYz5Tbn1OdXdEUzlkcXN6 ZjlxTlJMTlY9IzRBZ2wyZzxWNVFWcSFDNn5YKV4oZE9wPHk9dAp6PDx6Q0FMRzlyVXZoPUFHSGpg TEg0eClNLXhia1YmbUJROzBDK0MxfXgwUzJ5R3BwOWkkJXk2VCs0fih+JnhabFgKentnSntpM28r SmwmMC12NyZ4cFR8ISlJRytjYWglOXMxNllxUXZ6UXdwXl92O3RPUWU/NUhOUz5XTlRZNWlnMllm CnpXNiZtNG48M0VDbytHYyFEM2IzaEM2eEZiWTMpOyVUdkk0MVc1ZE19SVFFMn5SPipOaWE3JDNg SUZlK31yJXliKQp6Z3dBKSplRTRYb1Z7djEod04qVUA1PTVgNndyI1huPnZyPzxCNG5aVCZkN001 VnojIzA+UjBeWDsjQD9eQ0RgNSMKenZNRVMqVGY2d3ItbEhCMUNzaWkkYnpfcFI5OUNqXzZaY1RH PGtXPUJWS0ZVN0IjaDU7MCNqJTVKU3w/c2BJP0pSCnojc1UrayFBSmVwNDlCSD5TWih7RDNiXmk1 UlVFJn13fCVaVjUjbTNOZGJmYTd3WTs1I2ZydnN4Ni0wdjtoVH1jTAp6bSUwSzJJQCR2UlQqUDNa T1F8RDdNckZ8SUstdTVYMU9zaWZRUyZsMVZZI31hSCpDWnFXO0FoRWExVH1UP0MwPWUKelpAVl55 cHZFVzhqNlZwe08oNHM1XzRIQHctY3g+KTFyR01+YHR0cyg+Pzt6TTNKJik2MSFXP2lyZjctOW5s N2hxCno1ZHkwNVVeYEJjYztLN0NldWx3Iz1QUFJ8USsxQ3JLbCNtX1JzcCZYLTFOYXhjSShXWkAz MF51TGQ+MXlWJWA2Ngp6VjtlV2M/cVk1PFRiUzY2dkokVlNYeCNqSWYpMD8/TDc2eTJtLX1EWDM9 RH0pYWFqUzwkYnp0eV9tNys+YE11XzMKekl0RmlAI3ZBJkVlJkxWWjhNRjg5PFVYaUtJdUxuMXRy QDN1cWBldWI1VH1HcWpTJXd7M1d5aGBNPUMxKDZuYXAxCnpYYWs4YFU8PnlkdmlCRHImJnI+P1Z5 S1A9Z0BrM0l2WkskO3hBIzJ+aXlmKFRBRXZLWmRFUH1KRXJLMWheTkZxKgp6b1h3PzwmNlV7TiVh PChoNntwZmU5RVoteXc2fl9lN2NDUGhYQkpuVENMVWcjZFo8Ulo8ZVY/a2hwTGs/OWVQKVcKeipW KG9pWHRgMjxGTVRYWXJBPGU7NUgpSUZCdkpfcFB8fGptd21lfHREeiZWKDBrRmktbUk7JWtzIyQ9 V0IjamdNCnpkeHo/SWw9ZHdyJkVTa2Nsc2c9djxqcUwkNzEkd1B1fHNpQWEtM3QldyglPittNzxE PDFacE9YWFpINlN2cG5lewp6OFZJTSl4VWtBOHtDU0plRThocHM8SWRxPUozN0U1eHlHb2NXJWg4 aHFhKWgrPFd0Kl4+QWwyOFpEV1ZAaT5EMk4KejFKQG1yPG14Y04rdXJ2WTdlJThxcEk5aWotKnh9 VGpGbGtrOT4yZ3dpbipBb185dmZmWlNQTSN6SU9PPVlLYlUpCnplaWdaaTBIYDBJaCEkaXRzcXxH ZEcmaDZsQ3w/Wl9OZFo3bGhXbVY+RykwSyswK3p8TnN7bU1maHR3VD52dmpQRwp6OH1FdSV8RmU5 QDxAPXI0KVNAdHRrJXgoVDg4PURMcSpHeHVYP25aaWpEbmVFa005X0tfSGEpXjRRU1Y9Vm5JdmwK eiFyIztXOUJwM0JrK31LNzIlckcqU3BKR19YXj4jPktmIUw/RnQhRUN7KlA5Xjc8MCRfPjYleCpw eTJ1eFZGbHByCnpoWXQ2VU81WFdjP0lpNFNHJkhAVVZNIXdZV2BYUT96UEFOVG9FJTRnI3led3FR QSNwRClqU3lUR3ckJFQ+alorSgp6dngxZj08Q0pIMkxifkd8UFN0I355endEUUYtPkNsK0tEUUZU cGdRPUVRdFRIdzshaGdzUWRScUk0big5WFBwe2sKekJ4OV9JbUxDUGNhY0tZeigzPFI+TlZ6O0s+ R3lCT3dnVlolalBSMH1AWj0qUHlEMWRUel89aFFTaDtwIThpclUzCnpPPT1reFJ7NmAwU28oQl93 aiFjcXtZMmdUMzZIUDFqWV59cillU1diI1FhSHBIdlctQDNMLVNMaXVSejxxYTIhQgp6SmZBJDhv PGFGQ3NBbiRgXlREd34pe2Q2aGNCVEM2cEI2JUMte01iOGZmZW88JFZecmU9I25CaT5WMGdRJFgy VjQKejR6PyNkQkFtaGMrLVR0SDtNbyhAdGtPWTNJeG4rVmMyalVySFFnRCs4SSRqfDsxKTY2O2E4 WS1tZnB3cUFNeVhGCnp4UFVKbFZQPzZ5NXVkUHooRn5haSp8OWUhJlVYPUBBQFNBUTtqYlAwKXMx VEdRYkZrX0NQSV9pWUNuUGQ8RWRJTQp6dFd+cmpVSVE/XiF0cDBzZ09MQHhlKlh+SXFTbn5AIyUy Tld5PFh6bypORVc5Uzs0Rjh2dTtOKFlhZzw5QF4jeyoKekI/Qmo2QSprYHprYlZeVT1xNnJmZk4q fTI/b2pvbC0yS0A9cEgqZnJPSyZzNTh4UipEXyhHMHNQRHlZN1MpQGBKCnoqKWppIyNXPXYmRUZX VTNsPVVnY0gqPHBCP0BkOE5Dd20/SWhoS294R3hCNS1vOTxzQWRGY0BTKXZkPk9BVENOcAp6eHp9 aG9nY2M5TFZneWtEPF58dyk3Y300UWBfZ09KeUxkNDkxfUZkODEjJkA+dEtyb0ZAWWBoRXpONk96 M1A5dHYKejwrSU9AWllJZDE+SC04YlZ6a3FyVXBafDk7R3xKcEtoP0MrS0h3SnRrMXAoYTN1dGc3 ZWNPaU9AJV41NjNiMXYqClFeOHRVeWs2TjRLJjBLSCY0PVE7eUBCamIrCgpsaXRlcmFsIDQ2Nzg5 CnpjbVpzP2J5UW5UKiFFaWtpbmw8flBAb2hqP2dVUzxRb0lGJXlTb0xLKEJjIz03Rj4oRkl9fj8h KldtNjFgX2t3QQp6LWdWWUY+LUBWSGlAaF4qJkNFVWJANEFBJiR4Qzhta1lZVDBfNiVGPHRHTUVg WEQ9ekFKJHM/ezhXczVAKGI+bGkKemA5USMyT3pmTUttPkFfWjJVYDwhRTh9TytUJVleTCRlMnhq Qk01ajNyVDN9dyQqVSVlU3JyWWJxN2ZlYl49LWt0CnpkaXU5TEAhalokVU1gMyFzVD9QSjB0clJY U0NQZUFqYkNJR0tfTHc1cTdDMmR2TjM7KT9wdUM7V3VOXmFORUUycAp6e1h9fnglYj4jZ0B6IUQz ZHReVzA4NW1iNyspI29gWis1dGB1TyFjVD1qMkM/PmtEdzYyelEtZ3o7K2NLLWtuI0QKeml0dSpu WnRiQH0jdVpaQ3piP3QrWj5wPj5BN21tN2pgdmZxNVVJQmFIKFBFTnsxP0J6P0VrWCp0NFZ7NCtO NjVjCnoqQSQoKjY9WT1pRFZBMVheR2h3PW9KZm1eUDlwWkhVZUg4ND1aXnYmM3h8TFc0dFhQI2Bm TXtKPEg3RzBIbzA8MQp6Zjs1TmJCZzhvWTRffjBZPlo5R1U1em1WKWVATCkwKTt6fjBacEpMcSZA SmJsZTluMEh2eis8ZSFwSSpHTVlpK2UKemZZc2JWcGkpNnIoWExxajF3XlJxaExqQ2J0JkRJZ1I4 RmlQMHUqZnw3IXhkSm1LeTgjR2c5VU9YTlBZM18ld29pCnpRJDR8JGNGflhuLTR+cksmdF5hYCRs Z0MycG0tVGZuckAyclZTQ1FUNCZGc1NqSXpfcW0jZlZ3NUhyS0drOG16ZAp6a3p9bTBTdW5HaVJF KjJNV2xAMG0oPUJGeDFzY3ZXKmJQNXdiYkN+bmRFbFApSiR+NXN0TSFQQntxMHh+VGBBN0YKemZR VFlZWTN2S3peZE55SzBQQkN3RDBlU1NrZDstODRaMip2MF87ezZeTnZWWmR+bXdieU1MQiZgZmpS RTUtI3tMCnohbk1ubkJnWW1MSHhId25uTWY1KDRVdiojek9HM2oqO154I1FZcXBUQlJeRyM5dWhg ejlQP1dvQHkwejNSbzMpRQp6MDBBaF5AcCtEVXhJVHtnZUBhfmFEfWg3ZUYzVFhSayp6eXcoY1c+ fCVFMGB3em1iV2Q7VXZMQl98OEs8e3FHVjcKemxwQG5VbHEtKGYzP2NCNF4hVE1VZWBUeXlDIWR1 fFMmO2haYHZoXzhlVHUhWWlGI05sKzJwNTxma2RBaClJI2dyCno4UFR8RGVIe0A2OXJZRTA1Kjk8 PGR7eiZ4MVRuMnBnfT9AYTN8VHAxQmYrYHFnTzt4fkg/O1Nqa1U3R3tfdG1WIQp6IXVmQHA/cGZq RjJ9TXdROXhaSWtyXi1VVEBydUhlJjlGIW9MQ2NJMUZmZjB+QkJiR0VWdU9zZWxJRTByJWMxZiQK eiU7bXlDZzt1YDgxfiEjRD5sLSQ0cCg1WUZxNTB+RzVYeWVmPlYmUllteV4td1pQcT95RUd1JnB6 SXNMQl43V1NXCno5e2FpZko4VnhHMGZBQEZENCQ3Kml6dkgzS1MpN3FHTGlWYmJHTUF7TUAyX05w Wj1pQEV2U0ooI09GMX1tJn1TXgp6dWd8RTFVKm87UGl1ZmUqSWpSaWZfM1BJU016M0RJUmE8PnQ1 I2txJTxyQWBzI25mQVpYUFRxP1Yze0x+O0teK3EKenhvdUFvKngwP2h2cT0rUCgkPn1uRlhmNmtU fURFTkwtMCRUbXtCd15zdEM7Sk0tfGh2S2c7fSNkLTNuVjsxfmZoCnpzWThVXlcyMSo+enN3USla TD92cCtZLWlFaHdWQmBeTSZGeVYheU9lZj42RClgVGxHR0FeNVJ1SkpySm1YdW1FRgp6KU5nLXZk Rlp4U1hLeW9LV3VFQmw4U09KKV81Yl5aRGd0NTx3OGBVY1ZkV0BKN3dRSFM2ZzwlSklPTSpyWkc5 TU8Keno4SUd3SENibiQoU2tWOVF0Pj4keTwyJVkzUF81P09ARiU3ZVRwNENUWH1qfElyPVU2VWFD Nis5JVAjOCo4T2wqCnorditwfGRiLWNjTGYzd30tdiZqdipBb1EyUyhSPkA2M0BDaFg3Iz11YyYo JTZzeG9melpIamQmODA9NCU+aVIrYgp6VWRfVSNKQ35yc1A7T1lkTkAyPVNyQWd0R0IkMWpyTG5n Ykx0TFVAUCY4amI8KWg2aEE1bns3OW5PfVYtYylKO0cKekUzTWtFYHp6NCY+OHx4ajswNFB1PlJQ dT8pOG9qfmVGUGBKOzwyaVpUZWI+VipYdDV8e3EocjxSMlcrJGxeSkVsCnp7U3pEO1hHXnRXMiZy Njh2TkJlXlchSylZMUUtMktsUE4hT0Nwd1l0LUBoan5jQ2hvPE9Acjg+ejN1VnkyfVQzYQp6bEFW dSRUMFFuUFNNfl9DOWx0TDw9JU0tWChsVj9tb2N8bitsNDAydXpPRW1zWFo2flozNU9sS182Ukoz cDNYc3kKelZaZGNJUTxtKnlOY2kyMV9rKmgzYiFGTkVsWH5FPipSaEFxYDRDV3tKN092YlUhSiMz K3ctKCpVY0khVXBDUDsoCnpzQng0RmRkVFA0Z1NGbm4mRUN6P1orRFp+STxgSnVtUmc/SE00UUxG emduO2JeI2wkQikrbkJDZE1aT3owd2h9Pgp6QFNhJWZIfVB0Yl5WR056RjJKSUdmZ0ROcDcxMk5Z N2dZS1A1ZklEX3Z+IWwhOSZ2azVAcE1XTjQmNlpOI1U8X1cKekI2bz9YXitwMmRnPlhiNiVmJWkq SlJFeDtGSkhHQCpRZEJGXkxjN313amxyNnE5aDNNejRvQURwZ3tKaGRQYitBCnp8REIyOFVTMVlw O3JMMm1DKjdCU0VjLXREWDY1MD88IUU4JHY4SGphcGx+cSlkTz08TGFKMypuJWc5VUVlSXRLNAp6 Rj1YTlBGcD44N1hKemRydUhkKSojJTFeWWRSKl9Eai0jVy1WLX1WM2ZCTkEqcS1eUW9uYDhKOF93 fSNlIyhDT1AKeih9SkVhX1RwJnwjaiFqZW9aen1vMFhsQTd3LSNWJUFeVWNNODs3bXs3JitzKypa TCgoekF8eFRNI3JRMD94cUorCnpALVJ0aVMrdiVJbT9+fTFjQWtAWHB0eFR9JWk+MjNfMEwqKDxP fEBgKDVFRkhCcjYmTHJuJSVteGttKWdeUTJZawp6QFlefHUyUVhmNGYxVjZwailSM1NgOCo7PSNV Rkg3SE5uTj8zLVB7TDN2Xmp1TV5sJSh0e14zOVdlRzRRSlQ3ZkkKej5vO2k3XjBDcUgtSFhae0sz aHtjITQ8bXJSdWNjU3YoSVd3Q1JnQ2lFUFotenMoUyhLeGZma1M9UiRtb2VjajdFCnpULTsyQjlw c2xEO3swSX5XSGclK0c1VTt+JjBwTWopQnVlVHk4MFVUelAzXjFqNWdSJCt8TkB3bzNUJXdWSV9T VAp6SWRnZHFqWCVsRylkXz57NElfa2Qobz87eilMRj99dTRiQm9DYzVFTjNMSkdJeF54fF5PKCNB cDdLTyQ0I2tJP08KeiNfeUomUDY5IWp0TGRRQ0EyMGRjajBUbmxLRSQ8TkZNOX5JNjZ0ej0tO2xZ TEllcXAheERLWWhDK35LNSt9YTk1Cnp4MjN6aypAKkJVNXFDdEskJjJJU1J4MFglJkojdkg0UGtx PWU2TGBlVGBPLV54VURjLVRSRHJYe2dZfGc4Z1VtTAp6V2leRT0kZUFJX15kTzRLeXhEcGhYNnJo cVBXSm1AKS1kOWR2N35OMiRmZnohZFZ9TGojdkR0KTV2b2I4OHxzdWQKemNkLShGTHBXYCNTVks0 TzwzajYwKHZ8KyY/RVlGSCNaQCR8KyZHa0pQKykjVT9yeXV9Qj5NNGd0azMmO1g4RjFaCnpiY3Z2 d3FGYkVRYzNFPG9VKlV8NE9LfX0+KGQmPCllO2t2ZnhVN0hfTFNBZVVVeXl+cS1SVGpSODxeTkcj RiVjIQp6V0cmK1NVRXJQZWFBM09SdjJ2I3FXXm1ePkMpWW5EYU5IISUtdnBHOUBuNjBlKT02alc/ bmYoaGxoYjw1aUFGN30Keml0X1l0KW4weE1vcyF7aUVIS2g7I3JHalBrSzU2QiNsfFU7VXhGSFZj K1dZXitrdz1Ee0ZRV1ZjUE1IS2pGWjl1CnooWT9tJmclaEViKypXX1BtNlU/anpgV0NiVm00TlFs Uz0tfCF9QWt6Yk1xc3h7bHN0T0xiSDRrIzZaWHhNSlh6Kgp6cDJfUSNVbE0wcWJxYCZgcFEkOWVT MUo8fmV3bWlDPVckZG84S1BsVC1jQHpueWtGQUQxPDBMKG9zQnF1UlpCNkAKelkkYEZse3Q0YyNw NEohYDA8TCk0ajBqeWpHOFJgdzhDRmpNMVkjfismZXJTKW19YF5vS3VfQ0didHJedHBSQGk9Cnpe RDRITChjcSUpNkdGOWkpZHk0S25eV1glKyQ5ODl1WHtFb1FxazZkKyhSVmtGYnhXbjxhaUx6Ujd+ Py0kWSpkRAp6M2xZJlZSI1I+Q0AtRyEhWDckbVE9N2hLNjRJT0U/V2g7PnFZNlBvbGI5K3UqTGNy UCQmazJ6JChkQXtPZH09fHQKel8pPitFbXZxNW1nSShXPlUmKyMwVzVFJnFWJlNzdG53Z2k8amtW V0k8MSYydD5HOFU4IU0zIy1XQU5gdkVNaHl5Cno2VHNXOV8+N2xDPUw5YD13Sih9KHpiXjV0PEF5 a0dvaFlibjFvU1dnYXlyWE0+YUlhN0VNTV4pNSp3ayZaO1dvLQp6SnpscFMzdHdkNUkqbVVmNDtH Z1NrSVdRV2lWX0J3YVZheyExZDtqeW1kMyV1eHtZdm0rTWtFQHckU3NXaEtHaSYKek05YzZ8ISh0 ekdscT8ycXQ7WW5AKUxrNkQle05ufmtCRkpwQk8/ajk9eWI/a2IqYX0taEl+YUFxMl5CSTs0KVZA CnpGM24zOTw+eHJhYj0/ejRHNCpyeUpLZn00cXdMVz4zI2UpT283X3NhbFU9S1h6dSElMXp3aXBA PGdJPl9UPVhaPgp6Kjt6KHpnIXw0SkVzQEB2T0UhJiUkd2lkKWF5KWFMKXxFcCVNP3V1I2J7cmtH QUVgYTxSdlpTSEM3WS10KlI1ckIKemc/Kj8tUj5fVER4VTZfeGdDQU9yPEo3LVFINU5xQGZZTCRP IWo2QlZyJkA7I2M/R3t9V1M8O1JRc2IoNXtXIzc4Cnp2SnJwMkcoN0RoUWpMfGMjTGF1X3hrKmoy WVgjcGpCQXcwV19sS1dfQjJYP3djfVA2RjRfVVV9KiV7NytkQ3ZTVQp6azV1NX0mKUxLaGd3IzJT VURxOWYqOVo+TCM7IWhMIyooNkhHQnA5YkYyPX1YOUpzPTdXb2FpUHpvbTJ1SnpQeDgKej9Acihw amAjMVNFalowK1NMQER0VGB3Jm1rQjBvKXkrPCl9QWApRWs1Yms1b1oyXkpPWnxWKDVieWFCPkF2 ZWFPCnpVeUxPP292fi1JXiNyQzIxNnFOVHFvKHVXaVF0SFhEJjlSamVsdXkxdmVURHImRCp7eyVM NDcoN1gxN1JlZXdnaAp6MT95VTskK3krT3ZvKWhHa0l3ZSpfXiRPO14hMV40X2B8TjxFNE54bjU8 K2hoN0VSTjxsPk90Ukk5RktiaXBMU0AKekY5dkpGa0JOTWo4RzJtaXdPRWIyb2ElUlRre0RYeV4m RDZjJCFWRG9ZMSh5TEpwZkE+anA3M2xad19MTylge3VUCnptdERKIVBRb3xtVVZjaFFWbkRlYiUm VCU1JCpGPVhjPUY/Rk5aJkpEaFh4VGR7fHB8MyplME01MURIOzZkVTFqZgp6VEVoaXIqN2IpcTN5 YSh7U3t1V2xDcj4mSjwpZ2pBUWZIPWNhRWZqO2RPc1A5Tn1EQCVfdVo2PT0xQHBXdmd5N3cKekAh PyEqb1JseEVldXhDPnAkQDdFWCZneHw/NTg3THF2S35De3hmLUEmJlZrYil8Vno7R0BQR1U4e0FT NEljaDk2CnpVdjl3SkxTWDA1OG15eXpOWlFSNWNeRkpZbntmREo9JVo7XntxfFI+LURgREZ1U254 a05WYGxnciZPPER5M2wlOQp6P0I4JXd6dnBqMWM8YHhpKncoRn5kTzRsNnA/USFMWDxRX0VrYCYh dEgqRXspa21rMCs8MjBLKkN4dEZFLXQoQEQKek8jJHNoJGxDI1haPik0VGojezZmT0RadV5LMTl1 Q0c5MndORjtRRFp3fUkyUktgTzZ9NkQwK3FZfFJKOHFCMCo/CnpjdzVNYytaZWxRRWMqRD8mMXJQ bmVkaHEkRkMlaWc9LUlheDFwMk8jUnNDeW9BfnN0Y1h1PkJ5LXhtRGhfPEV4SQp6Y21AO2JHZGg3 QTgpVTh9JVNOWHcoPHZKcGA0cEE/cH15cWtvaUtndUl0K0pWRkxnQzcoWSE2OEh0Znk/a1Y3MCkK eitRYXl7RzgoNyZ3cWElfiQyRWI7cWhJVllfWTFBVHs4cmY4Vz9FZ1FMdE4oK1pZflNmS3h9WSFf RENlVVBxJiFxCnotZXF9Jm11JHo9OFM3SWZMcXdqQyUwcCFSPj08bXxMa3RaNEgwVG9vRmV6WFI+ bHwyKmd8KSRoVHJ2TmdaTGphRAp6PF84dzN4ZyZIKmNHUytvNipReExCaj9lYWJXbX5TO0I8N1Ff MEhPdERXOTh4bSk0bHk0Z0BwejB1b2NPbjNAZ18KelR1Rjh1KklqI0s3NEMhU1FnXjxPd1opRWFa RV9xYTd8YnpMdE1nQFQ4MFg0KmQjKUhjOTJoJnlsS15gXnEpZCs+CnpxJFBNeE9KXiNja3hnZyts RlNSK1k8Yz9vZFkzZDE7I2s2ZmA+eXxuajV0OFhGaihzO2J9dnhJRj8zKE5aVzFAWgp6YWNDP1p5 JXBrQW5yV1F4PDxGfX5oaFVrSFczc3hiOU9mVjNsc0VLYjZtV1E3JiNmQSQhfXAoOUh+KXpoeVMy bkMKei12Z3Z2d2thM30+LXEqQmYhQ3B+VT5kMG5le3hlNzlIbHJtMlVoJHpHTEdVPExARGVXRylI Ym5OfChlYzJFMSUwCnphbXVwQGxQUV4/ak1hRmwzaXBuS0gkNldrTG5lc0VLbnRqYi1KUDwoclpg cFo9OG1ANkkwfG9SOyEoMz1TUXk7Sgp6UGdHa0d1fTVhVCZ2YUtSODlFNXJJYkNYPT0yRy1mQngk alpsK3E5fU18UW5gSnppbGtKQDxxJj5oOSoxV1lHUkMKejtAPnRwRFBZXz1oeSVFN3tecE9+T2Vl dGM9dk0pQDE5czNta2teJXhsM3NpPysqdHx6RFMxK3EobDVMPEo/UlJ1Cnoxek52cVE3TV9DVD9r REExMWZsNUdnNyFOcCVgWEkjbT9SeEhMP3g+YWxGZWRFVypLRiUwTWg8MFBSd2AqXzYxPQp6RGw0 YndQTj01JCEpMSE+U0FqamVsa2c9QEUlX1lvcFo1YihlZEE/P0tLVE1GMVZkZWkhXj5uM09qZ2pe R3dtcWsKeik8fWNnOGpKa01vWGtYQjNMJCtYVj1aYWN4QyFZTD4wenQ5X3BpMEJpS3J3dTItMXBl OTBHPlBvb0RxKUxucnooCnoxQ0dAQ3tscXFZaHNnbiNDTXpzRjdUb3VYd2ZFP0pBTEtQV15kIVF5 Q3dhcjZLUlN7UkZicylPUSZKZ1Z7a0c8WAp6PndIemNIcVJLXmRLWCs7JmRGdCNQal5mNlRYITU+ bWk9KjtkS0lLfkFjcVptMHpXaypfWkE0KCV8PC0kYzxufVAKemNuYlNaMD0xbldePUhnc3hBaiN0 XnspYWg+Ql9CUT1iN1R7Yn1EeCE9SE1DQGBQcSgoZGlWTldxPj5GJGBfKVhvCnp3b2R1JFp4OFkz PGgtNyt6eDBvYylmV2hNPEQzSDd1eDNiUHt2Yit+TDBYeEg7M2VxP08xSUR3SzJva1ZteSNvSgp6 Um5iSFhSIT49WWo5Nm9nemo4SGd1VDZ6fDNiaSk1SkE2bVU7JGArRFVzcTJWUFVSVSVCRjdnPVoz MnlQK2o0M2oKejwxWXdpWFAwelZ0YENEcD87UVNtcnN3JipRKU0hdWR9O1lDayRRT2pfR1hsQWhp Z3Z5aSFuO2BNb2d0QTdqJnw1Cnp2fTszQkA8JUhCJVgyKGctfHkwfV9NZ3tRNmQ0dzhZfHkrPGQ/ X1pHT3VTeCtadD1eVz1zZ1JeVlUwJUxkeGhfUwp6R2h3X1g4I1hsUWNIcT8/U21WSDNnXno4TV9v VTJjKlBpZmI3fmozcSgtPmRkZ3RAVzdYOCReY1pgaDc5KUMkRDIKemhHcm9zWWMkeFV6bHs0IU1l YW09Tih8P0Z7O3I5Z0tfKDYzSk8xejBKVT5nZ1NtLTdhS1I/RnFiIzlfTWt3Oz8+CnoxbVllLW4k UmJsOENQZ1hGbUlKSjRUQ0h7bkw2MjdpZThzMypLZ3c7TGZtOD0oYStCXiUzQ15ANFh3Wjd0WGg9 NAp6RCpRRUs2IVZVem56KGF5UjRZRU5pO1IlQW9oUVBJbCVsTjI1NXI9UUQ3RUtCMyY3UHkqMHNI QEVZYEIrQWJrSC0KenZQOWwmPns7Jm1fcEh3LUxDNFJkYXJyKUpudj4lfDlkTlN5b3YxLXk9dk12 REclUkxMVHsyQEBGbXppSTk3YzcpCnpxO2ImQD9pSXZ6WkwpZiUpZUJadyV9M2JreUslfnhWdCM4 TFN6SVI2UGJUSyRndlZ0IVYyOT43PENCaHRQUWUxRAp6ZlZUV0loJEYzK21kP0EtNll7I2Fab0s/ USN3cHh1amg7OEhDdiFXQVN0OXNRKnh2Z0k0JUwhMWI2eVElVTF2VjwKekxtSD0qWEhSfFczcnV5 LTUmTVU5QjZ4c3RwbXE4ckRFQjY+SHwoYyg9dnttank5eEJzSjgmYEVNYjsleVRQUn1UCnpzb1NN YT57elFTPHVUM0hVUjgpfk4kNnM7bDN6RDZnKmx+JmpYcXpjO1hvLXs5YHhYLXk+eW92emlvVmls WDJVdAp6IWU8eitDTzRNdyo1cEg+N0VWcVpyN255MUoxcX5vZ30/JXRGcT45dnRlYmRJdEBTPHJo M0JpUXdBKl5ePSVWUFQKejB2TGBBWWQ9MX4wJnhpbipSaWg1VmBOdGdQeihQNC1RKTw1QFNKI2dQ Mzg2VFpKP1dKeEhjJiZBSjZPM2ZyeXArCnpFdWVjIytpSXUyaGJePyM5ODlGKCtKUXN0YGBvcDlu MTZwfm40bDBPRHtGUUFRYyNBJitLSWlqSyl5KGFUSX1Gcwp6cmxxYX17aiVkZjVyb18tIUB+ODJf RXg5O2o7SWJBTSE7MWdhT04/WiFIXztSZnNnTjdZUFZfMm1+ZSREaDYqXmYKejt7cWFIZj5lQDQ+ JnJ9MHleOXtSMGZwMDhRMldnQSl0MC1aV0J4Z0xpdD97bnpzRXFzNHw2IzY2MHloPU5KMDQ0CnpO WFFtdGQ4Zn5wYkd3dlJmUVZuJVpxMH0+YlUqaT0lWCZzYHlpKUExWGNWKCFgRmU8eWpxe00lUX5h UnF8SUdYNwp6aCFNPm5uaH5kWXQ3Sk1YJllLUmZvTnxZdztJJjN2bzZKLTtoNEpRJjYmIWUoNmlU IUhTWGUtRExgMSZmUE9KXiMKekdIYlY4MT9HRXtYbXcyNFJvTlh0d2h9NStsNV5wTSNGI3Qyblhw Knh5KS1HK3VBV0o/YFBKfmE1JUk5byk4PmUjCnpiKFk4TCkxeC1rPEBHSE1KQzxFdngoMVlPZUVq QmZtVVclQDh5bENJNVp0PEwzWGpnPkBfV2JUV25jQ2tHTVE8dwp6Wm88WmNxUVA+NWpfTFMjeEZS QDRuTFFgZnBaXjcjM2gjd3NjbWtnMCpuZnd9QFQkc2ZwMzN0Oz5rcDdUeXFfPWEKem9kQ1hBMClL U3laV3ZzeHAyYGpKLVZmKjgjfjdrU3pzI3wrSlV1bWI7KCp0Y05BPi0qX1JrcHlIdjx0R1Q3YTdD Cno4d1d4T1QoaW5gTyZHLT0hfFB4djB2NFM4ZmdONFl6aitvRDgzZ1k/dXNoUXw3bDBscHJ6Z0hV YFYyUmsqWWsmaAp6USZ2ZiQkeVg7eFZ6cXQmbS09MWd5QTZjN3YkTGtNUyF8cWtaUzBiNnoqV2Jw M3g9MXRIenM7N25yYGFzXj5BVFgKejwrTlkjSCVlWml6TmVRPUdGMWVgaz56eEtjK2FLPzsrcShn OFpKU2oqZ3BCKEs+cTNJVzgmQFNSdGhvLWRibVFACnpgR2VqITdGckkwRjMmWWctQkpGb2QjWWwm Yz5aQURLeG0pQmchOXJ6QT5WdjhGS2oyRShicipwR3dafl4xS0dAZAp6SDIjOzNBYS1aRlRKKDhy V1R7KURGO2FlPVZRY3VhO1h5M0VjOD9FQ0c9OFA9QzQzbE03cWlTd0Y1fnkwaWsjaz4KemFDP0Nl ZHRrJHMqe0kpJis8cSRLajIkPENTcXJ7ITFYJDcxKHNxeUNRMzRZbE9GdXc8TWJOdXVKKjEtZFIq b3BSCnp6P09McS1oMWxYMUckZEhmd2xMdmEpfj16dWA4YkUheUFQMFQlfTE+Mlh+N3ghSGorS3kr JXZNPnElUyZGSjMmUwp6NX5pJngwUWVlUWoxOWlVMGZ6Kk1KQHxve19efkdyQn40Kz4lcShSRTRw IXt0I15IOW9gVCpeQHdUPD55MFREUWEKejwpY1olWkNMdjA0YSY3dkxDOyFMU1hEfVBCZ2dKSWQq VlBUUGhaSGF8Q0NhP3NAY2t6d3BpMGFGcXolJFdLK3tJCnplWDt1czlCUCYlMHNRck8jVGgoNTRM PishWF8zQVQtXm1rPXd0TWp0UFFRbD4ja3ZzI2U/b2I0WnokU25wJUlfOQp6Z0omeS1oeXZvZ15i Sm5yRF5tUm4qQEBkQUd4aHBRS34hKzY/OWN1Q297WFRfIUxAPiFHMCtvPyhzfVkoV2xxe1MKekhj Qzc0YXo8QWQlX0kqZTBBRTN+eEcyaXBIP3xQcHo4QmxtNWNuM0hVYEhjbDw/PVZnNFMjKlAqbUsq NlgtaExhCnpvUjY+Mm0rWjFvIyR8bGtvXlNxb3t6YE95QjhUTWpNJUduKDA+YGpTZThMellFTUlj YXcyKHw/dztkJiNtKVc3YAp6N1FKM2NxfChqP3taPTIyZVpQNTwmN3hLMmB1Jm08JSpkeWYqVSlr U3M/dDw+VF5gaT8lRmhNc0xzO0J9aGdQMCgKejkxMS16dGQqZCg2SGpMNms1M21wIzR8cGolNzNx LXM5O1JSSE8pYjg2SXI1V0o3WTdxQUIpcF8xK2xKQkkodlM1CnpWbCNkRHcoXmFkNDtybyZUZGEm YClJYzJ3OWJQNyVCJDBEYTFhUDdQdCV5U01yckJvPWlQRHpoTT5GX055YFBTcwp6cnRUajtGX3k+ LVg3TDtRSWlrJDRDMS1KKFo9QVVqTDBAanpySWg8c15QTDQ0MX1jTFY8O1owb151RXE0NjV7fiYK eiZsOzdsPEt0LU4xOT4/RF5mTyklallte3NUXktVJCV6aUsrTjZJYlFeMW82K1FVWiF+cEpsemBJ YTdHX1h1MVV2Cnohdyswc2dvSHVQV3JeY2ZVSUM+RHFaNTclMCQxKH16RV8/NnZUUVdmKE54PGV0 fENoZ3k9I1Y5ZCRPV2tPZnZreQp6JTR5bjNAPSo2NTw5KVB1Kkc4P2U3IW5vTWRDJk9EZm1vQlpI NDY3UFk+SWB8UzlkNF5nX2Z6UW1tdmw9ckxRMUoKenNBMSRZQHNtaDZOVnMkPkl7YUkpdypLJFd7 MiNzTzdfR0BlPGtYYTxrWlFEM1M3RmRyVzBfN1liQTY3enNqP0V6CnpUP28yZyE/bFJUN3xfeSs0 MnE+SzA8Umpxbi05X1d0PkcycjglMCQmVDxKTzRFWmNENUJld1QoazNKRD8wUX0ofgp6I3FvLUEl WDVrJjI9RD1Ic2hYKm5QU2xfIzIoI15Ab0Mjc0BnTmdpdEUjWDg9O1Q4UV97aTtCSSY/Q1dycTlg bmsKellUKEQzNTw/VWxIciRBM0RAOG1gNms9cXJNdyZqWT8lZFJyWExoNkR4c0lRTCRwWjIwWHV5 eHRoe1JePClNSWJnCnowJkcxe24jWHFGPztDTEJwTiNYN3hiSm5+R1Vka212ZH1WSztlY28rSV5s Yi1ZKio+ZG5EOH01ajRsMClANCYzUwp6QXEoViE1cE1WISVWR1pzU0xzKXsoPFcwT1NydnlXPj9s cWN6SE8kRXM8V1VZPiFCVngrVHZUb0tyN1lFV2FJZDQKelY1fDtWJWxyWW9iKXZTMHB5bnxnTilU eXAhdFpARk83TnljU2hxWj9rRTRCJDxDeW93JmA1UyU1WEFlSW5ffFYmCnoqdGZLIXRPblIkUCh5 Vzt8NGdwYGUkRVZNP1JwdT1RS3Q2TmlwZUZJWnt3fFgxWG8yOFhRdTZqYzVFUnYkWjM7JQp6c3po bGVTUSlfcEQxWUJZXkdENGBUcHMtIzBGX2lhaUcxRTdhKU1zU2IlQnsqNl9YTUBQekc4eyFpUjRF T3RQIyoKens/JDwjTSZFVXV7WkhBRk55UC1PKT0jPiRzdXQrNDJQX1B0UkV1VCRLYVBqY3s/c2A2 ZkwkX0UoY1lqfVQpZH41CnolMUU3NCRuOz97MmlYV3t4MjFIIz5jfW5eRkx7IV8/NGFUQWNKa31W aE8rJSgtMCkyPGBWSitCWnRzUXJYRVE5cgp6YD8yamlHbjB3R2s2KCNVYmZjdUhKdEh0Z1BofV5Z byk/OGhxbUxzaTthcUl3YnFqIyg0VW1Da1J6YDZkKWtZb1EKeip1eihsVm8yPURpTmBmITxuY3RM Xih5MX5qPVNYe2VkUSRuPWA4Szs2IUpLKntWO1V3OURNRGUjazF1NzdeTGVsCnpyfkhrdlZ2KnRY XjdgZFdJWXlWWHBlZy1tcCZeYGdUa1pDPik0VXAkZXBsY2p5K0QoV2syI3o0dTdqKGV7WHplPwp6 dDIyWUhFVjNTfmsoJCN5VCpxRU09aFhDe1EkWDFQcmohS1E2OWN0YlZAYjRSYilHXypRTlkzZ3o+ YSRXTlgzKjIKenk2c2NnISRgdWkrUT43Uy1MWFYoWEFAOF5CMkdffFlabFlseTdfdFY2TEBMeDQl aF50I25HKDRAbEFoNj08TDhUCnp1eEY5eXteST5PLX5KeFFORkFAPiMkbzZhbjFqNH5keWdRZUBF bVghWn4/OVp7eXQ2KXdQeW92WUtFXmsrMG5fTgp6KlR4VXEqVip2SnV9SSRpQ29aR1pzb0dnUT9l T2s9WFJPRGZpaXleTU1qTXNWKExtT2A8NTM9U05Ye057Jk11cnAKekZwbyVKRFo4WnY9Q0hIekwp UmJGXztVMCYjRGtBJEtuNUBqNThJR0ZZKkBIQmAzMlQ9JlMhaHlVSz5lMUdze2c2CnpnN01KNlZ1 LUhrKm0zLTF0Wk50KT8hIypXNUcqVTdvdWRqfTdjSkdEX1Fvd3FgMXBJQWE5ViRNQX07ezMtRlY7 IQp6KWY4d1FgaVIyPUMyek41djZ3SWFKPEMpfGcmMiR4KnYmcXV5M0hxOWlzdlBMcVZ4YkU3bW18 WT9aKEJmQDFjRUsKejUpeXtmVCp1IXBtdj1WVnB4bXdqP1VDS3tAYFdQLSoyWmh3cnB5SnFyQ01I KTtCZk92Zy1manY7K0xqbG8wUUYoCnoxWXpWLWdwQHB3PSVQNXVpPkoka0N1YiNaazh9JFRFVU9w ZWVfbU02QUpQQVNxdGNRQVVmX19NX3x7KmJIfV42aQp6eG8wIz1KdCY9MXN6NiV4SXp7Zlk+YDww WCViNHM4Yk1ZN2FvXnJNNjFMO35qTVNfWGc7R0NrMXUyTTRwSjFIMm4Kei05a0ItPy1UcD5RRzh4 OC04UDJDJT5WTDI1e3dKOzdlMyFaaSpaaERVX3ZTbyN3R34jeCooYjNXfSRGKz4wO0g9Cno9MlV7 VlVWPSNIYX1uQXdkYHRJbFU7QSZTQG4wZ2RwdFE+N2o7N2xpRU8rWmt0SXk5SlF+MjxJKUVoN2Jt VFVhQQp6Y3I1X1A/P2Ftcz9SamctR3JPPno4bSRCMWJpQy0+UHNCZFRGNDglM21NUFRmUHNUcVJF XiFQUWsrP2BBZGlXeSkKeighWHA+dCRab1MjNUJJMFVHeX1CPDc4JVVeJmkjelliRXUzWSZnTXRT c3k1MCEhPGg8Jm5DRnBqWFA0ZT9WSTk7CnpsTjZHe1JHJW9xTUV9ZHl3MCQxRSpRKU9qN2BmI2BN K0AtJFFFd0RFS24xfiUwNkdsRWAoNXpnSzZeaSV6PyZYcwp6REI2KXhQYD19eUZ7TV5DVnp4RnBV WXQxby12QHZWMXgjRDNVdUhwXm5IVDEofDZ7NnBTYy1vS3Moak9BMSM9VykKenNtVkVncD1ONDBi T1VMRnBTZChsMEFke0k/NztWNDluKFkwMWZTODsxbjVtLUpNSXEtKT1qdkpPXkVvclR4JVJkCno9 c0JudDYmZnpeUmsmKm83eWJ2JXt6cSN+RkBndn5XIWFOcWVTdWM0SkE2NiQ2R3BqV1RTVW00WWE1 ZWNCNV9MKwp6RXZ+RyUtOWMhVDA0MWx7KnJWPExvQTNUIztFUnFEbSU0JS03SHU3VkRyUz44RDNL I2k7Y3pZc2FFM15edmF0NkYKenp5YFV0cVFySXA7dUlKKm5WLTF9b2pCPSNWREN1MmNRZEw8bSNu UWJjKyF5ViZnVFgmd2M0cm5ySVJDfHIod09tCnpFYXd5YChCTUdCOzRBdEJZLTVLdm8tKGx1R1Yx Z1Z6PGUyeURgIXh7cjZeMVVFO21MLWNCfERBKDd7aFEtTW0qdgp6KDhUV3NHNEV5b3Rzfil2Uj5+ TDc1fjtnZ3BwS2UtJEp0aTtsMzZWMGp7QmhlaU9rdEBNMmpvZSZpOF5Jdigtb0AKekY9cm01bWJD eVFtflZZPW5WPkE3JDFQR0hENih3JChtQT1hdWokVypQdFMwcF9iZUtWK2spciRrWkIwUSNkalpf CnpFOyR8TyFueW1tbEx8KE4pNms7enJGLW9MKjxXXzZOaVU9ZGUjZyREWHE1RXJzTHxmeF89aUxv Tmc1XnhVc0xrPgp6bnAmMXU+fGcqI0BVQWxkRVZRd30hR29TITsrb2NKbSZne09VOH1SaGs9RiNp Km94djkzPzB5PmxzYCZUOThqJTcKelZKVHMoWEs+OUhibFR8b0BaWWEkYTA7MlEtJVl2dlpDTyt2 YUpRJTBUMG1zRTQmZ0pJczlGNTsmez1tdSs4cV9LCnoyK3JJbEAlVUh9XiEwemUwUkZLOUFQeEFZ LUhsYGpXMW1NV1ZxSWpTU34pQGxydDFVWmczZTwxa3dvZzdQXzVHagp6NEszTkBjaH1xRnlea1kq bE1xO1UlN0xseEZtQ1VGWUUpeGFWS0dgQ1k0YDIqZkhoblAje24wXlErSkswMyNAezEKelgmXyMl bWhDRWRGKUg/bXEhJHgxVnwkZC1tPUQqcGhQYlYzMGM2d2tDaDZ2aCg7XyVtU3EqdGFYKFJANmBm NHBBCnp3PjBtPS1fMHZNc2hKY1NSZ20kPXk1aGshckZHRSk8QnlnbXZuaVRfX2Zeb1k9aCk/QlpS P0xhQW14UjgyJkJDUgp6S1lIX3VWWlowM0JBRH1jSWEzJUkrSWJuKWstJVYqUlRMcmtjKFdtfWB5 UDZ1LV4+S0kkdko5YjZtcHpeTzAmdEYKenZMNzJnN2lXRkowXmpGYFJgdV9gOHt3bihtUmkwV0Ja QCQ2bWNCSWVeOXs4fElLOW9kSjkhNnZOKXRMI1hnVl9ZCnpVYVRJdT1fcEEpMDFCPE8tYUJzIzkk ejxrQ1czQVZrRypmd21ZOzZXan07S1VHbm1IcGY3eX5sOUJGQnNEQyRtVgp6O0Neck5eU1kxZ1NL PEV2YVAtMHEqfHYzKmh8UlI7MVlGUFEzfE1SI1pzWEtYRXZLWGY9YUoqfkdKKFl3KlJCNkQKekFo aDtgITtSVVlPWEMjaE99czN6PiZ5TitUQUBseFlEPCRNSHUyTDJnVTZefWxtd0c8NmkmPDFzIUg0 USQpS0dhCnpubCNhMTxGNGNPRTBzVnh7cmRVfnM+UWxOVWNmfU5sczJMLXNtejh3eXh1T2xWUVVy Wkx5Ml5hZmpmamZqVlk3Jgp6Q09BdmlhNEpQY1pOSDlLQ3E+WGNrd0pZZ2opTUlfcmA+ND5SXlk4 dlUpRDAjIW5pdGdnZ19jMzk9fXs0YUc4VWUKek40dzhkUEZXPUkyUFJsc1pUUF5STUltQkohcWZm JmpYNSU3Tz0oe0N0PiNLeVBzJjBGWkQtWSFLZStGNlRrUT5lCnpWNVomQmp4KGskSDtIIzRVY1hQ KjJaYTJ8ZnU2aEJ1KVUkV0pvezAlR3tgV1lgQCVXVzdfZUFCQmNjTWxoX2hUIQp6WSg4cShVO0hq Zm8oLUdyeVN6TH5eKkd2bilgXyltb3x9P0c7ZnRoKGgzQ1NhZX0kanExcjlnc2M9dHhkYUhyMFcK ej5vI3gjQTlKPEZqKk99b2l8ZS0lUV9qKXBRWEhlUTJMRzMkSE9UYn41ak9RYHlSUHtjJntpVSFu JD0tRV9SKnlzCnopWGJUWClzNl8/QHY9T3VNK3F4aXpXMlZqQUx7N3hUdWlyZy1Zamk+THxEMFZe ald8YmtQdkpVKm04PjlKb1daUQp6NUA3Rl8qYT1QX1liOTlQaStTZmBAb09LNjtfX2lRQCt0aF9X MmB5dnJ3MXsrbHgrZWlgJE45VkZWJHohdXs1PHYKejNkK0ZqeXlFNUp2WXExTStASShFPzBvQDI0 KihKPiZsTXF6KnBhVXdrT3ZGZWQ9UUo3bipAKGhgSGpoR00jWH16Cnp8Rk9Lbys3K2x4MnlATS1Y QHtLMz54LTdTbkIraj8xcWxCOWZPS3xFVkRyX3klbVNlYGojSXMrWjhMYmBCMkxwTAp6LXZUfDUr JlRXfGpJLUwqbD8oQDl6KUc0SDtzQm5panJxNShWcH1qKy1WTHZmUXcwaEIqfjgwTzxMZ1BuRD1w bDcKeksrLU5edm90VytxJEV0K1gkcEspWjBsOUhwe1VyMUE1PTRmejNsd21CME1MKj1LYUwpbGJR dmF7aUVoPG8kSWooCnpzUGIqNks+dD53MGdHeH1IYW9KT25GNGlIYmwkZHxraTl0Mng/YHkoPjBy SzRzKkI3KWUtTW9xJSRAKDdUcH1NfAp6JEA/RnFnNmtzKSFqdWxfQnBZKW9OWT5qUmc5N155SzF7 biY1dyFaKz0wal9uRFh7OGNGVDAhSzRMKHNMQW5qYHMKekJWQVZ5fEN3bGdKLWdIcnp2RFNHKn5m IXFyV25MPEprU3J+V3VNJVZVbGU4bkJIckw8PzlkdFojMldBdStqP0pNCnooKUg+VWJ5RzVtMnhF eE0+bllyc095aXNieGJHVHJKVSFrfE4jITFPUnFZSyVVWX0qMGJGaHo8MG5XfWQ4RiZBbwp6Q3V8 RE9sUXRiJVJzPlRhaDdLd19WaH1gZjs5K2ktUVlPP1pBRTRfdkNoPnFvVz1FezhfWVNTZGhRR1ZB azlnVy0KemhATlhndFVGMWExdTVUVD9pX0x3Xyppe0NVYXJCXk8lbVFOV0c3aXdOU1ZzQ1Y2Xk92 K3tVVkNOT0A8ajkyQEpjCnpCVjllbHRvV3E8eEEqNUc5d2VfM05NdE05ZnlDaWpKVkw+bmchWmhf eE49QS1UXkJabDdxej9iXzJ3TTZkLUY5Kwp6KEtHckBWVkM2NV9PZ2gtP29NLUU1N3JUJE4zYUFe cG88fn4xX2NLZ1U4eCNNRm88Ozg4UzY5REk+MWtuSz1WeWYKejhickxiQnVVKjM7R2Y3QyNLM2lh JEtxKlBfQ0g2cU1FUGVNTXtVUkIoISpyT0E4eG5QTi01SXxjZ2o2Pk9qK28qCnp8RGR+bHR3VFJW ejV8Xz1GJjY2b1BHIXtqNkRGMzxrPV5NNFlpcEJheFVxPW5MY0Y2enMmbzg/cSpRPW0wP0xkVQp6 UWZhYUtuaHR7YjNfI2c1cFFIfHlNWjw8M0NufnVFPjg4SFoyST1NRmhXKFBDU0wkSG54Y1BYZDdq RWl7eVVPSDwKek9qN0BXRilsakkmOUdmJlVvRi1VcWpfTj45YXNHa1hYdVdEYW8zNW94ellvXm92 OFhSPEtvRXs4RWV8MjIlJWclCnpiTHJOfClPO1IyPDFOcDk+ZWlic1I+WGY7PjMhcm1yT3B4VFk7 cl5eeFpEMVlleW9JU2ohU0QwKlI3YCEye3E7SAp6QzV2VElDKkZoVSR0WXFAZmJtPG9IXzhsakp4 RkNta3d0U0FpJCZZY1FSPjV0bytvWjA8ayFYQT0oUDRpcXpwXlEKeilYOXBXcWptQFYkQ1ZoPFA+ Xj9mbik4T3lReDtqeWpiVytSdzV7OVQxYXVxb2FTISpWYG51O25ASCRzJF5JO19RCnpecFAkP29J eT9ad3FOeGhaaz8hNHYzdDBqYXA3UiF2OWc4Q2hFQXozaXI0bz9VaXxZPWFmY3Fkc3xlVD9kNnFH Qgp6ZyViMyU4QiZEYDJSXkJwOCgqJnA5bEojPT5yI2Ilc2tLemtGYTx9RGhhdEB3QmxfUntGc315 djduJmVRd1k8S30KemFOQTFBI1ZfJDA9YFg9NTB1VnZWOCFJT2pXcD1aQGllN0FOUWcwY0ZqPD4x T2V4MUE2PFU/QXtvVVF7KiZzeU5qCnp3JTx2bTRPZ2RMIT9IOX1EbiN7YFIhTyU/LUd8cHFjZiVl el5xbEUrbVhLKF8wZ256SlhYczFuS1FpPldzWlgqZAp6bDBycSE5JD9+RXFMbVpoa15pZ2ItJWBT M1d0YHA5VGVHPGJnd2s1P3t2JkZKNSglMElfRXgxMT4+dHJxWkNoP2wKenlrT0F+eGl8TmcoakY9 fj1ENThxKlMoKUA/fiVTRFhfcFY/M2tTb2lNaW8pO3t7KTBSZEwrMkRTdWsxcSQyRSMhCnpXO31P dyVXanUpYVd3PFMpfWc1KyRfMjQxQDt9bGM3RHpwU0U7PXQqT092LVMoeXM2JlpxMipET1NseS04 fUFNMAp6RU5ucTtoMUV5Pm4pNiFmYW96Vj9eSUFfdnd7bWQ/Pld0T0xpYj9EQFRpWnpTZlA5MH5F TURwLWomczcjPDxnSGAKelp7ZV98Mj9md254JWApOUt2PHozJXhvc2lOK3M1P3NqX1p9WEpQUTR5 UXZ8bUpHO2ZDeGc3bkdQZEspfUAzY0k7CnpYfHd5SSt9XldQeGZXd3pLa1g8S3lQP2FKJmNHNlJU fG16OW0rM0VzNmotT3BRek19bHhkUn45QyFeV2l6IUFFagp6cWdhajNzT3k2dUoySE4+djd1ZCkq Vn5MYnU0XmRWQmhzQm5UUzlJJEV+O25eY2QhaihJSTBLSXVfZlNXN2FANHwKem1IY3lnaW9kNE9a OzlsQzxlaT0kJW5veU0teVhjZkxMYUh2eElSSSFJJWx1TXk8O2RTbkJeYWApe1IrP209MyZSCnpE TFV3fFpeZWlgSjd0VEQ3K1BYZDVnOD4wO2ZPeXJuPHkmM1l7MTRuYj9QS3JKI300Y2ljbnVlQ15+ NVRIITV1Nwp6OXNVPG9pNXhPbmNjWSMmSlJJX3I9aEpuZmZsZipPZ2NASlpIX1pzb2M+YGY+M1R5 aE9QWEVte2BlalRQayoqZnEKemR6RiYwJXk0ZHMwWWorTGR+YCZFLT0mQytzSHJ+VCVkZkJ2JCMr RnNjTmhjNlE+SW1NMSNnLXZmTlZwZURPO2chCnpYYnJFVTYjcG15JGlBcXk5Mn5KdjdgT3BWbXI2 c3F1TiViRVIjUEAkZS03M0d0aH58dShGO2Q4UFBVPmkrbzNRVwp6en5ObmVtVTYmVXlYYkpGeHE/ dlhgU3JifD0oVmlNazs2bEQ4QHVga3o8OF90OW5NNUZYcDg4MDVOQHt7MDdWNSgKenApJDNFdm9A aj95YnA4ZCt6NW99eEp4a2BeJlJ+KHYyRGxZbjlSXnRua3k9aD49anQ9Vjhka05je0tPJjRwI15l CnpEQGV3cDIqeTN7Szh2emtgRzJOWWt9JE55PkR+c2hvPlJlLV9ASX08QU11NWgtSVhSOV9xTllH IWtoeT1mIzBjTgp6TGxJZDRDWmlINkVjMEM+TFJtejxOOFI+QFBJOz5jZHRYKGkpZyFtcG0xNSpC Njs2Jn5RdkRDdmgoVVRtIVVRYGkKelglN0FMPyN0OHd6Y2VVZng0fUooUFphZSNUaGY+QjR5LUxW bk1jQjlPMX5aU0o3bHMraE9SeURkOVEhayg3eHpACnopanU0bXkhSmF3Nk8wJnhzPHd+cHE7MCVv KVYtZyp0KzwkXl9RY3R6Uz9ISG5tVEZnfVBMPCpINH5EcF5IeFJyaAp6KWFAQioofGNFQ3Fad3N3 MzNOTCU2N3VOcyF3alU/YTI1QCsrKUVzOSE0VTMjKFQ/eVJgRDVFMiFFalVXTGh9ZW0KeiMxVzVa QHBieXw3T3V3RyhZSGx4K19mYlVuKmk1eHlpfk5sa1Q7WnReZHl2cztxWjBKQzJ+blFkWWR4MiNo eSphCnpHQ0xRbUFDI2pvc2VKbHA9VWZ1JThxOFBJYjt6ITBjWlpNMUE/UX45RGhTI1NVRzctYzZr JC1SQEdHcTspSUhCeQp6WDc4TzIrdTt9b29+WClLMmw4Kzt6KmhDUGpvQ35VUj1AUD1AQ2pRaGBU PEBWbVAhQXllPzxNJihqVDFGPX1rP1oKenVkXz9OcVE3ZElqd04tcWEkOV9sJj4mOTlIMS1aZHd+ P35rYjxkYVg+fV5RIy09TVNZI3hyeXoleWd6RHNsUlNiCnprYXpqKThwbGNMRjhQWFElRlRyQ0J7 eCZlWGIwRX1ITkBGZig1NlhpLU0wWGhAdz9UT0xJUV5iOWxNSSF1cTFwNwp6ZEVRVHBkQmxZP1l1 QyZUYj9zPyZqenxZQ3gjNEkrWmxvUTdPUj1ndDNGMzU7d01JR0xMLVR5byN5fnhjbGtWfFYKejIy KzIrcXREU0F6IVcqVDlVfWYmSVAmQD1kYChPI1EqR0BfSCNFZGYzd1ZWZXxFQDxTQHpHeE9hQCVr MV59OHZ9CnpsaWZFIW03dFVVbWIodTNqRi0kYnNjSXghbmgxaEwwMUlrWHVyM1ZmPGhKelpmWHpC dW1+cWZfI0EpWmxjMkVeKQp6XlFHMEU+Z0VYQ2BoJXdESi1nYWxlbTtlcjlocHIpSytBQ0t5Ujhq QTd8I3JkMVExUHduV1M2bXJIUDEyPiZRbGIKelNhKHBncmooIWdYZUUld1dWRyhVUnBQVU5lVjc8 MFFjdTYhI21vSU9Xa1UlSWg7IVg4c1J5NVRpUkxIUGFjY2R5CnohPkpQUFU4T2tQOER4cFg+aSMj fWcociF6JDBrQGsjP3RKYVcwMU1hSHtKe2FSMjJfWTVJbkQqaFB9ZUp2UyFaYgp6enMyfCg5dEh+ VjhZej1zaVVfQE8lQ3BPQ0w7MSRiUVlraFFqczlYRzI4KjtqKTJSKUckVj9FP3I9P2hoYm0mXn0K ektLNHUoPD1lYjlFbVVDKGxmbyswUXRQYSFkflNzZ0xoTk1DPiQ5ISk0Nll6OCQkNXl2V0dZSWI8 RHNxLXd+PiN9Cnpfd2x6enktO2krZSklQilfaUAkaTMjN05Bdj4/VTBZVjFxRm1sI2cmcSUxT2NZ KEVFSiRvM2F3Xm94Rn5HYDxeQwp6aWVHcThzKXloMlBAalhGKXxhIyhMLTI1K0Q+WV9SX2xmKzl5 fXZiezJqOFgpVzA4Z2wlVkEtP0F1UDt+R3wyfDwKemZ3NUY0YkpuIz5mTjlHREtxRWRjP0tyWkNA O2ZzKnkrS1o/SyF8NzJzNkJWIUplNG9LNXIlNWlkMVJvUklqLWpvCnpoNFclQm0zfW0pUXBUIXdG YS1Ac3hHXyYkQUs8Q1hDdSZicVN9PUczZGpnYDlmbmtGfnZfbSthVnk4djQ+fGNVbwp6RThQP2hD JT5eQGtgXj1ASCs+RmJzVDN6Vk9LKWgkO0h9RCotKlJ4MXNkelZAI04hSlZRfDI2O3F0ck07OCZq PlgKemAxKz1PQWJhUmk7Vi0mekBGVjQ+V1hoSEhJKzFid3p9bVBVXmVeVXFueCRzOEBIcGJqS0ha UDdoT0lmJXZ8X0AwCnp0NVhoMSE/VnVBVCU1eSgtKld2Tk1DYWtCdWtTZX1YUytZcSsld31zIXhj S1dge19eMUtlR1BNIVY1MEVgJldNUgp6U0E1JE81T1hWP0FSNVZnQWJWPjNUYGg5JFlwVnozTm9g N18tQlghWjt5UFYmYlFhRihrRG5PJSkqUGpPd1NSX2kKejNZZ35QeDszUl9XXyg2WSpTPkVZeHF8 TSFFd0ZOV19JQjZMRWZTfTFVe2pRfUl5enZodDB8TCsrYElhLUtNTTYmCnoqSlZZPnk3QihoITBJ cTI5YHphaTghK24tYnpuXyV7TF9BP3BAZik8dFloPlNTYGFuTWAmVUc1dnI0cHRaY3dFOAp6emFX OzBQeGgheSlBQHM3OUcmPWY5aUZnQ3FkNFdINTNIIWYhITh5IzBWYnhLREN1bX53NmtKS3FWX0R4 KkokcDcKenZLaT9Md1JBc09yK2FENmlkTmYld2FvOFM1ZVFpN0prVGo7XjdVT0lQfjhpdXJtLVc0 RjY+dipgenlIfEVHMWcpCno4bmElPUJ9XzJePk0wQ2lZNTJOTiYwd3hHYFRLcmJfP25NZDdwSz5N WURhTTNxWUE2fEQ8WTtIeT5jdkEpfGBTagp6Vmp8Vn1ePyklKXtuYzZkIUt3am4xejllUCZJak1Z Vkp8PHxMUmw2fmhUX2c/OT8kSSY+M251b1U7Qjx9VGo5R1UKemshPnJVR3w9WlpEN0lPR2UpdD0r RDRuXnk2S183WF5KQkZKRmwpR0NBZkpRRWZ7VElyP0NsQjFjYlNAcEQ2QWUxCnojKTFVZkQ1OyZf UUgqbWBHRlF4ZXNoeDFxRVZreW4yLT53QXlXcmlfMD9iUXY/Ty02RWpfUEhDe1Nzb3k2ZFd0JQp6 clJhI2gmdFE/U0JSZHtZZGNoWTlvUzhQKEh4U29GITdWclk2ekQmdGtzMHFXIXhvMyVhViVGKjZ6 fjA0Q0wzaX0KemBBSjtzbFo+WkZ5WHxXYCRZSkEhK3phU3xWaldqVDhxLTs1eTZJNzQlMDlKKEs+ TDcqXiZ2JGtRO1VXYEctcnx5CnptZ2JITnNaNForJXZqeXRvcD1sMihFWWJ1Mm1SJn1pRGAwJSU3 QD5LPlRLc34hZ3lrUUk+UktwWTV7YHVfdC1pKwp6eGk9cUNvaCNzKkgpP3heXnNRWDk9ODk7QTNR UFlBX0hDbypmKUZvTHVtfGc5bXh7fjFqKjwxfmdJPHY3aFV4OV8Kel80JFlQaGhnezBHYGw2diQ1 fnlfMjUhQVUjbVooSy0yKjc/dlQwPWxXMCVnQkt0fDJRIStWZFMlbCpMMVI7YFduCnpnKmt+YFVO bng5WU4/WEdONW58emMjWjB1I09MR2FjaDFod1hWSXchYDw8MjBte2NsZlgqVk1FY1NlaGBFKV40 RQp6RTgyMTEyWitUKE1ATUVvd0BZNUIoNVVmY0VFfnY9KzZUPVNlZVU4XzklR2owV2JFTChIJFpI PWBaSn5ESmEwfE0Kekg4cGE7Vks/SCZtTjYoRlNSPUAjTiR5fVE+OEtuTEUpPyhyK2JKRiE1UUJG VXQ3eShEOHZ+bklTPnhzbld8VzdNCnojKVZsKjMyZ2MhQFMxcEFldEJvTldhQjhiSjF9e24rcWAz O08zb1JmUz59UX1PYEo5RVJ1PVQ8aU5XZnlpSWNVSwp6OCE5QUwrQShVZFcreTJ6UnhtbF5fMjhA OXtUTEhTJm1WIz1JLTZMQmMpMHFRTyo+Xjl6PUNXKCN2d2dZT0JjVlgKej9vYUJgS31APHpeVzV9 VklMQkRIX3ExZ1lQWWl0KEEoc3h4KWsqVnpiPHRvUWQ1YHtoSmxSTDl7QHk7KGlJJlBxCnpCRnoq QlhiS2B7Q3c1P2dgM1h8akxOQVgrRCMmd3RkfnswQlRIbXZJOVpzfDUjTXExNThvYVQlcXwhNVZj KHFffAp6VHN0e18ta0BxIXlZWClCQFROOVUkMD53R0ZpcTN5eEJwXiROR1E8fDFBN0lQaSRMcWdx fGpeZkN6PjljJU9MY3gKeihWfGFkNjkkTEFlRjU1SyN1dEQwRmt5Zzk+ZStfPlg9OGBKIT5JQ19S JENKZmsoQnhRc0ZaSEtAe3FkPXolQyFiCnprOT13THFUKW56YHo/MTcpcGYwRU81XlI9JSVUQSVE YGh0cEF3Z2tJaHN8XkxHQ25EKiF6S2k5YHstI2M2Z14wegp6RWlvJXRGdW1WP2M3ST5Ac297TV5y dm5rRSR9cERhUyMrOGU5bVVIYEhfViFVPjgyejQoSlM/KGlJU2w/TVpLYmIKenVRV14lZ1laQm5h KVZLMGx1eUNLVU9fdFZycHQ2eDhQJH5GVER7XnpMQmokP2BVI2VGbHdYMWFnbyowZCpadk92Cnpe TytKZ1BuSW9SbnRrbyRhcj44OyVLR3hOV2B2WW11QDxHOGZZPUc2PmQ8M1NZTUdHdStoLWdnQTVk X1V3IWJsZAp6Qk1ALXk2QUR7RXFZSV5RI0B9NCFCWUhEVF5MeWZAXn1Yezh5ZjxhTClHOWMyPU5i UHVqMV5EKjNIaDBvRkpUJTAKek8kPGxMcEVYYENsQz9hbDZyY1duNm9ZQ0JeMiU/MlNlQT5DPlYx X0UmLVEkY0Moai1hX31lLXZmeUsyLXdScSkhCnp2Q1JKYGI7V0BhVjNjZTQpJWtOa2ZgM3BGbzRw U2ktMiZ5dE0/b2V7YTt3TlAlPVhQcnRyTjNTbGl+Pk0pNSZIbQp6SXJhfDN2K0xNPFlGP2BsTCFx SilZOVpNMkxsKGMpUm1nNzNhRjtQM0tVY09qaiFOd3JgVDliTG1Xdzh8TUJhTF8KekRFbClMdUQk RSVZPyFrZl87U35qdGs/JXN4Tk9oKj1JWCs8OHVLbnFXUHtfaVBRY0FiZncwfTFPSHdZQFpqU3I5 CnptRWFEKE1aVUA7MmVzSl9RRS0za3kzJWQ/YiFFZi04KDUzYkskR0VEbj9JMyFMSDdZbXlsemBQ KXFXZXNibUNqbwp6QD5+QGNycERwKj0pSzZ+a1doMUh8Q0B2OSs+TmJvZ2hVMkl5RXZSP0dBIzlm QEk5dWczbTlDP2N2K0l+O2pHXjMKemoxUzNpSkFVfWBjSz84eXl1N05xYXFNdW0ybCYhVGRWenM+ dDxoI3ZwYzU3JTB4JFZsMCZocTw2VDQzbUc+bSorCnpBTEY1U2tAPFpQJWE5NihiQmZIaXNYWHlz NyNYZmd7OSFmbWcmXnB6byk8dUs+fHN8bVArMEp9Yi1AZndRbntZOAp6SUZMbmorVjRlR25SejNo cCNQK18kMTBHfTs3Ujw3KSRrcjNvPmcpOyFjcXVGe2EkS2dwTVpiWF4mayhCcFpkK3kKekNERF4p VHtEKnkpdkhhLUtvcDktOEJVRDZ1aXU0elJyKkVvb0ErKH02cjY1IVpeV3teZkxxPnNXNj9GaWY1 JTl5CnpNeGM5TzhWelZzI0BhNCFxeXtDWXQxME0taUI5VG0ySjlWUyVKLTFGQjx0QTBVZUdlKVFM X2xoVysjeV40K09TUgp6S3lUS256ciRaTlkoIylzb0RxQzk4SDxRUW5BdENFeVcoKiVXUyVJZXB2 eiRfcnBFUkthZyFPdDNpdXsmbG1GOWoKemtDVjl1Xm1YQ3h4cihNVytfKlh+VEpGZl82cSV7O3FH S3tDZE8kWE5yX3BQMW0lZFpSMUBiUEVQYV44U0d6emtYCnp6I0chNnREciszRzkpdEA3XkU7PzRQ RWQlLUVIakAyU3ZMQU00SFlqSTJPTlNwTl9UZzxUeDhRKVZ7YnRWTlY7aAp6QUlwJDZlNWJTYjRl aWteSk5QYno3cUNJKVFoblFhK19LPWtqLVBmPyE3S0RaPEgrfEUqJUxrcEkkY0dZVSReVUgKek5M N0RQSlpKaGhNNkt3PlArZjc/PCZEUWxHVE9VbkN9JFQxV1FnRXRGOFhvYyptVzVieH1xejBFeENP MzVNaCsoCnpHXn5XPTBjJHsoNTZSZ0FsJWtRdDs9UylUUldBRG5jOT5kJUxDfHx3SS1zX3kkPVox MGkxKntVeXAzUlNYeGZzXwp6KX05NiFtYXwpXng0OF9qVlQwVFQ2LUk/OXJaJHs5V1l5XkNtXits T3w2JmE5KXUyST1OVStqdk5qdVBBTEg0fCQKemZzNUp1bHwzb3kpZ25acHtDU0hWJEJaZkhQVz43 Z2M+fEp3OG96WFU/d0FTez09R2V2M0F8SD5mKWB8Q1JzQWhOCnpjS0sySjFVTF8kTi1ANWFJdSNh KGYlJnYjRXhmPkImI0FecE52REQ1XjVCJjlON0goRS0yVDJ4Qn1PYXNqSDVnNAp6dXw8a3ZtWUtR bU16S34wPzN3M2RkWXQmREdfJHNDeDBZaE9XVG9zVShGNys+a0ZtcXxVRX5kXjFnNnp2ejR0RjgK emZmKV40YS01S19gNF44b14xKTtvd1dEdXxyYXh5WjkyaU5UUFd2PnN0NS1LPCheR2N2Qk5UUnNR PX1JTDxEfWRXCnpmQjRuY3tZSFNRRW1EaCl2Tzs+YjwqS0BMSCpTSlooPCk9NkxPVDZ4QU5iNCRz Yj40VGdVWDFGT2Z1ejl7fUwoIQp6SEJvflp5MD01TigyME1NSS00UXg4UUlqdiloSj1UYStIU1Nt T0ZsUmYwcUhLJUZxcD1hOEM1YSZEI3VJdWRmfSoKel5jOEh1Q3xXTUwydkM8fik2bjwhJU1WZC1S KWFDKS1fO2M8eHxHZTUjdl57MEliJkVveHkkMCVfWjB3bnVme0xqCnp6bTAodVAmTS0hV2JEbkhX WXFzbylUYTRUI1JiYFkrcmkkOyVMTzM0KVFRK21kRCQ/WGBKWTViJGtkaUhmMkZuPQp6NGdsSGV7 X0haeS1tQGRReHwwPUFeWGFudy1EQTJoailTZW8hb3AlZlZhZVdta0F3MkpyfW9jV0omdjFlPCF9 QioKejQ5e3pZbSslUnU/Ozs1WjlEMzcxKFNRc3FZVktuVUA/WU5Gaig4KE9LOHQrP3pNN1dCKW1a T2Y5b2YtbFRWbW1vCnokZiM8THotRllGYSZEcjQqNDJ2bDZLfkA8Qz1MQDNabCsxcHMpbFR0N1VI ejUjJH4hT1o2cF9DRUQqVXRFKlJEJQp6QUNyQmJgMkdjSnVOOXN5NmNSck1OQDh1ZXdCRHNHQVF4 WDExc0BYTkVnNklgWi13KSYyVSo+allydHwyaTJ6RVQKenBKS0lodF5lcnRSMFZmPGUlPUxyNH4k K0M0JERjJk58akYyYUw1KkpXYm5xQihPVVVsT1d4JnhFdnA1Wnw3N1JECnpvM3AxdjZZYThTRklq T2NKQHhhPDkqZn4kVEw4WCp7QUNNSFB3RVZUNl5jIztkKUBgQioqOV5TPSpFZUtLOVg5PAp6K1Ns S0U1aVFyUTJ0ay1fU0tZOT5aNGBLOyl2VzBHYnVDXnh0c3w9ZHJ9LXFKIWEhOSpWRW02K2JiKVRQ dCFTdiYKejFSSWV3QnV0Yy1VQjc1UkUkb34kYC1iMGUzTHNCJmxZSWo/ODJlPT9ARWxXMz1XJG5E b2MyQXc1bDwjemBLQXpxCnpkSWVvTitMIT11Y3s4SzBrb1YqNV9KSDQlJExAYHpoY3hPVnNtWj4x Y0M1O0huckNQZW10Tn54S2NmZHBtQ0x5SQp6e1JZSmh2JVRKNyVpV1JBRnAoP1lQV0lfcT4lVj5g STgjTVVBQjl6UCtxVXRMaHQ9MUNeYCkmYEt0cTc2VWxaMFIKent5Q2ViKD1VN1EoejxtRlopQ2dD IX5BbSF1aWEzcipMcENXeUs8UEt5YjdjVk9OKjtQSlckYjdzfmNaSWExOUNICnp1MDhmSm1Le0Yj ZG40X2FDbCM2NTMrfjx6YD9fR2BVa3hQMU1qU2slVkhvZXp5QTYpQUM/NHwwISVtTDlwRkZZJAp6 e3cxNW4zWDV3SmJxJkx+bi0qbyh2JkJ4V3UxTz05eW15cVFKKGtiazwwe3pKIXdGZiNNI09Oe3Ns Sm8raiZifDwKekZxU3MwOCFOJmtPd35qOWtAQDgyPGhFVWNxKFRhS3xIciYmNzF8fnB7ezBVdURP aExVMHd3YnZ1eUFuJD1hdyUzCnp7VjJjcj1IcmFtVWNEYzEkKyFNcGk/UTtwTTF+N0A5fWxMUnNZ LXN8aikrWSllOChpQyt1a3Zyen1nciQtX3ZYMAp6U0huREtlIyRYLSNkbUEqUGcyMDFLemAkR3lP Rmo0KzYrTnVmOGVhJSVhSVdQTTxYKWxxcnZ1bipuOGBARDdXQH4KelNPaTc3cXo4ciZrUz4qeTVE QXE1bHR4LVdMYl5kMU0zNHshJHN0OFJ5MVRtPnFgU0xvVjVwKHFkLW42fXtwe29ZCnplRSRUMD1I UTxEVVRhLXp0P1J0Yl5TcmlVQ0BYPTBSaFhVUEZgZVFSaUspTVhWd0hqUWVKeXM3cWpQUz0lTW1m aAp6RHwyMSFvK2tuRV8rQkZPMGw1Vj11TUV+cjkqbFpOQE18ZytENlFtZ2N9dSZBR15oe3l4ek4t Uyk3eExJbjElcHIKek5ARWZES3EzdWphMShiJnZ9PWsmSD0le1lhU3RLfHctYjwlTj96cHVVTCtZ eTBiY15pYSUzd3xse0B+MzlGIzl6CnpSX1ZkTk5Yb0diKUk4JH51RTc9YT85fT8qUUZvJXhOPE1Y TTEzPXQjQFlTWDZOWk1RKSRtTyRXYUxrKStaQiZkcgp6K3MmLU8kTkFGaGs/bXgpV0lJKGhKbzdv UEdoRldsLVg4fjx4e3tPMHA3bUxWUn59I0ltcXNLbl5xYDJ3PiF1SSYKemw1NnYzU144SHlhcDQ/ ViVpaFBpMXxrfWtSKnlyaF44bXJkR2ZrPjUyUjVfTDxJWXg/ckN4MiNaeFRJd1hWOW98Cnp6a3ZO OXhvSTRPZDkwSUcrYD94R0g3QEIrKyh4SFYrI15peiooYlR+Pk57Km5XaTg4MGJhNjh3dWJXOVFA I0hRNAp6PF5xVTZ0KDxrNHVFciEzbVU1TUJkN2k3LUx4e01TWX43KWcrOFdIO3AhR31qLXMhSGJj V3MpNFk2Zkk7aFApKy0KejVoUTBeZDlTbThPcEhRYyFha1UqQnJwPFZEdjxpQD1+M0A2UEFUcTU2 REg5e2lwKmg7Tm94YHkxNylfK1RRPy1YCnpZLXdnNWJSQWhBayp1S2xtSSpMRGUobStWQ2NKRHRk X31IMipgVHpANGB9PlBxWUZMTCg9PmIpOWZzb0pxc21DOwp6U3MpP0w8QDZIUmJPNitAcjlJRWM9 d1dXPVcmRUJGNGMlWVRVaytCX0sobTs/OURaWmBxJnI8dztzXn58VFBkJDsKelRPQ2kpRUllRGF0 RT5gcih8WVVhdk9WJFRqP2glcFk8cHk2Vk1kd0Y2IVo7P0xOXyQyI0liNjgoZiZwOVMpQVRQCnp6 dnI0QDRRRFZldTlzSnFDMj1ORXQyMWhjJmtOWWJ6Kz1EWXdCMT85RGZaLVBlPW8tNz5PP35oXklz ak9vbWh1Iwp6OCM+MjV2V1RFYlZCb15NP1VmVzZ1NkFRX3B0OEVNVyNYUmU+OHJWPHFifk5seHdI eTtGYShnYmZoQzdmV016K0AKelhZd182dH1IcWluSmoqaz9YaTBIYFV8cl9fP0dSfmZ8MnRFPHhM KXhVOEh4aFkoTl5YSzNmdksqVSl+ZSUpN01sCnppbnw0e3NiWjZoYDlrcUI2JWZEUi1fKFFwdDRT fGFKUEEqLSs3JTt7aD1sWlByQjAhVjJ+WDYyOUo0eEEkRyM1dgp6WUxBSlU1bCNQeW5UOUMmeWht WitpNkNqfj4+JilyO1BRUnFIO05UPTNLOElRX2N1UUwrKFJfeFpnKzt5O0k2cykKemlKNWFDPkVY aWcqPXFwWnBvaHN5dEEoRH5LQHFfUXB6dW5JJHN9b0M+fEQodCFqaUFyemZeQiZmUn01ZURoSVM8 CnpGfSVDR2QxVGpwTylRRjg/fkNUKj9OZVBRU1czc1RkajBAKlFuNj5NQUQ+Jn1zZWlrI0psWFIy eXJgRnY5YFowZQp6O1heXlNvUzQwS2NkM2JYRzdjNDREeG1iOT5RKU5CMExzWV5ZVyRYSXg7MjlX PkxGNHBXITQ8TiNnTWtlQjVQQmUKekN4UWB8RWIjJFYwanJ9YW56MjhhNXwlVkczN3JvRDd4fTEr NGQ+ZSk9UFJoQWl0Mzg0QkEjPnhhQT1KTWAxOXJkCnpQJDxlaF54TE9HQH0pQEV6YWd+VFlXY2pR PG9+anlLUHF7PHc2I302KlU/TEIqaE1CVGlvQXZvYm1GYU94TmkzPQp6NC17cWBtIzFuST0lX3tj Z1Mrb2lTT1B5MnJLfU03eCVvbWppT1lNM3dvWmw0SUtJdH0lanpKZlclaDgkdXdCQ1IKeiVXQXVA aXZtMWk9YWFtYWpUWjBSYFdmK1p0aW44MjchPVdPb3x2a0tsVVc2d14oNGEmdSg/YytkSGFlfHpx TzlICno5dk58JGBlViF6d31FQXpDNCMqWHRNUHZGWFItS3dHYzd6PWFsSTN+UzE9PShlSihwU2w7 d3o2TlVeMV53Rlomdgp6cW1EcTcre3FNdGBVYzBMU0hedz1VK3t2dFV9YntaQEpaamZ6WVFxJkdC NCp5TEZCISswI351MGFyQlFfWUYwPjwKektLIW5+XkYwPlBzM2prRDJoWDxyciRoZXo+Mjs3IzFB P0ZePE1jPXo5OE1YTG53VyMxV1V+RHlRTDBMVjcoezBKCnpUUXh1I093Wk1jan54RU1VI3w/ciEj QEsoPXJTQnpSVjJIX2NMNkxLZXljaWZ2ZWtRSjR7SjUyc1JnSzlhM2ZOJQp6QnFgX2R0UGJWP1Ix fHFoV2NHN0luZmxVY2A8MGdxRV5ycVpSMXx5Rj9XfGh9MDBfZGpoMTRzbkFUNz40YDhvansKelhO Y09JPiZULXdSa3xYSVRQQ0o3Yil3RT9QZXRZelIpPmhrM2xDcWRJejB6UUhMQXl8Q3FOQSk+UEEo TXtqOHMzCnozWHBVRT5Ob2MkKTNSSURGQi03RmRxPnAlJCo9cGk9UEpoUCFPR3w4bG03bjlweSZT OEJOMHIyU3ctVmM3dTVIPwp6PnotYDxCKTF+VyE8dEBjZU9VS0J2aXB2JDR1biF7IzJfcXomUllA ciMhSWdWKkwxeShNP0dSa2hheG5ROHItcVIKenZhbXReXkJ+UjlSdFZZP2cwNW05UEE+cEU7M0lj fWZZcnhaXmJzOXMlaUJMdCg5Xjk9ZGIkIys5NGg9IWk4PFF3CnprJE58NkJqJUdAQD5JTlIwLXA5 XjVJeThPQTc0fG07cjdCaThJfEtAUWR6YVpoVTB3T1k5UTBtUXktdDh3YHAwMQp6OShKdVRieDBC bEhTX2pPaHVQN15YS29FQ2RtSUMkaylgbTZMajhsPiRWeCkrRD82MntRX0xyTExaQSRwVHsyX0YK emBZUFN6cX1JcGR1MT4/RERoX254YDhZZUUoQ1Y2WVFfPSFlbl57cSslY3ppRkN9bFd8Qmh3PTNv dHlLUHh3YGB0Cnp3XjNOUnVfdClaZjY+TXdFOzVOMklfanRAdWApRT8rYDJKcT55Y3J1aUprZUs9 anhLeCZyWUA5ZndpeXVuMjdFLQp6e21Aeyl6MXBXY0ZxT0p5I2MlNHw2MDVLVSpwak45e0x2TSQ3 QGZmQjBrb0BMKU90ZFpuWDU3VFAkfTg7Yl8tQTcKeiNIKzA7cWRhe14oMXVhTXZJPUZNQXt2NTZl YnVITHF3UCZ1P184aWZQM1FHYHNtYnk+IVJTYGRGOyQ9TjFUXyh5CnozPGFfNEhSfD5lV1FZcERl M0o5cmZsc31hUXFMKjtaSTk4SEFHXyRQOE40X3RmSFYzeHdvdjk7bGI7LSsqeWFQUQp6VG09ISlr KDVYI14yQFpIMTc4ZH05OWtzQExqX2VHbiE3ZystKE9sWlAyIWpiZVppZVVHZ2IhaEl4Pz5sYDx0 YUgKeiN0UTVwXmdva0NUM0MrUklGcH1sbkJQdGkjMSpNb0oyKm8tZCRjPVZKU3tVTCNwTWtyS2Ew eCs9TXVhPkI9cXR5CnprPX03SXZvRWZSSHdjaE5UVTBFTzQpcSkrZlAzeUJgdjslTWJOVylFaWFw bi1EOSY+WjJ2JSFrajtlVCEmWWReWgp6VGYoZEBITzdtSnE4KFhKSC08WTMyPGgkVk9AdzBoNkZ0 S2wpbkhYMnRoPCRNMFY8T3NHWVVufC1HMzY9JEdUP2EKejQkMlFGemEheXYrTmlUX3lnSTRyQjVO UUBjSnktNShrSW1Ie2dIXyglR2lBdnZrZmdEKUpJaW51X2AhIS02a0hZCnotNGJEQSZifXJTdTZB Jl5Pemtmfi0rQ1BRZ2Y2YmFFTDdBQmlTLSpWcmEzTktDNVMhV2ZvanVEbTBUWE92OEF5ewp6djxh XmJ0eHIrQWA2MmlHeXtvVThXTlMmU21yJGVVdGJTTDckNnM2UGF2ZU5OdCRJeG5pQ0B+YyRTTFoy YEJfYHkKeiokVkN9JElvYSp5RSohRCVyRW97ODJJbUtISWRTPzMzU0EtPX5LPztqKzt5eT1ZWHlh LT9kRE1pWktAVVFKd1RqCnpzbElRfnd7Y1NvZXhjPFQoSkhBQVM8TytXVU1lendGbncla2tDQ2dj V2YwKzAxOVBPY2Q9flViZmMtIX4hTmclJQp6UkB9MTlsJjM4fk4lUmRiQ1dNIUJSe3dwbDJSbldZ eUlzbFFFYFpmNitGXnR3R1FXMHZocFZgM2BnJXxIRkAhZ1MKemsoKT5UMl9nenBOdmtpUyopTjBX cnJSMXUhfjUreV9uWHhYc1JrOSNkJGV6amQ9JTY9PiNUTyZkN0BnRmFMPkFVCnpkXiZNc3ZZd2wz KElqK0U7Y3VHIVQjJWpiNH5+MSsyeW5HPldHVDRSN21ORz5teWtOeXFaaF5xZmoxK2s/QEJiZQp6 I2Y8Vkg4Z2ZySFNYS15fVlNATHNoWkp+NkEwWj9zKF9lcGh8TCgzOXd7NEohSn0qSTRCJHVvdj45 MiREe15eZT4KenlfQVIpK25vfEFNQDdxNVNtKz1YKDA0UnkrI3l8KU1ENXlsJWtAUVorU3ZqV3Vv dlRxTUNoQnp4RWgpPE1QakdKCno1bWEmeURhe2g/PC0ja1I1eTdpRXFFJU1ZSVcwbWxBNkQqKEM9 V2koISpqU18hODtgcnNfIzR7RntXaXcyfllNcQp6bmRHTXlHdmUxO1R5NlJfcSZJUnw3YU1qYGF5 JWNqJktTQGM9dG9Le0lLdSVqTlk0JE9RWE98UW1HbmVFdCl5NjcKek1CYHtoNVM0VUF0T35CSys0 WXhtWUtLcV9fOFMkbWpQNHQkendHPClXcHU8MDxAOUQpQ0RfbVFZWlBVPWdjdyloCnpnUnR4ZFV4 KTFxPHteS0YrNVJXRUpOSDlIQnJjSmVsS0R+SHg9QWdmdWBEdEBMaHtLazRlbSUoQzVFaF5mYnd5 Kgp6RDVIWTxsX0BeMmRaKElMSVZ1al4wLSFYaVM3c0J5I1ZCOXJ0eDlzI1BFXkM3aD1rZj10VX1u I3VZKzVpLXstcFkKelJEdFNxRmxianJJRE9eOHNiWE5HWiM2VmJibEhVRE1XYnA2eWJZQGtEJk9N NTdSK0BHZ2wqWWRjNSVRJj0/WS10CnpALVoqPi1jLUFad0NhTCMyfT4/WDA+PW5tJW52RFpZR0Vn eVhHeC1SQnJsa35rSVFhTytMYlNrTCFtOVVoeypMVAp6JV5UPFZgRXtXPUZ3XnJCVj0oZ2k5KDZe SnlHX199OTswMmZrYGk0bDJJeHt4S00oJU1JblNaPXM+NFgkQEUxc28KejhHUE8pa0NlRmtKfSlD Sjk+X2JxVz1uRG5ReGQzX1UjQzgyWl4laWsrMUo3YHRQSFoyKy1sZHVOJTdVdzhqRVB3CnpKZ2VD QClBKklgUDJUVXxebWBHKnBjemEjJlpzVl9GK0hGelBadVV5c3pPcig7eFE4YXhFQyQyP3FGMXVk em8+agp6LW5fQUA3ckYrQjByMlZwJnojQT0+T0IxfHNYNkB2MkpjcjVmd1RtJDw+JVIjcTxpJkU4 Q0hBdFoqOGhxTVB2NCoKekpxUFpYbTRfV143SD88dF9idFk2aV5aM3ZpOHwxWXJUXiFjX184fGJT VExoWV9kTmpNTzJTajx0IWVKQ1E/bmxACnpTMzVNN3FSKSRKUTVyZjJDX1hQTjJEbjFOb0E7dypM PyprVjY/RDxaI3JpP3U9NHtsRD9DVnNTVDk2WF42Y1ZOUQp6cUZKJXRZJkBqMmgrWHJtQEBub3kx OHw9KXMwMG0weThiXyV6S1Y4Z00ockpJdVV5P0tidiFwOz93UCljQHNNPjkKenZHRmB9dUgyQjBv TUZQX1U3KmwrTzRYNkZxV3tnPTIkT3hZSntafmZEfjRKZ0F7QnBzJUtHZ15FRkEhdyV6aWRNCnpg VlNjJUZjPyRCe3Bydm1NZSlKZWZtZUY8b1F1YkxTPj1VT3E0NzhuNnRaJGBBKTxLeE1oQ3hfclol RXhWdW47MAp6bHpudSkhfX0qWUxJSTZ8YHxYbD5PLSZhQ0Y3ZCkycio1MGFqSVA3YTN1fE80O2Bf TzR4PDE9MWUoOSheSCZxaDQKenhoO1Naez9ZajZ6P1lpckpHRm5QZD1PSl9ENE1SWkxAPUE/cj0k YjxrSHkpVklqJih9eXpoRXEzZlhaP1BkN0ghCnorMDQzeFg3dntFQjVBeno0bl8lY1lXO0xIViFM SWtWJl95fDZsRStGNTVJNW07IWFMJmh7V0F+SH5XZjVhKHNIPQp6X35lTGpwWV5OMjItY3VnOUst KExEbTVFUWdLV08pT1k2NVNFRSVVT1dFMDJKZyg5Sz1DWV51ODYyMis3dXZMbSoKemJqdGNvTD9+ QkJeKm96NCVZNjh4Pk5LbVJgJntJKWMkbW8xNypJcF9hUjA/SXI3PU4yTWU8LTsofH12YGAqJko8 CnpBQDRMOElrZD1GbUYkKlRMbVpiKUcrTTtzey1TIXZRR2xldXFkNH57ZjBxfmg/Y2dSQ2E5Z1g2 I0YjPmxhX25TTQp6RlMxfWVNN0luNng3UzsmXitTZVEoRFFmWnUzOGp6eztRLWRfQkpffTU0YWk7 JWw/VklAYC1NIVFjPlhqK2k8T34Kenstcm5nVXMrLTg3SChJWWFwR2tpTTlmNmNxe0hPN1EheUhn Y0Y4dWBWPGFRdFhDUnIjIVl3TnYhWGoyUmxAK18kCnpvTUFSRCVJX0JeJHhuRU8hS0lKKFJEMD1R QzxmWW8kM0QoITNySnZBSFJgYzcremgxRDw4OWBRSGhzbjN6WkdoWQp6QGw+SztkcTh1bmBYcU5s V2g7MkE/RHc7LStRcTNkWW9kNjR8TTkkJmdyUmhVdnB4PH4ldTEyTEZ9ISZaTzMwNzcKelEtenRq QH00fVlET1lvbjNhP0NRdW84enpnJTVRRilpfHR5KSR8cylvdk4lcVRQSUpidkMoMSRyRzhseiMl IV57Cnp0XzhPcXt3UVVuYSNFTCFiO2ImX0s9Uz5yMCpISD1XRnNNcXBJZ3o2Vk9+RCFyQ3QwPGtS Nk5LKUIxZmM4LU52RAp6Jl87SWo5JGpVNFA5KFBLdjhZSVFtaEdeN2BZdTxPU0J6fUImdDZTPTUl e0FGKEV2UkZySE1DRiF7ZSV7MnFoZWcKeiFyKlllcHgqUXNUSEgmd0E4PTc2MGk1Y0I8VnpZakA+ Yj11QCR3UE09Jjd9ekU4OzUoa3JtP1I5JCh5a1o+X1VCCnpaQmlETGVyO2U4KzBuZG11dj9NOWFz QG5pd3AkaUNhYFQzJlVzUTdSPWNQdDI0aDM4RlRFMnlnRHwlcT9ucE47Zwp6OXE8Q2lCcFRlfmUl TUo2T2xhKEEtQ2wpOURkKmhtbkNyLTR3XkJmMCFKWjJ+b1hlIW4lSnJ3bVdCdkRaJU87MS0KekNP fkNLQGBaODE3P3VuVjtxWV8mbX41VG8xWUsmd2ErfHclUiZNandsZ2FYRTx+YF5KX19DWEdDbCFf STloMn1fCnpwXyEtamJDJE43eStxNX5PX2lRMzIwWmJAdj5GUFZAZzBIPjNrMytLPylQYWFAeG1V OVJ1QTteUHJmVCpoazU0Ywp6Q0lWcyRrTE9wXz5weVomN0I5TEIyWTw7d2JhYU4oSXE0flF5fih5 RmReUHRSKW4rWGc1fWRwfWtWYEFrd2lAIXEKemo7djxvZlAwV1JyMTFIP3VKJnc0XmglTFZtR2hC TmkjODh8I3hsUXlQZUNNeyVsWC1aVVArMSNsUVNkfVpFNWAyCnolcXU4QlBffEhDTnYtSD5GYD1X XngmbSUlPmVpX1ZxTTxDKnlMV0ZVOEhwJXlkdF41fVhscztZT3FUZWNRSypoRwp6I25oUn1gPSMm eldXUmNnK2J5I0UjbTFqVDNXTjhsdE9RJWJed2d7RTxEcCtKKUcxKTZQVFBGOExCezA/Y3hOZysK enZiK2w1THd8KndBYGZQdjZkbU5mTXZldzdaPiYkIUtZOCpwb1I7NlVhS3kzeU9vT1JNNH4yWD02 RjszUDltMnw0CnpKZWxsPWp2PyZaTSQ/TnxjU21ofGE7eGUlOyh+e0BnbCVCSDFzYHlzalorejt4 aks/byh+S2RwTikpZ2hCODF8Wgp6O1FeMnExbXJ2d3EyXzRMP255e2hQQGkwXkV5XlBtJnNsT3I2 MkxkZDliWGMqcUw4YDBSR345Z2BJTzZWWikodjYKemk1Q0pDOH4yJDtAfnh1Rz4wPGMxKjYmYiE0 PD5Eaz52cyZve3VRVFFWM1V3IyszOVMqcnszMllBTSY+VFZAZ21uCnpsfGxubVR8e0BsPHd7eFNx cXJiUWxJV35yXmQ/cCRzYSRPQFNCNnJ3QWNHSGlvPjlkV252VVBPKWQydmorYmkpTgp6bUF3TFI7 a280amB8SDJXdk1rTzNjOzJDUldiJGkwVjNHdHs5TXZATkB7MT5+YEhKPlBuRHdXJSolJCpASlVl a2oKenlAKCQhUXg8I0psNG18PnUpSGlKJDZMMzxQeTdPfl5Ycz1SWmxeJT89MjNKaTdFZFQtNShk ekZXWDxoKDBtWkY0Cno5N3MrY1hoI1Ntb05gPnhIQXhLYzJTbHpkcGtlQStmTjJ9UTFLMTV9elRF PiNeZDglTW1YRUJgQj48cmI5cDQ4MQp6eVhaQnZESGMjdXM7eGNoNkJEen4jenZ9V1F5VTRIcGxS JGdYezFNTXphb2BYV2BHaXRLcWNUc0Q0R2A1dGt8QnAKejVMdC1CYCUqZFhGWUk0eVE5TFFMYHU7 NH15Ym1gME15U1hkUmd6M2BnITx9VSEtWS1mKT8pYGxyP0JEbHA2bSFSCno5PGBpXnEocTNXJDdW VyphVGJlJXF1QUNQMEk5M1dRNGx8d0YjZyZISTFMdW9RWTh2TDZmdD9ZOXtiN3VXbndpSAp6ZnYy QnRLSWk5T1J2d2wzJWNPN1hiRnc4MlB+NjVabGpNQXdAcF5WJWd+d2E+ZFVeP1h6dHFKWEA3YzI3 aUZLTGcKenElYmBlbjVNM01kbXQze0deIWtwNjU0dCQoQHRSeitZV35uYWFpLW43THROckF2d0kq QC03Rkl5Tk5BY0lsby19CnpjMk90bFdmU2NneSVHTFpjQFFRI3k2VmJxe2dQMGo/ODlnSTApanl5 ZFdTQVgwclN8YzJFWWlpX1VkI1ZKUilFOQp6WSQpNDhhezMjdm52JjkjUldJZDszKlBARUImdW1u M2txU2QmRUNmdj9KNXNhNkR0X0R4bk5tMGVrcXJ0YElWSlkKeipVbCQyX2YwbytCUEhOUCZONXBs SHtUZmprcXdQJSpkXzxqanhvZ2V3dCNjSWw0d1RIK3A3LSg9TDEmK0AwciRxCnpjeDx1ciozelBS Pjw1UjhOQzVVc2ZIfnNtT1V3eCVrb3RzND8kbD0mZT0rYmNZWWBvXjc+bGRTbmBuK2RGYUJPegp6 Y1V+VkZeRkpMYnM/WHphcWMqdCFCKmkxfU1MdERHRzxGfWkwdk40OT5oVj4/KylXcXVXTWpwUUtI ZHQyQ3wjbzIKel5vMCtmJDFhJk57VzgpPGowPjFCe1d8T1ZTXzFSPVh7c3J5dTdQdU1rQWMpfUhD blQ3V0JZPkVyc2BRNXB+UlVYCnpGWGtJQj13OXt1PHR4dG9VeXxwQkEyKjR3ZE4+UHJPYSo9LUUt fXBwcE47VUQhY0Y/VWNafFc/WkprOF87UWFVawp6Ynh0KDt0V1l7UF4qVXxmOGQhKF8+SyRLXzlW cHE/Vjk2QUZxWmZPTlgkdlNVcTg7MD1sbERDYEdvUDkjcl9vTlgKejkmJCVaeyphfkFUdmNFLSE+ V2d2KU8rNEtycSspMSYqQGpjYWFkTEI0dVh1JEpyRHlsRCZgdDw0PmZIOTBOYygrCnpGWUclOWwj JUk0ZUFkcmRTKEVHezFBdlk5QmkwVXx0PmslaHM9RiU5RTMtSzNxdkdCIyQxbHFqaEV9JVRYM2pF Jgp6MHJmTXRPeVF8SHB4ISUqNld+UntuQHxDKUc5ZTJ3YnE5N2xHMjFRSVJwPm9IQHo4RmRjMmY0 T3RLfVBJOFd4STIKem98a214T2JXMHdPVygmamUtNFhlOTlyRnFmWVlBM3IlTVIyOEwpVj9BdypE NTdYTW1kaiVBJDlnempwWTFYb0x4CnpqUnomcSFTNm9+QU58fnJkOFVZKCVxWVJRMW0kbEpXYTI9 aEcjeUhzR0luWGA2TE1SOVM9fUNtbGkwb1JWaGU8cQp6MmtEQ09sPE9GdEQpamswKS1aVl9Qaila Xl87dztZMXF0PG9hOzhKMThnSmxLKlorU2okTF4oUVM4emtpeyVOVHMKejNha2VwYGdYRz4tWG83 eUZFZj58T1hzZz1DQDwkVUotakVaPWFRV29QdEJnUFV4VnU/JCk3N1g3LWBfRndrfUl0CnpaN1Bl QXlxbiRwOSMqbUVJUmhCeTw8S3pzbiNXWlNAVnVgJjlAQTBRVHRaV3hefFdVSVYyIUolYEB1NiFo KnE9bAp6c0N+b3Zua3hNTUIxYU83VHFSPWU8R3lvViE9aThxVTV4UmpATmc0SEU8UWJ5ZD5TZ1lR ez1saEd5fHY8WXYzKFAKem19WWsqajxjMEZgfWBuVFQoemp8bDI9OVl4NTk2cyZOc1hoVWlBVisr NntXUTFxPy0yR1ZWJmlkcERRQm01fDYwCnowbE9FNENaUnZwenE9fDVxPjJJbGxWZnZFIS1+ZnVy PyFDZW1McmZTN3dqb3ZeeWpefHIrKGNfeUQ7SjZqezY+egp6e0NWQ0ZyVillUjs+YDkqe2ZhczRz WTxANC1wQWM/P0hVcHlmXmYtMU5FSytFLXNIQmk7aSNEPTJDQyNSITluREAKemg/eHdJO3thfk5n ZUJJIWNfTHMzNm1tRExrYEk5V2NIY3l4QWN3fjxuQHI1dipZMFhUR2p2VlMhdEcrV2w1Kk9VCnol VFclZFIkRiRhcm5nPEQ2VzhfNDlQZy1DdXNeVVUrR3BOKzhxKW5Tdk88KndoVUIlTSZRUj08eytf QWB2TWtQJQp6ODFoYX43PSRtV2ROTjRKN1lAMCRFRj5mWXQ3XyUlUmFOPUdLKlp5ZDg3TWlgN0xl PUBqZko7QGJ7JmVjbHtkRF4KelF1d15+Kz0tbzE+c1lVPlIzeyR9KSkwRWRGVG0wYTNoZm1TJSRi PDBfeCU8VkV5PTF+YlMqMkpfRiMjJEthOEtyCnpJWD1TWjJOWVdIPyVVcEd5PEw2c04mS20hXzhP PTtXaW5eWk5lcSZDTVlEQ3xvWEUhfilII3xaMDZiWC1yUElxPgp6ITFBWTtfezZeYGZfMWwrX15Z KTUyKkgyIUk9VUoza2RwT19KOVNrRzJlUURtVWNubmVReldkS3s9UzdwK3EwPjEKeiZmYE5SO09u PjU4NylYc3s5Ri0tb1JYRChQMiNNWFhwNU9jTHxFZC1KP0ViRW8qWWF1S09ETilwSTMtNT8tN2hB CnokRUxMN3gpNHJRIXdtbnsyTyZQc3Yqdl5QRUZuNityY2tQV3prdkxnamByPyNNOGk1WTE3WFhw Y0p+QF9jblBpbgp6b3N3LUJVQWcjMyM2eENUQXFsSndXcThQKUVJPU82Xjt4dF5vKlMtKUF4MUx6 eVp7dVQoZiN0V0FRV09ad2cjOTwKeno4O1FoR0EtZkIlQDx7VmFAe29qNDUqNTUkeyVHcyU0MjNA Pnw8MF4qJlExNEpDfmwhWWkwSSopNDUrXm92fjYrCnpzMz18Y2pgfjRwT35BMylxNVhEI3JBeGAr eWNnT1godkxmPXtAJGtQek8+cyhMNG9wSVFESW1rODYjKllWQGhuKAp6IUleIVA8d3I2PXBFOz5r VCFBbHFmb2MpJXg3eGohWFQ5dTgmdTAhMG5PWmRySTl7cXd3dG5+dnVjKzBvKCZASSsKekZmXylZ d1BlfXVBdVk/PkBmNl9qJHJAKFJDM19tKl48cSFWPT1rMHktQ19KYHdGRTthRXFZQEJZYFhQdV9n UnFgCnpOQFA8b15BP2ptYllZQk07bm93cF5RJDUkeXU0PyVqQiZidzZmc3N6X3w9KyM1M3ZYXzRt YHx9MG1WZnxUKX1WaAp6Sjh5WjhZUzJ8KnIxS1N7WnwyT2NSfX5SNnF6WVVxeklIQ211PyEzUG8o UzM1X05GPjNJIzwrWT1KcVMwd1dDPGIKejA2VCtRTn5IQmVHK0JTTnZobz9iKzNWUXYjRzIjayhX My1iR359cF4ldFZLO3hVWW1DYn1iJHZobWBAN3BoTGVGCnp1KkNZfF8mM2dHJlVQSVVNUiR3eVVi RTNDMz5yPz1zezZBaFZqQklWKzZeNFpkZHdUV0prOy16NG18MmdKanpzPgp6QH5sfjh3Ym9rc3Np RTY+ckopdEg4bkQ8e2U5S2VqSGJKT09PQ2ptK2duPVRaWUxVMkhPUEQ+RmMpWGwyWjBUdlcKem8j ZlF9aHheWHY1dmBkVnA+JD8wSChGSGhUM1YhKUV1YHNOeUFnfl5JPUhYfkdUPiU4JF54dE8oKnp8 KTdMdG07CnpMVEc2R0UzZ1BPazFpKHQ/Pj1LWTBHVVlZcSZtfX5ASlNfP1JwfWFXPW9MK1ZBKEl8 MWp3eSh0ZzkmaXQyWkc3Uwp6Mm0yZFNwUHU5T1NOa1dDSElwc2ZDYXYmTD9CfERAPS1eNGphOTZB bCYqKWhVdncoVzhiOUxufEc5cSluOGooaHwKem1McWJVVm96JTR1TD5kXmk3aD1JS1RZKFg+SUg2 JnlUV3kqcTR9e3UtTUhzN1R7N0skcDRpcjJ1cTZtNmJpTkBrCnpRMkhFNGwlPklNekZ3M2UhZ3tN SXwzbTZ5YnEmPUNQKSVqKXA3V2g0eVo3KG0zeStAMFRIOVlDYjRNbm0mKGhyIwp6cnV8P3NZeytF SyE8VnlrTzlPNzlIZCpsU0MlXkVMOFdaS1dKe2NGYThpRjZRLU0hQmE8N0E2d2dCb2JFdUhYa3cK emI+MEFWdU5BbFZMUFZGWmV9QzE/U1FmWlQwKnBCNWNmdEBiO19QdD48IzFCM3Q7MFlHVX1vZn1A bUdQKypqZ2FaCnpTbWF+NiVPeHo7NlItKX40ZS0tR2gtYVB8IyUmSjtCZGhtaVVpemFXO2ohLWE4 T3U0eFZBXzNLVlphIVYkQ14mMAp6Y2FSNXIrVXt8cTRRJlpoI0dCWnU8blpvamV+aF52T3YxT05m NkhMSkZqJF85eTQjRUdtRH0tREN+KCpFVSlUQ1IKekRFaTNnU3V6flBVKnBHXklvWTA0aT1AJEVD PXVaez56e3EoOT9NZ2krUER8NlRBeVhtb3ExTHNTTmxNTk99JnxeCno+QytyMjZTPk16e2tDJDYm WjhfVngre2ZDKFAyPVFHRnpRcTxNTVU4RDZxIVYwXihvbm9nNGFKZWN8PGQjenZYdwp6LU5ZMkxk SFAmU18ycypXbVRxczVYbiQxb1VzOGF9UEQ9cC1qM2tJLW1hfiE5aHFQfWBoQlVKcHtjPkslXmop ZkgKekl+JnNDVXJHWVVEOXk/ZipSN1R8KyRsYW9lK2hqMjByKFRfLU40cG9XSVdNZ3pAXyp4TD0t Q2BJdUA8fG5ReTx6CnpCSTUoUnBTRyF3P25ZeVokbUVrZnh5dy07eXpGP09QIzBvRT0xO1VYMEcy SCRFSDRHa1BQOE5mSFFvJFVJTHVMOAp6aT9kfmtrfSE2RkxlSmYkcj5OYHBZPnNYTCRXUlR2JmxO enJGeXpGU3tXJFFeNShndFQ7XlM1fjJWOElNTnc8fTcKemBKOTJoSV4kYX1FKHwqaGR5YXoqNHA/ TT9vc1g7Z0M2fVg3eX49TEhxdzFRbU1HYFV0cT1mfUA7JnV1ej96R0dWCnpyU3RIVVdgMzRebWlY Xk5QUjAxN2wkRitiX29XcTNQYm1WVm9nV1VaWl4oTHY2MUJsTFdhRFJDS2Y1YHlRMV5fYwp6TStz I3A2IWlaRllOenp9b31tcWpYR3NiPUBgUjNNQGE4OVR1P0NxMCNmRVo/SUtOZUdVSVVYSmsxU08q TnQ0K1kKek1QaFdhbypEayR6NHRkNEFpNG9fWWA+SzFMamZVQ3tLQkEmb1duZCRQajdqVWlkZihP WmJvRz9XT2stY2VYSW9mCnpJKyhfR21OSjVXa2R1OEs3ZGQ2NXkkZ3s+R2hCQipAaUU1bl5FY0NJ YmlTMTQxPUk3QS1RcEReKFJYPXIkdEhvbwp6RFRlfFlIaStCI0xgdXpTYVRRWjt0XlFxWWVhS0pK LVBQN1RTQElydStxMjxBQ0RzU304aE1ZMkVLSml3JDd6JkIKem5wKXlYI3pKR3JJQTR+MC1mNTNZ Z2tpK1BGayY7bC1DUWphZEI0VX0mfm0lfEJhNncyT1J1fTlpcWVfQ2UycztiCnpheWdHQ1g3dCFa VFYjVHRaJk5CdEJsWSVUeDsrWT1DQkEoIT00YFVHVz9CbyRIISlIU0wzT3V2IWAqNGhAJFlidgp6 YTQwZndrP0VfcykjO1hIUW92VDQpT0RqXiZvMz1+dTs2YjY3RVpMXztoNGt2ZWNjYzEtXzNQM2pp UUFNWiYwNVQKendDVjlNMHVYNGRvPGliV3I0SFh7c3goJGdCaThffSFGfiVTYiokNkI+clJ1RG1W bjwtMlUmXm8/KCZjMkpyUVVnCnpAZj91NCt0VlchaGppeiskVE5Cfl89Yn5PcXZFe1VWZFoyP3NR Y3dCbSNyUUByd0lDNz9Ye25fUnpCWl5eQy1IMQp6d1ZeQCY3XkdyREF+Vjd2X1ZxYSU4NGEoUWVq UXtAWjFkSGpSMTUzbnRIQztVMCk8dDcwWk88QGpeMEBJaGFrWEgKemY3Zj1qQzYzRFg7TlliVChN VCR1IysxMzNrJTcjIyNuNiolTjJOSzFNfnJqMihmQXRXKT5DQT10PFc7T2x7KylyCnoxRHVgTWNI TSkpWFRTbkc4KDF8N0pvJUJVeipFVGVJXj5NTG5AUFQrVSRMOUFEclNTRTxGdk4wd3xxRFB2fVBf fQp6P0AkeShxKnArSUFaU0hCSUFqZWw9RGNgcE5EIWdxe34temIjNzI7MUB8SGBgbTxXbz49Rkl0 a1MjTThfQSllVjEKekxFPDUzQllacmZJPzc9fE19TGJ9bFFON3xBT2ZXbmctWDtGRC1oSiElMWpJ K3J+VzxZMk9VZlYkc1JabWooenE7CnokbzhRdT9gKCgyVWxBMyFQbDI2QmhwI2B2I0Z4aDxRODxt flZhWjJnU0tIZ3IjYCYoKEwmPigxTiM7NTRuPzBkQwp6THhNTWdFXk0hPHBSST9lSCVEQlRLbCt8 KEplc15+VE9wRTU3PSFzS25wXnwlYGdFeFBRXlEwZGJrdThzbnxKSmMKemUzaHVfVjtfUX4qTFc+ JkchRns1bmA5dyhJZysmUk5Gfj1NNlcwRio1ZG0lekprRDteWWV3ViZocS00eihoPnF3CnphfjYt Nmh2MiMqajBOZkk1cylJQz03Tn1OVlhKKXZkZnhpOXZrJHgpbE4wYFBfdnd2SmheUTliRXM7cUVn LXZLMQp6V2A8WTElfWpDYGUmVHJlQmtnNmp6V3F+PTx7MWV7YWBQK1J0Qmx3VUNuX3NHeFFHMUA7 bHc1MWJvZ0x5IW9KS2EKenxFJj8wPXlBTEpXIU9ydE9xaHlpJGFEMCR5MCVoODJ3WWY9NkxIcTNV YU88ZFcqSWhSd0N4KmQwKnBRNXtUJDFsCnoyKHpIdCZmMUs4ZUk+ajByRjNtVGdvd1ljdH1eI1p4 Mm1VSVdeNl5rM0ljQ2F5VGlPTWpvRV5hRVo+eFUmRzIkKAp6bGU8bHlhT3J3Xzc2cUZ6S0skNThk UT9OYzUte0lwJiszfUh5eWtNVFRVTWZEeCNAbn41VD08eVIxR01yOWhaVzgKel9iSX1VTzdNN3Zj aClFcXEkQXRwMjBzKUVwSSlSanUxRWxPezhjMW0jSHN8QURzQm1YKGRXXjRATGRIQWk1SE0zCnpD WXtiUSZ2YzJxekdRQVY2SFFIR3tUa25JKTU/UFh3MFFqUmpDPVI0Pj9GbVdSJSgtRVBHVl9NK2he OWBTSUU8MQp6NHAjJkJrIyhHfD4pTHs/bjcxa3ZzRmh6RzNhTFRmK3NuZk15STxLTW41Km9raihJ YTlmWjsyI0YmMkkkOFRYY1MKej0pZnwwVEkkYCRWOH5KYVBwY0JYbFpRPHtrVWp+Y0YlWF9fLXB9 SHImIUdxQTVEQzxJUXRZVFJefmFnfnVyfl58CnpzNGAye3pKfml9QD09WjxsWGVHKnJLNzJiQWB7 KTYzXkxDTmxaa0AtNH5pZ0d7c0kyMFhYazM/RlNWZXtvZG5mRQp6c1NoNmZ4WHdGNlhpPH58VzM2 OEwoTDs7NyN7UkwrKE5AT1QofE9uODZMJCE3JUhae0EtWlkwaSYwRCo9Uk87UVQKeihNb3pSLTxV cVQoXlhFZnA3RWFfTUhEVWpTZHpsRGBkeVVsei0qR2QhPVZUVjhhKzFKVyZjJWVSXzFxMTNUeU5O CnpCO218PnZHRGohd0w5P0p8OE1HazY5fEc0JEF2dGA/OzYpfGhWd3B0blApJnl0PVRwLW5qY21O Yk90ZXpQO1krZwp6R3t7KV9OZiVvdjhGVTFkI2MjTnRXKXhIX0R2QlRkdWg4UUViYSMxX2BEdz9n RF5ibz4lcyhKdENEbT5jQyoxbHcKelYlZ004V340Q0kzY3J9Rk1XWUtjZXZFfitqWFUjWSgzYjdK WHN7fl92Yk5YenpGWWtQekpmRm4wRG9Bazc9Yn5ZCno9QjFJX1VuSkN6U05kQEh0I2NeKWJDeTFP WHtJNilNYEdmfihxJDYjJV9VejwpR3N7bHMhS25ha0NPQ2xiMXBNRgp6dCh+V2B6UW9wXiVpRl9E ODJSUXhIfElGfnohcTN2T19IS19pcElHJEtXJGlWaD8wWntieiUrSGxYN3pqYXFZazkKenJqZ1cj YFpQfXp1cmxjMD9xVzs8YFZyTGFLVXo8JWUlNz1ybVJkXlByMD5SaDhuQDlyNHAxdHFIUytvNDYp Tz02CnpUZmJNITF3d3BlPklYNyR1WWomNiZ1bXxzTUt0dHE8VH4tcD1lP1QjVGBUKE5OOTJAQldY KHY1cVI9Q0BlZy00Zwp6O05oUH5xWlQpY1hNKk9RQD9fQSlpKkpLJVVJVjd6ekROfD0oNTszKHRp UURmYlYpSXQ8K0E+M1htOF59elJ3Y3kKelFXVnVDcDJWXldoRyhtMClAQlBKM3tfZ2wqT3QxKUxA KkNLXmhScXFOazMoc2M3M2EhJChTVlM8WCYxTlNhJiN8CnpOYE5TeXEkUFNnUVBtJVc9eGtOOSQ/ K3NZQktUTEJVQ0Z5LWdTKlImYEJUNDI3JHdDb2dzX1dPa0VuaFZeOH5iVgp6VzReNzZkVz8jT1Vv NChgWlZnbVRTS047d2k8d2BrMkpeS1gjKmReRVRHekF9NjdDVDFpITQ/dlU0KSR2Yjk8UXkKemQ4 aS1MOHJLdEVFaHlyMlhsLUl7QTQ+QmVOMldgKkdpLTteSDk2dXBRVXprKmkwciR5c31BVzIyXzBC NnckaVltCnomVFdVQTBFbVFKcDxzQk53KjFafnlHZSolcih1flVaTSZ7VmQkKUo+VnkkWjRqUUpr UW88dDlPcCpOdCRkRC1FSQp6TlZFRUE4dG80d0N8UEl2WEkmY1kpdHN7bE1RIXo+a001ZVZicSU+ ZE5BKUJ3SilEQT5oUC1iQlE9TmNgaU1lKnwKek4kdnAtQkw4LXhyR20oMVpjcH1TeDwpKUI3ZCZR dllYNXtXN1dvOHkxaVlFaHpRRUdnJGE3RVJtbD07PFFrREtlCnoqNj8qUjxCRD0yXjdtKnF0WSY1 NWdqNz9MSzBhbnBuWXlUP2Myek1AZnNWPkpvdjYlWDlDNlghYENZQGckOWxOegp6ZWt8RjtyYWt7 M05NZj9PLVVrYE1sRj49VClZM3xrZUVVQFRqWDllUzc/ZmFUe0VaaCYhTXQwJEg4NVI9bStNeTgK enMwMndNRWVHaXclKyEyNT59SVA0M35mSGhePSl8YmFPYmlCNUx1T3VtV18tX05pb3BycCN9fEFD cGl0aDFwSUljCnpoQ2phZTBwdH5Xa0xCN0lPVy1fP2ZSTGokPF5iTDFWLU1oNGp1MyVkcWttMzBq PVlpSSUtPFkwQFVDQk9pOHFEbQp6anEhSWFpemp1VlF5bnhmYEZDPVRqJGd4KUolRFgqR0YkLTYx P0xHOWVTcjJmeUFNNFRJfGFQKFchUGwlLWooTH0Kemg3eGRJSS0zdGF4JmVBKnRPREcyP0VLKzds KTY3KkErenI1TmdrTDI2KThlZj1GRzZQJDRFZHV1V1FnRUJEflFHCnpiaWlxX2pFcnt6RUdDcksq R3tRNGRPSENRXlA1T01HNnxyKWp2RHl+ZkxpVH13KSE4LVJDQnI0JGJRd08pOXpSPwp6aEhrZiM2 fCE2ME5zcCRASkU2JXxxbHVkVTEpWUsteUk8WTtfRHpscD4zYXpQKnI3OTNqMmBRJUN6eHNhcm58 TngKenRsbWlrSkBCTylQKExHJU9YYVdXMUB0cTBmZlpgOUZlTUJAYTgzYCNYO2h3T2JLWWx1aS1f MzkqdVQ3PnRTYzg5Cnp1Mkl7eXpDO3BRbCFEKEEmXylfYDl2ZGxwVj4tNlpYejFQO0ozRUk1JHFx T0A8ZXNvNkQhdyZPYEJHTTIwNUZlZwp6Ym1aVCNQZW1PdCt2ZkIkNXlDeno+Z0V1UFo1RjtkP2tV JnFBPUtrX2R0YENMQEJJcEMtUSZGI200b05DIVdhTmIKenklTUs8ZmM4dnchSDJwfFMrS2JSeGor cW8+RzNgWTApUihkOVhkYz4oelJOczNhdTB2dSRDTyFLTX5oSk5sZ3NACnpze2MrdXdHUitxfDd0 ZDIzLTtQVDZTakFVNzNSWjg9UmVIQCtrKyM9b3hrKzhDNzNPOHt4ZzFrUk9VNGhzbzRMcgp6K3Ay IU8tYkspbW1eXk5VYCRANngzZUhHZT5AMlM/WjwoZmR7ez4obEc5SCVUdTlAO0owTXgyQ3lhNUR7 UX04SisKeihPd0UoSm4yXihAeyhLV2p3NTlQYVRzNztVclBkQnotWndic0F+K1l1UDF4WSFEWUZp SzsyfVJaPyhzLUdafjxGCnoocXc9e0p9d0RPbnZmQm9UVWtOPkJGZkwpK2dXfFNmaXx7ajFuTH0/ bztmeCYpUiFPODcmcFl+bDBhellyPiZ7Zgp6JHx+cnExbDtmQ0hnX1ptRlhuNXNpNEY+PSE4fXcq eEsqfiNkSUo8OG1SNFBzMzh9VWlnXlZxUTwrcFhreUpxfiUKejJERGd4LT9EbVl5Xmt9IT8zNmcr Qyh5allKQVpLcl5hQCVWKkRAeUhKKjk5dnp2bWBgSi1EYilLKit6N2ZyS0x4CnpNWjA5R1JJIXwr ZkBlaCt6ZjA4TlolNnF+V0FHaDR2Kjl9fihIVXtxaSYpTVA/Sj1wMW9UciFlYmMzYlkmJjAkcAp6 Zk1YKDspZH1DPFlkc0xVMGxGZ2BxfUQ4JWhEJUxIZnRIUjkmUlFxfGFGbG83RzxEZ3VgMSFldjxU RyF3QGpKcTMKeit0cXNmZC1xcD5kUGJvYXU2ejR8UFhtMD1BNH12aXU+VG15SyZxYztaNTJLZyhr dWs9Y0cxQDhCZ31gY2JJJjV2CnpZKm53PHgxXktNb2NBbTN0Q1l5QjkmSX42Z1FhS0xgSnVPLTJv aiZyMHYpTGlGKCZpem9yYzMhT21lMUE2ek12bwp6IUxobHQhWDJVZXpLfHpSamV+Uy1zQHZoPlZw R2FlKnQoays7bWJPQDhuaWEtZH5rTSNgU0poREp9KkdDJmx+NXAKeiElJD1lQTNNTW8raCYpSG52 anpPKENNJDZfMGtgSnNwc09Bc30xcnh3emdqS0lCY2tLY0tyKElBU0RhSClsUUZyCnpITDBKcEQ5 RkN9dnpUR1FXU34kbTdIRXdtdHJASHgqRVdQaFkxR2FHSkRLYFc9IzJKdXhAZnxkXyZJNnZkYURt OAp6T19FZmUjXj5PUUpyTTkySURGWncpQyExZFFZdnBxLUBFJEdWZ1N9SXo9QGp8Jnx4eUxSOHt0 VmBKMiFmVHhaMzIKek1hIXIpZUpkbHB4aU5eMFAxSCRoKDdBKVZZVEAlJiFUejFHcU1Rem51MXR3 emNEQUlEeSp8RiQrfil+NGhveSZiCnpufD1UeXpsKnlVfERqLVdmQzBUYD8hUHxaI2ctUX0oNmYp aTMwVjZpMn1wZWB6U3A3IyYmLVBmOVp7U1BBT2xLKgp6czV4Z2c9YjVrZVJNZjJycjVsODx8SytE c3s+KzgjVTFHbE81d2BeUF8peH1XMVcwcHEoQjxHPXRiYlUmQH1SSmQKemYrQ3tRIUomPyRgNE4/ Vz96eWVeI2RQYGFwKW17OUY3OWlmKGEzNThwaHZSMlNlRGFEI01mfCFHNER7aURUQTV0CnokZSZz IWAlSk9ja194O1NhSl5JKj47VHdkeHg7NFpoVS0mNXhmWkgpejM9RShkI3Qoe0lTVnZXSzg+JXEo SGdASwp6eGJLeTRENSopPTB9TzJhM31BUkx2M1k3K3Z6Y015dCZVektaKWE3WT9CM2EpM29lfDFW d1lKWVptWXNlYjEqeyYKeldAQT9neEk2R2AzYytiRig5S0pueHIlfGcqKFJqOUJEJXNUS3dmbnJ4 T3AtT0QofVpHMUFHbHllVjM7dVNNcT5QCnp6anxFdWJuRWZ0Tmh9QUBhPzM1U20rayRJVW1YcD0w Y3FARjNLcGlCMS04bGolQWFXLWVocmVDLVhrRyUjfDV0Sgp6TmU4Q29SZmwlPUpseFpXNmJfc3ds Z0hqenlSQWd6e1M8UD88XlpQdlk9MVVzSTE0QmdNNV9wZkZ7NlM9LTs+eTkKeipJMVl3NUsoMFhW bmpBZWtPYDt9X1lOV3M3V3JWZ2dANytiIyhDVGhwT050ZTxwKk8oUmpBfigrbnFTaFREMzZaCnpP YnwkfGtMck5Dc09mZVIqTT1MZGZoY2NVMDZAPGMlcip8RGZwTG82JlRlSyE9RTlHMTlDR0hnPXsk VU48VV5ONQp6SDVPYU1UMDU1ajItc05SMHxKO2VQWjlsU0xtSz9uJEgqWU9Xc0F5YFFvZG1ORHEt PFJxTEglUks/KGpTO3U+Tm8KemdtJmwpIWJzeG8hZFU7cmc+RXU9JWlaP3t5Z31PfUN6P153eHRn SnJ7K1p8WDMoWldiIXpiV3p5cip0MzJZWmpACnolSmZSVU9XeDVoNyFNPDkpWSF3c19Kc0FRcjFO PUtiOXlSbDwmckFtS2ZeQ1gmbUM3Vyg8cklVcl9pd3NKNWR5dQp6KShxZkx2PT0lWDd9bE1qYUM5 ejM3S2h+JlJURnRfSlYkbENHbyp0cD5tKiVUJEgmfCo2fShmbWFRWE4+JUBGPFMKelBJY25OIVY4 cX1YJD81JEchQEUxX0krSEs9eU85MEItMmFeLUlgIUZ7T21fO2xQUGZAX0J9bVU3aW59NEpuZ0Fw CnokcUpsMGVJQmZnYW9TOFJnYnlIV0kkMVZ7RThRTn5TYWh9XlI+ZXNpIyk4bj85OWxacjlqWnFe O2hzSjBuSHZGSQp6cHFWeGMkSyE5cThlZ19vJXJYTj9je2hhOEJxZmJuQFJ6Jk8+enVkNGVVQVhW ZEFrflAyMG1vPEVYZEpocEYzUlgKenNkeXlQN31kenI/YFchfXRDZVo5Yz05fG5fbl9GLWBISjtT MmNROXpIKXJ7Uj8tSTVrN2FpNUYwbGBUVnh9OCtjCnphRFVVNmMyWmhDd2UmJns3KVAyP3ZpaEM9 eGx3RTE3encxfkYkYVJsdWhwXkEmMXczMmBBYC00WkoyfXkwZmZaaQp6OT5EM3sxS2JINFBHRzRl Pjl5d1N0NUl7dVF5TCRDNkc1K3tlQUsrWTM5LWNXOTg9JEFSK2w/IzA2WCEhSW01WH0KemU9aCgj RGo/RDBYRVh7WjQyMmB8bTlDI0NEKT55cy01JDxWKUdWempibENIeUJUOTFXQWBHPGhmKmc/QEds PWROCnpgSjM5ciFqfnJBd149PkpacD8obHJFWTFhLWVkKC1pfk17fkM8VGZMKSNLc0xjPnY7REh+ YzlnJUI7JH1NMjkpYwp6KFchTEg5I2tPTWAyZ2MtQVpOQU8/MjsjRllPUlBmeitsX1NyVyh+emwt dUhiN18zeWN7SmNsVEZOd3t1eD13S2AKeitfJStvMzg9I0plS3ltOF85LUx5YHl4NVRseXUxWlIo VFBpTnNGYUNDNiszWSohbXYoZCgjSXZeUH0hSVVtSyVgCnpAJHcxZT1xfT9rakxnMFJjQiVzRE54 SlQ8KFRkTD1UcUtFbFkyKn5LU3tMRVU3M2hvVHctdEZiciVqKUxtamAmUwp6JEZ1UlNSc2ozOW8h N0l8Y0M3QClZTCk+WHQjait3dW1fPnRRVXlhRDM1ayRzNnV4Z2JYWGdePzhLdGohPCY1cXUKenpE QSRmJXg2fXRqRntpNjRQY1E1P1EwLT08O3pyJkI1ZGUrSFN8M3B0MV83ZyZmQDFfQ0g7ZGYxWkt2 PTgxKSFnCnomRHZ3VEMtamk3N1lrRT9Od2Bte3RKJCU8c1pBVzUkR31KWXsmUHo7RjB5byYzcD1V YVQ0I0wtRmp1VW9gNVlFegp6aURAUlpeMVdPS0BFPElQUkplbl5rWjxWbGBDX0heQDJkbW9eP0pw YEpHXnE2Jih+UVpKa1M8Vl4wQStHXyEwd0cKelB2b0pqIWN9VXNUPjBtS3c/O0JEVHd5dGpHTHA7 ZzdOSmBnVjtLcERiflRFb2NWTTRZUW0wJER0THd5ZTAlTlUqCnpYRWNxY2U/ZiR6djUzUmh3Km1q UTdQU31QTzQqWCp7S0hzYyRpNVpOKE44Zy1UTkFNMktxK3AobVBNUm9HKG1PMwp6RmgyO2g8Qy0r O2ZHM2E0R3N9YEtNaEY+SyQwKCQ2QmtCTWU9bDMoflhPdmgtTzU9QmJJNnRLbCU1ISlBdklyeSsK emxETEVJITF0VnJAbW9HVkQpaGl1TnNRSVgzbTRnPjliZCMjKkN8YkZJemFUM3I9NyFYPDVnTXJx VUtocUx5Pnx0CnotPyV+YSo2NlFVPFkjJUlVQ0F9Jigxd3Z4b0Vyc2E0MDtaPzF1cDxidVUzWDBN JUtObTBURkdMalopYzcqcDc1Mwp6YkFsJkNDVjlIMGhNXnt9Y1J6OT1lT1RWTWRwQHdiQko1QVJg cEdMck4xfTs+dUFJcTE4PEtXTCMxRmZldT5rSSUKelZQRVI0TmM/a3hac19NWkM9VV50RFhHQS1o VGptV2Zra1JJZCRMeUxAKlQrSyZCLTNPVCpQKUEoT0tOWlQ7V2lKCno/JU5SKzNYMzchPVltTT8q TGhVbWVWY0NJbys5I2pBQDRxbk44TUhrOWlzS1FeXkJPfDZHcl87R2JLaDtEbnJxcwp6QT1UJUhv d3ZEfnpaMH1ablR3Vl5oJEwyMmAxUnVKJUd9ek5oeW5NOW5UeT8+b2dGVTg7S1ZFUGlwbVEkU0Zo UXQKemdkZyMhKGA/YmxBO15LU3Q2MWNzOFFUQDUkPFdRbERLOWxePG90UWtkPmooZklxbD1TcHxK Sz9xJUMjOGQzfm5JCnpQLV9vZ0JZMnNBKDtISE5uJFlAYkpEYGt1bWZFXig/Mzc4KjxTJll0MmQp ai1NJGo4c3V3MyM2RSFsSDF4dzQ9ZAp6V3l2Y2ZwTVkjZzZuWCE9WWklc0BUZUh6UVJlNnFXNzc/ QDdGQDV5UWtSbyNDWktOK256fXhCaSVITmEmd24qflUKejExUEVoNnpOOFhLM216WVZncm8pZW5J XzU3RzNKREJ+fmBwLWY1T2pkTiUwQEwycGpJeX5wN0lGMyNwdmBDMGNjCnpYS2NEWWpRK1l7K2lk TFNKNWh6I2MrNSpsRFl3SnojX1IzWUskOXp9VDI2aUMtcT5yQWxmfTtnWiteYj5FMX1vKgp6NHt0 KkdUdC01ejFgbnUlSjJsVShQWCV2IUcjZG0kJXcxNSgmNmhYRXtHMFBYaVBHcld2KUZYSkdCVzI/ PVVNaTEKejhyY3hnNHQ5d0VlZ35iKUtCVFgpa1l3KChTN19sMEhUOCRrQCFgVnR3O2MjKmhCc2A8 YnJ9TS14NT1HOUQhejZUCnp6azE0I0ozMCMwbkFUcFdHMlgyck9ydl9YS2EjQiljXjJtaDszey0t KFJpaEVXRmpHLU1fdDgxXyFvQylgQmNWYAp6QUFecGkhNW9mTmt9KkxGXk5STEUqYiE3PylMd3pC QUU0SjJBSDVKWGcleTFAOG9ScXQ/MkZlVygqPWJ+P3YpPTYKej5+QlYpNiEhQi1yP2tSbDU5ck8y ODg9ajdgZG9qJXp0T2Z4Ji1yUmJoKVFWUUM4U0N5bCVoJlJhSkZofUtFJjxKCnpyNzxecUNUOUVG WnA/aTUoZil+R1FOcjx5KGZ2fn5CUlZSeytAJE08SHNjRj07P3tAcFZVcEtwZTdGWGVBZGprJAp6 VDdRZSRNbGo7amhwVS0pV2VwN2g/SktVe3I+P3hATkokQFhycW9VQ3hsOEVoVzFZcytTKT09VEgl fiU3OX1gNy0KelVyNmY1VUl4czZ2XzRGfT5GLSFrXiVqVmA5Qj1nZWE2aXhYWVdibS1BcGVTdT1T UW1iXlQxe05qTHorUz99LTVZCnpQYTl2cSpfO2F0ZCkyYWc7MWBAcz5ePEY/RDw2RyUqRW80UUtO S0RkRSFiY1FUNWx7M15DJXg/Wn0+OHxTSENLWAp6UH1CJHN4dnlGV0xzU0p7UnUkTEpVZUpMe1hP RVIpX1B1KXA8XnB4aVlFMjgqeXt0NlpFPlhrQHReS1NHPC11T04Kemw/ZzZ+aiowcnYrVnZtTW5O Yl90XjI+N1E4aUdJKnh6V315NjROLT1AOCtwSXA3WEpNSmEmRDUmR0QoOHY4VlgoCnprJkRCSGhr LVpyJEU/O21qaEs2cW09fFBjQThmYEYpXkY7MExCQ3huZm40V25ZOFVwSEYxT1UlS0RNcXpQdUJL MQp6VTFDOWI8WjFiNnxHU3pGPG5DLWtYcUo2XzxJUWtDWkRyd1YwQHlxTXE8bF54a3RgPSokTE4w QWh0YTktRDxNPkUKeiZHaFIwVVZvRnV7Xkp7fjNLVEB8THNJdyR0Sys5U3pvK3h6VEg3QVV1RFBk QSMtX0dKTCZkKUJoVVp0ZlIkTj5aCnpNPCExTFhWNnBweXdjSTVjPT81N3dWejxGPm0rZEVoazM2 fSZrTG8tJWF2QCpVQ2ItZUBvflpTPldrfHVAQSt9KQp6Yn0+PTt3QyhLcDdefnAhV3NsWHhsJmkr biQ1NjBVWEJnZT9ONnl9Z3ZANTxuT3N+QVNSU0FtMDxTVz9DMVUtPTUKeiYqX2tRbjxgQDZCWCl6 YFl4OTVhX2lhd3FlVWRZRGFMSSNjK3d7NG8hTzE2QUh7LSZGTGQlblRLYTFoIUEhLSFLCnohQVlQ XyY4djc5b3EwM0VOKGFmZyl5by1aLVNyUEklRzxXQ3g2WU1zQEBEejV6RWBgWGZiU3FPPWs7eSZN Y2t7Qgp6SFVoeyVgQFVUcnc7VGgpRHFLPnF6WlhoRSorMWNAOFNYQm4+LWdRbXhHaFFIQlJuRDRD amo7cFk8dVgxYDBlS1QKemYlQFhRKDxnSSglbVZvTm9AOUFeU31edkgmT2xrTyR+SVQkdndMakdL MFYzYGRlKU1hcUJfeUBiaGpnK3lgNUgpCnpYVH14YTIpZlFzJG1SWnZFRztrbldYYnRmclRKentW TDIwe0VoPUorbTAzalRGJFdIQG4qeEs8UXlMIztlPl59Iwp6LVlBKjRheVNjbSs1ejZ0X2NCPCUk Z0toI0l8MmQqTk1fSGtDSk1mMHAwVlhgM0xZcjtUdmRxMkJ+TVN3V2U/UDwKent7OzY4ST9CeUU3 aHtLZ2ktWHBMUjBFTjY0bUNtUDVgbnxULWxNel92Ryh6ZWQ1YDs/Nitoa2JhVj9WQ0AzeXwjCnpx cXtgOFRud0ZUVH08VjdtZEEoPGYpQzd9V2AqJlRYfGc4IXhVTVM/XzN6R31KMDlpQylCNmE9cSRT QHI1dktMbgp6eGhwcEErYk9OZysjMENtMXd7clRSbkdgbzV1eUZVVkM8Q0dkJkNTPHBNYiN3cm1z b19PYUY0djtiUVB5Vk89Z14KemQ7TEh3dSZmQnEtZ20qalgocWEjUyFsQkA5K2ExRmpsPit7e1Nx UFprKll2SXNrT3F4IXRaS1BkdXtvaThgKW5FCnpgT25qWTA7SyVIZl4pWmI3bHc0aiU0ezNCK2s+ OUVofj4qOEgmVzhUbTshT1Y8O1Y5Sj5QYj9KXlRBUXtXPldLJQp6dmsmYXVLZzVTRVJ6aVJtYFRM RCNwNTcqcnVvMTVyUUtFbEtDRWFCKz9+ZTZ0QGtRN1ZCUExfMy1ya0R4NFY9d2MKenV6aykhPzBD UURLdWtkQXYwVTw2cD08QkZMaHlPPWU/QUhRQnA9cl9zVH4oYGFXSUwqUXB1eW4zJXclTiRZVXNl CnpteisrUjs3NnFJenk7M2xpfFN2akZxaXRSPH19eGB2ZTYwMzQ+XiZoNT11fHNHNXRMPjN7bmVn I0RUXlY/PCNXQAp6WTdLcjlyZktZK0I9eVRFJWxGZXFMWVoxdGswK3NeN3ErSmdBWiZxfFBgeSRR MWVBV2BfZS1LSyktU2FHYGtvIUYKemgyTl9aVGNoZG5AQCg/XlN7OHooal5aSSF4LWAmQSpGNUFL a0FVcGB4TjtIMipfcClreVo7KFh0UDBBJlckYGhUCnp5QSYkemVPZntxYzM5bEVWfHRtaml7RjZ7 VT5RfTdgYFA2cEkxQ0IqWlQ9WklWZ0BfJCttUkJ0JDNfPEU+UUI/YQp6SF5xWnQhdSF2RCY1ejJy KkVtcmh5LTRKZ3htOFZYNnZwemU/fjlPPCsmKnZicTdoZm83MlQtPVVrdFcoJUd1YFUKej1qLUJ2 P0hOIUdqbVY9PHl7Q2V0ZUo1VGVTajFva15uJl5DSlFYTX5kflFvZ0EzWUo4fDUlIWdgSm5IRDxv VWkwCnpLQ0B2eVBocl89XnIqfEN3QiZxT2B4d3RqRFlPbz9seHV4K2VQd05BbHYzfEooZDhfamo3 fDNVZDt7LUloU3lmMAp6PF9nbFlGfU51T1M2bF9hcmg9STljQjR4cFB1OSp5RH5QZkVrWEkkQ25r Sl5zMjBBK18laDhRamEyTTE+Rns5ci0KejF8YkE/cnctZGNBNT11XkdtKjZBTHU2RzM3PnA8RTU7 WT5GcihHU3EjYil+MTlkLWBoQl93WlJ7SlBRNihZQnlHCnpISzNCfnRUfTVALTk9KDZTMkR8b1pl VUNqUkdJJHNkR31efFp4YGNAQCFzclFwTnp+V2VWRiVqRT4yMkYyc1pBIQp6O0gjX09QUEBfQlgy VFhLcys7T2RZOCtUSXhZRFRJQEF+NGgpfm1PPkZfP0N7Pi1TfGRWaC1vO3ZBUmIhb0p7dk8Kejdo cCRAO2RhLUJqcFBMVmQ5PWpURDdiTn47WEd9T3IlZkJAOyZtTip7PGh2cS1aaW1rcHNQS3p4YDw9 RzhHdjQyCnpDdlJiX0sqWEZqelRZYUx3UylpalNtTFU8SjR+UDJGamdCNm56flFPRClyMzBrIUg0 S2t+akp2Y29XNV5gZlBlRAp6JGhLfEVpMjUyUXAkSW0lVTd3RTxCWVF5ZTBHQio0PGBNJWs7YXFq T3sodGpPaDJlOUxGKnJEUV9lVSpaV3Z6cj0Kek5qfW44QV9mTSMyLU4hRSlpdHxaVSVCa24kYDlA ZzFLVk5+Zn5mbyNeIUF6R2lgPWBxSkhZK3d6bmNqVkc0SUkoCnohOzk4WCNiNTttaDNFWnBlJk9i dzcrWnRHQihQWUAtQj4xMURgYmt0byRtPzlXWG9SdmAoLXk7dGQ3fVlyb2EjKgp6Nk1UbCZ4Yy1t SUZhNSUqK0UhJXpZJXl5e3xGYENCVHp1fSk4WlFMQzdOe3I8ejctKWBfUC1HKGVuPl92KW5pVzEK emBwO1VCViEqcXtwZT5XfHVSVEVrMUxJZVNoUzklUGFtbEFZa05JbWtgVFFCMXpaYzQlYkBPKSZ7 ZlZpNiZWeFQyCnojZWNXcUtPNG5BWFdnSFQ7P0c5JD1TSzEwcX4lWEF7MFc5WCFTRSote15WMUNA fko8MF8rTkwjS1JMc25vWiR+Qgp6XjxTTCNQY1p4bWhDampaQ204LWZAXyokQmYxdVNyKENWTjEp UEpHV0tmJi1QODIpY0NfPyh5WTtRcF5qJXVyLUAKemhjKXRMRnViRnFnQipydmE2NE13TUhHOFRv JFNjQiZAJXJHekE/UCE8Zkclc3Vua0xqQEkmMEQofkd+b29jX0J7CnppfShNRSRvRilebncrd3pG Z3NCd2x4YVBxYWViOXtvJEBWZWI9YG1lbChBMi1uSzM/dnl9MTUrR3FkVTUtcm8yOQp6b29CSUhh PD9ZPWk/Sz1uTV9uTWtQNGFNVVpTQmNOdkRFc0NpWUw3fmRVfHYlQD10Qj5uZH1YRSEtOCotM2I2 akcKeitVJndiVHgrMVZjIVBpSTc4JVk8blArT1VTK1I1Rm1pVVo9TkJrJHlIZk0tXkB+c2tNZVdD fmRlMnRYaFRTSSYqCno2NnZMcmlEQ1l9dXVsU2VzcExtWW9fVHFCXyQ8Z3o1UVEzbUNHPW0rPX5M Nj1KOFNGZik4fEwpMGlDaTxUM1Q5RQp6OXhfV1Y1RTYrRmBpT2hYQm9nfUdTSTI7K3hOYGM9MmpX QlUtflI+dHlCSX5fRXItUkhGVFYlRSE/MSV+dSk/YWkKemN6RypKJkg1fDZFPjZuUjxpbF9vIzU3 SyV7YERidWVLcj1XMEFITWBxa2MoQXE+WE4hVFFTe0p3PDF9LXB0PGtHCno8SUVsc09BWXJQME5T UGdxVENxMEJHMTVvbU4mcFI7XzxtaCNpbz5LaiVGSGNXK3YwUzZuPyFgUWRVLWAmRV9IVAp6UEFG ZUJRPmglQS1wI058IWdWaV57PHxXaCg3Km45QjN1Z09MPVF2enkzdDheUiozYGh3T3Y1SkxHfTU/ UFEzRiUKemxNbXhod0FzX3tefkZCZUx3K2d0ZG8xJFBQVCsqXnpuKHlLPU4pQlVSVTQwe1N6bj8+ MDNuXl9VQGVJX2xsfWkhCnoqcC1KUm5lQmc8OUJwKGBiNUM9bHZabVo7KykreyFZbit6cC1uM0ZR djJAQk1INUZNeiQ4cmdrdFVJWVc+VUM9Qgp6SGx9Njxre2d5SFBWUERpZiM1PjlxXkt4Y0FhR3g2 P3VAX1hjYGtxT0BXK0Fve2hzZ2xvYiFFb0tGYnFtPSFyQDUKejY1UWdPZyZnTFZURzFpaGclcVRJ VTQkXjhxOSpfZ0JRQnQqWGlfQXx5WkM1amtpZ0gzKHY5MFBEfEg3UEtEJExLCnpWbEA8KnhqU3Zj RkhFT1hzYT1qQiZJOSRSZV9ZKn5zM05yX2QrN0NCR08wK3I3ZG4qfV9QbCRfQHZ+eW0+SG52Pwp6 NHZvYGp4cj5mYlRecSh+aT44eX1mQzttUXF5KSlNWFNHfTN4WEF4UHpDYT8zUjdUck8yZmR9U1Fi MDE4SFJKSUUKemx6KzFUeXFDay1ifVAqQ0JVSjhGVHBqJig0eTwqQGJBVU5SbH1VVUM7R2ZHe3Zk VDlaI1QhNVpZLXc5IVVrYkVECnp5MzlDJUh3QSRHMkJDZGA+QkpsWnUlUU92eytyY2BEWH0rNS1V ezUocCQ5fkcpeHB0JDEhekgrLWlnQEhpYkBxUAp6MX5HTE5Ve3E9e2lPcCtKPkRmUGhANlUybyVH I3xOQilXX1NvRGdFYFRpMEcrPjx0aSRIfEJoPlhaUG87X3dvNV8KemAwTzxwRzRGcVhxVSFYO1li OWlfcEFmNDlvLTQ3NSl+fFN3YnBuQVAxaGB8YF9iKlUzajEzTUI2cXZWTXA8b2g7CnoqVDl5KyRh e1cmdHEofFhycVh4WVk3VDl3e05UP3VFUTlacns8bEdXO3FKWD1UTjE0aThhNCYrOWRfOzVrMXd2 Ygp6Z1NGRG4xUEFCcFh+KU9MS0h1YnMrUz1MZUQ5S2pXQ0lVLWBOYjxmbUtYbWU+KHU/TEEpUnNE PWAlVkVrO0RERW0KelNDbTZyZXdscWlyQVJxRlJ8YVhfYXlgXnBofC0mMHBSa3B9S1BSdWxHWUYj ZWY1Jndrbz0xSW53QWlObT1NSkBCCnp6Y2dye3BUTVJQQGlQWG54YGBRdiFDPik/amc2aH07MTwj bEs8JEBtaGYrZ0E+Xk1WemUjSF9KVldSPlU9VFdAQAp6dDBMfigtfG0jeThnPyNjMDZLak0mZCR5 eXtZTCs1XndjPk8tN2c8elE/Z1htOEd0SFQod28qek5qZihYXzFlayYKeld8YmJvSFAoczBsRilI Y0NHcGl1UXFUenRmRUxNUXJBPm5TSmQkVUZxJi1tWVhDe0ZVe3FtSFlZRysteHF7d3E7Cno+OVZx a2tAJjVSa05kPCVteVAlRT02PFclIS11UWdJQFNDMm1YUzFEMk50bEhFZGZjcmA2MGNYKWdhezI4 OThxIQp6TWVXdyZLSHtHPDJZazVTYWN3MUZUY05ySWBsXk4qQztsN3w+dGQtKlc8Z1RqN0NhRmh6 PSVzRW0rQXd5O1MkZFEKenlTaV97QCgxSGk7UCNIYSpuJTtOcHNJe2tnQTh3YFVjYz0raUI0YDUh UTxsTU4/bD00VkVXdjJyO0V6S3hCanx2CnptUUozZnF3cTRZY3xSeHAxViN9bmU2U2dBJGBfWEk4 clhtZVIme0FgaCVOLTN2ODZ+ekBtVSYlbFg3N2J2IT1lQwp6Vkhaam9pbG8oTz8zTjAtU0FnOVVL K3wweW5JfTs1TEk4fG8hI1p8VjlYa1haMEojXlEmMTUrcUB5Jm0qXllKQioKekh2ZWImWTgrcjFA UXklSE9hLVYjUl9IQzNoZ2VYIWZEPkFaP1dmR0ozc3BFU0I1eytXK2BCdDlqZVhvPUBfZTdnCnpC ZUFJbSVYfChgMTYoen1eR3RkRkpIMihycXRaRW5nUmklIzFFRHQ8XilpTSpGWld0RWBvV0pQdk8/ QnJBcjBJSQp6ZjB9MXhlIX1lV0VNUTxCM24wS2M7Y35ndWgqXzE5K3kpaipncmVrUUgmV3Y8NFQ5 UjdaI2R1ZyEhcXMoRCV2JmgKekFqczR7ZUsrenJaOHpxa0o1OThXT1V1MTxoUGZMJEt2NEh+VmBo QXE2RSVyZzhDUyleSj55M2p0aVNxTC1DMXBpCno5NnJrLTZ+KFI2P2VKZzdWeU4tbzRrdXFfI3gp VzJZPnNPJi18fFl1UWE2fmphaEU+Y0xiWWQxbz5BJFVSPnVORgp6OHFYKG51UWcxQlY5X1cwQENS bjBnVmUmSGI+NjtCVEpaRlo8SyFNaD1iK2JtNURGa3c9aHBvTGFob2lgOFppYC0Kekl8THlnbSYr Vl5OZkZ9Nmgra1BLWUlVa09WbHAkJmglbkA7a0pLbkRUZ2twYzUmQnx6Y2p6NT9gczN4QSR1aEZ3 CnpENzdIQnpOdXs5WW9WbUh0JTBvPGg3Q093b3UxK0NCUClyLUU5OENEbjxAODI0fX0mJiU4dnF9 PnROZlBifiZNaAp6NXN1fUNxVGE4dFdBR2QwMC0+ZzI9SXMjMV54JWIwTkx6WlpOPClAVXs5OV5E Pl55WlpAaStMKk1JaXBMZCY+WnwKemAycyNgNyh8Pz1VWmtkVDFibV4pWjNTQDlIWCRtZ0xJajRl RF5ZPDZaKyRyYlBnMyNzLVhuaXxAQnJiPSFRby1XCnpNbGVKKlNqSGRTI0FvYGdQKHwoN2NHK1A0 dyshZHtzI3hjaHZvUkwoUmE8V09CKHt8c2UoeT9oZiZkK2FNM2ghNwp6RCh+P1BvUDFLY1h4eTAw PDZoSkAyNEA4IT5HU0VvbEcqSCo1bVBYWnBNSGxwbEF5Jj03UUxHVldya0UlNEd2WisKeldNeDU7 PUlWT3dPQT85QXhiX059M3Q/aG84ZjRRWUBeO01ubjdOeD1UcXg5Z1dkOXRzezV+QWZJO00mTzly V3p8CnoqbGxIe0olaHkzc1IwP0dLZjhoJGlNeUZ8b1ZgMTheU0pBc3ghTyg2KEYwbmoma0t9NmNU RSQqN2NzQ19MfUd+Vwp6OTNDZzdIWWVeci1JfioqP2R0U0pPVD58Q3Y4c2k9MllZRSNDYzBWI3hf IW5oYU9iRTZfUjI1ZDxaMHBmQGQzZ08KelJVRWdZZmtPMjVxfWxtYiZldW9aJiZ8VyZGbiZNaEs3 WWZ1YSQ7VClYcENHIUM3ZVgzbjtadFVGTkVVUSkjZ3MpCno+UWlNSTltayRXR21eO1VtQTxjSV5G QnVWP1cjMlNgQGNJcDBaRGRNKjl1ZDUwTzYyMElhdGE+aFVmWmdlN0lrKQp6XyFtbyViKkotS2wy PF5qe2lSUXNXN1Ayb0V6M2wzNHhVdDBebj0qYzdeVWllNihKTVFhPUNvSisjUTdUMzJpQVAKekFC UUF5OSpmdjZycX5rIXpvKW1LKllHbFY9dUp0MDtaMGI2RCRvVj53eyEhNlRrVDJtSkE/JnxxVjtp QmpXZ2VOCno9e0xkMlBoSHN2SUFVI0hJaUhDWWJZa008XnpYRnlCKiNzVF8pNGVDPys2KDtqeHh6 Xj52KnVgbHtSJXl2KHVTSwp6UmIob088cTJVZGJecjJ+WGxAbFhmX0tpaGRCMSpfIyZOcm9WZmxe clVmb35Fa3NfIVVkdTs9cUEoWEcyOzNLPFUKenwxPDQ2cFhDX014R3tEVl49PkpeNkNESE8rPVgj MCsqUzVyeXxNR0E5V3NWJGU+NzVYO2c2YGxqcXUxVVApN29uCno5WF9CVnZoWUcmQzNPK2dXOXpB QChxYShRI2podTM0UkNAWFlVbmw4ajNzUHpDbG9aZyk+RTZ5byFRTWlLOyowJQp6XlhfMXtpRWw1 fE0+MzJTdD9yc31yPUNvcnNIVkVYeV4oSSNSIThwTGo1MHtyRlEtRmt1WkBwY0ZTTlIoSFNiPWEK elYkMkdaTW9RZTcqQEhCPkZqOUxMaEdXKDI9SjklRDJKSkhkQTJCcFU5bExTYFZ8MUc+OWt5Unok R0Z5LStsYE1TCnpnVEV1a0B+YGZeQzN9aHw/cGtOUkhfMzxsVXk/ZTQ/I3w3dkh2KzdyT1VVNTR6 NlRiZU12S3tGPz1zQUs5QEdhMAp6R2tLbDNQVUk5NnZzZGA0SmVScSl3KVFsQkNuU30wTSZ6KTA/ andTTSFyay1nYUE8ZS01RkdBZm14d0w2WmgrTj4Kend9NlE+O0JERGR5OV48RzZVfmVVKU9gJFQ5 Snx2RXtTfVk/TUh0JSUqKGJhJTtaRGxBTGNzTHBGPW8+QDdpZkomCnpDbDRhUUdrZGEmT31vSmxs MntlUUlTdkklSk59Py1vXjR7VTN6PDM2V207JTYoTH5STkRsUiN4XnR7WkxOPShDSQp6RzFLTzV2 cEh+PW5jaEIxaEtAdlRaYXNePG90SUpjZj9jN1RUU1pOQDsqa2pSQDgoJiU2UT5wZSRvQClhJnZL PEMKejBrbUhEZmslPm13SGJZfi1pRXgodUJAUlolKj4zfi1kPG5QQF5sMlJ5Y3BLY3QzOUh5d2pU R0hKSHhAQDJwN1FtCnppd3tHQiVSWmlROVdaQGspeGMxd2wxYld+VUReSjlJUHdpZ05+KitJI2Fn SDktRGEhMSp+bnRsYFQ7JSpuJG9KXwp6YUswYUpGWThgLXtIWEZXYDluR1JqWDghdEVDZFlhYnx+ K01eJip6VVZpR0hLa1pQSyo7ezx+aUBBcURvOFo/MmoKelNqe1V4NX1PdE5wNkgwamM7cnxiI2U9 U0cleCNJYilkR2UwM3ljVkN6dF9JIS12aG1aWFVeMkh0S3JYM3hWJCMzCnpDYjkmbGFpTUojQnkx KD0yYzgqY1QlSkAxeGl9ZTA8bVdYcENjVyRIOX5RezJzMTE9I2tzMjwrRGt0VVRGYG9tYwp6Nndt SjAyVEotaEYlJXxFXkdZKGVpfUEpPShLVHhYUVZFPmZKYk49Y0Qpc1o/bU5oSUFeVH0hT0w4X1kl azsrTDgKellOIy0wdUpCNHJCanZlKCs8XzJhN0JedmxvOyhoKXo/XlhLaz5rd29jdX02NkAyYEAz cUd0UWJnIXcxWGsmV3Q2Cno9czRhX2FHbHBGWCQqNURXSmF3XnVSRW5SaWAyRSskfm5BYFhGYmAo UG07PDxTWF92Tzs2MjFnTHczQGxjNk9AVAp6YCM1JWBWSUZsLT52U3ZtbWtpR3gpXzhXb142JXV+ Ql52bGllYC1EYmRCfGMqSlNCMHlHb2BBKnlLTG90MVNMaUwKekZ3NFIyS2pqQCs7WFdFe1VoTThO dTEkUjdEcD9NWkYpSWs+LWdrb35TKmhRd2JMO2RIZ2VtPkklYXgtLWhoZ1Y5Cno7IWtYaHJRS097 Y19xNkNwWE0/RT0oVFdDVzZQb1RNYDlvMG1He1Y5eHwxOU1UREhZeWZNU01fejdIbGR5aFNldAp6 PENkcXRuczY2e0E4UHF+VVk/Z3VaaUxzeVlBMUtvN0chOTw8MldBWk5PYll9Py1IVlJzUlpocWh6 e1VwOTRXdFQKenpyWG03LVQ/MT5ZM0dDNHBhe0cxQGB0d09ALWt4bXFhdlVZN2IlVVhMYX1sVVZf dihvVldCcGBuUXZzKzB2OG5HCnpVXmQ4YCk+VTBGZ0h0Y2s1THpfTVYyI3sxVEhDczxqYlgyUVkq cUBGYGZNaXEjcjZ6cldTZnJGbypXS3I1IXtYJAp6OTQ5dW5sRVgtKGkyKl83N35INVRQTys5OT1T R1QwP3F3UHxmOWcpYTJYeHhaOTRTSHNhNz1lJkN5Rnc0WH1YWmUKenY+TkdoT0cye0k2UF9jLURO JEJLbWVnPWRHOFJmMGIzVGQ+d2tWSTgyd15QfTt3QH56NjlBPCFqLU4oO0doQSQzCno8K0o4e3tn Jnd0T0hOKHpzakQ4X1N5K1hQM2thfmtUbipxSGteZTU4V1d2Q3JIMTNUT0RiOEozRlklVmhOKCpu YQp6MldgOD5VZX5QI3lATDlENntXRkwqRzx3ZVMyRDF1T092JjBtYFd3eDBSPEJUaFV6IWxacUlL JnlVK3lSXlRldTsKelUjOURTWG1EXllJemJgdFFaZllvY0lkXmlyeWNwJXlGSz1nd2B0YStZaD9U ZVk+ZjdWdl5zU3wlJHdHezlpbShRCnokNjdXcCZoOGU9QlJNX345VjdlKXA8MTEmX3JFX2pXRz1Y Rz5zc1NESEg0YWgqNjQ3Mm4yWUBeXiV7U0V4TCt5eAp6YCs7OCtSNFRNS0BnfGRWYVk/eXNLI1Jr dm5gXkVyQVh6eGIkMWV0Kko3d3VoOWg2TkI2M0FqNCp8X3FuPDF+Mz0KenFKdn5JcW8hXjNjTTs9 WTZOfFBsJjZ8R1c3fil5S0FpKkJxXndfUEs4YWkxVHZlTE80a1FxfD1NU2dwflBLTkg2CnpYUVVm fXlMLVdUey1RdkI8ez9vIT9+NTNJS2BqNHQ1JnZ9bGY2blNybm84JHlNPiFyeTJuQD5gNkVZZ0ha X2IzSAp6ZjBlQytqMlFNNGlxcVU4JnQ8eG94JFRiaktOOCZicjk9RSVYb0JCSEtkdzs1aXtRX0gk V3kpX1N1TylhPThjSj8KeihBPCFDdHBsU3BqX2lDR0hDMFklcjxkMjZIZ1FyWT5yXmhPOXE3UT1B KXp5QlF+X1YjI3gtQU80YlRtYjRoI2puCno3VXFXYnRePX0wTF9rc1ZTKF9aSU5SdTh1MGF1TyE0 JDYqcndWJX5wSnxsP3ArazU5MHZAN0dJMlBWZXNxalNPXwp6YTVlWTNNKnlpVj5FcEJlUkUzPzZz bkMlISotRUc1UGQlTzRJU21TXnk9aCh1SmlTSyk5R0E7WGwkTXJmZFI1fDIKeilIN2NiJiQrenMt VX1Od0U9c3lZeng7d2IrZlF8WEMwZ0dKYlVNJH5HfjlrKk1AJX1HSytBYitWQl9oSWs/QH0/Cnom UiRjYVhkMXNIcU8zKGduTVdNVjYwZD1MMUZwPmxYeW01XlVIZ0xpK0h0bjw7N3NrXnVranpCZFhA fmI9JWd6NAp6a2NEYnNEfHU3aVQrQjRhK1FWQzkrfHMmNyQ5R3MxVGZ8MzY2cStXbT4rcDsyX0Rh Qyg9I2tfOGItb2NsezJRe2EKQm1nQGlqCgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vbWFjL2VkaXRpbmcvc2VsZWN0aW9uLzI1MjI4LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3Rz L3BsYXRmb3JtL21hYy9lZGl0aW5nL3NlbGVjdGlvbi8yNTIyOC1leHBlY3RlZC50eHQKaW5kZXgg NDk1ZDUwNWNlODAzNDJlZTJjYTZjYzQyMmM2N2IxNGRkZTRmMzc5NS4uNzJmYjFkMzNmMjAxNjE3 NTczNzVmN2E3Yjc0NjNmNzE2ZmJjZmQxNyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vbWFjL2VkaXRpbmcvc2VsZWN0aW9uLzI1MjI4LWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9tYWMvZWRpdGluZy9zZWxlY3Rpb24vMjUyMjgtZXhwZWN0ZWQudHh0CkBA IC0yMSw0ICsyMSwzIEBAIGxheWVyIGF0ICgwLDApIHNpemUgMjAwOHgzMTA4CiAgICAgICAgICAg dGV4dCBydW4gYXQgKDEsNzMpIHdpZHRoIDYwNjogInNlbGVjdGlvbnMgYXJlIHJldmVhbGVkIHRo ZSByZXN1bHRzIGZvciB0aGlzIHRlc3QgbWlnaHQgY2hhbmdlIGFuZCBpdCBtYXkgbm8gbG9uZ2Vy IHRlc3QgZm9yIHRoZSBidWcuIgogICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQgKDAsOTIpIHNp emUgMjAwMHgzMDAwCiBjYXJldDogcG9zaXRpb24gMCBvZiBjaGlsZCAwIHsjdGV4dH0gb2YgY2hp bGQgMSB7RElWfSBvZiBjaGlsZCAxIHtCT0RZfSBvZiBjaGlsZCAwIHtIVE1MfSBvZiBkb2N1bWVu dAotc2Nyb2xsZWQgdG8gOSw5CmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNv cmUvQ2hhbmdlTG9nCmluZGV4IDdiMGQxM2Y4OWZkODI4ZmY4ZTA0ZDRhMGMwMGQwYzYwNWVjNDBi ODYuLjk0N2RlOWQ4N2IzYzY5ODZmMGQ0MjBkZWJlZTNiY2JmODk0OWQ4YzMgMTAwNjQ0Ci0tLSBh L1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzIg QEAKKzIwMTAtMDUtMjMgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0BjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgT2phbiBWYWZhaS4KKworICAgICAgICBGaXhlZCBmcmFt ZSBwYWdlIHVwL2Rvd24gc2Nyb2xsaW5nIGNhbGN1bGF0aW9uLiBNYWRlIHN1cmUgdGhhdCB0aGUK KyAgICAgICAgY3Vyc29yIG1vdmVzIHdpdGggcGFnZSB1cC9kb3duIGV2ZW50LiBQbGVhc2Ugbm90 ZSB0aGF0IG5vdyBmb3IgbWFjCisgICAgICAgIGVkaXRpbmcgYmVoYXZpb3Igd2Ugd2lsbCBzY3Jv bGwgdGhlIGNvbnRlbnQgdG8gY2VudGVyIHRoZSBjdXJzb3Igb24KKyAgICAgICAgcGFnZSB1cC9k b3duIHdoaWxlIG90aGVyIHBsYXRmb3JtcyB3aWxsIGFsaWduIHRoZSBjdXJzb3Igd2l0aCB0aGUg dG9wIG9mCisgICAgICAgIGRpc3BsYXllZCBmcmFtZS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4MjEzCisKKyAgICAgICAgVGVzdHM6IGVkaXRpbmcv aW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sIChmaXhlZCkKKyAgICAgICAgICAgICAgIGVk aXRpbmcvaW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAtZG93bi5odG1sCisKKyAgICAgICAg KiBXZWJDb3JlLmJhc2UuZXhwOgorICAgICAgICAqIGVkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHA6 CisgICAgICAgIChXZWJDb3JlOjp2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKTogRml4ZWQgcGFnZSBz Y3JvbGwgY2FsY3VsYXRpb24uIE5vdyBzY3JvbGwgaGVpZ2h0IGlzIGNhbGN1bGF0ZWQgb25seSBm cm9tIHRoZSB2aXNpYmxlIHBvcnRpb24gbm90IHRoZSBlbnRpcmUgZnJhbWUgaGVpZ2h0LgorICAg ICAgICAoV2ViQ29yZTo6ZXhlY3V0ZU1vdmVQYWdlRG93bik6IE5vdyBpdCBjYW4gdGVsbCBTZWxl Y3Rpb25Db250cm9sbGVyIHRvIG1vdmUgdGhlIGN1cnNvciB3aXRoIHRoZSBwYWdlIHNjcm9sbCB1 cC9kb3duIGV2ZW50cy4KKyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVNb3ZlUGFnZURvd25BbmRN b2RpZnlTZWxlY3Rpb24pOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVNb3ZlUGFn ZVVwKTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpleGVjdXRlTW92ZVBhZ2VVcEFuZE1vZGlm eVNlbGVjdGlvbik6IERpdHRvLgorICAgICAgICAqIGVkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxl ci5jcHA6CisgICAgICAgICogZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcDogRXhwb3Nl ZCBhbiBlbnVtIHBhcmFtIHRoYXQgbGV0cyBFZGl0b3JDb21tYW5kLmNwcCBjb250cm9sIGhvdyBj dXJzb3IgcG9zaXRpb24gd2lsbCBiZSBhbGlnbmVkIHdoZW4gcGFnZSBtb3Zlcy4KKyAgICAgICAg KFdlYkNvcmU6OlNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbik6IERpdHRvLgorICAg ICAgICAoV2ViQ29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5KTogRGl0dG8uCisgICAg ICAgICogZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmg6IERpdHRvLgorICAgICAgICAoV2Vi Q29yZTo6U2VsZWN0aW9uQ29udHJvbGxlcjo6KTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpT ZWxlY3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb24pOiBEaXR0by4KKwogMjAxMC0wNS0yMyAg TU9SSVRBIEhhamltZSAgPG1vcnJpdGFAZ29vZ2xlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBi eSBLZW50IFRhbXVyYS4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvV2ViQ29yZS5iYXNlLmV4cCBiL1dl YkNvcmUvV2ViQ29yZS5iYXNlLmV4cAppbmRleCA1NTg1MzFhMDVjOWFhYzc1NWNhY2YwYzQzMDdm NzUxYWE5MmVhZDIzLi5jM2U5MjA4NjQ3NWNiOGIwY2UwOTg4OGQ4ZjlkY2Q5YmRmZjUyM2I0IDEw MDY0NAotLS0gYS9XZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAKKysrIGIvV2ViQ29yZS9XZWJDb3Jl LmJhc2UuZXhwCkBAIC00MjAsNyArNDIwLDcgQEAgX19aTjdXZWJDb3JlMTlBbmltYXRpb25Db250 cm9sbGVyMjFwYXVzZVRyYW5zaXRpb25BdFRpbWVFUE5TXzEyUmVuZGVyT2JqZWN0RVJLTlMKIF9f Wk43V2ViQ29yZTE5Q1NTU3R5bGVEZWNsYXJhdGlvbjExc2V0UHJvcGVydHlFUktOU182U3RyaW5n RVMzX1JpCiBfX1pON1dlYkNvcmUxOUluc3BlY3RvckNvbnRyb2xsZXIzNGluc3BlY3RvclN0YXJ0 c0F0dGFjaGVkU2V0dGluZ05hbWVFdgogX19aTjdXZWJDb3JlMTlTZWxlY3Rpb25Db250cm9sbGVy MTBzZXRGb2N1c2VkRWIKLV9fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjEyc2V0U2Vs ZWN0aW9uRVJLTlNfMTZWaXNpYmxlU2VsZWN0aW9uRWJiYk5TXzE1VGV4dEdyYW51bGFyaXR5RQor X19aTjdXZWJDb3JlMTlTZWxlY3Rpb25Db250cm9sbGVyMTJzZXRTZWxlY3Rpb25FUktOU18xNlZp c2libGVTZWxlY3Rpb25FYmJiTlMwXzE5Q3Vyc29yQWxpZ25PblNjcm9sbEVOU18xNVRleHRHcmFu dWxhcml0eUUKIF9fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjE2c2V0U2VsZWN0ZWRS YW5nZUVQTlNfNVJhbmdlRU5TXzlFQWZmaW5pdHlFYgogX19aTjdXZWJDb3JlMTlTZWxlY3Rpb25D b250cm9sbGVyNWNsZWFyRXYKIF9fWk43V2ViQ29yZTE5U2VsZWN0aW9uQ29udHJvbGxlcjZtb2Rp ZnlFTlMwXzExRUFsdGVyYXRpb25FTlMwXzEwRURpcmVjdGlvbkVOU18xNVRleHRHcmFudWxhcml0 eUViCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAgYi9XZWJD b3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAKaW5kZXggNGNiMzRhY2JjZGMyMDkwMzJlODRj NjIzOWY3ZTk2ZWU4Mzg0NWRkMi4uZDIxMWVjY2VjMzljZDI3MzBmZjUxYWI0NGZmY2FhYWIzOWY2 MzBlMSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL0VkaXRvckNvbW1hbmQuY3BwCisrKyBi L1dlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcApAQCAtNDEsMTMgKzQxLDEzIEBACiAj aW5jbHVkZSAiRXZlbnRIYW5kbGVyLmgiCiAjaW5jbHVkZSAiRm9ybWF0QmxvY2tDb21tYW5kLmgi CiAjaW5jbHVkZSAiRnJhbWUuaCIKKyNpbmNsdWRlICJGcmFtZVZpZXcuaCIKICNpbmNsdWRlICJI VE1MRm9udEVsZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MSFJFbGVtZW50LmgiCiAjaW5jbHVkZSAi SFRNTEltYWdlRWxlbWVudC5oIgogI2luY2x1ZGUgIkluZGVudE91dGRlbnRDb21tYW5kLmgiCiAj aW5jbHVkZSAiSW5zZXJ0TGlzdENvbW1hbmQuaCIKICNpbmNsdWRlICJQYWdlLmgiCi0jaW5jbHVk ZSAiUmVuZGVyQm94LmgiCiAjaW5jbHVkZSAiUmVwbGFjZVNlbGVjdGlvbkNvbW1hbmQuaCIKICNp bmNsdWRlICJTY3JvbGxiYXIuaCIKICNpbmNsdWRlICJTZXR0aW5ncy5oIgpAQCAtMjU5LDcgKzI1 OSw4IEBAIHN0YXRpYyBpbnQgdmVydGljYWxTY3JvbGxEaXN0YW5jZShGcmFtZSogZnJhbWUpCiAg ICAgICAgIHJldHVybiAwOwogICAgIGlmICghKHN0eWxlLT5vdmVyZmxvd1koKSA9PSBPU0NST0xM IHx8IHN0eWxlLT5vdmVyZmxvd1koKSA9PSBPQVVUTyB8fCBmb2N1c2VkTm9kZS0+aXNDb250ZW50 RWRpdGFibGUoKSkpCiAgICAgICAgIHJldHVybiAwOwotICAgIGludCBoZWlnaHQgPSB0b1JlbmRl ckJveChyZW5kZXJlciktPmNsaWVudEhlaWdodCgpOworICAgIGludCBoZWlnaHQgPSBzdGQ6Om1p bjxpbnQ+KHRvUmVuZGVyQm94KHJlbmRlcmVyKS0+Y2xpZW50SGVpZ2h0KCksCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZnJhbWUtPnZpZXcoKS0+dmlzaWJsZUhlaWdodCgpKTsKICAg ICByZXR1cm4gbWF4KG1heDxpbnQ+KGhlaWdodCAqIFNjcm9sbGJhcjo6bWluRnJhY3Rpb25Ub1N0 ZXBXaGVuUGFnaW5nKCksIGhlaWdodCAtIFNjcm9sbGJhcjo6bWF4T3ZlcmxhcEJldHdlZW5QYWdl cygpKSwgMSk7CiB9CiAKQEAgLTY0Niw3ICs2NDcsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92 ZVBhZ2VEb3duKEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDb21tYW5kU291cmNlLCBjb25z dAogICAgIGludCBkaXN0YW5jZSA9IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoZnJhbWUpOwogICAg IGlmICghZGlzdGFuY2UpCiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gZnJhbWUt PnNlbGVjdGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6TU9WRSwgZGlzdGFuY2Us IHRydWUpOworICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25D b250cm9sbGVyOjpNT1ZFLCBkaXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxlcjo6QWxp Z25DdXJzb3JPblNjcm9sbEFsd2F5cyk7CiB9CiAKIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFn ZURvd25BbmRNb2RpZnlTZWxlY3Rpb24oRnJhbWUqIGZyYW1lLCBFdmVudCosIEVkaXRvckNvbW1h bmRTb3VyY2UsIGNvbnN0IFN0cmluZyYpCkBAIC02NTQsNyArNjU1LDcgQEAgc3RhdGljIGJvb2wg ZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlmeVNlbGVjdGlvbihGcmFtZSogZnJhbWUsIEV2ZW50 KiwgRWRpdG9yQ28KICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKGZy YW1lKTsKICAgICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0 dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6OkVYVEVO RCwgZGlzdGFuY2UsIHRydWUpOworICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlm eShTZWxlY3Rpb25Db250cm9sbGVyOjpFWFRFTkQsIGRpc3RhbmNlLCB0cnVlLCBTZWxlY3Rpb25D b250cm9sbGVyOjpBbGlnbkN1cnNvck9uU2Nyb2xsQWx3YXlzKTsKIH0KIAogc3RhdGljIGJvb2wg ZXhlY3V0ZU1vdmVQYWdlVXAoRnJhbWUqIGZyYW1lLCBFdmVudCosIEVkaXRvckNvbW1hbmRTb3Vy Y2UsIGNvbnN0IFN0cmluZyYpCkBAIC02NjIsNyArNjYzLDcgQEAgc3RhdGljIGJvb2wgZXhlY3V0 ZU1vdmVQYWdlVXAoRnJhbWUqIGZyYW1lLCBFdmVudCosIEVkaXRvckNvbW1hbmRTb3VyY2UsIGNv bnN0IFMKICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKGZyYW1lKTsK ICAgICBpZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJuIGZy YW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1kaXN0 YW5jZSwgdHJ1ZSk7CisgICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVj dGlvbkNvbnRyb2xsZXI6Ok1PVkUsIC1kaXN0YW5jZSwgdHJ1ZSwgU2VsZWN0aW9uQ29udHJvbGxl cjo6QWxpZ25DdXJzb3JPblNjcm9sbEFsd2F5cyk7CiB9CiAKIHN0YXRpYyBib29sIGV4ZWN1dGVN b3ZlUGFnZVVwQW5kTW9kaWZ5U2VsZWN0aW9uKEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JD b21tYW5kU291cmNlLCBjb25zdCBTdHJpbmcmKQpAQCAtNjcwLDcgKzY3MSw3IEBAIHN0YXRpYyBi b29sIGV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2VsZWN0aW9uKEZyYW1lKiBmcmFtZSwgRXZl bnQqLCBFZGl0b3JDb21tCiAgICAgaW50IGRpc3RhbmNlID0gdmVydGljYWxTY3JvbGxEaXN0YW5j ZShmcmFtZSk7CiAgICAgaWYgKCFkaXN0YW5jZSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAg IHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1vZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpF WFRFTkQsIC1kaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+ bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6OkVYVEVORCwgLWRpc3RhbmNlLCB0cnVlLCBTZWxl Y3Rpb25Db250cm9sbGVyOjpBbGlnbkN1cnNvck9uU2Nyb2xsQWx3YXlzKTsKIH0KIAogc3RhdGlj IGJvb2wgZXhlY3V0ZU1vdmVSaWdodChGcmFtZSogZnJhbWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFu ZFNvdXJjZSwgY29uc3QgU3RyaW5nJikKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9TZWxl Y3Rpb25Db250cm9sbGVyLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVy LmNwcAppbmRleCBkYjBlMDRkOGJiN2RlMjkwNTg3OGU2ZjJkNzdkOGVlZGU5ZGIyMzgzLi44YjM4 MjdkNWNiMTVmZGViYzZkNWRmN2I4OGQ2NGNkYTE2OWZlNWE3IDEwMDY0NAotLS0gYS9XZWJDb3Jl L2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL1Nl bGVjdGlvbkNvbnRyb2xsZXIuY3BwCkBAIC03OSw5ICs3OSw5IEBAIFNlbGVjdGlvbkNvbnRyb2xs ZXI6OlNlbGVjdGlvbkNvbnRyb2xsZXIoRnJhbWUqIGZyYW1lLCBib29sIGlzRHJhZ0NhcmV0Q29u dHJvbGxlCiAgICAgc2V0SXNEaXJlY3Rpb25hbChmYWxzZSk7CiB9CiAKLXZvaWQgU2VsZWN0aW9u Q29udHJvbGxlcjo6bW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlvbiAmcG9zLCBib29sIHVzZXJU cmlnZ2VyZWQpCit2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vdmVUbyhjb25zdCBWaXNpYmxl UG9zaXRpb24gJnBvcywgYm9vbCB1c2VyVHJpZ2dlcmVkLCBDdXJzb3JBbGlnbk9uU2Nyb2xsIGFs aWduKQogewotICAgIHNldFNlbGVjdGlvbihWaXNpYmxlU2VsZWN0aW9uKHBvcy5kZWVwRXF1aXZh bGVudCgpLCBwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmFmZmluaXR5KCkpLCB0cnVlLCB0cnVl LCB1c2VyVHJpZ2dlcmVkKTsKKyAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVjdGlvbihwb3Mu ZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmRlZXBFcXVpdmFsZW50KCksIHBvcy5hZmZpbml0eSgpKSwg dHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCwgYWxpZ24pOwogfQogCiB2b2lkIFNlbGVjdGlvbkNv bnRyb2xsZXI6Om1vdmVUbyhjb25zdCBWaXNpYmxlUG9zaXRpb24gJmJhc2UsIGNvbnN0IFZpc2li bGVQb3NpdGlvbiAmZXh0ZW50LCBib29sIHVzZXJUcmlnZ2VyZWQpCkBAIC0xMDUsNyArMTA1LDcg QEAgdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjptb3ZlVG8oY29uc3QgUG9zaXRpb24gJmJhc2Us IGNvbnN0IFBvc2l0aW9uICZleHRlbnQsIEUKICAgICBzZXRTZWxlY3Rpb24oVmlzaWJsZVNlbGVj dGlvbihiYXNlLCBleHRlbnQsIGFmZmluaXR5KSwgdHJ1ZSwgdHJ1ZSwgdXNlclRyaWdnZXJlZCk7 CiB9CiAKLXZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKGNvbnN0IFZpc2li bGVTZWxlY3Rpb24mIHMsIGJvb2wgY2xvc2VUeXBpbmcsIGJvb2wgY2xlYXJUeXBpbmdTdHlsZSwg Ym9vbCB1c2VyVHJpZ2dlcmVkLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkpCit2b2lkIFNl bGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBz LCBib29sIGNsb3NlVHlwaW5nLCBib29sIGNsZWFyVHlwaW5nU3R5bGUsIGJvb2wgdXNlclRyaWdn ZXJlZCwgQ3Vyc29yQWxpZ25PblNjcm9sbCBhbGlnbiwgVGV4dEdyYW51bGFyaXR5IGdyYW51bGFy aXR5KQogewogICAgIG1fZ3JhbnVsYXJpdHkgPSBncmFudWxhcml0eTsKIApAQCAtMTYxLDggKzE2 MSwxNiBAQCB2b2lkIFNlbGVjdGlvbkNvbnRyb2xsZXI6OnNldFNlbGVjdGlvbihjb25zdCBWaXNp YmxlU2VsZWN0aW9uJiBzLCBib29sIGNsb3NlVHlwaQogICAgIHNlbGVjdEZyYW1lRWxlbWVudElu UGFyZW50SWZGdWxseVNlbGVjdGVkKCk7CiAgICAgbV9mcmFtZS0+bm90aWZ5UmVuZGVyZXJPZlNl bGVjdGlvbkNoYW5nZSh1c2VyVHJpZ2dlcmVkKTsKICAgICBtX2ZyYW1lLT5yZXNwb25kVG9DaGFu Z2VkU2VsZWN0aW9uKG9sZFNlbGVjdGlvbiwgY2xvc2VUeXBpbmcpOwotICAgIGlmICh1c2VyVHJp Z2dlcmVkKQotICAgICAgICBtX2ZyYW1lLT5yZXZlYWxTZWxlY3Rpb24oU2Nyb2xsQWxpZ25tZW50 OjphbGlnblRvRWRnZUlmTmVlZGVkLCB0cnVlKTsKKyAgICBpZiAodXNlclRyaWdnZXJlZCkgewor ICAgICAgICBTY3JvbGxBbGlnbm1lbnQgYWxpZ25tZW50OworCisgICAgICAgIGlmIChtX2ZyYW1l LT5zZXR0aW5ncygpICYmIG1fZnJhbWUtPnNldHRpbmdzKCktPmVkaXRpbmdCZWhhdmlvcigpID09 IEVkaXRpbmdNYWNCZWhhdmlvcikKKyAgICAgICAgICAgIGFsaWdubWVudCA9IChhbGlnbiA9PSBB bGlnbkN1cnNvck9uU2Nyb2xsQWx3YXlzKSA/IFNjcm9sbEFsaWdubWVudDo6YWxpZ25DZW50ZXJB bHdheXMgOiBTY3JvbGxBbGlnbm1lbnQ6OmFsaWduQ2VudGVySWZOZWVkZWQ7CisgICAgICAgIGVs c2UKKyAgICAgICAgICAgIGFsaWdubWVudCA9IChhbGlnbiA9PSBBbGlnbkN1cnNvck9uU2Nyb2xs QWx3YXlzKSA/IFNjcm9sbEFsaWdubWVudDo6YWxpZ25Ub3BBbHdheXMgOiBTY3JvbGxBbGlnbm1l bnQ6OmFsaWduVG9FZGdlSWZOZWVkZWQ7CisKKyAgICAgICAgbV9mcmFtZS0+cmV2ZWFsU2VsZWN0 aW9uKGFsaWdubWVudCwgdHJ1ZSk7CisgICAgfQogCiAgICAgbm90aWZ5QWNjZXNzaWJpbGl0eUZv clNlbGVjdGlvbkNoYW5nZSgpOwogfQpAQCAtNzE0LDcgKzcyMiw3IEBAIHN0YXRpYyBib29sIGFi c29sdXRlQ2FyZXRZKGNvbnN0IFZpc2libGVQb3NpdGlvbiAmYywgaW50ICZ5KQogICAgIHJldHVy biB0cnVlOwogfQogCi1ib29sIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vZGlmeShFQWx0ZXJhdGlv biBhbHRlciwgaW50IHZlcnRpY2FsRGlzdGFuY2UsIGJvb2wgdXNlclRyaWdnZXJlZCkKK2Jvb2wg U2VsZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVBbHRlcmF0aW9uIGFsdGVyLCBpbnQgdmVydGlj YWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dlcmVkLCBDdXJzb3JBbGlnbk9uU2Nyb2xsIGFsaWdu KQogewogICAgIGlmICh2ZXJ0aWNhbERpc3RhbmNlID09IDApCiAgICAgICAgIHJldHVybiBmYWxz ZTsKQEAgLTc4Miw3ICs3OTAsNyBAQCBib29sIFNlbGVjdGlvbkNvbnRyb2xsZXI6Om1vZGlmeShF QWx0ZXJhdGlvbiBhbHRlciwgaW50IHZlcnRpY2FsRGlzdGFuY2UsIGJvb2wgdQogCiAgICAgc3dp dGNoIChhbHRlcikgewogICAgICAgICBjYXNlIE1PVkU6Ci0gICAgICAgICAgICBtb3ZlVG8ocmVz dWx0LCB1c2VyVHJpZ2dlcmVkKTsKKyAgICAgICAgICAgIG1vdmVUbyhyZXN1bHQsIHVzZXJUcmln Z2VyZWQsIGFsaWduKTsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICBjYXNlIEVYVEVORDoK ICAgICAgICAgICAgIHNldEV4dGVudChyZXN1bHQsIHVzZXJUcmlnZ2VyZWQpOwpkaWZmIC0tZ2l0 IGEvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuaCBiL1dlYkNvcmUvZWRpdGlu Zy9TZWxlY3Rpb25Db250cm9sbGVyLmgKaW5kZXggOWE0MDdmYzBjNWQ5MjNlZjYyYWMzMDRkYmRk NTcwOTQ4N2UyMDZiMy4uYzNkYzJmMmVhZGMzYWU5YTRjODYwYmQwNzk2NzNiYTk1MzE2MmExMyAx MDA2NDQKLS0tIGEvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuaAorKysgYi9X ZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oCkBAIC00NSw2ICs0NSw4IEBAIGNs YXNzIFNlbGVjdGlvbkNvbnRyb2xsZXIgOiBwdWJsaWMgTm9uY29weWFibGUgewogcHVibGljOgog ICAgIGVudW0gRUFsdGVyYXRpb24geyBNT1ZFLCBFWFRFTkQgfTsKICAgICBlbnVtIEVEaXJlY3Rp b24geyBGT1JXQVJELCBCQUNLV0FSRCwgUklHSFQsIExFRlQgfTsKKyAgICBlbnVtIEN1cnNvckFs aWduT25TY3JvbGwgeyBBbGlnbkN1cnNvck9uU2Nyb2xsSWZOZWVkZWQsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgQWxpZ25DdXJzb3JPblNjcm9sbEFsd2F5cyB9OwogCiAgICAgU2Vs ZWN0aW9uQ29udHJvbGxlcihGcmFtZSogPSAwLCBib29sIGlzRHJhZ0NhcmV0Q29udHJvbGxlciA9 IGZhbHNlKTsKIApAQCAtNTQsMTQgKzU2LDE0IEBAIHB1YmxpYzoKICAgICBOb2RlKiBzaGFkb3dU cmVlUm9vdE5vZGUoKSBjb25zdCB7IHJldHVybiBtX3NlbGVjdGlvbi5zaGFkb3dUcmVlUm9vdE5v ZGUoKTsgfQogICAgICAKICAgICB2b2lkIG1vdmVUbyhjb25zdCBSYW5nZSosIEVBZmZpbml0eSwg Ym9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwotICAgIHZvaWQgbW92ZVRvKGNvbnN0IFZpc2li bGVQb3NpdGlvbiYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKKyAgICB2b2lkIG1vdmVU byhjb25zdCBWaXNpYmxlUG9zaXRpb24mLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSwgQ3Vy c29yQWxpZ25PblNjcm9sbCA9IEFsaWduQ3Vyc29yT25TY3JvbGxJZk5lZWRlZCk7CiAgICAgdm9p ZCBtb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwg Ym9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwogICAgIHZvaWQgbW92ZVRvKGNvbnN0IFBvc2l0 aW9uJiwgRUFmZmluaXR5LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CiAgICAgdm9pZCBt b3ZlVG8oY29uc3QgUG9zaXRpb24mLCBjb25zdCBQb3NpdGlvbiYsIEVBZmZpbml0eSwgYm9vbCB1 c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwogCiAgICAgY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgc2Vs ZWN0aW9uKCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb247IH0KLSAgICB2b2lkIHNldFNlbGVj dGlvbihjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiwgYm9vbCBjbG9zZVR5cGluZyA9IHRydWUsIGJv b2wgY2xlYXJUeXBpbmdTdHlsZSA9IHRydWUsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBU ZXh0R3JhbnVsYXJpdHkgPSBDaGFyYWN0ZXJHcmFudWxhcml0eSk7Ci0gICAgdm9pZCBzZXRTZWxl Y3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgc2VsZWN0aW9uLCBUZXh0R3JhbnVsYXJpdHkg Z3JhbnVsYXJpdHkpIHsgc2V0U2VsZWN0aW9uKHNlbGVjdGlvbiwgdHJ1ZSwgdHJ1ZSwgZmFsc2Us IGdyYW51bGFyaXR5KTsgfQorICAgIHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxl Y3Rpb24mLCBib29sIGNsb3NlVHlwaW5nID0gdHJ1ZSwgYm9vbCBjbGVhclR5cGluZ1N0eWxlID0g dHJ1ZSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UsIEN1cnNvckFsaWduT25TY3JvbGwgPSBB bGlnbkN1cnNvck9uU2Nyb2xsSWZOZWVkZWQsIFRleHRHcmFudWxhcml0eSA9IENoYXJhY3Rlckdy YW51bGFyaXR5KTsKKyAgICB2b2lkIHNldFNlbGVjdGlvbihjb25zdCBWaXNpYmxlU2VsZWN0aW9u JiBzZWxlY3Rpb24sIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSkgeyBzZXRTZWxlY3Rpb24o c2VsZWN0aW9uLCB0cnVlLCB0cnVlLCBmYWxzZSwgQWxpZ25DdXJzb3JPblNjcm9sbElmTmVlZGVk LCBncmFudWxhcml0eSk7IH0KICAgICBib29sIHNldFNlbGVjdGVkUmFuZ2UoUmFuZ2UqLCBFQWZm aW5pdHksIGJvb2wgY2xvc2VUeXBpbmcpOwogICAgIHZvaWQgc2VsZWN0QWxsKCk7CiAgICAgdm9p ZCBjbGVhcigpOwpAQCAtNzYsNyArNzgsNyBAQCBwdWJsaWM6CiAgICAgRUFmZmluaXR5IGFmZmlu aXR5KCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24uYWZmaW5pdHkoKTsgfQogCiAgICAgYm9v bCBtb2RpZnkoRUFsdGVyYXRpb24sIEVEaXJlY3Rpb24sIFRleHRHcmFudWxhcml0eSwgYm9vbCB1 c2VyVHJpZ2dlcmVkID0gZmFsc2UpOwotICAgIGJvb2wgbW9kaWZ5KEVBbHRlcmF0aW9uLCBpbnQg dmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOworICAgIGJvb2wg bW9kaWZ5KEVBbHRlcmF0aW9uLCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dl cmVkID0gZmFsc2UsIEN1cnNvckFsaWduT25TY3JvbGwgPSBBbGlnbkN1cnNvck9uU2Nyb2xsSWZO ZWVkZWQpOwogICAgIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSgpIGNvbnN0IHsgcmV0dXJu IG1fZ3JhbnVsYXJpdHk7IH0KIAogICAgIHZvaWQgc2V0U3RhcnQoY29uc3QgVmlzaWJsZVBvc2l0 aW9uICYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsK 57081 2010-05-26 02:24:57 -0700 2010-05-26 06:42:24 -0700 Patch bug-38213-20100526182455.patch text/plain 90365 tony ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBjNzFhMTFiYzUwM2M0Yzc2NDc3ZmE2YTUyNWZiZDEzN2NlYWYxNzgxLi4zNTY0N2E5 NTc3ODIyMDIzMDk3ODU0NTZjMDM0NDM2ZTA0ODdkNWQ2IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAK KzIwMTAtMDUtMjYgIFplbGlkcmFnIEhvcm51bmcgIDx6ZWxpZHJhZ0BjaHJvbWl1bS5vcmc+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgT2phbiBWYWZhaS4KKworICAgICAgICBGaXhlZCBmcmFtZSBw YWdlIHVwL2Rvd24gc2Nyb2xsaW5nIGNhbGN1bGF0aW9uLiBNYWRlIHN1cmUgdGhhdCB0aGUKKyAg ICAgICAgY3Vyc29yIG1vdmVzIHdpdGggcGFnZSB1cC9kb3duIGV2ZW50LiBQbGVhc2Ugbm90ZSB0 aGF0IG5vdyBmb3IgbWFjCisgICAgICAgIGVkaXRpbmcgYmVoYXZpb3Igd2Ugd2lsbCBzY3JvbGwg dGhlIGNvbnRlbnQgdG8gY2VudGVyIHRoZSBjdXJzb3Igb24KKyAgICAgICAgcGFnZSB1cC9kb3du IHdoaWxlIG90aGVyIHBsYXRmb3JtcyB3aWxsIGFsaWduIHRoZSBjdXJzb3Igd2l0aCB0aGUgdG9w IG9mCisgICAgICAgIGRpc3BsYXllZCBmcmFtZS4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTM4MjEzCisgICAgICAgIAorICAgICAgICAqIGVkaXRpbmcv aW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi1leHBlY3RlZC50eHQ6IEZpeGVkIHBhZ2Ugc2Nyb2xs IGNhbGN1bGF0aW9uLiBOb3cgc2Nyb2xsIGhlaWdodCBpcyBjYWxjdWxhdGVkIG9ubHkgZnJvbSB0 aGUgdmlzaWJsZSBwb3J0aW9uIG5vdCB0aGUgZW50aXJlIGZyYW1lIGhlaWdodC4KKyAgICAgICAg KiBlZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24uaHRtbDogRGl0dG8uCisgICAgICAg ICogZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4 dDogU2Nyb2xsaW5nIHRlc3Qgb2YgY29udGVudGVkaXRhYmxlIGlmcmFtZSBhbmQgZGl2LgorICAg ICAgICAqIGVkaXRpbmcvaW5wdXQvc2Nyb2xsLXZpZXdwb3J0LXBhZ2UtdXAtZG93bi5odG1sOiBE aXR0by4KKyAgICAgICAgKiBlZGl0aW5nL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUtaWZyYW1l LWZpeGVkLXNpemUtc3JjLmh0bWw6IFJlc291cmNlIGZvciB0aGUgc2Nyb2xsaW5nIHRlc3QgYWJv dmUuCisgICAgICAgICogcGxhdGZvcm0vbWFjL2VkaXRpbmcvc2VsZWN0aW9uLzI1MjI4Lmh0bWw6 IENoYW5nZSB0aGUgdGVzdCB0byBoYXZlIHRoZSBjdXJzb3Igb24gdGhlIHJpZ2h0IGVkZ2Ugb2Yg dGhlIHNjcmVlbi4gIFRoZSBvcmlnaW5hbCB0ZXN0CisgICAgICAgICAgICB3YXNuJ3QgdGVzdGlu ZyB0aGUgYmVoYXZpb3IgYW55bW9yZS4KKwogMjAxMC0wNS0yNSAgVG9ueSBDaGFuZyAgPHRvbnlA Y2hyb21pdW0ub3JnPgogCiAgICAgICAgIE5vdCByZXZpZXdlZCwgYWRkaW5nIGNocm9taXVtLW1h YyByZXN1bHRzLiAgVGhleSBkaWZmZXIgZnJvbQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRp dGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3Rz L2VkaXRpbmcvaW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi1leHBlY3RlZC50eHQKaW5kZXggOThh NWJlMDBhY2Y0Y2ZjNzUzODM4MTNhZjRjOGVhMDJlNDM0MWVjMi4uMmVhODE5NDUxZmMxYzMxZjk5 NWU5NTI2YjBmZDg1MWZkMjY5NmYyZCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZWRpdGluZy9p bnB1dC9vcHRpb24tcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9l ZGl0aW5nL2lucHV0L29wdGlvbi1wYWdlLXVwLWRvd24tZXhwZWN0ZWQudHh0CkBAIC0xLDMgKzEs MjUgQEAKLU9uIE1hYywgb3B0aW9uK3BhZ2Vkb3duIHNob3VsZCBtb3ZlIHRoZSBtb3VzZSBjdXJz b3IgYW5kIHNjcm9sbCBpbiB0ZXh0IGFyZWFzLiBPbiBvdGhlciBwbGF0Zm9ybXMsIHBhZ2Vkb3du IHNob3VsZCBtb3ZlIHRoZSBtb3VzZSBjdXJzb3IgYW5kIHNjcm9sbCBpbiB0ZXh0IGFyZWFzLiBU aGlzIHRlc3QgcmVxdWlyZXMgRFJUIHRvIHBhc3MuCitQYWdlIHVwL2Rvd24gKG9wdGlvbitwYWdl IHVwL2Rvd24gb24gTWFjKSBzaG91bGQgbW92ZSB0aGUgbW92ZSBjdXJzb3IgYW5kIHNjcm9sbCB0 aGUgY29udGVudCBpbiBjb250ZW50ZWRpdGFibGUgZWxlbWVudHMuIFRoaXMgc2FtcGxlIGNvdmVy cyBjdXJzb3IgcG9zaXRpb24gbW92ZSB0ZXN0IG9mIGEpIGlmcmFtZSBlbGVtZW50IGNvbnRhaW5p bmcgY29udGVudGVkaXRhYmxlIGJvZHksIGFuZCBiKSBjb250ZW50IGVkaXRhYmxlIGRpdiBlbGVt ZW50LgorCitsaW5lIDAKKworbGluZSAxCisKK2xpbmUgMgorCitsaW5lIDMKKworbGluZSA0CisK K2xpbmUgNQorCitsaW5lIDYKKworbGluZSA3CisKK2xpbmUgOAorCitsaW5lIDkKKworaWZyYW1l IFBBU1MKK2RpdiBQQVNTCiAKLVBBU1MKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcv aW5wdXQvb3B0aW9uLXBhZ2UtdXAtZG93bi5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1 dC9vcHRpb24tcGFnZS11cC1kb3duLmh0bWwKaW5kZXggODZlNTRlYWNiZTdkNmI3ZTRmNmNkYzU5 YTZhZjk5Zjg2NWY4OWVlMS4uMWI2NjVmYjUxODU0ZjZjOGZlMDc1Mzg3ZWQ0OTU4YjUwMmI2YTM2 OSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1k b3duLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9vcHRpb24tcGFnZS11cC1k b3duLmh0bWwKQEAgLTEsMTcgKzEsNDMgQEAKKzxoZWFkPgorPHN0eWxlIHR5cGU9InRleHQvY3Nz Ij4KKyAgLmFoZW0geyBmb250OiAyMHB4IEFoZW07IH0KKzwvc3R5bGU+CiA8c2NyaXB0PgogaWYg KHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5k dW1wQXNUZXh0KCk7CiAKLWZ1bmN0aW9uIHJ1blRlc3QoKQoteworZnVuY3Rpb24gcnVuVGVzdCgp IHsKKyAgcnVuRnJhbWVDdXJzb3JNb3ZlVGVzdCgpOworICBydW5EaXZDdXJzb3JNb3ZlVGVzdCgp OworfQorCitmdW5jdGlvbiBnZW5lcmF0ZUNvbnRlbnQoKSB7CisgICAgdmFyIGNvbnRlbnQgPSAi IjsKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IDEwOyArK2kpCisgICAgICAgIGNvbnRlbnQgKz0g IjxwPmxpbmUgIiArIGkgKyAiPC9wPlxuIjsKKyAgICByZXR1cm4gY29udGVudDsKK30KKworZnVu Y3Rpb24gcnVuRnJhbWVDdXJzb3JNb3ZlVGVzdCgpIHsKICAgICB2YXIgZnJhbWUgPSBmcmFtZXNb MF07CiAgICAgdmFyIGRvYyA9IGZyYW1lLmRvY3VtZW50OwogICAgIHZhciBib2R5ID0gZG9jLmJv ZHk7Ci0gICAgZm9yICh2YXIgaSA9IDA7IGkgPCAxMDsgKytpKQotICAgICAgICBib2R5LmlubmVy SFRNTCArPSAiPHA+bGluZSAiICsgaSArICI8L3A+XG4iOworICAgIGJvZHkuaW5uZXJIVE1MID0g Z2VuZXJhdGVDb250ZW50KCk7CiAgICAgZnJhbWUuZm9jdXMoKTsKICAgICBmcmFtZS5nZXRTZWxl Y3Rpb24oKS5zZXRQb3NpdGlvbihib2R5LmZpcnN0Q2hpbGQsIDApOworICAgIHJ1bkN1cnNvck1v dmVUZXN0KCJpZnJhbWUiLCBmcmFtZSwgZnJhbWUpOworfQorCitmdW5jdGlvbiBydW5EaXZDdXJz b3JNb3ZlVGVzdCgpIHsKKyAgICB2YXIgZWRpdGFibGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgnZWRpdGFibGUnKTsKKyAgICBlZGl0YWJsZS5pbm5lckhUTUwgPSBnZW5lcmF0ZUNvbnRlbnQo KTsKKyAgICBlZGl0YWJsZS5mb2N1cygpOworICAgIHdpbmRvdy5nZXRTZWxlY3Rpb24oKS5zZXRQ b3NpdGlvbihlZGl0YWJsZSwgMCk7CisgICAgcnVuQ3Vyc29yTW92ZVRlc3QoImRpdiIsIGVkaXRh YmxlLCB3aW5kb3cpOworfQogCitmdW5jdGlvbiBydW5DdXJzb3JNb3ZlVGVzdCh0ZXN0TmFtZSwg ZnJhbWUsIHNlbGVjdGlvblNvdXJjZSkKK3sKICAgICB2YXIgb25NYWNQbGF0Zm9ybSA9IG5hdmln YXRvci51c2VyQWdlbnQuc2VhcmNoKC9cYk1hYyBPUyBYXGIvKSAhPSAtMTsKICAgICB2YXIgbW9k aWZpZXJzID0gb25NYWNQbGF0Zm9ybSA/IFsiYWx0S2V5Il0gOiBbXTsKIApAQCAtMTksMjYgKzQ1 LDQ2IEBAIGZ1bmN0aW9uIHJ1blRlc3QoKQogICAgICAgICByZXR1cm47CiAKICAgICBldmVudFNl bmRlci5rZXlEb3duKCJwYWdlRG93biIsIG1vZGlmaWVycyk7Ci0gICAgdmFyIGxpbmUgPSBmcmFt ZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7Ci0gICAgaWYgKGxpbmUgIT0gImxp bmUgOCIpCi0gICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgOCwgbm90ICIg KyBsaW5lOworICAgIHZhciBsaW5lID0gc2VsZWN0aW9uU291cmNlLmdldFNlbGVjdGlvbigpLmJh c2VOb2RlLm5vZGVWYWx1ZTsKKyAgICBpZiAobGluZSAhPSAibGluZSAzIikKKyAgICAgICAgdGhy b3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7CiAKICAgICBldmVu dFNlbmRlci5rZXlEb3duKCJwYWdlRG93biIsIG1vZGlmaWVycyk7Ci0gICAgdmFyIGxpbmUgPSBm cmFtZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7Ci0gICAgaWYgKGxpbmUgIT0g ImxpbmUgOSIpCi0gICAgICAgIHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgOSwgbm90 ICIgKyBsaW5lOworICAgIHZhciBsaW5lID0gc2VsZWN0aW9uU291cmNlLmdldFNlbGVjdGlvbigp LmJhc2VOb2RlLm5vZGVWYWx1ZTsKKyAgICBpZiAobGluZSAhPSAibGluZSA2IikKKyAgICAgICAg dGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSA2LCBub3QgIiArIGxpbmU7CiAKICAgICBl dmVudFNlbmRlci5rZXlEb3duKCJwYWdlVXAiLCBtb2RpZmllcnMpOwotICAgIHZhciBsaW5lID0g ZnJhbWUuZ2V0U2VsZWN0aW9uKCkuYmFzZU5vZGUubm9kZVZhbHVlOwotICAgIGlmIChsaW5lICE9 ICJsaW5lIDEiKQotICAgICAgICB0aHJvdyAiY3Vyc29yIHNob3VsZCBiZSBhdCBsaW5lIDEsIG5v dCAiICsgbGluZTsKKyAgICB2YXIgbGluZSA9IHNlbGVjdGlvblNvdXJjZS5nZXRTZWxlY3Rpb24o KS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgaWYgKGxpbmUgIT0gImxpbmUgMyIpCisgICAgICAg IHRocm93ICJjdXJzb3Igc2hvdWxkIGJlIGF0IGxpbmUgMywgbm90ICIgKyBsaW5lOwogCi0gICAg ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lclRleHQgPSAiUEFTUyI7Cisg ICAgLy8gVGVzdCB0aGF0IG9uIE1hYyBwYWdlRG93bi9wYWdlVXAgZG9lcyBub3QgbW92ZSB0aGUg Y3Vyc29yIGF0IGFsbC4KKyAgICBpZiAob25NYWNQbGF0Zm9ybSkgeworICAgICAgZXZlbnRTZW5k ZXIua2V5RG93bigicGFnZURvd24iLCBbXSk7CisgICAgICB2YXIgbGluZSA9IHNlbGVjdGlvblNv dXJjZS5nZXRTZWxlY3Rpb24oKS5iYXNlTm9kZS5ub2RlVmFsdWU7CisgICAgICBpZiAobGluZSAh PSAibGluZSAzIikgeworICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHRz IikuaW5uZXJUZXh0ID0gImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxpbmU7 CisgICAgICAgICAgdGhyb3cgImN1cnNvciBzaG91bGQgYmUgYXQgbGluZSAzLCBub3QgIiArIGxp bmU7CisgICAgICB9CisKKyAgICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VVcCIsIFtdKTsK KyAgICAgIHZhciBsaW5lID0gc2VsZWN0aW9uU291cmNlLmdldFNlbGVjdGlvbigpLmJhc2VOb2Rl Lm5vZGVWYWx1ZTsKKyAgICAgIGlmIChsaW5lICE9ICJsaW5lIDMiKSB7CisgICAgICAgICAgZG9j dW1lbnQuZ2V0RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lclRleHQgPSAiY3Vyc29yIHNob3Vs ZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGluZTsKKyAgICAgICAgICB0aHJvdyAiY3Vyc29yIHNo b3VsZCBiZSBhdCBsaW5lIDMsIG5vdCAiICsgbGluZTsKKyAgICAgIH0KKyAgICB9CisKKyAgICBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgicmVzdWx0cyIpLmlubmVySFRNTCArPSB0ZXN0TmFtZSAr ICIgUEFTUzxici8+IjsKIH0KIDwvc2NyaXB0PgotCi08ZGl2Pk9uIE1hYywgb3B0aW9uK3BhZ2Vk b3duIHNob3VsZCBtb3ZlIHRoZSBtb3VzZSBjdXJzb3IgYW5kIHNjcm9sbCBpbiB0ZXh0IGFyZWFz LiAgT24KLW90aGVyIHBsYXRmb3JtcywgcGFnZWRvd24gc2hvdWxkIG1vdmUgdGhlIG1vdXNlIGN1 cnNvciBhbmQgc2Nyb2xsIGluIHRleHQgYXJlYXMuICBUaGlzCi10ZXN0IHJlcXVpcmVzIERSVCB0 byBwYXNzLjwvZGl2PgotPGlmcmFtZSBzcmM9Ii4uL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUt aWZyYW1lLXNyYy5odG1sIiBvbmxvYWQ9InJ1blRlc3QoKSI+PC9pZnJhbWU+Ci08ZGl2IGlkPSJy ZXN1bHRzIj5GQUlMPC9kaXY+Cis8L2hlYWQ+Cis8Ym9keT4KKzxkaXY+UGFnZSB1cC9kb3duIChv cHRpb24rcGFnZSB1cC9kb3duIG9uIE1hYykgc2hvdWxkIG1vdmUgdGhlIG1vdmUgY3Vyc29yIGFu ZCBzY3JvbGwgdGhlIGNvbnRlbnQKK2luIGNvbnRlbnRlZGl0YWJsZSBlbGVtZW50cy4gVGhpcyBz YW1wbGUgY292ZXJzIGN1cnNvciBwb3NpdGlvbiBtb3ZlIHRlc3Qgb2YgYSkgaWZyYW1lIGVsZW1l bnQgY29udGFpbmluZworY29udGVudGVkaXRhYmxlIGJvZHksIGFuZCBiKSBjb250ZW50IGVkaXRh YmxlIGRpdiBlbGVtZW50LjwvZGl2PgorPGlmcmFtZSBzcmM9Ii4uL3Jlc291cmNlcy9jb250ZW50 ZWRpdGFibGUtaWZyYW1lLWZpeGVkLXNpemUtc3JjLmh0bWwiIG9ubG9hZD0icnVuVGVzdCgpIj48 L2lmcmFtZT4KKzxkaXYgaWQ9ImVkaXRhYmxlIiBjb250ZW50ZWRpdGFibGU9InRydWUiIGNsYXNz PSJhaGVtIiBzdHlsZT0iaGVpZ2h0OjE1MHB4OyBvdmVyZmxvdzphdXRvOyI+PC9kaXY+Cis8ZGl2 IGlkPSJyZXN1bHRzIj48L2Rpdj4KKzwvYm9keT4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxl CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1w YWdlLXVwLWRvd24tZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3Jv bGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zMDhkNjdh NmEyNDdiNjg3NWQxNmViOTg1ZjU3NzhiN2Q2NDA2NjIxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5 b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLWV4cGVj dGVkLnR4dApAQCAtMCwwICsxLDI1IEBACitQYWdlIHVwL2Rvd24gKG9wdGlvbitwYWdlIHVwL2Rv d24gb24gTWFjKSBzaG91bGQgbW92ZSB0aGUgbW92ZSBjdXJzb3IgYW5kIHNjcm9sbCB0aGUgY29u dGVudCBpbiBjb250ZW50ZWRpdGFibGUgZWxlbWVudHMuIFRoaXMgc2FtcGxlIGNvdmVycyBzY3Jv bGwgcG9zaXRpb24gdGVzdCBvZiBhKSBpZnJhbWUgZWxlbWVudCBjb250YWluaW5nIGNvbnRlbnRl ZGl0YWJsZSBib2R5IGFuZCBiKSBjb250ZW50IGVkaXRhYmxlIGRpdiBlbGVtZW50LiBFdmVuIHRo b3VnaCB0aGUgY3Vyc29yIHdpbGwgbW92ZSBleGFjdGx5IHRvIHRoZSBzYW1lIGxvY2F0aW9uIG9u IGFsbCBwbGF0Zm9ybXMgKGNvdmVyZWQgYnkgdGVzdCBvcHRpb24tcGFnZS11cC1kb3duLmh0bWwp LCBwbGVhc2Ugbm90ZSB0aGF0IE1hYyB3aWxsIHNjcm9sbCB0aGUgdmlzaWJsZSBhcmVhIGJ5IHBs YWNpbmcgdGhlIGN1cnNvciBwb3NpdGlvbiBpbiB0aGUgbWlkZGxlLiBBbGwgb3RoZXIgcGxhdGZv cm1zIHdpbGwgc2Nyb2xsIGJ5IGtlZXBpbmcgdGhlIGN1cnNvciBhbGlnbmVkIHdpdGggdGhlIHRv cCBlZGdlIG9mIHRoZSB2aXNpYmxlIGFyZWEuCisKK2xpbmUgMAorCitsaW5lIDEKKworbGluZSAy CisKK2xpbmUgMworCitsaW5lIDQKKworbGluZSA1CisKK2xpbmUgNgorCitsaW5lIDcKKworbGlu ZSA4CisKK2xpbmUgOQorCitpZnJhbWUgUEFTUworZGl2IFBBU1MKKwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLmh0bWwg Yi9MYXlvdXRUZXN0cy9lZGl0aW5nL2lucHV0L3Njcm9sbC12aWV3cG9ydC1wYWdlLXVwLWRvd24u aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi4xNGI3YWU4ZWFiNzAzYmE5ZWRlNjY4MzVmY2ZjOGExZWI0MmEyNmJk Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9pbnB1dC9zY3JvbGwtdmll d3BvcnQtcGFnZS11cC1kb3duLmh0bWwKQEAgLTAsMCArMSw4OSBAQAorPGhlYWQ+Cis8c3R5bGUg dHlwZT0idGV4dC9jc3MiPgorICAuYWhlbSB7IGZvbnQ6IDIwcHggQWhlbTsgfQorPC9zdHlsZT4K KzxzY3JpcHQ+CisKK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5b3V0 VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOworCit2YXIgb25NYWNQbGF0Zm9ybSA9IG5hdmln YXRvci51c2VyQWdlbnQuc2VhcmNoKC9cYk1hYyBPUyBYXGIvKSAhPSAtMTsKKworZnVuY3Rpb24g cnVuVGVzdCgpIHsKKyAgICBydW5GcmFtZVNjcm9sbFRlc3QoKTsKKyAgICBydW5EaXZTY3JvbGxU ZXN0KCk7Cit9CisKK2Z1bmN0aW9uIGdlbmVyYXRlQ29udGVudCgpIHsKKyAgICB2YXIgY29udGVu dCA9ICIiOworICAgIGZvciAodmFyIGkgPSAwOyBpIDwgMTA7ICsraSkKKyAgICAgICAgY29udGVu dCArPSAiPHA+bGluZSAiICsgaSArICI8L3A+XG4iOworICAgIHJldHVybiBjb250ZW50OworfQor CitmdW5jdGlvbiBydW5GcmFtZVNjcm9sbFRlc3QoKSB7CisgICAgdmFyIGZyYW1lID0gZnJhbWVz WzBdOworICAgIHZhciBkb2MgPSBmcmFtZS5kb2N1bWVudDsKKyAgICB2YXIgYm9keSA9IGRvYy5i b2R5OworICAgIGJvZHkuaW5uZXJIVE1MID0gZ2VuZXJhdGVDb250ZW50KCk7CisgICAgZnJhbWUu Zm9jdXMoKTsKKyAgICBmcmFtZS5nZXRTZWxlY3Rpb24oKS5zZXRQb3NpdGlvbihib2R5LmZpcnN0 Q2hpbGQsIDApOworICAgIGlmIChvbk1hY1BsYXRmb3JtKQorICAgICAgICBvZmZzZXRzID0gWyA1 NSwgMTc1IF07CisgICAgZWxzZSAKKyAgICAgICAgb2Zmc2V0cyA9IFsgMTIwLCAyNDAgXTsKKyAg ICBydW5TY3JvbGxpbmdUZXN0KCJpZnJhbWUiLCBmcmFtZSwgb2Zmc2V0cywgZnVuY3Rpb24oKSB7 IHJldHVybiBmcmFtZS5wYWdlWU9mZnNldDsgfSk7Cit9CisKK2Z1bmN0aW9uIHJ1bkRpdlNjcm9s bFRlc3QoKSB7CisgICAgdmFyIGVkaXRhYmxlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2Vk aXRhYmxlJyk7CisgICAgZWRpdGFibGUuaW5uZXJIVE1MID0gZ2VuZXJhdGVDb250ZW50KCk7Cisg ICAgZWRpdGFibGUuZm9jdXMoKTsKKyAgICB3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuc2V0UG9zaXRp b24oZWRpdGFibGUsIDApOworICAgIGlmIChvbk1hY1BsYXRmb3JtKQorICAgICAgICBvZmZzZXRz ID0gWyA3NSwgMTk1IF07CisgICAgZWxzZSAKKyAgICAgICAgb2Zmc2V0cyA9IFsgMTQwLCAyNjAg XTsKKyAgICBydW5TY3JvbGxpbmdUZXN0KCJkaXYiLCBlZGl0YWJsZSwgb2Zmc2V0cywgZnVuY3Rp b24oKSB7IHJldHVybiBlZGl0YWJsZS5zY3JvbGxUb3A7IH0pOworfQorCitmdW5jdGlvbiBydW5T Y3JvbGxpbmdUZXN0KHRlc3ROYW1lLCBmcmFtZSwgb2Zmc2V0cywgc2Nyb2xsRnVuY3Rpb24pIHsK KyAgICB2YXIgdG9sZXJhbmNlID0gMDsKKyAgICB2YXIgbW9kaWZpZXJzID0gb25NYWNQbGF0Zm9y bSA/IFsiYWx0S2V5Il0gOiBbXTsKKyAgICAKKyAgICBpZiAoIXdpbmRvdy5ldmVudFNlbmRlcikK KyAgICAgICAgcmV0dXJuOworCisgICAgZXZlbnRTZW5kZXIua2V5RG93bigicGFnZURvd24iLCBt b2RpZmllcnMpOworICAgIGlmIChNYXRoLmFicyhzY3JvbGxGdW5jdGlvbigpIC0gb2Zmc2V0c1sw XSkgPiB0b2xlcmFuY2UpIHsKKyAgICAgICAgdGhyb3cgIkZyYW1lIHZpZXdwb3J0IHNob3VsZCBi ZSBhcm91bmQgIiArIG9mZnNldHNbMF0gKworICAgICAgICAgICAgInB4ICwgbm90IGF0ICIgKyBz Y3JvbGxGdW5jdGlvbigpOworICAgIH0KKworICAgIGV2ZW50U2VuZGVyLmtleURvd24oInBhZ2VE b3duIiwgbW9kaWZpZXJzKTsKKyAgICBpZiAoTWF0aC5hYnMoc2Nyb2xsRnVuY3Rpb24oKSAtIG9m ZnNldHNbMV0pID4gdG9sZXJhbmNlKSB7CisgICAgICAgIHRocm93ICJGcmFtZSB2aWV3cG9ydCBz aG91bGQgYmUgYXJvdW5kICIgKyBvZmZzZXRzWzFdICsKKyAgICAgICAgICAgICJweCAsIG5vdCAi ICsgc2Nyb2xsRnVuY3Rpb24oKTsKKyAgICB9CisKKyAgICBldmVudFNlbmRlci5rZXlEb3duKCJw YWdlVXAiLCBtb2RpZmllcnMpOworICAgIGlmIChNYXRoLmFicyhzY3JvbGxGdW5jdGlvbigpIC0g b2Zmc2V0c1swXSkgPiB0b2xlcmFuY2UpIHsKKyAgICAgICAgdGhyb3cgIkZyYW1lIHZpZXdwb3J0 IHNob3VsZCBiZSBhcm91bmQgIiArIG9mZnNldHNbMF0gKworICAgICAgICAgICAgInB4ICwgbm90 IGF0ICIgKyBzY3JvbGxGdW5jdGlvbigpOworICAgIH0KKworICAgIGRvY3VtZW50LmdldEVsZW1l bnRCeUlkKCJyZXN1bHRzIikuaW5uZXJIVE1MICs9IHRlc3ROYW1lICsgIiBQQVNTPGJyLz4iOwor fQorPC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxkaXY+UGFnZSB1cC9kb3duIChvcHRpb24r cGFnZSB1cC9kb3duIG9uIE1hYykgc2hvdWxkIG1vdmUgdGhlIG1vdmUgY3Vyc29yIGFuZCBzY3Jv bGwgdGhlIGNvbnRlbnQKK2luIGNvbnRlbnRlZGl0YWJsZSBlbGVtZW50cy4gVGhpcyBzYW1wbGUg Y292ZXJzIHNjcm9sbCBwb3NpdGlvbiB0ZXN0IG9mIGEpIGlmcmFtZSBlbGVtZW50IGNvbnRhaW5p bmcKK2NvbnRlbnRlZGl0YWJsZSBib2R5IGFuZCBiKSBjb250ZW50IGVkaXRhYmxlIGRpdiBlbGVt ZW50LiBFdmVuIHRob3VnaCB0aGUgY3Vyc29yIHdpbGwgbW92ZSBleGFjdGx5IHRvCit0aGUgc2Ft ZSBsb2NhdGlvbiBvbiBhbGwgcGxhdGZvcm1zIChjb3ZlcmVkIGJ5IHRlc3Qgb3B0aW9uLXBhZ2Ut dXAtZG93bi5odG1sKSwgcGxlYXNlIG5vdGUgdGhhdCBNYWMgd2lsbAorc2Nyb2xsIHRoZSB2aXNp YmxlIGFyZWEgYnkgcGxhY2luZyB0aGUgY3Vyc29yIHBvc2l0aW9uIGluIHRoZSBtaWRkbGUuIEFs bCBvdGhlciBwbGF0Zm9ybXMgd2lsbCBzY3JvbGwgYnkKK2tlZXBpbmcgdGhlIGN1cnNvciBhbGln bmVkIHdpdGggdGhlIHRvcCBlZGdlIG9mIHRoZSB2aXNpYmxlIGFyZWEuIDwvZGl2PgorPGlmcmFt ZSBzcmM9Ii4uL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUtaWZyYW1lLWZpeGVkLXNpemUtc3Jj Lmh0bWwiIG9ubG9hZD0icnVuVGVzdCgpIiBzdHlsZT0iaGVpZ2h0OjE1MHB4OyBwYWRkaW5nOiAw cHg7Ij48L2lmcmFtZT4KKzxkaXYgaWQ9ImVkaXRhYmxlIiBjb250ZW50ZWRpdGFibGU9InRydWUi IGNsYXNzPSJhaGVtIiBzdHlsZT0iaGVpZ2h0OjE1MHB4OyBvdmVyZmxvdzphdXRvOyBwYWRkaW5n OiAwcHg7IG1hcmdpbjogMHB4OyI+PC9kaXY+Cis8ZGl2IGlkPSJyZXN1bHRzIj48L2Rpdj4KKzwv Ym9keT4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9lZGl0aW5nL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUtaWZyYW1lLWZpeGVkLXNpemUtc3Jj Lmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3Jlc291cmNlcy9jb250ZW50ZWRpdGFibGUtaWZy YW1lLWZpeGVkLXNpemUtc3JjLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZDJkNzZhMDliZjQ3MTdmOTIwNzdk NzI2ODgwYWUxNGQyOTY1NTQ0ZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRp bmcvcmVzb3VyY2VzL2NvbnRlbnRlZGl0YWJsZS1pZnJhbWUtZml4ZWQtc2l6ZS1zcmMuaHRtbApA QCAtMCwwICsxLDYgQEAKKzxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+CisgIC5haGVtIHsgZm9udDog MjBweCBBaGVtOyB9Cis8L3N0eWxlPgorPGJvZHkgYmdjb2xvcj0ibGlnaHR5ZWxsb3ciIGNvbnRl bnRlZGl0YWJsZSBjbGFzcz0iYWhlbSIgc3R5bGU9InBhZGRpbmc6IDBweDsgbWFyZ2luOiAwcHg7 Ij4KKworPC9ib2R5PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL3BsYXRmb3JtL21hYy9lZGl0aW5nL3NlbGVjdGlvbi8yNTIyOC1leHBlY3RlZC5j aGVja3N1bSBiL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9lZGl0aW5nL3NlbGVjdGlvbi8yNTIy OC1leHBlY3RlZC5jaGVja3N1bQppbmRleCAzMjU1MGYwNDE5OTFjYWQxNDYxZTAxN2EyN2NkYzIx MTlmZmIxZDg0Li42NjA0NGQ0Y2ViNWRkYjNlYWEzYzgwNjRkMWUzOWNjNzliMjU2YjE2IDEwMDY0 NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvZWRpdGluZy9zZWxlY3Rpb24vMjUyMjgt ZXhwZWN0ZWQuY2hlY2tzdW0KKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL2VkaXRpbmcv c2VsZWN0aW9uLzI1MjI4LWV4cGVjdGVkLmNoZWNrc3VtCkBAIC0xICsxIEBACi1kNGFkMzYzZTU5 ZDIyNjU4OGFkNGNmZjhhMWEzNTQ5ZApcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKKzg4NTU0 NWI2MTU3MzEwZmFhYTI4ZGVjMjZkNTYwNzZjClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL2VkaXRpbmcvc2VsZWN0aW9uLzI1 MjI4LWV4cGVjdGVkLnBuZyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9lZGl0aW5nL3NlbGVj dGlvbi8yNTIyOC1leHBlY3RlZC5wbmcKaW5kZXggM2EyY2MyZTAzNzBjYTkwNTAxNGJlMGYxOGIy MTY5OGY5NjNhNzZkMy4uYWQ1NzZhN2FjYzcyNGM0MjE0YzQ5MTU5OGRhMGJjOTFiNDg5ZTczZiAx MDA2NDQKR0lUIGJpbmFyeSBwYXRjaApsaXRlcmFsIDE1MTg4CnpjbWVIdWNUYGhaKkxNPDdhZ1oo YEIxckBVMXE0Slg0a2J9a2EwRWQ/bHAtKklqYjQtJUFpK1ghM0pPd241RGBJfAp6RyUxMGhXMSZi M2dicz10TGEjfGstZkoxfW8jJFFhbzMrMDZ6VGJNRF8zPEM7YUx6dF58TXFZMXYtaTB0cEB5ZSoK enhQSUNCM2soTTFJO25mP0VEWGttaFFTYVFJNXE8I2lKbXVJZmRUYnYrUy1PRXdZQVpQP2s8PEZJ Yk1Sbnl5MTdeCnpQRj9MWCsjYlk9Km10dyY9Q2ZqPHhSSW1iTVNIWmAhd2t2U2loSig1P1Z6YGRI eWByMnZReil5ZnJsY2Y1WnhtSwp6WWk0MWhzRX19KHY3X2FOdHtJJG5rNVV9WXUpQWY1aGE2UXMr c0tsbD5kQlpXTlVwaUo7QGM9ZXV5Wl57UU1TaHEKelMoOTJUVDVfTHhld3JuZWNxN2d8SkVCfjZI ZlhYKW54RjNmKUlAN0M/e2xmKWxTX3BzOF5lfnc1PnxfeG1leDsyCnorc3NmPm11YWJNRyM/amJj PnpTJjJ9K25fanJrcykmNlZmcFRQa0JTS1plLVo/ITdPaUs1P1F7eTYqX19oLUQoegp6b09NV04/ TG9xRzY/XnhmYWkhQ0NuX2d2SHdZJjg4T3Jkazhldi14Pj5iMTVWUGxNSl4xVD5xckh7T3Fpemk9 UU4KelNDQjElXlgjYk4lclViblEwe2B1KGdPP2ozekZOT1V7RCNKMTgqR3JyaDwqMHJ7e2R1JlJY PSkld09IOT11dkQ7Cnp5T0N8MmAwQ3hSb2JpWDN3aCNQfmNqQD1udmdsezNxPDU8PWhze0U2clRV JVliZEJ8eHZPPzYkIStKM1lRNiVnUQp6aVk7e0txYnBtKUM7T2FUS1EhIVgtU255WGFPVEI+PlQk Zyk2cUBJWTZkbDxqWFl5NiZ1Q29zXio1bk81P25uPigKenB7cl8zbDV1VGlubDw4el5LbUAkRWxs eXIrb2lZJV93UWJSOXtjanhLe0Q7MFApYkVoPE9FS3shJDk+X1Y2U29HCnpWNWV3KVZhSHBxNzR9 YDlVJXBVbEo4bXoyVzcoUGtkcElaOS1KPGhCTG8oWEM7Zy1APDd0RGtIY3l3PVBzenokfgp6TiZX cFJCYEczYk1uejdWPFEmdSVuPT1pZDNmKXRoYFBGX30/RSZsRSVhVWV+VHx0fVIweEJ+cWhhQH1o PmBmZjAKekluRktPdDAkdnBtU05SeVV0MmQ8RXdmK3BiJW1UdmBScWZTNzlEcmBRTyUlSTBPfTk3 aChpd351Rn0ta2xiOSF9Cnp2eFltV0V3ZEMzOEVaJlBwWHVDRCV9ODsoYmxFZ0FMYlBrfF8/eUk9 dERDYyhHSkI2Yz09dDY5aD1IWilAYitBSgp6VGRPUHUrQFhpczc3KyUpPD1ZP1k+Rj09OT1xc0tn Plh4aVpHNWtGR2djNmEoM2F3Z00qJVE5JFFEUDVzMF5DJEEKenhFeHE3diNzQTNYM3RKVSM+aV9w SmtDOSpubCklMlVlMTxTZSMqKG55ISRrZllQPUhmd2RpZ2xiLUtfd3pCYGsyCnpFMyRMWjxhRGBg SVhnPXotfmRENiMjWnlQcjtsNmtTOEx5MChtUztwSEx7SEkocF4odmFLWX5nYWB+TjdTQkpzUwp6 dSM/QSo3PDxGMWdUdjdsUn58fndtUjExVHI7cksrPUlnZUYrRnBud0N+ZXl1ZDYhcD9VeWdzRVcp blp9K1U4S3YKenZYTE5zQVBYa3g5OC0xeFFMaTZrcU1wOShrP0hucGFXeWh+TyZ7bkJBJTFVK3dL XlRMUDxPNE9WdnckTmU7NEptCnpYVlk4Vl8ya1BSe2VGfF9IT2hSUlRIMlohV3N2NVE7ISFURkxl RkBgaV5kWFFhMEVMQ0BQfkNnZCUoKVRvbl5ifgp6TXlrNHQ9ezBIRVFjNVdAKn5AQW08M1ExRmEy fXlYZDZOKD05bnF7RHMtZ1JISEtFNCY3WT1rcVIrakomYWJOJF8KenlQWCVDK2NKTFNgdiV8VWRL ekoyZWZzKVVVdzhibXhhPXRiPUJ8KEE7cn1eOyZRQyVobnd7O3g5RVpxUC1vemZgCnpGeis0bm0l YXA4OzI8RjEpNXU1eEIwcU5AbnFVI3pibkJaKi0mYW9vQChZc15lZmRFN3VLSUJKTTR8PiNALUgw Iwp6XkhsLSlnSSEoVzVjdiooTnhjKHVYb3lKX2ZjJllhUGMwJHhFZFl+Vk5rd25qM1l0VSQ8bEN0 I0ZOdVRsTS1sOygKemx6c2pRR005YiV1VV9AQiRDT1VZZnJgS3A3NWptME9QJlFsd3luJHt6fiZ6 dUxWe0xkdHhMYiFBay1aVkUpNlVOCnpGZERrbyRPYyhDUlJSRCl7KH1ZcVdjQzR8byV3cmo1TmBs b0FwbCktVis7Z2MmK1huSEE2e1hJI2ZWK2ZnSlJkYQp6RFMkO0U9MHNRSUtIbSlpT1p9SUQwNkc9 WDlIa0AkYnVJPHJIUk97Q0UyS1ElMl5+KGFzamE7VURAPjBGaDNGY2AKenZBWH1sb301SkojOF5R NipzeURWbzVnfHQ1MTRkdVdVQjlfS0NDWnlPYmRlMjkpenJ7RUo4T2w9UEFTQGkjQElyCnomM3kw KTg5QE9ec08lTVI8dURPPihGbUY3RDlucDMyYEA3TUolQGNyZlNvOyZlRV9scjhRPXZ+ZHxDa0hp bE8qeQp6eUVmMF50eVJaTmozNXJxPHlYNyRCQFg2KEtXcjt4a0dRUkI/QVp8fXd2ZFM+b0UmS0tA ZDBVJjtFKGpNdXpsJj4KejJAdmo0MGFBSkx0dn5gfXVLK0xoXjtLbWxhRzctbDtMVkhte3QoJSgr MVg+MSVweEpuTmIrY2NxcCh7Vk03OXpmCnp7XldtMkJ7WmtUVClsdWt0VlBgWlooNm1jVkg1filw WThRUHRaUmU8MSpBYE5wdntqQkt2THUqeV4qSSQmaXZUZAp6KlApaDwkaU9FRjdSUE42NVhZUURB YXc4TjVGdUR3PjtWJGt6dTY+NUtKVjRoOzNRYiNvcTkwe0JHMV9gemtDUWcKemRuYTF+VnYrZiMp MlNOITIjJE4pcGpxZlFjKEM9a0ZKSlZiJGlkLXVvV2JmNCh+V18yZCV4VGwhcVdXWHotZHVDCnok XzxmITRzb1M1Kl5TPjxGYypyTnFvQTVVdHE0fGx6Z2BvZnB2PE9TSF92NWR0M3NCVzFLaXJiWVpe P3xYaFJeUQp6OH49fX1ie313Tk0oejtBQjFiK1RJOTwhTUw5Pyt5KTt7fXBtQ20hYnJmTzBZOSRS JTdMZS1NVkZEdyklI1FveE0KejhlQ2w/NyR+Nj0jZXFKNVhnZyQ9SThMPUtQbSlQNiRqfitmcThV QjwwMV98bUspbjNab1U/KCFOWjttQHBFN0NfCnpBeD5+VEtHS3pDZ2xIRHorNWBkZTFBX1pjOEVG LTgyUlB5dTBqOHV8d2ctJnVNOzFVemAxaFcoZCR4dis9TWNRVQp6NVkoRGJ2bHFkbXdmWUZBNmpw UXVsNjxkRHd4JFNSPCtlYXpqKnhJMnRLU05AK2h2filhaD5iMXxIQFhoNUYzUHYKemplS2dKUXdj Qzc/JjMyTGk1JjNpTz5mK3hKNntGLWNDfjlXcTs5fiUzYnNMSEQ8JVJVPzxAfDROYTRsR0t+TUp4 CnpES3NKQ2djQk9GSjNIP2lzR3Jnfns4bFE0bW1JdXg/eTdKPVR1TUQ8TVl7KkhJU2lmPlNaZlUr YTNpbGNOcktYMQp6ZmRmYVhuZ2EmVFFjTU1PTi1lJCU+WkU2aGcqe301IXl3R3sxfXlYTElSUlJ4 PW1VcV8mNCZhMTx4ZkR6d3tvRHoKek8rYGIwRHFBeEY5OSU2NTJwQXxqTEstbWRLVGVeam52N0hO aTc9JW9zUT5qV04wTnBhUGhtPUg4TCohdyF2Z1FKCno2UFpoU29NO0pDKElDak17ME9nSEkyX2B4 Yk81ZE5Hb201ajk1fXBRPkhqXk97eHtVbkdhdERsWTxVJllUb2UhWQp6MEJhbFRMeEQ1P0dkTGhk YFhNbyo9b1htOW4yPCZeKlQ9KE97JXZ3KlQ3VmYkTTR5Y1BOaWxYUWBUWCo3OEdAZGwKemgkMDt2 SnQ2UXRKYCtuSWspPnhiNX5WJjN1JHtPcTBhQmwmWn1wcUBORTUpRz12M2tUPjVqbHFQUVVyc3dD KD9XCnp2WWViODtIUFc8Q3FIPjMhcEZIVEwxSyprRE55an1gRU9OWkt+d3xeYDRqYWorcmNmZmZF dnVtM2hAPkw0KUZvOwp6IWRKaXJfRCRBYmZWa181aGI9JkdJUj1OQDlkcHpNJW0wTE9BYl4rbClH KXhUenZCIVJDYztOSDFvd1hgSCM9TCQKekxxR00mJFApSGU5bytLM3JtdDBpbDJsbSU3XkhmcEJO SHZMaH5fdzkqYUNRYlN2dnYrUHtlKmA0S1UmYmZGNDdOCnpGYDlHKDlJXiRodkpEcG50QjBEfmZL Z2xWdEN2JUxHUUIzQGRsZilTNy1AdUxsdUxufm5GZ0hiZV5JYWlyfjtIcgp6JUh8O0lUPiNTNFlf TGxZU1lrIzE0YzdtUlk5cyh+KHBhTyEmcD1mQzlsKk81TUtsR0FXa3NMXlF+Sjl+I3ZAR24KeiV1 ME5fR181Ym0yfUMyRSh7SzRAbmpyU1hjfnZ4c2BCcUxmYzg3bHlgRU98RHpvQU9UQll8NnhLJkNs e0BwfW9ACnpyYEM+dlRUcCg2RmNIeH5aJTdRdHhLMGxvaFRBPHk1IWIqVE16TiRPUjZ2P05ybDJF ST1qVnhNe1QjNn09Iz5Vagp6PmdFfnRnVCQ1ajImdXBwVjh8eVpMb05ZQGZXenhGcTdRXjNnI2Jt QSUwP2xxSDNlOFpwWG85TFZYWWolK0hLQmkKekFZWTd0Zk9eWEtvYTYtI05kTiZRYVo1QWBqR2ow a3AhVlR1QTBZd040NndGJkJuWk9WTzh7JkNRS2ZTdXFyb1U9CnpNNilyKmUqcHJYVTB8UTE2ZH1T OXMjJmF7biRQP2Jte09tP2EwR300aTQ3PClzUE9YTHBpejN+MDZWYCh5QVoqbAp6c1goQWYtMH4/ MXltTEBJMmRNV3Z0ckZebiFrVUsldU8jMnJEdHJZKyYxN1dwYjA/ek40JiMzaWw4U2lQY2lrLWgK ekN5RHU2MDkyNVZNREt5bjgzV0t8MTxaZDswKjg8czlCM1REU3I8Z3lORHkhV3R0SDY/OUZwSzwl KlIoUjB5VVM0Cno+TWsmbFRZbUFJeUBkaSE0Zl5MS0gqaHUlSjtJeCNpQioqWlhKIUctazx0M1pK RnVBdilhMiNHRjJlPzZwIUBgbQp6amlwJUNWUV4+fTMkIyNkKlJ7YjVsIVdJMXYkX3EyQWdsenUw SnIwNT1RO19jP15tei17TjFaeCtYSXlOdUQkX1IKemEwNGs+KkRxY0I7QzYqK0w9bGpfMENlMWNf V3hoKGRrP3xNPjc+I2txU15ePSE0YkRyUEdOc1pNI0NLK1I9aipwCnpEYz05SGpZQXR6cjViMyoz bW18OSsmVTNLenJzblN2QXkoa1d0fXlATldSKigycktseFcqYiRJLT4xLU5jYzIjewp6KTBtXnV2 bWlLWEw2e3VkYn0/Yk5hZWRUPT1VO2xKaSttKUV4dWZkRT5IKnd+cUJffCgpYjglMzYxVE87Yj51 USgKej5YIW0zaCV+I3ZyTzA9bFp0TD9KZWlqelBqdC0qbmxSVFZnKTAxRk81VV5QVXQyKj03KkB1 NVI2XjtOeHhAOU55CnptZjwmbVV1UH1mZno7OyhCMiV9PTVSNGVLcCR3VzNIKlhKO25TY2Q/ekF6 fjlDbmFIbFhNdGBuP3p7KWNEMFUjNwp6Kyo5cz9YZERMK0R4KHRHPSowa2c9UjV9VTh1cFBmKDcl MT9QS0YydTV7QDAwR1FAJW1LKXJvPUEwZE02O0JaTlkKelhBbGVhMF4jdFJrMXxMT0VFLTVqcnJM a1UyNmxEPjhsY2hKZmFYVUkrRjtGSjlyaXsqe2tRPHgkVGRJR1l+ViYzCnp7KGlKPW9LU3lOWSNX RjdrQjBqe3NJRDFKSlNQdT4yeyhVejMtRGUwanE+bFdlc2BsWHsre2NCdTNAN3h7c3pUSAp6V3hQ PXRaP3V8VW59VXQ8QDVjcWlNKXxpPHsldUBxZU08QGR6dWZxfXF8YTFXenF8YWhxXlBMdEw0NXBW dzNELVEKek5rYzx9PWkyLVNwJkooUjd0NmEkJlkjY0kzIWtoMlpWaUNYSTJUbSslZ01kJUg5eTFD VFFENV97VlFPTikkXkxoCnojenNIVWZLP3c2R09mO1lKd0ZsXiVAek1VNGx+Xn16USZ3UTkka0ps bmQocUY7UXEjUzx2SUQyc09eVjB2akpuQwp6e3tCXyhkVXxeTFFAbi1fcXZWYnItP3BSSStmOEcl P0BGM2V2PDl0ZHh0Y2xiUEcyJmpfaFRAczR0Vz5EOT0jWFUKelFUWkklfDhDMnxqPDQ2ZVFASiVD aD1yanlPcyFOZVYkMj05Y0QqN0V2MDhoeUptO352cmhAeHhAek1wZ1opSDBOCnp7bl5VRGVWekBo d2d9djxTbnVTPlhqMVdhWS0oRVA2cVlhUXdaY35vMHVMKnhwRX1hZGRuKG5weSZjezhDdDd9dgp6 djcxb1ktUFlBPmlGK35WT0w/SmdRJUBQY0ZeOE98KiFvKTcmfEw2enZQIXRCZCskWkJjVSNeVlJD Pj9aOzNuP3MKel55Njg8Tz1KdlhNdz1RTUA4VjQ3blJZP1pUdlNWT1FDN3B3N2tvVDtiWTBaSzE2 NjI0X2xXUnotdnFPU0RtU3VACnphfXVZMmpxWHxoXzdDMUlqaERCQ2lWUiVrRUk4N1VjYzcyNVcq V2Q/Xjw3JnB4Yz1HUWRgMzNyTFU0e3s8cDZVQQp6VyN6PExaMDRsMDctTEp6cE4jVH42YXBPNlEp byUpUFF5aDExd20oZ0JJbWNIbylDdzE5TmBnTmF9eVAleGtkOHcKeiRDdnFrJDska1FrKH5oP3ZV WX1AJkNycD5sUEM2K3RNc3R3d29YZyQoS3xrI0pFbk9gVUFpVFpDfWpBYDsjanlzCnppSypsdHkx JmxWO2s/PVN2e0w9JVRiNSgtZW94bGRaRlJecUA8PDB4KXdjZCUleW59KnNWYlFLbndmJDgpd2gl eAp6cjBTY1ZzQGMhNXlWbnFLO1RVXk4wUXBNQnstcX0yXyVaVnFxQG9TbUFEQkZ5YF4/JF5AQUs4 MkZMbCNPYHM5fnQKekRZeCNWZVEwOChRN09AISF0ezdTZT0mWWEkWkVoeEZ8Uz5ZeUBTXnV0dyoh Z3VIJld7I0dVfT1RRj1Ee0piN0BZCnp7NHNVNzhjKT1zNzxoYnRGJk43aSFiSy1GTT58WnQzISVH LWw5JWgwUGlMKyE8PjNkTiVTTUFkOExNK145YzxiKQp6QS0hQm5ZMS1qTk48cDB9JW1JJkpxTUs7 RUhfdShva0hPWHJEWFZ7cXV7RFdDKSNVfihXbV5eRmVmPGo3b3ZDNkAKems2SFBjPnNQSFIpKjMm b0B2Sk5uMSRqamd7d2xhZkE8c0pjODwzSztyIV5XXjx5dmpiZVVWNHtaU1hlOV44ODA2CnpRcE5K OXMreFo2P35oVisydXBOTSVlSj1wYWFMT3RDQXlnVExFcXxsckh7YHpYTHgkPjEyVUlScDJPc29R YDc+Pwp6VT5CMSk4c0NxOU1mdjErWFZ2QjZLNW50V1p7TTImUylVTnZ1dSRARHpqfilCeU82WVNI KGU5PDtEeVB5KHFZQyYKelJWc349PVRiVzhOeHJXQEVlVmNSYkVHdDNtflFrajtjOU98e2JYWG5g cjYhKzg5YStsSigjd3BYS3JmeFlDZHQpCnokNHp2JXE+QGYwNXY1dCZadDFfJnkoU3VackYjQ2c/ MURxR181OCUwWVd3aERJdUVVbVA5Q01pbE5hKHptTlI9Kgp6PSpYQ2NrfW1CPXpvYlZxP0g0RkdN UjhLak4/c25GSX53VUNQTEx+NjxDbVJRdW5kcyFjUkkkPUgjUGFOOV8hIVYKejVVSkt0bEB7P3tK RzZKPEMxYUtLdlhlSHhSN18tRUBFY0V4QzU3KiNnYlB+Xkl0SUhXeXpBWVF3fEp2amZweTdeCnpj czUrflJiQmtQZjwoOVB6QlNAKWhURXhpOzdEeHohQiEzOVRYPk1rUiNwTFBBQX1+fD5YJXVNd1Mj a1MkTmMjQAp6NlNNd1ZMJENnXjNHbCZxU2FJeiZ3U0RGRlpQanFwYFg/Umc2JTQma3FzV2dqanY4 anBHQm9RRz9yTDclIW80ZFkKekV0eC1iQEIxXkFTPjdXVkBzez9KND1eTld3VzRhViE8QmhrVipK LTk3VmEjISQ3JllLPCpzT0ZpdzlLbFheY0kzCnpQVEN2ZHAmPiorakN3PSZlUSFAJD1nbVE0WCpZ VlJHYzNOMCtXQStfYURWQjJxblhUcFZwbjt3UTBMSVYhTGNRVgp6OUVRbnF3OEFHX01KZ1pqSks1 blNZaF5+RU0zT2lRaHVFNmslfGl5V3tlPjUqRD9PaHpKV2VtKjdRcDczTyh1UTIKeiRZOFo+M1dE KkVxSTJzYGVrI3lNXj9HWHIyJChQO0JBbDQzd2Elb0UpempzYWtEWTFXVzEtNl9HayUjM1JNK00l CnpTTUhNXiEhNmJJcWtFSXB5Pms2Mj1FTD9wOG5ha0JAWSFAPVhub3FONGNBfjlPPXt1OG5UWEB3 aiZhcGJLaCV7aAp6MioyI0A7ZjgxM2NwKXwme0E+TUNiYjJzJWtAdX1QbnRFPzl1TiZxZDQrI207 aGEjOSNIMTFUU3EpTEJJV345R0EKeiZOQHB2bCs7JHhSb3hvVio9OT5+QTY1KHpJTjN7ST0lSF99 e30yIWZiSERaaW1EIVU8e2Npbks4UG9kKGV6ZkMhCnpWdj93KS09ZX49Snc1VXpyP1RAKCFgRWx1 LU1MZmo+RXJhTz5peD5JI0BDOEhSdDNvTDgtTH1vdW9fPE1tPHBvVgp6SEtCYEYoeCVAdiM2OV5J LSleKSNBSUJJaSs9fXNzS2I8Xkc0NU8/fnJkOFhVdV92VEZaNHdUd2BfUTMtYTxaY0wKel94N0pC JmZpfVM8bmdtYzYyX3t3T3tUUHN5KnRKczt5ZlBObG9YfXZOdHMkSkBmJiZJYEtqRVcrV3NkSlly PFdeCnpNeUdxdzdzZEBrazxXYlYpS0MrVm5tZ2FEQ3VEek0tb2grPHpQK1dCQy1MbTxrakEweERe Ykx8P1JvM1VackJFbQp6N3o7Qk9oYV5qc3NLR1orVFUwU0dPazNTdndEUmljUnJiSHJ6ZTJEbUZD JkA2KC1tNFRSSkhkP0NwbDVlTylLVyEKenp3eWBmQEZwUyF1dEQ5YD0zZyZqNlQrfkwxNUdNXjdQ YjwyKCF2M35YaWFoTDlpYmtGWXstfllmJXBYR0M9YjRACnppdDZPejBLREQzaEZgNWllZTRgaEJp UjxOXlhDbS1eSlVKQHRqPio3ZnpSfmtta0hadV9CVGVQYnVNVjRKMHZaKQp6bShKWipKMkMtMHJu WXhjVXVwODN0RXBQPiZAd1N1RjRiT0YlKDtJe2M3Mk9LIyZ+WmxIM2FzNF8jRXFPVlZkI0sKenQm YFFMVWJVXjcjQ0s4WTVAWThWPChEdmB7SzJrRzk9LUleMlhsLXlyYHolR09ma3V8S1RheTJeI1cz eHJ1aTQ/Cno2c01kT048WHVOTXN1Jm8/X2NSKHVHMlZBY2FFV08lTjM3dkR5JUchaDY0NXd3I2p4 QXBaXkdNKjVeJEBrTkMpUQp6YiF8MWpvQjZlZi1FYlVrdko2YGwqYWMqfiR3cjU8YEpva0pzc0Zn PkBLcD9KdCZQa1JGbmRjQE41YHAyKVlITi0KejRRVlFWK0w9YD1PbDtTcGJ3cyFGdSErKXxSX0M8 RjQkc2tpVT1Ne3xraXNnSnA8WSMjaSZUO1RpX31WN3k8a3JLCnp0V0N1Wnw1fjBLOURTYzYhQnh5 MFEoZC1zWXcheWRyen4hfkREbCNhNW45VjN5PyFXVyY1ZikldX5AYStDN0Z7Uwp6ciVCX0VVS0Al SW5DTkQ+aExJJXJ0M05iP1hTNHxBOSs1dihWU2YpQHEzblgkd0NwM00mVFNSPjdiVG87VVY3RiEK ekw+RV9BUVJXJVAkfTVqanZxZ28hLU1BfT8xZGB0SCNnajxVVDxmRyYpWGA+dTxnVkdjbld+bDd5 RCF2djFvaFRhCnpHcXNrb21oVk9iMmt2WXpYMjh1ckM7MlYwNkIlUUdyKiU+bihwVV9RK3NCND9g eURGQEEtV304emE4VDx5QFJgSQp6WEgtZypEJDwxcEpUI2B4SEtBTjZjPCgxS1FtTjg3PGEqdSRX KE8oU0ZDalNFYmEtPSFZZShCQUR4USQ8dlNYMVEKenp8SD1ZPUI0QHx5SjdoSW03OXdXKWZZcF4j UGdFMWplJCZXT2x8Z3lyRl85YU5makJ8dSppYU16eWxOdT9gZVR3CnpKWGUxb1JAbFIpWW40JHsr fDNNXnc7N3h0TlQ9cXh0b0FPZWRSMXFOOWRAQFB4YCF7dHwwcVo5ZUp3fVNgRH09YAp6PE1eYDND WXZATCM/QiNnPVR7azN6KVFyV1Y4V1dmNUpOaWtWNU84KUwpSCRmXilLZzNeK1okZ3RGeG9CQFhI QjgKenJGOUdHeXtANllXIXlMe2E4ZSZQK25LOXY3TipMSndePGlSVFJtbkB1YyZxfig0PEBBPTdi SDNQdEI8SHNoc3dFCnpIMFZ3NERDdWZEWGN+QFRiU05BK0o9SXE+Jn5+TS03cipSTVVtRTk2P0Rk QHVzb34kdV9uWGM1P3oycXwlbUdxWgp6aGA/X08laCU/JVleX1REUip8SWlwd3w1cylfaVM9c2g9 cSs3fGpKNmRnbHlYU2klNilHeVJJV3Z8TmZgcFowN0wKel5SaWcwOGg4NjY8dTYtbl42I1F7Tzlw VF5IWm9uNmUwVFdAUiRJdUZ0UEhjNUR7WGtlOEViKk9hNE01cFN+c3BmCnoqb2NoNXRYIzYxN1FS dUx3KiZLfkVUdGhTKytpRUN2fkNhNXVNSWJKNVFUMXl6fkdpMERgd2o7JlhYdXMwRkt6IQp6K14m fEhGPFJebEpQazExJjVOQGlGUCMmc219flQkJUMpN2cmZih9dy1XM0pJKGYzRjV3WCUxWjgrQGJO WWBoRkYKemBHWj8lK08ye0RSSkVaQEV9enl8c1l3R2V2U05tYUJXe3RiWkNRU2tmM2UhMWM2dyE4 QlJhKSpZSHtGYFhzQD97Cnp3cCFTVlREVm4lQVU7QThwYChAUjtDK1BROFhiRjFvS1UkczdRWE4+ NmRwN1l5T0tDe0RGNXJ2aCk3KDR0QSFGaAp6c3MkOTRxcT5aX0NuVDwydmI2fitJb0d7eDx1dCF0 Tll+JmMxNCg2VnFCSjEzZVl9Q3B0O087WSFEIW5pO1pAflgKaXNhb1ZaOWxLfjImK3tUUHY7NDRi R1ZwNnoqdmFGa2tMNGI8eldIQitURVlfbQoKbGl0ZXJhbCA0Njc4OQp6Y21acz9ieVFuVCohRWlr aW5sPH5QQG9oaj9nVVM8UW9JRiV5U29MSyhCYyM9N0Y+KEZJfX4/ISpXbTYxYF9rd0EKei1nVllG Pi1AVkhpQGheKiZDRVViQDRBQSYkeEM4bWtZWVQwXzYlRjx0R01FYFhEPXpBSiRzP3s4V3M1QChi PmxpCnpgOVEjMk96Zk1LbT5BX1oyVWA8IUU4fU8rVCVZXkwkZTJ4akJNNWozclQzfXckKlUlZVNy cllicTdmZWJePS1rdAp6ZGl1OUxAIWpaJFVNYDMhc1Q/UEowdHJSWFNDUGVBamJDSUdLX0x3NXE3 QzJkdk4zOyk/cHVDO1d1Tl5hTkVFMnAKentYfX54JWI+I2dAeiFEM2R0XlcwODVtYjcrKSNvYFor NXRgdU8hY1Q9ajJDPz5rRHc2MnpRLWd6OytjSy1rbiNECnppdHUqblp0YkB9I3VaWkN6Yj90K1o+ cD4+QTdtbTdqYHZmcTVVSUJhSChQRU57MT9Cej9Fa1gqdDRWezQrTjY1Ywp6KkEkKCo2PVk9aURW QTFYXkdodz1vSmZtXlA5cFpIVWVIODQ9Wl52JjN4fExXNHRYUCNgZk17SjxIN0cwSG8wPDEKemY7 NU5iQmc4b1k0X34wWT5aOUdVNXptVillQEwpMCk7en4wWnBKTHEmQEpibGU5bjBIdnorPGUhcEkq R01ZaStlCnpmWXNiVnBpKTZyKFhMcWoxd15ScWhMakNidCZESWdSOEZpUDB1KmZ8NyF4ZEptS3k4 I0dnOVVPWE5QWTNfJXdvaQp6USQ0fCRjRn5Ybi00fnJLJnReYWAkbGdDMnBtLVRmbnJAMnJWU0NR VDQmRnNTakl6X3FtI2ZWdzVIcktHazhtemQKemt6fW0wU3VuR2lSRSoyTVdsQDBtKD1CRngxc2N2 VypiUDV3YmJDfm5kRWxQKUokfjVzdE0hUEJ7cTB4flRgQTdGCnpmUVRZWVkzdkt6XmROeUswUEJD d0QwZVNTa2Q7LTg0WjIqdjBfO3s2Xk52Vlpkfm13YnlNTEImYGZqUkU1LSN7TAp6IW5Nbm5CZ1lt TEh4SHdubk1mNSg0VXYqI3pPRzNqKjteeCNRWXFwVEJSXkcjOXVoYHo5UD9Xb0B5MHozUm8zKUUK ejAwQWheQHArRFV4SVR7Z2VAYX5hRH1oN2VGM1RYUmsqenl3KGNXPnwlRTBgd3ptYldkO1V2TEJf fDhLPHtxR1Y3CnpscEBuVWxxLShmMz9jQjReIVRNVWVgVHl5QyFkdXxTJjtoWmB2aF84ZVR1IVlp RiNObCsycDU8ZmtkQWgpSSNncgp6OFBUfERlSHtANjlyWUUwNSo5PDxke3omeDFUbjJwZ30/QGEz fFRwMUJmK2BxZ087eH5IPztTamtVN0d7X3RtViEKeiF1ZkBwP3BmakYyfU13UTl4Wklrcl4tVVRA cnVIZSY5RiFvTENjSTFGZmYwfkJCYkdFVnVPc2VsSUUwciVjMWYkCnolO215Q2c7dWA4MX4hI0Q+ bC0kNHAoNVlGcTUwfkc1WHllZj5WJlJZbXleLXdaUHE/eUVHdSZweklzTEJeN1dTVwp6OXthaWZK OFZ4RzBmQUBGRDQkNyppenZIM0tTKTdxR0xpVmJiR01Be01AMl9OcFo9aUBFdlNKKCNPRjF9bSZ9 U14KenVnfEUxVSpvO1BpdWZlKklqUmlmXzNQSVNNejNESVJhPD50NSNrcSU8ckFgcyNuZkFaWFBU cT9WM3tMfjtLXitxCnp4b3VBbyp4MD9odnE9K1AoJD59bkZYZjZrVH1ERU5MLTAkVG17Qndec3RD O0pNLXxodktnO30jZC0zblY7MX5maAp6c1k4VV5XMjEqPnpzd1EpWkw/dnArWS1pRWh3VkJgXk0m RnlWIXlPZWY+NkQpYFRsR0dBXjVSdUpKckptWHVtRUYKeilOZy12ZEZaeFNYS3lvS1d1RUJsOFNP SilfNWJeWkRndDU8dzhgVWNWZFdASjd3UUhTNmc8JUpJT00qclpHOU1PCnp6OElHd0hDYm4kKFNr VjlRdD4+JHk8MiVZM1BfNT9PQEYlN2VUcDRDVFh9anxJcj1VNlVhQzYrOSVQIzgqOE9sKgp6K3Yr cHxkYi1jY0xmM3d9LXYmanYqQW9RMlMoUj5ANjNAQ2hYNyM9dWMmKCU2c3hvZnpaSGpkJjgwPTQl PmlSK2IKelVkX1UjSkN+cnNQO09ZZE5AMj1TckFndEdCJDFqckxuZ2JMdExVQFAmOGpiPCloNmhB NW57NzluT31WLWMpSjtHCnpFM01rRWB6ejQmPjh8eGo7MDRQdT5SUHU/KThvan5lRlBgSjs8Mmla VGViPlYqWHQ1fHtxKHI8UjJXKyRsXkpFbAp6e1N6RDtYR150VzImcjY4dk5CZV5XIUspWTFFLTJL bFBOIU9DcHdZdC1AaGp+Y0NobzxPQHI4PnozdVZ5Mn1UM2EKemxBVnUkVDBRblBTTX5fQzlsdEw8 PSVNLVgobFY/bW9jfG4rbDQwMnV6T0Vtc1haNn5aMzVPbEtfNlJKM3AzWHN5CnpWWmRjSVE8bSp5 TmNpMjFfaypoM2IhRk5FbFh+RT4qUmhBcWA0Q1d7SjdPdmJVIUojMyt3LSgqVWNJIVVwQ1A7KAp6 c0J4NEZkZFRQNGdTRm5uJkVDej9aK0Rafkk8YEp1bVJnP0hNNFFMRnpnbjtiXiNsJEIpK25CQ2RN Wk96MHdofT4KekBTYSVmSH1QdGJeVkdOekYySklHZmdETnA3MTJOWTdnWUtQNWZJRF92fiFsITkm dms1QHBNV040JjZaTiNVPF9XCnpCNm8/WF4rcDJkZz5YYjYlZiVpKkpSRXg7RkpIR0AqUWRCRl5M Yzd9d2pscjZxOWgzTXo0b0FEcGd7SmhkUGIrQQp6fERCMjhVUzFZcDtyTDJtQyo3QlNFYy10RFg2 NTA/PCFFOCR2OEhqYXBsfnEpZE89PExhSjMqbiVnOVVFZUl0SzQKekY9WE5QRnA+ODdYSnpkcnVI ZCkqIyUxXllkUipfRGotI1ctVi19VjNmQk5BKnEtXlFvbmA4Sjhfd30jZSMoQ09QCnoofUpFYV9U cCZ8I2ohamVvWnp9bzBYbEE3dy0jViVBXlVjTTg7N217NyYrcysqWkwoKHpBfHhUTSNyUTA/eHFK Kwp6QC1SdGlTK3YlSW0/fn0xY0FrQFhwdHhUfSVpPjIzXzBMKig8T3xAYCg1RUZIQnI2JkxybiUl bXhrbSlnXlEyWWsKekBZXnx1MlFYZjRmMVY2cGopUjNTYDgqOz0jVUZIN0hObk4/My1Qe0wzdl5q dU1ebCUodHteMzlXZUc0UUpUN2ZJCno+bztpN14wQ3FILUhYWntLM2h7YyE0PG1yUnVjY1N2KElX d0NSZ0NpRVBaLXpzKFMoS3hmZmtTPVIkbW9lY2o3RQp6VC07MkI5cHNsRDt7MEl+V0hnJStHNVU7 fiYwcE1qKUJ1ZVR5ODBVVHpQM14xajVnUiQrfE5Ad28zVCV3VklfU1QKeklkZ2RxalglbEcpZF8+ ezRJX2tkKG8/O3opTEY/fXU0YkJvQ2M1RU4zTEpHSXheeHxeTygjQXA3S08kNCNrST9PCnojX3lK JlA2OSFqdExkUUNBMjBkY2owVG5sS0UkPE5GTTl+STY2dHo9LTtsWUxJZXFwIXhES1loQyt+SzUr fWE5NQp6eDIzemsqQCpCVTVxQ3RLJCYySVNSeDBYJSZKI3ZINFBrcT1lNkxgZVRgTy1eeFVEYy1U UkRyWHtnWXxnOGdVbUwKeldpXkU9JGVBSV9eZE80S3l4RHBoWDZyaHFQV0ptQCktZDlkdjd+TjIk ZmZ6IWRWfUxqI3ZEdCk1dm9iODh8c3VkCnpjZC0oRkxwV2AjU1ZLNE88M2o2MCh2fCsmP0VZRkgj WkAkfCsmR2tKUCspI1U/cnl1fUI+TTRndGszJjtYOEYxWgp6YmN2dndxRmJFUWMzRTxvVSpVfDRP S319PihkJjwpZTtrdmZ4VTdIX0xTQWVVVXl5fnEtUlRqUjg8Xk5HI0YlYyEKeldHJitTVUVyUGVh QTNPUnYydiNxV15tXj5DKVluRGFOSCElLXZwRzlAbjYwZSk9NmpXP25mKGhsaGI8NWlBRjd9Cnpp dF9ZdCluMHhNb3Mhe2lFSEtoOyNyR2pQa0s1NkIjbHxVO1V4RkhWYytXWV4ra3c9RHtGUVdWY1BN SEtqRlo5dQp6KFk/bSZnJWhFYisqV19QbTZVP2p6YFdDYlZtNE5RbFM9LXwhfUFremJNcXN4e2xz dE9MYkg0ayM2Wlh4TUpYeioKenAyX1EjVWxNMHFicWAmYHBRJDllUzFKPH5ld21pQz1XJGRvOEtQ bFQtY0B6bnlrRkFEMTwwTChvc0JxdVJaQjZACnpZJGBGbHt0NGMjcDRKIWAwPEwpNGowanlqRzhS YHc4Q0ZqTTFZI34rJmVyUyltfWBeb0t1X0NHYnRyXnRwUkBpPQp6XkQ0SEwoY3ElKTZHRjlpKWR5 NEtuXldYJSskOTg5dVh7RW9RcWs2ZCsoUlZrRmJ4V248YWlMelI3fj8tJFkqZEQKejNsWSZWUiNS PkNALUchIVg3JG1RPTdoSzY0SU9FP1doOz5xWTZQb2xiOSt1KkxjclAkJmsyeiQoZEF7T2R9PXx0 CnpfKT4rRW12cTVtZ0koVz5VJisjMFc1RSZxViZTc3Rud2dpPGprVldJPDEmMnQ+RzhVOCFNMyMt V0FOYHZFTWh5eQp6NlRzVzlfPjdsQz1MOWA9d0oofSh6Yl41dDxBeWtHb2hZYm4xb1NXZ2F5clhN PmFJYTdFTU1eKTUqd2smWjtXby0Kekp6bHBTM3R3ZDVJKm1VZjQ7R2dTa0lXUVdpVl9Cd2FWYXsh MWQ7anltZDMldXh7WXZtK01rRUB3JFNzV2hLR2kmCnpNOWM2fCEodHpHbHE/MnF0O1luQClMazZE JXtObn5rQkZKcEJPP2o5PXliP2tiKmF9LWhJfmFBcTJeQkk7NClWQAp6RjNuMzk8PnhyYWI9P3o0 RzQqcnlKS2Z9NHF3TFc+MyNlKU9vN19zYWxVPUtYenUhJTF6d2lwQDxnST5fVD1YWj4Keio7eih6 ZyF8NEpFc0BAdk9FISYlJHdpZClheSlhTCl8RXAlTT91dSNie3JrR0FFYGE8UnZaU0hDN1ktdCpS NXJCCnpnPyo/LVI+X1REeFU2X3hnQ0FPcjxKNy1RSDVOcUBmWUwkTyFqNkJWciZAOyNjP0d7fVdT PDtSUXNiKDV7VyM3OAp6dkpycDJHKDdEaFFqTHxjI0xhdV94aypqMllYI3BqQkF3MFdfbEtXX0Iy WD93Y31QNkY0X1VVfSolezcrZEN2U1UKems1dTV9JilMS2hndyMyU1VEcTlmKjlaPkwjOyFoTCMq KDZIR0JwOWJGMj19WDlKcz03V29haVB6b20ydUp6UHg4Cno/QHIocGpgIzFTRWpaMCtTTEBEdFRg dyZta0Iwbyl5KzwpfUFgKUVrNWJrNW9aMl5KT1p8Vig1YnlhQj5BdmVhTwp6VXlMTz9vdn4tSV4j ckMyMTZxTlRxbyh1V2lRdEhYRCY5UmplbHV5MXZlVERyJkQqe3slTDQ3KDdYMTdSZWV3Z2gKejE/ eVU7JCt5K092byloR2tJd2UqX14kTzteITFeNF9gfE48RTROeG41PCtoaDdFUk48bD5PdFJJOUZL YmlwTFNACnpGOXZKRmtCTk1qOEcybWl3T0ViMm9hJVJUa3tEWHleJkQ2YyQhVkRvWTEoeUxKcGZB PmpwNzNsWndfTE8pYHt1VAp6bXRESiFQUW98bVVWY2hRVm5EZWIlJlQlNSQqRj1YYz1GP0ZOWiZK RGhYeFRke3xwfDMqZTBNNTFESDs2ZFUxamYKelRFaGlyKjdiKXEzeWEoe1N7dVdsQ3I+Jko8KWdq QVFmSD1jYUVmajtkT3NQOU59REAlX3VaNj09MUBwV3ZneTd3CnpAIT8hKm9SbHhFZXV4Qz5wJEA3 RVgmZ3h8PzU4N0xxdkt+Q3t4Zi1BJiZWa2IpfFZ6O0dAUEdVOHtBUzRJY2g5Ngp6VXY5d0pMU1gw NThteXl6TlpRUjVjXkZKWW57ZkRKPSVaO157cXxSPi1EYERGdVNueGtOVmBsZ3ImTzxEeTNsJTkK ej9COCV3enZwajFjPGB4aSp3KEZ+ZE80bDZwP1EhTFg8UV9Fa2AmIXRIKkV7KWttazArPDIwSypD eHRGRS10KEBECnpPIyRzaCRsQyNYWj4pNFRqI3s2Zk9EWnVeSzE5dUNHOTJ3TkY7UURad31JMlJL YE82fTZEMCtxWXxSSjhxQjAqPwp6Y3c1TWMrWmVsUUVjKkQ/JjFyUG5lZGhxJEZDJWlnPS1JYXgx cDJPI1JzQ3lvQX5zdGNYdT5CeS14bURoXzxFeEkKemNtQDtiR2RoN0E4KVU4fSVTTlh3KDx2SnBg NHBBP3B9eXFrb2lLZ3VJdCtKVkZMZ0M3KFkhNjhIdGZ5P2tWNzApCnorUWF5e0c4KDcmd3FhJX4k MkViO3FoSVZZX1kxQVR7OHJmOFc/RWdRTHROKCtaWX5TZkt4fVkhX0RDZVVQcSYhcQp6LWVxfSZt dSR6PThTN0lmTHF3akMlMHAhUj49PG18TGt0WjRIMFRvb0ZlelhSPmx8MipnfCkkaFRydk5nWkxq YUQKejxfOHczeGcmSCpjR1MrbzYqUXhMQmo/ZWFiV21+UztCPDdRXzBIT3REVzk4eG0pNGx5NGdA cHowdW9jT24zQGdfCnpUdUY4dSpJaiNLNzRDIVNRZ148T3daKUVhWkVfcWE3fGJ6THRNZ0BUODBY NCpkIylIYzkyaCZ5bEteYF5xKWQrPgp6cSRQTXhPSl4jY2t4Z2crbEZTUitZPGM/b2RZM2QxOyNr NmZgPnl8bmo1dDhYRmoocztifXZ4SUY/MyhOWlcxQFoKemFjQz9aeSVwa0FucldReDw8Rn1+aGhV a0hXM3N4YjlPZlYzbHNFS2I2bVdRNyYjZkEkIX1wKDlIfil6aHlTMm5DCnotdmd2dndrYTN9Pi1x KkJmIUNwflU+ZDBuZXt4ZTc5SGxybTJVaCR6R0xHVTxMQERlV0cpSGJuTnwoZWMyRTElMAp6YW11 cEBsUFFeP2pNYUZsM2lwbktIJDZXa0xuZXNFS250amItSlA8KHJaYHBaPThtQDZJMHxvUjshKDM9 U1F5O0oKelBnR2tHdX01YVQmdmFLUjg5RTVySWJDWD09MkctZkJ4JGpabCtxOX1NfFFuYEp6aWxr SkA8cSY+aDkqMVdZR1JDCno7QD50cERQWV89aHklRTd7XnBPfk9lZXRjPXZNKUAxOXMzbWtrXiV4 bDNzaT8rKnR8ekRTMStxKGw1TDxKP1JSdQp6MXpOdnFRN01fQ1Q/a0RBMTFmbDVHZzchTnAlYFhJ I20/UnhITD94PmFsRmVkRVcqS0YlME1oPDBQUndgKl82MT0KekRsNGJ3UE49NSQhKTEhPlNBampl bGtnPUBFJV9Zb3BaNWIoZWRBPz9LS1RNRjFWZGVpIV4+bjNPamdqXkd3bXFrCnopPH1jZzhqSmtN b1hrWEIzTCQrWFY9WmFjeEMhWUw+MHp0OV9waTBCaUtyd3UyLTFwZTkwRz5Qb29EcSlMbnJ6KAp6 MUNHQEN7bHFxWWhzZ24jQ016c0Y3VG91WHdmRT9KQUxLUFdeZCFReUN3YXI2S1JTe1JGYnMpT1Em SmdWe2tHPFgKej53SHpjSHFSS15kS1grOyZkRnQjUGpeZjZUWCE1Pm1pPSo7ZEtJS35BY3FabTB6 V2sqX1pBNCglfDwtJGM8bn1QCnpjbmJTWjA9MW5XXj1IZ3N4QWojdF57KWFoPkJfQlE9YjdUe2J9 RHghPUhNQ0BgUHEoKGRpVk5XcT4+RiRgXylYbwp6d29kdSRaeDhZMzxoLTcrengwb2MpZldoTTxE M0g3dXgzYlB7dmIrfkwwWHhIOzNlcT9PMUlEd0syb2tWbXkjb0oKelJuYkhYUiE+PVlqOTZvZ3pq OEhndVQ2enwzYmkpNUpBNm1VOyRgK0RVc3EyVlBVUlUlQkY3Zz1aMzJ5UCtqNDNqCno8MVl3aVhQ MHpWdGBDRHA/O1FTbXJzdyYqUSlNIXVkfTtZQ2skUU9qX0dYbEFoaWd2eWkhbjtgTW9ndEE3aiZ8 NQp6dn07M0JAPCVIQiVYMihnLXx5MH1fTWd7UTZkNHc4WXx5KzxkP19aR091U3grWnQ9Xlc9c2dS XlZVMCVMZHhoX1MKekdod19YOCNYbFFjSHE/P1NtVkgzZ156OE1fb1UyYypQaWZiN35qM3EoLT5k ZGd0QFc3WDgkXmNaYGg3OSlDJEQyCnpoR3Jvc1ljJHhVemx7NCFNZWFtPU4ofD9GeztyOWdLXyg2 M0pPMXowSlU+Z2dTbS03YUtSP0ZxYiM5X01rdzs/Pgp6MW1ZZS1uJFJibDhDUGdYRm1JSko0VENI e25MNjI3aWU4czMqS2d3O0xmbTg9KGErQl4lM0NeQDRYd1o3dFhoPTQKekQqUUVLNiFWVXpueihh eVI0WUVOaTtSJUFvaFFQSWwlbE4yNTVyPVFEN0VLQjMmN1B5KjBzSEBFWWBCK0Fia0gtCnp2UDls Jj57OyZtX3BIdy1MQzRSZGFycilKbnY+JXw5ZE5TeW92MS15PXZNdkRHJVJMTFR7MkBARm16aUk5 N2M3KQp6cTtiJkA/aUl2elpMKWYlKWVCWnclfTNia3lLJX54VnQjOExTeklSNlBiVEskZ3ZWdCFW Mjk+NzxDQmh0UFFlMUQKemZWVFdJaCRGMyttZD9BLTZZeyNhWm9LP1Ejd3B4dWpoOzhIQ3YhV0FT dDlzUSp4dmdJNCVMITFiNnlRJVUxdlY8CnpMbUg9KlhIUnxXM3J1eS01Jk1VOUI2eHN0cG1xOHJE RUI2Pkh8KGMoPXZ7bWp5OXhCc0o4JmBFTWI7JXlUUFJ9VAp6c29TTWE+e3pRUzx1VDNIVVI4KX5O JDZzO2wzekQ2ZypsfiZqWHF6YztYby17OWB4WC15Pnlvdnppb1ZpbFgyVXQKeiFlPHorQ080TXcq NXBIPjdFVnFacjdueTFKMXF+b2d9PyV0RnE+OXZ0ZWJkSXRAUzxyaDNCaVF3QSpeXj0lVlBUCnow dkxgQVlkPTF+MCZ4aW4qUmloNVZgTnRnUHooUDQtUSk8NUBTSiNnUDM4NlRaSj9XSnhIYyYmQUo2 TzNmcnlwKwp6RXVlYyMraUl1MmhiXj8jOTg5RigrSlFzdGBgb3A5bjE2cH5uNGwwT0R7RlFBUWMj QSYrS0lpakspeShhVEl9RnMKenJscWF9e2olZGY1cm9fLSFAfjgyX0V4OTtqO0liQU0hOzFnYU9O P1ohSF87UmZzZ043WVBWXzJtfmUkRGg2Kl5mCno7e3FhSGY+ZUA0PiZyfTB5Xjl7UjBmcDA4UTJX Z0EpdDAtWldCeGdMaXQ/e256c0VxczR8NiM2NjB5aD1OSjA0NAp6TlhRbXRkOGZ+cGJHd3ZSZlFW biVacTB9PmJVKmk9JVgmc2B5aSlBMVhjVighYEZlPHlqcXtNJVF+YVJxfElHWDcKemghTT5ubmh+ ZFl0N0pNWCZZS1Jmb058WXc7SSYzdm82Si07aDRKUSY2JiFlKDZpVCFIU1hlLURMYDEmZlBPSl4j CnpHSGJWODE/R0V7WG13MjRSb05YdHdofTUrbDVecE0jRiN0Mm5YcCp4eSktRyt1QVdKP2BQSn5h NSVJOW8pOD5lIwp6YihZOEwpMXgtazxAR0hNSkM8RXZ4KDFZT2VFakJmbVVXJUA4eWxDSTVadDxM M1hqZz5AX1diVFduY0NrR01RPHcKelpvPFpjcVFQPjVqX0xTI3hGUkA0bkxRYGZwWl43IzNoI3dz Y21rZzAqbmZ3fUBUJHNmcDMzdDs+a3A3VHlxXz1hCnpvZENYQTApS1N5Wld2c3hwMmBqSi1WZio4 I343a1N6cyN8K0pVdW1iOygqdGNOQT4tKl9Sa3B5SHY8dEdUN2E3Qwp6OHdXeE9UKGluYE8mRy09 IXxQeHYwdjRTOGZnTjRZemorb0Q4M2dZP3VzaFF8N2wwbHByemdIVWBWMlJrKllrJmgKelEmdmYk JHlYO3hWenF0Jm0tPTFneUE2Yzd2JExrTVMhfHFrWlMwYjZ6KldicDN4PTF0SHpzOzducmBhc14+ QVRYCno8K05ZI0glZVppek5lUT1HRjFlYGs+enhLYythSz87K3EoZzhaSlNqKmdwQihLPnEzSVc4 JkBTUnRoby1kYm1RQAp6YEdlaiE3RnJJMEYzJllnLUJKRm9kI1lsJmM+WkFES3htKUJnITlyekE+ VnY4RktqMkUoYnIqcEd3Wn5eMUtHQGQKekgyIzszQWEtWkZUSig4cldUeylERjthZT1WUWN1YTtY eTNFYzg/RUNHPThQPUM0M2xNN3FpU3dGNX55MGlrI2s+CnphQz9DZWR0ayRzKntJKSYrPHEkS2oy JDxDU3FyeyExWCQ3MShzcXlDUTM0WWxPRnV3PE1iTnV1SioxLWRSKm9wUgp6ej9PTHEtaDFsWDFH JGRIZndsTHZhKX49enVgOGJFIXlBUDBUJX0xPjJYfjd4IUhqK0t5KyV2TT5xJVMmRkozJlMKejV+ aSZ4MFFlZVFqMTlpVTBmeipNSkB8b3tfXn5HckJ+NCs+JXEoUkU0cCF7dCNeSDlvYFQqXkB3VDw+ eTBURFFhCno8KWNaJVpDTHYwNGEmN3ZMQzshTFNYRH1QQmdnSklkKlZQVFBoWkhhfENDYT9zQGNr endwaTBhRnF6JSRXSyt7SQp6ZVg7dXM5QlAmJTBzUXJPI1RoKDU0TD4rIVhfM0FULV5taz13dE1q dFBRUWw+I2t2cyNlP29iNFp6JFNucCVJXzkKemdKJnktaHl2b2deYkpuckRebVJuKkBAZEFHeGhw UUt+ISs2PzljdUNve1hUXyFMQD4hRzArbz8oc31ZKFdscXtTCnpIY0M3NGF6PEFkJV9JKmUwQUUz fnhHMmlwSD98UHB6OEJsbTVjbjNIVWBIY2w8Pz1WZzRTIypQKm1LKjZYLWhMYQp6b1I2PjJtK1ox byMkfGxrb15TcW97emBPeUI4VE1qTSVHbigwPmBqU2U4THpZRU1JY2F3Mih8P3c7ZCYjbSlXN2AK ejdRSjNjcXwoaj97Wj0yMmVaUDU8Jjd4SzJgdSZtPCUqZHlmKlUpa1NzP3Q8PlReYGk/JUZoTXNM cztCfWhnUDAoCno5MTEtenRkKmQoNkhqTDZrNTNtcCM0fHBqJTczcS1zOTtSUkhPKWI4NklyNVdK N1k3cUFCKXBfMStsSkJJKHZTNQp6VmwjZER3KF5hZDQ7cm8mVGRhJmApSWMydzliUDclQiQwRGEx YVA3UHQleVNNcnJCbz1pUER6aE0+Rl9OeWBQU3MKenJ0VGo7Rl95Pi1YN0w7UUlpayQ0QzEtSiha PUFVakwwQGp6ckloPHNeUEw0NDF9Y0xWPDtaMG9edUVxNDY1e34mCnombDs3bDxLdC1OMTk+P0Re Zk8pJWpZbXtzVF5LVSQlemlLK042SWJRXjFvNitRVVohfnBKbHpgSWE3R19YdTFVdgp6IXcrMHNn b0h1UFdyXmNmVUlDPkRxWjU3JTAkMSh9ekVfPzZ2VFFXZihOeDxldHxDaGd5PSNWOWQkT1drT2Z2 a3kKeiU0eW4zQD0qNjU8OSlQdSpHOD9lNyFub01kQyZPRGZtb0JaSDQ2N1BZPklgfFM5ZDReZ19m elFtbXZsPXJMUTFKCnpzQTEkWUBzbWg2TlZzJD5Je2FJKXcqSyRXezIjc083X0dAZTxrWGE8a1pR RDNTN0ZkclcwXzdZYkE2N3pzaj9Fegp6VD9vMmchP2xSVDd8X3krNDJxPkswPFJqcW4tOV9XdD5H MnI4JTAkJlQ8Sk80RVpjRDVCZXdUKGszSkQ/MFF9KH4KeiNxby1BJVg1ayYyPUQ9SHNoWCpuUFNs XyMyKCNeQG9DI3NAZ05naXRFI1g4PTtUOFFfe2k7QkkmP0NXcnE5YG5rCnpZVChEMzU8P1VsSHIk QTNEQDhtYDZrPXFyTXcmalk/JWRSclhMaDZEeHNJUUwkcFoyMFh1eXh0aHtSXjwpTUliZwp6MCZH MXtuI1hxRj87Q0xCcE4jWDd4YkpufkdVZGttdmR9Vks7ZWNvK0lebGItWSoqPmRuRDh9NWo0bDAp QDQmM1MKekFxKFYhNXBNViElVkdac1NMcyl7KDxXME9TcnZ5Vz4/bHFjekhPJEVzPFdVWT4hQlZ4 K1R2VG9LcjdZRVdhSWQ0CnpWNXw7ViVscllvYil2UzBweW58Z04pVHlwIXRaQEZPN055Y1NocVo/ a0U0QiQ8Q3lvdyZgNVMlNVhBZUluX3xWJgp6KnRmSyF0T25SJFAoeVc7fDRncGBlJEVWTT9ScHU9 UUt0Nk5pcGVGSVp7d3xYMVhvMjhYUXU2amM1RVJ2JFozOyUKenN6aGxlU1EpX3BEMVlCWV5HRDRg VHBzLSMwRl9pYWlHMUU3YSlNc1NiJUJ7KjZfWE1AUHpHOHshaVI0RU90UCMqCnp7PyQ8I00mRVV1 e1pIQUZOeVAtTyk9Iz4kc3V0KzQyUF9QdFJFdVQkS2FQamN7P3NgNmZMJF9FKGNZan1UKWR+NQp6 JTFFNzQkbjs/ezJpWFd7eDIxSCM+Y31uXkZMeyFfPzRhVEFjSmt9VmhPKyUoLTApMjxgVkorQlp0 c1FyWEVROXIKemA/MmppR24wd0drNigjVWJmY3VISnRIdGdQaH1eWW8pPzhocW1Mc2k7YXFJd2Jx aiMoNFVtQ2tSemA2ZClrWW9RCnoqdXoobFZvMj1EaU5gZiE8bmN0TF4oeTF+aj1TWHtlZFEkbj1g OEs7NiFKSyp7VjtVdzlETURlI2sxdTc3XkxlbAp6cn5Ia3ZWdip0WF43YGRXSVl5VlhwZWctbXAm XmBnVGtaQz4pNFVwJGVwbGNqeStEKFdrMiN6NHU3aihle1h6ZT8KenQyMllIRVYzU35rKCQjeVQq cUVNPWhYQ3tRJFgxUHJqIUtRNjljdGJWQGI0UmIpR18qUU5ZM2d6PmEkV05YMyoyCnp5NnNjZyEk YHVpK1E+N1MtTFhWKFhBQDheQjJHX3xZWmxZbHk3X3RWNkxATHg0JWhedCNuRyg0QGxBaDY9PEw4 VAp6dXhGOXl7Xkk+Ty1+SnhRTkZBQD4jJG82YW4xajR+ZHlnUWVARW1YIVp+Pzlae3l0Nil3UHlv dllLRV5rKzBuX04KeipUeFVxKlYqdkp1fUkkaUNvWkdac29HZ1E/ZU9rPVhST0RmaWl5Xk1Nak1z VihMbU9gPDUzPVNOWHtOeyZNdXJwCnpGcG8lSkRaOFp2PUNISHpMKVJiRl87VTAmI0RrQSRLbjVA ajU4SUdGWSpASEJgMzJUPSZTIWh5VUs+ZTFHc3tnNgp6ZzdNSjZWdS1IayptMy0xdFpOdCk/ISMq VzVHKlU3b3Vkan03Y0pHRF9Rb3dxYDFwSUFhOVYkTUF9O3szLUZWOyEKeilmOHdRYGlSMj1DMnpO NXY2d0lhSjxDKXxnJjIkeCp2JnF1eTNIcTlpc3ZQTHFWeGJFN21tfFk/WihCZkAxY0VLCno1KXl7 ZlQqdSFwbXY9VlZweG13aj9VQ0t7QGBXUC0qMlpod3JweUpxckNNSCk7QmZPdmctZmp2OytMamxv MFFGKAp6MVl6Vi1ncEBwdz0lUDV1aT5KJGtDdWIjWms4fSRURVVPcGVlX21NNkFKUEFTcXRjUUFV Zl9fTV98eypiSH1eNmkKenhvMCM9SnQmPTFzejYleEl6e2ZZPmA8MFglYjRzOGJNWTdhb15yTTYx TDt+ak1TX1hnO0dDazF1Mk00cEoxSDJuCnotOWtCLT8tVHA+UUc4eDgtOFAyQyU+VkwyNXt3Sjs3 ZTMhWmkqWmhEVV92U28jd0d+I3gqKGIzV30kRis+MDtIPQp6PTJVe1ZVVj0jSGF9bkF3ZGB0SWxV O0EmU0BuMGdkcHRRPjdqOzdsaUVPK1prdEl5OUpRfjI8SSlFaDdibVRVYUEKemNyNV9QPz9hbXM/ UmpnLUdyTz56OG0kQjFiaUMtPlBzQmRURjQ4JTNtTVBUZlBzVHFSRV4hUFFrKz9gQWRpV3kpCnoo IVhwPnQkWm9TIzVCSTBVR3l9Qjw3OCVVXiZpI3pZYkV1M1kmZ010U3N5NTAhITxoPCZuQ0ZwalhQ NGU/Vkk5Owp6bE42R3tSRyVvcU1FfWR5dzAkMUUqUSlPajdgZiNgTStALSRRRXdERUtuMX4lMDZH bEVgKDV6Z0s2Xmklej8mWHMKekRCNil4UGA9fXlGe01eQ1Z6eEZwVVl0MW8tdkB2VjF4I0QzVXVI cF5uSFQxKHw2ezZwU2Mtb0tzKGpPQTEjPVcpCnpzbVZFZ3A9TjQwYk9VTEZwU2QobDBBZHtJPzc7 VjQ5bihZMDFmUzg7MW41bS1KTUlxLSk9anZKT15Fb3JUeCVSZAp6PXNCbnQ2JmZ6XlJrJipvN3li diV7enEjfkZAZ3Z+VyFhTnFlU3VjNEpBNjYkNkdwaldUU1VtNFlhNWVjQjVfTCsKekV2fkclLTlj IVQwNDFseypyVjxMb0EzVCM7RVJxRG0lNCUtN0h1N1ZEclM+OEQzSyNpO2N6WXNhRTNeXnZhdDZG Cnp6eWBVdHFRcklwO3VJSipuVi0xfW9qQj0jVkRDdTJjUWRMPG0jblFiYysheVYmZ1RYJndjNHJu cklSQ3xyKHdPbQp6RWF3eWAoQk1HQjs0QXRCWS01S3ZvLShsdUdWMWdWejxlMnlEYCF4e3I2XjFV RTttTC1jQnxEQSg3e2hRLU1tKnYKeig4VFdzRzRFeW90c34pdlI+fkw3NX47Z2dwcEtlLSRKdGk7 bDM2VjBqe0JoZWlPa3RATTJqb2UmaTheSXYoLW9ACnpGPXJtNW1iQ3lRbX5WWT1uVj5BNyQxUEdI RDYodyQobUE9YXVqJFcqUHRTMHBfYmVLVitrKXIka1pCMFEjZGpaXwp6RTskfE8hbnltbWxMfChO KTZrO3pyRi1vTCo8V182TmlVPWRlI2ckRFhxNUVyc0x8ZnhfPWlMb05nNV54VXNMaz4Kem5wJjF1 PnxnKiNAVUFsZEVWUXd9IUdvUyE7K29jSm0mZ3tPVTh9UmhrPUYjaSpveHY5Mz8weT5sc2AmVDk4 aiU3CnpWSlRzKFhLPjlIYmxUfG9AWllhJGEwOzJRLSVZdnZaQ08rdmFKUSUwVDBtc0U0JmdKSXM5 RjU7Jns9bXUrOHFfSwp6MitySWxAJVVIfV4hMHplMFJGSzlBUHhBWS1IbGBqVzFtTVdWcUlqU1N+ KUBscnQxVVpnM2U8MWt3b2c3UF81R2oKejRLM05AY2h9cUZ5XmtZKmxNcTtVJTdMbHhGbUNVRllF KXhhVktHYENZNGAyKmZIaG5QI3tuMF5RK0pLMDMjQHsxCnpYJl8jJW1oQ0VkRilIP21xISR4MVZ8 JGQtbT1EKnBoUGJWMzBjNndrQ2g2dmgoO18lbVNxKnRhWChSQDZgZjRwQQp6dz4wbT0tXzB2TXNo SmNTUmdtJD15NWhrIXJGR0UpPEJ5Z212bmlUX19mXm9ZPWgpP0JaUj9MYUFteFI4MiZCQ1IKektZ SF91VlpaMDNCQUR9Y0lhMyVJK0libilrLSVWKlJUTHJrYyhXbX1geVA2dS1ePktJJHZKOWI2bXB6 Xk8wJnRGCnp2TDcyZzdpV0ZKMF5qRmBSYHVfYDh7d24obVJpMFdCWkAkNm1jQkllXjl7OHxJSzlv ZEo5ITZ2Til0TCNYZ1ZfWQp6VWFUSXU9X3BBKTAxQjxPLWFCcyM5JHo8a0NXM0FWa0cqZndtWTs2 V2p9O0tVR25tSHBmN3l+bDlCRkJzREMkbVYKejtDXnJOXlNZMWdTSzxFdmFQLTBxKnx2MypofFJS OzFZRlBRM3xNUiNac1hLWEV2S1hmPWFKKn5HSihZdypSQjZECnpBaGg7YCE7UlVZT1hDI2hPfXMz ej4meU4rVEFAbHhZRDwkTUh1MkwyZ1U2Xn1sbXdHPDZpJjwxcyFINFEkKUtHYQp6bmwjYTE8RjRj T0Uwc1Z4e3JkVX5zPlFsTlVjZn1ObHMyTC1zbXo4d3l4dU9sVlFVclpMeTJeYWZqZmpmalZZNyYK ekNPQXZpYTRKUGNaTkg5S0NxPlhja3dKWWdqKU1JX3JgPjQ+Ul5ZOHZVKUQwIyFuaXRnZ2dfYzM5 PX17NGFHOFVlCnpONHc4ZFBGVz1JMlBSbHNaVFBeUk1JbUJKIXFmZiZqWDUlN089KHtDdD4jS3lQ cyYwRlpELVkhS2UrRjZUa1E+ZQp6VjVaJkJqeChrJEg7SCM0VWNYUCoyWmEyfGZ1NmhCdSlVJFdK b3swJUd7YFdZYEAlV1c3X2VBQkJjY01saF9oVCEKelkoOHEoVTtIamZvKC1HcnlTekx+XipHdm4p YF8pbW98fT9HO2Z0aChoM0NTYWV9JGpxMXI5Z3NjPXR4ZGFIcjBXCno+byN4I0E5SjxGaipPfW9p fGUtJVFfailwUVhIZVEyTEczJEhPVGJ+NWpPUWB5UlB7YyZ7aVUhbiQ9LUVfUip5cwp6KVhiVFgp czZfP0B2PU91TStxeGl6VzJWakFMezd4VHVpcmctWWppPkx8RDBWXmpXfGJrUHZKVSptOD45Sm9X WlEKejVAN0ZfKmE9UF9ZYjk5UGkrU2ZgQG9PSzY7X19pUUArdGhfVzJgeXZydzF7K2x4K2VpYCRO OVZGViR6IXV7NTx2CnozZCtGanl5RTVKdllxMU0rQEkoRT8wb0AyNCooSj4mbE1xeipwYVV3a092 RmVkPVFKN24qQChoYEhqaEdNI1h9egp6fEZPS28rNytseDJ5QE0tWEB7SzM+eC03U25CK2o/MXFs QjlmT0t8RVZEcl95JW1TZWBqI0lzK1o4TGJgQjJMcEwKei12VHw1KyZUV3xqSS1MKmw/KEA5eilH NEg7c0JuaWpycTUoVnB9aistVkx2ZlF3MGhCKn44ME88TGdQbkQ9cGw3CnpLKy1OXnZvdFcrcSRF dCtYJHBLKVowbDlIcHtVcjFBNT00ZnozbHdtQjBNTCo9S2FMKWxiUXZhe2lFaDxvJElqKAp6c1Bi KjZLPnQ+dzBnR3h9SGFvSk9uRjRpSGJsJGR8a2k5dDJ4P2B5KD4wcks0cypCNyllLU1vcSUkQCg3 VHB9TXwKeiRAP0ZxZzZrcykhanVsX0JwWSlvTlk+alJnOTdeeUsxe24mNXchWis9MGpfbkRYezhj RlQwIUs0TChzTEFuamBzCnpCVkFWeXxDd2xnSi1nSHJ6dkRTRyp+ZiFxclduTDxKa1Nyfld1TSVW VWxlOG5CSHJMPD85ZHRaIzJXQXUraj9KTQp6KClIPlVieUc1bTJ4RXhNPm5ZcnNPeWlzYnhiR1Ry SlUha3xOIyExT1JxWUslVVl9KjBiRmh6PDBuV31kOEYmQW8KekN1fERPbFF0YiVScz5UYWg3S3df Vmh9YGY7OStpLVFZTz9aQUU0X3ZDaD5xb1c9RXs4X1lTU2RoUUdWQWs5Z1ctCnpoQE5YZ3RVRjFh MXU1VFQ/aV9Md18qaXtDVWFyQl5PJW1RTldHN2l3TlNWc0NWNl5Pdit7VVZDTk9APGo5MkBKYwp6 QlY5ZWx0b1dxPHhBKjVHOXdlXzNOTXRNOWZ5Q2lqSlZMPm5nIVpoX3hOPUEtVF5CWmw3cXo/Yl8y d002ZC1GOSsKeihLR3JAVlZDNjVfT2doLT9vTS1FNTdyVCROM2FBXnBvPH5+MV9jS2dVOHgjTUZv PDs4OFM2OURJPjFrbks9VnlmCno4YnJMYkJ1VSozO0dmN0MjSzNpYSRLcSpQX0NINnFNRVBlTU17 VVJCKCEqck9BOHhuUE4tNUl8Y2dqNj5PaitvKgp6fERkfmx0d1RSVno1fF89RiY2Nm9QRyF7ajZE RjM8az1eTTRZaXBCYXhVcT1uTGNGNnpzJm84P3EqUT1tMD9MZFUKelFmYWFLbmh0e2IzXyNnNXBR SHx5TVo8PDNDbn51RT44OEhaMkk9TUZoVyhQQ1NMJEhueGNQWGQ3akVpe3lVT0g8CnpPajdAV0Yp bGpJJjlHZiZVb0YtVXFqX04+OWFzR2tYWHVXRGFvMzVveHpZb15vdjhYUjxLb0V7OEVlfDIyJSVn JQp6YkxyTnwpTztSMjwxTnA5PmVpYnNSPlhmOz4zIXJtck9weFRZO3JeXnhaRDFZZXlvSVNqIVNE MCpSN2AhMntxO0gKekM1dlRJQypGaFUkdFlxQGZibTxvSF84bGpKeEZDbWt3dFNBaSQmWWNRUj41 dG8rb1owPGshWEE9KFA0aXF6cF5RCnopWDlwV3FqbUBWJENWaDxQPl4/Zm4pOE95UXg7anlqYlcr Unc1ezlUMWF1cW9hUyEqVmBudTtuQEgkcyReSTtfUQp6XnBQJD9vSXk/WndxTnhoWms/ITR2M3Qw amFwN1IhdjlnOENoRUF6M2lyNG8/VWl8WT1hZmNxZHN8ZVQ/ZDZxR0IKemclYjMlOEImRGAyUl5C cDgoKiZwOWxKIz0+ciNiJXNrS3prRmE8fURoYXRAd0JsX1J7RnN9eXY3biZlUXdZPEt9CnphTkEx QSNWXyQwPWBYPTUwdVZ2VjghSU9qV3A9WkBpZTdBTlFnMGNGajw+MU9leDFBNjxVP0F7b1VReyom c3lOagp6dyU8dm00T2dkTCE/SDl9RG4je2BSIU8lPy1HfHBxY2YlZXpecWxFK21YSyhfMGduekpY WHMxbktRaT5Xc1pYKmQKemwwcnEhOSQ/fkVxTG1aaGteaWdiLSVgUzNXdGBwOVRlRzxiZ3drNT97 diZGSjUoJTBJX0V4MTE+PnRycVpDaD9sCnp5a09BfnhpfE5nKGpGPX49RDU4cSpTKClAP34lU0RY X3BWPzNrU29pTWlvKTt7eykwUmRMKzJEU3VrMXEkMkUjIQp6Vzt9T3clV2p1KWFXdzxTKX1nNSsk XzI0MUA7fWxjN0R6cFNFOz10Kk9Pdi1TKHlzNiZacTIqRE9TbHktOH1BTTAKekVObnE7aDFFeT5u KTYhZmFvelY/XklBX3Z3e21kPz5XdE9MaWI/REBUaVp6U2ZQOTB+RU1EcC1qJnM3Izw8Z0hgCnpa e2VffDI/ZndueCVgKTlLdjx6MyV4b3NpTitzNT9zal9afVhKUFE0eVF2fG1KRztmQ3hnN25HUGRL KX1AM2NJOwp6WHx3eUkrfV5XUHhmV3d6S2tYPEt5UD9hSiZjRzZSVHxtejltKzNFczZqLU9wUXpN fWx4ZFJ+OUMhXldpeiFBRWoKenFnYWozc095NnVKMkhOPnY3dWQpKlZ+TGJ1NF5kVkJoc0JuVFM5 SSRFfjtuXmNkIWooSUkwS0l1X2ZTVzdhQDR8CnptSGN5Z2lvZDRPWjs5bEM8ZWk9JCVub3lNLXlY Y2ZMTGFIdnhJUkkhSSVsdU15PDtkU25CXmFgKXtSKz9tPTMmUgp6RExVd3xaXmVpYEo3dFRENytQ WGQ1Zzg+MDtmT3lybjx5JjNZezE0bmI/UEtySiN9NGNpY251ZUNefjVUSCE1dTcKejlzVTxvaTV4 T25jY1kjJkpSSV9yPWhKbmZmbGYqT2djQEpaSF9ac29jPmBmPjNUeWhPUFhFbXtgZWpUUGsqKmZx CnpkekYmMCV5NGRzMFlqK0xkfmAmRS09JkMrc0hyflQlZGZCdiQjK0ZzY05oYzZRPkltTTEjZy12 Zk5WcGVETztnIQp6WGJyRVU2I3BteSRpQXF5OTJ+SnY3YE9wVm1yNnNxdU4lYkVSI1BAJGUtNzNH dGh+fHUoRjtkOFBQVT5pK28zUVcKenp+Tm5lbVU2JlV5WGJKRnhxP3ZYYFNyYnw9KFZpTWs7NmxE OEB1YGt6PDhfdDluTTVGWHA4ODA1TkB7ezA3VjUoCnpwKSQzRXZvQGo/eWJwOGQrejVvfXhKeGtg XiZSfih2MkRsWW45Ul50bmt5PWg+PWp0PVY4ZGtOY3tLTyY0cCNeZQp6REBld3AyKnkze0s4dnpr YEcyTllrfSROeT5EfnNobz5SZS1fQEl9PEFNdTVoLUlYUjlfcU5ZRyFraHk9ZiMwY04KekxsSWQ0 Q1ppSDZFYzBDPkxSbXo8TjhSPkBQSTs+Y2R0WChpKWchbXBtMTUqQjY7NiZ+UXZEQ3ZoKFVUbSFV UWBpCnpYJTdBTD8jdDh3emNlVWZ4NH1KKFBaYWUjVGhmPkI0eS1MVm5NY0I5TzF+WlNKN2xzK2hP UnlEZDlRIWsoN3h6QAp6KWp1NG15IUphdzZPMCZ4czx3fnBxOzAlbylWLWcqdCs8JF5fUWN0elM/ SEhubVRGZ31QTDwqSDR+RHBeSHhScmgKeilhQEIqKHxjRUNxWndzdzMzTkwlNjd1TnMhd2pVP2Ey NUArKylFczkhNFUzIyhUP3lSYEQ1RTIhRWpVV0xofWVtCnojMVc1WkBwYnl8N091d0coWUhseCtf ZmJVbippNXh5aX5ObGtUO1p0XmR5dnM7cVowSkMyfm5RZFlkeDIjaHkqYQp6R0NMUW1BQyNqb3Nl SmxwPVVmdSU4cThQSWI7eiEwY1paTTFBP1F+OURoUyNTVUc3LWM2ayQtUkBHR3E7KUlIQnkKelg3 OE8yK3U7fW9vflgpSzJsOCs7eipoQ1Bqb0N+VVI9QFA9QENqUWhgVDxAVm1QIUF5ZT88TSYoalQx Rj19az9aCnp1ZF8/TnFRN2RJandOLXFhJDlfbCY+Jjk5SDEtWmR3fj9+a2I8ZGFYPn1eUSMtPU1T WSN4cnl6JXlnekRzbFJTYgp6a2F6aik4cGxjTEY4UFhRJUZUckNCe3gmZVhiMEV9SE5ARmYoNTZY aS1NMFhoQHc/VE9MSVFeYjlsTUkhdXExcDcKemRFUVRwZEJsWT9ZdUMmVGI/cz8manp8WUN4IzRJ K1psb1E3T1I9Z3QzRjM1O3dNSUdMTC1UeW8jeX54Y2xrVnxWCnoyMisyK3F0RFNBeiFXKlQ5VX1m JklQJkA9ZGAoTyNRKkdAX0gjRWRmM3dWVmV8RUA8U0B6R3hPYUAlazFefTh2fQp6bGlmRSFtN3RV VW1iKHUzakYtJGJzY0l4IW5oMWhMMDFJa1h1cjNWZjxoSnpaZlh6QnVtfnFmXyNBKVpsYzJFXikK el5RRzBFPmdFWENgaCV3REotZ2FsZW07ZXI5aHByKUsrQUNLeVI4akE3fCNyZDFRMVB3bldTNm1y SFAxMj4mUWxiCnpTYShwZ3JqKCFnWGVFJXdXVkcoVVJwUFVOZVY3PDBRY3U2ISNtb0lPV2tVJUlo OyFYOHNSeTVUaVJMSFBhY2NkeQp6IT5KUFBVOE9rUDhEeHBYPmkjI31nKHIheiQwa0BrIz90SmFX MDFNYUh7SnthUjIyX1k1SW5EKmhQfWVKdlMhWmIKenpzMnwoOXRIflY4WXo9c2lVX0BPJUNwT0NM OzEkYlFZa2hRanM5WEcyOCo7aikyUilHJFY/RT9yPT9oaGJtJl59CnpLSzR1KDw9ZWI5RW1VQyhs Zm8rMFF0UGEhZH5Tc2dMaE5NQz4kOSEpNDZZejgkJDV5dldHWUliPERzcS13fj4jfQp6X3dsenp5 LTtpK2UpJUIpX2lAJGkzIzdOQXY+P1UwWVYxcUZtbCNnJnElMU9jWShFRUokbzNhd15veEZ+R2A8 XkMKemllR3E4cyl5aDJQQGpYRil8YSMoTC0yNStEPllfUl9sZis5eX12YnsyajhYKVcwOGdsJVZB LT9BdVA7fkd8Mnw8CnpmdzVGNGJKbiM+Zk45R0RLcUVkYz9LclpDQDtmcyp5K0taP0shfDcyczZC ViFKZTRvSzVyJTVpZDFSb1JJai1qbwp6aDRXJUJtM31tKVFwVCF3RmEtQHN4R18mJEFLPENYQ3Um YnFTfT1HM2RqZ2A5Zm5rRn52X20rYVZ5OHY0PnxjVW8KekU4UD9oQyU+XkBrYF49QEgrPkZic1Qz elZPSyloJDtIfUQqLSpSeDFzZHpWQCNOIUpWUXwyNjtxdHJNOzgmaj5YCnpgMSs9T0FiYVJpO1Yt JnpARlY0PldYaEhISSsxYnd6fW1QVV5lXlVxbngkczhASHBiaktIWlA3aE9JZiV2fF9AMAp6dDVY aDEhP1Z1QVQlNXkoLSpXdk5NQ2FrQnVrU2V9WFMrWXErJXd9cyF4Y0tXYHtfXjFLZUdQTSFWNTBF YCZXTVIKelNBNSRPNU9YVj9BUjVWZ0FiVj4zVGBoOSRZcFZ6M05vYDdfLUJYIVo7eVBWJmJRYUYo a0RuTyUpKlBqT3dTUl9pCnozWWd+UHg7M1JfV18oNlkqUz5FWXhxfE0hRXdGTldfSUI2TEVmU30x VXtqUX1JeXp2aHQwfEwrK2BJYS1LTU02Jgp6KkpWWT55N0IoaCEwSXEyOWB6YWk4IStuLWJ6bl8l e0xfQT9wQGYpPHRZaD5TU2Bhbk1gJlVHNXZyNHB0WmN3RTgKenphVzswUHhoIXkpQUBzNzlHJj1m OWlGZ0NxZDRXSDUzSCFmISE4eSMwVmJ4S0RDdW1+dzZrSktxVl9EeCpKJHA3Cnp2S2k/THdSQXNP cithRDZpZE5mJXdhbzhTNWVRaTdKa1RqO143VU9JUH44aXVybS1XNEY2PnYqYHp5SHxFRzFnKQp6 OG5hJT1CfV8yXj5NMENpWTUyTk4mMHd4R2BUS3JiXz9uTWQ3cEs+TVlEYU0zcVlBNnxEPFk7SHk+ Y3ZBKXxgU2oKelZqfFZ9Xj8pJSl7bmM2ZCFLd2puMXo5ZVAmSWpNWVZKfDx8TFJsNn5oVF9nPzk/ JEkmPjNudW9VO0I8fVRqOUdVCnprIT5yVUd8PVpaRDdJT0dlKXQ9K0Q0bl55NktfN1heSkJGSkZs KUdDQWZKUUVme1RJcj9DbEIxY2JTQHBENkFlMQp6IykxVWZENTsmX1FIKm1gR0ZReGVzaHgxcUVW a3luMi0+d0F5V3JpXzA/YlF2P08tNkVqX1BIQ3tTc295NmRXdCUKenJSYSNoJnRRP1NCUmR7WWRj aFk5b1M4UChIeFNvRiE3VnJZNnpEJnRrczBxVyF4bzMlYVYlRio2en4wNENMM2l9CnpgQUo7c2xa PlpGeVh8V2AkWUpBISt6YVN8VmpXalQ4cS07NXk2STc0JTA5SihLPkw3Kl4mdiRrUTtVV2BHLXJ8 eQp6bWdiSE5zWjRaKyV2anl0b3A9bDIoRVlidTJtUiZ9aURgMCUlN0A+Sz5US3N+IWd5a1FJPlJL cFk1e2B1X3QtaSsKenhpPXFDb2gjcypIKT94Xl5zUVg5PTg5O0EzUVBZQV9IQ28qZilGb0x1bXxn OW14e34xaio8MX5nSTx2N2hVeDlfCnpfNCRZUGhoZ3swR2BsNnYkNX55XzI1IUFVI21aKEstMio3 P3ZUMD1sVzAlZ0JLdHwyUSErVmRTJWwqTDFSO2BXbgp6ZyprfmBVTm54OVlOP1hHTjVufHpjI1ow dSNPTEdhY2gxaHdYVkl3IWA8PDIwbXtjbGZYKlZNRWNTZWhgRSleNEUKekU4MjExMlorVChNQE1F b3dAWTVCKDVVZmNFRX52PSs2VD1TZWVVOF85JUdqMFdiRUwoSCRaSD1gWkp+REphMHxNCnpIOHBh O1ZLP0gmbU42KEZTUj1AI04keX1RPjhLbkxFKT8ocitiSkYhNVFCRlV0N3koRDh2fm5JUz54c25X fFc3TQp6IylWbCozMmdjIUBTMXBBZXRCb05XYUI4YkoxfXtuK3FgMztPM29SZlM+fVF9T2BKOUVS dT1UPGlOV2Z5aUljVUsKejghOUFMK0EoVWRXK3kyelJ4bWxeXzI4QDl7VExIUyZtViM9SS02TEJj KTBxUU8qPl45ej1DVygjdndnWU9CY1ZYCno/b2FCYEt9QDx6Xlc1fVZJTEJESF9xMWdZUFlpdChB KHN4eClrKlZ6Yjx0b1FkNWB7aEpsUkw5e0B5OyhpSSZQcQp6QkZ6KkJYYktge0N3NT9nYDNYfGpM TkFYK0QjJnd0ZH57MEJUSG12STlac3w1I01xMTU4b2FUJXF8ITVWYyhxX3wKelRzdHtfLWtAcSF5 WVgpQkBUTjlVJDA+d0dGaXEzeXhCcF4kTkdRPHwxQTdJUGkkTHFncXxqXmZDej45YyVPTGN4Cnoo VnxhZDY5JExBZUY1NUsjdXREMEZreWc5PmUrXz5YPThgSiE+SUNfUiRDSmZrKEJ4UXNGWkhLQHtx ZD16JUMhYgp6azk9d0xxVCluemB6PzE3KXBmMEVPNV5SPSUlVEElRGBodHBBd2drSWhzfF5MR0Nu RCohektpOWB7LSNjNmdeMHoKekVpbyV0RnVtVj9jN0k+QHNve01ecnZua0UkfXBEYVMjKzhlOW1V SGBIX1YhVT44Mno0KEpTPyhpSVNsP01aS2JiCnp1UVdeJWdZWkJuYSlWSzBsdXlDS1VPX3RWcnB0 Nng4UCR+RlREe156TEJqJD9gVSNlRmx3WDFhZ28qMGQqWnZPdgp6Xk8rSmdQbklvUm50a28kYXI+ ODslS0d4TldgdlltdUA8RzhmWT1HNj5kPDNTWU1HR3UraC1nZ0E1ZF9VdyFibGQKekJNQC15NkFE e0VxWUleUSNAfTQhQllIRFReTHlmQF59WHs4eWY8YUwpRzljMj1OYlB1ajFeRCozSGgwb0ZKVCUw CnpPJDxsTHBFWGBDbEM/YWw2cmNXbjZvWUNCXjIlPzJTZUE+Qz5WMV9FJi1RJGNDKGotYV99ZS12 ZnlLMi13UnEpIQp6dkNSSmBiO1dAYVYzY2U0KSVrTmtmYDNwRm80cFNpLTImeXRNP29le2E7d05Q JT1YUHJ0ck4zU2xpfj5NKTUmSG0KeklyYXwzditMTTxZRj9gbEwhcUopWTlaTTJMbChjKVJtZzcz YUY7UDNLVWNPamohTndyYFQ5YkxtV3c4fE1CYUxfCnpERWwpTHVEJEUlWT8ha2ZfO1N+anRrPyVz eE5PaCo9SVgrPDh1S25xV1B7X2lQUWNBYmZ3MH0xT0h3WUBaalNyOQp6bUVhRChNWlVAOzJlc0pf UUUtM2t5MyVkP2IhRWYtOCg1M2JLJEdFRG4/STMhTEg3WW15bHpgUClxV2VzYm1Dam8KekA+fkBj cnBEcCo9KUs2fmtXaDFIfENAdjkrPk5ib2doVTJJeUV2Uj9HQSM5ZkBJOXVnM205Qz9jditJfjtq R14zCnpqMVMzaUpBVX1gY0s/OHl5dTdOcWFxTXVtMmwmIVRkVnpzPnQ8aCN2cGM1NyUweCRWbDAm aHE8NlQ0M21HPm0qKwp6QUxGNVNrQDxaUCVhOTYoYkJmSGlzWFh5czcjWGZnezkhZm1nJl5wem8p PHVLPnxzfG1QKzBKfWItQGZ3UW57WTgKeklGTG5qK1Y0ZUduUnozaHAjUCtfJDEwR307N1I8Nykk a3Izbz5nKTshY3F1RnthJEtncE1aYlheJmsoQnBaZCt5CnpDREReKVR7RCp5KXZIYS1Lb3A5LThC VUQ2dWl1NHpScipFb29BKyh9NnI2NSFaXld7XmZMcT5zVzY/RmlmNSU5eQp6TXhjOU84VnpWcyNA YTQhcXl7Q1l0MTBNLWlCOVRtMko5VlMlSi0xRkI8dEEwVWVHZSlRTF9saFcrI3leNCtPU1IKekt5 VEtuenIkWk5ZKCMpc29EcUM5OEg8UVFuQXRDRXlXKColV1MlSWVwdnokX3JwRVJLYWchT3QzaXV7 JmxtRjlqCnprQ1Y5dV5tWEN4eHIoTVcrXypYflRKRmZfNnEleztxR0t7Q2RPJFhOcl9wUDFtJWRa UjFAYlBFUGFeOFNHenprWAp6eiNHITZ0RHIrM0c5KXRAN15FOz80UEVkJS1FSGpAMlN2TEFNNEhZ akkyT05TcE5fVGc8VHg4USlWe2J0Vk5WO2gKekFJcCQ2ZTViU2I0ZWlrXkpOUGJ6N3FDSSlRaG5R YStfSz1rai1QZj8hN0tEWjxIK3xFKiVMa3BJJGNHWVUkXlVICnpOTDdEUEpaSmhoTTZLdz5QK2Y3 PzwmRFFsR1RPVW5DfSRUMVdRZ0V0RjhYb2MqbVc1Ynh9cXowRXhDTzM1TWgrKAp6R15+Vz0wYyR7 KDU2UmdBbCVrUXQ7PVMpVFJXQURuYzk+ZCVMQ3x8d0ktc195JD1aMTBpMSp7VXlwM1JTWHhmc18K eil9OTYhbWF8KV54NDhfalZUMFRUNi1JPzlyWiR7OVdZeV5DbV4rbE98NiZhOSl1Mkk9TlUranZO anVQQUxINHwkCnpmczVKdWx8M295KWduWnB7Q1NIViRCWmZIUFc+N2djPnxKdzhvelhVP3dBU3s9 PUdldjNBfEg+ZilgfENSc0FoTgp6Y0tLMkoxVUxfJE4tQDVhSXUjYShmJSZ2I0V4Zj5CJiNBXnBO dkRENV41QiY5TjdIKEUtMlQyeEJ9T2Fzakg1ZzQKenV8PGt2bVlLUW1Nekt+MD8zdzNkZFl0JkRH XyRzQ3gwWWhPV1Rvc1UoRjcrPmtGbXF8VUV+ZF4xZzZ6dno0dEY4CnpmZileNGEtNUtfYDReOG9e MSk7b3dXRHV8cmF4eVo5MmlOVFBXdj5zdDUtSzwoXkdjdkJOVFJzUT19SUw8RH1kVwp6ZkI0bmN7 WUhTUUVtRGgpdk87PmI8KktATEgqU0paKDwpPTZMT1Q2eEFOYjQkc2I+NFRnVVgxRk9mdXo5e31M KCEKekhCb35aeTA9NU4oMjBNTUktNFF4OFFJanYpaEo9VGErSFNTbU9GbFJmMHFISyVGcXA9YThD NWEmRCN1SXVkZn0qCnpeYzhIdUN8V01MMnZDPH4pNm48ISVNVmQtUilhQyktXztjPHh8R2U1I3Ze ezBJYiZFb3h5JDAlX1owd251ZntMagp6em0wKHVQJk0tIVdiRG5IV1lxc28pVGE0VCNSYmBZK3Jp JDslTE8zNClRUSttZEQkP1hgSlk1YiRrZGlIZjJGbj0KejRnbEhle19IWnktbUBkUXh8MD1BXlhh bnctREEyaGopU2VvIW9wJWZWYWVXbWtBdzJKcn1vY1dKJnYxZTwhfUIqCno0OXt6WW0rJVJ1Pzs7 NVo5RDM3MShTUXNxWVZLblVAP1lORmooOChPSzh0Kz96TTdXQiltWk9mOW9mLWxUVm1tbwp6JGYj PEx6LUZZRmEmRHI0KjQydmw2S35APEM9TEAzWmwrMXBzKWxUdDdVSHo1IyR+IU9aNnBfQ0VEKlV0 RSpSRCUKekFDckJiYDJHY0p1TjlzeTZjUnJNTkA4dWV3QkRzR0FReFgxMXNAWE5FZzZJYFotdykm MlUqPmpZcnR8MmkyekVUCnpwSktJaHReZXJ0UjBWZjxlJT1McjR+JCtDNCREYyZOfGpGMmFMNSpK V2JucUIoT1VVbE9XeCZ4RXZwNVp8NzdSRAp6bzNwMXY2WWE4U0ZJak9jSkB4YTw5KmZ+JFRMOFgq e0FDTUhQd0VWVDZeYyM7ZClAYEIqKjleUz0qRWVLSzlYOTwKeitTbEtFNWlRclEydGstX1NLWTk+ WjRgSzspdlcwR2J1Q154dHN8PWRyfS1xSiFhITkqVkVtNitiYilUUHQhU3YmCnoxUklld0J1dGMt VUI3NVJFJG9+JGAtYjBlM0xzQiZsWUlqPzgyZT0/QEVsVzM9VyRuRG9jMkF3NWw8I3pgS0F6cQp6 ZEllb04rTCE9dWN7OEswa29WKjVfSkg0JSRMQGB6aGN4T1ZzbVo+MWNDNTtIbnJDUGVtdE5+eEtj ZmRwbUNMeUkKentSWUpodiVUSjclaVdSQUZwKD9ZUFdJX3E+JVY+YEk4I01VQUI5elArcVV0TGh0 PTFDXmApJmBLdHE3NlVsWjBSCnp7eUNlYig9VTdRKHo8bUZaKUNnQyF+QW0hdWlhM3IqTHBDV3lL PFBLeWI3Y1ZPTio7UEpXJGI3c35jWklhMTlDSAp6dTA4ZkptS3tGI2RuNF9hQ2wjNjUzK348emA/ X0dgVWt4UDFNalNrJVZIb2V6eUE2KUFDPzR8MCElbUw5cEZGWSQKent3MTVuM1g1d0picSZMfm4t Km8odiZCeFd1MU89OXlteXFRSihrYms8MHt6SiF3RmYjTSNPTntzbEpvK2omYnw8CnpGcVNzMDgh TiZrT3d+ajlrQEA4MjxoRVVjcShUYUt8SHImJjcxfH5we3swVXVET2hMVTB3d2J2dXlBbiQ9YXcl Mwp6e1YyY3I9SHJhbVVjRGMxJCshTXBpP1E7cE0xfjdAOX1sTFJzWS1zfGopK1kpZTgoaUMrdWt2 cnp9Z3IkLV92WDAKelNIbkRLZSMkWC0jZG1BKlBnMjAxS3pgJEd5T0ZqNCs2K051ZjhlYSUlYUlX UE08WClscXJ2dW4qbjhgQEQ3V0B+CnpTT2k3N3F6OHIma1M+Knk1REFxNWx0eC1XTGJeZDFNMzR7 ISRzdDhSeTFUbT5xYFNMb1Y1cChxZC1uNn17cHtvWQp6ZUUkVDA9SFE8RFVUYS16dD9SdGJeU3Jp VUNAWD0wUmhYVVBGYGVRUmlLKU1YVndIalFlSnlzN3FqUFM9JU1tZmgKekR8MjEhbytrbkVfK0JG TzBsNVY9dU1FfnI5KmxaTkBNfGcrRDZRbWdjfXUmQUdeaHt5eHpOLVMpN3hMSW4xJXByCnpOQEVm REtxM3VqYTEoYiZ2fT1rJkg9JXtZYVN0S3x3LWI8JU4/enB1VUwrWXkwYmNeaWElM3d8bHtAfjM5 RiM5egp6Ul9WZE5OWG9HYilJOCR+dUU3PWE/OX0/KlFGbyV4TjxNWE0xMz10I0BZU1g2TlpNUSkk bU8kV2FMaykrWkImZHIKeitzJi1PJE5BRmhrP214KVdJSShoSm83b1BHaEZXbC1YOH48eHt7TzBw N21MVlJ+fSNJbXFzS25ecWAydz4hdUkmCnpsNTZ2M1NeOEh5YXA0P1YlaWhQaTF8a31rUip5cmhe OG1yZEdmaz41MlI1X0w8SVl4P3JDeDIjWnhUSXdYVjlvfAp6emt2Tjl4b0k0T2Q5MElHK2A/eEdI N0BCKysoeEhWKyNeaXoqKGJUfj5OeypuV2k4ODBiYTY4d3ViVzlRQCNIUTQKejxecVU2dCg8azR1 RXIhM21VNU1CZDdpNy1MeHtNU1l+NylnKzhXSDtwIUd9ai1zIUhiY1dzKTRZNmZJO2hQKSstCno1 aFEwXmQ5U204T3BIUWMhYWtVKkJycDxWRHY8aUA9fjNANlBBVHE1NkRIOXtpcCpoO05veGB5MTcp XytUUT8tWAp6WS13ZzViUkFoQWsqdUtsbUkqTERlKG0rVkNjSkR0ZF99SDIqYFR6QDRgfT5QcVlG TEwoPT5iKTlmc29KcXNtQzsKelNzKT9MPEA2SFJiTzYrQHI5SUVjPXdXVz1XJkVCRjRjJVlUVWsr Ql9LKG07PzlEWlpgcSZyPHc7c15+fFRQZCQ7CnpUT0NpKUVJZURhdEU+YHIofFlVYXZPViRUaj9o JXBZPHB5NlZNZHdGNiFaOz9MTl8kMiNJYjY4KGYmcDlTKUFUUAp6enZyNEA0UURWZXU5c0pxQzI9 TkV0MjFoYyZrTllieis9RFl3QjE/OURmWi1QZT1vLTc+Tz9+aF5Jc2pPb21odSMKejgjPjI1dldU RWJWQm9eTT9VZlc2dTZBUV9wdDhFTVcjWFJlPjhyVjxxYn5ObHh3SHk7RmEoZ2JmaEM3ZldNeitA CnpYWXdfNnR9SHFpbkpqKms/WGkwSGBVfHJfXz9HUn5mfDJ0RTx4TCl4VThIeGhZKE5eWEszZnZL KlUpfmUlKTdNbAp6aW58NHtzYlo2aGA5a3FCNiVmRFItXyhRcHQ0U3xhSlBBKi0rNyU7e2g9bFpQ ckIwIVYyflg2MjlKNHhBJEcjNXYKellMQUpVNWwjUHluVDlDJnlobVoraTZDan4+PiYpcjtQUVJx SDtOVD0zSzhJUV9jdVFMKyhSX3haZys7eTtJNnMpCnppSjVhQz5FWGlnKj1xcFpwb2hzeXRBKER+ S0BxX1FwenVuSSRzfW9DPnxEKHQhamlBcnpmXkImZlJ9NWVEaElTPAp6Rn0lQ0dkMVRqcE8pUUY4 P35DVCo/TmVQUVNXM3NUZGowQCpRbjY+TUFEPiZ9c2VpayNKbFhSMnlyYEZ2OWBaMGUKejtYXl5T b1M0MEtjZDNiWEc3YzQ0RHhtYjk+USlOQjBMc1leWVckWEl4OzI5Vz5MRjRwVyE0PE4jZ01rZUI1 UEJlCnpDeFFgfEViIyRWMGpyfWFuejI4YTV8JVZHMzdyb0Q3eH0xKzRkPmUpPVBSaEFpdDM4NEJB Iz54YUE9Sk1gMTlyZAp6UCQ8ZWheeExPR0B9KUBFemFnflRZV2NqUTxvfmp5S1Bxezx3NiN9NipV P0xCKmhNQlRpb0F2b2JtRmFPeE5pMz0KejQte3FgbSMxbkk9JV97Y2dTK29pU09QeTJyS31NN3gl b21qaU9ZTTN3b1psNElLSXR9JWp6SmZXJWg4JHV3QkNSCnolV0F1QGl2bTFpPWFhbWFqVFowUmBX ZitadGluODI3IT1XT298dmtLbFVXNndeKDRhJnUoP2MrZEhhZXx6cU85SAp6OXZOfCRgZVYhend9 RUF6QzQjKlh0TVB2RlhSLUt3R2M3ej1hbEkzflMxPT0oZUoocFNsO3d6Nk5VXjFed0ZaJnYKenFt RHE3K3txTXRgVWMwTFNIXnc9VSt7dnRVfWJ7WkBKWmpmellRcSZHQjQqeUxGQiErMCN+dTBhckJR X1lGMD48CnpLSyFufl5GMD5QczNqa0QyaFg8cnIkaGV6PjI7NyMxQT9GXjxNYz16OThNWExud1cj MVdVfkR5UUwwTFY3KHswSgp6VFF4dSNPd1pNY2p+eEVNVSN8P3IhI0BLKD1yU0J6UlYySF9jTDZM S2V5Y2lmdmVrUUo0e0o1MnNSZ0s5YTNmTiUKekJxYF9kdFBiVj9SMXxxaFdjRzdJbmZsVWNgPDBn cUVecnFaUjF8eUY/V3xofTAwX2RqaDE0c25BVDc+NGA4b2p7CnpYTmNPST4mVC13Umt8WElUUENK N2Ipd0U/UGV0WXpSKT5oazNsQ3FkSXowelFITEF5fENxTkEpPlBBKE17ajhzMwp6M1hwVUU+Tm9j JCkzUklERkItN0ZkcT5wJSQqPXBpPVBKaFAhT0d8OGxtN245cHkmUzhCTjByMlN3LVZjN3U1SD8K ej56LWA8QikxflchPHRAY2VPVUtCdmlwdiQ0dW4heyMyX3F6JlJZQHIjIUlnVipMMXkoTT9HUmto YXhuUThyLXFSCnp2YW10Xl5CflI5UnRWWT9nMDVtOVBBPnBFOzNJY31mWXJ4Wl5iczlzJWlCTHQo OV45PWRiJCMrOTRoPSFpODxRdwp6ayROfDZCaiVHQEA+SU5SMC1wOV41SXk4T0E3NHxtO3I3Qmk4 SXxLQFFkemFaaFUwd09ZOVEwbVF5LXQ4d2BwMDEKejkoSnVUYngwQmxIU19qT2h1UDdeWEtvRUNk bUlDJGspYG02TGo4bD4kVngpK0Q/NjJ7UV9MckxMWkEkcFR7Ml9GCnpgWVBTenF9SXBkdTE+P0RE aF9ueGA4WWVFKENWNllRXz0hZW5ee3ErJWN6aUZDfWxXfEJodz0zb3R5S1B4d2BgdAp6d14zTlJ1 X3QpWmY2Pk13RTs1TjJJX2p0QHVgKUU/K2AySnE+eWNydWlKa2VLPWp4S3gmcllAOWZ3aXl1bjI3 RS0KenttQHspejFwV2NGcU9KeSNjJTR8NjA1S1UqcGpOOXtMdk0kN0BmZkIwa29ATClPdGRablg1 N1RQJH04O2JfLUE3CnojSCswO3FkYXteKDF1YU12ST1GTUF7djU2ZWJ1SExxd1AmdT9fOGlmUDNR R2BzbWJ5PiFSU2BkRjskPU4xVF8oeQp6MzxhXzRIUnw+ZVdRWXBEZTNKOXJmbHN9YVFxTCo7Wkk5 OEhBR18kUDhONF90ZkhWM3h3b3Y5O2xiOy0rKnlhUFEKelRtPSEpayg1WCNeMkBaSDE3OGR9OTlr c0BMal9lR24hN2crLShPbFpQMiFqYmVaaWVVR2diIWhJeD8+bGA8dGFICnojdFE1cF5nb2tDVDND K1JJRnB9bG5CUHRpIzEqTW9KMipvLWQkYz1WSlN7VUwjcE1rckthMHgrPU11YT5CPXF0eQp6az19 N0l2b0VmUkh3Y2hOVFUwRU80KXEpK2ZQM3lCYHY7JU1iTlcpRWlhcG4tRDkmPloydiUha2o7ZVQh JllkXloKelRmKGRASE83bUpxOChYSkgtPFkzMjxoJFZPQHcwaDZGdEtsKW5IWDJ0aDwkTTBWPE9z R1lVbnwtRzM2PSRHVD9hCno0JDJRRnphIXl2K05pVF95Z0k0ckI1TlFAY0p5LTUoa0ltSHtnSF8o JUdpQXZ2a2ZnRClKSWludV9gISEtNmtIWQp6LTRiREEmYn1yU3U2QSZeT3prZn4tK0NQUWdmNmJh RUw3QUJpUy0qVnJhM05LQzVTIVdmb2p1RG0wVFhPdjhBeXsKenY8YV5idHhyK0FgNjJpR3l7b1U4 V05TJlNtciRlVXRiU0w3JDZzNlBhdmVOTnQkSXhuaUNAfmMkU0xaMmBCX2B5CnoqJFZDfSRJb2Eq eUUqIUQlckVvezgySW1LSElkUz8zM1NBLT1+Sz87ais7eXk9WVh5YS0/ZERNaVpLQFVRSndUagp6 c2xJUX53e2NTb2V4YzxUKEpIQUFTPE8rV1VNZXp3Rm53JWtrQ0NnY1dmMCswMTlQT2NkPX5VYmZj LSF+IU5nJSUKelJAfTE5bCYzOH5OJVJkYkNXTSFCUnt3cGwyUm5XWXlJc2xRRWBaZjYrRl50d0dR VzB2aHBWYDNgZyV8SEZAIWdTCnprKCk+VDJfZ3pwTnZraVMqKU4wV3JyUjF1IX41K3lfblh4WHNS azkjZCRlempkPSU2PT4jVE8mZDdAZ0ZhTD5BVQp6ZF4mTXN2WXdsMyhJaitFO2N1RyFUIyVqYjR+ fjErMnluRz5XR1Q0UjdtTkc+bXlrTnlxWmhecWZqMStrP0BCYmUKeiNmPFZIOGdmckhTWEteX1ZT QExzaFpKfjZBMFo/cyhfZXBofEwoMzl3ezRKIUp9Kkk0QiR1b3Y+OTIkRHteXmU+Cnp5X0FSKStu b3xBTUA3cTVTbSs9WCgwNFJ5KyN5fClNRDV5bCVrQFFaK1N2ald1b3ZUcU1DaEJ6eEVoKTxNUGpH Sgp6NW1hJnlEYXtoPzwtI2tSNXk3aUVxRSVNWUlXMG1sQTZEKihDPVdpKCEqalNfITg7YHJzXyM0 e0Z7V2l3Mn5ZTXEKem5kR015R3ZlMTtUeTZSX3EmSVJ8N2FNamBheSVjaiZLU0BjPXRvS3tJS3Ul ak5ZNCRPUVhPfFFtR25lRXQpeTY3CnpNQmB7aDVTNFVBdE9+QksrNFl4bVlLS3FfXzhTJG1qUDR0 JHp3RzwpV3B1PDA8QDlEKUNEX21RWVpQVT1nY3cpaAp6Z1J0eGRVeCkxcTx7XktGKzVSV0VKTkg5 SEJyY0plbEtEfkh4PUFnZnVgRHRATGh7S2s0ZW0lKEM1RWheZmJ3eSoKekQ1SFk8bF9AXjJkWihJ TElWdWpeMC0hWGlTN3NCeSNWQjlydHg5cyNQRV5DN2g9a2Y9dFV9biN1WSs1aS17LXBZCnpSRHRT cUZsYmpySURPXjhzYlhOR1ojNlZiYmxIVURNV2JwNnliWUBrRCZPTTU3UitAR2dsKllkYzUlUSY9 P1ktdAp6QC1aKj4tYy1BWndDYUwjMn0+P1gwPj1ubSVudkRaWUdFZ3lYR3gtUkJybGt+a0lRYU8r TGJTa0whbTlVaHsqTFQKeiVeVDxWYEV7Vz1Gd15yQlY9KGdpOSg2Xkp5R19ffTk7MDJma2BpNGwy SXh7eEtNKCVNSW5TWj1zPjRYJEBFMXNvCno4R1BPKWtDZUZrSn0pQ0o5Pl9icVc9bkRuUXhkM19V I0M4MlpeJWlrKzFKN2B0UEhaMistbGR1TiU3VXc4akVQdwp6SmdlQ0ApQSpJYFAyVFV8Xm1gRypw Y3phIyZac1ZfRitIRnpQWnVVeXN6T3IoO3hROGF4RUMkMj9xRjF1ZHpvPmoKei1uX0FAN3JGK0Iw cjJWcCZ6I0E9Pk9CMXxzWDZAdjJKY3I1ZndUbSQ8PiVSI3E8aSZFOENIQXRaKjhocU1QdjQqCnpK cVBaWG00X1deN0g/PHRfYnRZNmleWjN2aTh8MVlyVF4hY19fOHxiU1RMaFlfZE5qTU8yU2o8dCFl SkNRP25sQAp6UzM1TTdxUikkSlE1cmYyQ19YUE4yRG4xTm9BO3cqTD8qa1Y2P0Q8WiNyaT91PTR7 bEQ/Q1ZzU1Q5NlheNmNWTlEKenFGSiV0WSZAajJoK1hybUBAbm95MTh8PSlzMDBtMHk4Yl8lektW OGdNKHJKSXVVeT9LYnYhcDs/d1ApY0BzTT45Cnp2R0ZgfXVIMkIwb01GUF9VNypsK080WDZGcVd7 Zz0yJE94WUp7Wn5mRH40SmdBe0JwcyVLR2deRUZBIXclemlkTQp6YFZTYyVGYz8kQntwcnZtTWUp SmVmbWVGPG9RdWJMUz49VU9xNDc4bjZ0WiRgQSk8S3hNaEN4X3JaJUV4VnVuOzAKemx6bnUpIX19 KllMSUk2fGB8WGw+Ty0mYUNGN2QpMnIqNTBhaklQN2EzdXxPNDtgX080eDwxPTFlKDkoXkgmcWg0 Cnp4aDtTWns/WWo2ej9ZaXJKR0ZuUGQ9T0pfRDRNUlpMQD1BP3I9JGI8a0h5KVZJaiYofXl6aEVx M2ZYWj9QZDdIIQp6KzA0M3hYN3Z7RUI1QXp6NG5fJWNZVztMSFYhTElrViZfeXw2bEUrRjU1STVt OyFhTCZoe1dBfkh+V2Y1YShzSD0Kel9+ZUxqcFleTjIyLWN1ZzlLLShMRG01RVFnS1dPKU9ZNjVT RUUlVU9XRTAySmcoOUs9Q1ledTg2MjIrN3V2TG0qCnpianRjb0w/fkJCXipvejQlWTY4eD5OS21S YCZ7SSljJG1vMTcqSXBfYVIwP0lyNz1OMk1lPC07KHx9dmBgKiZKPAp6QUA0TDhJa2Q9Rm1GJCpU TG1aYilHK007c3stUyF2UUdsZXVxZDR+e2YwcX5oP2NnUkNhOWdYNiNGIz5sYV9uU00KekZTMX1l TTdJbjZ4N1M7Jl4rU2VRKERRZlp1Mzhqens7US1kX0JKX301NGFpOyVsP1ZJQGAtTSFRYz5Yaitp PE9+Cnp7LXJuZ1VzKy04N0goSVlhcEdraU05ZjZjcXtITzdRIXlIZ2NGOHVgVjxhUXRYQ1JyIyFZ d052IVhqMlJsQCtfJAp6b01BUkQlSV9CXiR4bkVPIUtJSihSRDA9UUM8ZllvJDNEKCEzckp2QUhS YGM3K3poMUQ8ODlgUUhoc24zelpHaFkKekBsPks7ZHE4dW5gWHFObFdoOzJBP0R3Oy0rUXEzZFlv ZDY0fE05JCZnclJoVXZweDx+JXUxMkxGfSEmWk8zMDc3CnpRLXp0akB9NH1ZRE9Zb24zYT9DUXVv OHp6ZyU1UUYpaXx0eSkkfHMpb3ZOJXFUUElKYnZDKDEkckc4bHojJSFeewp6dF84T3F7d1FVbmEj RUwhYjtiJl9LPVM+cjAqSEg9V0ZzTXFwSWd6NlZPfkQhckN0MDxrUjZOSylCMWZjOC1OdkQKeiZf O0lqOSRqVTRQOShQS3Y4WUlRbWhHXjdgWXU8T1NCen1CJnQ2Uz01JXtBRihFdlJGckhNQ0Yhe2Ul ezJxaGVnCnohcipZZXB4KlFzVEhIJndBOD03NjBpNWNCPFZ6WWpAPmI9dUAkd1BNPSY3fXpFODs1 KGtybT9SOSQoeWtaPl9VQgp6WkJpRExlcjtlOCswbmRtdXY/TTlhc0BuaXdwJGlDYWBUMyZVc1E3 Uj1jUHQyNGgzOEZURTJ5Z0R8JXE/bnBOO2cKejlxPENpQnBUZX5lJU1KNk9sYShBLUNsKTlEZCpo bW5Dci00d15CZjAhSloyfm9YZSFuJUpyd21XQnZEWiVPOzEtCnpDT35DS0BgWjgxNz91blY7cVlf Jm1+NVRvMVlLJndhK3x3JVImTWp3bGdhWEU8fmBeSl9fQ1hHQ2whX0k5aDJ9Xwp6cF8hLWpiQyRO N3krcTV+T19pUTMyMFpiQHY+RlBWQGcwSD4zazMrSz8pUGFhQHhtVTlSdUE7XlByZlQqaGs1NGMK ekNJVnMka0xPcF8+cHlaJjdCOUxCMlk8O3diYWFOKElxNH5ReX4oeUZkXlB0UiluK1hnNX1kcH1r VmBBa3dpQCFxCnpqO3Y8b2ZQMFdScjExSD91SiZ3NF5oJUxWbUdoQk5pIzg4fCN4bFF5UGVDTXsl bFgtWlVQKzEjbFFTZH1aRTVgMgp6JXF1OEJQX3xIQ052LUg+RmA9V154Jm0lJT5laV9WcU08Qyp5 TFdGVThIcCV5ZHReNX1YbHM7WU9xVGVjUUsqaEcKeiNuaFJ9YD0jJnpXV1JjZytieSNFI20xalQz V044bHRPUSViXndne0U8RHArSilHMSk2UFRQRjhMQnswP2N4TmcrCnp2YitsNUx3fCp3QWBmUHY2 ZG1OZk12ZXc3Wj4mJCFLWTgqcG9SOzZVYUt5M3lPb09STTR+Mlg9NkY7M1A5bTJ8NAp6SmVsbD1q dj8mWk0kP058Y1NtaHxhO3hlJTsofntAZ2wlQkgxc2B5c2paK3o7eGpLP28ofktkcE4pKWdoQjgx fFoKejtRXjJxMW1ydndxMl80TD9ueXtoUEBpMF5FeV5QbSZzbE9yNjJMZGQ5YlhjKnFMOGAwUkd+ OWdgSU82VlopKHY2CnppNUNKQzh+MiQ7QH54dUc+MDxjMSo2JmIhNDw+RGs+dnMmb3t1UVRRVjNV dyMrMzlTKnJ7MzJZQU0mPlRWQGdtbgp6bHxsbm1UfHtAbDx3e3hTcXFyYlFsSVd+cl5kP3Akc2Ek T0BTQjZyd0FjR0hpbz45ZFdudlVQTylkMnZqK2JpKU4Kem1Bd0xSO2tvNGpgfEgyV3ZNa08zYzsy Q1JXYiRpMFYzR3R7OU12QE5AezE+fmBISj5QbkR3VyUqJSQqQEpVZWtqCnp5QCgkIVF4PCNKbDRt fD51KUhpSiQ2TDM8UHk3T35eWHM9UlpsXiU/PTIzSmk3RWRULTUoZHpGV1g8aCgwbVpGNAp6OTdz K2NYaCNTbW9OYD54SEF4S2MyU2x6ZHBrZUErZk4yfVExSzE1fXpURT4jXmQ4JU1tWEVCYEI+PHJi OXA0ODEKenlYWkJ2REhjI3VzO3hjaDZCRHp+I3p2fVdReVU0SHBsUiRnWHsxTU16YW9gWFdgR2l0 S3FjVHNENEdgNXRrfEJwCno1THQtQmAlKmRYRllJNHlROUxRTGB1OzR9eWJtYDBNeVNYZFJnejNg ZyE8fVUhLVktZik/KWBscj9CRGxwNm0hUgp6OTxgaV5xKHEzVyQ3VlcqYVRiZSVxdUFDUDBJOTNX UTRsfHdGI2cmSEkxTHVvUVk4dkw2ZnQ/WTl7Yjd1V253aUgKemZ2MkJ0S0lpOU9SdndsMyVjTzdY YkZ3ODJQfjY1WmxqTUF3QHBeViVnfndhPmRVXj9YenRxSlhAN2MyN2lGS0xnCnpxJWJgZW41TTNN ZG10M3tHXiFrcDY1NHQkKEB0UnorWVd+bmFhaS1uN0x0TnJBdndJKkAtN0ZJeU5OQWNJbG8tfQp6 YzJPdGxXZlNjZ3klR0xaY0BRUSN5NlZicXtnUDBqPzg5Z0kwKWp5eWRXU0FYMHJTfGMyRVlpaV9V ZCNWSlIpRTkKelkkKTQ4YXszI3ZudiY5I1JXSWQ7MypQQEVCJnVtbjNrcVNkJkVDZnY/SjVzYTZE dF9EeG5ObTBla3FydGBJVkpZCnoqVWwkMl9mMG8rQlBITlAmTjVwbEh7VGZqa3F3UCUqZF88amp4 b2dld3QjY0lsNHdUSCtwNy0oPUwxJitAMHIkcQp6Y3g8dXIqM3pQUj48NVI4TkM1VXNmSH5zbU9V d3gla290czQ/JGw9JmU9K2JjWVlgb143PmxkU25gbitkRmFCT3oKemNVflZGXkZKTGJzP1h6YXFj KnQhQippMX1NTHRER0c8Rn1pMHZONDk+aFY+PyspV3F1V01qcFFLSGR0MkN8I28yCnpebzArZiQx YSZOe1c4KTxqMD4xQntXfE9WU18xUj1Ye3NyeXU3UHVNa0FjKX1IQ25UN1dCWT5FcnNgUTVwflJV WAp6RlhrSUI9dzl7dTx0eHRvVXl8cEJBMio0d2ROPlByT2EqPS1FLX1wcHBOO1VEIWNGP1VjWnxX P1pKazhfO1FhVWsKemJ4dCg7dFdZe1BeKlV8ZjhkIShfPkskS185VnBxP1Y5NkFGcVpmT05YJHZT VXE4OzA9bGxEQ2BHb1A5I3Jfb05YCno5JiQlWnsqYX5BVHZjRS0hPldndilPKzRLcnErKTEmKkBq Y2FhZExCNHVYdSRKckR5bEQmYHQ8ND5mSDkwTmMoKwp6RllHJTlsIyVJNGVBZHJkUyhFR3sxQXZZ OUJpMFV8dD5rJWhzPUYlOUUzLUszcXZHQiMkMWxxamhFfSVUWDNqRSYKejByZk10T3lRfEhweCEl KjZXflJ7bkB8QylHOWUyd2JxOTdsRzIxUUlScD5vSEB6OEZkYzJmNE90S31QSThXeEkyCnpvfGtt eE9iVzB3T1coJmplLTRYZTk5ckZxZllZQTNyJU1SMjhMKVY/QXcqRDU3WE1tZGolQSQ5Z3pqcFkx WG9MeAp6alJ6JnEhUzZvfkFOfH5yZDhVWSglcVlSUTFtJGxKV2EyPWhHI3lIc0dJblhgNkxNUjlT PX1DbWxpMG9SVmhlPHEKejJrRENPbDxPRnREKWprMCktWlZfUGopWl5fO3c7WTFxdDxvYTs4SjE4 Z0psSypaK1NqJExeKFFTOHpraXslTlRzCnozYWtlcGBnWEc+LVhvN3lGRWY+fE9Yc2c9Q0A8JFVK LWpFWj1hUVdvUHRCZ1BVeFZ1PyQpNzdYNy1gX0Z3a31JdAp6WjdQZUF5cW4kcDkjKm1FSVJoQnk8 PEt6c24jV1pTQFZ1YCY5QEEwUVR0Wld4XnxXVUlWMiFKJWBAdTYhaCpxPWwKenNDfm92bmt4TU1C MWFPN1RxUj1lPEd5b1YhPWk4cVU1eFJqQE5nNEhFPFFieWQ+U2dZUXs9bGhHeXx2PFl2MyhQCnpt fVlrKmo8YzBGYH1gblRUKHpqfGwyPTlZeDU5NnMmTnNYaFVpQVYrKzZ7V1ExcT8tMkdWViZpZHBE UUJtNXw2MAp6MGxPRTRDWlJ2cHpxPXw1cT4ySWxsVmZ2RSEtfmZ1cj8hQ2VtTHJmUzd3am92Xnlq XnxyKyhjX3lEO0o2ans2PnoKentDVkNGclYpZVI7PmA5KntmYXM0c1k8QDQtcEFjPz9IVXB5Zl5m LTFORUsrRS1zSEJpO2kjRD0yQ0MjUiE5bkRACnpoP3h3STt7YX5OZ2VCSSFjX0xzMzZtbURMa2BJ OVdjSGN5eEFjd348bkByNXYqWTBYVEdqdlZTIXRHK1dsNSpPVQp6JVRXJWRSJEYkYXJuZzxENlc4 XzQ5UGctQ3VzXlVVK0dwTis4cSluU3ZPPCp3aFVCJU0mUVI9PHsrX0Fgdk1rUCUKejgxaGF+Nz0k bVdkTk40SjdZQDAkRUY+Zll0N18lJVJhTj1HSypaeWQ4N01pYDdMZT1AamZKO0BieyZlY2x7ZERe CnpRdXdefis9LW8xPnNZVT5SM3skfSkpMEVkRlRtMGEzaGZtUyUkYjwwX3glPFZFeT0xfmJTKjJK X0YjIyRLYThLcgp6SVg9U1oyTllXSD8lVXBHeTxMNnNOJkttIV84Tz07V2luXlpOZXEmQ01ZREN8 b1hFIX4pSCN8WjA2YlgtclBJcT4KeiExQVk7X3s2XmBmXzFsK19eWSk1MipIMiFJPVVKM2tkcE9f SjlTa0cyZVFEbVVjbm5lUXpXZEt7PVM3cCtxMD4xCnomZmBOUjtPbj41ODcpWHN7OUYtLW9SWEQo UDIjTVhYcDVPY0x8RWQtSj9FYkVvKllhdUtPRE4pcEkzLTU/LTdoQQp6JEVMTDd4KTRyUSF3bW57 Mk8mUHN2KnZeUEVGbjYrcmNrUFd6a3ZMZ2pgcj8jTThpNVkxN1hYcGNKfkBfY25QaW4Kem9zdy1C VUFnIzMjNnhDVEFxbEp3V3E4UClFST1PNl47eHRebypTLSlBeDFMenlae3VUKGYjdFdBUVdPWndn Izk8Cnp6ODtRaEdBLWZCJUA8e1ZhQHtvajQ1KjU1JHslR3MlNDIzQD58PDBeKiZRMTRKQ35sIVlp MEkqKTQ1K15vdn42Kwp6czM9fGNqYH40cE9+QTMpcTVYRCNyQXhgK3ljZ09YKHZMZj17QCRrUHpP PnMoTDRvcElRREltazg2IypZVkBobigKeiFJXiFQPHdyNj1wRTs+a1QhQWxxZm9jKSV4N3hqIVhU OXU4JnUwITBuT1pkckk5e3F3d3RufnZ1YyswbygmQEkrCnpGZl8pWXdQZX11QXVZPz5AZjZfaiRy QChSQzNfbSpePHEhVj09azB5LUNfSmB3RkU7YUVxWUBCWWBYUHVfZ1JxYAp6TkBQPG9eQT9qbWJZ WUJNO25vd3BeUSQ1JHl1ND8lakImYnc2ZnNzel98PSsjNTN2WF80bWB8fTBtVmZ8VCl9VmgKeko4 eVo4WVMyfCpyMUtTe1p8Mk9jUn1+UjZxellVcXpJSENtdT8hM1BvKFMzNV9ORj4zSSM8K1k9SnFT MHdXQzxiCnowNlQrUU5+SEJlRytCU052aG8/YiszVlF2I0cyI2soVzMtYkd+fXBeJXRWSzt4VVlt Q2J9YiR2aG1gQDdwaExlRgp6dSpDWXxfJjNnRyZVUElVTVIkd3lVYkUzQzM+cj89c3s2QWhWakJJ Vis2XjRaZGR3VFdKazstejRtfDJnSmp6cz4KekB+bH44d2Jva3NzaUU2PnJKKXRIOG5EPHtlOUtl akhiSk9PT0NqbStnbj1UWllMVTJIT1BEPkZjKVhsMlowVHZXCnpvI2ZRfWh4Xlh2NXZgZFZwPiQ/ MEgoRkhoVDNWISlFdWBzTnlBZ35eST1IWH5HVD4lOCReeHRPKCp6fCk3THRtOwp6TFRHNkdFM2dQ T2sxaSh0Pz49S1kwR1VZWXEmbX1+QEpTXz9ScH1hVz1vTCtWQShJfDFqd3kodGc5Jml0MlpHN1MK ejJtMmRTcFB1OU9TTmtXQ0hJcHNmQ2F2Jkw/QnxEQD0tXjRqYTk2QWwmKiloVXZ3KFc4YjlMbnxH OXEpbjhqKGh8CnptTHFiVVZveiU0dUw+ZF5pN2g9SUtUWShYPklINiZ5VFd5KnE0fXt1LU1IczdU ezdLJHA0aXIydXE2bTZiaU5Aawp6UTJIRTRsJT5JTXpGdzNlIWd7TUl8M202eWJxJj1DUCklailw N1doNHlaNyhtM3krQDBUSDlZQ2I0TW5tJihociMKenJ1fD9zWXsrRUshPFZ5a085Tzc5SGQqbFND JV5FTDhXWktXSntjRmE4aUY2US1NIUJhPDdBNndnQm9iRXVIWGt3CnpiPjBBVnVOQWxWTFBWRlpl fUMxP1NRZlpUMCpwQjVjZnRAYjtfUHQ+PCMxQjN0OzBZR1V9b2Z9QG1HUCsqamdhWgp6U21hfjYl T3h6OzZSLSl+NGUtLUdoLWFQfCMlJko7QmRobWlVaXphVztqIS1hOE91NHhWQV8zS1ZaYSFWJENe JjAKemNhUjVyK1V7fHE0USZaaCNHQlp1PG5ab2plfmhedk92MU9OZjZITEpGaiRfOXk0I0VHbUR9 LURDfigqRVUpVENSCnpERWkzZ1N1en5QVSpwR15Jb1kwNGk9QCRFQz11Wns+entxKDk/TWdpK1BE fDZUQXlYbW9xMUxzU05sTU5PfSZ8Xgp6PkMrcjI2Uz5NentrQyQ2Jlo4X1Z4K3tmQyhQMj1RR0Z6 UXE8TU1VOEQ2cSFWMF4ob25vZzRhSmVjfDxkI3p2WHcKei1OWTJMZEhQJlNfMnMqV21UcXM1WG4k MW9VczhhfVBEPXAtajNrSS1tYX4hOWhxUH1gaEJVSnB7Yz5LJV5qKWZICnpJfiZzQ1VyR1lVRDl5 P2YqUjdUfCskbGFvZStoajIwcihUXy1ONHBvV0lXTWd6QF8qeEw9LUNgSXVAPHxuUXk8egp6Qkk1 KFJwU0chdz9uWXlaJG1Fa2Z4eXctO3l6Rj9PUCMwb0U9MTtVWDBHMkgkRUg0R2tQUDhOZkhRbyRV SUx1TDgKemk/ZH5ra30hNkZMZUpmJHI+TmBwWT5zWEwkV1JUdiZsTnpyRnl6RlN7VyRRXjUoZ3RU O15TNX4yVjhJTU53PH03CnpgSjkyaEleJGF9RSh8KmhkeWF6KjRwP00/b3NYO2dDNn1YN3l+PUxI cXcxUW1NR2BVdHE9Zn1AOyZ1dXo/ekdHVgp6clN0SFVXYDM0Xm1pWF5OUFIwMTdsJEYrYl9vV3Ez UGJtVlZvZ1dVWlpeKEx2NjFCbExXYURSQ0tmNWB5UTFeX2MKek0rcyNwNiFpWkZZTnp6fW99bXFq WEdzYj1AYFIzTUBhODlUdT9DcTAjZkVaP0lLTmVHVUlVWEprMVNPKk50NCtZCnpNUGhXYW8qRGsk ejR0ZDRBaTRvX1lgPksxTGpmVUN7S0JBJm9XbmQkUGo3alVpZGYoT1pib0c/V09rLWNlWElvZgp6 SSsoX0dtTko1V2tkdThLN2RkNjV5JGd7PkdoQkIqQGlFNW5eRWNDSWJpUzE0MT1JN0EtUXBEXihS WD1yJHRIb28KekRUZXxZSGkrQiNMYHV6U2FUUVo7dF5RcVllYUtKSi1QUDdUU0BJcnUrcTI8QUNE c1N9OGhNWTJFS0ppdyQ3eiZCCnpucCl5WCN6SkdySUE0fjAtZjUzWWdraStQRmsmO2wtQ1FqYWRC NFV9Jn5tJXxCYTZ3Mk9SdX05aXFlX0NlMnM7Ygp6YXlnR0NYN3QhWlRWI1R0WiZOQnRCbFklVHg7 K1k9Q0JBKCE9NGBVR1c/Qm8kSCEpSFNMM091diFgKjRoQCRZYnYKemE0MGZ3az9FX3MpIztYSFFv dlQ0KU9Eal4mbzM9fnU7NmI2N0VaTF87aDRrdmVjY2MxLV8zUDNqaVFBTVomMDVUCnp3Q1Y5TTB1 WDRkbzxpYldyNEhYe3N4KCRnQmk4X30hRn4lU2IqJDZCPnJSdURtVm48LTJVJl5vPygmYzJKclFV Zwp6QGY/dTQrdFZXIWhqaXorJFROQn5fPWJ+T3F2RXtVVmRaMj9zUWN3Qm0jclFAcndJQzc/WHtu X1J6QlpeXkMtSDEKendWXkAmN15HckRBflY3dl9WcWElODRhKFFlalF7QFoxZEhqUjE1M250SEM7 VTApPHQ3MFpPPEBqXjBASWhha1hICnpmN2Y9akM2M0RYO05ZYlQoTVQkdSMrMTMzayU3IyMjbjYq JU4yTksxTX5yajIoZkF0Vyk+Q0E9dDxXO09seyspcgp6MUR1YE1jSE0pKVhUU25HOCgxfDdKbyVC VXoqRVRlSV4+TUxuQFBUK1UkTDlBRHJTU0U8RnZOMHd8cURQdn1QX30Kej9AJHkocSpwK0lBWlNI QklBamVsPURjYHBORCFncXt+LXpiIzcyOzFAfEhgYG08V28+PUZJdGtTI004X0EpZVYxCnpMRTw1 M0JZWnJmST83PXxNfUxifWxRTjd8QU9mV25nLVg7RkQtaEohJTFqSStyflc8WTJPVWZWJHNSWm1q KHpxOwp6JG84UXU/YCgoMlVsQTMhUGwyNkJocCNgdiNGeGg8UTg8bX5WYVoyZ1NLSGdyI2AmKChM Jj4oMU4jOzU0bj8wZEMKekx4TU1nRV5NITxwUkk/ZUglREJUS2wrfChKZXNeflRPcEU1Nz0hc0tu cF58JWBnRXhQUV5RMGRia3U4c258SkpjCnplM2h1X1Y7X1F+KkxXPiZHIUZ7NW5gOXcoSWcrJlJO Rn49TTZXMEYqNWRtJXpKa0Q7Xllld1YmaHEtNHooaD5xdwp6YX42LTZodjIjKmowTmZJNXMpSUM9 N059TlZYSil2ZGZ4aTl2ayR4KWxOMGBQX3Z3dkpoXlE5YkVzO3FFZy12SzEKeldgPFkxJX1qQ2Bl JlRyZUJrZzZqeldxfj08ezFle2FgUCtSdEJsd1VDbl9zR3hRRzFAO2x3NTFib2dMeSFvSkthCnp8 RSY/MD15QUxKVyFPcnRPcWh5aSRhRDAkeTAlaDgyd1lmPTZMSHEzVWFPPGRXKkloUndDeCpkMCpw UTV7VCQxbAp6Mih6SHQmZjFLOGVJPmowckYzbVRnb3dZY3R9XiNaeDJtVUlXXjZeazNJY0NheVRp T01qb0VeYUVaPnhVJkcyJCgKemxlPGx5YU9yd183NnFGektLJDU4ZFE/TmM1LXtJcCYrM31IeXlr TVRUVU1mRHgjQG5+NVQ9PHlSMUdNcjloWlc4CnpfYkl9VU83TTd2Y2gpRXFxJEF0cDIwcylFcEkp Ump1MUVsT3s4YzFtI0hzfEFEc0JtWChkV140QExkSEFpNUhNMwp6Q1l7YlEmdmMycXpHUUFWNkhR SEd7VGtuSSk1P1BYdzBRalJqQz1SND4/Rm1XUiUoLUVQR1ZfTStoXjlgU0lFPDEKejRwIyZCayMo R3w+KUx7P243MWt2c0ZoekczYUxUZitzbmZNeUk8S01uNSpva2ooSWE5Zlo7MiNGJjJJJDhUWGNT Cno9KWZ8MFRJJGAkVjh+SmFQcGNCWGxaUTx7a1VqfmNGJVhfXy1wfUhyJiFHcUE1REM8SVF0WVRS Xn5hZ351cn5efAp6czRgMnt6Sn5pfUA9PVo8bFhlRypySzcyYkFgeyk2M15MQ05sWmtALTR+aWdH e3NJMjBYWGszP0ZTVmV7b2RuZkUKenNTaDZmeFh3RjZYaTx+fFczNjhMKEw7Ozcje1JMKyhOQE9U KHxPbjg2TCQhNyVIWntBLVpZMGkmMEQqPVJPO1FUCnooTW96Ui08VXFUKF5YRWZwN0VhX01IRFVq U2R6bERgZHlVbHotKkdkIT1WVFY4YSsxSlcmYyVlUl8xcTEzVHlOTgp6QjttfD52R0RqIXdMOT9K fDhNR2s2OXxHNCRBdnRgPzs2KXxoVndwdG5QKSZ5dD1UcC1uamNtTmJPdGV6UDtZK2cKekd7eylf TmYlb3Y4RlUxZCNjI050Vyl4SF9EdkJUZHVoOFFFYmEjMV9gRHc/Z0ReYm8+JXMoSnRDRG0+Y0Mq MWx3CnpWJWdNOFd+NENJM2NyfUZNV1lLY2V2RX4ralhVI1koM2I3Slhze35fdmJOWHp6RllrUHpK ZkZuMERvQWs3PWJ+WQp6PUIxSV9VbkpDelNOZEBIdCNjXiliQ3kxT1h7STYpTWBHZn4ocSQ2IyVf VXo8KUdze2xzIUtuYWtDT0NsYjFwTUYKenQofldgelFvcF4laUZfRDgyUlF4SHxJRn56IXEzdk9f SEtfaXBJRyRLVyRpVmg/MFp7YnolK0hsWDd6amFxWWs5CnpyamdXI2BaUH16dXJsYzA/cVc7PGBW ckxhS1V6PCVlJTc9cm1SZF5QcjA+Umg4bkA5cjRwMXRxSFMrbzQ2KU89Ngp6VGZiTSExd3dwZT5J WDckdVlqJjYmdW18c01LdHRxPFR+LXA9ZT9UI1RgVChOTjkyQEJXWCh2NXFSPUNAZWctNGcKejtO aFB+cVpUKWNYTSpPUUA/X0EpaSpKSyVVSVY3enpETnw9KDU7Myh0aVFEZmJWKUl0PCtBPjNYbThe fXpSd2N5CnpRV1Z1Q3AyVl5XaEcobTApQEJQSjN7X2dsKk90MSlMQCpDS15oUnFxTmszKHNjNzNh ISQoU1ZTPFgmMU5TYSYjfAp6TmBOU3lxJFBTZ1FQbSVXPXhrTjkkPytzWUJLVExCVUNGeS1nUypS JmBCVDQyNyR3Q29nc19XT2tFbmhWXjh+YlYKelc0Xjc2ZFc/I09VbzQoYFpWZ21UU0tOO3dpPHdg azJKXktYIypkXkVUR3pBfTY3Q1QxaSE0P3ZVNCkkdmI5PFF5CnpkOGktTDhyS3RFRWh5cjJYbC1J e0E0PkJlTjJXYCpHaS07Xkg5NnVwUVV6ayppMHIkeXN9QVcyMl8wQjZ3JGlZbQp6JlRXVUEwRW1R SnA8c0JOdyoxWn55R2UqJXIodX5VWk0me1ZkJClKPlZ5JFo0alFKa1FvPHQ5T3AqTnQkZEQtRUkK ek5WRUVBOHRvNHdDfFBJdlhJJmNZKXRze2xNUSF6PmtNNWVWYnElPmROQSlCd0opREE+aFAtYkJR PU5jYGlNZSp8CnpOJHZwLUJMOC14ckdtKDFaY3B9U3g8KSlCN2QmUXZZWDV7VzdXbzh5MWlZRWh6 UUVHZyRhN0VSbWw9OzxRa0RLZQp6KjY/KlI8QkQ9Ml43bSpxdFkmNTVnajc/TEswYW5wbll5VD9j MnpNQGZzVj5Kb3Y2JVg5QzZYIWBDWUBnJDlsTnoKemVrfEY7cmFrezNOTWY/Ty1Va2BNbEY+PVQp WTN8a2VFVUBUalg5ZVM3P2ZhVHtFWmgmIU10MCRIODVSPW0rTXk4CnpzMDJ3TUVlR2l3JSshMjU+ fUlQNDN+ZkhoXj0pfGJhT2JpQjVMdU91bVdfLV9OaW9wcnAjfXxBQ3BpdGgxcElJYwp6aENqYWUw cHR+V2tMQjdJT1ctXz9mUkxqJDxeYkwxVi1NaDRqdTMlZHFrbTMwaj1ZaUklLTxZMEBVQ0JPaThx RG0KempxIUlhaXpqdVZReW54ZmBGQz1UaiRneClKJURYKkdGJC02MT9MRzllU3IyZnlBTTRUSXxh UChXIVBsJS1qKEx9CnpoN3hkSUktM3RheCZlQSp0T0RHMj9FSys3bCk2NypBK3pyNU5na0wyNik4 ZWY9Rkc2UCQ0RWR1dVdRZ0VCRH5RRwp6YmlpcV9qRXJ7ekVHQ3JLKkd7UTRkT0hDUV5QNU9NRzZ8 cilqdkR5fmZMaVR9dykhOC1SQ0JyNCRiUXdPKTl6Uj8KemhIa2YjNnwhNjBOc3AkQEpFNiV8cWx1 ZFUxKVlLLXlJPFk7X0R6bHA+M2F6UCpyNzkzajJgUSVDenhzYXJufE54Cnp0bG1pa0pAQk8pUChM RyVPWGFXVzFAdHEwZmZaYDlGZU1CQGE4M2AjWDtod09iS1lsdWktXzM5KnVUNz50U2M4OQp6dTJJ e3l6QztwUWwhRChBJl8pX2A5dmRscFY+LTZaWHoxUDtKM0VJNSRxcU9APGVzbzZEIXcmT2BCR00y MDVGZWcKemJtWlQjUGVtT3QrdmZCJDV5Q3p6PmdFdVBaNUY7ZD9rVSZxQT1La19kdGBDTEBCSXBD LVEmRiNtNG9OQyFXYU5iCnp5JU1LPGZjOHZ3IUgycHxTK0tiUnhqK3FvPkczYFkwKVIoZDlYZGM+ KHpSTnMzYXUwdnUkQ08hS01+aEpObGdzQAp6c3tjK3V3R1IrcXw3dGQyMy07UFQ2U2pBVTczUlo4 PVJlSEAraysjPW94ays4QzczTzh7eGcxa1JPVTRoc280THIKeitwMiFPLWJLKW1tXl5OVWAkQDZ4 M2VIR2U+QDJTP1o8KGZke3s+KGxHOUglVHU5QDtKME14MkN5YTVEe1F9OEorCnooT3dFKEpuMl4o QHsoS1dqdzU5UGFUczc7VXJQZEJ6LVp3YnNBfitZdVAxeFkhRFlGaUs7Mn1SWj8ocy1HWn48Rgp6 KHF3PXtKfXdET252ZkJvVFVrTj5CRmZMKStnV3xTZml8e2oxbkx9P287ZngmKVIhTzg3JnBZfmww YXpZcj4me2YKeiR8fnJxMWw7ZkNIZ19abUZYbjVzaTRGPj0hOH13KnhLKn4jZElKPDhtUjRQczM4 fVVpZ15WcVE8K3BYa3lKcX4lCnoyRERneC0/RG1ZeV5rfSE/MzZnK0MoeWpZSkFaS3JeYUAlVipE QHlISio5OXZ6dm1gYEotRGIpSyorejdmcktMeAp6TVowOUdSSSF8K2ZAZWgremYwOE5aJTZxfldB R2g0dio5fX4oSFV7cWkmKU1QP0o9cDFvVHIhZWJjM2JZJiYwJHAKemZNWCg7KWR9QzxZZHNMVTBs RmdgcX1EOCVoRCVMSGZ0SFI5JlJRcXxhRmxvN0c8RGd1YDEhZXY8VEchd0BqSnEzCnordHFzZmQt cXA+ZFBib2F1Nno0fFBYbTA9QTR9dml1PlRteUsmcWM7WjUyS2coa3VrPWNHMUA4Qmd9YGNiSSY1 dgp6WSpudzx4MV5LTW9jQW0zdENZeUI5Jkl+NmdRYUtMYEp1Ty0yb2omcjB2KUxpRigmaXpvcmMz IU9tZTFBNnpNdm8KeiFMaGx0IVgyVWV6S3x6UmplflMtc0B2aD5WcEdhZSp0KGsrO21iT0A4bmlh LWR+a00jYFNKaERKfSpHQyZsfjVwCnohJSQ9ZUEzTU1vK2gmKUhudmp6TyhDTSQ2XzBrYEpzcHNP QXN9MXJ4d3pnaktJQmNrS2NLcihJQVNEYUgpbFFGcgp6SEwwSnBEOUZDfXZ6VEdRV1N+JG03SEV3 bXRyQEh4KkVXUGhZMUdhR0pES2BXPSMySnV4QGZ8ZF8mSTZ2ZGFEbTgKek9fRWZlI14+T1FKck05 MklERlp3KUMhMWRRWXZwcS1ARSRHVmdTfUl6PUBqfCZ8eHlMUjh7dFZgSjIhZlR4WjMyCnpNYSFy KWVKZGxweGlOXjBQMUgkaCg3QSlWWVRAJSYhVHoxR3FNUXpudTF0d3pjREFJRHkqfEYkK34pfjRo b3kmYgp6bnw9VHl6bCp5VXxEai1XZkMwVGA/IVB8WiNnLVF9KDZmKWkzMFY2aTJ9cGVgelNwNyMm Ji1QZjlae1NQQU9sSyoKenM1eGdnPWI1a2VSTWYycnI1bDg8fEsrRHN7Pis4I1UxR2xPNXdgXlBf KXh9VzFXMHBxKEI8Rz10YmJVJkB9UkpkCnpmK0N7USFKJj8kYDROP1c/enllXiNkUGBhcCltezlG NzlpZihhMzU4cGh2UjJTZURhRCNNZnwhRzREe2lEVEE1dAp6JGUmcyFgJUpPY2tfeDtTYUpeSSo+ O1R3ZHh4OzRaaFUtJjV4ZlpIKXozPUUoZCN0KHtJU1Z2V0s4PiVxKEhnQEsKenhiS3k0RDUqKT0w fU8yYTN9QVJMdjNZNyt2emNNeXQmVXpLWilhN1k/QjNhKTNvZXwxVndZSllabVlzZWIxKnsmCnpX QEE/Z3hJNkdgM2MrYkYoOUtKbnhyJXxnKihSajlCRCVzVEt3Zm5yeE9wLU9EKH1aRzFBR2x5ZVYz O3VTTXE+UAp6emp8RXVibkVmdE5ofUFAYT8zNVNtK2skSVVtWHA9MGNxQEYzS3BpQjEtOGxqJUFh Vy1laHJlQy1Ya0clI3w1dEoKek5lOENvUmZsJT1KbHhaVzZiX3N3bGdIanp5UkFnentTPFA/PF5a UHZZPTFVc0kxNEJnTTVfcGZGezZTPS07Pnk5CnoqSTFZdzVLKDBYVm5qQWVrT2A7fV9ZTldzN1dy VmdnQDcrYiMoQ1RocE9OdGU8cCpPKFJqQX4oK25xU2hURDM2Wgp6T2J8JHxrTHJOQ3NPZmVSKk09 TGRmaGNjVTA2QDxjJXIqfERmcExvNiZUZUshPUU5RzE5Q0dIZz17JFVOPFVeTjUKekg1T2FNVDA1 NWoyLXNOUjB8SjtlUFo5bFNMbUs/biRIKllPV3NBeWBRb2RtTkRxLTxScUxIJVJLPyhqUzt1Pk5v CnpnbSZsKSFic3hvIWRVO3JnPkV1PSVpWj97eWd9T31Dej9ed3h0Z0pyeytafFgzKFpXYiF6Yld6 eXIqdDMyWVpqQAp6JUpmUlVPV3g1aDchTTw5KVkhd3NfSnNBUXIxTj1LYjl5Umw8JnJBbUtmXkNY Jm1DN1coPHJJVXJfaXdzSjVkeXUKeikocWZMdj09JVg3fWxNamFDOXozN0tofiZSVEZ0X0pWJGxD R28qdHA+bSolVCRIJnwqNn0oZm1hUVhOPiVARjxTCnpQSWNuTiFWOHF9WCQ/NSRHIUBFMV9JK0hL PXlPOTBCLTJhXi1JYCFGe09tXztsUFBmQF9CfW1VN2lufTRKbmdBcAp6JHFKbDBlSUJmZ2FvUzhS Z2J5SFdJJDFWe0U4UU5+U2FofV5SPmVzaSMpOG4/OTlsWnI5alpxXjtoc0owbkh2RkkKenBxVnhj JEshOXE4ZWdfbyVyWE4/Y3toYThCcWZibkBSeiZPPnp1ZDRlVUFYVmRBa35QMjBtbzxFWGRKaHBG M1JYCnpzZHl5UDd9ZHpyP2BXIX10Q2VaOWM9OXxuX25fRi1gSEo7UzJjUTl6SClye1I/LUk1azdh aTVGMGxgVFZ4fTgrYwp6YURVVTZjMlpoQ3dlJiZ7NylQMj92aWhDPXhsd0UxN3p3MX5GJGFSbHVo cF5BJjF3MzJgQWAtNFpKMn15MGZmWmkKejk+RDN7MUtiSDRQR0c0ZT45eXdTdDVJe3VReUwkQzZH NSt7ZUFLK1kzOS1jVzk4PSRBUitsPyMwNlghIUltNVh9CnplPWgoI0RqP0QwWEVYe1o0MjJgfG05 QyNDRCk+eXMtNSQ8VilHVnpqYmxDSHlCVDkxV0FgRzxoZipnP0BHbD1kTgp6YEozOXIhan5yQXde PT5KWnA/KGxyRVkxYS1lZCgtaX5Ne35DPFRmTCkjS3NMYz52O0RIfmM5ZyVCOyR9TTI5KWMKeihX IUxIOSNrT01gMmdjLUFaTkFPPzI7I0ZZT1JQZnorbF9TclcofnpsLXVIYjdfM3lje0pjbFRGTnd7 dXg9d0tgCnorXyUrbzM4PSNKZUt5bThfOS1MeWB5eDVUbHl1MVpSKFRQaU5zRmFDQzYrM1kqIW12 KGQoI0l2XlB9IUlVbUslYAp6QCR3MWU9cX0/a2pMZzBSY0Ilc0ROeEpUPChUZEw9VHFLRWxZMip+ S1N7TEVVNzNob1R3LXRGYnIlailMbWpgJlMKeiRGdVJTUnNqMzlvITdJfGNDN0ApWUwpPlh0I2or d3VtXz50UVV5YUQzNWskczZ1eGdiWFhnXj84S3RqITwmNXF1Cnp6REEkZiV4Nn10akZ7aTY0UGNR NT9RMC09PDt6ciZCNWRlK0hTfDNwdDFfN2cmZkAxX0NIO2RmMVpLdj04MSkhZwp6JkR2d1RDLWpp NzdZa0U/TndgbXt0SiQlPHNaQVc1JEd9Sll7JlB6O0YweW8mM3A9VWFUNCNMLUZqdVVvYDVZRXoK emlEQFJaXjFXT0tARTxJUFJKZW5ea1o8VmxgQ19IXkAyZG1vXj9KcGBKR15xNiYoflFaSmtTPFZe MEErR18hMHdHCnpQdm9KaiFjfVVzVD4wbUt3PztCRFR3eXRqR0xwO2c3TkpgZ1Y7S3BEYn5URW9j Vk00WVFtMCREdEx3eWUwJU5VKgp6WEVjcWNlP2YkenY1M1JodyptalE3UFN9UE80Klgqe0tIc2Mk aTVaTihOOGctVE5BTTJLcStwKG1QTVJvRyhtTzMKekZoMjtoPEMtKztmRzNhNEdzfWBLTWhGPksk MCgkNkJrQk1lPWwzKH5YT3ZoLU81PUJiSTZ0S2wlNSEpQXZJcnkrCnpsRExFSSExdFZyQG1vR1ZE KWhpdU5zUUlYM200Zz45YmQjIypDfGJGSXphVDNyPTchWDw1Z01ycVVLaHFMeT58dAp6LT8lfmEq NjZRVTxZIyVJVUNBfSYoMXd2eG9FcnNhNDA7Wj8xdXA8YnVVM1gwTSVLTm0wVEZHTGpaKWM3KnA3 NTMKemJBbCZDQ1Y5SDBoTV57fWNSejk9ZU9UVk1kcEB3YkJKNUFSYHBHTHJOMX07PnVBSXExODxL V0wjMUZmZXU+a0klCnpWUEVSNE5jP2t4WnNfTVpDPVVedERYR0EtaFRqbVdma2tSSWQkTHlMQCpU K0smQi0zT1QqUClBKE9LTlpUO1dpSgp6PyVOUiszWDM3IT1ZbU0/KkxoVW1lVmNDSW8rOSNqQUA0 cW5OOE1Iazlpc0tRXl5CT3w2R3JfO0diS2g7RG5ycXMKekE9VCVIb3d2RH56WjB9Wm5Ud1ZeaCRM MjJgMVJ1SiVHfXpOaHluTTluVHk/Pm9nRlU4O0tWRVBpcG1RJFNGaFF0CnpnZGcjIShgP2JsQTte S1N0NjFjczhRVEA1JDxXUWxESzlsXjxvdFFrZD5qKGZJcWw9U3B8Sks/cSVDIzhkM35uSQp6UC1f b2dCWTJzQSg7SEhObiRZQGJKRGBrdW1mRV4oPzM3OCo8UyZZdDJkKWotTSRqOHN1dzMjNkUhbEgx eHc0PWQKeld5dmNmcE1ZI2c2blghPVlpJXNAVGVIelFSZTZxVzc3P0A3RkA1eVFrUm8jQ1pLTitu en14QmklSE5hJnduKn5VCnoxMVBFaDZ6TjhYSzNtellWZ3JvKWVuSV81N0czSkRCfn5gcC1mNU9q ZE4lMEBMMnBqSXl+cDdJRjMjcHZgQzBjYwp6WEtjRFlqUStZeytpZExTSjVoeiNjKzUqbERZd0p6 I19SM1lLJDl6fVQyNmlDLXE+ckFsZn07Z1orXmI+RTF9byoKejR7dCpHVHQtNXoxYG51JUoybFUo UFgldiFHI2RtJCV3MTUoJjZoWEV7RzBQWGlQR3JXdilGWEpHQlcyPz1VTWkxCno4cmN4ZzR0OXdF ZWd+YilLQlRYKWtZdygoUzdfbDBIVDgka0AhYFZ0dztjIypoQnNgPGJyfU0teDU9RzlEIXo2VAp6 emsxNCNKMzAjMG5BVHBXRzJYMnJPcnZfWEthI0IpY14ybWg7M3stLShSaWhFV0ZqRy1NX3Q4MV8h b0MpYEJjVmAKekFBXnBpITVvZk5rfSpMRl5OUkxFKmIhNz8pTHd6QkFFNEoyQUg1SlhnJXkxQDhv UnF0PzJGZVcoKj1ifj92KT02Cno+fkJWKTYhIUItcj9rUmw1OXJPMjg4PWo3YGRvaiV6dE9meCYt clJiaClRVlFDOFNDeWwlaCZSYUpGaH1LRSY8Sgp6cjc8XnFDVDlFRlpwP2k1KGYpfkdRTnI8eShm dn5+QlJWUnsrQCRNPEhzY0Y9Oz97QHBWVXBLcGU3RlhlQWRqayQKelQ3UWUkTWxqO2pocFUtKVdl cDdoP0pLVXtyPj94QE5KJEBYcnFvVUN4bDhFaFcxWXMrUyk9PVRIJX4lNzl9YDctCnpVcjZmNVVJ eHM2dl80Rn0+Ri0ha14lalZgOUI9Z2VhNml4WFlXYm0tQXBlU3U9U1FtYl5UMXtOakx6K1M/fS01 WQp6UGE5dnEqXzthdGQpMmFnOzFgQHM+XjxGP0Q8NkclKkVvNFFLTktEZEUhYmNRVDVsezNeQyV4 P1p9Pjh8U0hDS1gKelB9QiRzeHZ5RldMc1NKe1J1JExKVWVKTHtYT0VSKV9QdSlwPF5weGlZRTI4 Knl7dDZaRT5Ya0B0XktTRzwtdU9OCnpsP2c2fmoqMHJ2K1Z2bU1uTmJfdF4yPjdROGlHSSp4eld9 eTY0Ti09QDgrcElwN1hKTUphJkQ1JkdEKDh2OFZYKAp6ayZEQkhoay1aciRFPzttamhLNnFtPXxQ Y0E4ZmBGKV5GOzBMQkN4bmZuNFduWThVcEhGMU9VJUtETXF6UHVCSzEKelUxQzliPFoxYjZ8R1N6 RjxuQy1rWHFKNl88SVFrQ1pEcndWMEB5cU1xPGxeeGt0YD0qJExOMEFodGE5LUQ8TT5FCnomR2hS MFVWb0Z1e15Ke34zS1RAfExzSXckdEsrOVN6byt4elRIN0FVdURQZEEjLV9HSkwmZClCaFVadGZS JE4+Wgp6TTwhMUxYVjZwcHl3Y0k1Yz0/NTd3Vno8Rj5tK2RFaGszNn0ma0xvLSVhdkAqVUNiLWVA b35aUz5Xa3x1QEErfSkKemJ9Pj07d0MoS3A3Xn5wIVdzbFh4bCZpK24kNTYwVVhCZ2U/TjZ5fWd2 QDU8bk9zfkFTUlNBbTA8U1c/QzFVLT01CnomKl9rUW48YEA2QlgpemBZeDk1YV9pYXdxZVVkWURh TEkjYyt3ezRvIU8xNkFIey0mRkxkJW5US2ExaCFBIS0hSwp6IUFZUF8mOHY3OW9xMDNFTihhZmcp eW8tWi1TclBJJUc8V0N4NllNc0BARHo1ekVgYFhmYlNxTz1rO3kmTWNre0IKekhVaHslYEBVVHJ3 O1RoKURxSz5xelpYaEUqKzFjQDhTWEJuPi1nUW14R2hRSEJSbkQ0Q2pqO3BZPHVYMWAwZUtUCnpm JUBYUSg8Z0koJW1Wb05vQDlBXlN9XnZIJk9sa08kfklUJHZ3TGpHSzBWM2BkZSlNYXFCX3lAYmhq Zyt5YDVIKQp6WFR9eGEyKWZRcyRtUlp2RUc7a25XWGJ0ZnJUSnp7VkwyMHtFaD1KK20wM2pURiRX SEBuKnhLPFF5TCM7ZT5efSMKei1ZQSo0YXlTY20rNXo2dF9jQjwlJGdLaCNJfDJkKk5NX0hrQ0pN ZjBwMFZYYDNMWXI7VHZkcTJCfk1Td1dlP1A8Cnp7ezs2OEk/QnlFN2h7S2dpLVhwTFIwRU42NG1D bVA1YG58VC1sTXpfdkcoemVkNWA7PzYraGtiYVY/VkNAM3l8Iwp6cXF7YDhUbndGVFR9PFY3bWRB KDxmKUM3fVdgKiZUWHxnOCF4VU1TP18zekd9SjA5aUMpQjZhPXEkU0ByNXZLTG4KenhocHBBK2JP TmcrIzBDbTF3e3JUUm5HYG81dXlGVVZDPENHZCZDUzxwTWIjd3Jtc29fT2FGNHY7YlFQeVZPPWde CnpkO0xId3UmZkJxLWdtKmpYKHFhI1MhbEJAOSthMUZqbD4re3tTcVBaaypZdklza09xeCF0WktQ ZHV7b2k4YCluRQp6YE9ualkwO0slSGZeKVpiN2x3NGolNHszQitrPjlFaH4+KjhIJlc4VG07IU9W PDtWOUo+UGI/Sl5UQVF7Vz5XSyUKenZrJmF1S2c1U0VSemlSbWBUTEQjcDU3KnJ1bzE1clFLRWxL Q0VhQis/fmU2dEBrUTdWQlBMXzMtcmtEeDRWPXdjCnp1emspIT8wQ1FES3VrZEF2MFU8NnA9PEJG TGh5Tz1lP0FIUUJwPXJfc1R+KGBhV0lMKlFwdXluMyV3JU4kWVVzZQp6bXorK1I7NzZxSXp5OzNs aXxTdmpGcWl0Ujx9fXhgdmU2MDM0Pl4maDU9dXxzRzV0TD4ze25lZyNEVF5WPzwjV0AKelk3S3I5 cmZLWStCPXlURSVsRmVxTFlaMXRrMCtzXjdxK0pnQVomcXxQYHkkUTFlQVdgX2UtS0spLVNhR2Br byFGCnpoMk5fWlRjaGRuQEAoP15Tezh6KGpeWkkheC1gJkEqRjVBS2tBVXBgeE47SDIqX3Apa3la OyhYdFAwQSZXJGBoVAp6eUEmJHplT2Z7cWMzOWxFVnx0bWppe0Y2e1U+UX03YGBQNnBJMUNCKlpU PVpJVmdAXyQrbVJCdCQzXzxFPlFCP2EKekhecVp0IXUhdkQmNXoycipFbXJoeS00Smd4bThWWDZ2 cHplP345TzwrJip2YnE3aGZvNzJULT1Va3RXKCVHdWBVCno9ai1Cdj9ITiFHam1WPTx5e0NldGVK NVRlU2oxb2tebiZeQ0pRWE1+ZH5Rb2dBM1lKOHw1JSFnYEpuSEQ8b1VpMAp6S0NAdnlQaHJfPV5y KnxDd0ImcU9geHd0akRZT28/bHh1eCtlUHdOQWx2M3xKKGQ4X2pqN3wzVWQ7ey1JaFN5ZjAKejxf Z2xZRn1OdU9TNmxfYXJoPUk5Y0I0eHBQdTkqeUR+UGZFa1hJJENua0peczIwQStfJWg4UWphMk0x PkZ7OXItCnoxfGJBP3J3LWRjQTU9dV5HbSo2QUx1NkczNz5wPEU1O1k+RnIoR1NxI2IpfjE5ZC1g aEJfd1pSe0pQUTYoWUJ5Rwp6SEszQn50VH01QC05PSg2UzJEfG9aZVVDalJHSSRzZEd9XnxaeGBj QEAhc3JRcE56fldlVkYlakU+MjJGMnNaQSEKejtII19PUFBAX0JYMlRYS3MrO09kWTgrVEl4WURU SUBBfjRoKX5tTz5GXz9Dez4tU3xkVmgtbzt2QVJiIW9Ke3ZPCno3aHAkQDtkYS1CanBQTFZkOT1q VEQ3Yk5+O1hHfU9yJWZCQDsmbU4qezxodnEtWmlta3BzUEt6eGA8PUc4R3Y0Mgp6Q3ZSYl9LKlhG anpUWWFMd1MpaWpTbUxVPEo0flAyRmpnQjZuen5RT0QpcjMwayFINEtrfmpKdmNvVzVeYGZQZUQK eiRoS3xFaTI1MlFwJEltJVU3d0U8QllReWUwR0IqNDxgTSVrO2Fxak97KHRqT2gyZTlMRipyRFFf ZVUqWld2enI9CnpOan1uOEFfZk0jMi1OIUUpaXR8WlUlQmtuJGA5QGcxS1ZOfmZ+Zm8jXiFBekdp YD1gcUpIWSt3em5jalZHNElJKAp6ITs5OFgjYjU7bWgzRVpwZSZPYnc3K1p0R0IoUFlALUI+MTFE YGJrdG8kbT85V1hvUnZgKC15O3RkN31Zcm9hIyoKejZNVGwmeGMtbUlGYTUlKitFISV6WSV5eXt8 RmBDQlR6dX0pOFpRTEM3TntyPHo3LSlgX1AtRyhlbj5fdiluaVcxCnpgcDtVQlYhKnF7cGU+V3x1 UlRFazFMSWVTaFM5JVBhbWxBWWtOSW1rYFRRQjF6WmM0JWJATykme2ZWaTYmVnhUMgp6I2VjV3FL TzRuQVhXZ0hUOz9HOSQ9U0sxMHF+JVhBezBXOVghU0UqLXteVjFDQH5KPDBfK05MI0tSTHNub1ok fkIKel48U0wjUGNaeG1oQ2pqWkNtOC1mQF8qJEJmMXVTcihDVk4xKVBKR1dLZiYtUDgyKWNDXz8o eVk7UXBeaiV1ci1ACnpoYyl0TEZ1YkZxZ0IqcnZhNjRNd01IRzhUbyRTY0ImQCVyR3pBP1AhPGZH JXN1bmtMakBJJjBEKH5Hfm9vY19Cewp6aX0oTUUkb0YpXm53K3d6RmdzQndseGFQcWFlYjl7byRA VmViPWBtZWwoQTItbkszP3Z5fTE1K0dxZFU1LXJvMjkKem9vQklIYTw/WT1pP0s9bk1fbk1rUDRh TVVaU0JjTnZERXNDaVlMN35kVXx2JUA9dEI+bmR9WEUhLTgqLTNiNmpHCnorVSZ3YlR4KzFWYyFQ aUk3OCVZPG5QK09VUytSNUZtaVVaPU5CayR5SGZNLV5AfnNrTWVXQ35kZTJ0WGhUU0kmKgp6NjZ2 THJpRENZfXV1bFNlc3BMbVlvX1RxQl8kPGd6NVFRM21DRz1tKz1+TDY9SjhTRmYpOHxMKTBpQ2k8 VDNUOUUKejl4X1dWNUU2K0ZgaU9oWEJvZ31HU0kyOyt4TmBjPTJqV0JVLX5SPnR5Qkl+X0VyLVJI RlRWJUUhPzElfnUpP2FpCnpjekcqSiZINXw2RT42blI8aWxfbyM1N0sle2BEYnVlS3I9VzBBSE1g cWtjKEFxPlhOIVRRU3tKdzwxfS1wdDxrRwp6PElFbHNPQVlyUDBOU1BncVRDcTBCRzE1b21OJnBS O188bWgjaW8+S2olRkhjVyt2MFM2bj8hYFFkVS1gJkVfSFQKelBBRmVCUT5oJUEtcCNOfCFnVmle ezx8V2goNypuOUIzdWdPTD1Rdnp5M3Q4XlIqM2Bod092NUpMR301P1BRM0YlCnpsTW14aHdBc197 Xn5GQmVMdytndGRvMSRQUFQrKl56bih5Sz1OKUJVUlU0MHtTem4/PjAzbl5fVUBlSV9sbH1pIQp6 KnAtSlJuZUJnPDlCcChgYjVDPWx2Wm1aOyspK3shWW4renAtbjNGUXYyQEJNSDVGTXokOHJna3RV SVlXPlVDPUIKekhsfTY8a3tneUhQVlBEaWYjNT45cV5LeGNBYUd4Nj91QF9YY2BrcU9AVytBb3to c2dsb2IhRW9LRmJxbT0hckA1Cno2NVFnT2cmZ0xWVEcxaWhnJXFUSVU0JF44cTkqX2dCUUJ0Klhp X0F8eVpDNWpraWdIMyh2OTBQRHxIN1BLRCRMSwp6VmxAPCp4alN2Y0ZIRU9Yc2E9akImSTkkUmVf WSp+czNOcl9kKzdDQkdPMCtyN2RuKn1fUGwkX0B2fnltPkhudj8KejR2b2BqeHI+ZmJUXnEofmk+ OHl9ZkM7bVFxeSkpTVhTR30zeFhBeFB6Q2E/M1I3VHJPMmZkfVNRYjAxOEhSSklFCnpseisxVHlx Q2stYn1QKkNCVUo4RlRwaiYoNHk8KkBiQVVOUmx9VVVDO0dmR3t2ZFQ5WiNUITVaWS13OSFVa2JF RAp6eTM5QyVId0EkRzJCQ2RgPkJKbFp1JVFPdnsrcmNgRFh9KzUtVXs1KHAkOX5HKXhwdCQxIXpI Ky1pZ0BIaWJAcVAKejF+R0xOVXtxPXtpT3ArSj5EZlBoQDZVMm8lRyN8TkIpV19Tb0RnRWBUaTBH Kz48dGkkSHxCaD5YWlBvO193bzVfCnpgME88cEc0RnFYcVUhWDtZYjlpX3BBZjQ5by00NzUpfnxT d2JwbkFQMWhgfGBfYipVM2oxM01CNnF2Vk1wPG9oOwp6KlQ5eSskYXtXJnRxKHxYcnFYeFlZN1Q5 d3tOVD91RVE5WnJ7PGxHVztxSlg9VE4xNGk4YTQmKzlkXzs1azF3dmIKemdTRkRuMVBBQnBYfilP TEtIdWJzK1M9TGVEOUtqV0NJVS1gTmI8Zm1LWG1lPih1P0xBKVJzRD1gJVZFaztEREVtCnpTQ202 cmV3bHFpckFScUZSfGFYX2F5YF5waHwtJjBwUmtwfUtQUnVsR1lGI2VmNSZ3a289MUlud0FpTm09 TUpAQgp6emNncntwVE1SUEBpUFhueGBgUXYhQz4pP2pnNmh9OzE8I2xLPCRAbWhmK2dBPl5NVnpl I0hfSlZXUj5VPVRXQEAKenQwTH4oLXxtI3k4Zz8jYzA2S2pNJmQkeXl7WUwrNV53Yz5PLTdnPHpR P2dYbThHdEhUKHdvKnpOamYoWF8xZWsmCnpXfGJib0hQKHMwbEYpSGNDR3BpdVFxVHp0ZkVMTVFy QT5uU0pkJFVGcSYtbVlYQ3tGVXtxbUhZWUcrLXhxe3dxOwp6PjlWcWtrQCY1UmtOZDwlbXlQJUU9 NjxXJSEtdVFnSUBTQzJtWFMxRDJOdGxIRWRmY3JgNjBjWClnYXsyODk4cSEKek1lV3cmS0h7Rzwy WWs1U2FjdzFGVGNOcklgbF5OKkM7bDd8PnRkLSpXPGdUajdDYUZoej0lc0VtK0F3eTtTJGRRCnp5 U2lfe0AoMUhpO1AjSGEqbiU7TnBzSXtrZ0E4d2BVY2M9K2lCNGA1IVE8bE1OP2w9NFZFV3YycjtF ekt4Qmp8dgp6bVFKM2Zxd3E0WWN8UnhwMVYjfW5lNlNnQSRgX1hJOHJYbWVSJntBYGglTi0zdjg2 fnpAbVUmJWxYNzdidiE9ZUMKelZIWmpvaWxvKE8/M04wLVNBZzlVSyt8MHluSX07NUxJOHxvISNa fFY5WGtYWjBKI15RJjE1K3FAeSZtKl5ZSkIqCnpIdmViJlk4K3IxQFF5JUhPYS1WI1JfSEMzaGdl WCFmRD5BWj9XZkdKM3NwRVNCNXsrVytgQnQ5amVYbz1AX2U3Zwp6QmVBSW0lWHwoYDE2KHp9Xkd0 ZEZKSDIocnF0WkVuZ1JpJSMxRUR0PF4paU0qRlpXdEVgb1dKUHZPP0JyQXIwSUkKemYwfTF4ZSF9 ZVdFTVE8QjNuMEtjO2N+Z3VoKl8xOSt5KWoqZ3Jla1FIJld2PDRUOVI3WiNkdWchIXFzKEQldiZo CnpBanM0e2VLK3pyWjh6cWtKNTk4V09VdTE8aFBmTCRLdjRIflZgaEFxNkUlcmc4Q1MpXko+eTNq dGlTcUwtQzFwaQp6OTZyay02fihSNj9lSmc3VnlOLW80a3VxXyN4KVcyWT5zTyYtfHxZdVFhNn5q YWhFPmNMYllkMW8+QSRVUj51TkYKejhxWChudVFnMUJWOV9XMEBDUm4wZ1ZlJkhiPjY7QlRKWkZa PEshTWg9YitibTVERmt3PWhwb0xhaG9pYDhaaWAtCnpJfEx5Z20mK1ZeTmZGfTZoK2tQS1lJVWtP VmxwJCZoJW5AO2tKS25EVGdrcGM1JkJ8emNqejU/YHMzeEEkdWhGdwp6RDc3SEJ6TnV7OVlvVm1I dCUwbzxoN0NPd291MStDQlApci1FOThDRG48QDgyNH19JiYlOHZxfT50TmZQYn4mTWgKejVzdX1D cVRhOHRXQUdkMDAtPmcyPUlzIzFeeCViME5MelpaTjwpQFV7OTleRD5eeVpaQGkrTCpNSWlwTGQm Plp8CnpgMnMjYDcofD89VVprZFQxYm1eKVozU0A5SFgkbWdMSWo0ZUReWTw2WiskcmJQZzMjcy1Y bml8QEJyYj0hUW8tVwp6TWxlSipTakhkUyNBb2BnUCh8KDdjRytQNHcrIWR7cyN4Y2h2b1JMKFJh PFdPQih7fHNlKHk/aGYmZCthTTNoITcKekQofj9Qb1AxS2NYeHkwMDw2aEpAMjRAOCE+R1NFb2xH KkgqNW1QWFpwTUhscGxBeSY9N1FMR1ZXcmtFJTRHdlorCnpXTXg1Oz1JVk93T0E/OUF4Yl9OfTN0 P2hvOGY0UVlAXjtNbm43Tng9VHF4OWdXZDl0c3s1fkFmSTtNJk85cld6fAp6KmxsSHtKJWh5M3NS MD9HS2Y4aCRpTXlGfG9WYDE4XlNKQXN4IU8oNihGMG5qJmtLfTZjVEUkKjdjc0NfTH1HflcKejkz Q2c3SFllXnItSX4qKj9kdFNKT1Q+fEN2OHNpPTJZWUUjQ2MwViN4XyFuaGFPYkU2X1IyNWQ8WjBw ZkBkM2dPCnpSVUVnWWZrTzI1cX1sbWImZXVvWiYmfFcmRm4mTWhLN1lmdWEkO1QpWHBDRyFDN2VY M247WnRVRk5FVVEpI2dzKQp6PlFpTUk5bWskV0dtXjtVbUE8Y0leRkJ1Vj9XIzJTYEBjSXAwWkRk TSo5dWQ1ME82MjBJYXRhPmhVZlpnZTdJaykKel8hbW8lYipKLUtsMjxeantpUlFzVzdQMm9FejNs MzR4VXQwXm49KmM3XlVpZTYoSk1RYT1Db0orI1E3VDMyaUFQCnpBQlFBeTkqZnY2cnF+ayF6bylt SypZR2xWPXVKdDA7WjBiNkQkb1Y+d3shITZUa1QybUpBPyZ8cVY7aUJqV2dlTgp6PXtMZDJQaEhz dklBVSNISWlIQ1liWWtNPF56WEZ5Qiojc1RfKTRlQz8rNig7anh4el4+dip1YGx7UiV5dih1U0sK elJiKG9PPHEyVWRiXnIyflhsQGxYZl9LaWhkQjEqXyMmTnJvVmZsXnJVZm9+RWtzXyFVZHU7PXFB KFhHMjszSzxVCnp8MTw0NnBYQ19NeEd7RFZePT5KXjZDREhPKz1YIzArKlM1cnl8TUdBOVdzViRl Pjc1WDtnNmBsanF1MVVQKTdvbgp6OVhfQlZ2aFlHJkMzTytnVzl6QUAocWEoUSNqaHUzNFJDQFhZ VW5sOGozc1B6Q2xvWmcpPkU2eW8hUU1pSzsqMCUKel5YXzF7aUVsNXxNPjMyU3Q/cnN9cj1Db3Jz SFZFWHleKEkjUiE4cExqNTB7ckZRLUZrdVpAcGNGU05SKEhTYj1hCnpWJDJHWk1vUWU3KkBIQj5G ajlMTGhHVygyPUo5JUQySkpIZEEyQnBVOWxMU2BWfDFHPjlreVJ6JEdGeS0rbGBNUwp6Z1RFdWtA fmBmXkMzfWh8P3BrTlJIXzM8bFV5P2U0PyN8N3ZIdis3ck9VVTU0ejZUYmVNdkt7Rj89c0FLOUBH YTAKekdrS2wzUFVJOTZ2c2RgNEplUnEpdylRbEJDblN9ME0meikwP2p3U00hcmstZ2FBPGUtNUZH QWZteHdMNlpoK04+Cnp3fTZRPjtCRERkeTlePEc2VX5lVSlPYCRUOUp8dkV7U31ZP01IdCUlKihi YSU7WkRsQUxjc0xwRj1vPkA3aWZKJgp6Q2w0YVFHa2RhJk99b0psbDJ7ZVFJU3ZJJUpOfT8tb140 e1UzejwzNldtOyU2KEx+Uk5EbFIjeF50e1pMTj0oQ0kKekcxS081dnBIfj1uY2hCMWhLQHZUWmFz XjxvdElKY2Y/YzdUVFNaTkA7KmtqUkA4KCYlNlE+cGUkb0ApYSZ2SzxDCnowa21IRGZrJT5td0hi WX4taUV4KHVCQFJaJSo+M34tZDxuUEBebDJSeWNwS2N0MzlIeXdqVEdISkh4QEAycDdRbQp6aXd7 R0IlUlppUTlXWkBrKXhjMXdsMWJXflVEXko5SVB3aWdOfiorSSNhZ0g5LURhITEqfm50bGBUOyUq biRvSl8KemFLMGFKRlk4YC17SFhGV2A5bkdSalg4IXRFQ2RZYWJ8fitNXiYqelVWaUdIS2taUEsq O3s8fmlAQXFEbzhaPzJqCnpTantVeDV9T3ROcDZIMGpjO3J8YiNlPVNHJXgjSWIpZEdlMDN5Y1ZD enRfSSEtdmhtWlhVXjJIdEtyWDN4ViQjMwp6Q2I5JmxhaU1KI0J5MSg9MmM4KmNUJUpAMXhpfWUw PG1XWHBDY1ckSDl+UXsyczExPSNrczI8K0RrdFVURmBvbWMKejZ3bUowMlRKLWhGJSV8RV5HWShl aX1BKT0oS1R4WFFWRT5mSmJOPWNEKXNaP21OaElBXlR9IU9MOF9ZJWs7K0w4CnpZTiMtMHVKQjRy Qmp2ZSgrPF8yYTdCXnZsbzsoaCl6P15YS2s+a3dvY3V9NjZAMmBAM3FHdFFiZyF3MVhrJld0Ngp6 PXM0YV9hR2xwRlgkKjVEV0phd151UkVuUmlgMkUrJH5uQWBYRmJgKFBtOzw8U1hfdk87NjIxZ0x3 M0BsYzZPQFQKemAjNSVgVklGbC0+dlN2bW1raUd4KV84V29eNiV1fkJedmxpZWAtRGJkQnxjKkpT QjB5R29gQSp5S0xvdDFTTGlMCnpGdzRSMktqakArO1hXRXtVaE04TnUxJFI3RHA/TVpGKUlrPi1n a29+UypoUXdiTDtkSGdlbT5JJWF4LS1oaGdWOQp6OyFrWGhyUUtPe2NfcTZDcFhNP0U9KFRXQ1c2 UG9UTWA5bzBtR3tWOXh8MTlNVERIWXlmTVNNX3o3SGxkeWhTZXQKejxDZHF0bnM2NntBOFBxflVZ P2d1WmlMc3lZQTFLbzdHITk8PDJXQVpOT2JZfT8tSFZSc1JaaHFoentVcDk0V3RUCnp6clhtNy1U PzE+WTNHQzRwYXtHMUBgdHdPQC1reG1xYXZVWTdiJVVYTGF9bFVWX3Yob1ZXQnBgblF2cyswdjhu Rwp6VV5kOGApPlUwRmdIdGNrNUx6X01WMiN7MVRIQ3M8amJYMlFZKnFARmBmTWlxI3I2enJXU2Zy Rm8qV0tyNSF7WCQKejk0OXVubEVYLShpMipfNzd+SDVUUE8rOTk9U0dUMD9xd1B8ZjlnKWEyWHh4 Wjk0U0hzYTc9ZSZDeUZ3NFh9WFplCnp2Pk5HaE9HMntJNlBfYy1ETiRCS21lZz1kRzhSZjBiM1Rk PndrVkk4MndeUH07d0B+ejY5QTwhai1OKDtHaEEkMwp6PCtKOHt7ZyZ3dE9ITih6c2pEOF9TeStY UDNrYX5rVG4qcUhrXmU1OFdXdkNySDEzVE9EYjhKM0ZZJVZoTigqbmEKejJXYDg+VWV+UCN5QEw5 RDZ7V0ZMKkc8d2VTMkQxdU9PdiYwbWBXd3gwUjxCVGhVeiFsWnFJSyZ5VSt5Ul5UZXU7CnpVIzlE U1htRF5ZSXpiYHRRWmZZb2NJZF5pcnljcCV5Rks9Z3dgdGErWWg/VGVZPmY3VnZec1N8JSR3R3s5 aW0oUQp6JDY3V3AmaDhlPUJSTV9+OVY3ZSlwPDExJl9yRV9qV0c9WEc+c3NTREhINGFoKjY0NzJu MllAXl4le1NFeEwreXgKemArOzgrUjRUTUtAZ3xkVmFZP3lzSyNSa3ZuYF5FckFYenhiJDFldCpK N3d1aDloNk5CNjNBajQqfF9xbjwxfjM9CnpxSnZ+SXFvIV4zY007PVk2TnxQbCY2fEdXN34peUtB aSpCcV53X1BLOGFpMVR2ZUxPNGtRcXw9TVNncH5QS05INgp6WFFVZn15TC1XVHstUXZCPHs/byE/ fjUzSUtgajR0NSZ2fWxmNm5Tcm5vOCR5TT4hcnkybkA+YDZFWWdIWl9iM0gKemYwZUMrajJRTTRp cXFVOCZ0PHhveCRUYmpLTjgmYnI5PUUlWG9CQkhLZHc7NWl7UV9IJFd5KV9TdU8pYT04Y0o/Cnoo QTwhQ3RwbFNwal9pQ0dIQzBZJXI8ZDI2SGdRclk+cl5oTzlxN1E9QSl6eUJRfl9WIyN4LUFPNGJU bWI0aCNqbgp6N1VxV2J0Xj19MExfa3NWUyhfWklOUnU4dTBhdU8hNCQ2KnJ3ViV+cEp8bD9wK2s1 OTB2QDdHSTJQVmVzcWpTT18KemE1ZVkzTSp5aVY+RXBCZVJFMz82c25DJSEqLUVHNVBkJU80SVNt U155PWgodUppU0spOUdBO1hsJE1yZmRSNXwyCnopSDdjYiYkK3pzLVV9TndFPXN5WXp4O3diK2ZR fFhDMGdHSmJVTSR+R345aypNQCV9R0srQWIrVkJfaElrP0B9Pwp6JlIkY2FYZDFzSHFPMyhnbk1X TVY2MGQ9TDFGcD5sWHltNV5VSGdMaStIdG48Ozdza151a2p6QmRYQH5iPSVnejQKemtjRGJzRHx1 N2lUK0I0YStRVkM5K3xzJjckOUdzMVRmfDM2NnErV20+K3A7Ml9EYUMoPSNrXzhiLW9jbHsyUXth CkJtZ0BpagoKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9lZGl0aW5nL3Nl bGVjdGlvbi8yNTIyOC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvZWRp dGluZy9zZWxlY3Rpb24vMjUyMjgtZXhwZWN0ZWQudHh0CmluZGV4IDQ5NWQ1MDVjZTgwMzQyZWUy Y2E2Y2M0MjJjNjdiMTRkZGU0ZjM3OTUuLjQxYjRjODgwZDU5NWI3NzExZjU0OWM2YjA4ZWEyNmZl ZDhlZTAwNWIgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9lZGl0aW5nL3Nl bGVjdGlvbi8yNTIyOC1leHBlY3RlZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFj L2VkaXRpbmcvc2VsZWN0aW9uLzI1MjI4LWV4cGVjdGVkLnR4dApAQCAtMSwyNCArMSw0MiBAQAot bGF5ZXIgYXQgKDAsMCkgc2l6ZSAyMDA4eDMxMDgKLSAgUmVuZGVyVmlldyBhdCAoMCwwKSBzaXpl IDc4NXg1ODUKLWxheWVyIGF0ICgwLDApIHNpemUgMjAwOHgzMTA4Ci0gIFJlbmRlckJsb2NrIHtI VE1MfSBhdCAoMCwwKSBzaXplIDc4NXgzMTA4Ci0gICAgUmVuZGVyQm9keSB7Qk9EWX0gYXQgKDgs OCkgc2l6ZSA3Njl4MzA5MgotICAgICAgUmVuZGVyQmxvY2sge0RJVn0gYXQgKDAsMCkgc2l6ZSA3 Njl4OTIgW2JvcmRlcjogKDFweCBzb2xpZCAjRkYwMDAwKV0KLSAgICAgICAgUmVuZGVyVGV4dCB7 I3RleHR9IGF0ICgxLDEpIHNpemUgNzU4eDkwCi0gICAgICAgICAgdGV4dCBydW4gYXQgKDEsMSkg d2lkdGggNzUxOiAiVGhpcyB0ZXN0cyBmb3IgYSBidWcgKGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTIyOCkgd2hlcmUgU2VsZWN0aW9uQ29udHJvbGxlcjo6YWJzb2x1 dGVDYXJldEJvdW5kcyIKLSAgICAgICAgICB0ZXh0IHJ1biBhdCAoNzUyLDEpIHdpZHRoIDQ6ICIg IgotICAgICAgICAgIHRleHQgcnVuIGF0ICgxLDE5KSB3aWR0aCAxOTg6ICJ3YXMgcmV0dXJuaW5n IGFuIGluZmxhdGVkIGNhcmV0LiAiCi0gICAgICAgICAgdGV4dCBydW4gYXQgKDE5OSwxOSkgd2lk dGggMzI5OiAiSXQgd291bGQgbWFuaWZlc3QgaXRzZWxmIGR1cmluZyByZXZlYWxTZWxlY3Rpb24g Y2FsbHMuICIKLSAgICAgICAgICB0ZXh0IHJ1biBhdCAoNTI4LDE5KSB3aWR0aCAyMjQ6ICJCZWZv cmUgdGhlIGNoYW5nZSB3ZSB3b3VsZCByZXZlYWwiCi0gICAgICAgICAgdGV4dCBydW4gYXQgKDc1 MiwxOSkgd2lkdGggNDogIiAiCi0gICAgICAgICAgdGV4dCBydW4gYXQgKDEsMzcpIHdpZHRoIDI3 OTogIm9uZSBwaXhlbCB0b28gbXVjaCBiZWNhdXNlIG9mIHRoZSBpbmZsYXRpb24uICIKLSAgICAg ICAgICB0ZXh0IHJ1biBhdCAoMjgwLDM3KSB3aWR0aCA0NzU6ICJUbyBydW4gbWFudWFsbHksIHBs YWNlIHRoZSBjYXJldCBqdXN0IGFmdGVyIHRoZSBmaXJzdCBjaGFyYWN0ZXIsIHNjcm9sbCAxMDB4 MTAwIgotICAgICAgICAgIHRleHQgcnVuIGF0ICg3NTUsMzcpIHdpZHRoIDQ6ICIgIgotICAgICAg ICAgIHRleHQgcnVuIGF0ICgxLDU1KSB3aWR0aCAyMjU6ICJwaXhlbHMgb3Igc28gYW5kIGhpdCB0 aGUgYmFjayBhcnJvdy4gIgotICAgICAgICAgIHRleHQgcnVuIGF0ICgyMjYsNTUpIHdpZHRoIDM4 NjogIlRoZSBjYXJldCBzaG91bGQgYmUgcmlnaHQgdXAgYWdhaW5zdCB0aGUgZWRnZSBvZiB0aGUg d2luZG93LiAiCi0gICAgICAgICAgdGV4dCBydW4gYXQgKDYxMiw1NSkgd2lkdGggMTM2OiAiSWYg d2UgY2hhbmdlIHRoZSB3YXkiCi0gICAgICAgICAgdGV4dCBydW4gYXQgKDc0OCw1NSkgd2lkdGgg NDogIiAiCi0gICAgICAgICAgdGV4dCBydW4gYXQgKDEsNzMpIHdpZHRoIDYwNjogInNlbGVjdGlv bnMgYXJlIHJldmVhbGVkIHRoZSByZXN1bHRzIGZvciB0aGlzIHRlc3QgbWlnaHQgY2hhbmdlIGFu ZCBpdCBtYXkgbm8gbG9uZ2VyIHRlc3QgZm9yIHRoZSBidWcuIgotICAgICAgUmVuZGVyQmxvY2sg e0RJVn0gYXQgKDAsOTIpIHNpemUgMjAwMHgzMDAwCitsYXllciBhdCAoMCwwKSBzaXplIDIwMDB4 NTg1CisgIFJlbmRlclZpZXcgYXQgKDAsMCkgc2l6ZSA4MDB4NTg1CitsYXllciBhdCAoMCwwKSBz aXplIDIwMDB4NTg1CisgIFJlbmRlckJsb2NrIHtIVE1MfSBhdCAoMCwwKSBzaXplIDgwMHg1ODUK KyAgICBSZW5kZXJCb2R5IHtCT0RZfSBhdCAoMCwwKSBzaXplIDgwMHg1ODUKKyAgICAgIFJlbmRl ckJsb2NrIHtESVZ9IGF0ICg3OTgsMCkgc2l6ZSAzMDJ4MjcyIFtib3JkZXI6ICgxcHggc29saWQg I0ZGMDAwMCldCisgICAgICAgIFJlbmRlclRleHQgeyN0ZXh0fSBhdCAoMSwxKSBzaXplIDMwMHgy NzAKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMSwxKSB3aWR0aCAxMjA6ICJUaGlzIHRlc3RzIGZv ciBhIGJ1ZyIKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMTIxLDEpIHdpZHRoIDQ6ICIgIgorICAg ICAgICAgIHRleHQgcnVuIGF0ICgxLDE5KSB3aWR0aCAyNDk6ICIoaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpPyIKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMSwzNykgd2lkdGgg MTA5OiAiaWQ9MjUyMjgpIHdoZXJlIgorICAgICAgICAgIHRleHQgcnVuIGF0ICgxMTAsMzcpIHdp ZHRoIDQ6ICIgIgorICAgICAgICAgIHRleHQgcnVuIGF0ICgxLDU1KSB3aWR0aCAyOTQ6ICJTZWxl Y3Rpb25Db250cm9sbGVyOjphYnNvbHV0ZUNhcmV0Qm91bmRzIHdhcyIKKyAgICAgICAgICB0ZXh0 IHJ1biBhdCAoMjk1LDU1KSB3aWR0aCA0OiAiICIKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMSw3 Mykgd2lkdGggMTY5OiAicmV0dXJuaW5nIGFuIGluZmxhdGVkIGNhcmV0LiAiCisgICAgICAgICAg dGV4dCBydW4gYXQgKDE3MCw3Mykgd2lkdGggMTEwOiAiSXQgd291bGQgbWFuaWZlc3QiCisgICAg ICAgICAgdGV4dCBydW4gYXQgKDI4MCw3Mykgd2lkdGggNDogIiAiCisgICAgICAgICAgdGV4dCBy dW4gYXQgKDEsOTEpIHdpZHRoIDIxNTogIml0c2VsZiBkdXJpbmcgcmV2ZWFsU2VsZWN0aW9uIGNh bGxzLiAiCisgICAgICAgICAgdGV4dCBydW4gYXQgKDIxNiw5MSkgd2lkdGggNjY6ICJCZWZvcmUg dGhlIgorICAgICAgICAgIHRleHQgcnVuIGF0ICgyODIsOTEpIHdpZHRoIDQ6ICIgIgorICAgICAg ICAgIHRleHQgcnVuIGF0ICgxLDEwOSkgd2lkdGggMjc5OiAiY2hhbmdlIHdlIHdvdWxkIHJldmVh bCBvbmUgcGl4ZWwgdG9vIG11Y2giCisgICAgICAgICAgdGV4dCBydW4gYXQgKDI4MCwxMDkpIHdp ZHRoIDQ6ICIgIgorICAgICAgICAgIHRleHQgcnVuIGF0ICgxLDEyNykgd2lkdGggMTU0OiAiYmVj YXVzZSBvZiB0aGUgaW5mbGF0aW9uLiAiCisgICAgICAgICAgdGV4dCBydW4gYXQgKDE1NSwxMjcp IHdpZHRoIDE0NjogIlRvIHJ1biBtYW51YWxseSwgcGxhY2UiCisgICAgICAgICAgdGV4dCBydW4g YXQgKDMwMSwxMjcpIHdpZHRoIDA6ICIgIgorICAgICAgICAgIHRleHQgcnVuIGF0ICgxLDE0NSkg d2lkdGggMjk3OiAidGhlIGNhcmV0IGp1c3QgYWZ0ZXIgdGhlIGZpcnN0IGNoYXJhY3Rlciwgc2Ny b2xsIHRvIDAsIgorICAgICAgICAgIHRleHQgcnVuIGF0ICgyOTgsMTQ1KSB3aWR0aCAzOiAiICIK KyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMSwxNjMpIHdpZHRoIDE2MTogIjAgYW5kIGhpdCB0aGUg YmFjayBhcnJvdy4gIgorICAgICAgICAgIHRleHQgcnVuIGF0ICgxNjIsMTYzKSB3aWR0aCAxMjQ6 ICJUaGUgY2FyZXQgc2hvdWxkIGJlIgorICAgICAgICAgIHRleHQgcnVuIGF0ICgyODYsMTYzKSB3 aWR0aCA0OiAiICIKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMSwxODEpIHdpZHRoIDMwMDogInJp Z2h0IHVwIGFnYWluc3QgdGhlIGVkZ2Ugb2YgdGhlIHdpbmRvdyBhbmQgdGhlIgorICAgICAgICAg IHRleHQgcnVuIGF0ICgzMDEsMTgxKSB3aWR0aCAwOiAiICIKKyAgICAgICAgICB0ZXh0IHJ1biBh dCAoMSwxOTkpIHdpZHRoIDIzMjogIndpbmRvdyBzaG91bGQgc3RpbGwgYmUgYXQgc2Nyb2xsIDAs IDAuICIKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMjMzLDE5OSkgd2lkdGggMzM6ICJJZiB3ZSIK KyAgICAgICAgICB0ZXh0IHJ1biBhdCAoMjY2LDE5OSkgd2lkdGggNDogIiAiCisgICAgICAgICAg dGV4dCBydW4gYXQgKDEsMjE3KSB3aWR0aCAyNjc6ICJjaGFuZ2UgdGhlIHdheSBzZWxlY3Rpb25z IGFyZSByZXZlYWxlZCB0aGUiCisgICAgICAgICAgdGV4dCBydW4gYXQgKDI2OCwyMTcpIHdpZHRo IDQ6ICIgIgorICAgICAgICAgIHRleHQgcnVuIGF0ICgxLDIzNSkgd2lkdGggMjkyOiAicmVzdWx0 cyBmb3IgdGhpcyB0ZXN0IG1pZ2h0IGNoYW5nZSBhbmQgaXQgbWF5IG5vIgorICAgICAgICAgIHRl eHQgcnVuIGF0ICgyOTMsMjM1KSB3aWR0aCA0OiAiICIKKyAgICAgICAgICB0ZXh0IHJ1biBhdCAo MSwyNTMpIHdpZHRoIDE0MjogImxvbmdlciB0ZXN0IGZvciB0aGUgYnVnLiIKKyAgICAgIFJlbmRl ckJsb2NrIHtESVZ9IGF0ICgwLDI3Mikgc2l6ZSAyMDAweDAKIGNhcmV0OiBwb3NpdGlvbiAwIG9m IGNoaWxkIDAgeyN0ZXh0fSBvZiBjaGlsZCAxIHtESVZ9IG9mIGNoaWxkIDEge0JPRFl9IG9mIGNo aWxkIDAge0hUTUx9IG9mIGRvY3VtZW50Ci1zY3JvbGxlZCB0byA5LDkKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL3BsYXRmb3JtL21hYy9lZGl0aW5nL3NlbGVjdGlvbi8yNTIyOC5odG1sIGIvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vbWFjL2VkaXRpbmcvc2VsZWN0aW9uLzI1MjI4Lmh0bWwKaW5kZXgg MDgwNDg4ZDc0NDkxOTlmMjk4ODJkYTA0YTQxYjFjZGFhODEyMTA3MC4uYTM5ZGMzMDc3NGE3MGYw MmViMDBmZWUzOTg5N2QzNzJhZDRjOTQ0YSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vbWFjL2VkaXRpbmcvc2VsZWN0aW9uLzI1MjI4Lmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvcGxh dGZvcm0vbWFjL2VkaXRpbmcvc2VsZWN0aW9uLzI1MjI4Lmh0bWwKQEAgLTMsNyArMyw2IEBACiBm dW5jdGlvbiBydW5UZXN0KCkgewogICAgIGlmICghbGF5b3V0VGVzdENvbnRyb2xsZXIpCiAgICAg ICAgIHJldHVybjsKLSAgICAgICAgCiAgICAgbGF5b3V0VGVzdENvbnRyb2xsZXIud2FpdFVudGls RG9uZSgpOwogICAgIHdpbmRvdy5zZXRUaW1lb3V0KGFmdGVyRGVsYXksIDIwKTsKIH0KQEAgLTEx LDEzICsxMCwxMyBAQCBmdW5jdGlvbiBydW5UZXN0KCkgewogZnVuY3Rpb24gYWZ0ZXJEZWxheSgp IHsKICAgICBlZGl0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoImVkaXQiKTsKICAgICBlZGl0 LmZvY3VzKCk7Ci0gICAgd2luZG93LnNjcm9sbEJ5KDEwMCwgMTAwKTsKKyAgICB3aW5kb3cuc2Ny b2xsVG8oMCwgMCk7CiAgICAgdGV4dElucHV0Q29udHJvbGxlci5kb0NvbW1hbmQoIm1vdmVCYWNr d2FyZDoiKTsKICAgICBsYXlvdXRUZXN0Q29udHJvbGxlci5ub3RpZnlEb25lKCk7CiB9CiA8L3Nj cmlwdD4KIDwvaGVhZD4KLTxib2R5IG9ubG9hZD0icnVuVGVzdCgpOyI+Ci08ZGl2IGlkPSJlZGl0 IiBjb250ZW50RWRpdGFibGU9InRydWUiIHN0eWxlPSJib3JkZXI6IDFweCBzb2xpZCByZWQ7IGhl aWdodDoiPlRoaXMgdGVzdHMgZm9yIGEgYnVnIChodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjUyMjgpIHdoZXJlIFNlbGVjdGlvbkNvbnRyb2xsZXI6OmFic29sdXRlQ2Fy ZXRCb3VuZHMgd2FzIHJldHVybmluZyBhbiBpbmZsYXRlZCBjYXJldC4gIEl0IHdvdWxkIG1hbmlm ZXN0IGl0c2VsZiBkdXJpbmcgcmV2ZWFsU2VsZWN0aW9uIGNhbGxzLiAgQmVmb3JlIHRoZSBjaGFu Z2Ugd2Ugd291bGQgcmV2ZWFsIG9uZSBwaXhlbCB0b28gbXVjaCBiZWNhdXNlIG9mIHRoZSBpbmZs YXRpb24uICBUbyBydW4gbWFudWFsbHksIHBsYWNlIHRoZSBjYXJldCBqdXN0IGFmdGVyIHRoZSBm aXJzdCBjaGFyYWN0ZXIsIHNjcm9sbCAxMDB4MTAwIHBpeGVscyBvciBzbyBhbmQgaGl0IHRoZSBi YWNrIGFycm93LiAgVGhlIGNhcmV0IHNob3VsZCBiZSByaWdodCB1cCBhZ2FpbnN0IHRoZSBlZGdl IG9mIHRoZSB3aW5kb3cuICBJZiB3ZSBjaGFuZ2UgdGhlIHdheSBzZWxlY3Rpb25zIGFyZSByZXZl YWxlZCB0aGUgcmVzdWx0cyBmb3IgdGhpcyB0ZXN0IG1pZ2h0IGNoYW5nZSBhbmQgaXQgbWF5IG5v IGxvbmdlciB0ZXN0IGZvciB0aGUgYnVnLjwvZGl2PgotPGRpdiBzdHlsZT0iaGVpZ2h0OjMwMDBw eDsgd2lkdGg6MjAwMHB4OyI+Cis8Ym9keSBvbmxvYWQ9InJ1blRlc3QoKTsiIHN0eWxlPSJwYWRk aW5nOiAwOyBtYXJnaW46MCI+Cis8ZGl2IGlkPSJlZGl0IiBjb250ZW50RWRpdGFibGU9InRydWUi IHN0eWxlPSJib3JkZXI6IDFweCBzb2xpZCByZWQ7IHdpZHRoOjMwMHB4OyBtYXJnaW4tbGVmdDog Nzk4cHg7IHBhZGRpbmc6MDsgaGVpZ2h0OiI+VGhpcyB0ZXN0cyBmb3IgYSBidWcgKGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTIyOCkgd2hlcmUgU2VsZWN0aW9uQ29u dHJvbGxlcjo6YWJzb2x1dGVDYXJldEJvdW5kcyB3YXMgcmV0dXJuaW5nIGFuIGluZmxhdGVkIGNh cmV0LiAgSXQgd291bGQgbWFuaWZlc3QgaXRzZWxmIGR1cmluZyByZXZlYWxTZWxlY3Rpb24gY2Fs bHMuICBCZWZvcmUgdGhlIGNoYW5nZSB3ZSB3b3VsZCByZXZlYWwgb25lIHBpeGVsIHRvbyBtdWNo IGJlY2F1c2Ugb2YgdGhlIGluZmxhdGlvbi4gIFRvIHJ1biBtYW51YWxseSwgcGxhY2UgdGhlIGNh cmV0IGp1c3QgYWZ0ZXIgdGhlIGZpcnN0IGNoYXJhY3Rlciwgc2Nyb2xsIHRvIDAsIDAgYW5kIGhp dCB0aGUgYmFjayBhcnJvdy4gIFRoZSBjYXJldCBzaG91bGQgYmUgcmlnaHQgdXAgYWdhaW5zdCB0 aGUgZWRnZSBvZiB0aGUgd2luZG93IGFuZCB0aGUgd2luZG93IHNob3VsZCBzdGlsbCBiZSBhdCBz Y3JvbGwgMCwgMC4gIElmIHdlIGNoYW5nZSB0aGUgd2F5IHNlbGVjdGlvbnMgYXJlIHJldmVhbGVk IHRoZSByZXN1bHRzIGZvciB0aGlzIHRlc3QgbWlnaHQgY2hhbmdlIGFuZCBpdCBtYXkgbm8gbG9u Z2VyIHRlc3QgZm9yIHRoZSBidWcuPC9kaXY+Cis8ZGl2IHN0eWxlPSJ3aWR0aDoyMDAwcHg7Ij4K IDwvYm9keT4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VM b2cKaW5kZXggMzExMzk5OTBmNjQ3YzE5NWZkZWM5OGJmM2FhYzYzOTNjMDMxNTI5MC4uZTBmMGU4 MDBlMDg2YzQ2MmEwYzkzYjM3ZjU0MTZiZGJkNDQ2NTk0ZiAxMDA2NDQKLS0tIGEvV2ViQ29yZS9D aGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMiBAQAorMjAxMC0w NS0yNiAgWmVsaWRyYWcgSG9ybnVuZyAgPHplbGlkcmFnQGNocm9taXVtLm9yZz4KKworICAgICAg ICBSZXZpZXdlZCBieSBPamFuIFZhZmFpLgorCisgICAgICAgIEZpeGVkIGZyYW1lIHBhZ2UgdXAv ZG93biBzY3JvbGxpbmcgY2FsY3VsYXRpb24uIE1hZGUgc3VyZSB0aGF0IHRoZQorICAgICAgICBj dXJzb3IgbW92ZXMgd2l0aCBwYWdlIHVwL2Rvd24gZXZlbnQuIFBsZWFzZSBub3RlIHRoYXQgbm93 IGZvciBtYWMKKyAgICAgICAgZWRpdGluZyBiZWhhdmlvciB3ZSB3aWxsIHNjcm9sbCB0aGUgY29u dGVudCB0byBjZW50ZXIgdGhlIGN1cnNvciBvbgorICAgICAgICBwYWdlIHVwL2Rvd24gd2hpbGUg b3RoZXIgcGxhdGZvcm1zIHdpbGwgYWxpZ24gdGhlIGN1cnNvciB3aXRoIHRoZSB0b3Agb2YKKyAg ICAgICAgZGlzcGxheWVkIGZyYW1lLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MzgyMTMKKworICAgICAgICBUZXN0czogZWRpdGluZy9pbnB1dC9vcHRp b24tcGFnZS11cC1kb3duLmh0bWwgKGZpeGVkKQorICAgICAgICAgICAgICAgZWRpdGluZy9pbnB1 dC9zY3JvbGwtdmlld3BvcnQtcGFnZS11cC1kb3duLmh0bWwKKworICAgICAgICAqIFdlYkNvcmUu YmFzZS5leHA6CisgICAgICAgICogZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OnZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UpOiBGaXhlZCBwYWdlIHNjcm9sbCBjYWxj dWxhdGlvbi4gTm93IHNjcm9sbCBoZWlnaHQgaXMgY2FsY3VsYXRlZCBvbmx5IGZyb20gdGhlIHZp c2libGUgcG9ydGlvbiBub3QgdGhlIGVudGlyZSBmcmFtZSBoZWlnaHQuCisgICAgICAgIChXZWJD b3JlOjpleGVjdXRlTW92ZVBhZ2VEb3duKTogTm93IGl0IGNhbiB0ZWxsIFNlbGVjdGlvbkNvbnRy b2xsZXIgdG8gbW92ZSB0aGUgY3Vyc29yIHdpdGggdGhlIHBhZ2Ugc2Nyb2xsIHVwL2Rvd24gZXZl bnRzLgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlmeVNlbGVj dGlvbik6IERpdHRvLgorICAgICAgICAoV2ViQ29yZTo6ZXhlY3V0ZU1vdmVQYWdlVXApOiBEaXR0 by4KKyAgICAgICAgKFdlYkNvcmU6OmV4ZWN1dGVNb3ZlUGFnZVVwQW5kTW9kaWZ5U2VsZWN0aW9u KTogRGl0dG8uCisgICAgICAgICogZWRpdGluZy9TZWxlY3Rpb25Db250cm9sbGVyLmNwcDoKKyAg ICAgICAgKiBlZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwOiBFeHBvc2VkIGFuIGVudW0g cGFyYW0gdGhhdCBsZXRzIEVkaXRvckNvbW1hbmQuY3BwIGNvbnRyb2wgaG93IGN1cnNvciBwb3Np dGlvbiB3aWxsIGJlIGFsaWduZWQgd2hlbiBwYWdlIG1vdmVzLgorICAgICAgICAoV2ViQ29yZTo6 U2VsZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKTogRGl0dG8uCisgICAgICAgIChXZWJD b3JlOjpTZWxlY3Rpb25Db250cm9sbGVyOjptb2RpZnkpOiBEaXR0by4KKyAgICAgICAgKiBlZGl0 aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuaDogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpTZWxl Y3Rpb25Db250cm9sbGVyOjopOiBEaXR0by4KKyAgICAgICAgKFdlYkNvcmU6OlNlbGVjdGlvbkNv bnRyb2xsZXI6OnNldFNlbGVjdGlvbik6IERpdHRvLgorCiAyMDEwLTA1LTI1ICBEdW1pdHJ1IERh bmlsaXVjICA8ZHVtaUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgY2hhbmdp bmcgImZ0czIiIHRvICJmdHMzIiBpbiBvbmUgbG9jYXRpb24gSSBtaXNzZWQgaW4gcjYwMTg4Lgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhwIGIvV2ViQ29yZS9XZWJDb3JlLmJh c2UuZXhwCmluZGV4IDAxNjEzMWYwOWRlMmNlNTkwYTc0YWYxNzdkOTIyZDg4MGIxODg3MDMuLmM3 OTliODQ1M2Q0YjBlYmE1ZDYzM2M4MGMxMDE5MjRlNDFlMzg2NjUgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvV2ViQ29yZS5iYXNlLmV4cAorKysgYi9XZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAKQEAgLTQy MSw3ICs0MjEsNyBAQCBfX1pON1dlYkNvcmUxOUFuaW1hdGlvbkNvbnRyb2xsZXIyMXBhdXNlVHJh bnNpdGlvbkF0VGltZUVQTlNfMTJSZW5kZXJPYmplY3RFUktOUwogX19aTjdXZWJDb3JlMTlDU1NT dHlsZURlY2xhcmF0aW9uMTFzZXRQcm9wZXJ0eUVSS05TXzZTdHJpbmdFUzNfUmkKIF9fWk43V2Vi Q29yZTE5SW5zcGVjdG9yQ29udHJvbGxlcjM0aW5zcGVjdG9yU3RhcnRzQXR0YWNoZWRTZXR0aW5n TmFtZUV2CiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXIxMHNldEZvY3VzZWRFYgot X19aTjdXZWJDb3JlMTlTZWxlY3Rpb25Db250cm9sbGVyMTJzZXRTZWxlY3Rpb25FUktOU18xNlZp c2libGVTZWxlY3Rpb25FYmJiTlNfMTVUZXh0R3JhbnVsYXJpdHlFCitfX1pON1dlYkNvcmUxOVNl bGVjdGlvbkNvbnRyb2xsZXIxMnNldFNlbGVjdGlvbkVSS05TXzE2VmlzaWJsZVNlbGVjdGlvbkVi YmJOUzBfMTlDdXJzb3JBbGlnbk9uU2Nyb2xsRU5TXzE1VGV4dEdyYW51bGFyaXR5RQogX19aTjdX ZWJDb3JlMTlTZWxlY3Rpb25Db250cm9sbGVyMTZzZXRTZWxlY3RlZFJhbmdlRVBOU181UmFuZ2VF TlNfOUVBZmZpbml0eUViCiBfX1pON1dlYkNvcmUxOVNlbGVjdGlvbkNvbnRyb2xsZXI1Y2xlYXJF dgogX19aTjdXZWJDb3JlMTlTZWxlY3Rpb25Db250cm9sbGVyNm1vZGlmeUVOUzBfMTFFQWx0ZXJh dGlvbkVOUzBfMTBFRGlyZWN0aW9uRU5TXzE1VGV4dEdyYW51bGFyaXR5RWIKZGlmZiAtLWdpdCBh L1dlYkNvcmUvZWRpdGluZy9FZGl0b3JDb21tYW5kLmNwcCBiL1dlYkNvcmUvZWRpdGluZy9FZGl0 b3JDb21tYW5kLmNwcAppbmRleCA0Y2IzNGFjYmNkYzIwOTAzMmU4NGM2MjM5ZjdlOTZlZTgzODQ1 ZGQyLi5kMjExZWNjZWMzOWNkMjczMGZmNTFhYjQ0ZmZjYWFhYjM5ZjYzMGUxIDEwMDY0NAotLS0g YS9XZWJDb3JlL2VkaXRpbmcvRWRpdG9yQ29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5n L0VkaXRvckNvbW1hbmQuY3BwCkBAIC00MSwxMyArNDEsMTMgQEAKICNpbmNsdWRlICJFdmVudEhh bmRsZXIuaCIKICNpbmNsdWRlICJGb3JtYXRCbG9ja0NvbW1hbmQuaCIKICNpbmNsdWRlICJGcmFt ZS5oIgorI2luY2x1ZGUgIkZyYW1lVmlldy5oIgogI2luY2x1ZGUgIkhUTUxGb250RWxlbWVudC5o IgogI2luY2x1ZGUgIkhUTUxIUkVsZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MSW1hZ2VFbGVtZW50 LmgiCiAjaW5jbHVkZSAiSW5kZW50T3V0ZGVudENvbW1hbmQuaCIKICNpbmNsdWRlICJJbnNlcnRM aXN0Q29tbWFuZC5oIgogI2luY2x1ZGUgIlBhZ2UuaCIKLSNpbmNsdWRlICJSZW5kZXJCb3guaCIK ICNpbmNsdWRlICJSZXBsYWNlU2VsZWN0aW9uQ29tbWFuZC5oIgogI2luY2x1ZGUgIlNjcm9sbGJh ci5oIgogI2luY2x1ZGUgIlNldHRpbmdzLmgiCkBAIC0yNTksNyArMjU5LDggQEAgc3RhdGljIGlu dCB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKEZyYW1lKiBmcmFtZSkKICAgICAgICAgcmV0dXJuIDA7 CiAgICAgaWYgKCEoc3R5bGUtPm92ZXJmbG93WSgpID09IE9TQ1JPTEwgfHwgc3R5bGUtPm92ZXJm bG93WSgpID09IE9BVVRPIHx8IGZvY3VzZWROb2RlLT5pc0NvbnRlbnRFZGl0YWJsZSgpKSkKICAg ICAgICAgcmV0dXJuIDA7Ci0gICAgaW50IGhlaWdodCA9IHRvUmVuZGVyQm94KHJlbmRlcmVyKS0+ Y2xpZW50SGVpZ2h0KCk7CisgICAgaW50IGhlaWdodCA9IHN0ZDo6bWluPGludD4odG9SZW5kZXJC b3gocmVuZGVyZXIpLT5jbGllbnRIZWlnaHQoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBmcmFtZS0+dmlldygpLT52aXNpYmxlSGVpZ2h0KCkpOwogICAgIHJldHVybiBtYXgobWF4 PGludD4oaGVpZ2h0ICogU2Nyb2xsYmFyOjptaW5GcmFjdGlvblRvU3RlcFdoZW5QYWdpbmcoKSwg aGVpZ2h0IC0gU2Nyb2xsYmFyOjptYXhPdmVybGFwQmV0d2VlblBhZ2VzKCkpLCAxKTsKIH0KIApA QCAtNjQ2LDcgKzY0Nyw3IEBAIHN0YXRpYyBib29sIGV4ZWN1dGVNb3ZlUGFnZURvd24oRnJhbWUq IGZyYW1lLCBFdmVudCosIEVkaXRvckNvbW1hbmRTb3VyY2UsIGNvbnN0CiAgICAgaW50IGRpc3Rh bmNlID0gdmVydGljYWxTY3JvbGxEaXN0YW5jZShmcmFtZSk7CiAgICAgaWYgKCFkaXN0YW5jZSkK ICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgIHJldHVybiBmcmFtZS0+c2VsZWN0aW9uKCktPm1v ZGlmeShTZWxlY3Rpb25Db250cm9sbGVyOjpNT1ZFLCBkaXN0YW5jZSwgdHJ1ZSk7CisgICAgcmV0 dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6Ok1PVkUs IGRpc3RhbmNlLCB0cnVlLCBTZWxlY3Rpb25Db250cm9sbGVyOjpBbGlnbkN1cnNvck9uU2Nyb2xs QWx3YXlzKTsKIH0KIAogc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlRG93bkFuZE1vZGlmeVNl bGVjdGlvbihGcmFtZSogZnJhbWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3Qg U3RyaW5nJikKQEAgLTY1NCw3ICs2NTUsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VE b3duQW5kTW9kaWZ5U2VsZWN0aW9uKEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDbwogICAg IGludCBkaXN0YW5jZSA9IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoZnJhbWUpOwogICAgIGlmICgh ZGlzdGFuY2UpCiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVj dGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6RVhURU5ELCBkaXN0YW5jZSwgdHJ1 ZSk7CisgICAgcmV0dXJuIGZyYW1lLT5zZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRy b2xsZXI6OkVYVEVORCwgZGlzdGFuY2UsIHRydWUsIFNlbGVjdGlvbkNvbnRyb2xsZXI6OkFsaWdu Q3Vyc29yT25TY3JvbGxBbHdheXMpOwogfQogCiBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VV cChGcmFtZSogZnJhbWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3QgU3RyaW5n JikKQEAgLTY2Miw3ICs2NjMsNyBAQCBzdGF0aWMgYm9vbCBleGVjdXRlTW92ZVBhZ2VVcChGcmFt ZSogZnJhbWUsIEV2ZW50KiwgRWRpdG9yQ29tbWFuZFNvdXJjZSwgY29uc3QgUwogICAgIGludCBk aXN0YW5jZSA9IHZlcnRpY2FsU2Nyb2xsRGlzdGFuY2UoZnJhbWUpOwogICAgIGlmICghZGlzdGFu Y2UpCiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigp LT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6TU9WRSwgLWRpc3RhbmNlLCB0cnVlKTsKKyAg ICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2RpZnkoU2VsZWN0aW9uQ29udHJvbGxlcjo6 TU9WRSwgLWRpc3RhbmNlLCB0cnVlLCBTZWxlY3Rpb25Db250cm9sbGVyOjpBbGlnbkN1cnNvck9u U2Nyb2xsQWx3YXlzKTsKIH0KIAogc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQYWdlVXBBbmRNb2Rp ZnlTZWxlY3Rpb24oRnJhbWUqIGZyYW1lLCBFdmVudCosIEVkaXRvckNvbW1hbmRTb3VyY2UsIGNv bnN0IFN0cmluZyYpCkBAIC02NzAsNyArNjcxLDcgQEAgc3RhdGljIGJvb2wgZXhlY3V0ZU1vdmVQ YWdlVXBBbmRNb2RpZnlTZWxlY3Rpb24oRnJhbWUqIGZyYW1lLCBFdmVudCosIEVkaXRvckNvbW0K ICAgICBpbnQgZGlzdGFuY2UgPSB2ZXJ0aWNhbFNjcm9sbERpc3RhbmNlKGZyYW1lKTsKICAgICBp ZiAoIWRpc3RhbmNlKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgcmV0dXJuIGZyYW1lLT5z ZWxlY3Rpb24oKS0+bW9kaWZ5KFNlbGVjdGlvbkNvbnRyb2xsZXI6OkVYVEVORCwgLWRpc3RhbmNl LCB0cnVlKTsKKyAgICByZXR1cm4gZnJhbWUtPnNlbGVjdGlvbigpLT5tb2RpZnkoU2VsZWN0aW9u Q29udHJvbGxlcjo6RVhURU5ELCAtZGlzdGFuY2UsIHRydWUsIFNlbGVjdGlvbkNvbnRyb2xsZXI6 OkFsaWduQ3Vyc29yT25TY3JvbGxBbHdheXMpOwogfQogCiBzdGF0aWMgYm9vbCBleGVjdXRlTW92 ZVJpZ2h0KEZyYW1lKiBmcmFtZSwgRXZlbnQqLCBFZGl0b3JDb21tYW5kU291cmNlLCBjb25zdCBT dHJpbmcmKQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIu Y3BwIGIvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRyb2xsZXIuY3BwCmluZGV4IGRiMGUw NGQ4YmI3ZGUyOTA1ODc4ZTZmMmQ3N2Q4ZWVkZTlkYjIzODMuLjhiMzgyN2Q1Y2IxNWZkZWJjNmQ1 ZGY3Yjg4ZDY0Y2RhMTY5ZmU1YTcgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9TZWxlY3Rp b25Db250cm9sbGVyLmNwcAorKysgYi9XZWJDb3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxl ci5jcHAKQEAgLTc5LDkgKzc5LDkgQEAgU2VsZWN0aW9uQ29udHJvbGxlcjo6U2VsZWN0aW9uQ29u dHJvbGxlcihGcmFtZSogZnJhbWUsIGJvb2wgaXNEcmFnQ2FyZXRDb250cm9sbGUKICAgICBzZXRJ c0RpcmVjdGlvbmFsKGZhbHNlKTsKIH0KIAotdm9pZCBTZWxlY3Rpb25Db250cm9sbGVyOjptb3Zl VG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uICZwb3MsIGJvb2wgdXNlclRyaWdnZXJlZCkKK3ZvaWQg U2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRvKGNvbnN0IFZpc2libGVQb3NpdGlvbiAmcG9zLCBi b29sIHVzZXJUcmlnZ2VyZWQsIEN1cnNvckFsaWduT25TY3JvbGwgYWxpZ24pCiB7Ci0gICAgc2V0 U2VsZWN0aW9uKFZpc2libGVTZWxlY3Rpb24ocG9zLmRlZXBFcXVpdmFsZW50KCksIHBvcy5kZWVw RXF1aXZhbGVudCgpLCBwb3MuYWZmaW5pdHkoKSksIHRydWUsIHRydWUsIHVzZXJUcmlnZ2VyZWQp OworICAgIHNldFNlbGVjdGlvbihWaXNpYmxlU2VsZWN0aW9uKHBvcy5kZWVwRXF1aXZhbGVudCgp LCBwb3MuZGVlcEVxdWl2YWxlbnQoKSwgcG9zLmFmZmluaXR5KCkpLCB0cnVlLCB0cnVlLCB1c2Vy VHJpZ2dlcmVkLCBhbGlnbik7CiB9CiAKIHZvaWQgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW92ZVRv KGNvbnN0IFZpc2libGVQb3NpdGlvbiAmYmFzZSwgY29uc3QgVmlzaWJsZVBvc2l0aW9uICZleHRl bnQsIGJvb2wgdXNlclRyaWdnZXJlZCkKQEAgLTEwNSw3ICsxMDUsNyBAQCB2b2lkIFNlbGVjdGlv bkNvbnRyb2xsZXI6Om1vdmVUbyhjb25zdCBQb3NpdGlvbiAmYmFzZSwgY29uc3QgUG9zaXRpb24g JmV4dGVudCwgRQogICAgIHNldFNlbGVjdGlvbihWaXNpYmxlU2VsZWN0aW9uKGJhc2UsIGV4dGVu dCwgYWZmaW5pdHkpLCB0cnVlLCB0cnVlLCB1c2VyVHJpZ2dlcmVkKTsKIH0KIAotdm9pZCBTZWxl Y3Rpb25Db250cm9sbGVyOjpzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYgcywg Ym9vbCBjbG9zZVR5cGluZywgYm9vbCBjbGVhclR5cGluZ1N0eWxlLCBib29sIHVzZXJUcmlnZ2Vy ZWQsIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSkKK3ZvaWQgU2VsZWN0aW9uQ29udHJvbGxl cjo6c2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHMsIGJvb2wgY2xvc2VUeXBp bmcsIGJvb2wgY2xlYXJUeXBpbmdTdHlsZSwgYm9vbCB1c2VyVHJpZ2dlcmVkLCBDdXJzb3JBbGln bk9uU2Nyb2xsIGFsaWduLCBUZXh0R3JhbnVsYXJpdHkgZ3JhbnVsYXJpdHkpCiB7CiAgICAgbV9n cmFudWxhcml0eSA9IGdyYW51bGFyaXR5OwogCkBAIC0xNjEsOCArMTYxLDE2IEBAIHZvaWQgU2Vs ZWN0aW9uQ29udHJvbGxlcjo6c2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHMs IGJvb2wgY2xvc2VUeXBpCiAgICAgc2VsZWN0RnJhbWVFbGVtZW50SW5QYXJlbnRJZkZ1bGx5U2Vs ZWN0ZWQoKTsKICAgICBtX2ZyYW1lLT5ub3RpZnlSZW5kZXJlck9mU2VsZWN0aW9uQ2hhbmdlKHVz ZXJUcmlnZ2VyZWQpOwogICAgIG1fZnJhbWUtPnJlc3BvbmRUb0NoYW5nZWRTZWxlY3Rpb24ob2xk U2VsZWN0aW9uLCBjbG9zZVR5cGluZyk7Ci0gICAgaWYgKHVzZXJUcmlnZ2VyZWQpCi0gICAgICAg IG1fZnJhbWUtPnJldmVhbFNlbGVjdGlvbihTY3JvbGxBbGlnbm1lbnQ6OmFsaWduVG9FZGdlSWZO ZWVkZWQsIHRydWUpOworICAgIGlmICh1c2VyVHJpZ2dlcmVkKSB7CisgICAgICAgIFNjcm9sbEFs aWdubWVudCBhbGlnbm1lbnQ7CisKKyAgICAgICAgaWYgKG1fZnJhbWUtPnNldHRpbmdzKCkgJiYg bV9mcmFtZS0+c2V0dGluZ3MoKS0+ZWRpdGluZ0JlaGF2aW9yKCkgPT0gRWRpdGluZ01hY0JlaGF2 aW9yKQorICAgICAgICAgICAgYWxpZ25tZW50ID0gKGFsaWduID09IEFsaWduQ3Vyc29yT25TY3Jv bGxBbHdheXMpID8gU2Nyb2xsQWxpZ25tZW50OjphbGlnbkNlbnRlckFsd2F5cyA6IFNjcm9sbEFs aWdubWVudDo6YWxpZ25DZW50ZXJJZk5lZWRlZDsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAg YWxpZ25tZW50ID0gKGFsaWduID09IEFsaWduQ3Vyc29yT25TY3JvbGxBbHdheXMpID8gU2Nyb2xs QWxpZ25tZW50OjphbGlnblRvcEFsd2F5cyA6IFNjcm9sbEFsaWdubWVudDo6YWxpZ25Ub0VkZ2VJ Zk5lZWRlZDsKKworICAgICAgICBtX2ZyYW1lLT5yZXZlYWxTZWxlY3Rpb24oYWxpZ25tZW50LCB0 cnVlKTsKKyAgICB9CiAKICAgICBub3RpZnlBY2Nlc3NpYmlsaXR5Rm9yU2VsZWN0aW9uQ2hhbmdl KCk7CiB9CkBAIC03MTQsNyArNzIyLDcgQEAgc3RhdGljIGJvb2wgYWJzb2x1dGVDYXJldFkoY29u c3QgVmlzaWJsZVBvc2l0aW9uICZjLCBpbnQgJnkpCiAgICAgcmV0dXJuIHRydWU7CiB9CiAKLWJv b2wgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVBbHRlcmF0aW9uIGFsdGVyLCBpbnQgdmVy dGljYWxEaXN0YW5jZSwgYm9vbCB1c2VyVHJpZ2dlcmVkKQorYm9vbCBTZWxlY3Rpb25Db250cm9s bGVyOjptb2RpZnkoRUFsdGVyYXRpb24gYWx0ZXIsIGludCB2ZXJ0aWNhbERpc3RhbmNlLCBib29s IHVzZXJUcmlnZ2VyZWQsIEN1cnNvckFsaWduT25TY3JvbGwgYWxpZ24pCiB7CiAgICAgaWYgKHZl cnRpY2FsRGlzdGFuY2UgPT0gMCkKICAgICAgICAgcmV0dXJuIGZhbHNlOwpAQCAtNzgyLDcgKzc5 MCw3IEBAIGJvb2wgU2VsZWN0aW9uQ29udHJvbGxlcjo6bW9kaWZ5KEVBbHRlcmF0aW9uIGFsdGVy LCBpbnQgdmVydGljYWxEaXN0YW5jZSwgYm9vbCB1CiAKICAgICBzd2l0Y2ggKGFsdGVyKSB7CiAg ICAgICAgIGNhc2UgTU9WRToKLSAgICAgICAgICAgIG1vdmVUbyhyZXN1bHQsIHVzZXJUcmlnZ2Vy ZWQpOworICAgICAgICAgICAgbW92ZVRvKHJlc3VsdCwgdXNlclRyaWdnZXJlZCwgYWxpZ24pOwog ICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIGNhc2UgRVhURU5EOgogICAgICAgICAgICAgc2V0 RXh0ZW50KHJlc3VsdCwgdXNlclRyaWdnZXJlZCk7CmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRp bmcvU2VsZWN0aW9uQ29udHJvbGxlci5oIGIvV2ViQ29yZS9lZGl0aW5nL1NlbGVjdGlvbkNvbnRy b2xsZXIuaAppbmRleCA5YTQwN2ZjMGM1ZDkyM2VmNjJhYzMwNGRiZGQ1NzA5NDg3ZTIwNmIzLi5j M2RjMmYyZWFkYzNhZTlhNGM4NjBiZDA3OTY3M2JhOTUzMTYyYTEzIDEwMDY0NAotLS0gYS9XZWJD b3JlL2VkaXRpbmcvU2VsZWN0aW9uQ29udHJvbGxlci5oCisrKyBiL1dlYkNvcmUvZWRpdGluZy9T ZWxlY3Rpb25Db250cm9sbGVyLmgKQEAgLTQ1LDYgKzQ1LDggQEAgY2xhc3MgU2VsZWN0aW9uQ29u dHJvbGxlciA6IHB1YmxpYyBOb25jb3B5YWJsZSB7CiBwdWJsaWM6CiAgICAgZW51bSBFQWx0ZXJh dGlvbiB7IE1PVkUsIEVYVEVORCB9OwogICAgIGVudW0gRURpcmVjdGlvbiB7IEZPUldBUkQsIEJB Q0tXQVJELCBSSUdIVCwgTEVGVCB9OworICAgIGVudW0gQ3Vyc29yQWxpZ25PblNjcm9sbCB7IEFs aWduQ3Vyc29yT25TY3JvbGxJZk5lZWRlZCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBBbGlnbkN1cnNvck9uU2Nyb2xsQWx3YXlzIH07CiAKICAgICBTZWxlY3Rpb25Db250cm9sbGVy KEZyYW1lKiA9IDAsIGJvb2wgaXNEcmFnQ2FyZXRDb250cm9sbGVyID0gZmFsc2UpOwogCkBAIC01 NCwxNCArNTYsMTQgQEAgcHVibGljOgogICAgIE5vZGUqIHNoYWRvd1RyZWVSb290Tm9kZSgpIGNv bnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uLnNoYWRvd1RyZWVSb290Tm9kZSgpOyB9CiAgICAgIAog ICAgIHZvaWQgbW92ZVRvKGNvbnN0IFJhbmdlKiwgRUFmZmluaXR5LCBib29sIHVzZXJUcmlnZ2Vy ZWQgPSBmYWxzZSk7Ci0gICAgdm9pZCBtb3ZlVG8oY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgYm9v bCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UpOworICAgIHZvaWQgbW92ZVRvKGNvbnN0IFZpc2libGVQ b3NpdGlvbiYsIGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlLCBDdXJzb3JBbGlnbk9uU2Nyb2xs ID0gQWxpZ25DdXJzb3JPblNjcm9sbElmTmVlZGVkKTsKICAgICB2b2lkIG1vdmVUbyhjb25zdCBW aXNpYmxlUG9zaXRpb24mLCBjb25zdCBWaXNpYmxlUG9zaXRpb24mLCBib29sIHVzZXJUcmlnZ2Vy ZWQgPSBmYWxzZSk7CiAgICAgdm9pZCBtb3ZlVG8oY29uc3QgUG9zaXRpb24mLCBFQWZmaW5pdHks IGJvb2wgdXNlclRyaWdnZXJlZCA9IGZhbHNlKTsKICAgICB2b2lkIG1vdmVUbyhjb25zdCBQb3Np dGlvbiYsIGNvbnN0IFBvc2l0aW9uJiwgRUFmZmluaXR5LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBm YWxzZSk7CiAKICAgICBjb25zdCBWaXNpYmxlU2VsZWN0aW9uJiBzZWxlY3Rpb24oKSBjb25zdCB7 IHJldHVybiBtX3NlbGVjdGlvbjsgfQotICAgIHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZpc2li bGVTZWxlY3Rpb24mLCBib29sIGNsb3NlVHlwaW5nID0gdHJ1ZSwgYm9vbCBjbGVhclR5cGluZ1N0 eWxlID0gdHJ1ZSwgYm9vbCB1c2VyVHJpZ2dlcmVkID0gZmFsc2UsIFRleHRHcmFudWxhcml0eSA9 IENoYXJhY3RlckdyYW51bGFyaXR5KTsKLSAgICB2b2lkIHNldFNlbGVjdGlvbihjb25zdCBWaXNp YmxlU2VsZWN0aW9uJiBzZWxlY3Rpb24sIFRleHRHcmFudWxhcml0eSBncmFudWxhcml0eSkgeyBz ZXRTZWxlY3Rpb24oc2VsZWN0aW9uLCB0cnVlLCB0cnVlLCBmYWxzZSwgZ3JhbnVsYXJpdHkpOyB9 CisgICAgdm9pZCBzZXRTZWxlY3Rpb24oY29uc3QgVmlzaWJsZVNlbGVjdGlvbiYsIGJvb2wgY2xv c2VUeXBpbmcgPSB0cnVlLCBib29sIGNsZWFyVHlwaW5nU3R5bGUgPSB0cnVlLCBib29sIHVzZXJU cmlnZ2VyZWQgPSBmYWxzZSwgQ3Vyc29yQWxpZ25PblNjcm9sbCA9IEFsaWduQ3Vyc29yT25TY3Jv bGxJZk5lZWRlZCwgVGV4dEdyYW51bGFyaXR5ID0gQ2hhcmFjdGVyR3JhbnVsYXJpdHkpOworICAg IHZvaWQgc2V0U2VsZWN0aW9uKGNvbnN0IFZpc2libGVTZWxlY3Rpb24mIHNlbGVjdGlvbiwgVGV4 dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5KSB7IHNldFNlbGVjdGlvbihzZWxlY3Rpb24sIHRydWUs IHRydWUsIGZhbHNlLCBBbGlnbkN1cnNvck9uU2Nyb2xsSWZOZWVkZWQsIGdyYW51bGFyaXR5KTsg fQogICAgIGJvb2wgc2V0U2VsZWN0ZWRSYW5nZShSYW5nZSosIEVBZmZpbml0eSwgYm9vbCBjbG9z ZVR5cGluZyk7CiAgICAgdm9pZCBzZWxlY3RBbGwoKTsKICAgICB2b2lkIGNsZWFyKCk7CkBAIC03 Niw3ICs3OCw3IEBAIHB1YmxpYzoKICAgICBFQWZmaW5pdHkgYWZmaW5pdHkoKSBjb25zdCB7IHJl dHVybiBtX3NlbGVjdGlvbi5hZmZpbml0eSgpOyB9CiAKICAgICBib29sIG1vZGlmeShFQWx0ZXJh dGlvbiwgRURpcmVjdGlvbiwgVGV4dEdyYW51bGFyaXR5LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBm YWxzZSk7Ci0gICAgYm9vbCBtb2RpZnkoRUFsdGVyYXRpb24sIGludCB2ZXJ0aWNhbERpc3RhbmNl LCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSk7CisgICAgYm9vbCBtb2RpZnkoRUFsdGVyYXRp b24sIGludCB2ZXJ0aWNhbERpc3RhbmNlLCBib29sIHVzZXJUcmlnZ2VyZWQgPSBmYWxzZSwgQ3Vy c29yQWxpZ25PblNjcm9sbCA9IEFsaWduQ3Vyc29yT25TY3JvbGxJZk5lZWRlZCk7CiAgICAgVGV4 dEdyYW51bGFyaXR5IGdyYW51bGFyaXR5KCkgY29uc3QgeyByZXR1cm4gbV9ncmFudWxhcml0eTsg fQogCiAgICAgdm9pZCBzZXRTdGFydChjb25zdCBWaXNpYmxlUG9zaXRpb24gJiwgYm9vbCB1c2Vy VHJpZ2dlcmVkID0gZmFsc2UpOwo=