102560 2012-11-16 14:21:47 -0800 Text Autosizing: Work out what to do about form controls 2013-01-14 07:51:20 -0800 1 1 1 Unclassified WebKit Layout and Rendering 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P1 Normal --- 84186 106797 1 johnme timvolodine eric jchaffraix kenneth ojan.autocc webkit.review.bot oldest_to_newest 769674 0 johnme 2012-11-16 14:21:47 -0800 Text Autosizing isn't currently able to resize most form controls. - It can resize <button> - It can resize <select>, but their width ends up incorrect - It can't resize <input type="text"> - It can't resize <input type="checkbox"> Chrome for Android's legacy implementation used to avoid autosizing blocks that contained inputs, text areas, text fields or menu lists (see RenderBlock.cpp's resizeTextPermitted and RenderBlock::adjustComputedFontSizes in https://bugs.webkit.org/attachment.cgi?id=143381). That might be a reasonable short term step. But ultimately it seems it would be much nicer if we were able to just scale all of these up proportionately. 787431 1 178577 timvolodine 2012-12-10 09:56:21 -0800 Created attachment 178577 Patch 787439 2 178578 timvolodine 2012-12-10 10:01:21 -0800 Created attachment 178578 Patch 787445 3 178578 timvolodine 2012-12-10 10:03:17 -0800 Comment on attachment 178578 Patch please have a look at this CL 788367 4 178787 timvolodine 2012-12-11 05:56:27 -0800 Created attachment 178787 illustration of the impact on the form controls elements 789454 5 178578 johnme 2012-12-12 04:37:15 -0800 Comment on attachment 178578 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=178578&action=review First pass review comments. > Source/WebCore/rendering/TextAutosizer.cpp:126 > +bool TextAutosizer::contentHeightIsConstrained(const RenderBlock* container) Can you rename this method, now that it's not just dealing with constrained height, e.g. to containerShouldBeAutosized? Also it was at jchaffraix's suggestion that this function was given static linkage in TextAutosizer.cpp and not exposed in the header. Though it's probably not worth fretting about this right now, as I think avayvod has a patch in the works to give a whole bunch of these functions static linkage and move them out of the header, so he can keep this consistent when he does that. > Source/WebCore/rendering/TextAutosizer.cpp:131 > + QualifiedName tags[4] = {inputTag, textareaTag, buttonTag, formTag}; What about selectTag? And formTag is a tricky one; it probably does make sense to exclude it; but I suspect some sites will misuse this and wrap their entire page in a form element... > Source/WebCore/rendering/TextAutosizer.cpp:132 > + if (containerContainsTags(container, tags, 4)) It's not clear that the 4 depends on the length of the list of tags. I'd suggest at least using sizeof to avoid hardcoding this. Kenneth/Julien can probably best advise whether it would be better to use a Vector or whether this is fine. 789572 6 178578 timvolodine 2012-12-12 08:15:45 -0800 Comment on attachment 178578 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=178578&action=review >> Source/WebCore/rendering/TextAutosizer.cpp:126 >> +bool TextAutosizer::contentHeightIsConstrained(const RenderBlock* container) > > Can you rename this method, now that it's not just dealing with constrained height, e.g. to containerShouldBeAutosized? > > Also it was at jchaffraix's suggestion that this function was given static linkage in TextAutosizer.cpp and not exposed in the header. Though it's probably not worth fretting about this right now, as I think avayvod has a patch in the works to give a whole bunch of these functions static linkage and move them out of the header, so he can keep this consistent when he does that. done >> Source/WebCore/rendering/TextAutosizer.cpp:131 >> + QualifiedName tags[4] = {inputTag, textareaTag, buttonTag, formTag}; > > What about selectTag? > And formTag is a tricky one; it probably does make sense to exclude it; but I suspect some sites will misuse this and wrap their entire page in a form element... done, also removed form tag >> Source/WebCore/rendering/TextAutosizer.cpp:132 >> + if (containerContainsTags(container, tags, 4)) > > It's not clear that the 4 depends on the length of the list of tags. I'd suggest at least using sizeof to avoid hardcoding this. Kenneth/Julien can probably best advise whether it would be better to use a Vector or whether this is fine. done, using Vector now 789607 7 179060 timvolodine 2012-12-12 08:57:56 -0800 Created attachment 179060 Patch 789609 8 179060 timvolodine 2012-12-12 08:59:25 -0800 Comment on attachment 179060 Patch latest patch with the fixed comments from JohnM 789691 9 179060 johnme 2012-12-12 10:41:08 -0800 Comment on attachment 179060 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179060&action=review A couple more comments (some of which I intended to submit earlier, but somehow got missed out). > Source/WebCore/rendering/TextAutosizer.cpp:233 > + if (parent->isRenderButton() || parent->isTextControl() || parent->isMenuList()) Looking at HTMLSelectElement::createRenderer, <select> elements allowing multiple selection can also be rendered as a RenderListBox (instead of a RenderMenuList). And this still doesn't seem exhaustive. For example <input type="file"> creates a RenderFileUploadControl which contains text (the filename) alongside a button (see FileInputType::createRenderer). Ultimately listing all the render classes corresponding to the different input types doesn't seem sustainable. Can you instead do a tagname-based check? e.g.: Node* parentNode = renderer->parent() ? renderer->parent()->generatingNode() : 0; if (parentNode && parentNode->isElement() && s_inputTagNames.contains(toElement(parentNode)->tagQName())) return false; > Source/WebCore/rendering/TextAutosizer.cpp:297 > +bool TextAutosizer::containerContainsTags(const RenderObject* container, Vector<QualifiedName>& tags) Nit: If it's a container, it's guaranteed to be a RenderBlock, so please pass it in as such to make things clearer. > Source/WebCore/rendering/TextAutosizer.cpp:299 > + const Node* containerNode = container->node(); I don't think you need to special-case the container. Just do: const RenderObject* object = container; while (object) { ... object = nextInPreOrderSkippingDescendantsOfContainers(descendant, container); } > Source/WebCore/rendering/TextAutosizer.cpp:311 > + bool validCandidate = descendantNode && descendantNode->isHTMLElement() && !descendantNode->isShadowRoot(); Can you add a comment explaining why you need to check isShadowRoot? > LayoutTests/fast/text-autosizing/form-controls-boosting-button-textarea-input-elements.html:84 > + <th align="right"><label for="Bugzilla_login">Login:</label></th> This test is much too complicated. For example it's clearly irrelevant whether this label refers to "Bugilla_login" or some other field. Please reduce it to a minimal test-case[1]. [1]: https://wiki.mozilla.org/QA/Minimal_Test_Cases > LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element-expected.html:15 > + #boosted { I prefer to leave the relevant* styles inline in Text Autosizing layout tests. While it's a good idea to separate presentation (CSS) from content (HTML) when building a website, for layout tests since they're supposed to be very simple, it's usually easier to have the styles inline so you can see immediately how everything behaves. *: (i.e. not generic things applied to the body, but the properties whose interactions are being tested - in this case just the boosted font size) > LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element-expected.html:16 > + font-size: 2.05rem; Huh - 2.05x is a strange multiplier. Normally in these tests the multiplier is 800/320 = 2.5x. What's happening? > LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element.html:11 > + font-family: Verdana, sans-serif; The font-family shouldn't make a difference, so can be removed. > LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element.html:12 > + font-size: small; Please specify a pixel font size (e.g. 16px), then in the text below you can make a statement, like "This text should be autosized to 40px computed font-size (16 * 800/320)." > LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element.html:30 > +This tests the boosting of check boxes. This paragraph should be boosted, while Please don't talk about boosting. The WebKit term for this is Text Autosizing, so for example instead of "paragraph foo has been boosted" write "paragraph foo has been autosized", and instead of "paragraph foo has been boosted more than paragraph bar" write "paragraph foo has been autosized with a larger multiplier than paragraph bar". Ditto elsewhere :) > LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element.html:32 > +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ It's best to use Lorem ipsum text like the other tests, as a long string of +'s like this could behave stranglely since it can't be wrapped. > LayoutTests/fast/text-autosizing/form-controls-boosting-select-element.html:39 > + <option value=option1>Option 1</option> Please always use double quotes around attributes, i.e. value="default". In fact, you shouldn't even need to specify the value here (see minimal test cases earlier). 790669 10 179060 timvolodine 2012-12-13 09:21:18 -0800 Comment on attachment 179060 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179060&action=review >> Source/WebCore/rendering/TextAutosizer.cpp:233 >> + if (parent->isRenderButton() || parent->isTextControl() || parent->isMenuList()) > > Looking at HTMLSelectElement::createRenderer, <select> elements allowing multiple selection can also be rendered as a RenderListBox (instead of a RenderMenuList). > > And this still doesn't seem exhaustive. For example <input type="file"> creates a RenderFileUploadControl which contains text (the filename) alongside a button (see FileInputType::createRenderer). > > Ultimately listing all the render classes corresponding to the different input types doesn't seem sustainable. Can you instead do a tagname-based check? e.g.: > Node* parentNode = renderer->parent() ? renderer->parent()->generatingNode() : 0; > if (parentNode && parentNode->isElement() && s_inputTagNames.contains(toElement(parentNode)->tagQName())) > return false; right, testing for tags is probably better and more consistent done >> Source/WebCore/rendering/TextAutosizer.cpp:297 >> +bool TextAutosizer::containerContainsTags(const RenderObject* container, Vector<QualifiedName>& tags) > > Nit: If it's a container, it's guaranteed to be a RenderBlock, so please pass it in as such to make things clearer. done >> Source/WebCore/rendering/TextAutosizer.cpp:299 >> + const Node* containerNode = container->node(); > > I don't think you need to special-case the container. Just do: > > const RenderObject* object = container; > while (object) { > ... > object = nextInPreOrderSkippingDescendantsOfContainers(descendant, container); > } done >> Source/WebCore/rendering/TextAutosizer.cpp:311 >> + bool validCandidate = descendantNode && descendantNode->isHTMLElement() && !descendantNode->isShadowRoot(); > > Can you add a comment explaining why you need to check isShadowRoot? actually removed testing for isShadowRoot at this point probably not necessary >> LayoutTests/fast/text-autosizing/form-controls-boosting-button-textarea-input-elements.html:84 >> + <th align="right"><label for="Bugzilla_login">Login:</label></th> > > This test is much too complicated. For example it's clearly irrelevant whether this label refers to "Bugilla_login" or some other field. Please reduce it to a minimal test-case[1]. > > [1]: https://wiki.mozilla.org/QA/Minimal_Test_Cases done >> LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element-expected.html:15 >> + #boosted { > > I prefer to leave the relevant* styles inline in Text Autosizing layout tests. While it's a good idea to separate presentation (CSS) from content (HTML) when building a website, for layout tests since they're supposed to be very simple, it's usually easier to have the styles inline so you can see immediately how everything behaves. > > *: (i.e. not generic things applied to the body, but the properties whose interactions are being tested - in this case just the boosted font size) done >> LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element-expected.html:16 >> + font-size: 2.05rem; > > Huh - 2.05x is a strange multiplier. Normally in these tests the multiplier is 800/320 = 2.5x. What's happening? this is because I used {font-size: small} for the body, so after removing this the factor is 2.5 >> LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element.html:11 >> + font-family: Verdana, sans-serif; > > The font-family shouldn't make a difference, so can be removed. done >> LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element.html:12 >> + font-size: small; > > Please specify a pixel font size (e.g. 16px), then in the text below you can make a statement, like "This text should be autosized to 40px computed font-size (16 * 800/320)." removed. done. >> LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element.html:30 >> +This tests the boosting of check boxes. This paragraph should be boosted, while > > Please don't talk about boosting. The WebKit term for this is Text Autosizing, so for example instead of "paragraph foo has been boosted" write "paragraph foo has been autosized", and instead of "paragraph foo has been boosted more than paragraph bar" write "paragraph foo has been autosized with a larger multiplier than paragraph bar". Ditto elsewhere :) ok. done. >> LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element.html:32 >> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ > > It's best to use Lorem ipsum text like the other tests, as a long string of +'s like this could behave stranglely since it can't be wrapped. ok. done. >> LayoutTests/fast/text-autosizing/form-controls-boosting-select-element.html:39 >> + <option value=option1>Option 1</option> > > Please always use double quotes around attributes, i.e. value="default". In fact, you shouldn't even need to specify the value here (see minimal test cases earlier). removed. done. 790674 11 179285 timvolodine 2012-12-13 09:23:44 -0800 Created attachment 179285 Patch 791573 12 179285 johnme 2012-12-14 06:42:59 -0800 Comment on attachment 179285 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179285&action=review I've reviewed the code - just some minor nits. I'll look at the tests next. > Source/WebCore/rendering/TextAutosizer.cpp:54 > + s_inputTags.append(inputTag); You shouldn't initialize a static member from a constructor - if multiple TextAutosizer objects are created (which isn't unlikely, since there's one per document) you will end up with multiple copies of each tag in s_inputTags! In theory you'd use a static initializer for this; though I think they're frowned upon in WebKit (and Chromium). So instead perhaps try the following pattern, which I've seen a few times: #include <wtf/StdLibExtras.h> static const Vector<QualifiedName>& formInputTags() { DEFINE_STATIC_LOCAL(Vector<QualifiedName>, formInputTags, ()); if (formInputTags.isEmpty()) { formInputTags.append(inputTag); formInputTags.append(textareaTag); formInputTags.append(buttonTag); formInputTags.append(selectTag); } return formInputTags; } No guarantees that Julien/Kenneth will like that though :) > Source/WebCore/rendering/TextAutosizer.cpp:132 > +bool TextAutosizer::containerShouldBeAutosized(const RenderBlock* container) You'll need to rebase this now http://wkbug.com/104925 has landed (sorry!). > Source/WebCore/rendering/TextAutosizer.cpp:232 > + // avoid creating containers for text within text controls, buttons, or selection menus. Nits: s/avoid/Avoid/ and s/selection menus/<select> dropdowns/ > Source/WebCore/rendering/TextAutosizer.cpp:234 > + if (parentNode && parentNode->isHTMLElement() && s_inputTags.contains(toElement(parentNode)->tagQName())) Nit: I think parentNode->isElementNode() should be sufficient, instead of isElementNode->isHTMLElement(); ditto below in containerContainsTags. > Source/WebCore/rendering/TextAutosizer.cpp:299 > + const RenderObject* runningObject = container; The term "running" is a little confusing here. It's probably fine to call it either "renderer" or "object". > Source/WebCore/rendering/TextAutosizer.cpp:360 > + // Equalize the depths if containerShouldBeAutosized necessary. Only one of the while loops below will get executed. s/if containerShouldBeAutosized necessary/if necessary/ > LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element.html:29 > +the check boxes below should not be autosized. Lorem ipsum dolor sit amet, consectetur Nit: s/check boxes below/check boxes below and the surrounding text/ > LayoutTests/fast/text-autosizing/form-controls-boosting-radio-input-element.html:29 > +the radio buttons below should not be autosized. Lorem ipsum dolor sit amet, consectetur Nit: s/radio buttons below/radio buttons below and the surrounding text/ 791580 13 179285 timvolodine 2012-12-14 07:10:47 -0800 Comment on attachment 179285 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179285&action=review >> Source/WebCore/rendering/TextAutosizer.cpp:54 >> + s_inputTags.append(inputTag); > > You shouldn't initialize a static member from a constructor - if multiple TextAutosizer objects are created (which isn't unlikely, since there's one per document) you will end up with multiple copies of each tag in s_inputTags! > > In theory you'd use a static initializer for this; though I think they're frowned upon in WebKit (and Chromium). So instead perhaps try the following pattern, which I've seen a few times: > > #include <wtf/StdLibExtras.h> > > static const Vector<QualifiedName>& formInputTags() > { > DEFINE_STATIC_LOCAL(Vector<QualifiedName>, formInputTags, ()); > if (formInputTags.isEmpty()) { > formInputTags.append(inputTag); > formInputTags.append(textareaTag); > formInputTags.append(buttonTag); > formInputTags.append(selectTag); > } > return formInputTags; > } > > No guarantees that Julien/Kenneth will like that though :) oops, done. >> Source/WebCore/rendering/TextAutosizer.cpp:132 >> +bool TextAutosizer::containerShouldBeAutosized(const RenderBlock* container) > > You'll need to rebase this now http://wkbug.com/104925 has landed (sorry!). ack >> Source/WebCore/rendering/TextAutosizer.cpp:232 >> + // avoid creating containers for text within text controls, buttons, or selection menus. > > Nits: s/avoid/Avoid/ and s/selection menus/<select> dropdowns/ done >> Source/WebCore/rendering/TextAutosizer.cpp:234 >> + if (parentNode && parentNode->isHTMLElement() && s_inputTags.contains(toElement(parentNode)->tagQName())) > > Nit: I think parentNode->isElementNode() should be sufficient, instead of isElementNode->isHTMLElement(); ditto below in containerContainsTags. done >> Source/WebCore/rendering/TextAutosizer.cpp:299 >> + const RenderObject* runningObject = container; > > The term "running" is a little confusing here. It's probably fine to call it either "renderer" or "object". done >> Source/WebCore/rendering/TextAutosizer.cpp:360 >> + // Equalize the depths if containerShouldBeAutosized necessary. Only one of the while loops below will get executed. > > s/if containerShouldBeAutosized necessary/if necessary/ done >> LayoutTests/fast/text-autosizing/form-controls-boosting-checkbox-input-element.html:29 >> +the check boxes below should not be autosized. Lorem ipsum dolor sit amet, consectetur > > Nit: s/check boxes below/check boxes below and the surrounding text/ done >> LayoutTests/fast/text-autosizing/form-controls-boosting-radio-input-element.html:29 >> +the radio buttons below should not be autosized. Lorem ipsum dolor sit amet, consectetur > > Nit: s/radio buttons below/radio buttons below and the surrounding text/ done 791581 14 179476 timvolodine 2012-12-14 07:12:39 -0800 Created attachment 179476 Patch 791582 15 179476 johnme 2012-12-14 07:15:46 -0800 Comment on attachment 179476 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179285&action=review Thanks for the update. A couple more comments on the tests. > LayoutTests/fast/text-autosizing/form-controls-boosting-button-textarea-input-elements.html:14 > + font-size: 85%; This test is still far too complicated. For example the following are almost certainly irrelevant: - font-size: 85%; - "<span>| </span>\n" should be equivalent to just "|\n" - <form> <div> ... </div> </form> should be equivalent to just <div> ... </div> - id="quicksearch_top" - id="quicksearch" - name="quicksearch" - id="find" - class="txt" - class="btn" - <p><div> ... </div></p> should be equivalent to <p> ... </p> But that's just the low-level details. Ultimately even once you strip out the redundant information, this test will still be too complicated, because it's trying to do too many things at once. It might be easiest to just delete this test and create new ones in the style of form-controls-boosting-checkbox-input-element.html which just test text inputs and buttons respectively (when testing buttons, please make sure to test a variety of different button types, i.e. <input type="submit" value="Text">, <button>Text</button>, <input type="button" value="Text"> and <input type="reset" value="Text">; and similarly for text inputs, include type="text", type="email", type="number", type="password", type="search" and type="url" - all in their own divs of course so they don't affect each other). > LayoutTests/fast/text-autosizing/form-controls-boosting-radio-input-element.html:27 > +<div> Please indent your html tags (with spaces) so it's easier to see the tree structure. Ditto in other tests. 791593 16 179476 johnme 2012-12-14 07:36:18 -0800 Comment on attachment 179476 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179476&action=review > Source/WebCore/rendering/TextAutosizer.cpp:36 > +#include <wtf/StdLibExtras.h> Nit: most other code in WebKit includes <algorithm> before <wtf/*>. Probably because of http://www.webkit.org/coding/coding-style.html#include-others (i.e. 'a' is before 'w' when sorted). > Source/WebCore/rendering/TextAutosizer.cpp:52 > + // returns the tags for the form input elements http://www.webkit.org/coding/coding-style.html#comments-sentences > Source/WebCore/rendering/TextAutosizer.cpp:140 > +bool TextAutosizer::containerShouldBeAutosized(const RenderBlock* container) You still need to rebase this now http://wkbug.com/104925 has landed. > Source/WebCore/rendering/TextAutosizer.cpp:240 > + // Avoid creating containers for text within text controls, buttons, or <select> dropdowns Nit: full stop at end http://www.webkit.org/coding/coding-style.html#comments-sentences 791662 17 179492 timvolodine 2012-12-14 09:23:46 -0800 Created attachment 179492 Patch Work in progress. 791721 18 179476 timvolodine 2012-12-14 11:17:55 -0800 Comment on attachment 179476 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179476&action=review >> Source/WebCore/rendering/TextAutosizer.cpp:36 >> +#include <wtf/StdLibExtras.h> > > Nit: most other code in WebKit includes <algorithm> before <wtf/*>. Probably because of http://www.webkit.org/coding/coding-style.html#include-others (i.e. 'a' is before 'w' when sorted). done >> Source/WebCore/rendering/TextAutosizer.cpp:52 >> + // returns the tags for the form input elements > > http://www.webkit.org/coding/coding-style.html#comments-sentences done >> Source/WebCore/rendering/TextAutosizer.cpp:140 >> +bool TextAutosizer::containerShouldBeAutosized(const RenderBlock* container) > > You still need to rebase this now http://wkbug.com/104925 has landed. done >> Source/WebCore/rendering/TextAutosizer.cpp:240 >> + // Avoid creating containers for text within text controls, buttons, or <select> dropdowns > > Nit: full stop at end http://www.webkit.org/coding/coding-style.html#comments-sentences done >> LayoutTests/fast/text-autosizing/form-controls-boosting-button-textarea-input-elements.html:14 >> + font-size: 85%; > > This test is still far too complicated. For example the following are almost certainly irrelevant: > - font-size: 85%; > - "<span>| </span>\n" should be equivalent to just "|\n" > - <form> <div> ... </div> </form> should be equivalent to just <div> ... </div> > - id="quicksearch_top" > - id="quicksearch" > - name="quicksearch" > - id="find" > - class="txt" > - class="btn" > - <p><div> ... </div></p> should be equivalent to <p> ... </p> > > But that's just the low-level details. Ultimately even once you strip out the redundant information, this test will still be too complicated, because it's trying to do too many things at once. It might be easiest to just delete this test and create new ones in the style of form-controls-boosting-checkbox-input-element.html which just test text inputs and buttons respectively (when testing buttons, please make sure to test a variety of different button types, i.e. <input type="submit" value="Text">, <button>Text</button>, <input type="button" value="Text"> and <input type="reset" value="Text">; and similarly for text inputs, include type="text", type="email", type="number", type="password", type="search" and type="url" - all in their own divs of course so they don't affect each other). done >> LayoutTests/fast/text-autosizing/form-controls-boosting-radio-input-element.html:27 >> +<div> > > Please indent your html tags (with spaces) so it's easier to see the tree structure. Ditto in other tests. done 791726 19 179503 timvolodine 2012-12-14 11:30:49 -0800 Created attachment 179503 Patch 791751 20 timvolodine 2012-12-14 12:05:09 -0800 Kenneth/Julien, we had a couple of iterations with John on this bug. Could you have a quick look please? 792562 21 179503 kenneth 2012-12-17 01:42:15 -0800 Comment on attachment 179503 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179503&action=review > Source/WebCore/rendering/TextAutosizer.cpp:40 > #include <algorithm> > > +#include <wtf/StdLibExtras.h> > + Why is that include grouped separately? > Source/WebCore/rendering/TextAutosizer.cpp:53 > + > +static const Vector<QualifiedName>& formInputTags() > +{ > + // Returns the tags for the form input elements. Btw did you look into content-editable? What about input forms like date, email, etc? > Source/WebCore/rendering/TextAutosizer.cpp:216 > + // Avoid creating containers for text within text controls, buttons, or <select> dropdowns. > + Node* parentNode = renderer->parent() ? renderer->parent()->generatingNode() : 0; > + if (parentNode && parentNode->isElementNode() && formInputTags().contains(toElement(parentNode)->tagQName())) > + return false; What abut platforms that doesnt handle select dropdown inline? There is some kind of define for that > Source/WebCore/rendering/TextAutosizer.cpp:311 > +bool TextAutosizer::containerContainsTags(const RenderBlock* container, const Vector<QualifiedName>& tags) Name is confusing. so "contains tags" means all tags? or just one of them? 792886 22 179503 timvolodine 2012-12-17 11:34:43 -0800 Comment on attachment 179503 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179503&action=review >> Source/WebCore/rendering/TextAutosizer.cpp:40 >> + > > Why is that include grouped separately? not sure what the policies regarding includes are in WebKit, but I've deleted one line now so it's grouped under <algorithm> hope that's ok >> Source/WebCore/rendering/TextAutosizer.cpp:53 >> + // Returns the tags for the form input elements. > > Btw did you look into content-editable? > > What about input forms like date, email, etc? content-editable is a good point, however I think it is best to handle it in a separate bug, because this bug explicitly addresses form input controls input fields like date, and other should be fine, in fact they are included in the tests with this patch. >> Source/WebCore/rendering/TextAutosizer.cpp:216 >> + return false; > > What abut platforms that doesnt handle select dropdown inline? There is some kind of define for that not sure if I understand correctly: do you mean on platforms like blackberry where it looks like a customized implementation of SelectPopupClient.h is provided? Does this suggest that in that case testing the parent node is not sufficient? I've been trying to find a related define in HTMLSelectElement.* and in the rendering/ directory but no success so far.. >> Source/WebCore/rendering/TextAutosizer.cpp:311 >> +bool TextAutosizer::containerContainsTags(const RenderBlock* container, const Vector<QualifiedName>& tags) > > Name is confusing. so "contains tags" means all tags? or just one of them? renamed to containerContainsOneOfTags(..) 792892 23 179503 johnme 2012-12-17 11:42:11 -0800 Comment on attachment 179503 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179503&action=review >> Source/WebCore/rendering/TextAutosizer.cpp:53 >> + // Returns the tags for the form input elements. > > Btw did you look into content-editable? > > What about input forms like date, email, etc? > Btw did you look into content-editable? I can think of cases where content-editable text would benefit from being autosized. We should probably look into that separately, along with textareas (see below). > What about input forms like date, email, etc? Those all use the <input> tag, so should already be covered? > Source/WebCore/rendering/TextAutosizer.cpp:57 > + formInputTags.append(textareaTag); Please either a) add a test for <textarea> tags, or b) remove them from this list if you didn't mean to disable autosizing of textareas. I'd recommend option b (allow them to be autosized), as large textareas can benefit from autosizing. They suffer from crbug.com/165481, but we can deal with that separately. >> Source/WebCore/rendering/TextAutosizer.cpp:216 >> + return false; > > What abut platforms that doesnt handle select dropdown inline? There is some kind of define for that Even if the select dropdown is handled by the platform, a dropdown button will still be shown, and this shouldn't be autosized (at least until such time as Text Autosizing can smartly resize controls). Perhaps the comment above should say "<select> buttons" instead of "<select> dropdowns"? > LayoutTests/fast/text-autosizing/form-controls-autosizing-button-input-elements.html:27 > + This tests the autosizing of a button input element. This paragraph should be autosized, while It's not clear what "autosized" means (to future people who have to debug this test). Please give something that can be explicitly tested, e.g. set font-size: 16px in your style rules for body, and write "This paragraph should be autosized to 40px computed font-size (16 * 800/320), whereas the buttons below should be rendered at their default font size". Similarly for other tests. In fact it would be useful to have some text next to the buttons to demonstrate that their whole paragraph isn't being autosized. Ditto for your text inputs test (the others already have text, so are fine). > LayoutTests/fast/text-autosizing/form-controls-autosizing-button-input-elements.html:33 > +<form action=""> This <form> tag is unnecessary (ditto in other tests). HTML doesn't require that inputs have a form tag ancestor. 792893 24 179774 timvolodine 2012-12-17 11:42:43 -0800 Created attachment 179774 Patch 793048 25 179503 timvolodine 2012-12-17 14:38:34 -0800 Comment on attachment 179503 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179503&action=review >> Source/WebCore/rendering/TextAutosizer.cpp:57 >> + formInputTags.append(textareaTag); > > Please either a) add a test for <textarea> tags, or b) remove them from this list if you didn't mean to disable autosizing of textareas. > I'd recommend option b (allow them to be autosized), as large textareas can benefit from autosizing. They suffer from crbug.com/165481, but we can deal with that separately. done option b. >>>> Source/WebCore/rendering/TextAutosizer.cpp:216 >>>> + return false; >>> >>> What abut platforms that doesnt handle select dropdown inline? There is some kind of define for that >> >> not sure if I understand correctly: do you mean on platforms like blackberry where it looks like a customized implementation of SelectPopupClient.h is provided? >> Does this suggest that in that case testing the parent node is not sufficient? >> I've been trying to find a related define in HTMLSelectElement.* and in the rendering/ directory but no success so far.. > > Even if the select dropdown is handled by the platform, a dropdown button will still be shown, and this shouldn't be autosized (at least until such time as Text Autosizing can smartly resize controls). Perhaps the comment above should say "<select> buttons" instead of "<select> dropdowns"? done >> LayoutTests/fast/text-autosizing/form-controls-autosizing-button-input-elements.html:27 >> + This tests the autosizing of a button input element. This paragraph should be autosized, while > > It's not clear what "autosized" means (to future people who have to debug this test). Please give something that can be explicitly tested, e.g. set font-size: 16px in your style rules for body, and write "This paragraph should be autosized to 40px computed font-size (16 * 800/320), whereas the buttons below should be rendered at their default font size". Similarly for other tests. > > In fact it would be useful to have some text next to the buttons to demonstrate that their whole paragraph isn't being autosized. Ditto for your text inputs test (the others already have text, so are fine). done >> LayoutTests/fast/text-autosizing/form-controls-autosizing-button-input-elements.html:33 >> +<form action=""> > > This <form> tag is unnecessary (ditto in other tests). HTML doesn't require that inputs have a form tag ancestor. done 793049 26 179806 timvolodine 2012-12-17 14:41:03 -0800 Created attachment 179806 Patch 793581 27 179806 johnme 2012-12-18 05:58:21 -0800 Comment on attachment 179806 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179806&action=review Looks good with minor nits. > Source/WebCore/rendering/TextAutosizer.h:76 > + static bool contentHeightIsConstrained(const RenderBlock* container); Nit: the method order here doesn't match that in the .cpp file. It would also be nice if containerContainsOneOfTags and contentHeightIsConstrained were next to containerShouldBeAutosized, and measureDescendantTextWidth remained next to clusterShouldBeAutosized. So perhaps the following order would be good?: 1. containerShouldbeAutosized 2. containerContainsOneOfTags 3. contentHeightIsConstrained 4. clusterShouldBeAutosized 5. measureDescendantTextWidth > LayoutTests/fast/text-autosizing/form-controls-autosizing-button-input-elements.html:29 > + whereas the buttons and the corresponding text below should be rendered at Nit: actually, we've set font-size:16px on the body (or html - see below), so it would probably be more accurate to say "whereas the buttons below should be rendered at their default font size, and the accompanying text below should remain 16px". Similarly for the text input and <select> tests; and similarly for the checkbox/radiobutton tests, except that s/default font size/default size/ for those as the controls don't display any text. > LayoutTests/fast/text-autosizing/form-controls-autosizing-textfield-input-elements.html:8 > + font-size: 16px; Please set this font-size on the html element instead of the body element, so that when the -expected.html file uses the rem unit it's a multiple of the specified font size (ditto in all tests and test expectations). > LayoutTests/fast/text-autosizing/form-controls-autosizing-textfield-input-elements.html:35 > +<div> Nit: It doesn't really matter, but this div is technically unnecessary (since all its children are themselves divs, and it just lays them out vertically, which is the same as what the body element would have done if this div didn't exist). Ditto in form-controls-autosizing-button-input-elements. > LayoutTests/fast/text-autosizing/form-controls-autosizing-textfield-input-elements.html:38 > + <input type="text"> I realise that all of these text input fields are blank. It would be nice to have at least one that contains some text, so you can easily see the field's text size. Perhaps add a case with: <input type="text" value="Default value"> 794502 28 179806 timvolodine 2012-12-19 04:07:22 -0800 Comment on attachment 179806 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179806&action=review >> Source/WebCore/rendering/TextAutosizer.h:76 >> + static bool contentHeightIsConstrained(const RenderBlock* container); > > Nit: the method order here doesn't match that in the .cpp file. It would also be nice if containerContainsOneOfTags and contentHeightIsConstrained were next to containerShouldBeAutosized, and measureDescendantTextWidth remained next to clusterShouldBeAutosized. So perhaps the following order would be good?: > > 1. containerShouldbeAutosized > 2. containerContainsOneOfTags > 3. contentHeightIsConstrained > 4. clusterShouldBeAutosized > 5. measureDescendantTextWidth done >> LayoutTests/fast/text-autosizing/form-controls-autosizing-button-input-elements.html:29 >> + whereas the buttons and the corresponding text below should be rendered at > > Nit: actually, we've set font-size:16px on the body (or html - see below), so it would probably be more accurate to say "whereas the buttons below should be rendered at their default font size, and the accompanying text below should remain 16px". Similarly for the text input and <select> tests; and similarly for the checkbox/radiobutton tests, except that s/default font size/default size/ for those as the controls don't display any text. done >> LayoutTests/fast/text-autosizing/form-controls-autosizing-textfield-input-elements.html:8 >> + font-size: 16px; > > Please set this font-size on the html element instead of the body element, so that when the -expected.html file uses the rem unit it's a multiple of the specified font size (ditto in all tests and test expectations). done >> LayoutTests/fast/text-autosizing/form-controls-autosizing-textfield-input-elements.html:35 >> +<div> > > Nit: It doesn't really matter, but this div is technically unnecessary (since all its children are themselves divs, and it just lays them out vertically, which is the same as what the body element would have done if this div didn't exist). Ditto in form-controls-autosizing-button-input-elements. done >> LayoutTests/fast/text-autosizing/form-controls-autosizing-textfield-input-elements.html:38 >> + <input type="text"> > > I realise that all of these text input fields are blank. It would be nice to have at least one that contains some text, so you can easily see the field's text size. Perhaps add a case with: <input type="text" value="Default value"> done 794540 29 180137 timvolodine 2012-12-19 05:03:37 -0800 Created attachment 180137 Patch 794547 30 180139 timvolodine 2012-12-19 05:08:39 -0800 Created attachment 180139 Patch 794549 31 timvolodine 2012-12-19 05:12:10 -0800 last patch contains the rebased changes wrt to the patches landed by Anton 794566 32 timvolodine 2012-12-19 05:29:26 -0800 Kenneth could you please have another glance at the latest patch. I've reworked it using the comments from John and merged it with upstream. 794591 33 180139 timvolodine 2012-12-19 05:57:48 -0800 Comment on attachment 180139 Patch Kenneth thanks for review, can we land this patch? a few mac tests are failing, but looks like to be unrelated to this patch. 794656 34 180139 webkit.review.bot 2012-12-19 07:35:43 -0800 Comment on attachment 180139 Patch Clearing flags on attachment: 180139 Committed r138162: <http://trac.webkit.org/changeset/138162> 794657 35 webkit.review.bot 2012-12-19 07:35:49 -0800 All reviewed patches have been landed. Closing bug. 806352 36 johnme 2013-01-14 07:51:20 -0800 I filed bug 106797 to follow-up on the (long term, lower priority) idea of scaling up form fields. 178577 2012-12-10 09:56:21 -0800 2012-12-10 10:01:17 -0800 Patch bug-102560-20121210175343.patch text/plain 15794 timvolodine U3VidmVyc2lvbiBSZXZpc2lvbjogMTM2NTA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDAwYjI2MTA1ZWM3MGUy NjM5YzY3ZDBlOWFiMzRlNmZhYjI4YWVkNy4uM2MyNmFmYTk0MGZiZTk0MTI5NDU1OGJmZjgxMDFj NmZhMTZjMDAwNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDEyLTEyLTEwICBUaW0g Vm9sb2RpbmUgIDx0aW12b2xvZGluZUBnb29nbGUuY29tPgorCisgICAgICAgIFRleHQgQXV0b3Np emluZzogV29yayBvdXQgd2hhdCB0byBkbyBhYm91dCBmb3JtIGNvbnRyb2xzCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDI1NjAKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBEaXNzYWxvdyBib29zdGluZyBv ZiBmb3JtIGlucHV0IGNvbnRyb2xzIGxpa2UgYnV0dG9ucyBhbmQgdGV4dCBmaWVsZCBpbnB1dHMu IFRoaXMgaXMgYSBzaG9ydCB0ZXJtIHNvbHV0aW9uLAorICAgICAgICB0byBhdm9pZCBpbmNvbnNp c3RlbnQgYm9vc3Rpbmcgb2YgZm9ybSBjb250cm9scyAod2hpY2ggaXMgd29yc2UgdGhhbiBub3Qg Ym9vc3RpbmcgYXQgYWxsKS4KKworICAgICAgICBUZXN0OiBmYXN0L3RleHQtYXV0b3NpemluZy9m b3JtLWNvbnRyb2xzLWJvb3N0aW5nLmh0bWwKKworICAgICAgICAqIHJlbmRlcmluZy9UZXh0QXV0 b3NpemVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEF1 dG9zaXplcjo6cHJvY2Vzc1N1YnRyZWUpOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEF1dG9zaXpl cjo6cHJvY2Vzc0NsdXN0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6Y29u dGVudEhlaWdodElzQ29uc3RyYWluZWQpOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEF1dG9zaXpl cjo6aXNBdXRvc2l6aW5nQ29udGFpbmVyKToKKyAgICAgICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6 ZXI6OmNsdXN0ZXJTaG91bGRCZUF1dG9zaXplZCk6CisgICAgICAgIChXZWJDb3JlOjpUZXh0QXV0 b3NpemVyOjpjb250YWluZXJDb250YWluc1RhZ3MpOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEF1 dG9zaXplcjo6ZmluZERlZXBlc3RCbG9ja0NvbnRhaW5pbmdBbGxUZXh0KToKKyAgICAgICAgKiBy ZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oOgorCiAyMDEyLTEyLTA0ICBBbnRvaW5lIFF1aW50ICA8 Z3Jhb3V0c0BhcHBsZS5jb20+CiAKICAgICAgICAgVGV4dFRyYWNrJ3MgLmtpbmQgcHJvcGVydHkg c2hvdWxkIHJldHVybiBsb3dlci1jYXNlIHZhbHVlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1RleHRBdXRvc2l6ZXIuY3BwCmluZGV4IGIxMDJiMmI1YjI5Mzc1YzcyODQ5MmMxYzk4NGJmN2Y4 NjVkODcyMjEuLmRmZmFlZTUzYWIyNWIwNGRkNWUwNzFiZDk0NGU2MzY1MmY2MGJhNzAgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5jcHAKQEAgLTI1LDYgKzI1LDcg QEAKICNpbmNsdWRlICJUZXh0QXV0b3NpemVyLmgiCiAKICNpbmNsdWRlICJEb2N1bWVudC5oIgor I2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCiAjaW5jbHVkZSAiSW5zcGVjdG9ySW5zdHJ1bWVudGF0 aW9uLmgiCiAjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCiAjaW5jbHVkZSAiUmVuZGVyU3R5bGUu aCIKQEAgLTM3LDYgKzM4LDggQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCit1c2luZyBuYW1l c3BhY2UgSFRNTE5hbWVzOworCiBzdHJ1Y3QgVGV4dEF1dG9zaXppbmdXaW5kb3dJbmZvIHsKICAg ICBJbnRTaXplIHdpbmRvd1NpemU7CiAgICAgSW50U2l6ZSBtaW5MYXlvdXRTaXplOwpAQCAtODks NiArOTIsNyBAQCBib29sIFRleHRBdXRvc2l6ZXI6OnByb2Nlc3NTdWJ0cmVlKFJlbmRlck9iamVj dCogbGF5b3V0Um9vdCkKICAgICAgICAgY2x1c3RlciA9IGNsdXN0ZXItPmNvbnRhaW5pbmdCbG9j aygpOwogCiAgICAgcHJvY2Vzc0NsdXN0ZXIoY2x1c3RlciwgY29udGFpbmVyLCBsYXlvdXRSb290 LCB3aW5kb3dJbmZvKTsKKwogICAgIHJldHVybiB0cnVlOwogfQogCkBAIC0xMDUsNyArMTA5LDcg QEAgdm9pZCBUZXh0QXV0b3NpemVyOjpwcm9jZXNzQ2x1c3RlcihSZW5kZXJCbG9jayogY2x1c3Rl ciwgUmVuZGVyQmxvY2sqIGNvbnRhaW5lciwKICAgICBmbG9hdCBjb21tb25BbmNlc3RvcldpZHRo ID0gbG93ZXN0Q29tbW9uQW5jZXN0b3ItPmNvbnRlbnRMb2dpY2FsV2lkdGgoKTsKIAogICAgIGZs b2F0IG11bHRpcGxpZXIgPSAxOwotICAgIGlmIChjbHVzdGVyU2hvdWxkQmVBdXRvc2l6ZWQobG93 ZXN0Q29tbW9uQW5jZXN0b3IsIGNvbW1vbkFuY2VzdG9yV2lkdGgpKSB7CisgICAgaWYgKGNsdXN0 ZXJTaG91bGRCZUF1dG9zaXplZChjbHVzdGVyLCBsb3dlc3RDb21tb25BbmNlc3RvciwgY29tbW9u QW5jZXN0b3JXaWR0aCkpIHsKICAgICAgICAgaW50IGxvZ2ljYWxXaW5kb3dXaWR0aCA9IGNsdXN0 ZXItPmlzSG9yaXpvbnRhbFdyaXRpbmdNb2RlKCkgPyB3aW5kb3dJbmZvLndpbmRvd1NpemUud2lk dGgoKSA6IHdpbmRvd0luZm8ud2luZG93U2l6ZS5oZWlnaHQoKTsKICAgICAgICAgaW50IGxvZ2lj YWxMYXlvdXRXaWR0aCA9IGNsdXN0ZXItPmlzSG9yaXpvbnRhbFdyaXRpbmdNb2RlKCkgPyB3aW5k b3dJbmZvLm1pbkxheW91dFNpemUud2lkdGgoKSA6IHdpbmRvd0luZm8ubWluTGF5b3V0U2l6ZS5o ZWlnaHQoKTsKICAgICAgICAgLy8gSWdub3JlIGJveCB3aWR0aCBpbiBleGNlc3Mgb2YgdGhlIGxh eW91dCB3aWR0aCwgdG8gYXZvaWQgZXh0cmVtZSBtdWx0aXBsaWVycy4KQEAgLTExOSwxMSArMTIz LDE1IEBAIHZvaWQgVGV4dEF1dG9zaXplcjo6cHJvY2Vzc0NsdXN0ZXIoUmVuZGVyQmxvY2sqIGNs dXN0ZXIsIFJlbmRlckJsb2NrKiBjb250YWluZXIsCiAgICAgcHJvY2Vzc0NvbnRhaW5lcihtdWx0 aXBsaWVyLCBjb250YWluZXIsIHN1YnRyZWVSb290LCB3aW5kb3dJbmZvKTsKIH0KIAotc3RhdGlj IGJvb2wgY29udGVudEhlaWdodElzQ29uc3RyYWluZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRh aW5lcikKK2Jvb2wgVGV4dEF1dG9zaXplcjo6Y29udGVudEhlaWdodElzQ29uc3RyYWluZWQoY29u c3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lcikKIHsKICAgICAvLyBGSVhNRTogUHJvcGFnYXRlIGNv bnN0cmFpbmVkbmVzcyBkb3duIHRoZSB0cmVlLCB0byBhdm9pZCBpbmVmZmljaWVudGx5IHdhbGtp bmcgYmFjayB1cCBmcm9tIGVhY2ggYm94LgogICAgIC8vIEZJWE1FOiBUaGlzIGNvZGUgbmVlZHMg dG8gdGFrZSBpbnRvIGFjY291bnQgdmVydGljYWwgd3JpdGluZyBtb2Rlcy4KICAgICAvLyBGSVhN RTogQ29uc2lkZXIgYWRkaXRpb25hbCBoZXVyaXN0aWNzLCBzdWNoIGFzIGlnbm9yaW5nIGZpeGVk IGhlaWdodHMgaWYgdGhlIGNvbnRlbnQgaXMgYWxyZWFkeSBvdmVyZmxvd2luZyBiZWZvcmUgYXV0 b3NpemluZyBraWNrcyBpbi4KKyAgICBRdWFsaWZpZWROYW1lIHRhZ3NbNF0gPSB7aW5wdXRUYWcs IHRleHRhcmVhVGFnLCBidXR0b25UYWcsIGZvcm1UYWd9OworICAgIGlmIChjb250YWluZXJDb250 YWluc1RhZ3MoY29udGFpbmVyLCB0YWdzLCA0KSkKKyAgICAgICAgcmV0dXJuIHRydWU7CisKICAg ICBmb3IgKDsgY29udGFpbmVyOyBjb250YWluZXIgPSBjb250YWluZXItPmNvbnRhaW5pbmdCbG9j aygpKSB7CiAgICAgICAgIFJlbmRlclN0eWxlKiBzdHlsZSA9IGNvbnRhaW5lci0+c3R5bGUoKTsK ICAgICAgICAgaWYgKHN0eWxlLT5vdmVyZmxvd1koKSA+PSBPU0NST0xMKQpAQCAtMjExLDYgKzIx OSwxMiBAQCBib29sIFRleHRBdXRvc2l6ZXI6OmlzQXV0b3NpemluZ0NvbnRhaW5lcihjb25zdCBS ZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgaWYgKHJl bmRlcmVyLT5pc0xpc3RJdGVtKCkpCiAgICAgICAgIHJldHVybiByZW5kZXJlci0+aXNGbG9hdGlu ZygpIHx8IHJlbmRlcmVyLT5pc091dE9mRmxvd1Bvc2l0aW9uZWQoKTsKKyAgICAvLyBhdm9pZCBj cmVhdGluZyBjb250YWluZXJzIGZvciB0ZXh0IHdpdGhpbiB0ZXh0IGNvbnRyb2xzIG9yIGJ1dHRv bnMKKyAgICBpZiAocmVuZGVyZXItPnBhcmVudCgpKSB7CisgICAgICAgIGlmIChyZW5kZXJlci0+ cGFyZW50KCktPmlzUmVuZGVyQnV0dG9uKCkgfHwgcmVuZGVyZXItPnBhcmVudCgpLT5pc1RleHRD b250cm9sKCkpCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCiAgICAgcmV0dXJu IHRydWU7CiB9CiAKQEAgLTI1MCw3ICsyNjQsNyBAQCBib29sIFRleHRBdXRvc2l6ZXI6OmlzQXV0 b3NpemluZ0NsdXN0ZXIoY29uc3QgUmVuZGVyQmxvY2sqIHJlbmRlcmVyKQogICAgIC8vIHJlbmRl cmVycywgYW5kIHByb2JhYmx5IGZsZXhib3hlcy4uLgogfQogCi1ib29sIFRleHRBdXRvc2l6ZXI6 OmNsdXN0ZXJTaG91bGRCZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayogbG93ZXN0Q29tbW9u QW5jZXN0b3IsIGZsb2F0IGNvbW1vbkFuY2VzdG9yV2lkdGgpCitib29sIFRleHRBdXRvc2l6ZXI6 OmNsdXN0ZXJTaG91bGRCZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayogY2x1c3RlciwgY29u c3QgUmVuZGVyQmxvY2sqIGxvd2VzdENvbW1vbkFuY2VzdG9yLCBmbG9hdCBjb21tb25BbmNlc3Rv cldpZHRoKQogewogICAgIC8vIERvbid0IGF1dG9zaXplIGNsdXN0ZXJzIHRoYXQgY29udGFpbiBs ZXNzIHRoYW4gNCBsaW5lcyBvZiB0ZXh0IChpbgogICAgIC8vIHByYWN0aWNlIGxlc3MgbGluZXMg YXJlIHJlcXVpcmVkLCBzaW5jZSBtZWFzdXJlRGVzY2VuZGFudFRleHRXaWR0aApAQCAtMjcxLDYg KzI4NSwzMiBAQCBib29sIFRleHRBdXRvc2l6ZXI6OmNsdXN0ZXJTaG91bGRCZUF1dG9zaXplZChj b25zdCBSZW5kZXJCbG9jayogbG93ZXN0Q29tbW9uQW5jZQogICAgIHJldHVybiBmYWxzZTsKIH0K IAorYm9vbCBUZXh0QXV0b3NpemVyOjpjb250YWluZXJDb250YWluc1RhZ3MoY29uc3QgUmVuZGVy T2JqZWN0KiBjb250YWluZXIsIGNvbnN0IFF1YWxpZmllZE5hbWUgdGFnc1tdLCBjb25zdCBzaXpl X3QgbnVtVGFncykKK3sKKyAgICBjb25zdCBOb2RlKiBjb250YWluZXJOb2RlID0gY29udGFpbmVy LT5ub2RlKCk7CisgICAgYm9vbCB2YWxpZENhbmRpZGF0ZSA9IGNvbnRhaW5lck5vZGUgJiYgY29u dGFpbmVyTm9kZS0+aXNIVE1MRWxlbWVudCgpICYmICFjb250YWluZXJOb2RlLT5pc1NoYWRvd1Jv b3QoKTsKKyAgICBpZiAodmFsaWRDYW5kaWRhdGUpIHsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9 IDA7IGkgPCBudW1UYWdzOyArK2kpIHsKKyAgICAgICAgICAgIGlmIChjb250YWluZXJOb2RlLT5o YXNUYWdOYW1lKHRhZ3NbaV0pKQorICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAg ICB9CisgICAgfQorCisgICAgUmVuZGVyT2JqZWN0KiBkZXNjZW5kYW50ID0gbmV4dEluUHJlT3Jk ZXJTa2lwcGluZ0Rlc2NlbmRhbnRzT2ZDb250YWluZXJzKGNvbnRhaW5lciwgY29udGFpbmVyKTsK KyAgICB3aGlsZSAoZGVzY2VuZGFudCkgeworICAgICAgICBjb25zdCBOb2RlKiBkZXNjZW5kYW50 Tm9kZSA9IGRlc2NlbmRhbnQtPm5vZGUoKTsKKyAgICAgICAgYm9vbCB2YWxpZENhbmRpZGF0ZSA9 IGRlc2NlbmRhbnROb2RlICYmIGRlc2NlbmRhbnROb2RlLT5pc0hUTUxFbGVtZW50KCkgJiYgIWRl c2NlbmRhbnROb2RlLT5pc1NoYWRvd1Jvb3QoKTsKKyAgICAgICAgaWYgKHZhbGlkQ2FuZGlkYXRl KSB7CisgICAgICAgICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG51bVRhZ3M7ICsraSkgewor ICAgICAgICAgICAgICAgIGlmIChkZXNjZW5kYW50Tm9kZS0+aGFzVGFnTmFtZSh0YWdzW2ldKSkK KyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgICAgICB9CisgICAgICAg IH0KKyAgICAgICAgZGVzY2VuZGFudCA9IG5leHRJblByZU9yZGVyU2tpcHBpbmdEZXNjZW5kYW50 c09mQ29udGFpbmVycyhkZXNjZW5kYW50LCBjb250YWluZXIpOworICAgIH0KKyAgICByZXR1cm4g ZmFsc2U7Cit9CisKIHZvaWQgVGV4dEF1dG9zaXplcjo6bWVhc3VyZURlc2NlbmRhbnRUZXh0V2lk dGgoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lciwgZmxvYXQgbWluVGV4dFdpZHRoLCBmbG9h dCYgdGV4dFdpZHRoKQogewogICAgIGJvb2wgc2tpcExvY2FsVGV4dCA9IGNvbnRlbnRIZWlnaHRJ c0NvbnN0cmFpbmVkKGNvbnRhaW5lcik7CkBAIC0zMTksNyArMzU5LDcgQEAgY29uc3QgUmVuZGVy QmxvY2sqIFRleHRBdXRvc2l6ZXI6OmZpbmREZWVwZXN0QmxvY2tDb250YWluaW5nQWxsVGV4dChj b25zdCBSZW5kZXIKICAgICBjb25zdCBSZW5kZXJPYmplY3QqIGxhc3RUZXh0TGVhZiA9IGZpbmRG aXJzdFRleHRMZWFmTm90SW5DbHVzdGVyKGNsdXN0ZXIsIGxhc3REZXB0aCwgTGFzdFRvRmlyc3Qp OwogICAgIEFTU0VSVChsYXN0VGV4dExlYWYpOwogCi0gICAgLy8gRXF1YWxpemUgdGhlIGRlcHRo cyBpZiBuZWNlc3NhcnkuIE9ubHkgb25lIG9mIHRoZSB3aGlsZSBsb29wcyBiZWxvdyB3aWxsIGdl dCBleGVjdXRlZC4KKyAgICAvLyBFcXVhbGl6ZSB0aGUgZGVwdGhzIGlmIGNvbnRlbnRIZWlnaHRJ c0NvbnN0cmFpbmVkbmVjZXNzYXJ5LiBPbmx5IG9uZSBvZiB0aGUgd2hpbGUgbG9vcHMgYmVsb3cg d2lsbCBnZXQgZXhlY3V0ZWQuCiAgICAgY29uc3QgUmVuZGVyT2JqZWN0KiBmaXJzdE5vZGUgPSBm aXJzdFRleHRMZWFmOwogICAgIGNvbnN0IFJlbmRlck9iamVjdCogbGFzdE5vZGUgPSBsYXN0VGV4 dExlYWY7CiAgICAgd2hpbGUgKGZpcnN0RGVwdGggPiBsYXN0RGVwdGgpIHsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmggYi9Tb3VyY2UvV2ViQ29y ZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oCmluZGV4IGE3MDliMTE2OGU0NGRmMDBlYzFmOWQ3 M2JiZTVlNTE2ZmU5MjY3NzQuLjZjZjc0NDM0NGU3YzUyNDI1OTBiMzkzYjJkNWI5N2FiM2YwYTMz NTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmgK KysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaApAQCAtMjgsNiAr MjgsNyBAQAogCiAjaWYgRU5BQkxFKFRFWFRfQVVUT1NJWklORykKIAorI2luY2x1ZGUgIkhUTUxO YW1lcy5oIgogI2luY2x1ZGUgIkludFNpemUuaCIKICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUu aD4KICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgpAQCAtNzAsNyArNzEsOSBAQCBwcml2YXRl OgogICAgIHN0YXRpYyBib29sIGlzQXV0b3NpemluZ0NvbnRhaW5lcihjb25zdCBSZW5kZXJPYmpl Y3QqKTsKICAgICBzdGF0aWMgYm9vbCBpc0F1dG9zaXppbmdDbHVzdGVyKGNvbnN0IFJlbmRlckJs b2NrKik7CiAKLSAgICBzdGF0aWMgYm9vbCBjbHVzdGVyU2hvdWxkQmVBdXRvc2l6ZWQoY29uc3Qg UmVuZGVyQmxvY2sqIGxvd2VzdENvbW1vbkFuY2VzdG9yLCBmbG9hdCBjb21tb25BbmNlc3Rvcldp ZHRoKTsKKyAgICBzdGF0aWMgYm9vbCBjbHVzdGVyU2hvdWxkQmVBdXRvc2l6ZWQoY29uc3QgUmVu ZGVyQmxvY2sqIGNsdXN0ZXIsIGNvbnN0IFJlbmRlckJsb2NrKiBsb3dlc3RDb21tb25BbmNlc3Rv ciwgZmxvYXQgY29tbW9uQW5jZXN0b3JXaWR0aCk7CisgICAgc3RhdGljIGJvb2wgY29udGVudEhl aWdodElzQ29uc3RyYWluZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lcik7CisgICAgc3Rh dGljIGJvb2wgY29udGFpbmVyQ29udGFpbnNUYWdzKGNvbnN0IFJlbmRlck9iamVjdCogY2x1c3Rl ciwgY29uc3QgUXVhbGlmaWVkTmFtZSB0YWdzW10sIGNvbnN0IHNpemVfdCBudW1UYWdzKTsKICAg ICBzdGF0aWMgdm9pZCBtZWFzdXJlRGVzY2VuZGFudFRleHRXaWR0aChjb25zdCBSZW5kZXJCbG9j ayogY29udGFpbmVyLCBmbG9hdCBtaW5UZXh0V2lkdGgsIGZsb2F0JiB0ZXh0V2lkdGgpOwogCiAg ICAgLy8gVXNlIHRvIHRyYXZlcnNlIHRoZSB0cmVlIG9mIGRlc2NlbmRhbnRzLCBleGNsdWRpbmcg ZGVzY2VuZGFudHMgb2YgY29udGFpbmVycyAoYnV0IHJldHVybmluZyB0aGUgY29udGFpbmVycyB0 aGVtc2VsdmVzKS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRl c3RzL0NoYW5nZUxvZwppbmRleCBhODlkZDQ1ZjQ1NDBiNWM4MzZmODRjMmY0ZDA3ZGY0NTk3MTll ZDFmLi40ODgwNmNjOTE5NWYzZDcyNGM1NmNkMzM5YmM1M2FiNmY4NjY3MzE3IDEwMDY0NAotLS0g YS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTYgQEAKKzIwMTItMTItMTAgIFRpbSBWb2xvZGluZSAgPHRpbXZvbG9kaW5lQGdvb2ds ZS5jb20+CisKKyAgICAgICAgVGV4dCBBdXRvc2l6aW5nOiBXb3JrIG91dCB3aGF0IHRvIGRvIGFi b3V0IGZvcm0gY29udHJvbHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTEwMjU2MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIERpc3NhbG93IGJvb3N0aW5nIG9mIGZvcm0gaW5wdXQgZWxlbWVudHMgbGlrZSBi dXR0b25zIGFuZCB0ZXh0IGlucHV0IGZpZWxkcy4gVGhpcyBpcyBhIHNob3J0IHRlcm0gc29sdXRp b24sCisgICAgICAgIHRvIGF2b2lkIGluY29uc2lzdGVudCBib29zdGluZyBvZiBmb3JtIGNvbnRy b2xzICh3aGljaCBpcyB3b3JzZSB0aGFuIG5vdCBib29zdGluZykuCisKKyAgICAgICAgKiBmYXN0 L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWV4cGVjdGVkLmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3Rp bmcuaHRtbDogQWRkZWQuCisKIDIwMTItMTItMDQgIEFudG9pbmUgUXVpbnQgIDxncmFvdXRzQGFw cGxlLmNvbT4KIAogICAgICAgICBUZXh0VHJhY2sncyAua2luZCBwcm9wZXJ0eSBzaG91bGQgcmV0 dXJuIGxvd2VyLWNhc2UgdmFsdWVzCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3RleHQt YXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRU ZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWV4cGVjdGVk Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uY2VkN2UxZjcwMjk0YTZmYmY1YWRlYTMzYTc0ZjBmNzQ4MTU5YTM3 NgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zv cm0tY29udHJvbHMtYm9vc3RpbmctZXhwZWN0ZWQuaHRtbApAQCAtMCwwICsxLDExNCBAQAorPCFE T0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29u dGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4Owor ICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgICAgZm9udC1mYW1pbHk6 IFZlcmRhbmEsIHNhbnMtc2VyaWY7CisgICAgZm9udC1zaXplOiBzbWFsbDsKKyAgfQorICAKKyAg I2Jvb3N0ZWQgeworICAgIGZvbnQtc2l6ZTogMi4wNXJlbTsKKyAgfQorICAKKyAgI2hlYWRlciBm b3JtIHsKKyAgICBmb250LXNpemU6IDg1JTsKKyAgICBkaXNwbGF5OiBpbmxpbmU7CisgIH0KKyAg CisgICNoZWFkZXIgLmxpbmtzIHsKKyAgICBmb250LXNpemU6IDg1JTsKKyAgfQorICAKKyAgdWwu bGlua3MgeworICAgIG1hcmdpbjogMDsKKyAgICBwYWRkaW5nOiAwOworICAgIGxpc3Qtc3R5bGUt dHlwZTogbm9uZTsKKyAgfQorCisgIHVsLmxpbmtzIGxpIHsKKyAgICBkaXNwbGF5OiBpbmxpbmU7 CisgICAgd2hpdGUtc3BhY2U6IG5vd3JhcDsKKyAgfQorPC9zdHlsZT4KKworPC9oZWFkPgorPGJv ZHk+CisKKzxkaXYgaWQ9ImhlYWRlciI+CisgIDx1bCBjbGFzcz0ibGlua3MiPgorICAgIDxsaT4K KyAgICAgIDxhIGhyZWY9Ii4vIj5Ib21lPC9hPgorICAgIDwvbGk+CisgICAgPGxpPgorICAgICAg PHNwYW4+fCA8L3NwYW4+CisgICAgICA8YSBocmVmPSIiPk5ldzwvYT4KKyAgICA8L2xpPgorICAg IDxsaT4KKyAgICAgIDxzcGFuPnwgPC9zcGFuPgorICAgICAgPGEgaHJlZj0iIj5TZWFyY2g8L2E+ CisgICAgPC9saT4KKyAgICA8bGk+CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAgICAgIDxmb3Jt PgorICAgICAgICA8aW5wdXQgY2xhc3M9InR4dCIgdHlwZT0idGV4dCIgaWQ9InF1aWNrc2VhcmNo X3RvcCIgbmFtZT0icXVpY2tzZWFyY2giPgorICAgICAgICA8aW5wdXQgY2xhc3M9ImJ0biIgdHlw ZT0ic3VibWl0IiB2YWx1ZT0iRmluZCIgaWQ9ZmluZF90b3AiPgorICAgICAgPC9mb3JtPgorICAg IDwvbGk+CisgICAgPGxpPgorICAgICAgPHNwYW4+fCA8L3NwYW4+CisgICAgICA8YSBocmVmPSIi PlJlcG9ydHM8L2E+CisgICAgPC9saT4KKyAgPC91bD4KKzwvZGl2PgorCis8ZGl2PgorICA8cD48 ZGl2IGlkPSJib29zdGVkIj5UaGlzIHRlc3QgY2hlY2tzIHRoYXQgZnJvbSBjb250cm9scyBsaWtl IGJ1dHRvbnMsIHRleHQgaW5wdXRzIGFuZCBjaGVjay1ib3hlcyBhcmUgbm90IGF1dG9zaXplZC4K KyAgICBUaGUgdGV4dCBpbiB0aGlzIHBhcmFncmFwaCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGls ZSB0aGUgZm9ybSBjb250cm9scyBpbiB0aGUgaGVhZGVyIGFuZCBpbiB0aGUgdGFibGUtbGF5b3V0 CisgICAgYmVsb3cgc2hvdWxkIG5vdC4gQWxzbyB0aGUgIkZpbmQiIGJ1dHRvbiBhbmQgdGV4dC1p bnB1dCBib3ggYXQgdGhlIGJvdHRvbSBvZiB0aGUgcGFnZSBzaG91bGQgbm90IGJlIGF1dG9zaXpl ZC4KKyAgPC9kaXY+PC9wPgorCisgIDxmb3JtIG5hbWU9ImxvZ2luIiBhY3Rpb249IiIgbWV0aG9k PSJQT1NUIj4KKyAgPHRhYmxlPgorICAgIDx0cj4KKyAgICAgIDx0aCBhbGlnbj0icmlnaHQiPjxs YWJlbCBmb3I9IkJ1Z3ppbGxhX2xvZ2luIj5Mb2dpbjo8L2xhYmVsPjwvdGg+CisgICAgICA8dGQ+ PGlucHV0IHNpemU9IjIwIiBpZD0iQnVnemlsbGFfbG9naW4iIG5hbWU9IkJ1Z3ppbGxhX2xvZ2lu Ij48L3RkPgorICAgIDwvdHI+CisgICAgPHRyPgorICAgICAgPHRoIGFsaWduPSJyaWdodCI+PGxh YmVsIGZvcj0iQnVnemlsbGFfcGFzc3dvcmQiPlBhc3N3b3JkOjwvbGFiZWw+PC90aD4KKyAgICAg IDx0ZD4KKyAgICAgICAgPGlucHV0IHR5cGU9InBhc3N3b3JkIiBzaXplPSIyMCIgaWQ9IkJ1Z3pp bGxhX3Bhc3N3b3JkIiBuYW1lPSJCdWd6aWxsYV9wYXNzd29yZCI+CisgICAgICA8L3RkPgorICAg IDwvdHI+CisgICAgPHRyPgorICAgICAgPHRoPiZuYnNwOzwvdGg+CisgICAgICA8dGQ+CisgICAg ICAgIDxpbnB1dCB0eXBlPSJjaGVja2JveCIgaWQ9IkJ1Z3ppbGxhX3Jlc3RyaWN0bG9naW4iIG5h bWU9IkJ1Z3ppbGxhX3Jlc3RyaWN0bG9naW4iIGNoZWNrZWQ9ImNoZWNrZWQiPgorICAgICAgICA8 bGFiZWwgZm9yPSJCdWd6aWxsYV9yZXN0cmljdGxvZ2luIj5SZXN0cmljdCB0aGlzIHNlc3Npb24g dG8gdGhpcyBJUCBhZGRyZXNzPC9sYWJlbD4KKyAgICAgIDwvdGQ+CisgICAgPC90cj4KKyAgICA8 dHI+CisgICAgICA8dGQ+PGlucHV0IHR5cGU9InN1Ym1pdCIgbmFtZT0iR29BaGVhZEFuZExvZ0lu IiB2YWx1ZT0iTG9naW4iIGlkPSJsb2dfaW4iPjwvdGQ+CisgICAgICA8dGQ+WyA8YSBocmVmPSIi PkZvcmdvdCBteSBQYXNzd29yZDwvYT4gXTwvdGQ+CisgICAgPC90cj4KKyAgPC90YWJsZT4KKyAg PC9mb3JtPgorICAKKyAgPGZvcm0+CisgIDxkaXY+CisgICAgPHA+PGRpdiBpZD0iYm9vc3RlZCI+ VGhpcyB0ZXh0IHNob3VsZCBiZSBhdXRvc2l6ZWQsIHdoaWxlIHRoZSBpbnB1dCBjb250cm9scyBi ZWxvdyBzaG91bGQgbm90LjwvZGl2PjwvcD4KKyAgICA8aW5wdXQgaWQ9InF1aWNrc2VhcmNoIiB0 eXBlPSJ0ZXh0IiBuYW1lPSJxdWlja3NlYXJjaCI+CisgICAgPGlucHV0IGlkPSJmaW5kIiB0eXBl PSJzdWJtaXQiIHZhbHVlPSJGaW5kIj4KKyAgICA8YSBocmVmPSIiPltIZWxwXTwvYT4KKyAgPC9k aXY+CisgIDwvZm9ybT4KKworPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3Rpbmcu aHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9v c3RpbmcuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi44NWIwYjU5MjFmOWM3ZTFhNWZiMTE1ZjgxMzViMjcxMmVh MzRiODM5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXpp bmcvZm9ybS1jb250cm9scy1ib29zdGluZy5odG1sCkBAIC0wLDAgKzEsMTE5IEBACis8IURPQ1RZ UEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50 PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7CisgICAg bWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgICBmb250LWZhbWlseTogVmVy ZGFuYSwgc2Fucy1zZXJpZjsKKyAgICBmb250LXNpemU6IHNtYWxsOworICB9CisgIAorICAjaGVh ZGVyIGZvcm0geworICAgIGZvbnQtc2l6ZTogODUlOworICAgIGRpc3BsYXk6IGlubGluZTsKKyAg fQorICAKKyAgI2hlYWRlciAubGlua3MgeworICAgIGZvbnQtc2l6ZTogODUlOworICB9CisgIAor ICB1bC5saW5rcyB7CisgICAgbWFyZ2luOiAwOworICAgIHBhZGRpbmc6IDA7CisgICAgbGlzdC1z dHlsZS10eXBlOiBub25lOworICB9CisKKyAgdWwubGlua3MgbGkgeworICAgIGRpc3BsYXk6IGlu bGluZTsKKyAgICB3aGl0ZS1zcGFjZTogbm93cmFwOworICB9Cis8L3N0eWxlPgorCis8c2NyaXB0 PgoraWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdz LnNldFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNl dHRpbmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30g ZWxzZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7CisgICAgY29uc29sZS53 YXJuKCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVp bmcgdHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUg VGV4dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBw eCBkZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19G T1JDRV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hl YWQ+Cis8Ym9keT4KKworPGRpdiBpZD0iaGVhZGVyIj4KKyAgPHVsIGNsYXNzPSJsaW5rcyI+Cisg ICAgPGxpPgorICAgICAgPGEgaHJlZj0iLi8iPkhvbWU8L2E+CisgICAgPC9saT4KKyAgICA8bGk+ CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAgICAgIDxhIGhyZWY9IiI+TmV3PC9hPgorICAgIDwv bGk+CisgICAgPGxpPgorICAgICAgPHNwYW4+fCA8L3NwYW4+CisgICAgICA8YSBocmVmPSIiPlNl YXJjaDwvYT4KKyAgICA8L2xpPgorICAgIDxsaT4KKyAgICAgIDxzcGFuPnwgPC9zcGFuPgorICAg ICAgPGZvcm0+CisgICAgICAgIDxpbnB1dCBjbGFzcz0idHh0IiB0eXBlPSJ0ZXh0IiBpZD0icXVp Y2tzZWFyY2hfdG9wIiBuYW1lPSJxdWlja3NlYXJjaCI+CisgICAgICAgIDxpbnB1dCBjbGFzcz0i YnRuIiB0eXBlPSJzdWJtaXQiIHZhbHVlPSJGaW5kIiBpZD1maW5kX3RvcCI+CisgICAgICA8L2Zv cm0+CisgICAgPC9saT4KKyAgICA8bGk+CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAgICAgIDxh IGhyZWY9IiI+UmVwb3J0czwvYT4KKyAgICA8L2xpPgorICA8L3VsPgorPC9kaXY+CisKKzxkaXY+ CisgIDxwPlRoaXMgdGVzdCBjaGVja3MgdGhhdCBmcm9tIGNvbnRyb2xzIGxpa2UgYnV0dG9ucywg dGV4dCBpbnB1dHMgYW5kIGNoZWNrLWJveGVzIGFyZSBub3QgYXV0b3NpemVkLgorICAgIFRoZSB0 ZXh0IGluIHRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQsIHdoaWxlIHRoZSBmb3Jt IGNvbnRyb2xzIGluIHRoZSBoZWFkZXIgYW5kIGluIHRoZSB0YWJsZS1sYXlvdXQKKyAgICBiZWxv dyBzaG91bGQgbm90LiBBbHNvIHRoZSAiRmluZCIgYnV0dG9uIGFuZCB0ZXh0LWlucHV0IGJveCBh dCB0aGUgYm90dG9tIG9mIHRoZSBwYWdlIHNob3VsZCBub3QgYmUgYXV0b3NpemVkLgorICA8L3A+ CisKKyAgPGZvcm0gbmFtZT0ibG9naW4iIGFjdGlvbj0iIiBtZXRob2Q9IlBPU1QiPgorICA8dGFi bGU+CisgICAgPHRyPgorICAgICAgPHRoIGFsaWduPSJyaWdodCI+PGxhYmVsIGZvcj0iQnVnemls bGFfbG9naW4iPkxvZ2luOjwvbGFiZWw+PC90aD4KKyAgICAgIDx0ZD48aW5wdXQgc2l6ZT0iMjAi IGlkPSJCdWd6aWxsYV9sb2dpbiIgbmFtZT0iQnVnemlsbGFfbG9naW4iPjwvdGQ+CisgICAgPC90 cj4KKyAgICA8dHI+CisgICAgICA8dGggYWxpZ249InJpZ2h0Ij48bGFiZWwgZm9yPSJCdWd6aWxs YV9wYXNzd29yZCI+UGFzc3dvcmQ6PC9sYWJlbD48L3RoPgorICAgICAgPHRkPgorICAgICAgICA8 aW5wdXQgdHlwZT0icGFzc3dvcmQiIHNpemU9IjIwIiBpZD0iQnVnemlsbGFfcGFzc3dvcmQiIG5h bWU9IkJ1Z3ppbGxhX3Bhc3N3b3JkIj4KKyAgICAgIDwvdGQ+CisgICAgPC90cj4KKyAgICA8dHI+ CisgICAgICA8dGg+Jm5ic3A7PC90aD4KKyAgICAgIDx0ZD4KKyAgICAgICAgPGlucHV0IHR5cGU9 ImNoZWNrYm94IiBpZD0iQnVnemlsbGFfcmVzdHJpY3Rsb2dpbiIgbmFtZT0iQnVnemlsbGFfcmVz dHJpY3Rsb2dpbiIgY2hlY2tlZD0iY2hlY2tlZCI+CisgICAgICAgIDxsYWJlbCBmb3I9IkJ1Z3pp bGxhX3Jlc3RyaWN0bG9naW4iPlJlc3RyaWN0IHRoaXMgc2Vzc2lvbiB0byB0aGlzIElQIGFkZHJl c3M8L2xhYmVsPgorICAgICAgPC90ZD4KKyAgICA8L3RyPgorICAgIDx0cj4KKyAgICAgIDx0ZD48 aW5wdXQgdHlwZT0ic3VibWl0IiBuYW1lPSJHb0FoZWFkQW5kTG9nSW4iIHZhbHVlPSJMb2dpbiIg aWQ9ImxvZ19pbiI+PC90ZD4KKyAgICAgIDx0ZD5bIDxhIGhyZWY9IiI+Rm9yZ290IG15IFBhc3N3 b3JkPC9hPiBdPC90ZD4KKyAgICA8L3RyPgorICA8L3RhYmxlPgorICA8L2Zvcm0+CisgIAorICA8 Zm9ybT4KKyAgPGRpdj4KKyAgICA8cD5UaGlzIHRleHQgc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hp bGUgdGhlIGlucHV0IGNvbnRyb2xzIGJlbG93IHNob3VsZCBub3QuPC9wPgorICAgIDxpbnB1dCBp ZD0icXVpY2tzZWFyY2giIHR5cGU9InRleHQiIG5hbWU9InF1aWNrc2VhcmNoIj4KKyAgICA8aW5w dXQgaWQ9ImZpbmQiIHR5cGU9InN1Ym1pdCIgdmFsdWU9IkZpbmQiPgorICAgIDxhIGhyZWY9IiI+ W0hlbHBdPC9hPgorICA8L2Rpdj4KKyAgPC9mb3JtPgorCis8L2Rpdj4KKworPC9ib2R5PgorPC9o dG1sPgo= 178578 2012-12-10 10:01:21 -0800 2012-12-12 08:57:53 -0800 Patch bug-102560-20121210175842.patch text/plain 14303 timvolodine U3VidmVyc2lvbiBSZXZpc2lvbjogMTM2NTA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDAwYjI2MTA1ZWM3MGUy NjM5YzY3ZDBlOWFiMzRlNmZhYjI4YWVkNy4uM2MyNmFmYTk0MGZiZTk0MTI5NDU1OGJmZjgxMDFj NmZhMTZjMDAwNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDEyLTEyLTEwICBUaW0g Vm9sb2RpbmUgIDx0aW12b2xvZGluZUBnb29nbGUuY29tPgorCisgICAgICAgIFRleHQgQXV0b3Np emluZzogV29yayBvdXQgd2hhdCB0byBkbyBhYm91dCBmb3JtIGNvbnRyb2xzCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDI1NjAKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBEaXNzYWxvdyBib29zdGluZyBv ZiBmb3JtIGlucHV0IGNvbnRyb2xzIGxpa2UgYnV0dG9ucyBhbmQgdGV4dCBmaWVsZCBpbnB1dHMu IFRoaXMgaXMgYSBzaG9ydCB0ZXJtIHNvbHV0aW9uLAorICAgICAgICB0byBhdm9pZCBpbmNvbnNp c3RlbnQgYm9vc3Rpbmcgb2YgZm9ybSBjb250cm9scyAod2hpY2ggaXMgd29yc2UgdGhhbiBub3Qg Ym9vc3RpbmcgYXQgYWxsKS4KKworICAgICAgICBUZXN0OiBmYXN0L3RleHQtYXV0b3NpemluZy9m b3JtLWNvbnRyb2xzLWJvb3N0aW5nLmh0bWwKKworICAgICAgICAqIHJlbmRlcmluZy9UZXh0QXV0 b3NpemVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEF1 dG9zaXplcjo6cHJvY2Vzc1N1YnRyZWUpOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEF1dG9zaXpl cjo6cHJvY2Vzc0NsdXN0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6Y29u dGVudEhlaWdodElzQ29uc3RyYWluZWQpOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEF1dG9zaXpl cjo6aXNBdXRvc2l6aW5nQ29udGFpbmVyKToKKyAgICAgICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6 ZXI6OmNsdXN0ZXJTaG91bGRCZUF1dG9zaXplZCk6CisgICAgICAgIChXZWJDb3JlOjpUZXh0QXV0 b3NpemVyOjpjb250YWluZXJDb250YWluc1RhZ3MpOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEF1 dG9zaXplcjo6ZmluZERlZXBlc3RCbG9ja0NvbnRhaW5pbmdBbGxUZXh0KToKKyAgICAgICAgKiBy ZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oOgorCiAyMDEyLTEyLTA0ICBBbnRvaW5lIFF1aW50ICA8 Z3Jhb3V0c0BhcHBsZS5jb20+CiAKICAgICAgICAgVGV4dFRyYWNrJ3MgLmtpbmQgcHJvcGVydHkg c2hvdWxkIHJldHVybiBsb3dlci1jYXNlIHZhbHVlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1RleHRBdXRvc2l6ZXIuY3BwCmluZGV4IGIxMDJiMmI1YjI5Mzc1YzcyODQ5MmMxYzk4NGJmN2Y4 NjVkODcyMjEuLjhiOGExYmZjMzUzYzIwY2ZhZTkzMmFlYjQwYTVkYmI0ZjE4N2ZlZmYgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5jcHAKQEAgLTI1LDYgKzI1LDcg QEAKICNpbmNsdWRlICJUZXh0QXV0b3NpemVyLmgiCiAKICNpbmNsdWRlICJEb2N1bWVudC5oIgor I2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCiAjaW5jbHVkZSAiSW5zcGVjdG9ySW5zdHJ1bWVudGF0 aW9uLmgiCiAjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCiAjaW5jbHVkZSAiUmVuZGVyU3R5bGUu aCIKQEAgLTM3LDYgKzM4LDggQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCit1c2luZyBuYW1l c3BhY2UgSFRNTE5hbWVzOworCiBzdHJ1Y3QgVGV4dEF1dG9zaXppbmdXaW5kb3dJbmZvIHsKICAg ICBJbnRTaXplIHdpbmRvd1NpemU7CiAgICAgSW50U2l6ZSBtaW5MYXlvdXRTaXplOwpAQCAtODks NiArOTIsNyBAQCBib29sIFRleHRBdXRvc2l6ZXI6OnByb2Nlc3NTdWJ0cmVlKFJlbmRlck9iamVj dCogbGF5b3V0Um9vdCkKICAgICAgICAgY2x1c3RlciA9IGNsdXN0ZXItPmNvbnRhaW5pbmdCbG9j aygpOwogCiAgICAgcHJvY2Vzc0NsdXN0ZXIoY2x1c3RlciwgY29udGFpbmVyLCBsYXlvdXRSb290 LCB3aW5kb3dJbmZvKTsKKwogICAgIHJldHVybiB0cnVlOwogfQogCkBAIC0xMTksMTEgKzEyMywx NSBAQCB2b2lkIFRleHRBdXRvc2l6ZXI6OnByb2Nlc3NDbHVzdGVyKFJlbmRlckJsb2NrKiBjbHVz dGVyLCBSZW5kZXJCbG9jayogY29udGFpbmVyLAogICAgIHByb2Nlc3NDb250YWluZXIobXVsdGlw bGllciwgY29udGFpbmVyLCBzdWJ0cmVlUm9vdCwgd2luZG93SW5mbyk7CiB9CiAKLXN0YXRpYyBi b29sIGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWlu ZXIpCitib29sIFRleHRBdXRvc2l6ZXI6OmNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnN0 IFJlbmRlckJsb2NrKiBjb250YWluZXIpCiB7CiAgICAgLy8gRklYTUU6IFByb3BhZ2F0ZSBjb25z dHJhaW5lZG5lc3MgZG93biB0aGUgdHJlZSwgdG8gYXZvaWQgaW5lZmZpY2llbnRseSB3YWxraW5n IGJhY2sgdXAgZnJvbSBlYWNoIGJveC4KICAgICAvLyBGSVhNRTogVGhpcyBjb2RlIG5lZWRzIHRv IHRha2UgaW50byBhY2NvdW50IHZlcnRpY2FsIHdyaXRpbmcgbW9kZXMuCiAgICAgLy8gRklYTUU6 IENvbnNpZGVyIGFkZGl0aW9uYWwgaGV1cmlzdGljcywgc3VjaCBhcyBpZ25vcmluZyBmaXhlZCBo ZWlnaHRzIGlmIHRoZSBjb250ZW50IGlzIGFscmVhZHkgb3ZlcmZsb3dpbmcgYmVmb3JlIGF1dG9z aXppbmcga2lja3MgaW4uCisgICAgUXVhbGlmaWVkTmFtZSB0YWdzWzRdID0ge2lucHV0VGFnLCB0 ZXh0YXJlYVRhZywgYnV0dG9uVGFnLCBmb3JtVGFnfTsKKyAgICBpZiAoY29udGFpbmVyQ29udGFp bnNUYWdzKGNvbnRhaW5lciwgdGFncywgNCkpCisgICAgICAgIHJldHVybiB0cnVlOworCiAgICAg Zm9yICg7IGNvbnRhaW5lcjsgY29udGFpbmVyID0gY29udGFpbmVyLT5jb250YWluaW5nQmxvY2so KSkgewogICAgICAgICBSZW5kZXJTdHlsZSogc3R5bGUgPSBjb250YWluZXItPnN0eWxlKCk7CiAg ICAgICAgIGlmIChzdHlsZS0+b3ZlcmZsb3dZKCkgPj0gT1NDUk9MTCkKQEAgLTIxMSw2ICsyMTks MTIgQEAgYm9vbCBUZXh0QXV0b3NpemVyOjppc0F1dG9zaXppbmdDb250YWluZXIoY29uc3QgUmVu ZGVyT2JqZWN0KiByZW5kZXJlcikKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIGlmIChyZW5k ZXJlci0+aXNMaXN0SXRlbSgpKQogICAgICAgICByZXR1cm4gcmVuZGVyZXItPmlzRmxvYXRpbmco KSB8fCByZW5kZXJlci0+aXNPdXRPZkZsb3dQb3NpdGlvbmVkKCk7CisgICAgLy8gYXZvaWQgY3Jl YXRpbmcgY29udGFpbmVycyBmb3IgdGV4dCB3aXRoaW4gdGV4dCBjb250cm9scyBvciBidXR0b25z CisgICAgaWYgKHJlbmRlcmVyLT5wYXJlbnQoKSkgeworICAgICAgICBpZiAocmVuZGVyZXItPnBh cmVudCgpLT5pc1JlbmRlckJ1dHRvbigpIHx8IHJlbmRlcmVyLT5wYXJlbnQoKS0+aXNUZXh0Q29u dHJvbCgpKQorICAgICAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKwogICAgIHJldHVybiB0 cnVlOwogfQogCkBAIC0yNzEsNiArMjg1LDMyIEBAIGJvb2wgVGV4dEF1dG9zaXplcjo6Y2x1c3Rl clNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBsb3dlc3RDb21tb25BbmNlCiAg ICAgcmV0dXJuIGZhbHNlOwogfQogCitib29sIFRleHRBdXRvc2l6ZXI6OmNvbnRhaW5lckNvbnRh aW5zVGFncyhjb25zdCBSZW5kZXJPYmplY3QqIGNvbnRhaW5lciwgY29uc3QgUXVhbGlmaWVkTmFt ZSB0YWdzW10sIGNvbnN0IHNpemVfdCBudW1UYWdzKQoreworICAgIGNvbnN0IE5vZGUqIGNvbnRh aW5lck5vZGUgPSBjb250YWluZXItPm5vZGUoKTsKKyAgICBib29sIHZhbGlkQ2FuZGlkYXRlID0g Y29udGFpbmVyTm9kZSAmJiBjb250YWluZXJOb2RlLT5pc0hUTUxFbGVtZW50KCkgJiYgIWNvbnRh aW5lck5vZGUtPmlzU2hhZG93Um9vdCgpOworICAgIGlmICh2YWxpZENhbmRpZGF0ZSkgeworICAg ICAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG51bVRhZ3M7ICsraSkgeworICAgICAgICAgICAg aWYgKGNvbnRhaW5lck5vZGUtPmhhc1RhZ05hbWUodGFnc1tpXSkpCisgICAgICAgICAgICAgICAg cmV0dXJuIHRydWU7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBSZW5kZXJPYmplY3QqIGRlc2Nl bmRhbnQgPSBuZXh0SW5QcmVPcmRlclNraXBwaW5nRGVzY2VuZGFudHNPZkNvbnRhaW5lcnMoY29u dGFpbmVyLCBjb250YWluZXIpOworICAgIHdoaWxlIChkZXNjZW5kYW50KSB7CisgICAgICAgIGNv bnN0IE5vZGUqIGRlc2NlbmRhbnROb2RlID0gZGVzY2VuZGFudC0+bm9kZSgpOworICAgICAgICBi b29sIHZhbGlkQ2FuZGlkYXRlID0gZGVzY2VuZGFudE5vZGUgJiYgZGVzY2VuZGFudE5vZGUtPmlz SFRNTEVsZW1lbnQoKSAmJiAhZGVzY2VuZGFudE5vZGUtPmlzU2hhZG93Um9vdCgpOworICAgICAg ICBpZiAodmFsaWRDYW5kaWRhdGUpIHsKKyAgICAgICAgICAgIGZvciAoc2l6ZV90IGkgPSAwOyBp IDwgbnVtVGFnczsgKytpKSB7CisgICAgICAgICAgICAgICAgaWYgKGRlc2NlbmRhbnROb2RlLT5o YXNUYWdOYW1lKHRhZ3NbaV0pKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAg ICAgICAgICAgIH0KKyAgICAgICAgfQorICAgICAgICBkZXNjZW5kYW50ID0gbmV4dEluUHJlT3Jk ZXJTa2lwcGluZ0Rlc2NlbmRhbnRzT2ZDb250YWluZXJzKGRlc2NlbmRhbnQsIGNvbnRhaW5lcik7 CisgICAgfQorICAgIHJldHVybiBmYWxzZTsKK30KKwogdm9pZCBUZXh0QXV0b3NpemVyOjptZWFz dXJlRGVzY2VuZGFudFRleHRXaWR0aChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyLCBmbG9h dCBtaW5UZXh0V2lkdGgsIGZsb2F0JiB0ZXh0V2lkdGgpCiB7CiAgICAgYm9vbCBza2lwTG9jYWxU ZXh0ID0gY29udGVudEhlaWdodElzQ29uc3RyYWluZWQoY29udGFpbmVyKTsKQEAgLTMxOSw3ICsz NTksNyBAQCBjb25zdCBSZW5kZXJCbG9jayogVGV4dEF1dG9zaXplcjo6ZmluZERlZXBlc3RCbG9j a0NvbnRhaW5pbmdBbGxUZXh0KGNvbnN0IFJlbmRlcgogICAgIGNvbnN0IFJlbmRlck9iamVjdCog bGFzdFRleHRMZWFmID0gZmluZEZpcnN0VGV4dExlYWZOb3RJbkNsdXN0ZXIoY2x1c3RlciwgbGFz dERlcHRoLCBMYXN0VG9GaXJzdCk7CiAgICAgQVNTRVJUKGxhc3RUZXh0TGVhZik7CiAKLSAgICAv LyBFcXVhbGl6ZSB0aGUgZGVwdGhzIGlmIG5lY2Vzc2FyeS4gT25seSBvbmUgb2YgdGhlIHdoaWxl IGxvb3BzIGJlbG93IHdpbGwgZ2V0IGV4ZWN1dGVkLgorICAgIC8vIEVxdWFsaXplIHRoZSBkZXB0 aHMgaWYgY29udGVudEhlaWdodElzQ29uc3RyYWluZWRuZWNlc3NhcnkuIE9ubHkgb25lIG9mIHRo ZSB3aGlsZSBsb29wcyBiZWxvdyB3aWxsIGdldCBleGVjdXRlZC4KICAgICBjb25zdCBSZW5kZXJP YmplY3QqIGZpcnN0Tm9kZSA9IGZpcnN0VGV4dExlYWY7CiAgICAgY29uc3QgUmVuZGVyT2JqZWN0 KiBsYXN0Tm9kZSA9IGxhc3RUZXh0TGVhZjsKICAgICB3aGlsZSAoZmlyc3REZXB0aCA+IGxhc3RE ZXB0aCkgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6 ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmgKaW5kZXggYTcw OWIxMTY4ZTQ0ZGYwMGVjMWY5ZDczYmJlNWU1MTZmZTkyNjc3NC4uNWM2OGY2ZGMzNmIxYTFhODNh MjJjYjY3YmExNTVhNmY0ZWMxOTJhYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVy aW5nL1RleHRBdXRvc2l6ZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1 dG9zaXplci5oCkBAIC0yOCw2ICsyOCw3IEBACiAKICNpZiBFTkFCTEUoVEVYVF9BVVRPU0laSU5H KQogCisjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5jbHVkZSAiSW50U2l6ZS5oIgogI2luY2x1 ZGUgPHd0Zi9Ob25jb3B5YWJsZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CkBAIC03 MSw2ICs3Miw4IEBAIHByaXZhdGU6CiAgICAgc3RhdGljIGJvb2wgaXNBdXRvc2l6aW5nQ2x1c3Rl cihjb25zdCBSZW5kZXJCbG9jayopOwogCiAgICAgc3RhdGljIGJvb2wgY2x1c3RlclNob3VsZEJl QXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBsb3dlc3RDb21tb25BbmNlc3RvciwgZmxvYXQg Y29tbW9uQW5jZXN0b3JXaWR0aCk7CisgICAgc3RhdGljIGJvb2wgY29udGVudEhlaWdodElzQ29u c3RyYWluZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lcik7CisgICAgc3RhdGljIGJvb2wg Y29udGFpbmVyQ29udGFpbnNUYWdzKGNvbnN0IFJlbmRlck9iamVjdCogY2x1c3RlciwgY29uc3Qg UXVhbGlmaWVkTmFtZSB0YWdzW10sIGNvbnN0IHNpemVfdCBudW1UYWdzKTsKICAgICBzdGF0aWMg dm9pZCBtZWFzdXJlRGVzY2VuZGFudFRleHRXaWR0aChjb25zdCBSZW5kZXJCbG9jayogY29udGFp bmVyLCBmbG9hdCBtaW5UZXh0V2lkdGgsIGZsb2F0JiB0ZXh0V2lkdGgpOwogCiAgICAgLy8gVXNl IHRvIHRyYXZlcnNlIHRoZSB0cmVlIG9mIGRlc2NlbmRhbnRzLCBleGNsdWRpbmcgZGVzY2VuZGFu dHMgb2YgY29udGFpbmVycyAoYnV0IHJldHVybmluZyB0aGUgY29udGFpbmVycyB0aGVtc2VsdmVz KS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5n ZUxvZwppbmRleCBhODlkZDQ1ZjQ1NDBiNWM4MzZmODRjMmY0ZDA3ZGY0NTk3MTllZDFmLi40ODgw NmNjOTE5NWYzZDcyNGM1NmNkMzM5YmM1M2FiNmY4NjY3MzE3IDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYg QEAKKzIwMTItMTItMTAgIFRpbSBWb2xvZGluZSAgPHRpbXZvbG9kaW5lQGdvb2dsZS5jb20+CisK KyAgICAgICAgVGV4dCBBdXRvc2l6aW5nOiBXb3JrIG91dCB3aGF0IHRvIGRvIGFib3V0IGZvcm0g Y29udHJvbHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTEwMjU2MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IERpc3NhbG93IGJvb3N0aW5nIG9mIGZvcm0gaW5wdXQgZWxlbWVudHMgbGlrZSBidXR0b25zIGFu ZCB0ZXh0IGlucHV0IGZpZWxkcy4gVGhpcyBpcyBhIHNob3J0IHRlcm0gc29sdXRpb24sCisgICAg ICAgIHRvIGF2b2lkIGluY29uc2lzdGVudCBib29zdGluZyBvZiBmb3JtIGNvbnRyb2xzICh3aGlj aCBpcyB3b3JzZSB0aGFuIG5vdCBib29zdGluZykuCisKKyAgICAgICAgKiBmYXN0L3RleHQtYXV0 b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWV4cGVjdGVkLmh0bWw6IEFkZGVkLgorICAg ICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmcuaHRtbDog QWRkZWQuCisKIDIwMTItMTItMDQgIEFudG9pbmUgUXVpbnQgIDxncmFvdXRzQGFwcGxlLmNvbT4K IAogICAgICAgICBUZXh0VHJhY2sncyAua2luZCBwcm9wZXJ0eSBzaG91bGQgcmV0dXJuIGxvd2Vy LWNhc2UgdmFsdWVzCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3Npemlu Zy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0 L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWV4cGVjdGVkLmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uY2VkN2UxZjcwMjk0YTZmYmY1YWRlYTMzYTc0ZjBmNzQ4MTU5YTM3NgotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYm9vc3RpbmctZXhwZWN0ZWQuaHRtbApAQCAtMCwwICsxLDExNCBAQAorPCFET0NUWVBFIGh0 bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lk dGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdp bjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgICAgZm9udC1mYW1pbHk6IFZlcmRhbmEs IHNhbnMtc2VyaWY7CisgICAgZm9udC1zaXplOiBzbWFsbDsKKyAgfQorICAKKyAgI2Jvb3N0ZWQg eworICAgIGZvbnQtc2l6ZTogMi4wNXJlbTsKKyAgfQorICAKKyAgI2hlYWRlciBmb3JtIHsKKyAg ICBmb250LXNpemU6IDg1JTsKKyAgICBkaXNwbGF5OiBpbmxpbmU7CisgIH0KKyAgCisgICNoZWFk ZXIgLmxpbmtzIHsKKyAgICBmb250LXNpemU6IDg1JTsKKyAgfQorICAKKyAgdWwubGlua3Mgewor ICAgIG1hcmdpbjogMDsKKyAgICBwYWRkaW5nOiAwOworICAgIGxpc3Qtc3R5bGUtdHlwZTogbm9u ZTsKKyAgfQorCisgIHVsLmxpbmtzIGxpIHsKKyAgICBkaXNwbGF5OiBpbmxpbmU7CisgICAgd2hp dGUtc3BhY2U6IG5vd3JhcDsKKyAgfQorPC9zdHlsZT4KKworPC9oZWFkPgorPGJvZHk+CisKKzxk aXYgaWQ9ImhlYWRlciI+CisgIDx1bCBjbGFzcz0ibGlua3MiPgorICAgIDxsaT4KKyAgICAgIDxh IGhyZWY9Ii4vIj5Ib21lPC9hPgorICAgIDwvbGk+CisgICAgPGxpPgorICAgICAgPHNwYW4+fCA8 L3NwYW4+CisgICAgICA8YSBocmVmPSIiPk5ldzwvYT4KKyAgICA8L2xpPgorICAgIDxsaT4KKyAg ICAgIDxzcGFuPnwgPC9zcGFuPgorICAgICAgPGEgaHJlZj0iIj5TZWFyY2g8L2E+CisgICAgPC9s aT4KKyAgICA8bGk+CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAgICAgIDxmb3JtPgorICAgICAg ICA8aW5wdXQgY2xhc3M9InR4dCIgdHlwZT0idGV4dCIgaWQ9InF1aWNrc2VhcmNoX3RvcCIgbmFt ZT0icXVpY2tzZWFyY2giPgorICAgICAgICA8aW5wdXQgY2xhc3M9ImJ0biIgdHlwZT0ic3VibWl0 IiB2YWx1ZT0iRmluZCIgaWQ9ZmluZF90b3AiPgorICAgICAgPC9mb3JtPgorICAgIDwvbGk+Cisg ICAgPGxpPgorICAgICAgPHNwYW4+fCA8L3NwYW4+CisgICAgICA8YSBocmVmPSIiPlJlcG9ydHM8 L2E+CisgICAgPC9saT4KKyAgPC91bD4KKzwvZGl2PgorCis8ZGl2PgorICA8cD48ZGl2IGlkPSJi b29zdGVkIj5UaGlzIHRlc3QgY2hlY2tzIHRoYXQgZnJvbSBjb250cm9scyBsaWtlIGJ1dHRvbnMs IHRleHQgaW5wdXRzIGFuZCBjaGVjay1ib3hlcyBhcmUgbm90IGF1dG9zaXplZC4KKyAgICBUaGUg dGV4dCBpbiB0aGlzIHBhcmFncmFwaCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZSB0aGUgZm9y bSBjb250cm9scyBpbiB0aGUgaGVhZGVyIGFuZCBpbiB0aGUgdGFibGUtbGF5b3V0CisgICAgYmVs b3cgc2hvdWxkIG5vdC4gQWxzbyB0aGUgIkZpbmQiIGJ1dHRvbiBhbmQgdGV4dC1pbnB1dCBib3gg YXQgdGhlIGJvdHRvbSBvZiB0aGUgcGFnZSBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4KKyAgPC9k aXY+PC9wPgorCisgIDxmb3JtIG5hbWU9ImxvZ2luIiBhY3Rpb249IiIgbWV0aG9kPSJQT1NUIj4K KyAgPHRhYmxlPgorICAgIDx0cj4KKyAgICAgIDx0aCBhbGlnbj0icmlnaHQiPjxsYWJlbCBmb3I9 IkJ1Z3ppbGxhX2xvZ2luIj5Mb2dpbjo8L2xhYmVsPjwvdGg+CisgICAgICA8dGQ+PGlucHV0IHNp emU9IjIwIiBpZD0iQnVnemlsbGFfbG9naW4iIG5hbWU9IkJ1Z3ppbGxhX2xvZ2luIj48L3RkPgor ICAgIDwvdHI+CisgICAgPHRyPgorICAgICAgPHRoIGFsaWduPSJyaWdodCI+PGxhYmVsIGZvcj0i QnVnemlsbGFfcGFzc3dvcmQiPlBhc3N3b3JkOjwvbGFiZWw+PC90aD4KKyAgICAgIDx0ZD4KKyAg ICAgICAgPGlucHV0IHR5cGU9InBhc3N3b3JkIiBzaXplPSIyMCIgaWQ9IkJ1Z3ppbGxhX3Bhc3N3 b3JkIiBuYW1lPSJCdWd6aWxsYV9wYXNzd29yZCI+CisgICAgICA8L3RkPgorICAgIDwvdHI+Cisg ICAgPHRyPgorICAgICAgPHRoPiZuYnNwOzwvdGg+CisgICAgICA8dGQ+CisgICAgICAgIDxpbnB1 dCB0eXBlPSJjaGVja2JveCIgaWQ9IkJ1Z3ppbGxhX3Jlc3RyaWN0bG9naW4iIG5hbWU9IkJ1Z3pp bGxhX3Jlc3RyaWN0bG9naW4iIGNoZWNrZWQ9ImNoZWNrZWQiPgorICAgICAgICA8bGFiZWwgZm9y PSJCdWd6aWxsYV9yZXN0cmljdGxvZ2luIj5SZXN0cmljdCB0aGlzIHNlc3Npb24gdG8gdGhpcyBJ UCBhZGRyZXNzPC9sYWJlbD4KKyAgICAgIDwvdGQ+CisgICAgPC90cj4KKyAgICA8dHI+CisgICAg ICA8dGQ+PGlucHV0IHR5cGU9InN1Ym1pdCIgbmFtZT0iR29BaGVhZEFuZExvZ0luIiB2YWx1ZT0i TG9naW4iIGlkPSJsb2dfaW4iPjwvdGQ+CisgICAgICA8dGQ+WyA8YSBocmVmPSIiPkZvcmdvdCBt eSBQYXNzd29yZDwvYT4gXTwvdGQ+CisgICAgPC90cj4KKyAgPC90YWJsZT4KKyAgPC9mb3JtPgor ICAKKyAgPGZvcm0+CisgIDxkaXY+CisgICAgPHA+PGRpdiBpZD0iYm9vc3RlZCI+VGhpcyB0ZXh0 IHNob3VsZCBiZSBhdXRvc2l6ZWQsIHdoaWxlIHRoZSBpbnB1dCBjb250cm9scyBiZWxvdyBzaG91 bGQgbm90LjwvZGl2PjwvcD4KKyAgICA8aW5wdXQgaWQ9InF1aWNrc2VhcmNoIiB0eXBlPSJ0ZXh0 IiBuYW1lPSJxdWlja3NlYXJjaCI+CisgICAgPGlucHV0IGlkPSJmaW5kIiB0eXBlPSJzdWJtaXQi IHZhbHVlPSJGaW5kIj4KKyAgICA8YSBocmVmPSIiPltIZWxwXTwvYT4KKyAgPC9kaXY+CisgIDwv Zm9ybT4KKworPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmcuaHRtbCBiL0xh eW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmcuaHRt bApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi44NWIwYjU5MjFmOWM3ZTFhNWZiMTE1ZjgxMzViMjcxMmVhMzRiODM5Ci0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1j b250cm9scy1ib29zdGluZy5odG1sCkBAIC0wLDAgKzEsMTE5IEBACis8IURPQ1RZUEUgaHRtbD4K KzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04 MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAw OworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgICBmb250LWZhbWlseTogVmVyZGFuYSwgc2Fu cy1zZXJpZjsKKyAgICBmb250LXNpemU6IHNtYWxsOworICB9CisgIAorICAjaGVhZGVyIGZvcm0g eworICAgIGZvbnQtc2l6ZTogODUlOworICAgIGRpc3BsYXk6IGlubGluZTsKKyAgfQorICAKKyAg I2hlYWRlciAubGlua3MgeworICAgIGZvbnQtc2l6ZTogODUlOworICB9CisgIAorICB1bC5saW5r cyB7CisgICAgbWFyZ2luOiAwOworICAgIHBhZGRpbmc6IDA7CisgICAgbGlzdC1zdHlsZS10eXBl OiBub25lOworICB9CisKKyAgdWwubGlua3MgbGkgeworICAgIGRpc3BsYXk6IGlubGluZTsKKyAg ICB3aGl0ZS1zcGFjZTogbm93cmFwOworICB9Cis8L3N0eWxlPgorCis8c2NyaXB0PgoraWYgKHdp bmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRB dXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNl dFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30gZWxzZSBpZiAo d2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7CisgICAgY29uc29sZS53YXJuKCJUaGlz IHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVpbmcgdHJ1ZSwg c28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUgVGV4dCBBdXRv c2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBweCBkZXZpY2Ut d2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19GT1JDRV9URVhU X0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hlYWQ+Cis8Ym9k eT4KKworPGRpdiBpZD0iaGVhZGVyIj4KKyAgPHVsIGNsYXNzPSJsaW5rcyI+CisgICAgPGxpPgor ICAgICAgPGEgaHJlZj0iLi8iPkhvbWU8L2E+CisgICAgPC9saT4KKyAgICA8bGk+CisgICAgICA8 c3Bhbj58IDwvc3Bhbj4KKyAgICAgIDxhIGhyZWY9IiI+TmV3PC9hPgorICAgIDwvbGk+CisgICAg PGxpPgorICAgICAgPHNwYW4+fCA8L3NwYW4+CisgICAgICA8YSBocmVmPSIiPlNlYXJjaDwvYT4K KyAgICA8L2xpPgorICAgIDxsaT4KKyAgICAgIDxzcGFuPnwgPC9zcGFuPgorICAgICAgPGZvcm0+ CisgICAgICAgIDxpbnB1dCBjbGFzcz0idHh0IiB0eXBlPSJ0ZXh0IiBpZD0icXVpY2tzZWFyY2hf dG9wIiBuYW1lPSJxdWlja3NlYXJjaCI+CisgICAgICAgIDxpbnB1dCBjbGFzcz0iYnRuIiB0eXBl PSJzdWJtaXQiIHZhbHVlPSJGaW5kIiBpZD1maW5kX3RvcCI+CisgICAgICA8L2Zvcm0+CisgICAg PC9saT4KKyAgICA8bGk+CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAgICAgIDxhIGhyZWY9IiI+ UmVwb3J0czwvYT4KKyAgICA8L2xpPgorICA8L3VsPgorPC9kaXY+CisKKzxkaXY+CisgIDxwPlRo aXMgdGVzdCBjaGVja3MgdGhhdCBmcm9tIGNvbnRyb2xzIGxpa2UgYnV0dG9ucywgdGV4dCBpbnB1 dHMgYW5kIGNoZWNrLWJveGVzIGFyZSBub3QgYXV0b3NpemVkLgorICAgIFRoZSB0ZXh0IGluIHRo aXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQsIHdoaWxlIHRoZSBmb3JtIGNvbnRyb2xz IGluIHRoZSBoZWFkZXIgYW5kIGluIHRoZSB0YWJsZS1sYXlvdXQKKyAgICBiZWxvdyBzaG91bGQg bm90LiBBbHNvIHRoZSAiRmluZCIgYnV0dG9uIGFuZCB0ZXh0LWlucHV0IGJveCBhdCB0aGUgYm90 dG9tIG9mIHRoZSBwYWdlIHNob3VsZCBub3QgYmUgYXV0b3NpemVkLgorICA8L3A+CisKKyAgPGZv cm0gbmFtZT0ibG9naW4iIGFjdGlvbj0iIiBtZXRob2Q9IlBPU1QiPgorICA8dGFibGU+CisgICAg PHRyPgorICAgICAgPHRoIGFsaWduPSJyaWdodCI+PGxhYmVsIGZvcj0iQnVnemlsbGFfbG9naW4i PkxvZ2luOjwvbGFiZWw+PC90aD4KKyAgICAgIDx0ZD48aW5wdXQgc2l6ZT0iMjAiIGlkPSJCdWd6 aWxsYV9sb2dpbiIgbmFtZT0iQnVnemlsbGFfbG9naW4iPjwvdGQ+CisgICAgPC90cj4KKyAgICA8 dHI+CisgICAgICA8dGggYWxpZ249InJpZ2h0Ij48bGFiZWwgZm9yPSJCdWd6aWxsYV9wYXNzd29y ZCI+UGFzc3dvcmQ6PC9sYWJlbD48L3RoPgorICAgICAgPHRkPgorICAgICAgICA8aW5wdXQgdHlw ZT0icGFzc3dvcmQiIHNpemU9IjIwIiBpZD0iQnVnemlsbGFfcGFzc3dvcmQiIG5hbWU9IkJ1Z3pp bGxhX3Bhc3N3b3JkIj4KKyAgICAgIDwvdGQ+CisgICAgPC90cj4KKyAgICA8dHI+CisgICAgICA8 dGg+Jm5ic3A7PC90aD4KKyAgICAgIDx0ZD4KKyAgICAgICAgPGlucHV0IHR5cGU9ImNoZWNrYm94 IiBpZD0iQnVnemlsbGFfcmVzdHJpY3Rsb2dpbiIgbmFtZT0iQnVnemlsbGFfcmVzdHJpY3Rsb2dp biIgY2hlY2tlZD0iY2hlY2tlZCI+CisgICAgICAgIDxsYWJlbCBmb3I9IkJ1Z3ppbGxhX3Jlc3Ry aWN0bG9naW4iPlJlc3RyaWN0IHRoaXMgc2Vzc2lvbiB0byB0aGlzIElQIGFkZHJlc3M8L2xhYmVs PgorICAgICAgPC90ZD4KKyAgICA8L3RyPgorICAgIDx0cj4KKyAgICAgIDx0ZD48aW5wdXQgdHlw ZT0ic3VibWl0IiBuYW1lPSJHb0FoZWFkQW5kTG9nSW4iIHZhbHVlPSJMb2dpbiIgaWQ9ImxvZ19p biI+PC90ZD4KKyAgICAgIDx0ZD5bIDxhIGhyZWY9IiI+Rm9yZ290IG15IFBhc3N3b3JkPC9hPiBd PC90ZD4KKyAgICA8L3RyPgorICA8L3RhYmxlPgorICA8L2Zvcm0+CisgIAorICA8Zm9ybT4KKyAg PGRpdj4KKyAgICA8cD5UaGlzIHRleHQgc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUgdGhlIGlu cHV0IGNvbnRyb2xzIGJlbG93IHNob3VsZCBub3QuPC9wPgorICAgIDxpbnB1dCBpZD0icXVpY2tz ZWFyY2giIHR5cGU9InRleHQiIG5hbWU9InF1aWNrc2VhcmNoIj4KKyAgICA8aW5wdXQgaWQ9ImZp bmQiIHR5cGU9InN1Ym1pdCIgdmFsdWU9IkZpbmQiPgorICAgIDxhIGhyZWY9IiI+W0hlbHBdPC9h PgorICA8L2Rpdj4KKyAgPC9mb3JtPgorCis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgo= 178787 2012-12-11 05:56:27 -0800 2012-12-11 05:56:27 -0800 illustration of the impact on the form controls elements form_boosting_small.png image/png 344141 timvolodine iVBORw0KGgoAAAANSUhEUgAAA+gAAAI4CAYAAAD56sN/AAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A /wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9wMCw0oDgnkDAoAACAASURBVHja 7L15nF1Vlff93eecO1bVrXlMKqnMAySQEAhTIIQMTCIQg62o7dBta8/9Pj79adu236ff1tZu31Zf W330URoVZVABQWYDYYYECJmAzCFjpebp1h3P2fv9407nzrcqSaUCd/nxE+qeYZ3922efvdZvrb22 +PKX/0FFHE2YjjpiogAR/zchIs8xUeA3Mq7P/I0xnFPK9UyA/lLaTonYZd7jdGFPHh2F2nguYF+s PxgDdhOJfSn6VYHnn2zYcxr7qYz9Bxt7ShjHxXA41+eb04e9tCRdL/8B/+AJejV/8mhZzk1RCnRd p719Gs3NLSiV+52KRiMcOXKE3t5uNE2b3G2SCiklCjCV4Kpqkyav4MVBg4GoQCu/tGUpS1ls34to NIppSUBhGAZOp2PCn0Moid/bzGD1TEzdNf65VSlwV6EiAXzDh6kZfg9RwFYQ3/yvu1W/72p6hkwQ Ku0+wjb/q7hdYH8wJeJ/57AhkiaYSjc3ito15LbNsq7PZxuSceIZ0q9IxyftXGE7Nxd2ua4TjA/7 HPfJwl6kde05j30h/WXszx72Y9J/JrEv1Pcqv5+YHNMfFOxt100I9vnG3TmEvQCklERDo0gzghCJ 6VUh4lcoVPyvWMMc7ko03SAa8iOlmTwP25X2x5FK4fT40IRGJDicvCOJe2Y8mdI0nO4KNN2BHO1G 2/YTGi+8hkhUlujol9hJeUmIfKRBMV2n47ex6D7bbR+/fpVXh/3dO1X94yGain3cC+tW8WNiEmM/ MfpPF/ZjIQMn/3t/9vSPJZA1XrK3jP3p0T+WcVKKQZRPtzoDbadg2429R0ew2qKAzHpAleOGKuPX QtCoIn8XmnBynaeKaixCXpxm/WqMulTRAVzG/nToV+PWn0+LKGM/QfpPN/b5+jNf21UZ+zP8zTu3 sRdCIzQ6QnO9B4+7loiVcpzTpnEFSgiq3ILDJ3rxD4WZMbUBNCdSpvAWIsFmxBkKBV43HDzSTdC0 mD2tiYilJ8IJcZYgNiaEUqBpRE1FcHSEUESieRoR05cy6LuSqCUzyHth06cyyMMMJrEIAZNGUhez PxPsTt7eSbRfFSdgxvJKiIy22xo17rbnIZQKEY+nFft8+icx9pn6VZKSsgFXSrBjsmJfSL9KvHUF smUmEPux6D/3sY9TVzn1l7GfNN+8s4y9QGCGg5iRYHJeTjQnF4cvhIbT68OMhLCi4Yx75ybd0XRc nmqi4RGkaaKQGd/A9DvoDhcOdwWGVAqlpC19ShXkGcjgckWOx7PzusUQTjeDVEHMRQ4u+f2gXxUx Z1WSIVdFkyHL2J9u7HPTI2Xsz7z+sWCfuqaM/enFPh39YgnYxRjtcx17hEIpRSQKgahJMGKhpbXd dncFls+BacauCUVhNBIlErWIBvqQ0YgNbIGzog5Nd9FQHXfipSQYgQF/BAlERgdAmjgr6lFWlJC/ F3dVE5puUF1RwVB3L66KGkZGTHxRiVKyCGmRj5wpjKMaEwlS2KKKnSlL0l/qXfOdmU2clq4/F52j ikZmCmOvctKP70/smVDsS+37icNeTSLsmZTY5x43Ks83/1Sw5wOPPSjkWcReTS7shYYhIjQ0VKE7 PMiEL6xUnKyIW5YKnA6dkaFe/JbEqUWoa65FaQZKJvw0lSTaY5cJHA7BYG83IaVw61HqmhqQUkPG 75lgPZSK9Y7QBMGQyfDQEIZCYUkFSuUNtNuNZJX2ihdbPagKdm5m4kDh31XO45wF/RQYNMKGSzJK Qv7EGJnXKM5+pUtdualshuj7DftS9ZMDrzOJffp9VEnn5UyjfZ9gX+zdOxPYyzL2Y9Z/erEv7ZuX 657nDPYiNl9KKZGo2JraPBqliq2hS667lRKldPp7uvjbj8xlTnt1nJEXhCMm/3b3dsKqFqUMpJRY UsWukTG+3Yj286kbFvDfTxyiuUpx+YopPPByL87KegwNpGUipYrrlSlDg3yJeSpPEETl7bvCgY1E 1EDmeZ8ySRaVp48mr35VkIJKUISqYEUFO/ayjP2YsS+mvzj2sW/FWLHP3/fvf+zHq7907POhX2zc lbGf7NiTYZNPNuwlEpcuGBw1iahw0obM1XaFoFIDpRQOXaN7OIpCEQ2NYEVGQMqYU69Ac3hxeqpB aFRqAiUlDl2jqz+CRENJi9DwSZwV9egOF9HRPiQCV0UdIPC4FIayYsVlEmxB5mMljem4py+IPVxa tELY4htKpdYyZr4qygaRSJ2ffo90jlmlAS9s90mkRmXEV86mfhXvwngKokIgFEihECpj2hap823h mQLYxxMp82JPXv2J1JL3NfYJOGxQxLBPtN2O9enEvljf58I+1VfvD+zT9adSfFPr8VUW9pntPxPY Z447YYPl/Yl9cf252q9sk506Q9jnGnfpU2la21XMcZ1s2AtNJp1mpRSWKdH19LXhCoVSAikTzrxK /rdlKYSSvHOgm/9+bA/DoyamlNy0vIVQKIJ0y+T5ynadlArLNYXfPX+IL96yEGlG+a8H9+GubkbF 72tJhbJiTn2CdCeHAy4LkOz5SPdchHTa74LkmnuVh1jJHdHJT5RNtP58DmBJJUkFsSUHGfgWw54S Ah7jaXspUd/JhH2p+uUEYp9JPpbS9nzv0JnGXqhsbCZM/xnEvmgJUfEBxz7e+LOBPUIlbet8gVtR kISfHN8cFY+px7LJFZn5dZl9K1HJ81GSiFR01ET4+NpFVFd5kFLhdGg8sPFt3jwuMWXMsrBkzEKS cR2jw/1suLKNt3Z3cqDH4s9ums29T72DKWtRgKZJDFRs8icrxb3YisLSVtrmi7GNZaVwacfHWun3 TOrP9WrJMehXRXQUa4sqYnJMNPacQ30/VuwL9X0Z+7HpP53Y5xp3ZezPHvbFvlvqnMBeKA1pxZ1u FIFggAUtFlNqtaRWSyq2vWcxYlWgpCPmbFsqFU1XEAkHqfQ1ItwCKcEyQ1iWhbIU0oo73Ak9UiIl SMvCcApCERNlmei6QMqYOSRl/DopY6n1UoGUNj4s4zuoUsRkgnRPrguMM2sJck2KDAMrzvhK7Ovn sxcvioz1eLnMwAQto3JYTiJOqEhB2hKvVJLmOPWntT1Dv/36BMETD0wk9MUwVSlLMUH4JCsjpoij UrCXWdjHW6niOkWq9SLeN+cs9ukaYgZ1Luwhrt+mPYl9xkVnCPt8fZ/W9syUVuIOq5js2BfSn2Pc 24IfUmUOkonDXuXDPnF+IeztQUb7K3QuYZ+pPw37GGFxZrEv5Zs3XuztbZ847BWgRCrTTQiFJlLY aHEcLAVKaXHnXCJFjAi3pKSxxs03fraFobAGQkNGQ6xZ2ogALEsiRZx0FwrLis3Rnqp6fvnMCf7y lpnc6qvg/qd2ETDa0GUsC0sKhSEVSMvuoJMWZZKWicBMsmT2OEF28kR6Tc7Cjgp5uJT8fIc9lTGX 85UV+Shama903dn6s/kqdYptV0KghANN03OekxpHGR8pu357hFLY30KVtt4xi2qDYjWTitiuKvu+ eQ18QR5g8+rPVTQj/U+Vp+0qo+2kD+yc9KAqYz8G/Uns7eHzJPakUhgmHPvx9H1223NCOkmwL6j/ nMM+Q7/Ifp3ONvZCyJjjbEksJNJSmKYiEk2NAUuCKWPV3qUlsSwrFgW3YpOzlIL6unoudA8Tjpoo qWhvbULbPUI07qAnougyrksqDS1wjLXXnMf3fvMObdWKW69o59fPd+OsqEfGI+dSxoyPZFZcUTJC jYGsKfX6UomQ8RcAnFj9pQYmSiXQS7lWlaC/jH0Z+8mk/2xjr8rYn3HsS9F/bmGvEEilsJTEUuBh kHktAp/XQEowDMGBEwE6Az4sXEgRz3LTEnO0jDn2ugNfbSOG4WS4/wRSJY5pyXncIu6oKwkSHLog EjEJBKMYuoayLKSQSTLGUCpmNOR6eDPsp0bv4/LzGqiqcJ4mgMuSTwaGw7y0q5OAaMJwemMpJIy1 ZEnuwVRojfBY4lDjifblLn8xEfrzla1SJd2rjP37DfvS9J/72HPOYl9Y/9nHXggttT4cicvl5tAg HBxIP08XoAni6elxZ13FJvbK6jp++8IxpBlNJcW/NYzX14AmRPw8+/8VCouwqOOHDx+mwtdCnxnl F08fobK6OWYIqDibb8WKw6WR7rZGSWkhVBShZFoEQeTcSDR98UNu0jkXy1isrwTjY0tOhXDPQ0Cd ybYrkEJHaAZC6AUIMJW+9MeWtivsxJadkIICv+V4pFLJP2En92wn5csNFZl7ZZau3xa4y4BUFWl7 5j6OIrcOkYHTacM+I3J5DmJfSH8qYluo7Rn6zwr2pfZ99rEsPncyYp+LeD7nsC+BdLdhr0T60rKJ wF4J4tFwmXTSIyaEo/FCrwpMCywrtl494aArVJwYh67+MJedV48ZDSFlAM/MenoGRolG4068iJPt QiFNidJ0AkO9fPTqZp5+7RD7Ok3+av087n/qbSJaR/y5ZMxBl5a0L9SNee9WFB89/ODvr6Wywlv2 nidI1ncP8uf/sQlTm46mOeIvUWJ7HZWxfUDmWk7IufojPunlfIOzkg3G8sErYXWJPU9nQvQXanuO G2VF80RG/o0qjD1F9p0ohH3W5ec69hnH0iKjZxv7Yvrt54tzGPtMaAronzTYj1X/2cNeCAvLUuhI KtwCt0MraAt6jFgk27LAIRTVHh0pBXWVzdkOS/x5nXq8MJwEQ0hqKrTYzStqk+cJXIjqdmS8uKtD kygZy4ZTKpZ2l45/rIicCvVwwTSN+R115cn2DItUip37ennnhMCoaEJoGrmKDxYnkFTBTUDHTmqN hQQsvjfCeDZEzFwTO/a2qzT9Y92A9dSxV+c89uqcx34s+s9N7ClAcp872KsCQYOzj71CYCV+lZIg VezsTF/Prgl3Ijk+GTW3VIwM14RkX7fOzvd6bMXWh3C4KnB5Y3VzEkvVYsQ+KEviqazlVxuP4qmq p7rBxQ8feQ+nowanjC0VsCQYyfVq8WIHCVvIDA5y87VtVFZ4UUohMVHKRClQlgUCNE1PpjhqwkAT Rk6jQ4gi7Ha8CFGu09KuV7aUyoQBZmN3kgGDjN/yXj+WZ5wgaWqoYu2yeh7aMoCrsh5lmSgrECsJ nDRi051yoRsIwxtbX5Es3KDSBlHmYEuSZzJ7N+LMYgwAQuaLRdgqPQt7caZ8cRKVlu06Hv3pboEt Wle07bYPj+3HdB8gMQ7sjoSyLes4Ff32c3PpV+l/T0Ls06mQXG1nkmJfTL8de5VmQYpJiH1atfQs 7DnHsB+r/nTsszL5zyj2AofLy4m+UaQ5lPomJ6OBwrZlaewqw12Jy+vm4PEBlDQzIhekL+eLK3K6 K3G4dfYf7omV7RMiPzGhYkaAy12djLjnSnE3gwN8fEUtH7tpWdl7nkD5/q9e4LFtfbgr6knUZlAq c6RmGKdCkDdTIO+SlFJCRgWILQqQqXbdeS3jCdKv8hHy+czyfHtVFMKvVOyL7VlRxv7sYl9KibJz GftC+s8W9vn0FwronF3sQ1GT2moHmqHH/eHcbXIaGsNDkqip0LCoqdGQCJS3AlFXmZNwdzg0Bvui mEoRNKPU12tYVoxiqK2cGifcobaiOT4vKJy6oK8vGo+gSxtXoBTKMqlggFvXXB1/fIsTI89xYuQV rJCkc9tOKrw+2qbPZ0j4qairpr3qWhq9S5HSIhwMItFwuNw4Da0EakPEF9ObRMIRdF1gCQMhJW63 K23qEgLMaBSpFA6nEysaQSpwOJ1Jn9WKRpAIdMOBJsi6PhoJE4lE0R1OnE5nrCBAKTxQPMJzqr58 PkJAKYWm6axfvYiHX3wSy12DGR5h6cKp6Jqed5OA0dEgh4/1EtGqEJoRr/EvbNUlc6yHzvsi5xow +QYyeT8CCbtV5T1nHPpzPnvGvRU52p6wzlXGLTOM3IwK0FkforQxniflsmT9OdqWdp9Jhn0p+s8Z 7Ivpz5UHRUbl78mOve0cZSMR8rbddp+zin0h/ZMB+9hcqTsrMZwpzJQQOaulJEhhqcBwV+WpUZKt Q6mYo+/wVJeMfaLqe5J0VykSRVoRfNoA69ddmZxrTBWMPXt8CzhN12NnazEiwtA8OXFKI73HOMdl Xl+IHFfJaERqzs08P+f1eYj4syFKKW5ft4inNj+N6fIhNAMr6kdYpq0uQ4x8t6fUaw4PaEaq+BP5 tvDMH53KuXWYLbuk8EIDlZ5Nm8cYLmJaF9dv+0SRSQDayauCbVcFKlFnrJG1ORrCZlOcGf2THPu8 X7j3G/YqK6sq17t3NrAv1vfnJvb59Nuxz6U/G3v7/jFnCnshBMGozkjnMIrBDBNDpNfSiQdEHS5F JKoxeKw3M1EtB9eh0HQHDrdkJKwzeLg7/XuvMpbKxG0KzXBikCgoY4NfRgKsWd6GYRip93vEgEOK OsOFFfJSYVRT6dcIREw0L4iqWDr2UM8RfvKd7yMb2ll4ySpuvmox0aiJoWuYloVh6ETDISKWwOU0 EEiCoSguJxw8cpRNDz7OjGkudlcvwn28my/86Qb8owFcLjeOuLP/1gtPc7ArzE0fv423n3mUI6NO rrn5JrwRPw5vJSd2bOaI5WbGomU0qABKd+B0OpKO+HOP/IbXtu6icdEKrrt6Oc01XnSHC6dDIxQM xowphwunQyccDGAqDY/bhaaJU1iGb5t+Raz6bjgcxuPxEAwGcblcaJoWY1Vqqrh6cT0bd49gODz0 9g1RU+2LEQQ5RoTD4WL61Gb2vNeNcFTHTpAFCjsko4OqiOGr8pOSY67orwrcYwz6ZS4dGefJEvRL MrZsUuTa9TDr2tOmPxf25G97xoA/K9ir9wv2ufSXgL08TdircYy79zX2peo/S9jn/OZZpX/6M/ef yftjoTFfRKx0p1BaKg1bMzjCLWs7cDpi87SlQmw98e9g6QwdPcZw5xDtHR0IZwVmg0WFs5kLGv88 5shHwoQiUXTDgcfjLomgFkKgLAvTjGIKHSscwuEw0F0eDHvWRPy8qGXFDB+hiJgWQtNxGHrScAtH omhCw+EwspxzaZmEw2FMCW6PB4euUaprfrqy5wrdp77Wxw2XNvPAlkE8lXXUuiUd09uT2wCKDLfC sky6ewbp7A+gu3wFSKlSIkeFyCfSSUlR7FzOjH5JxpaLOUi6kpKDSyG/chxL6i+0ud6p6p+k2KsP OPZyMmJ/KvonG/aF9J9F7DPnYN2Jw3CV3HalFMJw43B4Sm67lArN6UF3emx9nx97hcBIVJpL0BZK KazRPtZcemWa3vCgn+Hj3VS2zGLWkg0c3b+VY/uPUFc/hdreOjTHKHhhJDjCgaCPf75tHd/75r+z 4MJvcejNo1y6pIPXt2zjsksX8tTvHmTvUCUXzm9jwVQ3d/7qSXwNLSxYfi1tLQ0ILYDT4UCP+tnx wu95bMt7XHbNday8aA4AR45u5/4nD9I8tYU3n3qEdyuX0TxrG+8+8zjV513N4hYfLbUGOzc/x5G3 3sA7fRFXrbiCaY1VQJg3Dg1w9XXX8fJTz3LvOy/irmtkziXrWDG/hj889gT9AwO0XnIrV8yr4eWn HmFvr8bNt93MrCn1aCL3fqPZ+GZ+IFK0lEAwMDDAQw89xIYNG3jooYe45cMfprqmBgFomsY1yzv4 /ZYdVDXMoLd/BF+VL79eYsWL6n1OuocjaLojIyJVYPzZ14zao9TFsmDGwkvk0p02TnIY3uPSX6B4 RMG223Wq4jWLTrv+CcI+5zfqg469ysaeMQZfzzr2ReaySY/9qeqfRNgX++bJM4+9SqS4J9tlQriX W65dYSNTQDth4IoKZK+bZoeOPuRE9wr6iWK0OAEwg37eeOo3PLztBNOndXDDbR+lvQqUboBlooSB UCbBYAjDGSOZrUgQSxgMHzvE8eN72COa2XXfr7ly5YW0Xv9pFhkjmJoTj8eFAPyd+9j46nbqFlzO 8oYgv3/hLVrmL+PKBVPxRyRVFYKXX9lCZWUdFy+dx2gwisvlxBEPIAweeIvfPvUCRwYs1t70IRbN mYZT1/G43SDDBMMmQtNxu1wIZTIaCOFwe3AaRrpTrcbSz+kdJoQgEAjgcrkQQhAOh3G73Qgh0HWd D686j3uf+QNOTw3DUYtw2EwthchKjBDU1dRgmgN0jYTRdWd+4jDtPVNF2qDy27dKFSCjSiWgVBH8 ipDOOYnIEnYWEJnkWykknppg/apwv50t7O3XflCxzxv8OJvYl6h/0mNfSP9pwF6NY5vanN+8MUZe S/reFsGtBALeiL0jKWNBWhGaq01mTGuK7wkXqyqrIgFmdVzI7u0v8fLD/0VV4zICQS9C7qbS2ccl H/oKdW2AGebY1k38+BeKUO1sGDjKK2/sYfHcet54cSNtTRG2dtVy+8oWfvDz11j3/S/z8VsVz7/0 GmFriNdff5vV18xBSUnE0pm7bCUj/o3sfOlRpi7+O2Y7onjaFlPj62HLk48idQ/LL2zD3Tib2zfc yG+e28VvntzGittW8OjLJ7hx2SX0njzGu1vfYNq6awAdMXSM3979JhHfDNasvoXrl7r49r2v8/J/ P8PKv/gn6rfdz/ajvRx47Mc0rfooV7pe4qnX9rF+tY/WaiMZyVZFAje5T4iRIPX19fh8Pr7yla9w 6aWXUlNTk+oHAYvmtlPr3kzYjOI3FZFoBEPTs1MhEkmAQlFb7aOztwvcNanCcllRLjIWPNrYPAqN zQJVI/NGnDJOTgZ0RGnkWNozZWyplK9AXFqhrwzDWybZjGzDHLLvrTLTbE+D/szFpvnmksmEfZb+ Am3PfO/POexz6RfFI5kThn2eY4X0Twbsz4j+s4n9ePWX2vZT+OYpYsvWEvOUGeLieT4cDkcy0quk YuC9k1S5PUyZcQWjI4P0HH0Hp9NNS9MUDDMKzRAJDNN5cDcLbv5rFh7/Ld/50e/505W11Jx/MdaB rXRWLaZ+6E0eeepV2uctpnn2YkZ2PMir+yI0NkzlxtWzqegHp8uFy+2k9/Be7tv0IGbrIq67bh1t PoNgzzGefvQhmsLVONoD/Prhx7nRcqMdf4MX9wxzw43X0tjcwsCB3Tz56C52H/Nz8aVXsnzpfBzA yXe2IKYv4+r2PTzzuwd5SnfQ2DKVW2+9nsDBzTy/7Qij0ssdt99A8PhOHt34Om0XrGTtlRdQ5Xbk cJQzBruwcSjJb0h6HqoQgkcffZSFCxeiaRoHDhzgpptuSt67vqaaRdNc7BkMEkEQCIRiy/dU7gRa IQS1NVV09Z1EumrJuadxoSWm+Y4V4HZOScYSsML2vopx6CkU4Cp2bNLoP4vY2+e0DyT249Sfq+/G jP04+76M/QcS+9Qa9MT67cgo1109Pc1v0zSdxuY5bPzll+jv04i0/CfO6fOx/AEkMDh4FH+oPnaN 7qT9otX8zec+yq/+97d47SQ4VIDBoRHC4Qi6DFHV0IaJi45mNycPbuXxxx9n8Ya/oi5wiM2AUhKh G/Qe38s9P/p3nt96iKaZ87gsAjggamrMrDWoaG7k2AmDxcYQzz1+H/e++Spd7jZmYoFUNLQ0UV1b h7/rGLqeQMVE1UzlptW3s3blAn74re/wv546xgGziTbhooIQja2N7De99BJh+x/u4V1XNUuv8lDp FKkJNde2IWkZlSpjz/jUSQKBZcVS3BcsWIBpmkSjJrqhJ+9tGDrXXtzKA1tGcLur6OruZ0pLY7xe QEYUKG50CcDn1RmOWKmKsZlF5RLrUBL72guR2wnOQXjFduYTOV+85LspMg5mpZQCSqYeXRSZtez6 lV2/Sm9PYt1J5j7MdqMq6TDIdFss8zmVyqpCLeLECln60wtj5dYvbAEQZav0mBnBzb1H+tixz9iH +nRgn6Xf9u5ltZ1zGHuVvV4LiVKTCXvSsM8ad3ZmnLOJvb3vY8tuxoJ9Sn/mhKcm7ptzqt+8JCwy 3cmzR8+z1rnZCvApOWbshYpVjE3oMINDrF0+Oz1QoCRVDkFD8/k8/auvojvqcVbOJxw6CeGnaZ3S wPSLvojQNEIjgzxy1/9mv3uEmZdcws4tz7Nw5vlYB3fxtN9gatfzXPrhj3Pg4Ts5PnMdH1t/B/qT z/Dm7mEObHuDrublaEJhmVG89VO4/uYb2bTlLR56+Fn+4pNriViwbF4rnYHDvLBHp6Z1AboluGjV zQx1/5x33nqOo7IN8crvqb96PRfP0jl88CDeppksnerE6fawZ9PjvNzbz8IlV3HLR2/jrZ//B9ve CPDU64Iv3XEZ//nt39K95Dnueng/n/3UDdx/z+84b0Yj82dNT61YVAWIlkweW2X/uHrNar7+9a9j mRZf/vKX04oF6g6day5uZ/vvuvFWN9HdN0h7W1NG4MZeBjH2b53PTfdoFF3T0ycGlSoYK4Rtlaiy WYuqBPJJ5bdeiya3qlRBu5ICgCqHFavyW9TZFadztD05njMIrpxtzZGCeqr6hX0lbj79uXRNNPY5 /iiiP2/b45Hfs459Sfoz370M8vesYD/OvlecY9jn0l/GfizYG0l7SilAYoX6WX3ZRUgpkxOXNCMc 2P4YJ46NctLxFSpGNIa278PlcmFGJU0+L269EQBNSUYPvs737jSJumazqq2BnqGdPPDYEMGaeVQ3 L2D0rW9x59uNCOXiwLtv8PS2bqYseJH+qlYamxtwV/jweVyEq6upbnAza7aGt6YGZ9w4czo05ly6 io/eej07nnuaYyPd+HxVOKZ34DFqqAkN43Z7qak0cToceCsrY+lucamtraGqwgWE8Pjq6XDojA65 +fCiDjY/9yx7X36Mlhvm8Ufr/4inN73KoD9IdU0Vmq4hlcqo0psj46NYoEZAT083dXV1fPKTn+Tp p59mcGiQurrU1jeaprHqkpnc9+xmXO5q+oZN6mrDOJ3O7LVuIm6qaRrVvgr6jo/idFekP6dSaS+o Ik9qhyq2A7LKZ7vkzxpQZNH6efUzFv2qiH77wJF2azpFnyiV+zlVJnNBTQAAIABJREFUeggsa+OH jArJKtMxzRqk6YNY5cxcUDlhGDv2agKwH0ffn1Xs7X1fDHv1PsY+37t2JrDPN+4oCfu0vio0Lib0 mzMR2HOK2KfmKCUtDDnEiovnoGzFYIVmUF0znT/c/RVU45/hal6Np6YKAlECI/30RPbG5n7Lwl1V w63r/47F/pf5xp1P8vFL6+jr6Uf3h1C6gaXrNLpMhlun0jvSybOPb+SVAzp/ettlbH1tU+x5JBgE 2f7y4/z6yUfxVzayeFlDTEc0Ss28Czi0Z5BG+llw2ZUcefM57vzeG7zy2g4WrV2DVSVwaR6am2po qzd4b2cEMxwFnISDQeZcsoq/uXUdgefv5f4ffoN3t2xheY2Typq5BJSP5voK3GqEsP84P/3JL2iY ugBPlS8P2Z5hnqrUNyvGo6gsw18p6O/rZ0rbFKSUDA0N0djQmLS9NAFXXzKb79z/LtJqZGA4Qkuj ha5rNhsusVOLTBbOrfZVcqKvF+H1pdJJsRFwyTEm4qS7ShqPiQJEyk6Ape3srtIJIzLJoRRTpTIz SUT2+M0k/UWB9zRLv1IZOyKojKQnYcsKlCniNcF6KRDI9F0YlMq4NtNWk6RtCWnHPk2/SJJaWfqz iOoU+SgmHfZ59Ke9f3Eu1b7rRtpcPdHYl9L39iABBbBXkw/7HPqlsu86IvJEa88V7NMzedOK94l0 Uj42/FUy4WxSYJ9TfyHsEzvRZNie48TeUHFQEAorGmJ+m0ZrUx2maaZ1rMtdy/O711FZO0gkYtLa Wk1jk8GR13fQot7g5JwvMBto61jC3Y88bMNRcv7Xv5v8OxgM8Nf/8BX27NvDq7v9XHHjR3jixs+n FK27CoArAK5YAsD6xL0sk6ipc/2a62KxcNNk8cq1LM5Dnlx2aRzMJfOT54ODL3zuk4Aiako+82df SJ5vBYa4WDnYXBVleHYdTect4W+WXJ7sFMuyUnWQVAmETV4SSNHU1MSNN96IaZmsXbs2uT2O/Q6z pzczvd7kZCSEYXg4cLiL9rZGnA4jryZN6EgrglIVOc4421VtxVnUJ8bwLKWcK07hvz8I2I+lL8rY Tw79E4G9KGN/JrC3R97jFeBRIKNBVl3YhNB0LCtVSc6MBHj9sW9z3PxTKtVlBPedIDKllt5OP16X xpzmabH5xHAgNPjDz77H/irJtTeupaPyCHfefQ9tHpPzr2+h0dXEN7/5fRoqHbS43uPQC49hzbuV jZu2Mr29kVGPi1BjA25vFT4qmdYxi3BFJdVVsQI7usuNYVRz6+c/zUUN/TyxcSu7q2poaKlhzpwA jdU+wl4vzsYGPC4nuuGhqtKBK15tzllRTZ3mQ7cgKh20Tesg3HOSpnlrMLa9yhP3/oBndwxz8yfW c9PlYd5+rxujrha3occc2CLrD1V+uij5u6YJdu3axWc++xk0ofHqa68ya9astJMrKjwsX1DNm0eD GM4KTnT10dZSjx4vDpvMDklUuBegGzoeJ0StAiRQHtI3NyGl8gZUyZ3zV4CASrde8+qnRP0JY17l WiWocpBVKm3pRyb5p3I+ew7i0ZZdldp5wXbPnNHnbFItt/5zBXtVAvYUwD6H/tOCvSjS9+Qk/c8p 7HPoV8X024I+Zw97+7grjn1WTfbM71cWTz9JsWfisBcf+eK3VZ/7CpQVhWAn//r5RVx24SzbemiB NKO8/OQTfP+nw3g8OlVVbppaqrn4/DrMB3/MsbBizl/9C9etbSUatVJGg0gfRJqmM9x7nI2/f4Ah Twe3rr+FGsOM182JpX6jyLGdWC4GZbyGUp7ot6aD/zgPPPgovY7pfOSGFTTVejEtWXibQDGeZ8mN T6ZIKXn8uR186773cPqmABrRkB8po+TeND7WDpe7AoRGWcpSlrKU5QMgQhD7n4KeTaimVaAsLP8J /t+/vICLFs1ILo8SQhAKjPDdv/soe/yfJTAyRGWFm6uuncNzj+xieng/syq6+PTDP8OyJLpeYC4x Q4z6Axw+uI9tr77IvDu+xEU1pT92NBpFdzjQAKSFpURhfcTqKmmxveMwpUI3jPhWciZCN9LMhIHe XnSzi+//6iVuufk6Fs6ZnrqPZaXsnNMghmEgVcxe0DQtK8ghleLpF3bwtbsP4a1tx4z4aal1UlPt y1sZX0pJZ/cAAasCJsG2cWUpS1nKUpYJEKViReJQChHp56rznCy/YCaWlGknCd3BNbfcxqpbyGIF +PhP4qeZRCJm+vGMzegsy6Kyvo0Nf/K3sbk9GiFWQD7BYCTWCYrcXLXK4akn04mK+e2FN7RXlgne Vj76mS/Gns2MYppWvBl25iPXeoJs57+4357LOU+/jxCCVZfO54XXD/FuVx+6qxIcOvHafgXaGSa7 soEqwC7k25IiX3WEXKXGyXNdPjQKVVvId16uexbbTiObdcvdjonEp9C1pwuj8TzPBwmfyfAOlfGZ fO9QoUovkxMfpcBSOmFTR9Njzq4CzJCfeS2Siy+YRTRqpl1qSZ3O4JUoZeKtqqS6zktzSzWXztU4 f9uL/Lb9H/k0IKWFlFbOd0cIAabJsX1v8vhL+7ho5Ue4qEbFddm20FGF4bbMKJa9pqEsvoWdZbu/ GY3aLk79t8Ph4MSeLWzcvJuV69YzY0Y7lmnGi+8WCQKMw2+PtTt2oT1bwX7rqy6ZS/vv36EzOILD XUXnYJijXZ2FeBcMhxvdocZeabgsZSlLWcpyTooQAvGRL3xbdbGIVedL/unzK5EQX6t2RlSS7u7m nw2LmUmZDXnfdY7NLDOtKM++sodARBWgHVSOlRbxiMopGsex5Izi5RCLmc3KttYjVzqEyEnMZBuz iZaVahyrDB2pp0m8j6l9B8Up45MfhfQj2eel45ODsCmITzrOYgzlK9Pfodz4CNvf43GuUncu/JZk X5HuXGWW9LAnGpXqgKq0sVL8HSpljKW/Oal75S64kt+VLEqqloBP9hgbu4Oea4yptPGT75km4htU 6hjLRtc+xnL1WWnfoFz4n8I3SOX+Btn7IP0NS8cnYir6/RaPv9pNSG9E63kOq34FdeI9vvr5y1k0 d1ossps2Z6bvKZ5we0FPtigSjhR/KYWGrhvoWmy9e9S0SGSHpeoQ5ttznjz9PV4/Ofs+uuFMPptp WbYlj2PYlkGQvRvRmJ8p3qdK8fKb+/jOL7cive3JgkcFyaW828XkG8ul/FYKhrm/gqeQNjhGwutc JihPFz6U+OyF+qvQMwk+mATuePEpZrGf7jH2fgqSqDEcn8hv0KmMsTPzDZJSELZELBQbDfTyV5/4 EJbMWI91qhhktVtlGbz52pGzEGMO9l1JlZOtnlAv+gzfSwjBmisXxrLW1QQ+02RkLCbinHP1HeID 2u8f9HeoPMbOWQw1TUPTtFNWiSboG3yB53abKCWp1Ab45z+5lAsWTk/LbEttXWsRDueaN82cNlFe 80pZmNJKu0oktnrLaViposayEGKcr0/2VZYZwSpAluTvmuxqhKrEbhf5bJx421Yun09bYwU79vej C5HT7CZJyaicpFFmqCP9N5VhUuZsVZ4Vg8WNY5Fe6qlg+3Ob3dmEaYpSzE9BFsInnZ7MvFumhlz4 ZD5PfoIyv7ukcuAj0p4199FC+GQjn5vKKjKm8vaZyNu34gziYydw8wVJSiUoScM293t1+vDJ50ae qTEmbEiotPGd/rbZx31p+JytMZb59Fk1JCb8GzT+MSYysFW2Aq3jwidWZY7RsOKtfYPxfdCtKD6P EVtvTZG5dLyiTvF4pj8vBGbUJBQKEYlEYvu7FuBasvYPVyLp8CeqHoq0Kq02SEX2hvRCxUGOV9uL 7S9rexFyZcFnES4ZlUDTqpjm+mzZXrO0ZxKpaoYJAycelVG23H9RjD8UIlmFMPavSOKT/rw52pbj g5e2jVDGYMi8RJ2L+NiqMSYqL8beizPwDuUkPzO31crITVG5o+tp6af2KTNZQTN9u7dEoZxJjc+E jjGRrDgqhM1gUYX53mLfoKJjTKkP3jeo1HdI2PdNP4VvUD6mPc8YU2r8+EAsDdvtdmMYxqk56QKa agyUtMCKcsV5Pi5Y2EE4HM0mudWpTd+nYyrPRcon3hnTNIsWbjuXCdMI0DG1mVnTW/OaxqXn0+Q2 yHOfO5YcHSgtKjpenSqP+yJKfLNKbfNkwAdKyS8s/pzqNONTqt7x9vtYnicfPsV+Hy8+jKO/x3pu KX2tzhA+YxljRb5ByeDqZB9j45nVTu83SAD6qczltor21/WH4ouZhcKSMl75VY25GEnhZNWxv/QJ 40Wp3GkBsbRvid/vR9M0GhoaklEIIURyos++R1nKUpaylKUsE+z32eYl+9zk9/sZGhqipqYmK5Ke P4E/t8RqxyiUsqip1IlEczi6k2k6zHgWKSWRSIRQOIy0rPTtDsdBnoyHoIQM4lOQk4CbMHIpo12n k1w6k/icEYIyV9RTgRDqtBOUIt5hmbHGcw2fM01Q2rfPzIqMn0YC1773dWqMnTv4TOgYi5fKEmnv UCLodvqCJOVvUPY7pGkaLpcTl8t9ykuvayqNVLUxqVR8DziV2JYtvocm6EJD6PFtWpRK6xxlZ1fi HZz6lCk0IWKRWCXTT0uu60pFrxECTQgsS2JasT3MdU3DtCSWNNG1BJIawWAQ3TCoq61F1/UUOx2J EA6H0XUdt9uddqwsZSlLWcpSlomWQCBIIDBKdXU1Docj6aDX1tYyGgjEnOu4g5cwAzRNoGsaQtPi jnZsXpVKYVoW9gJsQhM2f1YgrRgRoKTKMEBL951LJwdyHMs09LJI9+yCc8FgkEg4TJXPh9vtTiM2 EteWCfeylKUsZSnL2ZYEoW6flyzLoqenB6XA5XaXEJ/PP69alkw56EoqlJRJ/igxD2podPf20NPT w8yZM3E6HWnryxKp0EpJ23o1hYz/FgpH0QCny5Xcm1XF2QpF2nZ6WKZJd3c3Bw8dZHhomCltbTQ2 NWFZFm63m8bGRqSSCCSWZWIYRpoDPjo6yuHDhzlx4gSVlZXMnj2burq6tMjECf8JKp0+fM7KGDFh BQjjwKM7GI2M4jY86FlrAnOYKypVaT0cCuFwuRAyionG4QNHmTG7I0UolGLjMO5TMaNh3nuvk9lz OmJtMqOM9HYS9LbR4jNAmoz09xJy1lHrNIkaXjxGKkV3LHpVPMOivOFLWcpSlrLk/07av607dmzn +PHjLFmyhI6ODjRNSx7X4lG71PwLmtAYGByks7MTJdOXnjkcDmbOnJn+7ZakR5xRSKlQSJAiHnGK keGaEGiagSK9foudHEgQ58moSWwjs1iUOGO+T/na8fNEPJ6mYsSBQBCNREETOB2OeGV4GX/+ZIux pMTt8VBZWWkzUiyCwSBSStxud5LcKEtZylKWspTlbEl/fz9CaFRX+9B1HaUUhmHQ3NxMV1cXRjzA bA9kOwxHspaYPSdHWhZWIkBuC2SnHHQls9hpIQQnu07yy1/+kq1b3+QH3/8hbnddjDGwLJuDnbsS nmXG2ARpWjS3NONKOOlkpB7E010OHDjAvffey/Hjx/H5fITDYVwuFzNmzGD16tU0NzdjRa34vu7Z G6Ucfu8whw8fpr6+nnA4zP59+5k3bx61dbVJx/MXb9/N7JqZXD19DdWuGvr6NvGCX2dh3Vy2HnuO jtr5LG5YgACGIyP43I1UOzxEowN0BQcxHLU0uqsxksaRxZ49B5m3YC6hroMEa5r58v/4Gv/6zb+j sr6NKS11REeHiBiVVLg0BvsGqa6rhaifo8d78VX70N0+fG7F8WPHiOKkbWobTgHSDDAc0qmp0DjZ G6ClqZqh/gF8dXUMdh1jKCyY0j4F/9BJvvy3/8KP7/4PIspDozvM5nu+y9tL/5m/W1nB8feO0LPr Bd6uXMGcwec4VL+C6y5qp7rSC0oS9A/S1T9KXVMrPrcgMDLMYCCKbjipr3bT09WLcnioqXTjrago j8yylKUsZSninIdCIcLhMJqmMTAwwBVXXMHBgwdxu914vV48Hg8ulyuWuqkyistosHfvXv7Pj39M OBxOiyK3tLTw9a99Hd1Izw5TGYXNVHzZWmKOTsTgI2aUQwf34vF4aG9vR8YJAHsRmyRVYJ+vBVjR KNFoFKfTmTRKkplwiaewpfz5h/0cOnSI48ePYxhGGrEwa9as5F7hQsh4anGKdJBS0tPTw4EDBwiH w7S1tTF9+nQ8Hk/ynHC4i37ppNZVizvOq/sjfjyGF50wAWXgjm89l45VBhFtq7+hrAgRqeN06ETC EaIDJxh0tjC1zp37WkojtktNeZSWyUj3MQIV02j1xZ48Eg5y5PBJZs+dEf87RNfJXqZMm8Lo8ChV 1ZVJ7IUY25risTxbWcpSlrJ8UOf01LwTYvPmzYRCYdauXUNFRUXyuGEYSCnTfGShQOg67+5+l3A4 nPZVlkoxdepUaqqrbcVXY9cZ9gdId9AVfX0D3HPPPezatYu1a9cSiYY5ceIEmqZRX1+fewJQYFpm bFsXBZVeL4NDQ3R3d9PY2IjL6cquvicEAwODPP/8C0gp+drXvkZdfR1PPPEEDz34EA0NDbhcrlij 7WvLM4iB0egIXcOdzFzYQV9/hH3799DW3kptXW0yy8+rWRwYeJOTwRMsnXYb4Z5XeaKzlxOBC3nx wMPMbFiGjBxkbwikNYLX3cGHp13C5qOPc9DfR1P9ZaxrmEc4qFNdXYUROErniMk8TWPvnkPMvKqN Sj3IS5ueYTiiseb2T2HsephDU2/i+vNruP/O+/nM//VpXn38QbYfHqGGQTwXf44l2us89sZRPO5q bvnEx2l2gTV8gF8+1sWfrPbxf//nZr7zrc9z7y9+w/oNK3niiU2MmDozz7uUy8+vhUA3jz/yMCNR N2uuW43L44VgH288/zLvjVSxrGUqFSNDPP+7e3ij1WR643VcurCD4b5Onn38Yfb1mnTMX8Lqi+ey 6/nf8/zJSi6a08KUWotNr7xDVFQwfeo0NqxfXR6tZSlLWcqSRxIT9Z49e4hGo0mnurGxkWPHjtHZ 2QkIHA6DBQsWZM2/CoWyYN7cOdxxxx1Eo1GSi5hRNDQ0pNVZsfmYKScvvsRMqpiJkFh/F41Gee21 1/jJT37CNddcw5/92Z8lnzHlqGeXLRfxHVOCwSAnT56krq4uuW7eTpbbMwD8fj9PPfUUTz/9NN4K L5YZy4RzuVzMmzeXBQvmx9qW5kympK+3j4MHDqGkorKiiv37DuB0OJk5a2bSYOrpepgHhn3Mb1zO ZbXN+ByCR/c/QHP1XBrVEbaHqzm/4QKmudyY1ghB5aLV24hDg+7R4/hNi6aKNioNZ9KKGT5+gD53 OzOa3Ow9cJTwpu/xcNXH+egljXTMmE6lS9DfP0xNbTUyOEIADz6vg74TR/DjocqpU9tQR3Cgi85+ P1X1LTTVVKCUYmigj6q6BoKDPSh3PRUiwFDESbUryuFjJ/HUtNDslbxxz3/y0oy/5k8v8dAwZSq9 XUf4l3/8L+7+7ffxD3RxcjDIY/c+wu2fvJ777/sDG/74dpoaG3CIWOX67hPHkc4qprQ0EI2EGezv w1KCiuo6CA8zMBzEV1uHy+3F49TKg7YsZSlLWQrM6VJKRkdHUUqxe/ce5s+fz+HDh+nr6yMSiaBp GlVVVck5UQKaLVPcZej8/Oc/5+ixY2mTtWVZ/Plf/AXLL744q/5bmoMuZfxWQiBNk40bN7Jt2zaa mpoYGhrmpz+9E1B4vRV87nOfxeupiK1bFymX31KSwcHBJOsvhMAwDEzTpLe3l5bmlvTigICm6fT2 9jAw0MfVK1fS0TGDgwcPYJkWK1asoLW1FbfbjWVZsXQ/TWRF/Hv8Jzlq7WGk4SjbBkOEo2G6K3sZ VOcxjelJneFwF3UNV7PYOMQrXTtZ4mjnqhnX8eGZV2KODnLjvDtoHPk9DwzrfPnCT3HXli+xx2fx eNdB1rReQltlM45oPzvei7Lk/Lmc3HuItulLcIgAfdLHxU6DSNcxZq/6Fo17fsL37nuRW6Mvs9u5 ihuo5ZVNr/Cpz1/O13/8LL/69Q945Mu3sbfxo4T2/g7jos+ypEGgxy0iraKe5x75Acv1Zra+/jZb 9lzGH946QcPoN9jR/DE+tkjxnR//N8u+9yWk38+S62+j9/Fv8Z17q/gjb4CXH/sVvW3N/I8vbmDn ff8f+xrWs3LNdTTM+wyXLnQBUfa+s4XfvdzJv37pIzxy9895yNyAe/9ejLmfYcW8AHfefT8zb/5z /Jsf5ZkXdpYd9LKUpSxlKSJKKYaHh5k6dSozZsxI/r5s2TIAent72blzZyyCrFSS0BZKJHPN+/r6 2LlzJ5FIJOWgK0lLayvnnXceQmmpujtJwlokvXUl7QXpwLSivPnmm9x1111MmzaNpUuXcOTIEQAq KiqoqKiI75eevZzLjJoIEVt35/VWMDw8jFKKmpqanNFXIQTvvvsuL774Aus/sp5169axf99+7rnn Hg4fPszSpUuxrPQ5PJNwGPD3s/fou5x//vk4HAY9h04yGm1PI0EM3UswdJTNx7o4PDiTG1um8dKx p3APHGQG+3khWINfONk8vB2vw8WogiVTbqbFOsSmnnfxmxprZ2+gbnAQr68Wj9PB3r3v0bJsOtbI MU6OWDR4qujZ/yZ/6Anjm7aIT956CXf/8mG+8MVPMLT1SZ4XK1g9rYf7HtiEq7aRwwcG+Oo/fYxf 3/MrQkYl0y+8iuuXz0cpycu/+yWzP/KX7PjVd7HO+xxXON/kNXEJU4e2sO1QN66KBlauXoNuGBx6 axOPdEZpWXApl51Xj9fjpPPw27zy2i5mX3I1U1rrOb77De6559e0L5zD6hvXUG0G2LftNR5/9g08 Da1cevU66q1ufv2L+5h3+QrqGpo58farnOz3U93QzoKrb+XiDld5wJalLGUpSwE5efIk3d3dsblp YID58+dRWVnF4cPvMTAwQH9/PxdddBE+ny++lalE2rZfioQjbNiwIZZVnrFsbf68eXGfPX0OTFKn seh0PCVOyljROClpaGjAsiz8fj9erxe324Ou6wRDIWScp5dSImWMrU8YBZquoemx25uWiUCg6zqW tFKEQDxqoJSMrxMXBEZHCYVCtLW1ceutt/KhD32Iyy67jObmZkzTjD9XvPiNrTHH+45i1Ae5aNU0 mhdozFxWRcM8jbDuT2+wu4M5VR0sq5+NUxiEowGCUT9BUxIxAwTMABElaPG2oISHWj3KsJjKLW0L 2NP7LHfu/j29eg2XXTAXj0Owr8dkar2bcNd+KpqnATrUTGVaXSUzz1/I6EAPLreDSDCCsoYYMXWs 0S7cbbPweTycP28uhgZr/+hzjG7byM9/8lPe7gww1NeL5WhhcUU3P3qhm2/9/Uru+uYPmbfyBo4e P0rX/h289c5x1ly3GinBWT+NWc0+2ubMYrjnBKGAn907d7JoxdU4VQSh6WhCEQmHGB31A4pAfyeS MN7WWUxtrGZqayM9JwdoaGph7sIFDAz6UZrGnHkdNDZNoa2qnAZXlrKUpSzFnHMhBAsWLOD48RPs 378/mcoNsdT17du3s3TpUjweT7KYm5IxR12q2Npx/2ggtlabWGq6EDEffXR0NDZfSwlKxuZfJdMy 05QiNifH52alJL29vfzsrruorq7G5XLx1FNPc+edP+VnP/sZr772KprQkkR9whaQUhIKh+jq7qK7 u5uBgYGkHv+IH7/fH6tJk7QBYqnqoVCYkyc7aWhoZNXKVZhRk5GREaZMmcLq1auZ1t5ONBpNZsUl 221z0vtlJ33VB9kTfo13Ai/jbzjG4fA7DAT6UkQAigFTcG3HWg73vM7hUJSZdZfwqfl/zCdmruOa jk/wsZmr2H/yNepqr+IjzT5+f3Qzjx34LaN6I/Nr5+Fzujlx8F0GA2EgQL/y0eBxcmLvAabMmI7D oTEY9vDpP7mDTXd9hyPDg2x64Q0sqRh9bzs7jozy+I++jn/OWjZcM4MHH34JK3CYR185wkUXLaGp xhuzPYTA4z/AI6++yx+ee5VnHnuCTY89hqV38S/f/jVLll+OceR5fvfacXRNoFW0sf7ma3joB9+g VznoO7qTO3/yC1xzLqdZH+GFF7bSungF11yxkvU3rqEa6Dt6kI2P/JbGFRs4r8XJz370M7p7TrJ/ fw9rb1hHqGsnmw9Z3HDNhRze8Rrv9UXLA7YsZSlLWYpIV1c3LpebOXPmsG7dWnw+H42NDSxbtoy5 c+eiVCzDLOlDJ3xqGZtTNU3jnXfeYdu2bWzfsZ0d23ewfft2tm3bRm9vL5ZK96OllPlT3HVdZ8Pt txOJRNi1axdLly7lQx/6EA6HAyklIyPDyMx90yG57Vlinfio38/AwBBOlzOZEpfJHliWRW1dHa2t rWzZsoUpbW1U19Swe/dutmzezOVXXsnaNWvS2XZbIbsY06DhDw4T7Q9gWia6rtE/3IvpSJ+Aalw+ nLqBJdz4HG4aKmZyaLiHg8OHaXJ7OD5yCM0KcGhgG5uPC06IGazSJYHKBdzka+fHu18gGjzJgT6T ab4QEU8DHsPBnr0nmbp4LuCkyTXKK1u2IPa9yVUr/pi5lU6e376TXVs9hLy16A1LuaDqSTa/uZVX 3tiFulEwGFJcd9sGdj70I451jxLe8gcu+cjHuebK8/iHzW6uvOpq/u3vf8Eff+MiGpo20Lu/juWX LmA4rOMVigrVwxPPvMLI9sOsW/cxGvqC/MU/ruHkxp/zvLqdltoG6msq8bmaGXpvO3v2ttN/eC++ 6QtpDt3Hw8/5ODLq5Jrr5jK68xguEaV16lQ6pk3nxUceZWj/u3SFq8ujtCxlKUtZCkgi/byhoYHF i13s2bObpqYmhBBUVVWxe/duVq1alVYMLW3+VSCVpK21lbVr1ybXRycC24k909PqsCiRqtyanB9l vMCbwiK2w0lzSwsjIyP4/X5qampwOp1omkY0EkUikynxSqb1TqGQAAAgAElEQVTuJC0ZI9yFlpyv BQJN1+JkfiISHsuikwJknIi3LIsRv5+6ulouvvhi5s6dy+DgIM3NzYTD4TRCI0a6pyRsDNN6npP2 Ng+WZdHhnE7n/n66h05S640tsTNlhFm159FevYA2hxuXMAlbcaJdRhiN+glaJi53Kz5d4PM0MhI+ xPKO9bzbu52Hdz/AkNHE2iVXUunQCR5/C29TOw6Hxv4ek4svcHJEWUydMQdvZSMzGjSGLB2HiqB0 nd6hYbQG6BoIMn9OK1XN9cxucCIq5vCpa2fy+CO/od91Phf+z/UMhQSXrL2aH/zLt5h20RcwDj7J swHBv7UO86/dfWx9cyve9uVc0u5CntBonzUPr9fDlFroD4YZ6TnMMfM6PtNRS2SoE13XsKIRQoHR GNaREF0Do0SlYv6CGRg7D1Jl7cCqqKNl1gJchDGx8DZMZUp9HdOmtGLr6LKUpSxlKUseWbLkQrZt 287WrW+xZMmFyfl7eHiYXbt20dzcQn19fWr5mQQpElnpsXkuFAqlFYgFME2TUCiIihdOVanNWXI7 6Ikq6yDYcPvtSCl59tlnueCCC6itrU1tlZ5daQWlRHxy1oiaUYaHhnE4DHy+WKU7u3Oe2DvRsix8 Ph8rVqygu7ube++7j6qqKkZHR5k3bx6LFy8mEonEnxE0jXg6frqMDPvpj/YjpYWmCfp6BolWpTvo V7dfTbWrHl1v4ApNo7WyAYfxDIdGj7F29g3s6j/MUf9JZtYu4cToCB9d+DkWVNfy+rGNvDLczWcX fY52l5NOyyLQf4Ip06ZjODRCzjrmVsSK9nzmf32NwSNvc3LBLXzuuoXoLOT60d+yu6eOf/6fH8Pl rOfzn1rJf919H5rRxvkzaqhwdbPltdfwXfk5blnexOaRBgwhWH7Lp/nmcoFRNZ3/57vfZGmbgbPt C/Dcw7z+xnbmLVtBha+RP/nqVxntPYZr+ce44YqF9ByAG+rmMvXqL7HxuZ10XLaOem87jdqNLHrm JQ511zC1poE5cxfzuU+H2PTmYa792Oc5r1njhHclsl7DqJ7FhUsv4Je/epAjAS9LLzy/PErLUpay lKUEJx3gwIED1NbW0d3dTW9vL83NzdTW1jE4OIjHE8tGQyWc6dQGs5qmsX//fu666y5CoVBakbjm lma++tV/xohfm9i7NatIXCJDLf7T1KlTueOOT3D//ffFCPgNG5g1axZSSsKRCMHRQNZ8DsSK2lXE osDRaJSB/gEiVoSKikoqq6qyCHelFE6nkxkdM9m8eTOPPPIwV1xxBaFQiI0bNxIOh/niF7+Ix+PJ utYu0WiU3lA3Dq+JtCQO3Ukw5EWrTK2ZNoxqKh1uNKDKXYtTr2RGRTXHRvbTWFmLZnZxaPgwwdAR tvW8wfHuIyyuXwWak6Vta/BEOxk1LQ4f3M30GfPYt6+bqYvmIoIniXiacAmBt6aJ3h1beOW5IQZq LmJWdR3LZ/vYtnMX754YobpdZ80NN/DQpudpnRtm/5BChQaomr2c9UsW892fvspo5zu8cszHDRev wHvsqyz92+/gFM/z8PAFtDYvYf3KxcxbtJRaLUhVSyM9nkoOb3uGzVUtqNbLmVdbyUVrPs4dN7bz f372EB+7ZQVNzU14XE6aagXb33mHKi3EsWG4YNEinrnvXjoqA0y5+BpqHDq1NZWAi5amDnxvb+Wp l7rYfaTz/2fvrOPsrK79/exXznt0XOMyMeJChEAgWAgOBVqgQAuFUm8v9/b2d+sGLS2FUqBA8RYr TiCQADHiQtxlknH3Ofba749z5oxkYhRr2c/nk8o5r509797fvdZeey2myaz4EolEclQ6nMgTJozn 3XffxTRNIpEwmqZTWlpGRkYGI0eO7FIxzMXBSWxZS0qpaZqccsopiS1rPa5dWFgAkHSQd5lHXHHr n9yStmzm3z0Xu4vR25HNlWRJleLiYoYMGdKtHqub3EUuuk0OuiaMcxLedkVB07RUGZkO475rCXoX F13XiUQibN26lcbGRgYMGEBRURG6rmOaZvK4hIHe1taG1+ujoCDxw0rri1lzcBGN0WoECggIRyPM GnY+E/pP69bIx6Kh5k1W2UWclj+CtKPkT4lHIygeL5pwCcdMfB5PogRZz+pq7mF7/1nzztNsO9TK oWqb2/73m6RrvT1Xb/Vle7nYR/kidr2j086eret5/e1VBHPymXr2F5g0MI0Tr6orkUgknz/Wr1+P pmm0tbVRWFhIRUUFPp8Pv99PUVERHo+HsrIyNE1HVQRuShEhFo9RWlqa0NAuBnowGKRPnz7Jcpdu ShKemreF1z9QUWoWc/HcM7j+4vHdne6Aqmps376NefPmMWDgAK69piMJneilXHr3D1zXJRwJ09TY RHp6OqFQKFFureu+9+QzIRTisRhr1qxh0aJFGIaBbdtomsa5c+Zw8pQpWJaV8i8IBaLRGH6/n8zM TADe3PYsa6rfIDcnA8dxUBUNvT2XMwdfybDCRHK9SKSEattDnr+AquY9ZPgK8NPAwrI1DM2bQbht N63C4IWdr3NqXn+CaZM5s+8MnOhellSsJa4P4YIB0wlXlhPIK2TLhi2MmzgOt3Y3++3+jOyfQaxi N/vrw2zeuIMZcy9lWH6AeP1+XnxrDUVDBhHsP46T+js8ePudHIzqVNQqPPrnb7PozQVUtgnOvvhy ssN72VQXYvqYfmxd/g59Z5yLVr6NA/EcJg4rwGwu48XX3kFL78fss85AVO9kZ007pQcrOeuyy8mk jR27Shk/YRQHtyynMTgCb1sdI8cMZdcHy9myv5FJU8dhiiyG56ssfms+8cyhnD97Gk31dVTXNDFy VBGx5ireffNF3liwjr4jJzLnq9/j5AKp5hKJRHIsbNtmzZo15Ofn09raiuO45OXlsWfPbqZOnZpa Vd+3bx/BUCjpRE9IpGEY/OIXv6C0tPSwa95yyy1MnDQpsec86XDH7WKgv/Gn83pdle7I/qqqard9 dMdL14lFR1Y40dPb3wVFCHSPByV5PyuZYbbnNcPhCB6PTn5+fqoWuunGsGyLjhupioqm6Cio8s2S SCQSySdKa2srjY2N9O/fP6WFBw4cIC8vLyXmhw4dSoWa99TdjnD2bmaz6x6mxYqAp17fwuubNJSa RVw09wyuv2hcN03vcHDrukZVVRWqppKZkZkMg4fOIm+Hl01NfJrYG2dZJh6vkVz5P/yUzuSviVC+ 8vJy9u7di67rjBo1ivz8/ERUQOcvBQGxWIxAIJAy0FftX8QHpcvxGkYqIiDH34cZQ84mP71PD4f7 0d3Gz+58ntP6n0m/YO5R/loOkaiF19AxY1EUjw9V9ObUP/xebsseHnl+ObGmMvqc9mUumz7kuJ3Y H6/PvfuzNlYfYtWyBWwvizOgaDRfvGg2SJe7RCKRHJOWlhb2799PQ0Mjffv2ob29HUUR1NXVc8op pxBIlqHeu3cvwWAITVVSC9mKUKiorKCtre2w5KgDBw5MllxN5Ijt2NKWMNBbs5l315zDltc/eXqb HBxBSh0Hy7Lx+32puqiJRDqimzSl9sZJJBKJRPIJ4SZFWVEUbNtOfd6x1asjCVttbS1er7ebgX7C ying7/O2Mq/DQD/vDK67cFwyK/vhOquqSrfSaieiwj1LvB3reE3T0HUd1wXTjHdri67OiEgkQjAY TJVwdbCxHBPbcVKZ6jVVRxMe+XJJJBKJ5BPn4MGDZGdnEwqFAGhqaiIcDqcWi+PxGCUlpQQCgcM0 XVXVXnU+EU3mdhNUgThaHfTEQa44Dt9qygF7fJ7YIx/lHtct3OQePUU4tLa2Eg63J3z8QnqBJRKJ RPJvYMC7LqZp4jWMXuuap0Sv6xLrkcTT5TCvfM9SpF0PtiznqFp7rOc+keNN0+xR7/xI8wFBNBql ra0Vks52kfwmcQ+FOBYx1zxiBJ5EIpFIJB8XBQUFOI6TqGACeDweDMMgGo0C0NzcjMdjAIdr+nFF oadyxbqdBrro4QZ3cRGKksogq9C1zGrX/eZu8ksBKMn9Z4lkcR2Hd+xUR7gdJV6P4HZ3ewhyMrQu uebfsb9NJH+4pql4DB1F+fAh7OI4JxlHPvtTnCh8Arf/19rnU26jT+jW4t+1ff4t/gyfj/b518Yg ZB/7t3yHEglVHcdO5XZJfOrikNwe1lH/nGSmc0AonYZrh8OaXgzxwxK/djn+uF3Zx+Mc+FcdFSSS 0no8OvF4nNraul5D+yUSiUQi+aziOA627eDzeRNWtNtT6I5fSF26ZHFvam4iEe12tB3ivUx7us19 UmvzvW1j6x5b7/Y+Zep+ai/PcoS5VudPPtaP7/m9C6mUd6LLvraEk6EjbU8iTb7oMlfpfh3hup3p 8jqaoeM6JH9vKhGP2+ldESKRMV+IXp4x8QwJx0bnM3Y0QMqdIXp7Hrod74rOyV/iETr+CIKu2YHc Lk6SXpvS7c0m6Mwk3IsjqNOMcDsfzk25X3o6fLrcpCPp0GeufVIX7dbhXLo8h0g+Px/iHRJdn6F7 +/T+9h7HBPgwG67LmeJIf6/ux3Rp9U+3fT4DfSxl7NAtp8eHHIOOv4916Z3dWvs/bww6xjskktft +g59pGPQCfQxl9TzJPZzi25/n6O1T9cumNBG0ZmZvRedMwyD+oZ6bKt7mHhaWgjLMhGKr9vvEa7A Vbq0akdTd3t5Uy741HFKSss7/zZu1+HCFbg9W/gIz3zYqyx6fOt2fmsYBqqqHlcyV+mglO0jHbjS gSvfIdk+n34fS6qh62LbDrhOynJNRccpST1OpIJDCCdpwItECdOO5OnJab9j2wkD3SWRQbW3JHES iUQikUg+fRKJU63OPWtJUY9Eoti2g6oZOEA0FqWpqTl1zCfrPOnpwDox50lXl7zobr9DF2eM28M3 gDh8muUe02HQJUqvy7cd7UNXh1eXBYMTaZ8ubrPjdlAeVhXH7ayZw2egfbretJtzqfOPeJgfpmsp wA4nT6enqufvoNvvTTm5khPa3trok3ZQfjba5wh/syO8Q72aFx/6HfqUHbiHtU/3B/702+fj7mOJ xZzOl73nO/SvjUGdY/GxFwHc5GCf+B0d/ek/ZQw6/nfoRMcgVdUwTZOW1tZuDaGqKtnZ2QkDXQAF +fn0tM81TUXtUVRdIpFIJBLJx0NH8jazxyo5QH19PdOnTz/s8/b2dl5atC8V0m5bNrF4FFf63CUS iUQi+YzpPOi6Qzwex+6xNz1RqSzcGeLuuG5qBV0IgSIEu/aWUFvXRFt7RAq9RCKRSCQfM8GAj5zs dIYN6Zsy2Dt02bIsHMdBURTi8TgeTyKjeSAQoL6uHhiYvEaQ/Pz8brqtKAKtI4us9LlLJBKJRPIx W+LguA6W5RxWNaWxsZGioqJURviubN++vWuSuM6whrhpsWT5Jt5fvY3S8hoam9uOkA1WIpFIJBLJ R4FAkJEeoF+fXGZOHc1ZsyZhGHpKozuIxWJs3LiRgoICBg0alDTAlS5zgoTDvUO3NU2lsamVfcUV NDW3ETctaaNLJBKJRPLx2ebomkpGepChg/qQlZmWKjMqhKCuro6RI0emju/qdLcsq4uB3mUCsHj5 Jp54dgGmaaNpCn6fIcPcJZKPosOmkhAe3+f/6nmf5m/6qM+RSD4P40MsbrJ7fxn7istxgfPPntrN +BZCUFZWRnV1NW1tbd1qsnZFESKVDX73vjLeXfoBW3YcoLauiVjclI0tkUgkEsnHiMejkZudwZhR gzn3jMkMH9o3WRxFoCgKjuOgqiqHDh2ivLycCRMm4Pf7EaJLHfSO7LENTa28+PoyXNfF45GlTiSS f8WYTHTEzoQ0HRkdbcvCQaBpWqJ04DGu3/G9bVtYtouqqmjq4fkhuobDflKGcuI3OViWjYuCrik4 jo1tu6iahiJcTMtGCCX1zB3tII10iaR7XxJC4FEUbMfhxXnLmDJhOAV5WanvhBAEAgFmzpyJ4zhH 7kPJJDX1DS08+dwCtu4sxvDoaJqKrkttl0g+rrnBsbXN7ZaM66PW5H/xVx3x2T7uuYRE8p84RjQ0 trBw8XoqKuv43tcvJy8nI9VXOvabHzhwgObmZkpLSxkxYgTQUWZNdGaa272vlMamVjweXbasREJn mQTXsWhri4BQCAR9CFzC7WFsB7x+P7oqiEejxCwbw+vD0FSEIkhleExeR1FVCvoU4lVilB0sJ64k SgtBorRCNBrBcsDr9aEpLrFolLjloHl95Bfk0i9dp6amjor6dmzLxlEUfF4fqiK6CaRtmUQjUeKW RUfuSVXT8Xq9yQm6+GgE1XVxdR9DB2biMdvYV1pHenYB+Vk+qkpKaLYMhg0pxI20cKi6GVdoiCMk n5QiL5EkUBWF5uZ2du8rIy8nE01TaGtro7KyEk3TEmOJohCJRAiHw4eNWR1OwSUrNrF91yH8Pq9s VImcMP+LGtP1/I5M2I7jYNpO0nF+PA7oZBZo18EyLVAUVFVDEfxLTvePQj/dZHZw27KxHQdV01NO doSCrio4to3tuKi6htJtzJFIJD21WFVVAn6V7bsPsfj9TVxx8SyU5BxYURRc12XMmDEoioJpmqnz uu1BRwgqqxpSxoJEIqFjGRzhzeHGqyZBazlPv7ga1Z/BJddeRqYTYcWCNzgUDjD+lFmM7+9l48rF bC2PYRhGMrGTi1AUVEXgC4aYc+kVDPGU8Kdf3k2jmofP50dVBEYgxLTTZ9HX28qKpUspj6Yz7cyz GFegsHXXAayMIm46oy9vvPw6Fa0258w9HX9bKUuXraFZycDvNcB1sW2bjPw+TBw3nH5ZRmIQcEwa KktYu3Ev5Q1hVE3HRUHTVITrYtkJAdZUFUgKtOuk6jurydV+27a7JJ9KlDwR6f259NIzyW7cxa8f eYuRk2ZyzXlFPH3H7SxtzuOG6y7D2beK3/xjGXHXQAgVJ1nCQ1U7qkUgV9Ylkq5GuqZSWd2QqFSu KFiWRXt7e6p/dIr54ecqQmDh8v7qral97BKJnDCLlNEbi4aJxS10w4fPo2LF47TH4iiqTshv4Dg2 be1RhKoR9BvJCBal6+QAVyh4Q2mMzPfTWFtLeUMEj+5JGe+mGScciaHqOgGfB8u0CEeiIBQysjIZ OmQghJupKK+kNQ4x08HwevB6dLo50V2HWCxGJBrDdR2SgwKG4cUwPIc56D98+4BtO2QXFJCb4aWu 5CC1UZ2iIYUosVYOlNeTkdeX/EyDyoMltMZBqNpRpk7dS3VJJJ9XvIaH5Wu3cdkFp2IYCQO9oqIC NZm8tSPcvbq6mtbW1p5J4gSmZcm+JJEcpjQAChdfdzn9qeLd5+ZRl3YS//21S/EC+qElPLQywsU3 fJnzh8b54eLniEYDoHoYOnQAaYagqb6OfcUV+NMyGDx8BON8LgHFYtTIAdjhdvYXV5KeV8Ccy7/A aRkllG16C234Wfzo+9dgVK5l49p1tCu5NDb5aGqP0G/4CG6+5SqCVVtxGw6yrsqhvjGG5vFgWSZZ ffrzxeu+xEnpjWzZsoe0PkUMyPXxxD338uSbm8jpP4Isr0tpRS1x1c+Qwmyc9gYqa5pos3T69ckl O81DPGaheXQaqypox0dhfhaGJpLJLgTRlkb2t4dpaW5GNDbR3tZMVsEAJo4q4k2lnZitMm7sKCxz O3a0FT0tnQH9CvAbCrYVo7q0jNqwwOPxpLyK0kiXSBJSbFpWygD3+/3k5uam9qS3tbUd0UAXQiAQ VNc2yoaUSHph4szTmTAwwKZVi9h4MEr/0ROYM6EfjYe28+x7e0jPHcit155MtPoAz762AU8whIOL ZdkgElURUDVyBo3mv64dx7svvcD988vIyMxB03UQKgWDhnHBrCEc3L6FV5fuZeCwUVx/zmSaS/ex +1AjZ112CUbpOh59fC8DRk7lvCl9WLdiLSv31JGelo6qJgz9mONh7OTRnDymH8IFTYFYuJVtW7ax fW8VUSth0Cuqhqoq2JaF7bipcsmObWPZTodbATq2oyVXwzsnOgLbshg5ZRoXzhjMwof+zIKqDK67 9lK0knX8/OH5jJl6DV88awCP//q3bGh3cB1fwuHuglASTv/OaACp5xJJh07X1DYmelmyP0QikS5b WG1s20YIQTQa7ZEkDhmmIpH02qtcF6utkreXl3PTzFzGF3nYOWQEXsCKW0yZfBL3LNnC2MEaDXuW 8876cnzDpnP1tRczul+ApuYwOZkB1rz7Nm+uqyYatQgU5HHjbd8np2gEkapiXnrhJdZVNxFub6fF MOk3YgwXX3ohWuUGfvqLu3hjc5zzLp+E39ARhp+Cvn3INcDOyOW8i2bjLP2A1xYXE9R1BGCZJrGY Rcn2dTz2wN/pf8b1fO+6cwgaDjFXZ/acs5mR08q9j7xMbTCXL159KZGdC3j4lSqmzDyNL154Cula nGjMJi0zk/kP3sOWeA4XXXQmBQGBMPykp2dSvOJV7pxXjuEx0FVwrDimaWIB8VgEy4wRN02sWIxo pJXpF5zNF2b0IRaLk5mZQUvNIZ567J8caHYQHl/KuJBIJImVcEFn2GzXUi2u6/Y6+e26X900bbnn XCLpxfuVNmQMt1w/mSXubt7f9gEz517CTecOJFJayD9fW0HG9PO55dpL2Lf4Hzz8jyaCuoeM3AKG 9MvEjrZTdqiU8oiLEcpmxNgi9izSyO5bwPDCLCpKy6iKBhg3aCRfveYi1rxWy8tLi7nuli9z5YxC nr9vC+tammiqr0drqMPx+Dh97nnceNFwBvgsqsKriUbitJl6whh3dCZOm87XLp1EZfFODjYJxowa QsOWAn5777PsavEybGhfWmuqqKxtJ69fIXkZKqWlNdTUtZKWk8vggixUOwaqimpG2FfWSEH/QjJD XrATkX6KJti3Yy9tjY00NoRoamkibBcyZvRINPZgRprJyu/P+JFFhNxWzJhK36KBZKcHUIVNuLmR fYdqUA0fiqJJPZdIuuiyadqpaFGAnJyclFbH43Hi8TgAdXV1PZLEJaYBshUlkt46l6qyfOVmbp41 h8kTTyIwbAK0F7Nyl5dJU2cwZHAb/RWHlWtX0aCFuPiMM/nGNeewZ9UCytqjzDz7bCYODLFjy28w HYFjxSjZs4W9LYKbrp2Lblax/g8LMS2bzPwBfOHLN1OQAY/8/gleWbaP7GGn0HfQCKafOpC1Sxaz 6OBBqlpdjOoylix8l62Hol22p7i4bsJIzx88lqtvvJnM/idhtVRw4FAJDabOgEGDGV9Yi5cw6Doj TxpBY90i8vv146orL2RKdi1PPv0mgWGzufbk/mzNUHn/g70sedelYNAorr/2YvqFWlj81B6aomlM nXYyWSXNeDQOL8vodo4zFcX72JYRxuvzkN5vCGedN5rSdfPZu7geRTd6hBBKJJIPJcviXzhXIvkP x3VdVi9eQez6yYwcM4x4+2qmTxyQ+DJzCBMKTTJGDYF4hIVvvo2pCkZOmcFVcyeghBvBn4lZc5An n19Ae3sYMBh9xvn8dLLCwNwA65cv5aF/LKI9HAHCKL4AF37xKs6bkMvLD97NHx+ZR7DoFEL+IJYq yMxMZ8jQvuA6DJs0mYta2lm0eCWNYYFm6LiOQzRmAk0sevMlXt/uctsPv8OIkBc31kyfoknc9LWL +OCVv/PUq+VMvvpyrpqRyT13PUErfbjqSxcyc0w+4dZ2NK8PtWwrP3lgIZNPncxpYwZixkyCgSB5 WQ6/uO12sARpaUFcy8Qy48RNEycexzRjmHETB4jHw0S0IXz9pkvwWDFcPUC6brFh6QKeXLAL9ACK 3DIrkfTQ5c4cFo7jpPahd/zrQOlq2QtFSDGXSI6Aoqjs3biJBlSmzjqX2RMHsG/1Eh5fsJ5gv/F8 6/rTsaJRVry/mlBmNuOnTEKzIhzYt4e62hpWLFnBis0HCfoT3rLG2nIe/O3t3P/o8+xzILvPQDKt FizXRRUKhtCIa34KBw5iUEE6DkoirDxuEmutp/zQQcqaTBorDjH/1bfZuLcew+/rTGBDYt9qW1Mt u7ZuYOGytRyodznztOmMHpxHOBwlHo0Qbm+hvb2daCxOONxO/wH96Jefzcb3XuWBe+/lxfc2UxMF 17Wo2reVt5bvxPVnELBrePKuP/DY6+tpiTrYlkU8FsO2TXCdXtvQcTUyM71k5ReQptkcKKvABjIz DUwzcrhhL5F83vU86V1XFHFi53xUSSAlkv/QeXK0Yg+bqm2yR05k+OAixuYKVixZgeLN4NSTRzF2 7HCi0XqWrdxJRk5/br71S5w/pQ/1dXU4WhoXXfkFrjujiLa2RJLGtsZKVi5fQa2awxWXncfUoQHa w+2An1Enn8UPbjqPyo1L+OtD/6TGCpKX34eJ08Zx8rghtFaVsm9fCdhRdm9YzcKl66ltsVC7dmHX BtI55eyL+c5NX+CkPgH2Fx+gpKKaUEY2o0/qT2G6SrS1mbw+hRSN7I/mwszZp3LjF6bTsHcNL765 En92AeNG9MWvtLNpzVqef/kdWkWQSeOGEyvbRWV1FXkDhjPr5PH0TdNRHKvTyd75PxAI7GgzG9Zv Z8/+Q1RWNzBsymRuvuFMDLM1MReQSCSHjT3Ho81Kz0mAXEGXSI486XUbSlh3IEr+uBmMyRG8/95i Nqxbi4PBnDMnE20vY+m6QxheHzW1zaAZBAIedm3dyqJF77F25yHaIonreYwAIydO4eSTp1CgQLSh lgYTVFWjqeog/3jwLuZvrOeSG2/hpi+chhKuw7SdRNUFRUHXdXRFkJaVyfDRI8jLzuiqnYldZppO Xfle5r/yT+YtWUdYz2bq5PH0yQ4Qj8fx5xdw0rixTB49iMyggeu6NEfCxOJx8gcOY8qMWUw+aSBB b6LEmzd7AF/75s389w2z2LPyHeYt3UkwKxe/3995025GdtcHcoiJHL7xna9w9dwi1i5dxLaD9Thu 4tqObUkDXSI5opGufIhzpJ5LJF3p3BIi0ESUJev3owVyKZ4AACAASURBVKcN5hu3XoARb+Of99/H 3ojBGXOvYOrwdJoPbGRjlUpazmBmDgpRV17CgbJaDu3eysrly2mIgcABq43N77zKb+99kufe24zh CzC4Xz6xaELwherHbm0jMy+PEWNHoruJqboZB8uyqKmoYt/eQ2CF2b52BW8t20xj1EDrtj1FAFFK D+5hwby3WPnBTgonn86MSWMIOhFiDkTCbbS3NhOJxoAYYdvHyEH5aJTx1ONPcudfXmBXaS04Fiph Fi1YxoF6k4I+Oexc9RY/+/WD7K5uxwZMwDTjOI6N29PCSLZlZlYQf1o6/QpzidSWUdFsQkYaSqwN x5IGukRyJG0+lj4fliRO2ucSSe+C7roumuawYt0+5gwZg1dtYemKnbi2y/YwjPX7aD+wiV0tXrKy BKvffZtlI4KMmn4u12efhOINEG6spWTVKnx+hez+RXzrZ78ib/gYROkOnnt+HpFANmnBEH5fDXu2 rmR+SQYTR/6Ym777DeriTxPGhVCQgM9HU2MTu/fsZ8aZp/LjXwmefW0Zz7+9l2B6Oq4LqqZheBRG nDKX2+8dgevPIy+tnXkvLGbLpk3kjJqCPWcut37raxQ32PQJQnVaiJIdy3l3+TpuvOA8fvKzYTTb GfgBMxZj1NQzueHyWRhA4bDJ/OS3k6nftpJfz2/F5/cTCvpQNQ2P148GeD2eREbckIEV8KOLOLv3 VzIpJ4vps2YSzstDF+D3eVEUTQ4/Esnhan7Cxrb4EOdIJJ+XyXEHiqqzZuVGuGA45549jUjZZlZs 2sXoTZXcMvMUYlaMxSuXEzGCCDtKHeBLzyBed5ANpWUcOpiD3wojFAVUnaw+Q5g6CaaNHoxjWtRW ViCMgYDF9pWv8/iiZu688zv81/dupPGX91Hf0paacyuqguHRwBskf+AghvarJRTQMR26bFdRgHa2 bVjB0//cRMbISZw7Yxxjh/VjbU0U04Qhw4qYdVYLAwsywXHAbqc1ZgKZjB0/kXM9KgVZaWCXE4s7 TDt3Lj/70TcZ5a3i7hdfp8YJkZaWqDjj0pFQLjUZSv534r8sM864087ju1+9hNUv/pmnlh1g3MVX gp+Ew92x5QsnkRxBn4+F1usJchFLIulV0IWisvqtl/hd6TIi7bXsaEnDm27x59sfZHAgQs3eLXiz 8vFoHuqKd/LHPz/G+GF9yPBrOGacytJSDjSbvPDIg6xJN4nEbYJrP+DQvr2s/aAMPXsgLz/5MMvV Rg62pFFTv4Of/+JPTBzgoaS6jvI98/l9wxo272lGicV47dmnKd08gJAW5kBJDcnkzmi6h9qSfTxy 3/3kBTtC3m2aaivYuHkXDS1RVi5+j/+tOUC2J0ZtQwsvBdNpqdhNRVkTm9au5plIBSIWZtik01GB pjhUle7i3rsewKfGE4a4x0OkohizoYW//PkBjNZSYgTYsOR1bq9cxvpqB82q5s4/PIhdvRfhtvPk Q0+y8/1+ZPhcKra9xaH1yzm4vQKhGdKgkEh6jj98uNVwaaBLJMfqIwrV27dTC+RqIYo3rKROS2P1 ms3cctp5GJ4YK1ZsIBgMEW2u5IEn3uXG8ydwzXXXUNfu4nEttixbhmZ5QfiYOvcK/ny6ysih+Sye 9ywLN1cw7Ox0QMNuq+LVl9/mpOmn8J3Lz+F/vtPAM+8dQjfAGwxgYFJZlkgsd/mN38CbN4DX31rM rhqBz9BxEclyiTlce8ttnHJJmP4DCinbs5alG7axKzaQAwebOO3Sqwj0G0XOsL6gtJBmxHj3nWWc Ov0kbvjW95i0s5JBeSHccouomsdXr7ucyQNCEI1zyQ3f5IqAhwd/fgcBj46HpJNd0wmFfOhBH6qq Yvj8KIDPMCitLKOqHfoMH8+ZM4Pk5HhBC6BpWu/lJSQSaVN8iBV0uWdNIjkqilBoObSPJ7aux7Ed 0rP64tF1Nix6l2WRdjSPl4yMbFTNg6pqVBUfZN+WLcTNGALweP34/AFWLlrAolgc1zZxhcDj8RFK 64viuKxetIioaeIP5BIwVLavW826ZRF0XUdTBbt22fh8AdKDAcqLi9m9dRO2ZeMLBAmF0hN7zzWN ltpq3t2/m3C4Dcc2E2VhdINgKJ2MvBxa62p5+419xOMxBInkFLrXj6vkMGrUcMaN7k88EmdwnxDb V81nzYEG9hxsYef+g5jxKK6TKAfh8YUI+gzenP8eDgrBQAbF2zewY0MUwxfAq7Xx8msLcVEI+jOp P7SfF3duwTJNFAG24+ANhAgFQzJBnETSi4l+otosV9AlkuPrJ264kl/f/jBZdisHt64nlJHFntWL uOOPxbS1NLDmgEMwlIbjWLz1zxeo3LGR/vkhVBwiTY3s2rmfeqeB3/2xhra2drw+L6+21LNt81Ya rAA1+7fw+7vrKdm5n6Dfw0tPPUndgY1YDWWUlVTx4F1/RW89SDyYxcHtm/j5L/7CkHw/zbVl1DbH UYQBCLxqjOXvvE39vjW4pommKZjRdg7s2smO4iZiusrf7ruPJf2zaKmpxNYXkhVw2FHWSoN6iNee e5l+mRqWkcfwCR6aw20IIix88UV2LgtgmjYeXcPn1ylvjlH+3qv8qmw5m8vjaPEa/vCH+xH1xdhq kNXvvMBv9gfZ0qRRWrOaX/8mSr/cNMzmah64/W7SlRZahRdV0+VLJpEcPvCcmIGuCAVFkUvnEklv uG5HoQOBN5BGfiCU+lAIQVqWQch1EzkcUp1PxR/MwBdIS+yt7tj7JgQBf1oidMx1E3vKURJJGhGk eQzSEuVIEwawESAtw0kFtqTRWV9UM3z4g4nrJx5PgWQ4vm74yMw2yMjKxaXz2ZTkMbrHwPAFwHW7 JlknFnPZvnUXscYqNCfOuwsWsmvbNoprTULZhXg83kSbJM/quK4/1OUiBAmmk4rGMfxp3QYnfygj 1SYgkmUnlNSAlfz5Esnne9zBRYhEsscTM7a7TACkrEskPfQ8qcWui6YqLJ23gEg0guH1EwplYDdV 8dRzu3Bsi1B6H/yGD0XTceNRVi5fSzTSjuPYqKqOLxBCU0p44rldOFYc13FQNB1fII3snACN1WU8 +cxOVE0nt6CASEsjLzw/D9d18Xg82PveBlUnmFYA0Qhrlq1gcaQdTdUJpmXg8yX02lAs9mzfwYZV TZhmDFwHoah4/UECwTxCqsb2TdtYu6IN13VwXQeEhmEYDJ8ylPFjRlKYpqCn5yNaS3jmzfdpaKhh 39ImbNvENhPlnZTkfUXjZrZtNjF8frx6hDfeXISDIOjPZP/W9WxbF8PrD2JoghVLVxGNRhOOfscG 1UN6egaGNNAlkl4dgycW4q4IhKtg2y6RaAxFkStZEsmRJr89p9G9f9Z1stw5MejeUTs+t49yraNP 4ZMWfvKWdi8T9S7TfdcFnC7PJ1LP0XFn13XYsGoDS9uaMeNREAKfP0QgEEK4GjHT7RG55n6o5G7d n4sezyWRSCzLxrKdZBZ35YT6ljhho14i+fxMkDvUU9F0MrLzyUg6i1ESqZLzjGDiiGSCRiEEusdH ZpY3YQDT4VxOXMsfzErqYPdzNN0g1x9M6a3HAK8/1E0zU5VXhMDj85PuJBzynRN5F4RCIJiOL7k4 0OF07+zngpBuEEzL6uI8B8dxaK2vZenydWQHVexYmNqqMjZtPUBMSSM7NyMxtrh0c+QLINRlYmD4 ujjZuzrghcDrC3VpE7otVEgkku4oinJcTvduIe6KEIwYks+1l58qO5ZE8jnFTWZiT3jhkyv8yclG tzwVcoiQSD5WHMdlxLBCVPXEV9AVJTF5j8RMTEsma5JIjtZfuihgL59Zxzj2MBWlN0f4scXzWM7+ zmslAgBcEk559wjPl/h/7RXlvLlnJ5FIO45toekGgVA6Pq8f0wSE22MR4UQc5Ud7Zulwl0i6EouZ Hz5JXGF+OkMGzpAdSyKRE5YjiLFEIvmk+mEkEj3hEHeR3B6jqgpXXXAyPr9f9l2J5PNKcsXddQ5f 4ZdIJJ+Umgva2tvx6NqHK7PmOC6a7pEtKZFIJBLJp4wTjpx4wrfk8aqicOq0k8jLz5P2uUQikUgk n5aBLgTV1dVomvrhVtA76j1LJBKJRCL5bAj7Ca2gdz1HKGiadLpLJBKJRPJp6jhdtoueQBZ3gSPD XSQSiUQi+cwZ5x+2zJrrutLpLpFIJBLJp0xHBYnj0fMuaWFl3VSJRCKRSP6TDHuJRCKRSCSfLW0+ lj4nDHSZkVkikUgkkn9bMe95jkQikUgkkn9PNETCTO8IcZfCLpH0nO2qeA0dAMuMYVpOt37SEbKi ewxUReA6NrFYHDdZS/TYJOqAK4qKx/DgOjbxWDxRkfQj6I6JUmkKuqahaWq3+zqOg2VZOI6D68qJ vUTyWTbSj4n6Ic6RSCQSiUTyier5cexB76hzLMVcIunNuHXaSnj1ra0IoVA0/lSKCvw4JIJOOoxz x3HZumo+B2osvKECzjh9IortHG93RVGgtbGKDSvXomf35+QZk9Ed6yMaDBRUp40dm3ey52ANmqqk HA+hrHzGjBlDQWaAWCyC7bhyHJBIPqNiftS+KTr/fZhVd4nk86DnQgg03UBTBa5rE4t2d6YnHNoC RVExPDqu62KbcUzbOe7+1HEfVfOgqwLTjGOdwPnHc31V1dB0HUX0mK/YFpZl47hSyyWSz7KmHwut I7ZdirlE0jtm7SZ+9evbEYpC0Rk38sydNxOPmh3FhgGHWN12fnLb/1Fm+sgdcgannTMVJRI77nso qqCmbBd33vY9gtOv4G+zTsWIteJ8JKOBim7V896bz/LwM4tRhEPMtBCKiuELkNdnEBddfRNXXzSb 3KBK3HLkWCCRfMaMiuPqk+7hRrpEIumcGLuuy7Y1b3OgOorqLeS8OZNxYxapcDUhEK5DvKGU15dv xjC8DB49jRF9Qzju8d5HwY6FKd66ll1V7Qw/aTzD++dgOx+JoqNqOrXle9m5axfNYVBEYpzQPAEG FI3ipGED8AqLWMxMDAlyHJBIPnMG+nFncZdJ4iSSI8x5zTaqq6rwClj++uO8d/N1nDFAw05OnG3L ZumrT7CxtA4NiPvqU2LvprzYAkVVUkLq2E43D7fruKTn9OPyG2/GM3A8hh3vUbbYTYagKyiqgnAT 4enH5SUXAsW1aKgpp8X285VbvsoZ44bS3t7Kwd0f8MKLr/Knn/8vLn/g+ivOJU01UyvpQigoSscz Ju7n9nZP18VFoKqJEhJHPTbVLkrieMC2bdxu7SWRSPiwk2tpoEskRxB0l/de/gtPL6pCNTIxBr3I mUN82AkBQgiBZVm8/fe7+cVTy0nPyObLP7yf0QPSiVvHZ2ALRcEKN7L8lUf404JDfOdHtzN2aD7h 6EdjoGu6h5Lda3j0vvvZtK8d24phI1BVD6H0DEZOns03vnEzU0cPwInHZJopieTf2kCXvVciOZLa AnDyeRez753XefCxlzjnjmuxoxbgYoUP8fiTb1E061L0Da9SqSipiYBQFLzeADhhKssraA3H8AfS ySssJKQ5tIcjOC7YNmQXDOHmH/0EgYNlRnFIeMoDwSCuFSNugYJJTWUFUbzkF+ThwyISS6zmH60L uyLZxTNyGD9tJhfMnkRbOELs7HOYOLCQn99xDy/Me5MZU8YwdXg+iubBayg01ddSU9eA42pk5xeS nR7AikeJW1bSYQCuC5rHS8CrUlNeRm1blNzCfmQFA3h0DTMWJhyJ4yRLPQlFxR/wQ7yZkpJKImj0 HzCQoC4Ih6OJslAf0f57ieQ/SdCP1zoXUtAlkiPS3FBJdXUdHqWaB/72Eufc9RXsjqg4XMyWvTz0 xGs0NSm0tUdpiZhJPXJTuVqEoqCkHPEOju2kdMt1HVRvkDEzz+MrOY2MG9YH07J7+Am6O8Fdx0nk gjkO7RNCIR5ppeRABQOnXsb1X7qMbKI0NlSy5M0XeeetpyhvjvO7//s200b1IRq3Eka6oqAIBaEI 6HjmI+itm5y/qIoCuNjJY3uda7gurhCoioJQFHAcbOcox0skkmOWPz1sBV0ikfRO1sCpXH9BMX94 7UHe/8aVTC9QsEybDfOeZlOdl9/+5Tqeu+7V1Mq3EAqRtiaeued7PPXmTmLxKKZlo2oeMnP6cNbF X+Tmr16Fzw4jVI3K/du495c/xx15Ib/71ddRYibFW1fzlzv+gG/chVw01c9DD/6dvRWNCEVn4OgZ fOXmW5g7bQjhcJxjW7QCXHDsZGI418UIZHLa7OmMenUArx88RG1jIz7fUNa88yQPPfYc2/bVEjdN XAS6x8vQMdP5xne/zYRhhShOwkj3BkIUr32LBx/9O2u37aM9ZqJ7M5gyYTglBw8x+bybufVLZ5Lm 13GFiuE28cQfb+eFt5ZS09CCjUIgLYfTL76O2269Eq+wEa70+UskXQ30j9eol0g+PyiKCuRx5cV9 eebNR1j27S8xs6+WcJZbFitf/wc7m4JccdE0Xlm4ujPSjcS+8oBfp7G2itr6JixHISu3gPzcDOKR dmKmDa6L6ktj0jlXcPIcBdu2iJs2QlHxeH34dIVYLIZQVSItDZTWNJOWk0tuZohYezgVnXf0Dq7g OtB36EhmnTOXvqKdaDzOOWfNJOcnP+bxt59l2dzTGTVyAIZw8Qf9WNE2aqsraW6LYPjT6Nu3Dx7V JRqNYjudHnchEk50J9pMSUUVrhZiYL98PLoHVXFobWlLGOwdhkSHg76yjJr6VvxZeQzsk4sZiRC3 bBkZJ5H0os0nEOIuBV0iOSqqjytuvZWHXvsWf330FWb98iri7ZU89tjLDDvny8wZkcM/7O72sG2Z VFdVkN1/KMOHDiIz5CXSXMPW9Sv465/uosHy8/tvzSVmOkTbW9iyZgOOMxo0FcW0ibQ2s3Ptenas 3MHi1zPI6z+c6dOHU7ZvO8vnP4OJRkHhTxlboGLax7lBLimrbjIE3bUcXNsFTUNTEx7w+ppK4q7K qEkzGNg3D49iU3VgM+8sfpn/rne4//bvM3ZwHq7qpWT1P/nxL+9i2Y5GTp99JqMG59PSUMPuzWvY sLucwIgqLNsBoRBQmvnZD77D84t3Mu2M87hg/HA8bpiNy+bxj/t+Q6Pr5c5b5qCoamqFXiKRxvmJ npT4D6nnEsmR7FuDS2/5JgtfvYn7H32R2b/5MtGYiRUp44nH32TU3Ks5a0QTL76VcrmjuCZVO9/j 27f9kfpwlHgsjuMKDH+QorHT+Oqt3+bMsQVE4i5uez1LX3mcv75XzE3f+T8unD6QSF0Zrz/0MM9u auGyiy+hYt2LvLb4A8KWiy8tjzmXXcNNX/ki2ZqJ5Ryfz51kYjhb2AhFI2/AeKZNH8Nrb6/hQFU9 TXGNIqWEP/78L7z2zmrCsTimaaGoGsHMAs6/+mZuuPQMMgOeRCI7RcfrNPP0fX/k+XmLqKhrwkWh YNBY+gZaKK4N8cf7f8OwwmxwHIxAkP0rX+ee+x9j075SwlETzeOl79CJfOdHP+K0EXk4CGmkSyQ9 NP2EDHSJRHK0TgXZRbO46swinnjpQdbcfDnKqhdYXuLyu3u+hsdp6r5v3HXxBjP48vf+yLWeNDLS Qhi6hsClZM9Gfvzt61g671WqvnEp2SKSKNWmg50shdaR3EVRIX/IOL77wx8wc+QAfD4vkaqdPPrn O3hi/SrWbdvB5P6TMO34sQ1zRUH3GHh9XlxVx687vPjuUlat3cf4ubfQp7AfkXAbE06/iqJpl+MP phP0+9BUgaoIHr/jVn77tzfYWnwVw4f0JYNqHn7wMZZtaeT//e5OLjh9CiFvYn9+zcpnuea//5gI exOg6QZLn3+IZ97ezLfueIArZk8kO82PcB2uuPILBL91Bc/+7SFuvvZshqepCCFX0SWSDzVWyX4j kRyTrEGncM35I7n/5b+x8tYvMSnLZtP851lXpfKHB27Es/T3PSTUwQzXU2/6mDR9Kn3yctGESdn+ XSxZ+Dx3VNcTuPcBJucLYlacupK9rN2wjYuaoyiKgmvGqC8vZvmCJWxes5zMzEzGjJ+Gz21i/arV PHD/Q3jTcvjvG87FDkeOW//cjn+uA6qCYzk4gFdX0VUFEW+huqmN9MKhzBg5jMw0H/H2Rla8u4CH f/u/CO8D3HDhKaR5FAJ6mD/9/Cc8+OTrhEaczOw5p5GmWZQc2seq5SupD+fRFjMBUD1+dr/zN779 f3cTzRjN3Mu/zICCNBpKdvHccy9z27fKefgfTzAmz5faDiCRSI4PaaBLJMeLC0L1c903b+apK/6X e+9/lKzNz9LvlCu4cEIe0frG7oe7Lprmod+gEZRtW8kLr6xl7/4D1DQ00tTcxO7yCMF+9dREXHK9 R76p5cKAoilcfuEZGJEINgJv1mjGTZqAu3gBVXV1KB373o82aVc1aCrh/QXziB/aSGtTIzs2b+C9 d98lnDeGay8/n5GFQeJxk+zCwYQaSlm1YhHrPtjKofJymsMxyg5sIW63UheOYio6VZtXsmLTHkbN vppzZ82gf0Eatu2g6F78/QrQNRU3maJG0+K8/fIbRL25OPXFLH2nCje5507TdUw9Hat5C1sqwhSF PKhS0CUSiUTyMSE0H1/6+td5eP4P+Ovjr/DE/5zBE48+z+DTr2bOSTksXdw9qZsrdPJGzOHxR2aR nZ2B3+dDVRWstloWv3APt9w+n2UrNjL9i1OJCYGiaui61mmcCpHQaiXIGZddxzevu4TskA+PLli9 4Hl+8eM7WbN6BeVXX0CuiHLMoDgXFE3D6/XhEw7C46dp7wreW7qSJvIYPag/OZ44bXZ/bv3e/0Oo BunpIQyPjhAK3756Flfe8F8sWLiEC045idxBhayf/wTPvTKPvmdcz8+/fwMj+ucgcHCx+dN3r+Cp ZfFkgI6K1yzmjjseIDbgLO7/zQ8o6p+PoatY8RjnzxjC3Ot+xVMvLeWOr5+LoiryhZNIpIEukXxM gi4EeSedy+Uz7+OZf95HyHX44ZO34hMW0Z7HKgqxcBP/+O2PufeVFbTGYOiwYRTm5ZCVmUWaz8By HWz3GCteAlTNg0clsXdcKLiGB90XAtvGtu3jenZF1aC9mhcfu58Xk8luvKFsJp95Dddfdw2nTRqB cC10f4CtC/7O3Q/8jSVbDpGZW8DAAf3Iy84hKy0E1GI7Loqism9/CU2t7cwYM5GA34dj2ziOC46d zMzeGR6oWvXsKG7Dbo/z0tNPoCqiM+JACMxoO2mhIMQdkHlnJRKJRPIxkzNsNl86fTBPP/sAj2WV sKzY5Fd3fg2vY9I9h5MLQsGXlstQTyML357P5m07OFRaQWNbC/WVB1E8ClX11Ud1mDu2jZHTh5mz L2TiqMFEkiHhI0eNYdggH3WNddS02uQHOKaBrnngwOa1PP/EQ6Q7EapKi1nx/mI27CzhnOv+h9nT JyLMOLYWpGhQGjs2refl11exa89+KusbibbXcqCikVBhPbF4HI8hWDL/bQ41pnHnV65g0tgiNNfG dcEfCpId9ACJSD1F0yhe8i4biqsZPjSdTWveZ/v6RNJYhIJmt+FXXFZv2YDjnA3SQJdIpIEukXyc qJ4gN916I89c90t8U67miml9sXqGlwuBGw+z+72n+O2TCxkw6Xzu++m3KUz3YRheWutLufenG1nT 4Ca2kR3rpq6bMHaTGVET4e8KJyJ5jhmH7KH8123fZe6UEUTjNrphkJaeRVZmGrqqgKITK17FQ48+ xjvbW/nWbb/iwjNPJujVCYYyeO8fv2L71gPJ/WQQjcdxHPDoHkQy2/0R99UocaKmjeh7Mnfe9QMy Qv5uWSw7zsspTEdKuUQikUg+XgSKJ8AN37iJJ7/0E+7+61MUnnIll0wuwAw3HXYsjkXxuvf4n//3 K7aX1uHN7suoIf3JSM9Ct1vZXV6eSPB2NCnHTaysewwcy8K2bYRtoWoGPn8ajmPj2M5xuac9hmDn yoXsXrUQ1wVF1ekzeDTf/un3uOKis+mXYeCgoLZXcNftd/P3l96k3jIYNGgQfQvyKcjPJ2DsTpRE RaC5jew+UA9pQykqyEIXLnZyM7xt293qwKuKwp7dh7BQ2LNhIY/tXNJtz7wQLmpGBgGPR7raJRJp oEskHy8d+8L7T76Ev9whSBt9Jj5hYTuHSTmxWIzVy1dhekJc//2fMHN8PrbtIBQVQ0Twe7Vjllk4 1tOciPC5rgNGgH6Dixg/bjzt0Vjqc8dJ1FX3GBpbd+xk2849TL/w+1x66SWMyDewbAevP43M9EBq 5dtxXXLTghgelbraKmwzDsLAdRwEAk3TuhjrLo6Wy+Bclc179qD3HUpRfghcp1ur6R4dMxrBPkoN dYlEIpFIPgpFF0KhYMxcvjD5Hl7Y0Mj3br0VH71ExAlBa1M19/ziR2wuVfj6T//CF04dgUf3YKhx dq58gUWrHzsRQU5dt2PO0HWf9vHMDKJhl1Muv4lv3vxlcongKho+X4DM7GwCPg+4LobPw2uPPsLj T/yTvrOv5Vdf+xIj+mah6V7Snf3cuHsHe1JReHFilgOaBxWOWU0l5liYMYtLb/4l1546AI/a/XtF EajeNHRNla+aRCINdInk40agGOmce+lVCM2TLE/Su/5G4yaKomIYfrwejUjcQdMSe9aKSxpRPf0/ 0edOZHy1sZKe+54TEAHELQvbcdB1Lz7DQFNVUHQM0U5paTXtVmL13DYthp88gdysLJbOf4mKG85j QJ+sRGZXDyzcvJ1IJJ6cgLhYlp9z5kxn3s75/PK3D/HIH/6L/KCO67gIRUUXURY8/zxF551Prq7J DO4SiUQi+ZhNdNCMNL7zs7sZu6uZS6cWYPb0uAMCi3DjAd7b2sDAc2/l+9fMQcPBcUEjTHVmiG5L zJ8Ajg3pOfkMP2kMfWjHcjuqsziJf6joTj3r1m+nWh/KD6++gnNmTMCxLVw00p1GPB496Q1wcUQa eWkabCun1bKxhQIkQtwVRUNVOkXZcV2KCrNQNuLZWwAAIABJREFUNSirqmfI4Fl4dRWny6KDomqo wiUWN6XDXSKRBrpE8jELelJoNI+RMsR76o4LeL0eTjn1ZO55bQMP/e423OsvIUu32b15HS+98jLF VTH6j/hsBXOblsXosaMY1Lcvi194mPvTIsyaNIJ4QyVvvfEy76/ZggmoQuDaJkrBFK67YDo/fWge t974Nc49azoZusmGNSvZufsALfHOVQErHmfOTT/ikve38/Jr93H57rXMmXMafbOD1FfsZ9nS99m+ K8ors88lV5dDk0QikUg+foQQ9DlpGlcMd/Cq7hFXr11s4oBrC9Izg0Sa21BVDSfaxsFdu0FVP9lw bpGIgLMsC0vYPfasJxzuQjiJMqcRh0DAj2F4iEVdPL4AlVsO0tLSAjkJJ7rtBBg7aQS+lW/w6qJt TCwaTFbQj1A9hKu2sbuiJXFTAY5lUTR7DkMzHmTJU3fz5jmTuXLGcLRk5hlV99Cwbx2rSmLMmjIW VZEb1yQSaaBLJB+lQe4kSopE4lZS8EQPce8w3B3CJrS1J4LjhO5n1Owv88NrdnHnMwv+P3vnHR9H cfbx7+xeP+lOOvVmW3LvBdsYMMb0aghgejEhBAgkBNJI8r4JqSTvSwLkTSBAQg0dA6YXY2MbcO+9 SZbVe7+67f3jTrJkS0aAKbbn+/mcrbvdnZ2dnZlnflOe4RfrFqIK8AQKmHn6FRSsfZY1De0YcZOH aRoEO8AMRbvWmpuGTjACjkiU7sP0AtBjUQyjnaimf2rPtLBMopEgdITRdLPPWWuWHsNZMIXbb7uZ xt/9L88++BdetNvQDcExp85m1pkOnnt9JaGYDkA0anDBrb/B9GTwwOMv8PSjG0BxMeaEM7nrjpP4 3X2PYqo2QGBZBoo3j9889BQTnnuSF994n8f/8VdihondlUThsDFcdfsscp2yWpJIJBLJV2Lh4/ZW qDgdanzZWS/21MKG21fIjAF25i97idv+O42Txg+ivaaURe+/wTtLNmDzZXzDns1EExlMHFXIGwtW ct/991Oz92zyklW2r13Cq2/Op6Sqmcyc+BT0aCTG+VfM4aW3lzH3Lz+hauMCJgzLo6lsKx8vW0tt QzOQl2jvGFjJI/jNf3+f6+/4Cz+fcwnvnHEWk8cNRdXb2bpmGUtWrGfK7J8xfdIY6SNOIpECXSI5 tLiKLmDx4hl4kgPx6ex92HivfyDPLFmEbvNiC0WwAHdKNtf+7B5OvmwPO3eX4fJnMmT4UAK+JIzI dUR0lXQlSCRmkT9sEv/5aDE4kjBbO4hZFkUTZ/DCksUobh9GW7DrZpGonVNn38Li0+eQnJJKeyhy EButEXYM5I7fPcp3oxaB1BTCkd73TLcsC92wGDXjQv793LFs27aDpg6D/MIiCvLzcKsat/wkTFJq Om40TMPC5g4wa87tzLjweqIxHUsoeFPSsTa8gopBUmp23IO8FZ8BmJRewOzrb+esS79LJBrDtOJT 3J0uFx6PF48tMQohHblLJBKJ5BATDQexTI24K7b9jExCnFuAHouAHiKmGViWhS+Qw4//+D+U33En z/79D7xkt4GwMfbYE7n11tn83wMvE47pdC4n06NhtI4gmmHGg7VMtEiYcOI3utafCyzTIBLsIGiP YFriU5d4GXqMYDuEozGsvvaBsSwiYY1Z376VvdV1PPTSO/xm2fsoloE3czDfmTObVx9/mrq2IKZp YRkartxj+Mu9f+Xe++7n7fdeYel74MscxGU3/oq2Bffywkobna5qDR3Gn3U9L2QN5uHHnuKjRa8y f14QEKRlD2DsibO4ZNaJcvRcIvkciNnfu9cqC6ax4slrsSyLrVu34na7ZcpIJN1QFKXLmdqBo9UW VsKgCkVBWHGHa50O5RACLBNd0xGKis1m61KfQiTOtRJrwBUlvk7cNBNthf1+EwKR8LgqhEBRBJZp xkVuHxa9c0RAEfE4mubBHbB1HhMCDD3uAM/WbS9XIeL37Aw3FtNJ8idjV5REvAVeN/zlh1fy+6eW cPdz73HhlCIcwkp4oxdd4XePg2V1Ho83LCwhpD6XHPWEQiFGjhyJqqqsXr2awYMHd23jFAwGu8rr Hx54g+3RCVgVb3HFxedw4yXTME2TpUuXkpubKxNSIknYmfaWOjoigszsTGx9zSazTKIdrTR1REhO SSfZbQcsTEOnoa6a4h3baerQySkcRmF+Ji6HQktLB+5kP6nJHkxDJ9zRRmtIw5cSIMltwzR0Qu2t tEVM/CkBvE61azq9ocVoa21GFw5SUgPYlYOsZxeCaKid1tZWbB4/fl8yaq8T8+P2VsEiHGqnrGQX e0orsfuzKCocSHa6j472DgxhJ5DS6cxNICydtrY2gqEwhmmh2p1kF2TzP5dO55Et2bz71oMMy0vD MkwQCpga7R0dhMMRND0+J9Bmd+Byu/B4PNgUIdefS6TgFoLKykqmTZuGzWZj06ZN5Ofnd9lzTdOI xeKDZ3v27JEj6BJJf+gumHspdvumuSeEedd2aF1brghsdnvC8BtdgjzuT6Xn9fvf54DfuoSrFd9z HA5q/DqPxZ3H0K/zrYT3VkW1oaj7Giyd8e6Mh83pZuu7D3PXI6+Tkj+YEUMH4FY0Ni5dzKLlGxl6 5k1MH5KJU9nXUSC6OjXo24u9FOcSiUQiOcTiXAiBP5BNiiDROX7gaHX8PAWXL0C+f18nOEKgqHay cgeSnpmLaYGq2uId5RZ4vclYiR1RhKLi8QdI8scdqpmmhVBseFPSSSbxWyI+lmWh2h0EMrJ7t7X7 P4dp4nQnkeXxAWZXu+PA8xOOYYXA7fUzbPREikaMiw8UqPHp/G63t0f7QAgDDTsZ2blkJeKp2l20 bHudRTvrGTTpDHxuZ8KxnMCyTIRiw+dPxefv2d7Y/38p0iWS/iMFukTyJfJpgv5wj7dlmqRk5pDq 0ln2/issfCvemZCaNYjzv/vf3PLtC8kNeLsZf5knJBKJRPL12bV9ndW922Kxz7FMl1fyzt1IOvuU FdVG58Rt0zQRQpDoS+95PZ/+2/6i9tPaCPvO77phnx3anfGOz/5TsNmUbmlgHXCu12tw++yr2NKu MHbSOLLTfLTVFPPBux9Q2mDjz9fPJtWXsOmCrsn1+wvy/rUpJBKJFOgSieSQY2hRssedxL0PH0ss pnU1ZhTVhsvtwe107JtJIA20RCKRSA5fiX9wQX8ExNs0bRQNzWfZGwt4dsNyAFRnEiPGH8/9997K qZMH41CAvle+SyQSKdAlEsnXjWJzkOxzHnjA2rddjRTnEolEIpF8k7EIh+HqH/+WS37wX/Ht2eKb oGO3O3C73djUzhF4OSNOIvlKBbrNZiMUCsmUkUgkEonk6zbSti/ej77Pr4REIpEctLbA6fbg8ngP lO/d6hDZ6S6RfMUC3el0MnToUGnMJRKJRCL5OpvKQlBeXv6FwrAsi1AoJG26RCKRSCRfoz3/LHbY 1lsAityzUCKRSCSSb4xh/7zX5efnM3DgQCnQJRKJRCL5mlAUhb179/bbnss16JLPzZHo+Es6M5NI JEdao0B2ukskEolE8vUihJACXfLVZLSOjg4qKioIhUKHtbA1DINJkybJhqxEIpEcpliGhtG6DSvW AkLW5Z+eYCbCmY7qH4ZQbF96B7XsAJdIJJL+IQW65AsRCoVwOp0UFhZiGMZh+QxCCLZu3SpfpkQi kRzGtGx7ho2bNtHYoYDZP3skFCU+/f8oWwJgAarNwcAMhZHjjsM1aBZCCGpqaigtLcXhcByS+5im SUpKCgUFBTidTplJJRKJRAp0yVctdGW8JRKJRPJ1EA624MmcwNizzic1JRnTNA96vqraWL16FcOH D8fr9R5V6/QFYFgqoYoP0WP1PQR1IBAgPz//U9OvPyiKQllZGZFIRAp0iUQikQJd8lVhWVbX53B+ BolEIpEc5sJTCBRVRQgFVVV67Nfc297NS5Z8RH5+AcnJvqPQdnd2UFu92vNOu9i5brLze1/20rKs rmVi3c+V9lUikUikQJd8TeJcGmGJRCI5bGrvbgLt0+v5zvN6X0fcd1hWQhUL+hbJn7o22bKweoRh dapxeruq+69CRLnztw9yzaUXMGZkUe/xk/RID8MwMAwDC0GsYS8LFnzAym3l+AsKSPZnc+K40Ywa UYhuGF3vHsDtTeL5v/2R5FGTOGHGqbj02AFtAwsOkhf6lyd75JdueWP/fNT9Xv3KZ/3Id72Vg89a Jg481v+yeNAy0Uc56+u597/mc8VDIpF8KUgvKpJDLtRN0zxAuH+Wzxe9vu8we+9UkJ0LEonkSEfT DJ58ai31usX2t9Yxr77/3mSFENTV1vHMU88ghKC+poV7/v4R975axvalu1jY2ndYQghEpIyNqz7k vVXtCGGwfHkxP/njEh56bRe76vRPj4cQCK2Ftz6pZFVxuGtEV7St5s35a9hWFuk61e60s+6DV7jn t3fx3LsrMTCxG63Me/IBHnz+XRraNdor1vPAPXfz1Fuf0BqMIvVIT0zTjNtModC6dxMNITvTL/kh d1x/GcPyAuhmmPXrV/LEg/fz0JMvs7OqlUjdbp5++B/MfWc5TSEDEna3K6zO0fjmj3nx7U1UNOgI 0c6d9yznuz+bz6tbWgmZ/cuTQgjeX1hCc8zoITCFEFhVb/PwvL0YpoWINHDpHR/y0z8sYkmt/tmF pxAITMItjby6orXH9UIImhqbeOrx/8T/rm/jr39fzD2vlrHz4x180HKwZ4kfW/nxTu78zYds08Tn i5sZYvW2BraUR+LloX097y1cycaSCEIEmbugjHW7Ow5eNq0wd/xxIa+uqkdD9Oz4kO0iieRrQ46g Sw6pOAdQbHbqSjYzf/4H7Kpqxm5Te7nIICzSuWj2BUzM0Xnx5TdZX2XjmstnMXpoHoZ+aB3O2Z1u /v2LC7j93rf50aMr+dmFw3HaRI8GiUQikRzJhNva+PO/10JZHVOG1POTR3bhTXVy3fmZ/Pj+UoYE dFIK0tEshek5BmtqLQYMyOHyGZmdbfY4qh27w4XaXEtLRjJ7i6u5a3E5OQGVicdk8MYW8O4q5axz BmKOGMgxasJOCACdlvYo9rQ0zp0xEHu4jafn7qHaSGJ0nodIcz2lsWT8hkZVZSPOdA9CschPd7Or JMzm57Zx8VWjOO+4XLy92iPwp2WSk1HF/Xc/wPCBPybcGmTm7Cspee9JPs7RmDd3LT/5wbX4k72U rV+M1CE9xXnnCDooCMVO6aZPeHXhJ1RfcAYVtWGOHZPNrk1bUZIL8LSUsXPtK7xUEmXS2EmcemIN TqGj6zqqYSASQr3HO+r6x2ToqHxGxOqoQ2HZ0t3sKG/FSM7EXllGxOuizZnKJHsbW+ojeAYMxFGy i1LDTUNFA+s7FDI66qgPq8w4dyxTsx2IbiP6WBaTpgzm3NR6NrUYLNq0jTW1Ou6UDAYbNSyrhzbD w3CPxjVXjubhJzYxfoCNtbUGXn8a7uZKWnBTlGPnmUUtpIls5i5t4dhj87nquEziI87WvjLh9GA1 19CUlkxFaQ2/WVRGhk9hytQM3tyuYN9awqxzBqKNHMQUWxCXQ4dB2exaU4uZFOLRDxoZUeDBYQaJ uJJxmbBqfRMzp/lJz8+gZUcHgwdpvF5iULyykXNP9LGxJkZSIIP8nEH4Rbf0TZQFu93Gzg2lvLOq ilh6LiNcYUrr29na7OCHFw5hREESY0blMj2zg7sfLKemvJ3Lb5rEtEHJSI8BEokU6JLDXKB3GnUA 1eGkvnQ7zz36DxZtrjzIlUUUjpvMMd4Yc5/8J++sdjF56mTGDs9DMwwOZZtJNc19RovOnn3RtWZO 9hRLJJIjHVeyjzuvmkjjW2tYUFrPuFkTmF67gyUNgpOOG8JJ3kZaJo1g6aurWLgxxOCh+fhTD2wm mBbkpTnIz7Xz7NtV5E3WqVYcTBnsB7uCs3gndW4/i+vgtklApJtiwMnpM4dRmFPBWwuLKWmIETCC 5A1PJxKN0tYeo0WL0h61uPCc4VQ0R/E57Eyf5OWdFUGmZnpxJtuo06Fw/4FBYcfZsY6/va0y58bv ckntCyTbYtgzCsjLzcU/eiDbm/ZCRgEej4+CnDTcLilDehPppmmCMIlFwwwaO50Zx3+LM0cLHnxs HrGYhi0lnezsAnxJEZrClRiuXFLS84h6ndhUgWGamKbRNfW8dxT27CjnmeIgj0y38/aqeoTiICNg o7HBw9UXj2buO7tYVR/lF3Mm8egruwgrbu787iTmvbSNc88ewK6lIfasb8PqrU9fCNavKWapQ+GZ MxzcPa+awUPy8AZsrN0puOv6sfzfk7u6BL1mWCxYV8PgofkkpdtJVdyUlcXIHpTBKcdlMKnQ4v2l DYQjRi9lwiIzxc7gQS6enFfJwGkGFcLBxME+FJcd+85ttCSlML8GfjoZ6ktDLFpZx+ZWN66mVgad msO3rjgGf2MdpbUeLjjGz8fFHWRn+AmYjSxvtigUYOgmmflpTFIcZOSZVPkymZbtx2+D3hpNqoBN zTrnnDWC7bvbWba5lVsuHU7++hYc3S7QdZPBowo4J7eGOgNCOjilQpBIpECXHEkIsCz0aISMYcfz g+/dwKTBacS6j4pbJoaaxNhxw9AdbVz+ndsYc67KqKIcdM3oZl9FN+MuekxF/DRRfcC0Lmu//+l/ WBKJRHIkYFkWKAr+gnQ2vLqO3SlOvjNOYe4uCwuwTIskp8qITD8bG6JkFPRaYaK4XSTnBkh37SEj L0Dt5mJaw358MSdpAQcTpmWyZnOk5zo6IYAoH6/Yw8vL6hk6JIsZYwLUlkSobdFId+johoHbJohF TDQThgQU3v1oL3uqvEQdqQxURJ/1OJaJ5ckjXdnGC//8E0s3dHDKFedgVm/h739cR4uaxl2/vQO9 5N88/NffYC+cTqyxHUWRc9y7i/PuI+iGaWGZJqaho+tKj2VopmVg6hoExpHWuJOXHvkD23ZUcfmt I+M23jDAtPqeoWaZDBqaz7dPNXh1SQ1Ffhe7Gg06IhY2LcxDT65CZOczNVPn/ifW4h5QgBKMYphQ 6NP511vljFV1ktUYlc06Zq4Ddb98OuGYwdww2eQPz5Ry8sgAy2piDM6wGGHX+OXD64jg5axMnb8+ s5maqOC8Yaksr48yLM0iGjFwKzplbTb2rt/BytQB2JIcNNZ39PIsoDidJOdlkuHcRUZ+GtUbdtMa SiZDd+JPtjP1lGwWrYxfWx2FjKJ8/jM+jVWbytnYZrD+gzUMG+hFjbbzcHsEpwUr1zVw6im5DLOH eevj3Yw7LoBjYFp8XbnTRfvuJjY2hxlSWERA9Oz8KN9Tx4KlFQwe6GTbzgZcWdmMy/Xy/Os72Nnh ZMTITCDC5q015KRnEDZ8yJaQRCIFuuQIavB19bgDpmHEHc2YBknp2UycMp1TJmYTieq9Xm/g5rxL 53Be4nsspiWEeWLdmlC6euG7i/W+GlWd15rmPlMjVDudY+j7j6BLgS6RSI74ehooCZk89Pg6ECCq y/FnugB44rVqhIDXW0CUbQSh0tIAmDEqdtfAxLR4PZqoczUhWF3SwubKDpSsHCrWVZOa5aG4tIni PU2guqldXktmwM3O8g6G5SgIIbCp0NoBe1tVUpLdNDe009zQHm+KRFopA8AFRFAUePOj8kSdbqOl OgrUsFc3GeZUGVOQBqqCEN0dgRmE9HR+9vu/4Ev2dP066YGHe6TF8B/f1fX3vffe28NWSOgS6EYs hn/0yVw4Jm5TG1tMLr3w/C6nY3H7PAYsC3HsCfvsr2lihoJogKJYB9huIQR2G2zdY9Le1szTy2Mo imBL4nh9aS1rt7RSODhAckMDayxA2ImV1wDwjyfWJzrrG1gHmHYP/mATwvKAECiJdelLthtooXoe WARJAlbWCmzCpHRHFWDHpRhs3lzBSlsmWAbZTlhVJ7BhULy9KhFdB1tXl5OU6ebjLfUIC7xW9IB2 iC5gXXk722pDKHl5lK2uIjXbQ2lFC6XlLeDysuKTGjwCfvvImq7+qp0VrYlnacbvE9Q0hwAVQkEA cvLdbNnRDEDmyHSqmy1oKqdMgPUJGKaJPd9OrEMDV7ycOVTB3moNd6qHbBPCsXj6hesa2WaCQ1i0 VjXx8AubCPjtBDJ9rN4eAcoo000m+Rtx5LrAZpeFQSKRAl1yOAv07gbYwmJfe8eKC+1uTmK6XycU G06tkmdfeJ1NzU6uvuhcRhRkgmJnw8dzeXfBCkaf9W0mF9iY/8pLzF+0gvqgQdHYY7nxpusZOSAT hZ7bwYDB+iXzeHne+2zcXYnNnca0meeiNwQTa98644t0EieRSI4KHHaV331v8ueu4zOzMrnqmiux LIv8TC9/+sGxn6FzIIlxU/K7vl977tBD1OkwiXNPO/BX0zQS8T64bxEhFI4//jiSvB56rCc+aoy3 klh2IHq8685R9N5Gvj+rv5ZO+9rl8Tz1BC49O34sKzWVUUWph7YbKuccbvxW/NuMidnMmJj9pbV7 AmkBrrnuGizLIjvNw5++P/Vr7oQbxxknd35z8r3Zo77wM0qP7hKJFOhfuajsa4sWSX/Sr+cWHt29 tFqmRef8Q8uyMHQdTYt/ujWNUBQFRVFw6HW8/tLjvFns54TjpjF6YDbC7mT76vd46B/PMXDdDup3 bKaqsg7FFl9otfSTxbz87irmPf83Jg/LB8sEFGyKxoM/vZbfPTGfsCESDuoslix8s9soiZUQ6VKg SySSo8DWfcHG9v7eqz/z9V/Ss+0frsOZRJrWSLRiAY3VSr+m6w5LFUQrFxE5GjOHUBGhctz+niK2 oaGB9vb2Q3ILXdfJzs7G4XB8qXmBryD0Q1kmDoenl+JcIjl0drhz1lF/9cZRK9C7enNN/VN72SX7 p52CUGwHZL7uDUHLslBtDupLN/Gff93PkqwkDCORzqZOxJHH7AvPYer4oViWQCgKKCIhnM2uPT6d bli38COOO+8K7n7gOmYcM5xQzWZ+ftttvL7sQ55+fxOFuVkEPAo2h5MPHrmTPz3zAY7cydz/lz9z /qmT8CgGJdvW8j+/vI3nF23vJsqR4lwikRzRdDrv7GwcHMmN7rRxc/A3b8WMNoOQu8h+eqvRRMk4 EVvK8C7bXVhYSGFh4ZfaSJVIJJKjTZx3/t1fju4p7pZB7ZqHaKlci4lNjqZ/WnIBNmGQVnQiaWOu AaH2upd4p/hVbXaCdcXMe7605z6zhoHhHcuo8ZM4btLwhCDvmZkT6plwO1z83//gDzdfQrbbRDNM UkacyC3XXMSKTf/DtrVrCM0+joAnBbtWwoOPvEFb2MsTjz/CWeMGoBgaEQMKxxzPtAmFvLRou5zi LpFIjhpSUlJobGwkEAgc8eJIKHbsaePlS/+86fcl5w8pziUSydFarzY1NeHz+fpdDx7dAr1jN8WV bZj+i/GlF2GZxtcepWgsitPxzdz2xUIgaEY46jDailH9w3qI6h4CHQstFiZz6Ancdst3mTQ0QExP jKBbJoYtmeFDC4lEYti6ieOucBIC2rTAn5IECui6gWlZaLpGUXYmHqeTjkgHhqkjVBt1yxexrb6V wImXMCk3CdUyMLo5rjP2G+GXo+gSieRIbxgEAgFKS0sRQpCSkiITRSKRSCSSr9AOt7S00N7eTkFB AYrSv9ldtr7F2IHrWfo7PWn/9d3d1yv3J6wDpgPst1a8P+vHe4SfmC7N/vcUglg0ytCBBeQXjfxG vMjf/va33HXXXd/YjBZtLSdc29BjbV/vI+gWpmHizchgzKSpTB+fTSSm98hhpmnFHdEkBsw7rzUt CyWx7EAQ31/UMi2shDdY07Sw2+1xj8KmwDIthAJ799YRjcYYmZeLqqqYltnTS7vVbSf0LnF+oEDv b948SObD6pH/e+bn3v7+rGXs0/K6OMTl8JDFDXp/fsuKdwCJT68P5CiMRPLZyl9hYSENDQ3s2bOn y/eHRCKRSCSSL9cGW5ZFUlISAwYM+ExLzfoU6CLRmDZMUBUwDAubrb9GXcSvt0xMS0FVwTQtdAPs NoFpWqiqctDehk6nY6qqxvfUNkw0w8JmU7Grn/5g8TDioktREiJFCAzDQAjRo4HyTRo97Vwv+E3O bH1lwJ5iOHHMtDAMHV2Pfw58T4nrhJXw3bbf6HaneEuI7a5P1w32/WaIzn1846K9t2n3PePbu0AX QqDrejzvAYZhoukWdoeKrT/75XaJ4rg3e2U/ZzKdTvVUNb5EQNdNdBMcdgX1c+zH232veNFNkAsh wDITHvUFigKaHq8YOm9zsP1/O6/XDFAV8bn2Cu5RGSXi1pm2QggMw0yE27s473ofmoGBwGlXvlCH gURyNNG9/KWnp5Oeni4TRSKRSCSSr0lD9bfdelDFbUSDLNnYCpbJktXVgEUoomNYFppmEInqRGMG kVh83+tYTCeqmfGGthmhrW4n64tDAFRWNfPEO+W0hDXWbm0ALCIxA92MCxTTjAvwTkdidbV17Ni+ EwA9EmXF8j38/aWdrCqOexaNxgx0w0TXDcJRA8MwMfR4XGJa/NiO4iaKK1qJmvFRWYCd23dSU1v3 xXtE+iFcP2+D6nDuJeopouMitddj+69dtxLnJs43+xDh3cV1/Ir4xzBMctNScdrtlNRUEtP1LsG/ /zvaPyyzly3gVixbQafrwFWf7OJvz29m/rY2ADRNJxIzsSyTSFSP53/i+T+imWCZRKM67W0hdlWF MUyLaFQnmpjiHwqGWLtmHQDhYJT339/KP17ZwZryMACxmE5Mj8cpmgjfMOOdVKZpYpgWsZiBZpiY hklMM2hsiVBZFyRqmGiaQVQz4qmn1VNaupe9dRpgsHBFJZ9saWZXRRvl1e3x63UzHrYRD1sz9u0h H6tv5o1llextiu/7GonG46Zp+8pdJKqjGfH4WYnONF2P1w+6aVFW3kZzSOsqg6tXriYa0wBYt7aS 5pgJArRYPF0h/nc4UdcArFm6jUcW13asaqjvAAAgAElEQVSFqxlSnEskR7JNkUgkEonkaLXHtk8T 6B9vCHHMUAefrKtlWDq8sqqFk2YMpnlnKcVNBna7HQuYOaOAFQt3EUxKZc4ZBShWjGBjCVsrMzhm mJtwUzOrPqnCne/DKqkliTAf7owwdmwurtZmstLc7NScZCsaY4am0djQSMmeUkaNHsnGHY2Ut2hc ff5Q3KbGnj21vL+intHjc/DqId5b3cLp03OwdYRYWaGRkQwdYWho6ECJhUgbUsDMCdnk+W2UFJdQ YA4iNyf7iyWwZRCORLGEisvp6DFKejT2CPW2Bn3fCQdZ591dzIvEdzO++PzAEe/uH3OfqLcsDE0j e+J4slN9rFuyiG3lN5Pq9+JQQNc0YtEwtfUtXaK7+wh6b6xfu56p049HAbbubufKq8bzj3+u56wR E3jrnR1Uml6uOzWVx+ZV4U11c+FpeSx4ZyeR1AAXTXTzn9cqiMba+KjCyX9dO4Tly8rIGT2ACyak Eg6H2bJpC1OmTiYY0mkLWZw8I5+PFhQz9sJCXnq3BHdOBjNHeXnr3WJUv5epx+bSXqWR5zcoNwVb V1WRPTiTQr/F4s2thIMx6mvamTp9IKK5jXCSn7Om5+LTm6ioaEANZFGYrdJQXMVO3UdGrocJyRpb tlbR7vSR4XcwgBCRlBSqmqOMz/eSle5h3ZZG5i+vISfPR44jxtyF5WQUZmNva2F7k+Ck4W5WbWlk 0OgBKB0hJo0NsG1XK7GWVkrrImQMz2fZy6uxjxrIrecV4XepbFy/kZHjxuJyOtiypY70UTkEnDrv z99BpZLMNaflsHDBTrZVaVx05XgK3TAyTWVdyM+KZcXsrtPIHTWA00cmy9peIpFIJBKJRHJEcdAR dMu0WLu2lH++vJ3tQYuXP6nihosH89zL2yit7ODMc4uoKAtyfmGMh17ZzqtbogRLK9kQTogtoSSm r1okp3kZMCqLvatKKKkPM29RCZbN4oMle9m8o57XVpSxYkUZFbV6lwjunFI7stCPx9K4+1/r+WhN GWt3NbBsSzNl5Y10uLzE6tvZuqWMbUFBrqrhdDkYPKqACXlupkwdgGXolO9tij+wIg7NiEJoF3/5 02/51UMv0NIRPqozUa8C2uzfyHkPcW/um75u9bFXec/p79Y+gW9q6IHJXHb6OJJt5dz2418z7/1l 7Nq1kyXz5/Gj677FfXNXx0fc+7p/NzqntwNYsRD/enodvqG5tBWX8J+NMcIlZayqC9JqT+GU5Bae XLibcl8+wxqreK8qSKWRxHcvGcLJkweSpzdQovsYm+dK9PDQtcRCERY1lQ28PL+Y1AEpFG8r483N YZq2FbNwdzNhXxajnSG21HSwZVc7tTvL+WBzDYu2dlCzfQ+L93SguXyMHRLgzJmF5PgVapojjC5M wWbGbyaEkpg+bjJgbB6qadBc3sR7K6sormmhuKqNtWsqWbK5jnc/KWb1unragvGujB0hwbRUlQ7N 4v9eL2XK1AKmJ7WyI+zmvBMH8PH6Ws48KY/t2+pYtLSciGawZXcTS1fXMvPsIezaWk0gJ8B3zhuE z6Um0lbpcnChKAJFVQjvKWaHN58xbXW8u2oX6225TPcbVMe6+nHiHSdbmjj34pGs/ni3rL0lEolE IpFIJEeXQFdtKqedMoKfz5nAxBSVZK+d1vYYfr8Tl9dNkqqQn+5CcdtJdrs4+aTB3HztRIa76Brd 3HcnlSyfk9EZsDVqZ8SwbK4+bwS3nZ1LbqqTUk2Q7QjhHpjZKYu6GuVRVKYcX8R1p+YjgkHcmX4u u2QCsyck09EcxDcom5G5bnx+NxlpXpwKxKIaumInyeMk3WvDlVi72iXsvijhUv790N+5/4W3aQtF jvqMtP/otlBV3G4PbrcTRRxcmJuWwOVyo3rcKCKxftw0Ue0OvF5w2FV6TpU3QVFxe7y4nA5E4lgk GGbOT3/P6SeOJ1aymDu+cwkzZ57C1TfcwccVHk45cTRup4pDFZ8q0Lt/d/v83HLxULTKNnS7g2lT B/L9G6cy3hc/ryEEWX4HDnRiNht+p42BeT4UVExNJyWvgPPHqDwyb1dn1u4qG5ZQGDQogytn5tNe 0Y7T7+WsM4Zzw2VjGOa00GI6zWELh11Fi8bo0CE7PZnzzxvJNRdP5KJjsgkoHby3tBLLNBhSlMnx g72sWF3GpvrOEt5tmr/iYEKWDdUBjaqLKRMGcuvs4Vx3bCohbzLRUBsZOW4caUkQbKCxMUSJqbB6 fSNm1CQW1YlaKg7FJBTR8XpshMI6TpdKepKNjmCUkCVwJrvwCIUkt4rXAS3tOobVU2xDfN19KBQj ZKo40YnZVNx2lSSbRXVbDJuIa3k97lwAd7IbD+D12GTtLZFIJBKJRCI54jioF/cYLkYPiNHcFuWY sRkUpcATr+3h3HOGE6pqJBIyGDIkhajbxvETHDRv28M/3vBw/UXDiDulsiUcuimodhcTRtjI8iUh sqIMSdZ56KmNHH9sLqPGZ2OvFWS4NPwBE1BRFBW7LR49S9NYuLiEsqiTs2eMJDXazjtLd/N2RyZZ bgHBdtqUAPlJNjwZGSTV1bNoTSm+tCQGexxkpQrS/fHRS5vNhqqofYrM/nvvVnA4HDjtts/s8ftI c261v8jVtRiBgmFcddMdhF25FGR4iOlG7w7mDJ2Imsm3Lr+BcW0OinICaLoOZpiRU87hjp8Pomh8 ES50DMuMb72ma6i5o7nptp+gpg0l2ePENExMy0DzDOKBx5/ltZde5KOVW4koDoaOOZarrrqYpi0L +Hj9HsaMDKAIC9PsXZADOByOrr8HD0sHNYlLj3Gz25bNmOgu7ntF5dITvGxZV0H6qYO4ekI677+9 nR0ZmVzid2LPVWnTFdL1St5bb7BjdzNnTh8EgFAEdns8fJfLRn5hOoEkLyeNiVKvJOGp3MNjrSnM GJeKWLKZtUnJTBnjwGm1UeVOZ1JOEuuX7uG5Rj8FKQoNrQazzyqkrTnE3Ld24zJjpOVlMDELCCmo qo34hAA76T4H+ROyCLREcalQvbeZ1btDnD7Rx/QxPsJNPryZbpxCp7zC4PSTiyjI9rJ9ewOZLg+L VlSwsyiHgaKZtxfv5czxaby/pIqhEwcyenQSbyypxJuaTEGOh2hEZ0iBn/xhHl5eXMW3zx5AqteO w2Gn05Xd0ME+nn12A0lF2QyPVLDFm8bVozNpmreNd7eGuCESpUVRWF9noBvNjB2WTrA9xrhhabL2 lkgkEolEIpEcPQLdtGDljg5Wball5UZQVcEqC1xOwXvvbQchWLyxHkUVfLQFVGGBouB1apSWNDFu aDLJWSOYlOwhHDVYsa2FzbsaUVUFVYGdFjgcguWrK1kWv5SYZjKmPsKAmYPIzM7E7fEAUNasUdpq 4XFqzF+wEwuBzaayu7iBXRbYHIK125qwzMbEWmaBTRWE61p46f1mIjGDb80cRH6WlxEjR+D1JfX6 zJ2i2TTiTuYQYLPZUQQH3eZp33U6hhEf+e26ptv2UZ3Xxs+30DQNULDbD9/RwN5GoXVNw589kHMv GYywrIQH9z6801s6USXAqWdfzOnCQtN1NN0ADIpGn8jQ8TMxdS2+HVvnNuq6hpo5hEuuHAGWgabv 2+/c0mPERDLnX3UzF85REViYhkEsppEy8VSGTVYw9Bi6YfUYyd1foE87fhqd3ThLtjVibWlAUQVs aUWoCi7V4OWPWzl+kp9wfSMPvtSAza4gyhv4Z6mFqsBSE2x2BaukCaEK9uyo4uSRfrweL5MmTwQg GDV4d1U1jnW1iSUdDSiqimhq47UFrdjT/Ngsi9VL9qDYbFjlzezd24xqU7Hq26muA5siWLSqCiHi HuObTQvR1E5dnY/89CwKC5OxexxUN8RYs7WO8togDpsS3/JMESjEeG1xB0Ik9mHbFvc+jyJQrIQn ekVgATZV0LSjCguBqsBbq+uwqYL1q0tZYwnsqqCjppl6C1Ztb0BVBCZxJ35qYiR/yrFTcTnsACwt DZOa6oamFnYjEKFmHnqxCZtdZdTkLBa9s50FFthUBVU0sbQOPt5Sj82mMHNKrqzBJRKJRCKRSCRH h0BXFcHJk3M4eXLO5xRu4E0dwJDU+PdZJw5g1okD+i36AoEAgUAAy7IYPzSN8UO/+IiZZVkMGNR3 HFoa6mior6WsrIyquhZQbOQOGMTAAXnkZGfhdtp7EecKWqSDhupWtmzaQEVNK9mDRzJ8SBG5mQEU 0bnlXGLLGyNGQ0MD1XuL2bGnFEN4KBo+krzMdAJpgcNeqHd9Nwxi/d0yzjKIxQ48V9c1dF3r4xKd qKH3EReDaNSA6P69TjH6CO4Ab++jx47u+v6za8cf0nRyuV0MHzEcy7LISvPwqxsmfXnvBcjJ8XcV 92vOHfa155ORo0d2/f39S0d/obCkh2qJRCKRSCQSyVEh0L9o4/eLtJvFfvtGHyr6DksBLH5z0xX8 7ZWFANjtduKj3DrO9IH84u6/8YOrziHgsfd4SBHr4O2n/sqjDz3FhoqmrkNFx1/Gfx6/j2lDs+Mi HcCIsn7Ri/z4x7/kww0V2OwOBAaaZpA74lj++H//OiLE+eHOlyn6vqy83ef9vsFp+0WfX4pzyZGM 7ICSSCQSiUQK9KO88avjzhjIRRdfy5Tjp5CfE0DBpHbnGh597El+c+N1DB6yhMtOHkunRFdsToLL X+Unm/yMP/5UfnXTsfhtQd6d9yIfLH2By3+QzsoX7yHb7wZg14dPcPpZN9PhzeXa2+7ilGkjcejt bFz6AS++toCPPtlM/mEoZg3DIBw+vD3ZG/0d7ZdIJJKvqG6VSCQSiUQiBTqqqqJpWmIE+WjBBOz8 6aHHuv1kEI1pOF1Xk2sLcdOvHuGNxTs4Y/JoMpMTHuFNHdJG8M9nn+H6M/ZNU/7xj67jtInHs+D9 B5i/804un1yAnSZu/8HPaDQ93P34O/zionFd519xzQ3893+tZeFuweoPtx9WKZeUlISqqlRXV6Oq 6mE5ki6EwOVyydpAIpF8I+gcPdd1HZtN7lggkUgkEslRLdD9fj/Nzc1kZmb2aCgcDRjRIHV1dRRv 38T6jZvZU1ZJS0eE+uJNhCwItzRj6BrgjKeNoeMZeyxnTx7SlVYAwlHINRcey5Ktr7FgwWZmTywg uu5lPtzdQcq07/CjC8f0SFvLsvDmT2JWPqxa+OphJ9AnTJhwxDWMJRKJ5Ouug5qamvD5fIdhnbTP 70r356JzuZdE0oe97e9vksOj3GNZWF9yuZd5RnLEC3QhBMnJyTQ2NhKNRnE6nUd4Bo9vsiyEAugs euVRfvXrP7K8uIEkfyq+JC9OpxMt2IwGCS/b+1UMhk4s4aG8e1oNKxyL3f4adWXbgbPZvG43hmky feoEhG6CXelaqP9Vr0s+JCl3hOYLWaFLJJJvQh0UjUbp6OggPT39c9dLvYrirgZzL41penYcf/5G b3znEi0Wob21HdXlxZ/sOeoE55chEj5LmN8kkdLXDjiWFqG5rQPV4SHJ60ZV4r81tbZjcyWR7HH1 2vb6qtOS/ctQIo9LDiz3Hc0NhA2VQFrKPh9MX4bwT9xPCIFlmoQ62gjFdDxeH163Q74OyZEj0Dsr rOzsbCorK8nOzkZV1SPzyRUbIhbDMi0cbg9b3nyQG3/wU/ZYBdz6658z+5xTGDlsMJkpSeyY9wCn XffD+NZr/ahIQOBxqoiubxCMalgWuF0eOMzHEEzTJBqNomoGmLosRRKJRHKI69ja2lpyc3O/oLPW +Fafht7B5g07Eb5Mxg0riO8skjhu6BplOzfRqtkpGDKaNK+y71rToL2xip0VTeQUFJGbnvyZ7l+5 cz0P3fcgWcdfwh3fmXVUdK7owRb2VNXjT88lM9X7pdxDi0WoKN1OY5sBmF1bhgpFxeX2kpaRSWZG KmofHS1fV9rE2hrYVVqOcKdRNDAXl8OGVr6e/7n/MdInXcQNs08hNclBdM9qfn/f4wyafjU3XDSd JLf9S4uTZZnUV+xhb03TfoMlSnx7XNPE2qcJcTiTGT1uOHLhSd+8+rf/5r2qXO7/+89Jcx4KoRwX 4qahU1teShgPgwblonQ7IxZuZ+FLD/Py8jIuuOoHXDhzhHwRkiNHoHdW5C6Xi0GDBlFZWdlt3+4j zZLasAWb0DQdl1Pn9VfepaQxxn89+k9+ff3pdK9SwjGN/i6tTgxYUF5Th65DRnYBCMjN8CEUKK+s 2qfPEycfTlNxhBDEYjFCjU0IrQEsKdAlEonkUIpzIQT5+fld68+/mI2wiDRt5uQpx9M8cBah0tdx i3ijF6C9qZTLJh/DqrCdP7+xizvPG0hibAo91Mybf7uNK//4Fr99ehm/vuqYz3TnxopiXnzsPwzR hxwVAh2gedUrnPWdP3DFnY/yhxtP/lLu0VhTwm2zJ/LmJkCoqMLCTGzn6kvL5qTzLuf223/AKRMK v1GjvNXL5jLrsu8hJlzPm0/8mZGDMtDrinn+qUcp6hjKlbNmkJrkQKvdydOPP8ZU9RiunnU8Se4v sbzpOnPv/xm33vtKv87PHXgim0qXEJBVVZ8sffUJntkymt/f+1PSnIcu3HBHM7/79jmsEDNYuvDf dPccZGkx9q5ayJOPL2PoyTdwoXwNkiNJoHef1qYoCgUFBUf204facTpdCDNIY1sUcFCU42P//r76 piZimtG7oRMK9m5OfOKNqAgfLFlC1FKYNn0yqgIjpk4hzWNj+UfzKWn4PiOy960rFEKAFqQp9M13 sGZZFi6XC19OLkpylixBEolE8iXXuV9kirsQCo7UCVw1M5OHPlnBJzVwWnZi2qml0VGxinVhsCW5 WfHRAjjvekRi6ldHMMRHKzcQGDiG0888pitMDjK9t/txRVFxusBpt/V6vK8Oha4R4b5vkpgBQK/T 9Hs7v68bdl8G8Knr5A8ytbnzPZntDZSU7KG+IdhHnMUXfteKouJJcuFNz+aHv/0dQxwRNNOivbma FYvf5qUn72NnSQVvvvciQ9yi16n3XYm33/N0X+LQH58BB0naA/ANHMt1N98G+ceR6ksseVBUXC43 TodtX5tIUXG5HTjstn3jGXza3EOrf3lh/yacqnLC+XP43+zj4lPphUCPhnn96T+zstjiul/ezegk DcMCyxL4UvLwfFqM+vGu+/e+rW6DQ/0rc5+lfB6sLPQ8nz5/7y3+dqcbXM749HMOFo/+pVFnfAUW 1bt3UawM7jF6DmC3KRRkBVC9yaRl5n2m9JVLGyXfeIHen8JyRGGaWJaJbiUxrCgLNzFef+dDRg3I ZGDASSwSZu/mpdz3xFzqw6Aoyn5ppRBrqGT9xi0YQwuwKQqGHmXje4/w2JtbyJlyFRdOycIugKJz mHPaBP786iJ+evfj3P3988lMSUJYBsHWZjZ+9Bq71fGHUdKZB1SQEolEIjm0fLEp7gkNJFROPvUM /rHkBRbM38hp18R3ETFiMbYtXoyOn7GDA6z6eClwfdeFwfZaVqzaQ+bEWzguPSFKOhvqpkZtdRXN bR3oJriT/GRmZJLscXQJv77UnAD0aIja2lragyFMVLxJPtLT0/C6nUBCJBoxGuvraGhuxzAFnmQf 2dlZuB1qYg19vOEeam2iJRgjPSsLoQWpramlPRzD7koiLy8Xt0MFdBpr62hqaUO3BL5AFrkZKV1i tLugamuqp6GpiVAkhupwk5qaQXaGPx53a999939P0WAb1U3tAITaG6mqqkoctJGVk8m+BYMGtZUV tLSF0ExBks9HVnYObnt/Z9RZmKaJLy2bK2+5htHdjrRecxnqt07gndKdfLKqiSEzAvGZb5EQTU2t OLw+An5vtwxiEmxvozUYw+dPIcnt6CHUYuF2amrq6AhHUe0u0gMpYBkY2Ejx+3HYBW3NzXQEw9DL WnHTUgmkpeJxOUgdNo2f/noiwmbHYf9sk8SFpdPc2ER7RwfhcBTNMLE7nCT5/ORmZyAQCGF95jX6 iqIy/qTzGX9S9yMaNSv+zpoKwVU/u42Zrr57JYItddTUNxOOGjjcHtLSM0jzexP5s++4dD8W6Wih praeYCSGotrxJCUTSE0l2euKh5N4F1okSG1tLW0dISyhkuQPkJ2ZgdOuxPOwtU9IR4Jt1NXV0R6M gGrHl5JGTlYaNiWR3/vIw5gR6upbMG0u0lN82FQl0RWhU1fbgN2VjD/Z0+UXwIqFqG1swe72k+r3 oHQGKsButxNqb6SurolwTMfhTiK/oACnuq+sWZZFJNhKU0sboVCIWExHsdnxeJNIz8zG64zvDmSZ BjWVlUSFQEGjorkFdzgEQsHrT8Nnt+FL94EQ+AMpPepOPdxOVU0dHaEIKCoebzIpKSmk+LwIYUkj Izk8BPrRh0UkqnDeFZfz9vJ1vPb3X7Bp4VxGD82juWIXW4sb8bviZlXTDfYVZRPNtDC2LuT6Odcy ZvRwAkkeWqu38f7Hm8gcNIG//e13ZHpdXb2fv7znr6yvuZV3/n47mz95mePHDkHVQuxcu4wV28v5 /j3z5LQpiUQikRwqeQ+AqipMP/1kbL96mo8/mg8JgR6Lxfjgk5WkjT2TO2c7ueEvS1jZClP9gBWh uXQlG1qcXHzS9IS1jDuXi7TV8+E7r/PsCy+zu6qeSMwgJXMAJ51xMddd/S0GZfr67DEQWLTUlPLm qy8y9/V3KK1qxMJGRm4Rp8y6iCsunkVhlo9YsIVlH7zGM8/PZdWWvcQMhYwBQzl/9uVcduGZ5AWS ugTGyjee4sm3t3LWZRcQrVjHiy+/xfa9dfjzhnPd927nwpNGU75hCU/+5wVWbNhGa0xl3PSz+dlP bmPqyAFx0RJvyrN7w3KefOwJVmzaTkNLB6rTzZAxM7jhxus5afIwbAmR3lsHxLYFL/GrR14D4JM3 Hua2Xa9jWQLFNZCHnv4raQKMcCufzH+dfz3+BJtLGomZCln5gzj/8uu57ILTyElx9VtkWpaFZkA3 5Y+hmzg8AVSnh/S0fXPD925dwV/veZRhZ1/Pj649pVsoQZbPf55/v72DK2+8mVlTh3e9p8aKnbz6 4rPMnfcee+tbcfkzmTZ5PIoRxJt7DN/59jUMz3fyxrOP8uq7H0G39caqakMRJm16Jj//1e2cOH4I WtlafvfXh3GNPIfvXXkOmSmfYXvTWBl/+f2fWLFxG03N7URiGi63lwHDJ3LNt2/g7JOn4LaJzyS4 +krjcDCEZsTDiYSg+1zqrhkGpk7JhqU8+/QTvLN4Ha0hA29qBlNnnsV35lzJxGF58Q6DXnNK4v1a OtXFm3jpmad544NlNAbDWIqdtMx8Zp71La6+4mIGZcTFfnN1Ca+99DxvvLuQ8vpmNFOQNWAU37r0 KmbPOpn0JGfiXhZ1pVt58dlneH/xMqoaWjAVlbyiiVx29RzOP/1YfC77QTrRGnn4L3ezUwzmTz/9 DvkZ/vhZjVu5+9f34Rx+Fr+86QL8ibZt0+YP+cW9/2HaZb/gurPG4rQnwrQ0tq9dyto3n+PND1ZQ Wd9K+qCRXHvjHVx78al41X0diIteuY8Hn1tKTX0DoVAUu8NFenY+p114NddcNou8FDehtmr+986f sb7BIqhs5kc334SqaTiTUjjvup9y5SmDSMrOxOtxkZaTyIeWSVPVLl574WlefH0RdW1BDEUlJZDN tJPO4No51zAqP0WaCck3EjkICuiRILkTz+cPv/kN133rDNxGB9u37iBsz+aHd/+TZx/5Xy6bdRrj h+bitCWSzJ7OCdNncN61N3PZaeMJ1Zezft1a9jZanHLeHJ54+VUuOa4o7pHUivekJg+ewYtzn+K/ fjiHbNHO6k+WsHz1emLJA7jl53/guotOkC9DIpFIJIcMC0BR8Y85hWNSYMOHH9PRqXkijaxatZkT zj+dk0+cghGqYtGSkrhdDAbZ+tESzOQAp0yf3iX3Yx2NvPjg77j827eytV4w9cTTOef0mfgiZdx7 1/e55Vd/p/Ug/lTbqndyz89v4fpbfs62OpMxk45j8riRRKs38+f77+OlBSsBePepe5nz7e8x95MS ho8/hhOnjcWoXsOPb5zDL+95kur2ff5Pdq1ewtzn/sXtN32X3//f09RpboqKBtCw9UNuu/lW7rjl 21z/g1/y4Ya9ZA4oJC+g8toT9/K9Xz9CeUNH17OVLnuNyy6+iCfeWkn6oPGce94spgzLZdW8+znv 0htZsasOs3NufS9okQ4aWuJT20PBFurq6qmvr6O+oRkTsEyND5+7n7MuuJYPtzYxfMIUZhw3lmj1 Jn503QXc8b9PEjb7M2tCAAI9FqFiTxNV5WXs3buXPbu3Mf/dN1i7N8is2Zdzyuh9Ar2+YhfPP/8M C1bu3C+sKDvWf8Tzz7zMlr21XaF3VG/j7p/exM0//j2lHXbGTziGIbl+ln/wOg8+9Bivv/8x9c0R QBAOtdPUWE9DYyONjY20trezY+3S/2fvPOOjqrY2/j9T03vvpEESQu8BQgdRFKQpFrBjA0SsCIpi QRErAiqIgo2q9F5Db6ETCKT33ieZst8Pk0wSUgDFe/G+83ya35x99tl9r2fttdfit99Xsmn3cQrK qwAw5CWxbuVytuw7TanmFv3XaFKJOX6OEq2KlpEdie7Ti1YB7lzev4JRw0ayNTYVg+HGhvB/dzYZ ibWelPMxTHpkJDO/Xo+NVxDRfbrjbV3Bb1/O5P6HXuBoYomxLI05MBLGMhakXODj159l8jsL0Dn6 0qd/fzpHBlOaeoblP//EtsMXAChJv8iHrz/PSzPnUSBzpc/AoQzs1Ymyq3uY9OxTfPbTJjTVNc+/ eoxXnnuMdz7/EZ2NLwPvuoe+XVqTcXItEyY8wbJNR6ii8TEsAOReZJ7cxfK53xCXkWd6dnrzSpYs XsrHH35GYl6J6f+DW1ey9OffqbKyRaqxMpVkyKoSmfLYo3z9216EpTMB/l6kn9zO8w+MYv3J1Jqv gRCcj40hJbsYzxZh9IyOpkPblrYBlrYAACAASURBVFTmXuWtiWOZMm9tNdfWUZiXi0YPQldJTlY2 2TnZ5ObmUq4xhj/2joji8YceJLD6pKusIJ3vP5jC4y+/T6HKmZ79+tGjQwSGggTW/v4jK7YfN28Q Zty5GPXsPNHl0R/F/0uUxIldv80UyfGx9f7OzkgTyWnZTb5mMBiE4fo/q0pFcsI1kZpd3CBtY7+F vlKkJV4TKWmZ9dLPmDHzjm6yioIkURC3VmgL44QZZphhhhn/ORw7dkzk5+eLwsJCUVhYKNLS0kRq aqpIS0sTz765UPR9+bDoM3aGWLTiUN1NyLhFacrFzJGhQq5yERuT9EIIrUg5vkzYySzFV1uTRHH6 SdHGXiGGTfteCCFEQVaymDggQDi36CpOV9RkphNndv8iWtirxOhXvr6udIXisxcGC2vXYLFwe7wQ QoiTW38VrSwQ9zzxfnUajVjx9RvCAsTgR6eL5LrbZUWWWL12pdh7Ol5kx24U/SPchEvrIWLLqTRT El3OBfHMsA4C60CxYG2M6f/F0x4QTiA63fWI2Hz0qun/XYumC397SWDtJ16b+5PI19Q8SRcP9AgW ECR2nb1W/V+OGNXJW/h1ulecTCmrV7OU3fOFowwx4q2fRalG26RcIIQQ5bu+EhKISZ/tvj6BKE07 IVraIpxb9hOHUzS14kBxopg4KEwg2YmF+1ONyZsZB1kpl8TYHpYCpa3o2n+oGDJ4kBg0cIDo2DpY AMK3011i08lEoavzzqENi4W7pBIjpnx3XW45YtG7E4TMMUR8srqmTbVi+dypwlZC3PPETJFSXFua qvjdYngXXxESNU4cOJvZZBkXvT5OeDp7ije/+UMUaIzva06uEe39HUT0I++Ka5mlQgghyo78KkLd rcXgZ+aJtLxyo2gWs1R4O6jEfVMWidyi6naqLBTp1c/rzYlf3hJqCTFkyhJRUam9LfOsvLRQPH+P m1DbuYvNeXX7sPp5YZb49OneAslRTP9uR11BUKz5fIqwkMvFgMc+uOF3YtZ9J1xBDH36o+sErVyx f892cexishBCL376aJLwdPMW7y3dXj9d9inxQM8A0SJqjNhzMU8IUSU+fH648PALF4s3n6qXVHN1 h+gVYi/ajZgqziYXNSXcCiGEWPvxBGEDYs7aI6JMb3w0/YEuIsDXTQDi0w2nRHn14HrjvhAhOXUR l3Jq83yxi5OQJAsxdspscTax0PT/nm+eFzIQ0c99ZZovBoNBZGek1S+GXidyk2JFdJClkDl0Fqmm BxVibKBMOAcPb6ro9TrqyuldIliGiBj4/PU9LE7EbBe7j180bypm/Ndw5syZevt5Tk6OSEtLE2lp aSImJkaYTdxpaLrk6uFV988GTmHqa7ernUworfENaNHIew1jnAshkGQqvPxbNGJyZe4HM8wwwwwz bhOq9xS5XE6//kN4d80Cdu88ydDxkZzfs4cyW1969vJDUammZ2cv1uw/ADyBpjSTo8cT8egxkjbV Jr76khzO7FxDgtaJB/y82bltE+WVekDCQm2gyt6PsrxDnDh/CgYENShKVepFju7ehvDvwYQnnsTX to6zKAs37h8+CoCVX37HsfPZPPbxwwxs52XaZ+UuYTz04Gi2bHuD/SfOMPzuKDyUgNBRhhuTp73E kM6Bpu/16t4FFycHfHs8weTHx+KortnnPenZ0Y8VB2PILq1EAPn7V7PnUhYdH+xKwoldpMeCQQhA hr2VHbYKiX1H96HVjgC1opG929jQhaUVxnPpipLr5AsDcdt/Ja5E4oln3qCrj7rWKa+tL++8N43v tj3Bz8tX8EzPl27uHFgYqNKUUy4zXr+zdvIiqpsDqcknmDhhPO/M+YQJQzrf8pmyLv0sB/ftQRfU hyeffAwf29q78Uq1Jba2togKQ6PyE1Ty+ydTeWvBOqKe/IAXHxqKg/o2CDYqe2wNaRyNuUzcpUvE X0sgu6AYgyYVAWTkJNY6NPuH51JRYSa/rdyHX7tRvPZk/1o5UFISPfo5Rvy0mN0HNnCs6A062zdv 3iIBBdnpnE9IwdXGGgdHB1QWzvSMHmCcMynHOXxgHzrnEGzQsH3rJjRVeuO4tNWitPUg4dRFkrMy wPo8MUdPYevfDX1BGls3p1GlMwByHO00WFq7cPD8SbLysmnta9dk/Xr06IuL08/EHLrA+AGdseI0 63fHM2baW2z9fCZrV+7g0V5hWNoVcuBYOqE9h+OmVtYbl8K6A/M/m45zndP56EcexP6Fb7iSmVhv 3ri6OnHh1BEuX4knLu4y6Tk5FJdoKJRUqKoySCwBb1soKSigygAGqqgALJuUnWvM7PUgQVlxHqfi k/C0tcLB0RELlSUdogZcN27NMOPOgpmg0xTxrp310g1W7Ma9uzf9XnOLgVarNXeEGWaYYYYZt5VV yORy2vTrh434kph9O+DRCHYePIprWG/aWYJOWNCre0+WfHWAo/kCh8SjnC204JF+vUw5lZZVcj4u Hcoz+f6jyfyEvg5BMzqFiozqjre9TaMlyc4r5mpSJv7+PfENCGhiP9SSkZZDMX54e3kb7+HV8RTu 4xOMt68DiVcyycvW4+EtN9WyvKyivoBjqUSmkKOpKKWsvBwcVaZ8VA5WyJHQGQQSEHs2CUmm4OCa Lzm7SVHfYzUy7INa4uPjiVz21z3qnzqTCDIFbdt2MtW92kc1lkGdCQAun0m4mdzQ6/R4hbRnRcxu gus+Kc/nz2XfMGXaDGa+/hat226is6f8lsqalpFLYnIGwUEd8fSu30/CYDB51m5IzuHI6m+Y8emv +PZ6nA+nPoqHnfK2kKCitHN8NnsW85dvwmDtgIerCzY21lhQhkGA4T9GsgxUlWQQVwAtBnfE9rrx qVKoCW/dnvXbs7lyvpTOPWwaGwwgSQSHdeSRkV34etN3DL7rIAN6d6V1ZCRhYeG0Dg/D38uF9MwC MrJLybl8kY+mP4cCQ51sJCzUStq064GLrRUJCRcpLNFy9exGZl47iPy6tFaWKlpHtsRGrWx2rXCL 6kGQpyuxR/ZTWfUg57etIcngxl1jJ+CbuIFXNqwlrfRpbNP3cS5fw5g+/VGrVA3qWFJWgZO1Ze1I sXDBAdBoDaY0QlvMmu+/YNYnX3ElW4e3rycOtraoVQryC7VIMhni1icbSBJunqE8PqE/H/y6lgED zjO4b3ciIyMJCw8nvFUrQgO8jJ7v+WcvRphhhpmg/4VJbNwgjZuX/r/szFECwiIijXfV7kDHkpIE Jt/twuz50gwzzDDjX7LVIUlyLH270ztAxb59MaSUPcKxYxfoMv41ozBgYUGH3t2Qfbye7VuOE5lw AIOdE326965DCwVafSXW7oG8tWA1gwPlaHT1T1IlhQoXN68mSapB6JHJQC6vyRNTiDMjidOj0+tB KUNZ7XCqrgCtUMiRyeXodHqE4ToPaY0QWQnTld96JESSUU8s16OjskLDvVMX8vzd7bBWSdedyApU Nm5YqVU3bOumUKXTggRqK1ndbKuvlCtQyUGvvcm72ZKEQa+jqBJQ17afZOXEPWMmcPnQdt5cd4X9 +07ReWynhiSnGVai1xnQ6fTI5TLkspsrC0DC8T+YOv1jNB5dWfzRNFp52d9aHLZmsOTtF5i1OIah 419i4oRRdG0XjpuDLRhO4m3bDerUsDGFwO07KRUIvRYdoLKUNWhKSSahVCoxGAR6nbZJYU8IcA9p z6tzv8MlZBE7D53i2N4t/Pnzd5RoVdw9YSofvfcmtgoJjaaU0B538+6sd2jrBpV155wQyNS2BIW0 IGH3ATQVxXS+ewJvTXmaQAdhcnZXk1ZuaU+An8cN1opg+rTxY+fWU+SXF/HH+i14dx1CqI01oaPG MmPBZHafyyAv/gilOjui+7VBqZLfhJpQIKur7AFSjv7JI8+/jUPrgXz5yVT6dW9PgLc7cuD9CW2Y taKgwbC9IZ2ubl87Nz8mffQdNv7z2bznCOeO7GH72p/JL64iasRTfPD+2/Rs5WYKK2mGGWaCfsfU 3gZnR2uk0suUZVZh0Ov/60UaN7QNZWnH7sz2kmToy7ORhBZJaWOePWaYYYYZ/wLUnNPK5bb0H9iJ rUv38+emzZxOVzGrd3V8KZkax1Y9aW2nZcvWDRQUnsLJLZie3R1N+VhaqAjy86RsayaVVUpaRkTc Ujkc7Ozwdvdg9+UMUpPTwdurltiYyJMFzk72KLQ55OYUmPhfDc/Lzc2mIK+AAA9HrO1Ut0eBAYS0 8EallEhPK6F1u7bYKpoj4U2TvRrP3YYG/0sE+rqD3sDVuETo1qZOPgJdbgIZevD2c7vVzr2u/QCD AUX1yaChuiQSIBNaDNqq6xi6EoVCXo/AO9hZ4uJoy7nsHAoLCsC7dgxISqXR+W2dNySgMOkEr788 nQtlLnz1zRx6RfhWq3T+JveRZEAOf2yKBbdefPv1R3jb1CGDmor/8HmBHKW1C15yyE9IajA+tVot KcmJWFja4Van3RphmQC4BbTh9Q/n8zoGki9f4NyZ4/y6ZAHLv/ucgJZt+fSRELzcHDmSWoqNvTut IpoeHx5uTjg72HI5qwR3rwDCA22bVjI0MYZr1oqoflHYrfqOg4e2smrnNYZMfwdrKxX2fYbSPug1 1q3eTkb+DlT+XenmY2UMJ/wXOnvvn39QgcRbHyzhqWE+tSU06NHqDI2UzwAGfQOFU7361Hlo7dKC F2fM5cUZkHHtEufOxbJh5Y98ufxbPnALYtOCqWZyboaZoN9pEJbehIZ3pqooHn1ewR0xR8sL7+w2 k2NA6RSO3NrbPHvMMMMMM/4VDN24uynkcvr1HYT+u4Msnv0VGscW9OpZKxRbWHrSvYsfX25dR4U6 Bb+uY2lhPN4GSUJt50iXvgOw/nwDS77+kH5tP6ZNkFe1cK4jMzmBhNQMbNwCiAzxa1AMW39/uvXq xoItP7F61c/0bD0JD1s1ACW5qcReTsUrsBXtO0YS7lrBrj27uPDA3YQ7K6urUM7uPdu5lq9iVPsQ vOxvT/PogRZR/egY7M3WXz/j50EtuX9gT9zsjbdcy4vyuHblIjk6G3p2ikSpaPq00MrVGLbp6pXz VIhhWEqgraxAplTTsV8/bOXfsnXNYqaN/QJXi2qpo6qYTcuXUoiax++Orkefm1MrSJKE4jprZU1p IUdidrNqbyzu3h1p1zYMAJXKCjuFIDvtCjmAa/WYyL5yjrPn4kFRKw46+QcQ0TqcX344wM4dW+gW OhZrFZQWFXLu0FGupmSjcKttg6qiJD6Z8Tp7Llcx/culPNyvjYlO3R7Lcz16uYSkkigoKsHbxtjG Bk0xsbsPU6HT1WstSZI4uuMXTl4pIrhzf/p3DLk9p+fVnWJt782gaC++P7WNNaezuL+tu6me8Wdj 2HH0Kn5dn6BTUNPzUUJPTlYGaZllhLdpiUqS4RfaGr/Q1tjrC1m3+SXysrNQuN1Dt+7dWfzuzyz+ fgGhb00ixMtI/A1V5SRfu0xybjmBLVvjE9mBrh3bsW3JWn74qTOuzz1iCnmo1ZSQFB9HapGe1hHh uDjYNrtW9OgVjbf7D3w7ey7ny92Y2681xqnqw4NDOvL69uVkZpym7cgHcFCrb3LMNoRBJgBBVWVJ vYaOP3eY89fykMmUdXQ1CqwcLalMzuB8no7OzgrAgKZSj0Vds31JQsJAaXEuF+OyaN0hEks5eAa2 wjOwFSFeNqxdvoWCrGzz3mCGmaDfceS8Wtum9u6D2ruPeST8jTY0wwwzzDDjDl+vAUmhIKh3P9x4 h9jzZ/Dp+QztLGsJuKWlJdHduvHFxp84YeHIpH618c8RAklmSUjUSGY+tYXZy1Zw/+gsnnzoPvzc 7SjOTuXQnq2cTSnj8bfmExnih0EY0GkxmqwDyJ2IHvYw47ft4rfv51Ccl879/TqgqCoh9sA2/jyT z8RXZvHqyGGMHbuJWUt+5q3XrXl8zEBsFHrO7lvLFz9tJ7D/eO7p1RV1jZCv11GFtjrMVt1KG9Bq tQhdwxM3vV6HFi0GUX0WbBfJ9GnPkTfzI1546hmOPvIAXdu1RGmo4Or5k2xcuwqf+96mc9vwZgm6 fUR3unpbs2vlfD6MsCfIRUlaajkT35yEc7thTH0wilnL5/PSLD8e6tMGtUxHXOw+Zs5ZSUT0A0wc 2bea2ja394JBrycvM5XfFy7npEqDziDQaspJjT/L5k3rOZfnzLRJT9GvlZGIefgG0KW7F7/sXMnM d0IZ2tGLrKTL7N22kY3b9oJzBMJQfWJp5cfAe0ez5o+dfDPnHXLT4ojwtubaxXMcPhjDybhcwn0U 1afben6d/yFfLNuBc9dhyPKvsWpFCpVavTEsnxa69OlHWIAnCIFOp0WnM9ReHxAGtNoqdDp9nchb xn7T6Q0IYQA8GNa/HQd+3M37n37F8J6RqNESd3IPq9aso1Ar8NTr653q/zz3Ob7cWsTQKQvo1yHk FhUFRvN0bZVU/3S+2hbazsGF8c9PY81jrzP1yaepfOtZPO2VZCddZPmiz0lQteaTZ57FuVk5Sc/R vX/yxlvLGPvCU7Rv6YeNpQWaolR++3U1wi2Czp3bAiqGjBrPM0ePs2TJXNKvxTF6WF9cbJVkJ11h x8Y15Nu1YfYHH+LjGsjDE57i0qU4vv14JvHnY7lnQDfs1RJp1y6y5Y8V6EPu4es5M5sm6NVrhbpl FK29nVl55Aw+A6fQ2tXeFJf5ntHjmLn4KS6Ww+u9+6Kqvn9eU029TgtabSN3xwVag0Crq7VW7dZ3 IA7z/uCHOa/RwjAeB5VEbto1/lzzKzsOZ6JXe5ryUakt6DWwPz9/vIHXpkxn/MBwKsuL8WkzmKE9 Qq+n/iTGHeTh+95izEvP0yUiEDsbK7Rl2exYu5w8a0/GDujNX9YsmGHG/xeC/s/eGWpMSWiejf++ NqzxlFrfOc31ZRHVwqa5h/+dSp5/XPHTSGSGRv8zw4z/OYYuQ+kUycNDwlifrKTfiAEmAi5RfQ99 wAACvtmJa1BLBvTsVk/wFgJsnX2YNOdbrDznsmLbfr7//APKNFpUFla4efrSY9B9RHcwui2ztLEn JDwUP29XUzH8IqJ4+4vvcfzsS3Ye2sD0TcsxyJQ4ubjTrd+9RLUJBqU7T056nYoqwbKNSzm29VfU ch0lGgjpMpy335lKp1B3U56OHn5EhLbCyc6qfp1VtgSHhmHw80B1Hal2cvMnIigcByu1ca8Q0OuR N/jU0oVvf1nNkS2/sfG3UgzIcHB2wzeiH2OGRqFSyptfz2wj+fj9V5n17R8s/uRttEKOk3cPnpw+ CUmy4vW5C8g1vMqGHz5gzy+O2KgN5BWWETloPFPf/ZAQ+xuvgQqlGv+QSNyzi1j69ktoq/tPkmRY 2tjTomVv5s58hCcfuddEqryCInhy0nQuzZjDj3Mm8R0qHO2dierbi+EPjObEtXKc7axN3+g8YDgf zCtm3tffs/mXhfyhl+Hi25Jhffqhooo8gwQKCyCRC6n52Hv7o8o9y6ezjpkc74GB4iL4+JeVBAd4 IrO0I7hlONa+rqgUxpLJLO0JDYvAx9sFhbzaoaGVA63CIvD3dERR7ZRv4huzuFQ4i/Xfvc+679RY KuXYewYxZvQYdCs34uvjhqxOmwW06kTLhGRa+rvfMvmSJDle/q2IiJCwqdfd1d7slZZ0uOdJvpyZ wgeL/2DSUxNwdrSjtLgQa88I3nn3RZ6/vyP1vMc1gBJvT1/cLfL54r3XkKttcXWypby0BGHpzOS3 3uShe3oA4BPZmxnzFuH2zTds3n+CebN3UanVY2Vjj7uPP3cNHUpYgHE+hPYawex5Vvh8t4Q9R/bz 0f51VOkFNnaOePi24v67B+LjZn8Ta4UTdw/uzqXccoY/eB92dramR569hjKoZzf2XipnUO9g1CpZ PZbrGRRGkAhC1aDuakLDWlFZfQdekqDl4PHMfP4gC9ds5cmHNmPv4IjSwoaOvYbw0FhbjlyCGpcN KgsrRj/1JgcvlXBw33Je3lyJk0cLJs/u2Ugl5Njbe9DSC77/ZAYL5VZ4uDqg1ZSjERZMmPYGU8YP NdZJMvNzM+5AjjXq2XkiucyZIz8+ekOBualnRjLUkDzdqtArdFUU5GSSW2bAw8sbOyvl/7zE1JBw 3t5Qa7dCVu8sYtv4eEKSyEtPJLtIh28LP2wsjJrbnNRr5JYY8A/yx0r1D42bv0HizNYGTUNXmsfV 1GxsXXzxcLauJ2T9c8RfUFVZxrUrSSgtbQkI8kNu7goz7nAcP36coKAgZDKjxFpWVmYa17Pnr+dS ZTtE6kYeHDmUp0d3a0zqxqDXc+3CQeLTNQSFdyTE16nO8iqorChk//YYZPYOdOzdC/s6HpRqvHfX TKOyvGRiz8ZTVF6JhbUdwS0j8PNwMH2xODeD0ydisfIKpWNk0HVrqCDp4mkuJ2Wgl6vxCw4jvIWn kdYZBDKZhKGigCMH9nD0zFUqdDJ8AsMZMKAPHg4W1XuEMa/US6e4kJBPWMcO+LrVufdblsOhE2cR tt60DQvE2qJ2b0i5coIL8blEdovCw9EGGcKkqECUcT72HGnZBeiFDDfvFrSPDDGR3abX89oyZSec 43RcKgaZEnffYNqE+ZveR5Sxa+Mmzl1OpEwrJyA0jOj+Q/Cyk25qr6jUlHIx9iDp+Xpksto1DUmO rZM74RGtcbSSN1RiCy1XTh9i+/7jlOkkgsO7MCC6C7r8BA5fyKRV60haeDjWK0NJTjInz1ygwqAm vFMU3iWxPDR2NJfdR7J4/ie099Zw9tRZktLzUTTwKCfQVgkiOnUhwMsFirM4fOoccscAIlv6Y6VW oC/M4ODJc1i4hxAZ4ouFSo6uII2YE+ex8w6jdYg3KrkEkkRF9mU2bN9PUmoutq7edO49mA7BVuzZ fgCFWwu6RwYhr54bl0/t5VpWOR6BbWgb4nVL+69epyXu9D5SCyTa9+6Hq6pp2STh9F52HTpDVn4F jh7edO7Wi07hfo3LMHVliWq5uSDzGgdijnA1OZVSjQ4nF1869uhJ59YtTM4T6865zKRLXIpPoaxS h52jG+GRbXC2UTYyPw0kXznPlcQMNFoDji6eRLZvi63yZmQSYz5ZSec4czGVVl174+1oZZwj1XWK P7aHK4UWRPfpiJVSWU94vXBwB0ll1vTp2wULhbxWpjSUsnd7DAYXf/p0aFVH3tSyZ8NqYi+lgMqO 0LYdGBzdmZRzB4jLqKJL37441j1OrCrk4IGjFFUK7JzciYiIwMFa2Uj7QkVhGvv2HiA+MYXC0grs HL1o06krUV0iUJhlMzP+izh79iw+Pj6m/Vyr1VJVZfQRkpCQ0JCgGzdHPecPbeVEfB5dBo4m3Mui dtwbdBQmnmHV7jM4B7Tl/v7t620AmrJiYjatIl/hy30jBppM0G5KqC5KZ+3Sr1l+ooTJr8wgOtLt /0UnXTi8i5QyK/r064r6n1goDFpyU86yeusJlHIJnd5g0garLW3w9AukdWQkXk5Wd9xidWLXRk5d zKDnvfcS6uuGDFgxZwqLd+bywYKP6BhkvD+5fNYz/Hioki+WfEK4l+s/qjjQawv4bfEKyuV1KJ0k Q6mQIwz62vYVAoXKgojOfegS4WdejZpA0ZHVPDLrW3qPn83kkR1RKmS3p6cMekozrnHgfBJBEZ0I 8Xao149ZKad5YdxkrCP6smDhO/Viqpphxv8eQb+B4qpRBWTjJONGwn2NWXDjlk3NEBdT3jSbhmqz 9MbS1XyHRhTOTR421Kn7jfbAG++RtSS98TL/nbxvnlBcr3C/lfckSUJTWkhWdj5qBzc8nKqdwurL WTX/PabM/IqBk+fy6TsTcbpZcaGR04ebtaBqzFKu2XrDX7bMapiusfEqbnJ83r6+vpk591fS3no7 0PhhXHMHdZKEVIc032qfNLWmNFfe2zmXzDDjv0HQFU0Jtmc3zuexDzfxwrchfPVUN5NuWV+lYe8v c3h6xgrsI0Zyz7lVqKSaYCaQk3Kap8Y8QWWncYwYMfDWBOqqcuJjD7Jhex6jHn/5/00nLX17Ikuv BHD28lbc/4lLB6KcK4d/ZuIz80BS4eZij95gQBj0aCqrsHLyYdT4Z5g86WlaudncUddxVn09m4/W Hma+XzhB1QQ9/uR+tm1PYUrRDFO6uKO72bG1nPwyzT9eJl1lJm9PnkKmSomEcVPSV5VSXu0c187W FoMQIASWdk488853ZoLeDCqz4lm/eRu23V80ttvtgl5L0r7fefjl73ll7kpeG9e5zkOJqooyjsbs Q1vmg8rcDWb8P0CjXpslkxtwGvPp3Jj82rxQe6N3mrdCqknX/CekOt7fm65P03lLzeQn3XIb3kz9 b8Y67WbIws0SiuvT3ep7+QnnWfD1Qi4WK2kXEYqdpZysa2dYtWoDssC+jL27n5Gc36zZX3Nj7y/8 d6vt81fbrfH+lG56fN6uvr6VOfdX5uettEPDRzX1lZp+1kib3Hy/3rjMf2W8m8m5GXcyGqWDcpmc QSPGovhwE4f27ICnupniBFZptew9cNSYMOs0BzOhj0f1xNOXkxd/lEQsePje+1BSExP0ZjXSEgql Gku1BXLZzWvCRK1qrclFsTkz/cbTN7Xn3IqmspnndTT2xdlp5KRZIVfcqtb45jShIKFQWAAK+oyf xMyHBlFeWYVeV0VW0nlWL/+ehR+8i8E+kEWvDEdqRtPdnHb5n9BYDnvyZdy6pNIrsoXJBFmhUgMW dUz7QKG2AMlQax59E0LDX9WeKiy8mbd0KRVyWbU5pJ6ia9t5+s0fCB36KB8/eR+VWh1CCBRKNcGR bapbihuOzxsNypvRyteouG92XP6dE6OmxkODcStq3fc02EhlSizloFLIkSRZ03W/hasakiQhyeWI imLyMtIpq2gYrkWlsiXACTLcqs3bb6F9zdu6GWaY8b8MSxs7bK0UXNm7n9MHtqM1gLWdExH9xvDk s8/Tv0to9YpvXg/NMMMMZa/bbQAAIABJREFUM/5xgm70IyPDLqwPnVzgTMw+cgGX6lidVRUZHDme SIfe/Uk6cZS9e8/RZ2xrAKrKy4ndvw+5nSO9e/U25Vgj8BZlJXLmwmXyi8pRWNkQ0CKEViH+yG+K HAgyki4TF59ISXklltaO+AYGEejrhVIumchPUU4qFy7GkVNQjsrKlsBW4YT4utUjkKKimITkFIS1 B4He9qRdjSPuWgpVQoFfaCRhLdyRSVCam8bFuCvkFJahtnGiXadOOFsrjXFO65LnymLOXbhASlo2 lUKGs4snke3a42Apa5q4ShISOq5euEBepQxkVZw+cRqX6h5x8gjA173WkUdJViJnLl0lt7AcCxt7 /AJDCGvhaSrLDYkxAiQ1/m260HdAXcuGEbRtYc3We6dy/sRZYDhIEgathuz0VPI0Ej5+LbC3lJnq qykvJi05CWHphK+fN+q6ZoFCS0r8JeISUqnQgptXAB5OllSUluHg5o2HqwMVxfmkpmdQptE2YoZm wNbJC29PFyyUciK79sIrXIubhzO3ZPgsSZQVZpKYnE5Obi4lpRVIchX2jk4EtWqDl5PlLSls6ipV 5Ap77n3wgXqPSs+W8PSbS/Fo3Y37RtzftMJHV86ZU6dIzSpALynx9PUnLLwV1ooblKWu+am+kvgL Z7mWmkWFTmBj64C3nz/+Pt5YqmR18jGQnnCJS1cSKS7XYmnnSMtWEQR4OZvqbhrDhioSr1zkSkIK pZV6bB1cCItoi7eLTbPtJEkSuZkJZGQV4hHYCmdbS2TV2ryi3BSSM8oJbhmEpUphUvxkJ14kvVAQ GhGKlVIB1fF65UoVSknDpdNnSc7IwyBX4xMYTusgD5PSQQDoNVy9Ek92Xh5FRaVU6QzY2Dni6etP eLCfManBQEFaAueTskAmIyv5Epcu2lBZpUeptiGsVSAyuRpbDwsKnexqBc3qu3tJF88Qn5xBSaUO axt7PL19CAjwx0YtR5g9vpphhhn/wxCAY4tIprwzl+HjE8gtKEZnADtnTyJah2GlqJYqhPkU0gwz zDDjP0LQa4RoSeXOkOgwjv55nP1XtIwIUYJBS+HlGM4WWjH9uTfZMHUIe/fugWqCXlZezr4DR3F0 CSaqu4dJgDfoNBzfsYqFi3/l5OVU5DKJKoMee5cAxjw2kUfH3o2DsimeJVFZksvOP35h8a9rOBuf AkIGKHDzC+LhZ17gwZFDsJfrOHdgOwsXLmDf8YuUaWUIIKBVe8Y9+RxjhkRhZ2E8g9VnXGTBJ/PI sQoj0lPO/l2bOXE+njKdkojOfXnllck4alNZ8/Mydhw8RVpOAdZO3gwe/RQzX30SPycbk+IhN+Ek P3y3mHW7j1Gh0aJDj1Ynp9vA+5ky9UUivB2QSVITB7qlfDj5OfYmlUNVItOefRqVZKzzsGc/Yvr4 PgCc372ar79fyp6jF9BhjAfrGdqR8Y89waMj+6GQxE2bpYsGJsQGSktKASXeQf6mf6uKstj802es u6LklRkf0yOk1gg4O+kc8z98D23wXbwxYxJe1W2hKcpky6qf+H75Gs5eTUOSK3Fw98fX3YaSYonH Jk1l/Ig+pJ0/yMdfLORkfHatR1yZHLVSibaiiPbDJjPtmbEEuMrZ/uNc5q+7yswvPya6TfAtDe6Y dV/xwYJNpOeVYtAbT9cluYp2UYN59qWpREf4IJNJN++Yr6mTU4OWco3Rvl2vrWyUmUuSoDjjCt/N /4qVG7aRU2r8pq2jO0NGPcoTj40j2LVpHwA15LEkN4U1Py7g57XbSCnQIJcJdFqBo3sw4yc+z+MP DkYlSVSWZLN19TKW/r6BhPR8JBlotHr8W3biiecncXefDlhWWyCU5yWx9pel/PLHDjJySxAyA5Va Qcv20Tw7eRJ9OoSiaqadrh3ezOz5vzJw0hdMGNIBW6Ux0ZYlc1m0/jwvf/kDg9r5oqxWtP3w/nS2 FQWw/Lv3sLI3LkGSTCLn2kk+fXc9f27YQWJGNqV6Fe279mPSjHcY3rmFSVGgyzvOc0+9THJOAXo9 GIQeuUyBe1AbHnz0KZ4cNxi5rpIj635kxuLNYKhi/bI5nNlqh84g4RHQjRUrPkOhUOER6EuVj2NN 96Ipy2fzzwtZ8us64rNKkCsk9FV6bJz8GP7geKa+OA5Lszxqhhlm/E8zdKPFkrW9MxHtnBt/bo56 YYYZZpjxnyPoNQxELpMxYNAg3ln9Nbu3H2ZESC90VVpO7d2PxiGUQQO6kdsugB8P7EPDC1gA5cUp HI7NxHvgeMJrvMPpqzi/fy0vTZ1GpmU7HnlgAv4e9pTkJrNl3WremjoZvaULL43s2ngJtSVsX7mQ F6Z9RJVzBA+OGY+Psw2FWcns276erTt30nvYEErjdvH6pOeJSRXcN3oM7UK8KMtJZNXy5bz64gXE N98xYVhXo9l9aQ6njhxg54VN+AcG0rZ9G8Y+0pvyjPMsW/4zr2ZcRaYpwsbFh24D78PZRsaBDStZ POcVWnXsynMjumOlkBDFSXzw+gssO1zM3XffTZe2IVhIVVw+vY8vPptJWqU1v899AXtLFVKjFFpB RKfOHI49Rk6VNe07d8FaZiToLbyNnnVz4vYz5fmJ7Ei3Z+ITYwn1daU4K5Ed61by1BPH0duu5alB 4Tdh0m083c5OiOPC2TOUaSox6LWkxZ1g9W8b6THyKaY8MayWc2rKuBJ7iJ0n1YwvqW8eXFaYw5H9 26kq8aeiJm99KVt+nc/zr85F5t2WUeMew91WRV5OKnu2ruf4pUx6Dh8HgLWjKxFt26NyKTTGk5Up UGnzWbd6NXEZxbQeJmFlaVQIJF84zq69sTydX3zLg7u8QktgeHu6uPvi4eqIzFBFZtJFlnzzOWez FexfMRsXKzWS9M8didaY/1WU5LDwvVd4fcE6+o16guFdI1DoSzi2Zyufv/kiybnlLJwzCdsm788B 2mJ2r1rEK+98hk+3e5kwqif2KkFaUjwxuw5y/OhhRj44GFd9KZuWf8kbHy/FsWVvHpwwCjcHC7KT zrPsx2VMezUXm0VfMaRjC6gqYPnX7/HBkh2EdhrAw8M74WQtJy3+FN8uWsLUrHJ+/OZDOga7NzGG wd9JxYnDMRS32Mv9UWHYOlkCmfy8/Hd2n83Ccd1+okJHG72sVp5n2Yp1lHWbVOsQUYBcrmD/2gXE OTvSoWMUPQbYk5dygWW/LuNygSXRuxbiULNa6TSonPwZ0LkP3p7uWKklCrPT2bfhd158/jS+rQ8z rLUdLj6BtAn0JD49H++AMLq18UGrA0fPlsgAKzsnxj0znULHjtVrVQVnd/7GpGkzsYy4i0cffwBX GyVZqdc4evAYR/bsIPfFcfia9w0zzDDjfxjSjS/8mo2IzDDDDDP+SYx6dp7o8uiPogEMOlF0eYNw ANFm1NtCCCHKSwrE5LuChV+/SUIIrfhj9qNCaesvdqYLIUS5iF3/iZBhKZ6at8GUTVFGvHhtdAfh 0nqouJhf/xM5l/aKHoFOosPdT4siIYTIiRefPjVI2Pl3Er/tTRRCCJF0aqsY1s5ZOAX1FKsPXK33 fmb8MbHv8HFRWJIv5k4dIxRqR/HqF6uEvk6a2I0LRLirSrQfMUnEphQLIYSoOrNJDGnnJ2z8O4lP f9woyrQ1qfPF83d3FoC4f+J0cSw+25TPmRVzhKc1ov/Tn4u0vHIhhBC7vnlOqG29xeerDjZovtkT egsUPmJPQl698tS2r0EYDMafL3axF1h3FmXXJdHrtGLBC9ECLMRbP+6p9+zi7p9FsD3Cp/M4USBu AF2ROLp6ugCEnZu3aB0RIcLCw0VocICwViBAEnc/PUtcSMszvVKWelHMeKCbcG0ZLdadrKiX3aXD 60TfltYiaswL4mp1HZJPbBRD27oKj7A+4o/D8fXSr543WdiiEm998XuTRTy/Y6lo28JD9B45SZxL ri3HlxMHCRkeYuXeU6b/5jzcXYCv2HIqzvTfOyMiBVKQOHAlpXbsFdRtGYMoKS4SeRlXxcN9AwS4 iZi04sb75lahrxJZR78SIImolz5r5HmluLT3J2EnIToPnywyNLWPStPPiufuihAKx0CxeH9idUkb R2nKWfHqyA5C7dtFrDlWWO9ZdsIFcfJUrNAIIZKP/SkGdwwSfR56o8HYiPl9rvC0sxPPfbhEGIQQ cdsWibbBfmLcq1+JquvSrv1sirBWO4g5v24Tlc3WP17cFektnNqPFhcTs4QQQqTvWyC8vEJFoJe1 cGk/RlzNNE7+3H0LhZ0K8ewX20WZRmcs+/pPhbVKLlpGjxMb9sfWGbc54sHungKsxbb0KmEwGITB YBD6ylJRUqdAFaUlIicnQ/z5xTMCEOPeW2N6duWXtwQySzF7eWyD+Xc9NPlp4usXBglsfMX8ran1 2z47SRw9eEAUCjPM+O/h2LFjIj8/XxQWForCwkKRlpYmUlNTRVpamnj2zYWi78uHRZ+xM8SiFYf+ 1fU0NDI/G/vvduVvMBhM6+6tfvufLusd1jMN61ZHlvlfqlfdMXGDwXSH1b+pPmqkfn+1zmaYYcbf xpkzZ+rt5zk5OSItLU2kpaWJmJgY0bgXdwGSJEft05WoYBW7Du0hC7CqSOPQ8QR6TO4DyGnbpzeW b69g375z9Bvhy6n9+5HZO9K7V5Qpr5ysZNZvPIkqaADrFs/hl+IyAGRyBWUFmRSVl1OUFselCugi kxoc5V+6cI59sXkMmTqa+3sEYnJCJUm4B3XCPQjKLu/j6NETuLUbxNAB/ZBReye67dD7GNL/N+bt iOFS3FXa+rQzHsxXVdK6+13cd9dArBQ16R2JCHRFjj3jHh1Hp6DacF2R3drh6OxIfnYKOq0WsGTl qu3ohJyEo+uZdW4r+urwWgqVBRdTi0GXyrGUMrr7OaGSNaWBFlTphdHRmFZgpayNaWrQFfD7qr2o vQcw9dFo6t75Cuk5kgf7z+aDTdvYG6/nvuCbi+LsFdqau7q2pkqnM35FpyXt2kUOrprHM8U5fDT7 HXoEOd+youfUyZMcPJ3DqLcf4t6uQXXGEahUFqhlDWLOmELRxB/+g8efeYVSt658PutVIqrj8v5d 2Nmridm2lphDx7lyNZGs3FzKK/WkXisESsko1f9H7hNrK8qI3bmJYqUz9z30DB7q2vFp7RnC488+ xjebp7Npww4e7/lEk8VRqCywsXOkMvMMOzauwE/VAy8vbzxdHHANCKNmtJ46dYaTZ64R4pbIojkf UlZWYXo/O/4kFcXFxKekkgscjDnCtaRcfJNP88mH76OpMJroK9SWpJ65iKaykPPJ2RToaDTCgBAg yYKIat+CzStPklRYQit/N/5c+SfqgM5Mv6srz324nYPx+QS6O3Lg8GFKtQ706x2BSlU7ZvV6PdHD n+Tunm1rM5a7EN2zDb8e2sq17ErwUBidv6msyT19gOW7YrgQd4XU9EyKysqoKs9GkinJLcw0ZlFV QXG1V39NeWkjJgn1IVMosbF3gtIsYrasoqNLX7y9vPD2cMHa1Y/Orn5m004zzPgPneDqyotITEqi 1GBBC38/7G0sbp9dkyRRUVpEqUaPvYM9KoXc5MVTkiQqE0+xaPV2/DoP467uoaiV8mbLWpaTwsWk LOzd/Aj2df0fvpdtXPty0hJJSs7CvUUQ3h4uyP4VZa/Z7CuJ2byJo2cuUqLRYmHnzJinX6CFdSNW BMJAZWk2sReSkV8X412hssLT1x93R2tTvPI7o9+NfZSVfJWUtFy8gkONFoRA7K61bD+awpAxI4kM 9Abg+Jbf2Bmby4iHxxDq42ZefMww4w6BovHpbVzIZHJbBvTvzKYlsew9W0LP0gOczVPxRJ9egIRt YHfauAv279uHftho9sYcxdGtNdGdauIN66kozSGhHCyKk9myYRNafa25tEwmxz2iJ306RmHfwMmy DNBTmJ9DEc64+/rVIX31F8G0rEKyswvwa+uNk6ujaXE1pvXEy80Dcq9RUFBaj/9rq7RoNJWA0pSn 0kKJAgOlZWUYqksBgLUSSS5hqAm+SgFXkiuBMg7t3Y1apaDu9W6lhRuDBw4kyFb11/ifAKHJ5Eom 2PVrgyP1rdgNOj0tw9qiX7+e+AvZEOzZfHbCAJINPcZM5OMXh9d7VpBynoVz3+bNLxfyhXcEPeZO vMUy68nJzqEQdzw9vas9m9duVo2FzqqpS8HVI8yc9ioJBn8+mf0+vSO86z3/6yhj6cezmPP1EvKE AxGtW+Hj4U2ggwMUXuZKUjm1fsX/WVRV6YiLT8fCxpLg0NDrxqcaa69WuFJJyrXMZvNRu/py9wOP sfXIG3z3wYtsXx1JWMtggoJb0rFbbwb27YWbnYyc3ALytAKrxPNsKU+rE/deIFeoad+nD9HtI7BB T0pmCaXaSq5cOElJ+mX0hvox3KP7RNM52BeVoSlRwLhW9IruhsMvn3HkSh6DI+1Yv+MYnUbNY+Sj wXz15e+s3XKQ0VFBHDlwCFVQVzr7WlM3aIEEVFVoqNTqjcJwdedbqauVNTq9ScS6sGc5r0//iB2n 0gjv0I5gfx9CvP2QlVtx6MhlhOyvDRyljQPRI8YzZNspVn41lUNb2hAeGkxQSChtO3Rn4MD++LlY YvYSZ4YZ/zxKUy6w4IP3OKUJ4L0ZrxPV5naFqjTO3d0/f8mvB3J5bfabtPZzrzelKy7t4+VprzFo qhd9OwY3S9ABEvat4JnZy+j14JvMmzbqf95x2v4/f+L9Oct46N15vDB+2L8iTGXNsr1zyUe8/M58 EsuVuDpYYUCizQMNCbrxJR35V3cx8dl5qGQGSjVVpnBiKktbAsPaMuiue3hgzN3YyaU7KkTtjt++ Ze7XfzDxswU8PtJ4cBWzchGvLtyJfUQHE0HftfwLXv/5DAHdo8wE3Qwz7nSCXiMcK+QyBgwchFh0 hO1b92EjDlJlH0rfri4AWFi60q1TCMsO7iKxsBdHT2cSMOy5enc0JZmRBIV2H82ahVMozC+tt4IJ IVBbWuNqDaJCXKftlFWHXdIj9LoGq23dsEs3Ez75ZuiYVJ1KanxPr/NAQi7p0FuHM/frLwlwdzKd oNfdEFw8nFFIN1EwqbnyiUZFjFsWAoSBqooyU7vXvO/oG8HIhx5j0ZeriT95hBImopJEnc9KN5B1 DDfXAXUaRpIkdEUJzJ31GhsvV/HyR+8xum+betYPfwdZRzYyc/YnEDqcz96ZRK/OkXi5u6CQYMmb F9hzMqde+zYIFXMLYb1uVuNijCQomhEZm2sygSSpadf3fhYtdmbT9v1cjIvn2tU4ftq6nm+/+4mX Zn7I25PGopIbMGDPsIcnM2viPRQXldf7gMEgsHVwxRIdAh1C8uKJKTMYf3dXysvrO7kzGAQOzm7Y KZvqf2PG3aOicXP+hqNHL3HO+gTHsmyY07cL9n6tGNI9jCXr1lHyUicOnkynXf/HsFffnEhnmo9S dSsZipj36jQ2nJSY/c233NuvK8F+XliqFIi0DXz/06a/KLwJJEmJf/uBfPP9ItZt2s35S5e5dvUq qw/sYOGC73l8ynTenTkJN5WZnJvx70Wj62sTliFNOq38D5wWylUWuLh54l3lhqWF8m/VozGc2r6a 5asTeGjKC0aCXnfdUaqwt5JhbalsPK/rvqO2dcTbxwdXJ7sbr+a3fW+5vX3VXD41ln829k74BgTg YGdTrx5NhaG8tVCd3LKl0s3UXZIkROkVpr8xm0THbsz/Yjot3OwoK8qlpV1TORvQFCQTe+oEnu16 89CQTmh1egx6HQXZScRs/J4/N++mSOXMKyO7/a0+bawOfyesp62jMz4BAdjZWpneV1tao6LaYqTm PysbZNf9d8v9dTvXobr1bWZdatAut5LWDDP+tQS9hjPK5LToNhBf+dvs3LoBO5sjeHcYREj1WxZq NX16deWLt9ez9s/NJFTZMLFv7zqcU46VrQch1pCXkojG3oUAe5cmv1ef4xlzcHbxxJVCkuKvUAFY mk4eayecu4s97m6OxKSkkZ+TD65OdSZ/BhnZWeDsgqOD9W1UxToQFmjP1q2XSNc50MvXrxlqVk12 G13UJJAJ0OqQlFI94iNZuBPsDocvn6EAcJRqT5YlhYy4C2eQyS0IbHWzWk/JVIbrF0adppwKQKZS oazmkXJAr9eh02oAtUk7rLawQCGXqDR1kxInJwdsyCIrM70ecQOwUCmR1T2vliTQF7P0s3f5+s/z DJ/0Ps89MABL+e1b/E/E7CW7FJ57fjrjhnXiukjdDVQe0vXqEKmaS9+GVV2lUhAa5EVF6Xni4y5D ZHidelZSnh5HDmqiAtxvmJdMaUlEtyFEdBuCvqKYpOQUTu/bxCcfzObHH5cxZPh9+Pp44kIRWbnF WDq54dTMjQE/bxcsRSoZhTqc3Txxa2YzbWoMC0DZsidt/dw4EXuIZUmx2IZ2o3uI8arE2AfvYt6T y1m7ch2nsjQ81zcalVr91xqzIpmtx7Jw6PwE058eXe+R3qBvarhjuIGAXatQlNOiTTST20SDtoyk pGQuHI9h4cez+PmH7+l774OM7eJq3jnM+NcS8rq/iwsLkCxssLVQ1jPTNQm1prRV5OcWI7eyxt7K str8t+EcMkUJuU4grhfS8SaFfWu/SF6a/RUGZKhUqgZmVTXv6SrLKdHocbS3rf5uM+G/6pTZ1s4W sMXe3r7ZPVNVrRwoKylCK6lwsLE01a+m/IF9H+LXqLHIlKrqiJD161VaVIDGIOHg6IDiundvhqTV /NcsiTM53awkL68EpY0tdhbqOn11E0r9uvnrteQXFqOwtMHOSl3nXUHf0U8Rdd9jKNTqaiGyfpsL bSV5hWVYOzphqcAUKrd2eDTsR01ZCRV6GY521g3at1llB7V1rygpprTSgLOLA7I6edfkI+Wf4Wi2 jjEvTOXhEUPqSwWNjhkJSSYHFHS4dzyfzHrc9ERTnM66n+Yy9sXP+HHpH7wyslujpn9151T9/Gvb o27/6TSlFGkMODnY1UsvDAYk2c1eJhAMeXQy/R98HqWFGvmtLRim7+q1FRQVlYFMgYNT3Tb96yH2 TH1R/W5pUSEaAw3mRs3YqPlCZXkRxeVabJ1csJDV7VcacIKK0kJKKw04ODtVR4+5k64gmGHG3yTo 1QwduVM4fTo4s+zAejY6FRL1XF/TY7mFBRE9+2BRvphFn3yPytGF6OgexolVvVC5egQydkx3pv+w kmlv9mDWC+MI8jKawBfnpnJgz35ySwWjJlwfvsg4QSPatmVQTx9Wr13ON32788KYPqglQFvCoR2b SBMuREe1p0uX9qz+Zhubd+6iZ/goU2z1M1vWs2X3YdpGPU7L0MDbJfIAMG7CaH7a/i4z3ngLi7df YXB0WywkQF/BpXOxbF67i+Evv4S/rVWzmmB7d0eoSmbH0WQe6eIHGCgpq8Tawokx9/dk74IYPl++ j1kP9zblc/nQH/y26zye4aPpHXqTy69kvGdbj9RUlXPlzEG+XTCfbGy5r/dALACsLHBycyI/5TTn zp9kRJe+SICmMI0tGzZwJr6UsHa13w0Pj6B9gAWb/lzF6v5R3NezFYbyIi6fPcaarfvINshRmPYW HZt/+oIPv91C/4enMW/m0zgraVSA+6uwslIjySAl4TKVdKLm9uKV2F1s2nf5Osomoc88ytQPl6M1 OPL2vLdxU8hum62a0tKadv3uwva93/nzl0U8ce8XeFSfwpZlxvPDt0uRO3hy19C+dVRT13WdJFGU m8nZs2exD2hLZAs35JZ2BLaMINBJzo7fv+VKRgXFxQaiunSjf3dvVv84n5bBfrzw0N242xsJcVZK HNvX78Qtoj0Do7vTd2B/Oi/7ncVffoKvqx0T7u+Po5UcEKRePcfmtdtpPXgonSNb3UCb50B0jwh2 rdnJD5lXGPDmszhXC77thj5AG4dv+GTOtxRpPejfLRC1Umqipjcaw2osZFBUlkmaBryrO7Y4I47l 3/6Oro4oIslk2Hm7gqGC2JMHEUQZx3BpMQpru/om9pJERWkxp48fQuYeTpcwX1Ba4x8chr+fO2c3 LGZrWj5lpVrzrmHGvwqSJCEMerJPbueLPw7S997xqDMO8Oe2fSRnFvB/7J1nYJRF9/Z/9/bN7qb3 3ishCaH33nsXqVIVlGIBBQSlKIqINLGhoggivTfpXXqvoYVAKunZbH0/bCokFB+f51X/e32B7N1m 5sycmevMnHOkGifiazdmwCt9cJYJ5XacCjMT+XXZL+w/fprk9GzENraEhMfStlNXmsSHIJgLuXnm IF/9eohabbvQrUF00cSSx/lDO/ht/y3adO1FnUjLcVpTdjK7t67l+EM5Xbv1JtxbWXm5sx+ybcN6 7hrd6dyhDb4uNphSb7L8tzXk2kcR62/PmcPbOXz6Cjk68PSLoPeAAdSKDkAqVOImJQgImFj9zULW Hr4G5PHZ1HfxdXPAqNMS1bA7fTs3LpmHFFIRf+xcx969e7h08z4GiZKQyOoMfnUYgY7KkvvyE04w Z/kO4lv0pV3d4CK9ZuLwphVs3LmfG3cfojULODq7ExQSSZvO3akR5lGxrIw6Es/u5IuVx6jZqjs9 m1S1kIui67qCHI5sXcbuS1l0GjCaaj4WJZibmsCvy5Zz6MQ5UjNzkajsCY+qTocuXagb7W8hPrlp HNy+jgP3xXTq1Al52mk27TzEneR8ajRuSZ9OTclMusb6Vas48Md5UjLzkNqocff0pVaDZrRqWh83 eyU3Tuxh/Y6T1OnQjUbx4VBEkDITr7Fx/Wr2HTtHckY+NnZORFevz0svdSfI3bYkY4oh8TyLlq3F qUpLQtQ57N+7kzOXb1FgluIfEsOAYUOJ8nFELDw9DWqxzfjWyT2s3LCJs5fvkF1gwtnThzoNW9L3 pXYlmXHuHV7PR/MWWtZPv//Mm5kHQRCo1rQ3L7et/ozdejMmY3ndr7D1pFGLJsDnFtfHov5lyM/i xK61bLuYSZc+rxG9f3KJAAAgAElEQVTjJyudw1PvsXnVUlIkAfQZ3AdXUeks+ODGaX79dTUnL1wj W2vAzTuYID83CnPzqVqnBZ1b1SY14SJr163l/O1USwac4oW8VIZgNuAT1YCObVvi66LkyuGtbNx7 meY9elGrSuCLKAyuHt/Abxv3c/32fbKycjGLpNg7uRIdX4+X+/bC3VaG8ALpfZ/cDjFzZPNyNuw8 wI07D0rGRmBwBG26dKdmmGfJ3Qknf2fZ6k1cun6b7AI99i5eVKvZiF59e+GtEZch3mYuHtzMinVb uXorkbxCM04evtRu0ILuPTriqhSsJN2KfwdBL/amkYjltGpWh5/+2MTVByrebNKgjGaUofGrTqwT HLh1Hc/o9jQIk1ouFo0BtZMHfd/4kD+ujWbZR69z/dh2YsN9kJj1PLh7nSNHLhBatwu9BvYBsxmD Xoe2sBBjkcZzC63O8HETOTdmElNH9uXIxtZ4O9mQmXKPQ7t3E9JmCHEtm9Hj5YHs3H2ExTMnkHbr HNVDPclJu8WKH34kURTIxwNfpopvkaXcbERXWIhOry9VrMWEVa+jEC0G0+N7biYKC7UYdYYS616N LqOY/HYikz9dwusjrlC3ViwudkryMlO4dO4Ux87m0eDV1/DT2DyN2dC+Rx8+3/wxE0cM5nDdcEza LCJbDGN0r/p0f/0DVu7uxrTXB/PoYj8i/V3IfJDA1rXLuW4KZsEHk3F6Duug2WQEcx77li1i9K39 6PQGzCYT+TmPuHLuFGeu3qfTiLcZPbid5QEHD6LqNMZ+/hYWznqXzButsTHmcuXyBc6cOU2yDkIM hpKd6NAaTek/aABvTvuG0YP7sqZOVUy5qdy6+4CkezcBSYkiTzi+jk8+m0vCgwz8E8/w8aQJRfnD BYz6QtwiG9CvW1t8XG0x6nWY0Jb6RgMGXSFQiKmM8Ay6QjBrS/zda7TsTIz3EjYtnsKorJP4udqR lXyPI8f+4Oa1e4ARY5kjG4bUM8ybNx9QM/KTyRaC/gIGG7PJAJjRGYyPG6MRRDL8qrVmwtCWTPxm PgMG6WlTuwpSYzaH92xj9dZrdH1jJj0bBpVMXxUhO+UeS7+YxpFUFW2a1CXA1xMpWs4e3M7a0+nU 6z2Y2BAbbOW1GPXOFG68OZHZ44dxZFtzQv1cMRfmcvv6BXbvv8HYTz6jeaM6+NVuz9sT3mXse9OZ OnYou9Y1IMDTEX1+Fjcun2H34bssDKxKrejwp8znln7cpHF9ZizZwgO9jDZNamKvKTrGbhtD23rh fLjyOLKoHkQ4Kyw0uti1w2SgwAj6x9oOwGiwLIoMpqIHlD4M7l2L937ZzJDBw6kV4YMhN4PLZ45x 7tpNzBjR64vcYcRSnKo0pq6nlC0/zKaf4Ta2UiNmsTufzp+K+rFvaXMesf7bT1l1xUT7ZvUJ8vdB KTVy7fQh1uy6QkzdfjSp6WmdNaz458FkIvmPzXw0YwGrtxxGkZuATqLGwU5O4rXNLF+xift6DXNe 71Cy2M1LvcmH48eybOtpAiLjCPJxIS/jPmu/+5Qt+07yyRef0y7Wi9TEa3z+8RTqp8hLCLo2/T6r v/uUaUtPkiq4USfyZQDS71/n29lTOUItmvca9PQiZ9xm+aJZ7NNVI6ZGw1KC/vVctt0SE+nrjKEw D5WDA/rMe6xdtZK9F1NYOv99qgW7U7lHsJnLJ4+R8CATMHHmj6PctJFjKCzA6FEbvdHylEQq5+i6 BZz7NQmtSYqjkx0Zdy6wavkKLqSJWT5rOCq5xbKcdXEPUz/4kP6SeNrUCUYsgmNr5zL6rY+4iwd1 4yNQoef6mQNsXvkTN4zuLH2vR6UGFW1+JgtnTWPTyXS6NlmIRMASVBXISrvDrLfHss9Qje6vjQcg 4945po5/mzV7rxBcJZYALxcyH95m+Zfb2XH0PLNnz6RJpDvm3DQOrF7CxNU3OHrgANkJBzmfkEJG ZgEv6VU0aBDOsplvM++3I7gERRMZ4EpuRjJb9m7m9+NXcPQKon2tQM7tWcfED75ignOYhaALAll3 z/LZtMks+O0AHoERhAd68ODKQbZsWM/+E1eY+/F4In0sp6r0986yYPZMUpWr8FUbKTSasHdyIPfB NdasXM4f97Qs/3wcXo6aSuVYvOa5dWwtY8dNZMu5VOrUroGzRsK53Sv49df1nEtIYc7kQciBnIcJ HDh5DYA7V0+wJ/sWgkiMMqjpc5FKsaT8qa+spCss/245cls/+vYvjetjyM/m8Lrv+ODX2/jXG1xC 0AGyUu/y0/wPuKBsRvNX+uBaVLPb5/cxaexY1h66gndEHEGuai6fOsD2VVe5+/AR/cao6NyqNtrc dC6eOcaeM/dQFMU9Uiql3Ll6icS0bKp3MdKwRWt8gZPbVzBp1kpkIXEvRtCBswc3sHr9fsRqD9yd 7REZtVw6spmVK1ZzMlHLwvf64ahWvPgpwyKZHV83l9FvzeSO2YM61SJQCXpunDnA5l+XcsPgzk+T emI2w5V9P/H6W9O4lmlDfFwkLk4qkm6c4MPVazh1/R4LPxuPvSBg1Os4seVrxk6awwO9E/GxYbjY GEk4s5eNa9dz6W4ysyYNQ2Xl5lb8K3bQi8ieWCymUfue1NqdhoNLEE3incoReKXKlZ6De1J4OJ24 Vj1wLGPWtChQCb4xTZm3+GvqrlrHwWMn+ePQAUyCBCc3b3oMeYOWrVsjA8xSJX6R1Wial42bQ5Fl XaSkXtu+fKNyZOWazZw8d46rZ7SoHVxp2H0Ynbv3xF0MqvgWfDxvAQsXfsXhzb+wb6MIo8mEd3A9 Phoyit6tLTnQAQS1M/F1G5HrG4JaUX732TM0lqZ1zXg62pXXOxIH6tZvgjgoFIWsqNnkLoya8AF+ kfFs+30PF66c5bJWh1xlR3BcC7oNa0Cgneop+stypV6XUcxNMrFx+36OHNyPQu1IbHuLVdw1oilf LFjEF199z9aV37NDqsBo1OEaWJdF7w5hcPvoIoOI8FQx27mFEBsXj0KUy959+0vIvESmxCuqLt1H taJj+7aEuymL5KagevOezPrgLguWbeCbBXNQ2bsQW7MJg15txI2Te1BFhlC8/yHYuNBj6NtI1K6s 3raPC6dOonJwp0n3IUhu7WbhdzsxiSwTVWr6IzyDo6htayL3wQ1+v3ulhOgbdAUE6Jzo1KYZAD4R 1WhUzw43B01Jbfyja1I/KQCnMoaPwJg61MvWYq+0TKKqoIZ8MnsWcxd/y4afv0Oi1GDv4kmLTgNp 0+Q02w8k4mZTeppApPGjaZNGaPUuaMQvuqsrQmbrS826Dake6luhoUtp68LIKXPAfi5rtuxk/rFd iEUg1zgxaupchgzpj53o6YYWZ08/WrVtR8LS31j9yxIkciUykYDExp52Q9/j1SF98ZADyKnfrg/f Orqzav1mjp+6wOF9lxDJFHj4BDF2yst0b9vEEgBRUNH+5RE4eAawbvN2Tp67zMFr5xDLVXgHxDDp o1dpWiP6GVF6LeWNrN2UVq3bccMURv1wV8t4K9r+6NF/AH+kyQhs0x1bpaJomWxZcMqc/WjeuAFR Ac6IHqu7R1A0Deon460pGnOCkmFT5pIi+Yi1O1ZzYqcEewcnoqo3YOL73Vm6ZD2xIcVRMERo3OP4 bNF8Fv20ngvHD2CSqKlSw5uKXOpVdo40b9+V8w9+ZuNvPyHIFCgkYsQyG2p0e4PhwwYToOaviGBo hRX/c4hklnFXoNcxaPQUGtaoir1KzK0Lhxk7/FV+mDeHN1/vgBegz89h09I5LF79B+Pnfc/AtnVx d9JQmJvO3o3LGDtuMp9+Gkm7ZVPxDoyjRYiK29dOkwh4A3fu3OH40TOAnrMnDnHP8DI+EkhKSuT6 /XyqdalHNfcyVroKCyxBqVKjkdkgLtbJIglqjR1GbQqhNRvTu0s7wgI8EOkeMf+DN/lq/bfsPtWd KsHuyCodoyJGfPAJGXfP8fnWB7z14SzqRPpj1uuxdfVGI4ecoh3hpOQUhg4bTtvGdfFytSMv7Rbv DO3DxgWzOPfOQGp5ShEBIokcsQBKubSoNnnMnzqNE+mBbNn2PdVCvJFi4GHiHS6fO0GG2rUS/mJG EEnxrtqKUS2DmHt8O1sv59IhQm1ROcYC7p35nb0JBjq9+yrRjlCYncKqb2ez7PfrTPxiCS+3rImr vYqCnBS2rPiKdyZ9zheLqtBkwThEIhFKtR3oUrl2/QYtWvdnaFw4ckEgICKcS7vWsOC7bVTp+Rbz Z7yOm0ZBfvYjbl46zaUH+XjYWzSnVK7EFhsUsmJNqufX7+Yz++c9dBzyFm8Ofxl/NzvyHyWxbM77 TF8yj0WxcXwwshdONiIEsRRbOzsS0rOo0eMVOrduSoCXE4acB3ww+hXWLp3L8dH96OCoQVKZHAUB SOPDCe+y/mwen8z/mk6Na2BvI+bBrYt8PuE1Fs2YQO3GTehb3w//xr1ZOCmZRgNnUb/zq8x4rS0m Ezi4Pyv4oAAYOLthCaNSj2MwmjAZ9aTcu8Gxo6dp0OUNhnSvXc7AIleqsLHVIH0sAJEgEmOjtkWt sCmZU/PTEvh50Uf8diiBvmNm8Xq/1jip5WjzM1n/4xd88PGPyIpitriHxDJuyqe8kqtDJIDMRkPq 5f18+O4EcuT+DOrXgzDLIgCpXIkKW+RSyQvrimotBjGv9iu4efjg6mSPRDCR9+gBE4d14rvPZ/Pa oPbUD/EoMc6/yO485LPgg2n8kerP5m3fEx/qgxQDyffvcOnsCdJVFlc/XdY1Jr/1Ljdkdfhx+TSq RwWgkotIvXuZ5QumMHbepzRo150RzYLISDzJ+xNnkOPVhhWzJxMd6o1CYuL+1ZN8OWsSc+d+Rv0W 7eldy2pgt+LfQNCLp06xBM8a7Vm0KAqJTEOQrHiBarlHobKl56iZ1HkpFwcPy8K4OMhDqd+NCJ8q 9Xi7Sl1evnOTlIxszIIYjYMLfn6eRQt5QO1Mk16vEt7WiK+fQ8mEJZKrqdWyJ/ENWnPr9l2y83Uo Nfb4BQSgKjoqa0ZGbMPOfBIWx4ULl0l5lIdMZUtIRDRh/u7l/JnEHhGMnDANg8IJd/vywapqdxzC Z7Vy8Q3xKd8YyhAmvD8TlE44aJQlZZPYe9Ol/2s079CNe/eTKdQZkChUePoE4FS8g/iUgCdmsxmR rRevvTudlp2vkKM1IFWo8fXzL7knpvlLfB5VnTOXbpKakY9CY0tAcARRwV6U+gI9bWUmx6dqW77+ Og5JmVQhZjOIJTJc3D3xdC1tb4qOB9q6+DHwrWnENe3M/bQsZCpHoqJj8HVRcet6WwxyR5yKd5DN YOcRxMBxH9K623WS0nOwsXcnPNCTVbMvo5WqsXWwnGCIqNWeST7VKdCV8XcsKZMJha0z/u6Wexv0 eJXAJgX4B3mV3NOs7xgi2uoJ8ir1BW49eDwx3UwEuNiX9N2GPYbjHVmdqwmJ6EwSXLz9qBFfhbyH N2nXKwd/F2XJJCl2r8Fncz7HZJK+4O45gBi1bwMWzQ9A4+r1xIRUPAbsvKJ4b8YcWnc5ReLDdPSC DC+/AKpUiUItfXZgFqW9K10Hj6F647bcvJPIo6wcBIkCN69AoqLCsbeRlPpuSVXENuxATN1m3L51 l8ycPASxDCc3L3zcHUtlDQgKe+q16UXNxm24czeRnLwCRFIFLh4+eDrbPrMPl+gK9xgmTJ2JQeGI l6NdORIe1bg3s7zrYOsehLJo16n4XeqoJnw6JxQHj6DShXgRqrftzxfxHfApOsYpAE6htZkxey4d z1whK0eLxtmdiCqxeDqaianaGI2bT0n9xBIptTsNJ7RGC+48zEQkkePk6on8MW5gNpuR2Who1ns4 ETWbcP32PdIfZWIWZDh7+BIeEYmbvaKozawBZ6z45075bQa8y4SRbUp+CQsJZOf3M/nq6FUupIKX C2Q9esCyb35E7tuAGmFu3L56jutGE2KJFLPKnQBXOWdP7eK8cSoRri7UrxfD4X3XOXWxAO8oMQkX DnNb70SbrjW4cf4oe44l0r+eN4l3b5KUr6JdbFXL4uNPnJHV67T4Vm/JuPGTqRvqUPJ7tw7NWb/5 GFfvp5FlBBdxxTt4ZgSc3TzxdtYA6YRXqUpMpO8TGs2oL6R2r+F8OGk0mpKVUiTdWlRj77W9nH2g pYa7mordgnXcvpUJciU+gaG4OVn0l6OTK5ExNdDrtE8xdYLCRs1Lrw5jzo7xfPv9Wjp80s9C+7My 2fzLD5hcQuk/uCsAKfcTWLn0N2wD2xIb4MjNS2e4YjQhkcmR2HrhZWvi8ul9XGUcYYKAyahHcAii 3xtTeO+VZuWaf+2BX0nT6nB0difY2x0xYG9nj6dPAA0oPdH0OIz3TrB1x17UQU0ZNWI4NaPcLRdc XHhvylvsOXScX1dvpH+nxjiFWo726wu1xDR9hUkT38XfUVbSvt3b1GPrseWcT8qhZQxIxJXT5rSj m1h94Cq1e3/M6EFdSqLJu7p5MGvWm/xWewTzl66jT73R2Dh6EB/lV2TsDiI6uuoTu/FPQ1bSbY4e zSs5pWfUaVGobbhxYi+zP1nE6Ddew8vmxUfkzYunWfvbTqo2G8bUqa/jU7JR70uDWjVwVXxP8QFC qdIWvyBb/IpvKUxly6KNnEpXMOy99xnQoa7FBfQ/gNlkIji6HsHmfM6fOMX2g7+TlJJKoVHgYZ4B tAncytRSC/hzOYp03E54BNJwvANDcXNSloyNiKo1MOi0mI0GEg6sZfXJ+/R8pzkaMjl94ihms4BY ZMYvsioSwzrW7dzDiGa+XNqzlh0XMxjSqzGywhROHL2LWRAhFekJiIhE+9Nxtu0/SO9aPa1TgBX/ DoJeHFFRJHOgWrxD+YV6MbkUS3D1CcLVp2JFV0rALEEhPP2C8fR7knwACBI5rr7BJYGqHg9YI1Ha EhJRpYIJt4gkCgIObn40cPOr2DJdTJaUdgRHRD92rSjqulcQzl7lJ3Mwg0RDRFTVCt+HIKBxcCPS wa3C7z4tgmSpEUNarkzl2kUQsPMIoZFHyBOLiGcF6rB8X4zK3pMa1T2fIe4ywWiK8pTLbOypUb8Z NR67NzA8prQMCAiCiTvXr5KUmk9EXCzV/CyrlqtH1/PdsjU4hccRFWFJMWbr6IGto8ezJwqz2dIf fMu3h5t/GG7+5X/zCIzA47F2MwsCgVHxBEbFl3uvvXsQce7l21CkcCQ21vGxtn12FNli+UpVLsRX c3n6GBAEBKmGanUaUe0pbV/ZYsRsNiOI5fiFRuMXGv3UvlYy5iQ2BISEP9e9UqUtwWGRL9yHS3WF nLDI6IrHnMqR6BjHCq9J7FyJjXOt8JqjZwCOngFPXLNxCaBJi4AnihFXLe6xMW2539EzEEfPyusk FNsdBTGegRF4Bkb8uXawwoq/MwQBFzfvcmNJrzPg6uWPmSvk51t0X0F2Eieu5pPnfoOPxo+hsMT9 RMBk0PEgzYydj4jMTJA4uxBXrz75K5dy6txZOvp5cPTQMdSR7Rn7ensmDh7Bgd/3079eB25fPYvR JZCqsbHljPkvSiDsHFxQSqXl6mHr4IqNBrRaHQYDVBgZq8z3LG5sZvQ6XYXfMZnNlrbSG0AiKfmO q6c/YiA/T/eUzCsaXurXgkOLdtK3Z3fqxUYSFh5GcHAo8bXr46ZWVKzzhaIzVxIFQXU60jhoOoc3 /UDCtH4Eyk1kJF1g6ZYLxLUaR+sgG8BE9qMHnL2tRWc4z/R3RpfKShAw6rQkZoNboIjsHEAEJpMR e2cPoqrGlc4rCCBAVGw8DcIcWfXVdHLvn6ZaVChBwSFEx1YnJsIPsaTidB4JVxNITEomutkruLm6 lmwAIIDgUZ2IgAB+332J9IxMKJqpTSYTji4eSMymcnJ0cvNGJoaC/CddEB/HmaOnKTBCw+atwGAG iVDyXbdabQhWiTh79AQGzIgR0BW5P5keywr0dHJueWF0+/4sebMP+YW6IoJeSMq9q6z64Qs+nTgF ndqPuaPavfCQfJB0j0vpIrpXrW4h52V2XAp1Okxm4YnMR5bAf7msmD+dmd/tofGg9xg7qBMqyX9+ wEsQibhxeBMLv/2BLQdOg0SBRqNGqbQhNTEbAK3R9OeyjZoBQUPv/q04sGA7/Xp2p35cJGFh4QQH hxBfpwFuagUGfSEnD54A4OzvPzPm4NJySYWM+gLUdo7oCvNAX8iZY2cBA4c3fseV7YaSfiMIUJCX icbJAV1hvlX/W/HvIegVKq2yi9oKrj/vb89zXagk4nhl5XmebzytfBUHlKFCLfRcZeP5gp49q/5P efKZivhFAmJUFun3mWUo+vfwtlV89OkSnKtUwc1Bg1mXx/ljh7lboOatmUOoV8WLF9k0ebwMf1V/ e742fL4UL//tMfAi/fxF5Pdn7/0z7fDfuPb84/05y/uC7WuFFf9UFJOTsv1ZLIjLzHQmjMZcHgGe 4bV5Y1RHcgqK8z9btLdIJMbe2Y1wFYAt3uE18JXO5dypcyRXN3P6zE3iegyhRVwoG6Pd2H/8IBev V+fahQS8gqOJiXavZGZ9LpWNyWjEVLStWFwPkWBJy/pXjlKj0fBEBHpRubaqfGnVd8Jn6Nx+YPOO vWxYfpSc/EKUjh7UqNOE0ZOn0izKo2IyVfSjys6LV19pR49JW/h50zne7xLEie0ruVVoy/BBQ0pk pddbZBVZtQFvvNKqVFaWACiIRALOHr4E2wAFFvmZTMYSw0RxzAEQCI5vwrR5i/jx5185dGwPR7eu wiCS4RkQTs9XXmNo3+542cueMEzk5Oso0Opxt7VBKheV6F4LiVNiZyODvAz0hcYn5Vhp+z47dWt6 dgFmQONoWyKQ0u/a42QjoEvLfzKLxwtDjL2nP6ERjxmwa9Yi2FvF1k3d2fTzz3w0ql1p8FEzCOZn pag1UFiYjxYVCrW67IXKGW5RO+1f/S0TP/mB0KZ9+fDtoXioJSVG5P8IKeeY9sFkftqfRP+hQ2je oDqeLk44ObuyceHrTFm8+/lyFldYZzMg5uXxs9G5VmHT9j1sWH6cnHwtCgf30rER7kxabj6IpDTq MoRG/uLHjDUCMqUNLgFVKNQWkp6bj9jGjhY9h1Pb01QUs8bSD0SCgFSlwTsk2qr8rfj3EHQrrHiR VVNETByNG1bjQmIKCWkPkMjVxLbozbi2nejQoh4aiTXVhRVWWGHF3w7m8mREqnDEE5BJ7encrecz HhRwdg2gerg710/vYudJHbdy5LzUoinYyajXoC5bvjnGL2t3kJCaQ0j9WEIUpc/+pXUwv8jtRaeM REK5ujyHfeC5imLnE83YSdNo2+0qSYlJJCYmcu7YduZ88zX3jZ4c/20K4gr3QIriwyhsqNvpFQI+ WsHaH75nZJt3+fXHdbhXbUT/1iElSziFjT1ugFrj8QxZUfmOdFEWTZHcltotexFRrT43rieQ9OAh d26cZdmSJUx/fybu3oGM6Pxkvm9HjQKVjZysjCx0+XqwlZbZYc0lPVcLdipkCsmLdsanwsPR4puf kZwKZn8LrS/+rjmVB3lmFKGaF0szVkmZyu+6l56ws/MMw0sEyZnp5ACOFJ9KM2N67HSASCRGXNzf zBb5KeVKbMgi/9GjMu+29AOxWIKoXGY2yzcvH17L+Pc+QhzUkA+nvUukl21J//1PR9TZ/dvYevAM TfvNZvq0MXjblbbeFT9nJI9FpHnedIEl/UwAO+8qjJn4IW27XuP+/SQSE+9x/ugOPvvmGxKNnhz7 7X0C3ewBEZ6R9enTJajS8mqz0/B10WAUyQiu1ozeTd2e0v/NT8S5scIKK0G34l+8uLNYbWPqt+LD qOqkpj2iUKdHJJXj4u6FS1H+ebM1uJYVVlhhxd8ealsvWtRz4asjm5i7YTBjOsaVv0GXy4Wzlwis URMbwMXFhQb141j/9S7mFWZiE1CLVtUs8UBC4+rjKdnEz999g7NCQfe4amWnjf9/ix+VFIE0MvSi F6DezwfBnM/dFDO+birCouIIiypyvendlhOr17J3937yANtKp1QzgiDGwSeWgW1imbZjNQsWOLHn Zi4dpwzCtaz7jrMvjePs+G33Wr7d1Ychzcvv8hpy0rl28y5BsXHIKi2wgICezBwtEqkGO2cv4p29 sDiH9cDFnE2fCYu4di0BeJKg+0eH4+frxab9e7j3cBBh7r4lss2/vp8L16/hVbUzLk6Of6kMqzWu g1r0OdvXrWLm0FrFVQHgxvbfuJVvonb9uoj/Y9kKiKWycn8Xf+fS3rWcN0F4cBVcAaMgQi2Xka8t IDntPhBemle8IJuk5GxEfqXlcXH3IdQRLpw7zrWcEYRqSkl2WnIiaVpzKUkXIOXaET6aOIn70jBm zfqMZlW8nyjTf4LktCyMBgiMrIqTbXnTxr3ENPQYywwVSx+8n3CSqwnpYOdJg7iIcingnuhnZcZG aFQsoVEWdxdeas+JtWvY8/s+CgQR1Vu2QjHlF36eM4WXm/9MsKb8q/JTE7iWISI21IPqzZojfLGV pfNm0rXBF3g+5omRmXSD+wVyooJ8rMrdCitBt+L/EIoXCyIJ9k5u2Du5VbLgsJJzK6ywwoq/OzQO 7gx6ezKbe73BpFcHcO+PftSpEYlSpOfO9Yvs3rEfo9yHH9bVtCwkHFyoUrM+xs/Wc+bSLYaPH0Ix FQsJCaVOjAcHfjmMXb12xMbFUY5J/c9h2WmsWiUalXCQz2bMorBPWzTmLATHCFo1rv6f70OaUhnT 61XiOnejUZ14gn09MetzOHd4I9czIbBF/BNpHh/jMQAoVbZ0GTyCT34bwdxZ8xA5RzN0QNty9gRn ryAGjXuHXYMm8s7QAdwY9DI1q4UiM2m5dfU8O7buw8E/ji+XxCF/Rrvs3/gLv6w5RpuXelIjOgxn exVZD6+x/9gJxGpffHy9S1qwHJzj6N6pObsmLWbKhzPQjh5KbJAbGfcvsWjmNA5e1zNpTCdCfV3/ Uimqq7RlWLkYBPgAACAASURBVKcYPln3NWM/8GVw15Z42Em5dnY/09+ZQ6EqgPFDOpbfhf5TMHD/ wgm2b3VHq9NjNhnJy87g0qnDrFm1CpNrBG+8+SoAYo0G/2rVYO4mVn7zCeH2Q3EQa7ly5ii//bqc Q7d1xAWXEtjQ6Di6dGvBlG9+5PVhanq0rY1Em8GZ44fYuet3spGXHJvPT77CotnTWXHoFi36tEat vc/e3ffQG02YTSZsHD2ICAvFyVbxp2saV60KDmoFG5fMobp7AdVCPclNTWLHppUs/+0oZsxl9tAt BVs5ezLf7bxAy3HfUCcmAulTBZfGmN6vEtepKw1rVyPEzwuzPofzRzZx/RH4N6uOBlDFtmHyK82Z uGQZfXua6NW5NaF+rhRmp3H+5BGOnbpI9e5vERvmT3CdTozt8itz1s6jb69curVvToCnA3kZDzl9 dD9nbjygRb/xVoJuhZWgW/F/j6H/lb7wVlhhhRVW/LWk1FiYD2Y9+YXlA2SZzWYK8rIpzHqEvsh3 UyRVUL31AL75FhZ9+wPfz5vO9xIpYhGYBQkOroF0fbkupZtaSlz8ogiSwG2lisatWpZcUfuEUr1m HfjlMDbOAcRHqcvyy6eQXAO5OVlk6nIxGIsKZtSTk5VJliwPw2PntQ06LZmPTOQWFGI2P32+AmjY 8w1eO32HRcu+47XfVyAVi+j42qc0qlcdkaGQR/kmcvN1T7xLV5CLEdAaSj2bTfoCjGbIKygKHCfI MaZdYtqEfXzj5Y2bkwNmQwGJd27j2LAnn308ChFPO0VgOaotiOX4xjajeYSc9ZdTadRxLDXdxBTn xzCbQSRT07DLcL4qlLJ4yU989dkUvpZILaRUJMXJI5S+XWuiAsxmI9rcbLIytegMj3tmy5CaCji6 bRkbdm3E38cbWxsZ6cn3yDSoGDz+Xbq3shhkdNo8MsknX1saYK/jwHGkZOYxY+FyBh3djq+nE5kP EniQa8PAt6czpEczShLbGHRkPcpFkactiVBeDL22gGwj5OsMT5ej2QyCirdmLSDL/A7fzniHXSu+ xs5GTNKtq+Qrw5m1cBbNY0oD0poNluj5ufmFzzlszJiKnjm9+iv67PkVs9mM2WRCbzAiUyiJqNWB Sa+9SrcmRW4HEg1VGnVlWOuNfL3le/qf3o1GasIktSUkyIcgx/OkZWRR7I2vdA5k4Ovv8/CRgaWr 57Nj1VfYajSExNYlIqY6qQ/2YSjyy796Zi9rNm5Br4e9a7/n3M7l6IwmBEBfmI9fna58NnMqTWL9 0RXkkUcW2sLSyPva/Bx0PKJQX6oDCvOyMfEIXVFwQZfq7Xlv9EDGTVvMWyNP4upoS0FeAe6hNQgO sON2Si4FhjKxBLjNyo0HuZgoZkbN8Mp3z0u6thxT2iWmTdiLu6c3bs5lxkb97sz++HVEgCB3YeQH c1F4LOS7X9bxwYTtiCViMBmRyVUExtQmPsYSAFftFMA7sxZg57uAn9Zs4r0965BIRGAyIVdqiK7X gqpRwdZpwIp/FrPq/uoc8908J4792P8fvfh4Ipr5M9JCvdDbn+pj8+S3nx7tuaLo4M8XMfwfKZkX 8U/6P1Kvv1v9n7cu/1ZZWmHFPwUnTpwgKCgIUVFur7y8vJIxOH3hRq4UxmJO3MxL3doyrEdpbmaz yUTWrbNsPn6VKrVaEhNYetTYqNdx9dQBzt/Lol6brniryhJHE7cun+XqzdukpmdjEkSobR3w9gsg IMAfV/vSm/Oy0jhxeBfZIg/qNWmEo6z0PSmJNziw5yiu4dVoUCPyuc63m3PTOHbsGKkmB2rXjMfF To4pO5lDR46SI/eidvUYHNWle3Xp965x+PhJnMNrExsegFL8bJ2Xcucyp89dIjkjF8RSwmPrEhfp D6nX2bDvBG5hdakV5YO0TOrNexePcfDsdeKadyPURYlIgIL7l1m3/zRBsY2pEe6BgIErp09w4fIV rt24SXJGJgobRwJCI4mrWZtaUf7P1p1FbWTQF3L15F7O3MkhLLYu1cM8y0TyLrPOMeu5cfEc1xLu kPaoKJWtvRM+foEEBPjibGuDWZvNlTN/cDHVSM3aDfB1UZb7ZFZaEudPneTi1evcvpdIgc6Ms7sv ETHx1Ksdj7uDxV3t3uWTHDt9k/CadakS7F1S1tyM+5w4eoQ/Tl/gfmo2ts7uVKkaT6OGdXGzV1J8 esGYfoftB46j8IymVkwIKnmpsB5eP8OBkxcIrduGSG8npKJny/FhwnkOHz3OuYvXeJRnwjMgiLi4 GjRsEI/CEjEPENClXWXVjpMERteldrT/c0yORvJSr7F62wnEIkoNRYBIIsPeyYXg0HAiAstnRjAb DTxIOM+2XXu5mnAXidqFmPjaVA33J/PuedJMjjRo1gC7kjziJtISb/LHqXOkPspFotRQpUZt7h9Y wWsjptDq3cUsnvwyafevceLkSdKyTZhNRoxlrBtmkxG1mz91a9XAy9mW2+ePcvx8IjH16hPmZwnK eOPUAU5cSaFm40YEejpbSP/x3Zy6kUX9Fk3wKUpTW/gokf379nHkj/Pk6ER4B4VQo04jnEjkzMUk 4lu2I8BJg1iAR0d/JLjpK7g2Gs+h1VNwtJE/fXyb9RWPjZBI4mrWolaVgHJjw5ifwemz57l77wHZ +VrEEjlOrh74BwYQ4O+Lskyu+cLsZE6fvcC9+8nkaXVIZUqc3TwJCArEz8cLudg6h1jx98H58+fx 9vYumc/1ej26ouCdt27d+rcQdAsSb1zk3Lnr+EbHERHix186FvVa7j9MQaK2x9lOUxroowjLp49i 9WUbZs+fhL+j7TNeZuD4rp2kFEho0LoZthLRv9o1W5eVwtnz58ky2xIbHYWzvc0/otzFk0TS+T0s /n4l568nYpQpiOv4Ch8MaFOxZA06Lp3cw50UPSJR2UjpYhzdfYipFoWSv1/KrsJHDzh97gL5Eidi oyNwtFViuHea6Z9/id67Ea8N6IqXkxL97eNMnr0YRXg7XuvbDld7BVZYYcXfl6A/zbD25LUigzM8 l4G7JK7IU9/z4sbzFzUQVlqPSknC08rwZLC4F/1O2TcYdVrytIVIpApslPIyzz1f+z6zHZ5zM+Kp 7ypKV1v2ekFeDnoTqNWakiPij0e0L/tb2d/NRj25eVrkKg0ycfm2evz5v1KOOm0+Wr0ZtUZVLpRZ ZeV+dora552jS8v5+HvzcrMRy2xQyCQVPFM00iosRyGL3xvEuC+P88GiH3j7pfp/2uj+NLk97bfC gjz0JhFqlbLScbJuVn+6TFjJF9tO8mrzSKRioXJ+XpS6+XnGRuXtUoGc4B+5OWKFlaA/jaD/q464 H9mynDff/Jy+s75kyrj+fylB1yccYdxbM/CoO4hJr3XD2a48MTm14zdWH7DnvVlv4//MOCha5r09 nO13Ney+eZYqdqJ/dSfMvXue+R++zRljJAs+m0HDWL9/RLkFQSD35gEGDHyVQ5eTqRJXFaUogzPX 71RujNDms/KriSz9PZ3CvCwMRWlWBJEYjb0zkXF16fvqm7zUJOJvFTQvO+EUn04ezx11Hb78bCqO tl6YHt1n69oVaKuoebl7B7yclJjS77Lht2XYNvamf/dWuGKFFVb83fVYZb89ea2U7LxQKswXec+f TGn4Z+tRyQeeUob//Dulac4ExDIFtjLFEyThL0vj+YKpZiuTn/AY4VWqNCifgyhXeHpQLEVjK33u Ov+ncix+v0xhQ5mmLvPd/0Lq08r6exFJLy6bSm1bSRuWPnNs11oWzv+FgHoNCPVxA30Opw9s44fl m4luMYj2zWtWYjp6vrK/6Hgqbje5UlUmbkH58puLIjVsWrsDl5g2dKjhj1T8DGJdtp89c2wIf1q/ /TUytcKK/794DoJeiYW4IktUJZbc/9VuYWBUPL1fGUT16NAKyPkL1KMCmLIfcvTgPgIcmqLTG5+4 LpMrQaZAJAgVKtHy35HQpEtvnDJscJSXtxZXpJT+K1a/v0xWlU3cpb/LHb1o1LozgXjh7qz50/3o r5Dj0+9/cldj0y8L2HXqKu9+v41+dQORmA0Uyuwqf6/JyIM7V7mXJGL8gq+IttFhMJkpyHvE2aM7 WPLTd9xNySQyZhUxjsJ/RX5/pq8oXXxp1q4r6coQXBzUJUYFhdIG5NLSIDtFvynk0jLfecoux1/m alLxjlNFOwUVleNFjudbrexWWGHFX2AZ+eeRhErn/j9vUPhf1Fn4m7V1xd8VKo03oM/P4sSejSzf tgmJGMQiMUq1C/W7j2TcmyOJcJGVocR/j/Jb/puMXWgD3mkzBk+NgjJ2qT/Vz6zzrhVWPJWgV27l 0+VmkJajx9XDDUk5K2HpM8VPZaU9ILPAhIunFzZioZKFbyVHnswmzDxpUTWbir4nVEy44pt1Ib5Z l5K/LZHFRY/Vw0jawxQkdi7YKyVPWDsrW6zL7WyxUSpQqWxxdFRV2qAiqdTyHl0uSanZOHh5oqS8 VRWzjMHvf1KizB5vc1N+NokZ2Sht7HBx1JTxda/Id51Kj4SZixKClm9ay7nDsrJ6lJpETiG4eXsi L2NBfR6FWZZ8ZaYlk1NoxtXdHbm42C/OjI1nOIPHvV+mfKXvLn5/+sMHFJjleHs4PmYVt5T5CTka tTxMzkDt5olazDPl+Lg8BUEAYwGJ99ORqhxwc1KVvLtsu108ewyUUYwb2Arn5yRxIrEEG1t7Og7o TV1FaUsltmhIwb1rLD91mMOnkolp7vbEe0wmsyUvbwWys+Tw5LGxZuRh0kOkGgecNDaPvQtEz3E4 w2w2o/KJ5rXx0WUMRS9CnYUSf9VHqalk52lR2Tri7KgpJ8s/a6Qra1UvHRu2uDjaPhEHorT+hSTd S8asVOHl7FTOXxOK9UjRvaZ87iemItbY4+5g96RvpxVWWGGFFVb8lxDToB0/bd1OcmY2hYV6BLEU OwcXgkJD8XF3LDPH/c0KbrLl9Q8+wd7VB1lRcDgrybbCiv8aQbcsSvW6fGYP68ZR6jPnnfp88dFn HLpwB51RwNU7hB4jJjCiY7yFCJcMSiMHVn/NZ4t/4cb9VHRGMxpHD+q36MKYN0cRYCcmPSmBrz99 jys6fybM+piIolwjD26cZcFH76P1bcHUKaNKosNeOryFTz5eTGSnEbwzuO1TLX7HNy3li6/W03Lo GAZ0bACCwP7l85m//DhdB/ZClH6OH3/ZyN3UHKRyFTXa9GfCG/0IdLWt9LixIAjc3L+WSdNnkZCS R/K6z2l67ldkUoG8QicWr1hMvF9RWjGxguzbp5nx2c9s3XeGrLxCbGxdaNXvLSaPaINUKPbNEbFw bC+2JHrz0/JPcJCIEBDISDjMzGmfs//sNbLyC5HKlDi6eFK/WSfemTAMe1HFssrLSeWTMf25VODP 7B+/xE9qLmOlNJF86zgjR0zFo/FLzH93gIX0GArYuWIx85b8xq0H6ehNAnbOXjRt35vXXx+Ct9rS FjdP7mXWh58S2G44r/asyvefz2PX4dPY+MUxYvTbNI3WsGP5d3y5ZBXX7qdhMAvYqGwJCKvG4BHD aNsgFh5eYvbcedwQhTHmtSGEexdJ15TH1hVL+Gbpaq7eScaIGCfPALoOGMXwni1QK0SW9hIJrJvz Nt/uy+Xtt3pwYf8mVm89SEpmAQqVHY26j2TyqG7YK2VPPTZeQobzkpj7yUes3XmUlIxcxDIlPiEx DB07ka71g4v6ch7vdm3H0r33QWdDpyZNkJrNSCQefL91OT7SZ01CZoyG8rJy8w7G202NyZyPwtam pH8l3TzF+2Mmoqr3Cl9M6FEiO8jnxM6VvL9gB11eG8fQVtVL6lCYncyqJfP5fvVOHqRng1RFeFgo tkoQbIMYMXI0NcMdWLNkPl8sWoZZrSqKGmxGJJYgk4rJNzoz8q036N26NqbEs0yb/QVpDjUZM7wv ge7q51YiguEO7789jT1Hz5Gdm0+h3oBUpsDZM4DeI97hlQ61kIpFf+pIf3F9H906wsxpc9h/5jqZ +dqiseFBvaadGP/u8JKxYcq9x5wZH7Fm12EysvNBIsfDJ4zug0YyslcThDI+cHnJV5g9cxab958g K68QkUyJb3AM/YaNom/bmgjm5z1QaIUVVlhhhRUviKL1s8bBhfh6jSpdSzzVD///W9HNIFLiHxDw 5BrLCius+G8Q9KKFrlHP8W3b2JB8iCsHFiPSeBMZGoEh5yHbt67ixr1kgsK20iLMsptsKMxn5w9T GT5lCa4Rjej6UltsZQYuHN/PT3OncOdhGt9/PQ2V2IQh+Qa/7DpD675vElHHBTBz6+oxFizZgG1M Pu36DKJpiAoo5OKpvSzfcpA32w57ZmUe3DjPhk1r8GzcveS3+9fOs2fjz2zfvxU3N1e8/IKoGu3F H/t28c3McagcXXlveA9cVJUrFalCga3KBpEAEpkCO3t7lDIRcr0DUnERMxDEyPWX6de9DxKNO2Eh QXhLtOzYsIlzl67hG7KXAY2Dinx04NSudWy5HIG2iASYMi4w8OXB7LuWSdtuPaji70pG0m1OHDvM vOkz6T1uGJXF45KIxLjI8lm15GfiX3qdCR0iSxSlsSCbY2t/YPWOPYzpOAEAXd4j1i2exLhPfsMn pik9+nZCJSrg1KHdfP3xBJLSM1kw+23sgMyURA5s3sLaM/fZtdTM6Uv3USpEOBQoSXt4m72XjjBi zDTkPlVo26Un9lI91y+cYsu65Tj7h9CoQSzqvHSO7dnGH+Js+vfrB2gAHcvmzWD81C+Q+0bTomU7 7CUF7Nq4ng9HDyQ9dxFvDeyIo43FKnvj1GF2bTjMiaOrUTu6ExQUTLSXmX1bN/LF+xdx8w3gtS61 UMueMjkIApjSGTO4P4tXHyC+eQc6NAyh8NE91qxYwaiz59D+uIo+df1BEKFxdEIuFsBowMbeATVm xDJHxM+xKy0IIhRlY+Hps9m9Zglr9iVQt+NYOtcoPeqfm5nCjk3bsJc+HgRGz8O7F9i6YTPBbfuU EHpt+h2WfD6R8Z+vxd47gjZNmyM25pNw5Sy7jpxEHdaMzi8NA5xQadS4urliUioRAJFETmH6XQ7v O0iaPpCewywBKUw5KRz8fTN33SQM7NvrxbRIYTLnr99DULtSq1oQ9moZ+Zkp7Ny4gfdGnENqu5U+ jUJRiF984hYEAfOjiwx6eTB7rj6iTdceRAe4kvHgNieOHikaG8OxV5ox5dxh6Es9WXc8mZYdOtM5 3IfC7Afs27KG9958nRzREib0qImAmazEswzt25+91wto07Ez0UFuZKcksGvzBt4cl0CeeDHDW1X5 e+5aWGGFFVZY8c/Hc50q+3ue5Pozfv1WWGHFX0DQBQRkChCp1HQd/RG9m9XE2UGDseARe76fysAZ 61ix5XdahHUEjKTeOsR7074ltN1Yls0ei4uDGhGQm3KDOvMmM3rBT/zavT8jWnpTq0VLjCu/5o+z J3ipThvM2UlcPHyEbECSd58duw/TNKQFZN3nzqXzaIKiqV6tZrHBsVJlJZJIUaBAUiYPo1giRQIE N+rIWyOHEB/mi42NgpQ/VjNg5Dus2rSRlzo0wCXEvdJG8qrWgokj7rHj4DF86nRmxqSBeDjaYDCJ cHUrjQhnMGip33siQ7u3xt/TGalYxLXWn9N86KcsXbuJPvVHIhVbAqdI5QpQyBGw7NGd3LKSTUev MOijLXw0rA4apZzCglzSU5O5duESTqKKLasgILexpcOwcUxb3JnlXy1lQoePS10NsjL49edfcQpp yMhXGgNGbp3fxYdzVlK913i+nT4SJ1sLectJ6sHCmROY+ctPtOrYnb4NAxCJpCgkkJefS1C9wbz7 cTOcNTKkNnYo8+8zZ8Ey8hzjmP7J13Sr54XRYCA3O5MRly4idvJCDJgFEVK5HIVYiqhIeNcPr2fx l4tQx3Xk42mTaFLVFxFGRg7uxagBA5jzwUfUqxFJuxphlo4qlSMGqnd8hVH9uxPh74FCLuXunuq0 HzKZn9dtpE/zKNROmsrMvQiCwO4fZvHdyt9pOWY+H4/qjJezHSZ9Pq/0bkOH1n0Z//YM2hz8BgdB zvDp80i4sYfv9tvz4byF+ApGEElxfQZBF0QCeemJDKhVFzuxCTNm9IUFJD9IQqeJYMLg3jgIZY5u i0TIJSB/IsqrgFgsBZkCqbi4Txs5cWATH362gvCm/Vk8Zyr+LmrLLvPVQ0yfPJ7tD0BUlL6lfuvu RNdtbTmuLZKiEnL5etZEtu6S0e/t1+nRpk7R4BEjkymQy0pl9NyQh/PxnAUo1bY4OzqgVMgwm8yk Df2JmCavsHzVFjpW90Vh++civp/espINRy4zcMYmPh5eF42NonRsnL+EsxhMBgNrF0/nl713Wbhu Bz3qhqGxkYNJR99eXRnZqz2LPp7DiB4rsMnNZMXCGey4rOXrtVvoEB+AUi4BUyFd27dk5MABfP3F 1/RrNQ8bwbqLbsW/GZWkKP0bZZh4Zg2s6R+tsOJ/qiP+bllorLDi/xRBL6Z/MseqjH2jb5loze60 6tYJ0YxVXEm4YaEMBXmc3b6WM/cLGODmxLF92ynQ6jEjIBEbeWSywZCTxv6TxxnRMgSvsJoEKT/m 7LEzMKINSfdus//0OWIad6KK+C5H925DO7wFuQ+TOXP+JgHB9YmNdS02OL6gbjGixYbW7bvQvWXd kp/d2ramSsjX/HzrHlk5OYB7pZO/WCLB09URqVhAqXbA29sXV3v5YzeaMEoCGDZ8AA2CSt/l0asr XmPmcfXmDUxlclY+DkP2I8zAg3u3sHNsgxxQKpXYO7oQFBaJ0VyxGcWiJyW4BNaiZ4sgvj2+hu0J 02kVaCEcyed3sf58Hi3H9iRYCcbcdE7v2MjFNAP1HW05vHsL+Vo9CCJkYj052JCbkcTRc2fp2zAA MKEzQ42m3Zgx412cy/SYvJspaPMLyMiCgkItcrkS5GCj0uDq4QNmS33Ll90iwCO7dnLymo43x/am Q/2okqB+msiG9H+5I/venseuP65QNy4MB0mxHN3p07cPrRtULZVjt84Evjefc7cSKCwsBDSVmXsB WP3DcnJFIYwf3YdIv2LjigaHJn0Y2P1zpv2ynF1X5tA9whYndy9slSJAipePB17lJqynWLXNFsLr 5OaBs8SI2VyUo1Qh58rFS8ycMIp7IyczsX/jFx6wxoy7HN25lUeqICYNHkl8mG/JNceQYLzdHDEk lvYzlcYelca+5O8Da1by5U+bqN/7VSaMG4K7RvoXaBFbwkJtuXn2GL+uX86lK9d5mJ5FYdZdMguM 3E26i96gB/4cQdfnZFrGRuIt7JzaVTg2DNosln+3DMGlGtKMG2zbdBmjyYwgiDDo8lHa2pNy+QCn M6Fa/kNWL1uLzLUZpoeX2LT+FEaT5eh/XsYDlDYKbt48wvk8qKWyLkGs+Icvr59KYC16TKfN+3/s nXd4VFX3tu9zpk9m0nvvCYEASSD03kUExIqCDfsriooFxYIVsIFIsSECSpXee69SpUPoNSGkZ+o5 3x8zmSQkJLH9Xn2/ea6LCzizz9l7r12ftddei+0rFnJDG0uvbs34N8UVEQQBqbCYjQezsXoYyUzy wUsruhv+9xKuv/WkVkaWHMrrGpVDNRHAm/yC3Kpfu4njXz7CEAT4bfMyDl2S6HxbR/wMOrdY3HDj v0nQAQSFHs+yydF5p1nhHYgBGYvVccnWbLZw8MAJwMT6eZPYu1iu5GbKai7GJzQEtfOpX2AUmQ1C 2XVsFxeAy2cPcuB4KY+9/x98T03jlR92sf20RFj2RY5ezCOuRRNi1WXM53czdGTU6LWa8kleEBDw xkOjA6u1RuJctgDYnWlkScJut1fPykQdXnpV5XyMQRhFkQKr9Zaut2SgYe+HaP7BNyyb9AoZW38g KaUB6enppGW04rb2aSiE6hezMp/xOg9vBj79COPufJvvps2j21t3U1JQwKJZP2I3RPDw4w84SHVR KYcPZ4GlkJWzxrPtF8lVLkEAU3EBviHBKF1PZSQBvHyDHeS8gs8Bj5j6dOjWnZmrP+f5AT2Y0rgB 9VMb0Tg9ky6dOxEb4nULoixxKusKpeoIEqJCHeS8wndTEusT4qvixNFLFBRI+PiKjnYUtBh1N8lX 6Y9BqUKyWpFr9W12jb1HchFjbyPZX19h0Xfk2yItA+GnXzmw7zJ31TMCApLTiZ+9UterPYav1ujH kM++oZWhFJvseGazlHJ870Ze/s9TjB/9Ni1ar6Kjo2PXGbnX8zh2LIuAiGgSUxpW3qjYbNgl6ZZO A49umsuwl95Ck9yVYcOGkhJs+INjqmLPBYouMOKNYUydu5Rsq5bY6CiCAv3xUWtRCmBDog6Nc0s0 vGMgLd7/muWTXiNj6xSSUlJJy0gnLb0lPTukoxBkLCWX2XXMhMXrJJ99+C52Sa7QHhJF+WZCAn2x FoO5+Ap7z9spKD7IqBFvYZVklwQkyU7+dYmgGC+sJYCHe5Fw41++vRYEZMlO9v7VvD9lBZ3ueZbe LeMqpTEV5fHt2y+wP+A+ev7LCDqAPSeP8VN+pTgims9DjXhp1e6Gr4VwnTt1jWkLjxOcGsWjnSP+ /jxFmPnhEL6es5xe7/7AIz2a4aWsYd+VvYcBj77GGWL56cdPifDxcPkFKVvz8g8vpf9zH6FrdB9T PnoCD43K3bx/E1Z8P4pPVllZ0jzDTdDdcOOfQNBlWUZyEqtyfiJWCmMmyzJFZhNqz0Ce/eAHusfK WCocmwqCgEKlwcs/BIAAfz/atGzEwrnn2Ln+CKU7dlDqFcPt93QmZ+kpjJZVrN24mu7Gi2QX67kr LbWMS/1hDa8sV3Sc5lgwRATEunqsluvi21pGkm7OxyEroRYapA9LY+qyNfwyayZrN+1g99qFLPh5 Cr6hMbTq1p8p343AU5CrJbwyICi1xDW7kw4x77B55rdceetulLknmDZ3J0kdBnNHgoOQ2mWZInMp huBoZwr/uQAAIABJREFUhnw8hfZRdiy2m9pKrcU3MLRyzSR7pXo5nLcZ6PP4q/hF12f+gsXs3PMb P21dx/eSguj6rRj2zts81KsVN6sUwIrJYgO1BpVKUYX0ajRalCoVlmILdqsdXNtFGUm+tXxrh5ki M6iMOpQuwlier17vYGOmQjN/1rBZVCgJCvclSF/5eUSgN0/1mcGzP+xhw8addIxtXYXv1gSr3U6p 2YJKqUKtVlVSIlXf7x2/55zYwodvvcJRVRKj3hxO59SwPz2myiQ0/bPhjPlyKg3vG8Jng+4iPswf rc4Db8t+9mzejlX64+RclkEX2pipS9fwy+wZrNm4g93rFrJgxhR8Q6Np0aU/Uye/h0owUQL4N+rF 9K8GU2q2Vi6pKKJWa4gOspN3opQSIK71vcwcOYiCYtNNm1cBnYeBCG/3AuHG/whkibxjO5g46RsM yX2qEHRJsnHt4jUu2q7/O+tns3E1u5gioxmbXXa3dx2QfSWPmQuOkGIz/B8QdAcuHtvP2r1HScnO w17buhPQgIwomPbVJN79vjtj/3M7eo3SddoPFka8+iZL155g/CvjXF7E3fh7kJ99mSsXLFhsdrcw 3HDjn0DQ6wK1SkFimB8Wq4QVLamN69W44VZ4B5LcrD3K78Ywf9l8vE4dJ77lXcSK4BHTgMxIH3Ys mIJnmhEhKJZGjdNdpOy/uMP5g2Wo62ZBQXzDVjwbXY/+j+eTX5BPzsUsxrz9MvOnj2PynQ/zfM/Y mlgYnj6hPPVQb+79aAM/zt1F6xvzOFqq5d2HHitXBGiUxIX4UmTOBbWR1Eaxf0IeAnqvILr1HUCT tj3Iyy+kuDCP9fOnMurzCUz6oT5pma1oqBIrlxUNAT56KLpGYVGJ63suMpl3jeKiErxDvVF7qP4i +QL4EekrcPDMeUpFAa+b8r147Rwy4B/j/5eYyFU0tHCdcgsqgvwDQJIwlxRXSAxymdt3F2sWUCgV lerooVYR4OlBUU4h+bnXIdav/NsKBUqFolwZ5STvttxTjP34HWYdhFc/eoMB3RtXLtMfV0MAhSxa uo1cv6YMG/IUXZomVtj1X0etUmK9WVFWxQSxJi+1MqAgrmFLno1O5v5B+eQXFJBzMYux77zEvJ++ 5Pt+D/OfziEkGOC38+eIaNDwVhcdAJkiXSAxIhRfyyYmuf6tJ0H5n+k91w036q7gcvq5UKhQizJW UykyimqVbQoFKBTiLee+ivNFbSbRdfm91nFVKUJMLd8RBBQKAcXvvIteVXF/63mjYvjSWsOP1ham tJYwjnWdmyvPp7XMV3KZZaMjX6VCwGy2YZP+QPkrlLH2spZfCVMb9GgAvVpZYwhQxzfV/Oe9z1m8 qi0/jHiFe3q2pFNyoKP3CrBt2gi+X7KXHs9/xf3tGjgd9tYsA1fo1puuqJWHwK26PtVUv9/TTrda 38qX61quGNxiPNw8Luvqj6Gu/bgsjSgqQFCUy6YOoUgdcsUZ2fTPydANN9wE/Q9ApfcgvUcv1KMW MOXzEfTt/DP1PCunuXxiD2dKDbRomAhoCYltSP2APOZNnUJqiJ57B3QHICg+jjadm/Pi+zM4tieC uKZdyKjn4Zy+/nvQeGsRlArOZF9CqfprNbUCcO7UcULjEvHw9MXD05dwgNTG6E6tY95/xnHi1GWg ejJdNrcpdQZa9HuSmI/mMmH0p/xm2IlvXHsG9S5XmGh8/Mjo2h1xwsv88OVIerabRKyu8oJx9uge siUfmqTcmrwLgkDBjeuY7BDo74dfYCh+TkcF9bzs7Fq3lPXnL5BzvQg8K67Ejt1Ag8YphOrmsnrb fu7s2Rp/VfmiuH7tRk7naxncKJogw18paT1tOzZkyeQtzNxynue7JFRYjHOZOWcdqOLonuH/p3ub gFDJi3vZAlR0PYuvZy1FZ/CmQWYzh2pGocWogtLsExQBBld8bhvnjh4HpdJVGq+wIOo3bUzO0l/Y sGENvZvc4/p27rUrHD1xBpUyuQLxz+PH8aMZO+sAj706ktcfv9016P/8ouiwhigx2cCiJKiCw0SA wiOHKTGZqnRWwX6Vub+spyC/gBa9HyTBX8etHLwLguAaG3pPX/SusdEIj9Pr+WXHWE6cuoyyRxP6 9G7EtumbeOGDGXz3xn037QJKWb9wOem9+2I0hnD7bbGMXLGC18cvY/QzPSorVopy2LZ5F42696iB 6Lvhxj8fDvN2ibP7NzNj7R5A5sC2JfzseQabXUajD6BPv26u+UVUqFAAu1fNZOmGPdwohaS05tx3 X1+8lUIVQmsrusa82TPZeeAYBWaB6Hpp9Oh2G40Tg50Kruo38IIgIJea2XvoKlmlCjo0C8NPMLNt z2WOXLXQICWQjHhvBxmzmNm08zyrdl/jSqEN/0BPerSPoVWSV40OLcs2/lJRMUs2n2PLb9fJNcmE h3vTp0s8DcN0jnIAgmxl685L7M+6wdkrReSVSnh56kiM8+ferjEYFAKCIJeTCVMJv6w6w66T18kr heBgL+rH+9G9RSgeSqHC/Cqxbv1JNhzI4VK+Bf8gb1o3ieC2dD9HyMea5GOXuHYmm1UnimiaEUm0 qpipS7I4fKkED28jnVrH0L6ep4sEuYipbOfXnadZtCubK4U2gkN86NoqgpYJXs4rcTLXrhWwdPNF 8iSRM6ezmbYmC6nUitHLg/SUQKL8nFcEbFa27zrH8l3XuJxvwcffSLe2MbSt74OiEjm3sXvXBVbs vszFGxYMnh4kxvjSuVkoUf7a8j2K1rGWqRUiolBLv5VB6VOfj0a8QMcH3+a1N8ex9sc38NZr4MZ+ Xn93EiWRHfjwxXvx1iqcbe6Q55UjW5m7eA2Hs66i9Q4kvWUHHujVpoJCQUaSzKyZM5tsbTz972hR vpmSJUwF55i7YDOB9TPpkpFYczmtZi4e2cWGozk0b9eNAOsJJk+dx+lr+YQlpnHHnXeRFKRDMt1g xS+z2LTnKCbRQIv23bjjttZoBCfRxcalrCOsW7eJU+fOcy07H1GlIyIumS7de9A4Mdyx4uZdZvv2 bVy1+9KqeVNC/Dycbe8MwZp7kc1bt1GkjaRVZhr+nqpblv3GpWNs2baLg4ePc/lKDpKoJig0nNbd +tAhPd7VDtX10TJyfmrXWpat2cSRC9dQab2IjU+idceupCcEV3r/8uEtzF2ylsOnrqLzCSSjVQf6 396mzkovN9xwE/Q/AlFDdFoPPv5PL14cN4Nerc/Tu+8d1I8NIv/KGbasW8lvF4p55NXPnQQd/P3D yawXz5ZF+7Em9qN7NyeJ1ATToEkLwlTfcfxKEd0aZTgd1P2XvSnHt6BBkDfzFn3Di8ONtGscwZmj l3hwyHMkB/v+6c9vmT2WUUtO82D/+2iZmUaIn54Lx/cwdtpiwIcuXRrWSJQck6ACv/BUBvRMY8Qv c8j386b3CwMJKNN2CgKCoKN+yz689fAy3vnha3q2OcEdvXuSFOlH7oVTbFyznFN5Kp5989MaCTpA 7rnDfDxyNJcVUQy4907qJ0ejshWwcsZUlu88TdoDD5CYYICLVU2iut7dn+7zF/H952+il4p4/L4e eCuKWDrjO0ZNWkRaz+fo2DSVv+xGmXOVeOK14UyaextvPHov5rdfp0fL+pRkZzFl3CcsPJTLfcPH Uc9H9ae6miAImEoKmDH2O/bprdglGauphAunjrBi+WIOZBVx54sfcU8Thw21l3cAzVqGMnHrEp55 aSR3dUrl+pnDLJs/m0VrdqL0r9AOmmBadOxFi8kz+WLEy1w6soX0pCDOHNrHuvUbOHb2GnFNUim7 FrBk2gRGjJyEMaol/h42Fsycgc3mOKm3WgVSM1uSlhLzB6trB3xp2ySW5ftX8fKw93i4X1d81Vb2 b17KDz/P59T1UuIqxKUTgBs7lvHma29xSV2PPb3vq3GjBrB1zpeMXHyKB++/nxbN0gj103PhxF6+ nLoQ8HaMDYWGh4aPYf7arnz/zlNkbV1Cz9ta46sVOHNsH8uXrSXPFMSW3n0J8AnkkddHs2RzPz55 +SEOre1Nt87NMCisHD+4i6VLNuAZ1oRl3Xu4Vwg3/vWQJDv7lk3nza8XAxIrZ3zGhrlKZFnEL6IV 3ZwEXRDgxoX9DOrfhTkLN1JkkrDbbWi8glm0egc//vAxfkLZKLZzatcyHn/iefacLiAmMR6tXMKS WT/w1cQfeOmtDxhybxvXneFqp+TCYpYs/o1fLorsP3iZvbuz2HiikMICmWefbUF6vDc5Zy/zzvhd TN+aS2CgB0FGkTMbsxg38xDPP92CIb1j8VXfeh7OOnCKl8buYd3xEqLDDBhVEgtWn2DMjMN88EYH HmoRgE4pQEkOQz7dwq6sIoL8dBh0IoW5JvIlkS8XnGLGx+1I8lYhCJB/9iIPvrOVtccLiQg1oBdl Ti85illUcdeAlkwelIBCFJCL8nj0jXXM+/UGIaGe+HuIXN18mvFzDtO7dzpTnk2uWT42O6d/zWLw N6donXaWs4fPc/iKCVEAi11k5oazPP9sa55t4esiOEV5hXw1fhMfr7iCLCoI8lRy/cZxxs0+wlP9 G/PuAwkokDl44ALjfjrEVZTk7DnDkwfOYbPYiG8QyYcvtCTKT831i9f4eOJOvl2fjb+/ByHeSs5v Ps34WYd54tFMXr0nkQCNgL0gn48n7ebzRWfRGLUEeaq4ll3E1XwrTTs1YOJzaTQMc5wCqHRKRECr EKn9mMMhm6b3vsTTM+bzyS+fMOmB3rzaN4Mxw19lw8lcPpz1MSnhvpUUMivHvcLgT6dy9loxERFh lF6/xIQJ4/iu8/3M+GkMgc7+ItmLmPjWEHYEDign6M5DhOKre3l1yMs0e35kjQQdQLYUc2TVDAZ/ sohWLdtzYsdCjl8pQBBk7HiwdMkyHrjvdpZOfJ/lu05gsknIksR30+bwxJBhjB46wNED5OusmT+e gS9NxOjtj7+fN3ZTAbk3Cvj0y1Ref/c9Bvfvhspbxa71C3h3yn5Gj/+SJ/q2QXBZDsDOFT/z8tCP aDtkDG06ZtZY9s1LJjDkrUlcKNIRFOCDCitXL1/l09Gf8th7E3jz4Z74eKhueTA07YOneX/ibC5b dMRFBVOSc4msCznoPRNYenAHzYM9EAVY8eVQBn86lXPZJRXa5Cu+63o/M6Z/QYDqv77Dd8ONfw9B l5EpzgcTRVWMiGW7lTygoKT8dEznGcKg4V8SUi+DLyZNY9Kotyg2W1GptYRFJ9KhZ1+6tmnkSu8X 5Eda0xRYtJ/Q9PYkacsn5IS4FDIbBnH8sIbUBo0raUZrgtVUSh4mSk0W1zOLqYQC8qrcSQWZksIC 7PmOe721LxOBfPT5aMyvDufnL99juiCi8WpMzyceB6C0KB8sAjb5ZnsxiYLCUvIKSyqZHpcUFEBx AWWpo+MSKcmaysv/WYWXlycalYipuBDZO56R07+le1LNZ3llzuL0Rm/ufPwhRvzyAkWSH48+3s+l 7SybwY0BsQz+YAJRqd8z7rsZfPnBMEotNjQaPeGxSXTt05d2zVKcCnQLBWYoLDFVydPbN4Ago4If vx/HktmT8fH0QLaWkm8SaNX3Od4e+hThKrBbrRQX5pOvKMbmvI8seifz3idfohj2CtPGvsGcrz9G I9rIzSul5R1P8vF7L9EgqlzxYSouRJbzsVa5/yRTlJ9PqVSEXZZqYs3IgHdiV+bMmsLTg1/k9Wcf YqRRj91SQn6RkoGvfslHQ/pQMZR6SWEeyMqbnMRR46lNSVEedpPM5y8+7jx1cfym1nuR3Lg5o998 lof6daFsX+kXFsug1z5k88DHmfrZa8yZoENQaGjesROPPhrC+G9XUVKh/6a07Mln47/mnbdHMPO7 scxEJDghnf533k/64U1suGxHUGmAi+zYvp6zRcChrbz/ym5E7I6xhITNLvHi6MnUS4lBK1kpKsyn wKPE5WBNtlspzM/DVFyKXS5/VpCfh1BscvlbeOadURy78AjfTh/Lhl++Q7SbMISkMPiJBxj1xhfk FxRT8Rr66o2ryMo6T9tn3iDAQ+Myz7yVgGPiEyk9PZWXn1tdeWx4xfHRtG/onuww1wlKbMX0FWuY OPZzZi1ZxusrfkJCQG/0Iym1Cf3vGoAPgKgisVlPZixbzoQvxzBv1WxWzvseWRAwegdSL60ldz84 EE/3+uDG/wBEhZJ2D7/KLFmi35uTeWDIlwx9sBlWm4RCbcAIFAKCDObcQ+zNvoPPJi+kWf1w8i6e YOwb/2HeohlMX/AAg3s7/MFczjrIq888y1lFAlMXfUZqhCeiCOcObmHU20MZ9/lomjZpQus4XU2a A0ylVvZtvcjZs9dp1jiUt7ukoLHLJNcPxFZUwGff/8ovJ2wMG9qefk38UAhgKy7kvbHb+PybvaRG eXJPpn/1+4GrVxk6dhcHbN6M/6AVzeOMKIDSvFyeeXsDwz7fTYuY9jQK14Oo58XHWxIarCfAU4Na KSCKsHn+Lh774RRjF8Yz+r5IPNQiX0zYxuJDJYz9qCtd4o2oRDCZLGzfepID9jKHkxLD31vLrEMm Pn+3G+0TDKiVAqUlJqZ+s4lRs3bRsXkED2V41LjzsJgs3LhYwHoUPNS3EePbR+ClsLN7+0me/nQf k6f/xmMt2qIVBOylJpYv3s/whZdp26k+nz6RglEpc/V8NuMm72bU5P34BXgypGsQrVon8OnQUl4b s5v4dvX49NlU5BIraq2K8BBPKCpg4tQ9TN1fyovPt6N/ywCHw8+SIj6dtJMJP+wjJdKLR9sFsWzF UcbPP03nPmm8dFc8/moBm83Oof1n2XBBBnv5uqzUOsieTqWolaCXn6zqGT7yYxZt6snHw94mqbgt o6auJO3e4TzStRFq0WFDLQgCl7ZO58kRX1EU2IF5K0cQG2hEspWw8pu3ef7zSQx6vRELP33Uud5I 5F69zhUxv2rXtJVyNfcqNwpL6rDoS1iKC8i9co4tu/cw6NmPuPu2dijNV1k05XPeGv8zv+3bSr30 9kyeN4m0eD+ObF/NW0OHMm/ubG7vdx/tYlUg6chofz8/z+tDanI0WrUKlUrFuV9X8M5bw5n4zVQy MprTOsmfhg1S8Sn8kcVrNtG9exsidU5LQPkaS5eu5DdTMEPqJ+Jbi7fHuMa3M+7HHvgHhuFt0KFQ KJCKL/HKYw8w9u0P6d0hnbYpkdW+W7BvDiPGTUXVcAAL33uSiABP7FYL1y8c5dsvf3AeCMHFLVN5 YsRXlAZ3Yv5PI4gJMCBZS1jxzVu88MVEHo9qxPzRj/xZhzhuuPH/D0FXaQxM2H6AQjypvMSK+Ea0 5tCBg6h9gyppLo2BUdz16Eu0vn0gBYXFWG12RIUSvYcRbx9vvDwrkExtAH2e/ZR9fYfjHxRa8ZAT v7g0Rs/awusmCAuLKD96qwWdH3mNA90H4RMc7nrWa/DHHLrvdQLCbnaCYuCDKfN4yQRRkWE1LxTO giW16s13szO5nleIzS6jVHsQExEAwKs/beeREgXxQTefpoez8tBvWHXe6Ct4lv1o6SGGWjQEOh2b pN/2MCvSu3P5XBbHTp+h1CwQEplAveQ4wiMi0Ii13NUpM9VTaEhp/wi/7e+AQmsgNqh88aro/dQn NIH+T79Op36PU1hYjNUuoVCo0Bsqt1WDdn1Y/1sT1N5Vw9B5hsTxwvsTuOfpYZw+fYoLV3LQePgT l5BEQkIMAX6OE2Ixqgnj5m6kVNATHlrueSs0uQUjv57LE8cPc+T4WUolFfHJSSQkJBLq74VYoU8M +nwut79tJTI26qZS+DFt4y6KRR3RQb61sWcQFKR1vpe5K1tx8uhBjp3ORm30pn7DVGIio/D30lXq 0+9OP8jgIgWRdVw39AZvRk4/xCuFNpAlyi1CBRRKNUYvb/z8/fGo4OxGUGho3PFeFqxrxMHDB7lS YCUmNoUG9eLQqSSeeeEGviFh5eVS6sjsdi8/NGzD9fwibBLovfzxLT3Lx8O2oNB6oPUwAkqeHf41 dz6Vj0IEWaocXUGyywSGR6IFhNhWTFm6A6vSSFiog5qqkjowZ/0+ZI034SGOuwbq+t1Zvv0woocf 4QEOG359eCNGTlnEgP17OHn6Eh6BUdRLTiA20p/77nwCWedNoHf5RnTTiu1YCGTIk73w0KlrVcA1 7v4Qyzd04/L5LI5lnaXUDMGRCdRLiiM8MgKtiCvcYExqa4aNTOTJV/MoLjEhASqVBqOnF14+Pihd 3UBD/eZdeC+uES/k5VFSakZGQK3WYvTyxtvbm1r0Bm648Y+Ha74PiaZhXCggEByVTP0GDasooSXA N74TM2d/S5TRiEoBJEcjZw9g1gNj2HRwr4OgW/I4tGYaa86KjJ49jV5tyteGyMhoTLmn6P30BFbu 2EHruPa1cBsJRYgfQ59uxpNdQtGpHHfgtRolW1btY96v+Qx8sCVD74iu8JaRIXcns+Wd7aw/fp3u mf5UdxNq0fLDrDsn8NX7Tbk/06/8h1Ajr90TT79PDrH+fDGJ4Xp0WiN3d3GsOdisnDqXz6V8C75h RvQK2HE8G6stAtQWtu7LB7Uv97YPJ7ACy0yI8KLA4gglVnj0BF9uyOGJoXfwRKeKa6cn773SnEmd FvPTlrM8lJFSeyMatTz+aEve7xeOTu3IMNCgoPuKI2y9mMO+Emiuh8vXCvhx3lGCooIZOTSTRt4O dhYb5oVgs7HnjXXMX3WCAV2D8NeqSYzyRCeCj48HjSIrR1z5decF5mzLoW/vTIbfFVtJ9oPvrsfm /ZtZfySbAe2COHmmgEu5Ctqmh9E0pvw7cWFG2pbY8dCVn8Aq1AoEBFQKwWnjVfMEKwiOFMbELrz/ wr08+MEvPD54PTliCtPffoIgL02l9WPyVyM5ky0wZeFYujaPdbmXjX5nAls3JTP3m5HseedR0o2O TaWoAEW1l+EdToTranYtI4POj6ffHMNbj7RzOqyrh9J8gx/HL0Qd3Yoff5pEpIcGUYB4Pw1HNy3k ncWnOHHkGO1iGyCLBpLT2pLidLmUc/EMZy9fwabWEBAayPZjJ8k6f5bWSQ1p37EdXdqkMm3ZKnbf 14/I1kkAnNi8mvWbt9C8x4s0zUivNAdUh8S0DqQ496CFOVc4ff48RSUSoXGh2Hbs5MiVfJqlgKaa d48fPMDFnGLubNOLdpmNy8dBYiKJDVqg89UiAJPHjeJcjoIfl3xJl8xoV5tEvTOBrRuTmff1SPa+ /QhpBvdC64YbtRB0x4mfKCqITEp1ERtZEBx3phBQqg3US21QafCX/a3UGgiPNNS4YXDMfwqMviE0 8g0pf+78jqjSEhwZ54pMXjcnJODpF4SnX1ClfLwCw/AKDKuUh6MeCkKjYgmtSx5l9VNoCA6PpgL/ d70bFJNEUMU6uvJRE59Sv0r9w+JTXHG1ZVlG4+FJdJwn0XEJZLSyOO5fqTSUWQfX2amOIKDSelK/ YcNKsil7tWJbqXWeRER51thWOqM3CfW9K9fL+W9RqcInIBifgGDqpaZhtdoQFErUKmXlDaLag4jY xCoyEAQFPgEhNAkIoVFTCxICGrWqcjrnwb9/eCz+4dXJV0l0YlKVDWmNGnmFhrCoOMIio2lusSGI iiplLmvzkOh6hLjkWLtDFFGhJCy6HmF12DiXOaWRZQGFSktsSmOik+pjtcuo1WrXtsXnJkWY3S6h UGoIjoghuILe6ciGDSzbsJ/4Hu2pl+yIOR4UGkVQaK2FAY2BqPib5Kg1EpuQXLl+Ok/ikzyr1MM3 KJy2XUJobrEhKtUonZfKE5JvcoVeuo/Vhy6T3PMZmsb4OO6e1+KEp9LYaHmLsVFhk+blG4iXb2CN 848jrejqvzW1kXvb4Ma/FS7nUZIdm/MkUypzRlndhkDrR5y3scyvE4KoJjAuFRVWCoocTi2L8wvZ s+MgedlneP2+TN7XCE5rGgFRlCm6kU2JRc+Fi5drLZ9dkvHzM9AoKRBfg7rSmn74dBEXzuYz/uvN zPxpu8uyRxQETCVmrp4poFGelUIJjMJNrA6Zbb8VUZydx+Dhy3hdLbqseERBoLiwhKJrRZy7bsVs A51S5OCOk4yadpgtp/LJL7ZhtknIkoyp1E6Jze4gYahpmmRg5cYc7hq6jgfaR9A0xZ/G8d6otWr8 HdMu23ZdocAqM3nCauZNFl2Wco5TTju5NoljFwrrwvxAIRIYYHSSc4ecNToNMUFGNpy0UWgC9HAj t5BtJ+0k9wohw7uyw7SYSD+axXux7mI+v12UaR8mYLc7aiRVCYEpc/xcEVlZ+ZyYtp3lC36tJHtz qZkrZwsIz7eQAySGGwnxMvHhpJ1cPh9Lx8aBpCf746VV4uuprLR2qVQqBDSoXM4Ia5tdyy3/+g0d xeylm5i57SyPffEJTeJCnPIsWz/yWLPuBIR2pkfjSJcCQJYFtJ4h9OjYiZm757Nx2xXSuwb/1Zow RJWGoLAYBzl3llnv5UegP5j1noQbNC5yKnroCYkKxmw+S6mp2NltRQoun+Tbzz5myoLVXMrJx2Sx YLfbMZnMeCa1wGJzWIcqQ5vSvnNnZi7/nPXbttOjdRI6JFYvW8HuKx580KM19QKUleaA6hR3Slse P44bw8Qf5nDqwlVKzWasNjs2mxmQKbXZuZV9af20xnipFMz8Ygh+5gN0aN2c9CZNiPAz4BtYthu+ wep1JyCsK7c1iqjUJjqvUHp07MisPYvYtO0aaV0C3RO2G27UTNCrISFlm9RqNqtlg7+umsaayFP5 4lq3d2oqs1DTd2qox+8td3W//d58bvbAqVZrqkykdZFv9WnqJpvfVa9qyiwqlGgUyjqVu+Iz18Kt VldWNFTUXgt/fTs68lWg0ShuUvQIt+iLtV+x+D1OTm7Oo1yOKsqKdLOyoezfeWd+Y8zH77Miy0LH tpkEemm5ePwAi+bO5pKhHk/efS+hQu2nE5U3tL9j/FR5Jrt8IKgryLM6ZcmJFSs4nm1l9HMP46UZ pFWtAAAgAElEQVTXOqV+axL8e8aG8Cfmnz+b1g03/icgy9grbQwEUKhQI1NmDmS2WrmUk4PKK4je jw0m2dPuurpUNg6VBj8aN8+oU5aiWD63ls9YNvKKrBSpdfRuFUn7BCOmsnCgMggi2G0SaU2D8RGh ciRHRwiua4U2LEYD/TrHEB+gLS+j7DjllmwSbVI88VLCrlV7GDTuICeLNNzdLZHOaYFEBRsIFm7Q 4ZmNlco79NUO3FBv4+s1x9i65RQGDxUGnYZ2reMY/XwTQvUCF3JNIEDHzok0C1RUuSaoVIr4R9eR JMqUh2+tQGvVKgWO8B8AEmaThVy7iI+v1qV3LZOrVq0gwE9DyQkbeXkWCNPUpDahoNhCgVJLt+aR 9KjnSWlF2Qtgt8ukNg7DIEGP3qm8W2zjvWlHeX/MZT43atBrlKSkhPLWUxm0r+fl8jOiUqpAUFc4 Qa/bPCzLIGhCaJoRxuxtZ2nQtD4qpVh5/bDncumGHUNaEEZRriADR68KCwsDZLIv5QJ/MUF3+gGS ysz5K6xJShWUyvbK40ohIKorR2jJPrmbj4Y9w7hFx2ncuitvvHwbDRITiPA2890XIxm7+lqlftSh TQdapf7M0hXruf+ee2km72XNuo1EZ/agVXoTqnSCKmtbLsOfe4zPvl9IbItuPP3as2TUTyIqOprV 3w9l2CcLqlHelEPX4A6mfP0hr78zmjHvv84kvQGDwUBwVCpPD3uPZ/o0c7RJnh1jk+rbJDQsHJC4 duk64CbobrhRC0F3478F4Q8pJ/55Zf7TCpv/g1PLuioz/oltr9Hr8TSoObpjETvXLnA88/AhvU1f 3ho8mLu6Nalpbf47Sn9LT8Q3I1/lw1PDRnFf81jUiorXL/73xoYbbvyzyLfzr7rOzbd4olKIeOnU aPQ+tOs+kAHNvSix2G8amyJKleoPzCQuBoOHSgSzQJP0KF7oG01JqbVKoZRKBWrAWqWiKryUQKmC np0T6dHIF4vZXuV9lUqJgJ1vZ53kwEUFP43vRPcGPhjUooMAmuxolCIVeYpXaAAfvNGVoYNLOXI0 h11Hs1m/JYufFxzgZKmSLe+m4at3eL2qnxrL8528qM47ikLxJ6PBCJX/o1Aq0EgyJaVSlZ/tNpnS UgmlSkStVlQWlXxzS4vo1Q7Zp9YP5/kH46uXvUKBSgBB78GD/TPpeXtDzpy9wZ4jOWzaeYblu07S P19m9huZtElwXJnz0Hvi5ReAXq2qM0F30l9AQKVROmUnVtwuOAWqw0MFJTdMlS0WnCguLnWslTq9 q/KyQx9xs3aIv/Jek3Crh0K5vAEO7N7ClNm76PTQcL4f9wa+asFpSXeNkEAvZPuVSp8IzWxPp45t WD5mGfv2H6C4cB0bf73Cgx90JSPZzzXWb1WT02sWs2DZahJuG8yED18kPSkYpVKFQhQ4HuKLEqGS 36Tq6EOHu59lccf7uXb+FHt+3cvuHVuZMXc+Qwf0wbBqDwOb6TAooSTX7Ip7X22b6PXu+dkNN6rM xG644ca/CvrAaJ58ewy/HT7KqZMnOXHyJEd+28e8qV9yd+cmtfsr+C8itWN/Pnj9SYI9dS4lghtu uPF/sNirHPOB1Wb9U98xehrIaFKfosvnWLliGSg16PX6Sn90Oi0K4c/kIxITbiBcX8SWI9c5bwK9 ToVeW/mPWumgbpWOFmXH+w0SDOhtuSw7nE8pYrXviwoBKOH4NTOE+9M8zhMfvdJ1OotGrFZR4e2t IzrCl64d4njpsab8MrEPPfxkdq7N4opNpkVjP7DDrJXH0Gqr5qvXqlAL0l/YugJGTw+S/axcO5fN DScTKptf84vNHD6Zi7+3lrgopYvYCpKELNlvOuEXiQgxEOtVws6jOZwquYXsVYKL2+r0akKDPWnR NIJB9zVi2phevNQ5jKu7z3HsUpHryx36v8Pewzvo27qhyzy9btUrM7GQK2ubKiGEtAaeSCfWcahI dLFB2amA2LV9HaAjrXmo830FGkAuuIqp4jcFJR46NTJ/4+Ik31w3idycK+TiS3JaOiEGDRrXNTcV SmVlKwyHGIy07diJhmFFLPhxNKO+XYiY0Ir2rZqidSaqaQdw/tIFcvOKadSiNfHxkWjUahROUwe1 SqyTcl+p8SA4NIKGzdrR/9Gn+PirySwY/QLWoiusWbUdSQiicaoR+/G1HC5SVGmT3TvWAXrSmoW6 J2g33HATdDfc+Pei7J670duPiMgoYuPiiI+LIyY6kiB/H9Qqsfx++z+w7BqdAS+D3uUPwO211Q03 /n4Iooh/cjxgY9mC6Vx1Bjq5cv4cVn7neaHOn9RO/WkbauancW/xwkeTuZzvIOOm/KssmfYlzz45 iO+XHPijEwUAHVtF0qN5CMtn7OHFz3ex77zTo7bdwq5fT9P/P0v5buU5JG6eRhzv9++dREaMkQlj N/PGd4fIynFU2mYqZd2mY/QYuJB1x/MBA+FGBZy9woaT5V67C67k8NKw7ZwvsDi/LwDF/Oe9raw9 6vD8rVAq8NCr8TZK5JplMOowihCYlsSghnqObznC7SN2sr+s7JKVPXvO8NoHKxn687m/tI1DA4zc 0zmCg3sv8PHPZ8B5TUwuLWbOgn2sy9HQokkUSc7bZHqjhsAgJb8evcaqLMdJZmG+ifwSidZNw+nT NpyN8w/wwujt7D5T7BStlb37zvLIi8sZOz8LpSAzedZBxi3IokR29DOtVolKJWK220GrxkNTbqh5 /the1qxYwskrudjgr5v/nex10KCBYL/EC8+NoMDJBgUBds0dyfhlWUS0eZhOkWrncw8ik32wZm9h woosV1l+2ziPAQ+8ilWh+b/xPyLLgIjR2w8Pcjm0/1dyy36zFzJn/GeM/24eSg+dqzxOtRSZHTvS sW1zVsydw6r1O+jcqydNmyQ6RVJz6UMDfTEY9WxatZyrN4pdz7ct/YaPv1pMkSy5CHt1WP3Tl3w0 4SeySx0lUmt1GAwGSovzsAOegaFIsoLHBz0E9ou88NwIiiq0yc45HzF+2Wki2z5Cp0iVe5J2w42b FWBuEbjhxr9oo/2HfRH888ruNlF3w43/M4aOIb47gzuGM3btFJJDFqMQRAwBGew9sgwFMlYLmK22 aviDhAV7pRCXMamtGPvjjzz39POMGfYok0e9jFqlwG41k5dXQHByM9o84FMrMbHZ7FisUuU75M5p QRMYwPDnmmOyb2ParF9ZsvQQHhoRWZIoLrFgsmho3ssRT9smy1isdix2yXXSaIiOZNIbLXhm5HbG TdrC5Gm70KpEJEmiqMiMBQNDnBm+ODCJle/u5YkX5/NxqAGV1cr5nBLCIzyxWCQsFUKFrV95hMkr jhEUZCQ9zguFZGHPoWxO5gi8PyoDgwiCoGH0yO7Y31nL5Dl7WL/6MDq1Q3laWmqlxC4wbFjtHtwl SQKr3eWkrZyPOmRntkouc269ryf33ZfB9sOrGfXJapYt9iPBX8Opc9fZf8FM+04pvPlAubPW5PgA 7uwYywtfH+WOh6+hEyQiE0IZ8Wxzeqf58vJTzSiybuebeXtZvfoIBo0CWZYoKbFQalYT1yYJEDh5 5DKj5pziva99aBjrRaBB5GTWdXYezqfPwJa0qFfeD9bPGMfLI2fx8uz1REcGYfid3dhutyJBFXng vNPcbODbvLd2K8Onv0/S1jk0T08i7+Ixdu87gs2vCb98/R56Z/8SRRVPPj+Er+95i9fuaspX4SFI Rblcv5FLZEoK2M21huB1tZPdimyxVG0nWcJiBqvFVkWjINmsyGYLdsmRR9PmbRnQvRETJ79P6voZ +HvqyL10HnQ6LLKu8vfLovYYEujUvhULF60hS5tGh5YtCFE76Xkt62t8t/vp1XoGY+d8R5v0FUSF +lKQfZWrxUrCvMwOZVaF+thsFpAtrrFaeuUUI999g4/eeInUtHRiw3y5fOoA23ccwDftXv5zZ30U AjR/6G3eXbuVt6eNIHHLLJqlJ5F3/hi79x/BHtCUH78ZgY5/rtWfG278t6BIadrtnXyrnsf7Nqqj sq/qIPp3Daxyz6YVy+/21uyGG3/RCPvXzxFuuPHPxKVLl/D19XWNJavV6lJ2bdx1nBx7MBScIDUl gYz64ZXGnqjS07Ln3aTFh+DlF0pqeia9+91Nq7REkCTMpQUkZnagU5tGlUzrJLsNi0lDy44dyEyO cqyfopLAqHr0uvteurTNIDAgiKjYBJq16sDTL7zGu8NfITMpBKVCvOX8IChFZETCY/zp0DgQX71Y maEDXn6e9Ooczx0tQ4gL0hMd7k16/SAG9E1l1ItN6ZHmjwCICgGrqKJh/RBa1fNF5zTnDwj15f6e iXRp7EdkoIH4SG+apgbzRP80PnuxCRkRDooYEhdKt1RPLCYrRaV2AkN9GHh/E8Y8mYynXkuztDA6 1PNBFNT0bheCn1GJZLFx5XoJVllBw0aRfDK8HQ8280PhbBut0YPuXRK5t2MokX56oiO8SasXyP29 UvhsaCv6pjniut9Sp6IUUcgygo8nXZqFE+1bfsqodt6LD4/yp3PTYHyc1sPe/p50aRtNgq/IldwS sotthEYF8vwjTfhgUAOCtBWcjqrVNGkcSsfG/gR56UhJDuT2dtF0Tg/EQy1g9DFyW4c47mwbRlyQ B1FhXqSnBHJ/7waMHJJJ38wgRAGaN/SnQYwRQbJz/UYJ+SUSoREBDH2uBUP7xRNqKL/zXpJ/A7VX IK27dCcuxO93nxCZSwrx9IuiY/eeRHlrESvcGXdEaNGS2fVOWtYLpCDvOmfPZyN6BND9nmf4dtIo 0mP9EYWyy+YCgXEZtG8cTu71HIosFmJTMnn+zU959z+3Y7cbaNWhE82SI2tZ8CRsNivKwBg6tG9P TJC+0tixS3bqN+tAq2apFcaVjMViR+MXQ8d2rYkO8UbvG0ZGs2aEGOHy5RxEtZHWvQYw4t1h9GjV EJ/gWDq0aUFkgJdLwSUIAra8C6xZuZTQtvfz5KABBBvEKnvcqrtgENDSrksnwn013MjOxmrXUC+z Ix9++gV92zXA3y+Sdl26Eh3ghQIoLSrAO7ox3bq1wVuvJa5hJo0TQlErZHJzLnP5cjYeftH0eewV Jox6ibhAT0RBQBC1NOvajxbJARTcyHG0iSGAHvc8wzeTRpEW4+doE/ce3I3/z3Dt2jU8PT1dY1WS JOxOpWBeXh7CXU9/Jp8r9mPHlIG3JLDlXrWd/7VbuXJwC7O3HKN5l7vJTPT91wnm8L7zrD9SSNu2 UTQI83D3lFoI182T599NuH4fyZOrXZAqpb+pD7uJ498Ly6UjTF+8loDkdnRqXs8Vv9cNN9z449i9 ezdxcXGIztjNxcXFrjns/a8WcdTcGPnCEu7vdxtP3N282vnRajFhsdoBAaVKhUatQpYlzKUlSIIK na6iaa+MZLdTWmpGoVajVaucjqPK51K7zYrZYkWSZERRRKVWo3LGVr7V/LrnaA7z1mahEAVssoBG Jd7SnNbhNVzCYpUcJ4iCgFIhonHGTHc4MZcwWSVkwfEtsUKeogBWm+Q8qXdGDVGKzutA5ToByWan xGTHapcRRAGtRolOJVBisoMooFWJjrrIMiazDYtNwmZ3hqtSOu64K4Wq14slScJsuansahFBppZb zjJ2m4TJKqNWK1ApKh8qWK12bBJoNMqbiL6MxWyj1CJhl2UUChGtWolWLVa58i0ANrsds0VyhNBV CqiUChfxFQSHZ3LzTbJXq0RE1x13R1lMFgmb3fEdhUJEp3F8p16MD52bheFj1Dj6nsWGSqtDpVT8 bkJmtZRisdpRa/UoRbHK1YayUJs2i4lSkyNkmCCKqNVa9HqtK0RsmVILwG41U1xSik2SUChU6HR6 1EooLjEhqtTo1Kpa9yp2qwWz1Y5aoy33XwBIkh2zyQSiEq22wrhyknqzxY5ao6kwXiTMplJKTRYc TvE06LUaJLsVs1VCXXFsOdQSfD/iaZ56fzbDJ/zA8Md6VfitxkK7HMiZTSWYTGYkCRQqNR4eemS7 BbPFhlqjRelsJ4upBKsdtDotougYezarGZPZgtVqdYRnVihRa7Toteoq+67q2sSjLJKLex/mxv+H OHjwIOHh4a713Gq1YrE4rmKdPn361mHWbJZSxr40kO3Fyfzw/XtU9LEo2yyc2zKfV96YwbtBbf+V BH33lhO8Oe0in0T4ugl6LRAEAYqLmbfoMHNO2XimfyNaxej/9jyLd83jrmde51ePdJZ9M4qMhPBb pUYQYNrwAbw2YT53vzub9x7rgkGrcE38ZYvEq/e0YNKqC3yzajt900NRiu5F4W8h6Gf38OE7b5L+ 4Ke0TEtwE3Q33PjvzeAIglwhpKUWlbryZl0QRLR6Q+XNu3NzLSqUeBiUVTbSZf9WKFXolaoq5LKm U7zUeF8SIr0cjsqom6+wqsrV6n+v9ltCZcJSxbFcNWnKvlXdd6urVk11qK3sNTTdreVTw2+/q3w3 y0b+A+UXqieEsgwKhYBG5Zj/K/U92eGGra7ETJZlVGpdhb57cx8r6+egVGsxqrXVfqNK/1Vp8PSq GnbOw8OjVvLoiieu1qBUV3zmqLsoKtDpPSqR1bI4gUqVhrJhU640ENHqPNDqKu9JRbFyWsEpt/yj m1i+YhURTbvQtlmzCuNZqH0wOce5RqtHo71pPydqUKo0ldpJrdWjrlBvGQGlSoNBpbmlbBwHO3Vv EzfccKMct7QwkiQre9cuYWme05nHTbBbLZhLSrDa/51umG1WiRKTDZtdcveCOjEuKydOXmXFbht3 9rBCzN+fpSjbuXE9h+tSITap9nZ68KWhTJqxmC9ef5E+XdfRJiHIqeV3LAC/zX6fSQu2kzLwUzon +7vJ+d8JyUZJSTEmi9Xtqd0NN/4RJL2O7LHMWqoak9OKG+maN9W3zk+WZVRKsdJJoxv/+6hCxH6n SXPV/lZdH6s5VGrd+y91SldT+M+qxRUqRLGvex41pV22ZB7ztmbx8Ig3aNog0Km2qJtc65xnLfNA 7d+ve5u44YYbFTjQTTOoazOtVKmQ7TbsdhlV9etvrZOxfNP/a0tfw69Vfq8uuVyh/LcsUxUtuPC7 35frwDhcaWr5pitNLTL4vfKpy3dubqPq6+tMoRAQcThnKTPHqNxv6ih7Wa5zX1Do1IhKBVqlGoUo 1lx/AO+GjH7zaTytx3jp3a+5UVhKmSdbTKd47o0vyPdM46u3HsbboKlTv7xVmrJnVX+rqX51bSe5 1nFV13JXSVexneTqxlX1fUKuSz++qX6CIFT19fBHyvw75hE33HDjH64qcG/I3e3uxl+Cvs9+wLXr uYwZ+iC6MnruFrMbbvxPQHnTDIqAjN1SwOTPx3AoV8JWeo7PvhiD1mZFVKlp3LY3HVIDXekVokDx pf2M+fI79p28hD4gmtvvfJC7Ojd2mrjgMkOSbWb2rF/AtLlLOHX+Ohq/YNp37Mk9d/clQC/UYOri 0MCdP53Nsk2XiG4USddGPhw/cpHVe7JR+XnRqWkosX4O0nX8yEVmrTzNnqwCJLWKhg3CGdgjhvhA 7a25jytvmZ3bTzNvw3kOXyhCZdDRND2SQT1j8NMrXDZvF09fZtG2yxw8nc/FnFIEUUl4mCddOyRy e2Pf8jBSZSElNp7gl+2XOHKpCI1eR2KsH51bRtGunpfzXptDRhdPXOS7ZWc4kFWARaGkYb1gBvZN JtFPVat8TKVmliw6Qo6HL4/3DGPV0sPM3XGV3GKJ1EYRPH5nMqEewk13sGSuns/mu/kn2HO6AEmt pllGOPd0jiXGx6GaMRWZ2Lr5LCuPFGAqkpm3/DDnj+goNkHjBkF0axrk0vScPnmFGctO8eupfKwK JfXrhzGgeyz1QnWV7iOdP3mVX9ZksfVEHmZZQUS4N62bRtA1PQAfvaNbqjQqBIWIWqFCFGoi6K5O RvOH3mHg7CWMm/4e0+/vy5PdGqBRwjevPs+mE9d5c/pi6oV4u+6iOch7Lj9+O4G1Ww+QUyQRUy+V ex9+ktb1gspN5GWZi3vXMGPdAVrdPogWSZ4uGdptFrYt/4ndWWbufPJJIjW3LqcgQNGNayyZ/gOl wZk8cGcGC7/9ioXr9mBWedP+tn48dl83VLKVI1tXMvmneZy6fIOghHTue2AAbRtGuspUfOMyW9Yt Zc2W/Zw7d54ik4RvQDBN23WlT6/bCPd1LNnH92xkxbLNpHToSYeWjRBdt9cc5dm7fimrtmbRsU8v mqRE1bC5KmbD0qVs3LqDU2cucP1GER7e/iQ1zOShhx8kNsgTQZBr3KDZck8z9cef2LhjPzmlNoLC Y2mUlsnd/XoR5KVzndxhus6UbyewbutBcopkYlNSuefhJ2idHOQ2iXPDDTfccOP/XzgV6ZXM02/h Z8cNN9z4l+Kupz+TMwdOkcshyabC03JjveOgDpAVKpWsVCplD08f+eWJa2RZMslbv3hGBlHObHe7 HKhFBkHW69UyIHuHxsnDpm5zfE2SZFmW5YLs0/KIQR1lEOXQmFS5e/euckaDWFkAuUmPgfKeyxZn evmW2Lj8gJzc+lv5tlfWyoPfXixr0ifINPhKDr9/sfzL3jxZlq3yN99ukn2bTZT9ukyT2z+1SG59 /8+ysdlE2ffORfK8Pddd3/ru81WyNu17edL6S+UZWIvl199dKuuaTJQjes2QuzyzSM7sN01WNZko Rz60Wt53qaT8/QlLZa8WE2R92x/kpH4z5JQ+02R900ky6V/Lj08/JReZ7c6UdvnD4QtlQ/OvZWPn aXKbR+fJqb1+lEmbKJMxRd6ca3fVee6P62Rjs69lY/upcqenF8sdHpol6zMnysYuM+VfjhbXKp/c nAL5jm4TZH3HmXKPR2bIpE2UFU2+lsX0CTJNvpXTn14jX6j4vs0ib1q1Xw5tNUFWNPtGjus7Q066 /UdZaDRejn9wsTz3twJZlmX5+vlsecjL82Tqj5fJmCSLGZNkVcYkmfrfyI9+ule2y7IsS2b5p+nb 5IAWE2XvjlPldk8ukts+MFP2bj5R9uq9QJ669Zor22W//CrX7/KtrGg1WW70wFy52b0/y8YWX8sk TpQ/XHJOdkn5/Gq5VYPQ/8feeYdXVWVt/HfuuS3JTe+dhNB7r6FJx4IIooIIdgQdy9h7GctgRXEo iiKCKAoCKr3X0HtvCekJ6cmt5+zvj5vcJKQQlJlxPu/7POHhuWfvffZZu75rr72WCOs9Thw8my6u hgrZlJxcLhICPIVn06HibJ5Z5Oz/TkT56ESToU+KrIJSVz8XQoiyi7tEnxbhQgMivFFz0aFdS+Ep I3SGAPHs3I2uclVFEVs/e0zoDB7i7cUp1d5rKSsWr9zdXpgC4sTGgqtWU6SfPSSGhCF8wtqKG7o2 do4xg1EAQu8XJW66+wnx9pNjhBYEGo0wGHQCEE27DhJL9ma6yjmetEwMbGsQYBBRjZuJNq1biLBA HwGIjsMnio0nc4QQQhzbtEj0be4juo96VBxItZZ/fbmwcg+K+0d0FoHtR4hVe87WX3HrPjG0VwsB iLDoeNG6bWsRG+YnNBLCM7KzWHngvKjo9cXbvhaRfnpxy+OzRG6hxfmqo7+Kbk3DBOhFy45dRO9e XUWQt0EAYsDDH4hSi3MOKL2wUyQ2C6vRJnpjoHju683V5hU33PgrYc+ePSIvL08UFBSIgoICkZaW JlJTU0VaWpqY/MJM0f+pXaLf2JfFrB92uoXlhhtuuOGGG39SHD58uNp6npOTI9LS0kRaWprYtm2b qJWgq6oiCnLTxZgmOmEMSRTpVrsoKSkWJSUlwmp3CNVSInZ8MkUAwieypXhr5g8iM69ElBZdFlsW fyT8QDTperuo4CqOkhyx6O37hcE7RLwwa5WwKQ5hsViFtfSyWP7l68LX4CHGPDG9GnGqDZtXHhat un4i6DBbtJ70i3h/8SmxettFsSYpTWSX2MTKZftF7A1zxcTph0RqgV3YbA7hEKrYs/GwaD/sC9H/ 5d3iRI6jToI+4+N1wr//PPHmkvMip9guLFZn/rWLd4jgXrPEhJmnRXaJk4KcPpUhTqYVicJSmzBb HcJiU4SlMF+MuusbQfcfxMEcJynJ3H1E+PWcLXq9vE9kFFqF2WIXZRa7yEzNFi+/tVHsL1SEKoQ4 s+OQ8Ow6S4z88Ki4XGp3pjPbxaUzyaJ531kiYsIGYb+KfPJyC8Xw/tMFXb8QfZ7eIjYdLxAWm0Ok JWeLKQ9/J7R954u3fs1wpT9z8pLo0H+mCB+9XPxyqkgoDkVYzBaxauVBEdXjX6LT5A3iWHE5N8vK Fa+/vEz43viTmL89V6gOhygutQmLzSmPdasOiyYDvxRj/rlXJOfbnLJXVXFw+3HR45YvRfent4sj uUKIjHQx5v7vRPDY38Tyg3nCoSjCbHWI4vxCMWv2TrFkT6Yoqahg9mbRu22kaNR/ojhyPvPqvb0K aVv48h3CqEFMePNzMbJjtMDYSKw+liYcatVeZhWTEuMEkq945/vtoqi4VJSVlYns87vFwOZBQmsI FUuOOgWgKorYMn2KAI148/vkGgT9xTtbCb0pUmxoCEE/c0jc4IdA7y2GTXhW7DmVIew2szi64zcx oImPAI2IatFdTP9utcgvsYrSyxfF7FcnCfAUdzw9q7K9s9PE4YO7RfrlQmE2m4XFahOKpUDMe+9v wkPyEpPfmFtewWTx8r3DBKYm4tMlW6vJavt3H4gmJknc+dx0kW69ygi0ZIndew+KC2nZosxsFhaL RShCiN3fvSUifLVi6JRPRdplc50E/blbWgrkcLFg82FRVFomzGazMJcViE0/zhCvfPadsFjtQgiL mNirkUDyE+/+sEMUlzjbJOtckhjQLFBojWFi6fES98zuhpuguwm6G2644YYbbvy/JOi13EGXkCQN Hl4mdBpAkvHSa/HyMuHl5YVeK5ffgVVBZ+KJd+fx4kNjCPX3wtM7gJa9buLmfkFczjrGgUcMu6YA ACAASURBVEJnsRlpF5i34EfaDZvMPx4cgk4jYzDo0XsG0HPArdzSPYoj+zZyUi03V67TrAdKbRpu vLU962aN4MlRTRjYI4aBXSMIthXxy+YLeDeLZ8qYVkT6atHpZGQkOvdrxqD2YRw4lsG5rOLay85M Y9G2dLoNas/EgY0IMmkx6J35B45uR5cIE+v3XyK/1ApAQpNQmkV44+MhkZaaz+ZdyazYdRnPAAOU 5nOqQEEAZ1NKKLOpNI8LJthb7wzdYtASGhHEy88m0s7bea3gX/MPokTE8u0TrQjw1DrTGbVEJcQw ZVgEmacvsqng6vJR0RDaKIaV/0ykT3MfDDqZiCg/Jo5tgqPIyr7UAmdai5mjSec4YPFg/Ni2jGjq jUbWYDAaGJwYz0t3xrHvWAbLtqYDoNfJGLTOO8VGgxZJljF56jDoNFCUz4Zt5xHR0fztjnbE+Omc spck2vVMYHi3KI6dyOJ0ZiGX821k5VmJDPUlNsQbWaPBqJcx+Xlz76Su3NwxpDJigF5G0kjoZLla 2Jx6bKhd5vt3vvJPBraKYNHrj/Lz/kvc94/p9IwPKQ9H4/SCWrh7Pt8nXaTHxOd47JYueJs88fDw IDiuC19//gLCmsWML+bVNKevz9S+YfZpOCRo3HUsP897l85NQtHqjDRt1pqxwxLR+kXz1OszePSO wfh56fEMiKXbgJtpayoj48wxysrL8AsKp027LoQH+GAuzGHfjs2sWLWRi/kW/LzKyEhPIRvAEEPf Af2IU86wcdN20u3lZuRc5rd16zijbcmQxG6E6+v/CqEPpkundjSKCEY1F3FsfxIrli3jYpkDnV7P 6XPHMVvK6pCLlVNnckAfScdmsXh7emA0GjF6+JI48kFeemgMBr2Wgl3z+X53Mj0nPc9jt3TB5OVs k5D4Lsyb8QKqJZPPy9vEfRvdDTf+1y11G+YD43rl+x+WVP3+RGqRj6hTZuK/Ir8Gv6NB/k7+23K/ +m/XS6aiHh84v6dv/KfGcl2/ueGGGw1DLXfQqwz6qzMitDrPSnaIhE7nQXhQLMqZIqxlgC8U5aWz 71gB2cfeQPvTWzUGsKqqNO/VmPwCIKD+yVLV6Ajy9yJU53x/RX1TUktIzbVx9MAJut18uhrJkCRw mO0QG4HZ4qi15GOnCiiyCLb+sJNGS5OuFAuOMhty60DsDqdUbPkFvDVzL7NXXSKnzOGciCqCTzrA qgocQNcuYQTrj/LlrPVYMpoxsH0o3dqF0iLSyxXPEqWYTYcsWK3J+HadU6NuiqIiaWUy8xXwk6/a JpKkwUD5vX9A0sh4+XtjUFQsNqc39KISO/uP5+Ht50GHFuGutpAkCcnLiybNw9HlpXLkXBEQcaUe oBrSM8q4kGnl7J4M+tx2EUmqTCRJ4LDYITKUwmI7gZ38aBHjy6xVh3nIUcLoPjH0aBtChyb+eJR7 9RUVsW10ejQa5x10SWqYx1/XN2uj+ei9p+gx9jnyo27ixQl9MBkrQgU5i0/afgSrTdCr943otdXD CEX2upGm+idJ2nQQhSu9KV4faDQGZ9iScuWDTq/HP8gPVQg0cpXYPpKE0csT3yAZu82KFfBEAmsR a36ay0tvfsDeU6k1owZphCsCQ2KfvvTr25bFa9eye++tjOzRlOTt69i6dRs9RjxCp04dqr2vlj0T kiSx97f5vP7me6zfdxKzXamWJhZnnOFaNUcY6N+rDb+d2MDgYbdxz+jh9O7Vk65dO+HvoXXJN2n7 Yax2Qa/EETViKUf1vpEmuqfYtfHg1eO8uuGGG3960ilJEoU56Zw6cwG/yHiaxoY3JIgzkiSRc+ks p1NyiG3anKhgf/5/TwrOu8XZyceZNKAD50Pv5MiOr+sMwyNJEig2si6d50xmCQktWhPma6xW1p4V XzPxrkdo99D7LHz/kX//F0gSWItZuOYS57MsyK41DtBoiIr2Y1jPKII85Oo+Yv4EcjeXmVm46Dgl XibuHdsMbyA7I597Ji3mQlRTTnzRDwm4dCGbCQ/8TFGLluz7tPd1k5utsIR1O1M4bzUwvFc08UH6 GnU8dTSVlbuyaNM9jj6tA9D9pyUlSaxeuJPbZxxj6JgezHukBUa9O1KDG25cH4L+Byeyin+1slyF LDiwWYvIA9rdNInXJw6n1GKtllNVVALDY2h2reHIq5CJUptCfomVJp1iePDGBGI8BQ61isdyVSB7 m+ge511rUQVmB0WlNnoNbsG4HqH46wVVsiNUgd7fl+gAI9gLueOp1fy8v4ghN7bk7gExdGjiR6Nw b76ZuZIpc1NdcVZ1MY1Y/m4P/j7jIAt+OsyCJc7J1M/fj6ce68kLI6KQ7HZybODdOJKZExrXQeZk egX//slO0mrQViHXDkWQX+bAqNMQ6K2rJLfCGYvT4KHDS1IoKbZftewym0JesZWYthFMvrU58V5X yF4IZC8vujU2gc7IK1O7YjTu5cuNF9m14wLIoDd4MGZ0e966pzmNAsoXH50eraTBIGuv4iSu9n6R 0LkFOp2WgPhwvPVa17OKRT+3sBABBEf5uDZ2LhnoAwg0wYm8AhyAvmZX/3fsBdCWb1pc6rGKd2kk JF3VIC2l/Pz1NO6c/BbBLbrz+mdvMahnJ5omJHB252KmPvAgZlulMkof3Y0Bffvz3fOfsWnHPkb2 aMqG1evYfUbPa8/3pbVT4+WMf1yLPCVJYteit7n3qX+QrMRy33PvcuvQviTENybGeJae3UZyye6o 9/Me/Xg+paZn+fDLH3jrxXXOsSvp6T7kLmbN/pi2UT7kFjnbJCTKx1UPV5sYAggywenyNtG55283 3PifJp0AB9ct5t57n2HgU58w662HGzC/OhOsnzeNya9+z6vzf+Dxuwb/JTR2QghsVhtW29XXZYqz +XXGS/xt4Sk++/JH7hnarPq+S1WwWS3YHcp/7gNsJcxdcoT1B/JBlqpr+yXQm7yZ8Y9BjO8RjFGW /jQ6l7KyMj79bCdpoZGMKSfoCLDZFKx2tdrWw2ZXsDqub/heW0EJS5YfZW2RD02bhF1B0J04fiiF tz89yAQPH3r+Fwg6QKi3Fptdwejh4dagu+HGv5Wgl0+e6h98hd7DG3/AaIzillG3IVS15mnf79GU VsnjY9Ri0mkweHnRu2sjukfrUVVRY12vK0JkkJcOvQwmXz+G9mlMXIC21vwaSWL/qnPsOFvEsPG9 mftQU8J8ZNcJo7aWA+4OvVuytldLivOK2H0oi11HMvly+WleemUVQVF38VA7PeE6SC+VuWVEMzzU 2vckv2e+qyuPVpbwMWqxOhQKSqrQHcnZ4jazgzJVxtNLW4P7XnlIajJo8THI6LWe9OjUiL5xdcne ifD4cD58+ybeKbVw/FQOSUcy+W7VORbM2YrRx8ib45oSbgS0JkJDQvEMD0Wn015Dt5Cq9Y+qMqhK QP1NJiQgL7O4xkYBRxH5JeAR6V1jkKjXefFtaAtW1FwGCs+eZPWSJZia9eH92QsZ2zvSdeJg1Otq bfe+/fvTt80C1q/fzpa2/mzatZ3wnsPo1aWza8DXOj4kp1nIj4t+40S6L/NXz+fOwZ3QVCg7bAYk qQEm5x7hPPP+PJ55byanDx8kafce1i1fyHervmLIeE9Or52Ov8kbCbicUVK9PAmwFzrbJNoH2T13 u+HGf5QY1rVG1/1MuNbF+tILoeKwO1DVa5tXhariUB0IVVxbvf8N3q6vftpbcX2w4c/+8AmyEAhV weFw1GHZ9Du+qQ7ZVVi9Xb22ApvVgWerWH57uTudo72wqQrmEgu/LN3PCwvPMeWT/SQm9KFZmMcf 4ni11f/3En5vH28+/nAoZTqv+o08y8uX/vDYqa2/C5R6+zqoqqjF/L22/XXN3+uqy7XUMcxbjySB r49nw8rGzePdcKMuaOp7pDVKCEsJ5j/4El//WLo11XB230qWHStB0mjQVP0TKg5rGXYJfu/Fmcho E83jfDm69xI7j2c7v0AjVfuz2xQcdWiLmzX3JybEi9UbTnMqs6TW/NZy8/jMQjMWq0KzJgF4GrW4 Ym3XMdlI5eHofAN9GDSgCa883odfHm+LrFFI2p2FkLzo28kLJTOVGdsLarxXo5EQZjtWSeJ6XSzy 8dLSoZkvRfllHDyVWTmJApjNJJ/NwuZvpEWFxYEEskbCrirYHNVPSsMiPGmd4MvZw+lsPpReq+wc dgV7ObGVJAmNJOHhZaRjx2gemdiVpS90o2czE/sP53L5crmFhRTPt7/uYNmcF4kL877OdBe69WiJ ViuxfdtKp0+FKjK4nPQbp2zQsVcrFxn0kGVAkJ+fXlV/VX7C+58j7RJQYjaTk59PUEgwsY0jqysk NNQa7iy6W1/69u/HiZ1refOfb7LtQBojbh5Eh1bB5d9e31JZQGZBKYQ1JirED7mqLBuqPJIk53jX edGsY08mPPw35q/cwZ0tfcncvpn0MruzTWTYsX0lXNEmuUkrOWWHjr1a4jacc8ONhpGU2u4i1/d7 fRv00uJcjhzYzdYtWzl09BRFZrsrXGfN/M510VpWxMnD+9h/5CQFFocrbGVFUo3kJHy1XWOq726t VE4IJY1UZz5JkijLy2DfriR27jlGfpnNSSSlq9+PbdD92SrvMRemsW/nNrbt2cflUmsVIlSV1Aqy 08+zL2knW7Zu59S5S6hU1kdcUXdUlZyLJ9m2axdnUi8j6bRXnWtd9dZonGXUIdsrYS3J5/jBvRw8 foYia5V2qvIdFbIryLnEnp1b2XXgCPmlZldbNExmIGtlfLz0eHnp8TMZCQ/358FHutMlwoTtTBGX LUo1+db2fTXfVb0PSpJE8eUidhxI4/DFItRq67+4pjGk1+vp1y+B4b3CMVzLHqxK+N7iolIOncxk 6/40jpwvoMSmVhs7/4bR7xqDxQWl7D+azo7D2WQW2sr7o+S6Oy/K5WU3Wzh2PIst+zNIzbO6fkc0 rI7eQc6DHn9/g0uJU1GGYrFy5EQG2w5kcC7L7NrLuO+pu+HGNRJ0SaMlrlUTrCVHeH/OBuyqSkFO Cmcv5TTMYVc18hzHI088xeXze5h6541880sSRRY7VnMh+7as4OFxtzPunqewVSEZ1844A7g5MZbW HqW89NEOXll4hrQCGw6Hg7NnM3n7g3WMfWMXSefLas8fHM69fSMIK8tlwitb+NeqS1wutWOz2Thy 5BLPvPYr4z44RFqRQvNwH7y9dPzy2ynS88sXYruNRd/v5I0fMlAtTkKhlWDpd7t54osjXCxwbmQq NjqHk/NRhSAq1hchJJ56oDP+ksLzz//KGz+eJzXPiqI4OH8+i4/m7KDtmGXk/BH5XAkPT9p0T6AF pXz7wxE2XLCU101h6+6LvDr/LK2bhjCyT1S5lsVIaLQvZRfz+XV7CvkOQf7lUlJSi8Hkx5De8XTy tfD2jF088/UpLuVbcSgOLpzPYtr0jdz+6nZ2nDdzcv9FXpyxm9+O5KFUkcfFrGJyCy2Ehpvw9Co/ zS9K5Yd5c5j1w2/kFJVe984f0OseRrYLZtuX7/DZ6iOo5Rplc84J7p76Ng58mHL/JBcJjevYClBZ /PXHpJY6F5f81BNMe3YSHy06gV77n6GNKuDv601cTCSnjh5i07qN5VVUOLpjGa+/9g+Skq0Y9Vee M/sxoP8NdPZPZ926HRRF9uCGXl3wohq/rwNBNI4KhMxtrN51lEKbM0PWmd1MvetR9p7KQKOV65lm spgweiLfrtiJxaG6xoIoOMm5PBtyowQCtILA3s422TLnbWasOerS8pdlH+fuqW+jSL5MfWDSNW6x 3HDjrwlJkpCEStH5XzBJEq3Hv+Eae5Ji5dyqaUiSgQlvfu/6XSkrYMVbd6P1DmPGylQkSSI/6wJP jmmGySeYth270advH9q3aU5oSAQTn36fbJvkyn9008908NbS++apzP/8BZpHBdOiXWc6tW1Bs7Z9 mLl8b3laWDzjDW6+6wmSHSpz3p7sKqN5r1Gs3ptc89StPN97U8dx3ytzKKaUJ8YNceXreuvfOHw+ F0mScOSe45WHRhIRHUvnHt3p2bU1gQER3P/KF2QXlLkIaH2yy187gwBPmbvfWsG+dYu4e3hPfIxa JCmSnVklqJKEOfsYk0f1wy8gms49E0ns2pkgb39uevAtLtvL5SIE5uQVhHrpCY1sTOfuPenbpzfN E2IJimrJ+9/vcKVzEnMHKQdXM6RLHCFxLUjs0YPmcZG07TWK40U6tBqp3noXpp7h5cnjue+DpViy TjJpWLNyGRm46e7nAacllkbWUZqTzOwPnyAhOpRWHbrQoVVTWnYeyrfrDrvq5Dzhl7h0ZDMP3NyT sNAYuvbsQ4+ObQkKiuWh12aRWmC5qkzr7KMAqpVSRYVoE74Vd5clibPrDxDYazYPfJVKkaVSWSRJ EnM++w2542y+OW/BISr7YGlWDhOm/oTf0EX0euBX2o1eRPCwxbQc9iVyvyXkCAlVUfl82kqkjrOQ Os+u8eeR+BWv/JKNJEkU5BVz45CZhI1dg3ItezBJIistl4ceXYBPr/m0H7+cPg/+StvRiwgbvICp s46Rp0gu3znXW5VfkJ7DU8+vIHLIAjpNWEGvSUsJ7/cV0SN/Ztnhyj2YZC7l/Q/XEzVkAa3H/0zf B5YTPeBrujy6mYMZFqfloSRRtPs44X3mMHbGWfYmneHeJ5fi12s2Uruv2ZRlwyvI6efAL0RX2U4O C++9u4bAfvNoe/cKEh9YQcKI+fgP+o5pazL+BH4G3HDjz4k67Ya1Wh0PPPoic5bexYcP3sCHD4Le w8TUaUv54JHEa3uL0Y8B455hYbGVqS9P556bul/xMl/GTn4erzq0l1cfwE5NYd/hbfhEgic/O8Cb /1zPmx9UyWcXDBzZDn9fvUtzB9VP/u54sBeKTua5b07xyPO/8UhVvuWAcQ/EotNAZJ8W3N7hHDO3 naTVzWcJ89WSl2/F4WGifZielLzKU3rZYWP23MN8PHMnTeMDiQvRk5acx9F0Cy16tuHxAX5IEoS2 bcaGD+3c8UYSr76zllffqT7JxzSLxXSdG79Z0zA+eb4ro19PYui4hTRv5IvOZuXg2QLCmkTwzJQu tPOtuNJtpGenWEa2vcCieUksWrgbzBom3NuJuX/vSLf+zZguVJ74ZC/TPtrItE+ry773sFYEBxrR lips3XyGt2fuJzTalxYxJiyFpRw6V4AuKooPRkQT71fuLC7zKNPfe41TgX3o1rk9Ib6/RwJS3Scf kiezFn7LqYGjefLGDkxv3p6YAA0H9++nyGLkkelLuLNTgIsk+nUey6N93+HTzYuJ9vMg0NeDvMsF eIY1pW3rcI6kXL8ltr4erwA+MW25+c57Wbb6EZ6fMJD3nvBDq9rIK9UQHR1IsLceValZn279EunR rTNJFzZxww1D6NSxRcNOiSSJh6Y8wPp9p3h38kg+fzkEg2ohJ6+Itt07YTBqr3KqbeDS3jXc/dM8 HvSPoGObFhgkMwf37iLP6ssns1/Dz6gHNK42eXx4ez6u1iYeTPl0CWM7+P9JHAi54cafGy6fIuHd GRSnYdWm7RQBPoDVamP5st8AGxuW/ozl5bEYgTKLhc179uPjE0HfG5wKWiHJhDRqx6PPj6ND6xYE +xopyrrImqULmffh21i0/ix6574K7T56obB9xQyOJcUydPRjPN4qgtP7N7Ng/jI+ff9dmrWYT/8m HnTsN4wJt21j3k9radrvZm67uR9qaQlBca1pGuVf53cNGjuRo8eP8/3Gowy6/W4Su7ZCKSslqnVP woN9QWQx9f4JzFq2h5vueYRxIwdhUvNYOPMT5r75AKUqfPz03YT6GqjX0FaArDOw7Yun+O6VswQ1 akn3/oMoSC/BIMtoik8ztHcf9heH8tJHXzO4Rys0tjzWLJrBa5+9zCitH5s/n+oUi9DQfuBYEhO7 0iQuFk+9QtrZ48z77ENevPdWwpqeZXwHb0Ah+/x2hg4YxhlzAHc9+jI3dGqCvTCdXdvWsnDxceKu MvV5+IcweORYDpxLZ/XxPG4ZfTc9W4VRapVo0b6rU9EryXhINlYu/IDdm5ow/K4n6dw0hMM71rLo h1V89NEnJCTMoHsjIxKQsmcZD0+ewp6CSF6avoAhPVuiFF3i25kf8a/Xp2Dw9OSNv9+Nn6YBhu6q wGpXUBQVu6JQmFvMzNlJ7E538Par7WgU7FFtd1enR/SKE+CqD80FjHjwFzZfUrh1ZFtu7RyAZLOz 72g683/JQxjKT9g1EokDmvFeUFiVQyeBtaSED+cew6rzoEdrv2p70d9z2KtKGqIbBfP45Ja0j/Mh 0CRTkF3E8jVnmPHVflS9gc8nJXA9b9xLAI4iXvxoB//als+EOzpyV2I4OouN/cfS+ey7s5zNLMPa NgBPzEx5eS1f7S5i/Mj23NE/kgCdYHfSGV7++iRj3tGy9tXONAp0jhWtTsuu35Lo8XUpASE+dGkf SX6WDaMkICiCn94ZQusmHlT4AJz54Rpe+DGTISPb88iACHy0KsdOZfPzylNsOJLH04PD3RO1G240 lKALIZA0MpHd7+DomXb8sHgZWcUOAkJjGXJjVxAaorvfyGuvxtKndXC1vHpPb24Y/QDe3S0kmCrL M3gHcefTHzN80lNsWLOGY2fTELKeyPiW9OnTl4RIv1rvN1VoZCVJIiYhlCce7ERch2BXuVeS9AHD 2rGrTxOSDqSz+3QhxXZBcKCJxC5RtIoxoSuf5tt1j+clj0A6xpqqlCUzblJvbrm1LZuS0jlyqRSL CpFhvvTvHkV8sBENzjp+OG0YnX88wpJtmRSrMs1ahPLI2NaUXEhh5YFC2gboUATcPL47GxNCWbY9 k8MXCii2CVq1b8RDU+K4b3A0xnKzfgG0692K4781ZfPOi+w+U4JFEfj6edKjcxTd4r3rD9shSRg8 DIy7pwsDvQKryUeSIDDYnxcmdyKmYxXZafUMGtGeA83DmbPkJAcuFqPqvHjhxnbcOawxLUONVczJ oHHrGL6cfgt3bU/hSIYVbz9P+nSJRMZpHt1zQCu2dI9n76F0dp4opMiuEhjgRa+OkbSN80GvAYLi +eZtT37ZnMK243lkFdkIigjkqeHtuGdoHAnBxkryFdiE+x99mlyPGML8fa69d3sm8PRzL6FEtcPT oKshLyEEvk0HkXTkMF/8ayabdh4mp0Rl9H1/Z+zEKQzu3Ki8Ls4lT5Z9+PC3JJp+OI01O/Zj0/rR re9wpjwwnuPr5rL9tIVGhqtXyxQQyqTnXqE4pFv1BzovWiSO4jVtZ7q1qL5oBYbFM/GxVxCB7TGW L8F9Rt/P8qg4/jXzS06kFBDcqDm33TWBTvEmNv6yFENcd7yvINn4RRIc4A+mJvTt05VoD+r03H6l rCJ6jOXHJZHMnvstO/afxjMwigEj72bSiKYsXriUfFNjArydGyt9THv+/vwrhLXrhIdBAvz4de9W fvz+J7bs2seF9Az0hiDumvw6Ex5+kE7xwWjK3+PXbDC7jxxhzr9msmnXYS6XqIy+/2numDiFQZ1i 3eTcDTcaulGXRPnc5U3iwF4sn5fE+vMKt8bLWM05/LpsE43iY8i5sImfDlsY19aItSyfQ/tOENT2 aVrrnfNDQEgMz0374Yp1RaJ3z25kXejH0S1ryOY+QsrnGqsDWg4Yz8LvZtMupJxsFdxMrMnGs98f Zv/hvfRvkkjjVl24bdQwlv28nvY9hvLcE5PrV9CX7xE6Jg5ieP/OLNt4hoE3j+WJcUOq5Vv75XRW rNvBbc/9i0+ev59IH+dWZ8SoERgHJjL3nbcZP6ovwzs24ao3p4Ug1+HNnBVJ3D20s8uRJ8DXzz3F lhQDKw9uZXCzAFdJXXoNoCytNW9/8TGHpk2lnZeEsdEIVi8bQcX9Xyd7u5Ebu/gSnfgEa39ZyfgO t2MtKWbhtBc5UebDC1+u4R/jOrred+stN5G2oxVnlfrv3eu9fEkcfCOnk9aw/uIJRtz+EJOGNauR zmKDriMn8/UXH9EisHzxGj+UYF0p727ax5GTR+jeqAtwmW++/pp9BbF8/uUcxvRtWd427eneMZ7i /PEs/WkFo4cNoE+byHrFKetlSg5coMeYi9Uf2BVa9mhC60hP/ogx2oK5SWxJtfHw34cz484oF/ke P7IFxceSmZteubds0ymeNp0q89qsVt57ZQX5BgP/eOkGhjXS/2ENWXhEAC89NaTG2Onc3J+MZ1dx +HA6eSQQcB1vY2uB9MM5HDidT8/+rXl2XAdahDgt3Pr3jmPqnR0wa3V4Aht+PsgPu/N59YXBPDo4 Ek+Ns3+2bx2OVFzKI/NOsTOjJdGBBmcNhSDHoeOzaTcxMTEMg1z94sCwAY2q1MTK0rXZqAExfPds Z3x1zobt0zWGyXd3JC3T7J6k3XDjWgh6VVIcENWSh59oeaVSmehuw3m12/Bqi6gQAoOnN/1H30// 8pQVp4/OiUnCNyiGW++6n1trWVTqcjKSnW9h1Y5LnE0pRKfTcOhgCgcPpjRgcwJajUR+finLVp9i 2ZXPNfDLmtP8Uk9+WYLMzEIW/lxYq5zatQ2v+FK+X3rEVe7PS47wc5W0Bl9Purb3dMkvLyWHf36R U2/dJQmKCstYte40qxq8IdOALZ+3Zu+r+UyG8wdTeL0W2XkE+NIrwNdZP7uFxcuO1S9XrYS5xMyq DWdZtaFu2RcWlPHr+jP8WuO5lpbNQ2hV0f6WMhYsPUaZxcGkm5vRvJEfUmACkx55su7NWr3rogDP BJ54+vk681f0S71vLI889w6P1DEWqvZPrWcIU1+axtQr0oWMmky/K/p8bccxQoB3QBj3PPN6tXIR AvQmmifeysuJ1BhXgeGNmTj1pSqbVAAdLboPZXr3oTXeNOmxFtXTlo+tlJ0b2LBpM12GjKdnuXM4 0QDnPhX1CGvRm1em1QwfM3Hy49U3iNHtePyZdtV+8wxqzIQpzzBhSt1t5moTv1imSdpFKAAAIABJ REFUPP8OU+pI44YbbjRoRXCSIlnDsMF9eWrOTnZu3Met8Z3IObiM7Xm+fLBsHrPHDGTZTz8yru14 SnKPsjdNx5gnulVO5oC1tJDd65ayaPkGTpw6TVp2LoVFRWRnmWndy0K+gJByJ6OqBOFRLZzkXAjn HOMXSnSTZlB8kNzC4mr7iSv/d+X8W3VhkaokF7VnY9fmXaSXRjJ6ULdycl4xLwcwatQglm7+hLX7 UujZqgn+V1GqOuxWbrr/JW6/oQNaWaoyB1n45acN6AObsXX+R+yQNdXkfiJPD/aTHEwx066FB0Ko WC6nsuCb+WxN2sups+fJzi+ktLgASacjp6wAALM5j2U/bicw5haeHdeRqif8DYmt7ZJZjQOMK6Gi aCRiY1s4yXlFOwVGEhXXGJZtIb/YebWs4Nghjh0+BrI/G39ZzPGNarnDMgmjUeFceiFZ5lRyiy4D 9RN0oahowv15eHAskf56VNUZyScnI4/lWy5x87iLvPTGUJ4ZHon3NYfpUli2NhWhD+S5WyNdd7zr Opmuup447A6Wf7eVV9YVMOb+fjw/IPiPezErL9tcYmb7zgv8uC2dkymFpF+2UFhiJztXoVdTlatG GL5GqIC3SYuPt57N+5PZcSySuIAwDBrnJ+m9PTGUf9em7VmUSTpO7L/ItJQMlHLlj6yVOZ/sQAgz x7McWFqX+2q1Kwwf2Y6x3UIwVBsPV4jKGe+WID8tnM9k5tp0pgyMwENb7jtCkogM83Kv6W64cS0E vdaFscaSXzNtzTyVp+FXG4D1ebkMDfDgnhubulvrL4TaJu1rmcRrS9vQ3651PNTV5xvy7EqP8w0a Vw3yllt72rWr17D1uIMXHxtAuwinyVpDS/sjsmpI3rrnkd/XB9xww43yfbIsE5s4jEjNW2xI2giT 2vHLTyvxSBjG3Td048KgFsxdvALz63eStmszRSY/eiYOdpVxOeUYL0wcyeyNZ/EOiaZXrx4M694P 2V7EqsVfY6/1RFdcMQfpkHUeSEK9bs5Oa0cJyeklEBRDkE/5xbkqXtIbhcfj6akh7Ww2NosDDFeP ECKEWs05nfPHLE6kC+xcZMWK5bWuV+3bdyJABoTKhW3fM2DE3SSXCCKatadP1870Dg9GV3qeaTOW unZWDnM6R/MgoEdrfMrr/u90dS1qrBUGtDoPUCvbKSu3iNxCC7lpZ1i/cike2urm3kIYadOyJb4e Hlcnj4qKV1gQD45tQ7uo6hcb30tNIfHhjbz18V5GdQmgQ6TXNX56GSdyBfroQIK15WKrU36VewxV UTiy7Sh3f3KOrgPas3ByglOpcy1rbR1Iu5DJs2+uY8GeEvwjfOjZJoQb20ejmsv4Ze0Z7Kq4uoK8 Pj3BFUoEqYKgN43hzr6XOPbNCe5/fBlP+HvStnkQXdtEMG5EAu0amdBi5UKhoKzYzNbdKRzUa2oE tEmI8SPCQ4MGcFCp+6kxHmpU2mmV+uJjHdnwwm6ee/lXXnpDR4eWwXRqEcLIYc0Z2NIHWSNd1YjP DTfcBP1PCPeG/K8Jd7tffxSd3szaTRsI6TGcXj26ly+0knthdMON/89zqQAkDbJPawZ39mbRuh3k WCexduVWhtz/Dd5aLWNuHspHq79i/pYMivecxDegCQO6Oq9/KaWX2bLgPWZvTGHUI9NYMOPv5dds IOvCYdJ2/8jeBoaelKABERh+77FlZT6n52mFyvPmKtZ8klol5OofmPwkCVmjYGw2kj1JX1Yz9b0S iqOQZx6YSIo1iBm/reeRoS7bMfJPLGLaZz9W+Qrh9DhexVTgPz1PV7RThfQ0Wgm7rYTuNz3AnBnv 0TKgPmXG1U5Ey0mxqN52Qkh4RsVwQ7QH+9dnc67QQfvI2jQJ9b9DUgGlSihfqS75SS7lS9bZS9zy 8i4CW8by0zvd0F6ntVEtKWX1L4dZcMDGxAd6M/ux1q745Mnn0jlz8DyZytWVVXpZg1ErY3dURiJy WZyV6x9sVhWbImHUacrfIXHPA71J7NuYX7elsGlfJkknstielMxHC48z95+DmNTLH1koEBDC/A8G 0LNx/dFyiq5xOAoELRPbcnpJJAtXX2T7gSx2HslmztEMZi44xOOvDOOjUdHuPYgbbtQCd7QiN9z4 iyBfMdDvprv45K3H6NImtGKP6YYbbvy/Z+ggywb6DhiCLXUTPy5fwqZ0I7fdNgrQ0XjA7bTTFrF4 /lccOXOUqB5DiSnPXlJqZseeY3hHNOLuRyvJOYCiKKhCNJjmitp5LpIkUNQKUlU9fnJ9uxcJFYe4 Mp+J+CgfuJxMVn6x6yUVhO5c8llKSlWimoVi8JB/n0wFQBRdEjwx71vFzrRiaoaoFigOh9MsveQs W0/ZCE68qwo5B4QzTnlVaPUBxBog/8JZV2Sb6mT92li2KgQO9Y+FAY0ODSQuMpRjh/Zz6sTpWki5 WtkXGuTUt2ZlK8LQldoFyDoM5abQGiQkJMxWu0vh4jr5rlGUB02DJWxpeaTbXKldYezUmrEFKc0v 4I6n1pPjGcjC9wcRpee6rY35xTZ2n8wjJD6AO0ZVknPn2KmlPnVAF6AnMNRIdn4ZKfll1WTg/NfO +VwzxbKJYF9juV8gpwO9+KbhPHpvN36acQupGyax7JkOhFPI12vSyLTKtI/2QJORxZ5LJVhqUy4p KurvsXgptz5QVYF3cCAPje/ENx8M58yaiZydO4A4L/h45mEK3eFY3HDDTdDdcOOvCiEEsS268/BT rzFqQA98JOGOP+qGG38Nhu4kfloNA4f2QrEX8fpjH2BqMZxbmzsJqtEnnsFDW7Fu/udsPmlnSP9K PxOyRoPJywObxULGpRRA4HA4cNjKuHTuCEdP56L9A169jD4mvL0F6ZmXSLaCcNix2e0oqlqnLw8A U6AvnrKZc6kZZNtAsduw2Z1kt8cNvYnxyWLh8s2czSoFoaKqgO0SPyxeQ6GUwNAOMfjp6yKMDVF6 aBg7aQxGbQYPTnqG5MslWG027HY7NquV0rw05rzzLulCQtJ54C1DWfolChyqU352O2WlRWxduxGF SkWB3iOMPjfEUpi8ga+2pIBwprdbS0k/f4RzuSA3wFM6Rj0+IX7YivI5m+wk1TabDbvdce1tlNCJ Hn37UHxiHTO/nMexjCKE4sBut2N3KGSf2ceS5cs5k5LZoP4ohMChOE3obXYFm11BEYI9aw6w4lwJ Xh2iae7npLPBAUYMOg2HzmVQarY7Pb87VMwFhWw/WoxQRBUyrWVgYhga+2XeW5pKmcWBza5gsTk4 sf88e3LVav3IarXw0our2ZIj8+4rA+kTJmN3qK4/Rf1ja6SskfAyaLGY7WRllzrHjqKi2O1cSMnn 5CVrNaeDdaozPP1o2yQUU3oOv225RHKJAFWgKM7vObPnAmv3pBHYLoQWsc5T8NRL+ZxIKaLA4vSW r5Z/S2LLYCIDPVBsDqxWiSEDomkWI/Pqp/vYcrwAmyKwO1RsdgWHzcrCbw9zPMf8++xahJVVe3Io tThc8lRUleiWsXTyl9DYVezuCdoNN2qF1i0CN9z4C2zR6/EP4YYbbvz/htPKXYt/++G01T7B4fxU JjzxnosWenp6MOaWYbz7/TsUyHH06t/Xldfk68PQm0bw+rcv8NqUUaTfO5YA2cb+HZv5+be1lNig zRUkoy7nbZTfXa36qEnjlvTs0Z7Z8//F3Znnad/YF41vHGPvmkjP1pF1Khw6dehB+/aNmPXGC6Qe 2Eysn4oxugcP3zuefuMfYdRvm/j4s7/zUNZp7rltMF5KLt98/im/bD/DpDe+pUOC00agflPmuhSZ zqBYgx/7kKnrD/PZytm0brqWG28ZSKS/B+nnj7F6zSYKbY0Y/MJLSB4JjL+5NW/8/CODbr2X22/o gD0/jU0rl7B2zzk0OqPrUq+XycTDj/2dWb89yt9G9eXIfROJ8lU5vHsTS5dvwSK0NJPE1dvbGEp8 hxtoZPuKma8/RfKhDZhspUQ17cxrz092mrBf2RiuAgTV3dF5MP7+KZw6dY4Pv3qbGzb8TN8BfYnw 03Hx6B7WbNhJXN9xfPlp19rrU+VkXSNrKEm9zLQv9hLqrUMVAqvZxtlz2ew8U4xi9OKrJzoRG+S8 z+7dIYpu0Z78vOYIE/UO+iWYuJxZwA/rLpBZojgvXFfBgxO78MXGbL78YBW710fTOlzHxfNZJJ0z Y5CBcqeAQhUsnbeZT3YUEdQsnPyj53j+YGVhslambedYbu8c5OofomY3rFX2Fen8AjwY0juaD9cc 4OV313J+WBw+2Nm1P51fd6dTVgqRV1G2VDwd2q8RDxzK4KPF+0lOzmFs/xiivGSSL2Tz3bqLnMgU vPR8UxJbOJ39Xk7O5v5P9iMC/Bk7oBFtYr2wl5Qyf8kx9meq/GNKOEE+4NW7LY8Pz+O1xWcY/sAy bugaSctoTwrziliflE5KquDX7nG0Dqm9XvVCY+fJvy1DahHBmD7RdE3wRVJsbN18ip9zJAaPSyBI cjt/dcON/3mCXpun94YM7N+b7396Q1bL99X3zVc+qyqzay3r3/kNfyTdn0nu/z6Z1vQiXxFBodK5 73+nPWtuAK/YGNf2mxtuuPHHFXTl87lsiGLoLU1J3Wrn1lG3VJI5nSexfe+gq98H5EV144amUuVc ojPRfvjDzP/HBR59cy7vvHQISdYS17Y3z7z3Ly6u+5j9JXqXOZ5Gq8XkbcLTw1CDauj0Bnx8vDHq tRVDnoDmvXj6jfdwaF5l6aZf2L1ZZsDohzEYjfVNH0R0v4233irF4+1pbPj1e9Zh4LaHO6DVSkAQ H838muCQZ/h0/gIm/fQFAAbvSKa+s4BXp44mwKS76rwnafX4+PjgYdDVdPApBEIyMW3Zdvp9M505 3/7Axp8XUWK14RMUTf/RD3HTmDuJkUEjdLw45ycuFo1h0ZrvOLhqAVqdgS6Db2fVymcYP+YZPIzl ttWygSb972fprAzufeYDZn34FpJGS3Tzrrz86dccnP0kJ40eDWrvDok38uV3H/Lsax+x7OuZ6Lxj uHdqt3ICqsPbx7fyvVWgM3jg4+ONQSu71gfPiLa8P+c7Eod8w8wvFrJ+ybcUWxyERMYz4p6/MX7i RFo3iai9PpKEXQWdTaDVy1BYwJI1Z13KD1WSCPb3YsSw1jwzqT3tI4wIh4IFkGUTHzzdlYzXd7F+ 9QnWrhRgNPLgxJ7El5zntR8yUOwKVpuCQwLJL4hfpw/i79N3s2xPGseOS7RsFcnc6Z3YNn05X2TI 2O0qZkVh34U8ZKNMYXIWb3yZWY1la/VaRiue3N45EKtNRaOV0csSVgCHis2uIutkdOW/6cpP9rVa GZ1GwgZIko6ufVvwyX2FPDP/HK9PzwRJQ9PWkfz9oW4c2nKUDEVgs4OCgr0evYshNJjnHumBj8de Plt1iRf3pbjqGhwVyD9f6cJ9g2PQ2RXsGg0RjQIZ1jGQmasu8ezuZNfAMQb78vwz/ZjUMwSDXcEi 4MFH+9CqfQSzlp5gzf4U1m51YPTQ06FNJA8+3Jh2YUbsAqwK6HQaNDjj2Nvs1Gumr9XouX90PJ+s TObNz1JBEU5mbzRw+9jO/OuhZjgUFa3sNuZ1w40a8+boyR+KlNJAkuZN+F9hnqiqiorT9K7BpEI4 TWtAQqOR/hLaOiEEDpuZUrMdo6eXa1NUG6mrMDtTVQXQIMuaar56hKpgNZuxKuDh6Yle+5+ZUBVF xaHUDC0jAbJWg1Yj1amE+W/KXVUEdlUgyxp05aFIHHaFUquK0ajFqNOUt4+DUrvAw6jFcB1lqigq DodAo5XQ1bL4CSFwOJzjSCdr0Gj+G5ITFJfYcQjw9tIha/4c7eeGG39W7N27l8aNG6PROMd0aWmp i2S+NWMFJ63tEam/cudtw3lwTPeGKQWhXmVZ1Xy2klxOnEzGOziK+NjQhikHJclJZq94R+W7abDi uHr9GpbPUZbH6TOXsMkeNG/ZFKOGBq0ZDVJkigZ4+r4iTc6lM6RmFROR0JpQP32N8qn6XbYSjp08 ic47kqZx4VdXcjZQ6VqnQr6udpKkP6ww/27VWU4mF2Ly0Do9d9e6R3OuS1f6TdNoJPQalRNnLpNv g5aNg/AxSgg06LQSNqsDh6iuEDDoNK6rAKoQ2Cw2Fn57gFO6AF68Mx5ZgF4n12NiLlAcKla704Re b9CiESpmq+LyC2DQa5Ea8JtWI1GUX8rpSyX4BXvTOMqERhVIGgkJgc2moNKwSCd6vQZLiYXzlwrJ LVMICfEhLtwLvSSwOyr3SpIEOp2MsNi4kFZIRqENX38TTSO9MWjB5qi+r5I1ElqtBlmq8HovUFWB oojyPZhA0mgw6mRURamRvy7odBp0CC6k5HMp14yHlwfN4vzx0knYHCp9OobTp2O4e3J34y+HI0eO EBUV5VrP7XY7NpsNgAsXLvwPmrjbSjh2cD8XizR07tKZcD+PhuUz55G0aw8lhhC6tG+Nv5f+/3/r WwrY8NmTDH3me96at5kXJ3Spa9oHoCQ/hz3bt6EJbkK/7m2q2TCJrFO8+9hE3k2SmL9oGWN6hv1H PuHQ/nOs2J1LvllQNbyrp5eBLp2j6NU8gGCT1rWB+DMcv6oOlaNJ55i7J48+vZtwW5dAhMXG+m+3 M2zmBd5+52aeHxyMKLPw89yt3L4gg4/evZHH+wVetzqcOJrGwtWX6Ni7MaN7htZMUFTMD6vPccpq ZPzgOJqGGv8bHZQbhn/LngyZvUnj6RCgdxN0N9z4N6G+8Ic1HVxXEsqq5ExvCqJd56A6CHn9YSSl hr77KnWuq7za8gkh0HoG0LJdQC3EVvrd8mpoPSrTVHoSD45uQnB07WS2ar2RJCS9iVZtO1eRdxUZ N1AGDXnWoHb6A2E2hRDcOTThP9TTBRk5Zny89ei0zvBgqio4tGk/r5bArQ+147X7mrgnhD8R3Cbu brhRE/8mgl5Tk15zcWzgIL0y/eULfPX2k8w95sW387/lxh4xDatR6iHeeOJezvkOZtGc9+nULKjW 99e2QF33yaMurXsVgnkt2u+6y5SQdQYweqJrwOls6sm9/O222/Ac9BhJv35SY5OhNxjx8pCQ5Ya3 a13f0VCZHj+azIyFp8mx6/EyyuWhX5zOUczTd9K0bxt+fLUrbcI9/lgbiesT8xRAKCrnj6Xy+U8p yCFh3NYlECSQdTIYteiqyE+rlZGNsssS4PeOnStx9lQmH39xkPEmv9oJekkpK1afZHWxL4mdIl0E vb72qjY26mnvBm1aBSDpaRyoY4/dG39t1TzCHf7NDTf+5OT+f8GPRa31/q9YWtUuqzpDhf2Pyvv3 KAuuP8q4aeRCMoN96dQkgECTTEZyLmsP5hMUH87rdyW4B/Rfun+44cb/KEGvy6yr5iCqDPdRq6lU FdPoCk+YGllGU+Ve85V5K7XHKoqi1kgvSRJoNOj1BoxGg9MM+yoEpiKfJGsxGIwYDfo68lUJ3aEq KIpAluUq5vD1EKerEata5Cu53uP8TlmjgYpT4CvkoigKqqoiSRpkrVxNy+40QcRVJuAM7aKRkaUG LOhVZCbLWoxGMBiuZl1Q/n5VRVGrtlOVWLOuflAuU8XppVWuSOv61vrrKGskrFaF514fyvPDo/CR BIqikH4pm+fe3cbCTQeZ1S+eN2+Nwt8gceUhuutUvU4/BBVOgpzPnCFFnB6Pf6/PAlkv03dkBzZ2 aUlktP81qrYq5aGq5Z6HJaeJX7Wxc5VNpkYjodNpalemVNRT1qDXStUsEyrHgPPdkkZymp5XPdmh sr8J1WmWiCShlWtPV3cXkgnxlqDUE2+5/HuqzB9Xlu0m72644YYbbtQPPXfe0pjFB7LZuS8Vu4CA QBP3TejEs/d3IN4kuU9s3XDDjf89gl5BnEoKL1NiceAXFIqHtpKQFeXnYHbIBIUEoa0gEoqD/Nwc FK0nIYG+IAQOexmZmVmkpyaTlp6LAy0RMY1IaByHr483Rl258xHVQVlxESVWFS+TCUdZPikXznEu LY/AyFhaN2+Kn8kDTXm9CvPyKSqzotq1XM7JJP+ynjKLgsnHBx9vr1rNs1RVkHc5H7PNGaokOyuD XF87FpuKf0AAnh4GJMBhtVBckM2JE6e5lFlEcGw8zeKjCQ70R6/VIEmCuq2onaSh6HI2pXYNISEB 2MpKKCkzY3coGE2++Ht7Op2lWEopKMjl9InjXMoqxD+iEW2aJxDg749RJzu93ApBWdFlcnJzOH/u PLl5xRhNfjRq3ISo8GB8fX2QpaqkSmApKSQ3M42jx09TpjXRLC6S4jJr/WbfLtKnkJOdjU2AxlxM enExUnERklaPb0AwRpcJHCh2K9aiLI4dP0VyZgGhMfG0aJqAr5cRTbU7iwKrxUxedipnT58hLa+M 0Jg4msbFExzoi14rl3uubdjdq4oKyLKW6EYRPDC0EasP55GabsZuU8EgI0mCwgILpYpEiJ+hkthJ EgiF7Dwrkl5LoEnn6lOSBDarncIiM0dPXSbHKkiICyImQIfdIfD0NODrKSNUhazLFtQ6ZChpNIQG GJEkCW8/E80MHnh56q5pQEpCYLM7yMwtIz2ziPQ8C6pGS1SYN/FRPvh6Ou+q/zvM+SUJbDYHhQVm zqTkk5ZnxdvPROMob0L8jJiMsutOn+JQKC61cv5CPuczS9F7e9Eq3o+wQCOeukrfEMWFZkrsEBxg wG51UGJ2YFcEBg89gSYdpiAZk8PgmkuQJBSHQmGxleTkfM5ml2L09KRJnB/BJh1+PgZk977KDTfc cMONKyH+j73zDI+iav//Z7ZvtqT3TgKEhNC7VKVKEUREBWyIFSuKXRE7WFBBUEGK9CqgKL1I7y10 AoQUEkjdzWbbzPxfbCpdH33k+f/2e128YHZy5sy5z5xzf+9zFxkZNSNG3s6Ia97iJedeeOHF/yBB 9yjfTr5+tgtvzdzP5L1WhjY2AGAryeOx9lEsPB3NrgtnaObnuf9ixn7uSGxOSZtnyPhjPFDGkY3f 07DrSyAo0GjUCLKEw+kiOL4xb4/5hmfvuc2zWOZnMOW1oTw//xRPPP4UOVunsWz7ycrkMW36Ps23 E8bSMMKHvLRtvPbic0xbsx+AIb0qYqp1PPf+V3z51uNXpXrnNi/msWdfZt3B88BsurWdXf6LifEL l/B0/zs89Rqnj+WV0Z9xLNuCVqvBYXcQFN+CT8aN477uLTFoFOXFVa69uL9zZx2+2hnCuh2T2TBj EtPmLCWjwEbHp75kxZfDUVPK/G/e5bWPJ5NnE1EpFbidZShMCXwwaQrP9m+HRikgSRLjX+3Ka9/t Q6lSo1IqkCURp8tNaod7+W7qD7SON5dzNJnivDNMGPUCb01cjqxQoVKAUqkjNsKMQXfjePs9axdy d58h5AH8/h2R5u8ACKvdjI+/nc3DzTWgUIDLyubl05j8wo+s2nO2kjR3GTySrz5/l3ohVa7mZYUZ TPlqDJ9+8xPZxXb0WhWltjJCElvx/mef8VCf29AKAjfkmnIVgawh1zwrbpQk1zaj01XVkX32sbn8 dM6PE7/0oHb12OqyXFK6LkXVPpUTH7fGpPN4I7idDn6asZ0Rk49RIis8GVhdMg1ifTh4tJBHRvTk x8ficVsLaNh5IXmXhwu4RHDK6GrVomhFDzQuN9vnbaX92GO8/XFfRvcK/ROfpIttGw7Q8fkdYNSi UXmsME6nRFRCKO8934ZH24b8MwqG28GCeXt5d9pR0otFdFoFLpeI2ynT575mfDkslVqBGkBk45rD vD7pIPtz7CjVSiSXGwcahj/ZmrcGJBBq9CwtH7y0gDHbBX6b2ZHd607w44oznMmy0faBtqx6swmh kUZidfpqLv4S2zek8dSY3aQVi2hVCiRRwuGUqJMUw4qpPUjQehduL7zwwgsvLsNNhC94ybkXXnjx P0vQlQol/fvcxVszD7Fn3RaGNu4KshtL9k5WHhHRmQqZu2AbzYa1BtlBScZujktaHr27ayWhMgXE 8NCTr3JHp5bERoahFpyc2LuFiV98yqiXnyU2ZQt96ulBENAbfcGaydTvv+S2Tt2Z8MNbGKVLLJ// Ewt/ns4XSSlM//hp/GOTePSxxzh/cSy7Lvrw8MMP06xOMFaHgsYtW11zYQ5Jac2Ipx8l98NxFBqT GTr4HhIiTJQ61XRqlowArPphFI+P/Axt7a5M+HgYLZIjOXdgHZ9++BmP3Xs/ppXL6d8hFaVwfYqu Nfii0VziwZ59sGuDaNWpDx21bqKSItGoYd6ooQz++Dfue+otnh7Si9hQI9nHdzFm1Ou8PLAP8QdP c3dqICAQUbc97455kNTkZCKCzDitBezduIxRH33HwKEhZKz7BgCHNZ8f332UNyf9QaseD/LEg30J Nio4d3wfS2Z8T0bhjSdCQoPWvPraM4z7YgLalC68+vLDCKVWfALCaJ4aCc5M1GotBekb+X5SJh26 9GTS053QOrJZNGsqv8ycxHf1Uxj36pBynnmRcaNe4eOp6+j32Os8NaQvUYE6Tu1Zyeh3R/PSS28Q 6D+R/u2TEYTrGz0UCoH8S1ZOnCvBVyHjdrs5tPssH809Q3SzZB5vF4BZTWXWeZ1eDT4qFFe6U2A0 qFFqa077BVM28Nj3Z0luHMdn/RNJCNCQmVvMr7+kcdCgQaf2NKT0MTHh/Y5Y5SolwO1wsXJFGguO ldG7azza8m4o1UowqD0E+89AgoAgXx59qDl3NAsmOkiPShY5dCCbCXMO8u74HcTE9qBz9N+fPmLV 8gO89v1BghvXZt59SdQP1ZCdU8Lvq49x2OakuNQNgRo2/bKbB788TGxqAnNH1qVJvAFrfgmTftrN +M/XEx5h5vk7wjGoQKvXoDfZGPrKapxqHS0axdKuuUR4LROyKDFwYDvaudT4aDxGD1tGBn1f34oq IZopr6fSMtZAQZ6FrfuzmL48kwInXoLuhRf/Ia59ivjfCyH5/6X86X+zz7fGJf3xAAAgAElEQVRE iUwvvHL0wgsv/vsEXcbjqhvboRuRivdYt30j0BW308mOxQuxaCNoXguWLFnAZ8NaI5bZOb55M7LJ n3a3dfK0ofAhvml/pjXtj9Nuw1Zmx+WWqBMfgd6dwcDXl7Bryxb61OsMgOh2gTGKt8bP4O2HOlX2 pVlKLdL39OPE8f2cliHBFEC72++g5eLZpIlGevV/iC5NQquvcFeNQTcERnBnt9v54cepnPZL4d5B j1I/1lR1k+0IE6YuJtenGeumTqRDfU/iuWZNm9Mk2kDngc/x2ZTltEiuRVyw4YYWWrfTQqfHv2Tc O8MJqEYm5NyNjPh4ER0e+ZwfPnkShSwjyTKBbfswZaLEqob38+2Uhdw97gkUCgVDXhzn6V6pFbvd jluUSKhTn7StS/hp20rS3JCicnPx9AZGTdpISpcnWb9iIpVnxj270cAnn3YvzrneToGMgH9IDH3v uZu5305AH9+Yxx54oCZvzBER3U4IqM3H383ghXuqSvjUjwvm9D2PcuREGhlADLD798XMXrSG3k++ w2fvv4BZLMUpyXTo9yQjCy7w6NMfsWn3frq1T8Z4/Vy0GIxqvv9yA99/VXVNEEDW6ni0tg9FFidu s7raKeyf4MMFObw6/Sz+CTFs+K4bwZUe6dHcGeJm3rM7qwwFKh339KlX42s5tPUIrx4ppmX7+sx8 IanyG/rLG7dSQ2qTOkxpAk6HG5vDjUuEpEgfRFsJw+fnsf/IRTpH/51lSTzjtj+tkMxiA+/0S2FA eWK5eglB3NG2FmVlLlRqFTgL+GjWKXwSE/h2RHOSw3Q4XBJBgUa+HtGcLYdX89OKdAY1C8AQ6Jn8 rjIn7e9vxVdPNCREV1NGPlGBVPcv2Lc1i3wJnu3XjIc7lf9SK5DbWsXxyiMOrErvov2/oHB6lc1b U0aV4TjV8r24y8slqcrLLVblpLhxjpAryT1XliG7XoI0ScLuFHFJoNPWTKD5H7zp1cu9/QNJ1irn ueTGWmpDlGQEhRIfg+GyxJ9/z7MrQhDdTjs2hxud3getWvmvzyfvd/8X5CiJOB12HG4Zvf7mEvl6 jQVeePF/mKCXM3SUvql0b2Fmxh9buQiYHBYW/r6Kxvc8zaiG5+j33mK2FX5BY4WDDbsP4Rdcm04t PKRXkGWctmIO797CnLkL2XfkBDm5eZTYbFiLCtAYgrG47FUkSZYwBoSQmJBcY3EwmPyJTgjmtM1K sQUwA24XbklCliVcLuflq941S4TILhdieZ1vp9MBVBH0c1t3kp6RSccejxMTElqhV4AA8V3uJiV+ HMs3raOw6EHigg03WO1EJF0j3nn1kXJyXqUs7F72C5dkgcS8I4x8+ZUaG7YglKJTKTmdfbryWnFe FltWL2He8vWcTj9HbkE+pTYHxQX5qLV6Cu2A2sHBX5ZTojJx78PPoKs2frLdjt3hulEdm8qfnS4n kkx5LfQrOZwoigSGRBIfm1hDTr7+wUTEmimxlmKxAkY4cugImbmlmA9u5uNX07G7RARAoVRRkHkc u+Ait6iQQgcYtddXtux2kW53NaJHagA+gowsyzjsTvbvzWTRzO3MXpXJynGdaJdg/NPZefdvOkeW Gx7vk0qgsqoevCAIlDmlqyh+QmVYwblj5+j32mb0dWKZ/f5t/B2F+wRZxlHmYN/BbOatPsOBMyVc KCjDUuam2OJA42vGKop/gnbfzH0ek0JkuA+BKguzfjtJbKCK5HAdWpUSHx81Br3HcnF2ywXOFzkR tDa+nrEPvbKiFqqAViNTbJPIK7LhEKVKBd2t8eeNwfXKyfn1kylGRJnx1SlZsmwv3Wo3JTncB71O iV6rxuyjxehVHm5dhVOWsVgs6PV61Gq1V063KDkHmRKLg8JiB5k5xWRctOFGSViwkbgIE2YfFWaD Br1GUUlsb3YlEQSw251cyCtD7aMhPEjPdWmHzcaKVSfZdknJgz3rkBr5d5R79PSjtLiAklInfoEB 6LWaf2JQPTllyko4tG0dC5av5aKlDI0piGfeHo1/8XnKJBXR8bFo/k7u5bJxYtNivll+kP4PPkeX ZtH/2jeP20lhUREuQYOfrxnNv0Qy/ydRms8fS2bxywkngx5+kuaJvv/e2u2yc6mgCEFrwM9kQKX0 ytELL245gl7hbqxUaOh0R2d+/HQV647b6CrsYvX2It58axBt4g9hfHMmC+Zto9GAUA7sP0Jk69FE VuwfZUUs/240940Yhz40hibNWtCrXRcignw4d2gjX8/bU5OcUp4RXHTXINUKQYVSqQUZBPmfG4Ts S8VYS8uoHxWK1kdbwVvLiUcE0X56OFRImd19kxu3iN3uRDYbEKpZ7U9l5SMAF86fQFequ8yiLtCq ew9CG3iMFI7iTN4a0pnxq44TkViftre15o5acfiZfVg981PWnwCFAG5R5GhGLiqtmuj4hBrj97cv 5BVyKifwlXJSqlEqNQjI5aqcg/xiG0VuJxdzznFMsOIuJ2yyLKNQKmnSphPN69RCfxNddTpFWrSJ 58mu4dTg8oMa0WHiOp78Po3xK7NJfiiRIMOfe/dTl+wgy0RE+VaefF+7vF1VHHz+hXyGv7GePJ8g Fn7QiVr6v4c4Om1lzJ61k8fGp2EOD6BpchB3NY8h0k/JwQPnmbrTclPqsqL8X9Vx/tUVbUW1q317 1mVnuoXpG47RbU0aIcFG6iUEcvtt8Qy4PYZ64Xoyix043DIl+RZOadxoFTVte3XrBdE4PhCjWlHT yOIUayjPVzfFQHzbJJ7rlMHk7bn0fGwJvr4+JNcOoHlqJA/dlUiDaCMqL+e7JSFJElOmTKFRo0a0 b98epVLpJem3BjuvIueSSHr6Rb75aS8zVmZSICk84SWyjMMpIgsKmjWKYVDfOjx+Z1xVctA/Y/Tc fYZu9/9Cnd5NWPNtJ65LO8rsbNmSzo/pajq0iv+bCLoHv0x4m/en7+GTaZPp1br+3z+s5WO68rs3 6PPiBHwDQzDoNbjsNjo8+zzjUxPZbAvgkDWf+oa/8cFuO2f3rOG7CUup1er+f42gA3AhjVGvvM5J bRM+HfUKqXH+3u/tZuePrYh9a5Ywca2VFt2G/GsEHUA6s43HnnwVU/OHGTPyYSICfbwC8sKLW42g V6jrCqWCTnd0gA+X8seKLYTISykMasBd3RPQFBvp3cTE0qUzGdGpNwcylDz4ZpvKFnLOH2XUm+MI rHcHi35dym3xFbuTi22LnXw5Y9tNuQF7CJ9cvVt/E82s2ZhGrUKpUOJyOpCkilPUitucOCQJNCoU iv+sE0ajBlGUeXDULN7uHX0dfUri0KLPGb/qOB0Hj+a3n96ucltHomjXD6w9ZvUYLhQCSoXnpEN0 OQF9DaX4P9ONbzLDuixfdpcSjUoGRRRPv/0VL9zT5rrPuFF5OkEAt0vELoO2mvulIAj0bBJOiP8Z Tqfn43DGgUFd2XVZuIxZX+UZunJLscPuqjb+5aXwhMv74blQWmJlzJi1/HJRxWcfdqRrnPZvIyKn 0i/y0eRDxDWuy/yxd9A0pMJ90c1ynY0fNhff1LejVSvRK0UcLjcuoCJEv+LUp8whYneI6LUqTzZ9 wBAWwlcfdGHwnizW7sxh5+GLHM64yLvrTrJ4T2Pmvt0as06Fy+mm873N+G5YQjU/lL+LSKh574Oe 3Hsgg7X789h1MJc9p4r4ft95Ji09xebZd9E8RO1duW9RZGdnc+7cORQKBe3atUNRvjZ5Sfq/SASo qNQhcWzfGfq/tJZjoo7OHZIY1CmK2BAdON1kZhezfXcWP2/L5IOvLtKwfRwdjJd/otXKVl4RTub5 KTjUzKAByYQ2DK/0KrpmaUiFgEqlQKtWoFBwxRp87aXiGr9Xc6kvzDnHkRNHKbHar/r31df0q7dz PWNt+fNd6bz29gT86ndj3Yr5NIo247YWYtepSR/yANGWQPzVN7+XVn+va42ZoFCiVKlBV61KyQ3a vF7ytEqPu+u4Ol/xW4WwnVbOp5/glDYUh0O6pixuSnZXtyvdYJxutvwtNcMMrtL4DcuXXidco2pO 3SiUoVp/BQGlWu0p/asQbii7f1SOZcWcPn4U/9A83KL8p97bCy+8+K8R9AovdyUBTXvQwPw8Kzcu x2VbS6NeLxADuLUG+t3VhznvzuenRRos5iA6dGhfScLLCs+RZoe27ftUI+cAdqwW602zxqsSEYWA oFTgdLtxX+6Kfb14N5WAoBCwu5xIcs2NJCE+ksAAMycPplFSbAGzuaoN6yFO5BRirFsfo+E/s+43 a5iCjwqWzfqBpzq9RZCxptud7CrD4pAx+ejYvu8kCErue+Zlqj/VbbditVW59iuVCurEhSPaHZxI Owjt21WRc4UCp9N586YLQUBQenICOAHNX7aKqEiIiyZcymTTxo0M7NOG8Ms8DB2lViSlCq1Oxw3t HhWGCOFKsnzuYhllDhE/X315fXvBE/tnd2CVqjF8ALsbSYbqEXv1oo0oBYFDaRcQuwegrNa2texK jwm3w8G8n7YxZlMpw4Z3YkT7wOsrejc/+IBMSbGFUxY9fZvEVCPngOym1Oa+qSy1AAHBekJDBU5k l5BeCnUN5X9X3s8TOVbS82xENDTh5+eZYU6XhFqtpnmzOJo3iyv/nK08PWIlE39PZ9/9yfSv5Uek v5aNW9I53DmU1vGXafCSiMUu4aNTXVPpuN78czrdqDUqUhrGkNIwptIoNfHTlTw99yxTVl+i+aBw 78p9i0Kj0fDJJ5/w/PPPo1arad269TWVRi/+S/S8nFCX5Bfx+JvrOC778Pard/Be74gr7h58dyrv nM1h/MKT6MuviaKExeoElQo/g6rGeuVyipSUudHq1Bi1nvWqVmIYX4/pBoKA6jJiIbrcFJY4sDkl FBo1RqsLUebqccyyjLXUQXGppzSjSqXE16ytrL5x1TlVzY3f5nCjRIGlpIgCSwmyw4lK64PRoENZ bg0QnWUUFRVTWuZAFpT4GEwEBvqiEAQE5GvOW0EQEJ0OCvat4rgNena5i2gfF/n5+Wh9TBhVGkaO n4YoK9CoPeQQZKxFBTjREOhvosxSRFGJFZcoo9H7EBQUiKr8vWq8iyxSmH+JUpsDSaFCjwOXKN/U PlC9/6LTTkFhATa7C0GhwmAy4+dr8iS+rSBwoovS0lJcshKj0ViZE8BT7cSOtbQUpcYHg0GPAJRY rLgkQHJRVJiPpUSJwylhMBnRaa+uQQiCgOx2UGwpRaE1YNarKCkqosRaiiwoMfkF4mf0eBg6Si0U lZTgcImo1DoCg4PRqspz0FQzsrjtpRQUFVNmdyEoVRiMZgL9TZWE2TMFPePvkNQEBpgBkZKiElyi hNZgwlhZ7UamuCAfS6kNtyih1uoxmf0wG7QI8rXzCVQYDESXk5KSEuwOJ06XGxBQa7WYTGZMBn25 l2rNOasQALGMnAv5uNwSGh8j/n5+aNUeA2d1Y5GzrJTCoiLsDjcKlRqTrx9mk0+1srECktuJ1WpF VuowGKqqpAiCgNNuo7S0DI3BhI9OgyxDYYkVWVAguewUFuRjVjtwi2D280WtUuJdub3w4hYh6EL5 hqrQRtKtQyxjVszDoivjrZf7ev5Ip6PlXf3weWMq7380l+DElnSsXfEJK1HrfQkBck8eIrvEihER t8tJTvoBVqxYD9q/Tv3wNeMfEkhh9gEOHN5HxxR/rJZSdAYj/n7ma7cbFISfvy8ZaYc5cvwoiSEq rBYbvoHB+DVpR6sm9fl62TxWbe5MaK+OGNQCkiSy/OtJHDqXS99X7iQkwJ+bt4VfaWwI7zKAnk2+ ZN68T/ikXQOeuLMFvkZ9ZS34o9tXclyuxYuDexIeHgyyyP5tG8mv2xKVQsBhs3L60CY27c1CqQjx GDA0Ghp16YLxtR9ZMGciT/VPwU+jQHI7yDlzlN837UGtVt1E7wR0BgMhYSrSzqex+fQlGvtKOEUZ g18Ixj+pXDdt24EuXZKYMW0SibFRPP1AN8+Yim7spfmsmLOE6Ns60aVTW26UlFtQCFgtDi7kO/AV JCRZRpJkyopKeG/BcS46FfRoF4mpXHmMCdfCvnxWpxUSqg1AJ8jY7E42/36aQqdISLW2a7eOITng AMt+T2NttzBSw7QIkkRRkYUfVp+vIWhJdLN57SGemnSSRrc34MP7Ysgvsle5xisE/Mxa/lL0Vrn1 XavT4qd2k51RQG6pC70s4XZLnD+by5oduShuGMzoaaduXCBtG4QzYWsGc38N57meUZUfu8tmZfbK U+zPEnn90WASgpWAiz/25KLQaEipZcag85TqU6t1hJnUqAyemvWauEh6NA3hnbmnGLsgkNfuTiAu QAN4XGRPH81kT76ah7rGEmT+8yfdB/adp8RgJincB7NejVYNLpdESowJBCV+eq+qcMtTQlnm888/ Z8SIEahUKlq0aOEl6f8ahEqSvfnXfWy+AN3va+oh55cZtCvkExIXzuiXwyvXkqLCEr74dh9CYjwf PBBXrW2R9JOZfLI4k07d6vJgi2AAss7l893MQ5iT43jl7viqspsWG2s3p/PTinSO5tjQ+BppGefD qWw7GpWmJvl1uzl+NIf5q9L5I62AojIRvVFPx9viub9rPPUi9OWE5Or2/gWTxrFk/X7c2Jg56Uu2 LA/GbbeR0vE+Hr+vB8F+euwll1j/y1xmLfyVo+m5yCodtVJbMnTow3RomYqPWoEgyNfc7y/s/oU3 x8xGlOHQuvm8cHErINO0+1CeH9SBaaOeYUthHF9PeAOjAJLoYvbHL7PLkcSIZ7rz+4zvWLZ+F3lF dmJSmvHE8BH0al8flVDl9SA6LOzdsprJP/zI7rQM3DoTSbXrECKeQ3Ojfb3aKXNpQQ5rf1nET/MW cyqzGEFjILVlW+4fNISOzZPQlceO2y9lsGDGFI65Ynn00aHUDat6RubxHfz440+EtOrPQwN74D69 n8nT5rD71AVs2p18+cnbhPhpsNj0DHtpOF1bNbhm19wZB/hiwnT0dTrTLkHJsoXz2bDjAGWCkQ59 BvP80AGYKWT57On8vHIjp3MKCIxMYuhzr3Bvj5YY1MpK45P1Uha/LZrBnJ9Xcya7CKXOSL1m7Xli 2MO0aJCIRlExRyTmfjqSraX1+GjUYM7u3cbSZb+TVeKk3YBnGNazGZLLxtG9W5k6ZSp7j5+h2OrA HBJB6w53MeyRAcSH+nr042tqgC4yj//Bex9M5NyFXAqLrIgIBIVG0+b2Oxky+F7qRAbUNFaITjJP 7GPGts1MnbeSC8V2ouu34sGhj9G/ayv0qgo/UpminHSWLZzNwmWrOJdbitpgpmXH7jzwwEBaJMdV GlRKzx9m4uRpiNGdefi+XkT4VfX3xK4VTJ75K60GvUC/9g0pOLiRr6bM53y+jUt7f2f0OxkY9UpK 7Sbe+vRtGsZ5DeJeeHHLEPSKtUepUHF7h+6MWf4dtrDb6Ns1pnzTVmGMaEH/lkam7LhEi7ZdMVFh pVQQGF6fR/o24LNfptKjXwGdm8RTlH2aPbt3cvz8JRTqQESpyoooim5cbs/p5uUbjOh243a7qTAq o4uheZsuJE37lS/eHsEfvzZGLLbTa9AjPPvYPVd9IRkQTCl0bt+RtevG8eqLz7KgUSKF2TZeeH8U 99zRkueffYxj6W/y2rPPsHvD3bRIiSJ9/1pmzF+Pud5dvPhwd0LMmmqb3tUhul3gcldZwasTMCGM r7//iryHR/DN8IEsSW1Bg6Q4sBdz4uBujmZbeeajGSAIdL37Xup9/TOTXr+fgsMDifbTknHiCBu2 7sRmcyAKFWOiJiCpO68Pas2o2XNo1+UCvdvXx5p3hj3bt3Iu14JS61/uun99JS40LIZeve9h5bgl PNSjGy0bxKAxhTJg2Kv0q6cql5OAJF2pkLtdLtxusZKsBtfryDPPvU5O3juMe/Mpfp6eQmpyPG7r JQ7s28e5HJnPf2rMnTew+gOoNQqWLz3EmZ2n0QgyoihhLbGx90QBbqWagQ+2YWirAAzlB84970xk xkELb7y/nv0dovBTSRw6ksOpQhcWu0QwVJ3uGoL4bGgdHv/xJL2GLaVVw2DUTjtpGRZM5SdCiorT luKL3PfuDpwaDSFGiVc//aNyzsqAj8GHUa+0IFRZbhGXqjZyhcJzIoNUpVF6roEoVVnHY6KCeKiD PxO3HeOuV210SDRw8UIxe49f4niuHbXJeAMPFM9vxohgBvdLZu/JbYyZuIU/dkbStrYZ2eFk4/YM dp220LFfI+5tG1V+UqZk/e+H+XZdLq3axNIhJYBAg4ITRzKZs6uAlncm0zTeCCh49YlmXLBK/LR4 Nzs3n6JRbT8MKpmzZy6x52wpvfu34EGFUDXvRVDcJDHLPp7Jfd+f5LYWMbSrH0xUgIqczEJmrDhJ bJ0IBnUJ9a7atzjsdjtGo5GxY8fyxhtvoFaradSokZek/yvWEs+SIEoii9adQ+Wj4fH7qqpNCFfx Srp8LbFabMxdmAbtDJcRdInsrItMW3gcZWJ4JUEvuFjC/CVphFp9eOXueA9tsZYyeeoORkw7jjnc n+QoAxpZZM3ObNKzLMTX96vR6a0bj/LS+H2kl2m5vWkIjf1VnE6/xJhvNrH+SCHfvtSMhmFarl70 VCbrzEky84oAF2dPn6A4LxNXWSm6hI44RRlwMPmdx3nl218JikuiVdMUZGsee1b8wKJZC5i0+Gce 7t4ErUpxTV9re1Eeh45nIMtwKesEB6R8ZFkisFEBAjLr5//ArPPNGTvhDYyAJLlZM3saC7OC2Ldm AhmFCqIiQtGqRLYtnc7KNdtYt28fHWM9p9OSu4ytP0+i130jcQdFk1IngWCjkqN7NvLbuXNoTdE3 EL1nf7EXZvH9R6/y8ueziU1pSpPUZCRLDqumf8Hypb8y+psfGN63pUdOxblsWD6HdWXN6HH3o9QN q2rvYsZR5k+fQqKUyICBPVDaijl99jwFFge48jl+9BBZOgXFNhP9iizX7ZuYd4rFc2eSKf7OOLcV na8vYSH+SJfOM+G94Zw5fYjiQ+s4mVtKcFg4JqOWY9uW8ejaHYTs30m3BlEebwNnIWOH38PoeXup 3aARzVKTsV08x7o5nzFz5kIWr1lJ32YxlYaKdXN/ZE52Pcz2LUyf9RsacwBatQp93R4M69mEPSt+ pM/g51GGNaBDu1Y0Mis4fWA7E957iqWbDrBx6TcEqa+zfkkOLmXsZfGqbdSpV5eEpGSUUhkZJ4/w 2Tsr+f2PfSxe+B3R5W6RCpUGS8Zhxo16DofNRmhUBCajkp0rfuSPrVvI++ZHXrqnDQJgyTrCqBeH 882CDSQ1bUtqajLW3DPMHPM6y35bz9cTvqbfbXU9czPvLEvnTMXVxI+7evckotrndf74DqZ/Pw2p yd30bN8QZ8kljqVnYnO4EQuzOXLYjUYFJY4gSsoc3jXUCy9uKYJevuEpVUpa3tmdRjN2UfeuYURR tVfpdEbue+R59rKJgd3K3dsFj0XeNySaV76cRgEv8vueHcw5ug3f4Ch6D3mJD1J8GD1mITEhnhVD UGkJjUuieeNggkw1T9w0PiZqpzRGY65dSb4Abr97CF8rBL6aNIv0Y2lofGvh6x94rZep9AgY8sJr KMx+TJ29nFOHj2AISsFk9Ljo1mo3hG/G+/HpmC/Z8Ps8Vv/sRqXxoU2fYYz+8B2axAcAcuWmdy3E JDehoTsAn8us2xXKaUjD3qxeV4+JP0xl5eo/OJF2AEGpI7FlLx7r0pW7+/cEwJTUg3k/fsKz73zN tpXL2SqoCY6ty5tfz0d9cioz1lgwlY+JzsePl7+eTZHyGRZtOsyyJccx+YfRdfBIuteSePfHNYQH GW5kbEcXFMMDIz7ArvRh3sqdHE47QUqrOEICfUFZSmRiMk0dAgHGmu+mM/qS1KAp1lpx6BVV7bXo 9SCzUhszZ8Z0VqzfxrGD+1HqzDS7YwCv9OjNXd3aVyUyu0xRLLO7sbtlSt0KwoKNnM8qZGNmQaVi qVKrqJsUyV09knjgthDsFjvniz0NRTZI5KEOF/l6VSazlx0BpYLkBrF893QMb3+6F5VKJjPXio9G gQw07t6Y95xKxi9N58iJS+iNenrf1ZhHYl20f38v1lInWXlWys5fosxoJEQlsHPzaaqHaskymEwG 7nugAW4cFDgFggL1iGV2LhbYsJc6KHYrCAnU47LZuVRYRlmJDYusIMxfi6O0jEsFWtxKNfc/0ITD eTtZt/00O7aAOcjEwO4JDPYV+XLZBcQyB4VFZZQ6xOsqZwnJkbzzTDM+m3GYPzadYu1aCQQBnVHH 7V1SGDmwDlF6ifO5VrQagWZNImiWXswfm07y2+9uz0DrtLRpW4v37k3ErPDcq1KbeHt4C+rUOcWi dRls35uFQ4TIcF8eGpBI/y6RlFrtCJIKSaclMEjgUn4pmUoJrmMoEgSBsMQwejfIY+XOc6xdfwok GUGrpna9cD55rhXBdhuYDN6V+xaG0+nEZrNht9u59957ef/99xk7diwJCQlecv7fRnnFCUlycuKk HbU2hFZxisrTR1mWcTtc5Je6q2QjyyiUCnx9dWgEz3ep1apAfSWBVyoE0CpRV8v6rFAIaDVKNNUS RW7dfobPZh4juXU9fnjrNpqXxzzJuRd56r11LMuvsvpeOp3JZz8dpiw8hk0ftCMloGrzn/njJoZO OsHyNpE07BvHVQKckRB44dNvCZDzeGzsBsbP/oW7WtWtcduhxZ8w6ofl1On+DEunf0acv2dPy92z mO59h/DC8+/QbtNMkiMDrjpnZVkm4c6n2JPkh67uA/R6ciyz3q9emlRErdWBTltjvDRaQO0g6c6R zB0xnNphekBi1hv3MPjjZXw3bRkd3x0IyORnHuaVZ0eiiG3BtLnzGdAqtvzhJcx4bTCPTNh1fdEL nn7sWL+U9z+fTet7XmT2jC+IKY9dOLRuFkPuf4Svxo6habM5tI7SgI0N9CUAACAASURBVKBArdGh lTRXhJ4JSiVarRqNWoUoQ2hqByZN+pyS/Ps5qO3IohnjqRuuriGLa8YuK5TodDqK80Vef/dzXn16 ML5aoOQQ3dr0YsXM72jZ51FmTx/FHQ09hoifPxrG/W9OZubPu2lfJwyTXsXW6aMZPW87tw/9mKWT X6Mi4Orkmu+5vd8TDHvybdpvm0qAWokggEarBOdJft0bwfsT53F761QMCicutR+luUd4ethzBHd4 kg3LvyWgWr+Xjn2Yfq9+xzeLH+O9gQ2vM+p6ktsN5eS5EQSbquZtad4pvnj1YUYvW8vC3w7zYr/6 VYqDrKLR7QP5cNQI6sd4TtdXTv+YIY+8wYKZ07izexuSjG4Wzfye7xZsYMCIcUwc8zz+5Z/Xmhkf 8dCwNxk3aRr1kj4gKVCJoFCi1epQqNVXjL9SqUKnA5VKgVuG2Hb9+XmqiSad7yOg48ssnDgSPx03 J0cvvPDiv03QK+LGlPjV68u+A32rXfNs6iqdgc5PfMDeJ6rur9jwZUEgIK4x3y3ZQHFeJoWlMhHx 0ZUJY3r1e8pjbJRkFH4RDHj9Gwa8fmU7oYmNGDPjt0rKURmapfGjy73D6XLv8Cv7fLWFpOLkRh/K oGfeZdAz717l76BOq95MWdwba+FFci5aCIqKwd9HVeP5116kPL8/991vPFd9YasWM1zxXkr/RIaP /JDhI6899oIgkHrnE2y483EyTp9GofcnKiKw/I5uPD2q2pgIApqAOMZM/5XRRRfIKXESER1TmVDt zqGv12j36nqcpy3f0ARe/HgKL358+dsF8Oj7k3mUK+UUmdKG8fPX1hyn8r0nODaV597+jOfevt48 u9LokX3Jxqa9OTj9wnhlWNRV49RFUcLpLGPpujPVkvp5ssMF1ovltYgATmXb8A0wEh+iJ+uCzEtP tgC3m5VbMipP+2UZjH4BPP9YEIryeDW3283sVekgC1iLi1m8zg4KJRNeacP1vpnDf5zkAAIqYyBf PhtMWVkJs1cWIQgC6oAQPn8qDFtZEbN+L0AQBDTh4Yx9PBKbtZBZK/MRBE/SpHsHNqJdVjElbgVR Eb746wVcInz6RAhl9jJm/HbqBmTHMyBqtZIHBjaiW76Vc3k2BI2GuAgTfnoVaYezOHCg4psGjUbN 4Hsb06uwlHMXrLgFJTERZvwNKk6k5ZB2UKpMECUoFOgD/Bl6f2ClN4IkybjdEudO5HHqmCd+M7Zj KuM6w+nDFzguydc//ZdllColPXqk0qV9GaeyrNhEmZBgM7HBWorSLzD/pMxz99X3rty36oGtLJOX l0daWhoA7733Hr1792bfvn0kJCR4B+jfgugi3ykgmDTUyBohSZw/eJYX55/1uDkLHm+XgEADzw1v RV3t3/BsSzG79mSQ4RPEyHtSaR6uqUrEqVLgb9YiXaoy3G3dm8OO02X0GRiIVFjE1vMuzx6nUaHQ 64nQOTiQVUKWCJHKK/f6CrOAze4EJEotJVd0acGCxeTbDHz/7nPE+qsq963Qpnfz9L0/8MQXv7H2 +EVqhQegU1zdmAhgL7EhA067DZdbRK26cU1ydWhHZo19pXLvEQSZPkMHI3y8hGM5ZzzXnTZOb5zP jotaHvn4bQa0iq3av+0iYWFhV+TSuRrcBRnsW7ecwqAkBj0yjJhq1UZSO3Th2acG8thnm1i77g9a P3jHnzT8gGwtxemWEJVOSoqLIDy4hiyut0M57Da6DXmHl4YNwldb3i9zKu2S/FmV5uLLrz+hdWxV e337dsX06QwunDmCKHYHVEybPgcUsXz6yYvl89oTI1678+M8fdd43pg1h7XpExhQt2rWC+YmrNu1 huganRPZ/9Pn7L6o4IWuvTm7ezvHXFK5wUlGX7s5Onk663dsuCZBl2UZQaFCbwrAln2O7QfOcur4 Mc5kZGEpLeREVhmy5CSvIBPw7GGi24lfYmMeHT6S+jG+lSdgHTv3ZEjfhfxw4AgH958nKamAHX9s RF2vK4MH3o2/okqOne+7j/t++51x69ay/8B9JN3e8E/L0WW1IUoyLmcZxcUW/HSmm5ajF1548V8m 6NdKjFLNNHvV3y7PrOkbElVZZuVygni1rOg126m5ktzIgnf9TOA3/q2CLBr9g6ntH3wFYb7+869u GBD+RD+4jMh77hWISUi8oi+XP7Pius4vjHi/q4/3dZ99g0VY+AtyuplF/ZqnE1FmEqLM/5WPoOBC IeesMgEmLT5aJUgSRflFzJhajDkshM9GNiXOu0PdUiTQexJ7a8LtdvPzzz+zfv163njjDTp27Mib b76Jj4+PV3b/JhQqArVw1u6gEDBRdVpeZill/4kCDFoFoiiRcb4Ala8fA56sSdD/qtTyC5wcP1NC dKQvdSvKcFVuXCBVhoN5dIfMSw4K8u38NH83ixYJ1QypMiq1EkGtI8KkBTc1M37eNKwcPV4Iwc2o 5aurtOtWdCm1QStM6t85tCcbV+va6PR/c01oScICngoYnsydSPoQ/AGpvByl0+li364jKA0mWrdu V2PMZNkT5nUzKCwq5djxTMJDQ6mVWK9KvwAEZQihccmoSpdw7syF/0jGfwkCuOxObHY7GPWV64LO Vw+4KLZYkQiuyunip0dQCLgqrfF5HDpqgYTbSdRLlfOpolRw4ybtEGYd4sDObAbUrVP1XJ0/ZoEa oQtul5ude04DIlNGDWE6NcdXUKiISE4lxOBzrU3Jk5xNdHJs50o+eGsUizYcwCcwmABfE3qNEkth Liq1H5dLThLd2MtsgG9lf7Qh/kTXjsWy6Sj5lkvkX7BwLiOXWvGtCIuIrilHTS1iouKQstdz4ULh 9RU3L7zw4n+foP+nK++1s1zeurjm6fK/0O8/25frGlT+x/Df7veuNYfp9fUx4mP9iQzWo3A5STuW j2Q28tLzrYgTvMTi//L88OLmERoaisViYfr06Xz00UeEhoZy6NAhWrZs6f2G/hVrlofYKZRa6sVp 2H7GyubTTh5IKD/FVilJuaMRZzo1RFAIFBeVMuL1+SxMV1zJfWWhWps33wWnKGF1SqjVCo+L8XX/ 3OOF49IZeGpIE57sFIa1TLyM38qEhPkSfFM5KIWrVINx4nDLYFRR4Zlf/ZW0Wg2CAlwOx5W5ZP5+ jlr+fNlDRMu/D0mWKSq1o1Qo0Pno/jLXkiQJh9uFSq1Aq798XoBKpUaFiNvlvnLe/Fu2pPLOXfG+ yupjJgAOykTQmpWVJL66HHXl4QUuh6PmlJUlD0m+bC1ySk5Qanjuy0Xck2rAdVm5MUGhxBQUda1N CYCL547y3tMPMf+4nqff/pIH7+lG/TqJGDQyWxZ8SNvB429uEJRKlEoVSBKiLOOWRJxuNxqtErX2 Sjl6EgG7EN3iX5OjXG6w8LJ6L7z4/52ge+HF/w5SmsXzfD83h89YKCx1olQp6dYzhX5d69K3SYCX WHjhxc0o1goFQ4YMwd/fH5VKRZcuXdi1axdRUVFew8q/hfLTRKVCSec74pj89SmmzzvGgDcaoL6K N5tKqahxvUJdV8gykiheRoMEVMobny7r1UoC9GoseU6Ki+0QoataUxXCZeUYFQT7atC5nAhaHfUS g6/DKW5QA7s8c3eNAusA+BEepIMTmRSWl9KsKsUFWZkZOBwQGhWIUqX4V8SmVCgIDTTjdLnIy8kB 4qo8+ZRK1Mqbcx3w0WkJDw6g6KyV3KwCiK6+n5VRUpCLHQP+geYawyaJIpLoBtSV0lYplVeGmlXk OLgK4f1nY5dlIJDoIDUHz2ZQ6BYwU7Peeca5s8hAWEzgDSmnQhCoExcBooTVpqFRk2bXfvI19QGR SxeOsXx/IbcNepEJo56t9lspZQ7H1UO8hJpenIIggMXKpbw8fMx+BPsGYDY4CfI3czq3gKJLVggy VutHCQUFBaDzw2z2qRSLIIDodiNLIqCslKNSqeTK6oSeuETpavTcG4PuhRf/jk7lHQIv/i9DlmWi kqL47PVO/P59H3ZM78fWKX2Y/lpr+jYJ4AaJB7zwwotqimVISAhqtRpBEOjduzejR48mMjLyHz+J 9OKaDN1D+JQKevdIpnGIilVL9jJuZRZ5Ja4r7nY5XFgdkid3VSV5V2HWSZQWFJFVLfW7Jd9C2uli UF4/PMovQEdKoi8Xs4rYcSinhrEm+4KVzHxHOUn3PLFBUhDNYmHxqpPM3Z3vOe0uJ2VWaxn791/g VLYVN8J1jT46kx41JZzJvkhFLmqXyw0o6NgxFa0jjaWb9lLs9oyTIAjgyOfX1WtwqEJp2yISrebf WfvVGg1NWjYBeyEbVi/CVW3MCvOyOHoms7KW+/VgCg6icasmWLJPsGnDihpjbz13mD/WrsEnrhaN m3jc33U6DUaDD3m558nJzaycQaKzlJMn0ykocdUITRSMejR6Hfm5WeQXF3suSiJuUfTk3/nHhk8G fOjWpT7kb2HhpjRcVMgRygrPsmzVOlSmOrRvEcqNToUVSiXN7uhKiEZkxvjR7DyRid0lVT6rJD+X owf3cuB4+nXmnIzkdiECKl3Ns6/S3PMcPZYOVxhWBCRRqgxZqGj70M7dbNh4iHrJDUmpG4c+OpL6 DZM5f3QHO3Zvq3HvpYN/sHXXHiIa1Scx0eP+bjDo0Ot0ZGYcp6C4sFKOTlsxJ06dx1pWs7KKyteA SqXmQuZZisszt0tuF6Ik/cNy9MILL64F7wm6F/+31dcbJzbwOnx54cWf+I68Hie3pvFEFxbO+BEN efCrNEa+toL9Axtxb7twAg0qBGRKS50cOZLN1tNOjAH+6Mu5hNGoo1ULf77cks07PxzlkeZ+FBWU snHraeauyQCNrloceXmSTVFGrHARNhhp2SqGOovOMHnuAUKNAo3DNWRnFfDrmlMs2pNPcJKp0sM2 pXEUQ/un8PzEQ4z8xEFa7zo0izfists5kJbDj0szePKpVrw+sM51yJtA/eatiA5ZwOQJ3+IrlhDl U4bblEDXjm3oN+Rpfvp1B9+8+xYhSjsdGieikp1sWvAVP649T6eHP+S2aH9UN5zPMm43iNKVMeGS 6IYaLscyogguUbx6O1BF1NQ64tv1o1vC5/zy/VhGJ0XQJTWCkoJsNv66kDnzV6FRhVy3fKosg6AN pFmXe+k2eR5zJnxKTLiZLqlRuMsKWDZnClNXpNHnmQ/o1sZTek8dEU1So4aULpvOtCkT8BcGoHEU sOuPVcyZM5+MUmglVPOcDkmgfnJd5qxbzveTv8eW146CzFwad+hIo3oJ104RUF5CV5SkK9ywPZ4a biSuLFXrrvwbz28PPDWSH1c+zDvDh+PveIf6sUFITisrZ3zCov1OBrz2Jk39lZV7uOgWkauVg636 PpT4pvbmg+H9eG3iz/S6axAvPf0gybXCsRfnsXfLOlav30ybYV/xTd1a11Sn/cNq0y5ax/ZfZjJu TkNaxJgpupjFxt8WMmPOEgRtTWOlIIA16wyrl84lQtEKrVJBUfYxfvz2S7bnmhj9Rn/qBwFE063P ABYvWcukL8di1kq0TAzGYbnA5HFjWX+4hOc+vZcm9TzeSrrEetSrV4cVs5czdVpD7L3aIVjz2LBy KXMX/IzlcpNFXCqN68QyZeViJk5JoVurOmSlX6DrgP7UCgv06kBeeHGrEvTrbVD/PWXsSne2a2Zt v7W1pRqZ3f/ZsbyKC6DXXel/UcW++tz3Gg+8+B8xenkJ+79LzgEUArTp1owlviZGzTrGtk3HWPrL QXwNGhTIWMpE9CYddVLi6dw2nqTyUku+AQaeGNyCred2Mn/aZn6aImDQq6lbN4ie3RPZdLCYMF9N 5TN9DBpqxfoRFFIV9Ny0SRwfP1fCG9OOMfL91ciCgNGoo2VSAJ1bRlKiN2CusAio9Tw8qAkms5ZJ v55l+ty9TLCLCAoFfmYtiQ2jaJ4S5FFerurh5Pl/s+4PMGzoMabN/5V3nl+P3emm1+Mf0rpZI3zj 2/HpqDd485PxfDzyKSaHhOAuzafIqeG2u4Yy4cMn8TPpqZE97mpzXWMioVYcYYHmy+a4QHB0LWJV kZUkVRAUhMbEkuAIv2LdVih1xIXHEBbiV/n3pqA6fPrNGC4+9wFjn3+AD1V6DFotCbWT6drjTrYd zcXXeO00+xU14uPrt+Ljr7/ipZGjGPPCQ0wMCEZwWSixQfdHX2PkS08Roi6fK8pguvR5gMd2HWL2 4omsnjserVZPeK2GNG/eFq3PAYL8zNUUR3/uH/QQGdmXWPbzFFbP/ganEMW3s2rTpN61qzYIWiPR cbUIDPZDpaw5Gn4hkcRGifhoLksyoPQhvlYCkSH+laf4gQ36MOGDkbz62VRefGwQ4eFhlBXlYJF9 ueuRF/jm3QcrojwAgZCYWsT5RtQwHFSENygVWoaNmYrgF83kJWv46v2RWMucKFQa/ANDqdPgNrq3 q38da4hAeHQ93vjgXZ5+8wtGDu6JxuCLVqUkIaUBXe7ux459WQSYyhPNKdX4h0YTFHSMDYvH89vM T1EooMRiQR+YyIj3P+TxId0qH9G82918OPYi734wjreeGoyfvz9l1gJcGBk88hOeHNwbX2W5HDUx DBr8EOkZucz66m1++kqBUqUlPrUtrTu2Q7PjMP5GfbkLrQyE8/xzj1PknsyiiR/x05cORHUiyzt1 JiEs0LuQeuHFv6FL3fPUF3JGaSA7pj94U4TR6XTjdEuoVUq0GuV/RDCvdv+N2rCXOblY6EBn1BJs 1vztSsw/aXioTqosBXkUFJciCQJGvyCC/Yz/2LPdLicXc7IQVUYiI4L/JVL3/4mB5V+Eo8zKxdyL qIz+hAX53VrGAq8cvfDiH8fu3btJSEhAUe7eXFpaWrlffDBhOcccjZAzf+X+/nfy+IBWgCep2tEz hZXfrEarQnA6WL/tPGnnS8jKsyMqlYSFGEmK96dVozAijUpKSl2VscUCMhmnc1i0OZt8q0hcrWC6 t4kmVFHGst0F1KodRPMYI6IMRQWl7DqQiy7Yj7YNA5FdEgqlAlwu9h/M5Pc9F3FIClLqR9A5NYCC nAKOFEKTpCAi/VSIEggKAYNOSf6lEvYdLSCn2IVSrSQ22p/Gtf1QyRJBfnr8zNob7OkSR/dt5+TZ HGSNieTURsRFBqNWeN7LknOMlWs2cPBYJmgNJDVoxd19O6G7xlp3OcTis/yyfh9hCY1pnhJbzf1b Zs+aZWSU+dGzdwc0gCyJ7F69lGwpjJ492lQjuTKusnxWrdiELi6ZO5om1dABco5tYeEvG7lkcxNb uyF3dOlCiOMMv+05R2qTNtSO8rsp3aY49xS/LFvB8bO5CDpfGrduxx0dWmOqIOfV4rcvZZ1gxS+/ cDKrAN/QWvTsdRdx/hI7t25BG5lMw9Q66Ku1by/OZc/uvVwoKsM3OJpGDZMJ8jVcM6GgWJDJhp37 0ITWo2lyvKd6SjlO7tnA4bOltOnSkRCzoerP7RdYsWYHhrAk2jRKRK1SVtpn8tP38uvazRxPz0Nj 8iO1aVvu7tbqMv4ssXv1Us47g+nZsy2aa+hmAC5LDtt3HuRisQ2VRk987RRS60ZfVz+rui5zYudK lq7ZidUO8fWb0bVLB/ylC/z2xzHqNGpG/bhQZIeV02n7OZnvJizIn6O7N3I04yI6v1DadexC+6Z1 q+2vVfMw69Q+Vq5cx+nMAnS+QbTq2JUOLVPQCFfK8ezR3axavYaMSzZCYpLo3/8ejI7zbN91gIjU NtSNDav2dwIluens3neEQpubwPB4mjWuh1Gn+dOJIb3wwosb49ChQ0RFRVXu5y6XC6fTCcCZM2eu TdCrL0JOWxmHTxdyOtPCmWwLRXYRk4+WiHAz0SE+xIabiQ3zQfUXPmC3w8Wp05c4USiSUjuI/8fe eQdGUW1//DPbS3bTe08IIYUeegepiqCIiB3Fjii2p4gFxYqKIoqgiAgiAipSBEQEpEuTHiAJkEBI 78n2md8fu2mkEHy+9/Tnfv9RZm7u3Dln9p77Pffcc2IDNM22P37oPB8sTaVtvzY8el3kn0c7TCUc S00DfQCtokLRquR/ujKqjcSRHRtZsfw7Dp7OxIaM5OsnMnVYHDuOZBDSqgNdk6P+1OcW555n1nOT yfftz5yZU5D/Dz/IwuyzpJ/PIyQ2jrAAH/cv9Cpw9vcdvPfaTAL63cULk278n47lUsZJzuVW0jop AV+j3q0cN9z4ixJ0u0Nk4epT9ZKxCYKASiVHIROQyZzExCE6y3dZbc7M0ZenilMoZWiUzkRhDoeI xeZAlATUShl2uwOrK6RdJhNQKZ3lKi1WsXZhLzivq5XOsdvtDqw2EUEuQyHgrKctSnUymzuTpSkV MmeeN8n5XJtDwmyxM6hrKK0jW0ZOG7tXl/Q0ZqwlmifnTTv2awlSk31VR9I1EtFW3W9LHfVXanel aKu6f99iZ2vNO9GkE6Op5zYvt8Yj/qojGYSW/E2jDuVGdNLCsf2Z96+uXX0H0X9Ej/Xkc3V6dMMN N/6zBF1xpR96/oUCFq8+ySc/pJFVLuHno0GjELBa7BSVmnHIVPTpFcXDd3RgVLLnVQ/QUlLBVwt3 MWOXiXdeGMSTw4KbbZ+fU8LqTWlUhQTz6J9Jni8c4vnJjyMl3cLslycRHWT405UhCFB8ZgcTxt7A CXsIXdvGosLC2Ut5nFiziRsen8fIxz5h9fsP/KnPNVeUsOWH1ZwN0/DhzP/tB7nnh4U8/dpSHpr5 MY+OH+L+hV4FSnIz+XHlaqJ03XjhfzyWDZ++ykuLjjNv1TKGd01wK8cNN/6CkCQJhVzGfTck/L99 vz9SHvXPyD3S3FGO+tHujfRVfa2Re7V9tIwSXand1dxvceRenXE3mUT/D5SEbXhaQahTVq2Ff3OZ Y6n6/hV18ifL8t9vV59g/0f02JR8/sA7ueGGG38uFI1YvBrvbXlBCa++v40Pf8yn9+DWPDU0iraR BgwqgcpyC2mZxWzbncXW1AvM3uDNqOR2TRrQhobU6eFTeWi5ZlgiqiQ7vVobrmh4lQoZWrUclaLl IbbN3a9+jsxuJjc7C/xL4fI9Zpe3uKXey0bu1nhvN3wxk4M5Iq+uWMa0m7oCUFllpujEFl5+KYiE 3t2uZnVSzwvc1BgUSgVqDWjULTkScIWwvmY851JdV2yDXQHnLUtFCVkXz1NeZW2hDK8cZljvAU3p 3yWnlnrAL2/XMMLryuP6M7ztddsIMjkaNaiVihbo7j+rx8qiPLIuZWKxi3/ovdxww43/PP6//w7d 84wbbrjhhhv/CIIu4SQyoujg22V7+XBtHteM78JXz6cQcFnrbp1CuW10Ert3pXOg0nVqSxQpKzWR V+EgwN8DT42sxpDa7Q7yCyowSXJCgzxQC6DUqujaPYaEzhJGV8KTumd5CnLLSM+pwuyAgEADBeX2 hkTfRb4sVWbSL5STX2pFksnw9dETF25Ao3ASrnohTnUMvM1i5kLWJSwOECqLOHP6JGKFEatNICwy DA+dpoac5V7IIPPCJSpMdnQGL6Li4gn01FwhJE1AECTyL2Tx6++HQQikW4IXp0+fRkJBTFwMoW37 8WB4J3RGnxoZ2MoLOZtThF9ILL5aK6dTT5FfXI6g0hEaEUtkkJeLMdUnWZWFFzmdkUWZyYre0w+Z pRihRQX16hO8vKx0zmblUGUR8fDyJSomGn9PHUIdh0NFSSGXcovx9A8kwMdQLVTATkFuLkWVdoKC gjDq1JirKsjOLURATsGlLM5kZiJWVaLx8CEwwBeNStGE7KA4J5O8Ugcx8dHYy/JJTz9HcYUZrac/ SYnxaBUCSBbOnUnnUn4RDhQERLSidbhfjW7qhhlmZaRy8VIBVVYRo7cPMa3b4KNT1NOjrayQszmF eAdG4u+pxlSSx8W8EiSFhqjoCJQuVVvLCziVlkFhSQUo1AQEhtAqLhrVFcIUBUFAdNgoKcjhYm4h 5WVlWGwOVGotvgFBRERGoVM27EOhdCbPOXfyMBfySxEUWsJjYokI8kEQpPrhmw4rF8+nc/5iARYH ePoG0KpVDEatsp4eS/IukVdiIjA4GE+Dto4erWRnZVMpKgkLCkCrVlJeWkxeSRUyBC6cy+B0kBbJ akXn5U+QnzdKhbt6oxtuuOGGG2644YYbbvwpBN3JzSTMRUW8viwDj5hg3p/iJOf1iELN2SmBHj1b 0cNJlXFYbOzbksrsvWU8cm8vhrau3bUtL61kyTf7OG4x8tJTXYkWQDKZ+WXdcRYcszDp9k4MbK1z knmrlb17z7JgdRrbTxZjkQSCQ70wilYKHTLkNYTFmcAm61w+X/6QyubfCygx2bE7JAw+RoYPjGPC sEhCPZU1O+mXI+fIr7wxdzGns0tRVG3kxedS0atllJk8mTn/Xfq1bQWSmV0bVvHZ559z4ORFTFYJ uVpDtwEjmTDxHvq0jUDWLCFzMO/5SWzYmweCkhcfvh+NXEB0+PD5jysw/L6aCa99ycj7X+Oh0R0B ifx963jsneX0HTkBv/IDLP12HedyCrEpjPQZfANTnn2SbtG+9XZ90w5sYsGnC1j3yz6K7eDjE0RI aDDnKhQoZFfarXU5LMzl7F6/ggVLlrHv2HnsooDG6EvX/sO575476JYUWePoOLFnI2/N/p7BEx7j wbG96/RWxobl8/lmXymPP/kYg9pHs/6rT/nim41UYGXVko/5feu32EwVJPQbx5MPTyC+mWQ3W5fO 4YstOYwZP4SzB7eybtNOMnOK8IlI4PYHnmBcvxj2/byGJctXk5qRSbldSfueQ5j6wvP0ToqozRRr K+en777ms0VfcuJcMTaHhEpnoO/wsdwz8S46x/jX6K/o0AYef+srrr37BdoaL/Djmh85cPIcMn00 n//wOaECnDvyK18u/JKNuw9jsdixycDoGcz1t05kwu034KcRmi2lXlGSy5IP/8XCtccxmc2IDhG5 QoV/aDTXjbuL28eNIqQmGaKATAZ5mSf48rOZfP35Uo5kXEJQSVveKwAAIABJREFUGel2zUgefuRB BnWOc2bvdSXu2fT9UhZ9s4rjGTk4RAG9bwgDR9zAxLtvISHCv2ZcO35YxMc/nGLy1GcY1rNuOGwB i+a8xf6qYF59+mESI/xY/O4MVm49ioiZT955le+8DdjMVXQZ9QjP3T8Gfy+te2Z1ww033HDDDTfc cMONP4OgO4maxKXjmaRVKOg+OJokI/VqN1Yz+caKm4gOkfNpOazZXsh1N9YPf7WYbew/mMm2Kl8e d3Un2exknM7lh50VXH9d2xoye2BPGg+9uYczZg0je4cTYlRQUWbi0IlSyswCdblm7vk8Xpq1kw1n LAzqGcG10QYks4Wde87x+se7KXcIvDAuFg954yxJqdXh5+2FSiFHodHjHxCIp06BwWJAq1IiAId+ XMyEux6jwieeoYOHERXoQXbaEZbNeYU9R9P46vMP6Rjtg6zJkDsB78Bg9BoZiHa8A4PwUsgQJW+U coGqi6dYv349EQMfdwkGKjKPs3HDj+w/moa3XkFCUjsGt9eQnXaMb+a/QXqZlr1fv+B8puQgP20P Tz1yL6t/K2fEjdcxIDwAe0UBqanHyCwRiW2Wn7scC6KFfeu/4qGHnuKiqhW33Hg9IV5qzh77jTWf vcm+Ixl8Nv89ukQ7yXTOuVRWr19NQK+xl/Vn5uShXazdkMuYO+8GwMPLGy9PD2QXijF4ehMcEoKt qgJ/H09UV9h1TT+4kw1rd/HbgV8Ijogltm032nays/un1Tz/5BR2dAngTGYJEbGt6T80mbLsVFas /JRLUgibP/8XAUYnadz69YeMv+d5vNv1YejQkQR4KTh7bB+fv/E0+1IvsHzBO0R6KRAEqLpwkvXr 15NdBGLRccwqHwJ9jFBUiMUBJZkHePbRCWxI13PT6OEktQrBVpHP7q0beO6hOynkB96cOKim3E1j sNmsFJeWEBKTSKuYKHyMGkyl+ezfsYXpT0wiz2bgnYeH1fzmVAL8/usPzMoOJyAijuGJnck7d5Qf v3yPMzlFfPHph3QK9QBHJeu+/IDJL3yAIrwjo0fdiI9a4sT+bcx97VmOnytkzptP0yrAmeAt4+he 1q/by8i777tshJX89uvPrCtrxeMPOvXo5eePUacBrHj7+hEU6IPdbMLXywO53B1y6oYbbrjhhhtu uOGGG38yQYfTaeWgFEhp5V2PkDscItkXSyizCTWcQxAEPDy1RPg4Q9TlCjlKtYLLOZcggFIpR6OS 16ErAgqFHK1aXtO+5GIRi1ce5aRJx7vT+jN5UFBN663rDnHLi3uxi9UOAysr1hznpww7L08dzP29 /WraPjU+ltse28iKn89ybfdg+sboGnVGBCX35vWX7GzfvQs63MyCT18mwKNOI+sFZsx4g3NEsOCT Jdw+MKnmVr/4e7h92kLmfDuGDx65HqNW0cR5ZTmPvD2PoqyfeHGZyCfLlxFRp8V5uVMVdcODZQpn KHNIQjfefW0qg7u2cTo6co8xrGcKO9d+wWHzC3TUgNVUzroFr7H6t3weemsRs58ZV6PcgvQ9XNu1 B0Vic/zcqc+Ccyf44qOZpAmxfLZ4BXf0i3PdL+fT6Y/x6GvL+HhBdxbOuN+pa7kCraBFqZA3cEgo VGqUGg1y163BY+/GkXuCg4/O4e7HXmbKrQMb6KKpcHCFUoUc6HH93Tz/zON0jnHqefOcpxj/zLts O+XL2zNnM/GWwagBpBxu6NSJVd8t4+IHk5wEvSyVZ56fgS28B/OXfMvARP9q1xGdHxvD5NkfMPfG cbxxa3cEQUBw6eRSfi4PTHqJG4b0JSzIC1NpGX6SlZWfvMQ3h+Ss/vUnRnao/UZ56kFu6NmFuW+9 wRMTBxHQzDlJT99wnnh9OQaD64MTHVgsVezf8h13jp/Az9+toOzhYRhd7e12CG3bhZc+eJtRvZKc TrHSs7ww+T5eX7qOFd+PotOk0Zw/sJl58+YjRvdnweLPuSY50NlB1UWmPXI3r381lxV9u/Hc3cNr 5ItCg0Iua6BHlVqNVqPGlWiSWyc/iyl9O/tn7+eFdz5mSPuoFuvRDTfc+O+ixVmYG8ko/j8eeRNZ vRsr89h4Ho2/3ywkNZnJvLkcOn+3+bdBjpd/UKbwpnTWeJZ6tx11ww03Qa9nIqDcVR5F42JX1dOE xWzl4w+3sTlPQCEDQSbDYFSTMqANM67/c8qenTpXxPq9RQwcmsJEFzmvDhNWqBTolM4xApizCtl/ vACTQsXZ0znMy8nF6nAaNKNWJN8kcDavhAtFldAIQa+eAB3lldgdEtjMlJaUEuBRm5E+Z/dG9p/O pssNbzCkc6t6k+f4KZOYOfc7Vi1fxat3DcKo9Wws32iNcTVbRUCktNyCZFC3wCDJGHnX0zXkHEDm HcegvknsWJ5GWi50jITKikKWLF6PX9xQXnSR8+oxOuQGPLVQeHkURP0hApB5Po2NWzPodfM0busX V2fBYOCa62+l9+KvOLRvB8fL7yepxYnua9+yosqMBJgqy5vUReNWzYFJiOLhSRNryDlAnx4p6PVa UkbewZ2jBqGuee8genQIYtXvZ8ivciABGVtW8Xu2ieumPkG/Nn519Kjm0alP8trcH1n21UpmjO+G rM6Yr73/LV6Zck3tWHz9sFbmsGjxOrQ+vck9tI4Pt1e63lPAbrMiKjVUXDjIvjy4NqBpI61QKlFU 5LP+u9UcOZbK2fOZFJaVU1yUT5koYLCWkAtOgi6J2ARI6jqE0b2San4XMs9oRtxwEwu/3MzJo8eA 0Rz9/RB7jxdy6ytjXeTcpUddKKNvHMN33//M7gOHyRw3nIg/EJFeZbYhIVJRVnZ1enTDDTf+qxBc CR/t5iJOpmU3+H3KFWp8g0II8NK3KJHmf3HkzvwjedlkZxfgExpOoL83MiDt4HZ2HMig84BBtG0V 5lw37N3MziPZ9Bo6hPiIwL+rthAEsJor2PrDMvKECMbfPKTJ0qiCICBZqzh7eDdbUgvoOWAECWGG v/g7umqnV1VQZXHgYfBApZD/Y2ptC4KAaDOTn3ORgkqRoOBQfD11IImYTVWYbCJ6vccVowrdcMON fyBBF4BggxJEyC4z1SPIgiDg66sjBBlKQaSssISNW3MRY8L+FOMEUFxiIrNCRd8QT3Suh1cvGETR lVzahYuFFvJKbZQVVLFqYyoaQaoh75IEGpWSAV0CCdIr/7jDIP0SpioLCQkJyJXqWsMogaBLJtZb z6HTWZhs9v+IkiwmU33zJjrQa/1BSgO70+DZTLmcyAav4SkENZCZiCi15El2yotyueDQ0j26FTLq J0c3GryJjm3F6bwiLp6zkNRW/V9eukBlZVX9D1ijQCaXYTKXU2kyYdDqa8ar9NQ6CbOrtu6x1CwQ ITm5LXYR5LI6egxsTysPOTtPnMeGRN2vxdPTo8Zx5aoyisOcw4lscPimM3f2HBz1nB8Cam0o1w7v gqejSSsNSBRlneCd6S+w4NufkHmGER8XiZ+3Nwa9HpVMhiTUOqOqZWC3Wur82zkqo68PkRFQXF5E PlCYX0AZIQSFBNf7/QIEBYYTGh7AxfP5FObZiYhUuGdCN9z4fw2RyqwdPPzIeygQqbJYa2YQpcaD 2MQODB46jFHXXYNBIfyluNLONV/x9rtfcdPU13jw9mtRATtWzGXCm1/z+udrawj65i/f5ZGPN/Lx d7/8jQm6E1Vlhbz58H3sUAzkpmYIOoBUVcLOJe8ycc5e3l+1729A0J1f1p4fFrJyRzb3P/Uo7aJD +CcV2rYUX+KH+W/y1cEKJj81jTEDkqCygG2rvuHnNCu33TGBDrE+7mnLDTfcBL0hd2iV4AM2B78d vYRIHDJXxmetTs1Tzw7lKRehO3vgKDETDzTh7RNacKWBucHmELELMhTKK3sQBUHAZrMTnxzOGw90 pJ2vgLUOKZIkCZlKSZCv7gpPbXqEoiQiSSBXNBZmJnOG/opiw3P6/1ETJyEJtaOXRAsmwEv175Et SRKRAJmicVnLZNUZ8cVauUmXCVJo9gGuZn/EGjeUrwzJ6Yyo1191WbLacVc7Kpp6t1o9Sg2e4nA4 Gn4ZMhEB8Gw9hFUrXsFcaa6XCU6SJOQKFcF+TS9RHKZStq2czxsLvmfAuCd54cm7aBcfg69RT+ml VB4a04eDNrHFknIVRUMOiC6PjEzWeP1Yp2Oi9pu9aj228Nfshhtu/AUgSVhLz7Fj+694xnZgdK92 OEQRUXRQUZzLL1/PYvGy73lrwdc8fWPXf+uX3dIQ3pZCLpejVKmQ1Tl+o9Lq8MCIRl3rSlXrPFDj hapOGcrmogFaHinQeAWYarm2PPy88X4aG4cgyDB4CngpPVqwGJCh1ulReHmhbmzN1MQYG33//+Ix h30/LuWjJYcZcMt4J0FvqY7+g2Ns6pto8P02I9MWfeeCDLlCiVKpQF59BrCykF1rl/LBVhMpfUe7 CbobbrgJeiOLfJmAb5sw+oQo2H4wi0UHS5jQycsV/laXhwgoZLIGxEkuucqE2e2Aumatr1IpnNm0 peYX/R5aFZ6SheLCyhoeUN2HWilzJohz9RHsoybEV8NvuSbkajWR4fpmjGxzJa+cbUSkBqQmJjwA jVbJmdPpOGxW0Kpq+7KdIbPYhDYyCI3yv7kTWZfiylCofQlVQMmFdByAvK7MNBpaFi2lwMPTn0BM FJw/XyOXap1XVJRyITMTz6B2+IdoXU8WkGFBtNsuY3ZqlAp5Q6eFDMCBIBP+jQVTc5S9gS+gBnHR wQgyOHXyNIrRres/sziV8+UOApKCUbbk4IE6iIQg2JWZgdU3grjQJr+6JuuRV5SWsmfbNvQhCUya 9hYDkmv3SaxWG6KrhF5jBLtmkeBaDJQVF5KVC738gvABvHx90JFHXk5eAz0WFOSQl5NHUHcfPH2U NWoRHCYckuMyPWqQyxvRoyABdlDI/xQ9uuGGG/9ZCIICEOhww318MfPhmuvmskusWzyTmybNYs5H X/H0jV1prPRE3WohDYlnrSGtcYjaTJSZ7BiNhnrJUyVRRJC1NHxXYuC4B+k+cgJqvY6rioOrM07J YaWsvBJJkGP0NDrnO1cUU1Pzcz3C5VofVJWXY7Y50OoNaNWKGjLW2Dn4mrKn5WWICg0Grco1D9eX Y83fiFZKyk3oDJ7oDXpkgnSFtVIjdkmuqJFbWVkFar0BtVyod3Th8ufaTJVUWCSMXh7Im3mfunpu LC/A5derq+bU76KW2BqNRmQYMBiNTdoQZ38iZSXloNRi1Kvqybw5O9Mc2W78vYR61yvLSrEhx2j0 qPl+68ql5thnVRlVVgmDlyeKOu2aG5vGN4xbn3yTG+0SWp1rzarT42k0YjAoMF4uk79cfgg33HDj v07Qqw2zUmfk+XsSuP6N33l+5i48p6QwtFMAekV945md6wy/tjucE5dCIeDrq8ZebuHwqRzoEeuc yKxWdu3L5OA5C4rA5ulWWKCBzpEy9h/NZmtmPP0jnHXIzeUV7D6ezyWTgNxF8LRh3vRuH8SST0/x 4TdHCJrQjk6RzgnPbrFy8nQepwtEOiX6Ex3Y9GFbuZ8narWG46lHyS4qJzbEiGSz4FCoiezRj8So QHatW8SeOwczsltczeS7eeECfs8qZtgdQzDotfWozX8Tam0gA3oGMPfANhZvT+PuPq1cci9h95YN nC4EZajQPNMVIDQihv5d/dmwfT1rjjzAyHaBLqNgYdfWdexOq2TI0M4kuXaGtXoPjIKZ9IxTFAB+ ggA4OLXrF/b/noqg8q33GK3RgFZh5fiZsxQCvoDNagGZopFEc38eHEDygKHE+b3GLys+4dDtvUmJ 8nbp0cGKuXPJtErcN2Z4jZFtkvULAgqlH3fcNYJf3vqRKf+axVtTbiMhynnY3FpVzPHDhzl6JINR D9yDZxPdyWSgVCuwmEspLMgBXCzfVsGeX3/iSFoJigRZAz3ZbbbaxTBgK0rnx29XUqSMoUv3XgAk JCfRMUrJpo3r2HPrKLpHGpx6dJTw00/rSC3ScV3HJCJd6wCDpxEPcjh8KgMTvdAKAthNHNq8njPn shF8Y+t903ofT9QUs//YWUb0SEIDmM0WlColcpn77Jwbbvw1ISE5bPXJgjGYETeNRj1pFnarvWZu cVhNnNqziZ+O5jLo+jtpG157vKuqrJBfN6wky+LL6Ntuwl9Wa/eKs9NYu2YtB46epKjCSkBoDHHR YTjMlYTHd2Hk4G6UXjrH5p82cPR8fr15X65QIkPEP6otAwYMINJfy8VTB9m84xjt+g2mW9vYq/FI kHliOxs27yI1LZOi4jJEQYGPXyAJ7VIYOepaQry0CK5jcQJNOEOtl/hy0beczjhLXl4RVRY7HkZv ouIS6D9sFN0TQmrWA+Wn9/LZ2p10HjAGQ/kxft62kzPncxG0nrTt2IObx48lQCvUEH+nh6SItau+ Z/e+37lQVI7BO5iIsCDyzHJkHi3VqnNNZCrNY9f6X1m/5TcuFlZg9Aul76ChDBvcE10954rIpbQj rFm3nsPH0yk1ifiHRtK970AG9+uBj2uhl3vuBJs2bkQT3ZVrBvbCy7X+u5D6Gxt/3kVM9yH0SUms WUge3/EjP+/LpP91I2nfmNdacJbF3fLDctbvOYVIJYvnvs+B6GDsFjOxnQczckAKBp0KHJVs37SB bTv2kHY+D0HtQUxCEtcMH0WPxNAmnEX1dZd79FeWbtpHl2H30CvBq1702L5NX7PzRCmj73+Y6JoA Sxt7N67ml52/kZaZg1VQEBAYRlybBPoNGkJCeO2udtrBLazZuIXU9EwqzA78QqPo2r0vw4Zfg6+m +bFhqeD0/m3sOVfFoGHXE6UvZfPK5azecwpTkcSS+W9zfIsvlSYZnXv1Y8Sgbritqhtu/MMJuuDa eZXJBIaM6shLmSZmfZfGrVPLuWNoFIlheoxaGaYqGzn5Ffy27xyo5IT7apykQ60ktn0ogbJUlnx7 CH+hEh+ZSEZmEdsOZHMi10a4X90wYgmHQ8RiFXG4soxHx/gyZkQskz9P58k3tnNL7yBkNgvHzhSw ff8lTBYBUXQ1FtSMHN6G1LPFfLThBLefLWJoZ3+8NAIF+RXs2JeFLCSUWY97E93csbTA9vRLSWDb Fxt5+cXn6NU+mpysMu59+nG6xSfw5KR7ODppBlOffYbjo4cRFeBB3vljvPfWh3glDODRW6/FqHMt YJp5jN1mwbWvWt/Aig6Xo6M21brksANijfOjrjl22GzYzZaas+U6D0/GPzyFxbc8x7MP3kfWXddj UNg4d+YoW7ds55wJYuy2ZhYzziVKcHQCdz04ia2Pv8GUifdyduJNBBrkpB/dxZIly/FoO5K7b7+Z 6tPncUlt6doliFUrPuMJD4murXzIzjjB/n172LXnNGJk91pdAe1SetA2yZ/vF85GVpZFlKcDbWhH xt04ktiQpuug2+1WJMlaE7pdR0hYrRasNnvD0HS7DbDU/k1gN154/C4mTP2UyVOeZPzQ3vgbFWSe 2s/MN74ktscYHh17Te2ui2iv53yqq1y5QsGYh19h88E8lsx+grwTO+nTJQG9SiDvQjp7d+3lYnkg 1z1wT5PvpDd603vQcN5ZPoNZL0yifNw1qBxm0lOPsmXrZk4WOEh02BHr+Aawwr4tK3nmVQWtgn0R bFXs37qGlet3M/DW5xg7rBsAbboM4K4Jt/PU20t5/MGHuPvmoXipRY7tXs9nSzaRNHwCNw7pWzMB dO7di4TIr/hq7nsoyrNoHajlXOrv7Nu/j98zClB5i/Vk33PQUKIX/sC8t1+hJHU3XvJyfOIHMeGm Ifh6uuugu+HGXxNCTXWQapiKsvjuy+U4VH6Mu31U7fxprmDXijlMmbOHOa3H1hB0gLLCi3z21hQ2 FSXT6RYnQReA/HO/8/pzT7Pg+214hMUTG2jk+OFDfJNzkQs5BQy/fRojB3ejqjiXX39axfe709Cp lUgSqNQK8i+cI6eogvj+dxCf0p9If9i/fikPTp3LU7OWXR1BB37/9Vvmzv2WSsGXQH9vFDg4sH0d 8+d9zo4zr/HO07cR6KmrNn+NozKVt956jypBTVCAP1q1jMqTv7No/kes/HEHcz/7hM4RBmQCFO9f wxNPvkZij20YK05yqcyBp6eOgsxU5s9ZSGqpkjlTRruOZElI1mLmvv4sr777KWUeUSRGBSJZD7Ch wkx+voSHsWWufplMhqU4h+Vzp7Mo+yilNgVapYNzaRksXLGJ9z7+mHuHdaixbecOb2faM0+zelcq EfHJBBkV7PplLYu//IqHnnuVxyfejK9WwHQplXlvPENO7G1EJXYjJcxpMX75/gsmTp3L0PteISY+ kUgDgJ1v5r7Nq8vPsTghpXGC7sLO9T+w/9RFQGTzj6vYq1VjM1fSzxLEoF4dMejsrPzkHabOmEWp OoD46DAESwnLF83n27VbeGfWuwxsF+46ckeTO8tnf13OE09+xBTDCHoleNVZb0ms++IVXvn6DDHj nQRddNjZs/ojHnvqNTKs3nRMikXuMHNwxya+KDRz54zFzHp4KKLdxtGtX/PM829wLAcSEmLRKx2k HtrN4oVfMfHZV3jlidvRNOfnr8hn4+dv86/VuSz+oTeRCWb27trB3tQLWFGyZf1KDmxTUGHWYNb4 M2JQN/fU5YYb/2SCXhNW5DLkglrH1Kf6Et86gDU7L7J3TwYbqxwoFU6PrUqrIS4mhLdGBjGsn+sM kSCnddtoZk/uwMy155m9YD9anYqIKH9GDEuiX3YOeQovfFxOc5lWRVSMHwNK9IT7qJyD8vDgtnGd KDYJLNmRzRufXsBg0JKcHMzNI9pw/GQhCRG1IUBBUYG88GQ/WienselQHr/uzsTskPDwUBPfPoqh /WNpG6Gv944N39vAfY89g13nz8YdB1h6eCdyj9bcanUSvyF3T+E9m4pPF37N/PePoFTKqDSbiesx hvuefI5+CYHOsPIrhDZFtulC5wsS+svKWWl8w+mSkkJMNUkVQBMQSeeUrkQFelzmRJETEptEt57g p3HJUamh2/X38faLWcxdtprXX56KwdOXkJhEBtx4D8kH1mMOad2M88Dl8VUZ6T/mAd4vMzNnyWre mfESGpUCmygQmzKaRx6dxLDO4VTvl4QldePhp1+m5O3ZrF70Dt+iJCQsjpHXDycuIYkjBRr8PWuP HYR3HMhTU1/F+MVSDmxexQ6bSP8xoVzppHVIXDu6dAnA13BZLgGdHyldexLUOrxBHoSQ6LZ06aDD W1u7IL1lyqsUS0a+XPYD7739KyqFQJXFRtdR9/PQv6bSNrh2EarxiyAlJYWYYENDOQkyDBGdeX/u xyQt/Iptu/ez9tsj2CXw8PQnLuUa7uxfWx6tgYGWQKYx0vuGe5l+/Byfr/qJF/+1CU8fP0KiE+g/ 6m46Je+kyiuearqr9/SlU992pIle/LbuK1bkllJlMqHy8GXExOd57OH7iPJxhqML2gDG3fcUNknF wm838eb0nShkEg6Zlu7XT+SJJybRKdavRo8Jva9nytNZfPDJF3zx0esIMjXhMcncPPYWwsL2kOvZ GoOuVjZt+o5l2ov5fLViDb+sWY5NFBg5sesfzC3ghhtu/Hcgkb71e1568RJ2h4josJGXdYbN63+m 4/A7mDJhSD1vvVrrgdLTE7VCuIwQytF5eOJpN9QsIqxlOXy7YCZzvtnCtfc+z5MPjCHUW09VeSEb VnzOjNfno9M5DZZfdAKTX5zJ+BITMpmAUqOlLOsoH8x4kfUnrNx22zjaRTnneqVGhye6eufNW4o2 3W/gzdjhBIREExLgi1IuUVGQxfTHbufzd9/mtjEDGdoxFqE5hq6O4sW33ic8IoLw0GA8tEpMFSXs /e5dbnz8Yz79/k46TBqMTCFDptIgEwSyL6Qx8I57GDGgF0G+WnLSDvLkww8y9/VXefKR0USrQHQ4 +H3jQv716qeED7iLj5+9l9YRAWApJ/XoHqZNepTiFua1EQQBHJUUlFVy10PT6NOlLR5KK7+u/Zpp r3zEFwsWccuwDuiBqvx0vpgzg2+2ZzDxufd4dPw1eGtlnD+xh3dffZlZr7xEUHg0j4zuSlRyW3r1 6c3HuzI4m5FOSlg8lKdx4HAGAMeO/c6xk2eJ7BoNJcc5dSGX1v0GE98qusbONbYcuv/FNynOPs2s Nek8/uLr9OsYj2S14BUUhb+XlnN7lvLcC6/gSLiR959/lJ7tYsFSyt6Ny3hk0qtMeSGKTV+/SpCH huZSGirUWgRAq5ZfvtxBozMgyL1Quv7UZi5i1vPT2F+WyJof5pMSF4bMYSYzPZVDB/ZjD3J+jyWX jvLyv54nTdONhcum061dLDqFyPkTe5jz+jTmvDGDbv2HMKZTQDMKk6HWGTB4VqEQRJQBMdw18QEu XMhi2VErk59/heHdIqg0iwSFhbmtqhtu/NMJenXIUFpWGRkXy2qSggVGBnC9QklkeAmXCs2Umx3o 9GqC/fVEh3uSEO5ByYVCfjpXnZgKvGKDub6PRFqOCZlaSWLrADpGG8gwQLBNwcHdFzktkxBtDopV Ovokarh0Lo/NhXIcEqiUAm07hXODTMmFYhseRh2dkv0J1Ap46ZToJSubfrtYk9RLqZSTmBSM0VvP uVyTk6Dr1cRGeOHrIeP8+SIU4Z4YdMpGjJuTWId1uIYX32zPLWfOUmayY/AJolVMuHNylHtxy4PP k9J7KMdOnqawzIqXfyAdu/UhxkWgW3L29tp7XqLDKAhW1w9e8G4/mPc/iCcoqnWNBfHvch2zP+hI SGxEvbZypZJ+Yx8iqn8lcX61hE+h9eWB6e/RccB1pF3IQ671oU1ye9rHR5B6YBBVyoBmw6Sq5aAx BjLusVfpMnAkB49nUFplxzcojI6dUogM8qT2zJaEoDAw8MYJRLTpwP6jp7BJSqLjO9K9YxzF2Wc5 k1NFK5cnXZIkBJmewTc/QPuegzmbdQlRpiY0IorgAGMyBuZjAAAgAElEQVSzcut/62SiBltoE3lZ GERQB16YMROVd6gzLK7u39zwOFHdqkgIMDjfW5JAE8hDU9+mz5BRpJ457wztCw6lc/e+hHor6+nR u9NwPvggmaCYaBr7nQiCgG9sF56d0YW7zp8h61IBdgn0Rl9i4lpjUNHk2TEB53UP/yiefnsOPYZv 5XxOCWqjL4ntO5IYG8LZY/spkwxUV2sPje/AkzM/RWHwRWvP58CxNKrsMoIj40jp3AFfvbI26Zsk YQxuzcNT36bftfs4eiqTKhsEhEbTrWsK/p6a+npU+XDL/VNI6NKXY2fOgUJH6+RudEkK4eypk+SZ lUQHetfKR+nF+Iem0mvwaLLzikGpIzI6Fm+D2j2ruuHGXxgFaYf5ZnlW7VzhsONQayjJOs2nH33G gw9MJER39f1mpZ/km0UriOp+I2+8M52EmkqlsQgl5/li9jzsrnAgpdZITHxbYmr+upIlaz9mb0YF 4yZP5+Hbr0X/b8b0SqJI6w79aI2DjJPHOLj7V/IKCrGhxCJXgvkEGUUVWAANzSSS00Uzbkw0+Vnp pJ78nQvZlyitsuAot6OSweHDBxClQbgSrCBJEoNue44PX7u9tqOOKez+ZhavfnuMgzkQHQF2WxVL Zr1HhS6GNz6azaiEWhsY1yqapdMns11s2buKDgd4hHDXE28wdXyXWvPoqWLTsk85ffE0p83QUQOn jx7ku5WbSRk2mZenTSTQ9erBoRE8UVXInlsf4ccff+Tm0V3xN8SRmJyM/bsVnM7IgL7xnNm3g6MX y+jZvRO5BakcPHaMa7tGk338JGfP59Lhlo6EhvrWrCku90xLCASERBAT4o2AiuQOKXTr3Lpes2/m zSWtWM+nr0xn/KDEagtI5MOvcHDLj7y1ch4706cwql1I80fSrsJxJYpVnDldiS4qiM4pHQhyLScC gsJI6XUNNqsZyVZF6q/fs+pgDhNfvYEoL5HTJ446N6xkWlJ6dWP2t/NZ8/M2xnQa27InSxIgI7J1 PK1CfVCcqSKxQzfadwxpIDf3GXQ33PiHEvSayV5yZoEWBOd/K+wiBl8jAwI9kckEZC6C4nA4w9PL yq31/150JqTp0yOa/q6Mbna7iNUuEtsqkDgkrDYRu8PJ5oPCfQiT4WzjcO7BmS0SGr2WoQNaIXMR R5tNxCFBl44hiA4Rm73WelksdiwC+Ad6EhTsVZNExO4QqayyoVM3l8BNcJ5DkyTUBn/advJvZAJ1 ErNWySm0Sk5p3JBfYfaUJInINilEXjbpgoTaN4yePcPq9aX1j6Cnf0S9a5IkIZM5d9BDYqFu4hZn hlg1XfsPp+vlOwmde7Vgoq+VgyDIiWnbg5i2PRoxsLXJYJykW0Wr5G60Sq4fhuUf1gr/MBqMXxAE AsJiCAiLaYEMne8XEpdMSFwdfbiyngk6Pzp18WvQhyRJhES3JST6Mlm7dr+TU/qQnNKnST1KkoTG L5yefuGNjq26TfU58ODIOIIj4xp+N01ldHWNXxIEZGpP+g4b1aBJbHKXejLXe/nRoatfzaI3tm33 Zp7n0qNSR1JKP5JSuLIelR6079qP9l371WsaHd+WaBrXY0SrRCJaXf1vwQ033PjfIH7obXz+1G1Y bHanbbZayMs8zfeLP+LVJ56iVBnCB5NGXHWCsoK8LA5l2eg1ooeTnNfZPjVbLFx+Uqt2nrDw0xez eHHWMmKvuZ+pk+/AV0OzocstgSCTcfHYTr788ku+/3k35WYHarUKlVpD0aWLznE5RMRmSJsgCGDK 48tPP2X5d2s4nVOGVqNCrlSiFCtxiGAWG5ZXDQmLoW4COlEUCYmMBdkZKiqsgBKHNY/NO7Pxib/T Sc7rvLCpqsq5Pmph0ICEhFKtxd8vuJ5sZTIV/iGhHK+wYqoCNJCXncnpEiXjkjo4yXkdWxAeFU+X xABOZWSQninhHyHQJiGRaF05qafTAdi7dw8lQgDPPDaGNZ+8zc4dB8i5aySnTh3nQqWWse1a4cwh 28jOdh176DzOJ2GzWi97GxP7D5wD7w70jPdvYK+u6d+TD1YeYPfBS4xIDEah/DNsjYBC5cPoGzsx fcUabh0/gQGdE4mOiSE6OobkDh3xUmswlxVyaOd+QGLf+kU89Iu9ToI8qKoowsPLSJWp/OqHYLNh tzvrCNvqlFK9XG5uuOHGP5CgV0/q8ZGexEd6/r984abJQ9PeyZaQjT/Ups5xgiv1VX2t4b2r9Kpe caK/Qn+X/X1LiVjT479SX43sPldfuBo5NSHrlv59czr5o99Ei0lsC41z/f7+anp0ww03/vcQ8AqL pWPnyz12/enWPoQt7Ubyzbx5vD5pBOo6BVeEK5J1O1ZLBaVo0Xp51TyrOUpZPUEd+WUFz8+Yjbr1 IN586Qni/LT1k6j9UZRmMOu1abz/7UEG3zCW2wb2JCo0iICAYDYvfoFX56y7QhkQAQRYO+81Hnti NqF9RjH+nvEkxkbi6+OD0XKEoSMn18tQXw2Hw35ZdngJmaB0zsuuK6KthEtW0AUFt0BeV9Iqrk0T +2VzsIBMUNQxlzZMpios6NF7eVS7IWpErVVr8dB7Yq6wYCozA1riW7chqbU/J0+lk5p+hgP7ThIU 3Ztrxt7Kpb3fM3vrXk6fucDp1DMIvjHER1Y7tf+oCssprJDAzwd1tQO5zhi9jX7IFFCWV44kikAL ksu2wNmkUHrwwPT3MfnNZ/P2HXy4+TscMgW+IdH0G3wdD0+ZQrK3QH5ZJYJaR8rAUXQOkrDXyc0i CDLUHp5EJaW4pxo33HDjzyPo/4SFtZs8uOGGG2648c+EhOiw1/t3dW1uz/D2xGjgeEEOxUCwi2VJ gCiJLtLlylMjkyGvl0dFgUqlxYgJU3FRnb6dNlcmVyAX6lNKAbhwfBvTpk4nSx7Dh2++Qo/4AKp3 Xv9dS31m10a+27STDiOnMOuDV2gTVHv8Jn9vCCpB1rB85OWslzI+mvMlJT4dWP7BbAZ3qHPczKxC JZfR0lAD4bJ2glyHJ1BcVNRAF4JMhqzlXbfsmRKAEq1Oj5oKKovLatpU68lkMVFeWYLGU4PG6MwX 4BmXQGJSEjv3pfPjymWkFljpcE0n/ORyenXrzvwfPuPAr6s4euYCofEdCQ8Po45HoJkv0RXVVseJ 4RS6ET+DAFkFWKqjF+uMsai8ANEOhgDjFcv1Veu3OlFtbfm2y79fp8yDE/rw1vvtOHToCOfPZZJx Np2Duzax4P3pZDsCWfvenYT5eSAptXQePJ6H+jZdq1yUpEadN835ECScpVUby5PUwFHvDnt3w43/ 13BXbnDDDTfccMONfwQuz+Jeu8BP27WWY2YwxCQRhJMk6NVK7FYruQXZLs7liqCxVZKTV45MVssO vHxCaeMHacd/I7WcejXRS/MvUlAJdZpTln2S916exm/Zap5/6wPG9k5oMKZ/B9l5JVjMNtp07EKQ X/3cGJdyirBKYgsc9sVkF9rAK5aebevngqnMSMcm/tGiqgIyVQDt2qgpO7ubg8XUqbcOCrGKogrp P0K+AkMiaONtI/XYQbId9fWUefYk+47lERUTRauI6pIlQSQlJ6MuPcGCL5dQrgmhS/sOAHTu25/k cANfz1vIhj2ZdOzSkYhQQ61/oxnItQpkFFFqF+p6RAANKZ1joPh3tp3IrSH71WPc9PMOzHjQs1MQ SkXzTzGolUjAhZzz9Wq/C4KZC9kldeQrIYomcgrNoPKkY7c+jB53G088+yJz5syivRq2//gzDoWe lP79oSKPJXPeIN/R8Jnleec5dT77qsg5gKCUodQqKDOZqLSa698TBARHBaeO7GX5ih84evocouAm 52648f8ZCrcI3HDDDTfccOOfAImCtONs27rFWZpSFDFVlpJ+/ADfLv2CYn0Yzz05ybkw0GiJ7NgR TCtYtWgWPSIexltp41zqYVat/Jqtx8uJSKn18YfHtmHMLcP515wVPDkpkttH9UJlL+fkob2s/3Ed uZKS6kIb1pIsFs15g/mr99L5+onEekr8tnsnVoeEJIqojb7ExMTgZ/zjJRsTElvh52Vk8/IFrIzX 0y0xDFNxPju3rOWLr7dhpb7DoHEEk9LGjyP7f2XmvK8Y0aMtKtHE6cO7+Xrx55TaxD88PqXSyO0T xvLdv5bwzBPTePaekfjo4EL6MVav/IZ9ueDt/eczsLi2nbhx7DW8smgJL05P4vE7h+Ovl3Hm8A7e mTmbUn0brhtxnTM5qWvnNjEhmSj9YrYcu8RNfcfTsZ2z3J08pDM9u7Vh08yllKrj6JQUi6/c+Z01 TdFdlUPatMEg38T8OXPRlF6Pt6wC0RhNv+4dGP/Qg3z2w628OW0aHubH6Z/SGtFUzPZ1S1jw/SHa jXya3jE+KASajaUP79IVT+Dnr2exopOWWH89BRcz2LR2Jcu3nkUQahPzWauyeOKul+hzy810bZ9I RLAfdnMpB7dvJ98G0e2SUQKteo3moWFLmbviXe7ROxg7vB/hgV5UleRz/OAeDp08R7cbJxEfGXJ1 ivEOIDgqDkf2JpYt/owA+fVYS4rxCYmie9f2yK35bFg5j+ff/4VnXn+NhNZR7h02N9xwE3Q33HDD DTfccONvS80dzsRTx75fwG17f0CUJJAkLBYrouQgLLEns559gImjO7lWBzpie47iviHf8On6Bdye ugtfjUSlRSIgJJgwfygsLqM6YF7nG8atDz5PWlYFXy2dyU8rPsHTQ0tgZDzhIXEEnbmEw3Ve+Ozx 3Sz7ZjGVVji05XueOPwTFptzO9JuNRPSYTAvv/QCw7vGYTNXUUIVZoutlkyZqqigDLO19prFVIGF Eqw254gCOg9l8v238/Rrc3l60hEiQvwwlVeg8YvG4OVM0W2yOZoRmASCiidemsaxB6cw/alHWd4q ApmtApNdSefOkYgcpazSVPMnotWMBFSabQ26s1RVgGjH6sqWJ1coGHL7v5i47TSfffEaqdtW4q0T KK80ExAeh58S8ktakGxMErGaKrGXlGC5zGEgig6qykspLSvH7op21/lFc9ekaaRnPcM37z3FrrWL CDbKSTt1miqZL09Mf4VxQ7tQl2bHJyYQEeQJxwpJ7NiRaEP1XTn9unchwGMp5YHRRIVVnz9vbnfX eaPXqPu5d+8ZPlk2j4d+WY5aAYPuepkOSfGEd7mJt14/w3PTZzLlkWMkxIYhmYo5sP8EiYNu4e1X H8Vfr3aNsfHjEBKgTxjEcw+M5Nl5a7j/3jTCvDWUlpTjF5VIdLie3JPF2KqT7IoCmQfX8/jWjbRq FUuIvw82cxln087g3W8cb7xwLwB631Y8/+6H6ILfZ8WPi9i19mu0WhWizYooyYjt3JfbYyOvqDNz VTnlpWVYa3TmSZ9hN3P3z7tYtnQ2uzcsRSkYuXvyU/Ts2h5EE+fTT1BZfp6MzEv/7ukHN9xw4+9I 0Fuahfmvlq256Rrnf+za32LRdVXvIl2WuAYkUQLZXztDaGPnr/45mcIb6uzyDOxNycgNN9xww8mJ ZHhED2bWrPeRCRI2u6OGLMkUSnwDgklIbk+XtnH15levwHhemj2fxFU/cio9E7TetO3YnR5d2lN2 bi9nyzyIrNkxlRGW1JPXZ8/nmpt2cTGvGLnGSLvuvREzf+PRHduQaZ07lj6R7Zky/UPGFogg2bE7 asPNRbsNQ3AsscHOso4pw29lnqEd7frVJt7qecNEPgnpT7eebWuu9R8/mY/jb6RfR1fJLpmR2yf9 i4BW7di253dKTRKBETH0GjCcEGU2e/en0yU5ElUzPFICkobdzQfzfdn06y6ysovQ+wXTtmM3RgxM YGjfjehbd0XhOs/s03UUH34YSHKfNvW7EmQMuHUKHybdQO9QRY1O9CHJvPb+R3QauIFjZ86Cyof4 dh3p1as7hYc2kCVGXnEXRdB60e3myXyUnEffdn717hkDIpg49R2GWY3E6WtfLLJtH978cD79NvzE 4RPplFY5SOkznK69BzGgdxd8tPVtrCK4NQ88+yYdbjYxZHCPWv+FAIl9RjNzvieVuig6xoXU5eDN 2nRtaDJPvfgmPYbsJzO3BEmmol33fhh1SkDBDfc9SUBMW7bv2kva+XwEtY6Rt05iwNBr6dom5Mrr AEkCwcgj098hoH1/Dh07iUlUE9M6mf7XDEVTfJCdR4vo4IzIR6ULY9aSpew7fJS0s+cpLC1H55HA iJvupdeAgfRqF+GqWiMjNLEPM96LYdjYfWSczaKsyoJSrSM4LIr4xISaOvBN6szDn2H3PIPXQBM9 Enxrrke17cH0OZ8xcMdv5BVXINf40LVXb6c4VSGMu28q/m3P0mvgwJakxnPDDTf+zmb7pofekzIr fdm76M56N0TRQdrRXWQWWGvO0jgnJzmevkEktmuD9i9IDGzlhZxMTaVU1JPYpjW+njrE3NPMW/gl hR5J3DluFBH+OhzZx5n92WKsgV25c+xwgn20f1slSnYr5/eu5s2lOxh522Su7RnTbPvCixl8/s6b WGOH8vykMX+Pl7RbyCsoQtB44G30QCH7Z1HR0sJLHDlwBH1QJO3atUEBWM0mikuKUWiN+Hp6NB9V 6IYbbvztsX//fmJjY5G5kmNVVlbWkJQZH60h1dIB6cI6xo8Zwf1ju/8h593lpRSrUV5WjEylR69R NeJEdJYLbYosrZz1GHdPW86kdxby5kPDWvy+oijWvGvNu9CIc/IK1yxVFVjsAkajvlEid7nDs14/ 1bJzWCkrq0Lr6YVS1rTcWnK9sTFXlpeAUo9eo2xkfI3vSDfnoG94r7Yka93rNnMllRYRo6ehJmS6 7ns35SCvKXX6RzY7mpF5wz4clJVWIihUGPSaxnVzhW8ZoKqiBBsqPD10jX6/dYdiM1dSYbKg1nig 06rq6aG57/zP/B6a/A5b8F244YYbf30cPXqUsLCwGhtns9mwuspOnj17tmnnrMNu47sFL7Do53xM 5SXYJOfkIAgyDN4BJHfuwdi7H2FsvzZ/TkmUPwkVWceYM2Mqh6xxvPfGdPp0iEQszuT7xfNI97uO YUOHEuGvQyw8yzcLP6aiTRXXDhv0tyboiDYuHdnCvI8/xqfdTVck6GUFF/nqg0+p7Kv+2xB0R9ZB XnrxHTza3sjT991IgLf2H/VDzji6kydunUjsDZP47NMZeADnjuzk7RnvEjn4bl54dJybnLvhhhsN cLWRRnVLKdYlBgajdz2iV7eUV/X/ph7cxkfvf0lEtx7EhgUgc5g4uW8Ln3+xjJDOQxhzXR9XDy2b rmSXZeluablLoe6mgiCg1nmgvoyo1i3XKTQrC1d7uQqjt6pJotWUnFsyPgC9watxwnjF8TWtv8vu UD8Qy/lspUaPl+Zy0ie0TOZ/oPzold6poXzkGD2NjRDTlpW2rX5PnYdXE7pzyUWSkFzjUmr0eGv0 Ddq3pFTrv/M9XFVf7og5N9z4f40mCbokSWSlHSH1ZAX3vfoOSR4ORAnMVWWcPrqDJV/M4eiZC7Re /T3tff6NaaIJL+AfDWFWGfxo36UXHo4wfLxcE6xMjlbvgV6rqc06K1Og0+kRteo62TYbCSe+wjib kl3LPMP17jTw4jbato4RqTt5y5VqkOtRKa8c+CSTydEZ+D/2zjs+qqL929fZvtlN742EFNLovVfp oCIoduRRUOxdVFQUUVBARURQkSJFQamCdAHpVXoNJaQS0rOb7fP+salAAjw/n/L6nOsf+Ow5Z8o9 k5n5ztwzg9BrbzmNtc1W/7tczV2FmWxetxo/SxLPPOqoNd3/3jTWXl+ujfN2ZtNvhHdAKJ369COk aXLlH21B9iU2rlpLo4D2cksmIyPzbxL3tfWDEqbCK2z8eS7nf16MXqtCqXBfJ5bS5m5eev1lWkYa qH3X8H86/bWGwo31kfRfkr6/MO7/MtH3V6TxlgXxbU6EyMjIyPxHBLoEKNUaVHpvHnzxeboaq0RJ 5vkjSLn3MmfHZjbvyaRJ37DrBUn53ma3T1XNDsd9PySV4qbiUd6VHCS9J36eHjXCcrlAcQvHVQoh 8IhIZtRbEyob3NuTW1XpLCnMo9hkQW/wxs/HWKe7V22Cy2ouIr+wFIVKR1CQf7kHQtXMcM2G3x23 y1pCbqEF/+BAVOUuZG5BLq6zV3FeLmY0hPh7Y9Rr/onOr8qoZcX5mJwqAny9aq6cXOeK5iQn6yoq gzf+XroaKww3mqG/UcdXmztXXe56ai8vjAYPDEYvfH09bzB5UhVeWXEh+SU2AsKD0HLNKogk1SG2 rxkY1eKGVz39FY+cZcXkFJnxMHjj46l3f1P+ffUrYsBCTmY+CqMngV6e1d6ra1AmqJ/Sjk/ntiuf 6Xf/gXr7+GLQgdHT658W/jIyMjJ/FQ2adeGbZcu5fCUfs8WCpFTjGxBGcqPGJNQPrdaPybaSkZGR kZG5bYFeTRvgsNeU7mHRDUmoH4DYloWqfBVWkiQKrqTyyRtjsCcPZtJrQ6qJZCtnD6zj/c9X0fXh kTzRu1WlgHBYilm/eBbzlm4gLTsPoTYQHx9PkK8WqzKAh4aPom2SP1tXLeKLL3/AZfRw75MSAkmp QqNWYnH5MOThR3hoYAdE7jm++24WqUQzYthDxIUZb12wurL46tNprNu6n8LiEsqsdtQaPYHh0dz1 8Cge7NsanVpZp0u/JEnsXDmVmQu3cDk7F5PJgqRS4+UTQMvOfXnxxVEE6atE33ejh/N7UTIfvdqN H2Z8wx8Hz1BqceIXUo/+j7zIU3e3uk4oHtm0iGmzl3D6YjZWoSIoKIxw1RWU6ts4NkQCl8PKyeO/ M2PydP48m4lT0hDTsC2PPPEUPZtHIarFaynMZum8GSz+bRuZV0tRaDyIS2nBw8Mfp0+75HJzFLFi 3hwW/pHB40+NoFcL94FD2LKYN+MbdmcbGDViGI3qBwJgTz/ClOkzKQ3sxMhH7iEyQHNDe17ev5FP J03idGYx+o1zGHrPdgw6JaUWb8Z/OZ7mMeEogAv71jNjznz2HU2luMyBp08gbboN5MUXRhBiUCBJ dQ0OJSTJyuTnR3BQ2Ya5k59GqaialHEU/Mmo5yYT3vNB3n+sX+VXuWd38Pln37D7eCpFZhs6vZHg sCg69RjAyBGDqdjtZsk/z/TPv2Td9v3kF5tRaA1ExzfhvkceZ3CPpkiiLqdPifRTB5jx2Zf4tryH V0fexdGd63j7pbe4aIXCVd8yOHsnDrOJ0IRWPPb4k7RNCpFbNxkZmX8P5X2Fp28QnXoPqOs1eeJQ RkZGRkbmJtx0XVqSJHTVz9QQFnavXcgvG4/TpNcw7mlXdQKluTiXJXN+5Mff9l8Tip2ci4dYMH82 245erAzXVpLLL1+/w+Mvvsf6veeIjEkkLjKIyyf38v1XX7Jg8UrOZxYDClwuO5YyE2azGbPZRJnN QXHOZTYu+4nli5dxJr3AnbzibDauWMiCZRvJKrDcnjVsOezce4C0q2ZCo+Np3rI5DaKDOLZ1JaOf Hs78zScoc958gHHiwFZOXszAwz+cxs2b0ygpHlf+Kaa8/zZPvfctVkeVi/a2n+ewcMY4Bt39AHN/ 3YNLbcBTL1i/dCHvvfYMa44VlK/USrhcgqPrpvPIky/x7eLf0fqGEVMvFEvhZTbvOohKeYsCXZJQ S3Bq1y889ODTbDqUhsHbF3tRJj98PYGPJnzK8VxRGa8p9xLfTniFF977nGPZDpq1ak2DcA92rprD iBHPs2DdvvKAPclPO8Hi775g844jldFdPX2Yn+bO4OuPv2TnoVOVv6ce383s6V9zNC0LyaN2DwDh tGMyW3C6BA67hdLSEkqKiykuNeF0utzifNcSnnv+OaYu2oxHUH3atmmOvuw8n3/wJo89/R65Jptb hNd5OYmdtQt+YOGiTTivec9pSmP2wgUs216eL+HCnHWIEcNH8tVP6/Cql0j3bp2Jj/Th3MHNTHz/ I7LKZ7hKc07y7GMPM/Hb5RhCEunVpw9tG0ZxbscSXnzpFeZtOQ2SVHmAz43IyzjPj9/OY9Um99+W 027DXGbBKcBus1BcXExJSTEmcxkOl0tu2WRkZP59SLe+J1hGRkZGRkambupcQZcAe1kBL/XvT6Da hQDsVhMZF1PJtEcw/qnHCddSed+GJCnQa0Fx3SmvEkqVBhQGtJWrvC5OH9rEO+O+Rh/fmx++nEBK vUCUCsHVs/uY+tEYlpxSVZ7W3arbnUxv1AmXpECSlHgorSz7bjK7d+2nz2NP8MiQ7m45JCnQ6jzw EDqUitu1RjSjx36KSudJaEggBr0W4XKRvX8hnQc+yfzFq+nTMoYIf0OdwfR6aAxtHzAQGBiEj5cB JS5MRVd55YH2zPrqc86OfoQUPxUSoNXrQAWN+z/BIwN6EB0WgOQsY/fC8Tw0dgGzl6+nX8OhgMBh SmXMK+9yJNeP75fNpkvDKPQaBaX52WyZ8yEjp2685awKJ2i9vRnwxGju7NSCQD9PSjNP8O0nb/HF 5jX8tuMxUu5uCdjZv2054778hfg+/+CrCW8SHeiJy25mx4q5vPPeeD6f/j2NGjWhcZiGlCYtaeg/ m7OpZ8kFAoF9e/aTnXUVcLDrzxMMurMTQSo4dfwYV52BdGrViAgPt5i90SpyWPMejHk6nR37D+Hd aiAfv/UEkcEG7E4F4ZFhQD4ff/Axq4+W8dmMr7m7Wxt8DGpKC7KZ9d5TjF0wmZl9+vPqkNbo1Io6 DiiS0HkoQX2DvfmSEg9Ap3GfsOtyOjmwehErdpxg5MTVjHu8LQadBnNJIRlpFzlzMhUPFzgsxSz9 ZgJLdmQwacFS7uuYgrdRh8tmYt+WlTw34km+nDyToV2noJVqT5lCqUKvB53WHX/jDr14/uWnOf/M GzToPIivP38NUVyMSmfAPyBAbtlkZGRkZGRkZGRk/m4CvQKnw44dV/maogpvvyDyzl5g1qS3KS16 g9EPd7ntiF0lOezfsIpzFn/ef+oV7midUvksSG59RPoAACAASURBVNeIxOhQHMeulos2MHr5YfTy q3zn+LbFfPfDMmK73sd7b79EXKDHX2ANHxo18iE79TibVm7m1JlUsvOLsRdfpKjMwaWMi1gsFqAW gV7u5levQTMozWbjls0cO36Sy9k5mCwO/kwrAfMVLhQ7SPatcLUW4JHIW2NepoGx6nqVyMfuZ8TY BRw9faJcUDu5tHU5vx7P464XPmZ4/w5V8YYEYmoYB871t6jOBQ6gXmIXRj/3SKUbNvX86TugF1+s mMm5tItASxx5l9m9YS2F+hgeGTaKZvGR5S/7cOcjj3Ds4B+8/dM2tuw9ROO725CY0IBGKREcPnmG C2kOAusVsXPnDryb96VLQTZHd2zh1LnBBCX6c/h4KsqgeBLqh5en63p9KoRApdYQHRGCTq3EwyuQ mLh4wv2rrlsp2L+O9XtO0KLPaB64szfBXu4JIh8fX958/xW+XzaY739cyqgBTdCp9X/RITgC89Uc QIHZZCLI3103DQYjgSERNG3dHidQVJTDT3N+RB3ShQBRwPYtG3A4XShVKkrzzfh56zl4chtHzNDK Q7qleAEUKi0REWFoJfD0CaR+UBAEBdWwm7xaJSMjIyMjIyMjI/M3EugCUGo9eXHKd3T2seMUbnFn s5hIPbaLN198jikfFtG63Wa6x2pvK+LiwmKOHz2Nb1g9GjdvU1NU2O04nM5rxFrVIV/pR7fw9ouv kaNPYMrYsbSNC+AvuQTaksuMyZ/w3fyfuVTkIDQkhAB/P7w0VoRL4BSuOh2kK/Zr71kylXHT57Pr 6AUCgsMICvTDy9MLq0MBCGzOa8JReuJnVFX+JgmBwj8ML8BqdR8A4HK5OLD7AC6llg539KthL2G3 YbM7bi+vEqg1Rrc4rzyIToXGOxCFy4HN5g4v/2oBZ06fJyQqhgbJyRX6HiSQtGHEJjaG/F2kXUgH 2uAVn0BySiN+/e0EFzMu09h2nj3Hc2l638u09TrH6PGLOXbiHJ1j8zmVep7wxn2JiKjnDvcGh+9V iEyH0+107nI5cTjsQJVAP3H4NMUmK707dECrVtdIo6Z+JxICPNlw4DhWux34a65nk5QqmvR/gISP 5jH/02dI2zmbxKRkGjVuQtNmbejYogFKXFhKsjhw3kZpwEkmvDsau7PK/dzldJKf6yQgwoMyE3Cb c0zOajahFrvJyMjIyMjIyMjIyPxNBLp7oK8kMq4e0dccFJ2UEEP2zhWMmL6VdZt20z22S02lehPs TielZRbUah+0ev1NRUWFOC/JPM5nH7zG1hw9b04ax+CODao9/78ZY/WsSXw0fhIBHR9iwvv30ygm DKOnF36u0/Tvf4IrN9nbK0kSlrMbePndCezP9eaDcVNo2zgeXy9PjJ5ezH3/Xo6dP3KDdLpwlZ96 X/VIiZKqPAkEV4vNSAoFXt7ef4kIE8JVkfDK+z0lFDXitTucmCw2NFo1Wr2y4vWKdVw0Gh1qHFjN 5RMEUggpKUloFuzm4sU09l86SJFTS5MmTbkzyp+vv/yeHYdP0tY/gEtpxTS7I4XIcEPFnEHdsx/i xu8Um204neDh6YGkkK5JoxFPnQLy3Pu1b80wN7/GRZIkglO6MX/5MhYv+Zk/dh9kxYKdzJlpIzw2 hb6Dh/PFuKdBlFECRLboz7Sxj1BittaYJVEoJDw8vWngLTdGMjIyMjIyMjIyMrJAv7laodqZZpWr ti6XiuiICBBgKiqoUlEutzt2TdUsoVSpkKoJJJ1aRaCXgbIyM0V5V4GAqhV0pRKVSlVD6EuShMuU xZwvxjFzYzqPvD6RZ4d2QcFf4M4rKQArv67+ncvKBCa8+jIP9mpe7QUnBp2mzkO8Kti1cS37TmXx 4EczePqJO/Gs8lonLNB4G4kSNe86RyLQ0wPhclGYewUwVsu3hEql/JdUEINeQ5CPkdJ0E8V5pRBu pOrAcQulpYXY0WP0q1qZjk9sTIyfxJnDG8goOosuIoXk5AR0YeG0a1ifjXt3stwkkafxp2liLP6K CgVexwRNpUJXXPdeeIAnag1czczB5XCAVlUtjdlkFDuQwr1RK6Sb2hyXAIcDpyShrrQ9qNTqa2KV kBRaWna/m/jGrcm+kkd+Xh5p547x9cQP+P7rSXToP4R+9YKJksBSUkarth3qjPt2TzgW5VapskeV Deu6sk5GRuZ/h9quBq3RHtRypSQugVD81XdjX9/WiRtcxyrz/3edq73/EeVX59a4k/UmV43KyMjI /G9x26e4VzS6LnMms5b8hkKto2Hrtu7AFDqMarBdPUOJ++XKaDJOn0FUO2XcM8CPRm2aUXzpFL9v Wlsj7LLiAk6eOX+N6DTx6/yv+OjbTfR95GU+fuNRPBQ10/R/UOiAlVKzHZwe1IsIrPHUcfEcpSbT LS3R5xeVIgFBEVE1xDkIzqZe4ZbcC25UUEoFLTo2B6eVNWuW1si3pPEg43K6+975vxifsBAatm5G zrEj7N69nYpilQB7zjn2/bEJj6hYkhISK79JTIqnWeN6rJ4/nwWrztCkZRuahCkBb9p16oAlfS/z FixFFxhLg6h6lXM5daHx0iCpVVzOy0GpqlltG3dpR5CXJ2uXL6ak3NW/Io0X1i/mbG4RbTt2Rqe5 2V3xOjwNCsg9xmVHtUGpJHH52HGs1aSwy+UiI+0iAN4BYSQkN6Jdp64MHT6K1x/qhaUgi2Mns/D0 DqNfr3pc2L+Wd2Zvvj5KSxF7Nm+iFOm267FSo0atAVNZEWU1hLq7bmRfPMZPs6cyd8lqLuYUy+Jc RuZ/EEmSkISTojMr6dK1G337D2TKsgPu7VHlDa8ob39MxTmMfrAHXXr0Y9jzU3D95eKcciEucfHI Lia8NZqfVu8ovzFELqu/U50TV88xc8qHfDHvV3IKy6r1P27PsW/GPE3nFt1Yd/AsDrn8ZWRkZGpw 0xV0h93CylnzuejpdC8uWsvITjvHxvWr2bo/gy7DP+TBTu47l/UGH1q3C2fqlk288ObnDL2jEcWZ 59m0+hd++XUTCmNQVWevDaBZ54F0iJrDN5PGYM05ToukUDLPnuD3zZs4dOQcQcmdKkXHzl8XMmbs ZBzeDWgQ7c/2NauwWm3uNDok4ho2pmlK3D85mHABXrRqFM2SrcsZN2Eyjw/tT5BecHLf78xfuJg/ 0wqJTL75KnWnzm0xKL9h3ievEaMYSWKkP/lp5/hp4fes/f0Et3gu3/UdnkJJeJtB9I55l3U/Tea5 SC192yViKUjn919/ZvHKjei0xr++huhC6NjzTtrP/4UvJryDp8rMnZ0aY8k/z/yZU5m56gwDR73H gE4NqipVWDIpSQ2ZtXI2upgoWrVoSoU07tSpLdELl7LqWB59BjQnsl69ShFcJzEtSQj2ZfG6ebz7 cTDdW8aQfjaLu/4xjKTwrjz3UBee/fwXHn8ujJefuJ+EcC/O/vk7496eSL4iitEj7sSo15YPRmtb q1fRvksLFn23lxeefJsn7+2CylLI7k0rWPTLGmxS1cSAy+lg47xPmb23iEfvv4/mTZMJ9FJz/vge Zv/6B+gC6NQxAaVBxT/enMCvOx9k/AvDOPPHvdzRtQUGhYPUk4dY99sWVN6JrOje47aLJjQ4jJTE YBav/InX3guifbwPFqGjedtuNI0PIe30Pr7+9C0KQgcSFpNMdLCX3OLJyPwvIgS2oots27oFgGNX PHl80EK8yw8qlSQJ4bBw9vcFTFzknkhMLQj8lyYp89wR5k2fRgdRj6H9O8hl9HercnmXWLZwNqX1 h9C7a0eCfWqe/5Jx/gwHD/5JfmmZbCwZGRmZWxXoAoG5pADhsDHphcfRKN1uaUK4UKj1RMY15I3J cxj50CC8ynWLl38I/3jzIzYffYLZE15i+Td+uJyCBk1bMfiB/sz8bhWlFltlHLFNuzFp2te8+96H zJk2gTkKFYGRDejXvTMNIv1Yc8ZRfuVVLvt2redotgU4wuR3X0QpHO5Zf1yYzS6efOdTJn3wPEbh oLS4kEJRiqNi07HTTklRAYVqE85qvxUXFVBSasZZfnDX8FfHcOLCZb754Qu2r5iHFhsq7wgevr8b J0+ep6CwGNdN9qEHtR3KZ+/u4un3vuWlJ3dj1Kux2KDlHUPo0eYyy7ZmYKu2GdpUZIWCYlzXjaec FACakorOS0LnW5/JM7/hyrARTBv7Igv8fHA5bITHN+Xenu346petlFluflic0+mguBhKS8zXlbrd VoadEkrLqsopqU0/JkyZzFtvj+ONkQ/wRVgIdlMBJRY1/Z94i/dHj8JPTTU3NQPxCfXxAsISk0lp 2qQyLJ+GXWkaE86q7SdJSIwlOlhVnrs6OnpAIph3xo2l5M2xzPtsLPPVKpT6RNrccw9J4YEMHzOV YtdoPpo5jQd/W4C3QUN+djrKoOZ8PmcSdzSLRuXeD1HLSrI7lgdGT2b13iGsnf0Ru5bPBHsZ3hEp DHvqQcaNnU6R2VI+nyAREhzI6W3fMXL9CoID/dCqJEqLC3B6xTBx5if0iHcfZJfU4W7mL/uZ6V99 xZoVs1ixcDqSJKE1eFM/oRmDhwzmZtLZabdRVAZe1QYzYUmtGfX6u1x8ayxfffAyM9UamnYbzPiU TgCYSwo4d9pEXtklSsw2ubWTkfkfRpLcE8yNk+M5fug3pq84yZt3JZW7HoPZXMzsr6dBQBz1zBeR 1Opq/dGN3eSrP69oV2+6laZ8hlSllLCUmnC46g7vRs/qSkuFC31FO13bhIXbpZ9b21pUxyE37vS4 83WzcGqbHK6ep1u19a1uWbq5vW5t+9O1ZXyzMBUqBTaLGavNiUaru84Sz3wyi/vfLiM0Ohrlbdaz W96uVXkA7s3zWOFNciPX/JvlVUZGRuYv77OHjJoi0kz+7Jn7aI0HLpeTC6f2k5FnQ5SfFl3eeqFS a/H1DyQ8sh4+Huoa+8ec9jJOHznEwSOHySwso150Is0aJxPgpeLU6csExcQTH1a139zlsJF+4Szp OXnYnGD0DSJMbeKHT19j0m74fsEqBjbTkHkplVMXclArJJw1RLLA6YDwmDjiYiJRWYo5feYsJRhp EBeDl4caUVbIydNnsah8aRAbjVGvwmUu4PipMzj1QTSIicRDqwIEOZdTObh/H2dS09H6hpKYlEzj 5AjSzl3EpvOlUXw0eq26zs7DWpTDkcOH2H/oBFb0xCYlk5SUjM6ezcWMEhJbtcZfq0KS4OzBHWTb vGjTpiHqik5ACITLxL6dh5ACI2mVGF01PnDZOH30Tw7/eYjLBWbCo5JomBRPmJeC4xeyiIptSL2Q uuWexVTM6SN/4vSKpHlK/eqlTuHVLI6fTCOofhzxEYGVeXLayriUepKjx05w7mIWKqMfickpNE5J IjTAu3xQJCG5RykU52dx7sxZtAHRxNavh05ZNcbJuniG1Iu5RCcnERHkd/MT/iqeOy1cunCejOyr 2Bwu1FofGjZJxMtDhwSU5GVy5vRJjhw9SU6hlZDoGBomJpOS0gC9SqpKo1RXNC4unTrGwT8PcDYj l4CQGJo0akhCTCBHD51AHxpD07hwhBCYC3NJPX+BSxfOcS4tHZtDSVhUA1KSE4hPaICnRqqWNRdX Mi6RmZ1LcakZFxJavQH/gCCCgoLwMerq3IZvKrzK6RMn0QRE0bBBvUqb2MpKSLuQSvbVIuwu8AkI IaZ+fbwNGorzsjh37gwOTQBxsTH4eenlFk9G5v9j9u/fT2xsLAqFe1bcZDJVttEffrWKU9amiPTV PDC4HyPvbVutaXdw9eBMAls9x9Bn36d4/Sec8B/CiZ2z3ZdHOG2c2zqXdnc9S7/XP+P4x8+Q2+hx Luz5DkW19tlWmMGSxYs5fDodh9JA49bt6devD0Ee1wuczNP7WL5qA6npV1AYvKkfm0S7du1olhRF zuVUvpv4Hp/PWEhSn0d45olBOE2leAbWo3nz5oQHGG8qEi+d2s/6DZs5eykThc6XBinN6NurG6H+ npXvma+k8ttv69hzJBWH0oOEJm24b0h/fLU1+4Oj21ZzNFPB4Pv7knNsO6vWbuHSlVJC45sx7NGh +GkBcw7LflnBwROpONVGWva4h3u6pNToovauWUxqWRAPDO7KiR2r+XXzHvLMLmIat2f4A/3QAI68 8yxavJITFzPReAXTqc9g7mgRfb1ALLvKkp8WcfD4JcpcWpKbt6TfwLuI8FJUu8HFQvrJA+xKLaRN 5574W1NZtGQF5zIK8A6LpXffgbRICL0lQVtWnMuRg7vZ9+cpMjKzKLMKfAKCadauK907tcVTe30Z p589xLp1Gzl9MQNJ60N8clP69+2Jj2Tij59n8vzYydhC2vP0Y4OJCjZgtqjo3Ksb9UP8Obt/K0cv mWjfrSMhfl7VxgGCXRuXsWX7AbLyrQTVq0/vu++jVVxgzXFW5mlW/XGQqOZ9aBUl8evSn9l3NBWb yoPmHQdwb89m1wlvUZLBzz+v5M8TqZS6JMLrxdKwUXN6dG2NVuHugIXLydUzB1l3MBVDQDyDerWQ Gx4ZGZm/nKNHjxIREVHZn9vtdmw292LahQsXYMioKaL1o3NFdVwul7hVXC6XcFX8W+0zp90qTGVl wlXLN0II4XTeOJ6MIxtEh0ijaNb7MZFqE+I2EnNdfDfKS22/Vf7qcgqL2Sxsdletea7LHhVYy8yi zGKt7c3rw3G5as2D65rfXQ6rMN/EvrcSZ2W415RfZTiua79xiTKzWVhs9lrDvT5+Vy1h3Tjef8bm 1Z/bbVZhMpmF42b2rqsOOO3CZDYJu/NW0uIUZWUmYTabRfUqXZXnW/87uuUyc7luuR7+M3/XMjIy /33s27dP5Ofni8LCQlFYWCgyMjJEenq6yMjIEKPemiG6vbJbdB36jpi5eNc1TZRd5O6bJkAhHn// B/H7tBEChY/4fO1ZIYQQ5pI88c6QxsK/cX9x5PyforESEdn6cVHZ/Lns4tzuVaJbk/rC06AT4VFx IrpemDB6eIpOA4eLDcevVLUzlgLx29yPRYPwAOEbECIaN28m4mIihV6jFontB4qVe06KzT9OE6Hl d3OoNBrh6eUldBqVaNpjqFi7/1Kt/bubErHg83dEo/rBwuDtJ6Lqx4mIAH9h0OlFfO/HxK7jF4UQ QpxY/4O4q1NjYTAaRb3oGBEdGiAMXj6iSZehYveZrBrt7eRhXURUdCvxxMODREJUkNDqdQIQWqOP 6DR0tFj90zRxR6sk4aHVCL1OJUAhAsOjxeRlB4TDUdVJvNItWoTGdhHPDr9LhPobhVrnDsczIFwM HDlerF30qWgeFy40KpXQaVUC1CK2YUsx74+L5a29e/yRc2Kr6Ns6QXgZtCK0XpyIrR8pjHoP0aLr PWLZgfSqYi2+In6dOEoE14sXg4YOF03qBwqNSilUaoVAoRFNewwWi3ZeqGm+Wji+a6no28pfSGoP ERIRJWJjooW/j6fw9PQV970wXhzLLK32dqlYMv0D0SQ2RBi8fEW96FgRGRggDDq9SBwwUsye+rHo 1yZJAEJSqYXBaBRenh4CRaRYtHm/EEKImS8OEqEhzcSGQ6ergjVnirdHDhHhfnrhHxwp4uPjhJeH ToREJIr3520WNntVr56/6RsRXz9SDLj/KdG1eYIw6rTCQ6cSgAgMixYvfbtRCGdV2eQcWyt6tUoU RoO3SGrcRDRunCS8DTrhExQhnv98RZVNbRax++vRwjsgVDTsP0ZudGRkZP4lHDlypEZ/npubKzIy MkRGRobYvn27UN3YFe7WnXkq373GvU2h0uChurH7VMX/S7IvMPuzj1l5spQunVoT7KMnN+00v/78 I0fL/Hn9/keIUdflGHZdYmq9R/vWfqs4XVZRefVbXemvzR4V72t0+uvc7qoflCJdn9jyJ7WntyJs Samh/Naz20jf9XFWL7/a4q3pdiehu4Ftqod7ffxVz6VbKLPbrZPXulaq1BpUaupM403DUajw0Kvq tG/V7wp01U5SrIrvxuV5e/mro8xuMzz5kDgZGRmlUkub+16g7fjvmPbxFJ7tPZ2Ckxv5Zs1pHp78 JVFGrruSMjf9DK+NGsmey3rem7GcO1tG4bSWsHP9z7z19id8oNITt/AronVw7tg+Pnl/PK7wbiyY +iGxvlocditppw6w7eAZSotKGTBoGOPGneOdsV/QdMgzjB09HFdpCTpPf6Kig2+8eo67r1gz50vG jBmPvukgZnzxDM3jQhBOK2f2rmfG7+ex2h2IzP28M/5j1pyUGDf5e/p2aIhG6WL/ium8NO57nnqj Psu+foPoYB8AivNyybp4gpVKJyOe+5je7RviqbYx5fWR/LTiKx7ZpKflHYOZN/ZLooJ9yTv5G/c/ Oobx479meN+v8FW6T1kpyMkgK/Uiv3l155WJc+jYuB4u81XGPTuMVXMmsn+NDx36P8pH9/fH30PJ 2Z2Leeilz5jw6Swe6fgBEmAqzub1kcNZf6SUMV8u4b72sQiHhWO71/LyC2/z7ssqElf9RKInIFxY iwvISTvLNknLI4+N5otenTEqStn0yyxGT5rPvMhGDGn3Hiqp7nGUT3ACz7w1lZcDYgj29UKjViPZ Cpg3dTyTv5lGSkoTUkb0B2DDwm946833UST1Z9qkF2iTEIrLaePcgY1883sqvskd+XxsIJmjXscS 0ZP3XnmcuHAvLHYlCSkJ7vFfQS5Z2VmU2aq25X099lWmfPMLfZ/7kOcf7EOQtx5T7hleHfkkE5// B0kJf3B3ywjUCnBZSsnOyuLs0p8YcN9DzP1gEJHB3hRd2MnjjzzP9Hfe57kHuhDtoUCSHEx+83nW HzYzY8kyOsaHoMBFacEVdm5YziVXtX3wwoX5aiZFV7MoTc2UGwwZGZn/DDdaQf93UZpzSUx99RFh 0GmFwn1SjdB6eInG7fuLL+avE0VWp7zyJyMjIyMj8xetoI8Yv0QIYRVLxt4n0ASKL5cfFV+M7CaM 0d1Euk2I3LR9IkVRbQXdViy2//COQKETD771bY1gbXmp4rPn+gi8o8QnS/cKIYTYsXqW8ATR/8nJ 16yA20VB/lVRUGwWQgixa+kMEaOWxGOvT7vBYnktfX7eYfHEgOZCG95CzP11d81vbCZxOTNLOIUQ Syc/JXwkxDOT5ourNbzwLGLMw22FUvISc7YdFRX+bWMHJgsU4eKH9TtEkaVqlfb4gveFlwbR8f53 xKmL2dXCsYrhbQIE1BdHC8yVq/FPNNQJPJuIP05dEGZbVR5+n/ykAMQ9L0wXVwpKqhaM89NEn2iF 8AhsL3KEEMJhEafWTBEKJNH3mSmiup+aoyRbzB87VKD2FaPnbnEXa1G2+PntoQJDsBjzzQZhtlZl 9tzBDaJLnFI0aD9QHLHevG45HNV8zmwmcfbkUbFv3x4x+b1Rwl+DePj1KaJQCCEKjolnB7cV6pDG 4pul268pYrNIz8wSJocQ4uwm0a1hmGh51yviTEbpdfFNfqyzgHCxas9x9w+Xt4gWsf4irO1QcfBs Vo13z62dLHy0CtHlmUkiv6RMCCHE1TWfCaNGEn1GTRGp6bnVPCIcYvTQFAEKsfCMqdyr7Ypo44WQ wvqKa50yy4rzRPbVwqo8OB0iP/W4WLX6N7Fx10m50ZGRkfmPrKAr/pOTA3r/UB5+bQJ79+9j/4H9 7Nu7j907t7Ns0bc8MaQ7XhqFfHezjIyMjIzMX4UA0NB12Gs0NuYy7s2RzFhxkAeefI1wNThdVcvn EmApNbF/+z5U3sF07n6XO4jyfb1qv0ja9OyPuiibXTv+BMDPJ4SUANiwbCbPvjOJtZu3k5VfCpIK H19/fDzdHlgOhwOB+0aMa6mtz794/AwnT10guU0Pmjap2mMshEBSexARGoIC2L3rBIWKBnRv3RT/ ci88d5q19OjSAx91Mbv2Xqa08pxUFyi8aRAfg5e26raW6NhIlCol/qERRIb4V8u7hqgYf6CEElv1 a0IFqPxISohGr5bKD9YVxDaIAiSCIqII9KnaX6/Q+xFV3xtXWRGlgNNmZ+/W3bg0XnTrdS+qarZW Gv1p0+8ejPYCtm3eV1WcQqDS6omIaoBeo64oYIzeQURHRGK1migx1VEdKsKXHOxdu4B7+3QmOjqO th06071bD96e+B15NnAJB04g8/Q5Tpw4R2KLrjRv3rJmGaj0hIeG4KEEp93u/t3lxG6337RaHttz kPScfNp2HURkSGCNtMX2HkLDIG92rN+F2WKtkfbgyAQigv0rz+8BJQlxSYCLwqKKw1F9aJESjMjc wqDhrzB/yUqOn7sMgM7Tj2B/76o8KJT4xiQzoF8ferRNrDxQUEZGRubfieo/FbEQAoVSjW9QGL5B YbV3HLI4l5GRkZGR+SsVOj4hCbz8+AAe+/RX7JGdeP35vtWeVgl0u91JZm4eHnoNofUCKwW0u3tW o/cJwRsr+VcKAGjQvAMfTp3C6+9M4KsPX2POF954enlTL74JI555ieFDuqH8J1NeUFpMidlEWLA/ HkZNLWK+mNyCMggMwMegoUK3VbwWHByC3kNJbnY+druj2jBI4HA6aw6QVO4tRi6Xo/K2l4pwlOV7 +MQN7Ot0uRAKReUp8Wr3FSI4nfZqZeB+qNSrK39xuVxkXLmKWqMivH7wNbZWofEOwx/Iy86rLJ+K /Dkr016xtUpCrdK4x1F1KEy3/SysmT+Vp557B6tvHHc9OJJOLRsTEx3N+X0r+ODdj7A6XEhAYWkp xaZSAoP8MHppa51Qud2RW1ZuPjarIDw6CJVaeU3ewwj1VuNIu4rVWfPYf5fTWX5wsLKycDQqbflD V7ll1Yz5ZgEFL7/OojlT2PDjTLy9vfEJCKXnXY8y/v3n8VFVn2ip+dcij0JlZP5mveDt3DzyvybQ /9l9tDIyMjIyMjL/x85fa6DviNF0WnmChk+8RJzHjcWJQiGh12hxOl2YS2yAppoCE7gcVqwoUGvd okih86bzPU+yst0A0tMucvjgQXZt38KmLNkCmAAAIABJREFU3zfw0htXKXV9yov3dSgXjRLiNuSP TqVDq9JgKjFjtzgBZaWAqhpkadCplVBqw1F+h1v1GCwWK06nE41OhyTV7UQo1fXrbQ1PxDWfSDeO RAIPjRaXy4W52Aaoa9haOC2UAV467c3HT7ehlAvPHWfVooWU+DdlwmfTebR3CiqVGrVKiaHkCEa9 Alf5SrJOpUOr1mEuNWMrc4LvjcqgPMeCWy5fvUaLQgHmYhsup7jGzlbMFgFaHcpbGTtWDSIr0xLa sCtfzF3OmCtZHD90iP0HD7Bl7QpmfP4+F0xq1nw+yn0LjYyMzN9enNcl2P9bUMhFJSMjIyMj8z+G pCAgtjU/bdjMh0/2rVVWeui1NGlcH1NBIceO7qsazAA4irl6Zh8lSi/ikyIqv1NrPQiPjqdN5zsY 9uRzTJu7iM8+fAvN+V3s2r7HPfhQSkjChXA5b2kABZCYEEVUVBi7d+7gcublGmKsanClo0F8IMrS Q5y9Uoiz/KWKII8f3Ut+CSQ3CcPD+H8YAv0LtJxapaJ5s1ic5jIOHdxR09YuC4Und3EFLQmNom+a hNtJXn5hPpcy0olskEyr9i3Q63SoVe5VbLVahdLtAIADiImPoH50OPv27OFi2oVaysBdvijA4XTc kvBt0igKg1HPwUO7cdjKauY9cyenCk2EN4lBr1H9k0WjJDA0kuQmrRn04GO8PW4iP69dT3ttPr// vJzCckEvhMDlsGM2l2G12tyr+HJrISPz9+n6yg9xXrZsGcePH6+xki4LdBkZGRkZGZn/GEKAQqEm NDIKP08dtY1NJIMvDXsOpZ7IY9HXkzmY66oc0Fw8uot3P/6OoPpJ3HPXAMDJob3reWvMF2SVuldB tXoPDAYfPPWCYtRojJ4AGHx9CQiBPft3sf2ie5N0aXEBRSVlta5kSPU60KdHZ/QXNvL2+x+y9URG +ZMydq2axb1PvcbuU+ncd+8gYkN0TPjwMw5eKMB9G4ZE9uGVTF+0EVdkN+5IicCo+O8qDzQ6Eno+ TILBwpKvPuaPy5ZKW+RdOspr73yB3i+Shx8Y/JfG7W30ICjAjzMnjnP86OnK39NPbGPKZ9M5kG5D q3GvlBPWhl49u+GVvpV3PxjHpiNp5W9b2LtmDvePepWNB84ixUXh4+PLkT/Wsf/MRQBMBbmUmMtu mAbPVvfQvUk9Di3+grmbj1QT/BbeHTOR1Ktmhj36EEYPj9sdjiM503j6idfZezYXAJVGi5e3L5EB KgotgJcfFScDCIeNA3PGEZOQQocHPq4xASEjI/P34fDhw0ycOJFz5879V4p0lVxEMjIyMjIyf3dB 7gBc2K/ZS10pY6ptaLa5wFZ5/ZWC+intmTLpJe5/4TN6NU+gVbPG6Jz57Nq+k2JlGG9NncAdsVrA SV76WSaNf5Fv535BYoNkYiMDuJJ+mm1/7CG63d3849F7AGjYrC13DujPmBlL6Nt8K3qFlfot+vHB hx/Tu1XUDQWsJMGwl94lN6+I8TNn03vzL/h7GxBOO/nZV9C3uItnbQ7COg3nvWd38PxHc+nRdi+d 2zVFabnKwf37SC/25bP579MkrmrF32mzgUPCde3gTDixWpzY7E6uPSrM4bAB1hrf2G1WsNqvW3Gt 8BKwX7N/GgQOmxWr1Vr+jQK/yEZMnz6W/sPGMrBVIq1aNMNHZWLPzp1klWh54bOp3JXsWWkUl8OO 02qtcbhfxTN32DZcNxlz+ie2oP9dQ1j54seMHNKFyTHhYCklPacYrdaJCrDZqvL14NOjyc3N5/1p 8+nbfgWBPkaE005B9hU0Tfsx/HEJFAk8NLAzOw7M4B93d+UNHz15+R7M/W0J93dtgfM6+xmY8Nlk Tgx6lLcf6slPLdsSH+bJ6WMHOHQijS7Dx/FUv6Z4aBSVNrXawe5wXbdk7nK49/pX2cTOylmfsmDZ HCKiE2iaHIfLks/+3ds4Z/Nl8oQ3qwbDQmC+mklO+gVK/LPkhkNG5m9KbGwsRqORVatWMXDgQOLi 4qoOi/wvcHdXJrfqPbbI7sGIQU3k0pKRkZGRkfkvJTMzEz8/v8rBQ8Xp2JIksW3fGa46Q6D4LI2S 42mRElFDCAqHlatlHnTr3pPG8aG1xuFyOTAXl9CoQze6d2yCBCjUOuIatqZ356aYr2aSdjmTIouS dr0HM27CJB7u3RyVQgIUBIfWo22jGJwWM1dzM8nMzkFjCGXw8BcYN/YNWsUGIEmg0PvQtE1HWjeK x8fLi5ikpvTq05/ObZvi5aG+Ll2SJBBIKLXetOjcm7v6dCc2PBj/wBASGrfisefe4INXnqRJXBhK hYKkNj3o3KIBWAtJvZBOsQUad76HyVMnM6h7cwyaquVzU3EBnlGN6dunM74GXTUVbqXQoaVtp+60 TI5Cpaz6xlxSgGdAQ3oP6ImfRokkQUnBVYIatqdfr3ZoJanqEDd7GflOI12796RxXEiNSQdzaRFh sS3p3acrBgkUShWRCc0Z2KsNtoJsLqdnklfqoknHPrw/cSoj7m6HuiIdwoXNZkMVWJ/uXbsQHeRR oxxtdieRSS3o3KEtfppaJm4ACRUNGjWleUo9inIyKCiyEhSdwpMvv82zwwcTFexDk7ZdaZYShxZQ aL1o1rEXd/ftQYOIYPwCgklo1JJHn32Vca89TYsGESiVChq07ELHNk0I8vMlNCKWLr0G0K9nRwK8 DZSVFGEISqBXn24E+7gnHIxBsQwc2Bs/nYucjHTSMvPxjUjg2bcm8s6z9xPhb6is+y6bhVKFBx26 9qRJfDBKRdWA2moqQekVQo8+/Yn2USNJXvTs0QqtJCgtzuNy+iXKbCoatuvHxOlfMaRTEmpl1Qqa 01pGqTaILl260atjQ7nhkZH5G3L48GFatmyJv78/v//+O+Hh4fj4+FTrc/61Iv3KlSt4eXlVtWku V+Vhn4WFhUhDRk0RaSZ/9sx9tFqncaPZA1E+g133qXf/ipmHitPcpX9xPDL/KWrWrcoyRyo/Bff6 spbLX0ZG5n+N/fv3Exsbi0LhFmgmk6myLfzwq1WcsjZFpK/mgcH9GHlv2+oNJi6XnVKTBbVWj16r rkOgOzGXmkCpxmDQI1U7At3ltFNSUoLV5sDtvq7HYDCiUlTvpwUOuw2TyYzNbsflEiiVavQGAx56 7XWHiTlsVsosVgQSao0GrVaDopa2vXq/gMuJxWLB5nCCpECr06FVq2r0Dy6HDZPJRJnVDkhotHo8 PQ3lYk4ghDssq7kUqwM8jB6oFFUiXDhtlJotKNU69Fp1jT7HWlaK1S7wMBpRSu5wykqLsQslRqOH e59jeVrc4Vivs70QAmtZKTanhNFoRCFVHY4mXA5Kikuw2uy4kNBqdRiMRtRKqTJ/QrhwWK2U2Z3o 9B5oVIoa5Wi1lOEUEjoPAyqp1gEWojytDpuFkpJS7E4XSpUGg9GIRgllZWYklRadTouimt0QLixl ZVVloNWh1VxbBnbKLBacLvfNPXq9FqVCgbXMhNXuwsPggUqprHbUvqDMVIq5zILDKVCp1XgYPSv3 nlfm3eEuG5VWj06jqlE2dmsZZVY7OoMnagXueikclJaasVqtOJxOJIUKjVaHp6cRZbVxhhACp82C yWpHodTgWX3CRkZG5m/D7NmzSUxMpF27dqxevZpz584xePBgIiIiKl3d/5U64+jRo0RERFT253a7 HZvNfTXkhQsXbuziLkkSdpuFcU+145vfcvEObcaGA6uoJ4nKBl2SJFxWEzt/nED/F6cTGhHN8xMX 83S/2L88E5IkQVEGP839lvUXYNTTz9Ey3l+uXX8b3J39loVT+XbZQYa//gZ3tEqqUf7pW37ggRfG om38AN998grRob6y2WRkZGRuQoVwVig1eHlpaoica94s35euxOjlVUO8URmGGm8fvxvGUSFukCRU ai3ePtpa01PxriRJqDRaPDXaG75zw7FAxYSuQonOw4DuhuGXX+Wq0uDprcHzRqKU8lV5AVoPI9pr 7IUQSEoNnp6aG6Zdqzei1de0nd7ohf66OCQklRav8ivJrs2/zsOzPA9u4Qvu3yWFCi8f35vYT4Fa p0etu/6ZQqFE72Gskb4bDjbL8yqQUGl0+PpfL0gNRq8b2k2SFLdQBmoMRvV1z7V6Q6X9athcktAb PNEbPOvOu0qDp9eNy0at1aOuKpzy8FUYPb0wet5CndTq8S7//kYLRDIyMv//43K5sFgsAPTv3591 69axZs0aBgwYQFhY2H88fYq6OvWCqxnkZGdw5shmpnz7B+BuwCquzSgtzePzSZMpLszncnomxWb7 vy6llmJO7N3Kmg3byb5qkmvW35BLx/eycukqLmZevb6iqtTo9Hq0+ptfjSMjIyMjUyVqpRsK3eve vP738m+lmwiUiu9u5/rUut6tOxzpFr6t+x0kqdb3pGp5vvW012K72w7j5jasy363lb5r8yzdUmW6 Jfve7J3bsfn/Pe//93BlcS4j8/cU6E6nEyEEY8eO5csvv2TVqlUcOXKk0tX8P4mq9i4QFJISCKFj UwXzJk3krZGdCCpvqYS9jHO/z2X5sTKaNWvFqfOXqjVudczWutV/5cxyjf/XhVKJhBOnU0KpUt8g vNo7mJu5Q1ee2ldHQ3ztDOvNqOYVWGt8Nwunrriqnt3E1pXPucl7t2uvm3To15TrrdhNgcDhcqBQ Xl8tQ9rew4pNA0ChRqfV3GY9+yfyXs3tr1YbuM0vu9/LyMjIyMjIyMjI/H+CVqtl1qxZLF26lOjo aO6++27atGlDXFzcf8UYvs5T3AWg1njy6hvDuPu+D5k8bw8TH20DgMlUxNdffot/szt5tp8nIz47 f404lRBOKztXL+THX7dx+YqJ4OgE+t41iLu7NUdC1BB65oIMVi38gQ17j5JnchAcWo+W7TrRu9cd hOrK2LJmNVuPpmHOV7N0wUwu7PXDZJZo0aEz3do3qUVIVQk4S8Flfl2xjPXb9pBfYickIp5u/e6k d6fmGHUVgt/GllU/sXLN71zIKsU/IpqB9w+jX/sU1IoqcW7POM68VZsJadKPHskaFv+wgN/3HMap 9af3/SN44I4mKCTYv/ZHfl69mQu5JYRGN+Lpl1+iQaC+suBLz+3l+9U7adz9QdqHFTL9qznsP3Ue vX8Udw8bRf+W0YCDzT/OYvmmXeSUOohv1J6nX3yaMA/pGqEvOLB+EQuXbyY1swj/iBh69L2TB/t3 KHdHc9u5JC+b335aiDOyLfcNaMpv82ayautBSuxqWnXtw6MP3Ye/ru6JCPfvNs4d3c/q1Rs4c/ES OTkFKLUGohMacdc9g2nfJK5aGbu/sRZlsmblUtZu2UVesZ3g8Di69BnIXT1bcmrXNtbvPIoDG+uW LaLk0kGcZWbCk9vRq2tbvM2XWbZyA/p6LenZoQmeenVl2Wad3MmPS1aw+/B50PvQpF03Rv5jKAF6 ZXka3HnftngmB6548/Sz93Nmy1J+XLmB85mFBNZP5snnXiIlzFjDTVMCdi6fy/KNOziblY/RK4Ck hk3o0e9O2iSFV0582G0mfp31NekuI+37PkqLGA+55ZORkZGRkZGRkZH5L2Tbtm34+/sTGhpKq1at 2LZtGyUlJej1+v+OBA4ZNUW0fnSuuBabxSyeuzNEaD1SxMmiK+LuJL0IaDhIFAkhhMMiTq/7Qnhq DeK9+TvFL+/cJ9D7iwk/n6r8vuRqmnj3/vYCJGH0DRKNGiaLIG+tUHgEiPuf/ViYqsWVemizuLNZ iEClE1GJTUSHdi1EiJ9BAGLwyPfE6QunxbMDWovyOQOhUCqFWqUQ4CmeHTtdOMWNcbnc/57a8qPo 3ypOACIwvL5omJQgvHVaAYhRkxeJHLsQwpQmXn6ot/BQILwDI0TDRg2Fn1EjQC0eePsbkVNUVhlu 6R9zRWJkoGjRqZ+IC/UXkoTQ6lQCEJLSU7w7ba4Y1q+NMGgUQqHWCIWEQFII/4TeIrXIKsqTJTKW TRAGD73o2HOwiPTWCpCErjwco3eYmDjrR3FP+3ihAKFQa4UChKTWi6Quw9zlUB6StaxATH7iDqFQ KoTe0080btxQhPl5CEnrLXo99LoorGaTtBN7Rc9QhQiIbC56t4svt6daSCBQeYo+w94QV8Ut4EwX 0957SADCyy9EJCaniNioEKFXIdS+MWLct8uFvVoaz25fKu5ulyAAERAaLRomJQhfD50AxMvTZosn H35AeFcrX5VaLQDR6cE3xdmcMuE4skK0jAsSfUZ+KtKuVNWeTTPeEvFhPgKVXiQkNxRxEQFCoVCI 4MTuYndqbo268Xq3esLgmywG3dFceGiVQqFy2xRJITwjW4m9WRbhclWk2CzGDG0n9BqF8A6LFR07 dxSJ9UMEIDx9ksThquogTEXZYkAwwtMvRHy+OkfIyMjI/CvYt2+fyM/PF4WFhaKwsFBkZGSI9PR0 kZGRIUa9NUN0e2W36Dr0HTFz8S7ZWDIyMjIyMrXw559/igsXLgiTySQmTJggnnjiCXHkyJFqGtL1 L43/yJEjNfrz3NxckZGRITIyMsT27dtF3Zt5BYCE3hjIG6+M4OqJdXy2+Cguu4WZU2egT+rPC0Oa YbXX9NV3mPJZ9/14PvjpIP1GfMSFtDR279nLof07GT0okR+/+5K3P/8VAGdhGusXTmP1BR3vTl/J 2aN7Wbt+K6dOn+HXedPp1DAE7+gGTJo6jVfuaYt/fAfmrz5EcXEReXlpTHz9H7WunksSlJzfwdjx H7H6mIOPZizlxImj7N53gIuXTvL12MepF+CJVgVff/AmXy9Yx12vTmXvoT/Zs3svl84f56k7W/DT +KeZ9dshSsuvhRUuJ3a7nQN/bKHlkBc4eDKNnNwizmydRZQnfPTCY2y6rGfKos1kZ2VRXJTDW0Pa knd6Hd8uP46j/C5U4XRgsVjYvnM7g175gvPpuWRlXWHPLx/jKMrk3Wcf46SiEYu3HKYgN5usy6f4 R/sIzuxZxux1mYCE01bGzh8+5pVZW2g7+A1SL6ezc+cuDh0+xCePt2P9om94duyP/4+9846volj7 +Hd3T0056ZWEEEJNqKH3JoKIIiAK9q7YxYodKzasXLDXe8WC2LGACkjvNXQSUgjp/bTdnfePc9Ig geDVK/e++/voR3POnNmZZ2Zn5vfMUxpYNwg81TpFBfuh3QSWb95PZWUpGWt+ZGpPByuWfMtn324/ uWZHdzB22j2s2bKH7Kx9rF+3lp37c9j620JGJzt5/4NPWbmzGJCozlrLk08/yZebanj0lU/YtXsH a9Zv5FBmBm88cQORAQ4eeONfPHvHJGwE88J7X1NYVkZJSTHfvfEQKdE2vB4PLqcTt0ety0dbtP4z bnt6PoXB/fhp1WbWrV3Dtn1Z/PzmfahZK7jkxtkUllXVNdnr8eAq3cXmsmjmLviVI/lHKCst4KVr R1GZvZ6X5y9C13Uk4ND3r/Hs52sYfNWLHMjYxOLvFrN2cwYHti7jpgsGozTIuyqETmUpVJaW4vLo hlrSgAEDBgwYMGDAgIHTFF27diUpKYmAgABuuukmnn32WTp16lT3/d9u5n7CG/RzYoXFniYOCyEq C/eLEYkm0ar7BWLfxoUizGIT93+wUQhPhfjnvZMa3aDnZ+0U4zuYRFyH4WKns3G9ezYuEQPjEWlD LxDZQojqnAxxz+Q+IqRNH/HJquJGZVWvR7jdbt8f+TvFg9MGi6iOw8XXq7KOuyo/TtHh//ur1+4S MTLiqofniwJP4wIet1N4dCH0rN/EyB6JIrb/hWLNruxG1dTsWii6JIaKduNvFvtyfe2rXPaOSAyz iLE3vSKyCysblb9xYLyARLF8b7Zwa/WNOrrkFWEzISbc8bpweXx3yzmfPyFkEFfN/lrUuDx1N+uq p0yc1xohB/cSB6s9QvXXo6tusfWjmQJM4oZnvvK1pTRfXJQeIAIju4oN5Y1FkHdwqxjbXhbxnYaL vf7PsnasEYMciM4jbxA1DTVEarH4ev5tAlO4uOHVhSfV/Oi6Xtde4XWKfds3iR8Xfy8WffyqOGdY ZxHUbpD41y/bhRBCfP/mQyLehLj47pdEfhNj4HL75PHufdOEDYd4Y9Hy457n3PCZ6JLgECOvfFpk +W/QX7lltFBQxCvfrxc1x4z/w9O6CwgQn2zNFrWPvGNQtMDeTWzOOSo8DcZGzfpSBJskkXTBvcLj VYUQQvzwwg2+2/3XNxzTb024nE6hNniepqoie2+G2LN3nyipUg21pAEDBowbdAMGDBgwYOA0g67r J70d/6tvz//9G/QGF+mBjjjumXEVuVs/5Ywp92NpO4q7L01H9ajHla8uzWHdXpXotBGk2nw1CL8v clR0Iv16dSM/5yBbdgoC4qJI792L8sz13Dt9Io/NmcfSlRsprfGimMxYLJb6Rgj//wjR+IFNRSCV ALzs3JnJUT2J9K5pRJnrb5F9OVdtmCXI2LaPvLwCeqQPIyY6rq4MgL3zKLrERbN/9XbKKqobXpti sQZhs9SmrfF9HBETDAgsAXbMcn2jolpHI8kyTpfT3496WG3BvjyetTf/ip3ImCAQGtYAsz9nq0+b E9U6BtBxup2+W+HqXFZtqiE09Qx6ORrL2hESzaB+AygtzGTDelejZyomO3Z/nQJACcIR1QZZ9eB0 uk88H2p9v/ds4M6LzyIqLIwO3Xox5qxxTJx2C98sy0CxmlB1323y7oxD5Kmt6NG9KzFNjEFt3tRa IYpjBXQcJMDLunVZaI7+9G8bh11q3PchA0cRINewelUOHrdoMJOtBAYGYJKluk+U+I5ESTKuKmfd E/oNG4wdePneSUy/ZxaffPUjB/PLkPz5duWG/vWyTKt2HWnfLoXQAAVO2n4DBgwYMGDAgAEDBgz8 JyEdk2FDHMMpxWkS6LnF+aoki53+U2+nTzhk5x1h2q33EcrxXBlAdZVThkRovKMBofN9ZzGbCQ8P w+P2UFlaBnIEZ115Ny/PvBTnwVU8cueNjB7Sh7ioGEacfzMrdub9G92rocrphMAggoMa5yBtKPqy qiqcLg8RscFY7UrdAPr6FkJ4iAUqyo8z5ReNdQQAmBSpjig2+t4qnyCq+/GUzqRIPl3EMcRUsTYe Ms1dTgkQmhBynKwVk4nIyHBUr5eK0oqTkl5Jlk8cNdD/AEmC7C1Lufu6KcxZuJ4+E65lwbc/kXHg MM7iXTx47ThcFdW+/Lm4fWNgCyQ4yNbsGJz6tK2guMoLMQ4CrcpxfY+IjMBkgvLicnRdP+7la6yt UDAfM6KhPaeyeMGzdI+oYf5zjzJ14jg6JcWS2GkQc79cf1x0+vp/m34nDBgwYOCvOGQYGSMMGDBg wICBP76Xnujv056gg0RQWBIPPnAXvQeezR3XDG62pGINIghBRWG1/5f18KoaFZVVmMwmbIG+aNfB 0cnc9Ng7HMw5yq4Ny3nr5dmMH9yZ5Qvncu/MR9hWAZjqbzxFi6ldEEH2AKguo6rS2bgtDQh0kN2O 1WKmvLgGj0tv2GWghooqFQICMZvkFkjpPzyAliCCgYqjx8ta1zTKy6tQTAr2oMA/p83+ibtp3Sq+ WJ7FJbc+wpcfvcKUsSPp2DYRW3gIFrPivwX33VgH2QPBVU5VRU2zY9CQHp+c3wogkBCbAkXVdYqT hv2oqKhE0yHQEYQky6fed1lhyPl3sGpHNkcObGfRR29yx1UX4M5dw12XnMOC7VXGwdiAAQN/C0pK Sti7dy8HDx48XuHY3Kr5J5f7+yCavPE4nVrdVPv+kOwb9KupOv6usTqd2vK/jtN9rhswYOBvJ+ig WOyMv+1pVvzwPonm5ssFhCTQIxGKdi0jy0/qhJD8xKmATRs2EhkdT1o3a522QjGZCHCE0Sl9EFfe cg/vznuNu87rze6MXezdcQSsZhSzjFf14vV6jt/EmlyxFNK6tCVWzmXFph0c8dS2BX8aLYEGdOqc RHRMBFs2r6KstLBuEZQADq8g42ghcT07EBJkP+0G0ByYQO+OMuW7lrBHbSxrl6uCdWtXEhwSQ49e gX/iU2uoKC/BRTQJbZOx+MfQb4iPLNdqUnzKjk6pySSYjrJq81Zy3ceOAXi9un9+Kci48Gg6Jw61 pgM2evSIRSpdyZYj5XiOmWfr1vxKtQrp/RKwWP4YkZYVE1abjZjkNM6dejlPvPwmXzwxHVd1EWt+ 21A3d4WuU1aYT0FBIS63ZhB3AwYM/OWHdl3Xj7MOOhGhrV2XjmblM/sfq7hwxvececM3TL53KXfN 28gny3OoUqlPNXnawmc18PG83wjv+z5zl+T+mxZZf0ELJYnsnTk8/c5mFq0vauGe4BsjVdXYtf0I q3aVoEsSkqivU/OobF1zkKfe38ZvGeV/214jSRJaZi7Trl5Aj9tWsCHbbex7f5EySpIkyoqrWLvp CPuOVPvmusHQDRgwCPqxC4WsmLCYzUgn0OFFRMZy+eUXkL3jd2beOx/dx51wlh7m49eeYGlOGIPP mkYHBfIPZTBn1r384/PfUJGQJBkJqHZWkZWTTXBoGKHRMRAcSnSbNpQf2MjipT9RLaC86Ah5eUdQ m/JB9zdv7ITzGDWyGwueuZ/Hnn6NnFInkiTI2v47t08Zzsy5n1HTYSzjh/biyPL3mfvZTxQ7dd9m I8qY+fALbDxYzOUXTSM2Juq0G0B7gINrr72SiiPbuP2mZ/HzX1RnCQvnPsQXu2T6j78Kvy7kT0IA EVGxhHCU9at/57DT91BnaQ7zHp3FP979BnNgQN2B6Yxx4zlzTC++eHEWjzz+IoeLa5AkQfauVdw1 bRT3vfYR+UBC2zZEBnv41+eL2ZFTieYuIys7D5d2rMmJb3AvuuQyWkdZmXnHw2w7WOQ/OMDmr+fw 8sJNRPe5kjPahvFH+PmCF2dyz/PvUVTjmwuyrGC2KGTs2wcSxLdtV1fWWVXIRalxtGmfyvyfi4xV xYABA38pwsPD6dixIykpKS0g8z543fbIAAAgAElEQVRCq2kaH7/9C8mTv2Lm29tZvLmIQ7kV/LLs IC+8uYGpd3xPh8kL2eziv4JsaZqO26OhnaaJM7K2ZXH/3HV8vKqwxYoHgJpqJw89+A2THl7nVzzX l1DdXjas2MsD8zfx047yv5s7onp1vKow3Lr+QmUUwJa1B5h60ze8+HVWw48NGDDw/5WgC6E30KQ3 GYXNv04LaFDWEhzF+Bse4cbRrfj42enEJbZj+LCBpHZO4755v3HGhdfwzIMXAaAIjQMbfuGmKSOI iGzF4JFjGD18ID0HjeTz/YFcdMX1nNFOBiIZMepszuxs4+3HbyJYkQiNSuGJ+V80vVb5VYyWVv15 6pnnmDwknvmP3kJiRCCKotCm2xBe/nwFsmxGAu597CkuHpvOWzMvI61zKsOGDiQprjWz3/+Z0dfP 5obzBhBiadBjIZo0NRJCpzkjbV3X0Y/ZyXSa9lkWQhxXtuHOWCtrkzWQEdfM4r6Jqfzwxr3ExSYx YsQQUtu35bonvyD9zEuY9+wNjZ8pQNebaWMT5oNNYfCw0Vw5aQBLP3iGzrFhxMfHEhGdyJMfLEYJ i0HRtTopmON6M+upZ5k2qg1vPzmDpMggFEWhddogXljwK0KyYBEwcsLFnDGkN2sXPEv3xBBMtjAu uutlsotcmBTfTXXDtiUOv5YXZlyEtvdr+qa1p//gwfRKTaLfxDsptKXy/uuziItwNO54M33ThaCh SNTSPJ67+0qiQ4Lp1ncoZ599Fl2S47hu7s+kT5rJzWcnNJr/qgc8Hg+acVAxYMDAX4zS0tI6E/eT HvElEJrO9l+3cNFr+wjvEM/Sjy+m/JdL2f3lNApWXMXBBefy8EXtCMVDqff4vajp84Fock9qouAf InDNP7f+CCL9gd+f+vP+2KKeNqwTi54dzT3nJJ68roZnCeFTPqhNaB7MdgtnTurJoqdGcOng6Ja1 tRn5N2emfkq9lU4sz397O2ymjj/VwuMEzxDNnr9aLs8/430QQqBpotlz24nmrnEkMWDgvxNKap8x j5Z7A7h2Yvcmd/b2XQYybFhfbCdao2UT0clpDB86mKRon1+53RHFiAnT6NchgupqJ5U1Eu17DePO B5/i6YeuI8SvGggMi2Lg8JF0SYnHapaprChDtoQyZPzlPPXM01w7YUDdc6LapHHmORPo3rEtnbr2 4exJU5k8YSwJ0aFN7hy1Zn0hcSmcf/EVnDt6MJ06dCK970CmXH4DL776Dy4Y1csXATwghvPOn0y3 dvGoNZWUVeukdBvAPU+8yiPTzycm1N5ogZVDYuk/eDhd28VhaeCbLnRBYue+jBw5EIfV3Hj/skYx ZOgwundMRJZ9weSskYkMGz6cjgmhDW4tfJHGOvQczPBhfbA22BiQJKSAVowYMYzObWJ8m7bNwdBz L2FIWgwut4uyCo2kLv256e7HePXZO4k4xh3BareTPngEfXu0P2YxlwgJa8XQEUPo3Dqm2c0MScIa FseAocNoHxtIjVMjKi6ZydfczUvPzmLMwK7Etu7EsP69iA0PBsARk8zEqZcxccwwOnfsSM8+A5l8 2XW88MpcLhrbnwAJsEcxbsJ59O+RSsfULgw7YzyXTp1M1/atUCSBFBRF7wFD6NGpNTaLLzBc6uBz OXd4D4JtUFRcjT2yNRMuvpn3336RXinRKFJDBYmgTY+BjBzWC7vZ1NhfX9joO3Qog7q3R5Ykug4+ k+Hp7QkLDcblLKemRqN9z+HcfP9zvDbryuPeB0kWdB8yiqFDB9M60mKsLAYMGPjTkZeXR3h4OHa7 nYiICAIDA/1btcTy9Xsp0mKhYh9dU9vTK61eiahqGq++vYLVOTqznz6PC9IC/JZBEooiExoexLB+ bbhyXFvCbWYCTX4z99ogdEKnuLCCLRnF5FeqhIbYsChSPbnxl1NVlezcUjIOlZJd4ARFISTQ7A+e KeraelLC5K9P93o5lFnKrqxyVFkhOMCM4t9ut60/xDebyjjjzHb0S3FQUVrFzn1FlHrAEWTBJDfo w0nIT22wPU+Nk527i9mdW4U1wEqQTfH339+m5ojRsd8Jgd0RQKe2YcSHWRrLEvDUONm2t5ADedUI k4nQwPqzgtfjZdHCbRxWQrlranuUxhsNIeFBdEoOJSrYdFy04dqxKiupZNu+EipVmYgQS53869wX /G3RPF4ys0rYlV2FbDETYq/fF319k5oPbltWyee/ZlFodTBxaCLxQTp79hWxP99FQJCFAIuC1IDM Hhc1uTai6jGyE/5AtLXZYiQ0Du4vZkdWBYrNSrBdOa6upueU8FuPtGDsATSVffuL2HGoDKeuEBVi QaKpeeurU1O97DtQxIEjTgJCbASY5Eb9qp1TmqqRfbiEbYfK8aAQHtxwPOr7eSJk7T/Kot9y6JCe xPjeUU32AU0jJ6+U7ftLKanRCQq0YDXJdX0wXBAMGDi9UFBQgMPhqHs3dV1H03wxtcrKypDOnz5H HK6OYO37lzWvkTvBBnes5q42+nnDDbkp4u+jpzRaAJsuWnsIkJqt01emaW1u3cLUnCaxYd9OoG2s 3dia8s9rNlz/Cepuvp5jtKsnraOFsm6i3LFm442bLp10U2uJFruh3FoyBk3XWTtb/ry+n0yuJ5oL SBLSCeaksREaMGDgr8CGDRtISUlB9ge+rK6urltfn5j7DbvdPRA53zFt8jium9K/7ndej8pd9/yL 19aqzJ1/MTd0tx5PPBqseb6PJNA19u3M5pbZq/hxZwX4s4sEhQdz4xV9efKSdr7MH8LDrz9tZfTd 69HMSj35QqJrehJP3d6f8Wm+TCP60WIeeWE5b+fYeO767ngP7ufpTw+wN8vD1TcO4NWbu2H3uFjw xVYefHcXB466fUFiVYhJCOOBWwdy85kJfDz3F6a/l81tN3TDnZfP64uzKXcJ8OqkDU7lnZm96ds6 sHF6j2b2Mr2qglkvreKV73Moc/uztegSg0al8d4DfUkJMyOVFzP48m9YmS348O1JTO3mqEvXiaeS 8Zcu4rtcE9+9O5Gz2tvJ+mkjyfdv5Na7zuLlqYkgBN6aah6d/RtzFufiElKd0j02LpxZ9w3jojSF 9FEfsw9TfZt1QaDDzp23j2LWOdF8/97vjH8/hzmzxnH7iAj0yho+f3cll31VyJ2X9KRk227e+DUf XZFBNjFiREfmPTCQjiFy/V6sevj55wzueHUzO/NcIEtYAm3EOUwUlbi56OK+vHFzlxPORe1QLlNn LWevLYpzOwTww6/72ZBdAxKYQ4N5bMYQbjqrNcH+1DCPz/yah3918/3rZ3BW97AG2vFihl+wmIyI eJY/PoCO0fa6IVvx8zZueWUz2464fNNJl+mXGsK63SVcePlw3rq+fV0Wl2ZOK1xz/lu8XRRN7jcj +OCN9byxOJPMco1p1w7nn9d1QNdUvvx0PbfN20FOtd9qQZZJSonl1UeGc05n3yVDaVEFF0/9iLXB yfzj8kgeeGkrByp8cyU4IoTbbxrEY+cl1s034fWyavlups9Zz/ZcLyg+BUvXHq15+o4BnJ3mqOvn +uV7uOSuX+k+uR+PTorkiTnrWLS+gISurUiLtLL+lwPkodTPCbdKxz4pvHrXQEanBrPs5x3MnLuZ 1ZnVoMg+BYHJxPnn9+TJq7rQ3rg0MGDgtMP27dtJSEio28+9Xi8ejy/G2qFDh5rPqtVSktFUudqP TlaH1NJnNSBTzZaVTtK+lgSROUmZ2rpO1N7m23d83U2XPYHGt8k6Wijrk5Y7sab5VOXwR8fgRO3j r+p7U+06WVtbMicNGDBg4DSALEsM7RTHK8sO8vxLv9Jl5mAGdwiqc9VqrPis1XbrHNiVxeibfoZW 8bz19AB6tQ2iNL+EDxft4PnXV+Mxm3nxwiTQdQIC7Ywdm8roPtEkRdmRdZVNG3N5+6s93PeSRMST oxkQ7VsrTWaF/AO5zHisgAqPIC0lnEGR0CbMigWdeW+v4dZ5O2nfK5kXprcnLdJM5sFC3vh8Jysy iphyZgKKLOOQqnj85bW06RjL5VPTaRepsOSX/Xy9YhvPdIzgxas609rRDIGru3ms5uIZi/lqr5cb Lu3DxEGxBEkaK3/fzQPv72Di02aWPZJOeEgEnz4+kP7Tl3Ptfb/S86OzSY0wI0mCpx5bwnf7PDzz 3FmMbWdroPytVy1rumDOMz/w1OIyzp/Wh2uHxGDVVTbvOMI3vxxk6fZSruuXxK3XpjP3420cNoVw 32WdMHs1zDYz/bqGgqb7A7A2ViDLioT7SBlPzVtJ+5Qo7r95AGGSh6UrDvD9L/t4OM7BJ3d08+9V Gj/8uJNpD67E1jqOmbf1Jr2VlfwjZXzz6yGyMmtafBawWkxsW7GXjF3BjBmUxPPTwqnKK+L9nw4x 86nfSQgfxSWDYmpF0WyKFsHxaWvXL17HlGe2UWUN4b4betAzIZDCkkp+WrIXoZ+C6bYAPOUMn/IZ h6oU+nWOppOiExuogND57J2lTJ2fxTnndOfNcYnEBivs2ZXLk29v5qLbfuC3T6fQK9T3SshCpyQz myvmFDH+jDRuTAmk+EgJ7yzawyvzficmdhw39Q8BobJ29R7OunsFAW3ieP6RLnSLNrNlSzZzP9nF DbPcvDrrDM7rHFDXTLtZ59vvtrHiRxUREMjA9Hii4kLo1yWGjhaNeT9m07lXEpMGxaK5VKJahdMl KYgtv+/izhdXUxAWxwuPDaR/op38/HK++3E3O3LKyC52GQTdgIH/QpgMERgwYMCAAQP/mxCAYpIZ P60vk37J54utWQyZlkVgkJ1enaNIT40kPTWWswa3ItJWr3CsKKth/nvrqQ6P4/e3z6FjgP/GuWMU HZLDKL7zWxZ/v4eZFyYRrdjoN7gL3w5ubPZ97qA4Eh0qN3xaxKYdBQwYGVNPXD0Sw8d04elru9E2 rN4Pa/OqPbz3zV46DUvjjXsHMiDBTy4Gt+GqSank1UhEAJoQVLolrrhxCLOv6EyMzXcLccuISIbP WMYvm/LIP68NrR1BTQvG389vFqzn6x1OXplzDpf2jcAq+chfz67xeEsqmPH5Ltbd0oXRgSbiu3bg vdvyGf98BufP2siaOf3Y/PXvPPRDARdOH8WdIyKRm7ut16pZtKQIW+sOfHpneh2JH9Y/iduu7sOR AheYrFw+rRtLvt1KodnBPZd3p2F8V93parpuXUBQANOvH8jcqzvU1T1uQBxFt3xFxu589uvdaCdD zv4C3vtsO5Z2rfnHI6OY2KU+w0v3OBt7M1bi1VtGf71eldAOrfnw0cGM717vatgvOZBrX9jAv1YW MLBLNG1DTlGJrZdz/1t7OSqCWTH/LAYlB9X16bJOVhJu+f3U/LjdbvqN78eqq7sQaZfr3ozq/Bxu fTOTcRcP4esZqXVzt3uHSPokmOhw41r+8dVB3r68ra9ZAsISY1n+0dl0qVX86CrnpofS/9a1fLBo Nzf170dhfiVvfLQZc0IM858Zx3ntfaM4elAi/TuFMG7GKuYt2MW5s3rXBYLSPB6CEuN47Pb+XD00 rlGAqF8DXXz8czY9eyZy72Wpjbr2zZZCNuZaeWZ6D2acU+vWEs+kszpTXObEZjGO+QYMGATdgAED BgwYMHDaQPL7T1tDQvjsn1P4fOEOPvglizW7SlmxMZsVG7IRusAeGszdtw5m1nmtAaiqqGbJymKU Nkks/HgjLo/u57USzmo3+aoJp7uGPeUQHQLoGlmHivj4hwOs21PCwbwqSqs8lJS7MYeHUO5V69qk qhrR7WO4dHxn2oaZG/nI7tpbzOZDErdPS/CTc9+NvhACc1AgSX6+resCr2SjZ0qoj5zX+onHhZHg sLG8wI3Te/IQ7z//lo9ms7L5973kbDHXBWeVFZl9RwC9hu1HVIa38lkPj5wylMe2lXLf91u49ikX v32/l67De/LWVSkostS8Sb1sJipUxpOfx7xlR7lmcDQKtb7KMvExPqJcb9HQ8ltiIQSmICvdOsU0 8jkOCbTRPimElS4vhdXQLhiycstYvrma/ud38ZPzev/AUw1epmuC+HgHMWH2unZIksSYvnF0Tg5h 1+4CSkpraBtyamleD686zI5CJ2eP60mnKHujPulCcMqRz4KieenmbkQ0qEfogo1LMinQJKTKCh6Z v75RAEJXTQ12CbbnVtQrlZCxBgTS2aHUu17KJlp3TGR00mr2HirkCFBTWsmyDZUkD2vnJ+fCPy0U 2qbEcna6nXWHClhTDAMjfJW7sTGkX1uuHRpXZyFR735SN9CNNW8SBAebCRNV/Lw2m7G9I+kaZ0PX ff7tEaGNx8WAAQMGQTdgwIABAwYM/M0QDUi6bLZxwdTeXDC1NyAoPFrOxu35/LDiEG9+k8nzL/9G TKuJ3NgnCLfLyb4SgWor5vOfqxqlM5MATTbTPclBkAx4XSxcuJnLntuE02IntV0k/dMTaBVmYtfO PL7e42myXccH4PJQWOHGGxhIVLg/MKvwhWs/jmDURnFv4DjvK2HGIsvILSJxNewrA3dlDUtXZWIz yceZWqcmhxJjlZAbtPuuWaNZeegLPvtqN46kRL56tBeB/oikgqbdoxTZyoO3prPs4U3cNONLZtgs 9EqLpk9aLOeN7cDwjsEc18FTHelj5CnLMhazCdRaOemUVbo4otuIjHU0ku8f0/4c82et+1usDUew mSNlbqq82ilXu6/AidOj0bpNGGazfMwc+WPQjwnUJwRk5FeDEGzZmEmO7fjkwe07htMhvJkctf5Y NCBhNivExFnYVuzhqArmGifZbjMd4oLrZFzb/CCbmcSIIJYe8FKQ74EIS71C5ri5fELNGyAxblRb Jm8+yltfb6H74u20TgilV2oUZw5NYcKgOOIc5kYxewwYMGAQdAMGDBgwYMDA30vPG6cka3A7FxUT ytiYUM4cmsKwuGVMeiuT79dlc2OfVJAkFLOJtKHdWDurxwmfsmt7AbNe20hkh7a88+RIRrWtzXPh 5pOPvSzcdriFl54yiiyDrqPWmln7Tc4RpxL3pKWcU0YROkTH8c38kbSPtp1QlnVRwb06MhJmk4yz ooa8CpXEQMX/3KYj1kqyRL+xvcns1poPf8hk9ZajrNlZwOpNubz28VYemDWOWWNijxm7BmP4R/iz BFITyXQlXSB0/fh+/dvTzc8CdZ+Fg1mWmjX5PxFj9GfJRTTIW/pX3AKbZAlMCg/MmsT0npZT7mut MkYX4PQIFNlEkAlcHBsAWdRHa/enWZP4dwiz8P8jCEmI5fVnxnLx2my+XZHDqq1HWbJsP4sW7eSD ienMu60X3WOtBjk3YOC/DLIhAgMGDBgwYOB/EfWZJtwur4/0NrhFrDsIyBIp7Ryg+y5bAeyBgXQL 08jelcNBrSl+4svNDBolxeVsL7PTd2DbBuTcR2JU7VSu7ky0irDh8FSSmVeBu7YPSHVmyZr+J2V2 FgA2erSywOE81uTV4GmimKbp6A2ydoDG4w//xJf7VO69oguBNWWcf9cK8mu0upRzTfM5Xx7r8Pho bruqLwteOYfMpVew5dXBhKseXn5zB1qDnwtVx+vv/5955AsNtBGjuCjIr0Tzt7c+kP8p5s0WTWgE gJqsGkpKPLSLCibM7iO+sgR4VFyaaFQW/fhq2kbZsVsUDmaW4PFo/uL+VER/0vBLEvRqGwKazpLV B5vu3onmWwO5VZVXs3O3l9CoUNoBtoAA2ti9FGRXNEpDCFBR4+FQfiWOEAsxcZaWvsbgb4uo/cD/ fF0IJIud4UM78PwDI1n16TSKF5/P9LNasfrb/azcUWwsgwYMGATdgAEDBgwYMHA6wevxcuuti3j5 p1yqvBoer4ZX1VE1378l5U7e++oQ5mALZ3WJAyAkOIDzz07gSOZRbn9uC9U6eP2/9XhUDuwr4F8L M3CiYDGbsOoaZSU1daRW0wVFeRVs3VUM/nzMJyZ7PurRs0s0Q7oFsODH/Xy2pggQeFVffXu2Z/Hz 5qOU48v49u8xNN/zJpyVREKk4M5n17Epswq3V6/vp9PFe+9u5kClt45EfvvBMmb9Ushl04fy+I0D eeuaZAr37mfqyzupOYHPu1BdLF5XiNsve033EfY2aa3pGQJ4fYRclmXCIsy4a6rZWiLQNR2PV0PV xZ9C1ePjQ+jXxc76HTl8urmyTr4VxeVsyCggq0bC1OKULr7cvV5VB/zKGAQLfj3E5kPVnNEvnsRY n4l4ZKgFm7eU7fnVlKv+OSIEu9bmcbTc3cisu03feNqG2/nppwy25Fbj8vpk4HG7+GxlLk6P/m/L QpIkUke2o1sQfPnPDby7oax+3L0a1TUetm48yMfL8xtpJHRdx4nvXfCqOiWF5Sz4eD27LUGMH5MM QGh4MCP7hnLwYC4fbqny/06A5mFnRh4/7HCT2i6W/mEta6st0ExwoE5uUQ2H3aBrGh6vDqjsPFDK rqxKNF33KZN0gTkkjB5JDqyy7h8TAwYM/LfBMHE3YMCAAQMG/gdRZ0Usgbu8grtmfsfjUQ7OHd6a 1MRgwgNk8nLLWbLsACtzNcaO6c4tw3yswR4cwCWXD2TZlh9Y9Pl6Oqzez9h+sQSbNXbtKWTJhmJ6 9WnHhRekkhAXzoTuZr5Ysp0JuouRHQI5kl3CD6sPs/VQDQGJEY1IXTOMCYDkrm245vwSdry0kevu /4FP+rYiNd7Ggb35fL8qjzGXD6FXr1hk/DevTdXXIk7i+2Gfsb25fXMpT3+XxdBLFzGmfyvaxVkp Lizn5zV55BeaWDU+jfYO2L16O1fMPUDnAd145ZIkACZfPZzrNpUw95NVPNQpnNkTWmGp0x7UN0T3 Orn++oVE9E/mgiEJ9GwTjNfpZMnS3SytsXLBxSnYANViZtzgZN6bv5+p137J5EHRqDVeug/ozHX+ sWlo9N6YS5+ctia3j+TKSV1Y8sQ6rpvxFe90jyFYONmYUUxOiQcUE3IL2a/FbGL3pkyeekNidHok IWZYv/YQHy/PJbJPZy4YGEuoP9j5wP7xdFxxhCee/52s7cm0izCxZfNhftxWQnmZh5gODR5qi+Ch KUlc8/Zexl71FWf0iyVU8vL71nzKnToer+7vd0sa2vwNuDk4gg9m9ePM+9dx1Q2f8Uaf1vRpF4S7 ysm6zblsPaox4+aRXOIvr0iCgoOZpE5ayLDuEVh1L5u35bEpR2P0mM48MjHRp4yIDea6y3ryxa3L uOOBxRyalkqvOCsbtmbz+hd7adU9kZumdm7xuHVMimBQ9xje/HYHlxaV0j3eihzo4IbzU/jx663M /jKb0We1Z1zPaGIdCvszcnjlx8NE921Nj3Yh/rXACBRnwMDpCl3X0XW90XtqOtHOLlqQG1vUBt44 rQ8pxy9Mp9didawPWMt8wk7crwY+T6c4pn9N/xq35b9h3vx3HsiPl6uxMRsw8P8Ttebtqi5xy+1D MX+zn69X5vHhwh31tsKKTGR0CA/dls69U9vj9aj+y2yJ4Mgw3ps/gRELtvD+kiw+WrQLTZaJi3Vw yUU9mXJmWyRdEJMYzszbB3P4yZV8/dU2vgZsIYFccm4HLhjj4ekvj/hSgQFujw6yhEWR0FQdhF4X Ib620eed14NWrcJ47V/b+WHVQb6tVomMcTBhcjo3nJlIFOARElaLgq75bp51t4qQZGwWDUmRsZgk VFVD6DruE91sI3HnzFH06L2H17/awy9rDvGdUyMg0EqfHknMOKMd7R0mqo/kc9kTG6iJjOC9+3ti 0gUutwqSxHOzhrHmsu958YVfGdzpPMa1C8Cjg8WiIAmBx6OhCivXTEpm7tIcHlyfCbqfJDoCuPKK vrx0RQout4okyYyZ0ocnijy88l0Or3xcREJiON2HKegeDQ0Jq1lB13231q66z2R0XQN0XG4dxaTg 9upIsoxZkVC9IFQNjzAxZmwaH5tkHn5vJ0tXHCQoLIgLJ/WiR4CbV9/agkv1uTpodXOhMWSzyXdr LkvERgewd1cuPy3JwBeoX6bX8M68fFtP0lvb62TUbWgqt2aU8ciCfbyzYAvogtj28bw+ayAv/2ML 2ULg8eqoqoaqwdiLB/J6YCBPfLiLX1dmotisjBnTjZnpJs58fAOakHB7NEySaODrfUw7FZBMCmaz r6yrCSVNp0FdWf9OGE/+cyc/rsrjtQ1ezBYTndtFcd/Etlw6Jg6vquH2aKhCIiA0jEm9HSz86SC5 NRoJCeE8eEsad07rhNmj4vIFeCC1e1u+mK1z85x1PPrcCh8HNyn07N2WJ27px5h2VlxuFYvVhFcT mM0KiuSXu1ttoFaQCEuK5par0qnybOTLtVmsEBIjR3XGqZsY1DuOHhuO8PkX21jwSa37gExa32Te vDWdQSlBxhnAgIHTHAcOHEBVVYKDgwkL8ylipfOnzxGHqyNY+/5lzRzoBV6vz4Sp1g9LliUU2Rcg RZGl/4qXX2g61S4VXZIJsCm+4CCnVwvxeDR0IWGxKC3WYAt/yhFNCOQmArII/+EAyVfv39lrj1ul xq1hs5mxWQzvir+QpaMLgS5AkSVjYzZg4H8EGzZsICUlBVn2rZ/V1dV1++8Tc79ht7sHIuc7pk0e x3VT+gOgqjpPvL0Ji1nBpMjI6OTmlZFT6MQrJCJjHHRoFYzQNLyqaHQ76+camBQZk1K/vwjh84fV NB3Vz30VRUZXvWRllVGhybRpHUZUoIKmC8wmCY//HCHJEmaTgknGb7rd+P6wlpgosoTJf8aQGjxT 1XQ0TWAyK1hMss/UWKvzzEUIsFoVTBI+8ipOfs8qAEWRMCsycu3z8AU60zS9zo/eZlGQ/aS4Vr9R G3DPZlGQJYHb7X+mImM3+9rn0Xzm6WazgiI0DmSWklfqJtgRQIfkUOwKuL06DbJ8YTYrmJT6vnu9 Gl7dl9PeZpJ8bgqar6xiUrCawOPxlZEajJ3FrKAAbo+G1qB+xSRjMcnUZYZDsG1zNp+vOEqXvm04 r28EXo/erLwkScJi9o0PmttkrBUAACAASURBVEZ2XhlZRW7i4kJJjLT5A/01/p3FYqKmvIrdWeVY ggPplBiMIkmYTL6I6C6vji7qx9Fk9rXRf+eAAPJ3ZvPKklx6DurImNQgzCc4LAnAajVhkgQ1ruaj yUuyb+wVpV65rYv6sReAs9rNZ59sJT8okvuv6IjFP+eE8M3Jhu9O7X8VRUYSOjk5JeSUq8TGhNA2 LhDNqzaSjSL7zmdC03H5z2vHvhOy/8xde3bVNB2P/32ymWRKSqrYn1OBW5dpkxBKbLgNj1slpXUI Y/onEBFqMxZQAwZOI2zfvp2EhARkWfav8V48Hg+SJHHo0KEmbtAb3sDqgtKSKr76fg+LtxSQU1CD qpiIjgykc/soRvZrxdAukQSaT3+ypR3MYeK9v5AV05YFD/QjPcF6mrVQ5a031rPPbeHeW3sTa245 GSs/UspPu8pI69aKtJjGi3B5WSXz3tiKGhPOHVekEfQ39vCL937n0hd388BTY3l0Uhvj7fzLNCFe duwuIMsp0yctmthgw5PFgIH/n7o6gckk8+j1vQ1hGKiD2+OlrEolJMiCIkvIikzlkQIe3nYQc6tI ZlzTmyk9Qv7WNtZUuXBLMjaTT1EBYBIebpqxG49k46n7BjAy1vIfa09VeRVbvtpMZXg4903r+l+5 FhjKegMGTj9IksSePXtQVRWHw0F4eLhvvTvuJfZr7oQuyNyVyYQ7fmF7GYSF2mgba0erdrMuq4wl K7N4/t2NjLt0EN/d3LkRYWzKjPpY09sTLRZ/aCE5wXMlSQJZwmozYbfITd9On6r5dwv72XLofPdN Br9UBnDdjbUEvXlT97p+aTp7V2dw4eO7mPnweJ6aHN94U6ly8snnO3C2b8MNxxH0Jszgm5P/yeTb AphMCoF2cwP/vD9/A2m27X+iOX1z7Tylz5toU3Nz55TlUl7B2++u4cMsCx8+NoKzux6bX7fpcW/+ cwMGDPy3bvwGDBy7zi/5cSdXPLiGuPR4uiUGI9wuNm4vYE+h4Mbr+zLubybnAFuXbmfiKzuJbhVG apIDq/Cybn0u+0pVJl81lP5hyn+UeHq9tYH9dDRAMdYCAwYM/Emcwmz23crWWsc1SdD9Bmy4nTXc MHMJ26ut3H//CJ6c2LpBbSprVx/i3e/2k286/nBfuwz40pP4TMcamsY1Xix8qVp0QZ3pfEMf6pYs LLULtOQnPqrfps2kyE38VqqLqqLrte2T635/8sW+cT+FLnzRVSXJZ47WoJ9NEV+/U2ATzzDz3Jxx lHpNtLH6nkMDQiz85mKyJPnMsGq/8PcTqwmL6fh2R0WH8d6b56JZAwilvt7aH9dlOtF0dOplUU8W jxlXv3ylRmP1B4mkvy5Z9rlN1D2X5pUGxz+j8TypzTNaa5JoUqTGpPcEipgWjT0N+tzUXGuQY/i4 jfFY2dU+E475jUBVj53DLX8f8JvL2az1Nw/HvStS/bsnGr4DEn9jrAIDBgwYMPAXUzVS2kZyztBY lh8q57uDxZitZjq0i+Xuu7swbUQrAvj7b1yTOsUyoW8hy7eX8HNOKcgyKSkxzL6lC7ednYhZ+s+6 V0qyRHh4ANGhVmMKGTBg4E8l6CkpKaiqisvlap6g1xIJZ14OP2UKWo/sVEfO60ibZKLfwPb0G9ie sgpn7U/qCJTL6aGwuIbdB0spcem0ahVGalIwjkBznb+QpulUVDg5UlRN5pEqKp0aoaEBJCeGEB9m I9BuqiMIHreXsgoPlgALwTaZiioPTo8vCIojyILdLKNrOtU1bg7nVnAwpxLdYiGldQitIgNwBJnr CJos+eorL3GzbV8xhdXQNjmclPhAgiyKvw/Np22t7afqVamocrP/YCmZBTUEhAbRpW0I0WF27GYf iXNWuyit0TBbzUQGmxsRTNXtobDCi6nBd4kJoUQKGatcrypRvSql5S4OZZVyqMhJUHAgHZJDiAiy EBJkwVXlJr/CCwgqKlwUlzpxeX2yiQ63YTaZaNMmHE1RMPs3Z1XVKCtzIUwmHAEyhUXV7M8spdwj k9IukpRoO3aLXJcTVZIkX2qRGjfZeRXszqrE4gigY1IIDouEkGQcQRZsLXR10HUdl6ayb3ch+/Oq CY1y0CEphNgQn7kd+ILTlFR6UKxmHAGmOr8rSZJwOd2UVakEOmwE+v3+wEeOq6o95OeXsyOzAiXA TlpKKEFmCVWTiIqwYZKlEwQRltDcHo5WeAkMshFoElRUe3F5dZBkoiPsmCSfsqSsws3Ro+VkZFah mk2ktY+kVYSNkABTvc+g00NRjUZQgAXd4yE3v5w9OTU4IoPp0S6UsEALSoM5IXRBdbWLvKOV7Mqs QLdY6Ng2jKQIu/998PVT6DrV1R6qVAgJtCBpKhU1Kl5NYLebocJNhUtDUzWKSmooKVOocesEB1kI CTQjdB2ny0vukQr2ZZdTrcokJoSQGBVAeLAF298cq8CAAQMGDPwlJ0EE0CktgXdeTWiu0N9uSSWE IL5jIq8/nXjCMv8ZLbJPHqHhwfxr4ZX1cjSC3BowYODPUP75eYAv8CcnIegAmgBFoDrd1KiCAFPT waZCHfZGkcOLC0qZ++ZanvvqMF6zCZPsi9rapn08z907iIndfPe4R3OLuO+J7/lwtQtToI+AeT0q ktnM5Ik9eHp6D5KDfYRvza8ZTJmxjL4X9OWWUQ6enbeZpVuLiOicxNyZQ7mwVxhbNx7k4bkb+HZ7 GWarCUn3RQTtNawTr93Zj/4mGVmW0V1OPvlkAz8vP8SOox6EroFmZvptg3lkantiApU6ItTUhiBJ EugqP363hfte38HeUhWTSUbzqngUG/fcNoh7J7QhzKaw9Mu1TH5+B5E9Uvl9ziCSwyz+W1adxZ+u 4Nxn9zJy6mC+n9kFqyS49qJ3+aQwisJ1U4gUAl3TWPL9Fm6es5mDLgm7WUL16ng0QZ9eKSx8ZQS/ frCKy9/cDxaZF1/6iRdfAnSJxOR4Mr4YT9WRUs6d/BGZyankLxiNBGQfKGDSRZ+Ql9Seh88NZfY7 u8ipEaBqKEFBzLhpMLOnJTcIOCc4sCePWa+u4Z+/F6DYLQhdEBVsxuPxYIqO5Y2Hh3NeD8dJJ6LF LLF3ezbXL9vK5ysLcAKiykvb/u2Zf08/Rnf2mdYd3byPIfcsI3HEIN69LY3ksPrx+PqzlVw4ewcP zr2Qe4fHEOQfq8LDR7nz2ZV8tLYYWZGRhY41OAiHt4K8wgA2L7+A7lEnDpSSu3QLSXeu46JbxzI1 roxnP97N73sqQA5m55pLSTVp7NmexW3PrOHnvdXYbYovSrAKo8/qxpv39iYxQEZ4vKxesJLhL+zl gmk90Q5ksnBLKbJJRvfqtOnahvcfH8bQNva6d+fwwSM89spK3llWhDnAApoGJjMTz+nG7Bt7kBzi N+krLmPOc7/x+Fadp67viZJ9iDlfHiI3T2PQoHhiQuGLXwvBInPJbYt8WqUahTvuHsScq1PJzzzK Y6+t5f0VR/GaTJglgdPpxe4I4cVHh3PViHjMxpppwIABA/9rJ8EWkMq/33qqJcqB/5wCoQl5GOTc gAEDfzGO90H3L3wBifGMjDHxy8Y9XPePMO6d0IbIQAWLWcFilrFZTZiVelNpgMrSSl586ReeXuni npuGcfGwWBxmwcYNmTz+5mZunLWcpLfPJT0UFIuZPn1TSBsVSbckB+FBChVFlSz6fjfzPtuKLSiA 927s5GukyUR0qMzPSzLYtEYmOjaMiydEERIZSuswC/s27uXGJ39nU00gd0wfxIQ+UchuNyt+38+/ 9jk5VOCkf5SExWJi2+/7yDwQwnkjO3FntwhchcXM/2IP897YyNCuEUztG0WzMV/9q/QPn63m4rl7 6Te4E89ObEdagp3So2W8+t46nnlsCa1bT+HqvuGMv3gYz2TWcM9nGdz5QSxvX9+RMJvM3o27ueyV /aSP6MpX93fF6jc3ttstEFh/21+47yATH1xLXO92fHJtF7rF2sjPK2fZhmy++r2YcmSGjOrEfUdd zP7pKOPHdeGC9FDcGgSHBGIHqiSJwAALQfb6oZYVmZAAmS2ZuTy+sJqJk3sxuH0QuVmFvPXpDt79 ZBPp3WKYmhbgI63783j4+WUs2KlxyUW9mTokDrOusmHTYd7/Zh9uu6llUfElGbuo5sNv9tGvb2se mjGENiESy1Yc4N3Fe7j/nWBi7uxFt1gLkiITGGAmwHp8zACz2URwoBlrQ/Pt6jIuu/dnfjzgZer5 PZkyMJogWSdj31Hm/XMneQEmlBZs6LJJRg6ysOLr1Syq0kjrEMWVExOoLtOwA0VZuYy9+WdMya35 8LmhDOzowFNZzfc/7eL+D7dwqcXGbw90Q0LCZDGBJPhycQa9eiTy8kPdiVA0Vq0+xD9+Osx1T6xi 9VujCAMKcot55NlfeH+nztXXDOCKoXHoNVUsWrybVz/bRKlT5YvH+vliCEgSAYFW1KJcnvvHSiSL mV7pbRjaR6ZLp0jSk61U5FWyrtzMVeM7kJ5oo9oj0atHHHgree7N9cxfVc71Vw3g6pHx2DSVHXvy efOz/ZRWuHCDQdANGDBg4LSGkb7UgAEDBv7fEHTJv8Cb7Q5efKAfkx7fyKcfruKf81cQGu+gZ+dI uraLYEjvRAanhREZYsUkAbrKod2ZPP9jGdfPOIPZlyRRVePLf3n26E4ECTdnPbObj5ceJn1ya2Ji w7jlmiEgdCqrvbi9OnLrMAKssHHbL+zfV0AhnYjyt8vrVolPjeLl+wZxTlpofYO1Kh76aD9rckw8 /8Qg7jyr3mxrSL8kbih3oVhM6Eeq8XpUwjsn8ckTQzmjY224tPaE4ua6F7eyIbeGsQJCm+PnADWF PPTBAZJ6pTJ/Rk/ign05LCPCg5h3Dyzd8hNvfX2Aad0cWANN3P7AcDZnV/DBm7/Tr0s4V3cSTHtw Nda2CXzy1CCCTmBKv2llLi6rhUvO78uUgb68eB3bRjBscFsenu6mygRBneOZ1i+H2T8X0qdPMpeO jzlO4dLUxu7VJZK7tOGH+WfSIcD/sd6atgEepszPZkNGAVPT2oBws2JtJgvW1nD9rYOZf119QMAz e4ThLixj3m6thecJnUq3iVvvHMILl3eom3xTxyWieL3M/fUQ2yal0C02+pQn8mf/2shv+6u5+pYx vHZpst9NAEYPTqZ480EeW92cLJqGEhnJD3OHMbRtQH3zNY3H31hDlhzKujmj6RaML31OWABXXj6A AzvyePPHDHbd141Uf+oa7BauvX44r13Wpq6e80clY6v+irk781mwtpLp/ezs3HaI91c6mXr9IN66 JdVfMob+qVGEaEuYvTqT91d04KYhYfUTRDIxdnx3XpjenaiGbnElJfyaFMDOLCvjz+jAqI71fcjf nkXGwTK69E7huglppMf7buW7psYy7byuuLyg6ICRBc+Agf8NGneKpO3PKG9EjP5PwHezq2s6NU4v KEojRbyBP/cdalEwXQMGDBj4qwg6flt4WZboNrQrmz+MZf6i/SzdeIS9R5zszDjKmg3ZvPL2epJ7 tOGNh4ZxRvtAPDUqG1fm4TFJZO/J4ZbZ2fjTRKLIUFhYgVWWOFzi81nXdZ287FJ+XH6Qb9cfJbug hpJKD1VOlcJincFddCrBR9CFwCPZGNI32UfOG/hGH91byo69JXRMT2BAp+gGC6ePw4SH+EyaVV2g 6TqtE0KJDrY0WmBbxToIDbFQXK3iVjnh9eHeVbnk1WhE1lTy1BvrsUj1xM9iFqheyCypRq1Nkoqd dx4dyoEbfuaBp37ltxiV3bqDhbPPoF2QVM+1mohll5DowCLpfPrFRka06UlKhBWb1YTdZiLYbiUI EF6BR/U9S1P1Fu42ICQFhyPIR85r/alkExFxoeDJpMSlAlCVX8XmzUcJax/Nmf2SGm9Mbl/+2VPZ o3TFQly4zTfx6sYxkMGpoXz4Yw77Cpx4/gA/XLq6AJcI5bpRMT5y3kCoHr1pl4UTbcYTzunB0LYB jdw3NNXFjyuKsYfG8K931/CuWk/5dV2wu8KERXGxpwBSI/2CNskkxDkayc1qUZgwqjVz1u5ld2YR dItl09p8bK0cjBmYVDcnkMASEsDQYW2Y9e0W1mYU1BF0VdMJbx3J+Wd2IMp6zGFB80WbFULgVRsr T0LCbbSKCeTHLVl88lME9lEJhNoVrBYTwUFmbJb6gHTG4cOAgf8BGuffDDWPh4MFrroc003t/Ra7 haRI26nXr+vU1Hgoc+mEOGwEWgwN338KpcWVvPXeZjwJiTx0UYohkL/oHRJC4HV5Kazy4gi2EWxT DMEYMGDgP0fQj9UKBsdGcff0KO72M7uczGJWb8vn828z+HR9Nlc+uZr9752BputklrhA18nOLkG1 gy4a7f2MHtKK3q0CATiwM5sbH/2FJYc00tKiGNA9gXaJwbjLK/n4q52o2rGUSqDWEtAG2voSp5fi ag+h8TaCQiz1BwaOIb210cp1Hf2YSOEmRWkUff5EyCx1o+mC4sIKDuDCLDc+7HTrGYOjfXhdKjEh BEpsHG/dnkrv+zbxw1aNe2ePZmyytUl5N5RX11Gp3PRjNh9uzmbkpQeICA8krUME/XskcOk5KaTF Bfxbgy/+j73zDrCqutr+77Tbp/degBkYelcEpIgFUVDsUWNvKWrMq2nGROMXE40xXU1MgiVGjb2A itKR3oeBGZiB6b3dfu8p3x/3MgUGGGzx9T3PPwxzz91n77X37LWftVfpTQseHbsAkoTch852BzXq uoLEuRJISHL0k9unha73fW/k59hkK85YaPar+DiF3C8CQIBDnTqkJhKn9A+7+LQIh7X+c2OAEfJx sFtAtfjZV9WB1m+Bgz0phvn5NjIsxlHj1fvLTRGJTbKCptMWVNFUnerOAA6rREqyo2f+jeifqN3h IF5TaW8J9huZruuEwtqg58QA7FlpXDW/iH11O3n8T2t44kmJ/Jx4xo5IY/HZQzh7UioJtiN5GEyY MPG1gGHQvq+MooWrwKmARTzKpcgAWWHErLHsfWzyqbfvD/D+q9t4YEUnP71rBpd8Bcp0/V+Bu9PH K6/swjNBMgn6FwlVZe/KPVz6TCV3f3cWd8xMNmViwoSJL4+gHznID+yuJpCdn8yl+cksnJNL3QXP s6u2ifVemC4K2BURW5yT+396AZcUHp8wBDu7efe9PSw/LHDP9+bw2NWFPZ/VVTWwcc0+mvTBEQSr LGGTJbqDGqFQxDf3WOJ5Eo4nDJ4QOi0SoZDKRVdM44+XZZ6wFmaP3AydA/V+ZKsFqxZg++5GWuck k+w8UdZ4AWQ7jz++iGs2V/HRzha27G5i28E2nthczTPvHWLNcwsYYf98F4Qg9J97WRCwiAKqpqOG I9U/e8bVU3rtM50bEQQIB3XCYRGHIqIAIaPPYjT6y3MgWVlFIBim91K7t4b85xaRJ0m4FNAL81j6 5+knNkIET7AeNAOfJwySSILNgiCATRbRdZ1wWAPknht0iGR2DAsCsnJqt1LCAMI2BIE5545mwsRc PtpQw9pdzWwpa+PjFWW88k459/9oNvctLsBp3p6bMPG1giCJEGcjb3w2t52ZTlg7auMWRVLzMk5h 7+5j6DZ0Ojs87K120+XRj913ojvS8aujGH10kHCMfhhwHz3m+ydLbnYyz6DBew717cOJQwIGavM4 JTN75DTQ748/NkEQsFhlrLI4uLkaYBzHyLSPl+JgXLlPJP9BuYIPUJ50sGM47rODKJ17/PKtA+tT n9vLgcPdtHWpA/TfLE1qwoSJL5Cg95RK6/bRFBLJTrEPmFwrEBZISZUwOmVsIiiSxMSiBALvNvPW 8nIuuaX4mO+EQ2FUQcLjU9ld2U1GQQLzzyrs94w/qBII6YOmVFnJdgrTnWyqaudgdSeT0hP7bbT+ gIpklfm8nJHGDIknxWXhwxXl7J+ZQEn6UQxZ0+gO6Lgcck8W9N1rS7nmiTKmzJ/AuGAdj77wCQ8X xvHwJXnR7PgDK6xgWMNqkRk/uYDxkwt6mN8jDyzjh8saWfJxO48sjEeUIs/7Q+rnvkDinAoFaU5a Kr1UVXdCQVKPfDVNxx/SEIRTi3sTxGNrhFcd9NAVdjA8yYYT8AsikiDg9oeO8XgIhvRe7wwDEKwU Z1igvIP9bSFGpNv7eUQE1FNzcT+exUq0OjmjwMKzpYd5v3YS52TbjnnQ3R3EHmvr56IvimK//gc8 IdZ80oLitDK+IAlRERmeE0P3xmbKD3bAsJTeNaGHaKhtx2uzkJvrYlD2ECEi46CqR+q095G1qmog iMSnxLH4gjgWXxD5bPuKPVz98HreXNPAotOymJBtMXdHEya+TjAAUaBgbB4/uH7USYlQOKjiDuo4 nRYsaLR2BgmEdURZIi7G2uPiawB+XxhP0EAWwOMN4veH8AZ1LIpETJ/Ep5qq0dEdxBtQMRCw2RQS YixYFbGHJIWCKh6/is1uwWEVCQXDePwagizisit9ktNylB4x8PnCeAMqwZCGqhuIoojVKpMYa0WR BATBOAEZi+hinyeIT4WkeCvhQIgOTyRHjiRLJCfYsUYr2hxNGN3uAN0+lZCqIysSMU4r8U65551e X5BgGGLjbChHSmYaBn5/CH9YIDHO0pMDSNcNvJ4gYUQSYi2DvGiIPNXd6afLr2IIAi6XlQSXEtUn kRKdPn+YoC7gcig9nn5HdIPXFwZZwuVQkOh/yeD2hOj0htEMsNstOBQBVdWx2hQcVumE/TJUjW5f GGSZOIeMrmq4fWFCOsS6LFhkMUKmNY2OaKijZoDVIpMYb8PWp4qQHlbp9KlYbBZcskF7dxBvQMMQ RVwuK4lOuWd+jD5ro7MzgDugoupgs8okxEXa7UvStZBKp1/D4bDgsIgEAyE8AR1BFLER+QxRiKxv X7TcryQSH2MxE/OZMGHiiyXokR3Q4PDaPVz4uptf3z6GsVkOXHYZRYr4c/t9QbZ8sp9l+2DMvDxO twMojJ45hAnP7OPlF7cxZVgcF4+KRZYFdFWnrc3NzrIWpLR0FpXYSE2w0XHQz+69rZwWF0sobOD3 +VmzpY49NWGGFAzOZdeamcis07NYsmYnf3trP4VpoymIk9F1HU9HN29u72DKuGzOUD57TJwBxIzK ZcG4JB5/dx+/ejWZu+fnkhGnIGDgD6hUlNawo9vG7efn47RJtFTWcuXPNuAclstT906kQCniQN3b PPHoSkYVXMB1U5MGNB4YwLYth/HHJVCSEZG/RYKAX6MkJwZoJc4e8WqIT3NCWGVLWROtXanomkY4 DJlpjs88ZmuykwkTMgi9uY2XPtjPzOJxxEkG4XCYLRuqWVXWiTU+fdDtiYZOW4eftoCKVdcxEGgo q+SljU2kj8tlXF4kXjsxxU68y8Kuinr2VeeQZI0lHNLoau9k2eZ2vD69X3b3ebOy+ceWHTz+UgXZ 1wwjO14mFNaoLKthVW0QdNunV6DCkdsBC1dfXsR/Hi3ljgfW8e+fTCY7RkYSIRRSaWjo4t0Parnj vtNJjR6I0Azq6zppaLVFEvqEwmzZcpBHP6hjzOQRXDjZBWhMPD2XuBcO8e/3y7jitDhSbCKCYFCx t4EX36siozCJc8cPUs4uCwkJNtpbOth5sI0ZhVa8XhVXjJXO1i7KG/ykZcSRk2jFZhERJZGkGCsJ MTbCFhGLbB41TJj42vJ0TT8p0TNCYSo2HeTR1a2cM3MICb5W/vp2JeWNPmzxcSw6p4hbFxaSbBUJ uP0s+6iCf3zSStiv8u/Xd7BzvRVfCCaNz+buy4YhYeB3+1mx/hAvLz9EeYOPoCGQmZXIhWcNZfGM TBLtEU24b2c1z7xXw5RZQzmzyMaHqw6zprSdxIJ0bjh/KCXpx4mRNwK8+m4Zb6ytp7EzgDugYVEU srITuHx+MfOnpBE/iPCdpa9t5+1DAt+6opDSzYd4dV0dlfU+4tMTuXbxaK48M4MYixgNQxLA0Kg8 2MI/X9/HxvJOWj1hHC47Y8fmcNtFwxiV5QDDYMXy3by+08+td0xnarLYY7B47dVtrK6TePCeKaRH Q7QCPj9/eXIjjYnpPHbTiJPqLgEIBUNs3VfH88/vZsX+TlTRwrTT87l1cTETcyKhhSG3n6XL9rG2 Veb6i0cxNqP39NFc386SN/YiZmdx48VDSY6uBU1VKdtTz7+WVfDRrjb8usjQoWmUpCs0d6hccF4x F0xKOWH/tKZ2fv+f/chZmSyanEh1eT3LtjZT0wl33zaRafkxhPxBNm46xAvLD7P3sAePqpOYGMOF 5xZz6cws0mMihgZ/VSP3v3KQonEFjLb7+NeHVWw70EXIYmXGtCHceWkRw1OtvR4OqkppaR1Pvbqf LVXdeMOQnhHLwrOLuXRGFqkuOWL0Ngwadh3mJ+/VMf/cUUxJ0/lwdRXrKjzYXE7OHevkj+83gK7y 3rI9NJQeJKRCZmYiD31rLDZzazFhwsQXRdB7XIhFAXucnebyPSy64QBDS9KZNjKJzAQrhEKUVrSy fEsLxZPyeeyuiT0qIj0rjSfvP41rf72Ne3/8Ln8vTqMow4a7y8vu/W0EHLE8/P10rPFOFswp5OlV m/jFYx+xd1YOTiPM7vJ2th/soF0VGEZvorBIDhrjmJvDaAQ5F503nIN1Hh55fS+X761j4vAExFCA bXuaaYlP4Z8lWWAXMPSIa5l4VN0usad9AUk8sRIEC7+4eyrNgY289ux6Vi3fx5ihcdjQOFjZyo5a P1d+YxqiJBLo7OS2H31MlRDLKz+fRYFDAGJ55v5plH9nBbf+ZAWFT53H7EJn1LptgG4gRRXjgZ2H ue7ZVZw7s4BpI5JIixM5VNXKC+8fZtTYHC6fnQhA2oh8FhbtYtnSHSxobiPPJWDodp59dAayCLph oBu9d8iiKERj8Qe+QdC1iCwiUJg2pYAfLqjj0eV7OXNbNaPynLQ0u2npDuLza6QkicfI9HgHP5sQ 5KU39tBa00JBig1fjKhE3gAAIABJREFUp5vXV1RTG7Tw2ztLGFcQOUiIuemcMymNjf86wF2PG5w5 Ip5Qt5f1e1ppdwdAMxBEgSOXKfMWjeHyja0sWbqFC7dXMTzTRldbN9XdIPkj1QRE8eTO7qJAZJ3Q 15VO6JHbvEunct8eN39ZW82cG+o5Y0wqCU6B+voutuzvIj0nk7ujDUmiAL4gz/x9LVvXJ5Likmlv dbO5vJOikfk88J0pRKLYJIpKcvnFVbnc9+oBzr/HxzWzM8Hj4d3Vh9hUL/O9W0Ywv9jW0w/hyJwO dBNki+X0iTmULKvlt099wtp1KahdYS5ZPIrZBSKP/mENe30KF07PZWSuCz3g590VlZR6JH4yL5sh 6WaRNRMmvnaIbhUBX5DWdh+BY5KKCihWhbQ4C4amU7e/jiX/2s+KzXUEuv0kprhIcFqoPtzETx5v pNIn8Mx1Q9BVjaZWD4dagxga1NR2EuiQ8IcEktITEYCw28tT/9jET188SEFROqePykBRg2zeUccd D9Wy+8apPHZdERag+mAL/35zL5/UdPFPI8CmCi9Wi0ChW2bB9NzjE/SQl1XbGtlc6aE4L478HAVf V4CyHYf5xkeH+M3/O4fb52ZiP4mu2rzmAEs2B9iytYKWoEBqgg2ny0JlWS23fa8O67OL+cbYOJSo Pjmwo5L5966mW3EyY3wao0ZYqDvUykv/3sjL65vY8ORcClwi1k4v/3iljNQJI5m6IAkwCLi7ePQP W9il2xk5ZyR3TnECOt2trTyypIzhVyVGzkEncgITQBZ1KvZW8837aulCISPOiubx88xzm1m7t42X fzWXUQkiqi/Axk8q+WeVlblzRzK2T0RDR3s3bywrQxorcVmUoIPBhlVl3PGbzezqEDl9ZBJDXBL1 VY189HEH3c0COSMyT07QO7t548MDuOM6+OCtAHvrvCBL+NwCl1w+BvJ1Xnx+Hd//VzUJqfHMHJtK rKixfW8jd963lB13z+Xxq4cQb5MINrXxz7f2EbO2FtWrEpfsID3Wir/Tx5N/XsXqSi8rfjGVFFvk PLNjXRnz/mcNWmI8U0ckM8wOpeUtfPu+SlbcPIMld4zEKUX0fntVI8++vJe6To3HKmvY1wWxdhmX 1cHI7CwqmgIRIt/QheD1EtYEusMWzIwtJkyY+EIJ+hE3ny5PCDUrgwevG8k7a2vYWNHGCwea0MIG SCKuWCtnzh3O9745hhJHmJrGYMStVhDIHlXIcz+z88fXy1m7s5V3Dmo47RZGluRw7pl5TC2w0dAa IKMom59e0cKDL1Xy9IsdCIrMmLE5fOeb+ezduJ9mUaCxOYjLqtPu00hMdmJBo8EdQPOp9Ak1RrbY ufqy8aQkx/DcB4f5eN1hdFmhpDiD2+YNZVisRE1TALvLRpxVoKXVS6MSJqwZWCwyrT6NxAQHcjhM XaOPkKKjHW/HNUCyxfOre06jZGkFb62qZe3mWlQEcjPjufnK4Syem057t5+3l2xkdbPOFddOYLRL pbbJg2GAkpLBfRfn8T8v1/DDv5bywndLsEoGSqydNF2hrtmLWzfIHZ7OeSWtrFhzkPc+2A86yA4L o8Zm8/NvTcbV6aVGN8AQ+dGdUwj8bSebdtdTblGYPD6fxu4gXa0BnAlOEh0iNe4AclCnoSNATKIT xQZ1niCGN4yBgEXW6PBqpKfYkcNhOrv8uP0aFpudq74xiYC4k1c2NLNlf5Ci4gwevDyD0q2VvHAg TEu7n9Z2EX944NsZu13BrUJSViIOJ6xbd4AlDQEQBJIyE/nBtycyd3gsrc0eVB1EWebi84rYXePl zc31/HVPLZLdxhWLxzPO3s5Tb9UQ7A5Q0+jFIRggSfzgtknYYyy8tr6Jrfu85BUk8/B3J1H63If8 YadAY4uH2LDlhAaEJp9BerIDMRyiptEzwKFI4I67ZpBXVMaLKw6zfVcDAR0SEx0sPL+Es2fk4m71 0uUP09gdApvC9Mm5WLtbWbPVjWy3cPZZI7jpohJmpglUN3oQAEkWOXvhRBo98KelNdy3tQoEkZSM eL597WhuPjeb+iYPuiiit/sJywqpsQaeLh8t7QKBPnIXBJGiERl874ZR/OG1g6zbUIM1xsVsdxDB Fs/sSelUvl/NX17YjqHqIIrEp8dx07UTOXdEHFJQBatZrseEia8dNJ2yTyq4rK6+n4HWAJAkCscN 4x+3RsLTREkCWSImJYG/PDSP+WMiBuH9WyuYd8cHrPqwnPrrhpCZ4OL226aRrOhc+1o7jz04nysm uPq8VOfD1Qf4zeuH+cbNZ/KXG4p639vVzu0/+ZBXl1VwzmnZnD/cgSRLxMhhdlR2c+l5RfznuwUM S1JQEUlOPIFXmBTLL/5nLn9LtPb7ddWGUs67fz3PLqvhgrFJDEu1nvhQpEgookbqqHyevG4c04dF xrL+tfXMe2QXT71RxaUlY1CsEoS83P7z1YRycln3u7MYEtOrMLa8t4GpP9zGr98byZNXZDJ9Zjau 3+9nw85aWJCEoRkc3lnFroCNlBSJNz6o4M4p4zBUnYayejpcdhZOjZSNNYQTB2npuo49xsY1N07l jgV5xIigu7v52WMreWhpPX98rZInbxyKIAjIioTNInJ0pIAgiFgtMmLU3Ryg/VADf/hXKfuCLp7+ 5UxuntXrxfXc06u45U/l/ULWTqRbXQ6FbWWNpM4cwq+vncq04fGEPSGyhiRQvm4X//P8Yc65fCrP 3FFC7wxp3HnX6/z+ma3cdE4203IcCKKAzSKh2108eu8Uvjk7I2LE8HZx1Z3v8eLSnfzn8pHcOjkW 0dfFbQ9/gjc+jdf/PJ9zC6MhiWEv37rnXf789Hpmn5bLtybHRMLYJBFkgU27G7jkgjE8Pieb3CQr fo9KUVEic2M1Rj28j3vvOYd7zkrse7tlxqCbMGHiiyPo0X2G0spOtpS14EiI58qLE7nU7+dQg5cu n4rNZiUnJ454i8CBXbWUHXUNe4RsnDltCHNnDovcSBqReOVQWGXN+sNo0Zs/R24WP7s9iaoGH3FJ TnJSHRiqRu6CiYi6xpaPy9logGJRuOuu01FDKq+8UzFgRjdRELDEx3PT1Yk9MfORd4ZYsa4KXRA5 f9FYRF1nf1kdpaW9A5YtNu6+9XTUQJg1ayoZTLEyQRRIzkjm9mtSEaPxzpoeyTR/oLSRst0G1oJ8 fvv9QkLBMG+sPNTPympNzeax7+WihVXeWxX57PRLpjJL0FnxcRU6IMsSl1w0jgvm+jhQ7yFoCKSn xZKbaKF+Xz3/LjX6yFziysXjuFqKpP9WVY233y1HkEQuvWkaoq7xelR2kihw9R3TQdV49e3yfvJU FBuP3D2JUCDMkvcOIEaT2MmKyLhpRUyeXgxESqs1VLWwek8Hij2O0opGfI0C4eMJzzCwpCRz7x2R Ou1et5/qBjchUaEgMwabEGTZyr6yNxAliXnzihkxMoMWj0peVjxxdhGdTB74TjZ+bzfvr+yKytVA lCVGTyhk4pQhPWvZ39TImsMhLPEOPtlQw16rdEJrt6i4ePSu0wkGAry+8tBxL6IsjhiuWDSGq6O3 KLoRmftgSxevL+/EUDWqDnhAEnAkuLj0rCwui75YVTXqKhtYUtG/J6IokDs6n4eHZVBZ242uWMnP isUpGbzzQUWPbARBIG38EH46CbyNzbxYaxxzehMEAWtMAt+7eSqRyBQDvz/Msg3NJBdk8uNb0qhv ctPYFcIRY6cg3YVFNFi6ohJpZh7D8+PN3dGEia8jRw/rdLjVfonZIgTdwO3T+mzZBkKcnduvP435 Y2I5co2bnJvKvPEu3mnxU94FmXFgBFQ8QS0aax3q/76OLjZvqabbFcfInBi2723CF460FWPTSExP oGFXK3trOzh/eMQd3BOSueWayfzxhuIBVMlxalLLFpIcISoPtXGguovy6i7q2gIYIR9uVcTj9hI8 quzk8XRVWIrnyfumUhSr9Mhn2oIhJP+ujP2tbrSo7Go3lbO8RuW6+fk0VzXT2Eem1swkEgSRj3bV whVZWHOymZ4qsmp7E0FA1DRe/aCapOI87pkQ4P4Vh6nXx5ES1lm3vRWr084Zk5J6dM7x+wsaMkOL crnvwt4ynWJMLFdcNJpn336PXXuaCDL0lMuXbtjZwIodbVx1/SyujpLzI4n7YhwKDvk4JfsGQCio MmrmSF742RTy4vsfPX/7zgE6RAfzip3sLG0mHPXuUCwKBblxsHw/axuCTMxxRHWozoULxnLtrAg5 NwwDwRnH/7ummFd3bWbpuhpumTSSyg0VbGo1uOS2cZxbaO9dO4qTX393HM+sXcE/3iznW5Mn9v4d KBJXXzeDP1+de9QAQnT5I+vH7w8drXDNGHQTJkx8cQT9SP3zM8amccbYNFM6Jo4wSiprOvEgkxxr wSKJGGqIN+ubqevWuHBhMb+6seS/rqD2lLUgWBXiYy1YZRFN1di1bg8VXTqLrh/FD75ZzJd3L6yz WermifUdTJs2hKvmJPyvmvJBZd41YcLE/6I/akASmXrBBD66s+SEj/XhqvgDR5KPRkN9EIi1OyJJ uAbBd5s7wlQ1Buiu7eQnv/wAqU+2cgOwyiKFhcnEKlLPbw1JwW6R6McIe7jQMWndEQSBsN/Hy6/t 5v89v4/KLo3EBBsuu4xd0unwqiRIwuBckaPNu/0qxPYJ97HYSUDArRk9QtpU1oUiC/znX+t480WO IW0J+XFkOKNeW4KVs85I5P23GtjUaTAZN+9uauHi68dzdZGXB17bwIubPXxntMT6ihaSsvKYHg/H KfNyrOFF0/oMIWIAsbusDB8iUePxUg3kn9KWrlPX7Kc5HENBZgz2PrKGiFH6VFy7dcMgIcaKqho9 cx9N+0pprYbh7uLOhz5GEvrMk2FgsSlkZsXiMISj+LJGIKTjtIo9fcofEQk9ONge8X7bur8bBJhQ lNqbDC4qH1teOkNlg7ID7mPmLSnOflQf6RP2Z8KECRNfMkE3D+QmBkJrfQe/eWI1f97YxcThSSQ6 JVoauznY6GfsjGKuOafgpOVMvniE+en9H/BxS5jCvHiSYxW6W7vZechHXkkOP1xcEL09+IwZ3Qd7 GAmq+IMahLTIv//LYO4FJkx8PaGepNqHwMkrRQhifzJ7MmLmD6pkDkvjwW9PZXIKhLS+/NpAVCxk Z8T0a1TvUy71JJsVAO+/sYO7/rSbxKI8Hv/ucM6ZkEp+mgORbs6/9j22hvVPLbOe/C1C/0GHdB1N M/jmzTO5dowDccCUIK6e786bmIvx+naWb+ogy1nJJo+DX87NJzm2m9MSNvDWsgpuK85l5/4QE6/J 6iGGn3Y3FgQBWYpkyNcGNMGcmKCHVR0kEflzShzal9QLR71Hi0viyZ9MpDjNjnaUZ6auQ16BCyvg O65ZKZI0VwSkaOv+aEJEu/VY3wFDELEroAa1YySi6/oJl7cZc27ChIkvlaCbMDEQYhJdLDiniA6l ltq2IJ2eMCk5SSxcnMc1ZxcyJNnyFbhxlbnuG6NI2NzAgcYAnd0hYpITuPOsUdx6WQkFsdGSQAZf SpyYIIokZCYwY2omhUlm0jUTJkx8jWAcS2AFI0K2j3Z5jnPKZCXZ6G7Rcca6GDPC9QV0KMzyLS20 BmJ4+u6pXDS2r8dSpOTaF4GiTCcY0OGFKaOPX2Ujoh9h+JQs0qRtrNlSTXyohozhOczJEAgFnSye m8o9H1Syca7MQVXhWxMyB2WfOMaKYBgYUZfrYCBMfbNGbJqdLIgmixUiiWOj5PUItZUl4SgDg0yc U0EOB2jvDh1jLJGlz8ut20Z+ggwVAVzpCYwfETdo44Mo9h/8obJO/KpOSUYcApCXFEkoeKjegyA4 +5xTBIwuD/V+gZQ0+6CMUn0X/jFu/WYMugkTJkyCbuJLPYcZBlaXnfPmj+a8+aOP+8x/VTNFleOF F43lwovGnuSQJHwpMhMUmdFnj2X12WO/1HebMGHCxKBIxgCUROjH9E7lJCFgc8iEfGHq2zxAJIGW quq4UlxMHZfGY8tLWfJWKafljSc3wRKJHdY0mls91LWHSU52kZvyaYtV6ZH8J06ZYF+PJUOn8WAH HZ4wgv3zl+T4KdkUJ+zhpde3c+20eKYNjeupD+/1BKhrdNOlK0wuiuT0EOOTmVdo4eVN1fgDrVx4 02QALIrAglmFfP/FNdz/VwVrQgyzJsQwaI8vw8DQej0OBAA1wNbtNZR1Wrl6VAYxgKaIxDoUOjr9 1DR3QUlKJIeKqlJxuIumbo3MPiy9KDeWEUlh1m6vY/PcHCZnWFDDKt2eAGW1HtzaZ1T90bPDOTPT eX7zLn797/2kXlfChDwXshiZv7YOP/v3dzBkXDppdrnHTuB2R5LY2hUR0GlvdfPY6wdRZQsLpucg AJMmZZCglLJ8dTmN5yST7joSNqGy8sNy6nWB66ZlDNIgAHanAkGNmuZuIGKQCYc0JEVCNNW7CRMm TIJu4svCYEjlf514DjJBy5fVz4HeY5JzEyZM/NcR1qirbOaFpfsJq/0JuiEIJGYksXBitMCWboA6 UDlOI5IQVetzW263kleUiitQwXNvlFIYpyP7Q9hsdhbOyWH6GcP41oZ6nl66h8ubvdx4bi4ZsRIt zW6Wr6mkwmvhnptPIzfFhhFNuKmfkke6ldOHJ/D8ir38/c1ylFCQVIdAdWUzL75XztYqN8mpg4tB 1zUdNKFfEr0jUFW93228kJbFQ1cM5XvPl7P43o+565JixhfGQDhEaVkTb62oYuicKfw7StAFZOZN S+P5JyvZkBDPL2dGsrQjSqSW5HJGisCKrfUUnzmWEmVw/NwADE2lrraVZ1ZUMzzBgmDolO6q5fFn 95I/uYDrzokkj5MSbBSVJKG+sYslb+4hxzkchxpi5556Xlx2gH3VIbLF3tvkMaMyWTQ3j1+8XcG9 us7lZ2age71s2F7PR9uaCIelY7LBD8zDDTTNQNSN/lfV0e+ed8FortzRxR/f2MZ327q5YnYOhalW ujs8rN9Wx9/famDZG5eQmhvxvpAkkc1ry3k8NszovBiEUJCPVpTx9zVdzFs4gctG2xEFcA0r4M45 6fzsvTJ+sCSBG85IwS4Z1NY0c9efysgalsm3z8/vEaShG6ANtOYBRSKtKI1M605eeWsPU3IUkmWd brfBZYuGYjd3FxMmTJgE3cSnwXGz35rk0YQJEya+vnu+KGJ12MjOi0OrbuK7j9Ufw/sMSWbkGaNY ODEZUZGITXQyNC+OlJj+xwSrRSYjPYaisEiMpfcoMWZcPr+8tonfr2jizgdXEjZkLr1gJIvm5JCe n8qDP5xN4rM7eXNrMw/8roaAamC1yiQmOJlzZjYTh0Zi0GPj7BTlx5OeYD2lsV6xeCRlrUH+vnwf 31xVhlUSsThtzJ+ewbSwiJHuwGmVTtpOWkYc+fkirmOelSjIi8eS4cCi9H62+KYzkeNc/PnDGv71 nx38JaCDIBAXayMnO53F03sT7kqSyNln5JO/vJv04gJmpfa27nA4ue6iIRz6qJOFZ0WJ+yB0s92u MKQwkUZ/iEd/uxqfCpqq4gnCiLGFfO+6iZyRG50o0cb0M4r4/nmt/H1DFRevq8Bmk0lOT2TKiEzi Yq1kJdp7yKY1OYE7rh6PXxN4bVstP955GMUqM3Z8LnNG67zpbqOPn/lxYXFYKciJQ061HxUPHh2f M44nfjCNrMzdvLmxkV8/VU8grCMrMsmJdubNL6YgwRpxxRcFEARkQ2Pph/v4Z0eQsCGQmOjkmsvH 8/j3JmDtEZvIAz86k2ZjHe+8uYWPl1mItwjUtwfJL87hnu9OZ2JS1G9EFnHGOSjIjyctbqCwNJG0 /Bwev2UEv3ivjh8+sgpNkBg3Jo8rFg3ly8pvY8KEif/DBP1USdupPW9EvZqEft/HjN/5wiEIAoau 43MHafZpJCXYibVJpmA+/2PxMWvcjFEzYcLEf2PP13WDvZUdhN0Wblk0/Ph8ShCJTY5l/+FO1JBG ICGR686zkWj42XdIQ9Mj9CMUDFMwIodL8gR8tZ3ssxhohoGsSMy9YBxphY3sawpid1opKkhg36FO NM1AsVi4/uqJzJnRxo4D3XSHDWJcVkYVJTM0w4nq8bDPIxByOFl8YRE5sQJlhzsxtEFkCzcMFKuF yxYMJy7RybZKN4rTxqTxOZw3xsX6bc20GgrNjW5C3T6OF5IuSQJZY/K4MUegvcFNaUdvSjJZCDPv 7KH4Ypzsr+pA6ZMVfsyM4TwxJpMNu1pp6A6DKJKdEcfk0SnYdI3Syo5e3eCM45aFRSTlJbO/qoMe RwZdZ9iYAm60eRiVYWFfVQeacbL5Ba87xBnnjGKyy0mm4mfZ5mY6AjrZOcnMPS2bCZkipQfbIw8b YLHILL5sHLbUQ+yr9+GMd3HWGfmMSlfYsrMezRVDTWUnHUTm1eGI4eZrJjJhQjMHmoPEJ8dy1tR0 Vr66hdc+aae9009FXTfhAZKtHVmDWhfMnjkEMdZBXV0n3a1i/3K2RqRM6jWXj+f0yS3sOthNd0DH YlMYPiyFMXlOAm0eytpFOut8hEIas2eN4NaJNvYecuNRDfLykjmjJJ62mg6a+nREFEXuuXUKRR9X sa2ig86QwKwZCZw9I5/RiUYf2Rh022O5YcEwsixByqo6+q8TI2KLGD9vDL/MTGZnTQDZJjMkP5GA N4TVaTE3HBMmTHx++vuS2x83qr1JbFxybb8PdF2ntLSWg206uj6AgjQMFIvM2LHZ5MWKp/xivy9I RWUHgsvB6PxYcya+LOroD/LJR2U8tqGLm66axPwSpymULwhqWKOiogWPZGVicQKiKRITJkx8BmzZ soUhQ4YgRlm21+vtMZD/4k9vsy84DqP2Xa5cPJ9bLj0tsg9pOv94az+yLGG3nHgX0jWdQDhyAyxJ IlZZIBzWCPdhioIgICsSsmAQCmn9SKQgCiiyhCxGwotVVSes6f2+K0kiiixEK39E3cY1veeMIcki FlmMfFc9tczroiRitUgR8mwYqOHIeCyKhIhBMKz3Zoc/DhSLjCJCIKgd9ayAzSohGAaBsH6MC7wo iiiK2OPyrWkGYfXY9wmCiM0qYhyRdR+2LUoitgFkfsJDnChExmcYaAhYFRFBiMxlMDyQDAUkScBq kZAlAUM3CIU1whooigjR/xsIiKJBW7sfT9AgI91FolNGC2vUVDXx1zcraLLGceuFQxmdZiV0ov6K IjZFxNB1wqpxgjkQkGWxJ2GdYUTWbyScwkCQRLz7a7j35YOMmTaCG2el4bKJCICm6YRUY8DQBEEQ sVoj6yIiG4NgSD1KxlH5KyeWvyBE+qhIAroBiiQwtjiZotw4c4MyYcLEoLF7926ys7N79Hk4HCYU iiTkrKqqOr6Lu6rq/O53S3lmRRCSHVjFo+ujGsTFO/ntby/7VAS9oaaNH/70Q+SxJbz5wGRzpr4s gq5p1FQ08vrHzcyaN9YUyBcIr8fPr/7fB+xw5LDp6dmY9nUTJkx8qfu9YSBLIjdfNMIUholPhaXL 9vKvj+qRHQpOq4gWDLFnXxttAYErFo/g3mtH8GUWKvGnhLjv3xUMGZ7FjQsLvzKGbzNc0IQJE58n jkvQBcDhtCIkK3zv7jMY4+xbRxMwDCxWhakZg98e+7qyG7pOY7MHpTN0nOdOnFhrMM8c6edArsWD 2UxP9sxgN+QjWc6FQXzveHHi0cH2i3A6ngxO1i9JlpCsMrJ0ov4CA4UiRF3Bjg5JOPLOo8d66rIb wD18EDI93voY1Brp1x8Dwzi+K/qRcjkDubAf/SVRhNZWD7WO4DF/aKYyN2HCxBcNc48x8RlpJ4aq UXmwmY92NxAK6YiyRHKig8uunMTdFw8hSfly9VlIViguSCA9ViIQ0nFYRPNvzYQJE/93CHrPA7LE woXFzDhJikpV1Wiod6NarRSk2Wlu6KSqxU9IhaRkF0W5MchRAqSqGlW1bkKChBEIsb/Fi+ANIyoS yQkO4h1Sj3Job3VzoN6L269htVnIzYwlJ8XWsxkaYZXmdj9eQyQn3YliaDQ2e+nw6SQnO0iOsQxI 4gRBIBQI0djmo6UziCegohsCDodCVnos2YnWHsJ5vI1XEAQ0f5BDLX4c8S4yYgWqa7qpa/WjCiKp qbEUZzr6ENdeYqcHguyr6aalM4QmCCTGOygqiMcRdc3TwyHK6/044+zkJlij6UcMDE3lQK2XhEQX yUeS9xgGIW+AyrYQiQlOUmNPnvtPEKLJVkIBtpd30R3UcMbYKcyJJdEu9Yzb7wtS1xzAEWsnM9HS +2V0OjsDNLlVUpIcJDrkfqTZ7w1wsKabNk8Y2WohL9UOhkEYifRE2wlcLSPkuLPNQ7NbIysrFqci 0NHupaU7hM1lJz3BiiXqR9je5uFQg4dOr4psVUhPcVGU5YzMWbQ/LY1dtAVFhufF0NnmobLRgzug 44qxM2JoAg6R3jmKvt/f7aW8zku7Jxxt18mwDGe/NaHrOo313XhRGJbtBEOjpt6DX4O4OBtNh7vw GiJoKqWNHqxBFUEUSEhwkuwy8zOaMGHChImvKjeP6M9zzxnO6LGZHGzw4Q3oyFaZIQWJDE21Rx/7 csusOgoyeeQuOylZSVhkkxSbMGHi/yhBNwBNO3lD3m4/f/nTWg46Urh6Rjwvv13OJ+WdeIMGQ4Zn cOPiUVwzOwMZOFTZzGN/20FlQEAur+O2+1eghzSSMxK44fKxnD8mDjUUYuPGQyx5r5Idhzyouo6K SOGQVK5ZNIL5k1Kwi2B0eXjlP7vZFrCzeFomrdUNLNvcxMFmjRuuHccNZ+Uc17V4354qfvPv/Ww9 7CekaggGSIpCSUkG1y8uYW5JAjZZ4ET6J1jdxE+fKSOnJIcia4A3V1VTWt1FtyozZnQmd94wnvkj 4pDEXmLXVNPC82/t5+0tLXgDKiHNwOqwc/bcYdy6aBg5MSJawM3PHtuEfXQh/7x1eORCWzdoLK/h O3/az+lzRvG4VqE1AAAgAElEQVTAxTkAaKrGznXlPPB+E7feMoOFJyHoggBaWGPPrmp+sa6Vl9bV 0+JRiUuN56Jzi7jtwmHkx0faqDrQxENP72X0nJH8KPq+CMKsW1/Bn1Z3ctNVo7l4TGKUnBtUVzaz 5O19vLO+gSa3is1hZdSQeARdIzUvg29fMpwR6SfO0Lv2wzKeXt/Nzd8oRvF6eGtVDaW1XkZMLeL+ y4eRFSexbethnnmjnJ2HPXiDGroByVlJfOPCEq6ckY49qrzffHELr1XLXD8/jVWrD7NqbxvNHWGS sxK45PwRfOeioSRZhB7ZHN5fxzNv7ue9bS24gzqiKJKdn8o3FxZz2czMnvWkqhr/eGodm0nh0VsK WP5RFcu3N9OtS8w4s4AD75eyo0vA62nj2w+sRNB0HC4bl186kW+ekWTuPiZMmDBh4qsJIUK+RUUh JyeJnJykATj8l+sJZhgGSmIMZ0+L+a/1wYQJEya+EgRd13X27GkhJtbol9HSwECWJXJzk0i2CwSD YT5Zc4CVwWb2ljqJS4plxpRc/G4vqzZU8f1aLwXD5jMr24JikUlJsKEIXSgWhcxUJ0ZQJSHRhtMm AzqfrC3ne3/cTqctgYunF5CTpNDS2MlrHx3izoouxJ/M5KKxceAPsHtPA8+VBtmx9TA+fwhnrB09 aBAMaJwoxUxHVwAUhbEj48lLtWOToLWlm9eWlbLpcIBXH5rG5BwHgnD88hlqRzcfrK/Gv7mZZJdC cWEis09PwN3h5o3lpexuM9j2h5lkxciRW/uuLn7++Epe2KuzYFoWE4bGIoZD7NhTz8OPraQ+JPPM jUOR7A6ayw6zcp/Gb28dTgKg6QbLl+7l/fcPsa1D5n8uzsEBhEIaSz8uZ+nGID+6/+TVOAVBwOj2 8fq7pSTH2xk1OguXpLFrbxO/+uM62oIiT91cjAi0tbp57+ND+HJzj14ZVB5qYenaJmadPeyIPqel upmfP76a57a6OX1yDpecFoMWDlNe0cxHWxrIn6hw1Xknt/hUlTfx/uoGmt0deN0qgmLBqRh4vWEk SaR86wFuemgDIVcccyfnUphmw9PuZtnHB7jl4TbiHjubC8fEo4hQur2GpTtD7K+oIzkjjrEjM7EK Gtu21fDgL1chJcTw43lpSKKAt6WN+x5ZwUv7dC4+K4/ROU68HR5WbzzMNT9qIPDoudx0emJEAprO pnWVvOXtgK5ath0IkJnmxGUDn18nLcWBTYKALJGR6kRSNexOGzF2M3O+CRMmTJj4ajP0k/HeL5sY D/Q+k5ybMGHi/xxBFwA9FOaRXy7HKR2dJA5iYx3cf/8CFg2VEAQBi0XG4XJx4w2ncf2cXOIsgBrg qd9/zG2vNPPq2npmXZFPXn4qv/7BNA5e9xry6HxeeHBqv/c2H2rkb6+U4k7O4v3fzqGwT6LxiyYn s+jHG3jpoyoWjB2HIgpYrTKqz01qXh43LRjK1GFxSJqO1WE5YWKuCVOGM3Pu2B7qHQ5rEA4Sr/p4 6KUqtlePYXyOA/lEEdWigNUiIicn8LM7xvONWVlE8qUEufG2V/n76gNsbp1GmktGFmD5m1v4yycB nnnifG44LbFPQxr221/mqSXb+MFVQxhmtbNoZhor325hXZ3GgiwJLRzgpTWN5AxPoqWynverwlxU oBBWQ2za10lO0TCmJ0TMJyetxynLTDm9iEduGcmw5Mht9v7tlVz7o49Z9mE5a88fxsxMEVEUsFnl AV3JZElEtEooYo8EeXPZfl7c2MllV07h998ZS2I0eYxWU8clP17JXiGSnfWkC1ORcAhhOnFw67XD OWd8Cil2gbAgk674ufNPW/EmZ/LSw2cyLq03Q8098zMoueYD/rS0mlnDYkhySiiKBLLMpVdM5I4L hpIbFyHIezbs5fx71vDYX3fxndlnkWARePeVzby0xcdt987lL9cM6TUY7KzgnLs+5gePb2bRS+eQ LEZu261WCbxhSEnnL9cOZVyeEwsG2KwkXzmUykV/Z70zlX8/NLvf+EyrvwkTJr5MnErOFHNvMjGY tTHYnDNf0dF8AeVQj1NG+EuS0ddrfkyYMAn6iSGKjCjJIMtiHEPQHU4ryfbejUlHJDUzjbvOzaWH Jsoyp03LgecaqO0O9Hzf7Q1F6n+q6jGvrDjcwcodHaROTGHlx/t4xxPGEARkWaK1rh3RCFHV2E2l DsVChFinFWXxgxsnM2uo/egd65gN98gmFhOjcKCimfV7mtl3uIvaFh/ugEFtnRvEMK0BjQDgOomI 1LDO7NnDuXJGlJwbBghWZo1LYsnGDg50qOh5gKCx5O3DiM5Y3DUN/P5Qfa8xRBTxChK0tfJJk0ZR nsTc03PgrVZWbGllQVYqrQfrWH3Y4OcPTuKpR1fywvs1XHRbIf6uDrbWGkw7Nys6vhMrGF03UOId nH9WUYScRzfxomFpXD8vi9vf7mTTnlZmZqae0mIK1LezYVcjlrwsvnHuUBL7JI+RZAmHTcbQB1c6 BsPAo1l54rYpfHNqcr+PWraVsanaT2KJwgfL97NWpqfUT5wtTFgV2LC/mUC4GJAiK1GO5fZLhpIb rftuAKNOK+Hc4i08va2eMp/ONIvGC+/XQlISP7xqSM86FwQoGDuM60/fyY+W1bDikMqlhXK0HQF7 QhLP3j+No4sFdrS5CelgaDpBoK9Tv3kANmHCxH+DiBihIKWVXTR1BAioBlarTFycjfQkBznJ9mgS TJOkmzh2HQmCQDio4g1qWG0ydos0qPuAryaOlFzTWPlxOVVhO9fMz/+M1VYibbo7fXy0qgo9OZmL z0j7UucnFFTxBjRsDhm78r95fkyYMAn6Cf7cQbEoPPTQLE4bZE4rXdPRoU/pCxEUCzbDwBhUSVON ju4ADZ063qpG/vxiO6rem1VckkWSc1OYXpyATeslc3ar1HsA6bsfDWQ9jCY5W7uqnIf+toONNSGy MmLITXOQGGvFZZVAENAFY9CCDIU0fEENq0PqCVh32WwIYqSuaKRjXkobDCTJxz9e3dt/0zTAarMw Z3oOqWJkvMUTs8mStrFmWz0sTGXlxwdQs9K54pwhNL2/hadXH8BzWyH1ZQ00ygrzJmUc0REnnyfd IBBU+8gDBIdIVp4LAi00ev2nvJga2oPUtgYoyMogNcnRj4ga+sD1SU+4+iQFq2TQjykDe6u9qDoc PljP883NSELUu8OIEOb8ESmMLkrEKon92vP6VQybhAAI0faGFNlhWxuHug2muXzsa9BxDEsiWzyS MC6ank83KBmaDGI7+w74oLCXjguyJUK+j05WYCpFEyZM/LdpVR9yfri8jueXHuTdjY3UtgejBmyR 2CQHxQWJzJ6czVUXDCXJjMIxMQD5BNi3q4bnPqpjxrxiLpiY8r9ez6maxu8fW86bXeks/swEPYLm hg5+/JP3CUyZ9CUS9MhE7Nl2iBdWNnHOguGcPTrJPIeYMPF1JOgR5W7gdgMJn3a7iPwgnPypfieK sGhh7pwS/nDdELrc6jF9csXYSFP6cF8D9CNlxwbRL39DM4/8bRur6yX+5+bTuHxGBoUZTuyKyPK3 1rN7fye6/hmlKxz1gwCiYUBCCi/8cioWUegfNxAlyxnpMiAgxqcwZ6iVl3c00qEF+M+aRqbPnEaG IrDw7AIefXAf75R68OxuxRbjYtY412fkhQIYwhGzyvGtNsLAc6frEeIvCp9XUlejdw76NCgIEAqF mbNoKveem0GCVTgmP4JisxHvkDnZMPSAAYaIU44sIg0Qj+ODH00cj360F4BhRHIdmDdOJkyY+KrR qmjlifbaZu59dA0vb3Ezb04hl051EWcT6eoMUNPsZvv2w7yz4hBj5g3lTOdnNQocp1zoAOU7j/f8 Z2/nBCU7P7Mr8xdnTTleWdiBXZUHHuPx5CYc2/Apy6FiXz1/WLITstMiBH0Qc3biMZx8PCfr68Dv PLZk6kDPCYDLZcWqWwZ9djr+GCPHAFESiYm1YT3OGWQgV/RTKb17IuzbXcvvluwlvjgzQtA/1/kx YcLEV4agI3yBvEM34BiXZ4mEODtZ1jAd7jAxSTGkJp24iU+DsrIWyus9zD7vDO5YXES6rfczVYso ic8fDkrSJXY3duF2xXJainxc8hg5WEmcdXoazz3bxFurqlldafDEz/IAGDW1gCLnbv7xdhUFlR1k Dy9kuAIMsuSJ0IeI9tQw92vUVncjOSzkJR0h+wKipqGr2lHUVsKiCP3klByjkBprZWeLj/auAKT2 hhsIVglZEkD97FIsznHhtMrsO+whOyeBdPvgFqiiiD3KJ6KgQmwu80FsPCNjRVDsDEkSOFjfSbMu kC71ilMQBSoOdYIukp9nH2RPjUgDmvGZla4JEyZMfGpVq+m8/952Xv6kk0tumc5fbhlFch+dZwQC rNlWx9qdLcSdhJQcu3cdS6p6ftY1un0aMS5L7++i//i8QZBkHDapT5nLgdtRQ2H8KsQ4lKPa0XG7 Q1jsVqyy0K8dhF5yFvCH8IV0LBYZl13uISIDvfNUyNngiPAJSOcA3zvyVNAfwhvSccXYIsb8Afvb O8agP0TIEHpk1FP+7Ei7R2QZDNMd1ImNsSL3kYMgMKh+xjgVYpwKsU7lOAQ18n0tHO4pj2u3iCeU WT+CKERk5veF8IcNrFYFp0064Zwd+dnnDaKJEjF2uUc2A65bQ6fTHcLqsGK3KD3G98HOfe+7dbq6 Qsg2BadVoo9tqGcNHkE4ECKgCcQ4B56fI1/0eEOENQO73YJNOSK33jPp4ObHQozTcsL5UaPzY7Nb sCsnnx8TJkx81Qh6lGMce9Xbl+p9ihfLEi6XSHW7mz1ug1ExAug6YUOkqCCJcyfH8c8V5TxUksRd 5+WSGq353dnhZv2WJuRYB7OnZvJpq0nLkoAkCnR2+PAGDbBFxtHR0snKne10+vRBJTM7VXFfsyif l3+1l+//fiu/uW4Ek4fEIkKk7nlVB2s3tXDhlaNIjXrKz56aDX87zG+e3EM4L53zR0bIoSU2kUsm xPLwR3sZYYSY+c3s6HQNzgKq6QbBkNZvwy8tredfK5sozMli9piIVcRmk4m3h6lt6KBWg2wpoiwO 7q1nzY5WBKX3rj0uK5bRwxJ44dV63l59iHFZRSTbBdrbvaxbXcOuai9KTspnlmLa6CxmDo1lydoy nvhPHLecV0BhNNGdp9vLrr3N1IasLJiahsMqRdaoEWb/ITd5IxOxCOB3e/ngg928U+Zj+uUTyLEL gJXFZ6bxwb+a+PPSOh5ckNUjm/qDtby4sZnYrAxmDx2cE5woiMTEyng7PGxqCjMjTQF0fH6D/8/e ecfZVVV9/3vK7WXKnd57pqVOkglphNBBQDoC4iMKWECFByyPjccKvuqjqIAICIgECL0FSAgkQArp yaTNJNN7vzO331PeP+7NlGQSgvogj57fhz/I3HP23metfc7ev7XWXstuZHI3YMDAxwRV03mvrgfJ beaSC2LkfCLREaxWli4sZunCIoJKzAirRhUO7m7njUNBzlhayvRMeez6gD/EuvcP0xa18ulzi0kT QQ9F2L27nfc6FGorU+lv7mbN7n4GAiqZWUmcf2ohi8pc1O1qY9UHXdR3+hFMZmbNyuFTi7LJS4gR Pn3Uz+rN7XRhY0aWjfqDXbx/YAifIlBYkMLlZxdTliSw4YNW1u7opbkvhM1pY8GCAi6Yl0aiVYqZ kbUQr77dyub9g/QOB/GFNCxWEzmZbhYvyGdZReJYgtNI9wB/XtdBTkUBS3IFttb1sKfFh18xcdlS D6s29ZKYm841C1ORJTFGYuKyaNrXynNbB5i3pJzFBVbEY8hN/KyzprHqxT00aG6+cWk+27a1saVh mJGowMw5eZxdlQhAc30nL73fyb7WUbxhDU+Kk5rqDM5fmkdafJ/iGwnw6qp6fO5kTiu38Oq6Nva2 +4giMW1aGucsymdGlnUC2dLp7RjkpfWt7Gj0MhzSSElxMX9WFmfNyyDVLo1d23q4l1UbuqmoyWV2 rol1mzo40BEgOTsBj0ngtXWd+HR4a90hxFEvaihKZl4K59RmkZNkpqttgNUb29l2eIgBn4rdaSUn w8WCOdksLE/CaZk6Pk8QBFADrHy9md2NXnqHQ/jCGnabmbzsBE5dWMCSMtfYmhxs7+NP67uompFH ijLK2m3dHOjwocpmKkpTuercYrId4mRyrkZ4450m3t/TT8tACKvLRmleIu2hD/drTCSuEZ+fV9a3 sOXAIJ2DYUw2MwU5icybns5pc9JiRn0hln+mo3+Il1c1srtllIguUlKaznlL8piRbRtr0zs0yjsb m9lQP8qAN0QoquN0WinMS+L0BTnUFLnHjts1Hezm9Q/6mL0gj4pUkXWbOzjYFSQ1N4lEQeWlDT0E 0Fi1pp5ATz9KKEpOQRrn1WaSkWCivbmPNZs62N40zIBPxeGykpvhYuHcHE4pS8RuFo0PpgEDn2SC HsvfpqL4Vf5w3wZet4I2gaTrOtjsFi65ZA7z0kV0HSJRhbCiTflhC0dUohM8iakpTk5dkMmdL7by tR+vZ0mRDUSZpYtKOL0qhRs/O4edv/iAX92znt07CpmZ50DQojS1DPLGpn4uuGg6Z9RmIaATVTQi Ue0jedMrKjOZW5zIk+sO8EOHQm2xi7AvxKbdXXywpxfNp5xce5pOODr52SZ6LZSIijrBzXzeRXP4 +v4Av3lpGzd0DrCs2kOyXWRw0M+OfT1srFc446rqMeNrZlU2FVaVPXt7OO+mMziS990ki1xwZiE/ eX4j+zIT+cH8jKMNtidcaPR+H39duZ1oVwZJNgnv4Cir1jWy1WvmhzdUUhnbK5CTncDiuck8uOEw 37jbzKmFdnp7vGzb283GvYNo7kTUI4IyOzjv9BJWbejiT49tpbmxl+IkidYOL4dbhznYF2Zawcl9 /FVFQ4lok2Q3tkiaXHzz8zPp/90W7r53E9t2dFBT7MYsaLR3DPP25jamnVbD6XPSsFti/FzWAtz5 6428Up5Esl2iv2eYFasayZ9dyM+vLR3bqF1+VQ1PbFnDT3/1HtHucqozbfh9Ad5Ys58tQ1Z++N25 5JnG34FoRCUsaUeZr2ILqc1q5sxlBay4t4Fbf/Iu5093oUY0Zs0r4bJaow66AQMGPh6IAuQm2FDD XtauO8z5WcW4LcKUBndbfFeghqNsWF3HbSv7+ENu4RhBBxjx+nnosY2sHkmi5uw4QQ+GeO/1vdy8 souamiyU4RECoowQjdDUXc8b23u4aFYib69v5NCQRpLLRGfHMA++fJjOWxfz3SuKsQHa0Ah/XbGd xw4qzCt04R8JoJtNBL0+/vxSA9sPDzHNqbBmYweDURGXTeRgwwCPrG5F++/lXH1KaixZa3SUR57f y3uHAuRmOHBaJSLBCM+8cpAn1rbxq28v5ZyqBMwihJu7+OYv36dwXj81CWE27OmjfSiMb1Bk1ozl /O6PG2hxZLLwifMoSRTjjk8BAY0/3r+Bu98a5cm5ZSfeKmgqf7rnHV4cTSMy0sWKlxpp7gsRUuGy 622cXZXIgR0N3H7PdrZ3a1QWJ+I0w5YtTfzl5Xq2tdRw9w2VOIChAR+/vHstWy1pnDfLwf7WIHan idEhPw+v3M/7V8zm17fUUOwWAZ32pm5+8JtNrNw2SF6BhyynyJbt7fzllXq+eN1c7risjNR4JNqB XW3818/ep2hpGbU5Aq+s76RzIERJTR6zUq3s2z9IENhd10Vn6wDRcJTp80tYMDMLd1cvv7x/M49v HiYzy012oommtiGefamOV5dU8/CtNVRlWo8vpLCX362oo8mrkp1ix24RCfmHWPHifp5a38Hvvncq SwrtyAL4G9r4+l0bKZmeT4oySo8fXE4TQ71DPPSkwO4hnQe/WIZJiG+M9CiPPLaFH/65jj6zi8os G4I6yNsbWukfAMH1IS9R3NARGB7ll/dv5nevNiN7EqnItBHxD/HK6no8Bek8fu+nSBNBFnSaDndw 84/62XnYh91hZmTYz0PPHmBLcw33fL2G7LjMe7qG+OvzO3mvy0x+mhW7WWSkoY+Vrx7k2c3F3H1L DaeVxKIa92xt4ls/3casM8uoTFZZtaGbzoEgFbVFVLsl9hwcJgJs39lB8+FeIqEocxbpLJ6diaW9 m7vu3cTTO0bJyU4g0y3T1DrEyhfqeP30mTz6jdmUpFqMD6YBA580gj7RQmg2y1SWZ3FKMELbnk4a 9aNymuk6LreNpefHCJfLaWFuTS5p6Z6jzi+LJCc7Oa02m9n54/nQXR43N3y2lmH2sKm+j5VNOiVl 6SxfLgEi8xdP4/EEO4+93sSW+iFePtwLkkiqx8GVl1ZzxVlFsX6cNqor0hkJuUh3m076wU2pHr59 w1wsK+p44+161r4j4HBamTe3gC+WJbF+xwDFqVbsH9KOw+Pi1LnZzChwxsKwJiArN5ll83MoTjZz xCgpuBP41bcXU12dwZrtPWzY0kY4Hs5UXJzFzz+dRY48vlmSHcnceHERzzdpfPn8gnGpyhJzFpdy 6fIOgskezpx2kl5dq4mc/BTmzQ+SblF48sW9jIaiBCOQnpvC3d+p5KZzcsauT8tN5WvXL2BQ28WG tftZqwpkZiRw1uI85s7I4P3WKEWp4yHf0+cW8T/fF7j/+QZ2NPfR1CiQk+/hxk+l8tybDXQhYrF8 uJ4KilNZVmsiN9l6rJUdqFxQxm9cdha808KGugFef3cIRQdPkp0zzq7mknMK8DhjgpQE0EQLs4rt NDX0sXE0itlm5sorarj2kioWTwhZTyrI5o/fXsQvnqnnuVf28ppJIqqo2D1J3PWtMu64MHPsWqtV ZtacHAJiylHzJP4O2cxcdflcmnwy7+wZ5Nk1A6RmJDBroeE9N2DAwMcHSRK54Owq7lnzLg8++D6R zl5mFLjJSbWTle4gJ91FYbpt8j5AAItFxuQyY5aPJvwCdruZBNU8vokQBKw2EwgQkSQ+/7l5nFKW hBwN8MxLe/nFinqaW1K58MxSbl2QRYHHxMFdrfzkj9t5bk0T5y/K45RsE4gCTocZggEcaQl86dpZ zMhzoo56+dWDO1i5che5lZlcfu50zpmVRoZbZMNbB/juw3U89XY7SyuSKUyUQLTzxatruMlqoTjL QYJdRo2o7N28n8t/vJX7VrUyr6CCTJeMIEl4kmwc2tuKtTKDSy6aQVmWndCIQs2MQr51Xi43PtHO szuGuW1pCmYp5hUPtHXw5NZhKk+fzacr7DHv+XGPmQk4HBbwB3j87V6WLivnq4UubCKkF6QQHhni zt9uZpfi4cGfzOWU8kScJuhoHeDBxz/g549sY0FtHtfOcCKKIi6nCbMokF6WxxevzSTfY8bbN8yj T+/k0Zf2UVKazq+uyCPo9fHXlTt4bPMwn/vcAm47P5dkq0h7Sy/3PLKd3/9pG6mpbu44J7a2ySaZ VJfA3oY+PK5MvvjZueQmmnC47ZTkung3TeB7fznERedV8eXz89FCURwJdqoyzTzxwH7ue6OXqz8/ j9svLibNLjI0HKBubxf7/SbsHxbyKDn5zxtqSUyyUZDuwG2TiISi7Hh3L5/+yXb++GYJNf9RjNsq IsgSCW4LXb0+lp9fyqdqs8hJMjHUM8Q3717HY49u4/YrS6l2x3RVv7WB2+/dibuqjD9/oZKqbDui qtDSNsj3frqOfSf2aoxlsF/12i5+9GQDi8+bw53XlFKSaiHiD7P7QDfbm0aJROJ7AF0lEIpgyczn F5dmU5JhZaCzn/sf28bLbx/i9KWFfGVhzOXiSUviy59fxC0JbgrS7DgtIpFAmGdf3MV/PdrAE6tT Oa2kMrZ3NZtIdcOO/b0452Ry0+fmke2WcSY6KM1xsnqlzg+fauGKi6fzH8uz0cIKzkQHZakmHrqn jgfWDnLTl2q55fyCWITjUJA9dZ0cDFqwGlsTAwY+mQT9SChQQ9sIh9u8mFLSOatWn3qt0XUkWWLw UBtrugTCYYXcGbmkWky88UEHgqpxJAu2zxdi6YJMEpUQb33QjqrGFjBZEli+uID0LC8hRJITbQx3 DbK6fwhdAKvZxPJF+eTmJNA7oiCIIh6Pg5IcF1IowJubfOjhKNb0ZOZoEvv3ddDdLB2bxGuq4SPg sJhZVJuHNcGJNwyeVCcLZ2cgBwPIZiuhrmHeCASQjhfeLwioo2Hmz8rCRYA1G9uQ41W9BFFgIChz Wm0OvqZuXu8VxwwXoixRWZWF3WWluSdERAOLxURBXiL5HjNvb2wb61EHEkuzOd2jEunt481ebaxv TdNYtjgXr2hj25Z2dEX/UAuwrqoMamYuWJJHepKNjtYBGvuCiGYz5cUeylNNvL+5nagWD+ETRdBk zl1WQHL6ECEVcvM81FYkoYz6Ee1hRjqHeCvgR9F0REnCZbPzqdMKKWoeJYRISXEKKaFhwuEo4XCI D/Z0MdwhoqhTj1eURAYtDk6rNdPZPMCbgyPHJBvQEbBaZRbPzSE9xUX3SBRVh6QEG9MKk7BHgqze 5MdkFjnkVdGwsGxhHv5iPz0jEWSLmepSD6J3mDc3DR05xxFr1+bknEV5JHmcdAyHsdqsFOcnM7/Q wdpNbWND0XQdT0UOSwQLr29uRzx63gkCoiiw+JR8XMlu/Co4nBbcahBINL4+BgwY+F+Hrse+49UL y/jt14M8vLqZZ1/cxWMDUUzpTgqzXRRmJ1I7O5PzTy1kfr79b+5LVTXEFBc3XDuPW06bUB7TF+Dx lYeZNiuf395aM1aSckaGzLYdrdy310dHlw+yY9loFUUlpTiDb31xHudUHDHsp3Dhzg5eerePSy6s 4hefLeMIn5jujLDy3RYOtQwzPBKGRDu6ycHZCx34vX72HB5iS0+AIb+C4Atjtpmobx0iEFIgfnxO VVTyKor47bdqqS2YLIOrLq/kpy938Kcn67lpYTJmKdbzC8/toSUo8ftrpmGasDYJJzSSO7jzjqVc Mj150nqNpuMAACAASURBVIq2e+0Ontrh55ovzaUoSeJQ8xA6ArIgMndGBrzYw/MbOrh2xjRAR9UF 8gqzuO/WmvESnuUppFg1XtvwFu9vbIUr8mhtGWTl621Uzy3nxzdVkRXfiGSmOblNjbLhjnd4bX0z 152dSXr8/HdYEViwoJjff3s+Je7JrLozy4FZgLy8JOZNmxwJ1todIBgQKMlNpDwrlmkwOdFGcYGH i7QTRznquo5gcXHRqS6G+0fZ2zxIW0+A4aAK3ihWm0xd4wBRpYAjaWxVVWPx8iru+cb0CTJI5cq3 97Dt+V6296tUuUUENB5/fBcDupN77ljIlVXjWRArS1N4+r517B0+8d4JYHQ0wJ9XHMCencWv76hl TtIRTTspKvTwaVUhAPT26iiaSMm0HO7/Tu34aj8tgVD/AM/+8hAH2oaBZHRdx5Pi4rQUF8N9XnYc 7qezP0AgotM8rGBRI/QM+OgF0uJzJRwVWLKklHv/cy4Fzsms+nBmLMKgqCCZeeWTS9S2dAWJhkRK 85IoyzyiHzslhR6IV2AyYMDAJ5CgT1grEASBkpIMpoknZLlEFRVF1ZFNEjNmZSHoOuHokZBfHXRw OG0snetAUzUiynja9YiuY3XaWTAn9qHQNB1F0cZCpgNBBVGUmVaSRkV8HLFrVHxHko2ZTZSWpiKi E1W145K+qQbvC+nkFaRSUpI+dkYsEtHQLU4WprhQorGxaCfY+YguOwtnOdE0jag6Ieu4quNJT2Rp dhJKVEXVGGtHi6p4FUhNTyQzUxjLSKuoGl5f9JhucnJTKCiIhVOPPV7cols5PQsRnXBE40OfXNdB FEnJTiIzV0DTdMryEzhTjFn9FVUjElGI6OPGAVQNQRApLEpnWlkmghBbFCNRDZLdLEsVUJTYs4ui wOiQj7oDAawJdubOzsJpFhjo9fLoqw282xTlMwuSKEiRUaLqcRdrTdHIyksmr1AgGtViBp0p9BcM RhEEiaKiFErj80PXdKKKQiA+P2SdsRpsQVWktCSFacL43A2Ep2g3ECUpI4kLczyIYsxopaoa4VB0 UlI8QRComjEuf20KeWuajiibmTszM15zVcdqNhKwGDBg4OOBQDz7tWTiis/MZW5NDlsahmjq9NM5 4KelzUvdvjbeeL2B9XsH+N03F1H9N9ZZ03WwWU0ku63jxgEBJFkiySXhtEi4xlYXASwCzgQTUSWC oo5/QXUN3C4rDos8qR2nXcJpFUlxmuLkPN6OW8Zqk4lEx/cPghLmtTWHeGxVI7va/EiSiNksYRFU hnwKKeiT1iBV1aiszKYiwzpOGAUBHXAV5XPhrER+t/kQ65pncUGZAyns5Q+rO/GU5nDJ7ISxs94f lmBLsrm5ME7O9Qme2e07ekES2L2pnq/uODg2NkGAcCSK0ynjD07cH4hIJnmsxKceX5MSUhOYmydw eGiUFmBoyMf+HoFzzvfEyPmEazPTElhQ5mBz1ygHOzTSc2ILaVQwU1mcEiPnE64HxvZY6sTjjHE1 LKzJoHhNO795aAuHD3Yxo9BNfoaTytJUStKtiBw/47ogCBANsfLVgzzxZhP7ukJYTBImk4hZUAmE NSJM3ufouk5mmguiGpjEsbYz0twg9eELqYAJtCBrdoxgTs/n4irHpCiHaCRK9KSYqU7YP8oHTQpZ p6bHyHm8nbFnkmTs8fmqCyI2qyVGznUdXRAQELG57QiKRkAZzwHhH/bx8hsHeOStdg73BLFZZSwm iVAwzGBEQBcgMuEliwpmZpSlxsj5cfSjTKGfpfMzyF3XxS/+uJl9e7KYXpBAXoaTqrJUilItJ9CP AQMG/qkE/ciLWZafQFl+giEdAx8Z/U3d/HxjM9sGdCpyXTjMAgPdw6zb52VGbTE3X17JwkLHxzqm 1xxAVGTZKbmUOuRPhJyMRdCAAQMfy7eGycfTisoyKCqL5SxBU+jsGmVfQx8PPrKdp9bWc39tEb+/ JGfsXvhoqWB1XUeNW6rHEq4LIIqxZHUqIE8oPSoI8Q6Ozoau6eOlU49cLsbClZW4t088up0J2PTO AW7/5Qf4ktO47Mxp1BQnkJpkI00a4brvb2JI0495MEUZzycznvFbB0HkK1eU8PCmzfz+1TbOLytn 5zv72NSm8JUfziBdjtvZT6aIiq4TBFwT+tB06PUrIIvMmVtAbZowqfiHIIDFaiKrIG2yZidkCxfi shJFAYtTQtV0IkAkohAQZBxO8xEqPDZGiyzhtFoID6oE/QrEq4Afye0z1vaHWoFis2zRsjLuigg8 vqaF1WsO8IxfwWy3Mq00lc9fOZ1LF6TjNovHykmPOSrWvrqbW3+5A3tRDpeeX8jMAjcpiVaS9SEu un3jFLmKBdQJnt8j8pSkmKFhLGGfGqbTD7ZCJ7aPPKPH5a0qUUY0kexE67gsmSKzujA+h4+RoSgi TxxBNMzat/bxtd/twpmXwfWXz2BaloMMj52WhnZ+/sA2lHhE48TGo0cq63wE/Sw7o4K7FIkn17ay 6o0DPBVQMDusVE5L4/qrZnDJ3FQcU+nHgAED/1yCbhAGA38vzA4rxTlOtrf2sGn7KFFdJyHBzkUX Tecz55YyP07OP84FoGBaBgtMZkyafsxm9Z8F410zYMDAx0PPjyWIYx43USYrO4ms7ERSAgM89b06 9rYMAjmxW/VYKc0jkWFjZaZEgRgH0j/WpxFOpsu4J/vJVU3sH7Xy+2/P56tnZE64wEqiXWLwJId+ xItevmgaSwp3s3pVHY035HHPU42QlsKNp2actPf8eJAEyE0wgygxfV4RX17g/Ihq1sfIohJV6exU sZXYyAL6TSYcehT/SGSMfB8ptxVSVEYDISy2BGxO00nOKB1d4xhDgQ7IDgeXXTyThbX5HGweoaXb x+GmXh5+voHbehSKM5ewtNTFFInugSgPvXCYDtw8ecspXDlv4hEAEw6zeNIh2MdoQTSRKEO3N4gC yBNqpAuigCieXKuy2UqqrDLa5xuXZVwEk3Svn/zghnpGeO2dZnzuZH5926lcO9c99lum7CfZLqBq H2UqnEA/LidXXz6LpacUUt/ipaXbx6HGXh58roFbezWm3b2Y+fkOg5wbMPBJI+gGDPxdW0Ed3GmJ XH91DeeeGWA4oKASO3ddlO3GEt/QnUyt1X8kLvrMPGqDIulGaTMDBgz8WyHucVZUXnl5H4W1pczM sk5hpNRp7PCBIFCUFoueE0UBp1lEUVR6vD7AOvbdFqJRugcURJPwiXxmiNDnVcDkZE6Je/LPA36C YfWjhgWA5OCr5+bw+u8b+fkftvDCLi/Lrz2NiiSRE+aGOxmCbhKZW5uF9KcGHl+xnatmLyX7qGTa geFRWkYFKnKdcY0JY57icS+qyo4Pmtg1LPPpqnQcQFKyk8p0aGjspzUKeaZxj2tn9zAb6wMULHMx LevkBi/JIhIK/rG4cCH+n0b/qILHZSYrK4msrKT471WYBkf54TO9tPQFofR46dIj9Hg1sCVQe9Q1 aucoYUXjZNMAH8OPJRszi0zsau5jY4/KknRpTAayrjDg5yTmg4DN4eC0KitPHurkmQMBLiu3x26L 39vXNYjuST5Jwh/DaFCldyhMVkY6pYWT5+rIaJgBr0LeR2hPNIlIehTfFPrpG1FIdZvJyUkiJydp TFpat5e7Xu2mfTDM/HyH8dk0YMAg6Ab+xSh6LMma3UJhvmXKTc7E8LqPZTw65BR4yJk4BkHAMBAb MGDg3wWqqvCXhzfQurqL8+ZlMLc8maxkG06zwPBwkG0727jnqVYyCjP48vKs2ObAIpFX4YGhel54 dQ8LMqpIljSaWgd5Yc0h3j4UJn/6J/FLqgMWqnJsiNu7+NOLDUSXZ5NogtaWfp59s559XUE8+Sc/ 9iNr1jkXTmf6Ey08ufIAYcHJbRflIwpHXfQ3jFYQRfKmF3Dr2fX88rV9XO8QuXJJFgWpFkKBMPsP 9rK1fpgZCyvHCLokqLS1dPHjJ/YxM8+JrCnU1XXw8EsNeMqz+OqniwDIL0jiinPz+NbKw3z33mTu uDCfdIfI4cYefvvobnplN7csLYwniPtw5GY6yUo18fyaQ5Slmyl16UREK4unu3nmuQM0DGssX5hD Va4Tl0VgsH+YunYfcq6bFPeJqs3YmZVn5a33+/jtsw1cviANh6jR2NjHU6sO0jESpVAQ/kYJy1x3 cTGP3bmXb/16M9+7rIgMh0B3t5fX3jnM+/0gJn6IgUYQcLrsXH/dTF78/gfc/tN19F5RRlW2naA/ yLYdHezpCnHj7WdS/hGGmZpkoTzfzXNv9fDX5/djXpqGEI2y92AvK1bVs79HpUQ6+QYLs92ke2Se XtVAfoJIoV0nIts4dYaLx5/cS1dUYvmCbCpznDjMMNA7xL5OH6b8hLHKNwYMGDAIuoF/IXyoV/xj J8ZTGAMMcm7AgIF/ExwJSbdYLFxwTgn/781OfrSpmdzcBNKTLNhkgZGREJ19AabNKuLu62YxNzPu p5RMVM8v5mvntnDPmoPc0DWAxwz+KGSk2CnLNjEUVjHFdxGiWUTUNUIRDVGaHK1kkgSiEQVVO2rT YY4luYrdI8a7FdFUlbCqI8uT25EEnXBYiVXImNROzNMf1nXMcuyXGz87k/1dfp56ZhcbNx7GJen4 IxqzprkxSQIRRcdsirVvkSEcUVF1AYtZmnItAZBT0rl+aRq3v9hB9bIKziy2j43jw9YVWZZQowrR iIb1mJYFLA4nP/zmqSRk7eaJ9U18f3szNpuMrqpoGuSVZnBdeczraTVLyAKE/CFWv3WQJwdDjIQU IopO5fQifv25mSzJi/Vic7u4/tp5tA5sYsUL29izvZlsp0hThxevauJbX1vATWdljOtKgHBIPW44 +cz5Rdx81TA//ms937u7D5ddYk5tGTMqZ2CJBHjq+XqeXddEcaYDhwk6O4fpVc1895YallQknnC9 vu3GOdQPbOD+x7by1ltOLKgEolBT4ULUdSKqPqYfiyQQCitoCFhNk13MEhqEVQRZGjuHfvqFc/mv vX5+9tJuvnqokxQbjPijZOR6yHWq1B2ll6ksNJJJZtk5M3hgBO576RA/+/1GHA4TmqaiIzCvtpBy D8ijIkpYIaIe3ZCELEI0rKLF27SlJHHtJdW8X7+RBx7exHvrEhFVBUUyk2yXSUkUY899ZB4JOuGQ gn6cGVezsIRbrvBy19OH+M7dPTitIvMXVTBvehXmkJ/Hn2vkmbWHKcpwYDdBe/sQA9j576/XMLfQ Nem7YcCAgU8iQT9Jb6cetywar7KBk5kb/5c//FON/e99nv+NNv9d9WPAgIGjeUUsidaza5vQ0lI4 c4FEboaXlu5Rmpr9KJqAO8nOjBnZ1FZ7EAOjPPfWUCxEWBDQNY2SqkyW9ikcaB8laDZTXZ7OKVUe RjIkmvwm3l3TQr2koYQidJkcnD7DQuvBdl4cMaOoOpIk0tM5SvW8fJx2jZXrW5CiKrogIKthfJKD M6ptNNZ38ZLfS2TIhy3TwzzVwvbtLfQ1yqharFJMg1dgyZI8ggMjPLOuGVHR0AURU9RPZk4qZt3C +1taOVxvwizqTKvKYravg/rOEUbsVqaVpFBT4UELgd8h89Z7zSQ5TYS7ApwyN4dUwc+Law9jMwmT KnaMbZjMZgY0HVVRyU2TeG51I9JJhh/ruk5iVT6na06efbsJ0zFlTAQkSaCkNJXTw3C4zYc3rCHL EumpDsoKkxho7+OFnn76ukfojMq4Em3UVHrYVz+MX4WkRDs1lclER0Z5fu1QLBO8ICChU1mdyUKv ws7GIRpDGqmpLpbOySLDovL2u82EohomWaSlJ8KCxXlYwwGeX9+MdlSKc5NJRHA6Oas2m/qeIFFd wCkpvPluGwGLjWXzMtnTNMzOum5UBFJTXcyfnkGuHGXNu82oxz1QLWCVdWbOyqEn2kVjlxer00Zl WSrzKpMZHdYQEuGltY3YLDLBjjCnn5KHK+zl6dWNyOL4nG8KWzhtcR49u5t4pi0Wzi5IIkVlaZw3 L8LOxmHafCZKCpJZNDODEXuEjKCN595uxqyd+MC3KAqYPQksrskisclLn09FNktkZ7qZmedk0zvN jAz4KKstQE2F595tQY+oMf2KGi1tEU5fnIXNO8Ir65qJaKCGVZbMy2JY7aal1Ysryc7s6iSqs63k JJgRTBqvrW0hSYaGQY3FS3JhdPS4+jEnujhzfhaHekMoCNiFKK+ua0NzO1lWk0Fds5ftdV1ogkR6 mosF1Rmk6WH2N/RTVZSEzWL47gwY+Kev35d9+dd6q9/D5kevO+4m/fCBbrY3eekZDKFKEp4kGzmZ bqpLkkmxS8am3sDxoWoMjYQII5LktmCR/m/PE13X6dvfwvdeaOesM6u4bF7S399mKMK2DYf48y4/ V15QzdIS28eoH5VBb5ioKJLksmCWjPfYgIFPKrZu3UpxcTFi/JCr3+8fW39/8oeXORCehd7+Kp+5 9DxuvHwBECtNumF3D7IsYpZFJAF8/jCjgSiaLmBzmElymlEUlUh0chkrAQFZFhHRGBgOIZpkPG4L uqYjSCISOsFQLNcIgoDZJMU8mxGFqKKPlRCVZBGrRUZXVIJhFV0Y78FiljBLEIqosXtEAatFRkYn FFFRtPG6n7JJwmYRiYRVwlFtgttawG6VEdEJhlVUPZYO1GKRUMNRvL4IstVCokNGVfUYydQ1AmEN TdMRZBGHRUJVVELHK1kqCJj9Q1x35wb6XKk8fEcNHuvJHw4WAKvNjIyGL6gcN4+YKIpYTCKSFIsS 0OM6VFQtllldEOjtHOKHP1rLcEEJz901H1Mo5qrVdJ1oVCOiHPsMJjnmvfX5QvgiOk6nBZdVIjKF jK1mESUak8VU3hdJErGYJCRRQCBWHjcUjUVBWE0ioWCEYV8EDYFEtxWrSSQSndDPCaRktUpEghG8 vigWu4VEu0xU0bFYRFA1/GE1dixAknBa4uM8at6aTDI2k0goFCUyoU9ZljCL0D8UQJdkUhKt6GrM 0y6jn1AvRxu+zCYJkyQgCuM6iioxHQmigM1qAlXFH5qc70CWYnM4GomNO1aBQMBsEomGowz7FBwO M067jKbqyLKIrmqEIrHStH+LfqKKRjiqIkoSVpNIMBDTjy4IJCZYscoiwbCCJ9FKYZZrLLLEgAED /3vYs2cPOTk5Y+t5NBolEokl82xqaprCgz4h04kW8PGrh3bw7HsdHOgOYDOJRKM6ER08KQ7Kiz1c fFE1Ny5ONyRtYGp4vTz0l93UKS5uv7qS6kzr/+3n0XWGm7v50192Y87N+8cQ9GiUg9tbuPfZPsrn lH68BH1omD88spsWUxJ3XFXBtHSLMWcNGPgXga7riKLA4lkZhjD+EQaSVxtp6gnzuevncGFt1j9t HH3JMomSTthhZ05uoqEYA//w74bhdDNg4J+LYwj6WKkOReH++97jv1c0UTCvjB9fmUOGW0ZTNIaG Auyo6+LNra08mJL6DyDoU2f21vWj6pFOIElTh9//fe2c6KP0Sf1gHW9cH+Xvxwt1nurowkeVgx4K sX13J+vCyVx/oXrSuj/ZbO9/m87GS6x8qGyYbKAWBAFBksBuwiILJ6ukKefreH8CJrOEbJOZ0nB9 zP0nkM1HTMSnB0Ns2dlBnVnjho+kH2MRN2Dgkw7j/fwHQhnl9vv2EXZ6uGlZKlrM2f9PQSii4vWG GfJFDL0YML4bBgz8OxD0WDlPnWBfDz9d2YxcXMDj31/IrKzJXr3B/kKuaRymQzNNuVk/QvCIh5pN fN81PZbeYvz68d9HvAF02USCwzSpPS0SoX9EISnZjiketnPkjNix7WgMDoawuWzYTMKkdkL+ECNh SEu2xgnose2o0Sj93jAaAikeByaBsTqnx/Z58saHKUnvFFnFT4r4HLlv7DqVnt4gmGXSE+PlcCbW uz36w6sr9AyEcSbaccSJph7Xy+R7NHr7A4gWMyku80eWg2A347LLOAQTiS7LlARPiBe3HRz0E9El Mjy2cV2egHBOlFM0EmHAGwZBIjXFjsSJdBZvLxqhZyhCUpoT85Hfx/QxmcT7hgOMqgKZHhuukw5r HNf9kZ593iC+qE5ysh3z2O5OHxvXeHIllb7+EHa3HYc5dr8+/iBj44qEwgyORhEkibRk21hfxzVK HaMfEy6bjN1sIsl9Iv1o9A8GUJFIT7aNt/2xZ+Y3YMCAgX/OdumWry7hRqebGammWGjzP8lI6Ul1 c9fd5xNMMLznBgwYMPBvQdCPEIbI4BDdfoH87JQxcj6RYCanuFma4kZT1LHN+tCgl7v/ZyvR4gJ+ 9R/FExi/SsP+Nu58ooXTzi3niwtjHveOln7u/fMuLMW5fKraxH1PHWBfTwjRZKZ2fj63XFFOUmCY Pzy1n7V7B/FFdJJS3Fx1QTmfOTWLIyVYd206zAOvtlO7JJ80/Dz6ejPNgxEsNivnnF3OV8/Pp6++ g/tfbGDL4RFCukBGZhI3XzuDZRWJSELMiLB3RwMPvNJMXXswfhZJwO4wU12eyc1XVzEt1TJGRJ57 bCNP1wv85juzaNvbyfPr2qjvDTPvtHKSOlp553CEW29bwpxUU7z9OLEiyHd/sokWezIPfH06Nknk 2ETjMTLfs+Mwtz3Xyqcvnc/pnlEefq2J7c1+LE4X/+97C0gFFJ+P+57Yzavb+xkYjYIskZuTzKXn TuOaxekxshaOsPO9Bv5nwxCfOrUQ76E2nt/Sy2BQw53k4IzFRXz5kmJc8X4FQSASCPLCq3t5Yn03 ncMRBFmisMDD1eeXc+HcFIS4zLThEVa8fIAPgna+cHY+wfZOnlzXSfOQzsLpyQQHh3lpzwijYpib /3s1aS6JkYDAjddO57IFGejBAM+9Vs/T73bQPBhCQ8TttlJenMYNl5czI8fB8eiwIAhs27iPP77W zqGeEL6QAgg4XRZmVWfz9WuryHPJYzp7/P71vNpj58efy+WF1xp4q24Ir1/BneTk7LOruPXcrDGj Ujy3DvU7G/nt84fZ2+4noIIn2cE0SxhOgqOPe551Nq0/yB9XtXCoO0BYBbfbRnVFGlecX87CdBEd kEQYHfCyYsUB/rq+i4GghsNt56wlRdx4SQmJY+fDo2ze1MgvVhxmMBiNn3ETSUywcUptPv9xXjGF STHDmTbo5ZEX97NXT+ALZ+Qw2NzByne7aB2GU2clM9A5wOp6H0FTGzd+/008DonRgMAtX5jFBXNS 0QN+nnr5IM9u6KJlMASihNttoaIknZuuqKAy04ZofEcNGDDwLwxd10G2cem5ZZP/9rGT85jR1+60 cvY5047ZlxkwYMCAgX9pgi5gSU4kSYjSf6CVZ3eUcOnspClCxEGUpbFj6wFfkGde2EdogWOcoMdo Aj1d/TzxfD1SWfYYQR8e8PHKy7vZbW7n+TwrmK1kJ1tobhngtw/1sauuE1tolF1tEUoLEnErATa8 18DungiJSQ4unJEAQFtTP8+9uIvH328lz2PB4bKRmmBmx55OfnbIy7aNDXS2DdEXEinOdaH3DfHS 6120hCUeuXUOM7JjBojGxj7qWrwIdhfVOQmYBJ2Oln4ee2onO/tUHr9tBgXJMS/j9o2NPLUxghYe YNeBQUZDGpFQFH9KOp9zB1nxSgNyRT4PXF2IZBLHiG/LB4f49cq9zL38VEROvKh6W3pZ8ex+mgYU fj3Qx6H+KCZJBH2IH3xvAcm+Eb72o7d5ZvsIp9TkcNYMB6ERP+9va+G2fYOMikv40kIPuqLSdqCT vzxez5pN7TgkgewcFyl2hd07W1i9vR9vFH56VTGCIBAY8fP4E5v5/tPN2FOTOGtWKpERH+9tOsT6 nQP0fb2WLyyLn2kMhNi6pZU/7Aqxc0sTPV1DDIZ0An5wWAWyEkBRdVQ0goEoPkHFF5SIqgAKDz2x gx+taMCT52HRjExMSpQDjf386bEdFE/PoDzHwYlOrdcf7GZfhw9XgpOiPCuSrtHa2MP9j22nbgie /EYVyfbYNN+0roEn9+rU7aknpMrkZTlJdumsXVfPpgOD5OSez6VVjnjYosChrQe47hdb2dwUYfnC bEqdEgODAdYcGEQUTy70XomqvP3aNr76x/10RUyctyiLFDM0tQyy4oU9tJldLLw+D0kUCQ+M8oeH NiCrCpmZCXjsOrv3tPD23mGiVgvfvSA31rgapa19kA8O+5hTmURpggUUhbr9ffz2/k66RhTuvL6a LAvgD7JxUwt/OaSydUMDXV3DeMM6o6M6ngQJp6SjqKCJMf34dRVfSELRYoaAex/dxs+eaSSzKJVT ZmUiRaLsP9zHfX/eTlVNNqWZNoxT6wYMGPhXxlRe8n9OGPCx0UpGOLIBAwYM/BsQ9COeQ6snle9f WchtjzTylTvf4pHSRIpzXEwrSKQ4J4FZ5WmkOSf7zgRRwGYzIVqO9alJkgg2edK5XVEUsZglPKlO rrhqFufN9JDskGk50MnP7tvMqvc7uOhT03jgphJK02xYhChPPLmT7/y5kdUfdI0RdEmWsJgEEgpS ufmqSpZMSyDBLrN9/QH+64FdPLtR5aYrqrj6tFxyky3ISogf/2I9D7zVyI6Li8cI+ryFFdwzu5zE BDvJLhMmCdSIws/vfp3/fnU/268sIS/ZggiYLCas4ii7ezU+f+08aorc2CWwJbmYmZzLPS+28uzK /fzo0nwKTCJHTjI/vGIfIXMCP7imBLM4QeZTKEeUJbDKHG4d5IpPVfODWR4S7TKaAilRlRde2MGj G7z84qdn85maZJKdJrRolLp9HXz1+2/xmz/v4bqFy7ALApIsgd1M5fRcvnVFKQVpViyizu5d7Xzn Vxv468sHuHB5IbVpsGdPCz/8y2Fy5pbywG01FCWZ0VWFDzYc5vv3beM3T+9j1rQUajJlEASsVhnV GyAkp/KlL5zC7AInggppaQ5c/iEO1XWzNZrIHTfOYVGxnWBUJz3dxfDhdp58oxF7YT4/+9oclpbY 2XZwVQAAIABJREFUUaMqQ94gO3f3kF3i/lCvwNIzZjL9VBFPoo0kpwlZgEgownfvfJnfvFBH3XVl LLbLiIDZYkIwRaisLePzp+VSkmFDFnR2rt3Bxb/ez0NrWrm4siJWN1Xz84P/2crmFoE/3HU2Z1W4 cZhFgv4IW1dt58oHGz9sRwdoDHZ0cevvdtPjTOWpuxYzO8eOVQKvN8i+5mG6NAsoemwW6AI5Renc cdU0yjPs2GSdjZsa+cYvNvDy2kZuuiCXFADBzJIllTw3vZyCDDsJdhlRFBjp7OV7v3mfp9c0cv6S fC6qdoEQeyfDgyMolanccmMlM/McoEJGphP7YD8H9nRzyJzKd740i7n5NoKKTlaGi8GDrTzxRiPJ 5cXc/dUZLCi0o0YUBrxBdu7qoaDAaXhtDBgwYMCAAQMGDBj43yToQtwdLpksXH/jIpzZHv7yZguv vXkALSJg9thITbKRn5PIaQsL+M9rKkj6mysy6ER1idKyLP7z4mLM8b/mmtNZXJbA2qEwFywv4+zZ KWN3LKrJIPepA/QNBAlBzLuq64Q0M+ctKuCms/LGrk2fm8mjLx9kMJrMVWeXsqTUEf/FyZLZyfzl nV56vFGigEnXychMIkOJsHlnFy8cHKKlx48vrLHnoA9G/bT7FMKA7Uif2PjmTfP47MIMTEc92XXL Mvjy0508s9XL15YkY5YEop1tPLrNS/miak7JtcaI4IedYRMFlp89k599oRy3efy6gM/PE880IHrS SBOjbNjRiarF2goHo3jcFnY2d7PDD4ukeBicw8pZp0/jzDnj8sx2Sxza0ch/rvayYd8gtYl2tmxs pVd28s0LqqjJd8WvtHDO2cUcPNTNN57pYfWuPmoyMwFQFQ1Xbio3XT2H65ekTh5/T5AEu4Q5ZCIv y012xngug57RMMGoxmhQwWE34bCZwGbC7baSn5uEpuvHt17Ew9Czczxkh0Os397FzkPDtPb48Uc0 djSHYDRAq19F0cEcP+euy05u/9x05qWN+30LPlVC6h8a2Ns6HD+7LdC1vZnn9vtYftEp3Hh69viL kuJALk3gw2qxCIAaVtixoYm9g/CVa2Zy3gzP2O9JCTYK8pIJhVX0aDhW6ifBzkXnVnHBvHH9LK7J pjbfyu4hP80BSLGDLsqkpyeQlhBizaY29jR5ae8LEvAH2dIUIBC10z0UAGK6UxSVpMJ0vnLNHK5Z 4DlqoD7cNhGzyUx+tpucCVn2R0bDBBSd0UAUl9Myrp8EG4V5ySfWjwEDBgwYMGDAgAEDBv5+gs6E c8gJqYl84eo5LFlcQvdAkP7hIIdbhtixv4/V7zex6cAg7X545MsVf8cQBCwmOUbOj8TKS2C3y5jk CLa4m/nImEwWEZdLRNE0lAlEXxdEHBZ5jLwhCMgWEbNZwibK497qeDsOp4TNChFVRwVMgsCBbYe5 e8U+Xts1hN1mJjPFRpLLQkgFJIjGSeE4ebYwvdAdJ+fxhGBxGV59ZQU/eqmD3z9Tz42nzMcsSbz4 Yh0tXrjn6krs0pGRf8jZMQHyc5Nxm4UJCWl0oiE/HzSGCXu8/L/7NhLV9LF2NF3HO6SQ6jYTDALO +HBFAatZniQHySZTUZGE9tIgbUN+FJ+JA80jpKY5qChKHhMnAgiyjaICD5K3nab2USBzrD93gp28 DNektgF0TUfXYn9T1MmsNr0yi9Omp3DXK41c900vNaUeqkqSqCpJ4axTskmyxM+DT5WZn9jfdr23 n58+Vc/b+4ZJcFvJSLaR4DIT1gQQhUk1UGPylEm2x858C0cSwrkduIHRCePbvqePsCCwuDYfecIz 6ZpGWNFPamZHFI1d9YOYXBbmzc6cIBvGEtBZLRJaJPY8sizisk9OuigKIgkJNtSgTiQ+4QU1yqaN jdz50G52tgexOa3kpdpwWwVCSqz9ifnYNU0nMdFOXppzSv1o+tT6yZyexfIqD79ZfYjP/OcQs0uT qS5Jpqo4hbMXZuM2HV8/BgwYMGDAgAEDBgwY+AcQ9KOzkopmM+UlKZSXxP4dDkYYGA5SV9fG9d9Z z8ur9rHvixVUmv72Qej6uHFggp0AXY+RPxgnAAJT5WURxojipHaE2P9qun5MVmvhSGZ2IZ7va6CP nz+6k8e3Bbj5s7O4YH4aqS4ziQlWXln5PnsPjY6PcwJNjMYO6zLxbJgOuAvzubQmgd9/cJB32mdz Yb6f37zaTXJ5PpdVu8eI9skQG1XVJo0dQFcVRhWJtOIcfn9LOf6IGpdDjE2LooDVIlOWAETHx3VM dm9BQDKJYx7hqKbji6iYZRGLVRrXRWw2YJJlzKpGJKRNGqOm6ShTjHOyhibrXDDb+dqXTqF4WiOv bu5k9+42Vr1zCLPDSnVVDnd/Yy6LilwIU7irBUFA7ermuw/u4o1GjW/fMJ/l1cl4XCYSXFaeemwt uxuDU3q6VW1i0j5AFGJZ3ydc0+ePCc0dz2z+txBQXYdAVEMUBCxW0zHz72j56LqOph09T4VYpMWE 8R2q7+Env93IBz47N3/hFM6pTsBlN5NsCvPHx7dz1zu+Y9rWNB1F+4j6sTi545ZFlFc18toHXeza 0cprbx3C6rJRPT2XX902l3m5jin1Y8CAAQMGDBgwYMCAgX8AQYdjo1YnknaLzUyWzYwnwcLCovd5 rT9IawAqE44wNR39iCduLMupgDRFtvIT4UTX/qPpgAnYU9fNu3WDLDtnLl+7qprixPFz9LkpZmTp I9AQXQdB4uaLi/jTxu386Y1WUvIH2NoR4vPfnU6q9UgprL89CaxktVHk1GgfjTBnZubxsv3FVBKd aohxj3BIpavVD1aZbLcDiySQ7jTj743iHQpBlnXMgw4KgUCIoEnGmXCSFhkdxuMO9GNmWVpWMp+9 zMWZy0vpHw7jHQny4st13Pd6PfeWZVDwuWlku6bOE75lRzsb671ccOWp3HzpNNLt48LMTjZ9pBq1 R1+aZosduBgeCAC2Se+ALJ1cw7IoUJBkIxwdob1zBMoTJ5dKO9kZPak7jYbDfbxRH+WSz1fyo6tK J/wWIjPZgqaNfjTjmH78r0BGjof/uMLFuWeU0T8cZngkwLPP7+GPaw5wX0UW+dcUk+Yw8rgbMGDA gAEDBgwYMPCPwDE7a0EQQNPo2NrAd584hJ+pPW7BwUF2dWmYXAnMiZNzUZBwmlUi3mFG4yTkCDqa htGlT2YYrACM+BUURcOT7CDpKMLR3BkiGNZO2sBw5LGnLa1kWZ6Zt1/eww8eqSecnMJXTktFmuC9 /sjQYyM2m+1csDiZvsZOvvlU8xSsXGHj+62MTuB3ogD2ozy5XR0D3PtqK9npbpbPTUF0W5gxI4XB 5mHe3dU1NkwBUId9fLCtHUuGi+lFSScnC4uIySzS44sQnhBCLQgCAwN+RkIqssVETmYCsyrSOLU2 nx9cUU5luokDTaOM+pXjtu31KWiaRkqKkwTbZFkebg/FQrb/xik3d1YSqDqvrG+cJC9BFOno8Z9U u2arzPzF2QhDPla+shdfvJ0jtcojwSDv7R1ElMWPNAEiiooSFkl0H5XfPhyhu9vHR7FMiFYB2Szy /9m77zArqruB49+ZuX373d5hd2HpVZqIQbFgAxGxxxZNNInGksQW3yQm9tcaxYZYEAEBRXqT3ntZ 6rKwlO199/Zp7x93WbqAYl7L+TwPj97ZuXNnzpl7z/zOnPmdsqYgqmkcUz/V1R48IQOrw0ZGWgzd OiQxsG8r/nFjPnnxCjv2NeHx6+JXVBAEQRAEQRDOEcupgsDGsmqee2MXcxfu4uJe6fRqG0dKrB1T DbGrqJqxX+9gt8/O3x7tQVLz25xOO727xfDm+jIe/M9mbjovnsaaRuYv28vkZWXITuePMp+UCvRo H096nJOpX2+mQ4zOr9pF46v3MnXBHr5eUYYWMFuGGp9JyG+aIFki+P3gTBaOLuab0iCX3dqLNjFK 8/B987s9t9s8/7jNbuXOe/oyZeNcXvvPUooLDnFZz0Si7VC8v4a5K8vwaE7m9s8KPxYgS+h1Xl4b uZiSHZlku21UlNfx1bw9bG608OhvutI9BsBBn16tuKh1Ee+MWYfbqnNdr3jUJg/jp27njfm1XHx1 V4b3cZ/Z/sbHkJseg2fhXl7+ZAMHLkylvsxH3/6tcDTW8MqkQtxZSQzpm0ZeqgstEODr+XvZUhri rutjSYiznXLTfbokEu+y8cWEdbR1+Dkv20lDtYcv5xUyfU0VqOZ3Pt+SOudxfZv1TFq2jXvetDK0 ZxyGP8TSFUWMX1SKfJrOJhOQZIVWHVrxxLWFPPd1AVc+HOTmgRnEO2BPYSXT11eR2qsdF7TLPYs9 U0hLjKZdfJDpc3bwn0SFrqk2yg7VMmVBEVNXleNISzrz4050k5caxYSV+3nh4yiu65dETYmPgYNy MMrK+d+v9pKRm8yVvdPIS3US8vmZPG8fOypUHuwSR1y0VfyKCoIgCIIgCMIPEaAfDholRSanVx73 XdbArBUlvLy5nIQ4Oy6bjKkbNHlDJKQnMPKlgdwzKL3l/THuKP7wu/NZ+eRiPv5kHXNn2jEMyG+b wO1DW/PahAPo0pG7hTaLTCiooR6fyMuuIJkG/pCBohybIt6qSISCGroptcyPbZFMggEN8/gBATYZ Q9MJagZW67HbUSQIBDUkWcIKWFtn8eLvu3L/axv43/dWMSrKSjBk0KlrNpefF8unM8sxZfnInNy6 DgEDq+3kKewPx95DbutK2/EHKFCjeeyWPBzNd0tPF5xLkoRNNiGgY8ryMcE/hO/ktu7Qikkjr+Sd CQV8vbqIhUsKkWQJm91Cq+x4hl3aFndzedoVCSwyETLMmbONnSV+dFkiJzeZ13/XlbsvPVKPeR2z ef2pC3nyrXU8+9pSPkp2oQdDNAZNrhnenWd/14345jNHtimYukFQNbBaTlYWdu69uSsV9UE+XbKb Zcv2oFhcvNU2havbROMK+fh4/EYmTttBbIQFLRSi0msy/NZe/GVoaxK+ZZLt2Ha5vPnHWu5/czP/ emsF0U6FQMig+3k5XNXTz5jZ1cgWhcPJ701Nh6CO3W45NoCVZIJBjYBOeJ55AJuLt569mIanl/Dh Z+uZOcuOoekkpsZx18BU/j1pP6Ykf0sXTZgrOoon/jyItOwCRs0u5u+vH0CTwOW00qlzOrcMSA8/ A2+aaCED+bjz3W496hxu7qvo1acVz9zfjYff38ZfXq4lMULGlBQu6JnEpb2TmLpLRWo+DtkmY+hG +P2nqJ8Hbu9OrUdl3Dc7WbBwNxaLi+zuGQzMisHu9/DB2BLGfb2d2AgLaiBEpd/ktrv68chVmcTZ +H7PagiCIAiCIAiCcCSOuP7+V80D3nhWf3I7EE4mtbqgkrUFFdTU+aio8VNW1URxmYd6r47DYScr O5Y2aVG0yogi2ibRnBsMCdA0jd2F1WworKG0XiMrM47ubeOId0nsOuAlKS2G/GQHhgleT5DdRbUo 0ZF0yY1ueXZd0jVKyprY36iTlxlDcrQVozlTdFOjl8L9jThjI2mTGYVNgurKRgoPeUlMiyEnxYVp hIc2S6EQu/Y30mhaaJsZRaxTwTDD2cyrKhvYU+IjLTOO9Hg7iiSh+gLs3lvD6u211AdNsjJj6ZDr JkZROVARILN1PKnRVqyKRHFhJfuboEs7N9H2kwfpJhBr8fOXVzZS7ozm+bs6EGU90+HMJv5aD+sP eklPd5OTYDvpo8KKDBWVTZRW+2nw6RiA3WbBHesg0e3EHWHBCKpsW7OXd9fUc0n/HPLdUNWkISsy 8XEuslIiiXFIqMaRJHy6qnOwpI6tRXUUljQhO5zkt3bTJTeWtHgHNJexGVQpLmmgOqSQlxVNvCtc xsecZKZBeZWH/eU+/KqBYrHSplUMCZEyZeUeig81UniwkUqPSmS0k7ZZsXTIc5MaY0ORTv2EtiRL hDx+tu+pZs2OWry6TOtWcbRv7SbS9FNcGSK3bSKJLgWLDEW7Kinxy/Ts6MapyEcF0xrrt1SjRbro 1TqqpfNExmDP3lo2765mX1WQ5JQYOuXGkR0tU1DiJT0tjpwk+0mSB57YWeNr8lNc5qXWo6KZ4HBY SIp3keJ24VRMqssb2V2rkpMVR1qMJVyGEqgBlf2H6qnXFfJz3UQr4e15mwJs3lnJ1qJ6/Ci0znbT NScKNI2SOo1WmdFkxNnRfEH2HmqkzrDQJiOaOJd8Yv0YOmWVHg5U+sP1Y7WS3zoWt1OipLyppX6q vRpRMS7aZsfSITeOOIfCbVfkkZLgEr+kgvBfsG7dOnJzc5GbO229Xm9Lx/q/357GzmA3zEMzuHn4 lfx2RF9RYIIgCILwI7R161YyMjJa2nNVVQmFQgDs27fvJPOgS9CuVSypCS4UJZwN3DQM/AENTTeR FRmHw4pVAk03TrzYlySUS/JQQyoB1cThsGJXJHTTxKJI6PqR6ZwkWcJqkTENA/XoqaskUGQZixz+ DP2ohOGyLGFRZEzTQNPC6cdkJbzM0I1jp4qSJIYq4ezqmnbsvspKdnh/NKMlq7ckS1hkCAQ0VAOc DguKDJgSiiKhHbWuZUA2igyqemIZHGZzWPn8nTmUewye+fuFjOgYiUU68yR3kixxq0VGP/64jlkJ FDlcT4eH4JvNWesNIxxHG/4ArvIK3tvo4YIL2/Lgr+IIaCaY4Sm29FPVoyJh6Dr+oI4kyzjsFmRM dP2o6eYksCgy8knK+Pj6VOTmTPfNU3oZphlOHmiaBIIaId3EYlFw2hUwTXTDPH3wK0uMkPPx+zV0 E5xOKzLhO7qKLKGpOoeLzvKrVigShFTjhO1ee3EbMAxCx52HloE56KqGP2Rgt1uxWyQ0MzyS41vr 5bjjl5vL8+g6Mozmf4Asy1hPcr5LEignKV9ZkbjxqnyCAQ0DCYddQZHDiQwVCTQ9XH5IEhZF+g71 E1732+onpBnERtvFr6wgCOfMd378SxDlJwiC8DNx0iHucdF24sSF9/en1vPlyjoi2mRz9/lJpEcq /z/7EbCyI8oCkow7zkVcrFPUjSAuCAVB+NGRJIn6+noKCgooLS3FMAxRKKchyzJpaWn07t0bm80m CkQQBOHnFKCLi+xza8rn61m5q4G7/nkJCQ75/y2YMXSDQEDFbAriC4mLHeHcX1ALgiCcK36/H8Mw 6NSpE0lJSei6mC3i27RMm2qaojAEQRB+bgG6cG5dcEUvNvbtSlp6HC255P4fghnJaWfQrf3ZeKVK emq0qBhBEAThrIK/o1/TPFXk2bznbDryTNPEZrORkJBAQkKCqIQzEAgERCEIgiCIAF043QVGQlI0 CUl854uUc3ZxJcvEJETRLeH/bz8EQRCEnx5JktCDPgo3r2V7fSTXXdYznMND+vb3hJqqWbV2A2Z8 Lr/qmnvGwfzRy8Xw9jNjGIZo1wVBEESALpzJRc2ZLPul7IcgCILw06T5G1kxbRzv78zkust6IkkQ aKhg9ldTqHemcsU1Q0i2+di8ajFLNu4ltXUuKZFONq5dTmVkNQmhg6zbXYJVcdDl/ItJNUpZX7CX vF6XkJMscqIIgiAIggjQBUEQBEE4M4ZBwNtEbaMPgPryIt59+QkWl8TQK83kt1Pncd+ve/PskyPp ePEFLFs8nY69rkWvKWf7oRCTd81meZlOa4uXmcu2c88t/dm8ZiURbQeIAF0QBEEQjiOLIhAEQRAE 4ZQkQJKx2hzheF31s33bZnpfdj1DL+lG0ZIpLFy/HU9ELvfcewNuu5cmXxDDMFCDAXymTN75A7iw Z1vKioqIbtuXEbfeRvu0CFG2giAIgnAccQddEARBEIRTMk0wvBVsnz6BTl2+plV2Gy4fPIxXn7qH 6RkZ9L/zKW68KJWln47jluu2EB3p5PI2JgG/D59fISSHkGx2HJqCqutsWPAlq8ZP4JonRzP0vERR wIIgCIIgAnRBEARBEM6EPSaZO54bw5WP+ZAlGZvdQUy0k2uvvQ8sNuISk6jYtpwUi4dtpR6S+l7B sLt+Q/vYX+NVwSYbmFYHDlOj/806TqeVawZcTEScWxSuIAiCIIgAXRAEQRCEM2GaJpKiEOVOJuq4 eDoi4si0nY5OfRm1YAtBXcJqdxDnjsQiQeRx23M1vyU6KvrI9k+RxV04MyLxqyAIggjQBUEQBEEQ wR9gYppgsdmJT047Yfnp3n+yv8uyTExMDAD19fUiWD/DenK5XKIgBEEQRIAuCIIgCMIvODTk5DH4 qZafXmJiIgkJCUiSJO4On2WQLgiCIIgAXRAEQRAE4ZwwTRNFUURBfI/yE4G6IAjCT5uYZk0QBEEQ BEEQBEEQfgR+FnfQRY+xKDtBEAThp0+SJGpqatiwYQMHDx4Uz5+fAVmWyczMZMCAAdjtdlEggiAI IkD/cTTo27dvZ/Xq1ei6LgLOMwjKXS4XvXv3Ji8vTxSIIAiC8KMRDAaJiIjg0ksvJTU1FV3XRaF8 C8Mw0DRNFIQgCIII0H9cGhoayM/Pp1+/fqiqKmr2NDRNIxQKiYIQBEH42TIxzZMna/tvjp4yw+nc kY4swDxNEjlJkrBarVgsFiwWkS7ndAG6IAiCIAL001wQHJtN9LQXAic01mc2PcvxFwCKoiBJEjab TdTsaciyLDoyBEEQftYkJMlEU5uY8Nbb7A+YWBxxXHH9bXTOjDqhHeYHCtjDbbmfjcsXs6vSwvXD Lmm5+BCPWQmCIAjCDx6ghwPtuqpiZk2cTqer76VLlv2kQXnLxUBzz/qegpUsW7OXS265lQzHqQPx Y3rihe9EPNcnCILwy6Cp9Xz43NO4r3uO1k2TuOi92RTunMDCd95kez3kdLyAW4acT2PpHsZ8PhGf NY4rht1AllLNJ59PQotIpl//C6jeupCEblcT07CdtTURXNUjlqkz1zLoppupXzedaSv20vXCyxnU M4tVy75hy6FG2qclkdCqNZtmj+Wr6YuxZg2ke49Mdq5YT/6vhtIuLUJUkCAIgiD8sAF6WF1FER++ /AK3drydLll29KCXbSvmMnXZLtr3HcTwS3tRXrSFyVNm0Ki7aJufR6yjiWWLFhDTqQvzVszB54om yp3N1RedR8HKJVRZ0xh+eR9Ra4IgCIJwFnRVxzQltJAPQ3ZjAzTTRrBqJ3+/71WqpeWUfT6EKWUd +NsfRlC0YyOjRz3IvLpOPHn/CCpL97NxxSzWrakm9+AXLCxzo993De9PLKBVK51H/vQ2g399A6Ne fJilv7oN2+7JjN+mc/NFuWwdvQdsiSTEuqg1TBqqy9i9YxsJPa8UFSMIgiAIx/nBplkzTRNdC18Q gMr6BWO46TdP4XfYGfPKw/zhX+/x+jMPMXn5NmoKF/P2qEnUBb2Ul+5j04blvP/ep6zfuoNxH77C x1/Npab0ILv3lYoaEwRBEISzbZOBuvoyEvvcxNJ57+MtmMOf/+clGiNSSLKFCOl2br37cbrFevj7 k48xv8jPXfc+TjtHDU8/9SQrDnoZ1K8z08dOZfvBGC7IM3n17cX0vaQv2sFCVHcH7rz9erKTXOzY tws5KoGBN9/LndddjlPzMfT6W7iwZx5+r4/WXc7nxjvupGOGuHsuCIIgCP+1AB0ACWTFCgRpKCsm EJ3PnXeMID8jjrUF6/AGg1x17Y0M6ptPwB/EBExMNDVEQnYOg6+/gezkaGqkSC4bfgM3XXW+qDFB EARBONvw3IRBIx7myb88SMe0KCTZikX3sHbVRhqD4PM28vW4d9i0v5ao2HRy3RF8OXYkWw7WEx2T QreOXcjo3I/c4FZSB4/g2l757C0pZOCwu+h8/pV0ktZzQa/B7GhM43cjrsHr96PqOjnte9IhPZWn H76X50fNJSo2mnWzx/LX++9j/tY6UTWCIAiCcJwfbIi7LCtUHSzn99dk82qbXC4fOoLLU+bQv9tF dOjWlxefe4zCyc/y5z/cRIQrni4XDEbBxNANTNPENJqfUZctGFW7+M/Tk1kjd+HLtx4RtSYIgiAI Z8juzGJhrYokK4AEKCS0v4LC6iMBsiTJcPMyHjePen3DMv52+LUsI5HDrgYPUnMemMY/msiyDAzg 88UFhFeVkGWJKwb2DX+WJPHkm5/zxBstH4QswWVX3o4ky6JyBEEQBOG/FaC36jCQrUfNXSpJEph/ 4u3mht5oKKchNpHYmFhc7gwGDLmJ64ZczLCr7wZJwvzjA0iSxIgBnzdfUIQzvQuCIAiCcCaOTLOm KOHm/uhEq4qiHLf+6V4f+56j/yodty1JUpr3AGTpZNuhZX9EFndBEARB+EED9CNTpJ3Q6B6VfV2O TmboIy8y9JEXj12luUf9yHuP/FdCZHEXBEEQhDNz4lzj/+1g+HSfdrL9URQFt9uNLMvU1Ylh8Ke9 6jLDIxlcLpcoDEEQBBGgn9kFwZk2yme09VO8LyUlBb/fT0NDA4ZhiJo9gwbdYrGIghAEQRB+VG1T cnIyycnJojC+Y/mJEQmCIAgiQP9RNEg5OTmiNkVjLgiCIPyESZIUHinHqTvkT/f3X3r5CYIgCCJA FwRBEARB+EEC9bP5myAIgiCIAP1H1JCLoe1nR5Zl0dsuCIIg/OjadICqqipqampaXuu6TmpqKm63 u2XZqUaBndny5pw5gHnU43mH1zl+G8ffuW9OiXPkb0flxzlXo9NOtg/fvt0jiQFPvf6x6xy7nBPL 5yw+/9vyBJ2sjM5VmZ20ro7bj+9blqcup7Pf97M9b097Dv8Ur+VME/Mk58rRx3f2dSYIIkD/Udm6 dSurVq0SX9wzbBhcLhe9e/embdu2okAEQRCEH5WKigqamppISEjAarWyf/9+NE2jvLwcSZKIi4tr CZZN08DQDQzCHc+ydHzns8nhdHWSJGEaRnNgcCT4kjDRdRNZPpLg9ph1j0p8e3iZLIGq6lgsluaZ akx0wzih8/vMhuQf2cfjOytM08Q0DZBk5DMKKMNB2+HkcScERRy9TvjYDdNEkhVkCUzTaA6fGCUf AAAgAElEQVT65GOC05aOC8MI3xCR5ObPDP+/0nzc5tE9F0c+trmMDDTdRFaaj6X5taLI3zs4N00D TTOwWJTmbR1bpoe3bxj6GZTl4X0Ol5NhmiiShK7roFhQJE5dL6bZMuXgqT7iSL2a4SkNTSM848Fp ph48+lhPVkc/0FXjCefmmZzTJz+jj1p6ODhv/t4oiozefC4cLsfD3yvDNNANsFoUEaQLv8wA/ZQn fsuP+n8viDybXjOPx0O3bt3o3bu3qNUzYBgGHo9HFIQgCILwo2OaJpqmEQgEqKio4JNPPkGSJIYO HUpaWtox6/oPbmPCtHnsLG2g/+VDuahPN6LsEpqqgSyjyAqmqaPrBharlbJNC9gf0Z6OrVKJtISD U4slxKSvlzL4kguIiXahqhqK1cqhNbMoSexL96w4HJbwvO4HVs+gNOVC+rXWueW3L/HJ23/HZrdj kT189sVSbr/pSnRdwzBMZMWCIh+5G2gY+pHlEmiahilJ4aSthoGm60iSjKLIGLqGgYQR9LN7/RL0 doPpliSHj6t5HdMwMJoDQotiab5GMykp2c/2HaVcdml/zMPblRUsitwcHpkUFu6iul4nx1bFnI17 yB58LwNToe7ALoqqPCTn9yIrUkfVDGRFQWkOHqv2bWbylKlE5w/EHaqhYONKzLRuDLn6MtplJrYE kLquY5oSiqIgyxKGCXLVAv455hA3D7uKDjmJUDGPpz4p595briYvMw5VDQfYhq5jmKBYFGSaywkJ i0XBNHR0w0RWFOSjOk58hfO4/61C3n3lPuyyhCyH15VkBcM4XB8Khcum0pBzJb3TLOiG2Zw014qE 2fw5HHW8Jj5fNXPmbeLKi3swe9TzNF39Er9uAyGfh10blmHmD6ZrkomqNtedRTkyKqCl7MMdGKZh oJvh+g9UHWLPvmIi2/VBr9hDSUWAiwb0QNc0DMCiKC3nDISPR24+l2r2bmVvg0l6m66kRxqoWrhz 6XDniCLLLR1XpiRjUY68lmQFSQJD10FWUGTCddPc+YIsN5dFuOwURcbU9ebOJ+WYTixD11rqQpGl 8L6bUnMnCc2vQbFYMJvfH64TGUPXmwN9L2MnreD2GwYw6culXH/dYCC8Tck00dQg+9dN5fkZPkY9 e6cIzoVfBKVDr8v/0aC6uHdY12N79QwdVdPQD/9IKjL/ze/EMT/wSC0/SqcaPnXw4EEkSSIjI0PU 6hnQNA1VVXE4HKIwBEEQfgJKS0uPGd6tqmpLe7lk7W6q9RRoLKRzhzb07PjTbgt9Ph+lpaUsWrSI zz//HF3XGTZsGOnp6TgcjmOmFKtcM5UtoTYMu6YvE8Z/TXxiCvFmBZ9+/ClbykLk5mSye/k0Pv18 Mh5nGgWT3uCjmcsxo5PZtX4tq+ZPpcmZQUVZJZ3a51BbtJoPR4+lKOBi27gX+HjxdqwxWbTNSkCR Jb549o98uGQ3UUmpbF26jKayHaw+oHNep3Q2bCqke+dc5n/xPuOnLsaalENWYhRgYupB5ox/l4kz V+BIySXR1sC4Ue+zcNMB8jt3pGHPKt7+4FN2HgrSvkMqMz8dydRFm4lIysThKyGQ2J6Imm188MHH 7Cj1kdM6lR1LpzJ50VrWri0go303ou1AqJHl0z7nb6+MwZ2Ugkuu4+MPP6OkCdq0zQ7fmQnUMP3z j3hl1FRcNoVgsJ5la7dTV9NAfKyLoKZjdbnYsmAyY75ciDUqgezUeAAi3HGs3Laf7IxESgr3k9u5 Hym+Law85CO1TQdirWDUFjNh7BgmTF+JO70VaQk2Fkz5gqlTp1HoiePiXnls/GYaU6fPYF8olXxn HRt2bGfyNzvpmBvLsulfMHnOKpLz2uP07uejjz9iwer9dOyRz/pZn/PZxNmo0RlkJ8e2XB+++vS/ +fW//0mmK8T4KUvo3D6XVdMnYWvVhlWTm+sjMYfIpiIaEjoS2jyVr1duYc6Mb0hu14MorYwx747k m1WrqTOTyM9KAF1l/+qZ3P/4a6img0iqWF1Uxc7Vq0nKaQ81e/HH5xHavYiRoydQUifRpX2r5jvD GiW7N/DR6M8orjPJSoli85KpfDFvBbv2VmD46xj7+r9YVW3B5YwkymYhLRqmTfyMuWuLSGnViuqD O5k89jNWbi4EVwKZSTGEq+8QNboV1VvHltUL+GLWEqprKti8eikbd1WRlZvF1tVLmDZpAit3VZCW ncq2dWuY/eUEqs14zPpiJk34nN21MhkRjazYUoY7IYHdK+bijUgkUFrAZ5+MYXe9hbY56WyaP4Ex E6bhdSSRnRKPpfku9/Lpn/LZxFmoURlku02mfjaaqYs3k92+M9FyI1+O/oCpizeQ1SGPWXNWHKmT 1q2Z8tl41i//hoC7PdWHislSyrj7oWdpDNhoKN1JSvvOSHW7mbqqjH79+lO99H0C3YaQ6RRtgfDT V1lZSXR09FEje8IxL0B9fT0nH0tjGuxZ+hVPPPk0//73s7w5egqNKpi6RjAYJBQKYTT3OuqaGl6m apgcea2qGoauhZebBqoaQjdMNE1F1XVM0yAUChIKqRjNPYShUAhV09C08A4eKNzIxHGjWLPtEGCi anp4mJmoV0EQBEH42Tr8KFZTUxM+n4/LLruMdu3aEQqFTljX6nCyZ91sXnrudeIz88nPNnlh5DS6 X3I9wW2rKNw4nv/M3M3FVw2ja04yHfLzuPqex7j18vOYM3kqSR0u4PwuSaxfvwW9ZgOPvzKLG+75 A/3bZ9Kje2eG3Pck1w3siM0SvmTq1r0b197/N67p2x5ffQMX33wfpV+9wnavn0VL12JWL+b1mVU8 /NC9JDvMwweEWrmIt+fW8+eH7yUWH+Neegr7gDu5sbvJ/7z0FV+OfoPON/6Ja3unUlm0gLFrdB59 8E4itQYObV/P+j2lfDl6JO2H3U1v936eenkyxTs240/owIBcnbc+mhH+LFsUKV37cf2w4VzaNZnZ X02l3/ARuL0FvD1+XXgdh5u0rv245cbh3HRNf4Kajb7ntcMWLOHzTydSWVnBzJkzKKyo44obb6Zj ZgzqkdppHqlswRqsZNr495iwpoy0lFRSD/ebWOwkZ2Rj7pvHuGnref/5f1OkpDH85mG0yU5lxjvP UOTM44abh5CRFEfppkUs2u1nyJBBLB39PCWJ/bhrcAZjJy7nrWeeILbvtYwY3IdIzypenVLM3ffe QWu346jrwQCHSKO9C8DHV7OXYALr50+nonTRMfVRXrCSnbUa+9Z+w3Yjl3suT+SZlz5h8ut/wzrg Lu4c6GbW0p3hzSpWErr04cILL+HRP92CounEpbXl6h4OXnx9LDX7ClhbWMLMSZ/R+9YHuKx7OsHm PSor2sG0SRPpOfxWWsuF/Ou1SRTvKSIuvw9Z0R4+nbiAq266nZvuvoNkh4+CTStYvHwZB9QM+raO 5pvJnzB/0y7q1Vhax1goWDaDuuZte8v3sXf/Ifbs3Mbm4iZ6dU1j85q1KEl5VB7ax9YNq1i8ZC2J bfqR3riDVVvXMnriPCwJ+VzUVeGDcQvof9UN1K+axo5aP7OmzaaqZBsT5xdgbdjI82/P5vKbfkP5 oqns2zGFV6ft5fpbbqFdWixy8wB+PMt57eti7rznDtqmxfLF83+msd1Q7rk4ljc/XMDHf/sj/h43 8Ke7h+AwfXw1awlIsG7eNKpCPsaOnkz3wSPokgmLlq4jvnNv+vQdyJOP3E50zSZGzS5i5bjR1EW2 QrFKXHJBZxYu2i9+HIVfBMvJ43ODfatn8+pHO/ng2Wt55a83cMhYyF/7qbzzxXwkZyyXXXcnfXOc zJn4MUt21pLTqR+3XtePBeNGs2xPI/ntu9GnjZ1pq+u488beTPt4PG0uuYXAngXUxXfmklYWxoyZ RCgumyuvHUakp4iJE6YS170vbpudSE8J46dOpbiqjlukLPTiNRQbSdw2dICoNUEQBEH4mQfosiwz ePBgBg0aRFRUFD6fD03TThjiqgYDtD9/CI6qDVRZIVBXTmPTIUa98zYpiUlY0i7lwWEbmTL2JcpS ruBap4YW8OEzArhat6NHp3bYZAeKoqA3HiSmVR5oBtkZyTRY7QS8HgKheGwOGZBQJIWAtwnVdBKZ nU9uajyts9PwqM3PqicM5LFri3j6L79H6XYXr9yXDpKENXkgD19ZyGOP3I+1y224qw5RNeUD9jps XHbRFVyQ+Vf+M/JpPitTeeH9N7i73w4efuiPxHcZxqU2C5phEgpqtGvlJhhsTbBuLRGtYujUqyex tY3IWxqbS0QCAww1QE2DHwODNrmpFBxIQt1b0bKOZJiowQAeb4CE5GTye/Skap0HSd2BGgrS+7Kh SFu+5q2/PUSPK2/kd3dchxUAHV1T0dQQIXsSlw3rxbXXXd7SEYEkMf2zdylL6Mlv7ruNRSXx7Fva yMWDIkh0gyIHOVjt56r0SNyxHiTq0XWDzgP60TYrlnW+RrbO+4RieyS55w1iyPXP89WEL3hw7kb+ +eFoHruhhDef/TOe3BG8/IchuBQZCGI4mm+tShJWScfv96MZJnLCQB67di9P/+X3yF3v5Do5PMxf lq10Pq87iYkghVZSWh/imk7xyHscLY8lhK+JJdBCBD1+rDYHHc/riVsKIgdXYQKJaRlccOudvPba X5kox/P8m8/hAIKqSUjXyc9J4lBtGqH6tUTmxRPXrgMRBxtwEsLQdPzeAIohQagJuy0RZ3w6sY4q IqMsHLS7yWgdR9tkjcaDdfhNiJOa60+SMAyTtMwsWnfKprLcT6vsfIJ7i7EbGraEVOLj3biNFHbL VqSkbLp06YzT1kRsahIoUWQn26k347m8i4O5kz9CaX8zsXY/DQ0HePv114iJcqMkD+Ivw2HMm09T nX4Vz/5+OPFWC0T25/ERxbz1/F8Itv81iVUVVM8cRbHVSu8LrmHvJJXLW0UiRzhItTVik3V8Pj9a cz7n2Hbd6JnfGsOoDH+nDQlJV9E0jb43/5p37n+dg3FWXv9jHGh+HFEOtJqg+HEUfhFOmY1CkhVk RUJXVZyx8WQlJ9Dk9eGw29k8axzDf/sMtbu/YsRdT+F1xUHDfratHsstv/snAVcMslpHY6iWz158 nC/mTuHxl97mPx+8x6yJoykoOMCLf3+AeXs9BPct5t57HmDV7p28//o7bCwoYOHX7/DYvz8kLqcd 0VYFTI3a6koqq+tFjQmCIAjCz1xKSgoxMTGEQiEkScLj8VBbW0tycjJut/vYCxmrHZsCl/72UbJ9 BXyzI0S39h3IdDvwB2Vc/kIWrttNyBpHekIs7fucT8H0j5k6bw06luYh0hIuhwUlazBdLXt4540X ePrNSaR26sHasa8xY/l2Qlr4zmGbPv1YMfoFZq4qwumwY5omNqcLqyQRGeHCqN3E16sOkZiaQVp8 dHOUB1r1JqatKSU5PZOsZDe33nE/gRoPChqmYbB04QxCzkSyMpPRy9cze2M16ZlZpLijkK12UhLj GHhhb564/1HGfbGcm+64CRMZBQNZtuB02lqC71ibjYa9a5i3YQ95+Vk8fPcjrNlwgCuvHdyyTpJT Yf/WZYybswZ7VCRy87PYTpcLpyuCQ0XbKNi1i8jkbJLiY1ru6NQd2EXRpmVsLSylIWQjOtJ5THAO 0KFzR0o2L+flt8ZSeLCSYddfwcIvJ/LgY29SVFrD9Tdew4zPPuGhJ9+mosGHIyISqywR1GHEzXcT qUSCGsBhd7B6ySwqAzJprXKJ9e9g+sp9RLhTyEiMPSo5WwxRjeXUqzoQT0/bQZ545hnmbS1Bqt3c Uh/p8dFY7C7sioTV4cImmZjIxEZHcsXgX/G33z/I8+99jcXpaCknqxxBQqiQ596djBwTg1UykCSF iAgHVoeLkLeeFcu/gehUMjJSOfzOzKw0unbM49F7HmH+wu1cd8swDu0p4D9PP8bCb9Zw432/xQg2 MPXDkewo8xKV0pG0pEwOLnqHkTPW4UrpQuc4GVmxICtW7DZby0W7bLFhs1mx2WxYrRZkJKxWK7IM Nrsdm8OJVr2Xce++xLsLSshPTaJ9kgPT1MDRkw6RjUz84BmmH4ggJzaay2+7lhlza+iXF0tM1kVc 06sNcRE2AkGZCN8O5qzZgxKVSGaSG8vhzgvvNqav2osrLoWU2Ah+fffvkQMg6SFA4vbf3Mq7f/83 zzz9BCsOOuhuPcAT/3yG+dtKUCSZSJe9+asR/t5IUhStlAM88+Z41Mh8znNtwdHnNiTCyRi3rNtH bsdM8eMo/CJI19//qnnAG8/qT25vWWhoKvNf+z2Xv7ie//3b7bTqMYjr+ufxwr0X8nFBMlfkaIzZ m0fVoid44el/MG3BYg5qWcya8zHTXn6ar75ZSn1EF8aPf5U3hndhu9yPThedz5yRo+jZtzePvvEv Jjx9BxlXPE1f13b++c4ChtwzgrkfTOC12dPZ9ObDjFpj5x9/vYiP3niDvsOfYcT56VQFLLTPO/mX c8WKFSiKQp8+fUStngFVVfH5fMTExIjCEARB+AlYt24dubm5LZmevV5vSwLVf789jZ3BbpiHZnDz 8Cv57Yi+P9njPJuppo6fcgq+ayZwzijPznfJIP1tU4/9EGUHnH4qNL7D1FzNyehONT3Y4WP8flm2 z74OD3/ehrHPsDB2BA8ObodVOfvPD9VXUa1KlC58n+WuG/nT1bnf7VhOUU71+7byzaJFxA95gIHx 37mGz3BaNYNXRn5Cr+49ubBfl9Oew0eX+pl+/87FOX2qzwoF/Lzx+KNc98pIchWTxtoDPP3Ua/zv O69j/R7fc0H4sdi6dSsZGRkt7bmqqi2PcO3bt+/Ud9BtrhiyOlzEow89xPALO6OpBqlZbZF8tVR6 TJLdTmr3rmTSvE3EpeYw4IL+mMXLmPTNVuLT8zi//4XkJbi58KIrCFis3H77LQzq4cDa80ou6pDH kKuuY9y/HuDxkYu47oEnGJBixRUZielw0OvCy4iuXMx9D/yLMn8sMaFDjH75Of71zteiRgVBEATh LAO2n9LnnUlAdPRUaEct/R6fee727WTv+W+FE0dPB/d91jlVIZ3qfUcf4/fLsv3dytc0ocetT5Dj 24eBwdmehaZh4Ksp5pP33mezdAF/ujr3yDRf56icHO4UOp/Xn9bfKzfvmdfdr87vRavM5DM6h6Xv 8P2TztH5erJOCFkO0P6KX5OrhDPFe8oOcMND/8AKmKYIzoWfvxPuoJ9serPv/4N7fAP+bY3ht/eM narXTtxBPzviDrogCMJPy3e9g364Hdc07QcNDGVZPu08zoLwgzDN5rntT/H6W996kkD8HE8tfPxI jzO7C/6dPw3TPLLvP6l5w48r97OdclkQfipOdwfdcrJG9tten5uG/Fv/etqLgJORZfmYVPXC6RsL QRAE4ZfB4/FQXFz8g7TppmmiKAoJCQkkJSWJwhb++44Pxs/iDu9JvxPneNTD8SM9ftgY89jt/6QC 2uPK/b8RkwjCj5Hl53IgaWlpBAIBGhsbW+aRE76d1WoVhSAIgvAzZxgGhYWFdOrU6QfpwJZlmfr6 empqar53gH7SUXxietUTyiHcyX5sICbuLgqCIIgA/UfVcGVlZYnaPAcXQ4IgCMLPiyRJKIpCKBQ6 ZvSULMtnHLBLktSS/Opkf9M07Zw9f66FAvj8QawOJ0677ZTPxZ19+3Wuhv4eu51jl/9QIw/D5W8Y BiFDwmGVARNdU/F4/FgcTiIcNnGyC4Ig/Az8LB4WO5zJ9XSBqHCKRl8QBEH4WTMM45h/mqZSUV6J 2Rz0Hd1GmuZxrw0dv7cJv2Yc164eu81z1c7u2ricj94fxcadBw83VOghlZp6P5V1AWo9IVT9uwTX EpJkUtsQRNONlmuHs93tcHBuUlnppbreT3mNn5Bx+I72D9imSgb1VdXM2nxkytmG6gN8NnoUE+au Eie5IAjCz8TPZoj74YZW0zQMw2hpJGVZRlEUEYgKgiAIv1imaaLrevNdY2hsKOOxB17gw8nvofv8 hAIeahsDWBWJiFg3iuqjpsGL1SoTCoQ4uHUZWufh9IispzZgYJMlnDFuIu0KILVs+1zYWdxITtv2 nN81t+Xuef2Og/zjy2L2qwpdOiUxpE8q+Ql2/LpEXLQVnyeEL6ATGe1A0jRCmoEvZBDvdmIEVQKq gY5CihuefHsDd1zTht6dElAkCTCpqPKBLKEbJhZFQlUN3PER+Bv9uGKcOEyNSq9JQpS1ed50g/sf nE23QdmsL6jiif+5lA5WjZABhiSTEKVQVRdEUWSsdgsWXcOrgWRCbJRCjdckwWFS7oW0KJlqP8Ta TKqaNKyyRES0HcMfoC4IDpuFWIdEdZ2Xsv1VrNgbzbDz3JimhDslj6uuu4pPPpoKQy4UJ7ogCIII 0H9cPB4PlZWVqKqKLMuEQiHsdjvp6em4XK7DlyknHYJ26ufcTj4k7uSZJTnJukcvOzZD/Q+SnfI0 GTBPdeF2uuyip9rO8c/BnbDeaTOhfvuQwGO2d/zcot8ry+qJn3uu5gb9TuV0Rvv7HYdUfodz4scc ZEjfOtT1+PL4obPlCsJPM0A3DHA4Hei6TsjvYdXUUUzc5CHTGaDVwNvIqpnPmCWHSIlooD5yAMOy yykuLaN47nN8VZFAB6eP3MH3cc8lbQmoOrqun7P8L4osHRl6f/i7K0vExToxLQ4u6eBm08r9TKv2 UOGzcM9NOXz99S52723kxlu6U1JQQl1QZ9GaMh77y3nsXV9BlUflYL3MA0NTqKnzMP6bg6RnRJMV ZwN0HvznIrJz49hdXEv7tgns31HJDQ9fRsnUlaRf3Zde3mJeLojg2RFZRNjD+xSdHM/vbujEV77l lDdpbJq+jsIglAQiGPNIKx59bhXJ6TH0PL8NMcW7+LxYJt3p4KGbE3n441r+0dvgvkU6Xwx38cKW aG5MqOL9TSGy7RqZvfKJ3LaJkSWRXJofz8AkHx+sbCIjMoS9VdwxRaOqGrLFIk5yQRCEn4mf1Xwo VVVVhEIh0tLScDgcVFRUsGvXLhoaGo5aKzwELeBtpKqinKq6RtTmoW6nmN0TSQKfP3BMcCBJEqrf gz+kYbQEAOF1vT5/yzqHh8J5vX5AwldbQX3wyNR1IV8TftVoed0SUJ3sTsSZ3JyQwvug6xqNTd4z DihNQ0cNBtBM6ZTBuaFrqKEQBuDxeqirb2qeT9UkEAjg9wdPfK8kIUkG3qYGKqtq8Xm9NNXXUl5R idcfbAkcTzzeI2XUUFOJLxBo3pZEfXUFvmCw5VjPuqDMI0FbXUUJTX7tSH2dUPuAqdPQ6DlJuZy4 3ZaRHEE/qgmGHqK0vLq5nEDX1ZPWi3mqOj/uPFQ1jWAwBIZGwO8jpJ9uSGXzVDOSid8fIBAIndsp E88iODj93TXztEsP73uw+XujBX2EjKMD8HB5GIZGZckhgsYPnS1XEH46jh/mfnhYutfnY+WaLTz2 wjPcc8elfDnuS9Zv3Mnjr7zI3ddfjGLoGKaJoevEpbTmt0/8nd/cfgV7NmyG5mD6XA5xPxlN08nI TuTWYV0YmC/RoFi4+tqe/LqLg/I6L03xbh5/8AKu72ul2urk5ht68LvB6biDNewxXdzz694MydKo jHSRkJ7AX2/OJyvO1vw7bhCTm8z//KEfl+e5uPPu83h5WCa7DwS5fXgeCxce4K2vyrjzynQc9iOX TaH6Ot4cV0B0n24MTQ2xs8EkOz2awu1VBA1ISookLSWa5DgH1igHGW4XOa1jcbpTSGyo48vtIQYn Bhi7solBFyYxf20Z/3ysD4/ems2M+cW4EyN54MG+/HVIOgvXVfCvpy/gd4PTUYMiEa4gCIII0H8q B9OcSbasrIwZM2YwatQoiouLURTlhHWXTPuST94bycefjWfr3hJMwN9UT0VFFUFVBwzqa6upqKzD 0BqYPHkqBdv34Pd58Xgaqa73Ubx+Aev316EBnroayiuqUYM1fDZ2Env3HUIzjHBwoNXxyZgvOFRe w5JRf+fD1YcoKatCM2HfmjlsKAti6ipVFeVUVjdgNAeimCamHgp3JNQ0YEigBT2Ul5fjDelgmngb aiivqAx3FKhBKsvLqa1vpMlTxfQ5ywEIeBvCx6WbGLpGfV0tNdXVNPnVlsDGW13KqrlfsWJPDaFQ CF9THZXVtYT0I8FPY0khy+bPpKCshpnz5vL2e58TCATQDJUdO3eycWshoFNbXUF1XUO44yN8acXa +V/xxnufs2bpQqZPHs87H3zE1AUrqaz3twRVfk8jVRUVNHr9GKYEWhC/3887/3qKFdu3o2Lg8/n4 z//8lXVFe2gIBKmrqqTJp6KrAaoqymnwBjCRCHobKC8vp9EXxDQ0aqoqqKiqQzOMlkAfArz9z7+z dl8dAa+HgG4iGSoeb+CY+tAND5OnLgRMGhvqqamqoM4TRJJAC3goKyunpjZcbwBa0MfG2eNYuL2U /aWFPPz4y/i9TTT5gzQ1VjFz3koAmuqrqaisJqDqzQG8hGkY+JrqqKiqIaSDroWoq62muqaWQChA 0c7NTJm+gPL9e9i6eT0HPGCEfFRWVNLkC2IaOj5PI1XVNdQ3esMdIADobNqylW0792IYGrXVldQ2 NNLU1EBNdQ3+oIqhhfA0NVBRWYU3EEJTQ3g9jVRW16NqGt7GOioqa1B1A5/Xi6ZpSBh4vP7wRX5D LRWV1ai6AejUVVdSUVl7pANMksA8ui7AUP1UlJfT5FcBCUP1UVFeTl2Tn6Dv2DoJ+b00NjZSUV3P 3jVz2FgWpGDOOOZuOUhjQwPegAamScDXhNfXxNhX/smCnXWAhMhAIfySHe4gO3yXW9d1DMPAqmjs 27uX8vIKsnJasXzxGnZvLaRLz/NITUti9Yo1FOzch2RRsNic2GVQrHaMgJ+QLhMZYUfTtJZtnssA PTyM/EhPqGK1EB1hI8qpgDMGtwVqymoobJRIjLCREa2E77pLkcTIBiWHatm+34vqjNtlC0AAACAA SURBVCFR1ig5VMM+n5V0l40sl0lxuZdQS+45mRiXBU3TcTptoBkYioVoh0RkVjZJ5UXsi0ykfaSC clSnaVLrNP5933nc3DcefA14ouIY2j+VvCQnFsXCrTd15/pudj5deIi8Ltk8NLwtpRv3UBi00KeV SVVUHHf1S2DMdoPLM610ynGzdH0tu3bV071rClabFUUDSZbJTYtiyZpytuz1EB1pPaaTWMw9LwiC 8POidOh1+T8aVBf3Duv6kz+YpqYmFi9ezIwZM9i2bRuDBg2iZ8+eREZGEhUVdcy6X4yfQZc+FxBR uZ6dgViSEyLZsmwuC5auQo9MQakvYsacOazZWkZWXIjX3nifA1UqsVoJywoKWba5jDTK8SZ3wq2X 882MGSxbW0C0U+X5F0fSFLTS5bzOuKwWQqWbeeipVwnJ0bipZEulRtHqhejuNkTUFFCb1B25aD7j Zi5i34EmOnTLxwqYmBStmc24WYs5WOqjfacM1s2dxjfL1lLukWidZmP8R6PZvLsER1wKjbsXMX7W cqrrdVrnp7JtSxFd8lOZN2UiC9cUEFIiiHIG+ejdDykqKqKoKkTXdtkAVBfv5LO3XmKTN4YEO2xd NoelG3cjO+PITA4Ppzu4dRVjPniXIjMeye9h/5b1HKqoxi/bsSgmeihAqG4/kyZOocIrk5SaTpTD AigE9m8klJJDjOSlpN5Gt16dWLx4CVZnLPmt0wDYtWI248Z+zrr9AfLyMqncvZaZsxawaNkGel5y MaHSQubMXsCS5Ru5YMilrJ63mA3LFqBGZ1G3dyMLFy5ixyEvbXITmP/VFyxeuQEzOh25cjOTZn3D tt015Hdug9OiIAG+7V8yqborfxzajR3zv6A4ugNZcjHjZu0k2r+L8Yfro3sr1q7eRq8e2Yx84z0O FO1i1c5qenTJZuWMycxcuIqVqzbQ48LzsQNBbwPjX3yM+eVWkt0xbF68mKC/jq0HGmmXn8a2bUXk Z0Xw2eiP2LG/muiUbBKjHeFzuOYQ86d9xdINu5BdMaDW8Nmoj9m1bz/V9U2U7lrHO5/OJDUhlsi4 SIhKoGLzIqbMXEh9SMFheNmwcgGzlq7nUFkt8emtiXEqgMne4gPY7QoH9u5k5tdT2b73AAf37WbN spUEnUnYmopZsHQp85euoTZkR67ew4r16/lmYxlJ9gAb165kwZLVWNzp7F01n4Arnlgqmb16P5Gy hzXLFrFkxTrk2CzMigK+mjWPTdvLyW2fQ4TdhgSUbVvKhBnz2La7mvZdWrNz5TfMW7iUPRVB8vNS 2bJkFrPnL6VMi8AsXMKB2E5kSeE6cZSvYeqGfWzaUUGus5aahE5sGPkI0/ZqJFg9rNlRT7d2Kcwc P47UHufT/7wM/vc/Uxh6eT/ETXTh56C0tBS3293SaaqqajhUlCSWrN1NtZ4CjYV07tCGnh0zjgnQ y8rKiIyMbAnWJdNE9pWzYkMBpRU19L/uFkpXzaPW2Y57b/oV7tgo5k0eR6nXIKHVefTvlkuMO5GE uGjc7gSiHTZiYt0kxkViGOFRVIdHsH1fOwq20NDoIb9LFyzNgXpjQCeAhNMKGDKZMTKrNpVixrvp mhOHzTCIclqwWuy4TQ9TlpWwsbiJDp0yuaiti5mL95PQLoP8pAhaRepMW1dNZLQd2TTxB0IYBsRG WDGRcUU40A1QHFacFjiwo5z0PnmkR0j4/CpNPhVvQMPEJCraitev4pEiiKmrZnqBh+6d3KTG2Zg9 ZzcL9xn85socqveXM2bOAbLPa0PfeIVol53EtAQSU1wkRjnIdNtIzohh1ZJC9qjR3HlxEl6/id1u xSWZuJMiWLG0GF9kDN2yo8hJcYVHnxkBdu/axfY9pQwaeL74kgiCIPwEVFZWEh0d3dKeG4bR8phY fX39z+sZdMMwSEpKoqCggK5duzJgwAA8Hs9Jp5Gx63UsmjGeCn8Ed12Sx7YpIymK6skl/aOZs3Yb 6/bMIuXi6+kbEUlcbg65nfrx2CP3UDrrVTZXted3Nw3EO/1f7G/Q2Pn+P4gb/nfu7xiD7lTo2O18 nvrzXVitVkwTbBmd6dz9/9g77/A4ivOPf3b39rpOujv13mVbtpFsuXdM78Uk9JICIfxCAqRAaElI QgokoYZQAwmd0AkdDC64N9lyVe9dJ+lOd7e3u78/TtW4gU0CZD/P48e6vbnZabsz35l33pnL9Vdf wLL71mP2jufKY61875HXuCJtI5Vp51H78tNknvlLikKNhCNgN4GuaXz4+nPknn0bRcF6eprW8JtH 1/HIAz/m3htuZGLRJSzdpXPHzcewp7aDDe/9m6Izb2GC2kR3r48N69dz8gwHL64Pc9dNZ3DHjbcS ufpHbN3Zwc+uP5OXHryLutPnkwk4Y2KYd8LpxJx0DpZt/2J9m4fLjsvi2WcfJWfybSQDbreHhad9 g5yzz6LlnWfpzi+hKCWWmg3vMJBaiqdrF+3OGEzeAmYclY8eDgLWwRIX0DUdk8VCa+VqNlVsJH/S FMYV5Q9+rxCWnBQVj+Nv/3yLuYURXv+ohm9ccBFKex1x2k7ueaaKa66+nED9DpxWlbf+vZTzvn0Z 8wv6uPCqd7nh5qt49Z67aSjReGV9F9d860R0q4WlTz5F/LE/pEDzoesjUm3nRxuYduwN6EDtho/p zD+XOdZ2lq3egbJ5xaj6CLJqzWau+s5i3np3PX9/7mHu//432Lw4nrv/tYenH7+JWy77Jv1chwuQ TWZmzJtPwalXscCxi7+LNhaccCr//PWP2TLnD2zesIETZzjY2Gznl+fPo6M/AMSB3sfuik9YVmPn JxdN5fEH7yf39HNo6hL53slH8c5bL6JMO4fzl6Rz9qJxvPj+KhrqgzhaKjjlwm+wc/lSHnmskczM WCZMK8NfuYX3PtrIt86YAehU19SSkOCmoaoKZ9pEbJ0badNSKcl0sruyio6BWuoicZx+xlSee3kF jW0b8aXP5vjTFrPzxdvom3gm31qSxh0vfMx0Ww07NmZSUf8WWukF/Pvvd6FOOZcTZ9l5dukm4mpf JP7EKyiVFCRRHN7Lv/TVZ/DOv5JCIYAUKOeWez7g3nuv58GbbqFpqsSvHl3HC0/+lrbmVjY8/ADd Reczx9LGx6t3kJy8iR1x53PrkhK2/f0GqlLPpWzGDDzH/YQTcjr51vnXs3iGi5dWNHPaxdBvG0d8 6AmjFzAwgE+tcosmG8eefznHowM6Slgh6+LvgK4R9PXQ296C7kjGKds4ZlEZ3jiIUyMQXwyqimZP 5ig3hMJRny9Dq/JHgoRYiW3bqijfWce0CdFJ5J0dYTZsb8e0qz26rUwUMDvs4O/ntQ96kUSBHXoP oiSwY3MDy7d3kzcxg53b26k3i8TFOwm0dfFyUyeCJJLqkVm7roFVg6vQZpPIa029SJLI1qYadFFE wsfOrQrvtAgsrmvmlQZhzNYmsyzy0vvVwxY6siyTEgtKMMSLHzVjcTvJAZavqAJRJCc9BrWzi6fe 6USURCR62blNwGwSePItH4IgYPfEgB7iuTcrESURqvpYp0ctCjxJLtRghI6WbjjKC+j4OppZs3I1 9uRso5EbGBgYfE34Wgl0RVHIzc0lOzsbQRCwWCx0dXXtM2zYksyppy9g27ZdtNQ3EVFUKle/TtVG D+PKFnHiFd/j47fe4JcvreD6e/6AqA6wp7IGxR9ifFkZGUl2dosiAjqKJYY4oYemDhOZWV5kpZft u2oYPz4PkygCIqZQD7uqmxgIR8ibMI7YDBFZa4saIOs6p37r/3j4kbt5eGMD974wlzhT1Kzt5Iuv 4KGH7+DRHe38/g8X4++t5t6/3Idz3HTi4ks4bdJybrrxpyTOuZzvf/MC/nL/bTztE7n+jpsQdR0T CrEeF031rSSkxTOAGW9WLlnxLrzxXvyRaCsQRQk1HKR2ZwV5ioLVFkNXZzfuJA8DGiCCSZYJ+Xup 3dNIRLATn+IkO9lGZ7CLbiWCak5ldmkWjz90H7/cupkLLr6c1MQ4ILpnvbWnk4Q4hYwJMzntuLMp TYnWhQ4Iyh6ee+MjyhYey5zSTuyqjzivm97ubrp9/Sh+H55EL93tHfT4+lFVFXtmPsUFeYimOkS9 gwfvvgunKxHZM52LF7Xz2D2/pC/vXG664Epeef5pHv5gK7974p+4bTICEJYkRKIDyjivmx1VO6gO NKICp152FY88Gq2Pe56/PyovBYG4rAJSPU5SU5Pw9/rwZqXQUFOLLltGVmkFAVEQqd+5m/bCCK70 HLLiY0hMTsAf0kCykZheyuzUj/j5Lbcw4YQfUJyfCqqKRdKwx1hpa+3Ek+wlLMhY7DZ0JUhsQhpd oSA97c1UN3oRJBFMZmRJQ40ECZnsWIQQ3sREsicUU91aSyiijDR6IXosksWdSHx8Cg5zB3EJmRTG BKivklEVgRiXFb8m43A4sMoSnuJicrOddDpc2DQffZoLQQsx5YxzqHziBV7Y2Mod5yexttzB0g+f o8oSw/hZJ3DiiT/g9Rdf4sZ/r+fmBx5iTr4NETjpsqt44u9P8bMPt3Pnn76NqrZxz513Yk0vwqwE SM5Kpa6yCntsPLFeNzsrd1Ld3zjoq0CiZM4s4uNGXlsm2UzDru10J2Ry7jwHt99+PwsuuXWwGlRE SWKw+RoY/M8iCAJWq5VgMDjm+t6fGRgY/jNxwnyuLTkaHR0l2E9vHwf05xCJRDAdAUdluq4z94Sz mXvC2cOfARZMSWHBlJRDi+Sc4iNafv933pevToccj8Yl5nD1j382fM1wiGlgYGDw1edrNW5NSUkh JiYGi8WC1Wqlr6+P5ORkvF7vp8JmZKTiTBrPFd89lZrd20kfN5vSyTNIi/eQkuClevc2FHMs0+fM JTk2mZl5TpYuW02f2UNiTHT/lyMxC49V5PxLL2LjO+/z9N8fYWNthOl5Tl57ZwW+0JA4sjGr0MGL //4YU2IWiVZAsFGYm4IrLZdkp8TWLeuISR/H3HmziDWNdMDbyjcQlzWROfNmk5izmO+eOIXk1HQ8 rhhM/koqOmTKps+iKDWWbdu2kFRQyqyZU3HLJnILx+FMm0WeVs4L736EJf8YZiVYyEhPApNMUnoW 9sG+3OFNJDElmV2rVuO3FuDuWcUba3fhyZ9DzmAriUvNJC7GxraP3qFPtZKW5MbscBEfn0RavJfk WKhtaCLizGbmlMkkxzkG86/SHdKpr2pCUQTS0pJxmNSRAQWAnElpQRK7Vr/N7tZehMxjmBSvs/zt 59jS4EdKXUypN8wHbzzL9g4dUbBRkJWCLOlgncIFx81iXEEuXk8SrkgdW+oD5E6YxoziHHZXbET2 ZjFn3lwSbPJwGxg3tZhtH65FUXVKF59A3VtP8vQbq0jPSmbbmPqQKSrIAmSK8jJA10nKKcSbsYC8 yGaeeOZZNtQEhm0FTGYL2UeVUfv+8+xsCVGUm4YmSCRl5OKxWcnLTMTXXkV1v5Pp02dQlOYe/GEc CVllJPat49XlG4ktXMgE2UfF6vd5+aONmBJLWTLejRBsY+mmGtxJKcyeUkxmWgoP/fkxAkGZE884 GZfLhVUAtyeexPjYYXWemJCAx+0mMd5DnMuOy5tAbIwLye4mMdFDnFOmcstqHr//UbKycymdswCP w4IWhhNOP422yj389Z7nKZs+lcTUQqanC5QcfTKyOYZTz7yIcXnFpCXGk+x1s7tiM0JMMrPmzSU5 xjr8oqnYsh7Zk8nsubPw5hzDd06cRk52Np64OGJyjmF+Yjcvv/gCz7y5ipJFx1P35j94+t+rSc9K Ii4tl3izBrqOKy2PFKdE7vR5NC59jvL6buaeegpvfdDGBbMTQVcJdO6hR0o3xLmBIdAFgXHjxjEw MEA4HD6kf8EBPz6fj15fLwOhMIqy/7ChUAiLxUJmZuYRSevenw3Rue9y2rtYjHIyMDAw+Jq845dc +Se9zu9l9eMXf6UzcrCZ4/0fw/S5b8ghuYfe+2iwoctwgH2x/8mjoQ5+r6EVjM+Tnr2PF9tXnRwo zJGo+33XiYAgDHDDNb/k+zffQobH/hlKbMi7u0b9nu2ENI0nn3yTm3/1U8RDbReHWMYbt6zjw5XV XPu9cw7r2TiU8q3+4CnWks+8RdNJEQ7SWj9rPvfzHHy+Fss+j0Ns2fQKD21O4OZL5hAJ+Vn5/F3U 5lzMRXPSD/K8GRh8NVi3bh15eXnDTsH8fv/w++/X973GjlAJesMbnHf2SVx+zszP9378gvtiAwMD AwOD/3XKy8tJT08f7s8VRSEcDkfH49XV+zZx/yp26Af7/dhjmI7E1IZwyOH2FfIgqf0PHg118Hsd Tt0c6Lejj6z7Iut+n3Wi64CNn161hFpfmDS3DfEQ4xkKpaoRaretZWu7yCXXXIfI4LFyRywPOpnp WRw73/0fKR/vuJmU6Q6cEUA+SGv9PGV+xFrsp9E0jSCJXPaN2QwdLacmzYuKc0MwGPwP859u+8az ZmBgYGBgcHiY9tfB6rpOKBQa9hL7RSBJEna73ejQDf4bo1Z0XcedX8aQ/D10IRe1OpBMZuaecSlz P/PvOcR7CHg9CXg9CV+4yNR1HVdqLq5R+fuqPJe6riOKEtklswc/g2y2s+jYeYPnEBnvFwMDAwMD AwMDg6+wQB8a9NbW1n6hg2qz2UxycjJ2u92oCYP/gkYXDvj5AL/c5wLykRW0Y+/xRYvlsfH/Jy04 vuB6PIIr9wYGBgYGBgYGBgb/VYHu8/koKSk5YkenjEYURXw+H/X19RQVFR2W0N97EG6YtO6jHPa5 B/irtVJqYGBgYHCE+oTDCGPw36/HQ5p8HPa38qVJ+afHHPsYm+zLJ8sh59ngM78HjLI1MPgKCfQh wuHwyLmpkglBj6Aegl4XBAFRFFD3E1gQBFRVHd4c/3kRBAG0MO2trfgjJhITE7FbpP0MMj67IB0b z+cXtPsb9HyRg6FoGWv0+8M4XVYkQIsodHe00BOEtIwMrJLxEBgYGBh8zUfkg0It2teooTB1rQF6 /GEiGlgsMl63jTSvdXiLmyHSv7wIQvR41uBAiMauMJI4SmwBJpOIO9aK0yIh8GWadIlOFnR1BfAF IsTHO3Bao2ms3NHCzk6VGaVJeO3RoemuimZ2d+vMmZpEnDFYOWKTJIIgoIQiBCM6VquELIkYnlQN DL5CAl3TNDRNQ9d1dE2lq3Y7Pkcu2V4ZXRcwyabBPZ46kYiKSY6eLy0I0N/XS0e3n4y0JCSThK7p oOvRPe2Dx6YcsZX53nqWf/Ah7XI+Z50Yj90iIQgCdXU9dPaFMVtNxHkdpMZZPodvK4H+dh89FgfJ LhMm4fN5DRcEgb7WHso7VGxCBKvHxbhk2xfeaYaCCkuX7WHRyRNxAZqqUL99Pcs3VTL74uuY4jUe AgMDA4Ov84BcZ8ivo86ena28s6KW11Y2Ud0eQEPAYrMwflwSZx2Ty6LSJJIckiHSv+xoEWp21vKD hyuxmgTCavTIUh2wO61MGpfACbMzKCuIwywIXyr99coLm3lmVRfX/XQuR4+LxQQ8ft+H3PZmgLff XMJxBdHjQR+8813uXKax8sNzmJXmMOr8CE2SAGxeW80b5f2ceVohk9Mchjg3MPgqCXRVVVFVFV3X iYT8bH3tQdYU3sBPjvEQCIXYvrGcoGhBtnkoyolnx8Y19Kkm0FQSMjy8+soavnfpyaxdtR5rTByS xcnkiQXokQgMrqAPrc4fDpHeJjRLEoXFs4mPkYdPgHr99e28v7mD+Lx4jp2bQUGKk6AvSGJqHLFS hJpWP/2azKQ0Cy1dIfr9IbDbKYyXaegI0t8fJjM/kR3vbuU9OYkzZ6VTmmpBEgV6WnvY0aGgKxFk q4yoRVCtDo5KEtnaqlGSE0PlrjYSc+JxmUUEoGZZBXfscbAwsY8Vfg+PXZxNTVeISDBCSrYXenpo HhAQVCjMcbJ9dw9Wi4Qtxk6w20dqfiLVmxtJm5hOZ3U76fle6na2MyCaMJnNjM+wsHJdK45YGymp sfhbuqjuDPHxhhbmnDwR0DFZ7EyYPI3emu1U9uhM8RpvZQMDA4OvrTwftPrSgcotNVx9+3Le3DbA lLIUSian4raKNLf1sXF1Jc+/tpPvf38Ot11YhMci7HWa4r4tyPYl5D+rxdg+r38G8+wDTSZ8nomG z5Ke/4Z1XPQGGh3NHbz3VhWe8QmUZTkJqzq6rtFe1cab7+3ikTfTeeDWBZw6Ieaw9Nf+6vjzmkX7 egLUNvXjD6nD12x2M8SqyKOsAewOC8SqmEThCNZ11AHrvoPt+7tDquMDtI/R5XS4bf2QJuQO4Tn9 5KMd/OLxJrKPSo0KdAMDg6+OQNc0bVhEa6qGKFuxSDqqqtDbvJWHH32WgomFNDd1c+5lJ/DEY8/g zUynYtN6vv+H22htaaKxcRe/v/0vLDpuPo0tffz8j7/BpYXRj+QKuigioKFFFMA8/JIz260U5XqY PDuH2L4ulld34B8II8YPkKt08XFjENGbzECdn62dGqZQL1tCbo6OV2iJmBAHBljWqODuCNOJj7o2 L8WJZmxmgZ2rdvDXOjP5mo+Kfgszs80srxZ48Fup/OXJOu65bhL3PlnBVdfOJsZsRgBEWSI/18u8 CbFUfxKifXcjd7/bitLhY/Z5C0nevZXH9wjkeeP42SVp/Oa+1aTnxrNoUSGtH24m7eyZvPTASuZd eSLbXt7CNT8s5f7ndjK+OJ7aej+XXJLPTXev44KzCikIKfz79d0kZrjoCQlEjcMGzRsjChFETIY2 NzAwMPhaM2wO3e3j57d/zJt7dC6/cha/vHQiybaRTmDjql1cf9dq7r9nBU63k9+flc7YddcRAREO KUR0AbvVNGwSz+B9hizkooMIlb6AimwxYZXF4bTsved4dHh/SMNukxEGRc3BRNdYkaThH4igAzab GUkYivvA29P2vsfQ36FgtK90WKVhkTUUduj/obADgTARBGLs8nAce69a72tv9cGu7zfvQ3nzODjz /DIePj9v+KvOpnbufWwtv3i6iQdfreHUCZPYa7ZlTPyfus9gHQ0mavg7JawQUgWcNtOn9jB/lsmI yy6fxdkXani8Nj6L4fro+6gRlYGwiiAIOGzymPI7mKAe2bWoMRCMENHAapWRJWGwGY+059F1DBp+ fwRRlrCZpU+1raFQ4aCCooHdLn8qTcPpVyIEFB27TUYa07b4VFsd83ztJeQ/3XaEYWuZ4ICCKMuY TcLIczr4vcMuIzvMOGym//zkkoGBweEL9CET9yGxrmk6aAqhnkr83jK+e8nJ3H39lWxvKMCfOIOb vjWf+/6wGyWioGsayDbGzT2Jyy86macevp/6fpUJsoqqCV+I87nRKIJM2VHpnDU3mRefqSchM4mr 5nm447kG6pr7mTZvHKdMTeLtv68gv6SAU/NSuOsDP+vW7OKki2ZwbBFc90gzOTYTM8vyOXpSLEPv Mk2HeceM4zvpXfzkxQD/d0Eh1Tcth7gETkjawwtvbMNcnEum3cTQLntBh8rKNtZYY7nl0iI+fmEl uYVJSGIv26oGKExxs8BuQfGF6FcEppSmkplkpT+kcsqcZG58ehuTTpjEunfKsaem4vJ30x2XyJVL Crnj9nepUUwUTc3kiiXFNO3axZPuFG5fksZv7v2EiNHWDQwMDP7HiA7INU1n04oKnt8ywMyTp/DX KychDg/uowP20pmF3G8TmHvF+zz2z01ceUo62WaBgUCIVavrCdhjmJIls3JDK9vqegnpJoqKEpg7 OZncePOYlUK/z8/KTS1sqeymqSuM3WVjQkE8syYlkh1viYqRYIgtO9ppCEkUpjpoa+hk7c5OWvtU kpLjWDAtlYnZMciCsC9tOUZMd7R2s2ZbOzsa+mnrCaJqIl6vg8JsN3NKkkiKkREEfb9m3oIgoHT1 8uamDpIz4/EKIbbs6qC82kdIMDMu38sxs9JJdkh7CVqVzVta2LCrk90NfkKI5GS5KR2fyJxxcaDr qKEAL33Ugj3VzUmTPFHhq+uEe/t4eXU7WfmJzMiNGdSLGp31nby/u59JE9OYkGw+pFrWImMtEb2p CZxydBa/eLSeYFAdFtqRYIiKne3U+EWmTUwmxSUO57+3p591W9sQ4lxMnxiPg8FVXXRam318sqWV rdU99CoC2ZlusjxmAiGN4nEJTEh30tXqY9X2Ttr9EaQhUQqYJBF0jaQ0L2UFcbisIh0tPsqbFWZM TcZhOXSJLggCdVUtfLK9h5rWfjp6w4iiRHJyDBNyvcwtTcIhDWrZfdT1UN1pwQCvLmuiob2flq4g wQi44+wU5rgpm5RMrtc8djIgFOKTzS2U7+mmtnUAk91MbkYcxXluJhd4sInR3NZUtvNJRQe76vrw RyApKYbiPA8TCzykx5kBHV9nH8s2tlBe1UNHQCMxIYbS4kSmjfPitorDbb25sZtPtvWQlZ/A1Fzn cB1ChG3b26loVykrTiDHawGgvqqddZV+CgvcmJQgn2xpo7LJj9lhY/LEFBZO9hJrlQCdbRWtrNzd hypofLC8hmBbN5qikpzuZfY4N05jv7+BwZdboI82cdd0HdkZR3fNBj6xOYngJcu0haUrVyOmTWd8 ai4V0lKWrlxDS08Yi8lMvNeNKEh4XDYGQgpOTxJmTUFVNTSEYfF/JMYggighmaShyV8EAZIS7CR6 bQDMKEnhk8Ywb3/UTGZqLJ44nZBFQgWmlqSwzjfAx+t9tPVZWDAzA19bPx+0+CkZ52WS1cLS1m6q 42VKM6JHwsV5nHjMAqouk+G1oOkamekxmESR88/KYcr3N3Hf3SVYzSNO8OxuO0tOKeK8SdFON4JA caEHEx4sXjPpOYnEa2ZeemkrfWIuC2dlYfF38mKtn/NPy0R5bA2nXTeLN+9/B3fZUdi8KsW2KlZv bcOalkKJ28Sa+Gh+HR4PWWI9H2xuR7c5sI4qGFGSMIkiutH+DQwMDL7G+lwAmxNUwAAAIABJREFU IdqXv/BWFYLLwnfPHxHne6/upRZk8K1ZsfxhXSevru3j6jkxdLX38tPrXmGdPZWL5sTwwbpOdIuJ gf4g3X0637yojD9feRQpg6vx3e3d3Pf4Bh5+uwHJaSMxTqa32899vRpHHz+R2y+fRIFbRu/y8dhD K7lrU4hjS+Npb+ikJQCCqtDcFuSoBeO5/8fTmJ3t4GA7qDeu2cWNj2ynYUAmwWVGEnW6O/roDMlc fMl0fnFuPikxJoQDRDOws5bzf7qM9Im55Eh+yuv8SGYJv6+fTp/Id69ZyJ8uzMNpFgeFksrbb27l 5ofKaQxKpCZYEVWVJ18ux5qayl9unMsZxS60YD9XXvs6fZMnEXj6aERA03S2LC/nm/+3npIls9j4 x2nRMUE4wlv/WsNFjzbwwD8uOmSBLu5lDufv7GHZ2hYsGbEsnJE0fD3Y1ccjDy7nb1UWnr3zFE6f MDI+qa1q4dpfvI1YMonn75hPHtHJlvrKFn57/xqeWNmOPdZOvF0kGNHx9/TT3qBy02+P4bZz82mq buOexzexpjaA2RSN1ywLNDX1EWnsZ8GVi3nkh5NxWUWee2wlP3+hi+f/dSZLSuI/U5N+54113PRK B7LVQqzDBJpGR1svATmGG66bz4+PT0EWhQPWtdLZzKW3foQt1obbKSNL0N8XoqEjxKlnlXD31VNJ s0dXx5XAAI8/s5Hb/rmdDsFKboKVSDBMc3uAjMIU/n7XyUyN0di8rpKb/7qBN8p7yc6MxSFBR6ef oNnGld+fy29OTaejuYs7/raGv75Tj93rIskh0tLmR7XYuPo707n61FxiB6t8zYrdnH39ei758WL+ /v3CUakP8s9n1/G79/t54PeLuWJ2IgDL3trKZXdtY8r8bNyE2FQbQJIFGht8WBLi+dON87lsYQpW AV58qZxXNnShCQJP/msrL8oioZDCwhNLGJfpMgS6gcGXXaAPraBrmg6CRErJ0eRv3M6eqi4S8oo5 /8xZLNvcyIkXXkaSKcBEr59X315OjCeX1Bg3Ry+chcPm5riF05DsTkrnLMStB1FUdXBW/8gIdEGA rtY6uszVzCoswiyJBIIKDpdMTyDI+h0dWGUrqr+HD+uCzJzqwOqy0dczwNatHcRbLGxYuZPtjX3E ZqVxzIR0GqtaWduqcvTMOJRYF+GttXwUCNPXFYvTItGlWRE6eljXp+C16Kzf1k5iip3yXR0IgX7i s9wozZ2s75aGrJLo062YfB2s2SYjCpBVmMbL7+8mMdlBvN5P+fYuPq7oIy0/nWBtNx8ua6BbN3Pi vEzW7A6zaHEWvj3tZBZlIogDrK/WOSpb5vn36pg9O4v6nd1kxpvZuKMDRVEZnyLyzvp2ivO8+HtD xLgsaJpKc10lO2qbiZ9vmDAZGBgYfG0ZNHXVNIUt23sxmz3MnWxjyJPz6D4UwCyKzJmYTGRFNdsq 22BODKIoEhtjRoiE6RBd3PqTYsYlWuls7eKx57bw7PNbyMlN4PYz0ogMBHjh5c38+Y0mLrt0Blcc m0G6W6anw8djz23iD6+Wk5Icwz2XFCCIIs4YC/T1UO+L8I0zS5g3wYusDPDkS+U89O4unp+ewozs ouEV2f2RnpPKDVe5iU+MIzvBhkWCnvZefnffCh58dAPHlSVwdqmXA6k2QZKId9vYvbuVrDmZ/HJJ KYVJNnytndx872oeemgtl5+cyZQkCyJQX1HNt3+7hgkLi/ndkkKm5LsQFYVNm2u56jfLueqO9Sx6 eCGuuATOn+Xm7m1tbB+AYlt0bPXC2/WIXivbN9axY2Aa42ygqBortnfhyk7mtFI7B3WtLQgQjlCx sZ6/OxWCikZEUdhZ0cory5tYfEwxlx+fMhJcFLHbzcQ5o+bco5EkCZfTgmgzDZudK70+7n9iHQ8v 72TJmSV894RMkp0iXd1+nnhmEw91t2M1R0PnTkjlN9c66QlEzc5lswlfYyu/fmAjW70ezluURmps dMhps5kRYi1R7+GfkeIpBfyluJicFBfJbguiptJU18mPf7eUn9+5lvPnn0KmQ0I4QF1Ljlhu/dFc SgvjyEiwY5Ohq93Pqy+v56an11M6PZebjvagRjRWLN3GVXdtpHDWBO68dDwl6XbC/UHWlzexrKKb 3hB09bZxwx9X8Ga7hVuvW8AZ0xNwSTrVNZ28taEVlAhoIZ5/eSO/f62B05dM4Wdn5pIaI1K5u4W7 Ht/E7+9bgyvOyQ8XRwW32WzCFWvZh4WBgM0mI8eYsYyamDFbZRJjdCrq+zl9UQ5/Pj+FdLeJLav3 8KvHt/LX16uYPc7DUSkWvnXpNLq7+rj7w26uurSMxRPdaGEVb1IsCTEm471pYPBlF+iRSGSUiBbw ZE/k7IKjoh1+JEIEkXPyphCJKPT3RZAdicyZnoMzvpBYSSYmP4tIRKMoP4NIRCM9Nx8toqBqUbOp oQmAw0VypZGaVEun1k3/gIrHKdIXiCDKAv3+ELtqwtHMOhzMLHag9A/QCIioNAfCNA0MMKCJ2OI8 zM6PobMrgN3tYpYXfJ1+utp1UjO96LpOU0sfug6iJCKG/VTpAhYJqhv7sDol6lv7aKrq4eR5STS0 9o/pHkRJQlQGqPQHBlf9BcpKklE1HT0yQNBkZ+4UJ5qqsaMpxLjxyYjodLT00KpDrFdmZ60Pk8mM 3tbDbh0kyc7cEjuKr5+qbnBZRXbU9IAAcoyLeROjJmaB3hC4LGiRMP6BIKbkQvJjjQfAwMDA4OuO roZp7hOQ3HZSxP0qeSRRIMljAVWj2R8e+jURTSA7L53nb5/PiDupFPI8Eh9970M++LgazkijrqaL p16rJH1CHhcfl4kUCVPTomCx2phRmkHB2zWs29JMIwWkCdF9xPbMBG754TzOK4sbjtmhBlm2qp7d zf00qpC5vwW9wb3S4ydmMH4itLf1UtPST2dvGF2SSEqwIfXWU9kVIgDYD+LSLKKoTJs3kad+NQ2v eSSfVRv38MOnG1nbFmFyggWzCI8+tp5G3cm9S8aR6ZFoaQ9EJwsKMjhpUhx/eLeK1d0LONYrcMzc VO7eVM372/wUl9kJ+7p4bV03Jx5TyCdLq3hqVRe/WuQhHAywboefvDkTSOEQ9DlAWGHT6hp+Xl7P 0HqHpmpgkvB3+3l3ZTOnzkzh8+iudevqeWVpE3OPLeEPPywjwzb0TTx9VU28+FEb6uA97S4HUyaN djYW5q73N7NnQOKqK6ZzwZxEbIe5MKvrOrPmFDELjdp6H41NvfT0h9FEE1lJFpbvaWNHv0aGXTrg HnTZncC130ygo72PujY/VT0hBkIq6ekxIIus39YKR3sYCAR54PFyiE/krpsXcHTaUAZimTAuiYtU hS5/iA3LqnmzQuGi783kF+eOrHbnZnlYvKCAPn+Yyl3tPPVqFUWludx5bRl5Uct0stLicFsFNl27 lJfe28OFixPxfr7Cwa/IXHrBVP58UcHw1so5xTaWbWrluaou2nsGIMVCWlocxWl2RN1H6eRkFu91 nI+xB93A4Esu0O12O729vYe0yi0IAtOOOxtR0NG1CB2dXYeUALfbfdgvbFzZnHhW9phrSR4bx85I P+R4zj39SBZr3pdzkKbrmMw2iuecQPGcaO//ec91NzAwMDD4iiCIyALounZAfyQ6OhE1uhXKNLpf EERMZnNUnI9y8haX7GFWFlR29FEHdHX2s7U6iCx3ctsdHzGgDDqwEgVCgTBNIYEsVDqDkCaCpkGc y4o3xjJGGDjsFjweG4GwRlCB/XkSG0pHV2s3r39QxfPLGqnvDEYnvRHo7Q2gahDUddRDKCZN08lI jUWKqGAeOWouLSUW2dyMb0Ad3BoWZOnGPkxmO48+ugodhsWxIEBbUwSzTaWxS0Xwmpg7PQOLWsmy tc1cXZbH9vVVVOgu7rtqJnfsqOW1Nyv51SIPfY2tbAmY+MGM1Gj+DuIlXdcBq5l5x43n1pMz8YdV 0CEcDLNnTyuPv7qLy37Zzr23Hs1353522benrpddnSbOmpgYFeejnAEMhDU0/dNO8ITBfdLP/WMN t73ayLxTp/KjkzJxygf2JXBIzVgQqN/TzLPvVvHqmlZ6A5Foe0WgsysIIvQr+n637wmD/gwifj// emcPL3xYy662IGg6ER00RUGUBAJ6dOEoPNDPyu1BEqcWRMX5YAaG8ynJ2HU/aze2Yklycuzs7FHl MOLsLcZhpqKzjy11GvPmJ0bF+ajnKCU5jnkT7Kxs6mVro86CtM9XSJookxoXtfBA16PtR7bhtplR wyphbaRklMGZFUVR91lOBgYGX1KBLooiRUVF9Pf3f8aHVUCQZOyDnkz33xFq2O12UlNTD2/csY+0 GS+XQy2rI3Wsh4GBgYHBl47BA9AFyUxmgkBFr59qP7gde+3qHhQeEVWnptUPJpEst31sRKMUqDD4 tygK2F0mIprGABAKK3QoEhPcDkoKPQQUbfjngigw46hk8gsSSZEBLZoATddRtbGeqEVBQBREBOHA xzMLggDhAR7951pueb6OvPEpnLQwn8L0GNISHaz5uJzfPV3NZ9lJF/WRM7bPlCRpOF3R/IRoDgjg MjMhz40k7mUuPi6BU00CUzwiCBBXkMoUr8Dyjc1o5PLy23XkTMxkYYaD2kXJXPpSLeU9U2jZ0oJi NbNwetJgD30IFWySyMxNYHZpytivFuYyKc3Ccdes4ul/7+a7c72Dq6r6IR6NptI7EEGVrdgd8vCY 4YBpGSyfT96v4IbHd5NfWsDtlxSR7JBGPJEfTnP29XDrnz7msXV+jpmfzVnzveQkO4l3W3n9Xyu5 /13fQW6hAzqvvrCOS/68lZzSHI6fm8ukLBfeWDNaVyvn/nrLcC41JUSnKpERbx8uOWGvsVRI1ekM KFhkEVecdUy7GQmmEgwp9CIT4zKPxDX4vdUkEWe3EWxR8fcqkGY+hPLeT61po57TaKuNPk/7mrYw xn8GBl8tgT40O5iUlERSUtIXP4YwzGkMDAwMDAyOLIPdqiSamFHi4dV3+3hpeRdTjveMrIYOncEM RCIKr65uwWI1M2NS4v467OHwakSjtU3FmmYhGfDJJlwmgXHFGdx4RfEBk6bpB0m3cGiqumFbA08t bSS5OJeHfzGHGRmWEaHcWovDLHC4rm4+NToRzCTZdPaY7Nxy9SzsB5OEkoPjp8byixXNVLR18dq6 Lk6/bj6gc+yiPOL++RFPfNyGa3snsckJLEgTOah9+ygiEXXMHYfO8k5J9ZInKfh7BvDBoLNYYXDF Xx8z/hJFEMdsfxCxySKEw4SCkU/FLYl7re4PXq8sr+aaezaipyTxux+UMC7BMpyXwx3lbV65m3+s 6ebo02by7A0leEatA9WvsYLgO+h8hq4E+N1jFQjpaTzxm2OYnjbiiC/coo1pmKJsxWtS8Xf6B9vB 4Or8KMtDiyQQ7zATVPx09QwAthGr02GRLCHLJuxECPiVkbgG4wlHNPzBMGaLA4vdNPZZG4preIJD GJkoOsRZOmFfpa+DPsYE4tDbm4GBwRfPvnej/YfFsiHODQwMDAwMjjTRwb0kiZxx4njsSoinntlA RWdkpN8dPhda5eP3tvPqln7yitI4foJ1jEQVxb3Da2zfUs/mNomCokRigfj4GMrSBVZ+Us17tQOf Sk3YH6KxuY/IoUiBQxTV9R1B+vrDlExOITvJMua7ju4wQUU7QqU4GhvHlrhQ65v445uN+/xNzZ5O /BrDK67HzkyHQA93PbaNctXFeQuSAQFPfjoLMmT+9eo2VuzoZdKUdGLgM00qSGOcrY3UT+WeNmox E5vgJJaoxYPVJNIXVOgbCI0Zf4WDEXz96ijxJ5CW6CDFFmRLVTddY+oeuvvDBNRRq8QCdDe2ccvd a6nDxe3XzGJhnnOvNB0euxv9CLrO7FnZY8Q5QEuncmhtJhygukvAkZwwRpwDtDT3o41Kp9nmYME4 Ky1VzbxeFRwU3CNnmfs6e+nFRNnkBMIdft5bUT1cpkPnoivhMI2dQRI8TsbH61RXd9IyZNkyGE9b Rx9r9/STkuSkIE0crlOzGiIQDA8/d4OzMfj7w2jC4clpURYQVYX+yKenoY7I6UoGBgaHheGu0cDA wMDA4GvJ4L5fUWD8jHyuPbGKX7+8k+/daeOnZ+SSn2zHLgv09AywfkM9dz6ykUhyIj/5dgmjvcOI gkZbaycPv1NDYaIVExq7djTzt2e3Ys5N4vLTcwFIz/Rw4dmFXPm3XVz72xX89JuFFCRZEXSN5pZe PljeSFyKh+uvOOqIDT5yUp0kxFpZvbqGt46KZW6+g1AgzLYdzTz8bhP9/Tqfw1n4Qbng4hKe3vIx v/nTCqSeycwuiiPWJtLrG2D7ng7+/UErd//tJHKjVu6UTkvHrW/hHy9WkT+tiOmDPvFMsoVzjk3h lQdq8LlErpmRNlaQHaR+UTVaGnvYtquD/lD0WNyBQJidu1r4+0vbEbISWXJctH5kl5n0LBeBt6t4 /cPdFLtzMUUUqms7ef7fOylvirB4VMWUTkpmYWkcL72zg1/HWzm1JI5IMMT2nS0890EjwYjIkDP4 cK+PPz+8jhe29HL2N8vIsOls29OJokVXam0xVrIS7dFV+c/JhLw4LILAO+9s5+ikAjLiTPT3BVmz sY5n1/gOYpYxpLrtTEqWWFrdxDOftFCaakULR9hd2cbTr+5EN42kz2azcOmFxbz8qw1c97sVDFxY RF6SlXAwzI4drazd1c2Zly9i6uxcjivYzVPPbaQg0cRxxW6skkZLUw9Lt3ViSk3ht6ckcdbx6dz6 eg2/emwn152Yhtsq0tzUyQPPb2PPgI3rZ2eTOVj+iV4bWYmwYn0dz61NoDTBRFeXnxWrqnh5dTuS 3XN4z026C5dD57m3q0i36sRLKqpsZVJurHHMmoGBIdANDAwMDAwMvghGto9FnUXd8pP5RGxreWrp di7dVE9pXiwxZoH29n627u4mbUImf/7mJC6dPuJR3SxLmAQdX4ePv/1jA3pEIxBS6O4NkZCVzJ0X l3ByUXSl1Oywc+43yugNiTz2YQPX3d5McrwdSVDp6Q0TFi1cfkEGNgBZBFUjHNH3WgEGWRKIRDRE DeQDu7MhuTidy08v4GePVnDzX/oYn+4k6A/RGxExKVrUVF4QsRykrCySQFhRUQfzPBpJ0FHCKoIo YhlMas5RhdxzbZi7X9nF3Q+v5km3HYdNJOAP0R3QyM5NG1nlFQRs6WkszDLxUk2Yb5xRNDIIk02c eEwhjnt20SclcvIcz5D0PjCShCwBvQN89O52LtpUE3WOp2kEAmH8IZWUnGT+ck4x35kz6CDO6mDh wjyOeb+RZ5/byI5tDcQIKt0BDZOgEuMUUVQYSnZiTgrXXjaVzvvX89Bjn/CMy4pDhpj4GKyihGQW h+tu64Yqnl1eT1gxUb6uiuu31RIedEQWUVTypuTy+8uKyfaYEXQNPayNrXdNh7CGZBp9TYOwhmnw WvG8Aq46sYk/v1nOD1vaSI8z0dMTJICM1S6AEv29tL/CEwREs5NbrpxM3b1buOJXHzMz30lkIEx3 fxiPR0YPq6hDhumyicUnl/LH5ggPvV3Dj37XRmq8FVVR6PGFyJ6QxlVxAm5LMn/++RxufLCcBx9e xUvxDiwmnd7eEFpMDN/9Vi5Y7Xz7gjIqGlby7D9WsW1jMrmxEjurO9nTrnD5t6fy/ZMzhpM66ag0 Ljy9gBufquaHt/VRnGrF5wtic5pQTBJaREMcVX4iOqGwuo+JHQld01D3es4WLRrHJdt8PPxeBT8o r8Vp0pk2fyK/TIkxBLqBwZddoA859RAOM4zBl2mgdmTC/TfTfTjXDD5fHez9jBtla2Dw5UcQBFRN 54M1jYiigCiJHD03B5+is2JrF+s2NRGK6DhibYybnMbRMzMoTpH5YE0D+qBZe3urj/aIRGysk7mT Pazd3EnILDNhvIcFZenkxIl8uKYBjejeZrMsUjwlg7NUgU+2d9HYFSYiSeRmxzNxXAI5XomlG5qJ dPehxsZwlGBiz64WrH1mFDUqIlrq+0nPSUAya6xe3USNrA8f57XX2wnRZCIhzc0pM5N5a307yzf2 4/Y6WDQnlwLHAE67nUBLD++t0bGybw/fgigSrAsyeUISbj3Ih2vqcchRt1qiJFLjl5hRkkJfbStv RyyYhKg1tTMjnpPnhYhxtbGjwU8wpOF0OZha6qVkQgLr1jSOOBzTdfJLUpkWG8GrBvlgTeNwWpQw HDctjXZ7HC07mnn/EMzyRS1CdRtMmJKMxRQ9Q30wM7jiHIxPdjF7aipFiTLL1jaiDO531sM6ixdk 0fRuHTt2tGK2W5kxJYPZBU52JllQZJ1P1rTgRUUTBWSTlVOOzkFY3UJjt4LDZePoBXkINfXs2F1P xe5OVlTY2VQTJDc3AUeCjqqpdPWN7ItXVZX2Zh8fr22kKdVOj8XBtBKR6j3tfBAIIJtE/M4YppZY 2bG9FaW9F9kkEI6LZcpROlu2NNPlMiNKEtOmpLC4KcCa3Z1U1wgkp7g4YWE2ngEbos1PTXkT79VK BxyTmlITOaYslbc2d7B8Qx+xbgdlk1M4o8yFvxcStSAfrW8iokb7ufElGZzm11hV0UlDj4LJInNU aSJzJifRuKWJFkAU7Jy9OAeHs5kdjf0EFIHkdA/TJiWRLYb5cF0Tgq5x/KIcOkKVrC9vYFVIx+1x MHtGNmU5TvZUNLElHN0XbpEFEtITWTzJx4rdPj7p6iMrO54TZ6URaO9lZW2Y5ppOlgkhdFGkLihS VppIoKuXDzc2ow22IascQXQ5mJYHlbvb+cjvR1F1rBaJSeOTOL4rws7WIKooEhkYQFcjjEzRGBgY /Nf67yVX/kmv83tZ/fjFBxQ3tZXt7Gr209UXRjTLJMU7KMrzkuSUMI7r+mqghCPUNnTRGRg1yapH PfbHuW3kpjgQv4STLqG+AXY19YPVSkGqA6ssorR28dD7dXiyUzllajxOi0iouYMH3msgrSidk0s9 h2VKZ7AXqkZ3XwhkEzE2EybReNYNDP7TrFu3jry8PMRBb15+v3+4r/71fa+xI1SC3vAG5519Epef M3Pw0dX59/K64T3koihis0igRWjtGCCsaNhcNhJjLahKhIGwNiwcRVGgs9XH7+9YRnd6Nv+4dSpm RUMgeiRZSFEJjQrPqN+ZZQmzPLKaqWk6SkQjrGhEVA1EEZvVhFnUCQQjDJ/2pOtIJgm71YSuqgwE I8MrmvuZQkSSJGyyQFf3AP1hnXivHZsJNF3AYhYJDiiEIvoBtijrCJKEy2ZCVSL4w9qoPeA6slnG YREJBhRC6th4hvJpkqJ9pq5DRNVQFI1wZGzZ2GxmrCbw+8OEtbETKTFOGVHX6e0Pox1i72sySbjs pk/tGdYBTdUJKyohZWwaBCFaJpGwQlt3ELvDitdlRtN0TCYJVBV/MBJNg64jyhIuhxm7WYxGLAqE fb3c/ch6/rUzwg8unMjxxbFoQrRd7Xv1WkAdjDei6thsZmyyQH9AiR73petY7WZsJoE+v0JEi16z 2aPlFb02kmebSaepLYAqiCQnOBB1FV2QsMrCp8p2fxNXdpuJ/h4/3X6VWLcDt11kIKzjsElEwhH6 Q9qY8FaLhDy4Oq8T9fYfVqL/htyrmWQJy6i2MNTmQ4rK0PyJLEuYJfD1BOgJasTF2ohzyIRCkeGj z4aQB61XuroDBDWRRI8NWQQEAbMkEAhGCEeinunNFhm7RSQYjBActZKu6+Cwy1gk6B8Yew9ZlrCa JYaMFvoDYWZMTCI2xmK8bA0MvmDKy8tJT08f7s8VRSEcjvqcqK6uPrAXdwB/Zw+PvryTN1Y0sLWh f9DuSkB22JheksqSxXmcMycZQdA5AqdoGHyB9PUFePzJT3h9h0okHImeC6tHnZHEJziZMSWdJYtz KcuyH5EjUY4UXZUt3PzAZqTsTP70nWKy4i2Em9r45T2fUHT8TOYXe6ICvb6VG/+ygjnnzGdRsRub MQl8xNA6u7jrnxWQmsr3Tsom2WXsjjEw+LKj6zqSKHDq/KzP//5tcfKopBF2OVk0IdEo1P8xNmyo 5+P1LWTlu0mOs6CFFcq3NLF8dx8z5ozniiXjyY81TKK/bu8NY8HNwOC/yz5G2SNHr4T7+vjFn5Zz 58u1FEzL4YIzs0nzmIkEFXZVdvDqW+W8vbaNlh/O5AfHpLDXyar7NTv+1Ors0LEtAgcPO5jGfa3Y H/pL5QAr/vtJy+eJb5/p0XX0feVpf9ePIOFwhPKKJjbV2jjvrAmkm1RUXWcgEKK8ooXf31VLRVOQ v/20jBTzYaTkAPX5eV76ss1EWqIDk8eKbBo8X1SSiHGYcVglhp0LSxIupwWHRRp175FjYfZdbwev 6wOle791fAjteX/xjr6+v2fgSHagh5IHzdfHy+/thkIT5y3KMAS6gcFXgCPxjhgIRejtD+PrV4wC /d+TalRsbeJ3924gEGMj1i4jqCr+MEyYnM2N548jLzZqRWkc0WW8NwwMDL5AgT60cKrqOm+8uJ47 Xqmh9NgS7r/6KGbmxoyECw6weJKXH/1lLbf9dS0zik9ieoppPw+5SldPGHuMDaskjBIFDAvboZD9 vQMENQFvnHWsSBkT34hw8PcF0U0mnDZTdH/VQcyzh78fDDAQCNEfUjGbZWId8vBvDxzP3oJ8MD4t QrdPwem2IQ+mdySeITE4eN5sMEy3P4LNacVpEfd7r0/nfeT+e1+Pht2/4BQASRRJS4vj59dNZ+Jw OJX1a2q45tdLWbGmlhV7JrNkgvlTwk0b+ryP++yzPnWVLl8Yq8OCXRb3igvEQ5tLwVOQxp03JKOL IhbzZzNb10cdOdPXH2JAAbvNPOgERRhMs37A8h+d7mAwTN9ABNlkIi7GPKaN7qs9B/0h/IqOK9aK vLfoHopXV+nqDmO2yzitpsHre7cxne6eIIJsIs4hjwmzrw51KN2fEt9U6Of0AAAgAElEQVR61Dxz 9LWhv9VQGF9QxxNrGfMcCIKAySETY5fBLhPnNB+BSS0DA4OvArFuBz+6Zj597gSjMP73pBoLF+Zz V6yT6s4ggZCGJJtIS3ExryyVoiTbqL7KKC0DAwODL0ygMzjwj/T7+P0/d2NKTOSP101nZoZ5zMBf sNo456xJdNW18L0nm/nTq7U8c0UeuhJh54YantjYy4Jp6fjrWnhzUxttfRFcnhgWzcjk3GMzsI8S D3okwqpV1Ty/rJGqlgAhXSApycWi2VmcPjedODn65q/e2cxz79aTMymV/FiVF96vZVdTAEGWmTg5 g/OPzaIgwXJA8+yowAzy0luVvLu+nY7eEP6gimw2kZwYw9Hzczl1agI2WTxAPFEx8u4rm3mvQeS7 p6aybl0DH5Z30Nqj4HI7mD+vgEsXJmEazOfgsZe0VLfwz3dq2FjVS6dfwRFjY0JBIhecXsQ4r4yu 63zw3lbe3THAuRdOo8Q9KJ5UjXfe2MT/s3eeAVJU2dv/VVWn6Z6ccw4wDDlnEBVBEF1zdg1rQldx FyNiWLNrQkyYQAUVFFGyoGQY4sCQJjDD5Jynp2NVvR+6J5FN/3d37eeDMt3Vt+4999zwnHvPOVvK JR68sy/Bgosk22x2Fi7YS7EpmCevSz67DdtNSB0OoINnSaQmh9Arxov9x+nwfxMEgaKCKj5bXkRC /3iuHx3aRUcc7MgsZtmBViZPSGR0ok9Hf1pb2li7uYDVu6oobbCj9dLTN8kfUZHxCQnksrGxxAaK LFuRy/r9taCTOoieKInoNAJtTh23XpHKgFhv1JpGPlpzHK+ocP4yPAx/r3O/TifYW3jzixwOlbRQ 12R1EXSjjpgoPy6+IJXze/h2M6ScSl9UVWXrxoN8vb2B6iYrLW1OtFoNISHeDOsfxXUT4/DqQs4B Dmcd58uNZeSUtGJ2qPgHGOmVEsyFo+MZGGt0GZcamli06hjbDtdT0+xA66UlPsqfMUOiuWBIOCYR nDYbGzYd47vMKopqXAQ9KT6IS8YlMD4jAKFdDxpbWbWhgBy7F1ecn0RSoNhR//LiGpasK8QvOYpL x0ThBygNzXy5roB6gx+DYgxk7S9l65EGmh0QEe7PNVPTGJnmh1YQqD5ezaff5HK02o7GWcLMf1sJ NEmYrSJ335xBv2hvz9mJBx78z8FFvLx9jdxw48DuxkWPcP4E3e/at0THBnF1bNAZdcRz4uqBBx54 8AcTdAFXzsranFIyqxV6XxDLhBhdx9G60HlMCJKGqVPTeXR+ETu2Hcd5ZxIah5O83YW88GYuX/cJ R2e3o/PRYxQVtmYW8+WGMmqs8PDUGARBwGm1sXLlfmYtyMVuMDEg1Z8A1cnBrGJWbimhuGEIM/+S iB4ozK3irfe2Y4kKpWeYhvo2CPDRUFRUxpL1x6mxyDx5Q09C9WdZLBxmVm8+zursVpJifPA3Sdgt Nr5fWcIPW0tpfXgc1wwNwSiduZz1yw/w8jYrW3YFUN/owOBtwKhRWLH+GMt2VOIfNJFpGT6uoB4I lOceZ/qru9hVrtCvRyBRoSbqq5t466NCtuU28snsUcQYoCG3lJfmFmBKT6HfhABARba38uwbO9he qyN9VCrXZ7gs120NdTz+1i58zx/E7OuSz2XP5Qp40vUQ1Gln6/bjbCuyM3RwCmNSOp23iwpreH7O bsbfauok6K4fkbmrgBc/r8QvIYTRiT4IgoCtuYVPv9rH7C/yUQ1eDEjxp62ulWV5FezLrSdxYE8G 9okkNlBHSWkjmVmVKDpXxFVRI2FvamVfXh2IwYwbE8uAWG8cVfW8/tFuAof3Y3zfkF9E0LE08emK Yzi0GqJDjBj1Ai31LXyy4Rhr9lTz7tMTGB2rQzzLBmPz5hyW71OICTUR6K3BabOzY0seX60r5lib xPOXRSMIrqAwezYf5IF3DrCrzMHI/mEE6QUK8ypYtamA3a0avrkzlYaqOma9tpXPt1QTGh9C7ygv 2hrNLN5dzPoD1cT0nsxAycq3S/fy6PwcmkQjo3oF4DSbWfJdKT9sr+S5+wdz9VDXqZatqZVlP2Tz Q3MgAwYkdBB0gPLSGubO30n0hUM5z03Q1YZmliw7xNIihV7hBhSnjI+vAWdrK9+vK2BDQRsLHh7E kHhvrC1t7C9sosmqoG1sZc9BBYNWoMWq4arLe3hmUQ88+J/EybdiPETsz9T952KI8dyc8sADDzz4 PyHo4OLfeUcbQCcxqFeIm9d1mawFwc3RRQyBAfQPVNlf00ieCj0F0OokMGoJCPVn+mXJ9I73wUtQ 2LevmCfm7ua9r7O5aFQMfQNUjh4u5l8LcgjpncIbf8sgJcKIFoXCnDKempvJ+18dZni/CM5P9EKj lfDxEnCa9Iyd0IOJ/YIJ89dRkVvC7Pd289X6QiYNj+bidJ8zt1o0cdu1A7npOg0JESZ8jRKqrHJ8 fz5/mb2dj1cdZ2yaP0lBZ44yZvDSodO3IQQGMePqBAYk+mDUwp6fDnDL3MO8t7aYiak90RokwMLT b2Syrdmb92YNYkyvQAKMEs2NZtau2MtVrxzio7HJPD0pjPMnJKL/sJgtWRUwIQBVUSk/WEJmlYhP MCxYW8T1GT1AVqjNraRC78X14xI6+u5MC6YkCVRVNvPo01sIkxRkVaWt1cKBI7U0GgJ4dFoK4drO mxKSJOLjrcOoP/lquU4rIZq06DWd17A3bsrjmfk5xPZP4ulbMsiI9EJVVQoPHOex9/fRqBORBBWQ uPKyDMaPT0UVAFHEW3Twwce7yC61cM0NvRmW4ueutIi3SYtJL/GLg4cb/HnhH6MJDzESGWTApBex W50c2HyA8bP28vFPZQy/MQHdWVyqL542hDGXG4kNMRJg0qLKMiXFddw3azVzPs7iocuiCUKltaaG f762mx1mE+8/M5bxPf3x0QrU1rWyN6eGEnTgcPDNt3t5d10F064eyqwrE4j002Jrs3Ekt5qjlVZ0 TpUjuSU8Me8wxMXwxYxB9I30QnU42Lw5n6fn7efFzw7SK2kMGcESgijiZdDi49CgEU/scwlvkw6T rkvqGVHAZNSC3UKP3lFcOyGOtHAjktPGOx9n8vbqHNYdSqR/vDdRadE8ebWZ7MImhLgYnrupJ4nB WmyyQGKst2cW9cADDzzwwAMPPPDAgz+UoANVLQ4QINhkaOfk3dDhfS1IBPqLOG0Oqtugp+TyL8Zk 4LKpfbj5gk6/tdQIL8oOl/DoxkZ+zq6j70gTmduL2Fcn8FB6CLZmM9urmkEQ8BJF4qL9qMiuZdvR Os5PjAZVxSprGDsymWdvTqf9HLVHnJbNu0rZvL6Fsvo24PQEXVVV0BgY0juc1oZWdh2pIr+shdpm B0prMzZV4HhlM60WO2fNBamq2DHy6F2DuDi18509Q9J48vMCDhTUu9KFALX7i1i4q4Fhl6QQoFPI zqlx+WGLImGxQfhqVL7ZWsrTk8LxS4piSAhk7qlAJh1UWPPTMbSJUfy1h4OPN+VTO6MHAU6FzKxq JJ2eCYPDTtlPJ0IQBJw2B7k5NZSJ7nQxqoodEbm5lUXLDmMUenJJv4Bfrk2NjazdWkKD3p8Xr+nD 5IHBHV/FacNJDjWwo0uKj7BQH8K6HMrv2HiQxTuqGTWhJ49dl0a03+8Qhl3vzUXDvCkrrmP3vjIK K1ppMDtxNLSg0UkcPl6PosbDaaMNuGTWp08smNvYmF3DsbIWqhtttFqdtMjgqG+kwAZBksyhzEI2 Fjq49va+3H5edEc5ocEm0tPCaLM4qKhu4rNvCwhNjOHF6f1INbofCjQSGx3ARFWhpamNJduLyLPo efbyPkzs3XnF8KppPagoreGBpZUs311DxkXhv0o0TodMdFoEf7+hP6MTvTo+v2xUFEs3lpBXY6Xe CWE6DWmxPnjrRQRfI71Tg4kL1HQbBx4fdA888MADDzzwwAMPPPiDCLoAmLSunJc2p7OTqJxIXNz/ tltVREHEqAUU17eC5D6ho8tprF6iX58g5FWNFNe2orRoOXqsCafNxsqV2WxZo+Dms4giNNS3YTRp cXYkSAVVkPDx0rrIeUfkcx0mLz3Izdhl9UyM2nVFz2lj2eoc5n2fz8FyKyYvLT4mLSaNQrNFxkug ox5nhaglzKfTh1oVBAQfb/xEkTqn0hHkbe/+GuyiyLEDhTySf7ybLAVRRWuQsNud7l4xcUH/QDZv qmRvKwzUmvlyczWTzh/D9IFm3vr7PpZnW7g+RWTb4Wp8IkMZEylwLpFUZVklKMyX2Y9PoLfegVN1 uTS0ma1s3lbIKwuzqWhykpYwhjS/X6ZM5ZVm8kpaSEiNJi0uoFvfq3a5w1jRtT/a/dfy9hUw49Xd iDGRzLq9Lz1DdPwukWEtrcz5PJuvN5RQ1CQT5KPFy6DBIDhRFRWbeuaObn/7lh+zef37QnbmN+Pr rcfHqEGrEaluExAlsMogo7L3UA2Ct46xQ2O7tJ+OaPFGLw3lzS1klamk9g91kXP3tYeOgG6CiGK1 czC3kaBwb/qmBberFwgg6LxITQ1FbCwjr6gJ+HUEXVFVfH0MGNz54tvf7+NtwGTSYXUoHblnZbcu q4qK3Sl3nzo8PqkeeOCBBx544IEHHnjwBxJ0AZJijSCrHCxt7iCf3Y7IXGG6kR1mDlWDLt6bFB1g 6WTwinJCBHJJcF33VlSciopdVmmwOPEN8mbaxRn0DVCxdyFxoiCgNepJS+weoKS93K7EQBRd/z7j KZ4qgADbN+Qw682dtASHcfPVPRic6EOgn4EQqYVbZ28jV1Z/ES+UT6qPgKaD3Ln+W2dxosgqQ0el cnGKHklw0c92Yeq0IqZg/45PLhoRyZPrDrFxXxOxPmXsKBf44uJY4kLb6B+wi89XF3FjUjg7c9ro NzESI5xTJFUVFb1eS3pPX9JPuArdN8ZE+dFy3jtUzobsetJGBXZnqWdBm13BbJMxhmjR6aXufX+q urjJeUNJJU/NzSRf9OPVOwYyLtn7lCr3a/D1ot088f4ReozswT+viCI10oSftx4few1j7t7C2WLC q6pKfV4x09/YxVGriUdvHUDfGG+C/fXoRPjwg/XM36sgup9tsslIooDRR9et/V3TvsmyE7Mqonc/ 0+4+0lVWNlmlyepEr9VidBu6hA6dEdFptXjJCpY2uZvRzNVX5yY0AQFFUU8ap6LYmW3AQ7w98MAD DzzwwAMPPPDg/ztBF4juHUUoe8jKLKJC6U2EKJycuklRyd1TxDFZw6iMcPzdpOpUJEcQBLApVJe1 gV5DhI8Rg0YgwkeLrIW+/WO4Ik3/G5pyDkfeAoDMik0lZDfp+feM/syYFN3lAZ3Lv1hVf7tkT2A2 iYF6FFR8I4O4YXLkGQkhQMaQWALUg/y0r5xw+Ria5GguTDEgODRcPSSIf206ysHJEkdaJR4ZGs0J LPBsrNMVxV3fvX/0Wi0pET7YDjbS0mzrYoFwnZx2Z80u/3TUTsl760R89RKlZhuWNgeg7Yz6L4lI ogBydz1TWpt5dd4uvitQmXn/AK4cGtxBdn9bQCIBsPLR98dpDgjjlfsGMya5i7+03YlOOietYfPm fPaXObjv0ZHMvjq6m86tDtCgqnZUN7GN8TPgdCqUV7ZCul+nLnUYb0S0OgOhGgfNVS3umra7GnSS ZJNWJNikxVIh09Jkgyh9xwk6yFitdswaCVN7PnK1sy/b39kuQ1EUEAUB9TeMJ1X1ZLr1wAMPPPDA Aw888MCDPxriKbibywc8JJR7JwRTf6yCx+fldBCqrv+vOV7O7HlHwMfI7ZendtvWC4KA0aDp/nxV Ix+tKiE02Jtx/UPA18CA/uGYj1Xx+dJDNJ2CJJSXNZJf0fY7NtlJo1kG9KRGnxDgqt5Ma5vjD0no 2X9EDJFaWLJoN9vKbCd9L7e0sCu30UVmBdCHhjI2QWLrlgI+2lDDheel4A1oRJGpkxJpPV7N7A/y UIxGJg4IOJVN4LS8SxAFDPruRBmgpraZH/ZUEeCrJz7BdZqvlSS8sGE2t3U3Ajid1NWYUcTOWwzh kSYSY33JOVRFdmFDt7LrGtqobLC5SHonS+ajL/bx3sYG/nrDQP45LQ4vsXudfhsc1DSroDPSN97U 7ZuWosZutzXOhPI6G2gEUpJOyAMs2ygst3WIRNSIDBkeidBiYemqw1jc7ejIi+60sSevkcAAH87L 8CIvt5yvD5nd5L09L7pCeWk9jRo9/TOCaShpZtuByg7RCwDmNrKyypCCTfRKdPW9XiNg1ErUtdpo tli7ybCl2UZdkxNR/PWS1BgEREmgqsWGeGKkPlXl97BpeeCBBx544IEHHnjgwZ8dp0iz5jonkzRa brtzOOty1vLJRztwNDdz5ahI4oL1OK12jhyt4vPvc1iXb+Pm6UO5um8n2RUFAaW5jY8/24m9Ipoo fy111U0sW5fHz+UKd96TwfBQAdAxbEQi1w8r5osv93J9axuXDAsnyl9DQ52ZHfvKKGgSuPHKfiRH GH+nJuvpFWPC4KzgvW+OIljiCPMSKCyoYfHafLYfayFgYMTvLmhdVCTP3JDCrXNzuO2xdVwzId5F Gh1OcvJq2LC3kvhB6QxO9cftaMzEQWF8t6SCHZLEokkxrv6RBOL6xDModAfLtlUS3TuBwX7tppGz k1pRFGhpsbJybQnHdE6cCjjsDsrKG1m1qZD1JTJX3ZDKxJ6uoGHBQUbSk/Rs3nmc578NYHySierK Rn7cXMiSjeVo/QM63+obwPlDo1m0cRfPvbeD6pIkEgMkCovq+HlnKVvyW+g5TOzIB7B8WTYvLsrF OyqSHmE6MveU43A7PTtlSO8ZTHyg4Vee2qqAieFJBvZlVTD708NcOigYg+Lk0OFyPluVT4NNIfoc Ch/RNwQ+Pc6nn+0kUU4i1ChQUd7Mt+tyWZptQdIZ24VLXEY8D1yUw+urD3KNt8rVIyMJ9IKSojrW 7KlGTYjlm+np3HpTX5bPymTGv36i4NIU+sWaaGk0szWziII2kZmPXsCwYfEM+yafD77cS7y/wEW9 /VEsFpatPsobq6sYMSqdy91p1nShJuIT/Whdf4xPlx7EZI9H77Sze38ZX68toLBWZqD0G4weUUEk BhnYvreQNxb7cUGfACpLzIwdH09KmBHRM5d64MGfAKfIe32GIJGnypv+229H/Y6tOUNdfn091Y6Y I6f++1fI9z8ozsep5PKf1Kce/JfMJCfozB+nVyePqVPNSx789jH/nz7f/1cT9K6CFASBqJQYPnru fF77IptF32Tx06ZjhPpqke0OqmvNiD5+PDV7AtMvTcbQTgD1Ejp3nidzQytfLMmipNaGzakQGOrP 7BnjuPeyxI53RsSF88oT40hcfIglW4/zZGYBokZEVFW8THpGj06mX4r7NFcUsNmcKKdohqCqqDYZ QTo7Vbjl2r7klrcwb91hsvYW4atRcCAxbkAgwT71mO0KWu055NqWZbC508p1g4TD5sTqBINe6vjs r7ePwDssgHd+yGfe53tQJBFBVdFqRCJigxg3MLQbkZ4yPoa7FxTjNbAH0+K0HSYUk78/fx0Tzu4l VYwcGtfN1/2MpgmdhKrINJc28vyrGzGIrolLkRUUBCKiAnlq5kBum5TYEQc/MT2cu2/oR/YbWTz1 xlY+C9Fjd6r0TPGnb48A1hY4oYvML5qUzlt2mWc/O8Jzc7djMmoJCPFlYnowzS12bAjovXSAme+3 FlNQZMZAHS+/vwOxy0lsS6vCqy9cyK3DDei1Ana7jFN1tQHAS3PyZwaNSz+cCBjcn82aMZzCZ7bw 7vzdrFrtheh0our0XDQkjC3ZDTgUOoKknQqCINBvfAZPX1vLM98e4t6icnx00GZTSUwOZWiynh9z ZbQ6Vx8YvH14cuY4AiOzWfhzAQ/vKEAQXeVExARxc79QQOC8iX1Y4NDyzrc5zPlwJ5JWQkXFZNJz wYRUegRAcEAsbzw8nEfezeLRFzfyabwPssVKWb2NvqPTeeHeAcS02600Ri6d3JON+2r59vts9u0p QqvImAJ8SYrxJ7SsCZtT7RinklZEdsrYZRXdCTnmdBLY7DIyAnpduyC8efS2/jTN3cOCRftYskyD onrxxYAo0sL4fQIGeOCBB3/4RutUG9Nz37C6iGab2cb+g1XIJm9GZgSe9neCIIDDQUFRA/mNChkp QUSeNjvHaTbSf0CGiI72ugu2mq3UtTiQtBpCgryQ6FIPVe3I5nFu5EFAEFSys0opsWqZMDQc/TnX 39VWh91J1r4ymrUmxg8I/o8xgLa3uaW2lP1Ze2jRRNC/bwbhAcb/Ev0/cZn6JcaT//4x3k2n3bcp f9088NsJniAItFXks2FfLvHpQ0mPD0JVVczleWzaf4zEjKH0iA38Hd7unrOa6ti3YzsEJTNyUA/P YvBLJCgIqKpCS1kum7OPk5wxlLSYU2d6EhQnjRX5bM0uJiVjEKnRgR4B/h4EXRAEFFUlK6eO7Lw6 BFFAI4kkJARzkVMit7iRiqoWJK2O+ORweiX6E6CRWbc+D5vTFVhNtTnIPtTk8jOP9CPOaMQ/wI6k 0xAd7ouP4GDNOvfzuCYIEZWwyABGDxSoqLNicarodRpCg0wkBEhszyxkn0akotTKmAmJ+Drb+HxN PopDAQG0kkqtqmfKyDAq8ypZ2NyE8wzR3HUaCI4PY0SdzNFSMxbRQGpiIAlR/lw4SqBJ1LF+UwFZ Jg2KchrBaUQsEWFMngAbNxRw0KjpOMTWCE76DI8lwVvLwhW56DSu6F6iJIJGz5C+kYSGtNJoVRAE 8PP1IibCh/qSahZU1HTyf7PMlAuT8A73ZtHK3I6I2qqq0hoYyuQJRmJo5YuVucjK2QeYxWIjJDmB iYEqqApqF2pv8NISHeGHvyizZWsBVoerQEkSaLbpGDckkp25DTS2OkiIDyQ9MRCNwwe9v5Xa/CoW tTbjkFW0WpFWVc+YIdHEVFuxqwIhob6khEgc1IoUVzWxdE0ux0JktH7+XDjFgISKrKjdvJ4dDpXc g+V82tgMjS0MGBCLzuTkux9z8TZIOOpbGDE0Dh+tjcWrczHqRey1rZw3Mp5AzCxckYNOI6ATVXr3 i6ZRqOJ4jQXfQB96JQcRF+HNpecnYvCW+eSHHKQzrNCCKOAfFcjkoTayCppplnUkJwTSLzkAKUzF EKqwdUUeuRrV7YsuEhTux5hBKmV1VmwqmIw64qN9kavq+GxFg2usoaV/73B8g8w0WmQ0OomwEG8i jQIrV+QhiuC0weA+EciaWvLLGhF0enqmhTMkycTRw+UczZY7NrWq00HP3pEMs1dSWG3BEGCiV1IA KSFa/AwatIKDb1bkYxJU5NY2gpPCGSpp2bg5n0PeIori0tG6SgvDhiYQYG1lyQ95GEXXCZkoO8jo E4UmoBWzQ0HS6mioaMIS742XTvLMph548J+/00JAxdbSxIPPZlItaYnrFce/b0jq2JyfCxpqm3lr 7lbaEpIZmXGWDZjFys9rD/HOfgfP3jf8DATdtZE+drSC77eU02tQHBf2C/4DCYzClo35LFxfxOHS VlqsMqJGwsdbT0yUH8P7RHDpebGEmTQIwPHd+Ty2pJAeg1J4eFoseu2ZaLPKVwt2sLjSl22f/xKC 7oLVYuODd7Zw0D+BLQOC/yNUpzOWUBXz33yGOYv3ctvDTzFmtPG/SP1VVKWZp265hcOWcN5Y+C5R 2v+1IS6A/Thz3/qQlT/tIW3MFdx7y5Ukhft2xpFCQBBh5Sev8s3aLZQ74nj2+X8wKDXmD6tT7tpP eez97xk85U5m3nIhgiBQn7WGBx54i5tnzSc9PghUhardK7h/5gfc+fTnvxNBd6G27BivP3I/ytB7 PAT910CRqchczt8f/4R7/vUFaTEByHYru5a+y4uLd3LxDQ9wx6VDwWmjaPcP3P/Yl/z92Q88BP33 IujtZC0i2NgRFR2gb2oQ0yYJWC12zBbXKbW3tx69BHaH3EkOBQHVaqM1R4eglRg4JIF7Rgdgk1V3 VHcFh1M5mUwKIIkhnD/aFczKlZbKFa3dKSsu8qZCn5Qgpk5MRXEq2BxKl6UQ+qaFcbMEdodyRnLe jj5poUy7IIXWNgeiVouPlwZVVZHOExFRsdrls6Za69cjGJ0EFuvJzw7MiEJUFCwOpZt/riAKDOwb hSS5rbaqa+GTFRWnU+lWjiCGMGpEMqqsYLF3F5qUEcZfJAGHU8buVM95khwzOAaNeGrLsiwrbnl3 /06Ughk3LJY2sw2bLODjrcOVhU9AI4HDoWCXXXRfVlWMxhCmnJ8C7n7z0gus/uEAOYUtDLg4ifOG hxMsqmT0ikZzhmvXdruMQ1ZBDGTEyERUWcHmdMszJYiRo5O6fSakBDFqbDKKrGBvf06AfulhXD/N TqtVRu+lx1sv4pBVpox2y9ahnFV2Uo9gLhyXQkOzDUEj4eejA1kFMQGNKGC1Obv1nZgaxPhRAlKH PqvIsopDVjqMPoIgMLh3BJIkIJ6g8+06LAgCQ/tFcrPTSbPZAZKEr1GHJKjYHUo3o4YgCAzuE8FV U3rS0uZEb9BiMmhQVBVJFFEVpfM3YhBDh8Yhqio2h3JS3SdNSEFx65baZXM/sHckGrfuyoqKyaBB I3pOzj3w4D8frnwRiqxwZPsx3l16FPQ6/A42c/+1ScT9Ahub3e6k8Hg9rQbz2Z2rZJnamlaOFtto tshnLbswr5K5C/Zzud7nDyHoLnIu8/Gnmfz7y6OUOPQMTg+mb6wOi9lOaXkjX2QW8cXyPHxSruDK NG90Aphrm/hxaxGtAeGdmVvOgPKyRnJLwPkrqijLCsXHG8gJDuU/J7yHq5d/+uYzXnp9ASlT7mXq RWMxSfxX3aBSsbFz/Wq2mJNo+1+NneJsYPNPK1i5KouV64+S0bc3SZOGuLvIbWipP8iH8z5g6fY8 IJo7Hrz9DyPoAM1lOaxevRpN6tQOdbE315CXl0tlnbljI2pvqn7C7GkAACAASURBVOZY7lGqGtp+ 1/c7rGYKjxQiR1Z7loJfZ6HD2ljFsZzDVDe40nWpipPqYwdYtWYtiaNvcD+n0NZYScHhI9T8zn34 pybo7da1iGAjEcG/0ipqt1OdqQdBJDLCj9hIX4+U/0SoK6nhw+8PctymZVBaAH56gbLiOr5cnoMl NIRrJiYzLi3AI6j/ubnb42fkgQf/4fsrBAGcssKSlbkQHMQ/pobw6vflfLWljpljg07iWacb1wat iEYjouni3nTa67F6Ca1GQKMREU83R3TxY5dQMZvtyKfJCOPi2Gcq58xBRgUgf3c+r311lIbAcN67 qy/DUvzw1os4HQqtZhtlVU0sWnwQFcFlvBQgYVgaa96PweTv3e30/NQycstGcw7yOYUMwHVLTyud /vnObDNnu6Ld6Tp21jn6dPEE2q+2H9/J/I/nIceP5O8PTqdnhI+rfM7Bye4c+qarLM9pTTlFfTtu gpzm94Lgz+vLN9Oq6IjWuOTTrfanMDacre86XDE4tzaerqxzafM5yUUQkTRaggL9aa4v4ctvf2TM oD4khxjcv4c1iz4kqxZCTRqqzfpuwV/Ppb1Cu8nvHJf9HlPuZkPvv+AXGt/xG0F0WQWl9nlEAEQJ kJDcUW3PrluniNtwSruciEbLGdxgf+k4Ofs8dHJZp3nHaZ4/63x3Qplnn1/O3r4z6ZcgSiBoO4I9 SzovRt38BFsunE5odGLHfCSKEmi1XYJCn7qPzqV9f+a95UlX3H8rFKeMpc2B2mzDbJXx4E+2CZRl igpq+HBDFZ9oJQRJQCMJJKeG89K1fblsQKCH0P0PwtOXHnjwHz9IXSdUdbUs2NlMv1F9mHFtFB9/ XcBX3x9j5tigjiCxJ26oSvLKWb6zmopmB+FRAYQZVNeGvksgtPbNoa3FzIqNRRwuNSOYvOgfoaPR qp7Rjaj96n1lZTNbsuuwCiK5eTUs2+aFbHHgG+hN3+RAQnxcWxaHuY1Nu0rZkduEVRWJjwti6ugY Qk2SiySdZX3ZnlVMYXUbN96SwSWjovDutmf3JjUxiIyEIPA1oHMXo0WlrsmGxsf7pM1ja3Ud32+r JLfCjMHXyICMcJzdUlt0rY/Ktm2F7DjaQHWrg+BQP4b3j2Jkmi+C2p2OiJKIBOzaeowNOQ1YFYn0 9HAuGRGBVhDcfaTS3NjK1r1VFFa3Ut1gQxYkwkN9GNInnMHJfgiCq1zV5iC/oI7cZpWhfSMINsgc PFjJ0So78XEB9E/2RzolBXD17c/Lv2fFljKumf0oE4cmdOGzAkpzNZm792L1jmX0kHSElmoyd+2l rNHJoBHDiQsPcvnSW+r4af2P7Nx7mEa7SmRMMhOnXEpalF9HGt/2NcVSfYyVP/7MobwSJK8A+g4b R6SumqJqgfMmjsXXoENAYeePKyiVQ5l6/iC0GqlDp1RbNStXb8Mrpifj+6e6iaEGe2sddfYAXHYW AUV2sHvdcqqEKKZeOAScLWzdsJlai0Jin6H0jmvP4GLl5++XsjM7h0azk/CENEaNmsDAnpHdjQWq jcy1y9m67yi1ZhuBQeH0zOjH4CEDCfXtmjL15HXU1lrP4ey97DuYS0VFFRa7gl9gCBmDRjB62CC8 dcI57Z9kh42wXuMZry1h88pFbL1yEskXDnD9zlLAx1+uIH7UNEzZK1i+29p5U6NL2fu2rGbLjn1U 1FsJjorjvMnT6JcQ5L4mDwIWfl71M41W2ynHsyIGctHFozBKElpVpra2Fq/ghF82bakqdksdW37e zLGSYioq6rDJEBIRQ58BQzlveB+X68I57im1OlcKo41LP2fbwWMoGj8GjR7HBaP6IbaPE2sLuQez yG8SGTZqJEF6G9k7tpNT1kRCj17065WMBCjWJnZs+JHNuw/TbBOJSenFpEnnExfi0zGXVhQdImv/ YSLSh5GeHIPO/Y66sqPsyiomfcBAYiOCXGNfECjK3kZWbj0DxowiOsTfpSZqK9t+XM+OvQepa7UR EBpJcmovxo0eip9J53qXu+0Ht69jU+YeSqoa8A6OZMDg8Uwa09vVJ269y/rpewrbApg2ZTQiNnZu 3ER5g5mYjKEMTP5lQbIl2U5tXT0BkSlnMQ4LKLKVrSuXUaMY6T38AlJCDR3PFB3cysp1WyitasQQ EMqQ4WMZN3oAekH40/IFze++B9DrGH7pIFYOyaBHiuf0/M8G/8gg/nnfaK68qg2zTUEBDAYtEWE+ pER5Y9AIHnLugQceePB/ajl1zbmyrLB9Yx4lNpE7p/YkLELPlL4mlmQfZ0fDEIYFCN02VE6HgxVL d/PY58coqLKg89Kg14jIiLQ1S/TuILYun+68Q6XMfGsnG480YZXBSy+hEQQcdgfe4SFn2z2wcWMe 7313jEZV4Mf1OWzbko/d5qD3kBRenj6IEB8NpTklPP9xFkt21aHVa9CpMk12eG9ZFC8/MITxab6u DTuc4QTQFYi1qs56ygBsqgoh4X6dxgcEWo+V88DLe5l41QievyIGyR38c/+Wg8yYd4RduY2oOg1e GpA1OoRWhU6266qJ3NLEgy9s4ZudtfgHGvHRC9TV5PDWYh+uv6I/L1yb0IXjqDTW1HPvU6tZurGc GrMTRVEJDPNn1UVpvHlfP0wCoDjIOZDPXx7ZjdYgEeCrQ5AVWs0y3uEB3H51bx67PAkRUNss/Lzm EO8etHPVmDoKswtZnd1AdZPCdVf15a0H++N9GtsOzXls2LwBJXoQ548eieEEQ7tSeZQP/v0M9aHj 2b1Wz6Z137P7cCE19RrmfLOYu6eNoWz/ambNfoE1OwsJCgnBqJcpOl7MW3Pn8fSb73L5mN4YJJe8 jq5fwCPPzeGnnUfQmXzwksDy+usE+og0OeLZtHMIvgYdIDP/+YdZZhnN+WP7dRJ0AHMuTzz4IOFX /IPx/d2pgFUnnz49nWX1g8jauwgfwOmwsuDZB1jrPA+DbT+vPDeHgwXlyFoj1z/6Hq9Nn0xzaRYP 3Hs/q7bnEhwVjVHjpKbifeYE9+KOh2bz8I3jEYCm6kJef3Q6H6/ahaz3J8RPT21lBY0WHdOu+xtv v/sUAWfY/hTl7OBfD/+NH3Y1ExQcgFEr0NLUhCqZuPivD/DwjHvoGWY8u1eBqmCX/Ln++uGUv/Qa C79dy9iBvYgP0rNtySdsznfy7OxLyHkvk+W7i7t3tr2WV554hHkLv6VRNuHrrae+upq333qHu55+ nQevGOGWcwMvPfYPsspqUTsqI2AwGBEFJ43aARy+YBhGL4mG/Wu4954XufbR+Tx7+5hfMHnJtBSu 4Yqr/4Zd1BEYGIAkODE3NaIJiOfS6+7k9WfvRS+c3V9BI0F+1o/cds12vl+1jQazDVVRCU3sw63T ZzD7gRvQAWpLNesWzuWTfXaumHKQvK2LWLvjMDW1MjfNeJy5L86gKW83rz7/FJ+s2IGqMWDUQpPZ xjsfjGD2s09z+fh+ALQUHmbu87MIPP9BnvnnncT7ueS0fuEHPP36Ai5/ZgEP3jyZAK3r84VvvsJH +xU+65lBTIg/jrqjzHrkcT5fthl9QBDeXhqqSkuxyhKT73qWOY/eQpCvFyj1vDhzBh9+9SOSbzAB vnoaK4p4S57DRTfN5L1nb8fLfaK9+NWH+aKsLybyeee1d9l7tIhWq4NLHpzLp7OuPfdlxWmnYNNi 7nr6Kx56+SvuvyzjtAc4sq2Bj569j+e/2MGUu55h0iUucm5rreHLt5/m+XeXYZFMRIX60lhfzdtv vMklt9zP7MdnEG0S/pRxiDW/7x5ARZAkQmODmBTb3cLswZ9hD6ii0WlJiA8iIT7otM94on174IEH Hvwfzs3uE1BZdrDwhwL0YWHcPMIfASe3TIljwUv5LNxQxrDLojrXbNnJkZ153P32IeTgYN55fgzJ gVocNjtZWSU8/+GhbrErKkvrefG1LazMc3LL9UO5dkgQkqpSXljNx19nk+U4+wZ6woQ07i9q5MWv jzHuwh7cNSUexeLAJ8BEr2gjSmMDry3IYt62Ju64dgDXjgrHIKlk78xj9me53P+2gS8eGUifKK8z +kVfODSW8EXF/LBoJ/e0NDFxUCgZCf70TPRDAyekSHP9rVhtHCttoqrZ7j5tFLCVlnH3a3vZXiPx /EPjGBpvQlQVqisbeO6NHdQ5uq59Mi+8upGPM5t58t5RjEn1waAVaKpvZf78Hbz56S6G94/gkh6u jaugqlhbmzlQ68fMv4+lT6SBxtom5n22m4++PUxyWiSPXBgKiIRFhvD0A6Pon+qHj0GDViNQU1zL B5/vZe5XhxmYEcmkNC+QFVqaLGTtKKGstJ6UhECumZqOSYCUlECk02gPCBw/fIh9B47Sb+Tf6NU7 pZvhAQB7G7XV1Sxf+TI745IYOHgof7v/Lzia2uiTHIut9giPP/IIP1cGM/O51xnRJxGdBE3lB3ho +gPMnPks/Za8Ta+4UOylmTz0+LOsOaQw6/k5jO6Xgk6Qaaop4oV/3kNeEdjkzhualUXHKDMnnxwb QLZQUHgce3V9t/ZUFR+joCaiIyOQqqpUHi8mr2wxt/99Iz37jeCOKddg0qgk9IzAYa3jmfvu4Lu9 LTz9+kcM6xGBVoKqwkPMe+lxXnvhSYYOW8u4BAc7lr7Hq19u4vybHuWR2y5EK0BrYzW7N/7M8YY2 zMCZnPy8A2O55m+Pcc0/E4kMDsCg06BYG/jqg9d4d+4bJCT3ZPYdF3fcijgTHFYLSaMv59K9G/nX V5+Red004sdE8NFnywjtO5nxg/tSMk9193EnPnvpCf71748ZduM/uOfayUQEGmmtyuGJB2bwr7/f QXLSj0wdFINWCOSpN96myWJ33VhQweRrYtFTd/Huj4e49J+z8XUbTJzmBgoKi6hpaDvHpMCdxi2D fzL/fPrf9O+bip+3NzqtSEttOUvmzmbeO68x9PxLuHlszFnLERSoLc+hzHkZz869kx7RgZQe2cGc V17kzbffJqXvAG4Znw5OOy31NezZ8BPFuVmk9erDdbdNxwuV9CH9cLRW8dHcl3j160z+csv93H3D RZg0Krnbf+CFV9/locdfJujdlxjXN4akhFBErGzcsJmKGy4l3i8M5GLWb9rK4Yo6xJXruOrC4QTE BoD1IBt270b1m4SPl8tU9tWc55g7fy3XPfw0V08aiZ9epK2lkb0/L2O/047sHgefPPkAL328ilv/ 8QxTxwzA31uPw9rMN6//k1fefIxho0Zxx4U90EgC1SWFFB08zl/v3kpqn2HceOcl+GichPeO+8Ur i7WphuL8YzS0WE/7lGJv4ZNnpvPIW98y5LpZPHTrVLwEUG1N/PzlHB5/42uGXfkgD95wAd4GLfaW KpYtfJ83575CcFQyL9x7SZfbXR6C/qtwan8fDxn7s+Bc+tqjDx544IEH/9dzM6AqtBwvZWmejTFX JLr9byV6D0slVXOIlcvzeOOyqI4T5eZmK/MXZ1GPF+/POo+b+3feiEsO0vLVomzsqnvLpNjJ3lvI ZwcsTLt6EK/fkYGxvaAkEwXZxWTucZ7JuouKQHCwD0N6BmIUjpGUGMLEQZHdHtv4UyFLN5Yzeepg Hvlrb2K9XOvJ4F5B1FS3MHvxUX48lEBaVBT6M6w14b2TeP1+MzPn7GX+wr0sXeNFsJ+eQF89MZH+ DB8UxV+npBCsF9xEyCVEjSR2u6q/cMk+tudbePy5qdw/OdIVMM31BlZ+vpMDFZ3ta8wp4LW1ldz6 4BRm/qVru0LoE66y+NIf+WxLCZf0cJFfBQH/sFDmzh5FerAXGgEggkhvlZ3TN7F4xTEXQRckohMj mZnsErjNbKG42oIS5EWPJF+W/dzCnmMNLoLe7pXg583Vf+nPg9PiCPbRuTaCooD+NMQGoLjkGMXV DianpRLv5zb7dJWxICIg4x0/hMefeYxpFwwh0NcbVXbg7ePLyjn3sny/lZfmvcBtFw/u/F2//sz+ +16u+sfHbMyvoFdcKN/Pf4v1mfncP2cp9//tUgJ0nY9v+GA2Wws13TbrkkYDGulke4wgoBFAI0nd 2iNqNIhdTtoFQNKA5BPJE29+yIUD0ggK8EVCQVUVirYu4MM1h7n/w63cd12/LnUfQKxfKwPPn8HX P21m3I39ObB7J1ZDGNOuuZNhgzoPKoYPG0ltQwtBZxmroTE9ufKG9pNIJyWFx2k2a0hIS8XoXMWR w4do5GL8z4WsqDIOTRA3XHMl8797gG9Wbsc7v4aNh1u57V/TSPTzQ3ae4IpatYP3Fy1D32cKT/7z fkb2inZ/MYSP1ApGXPEIcz9bwtgedxHk48Wwsed1+3n++g/YsD+Pvpc+xKsPXYXRLWdBEBGhm6/7 uVFAEWP4AB59aKjrb2sLhcVlqHIgvQdlYF/xDZt27j0Hgq7iVCFl0FTe/uB1kgJ9XBIcNxQvpZXr p7/A8m/XcMv49I5gepiiue6eWfz95osI8vdDI6gYTCay1s7ny0VLGXTRXTz13BP08HeNvUGDB2Jp rGTGM/P54ecpDO17HV5xgxjQowerlx+kuLyC4T3CKNq+gb1lEr3ToqjYn0leYQkZsQHU7DtIaVU9 Qy4dTVCIK0Dmls17aHWEcdNNNzIypfMW0rDBA6lsdhLo7w3lG3nlw8WMv+NdnnvsFgxdWj340/f4 OnAgC5at4JbzktFIWiSXsjPjxfe4ZGQ/wkMC0AgKyq+ghIIggUZzcr+qIGo0gI1Pn7mbmXO+Y+Qt z/LBv6YT4eeqYWVxHvM/XUDI0JtYPOfRbhqdEhlA1rbLWLfmB+679xIiPVfcPfDAAw888MCD/xm4 j4CdssqKdXm0SF48eHNGBzUJjgnnrgvDeXhjGcsLHFyS6Mo71dpqZs2OJqLTe3G9m5x3xN8SRXQS 2NwE3dZoZW9WJVKAL5NGJWEUu9yeU0GrFc8cjbxLcCO705VpQj5F7tCsow0cNxu4v1+Ym5y3n3Br GN8/ig9WFrMzp5nakVFEmU4nDhVB0DBpUi9S0qPZmV1B5uE68kubOZpfx+7MMlZuLeLLHwv58Jmx 9A3VnyYPuYPlP1eDfxi3nxfeQc5d9ZHomnlSVSEzs5wGq8rSRdvIXC4hd/FRV2UHrbLCwaKmbkRS 5+VFnxCvLuWKJKVFMjhRILuslgIgURBQHHa+/e4gH/1YTEGNlVaLA7tDwWJ1oPPxxuLsNI4oioJP oDejBseQGGY6paHkVHvh5spqzLKJsNBwtO4N+Ikc0elwEJ8+hLHjxhET3l62q/6bthyhpSKfl2be xvtPG1Dc6UxESUNj+TEszlbyK1pRgLVrdmEz9OGqi4Z1kPN23dNqxD/kIE0FtP6pXDt1TLdr/k5r Kzt/2kKTpY0Fz9zKmjekjpN6QQBrSy0W1c7RvDwwjiY5NQ25fgNzn38Qoepy+vXOIL1nEjqTH5Em v9PKuH28aDQK2ZuW8+bceWTuz6PJ3IrV5sBma6PZBorqwAL4n2O77JY2IkZdy5Rx8/l8yWvsM5cR 0PtKzh/e36UPJwzMnMzdHC+rYejtl5MSE96tbj2nXk2fyFfYvHoLrY/fQpCPV7fvm3LWcvPfHqE0 8HzWvPwPksJ8fgfjogCShvUL5/DO/CUcKSqnuaUVm82Ow2FBMugwW1vOuY99A6NIDvTpolNGeg0a SUaISsmxw1QBYYKAIjvxi4hn9HmTSYgO61ZO3uGjZFcbuHf4WDc575yHho0YR2r4F2Rl5VJSD6mB JvoMTMfn623kFpUC/di0dj2ybwQP3XIeb875hB/35DFxbB/2H9pFebM30wcmE+xWwrTEaKSf1vHI zEe48S+TGDywH73Tk9GaAolxD7H9G7dQZVapWfQio9a/3W0O0Up2Cq0qlUePoqhKpySMCVx91cVE a0+th78ZkoTD3MiSl+7jiXlrueDOF3lz1t8Id8dgEASoqSxhy9Yi6oO+ZsSIrTjsDretT8Te1sLR Q2XEmsopbYY/Y7xxD0H3wAMPPPDAg/9Vfu6OLq04LSz4oRTFovDgjO+YLbn8tFVFoaaiEYdVYMGa 41xydwqgYLdZKG4RSY3wcW0UukXY7n4p1myTKa6x4OerJyLC1EG6u+2MfzMc1LY4wctAkEnbjbQB hAQa8PXWUlNnw2KV6XKcfdKGX1VVJL2etNRQkhMCmXyeHbPFSWubg/raRv79zi6+217Aq9/E8u5f U/A1nFiWAFjJr1PQR/kSouskuII7f6p6AjE4XmMBUaB3n3Ay/IVu6VcRBCaPTiAyNfIkwux0b9Ta r3iKkkh4mI69lXZq7RBja+PD+Vt4fHEZPiEBXDExjT7xfoT7CuzZeYxZS6tOqoskCh0R9bvx7DNE gbZbbAiSFoPR0EUGJxuDtFoJ1c36OstuoqLWjN07jEFDhhEXFoCziwFGlMajOp1c0DsOkUZKqtog NIUAg3SCXLtGrz9Fl/xWiFrXNf8uiuV0OimqqAZJT7+xF9DDT+mWYUAQBC719id16BDAi9FX3sPD h4uY+/ln3LZxKeGhQQSHRjJozMXce9/dDEgI5FRR4lzts7Phmw+5+95HqZGCuWDKNEYOzCA+No7S 7B959YV/Y3cqv3ACkAEdN117Oau2zeJAZQvP/msavVJPHROirLoOq00mJiECjU7TZcyAIEQT6a/D kV+Drf3kvb1vWvO56/bpbKsOZvGqVxmWEv67ED6n3c7yuX9n+vMLsRrjufLqaxnYK5WwIB+aCzZy 0wPvov6C4hVF7qIyqtsQZiQkVEuJtZl6FcLcKZAlSew4Ge7sMRuNjc04RH+CQvxOmocCAgIJDPKn praR1iYbBOrp37sfSSGw92gpza2VbMzMIrzndUy86Wa2/fA9mT+vp+q2qRzaeRAxOo2esaG08+Zb H3+ecoeGuQs/JXP1V4SEBOMfGMLg0VN44omHSA7zpqiyBofdTu9BIxiSGIymmz++wHkTLsYnZTha SdNN1zWCExVNR4C6Tj38rVYVEWwNfP/+bN7K3okQNZBb7rzVTc7b3+XE0lZPJZDYszcXjOmLxe7o Mh5EJk6+hIT0/icZETwE3QMPPPDAAw88+O+m54KAqqiUZxWyocpJSq9oUoIlnEpntOxgfz3OwxVk bsij+u4UQtsZjwIOx9kJgaC6w8QpKopDAaTfxpfUEwisuz46SQCHikNWT+JkdruKU1bRasUzXKPt Hp1eVVUkrYagAA1B7Y7ByUHEqWa2zsxk7aFqrI6kUxB019sFFRx25axtFQBfvQSiwPCRPZkx0ptT 8ax2QnRG0SgCtjYZCRF/HZQfr+OtzwvwT01i6UujSPDT4G3UIuJAaKhBcVacZB9RfwWvFUURRQHl LMl5XMabE/tHj7cOsPtz9S13MnFYOjar/aTfGoy+gBm9RoTmNpSuSuBmSCcTCPczsnDSs79uxHQ3 LgmCgI+XDlFv5LxL7+HOsYFYTxwTgoBW5zpNDorL4NGXP+DKvxVSkHeEvXv2smXzZj59fTal5ZW8 8cEcevqeunLNRUdZ9vmnlIixPP3yXG6/ZABeXl7oNBIHvar52FvqLpNfgPRJ1zJ51Cq80kK5YFR/ jKeRj16jRRLBanZ072sBwI7VpoJO22ngEQQE2njkntv5cksZL3+5kqkjerqjj//2mEO2tiJee24e tYZhrFu9kPTIAHx9vNGICqW7alHU354tSlZkbHYHelHrCryodirDybosodVoQHFit8knjSGHQ8bp dCJptIhu14qEAf1JTIrlYPYRNix1kl2uZdo1fQj3D2fcuMEsfW8PRYd/IjO/nKT0iwgPCu4YS37x g3j4xfe5/t4icg4dImv/AbauW84X817iUK2TVR8+hb/JgKKoZIy8kpk3DcekP3n+lLQG1+2TE8bq ScbU3wHtxRVVVDP5xutZMX8hLz85ix4fvEaCt7tugohGp0MPRCWP4pnnHqGpqfnkOVGrw2DwEHQP PPDAAw888OB/hZ6798eyovLNqqPIGi+eeXI8YwPpOAUUELBbbHz54Sae+LmWpZnN3DnUF73BSLKf g/qyWloAH6GT93jpNXRJBY6PQSI51IvaI2aOlzdBcmDnyZlOwqAVz/kUXQCQZU7+gYbYcANGWyPH 6yzIgCR0trGgtIGqaiuj40z4+YqnLV0Q4PDRWlJSg9CKp845HBHshSQJGHUSp+b6/4+98w6vqsr+ /ufcXtN7BVJIKCH00LuCSBWlqCgqFiyDil0cRQXF3kbBAgqiFBVExALSRXrvJZQESC83N7ef/f5x bxpJICgz7/ycrOfJDJ57zj777L323uu7qgAMpIQp2HMul1NOiRY1rDyKGi7uSJCRFgSOE/yw/hRT r2lfd/cuRr+SVGnRFT7rtuy0suOYG/82wSQDe0rKOGJRcm1aFG0i9TVeqlZLV8l7AXRBRhSUU2Yp +RMoWEeL1Ci0Py1l/cEcru3VHn+tvm5wjImU5v4sO7iZnVnlpMbWBBDCI1PTZKpEjQBLHnaVqkK/ gwRIRv1ftqxr1Go6dmqJ/K9f+HnlSh4adG/dsfrC4ZsyBf6hsbQPjaVdpwyuHTaa3ON7+HDaI3y0 fg1bt58mtW/dybgKCws4eeo0can96TWgJ/7m6kBFiUIB4s/OpyKIh6e/zz1CR8QlKiq0ahGL0aRn 957tuJ19wGioWsv52zhaVEZYy6YYKqzrwJypk3hz3jomTJ/HnUO7o1X4lGH8dccGjyWbPQUeYob2 ontqXI1512iUVw4effXVq6+psvxz7D8G7Xu2IA4us2ZURESHE0IOWWcycQHqavtQdtZxzmTmkzYw nLBIH8Tya0271EQ2bNjHnM83owyPpW3LBAAGDuxH5NxVzP14IZsO5DL4ic6EhPrXeGNIRCwhEbG0 aduJQcPKcDz5KJMH92DBokWcmDGZdh1boteqWLFsGTMeHISfpq5+u67aXnD5c0cAekY/8CKv3tub hTEq7n3pLe5Va5n78QwiNd490j8whpbBcPrgVvYWS6QFW1mCqAAAIABJREFU+NfZnrvCZet/LA5d 0SjCNFIjNVIjNVIj/Q3J524tlxfzyeoiQlrEMqq5ichQEzFh3r/oMCNN4wMYPrgZcpGdBb+c8oJu o55BXUM4dTKHV74964PyYM0v5OOFu9iYo0Ct9MpNqiADaR2iUGTns/DHw2Q7fJZO4WLFL0f4dO15 DNqGCdMmfx1BgbBxXy57C72AtcziwClD3w5RtGmmY9aiQ6w9WuYD3BJl58/z6c+Z5PmF0SclgODL vGr10u1cP/kX3v/xFHk2TyUwlySJ8vxCHv5oHxcuOBnXtxkGrape8Wl4n3BwWnh61gGcFePtsbNo yVa+P+GpoXSIaZ/MyCQNW1ft5Y739nIir8KC7Gbf3jO89PY6XvouuwZc9TicFPralQC5rIx3/rWF THQMu9abTE6t1REk28k6mUduNcPu1g3HeHnOERQG1VXx/g6OiCNYZ+f0uTMUcwXCsg9RjrltPG2a BPLWU/cz7c0vyS7xfb/Lwh+rv+XmQSPZcOgEADfeOBI/rYupj07m+3U7yS8s4OCONTx//xjmbMoC IdWwaEYnhoN1G5+tOFQ53heO/MEjE56iRP6LS0ijJ6nPzfSLU/HjnGn8Y8ZnZBf7+u62snXVN/zz sft5b8k2XNYiFn36Lot+2+V9VqnBzz+AxMQENLIdhVJCY/Sv911mg46QIH9OHjvKoYPHK6/nntzO v96fxZbTDrR/ApRWTENYTBOaxEagUyvrBfr+nYbSs3U8u5e8z1dr91WuDfDw2guvc/CChXE3j8bP 7A2S/n3eP5n67pdc84/3eefJWwjSK6spw/4650n6EMKAgsN/cNRadf3Eth+Z/MhM0GivYBDAabVg r7amSk7v5P2ZL1MenMTAwUO9erL6kKzvcvsOHenROZav58/j2w1HK7/VmXeQ+fMXcFxqQs+OHYiq prRL79AWf8t+lq7eRmTr7iQleAF6YPtBdE2K4Pv5czmTZ6R7WlNCtBXbdzFvTH+DFet886DS4BcY RGh4lBe+aY1o8WBqO4pbe6aSveFTbr7nSbYcqtpHTh/YylvP3svjbyyuCkv4T2iG1Wqi4hIICInh lgen8vrkEfzyxSvc99DzFPlui2uSzIQ7RnBy61Luv+sBNu7Lqmzi7NEdvPr0Yzzz7Cs4Jel/svpT owW9kRqpkRqpkRrp74jPAdkj2PrrYQ4Xe7itdyIqasaF+iKbCU+IoWukkx0bj7KnLI02gQbG3dKB Bb//yvQ3fuOHb82YlYLsAjtldg86rcDhlH3Pq2jbNp4HB2Xy9rK99DieTbhZRUmxjfJyJ1abQGg8 tctg1ZJ+Jdq3iaJ/xyje+fEAA45mY5I8NGsZzwsT29E1PYEpN+bx0KwDjHxoOf1ah2JSuNl1KIf9 5zw88o+e9Gsd5JMR64991Sk8rNlwmt92nOP1WXrCgg2E+6spK7GRlWPl+FkrN97VlXt6hKL31ScW ssDucOP0VAXgj7g1gz6/fs+yr7fSasthIoxKcgrKKXBIaCUP+FxgkSTUJhNvvdwfz4vrmfPxH/y0 cj9mvRLhkSkutVPsEDzxeGLlULidLgpOnqXdiEUkR5sxqWWOZxZx7LyNHoPb8/SQSABiooK4b1g0 Ly07TLcxBcQGaCgtspJvdeKWBbKLypAAhMDtkrE7PXgaDFy985KamEhqQijbtu3jaKaVTk2NNT2Y hQeHw47D6boovt4H8NsM4/33Cpj0j6eY+cRdfP7OVMwGLW6njcLccxSVhXHLKx4E0H70FJ5Z+wdP zF7GrSM3E2jWUVacS3BSb2KDteSU1ezhhEmT+GDl47x01yC+fa0ZSkcpWWdPERgbhwewV4ttBYHL 7kK2O6t5MgtcdrDjvAhneHkoMKYV734xjwfvfYB3n76bb2a9hEmvxeO0U5CXg1sXyrTuE5Ed5Wxd +TVvrHieGa1b0bJVKmaVkwM7NrLtUC7X3PEcQzvXn94tODmNgUNuYMnDr/DA2AHMTolHcpRxKisP j9uKEnA6XZc3hAoZp9OB3eFErpbQrpbuDnA5HYCj8j7w56VXp3Pgxjt5+rbBfPdRd5KjzRw/uIt1 Ww7Q6cbHuX9YZ0xaJZRtYdLU98kudVPy1Uy6rv6oBkhzus3MW7+GjmE6hMeNDLiqxXYIjzd5oasy nt2bMBE8uHwMqjPF8/jkwdz99gr6t21FQnwUjsJznD13Hl2APzgdOF2XB56yLBBO2LtqFq1abiCp WRPUspXDe3dyukhw0+TXuHt4q8q+u1wObA6p5p7lK20X3roPDzz4AIce+Sfjhw1gXu/OhBhk9u/4 gx1Hirl1ynRGX9+jBg91TG9DpFnBIXR0ad+aZpVaxED69OnAwp+2omqeStPIkBpKwLWL5/DijJeJ S21NesvmGDUeDu3axLodWdw2bQZxoQGAhuc/+hzHA3fzr7kz2bZyPkH+JiThoaykkHO5hdz2Yo/K xehy2MDuuGKDuvC4QLgq56Zyvty2qj0GgexxgcuO07fujGEJ3DVlOtaycv456wVuFzJzPpxGUEA0 oya9wJnccl75/AMGr/uO8GAzkuyhrKSAc7l2ht0xBe3/6PmtbNHx2udLXAYmjmjzb1Kk1D4k6z84 a8aHVdxLPVlF/39QvX2/RPbTK23zSpJqXNn4/v8Zr1qJZ/7CWDXS/yoJhKjGM8LnPlcjEVWVy9p/ bs9qpIbs4/XNTa1xbdwbLknnzp0jKCiocsxcLl/WW0li/baj5HsioPQYrVsk0d5XHkkIwZHMfMxR IUwa14pIfU3LVsW/9AYt0QEaDAFGmjcNIy5ARWhkIAM6huEuK+dCgR2tycjgAc2ZekcazcxKWqXF 0KOVFxDrTQYy2kYSG6zk7Hkrdhekp8fx6K1pDGsXTGBEIAM6RhFuVl5CnQAqg56u7SNJa2LGpFUR HRtI/66x9EoLxaCWSE2LoleLIJQuByeyS8kt89AkKYoXHsrg3uvi8FNfPtlR67bxjOwZTVyQ1isM WuwUlTpAo6FVy2hefKQbDw5NIMxYFUuvQaZEUtOrcxztm3gT4an0Bq7vHYtednE+z4oLFW3T45g5 pQtpgQqiEiMZ0S0CpVeKwT/En4G9mzEwI4QAnZrAQAMJcQEM6Z/MtAc6M7JjCBqFhFatwGp107RD Aje0MXL8bCnniuyERYdw74ROvHJbCgEab8+0Bh0d2kQSGwCnzpVhdQoSUyJ56NZ07ugfhdZgZEBG DMmhOiS1Ao9b4B8ZyDUdIwk3KRuwz3n/WxMcxpnd21i8dAPp3brSITXOm2SrQtHjclBol2nWJoNu 7Vvib1BVPu9tV0FU01QGDx9Ox7QkzAYDAYFBNGuexg233s/z0x6nc4sE1ColkqQlvXt/erZtjkGn IzS6KcNueYgXn3uUvN8X8EemknsfmUi4WY8EhDRJp1PLSApyzpKVk4shIJJRdz7J9Cmj8dgkOvTs S9+2yRUOJRTlZBOa2oUh13X3ZaQXFOWeJTqtB4Ov7VxpuZIkvOeOQkloXDJ9Bw2hZ0YrDFod5sAQ miW1YPjYO3n2uWcY0CEZk8lEQmoLQnQe8vJzOH3qBOdziglp2pa7Hn6Gp+4fTZBOXWdstveShsTU 1rRKiiDv7AmyLxRhCI5nzF0Pcu/to4gPMdO6Uy86tEnhkmG5wkVhkZ3YxHR6dW1PkJ++3ltLCvLQ BicxaHBfIoO8qbL9IpO4ZkAvTJKNM5knOHHqPCr/SO6c/DzPPTyBxEh/L584Cjh41kZKaktSE+IJ Cw8nIiKi8i88LJIBQ4cQqlci28rIdarp2W8g6YlhSJKE22Yh16mjd/9BpCV43e7dNgv5sok+/QfS qmkwCqWG5HY9SApVcuL4SfILSglp0pLxkx5nyp3X4ZQN9Ojbj47NL11mze2yU2YvpUXPYfRq4c+B g8c4l28hpkVXJj8zjSl3DsOvIgeE7MJS7sAck0KfHl2JCtJdxMtK4lLS6dqpDTpPMYePnCDrQhEh zdrz6LMv8I+7RhHhp/Eym+/c0weZcTglglr0YdzIa4kKMlfyQVSwH7JaQ8+BN9C/a1vMerVPLaal Q/sUzHoFRfk5ZGYe50JuMX4RqTzywqvcP24QoWYdkgRa/0i69L2O6/tnEOLvh9EvgMjoeHpcM4Kn X3iRcdd1J8CkQ5IkinKy8W+ewdDB3dEpFA2TmYTAZbNQIPzpO2AgLeKDAIHTVkaxKph+/a8lJTbA q5ixl1MkBdGvX39S472FBXV+IbRIa0eUQUmZR0LrH01qXCgG/1A69ezLdQN6ERVsQm8wExXXlG79 hzHl6We4+5Yh+Bv1f8vzPDc3Fz8/v8o9V5blyrr2xcXFSKPue1OcsQaz5fPxVwRIrwhEut2cPpHL 2hM2OrWNpkXkpSP+C3JLWbftHH7RIfRPD7ki8PfvEaQvEjg9LrLOlWFxg7+/vtrivYRS4TKCZ/mF AhZuzad5ahRdk66sNIXwyORl5vHD4VLapceSHvNfklGhUii3sWvzJtZuOU5Gn750apOM8v/ogvo7 AjUhZCRJUYfCqWYypb+6D/xpMF6lA2f9d/M4UR7KuJuvQwvIHjfrv5vHaVck48YO5Gol+xTOcjL3 /sGGY0V07nktKdGmRnR4heRxO1n33Zdky9GMHX0NqosDEn37t8NWxsaflpAvRzPyhgGoG4euXtq+ fTsJCQkofHGUVqu1cg2+9MFyDjvSEVkrGHvDddx9Y4ZXMHXLTJu9DY9Q4OenRS3Vu+pw2N2UOTzo dRpMOu87hCxTUGTH6vAgKZX4mTT4GVRYSu3ISiUBJnVVAi8B5eUOCixOPLKEwaAmwKRBuN1YHAKT QY1OLV06jlbyxt7Z7S7K7B5kJPQ6FXpfPLhCIeFxuSm2OLHYvFY5nU5NsL8WrUpRzRJYPymUEnhk Sq1OrHY3DqeMRwiUSgU6rZogfy0aJcjVrMyy202R1Y1Gq8akqwLuSgUUFtsoLXcjkNDrNYQGarGW 2rB5FAT5a2rEEiqU3v5brG6csnfudBoVJqM3m7Ise/dVi8WBW6FEr5QptLhwuQVqjYoAPy3+eiXu qiQCIMBm9Y27AJ1eQ6BZgwoPhWUeDHo1Rq0CIQtsNhc2Dxj1VXPhdHno2DKMfp2i6+EN72v2rPiY CfdMJmDAI8x+4wUSgxSV/CfcTixlZcgKLSajAZWyfiWn22mnzFqO2yMjKZTojSYMWnWts0d22Sm1 WHHLoDf5Y9SpeOb6BKavVLAnayutIwMrM1DLLht5+YXYHE5Uah3+QSGY9RKF+cVIWgMBJr0PcENZ cQEOWU1QsD8K3xloKSrEhYagIL9aMmV1eU52O7x9qui73ohBXy3oV8hYLSWUlllxOJwISYlOb8Q/ IACDVlW/0amaEtPlKKcgvwC7y4NKoyMwKAidWqKstBRJrcdkMlw6PlW4sVgsuGQVZpMBtap+icta WozNKWP290OrVlVTHggsJUWUlpbhdMuoNVoCgkIw6dVVPCE7KSy21L/mhIRfcBBqhYTsKKfIUo7O 6IdRp0aSJDyV1/wx6dUIIfA4yikus/nmu+o0cJaXkFdQgssjo9EZCQwMRK+WyS8sRWMw4WfQXeY8 cmEpKUWotGgkJ0UlFlwe0OmNBAQGotcoq3hZdmOzWrG5wWQyo62ecKMaHhCym9LiQkosNjwyaPUG goKC0GmUNe8DJGTKSktxyAr8TEbUKmXVULudFFvKvHNr0KFUSNX4QaastARLmRW7w4kkKdHqDASG BKPzJX2rgYWEmzJLGXanG5DQ6PSYTYYaPF1WXIDdo/LyegONGlVzY0dv8s6hEAK33UqJ1YHB5I9B 5+Ufl6OckjI7BpMfBt99km/x2SwlWBxuNDoDAWZDDfmuzGLB7nCBJKHR+Phc+vsq7vft20dMTEzl ee5yuXA6vV48mZmZl3Fx9w2q2+Vh6fyNPL70PIEBOp7/5/UMaXYF3vFOF/v+OM7jS3KY/njgZQF6 9ul8Xn9/M036tr0kQJckCUotzPv+MLusWu4a3pwW4VffGaJikeWdOs/rc/aybFc+hVY3HkCtUmIw amnfOpybBqcwtF2INwMpHibf/z3fZ3pY9PlQ2oVqLrmhlpzMZsrbu5gwsc+fAOgeTu06yaMfZ/Ls E0H/NQBd+GIW/1j6BQ88+DR+PW6nz8gx/6fAuRCC7fOmMe6lBQy5ZwZvPjrybyf0S5KC9Uvf5tU3 P2LHKT3T3nuHCcN6ehPvVNsHbMfWcNdj01m//QDX3jmd5x8aQ0zwv4PXJCSpjIk9OrPmnD/Ld20g xaxEkmQWvv4UCy+0Y0QFQJedfDnzCX6w9GDU1QTo9lJ2rfiCJ77cz6uzOjUC9D9BbpeNea88xipX P0aNvgaVJLAUnWR8t95kBXRi+e/fEAGUW4r4/I0n2eHuy+BGgH7VSamUuH9MGgqJy4JXbxy2LxN3 BYqWJBSV2bO9QqfsEywlLm5TQlJQleFZCKo1U7Pdy+5LVQJZredq9KnqPeJKMmj52pcuEvzqbcv3 ztq/SSgUNfsiywJJIdUxPjXbqi5jXPy+iueFoCorvRDIdX5n3eMu4KI++75Zqjk3QoBBX79MVwGC 21x3I6OG/cjzH3/Akn49efKWAZVtSSoNfgFB9SpvK8rbgYRKoyNAo7uE0UUghECh1hFwkQFErmNe vPfqCY+srWAICgm5WCeIOTAEcw1lgAK/oJBaQJk6lNQKlZaAQG3dfUdCkhQY/QIx+gU2yKhU/Tsq gIhaayAi2lDrFv/A4DoV6LXfocJc7f11K9K982/0C8B4Uf8qznyzfxBm/6B6vhWEQkNQUHCDhGil 1kCI1lCjjerXKuvA64yE6Iw13iNJEhqDP9GG2vH7ISEhlzEWeL9TqVITEFzVV6NfUJ1zI4RAUqgw mP0x1Dl+EpIkKu/zDwqj1hBdPD9CICQFJr8ATBe1WbF2AgLrWDtCgKTA5BeIqQ5+urhv3n+raryn rnkzBQRX/d4Az8P65kaSJNR6EyF6U40xVNdxX8X/6/0C0F/Un4p1YzL7YzJfwZr5m5OqIQDL5bIz d/ERMnMEmeesfLnqNEPuTmi49UwIHHYn+SWO2uUp6hLs3B6Kiu0Elbsv37bdzvZdZ/kh38iQ3glX HaBXfOPpvUe4feZO1h4qp2e3WEamBKKXBHn5ZWzdk82Sb/ezy6amV2ogYWYFIOF0OLGWCxoS6iW7 3BQW2ymz/7mMJm6Hi+JiO+VO8V/BWBXjVnpiMx9+8A4nDa14d8JtpMcF1Dgo/0+AdI+TcqsVh0f8 bTcCS1EOR48cIScXZs/7noy2aaTFBVQJHcCSr+bx88pVFDjhVHY+Lve/czwETpuNcpuuRsLesqJ8 CgpKqtaUEFgK88m3lFzdBKWywGEtJb+gCLtTppH+3B5gKSwg31Va7ZqMw2ajXFcV6ylkmdLifApc pYjGYfu37MPhQfrGwWikBvNLXeDRe2YHMPGBB9i8bS/PP/IU8eGhjB2QjiSJOhUsDblW9+/1W8vc TgfIyhpKioZ6cdX23q9D8K8HDDS873/+ngZ7o10CsDR83KU64tKlegbqT/az3oGv3caf4ZeG3dsw y+ulvr2usI9LtnnR/Fzq2670t0v17U/xVwPAb0Pn5s9+51Xltf8VgC5JXuEpb/9JfsmDwTd2oHzt dtb8fITCuxMIkhqm6ZA0SlQKyavdlS5/GKiVXo20QmrAQaL0um25PAKVqm433Usx4OWUDN7fnLzy 8QHW7itnxsv9ubVbBP46BZIAj8ebcCXz4Fk+PexAJVUt4FfeGMYLHvD3VyNd5n0qhdevT5Ia3rda vyvq3zQu1oxe/pCmjnwAtfeuSx3oIPP94q9YvOYs9736NDcNSKulNbtcPy61EVb/vaFatkvFF9f3 Lemjn2T3kIfR6k31QEnqiLGnQXN3eSVXHfG8DRyfhvYFQFKAIICmUQqOrl/G2m3DaB3Xo6rtnC18 tWIDgTHJWM4c916XLt/HGuvwijZbI+/+vBWnLBFgVFTrp6LSslT9WnULEw3i78v0Q/JaVRSK+jPR enkOX5jZ5dfJ5fahug7Ly12vi5cvxxMN3QvqfEdtZq8nHMFX5kgh1ahJbQpoypdbDyErVFRPlaSQ FJXWv0ut08sJR/9tOUv+f1Nj3oRGunr84l1boan9eP6VmbRY+gtnTh3nTEEyccGG/1gfuwy9jTub SQQbtY0T1kiN1Ej/gwDdJ8S53YLFPx3Ho9QxcUxLznmyWftjHt9us3JXR2OlvFZdAHWVlTF/2RG2 HCvBqdbSLikAudjtjau4WADzuNm2JZNFG86TY3WT2DyCYI8NhVJx2YOkvLSc3zefZWeWjbJymW9/ OsyxaB1ldshoF0nH5ACfLCmzZ9dZvlt/lmO5DvwCjVzTK4Hr2oWiVTYAJJXmszW7DJIiub5dKNEX uTf5AWFdE2neTsZPX5UY5eCes+wtUjJ6UDxqpbLae9z88OMR1uzJI9cGiUmhdFHb6hh+b59yM8/z +a9nOHDKglutJr1FBGOvTybaKNW0OEleoG89l8u7353g6IVygqOCuL5/Ir2TzJXvdzqc7NuXxard BZzOKaOk3IOfWU+rFuEM7tGEJoGqynvzLpSwelMWgQmRXJsexIWzeazakYtsMtI1PZLEEG2dB7mE RNGhjSxf/gMx3YYwbPB1aHwfVvFdR7f+xoYdp+k6eCipccHs2/wbW/ccwj+hLX0y2hFs9rq27d30 E8tX/sKhk+fQ+IfRvsu1jB89ELNW6QV/oqoMyG/LFvDz6s1kl9qJS2jDsAHt2L//EHEte9K7YxJq lZLCY9v4ds0OUruNIiM1uJIvJUli78albN6fz4CbJ9DU5OVB+4VjLF29k1ZdB9OlZSRClik+upWF 6/bRru8oOiUFcnTratbtOo7GL4obxw6pdI06vXsN85Ys5+jJ80h+wXTq3JubxowiVF+T784f/oP5 Xy3lYGY2QmuiWVJLunXvSa+uadWUPnUJUy5OH9nLzz+v5ljmGXJyi1BoDMQnt2Lw0KF0atm00l3w csKXzebh5omj2bJxLfO//p5+Gem0jPb6Gy2bP5dd+SbuG96RrxdeqIp/rMarBSd3svjb5WzZcxKh 9aN1517cMf4GArVel0WQyNy1gTU7DuO8qNyHJEnIsoeUjOvp2SYWpULB3nU/cLg0kFvGD0F1BZYF 2ePm6M5V/LRuF5mZJ8kvsmIwB5HcMo1BI8bQKtavgd4/Xhc2lUIm99A6PvjkW07nWohu0Z4bbhpN u4SQynZyTx9h9c9rCG3di/5dUjl3dDer12+GwFi6du9JQrg3+c7x3etZtGQphzLz0QWE02fwcIb0 74ZZ4xshdwG/rVrL0RINg/r0ID4swDdyFlb98DOlikh69+hAkNm37opO891PaxDBLenXrQ3+Rm8s 5Mkda/l+xS/sOpGFpDbSNKE5PQdcR7f0BDSqqr3Ieu4QCxZ/w7adh7FIapKapzP2tjtJjTJVjk95 5i6+/GULzbsOp2frCM7s2chv2w7iVAZw0/ibCGhwzIqE2+Vk66/fkatqys03Dah/3CUJZDdZBzax 6LcDRCWmMWZw98o7bAVnWfjlPDbvOYTFqaBZy44MGzKcji1jfHtCI0hvpEa62uC9Yt9I7zGE5A79 kCU1Bv1/NqTuujuepK9bwmw2NE5KIzVSI/19adR9b4pO4z8XF5Ps+19bSYFo032WiL1nnRBCiMxd B4Wi9Uei+8t7vHfIcuXdQvaIM4fPiK43fCFUHWYJdZdPRGjfz4Sm0yyh6jhLBA/8Wrz3W17lO0oL S8SMGSuEtuMsoegwSwT2+Uz4df9EKDrOFrT5WNzw0nZxKTp/NFvccu9iQat/CdrPEqoOs4W2wyxB y0/E1AVHvL1ylou3318jQrvNEqZec0Xy8AUitNcnQtXxY3Hjm7vFqSJnte+ohxy5ousN8wUdvhQ/ H7PUHquLnq34z6cmfSX0fb8Rx0odovKOsmIxdtISYe4yW0gdZ4uw/nOEttMsoevysaDdR+LeOZk1 ZmHZgvUirMcnwq/3PNHrrmWiy9ivhaHzbBF/0/fitzMOIYQQHodT/D5/naDtLJFx13IR3cPblqbj R4L0j0TMyCXirXX5la1eOFcgbp34maDNRyL0mnmi+YgFIqrfZ0LRbpZIm/iT+P5oWeW9u/84Ljr3 +1T0f3SNmP7eahHcdbYg/UMRdeNSMXdTfp3DVfH9v859UUTr1OLeaZ8K+0W/CSHE19PuFrEhyeLx p54R44f3EGatSgCi9aC7xa7jeUKIYjF98lgRZNSLmGapomef3iI9OUrotBrRauAkcSi7oKqx8rNi 0o19RIBeKVSGABEXFyf8jXphMJmFTqsWtz07T1jKvXN9YOHLIiTAKJ74ZLdwuDw1+v7BlGuF2RQu lp1xCFmWhSzL4uQ3M4TJ7CeenLXe+w1ulzg0b6ow+gWIB6Z+LG4f1E4YdFohSUoREtFBZAohPM4y 8cW08cJfpxVBkYmid+/eomObZKFVq0Ra7xvElmzf3NlLxer500WEWSt05mDRtlMn0SolQWgkREiz dPHGos2XXANCPic+njFBAMIUECoSmzcXTWPDhV6jFKaIVDHj0++Fu9qKro9WzH1ChOs0YubnS8V7 z98h/M3RYtb3v/sW6n4xvHNT0efO6eKXee+ItBij6DVhpjiZU175/KYvpou2iRFCodaJhOQU0Swq WKjUGtEk/Tqx9WS+qBjlH96dLCJCAoRerxcGg0EYDAZhNPuLALOf0Kklce/bayrn5KEeUcIU2Vdc cLl9vXeJ21pqhRTYQxT62nM5ysSYJKXQRPQXFSvTXl4qHhvdVAAiMCJGJDdvLuKjw4QKRFzzDuLj tSdq8eLF5Ck+J7568iaByiA6de0jwvRe3lQpEIBo3mWg+HLjicr7d6ycLzqEB4uBN04SLz52iwg2 eO+Pbt1bfLn6oBDCJr5880kRbVYKvSlAJDZPFVEZhzoDAAAgAElEQVSh/kIpqcXACc+IvWdLKjYb MfPBMcIQki6+WLmtsn3rgZ/F0K6pwthysPht57HK68d++lS0iQsUE1/7RuRYfetq5kMiOcIs9IER om2nzqJ183ihVioEhIhvdp0STt+zW5a8KlrGhQiDf5TI6NpT9OraTvjrlcIc0VzM33RCuD3eATq/ /E0RFOAn7n5qlrhnRDcRYDYIpUIhFMp4sbus/jG0W4vEqGaSMMQOEuWVe/55cVOqScS3u7myHwXn T4kRrdQisvn1orTyabc4sPYL0TzcKJK7Dhfbz1a8yCn2rvlKpDcJFgZTsGjfpYfokZEuIgO0IrBJ ezHj81XispP7f5i2bdsmCgsLRXFxsSguLhbZ2dkiKytLZGdni/ue/kj0efQP0Xv0VDHrcvtGIzXS n6S6ZCX5P7Le5NrvkeW/61JvpEZqpL857d27t8Z5npeXJ7Kzs0V2drbYuHGjUNVrwUBC9sgc2nic PTaJR65tDkBw0xiGNVewZtMxjnjSaK6UKl06i4rKeO6lNWy9IJg8pT+PDIhEkgUlucV88unvvL+7 Wo1Ju53VK/fz1KIsuvZJ4d1/tCPWpMDjdPHLzweZ/Paey9RMhbDESN5+uDOS2MyqIgNvPtSJfilG yp0Cfz8dEvDNt/uY/vkRWg1ozUt3tCIlRIPbXs4r7/3OB/O2khDtzxMjmxCguoS5RRPKDWkB7Mw8 y7jJKxl3TVO6tQqlXWoISZHG2mXhfP9ttzmxlUlU/4xXpq9h0aY8ho7vyvTRzfDTSMhuD6sX/cHt X2TWaOfElgPc/v5hugztxL/uSMKoViA8Hs6cyGLE5LU8+NoO9r/bxeclIIFLJjPHwYMP9uambpEY JDfbNh/jtulb+PCTbVzfZSCJajCZDUy6uw+PPhtEhFGNUiWhlD2sX3eEidN38OGXRxjyfDsAPB6B s6yMVWuOcSo5hIl3dCY9Ro9arSYlXl+fEROwsnvvIYpMSbRv29Jbx/Aiq6XL6cJTdJSZr75JRt+B PPv6hzQN0aH0jyG5aRDzXryPt+b9yl3TPuLuG68lwKBCqVKwatZT3DNtNm/P68vLDwwn2Kjk7Sfv 57PFaxg0+XVemHQDYX46hJDZtuAlRj/+IdZyZ6WLrMdpp6TEit1Zu3amw1aGpayE6qkSZJeDMksp NkfV/bLTjrW0mNkzHyS50wCee/VeEmOCsVsc+Lvc7Pj2be6fsYjrH36PNx4ZiUYC2VXOnnWLGXv7 4zz5zOv8Nudpzp85woypL6Bu1o81335Ksr8Kj8dDftYRVq9Zj1ZzmfqesoleQybxS7dJtEyORa1U otZoObt9BU9MeZTP5n5Fl4xu9GoRdHltnRDY3RruGDeGhQtXMHfhSgb27cLpxQv445SSl14YSLJ2 H253zZjs4r3LeWT6uxzzJLPwx9fpntYEtQr++PpVxk95j9sfeo3Vnz9LRJCJvrc/x/YRj1Ym+pFU WhwnfqHvwPG4Inty36h2qH3eMzZLCWWlZVccl6xU6xh179uM/mcLogLNqFUqJOEmc98axo4Yx6tT Z3Lb+o9QS7X8tWuQQpLAXU5BOTw761uG9O2I2lnE8i/f56Gp/2L2O2/Ru9t7RAEetwdXSQE/Lf6E k+kdueeZ10lLDEetM9O+dSQbv/ucqVNfJbTbrcyZ8RwdmgTituUze+bzTH93Om/HxDJj6j2EqTUk NY/CULSQA8czsdMBHbDp93XsP3QIa9Fhth2dTJe2ieiAPXs3cvycxH0pUYQYwHZwOa/PXoCcMoqV rz9GqyZheDwerHknmf3Wh/gbvOE2JXuXcftDL2LqcjfrX7yfuFBv5uLy87sYMWgY/5j0FNds+pxQ ow7hsmOxlPHpzEk0Te/N5Kmv0ioxGkteMVGaK5wcIVNeWkapu/xSTM2RjUsYMepurFEZfDVnNu1j vAlnTh/cxqOTHsQZ34tfV7xDSoQeSVJwdt96Xnz8fma//yYZGRn0TjY2at8bqZH+TZb0hlz7N7y5 YTHkjdRIjdRIfwNS1SOnI0ng9ggWrDyK0uDH7QPDAdDrdIzv14Tv5max+Nd8nh0Y4t00PS7O7D3B 5wedXHdjJ14b3ayyvQiDRMfEAFw7ciqvnT1fwufLDhKfFMXMx7rTPqLKpb11UjAResGlcnIJIVBI EsEBOvx0SlRqFeEhRkKDqwlmRfms2HSW8phIHhyVQtcEr5sp/jpeuqs1u48XM//nE4zsFErHJkbq EtcrXLoeeqQHDvVmXlqSyXtzCpmlV6HTKDEYNLRtFcW44S0Y1zUMhS+ZijcAU6oE6xLgOXuKd9bn Ede5BR9OTCXcXJWvuG9aMEjVAbrMrPm7cETE880TbWrUvAwNTuaBaw8z9bcT/F7eha5qn2LAoGHC bV14emRk5YEZ0Kc5T+3KZur6fFZuKuLB3oEYjFoyOjTxAU0Hh04Wk1Pk4LxVEBYI588XchaIBSQE TrdEp+7JfP58F5oalZUxpYpLJQmwnOFs1kmC4pvTNDa+mtqnpiBu9cCkF9/lqfvHEmZUe0GRSo3q wkbmLvmB9Bue5KG7x1M9ifaox1/i0y9WsvK3n5hy+zUEl+xk7rKNBHe9hZcn30pqfFjlvT07paPV KLwxxdWEiYvSIVwkaNQUBKqSXNQUFkDBwLvfYu7LN6PXaFEpvSVn7NYCZv3rPUxtb2XB9InVngmm 75DbuH3QfOZuWMZBnkZnzWVfpoPooWlkNIuomuOwUJqmdkBIlym0oDCS2LIDSb4Rzjp+iMPZuZQV WzAEB3PuRCZnzmVBQwC6T3kRnDSCEf0zmDr3a3belM53i34iLmMI3dq2RntwTy3AvHj+J+w6nMML ixcyqG9HKkLGB096jfs2rGb61x+w7sx9jAwyoTcHEm2ulo1UPsfoUS9whhiWLplDi0g/qnK1KP5U JkGlUkWHXkN9OSycHNt3kKzcXM6fsxIV58f+E9s45oEWyku37fG4UQY2YdKzb/PgDWkVuxk3jrmT /RvX8eX2P1i/IYsxPWIAgcMFXYffw2ezp9PET41CoUBSqlEVH+GzFUs469eadyfdx4B2Cb62gpjy 6P0cOrCH75Yt5Yah/bmuQwJtWrQnMdbEzv0nySqCxEAbP6/eQkLbntj3HmTNT1sZ0bsHSeFadm45 iiKuJSlxYSiAzGMnuZBfRNp13UhrkUpghQ4tLJSpb7VApTeiAuZ+8CrHpXR2vfscLaOqZcYNGcBj d49k3D+/Y022nVHJuopkJHS7eQYLXp9IkJ8JtUqJ7PGgUl3p7FRkkb4ovty3wJTAyU1LGDrydmwx XVnyzTdkNPNFq9sL2PvrPLYWB/PBZ5/QtUUVHwX2HMad9+3mxwdms2b7Vnon92k83S9SGl+uBn2d YR8NyPD7Z/tUXy6QP3PtavXhP/FsQ+enYmVcMr/H1er737SMUSM1UiM10t8KoFek93cVXWDelnK6 DsugtU/QU2nVDBjRktiPT7Dgp+M8O9Bb4sBh97BjZw6SQcs1XZvWOAgEAqVSqgZsIL/AwpbDHlKG RtEtQlFDMYBCumSCuBoaW+Gt34qoXX7j9KlSTmRZSElMoZlPCK3ok6FJJGnRfqzZUsS5Igc0MdYD 2Lz9UpnMPPxwX269pZQN28+x83gRh08UsmVfHit/OcKq9cf5YUJ3Zt+WhJ+u7qDMHdsvkG+Tmdgj iWCjqoY2RHnRBwuXlV93WCl3nyaiz1yqoyIhBOVWB7JaTVaBgMiqzpqMmspyOCBhNGvp1SUU90+F 7M8uArx1Qw/vOcVTH+7it/1FOGSByy17Lf0OD+0TBI7qQEWhIjTEj5RATYMFFU9eMaW5RQSFtyPA V76kdpUPGTeBJCcnEBNY0+J1eOdhCixu9nz8FKlfT6sqHwMoJZmiYgsocvDIggNbdnIur5B+40cS 7iujUVkSRaH4N2r3FTRP60Cg2VxDoCoty2bt+hzOKz4nIHCxt5huRf9lmVKLhYDoBLLyoIN/NBlJ Wpb9/DHD7nAxenBv2nfoQPP4CHR6wyXH2Ms6CvJP7+e96S8wd+lqckqseNwePLKMEAK/lG64ZHeD v0gIGQHccvNYFv/2BPfc+yC5xTrenzuElDAVWfs8Nb4fPGzZcgKnoQPdU+J94LxKqOzdvR/vLN7N 5s1ZXJcah1pbUapJQpI8PHPzGBb9foZXlqzn2rZNUCn++qxIkkT+4U088dSzLFu1jXKXC5fbjSx7 Y/HDYt3Y3NCQen8KpbdkSfW1GhwTSefu6Xzw+waOnzkBeAG6RwHh0c1oHlozmeCFrAsc3H+c+MTu tGjRrsacauPakdayNV9+sI2TJ89BhwSadmxFQnJT1u/dSV5+IQlFu9iy+ww9p8ygW8v5zF67iszs m0kKt7PjVDYprW8i0lfqpkW7dKKCQvjxg8e413aAwf1706lzBinxYRjMPgUl5azdlIWcnUVGahzK St4SgAK7tRgBnL1QjpxcVXUhqXV7IkODq/ZmlYpLJYm70jlTCDdH9q1m/OiJkNSf776cT/smVcoD S3Epu3ccoeT8Ee7u34T7VVXKUAUCW1kpDm0Eubn5jSd7rfNcxpa3n4++/A2tTkfH/mPomBRQI4eM JEk47TbWL5/D3mxBcFQK42/q92+xUEqShKPoPJvW/caxEg19+vQlOS4YOWsPTz3+CL8VN+Ht11+l W4sQPKe28uDkh9mraM87M1+gfWLgVevD/j++Z/Pu09icdekCBS6XjrH33IY6azdLVm0lPKUr1/dK v2Rd6SuEy5VlxeyFJ3lxyhMs+Gk9RTY3MSltmfPzajr6Xf2xtxdm8q/pTzHts63c/8JMXn5wlDdX CY0W6UZqpEZqpP9SgO49sj0emfW/HCfH4SFn2VYCV+2kImmxLGRK3RB0+BRrcjPoE+a1tp8tsqPV KAkLN1ALkV1kdrPZHeR6lGSE6CuF3+qg+8pPndqXim1uLHYPYX4ajHpl5eHklbM1BJmUYHXWcF2u u2HvwaXTqYmJDWJURADDPDIet0CWBHs2HGL8jB0snL2NiYPi6B1nqFP2P1NoRxaCiKhqtSB9mvOL P1k4HVywSwQ0j2TmqHgqvYp9EpUEaDQqOgdJNcH7xQOilDAGaEGWKXJ4gdr+XccZ+NAaSnVmxo1t z+B2oSTF+mHJL+SfM1dz2iVq9adKhq+Zoro+8Ot2uXE7XWiDtWg0qkuC3Oq1IivaLrCUYiktodOw 8dzQtxP+armaAkZCwoMmvDmxoX5szivE6YLAiCAUKuUl+3V1JR0qkxlWeV/IyM4icoHojEG8dOf1 2ByuWhofc0AorYwQFJzCjM8W4Hj0Sb6f8wbLP38brVZHSHQSE+5/jCcnj8MgSXVmipckifMHN/HP KRP5+Lfz9Bo0kufHDqV1SjLxgTbeeXEqr/14/oo/yw2Edb6Rwd2+ZNrs5bS87h90bd/G+3XiYqYo Ja/UCRHRmHWqWiwSGhaKWg1FecXIHhlQVv7+9T/H8+bXGxj/0tfce107dCqpLha7QnlXpjhzI316 XsuRMgM33vUwI67pTnLTJugkJ69Pvp7Fe6+wbFr1Qs4AGg2mAH9wOimxlVdbeFKdvFxWbqPEUkZA khH/IM1F+5Aef38zeMqwWn2JIk1ptE9K4JtFBzmXX8zvx9eRY4ikfWoaraOuZd7XL7Dz5BlauPI5 l11Ixi2dCQrzAdnYXsye/TrPPDuNxR+/xaJP30Wn1eAflsTEJ1/iqQmDMWhLySlxIMW149kHbybA pK+h3JQkCSELeib519jHlEoFQsggKarx49WxuikUguwTW7lpyEiOn3czfGR/HzivUvY4XS5yCgvR h8QyccpUWgV6cNVwsxIoDYG0bt+x8WSvY12UZ23m0SmPoTMYaDH4Atu/fr6yvnVF8tL8o78yftz9 5KoCaN55LLf+mwA6gD3vNAs/nMHC42Y+ik4lOS4YPE5KCvPILfTHWXHoeZwUFeSRqyiuunaVaOuv nzPt/Z/JzrXWI3YEkTFuNMadP/P4o8+TceurDOja6qoB9Arllr28hKfHDuLd1afpdM0IBsUFUm4r w+3594y9Lqgp4ybcx/69e3jzjTdITG3JhP6p/7fqnzZSIzVSI/0vAfSKA8MjPCz44QQEBHDXtVEI d3XoJyjNL2TRtlIWrT5Fn7FNkACtpESWBfZyr3nqUtu8QlKg8ggctqtzAglRJUdXkF6tQKdSYLV5 cDirQRwJwIPVJkCjQnMJs10tN0Ak1GolanXVAd1zYDq3rz3KCyty2ZnnolsM1JWEXqtQIAF2q7sS SddbuVGrIVQpOOnSctuo1uCqPU6SJKFSguy6xMB4BA6LGxQSoTo12O38tPIouWoT0x4fwJPXhOCW QaWUyJJt6CqsUvWC0oYd3kqFAqVSgdsl426oAbda2wFGPSqFIDgqjRtuuoWmIeoamcMBJIUStQqM Wi0qJVgKSpE9Hi8I9I1tXfaAilbE1WC9WvMoodCZCQI8imhuv+MuXE5nHQoPhdcAKWlo3mUoS37t S1H+eXZv28qmjev4cflSXpw2lWJZz7uPjKBWuLRvrPZs/52vVx5i5KRXmPPeExhlNwqVCokLmE26 GrVirxAyMW7czfx+2MqgCcNISQiqB7jqvdn0C22VwnP1bpZZrHg8oDcaatTD3P3tizz4+gJSxzzH q/cPwV+vrnO9XSl5XE5WffEJBwpkHnp7CW/c1x0kBSqlEmtJHgadEvFXq227XdhsVlCrCdTpajCD qIOXtWoNeq2Wc1YntjIBwTX3IZvNAWjRaqs8VFp1TCd43npOn9rJH2t2EhvbhmYxMSR17EXzeCMb Vu3CP/YYuXIkPVrEEqKpUhO17j2ahb8OozjnDLt37mTb5k3M++orXrpvJKbw7TwxIoEwA7hzDQwf dzMJYUHIslxrLaqUqosrql1KH/rXNF3CDZKTkDaj6dPidz7+9BUeiI3n/ceGU1GrQq1SEWjSodL5 06nHCMZ1DcR5cR4JSUKpVNJIdWF0N0J2o/O42P/TJyw+8CQ3ttRVrjl7mYVFs9/mvFuNESvlNmet s7AhrvINJUNkIhMen04fi4aM1nFVylfp4tKGks8bqvq7L+H6fQXu2m6ng/xcKw99sIgxXVPQS54a 55+MhuahZtxdh/PRJ00IS+6EVq2+ArlE1FsisyLUCuGm/MxaZv9yjM53vsyaDx/D7XIhhECr5yIF 8F8f94rnIlr24p7JT7Bj/ETmzppF7y5v09QoIa76+m6kRmqkRmqkK5fC68JIQsZ6MpNvjnvoO6gl s57owXuPd6/6e7I7b0zpQqLDxo8/nsAN6NQKWseZcNhc7D+RV3WgA5JSgaYS+Hmv+ZmNJJod5Gbn U+x7ccW5qFYpUNBAQ7rkTebkkj3IoqaQmRhtJDpMz8HMAnILy6oOJ4CifI7ml2GONxPip74EZpSw nStgzxkrLkGNeubVwY/DIcCjIsaspL4KcenxZhRKBTuP5FS6iYpKIb7mQ5LSSLfWOsqzs/lirxWN WlnrTy0JXNLFuE2qMfZOh8y2XTmojRrSk8KwO1yczbNi9tPSplWoTxD3PqNSSSgVV4exVEFG9MFm SgvzKbcUX/HzLdumEBUZzsrvFnM2Nw+FUo1Go6nxp8ArQKanN8NoNrB2zUocDlsNACFkdy2QqlMo kCQoteTUEkSUCukvLymNLpYuaVryD/7E4n1W1Bf1W6PRoFZ6cEk+QK9UYfQLIKZZCoNuuJmX35nF x7M/oGnRSXZt+qPCOFsH2SguysNCCE1TU/BTgFJVAapUqJQK/goWbdJtJItXLOOeYT2ou5CODOho 3SoMqXgz+3NKcVXgLeHtxY5t67G4IL1TDFqdl7mKDizj5kmv4ml2A/PfnEx4gOGqgHMAWZbJzD6L Qq2hffduqFRqVD7A5v33n4CPF62psrxi9m7eTVBEFCkpbS/7fExMMAmJMRw/cYTTp47U3IdKD3My 8yjq+BiiooMrn2mXlk5yEwMrvviMRatPkt4ng2ZxelCnMrB7Kkf3/cJ3i5YTmJxCs+iwKn0JoFCq MZrMRCe0YOCIMTz7+kf8+P5UwowyG9ZsxuoxkZERj6J4A/PXnUYoVbX4U6MUuBX/qWNIIMtKwuMy +GbZx0x7ew5jUl188NJDPPHhqkplh1+AmfYdW2PJOsGKH5YCytr9VqsRHkfjyX4J6jPuDpq6z/H6 a+9VwF9ApjRnN7Pmb6LbuPtI1rqQqwPeCkAJCEcZB/fsZc/BTMplKkOqhK/kZUNBosocQka/oYwZ PpAm4X5XyDFe0C7c5Zw5cYQd27Zz8PAJHB58HgG+M7oB8oMMRCU2p3Vaa9qktaFNm6q/tm1SMSgk /OPTGHfLePp3SkGtUjRM8VltP5Pt+RzYtYNdh45gh2phaICkwpV3CitqunXqiUatxmAwYDQaUUqi 6jxzl3No71527z9Omfuica9jhCpklIu7WjE2AJ37Xctdd41i48rlLFq63vu7EI2LpJEaqZEa6b8K oFdkufbAkh9PYFMqGD4gEYVSgV6nqvzTadQEBgVyfY8AcrLOs/iIC4VeQ4vu8YSUW/h6yR42n3N5 DxC3k+9XHuCZhZmYqsVmR4YaubZbCNt3Z/Ha4tOVh9CJQ6d5ff4e9hco0SobIKwH6wkNN5JzMJfV u3LwAGVF5eQV2lFERdK3bQTWA6eY9eMpcuxV9bLfX3CQH7cVMKJvU5Jj/WqA5VqDVFLE7Q8v57qn N7B0Wy5OQTUtv5tv5m1k9pZiwjqk0D1Ug7pOgQJiezQl3Szx89JdLNhVUvnN+3Yc4/YPDtS0UCmU PDqxHWprOZOfWMF7P2dRbJcBQfbZPN6fs4VuN6+gkKp8dHhkzudYqoEKmd/XHuCf356jabMoxnU0 IqGgaZiRwlwrq9aernxfXnYer83awpKt5eg1V0F/HhxLRGQ8OWePcTbnbA0A0SCK6cNt1/chMG8j t024jy+W/0657AWFx/dsYtoDN3LrlHc4k1uKrs1oBrRpStaaD3noxXfYduAYxw/uZM5bz9J59OMU 2+TKGHaA+LRktCoV383/gNOlPgucLZ+5r01m+ie/86dRre8xozmAyU8+hb3wJA/ceA1zv//D13fB yQObmf74A1w34BbsQOahtUy47TEOnrMAEkqVCoVCjVyeRy4ShtDwS1gz9AQEh2Emn91bN3Pe56kg l+fz+czpvP/Jt6hM+j8NmhQqNUaTCY1adUmhbczYscSGaHj2sWnsP11Ehdvz4VWzeHfxH/i3Hk3/ xBC0ElBymLFj7+MEyfywdBYtIgNrJO/7yxuaQkFSfDSyw8byhV9WXrcXneHdaZP4cGkmWnXDULok SbhsNnLOna/qn9vC8q8/4N3v9tA+YwDXdwi4fDvhbejW5xp0mb/zyZz5nLRUrc+v587ji2+2MGDA QDq0bV21fNqmk9o8id9+WskZOYguaS2ogDD9+wzEnLuTX/eeJi6lGxHBYZX9W79kFs+9+j6Hskt8 /KRGpYCc3AvYbTIh0bG4PXD/lCdpEqjnpbuG8c83v+RsoddVv/jCSRZ+8hrtkzI4XFzOf05Ul1Co tPgBEckdeWXON1wbXshbz93DtC9/97F7KG36j6N/vIcF7z/H3VM/5HS+t98luadZ9NHL3HbLzXz2 477Gk/0SR75fZHseub03O799lxUnXCCBs7yMH2e98//YO+/wKKr2739mZkt6IyGFkBBCIAm9hCa9 S0dpYgERFRCQDgKKgIJUAamCdBCk9yqINAUEkd5r6KGkZ3dn5v1jN5tNSELwQR+e3zvf68qFzs6c OXOf+r3PXbhpDGPAwPdQ0zK7SwmCQPLjO0z4tB358nlRqnx5ypcqSkhwBH3HLCDJfvJtZs/q6bgL Ak4uLrjY/lxdXXF3d0PnGkqXz2ZZ+/+d0wx/rx7FXnuDncfvvlhvUW8wpFsrXF08KRJVkspVq1C6 ZDG8vP14b9BUbjxMtMfSyetYF0Xs5v5Z/x7/Mpfg/N58NHotKWkWBEHg/tap5PfxpM/Mg5w7sJpO zWqQ38cT93wlOZVojTuS9vAsPdrUxcOrAKVjKhFTqgS+XkF0HjqLNAQUcyq/fNudgJp9ADPf9qyH i4sz3r6B9P12g9W1I+kR0we9h5+PFyXLladCmSgKBhWi6+cziVdtdVRT+W3TTPyMIhVf78jFRNv+ xKasOL57GZG+btR4swdXEx0sFIyBVK/XirLut9m9czP37ac0GjRo0KDhv4lMJu6qLViJbE5k4bob 6LwL8HZ5l2e0wggCLkYdbeuEMnnPaX7ccom3ikURVDCQ8R9H8v7UC9RuuxgPVx2mZBOKKhDkbURO UUg/5PYO9ObtduXYfGQ3o8fuYOYsA0ZB4VGqgLeLhLuHgNmSh8VVcqNx5YJs+jWWceN3M2X6XtIS RIZ9Vo1RHYryUYfSnL0Rz3fz97F312miC7hw7+5TTl96SrlGZejVNJQAZzK01NnA6OGCu2Rh19bT 7N59DiejjkBfF1xEhdj7KTyKTyV/0VBWfRlDkFeGmaoiKyA7nOrrvZjevzQ1hx2n0yer6ONpRE0z 8yTJTJkwT5BVFCVDYx5esTjbvzHz9uij9Bq6lf56EVEAWVEwm1VCIkNxddStJKYyfepOli92ppC/ EwmPkrlwP5X8oYFM/7yq9V5PZxo1Kc6sLduYNHknSxYacdWp3H1swcXdSHCgAZNDjjFVVZEtynNT 3mXD0ClVvCiGuTv488/ztK9ZEiGLnbaqyJixPGNem+4G12nEFMySniGTFtGx+TY+MhoRBBXZbMYs K7TuX93m3y4xccY0LrZ4i1WTh7Fu+ggERcZs8KNL06pcXr0t0z7NULw1H9f5mvFbN1M8xJ+AfK7E 3buP2TWIEqH5uHv2cSafXFWxknjFQQaqKoNqyRyY0PZ9ot6Zsi16s2ZqIp37TuD9FtXoatRb624x Y7ZIVGjUBTfgZnwcyxdNYMmq2RQKiyQ6vDzpTDoAACAASURBVACP713h9yN/EViuEYP7ds4g/9l0 0Mqv1eb9FhWZungs0dsW4O3mxKN7t3H19QMXHwSLOVO9c6TjioLFYs7k559lB5t+IxaLBVlW7Dv4 0LpdGdf7MN1HL6ZSiT1UjimJ/PQWf568QIpLMVbOHEmovzWw0/fjevPr2TukWe5Qr3SoQ4AyUCxm anw0nnXju2E06JBlM1mdMGWLBdUiZ7gpYEtxZrtP0huo06kflaeuYNXYD8k3fwg+Hkbu3LoLbgGE FnLnTrLl+cQzPfpYUiyff1CD6cMKEOzvRdzd61yNfUzxWu34+uvBGOy3K8gWrHLJorMRgJYdOnP+ zGk+n/Y1FXf+SInIQsTfu8Lx09coVuMt+vToTGEPx2dCKFcsBDegaMWqRISF28uMer0+hSd9z/FL d6jwWkn8/B2UMElxLJw0jlGfDSCqdFmKhgUQd+MsR46dw6XEG/RqF4OnASj5BhtWTOfdD/sxpv+7 TBhiQBIFFEXGZDKj862IU7pJsaJgUbHOAS8wDVjbRsWSqQ1VZAtZroFFtmCR09tVILRkNaYtXcU7 zVowpu+7GI3LGdQ6hrBS1Zi65Ed6de3BnK+6s2Bcn0z1Dildi5Y9/LSVPRfonVxo028Qw2c2Yty4 mTSZ3YukR5eYNn8btTpOpnaggWFKJt0JiXG3mTqwHUMXHKVq0/f5uH1DxKRYNvw4j2+H9OL2/TiW f9sPECkUXZ6BgwdhNjghoiLo9CQ/uMXuTT9x9IGEf8EQ+7yampzI03jxGfel58KUgotvKE3f+pAq Fcvgn88dU8JDtv60iBXjPsXZx5+RPdvh7/J8sikASU8fE/fwCS6Cw9yiCnj6eKEXRVRLGk+fPiE5 NcNdSTWnkpCYxJbJ3Zhx6S88ChQlqlQZnty1WXA8PU+j6jU4+tiXvl9No1b5osjJ99i6bDpTxvYh XvJg1cgOhMTU58NWJ5mz5iBlajSjcZVIkIxUrByFnBLPzEHt6D1jL+UbvMW4d5tgND9k28r5zP6q PzfvPGDT3C8QBCfKVm/O6EEH+GjUEgYNKsqq6UMRgVtnDzCqT28S/Mox4YvPCXPLWNsFQaB4dCR1 q5dk0fETHPvzIY3K+GqDRIMGDRpeJYIu2HZVclIqNduUo31UMD7Pqpqt/+j1lK5dklEf6DAGWs+M ja7OvNOlJsERAczecp0HSQpRUUG0rR9GQNpTlv2ZQKVwV7smv1zlCLbMc2P68tMcu56El58XLRoU oUqYM9t3XsYnIihPH1GhVnFWF/Jj24FYLsWZ8PRxp2l167OStzdTRjWgYe3LrPrlOlcemAgND+DD LtVoV6sgAe55yBNUIIhflrbj8B832X7kDqeuPuH+kzQQdERHB1KzSmHa1QjCxzVzWQ1blMK5kg4/ lwxfzpjXK3I0IB9T1lzm/O1k/AO9adkkigZ+ZiZtj6VSWW+7nEWdRO0m5bhUM4o9B69z9FIiaaqK t7crVSsEUzHcw3pab9ARWjKUwT1dKFXMj/N/XuXQxSd4ePjxxpsF+bBNJIU9dHa5R5YpxPaFLZiy 5BR/XE/Gy8+dPjUK07i8L7/vv8hDnTvpW9wCIfno3qUCvtGBOfCY7NLgWLtJTLnXKB8xn5/37uNE m+aUDjJkikFTvGYzBloiiIkKzdLFbD6EOi8+GD6b5h/04Zfdezl58QapZggqFEnt+nUoFhqIsy0A nWdETbYfOMKGVas4fikWF78ivNGmNf7XVrFq8w4yMws9o1f+TKEpE9mw+wAJFicate1K30+7c+fw Mrb+dptiHhmnrF5R1RkwcCDVKoTY28a3VB0GDNJTq1RAphGULg+9swfNu33Npdbd+HnHNk6cuYZF kPArUIRqNetQNqogIlCsTCN+27uBH1du4MT5Szx4cBdv/0iGTejNW++0oYgtIrgqPBskDkHAK6w8 X3y3kKiKc1i17Tcskhst3+tLx3b1eHT5GDtPxFG6cMBzu3h4ydp8Okiicrli5GbZ7FGoNB9/OhC3 YpXxdOjv7YbOJfK1JixesZajp24geBWiU58P6Nq1I1Gh+e3R2aOrtKDfwDKkWdRn9A2KLFO4Skl7 xofXO/fH56E/rna3A5GmHw6kQHxBu8m9KOlp2XUQRdLCrWNBEHEPKsXGw0f4dtx49h2/gpNXIO0/ asi77Vtydtd8jsUaCHjOIbpgdCOyZnM+M5aiWEQEJ39dz5GzN3ErXYP3B7SkY8f2hHgZ7fcHFilF 10EDCKiUOUBZehAuybMQA8fNoVLdpixbvo4LN+PwCSnNqI9H0f7NZhRxyDKRHgWyZqu3GYIvRWq3 JTzEIVOAvig9e/QkPOYOb75WAg8HQdZ4tx+rgiNZv2kHx86c5/6dO3gFlWBAhyF0ebcZIX4ZJ/7R dd/j0OnmHNizk4NHThGfkoaLpz8x1eryWrlieNisL1yLVWHwoAFUqFTohawcdDojrboNpLhSzL7Q GJzcaNOjPxUNJe39zMnVg9ZdBlFJKUqGelOiSPk6LN++k5lzVyPePcH1pBhCXfVEvtaStfurc+rY fvbsO87DhBTcvfJTrnI1qlYui4+LUVvZc+3cEl7B1ejWrjxfr5jCrgEfkLp6GqfSgpjQtysW09Es epg0rv21mRHzDlD1rYHsWfYNOllGkCQa1K5FgU/b88OaxSx8oz0dqxcgtFgMg0eWs/VjCZ3lKSum f8Xkq09p9+lnDO3eOJMS8G9ZzhgiGPj5OARBRK/PmIc6ta1Mowbt2L19B91b18Y/PP9zi3J1FRjZ ri6jM1nsKZjN3uy8dJK64QFYHQGyTsLW0+n7qXpmrDtI2zql0dtSbRqdReYP7s/eG05sP3GIekW8 7I/WrNsQ8/3SzJk+ictfdiC8UiP6dzrJnDW/U6nB24wY0AKz2YIkKtz8cy1Dp++iVLOe7NswFYMs I4gijerXJ7RPG8ZvWMSsXe/RrV4hjJ4FeLPLZ5w7dZJJC2YyrFRlRr8Xzbxxn7HlrhejZ06haWn/ Z9ZtfVAhipapQPzunzl37RKNyvhqfugaNGjQ8N9eqlt3m6TeSMrH7wvfsy5LisruI7fZczQWSRKt /sk5KLdV0k+MBHS6jPsURcUiW9M1iaKAJIoIqFgUFUkUraZkthVAVVUsFhXFtmBIojUYjCwr1v/P 5f2OmgVVtZ4+Kyr2gDJiRrYxFFnFoii2gzHreyQxPUhLXiRl/S7rO1SHwM7Wd+lEgUzh2AWrbBQV dJKYsdgJoCoqFtnhmyVrXS2yapVXpiTc6eTF9l6y+T7bgmtRrLnhFTXjJF4UrW0oZKlbVrmLNnko ioJKhmxURUVW1ExtISsqgb4uNKxakLAg9xx6hgAkMalfFwZM3c3YBYvp/3YDMsU7l63pwCRJQhTF Z4h/+gbI2rZyhnWBYA1A5+gbnO6PJ8vW+wRBQKfTkXBwLqH1u1K32/fMH/kObi7pSgI14yQYEEUJ nU6HqliQFdXBlxvrqbGsIEoSkmjzP7Rf0z2bIi9TRgIVOUvdRUm0mtzbYjKoqoJFTr/HmupKkiQk SbJ/f26BhlRVRZazfouEqijIqookSrnnrAerfGUFwdYWOd2tKgqyIoMgWse1kKGUUBXZ4Tsy6uGY 9k+RLblaYwhiRrmyxYyiCuh0kj0VkWyxWK/pdfb0UIpsQcHa3o4xIix26wEBUbIGilMU2TYmdbla cqqqavtW65hUZNlmXWANQibppEzpqVRFQZZlBFFCksQc+oOKIlvbWnUsS8osR7usnmmTjJRmVjli GztCpsBYiiJb5x67ZYqAKEnWeUhIvzeDGCmybBv36XNj5v5ibVdr/xefCeCVuwyztk16X1URrX3D 4Vq6i0dGuifVNlfKtuBvOof0myqKYv3G9DldtPWdnBSH/xdw9OhRwsPD7fNlUlKS/Vu/mr6Rc2ll UG9t5q03G/NRm8oOA9zCw2Oz8YvpxYdfreD7oa2JPfYTxcu3I7J1L/L9tZik6kP5ZW4/7l0/Qt3C FYmv8AHXf5+LHH+fpV91o/Os3xi/YDd93yjmUKMkflkxidrtx/HuVzNZNPSdrDML+9fPpm2HHoS9 3o2lC6ZRyHaCq8Se5LNPP2TRBU/mzVvA6xUCUa4f5ZOuH7D1URHmz5lJ7VL5kS8f4N33O3NMqsyC mZOoHJkeq0Hmz3072bBpG8f+Os2NO/dISHjM9Su38KnWnvVzxlEpsmCu8vz+i6b0/2Yz5Vq9T4Ww APTYxgEqplQnun7en6L53Hm0awaFmvSg+eAf+X7Im7gYddzbMJ6QVgPp8NUmZvZrhJPBQeunJtCi sA/b5XJ80a0VosM8rigyh7cuZdPhayy/kETrEDNXto0jvPFIek1czZS+zQCwJMezYfwnvDlmE6Pm /cqwDiUdap7C8e3fU67RQJoP/o71Yz6y/3Ll2M90b9eSY6YAalUtze4t+2k75DtmDGqT49jYPv8b 3u8zibfHzGN8t6bazliDBg0a/mGcPHmS4OBg+3puNpsxmayxta5evfpsFHdBgNoxQdQqH5hHip8D wRWy8LWXde/frU9O7/k75WfHR/9J+WR9Rn3Ou4Q81k/4D75BIBfSlx4J1pW27duz4+dfmDprATFl SlOzuL89QI0oSYi2AF5ZIwRnJd+SpOPZ4MwZkXzTn8/+vmyeQ7AGDcsyAgRJh5j1eUFCL0qZNzfZ XXOoe4aCIfs62QMoCgKCQ1k5kfBspexA6rL/Fsl+SplbOaqqIooSYnodcoiCrKoqgiiic1CmWMtN /y2H77AHMVIRs5NvDnWSdPqMNF+2OtmvOZDMrNfS/Uj1esMz5UqSzlZmzlGg7QGxJMle1+wig2f+ 9gy5ZNeX06+JkoQhx7KEjPGTtU3s9bX+6yhH+/tUK4HP/Fw2/S492JdDncQc6mRVmmRu1+eT3wzZ ZtdeOp0+U7949pot+JUgIIgCent/y6oYze47c4nurSHTZO8TUZ+PW0YxbtVUvPIVYsngXtkuBalp Zi5cvYOLmwuhxYqkN5PN0MMVT/8IfEgi9vI9hzawxaH4bQuf9RiAa4kmjPnmazs5/4+/4MlVhvTt xeT5m7B4+FGuXFlKV6pOkLuJlctW8lSW87zEp5nh9fd70q1uGVyFzM/lJSOApNPblbT2sZF6h5PX LZhcLrJk8aJsFaKRxSJxyZo9weHlZouF81diMTg5ERZVLIvcnXHzL0YgJm5duJtJL164XE1GfTeN dq07sXJNHG98OJBvbeScrFlpbBZtrq6uuIgySU9StOGhQYMGDa8AdNltEiUBELUNjoa8EamcUt0g CATHtODjD4/S7dOv+HpiBIFjh1DUz5hNZNmcSWhumoP0n3O8T7WeqqtKRqTb/2Tznt2zeb32Ir// m+U885sgZKuHyu07c28m4YXNJZ9bp+zKfKH35JyG6UVl+mxV//P+8Oz9jn09h2fz8P1ZFUl/p888 Xz7ZyDav7WW/JrxQm73YPRoAnF3d6NqvPxPWfUCRBl1oUiTnbCaKLeuAIGb0QTVTm6molgySKQhw 7+Jhxg35hL/0xfh2zHhqFPHMo4In9/YF+HH2RObM30SNTsOYOKovxQt4IqsiOstZzv5+gF/TXiyH ptXaR0ASdC9eJTWbsaGzXvQs254Te6bmGKxO0kmgyDkWq9iUgNnJ3R5V35IRkcNqeSLh5OKGQQKS kkhOeIIJMGKLfp95uGX8K7xgIFcNGjRo0PCPQfw7G1MNGvKyiU9f7Ft16cXcpXMpnk/g5pVLyPx7 gWINBcsycMjnvFm/DAa9lh9ZgwYNGqyrv57gmPYc2rWJJRN65nib0aCnSMH8JCelEHvpmo1kp1Pl ZJLirhGHC/kL57OzveQHl5k7cRjzj0CPwaPpXKfYSyDn6RqCFE6cvEyca3Hebd+CEsHeCIJojXOh kzJl7PivQR9M2VCJJ3/8zNlUHXq9Pts/MRcPPr0kERHiT1pqGjcvXMki91RS4q5wGz3+EX525YUA xJ47zPCePYn3iebttxqybdlcBo9abGuazCnZ0tfo5ORk0iwiLh5O2rjQoEGDhleNoGvQ8FLJe/pW wOBLk7admTj2C+pUjP5XO52hYHk+G/Yl7RuVw6DTursGDRo0pENncCamTmOKBrpn+7sK6D08KP96 A+T4WFavWpTOwQGIv32LzUuX4BwQQu0q1a0XU+NYv/Bbvpy9n3e7D2LURw0z1oSXQp4la2C4pKck p2bOeX/vxF/cu/8AxP/iXK8CuNKuY3NIuUCXzsOIz2LJbkl6wJLJk7lPzsHY9C7OlG/6OrrUx/y0 fG4muSfFPWTjgvnovAKoX712+oJL/J1LzBrRna333fl87npmjBlBp6pOzJnxDRPWHLWSeIdjcmt5 Sdy+H8tjyZOgIG9tUGjQoEHDq7A+ayLQ8M8xdCGTz6tj4DT1XzBFtfsSZ/K5UzVLEQ0aNPx/DzUH f+Rn53EnCpdpwpC2sxi9eAL15QR6vfM6UnIsKxfOYsGGizT9YChdGoYDJvbvWE6vAdPxConEVYpn 3JivbdlGVcxmgejyVWjRrA7GvzMNqzJgoFqlsoSv3sTwoYO4fLo1Rf2MnDq4jeUbfubuoyQCqv8X tza2dJttB01ny44TLFz5NeGHNtLyjQYEehi4fv44m7fsJlkN52Lv3rmUYyAw6nVGdCzH0IXfUb1N Cv06tcDZ8oB1y75n1k/HqdG2Lz1bRFlJf+J91s8bzdfLr/DBl9PpVtcaL6D3iMkcadmG70YNIbrY ChoX97bHzwAB+d51Lp44hmtQGMVCIuw6Bm2V1KBBg4ZXjKBnS2JUW9Aeh3uy8yH8ZwhQNoF/skQi ttcpu2t/wwc2O5nkuZysq9tLJqTPC/j1UuWfjZxf5D3Z3vMS2iNv+oEX9wXWoEGDhv/byD69Wdbk IY6/euQvxICpaxFcuzN+/rfsWvotAM7uAXQZPJExIz+xBgOUn/Lw9lkeAtw4x6wxnz3z9ibv9qVe rgRdeO6VRh8P4LP7D/l84lzGDT0AgE9oGUaNG8nqWbM5ZTL/I2LLduUSsrmgqqjOgczfe4x608cz Z+lqls78lhSzjFf+EKo2fY+Wbd8hMJeyVMDFMz+ffrse1aUbX82aQatVMwAwuuSjQ6/RTBo3wJpe Uk7m0LYldP98Pq+17c2k4R3s5ZSu0Yixk7+k5ftfMnLwZ0Qum0Vh94wXnT13ht17jxBdvTtlyvvn 0AIaNGjQoOFfXamzplnLSnYzkaqsKnZVfTa49z9IgDLVySEScdaT0uyuvUyymqf9j/rPEFLH1FrZ yeSf8r9Ll2l6G2dOC6VBgwYNGv5p/J00a9kpl7Ofu3NWhGes7SqJT+5z9uwlLDp3ikYXI5+r0f5s 3pXYmRX+OdUpp2vp73ny4BaXL15D5xlERJFQXIzSc5/P+bfsMwC8SL2yyu65Wvnc5JBJOa6SEh/H mTMXSBVcKBodiZ+7U85yd9yrPNMmDt+pxDH3q0F8NGYHX077gS8+qJ+3emvQoEGDhv8IL5xmLR2K bGHbiokcPJuMi08kA/p2wCDYvIrTFxDFzN2z+/h28U48vPJRo/n71Cju+499zIVj+1j540aK1mpC y6a1MADb547ivY9G8tbXPzBlSEcA1k3qx/v9Z9Br+lJGdn/z5VUg9Soz5qzh9r0n2aYYU2QLxao0 5e1mFVgz7Vv+jDXz4eD+hHo5vzyNim3hlM2p7Fj4DYNGzeTUzQeIbt60HPAtq7/o+I/I/tiOJXR+ uzNPwxowc/5CXi/hayXpaNp2DRo0aHhVkXdLotyj76cTYzcvf2Kq+D9DKF+I02VD5F8sQ4aVZHr5 BVPeLzhHkvxC2StysHL725k78iKQ3OSQJR2is4cv5Sv75k3uuShKHJUQp/buYcGsJVSs15G2retb f/+XLNw0aNCgQUPOyJGgy7KF7Ssm8d3GBxicPMgXU4eu1QMynaInJTzhu+GfMn7NaVy8AtBFNMtE 0HM0lf+b5t6X/jrAhIkTaJTiSVMbQRcEAUmUEBwJsygiIuXZ9zjPJ8EpV5k1bRKnLt7J9nReURQa f5Kf9s1Ksu77b1l2KpUG3XoQ4uWc5wUvW8Kb1b1ANnF261SafDSSoMjKDBz2CQY5FSEk38uXu+3d 5Ru+zdTZT2j3Vi/Gfj2GEgsmUtDIs1YVGjRo0KDh/wui/zwS/A/WJs9kWpN79s89uXacOd+N5TBR fPthVyI9eSZPugYNGjRoeMUIujWolwi44utuYcLoiXTdOj6DjKlmHl75hVlrTuPj6UOaQCYT89xM zu1a4RdcZCo1aM+azWXxLVwM4wuSzKx1SX93Rj2zN2/LKhXVYsK7Wlu2zRhB4YB8yIqSiegb3bww oGfw9z/x7lMoFeBmJdZ5ILKOt6iqYq+Po8wEQcBkMvHj0kUY3Aqy7MAhavpkr2x4Ebmna+mfWaBt 1xBEajZty5eDjtBt3HK+r1GHUd2aaORcgwYNGjRo+B9CatwVZk8awbQNV/hk1Ld80rysdQ+knZ5r 0KBBw6tN0AFUBCRdIL27V2TI6LksODqEThWsaThSE+NZMX0aqfmi6P9OecbM3erA6Wz+U6pCSlIi Ny+f5+rdRPIXLERk0VCcJNFuIq4qChaLGYusZE+JRQm9Xo8kCvgEhFDNLwhR1PFCGa0FAUWRMaUm EXvrOjdu3MGsSgQWDCM0OBA3FyOCKFq5KLmbbKuqimR0wdcvP75+PjneF1WhCkVVAYNeZy1PEDCn pWJRBZyMBmSLBVmWUVQVSadHr7Oe+MsWC2ZTAhfPnuHWgwR8C4ZTIiIUg84qA1BJTU7iVuxN9G7l KOYDaSkpqIKI0cloJeGKTGpKMrGXz3Hpdjz5gkKIjgzDSSci2XwdVFXBYjZjUVR0tvdn+LcryBYz ZjnLb0Z/6jfvQKNV69m4diWt2zahdD7NZU2DBg0aNGj4X4CqqjjlK8ygqesYNNV+8V/JrKJBgwYN GvKG5yYL1RkMNO02mEjDE8aPGW+7KvPo1lHmLP+N5t37UsFHxpKFX8umJA6smUlMVDCRZSvR+PW6 lC8RQXSFhvy4+7T9vntXTtK9aQVcXFyy/YuIacy6ww8A+HXFd4QanXj/s5kv/KG/bZzMayUCKVKs FHXqN6JRw3qUigqnUFQlZq8/SLLFxuXVvJXnGKQt85/19/61g3EyluDco3h7sJaeFb1w8azGuZtn +aZ/Z4oF58PFxYXWwxahArI5mbXTBlMkMIhSFarTtEkTKpYoSsGir7H017MAJCfcpHloAIsPJpB0 dy+BgoCTiwsFQqsSC2BJ5djWBVQtXpCI0hVp3LgeFUsXI6JkTeZv/dNe/ye3LzK4bRlcXAPpPm5V hmIFiL91mqFvv4aLXxRjlx1I13EAEF62Am+0eZPTR/fz88+/2n5TtZGkQYMGDRo0vOLIMbOKRs41 aNCg4ZVB7slCVSuHN/qUpG+3Rnw49Xt+OjWMNkUsbJr9HXc8izPwk3e4OGVb5ueUNE7sWUajNj1x K/YaUxb2oWwhb84e3s3UCZPo+f5bWJZupGONQnjmL8C7fYZSvMkD9DoRQRCRBBPHft3OnOVbCY+M pmRkfqs2QZIw6CR0OumFP1Q0+tKobWfah5QhqnAIzjqF2HO/M3XSVLp/3J+C/vNoWjXansM058VN xJL4mCuXLqIkxNlN3FVVwc3bnyA/byRJRKc3gN6QqSSdwRlRuEGTmErcNblRpXJdyulNhAe4I6Cy 8uuOtB+xjlYfDeOTd5sQ7OvE1RP7+Hr4F3Rs0piQc+epEZiP7t+MJnn8cP56EMDnEz7Dw2zG2T0Q b+Di4XXUa9oFoVAFJsztT8WI/Fw+sZ+p4ybQu+ObmH/cQbf6EXgXKEbfsfM5e7YBK6Z/Qfnypena MBIl6R5rFk5lwuoL9Bg5nWHv1QCs2nVUEHS+lKhQmVDzUo7+9ie0rYEWJk6DBg0aNPwT+NtR1F9y +f/gF+boXvffy5SSU0T/v0/kc0tV+7+RESYHmfzjbgHPvvdlpQ/+XxnbGv5vzuPPm//+G/V5lfqf Li8fodfDm90H8PnUekwcPYEGE5ozfeF2GnZbRDk/hXNK5hPUR/dimTl2JGKB4sxeu50WUa4AVK9R h6oVIqld+12mT5rKWzUm4ezhS43X21Pj9YznLx/eyobvRhBasRnDvvySol7/cUtQuVFHKjfqCIqM yWxBVhSc6zXEYL5N137f89fVW9SrGo3Tc6Y8yWDkye/raVBj/TO/1ej0NWum9CGfR85R25W0J7z2 wUSmDO+Bj4Mjvfn2HnqOXEX9ntNZPbUbstmCCoSHF6NsmJGQSh8wbc5aao1sT6sPe7Fz+VecjQ+k W/du5LOVkfj4HtO+HkaKdygL1+2iXWlPm9xrU+u1MlSr1Jwpo8fRqf4cnIECxWIYO2cOjRu2Z+xn fSgfvZy0Iz8xcNR8Xv/gc74Z+q5NfLZF2aa8CCxYhKgi+bh+4zxXZCgsaZOPBg0aNPxPkIp/ZUOS A6n4GwQvPaWnRVZQEdBJ1nSiqqpisSioQsa1v1MXQRBQFQWzrCKIAjpR+Hc2aA5p1DJiz6goipV8 iaLwTFyff48AWeukKAoWi4ooCUiS+LcIoZ1Mpn+LoqLY5C+KZA64mym13KsGwRaSx9bvENDrxX+B JGdtCxGd9A+rBP4l4pxensVsQlZUREmHXif9786tr5iryMucN15WPRTZgsUiowKiKKHT6f5VeWWN kaYoiu2a+FLm3H+VoKfDJbAy/TpVp9/3E+mnO8VlKZw5fd9CTX3yzL0Jj2PZuzeWAnXaWMm5w6Tr H1aOlvVC2HT+EPtuQd3gzIJ4cPF3xo8YwK74MKZOGk29aJ//3MfZtgDfPHeEdes28MuBo1y7eZO4 p4nEP4njqaqSZDaTBjg9pyjFYsY5vAJ93mmOr6cbiu0EXZEthJSuhYtRn9vT4F6RcSO74aPLPMCP rlvHAxV4eIFBAwfaTeUFAWTLY1wka+nhcAAAIABJREFUibM3zgEgWywoqnUysDiUnpJ4jz27ruBb pouVnDvI3atAKdq8HsGC4wfYfRWahAFIlKzyOj9MG0bLj8fSukFtQsX7BNd+j0kTh+P6TCe1/uvv 7U14gfxciHvE/XtQOEjbBmvQoEHDq0wqkpNNmGSHQKSA3qDDzSj9Y++VZYW0NBlBJ+Js+PvvUZ/E s3zHFW5L7rSvG0qotx7l0VMWbr1MvLsP7WsVJMhTl2tdTCYLJouKk1H3DMEx3XrAuE3XKFC8EO2q +OFq+Ic3Zpk28ipmk0xyqpnYW0+4dj8ZvYsTYSHeBHoZMBokdKLwtzaMVuWDSmqahTRZxdmow6gX 8/z8lQt3WLHjBpEVwmhVNYAXTwKTftKrYjYrpKSYuHL9MbcepiDo9RQo4ElwPidcDBJGg2TdIL/i Iyo5MZUli49x39OfYW8X+dfee/HMbZbvvEWpqoVpVSn/PztrCAKyRSYx1YIoSbgapWxTC78MoiSb U9kwfwKHLqdQtUUnWlWN+J+aW02pKSQnp2JwdsHZ2fhK9V9BEEhNTiDVJNv5wLMQ8fDyQDWlkJhi Qm90xtXZ+FLnuvRA3Knxjzh+YDebdv9GkiwQVrw8b3d6C1/p35WJIptJSzORHP+Ia1evEns/Hg+/ YIoWCcHX2wO9TmdXDP83SXqeCLoK6IxG3u09gJHfN2Pekg006f0dFX3BlPhsk6clPuCGKhATHpKp IwM4G50p6B9K8rl4Htx4CsGedgGkxl1m3tTRfL/zIUMnfc/HjUq8tAhkO+eN4pPPxnApTqRkpRgq VK1L4UKFuH5sM4tX7kHJoxu1IltwiyhF1x6fUtDX4290VgWzyYyqkxAc5HLu+n0Azp/YR/yVZ0l+ ideqUSgsJJeCZSzJ97hqhsIRhZ6Ru1FvICSoMKkHL3Dv2iMI87F2Pr0HNVt9xOg/j9Jn2jbk4tWZ Pm4CRd1z1iA5GQ14uDmTdt9EaqLlRfQ8GjRo0KDhX4bZZKZnl0XMPyuD2crSRTcjjd6pxOYeJf6x 9146E8vQCYcIrFKc77oW//t7vPgk1m8+ywmnAGrGFCDUW4/6JIGfNpzhTkAh6lQIyoWgW7FqwQEm 7H7CpFG1qBXhmZmg341j2tI/iWnlTvMKvrga/mF+nr42qyrxT5JYsPQoE368wM0UFVEnoioKqipQ NiaML7qWp1lpH6S/uWFMfvCE0eP3MPpwCt8Oq0vvBgF5fvbGlfvMWHicxjp3WlUNePEPtZlhmxIS mb3oGON+usiteBlRL4KqophkJHdnqpcPYVSfilQu5PbK7yZSktNY8eMxzhSIZujbRf41Qnbtwj2m LfiTNu6e/zhBB7j662leG3aIwEol2fR5BYJ9XvKgEARQFY6tH0/bj7+gZOPeDB8bwfNDNb9aWDnl M94ZPIX3B01m+jef4vyK1W/cJzEMX3A+lzuCOZd2g3uz+lKz92xa9pnN2kkfvby5zjYHJD+6zazh 3eg3bSNOLq6o5jQiYmpQqf1b+Lr+uzK5dGQLo4YPZ8XOE5hVEEXRetjqHkTvL8cx8IPWBHoa/3dO 0BEk3ENr0+/tikz5JZFPe3WxUcBsbhUldKjIZrN9OUo/KVZRsagWBEFAFB3UJmmPWLVgGp9P28Tb gybyRY/mpPs+/6ciSjm7ncmz53NNV4Ifd8yjfb1S9t9+XvSITRv3Iit5D3SmKgpm+7e9HDg5W2XR e9pO+tT2+ZvaPAkd5CB3kBWLPW98uiYJIC01mYRU6/ebkx9x8cJlKOWTowZJRUVBzTYXvAYNGjRo eFVg3ezqdDo+7lmbaref0u/ro6QFBrGwX3H8Q/LlvSQHv9e8EsWU5DTOXHhIUmhyNuU9R/fuaO4s COh0VtNewWGDr7OZ++Zs3Z5xUn3/3lOOn33EkxQ5G64goNeJVvP2PHw/eZBBjr87nCglPk2gX7/1 zD2WQnh0AGOaR1A82Jm0hBQOHrnBgs1Xad39DiNGNGJo/fy5+kw++z5r20tGPVHR/jQRzRTO7/T8 +uUgl9yey8knWgCQk+g76mdm7LhDiZjCdK8dQslgZ1ITTVy7EceGAzf4Zc859rxRgtIhbriLeZev oxLguX2XLG4OWfevL2Ber9NJ6HV/320kr+PHUa6iaDWpl0Qh2wHkmCo3qyuJYx/Jq++6W353GlQp iHeUD04vYHWRp3fY6pMad5qPPvwC9yJ1WbfmW9zse9bsZrEXa6usKYeF56Y5zqaP5CpT608FipSg WdUalCle2JZdKnNts1M3PM/dx/47zzeZf5689UZnJKBBpx5E+z7rxKsK+fCRQA4vTYMGDYkpWTiX leTvtoHCjfOH+GraRsq36snGJVMJdIH4R/cRjXkbu898o8Pc/qIuGRdO/cbpGw+p1+YDXq9fnWAf d+6eP8ycHxYyud87uHl4MrBzU/tc9OoTdMDo7Ey/yaupdyuFyoVybhRnjwAiXOD++fOkAk4Ogk1M fMqFK5dx944muIib7aqJXesWM2DoZKp26Mc3o3qjt5PO//wjz166xc2bt2nQ5lMqVSyV6bfUNDOK ov7X9XUVShRFArasWsonNXpgyGKCp1jMmGQVJ2NOWkwRvVsgUZ5w+exZEgE3B7mnpiZy9tJ5XNz9 CCmWcXpgSbzL6h/GM2bZcZq/15OUw0uZNLQPkRGraFo6ICMNupAxRJOTU3nyOBFndydcPTUHdA0a NGh4NWHdlIuSSKWqRSiT/Ijho46genvRpm7hTBsgRVZItagY9BI6QSU51WL1yxYEjEYdTnrRmqnE YVMmW2RS0mQssgoCSJKIQS/ZzahTTTKCaE3dmQKQYkYVBWuwVwksFoU0s4IsK8iKdZ2RJBEng2QN Gst/mCHEYQ20yCBIAqY0C8lmGSwKou1dWSRGWpqZVFO6n7GEi5PkQHCwK74VWSElzYLZYpWLTifi 7KTL1Y89/dDBYpZZt+ggc/9IoXK9EuycWBU3h/tavx7F+/XP0KD3XsZO2Eu1Em9SM9DaBrJFwSTb 2sq2V0g3ZzeZZRQEq8m4oOLk5cY7nV/jneyIiGq9P9UkIytWEmjQSxgNYg4+/Wqm50wyGPQiBl3O O9mDO86z5ch9StYvy+rPKlDEJ/O2s3/XKuzZchJLAWdENQuhVBRS0mRMFgVVBUkn4mzUoZcy+62n mmQsFgWLYiV4omhV6Lg4WdPcZvi/yqSYFPR6HQadgMViLRsEnJx09rRGmfu1VUlhNEhZXCOs/21O s5BillFU0OklXIw6e4yEnPqAPa6CWcasglEvocrWb5VV1ToGbN+p5nSgLAhYzDImi4peL6JPbwOb 8ifNJCPbypbEzOTcbLaQmmaVlyiJOOlF6z5YFDDorW0fUCKMRRPDMr1alRVSzDKSTsIoCaSkWTCZ bePEYDWFd1QE5Ei6BAEBhRXfDOTPeCMTlswk1JgxrlRVRZXNpKRZ0BudMOhELKY0TGYLiBLOzhlE UzankZySikVWEAQRvcGAs7OzvQ0ySLeKOS2VlFSTTcZ6DAYdKDKIOvveWraYSUszI+kNGA26TDI1 m0yYLAoGg8GWfhhqvdmFWm92yURjLWYTJpMFvdGIXifZ/t+MIOkwGAx2JYvFlEZqWhpmi2yruxFn Z6N17DkQUIs5jdTUNCwWGQQRSSdhMDph0KXLm1yNDmTgvWFjaR/ukuM9fk27sa1J14z2g1zbwMnZ KWO8mNNITk3FYlFAEDE4tgFAchy3zuzjsSEfTZq2JNDFQnKKGRdPX9JDDiiymZTkFMy2b9QbjTg5 OVkthwBBVTCbTKSZZQwGIwaDDkFVHeZiC2lpaSBmlnF2KFHzXba07E+Ar6OC+g2qRgXQ/qN+rF27 i7Z1q1IyzOe/unq/AEFXQRBx9g2msm/u2gkP7wI0alaaKTu2MWvLOXo1DEdWQDUn8NfvO9j8232q dupBVV/r/Sd/3cjwvgMwFG/MkCGfEUQqiUkygqpa86AbjBmTz9+Am5sLri7O3Ll+lbu3H1DQ2QOz WcGSfI/fj57moUl96f41L3rGEdGsA9ULTWTXjOFMrVeezrWKo9dLoCqkpSRz4fAOTqUF8dGb9XLU bTm7+dO4VSVG/rSDaWtP0r9pJCqgmJM4+8dO1uy5ReQbHaidbqkmJ7Fn3UJ6j5hP3Y9HsX76EH7f UJTGLXvyWb/+FFm5iEhv0a7FwxYs7u6jB5y/eQ//Mn4E5keDBg0aNLyqFN2+TquYs+ZDTScLFpnr x64yad9D6tcsQoj6hOmrL3LqZiJO3p40b1CUj5uG4ipmlJWckMLB366xaMd1rjxIQhH1FCzgRc2K BWnXIJTE2w+Zs/I8t80iSWduM3DSIeRUM/kCvGhZN4LyoQaOH7/G/M1XuXo/iUcJZkRJR4ECXjSv G06zqgXwdnoZRxgKa9adYfPJp6iCzMKfTrLvFycsJpmoMoXo1CAEycriUGSFm1fvsXHXZfaceEC8 oiMmJoz+HYoR5m3IdFJtSjPz59GrzN9xnXPXE0lGICwkH2+3iqZeCW+c9UJGgNXMvApQMSU9Zdyy y7jm92PWCCs5z3oaHl0+gqldYmk76wZTVp6jZq9o5DQzRw9cYsWZZNq1KEPlkIxtXEJ8Ems3n+aa 7MaH7xQnSBBQk1PZt/8yG66Yadc4kpgQJzsJvhv7iA27L7Hx0D0eJphx93KlQukgWtcLo3yYezZ7 fuuVx3fiWL7rGmfidbzTOJxKhd1zlP7NR/E8TUqlVkk/PNyzbDltJKR245L2fpW+4ZYtFk7/eYOF O65x4tJTEiwQFORN+xZRNCrri4dRssrSnMj0haf549JjYh8mk2QCT3cnoiID+OjNKKILuCDZ5P74 3C2+3HyLGrWjqBdhYP+Bq+w+8xTB6MLQnuXIJ6gkxqey/9AlFu26xfU7yUjOBiIK+9KsbjjNK+bP iOGgyMQ+TmDDyr9Yf+Q+T5JVSpYpSNe2xYkJdXn+CXlyKvt/vcyWGxYaxQSRcOM2C3de58YTCwXD /enYPJJmFXzJ5aCeY0eusWz/I5o0iqB+Kcdoymms3XyBw49EujQJJzrA2U5SU+KTWLvjImv33uTa IxM++b1oVik/t+4lUqBIMG/XKoCPq4Qp9j5j1l7Gv1goHaoH4OEkknbzPqPXXyGkeCFqBsPyzRfZ e+ohCYqOihXDGNAhklAvvZ005iQCAVASLzFxxjb8KrzPp00iHCxLAFXh3pEtfP3jXuq160mNCIlf Nq7ll+OXcPEtwmdf9sYTlYS4u+zbuoola7dyIzYO1dWT0mVf493OH1AxKhjJQYnz8NYlNq1cyPIt +4hLMFOwSCnKlyuO+vgGnmGv0fODlgBcO/07c39YQ7G6benUorJDrZM4tHMNq/bf5I0OHahVMgxB gDP7t7Dkp53ENO9Aq3oxAJz6ZQM/bvydmm3epmqUDz9v2si+wyfwLVGTt1s3Iyy/B2nx99i8egXr t+3i4o27iE7uRJerwwfvd6BcdCH0Nmsec+pjfl61jFWbdnH25j2QjAQVLEz1es3o0Lohvu7OeTrI tJhMKLjkmFv70Z/b+XLeZmq80YPWtYqiqgoP/tjOqKW7qNOmJ7UjjezdtJY9f1zA4BXGkK/64Y1K 4qP77N++isWrt3L91gNUVw9KlqrCOx98SJUSBSE1kWNbf2LivF2gpPDzyjk8/XMNetd81G3+Do2q RGBOesLR/TuYt3AJpy4/AIMbZavW4q133qFq8VAkEbAkcGTPJhas/Z0KtRvxbvvGODsoYM//8Qs/ rVqLT8kGtGnVjAC3HBSkqkqhiOhM84+AtbNGF4nA3y8/F548wGRK/a+v3brcSKOqKvYgaFnVM8+Y gdgi4QF4+PnzYf/hrNrZjqEdG3OtxydULOLDyUO7mT9vGUExjejbvwcAcdeOM3v8YA7eVikdIbBn wWg2pKRZNSIWM+6BRWjSqh3VSxa0RjiVZVQHc3RVVZEV2R5ULX1wK8j2+hSNqUiNqlUYv3QG/Uy3 qFetLOa422zfvo1zl6+hkFc3dxVFcZRJLneqCmS5T1Ws19RnbwZjEX5YMIUm7fsy8I3qLKpaj/Il wrDEP+TE7/s4eTOeXmOXZWw5FPmZtnHx8KTLwJEs39KC4e834kaPXlSL8ufC8f3Mnb0Qj+LVGDxs QPpw5fjejfTpMZSC1dozfvQQAGLqtuPbkX/S8fOF9OlfhB+//xKvdLNCm4xuXjnP2WtJNHyjOAUc FAQaNGjQoOF/D6osE3v2FtPnnWXHoVvcj32M3s0ZHxeRu9dv8OsfsZx+Uosf3gsDIDUhmUULDtFt 5gWCo/JTMdyTtMRkDh68zO4/75NoNNI0fxoHj9/liQwpdx6zZnsSstlCaEQQMRXCKI/C4WPXmb31 BpGFPAj2c8aSksbR36+yevtlunatwrgu0bi/hO87fvwWp2JTADj0Rywn9CKmNDN1nLxpX1vFTbCa LZ/6/Sz1N8ZjEiX8vQzEJyVwdOYN9t5MZe8X5fB1tQYPQrEwf/bP9Fp6i8AgL6qVzIdkSuXg4Uus 2HCe0ROaMahufsQc0raqisrD09c4maqnTP0ilHbLfOiR7pYmGSRea1AM78kXOfrbbSy9olHNFk4e vcrkTY8pXqlEJoKelJjK5h1nOJjmS8u3ixMEqGkmjv9+lan7kildPsxO0M+duErfb/az7VwaRSN9 CPdz4sG9J4yffoWDV58yZ1R1sovrl/ggjs8nH2D6L3EM7FOdyBD3XHcBQT7ueLsZ+fXgTc5W9MW9 kKvtpFZCzGS26hgVW2Hlkv188sNlDB7uVC/tS4hg5vBf12m/8TwDRr7Ol82DcdGLEB/HlDUXMSES HuxBfm+Bh3cTWLQ8llkbL7N/aSsq5dcBAk+v3mXakr+4+kRl2oUrHLhlxtkgYtS70bV7OVxSkhgz ehujN8XhF+pBmcKeyIkprN9yhjW7LjJ38Xs0MAhIgsrdG3d546P1nLprwd/TgGw2c+THY+w8/oBt cxoT/Ry/WjU1jeOHrzJh3R2Wr3PlydM0PL2dMAoKJ7ecZOfRO3zdvwa96/jnWMbZv24xZfFV/CIC shB0E7v2XmLBNYm6VYKJDrB6Rpvi4ug6/BeW/BaHb34PiuZ35s7NBww7co2nD5Kp2cZAs8oB+LhK mO8/Zs5PJ4lu5ELLSvnxcBIx3X3I96vO4PRLLEMfxmOWdPh7GXiamMDRGTf49ZaJX78oi7ezhJBj ymLr9fNbFnIyBXp37owOMruzKgoPT/7K9O8mcyNOYsKxRRy6HI+L0Yi3bwm6fdkb6f4VRvVqx/gV pykRU5WYksVJeHCdVd9/zZLlK5mzZhvtKgYDcPviEQZ3acfifdcJLhxJWLAfV//8me2r5pBsUqj9 hmon6LGXTjDzu8nU1RfPQtBTOL5/C99NP0KhSrWpVdI6F1796xAzv5tMUlBZO0G/eGQPc76bx8lr V/j2wRl+PXoRUImqa6F+3XqEGe7Rq3MnFm0+TrFyVSkdXZKkOxfY8P0wFq7cwk8r5tK8ShQCaYz9 pB1jFv+MZ1hpqpQthvnJbX7fs4FVyxaRr8Q52sSEk5foAEnxT3j8REDKxEBE3D3dkQSBpxd+47vv vkMu1JzWtYqCqvL4zD6mfzeV63EGJh9fxIFLT3ExGnHzKEq3Uf0wPrrJmF5tGL3sBNHlq1CpVHGS Ht1k3fyxLF62nDnrd9OhjBs3z59g95ELYJH56/edXD2hx8M/jIIVmtJISWDFtOF0HjwV98BClCoZ jZhyn6WThrFi+Sq+mvED3ZqUA70n/r6+3D24mB4bd5Os96H3m9b2eXTlAGO/6MuPf0jMmPc+AW5i jj5UmRRntgCWqmrte5dv3OLho6eElAjG1dX1v74u63LTuvvkDyY0xDv3Y3ZRxNXbj4IhBfF0SQ9u pqdw+WZs2bSCT/t9xg8ThjNHUdE7uVOmfmeGfzWK2sW9rZN9ahqJsoJf/vw8uPAHP5w5bC9aNpvw LRpDsYq1qV6yIE6u7gQXCiWfd8aS7ezmScHQUHw8MoTp4uFDwYKheLnbrrmFM/iLL0gxm1m+fSd/ 7d+B5ORB8479+DDoDvPnrsXNychzdfWiEwWCC2IM8EUn5X63t38wgaGe6MWM+3wCQwhKDkAnPKvs UFWVwjU7ceRIacZPmcG2HfvZsvY4ksGVYiVrMrpfU97q0Mh2v4hvQCghCYFIDooKQZAIiKzH1m1r 6dm7P0umfMVCRUFndCW6aju+GDOW18tazRYe3brM8pnjSClcja++GUukp7UM0dWPZp368tnZU8zf t41Zy+ow+N0aGZ098RpH9//MA48IKr1WwfbuVyethAYNGjRoeFEIiJIIokCqZGD6xOa8XdVKDC4e u0idrjvZtekMd94LIxC4GfuYqUvOUaJWKX6fUQO74WRaKj//dpMUNyPRZQqwfnoD2nTfSqFGZVg/ rFzmV8pm2rapzFvv1cLHOWOdjLt0k49H7WXd7hu0qBpCo2i3/0DzoKIiMmpEI4KdN9H9pziWz2pJ g6KZA7wmKCAKcPVuKgM+qsLAtpH4OgmQ+pQWnTewYdNJjn9SkjquOiTg5O7jdFt0k4961mFWx/CM gszxNGq/mqHjfqNzzeb463M4xVFUzp9PBJ1A5XAv+2bxWR4jYnTxpKK/yh/xTzinQLQg2FwJxIwT woz9JnqdiEFxSP9lcxswOvgvP739kBmLjrHtusjIzxvw+Zuh9jJOHr3IwdsKBoVMwXNFIOVhHEMm 7uf7A48ZPqg2g98Mw4ncLSqrvxZG7e2xzN15itY3H1C/YhCVo/NRNsqXED9n3Jz1eLjprSeGtiKu HDrFJz9cpvablVj4aQlchQyS9E7ntYyfcpiONf2J9jUiuPuza15rigZlDs+1/6d91PjmNJPX3GRZ V6uptiAKoBfZ/ssF6tWLZG3/QhQLdCHhcSoBqsKOVYcZvTmOhq0rsObL8vZ+nfL4MQvWnsNLVG0Z dKyHQJHVSrPy3RIU8tGhJiUy8qsdfLnvIYu332LMG8HP34BLIqgixcsW4uuuZSkf4gIorFt5lE6j D7Ny03kaVfQnMochIEoiepsJ+zNl60SMOhHHn6bM/YOfDsTR7r0qTOleEj+j9cfbv5+m1rBDIDhQ apsSRS+JGV1TFHAyiNyKMzHo49cY0CbSmi44+QlN31/P5o1/cbxHSWoGSc/0Tce5BmD7L4dA8KJJ s2rZdn9BsjKPHet/oFH7j9k8syWFC/iQ9CQen5QkdvwwgvFrrjFh9QH6vZExt8T+tZW6tVvw5ZCv aLtrFpant1k/52sW73vAR8N/YPaX79vvPfHzUlo1eQdVyNBECaKEQTCiz2aPL+l0iMbM5tOiJGEQ DOikjDIkvREPKZWtu36lVfv3WP11a4oEumERnIks4s74T7uy6kAsE5bv4pNWVe3P3fh1Hg3f/JAp 8zdSrngUHmeXM2/jPoo2H8a2BcPxd0uvUwLLp82mSIBnno7GdALMGtSVTe4GBzmryHI+pq3+gTAn CcEWm0pycOMQRGsbbF/7PQ3bfczGaa0oUtCXxMeP8TOlsnv+CEYvP8+YFb8yuG1F+3MPzu2mdvVG DBvwBe32zeONIVPZH+pOxS6L+GLmNvq3K2+/94+ff2TQ0KkUq/sey1cspLjN6vyv3ct4u+17TBw5 grLl1lI5UCS8QkM+nzCVi+06Mn3sV5SIXkS9cBMzJ03ix1/vM2LGPD5oVoG8xy9zjHmQzPK16zh3 N4WhDetSIMjz1SToqqqiNzgx4oc/GGFf5J4lYaqqonfxpOXg2bQcnHHNOth0RFRpxZb/x955x1dR Zn38OzO3lyQ3uekJCYHQW+i9iAgWXFQU7GWxoGtd29o7Yl27rhVRRBAVpCgiVXrvNSSB9F5vnfL+ cVMhCUER3X1z/uHDZO7MM+c85fxOXXcJZfnHOJbnIjw2lqhQe4P7EjoN5LPFqaccqKqqDBh/I+vH 39jg9yOuvJutV97d4NrYKY8xdspjDa6FdhjMW1//wpPZGRSU+mjTvn1tK5Wp/3yl3mFOk4VYCBnC srW7Glw7+d6AwB/7ehOPNVAS4NmFe3m2/rV61uMakG6LS+Hplz/k6Zeb0jc0TBY7r3x3kFcayEao 7eUXnzKO71eNo6Iwk/ScSkKjoogND2nIj7iOTJ+7jekNviXwryOuCy98uYEXGvnOXRs3Me/7Xxgw /FbGjOzV6MbaSq3USq3USv9dpGka2Ezcfdswrh7sqEGIhCdGc2E/G3OOVbG3FKJDQJZlyt0SYYi4 vYGoNoNBQm80MXpEXZskl1tG0QjkTp7wLkHS4wyRKK/wsC+zksNppaTnufC6XeTJIpVuDyVVHuB3 APT6dVhkDdBwe+RGIYPPJzNx0mCevLIDVn11orkpmAlDnSzaf5QdBTLD40AS4f3Z+xAjorh9VDhp WeW1PilRFBnbP5KfZh1jRa7C5HhdE2ohFLj9IAgEWYz1YMuJMCagG1iDRGSfQrEbzkQ23r4jRSxc ncN5F/Tj7mpwXpM33L1vMjUB52lqzXcJVLgreer1dXz4aymP3z+Shy5JxHAKcK5pGkJQKK8+NAhn iJHZG/JYsPQAcxYqKC4fWC0MHtCGu6/uzriUcIKMAQAy47sDlBtDuO2cKApzK8hTNdBAb9Qzsk8E s7YcYmWOj+RQIwajmbahPnLyy0k/VsrBjHJyS734K33oRIH0wtKTOHv5dcOZdVu9FmkJ4HW7+XDu IcwRobz9eACc13yb2eFg6k2DACjM01CQiEtKYObdvepsKVYTEy5K4qkft3KgsLJFcpBllZBEJ7de 1Zs+bczVjhCRccPbceOG43ySWszOgyV06uP43TJXM4+zZHsBQd3b8+DEZMKNdakUkWEWLEZdw0jU JsjnU7jiyv48MTkZsy6gg2IJYcIwJ0sOpbOjQGZotJHmW7VrpB7cheDsQ58YmvB2aoCOa5+Yw4cP jmnwl7L8ND78eBax/W7gmpFZMsBgAAAgAElEQVTxHD2aCggIokSlHMo5Azoye89aNvmgTW4mX85c QIcBl/H0UzX4IfA6ozWUUHO9QmRnbDNVKFcEHnzxA6bfdWlDOaT+zJLVG+kw8jq6J0ZyPCMNv6Kh IRHWuR/t27Rj1dZfKS67Gbnch6YoBFtN5OfmY48JRm8woNfZmfyP++vhi+adZIII6ft2kHdCqrCi RONSaKbShwaIXPXo13z26LgGf6ksyeKDDz8nos9V3DC6bZ0MBBGXN5jRg7vy6cY1rK2C4UYPVW4f aBpeT1UdL8qz2PXLN2Rb2nDXrXfRNaxuzfUYdi4P3XcN1z6/jMU/LmPgjecB0G/sRKa/eJgrpz7L ay8+w64udt6duYzrHnqVO2+4oIF8WwbOA6kfC958lI/n/EyXSx7ginP7Yhf5a7ZZExpJmhJach8n h74LgkBwRBu6R3DCZDq9jxZF8bTefeK1mrE4YxJwxjQmIJqthNjS9zVa2K6x5zZW8bQFPGlONid+ q90ZR3dny/heF1p3sgei5qJcfIT5sz9jW0UCr14xibbmP38Ct1IrtVIrtdIZ0yzx+pQGEFEUIMRq RVNl1GpsGx4WzGUjHLy96QADbyzhsuGx9OnkpGuSg+hQEyE2fdPei5ozQ5XZsimNZ9/fxpLdpejM BqwmCb0EZaVuDAk21LN8tPj9Kh6filUv1Z57DqsVURRR5Bo1torNqQpaVS79rphzEv8MRj1Opxm/ q/lUuGCTBGi4fHKjSmVNgLCmqbhdGpJBwm4Ezfv7ZVxQUkG628bo+DCC6sukEZJ0IpUFJTz+6jHe WJrHIw+ewyOXJCJx6vO/xnEQFB3OtKfG8q/icjbuLmBfRin7DxeyaX8xOzamMmlVGq++fhG3jYzG InnZka6glZRwwS3fNyxShobBoMMWbET1BuThq6rkg0+38OLXR8j3C1jNOgw6EQkVvwpKI8OLCrM2 4DFoKN5ytmaCrV8c7aXmeQKBKAgV6kVeiohmC0ZNqzdXTqXQgVpd2K++AmYKM9AmwUb5zhJyK85M Luy+9EpySzz0GRlJsN3UQO9TVQ3tNAoyBtaJgllXf53YEAURVVZb8ASZ0owSzHGJhDRqnqrTbyOi Ik6QlYq3KoftqQp5GZ+TED2zwcgFQUCnN9KuWwr+Cqgsz2J3HvQYN5ioE+a6pqlof8g2qqJhx241 naRH791/nEq3xuY5LzHm+39THx5rmoDZKGHr2x/V56Pt4OEMTOnF7M8f5dqjKxk9fCj9BvSnR6dk oqKicNjNtUUbm0sz9Svw0dYsLov/LUWdBSKjw0+Sgd+dzdZDMvm6r0iMmd2Qj4KA3mAkoUMXfOVA E7Wqyspc7NmTTmh4BJ06p9TtGYCgDye6fQoG19ccOZhZj49mLr7mVp5LPcI/X3mDJcAFNz7K4/dN wUoLMUkDZ6zKL58/x70vfITSbjzvPncnXduEnrEW32ccoJ8papRJgvCnZCu3GEz/D9AZ5Xv171Rv CbM++YCXP1nKJXdP57qJA2kc0bdSK7VSK7XS/xKJYrUaWb3dO6NDeOKRczF8sIXvNhfwn9mFlFf4 UCUdl03oyQtTU0h2SE2eKQB7t6fzzxdWs8Fl4x+3DeHqUXF0TgjGqvfy4iureGpF1R9hfzhthVyU Ap9dFxmq4FI09HHRLHiwB2ad2MgzBTrFN61eiYJA+zgbyBp7M0uBhOqK9UJDIwYaXpeL/Xkalk42 2utA8Wi/mwmyrIIuEK7cQPE+IbIPwGLU+OKHA9j1CvbQEEySgF8DqTocumlo0NABomkaQaFBjBkR RJ0/VOXz99dwz6f7eW9+Kn/rGUY7p4rLr6KERzDz/p60CTWe1AZXVaFDBwsGEd57ewV3fZVNv2Ed mH5ZMsO7hRHnNCO6s3GMWNjoyNTq5wn154Ws4AXsllPzpM6EQoPnCBJIv6skT/WPRSEQRq0JnJZz t5l3ByrdaxhNYoMw5jO5RzQoVtQsqciKit6oRwWkZrGuegKE19BUFy6g7ahrmfvCrVS5PCfxwWgN ortDJdXjxoOIwaJrEZ84Uaq/SZ51c/5EPdmr+KisLGXolfdw9/WXEmPVkOvPb01FZ4ugfXQwWCJ5 54M3SXrlVeYt3cin72zgrRfL8asWJkx9hNeevJO2kUEtcpK5KsqQtdBmiw42Ka2TZAAobtxA/LCr +Hb6VFzuky2HBpOVzmGA0vgkVlQVl9eL3mDDUr+nWQA9ozMYMSLj8/ga/tAWy6CRY0j54iu2udrT f/BA2rSwWEmDFneqlyWfPM8dj/4bf9y5fPX5mwztEl+veNyfSzpaqZVaQLvXLeOLmd8y4Io7eOC+ Owim1XveSq3USq30/5MEwqKdvPzUOF5G5ciBAjbtzWXe0kN8M28Xks3K7Ls6B4CtBpp6soK+62Ah aw6p3PWvPrx+ffv6ahteWf1j6o6q2ul7zE78gWAiyS6yt9hP+26xJNmkZpXBRqPvRIHY3rFESVvZ vPY4x709iTc20rNZljmw+SjpGBjdOw474NNqPOsBBbc+hhCFljgdROwWExbFR36Buxo/CLVg+sSf y34/0e3bcMeYSHauO8TTb21EECUenNAGQ007qEYBbGAsHq8cKAh3Qi/1wHtFrvtbIq8tTudAuRuf rAAmEoIkyPbRpkMkQ9o0V6ypis9/zANnNAtfH0VEfY3Wq5wWnhKNFuIskJFVgQuwtCCy8mR585s8 soJwArAr9ZGb7cJuMxATZGoWBgqqilqL4mtmglBrPKmhUIsei1GioNhTHSVTL2daFM4yHJEwWQ24 y6uqx3g6KFhEZ3HSRg8lJQo9+vZH38zdelMQYaiUZmafBJZFUTzJ+RzYsxQ0WT6Bp9WtB3+nfSza 6cBuMeHyGOjWsx+doppvBB7abiDPvzeX5/GRumcX27dsZuaHb/L9e48R32MQz904iiCjcNb3f9Hi JMEEWUU+uvcbQLNf0UTUj9GgJzLMQdW+cvKzSyDBUW//81FVWkAVZkJCgxrIrvDwOj754ENSXRHE mUqZ8e6/6dK5M5cPadegC0ajC7SmdZ23jDlvPMpD0z/B0vMKvvrgJQYkRwTkXbvmtT+1xtaf3Ia9 lf7ypGlomkbPUZezdGcqP3/1Bn3jTK3gvJVaqZVa6a+/gdfLrxROWdy0pc/0ev1k5bvwq4Ecxfad Irnqsp68cHtfEmQPOZllQKBQlUGnUVHloai+joSC36+AxYDB1BDg+kpcFJX7zvj5YjRKSJqfnDIf /urvkFsUjnsiGbhgpBOxJJdnvkkjp9RXW0xNUxXKyt0c2F9Auao1Uc8moGgaQyK4e6yTyuwsHvz4 EOVuuRYsB4wJCvsP5vL0J/sJjg1m6vh2tWAqyKzH7/WTmVdaB+s0lfwiF0UVyikVysS4YIYkwZad x/kx1V2n+6oqxUUVZORW4iOQ3uD26rhkRCL/ur4306b2Z2yEl2ff3chbS7KQqeun3hRu2bA2nVXb csgp9eJX6vpS13zn/sNlFFX46RkbjNUoAQJjhjix+Yt4+bs0Dud76orVaSoVlR4O7i+kxK+B5qdS FTA5zaj1agsofpnj2ZVNOe4aMcAISEYrFw8Kovz4cT5cWxIwElXf4Kr0cCyzhPwzVAOgPhhUFBWX 219vPCqrd+SyZHshXZOddG3fdP65yaDDrHjILXUF5nQ1gPQUVlFS6W8ARpPahZAQYWHbruPsTy8J dGpSVTw+mdTcKlw+5SxCdB3O5Ch8WQfIk08Dm1cDLJMljvPHJpK763temL0Zdz0Pq+zzUJCdyeG9 e/EBIaHxDOxmJGPXz/ywpxBVUZD9PqrKi0hLPUKxK2DYqgX0eiNW/JQUHsdVDxR6i/LILyhG+517 aGzPnvToksy2RbNY9PMyyuvNW9nnoSg3k0OpR3F7fbjKS8gvLK5eNwbadevLxBum8tFTdxFlEziy 59DJ3uWzgAlAwGiM4YJx7Snau4Bnv9jQwIMu+z0U5mRxeM/uah42/ii7I5jeA3pRmZ/BujU/Ntj/ fHlH2LL6F4TIOFL6dKr9jb8knXdfnc7MVZk89/GXzP5sGr4Dv/Dis8+x9VhF7bpqNPKk2oDpKcnk 9Qdv5e5nPyZp3F3Mn/V2NThvbLDan3Z6t3rQW+kUJ0jL6w+0Uiu1Uiu10l9qAw/o7KpGTnYJWUWl eDQNv9vDkawyDGYjbUJNdXqIqjWq2GiahqpS6+06cPA4U6fvY+qtvRjQ1o5eEtF8HpZtOk6Bxcq4 ToHiJ45QK106BfHtrkxen5PKpd2slFUqtGvvpF28g0TJxc8rjrKwYxCdQyXyckuZs2AfM37ORmwT U6cbaRqqqtEw0llDrb5+agQm0KlzOFGO47w7ez+RepUYvUwVZgb3CkcQqp+lNf5rpTrfuIamXNuX 2ZsrmPHv5bhzenH1yDhiQyRyc8pYti6DTxfmsnnVNQQZGzs7A+PR6yTumDqE+XuWMvs/K1GqKvnn xYk4TCKqopKemsO0tzaxutLMLdf14rIugSrlkllH225hCFVHmL1wD2M6mwkVZI4cyeOjb/by4y43 nQY2/IBAO9o6Y01yh3Cun9iVG9/cx/3Pr6To+u50jzGRm1XMrHl7KHNG8vyjQ9ALoGoaPllBAdr2 SmLavQoVL/zKk29vwGQYxC3nxKCv9lo1Zhk4tO0wD3+bRa8h7blhXFu6t7FjMYiARsahHB5/dzsF fiNPX9SeiOBAw6hJl/fimy1lfPPxWrwFZdw4JoGkSAPFBeWs3HiMd74+zk8LJzEwMpiRyVb2bM7g nR+Pc3lKCDpU9u06xmsz91Ahqw1lWj3HG1yrJ49bbujDzB1reejxJXju6M+53ULwVblZteYo89Zk cf8bV3GBMRAir6iNz7WT52nTJEoiVfnlzF9yALscR5RN4sjBLN6bu5/9cjCvjE2ia3AdLlJPWJ8J SUG0j4PvfzlK76QghiWaSU/L58vv9/HD5gKEjol1ayg8kr8NjGHNf/by+AfbyfpbOxJtsGNvNnOX HuVwjpsEqWERhMC3aA2vaSdca7BHtCSXPcDvXj36w/cLWHmgnKu7BZ2c8qsFQm8avKv671ZbEFMf eo5v1t7Ks1MuovjAE0w4ry82nULq3i3M+/o7DucaWLXjJyKj47n677fx/b1vcPf1k8m6awrBYgWb Vv7IgoU/k+E30LEe5g6PjadbDxurVs7n7S+GM3FQPDlp+/nuy0/4bNZixKiUBphN0zRUTW1QaE6r rvJ/Ip80DQRbJ2685ir27H2CR+69iyP7p3LZBcMINmqk7dnK3JkfUBQ9lo/+/QzpSz7kg+VHueDi S+nbpS0Wkx5RUFmwaBkVspFefbtjNDXfZE2rF2VzauB9ArDVNOCENtbVMjBZrEx9+Hnm/DqFF26+ iNJDT3DJ2AEE61WO7t/Gd3O/ZWeqwtr9K2sLLgbacdfjhSmMHudO4pz4z5j9zst069yGC3vEInvK +XHep7w2cxWjJ93P+NGBKv2ar5Qv3n2VVz7+iaseeYO/TzwXs1LCc49s5abHP+DpaYm8+/JjxNkk hCbz8lXeefphHnzzazqMvJLbJo+hImM3qw/VGckUWSGhS0/iI0PR/4lQ538QoJ9Q+I364VQnXPtN edlNPP8s5tY37b3+88IxGuPB7/WyNxemov0X1A9obPxnI/Lgz3rvn7feW9v8/e+Jtek1/qfM5SbH c/J58BdjI4IAqqrw2rQlfHFIQYyyYS/P4ZxbF3PO5X347PoOiJKAyWokwmnBbm7o0dbpRIKDzESH KVgkABGLUU9VbgG3/usnrFYTSZFGKio8ZJWqjBvfhYcmBULWYxLDmDKxFzvf3MYbb65kmlehU7c4 pv9zGBcNTuC+6zrx5OxULr31KGa9iIpIz25OUnpEko0Ri7G69Y9eR6jDTKTBiFEv1l4Lc5hRQowY m02sDPxt5JguXL2thK/WZHDNfal4fSoTruhPr65OgowGosKshNl06E7Iz7VYDMSEWwkyitQ4z3RR 0Xz30nDu/vc2Vq06wMKFu5FVDZ1OwhFsovewJJyG5ttMIQjY46KZ//pobpu2kZWLd/L9t9uICDbi LfdQWOzD2T6Cf93SmxeuqdfKTdST3DOZh85L5+31xxg66SgWk4RkNtMtOZTzBqlU2U1UF0RH1InY 7CZiwrRqDzVgtHDFZSn4FZg+7yhTH/0Jj6yh10sEB5u5pl8oCTqoMumJDLfisOprA6J7DEzm1QcU 7n1tE29/vYekaCvndwlucg306BXHkANVbNqewc2rDqFJIqE2PV63H7cq4IwM5sUnBnPNgFAMNUDJ 4WTGM0OJfnsbi7cf5e8rD+CTNSSdRLDdQKcBCURZA73NH7m7L9uf38LL05fyukmPXlXRzCYuHh5D VmU2EXZ9rYdUbzYQGW4hxCKdJA9BFGnTsyPfPePnrnf28PJba3jCoyBIIkF2Iz27RdMrFASPhNNp IcpxYmteAaNBT3SEhTDbqVVrURQC45JlNm9O49c1B6jwKOj0OmJjQ3n53hT+MSa29n6zRU9UuIUQ a11Ad7/+iVxzYSHTvj7M3/95HBEBvVHHsAHR9OwSQaHdgNlQN8qbbuhNnkvho6XHuP+FY6gI2EJs TO4TSU6pD00Qkaonuc6oI9JpwWnX164JnVFPlNNCmE1/8jqxGokJt2I3SrXrpPG9OvD/8847D9Mz 3zBnxkKufvmqhjUYBNCZ7YRGRGI36xv8NtABwkDSkKtY8LWfex55iS/ffIT3nnehIWA0WQiNasOY S27CCgiWUMZedx/TDqby6py13HvL9SDpSeran+Hjr8X6/X/w1cuGSOqcwg233sOWh1/m4evO5SHJ gEGU6NG/L72HD+NgoYTFWDcmo9lGeEQkdktdKoLRGkREeAQ2s/Ek45ymCQyedA+vGq08/+p7zH3v GT55xY2igslsxRri5NoLe+IIMuOKiCR750fcNONDnLEJxMc4qcjLIKdMpt/lD3P7hF7YjUKzBc2s QWGEO5yYdWKzGEUyWXGGh2O31gF+yWwnLLwJGYh64gdcwQ9zfNz18It8/fbjfDjNhUog9zwsMo6R F11PIDVcxGC2ExYZgdWkr3kKIJDYuS8vv/MmU25/iAcmj+WlmDgkfxnZeWX0u/AW/vXYw7SpZu22 lQv5ZMZs+l1+Ow/ceTNmAMnB5TfdzoEjh3j7u2/4ot8AHr5pXDP1sSqp9EOY2Ur+jkXcNHEestrQ 2ibLMv/8ZBH/uv4Cwv7Eo12YOPU17VhVGBtnXNdC5eePUUjONMDzuH1UuBQs1kBlWAC3y0eFW8Fm M9Qe/L8V4FRWeKjyQ2iwEb0knCVl6+Rx+X2BNjYNemE20y7udI0PpwWGVZUKlx+PAkFWPUbdbwkF OnEMGn6fgqwFerkaTnjmXx14apqG3+OnxK1gsxqxGs9OVommqFS6fHhVgSCrAYPuj+TR75w3p4s2 ND/5+cXIaqDCq+6/BJz/1Q0np2NobKgPnFkjSYMiLmiUlxTj9smIkg6LLaj2gP9zeKLh8/hQBQGT 0dDEmP842rJlC+3atavtalJVVVU7h5575wcOeHuhZS7iyssu4JbLB9aO7VhOBRvWpnK4XKsL5xQE YpKcjO3qQParFKQX8OPBClJ6xtErzhQozCUI+L1+9uzJ5mCpxvAhbYkzaWiaSnF+CQt/zWJPehnF VQqhYTYG9onj/MExBKHiVQLj0ksaWceLWb29EJcgkRAfQkpyKGF2PZ7yKlatS2Px1kIUnZ6ePeK4 dEg4eceL2XjMx+BekXSMtOArq2TNzjxKJDODu4UTFazDX1rJiu15uE02BncNw2mVGvXs1XiPBFHC JPj4dVM2B3PdCEY9KV0iSY6xQlEZ87fmExoXzuAOQbWAXxBFjh3JZfX+UnoOSKJzmA6pOg1V0knY DLB9VxbbUytxyRpWm5GUbtH0SrBQUelvUXCkpJPQ42fp8qOsO1DM8XwXBTmlbMz2c8uUEbx5TTz5 pd5a8KJqGjpRwO1yMXfhQTalVqCzmhk5KJFxKWFs3ZxGtt/IqCHxhEkaisfHwUP5bM9XGNAzmg7h BvyqhiiKmPQCBTmlrN1ZQE6lTJDDQv/ukXSIsuD3KxzLKGL9rgJi20XSv4sDQVbRELAZVLbszOPX XYUkdo5mQBcnIfqTPceaBkazAc3tYv32HDYfKCQ9t4qyKhmT3Uz7xDAuOactSU4DPn/AW1qTOy1J EnaTwN79OWw5VE65V8FkNtK9SyR9k+x43DKypqE36sk/kslnS4+Rlu8hNDKYc4clMbajjk8WHsce F8YFPUIRgMqsIr7dUUynrrH0b2tp1K2oN+jA62HNpiwOF/iQjBIdk8MZ1jUMv9tPhcvHmtVHKbcE c+moGAS/WrOcKC4uZ/HafKI7hDOuiwNfEykUgiSiFJXx0acbeWu/yrNT+9NBX8mWNBd2h5WBPSJp H2nG5fajVhvJjqcVsnZXEQkdIxnQKQRNVhF1EnJlFcvWpfPT1gJkSU//folcMdjJvr157CnRGNkr kjYOA7KqIUoSdr3K5h05bE8rR5b0DBucSFxBJuc/uY6owb2Zfk074kJ0eAtK+WFLPkHRTgZ3DMZi lPDll/D91gLC20QwuIMdg1S3TjIO57D6QBkpA5PoGKqjTYS1Qd2Bk9ajWsplnRKZ7+7Oob3LSQrS 1+5lmqpSlrqd+RsO0H3Q+fRuH9rMuamwY8Mq9h3ORBEkwqIT6TdgEOE28QRdWOPwllVs2JOOPTKR 4eeMxH1oORcPG4199AOsnPdSzcjQ/C62rFnCvCWrqZRFevQ7l4njR+LO2ccv27PpN3gwneMDlc2z Du1k7YbdJPUZTN+uSQBk7NnE+m2pdBk0jB7Jcc2cb252bdrEviOZePwqETFtGTRsCA5THd/yj+5i +ao17Nh7kKJSF46INvQeNo7Lz+8fMJqdQtfavf4Hth8qZujfJpMYbGwyRaMyYxffrtpJp37n0r9z NJqmUX50O/PX7aPLwHH0TXY2IwOVXRtXsfdwJjIioZFt6DtgMJFBUnXoh5/coztYuimdXgNG0KN9 5EnPKM05wJzZ89h9OAvNGETfoaO46PyxOGuWqaeUHVvWs/5oFUOHDqFHUnQD52texn7W/PILutie DBpU/e5Gyce2tWvZczAd9LpGiz/6fT66jxhHj3Zx/JHp/bt37yYuLq72PPf7/fh8gZSFtLS0kwF6 DdN85VVsSa9EkkTE6lYQoijSuXM49j8KYygKJaVuClwqUeFWgkzSb37U5jWH+OinbM7/W1cm9Ass pLXL9vPpinwun9ydsd1Dm1fMfH7S86qQzEaiHaaTQPi3Mzcw75DGU/ekkBxmOqvKvSbLpGdXkJVb waFjZQFDQZiVDgkhxEVYiXYYf5chpbLCw6GjpZhCLHRMCKLFUqiqZNbCA6zNl7hlQid6xpt/83cq Pj/Z+VUcOV5KWmYFZT4Vm91M29ggokJNhIcGLLuS+NdGZ5pf5sD6wzy/opBJl/ZifHf7WXmvWlrO lz8cYEuliZsndKRbtPEPf2d6WjG55TLJyaGEWnRnPKKkZm4c+XUuT70zn4SU0Tz4zxsJlvivIdlV Tnp6GmWygaS2iTjs5r/WAH3FbNt9FFlWGgc7mkZYXHuS40M4sHUbZbKB7n1TsEhnUs5UF3GpZMe6 FXz//SIOZBZgDo9j7KQbuWZUr7PMFIXi/Hxyc3M4npFOWkYOPkFPm7btaN+hA+0TYjDppbNibPkt AF1WVN6avQezSc+J6ZOKrAZAhCAgSiJGnYDfryArNRaYmvBfEUkU8PnkAAgThFqDqSQJtTqCLKu1 QKv+7yVJRK8TqnNuA/epmoYgihj0dYZXWVbw+jVESUAvgs+vBgwFooBBJyGi4ZPVQFi7GPidgIa/ wTubn1gGvVhdIRv8shrwnggiJr2Iqqr45XpBulrAa2vQCbWG4hNJpxPRidWpBFqgt7Wsnl7eogDo DRJ6SUQSNAozc3jggwNEdIjmnvFJWHSBYmuqoMNmEmtBh8kooRMDL/ZXy1JXwye/UisrnU5syM96 shHFgHwDj9GQZS3AEy0Qgm3Qiyiyir96ntSfEzqdgOJX8SsB4N4U3wUxEEKuk4Rqz3F1kTtFxedX aK4UgE4S0Ul1/FUUFVk5WUYmQ6CIl6YFvt0ng9kYSBfwVgtOEAVMehFZVvA3U0NOEECvq/YE14xT UaHaEGkwBEJoPT6lbs5pAa+40RDgl1dWm21rq1a6WLk6lR+PK1x5YSeGtrfWpiH4ZRVFqTefNa1x WTS5hlQkSURXT+aCIOD1+Cj3qNhsRkJsenRoVFV5+fGXgyzeWcbll/dgUFs7Ok1FO3FNaBpIIibd qdeJx6/yj0ldMeilZtfiuhkPc84N05n4/DxmPHIpUhN6a1PG7eaMonXG1aZ14X3rFnHthRdhP6cG oLfcaN5kZC4ti7Bt/j01qQzCKba05o3qJ7+jZfxtqTOhJe+vWVBNOV9/zzOak2+j/D1tx9EfGyF3 KoCua2rx5O86zMgHtiJ7fFClQLCZ6Egb330zmQF/lE7pcjP/6828stnN8/cN5W/dg347WDicx+ff HSCyV5tagH5kfzaffpdKl2FJpwToanYudzy9gaAeHXn1xs7EhjT02mxfn8qs1RpTb+5Octgfjs5r J4jf5eanXw7x/Ke72HDURZDDiEEUcLn9eFWRv43vxiPXdqVPG2tg4nL6xXD37Mxg7OSFJF/cm1/e HUVwS3/o9bBhUzpfpOo5f0TSaQP0mgWl+r0s++Ugz364k42ZHiwWAwYJvF6ZigofQeF2LrsihRcm dyAq6Ox5036rJzv7cA5fLkij84AujO9+ll7s8rBufTrfFFm5YFS7swLQX3z6Jz5YWsSXi6/mil6O M5o/UzM3KnP3cNt1N/BreSKz7p9OsPSXaFfZYipP3cRDN17H4sIEZs34hEtGdP5rDTB3KX36Xtns LZMf+4yvnr2Qm4cN5KOTauMAACAASURBVFd3KLsri+hmPXNDEARA8bJ92ddccukUCm2xJMc4ELIK cKaMOvsAXc7lk1cf49k3ZlKhiATZbIian5KySqK6jWTaKy8yaXR/zDrhLzcXNU1DJ4nce3UPWum/ hzzlUSxdnM6KnEoqJAPdYvRk55WT2K0dY7taWxn0v0CVFQhZufxc5OeisV24tNsfb6zN2n+cD5Zl IotmYqPs2HQqh/eVkZrpIrZjIo9d35Me0WduHE2C0OquAYOvf5irPp7Lp0/fycUje3L54HbVoc8n GzRacq3xvzcHyDQUhQZt/FoKxlo6puaMNM2Z7FoyjJbzoPnnnnjf7/220/n23/+Mln1TYyC/JaZT 4S+Xgy4IhHdvz/zpDpYu2sEbKwv5+/XDuX6gnU6G37A4WxpyramUl7lIzXHh8minYW06+R5JkjAZ dejreVglnYjZpAtYnE/xDMHv51huBY5oL5p28v06vQ5MarMVPU/HStRcmGhNPz5N9rP4u21MeH4r ER1iuP/OXpzTLRSHSeB4ZimLlh7m6++2sX53EQveOJe+kfqT0EttIZdGrI81f4qOdXDHlN6Ed42v bZ3QohBOQUCvlzAZJCTh9Cx29RfUyiU7ufGVnfgcYTx4ewoju4ZilaCkxMWu/bksXpfJir0FlLja 1gL0llnhAtb/ls0jGsqjEc27pSHBkiSCUUIn/TYr6OlY8Wr5Wl8WYvP3niSLeuu1ZesuwJrRYztA Gzedwqtz81qIVlpksRYE0Lx88dx9/JIu8szsz7m0T2yDCtUnDei0Lb01XpqWybU5K3NjlmsQMDnb MP7qW2hXFUq7+LCWbqSn3D+bfu9pziXRQLDNiK7dIB68+kIMet0J71HpOLA/YOKKO/9BD1cIYYa6 7/s9Mqj/nZUlBXz78evkByXz8YLlXDsoECZYVulqEa8aO6Dr86hpa3wjVFVAZnElPc65nEsuHkv3 DonoFRe/Lvmad977nDvufob42W8zulfbv5yhqLWY538Z1Xj5rUG8+uggbnl9O+//Zx2v+zWc4UE8 fE9CK0D/HyHVr2Gymohz6tChnpV3+jx+du3JZsX+/chKoPCh2WwgMSmaV+/qT5dqcH6mDI2nOosg hJfee5Md42/h2Uefo8+892kXajxrMtAbzETGRmFzBrdOyFb6y5GuKUXPFGLnghF28ncdBqGIrt3j GdbHXKuIqapKcZELv6QnOtRIWUkVeWVefDLY7SZiIyzoapShevmERYVVFJT78MoaRoOOILuRsGAj Rh2UlXkoditIaBSVuCguNVDlVbGY9YQFGVBkhfJKLyUVftw+GUUN5F6HBJuJCDYiib/fgyEIAoqi klvqRUFA9vnJyq9EUvT4ZQgPM2PW1yEevV7C6/WRU+CiyqOgM+iJi7Zj1Qt1ymC9jaqkpIqCUi9u n4reqCM0xEJUiKGaR435u+uUyvyMXKa+voOQtrG8/+L5XNLJUnvXwJ4xXH5Be7pOW8aDc49x31u7 WPVcHwRBQJYViordYDAQGWKoAzxoeD1+Csr9WG1GHJbAdIhv4+Sxh4YiSCKmE5RX2S+TW1BFmUtG RcBqNRDhMGEz6ZrRNwS8Hj9FpR4Eo55Qe3NFfSr5ePExciqNfPnaCK7q2xDEXDi6Pf+6qZK520tw Vo+3PigpL3OTX+KhyqsECguFmIkJNdYaihAEvG4vheU+qtwyHr+CIIhYzHqcYRaCTVK9nrAaxUUu XKpIXLgZUCkqduOWacAv0MgvqKKkwodX0TCZ9DiCjIQHGxtY4gL5WArHMiup8MhIBj0RoRZCbbom K+DWt+L5vDLFZR6MFiMOq0RufhXFlX40UcQZaiEi2NDsgajKCiXlXmRRwmE31OWPVYe+lVT4MVoM BFUXBKrlq6KQV+SisDxQRCY42IRNBy6fRmiIqbYIzYTLejJOBqtJCgB0QaC81EW5D2IjLHhdXnKK 3VR5FPRGPfFRdiz11klz4V4CAqVHVvHc+z/Tadx9PHpFnwaRJZqmUpybjUcwExsVBppMYX4BXlnD GhJGiLVGFip5WccpLi3HJ2uYbEFEhEfiCDJXtxSkXiqJl6zMTMoqXGiSAYcjBJtZT5XbT7AjFKtJ jyr7qSgrwSWLOELDMOnreOr3uiktKQaDFYcjBJ0Alqj2XHnbg8iaiMlkrH1PSUkJPsFEuDMESfFR VFSMy6sQEhaKzWIO7Aqqn4K8XAqLS/EqGmazjaiYOIKthhN4KFOUm0dhcSkeWcFgsmC3BxMRHhYI CRa0U9hJFUK7DebBB+5v9r5bnpyGT9Vh1wfmqKZplORl4dbMxEaHAQqFefl4ZbVaBqa69ZJ9nKKS MnyyiskaRHh4FKHB5kDUj6qQcfQQWw4cJjZqDEN6OsnJzEQyWogID619RllhLrkFJXh8CiarnYjI SBx2c23xGa+7kuKiQgRjEA6HA6OuPjhXqSovJb/URUiIA0dQ06BHM8Ry//MfEBERSn379MgxY/EU ZvP8zMXsOpLO8F5t0bfqFK30+xANWnU4c/dBnVjdLY6lm/OokCEkxEzvrq1A4n9G1BYzI8Z2Jay/ Sq9Ywx/+Pg1om5LI+086OJBeTkGljAJERgcztLuzeu86e0Uva97h7HohX83+iK2HCkjPyKFdaOJZ k0FEYmfue+419JGdWydkK/31AXr9hSn7ldq+lbKs1IIFALfLy0fvreWgMZxbx4Uzb/5+ftldTKlL JblLDDdP7MolA8JrPal+n5+tmzOYuegImzMq8MoqBqOR+PhQJo5L5qJeIcxfepgvNxXjqdD4bPZW Vi7VU+UVGD08ifsvb09hThEfz9vNoh1lVLh8yAqYTAY6dohk0oUdGNPLifUMVIzKPpjFS/NSOV4q U7DvOE+8XYbVIFLp1fHCwwPpG2cNcEHQSD2cz4aD2cxfl01ajgt7RAiTxnfl5gsTCTOL1W0pBdAU du/K4pP5B9mRVkmpy4/eaKBj5xhuvrQTwzoG0URDswCsUFR+mr+THM3IDVf05ZJOlhMiFAQEwcDU 2wexcHUW2zYcYnlub0ZHCZSWlDP99S3QMYnXbqhXDRaF1EOZPDX7GOeN78KUQYE+gJkZhbz5yQ6C uyXx+OT2tQU2yooq+GF5KnNXHiM9z4MmCISF2xkxpC3XXNCe9lLjITCyx8N3P+xj8c5ShozswOVD YzE2Ff9cVUmxV4ZwO5F2HY0akCw2Lh9iq/1/dQNXDh/MZcb8g2w8WEZRpQ9Rr6Nt+yhuuqQT53Z3 1EZTbPh1H28tyiKj0E2VR0YSJIJDLIwYksQN49uRHGqo/eavPlnPalcIL9+ezO5tWSxcn01ulcao cd25a3QUitfL2s3HmLHoCDuOVuBTNCx2Mz26RnHVhC6MSjDWoB5ys4qZOy+djxelkVrgxmC3c+GY ZO6Y2IEEu+6UxqXsjELenrELY1IMgxIlvvrhCFvSylElA0OGtOXWSzoyMMnepIfSXVDKZ/P2kWsJ 57YJHWgXWnfn0UNZvPftETqP6srVI2IIqjYMeavcrFqbxuc/HWVHWgWaTke7dpG0C1E5ViLy0G0p 9E8M5NUvnLuVWbt8PHVfH7pGBoxHS+Zt59sjGrdObMuurRn8sD6b9Fw3QZEOJl/clSkXJBBqEk+R ZxUwUMx/5zWyFCufPv4gInWRJQCK38Pnz93LVq0vLz4+kS3LlrJ46UqKvCJjr7+fWy7sg+wqZvXP i/h85tcczsrD5fFjdUTQf/h4ptx0JV3aOKurkWi4SnL48fs5fD7rGw4cK0JvDaZzp84kxtgpdhu5 eso9jEqJxV+Wy6IZ77Iyy8ptdz1E74Q6iJaXvosP33kLscN5TL3jOiIAtSiNmf95n+1VUdx+yxS6 JgSjFRzli/feJ13XkUvPH0rJobUsWbaGI9k+pjzwABPPHYBcVcSvSxcwa94P7Dt0DJeiYLQ4GDHu Mq67ZhKd2jiRBAH8VWxasZBPP5/DrsPHqPT50RmsxCV0YPLfb2fCqBTMhlMnH2iKgldWmyn0qPLx 47eyqrgdH336DHZAVf188fx9rPel8NJTk9i+4mcW/biCArfGudfez+0X90PxlPLrssXM+PwrDmbm 4XL7sISE03fIhdw85Wq6JYZTnJvKu08+yvZjMh7jbu67/lpUj0y7LgN5dvpD2GQvu9cvY+YXX7Bi 416qvGB3RjF0zEXceO0VdGsbFTDWFRzj6w/fYnOOgck33cb4wZ1r50tV7iE+/uA/bMw1c+ttUxje s20Tc08Dczhx5oYG7MBalWgTHowBqPLIyNAK0FvpjACXmnmmt9u48Bxbo06UVvrvJU3TEIx6OnaL oePZkqumoQkiUTEOomIcjf/9LIf01nxzx/7n07H/2ZzfAUNEsDOGsZddWbfX09oRppX+wgC9peT3 yiz/+QA/V2WzbZMRl2QkKTKIELeHzb8eZOOBYqI+vJihUTrQFPZtT+OGR1aSZ3dw0YAo4mwix7LK 2LT9OBVulT49B+P3ybh8KpoKLpefMp1GlVfA5Q0YB4pLXRzMKEE1mOmVGEaQSaCkqIpfV+znl52F vPHoMK7sE/q7maIqKhVuBVnVkP0KFZU+ZJ1Ahbd+8RcBs+DhyVfW4JcMxIVb6djOyOFD+TzyxDKs UZdw6yAnRikAIvZuPMQlj60Dh4MRKZHEhxnIyyzmx593smBzAWveP4/u4bpGihoEMLqiKizdlI3e ZOLK8xNqre21/1ZvLnqDhStHR7P620JWbMhj9IQoqirdzF90EMqCTwDoKnm5RcxddISg7vG1AL20 qJIFiw8SKQfz+ORAu5yKojJee2cd0+YfJ6lLNP17RGFWFQ4dLeTNb/YiBNt4cszJBdBUv5fZX23m kc8PEtmnM3d2DCXU1IzH1BpMB6eFHzfm8c3K4zgMEBNkIMhuwGKQGinIEeBv2u50rnr8V/I0M8N7 RzE4ykRJXhlLf93PhE35/PTWGIYlWZEEOJyaT2aZTFSUg7gwY6DoXkYJ019dwbocmcUPdcckBEwj a1ccYk5hCFZfDgvXFhEUasYkCbTJdgEqyxbv4ornNmOKC2dwVydxNonjWWUsX3OYzRUiO55OCYzZ 5WPet9uY6/UTFxtMp0QTaceKefmddRxzS8y+vWMTERR1VFJYyZIf97FPn02XGCMGu5V2CQ5KCyv4 /Ist7DpWxWePD6GHs/Fl7St3sWLNUY444PLzkmlXb6nk55Yw76dDnBMfx2UjYggKxEswb+4W7vzw AFJIEEO7hROkh+N5RcxYlU9JgZ6rJnWpBei7t2bwzVI3t97cg66BIp3s2JjGnI1utu9JR9YbiA+3 0rGdiUMH83n48Rzs0ZcypX9orTe/CacSqKXMnv8z1vYXctmgyAbecwBF8bN63jd8X7oLffEvLPxp M8ERkVjNZjocywd8/DjzNa67dzrxvc5hxJBzcZg1Du9Yx8zXHmTltiP8OPcNIozgrSxk9ptPcMtT HxPXbQB9e/fDJvlJP7Kdpd/sRHV2ZsD5NzEqJRa5qpRtKxcxZ18I46+9vwFALys4xo/fzUIcHMq1 1QCdyiLWL/uBRcXtufSKawIAvTyPtcsW8lPGL2xc/AXZ2elgtOGvEMgtLEMDvvvgGR56dTbm6O6M Hn4uTpvAoV0beP2xf7DtaCEfTLuPpAg7u3/+lCuvexhXSDvGjB5GdIiRY4cPsHvLEt7QRTO8T0di nc3X9hAQ8JUVsn//PixGQ4P+rrbQKGKcQQiCxtoFs5hzvB/vfvpMtQ1KZs23c/mmcAfm8hX88NNm gsOjsBgNtMvIBfws+/LfXHXX88R2H8mIIaMJs8KRnRv46q2H+WXrQZYveA8dKq6qikChJKooKi1F 8ChUujwA7Fu7gNtunML6oiDGjxtBm3AbGfu38dGLD7F87U5mfPoWPWIshMfEkxTn5Innn2N3Rilt PnuHnrE28Jcx64NXeWraTC665xU6dmhbf6tt0mB9IniCYvalZeMjisTIYMyt+kQrnUGQ/lv+1kr/ vfL9o+XakjQy4f8BH2pPOaF1XbXS/yhAp7qSpU4ycP5lfbn3b8lEWgVQvbz/2jKmzs3ny2WZDL0m EV+Fm7WrDnNQtfLmg+dx5/C6MK2irCK2pFYQGWTg73/vB2439y538eLjY7m4q6XBKxPaxfDOtAkN w6lVP19+uZkpL+9i+aYcJvYJ/V1eDE3TSOiewGcPCOy+fTmOPp2Z90gKwfqTcbMi+0nu04XHrunO wKRAiOSunzYz4qltfLIonet6OzBadOCt4M5p65HaJ7H01VEk1IumPLRmGz3u3MArS7KZcV2bRvkM Gqri5Ui6jM5ipVdE4Fr97bRmczFIAt3jg8GfR2pBGRCFIAgYjTownFwwQhIFMOrQ10tUFkUBk1FX 228WZJavOsLL32Yw/KJefPyvgSRYq58le1i4LhtjmBX8dXlUkl4CZGZ/uZnHZx2h7eDuvH9PCp3D DU2GcwcUXzPXjkti3/Fy3n/rV35eFsGArk66tnPQMT6IaKeF+Jgg4mvC1gE0Nw+/up4CewTfvXQO faLrwsVyd+yjx62reG1RJn1uScZuEpkwcShTbqsTgqZqeCvKuWrq93z39W6O3tWNLhahdo6juthV 4uSlJ0YztGMIFkHFrzNQlp3P7S9vwdAmllmvnsfopDoV/eC+4yw9poJSZ9AJi3Hy0p29Gd05BID0 PWmcd9sS1q08TMbtHUk4xfEoiAJ6SSQ+IYxH7hnI5EHhSICvuISHX1rF68szmL2sDT0mt23yADYY dJj04km1E0RRxGSU0NfrlZm+9QjTvz6MLSGOz54exqjkOk/OtCfm88j8kgaHml4vgVEKeHJrrhl0 6CSNTgOSefyabvRLDPB9x5JNDH9qOx8vSufalBAMUvNlwOXcTaxLVxlw1wXYT5r9AVBpMAH+TA5W 9OWNGd8ysFcyJsGPqreRd3At9z/0Ar2vepYfP3q0wcY378XrmfzkZ/xn4RQeu6w7h7et4IkXPqbj iKv46uvP6BFZvfg9Ofz7nmt45Pucuh6wgojeaMJkMjb47sCfJIwmM6JBX9cvVxAxGI2YjMa6dlei iMVioyx7H2LKJJ584CmG9e2C6HPhiG1L+qrPePatOfSYcB8z3n6IkHqvGfjPidz15rusmXwRSWP6 MPODDzlaZGXB0h8Y37tuPylJ386qw5UEmU8dSilIOnLW/8BNN2yvGyOgqSqjrnuCl+76W6CSsckE 5oZpHAYTIGeyt7QPr33yDUN6d8Qk+FF0NoqPbuK++5+m28Qn+XnGUw3CxX94/WYueWAG73x7C09P SuHtBUspHxrPbt1o1vz8de19FVkHmPHm86wrCOX1z+dyzyV9q8+BMj586m5uf2E2L7/Vn5nTbgWd nfHX3skrWcf5x/NzeHpaFz5+7X72fPsR//7PXHpPfoCnHpxKpPn0KvfW3Lf128/4Ye1OOl3wd3ol J9U4of6femBOHRp7up6xM9169U/hSmP1PX5jfYszef/vee5/owf/dMZ8Zqo/t1IrtVIr/VkAHdAQ CYuO5sWrOtSCVkHUMXp0InyRQ1ppVUB3QkBFBL/MsWPFHMvTYbPocdgNhMWGMTY2rBpnyVT6VDRV pbLKB1gaHNQWi4GykkpW7yziYEYZR7MrKKlUyMwpRjRoVHh9FAORZ8Ci53fJyKqG369QWu4jOOxE xVbFJwYz7Y4UuocZa7+/x7ltiXhpN0eLq2orQx7fdIQ12X4uHuZk++Z0ttUrbGUWjVgQWLk7C2jT 9MBUhTJZQNAbmvXUCKKAyRwobV3hPzOFR3z55Wzechx/dATXXdyZBGu93HqdiYuGJ1WjgMIAOJdE /FVuFszZw1NzUmk3uCvv3JlCR6e+2WJMNYEAfUd34wWzkcQFqWxOLWPFujS+XbIfT6kPU7SDC0Yl cevEzozsFIJBEijakcbqNDddRzo5vDebzINUt4gSCDZJWEQda/Zm45OTABGn08TBw/kcSC/lYEYZ mYVuKj0qx/0AbtIrNbrUsw0J5hB+ePc8ohtMfpW1cw5x1KNjymUpjE4yN6g30LFLPB27gOrxBa7b jFx/ZR9Gdw6uWSkERzsZ3dPO3Ew3R0ohIeTUK86Hnl4923D1oPBaQGAIdXDZ2GS++nEF+44W4aYt 5jOgSCxafZz9WX6m3dOT4cm2BgAkyCwhtaS1lqYhS8G8dGcKnYINteuk15i2hE/fTWpRZYMKqk1R yf7dlAO9u/WunSsncwdMkYNYtOhLGgTwyW6Wz/mKg2VGzm2fxLJF83H7AmtDJ2kUmaJRfZWs37ER Lk1k9/LvyRKiuO2We+kRWdebFZ9CcEgImpZ9xjdin9dF3MBJvPL6ewxIbhiJMmvhYtIKYVy0ifU/ Lcbj9gaMHyYbbsGKWc5nS0YBVwGSaAYEDmzfTEeHgNMRQmiIHUdiChMSW6qsakgGE8FBwUiSWDuv NS1QD+SUh0poPxYu+YrwBvuXj18/mMW+Uj23dezA8oXzcVfvT5KoUWSIQlDc/Lp1HUxKoaKsFJ8C iuCjAqjhSGZWOvMX76Tv6DuZeknfOmAoBjP2ir8z+quv2LZuGXuqbqWbFQRLBJNveZBD+/by/tyP +KeWTfneFcjtLuTpR+4hKVT6TeD82I4lPPDUa+QJCbx/39/plOikJQUo/3epuk6Gx0VRfg4uudoI qGkIOgPBoWE4bObTP4s1BY/bg4yI2WT6y7fVbOwbNA287kr8qojNZkFoQWsVQRBQFZmi/Cwq3GqT wFDSGwiLiMFqEP648btK2bNnF4WyjR7duxJmN/73zU5BoKwwm+IKb3M3obeGEBcegqYqFGYeZP22 wzjiOjCsb2eEGpDeihtaqZVa6a8O0CHQRkpu8CABzWDCommo1fjQZDMycmQSnX/J4413lrN2bSx9 kx10aR9K16RQuiSFEGaRAhq21vjGKaCRmZbH659sZ8aqHDSjkbgIM8FWA+6KQHE6BAHtrLEukPdc 4fJDWL0DSzIRLAjkqnWfsvVwOTpJZOXPO9m8/CRETXxnJ5ERluZfJ+oIM0G6z0t5PYW1ITwRUFWN 8goZRAHHCYXbfuvBUljh50hOFW0iwv+PvbMOk7Lq///rnp7ZiZ3t7maDJZYOCQURFSQEEQMJHwNF BAkRUEoRRFCwBUUR7AQlFKSbBQSEJXbJ7Zye+/fHbLMLi4/x+P3N+7q85Nq545zPOfc55/1JwoM9 6ygyrj6kCdjNFj77fD8bt2ShSUtkwaPXJ+c1LXRls2/dPpbW7WPJyc7n6JkSzpwv4WhWIZnHc/l8 9V42/17K2rmdaBmi4eCpMkRBYNevRzm+21UDVqyWioAhRE9IkLbycGfnh2+PMOPdTA7l2gny1eCl V6BRyigqd9UWFesn0ZIrXaqiWuYxu11k35lSBIWEFgn+15BJDVE1me11RkICaNUuYi86mj7r7LUK uFYlxNJ5KgkPkVBQbuYyEPFfnyLsnLpgxqb2ItpXibSyD1V9dDq5gW9NpLTCDoZaSi6Z6zspaKIO qfhCIQA+gcHXlo9S71Jg1Rors9nK/sxzgJk1r0/mG8FBjde2gFQqI7V9Z6J8jYhlJg4fPYPex4uE pOZ1x1UUXfWX/wKIoohWq6leAGvO8Gaysssxl13i/dfmsUYhr1WfXESu1BAcFUmIwQMb0H/oYLb+ /hITHx/DZ61b0qplOsnJycTFJdC6ZRo6lawyL0bj64HTbifslvvZtGLGH1sZlYarvherxca+Q2cB G58vncL3krpjIJHKSG7biWhf4zWe7KCs6BJZZhk9Ypq5KkzUsljrPDyJTUjkYFY+Z383k9xchSiC PiSJx6fO5vcRI3jv9VfxT+jAoqXT6BDnfZ3kjI2Q80MbGD1mLLsvypn26hL6d01Dxv/P1vMa5J47 xutzprIvV4ZSJsFpt6H0j2TA8FEM7vIHSr2VXOKHL77kjN2P/rffSrjfvy2DuQg4Wbt8EfuL/Zn4 zENomjhHzBWlrFo6ibX7yhDtFhz1qrw4HHZ8gmN4ZPrrdIz46yae89JR5owdxg/FzVjz0fv0aO7/ r5ybP330Im9991vDa5ZEikqjIbjzIF4bOwjR6SD7yBYmPPAI5wztWf/zt7SP0Ls/cjfccOPfQ9Ab JIASF/kQapHLpBYxfDRTwpvfneHQuVJ+2JjHW5+YkOv1PD2mNePviqq0+lUeHcV6tK28jBWrD7Dg mxxu75fK2P4xNI/U46WVc+LgSe6ZtAmrXfxHtZuVuZ/r9h2Xl7Pd7uDue9vzUCsdV+VdEkGp0zS+ vwsCEqmC+HAlO0+Xsy/HQXCItF4ZN9e+YXOIHDhZgKCQklA/EUhVubgbLo4uVj+/yhO+umhZPeuT TCYl9/ccvq3QUe5UEm+1kH2lghRfQ50SR9c7BFchJNSbkFrlqOwFBdw38Sc+2vg7W861ID1Eg4iI xWLntmHteKyrLzp5XfIoiiIKDw16jYzCk6cZMXs7Fp8AZk9Io1e6L1GBWhRSWLbgSx7+ML/B/jsr FUV1/lpJ1qrcnRuTyTXnjFD3/3/k+Ff12YgOAZkguU6IR1MJptOVIFIq1HFz/jPXCcmNHBIr2Zzk OmZ7UWx4rByiDYnawBMvr6F/MxVWh1hHeYJUhtEvhDJTETa7S8ElyJryuYiNKxZvcDUSRWeNF0Yt Uup0WnCoopkydx592jXDbLHVlY3DiX9oFAontB74BHO1gXy05ksyj2Xx4xcf8daCcyj84xk/ayFP Du2BXi2/thVPAKfVRLnZgofqD1jLRGcDYyDiwIag8OCx+Z8wIEVTnYC0Wo6CDL13wLXXIYcdBxLk SslVYyORCMhlUpxOJw6Hvc4XEhgcQkKzOL7el41/YBCBIQG1VIJNJedOTuz8gUcee5Ld2SJTX3mL xwZ3Qy3597j9/tXuu4JUjlbvQcmRE2zbfQjv0BT6D2yOUib7Q20RC86watlL/GxKpUXrjg0T9Eba 39RyiY3vd0LTySSWrwAAIABJREFU2tvQO2r9XRTtfPLSVFadTeGxZx5C08RW2Kwmdm76lO9/tZHc viteUkeduepw2DGbzTj+K51hE/oqlaHVe2JEWycU7k+fT3/6ONZT79mtmM3mhvcXcz7r1h4hStms 8siqoEXv0az+wESPQU/x2Pi5/LJmNlpBuPHjkxtuuOHGP03Qr0UDJDIpzdvE8nqbWJwmM0dOFbBz /3mWfnSIRSsOkt4ijNv8hCob6lX352QXs/vQFaJbRTFpTBva1lLimm2OWlalP4lEVB66nX/g4FW/ JYmhHggI5OTbSE/w/QMNEZBKpHTvEsK7R87w0Zen6PtoXINl3Irzili94zIGow/dWvlUH0IlThGn 3V6P1gko5NenSQaNnFBvDd8er+Ds+TI6BmqrN6irN3YnaDTcN7g5KXor05fsY9x8EenE9vRK0F2z pJYgCDjMVkxI0aqkdTfoyp7IvLzokqBlzbZL5JudmIG4IA9UcgnZeVYS43zxvAZD/XXLWS5bRJ4c 2ZEn+vrU+c16A9ZRiQBxQTpE20UOHcuH9MDqw/5fnuxFcnXugfzcCs7kCXT30hDUCA8XAAkCDqez WrlQNRPksvpEXIG/QQZlheSW26/SIsil/+0hRbwhbxeNwXWsLS105VW4oUVOJiUhOgSneQcFhTbi k1o1eq25oJSwIG9Kii9z9mQWJMfV9FOuuMrFVqhUNDidDhx2G6CskalchkQC/51bjwehAQYE8xXs Cm9i4xKudb4FBNr3vpv2ve/GXlbAseMnyNz7C7Oencb0CS9wR7d0mkcG/O0nTKlUSkJ0KKLVTm6e lYSkjD+0Xal13vhjJf9sdvWUrNL5VZjKOZ+dg1aXgU+Atvr7EC2FvP/aIlZv/J2MDp24dHgDz8+Y w9uvziTcqLimVaym1KCZPes/4Ynxz/J7hQ+zly5h5J3tq5VhNYrS/02iXtWu6rY5bZSWWZCrNajk klqKRZpUZunqfrqIXlB0CpMWraHnunfJ6PUw3YdO4M25w6qVbLXXmJq22Ck3W1FrNEgqveWq2iCo NOj0OvQyHR4eHg0QusrrKpVZ5WUVIFPioVLUGRNoSk3m6l2tsgqpnfIKCyoPD6RQR8Fcp424qkhU mKwoNDpXCdHqNglIJEq0Og0SvQ6PpigpaslHLleh9w/n9bWb6KR1XhUOJAgCgkTS4PhUDea1FQ01 hNhcUQ5yFSq59LqlL+vPJ0tFBTZRgtZDVd33PzKfqspJlpabkCk1qBWyGxzHxuPmB497ncHjGr5n 1yfP0+nu6XRq1aLOM5J7j+G5h37g0cWLeeP7+3mqT5zbiu6GG278MwS99uImk0tRVJYtkytkDWxk TYPFYuNcTjESvZZoXxUStYqU5CBSYo0UnbzAs9st5F4xQ5gUtVZOeXEh566UAp7VB0+n4EraZbc7 MFtrnOrtFgsHjxdwqdhBlORPFIxOjlwmJftCEfkVNsK85DhtDpwSSU2CqCYiqVUYzf0z+frrA6xs baB3mi9eHi4CWlpcwcmzhRSKKm5K9Wpg8xEqD7gSbrslkWarzvHJp/vo08qT/q380NQqK3cpO5d3 P9zLjhwJg0Yl0s6n6nAsw9PDyZn8IrJsEFVZqzn/YhHbDuSB7NraaQ8/D9q28GfhL7+x5sfjdI1L I1jvkn9ZURn7zpTi6WMg1SBgtzkJiPKhd6cousWqMGBn1IIDTFgoRT2hLV2itdfc/O1X8lmxowCf YC86JHkRbFTWua40v4hfj5di03qR7qdEBYQ2D6Z1mAff/HSY5RlGBncIIkDvOjpXlJk4eaaQKzY5 3dJ9q50IzGYrTmqsuOdz8jlwxtxkMiWRSshoF4r/smN8/t0h7u+gp2WYq/yew2rlxJkissol9En+ c+vWCoiUlVsodIJRAuDkwpnLrF6fRb7WSNv0IFfwRQP90GpkeGjknLtQxIXCcgg1IADmMhP7jhWR V+ag9tTOSDQSoDrDF1uyyYgxkBKgxGK2cPFyCftyKnA4/j6e55UQhRw4lXUYiL+hM5JMoaRF9974 TV/B8iUzua3tEjKSolHLXPLLPX+GU1lnEIzhtEkOonmHDvDaWr5Z8w4DO00mQK+horSAY7t/ZtOu oyjkNcumUqXA4Kkj93IOp88ch5YtXXPAVMyBffvJvlxBhPQPLkyVnezSvTNJH3/OsqXLiAry4dYO yagq2553KZt92/YS1a4jMYFeHNibiTEwnPAgL2RaL5JbtiW5ZVt2rnqHI5suUGa1/yMbjVQmp0WP 3gQq3+GDJdO5s/1S2iTHoJG71Fp5F85y6lQWTkMI7VLjGn2Ob0AEXVt7sW73j6w7/iS3xBsr54GT g7t/ZuuRK6Tc3ZyUqkgI0cr6VUuZ/8bHJN45icWT7+arl8fyzLI3mRUbx/wpD6KXXltpaDcVs+HT t3lmxkJMxiSWvfEq/don/Gs2+dp9c1Tk8+vmLRw4mMnZSyXovP1JTm9B2zZtCfWpKd1pLi9hx4/f UaaP47buqWTu2sGJ09nYZRqSWnQgJdL3qpWpRnxOSsoqXEpPc0UtpaaAaCrmyP7dnC6VEx8dQd7p /ezaf5hLhSZ8Q6Pp0vUm0pIikQtQUXiFnes3ceRcHiWOU3y1egUnIzwpN0vJ6NSB5NgwBMBals/+ PTvZve8gZ89fQVAbiI1rRocuXYgP86tO3nh8x3r2n7Vwc5+uWAvOk5n5G1cKivGLSadLmxR+3/o9 mZfl3NQpkdO/HWLvvoPkXCnBGBRB6/bd6NwqBmnl3lWlGCi+eJKt23dy6MgxLheUovMNJiW5OR26 diZIr0R0mvju4485XmBHtF7h/Q9WosWBIEiJbdGFNkkhTVD2S5ArAEHSaN4PS3kRh3b+zPF8gZQW 7UiL9qspCWgzceLQDnafLKJZelvS4wIpuHCaHdv2oA2JJcTTwdYt2zlx+jwSjZHklu3o1K4VAZ6N 5wxwzSc7544fYdu27Rw5cYYKh4zw6Dhat+tAy6QoFDKhep0+uecX9p4qoestXZBU5HHo4GEu5RXh E5VK+/QkdBoFFQXn2bVzJ/sPHSb7UgEqgy8JiSl07NqVKH999Rw+sPErfivwoP9dXbl04ghHjp2k sNRESFJbOjaPQiq5sfXWVnCK56cvQBPRngkP3FGj+AMkUgX3PDmVxR/04I2X5/NInzdRubm5G264 8U8Q9CryZMor5POdeWw5UQJWBzt2nORrh44OHcLxrrzLbndgtYsNHixttpqSZGVFJt5fsYsdZg+G dgkhxEuJQgqnTlxizYFC4mLDaRmnBamDmHg/9OYs3l59CI2tHGeZheAQb/q2NZKR5MfXX55n8Xt7 yOvkj2ixcuDwRb7+5SwXrtjruCs6nU5XmZ5alnWnQ8Rqc9T5W6MI8qFttJ7Xfj7HSx/q6Jpo4MK5 CgYNTCQpQIPT4QSbs0E+Z7c7sdprBdd6+THrviSeeOcwD0z9mQdviyYtQotgt3HiZB5rfz1Lcq+2 3JTqdc0DljYshAUPN2PMsiPcN+EnDg1PISNKh0oqUFJq4ufNv/PWDxfoflsyMx9IrCFmWhWd2/uy 9accJi7az5B0A0WF5Wzfc5bvd1wCqaKOZl4UwWZ3Yq/ynZOqaN8plpHbz7P8u0PcV1LBgLa+yJ02 Mg+d55sTZu4b2orUHlocTicWqwOTyQZouKNfGhUmO/957QhPvCyw6KkMOkVXWtIbUPUoRTsrVu5h T7GU/jdF0CnZh0CjErkEystM/Lj2KJ8cNnHHwFZ0CPNwEWyNkUn3JJG77ADj5vzK7luiaJtgQCE6 yTqTz/c/ZxHaoQVtmvmQ0SKEcN3vrPpoD/GyBIL0UkoKy/n+l1Os31MCNkkdcmu3OxHtYj2Xedd3 YogNY8bgSJ5ZlcWgaSIP9wrDRyNwPqeAdTtyKIuMoU96c1fcst2Jo4F4a4fDic0u0jTjvYBC4uDQ wXNMfBmahWkRLRY2bDnNhsxiht/TioFt/eo921n9bFmwnpR4Iyt2nub1Tw5RejkYqdnCjgM5/LA1 h6ICe61DIXTuHEPf7Rd564uDOArL6NLMk/KiEnZl5rLvRAk4FXVDORyuftb+KhwOJ9gEGvrk7HZn PTfnxqGJbEuSJ/y6aQO2qXchrzd7REQcNrBhv/rbkcjxS+vD7CeHMGnJavr3H8ao+/oTFeyNqfAy +3f8ws5Dp+j39DLaJEcT3/EuhndZzoqP5jPclsdNKWFcOfc7e3fv4cSJ31EFptUQT58AElq1QfrO Rt5+bS46+1A09mIy927j22++JasYIut4C4jY7XZsdnuNTEQRh82OTVrPE6iyey16D2H06KNMmfcm 4x/NYVv/24gP88NcfIUDuzezctUu3vzpO2ICPZgzYQIWn0h69e5KZJA/chkUnNvLtwdyiLtlBCFG 3XX0rE5sVjs2u+O6yiqHzQo2ex06YbeBzdbQGMjwanYrc8bfy8RFH9HvrnsYfd8AYkJ9MBflcmDn ZrbvO0qfcctcBF0Usduc2ER7nah8/5Aoho9+lHVPvMhTo/9D4ZPD8dNKOffbLt5ZtpSK4M7ce+89 lTk67Bxcv4rps17FFt2bKU+NJDrUm2EPT+LA/iMsf3UmYeFhPD28B8pruK5m7/uJ6dNncSCrnEGj 0rh8dCtL96+vdi0WHXaUQfHc1r0DQV76/71d3mUOxmkq4L2XZzD1pWVYdcGE+eopL8oj+7KJgf+Z zOxnxxJa6X5UnJvDMwOHsse3E8um9+KtRW9y6MRZ0Pnz+NwPmDe65x9TFuSfZeW8p5m79jw9unWm IGs3F0psSJwVXLhSTFK34bz+6hy6NAui+OxRlq/8hB3HLyGVF/L6giwUMiiu0DFn6WJSYsNwlF5k 5dKXWPjm55SIavz9PHFUFPD6iQuk9x7K/LnTyYhzeTd99uI4pnxxhskznuJ85jbWb9zO+YJS0gdM ZP3KuXw4bSRzfy7n3nu6c3jvPi6V2JFLHJzLuUhAai9WrXqPjgkBlUpMgaJz+5n17GQ+XHsIL39/ DFolpfkXmHeujKHjpjP/2Ufxkpbw6rOT2H3Riug8w3NPj0eCiFSuYPjUd69L0Ku+K4cduEa0id1S xuav3mH8q99y0/BnWfXGTPwqmeSZAxsYO2IEm4sieXv5e6THBXJ8x0+MHjgaS0QLOiSo2bX/JFKF nNzzOVhUATw9ewGTHh6C5zWKPvy2dS1TJ0/hx/1n8AsKRSuzkXXyLIHJXZkxexb9u7dEWalQ+Gbx VMat2M3YSeMxnTvID+s2k51XQnLfx/jijdmorRd4bc40lq3ahERrxMfogbn4Ci+fzOXm4Y+zYNYz xPi5PPfefmoIrx3wYtFrY9n42ads25NJbomJrqMX8MOiR5EqJY0oFBpSWjnZuGIO3x4r5dHXppNk rPWbK/skGv8WPNy/JU+t+oaffjfTN1blZg5uuOHG30vQa7stmc5f5oV3DiFXSEhN8OLIjqPMOarh nQ7heANqlYy4eD9snvp6LF+CVquiRTMf4gNcbqmeBhVpCT58++kppu47i9FThUYOZSYngXGRPDM0 lVQjgJQ2GdG8NKqEN3++xPy39uCQKLhvYCqDuoUwbEAqZ/KtfP3zb2xYfxSNWkFIuC8d2kcQ7J9H pL+mOr7Lx09HepIPod41WmD/AD0tk3wJMjZlgVUz/r40nOpjbNpxmi2bHSDX0aufy3ISGu5Fcr6I 51VZjWUkxfugDtajVtaou3sOasNrnlre3XiOnduz+H6DHQQBL08NCS2jGd4t6JqublUWiJsHtuNN lYYla8+w+rMDvO8ANSLnsktAq2fMf9oxbkgKsbqaZ+mNWkYNb8OBy7vZ9O0+vvtcwNOgonmyH8Pv SmT9vkIifWtkoterSE70xTukpqxWUJgfM5+5Cb+PDrP+0CXmvnUOpyBg9FTTuU0YvdJ9QGonItRI c0GGt65SLlIlQ4a1wuoQmP9NNl9sySEhOAE/VSNW+wBvHh6Swue/5pC5/yw/bTyBVCZFJQWLQ8DX X8/IYa2Yen8z/DU1G3G73s1ZrPfgrXWn2ZuZzZZtWTgR8NSrCEsKZ3iPYLQKAV1qDC/cn8viH84w ef4WdBoZUoWCli0juL+Pig2HzfiopZXWIAnRsb6klXnWyZxfHZonyBg9tisSg4HPt1/kjZUHMDtE NFol8TH+PHBrOCDBy09PaoIPIca6c0WlkhEe5kW6U8SrCVNSLhMQBAkKqcCFc1fYtDkLiyjg46Pl 8THteaR/PIGVDZWoFUSGG0nz1ODtUfleQcPgPkmcy7XwyfaTbP35OCq1kvjEIHrfFEmwfx7hPurq b0gV4MvUka3Qev7G+syLvH4kB41WRedO0QRJbby/x+YqrVaJkDAjKUlqvDxq+hka4UVyiYBBU18X KKdZvA/6CF2d76Rh90QQFJEM6JbAs199z/bsCjqHaupY0SUSKWGJ8aTUK1ZXdc5SKHWMmPkacp9I Vn63iTXvLKa0woJMocI3KJSMm+/i1o5JLittSCwzXlkK0+ewY/dPLNsq4hMcQ/eut9E59SBL19fK 4i7oaXvz3Uy6/yBvffMjI+/9ErVGT1hcOm273UZQ4B4CgvxrSorJ1YRExpHoFYZHVRJHpQdhMQmU KkPwUErr+kuIIoLCj0cmTMPoH8yqr9bx5YrXKa0wI5Wr8QsMpu/9D5ISFQZo6NAmgffWfMWUDV9h 9PbCQyElv6CYkNZ9mPbCkwR7uzw6RKERfi43kJySgjEssE4oRUPKopD4FBIN0UirZS0hLCGBFGtk nfwCVWMgl6u5b/oSZN4RfPjtBj5/fwklFRakchV+gSG07DGAvp1TXKuoXElEfBJOWUTl8ytloTLQ ZeDDvHwxj5c/+I6xo3/BU6emrLwc36jWzBn7JEO6udbo8iun+XHt9xTpknhuygQ6xHgjiuAX35Yn pj3PhaefY/Pa7+jRoQVtY7wa9QapsDoJi0vkinCZnWtXsfkrWx3dhdNqRtf2TtJSm/3vEfTK78np cLBn7Ts8Mm0xibeOYs7Eh0gM86Hg/Ak+eXsR8xc8jcQYwfKpA6q/J08jOPKP8OpSE8ntb+euERFo VErimof98fZIpGgNXmA9wLncfAY9MIHObVJROgpY/c5iXlv1ER9/3pFOzUbiG9+ScY+NIefiRY7a o5j45KO0iPOhwiIQn+yKFf5u+QKeX7KGNneMYtzoYSRG+WMry+XHjxYxZuJiFie1ZP7EBwnQyVDp jBikR3nnjfdo1rwVwx9/Bh+NgCGiFXoFqHRGVFxg84HzDBzyBDe1TUWndLBp5cs899ZaFn60gZZT BqFVyYEKXp38CEs3FjNt1hIG9OpAgJeG/OzjfLDoWabMHkd655483jOSWe9+wNQH+rI+N4o3PlqK QXSAREJw7PWT5gmCQEVJPh++vIBtSmudeHPR6UTn7U/Pux4k3ieEMdOWcOVSAQs+XsCs1DQWPXUX pRcOs2DeHH69aGTxe0sYepNLcS9TqPFSwu+lhagjevLSmGcJ91ZzJnMzi16ez+KXF5KQlMYDPZMa /C7Kzx9g7szJfHe4jMemLuTe2zujk9nYt+lLpk2dwcQpswkKWkSXZJcCQqX1xFtqYeW7H9AsvQVD Hn4af50UXVg6wV4Cy2c8w7yVu7j3P1MZcfdtRAYbqcjL5ou3ZjH6+VkkZXTh2eHd0SolaAzeyKUF LHjpTRLT2/DIxAEYFA684lojbYq3UpVngQil5/fz7Lz38UvuxTMju1M762R16VqFlJv73YHz3ef4 8cdt9I3t5o5Dd8MNN/5egl5lPc++XE5WsYy7e8Uglbhc15yiiEwmJfvIFcqkLitJUvsYQuUadvyW i+CoSm4kUl5up+/NkXjqYe/RXJyIRCaHMl6mYO/JYi4UmBGlUkJDjLRN8yfeILIz8zIgIJNLaN4+ lse9PTmTb0OlVRIT6sHuo7kopHL69U1E53OenCI7nt4edGwdTKhOIDNEh0Iv5eDhXDRSKJGr6dM9 Ao3Dyq7fcpEAJg8tfXuEIzGZ2HU0tzoOt7FFXKX1ZGDvOOLiSiixihi9PDBdKWVvWQWayEAGGUVy zhRQdllabW2SCnZatwsjSa1m/9ErdZKqeMcEMzbAwL7fCrhc6iLoAX460hK8UTpt7Dx8pUnGEN/E UMYZPdh4IJczl8opLLVgKTdh1WsZcmsMliv57D4PEgnYHc7K2C41owclELb7CoXlDkLCvOjaKggf iRm1WkOAaHONlShSUmylfZdolN5ydh3LRaz0klAopPTvm0RaUgEnLlXgkEgIDjaQHG5AVV7GzsNm vEP9uMVbIP9yEXsqynCIIlKZjOiEIB6RqThnsvDLzmwifdUNlNcSQSIho00EoSGe7D+RT9bFMvJL rDhFCV7eGprF+9M+0ZOLZ/M5W8/6qg7wYcxgDw4dK+B8kRW7CH4+WtISfNBKnOw+fAURgbQO0dwj Stnzewk2iZSICC96dwgl7/RFvAMtFJy8wk6Fy+oU1iKKAXYFew9faTD5miARaNcllqhIbw6cLqHC AXqDmrQEX/zVAjsOXqZIrmVA1zAUphL2HHEl9RFwfUPGMH9u9YYrJ3LZrWjcki6XSzh6sogCh5SE hEAmDAtn3/5cSp0C4SGeJEcayL+Qz/mzIhIJiGYrfpH+9LBJuXw+nz3FUhxOUKuU3NwjDoVBS3ah FU8fPTe3D8NbaiXSX49e5mD/4VyUuNqi0xkYensSCfEFXCqx4x3gSc+W3iw9lQVKB6dOF7BH4kpa pgrxY2B3J5fOFbEzvwypREAXHcQgH4Fzp/IpqkU+pYKdNh3DSdFo2J15mbAALSF+HkgkDbkZu45D gx56lLmfP8rLiz+l84vDqW3zlMpU3D9tEX3wQ1GPSFZVBhAURoaPn8Xdoy+x/9BxCsvMKJQehEfH Ex3qW0tBICOieQ/eX9WKXTv3UGyTER6XQnyQjA+mjcDqyKmjPPCLSuWZhW+T0XsdJ8/nofYMplPX bsQHazm0ZwcOXQhVvjGCMZSBYyZwk01NbJBLASbxiebesVMpkRgJ91U16NEk0Qcz7LFp9L93FEeO nqCwtAKpUktETBLRIV7VNubHZ79Mz4FDOZh5lJzLV0CiJjAsjptu6UGQXtGoEqQahlTmvvQycp/w BhN71Zbr0Anz6WrRV8fVSiRy7n32FW52+tYz9tUaA5mee56cyeBRj7LvwDEKykzIFRrCouKJDa/x /tB5BTBy0kLKJTXPchF9EbU+gPunLqZdr7vYsuco+SVWfILCadehE0mRftXWdrNTSctug+hyXyIp qYm1fEMEWnS5nTc/iOFAVhEGwXTNNTc0uT3jpvhRWGZpcH6KTgcyYyBxwb7/ezt8VdUJWwVvvTQf my6WRW++Tpdg17cYERFJSrNo9m5J49M3XmbqhAHEVn5ATicYAuN54e0V3N4qphEL5I3DbrOgCmnB 5LnLuK9HfM3UE4vZvHYDp86e5qwdItU6UtPTCPczcNYURPvOPWgdV6sWZcFBPvjkG+x+rRjcrzd+ Hk6yz55FkKnodMuttHx3DWt/XM/Y4bcRoAsCREwOCff8ZyovPP0QxnrWYafTjlnw56V3P2RgRk1/ OyVKeGv1z+zauw2bvR8gp+zoDyxcuZ02I1/kzi7J2MoLOFuaj0Rq4K6hg5i79AdWrP6Gx295mtZd byZML4UiL27u1rVOHPr15OgKsSji02ULUNSrLuKw2wiMTiGqy/3E+0jx8A5n3AvzOfr7YN6eO4XY EDWy375kxbrjPP7iO4y4rVUt1xknZgfc1G8kK5dOqiabHTp2Rm4tYvATC9m+9ddGCfrm77/kx58z GfDU60yd8CBVgVyRMYmUXDzFyOfe58ft99E6OaSqWC4mh4TBI8Yzd+pj+NXWeF/cwpIPfiC4xX0M 7N0eNeWcO1OCRKbi1rv6E/vaGlZ/+R1P3tUOrVILiNgcKh6atoAJD/RFcdXR7doyrSqVJgg2Pn1l OrsvKXju1ecIll8dXi4CgkyBT0oHQqUWDhw7DHRzk3M33HDj7yXoVQtSUamVyzYpLRN96no5iiIl V0opqlzEAiN9CBadnM0uqasklwgkx3vhtDs5mVNSvdFofT3pEehVHefqcIhYbVYyT1quul/noyfd z3U4tdlsZOVYXQ2WyejaKQqpAE6niNVmJ7cIQsO8cDpELl4oQcQV85gU74Xd5uB0ZftkSiXJ8Sps Njunc0qaJCCpVEJkhBGJIOB0OsnLL+dKHqi89aT5QUlhBUUFde8JjzQiiCIXrpRf5dorkbiswP6B QnXZpjNnCrjR6k1SqZSWqUFkpEuwWax4lBXw8aFCXvrgKHe3NuK02sgtshEUoEUiuhihTKWlbzc9 EsEle0uZiRxRoHmsEYfdUT1WEolAVIwPotPJ6XMlVx0YZB5qmsVpatqfXeRqvyDg4akl0QimMhOn SmobTgQCQo0EA1abnVPXkb9UKiEm2o+EOP/KxEKud9ntTrLOFTcqL0EioPfWYvQRQHDdk5NdWPd6 QSA0yp+ouIDKeejkUk4hgtqD1DgPzPllnKm83ivMG19ELlwovabHr0wmJSbKy0UinJB3uZjLTtdZ SCpXkBatxG63cuq8pc7Z2cOoI9EbyvNKKLnGC2RyCRfyzdhEKCm1kG+CqCgXMXM4RU6eLaw71wQB rbcOgyBSUVrBqeLabZXTtWPNN2Qxm8lDIDLSG6fDUf0NyaQiWbtLcMhkRATpCQ+XYTVZ+XT1Pt7f nktks0gEm40z50twOEFh1JHmA+UlJkqKKpUmvgaa+0NRQQUF9foXUfmd5FwuQ6uWE9xoCSUXFY/r NZShnRbw1hsvsPb+XvRK8qtOHCSRykjrfEv1OlU7s3L9BF4KXQBtOgQ0oJMT6yaCUnnSpkuPmguK s7HanfUOZy7i6eEZSN9B91/1zBbtu9e6DgS1gaQW7eq+08NIakbHRg+YNckgBTSeAbRu33DbXRcr SExvR2JRD0xxAAAgAElEQVR6u0b0jtdO/ITKn27de17nelefkzv0ILlK3rhKFaV2atoYyDz8yOjg 12g/lGotLTreXPOsyhKOgiBWPkNCfKtuxLfqdpVitcol3jsgjG59wurKvyr/hcyDqGatiWpW670N ZIoWRRG9bwhtfEOatC7/1UniBEFAIpFUe7rV/u8arcJpucy2Xbl4pt7uIue14qidCn9u69maX1Yc YsuBcmIzPFzyEsAYkl5Jzutm+/5v+iiKTvSe3vh4+daRmVrriXeAHpPZgtkMaEG02nA4nTidDiyW uueE0wcOc+FKERXWk7w2/3lUkpos53KFQNblMszBFdhslfeJDqySMPrf0cNFzmvJAEAQRZD5ERWo qzuH/SLxlsrIKjdXr7F712+mXCZw5chGnnzilzqkTiK1IVcpKCjJrST+VlwRb66kph71xvN680ll CGTqm6tIVZurwwar2qf00JMQUmME8I9tzbz5c7hv1HieGnEvcUEG7nhsJhMfvqPylqoEeCKiRECt qUz4WksWkbEJJOudXLiQzRXAT7ha4XPi2CkuWQNonZroIue17m/VujUJ/u9xIPMMlwsh0uiSvUUI 5rY+3V3kvNb1mVt2UGB2IJzby8xpZ5AJNbFgcoVImRXMFYU4nI4qjRioYxg2qGclOW/63Kxe44G8 oz/z/LJvCeswnLEDW7uo+1Up5AFBgkwdRJw3nD6b52YNbrjhxt9P0MXKLKupsV6kxnq5pfOvgYif tZh1R3azP/My6QFSHCYLJTY14+6Ncovn/wiO6kTeeXsf/kFe9GsX+re8c/Hr2/nlZD7FFTb8PRVY ykys33EJ9DoeHZzCmJsDr1PW7UYP740QHFEEwcjkuTNZd8swHntsCl9/uJDEQO3V8e2NlOS53mH4 ugc8UcRht2G1WqvroTedqDRcdqixxGR/tO1NIXg38lvD19frS0Py/i/HoPFnXad8U6PlmIRaJQ2b Lt8bJaJ/dQZ3k8lEQUEBkspEWCaTqQlKARHRWsQlB+hC/Cr/UiMPCeBrDMThPEjxheI6FNLpsFUm 0xT+xMTVQp1SeDUhXFIkggwBsUnvyi8zUW4yYQgIIiGlOUaFs1YOB4HmqS1QBiUR5lur3KjowGQy NzxXBNfv9qr8MdW/y5EjUNt54kJhGThF/MLjSIvUIan3oIyMzhhi2/4p66FSraXDrR1pJbn2da4m y0hocwuj+q9h1EtfcUWayIB7hmFoaG0VRZzOWn2tfIZMrURlALPNhrlaMNXqB8BKUakZVJ54aNVX zSeDhxGNRkdpXhlWkw0qQ7sE0VlT5qyW7C8XV2C1WAkKiiQ5NRK1TKy1pgukN89AHZ6OXlPLu0i0 U2EyI3qoEG5obrqU/YJo4q0XnuVMhZFFM6ZipOHk7NXfiCBHoxGwlFrcBxE33HDj7yfogrt0xL+P mldqjjO6NePFbDMfbr3Aii9+A5mctLRIHIDULab/E5Aq5DRL8iPQ/+9KUiNi1MkozC1izak8rDYn cqWM0CAvnrknkQe7+CHnz7UaXosoiaJIRPt7eHHKNma8/ysff7OFKSN7oxT+tgHANzSGlulSvA3u REFu/P2oqKggLy+vJiu7w9GE708AmRYjUJxbUPmXWh4FQHF5ARJBQOPl8c9uZlwd9uRyALs6aYKX ToVc4iA45SYmzXiGoL/sk7zatSnQ2wOHE9JvHcnsYcnXIc6VXh1VJURuMIJZFJ1YTIBHU9ZOkezj e/lx12kUHj4oik7x7aef0S3xAbQSoR4JrUvWq1y/K0rLycuHcK0nXlf1XwQUaNUKMJdiNpmvmk/l ljIslgqMejUy5fUr+foZ1SDaiOnQnznP9v9TFb4N6O8Agawdn7Jw1U6SbxnHyO6xDZajoxZpF0U7 FouIXC13L0JuuOHG30/Q3fj3Qah0N5UqlIwY2Z5beubye64NqVxKoL/ORc7dGU3+TyA43IdnxnVA 5f03JKKqPJkMHZxG567RnM+3YLY5UajkxER64a+V1RxA/ybFXtVbBk+YQ0CbPVRYpdicoPybNFCi 2pO2t49gfpsKYuP93RPSjb9/w5bJUKlUN+hqLiBVBZCRomP18R3sL4B0r1rWY1shG7bsRaEPplWa 4b9YMqpIjgR5Zf4CifS/+zgFhQSpQkJxYQUOsW4ZjKhmzYiNDOPTrz/kh7u6M+LW1nVvdpRz7mIh 3t6+eKiVf+o4tOzUEW/FYj59fQ4jer5For+mrizK8ziVbyUmLAhRlCBVC2AtpBTwrl19oinKTUGC Ut201bE45xBzZj7HhiwJ85Ys4ey3C1n64mQio8OZNKxbdT6PKsjl8mrm6qpWWMzeLZvJsfoxLLEZ WuqX7HSNQXRMKF6Sixw6dooKuqCpZRE/dOggpy7YuCkpBB+v68/P5NatCfM1sm7FYjb1bcnNzcPr XmApIutyGaFBgchl/+ViL4rgKOClaTPJUwSyZMZ41Nc6Irn8/3FYczmbD34hRvci5IYbbrgJuhtN OcG4XNOqtNchEb6ERNQ9NDXu9unGvwOu8dUa1GS0DP57xrUyIZdEoSAs1Iuw0GsdyP++ue469evp clO3WrIR/nIdgStuWUVgdDKB0f9Q/91wo968E69XMrRynZDKdQx/dASrR7/CM5PnMmfsQML9DBTn nmPtmrf4bn8+3f/zHC0Nf3yNEgQBq9lEUf5Zss5eQESkJPc8l/JyUSi0eOnVN/5Y/xACAgPJ27iN L776HA97e4rzCgiNTSQuIp2hdw9k42MzmfXsZApzHqRNSjRqGeRdymbP5h+5qIjmyTEPEBP65ybw 06XdyqNDevDc8o8YO96XB/rfQlSoH9hM5Jw+wc7NGxAS+jLvibsRkJKUFIdzdyavLlnN3W2jcZhL UPrE0iIh5LpLntVcxo4fd2LWmKhdvVUURZQaLbHJrfD1ELCWXuTNec+zYt0Jxi1eyRP39+ZMipa9 mfczZ+okYqM+ZED72GrSLxdEDu/ewMqvoojw9US0lrF34+e8svwbEnsO5o5bO1aObJ1hBqB9z150 afMRny1fRkJkEIN6tEAlsXPy4CaWvr0KRURnbm7THINwvVkDkvDOjBx2J488/x6TJk7i9L0DSYkL RY6Ny9mn2fHzOkr82zNj7L0YdZr/+rvZ//1bvL/+FO2GzWZgRmCj1vPqdHJOK4W/7+akVcH9iQnV 7Xav/G644YaboLtxfZLe6E/ubeT/wAA3EBsn/O3v/N+cW8LfYsD/I3Hhbrjxv7A3uJKmSuk55EnG bzvBkvemMGz/OlIjfcg/f5rtO4/SYcB/eGHSiFpkxkl5KZSWm5r8HQJcOn2Yhc8+xtd7cgAbm79c xgPW0wwZ8RjDe7YA0YG5oozSMie2elU4nA475aWlWE3mmnJi0iBu738323dk8ua8qXz9YQB2s5rJ L84hLiKI24Y9zMsWWLR0OXMmP4HB2xuVFMqLCyixCvQbNRmV2qUYsFSUg1iG3eFssAfm8lKwy7E7 6//upLyklNJyUy2FiJanZs3Hop7LR1+s4PH1X+DtrUewWSgtKsTh4csTnUZWj8GdD0zgsz0TWDj2 fr5PjEYpk3DnY69ck6CLooi5ogxzUSnPjRiEh7SBLO5RKbzw3o/0Cs1j5aJpzHztM3o+8hJPj+gN QER6D56fMZEhI55m7CPjMC5/g+6pQQDIJXA8cwfzpp3EYbNQWlxIcZmdhLZ38uzkJ2gVYawaGEzl ZZSWV1TLxi+hE088PYXzz0xn1tOj+aFlC4wKC7u27sCsDmbyC1PpmFaTCd9qqsBOCTa7owEFkpT7 n5xKORreXPEZU576BaO3Eblop7SwgApBzQMT+iCTymrGyayrzgNyI2u4+fJvjHt8BmaPCGZOfRhJ DQ1vTLeFzWJjy9dfYVcZuKlz+1qz3Q033HDj/yBBv64FsF6G1aY+s/b1/xesx02x0t1oP/86udTN pvpvHYMbs4w2bMF1W1fdcMON/5EFzWVF14Xx/CtLiU1fwa+7M7lSUIFnSBLjbx9J/8F3kxqiqV63 PAy+jJj6NHnebW9o7VZptEQlteTWkPZo1QpsFjPo/PCvjG0XdP70GDIG7U1yEkPqBlV7hyXw0JPP 4ghuiW+t2lltbx3MfIMf6zZs40pROUpdCOlJleTPI4B7Hp9MaruubNm6izM5V7DYRYy+gSQ0S6VN 2wwCvV3lDDsOGsMzcSUkhDRsTe9x31OI7SWEGnX1fvHkkWnPkeefglopr17fPYLTmPXKYrr22cj+ A0e4lF8CEjkBoVGkNG9ORkbLamIY3WUISxbJWbt5H7klJjQGX7q3jrmmLJVqHQMeeo7gjhXgtF1V uUR0OjD4hhCiB4vFjocxmMeef5kB947EUOkBJUiUtLl1OG+85uDn3+2YSkurlQ4WETK63snY4Rns 3XEIk1NGaFQzbu51M82iAqiyEwueIfR7cCwpFh8i/bVVmhM693uAZd5BfPb1Dxz9PYcKm5IeA0bQ o+8A+nbLwENRE/Pe5s77mRzQi7TooKtIsyiKyIxRjJ0+lzbderNj135yLhVgFwV8A8NISkmjTdvW eKhdk6L3qEmosvX4edx40gHRYaXdXY/QPaYdPeI9r7FPV4VuiZgKT/LGmi2EJt/GLS2NuO3nbrjh xt8BYcDDC8Rz5d7sXD7873+7w0rexXMcP3cFmVSGIIg4HE70Xr5Ex8dwY8uva9G0msopKTeh8tCh VSv/dWupKIqINjN5RaWo9UZ0qiYmJRGdmEsvsf/IOaRSScNEUpCh9w4iMSrwL+3DyX2b+eaHraR0 60uPdsn/zjOtrZh9+4/juNbHI5EQldwKb5WItSyP1e++zekKNbcPH01akNpN0t1ww40/FRs3bsTH x6c6i3ttvP7xVo5ZmiPmfMeQu25l1MC2dfaVOmuR3URuYQVqnR6tqoZ0Via5virbt3hdJevVytn6 cFZWiam/31WXvqvzW00m72uWBaRpSnzR6USoJbO6iuNrKJarS/w1pc2NtPEashMbTU52Y0ri+occ 1/00Oia7v3mfe+56kLRHFrNm4SMNKnVEGpZ/Q3IvKy7C4pDg7aWv13fA6Sp/ei2ZNLW/DWWiF5to AGjw3kY8sKrH2GnjyxdH0X/Sx0x8/xfm3tfGva+74YYbfwoyMzMJCQmp3s9tNleVIIDTp0//wy7u lmL2rv2AJxZ+gV6rQRDAXGEl45Y7mf7SNIJuTNcAwJFfv+ON5d9z07DRDO7V7l+p6Cw8tJ6xC1bR 696J3Nc7tamMkrwTGxg9ZgFKqUi52VrvwOFEVBjI6DuG5c/f/5e2/+jW75k8dR4Pzgz49xL0ksM8 8sAoShqI8RQEAaXaA63WgykfbuKWEAAnpbknmfnCu2w7a2XN0gloBbeu3Q033PjnUb8OPTI1vr7q ekRFqL2V1r65CWvY9UNNJNcIE7ma8Py5ITZCPYVG3XuvEULUQN9vJEHfHy2PeGME8FpyvTaxd9jt jTWsSWFzVfNJa/BEexXxrVXH7zp9+8NlIm/AO6+p99Ym4Fk7vmba/A+J7XovTwxpQxOE6oYbbrjx p+CaBL0x7e+fpkGUqQhPbkuf7rls/HoVmQVq7rp7FD06ZjRQUaRhDX39tpw9vIsPVi5Hm9rDRdCv swD/Gf1q8L5GtLNNeXdp1l5WffwR+pShN0DQnZgKz5J56ABBaR0Z1DMda+14L1FElGuIS/zv6mc3 1P7680SuUKEXFKhUir90Pv3Z41gHCm+6dOtGRYM7vZRd37/Plr3FFNldBySF1p+Hp71Ead55Ji6b xavdujN5YMuGi6u64YYbbvyDRP2Pkhw3/m/AYbdSaoPyqprw7vlUp09Oh52Tu7/l8VGPcJhEVs+b QYDCHbrmhhtu/NMEvb4GFCgtKsTskOLrra+ut3k9F7Ta5FFEcpWbGAodCW17Mys6kaeztnMhy8iI 8c/RM44GYtBryG5FaREOmQadWlHtalb1u8GgR4sCvV7fuMKh8kGWsmKKzXa8fLyRVb3rD8S+V11b UVqMBbkr02jlJlXfHa5KdsX5+Vilcnw9DdXPqLrG0+Bqu05vaBLpr4ZECshoeftwFs4ceQ1iW58z 1ozl1dYEsU4SlWpLjN1MYakVT6O+0jJyjWza9WVqt5JXWIra4IWHQvgD86nSra3yuvLiAsod4Ofl VXN/U8exERdGiS6BeYsXN3y4yT/Gzes+xCexF+1qRwvIvRg1cQZfft+d12bN4N6+XxOqcm/mbrjh hhtu/O8gPLktz82djW96N7cwGjscKz1o128MA1M7MTAj1K1sd8MNN/55gu4iNq5/H9z4Oau+Xsux rItYnDKCwqPpenNfhtzRBWllTU3RZubU1m94a8Mx+t7zKHGSE3z69XpOZOcTFJ3GI4/fd5VFvDZx Kiktw2p3IDrtVJSZAVU1wT17eCeffPwNwS27khxkZfUnX3HszGWQa2jWpgdDBvcjsbI25c71X/Pa O6spxs7XK18n/8TP2CrKCUvpxKD+fYkKNAAih7f/xKdffsPhY6cptToxeAfQutMt3Hv37QQY1AiA Lfsgi5d/ijG9P31beLP31w1s3XeU/DIFYyaNJ8aaxYL3PiOmw0DCJdms++knjpzMwSpREp3QkpGP PEy8v7ZerFoF33+8kh82/crZnCtYpXKCQqLp2usu7r2jI4IgkPnjJ7y8aA0AP338EmNPrMbpBLkm jOnzxnP9CtjCVe58V19h43TmNpa88QlBKR0ZMWoonkLN/pN77jBvvv4O8rCWPPjQMHxseWz69jN+ zXHQvmULzu3/iU27DlFkcuAbEsPtdw2i902tUAjXVmKUXDzF15+vZuP2/VzKL0epM5LcogND7xlE Yqh3dY1Wx4UjLPtgDfK4XtzRNoQjOzexeVcmuSVS7n/iEVrEhCDFzra1X/DVDz9xIiuHCoeAj38o 7bvfzn1390Yrc80f04ltzF3+Fcm9xnBzjJ2f1v3E3qOnqLAbGDdjImE65dUujFzbNf2bN2ax8UQR z6yYQZiybkyePqQ5Ux4fzG3jP+adb/czfUC6e193ww033HDjfwAuRXhgbCpjJrq889ylWOtJSBSR SGVEpffkufSeVX9sNNu7G2644cbfQtBrLL6w77ulPPr0C+y/JNCtUxs0cgs7vl/Op5+v4+SFF5j+ 8B2ue2xmsrZ8xYsvrGT/0QtILm5m7/GLlFfYiErqxH0NEPSmIvvoXl6bPYsiv1WkRGrJL3HiZdSS /fsRPv/0Cy6VWJk5cQwBGrh09hS/n8rGipPzZ06w1VqIraKMQlkQvc0ud+9fvniTac+/wiWLB8kp iYT5Ssk6tI3Za3/kt0ulzHp8KIFGDfacTF5fOA+iDvK1bwVHjv5GfkkZBYU2uj44ipDi/SycNwdp 8I/4yUqwSxR4+xgpOneErz5dQ2auwOoFj+KpUVWyswqWzXiKl976Bq/wJJLiQpE4yjm04WO+/G4j uc63eKpfBkUXs9hz7BwAF88eZZvlAqIISs8S7E3cgJ1OR83GW495CgggSJDi4NTub1mw9DOsGj8m 3dsDQQBTUQ5vPv80zy/fyujZbVArgMJctn21gmkfbyc2qQUyezkagydSSz4/fvsFX2/cx+JXX+Lu HumNsXNKzh9h0exneeWjTfiGJ5ASH0bBuQMsXvs9P+88wqKXptAixmWOdlz4jbcXzyffexs/hEg4 9tthrhSVUlBopeWdA2gdE8IXb85mxsvv49AGk5wYjbfCwbE9P/Dtdz9xrmwRz91/CxqVHNPJHcye /SJpuy7zESfYeySLMpOJwiIZA58eR2gDBP2qw0rlAUYURcrP/sq0hasIaT2QcXdnUJXtVcBlsZfI 5LTv9xBxz73L5x98wvQB6QjuSHQ33HDDDTf+cfwTJTv/ZRJyh4G44YYb/4sEvSr1p7XwGJPGT2VX UTDLV75O57QYlFI7pw5uZ+4zjzPv+am07dKFXkmegIBcpQHg2MEd9OjTj3seb45Bo0Sp1DbB6ts4 pHIFWjlU6Ax07PcQvTtlEOCj41LmJp6f/iyffv4pvW/tRb82EfS8+0HOn8xkytwP6DNkDE+M6o9Y XobK4ENYuBd5xzYwZ/bLiGGdeHXSeDqmxeChECi8nMWsJx9k6ZKF3NI1g8FdUpFI5XgavTl4eCsh 3Xvx0FODiYsIwFpqpl10INIDUvQGPZfKyxg6ZjR9bupAsL8n5qJsJo0awro35rN/wgN0jlIhBTK/ f5Mp81YweMorPDrkNmLD/BCcZs78tptHh/bjhcmzGdrnS5rfOpyX8y/S66nFdB80jqkPdsLpFBFk muvK0bWF2Nn3+dsMP725Xs1REVGupVmnfjw7sg9hKV2Zt+AV8u57iDnTnyMxPoE7M/z5fvkCXl2z lf5PzmPmE3fjAThFCUq1B+BBTFp7Hhx2J/Hhgcic5fzwydvMfPEN3l6xirZt04nQNtQyG1+tfJMX 311Ht3vHMuXxEUQGGDAXX2bNay8wY+nbvJqSytwJDxGglYBUjsHozcHfdhEWdAvDH59KQlQwtnIz bVskcWbXap59fglxfR/m6f/cT3pcKEqpk8vnjjLhwQEsfn4Od/VqQ0aELxKZEqNezfE96/G7+Vae nj6a8CBvLKVm4jyVTcv+WkmvBcHJ8peeIzNPzvwV0/CV1/Z6q3JBkKDwjaN7Rigf7PmF00Cke2d3 ww033HDj/7F33uFVFVv//+x9eknvpPdKEiD03ouoIEVBsesV9YoFUbGgYsV2rYi9d0VUUFSagtI7 0msghZDeTp/fH+fkpBICeN/33t+7v8/DA5w9e8qaNbPnO2vNGgUKFChQoOBcCLr73LSTg799yy97 y7hk1otcMaaf93lY+CQert3J9xPmsuCzJYx6dKqbxAgXyCZGXjmLlx6YgqGpl/WZzk63Cxc2Ab1H TGbuPdNpuHQsNSWA9b//zLIPdpFfeByIw2jyIyE2Eg0yEdEJZCU1v2f022+/YdO+EiaMzMLgrGTj 2tW4BBjMfnSKTUCc+pANB/IZMzAbnQQOu4X4nuOZ++Rc+neObJZXjXBht1noPv5aHrjnLoIMDU/S mDCiB7/s+JHthXX0jQtCJcOHL71CuT6GXllxnDq+j+Kje9wbGzotKclxLF20mLWFVsbHRpKd5C4r LDqFzMyss5ZjbVkJ+/ZJOF2u5u9qffFLrvD8IJPa6wIeefgerp1+Pw/fP4vSyd1Z8OInxA69gcfv vR6/JtrhdNgwxWQw7aZZTBwQ5f092uxgxx8/8/3mTWzddYy4njGte7BgO7/8shxVdB+m33gTPbI8 aYKDuXP2naxeu56FixZz5YSRhOfEAuCwWYjpNoqH5j7FiLy4Zvm9+M5bHKjUMKVzCvaKE6z94whC gMHsS0JiIvUrf2bd0XJy40JAAqfDTuaYK3nuuXtIjzrLc/0NHiVA8ZYfeOK9FaSOvIkbRqcDzQPG NPxTo9LQvVtX3tq4lu1HIT5WYegKFChQoECBAgUKFCg4B4IO4HIJNv+5BVQ6+g8d3sBTPC7SLuJ7 jiSCR9m2fgvQQNAF6A1kdO2NQW4R7fJ83IMEuCQVZqOvm5x77700YfINBJsNW5OrQhweq3Hr60Oc 7NlXQGVVNSsWfcCulV/hcLo8gdtk6qtOIWRw2FzYAb0nj7iMriRFh3rb2PLqsqCQSCSnHdB4nweH R6MC6ursnsBnp/hjcwGy04/Xn3qo1YHkqlNlGA0aKivtILRey7fTYW+xe9IROcrkXnQVb995GbUW W4v3VZj8m7RFpWPgJTfwyJGj3PPkfO7ZvZa41KG8+vRs4gM0zdorAK1eh06nbSYLc0QYqZnpvPfX MYpKCoHWBP3YwaMcPXqC9C4XEBUZ1VyfgrNJT0xi4Zf7KCkpBdwE3el0EJOaS0psRAvZW9i8oxCH tZqv3voXS/QaXC6PSCWJ2vJitBLU1tpp2J5wOR0k5/QhPsyndT+eQabuc2cCCQsvPfIQBfUhvPfo ffjSVswY93/UKpnETuE4HDZK8msg1qzMNAoUKFCgQIECBQoUKDg3go4QlFXXI0lgDvBp4DEeUiUj NH74q6C0zNKElrjfc3guWf87zzVJCFzC1YJQyUiSfBbEv57qeit2TSfGjJ/CgJwELLZGAizLKhAu Urt3wwdweQik027H7nAAmjbvanU5Hc2ChAHIkhqJptd/1lBWC3KnDG66+Rq0GnWz8+EqtQa1LNM1 RufdlDi3vQwBqPCPiCUxJe306TxlCwFqYyCDL5pAwFPz2XviKAPG/4OeSUGNDLrFey6PVd4rC50a tUELTidO4WqzvJp6O3UWO75mAxq93EKfdJgNOrBasFkczaiuW/bOFvpUR0WdHadPPFOuvJb4iEAc zsZyZZUaSQiyc6PRAhZPYQ67FYfDBRr5LCP0u2uzf9kHzP9+O10nzeHSHjG0tJ431woJvUGLcAls 9XZlllGgQIECBQoUKFCgQMF5EHRJIiLQB+ESlBeVALFN+JoL2VpCsRMCw83nwyfPH21ExxYemtr4 oKHiZkL9dWCvJrPPUMaP6tZu1udzO6jUMjgbQcQGuthdUc+oaVcQ2l6ThEDQQILlcyrf5XScgXQ2 RJYHS2Uhn772MuVqXzrnRPPb91/x3piRXD06t02S3vB/rxW6vJbSwlOYfAMJ8gluszx/sx5fk56q iiqstTYI0DbJupbymjowmdAZNR1onT+RASrYVUOfsZPolxjcvoqcr3IKAa5TPP7QE1SoY5g755/o af/GFSEEdbUWJFlCb9Ips4wCBQoUKFCgQIECBQo6hDYZoCzL5A3tAy4bPy76uoGzey3XW378kjJk evbpdR68R3iJvV6nRa2S3QG2dLqzYlYtU6n0GtSSjWqrpYHmep91796ZGFMFr81/j11Fda3yOrJt E8dLSv4NGw4+XDCqK5xax31PfEpbduatq5ZT4XKXrPd1u5GfqChpRRY7IhaVVndG2UuShMtazXdv zhXdkU8AACAASURBVOX5L1YxesazvPL4PcS7djHn4UdYvudUcwuxEKhUKkwmk5fkA2zbsI5FS9aT lZVFbnZym+VFpSeRkBjH1jW/cfDokWb6ZDm0lu1/7SQ0M4uIsLAOdLbMkMFdMNoP8fizb3OyjZ2U 3X+u5mRtXYvePzcdRZJY++WLfP7HMYZeM4vRGUHec+mn00aH08Xe/Hy0aj0RcUZlllGgQIECBQoU KFCgQEGHoG6LYkiyTGTexVzV70ne//gZZncOYeqoPviorWxY+T2PznkP3/je3Dlt5DkXLEkSOG2U lxSxZs06TpTWYK+V2Lb2N1IMcUQlxHIutse4mDiio3R88eG7RAdqSQuSsGmC6NW7H4MnXcuUZat5 5pMFXF1TxGUTxpASG4al6iRbNvzB99+sZfbbC7h0aMjffqXG1FlP8MWyi3ln7h3UHNzIqKG9CPEz UFpwiD9+/53ffzvCov3r8VeDf2ZvwoBlH7/Iq6l6Yv1lCo/XcOlN09qN5O52/rdzZONKvvxc28yF 38PcCUvozIheGSBsbPzpfe5/6mNiB1zLE/fdQCddHffO2sn1t8/jkUeTiZ0/j0RPTDW1RkfpvrW8 9Pjd5I/qT7Cvhvx9W/n4vbfJ18Tx2LQrSAs8TcUCMrn4opH88NvTPDr3UVx33UKPtEjKC/fyxjOP 8fP2au585mKykzudQWncZvexN9zNuF828smbj3FF8X7GjR1MTJg/1aUn2PDnapZ8t4U3Vv9ESPz5 kGOPibzuMA/OmY8lIJ3HZl/luSO97XPrDVZ1u9PKurUb0QV0pmsnZZJRoECBgv98CM8c3jTOjHJH uAJlDChjQIGC/wCC3sAyNOZoHvrXAmpn3sOTd97A1wuSMagcnDh6BENMP1557mm6Ruq9g9pRXwv1 5dTbnB0v3VLGb58/z5TZb1FfVwvAw7dNZtPUaTz/5rNE447mXW53UVNraTWRWOtrETUVWGyNLt1p fS7g5ltv4eFnFnD/LWsxGrT0vPBGEtK7EJUUxx2PvkBw7Hw+/OpH5t73C7LK7USgMfgQn9Gf6PAw ZEA4bFSW16CvteBqw+QtHFbKK+1U11lxtbBq2yy12IB6u9NrjQ9MHsRr73/E/PnzWfTD+yz95l1U MghkTP5hdBs0jiAVIIE2PI/nn7iFe55+kxk3XkOA2UhARC8uuWlau+J0Otwy2rroXa7+5bNm1nYh XAhdAAOnzmZErwx2rvqK626aSVlQH96d9yCd9ABGLrj8Fu7atZMHX3+GO/wDefulewlRSd7jDfm7 N/HCxh8oOFmOzQHxWb14Ys7dTBvbx1uW3VpPubBRV2/1/jbisuk8XlbJIy98wPVTVxAbFULVyWMU V+uYevsjTL/iAvy0DQ2xUVlRjlRTh7OZcCWEAH14Do+/8hYJC17js+8XM3v518gqCYSEzhxAWt4I ws0mJMBlt1BhEdTU287SM0JCwsUHc+/k131lTHjoVXrFmNuxnuM5WO/EcnwDP24+RdqkwYQ1Ze4K FChQ8D+95D7LBfbfkV60N0/+x8J9m8fe9Ss4UKqi36Ce+Bl0/33963KB3Ogc6RICWfn+KDiLMXBw 82r2FDno2b8HwT7Gc9bLlnPAf+e8oEDBfwhBbzyfLJHQbSzPvRbGxPWb+WvfYWodauKS08jr1p3u XVJpON8taU3kXjaTz7OnkNMjquOla33JGTyRV17titGgQ5bAarESGpNEgCdJRr+xfPhlBIHJXVq+ zIVX30Fkn6lkd8/xDn7ZHMbE62eS1n04R4vKcAiJqMRMEiPctuewxBxuvmcuw8ZdztHjxdTUW1Bp 9ASFhBMdl0BclPuEuCZtEG99/g268ExCvcyxEYbs0Xy+8EsC4vPwNTQXY59JM/gqZQyZ3SLQyO7N BIFEVv8LeTg+nSkHDlFYXIbN4URrMBPeKYqY+AQCZPcEiWxg8m1ziOk5lhPFZThRERAS2/496LKW yC6X8fHHqahUEk5nG7sKKi1hce5r20Lju/DAs28TlpxNv5RAb3R8fUA00x/8F6n9p2AOT3BflycE Tocd3+g0rr3rcbpFWDhRUoXO6EtscjoZqYkYNY160/2CK/kqogex2XneTR+tbySXTX+QtO7D2bh5 J/nF5ZgCw8js3IV+fXsREWjy6pM6sQ8vf7AQgpKJDNS1+HwIhJCIy+7HzIfjuHDqfo4XllBvtaPW GggN70R0fAKxgW5pmbtdzMKvYghP641Be7Zn+iVyR9/A510vp+ugsZ5todNZz91td9gdLPloPkUO H+695sp231GgQIGCf/uS27NxWHXoV66863XUMtgcLTfSBaj0xPa8hJfvnXL2+Vur2bb6Z37YWsSY cZfRJTHov1ZeS16fyytrjXy37P3/CoLu9kasYduKb3lraSHPPnM3lqLDfP3Vx9hiBnPTRX2VQaDg rLDs/ed4ZmkN7y96h+BU4znrZf3hjTz/0RKyBk3mwr6pyLKyElKg4JwJuocieo1+MendiUnvjqWu FrtLxsds8H7Q3RZagaTWEJaWx+S0vA7vkgkhQGMkLrsf12b3aysBAgiKSmDMxITGdyQJSQgEKhIz u5GY2YQgef42B0bQa3AEvdoqEwmjXwi5PULI7XH6uqkCoxkxNroVAWv4tzoknrHj4ls9F0LQKbUr E1K7NpOThJsAh0QlERKV1K5cJElCbQqh35BRbcik9Z3dbrmoMIemMXVq2hk7XQhBaGw6l8amN5N1 A0kP6pTMpKmN58ldLo9MdEYSMrsxMC/wNPV2/x2RmMlFno7xRqsXAqNfKH2GXkSfwWOoqbWgMZjQ qaVW+iQHRDJkTGSbsvf2v5DwC4miR0gUPdpppzY8iXETktrOq30pIYRE9oAxZJ/h3cbfBdWHV/PE /J9J7HcFVw+NbaiyAgUKFPzvQQispXtYtOhbZJ9gshMicTV3sUKoDWgSKs4tf0s1O1Ys5PmPdxHV efh/NUEvOXaAQ7vN1Duc/w0dC0hYK8r4/ael/HYgHB1wNH8/P372Cbm3XazovoKzxqnjhziwt4pa q+288qk7tJFnn5nHpepsLuiTgqyYKhQoOD+C3uAu1ZSQ6I0m9C0Iyek9fc88CM+Ypg0Xu/burm54 Jp1Pme2ka/pbe8/buorNW+1zLLs9mZxNu06bvoPujEIIHHZbu3m2zrqNs0yyGrOPuRXB7bA+dbC+ Z+rHM7zdbluaLmy9Ca0lzJk5kz21gbz35Bz8JMWlS4ECBf8ZkGT3577LuGv59P5rsNodzYieQEbv G3IWnL/J9aJqNZLDSnVNHZKkaTVHitPMqS3zav3NoM0N6bZcZ9vLv2k9zjQfyyo1aNRIHW17G3Vr WcfT/X76erbTFs9GetMVT2VVJbsP7mfoyOvcBKvgAPlV/twzunO7cmtJ9lueP25bfrQ+p9zG+ubM G9rt1+NM3+uzkulp6tiyPmfK64xldUDHGtZBdKAszjBumo8vOqhbHRgDajXI6nOWRcMzneykuroW u0NyB4LuUI+coV3ndGTw9GU1N/x1pO/whChS3PcV/G8Q9DMMdkUJ/49BOLHUVFFR4cDmOPcY9/9f 6pMkISGwVOQz56ZpvPzDVq5+4jMu7xtDm/cAKlCgQMH/IsyhUSSnprW7lMVhp+TQDv7Yd5IuvYcS IRXw9cIfOHCiFFNwNAOGjCIvLQIAh7We/Rv/YPWuY2CrYf2qxYTYYqitd9EpNole3bO818XUl53g pyWL2b7vCFa0JKR1Y+SwwUSHmr0L76JDf7F5237iu/QhPS6EokN/sWn7brQhsXTJziLYR3+ab4iN vVu3sHXnTo4dL6Sisg692Z/YlEwuGDOCIJPGc0SqIwtpGT9/M0e2rWbpij8oLLMSGpfKpCmTCTE0 frMqj+1i5eZ9JOQOJTPWx3vWW5Ik9m9dxa4jVfQcOZYIQ3MiWXZoC4t+/o1DhaX4Bnaia6/++NmO UFTrz6hRfdtdmAlJQhIu7JZaikoq0Ghl/tqxke27i5l8QwSlR7ayYc06Kn0TCHBUUlRkwewfiFmv 6RA5F7Zq1q38mVXrd1FpgaikDEaNGk5CuJ/3iJkkwYm9W9myK5/03v1JjPAnf+82tv21H0NEEl07 pxPQxhWjXhmIOtYtX8YfG7ZTUl2Pf0gnklIyGNi/F0E+eqQm384NK79nzbrtFFfaCIuOZ+jYcXSO 9m9Gzq2F+1m6bidxXYaR3cnG9199z/YDx9D6hDJg7ER6JgUjAbv/WMryP7dSUmsnKj6LSZePw09u veFScWwni376lQNHihFGX7Ky8hg9djh+6nY2BJpurAgr65b+wOotuzlVayMwKJz0zjn06JFHqK+u mdfd/s2rWLriD06cqsYUGE6f/kPo36szGkny9ImDE4f2sn79Jo6eKOBUaRUqnYmo+BSGDBtKYqdA t7yQcFWXsGHTZmp0nejfuzPq2lOsW7+J42U2uvTqSUJkqDvGUv0pVq5YwYZtu6iuh7DIeHoNHEK3 1OgmSxYJHz8/Sk/sZOlPKzl4vAxTSCQXT5xCYqix3c0RSZIoOfwXS3/bChIc2bWGr752opIlhGRm 5EXDMEqNy6O1v3zLH5t3cLK8jsDIOHr2HsbAvET3lcWShMNuZeOviynVxHDBsDywVfL7ytWUWSE5 tzcpITrWLvsJi18qw/plseHXr1m1YTdW2URu70FcMMB9RLb08HYWLVlOfkklgVEpDB0xmowYf8+t Uu6+c1oqWL10CWt37qfS4iI4tBOdc/PI65pNgEnj3R8oOrSXLZs3oeuUSU52Z4LMsvJxUfD3YuL0 50WPK98XChScDi5LjTi4ba34ZdWforDcogiktYSE3VIl1i3/SSxZukzkV9jcv7pcimgUKFDwt2HZ smVi27ZtYseOHa3+TJ/9uhh811ox6NIHxYIv/mz+otMuSja8IkASg2e9dobZTAhnXaX4/bVZIio+ VUy9doYYmJMgzHqd0OnUAo1R5A27RHzyx2EhhBBVhYfEUzdeKACBJAuTj58IDgoURnO4uPTGOcIu hBDCLrYu/0KM6JklOnWKFrl5PUSXzimiU1iI6Dr8CrFozW5v+Ss+fFb0SO4s7rz/SfHsnFtEVmK0 8DXqRJdRV4kVW4+evuL23eKGyUOEVqMTIeGRIj4hXnQK8Rd+gSGix4hp4s+9J4TL28LT4/6RiUJl iBPXTRsvMhMihMFgEBIIg2+w6DXmKrHnVL03h11fzROJcdHi8U/3CIezeb4L7h8vYuMyxM9Fzma/ r/pwrsjLTBJGnUGERkSKiLAQERQRK1KSk0Ru3ytFXUcUwVkttv/8gggKDhdJyUkiPjZSaEAERiaK lMQ4ER7kJ5ANIj4hVuQNGC0+XLq9/T73fKtOHdwiHrzuQhEeGiRCwzuJ+JgoERQYJDJ6jRGf/LS+ iYYIsfjVB0Ruclfx0OPPikfvvlZkxEcKH6NO9Lh4uli/p+A0miWEvXSfePDmS0VUaIiIT0oV2TlZ Ijw4QPj6BoiJd74gCkur3cnrC8Ujt14uEiL8RGhEjEhKShT+PmaRmN5DPP/NWuF0Nsr11K8LRFpS gph0zZ1idJ8c4edjEnqdSqA2itTcgeLTn34TD940USREBAm9Xi8kCeEbEi3GXP2QqHULwJvX8g/n iq4pcSI8MkH07NlD5HZOEcFBIWLY5Oli+0m7aJG8iQzdf1cUHxQPXTtaRIeHiE5xySI3N0tEhgUJ k0+4mHLTQ6LMk762LF+89uC1IiEqUsQmpIvePfNEckKUCItMEP+c+7ooaFAEV4F4be51Qi2rRUBw mIiLjxdREcHC399fpPe6QHz68wZvHRwH1oh/XNxfjLl8pnj6scfExYPzRHhIoFDJweKFz34WQgiR v+FHccOEoSIo0F+ER8aIpLgY4W92y/jFReuESwjx9KV5QqeLEdddO1X0yk0SviaTkEFoTb4io894 sfZIqXCeYSz9/tZDIjzQVwBCazCJwKAgERQUKPzDe4sjVqf7zaoj4o5pY0RkaKhI79xF9OzZTSRF B4vIpBxxx3NfefOqrTolbuwZJdL7Xit+WjhfDM7LEGHBASIsKkHc98Yvoq70mJjWtZNIz7tQzLh+ nAgP8hFqnVbIsixiMvuImU+8Ib5a8LDoHB8hDDqN0GjUQqXzEcMn3yBWH6j0lnNi30Zx++SBIiIs REQnpYnszukiLDhAmHyjxIxHXhPVTefiD18S3UO1YvRVD4iNR+zKx0nBWWP79u2irKxMVFRUiIqK ClFSUiJOnDghTpw4IVavXi3UyhaFgnaN50Ig6UwkZPckQXHlOe2uuVrnQ4/BI1tbChQoUKDgP2fC 4tiGZbz5hoy95RlrWU1gfBcuG9kdIZzUV5Rw/PBeFlsE4ydOYcbjA/HTWln/8xc88OyHvB6UyuTe T2AKimDC1dMpOHmK+SuOccNdcxjXL55ai4uwyFjUwIHNq7j/7lkUGjJ5dsHdpEf5I0tOdq5ayLzn X+G5l0NJSZ5HWoiKuqoqig/u4MXnnyYzM4OeoyZzWbgPptBEIvwNp2+ay8TwS66j3/hbiIuOwKjX IssSW79/nVnPfMBL7w3k+XumEd5G0NeW1nN1/UFWbY1i4g330y83BZPGwbevPcyL33zA/S8P4qPZ l6PXarBVl3LwSD6lVbZmt6YAVJQc5+iRQ9R6vM6EcFG46RtunPk0x0UCL3zwBZmRATht9Rz8ax2P 3v0AhXVxuDrkuaUnuvNo3norEXtVMd9+9j47ci7ktZmXsWP9Kj5+cwGXzlrAmM4m0PqQkhHdrk5I koSrMp8PX5/H05+sYey0W7jt6gsxawQHNvzI08+8wt0PPE1Q8LOM6BYHQE1FOcUHNvPUk0fIyMyi /0WXExNswBSRTrCvri3TP0jw9RvP8PLbPzBuxgNccfFgAvQq6msq2bLyO7bUu3A43Ecv3nh0Fk+9 8jHD/vEQN00aSoivnsqC3dz7z9t45JbrSU1azoisENQSOGsrOHz4MHtPvM+oiyfx2p2PExag5+i6 L7lh9gLunn41Kl0gl9/5JANz4sFWwUuzZ7D4k5f54vpbubpvCMLl5PDqT7lx5lOE9P8HH902iSAf PU5bDTv/+IEZs57h3pA0Fr9ym9di3dxqDMJSwdqFC3jus98ZdtVs7rtuBBpJUFNRwsZVyzlSXk8t EGAp5Yf3nmPuW0sZevmd3DJ5EEadCmtVIZ+++SJvvvAUEdEJ3HfVcHBqye5zIS8uGExGahwmgx61 Wubgn98x96l/8eKCj8lIyyA72oiw1VNacpIli15gc0wiXbr34MbbxuOsrqdrWjw1xTt5ZO7DvPPT Uabf/SCXjOqDWQNVJUf5dMGzlFbWUg9IkgqN9RiLlm9j4uRrmTW3C4FmNUten8u8zxfy2nsTeGnm JPxMpx9LGSOn8fLJEqbcP5+Bl9zO7VP7olK5LeghagkJJ0/dfh0LFu/mgSdfYXBuPAatiuqyQj6a dxevPnkPfQcMYEKeu2+Kjhxnd/Hn/KNwFZld+zJ9XBpGrURyajg2q5XCQwXsrijD5DOae+e9TU5C EPl7NvHMIw/x3Ny9pCZG0uvif/DEqH4YXBX89NkCnv3gc6Izh9D3ocugppCln7zCm0v3Mmn6A9w8 uT8ql5OqskJWLl6MU2WhDmg4nFlxsoCtJ21E7DtKrUUonxYFigVdgQIFChQoUCzo52JBRwBCluXm fyRJSFqzyJ74sDt5bbn4+clrBGofceu8L0VZdaNd9/juP8SwNK2IyuovNjc4VNUUiY/unSR0oani /Z8PNi/bUizeeeQq0SkpT3y+7mRLU7B4+d6pwi8qV7z9q9vKu+S1OSIKxKBJt4oVW/aKU2WVoq6u VtTU1gqb3XF6K7DTJuxNDHonjx8RO3fuEr8velGkRZpFwvCbxF9HS84o4/tHJgpUMeKjX/4UFZbG 8moKN4neYXohhQwURypqhBBCbHlvtlCDmPnmdmF3NLcmPnNTLwFm8e1xdx4Oh108OS1XgFG8snRn M9tjfWWBuChBEr4xI0XNGerncrmavVuWv1vMmNhTzHz9NyGEEJt+flv0ye4l1tW0bSU/jWFbbF/+ qejZSS26XXC92FnaVM4O8cHTt4oAtSxufvIdt8VZCPHlk7eKEBAXXHOPWL19vygtrxR1dTWiprZW 2Nvpp9vHdhMQI5a28Iaw15aL/IJiYXMKIU78JnJj/UWnnpPE5gPFzdJt++pRYZARo++eL6rrrEII IYq/e0bo1ZIYcePTYt+xJjpmKRAjo9QCKUZ8t2GXqLI0Wt3/fP12AYgbnv5BCCGEzVIjHpyYJowp F4pTzpa1rhUzx+UKc2QXsbMdY2ltSb6Yd/0goQpMFO+sPNXsmbWmQhQcPy4cQogjW5eJsXkxYtC0 h1vlUbj9VzEwNUwMmXa3KPbIv6l3RuXJArH7r7/E2l8+FBf2TRL+6cPEt2v2eZxIlolJvZOFMbqH eP7d78SxwpOiprZO1FRVCSGE+P7lGSJYhZgy6yWRX9W8j04e3y+Ol7ityU9NzhOyFCxe/GyxOFnd 6DVp2fe1iAsyiPBRN4uC0sozemRULXtVaGTEdXO/bZWmeueXIkiHuOnFZa2e1R1eIvxAXDjnA/fY qygW4zohdAEZ4t0la8SxE8WiprZO1NXWiHqrXZQc2yOGBSFCM8aIrfnF3nnAUX5CvHDdYIE2QPzz ic9EpUdfhBBi2/IvRJIO0efCfwq7EKL6yHZx+0U5wjexr/huS/PBU1teIoqKioS1yW8n9u8Siz5+ Vyz9bZM4Va14SypQLOgKFChQoECBgnNE9oSbefW2yS2CxAGyCnNwbFPDKuj0JKZ1JcBsoCHQksE3 jJSEOLYdqKGiGtCBsNvdV7cJgd1mbZZtZUEhO7fuoeDATh68bhTP6iWcLs+VmmrB8QN7qLSFUFBU BHQGXNjQ0qVHPwblprThtHSa+5VlDUU7/+CN1xfw8x9bKC4tp67egtNlp7S0hshUCw5nByKzCxeo AuiclYKfTuXJH0zhXRnUL5Y/v97MrlI7MX6cRUxqgXCe4rvFW9ElXsyVIzKbBeJ1SRq0ahnOEONF tHHnfHlpPrv2lDHjmf5AFYd2/EVdeA96mNqXWaPp1/3XwX372Fag4arpA8kMVNF4Ll1F954DSI96 h+3b9nDkFGQEu+Vkw0SvfgPp2zmpQ/0EkBwfhY5NPDj7fg5MupCeeblkZ6WgMfoT5bnRa+eatRw7 WcGQaZcSHxHULL/s8VPIDJ7HiiW/UX//NMwGrfd5TEpXEqNCvH0m6SJIiDJBiR9d8zLw8fwOgjSP blVXlQLgsBTzw5I91ItTjOnTE4d3fEgIl5Pj+7dTL3zZXwSZp7lN2GA0kJSSirNsJa88cTtS0URy OmeRmZGI1uRHhMkPgOP5R9mw8Rh1x96lV+8fsdvs7pJkFdaacnbtLSYnsYiCGgg1q6gpPsAHr7/M Vz/9zvGTpdTW1eNw2qksq8CcFYPV0TjmHA4b0WldGThwMNHh5qYuJvyxZgenXLGMHd6fKJ+mfSwR EtnkthtcuKQAcnKyCDHrGqeD5G6EGkzsrKzA5Tq9r0dDv1vt7nY5HXYcTlezQHHrf1lJqRW+e+l2 Nn6gbX6rhKuWSmDHnr3N9FQXlMZlo/vQMgpFteddg180OZ6rkgFUGi0JSbFIur0kpKbha9B6Y12Y g8KIjpCoqq2iBvAP8Cc+IZGq777h+cfuovryi8junEVmUgxG/2CMHh1rCHjZKSmDi5IyOjbGFCg4 DVQqlVdvZFlGlmXvGFIIugIFChQoUPB/AhKB8en0GzCwo7wSh9cVvjFuuE5tcK/YO+CPXV1XT+Gp MswRkfQcMopIgx1nk/fkQcPQBscwqHNiY6GSqvHO5BZRm6XWYd2RJIlDf3zFrNlzWLy5lL5DhzP+ qt7Ex8QQaSjmtltmU+BwdpxRCxf2JhsYDS7NEdEhSOylqNqJaIvltpelrZT8MvDNjMOnSb29xLsj vSdJ4LRx8sh2vl+1E4PWxYEtK9lV5GLP6oWU/HCIH3/6A5tI4MsvPkPS+pDTvT/Jkb5nyNlKVWUl FnwJCg1oJXZ/vwCCggM5fKqS6gorBOs8lE2N92rrDvQTksS0ux+hwAIvfvgpM5Z9Q0hwMP6BwXTt O5r7H5hJeqQ/x4tLsdsgJqETslrlzU8IkORoIv00bCwowdaCJDodDhxOF1q17K2KRqcG4cRmF6CR vNfBqgxqL/EEcFlPcawO/DJTGT64P7YWmzmqUaPxCQgi3dxO/xgD6T/pFu7dfYxXPvqI61YtJCwk mODQCPIGjOXW226ha7wfNdXlnASysnIZ2TuTeg9Bd7dTZsyFLlK69iPaCGUH1vPEQzOZ/91OUrv1 ZdpN00hNjCfSt57Xn3+W7w7aWo1ZjVrt1alGZ/wKSipqITCCIE+gxXaj9iOajQE3dOiRkFxwvk7d hwtPAtC531CyQzWt5qkxFxkIy2o+T0kqjTvg5GkiuQuXCxd4g1IigVojN7+BqOE1GVQGd9A3F4Bv FOOuu4Pd+Sd579sFrF7yCWEhQQSHRTFg9KXc8o+rSO3k45FryyMOiou7gnP4GksSR48ebbK55vAe 8amqqlIIugIFChQoUPB/AwKX03HW75xVshYLZ61ahV4NfqHxTLzqDkal66m3NSc/kqxGr9e34HOi zfzaWOUAsPCjT/hm1TFmPfca068YS6ifCYNOC+wj2N/ECeE6b+lZrHUI1PjpPVfR4rl2qSNZSyq0 QFWd9fwq4bJRvH8Dry/4EKMWCo4dpAo1P30wn9pTJzmw/wCGGDvzXztGQHQ6xqicDhB0NWq1BnBg szhbbTk4HA7sdgcqjRqVhzC30o0z9pObV/lE53Dn3FeZ/I9Z7Nu1i63bt7Nm2WK+fPc5dp60s+Sd xzDqdMgyWGpsCFcTMiQB2Km3CtBqO3CvtvBsrrRdn2YbT1o9PkC1IZWHnniE+qr6Vq/IsgqDRdZ2 ygAAIABJREFU6TQleTZcgmIzuffpN5h442EO7dvN5k2bWb36N97/1xyOFxSz4MOXMBs0aFCR1HkI jzz2Tyorq1r3iFaPSYYfVv7M25+uYch1D/D8Y7fTyc+A0aBHophfvvwA577KNuQsGlwFmkjIgF6j gaoKbB4SIDXZPBFnuL5W8srzLC6n8YhetPGCn9Ftme8x4lpmjY3F2WqTSkKt1bfa5BFwVrfjePu/ RX/T6vpjieiMXjz2ykdce8ch9u/5i82bNrFixQpenXsXJeVVPPnUbOKMUhsbapJC0hWcE5xNNgIl SUKtVnvmGlkh6AoUKFCgQMH/Gfwb3DAlCWSVhEsIXC2IcGhoIBkZiby7YCfbtu/goq6D0bYV603Y AdU51qCcfUeLEH6pDOrXk1iPFbiBfKpk6ezWz5KESiW1IC8O1q85Cj5dyAnRIgFaz/K+rq4cd/JG MqnTNr92SdJGkJUAPx5YxV47pGoa+8FkNqPGRYdM/GoDib0u4f33hlBy7C9efWIWg4c/wiPTcln2 3fvMmedg3sdfk62rQWj0hEaEdqDBKkIjwgmXSjl+9AA2QCs1GioLCw5z9GARiX3DCIs8x2VjE/kH hkUSGBZJ59zujLioBvs9M5k1fgjvfPMl+564g+zOcegNGjZvXY9w9AKaXE1W+Cf7quqJ7B6PXv33 XW2l0kaSl65h0YFVLDssMzrBr810dgTeC+HbVB0Zv5AouoVE0bV7L0ZdPJmTB7Yz/9E7mf/7ctZu LKRHp3jSfJ3s37WJPTUSaX5+p6lVHYUFJ6gglB79+pEcHtCsz1RqGURHFdtARlondN+vZt3eAob3 zUIvSd67v6Wz78YzQla70zudDvcYbIKevToD8P3Cb3h06pzTFGb9H5kSRZONwqDwWILCY+nWow9j J17B9dtWMfe+O1m2fAU7/7qWuLxw97EUpxOH04EsqVCpVYp7u4JzQgMhbzV2ZBnl4j4FChQoUKDg /whcdhsIF1artdUfW0fOaLcFs5GA2Ejspw6z6rflnh+dVJSVQkAifYePJ1l3nBcev5cXPlpKjacY S0URP3zwL+6+935+XHvoPFrlR5CfESp3snl/fuPCu6aAVx+cy8Zdh5A1HSSWkgS2KkqqXN7/S8A3 L8zgx+2lDLviBsI91r/otDgkAYu/fodSl+Qh2HUsevtxXv5kS9NMkWUTl116EfbK3dw5/VH2FpRj tdSwc90vzJ4+lYX7BWfim0IIhKTC6B9GRnoq0RFmyk46GTL+UiKiw9HWWjEk92dCbgzJ6RmkJCXg b9K270LveZST24XB/eL55vNP+HzZLkBCkiQcZfv4+KMP2e2Ipl+PnkRrzn0XR5KqeOnZf7Hwl03u n1QafP0DCArphCTLoDWhFQ4Ce01gQHoE6z55gc/W7PW8LgFWHn1wHkcqrFw5bSoGvf5vo2carQ8z 7p6BveIgt0ydwMIVO2gYDWWF+/lo/rNMm3ANVUhtknNJkqgqLebzt17ki2VbvO3z8fMnMSkejasO WSUh63xJzOjM1Kkj2fnrB9x200zW7yny5nN411oevv2fPD7vNcCIr68fKorYvXs3XrrqqmHh6y/x xbcrUBk6IANP/18yZQLZcQE899As3vjiV+wejS07uoOnbr+Cl79fhxVQ/U1kMzAlHq0Llv/4JYcr 3eOpvLgAq0sQOeAKLssJZuvC55g28zn2nmjwBHCwa92vPH73DTz8xi//I3OiCijN38+Hb77KknVu fZM1Onz9/IiNjUTlqkOl1aAx+HjfWf3VW4zKjGbKjKfZnu9UPiwKzm32aWduVizoChQoUKBAwf/3 CwG3W+uatx4jafHrzYMyIUBtJHX4jfz46gwQApfDBvUWHE7RarFvt1mwWFW4Gh6pAsnoPpKBsfP5 eN5M/lz4ErZ6iUEXXs67rz1E75GTef6FYu6a/SR3XjWeFx+KRK+VsdbXciL/BPG9xjJ0stus7nQ4 sIj61tfAtQuZyy+fwHcrNjDnxkl8M78zZtnG8cOH0Pj5UlYP/jZ7h856O2wO4BiTBnYjIz2DiEAj hccOsmPzTox5lzJv1iUYdW6W6tP9EqbkzeGD1R/SI3srUcEmSgqOU1QjCNGrAItXRpKs4oLbnuKK 5Zv56O05bFn6Dno11NVUoQlJJjpQTekZOW4T4uSo4tjWNey2xTM0U0X50QLW7thOWu9pjaTMk75d 657ktvqHpPdj+m0z2HnbfVw7YSSfDOxFmA/s2ryOjXvLufSfDzPtkqHe15x2OxYs2J1n109rFn3M jw8+xAOZ2eRmpuOrF+zZ9gcr1x1gyv1vktQpBNAx74V5/HXJddx12XA+69WXxHAje3dsZM2mvfSb 9hDTx+Si07h3NITLgdUJdkfrw9F2qwVsllaWX+Fyjweb3V1/WaWh+4S7efNYJf98+E0uH/8nESH+ qGWor63i5MkywtLGoGundU5rHRt/+pxnFz/ME1lZZGZl4KuxsXPjajbuOcmI6+YwtpsJMHHVHXMp LLPw4sfPseHnTwkJMIPLSXVFCUWnnFw18xEA+g8cwsV5n/PpvJnsWP4pwWYtJ/MPYZVkSqqdOM02 nA1n8YULm9WC1WZvHJvgdcwI6zKRZ54u4uY7H+Tuq8fxwuxO6NQStZWlHC8q5f6u16AGd6BHl7XF HOGeJ2xWC/VWW8dM6THDuG1sKk/98DX9c1Mw62RqrBGs2beSOEMnnvvoCxw3XMdHz93NL5+9hK/J gHDaqCov5VS1nZmvXurNymaBerXttCTHagGL1d6qvk6H3TOPuVr0vwur1YbFakMCHLWVLP/yLT64 Yw5dc3LIyEhB56xiy5+r2HbcxXX3XsagzMbzDWVF+Ww4UEJ45EGqlGvWFPw7No4yuo98uNJu5Ibx OYo0zmHno81osoqriwJlDCjCUaDgb8bhw4cxGo1tjq8NO/M55QyHqv10zkimW7NQ0wKXvY6jp1x0 zUqjU2QU0dHRTf7EEB0TR0pWHsN6pYMQWOtrqDNHMHTYcJI7NUbGcrkc1NXWEhyXxZAhgwjxMBa/ sGj6DBxEZLAPGr0vKVldGD5qFLlpcaDWE5+Zx+gLRtMtKx693khAcBiZub249ta7uGvGjXRJ6oRG LWOprULIfvQZOoyspMiOTEIgSYQmZtM9OwFb9SmOHjmBS+3DgIuvYe59/yAqJJCkrDyG9srF19S+ xbGypBCf5MFMHZlD+ckC9h/Jx6nxZ8zVt/Pi43eRkxCGLDVEjjfSb+gg1I4ajh8/SpVVIi1vCE89 8xx9U/0xh6Qw8sKxRBjc1midOZh+w8eQkxSJrNETnZDOhVNv4sG7b2TPwvkcUHdj9j8ndsjR32mt p/B4EabkPlzYO5PamkpOlZTRf9REUiL9EUgdPM0geeZsmajkHPr26opZVLJ330HyiyoIisvl9vvm cNdNlxHh10hP66srkLQhDBw+jJTYsA5qsJauXdII9NFQUXqSw0cOUlhchk9oGjMeepLbpl1IuL8R SQL/qFRGjRyE3lHN0cOHOHSsGENQNP+Y+TgP3XYFsaFmGhyzXZYaSu0a+g0ZRZfk0MYAg0BFSSE+ cd0Ye9FQTE1+F4468stg4JDhdM+IAUlCrTOR2a0P48ePIaFTAHq9mfDIaHJ7DebmO2dz/13XEOrv c1p3cJ3BRFJ6BiEGwalTxRw9cojC4nJC4rtww50PMPvmyQTo3Zs75sBweg8awaih/QgLNGM0+REV l8jA0ZO45/4HuHLiCMxGPT5hsXTpmo2BGg4dPEq9Q0XuoPHcd+8M+uamENQpmaEDehEZ7AsOK+X1 TuKyetK/exb+Jk2rPo5O7szYsWPJSoxCrzcQEBJBz6EXcf+cR7lkSHd89BqqSk+iCUtj9JhBhPg2 PXTvpKSonMQuPRndrysGneYMawMt3YeOJjMuDLXGQFhkHP2HXcDIQd3QIuEbFsvAkRcyfGA3fI0m fAKCiIlLZuS4y3nosbmMH5CDUa9BuJxUnDpBTO5ALhjWvZXrr8vpoLqimMTugxgxsEuTs/UuLPV1 WIwRDB06hOTIxiMCToeV+rp6UnL7069vVwL8AkhKTcZf4+DkyUKOHD7EydIaorMGcPu9D3LrtDH4 aNXeUyyWuhpkex15gy+gX/dsAs2KQ7KCs8PJkydPu4FaU1ODNHH68+JYbRDr3r/ynBfYZ5detIoc 6d7VlvhvXNPbCvfy9a9/Epren3458d4d3f9gStVK/i5BYyTWNp4rUNAeHCcPsmjZGsxx3enfNQWj TvW36KU7IMx/57ygQMG/A8uXLyc4ONh7FUtTvPbpGvZYcxHHFzNlwhhunNSr2VhyOa2UVdS0w9Mk 1BoD/r5GhHBhr6+jqt6GyeyHocmYdrmc1NdUY3WCj58/GrnpGkBQW11JvdWBrNJgMBox6DTNgi7b rHXU1tbjdAlUag1GkxmdpjF/m6WOmpp6dCYzJoPurNYgwmGlrLyc2loLklqD2S+AAB891ZVV2FHh azY1u+qpLdRVlVPnUGHWS1RVVVNntaFSaT15GZrMTXjXLVXlp6isqcUlZAwmH0KC/LHWVlJT78A3 MBCtLDUPPO20Ul5Zi5BkTD6+aKx7yQrOwDbyPg58+0TrINFttdnlxFJfh9Wlxt/HgNNho66mFo3R F71Wdc7zr3A5qK4sp7K6DqcLtHojgYEB6LVqTzp3m611NdTWWdGbfTDqtR3aSHGf5XdRW11FdXUt FpsNkNHpjQQEBaLXqFqsKQXVFWVUVddic7jQ6vX4BwRj0qubpXPZ6imvrkVn9MWk1zT5jghqK8up d0gEBPp7XbeFEOC0UlpRi85oxseoa7WOra+tps7ittiq1FpMZjMalXTa75L3feGitrqSqpo6rJ72 6Y1m/Pz8MOgao6t7yxJOaqprsNrsIMlodQZMZgNyU7329ElFVR1IMkYffwL9TNgstdRaXZjNJnQa NcJpp6a6BqeswWwyttL1pm20WeqorXOPQ43OgK+PyatyddUV1FkFvv6+aJsFBXRRWV6BQ9bg72NC Jcsd0ilbfQ01dVYEEhqdAR/PJpn3FgOXneqqGmwOJ5IkozMYMRsbI80jXFRXlOGQdAQEtN4gcTmd VFeW45L1+PubmxF0m6WOqjobJrMvBp26CUG3U1NdhZC1+Pr5uOXtclBTXUV1TR02ux0kFQajGX9/ P3QaVTOu4p6napC1Rkwmk1s3FCg4C+zcufO0/LmoqKhtF3dJkrDbLDxzxzDe/aUE4WzhLgMI4cIn MJyH31nFJTm6s6iSW7mLDv3FgufmoUoZyQMzpvzXCth6cC2P3D+Lnte/Rrf0mP98gu6ZMIsO7+DV p2cTNmout47LZu2St3ni1ZU8t+hjkpWDDwrOAvajm3n64fuIvfhRctITzpGgu+eFj5+4jZ8O+/LC Kw8TpFOjfPIUKDjPKd/DDGW1nuBgfYfSS5KM1mgm2NiCAAuBLKsw+fpjarYIb0xj8vHH5NO6/Ibn Wp0Rrc7Y5mIePIRQb2z27pnmgYa6SWodQSHhBIU0f+7j598mSWmrDkbfABpqpzf6nFaeDfeYCyR8 A4LxDQhulk5v8kNv8nJTJEngtJfzwfwvSB4wlLzOyehVcHzvOp574C72WGQeuOzShunwzH0kqzCY fDB4/q9Sa/Hx156hje3Nv8KTrxrfgBB8A9og2OBJBzqjGZ3R3PF+khqizskeHfFvf7PF87ePfxA+ /kHtppO1BoKCDC2egRASJr9ATI1NADyyaTIemubV0A6DyadVxPb22il5+1nG5BuAqZUAW+uOW+4q zL5+mE+Ttr0+0Rt90DcdoyoNPv4Bp9X1pnLV6o1o9cY2+9jo40+D6nvrLAQCGb+AwA6MpaY6BVqD mUCDuXVZnvcl2R2LoE15AZIs4xsY3GKjp3HMyioVfi2eN+ia1mAm2NBaZ1RqDX4BQc11W1bj4xeI j19gO33naVOTeercxpwCBe1D3d4HoODoHg7sL6Xr4FGEakWzIydCCEx+Qfgaz00hq0sLWfrFx2gG hPxXE3Rht1JWeorqWmvHg2n+b9bXM7GdKjjIb7/u4tbbsqC+iJ1/buKII0gh5wrOaQyUl5XiX2PB 5Tq/QbDp52/4ZFMoc194kCCdoowKFJwvznbRKJ0mAFbbzxotiacrRjpTghb5nGvdO5q2fUJxdu93 vEz3305bOc/cOZ18n0DMBj0q2e0qW1pez0V3PM/dE3M8tKN9jt6y3DP9v+Mkvf1GSLTdlecv+47o WsfTNT5rqx+k8y7zTPL5O3SnY+OmY+P2fNrQtB7SWfdnOzp1lvJq+7028m94fjbz2FnV5fznKgUK zougS4CsUqPSBXLfgs8YGmjH2ZyhI8kqTH4dD+nZ1D1Eo1HjtDmQnadL177CdyRNQz3bdUc6Q307 MuhkWUaS3Lt8p62rBIjm9RCNpodWLv9Ndzo7Itczyco7MQG4qincu5kCUw6jMtRUHi1jT/5Rug+9 trnczjBpnWnX/KzacTp3Zu+u/Rl0wXMN5WnTefOhYy78zfwR227zGa0GHXDRPrNsRJONn9Pn1TC2 vNaBM+pLazm0tSjsqGVElmVkSUKS5LPXlaZycthwWe1odbo26/K3zAkdnKvas7J1TK8b+66tc/qc xdU2ChT8/bqs4Gzkd/5ylNCaYnhj4SesWLedgpJSXJJMUHgCA0eMonvnZHzUSn8pUKBAgYIORHGX JJmAED8C/NtPV19Twa9ffkxNYC5TLu7Nyq/f5ruVG6mwyGT3GsS0Ky4lSOf+6JQVH+WLjz6l0Aaa w1t4/f33EbU1GAPC6dF3MOkxHvcSRz3rln/PN4uXcexkFb5h0QwfNY4xw/tg9Jz3EFUn+f23leQ7 ghg9eii+1iJWLFvB7hM19Bw0mO5ZSW3eJSdJEuUn9rBi1e9s3rab4wXFONEQFhnNgNETGN0vF42q 4x9ltc4IlUf48J2vWL1xDy6DP/0vvIIrx3TzfNxBkpws/fhdDrqiuWHqMDQqlZfgiLp83v1gMT5p PZk0qEvzcp1VfPn+u/y2djsVThUZWT0Y0S+VjVv2ktv3AnpmRpyhDyWcdhslBUcoqxdYS4/z64rN mGKTqCo6zra1a9i5/QBd+/hz+OABZJ2Z6Khw5Ha28ZvW7/CONXz2xTf8dagEnW8IA0ZfxMUjB+Kn a5Sfq6KAZStWUqqN5oJR/dFW5LNsxSoOFFnoP3IEOckxrfupCXE7uu13Fn3/E5v35yPUBuISUug/ bDT9uqag16i95Zzct47Pv/mBjTuPIhv8yek9mOuuHI+PusE1yZ3f6q/fYXt5IDddP47ty7/iy8Ur KaiwkZg7gH/efAV+Kglb8V7efv8ztuw9gsocwqCLruTSoVket8YmpMtVy8IP3mHlui0UV1gIT8hg +IhxXDAwy+0WJtom1k1lWLhnLR9++i1/HTqB0JlISMmiX7/+DOyTg1ryyAGoLDzAF59+wrrte6lz aUju3JtLxl1MTnK4d1OhtuwEa9esYPX6neQfL6DeJggMjaDnoFFcMHwgAUaVt+wDm1axav1Beowc S+eEUHatW8naLTvxicthcJ88QnzdvmHb/lzK4h9/Zd+RArTmUDK79mTiuAuIDPbxuvapNHq0rgqW fLaQn3/bRJVTTW7fi7jx8hHoVXLjhlQbBF/Cxg8ff8y2wnpwlfHua68Q5Dmvl5I3nCF5iV5lPLV/ Pe9/vpCdu49i05vJzunFlCuvJsZfRgj32czS3Wv5cs1uegybTLcEX3b/+TO/bzuEISiGCRNHU7Ft Fd9vOkbf4eOJYj/z3/iU/QVlRCTnMnHqVXSJ9cVZX8YPn3zAr+t3UIeR3oNGM2XKGEySaNJ3Dg5s WsVnXy1hX34xarM/SanZDB40iB5dUmg4luaoLGbtmt9Zd7ie/gP606NznPL1UfA/AkmScDqdfPfd d1RVVSkC6QBcLhdpaWnk5eWh0Wi8ctyxYwcul+u8CLQpMoVhY2JxOJ1IkkRkVDSxcbHeM8dK0A0F ChQoUMDE6c+LHle+L1rCZqkT/7woTGgMwWJVrTgjSvL3iXHxOhES11NMGJEr1DJCltUCEJI+QAyb coco8aTdvPJrEeU22AlJkoRGpxMqCRGT2Vu8s3SXEEKIsvwd4t5pg4ROYxCxydli6OD+IjU+XKg0 BjHptsfF4Up3Xs4jG8Tt4/uInAETxJ0z7hI90zsJlYwAlZj5zHuirp06L3l3lkgKUwmVwU/EJiaL lKQ44aNXC7VKL658+G1RUF4vhBDC5Tp9HpXLF4hOASaR3XuoSI4IETKS0GtkAQidwSSumveVsNrs ntQWcXnnEGFIu0JU/7/2zju6qmr5459TbklI7xVIAoHQIVIVCFWKgIr6QKl2nyhFmjywASoKihUQ FRQFLFhQKQKCFJFiIXRQmtKSkN5uOWf//rg35aYR0Peevt/5rnXWyro5Z5eZ2WVmz54ptnuU40zb KGJ9fcW1Y+aV/ajrovDsXtG7TZywqLKwegeL+nVjhNWsCm8fXxESFiWeeGuHqA3Sfj8mRvUKFUgm 4WX1Elazizde3t7Cy9tLKCCQVAHeoteNY2qkWylBHLnio1cfEzF+qvCq4ycSGiWJ6PBAoaCKHndM Ej+cyirr3/FtYlSv1qJ9n1Fi/IMPitYNwt18UsXMtz4TRTVUs2r+ZJEU7SesAeGiVdt2omVSnDCr soBA8f6Ow8Lmfn/zGzNEUr1QoZi9RMPGSSIuMlAoJotIuGaQSD2bK8qzcWJKXeEf3koMuaGT8LWq QjZbBCBUSx3RZsBY8dEbj4n4EF8XjawuWgWERornP9vvapu7gbmnd4nebeoLk6mOaJbcUXTr2kkk hPsIr8BoMXz6ElG9ALl+04pzxcb3nhYRPmZh9Q0Wrdu3E82SEoRZQoTEtxJzP/yuVHZ2frFYNIkO ED7+YaLttV3Ete2aizA/swhp2Em88vH20pJ/2vKe6NLEKpCsIqp+gmiUmCCC/byFjCx6j54qfjyT U/ruqufGinoh8WLsxKnirlu7CT+LIgDRpOcosevIRSFEpnhm3HAR7msWZp8g0SAxScQEBQgFRFjn 28X+M5nCsXuFSIoOFM069hMtG9YTFlkSVouLZopqFgOnviky8y43lnJE7/ohLjkEoZrNwmw2C5Oq iFGzPhKa+8M1r48XEX7ewjeknujSNUVc2665qGOWRVTjTmL9EZe86fZi8fObU0Qd/2Dx0IxFYnjv lsJqMQmQRXRcZ3Harott88cIq2+Q6N7nFhHrbxZIklBNkgBVtGjfU8xfvERc3zpWSCAkxUUTk1+0 GDlpfmmLtYI0seLFR0SgVRW+wREiuUM70SghViggYlp2F+9uSC19t+iXPWLS4OsElkTx1MI1woCB q8GmTZvEvn37xP79+ys9D0xbKLo98r1I+ccMsejDnZ7rud0uFi9eLAoKCkROTo7xXObJzc0VFy5c EE6n04OOe/fuFRkZGSIrK0tkZmZexZMlsrKyRHZ2tsjOzhaZmZniwIED7rlRNwTcgAEDBv6fYP/+ /SI1NbXK9XzDhg3isifoDlseC/41g6+99Up30K11/BgweiKto1SErlOYYyM9J5ULrYbx6aa3adsk ivRfU3l2wl18vHE1yz8bycM3tqRl54GsXP0e/7x9GKaOd/HZR3ORcnORTGYCgsIQub/z3kszWbjx LNMWfMyYwZ1cocZtGbz9whM8tuAVGjduylMPDAJdQ3M62bd1FaePx9O7/1Dun94O1VZMw9bJNboI NGo7mGVf3ExYeAy+3hYURUW2pTH5rn+weM5zDL6+AwM7NEGSar4Rpigy+3/ez6gHxrNs1M3EhviT c3oXt992B+/865/cMiiFvg2DUSQozM+hyF6IqJhEUneSm5dHflFJnkeBLoqYMnooX/94jn/OWca0 kT1QhaA4P51P5k1kwhtbsdmdtTLEBIXXZ+6yH5mlaRz8fg0Txz7HpM9206vOSd5b8ApLjwbyzQdP UJyd7wr+UkNZJa7v29d8yLRHZxGQfBtvzp1J+/hgnEWXWDp/Fk8+/zwvREUzd9ZYIsy4+aSxa8NS jsck0m/gaMZ3boMoKKBZx6ZV8kmSoPjoOuYvXkZRvQGsfuFRkhMj0ZwahZdO8eb8hQT5ulyhL/2w iodmv8Y5SzKrv5lLcsNIVEWw/b1ZDJu0gOEPz2XLO48S4I4eWlyQR+7FM+w634eXVn5Dj+R4FGcu 00YM4L21ixi5zZ9b75nOqjtvIdTXzG+7P6DHzROZN+d1xg16HRWw27MZP2wIuzMD+WTbejokBCFJ EgVZ51g0bSTzFjxO7759GdYpvCoiggTnzhzl2RlPYEroxZZP36Khn4Kua2T8foxNm7diNrtydx7e tZlJ46ZQp+VAvnnxGRqEWJEUmV93r2XGpHEseO1Vktu0oWOcF5Hx7ZmzeA0BkQ0I8vFCVVUULZdF T09hxitv8nn7jrS+b6BrfNsdaFkneGnefNp168205xcQH+aN6hdFk/hAlj49ljnzl9HyHxOY/ej9 NIoOBJwc3vEF89YcBeFEAKqqsn/nN/Qffh9zl44mKS4S+4UfGTH4dlbPmUXqnf3o3DASudqx5MMH ew/wyPVNeTs1hK2pa4ipYwZ3rAtZkji1eTHDJ75M8ohnWDh9BL4WFYST84c3M/CGoTw4ZgbHNrzi GjsOGwU5l3jj+fEkdbiemfMeIj4yEEexjr+zCKe9mOK8TH48cJhxM5cw4saeqI501r77PPc9+Q4z ft1P686DWPPaQ7RtGMqxH7Yw+b672bD2U9aMvJd+Tb04+OMO5j7zEnFdh/PW4jnU85bRdCdnj/3A hu9SqaOU3d8RTjvZGWlgu0BufrFhGTbwX4G3t7dBhFpCqyK/txACRVFQ3N5vkqKWRrkWuoYAHI7q 12SL1QtHcRH6ZeopV2PZfOn2KPO8xlTNNRojA4YBAwYM/K1Ro4Luuq9sY+X8WVX+38vSQvbzAAAd 4UlEQVQvhLq9xtE6ylWMLkF0yxv5fNVCApGQZYnw4Pbc/eDtvD/8NXYdOwi0RJZVwiMjsMhg8vIj xt8f/P1Lyz20ezcffLGVHkNm8Nhd/crVGMiQO0ax7qtN7Nyzk/MPDCJSltAcNrzrdWTu/BcZ3r81 4Io4KSlKjflE6yddQ7z73vilc6c5fvIUuYV2vEMCkYv2cexCFkWA12VuijpsRfS96zmemnoHMaGu 0JdRkYN4fvxo+j/yKp98uI0ekwfgZXYvotWsmhJl/xJCkLl7JW9sOE7b22fwwoQhWFS3E7gWREqH lrDo21oxuSRiZXB4DGi5HM05T0FQa25JDsV2Jo30wkySU24gzD8ISqJX1rDASwC5J9i2/hNOeDXi hQfHcH1yAzeLAnn44Qc4evBnPvzycwbf1JebOiYC4HQUE9CoF6+/PIcbU5oiuy9Cy4pCdbHvT584 xfm0SzS4tj0tmjQlqCSobmgI0+bOR7F6YwLeX/I6h07nMn/ts3Tr2AIvd4GDxr7IfZvXM2/Vy2x7 egx9E62o4HJ3927Jx58uoVlkGGZVBqKZMOoWlm2bw4B7F/DyY0NKc+ZG9LuXgc2n89HP2zgroJ5w krbjXZbt/J0ZH6znhvYNS9scHBzMhNkzeTVxAJ9s+pphnYZXQ0QoyEtj/0k70QOb0z6uTJEPCQ0l LikZXbFC0QX2rH+PoySwaPartE0siyyc3Gsow0fs5p6nv2Rn6s90jOtIaHQC4bEufhRmpXHk2CGy 8gqxmbzwkTM49dtpsoBAQEKnUIO7p8/jsQkjCa9jct0lN5lQftvKR6vXQdO+zHjkfq5tWdbHa/uP pEV3O76+PtjOatiKC+kycjrzZt5Po1h3ZNTIPgy5tSPfP7eG3WfyaJcQiZdcpa8/ApmA4HB8rTJI JqJiY4n1NnlsVBe9OJu86BtYtWCSR8TbkNAhjB32FhOXfszWnFfoWqdsehvw4Mu89eQQzKoJVXG5 wMuOAlcwO0sAD898g8dGdnRvbsPoceMImj/9DraE7nz08SJC3cO1Q4dODBvcgweX7ufXo4ehaRsy My5wJM1J74ataBVbFjY6JOR6EtukICll7bfUa8Vjb63m7lwnsTGxxspjwMDfELqulyrUkiSTfew7 VqzbQaHNSUCjpgTL3gzs0xmTSXXF4xAaDqeGJCsoMsyfcj8DZ7xIpORS5nVd94idYbc5WL/2CJcC Q+gVI1MUGU49xUnqoYs0bx2N2b14OIodnDqTiW98OBHuXZyjyMaO3Wc4VWRiaJ/6WAx2GTBgwMD/ poIuAMUSyPKfj9MtsEKQONypDwIt5d4GxeRDsFvpFYCkeBEQnYiKg8KCIo+FrkR5rIizv5/j0NEL fHfiEQLenlb2juRSxgsKi+nUPJcsG0RKrrysIRExxDdoiNlkrmLzXzk4myRJyMUZLHl9Hi8uWM6v Z9Oxa040rWzBtOs6Wi0VYC8fv3J5G13ld+9/HdbpC/npaCqa1u/KOCNg59bvsQmZ3v3vwKLKHsFq VKV2qawq3qF35BWw/9BpYjt3xQu4kJXBmaOn6TY0xeOby0V0TfvtIgdTjxEb14pmza7xqMsc05IW zVvx5trN/PLL7+BW0HXNSXhMferHxWMxX55PAI1atiA2LIKNb0znAftxBlzfnXbt29M0LhIvnxJF 1cbOnSfQ/TvSpVG0WzkvCeal0L1LT179/HV2fHeWnnEhqCZ3JbI3wcEBbuXchai6LiXZ6lOnVDkH kEzeRNQNQBwuoNABuqSzY/Ne7E4Hs4a1Ya5J9vCJ0DUb+Uic/u1cjfzx84uiQ0MLn69/g4Gj7Qzp n0Jy27Y0qheBxZ3CI+tcJgdST5L+6x6GXReNSZXKnZpAYW4uDt96ZGRkurql5bPhg6XMfO4Vfjx8 Brvbe0F3fyTQcZTSXceJHwkNEogN9Mwpc2j/cU6dPk+bAQ9Rv36cx3iVVTP+vuaykS90vHyC8PPx KeUnkkRsVAPMEhTk29B1qCYgRKkJrKRfuq57Bq1znmfjljPY888SHRBAxZQJRXm5aELm94s6JEiu NskqjVok41fHs1+6A5cHi6zg4x/iMT4s3n6EhMIFRcVfLqtf8rISGhOKZndQbHPNY+FhsSRHSXy2 bC5DtYsM7tOF5LZtiYsMwsvL22NMSBYvouMTia4wvxoHXAYM/L0U9JI76JIic27PWgpib2F050hM FjtfrNmLLgr4cvU3ZJ49jdIghX+kNOPCwW95/8u9/LTvNP2EQBd6JQUdwK7p7DtnZ0LvYLau+RlH YDj1rBo7dp4gvnU0R/eeYONJB32vi+HY/t+x+vmyffcpsjWJzimJNI4P4ez3v5EuIMaYXAwYMGDg f1NBd+2dFYIiggkNuIJFzGMfLiHJKqbKTt3VwE5RYTZZqHS9eSR39mlHYbHds3xNo15SG2Is7l2u cEdQl6TKG99qU0NkMmPsPTz75mqadh3AE5NvoX3LJiTEN2DjW4/w8L+W4NRqnzJKiMquZnJwEN6y TFZBrqchohYLp0BwIS0TZJmwiFCPcqszbFTNP4nC3Ew2fraEY+kKhdnn+WbTt2gxZhYueJmj+77n uyMZ+G9dyQs/S8Q2bMmtA7pettyC4iKy8/Lxi/TGP9hSWpdLL7Pi6+8HIp+C/MIKRp1qooZXF9E6 qhOvvPY8Mx57ks+XvsKn77yGxWLGLzSeOyc+xbR7BuHnlUtajgMpMhAfs1JePwQgLCwMRYWs9CyE Xt5lkLKAbyUDQi2J0K6XRjsHCQQoVrW03QLBhaxMkFWGTnqWTlFKJQOWbDITmdi2euuXBJFxSTyz ZDn2Rx7li6Uv8MW7L2GxWAmNasCoMZOZMe52HA47aVmX8ItpxL1jJ9LYT8NRPp2Z0FF8Qkhu3xqw seL12dw3bg4BTdozduZ4urVvRYOEBhzaspQJY6dhc1Q0O8llhpFyhMspyKXYVkxIaAAWL7WSDFYx CDyMaQBm5U9KlebI5kKewLdZV54fc2upsaG8nKuqhU5hEqUTjeTKsFCjMlzR6AioiksudE8SIZs9 rQuN26UwZ9FiJj36JCsXPM0HbzyH2WQhOqElD02ezgMj+mKpJvqzEanZgIG/p4JeeoKOhK452fzx QtK/86LP0BF8t/Mnbh3UhnffXsWU2TNYNe8pDjWZzCuvrWfS1Pu4cGg3Tk1DQ6tSQRcCNAHeFpnc nAKWvLaTDWadM+cL6Z+WzqpUG/f2i2DukgP0bKJy/lI+ew/mcccN9Vj54UEeui0BpdZ7LQMGDBgw 8LdV0EEg9KsrXKqNQipV3DybsHp5YQGi6rZixKg7cdjtlRYcWVFQAV33VBBqqf9ycvM61m/8lib9 x7Jo7qO0SwxB4EoXFejnjSJXsXu/UhTkUqzrRHv7uDfj7vKc5RbQGo7RfLwtIAQFOQVAUEXNu9bN sBXls2fLl2w+rmHLS+PgkQskWI6z8r0DnD1xggzdzOFtn7PfodK+h7lWCrpZNeFtsVJc4KAwT4dQ uRyvdYqLbIAFs8VcrUJ0uR6UKDFJ193Ee2v6kZP2O/t++pE93+/gvRUrmDP2NrxCd/D40Ob4W2VE WiEOTa9Udl5eAboOXnXqXD73aKW/qruOIBHq7wOSQmLL67nnxvrYnXolHslyNZ4OJZHZFTONOgzk ow3dyc64wM97drNj2xbWfPkZs56cTp7sx9w7kgjwtmD29qFTymBuusYPu12rUJWMyaSScWgHaz/5 FO9mvZj32kJu7VIfTQdFlkkP9HNlJqjZolP6Zx2LDxaThZxLOdiLnOCjlorrlSiYV6OGVmqj1ZdQ K1wsCmDYvXejOrQqjVGKKiGc4opl7epmT2/a9hnBui43k3H+N37cs4ftW77mi6++YuKURymWrEwd 3s04JTdg4H8EQoiyE3RJx+l00nnQPdzZNRIfHxsrnA50XUMNqUvDutFEBnqR8fshRFhT6kdGEOxv QWg6ulR2gl5xrpTcc5eXt5Xbh7elt7WQt979ntwL6Xx7IJ1QP0Hd+EA0LRdFlQmNDiAx0oft4hSF AozkjQYMGDDw94dcm+31v+OgR5JlZBl0uw1nhfoiIuvTPNjJz7u/Zfd5MJnNmCs8ilQ79/PqcDEj ncycHBJbNCc6JhxJVkpP21RVvuI+S7LscX8cYPfGXRQVOWnbthuqogIKVhnIOU+eJLvD2Lu+Ucwm D6VEkiTatmwAQmPr9nWedakmzFdgQPAPjWHaq1/y9efLefK+gQTH92LTzi28s2g+vbomcePDM/l2 w9es++oTZk0eXasyo6KCaJgYy4lTxzl54lCZQg2Qd5yTvx5GiYkmttzd3KsWUsWEdx0fIuMa0Wvg bTw65zXWvPYEsQEKOzZ/T66jDq1bhUP6dlLTC13yJIFwE3fPrs0U69CmQ3SZe/sfbpNMp87JoNlY 8e6bIKuVZNRsMiGchdVroMLVUFlRqeMbQHT9RvS5+XZmvbSIxYteJy77JD9s24kaHE6bNk3JOHaQ DRvWAUqlukwmlyEgOy+PCxnpRNePo2FSPCCjlMi1SUGWa293atG6IbExEWzZ/DXn0s6X2BVK5fNK DGK1pqtZAnshjoqGDSma6zqG4zi5jqVbL1amtdmMSdZx/Ef3phKKaqKOXyD1EpszYMhI5r25nPmz ZxB4YR/7f0otNXoI3Ulhfi6ZmdkUF9td3ibG+mPgaqROkioZxwxvjP8MNE3zeJwOG0I2YbVakSWB zWZD0zQcTicIHc3pRA9tj+nYKiZPf5yv955F0z3LKH+CLsuu2D2oMooE3j4qAb5mzGYTwXXr0s7X zrlMG0KRMMkgnE52f3uEFz4+jE9ifYJkkEqdCY0ZxoABAwb+dxV0oZFzKZecrEwyM8ueS5cukZWV hf0qT9etPr5Exfty9MhOVmw/DUBO5kXSsgppcU17ho+6hcPfruTBO0ewfvdxdEA4C/hh2xeMHjSI qU++hAbIV7kviY4IISgokG1fr+HUbxdKf9++eiFPvfghmU6Bosi1I6Isc/7UKRzukHSSJJF+cB0T Zi/E5tWMe29uidksAypxzetB4S7mv7+71Fp+ZOcX3HrDA+R4mkWo23ME1wTBxoVP8cw76zmfeYnf ju1jwZxH6f/wC5gqnk5XxT4hkGUZL+86SDocPX6WmI7XEQbY7Xmk/XqOTu16gqzi6+uDt5fFw12/ 2k1iaFM6du+L3297eeutpRzL1ku9BD55fzlvrthGt2696Niu9R/aiO74bAmPPfsS+05dcitEKqoE aelpFBU4CI6OQQOGDR9GqK/OlHGPc/xCQalhKfWrl3j5k58IuWYkPeP8Mf1Z+1hZIeK6EdzZLpz9 q+fTd/R09p1IA8CWf4lvPl3KfUP7M33x5uo6hyQ5+eXwFkaPmMTBs3kgufonyyachWmkIVMnJATw oW3vIVwblc8bzz/K2NlvczbLFQk889yvLJs/nWEjRrNyyxFiI4KJjghj/497+WHvvtLqDu9azayn XyL1ggOLuXbxC4hN4ebrO2M9vpaHpj7BN6mnQQK9II0v336a64b8k30n0zCpyp82IcU2agCcYP7i 9TgAZ2EGp86mI5B5ZMbjeOkFPPKPHrzw7noyi1wmuvMnUln43HTaN+9BBv+Je92uGr7b8iljHprF yUvFIEmoqgoIivIzyKQOPsHBpV/YTv7M4yP7ERzVnueXbvrTDRsG/n8gPz+f8+fPc/bsWc6dO+fx GArZvx8lLu6apuG022hw8xTuSQkHoWG3+/D8zAlomj8vPTMBTdMY+ugztAoI4LEXXmXKhHEs/3gZ oZrN5eZeQUF3OnU27jnH13vO8tzSfXyfqbDvkx+Zs/wg2aY6LPnoKKZQf3A6uZSezfcXdHavOcYl TKiSxPlfzvLk2/v4+seLnDmRY8wwBgwYMPAXR1XG9ZLfqnVxF7iCejltWfyjSSiKVFHx0/EPiebF 1UcYdo0rmJbmBGdVqUl0HSdOdK1Mm4+t34DhI+/m87EvMjKlIXcJJ5GN2vHEvDe5s28zRk6YRV6R k6deX0afr1dgMSmAwGGzoxPIuA6DMLsVUE1z4nRqV7Q9ie08mJt7fcLshZ/Qve1GYsKDyM/KINvh Q0Kkq6Ty7a1BA0ZSzHy3Yhr1vpxLg4Q4pOIMfjn5O4U2P1787G2aRPqVWkLuHz+JBV/cw7y7U1jy rwjk4lwys3No1bkTCsfQSlzeJAmTb33efn8hPQbcz7TR/XnCpCB0HWEOoF/HVpzedsBlLq8l87Nz LnHg4I+k3DYG0Lh4KpX9l/yZkRJzWYGpKBsS0HfwMKYdSmXy3Hl02LKKZo3jKMw4xQ8HTtKg42Am jLufBv5ldNKcTteG5EqEtyiLla/OZuajk0ls0YpG8dFknz3C3h8OY240gIeGdCTQBIHXj2Xuwzt5 cO77tG60ng5tm2HLOMXPB3/F6d+czxfNJMy/LPa3pjnB6azUFiF0dECrxHuBrjnRnSUnnxLWOmHM +2gd+qg7WLp0Nhvff95l1NF17HY7loAoZt8WWaN9rDj3EiuXzeW9VYuoF9eIpgnRZF48ya49qUS1 6cOU8S6PhqROfXhlyVIeHjOBl6ffxYKnHkCWJYSmYXc4Sex4A8MDfLHUa8zAwUNY+/CT3H1jJ56I DEEU55OeBxFhVrxkcDo1jw2nE6crqrmnWCNJcN/j88gusPP0oqX0+OodLBYT6Bo2u4OobqNQLVaE cLl6arpe5YbWIahUfnVSdeeDU3lt5UAWjh/EkikquuZk6Iz3WTLjNup2uYevV+Rx+33TeGRkPx69 14SEK0ikw+EkoskAvEvUFF0D3VlNvQKh6+B0VrrLLoSofh4T7m/cZeZePMOiV2eweOkLNGiYRMPY EM6fOcLun4/Rpu9o7hlxUzk7p+sEHVs2RTa7sSoZuCrUq1ePpKSkUm+v8nP2p1tOXNZYa+CPK+ii XKwNSTVjKkdbi8WMEGC1mBFCYDK74rNYrF4ek6uogi+qKtMjOZLME+nY60YwKSUce8l1HYlK1+Fk BBnZhfzwSyE3dIwgN6eQ7TtPcSwvmBbx/gazDBgwYOAvjvPnz1e5NhcUFFSvoCuKSu9bx+LVJJ+q MyO58qAnhbtOz7z8ghg6/hEuBXesYLeVCK/bnEkTp5LYpWXZz9YgBtz7JHvb9OTLdVvIdaokJCXT s208AH6RiUydv5zbxxxi06bN/HLmIpLJi7jGrenSuRMN6rpdp/2j6Hv7vcTbwqkXYq0VQVzrnJWp 898k8ZqOvP/RV6TlQ70eN3PX/Q/gm5vKV+t306lxLKbLlGWu14p/PjyOyEbtyT6+na07fyStyJdB 1w7mvrEP0yEptiw9GhBz3V1s/SaIFxcu48Dp84RFdWXQ0AcY2tmfOXOXEXhNp3KkU2ja604O/XIt Kz9cxZmMIgIi4hg46AYcm19k9eZUzD4htRYEs7cPnXqOoHXvtqAV4x+UwD0TJ9PCemUCJbm1N8Uv lnEzF3BN1368t/wTjpzOwD+mBU/e/ThDBg8iMaYssqAUVJebRj1IB3MDogJrnwCm05AxfBDVkM++ XMve/UfIuHAe//AmjH92MncNH0hcRNnd/BEzl9Ms5Ube/XA1Px06izU0kXumPMiD948gISqIcmyg 96gJeKeFEWDyHALWuu2YOmUyrTonVdgAy3S/+SEsSQohJeVIMgGxLVn41W4mH/qe9Rt3cvZSLmaL D0mt2tG9e2fC/LxqVNAbt+rD91tXs+Kj1aQe+YX0jIsEhScxY954br/jFhJC3UYFyUyrXnewZldP 9u3ezrc795GZb8M/OIK2nbrQ4Zrm+Hu7PCpuuncSYfUb8saby/jlfD4R8U25bcRomoZpbPzqK8KS 21KSDTnp2r5MnBxFx+bxFfrrviNvCWXSi8sZcu9ENm3awvHf05DrBNKuSy+uS25KsJ83DkcSD4yb QmDzZHysnvRMSO7B5CkKnRPDMNVoS3LNGgHN+rMrdT8ffPApZzLy8fIPp99NXVzeJopKp1vHc+j6 4WzZsJY9+45T7NTxD42lY9eetG8RjxeArBLepheTpvrRpVlY5ZpMVup37M/kyXG0b+QZ28E3KJKh YyaR49/Gc3KUvUlM7sukSfG0b+KKxd5jwEi2rovgo0/XcuD4CdIyMoiIb8cLY2Zzy839iQ0s470a FMX1Q+5Ca55P12saGquSgau2tquqWklBvxxkWSYhIYHs7GxDUb8CZbyisdput3PkyJE/7UqBJEnE x5fNvd7eZoYNS3Z5WMkSl3OSiwjxpW+wK5uJr58X1/dqTC9RcvJi5IkwYMCAgb/yGpOSklLler5/ /36kWx54QZwpCGbXOyMqKeC6rtV48iVJkiuHtTtSsaY5ARlFVSgfq9t1KuXOBarI5QJMCYQu0HQN IST3/Su5QrRyHV3TXSddkoQseb5T0k4hJGRFduXWvqyGLhCShIQo52bmukfuuivuqlNSXPfSaypR 6DqariNJMkJobgu7uyxVLW1P+VynQtdwutNeSZKEoqgosoTT6QRZcedr9gzCpWsl78ugO1g69Sbu fe073v/pEkOSaptyTUfTdGRFRcYV7EYXoLrCVl9R4LnyPNR1vSyNlyShuPkslYtgXcJHIUkoFXhc A5uQ3Gn0XDLgpq07+FpJHSUnEpIkobvv9+nuaO2yIqMqSpm8CZfru+Z0ooMrXV35NF+6jlPTkGUF WZYqyZmug6qqZQpsBTkoTaslyciKXH1AtZLOuU9jnJrmjhxfvn+K+5Xyae/cfNNFWbpAWa4QrdyT J5LkGpMyoOkakqSUtk1300pW5EqThHC3UaowDivV6ZYrSZI9aOaagDT3WHKNhZqDwJelESxx/Syh Rcl3pTJXhTzIcpksIHScmkBWFBS5cgR1IXQ0XaCUfFfuf1XOY+7USB7flPym6S7PlnJzoiKX8a6k TyXyIytlcQEMGLgSpKam0qJFC5555hn3fKfToUMHunfvzj//tYgjtlaI379i6OB+3HtrhwrruX7F ir0BT48yTdP+LeXLcuU1v8ZAnBXSklZ6t5q0pQYMGDBg4K+znjdr1qzKdTk1NbXqE3RRXnGshe5X 8r6qmjwV4NJFQkI1yZU24ZLbSqxWpRi4li63ciGjVFFnyeKmlEvlVKvo0iWKUWkfK5JBKYu+XU75 q7Lfslyu/fJllNmSbxRMVdwDVk0mTxrpOnvXrGDbWejRrTPxMaE48i6ybsVCpryylpi2oxhcK+W8 JCe4jKqWKHJu40oFRexKNhUl38myglxFfzx57eLjlfBJcivULuVLqZa2uI0trvv21bxbykcXLRRV LZMptyzg5qepCnn0HA9lin6ZHMuV5LjGfpYfA5JUqc5qZadUGa2ax6W8rYYnpW1000NWFMpE3VMO yowa1DgOy8tVRb578kOUKtQ1yZRUep+baucFl+wq1fBYAkkpPbGvioaSVEbDknR6JW3zmMdKfEsl CbnSNyW/KZc1OFScT69mzBkwUILrrruOlJQU2rdvz6RJk2q1PiuKYhDuKlB+HP+7aFjVOlHj+lhh 7qj0rjG3GDBgwMBfHpIksW3bNrZv3w64vLQee+wx1369ug+utIIqF4dqc5DXXEdt6q9pk39Vba7l QvhH67qSvgkhOLFrPY/MWoYkyeVOUCG6eS9WLH/F7YJ/OVe2ypZ06Q/wu7bf1cTrWtVZi01GWTmX OS3wUDypVl5r10+pwonu1dHoSuW85vev8LSkhrF5JeXWxNua6PZvoVc18nI5Gpa1t7rypD/Eu6uW fwMGqoCu63Tu3Jl169bRtWtXTCbTn7PWGbjicfxn12HAgAEDBv7/QAhB586deeqpp9i4cSPr168v /Z9qmFn/fUT/o4uurCgMHP8sX7Xuw8HDx8kt1jBbfWjWrgt9unXAS61K3f7r9seAAQMGDFw9zOay S8k9e/b0mJNVkwo2g0YGDBgwYMDA3wnr16/nm2++oXv37mVR3B0OB7JqMajzJ0OSJM6dO0d6eror +vMfQFRcEpFxjcuXztEDP/1H+qFpGkFBQcTFxRtMNWDAgIH/IoKDg/nll+PYbLZKinvLNh04sDWf 8unWhBCcu3jRMK4aMGDAgAED/2UIIYgMC0OWZQ+DuyzL9OjRo3StNplMqA3qRZKVFkGHO1eiO430 Pwaqw3aDBAYMGDDwF4OjKAeT1QffiCZItgwi6/gjyWVu71Zvb4NIBgwYMGDAwF8BbiW8cePGHD16 tJLB3WQyERgYyP8BWF8S15LUx7MAAAAASUVORK5CYII= 179060 2012-12-12 08:57:56 -0800 2012-12-13 09:23:40 -0800 Patch bug-102560-20121212165516.patch text/plain 24571 timvolodine U3VidmVyc2lvbiBSZXZpc2lvbjogMTM2NTA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDAwYjI2MTA1ZWM3MGUy NjM5YzY3ZDBlOWFiMzRlNmZhYjI4YWVkNy4uNjNkMzUwZjc1YjQzZDI2MzY4MjNlYjEwNWU3ZDVh MWNlMTEwOTcyYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEyLTEyLTEyICBUaW0g Vm9sb2RpbmUgIDx0aW12b2xvZGluZUBnb29nbGUuY29tPgorCisgICAgICAgIFRleHQgQXV0b3Np emluZzogV29yayBvdXQgd2hhdCB0byBkbyBhYm91dCBmb3JtIGNvbnRyb2xzCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDI1NjAKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBEaXNhbGxvdyBhdXRvc2l6aW5n IG9mIGZvcm0gaW5wdXQgY29udHJvbHMgbGlrZSBidXR0b25zLCB0ZXh0IGlucHV0IGZpZWxkcywg c2VsZWN0aW9uIGNvbnRyb2xzLCByYWRpbyBidXR0b25zCisgICAgICAgIGFuZCBjaGVjayBib3hl cy4gVGhpcyBpcyBhIHNob3J0IHRlcm0gc29sdXRpb24gdG8gYXZvaWQgaW5jb25zaXN0ZW50IGF1 dG9zaXppbmcgb2YgZm9ybSBjb250cm9scyAod2hpY2ggaXMKKyAgICAgICAgd29yc2UgdGhhbiBu b3QgYXV0b3NpemluZyBhdCBhbGwpLgorCisgICAgICAgIFRlc3RzOiBmYXN0L3RleHQtYXV0b3Np emluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50 cy5odG1sCisgICAgICAgICAgICAgICBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xz LWJvb3N0aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbAorICAgICAgICAgICAgICAgZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1yYWRpby1pbnB1dC1lbGVt ZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYm9vc3Rpbmctc2VsZWN0LWVsZW1lbnQuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1Rl eHRBdXRvc2l6ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpU ZXh0QXV0b3NpemVyOjpjb250YWluZXJTaG91bGRCZUF1dG9zaXplZCk6CisgICAgICAgIChXZWJD b3JlOjpUZXh0QXV0b3NpemVyOjpjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZCk6CisgICAgICAg IChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpwcm9jZXNzQ29udGFpbmVyKToKKyAgICAgICAgKFdl YkNvcmU6OlRleHRBdXRvc2l6ZXI6OmlzQXV0b3NpemluZ0NvbnRhaW5lcik6CisgICAgICAgIChX ZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpjb250YWluZXJDb250YWluc1RhZ3MpOgorICAgICAgICAo V2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6bWVhc3VyZURlc2NlbmRhbnRUZXh0V2lkdGgpOgorICAg ICAgICAoV2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6ZmluZERlZXBlc3RCbG9ja0NvbnRhaW5pbmdB bGxUZXh0KToKKyAgICAgICAgKiByZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oOgorCiAyMDEyLTEy LTA0ICBBbnRvaW5lIFF1aW50ICA8Z3Jhb3V0c0BhcHBsZS5jb20+CiAKICAgICAgICAgVGV4dFRy YWNrJ3MgLmtpbmQgcHJvcGVydHkgc2hvdWxkIHJldHVybiBsb3dlci1jYXNlIHZhbHVlcwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwCmluZGV4IGIxMDJiMmI1YjI5 Mzc1YzcyODQ5MmMxYzk4NGJmN2Y4NjVkODcyMjEuLmU5NzY2ODBjMzUzZjk3MmMwNGQ5MmM2ZTQ3 OWRmZTA3ZWJiMzI3MTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0 QXV0b3NpemVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXpl ci5jcHAKQEAgLTI1LDYgKzI1LDcgQEAKICNpbmNsdWRlICJUZXh0QXV0b3NpemVyLmgiCiAKICNp bmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCiAjaW5jbHVkZSAi SW5zcGVjdG9ySW5zdHJ1bWVudGF0aW9uLmgiCiAjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCiAj aW5jbHVkZSAiUmVuZGVyU3R5bGUuaCIKQEAgLTM3LDYgKzM4LDggQEAKIAogbmFtZXNwYWNlIFdl YkNvcmUgewogCit1c2luZyBuYW1lc3BhY2UgSFRNTE5hbWVzOworCiBzdHJ1Y3QgVGV4dEF1dG9z aXppbmdXaW5kb3dJbmZvIHsKICAgICBJbnRTaXplIHdpbmRvd1NpemU7CiAgICAgSW50U2l6ZSBt aW5MYXlvdXRTaXplOwpAQCAtMTE5LDcgKzEyMiwyMCBAQCB2b2lkIFRleHRBdXRvc2l6ZXI6OnBy b2Nlc3NDbHVzdGVyKFJlbmRlckJsb2NrKiBjbHVzdGVyLCBSZW5kZXJCbG9jayogY29udGFpbmVy LAogICAgIHByb2Nlc3NDb250YWluZXIobXVsdGlwbGllciwgY29udGFpbmVyLCBzdWJ0cmVlUm9v dCwgd2luZG93SW5mbyk7CiB9CiAKLXN0YXRpYyBib29sIGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFp bmVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIpCitib29sIFRleHRBdXRvc2l6ZXI6OmNv bnRhaW5lclNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIpCit7 CisgICAgVmVjdG9yPFF1YWxpZmllZE5hbWU+IHRhZ3M7CisgICAgdGFncy5hcHBlbmQoaW5wdXRU YWcpOworICAgIHRhZ3MuYXBwZW5kKHRleHRhcmVhVGFnKTsKKyAgICB0YWdzLmFwcGVuZChidXR0 b25UYWcpOworICAgIHRhZ3MuYXBwZW5kKHNlbGVjdFRhZyk7CisgICAgaWYgKGNvbnRhaW5lckNv bnRhaW5zVGFncyhjb250YWluZXIsIHRhZ3MpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAg ICByZXR1cm4gIWNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnRhaW5lcik7Cit9CisKK2Jv b2wgVGV4dEF1dG9zaXplcjo6Y29udGVudEhlaWdodElzQ29uc3RyYWluZWQoY29uc3QgUmVuZGVy QmxvY2sqIGNvbnRhaW5lcikKIHsKICAgICAvLyBGSVhNRTogUHJvcGFnYXRlIGNvbnN0cmFpbmVk bmVzcyBkb3duIHRoZSB0cmVlLCB0byBhdm9pZCBpbmVmZmljaWVudGx5IHdhbGtpbmcgYmFjayB1 cCBmcm9tIGVhY2ggYm94LgogICAgIC8vIEZJWE1FOiBUaGlzIGNvZGUgbmVlZHMgdG8gdGFrZSBp bnRvIGFjY291bnQgdmVydGljYWwgd3JpdGluZyBtb2Rlcy4KQEAgLTE0Myw3ICsxNTksNyBAQCB2 b2lkIFRleHRBdXRvc2l6ZXI6OnByb2Nlc3NDb250YWluZXIoZmxvYXQgbXVsdGlwbGllciwgUmVu ZGVyQmxvY2sqIGNvbnRhaW5lciwgUgogewogICAgIEFTU0VSVChpc0F1dG9zaXppbmdDb250YWlu ZXIoY29udGFpbmVyKSk7CiAKLSAgICBmbG9hdCBsb2NhbE11bHRpcGxpZXIgPSBjb250ZW50SGVp Z2h0SXNDb25zdHJhaW5lZChjb250YWluZXIpID8gMSA6IG11bHRpcGxpZXI7CisgICAgZmxvYXQg bG9jYWxNdWx0aXBsaWVyID0gY29udGFpbmVyU2hvdWxkQmVBdXRvc2l6ZWQoY29udGFpbmVyKSA/ IG11bHRpcGxpZXIgOiAxOwogCiAgICAgUmVuZGVyT2JqZWN0KiBkZXNjZW5kYW50ID0gbmV4dElu UHJlT3JkZXJTa2lwcGluZ0Rlc2NlbmRhbnRzT2ZDb250YWluZXJzKHN1YnRyZWVSb290LCBzdWJ0 cmVlUm9vdCk7CiAgICAgd2hpbGUgKGRlc2NlbmRhbnQpIHsKQEAgLTIxMSw2ICsyMjcsMTMgQEAg Ym9vbCBUZXh0QXV0b3NpemVyOjppc0F1dG9zaXppbmdDb250YWluZXIoY29uc3QgUmVuZGVyT2Jq ZWN0KiByZW5kZXJlcikKICAgICAgICAgcmV0dXJuIGZhbHNlOwogICAgIGlmIChyZW5kZXJlci0+ aXNMaXN0SXRlbSgpKQogICAgICAgICByZXR1cm4gcmVuZGVyZXItPmlzRmxvYXRpbmcoKSB8fCBy ZW5kZXJlci0+aXNPdXRPZkZsb3dQb3NpdGlvbmVkKCk7CisgICAgLy8gYXZvaWQgY3JlYXRpbmcg Y29udGFpbmVycyBmb3IgdGV4dCB3aXRoaW4gdGV4dCBjb250cm9scywgYnV0dG9ucywgb3Igc2Vs ZWN0aW9uIG1lbnVzLgorICAgIFJlbmRlck9iamVjdCogcGFyZW50ID0gcmVuZGVyZXItPnBhcmVu dCgpOworICAgIGlmIChwYXJlbnQpIHsKKyAgICAgICAgaWYgKHBhcmVudC0+aXNSZW5kZXJCdXR0 b24oKSB8fCBwYXJlbnQtPmlzVGV4dENvbnRyb2woKSB8fCBwYXJlbnQtPmlzTWVudUxpc3QoKSkK KyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisKICAgICByZXR1cm4gdHJ1ZTsKIH0K IApAQCAtMjcxLDkgKzI5NCwzNSBAQCBib29sIFRleHRBdXRvc2l6ZXI6OmNsdXN0ZXJTaG91bGRC ZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayogbG93ZXN0Q29tbW9uQW5jZQogICAgIHJldHVy biBmYWxzZTsKIH0KIAorYm9vbCBUZXh0QXV0b3NpemVyOjpjb250YWluZXJDb250YWluc1RhZ3Mo Y29uc3QgUmVuZGVyT2JqZWN0KiBjb250YWluZXIsIFZlY3RvcjxRdWFsaWZpZWROYW1lPiYgdGFn cykKK3sKKyAgICBjb25zdCBOb2RlKiBjb250YWluZXJOb2RlID0gY29udGFpbmVyLT5ub2RlKCk7 CisgICAgYm9vbCB2YWxpZENhbmRpZGF0ZSA9IGNvbnRhaW5lck5vZGUgJiYgY29udGFpbmVyTm9k ZS0+aXNIVE1MRWxlbWVudCgpICYmICFjb250YWluZXJOb2RlLT5pc1NoYWRvd1Jvb3QoKTsKKyAg ICBpZiAodmFsaWRDYW5kaWRhdGUpIHsKKyAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCB0 YWdzLnNpemUoKTsgKytpKSB7CisgICAgICAgICAgICBpZiAoY29udGFpbmVyTm9kZS0+aGFzVGFn TmFtZSh0YWdzW2ldKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQor ICAgIH0KKworICAgIFJlbmRlck9iamVjdCogZGVzY2VuZGFudCA9IG5leHRJblByZU9yZGVyU2tp cHBpbmdEZXNjZW5kYW50c09mQ29udGFpbmVycyhjb250YWluZXIsIGNvbnRhaW5lcik7CisgICAg d2hpbGUgKGRlc2NlbmRhbnQpIHsKKyAgICAgICAgY29uc3QgTm9kZSogZGVzY2VuZGFudE5vZGUg PSBkZXNjZW5kYW50LT5ub2RlKCk7CisgICAgICAgIGJvb2wgdmFsaWRDYW5kaWRhdGUgPSBkZXNj ZW5kYW50Tm9kZSAmJiBkZXNjZW5kYW50Tm9kZS0+aXNIVE1MRWxlbWVudCgpICYmICFkZXNjZW5k YW50Tm9kZS0+aXNTaGFkb3dSb290KCk7CisgICAgICAgIGlmICh2YWxpZENhbmRpZGF0ZSkgewor ICAgICAgICAgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCB0YWdzLnNpemUoKTsgKytpKSB7Cisg ICAgICAgICAgICAgICAgaWYgKGRlc2NlbmRhbnROb2RlLT5oYXNUYWdOYW1lKHRhZ3NbaV0pKQor ICAgICAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgICAgIH0KKyAgICAgICAg fQorICAgICAgICBkZXNjZW5kYW50ID0gbmV4dEluUHJlT3JkZXJTa2lwcGluZ0Rlc2NlbmRhbnRz T2ZDb250YWluZXJzKGRlc2NlbmRhbnQsIGNvbnRhaW5lcik7CisgICAgfQorICAgIHJldHVybiBm YWxzZTsKK30KKwogdm9pZCBUZXh0QXV0b3NpemVyOjptZWFzdXJlRGVzY2VuZGFudFRleHRXaWR0 aChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyLCBmbG9hdCBtaW5UZXh0V2lkdGgsIGZsb2F0 JiB0ZXh0V2lkdGgpCiB7Ci0gICAgYm9vbCBza2lwTG9jYWxUZXh0ID0gY29udGVudEhlaWdodElz Q29uc3RyYWluZWQoY29udGFpbmVyKTsKKyAgICBib29sIHNraXBMb2NhbFRleHQgPSAhY29udGFp bmVyU2hvdWxkQmVBdXRvc2l6ZWQoY29udGFpbmVyKTsKIAogICAgIFJlbmRlck9iamVjdCogZGVz Y2VuZGFudCA9IG5leHRJblByZU9yZGVyU2tpcHBpbmdEZXNjZW5kYW50c09mQ29udGFpbmVycyhj b250YWluZXIsIGNvbnRhaW5lcik7CiAgICAgd2hpbGUgKGRlc2NlbmRhbnQpIHsKQEAgLTMxOSw3 ICszNjgsNyBAQCBjb25zdCBSZW5kZXJCbG9jayogVGV4dEF1dG9zaXplcjo6ZmluZERlZXBlc3RC bG9ja0NvbnRhaW5pbmdBbGxUZXh0KGNvbnN0IFJlbmRlcgogICAgIGNvbnN0IFJlbmRlck9iamVj dCogbGFzdFRleHRMZWFmID0gZmluZEZpcnN0VGV4dExlYWZOb3RJbkNsdXN0ZXIoY2x1c3Rlciwg bGFzdERlcHRoLCBMYXN0VG9GaXJzdCk7CiAgICAgQVNTRVJUKGxhc3RUZXh0TGVhZik7CiAKLSAg ICAvLyBFcXVhbGl6ZSB0aGUgZGVwdGhzIGlmIG5lY2Vzc2FyeS4gT25seSBvbmUgb2YgdGhlIHdo aWxlIGxvb3BzIGJlbG93IHdpbGwgZ2V0IGV4ZWN1dGVkLgorICAgIC8vIEVxdWFsaXplIHRoZSBk ZXB0aHMgaWYgY29udGFpbmVyU2hvdWxkQmVBdXRvc2l6ZWQgbmVjZXNzYXJ5LiBPbmx5IG9uZSBv ZiB0aGUgd2hpbGUgbG9vcHMgYmVsb3cgd2lsbCBnZXQgZXhlY3V0ZWQuCiAgICAgY29uc3QgUmVu ZGVyT2JqZWN0KiBmaXJzdE5vZGUgPSBmaXJzdFRleHRMZWFmOwogICAgIGNvbnN0IFJlbmRlck9i amVjdCogbGFzdE5vZGUgPSBsYXN0VGV4dExlYWY7CiAgICAgd2hpbGUgKGZpcnN0RGVwdGggPiBs YXN0RGVwdGgpIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0 b3NpemVyLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oCmluZGV4 IGE3MDliMTE2OGU0NGRmMDBlYzFmOWQ3M2JiZTVlNTE2ZmU5MjY3NzQuLjhmMGZkOTgyNGYyM2Iz NjBiOWU0ZGNiMTU4ZmJkODIzZmZkNjRiYmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9UZXh0QXV0b3NpemVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Rl eHRBdXRvc2l6ZXIuaApAQCAtMjgsNiArMjgsNyBAQAogCiAjaWYgRU5BQkxFKFRFWFRfQVVUT1NJ WklORykKIAorI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkludFNpemUuaCIKICNp bmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgpA QCAtNzEsNiArNzIsOSBAQCBwcml2YXRlOgogICAgIHN0YXRpYyBib29sIGlzQXV0b3NpemluZ0Ns dXN0ZXIoY29uc3QgUmVuZGVyQmxvY2sqKTsKIAogICAgIHN0YXRpYyBib29sIGNsdXN0ZXJTaG91 bGRCZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayogbG93ZXN0Q29tbW9uQW5jZXN0b3IsIGZs b2F0IGNvbW1vbkFuY2VzdG9yV2lkdGgpOworICAgIHN0YXRpYyBib29sIGNvbnRhaW5lclNob3Vs ZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIpOworICAgIHN0YXRpYyBi b29sIGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWlu ZXIpOworICAgIHN0YXRpYyBib29sIGNvbnRhaW5lckNvbnRhaW5zVGFncyhjb25zdCBSZW5kZXJP YmplY3QqIGNsdXN0ZXIsIFZlY3RvcjxRdWFsaWZpZWROYW1lPiYgdGFncyk7CiAgICAgc3RhdGlj IHZvaWQgbWVhc3VyZURlc2NlbmRhbnRUZXh0V2lkdGgoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRh aW5lciwgZmxvYXQgbWluVGV4dFdpZHRoLCBmbG9hdCYgdGV4dFdpZHRoKTsKIAogICAgIC8vIFVz ZSB0byB0cmF2ZXJzZSB0aGUgdHJlZSBvZiBkZXNjZW5kYW50cywgZXhjbHVkaW5nIGRlc2NlbmRh bnRzIG9mIGNvbnRhaW5lcnMgKGJ1dCByZXR1cm5pbmcgdGhlIGNvbnRhaW5lcnMgdGhlbXNlbHZl cykuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKaW5kZXggYTg5ZGQ0NWY0NTQwYjVjODM2Zjg0YzJmNGQwN2RmNDU5NzE5ZWQxZi4uZThm NjU1YTZlZGYxOTg1ZGI5ZTQ1ZDVjOTQ4NzAyNWM5NDM5OTE2YyAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIy IEBACisyMDEyLTEyLTEyICBUaW0gVm9sb2RpbmUgIDx0aW12b2xvZGluZUBnb29nbGUuY29tPgor CisgICAgICAgIFRleHQgQXV0b3NpemluZzogV29yayBvdXQgd2hhdCB0byBkbyBhYm91dCBmb3Jt IGNvbnRyb2xzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0xMDI1NjAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBUZXN0cyBmb3IgZm9ybSBpbnB1dCBlbGVtZW50cyBhdXRvc2l6aW5nLiBBZGRlZCB0ZXN0cyB0 byBjaGVjayB0aGF0IHZhcmlvdXMga2luZHMgb2YgZm9ybSBlbGVtZW50cworICAgICAgICBkb24n dCBnZXQgYXV0b3NpemVkLCBpLmUuIGJ1dHRvbnMsIHRleHRhcmVhcywgY2hlY2sgYm94ZXMsIHJh ZGlvIGJ1dHRvbiBhbmQgc2VsZWN0aW9uIG1lbnVzLgorCisgICAgICAgICogZmFzdC90ZXh0LWF1 dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1idXR0b24tdGV4dGFyZWEtaW5wdXQtZWxl bWVudHMtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXpp bmcvZm9ybS1jb250cm9scy1ib29zdGluZy1idXR0b24tdGV4dGFyZWEtaW5wdXQtZWxlbWVudHMu aHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1ib29zdGluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWw6IEFkZGVkLgor ICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctY2hl Y2tib3gtaW5wdXQtZWxlbWVudC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0 b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXJhZGlvLWlucHV0LWVsZW1lbnQtZXhwZWN0 ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250 cm9scy1ib29zdGluZy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0bWw6IEFkZGVkLgorICAgICAgICAq IGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3Rpbmctc2VsZWN0LWVsZW1l bnQtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcv Zm9ybS1jb250cm9scy1ib29zdGluZy1zZWxlY3QtZWxlbWVudC5odG1sOiBBZGRlZC4KKwogMjAx Mi0xMi0wNCAgQW50b2luZSBRdWludCAgPGdyYW91dHNAYXBwbGUuY29tPgogCiAgICAgICAgIFRl eHRUcmFjaydzIC5raW5kIHByb3BlcnR5IHNob3VsZCByZXR1cm4gbG93ZXItY2FzZSB2YWx1ZXMK ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYm9vc3RpbmctYnV0dG9uLXRleHRhcmVhLWlucHV0LWVsZW1lbnRzLWV4cGVjdGVkLmh0bWwg Yi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5n LWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu Ljg4ZmM4NmM2YWNkZjc4NzE5Yjg3ZDY0MjMzYjUzMzczNmJiMGM4ZmEKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0 aW5nLWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1sCkBAIC0wLDAg KzEsMTA3IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9 InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3 aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAg ICBmb250LWZhbWlseTogVmVyZGFuYSwgc2Fucy1zZXJpZjsKKyAgICBmb250LXNpemU6IHNtYWxs OworICB9CisgIAorICAjYm9vc3RlZCB7CisgICAgZm9udC1zaXplOiAyLjA1cmVtOworICB9Cisg IAorICAjaGVhZGVyIGZvcm0geworICAgIGZvbnQtc2l6ZTogODUlOworICAgIGRpc3BsYXk6IGlu bGluZTsKKyAgfQorICAKKyAgI2hlYWRlciAubGlua3MgeworICAgIGZvbnQtc2l6ZTogODUlOwor ICB9CisgIAorICB1bC5saW5rcyB7CisgICAgbWFyZ2luOiAwOworICAgIHBhZGRpbmc6IDA7Cisg ICAgbGlzdC1zdHlsZS10eXBlOiBub25lOworICB9CisKKyAgdWwubGlua3MgbGkgeworICAgIGRp c3BsYXk6IGlubGluZTsKKyAgICB3aGl0ZS1zcGFjZTogbm93cmFwOworICB9Cis8L3N0eWxlPgor Cis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBpZD0iaGVhZGVyIj4KKyAgPHVsIGNsYXNzPSJsaW5r cyI+CisgICAgPGxpPgorICAgICAgPGEgaHJlZj0iLi8iPkhvbWU8L2E+CisgICAgPC9saT4KKyAg ICA8bGk+CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAgICAgIDxhIGhyZWY9IiI+TmV3PC9hPgor ICAgIDwvbGk+CisgICAgPGxpPgorICAgICAgPHNwYW4+fCA8L3NwYW4+CisgICAgICA8YSBocmVm PSIiPlNlYXJjaDwvYT4KKyAgICA8L2xpPgorICAgIDxsaT4KKyAgICAgIDxzcGFuPnwgPC9zcGFu PgorICAgICAgPGZvcm0+CisgICAgICAgIDxpbnB1dCBjbGFzcz0idHh0IiB0eXBlPSJ0ZXh0IiBp ZD0icXVpY2tzZWFyY2hfdG9wIiBuYW1lPSJxdWlja3NlYXJjaCI+CisgICAgICAgIDxpbnB1dCBj bGFzcz0iYnRuIiB0eXBlPSJzdWJtaXQiIHZhbHVlPSJGaW5kIiBpZD1maW5kX3RvcCI+CisgICAg ICA8L2Zvcm0+CisgICAgPC9saT4KKyAgICA8bGk+CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAg ICAgIDxhIGhyZWY9IiI+UmVwb3J0czwvYT4KKyAgICA8L2xpPgorICA8L3VsPgorPC9kaXY+CisK KzxkaXY+CisgIDxwPjxkaXYgaWQ9ImJvb3N0ZWQiPlRoaXMgdGVzdCBjaGVja3MgdGhhdCBmcm9t IGNvbnRyb2xzIGxpa2UgYnV0dG9ucywgdGV4dCBpbnB1dHMgYW5kIGNoZWNrLWJveGVzIGFyZSBu b3QgYXV0b3NpemVkLgorICAgIFRoZSB0ZXh0IGluIHRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBh dXRvc2l6ZWQsIHdoaWxlIHRoZSBmb3JtIGNvbnRyb2xzIGluIHRoZSBoZWFkZXIgYW5kIGluIHRo ZSB0YWJsZS1sYXlvdXQKKyAgICBiZWxvdyBzaG91bGQgbm90LiBBbHNvIHRoZSAiRmluZCIgYnV0 dG9uIGFuZCB0ZXh0LWlucHV0IGJveCBhdCB0aGUgYm90dG9tIG9mIHRoZSBwYWdlIHNob3VsZCBu b3QgYmUgYXV0b3NpemVkLgorICA8L2Rpdj48L3A+CisKKyAgPGZvcm0gbmFtZT0ibG9naW4iIGFj dGlvbj0iIiBtZXRob2Q9IlBPU1QiPgorICA8dGFibGU+CisgICAgPHRyPgorICAgICAgPHRoIGFs aWduPSJyaWdodCI+PGxhYmVsIGZvcj0iQnVnemlsbGFfbG9naW4iPkxvZ2luOjwvbGFiZWw+PC90 aD4KKyAgICAgIDx0ZD48aW5wdXQgc2l6ZT0iMjAiIGlkPSJCdWd6aWxsYV9sb2dpbiIgbmFtZT0i QnVnemlsbGFfbG9naW4iPjwvdGQ+CisgICAgPC90cj4KKyAgICA8dHI+CisgICAgICA8dGggYWxp Z249InJpZ2h0Ij48bGFiZWwgZm9yPSJCdWd6aWxsYV9wYXNzd29yZCI+UGFzc3dvcmQ6PC9sYWJl bD48L3RoPgorICAgICAgPHRkPgorICAgICAgICA8aW5wdXQgdHlwZT0icGFzc3dvcmQiIHNpemU9 IjIwIiBpZD0iQnVnemlsbGFfcGFzc3dvcmQiIG5hbWU9IkJ1Z3ppbGxhX3Bhc3N3b3JkIj4KKyAg ICAgIDwvdGQ+CisgICAgPC90cj4KKyAgICA8dHI+CisgICAgICA8dGQ+PGlucHV0IHR5cGU9InN1 Ym1pdCIgbmFtZT0iR29BaGVhZEFuZExvZ0luIiB2YWx1ZT0iTG9naW4iIGlkPSJsb2dfaW4iPjwv dGQ+CisgICAgICA8dGQ+WyA8YSBocmVmPSIiPkZvcmdvdCBteSBQYXNzd29yZDwvYT4gXTwvdGQ+ CisgICAgPC90cj4KKyAgPC90YWJsZT4KKyAgPC9mb3JtPgorICAKKyAgPGZvcm0+CisgIDxkaXY+ CisgICAgPHA+PGRpdiBpZD0iYm9vc3RlZCI+VGhpcyB0ZXh0IHNob3VsZCBiZSBhdXRvc2l6ZWQs IHdoaWxlIHRoZSBpbnB1dCBjb250cm9scyBiZWxvdyBzaG91bGQgbm90LjwvZGl2PjwvcD4KKyAg ICA8aW5wdXQgaWQ9InF1aWNrc2VhcmNoIiB0eXBlPSJ0ZXh0IiBuYW1lPSJxdWlja3NlYXJjaCI+ CisgICAgPGlucHV0IGlkPSJmaW5kIiB0eXBlPSJzdWJtaXQiIHZhbHVlPSJGaW5kIj4KKyAgICA8 YSBocmVmPSIiPltIZWxwXTwvYT4KKyAgPC9kaXY+CisgIDwvZm9ybT4KKworPC9kaXY+CisKKzwv Ym9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6 aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctYnV0dG9uLXRleHRhcmVhLWlucHV0LWVsZW1lbnRz Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJv b3N0aW5nLWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50cy5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA4 YzllOGIzMDRhY2FhNTAzMTQzYWU4YTE1ODljMjg0MmI4NzcxYTEKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5n LWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50cy5odG1sCkBAIC0wLDAgKzEsMTEyIEBACis8 IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBj b250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7 CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgICBmb250LWZhbWls eTogVmVyZGFuYSwgc2Fucy1zZXJpZjsKKyAgICBmb250LXNpemU6IHNtYWxsOworICB9CisgIAor ICAjaGVhZGVyIGZvcm0geworICAgIGZvbnQtc2l6ZTogODUlOworICAgIGRpc3BsYXk6IGlubGlu ZTsKKyAgfQorICAKKyAgI2hlYWRlciAubGlua3MgeworICAgIGZvbnQtc2l6ZTogODUlOworICB9 CisgIAorICB1bC5saW5rcyB7CisgICAgbWFyZ2luOiAwOworICAgIHBhZGRpbmc6IDA7CisgICAg bGlzdC1zdHlsZS10eXBlOiBub25lOworICB9CisKKyAgdWwubGlua3MgbGkgeworICAgIGRpc3Bs YXk6IGlubGluZTsKKyAgICB3aGl0ZS1zcGFjZTogbm93cmFwOworICB9Cis8L3N0eWxlPgorCis8 c2NyaXB0PgoraWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNl dHRpbmdzLnNldFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5kb3cuaW50ZXJu YWxzLnNldHRpbmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRlKDMyMCwgNDgw KTsKK30gZWxzZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7CisgICAgY29u c29sZS53YXJuKCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6aW5nIHNldHRp bmcgYmVpbmcgdHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBtYW51YWxseSBl bmFibGUgVGV4dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBkZXZpY2Ugd2l0 aCAzMjBweCBkZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBvciBkZWZpbmUg SEFDS19GT1JDRV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwvc2NyaXB0Pgor Cis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBpZD0iaGVhZGVyIj4KKyAgPHVsIGNsYXNzPSJsaW5r cyI+CisgICAgPGxpPgorICAgICAgPGEgaHJlZj0iLi8iPkhvbWU8L2E+CisgICAgPC9saT4KKyAg ICA8bGk+CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAgICAgIDxhIGhyZWY9IiI+TmV3PC9hPgor ICAgIDwvbGk+CisgICAgPGxpPgorICAgICAgPHNwYW4+fCA8L3NwYW4+CisgICAgICA8YSBocmVm PSIiPlNlYXJjaDwvYT4KKyAgICA8L2xpPgorICAgIDxsaT4KKyAgICAgIDxzcGFuPnwgPC9zcGFu PgorICAgICAgPGZvcm0+CisgICAgICAgIDxpbnB1dCBjbGFzcz0idHh0IiB0eXBlPSJ0ZXh0IiBp ZD0icXVpY2tzZWFyY2hfdG9wIiBuYW1lPSJxdWlja3NlYXJjaCI+CisgICAgICAgIDxpbnB1dCBj bGFzcz0iYnRuIiB0eXBlPSJzdWJtaXQiIHZhbHVlPSJGaW5kIiBpZD1maW5kX3RvcCI+CisgICAg ICA8L2Zvcm0+CisgICAgPC9saT4KKyAgICA8bGk+CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAg ICAgIDxhIGhyZWY9IiI+UmVwb3J0czwvYT4KKyAgICA8L2xpPgorICA8L3VsPgorPC9kaXY+CisK KzxkaXY+CisgIDxwPlRoaXMgdGVzdCBjaGVja3MgdGhhdCBmcm9tIGNvbnRyb2xzIGxpa2UgYnV0 dG9ucywgdGV4dCBpbnB1dHMgYW5kIGNoZWNrLWJveGVzIGFyZSBub3QgYXV0b3NpemVkLgorICAg IFRoZSB0ZXh0IGluIHRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQsIHdoaWxlIHRo ZSBmb3JtIGNvbnRyb2xzIGluIHRoZSBoZWFkZXIgYW5kIGluIHRoZSB0YWJsZS1sYXlvdXQKKyAg ICBiZWxvdyBzaG91bGQgbm90LiBBbHNvIHRoZSAiRmluZCIgYnV0dG9uIGFuZCB0ZXh0LWlucHV0 IGJveCBhdCB0aGUgYm90dG9tIG9mIHRoZSBwYWdlIHNob3VsZCBub3QgYmUgYXV0b3NpemVkLgor ICA8L3A+CisKKyAgPGZvcm0gbmFtZT0ibG9naW4iIGFjdGlvbj0iIiBtZXRob2Q9IlBPU1QiPgor ICA8dGFibGU+CisgICAgPHRyPgorICAgICAgPHRoIGFsaWduPSJyaWdodCI+PGxhYmVsIGZvcj0i QnVnemlsbGFfbG9naW4iPkxvZ2luOjwvbGFiZWw+PC90aD4KKyAgICAgIDx0ZD48aW5wdXQgc2l6 ZT0iMjAiIGlkPSJCdWd6aWxsYV9sb2dpbiIgbmFtZT0iQnVnemlsbGFfbG9naW4iPjwvdGQ+Cisg ICAgPC90cj4KKyAgICA8dHI+CisgICAgICA8dGggYWxpZ249InJpZ2h0Ij48bGFiZWwgZm9yPSJC dWd6aWxsYV9wYXNzd29yZCI+UGFzc3dvcmQ6PC9sYWJlbD48L3RoPgorICAgICAgPHRkPgorICAg ICAgICA8aW5wdXQgdHlwZT0icGFzc3dvcmQiIHNpemU9IjIwIiBpZD0iQnVnemlsbGFfcGFzc3dv cmQiIG5hbWU9IkJ1Z3ppbGxhX3Bhc3N3b3JkIj4KKyAgICAgIDwvdGQ+CisgICAgPC90cj4KKyAg ICA8dHI+CisgICAgICA8dGQ+PGlucHV0IHR5cGU9InN1Ym1pdCIgbmFtZT0iR29BaGVhZEFuZExv Z0luIiB2YWx1ZT0iTG9naW4iIGlkPSJsb2dfaW4iPjwvdGQ+CisgICAgICA8dGQ+WyA8YSBocmVm PSIiPkZvcmdvdCBteSBQYXNzd29yZDwvYT4gXTwvdGQ+CisgICAgPC90cj4KKyAgPC90YWJsZT4K KyAgPC9mb3JtPgorICAKKyAgPGZvcm0+CisgIDxkaXY+CisgICAgPHA+VGhpcyB0ZXh0IHNob3Vs ZCBiZSBhdXRvc2l6ZWQsIHdoaWxlIHRoZSBpbnB1dCBjb250cm9scyBiZWxvdyBzaG91bGQgbm90 LjwvcD4KKyAgICA8aW5wdXQgaWQ9InF1aWNrc2VhcmNoIiB0eXBlPSJ0ZXh0IiBuYW1lPSJxdWlj a3NlYXJjaCI+CisgICAgPGlucHV0IGlkPSJmaW5kIiB0eXBlPSJzdWJtaXQiIHZhbHVlPSJGaW5k Ij4KKyAgICA8YSBocmVmPSIiPltIZWxwXTwvYT4KKyAgPC9kaXY+CisgIDwvZm9ybT4KKworPC9k aXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4 dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctY2hlY2tib3gtaW5wdXQtZWxlbWVu dC1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1j b250cm9scy1ib29zdGluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uN2UwMDNjN2Y4YzhiMGM1Njc2ZmM1MzdkNzA4MTRlMTJiN2E3NWMzNAotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYm9vc3RpbmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sCkBAIC0wLDAg KzEsNDAgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0i dmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdp ZHRoOiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICAg IGZvbnQtZmFtaWx5OiBWZXJkYW5hLCBzYW5zLXNlcmlmOworICAgIGZvbnQtc2l6ZTogc21hbGw7 CisgIH0KKyAgCisgICNib29zdGVkIHsKKyAgICBmb250LXNpemU6IDIuMDVyZW07CisgIH0KKzwv c3R5bGU+CisKKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+Cis8ZGl2IGlkPSJib29zdGVkIj4K K1RoaXMgdGVzdHMgdGhlIGJvb3N0aW5nIG9mIGNoZWNrIGJveGVzLiBUaGlzIHBhcmFncmFwaCBz aG91bGQgYmUgYm9vc3RlZCwgd2hpbGUKK3RoZSBjaGVjayBib3hlcyBiZWxvdyBzaG91bGQgbm90 IGJlIGF1dG9zaXplZC4gKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrCisrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKworPC9kaXY+Cis8ZGl2Pgor PGZvcm0gYWN0aW9uPSIiPgorQ2hlY2sgb25lIG9yIG1vcmU6Cis8aW5wdXQgdHlwZT0iY2hlY2ti b3giIG5hbWU9InZlaGljbGUiIHZhbHVlPSJCaWtlIj5JIGhhdmUgYSBiaWtlPGJyLz4KKzxpbnB1 dCB0eXBlPSJjaGVja2JveCIgbmFtZT0idmVoaWNsZSIgdmFsdWU9IkNhciI+SSBoYXZlIGEgY2Fy IDxici8+Cis8L2Zvcm0+Cis8L2Rpdj4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJv b3N0aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4 dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctY2hlY2tib3gtaW5wdXQtZWxlbWVu dC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLmI0NWFiOTlhNzU3NGY5MDdkMmRlZDQzNzU4ZWNkMzY3NjdiZDA1 NTEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9m b3JtLWNvbnRyb2xzLWJvb3N0aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbApAQCAtMCww ICsxLDQ0IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9 InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3 aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAg ICBmb250LWZhbWlseTogVmVyZGFuYSwgc2Fucy1zZXJpZjsKKyAgICBmb250LXNpemU6IHNtYWxs OworICB9Cis8L3N0eWxlPgorCis8c2NyaXB0PgoraWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAg ICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVl KTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93 U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30gZWxzZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29u c29sZS53YXJuKSB7CisgICAgY29uc29sZS53YXJuKCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUg VGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVpbmcgdHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5k ZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUgVGV4dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVz ZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBweCBkZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBv ciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19GT1JDRV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RP UC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdj4KKzxkaXY+CitU aGlzIHRlc3RzIHRoZSBib29zdGluZyBvZiBjaGVjayBib3hlcy4gVGhpcyBwYXJhZ3JhcGggc2hv dWxkIGJlIGJvb3N0ZWQsIHdoaWxlCit0aGUgY2hlY2sgYm94ZXMgYmVsb3cgc2hvdWxkIG5vdCBi ZSBhdXRvc2l6ZWQuICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KworKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKKzwvZGl2PgorPGRpdj4KKzxm b3JtIGFjdGlvbj0iIj4KK0NoZWNrIG9uZSBvciBtb3JlOgorPGlucHV0IHR5cGU9ImNoZWNrYm94 IiBuYW1lPSJ2ZWhpY2xlIiB2YWx1ZT0iQmlrZSI+SSBoYXZlIGEgYmlrZTxici8+Cis8aW5wdXQg dHlwZT0iY2hlY2tib3giIG5hbWU9InZlaGljbGUiIHZhbHVlPSJDYXIiPkkgaGF2ZSBhIGNhciA8 YnIvPgorPC9mb3JtPgorPC9kaXY+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29z dGluZy1yYWRpby1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0 L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXJhZGlvLWlucHV0LWVsZW1l bnQtZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45Y2FmMDA5ZjEzZmY4NTk3NDQ3Njc4ODQ2NjNj YmU2YTU3MmQwODU5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1 dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1yYWRpby1pbnB1dC1lbGVtZW50LWV4cGVj dGVkLmh0bWwKQEAgLTAsMCArMSw0NCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFk PgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4K KyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxv dy15OiBoaWRkZW47CisgICAgZm9udC1mYW1pbHk6IFZlcmRhbmEsIHNhbnMtc2VyaWY7CisgICAg Zm9udC1zaXplOiBzbWFsbDsKKyAgfQorICAKKyAgI2Jvb3N0ZWQgeworICAgIGZvbnQtc2l6ZTog Mi4wNXJlbTsKKyAgfQorPC9zdHlsZT4KKworCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdj4KKzxk aXYgaWQ9ImJvb3N0ZWQiPgorVGhpcyB0ZXN0cyB0aGUgYm9vc3Rpbmcgb2YgcmFkaW8gYnV0dG9u cy4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGJvb3N0ZWQsIHdoaWxlCit0aGUgcmFkaW8gYnV0 dG9ucyBiZWxvdyBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4gKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKworKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysKKzwvZGl2PgorPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KK1NlbGVjdCBvbmUgb2Y6Cis8aW5w dXQgdHlwZT0icmFkaW8iIHZhbHVlPSIxIiBpZD0icmFkaW8xIiBjaGVja2VkPSJjaGVja2VkIi8+ PGJyLz4KKzxsYWJlbCBmb3I9InJhZGlvMSI+UmFkaW8xPC9sYWJlbD4KKzxpbnB1dCB0eXBlPSJy YWRpbyIgdmFsdWU9IjIiIGlkPSJyYWRpbzIiLz48YnIvPgorPGxhYmVsIGZvcj0icmFkaW8yIj5S YWRpbzI8L2xhYmVsPgorPGlucHV0IHR5cGU9InJhZGlvIiB2YWx1ZT0iMyIgaWQ9InJhZGlvMyIv Pjxici8+Cis8bGFiZWwgZm9yPSJyYWRpbzMiPlJhZGlvMzwvbGFiZWw+Cis8L2Zvcm0+Cis8L2Rp dj4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9m YXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXJhZGlvLWlucHV0LWVs ZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYm9vc3RpbmctcmFkaW8taW5wdXQtZWxlbWVudC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjI1OTEzOWJj MDBhNDEzYzUyZGQyOTZiNmY4MzI1YmI4YTk0MDQ4ZTQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXJhZGlv LWlucHV0LWVsZW1lbnQuaHRtbApAQCAtMCwwICsxLDQ4IEBACis8IURPQ1RZUEUgaHRtbD4KKzxo dG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAi PgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOwor ICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgICBmb250LWZhbWlseTogVmVyZGFuYSwgc2Fucy1z ZXJpZjsKKyAgICBmb250LXNpemU6IHNtYWxsOworICB9Cis8L3N0eWxlPgorCis8c2NyaXB0Pgor aWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNl dFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRp bmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30gZWxz ZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7CisgICAgY29uc29sZS53YXJu KCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVpbmcg dHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUgVGV4 dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBweCBk ZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19GT1JD RV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hlYWQ+ Cis8Ym9keT4KKworPGRpdj4KKzxkaXY+CitUaGlzIHRlc3RzIHRoZSBib29zdGluZyBvZiByYWRp byBidXR0b25zLiBUaGlzIHBhcmFncmFwaCBzaG91bGQgYmUgYm9vc3RlZCwgd2hpbGUKK3RoZSBy YWRpbyBidXR0b25zIGJlbG93IHNob3VsZCBub3QgYmUgYXV0b3NpemVkLiArKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCisrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKworPC9kaXY+Cis8ZGl2PgorPGZvcm0gYWN0aW9uPSIiPgorU2VsZWN0IG9uZSBv ZjoKKzxpbnB1dCB0eXBlPSJyYWRpbyIgdmFsdWU9IjEiIGlkPSJyYWRpbzEiIGNoZWNrZWQ9ImNo ZWNrZWQiLz48YnIvPgorPGxhYmVsIGZvcj0icmFkaW8xIj5SYWRpbzE8L2xhYmVsPgorPGlucHV0 IHR5cGU9InJhZGlvIiB2YWx1ZT0iMiIgaWQ9InJhZGlvMiIvPjxici8+Cis8bGFiZWwgZm9yPSJy YWRpbzIiPlJhZGlvMjwvbGFiZWw+Cis8aW5wdXQgdHlwZT0icmFkaW8iIHZhbHVlPSIzIiBpZD0i cmFkaW8zIi8+PGJyLz4KKzxsYWJlbCBmb3I9InJhZGlvMyI+UmFkaW8zPC9sYWJlbD4KKzwvZm9y bT4KKzwvZGl2PgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3Rpbmctc2VsZWN0 LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5n L2Zvcm0tY29udHJvbHMtYm9vc3Rpbmctc2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi40YTQyMGQyNzUwMTc3MGUwMWQ5MTIzZjc5YTk1MDE1OGQ4ZGI0Mjk1Ci0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1ib29zdGluZy1zZWxlY3QtZWxlbWVudC1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsNDMgQEAK KzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQi IGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBw eDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICAgIGZvbnQtZmFt aWx5OiBWZXJkYW5hLCBzYW5zLXNlcmlmOworICAgIGZvbnQtc2l6ZTogc21hbGw7CisgIH0KKyAg CisgICNib29zdGVkIHsKKyAgICBmb250LXNpemU6IDIuMDVyZW07CisgIH0KKzwvc3R5bGU+CisK KworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+Cis8ZGl2IGlkPSJib29zdGVkIj4KK1RoaXMgdGVz dHMgdGhlIGJvb3N0aW5nIG9mIGEgc2VsZWN0aW9uIG1lbnUgZWxlbWVudC4gVGhpcyBwYXJhZ3Jh cGggc2hvdWxkIGJlIGJvb3N0ZWQsIHdoaWxlCit0aGUgc2VsZWN0aW9uIGJveCBiZWxvdyBzaG91 bGQgbm90IGJlIGF1dG9zaXplZC4gKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKworKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKKzwvZGl2PgorPGRp dj4KKzxmb3JtIGFjdGlvbj0iIj4KK1NlbGVjdGlvbjoKKzxzZWxlY3Q+CisgIDxvcHRpb24gc2Vs ZWN0ZWQgdmFsdWU9ZGVmYXVsdD5EZWZhdWx0PC9vcHRpb24+CisgIDxvcHRpb24gdmFsdWU9b3B0 aW9uMT5PcHRpb24gMTwvb3B0aW9uPgorICA8b3B0aW9uIHZhbHVlPW9wdGlvbjI+T3B0aW9uIDI8 L29wdGlvbj4KKzwvc2VsZWN0PgorPC9mb3JtPgorPC9kaXY+Cis8L2Rpdj4KKworPC9ib2R5Pgor PC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9y bS1jb250cm9scy1ib29zdGluZy1zZWxlY3QtZWxlbWVudC5odG1sIGIvTGF5b3V0VGVzdHMvZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1zZWxlY3QtZWxlbWVudC5o dG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLmIzZGJlZjZjZTJmMTBlMDg3NmJmMzUwYTIwMTczMDEwYTMwMTQ2YTkK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3Jt LWNvbnRyb2xzLWJvb3N0aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWwKQEAgLTAsMCArMSw0NyBAQAor PCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIg Y29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4 OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgICAgZm9udC1mYW1p bHk6IFZlcmRhbmEsIHNhbnMtc2VyaWY7CisgICAgZm9udC1zaXplOiBzbWFsbDsKKyAgfQorPC9z dHlsZT4KKworPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJuYWxzKSB7CisgICAgd2luZG93Lmlu dGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ0VuYWJsZWQodHJ1ZSk7CisgICAgd2lu ZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ1dpbmRvd1NpemVPdmVycmlk ZSgzMjAsIDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRvdy5jb25zb2xlICYmIGNvbnNvbGUud2Fybikg eworICAgIGNvbnNvbGUud2FybigiVGhpcyB0ZXN0IGRlcGVuZHMgb24gdGhlIFRleHQgQXV0b3Np emluZyBzZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1biBpdCBpbiBEdW1wUmVuZGVyVHJlZSwgb3Ig bWFudWFsbHkgZW5hYmxlIFRleHQgQXV0b3NpemluZywgYW5kIGVpdGhlciB1c2UgYSBtb2JpbGUg ZGV2aWNlIHdpdGggMzIwcHggZGV2aWNlLXdpZHRoIChsaWtlIE5leHVzIFMgb3IgaVBob25lKSwg b3IgZGVmaW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRPU0laSU5HX09OX0RFU0tUT1AuIik7Cit9Cis8 L3NjcmlwdD4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+Cis8ZGl2PgorVGhpcyB0ZXN0cyB0 aGUgYm9vc3Rpbmcgb2YgYSBzZWxlY3Rpb24gbWVudSBlbGVtZW50LiBUaGlzIHBhcmFncmFwaCBz aG91bGQgYmUgYm9vc3RlZCwgd2hpbGUKK3RoZSBzZWxlY3Rpb24gYm94IGJlbG93IHNob3VsZCBu b3QgYmUgYXV0b3NpemVkLiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrCisrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKworPC9kaXY+Cis8ZGl2Pgor PGZvcm0gYWN0aW9uPSIiPgorU2VsZWN0aW9uOgorPHNlbGVjdD4KKyAgPG9wdGlvbiBzZWxlY3Rl ZCB2YWx1ZT1kZWZhdWx0PkRlZmF1bHQ8L29wdGlvbj4KKyAgPG9wdGlvbiB2YWx1ZT1vcHRpb24x Pk9wdGlvbiAxPC9vcHRpb24+CisgIDxvcHRpb24gdmFsdWU9b3B0aW9uMj5PcHRpb24gMjwvb3B0 aW9uPgorPC9zZWxlY3Q+Cis8L2Zvcm0+Cis8L2Rpdj4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0 bWw+Cg== 179285 2012-12-13 09:23:44 -0800 2012-12-14 07:12:34 -0800 Patch bug-102560-20121213172104.patch text/plain 22008 timvolodine U3VidmVyc2lvbiBSZXZpc2lvbjogMTM2NTA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDAwYjI2MTA1ZWM3MGUy NjM5YzY3ZDBlOWFiMzRlNmZhYjI4YWVkNy4uNjNkMzUwZjc1YjQzZDI2MzY4MjNlYjEwNWU3ZDVh MWNlMTEwOTcyYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEyLTEyLTEyICBUaW0g Vm9sb2RpbmUgIDx0aW12b2xvZGluZUBnb29nbGUuY29tPgorCisgICAgICAgIFRleHQgQXV0b3Np emluZzogV29yayBvdXQgd2hhdCB0byBkbyBhYm91dCBmb3JtIGNvbnRyb2xzCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDI1NjAKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBEaXNhbGxvdyBhdXRvc2l6aW5n IG9mIGZvcm0gaW5wdXQgY29udHJvbHMgbGlrZSBidXR0b25zLCB0ZXh0IGlucHV0IGZpZWxkcywg c2VsZWN0aW9uIGNvbnRyb2xzLCByYWRpbyBidXR0b25zCisgICAgICAgIGFuZCBjaGVjayBib3hl cy4gVGhpcyBpcyBhIHNob3J0IHRlcm0gc29sdXRpb24gdG8gYXZvaWQgaW5jb25zaXN0ZW50IGF1 dG9zaXppbmcgb2YgZm9ybSBjb250cm9scyAod2hpY2ggaXMKKyAgICAgICAgd29yc2UgdGhhbiBu b3QgYXV0b3NpemluZyBhdCBhbGwpLgorCisgICAgICAgIFRlc3RzOiBmYXN0L3RleHQtYXV0b3Np emluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50 cy5odG1sCisgICAgICAgICAgICAgICBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xz LWJvb3N0aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbAorICAgICAgICAgICAgICAgZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1yYWRpby1pbnB1dC1lbGVt ZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYm9vc3Rpbmctc2VsZWN0LWVsZW1lbnQuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1Rl eHRBdXRvc2l6ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpU ZXh0QXV0b3NpemVyOjpjb250YWluZXJTaG91bGRCZUF1dG9zaXplZCk6CisgICAgICAgIChXZWJD b3JlOjpUZXh0QXV0b3NpemVyOjpjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZCk6CisgICAgICAg IChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpwcm9jZXNzQ29udGFpbmVyKToKKyAgICAgICAgKFdl YkNvcmU6OlRleHRBdXRvc2l6ZXI6OmlzQXV0b3NpemluZ0NvbnRhaW5lcik6CisgICAgICAgIChX ZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpjb250YWluZXJDb250YWluc1RhZ3MpOgorICAgICAgICAo V2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6bWVhc3VyZURlc2NlbmRhbnRUZXh0V2lkdGgpOgorICAg ICAgICAoV2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6ZmluZERlZXBlc3RCbG9ja0NvbnRhaW5pbmdB bGxUZXh0KToKKyAgICAgICAgKiByZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oOgorCiAyMDEyLTEy LTA0ICBBbnRvaW5lIFF1aW50ICA8Z3Jhb3V0c0BhcHBsZS5jb20+CiAKICAgICAgICAgVGV4dFRy YWNrJ3MgLmtpbmQgcHJvcGVydHkgc2hvdWxkIHJldHVybiBsb3dlci1jYXNlIHZhbHVlcwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwCmluZGV4IGIxMDJiMmI1YjI5 Mzc1YzcyODQ5MmMxYzk4NGJmN2Y4NjVkODcyMjEuLjQ5ODU3NTM4ZGJkMjY1MzM0ZDgyMGRhNTBl YzQyNWNlMGYwM2Y5MzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0 QXV0b3NpemVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXpl ci5jcHAKQEAgLTI1LDYgKzI1LDcgQEAKICNpbmNsdWRlICJUZXh0QXV0b3NpemVyLmgiCiAKICNp bmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCiAjaW5jbHVkZSAi SW5zcGVjdG9ySW5zdHJ1bWVudGF0aW9uLmgiCiAjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCiAj aW5jbHVkZSAiUmVuZGVyU3R5bGUuaCIKQEAgLTM3LDE0ICszOCwyMyBAQAogCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKK3VzaW5nIG5hbWVzcGFjZSBIVE1MTmFtZXM7CisKIHN0cnVjdCBUZXh0QXV0 b3NpemluZ1dpbmRvd0luZm8gewogICAgIEludFNpemUgd2luZG93U2l6ZTsKICAgICBJbnRTaXpl IG1pbkxheW91dFNpemU7CiB9OwogCisvLyBob2xkcyB0aGUgdGFncyBmb3IgdGhlIGZvcm0gaW5w dXQgZWxlbWVudHMKK3N0YXRpYyBWZWN0b3I8UXVhbGlmaWVkTmFtZT4gc19pbnB1dFRhZ3M7CisK IFRleHRBdXRvc2l6ZXI6OlRleHRBdXRvc2l6ZXIoRG9jdW1lbnQqIGRvY3VtZW50KQogICAgIDog bV9kb2N1bWVudChkb2N1bWVudCkKIHsKKyAgICBzX2lucHV0VGFncy5hcHBlbmQoaW5wdXRUYWcp OworICAgIHNfaW5wdXRUYWdzLmFwcGVuZCh0ZXh0YXJlYVRhZyk7CisgICAgc19pbnB1dFRhZ3Mu YXBwZW5kKGJ1dHRvblRhZyk7CisgICAgc19pbnB1dFRhZ3MuYXBwZW5kKHNlbGVjdFRhZyk7CiB9 CiAKIFRleHRBdXRvc2l6ZXI6On5UZXh0QXV0b3NpemVyKCkKQEAgLTExOSw3ICsxMjksMTUgQEAg dm9pZCBUZXh0QXV0b3NpemVyOjpwcm9jZXNzQ2x1c3RlcihSZW5kZXJCbG9jayogY2x1c3Rlciwg UmVuZGVyQmxvY2sqIGNvbnRhaW5lciwKICAgICBwcm9jZXNzQ29udGFpbmVyKG11bHRpcGxpZXIs IGNvbnRhaW5lciwgc3VidHJlZVJvb3QsIHdpbmRvd0luZm8pOwogfQogCi1zdGF0aWMgYm9vbCBj b250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyKQor Ym9vbCBUZXh0QXV0b3NpemVyOjpjb250YWluZXJTaG91bGRCZUF1dG9zaXplZChjb25zdCBSZW5k ZXJCbG9jayogY29udGFpbmVyKQoreworICAgIGlmIChjb250YWluZXJDb250YWluc1RhZ3MoY29u dGFpbmVyLCBzX2lucHV0VGFncykpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIHJldHVy biAhY29udGVudEhlaWdodElzQ29uc3RyYWluZWQoY29udGFpbmVyKTsKK30KKworYm9vbCBUZXh0 QXV0b3NpemVyOjpjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJCbG9jayog Y29udGFpbmVyKQogewogICAgIC8vIEZJWE1FOiBQcm9wYWdhdGUgY29uc3RyYWluZWRuZXNzIGRv d24gdGhlIHRyZWUsIHRvIGF2b2lkIGluZWZmaWNpZW50bHkgd2Fsa2luZyBiYWNrIHVwIGZyb20g ZWFjaCBib3guCiAgICAgLy8gRklYTUU6IFRoaXMgY29kZSBuZWVkcyB0byB0YWtlIGludG8gYWNj b3VudCB2ZXJ0aWNhbCB3cml0aW5nIG1vZGVzLgpAQCAtMTQzLDcgKzE2MSw3IEBAIHZvaWQgVGV4 dEF1dG9zaXplcjo6cHJvY2Vzc0NvbnRhaW5lcihmbG9hdCBtdWx0aXBsaWVyLCBSZW5kZXJCbG9j ayogY29udGFpbmVyLCBSCiB7CiAgICAgQVNTRVJUKGlzQXV0b3NpemluZ0NvbnRhaW5lcihjb250 YWluZXIpKTsKIAotICAgIGZsb2F0IGxvY2FsTXVsdGlwbGllciA9IGNvbnRlbnRIZWlnaHRJc0Nv bnN0cmFpbmVkKGNvbnRhaW5lcikgPyAxIDogbXVsdGlwbGllcjsKKyAgICBmbG9hdCBsb2NhbE11 bHRpcGxpZXIgPSBjb250YWluZXJTaG91bGRCZUF1dG9zaXplZChjb250YWluZXIpID8gbXVsdGlw bGllciA6IDE7CiAKICAgICBSZW5kZXJPYmplY3QqIGRlc2NlbmRhbnQgPSBuZXh0SW5QcmVPcmRl clNraXBwaW5nRGVzY2VuZGFudHNPZkNvbnRhaW5lcnMoc3VidHJlZVJvb3QsIHN1YnRyZWVSb290 KTsKICAgICB3aGlsZSAoZGVzY2VuZGFudCkgewpAQCAtMjExLDYgKzIyOSwxMSBAQCBib29sIFRl eHRBdXRvc2l6ZXI6OmlzQXV0b3NpemluZ0NvbnRhaW5lcihjb25zdCBSZW5kZXJPYmplY3QqIHJl bmRlcmVyKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgaWYgKHJlbmRlcmVyLT5pc0xpc3RJ dGVtKCkpCiAgICAgICAgIHJldHVybiByZW5kZXJlci0+aXNGbG9hdGluZygpIHx8IHJlbmRlcmVy LT5pc091dE9mRmxvd1Bvc2l0aW9uZWQoKTsKKyAgICAvLyBhdm9pZCBjcmVhdGluZyBjb250YWlu ZXJzIGZvciB0ZXh0IHdpdGhpbiB0ZXh0IGNvbnRyb2xzLCBidXR0b25zLCBvciBzZWxlY3Rpb24g bWVudXMuCisgICAgTm9kZSogcGFyZW50Tm9kZSA9IHJlbmRlcmVyLT5wYXJlbnQoKSA/IHJlbmRl cmVyLT5wYXJlbnQoKS0+Z2VuZXJhdGluZ05vZGUoKSA6IDA7CisgICAgaWYgKHBhcmVudE5vZGUg JiYgcGFyZW50Tm9kZS0+aXNIVE1MRWxlbWVudCgpICYmIHNfaW5wdXRUYWdzLmNvbnRhaW5zKHRv RWxlbWVudChwYXJlbnROb2RlKS0+dGFnUU5hbWUoKSkpCisgICAgICAgIHJldHVybiBmYWxzZTsK KwogICAgIHJldHVybiB0cnVlOwogfQogCkBAIC0yNzEsOSArMjk0LDI0IEBAIGJvb2wgVGV4dEF1 dG9zaXplcjo6Y2x1c3RlclNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBsb3dl c3RDb21tb25BbmNlCiAgICAgcmV0dXJuIGZhbHNlOwogfQogCitib29sIFRleHRBdXRvc2l6ZXI6 OmNvbnRhaW5lckNvbnRhaW5zVGFncyhjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyLCBWZWN0 b3I8UXVhbGlmaWVkTmFtZT4mIHRhZ3MpCit7CisgICAgY29uc3QgUmVuZGVyT2JqZWN0KiBydW5u aW5nT2JqZWN0ID0gY29udGFpbmVyOworICAgIHdoaWxlIChydW5uaW5nT2JqZWN0KSB7CisgICAg ICAgIGNvbnN0IE5vZGUqIHJ1bm5pbmdOb2RlID0gcnVubmluZ09iamVjdC0+bm9kZSgpOworICAg ICAgICBpZiAocnVubmluZ05vZGUgJiYgcnVubmluZ05vZGUtPmlzSFRNTEVsZW1lbnQoKSkgewor ICAgICAgICAgICAgaWYgKHRhZ3MuY29udGFpbnModG9FbGVtZW50KHJ1bm5pbmdOb2RlKS0+dGFn UU5hbWUoKSkpCisgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIH0KKyAgICAg ICAgcnVubmluZ09iamVjdCA9IG5leHRJblByZU9yZGVyU2tpcHBpbmdEZXNjZW5kYW50c09mQ29u dGFpbmVycyhydW5uaW5nT2JqZWN0LCBjb250YWluZXIpOworICAgIH0KKworICAgIHJldHVybiBm YWxzZTsKK30KKwogdm9pZCBUZXh0QXV0b3NpemVyOjptZWFzdXJlRGVzY2VuZGFudFRleHRXaWR0 aChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyLCBmbG9hdCBtaW5UZXh0V2lkdGgsIGZsb2F0 JiB0ZXh0V2lkdGgpCiB7Ci0gICAgYm9vbCBza2lwTG9jYWxUZXh0ID0gY29udGVudEhlaWdodElz Q29uc3RyYWluZWQoY29udGFpbmVyKTsKKyAgICBib29sIHNraXBMb2NhbFRleHQgPSAhY29udGFp bmVyU2hvdWxkQmVBdXRvc2l6ZWQoY29udGFpbmVyKTsKIAogICAgIFJlbmRlck9iamVjdCogZGVz Y2VuZGFudCA9IG5leHRJblByZU9yZGVyU2tpcHBpbmdEZXNjZW5kYW50c09mQ29udGFpbmVycyhj b250YWluZXIsIGNvbnRhaW5lcik7CiAgICAgd2hpbGUgKGRlc2NlbmRhbnQpIHsKQEAgLTMxOSw3 ICszNTcsNyBAQCBjb25zdCBSZW5kZXJCbG9jayogVGV4dEF1dG9zaXplcjo6ZmluZERlZXBlc3RC bG9ja0NvbnRhaW5pbmdBbGxUZXh0KGNvbnN0IFJlbmRlcgogICAgIGNvbnN0IFJlbmRlck9iamVj dCogbGFzdFRleHRMZWFmID0gZmluZEZpcnN0VGV4dExlYWZOb3RJbkNsdXN0ZXIoY2x1c3Rlciwg bGFzdERlcHRoLCBMYXN0VG9GaXJzdCk7CiAgICAgQVNTRVJUKGxhc3RUZXh0TGVhZik7CiAKLSAg ICAvLyBFcXVhbGl6ZSB0aGUgZGVwdGhzIGlmIG5lY2Vzc2FyeS4gT25seSBvbmUgb2YgdGhlIHdo aWxlIGxvb3BzIGJlbG93IHdpbGwgZ2V0IGV4ZWN1dGVkLgorICAgIC8vIEVxdWFsaXplIHRoZSBk ZXB0aHMgaWYgY29udGFpbmVyU2hvdWxkQmVBdXRvc2l6ZWQgbmVjZXNzYXJ5LiBPbmx5IG9uZSBv ZiB0aGUgd2hpbGUgbG9vcHMgYmVsb3cgd2lsbCBnZXQgZXhlY3V0ZWQuCiAgICAgY29uc3QgUmVu ZGVyT2JqZWN0KiBmaXJzdE5vZGUgPSBmaXJzdFRleHRMZWFmOwogICAgIGNvbnN0IFJlbmRlck9i amVjdCogbGFzdE5vZGUgPSBsYXN0VGV4dExlYWY7CiAgICAgd2hpbGUgKGZpcnN0RGVwdGggPiBs YXN0RGVwdGgpIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0 b3NpemVyLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oCmluZGV4 IGE3MDliMTE2OGU0NGRmMDBlYzFmOWQ3M2JiZTVlNTE2ZmU5MjY3NzQuLjAxMGJiYmE5NzQxNjI4 NWZhZWY3YzQ0MTg5MjM0MGYxYTYxZDMzNzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9UZXh0QXV0b3NpemVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Rl eHRBdXRvc2l6ZXIuaApAQCAtMjgsNiArMjgsNyBAQAogCiAjaWYgRU5BQkxFKFRFWFRfQVVUT1NJ WklORykKIAorI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkludFNpemUuaCIKICNp bmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgpA QCAtNzEsNiArNzIsOSBAQCBwcml2YXRlOgogICAgIHN0YXRpYyBib29sIGlzQXV0b3NpemluZ0Ns dXN0ZXIoY29uc3QgUmVuZGVyQmxvY2sqKTsKIAogICAgIHN0YXRpYyBib29sIGNsdXN0ZXJTaG91 bGRCZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayogbG93ZXN0Q29tbW9uQW5jZXN0b3IsIGZs b2F0IGNvbW1vbkFuY2VzdG9yV2lkdGgpOworICAgIHN0YXRpYyBib29sIGNvbnRhaW5lclNob3Vs ZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIpOworICAgIHN0YXRpYyBi b29sIGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWlu ZXIpOworICAgIHN0YXRpYyBib29sIGNvbnRhaW5lckNvbnRhaW5zVGFncyhjb25zdCBSZW5kZXJC bG9jayogY2x1c3RlciwgVmVjdG9yPFF1YWxpZmllZE5hbWU+JiB0YWdzKTsKICAgICBzdGF0aWMg dm9pZCBtZWFzdXJlRGVzY2VuZGFudFRleHRXaWR0aChjb25zdCBSZW5kZXJCbG9jayogY29udGFp bmVyLCBmbG9hdCBtaW5UZXh0V2lkdGgsIGZsb2F0JiB0ZXh0V2lkdGgpOwogCiAgICAgLy8gVXNl IHRvIHRyYXZlcnNlIHRoZSB0cmVlIG9mIGRlc2NlbmRhbnRzLCBleGNsdWRpbmcgZGVzY2VuZGFu dHMgb2YgY29udGFpbmVycyAoYnV0IHJldHVybmluZyB0aGUgY29udGFpbmVycyB0aGVtc2VsdmVz KS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5n ZUxvZwppbmRleCBhODlkZDQ1ZjQ1NDBiNWM4MzZmODRjMmY0ZDA3ZGY0NTk3MTllZDFmLi5lOGY2 NTVhNmVkZjE5ODVkYjllNDVkNWM5NDg3MDI1Yzk0Mzk5MTZjIDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIg QEAKKzIwMTItMTItMTIgIFRpbSBWb2xvZGluZSAgPHRpbXZvbG9kaW5lQGdvb2dsZS5jb20+CisK KyAgICAgICAgVGV4dCBBdXRvc2l6aW5nOiBXb3JrIG91dCB3aGF0IHRvIGRvIGFib3V0IGZvcm0g Y29udHJvbHMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTEwMjU2MAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFRlc3RzIGZvciBmb3JtIGlucHV0IGVsZW1lbnRzIGF1dG9zaXppbmcuIEFkZGVkIHRlc3RzIHRv IGNoZWNrIHRoYXQgdmFyaW91cyBraW5kcyBvZiBmb3JtIGVsZW1lbnRzCisgICAgICAgIGRvbid0 IGdldCBhdXRvc2l6ZWQsIGkuZS4gYnV0dG9ucywgdGV4dGFyZWFzLCBjaGVjayBib3hlcywgcmFk aW8gYnV0dG9uIGFuZCBzZWxlY3Rpb24gbWVudXMuCisKKyAgICAgICAgKiBmYXN0L3RleHQtYXV0 b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVt ZW50cy1leHBlY3RlZC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3Npemlu Zy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50cy5o dG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xz LWJvb3N0aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisg ICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1jaGVj a2JveC1pbnB1dC1lbGVtZW50Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRv c2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctcmFkaW8taW5wdXQtZWxlbWVudC1leHBlY3Rl ZC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRy b2xzLWJvb3N0aW5nLXJhZGlvLWlucHV0LWVsZW1lbnQuaHRtbDogQWRkZWQuCisgICAgICAgICog ZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1zZWxlY3QtZWxlbWVu dC1leHBlY3RlZC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9m b3JtLWNvbnRyb2xzLWJvb3N0aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWw6IEFkZGVkLgorCiAyMDEy LTEyLTA0ICBBbnRvaW5lIFF1aW50ICA8Z3Jhb3V0c0BhcHBsZS5jb20+CiAKICAgICAgICAgVGV4 dFRyYWNrJ3MgLmtpbmQgcHJvcGVydHkgc2hvdWxkIHJldHVybiBsb3dlci1jYXNlIHZhbHVlcwpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1ib29zdGluZy1idXR0b24tdGV4dGFyZWEtaW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRtbCBi L0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3Rpbmct YnV0dG9uLXRleHRhcmVhLWlucHV0LWVsZW1lbnRzLWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u YTM3YzU2NjA3NzI3MThjNzkzZDJjY2FmNjYyNWQ3OWY0NTVkMGJiMgotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3Rp bmctYnV0dG9uLXRleHRhcmVhLWlucHV0LWVsZW1lbnRzLWV4cGVjdGVkLmh0bWwKQEAgLTAsMCAr MSw4NCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2 aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lk dGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0K KyAgCisgICNoZWFkZXIgZm9ybSB7CisgICAgZm9udC1zaXplOiA4NSU7CisgICAgZGlzcGxheTog aW5saW5lOworICB9CisgIAorICAjaGVhZGVyIC5saW5rcyB7CisgICAgZm9udC1zaXplOiA4NSU7 CisgIH0KKyAgCisgIHVsLmxpbmtzIHsKKyAgICBtYXJnaW46IDA7CisgICAgcGFkZGluZzogMDsK KyAgICBsaXN0LXN0eWxlLXR5cGU6IG5vbmU7CisgIH0KKworICB1bC5saW5rcyBsaSB7CisgICAg ZGlzcGxheTogaW5saW5lOworICAgIHdoaXRlLXNwYWNlOiBub3dyYXA7CisgIH0KKzwvc3R5bGU+ CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2IGlkPSJoZWFkZXIiPgorICA8dWwgY2xhc3M9Imxp bmtzIj4KKyAgICA8bGk+CisgICAgICA8YSBocmVmPSIuLyI+SG9tZTwvYT4KKyAgICA8L2xpPgor ICAgIDxsaT4KKyAgICAgIDxzcGFuPnwgPC9zcGFuPgorICAgICAgPGEgaHJlZj0iIj5OZXc8L2E+ CisgICAgPC9saT4KKyAgICA8bGk+CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAgICAgIDxhIGhy ZWY9IiI+U2VhcmNoPC9hPgorICAgIDwvbGk+CisgICAgPGxpPgorICAgICAgPHNwYW4+fCA8L3Nw YW4+CisgICAgICA8Zm9ybT4KKyAgICAgICAgPGlucHV0IGNsYXNzPSJ0eHQiIHR5cGU9InRleHQi IGlkPSJxdWlja3NlYXJjaF90b3AiIG5hbWU9InF1aWNrc2VhcmNoIj4KKyAgICAgICAgPGlucHV0 IGNsYXNzPSJidG4iIHR5cGU9InN1Ym1pdCIgdmFsdWU9IkZpbmQiIGlkPWZpbmRfdG9wIj4KKyAg ICAgIDwvZm9ybT4KKyAgICA8L2xpPgorICAgIDxsaT4KKyAgICAgIDxzcGFuPnwgPC9zcGFuPgor ICAgICAgPGEgaHJlZj0iIj5SZXBvcnRzPC9hPgorICAgIDwvbGk+CisgIDwvdWw+Cis8L2Rpdj4K KworPGRpdj4KKyAgPHA+PGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICBUaGlzIHRl c3QgY2hlY2tzIHRoYXQgZm9ybSBjb250cm9scyBsaWtlIGJ1dHRvbnMsIHRleHQgaW5wdXRzIGFu ZCBjaGVjay1ib3hlcyBhcmUgbm90IGF1dG9zaXplZC4KKyAgVGhlIHRleHQgaW4gdGhpcyBwYXJh Z3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUgdGhlIGZvcm0gY29udHJvbHMgYWJvdmUg YW5kIGJlbG93IHNob3VsZCBub3QuCisgIFRoZSAiRmluZCIgYnV0dG9uIGFuZCB0ZXh0LWlucHV0 IGJveCBhdCB0aGUgYm90dG9tIG9mIHRoZSBwYWdlIHNob3VsZCBub3QgYmUgYXV0b3NpemVkLgor ICA8L2Rpdj48L3A+CisKKyAgPGZvcm0+CisgIDxkaXY+CisgICAgPHA+PGRpdiBzdHlsZT0iZm9u dC1zaXplOiAyLjVyZW0iPgorICAgIFRoaXMgdGV4dCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGls ZSB0aGUgaW5wdXQgY29udHJvbHMgYmVsb3cgc2hvdWxkIG5vdC4KKyAgICA8L2Rpdj48L3A+Cisg ICAgPGlucHV0IGlkPSJxdWlja3NlYXJjaCIgdHlwZT0idGV4dCIgbmFtZT0icXVpY2tzZWFyY2gi PgorICAgIDxpbnB1dCBpZD0iZmluZCIgdHlwZT0ic3VibWl0IiB2YWx1ZT0iRmluZCI+CisgIDwv ZGl2PgorICA8L2Zvcm0+CisKKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5n LWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50cy5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90 ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1idXR0b24tdGV4dGFyZWEtaW5w dXQtZWxlbWVudHMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4wMGVkNzE3MDFlNmFjZjQ3ZWUyNDI1ZDA3YmEw ZWQ3ZjE3OTAxY2FmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1 dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1idXR0b24tdGV4dGFyZWEtaW5wdXQtZWxl bWVudHMuaHRtbApAQCAtMCwwICsxLDkzIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhl YWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxl PgorICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJm bG93LXk6IGhpZGRlbjsKKyAgfQorICAKKyAgI2hlYWRlciBmb3JtIHsKKyAgICBmb250LXNpemU6 IDg1JTsKKyAgICBkaXNwbGF5OiBpbmxpbmU7CisgIH0KKyAgCisgICNoZWFkZXIgLmxpbmtzIHsK KyAgICBmb250LXNpemU6IDg1JTsKKyAgfQorICAKKyAgdWwubGlua3MgeworICAgIG1hcmdpbjog MDsKKyAgICBwYWRkaW5nOiAwOworICAgIGxpc3Qtc3R5bGUtdHlwZTogbm9uZTsKKyAgfQorCisg IHVsLmxpbmtzIGxpIHsKKyAgICBkaXNwbGF5OiBpbmxpbmU7CisgICAgd2hpdGUtc3BhY2U6IG5v d3JhcDsKKyAgfQorPC9zdHlsZT4KKworPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJuYWxzKSB7 CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ0VuYWJsZWQo dHJ1ZSk7CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ1dp bmRvd1NpemVPdmVycmlkZSgzMjAsIDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRvdy5jb25zb2xlICYm IGNvbnNvbGUud2FybikgeworICAgIGNvbnNvbGUud2FybigiVGhpcyB0ZXN0IGRlcGVuZHMgb24g dGhlIFRleHQgQXV0b3NpemluZyBzZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1biBpdCBpbiBEdW1w UmVuZGVyVHJlZSwgb3IgbWFudWFsbHkgZW5hYmxlIFRleHQgQXV0b3NpemluZywgYW5kIGVpdGhl ciB1c2UgYSBtb2JpbGUgZGV2aWNlIHdpdGggMzIwcHggZGV2aWNlLXdpZHRoIChsaWtlIE5leHVz IFMgb3IgaVBob25lKSwgb3IgZGVmaW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRPU0laSU5HX09OX0RF U0tUT1AuIik7Cit9Cis8L3NjcmlwdD4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXYgaWQ9Imhl YWRlciI+CisgIDx1bCBjbGFzcz0ibGlua3MiPgorICAgIDxsaT4KKyAgICAgIDxhIGhyZWY9Ii4v Ij5Ib21lPC9hPgorICAgIDwvbGk+CisgICAgPGxpPgorICAgICAgPHNwYW4+fCA8L3NwYW4+Cisg ICAgICA8YSBocmVmPSIiPk5ldzwvYT4KKyAgICA8L2xpPgorICAgIDxsaT4KKyAgICAgIDxzcGFu PnwgPC9zcGFuPgorICAgICAgPGEgaHJlZj0iIj5TZWFyY2g8L2E+CisgICAgPC9saT4KKyAgICA8 bGk+CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAgICAgIDxmb3JtPgorICAgICAgICA8aW5wdXQg Y2xhc3M9InR4dCIgdHlwZT0idGV4dCIgaWQ9InF1aWNrc2VhcmNoX3RvcCIgbmFtZT0icXVpY2tz ZWFyY2giPgorICAgICAgICA8aW5wdXQgY2xhc3M9ImJ0biIgdHlwZT0ic3VibWl0IiB2YWx1ZT0i RmluZCIgaWQ9ZmluZF90b3AiPgorICAgICAgPC9mb3JtPgorICAgIDwvbGk+CisgICAgPGxpPgor ICAgICAgPHNwYW4+fCA8L3NwYW4+CisgICAgICA8YSBocmVmPSIiPlJlcG9ydHM8L2E+CisgICAg PC9saT4KKyAgPC91bD4KKzwvZGl2PgorCis8ZGl2PgorICA8cD48ZGl2PgorICBUaGlzIHRlc3Qg Y2hlY2tzIHRoYXQgZm9ybSBjb250cm9scyBsaWtlIGJ1dHRvbnMsIHRleHQgaW5wdXRzIGFuZCBj aGVjay1ib3hlcyBhcmUgbm90IGF1dG9zaXplZC4KKyAgVGhlIHRleHQgaW4gdGhpcyBwYXJhZ3Jh cGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUgdGhlIGZvcm0gY29udHJvbHMgYWJvdmUgYW5k IGJlbG93IHNob3VsZCBub3QuCisgIFRoZSAiRmluZCIgYnV0dG9uIGFuZCB0ZXh0LWlucHV0IGJv eCBhdCB0aGUgYm90dG9tIG9mIHRoZSBwYWdlIHNob3VsZCBub3QgYmUgYXV0b3NpemVkLgorICA8 L2Rpdj48L3A+CisKKyAgPGZvcm0+CisgIDxkaXY+CisgICAgPHA+PGRpdj4KKyAgICBUaGlzIHRl eHQgc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUgdGhlIGlucHV0IGNvbnRyb2xzIGJlbG93IHNo b3VsZCBub3QuCisgICAgPC9kaXY+PC9wPgorICAgIDxpbnB1dCBpZD0icXVpY2tzZWFyY2giIHR5 cGU9InRleHQiIG5hbWU9InF1aWNrc2VhcmNoIj4KKyAgICA8aW5wdXQgaWQ9ImZpbmQiIHR5cGU9 InN1Ym1pdCIgdmFsdWU9IkZpbmQiPgorICA8L2Rpdj4KKyAgPC9mb3JtPgorCis8L2Rpdj4KKwor PC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9z aXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVj dGVkLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xz LWJvb3N0aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5lN2I3ZTZmZDQwOWUwMTA0OTYxNzBjZThhYjAxNzE0NDRlOTlhMzA1Ci0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29z dGluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKQEAgLTAsMCArMSwzNCBA QAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9y dCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgw MHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5 bGU+CisKKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+Cis8ZGl2IHN0eWxlPSJmb250LXNpemU6 IDIuNXJlbSI+CitUaGlzIHRlc3RzIHRoZSBhdXRvc2l6aW5nIG9mIGNoZWNrIGJveGVzLiBUaGlz IHBhcmFncmFwaCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZQordGhlIGNoZWNrIGJveGVzIGJl bG93IHNob3VsZCBub3QgYmUgYXV0b3NpemVkLiBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwg Y29uc2VjdGV0dXIKK2FkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNp ZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLgorPC9kaXY+Cis8ZGl2Pgor PGZvcm0gYWN0aW9uPSIiPgorQ2hlY2sgb25lIG9yIG1vcmU6Cis8aW5wdXQgdHlwZT0iY2hlY2ti b3giIG5hbWU9InZlaGljbGUiIHZhbHVlPSJCaWtlIj5JIGhhdmUgYSBiaWtlPGJyLz4KKzxpbnB1 dCB0eXBlPSJjaGVja2JveCIgbmFtZT0idmVoaWNsZSIgdmFsdWU9IkNhciI+SSBoYXZlIGEgY2Fy IDxici8+Cis8L2Zvcm0+Cis8L2Rpdj4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJv b3N0aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4 dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctY2hlY2tib3gtaW5wdXQtZWxlbWVu dC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLjFkNDg0ODg5YjJhZTRkMDhhOTFkNDliNjFjNTc4NWNjYTAxZmNh M2QKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9m b3JtLWNvbnRyb2xzLWJvb3N0aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbApAQCAtMCww ICsxLDQyIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9 InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3 aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAg fQorPC9zdHlsZT4KKworPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJuYWxzKSB7CisgICAgd2lu ZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ0VuYWJsZWQodHJ1ZSk7Cisg ICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ1dpbmRvd1NpemVP dmVycmlkZSgzMjAsIDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRvdy5jb25zb2xlICYmIGNvbnNvbGUu d2FybikgeworICAgIGNvbnNvbGUud2FybigiVGhpcyB0ZXN0IGRlcGVuZHMgb24gdGhlIFRleHQg QXV0b3NpemluZyBzZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1biBpdCBpbiBEdW1wUmVuZGVyVHJl ZSwgb3IgbWFudWFsbHkgZW5hYmxlIFRleHQgQXV0b3NpemluZywgYW5kIGVpdGhlciB1c2UgYSBt b2JpbGUgZGV2aWNlIHdpdGggMzIwcHggZGV2aWNlLXdpZHRoIChsaWtlIE5leHVzIFMgb3IgaVBo b25lKSwgb3IgZGVmaW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRPU0laSU5HX09OX0RFU0tUT1AuIik7 Cit9Cis8L3NjcmlwdD4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+Cis8ZGl2PgorVGhpcyB0 ZXN0cyB0aGUgYXV0b3NpemluZyBvZiBjaGVjayBib3hlcy4gVGhpcyBwYXJhZ3JhcGggc2hvdWxk IGJlIGF1dG9zaXplZCwgd2hpbGUKK3RoZSBjaGVjayBib3hlcyBiZWxvdyBzaG91bGQgbm90IGJl IGF1dG9zaXplZC4gTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyCithZGlw aXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUg ZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwvZGl2PgorPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4K K0NoZWNrIG9uZSBvciBtb3JlOgorPGlucHV0IHR5cGU9ImNoZWNrYm94IiBuYW1lPSJ2ZWhpY2xl IiB2YWx1ZT0iQmlrZSI+SSBoYXZlIGEgYmlrZTxici8+Cis8aW5wdXQgdHlwZT0iY2hlY2tib3gi IG5hbWU9InZlaGljbGUiIHZhbHVlPSJDYXIiPkkgaGF2ZSBhIGNhciA8YnIvPgorPC9mb3JtPgor PC9kaXY+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1yYWRpby1pbnB1 dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3Npemlu Zy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXJhZGlvLWlucHV0LWVsZW1lbnQtZXhwZWN0ZWQuaHRt bApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi5mZjAxYTQzMmE4ZTZlMjg4NmNkMmY0N2Q2YjYyMmQ1MjkzYTMwNzU1Ci0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1j b250cm9scy1ib29zdGluZy1yYWRpby1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKQEAgLTAs MCArMSwzNiBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1l PSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAg d2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47Cisg IH0KKzwvc3R5bGU+CisKKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+Cis8ZGl2IHN0eWxlPSJm b250LXNpemU6IDIuNXJlbSI+CitUaGlzIHRlc3RzIHRoZSBhdXRvc2l6aW5nIG9mIHJhZGlvIGJ1 dHRvbnMuIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQsIHdoaWxlCit0aGUgcmFk aW8gYnV0dG9ucyBiZWxvdyBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4gTG9yZW0gaXBzdW0gZG9s b3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyCithZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21v ZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwv ZGl2PgorPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KK1NlbGVjdCBvbmUgb2Y6PGJyLz4KKzxpbnB1 dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMSIgY2hlY2tlZD0iY2hlY2tlZCIvPgorPGxhYmVsIGZv cj0icmFkaW8xIj5SYWRpbzE8L2xhYmVsPjxici8+Cis8aW5wdXQgdHlwZT0icmFkaW8iIGlkPSJy YWRpbzIiLz4KKzxsYWJlbCBmb3I9InJhZGlvMiI+UmFkaW8yPC9sYWJlbD48YnIvPgorPC9mb3Jt PgorPC9kaXY+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1yYWRpby1p bnB1dC1lbGVtZW50Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3Jt LWNvbnRyb2xzLWJvb3N0aW5nLXJhZGlvLWlucHV0LWVsZW1lbnQuaHRtbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45 Yzk1MmE2MjkyZTI4ZGEwNWZhZWI3NzZhN2NlYzM3NDRhYjYzNDFmCi0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGlu Zy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0bWwKQEAgLTAsMCArMSw0NCBAQAorPCFET0NUWVBFIGh0 bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lk dGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdp bjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+ CitpZiAod2luZG93LmludGVybmFscykgeworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Mu c2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0 dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOworfSBl bHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xlLndh cm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBiZWlu ZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBU ZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMyMHB4 IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNLX0ZP UkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwvaGVh ZD4KKzxib2R5PgorCis8ZGl2PgorPGRpdj4KK1RoaXMgdGVzdHMgdGhlIGF1dG9zaXppbmcgb2Yg cmFkaW8gYnV0dG9ucy4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUK K3RoZSByYWRpbyBidXR0b25zIGJlbG93IHNob3VsZCBub3QgYmUgYXV0b3NpemVkLiBMb3JlbSBp cHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIKK2FkaXBpc2ljaW5nIGVsaXQsIHNlZCBk byBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxp cXVhLgorPC9kaXY+Cis8ZGl2PgorPGZvcm0gYWN0aW9uPSIiPgorU2VsZWN0IG9uZSBvZjo8YnIv PgorPGlucHV0IHR5cGU9InJhZGlvIiBpZD0icmFkaW8xIiBjaGVja2VkPSJjaGVja2VkIi8+Cis8 bGFiZWwgZm9yPSJyYWRpbzEiPlJhZGlvMTwvbGFiZWw+PGJyLz4KKzxpbnB1dCB0eXBlPSJyYWRp byIgaWQ9InJhZGlvMiIvPgorPGxhYmVsIGZvcj0icmFkaW8yIj5SYWRpbzI8L2xhYmVsPjxici8+ Cis8L2Zvcm0+Cis8L2Rpdj4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5n LXNlbGVjdC1lbGVtZW50LWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0 b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXNlbGVjdC1lbGVtZW50LWV4cGVjdGVkLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZjg2MGM2NzBiZGQ2ZWE5OWY4MDgxM2MzNWMyOTk2ODFhNDkzOTIwYQot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0t Y29udHJvbHMtYm9vc3Rpbmctc2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbApAQCAtMCwwICsx LDM2IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZp ZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3aWR0 aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgfQor PC9zdHlsZT4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+Cis8ZGl2IHN0eWxlPSJmb250LXNp emU6IDIuNXJlbSI+CitUaGlzIHRlc3RzIHRoZSBhdXRvc2l6aW5nIG9mIGEgc2VsZWN0aW9uIG1l bnUgZWxlbWVudC4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUKK3Ro ZSBzZWxlY3Rpb24gYm94IGJlbG93IHNob3VsZCBub3QgYmUgYXV0b3NpemVkLiBMb3JlbSBpcHN1 bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcKK2VsaXQsIHNlZCBkbyBl aXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVh LgorPC9kaXY+Cis8ZGl2PgorPGZvcm0gYWN0aW9uPSIiPgorU2VsZWN0aW9uOgorPHNlbGVjdD4K KyAgPG9wdGlvbiBzZWxlY3RlZCB2YWx1ZT1kZWZhdWx0PkRlZmF1bHQ8L29wdGlvbj4KKyAgPG9w dGlvbj5PcHRpb24gMTwvb3B0aW9uPgorICA8b3B0aW9uPk9wdGlvbiAyPC9vcHRpb24+Cis8L3Nl bGVjdD4KKzwvZm9ybT4KKzwvZGl2PgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9v c3Rpbmctc2VsZWN0LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6 aW5nL2Zvcm0tY29udHJvbHMtYm9vc3Rpbmctc2VsZWN0LWVsZW1lbnQuaHRtbApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li5hMjU0ZGRmZWNhNDM5MDk3YjFkYzZjYzA2NmI3ZTc2YWExZjJlN2U0Ci0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29z dGluZy1zZWxlY3QtZWxlbWVudC5odG1sCkBAIC0wLDAgKzEsNDUgQEAKKzwhRE9DVFlQRSBodG1s PgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRo PTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46 IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8c2NyaXB0Pgor aWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNl dFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRp bmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30gZWxz ZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7CisgICAgY29uc29sZS53YXJu KCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVpbmcg dHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUgVGV4 dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBweCBk ZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19GT1JD RV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hlYWQ+ Cis8Ym9keT4KKworPGRpdj4KKzxkaXY+CitUaGlzIHRlc3RzIHRoZSBhdXRvc2l6aW5nIG9mIGEg c2VsZWN0aW9uIG1lbnUgZWxlbWVudC4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXpl ZCwgd2hpbGUKK3RoZSBzZWxlY3Rpb24gYm94IGJlbG93IHNob3VsZCBub3QgYmUgYXV0b3NpemVk LiBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcKK2Vs aXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUg bWFnbmEgYWxpcXVhLgorPC9kaXY+Cis8ZGl2PgorPGZvcm0gYWN0aW9uPSIiPgorU2VsZWN0aW9u OgorPHNlbGVjdD4KKyAgPG9wdGlvbiBzZWxlY3RlZCB2YWx1ZT1kZWZhdWx0PkRlZmF1bHQ8L29w dGlvbj4KKyAgPG9wdGlvbj5PcHRpb24gMTwvb3B0aW9uPgorICA8b3B0aW9uPk9wdGlvbiAyPC9v cHRpb24+Cis8L3NlbGVjdD4KKzwvZm9ybT4KKzwvZGl2PgorPC9kaXY+CisKKzwvYm9keT4KKzwv aHRtbD4K 179476 2012-12-14 07:12:39 -0800 2012-12-14 11:17:55 -0800 Patch bug-102560-20121214150958.patch text/plain 21806 timvolodine U3VidmVyc2lvbiBSZXZpc2lvbjogMTM2NTA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDAwYjI2MTA1ZWM3MGUy NjM5YzY3ZDBlOWFiMzRlNmZhYjI4YWVkNy4uNjNkMzUwZjc1YjQzZDI2MzY4MjNlYjEwNWU3ZDVh MWNlMTEwOTcyYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEyLTEyLTEyICBUaW0g Vm9sb2RpbmUgIDx0aW12b2xvZGluZUBnb29nbGUuY29tPgorCisgICAgICAgIFRleHQgQXV0b3Np emluZzogV29yayBvdXQgd2hhdCB0byBkbyBhYm91dCBmb3JtIGNvbnRyb2xzCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDI1NjAKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBEaXNhbGxvdyBhdXRvc2l6aW5n IG9mIGZvcm0gaW5wdXQgY29udHJvbHMgbGlrZSBidXR0b25zLCB0ZXh0IGlucHV0IGZpZWxkcywg c2VsZWN0aW9uIGNvbnRyb2xzLCByYWRpbyBidXR0b25zCisgICAgICAgIGFuZCBjaGVjayBib3hl cy4gVGhpcyBpcyBhIHNob3J0IHRlcm0gc29sdXRpb24gdG8gYXZvaWQgaW5jb25zaXN0ZW50IGF1 dG9zaXppbmcgb2YgZm9ybSBjb250cm9scyAod2hpY2ggaXMKKyAgICAgICAgd29yc2UgdGhhbiBu b3QgYXV0b3NpemluZyBhdCBhbGwpLgorCisgICAgICAgIFRlc3RzOiBmYXN0L3RleHQtYXV0b3Np emluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50 cy5odG1sCisgICAgICAgICAgICAgICBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xz LWJvb3N0aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbAorICAgICAgICAgICAgICAgZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1yYWRpby1pbnB1dC1lbGVt ZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYm9vc3Rpbmctc2VsZWN0LWVsZW1lbnQuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1Rl eHRBdXRvc2l6ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpU ZXh0QXV0b3NpemVyOjpjb250YWluZXJTaG91bGRCZUF1dG9zaXplZCk6CisgICAgICAgIChXZWJD b3JlOjpUZXh0QXV0b3NpemVyOjpjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZCk6CisgICAgICAg IChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpwcm9jZXNzQ29udGFpbmVyKToKKyAgICAgICAgKFdl YkNvcmU6OlRleHRBdXRvc2l6ZXI6OmlzQXV0b3NpemluZ0NvbnRhaW5lcik6CisgICAgICAgIChX ZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpjb250YWluZXJDb250YWluc1RhZ3MpOgorICAgICAgICAo V2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6bWVhc3VyZURlc2NlbmRhbnRUZXh0V2lkdGgpOgorICAg ICAgICAoV2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6ZmluZERlZXBlc3RCbG9ja0NvbnRhaW5pbmdB bGxUZXh0KToKKyAgICAgICAgKiByZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oOgorCiAyMDEyLTEy LTA0ICBBbnRvaW5lIFF1aW50ICA8Z3Jhb3V0c0BhcHBsZS5jb20+CiAKICAgICAgICAgVGV4dFRy YWNrJ3MgLmtpbmQgcHJvcGVydHkgc2hvdWxkIHJldHVybiBsb3dlci1jYXNlIHZhbHVlcwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwCmluZGV4IGIxMDJiMmI1YjI5 Mzc1YzcyODQ5MmMxYzk4NGJmN2Y4NjVkODcyMjEuLjVlZDYzOWI1MmU1NGVjYTFhYjI3MWY3N2I5 Y2UyZjUzYzAxYTc1YjcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0 QXV0b3NpemVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXpl ci5jcHAKQEAgLTI1LDYgKzI1LDcgQEAKICNpbmNsdWRlICJUZXh0QXV0b3NpemVyLmgiCiAKICNp bmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCiAjaW5jbHVkZSAi SW5zcGVjdG9ySW5zdHJ1bWVudGF0aW9uLmgiCiAjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCiAj aW5jbHVkZSAiUmVuZGVyU3R5bGUuaCIKQEAgLTMyLDE2ICszMywzMyBAQAogI2luY2x1ZGUgIlJl bmRlclZpZXcuaCIKICNpbmNsdWRlICJTZXR0aW5ncy5oIgogI2luY2x1ZGUgIlN0eWxlSW5oZXJp dGVkRGF0YS5oIgorI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIAogI2luY2x1ZGUgPGFs Z29yaXRobT4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCit1c2luZyBuYW1lc3BhY2UgSFRNTE5h bWVzOworCiBzdHJ1Y3QgVGV4dEF1dG9zaXppbmdXaW5kb3dJbmZvIHsKICAgICBJbnRTaXplIHdp bmRvd1NpemU7CiAgICAgSW50U2l6ZSBtaW5MYXlvdXRTaXplOwogfTsKIAorCitzdGF0aWMgY29u c3QgVmVjdG9yPFF1YWxpZmllZE5hbWU+JiBmb3JtSW5wdXRUYWdzKCkKK3sKKyAgICAvLyByZXR1 cm5zIHRoZSB0YWdzIGZvciB0aGUgZm9ybSBpbnB1dCBlbGVtZW50cworICAgIERFRklORV9TVEFU SUNfTE9DQUwoVmVjdG9yPFF1YWxpZmllZE5hbWU+LCBmb3JtSW5wdXRUYWdzLCAoKSk7CisgICAg aWYgKGZvcm1JbnB1dFRhZ3MuaXNFbXB0eSgpKSB7CisgICAgICAgIGZvcm1JbnB1dFRhZ3MuYXBw ZW5kKGlucHV0VGFnKTsKKyAgICAgICAgZm9ybUlucHV0VGFncy5hcHBlbmQodGV4dGFyZWFUYWcp OworICAgICAgICBmb3JtSW5wdXRUYWdzLmFwcGVuZChidXR0b25UYWcpOworICAgICAgICBmb3Jt SW5wdXRUYWdzLmFwcGVuZChzZWxlY3RUYWcpOworICAgIH0KKyAgICByZXR1cm4gZm9ybUlucHV0 VGFnczsKK30KKwogVGV4dEF1dG9zaXplcjo6VGV4dEF1dG9zaXplcihEb2N1bWVudCogZG9jdW1l bnQpCiAgICAgOiBtX2RvY3VtZW50KGRvY3VtZW50KQogewpAQCAtMTE5LDcgKzEzNywxNSBAQCB2 b2lkIFRleHRBdXRvc2l6ZXI6OnByb2Nlc3NDbHVzdGVyKFJlbmRlckJsb2NrKiBjbHVzdGVyLCBS ZW5kZXJCbG9jayogY29udGFpbmVyLAogICAgIHByb2Nlc3NDb250YWluZXIobXVsdGlwbGllciwg Y29udGFpbmVyLCBzdWJ0cmVlUm9vdCwgd2luZG93SW5mbyk7CiB9CiAKLXN0YXRpYyBib29sIGNv bnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIpCiti b29sIFRleHRBdXRvc2l6ZXI6OmNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRl ckJsb2NrKiBjb250YWluZXIpCit7CisgICAgaWYgKGNvbnRhaW5lckNvbnRhaW5zVGFncyhjb250 YWluZXIsIGZvcm1JbnB1dFRhZ3MoKSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIHJl dHVybiAhY29udGVudEhlaWdodElzQ29uc3RyYWluZWQoY29udGFpbmVyKTsKK30KKworYm9vbCBU ZXh0QXV0b3NpemVyOjpjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJCbG9j ayogY29udGFpbmVyKQogewogICAgIC8vIEZJWE1FOiBQcm9wYWdhdGUgY29uc3RyYWluZWRuZXNz IGRvd24gdGhlIHRyZWUsIHRvIGF2b2lkIGluZWZmaWNpZW50bHkgd2Fsa2luZyBiYWNrIHVwIGZy b20gZWFjaCBib3guCiAgICAgLy8gRklYTUU6IFRoaXMgY29kZSBuZWVkcyB0byB0YWtlIGludG8g YWNjb3VudCB2ZXJ0aWNhbCB3cml0aW5nIG1vZGVzLgpAQCAtMTQzLDcgKzE2OSw3IEBAIHZvaWQg VGV4dEF1dG9zaXplcjo6cHJvY2Vzc0NvbnRhaW5lcihmbG9hdCBtdWx0aXBsaWVyLCBSZW5kZXJC bG9jayogY29udGFpbmVyLCBSCiB7CiAgICAgQVNTRVJUKGlzQXV0b3NpemluZ0NvbnRhaW5lcihj b250YWluZXIpKTsKIAotICAgIGZsb2F0IGxvY2FsTXVsdGlwbGllciA9IGNvbnRlbnRIZWlnaHRJ c0NvbnN0cmFpbmVkKGNvbnRhaW5lcikgPyAxIDogbXVsdGlwbGllcjsKKyAgICBmbG9hdCBsb2Nh bE11bHRpcGxpZXIgPSBjb250YWluZXJTaG91bGRCZUF1dG9zaXplZChjb250YWluZXIpID8gbXVs dGlwbGllciA6IDE7CiAKICAgICBSZW5kZXJPYmplY3QqIGRlc2NlbmRhbnQgPSBuZXh0SW5QcmVP cmRlclNraXBwaW5nRGVzY2VuZGFudHNPZkNvbnRhaW5lcnMoc3VidHJlZVJvb3QsIHN1YnRyZWVS b290KTsKICAgICB3aGlsZSAoZGVzY2VuZGFudCkgewpAQCAtMjExLDYgKzIzNywxMSBAQCBib29s IFRleHRBdXRvc2l6ZXI6OmlzQXV0b3NpemluZ0NvbnRhaW5lcihjb25zdCBSZW5kZXJPYmplY3Qq IHJlbmRlcmVyKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgaWYgKHJlbmRlcmVyLT5pc0xp c3RJdGVtKCkpCiAgICAgICAgIHJldHVybiByZW5kZXJlci0+aXNGbG9hdGluZygpIHx8IHJlbmRl cmVyLT5pc091dE9mRmxvd1Bvc2l0aW9uZWQoKTsKKyAgICAvLyBBdm9pZCBjcmVhdGluZyBjb250 YWluZXJzIGZvciB0ZXh0IHdpdGhpbiB0ZXh0IGNvbnRyb2xzLCBidXR0b25zLCBvciA8c2VsZWN0 PiBkcm9wZG93bnMKKyAgICBOb2RlKiBwYXJlbnROb2RlID0gcmVuZGVyZXItPnBhcmVudCgpID8g cmVuZGVyZXItPnBhcmVudCgpLT5nZW5lcmF0aW5nTm9kZSgpIDogMDsKKyAgICBpZiAocGFyZW50 Tm9kZSAmJiBwYXJlbnROb2RlLT5pc0VsZW1lbnROb2RlKCkgJiYgZm9ybUlucHV0VGFncygpLmNv bnRhaW5zKHRvRWxlbWVudChwYXJlbnROb2RlKS0+dGFnUU5hbWUoKSkpCisgICAgICAgIHJldHVy biBmYWxzZTsKKwogICAgIHJldHVybiB0cnVlOwogfQogCkBAIC0yNzEsOSArMzAyLDI0IEBAIGJv b2wgVGV4dEF1dG9zaXplcjo6Y2x1c3RlclNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJs b2NrKiBsb3dlc3RDb21tb25BbmNlCiAgICAgcmV0dXJuIGZhbHNlOwogfQogCitib29sIFRleHRB dXRvc2l6ZXI6OmNvbnRhaW5lckNvbnRhaW5zVGFncyhjb25zdCBSZW5kZXJCbG9jayogY29udGFp bmVyLCBjb25zdCBWZWN0b3I8UXVhbGlmaWVkTmFtZT4mIHRhZ3MpCit7CisgICAgY29uc3QgUmVu ZGVyT2JqZWN0KiByZW5kZXJlciA9IGNvbnRhaW5lcjsKKyAgICB3aGlsZSAocmVuZGVyZXIpIHsK KyAgICAgICAgY29uc3QgTm9kZSogcmVuZGVyZXJOb2RlID0gcmVuZGVyZXItPm5vZGUoKTsKKyAg ICAgICAgaWYgKHJlbmRlcmVyTm9kZSAmJiByZW5kZXJlck5vZGUtPmlzRWxlbWVudE5vZGUoKSkg eworICAgICAgICAgICAgaWYgKHRhZ3MuY29udGFpbnModG9FbGVtZW50KHJlbmRlcmVyTm9kZSkt PnRhZ1FOYW1lKCkpKQorICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOworICAgICAgICB9Cisg ICAgICAgIHJlbmRlcmVyID0gbmV4dEluUHJlT3JkZXJTa2lwcGluZ0Rlc2NlbmRhbnRzT2ZDb250 YWluZXJzKHJlbmRlcmVyLCBjb250YWluZXIpOworICAgIH0KKworICAgIHJldHVybiBmYWxzZTsK K30KKwogdm9pZCBUZXh0QXV0b3NpemVyOjptZWFzdXJlRGVzY2VuZGFudFRleHRXaWR0aChjb25z dCBSZW5kZXJCbG9jayogY29udGFpbmVyLCBmbG9hdCBtaW5UZXh0V2lkdGgsIGZsb2F0JiB0ZXh0 V2lkdGgpCiB7Ci0gICAgYm9vbCBza2lwTG9jYWxUZXh0ID0gY29udGVudEhlaWdodElzQ29uc3Ry YWluZWQoY29udGFpbmVyKTsKKyAgICBib29sIHNraXBMb2NhbFRleHQgPSAhY29udGFpbmVyU2hv dWxkQmVBdXRvc2l6ZWQoY29udGFpbmVyKTsKIAogICAgIFJlbmRlck9iamVjdCogZGVzY2VuZGFu dCA9IG5leHRJblByZU9yZGVyU2tpcHBpbmdEZXNjZW5kYW50c09mQ29udGFpbmVycyhjb250YWlu ZXIsIGNvbnRhaW5lcik7CiAgICAgd2hpbGUgKGRlc2NlbmRhbnQpIHsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmggYi9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oCmluZGV4IGE3MDliMTE2OGU0NGRmMDBlYzFmOWQ3M2Ji ZTVlNTE2ZmU5MjY3NzQuLjY0OTMzNDgxMDM2N2Q4YjFkMzI3Yjg0OTBiNzA4N2IxNjdkODhmZDAg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmgKKysr IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaApAQCAtMjgsNiArMjgs NyBAQAogCiAjaWYgRU5BQkxFKFRFWFRfQVVUT1NJWklORykKIAorI2luY2x1ZGUgIkhUTUxOYW1l cy5oIgogI2luY2x1ZGUgIkludFNpemUuaCIKICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4K ICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgpAQCAtNzEsNiArNzIsOSBAQCBwcml2YXRlOgog ICAgIHN0YXRpYyBib29sIGlzQXV0b3NpemluZ0NsdXN0ZXIoY29uc3QgUmVuZGVyQmxvY2sqKTsK IAogICAgIHN0YXRpYyBib29sIGNsdXN0ZXJTaG91bGRCZUF1dG9zaXplZChjb25zdCBSZW5kZXJC bG9jayogbG93ZXN0Q29tbW9uQW5jZXN0b3IsIGZsb2F0IGNvbW1vbkFuY2VzdG9yV2lkdGgpOwor ICAgIHN0YXRpYyBib29sIGNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJs b2NrKiBjb250YWluZXIpOworICAgIHN0YXRpYyBib29sIGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFp bmVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIpOworICAgIHN0YXRpYyBib29sIGNvbnRh aW5lckNvbnRhaW5zVGFncyhjb25zdCBSZW5kZXJCbG9jayogY2x1c3RlciwgY29uc3QgVmVjdG9y PFF1YWxpZmllZE5hbWU+JiB0YWdzKTsKICAgICBzdGF0aWMgdm9pZCBtZWFzdXJlRGVzY2VuZGFu dFRleHRXaWR0aChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyLCBmbG9hdCBtaW5UZXh0V2lk dGgsIGZsb2F0JiB0ZXh0V2lkdGgpOwogCiAgICAgLy8gVXNlIHRvIHRyYXZlcnNlIHRoZSB0cmVl IG9mIGRlc2NlbmRhbnRzLCBleGNsdWRpbmcgZGVzY2VuZGFudHMgb2YgY29udGFpbmVycyAoYnV0 IHJldHVybmluZyB0aGUgY29udGFpbmVycyB0aGVtc2VsdmVzKS4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBhODlkZDQ1ZjQ1 NDBiNWM4MzZmODRjMmY0ZDA3ZGY0NTk3MTllZDFmLi5lOGY2NTVhNmVkZjE5ODVkYjllNDVkNWM5 NDg3MDI1Yzk0Mzk5MTZjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIv TGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIgQEAKKzIwMTItMTItMTIgIFRpbSBW b2xvZGluZSAgPHRpbXZvbG9kaW5lQGdvb2dsZS5jb20+CisKKyAgICAgICAgVGV4dCBBdXRvc2l6 aW5nOiBXb3JrIG91dCB3aGF0IHRvIGRvIGFib3V0IGZvcm0gY29udHJvbHMKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwMjU2MAorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRlc3RzIGZvciBmb3JtIGlucHV0 IGVsZW1lbnRzIGF1dG9zaXppbmcuIEFkZGVkIHRlc3RzIHRvIGNoZWNrIHRoYXQgdmFyaW91cyBr aW5kcyBvZiBmb3JtIGVsZW1lbnRzCisgICAgICAgIGRvbid0IGdldCBhdXRvc2l6ZWQsIGkuZS4g YnV0dG9ucywgdGV4dGFyZWFzLCBjaGVjayBib3hlcywgcmFkaW8gYnV0dG9uIGFuZCBzZWxlY3Rp b24gbWVudXMuCisKKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xz LWJvb3N0aW5nLWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1sOiBB ZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0 aW5nLWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50cy5odG1sOiBBZGRlZC4KKyAgICAgICAg KiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWNoZWNrYm94LWlu cHV0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1 dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50Lmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMt Ym9vc3RpbmctcmFkaW8taW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sOiBBZGRlZC4KKyAgICAg ICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXJhZGlvLWlu cHV0LWVsZW1lbnQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcv Zm9ybS1jb250cm9scy1ib29zdGluZy1zZWxlY3QtZWxlbWVudC1leHBlY3RlZC5odG1sOiBBZGRl ZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5n LXNlbGVjdC1lbGVtZW50Lmh0bWw6IEFkZGVkLgorCiAyMDEyLTEyLTA0ICBBbnRvaW5lIFF1aW50 ICA8Z3Jhb3V0c0BhcHBsZS5jb20+CiAKICAgICAgICAgVGV4dFRyYWNrJ3MgLmtpbmQgcHJvcGVy dHkgc2hvdWxkIHJldHVybiBsb3dlci1jYXNlIHZhbHVlcwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1idXR0b24tdGV4 dGFyZWEtaW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4 dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctYnV0dG9uLXRleHRhcmVhLWlucHV0 LWVsZW1lbnRzLWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYTM3YzU2NjA3NzI3MThjNzkzZDJj Y2FmNjYyNWQ3OWY0NTVkMGJiMgotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3Qv dGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctYnV0dG9uLXRleHRhcmVhLWlu cHV0LWVsZW1lbnRzLWV4cGVjdGVkLmh0bWwKQEAgLTAsMCArMSw4NCBAQAorPCFET0NUWVBFIGh0 bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lk dGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdp bjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKyAgCisgICNoZWFkZXIgZm9ybSB7 CisgICAgZm9udC1zaXplOiA4NSU7CisgICAgZGlzcGxheTogaW5saW5lOworICB9CisgIAorICAj aGVhZGVyIC5saW5rcyB7CisgICAgZm9udC1zaXplOiA4NSU7CisgIH0KKyAgCisgIHVsLmxpbmtz IHsKKyAgICBtYXJnaW46IDA7CisgICAgcGFkZGluZzogMDsKKyAgICBsaXN0LXN0eWxlLXR5cGU6 IG5vbmU7CisgIH0KKworICB1bC5saW5rcyBsaSB7CisgICAgZGlzcGxheTogaW5saW5lOworICAg IHdoaXRlLXNwYWNlOiBub3dyYXA7CisgIH0KKzwvc3R5bGU+CisKKzwvaGVhZD4KKzxib2R5Pgor Cis8ZGl2IGlkPSJoZWFkZXIiPgorICA8dWwgY2xhc3M9ImxpbmtzIj4KKyAgICA8bGk+CisgICAg ICA8YSBocmVmPSIuLyI+SG9tZTwvYT4KKyAgICA8L2xpPgorICAgIDxsaT4KKyAgICAgIDxzcGFu PnwgPC9zcGFuPgorICAgICAgPGEgaHJlZj0iIj5OZXc8L2E+CisgICAgPC9saT4KKyAgICA8bGk+ CisgICAgICA8c3Bhbj58IDwvc3Bhbj4KKyAgICAgIDxhIGhyZWY9IiI+U2VhcmNoPC9hPgorICAg IDwvbGk+CisgICAgPGxpPgorICAgICAgPHNwYW4+fCA8L3NwYW4+CisgICAgICA8Zm9ybT4KKyAg ICAgICAgPGlucHV0IGNsYXNzPSJ0eHQiIHR5cGU9InRleHQiIGlkPSJxdWlja3NlYXJjaF90b3Ai IG5hbWU9InF1aWNrc2VhcmNoIj4KKyAgICAgICAgPGlucHV0IGNsYXNzPSJidG4iIHR5cGU9InN1 Ym1pdCIgdmFsdWU9IkZpbmQiIGlkPWZpbmRfdG9wIj4KKyAgICAgIDwvZm9ybT4KKyAgICA8L2xp PgorICAgIDxsaT4KKyAgICAgIDxzcGFuPnwgPC9zcGFuPgorICAgICAgPGEgaHJlZj0iIj5SZXBv cnRzPC9hPgorICAgIDwvbGk+CisgIDwvdWw+Cis8L2Rpdj4KKworPGRpdj4KKyAgPHA+PGRpdiBz dHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICBUaGlzIHRlc3QgY2hlY2tzIHRoYXQgZm9ybSBj b250cm9scyBsaWtlIGJ1dHRvbnMsIHRleHQgaW5wdXRzIGFuZCBjaGVjay1ib3hlcyBhcmUgbm90 IGF1dG9zaXplZC4KKyAgVGhlIHRleHQgaW4gdGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9z aXplZCwgd2hpbGUgdGhlIGZvcm0gY29udHJvbHMgYWJvdmUgYW5kIGJlbG93IHNob3VsZCBub3Qu CisgIFRoZSAiRmluZCIgYnV0dG9uIGFuZCB0ZXh0LWlucHV0IGJveCBhdCB0aGUgYm90dG9tIG9m IHRoZSBwYWdlIHNob3VsZCBub3QgYmUgYXV0b3NpemVkLgorICA8L2Rpdj48L3A+CisKKyAgPGZv cm0+CisgIDxkaXY+CisgICAgPHA+PGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAg IFRoaXMgdGV4dCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZSB0aGUgaW5wdXQgY29udHJvbHMg YmVsb3cgc2hvdWxkIG5vdC4KKyAgICA8L2Rpdj48L3A+CisgICAgPGlucHV0IGlkPSJxdWlja3Nl YXJjaCIgdHlwZT0idGV4dCIgbmFtZT0icXVpY2tzZWFyY2giPgorICAgIDxpbnB1dCBpZD0iZmlu ZCIgdHlwZT0ic3VibWl0IiB2YWx1ZT0iRmluZCI+CisgIDwvZGl2PgorICA8L2Zvcm0+CisKKzwv ZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3Rl eHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWJ1dHRvbi10ZXh0YXJlYS1pbnB1 dC1lbGVtZW50cy5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1j b250cm9scy1ib29zdGluZy1idXR0b24tdGV4dGFyZWEtaW5wdXQtZWxlbWVudHMuaHRtbApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi4wMGVkNzE3MDFlNmFjZjQ3ZWUyNDI1ZDA3YmEwZWQ3ZjE3OTAxY2FmCi0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1ib29zdGluZy1idXR0b24tdGV4dGFyZWEtaW5wdXQtZWxlbWVudHMuaHRtbApAQCAtMCwwICsx LDkzIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZp ZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3aWR0 aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgfQor ICAKKyAgI2hlYWRlciBmb3JtIHsKKyAgICBmb250LXNpemU6IDg1JTsKKyAgICBkaXNwbGF5OiBp bmxpbmU7CisgIH0KKyAgCisgICNoZWFkZXIgLmxpbmtzIHsKKyAgICBmb250LXNpemU6IDg1JTsK KyAgfQorICAKKyAgdWwubGlua3MgeworICAgIG1hcmdpbjogMDsKKyAgICBwYWRkaW5nOiAwOwor ICAgIGxpc3Qtc3R5bGUtdHlwZTogbm9uZTsKKyAgfQorCisgIHVsLmxpbmtzIGxpIHsKKyAgICBk aXNwbGF5OiBpbmxpbmU7CisgICAgd2hpdGUtc3BhY2U6IG5vd3JhcDsKKyAgfQorPC9zdHlsZT4K KworPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJuYWxzKSB7CisgICAgd2luZG93LmludGVybmFs cy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ0VuYWJsZWQodHJ1ZSk7CisgICAgd2luZG93Lmlu dGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ1dpbmRvd1NpemVPdmVycmlkZSgzMjAs IDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRvdy5jb25zb2xlICYmIGNvbnNvbGUud2FybikgeworICAg IGNvbnNvbGUud2FybigiVGhpcyB0ZXN0IGRlcGVuZHMgb24gdGhlIFRleHQgQXV0b3NpemluZyBz ZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1biBpdCBpbiBEdW1wUmVuZGVyVHJlZSwgb3IgbWFudWFs bHkgZW5hYmxlIFRleHQgQXV0b3NpemluZywgYW5kIGVpdGhlciB1c2UgYSBtb2JpbGUgZGV2aWNl IHdpdGggMzIwcHggZGV2aWNlLXdpZHRoIChsaWtlIE5leHVzIFMgb3IgaVBob25lKSwgb3IgZGVm aW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRPU0laSU5HX09OX0RFU0tUT1AuIik7Cit9Cis8L3Njcmlw dD4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXYgaWQ9ImhlYWRlciI+CisgIDx1bCBjbGFzcz0i bGlua3MiPgorICAgIDxsaT4KKyAgICAgIDxhIGhyZWY9Ii4vIj5Ib21lPC9hPgorICAgIDwvbGk+ CisgICAgPGxpPgorICAgICAgPHNwYW4+fCA8L3NwYW4+CisgICAgICA8YSBocmVmPSIiPk5ldzwv YT4KKyAgICA8L2xpPgorICAgIDxsaT4KKyAgICAgIDxzcGFuPnwgPC9zcGFuPgorICAgICAgPGEg aHJlZj0iIj5TZWFyY2g8L2E+CisgICAgPC9saT4KKyAgICA8bGk+CisgICAgICA8c3Bhbj58IDwv c3Bhbj4KKyAgICAgIDxmb3JtPgorICAgICAgICA8aW5wdXQgY2xhc3M9InR4dCIgdHlwZT0idGV4 dCIgaWQ9InF1aWNrc2VhcmNoX3RvcCIgbmFtZT0icXVpY2tzZWFyY2giPgorICAgICAgICA8aW5w dXQgY2xhc3M9ImJ0biIgdHlwZT0ic3VibWl0IiB2YWx1ZT0iRmluZCIgaWQ9ZmluZF90b3AiPgor ICAgICAgPC9mb3JtPgorICAgIDwvbGk+CisgICAgPGxpPgorICAgICAgPHNwYW4+fCA8L3NwYW4+ CisgICAgICA8YSBocmVmPSIiPlJlcG9ydHM8L2E+CisgICAgPC9saT4KKyAgPC91bD4KKzwvZGl2 PgorCis8ZGl2PgorICA8cD48ZGl2PgorICBUaGlzIHRlc3QgY2hlY2tzIHRoYXQgZm9ybSBjb250 cm9scyBsaWtlIGJ1dHRvbnMsIHRleHQgaW5wdXRzIGFuZCBjaGVjay1ib3hlcyBhcmUgbm90IGF1 dG9zaXplZC4KKyAgVGhlIHRleHQgaW4gdGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXpl ZCwgd2hpbGUgdGhlIGZvcm0gY29udHJvbHMgYWJvdmUgYW5kIGJlbG93IHNob3VsZCBub3QuCisg IFRoZSAiRmluZCIgYnV0dG9uIGFuZCB0ZXh0LWlucHV0IGJveCBhdCB0aGUgYm90dG9tIG9mIHRo ZSBwYWdlIHNob3VsZCBub3QgYmUgYXV0b3NpemVkLgorICA8L2Rpdj48L3A+CisKKyAgPGZvcm0+ CisgIDxkaXY+CisgICAgPHA+PGRpdj4KKyAgICBUaGlzIHRleHQgc2hvdWxkIGJlIGF1dG9zaXpl ZCwgd2hpbGUgdGhlIGlucHV0IGNvbnRyb2xzIGJlbG93IHNob3VsZCBub3QuCisgICAgPC9kaXY+ PC9wPgorICAgIDxpbnB1dCBpZD0icXVpY2tzZWFyY2giIHR5cGU9InRleHQiIG5hbWU9InF1aWNr c2VhcmNoIj4KKyAgICA8aW5wdXQgaWQ9ImZpbmQiIHR5cGU9InN1Ym1pdCIgdmFsdWU9IkZpbmQi PgorICA8L2Rpdj4KKyAgPC9mb3JtPgorCis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZm IC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1i b29zdGluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRUZXN0 cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWNoZWNrYm94LWlu cHV0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42NTk2ZDM1ZDQ1MDM3NzE4NjQz YzgxM2U3MzJhM2U0OTRkNzQ5YTFlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1jaGVja2JveC1pbnB1dC1l bGVtZW50LWV4cGVjdGVkLmh0bWwKQEAgLTAsMCArMSwzNSBAQAorPCFET0NUWVBFIGh0bWw+Cis8 aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAw Ij4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsK KyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKworPC9oZWFkPgorPGJv ZHk+CisKKzxkaXY+Cis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDIuNXJlbSI+CitUaGlzIHRlc3Rz IHRoZSBhdXRvc2l6aW5nIG9mIGNoZWNrIGJveGVzLiBUaGlzIHBhcmFncmFwaCBzaG91bGQgYmUg YXV0b3NpemVkLCB3aGlsZQordGhlIGNoZWNrIGJveGVzIGJlbG93IGFuZCB0aGUgc3Vycm91bmRp bmcgdGV4dCBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4KK0xvcmVtIGlwc3VtIGRvbG9yIHNpdCBh bWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IK K2luY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxk aXY+Cis8Zm9ybSBhY3Rpb249IiI+CitDaGVjayBvbmUgb3IgbW9yZToKKzxpbnB1dCB0eXBlPSJj aGVja2JveCIgbmFtZT0idmVoaWNsZSIgdmFsdWU9IkJpa2UiPkkgaGF2ZSBhIGJpa2U8YnIvPgor PGlucHV0IHR5cGU9ImNoZWNrYm94IiBuYW1lPSJ2ZWhpY2xlIiB2YWx1ZT0iQ2FyIj5JIGhhdmUg YSBjYXIgPGJyLz4KKzwvZm9ybT4KKzwvZGl2PgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4K ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYm9vc3RpbmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC5odG1sIGIvTGF5b3V0VGVzdHMvZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1jaGVja2JveC1pbnB1dC1l bGVtZW50Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYmI1OTliZjdkNzI0MjE0ZmJlMjdiM2U3ZjM4OGEzMDJi NjJiMWYyNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6 aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC5odG1sCkBA IC0wLDAgKzEsNDMgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEg bmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgewor ICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVu OworICB9Cis8L3N0eWxlPgorCis8c2NyaXB0PgoraWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAg ICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVl KTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93 U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30gZWxzZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29u c29sZS53YXJuKSB7CisgICAgY29uc29sZS53YXJuKCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUg VGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVpbmcgdHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5k ZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUgVGV4dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVz ZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBweCBkZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBv ciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19GT1JDRV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RP UC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdj4KKzxkaXY+CitU aGlzIHRlc3RzIHRoZSBhdXRvc2l6aW5nIG9mIGNoZWNrIGJveGVzLiBUaGlzIHBhcmFncmFwaCBz aG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZQordGhlIGNoZWNrIGJveGVzIGJlbG93IGFuZCB0aGUg c3Vycm91bmRpbmcgdGV4dCBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4KK0xvcmVtIGlwc3VtIGRv bG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21v ZCB0ZW1wb3IKK2luY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8 L2Rpdj4KKzxkaXY+Cis8Zm9ybSBhY3Rpb249IiI+CitDaGVjayBvbmUgb3IgbW9yZToKKzxpbnB1 dCB0eXBlPSJjaGVja2JveCIgbmFtZT0idmVoaWNsZSIgdmFsdWU9IkJpa2UiPkkgaGF2ZSBhIGJp a2U8YnIvPgorPGlucHV0IHR5cGU9ImNoZWNrYm94IiBuYW1lPSJ2ZWhpY2xlIiB2YWx1ZT0iQ2Fy Ij5JIGhhdmUgYSBjYXIgPGJyLz4KKzwvZm9ybT4KKzwvZGl2PgorPC9kaXY+CisKKzwvYm9keT4K KzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zv cm0tY29udHJvbHMtYm9vc3RpbmctcmFkaW8taW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sIGIv TGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1y YWRpby1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYWY1MDViYWM4NTIy ODYwN2MzMzI5YWI2ODIwZTZmOGFiOWUwZDY4NwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRl c3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctcmFkaW8taW5w dXQtZWxlbWVudC1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsMzcgQEAKKzwhRE9DVFlQRSBodG1s PgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRo PTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46 IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCisKKzwvaGVhZD4K Kzxib2R5PgorCis8ZGl2PgorPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorVGhpcyB0 ZXN0cyB0aGUgYXV0b3NpemluZyBvZiByYWRpbyBidXR0b25zLiBUaGlzIHBhcmFncmFwaCBzaG91 bGQgYmUgYXV0b3NpemVkLCB3aGlsZQordGhlIHJhZGlvIGJ1dHRvbnMgYmVsb3cgYW5kIHRoZSBz dXJyb3VuZGluZyB0ZXh0IHNob3VsZCBub3QgYmUgYXV0b3NpemVkLgorTG9yZW0gaXBzdW0gZG9s b3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9k IHRlbXBvcgoraW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwv ZGl2PgorPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KK1NlbGVjdCBvbmUgb2Y6PGJyLz4KKzxpbnB1 dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMSIgY2hlY2tlZD0iY2hlY2tlZCIvPgorPGxhYmVsIGZv cj0icmFkaW8xIj5SYWRpbzE8L2xhYmVsPjxici8+Cis8aW5wdXQgdHlwZT0icmFkaW8iIGlkPSJy YWRpbzIiLz4KKzxsYWJlbCBmb3I9InJhZGlvMiI+UmFkaW8yPC9sYWJlbD48YnIvPgorPC9mb3Jt PgorPC9kaXY+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1yYWRpby1p bnB1dC1lbGVtZW50Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3Jt LWNvbnRyb2xzLWJvb3N0aW5nLXJhZGlvLWlucHV0LWVsZW1lbnQuaHRtbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4z NDU3NDlmOWI4MTUwMmNhZTA0NWEwZjhjMmZkNmYwZTYyOTYyYzA4Ci0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGlu Zy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0bWwKQEAgLTAsMCArMSw0NSBAQAorPCFET0NUWVBFIGh0 bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lk dGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdp bjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+ CitpZiAod2luZG93LmludGVybmFscykgeworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Mu c2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0 dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOworfSBl bHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xlLndh cm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBiZWlu ZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBU ZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMyMHB4 IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNLX0ZP UkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwvaGVh ZD4KKzxib2R5PgorCis8ZGl2PgorPGRpdj4KK1RoaXMgdGVzdHMgdGhlIGF1dG9zaXppbmcgb2Yg cmFkaW8gYnV0dG9ucy4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUK K3RoZSByYWRpbyBidXR0b25zIGJlbG93IGFuZCB0aGUgc3Vycm91bmRpbmcgdGV4dCBzaG91bGQg bm90IGJlIGF1dG9zaXplZC4KK0xvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1 ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IKK2luY2lkaWR1bnQgdXQg bGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+Cis8Zm9ybSBhY3Rp b249IiI+CitTZWxlY3Qgb25lIG9mOjxici8+Cis8aW5wdXQgdHlwZT0icmFkaW8iIGlkPSJyYWRp bzEiIGNoZWNrZWQ9ImNoZWNrZWQiLz4KKzxsYWJlbCBmb3I9InJhZGlvMSI+UmFkaW8xPC9sYWJl bD48YnIvPgorPGlucHV0IHR5cGU9InJhZGlvIiBpZD0icmFkaW8yIi8+Cis8bGFiZWwgZm9yPSJy YWRpbzIiPlJhZGlvMjwvbGFiZWw+PGJyLz4KKzwvZm9ybT4KKzwvZGl2PgorPC9kaXY+CisKKzwv Ym9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6 aW5nL2Zvcm0tY29udHJvbHMtYm9vc3Rpbmctc2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbCBi L0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3Rpbmct c2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mODYwYzY3MGJkZDZlYTk5 ZjgwODEzYzM1YzI5OTY4MWE0OTM5MjBhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMv ZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1zZWxlY3QtZWxlbWVu dC1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsMzYgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+ Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8 c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAg b3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8L2hlYWQ+Cis8Ym9keT4KKwor PGRpdj4KKzxkaXYgc3R5bGU9ImZvbnQtc2l6ZTogMi41cmVtIj4KK1RoaXMgdGVzdHMgdGhlIGF1 dG9zaXppbmcgb2YgYSBzZWxlY3Rpb24gbWVudSBlbGVtZW50LiBUaGlzIHBhcmFncmFwaCBzaG91 bGQgYmUgYXV0b3NpemVkLCB3aGlsZQordGhlIHNlbGVjdGlvbiBib3ggYmVsb3cgc2hvdWxkIG5v dCBiZSBhdXRvc2l6ZWQuIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBh ZGlwaXNpY2luZworZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFi b3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+Cis8Zm9ybSBhY3Rpb249 IiI+CitTZWxlY3Rpb246Cis8c2VsZWN0PgorICA8b3B0aW9uIHNlbGVjdGVkIHZhbHVlPWRlZmF1 bHQ+RGVmYXVsdDwvb3B0aW9uPgorICA8b3B0aW9uPk9wdGlvbiAxPC9vcHRpb24+CisgIDxvcHRp b24+T3B0aW9uIDI8L29wdGlvbj4KKzwvc2VsZWN0PgorPC9mb3JtPgorPC9kaXY+Cis8L2Rpdj4K KworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1 dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1zZWxlY3QtZWxlbWVudC5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1zZWxl Y3QtZWxlbWVudC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmEyNTRkZGZlY2E0MzkwOTdiMWRjNmNjMDY2Yjdl NzZhYTFmMmU3ZTQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0 b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWwKQEAgLTAs MCArMSw0NSBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1l PSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAg d2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47Cisg IH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykgeworICAgIHdp bmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOwor ICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXpl T3ZlcnJpZGUoMzIwLCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xl Lndhcm4pIHsKKyAgICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0 IEF1dG9zaXppbmcgc2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRy ZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEg bW9iaWxlIGRldmljZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQ aG9uZSksIG9yIGRlZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIp OworfQorPC9zY3JpcHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2PgorPGRpdj4KK1RoaXMg dGVzdHMgdGhlIGF1dG9zaXppbmcgb2YgYSBzZWxlY3Rpb24gbWVudSBlbGVtZW50LiBUaGlzIHBh cmFncmFwaCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZQordGhlIHNlbGVjdGlvbiBib3ggYmVs b3cgc2hvdWxkIG5vdCBiZSBhdXRvc2l6ZWQuIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBj b25zZWN0ZXR1ciBhZGlwaXNpY2luZworZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lk aWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+Cis8 Zm9ybSBhY3Rpb249IiI+CitTZWxlY3Rpb246Cis8c2VsZWN0PgorICA8b3B0aW9uIHNlbGVjdGVk IHZhbHVlPWRlZmF1bHQ+RGVmYXVsdDwvb3B0aW9uPgorICA8b3B0aW9uPk9wdGlvbiAxPC9vcHRp b24+CisgIDxvcHRpb24+T3B0aW9uIDI8L29wdGlvbj4KKzwvc2VsZWN0PgorPC9mb3JtPgorPC9k aXY+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgo= 179492 2012-12-14 09:23:46 -0800 2012-12-14 11:30:46 -0800 Patch bug-102560-20121214172105.patch text/plain 23650 timvolodine U3VidmVyc2lvbiBSZXZpc2lvbjogMTM2NTA2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDAwYjI2MTA1ZWM3MGUy NjM5YzY3ZDBlOWFiMzRlNmZhYjI4YWVkNy4uNjNkMzUwZjc1YjQzZDI2MzY4MjNlYjEwNWU3ZDVh MWNlMTEwOTcyYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEyLTEyLTEyICBUaW0g Vm9sb2RpbmUgIDx0aW12b2xvZGluZUBnb29nbGUuY29tPgorCisgICAgICAgIFRleHQgQXV0b3Np emluZzogV29yayBvdXQgd2hhdCB0byBkbyBhYm91dCBmb3JtIGNvbnRyb2xzCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDI1NjAKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBEaXNhbGxvdyBhdXRvc2l6aW5n IG9mIGZvcm0gaW5wdXQgY29udHJvbHMgbGlrZSBidXR0b25zLCB0ZXh0IGlucHV0IGZpZWxkcywg c2VsZWN0aW9uIGNvbnRyb2xzLCByYWRpbyBidXR0b25zCisgICAgICAgIGFuZCBjaGVjayBib3hl cy4gVGhpcyBpcyBhIHNob3J0IHRlcm0gc29sdXRpb24gdG8gYXZvaWQgaW5jb25zaXN0ZW50IGF1 dG9zaXppbmcgb2YgZm9ybSBjb250cm9scyAod2hpY2ggaXMKKyAgICAgICAgd29yc2UgdGhhbiBu b3QgYXV0b3NpemluZyBhdCBhbGwpLgorCisgICAgICAgIFRlc3RzOiBmYXN0L3RleHQtYXV0b3Np emluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWJ1dHRvbi10ZXh0YXJlYS1pbnB1dC1lbGVtZW50 cy5odG1sCisgICAgICAgICAgICAgICBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xz LWJvb3N0aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbAorICAgICAgICAgICAgICAgZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1yYWRpby1pbnB1dC1lbGVt ZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYm9vc3Rpbmctc2VsZWN0LWVsZW1lbnQuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1Rl eHRBdXRvc2l6ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpU ZXh0QXV0b3NpemVyOjpjb250YWluZXJTaG91bGRCZUF1dG9zaXplZCk6CisgICAgICAgIChXZWJD b3JlOjpUZXh0QXV0b3NpemVyOjpjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZCk6CisgICAgICAg IChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpwcm9jZXNzQ29udGFpbmVyKToKKyAgICAgICAgKFdl YkNvcmU6OlRleHRBdXRvc2l6ZXI6OmlzQXV0b3NpemluZ0NvbnRhaW5lcik6CisgICAgICAgIChX ZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpjb250YWluZXJDb250YWluc1RhZ3MpOgorICAgICAgICAo V2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6bWVhc3VyZURlc2NlbmRhbnRUZXh0V2lkdGgpOgorICAg ICAgICAoV2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6ZmluZERlZXBlc3RCbG9ja0NvbnRhaW5pbmdB bGxUZXh0KToKKyAgICAgICAgKiByZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oOgorCiAyMDEyLTEy LTA0ICBBbnRvaW5lIFF1aW50ICA8Z3Jhb3V0c0BhcHBsZS5jb20+CiAKICAgICAgICAgVGV4dFRy YWNrJ3MgLmtpbmQgcHJvcGVydHkgc2hvdWxkIHJldHVybiBsb3dlci1jYXNlIHZhbHVlcwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwCmluZGV4IGIxMDJiMmI1YjI5 Mzc1YzcyODQ5MmMxYzk4NGJmN2Y4NjVkODcyMjEuLmU5YWM2YWIyZTM0YWQ2NmRmNWE0ZTZjOWEw NjA1MTYzOTM4NjhlNGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0 QXV0b3NpemVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXpl ci5jcHAKQEAgLTI1LDYgKzI1LDcgQEAKICNpbmNsdWRlICJUZXh0QXV0b3NpemVyLmgiCiAKICNp bmNsdWRlICJEb2N1bWVudC5oIgorI2luY2x1ZGUgIkhUTUxFbGVtZW50LmgiCiAjaW5jbHVkZSAi SW5zcGVjdG9ySW5zdHJ1bWVudGF0aW9uLmgiCiAjaW5jbHVkZSAiUmVuZGVyT2JqZWN0LmgiCiAj aW5jbHVkZSAiUmVuZGVyU3R5bGUuaCIKQEAgLTM1LDEzICszNiwzMSBAQAogCiAjaW5jbHVkZSA8 YWxnb3JpdGhtPgogCisjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgorCiBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAKK3VzaW5nIG5hbWVzcGFjZSBIVE1MTmFtZXM7CisKIHN0cnVjdCBUZXh0QXV0 b3NpemluZ1dpbmRvd0luZm8gewogICAgIEludFNpemUgd2luZG93U2l6ZTsKICAgICBJbnRTaXpl IG1pbkxheW91dFNpemU7CiB9OwogCisKK3N0YXRpYyBjb25zdCBWZWN0b3I8UXVhbGlmaWVkTmFt ZT4mIGZvcm1JbnB1dFRhZ3MoKQoreworICAgIC8vIFJldHVybnMgdGhlIHRhZ3MgZm9yIHRoZSBm b3JtIGlucHV0IGVsZW1lbnRzLgorICAgIERFRklORV9TVEFUSUNfTE9DQUwoVmVjdG9yPFF1YWxp ZmllZE5hbWU+LCBmb3JtSW5wdXRUYWdzLCAoKSk7CisgICAgaWYgKGZvcm1JbnB1dFRhZ3MuaXNF bXB0eSgpKSB7CisgICAgICAgIGZvcm1JbnB1dFRhZ3MuYXBwZW5kKGlucHV0VGFnKTsKKyAgICAg ICAgZm9ybUlucHV0VGFncy5hcHBlbmQodGV4dGFyZWFUYWcpOworICAgICAgICBmb3JtSW5wdXRU YWdzLmFwcGVuZChidXR0b25UYWcpOworICAgICAgICBmb3JtSW5wdXRUYWdzLmFwcGVuZChzZWxl Y3RUYWcpOworICAgIH0KKyAgICByZXR1cm4gZm9ybUlucHV0VGFnczsKK30KKwogVGV4dEF1dG9z aXplcjo6VGV4dEF1dG9zaXplcihEb2N1bWVudCogZG9jdW1lbnQpCiAgICAgOiBtX2RvY3VtZW50 KGRvY3VtZW50KQogewpAQCAtMTE5LDcgKzEzOCwxNSBAQCB2b2lkIFRleHRBdXRvc2l6ZXI6OnBy b2Nlc3NDbHVzdGVyKFJlbmRlckJsb2NrKiBjbHVzdGVyLCBSZW5kZXJCbG9jayogY29udGFpbmVy LAogICAgIHByb2Nlc3NDb250YWluZXIobXVsdGlwbGllciwgY29udGFpbmVyLCBzdWJ0cmVlUm9v dCwgd2luZG93SW5mbyk7CiB9CiAKLXN0YXRpYyBib29sIGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFp bmVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIpCitib29sIFRleHRBdXRvc2l6ZXI6OmNv bnRhaW5lclNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIpCit7 CisgICAgaWYgKGNvbnRhaW5lckNvbnRhaW5zVGFncyhjb250YWluZXIsIGZvcm1JbnB1dFRhZ3Mo KSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIHJldHVybiAhY29udGVudEhlaWdodElz Q29uc3RyYWluZWQoY29udGFpbmVyKTsKK30KKworYm9vbCBUZXh0QXV0b3NpemVyOjpjb250ZW50 SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyKQogewogICAg IC8vIEZJWE1FOiBQcm9wYWdhdGUgY29uc3RyYWluZWRuZXNzIGRvd24gdGhlIHRyZWUsIHRvIGF2 b2lkIGluZWZmaWNpZW50bHkgd2Fsa2luZyBiYWNrIHVwIGZyb20gZWFjaCBib3guCiAgICAgLy8g RklYTUU6IFRoaXMgY29kZSBuZWVkcyB0byB0YWtlIGludG8gYWNjb3VudCB2ZXJ0aWNhbCB3cml0 aW5nIG1vZGVzLgpAQCAtMTQzLDcgKzE3MCw3IEBAIHZvaWQgVGV4dEF1dG9zaXplcjo6cHJvY2Vz c0NvbnRhaW5lcihmbG9hdCBtdWx0aXBsaWVyLCBSZW5kZXJCbG9jayogY29udGFpbmVyLCBSCiB7 CiAgICAgQVNTRVJUKGlzQXV0b3NpemluZ0NvbnRhaW5lcihjb250YWluZXIpKTsKIAotICAgIGZs b2F0IGxvY2FsTXVsdGlwbGllciA9IGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnRhaW5l cikgPyAxIDogbXVsdGlwbGllcjsKKyAgICBmbG9hdCBsb2NhbE11bHRpcGxpZXIgPSBjb250YWlu ZXJTaG91bGRCZUF1dG9zaXplZChjb250YWluZXIpID8gbXVsdGlwbGllciA6IDE7CiAKICAgICBS ZW5kZXJPYmplY3QqIGRlc2NlbmRhbnQgPSBuZXh0SW5QcmVPcmRlclNraXBwaW5nRGVzY2VuZGFu dHNPZkNvbnRhaW5lcnMoc3VidHJlZVJvb3QsIHN1YnRyZWVSb290KTsKICAgICB3aGlsZSAoZGVz Y2VuZGFudCkgewpAQCAtMjExLDYgKzIzOCwxMSBAQCBib29sIFRleHRBdXRvc2l6ZXI6OmlzQXV0 b3NpemluZ0NvbnRhaW5lcihjb25zdCBSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogICAgICAgICBy ZXR1cm4gZmFsc2U7CiAgICAgaWYgKHJlbmRlcmVyLT5pc0xpc3RJdGVtKCkpCiAgICAgICAgIHJl dHVybiByZW5kZXJlci0+aXNGbG9hdGluZygpIHx8IHJlbmRlcmVyLT5pc091dE9mRmxvd1Bvc2l0 aW9uZWQoKTsKKyAgICAvLyBBdm9pZCBjcmVhdGluZyBjb250YWluZXJzIGZvciB0ZXh0IHdpdGhp biB0ZXh0IGNvbnRyb2xzLCBidXR0b25zLCBvciA8c2VsZWN0PiBkcm9wZG93bnMuCisgICAgTm9k ZSogcGFyZW50Tm9kZSA9IHJlbmRlcmVyLT5wYXJlbnQoKSA/IHJlbmRlcmVyLT5wYXJlbnQoKS0+ Z2VuZXJhdGluZ05vZGUoKSA6IDA7CisgICAgaWYgKHBhcmVudE5vZGUgJiYgcGFyZW50Tm9kZS0+ aXNFbGVtZW50Tm9kZSgpICYmIGZvcm1JbnB1dFRhZ3MoKS5jb250YWlucyh0b0VsZW1lbnQocGFy ZW50Tm9kZSktPnRhZ1FOYW1lKCkpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKICAgICByZXR1 cm4gdHJ1ZTsKIH0KIApAQCAtMjcxLDkgKzMwMywyNCBAQCBib29sIFRleHRBdXRvc2l6ZXI6OmNs dXN0ZXJTaG91bGRCZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayogbG93ZXN0Q29tbW9uQW5j ZQogICAgIHJldHVybiBmYWxzZTsKIH0KIAorYm9vbCBUZXh0QXV0b3NpemVyOjpjb250YWluZXJD b250YWluc1RhZ3MoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lciwgY29uc3QgVmVjdG9yPFF1 YWxpZmllZE5hbWU+JiB0YWdzKQoreworICAgIGNvbnN0IFJlbmRlck9iamVjdCogcmVuZGVyZXIg PSBjb250YWluZXI7CisgICAgd2hpbGUgKHJlbmRlcmVyKSB7CisgICAgICAgIGNvbnN0IE5vZGUq IHJlbmRlcmVyTm9kZSA9IHJlbmRlcmVyLT5ub2RlKCk7CisgICAgICAgIGlmIChyZW5kZXJlck5v ZGUgJiYgcmVuZGVyZXJOb2RlLT5pc0VsZW1lbnROb2RlKCkpIHsKKyAgICAgICAgICAgIGlmICh0 YWdzLmNvbnRhaW5zKHRvRWxlbWVudChyZW5kZXJlck5vZGUpLT50YWdRTmFtZSgpKSkKKyAgICAg ICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAgICAgfQorICAgICAgICByZW5kZXJlciA9IG5l eHRJblByZU9yZGVyU2tpcHBpbmdEZXNjZW5kYW50c09mQ29udGFpbmVycyhyZW5kZXJlciwgY29u dGFpbmVyKTsKKyAgICB9CisKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKIHZvaWQgVGV4dEF1dG9z aXplcjo6bWVhc3VyZURlc2NlbmRhbnRUZXh0V2lkdGgoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRh aW5lciwgZmxvYXQgbWluVGV4dFdpZHRoLCBmbG9hdCYgdGV4dFdpZHRoKQogewotICAgIGJvb2wg c2tpcExvY2FsVGV4dCA9IGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnRhaW5lcik7Cisg ICAgYm9vbCBza2lwTG9jYWxUZXh0ID0gIWNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVkKGNvbnRh aW5lcik7CiAKICAgICBSZW5kZXJPYmplY3QqIGRlc2NlbmRhbnQgPSBuZXh0SW5QcmVPcmRlclNr aXBwaW5nRGVzY2VuZGFudHNPZkNvbnRhaW5lcnMoY29udGFpbmVyLCBjb250YWluZXIpOwogICAg IHdoaWxlIChkZXNjZW5kYW50KSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvVGV4dEF1dG9zaXplci5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6 ZXIuaAppbmRleCBhNzA5YjExNjhlNDRkZjAwZWMxZjlkNzNiYmU1ZTUxNmZlOTI2Nzc0Li42NDkz MzQ4MTAzNjdkOGIxZDMyN2I4NDkwYjcwODdiMTY3ZDg4ZmQwIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9UZXh0QXV0b3NpemVyLmgKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2lmIEVOQUJMRShU RVhUX0FVVE9TSVpJTkcpCiAKKyNpbmNsdWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJJbnRT aXplLmgiCiAjaW5jbHVkZSA8d3RmL05vbmNvcHlhYmxlLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NP d25QdHIuaD4KQEAgLTcxLDYgKzcyLDkgQEAgcHJpdmF0ZToKICAgICBzdGF0aWMgYm9vbCBpc0F1 dG9zaXppbmdDbHVzdGVyKGNvbnN0IFJlbmRlckJsb2NrKik7CiAKICAgICBzdGF0aWMgYm9vbCBj bHVzdGVyU2hvdWxkQmVBdXRvc2l6ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGxvd2VzdENvbW1vbkFu Y2VzdG9yLCBmbG9hdCBjb21tb25BbmNlc3RvcldpZHRoKTsKKyAgICBzdGF0aWMgYm9vbCBjb250 YWluZXJTaG91bGRCZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyKTsKKyAg ICBzdGF0aWMgYm9vbCBjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJCbG9j ayogY29udGFpbmVyKTsKKyAgICBzdGF0aWMgYm9vbCBjb250YWluZXJDb250YWluc1RhZ3MoY29u c3QgUmVuZGVyQmxvY2sqIGNsdXN0ZXIsIGNvbnN0IFZlY3RvcjxRdWFsaWZpZWROYW1lPiYgdGFn cyk7CiAgICAgc3RhdGljIHZvaWQgbWVhc3VyZURlc2NlbmRhbnRUZXh0V2lkdGgoY29uc3QgUmVu ZGVyQmxvY2sqIGNvbnRhaW5lciwgZmxvYXQgbWluVGV4dFdpZHRoLCBmbG9hdCYgdGV4dFdpZHRo KTsKIAogICAgIC8vIFVzZSB0byB0cmF2ZXJzZSB0aGUgdHJlZSBvZiBkZXNjZW5kYW50cywgZXhj bHVkaW5nIGRlc2NlbmRhbnRzIG9mIGNvbnRhaW5lcnMgKGJ1dCByZXR1cm5pbmcgdGhlIGNvbnRh aW5lcnMgdGhlbXNlbHZlcykuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9M YXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggYTg5ZGQ0NWY0NTQwYjVjODM2Zjg0YzJmNGQwN2Rm NDU5NzE5ZWQxZi4uZThmNjU1YTZlZGYxOTg1ZGI5ZTQ1ZDVjOTQ4NzAyNWM5NDM5OTE2YyAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDIyIEBACisyMDEyLTEyLTEyICBUaW0gVm9sb2RpbmUgIDx0aW12b2xvZGlu ZUBnb29nbGUuY29tPgorCisgICAgICAgIFRleHQgQXV0b3NpemluZzogV29yayBvdXQgd2hhdCB0 byBkbyBhYm91dCBmb3JtIGNvbnRyb2xzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0xMDI1NjAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBUZXN0cyBmb3IgZm9ybSBpbnB1dCBlbGVtZW50cyBhdXRvc2l6aW5n LiBBZGRlZCB0ZXN0cyB0byBjaGVjayB0aGF0IHZhcmlvdXMga2luZHMgb2YgZm9ybSBlbGVtZW50 cworICAgICAgICBkb24ndCBnZXQgYXV0b3NpemVkLCBpLmUuIGJ1dHRvbnMsIHRleHRhcmVhcywg Y2hlY2sgYm94ZXMsIHJhZGlvIGJ1dHRvbiBhbmQgc2VsZWN0aW9uIG1lbnVzLgorCisgICAgICAg ICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1idXR0b24tdGV4 dGFyZWEtaW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1idXR0b24tdGV4dGFyZWEt aW5wdXQtZWxlbWVudHMuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXpp bmcvZm9ybS1jb250cm9scy1ib29zdGluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVjdGVk Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYm9vc3RpbmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC5odG1sOiBBZGRlZC4KKyAgICAgICAg KiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXJhZGlvLWlucHV0 LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9z aXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0bWw6IEFk ZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3Rp bmctc2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90 ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1zZWxlY3QtZWxlbWVudC5odG1s OiBBZGRlZC4KKwogMjAxMi0xMi0wNCAgQW50b2luZSBRdWludCAgPGdyYW91dHNAYXBwbGUuY29t PgogCiAgICAgICAgIFRleHRUcmFjaydzIC5raW5kIHByb3BlcnR5IHNob3VsZCByZXR1cm4gbG93 ZXItY2FzZSB2YWx1ZXMKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6 aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctYnV0dG9uLWlucHV0LWVsZW1lbnRzLWV4cGVjdGVk Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJv b3N0aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmE4 OTE1ZmU1ZTljNmQ2MzEwMzliOGE2MDk4YzM0Nzk3ODJhMDZhYjMKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5n LWJ1dHRvbi1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsNDQgQEAKKzwh RE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNv bnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsK KyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgor Cis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAg IFRoaXMgdGVzdHMgdGhlIGF1dG9zaXppbmcgb2YgYSBidXR0b24gaW5wdXQgZWxlbWVudC4gVGhp cyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUKKyAgICB0aGUgYnV0dG9ucyBi ZWxvdyBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4gTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQs IGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nCisgICAgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9y IGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKwor PGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KKyAgICA8ZGl2IHN0eWxlPSJmb250LXNpemU6IDIuNXJl bSI+CisgICAgICAgIFRoaXMgdGV4dCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZSB0aGUgaW5w dXQgY29udHJvbHMgYmVsb3cgc2hvdWxkIG5vdC4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAg ICAgICA8aW5wdXQgdHlwZT0ic3VibWl0IiB2YWx1ZT0iRmluZCI+CisgICAgPC9kaXY+CisgICAg PGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9ImJ1dHRvbiIgdmFsdWU9IkJ1dHRvbiI+CisgICAg PC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9InJlc2V0IiB2YWx1ZT0iUmVz ZXQiPgorICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIDxidXR0b24+SW5saW5lQnV0dG9u PC9idXR0b24+CisgICAgPC9kaXY+Cis8L2Zvcm0+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1s PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250 cm9scy1ib29zdGluZy1idXR0b24taW5wdXQtZWxlbWVudHMuaHRtbCBiL0xheW91dFRlc3RzL2Zh c3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctYnV0dG9uLWlucHV0LWVs ZW1lbnRzLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDFjNDY2NGIzYzZkMWMzZjlmOGQ1Y2VlMjkyZmIxOTFh MTA4OTZlMAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6 aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctYnV0dG9uLWlucHV0LWVsZW1lbnRzLmh0bWwKQEAg LTAsMCArMSw1MyBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBu YW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7Cisg ICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47 CisgIH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykgeworICAg IHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUp OworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dT aXplT3ZlcnJpZGUoMzIwLCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25z b2xlLndhcm4pIHsKKyAgICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBU ZXh0IEF1dG9zaXppbmcgc2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRl clRyZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNl IGEgbW9iaWxlIGRldmljZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9y IGlQaG9uZSksIG9yIGRlZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9Q LiIpOworfQorPC9zY3JpcHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAgIFRoaXMg dGVzdHMgdGhlIGF1dG9zaXppbmcgb2YgYSBidXR0b24gaW5wdXQgZWxlbWVudC4gVGhpcyBwYXJh Z3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUKKyAgICB0aGUgYnV0dG9ucyBiZWxvdyBz aG91bGQgbm90IGJlIGF1dG9zaXplZC4gTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNl Y3RldHVyIGFkaXBpc2ljaW5nCisgICAgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lk aWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKworPGRpdj4K Kzxmb3JtIGFjdGlvbj0iIj4KKyAgICA8ZGl2PgorICAgICAgICBUaGlzIHRleHQgc2hvdWxkIGJl IGF1dG9zaXplZCwgd2hpbGUgdGhlIGlucHV0IGNvbnRyb2xzIGJlbG93IHNob3VsZCBub3QuCisg ICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9InN1Ym1pdCIgdmFsdWU9 IkZpbmQiPgorICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIDxpbnB1dCB0eXBlPSJidXR0 b24iIHZhbHVlPSJCdXR0b24iPgorICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIDxpbnB1 dCB0eXBlPSJyZXNldCIgdmFsdWU9IlJlc2V0Ij4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAg ICAgICA8YnV0dG9uPklubGluZUJ1dHRvbjwvYnV0dG9uPgorICAgIDwvZGl2PgorPC9mb3JtPgor PC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv dGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctY2hlY2tib3gtaW5wdXQtZWxl bWVudC1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9y bS1jb250cm9scy1ib29zdGluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uMjBjMjE1NjBhZjViNDk0ZGRiZjU4ZGY1MDBiNTcyMjBlMDBmY2I5ZQotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29u dHJvbHMtYm9vc3RpbmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sCkBAIC0w LDAgKzEsMzMgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFt ZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAg IHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOwor ICB9Cis8L3N0eWxlPgorCisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2IHN0eWxlPSJmb250LXNp emU6IDIuNXJlbSI+CisgICAgVGhpcyB0ZXN0cyB0aGUgYXV0b3NpemluZyBvZiBjaGVjayBib3hl cy4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUKKyAgICB0aGUgY2hl Y2sgYm94ZXMgYmVsb3cgYW5kIHRoZSBzdXJyb3VuZGluZyB0ZXh0IHNob3VsZCBub3QgYmUgYXV0 b3NpemVkLgorICAgIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlw aXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IKKyAgICBpbmNpZGlkdW50IHV0IGxh Ym9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLgorPC9kaXY+Cis8ZGl2PgorPGZvcm0gYWN0aW9u PSIiPgorICAgIENoZWNrIG9uZSBvciBtb3JlOgorICAgIDxpbnB1dCB0eXBlPSJjaGVja2JveCIg bmFtZT0idmVoaWNsZSIgdmFsdWU9IkJpa2UiPkkgaGF2ZSBhIGJpa2U8YnIvPgorICAgIDxpbnB1 dCB0eXBlPSJjaGVja2JveCIgbmFtZT0idmVoaWNsZSIgdmFsdWU9IkNhciI+SSBoYXZlIGEgY2Fy IDxici8+Cis8L2Zvcm0+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1j aGVja2JveC1pbnB1dC1lbGVtZW50Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3Np emluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi42YTc3OWUwNTlkYTE3MWVkZDU1ZmU2MzRmODE1YWVmMGQ1NDEzOGY1Ci0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250 cm9scy1ib29zdGluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50Lmh0bWwKQEAgLTAsMCArMSw0MSBA QAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9y dCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgw MHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5 bGU+CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykgeworICAgIHdpbmRvdy5pbnRl cm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOworICAgIHdpbmRv dy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXplT3ZlcnJpZGUo MzIwLCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xlLndhcm4pIHsK KyAgICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0IEF1dG9zaXpp bmcgc2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRyZWUsIG9yIG1h bnVhbGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEgbW9iaWxlIGRl dmljZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQaG9uZSksIG9y IGRlZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIpOworfQorPC9z Y3JpcHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAgIFRoaXMgdGVzdHMgdGhlIGF1 dG9zaXppbmcgb2YgY2hlY2sgYm94ZXMuIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6 ZWQsIHdoaWxlCisgICAgdGhlIGNoZWNrIGJveGVzIGJlbG93IGFuZCB0aGUgc3Vycm91bmRpbmcg dGV4dCBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4KKyAgICBMb3JlbSBpcHN1bSBkb2xvciBzaXQg YW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9y CisgICAgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwvZGl2 PgorPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KKyAgICBDaGVjayBvbmUgb3IgbW9yZToKKyAgICA8 aW5wdXQgdHlwZT0iY2hlY2tib3giIG5hbWU9InZlaGljbGUiIHZhbHVlPSJCaWtlIj5JIGhhdmUg YSBiaWtlPGJyLz4KKyAgICA8aW5wdXQgdHlwZT0iY2hlY2tib3giIG5hbWU9InZlaGljbGUiIHZh bHVlPSJDYXIiPkkgaGF2ZSBhIGNhciA8YnIvPgorPC9mb3JtPgorPC9kaXY+CisKKzwvYm9keT4K KzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zv cm0tY29udHJvbHMtYm9vc3RpbmctcmFkaW8taW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sIGIv TGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1y YWRpby1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOWNhNzFjM2FkMzk4 ODlhOGJlMzIxNmQ4ZjYzNTdmZjQ5NGQ2MDBiOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRl c3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctcmFkaW8taW5w dXQtZWxlbWVudC1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsMzUgQEAKKzwhRE9DVFlQRSBodG1s PgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRo PTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46 IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCisKKzwvaGVhZD4K Kzxib2R5PgorCis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDIuNXJlbSI+CisgICAgVGhpcyB0ZXN0 cyB0aGUgYXV0b3NpemluZyBvZiByYWRpbyBidXR0b25zLiBUaGlzIHBhcmFncmFwaCBzaG91bGQg YmUgYXV0b3NpemVkLCB3aGlsZQorICAgIHRoZSByYWRpbyBidXR0b25zIGJlbG93IGFuZCB0aGUg c3Vycm91bmRpbmcgdGV4dCBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4KKyAgICBMb3JlbSBpcHN1 bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVp dXNtb2QgdGVtcG9yCisgICAgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFs aXF1YS4KKzwvZGl2PgorPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KKyAgICBTZWxlY3Qgb25lIG9m Ojxici8+CisgICAgPGlucHV0IHR5cGU9InJhZGlvIiBpZD0icmFkaW8xIiBjaGVja2VkPSJjaGVj a2VkIi8+CisgICAgPGxhYmVsIGZvcj0icmFkaW8xIj5SYWRpbzE8L2xhYmVsPjxici8+CisgICAg PGlucHV0IHR5cGU9InJhZGlvIiBpZD0icmFkaW8yIi8+CisgICAgPGxhYmVsIGZvcj0icmFkaW8y Ij5SYWRpbzI8L2xhYmVsPjxici8+Cis8L2Zvcm0+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1s PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250 cm9scy1ib29zdGluZy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0 L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXJhZGlvLWlucHV0LWVsZW1l bnQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi40ZDkyNTcwODM3NjQ2YWZjYzY1ZDk3YWM4YjIyMjVmZDk5NGVl YmU5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcv Zm9ybS1jb250cm9scy1ib29zdGluZy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0bWwKQEAgLTAsMCAr MSw0MyBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2 aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lk dGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0K Kzwvc3R5bGU+CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykgeworICAgIHdpbmRv dy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOworICAg IHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXplT3Zl cnJpZGUoMzIwLCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xlLndh cm4pIHsKKyAgICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0IEF1 dG9zaXppbmcgc2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRyZWUs IG9yIG1hbnVhbGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEgbW9i aWxlIGRldmljZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQaG9u ZSksIG9yIGRlZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIpOwor fQorPC9zY3JpcHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAgIFRoaXMgdGVzdHMg dGhlIGF1dG9zaXppbmcgb2YgcmFkaW8gYnV0dG9ucy4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJl IGF1dG9zaXplZCwgd2hpbGUKKyAgICB0aGUgcmFkaW8gYnV0dG9ucyBiZWxvdyBhbmQgdGhlIHN1 cnJvdW5kaW5nIHRleHQgc2hvdWxkIG5vdCBiZSBhdXRvc2l6ZWQuCisgICAgTG9yZW0gaXBzdW0g ZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVz bW9kIHRlbXBvcgorICAgIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlx dWEuCis8L2Rpdj4KKzxkaXY+Cis8Zm9ybSBhY3Rpb249IiI+CisgICAgU2VsZWN0IG9uZSBvZjo8 YnIvPgorICAgIDxpbnB1dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMSIgY2hlY2tlZD0iY2hlY2tl ZCIvPgorICAgIDxsYWJlbCBmb3I9InJhZGlvMSI+UmFkaW8xPC9sYWJlbD48YnIvPgorICAgIDxp bnB1dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMiIvPgorICAgIDxsYWJlbCBmb3I9InJhZGlvMiI+ UmFkaW8yPC9sYWJlbD48YnIvPgorPC9mb3JtPgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4K ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYm9vc3Rpbmctc2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zh c3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3Rpbmctc2VsZWN0LWVsZW1lbnQt ZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mMjFkOTdlYzY2NDM2NmU5MWM1MGY3OTdjZWQxODYy OGQ0NjA3OWVlCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9z aXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1zZWxlY3QtZWxlbWVudC1leHBlY3RlZC5odG1s CkBAIC0wLDAgKzEsMzQgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1l dGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkg eworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlk ZGVuOworICB9Cis8L3N0eWxlPgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9u dC1zaXplOiAyLjVyZW0iPgorICAgIFRoaXMgdGVzdHMgdGhlIGF1dG9zaXppbmcgb2YgYSBzZWxl Y3Rpb24gbWVudSBlbGVtZW50LiBUaGlzIHBhcmFncmFwaCBzaG91bGQgYmUgYXV0b3NpemVkLCB3 aGlsZQorICAgIHRoZSBzZWxlY3Rpb24gYm94IGJlbG93IHNob3VsZCBub3QgYmUgYXV0b3NpemVk LiBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcKKyAg ICBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9s b3JlIG1hZ25hIGFsaXF1YS4KKzwvZGl2PgorPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KKyAgICBT ZWxlY3Rpb246CisgICAgPHNlbGVjdD4KKyAgICAgICAgPG9wdGlvbiBzZWxlY3RlZCB2YWx1ZT1k ZWZhdWx0PkRlZmF1bHQ8L29wdGlvbj4KKyAgICAgICAgPG9wdGlvbj5PcHRpb24gMTwvb3B0aW9u PgorICAgICAgICA8b3B0aW9uPk9wdGlvbiAyPC9vcHRpb24+CisgICAgPC9zZWxlY3Q+Cis8L2Zv cm0+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMv ZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1ib29zdGluZy1zZWxlY3QtZWxlbWVu dC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1i b29zdGluZy1zZWxlY3QtZWxlbWVudC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjkxMWM4ZmMyZjNmNmVjYzRm ZjQ3NDE4MmYwMGVkOTE5NmUwMzE1ZjMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXNlbGVjdC1lbGVtZW50 Lmh0bWwKQEAgLTAsMCArMSw0MyBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgor Cis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAg Ym9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15 OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFs cykgeworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFi bGVkKHRydWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXpp bmdXaW5kb3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29s ZSAmJiBjb25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRz IG9uIHRoZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4g RHVtcFJlbmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBl aXRoZXIgdXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBO ZXh1cyBTIG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19P Tl9ERVNLVE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2Pgor ICAgIFRoaXMgdGVzdHMgdGhlIGF1dG9zaXppbmcgb2YgYSBzZWxlY3Rpb24gbWVudSBlbGVtZW50 LiBUaGlzIHBhcmFncmFwaCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZQorICAgIHRoZSBzZWxl Y3Rpb24gYm94IGJlbG93IHNob3VsZCBub3QgYmUgYXV0b3NpemVkLiBMb3JlbSBpcHN1bSBkb2xv ciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcKKyAgICBlbGl0LCBzZWQgZG8gZWl1 c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4K KzwvZGl2PgorPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KKyAgICBTZWxlY3Rpb246CisgICAgPHNl bGVjdD4KKyAgICAgICAgPG9wdGlvbiBzZWxlY3RlZCB2YWx1ZT1kZWZhdWx0PkRlZmF1bHQ8L29w dGlvbj4KKyAgICAgICAgPG9wdGlvbj5PcHRpb24gMTwvb3B0aW9uPgorICAgICAgICA8b3B0aW9u Pk9wdGlvbiAyPC9vcHRpb24+CisgICAgPC9zZWxlY3Q+Cis8L2Zvcm0+Cis8L2Rpdj4KKworPC9i b2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXpp bmcvZm9ybS1jb250cm9scy1ib29zdGluZy10ZXh0YXJlYS1pbnB1dC1lbGVtZW50cy1leHBlY3Rl ZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1i b29zdGluZy10ZXh0YXJlYS1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LmMzNDY5NWZhZjJmM2M0ODJmYzM0YTgxNjRiZmVlOGEzMWUwYjdjZDYKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0 aW5nLXRleHRhcmVhLWlucHV0LWVsZW1lbnRzLWV4cGVjdGVkLmh0bWwKQEAgLTAsMCArMSw0NyBA QAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9y dCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgw MHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5 bGU+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDIuNXJlbSI+ CisgICAgVGhpcyB0ZXN0cyB0aGUgYXV0b3NpemluZyBvZiB0aGUgdGV4dGFyZWEgaW5wdXQgZWxl bWVudHMuIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQsIHdoaWxlCisgICAgdGhl IGJ1dHRvbnMgYmVsb3cgc2hvdWxkIG5vdCBiZSBhdXRvc2l6ZWQuIExvcmVtIGlwc3VtIGRvbG9y IHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZworICAgIGVsaXQsIHNlZCBkbyBlaXVz bW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLgor PC9kaXY+CisKKzxkaXY+Cis8Zm9ybSBhY3Rpb249IiI+CisgICAgPGRpdiBzdHlsZT0iZm9udC1z aXplOiAyLjVyZW0iPgorICAgICAgICBUaGlzIHRleHQgc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hp bGUgdGhlIGlucHV0IGNvbnRyb2xzIGJlbG93IHNob3VsZCBub3QuCisgICAgPC9kaXY+CisgICAg PGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9InRleHQiPgorICAgIDwvZGl2PgorICAgIDxkaXY+ CisgICAgICAgIDxpbnB1dCB0eXBlPSJlbWFpbCI+CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAg ICAgICAgPGlucHV0IHR5cGU9Im51bWJlciI+CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAg ICAgPGlucHV0IHR5cGU9InBhc3N3b3JkIj4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAg ICA8aW5wdXQgdHlwZT0idXJsIj4KKyAgICA8L2Rpdj4KKzwvZm9ybT4KKzwvZGl2PgorCis8L2Jv ZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3Npemlu Zy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXRleHRhcmVhLWlucHV0LWVsZW1lbnRzLmh0bWwgYi9M YXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWJvb3N0aW5nLXRl eHRhcmVhLWlucHV0LWVsZW1lbnRzLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uODAwNTlmNDI1NGEzZTY2NjRk OWUyZjk2YjEwZjk1OWMxODk4MWQzNQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zh c3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYm9vc3RpbmctdGV4dGFyZWEtaW5wdXQt ZWxlbWVudHMuaHRtbApAQCAtMCwwICsxLDU2IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgor PGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0 eWxlPgorICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92 ZXJmbG93LXk6IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4KKworPHNjcmlwdD4KK2lmICh3aW5kb3cu aW50ZXJuYWxzKSB7CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3Np emluZ0VuYWJsZWQodHJ1ZSk7CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0 QXV0b3NpemluZ1dpbmRvd1NpemVPdmVycmlkZSgzMjAsIDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRv dy5jb25zb2xlICYmIGNvbnNvbGUud2FybikgeworICAgIGNvbnNvbGUud2FybigiVGhpcyB0ZXN0 IGRlcGVuZHMgb24gdGhlIFRleHQgQXV0b3NpemluZyBzZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1 biBpdCBpbiBEdW1wUmVuZGVyVHJlZSwgb3IgbWFudWFsbHkgZW5hYmxlIFRleHQgQXV0b3Npemlu ZywgYW5kIGVpdGhlciB1c2UgYSBtb2JpbGUgZGV2aWNlIHdpdGggMzIwcHggZGV2aWNlLXdpZHRo IChsaWtlIE5leHVzIFMgb3IgaVBob25lKSwgb3IgZGVmaW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRP U0laSU5HX09OX0RFU0tUT1AuIik7Cit9Cis8L3NjcmlwdD4KKworPC9oZWFkPgorPGJvZHk+CisK KzxkaXY+CisgICAgVGhpcyB0ZXN0cyB0aGUgYXV0b3NpemluZyBvZiB0aGUgdGV4dCBmaWVsZCBp bnB1dCBlbGVtZW50cy4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUK KyAgICB0aGUgYnV0dG9ucyBiZWxvdyBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4gTG9yZW0gaXBz dW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nCisgICAgZWxpdCwgc2Vk IGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBh bGlxdWEuCis8L2Rpdj4KKworPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KKyAgICA8ZGl2PgorICAg ICAgICBUaGlzIHRleHQgc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUgdGhlIGlucHV0IGNvbnRy b2xzIGJlbG93IHNob3VsZCBub3QuCisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlu cHV0IHR5cGU9InRleHQiPgorICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIDxpbnB1dCB0 eXBlPSJlbWFpbCI+CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9 Im51bWJlciI+CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9InBh c3N3b3JkIj4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICA8aW5wdXQgdHlwZT0idXJs Ij4KKyAgICA8L2Rpdj4KKzwvZm9ybT4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+Cg== 179503 2012-12-14 11:30:49 -0800 2012-12-17 14:38:34 -0800 Patch bug-102560-20121214192808.patch text/plain 24375 timvolodine U3VidmVyc2lvbiBSZXZpc2lvbjogMTM3NzM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjA1MDE5ZDIxMTM5NTVm MWRlODcxYWRjYTE2MjE2OTU1ZWY0NTg5My4uOWE1NGM2NjFiMjhiM2I4Mzc2MDYyYzJiZmRjZjIw NTUyZDI1MGJjMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMxIEBACisyMDEyLTEyLTE0ICBUaW0g Vm9sb2RpbmUgIDx0aW12b2xvZGluZUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgVGV4dCBBdXRv c2l6aW5nOiBXb3JrIG91dCB3aGF0IHRvIGRvIGFib3V0IGZvcm0gY29udHJvbHMKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwMjU2MAorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIERpc2FsbG93IGF1dG9zaXpp bmcgb2YgZm9ybSBpbnB1dCBjb250cm9scyBsaWtlIGJ1dHRvbnMsIHRleHQgaW5wdXQgZmllbGRz LCBzZWxlY3Rpb24gY29udHJvbHMsIHJhZGlvIGJ1dHRvbnMKKyAgICAgICAgYW5kIGNoZWNrIGJv eGVzLiBUaGlzIGlzIGEgc2hvcnQgdGVybSBzb2x1dGlvbiB0byBhdm9pZCBpbmNvbnNpc3RlbnQg YXV0b3NpemluZyBvZiBmb3JtIGNvbnRyb2xzICh3aGljaCBpcworICAgICAgICB3b3JzZSB0aGFu IG5vdCBhdXRvc2l6aW5nIGF0IGFsbCkuCisKKyAgICAgICAgVGVzdHM6IGZhc3QvdGV4dC1hdXRv c2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMuaHRt bAorICAgICAgICAgICAgICAgZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRv c2l6aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC90 ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVsZW1l bnQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvdGV4 dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxl bWVudHMuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwOgorICAg ICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpmb3JtSW5wdXRUYWdzKToKKyAgICAg ICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OnByb2Nlc3NDb250YWluZXIpOgorICAgICAgICAo V2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6aXNBdXRvc2l6aW5nQ29udGFpbmVyKToKKyAgICAgICAg KFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OmNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKToKKyAg ICAgICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OmNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVk KToKKyAgICAgICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OmNvbnRhaW5lckNvbnRhaW5zVGFn cyk6CisgICAgICAgIChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjptZWFzdXJlRGVzY2VuZGFudFRl eHRXaWR0aCk6CisgICAgICAgICogcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaDoKKwogMjAxMi0x Mi0xNCAgS2VudGFybyBIYXJhICA8aGFyYWtlbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgQ2hp bGROb2Rlc0xhenlTbmFwc2hvdDo6bmV4dE5vZGUoKSBjYW4gY3Jhc2ggaW4gRGVidWcgYnVpbGRz CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5jcHAKaW5kZXggOGI3Zjgy NDI3ZWM4YzQ4ZTQxODY0ZTkyZWVhMDQ1NmMxYzNjMTQzYi4uYjI0MjE3Yzc4ZmMwZGE1MDY2NTZj ODlhMGZhOGZjNmZmNWM2NjczZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1RleHRBdXRvc2l6ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0 b3NpemVyLmNwcApAQCAtMjUsNiArMjUsNyBAQAogI2luY2x1ZGUgIlRleHRBdXRvc2l6ZXIuaCIK IAogI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiSFRNTEVsZW1lbnQuaCIKICNpbmNs dWRlICJJbnNwZWN0b3JJbnN0cnVtZW50YXRpb24uaCIKICNpbmNsdWRlICJSZW5kZXJPYmplY3Qu aCIKICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgpAQCAtMzUsMTMgKzM2LDMxIEBACiAKICNpbmNs dWRlIDxhbGdvcml0aG0+CiAKKyNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CisKIG5hbWVz cGFjZSBXZWJDb3JlIHsKIAordXNpbmcgbmFtZXNwYWNlIEhUTUxOYW1lczsKKwogc3RydWN0IFRl eHRBdXRvc2l6aW5nV2luZG93SW5mbyB7CiAgICAgSW50U2l6ZSB3aW5kb3dTaXplOwogICAgIElu dFNpemUgbWluTGF5b3V0U2l6ZTsKIH07CiAKKworc3RhdGljIGNvbnN0IFZlY3RvcjxRdWFsaWZp ZWROYW1lPiYgZm9ybUlucHV0VGFncygpCit7CisgICAgLy8gUmV0dXJucyB0aGUgdGFncyBmb3Ig dGhlIGZvcm0gaW5wdXQgZWxlbWVudHMuCisgICAgREVGSU5FX1NUQVRJQ19MT0NBTChWZWN0b3I8 UXVhbGlmaWVkTmFtZT4sIGZvcm1JbnB1dFRhZ3MsICgpKTsKKyAgICBpZiAoZm9ybUlucHV0VGFn cy5pc0VtcHR5KCkpIHsKKyAgICAgICAgZm9ybUlucHV0VGFncy5hcHBlbmQoaW5wdXRUYWcpOwor ICAgICAgICBmb3JtSW5wdXRUYWdzLmFwcGVuZCh0ZXh0YXJlYVRhZyk7CisgICAgICAgIGZvcm1J bnB1dFRhZ3MuYXBwZW5kKGJ1dHRvblRhZyk7CisgICAgICAgIGZvcm1JbnB1dFRhZ3MuYXBwZW5k KHNlbGVjdFRhZyk7CisgICAgfQorICAgIHJldHVybiBmb3JtSW5wdXRUYWdzOworfQorCiBUZXh0 QXV0b3NpemVyOjpUZXh0QXV0b3NpemVyKERvY3VtZW50KiBkb2N1bWVudCkKICAgICA6IG1fZG9j dW1lbnQoZG9jdW1lbnQpCiB7CkBAIC0xMjMsNyArMTQyLDcgQEAgdm9pZCBUZXh0QXV0b3NpemVy Ojpwcm9jZXNzQ29udGFpbmVyKGZsb2F0IG11bHRpcGxpZXIsIFJlbmRlckJsb2NrKiBjb250YWlu ZXIsIFIKIHsKICAgICBBU1NFUlQoaXNBdXRvc2l6aW5nQ29udGFpbmVyKGNvbnRhaW5lcikpOwog Ci0gICAgZmxvYXQgbG9jYWxNdWx0aXBsaWVyID0gY29udGFpbmVyU2hvdWxkYmVBdXRvc2l6ZWQo Y29udGFpbmVyKSA/IG11bHRpcGxpZXI6IDE7CisgICAgZmxvYXQgbG9jYWxNdWx0aXBsaWVyID0g Y29udGFpbmVyU2hvdWxkQmVBdXRvc2l6ZWQoY29udGFpbmVyKSA/IG11bHRpcGxpZXIgOiAxOwog CiAgICAgUmVuZGVyT2JqZWN0KiBkZXNjZW5kYW50ID0gbmV4dEluUHJlT3JkZXJTa2lwcGluZ0Rl c2NlbmRhbnRzT2ZDb250YWluZXJzKHN1YnRyZWVSb290LCBzdWJ0cmVlUm9vdCk7CiAgICAgd2hp bGUgKGRlc2NlbmRhbnQpIHsKQEAgLTE5MSw2ICsyMTAsMTEgQEAgYm9vbCBUZXh0QXV0b3NpemVy Ojppc0F1dG9zaXppbmdDb250YWluZXIoY29uc3QgUmVuZGVyT2JqZWN0KiByZW5kZXJlcikKICAg ICAgICAgcmV0dXJuIGZhbHNlOwogICAgIGlmIChyZW5kZXJlci0+aXNMaXN0SXRlbSgpKQogICAg ICAgICByZXR1cm4gcmVuZGVyZXItPmlzRmxvYXRpbmcoKSB8fCByZW5kZXJlci0+aXNPdXRPZkZs b3dQb3NpdGlvbmVkKCk7CisgICAgLy8gQXZvaWQgY3JlYXRpbmcgY29udGFpbmVycyBmb3IgdGV4 dCB3aXRoaW4gdGV4dCBjb250cm9scywgYnV0dG9ucywgb3IgPHNlbGVjdD4gZHJvcGRvd25zLgor ICAgIE5vZGUqIHBhcmVudE5vZGUgPSByZW5kZXJlci0+cGFyZW50KCkgPyByZW5kZXJlci0+cGFy ZW50KCktPmdlbmVyYXRpbmdOb2RlKCkgOiAwOworICAgIGlmIChwYXJlbnROb2RlICYmIHBhcmVu dE5vZGUtPmlzRWxlbWVudE5vZGUoKSAmJiBmb3JtSW5wdXRUYWdzKCkuY29udGFpbnModG9FbGVt ZW50KHBhcmVudE5vZGUpLT50YWdRTmFtZSgpKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCiAg ICAgcmV0dXJuIHRydWU7CiB9CiAKQEAgLTIzMCw3ICsyNTQsNyBAQCBib29sIFRleHRBdXRvc2l6 ZXI6OmlzQXV0b3NpemluZ0NsdXN0ZXIoY29uc3QgUmVuZGVyQmxvY2sqIHJlbmRlcmVyKQogICAg IC8vIHJlbmRlcmVycywgYW5kIHByb2JhYmx5IGZsZXhib3hlcy4uLgogfQogCi1zdGF0aWMgYm9v bCBjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVy KQorYm9vbCBUZXh0QXV0b3NpemVyOjpjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBS ZW5kZXJCbG9jayogY29udGFpbmVyKQogewogICAgIC8vIEZJWE1FOiBQcm9wYWdhdGUgY29uc3Ry YWluZWRuZXNzIGRvd24gdGhlIHRyZWUsIHRvIGF2b2lkIGluZWZmaWNpZW50bHkgd2Fsa2luZyBi YWNrIHVwIGZyb20gZWFjaCBib3guCiAgICAgLy8gRklYTUU6IFRoaXMgY29kZSBuZWVkcyB0byB0 YWtlIGludG8gYWNjb3VudCB2ZXJ0aWNhbCB3cml0aW5nIG1vZGVzLgpAQCAtMjUwLDggKzI3NCwx MSBAQCBzdGF0aWMgYm9vbCBjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJC bG9jayogY29udGFpbmVyKQogICAgIHJldHVybiBmYWxzZTsKIH0KIAotYm9vbCBUZXh0QXV0b3Np emVyOjpjb250YWluZXJTaG91bGRiZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayogY29udGFp bmVyKQorYm9vbCBUZXh0QXV0b3NpemVyOjpjb250YWluZXJTaG91bGRCZUF1dG9zaXplZChjb25z dCBSZW5kZXJCbG9jayogY29udGFpbmVyKQogeworICAgIGlmIChjb250YWluZXJDb250YWluc1Rh Z3MoY29udGFpbmVyLCBmb3JtSW5wdXRUYWdzKCkpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisK ICAgICAvLyBEb24ndCBhdXRvc2l6ZSBibG9jay1sZXZlbCB0ZXh0IHRoYXQgY2FuJ3Qgd3JhcCAo YXMgaXQncyBsaWtlbHkgdG8KICAgICAvLyBleHBhbmQgc2lkZXdheXMgYW5kIGJyZWFrIHRoZSBw YWdlJ3MgbGF5b3V0KS4KICAgICBpZiAoIWNvbnRhaW5lci0+c3R5bGUoKS0+YXV0b1dyYXAoKSkK QEAgLTI4MSw5ICszMDgsMjQgQEAgYm9vbCBUZXh0QXV0b3NpemVyOjpjbHVzdGVyU2hvdWxkQmVB dXRvc2l6ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGxvd2VzdENvbW1vbkFuY2UKICAgICByZXR1cm4g ZmFsc2U7CiB9CiAKK2Jvb2wgVGV4dEF1dG9zaXplcjo6Y29udGFpbmVyQ29udGFpbnNUYWdzKGNv bnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIsIGNvbnN0IFZlY3RvcjxRdWFsaWZpZWROYW1lPiYg dGFncykKK3sKKyAgICBjb25zdCBSZW5kZXJPYmplY3QqIHJlbmRlcmVyID0gY29udGFpbmVyOwor ICAgIHdoaWxlIChyZW5kZXJlcikgeworICAgICAgICBjb25zdCBOb2RlKiByZW5kZXJlck5vZGUg PSByZW5kZXJlci0+bm9kZSgpOworICAgICAgICBpZiAocmVuZGVyZXJOb2RlICYmIHJlbmRlcmVy Tm9kZS0+aXNFbGVtZW50Tm9kZSgpKSB7CisgICAgICAgICAgICBpZiAodGFncy5jb250YWlucyh0 b0VsZW1lbnQocmVuZGVyZXJOb2RlKS0+dGFnUU5hbWUoKSkpCisgICAgICAgICAgICAgICAgcmV0 dXJuIHRydWU7CisgICAgICAgIH0KKyAgICAgICAgcmVuZGVyZXIgPSBuZXh0SW5QcmVPcmRlclNr aXBwaW5nRGVzY2VuZGFudHNPZkNvbnRhaW5lcnMocmVuZGVyZXIsIGNvbnRhaW5lcik7CisgICAg fQorCisgICAgcmV0dXJuIGZhbHNlOworfQorCiB2b2lkIFRleHRBdXRvc2l6ZXI6Om1lYXN1cmVE ZXNjZW5kYW50VGV4dFdpZHRoKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIsIGZsb2F0IG1p blRleHRXaWR0aCwgZmxvYXQmIHRleHRXaWR0aCkKIHsKLSAgICBib29sIHNraXBMb2NhbFRleHQg PSAhY29udGFpbmVyU2hvdWxkYmVBdXRvc2l6ZWQoY29udGFpbmVyKTsKKyAgICBib29sIHNraXBM b2NhbFRleHQgPSAhY29udGFpbmVyU2hvdWxkQmVBdXRvc2l6ZWQoY29udGFpbmVyKTsKIAogICAg IFJlbmRlck9iamVjdCogZGVzY2VuZGFudCA9IG5leHRJblByZU9yZGVyU2tpcHBpbmdEZXNjZW5k YW50c09mQ29udGFpbmVycyhjb250YWluZXIsIGNvbnRhaW5lcik7CiAgICAgd2hpbGUgKGRlc2Nl bmRhbnQpIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3Np emVyLmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oCmluZGV4IGRk M2UxOWRkZDNiZWE0ZDAwMjY4ZmEyYWIwMmE5YTU2OTA0YTMxN2UuLjY0OTMzNDgxMDM2N2Q4YjFk MzI3Yjg0OTBiNzA4N2IxNjdkODhmZDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9UZXh0QXV0b3NpemVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRB dXRvc2l6ZXIuaApAQCAtMjgsNiArMjgsNyBAQAogCiAjaWYgRU5BQkxFKFRFWFRfQVVUT1NJWklO RykKIAorI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkludFNpemUuaCIKICNpbmNs dWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvUGFzc093blB0ci5oPgpAQCAt NzAsOCArNzEsMTAgQEAgcHJpdmF0ZToKICAgICBzdGF0aWMgYm9vbCBpc0F1dG9zaXppbmdDb250 YWluZXIoY29uc3QgUmVuZGVyT2JqZWN0Kik7CiAgICAgc3RhdGljIGJvb2wgaXNBdXRvc2l6aW5n Q2x1c3Rlcihjb25zdCBSZW5kZXJCbG9jayopOwogCi0gICAgc3RhdGljIGJvb2wgY29udGFpbmVy U2hvdWxkYmVBdXRvc2l6ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lcik7CiAgICAgc3Rh dGljIGJvb2wgY2x1c3RlclNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBsb3dl c3RDb21tb25BbmNlc3RvciwgZmxvYXQgY29tbW9uQW5jZXN0b3JXaWR0aCk7CisgICAgc3RhdGlj IGJvb2wgY29udGFpbmVyU2hvdWxkQmVBdXRvc2l6ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRh aW5lcik7CisgICAgc3RhdGljIGJvb2wgY29udGVudEhlaWdodElzQ29uc3RyYWluZWQoY29uc3Qg UmVuZGVyQmxvY2sqIGNvbnRhaW5lcik7CisgICAgc3RhdGljIGJvb2wgY29udGFpbmVyQ29udGFp bnNUYWdzKGNvbnN0IFJlbmRlckJsb2NrKiBjbHVzdGVyLCBjb25zdCBWZWN0b3I8UXVhbGlmaWVk TmFtZT4mIHRhZ3MpOwogICAgIHN0YXRpYyB2b2lkIG1lYXN1cmVEZXNjZW5kYW50VGV4dFdpZHRo KGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIsIGZsb2F0IG1pblRleHRXaWR0aCwgZmxvYXQm IHRleHRXaWR0aCk7CiAKICAgICAvLyBVc2UgdG8gdHJhdmVyc2UgdGhlIHRyZWUgb2YgZGVzY2Vu ZGFudHMsIGV4Y2x1ZGluZyBkZXNjZW5kYW50cyBvZiBjb250YWluZXJzIChidXQgcmV0dXJuaW5n IHRoZSBjb250YWluZXJzIHRoZW1zZWx2ZXMpLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGM5YzQyZmU5MjExMzU5NzBkYjY2 NmRkMDAxZmZiOTdlNjVmZmNjNDkuLjI2YWRjM2U5Y2ExOTA1NTYxNzc2MmNkZmI3ODBmYjJkY2M5 YWEyNzcgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAxMi0xMi0xNCAgVGltIFZvbG9kaW5lICA8 dGltdm9sb2RpbmVAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFRleHQgQXV0b3NpemluZzogV29y ayBvdXQgd2hhdCB0byBkbyBhYm91dCBmb3JtIGNvbnRyb2xzCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDI1NjAKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0cyBmb3IgZm9ybSBpbnB1dCBlbGVtZW50 cyBhdXRvc2l6aW5nLiBBZGRlZCB0ZXN0cyB0byBjaGVjayB0aGF0IHZhcmlvdXMga2luZHMgb2Yg Zm9ybSBlbGVtZW50cworICAgICAgICBkb24ndCBnZXQgYXV0b3NpemVkLCBpLmUuIGJ1dHRvbnMs IHRleHRhcmVhcywgY2hlY2sgYm94ZXMsIHJhZGlvIGJ1dHRvbiBhbmQgc2VsZWN0aW9uIG1lbnVz LgorCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6 aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1sOiBBZGRlZC4KKyAgICAgICAg KiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctYnV0dG9uLWlu cHV0LWVsZW1lbnRzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5n L2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVjdGVk Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYXV0b3NpemluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50Lmh0bWw6IEFkZGVkLgorICAgICAg ICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1yYWRpby1p bnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1h dXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMt YXV0b3NpemluZy1zZWxlY3QtZWxlbWVudC1leHBlY3RlZC5odG1sOiBBZGRlZC4KKyAgICAgICAg KiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctc2VsZWN0LWVs ZW1lbnQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1j b250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1s OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1 dG9zaXppbmctdGV4dGZpZWxkLWlucHV0LWVsZW1lbnRzLmh0bWw6IEFkZGVkLgorCiAyMDEyLTEy LTE0ICBKb2huIE1lbGxvciAgPGpvaG5tZUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVGV4dCBB dXRvc2l6aW5nOiBEb24ndCBhdXRvc2l6ZSB1bndyYXBwYWJsZSBibG9ja3MKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3Npemlu Zy1idXR0b24taW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv dGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxl bWVudHMtZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hODkxNWZlNWU5YzZkNjMxMDM5YjhhNjA5 OGMzNDc5NzgyYTA2YWIzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0 LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50 cy1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsNDQgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+ Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8 c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAg b3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8L2hlYWQ+Cis8Ym9keT4KKwor PGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRoaXMgdGVzdHMgdGhlIGF1dG9z aXppbmcgb2YgYSBidXR0b24gaW5wdXQgZWxlbWVudC4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJl IGF1dG9zaXplZCwgd2hpbGUKKyAgICB0aGUgYnV0dG9ucyBiZWxvdyBzaG91bGQgbm90IGJlIGF1 dG9zaXplZC4gTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2lj aW5nCisgICAgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3Jl IGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKworPGRpdj4KKzxmb3JtIGFjdGlvbj0i Ij4KKyAgICA8ZGl2IHN0eWxlPSJmb250LXNpemU6IDIuNXJlbSI+CisgICAgICAgIFRoaXMgdGV4 dCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZSB0aGUgaW5wdXQgY29udHJvbHMgYmVsb3cgc2hv dWxkIG5vdC4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICA8aW5wdXQgdHlwZT0ic3Vi bWl0IiB2YWx1ZT0iRmluZCI+CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0 IHR5cGU9ImJ1dHRvbiIgdmFsdWU9IkJ1dHRvbiI+CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAg ICAgICAgPGlucHV0IHR5cGU9InJlc2V0IiB2YWx1ZT0iUmVzZXQiPgorICAgIDwvZGl2PgorICAg IDxkaXY+CisgICAgICAgIDxidXR0b24+SW5saW5lQnV0dG9uPC9idXR0b24+CisgICAgPC9kaXY+ Cis8L2Zvcm0+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWJ1dHRv bi1pbnB1dC1lbGVtZW50cy5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcv Zm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50cy5odG1sCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjQxYzQ2NjRiM2M2ZDFjM2Y5ZjhkNWNlZTI5MmZiMTkxYTEwODk2ZTAKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xz LWF1dG9zaXppbmctYnV0dG9uLWlucHV0LWVsZW1lbnRzLmh0bWwKQEAgLTAsMCArMSw1MyBAQAor PCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIg Y29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4 OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+ CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykgeworICAgIHdpbmRvdy5pbnRlcm5h bHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOworICAgIHdpbmRvdy5p bnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXplT3ZlcnJpZGUoMzIw LCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xlLndhcm4pIHsKKyAg ICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0IEF1dG9zaXppbmcg c2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRyZWUsIG9yIG1hbnVh bGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEgbW9iaWxlIGRldmlj ZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQaG9uZSksIG9yIGRl ZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIpOworfQorPC9zY3Jp cHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAgIFRoaXMgdGVzdHMgdGhlIGF1dG9z aXppbmcgb2YgYSBidXR0b24gaW5wdXQgZWxlbWVudC4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJl IGF1dG9zaXplZCwgd2hpbGUKKyAgICB0aGUgYnV0dG9ucyBiZWxvdyBzaG91bGQgbm90IGJlIGF1 dG9zaXplZC4gTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2lj aW5nCisgICAgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3Jl IGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKworPGRpdj4KKzxmb3JtIGFjdGlvbj0i Ij4KKyAgICA8ZGl2PgorICAgICAgICBUaGlzIHRleHQgc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hp bGUgdGhlIGlucHV0IGNvbnRyb2xzIGJlbG93IHNob3VsZCBub3QuCisgICAgPC9kaXY+CisgICAg PGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9InN1Ym1pdCIgdmFsdWU9IkZpbmQiPgorICAgIDwv ZGl2PgorICAgIDxkaXY+CisgICAgICAgIDxpbnB1dCB0eXBlPSJidXR0b24iIHZhbHVlPSJCdXR0 b24iPgorICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIDxpbnB1dCB0eXBlPSJyZXNldCIg dmFsdWU9IlJlc2V0Ij4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICA8YnV0dG9uPklu bGluZUJ1dHRvbjwvYnV0dG9uPgorICAgIDwvZGl2PgorPC9mb3JtPgorPC9kaXY+CisKKzwvYm9k eT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5n L2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVjdGVk Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1 dG9zaXppbmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LjIwYzIxNTYwYWY1YjQ5NGRkYmY1OGRmNTAwYjU3MjIwZTAwZmNiOWUKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9z aXppbmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsMzMg QEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3Bv cnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4 MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0 eWxlPgorCisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDIuNXJl bSI+CisgICAgVGhpcyB0ZXN0cyB0aGUgYXV0b3NpemluZyBvZiBjaGVjayBib3hlcy4gVGhpcyBw YXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUKKyAgICB0aGUgY2hlY2sgYm94ZXMg YmVsb3cgYW5kIHRoZSBzdXJyb3VuZGluZyB0ZXh0IHNob3VsZCBub3QgYmUgYXV0b3NpemVkLgor ICAgIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBl bGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IKKyAgICBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBk b2xvcmUgbWFnbmEgYWxpcXVhLgorPC9kaXY+Cis8ZGl2PgorPGZvcm0gYWN0aW9uPSIiPgorICAg IENoZWNrIG9uZSBvciBtb3JlOgorICAgIDxpbnB1dCB0eXBlPSJjaGVja2JveCIgbmFtZT0idmVo aWNsZSIgdmFsdWU9IkJpa2UiPkkgaGF2ZSBhIGJpa2U8YnIvPgorICAgIDxpbnB1dCB0eXBlPSJj aGVja2JveCIgbmFtZT0idmVoaWNsZSIgdmFsdWU9IkNhciI+SSBoYXZlIGEgY2FyIDxici8+Cis8 L2Zvcm0+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWNoZWNrYm94 LWlucHV0LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zv cm0tY29udHJvbHMtYXV0b3NpemluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50Lmh0bWwKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uNmE3NzllMDU5ZGExNzFlZGQ1NWZlNjM0ZjgxNWFlZjBkNTQxMzhmNQotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMt YXV0b3NpemluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50Lmh0bWwKQEAgLTAsMCArMSw0MSBAQAor PCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIg Y29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4 OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+ CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykgeworICAgIHdpbmRvdy5pbnRlcm5h bHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOworICAgIHdpbmRvdy5p bnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXplT3ZlcnJpZGUoMzIw LCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xlLndhcm4pIHsKKyAg ICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0IEF1dG9zaXppbmcg c2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRyZWUsIG9yIG1hbnVh bGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEgbW9iaWxlIGRldmlj ZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQaG9uZSksIG9yIGRl ZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIpOworfQorPC9zY3Jp cHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAgIFRoaXMgdGVzdHMgdGhlIGF1dG9z aXppbmcgb2YgY2hlY2sgYm94ZXMuIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQs IHdoaWxlCisgICAgdGhlIGNoZWNrIGJveGVzIGJlbG93IGFuZCB0aGUgc3Vycm91bmRpbmcgdGV4 dCBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4KKyAgICBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1l dCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yCisg ICAgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwvZGl2Pgor PGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KKyAgICBDaGVjayBvbmUgb3IgbW9yZToKKyAgICA8aW5w dXQgdHlwZT0iY2hlY2tib3giIG5hbWU9InZlaGljbGUiIHZhbHVlPSJCaWtlIj5JIGhhdmUgYSBi aWtlPGJyLz4KKyAgICA8aW5wdXQgdHlwZT0iY2hlY2tib3giIG5hbWU9InZlaGljbGUiIHZhbHVl PSJDYXIiPkkgaGF2ZSBhIGNhciA8YnIvPgorPC9mb3JtPgorPC9kaXY+CisKKzwvYm9keT4KKzwv aHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0t Y29udHJvbHMtYXV0b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwgYi9M YXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmct cmFkaW8taW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjljYTcxYzNhZDM5 ODg5YThiZTMyMTZkOGY2MzU3ZmY0OTRkNjAwYjgKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctcmFkaW8t aW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsMzUgQEAKKzwhRE9DVFlQRSBo dG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9Indp ZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJn aW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCisKKzwvaGVh ZD4KKzxib2R5PgorCis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDIuNXJlbSI+CisgICAgVGhpcyB0 ZXN0cyB0aGUgYXV0b3NpemluZyBvZiByYWRpbyBidXR0b25zLiBUaGlzIHBhcmFncmFwaCBzaG91 bGQgYmUgYXV0b3NpemVkLCB3aGlsZQorICAgIHRoZSByYWRpbyBidXR0b25zIGJlbG93IGFuZCB0 aGUgc3Vycm91bmRpbmcgdGV4dCBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4KKyAgICBMb3JlbSBp cHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRv IGVpdXNtb2QgdGVtcG9yCisgICAgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25h IGFsaXF1YS4KKzwvZGl2PgorPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KKyAgICBTZWxlY3Qgb25l IG9mOjxici8+CisgICAgPGlucHV0IHR5cGU9InJhZGlvIiBpZD0icmFkaW8xIiBjaGVja2VkPSJj aGVja2VkIi8+CisgICAgPGxhYmVsIGZvcj0icmFkaW8xIj5SYWRpbzE8L2xhYmVsPjxici8+Cisg ICAgPGlucHV0IHR5cGU9InJhZGlvIiBpZD0icmFkaW8yIi8+CisgICAgPGxhYmVsIGZvcj0icmFk aW8yIj5SYWRpbzI8L2xhYmVsPjxici8+Cis8L2Zvcm0+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9o dG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1j b250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3Rz L2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1yYWRpby1pbnB1 dC1lbGVtZW50Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNGQ5MjU3MDgzNzY0NmFmY2M2NWQ5N2FjOGIyMjI1 ZmQ5OTRlZWJlOQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRv c2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0bWwK QEAgLTAsMCArMSw0MyBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0 YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7 CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRk ZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykgewor ICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRy dWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5k b3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBj b25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRo ZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJl bmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIg dXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBT IG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNL VE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAgIFRo aXMgdGVzdHMgdGhlIGF1dG9zaXppbmcgb2YgcmFkaW8gYnV0dG9ucy4gVGhpcyBwYXJhZ3JhcGgg c2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUKKyAgICB0aGUgcmFkaW8gYnV0dG9ucyBiZWxvdyBh bmQgdGhlIHN1cnJvdW5kaW5nIHRleHQgc2hvdWxkIG5vdCBiZSBhdXRvc2l6ZWQuCisgICAgTG9y ZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNl ZCBkbyBlaXVzbW9kIHRlbXBvcgorICAgIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBt YWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+Cis8Zm9ybSBhY3Rpb249IiI+CisgICAgU2VsZWN0 IG9uZSBvZjo8YnIvPgorICAgIDxpbnB1dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMSIgY2hlY2tl ZD0iY2hlY2tlZCIvPgorICAgIDxsYWJlbCBmb3I9InJhZGlvMSI+UmFkaW8xPC9sYWJlbD48YnIv PgorICAgIDxpbnB1dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMiIvPgorICAgIDxsYWJlbCBmb3I9 InJhZGlvMiI+UmFkaW8yPC9sYWJlbD48YnIvPgorPC9mb3JtPgorPC9kaXY+CisKKzwvYm9keT4K KzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zv cm0tY29udHJvbHMtYXV0b3NpemluZy1zZWxlY3QtZWxlbWVudC1leHBlY3RlZC5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXNl bGVjdC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZjIxZDk3ZWM2NjQzNjZlOTFj NTBmNzk3Y2VkMTg2MjhkNDYwNzllZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zh c3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1zZWxlY3QtZWxlbWVu dC1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsMzQgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+ Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8 c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAg b3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8L2hlYWQ+Cis8Ym9keT4KKwor PGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRoaXMgdGVzdHMgdGhlIGF1dG9z aXppbmcgb2YgYSBzZWxlY3Rpb24gbWVudSBlbGVtZW50LiBUaGlzIHBhcmFncmFwaCBzaG91bGQg YmUgYXV0b3NpemVkLCB3aGlsZQorICAgIHRoZSBzZWxlY3Rpb24gYm94IGJlbG93IHNob3VsZCBu b3QgYmUgYXV0b3NpemVkLiBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIg YWRpcGlzaWNpbmcKKyAgICBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1 dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwvZGl2PgorPGRpdj4KKzxmb3JtIGFj dGlvbj0iIj4KKyAgICBTZWxlY3Rpb246CisgICAgPHNlbGVjdD4KKyAgICAgICAgPG9wdGlvbiBz ZWxlY3RlZCB2YWx1ZT1kZWZhdWx0PkRlZmF1bHQ8L29wdGlvbj4KKyAgICAgICAgPG9wdGlvbj5P cHRpb24gMTwvb3B0aW9uPgorICAgICAgICA8b3B0aW9uPk9wdGlvbiAyPC9vcHRpb24+CisgICAg PC9zZWxlY3Q+Cis8L2Zvcm0+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6 aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3Npemlu Zy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctc2VsZWN0LWVsZW1lbnQuaHRtbApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw Li45MTFjOGZjMmYzZjZlY2M0ZmY0NzQxODJmMDBlZDkxOTZlMDMxNWYzCi0tLSAvZGV2L251bGwK KysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRv c2l6aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWwKQEAgLTAsMCArMSw0MyBAQAorPCFET0NUWVBFIGh0 bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lk dGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdp bjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+ CitpZiAod2luZG93LmludGVybmFscykgeworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Mu c2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0 dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOworfSBl bHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xlLndh cm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBiZWlu ZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBU ZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMyMHB4 IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNLX0ZP UkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwvaGVh ZD4KKzxib2R5PgorCis8ZGl2PgorICAgIFRoaXMgdGVzdHMgdGhlIGF1dG9zaXppbmcgb2YgYSBz ZWxlY3Rpb24gbWVudSBlbGVtZW50LiBUaGlzIHBhcmFncmFwaCBzaG91bGQgYmUgYXV0b3NpemVk LCB3aGlsZQorICAgIHRoZSBzZWxlY3Rpb24gYm94IGJlbG93IHNob3VsZCBub3QgYmUgYXV0b3Np emVkLiBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcK KyAgICBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQg ZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwvZGl2PgorPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KKyAg ICBTZWxlY3Rpb246CisgICAgPHNlbGVjdD4KKyAgICAgICAgPG9wdGlvbiBzZWxlY3RlZCB2YWx1 ZT1kZWZhdWx0PkRlZmF1bHQ8L29wdGlvbj4KKyAgICAgICAgPG9wdGlvbj5PcHRpb24gMTwvb3B0 aW9uPgorICAgICAgICA8b3B0aW9uPk9wdGlvbiAyPC9vcHRpb24+CisgICAgPC9zZWxlY3Q+Cis8 L2Zvcm0+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVs ZC1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1 dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50 cy1leHBlY3RlZC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjYyMDAxNDlmYTA1MzZmZWQ3MTQxMGFhN2M1ZTAy MmYwNWI2ZjgwOWUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0 b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctdGV4dGZpZWxkLWlucHV0LWVsZW1lbnRz LWV4cGVjdGVkLmh0bWwKQEAgLTAsMCArMSw0NyBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4K KzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxz dHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBv dmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzwvaGVhZD4KKzxib2R5PgorCis8 ZGl2IHN0eWxlPSJmb250LXNpemU6IDIuNXJlbSI+CisgICAgVGhpcyB0ZXN0cyB0aGUgYXV0b3Np emluZyBvZiB0aGUgdGV4dCBmaWVsZCBpbnB1dCBlbGVtZW50cy4gVGhpcyBwYXJhZ3JhcGggc2hv dWxkIGJlIGF1dG9zaXplZCwgd2hpbGUKKyAgICB0aGUgYnV0dG9ucyBiZWxvdyBzaG91bGQgbm90 IGJlIGF1dG9zaXplZC4gTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFk aXBpc2ljaW5nCisgICAgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQg bGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKworPGRpdj4KKzxmb3JtIGFj dGlvbj0iIj4KKyAgICA8ZGl2IHN0eWxlPSJmb250LXNpemU6IDIuNXJlbSI+CisgICAgICAgIFRo aXMgdGV4dCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZSB0aGUgaW5wdXQgY29udHJvbHMgYmVs b3cgc2hvdWxkIG5vdC4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICA8aW5wdXQgdHlw ZT0idGV4dCI+CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9ImVt YWlsIj4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICA8aW5wdXQgdHlwZT0ibnVtYmVy Ij4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICA8aW5wdXQgdHlwZT0icGFzc3dvcmQi PgorICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIDxpbnB1dCB0eXBlPSJ1cmwiPgorICAg IDwvZGl2PgorPC9mb3JtPgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3Npemlu Zy10ZXh0ZmllbGQtaW5wdXQtZWxlbWVudHMuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1h dXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxlbWVu dHMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi44MDA1OWY0MjU0YTNlNjY2NGQ5ZTJmOTZiMTBmOTU5YzE4OTgx ZDM1Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcv Zm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50cy5odG1sCkBA IC0wLDAgKzEsNTYgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEg bmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgewor ICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVu OworICB9Cis8L3N0eWxlPgorCis8c2NyaXB0PgoraWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAg ICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVl KTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93 U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30gZWxzZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29u c29sZS53YXJuKSB7CisgICAgY29uc29sZS53YXJuKCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUg VGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVpbmcgdHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5k ZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUgVGV4dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVz ZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBweCBkZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBv ciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19GT1JDRV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RP UC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdj4KKyAgICBUaGlz IHRlc3RzIHRoZSBhdXRvc2l6aW5nIG9mIHRoZSB0ZXh0IGZpZWxkIGlucHV0IGVsZW1lbnRzLiBU aGlzIHBhcmFncmFwaCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZQorICAgIHRoZSBidXR0b25z IGJlbG93IHNob3VsZCBub3QgYmUgYXV0b3NpemVkLiBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1l dCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcKKyAgICBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1w b3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwvZGl2Pgor Cis8ZGl2PgorPGZvcm0gYWN0aW9uPSIiPgorICAgIDxkaXY+CisgICAgICAgIFRoaXMgdGV4dCBz aG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZSB0aGUgaW5wdXQgY29udHJvbHMgYmVsb3cgc2hvdWxk IG5vdC4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICA8aW5wdXQgdHlwZT0idGV4dCI+ CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9ImVtYWlsIj4KKyAg ICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICA8aW5wdXQgdHlwZT0ibnVtYmVyIj4KKyAgICA8 L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICA8aW5wdXQgdHlwZT0icGFzc3dvcmQiPgorICAgIDwv ZGl2PgorICAgIDxkaXY+CisgICAgICAgIDxpbnB1dCB0eXBlPSJ1cmwiPgorICAgIDwvZGl2Pgor PC9mb3JtPgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4K 179774 2012-12-17 11:42:43 -0800 2012-12-17 14:40:57 -0800 Patch bug-102560-20121217194000.patch text/plain 24421 timvolodine U3VidmVyc2lvbiBSZXZpc2lvbjogMTM3NzM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjA1MDE5ZDIxMTM5NTVm MWRlODcxYWRjYTE2MjE2OTU1ZWY0NTg5My4uOWE1NGM2NjFiMjhiM2I4Mzc2MDYyYzJiZmRjZjIw NTUyZDI1MGJjMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMxIEBACisyMDEyLTEyLTE0ICBUaW0g Vm9sb2RpbmUgIDx0aW12b2xvZGluZUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgVGV4dCBBdXRv c2l6aW5nOiBXb3JrIG91dCB3aGF0IHRvIGRvIGFib3V0IGZvcm0gY29udHJvbHMKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwMjU2MAorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIERpc2FsbG93IGF1dG9zaXpp bmcgb2YgZm9ybSBpbnB1dCBjb250cm9scyBsaWtlIGJ1dHRvbnMsIHRleHQgaW5wdXQgZmllbGRz LCBzZWxlY3Rpb24gY29udHJvbHMsIHJhZGlvIGJ1dHRvbnMKKyAgICAgICAgYW5kIGNoZWNrIGJv eGVzLiBUaGlzIGlzIGEgc2hvcnQgdGVybSBzb2x1dGlvbiB0byBhdm9pZCBpbmNvbnNpc3RlbnQg YXV0b3NpemluZyBvZiBmb3JtIGNvbnRyb2xzICh3aGljaCBpcworICAgICAgICB3b3JzZSB0aGFu IG5vdCBhdXRvc2l6aW5nIGF0IGFsbCkuCisKKyAgICAgICAgVGVzdHM6IGZhc3QvdGV4dC1hdXRv c2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMuaHRt bAorICAgICAgICAgICAgICAgZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRv c2l6aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC90 ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVsZW1l bnQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvdGV4 dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxl bWVudHMuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwOgorICAg ICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpmb3JtSW5wdXRUYWdzKToKKyAgICAg ICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OnByb2Nlc3NDb250YWluZXIpOgorICAgICAgICAo V2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6aXNBdXRvc2l6aW5nQ29udGFpbmVyKToKKyAgICAgICAg KFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OmNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKToKKyAg ICAgICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OmNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVk KToKKyAgICAgICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OmNvbnRhaW5lckNvbnRhaW5zVGFn cyk6CisgICAgICAgIChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjptZWFzdXJlRGVzY2VuZGFudFRl eHRXaWR0aCk6CisgICAgICAgICogcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaDoKKwogMjAxMi0x Mi0xNCAgS2VudGFybyBIYXJhICA8aGFyYWtlbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgQ2hp bGROb2Rlc0xhenlTbmFwc2hvdDo6bmV4dE5vZGUoKSBjYW4gY3Jhc2ggaW4gRGVidWcgYnVpbGRz CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5jcHAKaW5kZXggOGI3Zjgy NDI3ZWM4YzQ4ZTQxODY0ZTkyZWVhMDQ1NmMxYzNjMTQzYi4uNWVlNDA3ZTEzOTFlMDZmNWNkMmQ5 OWY4YWJjODRjYzc3NmQ3YmU0MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1RleHRBdXRvc2l6ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0 b3NpemVyLmNwcApAQCAtMjUsNiArMjUsNyBAQAogI2luY2x1ZGUgIlRleHRBdXRvc2l6ZXIuaCIK IAogI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiSFRNTEVsZW1lbnQuaCIKICNpbmNs dWRlICJJbnNwZWN0b3JJbnN0cnVtZW50YXRpb24uaCIKICNpbmNsdWRlICJSZW5kZXJPYmplY3Qu aCIKICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgpAQCAtMzQsMTQgKzM1LDMxIEBACiAjaW5jbHVk ZSAiU3R5bGVJbmhlcml0ZWREYXRhLmgiCiAKICNpbmNsdWRlIDxhbGdvcml0aG0+CisjaW5jbHVk ZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK3VzaW5nIG5h bWVzcGFjZSBIVE1MTmFtZXM7CisKIHN0cnVjdCBUZXh0QXV0b3NpemluZ1dpbmRvd0luZm8gewog ICAgIEludFNpemUgd2luZG93U2l6ZTsKICAgICBJbnRTaXplIG1pbkxheW91dFNpemU7CiB9Owog CisKK3N0YXRpYyBjb25zdCBWZWN0b3I8UXVhbGlmaWVkTmFtZT4mIGZvcm1JbnB1dFRhZ3MoKQor eworICAgIC8vIFJldHVybnMgdGhlIHRhZ3MgZm9yIHRoZSBmb3JtIGlucHV0IGVsZW1lbnRzLgor ICAgIERFRklORV9TVEFUSUNfTE9DQUwoVmVjdG9yPFF1YWxpZmllZE5hbWU+LCBmb3JtSW5wdXRU YWdzLCAoKSk7CisgICAgaWYgKGZvcm1JbnB1dFRhZ3MuaXNFbXB0eSgpKSB7CisgICAgICAgIGZv cm1JbnB1dFRhZ3MuYXBwZW5kKGlucHV0VGFnKTsKKyAgICAgICAgZm9ybUlucHV0VGFncy5hcHBl bmQodGV4dGFyZWFUYWcpOworICAgICAgICBmb3JtSW5wdXRUYWdzLmFwcGVuZChidXR0b25UYWcp OworICAgICAgICBmb3JtSW5wdXRUYWdzLmFwcGVuZChzZWxlY3RUYWcpOworICAgIH0KKyAgICBy ZXR1cm4gZm9ybUlucHV0VGFnczsKK30KKwogVGV4dEF1dG9zaXplcjo6VGV4dEF1dG9zaXplcihE b2N1bWVudCogZG9jdW1lbnQpCiAgICAgOiBtX2RvY3VtZW50KGRvY3VtZW50KQogewpAQCAtMTIz LDcgKzE0MSw3IEBAIHZvaWQgVGV4dEF1dG9zaXplcjo6cHJvY2Vzc0NvbnRhaW5lcihmbG9hdCBt dWx0aXBsaWVyLCBSZW5kZXJCbG9jayogY29udGFpbmVyLCBSCiB7CiAgICAgQVNTRVJUKGlzQXV0 b3NpemluZ0NvbnRhaW5lcihjb250YWluZXIpKTsKIAotICAgIGZsb2F0IGxvY2FsTXVsdGlwbGll ciA9IGNvbnRhaW5lclNob3VsZGJlQXV0b3NpemVkKGNvbnRhaW5lcikgPyBtdWx0aXBsaWVyOiAx OworICAgIGZsb2F0IGxvY2FsTXVsdGlwbGllciA9IGNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVk KGNvbnRhaW5lcikgPyBtdWx0aXBsaWVyIDogMTsKIAogICAgIFJlbmRlck9iamVjdCogZGVzY2Vu ZGFudCA9IG5leHRJblByZU9yZGVyU2tpcHBpbmdEZXNjZW5kYW50c09mQ29udGFpbmVycyhzdWJ0 cmVlUm9vdCwgc3VidHJlZVJvb3QpOwogICAgIHdoaWxlIChkZXNjZW5kYW50KSB7CkBAIC0xOTEs NiArMjA5LDExIEBAIGJvb2wgVGV4dEF1dG9zaXplcjo6aXNBdXRvc2l6aW5nQ29udGFpbmVyKGNv bnN0IFJlbmRlck9iamVjdCogcmVuZGVyZXIpCiAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICBp ZiAocmVuZGVyZXItPmlzTGlzdEl0ZW0oKSkKICAgICAgICAgcmV0dXJuIHJlbmRlcmVyLT5pc0Zs b2F0aW5nKCkgfHwgcmVuZGVyZXItPmlzT3V0T2ZGbG93UG9zaXRpb25lZCgpOworICAgIC8vIEF2 b2lkIGNyZWF0aW5nIGNvbnRhaW5lcnMgZm9yIHRleHQgd2l0aGluIHRleHQgY29udHJvbHMsIGJ1 dHRvbnMsIG9yIDxzZWxlY3Q+IGRyb3Bkb3ducy4KKyAgICBOb2RlKiBwYXJlbnROb2RlID0gcmVu ZGVyZXItPnBhcmVudCgpID8gcmVuZGVyZXItPnBhcmVudCgpLT5nZW5lcmF0aW5nTm9kZSgpIDog MDsKKyAgICBpZiAocGFyZW50Tm9kZSAmJiBwYXJlbnROb2RlLT5pc0VsZW1lbnROb2RlKCkgJiYg Zm9ybUlucHV0VGFncygpLmNvbnRhaW5zKHRvRWxlbWVudChwYXJlbnROb2RlKS0+dGFnUU5hbWUo KSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKwogICAgIHJldHVybiB0cnVlOwogfQogCkBAIC0y MzAsNyArMjUzLDcgQEAgYm9vbCBUZXh0QXV0b3NpemVyOjppc0F1dG9zaXppbmdDbHVzdGVyKGNv bnN0IFJlbmRlckJsb2NrKiByZW5kZXJlcikKICAgICAvLyByZW5kZXJlcnMsIGFuZCBwcm9iYWJs eSBmbGV4Ym94ZXMuLi4KIH0KIAotc3RhdGljIGJvb2wgY29udGVudEhlaWdodElzQ29uc3RyYWlu ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lcikKK2Jvb2wgVGV4dEF1dG9zaXplcjo6Y29u dGVudEhlaWdodElzQ29uc3RyYWluZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lcikKIHsK ICAgICAvLyBGSVhNRTogUHJvcGFnYXRlIGNvbnN0cmFpbmVkbmVzcyBkb3duIHRoZSB0cmVlLCB0 byBhdm9pZCBpbmVmZmljaWVudGx5IHdhbGtpbmcgYmFjayB1cCBmcm9tIGVhY2ggYm94LgogICAg IC8vIEZJWE1FOiBUaGlzIGNvZGUgbmVlZHMgdG8gdGFrZSBpbnRvIGFjY291bnQgdmVydGljYWwg d3JpdGluZyBtb2Rlcy4KQEAgLTI1MCw4ICsyNzMsMTEgQEAgc3RhdGljIGJvb2wgY29udGVudEhl aWdodElzQ29uc3RyYWluZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lcikKICAgICByZXR1 cm4gZmFsc2U7CiB9CiAKLWJvb2wgVGV4dEF1dG9zaXplcjo6Y29udGFpbmVyU2hvdWxkYmVBdXRv c2l6ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lcikKK2Jvb2wgVGV4dEF1dG9zaXplcjo6 Y29udGFpbmVyU2hvdWxkQmVBdXRvc2l6ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lcikK IHsKKyAgICBpZiAoY29udGFpbmVyQ29udGFpbnNPbmVPZlRhZ3MoY29udGFpbmVyLCBmb3JtSW5w dXRUYWdzKCkpKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKICAgICAvLyBEb24ndCBhdXRvc2l6 ZSBibG9jay1sZXZlbCB0ZXh0IHRoYXQgY2FuJ3Qgd3JhcCAoYXMgaXQncyBsaWtlbHkgdG8KICAg ICAvLyBleHBhbmQgc2lkZXdheXMgYW5kIGJyZWFrIHRoZSBwYWdlJ3MgbGF5b3V0KS4KICAgICBp ZiAoIWNvbnRhaW5lci0+c3R5bGUoKS0+YXV0b1dyYXAoKSkKQEAgLTI4MSw5ICszMDcsMjQgQEAg Ym9vbCBUZXh0QXV0b3NpemVyOjpjbHVzdGVyU2hvdWxkQmVBdXRvc2l6ZWQoY29uc3QgUmVuZGVy QmxvY2sqIGxvd2VzdENvbW1vbkFuY2UKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKK2Jvb2wgVGV4 dEF1dG9zaXplcjo6Y29udGFpbmVyQ29udGFpbnNPbmVPZlRhZ3MoY29uc3QgUmVuZGVyQmxvY2sq IGNvbnRhaW5lciwgY29uc3QgVmVjdG9yPFF1YWxpZmllZE5hbWU+JiB0YWdzKQoreworICAgIGNv bnN0IFJlbmRlck9iamVjdCogcmVuZGVyZXIgPSBjb250YWluZXI7CisgICAgd2hpbGUgKHJlbmRl cmVyKSB7CisgICAgICAgIGNvbnN0IE5vZGUqIHJlbmRlcmVyTm9kZSA9IHJlbmRlcmVyLT5ub2Rl KCk7CisgICAgICAgIGlmIChyZW5kZXJlck5vZGUgJiYgcmVuZGVyZXJOb2RlLT5pc0VsZW1lbnRO b2RlKCkpIHsKKyAgICAgICAgICAgIGlmICh0YWdzLmNvbnRhaW5zKHRvRWxlbWVudChyZW5kZXJl ck5vZGUpLT50YWdRTmFtZSgpKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKKyAgICAg ICAgfQorICAgICAgICByZW5kZXJlciA9IG5leHRJblByZU9yZGVyU2tpcHBpbmdEZXNjZW5kYW50 c09mQ29udGFpbmVycyhyZW5kZXJlciwgY29udGFpbmVyKTsKKyAgICB9CisKKyAgICByZXR1cm4g ZmFsc2U7Cit9CisKIHZvaWQgVGV4dEF1dG9zaXplcjo6bWVhc3VyZURlc2NlbmRhbnRUZXh0V2lk dGgoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lciwgZmxvYXQgbWluVGV4dFdpZHRoLCBmbG9h dCYgdGV4dFdpZHRoKQogewotICAgIGJvb2wgc2tpcExvY2FsVGV4dCA9ICFjb250YWluZXJTaG91 bGRiZUF1dG9zaXplZChjb250YWluZXIpOworICAgIGJvb2wgc2tpcExvY2FsVGV4dCA9ICFjb250 YWluZXJTaG91bGRCZUF1dG9zaXplZChjb250YWluZXIpOwogCiAgICAgUmVuZGVyT2JqZWN0KiBk ZXNjZW5kYW50ID0gbmV4dEluUHJlT3JkZXJTa2lwcGluZ0Rlc2NlbmRhbnRzT2ZDb250YWluZXJz KGNvbnRhaW5lciwgY29udGFpbmVyKTsKICAgICB3aGlsZSAoZGVzY2VuZGFudCkgewpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaCBiL1NvdXJjZS9X ZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmgKaW5kZXggZGQzZTE5ZGRkM2JlYTRkMDAy NjhmYTJhYjAyYTlhNTY5MDRhMzE3ZS4uYTc5ZWY3NDM5MDNmNWRmYzc2OWJiMjlhMWRiMzFhNWE3 NjFjNmU1MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6 ZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oCkBAIC0y OCw2ICsyOCw3IEBACiAKICNpZiBFTkFCTEUoVEVYVF9BVVRPU0laSU5HKQogCisjaW5jbHVkZSAi SFRNTE5hbWVzLmgiCiAjaW5jbHVkZSAiSW50U2l6ZS5oIgogI2luY2x1ZGUgPHd0Zi9Ob25jb3B5 YWJsZS5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzT3duUHRyLmg+CkBAIC03MCw4ICs3MSwxMCBAQCBw cml2YXRlOgogICAgIHN0YXRpYyBib29sIGlzQXV0b3NpemluZ0NvbnRhaW5lcihjb25zdCBSZW5k ZXJPYmplY3QqKTsKICAgICBzdGF0aWMgYm9vbCBpc0F1dG9zaXppbmdDbHVzdGVyKGNvbnN0IFJl bmRlckJsb2NrKik7CiAKLSAgICBzdGF0aWMgYm9vbCBjb250YWluZXJTaG91bGRiZUF1dG9zaXpl ZChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyKTsKICAgICBzdGF0aWMgYm9vbCBjbHVzdGVy U2hvdWxkQmVBdXRvc2l6ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGxvd2VzdENvbW1vbkFuY2VzdG9y LCBmbG9hdCBjb21tb25BbmNlc3RvcldpZHRoKTsKKyAgICBzdGF0aWMgYm9vbCBjb250YWluZXJT aG91bGRCZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyKTsKKyAgICBzdGF0 aWMgYm9vbCBjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJCbG9jayogY29u dGFpbmVyKTsKKyAgICBzdGF0aWMgYm9vbCBjb250YWluZXJDb250YWluc09uZU9mVGFncyhjb25z dCBSZW5kZXJCbG9jayogY2x1c3RlciwgY29uc3QgVmVjdG9yPFF1YWxpZmllZE5hbWU+JiB0YWdz KTsKICAgICBzdGF0aWMgdm9pZCBtZWFzdXJlRGVzY2VuZGFudFRleHRXaWR0aChjb25zdCBSZW5k ZXJCbG9jayogY29udGFpbmVyLCBmbG9hdCBtaW5UZXh0V2lkdGgsIGZsb2F0JiB0ZXh0V2lkdGgp OwogCiAgICAgLy8gVXNlIHRvIHRyYXZlcnNlIHRoZSB0cmVlIG9mIGRlc2NlbmRhbnRzLCBleGNs dWRpbmcgZGVzY2VuZGFudHMgb2YgY29udGFpbmVycyAoYnV0IHJldHVybmluZyB0aGUgY29udGFp bmVycyB0aGVtc2VsdmVzKS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xh eW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBjOWM0MmZlOTIxMTM1OTcwZGI2NjZkZDAwMWZmYjk3 ZTY1ZmZjYzQ5Li4yNmFkYzNlOWNhMTkwNTU2MTc3NjJjZGZiNzgwZmIyZGNjOWFhMjc3IDEwMDY0 NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9n CkBAIC0xLDMgKzEsMjQgQEAKKzIwMTItMTItMTQgIFRpbSBWb2xvZGluZSAgPHRpbXZvbG9kaW5l QGNocm9taXVtLm9yZz4KKworICAgICAgICBUZXh0IEF1dG9zaXppbmc6IFdvcmsgb3V0IHdoYXQg dG8gZG8gYWJvdXQgZm9ybSBjb250cm9scworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTAyNTYwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgVGVzdHMgZm9yIGZvcm0gaW5wdXQgZWxlbWVudHMgYXV0b3Npemlu Zy4gQWRkZWQgdGVzdHMgdG8gY2hlY2sgdGhhdCB2YXJpb3VzIGtpbmRzIG9mIGZvcm0gZWxlbWVu dHMKKyAgICAgICAgZG9uJ3QgZ2V0IGF1dG9zaXplZCwgaS5lLiBidXR0b25zLCB0ZXh0YXJlYXMs IGNoZWNrIGJveGVzLCByYWRpbyBidXR0b24gYW5kIHNlbGVjdGlvbiBtZW51cy4KKworICAgICAg ICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24t aW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0 LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50 cy5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRy b2xzLWF1dG9zaXppbmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sOiBBZGRl ZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXpp bmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3Rl eHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctcmFkaW8taW5wdXQtZWxlbWVu dC1leHBlY3RlZC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9m b3JtLWNvbnRyb2xzLWF1dG9zaXppbmctcmFkaW8taW5wdXQtZWxlbWVudC5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmct c2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0 LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWw6 IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0 b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisg ICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXRl eHRmaWVsZC1pbnB1dC1lbGVtZW50cy5odG1sOiBBZGRlZC4KKwogMjAxMi0xMi0xNCAgSm9obiBN ZWxsb3IgIDxqb2hubWVAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFRleHQgQXV0b3NpemluZzog RG9uJ3QgYXV0b3NpemUgdW53cmFwcGFibGUgYmxvY2tzCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctYnV0dG9uLWlu cHV0LWVsZW1lbnRzLWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3Np emluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctYnV0dG9uLWlucHV0LWVsZW1lbnRzLWV4cGVj dGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMC4uYTg5MTVmZTVlOWM2ZDYzMTAzOWI4YTYwOThjMzQ3OTc4MmEw NmFiMwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5n L2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQu aHRtbApAQCAtMCwwICsxLDQ0IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisK KzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBi b2R5IHsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6 IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXYgc3R5bGU9 ImZvbnQtc2l6ZTogMi41cmVtIj4KKyAgICBUaGlzIHRlc3RzIHRoZSBhdXRvc2l6aW5nIG9mIGEg YnV0dG9uIGlucHV0IGVsZW1lbnQuIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQs IHdoaWxlCisgICAgdGhlIGJ1dHRvbnMgYmVsb3cgc2hvdWxkIG5vdCBiZSBhdXRvc2l6ZWQuIExv cmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZworICAgIGVs aXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUg bWFnbmEgYWxpcXVhLgorPC9kaXY+CisKKzxkaXY+Cis8Zm9ybSBhY3Rpb249IiI+CisgICAgPGRp diBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgICAgICBUaGlzIHRleHQgc2hvdWxkIGJl IGF1dG9zaXplZCwgd2hpbGUgdGhlIGlucHV0IGNvbnRyb2xzIGJlbG93IHNob3VsZCBub3QuCisg ICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9InN1Ym1pdCIgdmFsdWU9 IkZpbmQiPgorICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIDxpbnB1dCB0eXBlPSJidXR0 b24iIHZhbHVlPSJCdXR0b24iPgorICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIDxpbnB1 dCB0eXBlPSJyZXNldCIgdmFsdWU9IlJlc2V0Ij4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAg ICAgICA8YnV0dG9uPklubGluZUJ1dHRvbjwvYnV0dG9uPgorICAgIDwvZGl2PgorPC9mb3JtPgor PC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv dGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxl bWVudHMuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40MWM0 NjY0YjNjNmQxYzNmOWY4ZDVjZWUyOTJmYjE5MWExMDg5NmUwCi0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5n LWJ1dHRvbi1pbnB1dC1lbGVtZW50cy5odG1sCkBAIC0wLDAgKzEsNTMgQEAKKzwhRE9DVFlQRSBo dG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9Indp ZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJn aW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8c2NyaXB0 PgoraWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdz LnNldFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNl dHRpbmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30g ZWxzZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7CisgICAgY29uc29sZS53 YXJuKCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVp bmcgdHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUg VGV4dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBw eCBkZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19G T1JDRV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hl YWQ+Cis8Ym9keT4KKworPGRpdj4KKyAgICBUaGlzIHRlc3RzIHRoZSBhdXRvc2l6aW5nIG9mIGEg YnV0dG9uIGlucHV0IGVsZW1lbnQuIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQs IHdoaWxlCisgICAgdGhlIGJ1dHRvbnMgYmVsb3cgc2hvdWxkIG5vdCBiZSBhdXRvc2l6ZWQuIExv cmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZworICAgIGVs aXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUg bWFnbmEgYWxpcXVhLgorPC9kaXY+CisKKzxkaXY+Cis8Zm9ybSBhY3Rpb249IiI+CisgICAgPGRp dj4KKyAgICAgICAgVGhpcyB0ZXh0IHNob3VsZCBiZSBhdXRvc2l6ZWQsIHdoaWxlIHRoZSBpbnB1 dCBjb250cm9scyBiZWxvdyBzaG91bGQgbm90LgorICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAg ICAgIDxpbnB1dCB0eXBlPSJzdWJtaXQiIHZhbHVlPSJGaW5kIj4KKyAgICA8L2Rpdj4KKyAgICA8 ZGl2PgorICAgICAgICA8aW5wdXQgdHlwZT0iYnV0dG9uIiB2YWx1ZT0iQnV0dG9uIj4KKyAgICA8 L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICA8aW5wdXQgdHlwZT0icmVzZXQiIHZhbHVlPSJSZXNl dCI+CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGJ1dHRvbj5JbmxpbmVCdXR0b248 L2J1dHRvbj4KKyAgICA8L2Rpdj4KKzwvZm9ybT4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+ CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRy b2xzLWF1dG9zaXppbmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sIGIvTGF5 b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWNo ZWNrYm94LWlucHV0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yMGMyMTU2MGFm NWI0OTRkZGJmNThkZjUwMGI1NzIyMGUwMGZjYjllCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWNoZWNr Ym94LWlucHV0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbApAQCAtMCwwICsxLDMzIEBACis8IURPQ1RZ UEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50 PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7CisgICAg bWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4KKworCis8 L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRo aXMgdGVzdHMgdGhlIGF1dG9zaXppbmcgb2YgY2hlY2sgYm94ZXMuIFRoaXMgcGFyYWdyYXBoIHNo b3VsZCBiZSBhdXRvc2l6ZWQsIHdoaWxlCisgICAgdGhlIGNoZWNrIGJveGVzIGJlbG93IGFuZCB0 aGUgc3Vycm91bmRpbmcgdGV4dCBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4KKyAgICBMb3JlbSBp cHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRv IGVpdXNtb2QgdGVtcG9yCisgICAgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25h IGFsaXF1YS4KKzwvZGl2PgorPGRpdj4KKzxmb3JtIGFjdGlvbj0iIj4KKyAgICBDaGVjayBvbmUg b3IgbW9yZToKKyAgICA8aW5wdXQgdHlwZT0iY2hlY2tib3giIG5hbWU9InZlaGljbGUiIHZhbHVl PSJCaWtlIj5JIGhhdmUgYSBiaWtlPGJyLz4KKyAgICA8aW5wdXQgdHlwZT0iY2hlY2tib3giIG5h bWU9InZlaGljbGUiIHZhbHVlPSJDYXIiPkkgaGF2ZSBhIGNhciA8YnIvPgorPC9mb3JtPgorPC9k aXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4 dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1jaGVja2JveC1pbnB1dC1lbGVt ZW50Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xz LWF1dG9zaXppbmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC5odG1sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjZhNzc5 ZTA1OWRhMTcxZWRkNTVmZTYzNGY4MTVhZWYwZDU0MTM4ZjUKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmct Y2hlY2tib3gtaW5wdXQtZWxlbWVudC5odG1sCkBAIC0wLDAgKzEsNDEgQEAKKzwhRE9DVFlQRSBo dG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9Indp ZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJn aW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8c2NyaXB0 PgoraWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdz LnNldFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNl dHRpbmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30g ZWxzZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7CisgICAgY29uc29sZS53 YXJuKCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVp bmcgdHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUg VGV4dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBw eCBkZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19G T1JDRV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hl YWQ+Cis8Ym9keT4KKworPGRpdj4KKyAgICBUaGlzIHRlc3RzIHRoZSBhdXRvc2l6aW5nIG9mIGNo ZWNrIGJveGVzLiBUaGlzIHBhcmFncmFwaCBzaG91bGQgYmUgYXV0b3NpemVkLCB3aGlsZQorICAg IHRoZSBjaGVjayBib3hlcyBiZWxvdyBhbmQgdGhlIHN1cnJvdW5kaW5nIHRleHQgc2hvdWxkIG5v dCBiZSBhdXRvc2l6ZWQuCisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3Rl dHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvcgorICAgIGluY2lkaWR1 bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+Cis8Zm9y bSBhY3Rpb249IiI+CisgICAgQ2hlY2sgb25lIG9yIG1vcmU6CisgICAgPGlucHV0IHR5cGU9ImNo ZWNrYm94IiBuYW1lPSJ2ZWhpY2xlIiB2YWx1ZT0iQmlrZSI+SSBoYXZlIGEgYmlrZTxici8+Cisg ICAgPGlucHV0IHR5cGU9ImNoZWNrYm94IiBuYW1lPSJ2ZWhpY2xlIiB2YWx1ZT0iQ2FyIj5JIGhh dmUgYSBjYXIgPGJyLz4KKzwvZm9ybT4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1 dG9zaXppbmctcmFkaW8taW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMv ZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0 LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45Y2E3MWMzYWQzOTg4OWE4YmUzMjE2 ZDhmNjM1N2ZmNDk0ZDYwMGI4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90 ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVsZW1l bnQtZXhwZWN0ZWQuaHRtbApAQCAtMCwwICsxLDM1IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1s PgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgor PHN0eWxlPgorICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAg IG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4KKworCis8L2hlYWQ+Cis8Ym9keT4K KworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRoaXMgdGVzdHMgdGhlIGF1 dG9zaXppbmcgb2YgcmFkaW8gYnV0dG9ucy4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9z aXplZCwgd2hpbGUKKyAgICB0aGUgcmFkaW8gYnV0dG9ucyBiZWxvdyBhbmQgdGhlIHN1cnJvdW5k aW5nIHRleHQgc2hvdWxkIG5vdCBiZSBhdXRvc2l6ZWQuCisgICAgTG9yZW0gaXBzdW0gZG9sb3Ig c2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRl bXBvcgorICAgIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8 L2Rpdj4KKzxkaXY+Cis8Zm9ybSBhY3Rpb249IiI+CisgICAgU2VsZWN0IG9uZSBvZjo8YnIvPgor ICAgIDxpbnB1dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMSIgY2hlY2tlZD0iY2hlY2tlZCIvPgor ICAgIDxsYWJlbCBmb3I9InJhZGlvMSI+UmFkaW8xPC9sYWJlbD48YnIvPgorICAgIDxpbnB1dCB0 eXBlPSJyYWRpbyIgaWQ9InJhZGlvMiIvPgorICAgIDxsYWJlbCBmb3I9InJhZGlvMiI+UmFkaW8y PC9sYWJlbD48YnIvPgorPC9mb3JtPgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0 b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQt YXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctcmFkaW8taW5wdXQtZWxlbWVudC5o dG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAuLjRkOTI1NzA4Mzc2NDZhZmNjNjVkOTdhYzhiMjIyNWZkOTk0ZWViZTkK LS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3Jt LWNvbnRyb2xzLWF1dG9zaXppbmctcmFkaW8taW5wdXQtZWxlbWVudC5odG1sCkBAIC0wLDAgKzEs NDMgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmll d3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRo OiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8 L3N0eWxlPgorCis8c2NyaXB0PgoraWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cu aW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3 aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJy aWRlKDMyMCwgNDgwKTsKK30gZWxzZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJu KSB7CisgICAgY29uc29sZS53YXJuKCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRv c2l6aW5nIHNldHRpbmcgYmVpbmcgdHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBv ciBtYW51YWxseSBlbmFibGUgVGV4dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmls ZSBkZXZpY2Ugd2l0aCAzMjBweCBkZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUp LCBvciBkZWZpbmUgSEFDS19GT1JDRV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30K Kzwvc2NyaXB0PgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdj4KKyAgICBUaGlzIHRlc3RzIHRo ZSBhdXRvc2l6aW5nIG9mIHJhZGlvIGJ1dHRvbnMuIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBh dXRvc2l6ZWQsIHdoaWxlCisgICAgdGhlIHJhZGlvIGJ1dHRvbnMgYmVsb3cgYW5kIHRoZSBzdXJy b3VuZGluZyB0ZXh0IHNob3VsZCBub3QgYmUgYXV0b3NpemVkLgorICAgIExvcmVtIGlwc3VtIGRv bG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21v ZCB0ZW1wb3IKKyAgICBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVh LgorPC9kaXY+Cis8ZGl2PgorPGZvcm0gYWN0aW9uPSIiPgorICAgIFNlbGVjdCBvbmUgb2Y6PGJy Lz4KKyAgICA8aW5wdXQgdHlwZT0icmFkaW8iIGlkPSJyYWRpbzEiIGNoZWNrZWQ9ImNoZWNrZWQi Lz4KKyAgICA8bGFiZWwgZm9yPSJyYWRpbzEiPlJhZGlvMTwvbGFiZWw+PGJyLz4KKyAgICA8aW5w dXQgdHlwZT0icmFkaW8iIGlkPSJyYWRpbzIiLz4KKyAgICA8bGFiZWwgZm9yPSJyYWRpbzIiPlJh ZGlvMjwvbGFiZWw+PGJyLz4KKzwvZm9ybT4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xz LWF1dG9zaXppbmctc2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zh c3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1zZWxlY3QtZWxlbWVu dC1leHBlY3RlZC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmYyMWQ5N2VjNjY0MzY2ZTkxYzUwZjc5N2NlZDE4 NjI4ZDQ2MDc5ZWUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0 b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctc2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQu aHRtbApAQCAtMCwwICsxLDM0IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisK KzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBi b2R5IHsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6 IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXYgc3R5bGU9 ImZvbnQtc2l6ZTogMi41cmVtIj4KKyAgICBUaGlzIHRlc3RzIHRoZSBhdXRvc2l6aW5nIG9mIGEg c2VsZWN0aW9uIG1lbnUgZWxlbWVudC4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXpl ZCwgd2hpbGUKKyAgICB0aGUgc2VsZWN0aW9uIGJveCBiZWxvdyBzaG91bGQgbm90IGJlIGF1dG9z aXplZC4gTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5n CisgICAgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0 IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+Cis8Zm9ybSBhY3Rpb249IiI+Cisg ICAgU2VsZWN0aW9uOgorICAgIDxzZWxlY3Q+CisgICAgICAgIDxvcHRpb24gc2VsZWN0ZWQgdmFs dWU9ZGVmYXVsdD5EZWZhdWx0PC9vcHRpb24+CisgICAgICAgIDxvcHRpb24+T3B0aW9uIDE8L29w dGlvbj4KKyAgICAgICAgPG9wdGlvbj5PcHRpb24gMjwvb3B0aW9uPgorICAgIDwvc2VsZWN0Pgor PC9mb3JtPgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1zZWxlY3Qt ZWxlbWVudC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250 cm9scy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTExYzhmYzJm M2Y2ZWNjNGZmNDc0MTgyZjAwZWQ5MTk2ZTAzMTVmMwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1zZWxl Y3QtZWxlbWVudC5odG1sCkBAIC0wLDAgKzEsNDMgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+ Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8 c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAg b3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8c2NyaXB0PgoraWYgKHdpbmRv dy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRBdXRv c2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5kb3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRl eHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRlKDMyMCwgNDgwKTsKK30gZWxzZSBpZiAod2lu ZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7CisgICAgY29uc29sZS53YXJuKCJUaGlzIHRl c3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6aW5nIHNldHRpbmcgYmVpbmcgdHJ1ZSwgc28g cnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBtYW51YWxseSBlbmFibGUgVGV4dCBBdXRvc2l6 aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBkZXZpY2Ugd2l0aCAzMjBweCBkZXZpY2Utd2lk dGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBvciBkZWZpbmUgSEFDS19GT1JDRV9URVhUX0FV VE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwvc2NyaXB0PgorCis8L2hlYWQ+Cis8Ym9keT4K KworPGRpdj4KKyAgICBUaGlzIHRlc3RzIHRoZSBhdXRvc2l6aW5nIG9mIGEgc2VsZWN0aW9uIG1l bnUgZWxlbWVudC4gVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUKKyAg ICB0aGUgc2VsZWN0aW9uIGJveCBiZWxvdyBzaG91bGQgbm90IGJlIGF1dG9zaXplZC4gTG9yZW0g aXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nCisgICAgZWxpdCwg c2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWdu YSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+Cis8Zm9ybSBhY3Rpb249IiI+CisgICAgU2VsZWN0aW9u OgorICAgIDxzZWxlY3Q+CisgICAgICAgIDxvcHRpb24gc2VsZWN0ZWQgdmFsdWU9ZGVmYXVsdD5E ZWZhdWx0PC9vcHRpb24+CisgICAgICAgIDxvcHRpb24+T3B0aW9uIDE8L29wdGlvbj4KKyAgICAg ICAgPG9wdGlvbj5PcHRpb24gMjwvb3B0aW9uPgorICAgIDwvc2VsZWN0PgorPC9mb3JtPgorPC9k aXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4 dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxl bWVudHMtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zv cm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi42MjAwMTQ5ZmEwNTM2ZmVkNzE0MTBhYTdjNWUwMjJmMDViNmY4MDll Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9y bS1jb250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5o dG1sCkBAIC0wLDAgKzEsNDcgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKwor PG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJv ZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTog aGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0i Zm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRoaXMgdGVzdHMgdGhlIGF1dG9zaXppbmcgb2YgdGhl IHRleHQgZmllbGQgaW5wdXQgZWxlbWVudHMuIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRv c2l6ZWQsIHdoaWxlCisgICAgdGhlIGJ1dHRvbnMgYmVsb3cgc2hvdWxkIG5vdCBiZSBhdXRvc2l6 ZWQuIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZwor ICAgIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBk b2xvcmUgbWFnbmEgYWxpcXVhLgorPC9kaXY+CisKKzxkaXY+Cis8Zm9ybSBhY3Rpb249IiI+Cisg ICAgPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgICAgICBUaGlzIHRleHQgc2hv dWxkIGJlIGF1dG9zaXplZCwgd2hpbGUgdGhlIGlucHV0IGNvbnRyb2xzIGJlbG93IHNob3VsZCBu b3QuCisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9InRleHQiPgor ICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIDxpbnB1dCB0eXBlPSJlbWFpbCI+CisgICAg PC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9Im51bWJlciI+CisgICAgPC9k aXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9InBhc3N3b3JkIj4KKyAgICA8L2Rp dj4KKyAgICA8ZGl2PgorICAgICAgICA8aW5wdXQgdHlwZT0idXJsIj4KKyAgICA8L2Rpdj4KKzwv Zm9ybT4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctdGV4dGZpZWxk LWlucHV0LWVsZW1lbnRzLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9m b3JtLWNvbnRyb2xzLWF1dG9zaXppbmctdGV4dGZpZWxkLWlucHV0LWVsZW1lbnRzLmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uODAwNTlmNDI1NGEzZTY2NjRkOWUyZjk2YjEwZjk1OWMxODk4MWQzNQotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxlbWVudHMuaHRtbApAQCAtMCwwICsxLDU2 IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdw b3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3aWR0aDog ODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgfQorPC9z dHlsZT4KKworPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJuYWxzKSB7CisgICAgd2luZG93Lmlu dGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ0VuYWJsZWQodHJ1ZSk7CisgICAgd2lu ZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ1dpbmRvd1NpemVPdmVycmlk ZSgzMjAsIDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRvdy5jb25zb2xlICYmIGNvbnNvbGUud2Fybikg eworICAgIGNvbnNvbGUud2FybigiVGhpcyB0ZXN0IGRlcGVuZHMgb24gdGhlIFRleHQgQXV0b3Np emluZyBzZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1biBpdCBpbiBEdW1wUmVuZGVyVHJlZSwgb3Ig bWFudWFsbHkgZW5hYmxlIFRleHQgQXV0b3NpemluZywgYW5kIGVpdGhlciB1c2UgYSBtb2JpbGUg ZGV2aWNlIHdpdGggMzIwcHggZGV2aWNlLXdpZHRoIChsaWtlIE5leHVzIFMgb3IgaVBob25lKSwg b3IgZGVmaW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRPU0laSU5HX09OX0RFU0tUT1AuIik7Cit9Cis8 L3NjcmlwdD4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+CisgICAgVGhpcyB0ZXN0cyB0aGUg YXV0b3NpemluZyBvZiB0aGUgdGV4dCBmaWVsZCBpbnB1dCBlbGVtZW50cy4gVGhpcyBwYXJhZ3Jh cGggc2hvdWxkIGJlIGF1dG9zaXplZCwgd2hpbGUKKyAgICB0aGUgYnV0dG9ucyBiZWxvdyBzaG91 bGQgbm90IGJlIGF1dG9zaXplZC4gTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3Rl dHVyIGFkaXBpc2ljaW5nCisgICAgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1 bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKworPGRpdj4KKzxm b3JtIGFjdGlvbj0iIj4KKyAgICA8ZGl2PgorICAgICAgICBUaGlzIHRleHQgc2hvdWxkIGJlIGF1 dG9zaXplZCwgd2hpbGUgdGhlIGlucHV0IGNvbnRyb2xzIGJlbG93IHNob3VsZCBub3QuCisgICAg PC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9InRleHQiPgorICAgIDwvZGl2 PgorICAgIDxkaXY+CisgICAgICAgIDxpbnB1dCB0eXBlPSJlbWFpbCI+CisgICAgPC9kaXY+Cisg ICAgPGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9Im51bWJlciI+CisgICAgPC9kaXY+CisgICAg PGRpdj4KKyAgICAgICAgPGlucHV0IHR5cGU9InBhc3N3b3JkIj4KKyAgICA8L2Rpdj4KKyAgICA8 ZGl2PgorICAgICAgICA8aW5wdXQgdHlwZT0idXJsIj4KKyAgICA8L2Rpdj4KKzwvZm9ybT4KKzwv ZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+Cg== 179806 2012-12-17 14:41:03 -0800 2012-12-19 05:03:32 -0800 Patch bug-102560-20121217223819.patch text/plain 24597 timvolodine U3VidmVyc2lvbiBSZXZpc2lvbjogMTM3NzM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjA1MDE5ZDIxMTM5NTVm MWRlODcxYWRjYTE2MjE2OTU1ZWY0NTg5My4uOWE1NGM2NjFiMjhiM2I4Mzc2MDYyYzJiZmRjZjIw NTUyZDI1MGJjMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMxIEBACisyMDEyLTEyLTE0ICBUaW0g Vm9sb2RpbmUgIDx0aW12b2xvZGluZUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgVGV4dCBBdXRv c2l6aW5nOiBXb3JrIG91dCB3aGF0IHRvIGRvIGFib3V0IGZvcm0gY29udHJvbHMKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwMjU2MAorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIERpc2FsbG93IGF1dG9zaXpp bmcgb2YgZm9ybSBpbnB1dCBjb250cm9scyBsaWtlIGJ1dHRvbnMsIHRleHQgaW5wdXQgZmllbGRz LCBzZWxlY3Rpb24gY29udHJvbHMsIHJhZGlvIGJ1dHRvbnMKKyAgICAgICAgYW5kIGNoZWNrIGJv eGVzLiBUaGlzIGlzIGEgc2hvcnQgdGVybSBzb2x1dGlvbiB0byBhdm9pZCBpbmNvbnNpc3RlbnQg YXV0b3NpemluZyBvZiBmb3JtIGNvbnRyb2xzICh3aGljaCBpcworICAgICAgICB3b3JzZSB0aGFu IG5vdCBhdXRvc2l6aW5nIGF0IGFsbCkuCisKKyAgICAgICAgVGVzdHM6IGZhc3QvdGV4dC1hdXRv c2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMuaHRt bAorICAgICAgICAgICAgICAgZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRv c2l6aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC90 ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVsZW1l bnQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvdGV4 dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxl bWVudHMuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwOgorICAg ICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpmb3JtSW5wdXRUYWdzKToKKyAgICAg ICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OnByb2Nlc3NDb250YWluZXIpOgorICAgICAgICAo V2ViQ29yZTo6VGV4dEF1dG9zaXplcjo6aXNBdXRvc2l6aW5nQ29udGFpbmVyKToKKyAgICAgICAg KFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OmNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKToKKyAg ICAgICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OmNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVk KToKKyAgICAgICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OmNvbnRhaW5lckNvbnRhaW5zVGFn cyk6CisgICAgICAgIChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjptZWFzdXJlRGVzY2VuZGFudFRl eHRXaWR0aCk6CisgICAgICAgICogcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaDoKKwogMjAxMi0x Mi0xNCAgS2VudGFybyBIYXJhICA8aGFyYWtlbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgQ2hp bGROb2Rlc0xhenlTbmFwc2hvdDo6bmV4dE5vZGUoKSBjYW4gY3Jhc2ggaW4gRGVidWcgYnVpbGRz CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5jcHAKaW5kZXggOGI3Zjgy NDI3ZWM4YzQ4ZTQxODY0ZTkyZWVhMDQ1NmMxYzNjMTQzYi4uZTE3YmY4MmM5NTQyNThmODNmYzY4 YzA1MGE4ZDQzZGI1NDE5MTY1MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1RleHRBdXRvc2l6ZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0 b3NpemVyLmNwcApAQCAtMjUsNiArMjUsNyBAQAogI2luY2x1ZGUgIlRleHRBdXRvc2l6ZXIuaCIK IAogI2luY2x1ZGUgIkRvY3VtZW50LmgiCisjaW5jbHVkZSAiSFRNTEVsZW1lbnQuaCIKICNpbmNs dWRlICJJbnNwZWN0b3JJbnN0cnVtZW50YXRpb24uaCIKICNpbmNsdWRlICJSZW5kZXJPYmplY3Qu aCIKICNpbmNsdWRlICJSZW5kZXJTdHlsZS5oIgpAQCAtMzQsMTQgKzM1LDMwIEBACiAjaW5jbHVk ZSAiU3R5bGVJbmhlcml0ZWREYXRhLmgiCiAKICNpbmNsdWRlIDxhbGdvcml0aG0+CisjaW5jbHVk ZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKK3VzaW5nIG5h bWVzcGFjZSBIVE1MTmFtZXM7CisKIHN0cnVjdCBUZXh0QXV0b3NpemluZ1dpbmRvd0luZm8gewog ICAgIEludFNpemUgd2luZG93U2l6ZTsKICAgICBJbnRTaXplIG1pbkxheW91dFNpemU7CiB9Owog CisKK3N0YXRpYyBjb25zdCBWZWN0b3I8UXVhbGlmaWVkTmFtZT4mIGZvcm1JbnB1dFRhZ3MoKQor eworICAgIC8vIFJldHVybnMgdGhlIHRhZ3MgZm9yIHRoZSBmb3JtIGlucHV0IGVsZW1lbnRzLgor ICAgIERFRklORV9TVEFUSUNfTE9DQUwoVmVjdG9yPFF1YWxpZmllZE5hbWU+LCBmb3JtSW5wdXRU YWdzLCAoKSk7CisgICAgaWYgKGZvcm1JbnB1dFRhZ3MuaXNFbXB0eSgpKSB7CisgICAgICAgIGZv cm1JbnB1dFRhZ3MuYXBwZW5kKGlucHV0VGFnKTsKKyAgICAgICAgZm9ybUlucHV0VGFncy5hcHBl bmQoYnV0dG9uVGFnKTsKKyAgICAgICAgZm9ybUlucHV0VGFncy5hcHBlbmQoc2VsZWN0VGFnKTsK KyAgICB9CisgICAgcmV0dXJuIGZvcm1JbnB1dFRhZ3M7Cit9CisKIFRleHRBdXRvc2l6ZXI6OlRl eHRBdXRvc2l6ZXIoRG9jdW1lbnQqIGRvY3VtZW50KQogICAgIDogbV9kb2N1bWVudChkb2N1bWVu dCkKIHsKQEAgLTEyMyw3ICsxNDAsNyBAQCB2b2lkIFRleHRBdXRvc2l6ZXI6OnByb2Nlc3NDb250 YWluZXIoZmxvYXQgbXVsdGlwbGllciwgUmVuZGVyQmxvY2sqIGNvbnRhaW5lciwgUgogewogICAg IEFTU0VSVChpc0F1dG9zaXppbmdDb250YWluZXIoY29udGFpbmVyKSk7CiAKLSAgICBmbG9hdCBs b2NhbE11bHRpcGxpZXIgPSBjb250YWluZXJTaG91bGRiZUF1dG9zaXplZChjb250YWluZXIpID8g bXVsdGlwbGllcjogMTsKKyAgICBmbG9hdCBsb2NhbE11bHRpcGxpZXIgPSBjb250YWluZXJTaG91 bGRCZUF1dG9zaXplZChjb250YWluZXIpID8gbXVsdGlwbGllciA6IDE7CiAKICAgICBSZW5kZXJP YmplY3QqIGRlc2NlbmRhbnQgPSBuZXh0SW5QcmVPcmRlclNraXBwaW5nRGVzY2VuZGFudHNPZkNv bnRhaW5lcnMoc3VidHJlZVJvb3QsIHN1YnRyZWVSb290KTsKICAgICB3aGlsZSAoZGVzY2VuZGFu dCkgewpAQCAtMTkxLDYgKzIwOCwxMSBAQCBib29sIFRleHRBdXRvc2l6ZXI6OmlzQXV0b3Npemlu Z0NvbnRhaW5lcihjb25zdCBSZW5kZXJPYmplY3QqIHJlbmRlcmVyKQogICAgICAgICByZXR1cm4g ZmFsc2U7CiAgICAgaWYgKHJlbmRlcmVyLT5pc0xpc3RJdGVtKCkpCiAgICAgICAgIHJldHVybiBy ZW5kZXJlci0+aXNGbG9hdGluZygpIHx8IHJlbmRlcmVyLT5pc091dE9mRmxvd1Bvc2l0aW9uZWQo KTsKKyAgICAvLyBBdm9pZCBjcmVhdGluZyBjb250YWluZXJzIGZvciB0ZXh0IHdpdGhpbiB0ZXh0 IGNvbnRyb2xzLCBidXR0b25zLCBvciA8c2VsZWN0PiBidXR0b25zLgorICAgIE5vZGUqIHBhcmVu dE5vZGUgPSByZW5kZXJlci0+cGFyZW50KCkgPyByZW5kZXJlci0+cGFyZW50KCktPmdlbmVyYXRp bmdOb2RlKCkgOiAwOworICAgIGlmIChwYXJlbnROb2RlICYmIHBhcmVudE5vZGUtPmlzRWxlbWVu dE5vZGUoKSAmJiBmb3JtSW5wdXRUYWdzKCkuY29udGFpbnModG9FbGVtZW50KHBhcmVudE5vZGUp LT50YWdRTmFtZSgpKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCiAgICAgcmV0dXJuIHRydWU7 CiB9CiAKQEAgLTIzMCw3ICsyNTIsNyBAQCBib29sIFRleHRBdXRvc2l6ZXI6OmlzQXV0b3Npemlu Z0NsdXN0ZXIoY29uc3QgUmVuZGVyQmxvY2sqIHJlbmRlcmVyKQogICAgIC8vIHJlbmRlcmVycywg YW5kIHByb2JhYmx5IGZsZXhib3hlcy4uLgogfQogCi1zdGF0aWMgYm9vbCBjb250ZW50SGVpZ2h0 SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyKQorYm9vbCBUZXh0QXV0 b3NpemVyOjpjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJCbG9jayogY29u dGFpbmVyKQogewogICAgIC8vIEZJWE1FOiBQcm9wYWdhdGUgY29uc3RyYWluZWRuZXNzIGRvd24g dGhlIHRyZWUsIHRvIGF2b2lkIGluZWZmaWNpZW50bHkgd2Fsa2luZyBiYWNrIHVwIGZyb20gZWFj aCBib3guCiAgICAgLy8gRklYTUU6IFRoaXMgY29kZSBuZWVkcyB0byB0YWtlIGludG8gYWNjb3Vu dCB2ZXJ0aWNhbCB3cml0aW5nIG1vZGVzLgpAQCAtMjUwLDggKzI3MiwxMSBAQCBzdGF0aWMgYm9v bCBjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVy KQogICAgIHJldHVybiBmYWxzZTsKIH0KIAotYm9vbCBUZXh0QXV0b3NpemVyOjpjb250YWluZXJT aG91bGRiZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyKQorYm9vbCBUZXh0 QXV0b3NpemVyOjpjb250YWluZXJTaG91bGRCZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayog Y29udGFpbmVyKQogeworICAgIGlmIChjb250YWluZXJDb250YWluc09uZU9mVGFncyhjb250YWlu ZXIsIGZvcm1JbnB1dFRhZ3MoKSkpCisgICAgICAgIHJldHVybiBmYWxzZTsKKwogICAgIC8vIERv bid0IGF1dG9zaXplIGJsb2NrLWxldmVsIHRleHQgdGhhdCBjYW4ndCB3cmFwIChhcyBpdCdzIGxp a2VseSB0bwogICAgIC8vIGV4cGFuZCBzaWRld2F5cyBhbmQgYnJlYWsgdGhlIHBhZ2UncyBsYXlv dXQpLgogICAgIGlmICghY29udGFpbmVyLT5zdHlsZSgpLT5hdXRvV3JhcCgpKQpAQCAtMjgxLDkg KzMwNiwyNCBAQCBib29sIFRleHRBdXRvc2l6ZXI6OmNsdXN0ZXJTaG91bGRCZUF1dG9zaXplZChj b25zdCBSZW5kZXJCbG9jayogbG93ZXN0Q29tbW9uQW5jZQogICAgIHJldHVybiBmYWxzZTsKIH0K IAorYm9vbCBUZXh0QXV0b3NpemVyOjpjb250YWluZXJDb250YWluc09uZU9mVGFncyhjb25zdCBS ZW5kZXJCbG9jayogY29udGFpbmVyLCBjb25zdCBWZWN0b3I8UXVhbGlmaWVkTmFtZT4mIHRhZ3Mp Cit7CisgICAgY29uc3QgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGNvbnRhaW5lcjsKKyAgICB3 aGlsZSAocmVuZGVyZXIpIHsKKyAgICAgICAgY29uc3QgTm9kZSogcmVuZGVyZXJOb2RlID0gcmVu ZGVyZXItPm5vZGUoKTsKKyAgICAgICAgaWYgKHJlbmRlcmVyTm9kZSAmJiByZW5kZXJlck5vZGUt PmlzRWxlbWVudE5vZGUoKSkgeworICAgICAgICAgICAgaWYgKHRhZ3MuY29udGFpbnModG9FbGVt ZW50KHJlbmRlcmVyTm9kZSktPnRhZ1FOYW1lKCkpKQorICAgICAgICAgICAgICAgIHJldHVybiB0 cnVlOworICAgICAgICB9CisgICAgICAgIHJlbmRlcmVyID0gbmV4dEluUHJlT3JkZXJTa2lwcGlu Z0Rlc2NlbmRhbnRzT2ZDb250YWluZXJzKHJlbmRlcmVyLCBjb250YWluZXIpOworICAgIH0KKwor ICAgIHJldHVybiBmYWxzZTsKK30KKwogdm9pZCBUZXh0QXV0b3NpemVyOjptZWFzdXJlRGVzY2Vu ZGFudFRleHRXaWR0aChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyLCBmbG9hdCBtaW5UZXh0 V2lkdGgsIGZsb2F0JiB0ZXh0V2lkdGgpCiB7Ci0gICAgYm9vbCBza2lwTG9jYWxUZXh0ID0gIWNv bnRhaW5lclNob3VsZGJlQXV0b3NpemVkKGNvbnRhaW5lcik7CisgICAgYm9vbCBza2lwTG9jYWxU ZXh0ID0gIWNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVkKGNvbnRhaW5lcik7CiAKICAgICBSZW5k ZXJPYmplY3QqIGRlc2NlbmRhbnQgPSBuZXh0SW5QcmVPcmRlclNraXBwaW5nRGVzY2VuZGFudHNP ZkNvbnRhaW5lcnMoY29udGFpbmVyLCBjb250YWluZXIpOwogICAgIHdoaWxlIChkZXNjZW5kYW50 KSB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5o IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaAppbmRleCBkZDNlMTlk ZGQzYmVhNGQwMDI2OGZhMmFiMDJhOWE1NjkwNGEzMTdlLi5hNzllZjc0MzkwM2Y1ZGZjNzY5YmIy OWExZGIzMWE1YTc2MWM2ZTUwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv VGV4dEF1dG9zaXplci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3Np emVyLmgKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2lmIEVOQUJMRShURVhUX0FVVE9TSVpJTkcpCiAK KyNpbmNsdWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJJbnRTaXplLmgiCiAjaW5jbHVkZSA8 d3RmL05vbmNvcHlhYmxlLmg+CiAjaW5jbHVkZSA8d3RmL1Bhc3NPd25QdHIuaD4KQEAgLTcwLDgg KzcxLDEwIEBAIHByaXZhdGU6CiAgICAgc3RhdGljIGJvb2wgaXNBdXRvc2l6aW5nQ29udGFpbmVy KGNvbnN0IFJlbmRlck9iamVjdCopOwogICAgIHN0YXRpYyBib29sIGlzQXV0b3NpemluZ0NsdXN0 ZXIoY29uc3QgUmVuZGVyQmxvY2sqKTsKIAotICAgIHN0YXRpYyBib29sIGNvbnRhaW5lclNob3Vs ZGJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIpOwogICAgIHN0YXRpYyBi b29sIGNsdXN0ZXJTaG91bGRCZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayogbG93ZXN0Q29t bW9uQW5jZXN0b3IsIGZsb2F0IGNvbW1vbkFuY2VzdG9yV2lkdGgpOworICAgIHN0YXRpYyBib29s IGNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIp OworICAgIHN0YXRpYyBib29sIGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnN0IFJlbmRl ckJsb2NrKiBjb250YWluZXIpOworICAgIHN0YXRpYyBib29sIGNvbnRhaW5lckNvbnRhaW5zT25l T2ZUYWdzKGNvbnN0IFJlbmRlckJsb2NrKiBjbHVzdGVyLCBjb25zdCBWZWN0b3I8UXVhbGlmaWVk TmFtZT4mIHRhZ3MpOwogICAgIHN0YXRpYyB2b2lkIG1lYXN1cmVEZXNjZW5kYW50VGV4dFdpZHRo KGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIsIGZsb2F0IG1pblRleHRXaWR0aCwgZmxvYXQm IHRleHRXaWR0aCk7CiAKICAgICAvLyBVc2UgdG8gdHJhdmVyc2UgdGhlIHRyZWUgb2YgZGVzY2Vu ZGFudHMsIGV4Y2x1ZGluZyBkZXNjZW5kYW50cyBvZiBjb250YWluZXJzIChidXQgcmV0dXJuaW5n IHRoZSBjb250YWluZXJzIHRoZW1zZWx2ZXMpLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGM5YzQyZmU5MjExMzU5NzBkYjY2 NmRkMDAxZmZiOTdlNjVmZmNjNDkuLjI2YWRjM2U5Y2ExOTA1NTYxNzc2MmNkZmI3ODBmYjJkY2M5 YWEyNzcgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAxMi0xMi0xNCAgVGltIFZvbG9kaW5lICA8 dGltdm9sb2RpbmVAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFRleHQgQXV0b3NpemluZzogV29y ayBvdXQgd2hhdCB0byBkbyBhYm91dCBmb3JtIGNvbnRyb2xzCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDI1NjAKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUZXN0cyBmb3IgZm9ybSBpbnB1dCBlbGVtZW50 cyBhdXRvc2l6aW5nLiBBZGRlZCB0ZXN0cyB0byBjaGVjayB0aGF0IHZhcmlvdXMga2luZHMgb2Yg Zm9ybSBlbGVtZW50cworICAgICAgICBkb24ndCBnZXQgYXV0b3NpemVkLCBpLmUuIGJ1dHRvbnMs IHRleHRhcmVhcywgY2hlY2sgYm94ZXMsIHJhZGlvIGJ1dHRvbiBhbmQgc2VsZWN0aW9uIG1lbnVz LgorCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6 aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1sOiBBZGRlZC4KKyAgICAgICAg KiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctYnV0dG9uLWlu cHV0LWVsZW1lbnRzLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5n L2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVjdGVk Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYXV0b3NpemluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50Lmh0bWw6IEFkZGVkLgorICAgICAg ICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1yYWRpby1p bnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1h dXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0 bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMt YXV0b3NpemluZy1zZWxlY3QtZWxlbWVudC1leHBlY3RlZC5odG1sOiBBZGRlZC4KKyAgICAgICAg KiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctc2VsZWN0LWVs ZW1lbnQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1j b250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1s OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1 dG9zaXppbmctdGV4dGZpZWxkLWlucHV0LWVsZW1lbnRzLmh0bWw6IEFkZGVkLgorCiAyMDEyLTEy LTE0ICBKb2huIE1lbGxvciAgPGpvaG5tZUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVGV4dCBB dXRvc2l6aW5nOiBEb24ndCBhdXRvc2l6ZSB1bndyYXBwYWJsZSBibG9ja3MKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3Npemlu Zy1idXR0b24taW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv dGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxl bWVudHMtZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zY2RhYjVkNjhhYmQ5MjIwZDdlN2U2NWNk MmUzMjIxYzU1ZjU1NjY3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0 LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50 cy1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsNDYgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+ Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8 c3R5bGU+CisgIGJvZHkgeworICAgIGZvbnQtc2l6ZTogMTZweDsKKyAgICB3aWR0aDogODAwcHg7 CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4K KworPC9oZWFkPgorPGJvZHk+CisKKzxkaXYgc3R5bGU9ImZvbnQtc2l6ZTogMi41cmVtIj4KKyAg ICBUaGlzIHBhcmFncmFwaCBzaG91bGQgYmUgYXV0b3NpemVkIHRvIDQwcHggY29tcHV0ZWQgZm9u dC1zaXplICgxNiAqIDgwMC8zMjApLAorICAgIHdoZXJlYXMgdGhlIGJ1dHRvbnMgYW5kIHRoZSBj b3JyZXNwb25kaW5nIHRleHQgYmVsb3cgc2hvdWxkIGJlIHJlbmRlcmVkIGF0CisgICAgdGhlaXIg ZGVmYXVsdCBmb250IHNpemUuCisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNl Y3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kCisgICAgdGVtcG9yIGluY2lk aWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKworPGRpdj4K KyAgICA8ZGl2PgorICAgICAgICBTdWJtaXQgYnV0dG9uCisgICAgICAgIDxpbnB1dCB0eXBlPSJz dWJtaXQiIHZhbHVlPSJGaW5kIj4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICBTaW1w bGUgYnV0dG9uCisgICAgICAgIDxpbnB1dCB0eXBlPSJidXR0b24iIHZhbHVlPSJCdXR0b24iPgor ICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIFJlc2V0IGJ1dHRvbgorICAgICAgICA8aW5w dXQgdHlwZT0icmVzZXQiIHZhbHVlPSJSZXNldCI+CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAg ICAgICAgSW5saW5lIGJ1dHRvbgorICAgICAgICA8YnV0dG9uPklubGluZUJ1dHRvbjwvYnV0dG9u PgorICAgIDwvZGl2PgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1i dXR0b24taW5wdXQtZWxlbWVudHMuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6 aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMuaHRtbApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwLi45YTU1MWNkNzY3ZTA2ZTA2MzA3ZTYyMTAxZTdkZTQ2MDA1ZmJlNWQ5Ci0tLSAv ZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250 cm9scy1hdXRvc2l6aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50cy5odG1sCkBAIC0wLDAgKzEsNTUg QEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3Bv cnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIGZvbnQtc2l6 ZTogMTZweDsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93 LXk6IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4KKworPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJu YWxzKSB7CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ0Vu YWJsZWQodHJ1ZSk7CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3Np emluZ1dpbmRvd1NpemVPdmVycmlkZSgzMjAsIDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRvdy5jb25z b2xlICYmIGNvbnNvbGUud2FybikgeworICAgIGNvbnNvbGUud2FybigiVGhpcyB0ZXN0IGRlcGVu ZHMgb24gdGhlIFRleHQgQXV0b3NpemluZyBzZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1biBpdCBp biBEdW1wUmVuZGVyVHJlZSwgb3IgbWFudWFsbHkgZW5hYmxlIFRleHQgQXV0b3NpemluZywgYW5k IGVpdGhlciB1c2UgYSBtb2JpbGUgZGV2aWNlIHdpdGggMzIwcHggZGV2aWNlLXdpZHRoIChsaWtl IE5leHVzIFMgb3IgaVBob25lKSwgb3IgZGVmaW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRPU0laSU5H X09OX0RFU0tUT1AuIik7Cit9Cis8L3NjcmlwdD4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+ CisgICAgVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCB0byA0MHB4IGNvbXB1dGVk IGZvbnQtc2l6ZSAoMTYgKiA4MDAvMzIwKSwKKyAgICB3aGVyZWFzIHRoZSBidXR0b25zIGFuZCB0 aGUgY29ycmVzcG9uZGluZyB0ZXh0IGJlbG93IHNob3VsZCBiZSByZW5kZXJlZCBhdAorICAgIHRo ZWlyIGRlZmF1bHQgZm9udCBzaXplLgorICAgIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBj b25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZAorICAgIHRlbXBvciBp bmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLgorPC9kaXY+CisKKzxk aXY+CisgICAgPGRpdj4KKyAgICAgICAgU3VibWl0IGJ1dHRvbgorICAgICAgICA8aW5wdXQgdHlw ZT0ic3VibWl0IiB2YWx1ZT0iRmluZCI+CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAg U2ltcGxlIGJ1dHRvbgorICAgICAgICA8aW5wdXQgdHlwZT0iYnV0dG9uIiB2YWx1ZT0iQnV0dG9u Ij4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICBSZXNldCBidXR0b24KKyAgICAgICAg PGlucHV0IHR5cGU9InJlc2V0IiB2YWx1ZT0iUmVzZXQiPgorICAgIDwvZGl2PgorICAgIDxkaXY+ CisgICAgICAgIElubGluZSBidXR0b24KKyAgICAgICAgPGJ1dHRvbj5JbmxpbmVCdXR0b248L2J1 dHRvbj4KKyAgICA8L2Rpdj4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXpp bmctY2hlY2tib3gtaW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWNoZWNrYm94LWlucHV0 LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zZTZhMTNmODgzYWJlYTI0MDk4Yzdj YzdmMmIxYjlkMTAyNWY2ZGI5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90 ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWNoZWNrYm94LWlucHV0LWVs ZW1lbnQtZXhwZWN0ZWQuaHRtbApAQCAtMCwwICsxLDMyIEBACis8IURPQ1RZUEUgaHRtbD4KKzxo dG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAi PgorPHN0eWxlPgorICBib2R5IHsKKyAgICBmb250LXNpemU6IDE2cHg7CisgICAgd2lkdGg6IDgw MHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5 bGU+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2IHN0eWxlPSJmb250LXNpemU6IDIuNXJlbSI+ CisgICAgVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCB0byA0MHB4IGNvbXB1dGVk IGZvbnQtc2l6ZSAoMTYgKiA4MDAvMzIwKSwKKyAgICB3aGVyZWFzIHRoZSBjaGVjayBib3hlcyBi ZWxvdyBhbmQgdGhlIHN1cnJvdW5kaW5nIHRleHQgc2hvdWxkIGJlCisgICAgcmVuZGVyZWQgYXQg dGhlaXIgZGVmYXVsdCBmb250IHNpemUuCisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQs IGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvcgorICAg IGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxk aXY+CisgICAgQ2hlY2sgb25lIG9yIG1vcmU6CisgICAgPGlucHV0IHR5cGU9ImNoZWNrYm94IiBu YW1lPSJ2ZWhpY2xlIiB2YWx1ZT0iQmlrZSI+SSBoYXZlIGEgYmlrZTxici8+CisgICAgPGlucHV0 IHR5cGU9ImNoZWNrYm94IiBuYW1lPSJ2ZWhpY2xlIiB2YWx1ZT0iQ2FyIj5JIGhhdmUgYSBjYXIg PGJyLz4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctY2hlY2tib3gt aW5wdXQtZWxlbWVudC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9y bS1jb250cm9scy1hdXRvc2l6aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi44NGIxNWY5MTAyZmY1MDM4NWU1MGNmZDA3NGY4NDA2NTQ3NTc5ZjJjCi0tLSAvZGV2L251 bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1h dXRvc2l6aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbApAQCAtMCwwICsxLDQxIEBACis8 IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBj b250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICBmb250LXNpemU6IDE2 cHg7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBo aWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykg eworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVk KHRydWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdX aW5kb3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAm JiBjb25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9u IHRoZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVt cFJlbmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRo ZXIgdXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1 cyBTIG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9E RVNLVE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAg IFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250 LXNpemUgKDE2ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgY2hlY2sgYm94ZXMgYmVsb3cg YW5kIHRoZSBzdXJyb3VuZGluZyB0ZXh0IHNob3VsZCBiZQorICAgIHJlbmRlcmVkIGF0IHRoZWly IGRlZmF1bHQgZm9udCBzaXplLgorICAgIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25z ZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IKKyAgICBpbmNp ZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLgorPC9kaXY+Cis8ZGl2Pgor ICAgIENoZWNrIG9uZSBvciBtb3JlOgorICAgIDxpbnB1dCB0eXBlPSJjaGVja2JveCIgbmFtZT0i dmVoaWNsZSIgdmFsdWU9IkJpa2UiPkkgaGF2ZSBhIGJpa2U8YnIvPgorICAgIDxpbnB1dCB0eXBl PSJjaGVja2JveCIgbmFtZT0idmVoaWNsZSIgdmFsdWU9IkNhciI+SSBoYXZlIGEgY2FyIDxici8+ Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVs ZW1lbnQtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zv cm0tY29udHJvbHMtYXV0b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMC4uOWUwMzBkODI0MTE2N2QwZDYyN2Y1OGRkZGViNWU3ZGQ2MTgwNzlhZAotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29u dHJvbHMtYXV0b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKQEAgLTAs MCArMSwzNCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1l PSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAg Zm9udC1zaXplOiAxNnB4OworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAg b3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8L2hlYWQ+Cis8Ym9keT4KKwor PGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRoaXMgcGFyYWdyYXBoIHNob3Vs ZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250LXNpemUgKDE2ICogODAwLzMyMCks CisgICAgd2hlcmVhcyB0aGUgcmFkaW8gYnV0dG9ucyBiZWxvdyBhbmQgdGhlIHN1cnJvdW5kaW5n IHRleHQgc2hvdWxkIGJlCisgICAgcmVuZGVyZWQgYXQgdGhlaXIgZGVmYXVsdCBmb250IHNpemUu CisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5n IGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvcgorICAgIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0 IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+CisgICAgU2VsZWN0IG9uZSBvZjo8 YnIvPgorICAgIDxpbnB1dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMSIgY2hlY2tlZD0iY2hlY2tl ZCIvPgorICAgIDxsYWJlbCBmb3I9InJhZGlvMSI+UmFkaW8xPC9sYWJlbD48YnIvPgorICAgIDxp bnB1dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMiIvPgorICAgIDxsYWJlbCBmb3I9InJhZGlvMiI+ UmFkaW8yPC9sYWJlbD48YnIvPgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3Np emluZy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0 b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctcmFkaW8taW5wdXQtZWxlbWVudC5odG1s Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjM3NmY2Mjk2ZGQ1MWY0ZDgyNGI3ZDVhMTIwMjc4NTJmOTI3ZGNmYjMKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNv bnRyb2xzLWF1dG9zaXppbmctcmFkaW8taW5wdXQtZWxlbWVudC5odG1sCkBAIC0wLDAgKzEsNDMg QEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3Bv cnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIGZvbnQtc2l6 ZTogMTZweDsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93 LXk6IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4KKworPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJu YWxzKSB7CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ0Vu YWJsZWQodHJ1ZSk7CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3Np emluZ1dpbmRvd1NpemVPdmVycmlkZSgzMjAsIDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRvdy5jb25z b2xlICYmIGNvbnNvbGUud2FybikgeworICAgIGNvbnNvbGUud2FybigiVGhpcyB0ZXN0IGRlcGVu ZHMgb24gdGhlIFRleHQgQXV0b3NpemluZyBzZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1biBpdCBp biBEdW1wUmVuZGVyVHJlZSwgb3IgbWFudWFsbHkgZW5hYmxlIFRleHQgQXV0b3NpemluZywgYW5k IGVpdGhlciB1c2UgYSBtb2JpbGUgZGV2aWNlIHdpdGggMzIwcHggZGV2aWNlLXdpZHRoIChsaWtl IE5leHVzIFMgb3IgaVBob25lKSwgb3IgZGVmaW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRPU0laSU5H X09OX0RFU0tUT1AuIik7Cit9Cis8L3NjcmlwdD4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+ CisgICAgVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCB0byA0MHB4IGNvbXB1dGVk IGZvbnQtc2l6ZSAoMTYgKiA4MDAvMzIwKSwKKyAgICB3aGVyZWFzIHRoZSByYWRpbyBidXR0b25z IGJlbG93IGFuZCB0aGUgc3Vycm91bmRpbmcgdGV4dCBzaG91bGQgYmUKKyAgICByZW5kZXJlZCBh dCB0aGVpciBkZWZhdWx0IGZvbnQgc2l6ZS4KKyAgICBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1l dCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yCisg ICAgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwvZGl2Pgor PGRpdj4KKyAgICBTZWxlY3Qgb25lIG9mOjxici8+CisgICAgPGlucHV0IHR5cGU9InJhZGlvIiBp ZD0icmFkaW8xIiBjaGVja2VkPSJjaGVja2VkIi8+CisgICAgPGxhYmVsIGZvcj0icmFkaW8xIj5S YWRpbzE8L2xhYmVsPjxici8+CisgICAgPGlucHV0IHR5cGU9InJhZGlvIiBpZD0icmFkaW8yIi8+ CisgICAgPGxhYmVsIGZvcj0icmFkaW8yIj5SYWRpbzI8L2xhYmVsPjxici8+Cis8L2Rpdj4KKwor PC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9z aXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50LWV4cGVjdGVkLmh0 bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9z aXppbmctc2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lYWU1ZTNiZGRj Njg5NTVkNzlmNmVmMjg0ODZiNGZhYzMxODYxZDE0Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXNlbGVj dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKQEAgLTAsMCArMSwzNSBAQAorPCFET0NUWVBFIGh0bWw+ Cis8aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9 ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgZm9udC1zaXplOiAxNnB4OworICAgIHdpZHRo OiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8 L3N0eWxlPgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVy ZW0iPgorICAgIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21w dXRlZCBmb250LXNpemUgKDE2ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgc2VsZWN0aW9u IGJveCBhbmQgaXRzIGNvcnJlc3BvbmRpbmcgdGV4dCBiZWxvdyBzaG91bGQgYmUKKyAgICByZW5k ZXJlZCBhdCB0aGVpciBkZWZhdWx0IGZvbnQgc2l6ZS4KKyAgICBMb3JlbSBpcHN1bSBkb2xvciBz aXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVt cG9yCisgICAgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwv ZGl2PgorPGRpdj4KKyAgICBTZWxlY3Rpb246CisgICAgPHNlbGVjdD4KKyAgICAgICAgPG9wdGlv biBzZWxlY3RlZCB2YWx1ZT1kZWZhdWx0PkRlZmF1bHQ8L29wdGlvbj4KKyAgICAgICAgPG9wdGlv bj5PcHRpb24gMTwvb3B0aW9uPgorICAgICAgICA8b3B0aW9uPk9wdGlvbiAyPC9vcHRpb24+Cisg ICAgPC9zZWxlY3Q+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXNl bGVjdC1lbGVtZW50Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3Jt LWNvbnRyb2xzLWF1dG9zaXppbmctc2VsZWN0LWVsZW1lbnQuaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iNTZk MDZkYWE3OTE5ZDU1ZjM4NTA1ZmFhODg0MGM4MGMzYjhjNzQwCi0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5n LXNlbGVjdC1lbGVtZW50Lmh0bWwKQEAgLTAsMCArMSw0NCBAQAorPCFET0NUWVBFIGh0bWw+Cis8 aHRtbD4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAw Ij4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgZm9udC1zaXplOiAxNnB4OworICAgIHdpZHRoOiA4 MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0 eWxlPgorCis8c2NyaXB0PgoraWYgKHdpbmRvdy5pbnRlcm5hbHMpIHsKKyAgICB3aW5kb3cuaW50 ZXJuYWxzLnNldHRpbmdzLnNldFRleHRBdXRvc2l6aW5nRW5hYmxlZCh0cnVlKTsKKyAgICB3aW5k b3cuaW50ZXJuYWxzLnNldHRpbmdzLnNldFRleHRBdXRvc2l6aW5nV2luZG93U2l6ZU92ZXJyaWRl KDMyMCwgNDgwKTsKK30gZWxzZSBpZiAod2luZG93LmNvbnNvbGUgJiYgY29uc29sZS53YXJuKSB7 CisgICAgY29uc29sZS53YXJuKCJUaGlzIHRlc3QgZGVwZW5kcyBvbiB0aGUgVGV4dCBBdXRvc2l6 aW5nIHNldHRpbmcgYmVpbmcgdHJ1ZSwgc28gcnVuIGl0IGluIER1bXBSZW5kZXJUcmVlLCBvciBt YW51YWxseSBlbmFibGUgVGV4dCBBdXRvc2l6aW5nLCBhbmQgZWl0aGVyIHVzZSBhIG1vYmlsZSBk ZXZpY2Ugd2l0aCAzMjBweCBkZXZpY2Utd2lkdGggKGxpa2UgTmV4dXMgUyBvciBpUGhvbmUpLCBv ciBkZWZpbmUgSEFDS19GT1JDRV9URVhUX0FVVE9TSVpJTkdfT05fREVTS1RPUC4iKTsKK30KKzwv c2NyaXB0PgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdj4KKyAgICBUaGlzIHBhcmFncmFwaCBz aG91bGQgYmUgYXV0b3NpemVkIHRvIDQwcHggY29tcHV0ZWQgZm9udC1zaXplICgxNiAqIDgwMC8z MjApLAorICAgIHdoZXJlYXMgdGhlIHNlbGVjdGlvbiBib3ggYW5kIGl0cyBjb3JyZXNwb25kaW5n IHRleHQgYmVsb3cgc2hvdWxkIGJlCisgICAgcmVuZGVyZWQgYXQgdGhlaXIgZGVmYXVsdCBmb250 IHNpemUuCisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBp c2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvcgorICAgIGluY2lkaWR1bnQgdXQgbGFi b3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+CisgICAgU2VsZWN0aW9u OgorICAgIDxzZWxlY3Q+CisgICAgICAgIDxvcHRpb24gc2VsZWN0ZWQgdmFsdWU9ZGVmYXVsdD5E ZWZhdWx0PC9vcHRpb24+CisgICAgICAgIDxvcHRpb24+T3B0aW9uIDE8L29wdGlvbj4KKyAgICAg ICAgPG9wdGlvbj5PcHRpb24gMjwvb3B0aW9uPgorICAgIDwvc2VsZWN0PgorPC9kaXY+CisKKzwv Ym9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6 aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxlbWVudHMtZXhw ZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRtbApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi5hZjdlZmY2YTM3OWQ4ZWU4MDM0M2YyZGYyZTliNDQ1ZWRlMGZjZTJmCi0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1sCkBAIC0w LDAgKzEsNTAgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKworPG1ldGEgbmFt ZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAg IGZvbnQtc2l6ZTogMTZweDsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAg IG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4KKworPC9oZWFkPgorPGJvZHk+CisK KzxkaXYgc3R5bGU9ImZvbnQtc2l6ZTogMi41cmVtIj4KKyAgICBUaGlzIHBhcmFncmFwaCBzaG91 bGQgYmUgYXV0b3NpemVkIHRvIDQwcHggY29tcHV0ZWQgZm9udC1zaXplICgxNiAqIDgwMC8zMjAp LAorICAgIHdoZXJlYXMgdGhlIGlucHV0IHRleHQgZmllbGRzIGFuZCB0aGVpciBjb3JyZXNwb25k aW5nIHRleHQgYmVsb3cgc2hvdWxkIGJlCisgICAgcmVuZGVyZWQgYXQgdGhlaXIgZGVmYXVsdCBm b250IHNpemUuCisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFk aXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvcgorICAgIGluY2lkaWR1bnQgdXQg bGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKworPGRpdj4KKyAgICA8ZGl2 PgorICAgICAgICBUZXh0CisgICAgICAgIDxpbnB1dCB0eXBlPSJ0ZXh0Ij4KKyAgICA8L2Rpdj4K KyAgICA8ZGl2PgorICAgICAgICBFbWFpbAorICAgICAgICA8aW5wdXQgdHlwZT0iZW1haWwiPgor ICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIE51bWJlcgorICAgICAgICA8aW5wdXQgdHlw ZT0ibnVtYmVyIj4KKyAgICA8L2Rpdj4KKyAgICA8ZGl2PgorICAgICAgICBQYXNzd29yZAorICAg ICAgICA8aW5wdXQgdHlwZT0icGFzc3dvcmQiPgorICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAg ICAgIFVSTAorICAgICAgICA8aW5wdXQgdHlwZT0idXJsIj4KKyAgICA8L2Rpdj4KKzwvZGl2Pgor Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0 b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctdGV4dGZpZWxkLWlucHV0LWVsZW1lbnRz Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1 dG9zaXppbmctdGV4dGZpZWxkLWlucHV0LWVsZW1lbnRzLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZDU5Y2Yy MzJhZmQzZDAzZDk1ZjcxYmRmZDg2NWQxZmM5ZGQzNmFhNwotLS0gL2Rldi9udWxsCisrKyBiL0xh eW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10 ZXh0ZmllbGQtaW5wdXQtZWxlbWVudHMuaHRtbApAQCAtMCwwICsxLDU5IEBACis8IURPQ1RZUEUg aHRtbD4KKzxodG1sPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3 aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICBmb250LXNpemU6IDE2cHg7CisgICAg d2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47Cisg IH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykgeworICAgIHdp bmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOwor ICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXpl T3ZlcnJpZGUoMzIwLCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xl Lndhcm4pIHsKKyAgICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0 IEF1dG9zaXppbmcgc2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRy ZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEg bW9iaWxlIGRldmljZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQ aG9uZSksIG9yIGRlZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIp OworfQorPC9zY3JpcHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAgIFRoaXMgcGFy YWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250LXNpemUgKDE2 ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgaW5wdXQgdGV4dCBmaWVsZHMgYW5kIHRoZWly IGNvcnJlc3BvbmRpbmcgdGV4dCBiZWxvdyBzaG91bGQgYmUKKyAgICByZW5kZXJlZCBhdCB0aGVp ciBkZWZhdWx0IGZvbnQgc2l6ZS4KKyAgICBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29u c2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yCisgICAgaW5j aWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwvZGl2PgorCis8ZGl2 PgorICAgIDxkaXY+CisgICAgICAgIFRleHQKKyAgICAgICAgPGlucHV0IHR5cGU9InRleHQiPgor ICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIEVtYWlsCisgICAgICAgIDxpbnB1dCB0eXBl PSJlbWFpbCI+CisgICAgPC9kaXY+CisgICAgPGRpdj4KKyAgICAgICAgTnVtYmVyCisgICAgICAg IDxpbnB1dCB0eXBlPSJudW1iZXIiPgorICAgIDwvZGl2PgorICAgIDxkaXY+CisgICAgICAgIFBh c3N3b3JkCisgICAgICAgIDxpbnB1dCB0eXBlPSJwYXNzd29yZCI+CisgICAgPC9kaXY+CisgICAg PGRpdj4KKyAgICAgICAgVVJMCisgICAgICAgIDxpbnB1dCB0eXBlPSJ1cmwiPgorICAgIDwvZGl2 PgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4K 180137 2012-12-19 05:03:37 -0800 2012-12-19 05:08:32 -0800 Patch bug-102560-20121219130053.patch text/plain 23522 timvolodine U3VidmVyc2lvbiBSZXZpc2lvbjogMTM4MTE3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTQyNzk2MGUxMmNlMTEz YTgzNjBhYjcxMmI2ZjI4ZTdmNDkwMDgwMS4uMjgzMmExNWM3MzBlYTgzN2I5ODI2N2Q0NGY3MGVi NTYwYWIzOTY0OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDEyLTEyLTE5ICBUaW0g Vm9sb2RpbmUgIDx0aW12b2xvZGluZUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgVGV4dCBBdXRv c2l6aW5nOiBXb3JrIG91dCB3aGF0IHRvIGRvIGFib3V0IGZvcm0gY29udHJvbHMKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwMjU2MAorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIERpc2FsbG93IGF1dG9zaXpp bmcgb2YgZm9ybSBpbnB1dCBjb250cm9scyBsaWtlIGJ1dHRvbnMsIHRleHQgaW5wdXQgZmllbGRz LCBzZWxlY3Rpb24gY29udHJvbHMsIHJhZGlvIGJ1dHRvbnMKKyAgICAgICAgYW5kIGNoZWNrIGJv eGVzLiBUaGlzIGlzIGEgc2hvcnQgdGVybSBzb2x1dGlvbiB0byBhdm9pZCBpbmNvbnNpc3RlbnQg YXV0b3NpemluZyBvZiBmb3JtIGNvbnRyb2xzICh3aGljaCBpcworICAgICAgICB3b3JzZSB0aGFu IG5vdCBhdXRvc2l6aW5nIGF0IGFsbCkuCisKKyAgICAgICAgVGVzdHM6IGZhc3QvdGV4dC1hdXRv c2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMuaHRt bAorICAgICAgICAgICAgICAgZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRv c2l6aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC90 ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVsZW1l bnQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvdGV4 dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxl bWVudHMuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwOgorICAg ICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpmb3JtSW5wdXRUYWdzKToKKyAgICAg ICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OmlzQXV0b3NpemluZ0NvbnRhaW5lcik6CisgICAg ICAgIChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZCk6 CisgICAgICAgIChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpjb250YWluZXJTaG91bGRCZUF1dG9z aXplZCk6CisgICAgICAgIChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpjb250YWluZXJDb250YWlu c09uZU9mVGFncyk6CisgICAgICAgICogcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaDoKKwogMjAx Mi0xMi0xOCAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAg ICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjEzODA5Ny4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcAppbmRleCA1OGVhNmU4MDQ4N2VhZWFkOGE4Yzc5MWZk NTdmY2IyYzFmYjRiNzE5Li40NGZhMjMzZjY3ODI3NmY1NzVkNTQ3OTUwNzcyZWIyYjFhZmY4MWY4 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwCkBAIC0yNSw2 ICsyNSw3IEBACiAjaW5jbHVkZSAiVGV4dEF1dG9zaXplci5oIgogCiAjaW5jbHVkZSAiRG9jdW1l bnQuaCIKKyNpbmNsdWRlICJIVE1MRWxlbWVudC5oIgogI2luY2x1ZGUgIkluc3BlY3Rvckluc3Ry dW1lbnRhdGlvbi5oIgogI2luY2x1ZGUgIkludFNpemUuaCIKICNpbmNsdWRlICJSZW5kZXJPYmpl Y3QuaCIKQEAgLTM1LDE0ICszNiwzMCBAQAogI2luY2x1ZGUgIlN0eWxlSW5oZXJpdGVkRGF0YS5o IgogCiAjaW5jbHVkZSA8YWxnb3JpdGhtPgorI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4K IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCit1c2luZyBuYW1lc3BhY2UgSFRNTE5hbWVzOworCiBz dHJ1Y3QgVGV4dEF1dG9zaXppbmdXaW5kb3dJbmZvIHsKICAgICBJbnRTaXplIHdpbmRvd1NpemU7 CiAgICAgSW50U2l6ZSBtaW5MYXlvdXRTaXplOwogfTsKIAorCitzdGF0aWMgY29uc3QgVmVjdG9y PFF1YWxpZmllZE5hbWU+JiBmb3JtSW5wdXRUYWdzKCkKK3sKKyAgICAvLyBSZXR1cm5zIHRoZSB0 YWdzIGZvciB0aGUgZm9ybSBpbnB1dCBlbGVtZW50cy4KKyAgICBERUZJTkVfU1RBVElDX0xPQ0FM KFZlY3RvcjxRdWFsaWZpZWROYW1lPiwgZm9ybUlucHV0VGFncywgKCkpOworICAgIGlmIChmb3Jt SW5wdXRUYWdzLmlzRW1wdHkoKSkgeworICAgICAgICBmb3JtSW5wdXRUYWdzLmFwcGVuZChpbnB1 dFRhZyk7CisgICAgICAgIGZvcm1JbnB1dFRhZ3MuYXBwZW5kKGJ1dHRvblRhZyk7CisgICAgICAg IGZvcm1JbnB1dFRhZ3MuYXBwZW5kKHNlbGVjdFRhZyk7CisgICAgfQorICAgIHJldHVybiBmb3Jt SW5wdXRUYWdzOworfQorCiBUZXh0QXV0b3NpemVyOjpUZXh0QXV0b3NpemVyKERvY3VtZW50KiBk b2N1bWVudCkKICAgICA6IG1fZG9jdW1lbnQoZG9jdW1lbnQpCiB7CkBAIC0xOTIsNiArMjA5LDEx IEBAIGJvb2wgVGV4dEF1dG9zaXplcjo6aXNBdXRvc2l6aW5nQ29udGFpbmVyKGNvbnN0IFJlbmRl ck9iamVjdCogcmVuZGVyZXIpCiAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICBpZiAocmVuZGVy ZXItPmlzTGlzdEl0ZW0oKSkKICAgICAgICAgcmV0dXJuIHJlbmRlcmVyLT5pc0Zsb2F0aW5nKCkg fHwgcmVuZGVyZXItPmlzT3V0T2ZGbG93UG9zaXRpb25lZCgpOworICAgIC8vIEF2b2lkIGNyZWF0 aW5nIGNvbnRhaW5lcnMgZm9yIHRleHQgd2l0aGluIHRleHQgY29udHJvbHMsIGJ1dHRvbnMsIG9y IDxzZWxlY3Q+IGJ1dHRvbnMuCisgICAgTm9kZSogcGFyZW50Tm9kZSA9IHJlbmRlcmVyLT5wYXJl bnQoKSA/IHJlbmRlcmVyLT5wYXJlbnQoKS0+Z2VuZXJhdGluZ05vZGUoKSA6IDA7CisgICAgaWYg KHBhcmVudE5vZGUgJiYgcGFyZW50Tm9kZS0+aXNFbGVtZW50Tm9kZSgpICYmIGZvcm1JbnB1dFRh Z3MoKS5jb250YWlucyh0b0VsZW1lbnQocGFyZW50Tm9kZSktPnRhZ1FOYW1lKCkpKQorICAgICAg ICByZXR1cm4gZmFsc2U7CisKICAgICByZXR1cm4gdHJ1ZTsKIH0KIApAQCAtMjQyLDcgKzI2NCw3 IEBAIGJvb2wgVGV4dEF1dG9zaXplcjo6aXNBdXRvc2l6aW5nQ2x1c3Rlcihjb25zdCBSZW5kZXJP YmplY3QqIG9iamVjdCkKICAgICByZXR1cm4gaXNBdXRvc2l6aW5nQ29udGFpbmVyKG9iamVjdCkg JiYgaXNBdXRvc2l6aW5nQ2x1c3Rlcih0b1JlbmRlckJsb2NrKG9iamVjdCksIDApOwogfQogCi1z dGF0aWMgYm9vbCBjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZChjb25zdCBSZW5kZXJCbG9jayog Y29udGFpbmVyKQorYm9vbCBUZXh0QXV0b3NpemVyOjpjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5l ZChjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyKQogewogICAgIC8vIEZJWE1FOiBQcm9wYWdh dGUgY29uc3RyYWluZWRuZXNzIGRvd24gdGhlIHRyZWUsIHRvIGF2b2lkIGluZWZmaWNpZW50bHkg d2Fsa2luZyBiYWNrIHVwIGZyb20gZWFjaCBib3guCiAgICAgLy8gRklYTUU6IFRoaXMgY29kZSBu ZWVkcyB0byB0YWtlIGludG8gYWNjb3VudCB2ZXJ0aWNhbCB3cml0aW5nIG1vZGVzLgpAQCAtMjY0 LDYgKzI4Niw5IEBAIHN0YXRpYyBib29sIGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnN0 IFJlbmRlckJsb2NrKiBjb250YWluZXIpCiAKIGJvb2wgVGV4dEF1dG9zaXplcjo6Y29udGFpbmVy U2hvdWxkQmVBdXRvc2l6ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lcikKIHsKKyAgICBp ZiAoY29udGFpbmVyQ29udGFpbnNPbmVPZlRhZ3MoY29udGFpbmVyLCBmb3JtSW5wdXRUYWdzKCkp KQorICAgICAgICByZXR1cm4gZmFsc2U7CisKICAgICAvLyBEb24ndCBhdXRvc2l6ZSBibG9jay1s ZXZlbCB0ZXh0IHRoYXQgY2FuJ3Qgd3JhcCAoYXMgaXQncyBsaWtlbHkgdG8KICAgICAvLyBleHBh bmQgc2lkZXdheXMgYW5kIGJyZWFrIHRoZSBwYWdlJ3MgbGF5b3V0KS4KICAgICBpZiAoIWNvbnRh aW5lci0+c3R5bGUoKS0+YXV0b1dyYXAoKSkKQEAgLTI3Miw2ICsyOTcsMjEgQEAgYm9vbCBUZXh0 QXV0b3NpemVyOjpjb250YWluZXJTaG91bGRCZUF1dG9zaXplZChjb25zdCBSZW5kZXJCbG9jayog Y29udGFpbmVyKQogICAgIHJldHVybiAhY29udGVudEhlaWdodElzQ29uc3RyYWluZWQoY29udGFp bmVyKTsKIH0KIAorYm9vbCBUZXh0QXV0b3NpemVyOjpjb250YWluZXJDb250YWluc09uZU9mVGFn cyhjb25zdCBSZW5kZXJCbG9jayogY29udGFpbmVyLCBjb25zdCBWZWN0b3I8UXVhbGlmaWVkTmFt ZT4mIHRhZ3MpCit7CisgICAgY29uc3QgUmVuZGVyT2JqZWN0KiByZW5kZXJlciA9IGNvbnRhaW5l cjsKKyAgICB3aGlsZSAocmVuZGVyZXIpIHsKKyAgICAgICAgY29uc3QgTm9kZSogcmVuZGVyZXJO b2RlID0gcmVuZGVyZXItPm5vZGUoKTsKKyAgICAgICAgaWYgKHJlbmRlcmVyTm9kZSAmJiByZW5k ZXJlck5vZGUtPmlzRWxlbWVudE5vZGUoKSkgeworICAgICAgICAgICAgaWYgKHRhZ3MuY29udGFp bnModG9FbGVtZW50KHJlbmRlcmVyTm9kZSktPnRhZ1FOYW1lKCkpKQorICAgICAgICAgICAgICAg IHJldHVybiB0cnVlOworICAgICAgICB9CisgICAgICAgIHJlbmRlcmVyID0gbmV4dEluUHJlT3Jk ZXJTa2lwcGluZ0Rlc2NlbmRhbnRzT2ZDb250YWluZXJzKHJlbmRlcmVyLCBjb250YWluZXIpOwor ICAgIH0KKworICAgIHJldHVybiBmYWxzZTsKK30KKwogYm9vbCBUZXh0QXV0b3NpemVyOjpjbHVz dGVyU2hvdWxkQmVBdXRvc2l6ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGJsb2NrQ29udGFpbmluZ0Fs bFRleHQsIGZsb2F0IGJsb2NrV2lkdGgpCiB7CiAgICAgLy8gRG9uJ3QgYXV0b3NpemUgY2x1c3Rl cnMgdGhhdCBjb250YWluIGxlc3MgdGhhbiA0IGxpbmVzIG9mIHRleHQgKGluCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oIGIvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaAppbmRleCA2ZGM5ZGJmM2M1YjkwYzM1YjIwNDll M2NiNTI5YTcwZTBlYzllNDdjLi4xNjhhMjg1Yjk1OGE5NDhlODhhYjYwMGUwYjE3M2QwOTU4MjI5 NDYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmgKQEAgLTI4LDYg KzI4LDcgQEAKIAogI2lmIEVOQUJMRShURVhUX0FVVE9TSVpJTkcpCiAKKyNpbmNsdWRlICJIVE1M TmFtZXMuaCIKICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvUGFz c093blB0ci5oPgogCkBAIC02OSw2ICs3MCw4IEBAIHByaXZhdGU6CiAgICAgc3RhdGljIGJvb2wg aXNBdXRvc2l6aW5nQ2x1c3Rlcihjb25zdCBSZW5kZXJPYmplY3QqKTsKIAogICAgIHN0YXRpYyBi b29sIGNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWlu ZXIpOworICAgIHN0YXRpYyBib29sIGNvbnRhaW5lckNvbnRhaW5zT25lT2ZUYWdzKGNvbnN0IFJl bmRlckJsb2NrKiBjbHVzdGVyLCBjb25zdCBWZWN0b3I8UXVhbGlmaWVkTmFtZT4mIHRhZ3MpOwor ICAgIHN0YXRpYyBib29sIGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnN0IFJlbmRlckJs b2NrKiBjb250YWluZXIpOwogICAgIHN0YXRpYyBib29sIGNsdXN0ZXJTaG91bGRCZUF1dG9zaXpl ZChjb25zdCBSZW5kZXJCbG9jayogYmxvY2tDb250YWluaW5nQWxsVGV4dCwgZmxvYXQgYmxvY2tX aWR0aCk7CiAgICAgc3RhdGljIHZvaWQgbWVhc3VyZURlc2NlbmRhbnRUZXh0V2lkdGgoY29uc3Qg UmVuZGVyQmxvY2sqIGNvbnRhaW5lciwgY29uc3QgUmVuZGVyQmxvY2sqIGJsb2NrQ29udGFpbmlu Z0FsbFRleHQsIGZsb2F0IG1pblRleHRXaWR0aCwgZmxvYXQmIHRleHRXaWR0aCk7CiAKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRl eCA3MWM0MmI2ZWJmYmZlYzE2MzNhY2JkNmVhNDg2M2RjZjIwYzRkOTQyLi5lYjFlYTQzNjkyMGVh MWY1ZTk5MDkyY2MzNjZiNDY0M2YxMzI1NzkxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTIt MTItMTkgIFRpbSBWb2xvZGluZSAgPHRpbXZvbG9kaW5lQGNocm9taXVtLm9yZz4KKworICAgICAg ICBUZXh0IEF1dG9zaXppbmc6IFdvcmsgb3V0IHdoYXQgdG8gZG8gYWJvdXQgZm9ybSBjb250cm9s cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTAyNTYw CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdHMg Zm9yIGZvcm0gaW5wdXQgZWxlbWVudHMgYXV0b3NpemluZy4gQWRkZWQgdGVzdHMgdG8gY2hlY2sg dGhhdCB2YXJpb3VzIGtpbmRzIG9mIGZvcm0gZWxlbWVudHMKKyAgICAgICAgZG9uJ3QgZ2V0IGF1 dG9zaXplZCwgaS5lLiBidXR0b25zLCB0ZXh0YXJlYXMsIGNoZWNrIGJveGVzLCByYWRpbyBidXR0 b24gYW5kIHNlbGVjdGlvbiBtZW51cy4KKworICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5n L2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQu aHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1hdXRvc2l6aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50cy5odG1sOiBBZGRlZC4KKyAgICAgICAg KiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctY2hlY2tib3gt aW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQt YXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctY2hlY2tib3gtaW5wdXQtZWxlbWVu dC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRy b2xzLWF1dG9zaXppbmctcmFkaW8taW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmct cmFkaW8taW5wdXQtZWxlbWVudC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0 b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctc2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQu aHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3Qv dGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQt ZWxlbWVudHMtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9z aXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50cy5o dG1sOiBBZGRlZC4KKwogMjAxMi0xMi0xOCAgSWx5YSBUaWtob25vdnNreSAgPGxvaXNsb0BjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCByZWJhc2VsaW5lIGFmdGVyIHIxMzgwNzUu IFJlbW92ZSBlbnRyaWVzIGZvciBwYXNzaW5nIHRlc3RzIGFuZCBvbmUgYmFkIGV4cGVjdGF0aW9u IGZvciBhIHJlZnRlc3QgYnkgZHByYW5rZUBjaHJvbWl1bS5vcmcKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0 b24taW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1h dXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMt ZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iN2Y5ZmYyYmQ4YzA1YmJiZjI2YTUxYTEyZjIxOTYw ZTllOTVkOGI5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9z aXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50cy1leHBl Y3RlZC5odG1sCkBAIC0wLDAgKzEsNDMgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWwgc3R5bGU9 ImZvbnQtc2l6ZTogMTZweCI+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRl bnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAg ICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8 L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRo aXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250LXNp emUgKDE2ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgYnV0dG9ucyBiZWxvdyBzaG91bGQg YmUgcmVuZGVyZWQgYXQgdGhlaXIgZGVmYXVsdCBmb250IHNpemUgYW5kCisgICAgdGhlIGFjY29t cGFueWluZyB0ZXh0IGJlbG93IHNob3VsZCByZW1haW4gMTZweC4KKyAgICBMb3JlbSBpcHN1bSBk b2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNt b2QKKyAgICB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1 YS4KKzwvZGl2PgorCis8ZGl2PgorICAgIFN1Ym1pdCBidXR0b24KKyAgICA8aW5wdXQgdHlwZT0i c3VibWl0IiB2YWx1ZT0iRmluZCI+Cis8L2Rpdj4KKzxkaXY+CisgICAgU2ltcGxlIGJ1dHRvbgor ICAgIDxpbnB1dCB0eXBlPSJidXR0b24iIHZhbHVlPSJCdXR0b24iPgorPC9kaXY+Cis8ZGl2Pgor ICAgIFJlc2V0IGJ1dHRvbgorICAgIDxpbnB1dCB0eXBlPSJyZXNldCIgdmFsdWU9IlJlc2V0Ij4K KzwvZGl2PgorPGRpdj4KKyAgICBJbmxpbmUgYnV0dG9uCisgICAgPGJ1dHRvbj5JbmxpbmVCdXR0 b248L2J1dHRvbj4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctYnV0 dG9uLWlucHV0LWVsZW1lbnRzLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3Npemlu Zy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctYnV0dG9uLWlucHV0LWVsZW1lbnRzLmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZWMxNmIwYmExNDlkMmU2NmU1M2UxYjQxYWUyZGRjNzIyMTE4MWUwNAotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMuaHRtbApAQCAtMCwwICsxLDUyIEBA Cis8IURPQ1RZUEUgaHRtbD4KKzxodG1sIHN0eWxlPSJmb250LXNpemU6IDE2cHgiPgorPGhlYWQ+ CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgor ICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93 LXk6IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4KKworPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJu YWxzKSB7CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ0Vu YWJsZWQodHJ1ZSk7CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3Np emluZ1dpbmRvd1NpemVPdmVycmlkZSgzMjAsIDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRvdy5jb25z b2xlICYmIGNvbnNvbGUud2FybikgeworICAgIGNvbnNvbGUud2FybigiVGhpcyB0ZXN0IGRlcGVu ZHMgb24gdGhlIFRleHQgQXV0b3NpemluZyBzZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1biBpdCBp biBEdW1wUmVuZGVyVHJlZSwgb3IgbWFudWFsbHkgZW5hYmxlIFRleHQgQXV0b3NpemluZywgYW5k IGVpdGhlciB1c2UgYSBtb2JpbGUgZGV2aWNlIHdpdGggMzIwcHggZGV2aWNlLXdpZHRoIChsaWtl IE5leHVzIFMgb3IgaVBob25lKSwgb3IgZGVmaW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRPU0laSU5H X09OX0RFU0tUT1AuIik7Cit9Cis8L3NjcmlwdD4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+ CisgICAgVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCB0byA0MHB4IGNvbXB1dGVk IGZvbnQtc2l6ZSAoMTYgKiA4MDAvMzIwKSwKKyAgICB3aGVyZWFzIHRoZSBidXR0b25zIGJlbG93 IHNob3VsZCBiZSByZW5kZXJlZCBhdCB0aGVpciBkZWZhdWx0IGZvbnQgc2l6ZSBhbmQKKyAgICB0 aGUgYWNjb21wYW55aW5nIHRleHQgYmVsb3cgc2hvdWxkIHJlbWFpbiAxNnB4LgorICAgIExvcmVt IGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQg ZG8gZWl1c21vZAorICAgIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFn bmEgYWxpcXVhLgorPC9kaXY+CisKKzxkaXY+CisgICAgU3VibWl0IGJ1dHRvbgorICAgIDxpbnB1 dCB0eXBlPSJzdWJtaXQiIHZhbHVlPSJGaW5kIj4KKzwvZGl2PgorPGRpdj4KKyAgICBTaW1wbGUg YnV0dG9uCisgICAgPGlucHV0IHR5cGU9ImJ1dHRvbiIgdmFsdWU9IkJ1dHRvbiI+Cis8L2Rpdj4K KzxkaXY+CisgICAgUmVzZXQgYnV0dG9uCisgICAgPGlucHV0IHR5cGU9InJlc2V0IiB2YWx1ZT0i UmVzZXQiPgorPC9kaXY+Cis8ZGl2PgorICAgIElubGluZSBidXR0b24KKyAgICA8YnV0dG9uPklu bGluZUJ1dHRvbjwvYnV0dG9uPgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3Np emluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRUZXN0cy9m YXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctY2hlY2tib3gtaW5w dXQtZWxlbWVudC1leHBlY3RlZC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjg5MGY5MjdkMTEwODExNGUxYmU5 M2FlMzEwNTdhYzI0ZDZlMjlhMGYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0 L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctY2hlY2tib3gtaW5wdXQt ZWxlbWVudC1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsMzEgQEAKKzwhRE9DVFlQRSBodG1sPgor PGh0bWwgc3R5bGU9ImZvbnQtc2l6ZTogMTZweCI+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmll d3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRo OiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8 L3N0eWxlPgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVy ZW0iPgorICAgIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21w dXRlZCBmb250LXNpemUgKDE2ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgY2hlY2sgYm94 ZXMgYmVsb3cgc2hvdWxkIGJlIHJlbmRlcmVkIGF0IHRoZWlyIGRlZmF1bHQgc2l6ZSBhbmQKKyAg ICB0aGUgYWNjb21wYW55aW5nIHRleHQgYmVsb3cgc2hvdWxkIHJlbWFpbiAxNnB4LgorICAgIExv cmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBz ZWQgZG8gZWl1c21vZCB0ZW1wb3IKKyAgICBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUg bWFnbmEgYWxpcXVhLgorPC9kaXY+Cis8ZGl2PgorICAgIENoZWNrIG9uZSBvciBtb3JlOgorICAg IDxpbnB1dCB0eXBlPSJjaGVja2JveCIgbmFtZT0idmVoaWNsZSIgdmFsdWU9IkJpa2UiPkkgaGF2 ZSBhIGJpa2U8YnIvPgorICAgIDxpbnB1dCB0eXBlPSJjaGVja2JveCIgbmFtZT0idmVoaWNsZSIg dmFsdWU9IkNhciI+SSBoYXZlIGEgY2FyIDxici8+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1s PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250 cm9scy1hdXRvc2l6aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3Rz L2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1jaGVja2JveC1p bnB1dC1lbGVtZW50Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uM2VjNjc2OTU1ZWQ1ODRmNjUzZTUwZmZiMzBm OGQyZTI1MzJmNzFjNQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1h dXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50 Lmh0bWwKQEAgLTAsMCArMSw0MCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbCBzdHlsZT0iZm9u dC1zaXplOiAxNnB4Ij4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0i d2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1h cmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3Jp cHQ+CitpZiAod2luZG93LmludGVybmFscykgeworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGlu Z3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMu c2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOwor fSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xl Lndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBi ZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJs ZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMy MHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNL X0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwv aGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAgIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRv c2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250LXNpemUgKDE2ICogODAwLzMyMCksCisgICAgd2hl cmVhcyB0aGUgY2hlY2sgYm94ZXMgYmVsb3cgc2hvdWxkIGJlIHJlbmRlcmVkIGF0IHRoZWlyIGRl ZmF1bHQgc2l6ZSBhbmQKKyAgICB0aGUgYWNjb21wYW55aW5nIHRleHQgYmVsb3cgc2hvdWxkIHJl bWFpbiAxNnB4LgorICAgIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBh ZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IKKyAgICBpbmNpZGlkdW50IHV0 IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLgorPC9kaXY+Cis8ZGl2PgorICAgIENoZWNr IG9uZSBvciBtb3JlOgorICAgIDxpbnB1dCB0eXBlPSJjaGVja2JveCIgbmFtZT0idmVoaWNsZSIg dmFsdWU9IkJpa2UiPkkgaGF2ZSBhIGJpa2U8YnIvPgorICAgIDxpbnB1dCB0eXBlPSJjaGVja2Jv eCIgbmFtZT0idmVoaWNsZSIgdmFsdWU9IkNhciI+SSBoYXZlIGEgY2FyIDxici8+Cis8L2Rpdj4K KworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1 dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVsZW1lbnQtZXhw ZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYXV0b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uOGRiZGNlY2ExNjFhYzcyM2JkMzk1NDZmNzY2NjU4ZGIyYjA0OTE3OQotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0 b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKQEAgLTAsMCArMSwzMyBA QAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbCBzdHlsZT0iZm9udC1zaXplOiAxNnB4Ij4KKzxoZWFk PgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4K KyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxv dy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2IHN0 eWxlPSJmb250LXNpemU6IDIuNXJlbSI+CisgICAgVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1 dG9zaXplZCB0byA0MHB4IGNvbXB1dGVkIGZvbnQtc2l6ZSAoMTYgKiA4MDAvMzIwKSwKKyAgICB3 aGVyZWFzIHRoZSByYWRpbyBidXR0b25zIGJlbG93IHNob3VsZCBiZSByZW5kZXJlZCBhdCB0aGVp ciBkZWZhdWx0IHNpemUgYW5kCisgICAgdGhlIGFjY29tcGFueWluZyB0ZXh0IGJlbG93IHNob3Vs ZCByZW1haW4gMTZweC4KKyAgICBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0 dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yCisgICAgaW5jaWRpZHVu dCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwvZGl2PgorPGRpdj4KKyAgICBT ZWxlY3Qgb25lIG9mOjxici8+CisgICAgPGlucHV0IHR5cGU9InJhZGlvIiBpZD0icmFkaW8xIiBj aGVja2VkPSJjaGVja2VkIi8+CisgICAgPGxhYmVsIGZvcj0icmFkaW8xIj5SYWRpbzE8L2xhYmVs Pjxici8+CisgICAgPGlucHV0IHR5cGU9InJhZGlvIiBpZD0icmFkaW8yIi8+CisgICAgPGxhYmVs IGZvcj0icmFkaW8yIj5SYWRpbzI8L2xhYmVsPjxici8+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9o dG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1j b250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3Rz L2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1yYWRpby1pbnB1 dC1lbGVtZW50Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjljMWQ0NDAzYmFlZjRjM2QzYWI1ZTg0ODY2NmY4 ZjA3Yjk2NDBjNAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRv c2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0bWwK QEAgLTAsMCArMSw0MiBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbCBzdHlsZT0iZm9udC1zaXpl OiAxNnB4Ij4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9 ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjog MDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+Citp ZiAod2luZG93LmludGVybmFscykgeworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0 VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGlu Z3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOworfSBlbHNl IGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xlLndhcm4o IlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBiZWluZyB0 cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBUZXh0 IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMyMHB4IGRl dmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNLX0ZPUkNF X1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwvaGVhZD4K Kzxib2R5PgorCis8ZGl2PgorICAgIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQg dG8gNDBweCBjb21wdXRlZCBmb250LXNpemUgKDE2ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0 aGUgcmFkaW8gYnV0dG9ucyBiZWxvdyBzaG91bGQgYmUgcmVuZGVyZWQgYXQgdGhlaXIgZGVmYXVs dCBzaXplIGFuZAorICAgIHRoZSBhY2NvbXBhbnlpbmcgdGV4dCBiZWxvdyBzaG91bGQgcmVtYWlu IDE2cHguCisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBp c2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvcgorICAgIGluY2lkaWR1bnQgdXQgbGFi b3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+CisgICAgU2VsZWN0IG9u ZSBvZjo8YnIvPgorICAgIDxpbnB1dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMSIgY2hlY2tlZD0i Y2hlY2tlZCIvPgorICAgIDxsYWJlbCBmb3I9InJhZGlvMSI+UmFkaW8xPC9sYWJlbD48YnIvPgor ICAgIDxpbnB1dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMiIvPgorICAgIDxsYWJlbCBmb3I9InJh ZGlvMiI+UmFkaW8yPC9sYWJlbD48YnIvPgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMt YXV0b3NpemluZy1zZWxlY3QtZWxlbWVudC1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50 LWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYjgyYmFkMzUzMTQ1NzJkZWExOWNlNDUxNjI3Yzk0 MmMwNTBiMzZhZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRv c2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1zZWxlY3QtZWxlbWVudC1leHBlY3RlZC5o dG1sCkBAIC0wLDAgKzEsMzQgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWwgc3R5bGU9ImZvbnQt c2l6ZTogMTZweCI+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9Indp ZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJn aW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8L2hlYWQ+ Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRoaXMgcGFy YWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250LXNpemUgKDE2 ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgc2VsZWN0aW9uIGJveCBzaG91bGQgYmUgcmVu ZGVyZWQgYXQgaXRzIGRlZmF1bHQgc2l6ZSBhbmQKKyAgICB0aGUgYWNjb21wYW55aW5nIHRleHQg YmVsb3cgc2hvdWxkIHJlbWFpbiAxNnB4LgorICAgIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0 LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IKKyAg ICBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLgorPC9kaXY+Cis8 ZGl2PgorICAgIFNlbGVjdGlvbjoKKyAgICA8c2VsZWN0PgorICAgICAgICA8b3B0aW9uIHNlbGVj dGVkIHZhbHVlPWRlZmF1bHQ+RGVmYXVsdDwvb3B0aW9uPgorICAgICAgICA8b3B0aW9uPk9wdGlv biAxPC9vcHRpb24+CisgICAgICAgIDxvcHRpb24+T3B0aW9uIDI8L29wdGlvbj4KKyAgICA8L3Nl bGVjdD4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctc2VsZWN0LWVs ZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYXV0b3NpemluZy1zZWxlY3QtZWxlbWVudC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmFmMTQzYjY0N2Y4 YmZmMzk0ZGVlYTNjMGJlMDlkNzM0MjQ4NDBkNDAKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctc2VsZWN0 LWVsZW1lbnQuaHRtbApAQCAtMCwwICsxLDQzIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sIHN0 eWxlPSJmb250LXNpemU6IDE2cHgiPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBj b250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7 CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4K KworPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJuYWxzKSB7CisgICAgd2luZG93LmludGVybmFs cy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ0VuYWJsZWQodHJ1ZSk7CisgICAgd2luZG93Lmlu dGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ1dpbmRvd1NpemVPdmVycmlkZSgzMjAs IDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRvdy5jb25zb2xlICYmIGNvbnNvbGUud2FybikgeworICAg IGNvbnNvbGUud2FybigiVGhpcyB0ZXN0IGRlcGVuZHMgb24gdGhlIFRleHQgQXV0b3NpemluZyBz ZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1biBpdCBpbiBEdW1wUmVuZGVyVHJlZSwgb3IgbWFudWFs bHkgZW5hYmxlIFRleHQgQXV0b3NpemluZywgYW5kIGVpdGhlciB1c2UgYSBtb2JpbGUgZGV2aWNl IHdpdGggMzIwcHggZGV2aWNlLXdpZHRoIChsaWtlIE5leHVzIFMgb3IgaVBob25lKSwgb3IgZGVm aW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRPU0laSU5HX09OX0RFU0tUT1AuIik7Cit9Cis8L3Njcmlw dD4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+CisgICAgVGhpcyBwYXJhZ3JhcGggc2hvdWxk IGJlIGF1dG9zaXplZCB0byA0MHB4IGNvbXB1dGVkIGZvbnQtc2l6ZSAoMTYgKiA4MDAvMzIwKSwK KyAgICB3aGVyZWFzIHRoZSBzZWxlY3Rpb24gYm94IHNob3VsZCBiZSByZW5kZXJlZCBhdCBpdHMg ZGVmYXVsdCBzaXplIGFuZAorICAgIHRoZSBhY2NvbXBhbnlpbmcgdGV4dCBiZWxvdyBzaG91bGQg cmVtYWluIDE2cHguCisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVy IGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvcgorICAgIGluY2lkaWR1bnQg dXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+CisgICAgU2Vs ZWN0aW9uOgorICAgIDxzZWxlY3Q+CisgICAgICAgIDxvcHRpb24gc2VsZWN0ZWQgdmFsdWU9ZGVm YXVsdD5EZWZhdWx0PC9vcHRpb24+CisgICAgICAgIDxvcHRpb24+T3B0aW9uIDE8L29wdGlvbj4K KyAgICAgICAgPG9wdGlvbj5PcHRpb24gMjwvb3B0aW9uPgorICAgIDwvc2VsZWN0PgorPC9kaXY+ CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1h dXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxlbWVu dHMtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0t Y29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRt bApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi5mMmZlZmEwNzIzNTg4NDBmNmMyNTM3NDkxMDUyZTJhYjVjNjk4ZmQxCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1j b250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1s CkBAIC0wLDAgKzEsNDcgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWwgc3R5bGU9ImZvbnQtc2l6 ZTogMTZweCI+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRo PTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46 IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8L2hlYWQ+Cis8 Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRoaXMgcGFyYWdy YXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250LXNpemUgKDE2ICog ODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgaW5wdXQgdGV4dCBmaWVsZHMgc2hvdWxkIGJlIHJl bmRlcmVkIGF0IHRoZWlyIGRlZmF1bHQgZm9udCBzaXplIGFuZAorICAgIHRoZSBhY2NvbXBhbnlp bmcgdGV4dCBiZWxvdyBzaG91bGQgcmVtYWluIDE2cHguCisgICAgTG9yZW0gaXBzdW0gZG9sb3Ig c2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRl bXBvcgorICAgIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8 L2Rpdj4KKworPGRpdj4KKyAgICBUZXh0CisgICAgPGlucHV0IHR5cGU9InRleHQiIHZhbHVlPSJE ZWZhdWx0IHRleHQiPgorPC9kaXY+Cis8ZGl2PgorICAgIEVtYWlsCisgICAgPGlucHV0IHR5cGU9 ImVtYWlsIj4KKzwvZGl2PgorPGRpdj4KKyAgICBOdW1iZXIKKyAgICA8aW5wdXQgdHlwZT0ibnVt YmVyIj4KKzwvZGl2PgorPGRpdj4KKyAgICBQYXNzd29yZAorICAgIDxpbnB1dCB0eXBlPSJwYXNz d29yZCI+Cis8L2Rpdj4KKzxkaXY+CisgICAgVVJMCisgICAgPGlucHV0IHR5cGU9InVybCI+Cis8 L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90 ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1l bGVtZW50cy5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250 cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50cy5odG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LmE5NzgyNzc5M2Y3ODBkMzcwZjE2ZjJhODk2YWRjYzBiZTJhYzM5NjAKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9z aXppbmctdGV4dGZpZWxkLWlucHV0LWVsZW1lbnRzLmh0bWwKQEAgLTAsMCArMSw1NiBAQAorPCFE T0NUWVBFIGh0bWw+Cis8aHRtbCBzdHlsZT0iZm9udC1zaXplOiAxNnB4Ij4KKzxoZWFkPgorCis8 bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9k eSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBo aWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykg eworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVk KHRydWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdX aW5kb3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAm JiBjb25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9u IHRoZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVt cFJlbmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRo ZXIgdXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1 cyBTIG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9E RVNLVE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAg IFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250 LXNpemUgKDE2ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgaW5wdXQgdGV4dCBmaWVsZHMg c2hvdWxkIGJlIHJlbmRlcmVkIGF0IHRoZWlyIGRlZmF1bHQgZm9udCBzaXplIGFuZAorICAgIHRo ZSBhY2NvbXBhbnlpbmcgdGV4dCBiZWxvdyBzaG91bGQgcmVtYWluIDE2cHguCisgICAgTG9yZW0g aXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBk byBlaXVzbW9kIHRlbXBvcgorICAgIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWdu YSBhbGlxdWEuCis8L2Rpdj4KKworPGRpdj4KKyAgICBUZXh0CisgICAgPGlucHV0IHR5cGU9InRl eHQiIHZhbHVlPSJEZWZhdWx0IHRleHQiPgorPC9kaXY+Cis8ZGl2PgorICAgIEVtYWlsCisgICAg PGlucHV0IHR5cGU9ImVtYWlsIj4KKzwvZGl2PgorPGRpdj4KKyAgICBOdW1iZXIKKyAgICA8aW5w dXQgdHlwZT0ibnVtYmVyIj4KKzwvZGl2PgorPGRpdj4KKyAgICBQYXNzd29yZAorICAgIDxpbnB1 dCB0eXBlPSJwYXNzd29yZCI+Cis8L2Rpdj4KKzxkaXY+CisgICAgVVJMCisgICAgPGlucHV0IHR5 cGU9InVybCI+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgo= 180139 2012-12-19 05:08:39 -0800 2012-12-19 07:35:43 -0800 Patch bug-102560-20121219130555.patch text/plain 23807 timvolodine U3VidmVyc2lvbiBSZXZpc2lvbjogMTM4MTE3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYTQyNzk2MGUxMmNlMTEz YTgzNjBhYjcxMmI2ZjI4ZTdmNDkwMDgwMS4uMjgzMmExNWM3MzBlYTgzN2I5ODI2N2Q0NGY3MGVi NTYwYWIzOTY0OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5IEBACisyMDEyLTEyLTE5ICBUaW0g Vm9sb2RpbmUgIDx0aW12b2xvZGluZUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgVGV4dCBBdXRv c2l6aW5nOiBXb3JrIG91dCB3aGF0IHRvIGRvIGFib3V0IGZvcm0gY29udHJvbHMKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwMjU2MAorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIERpc2FsbG93IGF1dG9zaXpp bmcgb2YgZm9ybSBpbnB1dCBjb250cm9scyBsaWtlIGJ1dHRvbnMsIHRleHQgaW5wdXQgZmllbGRz LCBzZWxlY3Rpb24gY29udHJvbHMsIHJhZGlvIGJ1dHRvbnMKKyAgICAgICAgYW5kIGNoZWNrIGJv eGVzLiBUaGlzIGlzIGEgc2hvcnQgdGVybSBzb2x1dGlvbiB0byBhdm9pZCBpbmNvbnNpc3RlbnQg YXV0b3NpemluZyBvZiBmb3JtIGNvbnRyb2xzICh3aGljaCBpcworICAgICAgICB3b3JzZSB0aGFu IG5vdCBhdXRvc2l6aW5nIGF0IGFsbCkuCisKKyAgICAgICAgVGVzdHM6IGZhc3QvdGV4dC1hdXRv c2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMuaHRt bAorICAgICAgICAgICAgICAgZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRv c2l6aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC90 ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVsZW1l bnQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWwKKyAgICAgICAgICAgICAgIGZhc3QvdGV4 dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxl bWVudHMuaHRtbAorCisgICAgICAgICogcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwOgorICAg ICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpmb3JtSW5wdXRUYWdzKToKKyAgICAg ICAgKFdlYkNvcmU6OlRleHRBdXRvc2l6ZXI6OmlzQXV0b3NpemluZ0NvbnRhaW5lcik6CisgICAg ICAgIChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpjb250ZW50SGVpZ2h0SXNDb25zdHJhaW5lZCk6 CisgICAgICAgIChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpjb250YWluZXJTaG91bGRCZUF1dG9z aXplZCk6CisgICAgICAgIChXZWJDb3JlOjpUZXh0QXV0b3NpemVyOjpjb250YWluZXJDb250YWlu c09uZU9mVGFncyk6CisgICAgICAgICogcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaDoKKwogMjAx Mi0xMi0xOCAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAg ICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjEzODA5Ny4KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9UZXh0QXV0b3NpemVyLmNwcAppbmRleCA1OGVhNmU4MDQ4N2VhZWFkOGE4Yzc5MWZk NTdmY2IyYzFmYjRiNzE5Li45N2UyZDE4NGQ4MmI4ZWYwMjZhMWQ4ZjA2ODZjODZkOTY3MWQ0NGZk IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuY3BwCkBAIC0yNSw2 ICsyNSw3IEBACiAjaW5jbHVkZSAiVGV4dEF1dG9zaXplci5oIgogCiAjaW5jbHVkZSAiRG9jdW1l bnQuaCIKKyNpbmNsdWRlICJIVE1MRWxlbWVudC5oIgogI2luY2x1ZGUgIkluc3BlY3Rvckluc3Ry dW1lbnRhdGlvbi5oIgogI2luY2x1ZGUgIkludFNpemUuaCIKICNpbmNsdWRlICJSZW5kZXJPYmpl Y3QuaCIKQEAgLTM1LDE0ICszNiwzMCBAQAogI2luY2x1ZGUgIlN0eWxlSW5oZXJpdGVkRGF0YS5o IgogCiAjaW5jbHVkZSA8YWxnb3JpdGhtPgorI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4K IAogbmFtZXNwYWNlIFdlYkNvcmUgewogCit1c2luZyBuYW1lc3BhY2UgSFRNTE5hbWVzOworCiBz dHJ1Y3QgVGV4dEF1dG9zaXppbmdXaW5kb3dJbmZvIHsKICAgICBJbnRTaXplIHdpbmRvd1NpemU7 CiAgICAgSW50U2l6ZSBtaW5MYXlvdXRTaXplOwogfTsKIAorCitzdGF0aWMgY29uc3QgVmVjdG9y PFF1YWxpZmllZE5hbWU+JiBmb3JtSW5wdXRUYWdzKCkKK3sKKyAgICAvLyBSZXR1cm5zIHRoZSB0 YWdzIGZvciB0aGUgZm9ybSBpbnB1dCBlbGVtZW50cy4KKyAgICBERUZJTkVfU1RBVElDX0xPQ0FM KFZlY3RvcjxRdWFsaWZpZWROYW1lPiwgZm9ybUlucHV0VGFncywgKCkpOworICAgIGlmIChmb3Jt SW5wdXRUYWdzLmlzRW1wdHkoKSkgeworICAgICAgICBmb3JtSW5wdXRUYWdzLmFwcGVuZChpbnB1 dFRhZyk7CisgICAgICAgIGZvcm1JbnB1dFRhZ3MuYXBwZW5kKGJ1dHRvblRhZyk7CisgICAgICAg IGZvcm1JbnB1dFRhZ3MuYXBwZW5kKHNlbGVjdFRhZyk7CisgICAgfQorICAgIHJldHVybiBmb3Jt SW5wdXRUYWdzOworfQorCiBUZXh0QXV0b3NpemVyOjpUZXh0QXV0b3NpemVyKERvY3VtZW50KiBk b2N1bWVudCkKICAgICA6IG1fZG9jdW1lbnQoZG9jdW1lbnQpCiB7CkBAIC0xOTIsNiArMjA5LDEx IEBAIGJvb2wgVGV4dEF1dG9zaXplcjo6aXNBdXRvc2l6aW5nQ29udGFpbmVyKGNvbnN0IFJlbmRl ck9iamVjdCogcmVuZGVyZXIpCiAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICBpZiAocmVuZGVy ZXItPmlzTGlzdEl0ZW0oKSkKICAgICAgICAgcmV0dXJuIHJlbmRlcmVyLT5pc0Zsb2F0aW5nKCkg fHwgcmVuZGVyZXItPmlzT3V0T2ZGbG93UG9zaXRpb25lZCgpOworICAgIC8vIEF2b2lkIGNyZWF0 aW5nIGNvbnRhaW5lcnMgZm9yIHRleHQgd2l0aGluIHRleHQgY29udHJvbHMsIGJ1dHRvbnMsIG9y IDxzZWxlY3Q+IGJ1dHRvbnMuCisgICAgTm9kZSogcGFyZW50Tm9kZSA9IHJlbmRlcmVyLT5wYXJl bnQoKSA/IHJlbmRlcmVyLT5wYXJlbnQoKS0+Z2VuZXJhdGluZ05vZGUoKSA6IDA7CisgICAgaWYg KHBhcmVudE5vZGUgJiYgcGFyZW50Tm9kZS0+aXNFbGVtZW50Tm9kZSgpICYmIGZvcm1JbnB1dFRh Z3MoKS5jb250YWlucyh0b0VsZW1lbnQocGFyZW50Tm9kZSktPnRhZ1FOYW1lKCkpKQorICAgICAg ICByZXR1cm4gZmFsc2U7CisKICAgICByZXR1cm4gdHJ1ZTsKIH0KIApAQCAtMjQyLDcgKzI2NCwz NSBAQCBib29sIFRleHRBdXRvc2l6ZXI6OmlzQXV0b3NpemluZ0NsdXN0ZXIoY29uc3QgUmVuZGVy T2JqZWN0KiBvYmplY3QpCiAgICAgcmV0dXJuIGlzQXV0b3NpemluZ0NvbnRhaW5lcihvYmplY3Qp ICYmIGlzQXV0b3NpemluZ0NsdXN0ZXIodG9SZW5kZXJCbG9jayhvYmplY3QpLCAwKTsKIH0KIAot c3RhdGljIGJvb2wgY29udGVudEhlaWdodElzQ29uc3RyYWluZWQoY29uc3QgUmVuZGVyQmxvY2sq IGNvbnRhaW5lcikKK2Jvb2wgVGV4dEF1dG9zaXplcjo6Y29udGFpbmVyU2hvdWxkQmVBdXRvc2l6 ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGNvbnRhaW5lcikKK3sKKyAgICBpZiAoY29udGFpbmVyQ29u dGFpbnNPbmVPZlRhZ3MoY29udGFpbmVyLCBmb3JtSW5wdXRUYWdzKCkpKQorICAgICAgICByZXR1 cm4gZmFsc2U7CisKKyAgICAvLyBEb24ndCBhdXRvc2l6ZSBibG9jay1sZXZlbCB0ZXh0IHRoYXQg Y2FuJ3Qgd3JhcCAoYXMgaXQncyBsaWtlbHkgdG8KKyAgICAvLyBleHBhbmQgc2lkZXdheXMgYW5k IGJyZWFrIHRoZSBwYWdlJ3MgbGF5b3V0KS4KKyAgICBpZiAoIWNvbnRhaW5lci0+c3R5bGUoKS0+ YXV0b1dyYXAoKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgcmV0dXJuICFjb250ZW50 SGVpZ2h0SXNDb25zdHJhaW5lZChjb250YWluZXIpOworfQorCitib29sIFRleHRBdXRvc2l6ZXI6 OmNvbnRhaW5lckNvbnRhaW5zT25lT2ZUYWdzKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWluZXIs IGNvbnN0IFZlY3RvcjxRdWFsaWZpZWROYW1lPiYgdGFncykKK3sKKyAgICBjb25zdCBSZW5kZXJP YmplY3QqIHJlbmRlcmVyID0gY29udGFpbmVyOworICAgIHdoaWxlIChyZW5kZXJlcikgeworICAg ICAgICBjb25zdCBOb2RlKiByZW5kZXJlck5vZGUgPSByZW5kZXJlci0+bm9kZSgpOworICAgICAg ICBpZiAocmVuZGVyZXJOb2RlICYmIHJlbmRlcmVyTm9kZS0+aXNFbGVtZW50Tm9kZSgpKSB7Cisg ICAgICAgICAgICBpZiAodGFncy5jb250YWlucyh0b0VsZW1lbnQocmVuZGVyZXJOb2RlKS0+dGFn UU5hbWUoKSkpCisgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIH0KKyAgICAg ICAgcmVuZGVyZXIgPSBuZXh0SW5QcmVPcmRlclNraXBwaW5nRGVzY2VuZGFudHNPZkNvbnRhaW5l cnMocmVuZGVyZXIsIGNvbnRhaW5lcik7CisgICAgfQorCisgICAgcmV0dXJuIGZhbHNlOworfQor Citib29sIFRleHRBdXRvc2l6ZXI6OmNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnN0IFJl bmRlckJsb2NrKiBjb250YWluZXIpCiB7CiAgICAgLy8gRklYTUU6IFByb3BhZ2F0ZSBjb25zdHJh aW5lZG5lc3MgZG93biB0aGUgdHJlZSwgdG8gYXZvaWQgaW5lZmZpY2llbnRseSB3YWxraW5nIGJh Y2sgdXAgZnJvbSBlYWNoIGJveC4KICAgICAvLyBGSVhNRTogVGhpcyBjb2RlIG5lZWRzIHRvIHRh a2UgaW50byBhY2NvdW50IHZlcnRpY2FsIHdyaXRpbmcgbW9kZXMuCkBAIC0yNjIsMTYgKzMxMiw2 IEBAIHN0YXRpYyBib29sIGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnN0IFJlbmRlckJs b2NrKiBjb250YWluZXIpCiAgICAgcmV0dXJuIGZhbHNlOwogfQogCi1ib29sIFRleHRBdXRvc2l6 ZXI6OmNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWlu ZXIpCi17Ci0gICAgLy8gRG9uJ3QgYXV0b3NpemUgYmxvY2stbGV2ZWwgdGV4dCB0aGF0IGNhbid0 IHdyYXAgKGFzIGl0J3MgbGlrZWx5IHRvCi0gICAgLy8gZXhwYW5kIHNpZGV3YXlzIGFuZCBicmVh ayB0aGUgcGFnZSdzIGxheW91dCkuCi0gICAgaWYgKCFjb250YWluZXItPnN0eWxlKCktPmF1dG9X cmFwKCkpCi0gICAgICAgIHJldHVybiBmYWxzZTsKLQotICAgIHJldHVybiAhY29udGVudEhlaWdo dElzQ29uc3RyYWluZWQoY29udGFpbmVyKTsKLX0KLQogYm9vbCBUZXh0QXV0b3NpemVyOjpjbHVz dGVyU2hvdWxkQmVBdXRvc2l6ZWQoY29uc3QgUmVuZGVyQmxvY2sqIGJsb2NrQ29udGFpbmluZ0Fs bFRleHQsIGZsb2F0IGJsb2NrV2lkdGgpCiB7CiAgICAgLy8gRG9uJ3QgYXV0b3NpemUgY2x1c3Rl cnMgdGhhdCBjb250YWluIGxlc3MgdGhhbiA0IGxpbmVzIG9mIHRleHQgKGluCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5oIGIvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1RleHRBdXRvc2l6ZXIuaAppbmRleCA2ZGM5ZGJmM2M1YjkwYzM1YjIwNDll M2NiNTI5YTcwZTBlYzllNDdjLi4xNjhhMjg1Yjk1OGE5NDhlODhhYjYwMGUwYjE3M2QwOTU4MjI5 NDYwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvVGV4dEF1dG9zaXplci5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9UZXh0QXV0b3NpemVyLmgKQEAgLTI4LDYg KzI4LDcgQEAKIAogI2lmIEVOQUJMRShURVhUX0FVVE9TSVpJTkcpCiAKKyNpbmNsdWRlICJIVE1M TmFtZXMuaCIKICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvUGFz c093blB0ci5oPgogCkBAIC02OSw2ICs3MCw4IEBAIHByaXZhdGU6CiAgICAgc3RhdGljIGJvb2wg aXNBdXRvc2l6aW5nQ2x1c3Rlcihjb25zdCBSZW5kZXJPYmplY3QqKTsKIAogICAgIHN0YXRpYyBi b29sIGNvbnRhaW5lclNob3VsZEJlQXV0b3NpemVkKGNvbnN0IFJlbmRlckJsb2NrKiBjb250YWlu ZXIpOworICAgIHN0YXRpYyBib29sIGNvbnRhaW5lckNvbnRhaW5zT25lT2ZUYWdzKGNvbnN0IFJl bmRlckJsb2NrKiBjbHVzdGVyLCBjb25zdCBWZWN0b3I8UXVhbGlmaWVkTmFtZT4mIHRhZ3MpOwor ICAgIHN0YXRpYyBib29sIGNvbnRlbnRIZWlnaHRJc0NvbnN0cmFpbmVkKGNvbnN0IFJlbmRlckJs b2NrKiBjb250YWluZXIpOwogICAgIHN0YXRpYyBib29sIGNsdXN0ZXJTaG91bGRCZUF1dG9zaXpl ZChjb25zdCBSZW5kZXJCbG9jayogYmxvY2tDb250YWluaW5nQWxsVGV4dCwgZmxvYXQgYmxvY2tX aWR0aCk7CiAgICAgc3RhdGljIHZvaWQgbWVhc3VyZURlc2NlbmRhbnRUZXh0V2lkdGgoY29uc3Qg UmVuZGVyQmxvY2sqIGNvbnRhaW5lciwgY29uc3QgUmVuZGVyQmxvY2sqIGJsb2NrQ29udGFpbmlu Z0FsbFRleHQsIGZsb2F0IG1pblRleHRXaWR0aCwgZmxvYXQmIHRleHRXaWR0aCk7CiAKZGlmZiAt LWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRl eCA3MWM0MmI2ZWJmYmZlYzE2MzNhY2JkNmVhNDg2M2RjZjIwYzRkOTQyLi5lYjFlYTQzNjkyMGVh MWY1ZTk5MDkyY2MzNjZiNDY0M2YxMzI1NzkxIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMTIt MTItMTkgIFRpbSBWb2xvZGluZSAgPHRpbXZvbG9kaW5lQGNocm9taXVtLm9yZz4KKworICAgICAg ICBUZXh0IEF1dG9zaXppbmc6IFdvcmsgb3V0IHdoYXQgdG8gZG8gYWJvdXQgZm9ybSBjb250cm9s cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTAyNTYw CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdHMg Zm9yIGZvcm0gaW5wdXQgZWxlbWVudHMgYXV0b3NpemluZy4gQWRkZWQgdGVzdHMgdG8gY2hlY2sg dGhhdCB2YXJpb3VzIGtpbmRzIG9mIGZvcm0gZWxlbWVudHMKKyAgICAgICAgZG9uJ3QgZ2V0IGF1 dG9zaXplZCwgaS5lLiBidXR0b25zLCB0ZXh0YXJlYXMsIGNoZWNrIGJveGVzLCByYWRpbyBidXR0 b24gYW5kIHNlbGVjdGlvbiBtZW51cy4KKworICAgICAgICAqIGZhc3QvdGV4dC1hdXRvc2l6aW5n L2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQu aHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1hdXRvc2l6aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50cy5odG1sOiBBZGRlZC4KKyAgICAgICAg KiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctY2hlY2tib3gt aW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQt YXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctY2hlY2tib3gtaW5wdXQtZWxlbWVu dC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRy b2xzLWF1dG9zaXppbmctcmFkaW8taW5wdXQtZWxlbWVudC1leHBlY3RlZC5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBmYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmct cmFkaW8taW5wdXQtZWxlbWVudC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L3RleHQtYXV0 b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctc2VsZWN0LWVsZW1lbnQtZXhwZWN0ZWQu aHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9s cy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZhc3Qv dGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQt ZWxlbWVudHMtZXhwZWN0ZWQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC90ZXh0LWF1dG9z aXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50cy5o dG1sOiBBZGRlZC4KKwogMjAxMi0xMi0xOCAgSWx5YSBUaWtob25vdnNreSAgPGxvaXNsb0BjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCByZWJhc2VsaW5lIGFmdGVyIHIxMzgwNzUu IFJlbW92ZSBlbnRyaWVzIGZvciBwYXNzaW5nIHRlc3RzIGFuZCBvbmUgYmFkIGV4cGVjdGF0aW9u IGZvciBhIHJlZnRlc3QgYnkgZHByYW5rZUBjaHJvbWl1bS5vcmcKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0 b24taW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1h dXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMt ZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iN2Y5ZmYyYmQ4YzA1YmJiZjI2YTUxYTEyZjIxOTYw ZTllOTVkOGI5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9z aXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLWJ1dHRvbi1pbnB1dC1lbGVtZW50cy1leHBl Y3RlZC5odG1sCkBAIC0wLDAgKzEsNDMgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWwgc3R5bGU9 ImZvbnQtc2l6ZTogMTZweCI+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRl bnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAg ICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8 L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRo aXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250LXNp emUgKDE2ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgYnV0dG9ucyBiZWxvdyBzaG91bGQg YmUgcmVuZGVyZWQgYXQgdGhlaXIgZGVmYXVsdCBmb250IHNpemUgYW5kCisgICAgdGhlIGFjY29t cGFueWluZyB0ZXh0IGJlbG93IHNob3VsZCByZW1haW4gMTZweC4KKyAgICBMb3JlbSBpcHN1bSBk b2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNt b2QKKyAgICB0ZW1wb3IgaW5jaWRpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1 YS4KKzwvZGl2PgorCis8ZGl2PgorICAgIFN1Ym1pdCBidXR0b24KKyAgICA8aW5wdXQgdHlwZT0i c3VibWl0IiB2YWx1ZT0iRmluZCI+Cis8L2Rpdj4KKzxkaXY+CisgICAgU2ltcGxlIGJ1dHRvbgor ICAgIDxpbnB1dCB0eXBlPSJidXR0b24iIHZhbHVlPSJCdXR0b24iPgorPC9kaXY+Cis8ZGl2Pgor ICAgIFJlc2V0IGJ1dHRvbgorICAgIDxpbnB1dCB0eXBlPSJyZXNldCIgdmFsdWU9IlJlc2V0Ij4K KzwvZGl2PgorPGRpdj4KKyAgICBJbmxpbmUgYnV0dG9uCisgICAgPGJ1dHRvbj5JbmxpbmVCdXR0 b248L2J1dHRvbj4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctYnV0 dG9uLWlucHV0LWVsZW1lbnRzLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3Npemlu Zy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctYnV0dG9uLWlucHV0LWVsZW1lbnRzLmh0bWwKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZWMxNmIwYmExNDlkMmU2NmU1M2UxYjQxYWUyZGRjNzIyMTE4MWUwNAotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYXV0b3NpemluZy1idXR0b24taW5wdXQtZWxlbWVudHMuaHRtbApAQCAtMCwwICsxLDUyIEBA Cis8IURPQ1RZUEUgaHRtbD4KKzxodG1sIHN0eWxlPSJmb250LXNpemU6IDE2cHgiPgorPGhlYWQ+ CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgor ICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93 LXk6IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4KKworPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJu YWxzKSB7CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ0Vu YWJsZWQodHJ1ZSk7CisgICAgd2luZG93LmludGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3Np emluZ1dpbmRvd1NpemVPdmVycmlkZSgzMjAsIDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRvdy5jb25z b2xlICYmIGNvbnNvbGUud2FybikgeworICAgIGNvbnNvbGUud2FybigiVGhpcyB0ZXN0IGRlcGVu ZHMgb24gdGhlIFRleHQgQXV0b3NpemluZyBzZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1biBpdCBp biBEdW1wUmVuZGVyVHJlZSwgb3IgbWFudWFsbHkgZW5hYmxlIFRleHQgQXV0b3NpemluZywgYW5k IGVpdGhlciB1c2UgYSBtb2JpbGUgZGV2aWNlIHdpdGggMzIwcHggZGV2aWNlLXdpZHRoIChsaWtl IE5leHVzIFMgb3IgaVBob25lKSwgb3IgZGVmaW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRPU0laSU5H X09OX0RFU0tUT1AuIik7Cit9Cis8L3NjcmlwdD4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+ CisgICAgVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1dG9zaXplZCB0byA0MHB4IGNvbXB1dGVk IGZvbnQtc2l6ZSAoMTYgKiA4MDAvMzIwKSwKKyAgICB3aGVyZWFzIHRoZSBidXR0b25zIGJlbG93 IHNob3VsZCBiZSByZW5kZXJlZCBhdCB0aGVpciBkZWZhdWx0IGZvbnQgc2l6ZSBhbmQKKyAgICB0 aGUgYWNjb21wYW55aW5nIHRleHQgYmVsb3cgc2hvdWxkIHJlbWFpbiAxNnB4LgorICAgIExvcmVt IGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQg ZG8gZWl1c21vZAorICAgIHRlbXBvciBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFn bmEgYWxpcXVhLgorPC9kaXY+CisKKzxkaXY+CisgICAgU3VibWl0IGJ1dHRvbgorICAgIDxpbnB1 dCB0eXBlPSJzdWJtaXQiIHZhbHVlPSJGaW5kIj4KKzwvZGl2PgorPGRpdj4KKyAgICBTaW1wbGUg YnV0dG9uCisgICAgPGlucHV0IHR5cGU9ImJ1dHRvbiIgdmFsdWU9IkJ1dHRvbiI+Cis8L2Rpdj4K KzxkaXY+CisgICAgUmVzZXQgYnV0dG9uCisgICAgPGlucHV0IHR5cGU9InJlc2V0IiB2YWx1ZT0i UmVzZXQiPgorPC9kaXY+Cis8ZGl2PgorICAgIElubGluZSBidXR0b24KKyAgICA8YnV0dG9uPklu bGluZUJ1dHRvbjwvYnV0dG9uPgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3Np emluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRUZXN0cy9m YXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctY2hlY2tib3gtaW5w dXQtZWxlbWVudC1leHBlY3RlZC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjg5MGY5MjdkMTEwODExNGUxYmU5 M2FlMzEwNTdhYzI0ZDZlMjlhMGYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0 L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctY2hlY2tib3gtaW5wdXQt ZWxlbWVudC1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsMzEgQEAKKzwhRE9DVFlQRSBodG1sPgor PGh0bWwgc3R5bGU9ImZvbnQtc2l6ZTogMTZweCI+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmll d3BvcnQiIGNvbnRlbnQ9IndpZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRo OiA4MDBweDsKKyAgICBtYXJnaW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8 L3N0eWxlPgorCis8L2hlYWQ+Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVy ZW0iPgorICAgIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21w dXRlZCBmb250LXNpemUgKDE2ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgY2hlY2sgYm94 ZXMgYmVsb3cgc2hvdWxkIGJlIHJlbmRlcmVkIGF0IHRoZWlyIGRlZmF1bHQgc2l6ZSBhbmQKKyAg ICB0aGUgYWNjb21wYW55aW5nIHRleHQgYmVsb3cgc2hvdWxkIHJlbWFpbiAxNnB4LgorICAgIExv cmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBz ZWQgZG8gZWl1c21vZCB0ZW1wb3IKKyAgICBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUg bWFnbmEgYWxpcXVhLgorPC9kaXY+Cis8ZGl2PgorICAgIENoZWNrIG9uZSBvciBtb3JlOgorICAg IDxpbnB1dCB0eXBlPSJjaGVja2JveCIgbmFtZT0idmVoaWNsZSIgdmFsdWU9IkJpa2UiPkkgaGF2 ZSBhIGJpa2U8YnIvPgorICAgIDxpbnB1dCB0eXBlPSJjaGVja2JveCIgbmFtZT0idmVoaWNsZSIg dmFsdWU9IkNhciI+SSBoYXZlIGEgY2FyIDxici8+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1s PgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250 cm9scy1hdXRvc2l6aW5nLWNoZWNrYm94LWlucHV0LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3Rz L2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1jaGVja2JveC1p bnB1dC1lbGVtZW50Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uM2VjNjc2OTU1ZWQ1ODRmNjUzZTUwZmZiMzBm OGQyZTI1MzJmNzFjNQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1h dXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1jaGVja2JveC1pbnB1dC1lbGVtZW50 Lmh0bWwKQEAgLTAsMCArMSw0MCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbCBzdHlsZT0iZm9u dC1zaXplOiAxNnB4Ij4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0i d2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1h cmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3Jp cHQ+CitpZiAod2luZG93LmludGVybmFscykgeworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGlu Z3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMu c2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOwor fSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xl Lndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBi ZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJs ZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMy MHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNL X0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwv aGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAgIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRv c2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250LXNpemUgKDE2ICogODAwLzMyMCksCisgICAgd2hl cmVhcyB0aGUgY2hlY2sgYm94ZXMgYmVsb3cgc2hvdWxkIGJlIHJlbmRlcmVkIGF0IHRoZWlyIGRl ZmF1bHQgc2l6ZSBhbmQKKyAgICB0aGUgYWNjb21wYW55aW5nIHRleHQgYmVsb3cgc2hvdWxkIHJl bWFpbiAxNnB4LgorICAgIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZWN0ZXR1ciBh ZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IKKyAgICBpbmNpZGlkdW50IHV0 IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLgorPC9kaXY+Cis8ZGl2PgorICAgIENoZWNr IG9uZSBvciBtb3JlOgorICAgIDxpbnB1dCB0eXBlPSJjaGVja2JveCIgbmFtZT0idmVoaWNsZSIg dmFsdWU9IkJpa2UiPkkgaGF2ZSBhIGJpa2U8YnIvPgorICAgIDxpbnB1dCB0eXBlPSJjaGVja2Jv eCIgbmFtZT0idmVoaWNsZSIgdmFsdWU9IkNhciI+SSBoYXZlIGEgY2FyIDxici8+Cis8L2Rpdj4K KworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1 dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVsZW1lbnQtZXhw ZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYXV0b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MC4uOGRiZGNlY2ExNjFhYzcyM2JkMzk1NDZmNzY2NjU4ZGIyYjA0OTE3OQotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0 b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50LWV4cGVjdGVkLmh0bWwKQEAgLTAsMCArMSwzMyBA QAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbCBzdHlsZT0iZm9udC1zaXplOiAxNnB4Ij4KKzxoZWFk PgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4K KyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxv dy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2IHN0 eWxlPSJmb250LXNpemU6IDIuNXJlbSI+CisgICAgVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIGF1 dG9zaXplZCB0byA0MHB4IGNvbXB1dGVkIGZvbnQtc2l6ZSAoMTYgKiA4MDAvMzIwKSwKKyAgICB3 aGVyZWFzIHRoZSByYWRpbyBidXR0b25zIGJlbG93IHNob3VsZCBiZSByZW5kZXJlZCBhdCB0aGVp ciBkZWZhdWx0IHNpemUgYW5kCisgICAgdGhlIGFjY29tcGFueWluZyB0ZXh0IGJlbG93IHNob3Vs ZCByZW1haW4gMTZweC4KKyAgICBMb3JlbSBpcHN1bSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0 dXIgYWRpcGlzaWNpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yCisgICAgaW5jaWRpZHVu dCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1YS4KKzwvZGl2PgorPGRpdj4KKyAgICBT ZWxlY3Qgb25lIG9mOjxici8+CisgICAgPGlucHV0IHR5cGU9InJhZGlvIiBpZD0icmFkaW8xIiBj aGVja2VkPSJjaGVja2VkIi8+CisgICAgPGxhYmVsIGZvcj0icmFkaW8xIj5SYWRpbzE8L2xhYmVs Pjxici8+CisgICAgPGlucHV0IHR5cGU9InJhZGlvIiBpZD0icmFkaW8yIi8+CisgICAgPGxhYmVs IGZvcj0icmFkaW8yIj5SYWRpbzI8L2xhYmVsPjxici8+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9o dG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1j b250cm9scy1hdXRvc2l6aW5nLXJhZGlvLWlucHV0LWVsZW1lbnQuaHRtbCBiL0xheW91dFRlc3Rz L2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1yYWRpby1pbnB1 dC1lbGVtZW50Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjljMWQ0NDAzYmFlZjRjM2QzYWI1ZTg0ODY2NmY4 ZjA3Yjk2NDBjNAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRv c2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1yYWRpby1pbnB1dC1lbGVtZW50Lmh0bWwK QEAgLTAsMCArMSw0MiBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbCBzdHlsZT0iZm9udC1zaXpl OiAxNnB4Ij4KKzxoZWFkPgorCis8bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9 ODAwIj4KKzxzdHlsZT4KKyAgYm9keSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjog MDsKKyAgICBvdmVyZmxvdy15OiBoaWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+Citp ZiAod2luZG93LmludGVybmFscykgeworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0 VGV4dEF1dG9zaXppbmdFbmFibGVkKHRydWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGlu Z3Muc2V0VGV4dEF1dG9zaXppbmdXaW5kb3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOworfSBlbHNl IGlmICh3aW5kb3cuY29uc29sZSAmJiBjb25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xlLndhcm4o IlRoaXMgdGVzdCBkZXBlbmRzIG9uIHRoZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBiZWluZyB0 cnVlLCBzbyBydW4gaXQgaW4gRHVtcFJlbmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBUZXh0 IEF1dG9zaXppbmcsIGFuZCBlaXRoZXIgdXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMyMHB4IGRl dmljZS13aWR0aCAobGlrZSBOZXh1cyBTIG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNLX0ZPUkNF X1RFWFRfQVVUT1NJWklOR19PTl9ERVNLVE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwvaGVhZD4K Kzxib2R5PgorCis8ZGl2PgorICAgIFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQg dG8gNDBweCBjb21wdXRlZCBmb250LXNpemUgKDE2ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0 aGUgcmFkaW8gYnV0dG9ucyBiZWxvdyBzaG91bGQgYmUgcmVuZGVyZWQgYXQgdGhlaXIgZGVmYXVs dCBzaXplIGFuZAorICAgIHRoZSBhY2NvbXBhbnlpbmcgdGV4dCBiZWxvdyBzaG91bGQgcmVtYWlu IDE2cHguCisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBp c2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvcgorICAgIGluY2lkaWR1bnQgdXQgbGFi b3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+CisgICAgU2VsZWN0IG9u ZSBvZjo8YnIvPgorICAgIDxpbnB1dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMSIgY2hlY2tlZD0i Y2hlY2tlZCIvPgorICAgIDxsYWJlbCBmb3I9InJhZGlvMSI+UmFkaW8xPC9sYWJlbD48YnIvPgor ICAgIDxpbnB1dCB0eXBlPSJyYWRpbyIgaWQ9InJhZGlvMiIvPgorICAgIDxsYWJlbCBmb3I9InJh ZGlvMiI+UmFkaW8yPC9sYWJlbD48YnIvPgorPC9kaXY+CisKKzwvYm9keT4KKzwvaHRtbD4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJvbHMt YXV0b3NpemluZy1zZWxlY3QtZWxlbWVudC1leHBlY3RlZC5odG1sIGIvTGF5b3V0VGVzdHMvZmFz dC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXNlbGVjdC1lbGVtZW50 LWV4cGVjdGVkLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYjgyYmFkMzUzMTQ1NzJkZWExOWNlNDUxNjI3Yzk0 MmMwNTBiMzZhZQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRv c2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy1zZWxlY3QtZWxlbWVudC1leHBlY3RlZC5o dG1sCkBAIC0wLDAgKzEsMzQgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWwgc3R5bGU9ImZvbnQt c2l6ZTogMTZweCI+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9Indp ZHRoPTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJn aW46IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8L2hlYWQ+ Cis8Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRoaXMgcGFy YWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250LXNpemUgKDE2 ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgc2VsZWN0aW9uIGJveCBzaG91bGQgYmUgcmVu ZGVyZWQgYXQgaXRzIGRlZmF1bHQgc2l6ZSBhbmQKKyAgICB0aGUgYWNjb21wYW55aW5nIHRleHQg YmVsb3cgc2hvdWxkIHJlbWFpbiAxNnB4LgorICAgIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0 LCBjb25zZWN0ZXR1ciBhZGlwaXNpY2luZyBlbGl0LCBzZWQgZG8gZWl1c21vZCB0ZW1wb3IKKyAg ICBpbmNpZGlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXVhLgorPC9kaXY+Cis8 ZGl2PgorICAgIFNlbGVjdGlvbjoKKyAgICA8c2VsZWN0PgorICAgICAgICA8b3B0aW9uIHNlbGVj dGVkIHZhbHVlPWRlZmF1bHQ+RGVmYXVsdDwvb3B0aW9uPgorICAgICAgICA8b3B0aW9uPk9wdGlv biAxPC9vcHRpb24+CisgICAgICAgIDxvcHRpb24+T3B0aW9uIDI8L29wdGlvbj4KKyAgICA8L3Nl bGVjdD4KKzwvZGl2PgorCis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctc2VsZWN0LWVs ZW1lbnQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0tY29udHJv bHMtYXV0b3NpemluZy1zZWxlY3QtZWxlbWVudC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmFmMTQzYjY0N2Y4 YmZmMzk0ZGVlYTNjMGJlMDlkNzM0MjQ4NDBkNDAKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9zaXppbmctc2VsZWN0 LWVsZW1lbnQuaHRtbApAQCAtMCwwICsxLDQzIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sIHN0 eWxlPSJmb250LXNpemU6IDE2cHgiPgorPGhlYWQ+CisKKzxtZXRhIG5hbWU9InZpZXdwb3J0IiBj b250ZW50PSJ3aWR0aD04MDAiPgorPHN0eWxlPgorICBib2R5IHsKKyAgICB3aWR0aDogODAwcHg7 CisgICAgbWFyZ2luOiAwOworICAgIG92ZXJmbG93LXk6IGhpZGRlbjsKKyAgfQorPC9zdHlsZT4K KworPHNjcmlwdD4KK2lmICh3aW5kb3cuaW50ZXJuYWxzKSB7CisgICAgd2luZG93LmludGVybmFs cy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ0VuYWJsZWQodHJ1ZSk7CisgICAgd2luZG93Lmlu dGVybmFscy5zZXR0aW5ncy5zZXRUZXh0QXV0b3NpemluZ1dpbmRvd1NpemVPdmVycmlkZSgzMjAs IDQ4MCk7Cit9IGVsc2UgaWYgKHdpbmRvdy5jb25zb2xlICYmIGNvbnNvbGUud2FybikgeworICAg IGNvbnNvbGUud2FybigiVGhpcyB0ZXN0IGRlcGVuZHMgb24gdGhlIFRleHQgQXV0b3NpemluZyBz ZXR0aW5nIGJlaW5nIHRydWUsIHNvIHJ1biBpdCBpbiBEdW1wUmVuZGVyVHJlZSwgb3IgbWFudWFs bHkgZW5hYmxlIFRleHQgQXV0b3NpemluZywgYW5kIGVpdGhlciB1c2UgYSBtb2JpbGUgZGV2aWNl IHdpdGggMzIwcHggZGV2aWNlLXdpZHRoIChsaWtlIE5leHVzIFMgb3IgaVBob25lKSwgb3IgZGVm aW5lIEhBQ0tfRk9SQ0VfVEVYVF9BVVRPU0laSU5HX09OX0RFU0tUT1AuIik7Cit9Cis8L3Njcmlw dD4KKworPC9oZWFkPgorPGJvZHk+CisKKzxkaXY+CisgICAgVGhpcyBwYXJhZ3JhcGggc2hvdWxk IGJlIGF1dG9zaXplZCB0byA0MHB4IGNvbXB1dGVkIGZvbnQtc2l6ZSAoMTYgKiA4MDAvMzIwKSwK KyAgICB3aGVyZWFzIHRoZSBzZWxlY3Rpb24gYm94IHNob3VsZCBiZSByZW5kZXJlZCBhdCBpdHMg ZGVmYXVsdCBzaXplIGFuZAorICAgIHRoZSBhY2NvbXBhbnlpbmcgdGV4dCBiZWxvdyBzaG91bGQg cmVtYWluIDE2cHguCisgICAgTG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVy IGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvcgorICAgIGluY2lkaWR1bnQg dXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8L2Rpdj4KKzxkaXY+CisgICAgU2Vs ZWN0aW9uOgorICAgIDxzZWxlY3Q+CisgICAgICAgIDxvcHRpb24gc2VsZWN0ZWQgdmFsdWU9ZGVm YXVsdD5EZWZhdWx0PC9vcHRpb24+CisgICAgICAgIDxvcHRpb24+T3B0aW9uIDE8L29wdGlvbj4K KyAgICAgICAgPG9wdGlvbj5PcHRpb24gMjwvb3B0aW9uPgorICAgIDwvc2VsZWN0PgorPC9kaXY+ CisKKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1h dXRvc2l6aW5nL2Zvcm0tY29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxlbWVu dHMtZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvdGV4dC1hdXRvc2l6aW5nL2Zvcm0t Y29udHJvbHMtYXV0b3NpemluZy10ZXh0ZmllbGQtaW5wdXQtZWxlbWVudHMtZXhwZWN0ZWQuaHRt bApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi5mMmZlZmEwNzIzNTg4NDBmNmMyNTM3NDkxMDUyZTJhYjVjNjk4ZmQxCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1j b250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50cy1leHBlY3RlZC5odG1s CkBAIC0wLDAgKzEsNDcgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWwgc3R5bGU9ImZvbnQtc2l6 ZTogMTZweCI+Cis8aGVhZD4KKworPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRo PTgwMCI+Cis8c3R5bGU+CisgIGJvZHkgeworICAgIHdpZHRoOiA4MDBweDsKKyAgICBtYXJnaW46 IDA7CisgICAgb3ZlcmZsb3cteTogaGlkZGVuOworICB9Cis8L3N0eWxlPgorCis8L2hlYWQ+Cis8 Ym9keT4KKworPGRpdiBzdHlsZT0iZm9udC1zaXplOiAyLjVyZW0iPgorICAgIFRoaXMgcGFyYWdy YXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250LXNpemUgKDE2ICog ODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgaW5wdXQgdGV4dCBmaWVsZHMgc2hvdWxkIGJlIHJl bmRlcmVkIGF0IHRoZWlyIGRlZmF1bHQgZm9udCBzaXplIGFuZAorICAgIHRoZSBhY2NvbXBhbnlp bmcgdGV4dCBiZWxvdyBzaG91bGQgcmVtYWluIDE2cHguCisgICAgTG9yZW0gaXBzdW0gZG9sb3Ig c2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRl bXBvcgorICAgIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuCis8 L2Rpdj4KKworPGRpdj4KKyAgICBUZXh0CisgICAgPGlucHV0IHR5cGU9InRleHQiIHZhbHVlPSJE ZWZhdWx0IHRleHQiPgorPC9kaXY+Cis8ZGl2PgorICAgIEVtYWlsCisgICAgPGlucHV0IHR5cGU9 ImVtYWlsIj4KKzwvZGl2PgorPGRpdj4KKyAgICBOdW1iZXIKKyAgICA8aW5wdXQgdHlwZT0ibnVt YmVyIj4KKzwvZGl2PgorPGRpdj4KKyAgICBQYXNzd29yZAorICAgIDxpbnB1dCB0eXBlPSJwYXNz d29yZCI+Cis8L2Rpdj4KKzxkaXY+CisgICAgVVJMCisgICAgPGlucHV0IHR5cGU9InVybCI+Cis8 L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC90 ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1l bGVtZW50cy5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC90ZXh0LWF1dG9zaXppbmcvZm9ybS1jb250 cm9scy1hdXRvc2l6aW5nLXRleHRmaWVsZC1pbnB1dC1lbGVtZW50cy5odG1sCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAu LmE5NzgyNzc5M2Y3ODBkMzcwZjE2ZjJhODk2YWRjYzBiZTJhYzM5NjAKLS0tIC9kZXYvbnVsbAor KysgYi9MYXlvdXRUZXN0cy9mYXN0L3RleHQtYXV0b3NpemluZy9mb3JtLWNvbnRyb2xzLWF1dG9z aXppbmctdGV4dGZpZWxkLWlucHV0LWVsZW1lbnRzLmh0bWwKQEAgLTAsMCArMSw1NiBAQAorPCFE T0NUWVBFIGh0bWw+Cis8aHRtbCBzdHlsZT0iZm9udC1zaXplOiAxNnB4Ij4KKzxoZWFkPgorCis8 bWV0YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ODAwIj4KKzxzdHlsZT4KKyAgYm9k eSB7CisgICAgd2lkdGg6IDgwMHB4OworICAgIG1hcmdpbjogMDsKKyAgICBvdmVyZmxvdy15OiBo aWRkZW47CisgIH0KKzwvc3R5bGU+CisKKzxzY3JpcHQ+CitpZiAod2luZG93LmludGVybmFscykg eworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdFbmFibGVk KHRydWUpOworICAgIHdpbmRvdy5pbnRlcm5hbHMuc2V0dGluZ3Muc2V0VGV4dEF1dG9zaXppbmdX aW5kb3dTaXplT3ZlcnJpZGUoMzIwLCA0ODApOworfSBlbHNlIGlmICh3aW5kb3cuY29uc29sZSAm JiBjb25zb2xlLndhcm4pIHsKKyAgICBjb25zb2xlLndhcm4oIlRoaXMgdGVzdCBkZXBlbmRzIG9u IHRoZSBUZXh0IEF1dG9zaXppbmcgc2V0dGluZyBiZWluZyB0cnVlLCBzbyBydW4gaXQgaW4gRHVt cFJlbmRlclRyZWUsIG9yIG1hbnVhbGx5IGVuYWJsZSBUZXh0IEF1dG9zaXppbmcsIGFuZCBlaXRo ZXIgdXNlIGEgbW9iaWxlIGRldmljZSB3aXRoIDMyMHB4IGRldmljZS13aWR0aCAobGlrZSBOZXh1 cyBTIG9yIGlQaG9uZSksIG9yIGRlZmluZSBIQUNLX0ZPUkNFX1RFWFRfQVVUT1NJWklOR19PTl9E RVNLVE9QLiIpOworfQorPC9zY3JpcHQ+CisKKzwvaGVhZD4KKzxib2R5PgorCis8ZGl2PgorICAg IFRoaXMgcGFyYWdyYXBoIHNob3VsZCBiZSBhdXRvc2l6ZWQgdG8gNDBweCBjb21wdXRlZCBmb250 LXNpemUgKDE2ICogODAwLzMyMCksCisgICAgd2hlcmVhcyB0aGUgaW5wdXQgdGV4dCBmaWVsZHMg c2hvdWxkIGJlIHJlbmRlcmVkIGF0IHRoZWlyIGRlZmF1bHQgZm9udCBzaXplIGFuZAorICAgIHRo ZSBhY2NvbXBhbnlpbmcgdGV4dCBiZWxvdyBzaG91bGQgcmVtYWluIDE2cHguCisgICAgTG9yZW0g aXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBk byBlaXVzbW9kIHRlbXBvcgorICAgIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWdu YSBhbGlxdWEuCis8L2Rpdj4KKworPGRpdj4KKyAgICBUZXh0CisgICAgPGlucHV0IHR5cGU9InRl eHQiIHZhbHVlPSJEZWZhdWx0IHRleHQiPgorPC9kaXY+Cis8ZGl2PgorICAgIEVtYWlsCisgICAg PGlucHV0IHR5cGU9ImVtYWlsIj4KKzwvZGl2PgorPGRpdj4KKyAgICBOdW1iZXIKKyAgICA8aW5w dXQgdHlwZT0ibnVtYmVyIj4KKzwvZGl2PgorPGRpdj4KKyAgICBQYXNzd29yZAorICAgIDxpbnB1 dCB0eXBlPSJwYXNzd29yZCI+Cis8L2Rpdj4KKzxkaXY+CisgICAgVVJMCisgICAgPGlucHV0IHR5 cGU9InVybCI+Cis8L2Rpdj4KKworPC9ib2R5PgorPC9odG1sPgo=