170272 2017-03-29 23:50:10 -0700 Add a test to ensure <mo> paints its leading and trailing space as specified in its attributes. 2018-01-04 01:55:13 -0800 1 1 1 Unclassified WebKit MathML Safari Technology Preview Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 lambda lambda alex buildbot commit-queue dbarton dbates ews-watchlist fred.wang rego webkit-bug-importer oldest_to_newest 1292714 0 305839 lambda 2017-03-29 23:50:10 -0700 Created attachment 305839 An arrow operator with unnecessary left space I note that there is a large, observable space before an arrow character inside a <mo> element, as in the attached document (basically $X \to Y$). More clearly, one can inspect the <mo> element in the Inspector to find the extra space to the left of an arrow. I am not sure if this is the result of ruling the <mo> as a prefix or postfix, but according to the specification for MathML 3, an operator in the middle of a <mrow> should be treated as an infix, given that all other lookup information is absent (https://www.w3.org/TR/MathML/chapter3.html#presm.formdefval). The issue is tested against both Safari and Safari Technology Preview. I have installed STIX 2, but since Safari uses the old STIX fonts, this seems not a font-specific issue. I also tested the same code in Firefox, and the spacing is normal. I have tested it against multiple arrow characters, from normal "RIGHTWARDS ARROW" to long right arrow to the $\mapsto$ arrow. The issue is of importance as people type morphisms everywhere ("Let $\phi: A \to B$ be ..."). 1292720 1 lambda 2017-03-30 00:00:47 -0700 I checked the Operator Dictionary, in which arrows are indeed treated as infix operators. I have no idea where the issue could be, then. Is there any easy way to get started with WebKit’s MathML code base? I have some experience with C++ in general and tried to comprehend some part of WebKit but failed. 1292741 2 fred.wang 2017-03-30 00:59:05 -0700 Hi, You can play with lspace, rspace and form attributes on the <mo> element. Indeed, in Epiphany the default spacing seems incorrect, although I have not checked the operator dictionary. I'd suggest to compare https://trac.webkit.org/browser/trunk/Source/WebCore/mathml/MathMLOperatorDictionary.cpp and https://www.w3.org/TR/MathML3/appendixc.html to see if there is an error. If not, you'll have to debug the parsing in https://trac.webkit.org/browser/trunk/Source/WebCore/mathml/MathMLOperatorElement.cpp to see what's happening. 1292745 3 fred.wang 2017-03-30 01:12:17 -0700 OK checking the dictionary, the default spacing is actually correct (lspace = rspace = 5). If you don't want the space, you can use <mo lspace="0em" rspace="0em">. The issue seems to be how the stretched operator is drawn. Compare <mo stretchy="true> VS <mo stretchy="true>. In that case, you'll have to look into WebCore/rendering/mathml/ and more precisely RenderMathMLOperator.cpp and MathOperator.cpp 1293509 4 lambda 2017-04-01 18:47:28 -0700 I believe I have found the issue, but since I am not familiar with the code, I am not sure what is the right way to fix it. In RenderMathMLOpeartor.cpp, line 290 - 311: > void RenderMathMLOperator::paint(PaintInfo& info, const LayoutPoint& paintOffset) > { > RenderMathMLToken::paint(info, paintOffset); > if (!useMathOperator()) > return; > > LayoutPoint operatorTopLeft = paintOffset + location(); > operatorTopLeft.move(style().isLeftToRightDirection() ? leadingSpace() : trailingSpace(), 0); > > // Center horizontal operators. > if (!isVertical()) > operatorTopLeft.move(-(m_mathOperator.width() - width()) / 2, 0); > > m_mathOperator.paint(style(), info, operatorTopLeft); > } For the un-stretchy operator, useMathOperator() returns false and the code ends at the fifth line. The paintOffset is { x = 512, y = 512 } (which depends on the specific HTML I am using). Later in RenderBlock::paint(), it will be adjusted to { x = 796, y = 512 }, where 796 - 512 = 284 is the leading space, I believe (there is some space around the operator). However, for the stretchy operator, the code continues. location() returns nothing. leadingSpace() gives 284. m_mathOperator.width() gives 790, width() gives 1538. Note that (1538 - 790) / 2 = 284. In other words, by adding the leadingSpace() the operator is already centered. Centering horizontal operators again actually moves the operator towards right by 284. I believe the “center horizontal operators” part is unnecessary, or should be grounded by something like > auto contentWidth = width() - leadingSpace - trailingSpace(); > operatorTopLeft.move(-(m_mathOperator.width() - contentWidth) / 2, 0); I am not sure, however, this gives the correct semantics, as I am truly unfamiliar with the code. Moreover, it seems that the vertical positioning for stretchy operator is also wrong. I will keep inspecting the code. 1293601 5 fred.wang 2017-04-03 00:43:29 -0700 (In reply to Minsheng Liu from comment #4) > > auto contentWidth = width() - leadingSpace - trailingSpace(); > > operatorTopLeft.move(-(m_mathOperator.width() - contentWidth) / 2, 0); Right, I think this makes more sense than the current code (although I don't exactly remember what is the reference point for strechy operator painting). At least, this will be compatible with the current code when lspace=rspace=0 which is the case for accents (see e.g. https://bug-72828-attachments.webkit.org/attachment.cgi?id=229368). BTW, we have various tests in LayoutTests/mathml/ ; I think you should check whether they won't be broken by your changes (or will need a small rebaseline) and add a new one for the present use case. 1293610 6 alex 2017-04-03 01:25:50 -0700 (In reply to Minsheng Liu from comment #4) > I believe I have found the issue, but since I am not familiar with the code, > I am not sure what is the right way to fix it. In RenderMathMLOpeartor.cpp, > line 290 - 311: > > > void RenderMathMLOperator::paint(PaintInfo& info, const LayoutPoint& paintOffset) > > { > > RenderMathMLToken::paint(info, paintOffset); > > if (!useMathOperator()) > > return; > > > > LayoutPoint operatorTopLeft = paintOffset + location(); > > operatorTopLeft.move(style().isLeftToRightDirection() ? leadingSpace() : trailingSpace(), 0); > > > > // Center horizontal operators. > > if (!isVertical()) > > operatorTopLeft.move(-(m_mathOperator.width() - width()) / 2, 0); > > I also wonder why are we doing this part of the layout in the paint method, probably we should try to move to the layout if we don't find any real limitation. This could be also the problem, as you found leadingSpace is a calculation already centered and we are centering again in the paint. Maybe just try to move that to the layout and see if that is already done. As Fred said run the tests because there are a lot of cases to consider in this code. 1293611 7 lambda 2017-04-03 01:36:15 -0700 Thanks for the feedback. I will look at it when I have more time later this week. However, I do have some question regarding the tests, as I am completely new to WebKit hacking. Hours ago, I run a WebKit test on my modified build. While there were many issues, none of them were related with MathML. I expect at least some diffs in MathML tests. Are MathML tests in LayoutTests/ automated or manual? What is the right way to see whether I have broken existing *MathML* code or not? (In reply to Alejandro G. Castro from comment #6) > (In reply to Minsheng Liu from comment #4) > > I believe I have found the issue, but since I am not familiar with the code, > > I am not sure what is the right way to fix it. In RenderMathMLOpeartor.cpp, > > line 290 - 311: > > > > > void RenderMathMLOperator::paint(PaintInfo& info, const LayoutPoint& paintOffset) > > > { > > > RenderMathMLToken::paint(info, paintOffset); > > > if (!useMathOperator()) > > > return; > > > > > > LayoutPoint operatorTopLeft = paintOffset + location(); > > > operatorTopLeft.move(style().isLeftToRightDirection() ? leadingSpace() : trailingSpace(), 0); > > > > > > // Center horizontal operators. > > > if (!isVertical()) > > > operatorTopLeft.move(-(m_mathOperator.width() - width()) / 2, 0); > > > > > I also wonder why are we doing this part of the layout in the paint method, > probably we should try to move to the layout if we don't find any real > limitation. This could be also the problem, as you found leadingSpace is a > calculation already centered and we are centering again in the paint. Maybe > just try to move that to the layout and see if that is already done. As Fred > said run the tests because there are a lot of cases to consider in this code. 1293612 8 fred.wang 2017-04-03 01:59:27 -0700 (In reply to Alejandro G. Castro from comment #6) > I also wonder why are we doing this part of the layout in the paint method, > probably we should try to move to the layout if we don't find any real > limitation. This could be also the problem, as you found leadingSpace is a > calculation already centered and we are centering again in the paint. Maybe > just try to move that to the layout and see if that is already done. IIRC, the layout part calculates the preferred width and width (left space + right space + content width). However, for stretchy operators we paint them ourselves, so we have to do some special positioning of glyphs, mirroring (RTL) etc. It seems the reference point for the painting is the center of the operator (which probably makes thing easier to applies a scale transform in RTL). Probably things can be simplified as many things are inherited for the old implementations, but I don't remember exactly. 1293613 9 fred.wang 2017-04-03 02:06:33 -0700 (In reply to Minsheng Liu from comment #7) > Thanks for the feedback. I will look at it when I have more time later this > week. > > However, I do have some question regarding the tests, as I am completely new > to WebKit hacking. Hours ago, I run a WebKit test on my modified build. > While there were many issues, none of them were related with MathML. I > expect at least some diffs in MathML tests. Are MathML tests in LayoutTests/ > automated or manual? What is the right way to see whether I have broken > existing *MathML* code or not? On which platform do you work? Tests are executed automatically with the run-webkit-tests (you can restrict execution to Layout/mathml/). Two things to note: 1) It is possible that our test coverage is limited and hence does not detect your changes, that's why we always add new tests when we fix a bug. 2) There are some tests (pixel tests) which compare against an expected render tree (txt file) and visual rendering (PNG image). However, if your code changes visual rendering but to the render tree, the test runner will still consider the test to pass. That's very likely to be the case if you only modify RenderMathMLToken::paint here. That's why it's often better to use reftests or javascript tests. 1370783 10 lambda 2017-11-12 14:13:39 -0800 I am sorry that I have been inactive for the last several months. Now that I finally get some free time, I plan to re-investigate the matter. All past MathML layout tests are passed, and I am about to insert a new one. As for Alejandro’s advice, I am learning the rendering process of WebKit. Hopefully this bug could be resolved soon. 1370787 11 lambda 2017-11-12 14:31:34 -0800 In fact, I think the centering process should be removed entirely. In RenderMathMLOperator::layoutBlock, we have if (useMathOperator()) { for (auto child = firstChildBox(); child; child = child->nextSiblingBox()) child->layoutIfNeeded(); setLogicalWidth(leadingSpaceValue + m_mathOperator.width() + trailingSpaceValue); setLogicalHeight(m_mathOperator.ascent() + m_mathOperator.descent()); } else { // irrelevant, as the buggy code only concerns cases where `useMathOperator() = true`. } So, logicalWidth, which is just width when we are in horizontal writing mode, is just the sum of operator width, leading space, and trailing space. Hence, it makes no sense to do centering. It is already centered! // Center horizontal operators. if (!isVertical()) operatorTopLeft.move(-(m_mathOperator.width() - width()) / 2, 0); I will just remove the code, which does not lead to any regression. 1370790 12 lambda 2017-11-12 15:05:07 -0800 Forget my last post. I did not run the pixel level tests. Sorry but I am very unfamiliar with the WebKit infrastructure. 1370805 13 326734 lambda 2017-11-12 18:21:43 -0800 Created attachment 326734 a proposed patch Truly stretched operator requires the special centering code I proposed to delete. The reason is that the stretchTo function does not update the element’s width (but does change that of m_mathOperator). My proposed patch changes that, and everything works fine. Regarding to pixel test regression, I got six failed, but five of them failed without changing any code, so I am not sure if expected images need to be updated. The only case *I think* that is relevant is mathml/opentype/opentype-stretchy-horizontal. My patch passed the pixel test but has different text output (render tree). Nonetheless, I compared patched image output with unmatched output with my eyes and I think the patch gives the correct behavior. I need the following help: 1. I am unsure about how to create a pixel test. I create one, and run the pixel test. It seems that WebKit automatically included it into the test case. Is that all I need to do? How about other platforms where expected images have not been created? 2. How to fix the five failed pixel tests. I am pretty sure that my code does not change the behavior of WebCore (I compared the result with the unmatched build). Do those tests’ expected images need to be updated? 3. What else do I need to do/be careful about before we submit the patch? 1370811 14 326737 lambda 2017-11-12 18:24:30 -0800 Created attachment 326737 comparison on opentype-stretchy-horizontal case Here is a comparison for the opentype-stretchy-horizontal case. With the patch the output are aligned, which according to the test file, should be the correct behavior. 1370890 15 326734 fred.wang 2017-11-13 06:04:03 -0800 Comment on attachment 326734 a proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=326734&action=review This looks good to me and correspond to what Alejandro suggested. But I guess we need more testing. > b/Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp:306 > + You should not do this whitespace change. 1370893 16 fred.wang 2017-11-13 06:30:30 -0800 (In reply to Minsheng Liu from comment #13) > Created attachment 326734 [details] > a proposed patch > > Truly stretched operator requires the special centering code I proposed to > delete. The reason is that the stretchTo function does not update the > element’s width (but does change that of m_mathOperator). My proposed patch > changes that, and everything works fine. > > Regarding to pixel test regression, I got six failed, but five of them > failed without changing any code, so I am not sure if expected images need > to be updated. The only case *I think* that is relevant is > mathml/opentype/opentype-stretchy-horizontal. My patch passed the pixel test > but has different text output (render tree). Nonetheless, I compared patched > image output with unmatched output with my eyes and I think the patch gives > the correct behavior. > > I need the following help: > 1. I am unsure about how to create a pixel test. I create one, and run the > pixel test. It seems that WebKit automatically included it into the test > case. Is that all I need to do? How about other platforms where expected > images have not been created? > > 2. How to fix the five failed pixel tests. I am pretty sure that my code > does not change the behavior of WebCore (I compared the result with the > unmatched build). Do those tests’ expected images need to be updated? > > 3. What else do I need to do/be careful about before we submit the patch? @Minsheng Liu: Thanks a lot for working on this. You did not reply, but are you developing on Linux (e.g. WebKitGTK), macOS, or something else? Sometimes the pixel tests require some specific fonts to be installed. Sometimes they have not been updated and thus just marked "failing". I guess you can ignore existing failures, though. opentype-stretchy-horizontal is supposed to test various ways of stretching operators (base size, variants and assembly). The spacing is irrelevant here and the screenshot you gave still looks good to me. You can check the help of run-webkit-tests to know how re-generate the test expectations for that test (text and png). You can submit your patch to EWS testing. This will build it on various platforms and run tests on macOS & iOS (with some results and test expectations). You can also take a look at https://mdn.mozillademos.org/en-US/docs/Mozilla/MathML_Project/MathML_Torture_Test$samples/MathML_Torture_Test to see if you don't see anything abnormal or if you patch improves things. I think we need to add at least one new test for this bug (i.e. that fails before your patch and passes after). The easiest way is to create a pixel test (again the help fo run-webkit-tests explains how to generate test expectations). However, I would prefer javascript tests or reftests, if possible as they are more reliable and easier to debug later. Here are some random ideas: * A javascript tests that measures sizes & position of some boxes with getBoundingClientRect() to check that the operator is correctly sized/placed. See for example LayoutTests/mathml/presentation/stretchy-depth-height.html for an example. * A reftest with a rectangle that hides the location where you expect the operator to be. See LayoutTests/mathml/presentation/mroot-transform.html for an example. * A mismatch reftest for <mo lspace="0px" rspace="50px">→</mo> VS <mo lspace="50px" rspace="0px">→</mo>. Note: In general try to avoid text in your tests as that may give inaccurate sizes. Use mspace/mpadded with pixel lengths instead. If needed, use the "Ahem" font or some special WOFF fonts to guarantee the expected size. 1370903 17 fred.wang 2017-11-13 07:43:36 -0800 (In reply to Frédéric Wang (:fredw) from comment #16) > You can also take a look at > https://mdn.mozillademos.org/en-US/docs/Mozilla/MathML_Project/ > MathML_Torture_Test$samples/MathML_Torture_Test to see if you don't see > anything abnormal or if you patch improves things. Look at tests 19 and 22. Your patch seriously changes the position of horizontal braces. I guess the real issue is that the munderover render class uses the unstretch sizes to position its children and I suspect this "centering" hack is supposed to workaround that. However, probably the positions of children should really be updated after the stretch. 1370905 18 lambda 2017-11-13 07:50:54 -0800 Aha thanks! I did play around with the Torture Test but did not look at it carefully. The reason I included the OpenType stretchy horizontal case is that a similar issue was found there with <mover>. I will look at it, and the JavaScript test you just mentioned. 1371266 19 lambda 2017-11-13 21:41:07 -0800 Here comes the bad news. If we want to move layout code out of paint(), some non-trivial change is required. For the cases you have mentioned, the DOM involves more than one layer of <mover>. It looks like: \mover{x + ... + x}{\mover{horizontal brace}{k times}} The current logic layouts the structure as follows: 1. layout {x + ... + x}. 2. layout {\mover{horizontal brace}{k times}}. (Note the width is incorrect!} 3. stretch the horizontal brace without updating its location. And fixing everything in operator’s paint(). Despite being ad-hoc—it is unclear to me whether the original fix in paint() is or can be made correct or not—one consequence of this algorithm is that the width of the stretched part of a <mover> element is its original content width. I just checked myself that MathML 3 does not specify the width in such scenario (width is not mentioned at all in the section regarding <munder>/<mover>), but this felt just wrong and would make Inspector very hard to use in inspecting the bounds of those elements. I checked that in Firefox, the width of \mover{horizontal brace}{k times} is the same as that of {x + ... + x}. So, 1. I think we should change the current behavior and use the more natural width, which involve a non-trivial change to the layout algorithm. 2. Since you are more familiar with MathML standard, does the width of a stretched operator affect its parents? If the standard is unclear in this area, should we send something to the committee? — Minsheng 1371290 20 326859 lambda 2017-11-13 22:44:01 -0800 Created attachment 326859 fix the algorithm of layout <mover>/<munder> when stretchy operators are present The fix is simple: I force the layout of all blocks containing stretchy operators. The cost is not that high, as children of those blocks do not need layout and hence all the extra computation is to recalculate the location. Moreover, Inspector now gives the correct bounds of those elements. I have tested the code manually against the torture test and it does not break the original bug, the arrow centering issue. Could you look at my changes and check if I satisfy the coding guidelines? I am not very familiar with C++ and its OOP capabilities, and while I have read the coding style guidelines, I might forget some. But I think the reviewer should handle that anyway. --- About tests. I work on macOS High Sierra. I would like to continue my work but I have to sleep right now. Hopefully I could finish tests before the Friday. I am a third year undergraduate (major in not CS but math) so the course load is not light. 1371291 21 buildbot 2017-11-13 22:46:23 -0800 Attachment 326859 did not pass style-queue: ERROR: Source/WebCore/rendering/mathml/RenderMathMLUnderOver.cpp:39: Streams are highly discouraged. [readability/streams] [3] ERROR: Source/WebCore/rendering/mathml/RenderMathMLUnderOver.cpp:39: Alphabetical sorting problem. [build/include_order] [4] Total errors found: 2 in 1 files If any of these errors are false positives, please file a bug against check-webkit-style. 1371292 22 326860 lambda 2017-11-13 22:51:08 -0800 Created attachment 326860 same patch, ignore the <iostream> 1371334 23 fred.wang 2017-11-14 01:16:15 -0800 (In reply to Minsheng Liu from comment #19) > So, > 1. I think we should change the current behavior and use the more natural > width, which involve a non-trivial change to the layout algorithm. > 2. Since you are more familiar with MathML standard, does the width of a > stretched operator affect its parents? If the standard is unclear in this > area, should we send something to the committee? I believe it indeed *does* affect the width of its parent (otherwise you would paint stretchy operators out of the bounds of munderover) but you can ask confirmation on https://lists.w3.org/Archives/Public/www-math/ BTW, the unofficial draft http://mathml-association.org/MathMLinHTML5/ gives more details in general regarding layout rules. (In reply to Minsheng Liu from comment #20) > Created attachment 326859 [details] > fix the algorithm of layout <mover>/<munder> when stretchy operators are > present Thanks for continuing the effort on this, it's very helpful. So this patch fixes your initial test case, right? What about the centering, do we still need it? I actually wonder whether it was because the actual size of the stretched operator does not necessarily match the target size (so it would still be more beautiful to do a centering... but ignoring lspace/rspace to avoid this bug)? I forgot to mention that Tools/Script/check-webkit-style will do the style check of EWS, so you can run it locally. Also, you can use "Tools/Scripts/prepare-ChangeLog" to format a patch for review ("Tools/Scripts/webkit-patch upload" will do that). I guess it is explained in details in https://webkit.org/contributing-code/ Checking the code, it seems that RenderMathMLUnderOver::computeOperatorsHorizontalStretch is actually only called in RenderMathMLUnderOver::layoutBlock, just before some calls to layoutIfNeeded() on the munderover children... but I believe these layoutIfNeeded calls are useless as we already do the layout in computeOperatorsHorizontalStretch. Also, computeOperatorsHorizontalStretch really does operator stretching and child layout, so the name is not good (I guess this was inherited from old implementation). So I propose you open a preliminary cleanup bug to rename "computeOperatorsHorizontalStretch" to "stretchHorizontalOperatorsAndLayoutChildren" and remove the useless layoutIfNeeded calls, so that things are a bit clearer. That won't require new tests and you would be able to experience the contribution process. I quickly try your patch on the torture test and your change makes WebKit crash on an ASSERT for me: ASSERTION FAILED: !needsLayout() /Users/fred/WebKit/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp(479) : virtual std::optional<int> WebCore::RenderMathMLScripts::firstLineBaseline() const 1 0x10eeed24d WTFCrash 2 0x11639fbac WebCore::RenderMathMLScripts::firstLineBaseline() const 3 0x11638b0d8 WebCore::RenderMathMLBlock::ascentForChild(WebCore::RenderBox const&) 4 0x11639b909 WebCore::RenderMathMLRow::firstLineBaseline() const 5 0x11638b0d8 WebCore::RenderMathMLBlock::ascentForChild(WebCore::RenderBox const&) 6 0x11639b909 WebCore::RenderMathMLRow::firstLineBaseline() const 7 0x115ff77a4 WebCore::RenderBlock::firstLineBaseline() const 8 0x116019045 WebCore::RenderBlockFlow::firstLineBaseline() const 9 0x11629a8e6 WebCore::RenderTableCell::cellBaselinePosition() const 10 0x11629ab1b WebCore::RenderTableCell::layout() 11 0x1162b8dcd WebCore::RenderTableRow::layout() 12 0x115f8cdfc WebCore::RenderElement::layoutIfNeeded() 13 0x1162bd020 WebCore::RenderTableSection::layout() 14 0x115f8cdfc WebCore::RenderElement::layoutIfNeeded() 15 0x1162913ba WebCore::RenderTable::layout() Are you building WebKit in debug mode? (see https://webkit.org/building-webkit/). 1371342 24 fred.wang 2017-11-14 02:13:44 -0800 (In reply to Frédéric Wang (:fredw) from comment #23) > I quickly try your patch on the torture test and your change makes WebKit > crash on an ASSERT for me: > > ASSERTION FAILED: !needsLayout() OK, I stand corrected. It's already reported in bug 174131 1371440 25 lambda 2017-11-14 10:47:52 -0800 > So this patch fixes your initial test case, right? What about the centering, do we still need it? I actually wonder whether it was because the actual size of the stretched operator does not necessarily match the target size (so it would still be more beautiful to do a centering... but ignoring lspace/rspace to avoid this bug)? The updated computeOperatorHorizontalStretch(), plus the fix in stretchTo() that updates the logical width, should match the actual size of the stretched operator with the target size, rendering centering unnecessary. I think our general aim should to match these two sizes as they give better bounds in the Inspector. Therefore, removing the center code once and for all should be fine, and if we find any further issue on those, we could fix them independently. By the way, I think the patch, if accepted, would not get into mainstream Safari until next September, so we have plenty of time to catch them…I am unsure about other platforms. 😂 > So I propose you open a preliminary cleanup bug to rename "computeOperatorsHorizontalStretch" to "stretchHorizontalOperatorsAndLayoutChildren" and remove the useless layoutIfNeeded calls, so that things are a bit clearer. That won't require new tests and you would be able to experience the contribution process. Ok, my plan will be handle them in three steps: 1. Cleanup layout code in RenderMathMLUnderOver.cpp. 2. Rework stretchHorizontalOperatorsAndLayoutChildren() so that it gives correct bounds. This one requires some test using getBoundingClientRect(). 3. Remove the center code and closes this issue. By the way, is there any other environment where an operator might be stretched? If so, I could look at them manually. 1371457 26 fred.wang 2017-11-14 11:09:02 -0800 (In reply to Minsheng Liu from comment #25) > > So this patch fixes your initial test case, right? What about the centering, do we still need it? I actually wonder whether it was because the actual size of the stretched operator does not necessarily match the target size (so it would still be more beautiful to do a centering... but ignoring lspace/rspace to avoid this bug)? > > The updated computeOperatorHorizontalStretch(), plus the fix in stretchTo() > that updates the logical width, should match the actual size of the > stretched operator with the target size, rendering centering unnecessary. I > think our general aim should to match these two sizes as they give better > bounds in the Inspector. Therefore, removing the center code once and for > all should be fine, and if we find any further issue on those, we could fix > them independently. So my point is that we have non-streching elements providing a target size, then we stretch the operator to be *at least* that target size. We use the base size, size variants or glyph assembly but we can not necessarily match the target size. I think the logical width should match the stretched size, though. > > By the way, I think the patch, if accepted, would not get into mainstream > Safari until next September, so we have plenty of time to catch them…I am > unsure about other platforms. 😂 Well, I think we can't say anything per https://trac.webkit.org/wiki/FAQ#WillfeatureXXXbeincludedinthenextreleaseofSafari > Ok, my plan will be handle them in three steps: > > 1. Cleanup layout code in RenderMathMLUnderOver.cpp. > 2. Rework stretchHorizontalOperatorsAndLayoutChildren() so that it gives > correct bounds. This one requires some test using getBoundingClientRect(). > 3. Remove the center code and closes this issue. Sounds good to me, thanks. > By the way, is there any other environment where an operator might be > stretched? If so, I could look at them manually. Yes, for example vertical operators in <mrow>. Search for "stretchTo" in rendering/mathml 1371467 27 lambda 2017-11-14 11:14:21 -0800 > I think the logical width should match the stretched size, though. Oh good! I mistook your target size for logical size. > Well, I think we can't say anything per https://trac.webkit.org/wiki/FAQ#WillfeatureXXXbeincludedinthenextreleaseofSafari Hahahahahahahaha. True. 1380110 28 lambda 2017-12-10 18:54:47 -0800 @fred As you might have noticed, I have deleted the “centering” code in the paint() method in the other patch (179682), so the bug is gone. I plan to add a pixel test for this issue, how do you think? 1380164 29 fred.wang 2017-12-11 02:29:22 -0800 (In reply to Minsheng Liu from comment #28) > @fred As you might have noticed, I have deleted the “centering” code in the > paint() method in the other patch (179682), so the bug is gone. I plan to > add a pixel test for this issue, how do you think? Please finish https://bugs.webkit.org/show_bug.cgi?id=179682#c76 first ;-) As you might have noticed, pixel tests are easy to write but a pain to deal with, so I'd prefer you write javascript tests or reftests instead. See comment 16 for suggestions. 1380210 30 lambda 2017-12-11 08:46:16 -0800 (In reply to Frédéric Wang (:fredw) from comment #29) > (In reply to Minsheng Liu from comment #28) > > @fred As you might have noticed, I have deleted the “centering” code in the > > paint() method in the other patch (179682), so the bug is gone. I plan to > > add a pixel test for this issue, how do you think? > > Please finish https://bugs.webkit.org/show_bug.cgi?id=179682#c76 first ;-) > > As you might have noticed, pixel tests are easy to write but a pain to deal > with, so I'd prefer you write javascript tests or reftests instead. See > comment 16 for suggestions. I doubt that any getBoundingRect() could work as the fault is on paint(). The render tree before and after the other patch for simple operator case should be the same. I will give reftests a try after my final today is dealt with. 1384849 31 330229 lambda 2017-12-27 23:13:53 -0800 Created attachment 330229 Patch 1385016 32 330229 dbates 2017-12-31 19:16:59 -0800 Comment on attachment 330229 Patch Thanks for the test, Minsheng! Very minor, we should add a new line at the end of file mo-arrow-painted-center.html and it would be good to add <html>/</html> tags to both files. 1385018 33 lambda 2017-12-31 19:19:08 -0800 (In reply to Daniel Bates from comment #32) > Comment on attachment 330229 [details] > Patch > > Thanks for the test, Minsheng! > > Very minor, we should add a new line at the end of file > mo-arrow-painted-center.html and it would be good to add <html>/</html> tags > to both files. You are absolutely right. Just a few minutes! 1385020 34 330272 lambda 2017-12-31 19:28:49 -0800 Created attachment 330272 Patch 1385041 35 fred.wang 2018-01-01 00:44:56 -0800 Thanks for finishing the work on this Minsheng. Some quick comments: - "<mo> is painted correctly" is vague. Can you provide more details in the bug summary and description? If I remember correctly the issue was that operator spacing was incorrect for horizontally stretched operators, because some centering was performed before? And also maybe because the logical width was incorrect too? - Is <mo lspace="100px" rspace="100px"> a good case? It seems that it won't be affected by the old "centering" behavior? I guess you want to check a case where lspace != rspace e.g. <mo lspace="100px" and rspace="200px">? - While we are here, maybe test the RTL case too with <math dir="rtl">? - I would put some visible <mspace> elements before and after the <mo> operator, so that one can really see the operator spacing. Actually, you could use such <mspace> elements to indicate the reference 100px/200px widths. - red/green is generally used to suggest failure/success, so the reference widths could have more neutral colors. See http://web-platform-tests.org/writing-tests/rendering.html 1385373 36 lambda 2018-01-02 20:13:17 -0800 Sorry that I cannot get to you sooner. > - "<mo> is painted correctly" is vague. Agreed. > - Is <mo lspace="100px" rspace="100px"> a good case? It seems that it won't > be affected by the old "centering" behavior? Actually it is fine. The old behavior is add a center offset (lspace plus rspace divided by 2) to the existing lspace. The effect of that code to the test case I propose would be having a left space of 200px and right space of 0px. Though I do agree with you that we could add three different cases, where left = right left < right left > right > - While we are here, maybe test the RTL case too with <math dir="rtl">? And double the three to six. > - I would put some visible <mspace> elements before and after the <mo> > operator, so that one can really see the operator spacing. Actually, you > could use such <mspace> elements to indicate the reference 100px/200px > widths. My intention was to have them aligned so that a vertical comparison is possible. But you are right that the operator spacing would be hard to see in this case. I might change it to have a combination of both. > - red/green is generally used to suggest failure/success, so the reference > widths could have more neutral colors. See > http://web-platform-tests.org/writing-tests/rendering.html I was not aware of that : ) (In reply to Frédéric Wang (:fredw) [back 03/01/2018] from comment #35) > Thanks for finishing the work on this Minsheng. Some quick comments: > > - "<mo> is painted correctly" is vague. Can you provide more details in the > bug summary and description? If I remember correctly the issue was that > operator spacing was incorrect for horizontally stretched operators, because > some centering was performed before? And also maybe because the logical > width was incorrect too? > > - Is <mo lspace="100px" rspace="100px"> a good case? It seems that it won't > be affected by the old "centering" behavior? I guess you want to check a > case where lspace != rspace e.g. <mo lspace="100px" and rspace="200px">? > > - While we are here, maybe test the RTL case too with <math dir="rtl">? > > - I would put some visible <mspace> elements before and after the <mo> > operator, so that one can really see the operator spacing. Actually, you > could use such <mspace> elements to indicate the reference 100px/200px > widths. > > - red/green is generally used to suggest failure/success, so the reference > widths could have more neutral colors. See > http://web-platform-tests.org/writing-tests/rendering.html 1385461 37 330392 lambda 2018-01-03 09:16:45 -0800 Created attachment 330392 Patch 1385483 38 330392 fred.wang 2018-01-03 09:55:52 -0800 Comment on attachment 330392 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=330392&action=review > LayoutTests/mathml/presentation/mo-paint-lspace-rspace-expected.html:19 > + <p>The test passes if the arrow has a left space of 50px, which is as wide as the black block to the left, 150px > LayoutTests/mathml/presentation/mo-paint-lspace-rspace-expected.html:34 > + <<mspace width="200px" height="10px" depth="10px" mathbackground="black"></mspace> extra < > LayoutTests/mathml/presentation/mo-paint-lspace-rspace-expected.html:43 > + right/left are inverted in RTL mode. > LayoutTests/mathml/presentation/mo-paint-lspace-rspace-expected.html:52 > + <p>The test passes if the arrow has a left space of 50px, which is as wide as the black block to the left, 150px > LayoutTests/mathml/presentation/mo-paint-lspace-rspace.html:17 > + <p>The test passes if the arrow has a left space of 50px, which is as wide as the black block to the left, 150px > LayoutTests/mathml/presentation/mo-paint-lspace-rspace.html:30 > + <<mspace width="200px" height="10px" depth="10px" mathbackground="black"></mspace> extra < > LayoutTests/mathml/presentation/mo-paint-lspace-rspace.html:36 > + and a right space of 200px, which is as wide as the black block to the right.</p> right/left should be inverted in RTL mode (note that MathML3 defines lspace as "leading space" and rspace as "trailing space") > LayoutTests/mathml/presentation/mo-paint-lspace-rspace.html:44 > + <p>The test passes if the arrow has a left space of 50px, which is as wide as the black block to the left, 150px 1385650 39 330429 lambda 2018-01-03 18:59:25 -0800 Created attachment 330429 Patch 1385652 40 lambda 2018-01-03 19:01:18 -0800 That is indeed a lot of typos. I have rephrased the language to using leading/trailing space, but keep the "black block to the left/right" (adjusted for RTL and LTR) to make it easier for human readers. I also added two headings. (In reply to Frédéric Wang (:fredw) [back 03/01/2018] from comment #38) > Comment on attachment 330392 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=330392&action=review > > > LayoutTests/mathml/presentation/mo-paint-lspace-rspace-expected.html:19 > > + <p>The test passes if the arrow has a left space of 50px, which is as wide as the black block to the left, > > 150px > > > LayoutTests/mathml/presentation/mo-paint-lspace-rspace-expected.html:34 > > + <<mspace width="200px" height="10px" depth="10px" mathbackground="black"></mspace> > > extra < > > > LayoutTests/mathml/presentation/mo-paint-lspace-rspace-expected.html:43 > > + > > right/left are inverted in RTL mode. > > > LayoutTests/mathml/presentation/mo-paint-lspace-rspace-expected.html:52 > > + <p>The test passes if the arrow has a left space of 50px, which is as wide as the black block to the left, > > 150px > > > LayoutTests/mathml/presentation/mo-paint-lspace-rspace.html:17 > > + <p>The test passes if the arrow has a left space of 50px, which is as wide as the black block to the left, > > 150px > > > LayoutTests/mathml/presentation/mo-paint-lspace-rspace.html:30 > > + <<mspace width="200px" height="10px" depth="10px" mathbackground="black"></mspace> > > extra < > > > LayoutTests/mathml/presentation/mo-paint-lspace-rspace.html:36 > > + and a right space of 200px, which is as wide as the black block to the right.</p> > > right/left should be inverted in RTL mode > > (note that MathML3 defines lspace as "leading space" and rspace as "trailing > space") > > > LayoutTests/mathml/presentation/mo-paint-lspace-rspace.html:44 > > + <p>The test passes if the arrow has a left space of 50px, which is as wide as the black block to the left, > > 150px 1385751 41 330429 fred.wang 2018-01-04 01:27:30 -0800 Comment on attachment 330429 Patch LGTM, Thanks! 1385753 42 330429 commit-queue 2018-01-04 01:48:55 -0800 Comment on attachment 330429 Patch Clearing flags on attachment: 330429 Committed r226403: <https://trac.webkit.org/changeset/226403> 1385754 43 commit-queue 2018-01-04 01:48:57 -0800 All reviewed patches have been landed. Closing bug. 1385755 44 webkit-bug-importer 2018-01-04 01:49:25 -0800 <rdar://problem/36293853> 305839 2017-03-29 23:50:10 -0700 2017-03-29 23:50:10 -0700 An arrow operator with unnecessary left space arrow-left-space.html text/html 164 lambda PG1ldGEgY2hhcnNldD0idXRmLTgiPgo8bWF0aCBkaXNwbGF5PSJpbmxpbmUiIHhtbG5zPSJodHRw Oi8vd3d3LnczLm9yZy8xOTk4L01hdGgvTWF0aE1MIj4KICA8bXJvdz4KICAgIDxtaT5YPC9taT4K ICAgIDxtbz7ihpI8L21vPgogICAgPG1pPlk8L21pPgogIDwvbXJvdz4KPC9tYXRoPgo= 326734 2017-11-12 18:21:43 -0800 2017-12-27 23:13:36 -0800 a proposed patch RenderMathMLOperator.cpp text/plain 993 lambda LS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL21hdGhtbC9SZW5kZXJNYXRoTUxPcGVyYXRv ci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL21hdGhtbC9SZW5kZXJNYXRoTUxP cGVyYXRvci5jcHAKQEAgLTE2OSw2ICsxNjksNyBAQCB2b2lkIFJlbmRlck1hdGhNTE9wZXJhdG9y OjpzdHJldGNoVG8oTGF5b3V0VW5pdCB3aWR0aCkKICAgICBtX3N0cmV0Y2hXaWR0aCA9IHdpZHRo OwogICAgIG1fbWF0aE9wZXJhdG9yLnN0cmV0Y2hUbyhzdHlsZSgpLCB3aWR0aCk7CiAKKyAgICBz ZXRMb2dpY2FsV2lkdGgobGVhZGluZ1NwYWNlKCkgKyB3aWR0aCArIHRyYWlsaW5nU3BhY2UoKSk7 CiAgICAgc2V0TG9naWNhbEhlaWdodChtX21hdGhPcGVyYXRvci5hc2NlbnQoKSArIG1fbWF0aE9w ZXJhdG9yLmRlc2NlbnQoKSk7CiB9CiAKQEAgLTMwMiwxNCArMzAzLDkgQEAgdm9pZCBSZW5kZXJN YXRoTUxPcGVyYXRvcjo6cGFpbnQoUGFpbnRJbmZvJiBpbmZvLCBjb25zdCBMYXlvdXRQb2ludCYg cGFpbnRPZmZzZXQKICAgICBSZW5kZXJNYXRoTUxUb2tlbjo6cGFpbnQoaW5mbywgcGFpbnRPZmZz ZXQpOwogICAgIGlmICghdXNlTWF0aE9wZXJhdG9yKCkpCiAgICAgICAgIHJldHVybjsKLQorICAg IAogICAgIExheW91dFBvaW50IG9wZXJhdG9yVG9wTGVmdCA9IHBhaW50T2Zmc2V0ICsgbG9jYXRp b24oKTsKICAgICBvcGVyYXRvclRvcExlZnQubW92ZShzdHlsZSgpLmlzTGVmdFRvUmlnaHREaXJl Y3Rpb24oKSA/IGxlYWRpbmdTcGFjZSgpIDogdHJhaWxpbmdTcGFjZSgpLCAwKTsKLQotICAgIC8v IENlbnRlciBob3Jpem9udGFsIG9wZXJhdG9ycy4KLSAgICBpZiAoIWlzVmVydGljYWwoKSkKLSAg ICAgICAgb3BlcmF0b3JUb3BMZWZ0Lm1vdmUoLShtX21hdGhPcGVyYXRvci53aWR0aCgpIC0gd2lk dGgoKSkgLyAyLCAwKTsKLQogICAgIG1fbWF0aE9wZXJhdG9yLnBhaW50KHN0eWxlKCksIGluZm8s IG9wZXJhdG9yVG9wTGVmdCk7CiB9CiAK 326737 2017-11-12 18:24:30 -0800 2017-11-12 18:24:30 -0800 comparison on opentype-stretchy-horizontal case comparison on opentype-stretchy-horizontal case.png image/png 94496 lambda iVBORw0KGgoAAAANSUhEUgAAAeAAAANgCAYAAAD0+7tkAAAKrGlDQ1BJQ0MgUHJvZmlsZQAASImV lgdUU1kax+976Y0WCB1CDUV6B+k1FEE62AgJkFBiSAgqNlQGR2BEERHBMqAjTcFRKSIqYsE2CCjY HZBBRV0HCzbU7IssYWf37O7Z75z77u99ue9/v+/l3XP+AJBvsQSCTFgBgCx+jjAy0Icen5BIx40C IsACJaAKHFlskcA7IiIUIDE7/zXeDwNIOt+0kGr9++//NRQ5KSI2AFAEwskcETsL4RPI6GILhDkA oARI3mBFjkDK5QgrC5ECEa6XctoMd0k5eYb7v6+JjvRF+A8A8GQWS5gGAGkSydNz2WmIDhnpFljz OTw+wl4Ie7C5LA7C+QjPy8paLuXDCJsk/5NO2l80k2WaLFaajGd6+R54P55IkMla9X++jv8dWZni 2T0MkEHmCoMipftJ31vG8hAZ85MXhM8yjzNTk5S54qCYWWaLfBNnmcPyC5llcUaM9yyzhHPP5nGj 42ZZuDxSps/PXBAq009hyjhF5B81y6m8AKasnhxm9Czn8mIXzLIoIypkbi9fWV4ojpTVnCWaqydV GCDrl8tjytbncKODZD2y5mpIEcXLauOk+PnL8vwY2RpBjo9MU5AZMddLZqAsL8qNkj2bg3xss5zO Co6Y04mQ9Qh4IAywADsnZWWOtHjf5YJVQl4aN4fujZyYFDqTz7acR7e1tnECQHr+Zv7et7Tv5wqi XZ3LbWoFwP2MRCI5NZcL2QbAcQYAxP65HGM7APKaAFyuYYuFuTM5tPSCQU62PFAG6kAH+X5MgAWw BY7ADXgBfxAMwkE0SABLARtwQRYQghVgDdgACkEx2AZ2giqwHxwA9eAIOAbaQRc4By6Ba6AfDIH7 YASMgxdgErwH0xAE4SAKRIXUIV3ICDKHbCFnyAPyh0KhSCgBSoLSID4khtZAm6BiqAyqgmqgBuhX 6CR0DroCDUB3oVFoAnoDfYZRMBlWhrVhY9gKdoa94RA4Gl4Cp8HZcB5cAG+FK+Fa+DDcBp+Dr8FD 8Aj8Ap5CARQJRUPpoSxQzihfVDgqEZWKEqLWoYpQFahaVDOqE9WLuokaQb1EfUJj0VQ0HW2BdkMH oWPQbHQ2eh26BF2Frke3oS+gb6JH0ZPobxgKRgtjjnHFMDHxmDTMCkwhpgJzCNOKuYgZwoxj3mOx WBqWgXXCBmETsOnY1dgS7F5sC7YbO4Adw07hcDh1nDnOHReOY+FycIW43bjDuLO4Qdw47iOehNfF 2+ID8Il4Pn4jvgLfiD+DH8Q/xU8TFAhGBFdCOIFDWEUoJRwkdBJuEMYJ00RFIoPoTowmphM3ECuJ zcSLxAfEtyQSSZ/kQlpI4pHySZWko6TLpFHSJ7IS2YzsS15MFpO3kuvI3eS75LcUCsWY4kVJpORQ tlIaKOcpjygf5ahylnJMOY7cerlquTa5QblX8gR5I3lv+aXyefIV8sflb8i/VCAoGCv4KrAU1ilU K5xUuK0wpUhVtFEMV8xSLFFsVLyi+EwJp2Ss5K/EUSpQOqB0XmmMiqIaUH2pbOom6kHqReq4MlaZ ocxUTlcuVj6i3Kc8qaKkYq8Sq7JSpVrltMoIDUUzpjFpmbRS2jHaMO2zqraqt2qK6hbVZtVB1Q9q mmpeailqRWotakNqn9Xp6v7qGerb1dvVH2qgNcw0Fmqs0NincVHjpaayppsmW7NI85jmPS1Yy0wr Umu11gGt61pT2jragdoC7d3a57Vf6tB0vHTSdcp1zuhM6FJ1PXR5uuW6Z3Wf01Xo3vRMeiX9An1S T0svSE+sV6PXpzetz9CP0d+o36L/0IBo4GyQalBu0GMwaahrGGa4xrDJ8J4RwcjZiGu0y6jX6IMx wzjOeLNxu/EzhhqDychjNDEemFBMPE2yTWpNbpliTZ1NM0z3mvabwWYOZlyzarMb5rC5oznPfK/5 wDzMPJd5/Hm1825bkC28LXItmixGLWmWoZYbLdstX1kZWiVabbfqtfpm7WCdaX3Q+r6Nkk2wzUab Tps3tma2bNtq21t2FLsAu/V2HXav7c3tU+z32d9xoDqEOWx26HH46ujkKHRsdpxwMnRKctrjdNtZ 2TnCucT5sgvGxcdlvUuXyydXR9cc12Ouf7pZuGW4Nbo9m8+YnzL/4Pwxd313lnuN+4gH3SPJ42eP EU89T5ZnredjLwMvjtchr6fept7p3oe9X/lY+wh9Wn0++Lr6rvXt9kP5BfoV+fX5K/nH+Ff5PwrQ D0gLaAqYDHQIXB3YHYQJCgnaHnSbqc1kMxuYk8FOwWuDL4SQQ6JCqkIeh5qFCkM7w+Cw4LAdYQ8W GC3gL2gPB+HM8B3hDyMYEdkRpxZiF0YsrF74JNImck1kbxQ1allUY9T7aJ/o0uj7MSYx4pieWPnY xbENsR/i/OLK4kbireLXxl9L0EjgJXQk4hJjEw8lTi3yX7Rz0fhih8WFi4eXMJasXHJlqcbSzKWn l8kvYy07noRJiktqTPrCCmfVsqaSmcl7kifZvuxd7BccL045ZyLFPaUs5Wmqe2pZ6rM097QdaRNc T24F9yXPl1fFe50elL4//UNGeEZdhiQzLrMlC5+VlHWSr8TP4F9YrrN85fIBgbmgUDCS7Zq9M3tS GCI8JIJES0QdOcqI0bkuNhH/IB7N9citzv24InbF8ZWKK/krr68yW7Vl1dO8gLxfVqNXs1f3rNFb s2HN6FrvtTXroHXJ63rWG6wvWD+eH5hfv4G4IWPDbxutN5ZtfLcpblNngXZBfsHYD4E/NBXKFQoL b29227z/R/SPvB/7ttht2b3lWxGn6GqxdXFF8ZcSdsnVn2x+qvxJsjV1a1+pY+m+bdht/G3D2z23 15cpluWVje0I29FWTi8vKn+3c9nOKxX2Fft3EXeJd41UhlZ27DbcvW33lypu1VC1T3XLHq09W/Z8 2MvZO7jPa1/zfu39xfs//8z7+U5NYE1brXFtxQHsgdwDTw7GHuz9xfmXhkMah4oPfa3j143UR9Zf aHBqaGjUaixtgpvETROHFx/uP+J3pKPZormmhdZSfBQcFR99/mvSr8PHQo71HHc+3nzC6MSeVmpr URvUtqptsp3bPtKR0DFwMvhkT6dbZ+spy1N1XXpd1adVTpeeIZ4pOCM5m3d2qlvQ/fJc2rmxnmU9 98/Hn791YeGFvoshFy9fCrh0vte79+xl98tdV1yvnLzqfLX9muO1tusO11t/c/ittc+xr+2G042O fpf+zoH5A2cGPQfP3fS7eekW89a1oQVDA8Mxw3duL749codz59ndzLuv7+Xem76f/wDzoOihwsOK R1qPan83/b1lxHHk9Kjf6PXHUY/vj7HHXvwh+uPLeMETypOKp7pPG57ZPuuaCJjof77o+fgLwYvp l4V/U/zbnlcmr0786fXn9cn4yfHXwteSNyVv1d/WvbN/1zMVMfXofdb76Q9FH9U/1n9y/tT7Oe7z 0+kVX3BfKr+afu38FvLtgSRLIhGwhKzvVgCFDDg1FYA3dQBQEgCgIr6ZuGjGH38PaMbTfyfwn3jG Q38PRwCakUlqhXy7ATiKDGMvAOSQe6klivYCsJ2dbPwjRKl2tjNaZMRlYj5KJG+1AcB1AvBVKJFM 75VIvh5Eir0LQHf2jC+XBhbx7824VDZLc6DTKh/8S/wdyIEIqJJ7zecAAAAJcEhZcwAAFiUAABYl AUlSJPAAAAIEaVRYdFhNTDpjb20uYWRvYmUueG1wAAAAAAA8eDp4bXBtZXRhIHhtbG5zOng9ImFk b2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJYTVAgQ29yZSA1LjQuMCI+CiAgIDxyZGY6UkRGIHhtbG5z OnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAg IDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOmV4aWY9Imh0 dHA6Ly9ucy5hZG9iZS5jb20vZXhpZi8xLjAvIgogICAgICAgICAgICB4bWxuczp0aWZmPSJodHRw Oi8vbnMuYWRvYmUuY29tL3RpZmYvMS4wLyI+CiAgICAgICAgIDxleGlmOlBpeGVsWURpbWVuc2lv bj44NjQ8L2V4aWY6UGl4ZWxZRGltZW5zaW9uPgogICAgICAgICA8ZXhpZjpQaXhlbFhEaW1lbnNp b24+NDgwPC9leGlmOlBpeGVsWERpbWVuc2lvbj4KICAgICAgICAgPHRpZmY6T3JpZW50YXRpb24+ MTwvdGlmZjpPcmllbnRhdGlvbj4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJE Rj4KPC94OnhtcG1ldGE+CrdBFvMAAEAASURBVHgB7L0JtG1ZVaa5Tnfve9F3EEQAQRCKNIYCSSd9 VCF2mUKqI9Uk1WTksEw0xcqy0qzSqpE5RtUopMwsBwqiZtqQpUMtqqBKBFMKdWCDWhIKgQgIQkAA QWNEvOjfu/d09X3/2vu9G6+PePeee2+w1nvnnn32Xs3c8+yz//3POddcg0//3T3L8qDK4EHVbpWb BpoGmgaaBpoGmgZO1MDwxF1tT9NA00DTQNNA00DTwE5rYHziAI3hnqiTtqdp4Bw10H5W56jAFTZ/ kDbBFUrWhnqYaeA4BtzuEg+z77edzl7RQLup75VvosnRNLBnNHAcAO8ZuZogTQNNA00DTQNNAw9r DRwHwO0x/WH9bbeT2z0NNOPS7um+jdw0sEc1MP7pX/yNsiyD/FsU/s0XZTQclOWSfQMB2WPLslgs yoD9w+WwLLyZLBdlOBrxTh1f7uI1GAzKgs8jjvk+n1FvuOS1RpM5r0Up42EZ0qtjWeybj7QZRpbZ bIYMo4w/YJ915+ybzWdlPJpQx/7sn3b0OWfgAfKmL8ZEBGSrzxaDAX0uZuwblTl1PSXlnIxH6S/n xQgKwFmmXimMNaMf+rf93HF4eZr2bXvLsjvu9nxO33SurP637qKr6Lb7UGAZKgN6TC+Kb10+DZUf PVlxbkP+j+OhR9/IYqF5znnJ8UEZc46+q40crbL5vbmH7jw3v8floDsv2ilzQRdq2gZVbXzn7PH7 j7bZP1/Oq66p7tc0HKBDdD5Hl4s0oq7KcDRPYrhAolGkmS+rvusodRyPeBrz2ZwmQ77rTs5Iy3jo j+4pfhdU5OU4XCWMU68Fz8X9S67Bwjn1umZnznPBuLYc0b/Xht9dPVb7cDvjsN/vYO6FQ5Ux5+G5 WybDSc7d9kPOyHG8jpVkriL8jv0dIJPbfJ1Vv3Tl1+Zl57i2GfKujDN06bcUfXAKvlumXjP2xXa6 Rod+UpL8TngfDdFV+lsUhqJtldWvcekY/gSt330na8ifc2Fnrc8p+ltE0CoT7alb+2Sf1xLn7zkp o7+PFM5PfdZS5ep/215DY3/PvNtn/S44V9rMlptIWK+D+g17PxmnX39H8+iljpmmDJDvwUsIGcbp g+9xwRU64Brks78Hf5tjzsPffc6bUXz3e+Iqj5hqmzuOZ4FCePnGUc/V3289C3TYXbf9cXXghZC2 y3qt5dq2C0+Po46jFH6LA77PAedkUYa8c6R+q45pC/VJG+9tbE+4MBQjlz97PFb1Yyv7UJdIQdP6 bi+eY9WD56ZM6s/+cn07Un8uyOfvWoG95pTAonxTLi5/u9x2c2TKb9gh1bf/vK5zL88Vw32FPmx/ bLxjMnk6uY7oy3t0BKa9Ui39TfObmlHJehM+W/xrje4qyif3O4oYMOZenOve620wYdtr1doWrkPu xxGYPRP07jk5Hr8MdlOXivyUkMfrmPNV5fShzsb8fqyb65QN+xRTPOeMgc783svcE3JcdTgvkwHX LP+qHFx3Y6T1OqTvJfrJ947uc39FQnU19NphfH8XuRMxXv1dOqga4Pr2C3YM5WPswWt+4W30VU/V gwEEzsavcbGY5oIXGPPjQwBvYEs6GHHz90L2egiIUceTnPHljlUi5+MX7J3FG0G2A971AvEE8pOg vcrwZMdjxvcEOeZ3O0LAKSez9HguNMbqtv1svbwjraCkshTIvnJjQ/m5uHj3Zrjwy3KALeVoH7b3 JuXFA9hPZxtlurlZNjePlPl0hvz+EDxZT6nWE+RVov06vn1RIzLkfLtxAqhso5JcAeob6dMnzVLq j8EfKOfLPk9XmS1zHjzyIMLOyOcpIIsXnKXrIrJlB39GE28U3OT9xdOh/fvjVUXeDBTG8/UHXh+0 HNNtx1OviqosXKBu05ffV75zx/RCYadt+3bK3Rcl94ZbQVCBHdALvGvHjycPEHyO/rpxIitVFCA3 Et5zQUdRXsS084Gi+2d3jpUfhcN0/dcbPcdyDShYL3tqR/9z61L88Sh7nietqcq4an2ItIZDV115 TTIy+stDUHdN5ftED74LmP7YZjx4KuOIu16vl6o7r1P15xh+h15DjMa+OddeBUavYVWADtjIadFA oPB8/C5zvacHK1Q953KwDW173fvbpVrZRB57ChDQ+ybXFCOkf1sodlTMXmVS5xZ/Ll6GnkOVud44 htxc/d4GAmX3b8yPduqJ8HnC9edvz9+EN2r7n3EtOoZyqnNHYDf7qk6ynz+Rg33WUQf9des9wb6V Q9362d9ffo/0G6DluIDjueYBiP6UDxVzLuqp+/4im/1zFOHsOmC3nLJVf9NUTR/s8MvIdTHwoTfX DeflPuTodZV6KsqGHsuFVHXrMXWZ+4L9+nnLdxoFI6djR1jPH7lmKsM+u37rb23rZ8fnHHwhS73+ vYC7cdlvH94PBaO+OJIPB46huHavfPbS31f83t3n95bLiPN2fOtyJNfJgOvAsSVaOW3HUP0pbLDT c/a+7e+Nb5pdfnu287DHead+ZOCaUjuOrZ7FE86k9kaFIb+ngCrn5LgZlGvO3799Wdxf5TxurNpN ztv7kOPylutJnS+4p3k1qxNPwX4CmG7ns204zgelzDlwxOvRrm0TufnkvdLfqPLlHukZ2glvSrlk /xIsBde74glwwxkx6Bxt85ELbI2B7NZ+BDCZDTeV/BDo2A2+IfVw9Ikd8FVwb9DoHYHoyzpeBHwe Im29iFCr4BWQ5wdgPQQfDr0x1CfoTYDQ8ezfp9/04Q8/Y9IfbVQWoyElN4a5MnmBoCTGCrDTPkCW sanP8R5APa96s1F5C8B2o2weOVwO8CDw5GuuLF927WPLtddcXa649OKyNjlJwLgdtNI00DTQNNA0 0DTwEDQArtUnGtHfp2afIgN42D8FMh5BACwhTtYHYAnOAUWfGHgCpn5AjUeCcUwO7hewqzTVZCIQ A9Z0V01egHAeGeiXR5DKAjqGSqVAKmM7jk8PI0wUSx87BFqexgRqn+iUSuD3STJPc8jm01ueqJEn T3IKwv/6gGB/PAkKwvbFGIwCQC/K4Y37yr1331n+3pMeX17w7KeXax/7qHr+jko9mX8rTQNNA00D TQNNA9ulAbAIcBPsZLqYLaSOsl8BR2D0pWlM4BRgO1wNkAlg+kkt8RuAqgKy/r2Yc4A5OqqyUk9G 7kj2kX6ws1ewBUD5p6liuFzDXLaRWuOJbFrg5zjEeIj93wcAx5rF1JWBkYE+OQ8OUQc/1CZ+Svuj F7pMezrKoI4eMyhHHU/z7uH77yuz6ZHyDS98Zvm6Fz079fVDt9I00DTQNNA00DSwUxoYhgUKvJh9 ZZv6XcAm/J/zsjmdBpxHBHa4Oz4xADmGc1u4TZHxBsLZELgFL53RAVmOVyZb2W86SisPuOEf2Whl tjLtFHZrco6vUfkA0PhwNH9zTOu3Juje9K0zXtfPxkaVWfCt7J4+ZMg24yRms2leBhPFt8g53nPP ofKiZzylvPSFz4rsjtNK00DTQNNA00DTwE5qAMem0bTVLyvgTQFPQiZKWZPFwiDZFJjLoos+FvkA 101Y5hq+0iEsNYAlG6byjBA0oJJ3gLCXHOAT/EaMI7YNMSlXQJ0Gfo1QFiwTbAFYGuls/RrwxUMB 9Y0wm+MvXs6NiqsPA0PGnCJzzOZIvYAVx+dMW9mtfdTi2PqQa2DGgvNZYFrXx3z48L2Yna8rX/fi 52S8XuT23jTQNNA00DTQNLCTGjCGCUIL+DFHRF+vzBGnawArx5ZjQFMTbwUvzdUx/wJuMwB6om/X bdon6nACwNLFEBAd40eWJQuEgrFRkmOiI6WqmqiHMGtfMmyGZmSj8jhOYRjGrMDpQfsYIJcAHpBl bEFU8NU0nbpEyGV6C/scb8pDgCCuHPFnRw7k0WRN+NkcU/c65/+8Zz+1gW+03v40DTQNNA00DaxK AxWAYY4L5j7F1AzIJd4eOEy0MlHJArFMWRAzsl50k7UKipsAnAQ5DFPUFCBhmxPYseAroNJT/oHK 8u2yNKgqYItfeQLTldnSdDh2DpgPBHTTm6T54LibOIE1jzu9QXjVLy0QJwra6GwYsILoq05IOv04 tg8CAV9F64T3+Ahfs9ONrnvMI8o1Vz2C2q00DTQNNA00DTQNrE4DY+d8CpSjcoBRNe46oQe4BbCW gKzAaLwTHJe9grJgKxjjcw0Q9uyWoxwTaqtJ2GAnzdEdexVZMxmZNztMbybDcDQPMjZDJII5TFxw ZT9VF5lr6JxV+0JWAHxgVgcAdcbUI6Ow9R1X9u7Tgu04L+bsKb8vzdhL2rjt/OIliSVm883yhMc/ lvqtNA00DTQNNA00DaxWA0MZo2UwBOAwMwuYZq4BpdgychmAY4sdVNK3CsyZ9Yh5sev4f2W/+oqr mXpYJmvYoGMqpi9YqmAcm7Rtw6JlpoOyRj3fl0F3gVWg76Y1UTMy0dZ5vU5+R5Dsq9m0Kujryx3C tGuwFocjnw8HILkdInNtVQG5+oUZnz41Zc82p+WaR1+VftufpoGmgaaBpoGmgVVqYCyQLmJGFvSE K822ghdcVr8v+5ItSakEOMDLIjDLgjUhm6JC5qofWNZpkWliJOYf4Jo9/NH0i7+XmjnibrOaJNuV e+g64F+myFSnCAW8hW5Zrx3RrxlEYoI2XZhPADLlAHQ9hyXJQDIf2EjnmKrpm87jK6a+0c+mRPR1 6cUXKEYrTQNNA00DTQNNAyvVAHhqAFMF1WEATdOxAApYAlqZagTyVQAD6DgWEAR8ZZFCrCZpA6wy pakzL7ObtHeVgcYH62nZFjO0UdNT5t+6HxzHr7sOOIKhDCxgK0eotePyb+z8X8zGAX8isJcALsPR RvM1VWk8DOtm/i99Gx29AHwFbH3TKQyUQC57lFmzU59wy3BV1dP+Ng00DTQNNA2sVgNj2W9lnQAS 2xqhpa9GNAt0lpBe9lW4FdUAMOr62f8BXoAvEc8AqUAniU6AFNWSo5mKBlaVhUwWwKQ7E5onJ5X7 jYoOO9UcLVN2ZJmvkdQm5JK5souXpuTFXJDGFB7gp1vANAFf9G3eUcHcoC2nNy2mALLAzcNBfRhg jO6hw1FaaRpoGmgaaBpoGli1BoY1abtgCIjxEngnRCPX6TzwUfYJqCaPtpgMW/NuknKAhgsBlf0m waCHHB/IQHkZYKXpOCzU9gIvPltB1aComLgBQqc1uWLRUNMxjHXBoHYnUAve5nTOIPzRB+z+kb5f DeSMMwJcZcduC97+E19NFG6QWVbpSI/2SbvUc1uZW2kaaBpoGmgaaBpYvQbIo0HQVECpBkzFTBv6 aWIMIJXEF1LQREoDnHN8s5qoNQ27fzBympJMlYAs3vXdzgDImaxTRKfeBPNw2gOuPeZJZo+ulgJQ DkdrHahWJchsk8sZMDVhBjhMEWj1IRsRnSeDrPajnAFlHgyoGmDNCiyeF/8gyuwz4YijK7n7Lb00 +dD+NA00DTQNNA00DaxMA4QMw2oBUogleCSDBJwITspcWhNwMD/YJcdENf2r1AhwCrbBM1gouwFg AdWQLcBUX+5af7yuewpiZvpQciyzbbGubDQrHTG2DLmuXassHCPAi9lCsGIeBlyST7yU2i4YDESu H2nDeJk3nOCrTbYFWM3gzEeeVCaO/Zk+6It9C151OB8QWmka2Dsa8Pew28V7wLmUvXAOvfznei59 P9v1vpd0s13ndLJ+9preTybjXtg3FlTNIiWLFUlnABu4S4YrAqPG5nXGbIyJ13VqgS/+UR/zsaAr ItK0Fn2uMmL2L9YImOruI65Hq39WBpxpSbz3yTJcTzMrLdG36ScNnJI5a/4eufyfNyOQ3SU6XaZQ 83LM0YK8Mjs+fuQjLCNoWNUEwNY3XBmvguWpgr59MAB0AXGXIrTtMcE7+dtb08CKNeDN+PDhw+X+ ++/nuq451FcswimH003k6+DBg3md6oa6l8+hP7mzPZe+/na97wfdbNe5nqyf3dL7yWTZq/uYBQQ4 CXSAUjAzfwQsgJP9gq8lIAY4JwKZNqOeLXPM6TzJGy1yY2buj81Y0B4o7sB0TmpIgHgC0Od/BVDn 8i41a0N1NW0D/2UMkwWLI4Njy7aB5AAwG7wTXQ2jFdCVbgIIC+RT8lNnAXT6yCLZmqkNguY8gOUy hWG7rJLPDjnnesZ8aqVpYLUauO+++8qdd97JfPg1HhwnZX3dmQBcn5RTgd2qJPS34YO5DwXKeejQ oXLxxReXCy544JS9U53Dbsvf66n+xuUVZz6Xvs12ve913WzXeZ6qn7O9hk7V/ktlvxNp84PXL2oK ySEvf3hetJZEC3dRyh43XZVRxgLhUY+uc4koSfEoqPF/RnrJBX5cg7qI2+IzwGx6Lev5h3EdQRZL umnG44Uzt0Y1A66Asng5wres+dkvVOIqkw5Ma2amrSbtCexZW7X5rC2arGeAve0H8VkDztBiZUk+ 6Ziv6ayTO43an6aBFWlA4D1y5Ei56KKLAsAyBUGrf61IjFMO42+tf/n72uRB+t577809QZkte/0c lNFz6N/dPtW5pNI2/tkPutnG0z1pV/31s0q9n1SQPb5z3LNJwUlQ1Z/qk7gmZ5VHBfbDMGG5pOyA vMJOATuvbb2w1h2v1YAqs2FlShIAN2cbHIxpWMidYLYWsu03c3RVjH1TN6AKWM8BSX4mHBcojXYm cAq5FowxhM3GFC7bhp2PPMY/Qd9/WcQBIEeinId2aB8UvLlxODcPhxu6GATsupb6A+0/tfemgZ3W gMxI8L3wwgvDenN97vSgD7L/rQ8Czkrw5e/8nnvuybvd7fVzUMaeiffvJzuX41m97c6l7Ifv91zO 72zbnuka2m69n61ce62e3LNeqGKhT4mwzRq1LGDKGiuIClwCWNCs8wtXJQtimoi54Dug0xxtYJUc l9+tR9K34GyRZYvgjpcKdOwMZKclaWoWPJN9K+DKPqphFGM/YI9veLapZIRZIZzLFDqFCcQG32HE UwGcXgB828jmnTplMJdljpladu/YvTz1SPvbNLCzGvCakx3JIjU570XwPZkGejn93dx1112pst/O oT+v48/l/PPPPwrUfZ2H+r5fv9+Her4Ppt1O6v3ByLHX6kIw67xcg5vkloKjflmfFtfwTZkq0uAq AdWim9e5vJp5xwCeoKz/VTCeEPksy7W+7fsVkwTnTUzC/bSjGjwlQ6Ze+je4SxYN26XyCJNyFlyw b2WizkBGq80ac7j5oUV8GbHtE01NTf28YwLARqxl7JhZR1gGTHFOsDv9kZg1y7WHhfVWmgZWpQED rvT5+upvSKsa+1zHUV7l7tnwfjyHXgf9ueh79zvZrrKfv9/t0sHp+tkpvZ9uzL1+DGwzohkzMKBm MFNyNetf1T8quPEyUYaZqAQs01Nqlhb0zMdczc6CYDUDe1FrNjZIyoAoAVnwFQd7xiyQ2l7/ciCQ P8mORXVNywZ61c/0xZQjDd/2syQcGgs0LW2tWczgq2n6GQ5ZXpC9+pCVL6DNZ0cywxfPFxT2+yCB 2dsHC/3LrTQNrEoDmm39fQhi+7Eodx8fsl/Pode78vsQsZ0AvN+/3143O/m+E3rfSXl3uu8g4CBB TNVMPBo5JUjYmiVquaZzxJgMagb2AK45IBcwZZv/mNMA7wmO4MyxNfjJbFquSkTkMebhcczXE+p4 46mmYQ3UgqGAHlMwba03xb48cKoQn83SRRQVNYlupu54vE4fAjetMVfPZvp4iR6lD5N2CLo+LBCz nX2RkQivZNZCflNf2s8I2ZI4BMhupWlgVRowmMnrz+t0P5atcm/d3q/n4ncxnTLHcZvKfv9+t0kN p+3G62a79X7aAff4wbFgBFJiwNVjKyDBInlKN9ezWCacCZRm7EjEsqZbcTEsNTZdPguI7Jc06w+2 CiDq6kgCqf0PxvpdBVHHWMfUDMiyP+v0VnoaIBYY7QhMLQdgw7LnRRg18g2m9Ie8jLVkvq8PC24P yNY1B+hltJERtq7cPCXwWThWMP4C6Ak64wSSslJ7dytNAyvSQOIRuAH5YLgfy1a5t27v13PxHHRJ bVfZ79/vdunhdP2o8+3W++nG2+vHxl6A5m7WrxrDGDcI8y+DzIAcAUuw2BiAYZ1oTrwjt7Ig6kfT VWLiNdEGIJcc0bJg2muyzo8UNBbsNDsPYa3CYczTgJ+BV5rAnWNsCkn9vaK304tGZrsKYQbS/ZEI nprFIxsy0pOAvgTkkz0LKRdGZykn9efU1VStqRlkFoLpm1WYECQGc45v30/PzltpGji1BvobfX8D OnXNvXskv+dOvK3be1fiU0um/LIxLXvbUR4O3+926OFMfWy33s803l4/Lv2tQAQaCYZJbiHesa6v fuGs0CAocp3mRwe+4cUKW821C5AJoEPqL2WUthXc2Bb7sngDWhCo7XuOH9d+BHxTXGYJQprJvv0s qIepEjSVY2GzHIsmOSYoU+zDKVMm3AisG2SFuZk9OZ8lCTeohZzAvAk5fEjAtq4V3CdVg7oy/Sm9 tT9NA00DX6oaCAnhftLKajXQ9A4dDZABjlniD4CUFwrEghQ4io+2gh8cFrADADnmpTqS4Qrf0/oE GZ4MUHtwAPgGZLmo14Yk0gAM7Te9C4SmmfSCr6hO+kuBFLAWVBlPBM0TJZ81ddMEINevW/cHUAFW qkUepE1/kl/rCsGamuXUjukyh7Jp+8w/hpDZ50RWe82ddDSDN5xj6bt+pOTLpmYfNXjgwIHMG/V9 N0qTbze0fm5jGlz0qU99it/ysFx33XW5ls6tx51p7bX+iU98Ikz0cY97XNJe7sxI+7vX22+/vfz1 X/912djYWMmJeK95ylOeUi6//PKVjPelOshYIKrRyKCSgAdQJUezhmfQLADG5sBAKhhq2C17acQ2 YCrzBNaSeIPpSQFiAZeoZE3SU6KUBb0ESlFXf7JAGP8wiCk4eswpSonGZp/HDcwKINP7EMC2jmkk HVdirsm6BoLQTjBVJnzRSfRBWyUZs8KSMjotChHof45P2WAyTNW28AFgF4s/Jn9Ygq8XvIC7dV6i evBByFzBd9xxR0DYH4RzSFdRmnyr0PL2jyH4/u3f/m2uHXt37u5evZEqm9e3RZm//Mu/vIFwtPHA P6sEX0f2oftDH/pQeeELX/hAQdqnbdUAIVFGHGMKZg7uBN+ua/I613asLzcMFJMz79LdxYCVhjQT G/gE6E1nskvbE7QlC+UYsMgLHy59WcdALvsf4K8VnJcEUmmpDiIKnI4BPXX5wCTUIFiqzAm2oq+p gIss68ODZOLaTF9jQD3R0/iTxU9GDWALuUZMr/WpK/ks61aWjc0pU6zwNfMQoVl8Nl0Hgjdor6y7 UwTU2267rZx33nnl0ksvRQ1RSs6ll8h9Rgw6XcKk+LJjWc0VV1xRLrvssr7ajrw3+XZErTveqTfO reDrQ+pezjqkbL0v1odNZX/CE56QB9IdV9Y+GqBnvs985jNzvziV6O9617ty6KUvfempqpxxv7m/ b7zxxoDwGSu3CuekAYKQCVACxQRfwXAJuC609VKcNmQKyaUMEtPwEhAOoxxgCo1pWiYrZQZs+aHL RI2nFoNd1Ui/r8v/GQkt71yyolEKwJcgL45r1pYhS3AnrqKUaUTKIYAK2c71dWwqwHDF7KyIJFWn DvjMD9gHAMbggcB5wdYRaAV6mbRTlVyCcN71rYk98tfTrDKt8K/Ae/fddx9NR+jQMY8j6/Fl636Z rykMbWsfO1WafDul2Z3tV/D96Ec/epT5CmyC2aosJg/l7JRNGas1y9/2POfgubRyogZ8WN/psoox dvoc9kv/Y4FwBtPMQveu+wdwTkzdmKxWABhmWxc50Iw7n2/yQxEQ9UMAjQD02rqOYIKaOL6xMQXs QD4drhNYNPOLxbgjMFB6guVWk3DwnD3akv3hxdQqUxaIHZsFFBiQYK+KkLibxdoyXGNRBZ4TXGVp AtONn5n1fpkaDNgzp4/zmNPWPkdm62KIDWQfAfxiW5i3gM8Tx4KALZdeXHXx6VKTs8y3P/fjZVAf lp4V98fdr5nadvYhO97uH0uTr9f2/nrX7Pyxj30sbhwl99rYL+ZcrTuCcM/cdUX5IOE+j7VyogY0 D28t+mtb2X8aYIZPNUFzTwf8SKYhOsosYcP+EKYAsODrVKKaik6AWws4jADvgCm+XZ9cZcxODdKR HFM2+jBGWV9w/MyMZYKOkSAOG6VXpitZQ9M3YGg9xrFOeDHIOwNQ+6CkZMeijeArKGu1lSEHrnwI AFzHRGOvmaxDXg1gcRbxTwtmYxi8pvKavcuHCR8WVld8qv/iF78Y89rx4Kus/auXqP/se1/ctq0+ Y/vaTqbQ5Ou1vL/eBd+Pf/zjDwBfA6/2E3gpqzL74GDx3uM5bef1vb++1Sbtl4IGYvEFtwJ+pnAc A8LmxQDPCjkwAmre8OWT8lGji53PK0t2CtCUbFQGPlkWgKWALRiPMGULnC4xGF9mzNfAIm0EfUag H/uzV/qCni6mAj9Mmx/fnH4E2TFjmXM6wWLKx7Yse6ypXDACsHt80ipttis/mxFrc9NxkF2my0Gn JGWaE0PmQQFz9SqLflWZryz2eFBVjq2Au3W7P9bL6jH7sC/73K7S5NsuTa6uHwFK5tg/pPpbFcgM 5ttvRZmV3XOweE6y+gbCJ36TMt6trxNrtD37QQNDg5bWTEUJYAmcLhVo0S/r/F4BMkDagZifBWMM u9QShAFbQFPglr3KXI2MdrqSPyRfeaqF4fq72mS1Itkvtu/uOIBqHVkvXS6y3KD9CtwVpOOnZlyf igPm1BeADMgSpB1V2TMPmTaCbA/YgrLga+BY5KJ2IJ8/Q859VcUgCn23+rw8t7702/17v3/re3+s f/eY2/Zln32AxtY2D3a7yfdgNbb79QUmAcpr3+JvTbPzfgTfXpvK7jn0IOy5NRDutdPeH24ayKOm YBumCMh5Y++Bc4wfNdN/PIppV4Oy1HiBr1WgDvgKnpiNBDUBTjO07WWbpo10GpN9C5hZuQhw7FdJ Ak9Tp7Jg27P6kkAMiNqn20A1Y9EF/VXYquCsnD4K2Ls/Un3TAXoDwXhYkKFHFsZTHrpMP84hFow1 VfvgsKoiUGpm68/VcXtA7d/7fX7uX718fZ3+3f32ZZ/2fa6lyXeuGlxt++OnGnktCFxaRfZ78Rw8 l/634u9blu85t1I1oA9466vpZX9qYNg/PbtykUAVMO3YposdeMMPzBlaDJCmDvX6Ivu0CI4yW8Ey 5uouK5Wg7Ri+rAum10hrIqHNdOXUoxxnmlE1EVMBZivw1xfjA5iO67xg4LWayJUrDFjA1S+tr5nR AGrNz8HWnAdtRV/qcpAx6/Qo2xhgtqoiW/GB4viyFVC3bvf1tu7but0ft8/tMNE1+XqN7v13v6ut ZueHE/j22j8ehLXCec7bca33Y7T3poHd1sDY4KikoATYBEQBWEZcU1LCFCcyxjqtiJ2JUhZzTQPJ Iyry1/oBWtqFCwN2LuZAjwHjxUDGLHgaJb3GHF+OaBLGNCyo2P8c/y+VGM/jzN0lWMr2WS+YAR1J 8LS+OLZkSpJgm8UYZLddjmmnNdmhDwLWdxt+XEO1OJcJu2aAvX1X+VfzFTiHV/PayUBUCU61vz/W s4Gt0trG72s7bkpNvq2a3bvbxzNfH0y/7Mu+bF+bnU+l7d4c3QeY+aCuOVp2vJ8CzE51fueyv0U9 n4v29k7b4RqA541cMmj+59zoATQTYxhtPDHSWVjlh561gs1YxXzbmjgD9klDodXj62Seir8WeFsC rq7Na9IMfbDWy5xf2Sm7hkZLg4H2I4iPjWwOSBt5zS7Ac+gqS5ixhV+XJow5HCSG7KZM6WtJ4Nea c5U5B+YVsa2cno/pL6nMQ0IWgYAFJ68HLQ3UGnJeXUaQ2tkO//UJfiuInglwz3S8F9c+7ftcS5Pv XDW4mva33HJLLEaO5nf/cAXfXpuCsOfY/3YEYXXQStPAw0EDpKIEmIQ4E2sAeCbVAMoCqEOAzIhk 6wRwYZzAIP88rq+3qkDSOQI8SaYV0Au2GrTFPr24A5jnrBxgDMEXgOTQkcUmUdb4agVWWTesecKc 4ilBWALt+MB66i8EfCWyO03RHJsKtshikhCQF/mA2p6dc1MyjoxRFCYyej5gNWPw0qzOu2zfnltp GtjPGoiVZz+fwFnIfvw59mB8Fk0ftlXaPOCHx1c79OI2qEqw8iVQhTnm/Ixp5kUdU0F64etKNe9z liA09zOseb7hdCSZMIAGkLuMoYipT3gOSsONExBll1qNF0OnKRF9DesN+NJSlitAO7fYR4KknoTd Hi1GVguiAK7A7zrCY5hsArVAXI3dwi6iIiMyJOoaGAawa+EdMB/Qj+V0DLPW396/kdMHh66c7ibi sTMd7/vxPE7mW+6Pn+17k+9sNbW79a699tqj37ff/c0337wtQXi7e1anHt3gQM+x/716nbpoQytN Aw8HDTADSGADZMElwSq+XbBKAOiDlAZc9AvX3QXcnC6ErTfZsfQ/imcDsl6F8HJD8F2fsuwZ63H8 vOa6FMSFdlCQv7QbsU9GzDj6jZNkA9DcBLRHsGQBdc6UpbpsYMd0BVUEnZBo4wiAP+W4Ga/GExJs xBRe5Z4R4OWKTA4naOdcljxA0K9AD/zSjq2ewrNnp4tJTDSfxce+BYj7cZWxv8n0+/p3j52suN8+ 7ftcS5PvXDW4mvZ96kYDkqZT8qrzu/rkJz9Zrr322nLRRRetRogVjeJCDeY+7xnwZDKJ/1cdfKmX 5gN+eFwBoYf6RPX1ClDBJ87N4A5ZrKAgRDqtZzgGYAVZQNDgLI8LAs6nHRlcRRuBVCY6An31ITtV SZCwnkk0BCDwr+uHvtmu7QRoxqC5n30YMIOWJmejnV3ZiD3Zhsiy5YMAcE7fyhQTOZ3FHG0/mUJl zLTyR6L0iyB1bOqsspi56mS+2q3gunW7l23rvq3b/XH7tO9zLU2+c9Xg6toLQAYi9ZYPAerhxoRl vj5Y9ODruXrODXxXd521kXZeA8Op6a4ASU22/A9ACnpGCge2AExNy978NRQLdv4oErQFEAvGczJO LQRZgHN9XSAGmmW85lwGIGzjPk3MlvhgcRRPAH7LjM4CpIzjfN7+R5cIaGTRD4xRuqzLWpHD9JUD +l5fx4SNVPNMadI7zba+YOowKNuawmX1VR6PJxkHx+earZVxRUV2YgSruuhLD6j9u/vd3vo6XV37 ss/tYD5Nvl7T++O9Z8KyQovXwsMFhI83O3uO5oVu4Ls/rs0m5dlrABesyEhu5k0AK8AKZyRM2RWG 9McKUQsClsQNMBZwGFaTJxjXH5OPcoQXYM2bfVrP4FwXV9Ak7QpGS+YG+z4H9GXH7tf2LZgTG8UK Spq9p5HDlZRiIhYsrYMMTieiAX99py3HjJ52opGsWBlDzDls/RnR2oZaIUqVpxtLWV0qUYlXVbx5 CHJmnDoecJVh677jZeqP9e99ffuyz+24MTX5jtf63v/sdyYrfDiB8MnAtzHfvX8tNgkfmgaG4zWm /4Csc8BMt6kmWxmx2ap8qk56R/sOcYONCmIgmmCgP9bitKLkYGYd302AfJoczACtCC1cQn9TXyBk jSObmUnLKGhR0JSXBmUV5gu70IOBXrLVar4GZNmhjBsblZXba01pqU8VIO1Y85TxbemjQcRla0ZA WJYkDNjTB75jme9WMKPaSopr+Lr4+PFTfnpZfD/ZS+H6Ov22fdjXdq4L3ORbyWWwrYMIwrLDPg6g Z8L6T/dbUWZZvOdg8Zwa891v32KT98FooGbCImBqxEVfg6Hq2r2z2RHY6hQYrGZh8Uu/qlmpFiSV ECVrSkkTYnSm3fEBgJJ2BGm5ipE+X4HDwC79yEldiR8Zfh0ZQ745bspLg7k2mcc0xLTsvGPNzhsE ZA2ZsxR/rr7jNKttnbPsA4CLKphNy2K6DacW6TPuU1FOuiURZzBrHwSUyZr12cHt1RX9rI985COT OOP4h4CtwNtLdKp9tjX5hn1th/+3H6/J12tif70LVLLErSCs/3Q/gbCyKvNW8N16TvvrG2nSNg2c nQagtIAVSLh2UJNzB5YQU5cM1B8rvdV/G/TDhOw8JaOOocwBY/4AZ5qJ9bUStTxinVtY7vpanSKU mCvqOIO4pn+0iw5EBX2QXRM0XZQDgPOUfhc4o61iCo46riA9TpINOC3MGhk8muUPpwkAM6GIEdpO TbIVQdsB9RE2aaO5Z4B77/Mdcp4T5eZhYtXF9XsvvPDC+G6PZ8K9LD3w9p/7d/fbRr+vfWz3WsCO 0+Trtb2/3o9niwKZgHbnnXfu+RNRxq3gezyr3/Mn0ARsGniIGiC9Mr5VQHUJ4/QGTzxTfLAxRdOp P2QDpPIyhaNgihlXj2xYHMCa9X4XG3xWChnosGxsCpRMFaLvAJ/90EomCoyQ7cq1fjVT806UlCx5 GLYKh6WfCSx2lMxctb3Ao5zmeUYo4Tymbpm2/S3oI6Z0+tf3POePU5rc50PCsltAYs7x6ZS80zFS w6p3oVxxxRXx3d5zzz1HVzI6Heh6zKLP1zb6fe1jp0qTb6c0u7P9Hj9Npwfh++67b2cHPofele14 8N3q1z6Hrh+WTQ8dOrTj57WKMXb8JPbJABDLOj/VoKeYoGGxWbPXubSCIIBcmauQJdiBZ0YjA64C g2Zdf+gGWGWKMNsW01AK4v27wC1TBp4T9Wz8s5mzBGWPgKOAJQBrgBbMVsypwEMwF35cZfDlggyI DEgL3HSCvLqSnc9sX0s6pWamMSnvVACmrE8O0B5QZu6kpZLfPDHk86r/6G81zd7tt99evOA1/8ry nabVA27/8OPDhyZnWa9JCGQIO12afDut4Z3pXxA2daP5k31gs/jQ5rW2F8u99957VCyva2Xvg8qO HmgbuT94D7jxxhvPShvvete7zqre6Sptp3vrdON8KR/zng94jQA+wElQRRsjskwJAhV4gTVAVX/v WNQCSDULC6R8IAMWP3LAN35aQRBUlKWuAaJ9EYjpmqaVzRrYJSwenXJEuzFmZzA1AGQ7x5Z1D3kC kPm6otGYPmewb6chpTL90iLs14UdOA3AuE57cl4zzajr6MhP9i0B3jFdinADUO+BzvF2o3jDufrq qwOu3iT9gfkScC0xu+Pfc2WYK6+8clv9vWdzvk2+s9HS3qvTm6PNmexvdyetJed69pdffnkRhP0t XnPNNbnmz7XPh2N7E2+YftL7wyqK4NuSfey8psfe7BNM5XShUEo8uAZKAbRHWBXBBRL0mZIyqwNi QA4mKTOezczEoy9VMBWYAU2wMUyTY4KdGbBiquYHZgpLi+OV5TQgaw5nI6Li1+VpIDmpgfdMOwpq 0yAPAD4QdOZworSVz36q6Vo8po2IS5F1Y9x2oARdOW7k4jO4TN/Inh2pvut/vNj38tNmk2/XL5EH LYAPb9ddd92DbrfqBsop623l9BrwQeWFL3zh6Su1o/tOA+N55spWs6xBWIKT824tRgyblMOIZGbn Jh2lLFOw1fdqgFaiigVnQK4myIBvApTO5w3jtSMim4dDFleQNwu+HFsy91hgroZvfMxg54Coa5mv CTioRH2AU4CGOdNlWLQs2QgtA8GUa8bUpQEMHN6NDDJo5LIu/QjmNIYjIw8HwV8b83K/55m39qdp oGngS1gDu20J+1JVfdM7GLswW5VkMYAHoAps7NBsmzSQAFqyS2lmxoybACwAcegiDIK3oAYjnk0x O68BnAIoEdCzLCUIvIK37KEvQZjF4zc0oQjYTC8SzPlkDqthQJtRRVhM0vp6A8rUG5GGcoQJWn9u ljek7iYMW6Zb8zlTh6jo0dhFGXg4QP5grVgscvOun9l9nG32mYjD+c6tNA2sQgP9zcbr0Vf/eRVj b9cY+S11ne3Xc+h1ofwSgGq56/c+9Pf++7Tf/a6bh66FM7fcbr2fecS9XQMk1CcKfGEK0t+qguoa vZqYCXDin0kyJuN6sXqhaX42OYZ+WRkrcBzWuoAVZ4EG+wubFg6pJ5wnXSQMFeYrwR1gC3bbMqLP pYv8wmwHzgkWJsOOBW3Yrv5bPlvIdJlxBd7MK6ZvxAB0jWx2hnENFKMB+KqDux5HgpyLAWZGR2tG 94GglaaBVWnA30aua35j+7F4b+jL1u1+3356V35fPXBuh+z7/fvdDh2cqY+d0PuZxtzLxyGRAJts U/8szNElAp2qMyM3pBfnkKjiEXU2AVcZ8AHyLw8ASwEVzOYillECgF7MgJ1BxzLnqRmoAEEzbDnX 2D4NjKpPnLyzOlE1WXd+XOYOzwab7KdTqSpwKZj6hZmgY0F/+qFnM+Vhf2i7c4id44usmqFZYWkh mAvKmLoXjLHYpP4aHXI+Ma1z/MBEgWHPCt5K08CKNGB0b3Ke79Prrn8IVl3+Lvdzyb2Je8d2Rlzv 9+93Fd/nTuh9FXLv1BhAGsDKb0k2KzhubAC+c3JRmWyD4nzdDSKkJ1SSsTpveJNgrZilMUPLfgPW HtcQTDCXe2vWK+tXEHU1I28+dAVTxder+ThBVM4rrozUZBpLgrNiQjYyGoRPKkxMxbJzuqXg99VE zg3AL1Nfb1g4DwcW+xLwfRjI8orOEXZQMFimLDNOYJkPBgH6NGt/mgZ2XAMHDx7MEoJ9lPuOD7jN A/j77ct+PYdefs9lk4x+zjDYrrLfv9/t0sPp+tkJvZ9uvL1+bJggJ6QUfAW0mm4SJimTZd8aL4Ot nM5jZPEmvt55oqNlndSBHbsmb0zTMMs5TFkP8iQ5nSv4mmkr5moAD09ugFdwFKr1JesLtgiqzksW dHXRagpXhioHpmnGETSV07qOGZYO87W39MHoyS0tuKePnlFztDNl+4DgTB96SZv2p2lgFRrwBu1N 39d+AzDlVe6+7Mdz6GXvz8X1lLdz9sF+/n573ezk+07pfSdl3um+x0uDpcAog6uGbEg0DcIyHWTQ DhDT34t9l5sGJl1BGt+pnl3n5wZ4PQ77XWDmNWmG6xrqV552gVJ0zH8TVGoJJkAKX69Ry664JFyb AcvFFaYxU5MSUxk0cdEPkM5bhACYZa/VFxzwpYqZtaw6ksZTDMyq7StIi8KSXac5GXglOMd8xtOD UdOtNA2sSgNes5dcckkSY/hQadHKs9eLN06Tepi1SvktzlvfT+fQ6/j4c/E72a6yX7/f7Tr/0/Wz k3o/3bh7/RjYappJsI4L0XtCTLvAXn5cgJZJNQQ08DR+YplrvWlgSDYlJejn0oLyyYAjwGYdgdag KiFU/22Cs+hnBgiajcrPgrDjGoRl0NYc07fpKwX3AWZns3PJhukZszfdAZjK5W+mZ8D57D4lcFoS iTi4rVGxntOCYCsBOvXdR13rWTyvVpoGVqkBM1LJvAQwfy8mzfD35O+gf61SnpON5W+lf/WsRfCV LfYZtfb6OXhenkP/7vapziWVtunPfvh+t+lUT9tNf/2sSu+nFWYPH2TtAoAQQIo5lhtCLlqA19SO MtfkigavZuRP9pgsWVN0GGp3Ypqnx4CuEdOZO2w7wHRJQg/zPNNQSmurug2zXcC8NWoLoJqEBeTB kOUMMW8LuWNYsf7gyoIFV5m14xis5WcG5zMj0adGbyHYfWTAor04jCEbkLUfg8gE5pySlThimwrE OdD+NA2sSAOySLM/uQKQAGzwjtd/HnqRQSDezeLv3IeDxGzwsKC5WZl78FW2053Dbsvf6y73Mj6c 6Vz6+tv1vh90s13neqp+zuYaOlXbL6X9NWRKEIQGLwQ0HxoFOH6AlW3CUAVj2KwBTgMDr6jjPN0F RuXBEFMyhw9DUTUDLwRemSiguEYg1wifsEkwnMO7WGpyxmQswyWBxpq0OoU6FVED5DN9wAZeAaYu K6hZ2wcCP+vXVUZcvMhz7MHBH73yjgD9sGbAe0ik9mhSGb4mcYmvQFxdychpZ600DeyCBi644IIA mitb+dLEK+D1oLELIh0d0t+SDwQyc0HXVJYnA9W9fA79yZztufT1t+t9P+hmu871ZP3slt5PJste 3jcWhPLD77AIzAKg8OfKETHfGqk8YUm/5SYVAEGBkp8n55QamI/ZBngPkKfZxBmyVtmtCzmYGtK+ 9b/6gx5xbACznePvXWJy1tTMofh+aQGAAooA8xBQxygdc3Rl54Iv43BjEHwN3OL2wLAszYd/KgFY ArMPBYC9DwguTTig8ylBYzLdNYCcgcoGBx1Ls7f9tdI0sFsa8Ho1CndrJO5eAeCz1clePYdefuXb rbLXdbOTetlNve/keW1332N9tYKbUcrTufNwATooosAp0B6AxQ5gwyp0ib94AIstgOTcfQZmwSjX iHheAsJjwHyxYLoRACq42YOgLdDafrJ2HuDIU74uY+iofSQK223r0b4y3zXqUw8mPEcug7DMhEWn MWmbYGM4AqRhvAcAdiE2/xlutBgDspuAff3hYRm3GRCMKIDymNWWHHdJf7L4VpoG9pIGHg43rofD OezUNdF0s1Oa3Z/9Do1wdt1d+WyBuZo4I3N8AV+DlPSnbgDGAWpAbcKUn0wrAvycaytIbwpoAjJA PiJjlpHIljU6MGnG2DzQRE7PZkcAaPNVwUIBdt24liXjW7w46/KIm4AkAOn0IpETn/GAPsVLwVhm 7rKFFucdW/ToWgKsSBUfNWZzJHBnWDGDOwgfMafTf9YKTqv2p2mgaaBpoGmgaWC1Gki4sIkp5rBf 1/ldI2gJDy5m4ApoMlxB04LhGP8ugCbbBRBdwtAjuF3jf9V8JiBXvgnu6cf1mMsI0r+RzMOREdCT uh9Ada5v9cUKpPidAcgspBBTMaZvTdX0YxE0l4CxDwbJGd3ty8MD9ZOQA1nzrika9ObM5N9h07J0 kmrSz7RMAWXHaaVpoGmgaaBpoGlgNzTAGgi9rxfohNXyP4AldLll8JXM1Je+U9ln/LoA3NjoTarE 7ypLjZlYGAV1DdrCoWyEtAsnCIJr6wRRAXoxb1M3wVD0azF15RRWS7dlHXasHALkgnBmg6tMWymI i8VgMkDd+YiR36J8snA26jkQ3V2ZsywY0zUsfmGENaBsQJd9KGkrTQNNA00DTQNNA7uhAQinYATz Ha8nyrn6hAG8TViiEcMgVaZHAKiGHq+TqcqAKkHU0i/cIPYZhGWUsQHNMW0Lomw7/06ztkBoX+mP tkKnOZ0TvCXAAtZHpht2S0EG8zcH9CtQjmHnSXUJMJu8w7EjL3WM1LZ/A68EV58F+pe9eY79lCqZ tAebD1jNtNI00DTQNNA0sBsaGE8BuTWYrNHLdXUjsAkw40PAc8m76SiZTaQrtTJHfcX6hQFb9gTo ZNKaqmWoY6itkcpmz7JvIDbsNP5fo6I687YdxqwMFJsH2uNmxJJRx+wNq6ZpxtVM7j8N4QuY9dCI ah8eQNssLUgfMlvbspfxmO4k0LJv6EMEx23n/F9lXwSE7a+VpoGmgaaBpoGmgdVrgHwXMEOn/bCa ENlewTcWX8Ds6xzA+HSJRl5g7l1g/l0keEkY1NxsYBNsk/zKSwDajFPrk4NEMwPkfAb9mPXD3GDa OK3J1ZKchysrlakyKH3U4C7N1QZPCabrTC8SRCG3AXARWEZLsyqPUdqMJSd28UFZ8RzUp0k1fbNv BHDro576UMArIM6b8hrxrXX6MMA+N1tHK00DTQNNA00DTQO7oAFgdkimGwCsHAG4AF0zY5HzWQuz 0c6C1oxMOLJfcz0b+TyMCVjfKjgaIIbJkp7KvMwBV/brB54Y+QzImfoxZulEO+vPJTCKfpKCEqDU PF1ZqYwYwNV9C7wu5vTHWE43GhkODXjOWfdXZj12bjLAq3nbuvOlpmsl0qctXBuBbR+uwBT4Dhgn wls/MKjsNKdWmgaaBpoGmgaaBnZDA0PNyEYFuyiDoDkCvCaTA5FF36xAJjzX+bmwYY6brEPgNchK 36/tAnEc85/mYxNpaO51W7P0GpHQTlMSALeWPhJZU7fM2elKS+zd1RdNTTByw5zTvMu8eUKgDh0C 1MogK98AlAnpSnsTgyi3KTCXMOW0A+z1/8LZOUZfAHIy/cjUW2kaaBpoGmgaaBrYBQ1IMMvB9QNZ 6k+Qjb2XdJGajpMIA9AKM6ai82fDMqkmMzbh8tQkGmGhNq2ABuxSD5bJZ0EyWalgnQFfmS/MlN7p g3oxF+tnFrBZMYn6BmMZ0eyqSxaN3jJyma1Zsqo8gGnGxdzMOC4q4ejxH/sgIPAD1s45dqqwEdwG XU0IIhsYum1djrXSNNA00DTQNNA0sBsaAJMwMcOANQHLUGMrFh4BZiOgBS6ZbG9aNlDLarLV0RqJ NwDQgHEnfU8qXUVpCgiOR5WxVjMwZm16EnwNqhIQa9IOpywZHMU6qTwEOK4lc5Cpa/+y2TBrGTAy sANRhWxkBE9NY2m+aTA5oE4lqvgo4DswLINmn+krLZ5vK00DTQNNA00DTQO7pYGha/pubMoFDV6S GVYfbc9mPRJzM0BmETDXWH5QjFxgyjWYWIbr9KCYhAFdAVLQ9nPA0kQfmn1poztWQHRRh8OuAexU I83FAHkinxnDBwGkSXvB137okJfmcOtaCfCnQyzXeRjws1XChDGNO6fZai7XMIR9a5Ku49TlCIVf um6laaBpoGmgaaBpYFc0MNbMPHHaEIAlM3UlIqchhdUCUJmSBMpmipLHwk4BNJBU37HL/TkH1whn WazGZ1oB1IA57TPdh736gKGfZb4hgNZIaZNyzADeA4In25qKZcZLfLwQZ7aNiK7r+RoWbZf9lCPR Nf5jBwTMJcUBXSoFaGXNtvEcfBDgfRP51tjnORmZLa5/9rOfjcTtT9NA00DTQNNA08AqNTBcX3PJ v/UA7ga00EAnA62cQytQ6SQO40QqWa3b4BjMtYJvTMwiGUU2K+/0JZuVdRpMpU+XVjBW5hvTB0gJ mAKCAKeLKdRSobtnwjQHczFHC5h0H9M37z4YaGaOjDTUlGwEdh4Y/CzTZZ/HfaDQD605XAn1M3s8 gAyY+8jRStNA00DTQNNA08BuaGAsUIKFABZsMUsBwmgBy6V0FB+qPlkOwm6tV5mkBuaAmM5XQRHW auarIWAurMlaN6HEmqU1Ey8xHZsKckA0s0w7CzdAcddGrJxkXwFqgJOgLsFbsJwn0cYaIAxwK99c sKwgrTxhw4DrHIoLRtMHUvF0oFwyYc3V8TXTt8X9PBVkapRM3bKAfV966aXZbn+aBpoGmgaaBpoG VqmBLEcYwCINhyFXBi65uhHTbAEy/bYAKri6DgAKdMKZ8UthvhBbo441P9suIMc+p/qQzjltbREG C+DKkO1PFqo5eGISjelUdOS//mT9us4/rsk4zP3stCSBVA4tk52IzgoXVs1egF/zMqiuEHzkGK8l 0dKcho8SHOSQrw6EkyGLut2hHG9/mgaaBpoGmgaaBlapAbjioEw3jwBiAhdwBTBphp7i350yH1dg HAOWYZkAmOZdzcgLE2OAYQmyop1Q1wdRyXJlwhZZc1ivgEeJiRggNoBrCeN1hSLHFD/X7BNgJX46 +5zzO/KAMto/bZiEFMBVhpiTkXsJMMvCPRfSbkT2nAeyu+9YQQbpPsWHBWVrpWmgaaBpoGmgaWA3 NDDWp+vCBjJWma2glgKtdTk/lyB0LV6DmZyHK9CNYKjO4U3KSE29gJpJOcQzk2QYKOUqRmbVss4M 07Mm7An9TPXHwlCdizsF2DUtY6AuE83X9E1rEm/oS0YY+p0CyDLckX3SZolcC9Njsk+oHuAndltf 9Yjjc/oTfJMNy3PhmABeS/VN+7F/WOgOtLemgaaBpoGmgaaBlWogyxHKbk2o0Ztrww5NmAzqClSb LOSr+VfwNRWlvmG5pVOYZMQCZFJGisCwVgOvTNohk+ZITkiGLTBa7MNJQ44TwGYst82GtQDBLqz1 AABAAElEQVSsA47UFzZTh/dMc6J5pigdTdAhMFc5p7DwOVm9JLgTp0Q5eoe/jqqZvb7qWCYD6eXh cCtNA00DTQNNA00DK9UAuFaX9KtRwy5UAFACXpqHZakVBmWZM4KmJgAgzBWwNguV+ZxNgBFQJKJZ 4F0QPBWWjJ92Tj3BOf5igqkEbAOlNFeDr8lgpW1btrw5BcxBTAH0APOKrTMjunkB2Lv2LxKBvprI K6AnuIsHgpiaMZXbbuEDAPUM2lLOJUzZ1ZZk6NYT2MOa7T3bbLTSNNA00DTQNNA0sAsawA0KyGHt lS0eXbdX1LR0YGdwVvy4wHEfaUwrQM6/ApsBXLLdWmS4YZe0lznzgQOVAU9I4rFOrmmPzxjUNYcz rUj7N+AcXzTmZ1dHEiSdRywI278yzHkQcAqUDDcBVw4Ztl3H5gMPAG4b8MXDQXbjGeYkZ1P69UQD 1H399t400DTQNNA00DSweg0MBUBNtkn/CFOs2Ct7rCxRVpsVkGChmZYkoAqGmHBHsNc6Txd4DHhu OYHOXC1IQ4SrqVrgY6oTUE87F3KoDHloIhBfHNa4rZ/YBRkkwjFk62/ugq/WY66WLXeMlmOGZsm6 ETCA66aLNGhCD/tlB5vJ2IXIkcUHgBostkXmttk00DTQNNA00DSwIg2AtJiZAavJxEAsQFHwMhRK dgvbdCnAgCgMVajDKg3YgWKUAUFavgTrADbHq8naz+zvQA64ZJv+ZLywUEmo5mQjqDVzazIWDE22 seYUJCrYk2sSr2HKVr5Npyt1ZQ0G7YOCzwIJwJKh06L6pqtfeiZL5tyUd2jQGDXMxjUerKV/Tej6 r1tpGmgaaBpoGmga2A0N4Fw10pnAJab4CIID1xq04D91Pq60NIFWUMiYdAFmwVWkzhKGgKwpKees 3TtmpSHN0XVJQFgr+DYZO4WJ6OcuElpQFSv5WBNxCMqMLTle6uvFh2yAVMCUMXwAELGB0uSRPqCv GdYbggv6iqG2neNjdp1gHx+si1iYuOvcZvcJxCYD8YCMfsAYPli00jTQNNA00DTQNLAbGsDyOwG9 iHRmdIF2WjbCRBUmc3w7qQzSErDCjAFEOWqWLxS+AUKXDpT9rk3OyzGbyThnTCnaZNEFWW5dhtDp Qq6iROS1zlrtzvh4Zd3rTi+CoQYYPU7XBm5pPh4AsAeY4jRzrWD26z/u/dFT2tO8jisVp8GCl2Zq QThMHHmTNIS+4NaAf/VJd6fX3poGmgaaBpoGmgZWqoHxwoUR8KtubgCS+GFZ6yiBUUphJDFGabEt rFJ/sEVA4w+MNYZfwLGy2QqBm2HSMuJ5wBD/K+zT+bwGQBmpDAeGhdKIOhi/y8ApT9TdEGgXtBcc GVduPsOMHODnWD0u8MJy6cdIaK3ZwzmR1OKugVZJHgLr5mHAVZpMO2nAVu8jVkZzXGu+DtB7Qq00 DTQNNA00DTQNrFgDzAMGIAGoCWv7Ckj6YS0JkOIzvDV5njXhuk+fsYFXBmAFUNlnukjZcuYSA4AW pya5BKHFMZyv2wc9ZWlA2sU3qw+Zbdl3IpQBx5BiwN0kHWPeTeDhikv2nOlS7EtKS8SZa9oGkBe2 90xg0WNN2JSZ0V9d0dc8iZ9ZMEYuzqOVpoGmgaaBpoGmgd3SwFg2K4D5HtCFVQqU/f4KtO4zDzMB UsBcjYACDgU1WTBtj7CUkr5VYVCi7Hzi0VhQxg8rsIOJ+mbd3iRASiBddzEGWHCWFaSdcC2w+m56 SZE44wn87E/QloFfIrHMGIZsf46fd9ktnz0Pzc8BWh4MRibmoDsZueP6L37g3dJ6G7dpoGngYaeB SgK0zLWH+zN+ud6juRefbakJmM629urr1e/+5OMab3SqK2IsYFmy6AIAJqzpn10CwmalMjuVYLXo kmoIiNQAYLtEGrSfkjBDM7MBXbZ3Pd8ZyjV9Rl8cJ1OawFLrWFNTsqx5BKiOAWPN0FMWYEj+aMB7 CJuewmz192o2zkOCX5rEFkQ1wYcm5spoAVjqOW84QWIBWeRCBPcpSV3qkHf6EKTP/uvvz6K9Nw00 DTQNnKiBzTs+Vn789b/GgUvKD/7oq8vla6e65Z7Ydv/vmZcNXJiT9XXu6mcuSwJt3/OrP1N+7+a7 zly5q/GUl76y/KPnPe6s6z/UirPpBiTSXBVncyZ1lGPf/alGPb+86Jv+QXnuM55IHNMxTLT2cMyK RIKvZcS24KTp1n0JlgIcA6oEOs0x7wq+Bk1ZNPkaZGXWLKcs1bYAIH30Cx1orpayxnydVgIhG4B1 6oHcrkdskRnbp0ApY/W4xSjqmK/pZ6D52DqoSfD1wYDOrMbuymyNtNYM7YOo1cHwjD8kwtsHBac1 9X3Xhu1v00DTQNPAQ9fAQrPfl2ARTP/4f399ee1rX1ve/t5bzloD9921cdZ1rWgg706XzTs+Xv6X 17y2vPY1ry+3b4orZ1fO/N3fV/7wt/+P8r/+z28qd3Vu2b5nTNCAnuZdkJkZPgATvltYqIk5TI4x x9QbtqgfF+DrQpLZTxdGL3PhyW7NBe2uLOZgkBRIlznEVnPObY7ywf1U1BQcE4TTmfgHhHNQVg0w 4z+eTf1cM1kxqoJJcUVP/suaZd71oreNjFtQFfANuNLvrDwRGXxGpKyopFyGdwnqdGiNVpoGmgaa BpoGHqIGNnE/PpgyYObNS77vh8oLIG99GQ43y//9+jeWjx2eleue9fLybS95Irhx7Pho7WBfdcfe l0ynPbcyKd/z6leXqw+6HkKgrkzvu6O8+7f/n/K+m2+j61vKb777o+V7vvaJR4cZL2G9Q9BpIZN1 N2AVtsnmgoQbgw5M9dN6fMIfAVM8TNAU4Ku/V0CdAcjAXyKd05dTlFxSEFBMukqBWhbqnF2Q0cAr gRwCzbjmltZHzJxhknUIkwF7TdCMLeguAM0BgC9rr+sPU8eu5OU8RJBOOj5lA64UVkCWMcuCjece Yxr3SSrnpwk684Zt30rTQNNA08DuaGAxPVLuufu+rMPuvez8iy4p5607V6Qr3PM2wgCHZX2daaMn FFx5Gy7YCoGZrMfyt7XKfOP+coj+uQ1S7P9S+peAPLAIQJsbkJMuKdMDjxLUinl2yv1bGUKKkGs6 O1JuO3QkVe+8625WsgPEwONJX+f4TrrP4/WDpTN8Zs9yuVYedekBAPjecvEjLkM+ALcaRk/Sw7zc e+jOcrgD6MmBC8slFx44Sb1+F/Xvuqsc3vRBYVDWz7uoXHQ+Ls8tZYZ+7737nm7PtBy+n3M1UDcr BeZst9Q+1ebF5aILz4/5uhf94MFHl2/+7u8tB3/hDeVPbr233PyePy/3vuQrygVgoWU80D4Lm3Qs o5Y17a4zf3fhvB7ZKAKbQ9kAKFlu/LhsjwbrAK1H7UhQ5euFkW4CwkYtrxEZ7TQiGfEAIBT07H8w roFSY9rOGGMg+jK+fci0p5iyRffJBAUx3ibbztmNIXyKfxjn83y5STsfDqiC3H7pWfCBzy6LaLSz AE3TWidTm8iG5Xj0ZeR0wJnza6VpoGmgaWA3NLBc3F/+4vd/p7zjPX91wvBf8axvLN/yDc+Kz/Ce T99YfvJNv0OdSfneH/nvy6PPeyAgzO/9bHnN//ZL6eNbXvWvyldfeX62l8uN8sE//J3y1ne//4T+ n3bDt5ZveNH15F6oQGCFz/zZ28svvesD5Uk3/NPyHS++9gFtFtND5Wde89PlTva+4tU/Wp5w2Vr5 9J+9LfX7ije/5y3lte/x0/nlB370h8sjHqIffC6TOkU5fMenyi+9/k1FPrm1XPH4Z5Xv+s5vLBev HTsfj9/5mQ+X//SLb47cW+tfevVXlm//zpeXR104KYvp7eV1r3lDue9ohfvKL/7UT+TTyXRxtNoJ G2LXCTvBzvXy7K97cfmTN72Dg3eUw5zfBZ2cYKrgZiBTFdy1gYXdynIBTFBOU3R8qqaFFHJhqe7v iwskVJMvT0fDtYDtJtHNLmMomxX0Euwl4EF5Zb0ujiBRFVBdoCELK4TpwlTx4brgwmy2SaS0kphP espTVX1qWRD0NQOENSMrl6s0KRe4Sz9Lnow2Oc5YILDjHuBpSpl9VpARu69Kf+JTYH9O7b1poGmg aWDnNDAvf/5//tIW8J2Uq6++Goit5aPv/c/ll9/2Pu7FwNlV1xHaZZmWj3z8eOgp5e9u/miOlnJV eexl1VS7XB4pvwvr2gq+j7z6kV29Ut7/7reWN/zC75YjspSuDCQ9lLXJA0GsHiZQtm50bJzHgQsv 6vYcextjfi3lIu7H21/u/8KHy0+cBHwd6bab31te9+NvKofiuqxjH7nto+WntoDvY6/7inLlZZUp H7r1r8vP/+Rbyv05/yESn7xccF5/1ic/frZ7Z/fff0JVH5DGc8BKEJTtQlwpMlQYsKZnEYu/eGQ1 JocBDwLCNdWjLHJOpLLsF+5KbcDNvihT6L6gOvIJSxswbzETC4DkdTbAy6yUmraT4AMW7L8DoPIG vt74lQVKmPQSn7RmbPuJnzc6IQIaGSG69F2jmqHQScgxCdgypv+RTz+1evacLImy1hcc23d2tT9N A00DTQMr08DiyG3l9z5ye8a7/obvKC970ROZ0sn9brFRbvqdN5fffO8nyhdv+qNy+zc9DSZ5eXnh Ux9dfuumz5Yb3/2+8oLrv+4oc/Um/hfvvjH9XPOs55dLu+jdu25+f0yeHnjcU7++fPs/eE45DyK1 nN1f/r+3v7m886ZPlXtv/ZPy/pufVb7mugrv6eRB/HnUV72k/JvrX1D+3ze8rvzZHUfKTkYqL5f3 l7f93Jsj3fjgY8o//b5XlMdc4sPGonzuw39a/sObf5ftW8q73/vp8i3Pe1z2f+iP/zD1D1x2fXnV P/+HsOOKTYc+9b7y0296G8f+ptxy+0Z50hWXlu/7t/+2HP7CB8tP/Nxb2H8JDP7VD4HBkw3yJM8u y/k95Z2/9UeRZXzw8eXC7gHn7lv+iocaWmj6FfB8WfTNemJ6YpcBL03O0ktB2KxTAm8146YeuObE onFGd34XnwFSwXKNObh0TDXGAPSGmpipbYINYduxF5qmjWB2bAbxyMA81LR3WlIisul7HpbuuLJd ZdvMnOPki6Ytu7mIVTLGb8A6MVvOTRaIPQ/++Vfyrmz6nFtpGmgaaBpYtQYG65eVV//L/5r71Khc dOmFkJxaBsP18tUv/YbyB+99Y8ym3D0pw/LE5zwHAH5rOXLHX5TbDr8UM3S9Vy/vu63cBPhZnv/s L8u7gbV/+XuxBZcDlz2tfOfLn1MOdPf2wfi88pyXf2f5wqd/qryfdu/5vfeVZzz+hoB/Gj/oP7j8 DlSWWP8+6A7OqsH00GeBy1r+yateWR5zUa+xYbnqyc8v33XD58uvvvuD5QPv+tPy0udeg4/1WLeX PxbQ68DXvZc+7qnlX/3Lx+NzH5TzLu69tWLWsTOoej/Wx9lt3VU++cnPlCPngZFdg8N3f768481v P2oCf+E3P7f7Lubl/X/wx/jsnUsrmNLERRT8sjXfjki6kRk+QFYiizmhPmGHQC1wWkY8cQmQYcwi IMX5uCMCnoY4aHtwDPwFkOtUJ6s6hUhQreBLn2G0MG/ANWMZ5Ww9+jwKmkI9OzL/l/5l0YIp8J7g LJn8HBN1SHcVJw8WpsBU5srquzbdOUTo9qdpoGmgaWBFGjAS+MKLK/M0uOm+I7jNmC0y5bVxz+ex Jz6wnPfIa8s17LqlM0M/+quqOfmLN3+kq/vE8pjLK5gsZ/eWvyXgx/Liv//io+CbHfwZDA5k//t/ 5Z2w4E+WI9xPCfvZ0+WOz97SyYeL9Mjd5S6gQVywmIlxfFFvRP5C52Mdlot5sLF89qbfKm/4u0+U b/z655UrL7+sXHD+gXI+uq+e8lTZpj/T8rZf++VT9mV09/Of/IgcX0zvLn/DPOhAfg21krE67Qio BNAMbhLMnHpkzmV9uS6MAKrCavFUMD/YbFNUph7/eXNJhRo6DrvkAksQFr7cykpRGIAXUzYAm3bC If2E0QL4S33JiqddmY0pfZsUpBJombXATltkmG3WqD/9xyb0mBMR5xfiHGLB3fWGrS8Sm1s6pN5T sn/YdGX7Gc09rTQNNA00DaxUA/fd9onyG7/06+UzTL05UxmMLiwvuuH6sLzeDL3GEjq9+fnp3/SC cl7HcjH3lcNdhxeff4zhbR3jIJHWtdxdjnBfv9Ab7R4usyOV5esH/5Wf/emzkvTxz/3acs27P8JD Syn6fH/tl/+6azcpz7jh68uLnvv3ykXHBW2dVcenqTQ+eHl55KVV57feeuvRmk/+xv+qfPuzrz76 uf+OxqaKjDkXsNvKcGWKAlqYKxthpXzK3Fy+6JHBWpg6ZM8Ca0zY4lnM0L4D4piWbSeKmtUq2bWo G1BN3/yhOJ1pBvhqETaxx1g/BheFGazW8BUHJh1Tdo4pWVO3Uc+bPBSYgcU1g+3TPiY8UyzxSc/x M9NtADsPFLRTRsLHcp5uNxN01X/72zTQNLBaDZj04d//zK8eHfTAZVeWqy+5uFxyxeVlfXl7+dP3 9oFVR6vgy31GKZhZezP0VcQCV/PzpDz9yY86VnHL1uCUwMo99hRldNIgrFNUXtlusaeW65/2DO7y xz73+32fEU7VZ5sa4jt/5b/5sfL5T3683HTTTeUvb+qtBVMeXN7O68/IWvb925i17JLyqv/mB8rl 4hdlcf9ny2v/3S/EQnHHzZ8scwD4eEMDCR/FR83OnBCAl+cgwawDLKANgOQJjZZrnPaUbRNojGC4 ATGYa8BWEAZsxwIvFNT0ka5GxEf6hdnqQwaEA9SAX8zc1F+6kpEwT58C7hBGTIeAMQFZwiXUegoY y2j1K4ey0yKR1Yg8p++MRZ8DTNobRP+NlrBizOkD5hYHfJFhBGDLlAPm+cMwrTQNNA00DeyCBj73 kQ90o15R/tmr/9nR6GV3LuaHyocB4DuPk2t08aPK04ji1Xf7ic/cWQ6WT+TmfsHVzyqPOv/YrX1A Wl8Nsra/9e/uIcjoxDmyd33u0+l9fPCqcvA4wP3Eh28u02c+9ji/8KkB+zgxd+Tj+gU9Y7+ufOPL /v4xtn+G0TT1X/X4J+X1Df9wUY7cd3f58J/+fnlbpn7dVt5z063lZc96zBl6OfvDQNjRMjzv0eU7 OqvFFz7yrvLhLzytXH/leTmuv9nvCNtsBdsaZEVr2KWsVb9vzMqAllHSSWjBDutpipY5a/7VPC12 W18mvAz4AZYyTNoKeTP25ZjmYYDWtqTnCJALuOaBdn6wxSQbY8AzMhDA5fKCAU4O24esNVOn2B5P FpmzLDjrAw5bn5LIg8AtgXuCbLJ6ZYj5Oj5uGDenqRzZyKjtT9NA00DTwHZoAIpwFtbcUTflp5Qr k4Bi68hf/NBfngC+Htd3+9wbnpmqf/4Hv11+651/ku1nv/gZDwDLwei88qTHX5xjf0QA0D3cr7cW o3Lf8dY/zq7zH3V1Oci92jInz4Llvs9/ofMr52P+HP7Cp06Ye9sf5fafcmZDet/iwb9ffNWju0af KB84SQ7pjbs+X953443lfR+EaVLTQLTPfOxvygc/+MHyxXt6j/qwHDj/kvK0l3xzeWY3HWkDK2pf sgBQ96GiUX/k7N+Pf0x5/HNv6KaQlfKb/+mdR6d9DUYX5DsaLl0pqPsCfE+6ScYLc+R7MTTeBBxz s0bxRepfTSF4qq50ZNIMWSzgjLlYNDZ7Vg/edA6mc5LdGLYVZL1KA/KMmKxWvFucU7zZpZj0+UA/ 9AQmLYGWoc9k0zBd5YPzEoSF/DjhDfwa4LgerlU/MR+pPsBfTUIQPhjgNc3KS/Vi7E8jg7Y/TQNN A00D26KBu8odtx0qdx06VA4d/7r9ULm/yzHcg10pnyx/+9lDuX8tZhvllr/6o/LzHTieTJwrnnB9 gofuvfXj5ZOJfr6kPOnanh32LUZEUr+k+3BLeeMb31puu+9I7oNH7vu78tY3vjF+USu85KVP7+68 pVz8qKvSZnb4w+XtREcr64L8C7d96oPMp/3Nrr8Hvskwr/uKa7PzQ+96e7n1rvvjlnxgrXP/NLn4 0UdB852/8lPlLz7BQ4L3dWKMDn3uY+X1r/v58rZ3vKP8/p/eUgcjyclv/tpvlLe85S3lP/7srwPC Nfe02b5uu/kD5cbojsefSysjtdH6xZd1gVl3lj+78WPlCNmxaiDyQ5dfM/h3vOx56WB2+APlvR87 1HXGd/S1/wUkko9wTIBPRghTJXo5k2mxHQuJunSXgijgZwyxYJmoZxGWNsBtAFdAzDQk6ps6Uuws c8APH3H8wBz3PT5jzkpAFQQJ7QKbAVG2s7oRICkIu8IS2BuAFUxr1DMyIVC/pKDKUQKHcvLSfLDB w8IaKSt9CBBoOar5mv41U9vOOcA+C/TR2VRqpWmgaaBpYJs0MC2/9h/ecMq+vpwsU//kxdeWq56C P5esU/DN8uZffP0p6x9/YHjgivI1sNt+JaFHPvWFJ/Vhnn/VU8q3Pf+vylveA5Dc8cHyM//+g8d3 VZ7w/G8rT7nqWCzwxY/7SiKt3xlw/vB7fqv4Opty6VV9go/byn983b+jyUNbEeoYFz1xVNn/S7/7 H5ebfuqXw87f/is/V95+QrVJ+Uff8bz6QDG6uHzbt74gDzOzwzeXn/3J15bxwYNldrgPT7PxdeXp X3HF0V4Gk/PK5XwyI9Zfvus3eJUHPbcZSDqhXPnVX1OuedufRK+//+v/V7n+x74387XPv/p6cUt/ rX5bANbsUoCnCzEIsjUhBzAGeAl2ZpmyaM4VMocwWefwyi6dtqTv1xc7Mj/XurJPQbf6fmGtoJ8W kboWpPUBzq6/MHCCu2IOpw+jl6scgibjAahhv7zHTM2YgrOh+z4ojMaArz5k+re+0gbwOTd9wGbY yvg06vNYK2MrTQNNA00D56IB74VnUy7pMiutXXJN+df/4pXl2s4U2re99Oqnllf90KvKE5JRqka8 9Mfq+6g8HebUlxc854ncF09WRuX6r31F+eeveNlJptucX172iu8vr/ja64+yX3sw0vp7fuQHylde fcEDOhwffFT57u//wfLSJ12Z/dVWeazKpU94dvnWG3ig2FJOBkRbDp+wKQm76KL6MHDRhSeP3FZn /92//sHyrOsqU9/ayeOf/DXl+3/4R8o1Fx3TmYlC/sUrv608KrqEGG4B32fc8PLy3/4P3/WA6G/P /x+/+oHfybHeto72wO1j3z0xTw88lE/2+/Lv/vruyOfK33z67m4b1+6v/P5HlwEp4CoAiCJkiUAd wFwjnJ0rLEBb3Gd9M1PpA3bumnUhtwFj6+kLEKz1DVMtxf0BVj45Ts9Ok6WKj+4zYEsztmksl5ih DbSyjWNmfEB5BnqnT/rzn2Cv+dmiDIop080IvCfJhzK4DdD3DwSzzY3yuU/fXP6nH/qutG1/mgaa BpoGdkMD0w3Mo94/ScqxvnURhlMI89n3/efyC2/7c45eU374f3zlA0Dk5E3m5fBhMx4SK8MskzWY 4PEgeny76cZh7rvsxb13dPGF4yvt4ucZ8jEBJvd8F6CYcG6nK0fPB0WvsW4x0LInSgA+/luATp+p c3mHBCsJeC6eMOLETCnpIgk9iJK9IwxWH3DoJsg5M5uVwMpropkYUOS7C1BrPq4LMQCeQKP15lLq ADd70EYAFsQWS91WJj8sAfLat2FWPDEM9QHTR6Kl2QNgu5SiLNi2mrnVreOn/+4RZsZDg/36cnyP Z0xqtdI00DTQNLBbGnAh+7Mth++4ufx6wLfg5/0vzwJ87XlUDgK6KWdH1Mm7f/BoXuracG/9PX41 pTNJt1fPZyy7lGVWMNIkTJSygU68WwRlwdDPAVhxEfAbzqvpWMBNZBb1BEXryEzjDyZQS1OvvlxZ a+1RRlvXIBaMLVq2a1YsAq5YqlCgZcDKqgVSKtjviPm9roKkj9jpUfEt2wVV9A1zNGzYBRqWPBwI wcpn347d+6IDxhm7SmS1VpoGmgaaBvaqBpw3/OOv/9Ut4l1SXsRUoVb2twZcyz6miaxOBEwJf5qF Y17GmLyAlc4EMN4HBGllFSJAUIx0+lAh3HsBgDudaOCcYHoAdwPKJsagAwYQpPkPmM4BWNYvAihN lMF+2DM5wgOwAnLWDYbFGlktc9a3nBjrmAx8ECDoyv61IdDnHHP1VFsJgC1bFmqzyAIyIWIA2KlS ySNNHecfa2IXsPU7tNI00DTQNLDXNTCfHgse0if7Xd/7PScNvtrr59Hke6AGxgNMzGaUkrEa9DRz ji50NaxYgALkBkwjWpAwY05ii8noAEAHMAt6WSoQ2JRqBtCoDIjqy92ERWPPpk+nEBmNbIybzJk5 vxO2Cb6a0VDIngrSDKQpOpZpgLeDz4wN9DN+bWP08igma8za8f/yGUDmMSHAnHzWfX+OSIdYrCNT xKR9WDkg3ErTQNNA08B+0MDBRzy5/NiP/RjkAishJutGHfbDt3ZmGQkjruZl8ZR46DBJQc7MWJp9 q68VhgvYCoocosB88cU6XdfIZAFW2mv+aIF2CujJZvXNis6ahmO+lpPSbo75Wsa6DpBOBVbNzDYO G5bJArgwVYHd9JXJxCWowrIXnf/XQCv7UC7n/5Y5zg3eHCfrEyOlea0l2YK8STrsU/YrcDcQ9nts pWmgaWBfaABSNEn06b6Qtgl5lhoAsgAtgE8fb+/njRkXXHR6kEWQdXqSCS8smoEtTtJ2aUJBbyH4 UX8J4uGBTT7nrHIkNmeqkj5degIsa4AU/fBPHjrEzDzEDq0vmKoBSLctArrToczGJSu3T+WLSZxx lS5zfNk7Y3lCo6ct1k04FmCrqdnuBN1NJlc7citNA00DTQNNA00Du6mBseBpJPEiduQKggKx5LXC r+IJfPEOA8ocAzato7l4IMPV9wtQkjuDeoIf05ZoFdbLvkxJAsC7nmgHC6XGKCybsQX09CWIpyFH 8RUjl0saypKTjpIxBVYDw4i1pgbgTDsJuHIteAqI3znm8A7gOT8BOu3ZPxK0qesw5pFupWmgaaBp oGmgaWA3NDB0KpGgliUGkUCcFGAFV0G2LwHT/gPvslkTdri/z1Il9z0KzlDZ2t4kHYJy7U/2GpM1 fchsUwjqsh9fYa7UVYpjDJwdgLb9j5h7XKOfNUezWwAmmXjk00zdFZN92GLokwQA7xGTd2D1TumX QOyqt7emgaaBpoGmgaaBlWpgPJnAJAVaXgE2ho9pWFNvzLeYl4Uv/jsNaLQYwzJNlAEcEsCl/9Xj rl4kjXU5QXCPKGoWRcAcbNeCo35d6HZMyo7jQgkcArzxy3bbnrmgbV0Z64LgsAXH9NtKc8XXsGVN 3dSLidtj1epc82rqZ6Zkni8j1DZCcT0vU1O6DxGOnm8atD9NA00DTQNNA00DK9RAn10yQNgvctCP L1Ca8aqPimbGT5kPp/EHG3UMhFWWahBUCsi2rOketSX3qR8FaH3DFlmtgOyqRrJXC8bsAKqgqXk5 4EqdyaT25RSpWpFRlYE+ZMpGbrvq0aagTzExuEAtC68sXjN5bRsA9mkgjBgZOLfez5zG7U/TQNNA 00DTQNPACjUwNMgppmLNtLJKUEkfLhsBOWVxf+qwUANxTmTFcppQBUpNw04Rsh/+w2adDmSwVQVc +0t7fcUCIP0KfM41NhtWDbKqqxrlvF3DN2ANM3YZROXQdwsTPrB2AOZcx7aKsda6cWWzFmb54hMm sDuAzxSn7gFiRD8MGblcmEEZyL+ZemnY/jQNNA00DTQNNA2sWANmnYR1ArwENYmZiTgGaA1s0nAr AApolYU6B9fEGcCv+w1ZpqKmYMFVBms/ST0JwMYMTKcyacOyloBwVibqTMj6kD1mXzJb69MhIA6S 4xeeTTVnV7Zsv0Fuk56HxTomkiGzEdoWYDyyLDB9z0V5ZFqDabt+8IhxaFEBn5omD8kDQVq2P00D TQNNA00DTQOr1cBYzMvcWKOuADZBSZMueJVtGWp8tgCZaStL2LFAyaYoDZjFhwslNd/zfLHB/uqH FRYFV52uMwBxSJSy5mPHkyXTlONELrugg6w6YCywCsr6ahnHoXgtB5swbScWedxxKQFnuwf42ZVI bcDYxwDOJGNYVzt7XX1JluywHOXEGSHdtD9NA00DTQNNA00Dq9bAWEASjEQw00/GDwvOGjEMTlXE 4m3IMoHO882ShYBwckjDRgNm7gec9evaRtAVBu3WvMsVcJ3LCwDDagVF5w9XU7UgiE+XpQKT7QqI dVCnIImPMVFHkA6oAXqHkdFaTBgiA7Y/F2kwxaVrAUuKzQbtM4Kmbk9F+ZTL1JWSaMe/9dZb00/7 0zTQNNA00DTQNLBKDQBJoBmM04ApCzgWJuq2U5QES/cJzDJUs2G5LwDoJNyu9KZkgdPjEmrLhH49 FnM0wO7ShvlMhWSmkggD2Fk2UODmZTElZjVJG30t7wVI7RPktI4AykB51QhsZGSu8pDxB0xL6n3U U6KejdQWrz0POvBPSqKr+w/tvWmgaaBpoGmgaWCFGhjXaUAVBEFE+CHMFN+spmIBz3mz+m6NkDZC WfoZcGNRBYHWybgxJ0M1K2BWn67maKca0Zp2MFKjpib6mgmoAhDn+JId29WN0i/BV3O2J2bEkqdy LECvr5am9qQsjiWYyqx9ZQh2hHUzjqBqIBbB2CC2EVqyafvT/F390vZfHxKW5au+6qtWqO42VNNA 00DTQNNA00DVwFAg6l+C79ZSk2IAZiCggEwoVurq+/VY1wXgBg6beMMdgLj9WccW5l22JGkHm/Zl TUFc0IzJmOPAMsfIL40/OMdEWUrAn/4syYwFYc8hQFxm7AcBNQCMTHkIAK2VQcprPmpbR372VRCv DxHptP1pGmgaaBpoGmga2AUNxO5sLuYEPXWsE+RkZSKwTYFYCUnPKdZjWOwEADPgqU4PCtAG3qp5 OEk59CqLfYCfBusBvmNQOX5mAVmQtQQgeY85GmCUGxNfzf46Hcr9+qZNBmKHFWABdfy80/kmPmMA G1ZrS5NrhCH7FxP3gjFsG3M5cjiWrFsSnoqwbVdeEqNbaRpoGmgaaBpoGtgNDYwrI6xm4gpymGth u0PMuBWhMEUDXuZ8HgKuRi3LJgcds41VGrCcsFDDvBzB4ksgF6CHdTiMtbJcF0pwUUH36Z81CQcm ZEGStsA/CT4ARac1cdQ+HTsgrOk7mnEncsi+kU0Tt0Br/wK8fmxXRlq6bCLdYMymC9czrgCclJTI PM9iDe6zXStNA00DTQNNA00Du6OB8YhsU0YaWwQzDboyxbriUWdmFnw7k7PzdTkK0ewCoWgBygGa G2W8ZJnCLl0lqMp+5uPGlyxAwm9hp5Vdxwsrr40fd839yaBFBHMng5m2wn6RJRCrCVxQDuAqA+AL zMqBhVtB3+hmFhwGyBkGQEeqtLG2shhwtgTA69QqWrHdStNA00DTQNNA08BuaCCZsBy4MklwMIBX WapsU7ZqEgyIaoKm9MkKvhYzZhkEZVvn6M4xV1dfsGx3UDYxJ0NJAV74KDmnrScoGl0tm7VPAVVA jNnYuglvFi+r2Vm/r/5mRuDVTY+izhDGPSQQTLO2gVYm/0hCEZkwUdACfp/LWnP0VHM2oC2rDvwH zH1KaKVpoGmgaaBpoGlg9RoIxRUY+5dsVvDqg59c3F5K6SILmS8cM67g2LNH/baB1WS5ElQ1NwuI Ekz9xQLjBjkjNwFe320pnPbgnQApAHI0XI8GNk06LZDSgcNorpbtBug7Rl19yDiqKZqTneN7lB1L 4QVacVgztwOlVMDN/shcjdvdwfbWNNA00DTQNNA0sDINgFkVnDLNCLCy9OZmQU7gi6HXbequTfgc 2K6RxQHojpHOAEcZqSxTnpm5xYCfI4wASecOH0jyDoDRsK7OD+sYMU/DrmcAvHOFZd8z/LyCs2Bq VadF+WBgf2bWsmReMe/6pF1gQZltE9aMvBWo8VETtCXsC8g5S+r5YNBK00DTQNNA00DTwG5oIFDq 1J3EP8EcNe1qqrWYLxlkA6iALMDMbFigcxdBDAzKlikCs1sCYw9pgrDFYwH0Huyo5D6byptl0oKq HDfzgru+0hgWLIBWEGXozD2mP+oK6MoV9kyfZtlK6WTywUDoF5Qtpse0nQ8JI8YItc6R9qdpoGmg aaBpoGlg9RrIcoRM/JFkZurRlFSOen4FZQHLJBkuxKAfN0AZf20FxQrTACkgWf3BtigxNdtnkmnQ j8cr6LLPChQH7sHaY7JTF4KoYVUcYd8EUHUpRIueaKdLyYJl2dZNVzJfquvv1eXsA0LAn+OOUIO0 eIigoSx64n7kiQ8546b79qdpoGmgaaBpoGlgpRoYygjrer/Vl6sptwdMgU2GKvjKUfXpCm5ZDYn3 ADQAa9GkLNMVTMeYmcmnAXizF8Du1+TVdC1oVsC2NZ9AZKF0DeCc0DZjC7CZ1gQrDmOtLFbz8YR6 grNo25vKXWghYyBgD9iOE6mQOVOOOn9ydvPH480E3WujvTcNNA00DTQNrFoDY8G0AhnAC5ay5lAZ kxJStNWqK3jNeWn4tQjKdak/wBBE1SMr+7SfTGeiWoKrmI5EJ3aQdv51DrHtl/xJ4BRtCZ4OkM8T nMUo9DlmLrG+4OlsM4BvcJWs12UGB5MK/EtBmCKjxoLN/GL8xvQdD68PEex3ucLAu2LwRBAzO/Lo H97g3fqtNA00DTQNNA00DeyGBoZLGOUmk3sT9cy24CTAMskHQCYQChBzTrB5l2WnArNMNACKSdhp SkYsb00BKQueDNfCRmPa5nMYJwDaT0FyTx9IZb+u2Zv1hZl+JKkWcjVB286EHdBVphe5YlLH1OmT ViQMAXwJsBoiZ8AXWbAy12Ar6mrBrh5qEnPQjwzec43tfTc03sZsGmgaaBpoGmgaQANDcy+7FGAA VXzVxAwQu5QfWBaTbwVU5wIDbvpeRVUAMXNvqSkQylDj15WOyi7dC3BrSra9ZFOwl6MGyOW9Am/3 NQjgC9qaUGO2nAbQ9Su7RCLNw2idfrwY16QhNgusQ7cN3krAmL132bHAc6KwZdfUk8UzrislyfbF c/3FMvJWmgaaBpoGmgaaBnZDAyzGUNlppsoKkF2UlHmdLTHiUkfWqMk2ZmbnBANtiUCGAa/DTAVn 4471wQqqR2YbgGFlrg/AuWS8qkBswJVg3S97aB9AbwC6mpAF+ZodK/3S0dA8kyn0TRHMTTOZHkFW wTgZsTjmcwJPAMhZHwhk956RxYeCfjs72p+mgaaBpoGmgaaBFWpAl6tcNENmnq1gFR+qIFtLsJg/ JthY4h92hSHbCX4GUMl8+4Cr9Aa4hfV2wC0OZwTBUpMwHRtZrXnbIjAKlgFTdgU42e94stWjBblk 3rZ3HAG+AmmVVACvJnE/G//si20Bumfh3VjJDd2d99H+20bTQNNA00DTQNPAijRA7FRlsnLI+FFB t5EoCW4lH7Sf8QjPSDNpHQzEQciap9kALRCSSCoBtk8rKejJWAOgMFb/Hc1SBQOVVY9F2Q4U3aO9 W1APOAPUIm8imtl07PpwQEsqOdqMrFoc0iWdtJXh5PSZxZfoSzCvSTcqYPvZ8Syye8/lWDav7G5/ mgaaBpoGmgaaBlamgaFs1+hiWajgluxVDB9rbQCyskgZpAxTphvmaqSTJmuK4KcJWx+roGgJAFLX +oKkbe1D8BP+BEOPxffLe/p3P5XtL+yVj4Fvk2bxr+9XYA+EgtYGhymHUdimrNQvXYH1GHUG17u2 QD3A3nP7joB3R9tb00DTQNNA00DTwOo0ABoCirEnYwrWZCsoAnxzAqF44xV+GoDUbDyCYgp2Nhnr PxakbUPNPsrYQCcTcVSANq0kn03gAfgJnhWIPck6lp8tArsAvQa4y8Lt14xWAUq2fUio5mrAlmlO dYqRJnDGFmUZMm1g3fOY0e1V2cR7xuA14OSsM0uO6zqutVppGmgaaBpoGmgaWKUGIKYm1qhgN0vU spgMqAnHAVqm7/gP0BJ4jY+2TSKPBTcZJeA6JZo6HJV6MlABz/pD5gn1iThM5uEcIQOsBMOYnUHH fKwEt5q0OTxkOUFHM2NVv/qS5m5lYvgAqZHNyQXNjgWBYZVlA75IIujbpRHQFs8orJl0lmHrjio1 b6VpoGmgaaBpoGlgFzQwdtaQU46EKZf+0wcruAq4/jPQKdt89rj5oGfTLAocgIupGBat/5iKMUP3 Uc0yT0FRxBSkBUuTYWh6li27OMMSRrpYWKfzMQvo9iy75l0gVx4BW7CfC5qmlaRvzeebMNksYQgl V9YFqy9VRl3lSW8BYcb0gcJ+sZ7Py5GMsQs6b0M2DTQNNA00DTQNEF0F8o6x3wbcZKgUM0gZ9ARa BfgE1jBWzbqwZEE1Wal4FyQrWNuwmpqFTtkps4vtDFBkDwA6kv3SR13i0JEosuohiUCoowwBZdtg qhZk3Zfh+ZRALgB37rgAt8sVZhUn+1Fe6rBYE38ZAzO00hWmPeEZ9iBtkMonDacy2akPDa00DTQN NA00DTQN7IIGtDeDTGCRZl1ZJsDk2rprZpfiwEKwogS3BDZeAUqyXFQTswBaAZwVfzlqqUFSU9Bu PqvAar8yY83QjmPfeQcwLYI4NDiAmh30GTM4PU7cBqgr0CMXVe1H0UfYkwV1DqcOObhqoJfnQzvB 3ilHPjRIhO1V/qyZvMqa0dqfpoGmgaaBpoGmgZVqYCyoOa/XzFBuV5ZZAS2YCFwlhzNiCcL/P3tv AmvpWtb5fmva5zAooogKiAdxQq9oVIK00ZYLN0Y0DN3YGNFu47WdYlo0mlZBgXtV0L6XyL0x0QZM jAxqQBuuVyHRBkLEYOSo4IAD4sRRcUCF1lN7Tf37/Z/v21UcTgGHs2utqjrPu2ut9Q3vtJ6qXb/v /7zP+766qNWNupDdDUnFKtIMypqz/KRQ20NzpbXjv/H3cjFTmsxJubilybfGLW15FTI5hhPdyBRx LNr63UJwxmpYBWwBSz/plA8BtfSk05l4ELBHqNm0HeVM/2krEdHUnwcL6vORwuS5KDZXp7ZAW6At 0BZoCxzDAlkSWSgmwErA0QtRZhSxyTWdo4TJk7HhkVm6eKNIhTYgc4lKU1zGHqg6M6YsSJWj3Kd+ gWtSEVNB6gj0uTfBWbUbVZ3e6DFmdStgbc9qAQ0PqyNGVVcSzrZTZ3mw4FDW+tBgH+V8Vuca+z4W 7I+2QFugLdAWaAsc3AKwz7HZgqIu3+KXGrfSnKhh84jjLD0pOEmBKp+Crly6uqvVsdMc3ZGEfpBH yE7LW6Y811Ov9QFO7+tWPlWKkwysEpq2KZitmZ7kMzDlvimKmPvZD5gFO+RyKVw/63sZ6JV+Whcv q9EFHfCnln5rC7QF2gJtgbbAYS2wdPzUHzbrC/Cc58t2SHHzCtY9alFFusIdbLBWxlF1CwPKcJH+ Zj1pIYvIJWe+wQTNnAhXFGwtkOFmD7qagSIViHZ/rHjnxg1eE/hy3jrJKzwhJ+f+YSKUWxd6T6in AQUxtVCHrm+hbapxY6CLK3zvWDT9F/Ne92Gj+jhW0B9tgbZAW6At0BY4oAXYjrAU45w9eI0YDuzG KT0GO/EnY6n2yZ2NTLvtOgtr1MIYjtGWChZowtNXKc1IzZThIvUAQIEvUHlVXqFYGPaaUBXMk6pO 3rHOjFVbzk5N5S2tGqZeYTztE5xoa0AdZcx1W5gvKgAswE8VVtSpLdAWaAu0BdoCh7fA0mk8tU2f azwDM4jsFCDhKtB8rZ2ThCsaGRkFvEeVhtzoyB2Q2yiLR9XpOLHbDKoykziekuoTIcoevgZEFXTd 69eWXPnKdrN+NHUJ2Q3gFbR7Ftmwbx6nX1zPetVU7N7FfgdVb9aO5prbHtpsxpmpe+70pwXzhXc8 ZLDAx8bdnFDwUzDY1L/+bAu0BdoCbYG2wKEswLoapXp136qAVZ6q1TMFS09K0aJyUcnuhiSLTftZ Ng8EhvKxlK95Le+nSjYSmmPvC7ztGgi7ahbAtA3Xcl6z7KXzhqf5witXv5rpCqc8ytbAK/MWUAkM Y4/gci8DZEEObaOc+dQ9HXc3X0Ow6xYHvwH6nsU+GF0OzJ1qRU87tQXaAm2BtkBb4CgWiALWdezU ngXvJ8BtKyAFKEADYVncQlpFGRPZrAq9dY07FxgLOPQoY7BrIAj1WIkKHRvA5htJOeqxLtXxfEmN wJ6cgWjgikvbqUcrVTerZbnIB63VxhAjyOeJdi5VLYxrPBlGcyzYvVPPBdZs/fadxoVyvh0PEGSY AWi75D0h3Kkt0BZoC7QF2gLHsMAyipeWl4BVSG7WwleICamIRcB2MbDJW2sgFoQxSAwfWQf6NHlP UK6Cb0s9UaiUtE6Vq9OPMgUJCi6QzKpTRfcC8BqlbFtGMO+Av4BVn55FMZPHaU6pK2BFDRdtUw9F SbajYlbv1jxiO2d/HAe2/mheF4KmP3V9rCTl+60t0BZoC7QF2gKHs8BcqEHLwM1mdQXnGsgST1NE cSKWAZrAFs8ryjjmGhDCtLiphZ0vAWe9ASDVA9+4piknhC0nJHUVm88pTfwplzWLUxd8hbiquZap tFHzCu5pzrE9yTiudCVF1VLGfPaRlqPWsxJWECym6zv5kDDlStZ+awu0BdoCbYG2wAEtwNBp6Bmw ZfHJUTWOTAs4zbNanGQzBfsWl7Vqk+Q9XdKOwWbTBK4tGb+Nwp1kKtcMlJqSgVaeCsAJ1jX+y7KT Kt00zngxOzfU3GT7KMhTEe2XSha00wOCdZ+gbnUru+mDOzwlOps+2Jelrm/Kb1wOc7xmnzu1BdoC bYG2QFvgGBYQaVkFy88AcYRmKdlSwwIs2woKXectkQToBD8hjJe49vyFngvm3XotL/IKPKHquW5m ty50zBnPcLmlySNMmWlMnQpygU47btVkGj+tw/nD5Y6uBTvs25QcOpapiaRGi1tHVtSiIecz2/4S OJvJfnjeqS3QFmgLtAXaAsewwNIoZAGpij1z3QLDjOECKKEcpQnc1riDE/CElBSNWZqSvC5juVjN B4aCIemafGhpxoed3pS6yWOy7O50neAqA7oEoHe8bhs7VrKauzUhXMx4LkB2upAR2vbDHZBmS/LS F+ueri9wh0vzNZA95fskWR8PDALaKhNBTXuLtEl+7ttmp7ZAW6At0BZoCxzDAnPHZCeo+mkKFAGX 48EmI5R155o3i2QAbBfUUD/qxt1wz6lFN7CKVqA4I5CLe5OrV0AGsEpUArAsp9rNp4qZI2Hs/FxX tLK9WuMZgDpNSsCSp+b36nYmkhklnqAqZfSYqCXjy9a1WK2ALQ8AQNhpTRvybal/emigmU5tgbZA W6At0BY4mgXm0+IVwlLonalRwLWMfiyVOqnFwBrAnblvhR2clmfuPrRkm0K3BPR4WtGKqjP1aOaE 4XEseIZC9ocR2biDMx5rvYDVqOhJoe4Z73XnI5zgREwLYuoSxipcylun9cv2aUzX7+JUJj/N54sn jbieU0XDN3bst7ZAW6At0BY4ngWyHaHNX5xPC+RQukYJT8p0AbAc+hWAjt16fT3CTc0sBGe4fjeq TTKucBNvNrqVJbOuYCqgWqEoAAm9zjdWhQpNPwX6CeOz3nc+8N6lMWlrB7DjVWZc2bYdJDavYt3q yclqWACZcmuUs5HTibK2DV5+qIKdfcRNqxx2uMtPT3FNj/1IZ/qtLdAWaAu0BdoCB7TAMuCNvhyB BKMc/93F7eyYKTAdj2VYbaRQytK5w1OK23d0YatQDX7aAtwAmmOqAJy4snOlSs1Ry8rXgDWBVqVs Sw3DWspHaQfIHAtS3NxeW+NOXgDb/ABS25HyW4BtH6N8OVcl60kXwvY/7UvrHNdnTs7zDXf8rbzO Ly2HG2+sdbjPr86uqS3QFmgLtAWOaYGlMPMnoKInW+Sm82adDqRCPHUeLnl0HScvIBVu09jx5OYN KMdvkihkwJoxY1WmL2WuMnpMcQt7aTwnOycVNCXwBWvwaNHsCqHurmuqYjoU17Pj1FZtUuDOmIYU V7o6Haj7XbZrauPYhwnHj/GOJ/m1rkR68wueODz0G15+blXPFo8bfvWd/214+IecW5VdUVugLdAW aAsc2QKIzRpLTT8A5dk+v8IMuAkt0WcKNDkObKGXEdQCe3LlmtfkXFtVrFN+ajqRLmPq4b55S53y CXXD3ZSiPcqIXhW0c5IX+I2FqCtZlSI38hnQGmE9at6xaPLyNMGpgVgGg/mkgNvcPlGHq2rlkH74 dWT4yO2pinP8PH9S6pDv1BZoC7QF2gLXjwUYjgVykChwZbEKx3ldxELXtE5bfyY1emIgkzKTFPAC 3wAaqAk0sWkAVdaRJo91Tso4bVBUMDuFyAhlk8g2ohrCVn5hS4sJ0qIvOq11Ka8Ep30FyjumOXnf S/ZVlLpoxyhs08VqtxBre57vmY/kA4Hloqrrq9iNTm2BtkBboC3QFjioBZSkccsKpWEtmIAePlrB axKGqlYBFiDDtLh8dTEDNjdXCGiJZ95sbwVwlpWnbsggAFGeUaZcU/FybW+EMoCH14EhTSSPWww6 n1i1vGXfQsubP4FVATd1AFrnC2+33udFa7ZSewIDZACtuzltUmZL0FZ6YR/8bqhzXeEFZO90agu0 BdoCbYG2wOEtQGwxgMv8XWBEuHPGggHgCeBczU4C00xHAmAGQZUy3g8nK+5xbQO0BeUNq7sz5quj 1K0EWe+ZH/hYwBW6vAS2UtloaSGta3vP7kkODc+ZqwvLsxCHLujlkv7wZ+YWiVHC9E2lLP2dpkRP HSteA1Su5JLoX2eXJlUy34SHgCXfSdEuf90JScjT6/SHYp3aAm2BtkBboC1wFAvg3YV+wnEG6ICW PuEZ5zuJNTl1IZjXSm0CNBBmXgEszOJ6ZgUs3brq0TlQXe9Px8hn6oGQwthtDt1/eKVyFeZRp0ZK q7BR4ri0s8+SRAXPPBcwoMyylbadMVvqVjgD5/0WmFsvkC2oDgSMXQC25T73eyG0gTfTmnCdq+ql sGPMbnnod+jUFmgLtAXaAm2BY1kATBWIVLbO5825YOWFNuWuAK1PIZlFMfj0vrSeA25hpzvYpKI1 Mlm1a0CXcEwgFiR0fq4CFtqPMKwo5ZXTkUintgNgTfM5tQBola79YGpxLQzCwVYFzB/3FV6xf7Ft CXRVtFBWFQvcSa3btT3tO4PZQK36DsmatvqtLdAWaAu0BdoCh7YA8UlGDAs6uagvWFoV+OLp5boQ TuQx8ArMeCsAA22DoSinehXItUyk+rXyxKXtHWBM1iTzGgFtpLP1eDkPAN4VziTHfpG/vNTHI+Dp ntdV36f4vkWqIJ76bz8dC87DA7C/keUoV9R/tgBI6F7111euY9vr1BZoC7QF2gJtgUNagGFXxkmB lRCb4d91MwRXuSLWCbUI8UgCtgKeQB7wFXy+iy/PN0RvLQJirzF/GA0sbIWssFVVR6UKQ5Rq2rIw 5y6cUes+e8pFfcZJtM2pl1zD2dFpoV4QF7LVN2GcRTbot1OWBKv1pK40QZsGZXFjT+DWlnHjBIKl /bGp/mgLtAXaAm2BtsCBLTBXuOpaVtn6lvmzqmDk76ReVaeZ5APcVK1xU4/u4cwjxm2ckVyiqYxY NrnpARgsEFKf0PXHWcUq7eSyTVvhnnWmXq6kL35ShwPJzn5yKpLdchqTbu2TE4K9+LRvXq96/KSP RkIDciOe7aY1+6Cga5yTszQp8rMLfdAWaAu0BdoCbYEDWQBxC2jlEqBSrc5mjKkCtgXjsgLRHz8d 21Vp6kr2PpcAJWQUurmP+kVpimqBquvYl/cCTk4zVsxOSV5IGRvmaLVC20JZ1ezeqGXqCPRpQyVr fapkg7a4GXf4jr6mP/RL1Z3+UJv1CHi3LbR7ebiwvrTlgW7itwAAQABJREFUOX3iO+xR3pewmJKd 2gJtgbZAW6AtcDgLZClKwSeUhOmOqTqq3SWQZDJQNkMQdLpxozbpWwVeoTlRmWJsRSDWerseTqG4 butyBXsH0CWwS/VKfUjOLZs0CEZBSrW0W4j3fMuNNWO7u2QwiyA3QItIZ645XYluZGRYdSznqbb6 kSAr4I8rOlHTVG77eSTgnpHQtuQ9+51dm3wy6NQWaAu0BdoCbYEjWICVsFSu5bJNAJRA3J+gNnHv ojLjNlYxkk+4KiQzrksZoS235WXm+AZuqlrBWHDTZR2AUzBzhgNVwct0JFSq9UadCkxnFu2YewRp ExBG2Y3bEdJIMA1wT1HBS9zJls81wDr1O2tPWz+AHTuRlb28TlVxbSf4i65FUftlOrUF2gJtgbZA W+AIFlgGpgDKcVfVZWA8nNIViDUmIRkECmoy7lGyLo6hwkRvUhZ4CuRxepD5dU87NchcJiEsG+P+ FbrM79U9vAGWjgunXsZ7nW5kRyxpAQFeY9Dk5YHATSL2KteMQRdIzbkAxAZ0Rc0DclrPw8KONtIH x7S5b7JvQtkHh05tgbZAW6At0BY4hgWcSjsm3czACrg6/itQDcNSYHrsp6nEpK5cdhUyolgWhq1O Q5oSgAtsq6zlTQ4dC+EJyusR7Pqis3QlazzPbciMLofpdfpkMjhMBS5oBXxUdSBbQVzmWdhnO0gS u/FZc+zDg0re71oR3ap+Fx8Zv1RK9FtboC3QFmgLtAUOZ4GsgFGwJZhpDAtWjcpMA7Kc/wv7ODHq WNiVu3rmeDEQ228nvMm7ui/+9uTnQ9oGmH4lF6MyqYJVq94X8vE9C0nKi8pMGRKOupKFZp4ShLMB YwXfRDlbmdBFJ1cAGRCm7slNvmDNaDU6JdKW482wOxC2nq31d2oLtAXaAm2BtsARLJAx4IIX0ETO Gmm8cQ/gUWVumBAcBYtb2Pv+kDP3S5wCN5L5hXLKQUAVsvlMiUQe6/Na3NFcd/nLOLcddwaktfhG RTUL3Ywxj+15nOroR4lkwe8UpBA67QhX+6TKLVe3daquuV1dST6/r2TXK96pLdAWaAu0BdoCx7AA WNOdPCpbZ8oCT4dYhZzgdDw2cKV3wixrKnPsXNspxXUtQCl/KTi977jrjHFbARsoUkz1qpo9WXGN 65l7TN7AFFL6E+jTvHk99lOGUoI3pkhx4laE1mnE9rScpd/Fnri4CAfjgwGHfCFK5jv4fTiiQT46 tQXaAm2BtkBb4AgWwCvLPFw2J5Bui/0K2KlkawxYEldwFKrYpbFIBS8/oduoXIWuP0t2Q3KqEMg+ u+d8XBWnc4fNw1wjXN2S0ehooEr7cTwLWopZ/1kbgpi8lhS/wtwxZ+cA7w3GIu8UwDXgbl6xrGbC wsZ6hHzUsMC2V5RNH3xY4MSHjE5tgbZAW6At0BY4hgUyDzi7BOKV3c1ZllJYSTkhKixzVCAsdYzb mEFhVan3fDsDZoAIFIGjxV30Yos72889uyOpXOOOdkiW8pDZAyKiyaykta5RMZcqFtJcBpTGbzkp ymxGXW/c6kiQkzbbU9oBqEDY7ZJc66N2c6pAq7Uuddf/IDJsQd/W5I/CTul+awu0BdoCbYG2wOEt gNfXPXSBGvA0SGrDustrqHfKvrpe875CMSrWHY4ELy/v+Yqu5dxlHstdXMpUgG4y1chzdyZa4d6G gjBT4LuNoFOQTAZ3iXM+sl2hGjordFGr7mTPCc3G3YzC5mzm3sErnOecOF49W9xtWOGKNthqBa2N pJ4vLEe/HehVlicga8m5avziBhTJ1G9tgbZAW6At0BY4sAVqP2AkY8EWqLKS1Bj2HHeu8lOI6coV to73xnUMfFe4lYPH+I5VnVzTz2vAFGPJUblA0kUzNqzLzLJY1GOQV0VOuzXgwnPzF4LZuaigvrFN oYwbWYbqdp5SxnmFv+O81M8jxLBFDauO1wSR+YDgg4SLbmQLRJTvjoVFNqzWpSt7gYI2T5a2nCrt z7ZAW6At0BZoCxzQAnPdyrvsJAQ4mYdbEcvCyTm+ghnFCLQMdkLHFrQCVdSnkc6A8AbugdYEcN2K q3ntcpa4et1AoRLKFFXqK8CEqILQJGZBdI59090swG0veQGlbbiEJIdpw75lHWpAah64Wq5p8ljz BF/r1V09eqrHFoE0ZaxTdHdqC7QF2gJtgbbAMSywVJmqBkMnleyY4gLm1GDnaNEoRm4KvTElEEvg Zcx4GE4A7M5NG1S//OwgX9UdnzNQrfoVs44Te6/UNIqUsi68kdWzuB6HMm1toKXtpItT9zgRoDST dpw/7MJY5jEIi7UqueeosfWZF2Dj7q4HgqrEtp0X3Kkt0BZoC7QF2gLHsADoMmiKl2rQebzANO5m 3bskx0xNAi/LRHLsOsqO3y4zLgvsomgNzKotArObUlzHqlYBioKFuvUqdes4cDZtkKKkiesCc0Pw VylUehVQkgFubqSsrmauTc8KeryTZ1KzVOQDgPdrXjLtovD9ngLa8lW3rXZqC7QF2gJtgbbAcSww z3xZ2nZcNSAFloJRNRs1yb3JXaxbeQ6kXcJxBciijgG26pINDAM+o57BbXAYtzVjugLPwKjSno6/ oljh+m5UzgLUNH3G+yz3hShtTdeL0ozrJjtIHeFrvuyARBm+RtpzmlH1m3nCzLJaLk+S/9Jx32o1 TfdbW6At0BZoC7QFDmqBLL2crflmJ9XwSCV3IRJgRicvIW3inYCa2xLC0kBRdSwcZ0QcO9VHgOsE VsUWYIGkEc7A2p/axpAtDoV2VDP1O9QLoC27WVP3qJyz4QJ9sQ0VNy2Oqrcwng5dAnBd2aWlGW92 L2MUtlHXur1t1ylKO5W139KoaJJlOrUF2gJtgbZAW+AYFmApSuf1Cs0LaT+oBKo71nguBalLFxJG +apsjXyuMmuAyU1erkh1UjAWlJbnx8/FcJIAKY+DPSfpjsn6a09hQUg9AnfDG5Cf+jG5i8VrVr1i fWr7m+Ax8uky39CHJU8F0x7GklqFvlyxtaH9JVjMqVW7/ZozV83ywcKuF7LH7vRHW6At0BZoC7QF DmYBAHwK0Fz72VWwCp4BHMpRCGYPYNUpc3odR52zWAe79CavQNxksHUAaqAO2WkdykzL1rKVQA41 KkgvqFIRs7qgk4N8cU8nt+07MDzVLZRdXQuIq2I5zn6/VO8uSjYrZGdzlr+U2VywuKC+cGpQlhsx sEkDKnjN4h6leecVoQ3AdXNnwZCDmbobagu0BdoCbYG2wEULsDSVY7fA7ATViqJV1KoOXVZymDG/ FoUpAIWqajMrTHEsZ1dQdw7chGi9zFbu4szRlbMki69pBD4m2lkXdtQn0LRcgrZWRFOf+gBQC3Zk ZyZVN6TM3GQq0SmOjEUgjy5p7i0JsFrPWGXLvvGgYL177u939t/FRARtuZ59YHCnpXJpC2FudmoL tAXaAm2BtsARLMBMnIKQi1ZsR2Woep1lDjAAHFe/cmEM5wHrXA6hyb9eOw+4xopdKzpuYaEbRYpb mGgpIQcGqQ+QGz1Fc2sWySiiuyEDypc8uryhKPUJV0HKh58MEqtWTYE8n45ZC1O6RLId5DfJIOmF iplz1XoW/+C6CtlAMauZo9JTn1+b653aAm2BtkBboC1wDAtkKUrh6HiuwVKCzeSUH13IO+YJG1Bl YFWmKaEghbbu3lpS0ijlgriw9VglWmWog7JGHme8N/UI7cqvH1nQykEfALjBsT+O1PKjS5nrAtxu uSDISpATqGVfvW63LOeY8wJpPadTuqbzMDA2oys685r9YtTnNKuUCMC92Kkt0BZoC7QF2gKHtQDE AoCOlwpPIGaK+5dP4aZYFZ5xKXMNjzMMM4r54vQgGajaHTUm94LG5OFW1K9A9Y95MtZsu3ENW+F0 D2IagMX1PAgIZMjr4h6ZPsR1NCz1FlkXgh5lq/LNdCU+9U47jzhTpdwdiSIb+8ONwi7g5ktZrlNb oC3QFmgLtAWOZYHlDhhlmhCQ01nsWswrVtyocVqUMQFaQk8oqnhZ3iqQdBoRB+l3YMzlrGKlq9cd laJuzaNbmDegaT4aSV0pCxhlahbY4LPACqo5DpzpU9alphrn+brtIYPO43xeLspQCGtXzmDOST1A AO4EX6mUxzYpb1cE9tgIB53aAm2BtkBboC1weAvMT4GUbmIVsOox+/O6eAbHRis7piqYi7Wja9hw Kiip0oyqBY4XTnEtA1+RG5DqPx7TxalOzssVgeTR5Uw9RiKbvwDP9CYVra5v7qu8VcxOVrblIi6A tijJMlkQhM0WrIM/Sap1v4sXRi0elS3YTTNW8OIRAZU8XqjL/d4WaAu0BdoCbYGDWWC+Yv5ugIkb OKAjclhoZaOFkbtgLpHHAaOQE466jSeXNSBzWcqBBTlcb1nIqoDLLQ2U3XqQsWRXp5qgt7UOrpts V5jGDT6ud+mGDiZ1uVOg5GmtimVEtS5ldzViGpTQT5+MglZt0w/bgfMi3Gsqb79jmM/1jGGTzTY7 tQXaAm2BtkBb4BgWIGapoojdVzf6FniqOsEUQ7MoYNzJM6C8BmJCbe6KUnBLWC6BpfOE45q29zv2 27W00Bu/jXvvWpeBTwLPaGqDtCqQSlhTD/ccXBbKbM+UkoGjChY3tCtxGdw1pz/C9GRx4zBfoXLd QBjCqnNdjeuEjghax6m3wD1rWlP3UsmMkrdvBpWxZtewR+W72lentkBboC3QFmgLHMMCkjbQErRu 3RepKdAAnvrQFaQWLNJxAiijbEd1O5WjRFJUNGBz+ccCXSlPF+2Yj6tfCURdy7qIV4IZmOr+3ulC pn7Hn6X8Are0ALZOSmTRjQA57mqmP21OS83St2m+sJDXb04RpK2rZtXUJL+DgVyOc5cbm+NNbSYB /qvz/d4WaAu0BdoCbYEDW2AZxYhkVEc6TXe2XAw3sLSk0c8qVUeAhwVKUfUKIANmYJ0lJIUdeYTf DDU6V41yT6Vc9QpKXcsCVWWqI9mqULt8Jg/AXlFmiXqNoxko67ImO/lQ47RL7RmzNZr5LFLbdrkv YJcAXPI6bu10JAqyBsce1W5+gsosTYUVP0YJgJwG7EyntkBboC3QFmgLHMECcxWoFFNh7iQUMM4Y q+BCNa5Wjp9y2SWySFMQlYWyhCX51JGCMCO2ZBa6bk3o+VT3Ce5q23DfX7m9o2HB7MYJ5k8/qMng LHLFrc1tGKsb2r6hnFPS1kgCmh9ZGv5SgXsAC26Vrg8U4nnad9j+GUWtEl7RB1fHmnptdZ3aAm2B tkBboC1wSAuEZipWgeZYql5gI6E9h1KBpuOu4ndyC+unXkRdGsUsWM0M+FCxOno3TF1y718DspzS ZDCW2x2qeCsv9ced7LrPVjzd4yRtVmS20PWBIOAGxALT9pxnHNezhanzlCAtvMrAWKjbV9shr/3h U7FsVTv6yXAy1+phgOquSFpfePu51rvf/xPj1p3aAm2BtkBb4HqywDJuZtjmzkFbKWbClaz61OVM qFJcyrAMiHGuihRqglKqATPjppcGReFidlXI/UbpCgaBoS5koe7iF0lMXcq8YzEZZVuA1C3NHRkb 9tuygVJKYYOvvAhW7RwvHxDIbXwX3nGBa8H0j3vm3+mPBs6WcRsJS5rLdaB9XlCHq5OvRHrQlzxr ePlN7xxOxh0e72wbp6f3GB50tztbS5dvC7QF2gJtgavJAuzip0oUUEYmLwhwAlxEOifUWUwFiEpk 1OwKsAFFA6320o9yqtpAlnnAVBTo6RYuFzRKFum2J39NTVLZUifqOEFRuqORp65KNdN9vJxA63rN 1scfQK9reciCICwMIpTtjYo4DwSURaFLVTeKcLMFQe5ev/wBxqLXB4J1wLshqtoFOhzr9kHiSqR7 P/jhw2MffCVq7jrbAm2BtkBb4HqxQBy2fpksfAHkTlYubqHqJDCKuyzmGEC6bWGSe+myxKN60u0D s0PS2nHaOo7bFx6CVaAqAXFXA/bsw0CemTssEbAluB2jNUX5ks8xaOf2qqlnww3ZVEH3uC5n5xAr uBcM+BrhrDvZcWTVrdUIU5jqc0K0bTQveXyAoJuULSB7d+6ymShx+9CpLdAWaAu0BdoCx7DAXM9w VqqCXPN9+UwFo65p5/sqHp1K5IlLRiqOTQLPmbXOBdZdrcp1XDbjtoDWOgyeWmzxSUPOchOLP++t xGDtMcw96xKqKvG1L2E+XKAPQrlUsR/6m7euvgWsQ13qUAinvBRGKbt/sOPNQv9kdUP6sVmvcYN7 ndYdBE5v+E6d2gJtgbZAW6AtcCQLzONCBqRRmaOb1rFZr2ctZQB3sjyJisziFahKmBtYzpnLm4U0 gNpqyWpZSs0x1QYJQnw3bFSrANzpRSYX9uCsoGxAFBTdq4q5tz8FzeSPuqYSla/3rdpS7lvsalcq ZQO6stiGijtqltFoykS5615GIef7cZ8vmgAsh4Z1WYfrLYDz99FvbYG2QFugLXB4CzgTCJDFCQzo cP4CPKchOY6LNzouXNFoJLRrZ6wAaTZioIxjwQJyznKWBWWJ5riu+lbgUo6fwFKIQlHBC21tNO2x IXHawC/NdcqzolX6A1zLdyxkBS5tkzeynHwcJblfsH1zrLiGh+0rDnBftO13ymMBFdivLQQ2Qtvk eae2QFugLdAWaAscwwJQTxAxTgvIBKNTkVSVLoyxl8BjcnLPApjtANmWICaT+MrmCdsLgZ1AU5UW QC1rnQV48zslKThMtRyP4B+MjI40LXVrmdRFmy5DabBXNoUgv21XtDMVWj6ucqBLNqHvgQpeBV4J oAth7/O04VrUPlxkOpOQ79QWaAu0BdoCbYEjWMDYKIBVYU+u8+yYqm9Crlaxqk8yBYpCM9OLyJap RwwiOy6b6+MXEMCOszoOu09wFWXx+cYBDfSig4GguntDeYUou0JQhgPYHpc0AVlCWLFswNSpqpz8 Ucxky/7Arr5FlBaimbyOQXPdwC9pLJwpsWeN64It2pv7mSeMAM7Wiebr1BZoC7QF2gJtgSNYgKBl p/wAWeCb8dasypHh0yjZqU971OPkss1qVoAU8QlkUcuCD7euAVOOrW6ZezQpWGEr1I2Wzhxi5Kfc M79CWje1AV+ZghyQSlxeKnEKyvKLY8dUBKETIGZDAhaYxqWcerxP4nhBnQaG+RBhX+J1RhZzCOZp 02zN35ir39oCbYG2QFvg8BZYCk2HX1fo0loSssCqihWYQs4dkxSnM2AtyNxa0BWvFriGDUoOuDmO 69ldiPhBdnJd4KFEubfCB6x7Wtew1zJDCU28ZOUO3cpCdM/9WdzUZioFrLpOW7wLZeGZ4CvA79KS SWSn9UwvEvZGO28Br/DOfGG/BTdsh9JK7HJJV+l+bwu0BdoCbYG2wMEtwEpY4g1qkaKEARebDw5L dkByaUcZp2rMillRkCKMEkRMb5j2k40TOHfMWDXsXN4dbt99YCeAcRzLPJtw8FXpSXuux+ylGjMm 0Mp7njuma4O0kvm7pwX2Oe5mAUpVJOcTG0hl53IBGHNA/7ahrn1WAaOE06bgpXmmN214GBDSQjhd qeL93hZoC7QF2gJtgYNaYG6Qk4pVN60KWJU5n7EIBgFY05Z+1aNSyMJveQLEWAlLZJ7wCXspuxtO gSWzeJPdOGjhbspcXhRxqWqgjt/YpuZGRpGqbXA4qWjaALdZRUslrYI2JYo6EdFFXd3aJqdA6Qef FvHKeHAgq1oHvvQxfVnt6a+BXPSR/s4cFO7UFmgLtAXaAm2BI1gg84CdF7vG1Su4lkYKs9qUwUxu al9jqCAaIAeguIqJh0J7AkWk5J68qluBG/furlbJKmevruZRfY4A3gZ6uo+B7Kbc3Fkpa8FCHFxz 9SyBPAeuBm7V4hs8Fnis35r6po0dhvk69W93rNJFmbi4BSs/K5bFWvAAUNdOo4btcjF7VNvN3yP8 k+sm2wJtgbZAW0ALLIWqmAs+OXazgqhGrrlmleO8cQkDSxe4MJJZFmZtZ2Do2sxZ1xkY637WbS20 dSXrkrbyWqDDiGcUKBd2wHgKnFoQh20f9CavUdAbjrN+My5iEJy1pyW87KUYLmW5X+TcUp+rZbkg CLs9kJ/23ZswJcmHKs5a1FaOojYJdQHvI4PQ7tQWaAu0BdoCbYFjWGApjNC6Ubiu8GiYExgLEB0+ zdZ9EpcU5clnrgtHIWYKzyhnBcIOiGYlK264rrSeaNdtNvhKdlpS5taUIkFYVTj9iKsBpPe97hiu /fNYmjumbJ+FtvnnkJmlQ2iTXo8u7Khl8pODhwCwzAOBgWYqd/OtgLShYumE1XZqC7QF2gJtgbbA gS2wjPsY2C0YW90Mp6jXWvRCOGVub1RiTUGqXZPoIdd2AaF7/UK6uIud3+u4L/eArZszgDgg53ix R4Z6OT7MceAYFiJuwatubd3F3DC4ilM4ST+EsG+sUT0jsKvGlFHs9DGq2eoFMa+97nA5TX2lcD0u yBrMZcyWn/bd3ZtMor1TW6At0BZoC7QFjmGBzOQRRwYmqTazUIUDpTJzBJXgRcjmno5hXcxGPxs1 rVt6z/2oXAplzJiictM1nTfQ9JTNEBwLrjnBqOlwz2AveTi6hLm2B9p7IpkDetpWjQvjch+z1jQK WGjaxyhh+ynYheroWlalmwJo+pUxaC4p4vN1eCtAB/fJ229tgbZAW6At0BY4tAUShJVGiRY2sUFw opp1QwuqGRsfSNNAjnMRKNxcnzmwpozu5ixlqSsbReyUJCFaU5CEZNVFyDUq9AaxalOMz5YCtb6M F3MtIVSc54dPFbQQ3m9P+WQMOt1UyippVeu2T/+EuQ8QBnOpxak60NVFbR5+NoZJ+51sPCivo5z2 W1ugLdAWaAu0BQ5ogXmCoVCSixWgBWS6luWey1TVNCE+HbsVjYIO13AUKlArJWlvuQYJA9L4eVM8 908A4gL5bGy0rurt9taAW+Wqwo2bmGPrEI4wtGAu7CGvXTEqew9FM/fXzqls49a2nQL0sDeKGrgK XvzN6yhp6nOOFNdd5MM64sa2ipnhZPUgwEGntkBboC3QFmgLHNQC86V75kI9x1Xjxs1gqWtDC8BS qBvcuipisMe6y0IMeG7G+b6BJtREaZp7R2SybuXVicFOAJeBWac3MaFpuHXNdKFRnS6cuquf2lpt myODqpw6RFNRtG6iINS5E1e3Sjs9I4+LWNtvoSuoB9qISifSajUAY/zbRmXXQ0LtE+yDhG5s5k5R lgeOTm2BtkBboC3QFjiSBbIQRwSo6pZOzASgSpJjg7Ccl+sKF95zeNUFMqJEUby1YhXXch21SSaB B34DbAd53YEITAaWq+UNKGVgjit6py9Z9zANLU5UwMBSENfgMedcQ4Vv1gVo1tLIuHJGkoW9AVZ8 iu4V5d0jeIWKd3OGTR4m7PGGKnwAoE0aWtCuV72mVM50J847tQXaAm2BtkBb4NAWWLpk5A6XbiKV pW64qOt2BbhqzNT4ZimrGnWdZZXnErgKZOf2LiUv9wTfTOCOC3gYAGVyoQ2JvgN8c2YCrzcsjGEU tfd0DbuEJA2reIWq6z/vUeKzLKahHEY/n5oDHW5+4c9DwRRgFW80+a2H7vEKZjkAyHw3F+PIdfrn LkpCf8u8Zk47tQXaAm2BtkBb4CgWSBR0QIob1w0MVJRZSGMcHxV6S/y9ce9CsYVbH5HinlZZAlxF s3A2+MnYZVMFTgnDcgNvcFkLPhV01CtgzFgudWxUtI5DA+pyRgt+gsEActhtQYDv2DM3oowLsgBc XzT9CmDTVuXjMYG+kR34ClrHit1i0TacG+wGE4K5U1ugLdAWaAu0BY5hgURBLyMhVZoFT0G3NmKY lL15oZuqNy/GYc1uQFMOAKIcE4iCeqavOAUBHMJXhRtvs2PHuozJZ52O+wpxwRnIqqhtB4QL8yhd zgu0ld+8upODYU4WGRMGwCbO7bfQ9aFATifaGijXbeqlXeu1jQngudlvbYG2QFugLdAWOLAFahoS 8FuibAVf1C+fBjdJUPGWlaX4zCIbgBM84mZGqyot4zweITdOZYoatg5oqKIVhArnqFC5Tr7CprDl 3LwykzYdbT4LCCNfecG5SRK+qZt8wn68WJ9Mi1J16+a2RaGePYg5pvac18pbaHS6nYcBHgg6tQXa Am2BtkBb4BgWmO/cUjBQFXCAFWSqaGesr6yL1mk7tS9wdW+zIaKZwCjBeaaKUZbC06k/DM5yXeSR JiDjmlYFJzoZlVqANmiqwL2lzkBZ+Sqc034p7hq/LVDaXhbroA4fBpxi5Mu2Vb9C12lUCeji02uJ ejbwiz6QjWuTqlZljxCvr9bvbYG2QFugLdAWOJgFmAnktn+AaEXsssFNuIqDJYAJfjlGTRpkxZHA 2rP13zyg5RqsE7YKSXMsCNyaU1+io81rWaiYPYOB4Qb4GRPt7F7zOa0oK2dlDi+jw0Yn4z52I4ck 6s8iHwDfhwDbMajKvkTnsjxlIRS4An7TPKqderxB/hntC3inUrkV4emoomX9XtndqS3QFjh3C7zr Xe8a/uqv/mrw8xM/8ROHD/mQDzn3NrrCtsC1boGlEJovBd8wXGBHoRuYzuOOSDpu50QKCzAjpVWT gtUx3R3u390atzLjvbp9GcwdVowJ71Gaqsw9EA8oWYTD3Yp0ZO9V1Nxck3fBYh7mWwNWl7MUhmyR RB7aE74AeePuRgBz6cIftKfyhdbpg3N4Z9RLLdkgghv5exDmc/IbHU3RUvG0l/zrzXDBBwqu+0BA 83kISMF+awu0Bc7NAm9729uGn/zJnxz++I//ePjHf/zH4fu+7/uGT/u0T0v9p6euBcA+4icn+ey3 tsBd2QJsRyhBoRIK84SPU8C3gFJZxxmuzQGdewHvNgXVGWOt7j6klt0CNVfAEt6CdU8eh2YdXy33 L8cQ2ulBzCgadqxo5VaC3sfXnHFnSVh7D3OPKU0zFvAQ1K787LrOim3nIduIi3qUcxttHVhzmX5n 0Y16EqAu+0knqDhKPPkAtaCX+iSjtd3KcDzNtX5rC7QF7rwFHA76uZ/7ueGZz3zmcMMNNwyf93mf x0O6v79OWdwMP/iDP5gH62/91m8d7nGPe9z5BruGtsA1bAHXnwRUUlNFGRRHJQZVqF4F6RxFmu2E uL/LrkTilxzAt8ZlhR0uYBSqC2k4zccdh3bM561gaQitEmW8eZ8lIK2dPCprorMM5hLce+C7d34v hVSt7h0s2J09vOeTxwKu8ICAsi7VbJNEWeui5i5nQBWw0rbzfQ3aOoH8GzaDyDg250uX3AS+Ku9L x7Yp3Kkt0Ba4kxaYAGxcyTd+4zcOj3/844eP+7iPS61rfg+/93u/N8df93Vf1wC+k7bu4te+BbIf sJTdoBzj7hWcQM1fJN4S5CREISFg5BKK0lHirLHsddI2LmqU8VL3r+5hlLE/qGvBmKFWK7G+BEl5 SP22Q3SWNUJ0GM+xgVa6mgNe4M/5fL6OElY4O8absjxU59OFP2Aq2Tl3RawCr/ecjeTTN0elyLmw txKQ7th0IJ5v0G9tgbbAeVngD/7gD1LVl33Zlw2f+7mfe17Vdj1tgevOAuwmiKpEdbpJfebP8hUN Wsp4L/cchxWULh8p1LyeyGjU5gwiizN3QspmB5y4wMUGqGY81rFbVTEvF9Wo6OdUFxjrvt4BdpDP ue/WJmQpx0NBAMulWZ4ADNoin/0xCVL64g8HXOalkufUiOuAG/juvE4O76cN3Nh6xDLVyfyd2gJt gctawN+TP/qjPxp+//d/f/iHf/iH5DOgSlX7kIc8ZLjxxhvPygrev/mbvxne/e5359of/uEf5tN8 f/qnf5qgrCnz61//+uHe97738IhHPOI9xoMdM/693/u94a//+q+Hf/mXfxnuf//7Dx/7sR873HTT TVPRs8+//Mu/HGzzfve7XwK9fud3fidlP+IjPmJ45CMfeZavD9oCV6sF0I4kx0kDvVKPXhJNAWAA Nx17R45BuLBwLEfmHer14rQetyd03EdAE4JlfpK/zIH3GLEsOmlaWnqbDLSvwnWVKt3XwtZ+caxq jZIFunbOiUX0hD/1sGCOmmLEJg88LDiObFx0qXk0tgI8+fWcz4mGtkT1i4NObYG2wG0s4Jjtz/zM zwyvfOUrh9/6rd8a3vnOd8ajJDiNbP78z//84Wu+5muGD/uwD8v/FY79vvrVrw44repHf/RHc+9Z z3rW8JKXvGT4lV/5lbMWfuiHfijwfulLXzp8+Id/eK4LefP92q/92vDnf/7nAfnHf/zHDw9+8IOH xz72scMXf/EXx3NlZv9vetOb3jQ8+9nPHp7whCcE2D/yIz8y3HzzzcMXfuEXNoDPLN0HV7MFlkIx KfBDLRqtDLoKvv5D5y4vg5tUtyY8uxUdnZuc5BM1i2pFSGfRDas1dkqGWkXg63KTwNj1olW7tqH+ NaPrPquInU5UwBWQ5NGFTD6nO5kctxWuXvOKMNX1rLs7vWPsNyV5m2cuMxsycE1cRw2rulXPgt4K O7UF2gLvZQF/v371V391eNrTnhbl+5Vf+ZXDAx7wgOHChQuB48te9rLhVa96VeD51V/91SmvWjXa +Zd+6ZcC6k/5lE8ZVKN3v/vdB0Gqon3d616XvJ/xGZ+RqUmrVa2c9yd/8ifD93//9w8/9VM/NTzq UY8avvRLv5R1AlZpSyj/+q//eoD85V/+5Wd9fcc73jG85jWvyVjyz//8z0cNf+qnfmqAfZapD9oC V7EFlm4fmKApwKZC3G/XUbLlLg7ioJ6La5SiVeXq6oVpAR30A34oTADoJgqSTrhuvM7xknzxFoPt rIa1d03ocSyWG+Bz2HLu+K87GekeLrhyAHSFsYpbmLrIh0lXOXsepd09AB7WApn+UMTIab/HwrLV Q/LbJ0ENzP0anmWc2uNObYG2wG0t4O/gT//0Tw9ve9vbBiOWv+M7vmP4qI/6KKYOrgddv0Yw//AP //Dw4z/+44MA9v+Axz3uccMXfdEXDc9//vOHf/qnf0oQ1oMe9KDhQz/0Q4cnPelJufbc5z43TX3L t3zL8JEf+ZGpxziNF7zgBZm69MQnPnH4tm/7tkGQCuBbbrllEOTf/d3fPTz96U8PnC13aVJZf/qn f/rwAz/wAwG9/ezUFrgWLECwMWOvcLM2SRCaBlHRdeDoL6GuX2jGL9iS8xrHFXFbBlq9u+CeStV5 vM4R9pdpw0tla3kX30h5gqPgLHlQv0xfMk8SdFziCGdjYlS2oCUfJM3OSGbgXqY+cc0AMJNKN2PX jkFTl5HZtqWT2hz0ku6XIje/yeCr3KO77vxkXfa/U1ugLfDeFhCoN91002C08td+7dcOH/MxH5Pf OacWOf77mMc8JoWmgCtPHBtW8RrgaNJV7bkgFcIeT0m3s+f+Hqt+f+zHfmy4293uFtA6Lnyve90r yvkTPuEThq//+q8fHvrQh0bhvva1r52qOPt0zFlAf8VXfEWCvoR+p7bAtWCBBGG5peCe6OUlcnWH ynTLwawJ7bxbfhHnSFdVZKFPd68LZIgzyiGFBZnTg0ScQ6sGZzF1WEryxj1gKyCzKpXgpSwrgOQz 48bWxXiT7mQfBpa4lBMFPT4EzPRr06ZKN1sconLtQ1ql3gIun14Crq6o5UIddsaFQNDs6t88J5jJ LmSfYzvXqS3QFngvC/j7pbvXcWBdz3/3d3+XMWCDpBwL/oVf+IWUufXWW9+r7B254P8Lv/Ebv5Hg LYO1hLZAvjSZ5zM/8zOH3/zN3xx++Zd/eVAlX5o+6ZM+Kcr40mt93Ba4FizANCThqju3uusTqVHM bhXocQCs0vRHn7IgI5WadWlHzp0+xKpYoC1396pYygbNQFQ1zc2ATwCCcHLSBmUTdAURawSXvvAw IIQ5IhiLYnSspiVZW4HXX0iT6zur3LPFIOfCNkPa3DdaO9seJmdYbHPDjO8mkHVJG73dqS3QFrh9 C+jKfctb3jK86EUvGt785jcHwn//938//O3f/m3GZm+/1B2/Oqloo6x1I982+fv+u7/7u7l8Wzh7 0fHlaSz5tmX7vC1wNVtgucV9a1J94pcFS04ZErOC2YAltG3JWtgJFIGtzmdzbgQYatNfEJeADISB oG5oAegKVdZkcNVyhGXoylXrTiK/Cjw4BbhpijPbdWpT6uDi3ulKWYAD5NqHTPwdAQ2k8/yQOciu 0mXdqnchzx2fLqQvL/Ww2yAK9qjpdOKc31ANt/K6qtPyxuHGioG/qrvZnTuOBfwdfuELXzj84i/+ 4vDGN74x7mXdwR/90R8dNWpg1Xd+53fm9+jO9ND/O4S6yeNpqtNt69TtPU19uu093eKd2gLXogVQ wKPbmF84x193wgw4GmkMoerl+CvngSJ4M8m1PctWKoUXuIhd2nHGghlRrIB0bgb5nIzW68jteA24 Om3JsV1BqQuZAgnusnoBb+CV47Z5JFDW5r79IG8SY9VAn04VjL1mH/kwAEsXetzowlfsUq9fSZc3 MVwspimgp7osfH7pzS944vDQb3j5+VV4BWp65HPfOPz3//RZV6DmrvJ6sIBzeL/ne74nc3eNhP6c z/mczMfVRXyf+9wn47HnAWB/B63P5DjxU5/61Pf5eyn4O7UFrhcLEILleC6IAnY+9WaLP76dAVHl nuY+QRVu0OBY7qSKBbTKVpiVGAV+shkmG4ylOOZdtHI9o7SlRKk3kDZIaneaNpyalMAN6JkoZvNo YX45o645c3nJrOHsNCXKCn3eht0pn0KYa9PiHU5Zsp86wXVtW5Lb4y/2+CBhX69Yuvp3fvnQK/bd u+Jr3QL+zr3hDW8Y3v72tyf46SlPeUrm807fy/vTIhse39n0yZ/8yaniz/7szxIZ7cIalybbcJqR EdnOPe7UFrheLJAVJf0HrrdYaE3BSY6PCspc43dMIHqeFbIEH9CTuAnC4ngJxV3P2UAuKxOYyuSA EPXqBg+O5W4hYQKjAbf1sfxzVtnaoIiFPFSljK2pWG3YuoR6bcZQq3CZj4T3PGO9KOm5i3eQj9xR zumb7XuRtMjUJfvt/QK8ZTu1BdoC720B5+yafCi/7c5Frmr14he/OPfvCID9v2BK02pZ/h/wWZ/1 WXEvG9BlcNdt63SMWDWu4nZ6U6e2wPVigawF7T94VeUKeM5xKWfzAqcjoR/BY1zCKmKhe8KUgvyC CFlBSdkFoCuY6Y4u9awbeU60ckFYCAJD3p2Li94FstznFzJtU+8SwGYLwoVKm/6oXCWvaprNHbZs fyhL1bVOfco487hz07BC6V6wLrc6BLK0K2h3cVGn0eGUrqiIVcmOKzvnuFNboC1w+xZwoYwl8wNd FtJ5vbqg/V11hSqnAv3FX/xFHqD/+Z//eXBZSefqTita3X6NOqwWWSTjrW99awK7PvuzPzvRyw98 4AMH5wV/+7d/e1bPcnlLV78ysEoV/rM/+7NZicuobGHdqS1wvVgA7zJb8/GUGzASdpxdgoDv3l2P gJjJp9SVvmZ+IQvWupsBKOAUhhW17LUKqHJsdyFogbnghqXgl/FhV7sys0hXKHsEEK2THsSlXW5v zpOPNgjfEsi0TDBYzRO2rFCe78aHBPYtnvPwMFuXWraNuQFbfK8N/TBlH2NUdqBvW3ynSR0nQ7+1 BdoCsYC/Gy5s8c3f/M2Zn/uMZzwjAPami3AIR+fdPu95z8sylW496Ov9bbzg/zVC1BWvnvOc5wwG dT384Q/PfOAnP/nJmYr0Ez/xE6nbhThU3rqdnQLlfORv+qZvSjBY/zW1Ba4XC6CAx2AkfunWbutH JPEJq15dEG5sHSgc/YXcQkv301UFC9XVGYyFq64qx2EZpSWf0cei27m4C+Gqz9lcRh+7VaH5T9eu ZUVeIEx94JJ8qFvUrHsPkw2A2x4gzwpY6Fcbkr66kcf7HidAi4VAdkKY8y2VJgJaNzdwZrJzQK9r 3D4I+7jQqa5TW6At8N4WuOc975kVsG666aZMAXrXu96VjRFcItKFMlTE973vfYeHPexhiVx24QyT /1cIY93JBmxdmrznkpYGUhn57OcUwWxdKmDHg3/7t387K2ApDBzzFexf8AVfMNiXS5Mq3f2FBXmn tsC1aIHZT7/2jxiuRQ0CKQOgBJqq1HOvC2CT46YCLOAyv2Oy/IKQKzBUTYaz5HHyvuVyDSKnDs6t yUAux3NFtFOaqJnygNEj8timebziNKTcz0IhgpbyqmlumtedlIQvVOdcnLuex1iWelMXBXQ7n40h u7QlCD79H/9juOXtfzI853u+mVLnm978Y19FFPQLz7fSc67tcURB/7eOgj5nq15/1Z2eniYS2jFb 5wVfupqV39brwlmAJpDyAzCBy1k6lit8Bf2lyd9rF/pwNyT/f3GjBxcC6dQWuB4tsNwiJeeATkgV hFWcQA1w+QsVwAo786AyhdoENg0SVcq1wNR7/shNKTkB29PpRV20kDq4lDQFXbkAyDT9yXqNXHZM 2kWeBX+5r+2D/QWwRH05VWm7PY0rPFHZ1BG3tmA3j/3gW1jebqn4eYvbvFrv97ZAW+ByFtAN7Bjt 5ZIAvS1EL5d3uu7Y7m1BPt3z99Wx5Pc3njzl78+2wLVsAWcYASkAhXJcq2hRvtnIAFq5ExFkC0xn 0hBwCmTJGMUpcOMr5hKgdFUqF8zw0hwX9ZYgKfNHWYM/6+at1LRWA9BCUoj6mWQeHgacVkR1gBKV 6z3y0lEAbRmuUZ/zleEq7RVojci2P7OMDVsf0EVlUzv1Vf3i2POAeWozDfdbW6At0BZoC7QFDmcB vMQAi1f0IRBVvc5cAxJICcsoRyBmHhGsMhW0gSHXZKHBxo65VlCT+tbFJgEuU5OMlLasrIuq9YDz qd1sJ0i9AXva9LZjwAKbdoWqbQvmJAPGqIM293E3k0el7SUeGFTvKmSzUyxq2GJ+LzNxJ/WdAT91 9ltboC3QFmgLtAUOawECmcGpSldohlJAMwtjuEoVkAN2gSUghHkFMj4DWyDnZ+Ad8BHwhPJVuhqU ZXWwdKyfuhyzHWFqu4E7eZaqVl7ulDRt7qC61f1sANcMkAfitkF+Yay72WsZdxrHmUul89DAU4Gq mj9pL+SX34DaIDEunn0Pzzq1BdoCbYG2QFvg0BZw+JdIZeDrvFyOhW+Aq3wcFamArYhlYSvBymW8 IKApkIVqE4S3jBNPSbALWSEpyFXA1qocto0l05JUpBvhLjD1J4/3bSO7GpGvxnnrlu3YZsakBbZq WNhznavUy31bAcJes+18t3wfazUJab9DTvqtLdAWaAu0BdoCB7dAXNBbXL3O8507T5ex1y2BSgVD FeNyWDGndulKUwGW6z87RWk2XNgzlYhpQrJtBeiEM8t4MO0HFzYcdryWjZbgouPCBeaJeejXwHPG lCfBb57JRZ2dlEJq6+AWUdAiXgU7m50Ma9p0rWmXo8yiGgKX+uFx2owVUck7pyaR1whux4KdRmVT e4K6llHQFx8WUqbf2gJtgbZAW6AtcCALzI2Cdm9ep/xEsbqY8w7Xr5oWYME8pvashzXzaSv4iU/m 5aogZ8wZrk0PXCSDxTKch3viSlm4l8kvpFWsDsj6KXQd83XxDoeZnTJkOLLgBZ3Vnu5lT4Wm7XM2 d8VqXNSON+/2t+b+pKjduziuZQpRBJc1/ZerPEQso+Z9EqAWvojj0cJ451Qkywn1Tm2BtkBboC3Q FjiCBaATq0WhEtdsdh8HLZA6YYHmFcrXlChioOiGDXvXXOb+fL6KajXwKiqUoi6AccrGCDOgKhSd TuSCF0JY2MUNrcuYOoVxAGoeqemLenVJW78A3+jepl0XmI4ixk0Ntsk2qmvhbjnyWteM6wpvHwoS KU1uR7Zzj/tCntrymjmtiWP71qkt0BZoC7QF2gLHsABe2YJkYqfoQdzM0GmCU+YEjwBbATgDpVzh alK05Kx+Qzd17hooGiQlvxf6llG7gq9c2riOyS4gd8zXpZGUpfq0KyTtj8klMb0N7rPVoeUnaC4v gXC5tgvaNEbuKm+QlmnPw0U+uZx2qHQOqa17WgAkGfqtLdAWaAu0BdoCB7RAxoDj3oVOBV3m7brP L8ATxhMQOQqwVKcTtAXmWZ7wFAAGqkpR3L68dPm6A1KlCrbS7axrOe5o8uuOFugJW4bQZ3XSJ/Q0 RekPQNV1nZp4S78Mc7ZdPrYo76yglT5xgXPX3KC2GttOvybocnU8P6Ctu6m2QFugLdAWaAucWYCF OIQa0A1gBVaYBsyIexZSvOIWBozbNUtMcsmdhIjJKmhyfhHKLgNJbSwLOUUZOyXIOqyq5ujq9EYJ O0eYa8LYub7Cl8Mo39rKUKVdrmr7UcFWArxc2pmulIcBQ78saAPcz1ebylknAWS6skkb17aW5zml zlztt7ZAW6At0BZoCxzeAnFBr93WTwADQpZxZvwXKMdNW4gymtg5vEZHT+oUYRthqjIWkI7fLoiW PgMtTFWlCsclF61jNlsFlAhjxn4LulboQ0BgT6VR18CZ6gioclqR9dA7doMgrCrwVFW7v7DSWYxm sQ/yzxfU7/fwmveth0txf+uKhvh+o71BWERFl1v88EbvFtsCbYG2QFugLZD9gB2zdScig5OWjL1m fFdoAizFoitf7bi+JMBJNey6HS5FCbUJxqrAKaf/wkt9wdzDvcw47R6ZLFANysoazEB3BtgdtzVg SgjagHN65aUqVuW8IJ9zf53OZJBWlPDulAxMdSKfsHaBDoXtjIht+2vbuzlbHuLuduqRpBX+W6Yw 1Zg17Ql9VDP4pS7S+FEn/d4WaAu0BdoCbYHDWaDmAQsmqOqY7cxFMyDbRtULDCsBWcin29iVO8gS hWkwlYtcRLUCwExjMgoZRSuQE0EtUM0HNK2b4nE9O87sGtGO3cL3lFF1Z0qULmnyC1CBb8j1bHWS rljedgQuzwtJWaiDdua7k4Ir38flNGmWPDw8+JDgV7EfvKKRdaPz6tQWaAu0BdoCbYFjWCBLUWb4 FOA5VipcVcRLSOfYrilrMq9QyUDzVFcw1wuMAlhoAzUBSEWLlbAVkihkKwaJrqKV5SOtk0tGQAt7 8wtUk1ktFzXrAcm8bnso+JNRlQucE+Gsu1pykwR1lPbmFOhzgfJ0KeBntDn3lNxzFu6woZS3Svre qS3QFmgLtAXaAsewwPIGBkk3I2gdC545ViuXIBjog4IwC1BtHRxWQbJylQDbnzotyMU3pGap4Mzj BYZrYCxgLa5SJTcV+iKvLmGvc+o4bcZvgenGumkzKjw3CdUK/71GXsdsrReAqmZ3XNwF4PaJNshr sDVZaI97qaP65/gzOzekbqGdr0ufMwf5GFbvNtsCbYG2QFvgLm+BpfBVPWa+L5Cc5RziJQHIEX66 kFWp0tCNFlw5KyBEzUapcmu7Bs4GY0lElHRtiiCmgSIQr6Anz8Z6Baptu4gGlelK9keKOo7MAeAF mF6ylMDlslz2lQeEgNZzA7J0o3MsjHkTxJZxZ6UNdWf8V9BTm++pmHo6tQXaAm2BtkBb4NAWgIoF X8El0KJcgddZhPCoKhOl7PiwNARwck+o5pT88tI6TgGmSnraDckvZNmUE3q6fWnTsdipfAaByWce 6z1LlMv61H6KTBUy94WnkDe/Pz48CHCnR1FLfsxPoXyPjcreur3mHx8QOrUF2gJtgbZAW+CIFgiJ prFYASrAlLrC0aRr1/sbILtljFXlWbAV1gIyhbKusy7lBXkFowDPvF8VJ1UFoGRNW4DSKU3WIySj jkeQFlSrTlVsiGmdKGrB7aIeuUu5ADsdktpF7riwzUH/XegjuS1AJzLmO5bTXZ2HCm51agu0BdoC bYG2wKEtAIZkIOA0+opUDmOgGcqhJjkI9FSbTPlx/q3BWipRMGsBEso4hVXCRD2PS0UK14wXc+A0 priMyWdwl9OJdqe4jKnLMtbDIW/Rqanffm3Y+MEU5QtEVbp2LgqbOlK/6tYORM3XHGHrcoy3Fv+o NrIoiJXpZieYS4B3agu0BdoCbYG2wDEskGlINix4VaRCL+OyBC4JUqcQ7WdrXqpdFegIL4h3ujba WXDuhpPVkiCoJXN4DY5yzvCohDmmaKYM7chXrm0gnm8LwhlPrja9IJXJr9pmLi/raWVREFEvcJ1+ lK0OuT+5rzeszuU4bwlh67e/Qp6quCd03SOY2LGqn+tzp0PZqU5tgbZAW6At0BY4kgXgIPACaEJL JgVsAs71l1W2wnTLLr9OugVu4A3Y1TSik5M6ZnmOKM0FbuWNqteAaaDoutC6sOVqKkd1EqcFnKUg 93iZdG+rWPfu++sSWIROu1+vFF0DXbV5Vr7i0/Fl7kRF02iuuyjHiocFGE09fBc+A17qclUvb2yW 9JlPNW+pYr8sJ53aAm2BtkBboC1wBAvU3gmq37hjhRKQBX6uWBUoQynHX1ecR8HSSQtlrJaBVBUp ojVYFm5Rs9yPS5jz7MFLtRWIBXypy/osHxCSZ9rRKKrUXZIAo5D3wUD4BpsBti5oeEpZ8zremyhu x4bNBbizEha98b59sY54xFXGdtCvmKlTQN8v2Kkt0BZoC7QF2gJHsEAYNI3/6qqVpsIRfgWMKtBp Du4Ns5OM/+rCFdS6hDeM4wbewFixGwCjmj22Os8Vs+V6rmtxI/tlqUMGRoGzPrMYN9J5hxJOBVyB m+mLQFUpe93jUrH0ESJ7br8XrAXtNoh5QKDx0rvccu1n5/9KYP7kiYE+VS8579QWaAu0BdoCbYED W2ApRA2OMrAK/BUMAzOBqqtZXgmucYyYC4KsQKvrGcxx23FYwbZxHWY+LScYrX8BnHVtb1jMo+Bp vWSwTguTP9OIoKfQFNxZt5k6PRaayeeh5xRNNLV1qHCtx+pwMVtv+jeW8UGgKrCcfTNgzEq4Wjdz 3G9tgbZAW6At0BY4pAVccTLjvHEDC8y0rntYl67jtKCWPGujkQGlgBRwe9y/YkzgZeqPUISMucf1 6djqNg7Ocp/KqELqAVynBdmeOywhkZ3Da6DVlLxfbZldoBt9bX4ga3Wcu+lCoplDaVnMI4N57YdA pqgBXTm2n6xTnQhs7nA5321qrz/bAm2BtkBboC1wSAssDXoKbG0VeF1MgrXOoiiBmkCcAWFz7QQn kFwR/Sw446bmzoIxYdeBFqUWL0BzMNYtHj20Ft3H0N8/XOMK9dgXyxlYZUMpL7i9x41p/DnuaOsH ykZqZ8oRddjnckFbC/0imtv1o/3hY4QuqvzsYYBsndoCbYG2QFugLXBgC7i5UVJcxChKwZlxVTYu qOAoMXZx2s9WJcmr3NZCruC5VSHrMs4l3pSYuZeP7M1ruY2R1JUp6tcWo3zJLoSnxOKUqU+g627O ylcQNEV5Myraa/aEHmces0c7x6JV6rQflZv7YXmCr1TaE3wt3akt0BZoC7QF2gLHsAC7IQE1uOdY LXKyoo7diGEcj61gJ9E27pY0QstIYsG5dh4ud+cL5gDH12swlPAsF7LoC1iNbjaf85Im2JLfFZyh ZoC5PFmVO5qyVuX0pihj7sf1zLUN9QhR3dYqcvk642Fht18TpW0vcUv7oyoH6ImSHoEvrK2HWwVp O96pLdAWaAu0BdoCR7DA3DFYkzBzyo8SU0YKrwWfQlU1KUhVrku2G1wu2fOX60Iy7l7vok7jykat 1pKUVpUMQFegFu0SB0UD0z1BnXFm7lt+isimAwnoUqIrjJc8HPiZ6VEQlEDrSgGtDCcCmiYWPAgI WutXpfs9DNKy8G7HdoVuHsEc54VbHHZqC7QF2gJtgbbAkSwwX83QmYwDB4IwSQiylUKN9epSVm0G fkIMdZn5tJJwioQeA54EHXnjFiZKylirwE+wCm/HYeUx4Nuzp3CBkW8dP3GB2vuRp3zIV5X5ek1F /HHJSrc79L73HPO1DjAj3ckAAEAASURBVBWtwVjzuRsu8AUM0qKeUsg4uFH2lrBux4NTKZHQyRft TmWd2gJtgbZAW6AtcGAL6OWNWtwDMb3ES+f4CjahqXsamq245tKQuqPRkQVRGSxcuSbxZivgS76d 8D0FyuSnouSRcy6GwWnqzXrOXrQdyjvGKyB3p4wjA1nBm8R1la6tbrase0n/lLmJpKZslDWXBLG+ aNeUNuAqibnEUeKo9bi4rUc+swpIvh0N0mSntkBboC3QFmgLHMUCLNAItNZr8AXsgFsAx3qRXvea kBW6zu+Vc04FEmjO0809LroDkqO5GxeHDtbI6HhygEdNY96sYMWtBVA0ilrqTtOCaCRALeCK0xGP fAhYQc8fXNEA2D6lbvoo9JlfLJsF99Qn/elzO+zDAWPactkmhT+HSX7HTm2BtkBboC3QFjiGBcDY CK3wzsCqGhM+gy8QW29crKMij6NUIWHcvwnc8phKfAPEAtV7BmIRwHwGxIzvCkOyuiBHpgaRzw6Y 3/pVtAJzSmlDl7JtU5mRz1HcUwb6saUuClX7qO9MbcqVqs9AMau0HWu+tLzj11cirS+8/UpUe651 /t2tPix1agu0BdoCbYFjWYA9D4RXRQc7lhpMBVhgD0BlpSxBZTZfARoH5uS6C1+okAtvKkyjk3E1 OzbLMpUGRS2Xq9El7fVaeUsqWt4FN4S3arT2/62qsk0hgD9Twly2fQFbahwF7vi0ZZXGpLkLbbDt kaDmcuYNu6OTbm5aIgNj2wrv1MV7FUvZ83x70Jc8a3j5Te8cTk7Os9ZzrOv0dDh50IPOscKuqi3Q FmgLtAXuqAWWcBJYAUuVJuCSSoEVBBOiCc7iaty1gCwqVRqTT/BFRRqkJc34431dv65+JTAZSJbU Ubkq5AXRynt3LAr8RgLGhW1eFe7Yj7FuVfCYC/f3IrsjCWXHe3Vt22/bzIIb+q/py4z6na40c3el jD1zn60UZxvd16hzoJwo7uoEDZ9vuveDHz489sHnW2fX1hZoC7QF2gLXlwVE4bBGlUbtAjMDl/YO lpIy3ShQdnpPRUpLToOYTAvmAmcaEkpVUBbAcTFbD1C0zGxcicp2lMb7pRHLql6jl71KOUCqap3K O6VJWJe6piG5yv3JPe6xDwlxXXOPQeBk8pywadzbYXmpaqDrdcsaze0c4pTzoUH136kt0BZoC7QF 2gJHsAAxTbPhBhbdEJonuIoNZEI70pWCVvpEEBMEq+45tsth3NH6mmFpuXnrfjZuAKjLqFHcv8Y9 A0DVq6p1vnW7Iv7gmrYN3c7ODto4zqx65lVYLLUdqFKXY72uP72kYaEtoNXqMtepUa75bNrzXSY3 uXsKn+rGpsyc6VaJnqaOTLRKUFmVScF+awu0BdoCbYG2wAEtAPoALsRbsZUfhApYZ8IziRtccw5v 5gKrKSGeLmS163ZPMFVULMiWiSM6LQo+S2nGByy/AbGLYMQlrPt6VM0CnWZ8ELCuObBPG3RKF3jq 4mMBWANsGrJ35rE94eqylSru9HoqYw+pg/W5osT3s4tLZc5wi5eKLtSnkX5rC7QF2gJtgbbAAS3A QlMFoQBR3gpGwOZVjwVtgCjYdOF6g6At9Sc7OaB+YTh1CDSwWq5qYWotgWq5t20m9aB0o5KnLwng yYryHeuwGeuiPVvh0GZTttQ5me0DyRY9Nr8rZeletoDTjnxg8DHBH3vDthE8BXCmkucpwDIW79QW aAu0BdoCbYFjWABqFdxqJq0gxFWMuhSSwjWAVXXCqyyYodoEjo7BKm4FssFYljFTdkmKK7nq8UsJ u8CU66ptx40DQO4V3P1M8ahgbl68DyVTt/XQV+s5AycX5Kh1qdpn9JMmqN8ypZ7tP88RBIXxNub1 QcEx6Cs1Dcnv3Kkt0BZoC7QF2gLvywIsxAGMoKgrKAtBXc5JklWx6EWP648XRogKNaDnbe/zKQgt zZlUpqpy9epatpwQN49wn5Q1WjTN5Y38S1bUEphWHKWcFTSs1XZcaavGgwVr6rJp+uxDgF23Nq9X 4tP89KoueZ1jc6UzY7b+aAu0BdoCbYG2wIEtsDTg2SWWw6TQExUJ3OTuzmgrb0mvjPWqPwEYrl7v S9soY69yIdv8Mb66Y/1mb6swXbPZ8r5SBvTqHs64rVOU+BOKB4jCtyBZmKx6Upa8tQew7QDiKFig vgawcZXTHq0aD71AZqu5nfQrxHVBB7rpJxn8POuP553aAm2BtkBboC1wWAsQdAyeUJmKVFNg64EL ZuDPXU27BpFPt65AJQYrSfWbFzAz7YHk3EU9hDXgU3mqnj32pVCeknFe8ywQXVdgctVVshswA07L ZFzX40RvJZraEkJcr7JpuTLQigqArktVGrxle27OwAftEMBFcXoRV7UdGYeLU77f2gJtgbZAW6At cGgLyNhAMm5ilKGrRlVkc6ndWsoRYAE8oaeqHfk7BjvNsjJV2ArwnM4UhcwFaxC6aQRSu7pVKWGU Kuc7NlgIeKNGuc+n+xBzkGNOomo9d0EP+3CK2hWkUeTK94C7FLVj0tYnjKstPlXWdtjAK8sJfaK3 af3Qtu722gJtgbZAW6AtcGYBvbZACo7hh96zoIXKUfWpQoxyHSEqSbPbUPLzRgJtySNod0QeZ2Us bglKX0kAMHWOn47TykTn6qJvjYU6uy9AkdA0JYztgGq6qrGQ9axyHchz252btqp3avI9i37QgF9B 2O6Q6jNWwLK9jEdTVU1/cq5wfYex9v5oC7QF2gJtgbbAQS0wL+ULmJge5Gb3wtRAqJnAFbECklfy Ab1Sl/SRaxtIF84KTIC2RaUmcCoArVHXKE3GYlW31iHsfamKnfM78jRfesvSkQZg7SFmFsvQDa4a tlej37vqE8y0x7ziBQ8OAljAbtkTWM0Ml7kSluc8EdG0TS9om3FmRopd1CN9P6i5u7G2QFugLdAW aAuUBZy8ExeyilWFqfs4Ll/uC029v1GY3gOOWaQjgEQl8+kSklnekXwLAqhEZ1Qtn/5kzWUGYKOC xzolsOd5CXiOvabyzYIdtgUodV+rujPFiDht81zat4Xj03k68DqVO07MN3JlypoqRd/pc5S5YOaV oWS/F31vFVz/CPq9LdAWaAu0BQ5vAby46ksACcDAWVQq7PMAiHFPAgtCQOeSkWY0L2I3CjJ5uSCs ITKfyk/gSiRyRnBTnLryyf3SpqAZSloHVdZANOAU5ipvlC+3KlFQdbvwUYFjYe0OToI1EdZeE9LW MxaJsqWz9CJ1E6M1bN3jmO9k8/bLh4MJ5mOx/mgLtAXaAm2BtsDBLBBmBY4SLAlsMfCqAjVFBQOt 8MqMXoNirjYlJCsSmXNuBYMCUbZZnItuPyh9hWbA5/0RotM4sarUiOdsRxjFi3vYNsf2bNGxYOv1 5fWMF3sIVOE+OcoVnfvpWbUjaJ0nPOWnSOquucs20qkt0BZoC7QF2gKHt0AoK+xknQBVZUa5CkUA mmAoMhikpYLUbRvXMaQTur5UlSLQ61GZ+R6S0oAsKiIZIEXFVRYoTlOQKJU6A1jqqI4IWF5CG6lN Lyh3dmvsB3VzX9CHydTDaeovjUubQr2IXN/NDOT2R2UfCKd3/dYWaAu0BdoCbYHDWgBfrCBylyFU J3wSaKpFQevYqQp2mZU6xFpGeAPPgNlzN1gQkQBS+G45CKA3unnr2K/kEhnO5Y2rmrbWTEEyn20H pIw9W7/3dUHLdPuzI6/5OEgb6QHXnca0V35bHljzh/LlnjZAy8xu0CBz3RbR89TP97Nevp1VdmoL tAXaAm2BtsBRLDCfVGupQiAHnQRvxlUBlYpxvQaeIEuVrEKuhS4KuHs3KeLeFlDK6ZWYg+LWpyvb JNRdeWq7v1DnqZd8XHeq0QTbQJNymcPLLQGZHZEEMMliOJyzA5ILbszdwcmr3DbLhihqngfIwXfg vgrYqKvsb8wDATsFw2t6aEWJxuKzU1ugLdAWaAu0BY5gAWVnFGZNAQoZwReqEmW89JQN7VWUenLd wtc9dqekC3dpBaTFnEU1wO8MJuo2jqpGeRrZHMhSHn0KAjmwHPlqqhNTh8giQaN+qSVjwVaqO1w5 ThMuc7lnsJczphOhkMmvwpbSPjDYQdfwyH0qnO/X5BTuLrrBFyGE+0QlnJW2xqhsAd2pLdAWaAu0 BdoCR7AAfAROAMtlJHUfCz2n/SycC6yK1Lcrwjg2nioABWgbV6QCemGf7mqUbAKutkIPYlJXlqQM oKmXOkE59YwrUgF4F9EQzmeuathsC7ZlP6SptXluu5kKPC6N6QOBLuX64ydtqmrTDjWWNIfL1EAz qmpd1hxW0iUdKTxd6M+2QFugLdAWaAsczgLsuyDgEMIoTQEn9+KChloZNYVrK129AEvFGijLRspM c3Wz/+5Itu3uNHkFpEpXLubF23J5IycoUu45XuzYb5LQF/C04dQnTrgnSwU7DwajK9v6FpYD4gZp 5WGA+wG2FVGeN8DsWHNqTr5MX3Lakrd9W9AB8vqA0Kkt0BZoC7QF2gLHsMBcBTsBV6jp2s0qU0DP PYIFmZBWv5pkWIKixDOCM6CjjJDNVCP91CRdxlGo5pdzvLbbC7iscf9yYn1Vj7nFJj+CmAaoztoD VnFa0De//LQvYx+slw4YaJ2IaSsak+C2soz/ci3uar5CdkECxtbbqS3QFmgLtAXaAseyQPyzglAx mjFdICxIs42fpCMJ6Gl6kfnc+F6FGiCGcwXnwJr8k1tbAMZFTT0CcGdAFNeWVCKcA2GLCkrPAnRR bF5CpihcCtor1BHyct8ywNp+W1P2A+ZYHtun+j4F2IwhU39Ucu7V+DFZudYQ1g6d2gJtgbZAW+Dw FmA6rEATuAW0gldFGotNoaciFsoZA+bY/YLBNfdQyEKNU8tnLu84Tiw8TYI72xQCzeDOMVmOg0vy VKTy2La1ZlUNCTsmqhH6I1kzHzn10LABXtaTNiSvmIfCPkgE0mOxqGMK1bVS1Gaf8owt9UdboC3Q FmgLtAUOZgEYhiJd4hhGfcpMIerG90JVZApL9wSeYCWM497lbiKTDd6ijkkVF2Wr/5Y5G+e1NhpR We9YM9pNHbIZAzCX556rZA2kUtU6zmv5KFzZOqa5Cz1PyhU39/QAUbcptxLm9N8ylBfI05aKUx25 F019ScXTzf5sC7QF2gJtgbbAASwwd0yUbYVgFSo30Cv16L68Xlvp1yUJrT3u6bhy61JAJ6QTvCXL oHapzzHfeD76llOJ5VWtTnsqQHMG8F3bOWUNCnPMmW5FlbtmNCnARtk6v9eFqAV+XNBmJGXXJA6d C2yfzCZ9zWNlcalLZO8G4Oar81zst7ZAW6At0BZoCxzQAgnCcps+GIz6PY1L2fadyyuQawVJQAUU VyhUIanidStC8IbC5Rpg5iRTk1TIgR91JAecmwPRAjNTieI6rijmTEEiczZj0EVMzt2G0C9VtmrY ObxAPKANeKkzocxWzngy04pq+8NSwpaJcOd20qiuczz2a+VqIfTB1mRzp7ZAW6At0BZoCxzDAuVo RilmWg+wm8ZTEaQIR5Qq6jSRx8zbPQVcakaBqesaRzIQGxUzwc+BLPdl56RqA2RhyUWvK1hn7Nsr TwU01edYFb3D/703tNo6VMX2h5+AmXNY78qZBU5BjmtcoKt0A18Hi/ljI+7GZAsZ07ZKGhS4Z1OP 7L9ZOrUF2gJtgbZAW+AIFjAgWSIGeMIMzNVWgwZTRZUKLk5Qw9JarumcdpksgaYShnOcAmLBRw3e WODC3u83Lr0hBsNFv5/ZXYxDuOckxakPSArNGZT2x+S6WdTEdfJy7EIhC8/5CTzJH4VOdgGsW9vv Y6Q17/Rnwfg2ebhnfts2OS7MKZ/jhVztt/O0QFz/51lh19UWaAu0Ba4zC2TSbrmNHb8FpLyt3TsX WnFlVIlAT2qRQCS8Fr5gkEsSXLXsqlZ6d6fx1QRCca/0LBnIK+52upABpGrZyvMfNYcGa434jpvZ MV5BHUZynGLS1ijpkZszFw8R0oDYh4SMTyuT6ZD1TkO9wtdNI2zPseI9efx210tq2F0vf5P9PdoC bYG7kgUC4LiUoZZQOlORWEFFrKs5i1f4CdsWAkzl6QkME2Me6io+U6sqTgGbOhjD9R51cRBI1j0B Lsy9yK0QNoxMHsd+p+QykktUsFlsa0pGYxd8hLXV5C19E7Hm9XqtpMXDhL0cr3GZVO9Tfcf8bIge 0/rddlugLdAWOLwFFISoTxqOGxrARXkKWqAKrHQh+7lkCtGSHRTM7zhu2EXeteO2kE7l63jwlmiu BCKbhcw7lamYDgmBt2VJAalQ5lw1/B7Xua/6Nk+6ZhnyiFAzxtXNPVWvbfuyegTzRYWdkpS28xYf K0pfgHnUsU8EVyC98y1vGN7wllvG+G37WX18X59XoBtd5XVqgc27bhne8MqXDq/47zcP77i1Zglc p1+1v9YVtcBmuOUtrxte+YZbrmgrXfnlLTB3fNSX8FS0yjohnLFbJKdgzCIcQGTHXCFf+407HyVj IJtDXcy5vhxWuoapTOW5wfVr4FNgvBTU5lYtk0aVK5i4FPWdiimfYCkUrvrZstZF63SQfvCSp65y pas6wV9UERDTYVV6IrNVvORzCpMNz2YIfseesyuS5dMZe3Kn0m3B+sev+q7hcx9y/+E+n/G/Dt/9 3BcNN7/1HWcwvlMNdeG7rAWE7s2vfPHw1H//qOHkXg8YHvGYfzc8/tGfM3z03U+GJ3zD/zG89HVv bhjfZf913JEvDnTfevPw4v/nqcOj7nb34QGf+q+H73/tn9+RCjrvOVpgKeKEmSmLYQDDDfspBFTK Rgkm3M4yCbHg0yIUiqYE1LqmAbYKmMFgdv8LEHVvC/DNRqRTlDfxqWt7S5DW3PHb3OCe93VLC07B qqrmYs0RtgOCWlXtfU5N9o+8xkqnTYPDLECybR8YDMbauj0hi3jYc6OtU9cdBHAeFKz4/aTVDfdP jn9806uHZz3F1zDc66GPHL7pa/734d9+yaOHhz74vgSydWoLvG8LCN03/cprhpe9+AXDs1746stm fvl/fcbgy/S4r3vG8OQnP2H4goc9ZLjvjf2vLEa5y78J3TcNr/n/Xza84D//l+HVF97Ta3KfG91X vdMxLECQMCRDFSpC10ASosY9uwdeDs+a1uxg5EUDqhLjRBHzh4GwTJwtCI5y6z8jsbbMz5Xqjt2a xyCvuJkp472A3jL6jIUpWBS7Zy5kjuecRCfTUIFPIAvSbR4YVMUb3d/JVZHSQntlORTvjkAyG9+b Z2S3X9WUvnBzn+9b1277/oHC9rblLnfeML6cZfr6pRb4QKF7aZlLjxvGl1rjrnz8vqF7V7bM1fTd cQrX/NpoSOGlixlQrkb4ZplJ9FqimgGYkDMJs8wOMjMy1f2B3dxgxucOKTpHdS5Qx1OgldHPQk33 MDxOynizcBxVsHwU8DuU8QyIeh6xSh9NOqG9ltW7Am2VdD3l7+JiJr/jwuNDQeYqMx3KZLS0U6Ys rxe6mOw79fkdDpgaxgc09jXQlNB9I0r3Fe9H6d7Rr9IwvqMWu9bzC903onRfcbtK91r/dtdj/5dZ 11lXLxB15Nf1nXOEgBTKKt+aEiRwUauAdOl8IxCmq1gYCuNETwtFFsdYUpfgFGyqzURMUyJjudBx grAwlIg0QUm1N2tm4RQftgV8r8Z9TX3ZqlD4A+aNPnIVOg1vI6Ilaqlo15l23nBFb1t/HdufqGzK 7Bc1zQp5fHD4+pUvTQ3jS61x1zm+UtC9nAUbxpezzLV+vaF7Lf8NLmf6Z4GUzmf1YIAJZHXuOobq MGkEIrJVhWtQlGOoQjdi2PtjOfNxGtezYDeQam4AFElVWuPB5q4y5mcxavKPoFYaC0rPaWuHixjd HHCfPQSQwU0dUoOVeiTocX8L+sxXTid8oz6/S65zjw5X/80njqtvqeQqeGsYXwV/CVewC4eG7uW+ SsP4cpa5Vq43dK+Vv6n3108WtQJGwEsXbaKFKRFVzOekGAMwiKsa1QmccVXRyDV1cECnUh5hKRDD QOA+Lf0Ylcv1SQ0H7PZOlzX5Zrqoo1LJE5e0cB1BmSbQ52vq1a0tw53rpOrlXpS1jxCBqsUM8OK+ +dIRv4mQhsc8PNgHni3ycEGOqzI1jK/Kv5Y73KmrBbqX63jD+HKWudquN3Svtr+R8+gPvl4JRexU 3MqyS6jVVoA1Hgy8oJxINZgqWAZegi/BTSpjrhqitSdYyx2MCsTkIV/VZx0XwZ42AX/qAKgqafMJ flfiEqxZnYtaPRWkLmTleLIK1oU8jILe24CKmPFmDzdEObs6luq9EoXsnzs72YhlbU9W096Ua8x8 1X40jK/av5rb7djVDt3b7TQXG8aXs8yxrjd0j2X5Q7W7DMOEY3zQIMk/wk0Q04s9sMtqHVum8QA6 3jLH1vvzuKrNzGWopls3QISsApILI/hUraPrWPBxcyssQ+CCs2DP2LCRXbTpPcdx1eZbXOTeWy+c fmTFZMl0o2rbbRIdm051fJHFOI/YPiaF8BzpDnc6lNftR6BcWa6V92sFxme2v1YMeyf7Gei+/rXD K170/OHZL3rNnazt+MUvhfFj/+Mzhq988uOHz++pTQf4iynovvYXXjE8/z//X8NrbjNl6Ep0QCly V/t9vRJ2/GDqXAo23bVbALmCxuGmU4WA4F4lzF+OryXBVTvcvuBRhpF0SfNOAceRXZVKPRp4q1OZ d1usLJhmihL3dQE7zpyxZtWpDZLCQk5mKPGd05i4Lj4zHcmnAxo74bW5QA/IXAoZ6HO8Vx7TM+tQ FW99WKhJU7lv8Fi+F/XYrgFZ1Exme3ztpkthPMwfOXzXc957nnH/Yl25v9/rDbqXs9QrnveMwZep YRwznPPb4aF7zl+gq/sgLbBUbSIsASFgEo5ATkiVSJRoVbNM1E3t+O+MaUKu1RxOUm5hBSBO1/DW wCngm92Qsv5TEdb6dGmvCKDKzF/O49oGjo7Jemzbs4zzUh1V2sYpMKXaKPQNewUvV7S7HoFKGdW0 mQNi+pD1q+mnMM6SmE5hJof3Z4sT6jmlXr+Ujmo/r5O0u7joxzD/wuE7n/O1w799zKN60Y9z/uu9 q0D3cmZrGF/OMnf0ekP3jlrsesy/FEb5gVJGKQdOcCkKVUAJSEAnINfAcKFKRhmrlWWf6HU1K49q jLjAuttfAKzmrXvC2Ujlja7iUXjmFm+ZNkTbbkW4Y9quq2EpTmfAXmUuJtXeDA3XA4CBWHrEBbcX qXu5XQ27FX2FunPc4TsXBdGdnQcD6vZ7skpXoqspk5W7rPh6TLvXDM9+ii++3LxhfGf/iu/q0L2c /RrGl7PM5a43dC9nmbvq9QIwIBKGWUoSSyxRool8DuBQxLlHgNSCmC3d06jYDUoVDkZd1upUQJGy IJEf760CTQ1bU364Q30uhpH9hHPduziLnVZE4Vp+0kqBO/DMwhnkl8YGY21UsTAV/uOqruOqgbJ0 0jWtU1EW53AKkw8AqGWDulDN3vU+LeSVAK9cu47fGsYf1F9uQ/eOme29YPwkxowf0cth8r8WGx68 cXjt/8eY7tMPM6Z7x/7mOvcxLZBlooRvuYMBmYoTmAmpaVqSAVRZmSowZDlIVOZeEkIwxewc4NXm 9rqGrUy9WoBWaTqEKxxVwbB9BKVtqr1JVGXVpjTB1ahbrymX+XSXJdGpgg1EyeiRKts1nskot1Of Lu5yadsWF1HS9sPKrd97nJHGRnN8Pm+TR+F8ajvnWhrG79OgDd33aZ4P+GbDuKH7Af9juYtnZCEO MBQaCUjgBLBcaEP4OiYM8rju5B+gShT0fg5NoZgrUyk4VcczJtiGb3Evo3+pSAWbiykJLFGtJVBt rJatZM0sjpw6ZLsGgo2uY3IISilpvZJ2vvHAuu2wR9NN+iNQve1V8ga0OeOK0A2qM4M5ZStQjMN0 yHIffIrL/oMvfrySDePYvqF7Zf8J3nVg3NC9sv+Srs/aE4QVdqkkA0b5xZVL4cS9GeDd7IxsBmfQ tJRkGQVOlxoVitKRslHUHG+FMnejor1r+YHdNwjkGtzA4RSAAvtsH7gR3JyTYwoEsy67Y5sZBOZu XM1GaANsk+o80BW2vib2c8/vMnecOE8I5HNMmzpr6DjfPHV8IG/XLGzf35c7MowPbVehe/PrmTLE 2svXw5Sh9/fXe7Xcf08YP3148r97Am7qT7mGd20SujfHvfyCZ1zD7mU1jf+hdzq4BeKCLtO7ItUI LCB1CqGyUxLuXK8b3bwgAjnuYgKcEhSF/M1fnPcpkyhp/iLdpUjebTPtx+0IgfdWSG4yNuzClxsU 7QRQRfWO9hyTFc7uIZx/Dy7swRXVsRCW7XEtWxWQ1c3tucnobM/9Q5GoW8eUawEO2/IyQWDcJlY7 QFbfv690l/xHeVsY/99MbSKa+tOv8S0UG7rv61/64e+94nnPZGrTM9PwY//jtQTj6wS6h/8r7xZv xwLLqFVAWvAFd7qPEZsLNzVYoR6jKBm7ZTN7o4hDN8BoPseCFZ8Rl9yJ23lsxGur3KQ+6hKXRk8L 31KwnusyJqALlRy4WhZSZsoQF/aERAeWXBaGtbVgwTQF6DR4DrwtiqCm79wfgc0R34udmqA1XykR 1S4qkqBtzu3jbdNdErq3NcJ0Loy/1RcX5kRTB8b/Ghjf75rYz7ihO/1FXt2fVz+MG7pX97+ga7d3 iE+AJMgMkAKynMY9uzPIij11t6pdru1w97oZgymfThXi+hrlq1rNgh4cm4yO9ppnUbO19iMXLk5V mgt08qyJqnYcOVORQkQDtSLMAWUFXtmOwI9be6y3GuUhQGCrmMnj08CCA+uNUubL6NpeTeHO3PdB Q9i7upZFAnYKTJ9c6nR7FgiMv2p42Cc/cLjx5NHD0/7flwy/8dZbbi/nUa8J3V971UuGp/2HRw83 3vuBw7/6kq9qN/NR/0buWOPC+En/22cO97vnjcO/+cb/c3jZq397eMetPvgfJ73kvzxtePQ97jk8 8H/5V8NXfdezD7Iy1XG+abd6DAskCGvkKmpU1SlsmYoEIDecq1lNWQIy04FwPuNadp6t5Zw7LMAd B3a0V74ZtOUc3oDT4CtgHciqtIG6c4mHUUWrioWfM4utx7YN6rLeGW7qrW5rpz8Jeojp2lyu3JW6 o2alM3mlLoV1WktgTwUsLXMNl/N434tyfmGwmV+s0x23wCXK+N3vfvcdL38FS9wT6Ha6PixwqTI+ 1r8zodupLXClLMBa0IAtKrfGS2vDA+AksHipjE2ZyzvmzbaEgNVx1QBTojlmzLnJ6GlBLo31Qieg Cne1fuAVS1pWdDVl3iPwq/JtmK/rMpgmx4Vd5nJamtL2LGLd1hnBbDPSf5yUHLHNvcmVDIqz0teG zDOX7pL9Vj8VtqFOH7QF7nnPe37QZbtgW+ADtUD/O/tALdX5riULLB2fVfnKo0Q/CyigJX+XQg5q GmDltbienXIkCPmWwtDjsyTkeAlHV8UyUMt6SipfLOS6G4EwdeELBore45PKXJTDsWbHbq0h/XKk 13p8AKDCuLhTPxd1hQtcnwQgs+0psP3UI+5CHGdzgPN97JV98rudfwr4abtTW6At0Ba4Nizg//f9 n9Yx/q6yG9KkcqNU/Yvgj+CTsHuBy0tFLNAMYpKVYO0MYOY1mMpIae/oPh6WlvGGFVWyavSs1Sf5 l+6P/PWtpiyRH1AqrdMWeVTR2aM4DYeqBVHgazmHqwW//bX2jCdXY1HH7o6UShgrzpgx3bS+WtRj 7MwH8dH/aD8Io3WRtkBboC3QFogF5v+TvTeBsuy6y3t3Dd3qbrXmWW5bkiWPGE/YeIAHGBNm2zKD jY0JKy8ECC+EhLDyACfLOGFYhCwCZCVZcTCjZQx4kE3AWQEzJA8weMA2sS3LsjXYFmrN6pbU6q7p fb9vn33rdnVVdVXXvbfurfp21b3nnL3/+7//+zv33u/898iCGzTzEnqEAslCYBp4VeN0rXQvliHa 9WAokR5OJ7wnDSY9j4Imnv5a5YfgqmarqlzM/F1lcjwKFDwIWmRqXZ1LzXkLjJJmHjE6617F1cue 0rBnE6+EIftpDd5iJDSBeL8YeCWdONvwN8yNh6zESuoIbzBQfv9rg9kiFgSCQBAIAkHgFARm29Qh GmThPnutJho8XUX4vBItXiREVvfnNZeJozXwSXKVHEVqIjmIGvdYsSbubm0NIqRTI5uVXp3jOriK ZmI8bB4G7JniybLcpQZgaVyz1n1WOk3lEKjKcv90PfXUIhSr4dp5vemDlGPPtD3iznun4xjbqIPT sBGF6wf0JASBIBAEgkAQGDQCYkD8V5GpRi/hsdK/ykIaUCcjjkVbIjM1Q4usaCrW+Gc3DZvM2OBA zc2QprlaTcdq7PWAKIjz+OKJytI1Snp0aXeXqUbynGk+VhpN21obS3oUJwZnByTalXkYmJEMUjRH s7DHjDxob9JgH1oyWgfaNWgjoblyWzlF4zXj7rJvMOWRpkJMqopfg1xDuoIsIQgEgV2BAL93+c3b nlutDY60zaD6bqdhKN0I1mPGVaz9weoDhvREXOzVK+oSQYrMRJKS9KhmaK4OitKlvNQFucjIL0mP V9JSmzAN0fAuTdoQuXdbQoOI3k3HKhpedNM1YjpnwNdexyMjIpVuHhC8lCXcKXLn4WBm9izNA+72 +OWDJA+bJwV2P5IZClKiMpmmhFftRwgOzs2xhnwAGxI5BoEgEASCwCgQmF5gIQzIV6HOrxVdirjq JgbVE4YQISh7j5KbY5Sy2I/4FiDWJfpkFXFSs7bIFzGvIS0ZBDzaWnFu4pbnbe+UJLH0DPOLLVbn 9NphVtz0jOTYuIFyIFN5tiZNNVNPMaxaAWvN5N0DBHmxtQbJ1NFatmG5qX0wT3/Y0nt1JeYQBIJA EAgCQWAtBLQfsPhIHqOXh5QUK1rBgDQ1c2qvU+4p6ZAfK1tBpu6vVZxHLiu+UqAU6LwRsBjJ5Er/ MkFX9ooZFMWOS9A1TdfwJrORpNQXbvrGLmeTFM3Q7lyuU6LwlkljQJYKM5Fjm8RQpTfloa/XNhOh emhxrcV59RSrwKVutLZla/Km303+m86VDEEgCASBcUNAv4kQQcLIEaijoDv6tHdJczHubRfgQJqj IUqIVTRnEm03DMKmCVpMXW9iR9TVU616OHfQkRimCeGp4lE3PYiIlu2F0wdMHuIomz5ejkhAzpxC 6i6Dc7nQJnJLSLds5dot0JLjo1UHdVGuXnj4cvPRuJmAre21mXyRDQJBIAgEgSCwEgG6dMVGDKwS tYmRPAAKb7MLjTztr0Js6uNla8BGeJAZTcj2eiFhsjZidV+wGo7VzE3XMoOgGNDl9EaPYu9G8BQJ WZpYlQGdlfDIQzx9wDUd9nS62pmtU8az4AaDrniYI5+yiOy5QHOlY+I5w0xepwuNcDkmBIEgEASC QBAYFAKz9kbFRJAqg50gR3XGqjWYjZKWPVTopxKWmqHxhHXha2UxNyErZsOvrEtIkkESxGMt/a/0 5bIohmKmVBb+NAFyR4Zmbvqf3dyMjPK76Vtx1eNVWjdCmwxsvDCPO6xzBotRFtOQTLrSVft5a7pX xJJcJXfqRclQ8alhq2S71fynWpSYIBAEgsCQEOA3uv4gDqmAqF0LAc3ugbBEdBrMBGHO2iPFG4by 5BFr5LBJUOc4xpzDXW6OlgyBg/WI0PBQp5dEsibC2pTMqGiCb7JYeoo2a8VVjxj9Fvfo6Cooj1mK eAAgp21RIUvz85qCZL6VenTgPTMNqg7YkqQIGnJ3JuWTYi50xC4qRJI/a5zzwNEFbGuvFrfRY8vX jhvNF7kgEASCQBDYvQiIxyAokQ8OpAYnmaiEB6OjCfS5mmfxTjVSCvqFy0x8ioNMyQNVTmlOLo7o vKYCWS3Eq8zIE8gzLdJjShE5TOImWXSKTBU7q3c3SXeZpmfxmCFj/GQGe9XyIV2ayz1tSnbMlr2S c3GId/VQXnnzNF27DtZEKdS5PiycCWm2PO1IuQlBIAgEgSAQBDaDgHa810aAIinRo/tM7e3S9yoS o4l3YY8Idq56x6x4NWMKxFtk0DJkhiMqMpvWCld4tzDwIqON64AqbxMoGUYls5DGkmQhRTxVlDAY SrmhRI+85kgcxD+r5mbWl2bUtPmYrKLaKT0tMEobG6bklmPr4tJxGcRQZwnxYKBE5ZaevTrqz6O3 Jah/T4PSA4Z1qryNBMg2IQgEgSCw4xDQT1t+37bnrs66SxZSlTcJIcGfZjRcWJp4RTwLeJDiNRbW YPEMyFGcJtKsTbj2Lu0GK4+mEqFnSSQ8I6JFndNpZ9YJfb9arUNeLp5wTYTb8HAR0akJmf2E56Sf Pl1IVm/4xvJ49TCArSJ7WrIX9VbnJ4to8dptWm265mKeecKyuDZVK5/0TlM36aCs9cKZfCirV7ye 1qQFgSAQBIJAEBCn0tRc+3hpkpWHq/165+fkHcqTxHPEW4T4aHyGQL1FoeLmmZsrBN3NasbVlUja pCXCnGZzYOmAuD2tSBoQg2TJZA9Y5Iq36nKI1jWbKdijlX4cc/p62ZEJO/CDpc6kLikKqy+auqWH pS0XsJc8Koi+Y7ndiidZsgrVm1a6kngWWBnOlHRX6sl1EAgCQSAIBIH1EPBCHNXjFQFKEg8XosUj XjCBduQHsTHMWcTXtR6bXGFEcZ+JsXNydaGIrmmYwtGLh1udahGu9CxqhSqIESKESzk4QJpEKMDP JkQfiYUxRepShIRHOytnJX3srvaRSF5PqVIcsqoFyiSNPGXoDAO6sBni3Yxs059jEAgCQWAcEeDX NL9p23Nn6mBixipBUTT1QrQ64Gt6ZDNk5nFQIlAToNJ0bXJUDAtx2MOU/T43CUKWym/Oq27m8g5I EKL6i6Vjif7azjOFEsnlwVYQpV4QJ5aYMLnm4UDt1ugl0TyKCE8AHBS5xDBpPQm0hwRZodiqvclw tA5yoFev04UmtyHZzvLT6Ux6EAgCQSAI7F4ENGqpBrgXamTuLOTU22uXWBEfFMbAJ/pe7YmKOz3Q SeQHUXsJSzO38kuZdymCnKVvvluPuZKwRizP7vH0Jha8hPugaFNg58Sa7FQgTcSQO17rvNkWstS1 0rCnEnxHoESQKO/bzdykE4VNXQR60SUf3nOWlbxu2AjZNgWbkW15cgwCQSAIbDsC+l3M79f23AWN sTL11YFVIisGKNWFNDSYSkwHyTKAqXqMIjW85SXtYqj+WbLW7LAknqryqk8Zwm6DnuYlODOzx/27 tT9Y9McIZPXrMgYL8oUoW6jloIsYUbSbwtGnPBrghUcLe9JEbrtgY5q8FYftjMgmquamC7gOzLKX rPjq1aOj2lsll9+pQ3stx5561mTa8VSJxASBIBAEgkAQWBuBWROsiG1e031mRcPzGvkkbnRTMERW CUsRGpzF5gYMZmL2EcRZgy5EgLU/thIyWxfCoJWcdKomZ09p0lkl1pqG26szN2f7XA8AtQlaKvGi Fck6z5TmVaDRCXfSFK2HAjc5Oxm/licC7Sq8NGebZYHSmc5EX7AeCjxaupbHoC6eIEzmtRK2tTtd 90CdThc2IHI6FUkPAkEgCIwIge73eESlpZhlBDSpdlb7AWtqkch1XqOTvVevvMhphiPTtyo28WAl Hef0gqQXTNIwn5IlRwszA6NaUzSEhyeLN8qoY8gVspSAmqp1FF1C4PZU3YQNFTLoi57jWqxmKjmf U+w6S4PKh4Dx0K1AOvlDUX0AUN+yzzWuWtHsSUxpM3LbF5mDrHPXZx7CrgVsjFCdk9xrho3oWTNz EoJAEAgCQWDXITDLHNpZvEn1BjPKGeLqenndbGxvkxFNs1Cv6E6rXeGdLngglohMTGqPWCKQkD1q iJc5uZKZURzjorxjkTivNmuLMEWklF2boWsfs9FXXvnZ9raV1X21ldwgTPYhpowuXnb5MUBxS8xZ kv1OUzpES6hcLfKWYI3RQ4Ac5XJceegfXiNshFA3IrOG+kQHgSAQBMYCAX7H8lu2PbdieoE5tmJR ls/wTeBmiLW84pVvTCXLpfkT3U3SNcOixWaQHStcEdwfq8FOeKAsMTmtJmv8zEVdW4JmaunD85WU 8zLwqzUpE4dSiVcS1YlKWv5gYKdE0Gry1gVluP0aIpUnT7Bu8nbkag9cyeTj6QLb2NO4esqUeXI4 3YexpRurk7P6aq34VUQTFQSCQBAIArsYAa2rIbISD0FU/MFuEJ9oyrCwSIb7YWFGBY+SlrfJpclI pCZWq83USscDnrEXi3QlOLxe+M/lQNIiR8oygbMoR0eWlYyXSRi/2GV0siZbykMzOtUXzJVX19KR K8jei27IDmpCoPmZUL1v5ZUQehtJr0aa/XH951bU97Za2mpxfVlyGgSCQBAYHwT0W4hjkjB6BLS6 ZEeOKpspP3AVzbwE0mieNjHqGmKhb5gtBWmahsi8DCQ6lIVND2Bmk6sbrNVcDYnCg7rBeLx4yqxS BcXjdzOsmkZngrm80Sbs7EhntqfraUySbUmWkE3YBdl6TWo+SJijRNJNxrKL0dAmfCSpBzZTBwT7 Atd8GHnVVcKqTL9c/3lf1t7psRP14aUXkZMgEASCwJgiMH/iWHnkkUfG1LqdbZbbbSEbyNYLceCR ipMgKQh2enqPriuhQJ40TdujZD4S82n9J3nrUJSJz74rPGivFAhZ5pLVN+ZheE/whQhFln3854cB 9EGgfgiA7NWMTUR7KJBR1St3QSZV6Bfit83SiUoGdPE8QMAO109p8C4evR8KeOLoQiPeubm5cvz4 8fLoo4+WY8eO+Zw4MEJmPfJtabcfPtrU5hgEgkAQGGsEHrnnjvLpT+8baxt3qnFailJ0BSuJY/Fu W0MEHiWjnxl0BYFBaxq+JFKeE7tBYOx+VNnTNDatucGaq7s0hwb0VL1el1nnSyJfdjGanlVejULG M62jq/F/VbgJthKjR0PDzdilgC2UhLe9qAcEb85AjMh5SiO8eFAgPxa2EdJ2xiFMnXjOMGliXddD ek3wLlPlSG5eew0/9thj5aGHHvJrVoPOzj/v/HLllVeWvXv2msCxZSPhuc+5sXz7GzciGZkgEASC QBDYrQiohVkEhVO6V9QkMquEqYZjyBiS1Auim1H7MWOWF0W+7AG8IKKFH+E+jks08UrP1B451Wzw wDwiRZiIQVfkDN8xKnpRA7em1fxL8zRrQpuuvbURWWUDVGqllK84E6w0yQslwg8Gipdbyn4PlmHg 2NLCCY16loeu/FZn+/VQIFkeC2yvSLjtdYwnjWcL+dIEc/fdd8uiqfKEJ1xVDuzfb2Ku5KyKSSdF JgSBIBAEgkAQGAQC9oAhpkU5thBrJRlIS32qeLp000qAoz1eNePSijzLCGQxqvPqSLP0lLxGCJuR z1OzdmHJJIdZ5xp5PC1yJp1SpuQxQ/CQK8tV4tWyEYSnRGGF5RRHGR2B+kGA3ErjtYibq6cH73Ak WxeLVtzydCQ8X1UKu2FekayuFJhIxSYQWCClSoeMId/Dhw+X/SLdx135OC2duSBv+LjLcLa8BYEg EASCQBAYMAKe+Mtyj3iQbR1ocVslPU39gfx4QbbsDQwTT9NPLLKEmBmw5elEIm8vMGUZxREPzYn5 8J5ZHYs8eJvSqHQRocr17sGts1bE6K0LKUZSzktZeL4KnkrEUeX6Zb+Wpm1FSm4GG/CflY4C+rQr 2SunohjZDfGy2pbTJUM/L54v5HvFFVeqz/eEtmNcbl6n3IQgEASCQBAIAoNGQJwqkhIR4SF6o3po zqOvRGY0T4tQ67Z+NEAraEDWkpZ8hBxJQ4a8M8qzoD+cXYKJTp4kxyX6faFaMfS0vOQ2LQiitDcr gkUfdnjUtUlceiFx6XUaVEq89ChaL84h4npcQk5eOOU5SkJTNEtLxjSMmM6kxDajBHn6fAlXXH5F OSHyrWU4Km9BIAgEgSAQBIaGwLQHMzMVSERKYFEON92KqEyOsCvxIjBOmWpEYy8kh4dLPyrepZhQ K2Kp/7eTp592doYmZ8nJ6TV9y3tmQBQ62gArjnjSyFWPuiNjkTL6KcWE2pWxqAcAe7C2SbZCtBiA p4w4gSZm218v7eFbl8Rkl9eb1vXciRMm4Msuu7ycOKE2+IQgEASCQBAIAiNCoDqQrJms5mFIC3q1 52gCY5lKmpwroU2pn5UA31UPWPwnDlTWjvAk565hR3SylRxhR/LQRCxONWly3YJJlC5dK8dzrcRb 4ztB6fC1MiFBgKRpoiaelz3YbqUr+ptpNnedeDLQuT1fGcxSmfNzJ/yQsEfbIyYEgSAQBIJAEBgl ArOeA8zgK5HTrNiT/ly4Da/TJCtyk7+qeMmwCIeIDFl7rJApFKg8oj9lgHiXzW8kWX3mmkcS1UOF uTnVi4FWYkqv/ywWZVyVE9wUTrO27dJRafZmKU+FLsrTZUQYRWIPZDtXje40Y4H0Wazmb7L0B9Mf ffDgQT1EVFuUKSEIBIEgEASCwEgQYACyeBO/VOSrqUIeSCUPUVwHJ1YSlikQpUlZJGcaJl/X4WuC FIk1wmUpSsiSmEqPyqumX/PqCq6TOjV/m741WlpWcK0+4xoY4QynQ8LVFvT6IQArRNyce9NBkb8H keE5qywGirHjMJ60hjrTKl0HeKm5fZEHDkUvioDPPvtgV1YOQSAIBIEgEARGh8CsmRU2UphZmhVl iSYhRAhPf26yldBiN73HDK14mp09spmt/ZQGDbrZGOJDxawGXaEWLoXNFfBQ56V4BiZWFGRfR1Fr BDPLW8r1NUmzyxF9tXjfkoNKyUCTcluOEn01oFtUb3uRY7EQHiRUNT1d+AFjhpWslCI2P7F0QkfV TfILIuAZ7YXsZutOWw5BIAgEgSAQBEaBwPSsGAp+hLpEU/JG64AsvFd2OuLI6lP2jDUXeLpoVSjt CkxYtKcs8lWeMq1pRfJgi0ZI90hNJCrtJjsTOaQLp0usebScI8VazUvqY3a6m8RFxcw9VjykDEm6 qRhG7ggdcl0UqS7Apva61ZfLCl1i2wXXRjo1aAsPnfKoy96pPT5KY3d0VfIWBIJAEAgCQWCkCGhr 38q+EJzJT8S0NL/gHY081UfMKx4UaYqQ5Znipc5AyJ2ZeMk09zI/mPPq1kpWpzAv3NgCZbQmacd1 ZRI/A5tShu0RVfqoZmwdbZe89DZymrxu4rbuOliLsiHbRVYMgYzRp7yUz8OF60czONOosJO89D0n BIEgEASCQBDYBgTUbsyUoOqFuumZtlqFtlzjjD1Gc6PeJCjmMm/RTA2L6ejVqjhXgndSUhyEZwKH AQnI65SFN3rkjLouzHdkCDnS/GyZjpDNpeSDlAnSucSSlbq0nPJUfxaS7rx1m0rZeom8mfq04Lo1 PZ1dVpi3IBAEgkAQCAKjRQD6rN4sbCYSNF/i3mqwkulOpEUTsT1RRkTRNwvdmdTgNpGtonmRwWpM h1wS6WhPc4JAeTW6hKSdrrg6hbjL4T7pmoYplN8LavaGfFugCZsriJh+aKymyZzmatSLzn30gwEE jm7SOO1T2/TlGASCQBAIAkFgFAjQBSyCEiWKfFl5CgKF0fAkzY+QlgJpS+oThugYFMVxScIMvdJp DXiuNFMrS5fNJ41oEULaZCkB6+hyMxKbcdM1VFJfVFN4XSCEwqo9U92DQifoBwHr7PRVZkUe4mYJ 6qZTFzYU3VRapiHWPQQ0fTkGgSAQBIJAEBgFArOVBEVGYiSTnQiOPmDTrs7ttYpUPQ9YMgtmVxEX aQxucv8vfKYckDQDsbT0FaSIVuuhJhCnpgMtsuoW0ibD6klXNlS5NIebaCWrvubpbsMGsrv5Gf3W y0NAfWBgi0R2XfImEPZuGbJFGSpL8u1JgPphDDs+eTQ1SnuE74u8BYGRIsDDH3tPsw0mc9Jbt081 on3SdeXvymhM43vGIMpZbZyy76x95ayzzqrfvXWKX60eI3+w7X5ouoOsXT7bbH3WqeqmksYCl01Z PDjhM/kcDa70ydEkD1hfOH3B4Sqm77Q+YaowDSGKpHqjlu2lMoyKcdCkQHaVpP0boc88Tb+eh6sU PoDtizhFs6885FmRpb1dZaBPFllGOtv/xetGTkQ6NUUJjGDGkmofpbHJknc6xLGV7Vp6Q9Oa1Cyu srhaRJ8eGDjnb/lrKHHFezEv6eQDEucXZBO2A4FHH320HD16pJx33nnl0ksvKWftO6vs2bOna/E5 2SI/fJ4cNbQrHgLm5ua0Sclj5eGjR7VRyeFyzjnnlgMHDqxa5lr1gPRGGvSd7ntkcdF8v/kt2Ux9 BmXz2OAyqAptUs9mP0ebVL9jxKsHzCcVD1UE2/pFq2fJ+sjM561EWcoJke6M/+aZ3qOzxaU5e6ow +KKWgJzS/F8vDWl2k16oUN4svjAjnfGgaRqWJElKgyT587dFDKtIESp5GFk95R2MwFsrdYk0TbQ2 UuUpy6zmLs9B1NZVSVbPDTjQqlIlWSW5HOYgOxPX9CV38TokBIGRIXBUxDY/P1euve467cK1j4+2 /vk0rh7aQ+zqqYONpRUMrxfv94ILzi8XH7uk3HHHHfbQzznnnJMKW68eo7T5JKP6LvhNYPDlRuvT l3VLp+OOy5Yqt8HMm/kcbVDljhSTm0nT84yIUS6lSBjSkmuqaHZQwAvVwYQGye3R2tD6qRCRTZub IeG9JktzOFsOihXhOXY/Ug+sTtAgIlTkAs3PboYmWk3EThNhyytuPbUUW8lYMuzigD22AhuZa6w5 yDraLr2T094sDwki7EWt8jGlBwHy8SOA3uoJy2auFb8wJxv5cmIZbwlBYEQI4BnNL8yV60S+XsjG 34ERFb6JYvxAoC/ZPnnmT3ziNeXWW29VU/kxb9uJmkmpR6vy6erT5LZ6nDRctlrf0+UfFe6ns2Nc 07tBWJCXoIKNcCvdX6tzNwXLdMWxXCQb39OvKh6Vc1q9y7I453ze4UjkKsFKwpAqstJJ8zIN10vz 8qAhUNOi9Lv7FoqEcvWnokmeWsCLFsnK08Ukla588rQXO4LFOZawTJBp0k0TtstVPWjClq21KVu6 JCcx20TzsweazeKDE2qZ9TzvQWC4CPCZPXLkaLnuSdeafIdb2uC0z2oL0UOHDpVP33yLvEl57AqT WI+GyMr6DKqJf1Lvb8Nl2Mdh4T5su4epH99WdIg/KbKDARVoniWe5mAIkA+oZyAplj19vSKV0qEx 0vwBhmxZEQsVECDpvX4gKFCyXOPi+kKkqWLsXVsaMlQEcXi+DqJt2VSbsEXszAuW/mpvlWCBEK+n aa+dUkXe5FGRHAkuXTbRp02o9iudyiUEgREhwICr8847V15lJbERFTuQYvbv31/OP/88bdt5Qvtm T249Ghj99WlxWz1O8v3dat03mn8YuG+07HGUm52RO0vzM8Rm4pQHibcLbeE7MqcW75bmW1GWYtQv q3NIsNFX856JEx+akKt4zQOdo98jnEV6rMW8IDL0elryXqteMoog8WCJkXKPqO68YGWuDwYUKrIn 3fsCo9eG6EGAeCyjcBvQ6SGe/DKii+7JNJKW1oQgMFQEGO188SUX18/eUEsajvJzzj2n3HvPfVY+ yfVo6LT67N27t0Vt6Tjp93dLld9E5kHjvomix07UvmrzZCEyr0KFxwsR6kWo5KUTvFMzmMjX3qNy 0vTLOfxpknMGx0GHEjRRk42RzZRFOaSxGbHJExnLIUSfsK6VoXrXtUyIFUUmUc9RVroyz0gWbXjm hOrdUooChTayVv5K2ORTfEIQGDECjMbdP4Heb4MJomK6FK9JrsfK+rTrrR4n/f5utf4bzd8+RxuV 38lys/MiozoFSAOqNOgKPmOzeruylZFNoJAXJAid0pTM9N/KyF1zs5qfTc6SW8SrFTGIzawEAABA AElEQVQ7QHZmWaQpg3h6hBnh3JUt+bq1If3Dc5YxCasMPwiYZKsaPRrIRjVl6+GAaIZhecB0R8T0 BTuPyu1anE3ETmbVLgZ/KVe1FQtDxqCQMHwE+F4w8GpSAz+cCwu1e2iS69HwX67PYH4DJv3+NlyG fRw07sO2d5j6YTxRkL5UYqsl7STEyGd8SnYZmpKH6i39RGaQJYznhTQ8ktlUbNtYAJIPHx6pP8oi QbxMRhzTLGxP1LwL8YmEtcDGtMqs3jTlVCpmTi/kajLuvhOsfOW+YZXkRT80EMseLLZAxmwCwYAv 2eR9hTG+C96nWARtb1r1YRAZc5EZ5V2DrptwjkFgyAjwEDs7qx27JjT44VZ1IExyPRr8rT6D+g2Y 9PvbcBn2cdC4D9veYepXHzAEx3Qj/Wke8IwGXonKRFqaZ8S0HnmaHgEtK3BmPY2IhmR5kiazrpna TdGM1NKo6B4H2vPVFcOV50S8Gn3spSppLsZJVtksFQk3kwdy9zrPKqd+KUT8kiG0eEn5303StrPK mLj946B64P3qj5o4L8r08sIfysPIaTdNU6FakOXyFgSGioA+a/40T+hnrm43WhGa5Hq0e9yrz6Du x4Tf34bLsI8Dx33YBg9R/6ynCnk4sjxRHWl9pnF4wXv+6mumEVMQF8+9M3ijamqeUjMUU4TEzjYN HvO5CLCOhO4GQpkAq9zUHpG5Fh8Qo4rc5W0riwndP0lcqVmZJmqJV14UMdujVprKcX/wjB4UZB9T krC7cDR9K6u820qm3Vxm2b/IiOuuD3hB6TPyfhc0wlqW4PCPTZi/49Zy/G8/XOY/fVOZu+eusqiF GgjTWvhgzyWXl9knPbWc9cXPLbNPuGZbbF448tkyf8+Hy8KDnyzzj95Vlk4csR1Te88tswcuLzPn P63MXvLcMnPuE7fFvs89/Nnyt/d9qNxy5JPl7kf/rjw8V+07uOfccumBK8p15z6tfPFFX1Ief3B7 7NsOUO66667y7ve8u9Dc9+pXvXrNlay2w7b+Muk3vfnTN3ua4BOf+MSxtbPf5u04v+mmm8o73vkO Tf+qn+1h28AKbd/yym8pT33qU4dd1K7WX+cBa94tLbMmVfHggppoWX5yGpLjJZJkYDR8C/nSB0yz ryQqeFpYwLSt+YJVvpIonAgxeitA+o5YqIPpQoys1h9eKqzJuclSl5TjGMhX5/pmOj9lQ76QbiVr qFdU2pNROsTu+cPSgDesF48IEPmsykQHo77nlYdsZnuO2xTmPn97OfbeG8tjH/7rcvHBs8u+/Vru j7V3u2X/lngauv+e8tif3l7u/e/vLPue+6Vl/zdcX/YcumokFi8cvb2cuPWd5fjhvyoXXzBbzj5w Vinn6gFs5myXv8R9n7utPPLAp8q9n317OeuyF5S913xLmTlnNPZ9/uHby//4/DvKR+55f9lzvtYt PrC/zJw3W86Zucj20S1x59wXyq1Hbil/cMfvlmdf8sLy9Ye+tRw6OBr7VrtJdZDgaimDizt8+HC5 4a03eI1ptH7yk58sz3nOcwZXgDQNqh4PPPBAeeSRR2zbTZ+6qTz5SU+eaBIeFC4rb9bb3/F2LV1a H8xXpg3j+qGHHjLh/9iP/tgw1Ednh4DcxEpwEBL9rYxwhJ2mtGqFultFwkxBgjTxXPXF08LR9L5y jrcKwbHUhi5NrtWDZYQzfqZ0Ia3ENjhKEdJJHF5yJcipyqxoUJM0fcfKpTyMwqb5u/YBYyd59uh1 wra60O4BgbzVGuzjTLJYRrTOIGfyU646jHXthN4RqVGGx/7X+8rD73pruUzzK/c84QkAVKvQZ8SU PP6y96yy/+yzy+MvvKjMffbmcvjfv7EcfOVry76veGmf5OBPT3zuD8tjt7y1XHHRUtl73YWyT6hW yHqFubVD6xcfPHtfOSi5E0c+Uv7uAx8t+657bdn7+L/XkxvGyf++8w/Ljbe9pUxftKdcdN2Vy58H FdbdWm8qsEce4L6DB8rSxUvlpoc+Xj7x0Y+U669+Xfm/rhyufavVubbsrJYyuDjI96195MsyjFdf c83KW3fGBTZsV3wUzljfQbXysG40awfz24M3/OQnP6W34tYZK95gRt+TVqkN5llLbJj3t5Hv933f 95Wrrrp6LRPKj/94Jcyf/umfWVPmdAm33XZredOb3mRve1D3eWWZg8R9pe5JulY3LMSkHy2Tm4hT RAD5VZdXJ3jCiqt78LL6lM6VAeLl5bm3vkuiOw+gatW3u6ovfpWERKUZZZUEyStdrA8NSXs8tPLj DVtOZVQyrz+otpN2494iHZRfPx7u8+2+RMTUeIi72mJPW5WCkL1/sY5kZdnM7QiP/P67ysyNv1Ue d8EF8tzOV/U78q2fylrhk85lpWSQJQ950TGscPyz7yj77vzV8oRDe8re8w9yo4yX4Qay1V6SQZY8 5EXHsMJ773h7efvdv172Pe7scvCCc2Ue97XeT9/TDjvO64sqTFmWPORFx04Ld999d/mt33prz/OF fF/zmtdqAQ19xsY0YCOE2zZvgIRpbj127NiYWry9Zq1HvoOy7OqrrxmUqug5DQLsb1B/wGi+7YTr D5o8TgjLP7aQK7zQSegCUq6jiRUn8maBDqb4eCMG6WGd52V9KJYuDvxSwjceiUwcXi36aSJGQna0 1bKUR664hEX49tSthljpV1JVKB1Qq8zRdW221tFpOkq/66H+6Kq/xkHSPBT06qT8owiP/X9/XPa+ 7/fLORermXRGI2KxsxlrAzrDe8YY+O5KNdFSgOQ9Kh3HztWqSl/+1T3JQZyc+ML7yv573lHOu/Q8 3Qo1gdg+NPcAPbkYgHcSJ7on8jid9+53lGN7zyt7HzdYT/3P73pf+R/331jOu+RCDRjUmACe7/is rYTN1nRvJGKePrd7NQ/3vEtmy/+458Zyzp7zy5ddPlj7+otdeV4/a+sZujLHxq8h37e+9a094oLY Xvva15bLL79cSgZX5vL3ZXA6D6jr4MlPfnL59Kc/bS+YGRU33fTJ8pSnPGXozdHUZ7lOG8d7Nclh 3t/l8iruN95443KUzq6//vqTrgd3zwd3n/sNHCTu/Xon7VxUyO9XB7LIDgJr1yYzEVdHnZ3nK1k6 U+mf1Bcbb7hoWlH9hVMaTZVQXseEpFsfHnY3VQn2hOTrh6Sm2wR5wPivECa/GbZFTeDkt3et/O3H 3oYj3ZlO0zJ+OaQM0bpMvlyKZaUvmyv57pfYctUGR47kbf7Oz5WH3/6WchCPBPIlNOxdYSpNXP+r XfTJKi860IXOQYWFh+8ox2/+jXLuhfJ6IV8Cxdu2ds51X+iZpxPLKk150YEudA4q3PnoHeUdn/01 e7ImX5fNve5K8LXOVx6J6pMlL54zutA56WE18v2O7/iOjnwno3Zsd3jttddqepNnRvqBG0KOJzwZ 9y9WnhkCbP6HD6p3aLbr7+VKBMk8XkZj4WQQcHo9OgtvleZgeaqmOJql0SI10+p0tT+qZBqTcVEg VLjThCch6+6YkyJUqm3wHGHKUZw3TpC+2jSNbh4EsBFbMWS5H3deaQxtJ5WBN+hk7i+PCBjlbQml tPK3+qUV5znBOo4yHPuDG8tl+qGZYjUkiu6V74p2pqy0SZUhyu4+57pQBdGBrgel85zv+cGBVGPu 1neVyy8SjmdpaT7KtCl685HrPrLrSgRrA44MNvLUxL90XH7RiXKfdM588Q910ls7vPdz7ywzF+0t e7WF3ymeL0WDDXb0B5tTbTJ0EuDziY7jFz1W0PkPn/LP+nMM9dw2DrCEe+655yTPl1HPkO8VV1xR 8RhgWf2qBl0PdJ+tsQ6MhP7MZz7T6xP+1Kc+Ze+YNYQnIQwDl/56N/2veMUr+qNPuddN7iShM7gY lJ4zKHpXZIHJegOVmjvJcpTsKMQ1P1q1lQ+vt3qZHsjEghr69TXt8WuoH16mMdHHyq9gHWTFj139 o5m6jRAkXx1YxY8mWXnTy94zU4WUBwaWWlM7aQrkm4LgIXWMUuDhYdYPAyqTZmps17HLIQl+btGP NHmh8Urh2MwHbBSvuc/dVo5/+K/KXg3vty1dnXxRjbV9Na2eNpt11bO/ntf6oAud6N5qHRaO3Fbm Dv9lOes8jXDGng6veuQanLr4vmONs/DJeRSFLnSie6v2ff7h28rf3P0X8vyX8TsJQi7417H/1eJa PXr2ShZd6ER3f55hnvv+DehtPfIdUBGnqGnYnJIwoIiDBw+WJz3pSb0+YQZn3Xzzzb1+7QEV01PT 6jOoY09xTtZFYFB4T7qeWf0OVaeWExEgxCcqqyQlpoIMISp41YOxRG6MLIYf9aulNxGajvT5slev V66iqVl/gOPgY53qxFxivlSsC932+2WAFR7ttDpxF6dZ0UokvHBC6ViifPpbZKS09TBwG99WP7TY Qjm1EOXTufYCrvklI7We4tzMQJL6kNsE3iU4ZrhvJzTP9+JzaNqVUb1idbLqeZ8tpPe8375zRKQL nY9I9+wWpybN3/uhctGF8nx5CLJNfbYJd0PfbPUFtlRZm0im7rpnr3Sh86h0793i1KSP3f/BctaF aj3gHvO817OFc13w34sEnBqI82dRAn70wmTy6oUudKL7cWdf1bJMxPG+++47xfN9zWteY893Iiqw jpE0R0PCEC8P1Y2EiZsUT3id6g0k6fR9wAMpJkqGjIAbjCFU/1Bx1KpV9lBVsD779ihnJGAOIIJf LzxRHSA6fnN97WZoFuiQSEdy2I5u//BxoV89T3PiVPN5KcfBv4giZgjTq2+hQ6Qv4icPNGy9ELFG QU/PQMZ6SFB+pymdQLkL+lF1f7CyTjPQy14uvKs6YHeX7gySod6jeC186pN1nq/wcGVssK0gwv/t 6pQjeZDpO3SAWCe6t1qHxQc+Uef52r5aVC2vj3x9Ezo7bIvO642pVeK8hU4Pc4fRvVX7bnnw457n axhaOS6eN8ygwNWD05pME+vsZu4wurdq30bzr27h5mLvvffecsMNN/T6R73YxqtfPRLybfXcnMWb l24kzG8MwVOUhuAJt/oM6rj5mu7OHIPCe9L1zNI/anLS54DfJCit0qLeOYHk1MQLCfs3zqRFNPGV vPgIcT5V9mjAkxZnEMkxCKvK0BzMl4h+WjxpNRGjCG7s8kGikDTbFLL9ISlMS+g1JaNb5S4unrCX vYiXricAm6d3SvCgLxXDQiHVZtmmTCwqogjr1Fu1k/5iFU75owpz991dyj4tZNELrfSVhrT4Jojt CkT7KajVpYvXoBXrttCZv80fk33ndwOvUNOZwa1q5+tql5xNXGFe0Qpo6O6v+bp61ki897G7y8yF dYDOSSKUayO72P5zovjgKNTPp8472Bypt5k9swXdowon2XoGhd5///32fB999FHn3qN52K8W+V55 5ZUn43AGujeTZav12EhZkPB1111Xbrnllp4nTJ/wOHvCw8al6U8f8EY+QeMvM+umWH6U9EMFTfIj 2h+44eJTT/FxquQgaUYae3ATBCjP2PN0p0V+teVXEvrDY1Y6FAnJm1pVoKNdWi0JCQIN1/oVka6q s6b6Z92nnurkzBAu1lRr64hrXasJm12W6ogvXctGdCHJP3bikbMDlIlex/aBrmUN733p4aNl6myt dDXg4FXJpHvL9dDyjW2Fq1VNFFZrBtKM86kSU+z+I91bte/h+SNe4Wo9M04tff0YdE3rQe/o/INb tm/9kmrqVjFAy3ve857SyJeH1Fe96lUm342UPwiZQdRhM3YwMAsSZkQ0ZdMcffvttw9siUR0DqpO g9KzGXwmVXaQuE8qBtitpSjrD2ulwOog0ILM72n7seO6d9FFNs8ZJTP6ka1Tf6qn6w9iVSs98k/x OOuiWCZERkpXErZi0y952H2J0Jqw6evlRwbihEGb183RGyvIRs/tVV57wbAsZ1RGWSBmUpbrImIn jTron9OEIDCpCPC9OH78+KSav2G7Id3+UB+q+2N23/m73/3ukyq90iM+KTEXY4sAzq1Dx32mMEdU LqxcBWHBYnr1Pvx959ahN49ORk7U5iccafOoYzG4/N7apGw2R5VzmSSrBcpPFGUpcEr/jwm2o8pK zDVfXaISUiaf7FI2cvLyfsacQ/46LkhnnZRU5ZGFmhvRS2ToYergOfLQT/4hGUSh6ET3loM2LqiL o6yhqbtfq6auk2ad0r3VcPbsub0pZlvV1fJjNp8VdE9KeNnLXubpOtjLd+yd73ynp+1Miv2btZM1 iW+99VbXlbzME7766qs3qybyQWAsEdBQZEhVBKkfI/3rB0nNtH0/qHjIHgihp23IrMrXHy73w7pP tzU1VwKE4KwM3eSRPhOump9FgRYyQUuuNQUj52UtdXQ55FOonrHoEuKWEHLenam7xtNlpLNmBUPx ImL6j0XcqkflcnnRmss8D7srD3I6cRpR6B9FmL3oklIeut9rO9fyqAll6whgPTOIXyU4uqW1o+S0 dB+6t1qPmf2yb06LeqhP0YEiZBMfBZvWs68mn/Iuud7Hps+8Mif892+9f/LifZeUw3OHC2s7nxQo V3+9+veMOEmqfv767eqSF7RN5mX7LlvOf3K2gV71bNyC1osuuqh853d+pwdhsYkBXjAk/MpXvtJN tVtQvaGsg6jDhgqS0IMPPujm5toCxkdzj/t/WeVrUIH6DKpOg9KzkbpNusc7SNw3gte4ymjeEF6h fsJEToACefmDpB9cpgzR+bs0L89Ne/lCYEu0JZv8mG+rpmVGJIuE+aFVZq3tLJJjIFUjX/18z3uP YEZMV93N+8WLRX+lZfukHU5aNpIff13xMADh8vtPk7T3kpR+PxSoDHK7PMnNaAoSexQvYq+DUjWA TFZb1yIjvE9Ue9G3yu9xl2/whxltKfjY//4jb6zgkiF+DMAQTk4i4RXl29DO2u5gttP5Y8ceLTPP e/GKDJu/nD7vaeUR7RrExgoOtktnfDaMILFd4djuy2WbJGbZmsB5fT3y6PGC7q2G6859ernjkdu8 sYLr3uHXrPOx2bWiMH/eZE87OhmD9X/80WParvDpK3IM77KRyVZKYKs4phy97W1vKw8//LBJ+F3v elfhR5n+0lGEQdRjPTvZdu+2227rkSOeLytlQcLDLns9u06XNmzbNqp/o3LbXZ/Tlb/T09UbyxrO oiiRYVt8g99OwsK8fmhxE/kRFrk5mNAqkXo6kFxn99FotKvORIbk4TUv8quDr2bYm7cjeJOuWUdl ilgpS9SsmOqb0ovsbRF1rCOYdW158TsEjhHaEQlKZm5wS1uSJ+PtDnkQMBtU0vWDhcp23y8joqVj 3tsn1vLbk9iwj7PPeHa59+jDPEVQgy6A7WrnLU5Hp3dC/eeISBc60b1V+6cvek657/4T9eHKxauw rljff877rivGNe4k8rVMJyjc0Ynurdr3jAueW47f/6hbQsydPVtkliO6o21ffjsprcvT8tOqgk50 b9W+jeZftmxrZxdoUw5WvDpHuwkR+MGlX5ARw8MMrZ7DLGMl+UK6PFgM0vNt9rf6DOrY9Oa4PgKD wnvS9Uyz/CNUxW8TL+biNkdiSst04NwyctjkDKYialE2ZxamGZqN7uWmSkbTRPSjxo8zxF61+tK/ 13in/YBVJZTnAnyJ5uV80qM0e706QrqQ/JRGW0+JUW2J44mTbttAHkkq3laqUtSh2kVluJadPCjg gY8ozDzuqrLn2c8vJ9SnJcP1amVjYDOiO+e6vVqiZfxW8+oUXehE91bDlPbInbnkBeX4Q4+cXHZX JPbaZK77XjWuE/JBb106utCJ7q2GKw9cVZ518QvLww8u43cShFzwr2P/q8XZJky3bVUWXehE9ySG tUiYEcOTGlYjXzzfYZDvpGIUu3cOAtCRaoM3WV/wkoOi69Z9HfkqnTClZuAlLbbf+omJZrUsfvTY bMFBkf49FMERj24C3qjJVOdEwdU0L/dCJ4c9hP5L/6gSJwb1MpW2WV6v9E/jlUsYGbjW5NuXGe/b 9eJhg/KwU4eeCIWNIJz1dS8vdz0iL+6xx2ppgORQCaF37ntCWpfuQzuvR3SgC52DCjNPeEW56149 vByXJ0xo5XZFgzULmfS/iFtNFh3oQuegwtddeX1ZuPdEOXHssVos9vRs46Nwsm22E4FmIscuDzrQ hc5JDmw1yK5H52pnLELzhCeRhBlw1d/szAIjw/J8J/mex/adg4B4tP2C1R+w/qrV3ysITrH8cJnk NM+2G13MKGMCKkyy5k08UEf3ESE/lLUcryPd/SLS9NziW6bmvTa96Kr6VVY9sXJIVhFdNunRFT8+ eMktjeuan+lHxMt3x2YJUw4s3Mh6FMfpKx5XDrzyO+TFPagnDy1YQuhwsVGcU5GTXu2iT1Z50YEu dA7K9qmzD5XZa19bjtxPU3n3MEXxGNRnBjG90IvvZEhQXnSgC52Dsu/y/YfK9Ve9rjz8wBF1j7AW ucrSWz+EPTubXRyrWE+WvOhAFzoHZd926aEZmj5h+oYJ2EFzNItWbJdNmy23DbgiHwHyZWMGmp83 q2snyhsUvZ2ubhuVG5We05Wz29PlMNamXU/36T78fAXsKEJokJh/1SQp7wfACo6nWJmWZzzh7jeu u/dI1y+RZR2r68rV9Urkx48mdLky0E1rDcqCbohyntWt0Kqy8WqmOze9NjJTFt679Ckdex2kH7uq bcqHGP3MHa+4LbpLtfyI3va8+KvKsa/8Oq2PfJ88TXnCNhJjq6XLVjuhWkWaX6qp8pAXHegadJi5 4iXl4QteUR66+6GydEKecDPD9jU7+o4IdLZxSh7yogNdgw4vvPQl5e+d+83loXvuLyfUCkD3Qs8j b6asPPa8djXbKw950YGunRIgYVbE6ifh3/u93/N6yuNeRzzfO+64o/62yFiam2l2hoQTRo/A8u/2 6MvebSXOmtT8I1pJDKIyV9GPKsLydoT6QYMIdaieLtRpTiSm8zjJJwLkNaMfZHujykPA0zXZ0hTM jkn61ZxWHy7bCJoYOzkIFFKf08joKRWwwAAwBRbz8LrQysO2hP1EC9nXoVjN8BoDtzPIxot72C6N loaldU5+POHqIbu2LmdUb3u/7mXlMf1gPvie3ymXa7m9PTQfUnEjvIoVBn6xzD10pNylJQj3vfxV Za/Id1hflGk1Gx/dc0554NbfKVdefKLsPVc7JInE1gy2b0l90o+UO+/VgPlrXify/eqh2fc1ajY+ oLm7//1zbysnZN/Z551jEvaAQRmp2+vgZwbOZB+fhUcePOpm51c8/rXlxZcOz75a+qnv9YHx1PhB xdAMzcAsRkdDanw+IGGI+dChQwMpZtB1YCoVK1u10O/5trhhHqnPoL5Hg8ZmtXrffvsd5aqrnrBa 0sDqQRnDDoPEfdi2DlO/F9flA+gfKxNT9Wj5EZuaovkHl5F0fsUcqQPDsBTvfLWJGqptMvZCJT/d ESgjkCFh3JVFBk+JcBf00jJcPiqlFygCAmdAV124glslcpI85E3LaO+DLi98galH3Q+uFoKucpIX zVonHjVX2DYt0oWs8b3ZzqnX/N0rfXQneK/TV19b7vuf/72c+OgHyyXa1Wjffi1VqekWLC9JcP3V XMpUo3s02nnvs55XDnztN5eZKx8/dEMh0Olzn1TuvuM9Ze7THyiXXLinbtbAaHdNVav2CUeNOmeq 0T33z5U9Fz9fNr5czc7Dtw8Cvfrgk8of/d27y8dk394L9nmzBtZ2ZnlJAotsMM+XqUYnHnisPPPC 55evedorNOhq+PbZgG14wxOGhH/7t3/b82j5bn/+858fGAEPukoQcAujJt9W7iQcebhigNqv/Mqb N2TuG97whg3JrSfUxhWsJ5O0rSEwW0lIlAYvQbIKbQ1nk55Is3mZCLlZWG3QpmmIUnGNQNG1SBOx fpdRR5M1A6+6FmNicKHtqLhcZVyUt8vPZY9UOZfYAs3OlIdn2OVh8BUmumw4AFKmTB0tq6h5PRxg LzbhpCtBfyJ+ZGxPXaSDeKdR2DaF6SsOlbO++/vL7OdvL0c+8dHy4Gdulod2d1nU2s6Eaa1wNXPx pWX6uS8sB57+rDLTbTk4qCf201b7wKEy/dQfKHu0X+6D93+0PHDkU2VRGyssaW1nwpRWuJrWIhtT 5z6l7HnCs2Tv1Y4flX1XqP/2u574/5TPX35b+eSDHymfPfqpcu+xw+XI/AO246C85Mv2X16eePAp 5WlXPLscOjBa+2xE/9uIPmuNhP/wD//QUwSf8Yxn9FuxtfMB1+HCCy/0XGa+53jpzPcdaVB9BvZ5 HTA2/TiwAhqtGZDwKALkS5lDC4PEfWhGDl/xbJufW4m4Fjg1Lc+XNmYICzoTAUKCeD5eg1kkpwh5 sxAdhCq6Q0TXMxatfbGQtWhPATqUiEhwRgt6eGEN3wAtrIG8GLorybQIdWpJDxF4JVa0UA7CHdei rH5xPE+5zhGmyXpKOyZBuJKutunYCJq9gr3ylsrjb/nBAOu2L0CsjVy3z4q1SzaxduRafcu1Zbcj BWJt5Lod5W+mzIH92J+mUDYxuP765RHegy53UPpY6/2aa67p1WZQensKR3wyLPvZAeqHf/iHR1wb fmb5JU0YFgJuS4R8+wmYucF2Nc1/HdHJAnugOtrDhA8haMi3CxAsfMjTrD3XXhpkvWAp97/qpkK8 kjRRcgYhwvNEML9XSb75fACgZ/fXsvIWZE05XbyS9Jyg1bbU3KjHfZF2bX52unRx7Nkoe2k5b8Hl tYscg8AIENDHcUeEnVKPQd+M4DJoRHe2vtoHLF6yh0ldux8IvEOPeqYTVWFmSrsSeUsjpvLUnlST m1Mr0bEgB3HuA+7i66ESNURK7zFFzIuQ8ZDdkqzrRobVK8VTda9xWaK/UUtLTk9hqubxwvD41XzS JcyBJnO41ZaiyMTPwwCesxLsNmMzOrlGVtKc5hsjPBNGgoA+l2wsv2fUzawDqtzcvKbOdQ/Vk1yP Bkerz8B+Ayb8/jZchn0cOO7DNniI+sWBkKCYSMHfre4L5kFMIjOnK87Xok88WfGXg3M5zVzmeD7M pPOyt6uzFgfLLuJddwHJOpfYtGgrGJw1b8IUgUqOhT/8cGC9uMW4sO1xwQwq/bpWOvOUbRsy2E68 jlaHqEgXCd5ZSUuZmik5BoGhI8AiNPOQ2ISGOQ1om9EiPLwmuR4N/lafdr3V46Tf363Wf6P5B437 RssdRzktRSlK8gsChpSqx2uSM0FVUhOPWQ6v1e6mjpW65X2S2AVIF+ITxyl0HigXlIF7q2ZkyqOJ mqO3CnSZSu/m8Nb85BGRcjDhVh1utlY+h+4gVdIFCVMeQRGyz3ObuXS9Opv0I2jb7D13CpBJCAJD RoABRseOHRtyKcNTf0xT4Oiz5TXJ9WgItfq0660eJ/3+brX+G80/aNw3Wu44yrkJGuKFDBmRzFQh iFW9qjp2pEacXgsa4DQzwwZK1TtlMwT7riIzk52y0x9rWmtEbrIU+cGMGthF07IFIG2VyzKSvYAM JIo+bEGRzsXcnNirletar52mWLFvtXu5XD9QQP4mXs0bph5k89QpyeuM7ITls3qd9yAwLAT2nrXX 83MvuODCYRUxVL0PHXmoUAcC84wntR4NpFafQf0GTPr9bbgM+zho3Idt7zD1axqSSAiSFLFBUlPq 6/UI6I6ieuSsEcl4rZCwvVcIUoG8yLgPFg9WZGmd9kLNeuZel0GcCRnfWGmkVANqPLrU50vzsEdA sxsT3Ius/2UD6z5Pd6OnMUF5fKCp2V6wrmQHC3fgmVefGBsVb7Kfxwqdk5WcCUFgNAiwwtPhw4c1 7eZoOfvsg6MpdEClPPLIwyLdI+Wyyy6zxkmtR4NjZX1a/FaOk3x/t1LvzeQdBu6bKX/cZNUEDQfi IYr4NP3IzKRrjzr2kGERMsQIqSl1WotzLGo+Loyrsc6VXJ3SVU0Eah7mEkLkoJebpqWXsuBCGNVz hJ3KtZm2TIvYtXwCEYX9e6VCAdtEvpKpU4oUj03Ku+A+ZZq0qyxEuyQvXVkZOSYJ/encRVJZFhGp 7jCKawKJeQWDIX8GaC0679zzyqdv/vRE9aHS33vzp2627dRhUuvh77veVtZnUN/9Scel4TOs47Bw H9T92w49s57jK4KaEYEtzJ+oJLw4J36tTcVLSzq35ysZ/UAt0C+rUdBTCyIyT+IVwcHMmgI0rT6u RW0UUPPSiN2RJlOQRH7LHifxkhXROi869bWGAeZ1mBZJLupLX6c14a9q4JZYFGJGikC+xWYn+eTt Yg5e8LRImQcIkzW0raZvl40ZnY7WXwxBJwSBUSGwb/++cvb8wfKBD3ywfNEXPb23i9Goyt9sOUeP Hi0f//gnykUXXaSV2vbp21K/L5NWj1bvterT0rd6nFRctlrv0+UfNu6nK39c02fxHMVQIiwRlUiX 5md7qaK6SpgcOyKFUCW/uCjyxY0VCUKIrD01x4lIs39f3jrXV3Lyet3sSzNxx6DQM2SJDnxZ/vlq M+rZM59UzpRsItZyIs5Z2QepV9amcLxZ9JAdORG09CwwwlkxtTldnrbK8Q8Hzew0YUsHZbl+nCQE gREicI5WOGPA4Qf++oPqR72gXH7F5eVcLSHJjzcPu3z/WsCr4n9UgelFj2mrxiMi3sN33VXuv/+B 8vjHHyrY7C9NnyHr1WPkK1phl77L/p73nfMgvtH69FVtS6djh8uWanNmmTfzOTqzEnZGrql3/fkt 4lcYjG85Xq8IjWuF5d8BmnrpR8XrFKHpBBLj3+Sm5mGcWLxSE6xO0MaXAZKDq5leZJ0mYeXu9Cya bascOpGr+/vyUEB58pJZ43lB/c+i37q+NGmSdoEqB/3ywLHKGzxQkPS2zRdqvMpQHCSNTUeOPFBu +tuPlJ/7iR+1XXkLAqNGgO/Avffeq77VB8tx7Z9MEx1x/vbVr2BnEt8khZPitmDtKoRuopfKGXUh zc7u0Y5Ee8v5519gz5eHgvXCavVY8PeaXJ3t/QoGVY+mU/WpVeoq1rvWL5ps32x9mtqtHlfDZV5r GuyGMDs7s224TxK+deFVCI7Vp0RxcmFFsJUsqQhfHwjO336O8kwlIfLrPEn6XMkOO+t7WvcMVprI sX3Pls+kBTa2OF8WXqTyjRFNilSnOzsgSV4zskd0q70TWOaSMpW/I3pUcQ0Z22uQvH3mZfOlH1p3 CS7OA7V07Uq5YtUeCSYEgZEiQGvSpZde4tfc3JwfIisB+4N9ki18F4YW+Prxp+8ghMU0I/bhXQ7r l71mPTqb/Z1dX8VyUWd41t9qYBVdnc6kPmdowinZVsMFz3A3BFpANvs52g24rKxjJWCTHmR48rfE X3qxXP1wm9rULCw6Q1S05gPEq9B+IPxlc0yNg6x5gJ7X4Kr6RWxl6IqlI1GGCn1ZOcdbhcl5CEB1 3Y0JkZoPW+QM+1mho1XL2VNGhykYyia19fhSgDx7xTrFfdLS2T0MKDEhCGwrAhDeyaS3reacceE7 pR5nDMAaGYPLGsDs8ujZ6kWaAUVIeK6NcCEoEaC9Tciv0h0bL/hMZNlPqO52lSdKpim5xJxWApdc ZWwRopShFG0mZM5xn1WuDOFplT5otizk4dl9uqTRLC5R5h8zvaiteIV+5GrgRLrkJS87wOhHEU3Z OndeRVFP/kgiW0IQCAJBIAgEgREjoN2QRFd4lCZf+Y0mtUqMeJvsVGQGU1RtHlNTNU3WYlhSINW6 G1LHZMpfl/DAB6XvGFLsSFbS6HLzNG4x7K5/e7mdfjTybxmasTWSCxPrYCvyQ8K6JqNs4zGAJuhq TW1Gp894SlOlsABSrs3eSOrBgEFkWlKv5ZBAQhAIAkEgCASBkSOgMU2VRsVwJj4s8G5IorYFmmoV PNCqGxyCF2oG7DxZPFIHq2EQlaYjSYTA6OiqV1OO5MXigbJqlWmT5mfLiYily94ytOg4mrchaBFq 12WCDZV4eVogKA/2ebBHV6DKthnkcb10pF4kq3wO08pD30wtB+mEIBAEgkAQCAKjR0ArYTVCg7zq ZvZFOw9Bwqz7bM/S3qqafs1gMpKjiFRrsldCFaFBiFNq/vV8Ypas1FSlOiLZQ7aki+5mkZ/y2LtF N66t8nmRDvKLNNmcAaLVihzSx5Sk6vV68Jfk/UxgQ4jXoiCF/X+lRZeIkrQ0K93a+7djWaXrGhu1 spZ2JNZgl+M4/Bii/5CwkEgIAkEgCASBESOAm9kVKfKFkDwga0FESj9pDXYmzZXu/VWkyNJEirzI zYKcw2mLosVZGntFijBilXGDNAtsoGdJ60krnnQoEY8U0aoHk2hCVj4ROnOJlapztCuNZJ1SjpvC a/u59CIjgtYf/220ddVJnF4ELd6BkuoBOyZvQSAIBIEgEARGjoBHQdsjhd8caCrGWazNz9AfK1C5 z1Xx9APTHNzm9SpZAcYTM5qp3etqGciQ5LpDEoOjtFCHiVZ0DCfSZCyGNLnSxGyOVCESYo5vJVop UBQ0TpMz+nRZgzJwzgjoSrpKk/tMXh4m0Ge7lavpZpS05wLLVY7324DMMQgEgSAQBEaNgLcjFD2Z GDv+FF1Ba/I7RYqct20CMc4eZSdoKb1VKdGtyK/xMWTcI0udaJdfUZ9Iugt1elEth77hXnDzMldV ljWg657BXOOV4+nyUl7+VY4X7iAFW1gEGpZ3QL+CjebANRrM/k7KWxAIAkEgCASB7UDABOz2ZJVe /cll8oIXoSx6cVuwB2sSbARbCZG+ZKf1vM6al3wQNAH9bvoVEdbcfYSMnBSYXPGEaYY2f1YZT0nq +LS5u5AvGzpUgq7UyvQmCL2OjKZced69fLpUoOw6NWq5XjUl70EgCASBIBAERoNAHYQlQjRVmY/E ViJCN+FCcLr0OCjZgyfMXF0CDdQWR8AE5zedwp4071baNdV2Ijig5MYTJZVmbMoheIyU24xpQiZd kkx3ommbRwCVA+EuNxvjGVddVqAyqz2SryO1FI0dNdVTqiBrRbj/2NH9+qpc3oNAEAgCQSAIjAIB 2E1EV71EZvTQy0o/qilShAgZQrDE4eXiWdLn6kU7PPCpmrkES5uplZ/R1GJH+luhaeYJ88f0JGWv cXpnXWe8ZmQ0K8lH0tlNyXOOdb4gG7xoR1eWCbXT4WlKyouNbKfIetU8JFSChZ0pX8L6t0cMYzvQ Dxzy7cDIIQgEgSAQBLYBgWmIzp6ovEW8UHu+MqSuVNV2/DVH2zxJa+s/BMyCOkJ0IsEpDd7CG4Zq zbISYiCVRTtZLfSOB12bmkWAyqriTYbK5qOnPtH8rD8I3J6vB4FpwJb1YwbeM94x3jIHZUZaJGwZ ES+eOLbWhwnItsowkKs+THDNKyEIBIEgEASCwOgRmJ32ln54jaI8kRmUCfW5BZjrjqOYEsRiFtOa QuTVMXSNHLwmMcVrXpLOp+RGs9oU3qfTRcK1SVlCYktPFaIjuGvm9tKWXTzEDHmzjaBHTOP1yht2 CZC5CnKfr1KZV1y3TsQukSrqabLWClisxUXpU8z51R+1Ym1pPzMwf0pxPHhg1wc/+EFdJwSBIBAE gkAQGC0Cs157WcQ3I+LDY5yeFsHiWYqgIMLanyqjRG7Vi6TfVs298iSZvwvz0fyMR6rZvSZkMx1s J9J0E7PEvAgGDE+cLt2Xi0y3bZm9Ym3V5aUnWeRDfyZPu8jO4CZsUbjsFIHrv7I/y15Jj8KU7JiH 3FUCzeQ8TNgMinXRkLGIWWQMPTuSjAlBIAgEgSAQBEaMgPa4r54qnu5U2StSgqTk0bIQh8gRwoMc myvM+aIIzMs5Sg4yxaPUaC5dwHIiYeUz8XbrONuHVTJ9vvNiQvL4JSH0sG+vCVnnECV56cutLc40 K3ttSR3Rr8w2Vis7Q876d3+uNELeGtbd1yyNbdUmiL9Zi3sPjWPDd/391yGUEASCQBAIAkFgpAjI AxbJiokgSdZrxvNkgQx7pB1JwYqQHPwHJRMgysptULTiIUwnLBMofa1EWtQZtD60mpTxnimXwKwh UbDOGHgF0YocO1nSl8ur8nVQmDXKHpGuJOp61JLEiyeJo/4gXbx2rlofsAeRMeJLZSCaEASCQBAI AkFgOxAQ79LM3FGRSIlmaNNeHwk2wxbdf9qudBQjQ9QQL4OnzOSN1uTN2nPuE6+e6sm0R94mR8Nz I1+OdUUrqa0s3WmqRAxt05RMkE/epS3r7qzq4uFbqHyF3Cp17GXISRAIAkEgCASBISKgRtva5Owy RKI0EFdvUaRFpN4qcXKBZwxhQrwdmdnDrCTq8VKKbzRIS/HKgBdtwkURJKp3lycyNIkT63zSjz1k EJnLaZaHjCdelbqPV0ls1oDNbmJuBbtQ9FFCF9DjoL5hnYZ7OzhyCAJBIAgEgW1BgBFX/mftZ08R UtMwFFrpCqLFK6VPtzbjLjIamnQLVI8ZwqQJGg+YAVn2NM18EtKxTQVys3CnGXKEwmtaJXN7vIrz vF7LVUvovqVvt451brZhR30gaA8I1WbyW7OJtq03bdsUjzMtZbaxaVJMQhAIAkEgCASBkSIwba5S kSbfzrukbxWGhUMhVm9eoDm2jhdtVr8VBxXCFa1CvgR5mXisHsCl/CZGER5HZNGHIwoHQrLWrSvI mGD57lwWOY6pRExVIrSmaoZQQb6VVJ1kvfa45d7aLpXmPmgnk588DDiTHgS59BXHhCAQBIJAEAgC o0VALId3KzLUwCR7sj0SFkOJV0nTxF5TFZ4lJLnIKGeIUcRLs7EXzzBRSx5xtReb6PSODOeLCwyw 0lE6ppl6JDnykSaV1ut09LSX4yFancCZiicfK16xehee+TSeOfL6m1Gyz3TNfGF7wrSwk+6HimqX PXqpsF4KTQgCQSAIBIEgMGIExIHqXxWh4bV6dLIojD+IlMZkQvUomXokvkZWOw4tacS00xBx36xO iINRFZq3ijyk7bguvjrYy/GkNzLmaFkdnc3eKrKO9htLVeKV4wnzRyAd0eodc40nTFxLh4nRWUm8 Pmf0KbWWvAWBIBAEgkAQGA0CmoakgsRDdcUovGB5tiIvokVf8i4rITpOnu2MSBhvGeqikRqShvxM uGQS4VXZ6oHW3JKF99yPrFz2WFFQ6bPpxnudgUJRaMPM7b4mDl0cWWKDf2JqM3NHwyJlBljBufpH vU84mJr1gOA4XXk6kjU6MW9BIAgEgSAQBEaKwGxdB1pUBjNpecdKXXpnEQ51zroJufOS7S0rHqJk qUn3DWOu3Eko0M3VujS5SZ/jdDQ5d8RcB11JnvL4F9Fy7j8RuyiyL41zi1XypVmZdAgcr1t/XoyD 8js95mbOOznMw56OsVXPaj9k3nZiQiYhCASBIBAEgsAoEZA/C3kqdE2/PpUXKlfXpFe3Y2AThSoH RTqIUCHWRq4mNHSZcOXJSjOv/mDShFEV+orrRFReb56xZDrC5tiCR0ejv0WxYAhWUngXIF7oF1kC SR5xrWui6trSouPu2kJ5CwJBIAgEgSAwYgRm25QdM6KbaGmCFrHRSar/tvwjTiTkxiYIDLKCzaA4 SM0pDHxCHjl7pPQHVwL24C2lW87EV/Mi3EZQW03n4XpHpqqoKlROO7Gi1kqs5NefyuGxoNrhgjGm x8eOd3N3NYyVvmhSryO7yY9NCUEgCASBIBAERo9AG/NkomO8ssmX1bEcdIRM9cdykZxBphr3rNSu r5ZUkSWecD3WnCbhjt+Ir0FESDAf1jjWovYZZKwzTdFdDjrnOYAomo4JtqbT1/RyrH/YgIdORh3E 2oyYrg8ZiqLZ3J41mqTrVDe8JuQ9CASBIBAEgsCQEdD6FhCqaU0kJxozOZ4QaWlA0+KcCKzrTxXh +gwi9EIWeMFYV8nOU486fiXOOyVB2orjnH5YHOIaT56qV5241kEz8YzeOqfZcbU8yVb314txsDCI R0zLPh4DrBfvW+caHaa3GZ+bdClPBjTS9gpePZu78smXEASCQBAIAkFgxAiIouo0JB/VB2u6EgvX KUfVmtrnKqKEvPRa0HJSbD8IWfOG91kX36iEiIMKMXJkkNSCSBYi7O8Dti8rGQ+ylmqalj26mmKU jxekbCdVR5qN5yiOwWHI+oFAEXoYWOSBgDJty3IzNcTNQwVmUgepQIPzoxh7EoJAEAgCQSAIbAcC OJFiJ0/sEZfhFVYvFbKC5iAv7XGvC1GzCBoPFlKcWdI5g6Z0TlNu68uVZCW4Pm4jj5uJFWei7Cc+ ziHJWrA4E5YUoevd/b2NkFUGMqyEiQ6VSFEKeljoTonzA0RNcF2aF11He0uns3TkS70SgkAQCAJB IAhsAwKzkBk+Is2zkBSsZU6UvwkN4rlOa5vARVhXq1khy+pT87i/im/9sNV2iFiecVWKKpO1m4l1 UWm+EjZTiSBYOLB6tFLnJmTFYIPS/XSgt8X5eo63jDdNHm9FqPyL8sYpx1OiZKOJXhWgTBLoA7a8 0vyQwDXlqL41pzInBIEgEASCQBAYMQKzYiwRlMhJ5AtRmQx1rklEOockISulQHaiLKYlwW0QtonW nN3y6tg1A1sZRAgLKi/X4u2uj7lS3wykCOlTcPVN1SxcHwJMpNgjgmXhDsVKDQPBdKb/eRtR85Hd 3rKKoSzPCVY6ZruvGZukw9VQPM8OyOFRJwSBIBAEgkAQ2A4E7GRCds2jlH9b+VDstHKUsK8hTAV7 kzCa5TrTubRGM5zTTIhKNln7WGXdbA0xE2d2JY+yWKeOvmpvIlDIX8pnWCykldnyI1ZZ1RnQYT0w NSOf/RDQbJBmCNnPBCeX0krLMQgEgSAQBILAsBHQSli1yRjP1rRHk6+bf+Xp2ovsmnUhaV2zCCVk jec6A+lVJoPi1FRctzRUpHU00qUSkOzitLxpbezglawkY/7Um/3kyusdUUP+NDdLa9PPOXrkRreH heolK97N0IqHb/mTnZXV1Z+tPJ1qpXBebYN67TXrmBAEgkAQCAJBYNQI1LWq4Kvub2GBscb1us7R 1SrR8jghLw/G6tIY9QwJQ9akkWNKg628oYPi7VvqrQ6kglBF3WLCmt7Ij7wUrnfKsC60QclVJ+n1 QUB5u3MeFNBPmv11sawX2ECHCrEGsTF9zjV/jXMze2V9x7dSXFTegkAQCAJBIAiMEIHZbq8FN+tC kK0pF+Ja0iArfMgpvGSMsjdaPeJ6qdjOY7ZHqbWcK5nq4PwolLcsYlX7sV7qW5YITcj2XolXMD3K i/VQq4XjajWm/xlVlXyRqIKyQ/H0CIvSYfGOlEmH4CH++mBQ61GnQCFaB4DJ9q5MdE8xpDohCASB IBAEgsA2IKA9CM10lZg8ClkkBrcx31a8trTEaGhYj3eRsY409cKEojMTosQ1QHoeXkXSaRCcA0fr k2eNc61zBlaRES+avJzTmj1dTsiLVh+viHxR+uqoaJbFRAS7yCxShuflqZOnbqiAANaIfLtR0va8 5bK7TxobZDdN5BKkRKnh2BG7Y/IWBIJAEAgCQWB0CKgPGBLDs4TARIJ6c7MyRKe/aXuJImMx2ZRW xpoXyXnKDyQoBxJ5T1+Shztv8oOo+ZMeESmNxb62fmm0pwuJL2kqk1JMhJVIF+yOz0sfRCubbBz5 lU9yU3jY6FMampcgahEzNvBUgE487UVNl3IdeFigDP7ILz0LinMztUTTByzcEoJAEAgCQWBbEJg9 /tjDIikRngLv5jwRFaTVC5BYP2E5Cfe4SkBuJjgpoL/WecmgF5xIaFODlqbUrC3mNnEqvteHbHGV iy5lIl2pekGoImC5vaj09Cc1I7PCFte8zUvWzdxcKu98m59sB1dyNpUm6qqbfuiFOS23aUJXpoQg EASCQBAIAiNGYPbOO27tiE0lm9A48EfAa6zkXAlWfa4wKiQpcpyRVwzHtX5VMrV8MK8HVsHoBPf7 klU6OTcp6oiuTiceqaUhVOR0pQMFdIQrb1fN0IyOpvxqh8517bz07/IQQPM5mqwMXaiAsJWuC+Y2 H3v0kfLIw0dsWt6CQBAIAkEgCIwagdkf+Z5vMwm2gk2IEKGZD44zi/m48nzlNTqIa6/WlE18O1+Z xnXzXpsMx3be0teKW5AX26+z5euXb+ftSJ7777+/fHBfrRv2JQSBIBAEgkAQGCUCGx4GDMkNIqyl p5Fofxnrxa2lpz8/5yvlVtO5Mk+ug0AQCAJBIAgMG4ENE/BmDFlJeivzrpe+WtpapLmaLGWtFb/S jlwHgSAQBIJAENguBDZNwBslt9PJrZdO2mrpq8WtBdxqsv1x/edr6Uh8EAgCQSAIBIFhIbBpAm6G DILABqGj35619K0V3/LmGASCQBAIAkFg1AhMj4Kc1itjvbRBgtFfTjtvx0GWE11BIAgEgSAQBDaC wBl7wE35Rklso3JN72aOa+leK34zuiMbBIJAEAgCQWAYCGyZgDdj1HYQ4lplrhW/mfpENggEgSAQ BILAmSJwEgFvlZS2mn+jlaCc9cpaK22t+I2WG7kgEASCQBAIAoNC4CQCHpTSQek5HWGul75e2qDs i54gEASCQBAIAmeKwKoEvBXyOpO86+Uhbb30jVR8pY6t6ttImZEJAkEgCASBILAeAqsS8HoZNpO2 GaI7nexKEl1pR0s/nZ6V+XIdBIJAEAgCQWA7EFiXgAdBZpvR0Uh0mEBsxp5h2hHdQSAIBIEgsLsR mB3H6g+KJEdB6D385ufKsTlttTiwMFv2798zMG1RFASCQBAIAuOFwIYIeFCEOIyqb4Zkh1mPv33z t5dnfv+7B1bFqZlXlL984MbygnMGpjKKgkAQCAJBYIwQWLcJehh2boYwh1H+8HQOninj/w7vbkVz EAgCQWC7EdgUAQ/SgxykrpUgbpTkh2nDSptyHQSCQBAIAkGgH4FNEXDLuJ3EtVFybbZy3E57++3I eRAIAkEgCASBhsAZEXDLPAhiO1MdmyXiMy2n1TXHIBAEgkAQCAKDRGBLBDxIQ0alK0Q8KqRTThAI AkEgCKyHwMAIeLuJrZXfjutVmrSNyp1OT9KDQBAIAkEgCJwJAgMj4DMpPHmCQBAIAkEgCOxWBIZC wIPyLtHTXmdyg7aS90zKS54gEASCQBAIAhtFYCgETOGDIuFWkUHra3pzDAJBIAgEgSCwHQgMjYC3 ozKbLTOkvlnEIh8EgkAQCAKDQmAkBDzMpuCQ6KA+CtETBIJAEAgCo0RgJATcKjQsshyW3mZ3jkEg CASBIBAEBo3ASAl40Mavpe90hHy69LX0Jj4IBIEgEASCwKAQ2JEEPChwoicIBIEgEASCwLAQGAsC HoVHOooyhnWTojcIBIEgEAR2HgJjQcDACkG21zBhDhEPE93oDgJBIAgEgY0iMDYE3G9wSLIfjZwH gSAQBILATkRgLAkYoIdNwsPWvxM/LKlTEAgCQSAIDA6BsSXgwVUxmoJAEAgCQSAIjB8CE0fA8VzH 70MUi4JAEAgCQWDzCEwcAVNFSDhEvPmbnRxBIAgEgSAwPghMJAGvBl9IeTVUEhcEgkAQCALjisCO IeAGcL9nHFJuqOQYBIJAEAgC44bAjiPgcQM49gSBIBAEgkAQWA2BXUXA/d7xamAkLggEgSAQBILA qBDYVQQ8KlBTThAIAkEgCASB0yEQAj4dQkkPAkEgCASBIDAEBELAQwA1KoNAEAgCQSAInA6BEPDp EEp6EAgCQSAIBIEhIBACHgKoURkEgkAQCAJB4HQIhIBPh1DSg0AQCAJBIAgMAYEQ8BBAjcogEASC QBAIAqdDIAR8OoSSHgSCQBAIAkFgCAjsSgLOghxD+CRFZRAIAkEgCGwKgV1JwJtCKMJBIAgEgSAQ BIaAQAh4CKBGZRAIAkEgCASB0yEQAj4dQkkPAkEgCASBIDAEBELAQwA1KoNAEAgCQSAInA6BEPDp EEp6EAgCQSAIBIEhIDA7BJ27UuXc8S+UqampwdV9jjCUUAAAI85JREFU6UiZG5y2aAoCQSAIBIEx QyAEPKAbcs03/Uy58eoHyt69g1F44sTZ5Zr9g9EVLUEgCASBIDB+CISAB3RPLrj2BeXl1w5IWdQE gSAQBILAjkcgfcA7/hangkEgCASBIDCOCISAx/GuxKYgEASCQBDY8QiEgHf8LU4Fg0AQCAJBYBwR CAGP412JTUEgCASBILDjEQgB7/hbnAoGgSAQBILAOCIQAh7HuxKbgkAQCAJBYMcjEALe8bc4FQwC QSAIBIFxRCAEPI53JTYFgSAQBILAjkcgBLzjb3EqGASCQBAIAuOIQAh4HO9KbAoCQSAIBIEdj0AI eMff4lQwCASBIBAExhGBEPA43pXYFASCQBAIAjsegRDwjr/FqWAQCAJBIAiMIwIh4HG8K7EpCASB IBAEdjwCIeAdf4tTwSAQBIJAEBhHBELA43hXYlMQCAJBIAjseARCwDv+FqeCQSAIBIEgMI4IhIDH 8a7EpiAQBIJAENjxCISAd/wtTgWDQBAIAkFgHBEIAY/jXYlNQSAIBIEgsOMRCAHv+FucCgaBIBAE gsA4IhACHse7EpuCQBAIAkFgxyMQAt7xtzgVDAJBIAgEgXFEIAQ8jnclNgWBIBAEgsCORyAEvONv cSoYBIJAEAgC44hACHgc70psCgJBIAgEgR2PQAh4x9/iVDAIBIEgEATGEYEQ8DjeldgUBIJAEAgC Ox6BEPCOv8WpYBAIAkEgCIwjAiHgcbwrsSkIBIEgEAR2PAKzO76GqWAQ2AUIzM/Ply984QtlZmam HDp0aCQ1XlpacpkPPPBA2bdvX3nSk540knJTSBDYKQiEgHfKnUw9djUCDz30UPnpn/7pcu6555af +7mfGzoWi4uL5e1vf3v50z/903LfffeVpz71qeWNb3zj0MtNAUFgJyGQJuiddDdTl12JAJ7oww8/ XN70pjeV3/iN3xgJBocPHy6vf/3ry3/5L/+lfOITnyh44AlBIAhsDoF4wJvDK9JBYNcjgPf7f/7P /ym33HJLufrqq8u//bf/tjzlKU/Z9bgEgCCwWQRCwJtFLPJBIAiUO+64wyh80Rd9Ubn++uuDSBAI AmeAQAj4DEBLliAwzgjQJH3bbbeVm2++udx1113l4MGD5fLLLy9f8iVf4sFSq9lOnk996lMeVHX3 3Xe7L5nBXE984hPLOeec08vy6KOPlo985COWJfLYsWPl/e9/v+Wf/vSn9+Qee+yx8uEPf9jl00dM 3/Rll11Wnvvc5/q8J6gTykbH3NxcecELXlBOnDhR/vIv/7Lcc8895Ru+4RvKhRde2BN/8MEHy003 3VRoAqfsxz3uceXxj3+8PfGeUE6CwIQgEALe4o2a04/AePd+zZb9+/dssZbJPikILCwslL/4i78o v/Zrv1Y+9rGPldtvv72cf/755QlPeEL5xm/8xvLqV7+6XHHFFSdVB1L9gz/4g3LjjTeauD//+c+b 9K699trynOc8p3zXd32XSQ6ihJz/zb/5N5ZDCWVwjdxP/dRPmUz/7u/+rvzO7/xOee9731s+97nP Oc95551nHS95yUvKt3zLt5Qv/uIv7tmAzb/wC7/gwVz/7b/9t/Jbv/Vb5T3veY/JG70QcHtAIO0D H/iA9T7yyCN+QMDOl7/85eXrv/7rPQq8pzgnQWDMEQgBb+UGHf1w+fbLX1je/ejcVrQMNe/UzCvK Xz5wY3nBshMz1PKifHsRYDQ0hIj3+FVf9VUmXQiREct4maT/q3/1r3pERX/uW9/61vLzP//zhelE r3zlK8vXfu3Xlvvvv98eLCOb8aL/5b/8l/Y2zzrrrEKzM14qHvMll1ziawiegFf6H/7Df/CAMIjx m7/5m8ull15qEv7gBz/o/mLyUR5eOQFy/fM//3N73zw4/NIv/ZJ1fumXfqk9dtJvk0cPwf/2b/92 eelLX2q9e/bscVM4pPyhD33IA9F4wEgIApOCQAh4K3dKjuU5s+M/kDz+71Zu8mTlZTQyTb6QMM25 NB/jtdI8/MM//MPlP/7H/1he9rKXuSkYYqM59yd/8idNzExfwouEVGnqZaDVG97whvKf/tN/Kk9+ 8pPLP/kn/8Rk+qM/+qMebf0nf/InbtbmGjKEzJmWhDcL+WLDl33Zl9kDR99HP/pRk//b3va28sxn PrOQb2X41V/91fKDP/iD5Su/8ivLRRddZJLGQ37zm99c3vKWt5RXvepV5Z//839enva0p5XZ2dly 5513egAYDxU8LEDOF1988Uq1uQ4CY4nA+LPHWMIWo4LAeCIwNTVlgsLzhEhZIAPv9B/8g39QaP6F nH/v937PxkOYv/mbv+lmaojtu7/7u72IB14u/bXIf9/3fZ+J9dd//dfL8ePH7TlDjK1fGP1c08eL vl/8xV/0lCTK+6Zv+qZywQUXFGzi+BVf8RXlH/2jf2SP9z//5/9sb3klijw0QLAQ6bOf/Wx1n+wv t956qz1qyoS0X/jCFxaatM8++2wv/oGNEDoPE3/2Z3+2UmWug8DYIhACHttbE8OCwOYRwBOFfFcG yArPl/A3f/M3PkKY73znO02QNPeykhZNve3FSGcGYUGg5KEpe73AXOQ/+qM/KtPT0+Vbv/Vbna9f Hj14tgT6mSmvP5D+7d/+7SbrFo+XTtk0qV911VVOa/a1I971s571LBP7+973vpY1xyAw9gikCXrs b1EMDAIbR4B+VbzD1UJbKhLiIjD46jOf+YyJC6/4r/7qrxzf/0bzLwGypi/4as37XS1AlDQHI4c3 fM0115wiBsFiH4PC6IuG4K+77rqT5FbqRy+juQn0S7Pa18qADIuBENr0qJUyuQ4C44hACHgc70ps CgJDQIA+0/7AVKFGsJAxnuRq4du+7dvc9Mx0pvVCy48ca1KvFiBoCJPQjv1yNH+vDBAvgbytjJUy EDek3z8VaqVMroPAuCFw8jdy3KyLPUEgCGwKAbzUo0eP9vpo+zOTRmje6YEDBzyQiYFbNFszanqt gPdKE/B6Ac+WgHfLnF6aw/sDhEvTM+noYw7vRkIbVIV+lr8k72qBeOqUEAQmBYEQ8KTcqdgZBDaA AMTHNJ/nPe95J0lDfkz1ITC3lsAAJ0Y303xL/y4DmVYGFrxg6g+y63mXjVDxsvGmP/7xj3sQVb8+ bGBxDgKkuhECRm9b5pI5xQwsu/LKK/vV2jP+/d///ULT+pd/+ZeflJaLIDDOCGQQ1jjfndgWBDaJ ACT3y7/8y+XIkSO9nMQxkInFLWgeZnQyAXJ7zWte43MWzbj33nt93t6Y08vUn3/xL/6FF+po8Wsd GejFPGLKY9oQnnh/wPNlsQ8Co65P16SNHDayehYjuSF27ER/C5zzwPGv//W/Lj/2Yz92SplNLscg MI4IxAMex7sSm4LAGSKwd+9ej2xmtSs8WjxNBkcx95Ym6H/8j/+xRwyjntHKr33tay3PHF0Wx/jq r/5qrzwFgUPazBum6fd7v/d71+zXbabS7/tDP/RD5Y//+I/LDTfcYE+VKUOsZMUo5r/+67/2FCjm CKMPcj1dQAby/af/9J96MZD/+l//q6dWMTobb5uR1Izkxn7q0rz70+lNehAYBwRCwONwF2JDEBgQ AvTTMpXnV37lV3prQDMymCUpIT0WuWiDsSC3qzV46Sd+4icKxMZCHCykwRxgVsViIQ6m97B0JPNy TxfQx3QmFsTAC2chjuc///luNqYpmzWkWY+aebvPeMYzTqeulw6xv+51r7OHznaLP/7jP+6FOOhj ptmZQVro/IEf+IFV+757inISBMYMgRDwmN2QmBMENosAxIeX+rM/+7MmT1azYnoP2wUy6AmvEC+S ecBtAFYrAy+YAViQ7ote9CLLs1gHxIw3/FUamAWp4lm3QHn0Mf+7f/fvvGRki+cIKX7P93yPB2yx oUIbFMaiGtj14he/2HOBKbcFCJbBVazt3JanbGntiH0/8iM/Up761Kf6wQCvnhHcLO7B4h3MLz7d ILGmK8cgMC4ITKmpqdeh0vpWGO5PaNcc26vF918T15+nTTVoMhxXxjV5ji1tvWN/2so8q11TJl9Q 0gjtnGtGffKEz/qxrPBzxuGxD5fvuuzF5S1Hjp+ximFnZC3oD2ot6OdmLehhQz12+umDZXAVTcCs VgVxrheYlsSylUz1YdAVzdgb6addSyfl0/TMAh2UzwCqfiJfK9968Xyv8Xixk+8yc57ZtSkhCEwi AvGAJ/GuxeYgsAEEWLqxLRm5AfHespV4y4MImy1/I2XyEAGZ80oIApOOwHI70KTXJPYHgSAQBIJA EJggBELAE3SzYmoQCAJBIAjsHARCwDvnXqYmQSAIBIEgMEEIhIAn6GbF1CAQBIJAENg5CISAd869 TE2CQBAIAkFgghAIAU/QzYqpQSAIBIEgsHMQCAHvnHuZmgSBIBAEgsAEIRACnqCbFVODQBAIAkFg 5yAQAt459zI1CQJBIAgEgQlCIAQ8QTcrpgaBIBAEgsDOQSAEvHPuZWoSBIJAEAgCE4RACHiCblZM DQJBIAgEgZ2DQAh459zL1CQIBIEgEAQmCIEQ8ATdrJgaBIJAEAgCOweBEPDOuZepSRAIAkEgCEwQ AiHgCbpZMTUIBIEgEAR2DgIh4J1zL1OTIBAEgkAQmCAEQsATdLNiahAIAkEgCOwcBELAO+depiZB IAgEgSAwQQiEgCfoZsXUIBAEgkAQ2DkIhIB3zr1MTYJAEAgCQWCCEAgBT9DNiqlBIAgEgSCwcxAI Ae+ce5maBIEgEASCwAQhEAKeoJsVU4NAEAgCQWDnIBAC3jn3MjUJAkEgCASBCUIgBDxBNyumBoEg EASCwM5BYHbnVGUbajI3V75wfKFMTU1tQ+EbLHLpSJnboGjEgkAQCAJBYHQIhIC3gvU5Ty4/c+M7 yuGyV3/jGU6cOLtcs388bYtVQSAIBIHdjEAIeEt3/4Lygq9/+ZY0JHMQCAJBIAjsTgTSB7w773tq HQSCQBAIAtuMQAh4m29Aig8CQSAIBIHdiUAIeHfe99Q6CASBIBAEthmBEPA234AUHwSCQBAIArsT gRDw7rzvqXUQCAJBIAhsMwIh4G2+ASk+CASBIBAEdicCIeDded9T6yAQBIJAENhmBELA23wDUnwQ CAJBIAjsTgRCwLvzvqfWQSAIBIEgsM0IhIC3+Qak+CAQBIJAENidCISAd+d9T62DQBAIAkFgmxEI AW/zDUjxQSAIBIEgsDsRCAHvzvueWgeBIBAEgsA2IxAC3uYbkOKDQBAIAkFgdyIQAt6d9z21DgJB IAgEgW1GIAS8zTcgxQeBIBAEgsDuRCAEvDvve2odBIJAEAgC24xACHibb0CKDwJBIAgEgd2JQAh4 d9731DoIBIEgEAS2GYEQ8DbfgBQfBIJAEAgCuxOBEPDuvO+pdRAIAkEgCGwzAiHgbb4BKT4IBIEg EAR2JwIh4N1531PrIBAEgkAQ2GYEQsDbfANSfBAIAkEgCOxOBELAu/O+p9ZBIAgEgSCwzQiEgLf5 BqT4IBAEgkAQ2J0IhIB3531PrYNAEAgCQWCbEQgBb/MNSPFBIAgEgSCwOxEIAe/O+55aB4EgEASC wDYjEALe5huQ4oNAEAgCQWB3IhACHsJ9f+Cm95f3f/ILZW5pqSwNQX9U7l4ElvSZmjvyhfL+9/5u eff7PlQOH5srikoIAptEQL9NS3PlC5/8X+W9f3XnJvNGfFAIhIAHhWSfnlv/54+XFz39ULnk2S8t r//FG8qHbjkcMu7DJ6ebQ6CR7ofee0N5/d9/adl73qHyom98Vbn+a55XLj+wt7zy+99Yfvd/fSxk vDlYd6F0R7q3fKjc8IuvLy/df6AcevpXlp/+s8/tQizGo8qz42HGzrJiz1mPc4Ue+tiflJ/5Z7xK Oe+ZLyk/8H//w/Kt3/Q15ZnXXlpmp6bK1M6qdmozQAQg3fmjd5aP/fmflne89c3lZ97yJ2tqf/eb fqLwIrzie3+ifOd3vrJ8xfOfVi7dt6foY5awqxGAdOfLnZ/5WPnT339HefP/+3PlT47Pn4TIRfqc JGwPAiHgEeEeMh4R0BNczGZId61qhozXQmY3xZ+edHcTGuNc1xDwNtydkPE2gD6mRTbS/ZA83fec xtPdbBVCxptFbJLlG+l+SJ7ue1b1dCe5djvV9hDwNt/ZkPE234BtKH6YpLtWdULGayEzyfEh3Um+ e9geAh6jOxgyHqObMWBTtoN016pCyHgtZCYhPqQ7CXdpozaGgDeK1IjlQsYjBnwIxY0T6a5VvZDx WsiMU3xId5zuxiBtCQEPEs0h6QoZDwnYIaidBNJdq9oh47WQ2Y74kO52oD7qMkPAo0Z8i+WFjLcI 4BCyTzLprgVHyHgtZIYZH9IdJrrjqDsEPI53ZYM29ZNxmX5J+bGfzzzjDUK3ZbGdSLprgRIyXguZ QcSHdAeB4qTqCAFP6p1baffi8qIfIeOV4AzmejeR7lqIhYzXQmYz8SHdzaC1k2VDwDvx7oaMB3ZX Q7prQxkyXhubU1NCuqdikpgQ8E7/DISMN32HQ7qbhsxLYULIBC+H+Soth/ni3b4cZke6N2lxjPdo cYw3nLoMpAHL265FIAS8m259yHjNux3SXROaTSec4hnvKjIO6W76A7OLM4SAd+vNDxlrkfq64cEw loHcrR+rlfXeHWQc0l1533O9MQRCwBvDaWdL7SIyDulu30d5Z5FxSHf7Pkk7p+QQ8M65l4OpyQ4k 45DuYD4ag9QymWQc0h3kZyC6shZ0PgPrIbAqGX+V9jO+cuz3Mw7prndjxyttvMk4pDten5adZc30 zqpOajM0BEzGryvPe9Khsnf2peX1v3hD+dAtXxhacWeqeO7IF8r733tDef3ff2nZe96h8qJvfN26 m9mfaTnJNxwEIONXfc2zyuUH9pZXfv8by+++72Pl8LG54RS2Aa03/Ozry0v3HyiHnv6i8rof/ZlT NrPfgIqIBIE1EUgT9JrQJGFNBPo840cffXRNse1IOCDSTdgZCPR7xtv1OYN0E4LAsBAIAQ8L2V2i 98CBA7ukpqnmdiKQz9l2op+yh4VAmqCHhWz0BoEgEASCQBBYB4EQ8DrgJCkIBIEgEASCwLAQCAEP C9noDQJBIAgEgSCwDgIh4HXASVIQCAJBIAgEgWEhEAIeFrLRGwSCQBAIAkFgHQRCwOuAk6QgEASC QBAIAsNCIAQ8LGSjNwgEgSAQBILAOgj8/+3dPagm1RkH8LmwRZpNkcLCJoFtrBQESZqkkBRXUySF pIjapIhYxCKddinsUtjFBAwoYhEIqbKVElJIGgWxkMAiaVJIICy7QgpZ9+bO3XvcsyfvzP3wPTPv 87y/F9z5ODPn4/cM+Wfe/bgCeAZHEwECBAgQ6CUggHvJ6pcAAQIECMwICOAZHE0ECBAgQKCXgADu JatfAgQIECAwIyCAZ3A0ESBAgACBXgICuJesfgkQIECAwIyAAJ7B0USAAAECBHoJCOBesvolQIAA AQIzAgJ4BkcTAQIECBDoJSCAe8nqlwABAgQIzAgI4BkcTQQIECBAoJeAAO4lq18CBAgQIDAjIIBn cDQRIECAAIFeAgK4l6x+CRAgQIDAjIAAnsHRRIAAAQIEegkI4F6y+iVAgAABAjMCAngGRxMBAgQI EOglIIB7yeqXAAECBAjMCAjgGRxNBAgQIECgl4AA7iWrXwIECBAgMCMggGdwNBEgQIAAgV4CAriX rH4JECBAgMCMgACewdFEgAABAgR6CQjgXrL6JUCAAAECMwICeAZHEwECBAgQ6CUggHvJ6pcAAQIE CMwICOAZHE0ECBAgQKCXgADuJatfAgQIECAwIyCAZ3A0ESBAgACBXgICuJesfgkQIECAwIyAAJ7B 0USAAAECBHoJCOBesvolQIAAAQIzAldm2jQROFPg4ODgzGuWvODo6GjJ4Yy1kMBaz5nnaaEC7+kw AnhPC7+dZR8M169f305XW+rl6aefHvyP5pYwd6SbMXzXes6eeuqpHVEwjYwCAjhjVbuu6WC499L7 6PDcyz8fDg8Pu4520c6vv/3a8M4bvx7e/uvNk1uF8UUFd+P68sb76I9/Mbz47E+Pn7MnV5lYmcfx /6sbfLeySglSD+r3gFOXd1uLG0N3/O+x4flXXhuuf3BjuPXFR8Nbr760rQG21s/hz14a3nrvP8Ot f30yjGH8/JPfOp37bn1VvrUFJ+ro3jN2MDz2kxeG3/7x3eGfn90aPvrz68MLz6wTviPt3S9uDZ/8 /frw2ivPf/UceZISPXQrL0UAr1yA3R1+OnQPH782XN3x706uPvzIIIx39+kqM5sL3W8/dLVctt72 ytXhke8eDi+9+pYwXq8KaUcWwGlLe5mFxQ7dqRUL4ymZdc4/GLp/e+BNdydCd4pFGE/JOH9JAQF8 Sbg8t+UM3an6COMpmb7n/z90/3v69fL3h50O3SkWYTwl4/wFBATwBbDyXLpfoTtVN2E8JbOd8/Oh +43tDLILvQjjXahCyDkI4JBlu8ykhe6cmjCe0zl/296E7hRJE8Y3/AGuKSnnjwUEcOrHQOheprzC +GJqex+6U1zHYXyt+gNcwngKan/PC+B0tRe62yypMN6sKXQ3u0yeFcaTNPvcIIBTVP9+6L5w/Pd0 363+nm6EvzIUpQT7HsZCd0tPqjDeEmT8bgRw2BpuDt3Xj/9xjCcD/D3dsOynE9+XMBa6nZ9UYdwZ eLe7F8C7XZ9mdkK3AdmJw2xhLHRXeqyE8Urw6w0rgNezP+fIQvecUDtxWdQwFro78fjcn4Qwvm+R eE8A72Rxhe5OluWCk9r1MBa6FyzoWpcL47Xku48rgLsTn3cAoXteqYjXPRjGN1b7QRFCN+LTU825 DeMP/KCISifcrgBetWRCd1X+lQa/+vC1+z8o4rP+YSx0Vyp072HHMH78/g+KuCGMe4tvvX8BvHXS szoUumcJ7VP71Yf6hLHQ3aen6HitwjhkwQXwImUTuoswBx/k64ax0A3+AGxr+sJ4W5Ld+xHAXYg/ P+5V6Hah3ZNOzxvGQndPHojLLvMcYXz7sn2772sLHNy+ffuo9HJ0dG/37t27J6fK8bgt/40NZb+0 j+fqe8b9+ppxvz1Xrh+3pW1uW7e192w6Hsf88ssvv5pX2R+vvXPnznDz5s3hww8/HN58881x+lv9 /OOdXw0vf/Cd4ZfP/Wh44tHd/+H1W128zroKfP7vT4f33/3L8M4bfxg+/ub3hheffXY4/METxz/S L9FPF+oqqPMTgTufD59+/P7wp9//brj1w98Mrz5zDcwKAgK4QwCvUEdDEiBAgEAwAV9BByuY6RIg QIBADgEBnKOOVkGAAAECwQQEcLCCmS4BAgQI5BAQwDnqaBUECBAgEExAAAcrmOkSIECAQA4BAZyj jlZBgAABAsEEBHCwgpkuAQIECOQQEMA56mgVBAgQIBBMQAAHK5jpEiBAgEAOAQGco45WQYAAAQLB BARwsIKZLgECBAjkEBDAOepoFQQIECAQTEAAByuY6RIgQIBADgEBnKOOVkGAAAECwQQEcLCCmS4B AgQI5BAQwDnqaBUECBAgEExAAAcrmOkSIECAQA4BAZyjjlZBgAABAsEEBHCwgpkuAQIECOQQEMA5 6mgVBAgQIBBMQAAHK5jpEiBAgEAOAQGco45WQYAAAQLBBARwsIKZLgECBAjkEBDAOepoFQQIECAQ TEAAByuY6RIgQIBADgEBnKOOVkGAAAECwQQEcLCCmS4BAgQI5BAQwDnqaBUECBAgEExAAAcrmOkS IECAQA4BAZyjjlZBgAABAsEEBHCwgpkuAQIECOQQEMA56mgVBAgQIBBMQAAHK5jpEiBAgEAOAQGc o45WQYAAAQLBBARwsIKZLgECBAjkEBDAOepoFQQIECAQTEAAByuY6RIgQIBADgEBnKOOVkGAAAEC wQQEcLCCmS4BAgQI5BAQwDnqaBUECBAgEExAAAcrmOkSIECAQA4BAZyjjlZBgAABAsEEBHCwgpku AQIECOQQEMA56mgVBAgQIBBMQAAHK5jpEiBAgEAOAQGco45WQYAAAQLBBARwsIKZLgECBAjkEBDA OepoFQQIECAQTEAAByuY6RIgQIBADgEBnKOOVkGAAAECwQQEcLCCmS4BAgQI5BAQwDnqaBUECBAg EExAAAcrmOkSIECAQA4BAZyjjlZBgAABAsEEBHCwgpkuAQIECOQQEMA56mgVBAgQIBBMQAAHK5jp EiBAgEAOAQGco45WQYAAAQLBBARwsIKZLgECBAjkEBDAOepoFQQIECAQTEAAByuY6RIgQIBADgEB nKOOVkGAAAECwQQEcLCCmS4BAgQI5BAQwDnqaBUECBAgEExAAAcrmOkSIECAQA4BAZyjjlZBgAAB AsEEBHCwgpkuAQIECOQQEMA56mgVBAgQIBBMQAAHK5jpEiBAgEAOAQGco45WQYAAAQLBBARwsIKZ LgECBAjkEBDAOepoFQQIECAQTEAAByuY6RIgQIBADgEBnKOOVkGAAAECwQQEcLCCmS4BAgQI5BAQ wDnqaBUECBAgEExAAAcrmOkSIECAQA4BAZyjjlZBgAABAsEEBHCwgpkuAQIECOQQEMA56mgVBAgQ IBBMQAAHK5jpEiBAgEAOAQGco45WQYAAAQLBBARwsIKZLgECBAjkEBDAOepoFQQIECAQTEAAByuY 6RIgQIBADgEBnKOOVkGAAAECwQQEcLCCmS4BAgQI5BAQwDnqaBUECBAgEExAAAcrmOkSIECAQA4B AZyjjlZBgAABAsEEBHCwgpkuAQIECOQQEMA56mgVBAgQIBBMQAAHK5jpEiBAgEAOAQGco45WQYAA AQLBBK4cHR19NeWyv2k7nqvPl/3x5k1t5dzUtr6vvWaurVw7XtN+Slu9Ha+pj9v9tg/HBAgQIEBg CQFvwEsoG4MAAQIECDQCArgBcUiAAAECBJYQEMBLKBuDAAECBAg0AgK4AXFIgAABAgSWEBDASygb gwABAgQINAICuAFxSIAAAQIElhAQwEsoG4MAAQIECDQCArgBcUiAAAECBJYQEMBLKBuDAAECBAg0 AgK4AXFIgAABAgSWELj0P0U5Tm78Zx3Ltt1v/8nH+ri+pz4/t38yUPXLWdeO7fU49X5pq7qzS4AA AQIEFhXwBrwot8EIECBAgMA9AQHsSSBAgAABAisICOAV0A1JgAABAgQEsGeAAAECBAisICCAV0A3 JAECBAgQuNSfgh7Zyp9Cntov7e22vr5tG483tZ+cPP6lvn7TdVP3t/eVe0u/tgQIECBAYGkBb8BL ixuPAAECBAgcCwhgjwEBAgQIEFhBQACvgG5IAgQIECBw7t8Drqna31Mtx+M1ZX/T9iLt9XgXuW/T uOVc3U/Zb8dxTIAAAQIElhDwBryEsjEIECBAgEAjIIAbEIcECBAgQGAJAQG8hLIxCBAgQIBAI3Cu 3wMe79n0+6jjubm2ck97XX2+7J+3n7avqfumzpfxSj/jdT4ECBAgQGBpAW/AS4sbjwABAgQIHAsI YI8BAQIECBBYQWCxr6Drr37b/XHd9VfCdXtpK+fa43J+attePx6Pn/F6HwIECBAgsJaAN+C15I1L gAABAnstMPsGXGTqt8vx3NRx21a/Zdb31PtljKl762vb/fqeTfvtufZ47M+HAAECBAisIeANeA11 YxIgQIDA3gsI4L1/BAAQIECAwBoCG7+CLhMpX9HWX/2ObVPHc231PZfdb/vf1E99zbhff8bry6fc W45tCRAgQIDAkgLegJfUNhYBAgQIEDgV2PgGXN4U6239xlj22/axz9JW75dz9fZ0/JNNfb7st/fP HW9qa8+Vfst2bPchQIAAAQJrCXgDXkveuAQIECCw1wIPvAEXifEtcfzU2/rNsey37VP3tNeX6+rz 9f5Z7fW19f543/ipz4375VzZlvaTBr8QIECAAIEVBLoEcAm4elvW1p6rj6f2x3vrtvq49Fu25bpy TdmW8+223GdLgAABAgSWFPAV9JLaxiJAgAABAqcCV2qJ8e1w/GzaljfH0r7puG0r12zaTl07db70 0ba3x+W6dluuG7c+BAgQIEBgbQFvwGtXwPgECBAgsJcCD/we8PjWOH42bcsbZWnfdHxy8+n9pY/2 XLlv07btu/Sx6dq2rb637Jdte385P259CBAgQIDAGgLdA7gNvzY4N7WXcyNI2a/vq6Hq9rP2y31T fZV2WwIECBAg0FvAV9C9hfVPgAABAgQ2CPwPVlyoTedHOyUAAAAASUVORK5CYII= 326859 2017-11-13 22:44:01 -0800 2017-12-27 23:13:41 -0800 fix the algorithm of layout <mover>/<munder> when stretchy operators are present RenderMathMLUnderOver.cpp text/plain 2207 lambda ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0aE1M VW5kZXJPdmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0 aE1MVW5kZXJPdmVyLmNwcAppbmRleCA2NzYwMTZmZjBhMy4uYmViZmFlNjk2MTQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0aE1MVW5kZXJPdmVy LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0aG1sL1JlbmRlck1hdGhNTFVu ZGVyT3Zlci5jcHAKQEAgLTM2LDYgKzM2LDggQEAKICNpbmNsdWRlICJSZW5kZXJNYXRoTUxPcGVy YXRvci5oIgogI2luY2x1ZGUgPHd0Zi9Jc29NYWxsb2NJbmxpbmVzLmg+CiAKKyNpbmNsdWRlIDxp b3N0cmVhbT4KKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBXVEZfTUFLRV9JU09fQUxMT0NBVEVE X0lNUEwoUmVuZGVyTWF0aE1MVW5kZXJPdmVyKTsKQEAgLTUzLDcgKzU1LDggQEAgTWF0aE1MVW5k ZXJPdmVyRWxlbWVudCYgUmVuZGVyTWF0aE1MVW5kZXJPdmVyOjplbGVtZW50KCkgY29uc3QKIHZv aWQgUmVuZGVyTWF0aE1MVW5kZXJPdmVyOjpjb21wdXRlT3BlcmF0b3JzSG9yaXpvbnRhbFN0cmV0 Y2goKQogewogICAgIExheW91dFVuaXQgc3RyZXRjaFdpZHRoID0gMDsKLSAgICBWZWN0b3I8UmVu ZGVyTWF0aE1MT3BlcmF0b3IqLCAyPiByZW5kZXJPcGVyYXRvcnM7CisgICAgVmVjdG9yPFJlbmRl ck1hdGhNTE9wZXJhdG9yKiwgMj4gc3RyZXRjaGluZ09wZXJhdG9yczsKKyAgICBWZWN0b3I8UmVu ZGVyQm94KiwgMj4gc3RyZXRjaGluZ0Jsb2NrczsKIAogICAgIGZvciAoYXV0byogY2hpbGQgPSBm aXJzdENoaWxkQm94KCk7IGNoaWxkOyBjaGlsZCA9IGNoaWxkLT5uZXh0U2libGluZ0JveCgpKSB7 CiAgICAgICAgIGlmIChjaGlsZC0+bmVlZHNMYXlvdXQoKSkgewpAQCAtNjEsNyArNjQsMTAgQEAg dm9pZCBSZW5kZXJNYXRoTUxVbmRlck92ZXI6OmNvbXB1dGVPcGVyYXRvcnNIb3Jpem9udGFsU3Ry ZXRjaCgpCiAgICAgICAgICAgICAgICAgaWYgKGF1dG8gcmVuZGVyT3BlcmF0b3IgPSBkb3duY2Fz dDxSZW5kZXJNYXRoTUxCbG9jaz4oKmNoaWxkKS51bmVtYmVsbGlzaGVkT3BlcmF0b3IoKSkgewog ICAgICAgICAgICAgICAgICAgICBpZiAocmVuZGVyT3BlcmF0b3ItPmlzU3RyZXRjaHkoKSAmJiAh cmVuZGVyT3BlcmF0b3ItPmlzVmVydGljYWwoKSkgewogICAgICAgICAgICAgICAgICAgICAgICAg cmVuZGVyT3BlcmF0b3ItPnJlc2V0U3RyZXRjaFNpemUoKTsKLSAgICAgICAgICAgICAgICAgICAg ICAgIHJlbmRlck9wZXJhdG9ycy5hcHBlbmQocmVuZGVyT3BlcmF0b3IpOworICAgICAgICAgICAg ICAgICAgICAgICAgc3RyZXRjaGluZ09wZXJhdG9ycy5hcHBlbmQocmVuZGVyT3BlcmF0b3IpOwor ICAgICAgICAgICAgICAgICAgICAgICAgCisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoY2hp bGQgIT0gcmVuZGVyT3BlcmF0b3IpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RyZXRj aGluZ0Jsb2Nrcy5hcHBlbmQoY2hpbGQpOwogICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAg ICAgICAgICAgfQogICAgICAgICAgICAgfQpAQCAtNzUsOCArODEsMTQgQEAgdm9pZCBSZW5kZXJN YXRoTUxVbmRlck92ZXI6OmNvbXB1dGVPcGVyYXRvcnNIb3Jpem9udGFsU3RyZXRjaCgpCiAgICAg fQogCiAgICAgLy8gU2V0IHRoZSBzaXplcyBvZiAocG9zc2libHkgZW1iZWxsaXNoZWQpIHN0cmV0 Y2h5IG9wZXJhdG9yIGNoaWxkcmVuLgotICAgIGZvciAoYXV0byYgcmVuZGVyT3BlcmF0b3IgOiBy ZW5kZXJPcGVyYXRvcnMpCisgICAgZm9yIChhdXRvJiByZW5kZXJPcGVyYXRvciA6IHN0cmV0Y2hp bmdPcGVyYXRvcnMpCiAgICAgICAgIHJlbmRlck9wZXJhdG9yLT5zdHJldGNoVG8oc3RyZXRjaFdp ZHRoKTsKKyAgICAKKyAgICAvLyBVcGRhdGUgdGhlIGxheW91dHMgb2YgTWF0aE1MIGJsb2NrcyBj b250YWluaW5nIGVtYmVsbGlzaGVkIG9wZXJhdG9ycy4KKyAgICBmb3IgKGF1dG8qIHJlbmRlckJs b2NrIDogc3RyZXRjaGluZ0Jsb2NrcykgeworICAgICAgICByZW5kZXJCbG9jay0+c2V0TmVlZHNM YXlvdXQoKTsKKyAgICAgICAgcmVuZGVyQmxvY2stPmxheW91dCgpOworICAgIH0KIH0KIAogYm9v bCBSZW5kZXJNYXRoTUxVbmRlck92ZXI6OmlzVmFsaWQoKSBjb25zdAo= 326860 2017-11-13 22:51:08 -0800 2017-12-27 23:13:45 -0800 same patch, ignore the <iostream> RenderMathMLUnderOver.cpp text/plain 2018 lambda ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0aE1M VW5kZXJPdmVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0 aE1MVW5kZXJPdmVyLmNwcAppbmRleCA2NzYwMTZmZjBhMy4uMTIwMWJmNTQzYTIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0aE1MVW5kZXJPdmVy LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0aG1sL1JlbmRlck1hdGhNTFVu ZGVyT3Zlci5jcHAKQEAgLTUzLDcgKzUzLDggQEAgTWF0aE1MVW5kZXJPdmVyRWxlbWVudCYgUmVu ZGVyTWF0aE1MVW5kZXJPdmVyOjplbGVtZW50KCkgY29uc3QKIHZvaWQgUmVuZGVyTWF0aE1MVW5k ZXJPdmVyOjpjb21wdXRlT3BlcmF0b3JzSG9yaXpvbnRhbFN0cmV0Y2goKQogewogICAgIExheW91 dFVuaXQgc3RyZXRjaFdpZHRoID0gMDsKLSAgICBWZWN0b3I8UmVuZGVyTWF0aE1MT3BlcmF0b3Iq LCAyPiByZW5kZXJPcGVyYXRvcnM7CisgICAgVmVjdG9yPFJlbmRlck1hdGhNTE9wZXJhdG9yKiwg Mj4gc3RyZXRjaGluZ09wZXJhdG9yczsKKyAgICBWZWN0b3I8UmVuZGVyQm94KiwgMj4gc3RyZXRj aGluZ0Jsb2NrczsKIAogICAgIGZvciAoYXV0byogY2hpbGQgPSBmaXJzdENoaWxkQm94KCk7IGNo aWxkOyBjaGlsZCA9IGNoaWxkLT5uZXh0U2libGluZ0JveCgpKSB7CiAgICAgICAgIGlmIChjaGls ZC0+bmVlZHNMYXlvdXQoKSkgewpAQCAtNjEsNyArNjIsMTAgQEAgdm9pZCBSZW5kZXJNYXRoTUxV bmRlck92ZXI6OmNvbXB1dGVPcGVyYXRvcnNIb3Jpem9udGFsU3RyZXRjaCgpCiAgICAgICAgICAg ICAgICAgaWYgKGF1dG8gcmVuZGVyT3BlcmF0b3IgPSBkb3duY2FzdDxSZW5kZXJNYXRoTUxCbG9j az4oKmNoaWxkKS51bmVtYmVsbGlzaGVkT3BlcmF0b3IoKSkgewogICAgICAgICAgICAgICAgICAg ICBpZiAocmVuZGVyT3BlcmF0b3ItPmlzU3RyZXRjaHkoKSAmJiAhcmVuZGVyT3BlcmF0b3ItPmlz VmVydGljYWwoKSkgewogICAgICAgICAgICAgICAgICAgICAgICAgcmVuZGVyT3BlcmF0b3ItPnJl c2V0U3RyZXRjaFNpemUoKTsKLSAgICAgICAgICAgICAgICAgICAgICAgIHJlbmRlck9wZXJhdG9y cy5hcHBlbmQocmVuZGVyT3BlcmF0b3IpOworICAgICAgICAgICAgICAgICAgICAgICAgc3RyZXRj aGluZ09wZXJhdG9ycy5hcHBlbmQocmVuZGVyT3BlcmF0b3IpOworICAgICAgICAgICAgICAgICAg ICAgICAgCisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoY2hpbGQgIT0gcmVuZGVyT3BlcmF0 b3IpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RyZXRjaGluZ0Jsb2Nrcy5hcHBlbmQo Y2hpbGQpOwogICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgfQogICAgICAg ICAgICAgfQpAQCAtNzUsOCArNzksMTQgQEAgdm9pZCBSZW5kZXJNYXRoTUxVbmRlck92ZXI6OmNv bXB1dGVPcGVyYXRvcnNIb3Jpem9udGFsU3RyZXRjaCgpCiAgICAgfQogCiAgICAgLy8gU2V0IHRo ZSBzaXplcyBvZiAocG9zc2libHkgZW1iZWxsaXNoZWQpIHN0cmV0Y2h5IG9wZXJhdG9yIGNoaWxk cmVuLgotICAgIGZvciAoYXV0byYgcmVuZGVyT3BlcmF0b3IgOiByZW5kZXJPcGVyYXRvcnMpCisg ICAgZm9yIChhdXRvJiByZW5kZXJPcGVyYXRvciA6IHN0cmV0Y2hpbmdPcGVyYXRvcnMpCiAgICAg ICAgIHJlbmRlck9wZXJhdG9yLT5zdHJldGNoVG8oc3RyZXRjaFdpZHRoKTsKKyAgICAKKyAgICAv LyBVcGRhdGUgdGhlIGxheW91dHMgb2YgTWF0aE1MIGJsb2NrcyBjb250YWluaW5nIGVtYmVsbGlz aGVkIG9wZXJhdG9ycy4KKyAgICBmb3IgKGF1dG8qIHJlbmRlckJsb2NrIDogc3RyZXRjaGluZ0Js b2NrcykgeworICAgICAgICByZW5kZXJCbG9jay0+c2V0TmVlZHNMYXlvdXQoKTsKKyAgICAgICAg cmVuZGVyQmxvY2stPmxheW91dCgpOworICAgIH0KIH0KIAogYm9vbCBSZW5kZXJNYXRoTUxVbmRl ck92ZXI6OmlzVmFsaWQoKSBjb25zdAo= 330229 2017-12-27 23:13:53 -0800 2017-12-31 19:28:39 -0800 Patch bug-170272-20171228151351.patch text/plain 2746 lambda U3VidmVyc2lvbiBSZXZpc2lvbjogMjI2MjkyCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggYzY0ZjA1ODcxMWMwYWI0MGU4MTkw YjNmMWQ2ZDIyZDVkZDg5MDM0MS4uODQ5NDkyNDcyNjMyNDkwMmZjY2UyZDg1MWZiNGJlNWMwNDYx MjY5OSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3Rz L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDE3LTEyLTI3ICBNaW5zaGVuZyBMaXUgIDxs YW1iZGFAbGl1Lm1zPgorCisgICAgICAgIFBhaW50IDxtbz4gY29ycmVjdGx5LiAKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3MDI3MgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhIHJlZmVyZW5jZSB0 ZXN0IHRvIGNoZWNrIGlmIDxtbz4gaXMgcGFpbnRlZCBjb3JyZWN0bHkuCisKKyAgICAgICAgVGhl IGJ1ZyBpdHNlbGYgaXMgZml4ZWQgYXMgYSBwYXJ0IG9mIDE3OTY4Mi4KKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3OTY4MgorCisgICAgICAgICogbWF0 aG1sL3ByZXNlbnRhdGlvbi9tby1hcnJvdy1wYWludGVkLWNlbnRlci1leHBlY3RlZC5odG1sOiBB ZGRlZC4KKyAgICAgICAgKiBtYXRobWwvcHJlc2VudGF0aW9uL21vLWFycm93LXBhaW50ZWQtY2Vu dGVyLmh0bWw6IEFkZGVkLgorCiAyMDE3LTEyLTIyICBBbnRvaW5lIFF1aW50ICA8Z3Jhb3V0c0Bh cHBsZS5jb20+CiAKICAgICAgICAgW1dlYiBBbmltYXRpb25zXSBJbXBsZW1lbnQgRWxlbWVudC5h bmltYXRlKCkKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL21hdGhtbC9wcmVzZW50YXRpb24vbW8t YXJyb3ctcGFpbnRlZC1jZW50ZXItZXhwZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL21hdGhtbC9w cmVzZW50YXRpb24vbW8tYXJyb3ctcGFpbnRlZC1jZW50ZXItZXhwZWN0ZWQuaHRtbApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi5iYzA1NmU4YTU4ZGU2Y2Q1M2MwNzk3NmQ1MjY3OWYzNjYwNGFhZmNlCi0tLSAvZGV2L251 bGwKKysrIGIvTGF5b3V0VGVzdHMvbWF0aG1sL3ByZXNlbnRhdGlvbi9tby1hcnJvdy1wYWludGVk LWNlbnRlci1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsMjMgQEAKKzwhRE9DVFlQRSBodG1sPgor PGhlYWQ+CisgIDx0aXRsZT4mbHQ7bW8mZ3Q7IGFycm93IHBhaW50ZWQgY2VudGVyPC90aXRsZT4K KyAgPG1ldGEgY2hhcnNldD0idXRmLTgiPgorPC9oZWFkPgorPGJvZHk+CisgIDxwPlRoZSB0ZXN0 IHBhc3NlcyBpZiB0aGUgYXJyb3cgaGFzIGEgbGVmdCBzcGFjZSBvZiAxMDBweC48L3A+CisKKyAg PG1hdGg+CisgICAgPG1zcGFjZSB3aWR0aD0iMTAwcHgiPjwvbXNwYWNlPgorICAgIDxtbyBsc3Bh Y2U9IjBweCIgcnNwYWNlPSIwcHgiPuKGkjwvbW8+CisgIDwvbWF0aD4KKworICA8cD5UaGUgcmVk IGJhciBpcyBvZiAxMDBweC48L3A+CisgIDxtYXRoPgorICAgIDxtc3BhY2Ugd2lkdGg9IjEwMHB4 IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0icmVkIj48L21zcGFj ZT4KKyAgPC9tYXRoPgorCisgIDxwPlRoZSBibHVlIGJhciBpcyBvZiAyMDBweC48L3A+CisgIDxt YXRoPgorICAgIDxtc3BhY2Ugd2lkdGg9IjIwMHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4 IiBtYXRoYmFja2dyb3VuZD0iYmx1ZSI+PC9tc3BhY2U+CisgIDwvbWF0aD4KKzwvYm9keT4KZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL21hdGhtbC9wcmVzZW50YXRpb24vbW8tYXJyb3ctcGFpbnRl ZC1jZW50ZXIuaHRtbCBiL0xheW91dFRlc3RzL21hdGhtbC9wcmVzZW50YXRpb24vbW8tYXJyb3ct cGFpbnRlZC1jZW50ZXIuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43NWM2MWFmODViMDI0Mjc5ZWEzZjY4Mzlh ZTExZWU4OThlYzUxMjdmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvbWF0aG1sL3By ZXNlbnRhdGlvbi9tby1hcnJvdy1wYWludGVkLWNlbnRlci5odG1sCkBAIC0wLDAgKzEsMjIgQEAK KzwhRE9DVFlQRSBodG1sPgorPGhlYWQ+CisgIDx0aXRsZT4mbHQ7bW8mZ3Q7IGFycm93IHBhaW50 ZWQgY2VudGVyPC90aXRsZT4KKyAgPG1ldGEgY2hhcnNldD0idXRmLTgiPgorPC9oZWFkPgorPGJv ZHk+CisgIDxwPlRoZSB0ZXN0IHBhc3NlcyBpZiB0aGUgYXJyb3cgaGFzIGEgbGVmdCBzcGFjZSBv ZiAxMDBweC48L3A+CisKKyAgPG1hdGg+CisgICAgPG1vIGxzcGFjZT0iMTAwcHgiIHJzcGFjZT0i MTAwcHgiPuKGkjwvbW8+CisgIDwvbWF0aD4KKworICA8cD5UaGUgcmVkIGJhciBpcyBvZiAxMDBw eC48L3A+CisgIDxtYXRoPgorICAgIDxtc3BhY2Ugd2lkdGg9IjEwMHB4IiBoZWlnaHQ9IjEwcHgi IGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0icmVkIj48L21zcGFjZT4KKyAgPC9tYXRoPgor CisgIDxwPlRoZSBibHVlIGJhciBpcyBvZiAyMDBweC48L3A+CisgIDxtYXRoPgorICAgIDxtc3Bh Y2Ugd2lkdGg9IjIwMHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3Vu ZD0iYmx1ZSI+PC9tc3BhY2U+CisgIDwvbWF0aD4KKzwvYm9keT4KXCBObyBuZXdsaW5lIGF0IGVu ZCBvZiBmaWxlCg== 330272 2017-12-31 19:28:49 -0800 2018-01-03 09:16:27 -0800 Patch bug-170272-20180101112847.patch text/plain 2859 lambda U3VidmVyc2lvbiBSZXZpc2lvbjogMjI2MzE0CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggM2FlZmZmNTg0NjczNmM3Y2RiMWVk Y2UzNzBkNzZhNmVkZDRjNmZmOS4uYjEzY2FlOTQzZmU1YTk4NDY2Y2M3NjEwNjgwZmRjNzNmZTVi OGY0MSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3Rz L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDE4LTAxLTAxICBNaW5zaGVuZyBMaXUgIDxs YW1iZGFAbGl1Lm1zPgorCisgICAgICAgIFBhaW50IDxtbz4gY29ycmVjdGx5LiAKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3MDI3MgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhIHJlZmVyZW5jZSB0 ZXN0IHRvIGNoZWNrIGlmIDxtbz4gaXMgcGFpbnRlZCBjb3JyZWN0bHkuCisKKyAgICAgICAgVGhl IGJ1ZyBpdHNlbGYgaXMgZml4ZWQgYXMgYSBwYXJ0IG9mIDE3OTY4Mi4KKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3OTY4MgorCisgICAgICAgICogbWF0 aG1sL3ByZXNlbnRhdGlvbi9tby1hcnJvdy1wYWludGVkLWNlbnRlci1leHBlY3RlZC5odG1sOiBB ZGRlZC4KKyAgICAgICAgKiBtYXRobWwvcHJlc2VudGF0aW9uL21vLWFycm93LXBhaW50ZWQtY2Vu dGVyLmh0bWw6IEFkZGVkLgorCiAyMDE3LTEyLTI4ICBaYWxhbiBCdWp0YXMgIDx6YWxhbkBhcHBs ZS5jb20+CiAKICAgICAgICAgUmVuZGVyVHJlZVVwZGF0ZXI6OkdlbmVyYXRlZENvbnRlbnQgc2hv dWxkIGhvbGQgYSB3ZWFrIHJlZmVyZW5jZSB0byBSZW5kZXJRdW90ZS4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL21hdGhtbC9wcmVzZW50YXRpb24vbW8tYXJyb3ctcGFpbnRlZC1jZW50ZXItZXhw ZWN0ZWQuaHRtbCBiL0xheW91dFRlc3RzL21hdGhtbC9wcmVzZW50YXRpb24vbW8tYXJyb3ctcGFp bnRlZC1jZW50ZXItZXhwZWN0ZWQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5iYjdlMTVkMzhiMDZmNDc5Njc1 Y2Q1YWZlZTNlMGE1NzZkYTY4ODU3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvbWF0 aG1sL3ByZXNlbnRhdGlvbi9tby1hcnJvdy1wYWludGVkLWNlbnRlci1leHBlY3RlZC5odG1sCkBA IC0wLDAgKzEsMjUgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+CisgIDxoZWFkPgorICAgIDx0 aXRsZT4mbHQ7bW8mZ3Q7IGFycm93IHBhaW50ZWQgY2VudGVyPC90aXRsZT4KKyAgICA8bWV0YSBj aGFyc2V0PSJ1dGYtOCI+CisgIDwvaGVhZD4KKyAgPGJvZHk+CisgICAgPHA+VGhlIHRlc3QgcGFz c2VzIGlmIHRoZSBhcnJvdyBoYXMgYSBsZWZ0IHNwYWNlIG9mIDEwMHB4LjwvcD4KKworICAgIDxt YXRoPgorICAgICAgPG1zcGFjZSB3aWR0aD0iMTAwcHgiPjwvbXNwYWNlPgorICAgICAgPG1vIGxz cGFjZT0iMHB4IiByc3BhY2U9IjBweCI+4oaSPC9tbz4KKyAgICA8L21hdGg+CisKKyAgICA8cD5U aGUgcmVkIGJhciBpcyBvZiAxMDBweC48L3A+CisgICAgPG1hdGg+CisgICAgICA8bXNwYWNlIHdp ZHRoPSIxMDBweCIgaGVpZ2h0PSIxMHB4IiBkZXB0aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9InJl ZCI+PC9tc3BhY2U+CisgICAgPC9tYXRoPgorCisgICAgPHA+VGhlIGJsdWUgYmFyIGlzIG9mIDIw MHB4LjwvcD4KKyAgICA8bWF0aD4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjIwMHB4IiBoZWlnaHQ9 IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0iYmx1ZSI+PC9tc3BhY2U+CisgICAg PC9tYXRoPgorICA8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9tYXRo bWwvcHJlc2VudGF0aW9uL21vLWFycm93LXBhaW50ZWQtY2VudGVyLmh0bWwgYi9MYXlvdXRUZXN0 cy9tYXRobWwvcHJlc2VudGF0aW9uL21vLWFycm93LXBhaW50ZWQtY2VudGVyLmh0bWwKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMC4uOGE1MWU0Nzc5ZTEyODFkNDk1YjRiYjIwOGFmZTY2ZThmODY4MzZjZgotLS0gL2Rldi9u dWxsCisrKyBiL0xheW91dFRlc3RzL21hdGhtbC9wcmVzZW50YXRpb24vbW8tYXJyb3ctcGFpbnRl ZC1jZW50ZXIuaHRtbApAQCAtMCwwICsxLDI0IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgor ICA8aGVhZD4KKyAgICA8dGl0bGU+Jmx0O21vJmd0OyBhcnJvdyBwYWludGVkIGNlbnRlcjwvdGl0 bGU+CisgICAgPG1ldGEgY2hhcnNldD0idXRmLTgiPgorICA8L2hlYWQ+CisgIDxib2R5PgorICAg IDxwPlRoZSB0ZXN0IHBhc3NlcyBpZiB0aGUgYXJyb3cgaGFzIGEgbGVmdCBzcGFjZSBvZiAxMDBw eC48L3A+CisKKyAgICA8bWF0aD4KKyAgICAgIDxtbyBsc3BhY2U9IjEwMHB4IiByc3BhY2U9IjEw MHB4Ij7ihpI8L21vPgorICAgIDwvbWF0aD4KKworICAgIDxwPlRoZSByZWQgYmFyIGlzIG9mIDEw MHB4LjwvcD4KKyAgICA8bWF0aD4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjEwMHB4IiBoZWlnaHQ9 IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0icmVkIj48L21zcGFjZT4KKyAgICA8 L21hdGg+CisKKyAgICA8cD5UaGUgYmx1ZSBiYXIgaXMgb2YgMjAwcHguPC9wPgorICAgIDxtYXRo PgorICAgICAgPG1zcGFjZSB3aWR0aD0iMjAwcHgiIGhlaWdodD0iMTBweCIgZGVwdGg9IjEwcHgi IG1hdGhiYWNrZ3JvdW5kPSJibHVlIj48L21zcGFjZT4KKyAgICA8L21hdGg+CisgIDwvYm9keT4K KzwvaHRtbD4K 330392 2018-01-03 09:16:45 -0800 2018-01-03 18:59:10 -0800 Patch bug-170272-20180104011642.patch text/plain 8020 lambda U3VidmVyc2lvbiBSZXZpc2lvbjogMjI2MzU4CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggYjQ0ZDViMDFkMWM2ZDQwYWUxOGRh ZWEyNzYyOWJjMzRhNmNjYTUyMC4uOGFkYzc3MWY2OWIwMTYyNTcyNzE2ZWVhYTc4OWJlM2NmOTNh MWJlMCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3Rz L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDE4LTAxLTAzICBNaW5zaGVuZyBMaXUgIDxs YW1iZGFAbGl1Lm1zPgorCisgICAgICAgIEFkZCBhIHRlc3QgdG8gZW5zdXJlIDxtbz4gcGFpbnRz IGl0cyBsZWFkaW5nIGFuZCB0cmFpbGluZyBzcGFjZSBhcyBzcGVjaWZpZWQgaW4gaXRzIGF0dHJp YnV0ZXMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NzAyNzIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBB IHJlZmVyZW5jZSB0ZXN0IGlzIGFkZGVkIHRvIGVuc3VyZSA8bW8+IHBhaW50cyBpdHMgbGVhZGlu ZyBhbmQgdHJhaWxpbmcgc3BhY2UgYXMgc3BlY2lmaWVkIGluIGl0cyBhdHRyaWJ1dGVzLgorCisg ICAgICAgIFRoZSBidWcgaXRzZWxmIGlzIGZpeGVkIGFzIGEgcGFydCBvZiAxNzk2ODIuCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzk2ODIKKworICAg ICAgICAqIG1hdGhtbC9wcmVzZW50YXRpb24vbW8tcGFpbnQtbHNwYWNlLXJzcGFjZS1leHBlY3Rl ZC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBtYXRobWwvcHJlc2VudGF0aW9uL21vLXBhaW50LWxz cGFjZS1yc3BhY2UuaHRtbDogQWRkZWQuCisKIDIwMTgtMDEtMDMgIENhcmxvcyBHYXJjaWEgQ2Ft cG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIENyYXNoIGRlc3Ryb3lp bmcgV2ViQ29yZTo6RmlsZU1vbml0b3IKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL21hdGhtbC9w cmVzZW50YXRpb24vbW8tcGFpbnQtbHNwYWNlLXJzcGFjZS1leHBlY3RlZC5odG1sIGIvTGF5b3V0 VGVzdHMvbWF0aG1sL3ByZXNlbnRhdGlvbi9tby1wYWludC1sc3BhY2UtcnNwYWNlLWV4cGVjdGVk Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uZTNmNmEyM2NjZTg2MmQ3NGI3MWE3NTQ4YjgwMTk3ZTMyNTM0NWM3 YQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL21hdGhtbC9wcmVzZW50YXRpb24vbW8t cGFpbnQtbHNwYWNlLXJzcGFjZS1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsNzQgQEAKKzwhRE9D VFlQRSBodG1sPgorPGh0bWw+CisgIDxoZWFkPgorICAgIDx0aXRsZT4mbHQ7bW8mZ3Q7IHBhaW50 IGxzcGFjZSByc3BhY2U8L3RpdGxlPgorICAgIDxtZXRhIGNoYXJzZXQ9InV0Zi04Ij4KKyAgPC9o ZWFkPgorICA8Ym9keT4KKyAgICA8cD5UaGUgdGVzdCBwYXNzZXMgaWYgdGhlIGFycm93IGhhcyBh IGxlZnQgc3BhY2Ugb2YgMTAwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2Nr IHRvIHRoZSBsZWZ0LAorICAgICAgYW5kIGEgcmlnaHQgc3BhY2Ugb2YgMjAwcHgsIHdoaWNoIGlz IGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRoZSByaWdodC48L3A+CisKKyAgICA8bWF0 aD4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjEwMHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4 IiBtYXRoYmFja2dyb3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgICAgPG1zcGFjZSB3aWR0aD0i MTAwcHgiPjwvbXNwYWNlPgorICAgICAgPG1vIGxzcGFjZT0iMHB4IiByc3BhY2U9IjBweCI+4oaS PC9tbz4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjIwMHB4Ij48L21zcGFjZT4KKyAgICAgIDxtc3Bh Y2Ugd2lkdGg9IjIwMHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3Vu ZD0iYmxhY2siPjwvbXNwYWNlPgorICAgIDwvbWF0aD4KKworICAgIDxwPlRoZSB0ZXN0IHBhc3Nl cyBpZiB0aGUgYXJyb3cgaGFzIGEgbGVmdCBzcGFjZSBvZiA1MHB4LCB3aGljaCBpcyBhcyB3aWRl IGFzIHRoZSBibGFjayBibG9jayB0byB0aGUgbGVmdCwKKyAgICAgIGFuZCBhIHJpZ2h0IHNwYWNl IG9mIDE1MHB4LCB3aGljaCBpcyBhcyB3aWRlIGFzIHRoZSBibGFjayBibG9jayB0byB0aGUgcmln aHQuPC9wPgorCisgICAgPG1hdGg+CisgICAgICA8bXNwYWNlIHdpZHRoPSIxNTBweCIgaGVpZ2h0 PSIxMHB4IiBkZXB0aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAg ICAgIDxtc3BhY2Ugd2lkdGg9IjE1MHB4Ij48L21zcGFjZT4KKyAgICAgIDxtbyBsc3BhY2U9IjBw eCIgcnNwYWNlPSIwcHgiPuKGkjwvbW8+CisgICAgICA8bXNwYWNlIHdpZHRoPSIxNTBweCI+PC9t c3BhY2U+CisgICAgICA8bXNwYWNlIHdpZHRoPSIxNTBweCIgaGVpZ2h0PSIxMHB4IiBkZXB0aD0i MTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICA8L21hdGg+CisKKyAg ICA8cD5UaGUgdGVzdCBwYXNzZXMgaWYgdGhlIGFycm93IGhhcyBhIGxlZnQgc3BhY2Ugb2YgMjAw cHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRoZSBsZWZ0LAorICAg ICAgYW5kIGEgcmlnaHQgc3BhY2Ugb2YgMTAwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJs YWNrIGJsb2NrIHRvIHRoZSByaWdodC48L3A+CisKKyAgICA8bWF0aD4KKyAgICAgIDw8bXNwYWNl IHdpZHRoPSIyMDBweCIgaGVpZ2h0PSIxMHB4IiBkZXB0aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9 ImJsYWNrIj48L21zcGFjZT4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjIwMHB4Ij48L21zcGFjZT4K KyAgICAgIDxtbyBsc3BhY2U9IjBweCIgcnNwYWNlPSIwcHgiPuKGkjwvbW8+CisgICAgICA8bXNw YWNlIHdpZHRoPSIxMDBweCI+PC9tc3BhY2U+CisgICAgICA8bXNwYWNlIHdpZHRoPSIxMDBweCIg aGVpZ2h0PSIxMHB4IiBkZXB0aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFj ZT4KKyAgICA8L21hdGg+CisKKyAgICA8cD5UaGUgdGVzdCBwYXNzZXMgaWYgdGhlIGFycm93IGhh cyBhIGxlZnQgc3BhY2Ugb2YgMTAwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJs b2NrIHRvIHRoZSBsZWZ0LAorICAgICAgYW5kIGEgcmlnaHQgc3BhY2Ugb2YgMjAwcHgsIHdoaWNo IGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRoZSByaWdodC48L3A+CisKKyAgICA8 bWF0aCBkaXI9InJ0bCI+CisgICAgICA8bXNwYWNlIHdpZHRoPSIxMDBweCIgaGVpZ2h0PSIxMHB4 IiBkZXB0aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICAgIDxt c3BhY2Ugd2lkdGg9IjEwMHB4Ij48L21zcGFjZT4KKyAgICAgIDxtbyBsc3BhY2U9IjBweCIgcnNw YWNlPSIwcHgiPuKGkjwvbW8+CisgICAgICA8bXNwYWNlIHdpZHRoPSIyMDBweCI+PC9tc3BhY2U+ CisgICAgICA8bXNwYWNlIHdpZHRoPSIyMDBweCIgaGVpZ2h0PSIxMHB4IiBkZXB0aD0iMTBweCIg bWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICA8L21hdGg+CisKKyAgICA8cD5U aGUgdGVzdCBwYXNzZXMgaWYgdGhlIGFycm93IGhhcyBhIGxlZnQgc3BhY2Ugb2YgNTBweCwgd2hp Y2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8gdGhlIGxlZnQsCisgICAgICBhbmQg YSByaWdodCBzcGFjZSBvZiAxNTBweCwgd2hpY2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxv Y2sgdG8gdGhlIHJpZ2h0LjwvcD4KKworICAgIDxtYXRoIGRpcj0icnRsIj4KKyAgICAgIDxtc3Bh Y2Ugd2lkdGg9IjE1MHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3Vu ZD0iYmxhY2siPjwvbXNwYWNlPgorICAgICAgPG1zcGFjZSB3aWR0aD0iMTUwcHgiPjwvbXNwYWNl PgorICAgICAgPG1vIGxzcGFjZT0iMHB4IiByc3BhY2U9IjBweCI+4oaSPC9tbz4KKyAgICAgIDxt c3BhY2Ugd2lkdGg9IjE1MHB4Ij48L21zcGFjZT4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjE1MHB4 IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0iYmxhY2siPjwvbXNw YWNlPgorICAgIDwvbWF0aD4KKworICAgIDxwPlRoZSB0ZXN0IHBhc3NlcyBpZiB0aGUgYXJyb3cg aGFzIGEgbGVmdCBzcGFjZSBvZiAyMDBweCwgd2hpY2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sg YmxvY2sgdG8gdGhlIGxlZnQsCisgICAgICBhbmQgYSByaWdodCBzcGFjZSBvZiAxMDBweCwgd2hp Y2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8gdGhlIHJpZ2h0LjwvcD4KKworICAg IDxtYXRoIGRpcj0icnRsIj4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjIwMHB4IiBoZWlnaHQ9IjEw cHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgICAg PG1zcGFjZSB3aWR0aD0iMjAwcHgiPjwvbXNwYWNlPgorICAgICAgPG1vIGxzcGFjZT0iMHB4IiBy c3BhY2U9IjBweCI+4oaSPC9tbz4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjEwMHB4Ij48L21zcGFj ZT4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjEwMHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4 IiBtYXRoYmFja2dyb3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgIDwvbWF0aD4KKyAgPC9ib2R5 PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbWF0aG1sL3ByZXNlbnRhdGlvbi9t by1wYWludC1sc3BhY2UtcnNwYWNlLmh0bWwgYi9MYXlvdXRUZXN0cy9tYXRobWwvcHJlc2VudGF0 aW9uL21vLXBhaW50LWxzcGFjZS1yc3BhY2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yZWM3MzllNzFkNDFm MGMzZTY5ODljMTQ0ZjhlN2ZhMmYwYWVmYjVmCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvbWF0aG1sL3ByZXNlbnRhdGlvbi9tby1wYWludC1sc3BhY2UtcnNwYWNlLmh0bWwKQEAgLTAs MCArMSw2MiBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKyAgPGhlYWQ+CisgICAgPHRpdGxl PiZsdDttbyZndDsgcGFpbnQgbHNwYWNlIHJzcGFjZTwvdGl0bGU+CisgICAgPG1ldGEgY2hhcnNl dD0idXRmLTgiPgorICA8L2hlYWQ+CisgIDxib2R5PgorICAgIDxwPlRoZSB0ZXN0IHBhc3NlcyBp ZiB0aGUgYXJyb3cgaGFzIGEgbGVmdCBzcGFjZSBvZiAxMDBweCwgd2hpY2ggaXMgYXMgd2lkZSBh cyB0aGUgYmxhY2sgYmxvY2sgdG8gdGhlIGxlZnQsCisgICAgICBhbmQgYSByaWdodCBzcGFjZSBv ZiAyMDBweCwgd2hpY2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8gdGhlIHJpZ2h0 LjwvcD4KKworICAgIDxtYXRoPgorICAgICAgPG1zcGFjZSB3aWR0aD0iMTAwcHgiIGhlaWdodD0i MTBweCIgZGVwdGg9IjEwcHgiIG1hdGhiYWNrZ3JvdW5kPSJibGFjayI+PC9tc3BhY2U+CisgICAg ICA8bW8gbHNwYWNlPSIxMDBweCIgcnNwYWNlPSIyMDBweCI+4oaSPC9tbz4KKyAgICAgIDxtc3Bh Y2Ugd2lkdGg9IjIwMHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3Vu ZD0iYmxhY2siPjwvbXNwYWNlPgorICAgIDwvbWF0aD4KKworICAgIDxwPlRoZSB0ZXN0IHBhc3Nl cyBpZiB0aGUgYXJyb3cgaGFzIGEgbGVmdCBzcGFjZSBvZiA1MHB4LCB3aGljaCBpcyBhcyB3aWRl IGFzIHRoZSBibGFjayBibG9jayB0byB0aGUgbGVmdCwKKyAgICAgIGFuZCBhIHJpZ2h0IHNwYWNl IG9mIDE1MHB4LCB3aGljaCBpcyBhcyB3aWRlIGFzIHRoZSBibGFjayBibG9jayB0byB0aGUgcmln aHQuPC9wPgorCisgICAgPG1hdGg+CisgICAgICA8bXNwYWNlIHdpZHRoPSIxNTBweCIgaGVpZ2h0 PSIxMHB4IiBkZXB0aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAg ICAgIDxtbyBsc3BhY2U9IjE1MHB4IiByc3BhY2U9IjE1MHB4Ij7ihpI8L21vPgorICAgICAgPG1z cGFjZSB3aWR0aD0iMTUwcHgiIGhlaWdodD0iMTBweCIgZGVwdGg9IjEwcHgiIG1hdGhiYWNrZ3Jv dW5kPSJibGFjayI+PC9tc3BhY2U+CisgICAgPC9tYXRoPgorCisgICAgPHA+VGhlIHRlc3QgcGFz c2VzIGlmIHRoZSBhcnJvdyBoYXMgYSBsZWZ0IHNwYWNlIG9mIDIwMHB4LCB3aGljaCBpcyBhcyB3 aWRlIGFzIHRoZSBibGFjayBibG9jayB0byB0aGUgbGVmdCwKKyAgICAgIGFuZCBhIHJpZ2h0IHNw YWNlIG9mIDEwMHB4LCB3aGljaCBpcyBhcyB3aWRlIGFzIHRoZSBibGFjayBibG9jayB0byB0aGUg cmlnaHQuPC9wPgorCisgICAgPG1hdGg+CisgICAgICA8PG1zcGFjZSB3aWR0aD0iMjAwcHgiIGhl aWdodD0iMTBweCIgZGVwdGg9IjEwcHgiIG1hdGhiYWNrZ3JvdW5kPSJibGFjayI+PC9tc3BhY2U+ CisgICAgICA8bW8gbHNwYWNlPSIyMDBweCIgcnNwYWNlPSIxMDBweCI+4oaSPC9tbz4KKyAgICAg IDxtc3BhY2Ugd2lkdGg9IjEwMHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFj a2dyb3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgIDwvbWF0aD4KKworICAgIDxwPlRoZSB0ZXN0 IHBhc3NlcyBpZiB0aGUgYXJyb3cgaGFzIGEgbGVmdCBzcGFjZSBvZiAxMDBweCwgd2hpY2ggaXMg YXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8gdGhlIGxlZnQsCisgICAgICBhbmQgYSByaWdo dCBzcGFjZSBvZiAyMDBweCwgd2hpY2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8g dGhlIHJpZ2h0LjwvcD4KKworICAgIDxtYXRoIGRpcj0icnRsIj4KKyAgICAgIDxtc3BhY2Ugd2lk dGg9IjEwMHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0iYmxh Y2siPjwvbXNwYWNlPgorICAgICAgPG1vIGxzcGFjZT0iMTAwcHgiIHJzcGFjZT0iMjAwcHgiPuKG kjwvbW8+CisgICAgICA8bXNwYWNlIHdpZHRoPSIyMDBweCIgaGVpZ2h0PSIxMHB4IiBkZXB0aD0i MTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICA8L21hdGg+CisKKyAg ICA8cD5UaGUgdGVzdCBwYXNzZXMgaWYgdGhlIGFycm93IGhhcyBhIGxlZnQgc3BhY2Ugb2YgNTBw eCwgd2hpY2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8gdGhlIGxlZnQsCisgICAg ICBhbmQgYSByaWdodCBzcGFjZSBvZiAxNTBweCwgd2hpY2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxh Y2sgYmxvY2sgdG8gdGhlIHJpZ2h0LjwvcD4KKworICAgIDxtYXRoIGRpcj0icnRsIj4KKyAgICAg IDxtc3BhY2Ugd2lkdGg9IjE1MHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFj a2dyb3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgICAgPG1vIGxzcGFjZT0iMTUwcHgiIHJzcGFj ZT0iMTUwcHgiPuKGkjwvbW8+CisgICAgICA8bXNwYWNlIHdpZHRoPSIxNTBweCIgaGVpZ2h0PSIx MHB4IiBkZXB0aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICA8 L21hdGg+CisKKyAgICA8cD5UaGUgdGVzdCBwYXNzZXMgaWYgdGhlIGFycm93IGhhcyBhIGxlZnQg c3BhY2Ugb2YgMjAwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRo ZSBsZWZ0LAorICAgICAgYW5kIGEgcmlnaHQgc3BhY2Ugb2YgMTAwcHgsIHdoaWNoIGlzIGFzIHdp ZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRoZSByaWdodC48L3A+CisKKyAgICA8bWF0aCBkaXI9 InJ0bCI+CisgICAgICA8bXNwYWNlIHdpZHRoPSIyMDBweCIgaGVpZ2h0PSIxMHB4IiBkZXB0aD0i MTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICAgIDxtbyBsc3BhY2U9 IjIwMHB4IiByc3BhY2U9IjEwMHB4Ij7ihpI8L21vPgorICAgICAgPG1zcGFjZSB3aWR0aD0iMTAw cHgiIGhlaWdodD0iMTBweCIgZGVwdGg9IjEwcHgiIG1hdGhiYWNrZ3JvdW5kPSJibGFjayI+PC9t c3BhY2U+CisgICAgPC9tYXRoPgorICA8L2JvZHk+Cis8L2h0bWw+Cg== 330429 2018-01-03 18:59:25 -0800 2018-01-04 01:48:55 -0800 Patch bug-170272-20180104105923.patch text/plain 8194 lambda U3VidmVyc2lvbiBSZXZpc2lvbjogMjI2MzU4CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggYjQ0ZDViMDFkMWM2ZDQwYWUxOGRh ZWEyNzYyOWJjMzRhNmNjYTUyMC4uOGFkYzc3MWY2OWIwMTYyNTcyNzE2ZWVhYTc4OWJlM2NmOTNh MWJlMCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3Rz L0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDE4LTAxLTAzICBNaW5zaGVuZyBMaXUgIDxs YW1iZGFAbGl1Lm1zPgorCisgICAgICAgIEFkZCBhIHRlc3QgdG8gZW5zdXJlIDxtbz4gcGFpbnRz IGl0cyBsZWFkaW5nIGFuZCB0cmFpbGluZyBzcGFjZSBhcyBzcGVjaWZpZWQgaW4gaXRzIGF0dHJp YnV0ZXMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x NzAyNzIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBB IHJlZmVyZW5jZSB0ZXN0IGlzIGFkZGVkIHRvIGVuc3VyZSA8bW8+IHBhaW50cyBpdHMgbGVhZGlu ZyBhbmQgdHJhaWxpbmcgc3BhY2UgYXMgc3BlY2lmaWVkIGluIGl0cyBhdHRyaWJ1dGVzLgorCisg ICAgICAgIFRoZSBidWcgaXRzZWxmIGlzIGZpeGVkIGFzIGEgcGFydCBvZiAxNzk2ODIuCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzk2ODIKKworICAg ICAgICAqIG1hdGhtbC9wcmVzZW50YXRpb24vbW8tcGFpbnQtbHNwYWNlLXJzcGFjZS1leHBlY3Rl ZC5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBtYXRobWwvcHJlc2VudGF0aW9uL21vLXBhaW50LWxz cGFjZS1yc3BhY2UuaHRtbDogQWRkZWQuCisKIDIwMTgtMDEtMDMgIENhcmxvcyBHYXJjaWEgQ2Ft cG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIENyYXNoIGRlc3Ryb3lp bmcgV2ViQ29yZTo6RmlsZU1vbml0b3IKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL21hdGhtbC9w cmVzZW50YXRpb24vbW8tcGFpbnQtbHNwYWNlLXJzcGFjZS1leHBlY3RlZC5odG1sIGIvTGF5b3V0 VGVzdHMvbWF0aG1sL3ByZXNlbnRhdGlvbi9tby1wYWludC1sc3BhY2UtcnNwYWNlLWV4cGVjdGVk Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uOGRiMDc1Yjk3YTg2Mjk0YjlkZWI2NTczN2NhMzgzMWY3OGQwMGNk ZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL21hdGhtbC9wcmVzZW50YXRpb24vbW8t cGFpbnQtbHNwYWNlLXJzcGFjZS1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsNzggQEAKKzwhRE9D VFlQRSBodG1sPgorPGh0bWw+CisgIDxoZWFkPgorICAgIDx0aXRsZT4mbHQ7bW8mZ3Q7IHBhaW50 IGxzcGFjZSByc3BhY2U8L3RpdGxlPgorICAgIDxtZXRhIGNoYXJzZXQ9InV0Zi04Ij4KKyAgPC9o ZWFkPgorICA8Ym9keT4KKyAgICA8aDE+TFRSIGNhc2U8L2gxPgorCisgICAgPHA+VGhlIHRlc3Qg cGFzc2VzIGlmIHRoZSBhcnJvdyBoYXMgYSBsZWFkaW5nIHNwYWNlIG9mIDEwMHB4LCB3aGljaCBp cyBhcyB3aWRlIGFzIHRoZSBibGFjayBibG9jayB0byB0aGUgbGVmdCwKKyAgICAgIGFuZCBhIHRy YWlsaW5nIHNwYWNlIG9mIDIwMHB4LCB3aGljaCBpcyBhcyB3aWRlIGFzIHRoZSBibGFjayBibG9j ayB0byB0aGUgcmlnaHQuPC9wPgorCisgICAgPG1hdGg+CisgICAgICA8bXNwYWNlIHdpZHRoPSIx MDBweCIgaGVpZ2h0PSIxMHB4IiBkZXB0aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48 L21zcGFjZT4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjEwMHB4Ij48L21zcGFjZT4KKyAgICAgIDxt byBsc3BhY2U9IjBweCIgcnNwYWNlPSIwcHgiPuKGkjwvbW8+CisgICAgICA8bXNwYWNlIHdpZHRo PSIyMDBweCI+PC9tc3BhY2U+CisgICAgICA8bXNwYWNlIHdpZHRoPSIyMDBweCIgaGVpZ2h0PSIx MHB4IiBkZXB0aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICA8 L21hdGg+CisKKyAgICA8cD5UaGUgdGVzdCBwYXNzZXMgaWYgdGhlIGFycm93IGhhcyBhIGxlYWRp bmcgc3BhY2Ugb2YgMTUwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRv IHRoZSBsZWZ0LAorICAgICAgYW5kIGEgdHJhaWxpbmcgc3BhY2Ugb2YgMTUwcHgsIHdoaWNoIGlz IGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRoZSByaWdodC48L3A+CisKKyAgICA8bWF0 aD4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjE1MHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4 IiBtYXRoYmFja2dyb3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgICAgPG1zcGFjZSB3aWR0aD0i MTUwcHgiPjwvbXNwYWNlPgorICAgICAgPG1vIGxzcGFjZT0iMHB4IiByc3BhY2U9IjBweCI+4oaS PC9tbz4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjE1MHB4Ij48L21zcGFjZT4KKyAgICAgIDxtc3Bh Y2Ugd2lkdGg9IjE1MHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3Vu ZD0iYmxhY2siPjwvbXNwYWNlPgorICAgIDwvbWF0aD4KKworICAgIDxwPlRoZSB0ZXN0IHBhc3Nl cyBpZiB0aGUgYXJyb3cgaGFzIGEgbGVhZGluZyBzcGFjZSBvZiAyMDBweCwgd2hpY2ggaXMgYXMg d2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8gdGhlIGxlZnQsCisgICAgICBhbmQgYSB0cmFpbGlu ZyBzcGFjZSBvZiAxMDBweCwgd2hpY2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8g dGhlIHJpZ2h0LjwvcD4KKworICAgIDxtYXRoPgorICAgICAgPG1zcGFjZSB3aWR0aD0iMjAwcHgi IGhlaWdodD0iMTBweCIgZGVwdGg9IjEwcHgiIG1hdGhiYWNrZ3JvdW5kPSJibGFjayI+PC9tc3Bh Y2U+CisgICAgICA8bXNwYWNlIHdpZHRoPSIyMDBweCI+PC9tc3BhY2U+CisgICAgICA8bW8gbHNw YWNlPSIwcHgiIHJzcGFjZT0iMHB4Ij7ihpI8L21vPgorICAgICAgPG1zcGFjZSB3aWR0aD0iMTAw cHgiPjwvbXNwYWNlPgorICAgICAgPG1zcGFjZSB3aWR0aD0iMTAwcHgiIGhlaWdodD0iMTBweCIg ZGVwdGg9IjEwcHgiIG1hdGhiYWNrZ3JvdW5kPSJibGFjayI+PC9tc3BhY2U+CisgICAgPC9tYXRo PgorCisgICAgPGgxPlJUTCBjYXNlPC9oMT4KKworICAgIDxwPlRoZSB0ZXN0IHBhc3NlcyBpZiB0 aGUgYXJyb3cgaGFzIGEgbGVhZGluZyBzcGFjZSBvZiAxMDBweCwgd2hpY2ggaXMgYXMgd2lkZSBh cyB0aGUgYmxhY2sgYmxvY2sgdG8gdGhlIHJpZ2h0LAorICAgICAgYW5kIGEgdHJhaWxpbmcgc3Bh Y2Ugb2YgMjAwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRoZSBs ZWZ0LjwvcD4KKworICAgIDxtYXRoIGRpcj0icnRsIj4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjEw MHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0iYmxhY2siPjwv bXNwYWNlPgorICAgICAgPG1zcGFjZSB3aWR0aD0iMTAwcHgiPjwvbXNwYWNlPgorICAgICAgPG1v IGxzcGFjZT0iMHB4IiByc3BhY2U9IjBweCI+4oaSPC9tbz4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9 IjIwMHB4Ij48L21zcGFjZT4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjIwMHB4IiBoZWlnaHQ9IjEw cHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgIDwv bWF0aD4KKworICAgIDxwPlRoZSB0ZXN0IHBhc3NlcyBpZiB0aGUgYXJyb3cgaGFzIGEgbGVhZGlu ZyBzcGFjZSBvZiAxNTBweCwgd2hpY2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8g dGhlIHJpZ2h0LAorICAgICAgYW5kIGEgdHJhaWxpbmcgc3BhY2Ugb2YgMTUwcHgsIHdoaWNoIGlz IGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRoZSBsZWZ0LjwvcD4KKworICAgIDxtYXRo IGRpcj0icnRsIj4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjE1MHB4IiBoZWlnaHQ9IjEwcHgiIGRl cHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgICAgPG1zcGFj ZSB3aWR0aD0iMTUwcHgiPjwvbXNwYWNlPgorICAgICAgPG1vIGxzcGFjZT0iMHB4IiByc3BhY2U9 IjBweCI+4oaSPC9tbz4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjE1MHB4Ij48L21zcGFjZT4KKyAg ICAgIDxtc3BhY2Ugd2lkdGg9IjE1MHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRo YmFja2dyb3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgIDwvbWF0aD4KKworICAgIDxwPlRoZSB0 ZXN0IHBhc3NlcyBpZiB0aGUgYXJyb3cgaGFzIGEgbGVhZGluZyBzcGFjZSBvZiAyMDBweCwgd2hp Y2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8gdGhlIHJpZ2h0LAorICAgICAgYW5k IGEgdHJhaWxpbmcgc3BhY2Ugb2YgMTAwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNr IGJsb2NrIHRvIHRoZSBsZWZ0LjwvcD4KKworICAgIDxtYXRoIGRpcj0icnRsIj4KKyAgICAgIDxt c3BhY2Ugd2lkdGg9IjIwMHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dy b3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgICAgPG1zcGFjZSB3aWR0aD0iMjAwcHgiPjwvbXNw YWNlPgorICAgICAgPG1vIGxzcGFjZT0iMHB4IiByc3BhY2U9IjBweCI+4oaSPC9tbz4KKyAgICAg IDxtc3BhY2Ugd2lkdGg9IjEwMHB4Ij48L21zcGFjZT4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjEw MHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0iYmxhY2siPjwv bXNwYWNlPgorICAgIDwvbWF0aD4KKyAgPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvbWF0aG1sL3ByZXNlbnRhdGlvbi9tby1wYWludC1sc3BhY2UtcnNwYWNlLmh0bWwg Yi9MYXlvdXRUZXN0cy9tYXRobWwvcHJlc2VudGF0aW9uL21vLXBhaW50LWxzcGFjZS1yc3BhY2Uu aHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi40NzYyM2Q0MThiYWFiODNjMjQyYTM5MzQxN2NiYzdjODAwNWM0Yzhj Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvbWF0aG1sL3ByZXNlbnRhdGlvbi9tby1w YWludC1sc3BhY2UtcnNwYWNlLmh0bWwKQEAgLTAsMCArMSw2NiBAQAorPCFET0NUWVBFIGh0bWw+ Cis8aHRtbD4KKyAgPGhlYWQ+CisgICAgPHRpdGxlPiZsdDttbyZndDsgcGFpbnQgbHNwYWNlIHJz cGFjZTwvdGl0bGU+CisgICAgPG1ldGEgY2hhcnNldD0idXRmLTgiPgorICA8L2hlYWQ+CisgIDxi b2R5PgorICAgIDxoMT5MVFIgY2FzZTwvaDE+CisKKyAgICA8cD5UaGUgdGVzdCBwYXNzZXMgaWYg dGhlIGFycm93IGhhcyBhIGxlYWRpbmcgc3BhY2Ugb2YgMTAwcHgsIHdoaWNoIGlzIGFzIHdpZGUg YXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRoZSBsZWZ0LAorICAgICAgYW5kIGEgdHJhaWxpbmcgc3Bh Y2Ugb2YgMjAwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRoZSBy aWdodC48L3A+CisKKyAgICA8bWF0aD4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjEwMHB4IiBoZWln aHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0iYmxhY2siPjwvbXNwYWNlPgor ICAgICAgPG1vIGxzcGFjZT0iMTAwcHgiIHJzcGFjZT0iMjAwcHgiPuKGkjwvbW8+CisgICAgICA8 bXNwYWNlIHdpZHRoPSIyMDBweCIgaGVpZ2h0PSIxMHB4IiBkZXB0aD0iMTBweCIgbWF0aGJhY2tn cm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICA8L21hdGg+CisKKyAgICA8cD5UaGUgdGVzdCBw YXNzZXMgaWYgdGhlIGFycm93IGhhcyBhIGxlYWRpbmcgc3BhY2Ugb2YgMTUwcHgsIHdoaWNoIGlz IGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRoZSBsZWZ0LAorICAgICAgYW5kIGEgdHJh aWxpbmcgc3BhY2Ugb2YgMTUwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2Nr IHRvIHRoZSByaWdodC48L3A+CisKKyAgICA8bWF0aD4KKyAgICAgIDxtc3BhY2Ugd2lkdGg9IjE1 MHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0iYmxhY2siPjwv bXNwYWNlPgorICAgICAgPG1vIGxzcGFjZT0iMTUwcHgiIHJzcGFjZT0iMTUwcHgiPuKGkjwvbW8+ CisgICAgICA8bXNwYWNlIHdpZHRoPSIxNTBweCIgaGVpZ2h0PSIxMHB4IiBkZXB0aD0iMTBweCIg bWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICA8L21hdGg+CisKKyAgICA8cD5U aGUgdGVzdCBwYXNzZXMgaWYgdGhlIGFycm93IGhhcyBhIGxlYWRpbmcgc3BhY2Ugb2YgMjAwcHgs IHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRoZSBsZWZ0LAorICAgICAg YW5kIGEgdHJhaWxpbmcgc3BhY2Ugb2YgMTAwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJs YWNrIGJsb2NrIHRvIHRoZSByaWdodC48L3A+CisKKyAgICA8bWF0aD4KKyAgICAgIDxtc3BhY2Ug d2lkdGg9IjIwMHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dyb3VuZD0i YmxhY2siPjwvbXNwYWNlPgorICAgICAgPG1vIGxzcGFjZT0iMjAwcHgiIHJzcGFjZT0iMTAwcHgi PuKGkjwvbW8+CisgICAgICA8bXNwYWNlIHdpZHRoPSIxMDBweCIgaGVpZ2h0PSIxMHB4IiBkZXB0 aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICA8L21hdGg+CisK KyAgICA8aDE+UlRMIGNhc2U8L2gxPgorCisgICAgPHA+VGhlIHRlc3QgcGFzc2VzIGlmIHRoZSBh cnJvdyBoYXMgYSBsZWFkaW5nIHNwYWNlIG9mIDEwMHB4LCB3aGljaCBpcyBhcyB3aWRlIGFzIHRo ZSBibGFjayBibG9jayB0byB0aGUgcmlnaHQsCisgICAgICBhbmQgYSB0cmFpbGluZyBzcGFjZSBv ZiAyMDBweCwgd2hpY2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8gdGhlIGxlZnQu PC9wPgorCisgICAgPG1hdGggZGlyPSJydGwiPgorICAgICAgPG1zcGFjZSB3aWR0aD0iMTAwcHgi IGhlaWdodD0iMTBweCIgZGVwdGg9IjEwcHgiIG1hdGhiYWNrZ3JvdW5kPSJibGFjayI+PC9tc3Bh Y2U+CisgICAgICA8bW8gbHNwYWNlPSIxMDBweCIgcnNwYWNlPSIyMDBweCI+4oaSPC9tbz4KKyAg ICAgIDxtc3BhY2Ugd2lkdGg9IjIwMHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRo YmFja2dyb3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgIDwvbWF0aD4KKworICAgIDxwPlRoZSB0 ZXN0IHBhc3NlcyBpZiB0aGUgYXJyb3cgaGFzIGEgbGVhZGluZyBzcGFjZSBvZiAxNTBweCwgd2hp Y2ggaXMgYXMgd2lkZSBhcyB0aGUgYmxhY2sgYmxvY2sgdG8gdGhlIHJpZ2h0LAorICAgICAgYW5k IGEgdHJhaWxpbmcgc3BhY2Ugb2YgMTUwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNr IGJsb2NrIHRvIHRoZSBsZWZ0LjwvcD4KKworICAgIDxtYXRoIGRpcj0icnRsIj4KKyAgICAgIDxt c3BhY2Ugd2lkdGg9IjE1MHB4IiBoZWlnaHQ9IjEwcHgiIGRlcHRoPSIxMHB4IiBtYXRoYmFja2dy b3VuZD0iYmxhY2siPjwvbXNwYWNlPgorICAgICAgPG1vIGxzcGFjZT0iMTUwcHgiIHJzcGFjZT0i MTUwcHgiPuKGkjwvbW8+CisgICAgICA8bXNwYWNlIHdpZHRoPSIxNTBweCIgaGVpZ2h0PSIxMHB4 IiBkZXB0aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICA8L21h dGg+CisKKyAgICA8cD5UaGUgdGVzdCBwYXNzZXMgaWYgdGhlIGFycm93IGhhcyBhIGxlYWRpbmcg c3BhY2Ugb2YgMjAwcHgsIHdoaWNoIGlzIGFzIHdpZGUgYXMgdGhlIGJsYWNrIGJsb2NrIHRvIHRo ZSByaWdodCwKKyAgICAgIGFuZCBhIHRyYWlsaW5nIHNwYWNlIG9mIDEwMHB4LCB3aGljaCBpcyBh cyB3aWRlIGFzIHRoZSBibGFjayBibG9jayB0byB0aGUgbGVmdC48L3A+CisKKyAgICA8bWF0aCBk aXI9InJ0bCI+CisgICAgICA8bXNwYWNlIHdpZHRoPSIyMDBweCIgaGVpZ2h0PSIxMHB4IiBkZXB0 aD0iMTBweCIgbWF0aGJhY2tncm91bmQ9ImJsYWNrIj48L21zcGFjZT4KKyAgICAgIDxtbyBsc3Bh Y2U9IjIwMHB4IiByc3BhY2U9IjEwMHB4Ij7ihpI8L21vPgorICAgICAgPG1zcGFjZSB3aWR0aD0i MTAwcHgiIGhlaWdodD0iMTBweCIgZGVwdGg9IjEwcHgiIG1hdGhiYWNrZ3JvdW5kPSJibGFjayI+ PC9tc3BhY2U+CisgICAgPC9tYXRoPgorICA8L2JvZHk+Cis8L2h0bWw+Cg==