233372 2021-11-19 09:26:47 -0800 Web Inspector: Add CSS variable names to property name completion list 2022-03-24 19:24:12 -0700 1 1 1 Unclassified WebKit Web Inspector WebKit Nightly Build All All RESOLVED FIXED InRadar P2 Normal --- 233369 1 rcaliman rcaliman deshnawysameh hi inspector-bugzilla-changes pangle webkit-bug-importer oldest_to_newest 1816892 0 rcaliman 2021-11-19 09:26:47 -0800 <rdar://83205968> 1816897 1 444827 rcaliman 2021-11-19 09:52:33 -0800 Created attachment 444827 Patch 1.0 Depends on Bug 233369 1816900 2 444829 rcaliman 2021-11-19 09:55:40 -0800 Created attachment 444829 Screenshot of variable autocompletion Behavior with patch applied. 1821206 3 444827 hi 2021-12-07 13:33:42 -0800 Comment on attachment 444827 Patch 1.0 View in context: https://bugs.webkit.org/attachment.cgi?id=444827&action=review > Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js:153 > + this._queryController.addValues(values); Should we use `this._values` instead since it's been sorted? > Source/WebInspectorUI/UserInterface/Models/CSSNameCompletions.js:52 > + this._cachedValues = values.slice(0); ditto (Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js:153) > Source/WebInspectorUI/UserInterface/Models/CSSNameCompletions.js:53 > + this._isStaleListOfCSSVariables = true; Why would we start out as stale? Perhaps we should reword this to something like `this._needsVariablesFromInspectedNode = true;` so it's more clear what it's used for. > Source/WebInspectorUI/UserInterface/Models/CSSNameCompletions.js:91 > + this.values = this._cachedValues.concat(variables); Is there a better way we can do this? `Array.prototype.concat` involves creating a copy of the entire array. See r249301 for more info. 1822306 4 444827 rcaliman 2021-12-09 13:21:44 -0800 Comment on attachment 444827 Patch 1.0 View in context: https://bugs.webkit.org/attachment.cgi?id=444827&action=review >> Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js:153 >> + this._queryController.addValues(values); > > Should we use `this._values` instead since it's been sorted? Doesn't really matter. `WI.CSSQueryController` will rank results based on match heuristics, not sort order. It doesn't sort the array again. >> Source/WebInspectorUI/UserInterface/Models/CSSNameCompletions.js:52 >> + this._cachedValues = values.slice(0); > > ditto (Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js:153) Done. Though, after concatenation with the list of variables, the resulting array will be sorted anyway when setting `this.values` so it doesn't really help that much. >> Source/WebInspectorUI/UserInterface/Models/CSSNameCompletions.js:53 >> + this._isStaleListOfCSSVariables = true; > > Why would we start out as stale? Perhaps we should reword this to something like `this._needsVariablesFromInspectedNode = true;` so it's more clear what it's used for. > Why would we start out as stale? To avoid doing potentially unnecessary work. `WI.CSSPropertyNameCompletions` gets instantiated in `WI.CSSManager.initializeCSSPropertyNameCompletions()`. At that point it's not guaranteed that the user has selected the desired node, nor has the intention to edit a CSS property name. We need to do the work to merge the CSS property names list with applicable CSS variables for the inspected node only when completions are requested (i.e. the user is typing). > Perhaps we should reword this to something like `this._needsVariablesFromInspectedNode = true;` so it's more clear what it's used for. Good idea. Done! >> Source/WebInspectorUI/UserInterface/Models/CSSNameCompletions.js:91 >> + this.values = this._cachedValues.concat(variables); > > Is there a better way we can do this? `Array.prototype.concat` involves creating a copy of the entire array. See r249301 for more info. Yes, we can push the cached original values onto the fresh `variables` array; no harm mutating that: ``` variables.pushAll(this._cachedValues) ``` I didn't know concat was slow. I _assume_ the spread operator suffers from the same, right? ``` [...variables, ...this._cachedVariables] ``` 1822307 5 446599 rcaliman 2021-12-09 13:22:36 -0800 Created attachment 446599 Patch 1.1 Address code review feedback: - update name of flag for indicating list of css variables is out of date - avoid copying arrays with Array.concat() Depends on Bug 233369 1822328 6 446599 pangle 2021-12-09 14:08:50 -0800 Comment on attachment 446599 Patch 1.1 View in context: https://bugs.webkit.org/attachment.cgi?id=446599&action=review > Source/WebInspectorUI/ChangeLog:18 > + be stale whenever the inspected node changes. Only when a query completions comes in do we check > + this flag and augment the list of CSS property names with the latest list of CSS variables. s/query completions/completion query Also, it might be worth rephrasing this since it initially would lead my to believe that only when executing a query do we rebuild a stale list of completions, but it appears we also do so for `startsWith`. Both of these are kinda like executing a query, but only the first one actually has it in the name. > Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js:150 > + if (this._queryController) { > + this._queryController.reset(); > + this._queryController.addValues(values); > + } Nit: This is probably better expressed as an early return. e.g. ``` if (!this._queryController) return; [rest of the code] ``` > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:47 > + WI.domManager.addEventListener(WI.DOMManager.Event.InspectedNodeChanged, this._handleInspectedNodeChanged, this); What about new variables that may be declared while editing the currently inspected DOM node. If I add a `--fancy-new-variable` to a rule for the inspected node, will that variable name also be included when I get completions for another new property in the node's style attribute? I suspect not currently, and the patch doesn't apply cleanly for me to check :( Probably need to set `this._needsVariablesFromInspectedNode = true` when `WI.DOMNodeStyles.Event.NeedsRefresh` is dispatched for the inspected DOM node's style. The `WI.DOMManager.Event.InspectedNodeChanged` event provides the previously inspected node, so it should be possible to hook up the event listener/tear it down below in `_handleInspectedNodeChanged`. 1822488 7 446599 hi 2021-12-09 19:32:48 -0800 Comment on attachment 446599 Patch 1.1 View in context: https://bugs.webkit.org/attachment.cgi?id=446599&action=review >> Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js:150 >> + } > > Nit: This is probably better expressed as an early return. e.g. > ``` > if (!this._queryController) > return; > > [rest of the code] > ``` you also could use `?.` for both and not have an `if` ``` this._queryController?.reset(); this._queryController?.addValues(values); ``` your choice :) > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:44 > + this._cachedSortedPropertyNames = this.values.slice(); Does this also need to be updated in `WI.CSSCompletions.prototype.addValues`? This approach of using `WI.CSSCompletions.prototype.set values` to override the result of `WI.CSSCompletions.prototype.get values` may quickly get out of sync if some other callsite were to call `WI.CSSCompletions.prototype.set values` with a new set of property names, which this would not have any knowledge of. Perhaps instead of adding a `WI.CSSCompletions.prototype.set values` we could instead make a protected `WI.CSSCompletions.prototype.get additionalValues` that's combined with `this._values` inside `WI.CSSCompletions.prototype.get values` and overridden by this class to return a cached list of CSS variable property names? > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:78 > + console.assert(nodeStyles instanceof WI.DOMNodeStyles, nodeStyles); I don't think this adds anything since `stylesForNode` is guaranteed to return a `WI.DOMNodeStyles` (and it'll even create one if it didn't have one yet). > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:81 > + console.assert(Array.isArray(variables), variables); this is redundant because `Array.from` is guaranteed to return an array 1822716 8 446599 rcaliman 2021-12-10 08:19:33 -0800 Comment on attachment 446599 Patch 1.1 View in context: https://bugs.webkit.org/attachment.cgi?id=446599&action=review >> Source/WebInspectorUI/ChangeLog:18 >> + this flag and augment the list of CSS property names with the latest list of CSS variables. > > s/query completions/completion query > > Also, it might be worth rephrasing this since it initially would lead my to believe that only when executing a query do we rebuild a stale list of completions, but it appears we also do so for `startsWith`. Both of these are kinda like executing a query, but only the first one actually has it in the name. Slight rewording to remove the ambiguity of when the list of matching variables is refreshed. >>> Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js:150 >>> + } >> >> Nit: This is probably better expressed as an early return. e.g. >> ``` >> if (!this._queryController) >> return; >> >> [rest of the code] >> ``` > > you also could use `?.` for both and not have an `if` > ``` > this._queryController?.reset(); > this._queryController?.addValues(values); > ``` > your choice :) Oooh, I like `?.` Done >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:44 >> + this._cachedSortedPropertyNames = this.values.slice(); > > Does this also need to be updated in `WI.CSSCompletions.prototype.addValues`? This approach of using `WI.CSSCompletions.prototype.set values` to override the result of `WI.CSSCompletions.prototype.get values` may quickly get out of sync if some other callsite were to call `WI.CSSCompletions.prototype.set values` with a new set of property names, which this would not have any knowledge of. Perhaps instead of adding a `WI.CSSCompletions.prototype.set values` we could instead make a protected `WI.CSSCompletions.prototype.get additionalValues` that's combined with `this._values` inside `WI.CSSCompletions.prototype.get values` and overridden by this class to return a cached list of CSS variable property names? I don't think this is an issue. There is at most only one instance of `WI.CSSPropertyNameCompletions` created in `WI.CSSManager.initializeCSSPropertyNameCompletions()` with the payload of supported CSS properties from the backend call. There is no outside change to this list of properties for the lifetime of the Web Inspector session. The reason for splitting and subclassing `WI.CSSPropertyNameCompletions` from `WI.CSSCompletions` is to be able to handle mutations to this list of values internally, like we do here by augmenting with applicable CSS variable names. `WI.CSSCompletions` shouldn't have to know or care how the list of values it is given was created. Since we don't update `WI.CSSPropertyNameCompletions.values` from the outside, I think this is safe from side-effects. >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:47 >> + WI.domManager.addEventListener(WI.DOMManager.Event.InspectedNodeChanged, this._handleInspectedNodeChanged, this); > > What about new variables that may be declared while editing the currently inspected DOM node. If I add a `--fancy-new-variable` to a rule for the inspected node, will that variable name also be included when I get completions for another new property in the node's style attribute? I suspect not currently, and the patch doesn't apply cleanly for me to check :( > Probably need to set `this._needsVariablesFromInspectedNode = true` when `WI.DOMNodeStyles.Event.NeedsRefresh` is dispatched for the inspected DOM node's style. The `WI.DOMManager.Event.InspectedNodeChanged` event provides the previously inspected node, so it should be possible to hook up the event listener/tear it down below in `_handleInspectedNodeChanged`. That use case did not work. Thank you for the suggestion! Done. The latest patch applies cleanly because it no longer depends on unlanded code. (Bug 233369 landed) >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:78 >> + console.assert(nodeStyles instanceof WI.DOMNodeStyles, nodeStyles); > > I don't think this adds anything since `stylesForNode` is guaranteed to return a `WI.DOMNodeStyles` (and it'll even create one if it didn't have one yet). Removed. >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:81 >> + console.assert(Array.isArray(variables), variables); > > this is redundant because `Array.from` is guaranteed to return an array Removed. 1822717 9 446735 rcaliman 2021-12-10 08:20:17 -0800 Created attachment 446735 Patch 1.2 Address code review feedback: - remove unnecessary asserts - refresh list of CSS variables when styles change - address nits & typos 1822774 10 446599 hi 2021-12-10 10:02:18 -0800 Comment on attachment 446599 Patch 1.1 View in context: https://bugs.webkit.org/attachment.cgi?id=446599&action=review >>> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:44 >>> + this._cachedSortedPropertyNames = this.values.slice(); >> >> Does this also need to be updated in `WI.CSSCompletions.prototype.addValues`? This approach of using `WI.CSSCompletions.prototype.set values` to override the result of `WI.CSSCompletions.prototype.get values` may quickly get out of sync if some other callsite were to call `WI.CSSCompletions.prototype.set values` with a new set of property names, which this would not have any knowledge of. Perhaps instead of adding a `WI.CSSCompletions.prototype.set values` we could instead make a protected `WI.CSSCompletions.prototype.get additionalValues` that's combined with `this._values` inside `WI.CSSCompletions.prototype.get values` and overridden by this class to return a cached list of CSS variable property names? > > I don't think this is an issue. There is at most only one instance of `WI.CSSPropertyNameCompletions` created in `WI.CSSManager.initializeCSSPropertyNameCompletions()` with the payload of supported CSS properties from the backend call. There is no outside change to this list of properties for the lifetime of the Web Inspector session. > > The reason for splitting and subclassing `WI.CSSPropertyNameCompletions` from `WI.CSSCompletions` is to be able to handle mutations to this list of values internally, like we do here by augmenting with applicable CSS variable names. > `WI.CSSCompletions` shouldn't have to know or care how the list of values it is given was created. > > Since we don't update `WI.CSSPropertyNameCompletions.values` from the outside, I think this is safe from side-effects. This may be the case right now, but a future engineer who looks at `WI.cssManager.propertyNameCompletions` and `WI.CSSCompletions` might think that they can add new things via `addValues` and/or `set values`, which would cause this hidden bug to surface. Also, you've put `set values` inside the "// Public" section so again future engineers will look at that and think it's allowed by anyone. I think if you want to do as you describe we need to rename `set values` to `updateValues` in "// Protected" (so that only subclasses are allowed call it) and override `addValues` to either throw an error or also add to `_cachedSortedPropertyNames` (or re-initialize `_cachedSortedPropertyNames` with the new `this.value`). 1822780 11 446735 hi 2021-12-10 10:15:16 -0800 Comment on attachment 446735 Patch 1.2 View in context: https://bugs.webkit.org/attachment.cgi?id=446735&action=review > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:59 > + if (this._needsVariablesFromInspectedNode) NIT: you could move this `if` inside `_updateValuesWithLatestCSSVariables` and rename the latter to `_updateValuesWithLatestCSSVariablesIfNeeded` to avoid having to have every callsite do this check > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:92 > + if (!event.data.lastInspectedNode?.id) I think you should really just check for `!event.data.lastInspectedNode` as I don't think it's possible for a `WI.DOMNode` to have a falsy `id`. > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:96 > + nodeStyles.removeEventListener(WI.DOMNodeStyles.Event.NeedsRefresh, this._handleNodesStylesNeedsRefresh, this); This could be problematic if the user changes the inspected node multiple times before `_updateValuesWithLatestCSSVariables` is called. I think you should add an early return if `this._needsVariablesFromInspectedNode` is already truthy as in that case we won't have added the event listener yet, meaning there's also no need to remove it. 1822886 12 446735 rcaliman 2021-12-10 12:29:35 -0800 Comment on attachment 446735 Patch 1.2 View in context: https://bugs.webkit.org/attachment.cgi?id=446735&action=review >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:59 >> + if (this._needsVariablesFromInspectedNode) > > NIT: you could move this `if` inside `_updateValuesWithLatestCSSVariables` and rename the latter to `_updateValuesWithLatestCSSVariablesIfNeeded` to avoid having to have every callsite do this check Done >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:92 >> + if (!event.data.lastInspectedNode?.id) > > I think you should really just check for `!event.data.lastInspectedNode` as I don't think it's possible for a `WI.DOMNode` to have a falsy `id`. Indeed, there is the case `lastInspectedNode` is `null` at start-up, but I didn't encounter a scenario where DOMNode exists without an id. >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:96 >> + nodeStyles.removeEventListener(WI.DOMNodeStyles.Event.NeedsRefresh, this._handleNodesStylesNeedsRefresh, this); > > This could be problematic if the user changes the inspected node multiple times before `_updateValuesWithLatestCSSVariables` is called. I think you should add an early return if `this._needsVariablesFromInspectedNode` is already truthy as in that case we won't have added the event listener yet, meaning there's also no need to remove it. Good catch. Done! 1822891 13 446599 rcaliman 2021-12-10 12:34:57 -0800 Comment on attachment 446599 Patch 1.1 View in context: https://bugs.webkit.org/attachment.cgi?id=446599&action=review >>>> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:44 >>>> + this._cachedSortedPropertyNames = this.values.slice(); >>> >>> Does this also need to be updated in `WI.CSSCompletions.prototype.addValues`? This approach of using `WI.CSSCompletions.prototype.set values` to override the result of `WI.CSSCompletions.prototype.get values` may quickly get out of sync if some other callsite were to call `WI.CSSCompletions.prototype.set values` with a new set of property names, which this would not have any knowledge of. Perhaps instead of adding a `WI.CSSCompletions.prototype.set values` we could instead make a protected `WI.CSSCompletions.prototype.get additionalValues` that's combined with `this._values` inside `WI.CSSCompletions.prototype.get values` and overridden by this class to return a cached list of CSS variable property names? >> >> I don't think this is an issue. There is at most only one instance of `WI.CSSPropertyNameCompletions` created in `WI.CSSManager.initializeCSSPropertyNameCompletions()` with the payload of supported CSS properties from the backend call. There is no outside change to this list of properties for the lifetime of the Web Inspector session. >> >> The reason for splitting and subclassing `WI.CSSPropertyNameCompletions` from `WI.CSSCompletions` is to be able to handle mutations to this list of values internally, like we do here by augmenting with applicable CSS variable names. >> `WI.CSSCompletions` shouldn't have to know or care how the list of values it is given was created. >> >> Since we don't update `WI.CSSPropertyNameCompletions.values` from the outside, I think this is safe from side-effects. > > This may be the case right now, but a future engineer who looks at `WI.cssManager.propertyNameCompletions` and `WI.CSSCompletions` might think that they can add new things via `addValues` and/or `set values`, which would cause this hidden bug to surface. Also, you've put `set values` inside the "// Public" section so again future engineers will look at that and think it's allowed by anyone. I think if you want to do as you describe we need to rename `set values` to `updateValues` in "// Protected" (so that only subclasses are allowed call it) and override `addValues` to either throw an error or also add to `_cachedSortedPropertyNames` (or re-initialize `_cachedSortedPropertyNames` with the new `this.value`). Ok, I replaced the public setter with a `WI.CSSCompletions.replaceValues()`. It's a bit of a "beware of dog" sign, but I guess it helps by requiring a more intentional reading than just setting a value. `WI.CSSPropertyNames.addValues()` will throw an error to prevent unintentional overwriting. Factoring in logic to clone or replace `_cachedSortedPropertyNames` feels premature. We don't have this use case yet. It can be done when necessary. 1822892 14 446782 rcaliman 2021-12-10 12:35:30 -0800 Created attachment 446782 Patch 1.3 Address code review 1822903 15 446782 hi 2021-12-10 12:46:00 -0800 Comment on attachment 446782 Patch 1.3 View in context: https://bugs.webkit.org/attachment.cgi?id=446782&action=review r=me, nice work! > Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js:179 > + console.assert(Array.isArray(values), values); NIT: Do we also want the other assertion in the `constructor` too? In fact, you could just call this in the `constructor` and avoid some repeated code :) > Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js:182 > + this._queryController?.reset(); Style: I'd add a newline before this > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:60 > + return super.executeQuery(query); Style: I'd add a newline before this > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:66 > + return super.startsWith(prefix); ditto (:60) > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:71 > + throw new Error("Adding values will overwrite the list of supported CSS property names"); NIT: I'd just make this into a `console.assert(false, "Adding values will overwrite the list of supported CSS property names")` so that this doesn't cause issues in production. You've already made sure it's not an issue by NOT calling `super.addValues(...)`. > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:91 > + let variables = Array.from(nodeStyles.allCSSVariables); > + let values = variables; NIT: I'd just do `let values = Array.from(nodeStyles.allCSSVariables);` and avoid the extra `variables` variable that's not used otherwise. > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:93 > + Style: I'd remove this newline > Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:95 > + this._needsVariablesFromInspectedNode = false; Style: I'd add a newline before this 1822912 16 446782 rcaliman 2021-12-10 12:58:53 -0800 Comment on attachment 446782 Patch 1.3 View in context: https://bugs.webkit.org/attachment.cgi?id=446782&action=review >> Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js:179 >> + console.assert(Array.isArray(values), values); > > NIT: Do we also want the other assertion in the `constructor` too? In fact, you could just call this in the `constructor` and avoid some repeated code :) Copied over the assertion. I'll avoid calling this in the constructor. That's a recipe for trouble when we add more stateful logic and the unwittingly run it by accident. >> Source/WebInspectorUI/UserInterface/Models/CSSCompletions.js:182 >> + this._queryController?.reset(); > > Style: I'd add a newline before this Done >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:60 >> + return super.executeQuery(query); > > Style: I'd add a newline before this Done >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:66 >> + return super.startsWith(prefix); > > ditto (:60) Done >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:71 >> + throw new Error("Adding values will overwrite the list of supported CSS property names"); > > NIT: I'd just make this into a `console.assert(false, "Adding values will overwrite the list of supported CSS property names")` so that this doesn't cause issues in production. You've already made sure it's not an issue by NOT calling `super.addValues(...)`. Good idea. >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:91 >> + let values = variables; > > NIT: I'd just do `let values = Array.from(nodeStyles.allCSSVariables);` and avoid the extra `variables` variable that's not used otherwise. Done. >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:93 >> + > > Style: I'd remove this newline Done. >> Source/WebInspectorUI/UserInterface/Models/CSSPropertyNameCompletions.js:95 >> + this._needsVariablesFromInspectedNode = false; > > Style: I'd add a newline before this Done 1822913 17 446788 rcaliman 2021-12-10 12:59:30 -0800 Created attachment 446788 Patch 1.4 Carry over R+; Address final nits 1823110 18 ews-feeder 2021-12-10 17:09:20 -0800 Committed r286890 (245118@main): <https://commits.webkit.org/245118@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 446788. 444827 2021-11-19 09:52:33 -0800 2021-12-09 13:22:32 -0800 Patch 1.0 bug-233372-20211119185232.patch text/plain 5257 rcaliman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi SW5zcGVjdG9yVUkvQ2hhbmdlTG9nCmluZGV4IGM2YjhmNjViYjY0MDFmNjNmNTJjNmYxMjc1MTQy MjM1ZjdhMzkwNmUuLjFhMDNlZjQ5MjRiMjFjYjJmNmY0YjM4NjFhN2JiMWE2YTVlYzBiODkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl Ykluc3BlY3RvclVJL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDIxLTExLTE5ICBSYXp2 YW4gQ2FsaW1hbiAgPHJjYWxpbWFuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWIgSW5zcGVjdG9y OiBBZGQgQ1NTIHZhcmlhYmxlIG5hbWVzIHRvIHByb3BlcnR5IG5hbWUgY29tcGxldGlvbiBsaXN0 CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzMzNzIK KyAgICAgICAgPHJkYXI6Ly84MzIwNTk2OD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGQgdGhlIGxpc3Qgb2YgYXBwbGljYWJsZSBDU1MgdmFyaWFi bGVzIHRvIHRoZSBsaXN0IG9mIENTUyBwcm9wZXJ0eSBuYW1lIGNvbXBsZXRpb25zLgorCisgICAg ICAgIGBXSS5DU1NOYW1lQ29tcGxldGlvbnNgIGlzIGEgbG9uZy1saXZlZCBvYmplY3QgdGhhdCBo b2xkcyBhbGwgc3VwcG9ydGVkIHByb3BlcnR5IG5hbWVzLgorICAgICAgICBJdCBkb2Vzbid0IG5l ZWQgdG8gY2hhbmdlIG92ZXIgdGltZSBpbiBhIFdlYiBJbnNwZWN0b3Igc2Vzc2lvbi4gQnV0IHRo ZSBsaXN0IG9mIGFwcGxpY2FibGUKKyAgICAgICAgQ1NTIHZhcmlhYmxlcyBkZXBlbmRzIG9uIHRo ZSBzZWxlY3RlZCBub2RlLgorCisgICAgICAgIFRvIGF2b2lkIHRocmFzaGluZyB0aGUgbG9uZyBs aXN0IG9mIHZhbHVlcyBpbiBgV0kuQ1NTTmFtZUNvbXBsZXRpb25zYCB3ZSBkb24ndCBwcm9hY3Rp dmVseSBjb2xsZWN0CisgICAgICAgIENTUyB2YXJpYWJsZXMuIEluc3RlYWQsIHdlIGludHJvZHVj ZSBhIGZsYWcgdG8gaW5kaWNhdGUgdGhhdCB0aGUgbGlzdCBvZiBDU1MgdmFyaWFibGVzIG1heQor ICAgICAgICBiZSBzdGFsZSB3aGVuZXZlciB0aGUgaW5zcGVjdGVkIG5vZGUgY2hhbmdlcy4gT25s eSB3aGVuIGEgcXVlcnkgY29tcGxldGlvbnMgY29tZXMgaW4gZG8gd2UgY2hlY2sKKyAgICAgICAg dGhpcyBmbGFnIGFuZCBhdWdtZW50IHRoZSBsaXN0IG9mIENTUyBwcm9wZXJ0eSBuYW1lcyB3aXRo IHRoZSBsYXRlc3QgbGlzdCBvZiBDU1MgdmFyaWFibGVzLgorCisgICAgICAgICogVXNlckludGVy ZmFjZS9Nb2RlbHMvQ1NTQ29tcGxldGlvbnMuanM6CisgICAgICAgIChXSS5DU1NDb21wbGV0aW9u cy5wcm90b3R5cGUuc2V0IHZhbHVlcyk6CisgICAgICAgIEFsbG93IGEgc3ViLWNsYXNzIHRvIHJl cGxhY2UgdGhlIGxpc3Qgb2YgdmFsdWVzIGluIG9uZSBnby4KKyAgICAgICAgSWYgYSBgV0kuQ1NT UXVlcnlDb250cm9sbGVyYCB3YXMgdXNlZCwgcmVzZXQgaXQgYW5kIHByb3ZpZGUgaXQgdGhlIG5l dyBsaXN0IG9mIHZhbHVlcy4KKworICAgICAgICAqIFVzZXJJbnRlcmZhY2UvTW9kZWxzL0NTU05h bWVDb21wbGV0aW9ucy5qczoKKyAgICAgICAgKFdJLkNTU05hbWVDb21wbGV0aW9ucyk6CisgICAg ICAgIChXSS5DU1NOYW1lQ29tcGxldGlvbnMucHJvdG90eXBlLmV4ZWN1dGVRdWVyeSk6CisgICAg ICAgIChXSS5DU1NOYW1lQ29tcGxldGlvbnMucHJvdG90eXBlLnN0YXJ0c1dpdGgpOgorICAgICAg ICAoV0kuQ1NTTmFtZUNvbXBsZXRpb25zLnByb3RvdHlwZS5fdXBkYXRlVmFsdWVzV2l0aExhdGVz dENTU1ZhcmlhYmxlcyk6CisgICAgICAgIEhvbGRpbmcgYSBjb3B5IG9mIHRoZSBvcmlnaW5hbCBs aXN0IG9mIENTUyBwcm9wZXJ0eSBuYW1lcyBpbiBvcmRlciB0byBjcmVhdGUgYSBuZXcgbGlzdAor ICAgICAgICBhZ3VtZW50ZWQgd2l0aCB2YXJpYWJsZXMgb24gZGVtYW5kLgorCisgICAgICAgIChX SS5DU1NOYW1lQ29tcGxldGlvbnMucHJvdG90eXBlLl9oYW5kbGVJbnNwZWN0ZWROb2RlQ2hhbmdl ZCk6CisgICAgICAgIENvbnNpZGVyIGNoYW5naW5nIG9mIHRoZSBpbnNwZWN0ZWQgbm9kZSBhcyBh biBpbmRpY2F0b3IgdGhhdCB0aGUgbGlzdCBvZiB2YXJpYWJsZXMgaXMgc3RhbGUuCisgICAgICAg IFRoYXQgbWF5IG5vdCBuZWNlc3NhcmlseSBiZSB0cnVlIGZvciB3ZWIgcGFnZXMgd2l0aCBhbGwg Q1NTIHZhcmlhYmxlcyBkZWNsYXJlZCBvbiA6cm9vdCBvciA8aHRtbD4sCisgICAgICAgIGJ1dCBp dGVyYXRpbmcgb3ZlciB0aGVtIHRvIHZlcmlmeSBpcyBuZWVkbGVzc2x5IGV4cGVuc2l2ZSBlc3Bl Y2lhbGx5IGlmIGNvbXBsZXRpb25zIHdlcmUgbm90IGV2ZW4gcmVxdWVzdGVkLgorCiAyMDIxLTEx LTE3ICBSYXp2YW4gQ2FsaW1hbiAgPHJjYWxpbWFuQGFwcGxlLmNvbT4KIAogICAgICAgICBXZWIg SW5zcGVjdG9yOiBTdXBwb3J0IGZ1enp5IG1hdGNoaW5nIGluIENTUyBjb21wbGV0aW9ucwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvTW9kZWxzL0NTU0Nv bXBsZXRpb25zLmpzIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvTW9kZWxz L0NTU0NvbXBsZXRpb25zLmpzCmluZGV4IDFkMmNkMWEyYTBjMzdhYjRiNjdkN2RkMTYzMjdiMTQ3 MGFjM2EyMTEuLmE2MzBkZjVkZTlmMmI5ZmU5MzMyYmVjNmQyYmVhNzZmZjBmNWYwZGUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL01vZGVscy9DU1NDb21w bGV0aW9ucy5qcworKysgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9Nb2Rl bHMvQ1NTQ29tcGxldGlvbnMuanMKQEAgLTE0Miw2ICsxNDIsMTggQEAgV0kuQ1NTQ29tcGxldGlv bnMgPSBjbGFzcyBDU1NDb21wbGV0aW9ucwogICAgICAgICByZXR1cm4gdGhpcy5fdmFsdWVzOwog ICAgIH0KIAorICAgIHNldCB2YWx1ZXModmFsdWVzKQorICAgIHsKKyAgICAgICAgY29uc29sZS5h c3NlcnQoQXJyYXkuaXNBcnJheSh2YWx1ZXMpLCB2YWx1ZXMpOworICAgICAgICB0aGlzLl92YWx1 ZXMgPSB2YWx1ZXM7CisgICAgICAgIHRoaXMuX3ZhbHVlcy5zb3J0KCk7CisKKyAgICAgICAgaWYg KHRoaXMuX3F1ZXJ5Q29udHJvbGxlcikgeworICAgICAgICAgICAgdGhpcy5fcXVlcnlDb250cm9s bGVyLnJlc2V0KCk7CisgICAgICAgICAgICB0aGlzLl9xdWVyeUNvbnRyb2xsZXIuYWRkVmFsdWVz KHZhbHVlcyk7CisgICAgICAgIH0KKyAgICB9CisKICAgICBhZGRWYWx1ZXModmFsdWVzKQogICAg IHsKICAgICAgICAgY29uc29sZS5hc3NlcnQoQXJyYXkuaXNBcnJheSh2YWx1ZXMpLCB2YWx1ZXMp OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvTW9kZWxz L0NTU05hbWVDb21wbGV0aW9ucy5qcyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJm YWNlL01vZGVscy9DU1NOYW1lQ29tcGxldGlvbnMuanMKaW5kZXggZmVkNTg4ZmEwOGUyNTU1ZjEz ZTk4YzVlMDM1MTM2Y2M3ZGQ3NjJiNi4uNThlNDZjNmNhMDc0MGZhMzI5Y2QwMDQ1MzIwOTYxYTc1 NDM5ZmY0ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2Uv TW9kZWxzL0NTU05hbWVDb21wbGV0aW9ucy5qcworKysgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkv VXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTTmFtZUNvbXBsZXRpb25zLmpzCkBAIC00OCw2ICs0OCwx MSBAQCBXSS5DU1NOYW1lQ29tcGxldGlvbnMgPSBjbGFzcyBDU1NOYW1lQ29tcGxldGlvbnMgZXh0 ZW5kcyBXSS5DU1NDb21wbGV0aW9ucwogICAgICAgICB9CiAKICAgICAgICAgc3VwZXIodmFsdWVz LCBhY2NlcHRFbXB0eVByZWZpeCk7CisKKyAgICAgICAgdGhpcy5fY2FjaGVkVmFsdWVzID0gdmFs dWVzLnNsaWNlKDApOworICAgICAgICB0aGlzLl9pc1N0YWxlTGlzdE9mQ1NTVmFyaWFibGVzID0g dHJ1ZTsKKworICAgICAgICBXSS5kb21NYW5hZ2VyLmFkZEV2ZW50TGlzdGVuZXIoV0kuRE9NTWFu YWdlci5FdmVudC5JbnNwZWN0ZWROb2RlQ2hhbmdlZCwgdGhpcy5faGFuZGxlSW5zcGVjdGVkTm9k ZUNoYW5nZWQsIHRoaXMpOwogICAgIH0KIAogICAgIC8vIFB1YmxpYwpAQCAtNTYsNCArNjEsMzkg QEAgV0kuQ1NTTmFtZUNvbXBsZXRpb25zID0gY2xhc3MgQ1NTTmFtZUNvbXBsZXRpb25zIGV4dGVu ZHMgV0kuQ1NTQ29tcGxldGlvbnMKICAgICB7CiAgICAgICAgIHJldHVybiB0aGlzLnZhbHVlcy5p bmNsdWRlcyhuYW1lKTsKICAgICB9CisKKyAgICBleGVjdXRlUXVlcnkocXVlcnkpCisgICAgewor ICAgICAgICBpZiAodGhpcy5faXNTdGFsZUxpc3RPZkNTU1ZhcmlhYmxlcykKKyAgICAgICAgICAg IHRoaXMuX3VwZGF0ZVZhbHVlc1dpdGhMYXRlc3RDU1NWYXJpYWJsZXMoKTsKKworICAgICAgICBy ZXR1cm4gc3VwZXIuZXhlY3V0ZVF1ZXJ5KHF1ZXJ5KTsKKyAgICB9CisKKyAgICBzdGFydHNXaXRo KHByZWZpeCkKKyAgICB7CisgICAgICAgIGlmICh0aGlzLl9pc1N0YWxlTGlzdE9mQ1NTVmFyaWFi bGVzKQorICAgICAgICAgICAgdGhpcy5fdXBkYXRlVmFsdWVzV2l0aExhdGVzdENTU1ZhcmlhYmxl cygpOworCisgICAgICAgIHJldHVybiBzdXBlci5zdGFydHNXaXRoKHByZWZpeCk7CisgICAgfQor CisgICAgLy8gUHJpdmF0ZQorCisgICAgX3VwZGF0ZVZhbHVlc1dpdGhMYXRlc3RDU1NWYXJpYWJs ZXMoKQorICAgIHsKKyAgICAgICAgbGV0IG5vZGVTdHlsZXMgPSBXSS5jc3NNYW5hZ2VyLnN0eWxl c0Zvck5vZGUoV0kuZG9tTWFuYWdlci5pbnNwZWN0ZWROb2RlKTsKKyAgICAgICAgY29uc29sZS5h c3NlcnQobm9kZVN0eWxlcyBpbnN0YW5jZW9mIFdJLkRPTU5vZGVTdHlsZXMsIG5vZGVTdHlsZXMp OworCisgICAgICAgIGxldCB2YXJpYWJsZXMgPSBBcnJheS5mcm9tKG5vZGVTdHlsZXMuYWxsQ1NT VmFyaWFibGVzKTsKKyAgICAgICAgY29uc29sZS5hc3NlcnQoQXJyYXkuaXNBcnJheSh2YXJpYWJs ZXMpLCB2YXJpYWJsZXMpOworCisgICAgICAgIHRoaXMudmFsdWVzID0gdGhpcy5fY2FjaGVkVmFs dWVzLmNvbmNhdCh2YXJpYWJsZXMpOworICAgICAgICB0aGlzLl9pc1N0YWxlTGlzdE9mQ1NTVmFy aWFibGVzID0gZmFsc2U7CisgICAgfQorCisgICAgX2hhbmRsZUluc3BlY3RlZE5vZGVDaGFuZ2Vk KCkKKyAgICB7CisgICAgICAgIHRoaXMuX2lzU3RhbGVMaXN0T2ZDU1NWYXJpYWJsZXMgPSB0cnVl OworICAgIH0KIH07Cg== 444829 2021-11-19 09:55:40 -0800 2021-11-19 09:55:40 -0800 Screenshot of variable autocompletion variable-autocompletion-screenshot.png image/png 114667 rcaliman iVBORw0KGgoAAAANSUhEUgAAApIAAAIECAYAAACqt844AAAK22lDQ1BJQ0MgUHJvZmlsZQAASImV lwdUU9kWQO976SGhJBABKaF3pBNASuihSK+iEpJAQokhIQiIDRkcwbGgIoJlREdFFBwdARkLYsE2 KCp2nSCDgjoOFkRFzbzAJ8zMX///9c9aJ3fn5NxT7rtvrRMAyKFskSgXVgcgT1ggjg3xpyenpNJx gwAL1IEqoAAvNkciYkZHRwBEpta/y/vbAFKsN+0Usf799/8qFC5PwgEASkM4gyvh5CHciehzjkhc AADqIGI3WVQgUvB1hDXFSIEI/6bgrEn+oOCMCUaTJnziYwMQpgOAJ7HZ4iwASLaInV7IyULikBQ9 OAi5AiHCpQj7cPhsLsInELbNy1uo4CGELRF/EQBk5HQAI+MvMbP+Fj9DGZ/NzlLyZF8Tgg8USES5 7OL/82j+t+TlSqdymCNK4otDYxX5kPO7m7MwXMnCjDlRUyzgTtakYL40NGGKOZKA1CnmsgPDlXtz 50RMcaYgmKWMU8CKn2KeJChuisULY5W5MsUBzClmiyfyEhGWSXMSlHY+j6WMX8KPT5riQkHinCmW 5MSFT/sEKO1iaayyfp4wxH86b7Cy9zzJX/oVsJR7C/jxocre2dP184TM6ZiSZGVtXF5g0LRPgtJf VOCvzCXKjVb683JDlHZJYZxybwFyOaf3RivPMJsdFj3FQAAiARtw6GpTBEABr6hA0UjAQlGxWJDF L6AzkbeNR2cJOfa2dCcHJ0cAFO/u5HV4S5t4JyHa5WnbKgfkqnfJ5fKv07YQ5DYcRqITx6Ztlsg5 qj8E4CKDIxUXTtrQig8M8vTUgCbQAQbABFgCO+AE3IAX8ANBIAxEgXiQAuYjtfJBHhCDRaAUrAAV oAqsB5tBHdgJdoP94BA4AtrACXAGXABXwHXQBx4AGRgEL8AIeA/GIQjCQWSICulAhpAZZAM5QQzI BwqCIqBYKAVKh7IgISSFSqGVUBVUDdVBu6BG6EfoOHQGugT1QvegfmgYegN9glEwCdaE9WFzeBbM gJlwOBwPz4Oz4Hy4BC6H18K1cAN8EG6Fz8BX4D5YBr+AR1EApYKioYxQdigGKgAVhUpFZaLEqKWo SlQNqgHVjOpAdaNuomSol6iPaCyaiqaj7dBe6FB0ApqDzkcvRa9B16H3o1vR59A30f3oEfRXDBmj h7HBeGJYmGRMFmYRpgJTg9mLOYY5j+nDDGLeY7FYGtYC644NxaZgs7GLsWuw27Et2E5sL3YAO4rD 4XRwNjhvXBSOjSvAVeC24g7iTuNu4AZxH/AqeEO8Ez4Yn4oX4svwNfgD+FP4G/hn+HGCOsGM4EmI InAJxYR1hD2EDsI1wiBhnKhBtCB6E+OJ2cQVxFpiM/E88SHxrYqKirGKh0qMikBluUqtymGViyr9 Kh9JFJI1KYCURpKS1pL2kTpJ90hvyWSyOdmPnEouIK8lN5LPkh+TP6hSVe1VWapc1WWq9aqtqjdU X6kR1MzUmGrz1UrUatSOql1Te6lOUDdXD1Bnqy9Vr1c/rn5HfVSDquGoEaWRp7FG44DGJY0hCo5i TgmicCnllN2Us5QBKopqQg2gcqgrqXuo56mDmlhNC02WZrZmleYhzR7NES2KlotWolaRVr3WSS0Z DUUzp7FoubR1tCO027RPM/RnMGfwZqye0Tzjxowx7Znafto87UrtFu0+7U86dJ0gnRydDTptOo90 0brWujG6i3R36J7XfTlTc6bXTM7MyplHZt7Xg/Ws9WL1Fuvt1ruqN6pvoB+iL9Lfqn9W/6UBzcDP INtgk8Epg2FDqqGPocBwk+Fpw+d0LTqTnkuvpZ+jjxjpGYUaSY12GfUYjRtbGCcYlxm3GD8yIZow TDJNNpl0mYyYGppGmpaaNpneNyOYMcz4ZlvMus3GzC3Mk8xXmbeZD1loW7AsSiyaLB5aki19LfMt GyxvWWGtGFY5VtutrlvD1q7WfOt662s2sI2bjcBmu02vLcbWw1Zo22B7x45kx7QrtGuy67en2UfY l9m32b+aZTorddaGWd2zvjq4OuQ67HF44EhxDHMsc+xwfONk7cRxqne65Ux2DnZe5tzu/NrFxoXn ssPlrivVNdJ1lWuX6xc3dzexW7PbsLupe7r7Nvc7DE1GNGMN46IHxsPfY5nHCY+Pnm6eBZ5HPP/w svPK8TrgNTTbYjZv9p7ZA97G3mzvXd4yH7pPus/3PjJfI1+2b4PvEz8TP67fXr9nTCtmNvMg85W/ g7/Y/5j/WIBnwJKAzkBUYEhgZWBPECUoIagu6HGwcXBWcFPwSIhryOKQzlBMaHjohtA7LH0Wh9XI GglzD1sSdi6cFB4XXhf+JMI6QhzREQlHhkVujHw4x2yOcE5bFIhiRW2MehRtEZ0f/XMMNiY6pj7m aaxjbGlsdxw1bkHcgbj38f7x6+IfJFgmSBO6EtUS0xIbE8eSApOqk2TJs5KXJF9J0U0RpLSn4lIT U/emjs4Nmrt57mCaa1pF2u15FvOK5l2arzs/d/7JBWoL2AuOpmPSk9IPpH9mR7Eb2KMZrIxtGSOc AM4WzguuH3cTd5jnzavmPcv0zqzOHMryztqYNcz35dfwXwoCBHWC19mh2Tuzx3KicvblyHOTclvy 8HnpeceFFGGO8NxCg4VFC3tFNqIKkSzfM39z/og4XLxXAknmSdoLNJEh6arUUvqNtL/Qp7C+8MOi xEVHizSKhEVXi62LVxc/Kwku+WExejFncVepUemK0v4lzCW7lkJLM5Z2LTNZVr5scHnI8v0riCty VvxS5lBWXfZuZdLKjnL98uXlA9+EfNNUoVohrrizymvVzm/R3wq+7VntvHrr6q+V3MrLVQ5VNVWf 13DWXP7O8bva7+RrM9f2rHNbt2M9dr1w/e0Nvhv2V2tUl1QPbIzc2LqJvqly07vNCzZfqnGp2bmF uEW6RVYbUdu+1XTr+q2f6/h1ffX+9S3b9Lat3ja2nbv9xg6/Hc079XdW7fz0veD7u7tCdrU2mDfU 7MbuLtz9dE/inu4fGD807tXdW7X3yz7hPtn+2P3nGt0bGw/oHVjXBDdJm4YPph28fijwUHuzXfOu FlpL1WFwWHr4+Y/pP94+En6k6yjjaPNPZj9tO0Y9VtkKtRa3jrTx22TtKe29x8OOd3V4dRz72f7n fSeMTtSf1Dq57hTxVPkp+emS06Odos6XZ7LODHQt6HpwNvnsrXMx53rOh5+/eCH4wtluZvfpi94X T1zyvHT8MuNy2xW3K61XXa8e+8X1l2M9bj2t19yvtV/3uN7RO7v31A3fG2duBt68cIt160rfnL7e 2wm3795JuyO7y707dC/33uv7hffHHyx/iHlY+Uj9Uc1jvccNv1r92iJzk53sD+y/+iTuyYMBzsCL 3yS/fR4sf0p+WvPM8FnjkNPQieHg4evP5z4ffCF6Mf6y4neN37e9snz10x9+f1wdSR4ZfC1+LX+z 5q3O233vXN51jUaPPn6f9358rPKDzof9Hxkfuz8lfXo2vugz7nPtF6svHV/Dvz6U58nlIraYPTEK oBCFMzMBeLMPmY1TAKAiczlx7uRsPSHQ5P+BCQL/iSfn7wlxA6DZD4AYRJnLATiCqDmiash3xUgU 7wdgZ2el/kskmc5Ok7FIyGSJ+SCXv9UHANcBwBexXD6+XS7/sgcp9h4AnfmTM71CsMgs32yoL3Up vlXUVw7+IZPz/l96/OcKFBW4gH+ufwJ2uBtRJNVCmQAAAIplWElmTU0AKgAAAAgABAEaAAUAAAAB AAAAPgEbAAUAAAABAAAARgEoAAMAAAABAAIAAIdpAAQAAAABAAAATgAAAAAAAACQAAAAAQAAAJAA AAABAAOShgAHAAAAEgAAAHigAgAEAAAAAQAAApKgAwAEAAAAAQAAAgQAAAAAQVNDSUkAAABTY3Jl ZW5zaG907G9fRAAAAAlwSFlzAAAWJQAAFiUBSVIk8AAAAdZpVFh0WE1MOmNvbS5hZG9iZS54bXAA AAAAADx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IlhNUCBDb3Jl IDYuMC4wIj4KICAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAy LzIyLXJkZi1zeW50YXgtbnMjIj4KICAgICAgPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIK ICAgICAgICAgICAgeG1sbnM6ZXhpZj0iaHR0cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iPgog ICAgICAgICA8ZXhpZjpQaXhlbFlEaW1lbnNpb24+NTE2PC9leGlmOlBpeGVsWURpbWVuc2lvbj4K ICAgICAgICAgPGV4aWY6UGl4ZWxYRGltZW5zaW9uPjY1ODwvZXhpZjpQaXhlbFhEaW1lbnNpb24+ CiAgICAgICAgIDxleGlmOlVzZXJDb21tZW50PlNjcmVlbnNob3Q8L2V4aWY6VXNlckNvbW1lbnQ+ CiAgICAgIDwvcmRmOkRlc2NyaXB0aW9uPgogICA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgqerjgI AAAAHGlET1QAAAACAAAAAAAAAQIAAAAoAAABAgAAAQIAALo73+r9WAAAQABJREFUeAHsnQW4HLXX xlOFCtACbYEqFCnu7u7u7lLc3d2d4lCguP0pru2HU9yhhbZQoV6qVNkvv9yeJTs7szszu3vv3vac 57l3ZjJJJnmTnbxzck7S4Ndff80YFUVAEVAEFAFFQBFQBBQBRSAhAg2USCZETKMrAoqAIqAIKAKK gCKgCDgEGkyZMkU1ktoZFAFFQBFQBBQBRUARUAQSI6BEMjFkmkARUAQUAUVAEVAEFAFFAASUSGo/ UAQUAUVAEVAEFAFFQBFIhYASyVSwaSJFQBFQBBQBRUARUAQUASWS2gcUAUVAEVAEFAFFQBFQBFIh oEQyFWyaSBFQBBQBRUARUAQUAUVAiaT2AUVAEVAEFAFFQBFQBBSBVAgokUwFmyZSBBQBRUARUAQU AUVAEVAiqX1AEVAEFAFFQBFQBBQBRSAVAkokU8GmiRQBRUARUAQUAUVAEVAElEhqH1AEFAFFQBFQ BBQBRUARSIWAEslUsGkiRUARUAQUAUVAEVAEFAElktoHFAFFQBFQBBQBRUARUARSIaBEMhVsmkgR UAQUAUVAEVAEFAFFQImk9gFFQBFQBBQBRUARUAQUgVQIKJFMBZsmUgQUAUVAEVAEFAFFQBFQIql9 QBFQBBQBRUARUAQUAUUgFQJKJFPBpokUAUVAEVAEFAFFQBFQBJRIlrkPjB071gwbNsxMnjzZZDIZ 06BBg0RPkDQtW7Y07du3N4ssskii9Bq5OhDQflAd7VDXpdB+UNctUB3P135QHe2gpagMAkoky4jr 4MGDzfjx481CCy1kWrRoYRo3buxyj0smIZHIrFmzzJQpU8yECRNM69atTZcuXVy4/qsfCGg/qB/t VOlSaj+oNML1I3/tB/WjnbSU6RFQIpkeu5yU48aNM3/++adZYoklzHzzzWcaNWpkGjZs6OIkJZL/ /vuvmT17tpk+fboZPny46dSpk1l44YVznqcX1YmA9oPqbJfaLpX2g9pGvDqfp/2gOttFS1VeBJRI lgnPH3/80Wki0SA2adLEaSMhkkIm4z4GEskfWsmZM2c6DSeayRVXXDFuFnUWj5fmO++8Y5Zaaimz 1lpr1Vk56vLB2g/qEv3qebb2g+ppi7osSX3sB59++qkZMmSI2WabbdyYlga/ahkLxowZY77//ntX jzXWWCNNVTRNDASUSMYAKU6UL7/80nTr1s00a9bMEUlfIxknvR9HNJIQyX/++cf88ssvZs011/Sj FDx/7LHHzMcff2y22247s+uuuxaMW86bjz/+uPnwww8deb7++uvd9H45868PedVVP/j777/NQw89 VBSi9ddf3/CnUlkEqqEfnHzyyVnzmrDa/u9//zMDBw40G2+8sVl77bXDomhYiQjURT+gTWlblBgn nHCCG4+iqjFixAjzxBNPuNtHHXWUmwm74IILnH3/FltsYfbee++opAXDq2Us+Oqrr8z9999vOnfu bM4999yCZdab6RFQIpkeu5yU3333nVlppZVM06ZNs9Pacae0czKyF9hKCpmcMWOG+eGHH8wqq6wS jBZ6PXr0aHPxxRdn791xxx0FB5NsxBgnfGXeeeedzoHo/PPPd/X0k33wwQfmySefNG3btnVlSKqN 9fOqr+d11Q9GjhxpLr300qKwbb/99maXXXYpGk8jlIZANfSD22+/vSCJuOuuu9y7hY9NPjpVyo9A XfSDadOmmbPPPtvNaEEOCykhevfubV5//XWz2GKLmUsuucTNhPEe4V1/6KGHmnXXXTcVKFFjQbEx JNXDCiRSIlkAnDLeUiJZJjB/+uknN/2Mgw3aSEhkKUQSMomdJFPcTI+ssMIKsUr6yiuvmFdffTUb 95hjjjGrr7569rqUE75eL7vsMpdF1CA1ceJEg8f5vEgiAaau+oFPJNFEYV4RJqwCgPmFSmURqIZ+ EPUblZorkRQkKnesq37A7MTnn39uVl11VXPcccdFVvCiiy4yTP/6HxOMOcyELbDAApHp4twIGwvi jCFx8o4bR4lkXKRKi6dEsjT8sql//fVXR/ZkSrscRFK0kryMlltuueyzok4gn2gjeTEwzc6UOJrM 7t27RyXJCed5hQhgbb8EpHDFyiXxquFYV/3AJ5LFCEQUTrJqQJIPoDRpop4fFV6f2l/qUB/6QVwi WWn80+RPGqTQ+0raoi6PddUPGDNkNgozI0yugjJo0CDDPX7vV111VeIPzDTtlnQMSfqM4PtIiWSw 1StzrUSyTLjW1QvDL/5vv/1mbrrpJvclec455xi+NnlJXHfddU5L6MeVc14m2PFAOvEQb9OmjbMn 2WqrrZy3uMTjRcOUCSQVadeunXuJr7fees4omzBeXs8995zp2LGjOfzwwwly9il//fWXwd5mo402 cmH+v7ffftt88sknzkHnoIMOyt5iyQy+qMmT6foll1zSkWPyYHmlapW66gdpiSR2uExDUW76D7L0 0ku7Dxds58I0m6TBFpY0/fv3d6YYtPnyyy9vtt1225zBnbz79OljVltttdAp9VtuucVMmjTJHHnk kW7dVGlXnvHyyy9n+yUrIbAiwiabbFIv7PnqQz8oRCSxs+O9QD34/S6++OKuTzBNijOdCO3/1FNP OZMeplODxI53xo033uhMdY444gjToUMHl5T2xY6b2RbymH/++V3/QYNGX/Hl22+/NS+99JJ7Lu8b pmLpq8z+8L6rZqmrfgABw/wIR03eqxtuuGEeTM8884z7baJ0OOWUU7L37777bvfOJZ3f1kSgrXhn s0IJv1vGi65du5rdd989R4MZNhbEGUN4RpK+QXwEEwJII/2J1U5YgxkzHrSraiNZg1El/yuRLBO6 /MAYSCuhkfz555/NsssuW7SkvXr1Mh999JHZdNNNzX777WduvvlmM2DAAGcwDZELCoPFrbfe6n64 3OPFzA8PgUBABmVa/LTTTnPxmG5HiAtJ3Wyzzcwee+zhwr744gvz4IMPOtLHoIIwzc50O0RQwtyN Of+wyxk1apQrL+VGILcQDF4oCJjKcyETZ511lht43M0q+1dX/SANkWSwuffee91LGBiFBBCOoM0+ 9thjs+GE8cV/3333mW+++YZLd48w0QQwKJEGYoBI+0MAsLkKCgbwDHa0qQxaTKvRd4cOHer62KKL LmpwJpL+AFndbbfdgllV1XV96AdRRBKShlZb8A6+FzCd4GMDYdDmo5XjSSedlGeCw8cg06wLLrig ueaaa7L9hcH966+/dnnQ76TPEXDIIYfkOITxTuPdhu311KlT3WYPxGvevHnVE8m66gfg88ILLzjS x2zWqaeeSlBWwPu8884zTD8fdthhObaQl1obSd4nwfakHXDMIS3Y8xvH5hGhfekHskxd2FgQZwzh PZKkb/Bs+hFp5B3k91feYZBMdbYBqcqJEskyYVuXLwyqwEsfooYGQAZltEH88FmHkpeGL2j50FSy 8DkEGDLIVxyawNdee80Z4bOoOi9/0UoVm5YIe3mgwRTnn+D0CUSBMH741157rfPy5sXEOV+7LNeA 7Q5EgnJBUrnPUkgnnniiX52qOa+rfpCGSD799NOmb9++Dn8Gb5zFEJy7Hn30UfdRwYfCvvvum8X3 2WefNe+9954j9wceeKDTHkHyWWKDvsaHCH1p6623dmnSEEmWH3nkkUec5pkBEEcA8kWzyeBIf7z6 6qsjtezZwtbhSTX0A37fOP9FCR8RzET49nF81JEOwsYgjGMWH2/MVuCYwaAMieADAG0UQlvRZmi9 /FkF7t1zzz0GjSIzHHvuuSdBzqP4zTffdGXjY5XfMx8P9CvC+XCEdKDpQoRIco59Lx/J3COefLBw rxqlrvoBWNBmV1xxhfsY4z3uz+TQ7rfddptrA6a30fiLRBHJCy+80LBDD23JbxxFAu9jlBGMJ34b h40F5F9sDMHbPEnfQFvOeIFTKu8vPjDpr3/88YfhXYWyBFEi6WCo2D8lkmWCti5fGFRBfrg4U8jL A5LIVyIDPWSO6SkRfqz8aBkMIJm+DQ2DCAQPMudrJYu9BKQMQe2jaEb32msvs+WWW0oR3MDENBVT WWixkLfeesu8+OKL7od/5plnOpIjCdh6knLx5XnDDTdUJZGoq37gE0leqAyyQcEJSgZ6tAoM1ryA w6a+ZPCGiKAdFq2RpGEwFw2yPIcpL6ajIX5MqyFpiKRo1lmShulQX5i6osxoWSA01SrV0A/iYuMT SXkv0IaQRZ9goHVk0OY9wICNZhihrvQRPjwhJaLZ9r2HISF8qPLbpQ+RV5gjIJolpihlVoX8pS9y fvnll2cJLNfVLnXVDwQXPrhYEzL47uVDEZOisJmCMCLJjIAoI3C4RDssArlkqhuiKrMKUWNBoTEk Td8Q51LKQ/n8DwtmOqg/WlclktJalTkqkSwTrnX9wmBZHgbZ4NqRMn2FhkimoKky05NMCey4445m p512ioVCoZcAGUS9PGQg4CWDtlREprXxKsQ2CpGBxB+oJD5HSYNGshoXaa+rfuATSR8v/5wXPUQA EW0F2mA0EzL4S3yIJnZTaAKxteUrHyJ/5ZVXOpJKmjCyKunlmIZIoplCm0D+2Dmx7qVMmUm+1X6s hn7gD6pheEHmGLx9IinvBd4JvBuCIu2JyQtEECEPiCLaKaa9meFAZFobu0jWJkTQIEEG/Q8Ud2PO P0njf4zK+4M+SF+sT1JX/UAwkt+ST6T4TTN7hRYYjX/QkTOMSNLGfNijZOhit+ylf5CO90eYRI0F hcaQNH0De0605FH9leXo3n//fSWSYY1UxjAlkmUCsy5fGHx5yWKrDLxi0E7V+vXr56aW0DhimM50 BILGiH3B0QQGjdtdhJB/hV4CRI96eYhmgheYTG8LKUFLBrkRUiLLUYQ8PifIH/xybtTxRV31A59I 0qZijuDDQZjY2qKNQCuBlggSECaQRtpJbNZwjmCx+0JpgvkI8QjTfBA3ykYSj1NsZUUwb2AJLNa1 E62H3KvGYzX0g2Le+/KR6f+WIHwQwjBtITjz8QnZhNjzWxaR9Qj96W2mzrGlZVFrsdEWswVJF3Xk fUD5+cARIhl0ColKW03hddUPBANmlfiN8WEo2lzahLbBTIA2lDFB0oQRSe5B8nv27Jm1Z+V9AuHH AYudzPwZgqixoNAYkqZvyDgW1V8hkZBJn0hLPfVYPgSUSJYJy7p8YbAt4fPPP1+0Jr62QAZwlgbC FiqOFHoJkD7q5cE9WddMBhUZeII2eHwp8/JjABGDftKLgPMyyyzjCEWYJ6LEq6tjXfUDn0gWIxBg I/azhV6w2FUxZXXAAQe43U/w1GbHCjy0Zeq6GM5piCR5YvPLgMeHEA5jaM9E8Nxmaj04AMr9ajjW h34QRiQxhWEqkB1RxGbWxxNb2B49ejjnCmwpRaT/yfQ27cfsA2Y1fCjKmoQysJNOPmokD458dKKZ gqDwvoJQKpGsQQitIH+QQnCN64RJe9FuorWTWZ/g7JW0QxSR5D5jAB+h2L3S5iK0L+0lSoyosaDQ GJKmbxTrr/LxW+g9J3XQY3oElEimxy4nZV0NHBRCNEecy5c/5yJMbyC+zZlMCWBMjxYzjhR6CZA+ 6uXBPV56EByZ3paXFXYtOAOJyBQ9Dh6QzPomddUPZCAHrzhEEmN0BnimGDGWD5IyBiymvbBH5KOD FzGkEnIZNR0e1lZCJMMcpHgG0+dCOqI0jQyceBK/++67WQ9z7OzCiEhYGeoirD70gzAiKWEs58Je y0ERG2ZIJmTTF+yWcW6AUGCfjXPcyiuvbI4//vhsNFm7EMLJskBxRIlkDUppiaSspYjdK8SLj3V+ c7yDWcYtKPJuDnptB+PxwYEWkd8l53zgn3766S5a1FhQaAxJ0zd41zG2RPVXcQ5UIhlsvfJeK5Es E551NXCI5zPVwMmGKcCgYEMCcYQ0oEXAdgrPbBwj+ILk5eLbuvC1yxQGU+Z8xcqA7b8EICG+FyDP jHp5cI+XIKRRtB0QRpx/xKObOIhoKiEeDFRBggOZQWuBvRTT4tUmddUPkhJJzAwgYxzDtE94bkMq 6Bc4UnCkX0AuScO6j0xn+UI/QzvOtOdhdkkRRDQC9DlMK3xbTCGmxJOVBjhnOp1nMPD5zh70IUwf MO7HAxgv0WqV+tAPhDT6U9vivACpP+OMM3LaC0JPG0IWw2yrRaPEWq8QSabBjz76aLf6grQTBIZ+ R1+C0KB59IV0tD/tzuCPKJGsQSgtkeS3xDse+0YUDSgWsHMkLEzCiCTtwgoc/I6D5FPMZLjHuwKJ GgsKjSFp+oZ4edOPsOH03y/MYuBsw0oESiTDWrp8YUoky4QlAwc2PEzF8AcBCpKguI+SFwYvW/5Y qkHIXDAP+eISTV/wPtfkwUuDl8HBBx9sNthgA7dGHx6W/HhxZthnn33cSwINFD9OllrhZY4GSjy6 J0+enHWWYSDHA9uvY9TLQ8qENzYajVatWrl1Af1lYiQOy/ygqaDMOAjtvPPOzt4PTBhQWGKGc2y5 ZBpF0lbDsa76QVIiCVZiw4Z2CM0gU9YIXp4409BffKcK7omJAoMGGgvRIjL4M4iQBg237OdNXrzM EfoM09J80OAFytIwaEYRn0jSL9FOYMyPdksGB57BhxB9NoyEuIyq5F996AdhRJL24PcH+WBGAKc3 3gMMyrwX+vatWS6KQVuInkAOUeE9Q3zeI9jQ0V7+RypxZUkg1h6kfbG5RbDZZtqVtvdXcqjvRLIu xgUHqPdPnE4kKGzVBbkXRiRx5OTjn98ijo7iUMXHBXbTaCb9WYeosaDYGJK0b/z+++9uzVnK4fdX HIlY/QFtLKJEUlq3MkclkmXClR0M/AXJ+cH5JCvJYyBK/DD4g1Chug961pEf95l2xKaw2FQwtm3Y uPnTD/5CrpBfNIR8MTKIIGFEDw0ia4YhDAR84coyIFEvDxfZ/hOvPK7BB4IR1Gpy77PPPnMaUc4Z hNBMUUc0pAjPxNayGqUu+gE4pCGSkAOWZkIziMge3AzoCCYHTFVBDEQgcUyFy/pspKGf46CBoBGH FNI3EPqoaLG4hoCyVAd9gXPKAOnwiSQv/wceeMB9MBAHsspzIRj0TdYQhMhUs9SHfhBGJMEUp4qH H37Y4c/vjyXC+M2DPW3NkmCYyYSJ2N9xj4+G/fffPy8aMwr0CWZTEPoQH6tojngG9nZoQ0XzVZ+J ZF31gyDo/F4xPUBoU2aU+IAMkzAiyZjE+1o2CeCdzO+Ya2YIyBMnP7GrLTQWFBpDkvYNyu/7CFAO 3kH0Jd49XazmdbBVTiiRDGvp8oUpkSwTljgE4BzCVzgkqVxEkgEU7UYYkZRFZXmWb9AeViXyQGPE QEBcGejZBo2pCcrPgM59XuBMaeONFxRIB1PibIHFD9UndeQFASikHeXZaD3wwEWjFSV84UIo+eIE A4QpU0grW/dRzmqUuugH4MBAzwsaXNAm0g/jCAQdcwL6By9fhAECDTjaYOknfl5oFZgC5QNH0uCx yYcUjjm+9ybp0FShyZQ+RhgfLWjH8QBGOxnUMFIetnCDcNLPED468NpG28mHTzVLfegH4oQRttQW Tk78Bvn98V5AiwyBx/t+nXXWiYReTCKIEGxTPxEfhfQhiJZ8mPIeQwPOVLssdk4amTqlf6HBrE9S V/0gDCNZOs3X9obFY51IFApgLZpH4vHRx4YAkER+0wjEjZkMFBm+hrrQWFBoDCHPJH2D+Ahr2FIu ZkAgvXyYMDMCqeQd06XAVH5NDvq/FASUSJaCnpeWrx46LQOvTySTEh5+BL5GEptCbFP4IVRS0ATw HMgag0YxgdyRBm0V9a2USLnQUkR9QVfq2Wnyrc/9QDS+YVriKCxIg9acflNMIISQBl7yYQQ1LD3t j8aDtq9Gm9iwMhNWn/uBXyfBn3dbpcg7fQiySh+q1DP8OtXm+dzSD4KY0WYQS/pF2vd/nDEkad/g w5hy0ZfSlitYV70ujoASyeIYxYpBB0azghOIaCWFRMqxWEYQSESIJD80Fo7GplCWzyiWh96vWwS0 H9Qt/tXydO0H1dISdVsO7Qd1i78+vXYQUCJZRpzRtmDjgc0PGhT5uk5KJNHw4LSArRo2Yv40TxmL q1lVCAHtBxUCtp5lq/2gnjVYhYqr/aBCwGq2VYOAEskyNwVfoBBACCUSl0RKMUQrCYGEkKomUpCp X0ftB/WrvSpVWu0HlUK2fuWr/aB+tZeWNhkCSiST4aWxFQFFQBFQBBQBRUARUATmIKBEUruCIqAI KAKKgCKgCCgCikAqBJRIpoJNEykCioAioAgoAoqAIqAIKJHUPqAIKAKKgCKgCCgCioAikAoBJZKp YNNEioAioAgoAoqAIqAIKAJKJLUPKAKKgCKgCCgCioAioAikQkCJZCrYNJEioAgoAoqAIqAIKAKK gBJJ7QOKgCKgCCgCioAioAgoAqkQUCKZCjZNpAgoAoqAIqAIKAKKgCKgRFL7gCKgCCgCioAioAgo AopAKgSUSKaCTRMpAoqAIqAIKAKKgCKgCCiR1D6gCCgCioAioAgoAoqAIpAKASWSqWDTRIqAIqAI KAKKgCKgCCgCSiS1DygCioAioAgoAoqAIqAIpEKgwcCBAzOpUmoiRUARUAQUAUVAEVAEFIF5GgEl kvN082vlFQFFQBFQBBQBRUARSI9Ag4yV9Mk1pSKgCCgCioAioAgoAorAvIqAEsl5teW13oqAIqAI KAKKgCKgCJSIgBLJEgHU5IqAIqAIKAKKgCKgCMyrCCiRnFdbXuutCCgCioAioAgoAopAiQgokSwR QE2uCCgCioAioAgoAorAvIqAEsl5teW13oqAIqAIKAKKgCKgCJSIgBLJEgHU5IqAIqAIKAKKgCKg CMyrCCiRnFdbXuutCCgCioAioAgoAopAiQgkIpJjRowzX7z/g/n9l8FmypSpJT46N3mLFs1N125d zFqbrGQWXWzh3Jt6pQgoAoqAIqAIKAKKgCJQdQjEJpIjh441vXq8YGbPnl3RSjRq1MgcdPwepl2H RSr6HM1cEVAEFAFFQBFQBBQBRaA0BGITyUdue8GMHD7KLLDAAmbxxRc3zZs3L+3JgdRTp041f/31 l5k0aZJpt0Rbc+gpewRi6KUioAgoAoqAIqAIKAKKQDUhEJtI3nT+/U4bufzyy5v55psvpw7ssvjP P9PMjBkzcsKjLuabr6lp1qxZ3u3p06ebn3/+2aCVPOPqo/Pua4AioAgoAoqAIqAIKAKKQPUgEJtI Xn/OPa7Uq622Wl7pR44YZSZMmJAXXiigdetWpk3bNnlRvvnmGxd29nXH5d3TAEVAEVAEFAFFQBFQ BBSB6kGgLERyQP/fDFrJldde1tasQcHaYWP501e/Oa1j16WXyotbKpH8999/TYMGDdxfXuYaoAjU EgL8HsaNG2cw2UBTjxa/Q4cOtfR0fYwioAgoAoqAIlA7CJSFSPb/dYAr7QmXHFSUwE2fNsPcf+3T pmHDhmbpZbrm1TINkfzxxx/NV199ZcaOHWsmTpzo8l5wwQXNoosuatZee22zzDLL5D2nXAEzZ840 b7zxhiPSaGs7depUrqyL5tO/f3/zyy+/uHitW7c2G2+8cdE05YxAW/3555+mRYsWZsstt3RZjxgx wrz//vuuH+y0006hJgzlLEM15oWJxkcffeRIpJQP2+JNN91ULvWoCCgCioAioAjMFQhUjEhOmjDF TLZ/QZk5Y5bp3evdshBJSNzjjz9u/vjjj+Bjcq7bt29vDj744BzbTjRFQlpXWmklA/FMI5MnTzY3 3XSTS7rDDjs44pomnzRpHnjgATNs2DCXFGJ++umnO1IXlleh+v7666+OhC+00EJmxRVXDEseGvb8 88+bH374wTlg8WwEYvv000+785NPPtlAcCslhepUqWfGyfenn34yAwcOdFHpV2DAsXPnznGSaxxF QBFQBBQBRaDeIFAxItmv73emX99vI4Fg3cj2Hdrn3RdyF8dGsnfv3ubrr792eeC8s8oqq5hWrVqZ adOmmdGjRztSw1Q3glZy//33z2pMhwwZYh566CF3j/Bll2VaPrnUFZGkfj169Mgp8HbbbWfWXXfd nDC5KFTfxx57zBEfvPGPOeYYSVL0KEQSknTaaae5+LVJJAvVqWjhKxjhk08+ccScPrnFFltk+1wF H6lZKwKKgCKgCCgCdYJAxYlkkyaNTePGTXIq16zZ/KaVdbZp3LhxTjgXcYnk33//bW677TaXvm3b tubwww83888/f05+aOvQjrGkEHL00UebJZZYwp2Xi4TUFZF8++23zccff+zqIv8KEcFC9U1LJKk7 WsEmTZpkNY9KJI35v//7v5plrNq1q1UNtfQDPSoCioAioAgoArWFQMWJJGSxceNGc+rTwLRs2cKR SKZiwyQukWSZoGeeecZlse+++5pu3bqFZefs9fr06ePuYbO35ppruvNCxCo0o4jAuERy1qxZBvKL 0wX2cqUIjhw333yz4dmQaNb0HDx4sMvyhBNOcLahwfwL1TcukeS52KFSl8UWWyz4CHcdRiTREGM7 2bJlS7PIIouUTUNXqE7BwpUT/2DewWshkny0rLHGGsHbeq0IKAKKgCKgCMw1CFScSIYh1Xrh1qZN m0XDbsXWSDJ9+NZbb7k89ttvP7PccsuF5jd+/Hjz5JNPuntrrbWWWWeddcztt9/uliuSaW9ILYR3 vfXWM59++qmLu8kmm5gNN9wwL0+e27dvXxe+5557Og1nIRvJQYMGmTfffNNNtcvzsJmjvDiohGll 8x4aCBgwYIB54oknXOhWW23lyOmrr77qrjfaaKOs44ski6ovpPrLL7/MWf+zadOmrk6HHnqoQev5 xRdfuGuew1Q2eOJcc+aZZ7p64eiEbeWRRx7pHucTSexS33vvPTN8+HDnjEQEtJfrr7++czzxPyZe eOEFg60mDlJojoPCs3Euwt71kEMOiWxDPiqWWuq/1QAqgX+wbMFrJZJBRPRaEVAEFAFFYG5FoGJE csqkf8yUSbn7cY8aPs70feVTq0FrZjp0DF8KJa5G8vfffze9evVy7QIx23vvvd2OO3Ea6vrrr7cL qP+TF3X33Xc3L730koHwtbPTkscdl7+W5f333++IEQTwjDPOcNq5KCL54YcfOiKFJi9MWA4G+8yk uwQ9++yzBocOljnCNpEF3CkD5YbUnXrqqTmPi6qvEMmcyPZCpshfeeUVRzSlfExjI0IkxUYSDWuY s42LHPFv6aWXNgceeGD2LmQforjwwgubk046KRsuJxBnCLSULapOvr1rpfCXMkUdIeB4bqtGMgoh DVcEFAFFQBGYWxCoGJEMA2jY4JHmxZ5vlYVIMlCjaRNyw/PQZqGN6tKli+nYsaObSg0rB1o1PL0h jci2227r0kFisKn87bffXDiEhjAR3y6THX722WcfN70cRiTZ7hHSCYlkShdHGMpEHiwNA2lC8BhH sxlXIMA8j/U4qStaPwRSDblGDjvssBwP4aj6QginTJnicEBrSF3R6DH9DiEVIukytf+Ylqbebdq0 cY5NcYgkGsStt97a2VAOHTrU5Skk3jdJSEoko+pEHSD5lcJfsIg6Yo+LRhKhH9K+KoqAIqAIKAKK wNyKQMWI5G8//mH48+WfqdMMZBIC075DjdOLf5/zuBpJ4uJMg30fpDJMIBUrr7yys1MLLu8TZV/3 /fffG6ZZEaaemSoWwbkFbRMiJCjKRrJnz56OrEJq0GxCwkTQHD766KPZ+2g2g45CEjd4/Pzzz81r r73mgtGg4qmOgJsQ49VXX93ssssuLlz+RdWX+1E2kj6RhBQdcMABbmpa8ixGJCH23bt3d0s9SRrI 5IMPPuguIdZHHHGEO09KJElUqE6Vwt8VNuIfdpj0H1mSibapzXVFI4qlwYqAIqAIKAKKQMUQqBiR LLT8zxLtF4/UFiYhkqCCIweLkaPhg6SgqQsKtnjYR26//fbZW1EkhLUpb7jhBsNRplElkazbCOnD RpAp5TAiyU4m11xzjUvGIuW77rqrZJE9UuaXX37ZXe+1116x12+87777nLYNW8OzzjorS+wg0zfe eKObakejSPl8+8uo+lKAOETy2GOPzXOwKUYko+r18MMPu4XMWR7n7LPPdhiUk0hWEn9X2MA/7GpZ CF/2msfkgGlt2p5zFUVAEVAEFAFFYG5FoOJEcoEFWv7npWzHVEgOJChKkhJJPx/IH9ogSBPTvBzF wYV4/jqLhYjViy++aL777juX9SmnnOLWpmQv8VtvvdWFYVuIBzgSRiSZVoXwIWhCmd4NCsRDNFdM /W6wwQbBKHnXo0aNMnfffbcLx24x6AzEjjKinQ2SuEL1LUYkaa/zzz8/rzzFiOSJJ56Yo4mVDHCS wmkJOffcc12fKCeRrBT+Uv7gEecr+oEIbYMzVVi7Sxw9KgKKgCKgCCgCcwMCFSeSaMVYS9KXhg0b WRu8BU1LSzKDUgqRDObF4I7XsCxazlI5TLUihYiV78gjJM/3EvdtEMOIJI4wOMTElc0339zgJV5M fAJWLC4LrON4IlKovsWIJMQI7WdQihFJtKKYMQTlgw8+cO1COM5CkO1iRFKmqn0tcVSdKoV/sB5y jSaSaW0+Nni22ICyCgDT+yqKgCKgCCgCisDcikDFiWQh4Dp26mj3Ys5dRDwOkWT6Gq9dHFkgTGjf Csk999xjRo4c6Wz1zjvvPDflG0VCyId8ZZ1GtEpHHXWUkWntoFd0GJH0iSh2gKuuumqh4jnHmGKE A80qZcI5BnJOOcIEMgOpYTof20vxuC5U30oRSXAL08qxHBLTwZTxwgsvdNO/xYgkDkZgHYdIVgL/ MKzDwlgvkyWTkK5duzrnpLB4GqYIKAKKgCKgCMwNCFSMSLLP9qSJucv/CGDfffaLGfDDYNOm7aLZ HVHkXhwiSVw8tvHcZd1D7OywV4wSHFtYTxDiwhQtcQsRK/IRssM5u+agEYNgBtdpDCOSvnc3Tiqs yRgUvM0pE4L3NfaChQQbUMgWwjaITNOHyRtvvGE+++wzdwubUNbNRArVt1JEcrfddgsl0WIjybJN 7MeNCJH0lxJyN+w/3+YxDpGsBP5SlmJHPnJwyILMQ6JxfFJRBBQBRUARUATmVgQqRiQLAfbhm1+a bz75qSQiyTI9LH6N+IQp+FyIHlspMrDHISGSPmhnh00jEtw5JoxIQjivvfZaR4AgrxBdbEN98T2i jz/+eLekjn8/eM4uPuzmg/hbPQbj+V7Rok0lTl0QSdbJhISDgYhv5+k7IrGgumjywMsn1r5ZQZw2 rAT+Uv44R12QPA5KGkcRUAQUAUVgbkCgLERyQP/fnLZurY1XNiaGk+qQgX+ZkUPH2O392rjtEn0g 42ok//zzz6yWkPRo3nCCYZkdNI6s58cUJ9ohWWsShxZsHhGmIO+99153Tjp2bgkuwXPXXXeZMWPG uDj884mZBIYRSe6xVuQ777zjojH9zlI95M8UNcsIsW0j53j3hu3kIvlzpPxMa6Pton44sRQSnIKY 4kbE4aVQfZ966im3qwxT5pSFaXbIn5DdtDaSPB+yiBaXcrNWJYSYsuHNDCmXZZGwY+3duzdJzAor rGB22GEH16fY7YbljsRpyieShepUTvxdoRL8UyKZACyNqggoAoqAIlCvESgLkRzx1wi7/MmkREBA JLos2TnPgzsukeRheMvK4s/ycAgQRBIPbl/YSYWtFGUKHGKCnaV4OROXnVaIJ+I7hRC24447umWE 5D7HKCIJ6WNBcmwzEeqLUwk2jmhHEbyhjznmmKIOGUxVM2WNbLHFFmbjjTd251H/fKccnHhw5ilU X399TPIUwlwOIhlVRrZJ3GabbbK3MVPAIz3YbtkIc058IlmoTuXEP1iGYtfsqMP0OoQchxsVRUAR UAQUAUVgbkWgLESSqcQpU6aaGRELgwfBg+y1aNkij0QSLwmRJD7b5kGcfM0h4SI4paBxhLj46ypy H49uyKJIcM9u39YO0ofzSnCKGm0h6zeCwc477+wWP5f8IEUQQNaM9AVSueKKKzqC5++c48fxz8XG k3TYFLZq1cq/nXeO5g8Siyy22GKGNSCRqPpST7zMSYdImtdff93069fPLd8kWyC6CHP+yTJJlIdl khDZB5w2RguLVla0o9yHyLPQO+0RFLTMmCyIBpn7tBlxwRIHHSG5kjaqTtwvF/7yrLhH9i/HNAIM 0IIXa6+4+Wo8RUARUAQUAUWg2hCITSRvOv9+N7XKFnlBMlWuSqEdxA4QsnHG1UfHzhbNFERy7Nix zgEHUgeBxJmDqWMIWJSwVAtEhzox4PtxWeycxcnJ37fni8orKhytJSQNrRvTxBA1thmsCylU39Gj R7u6gl1wmr+UspIva2aioaPuQUIfzHvcuHEGW0rsJNnzvFhZCtWJvGsbf+xRv/3222y16FNM4at2 MguJnigCioAioAjMJQjEJpKP3PaCGTl8lNNOMb0oy8qUCwe0UGhxsG1st0Rbc+gpe2SzhhhGSaF7 UWnihqMBky0RjzzySEdK46bVePMuAvRJ9mvH8YmPET5EMGsoZpIw7yI2d9Tc/wgN1qjQvWBcvVYE FAFFoD4hEJtIjhw61vTq8ULoFoTlrDDayIOO38O067CImy4mbwZiBmf5K+fzgnkx8KNBw8aOvash uHgfH3zwwcGoeq0IxEKAKXaIRDFNbKzMNFK9QYA2lz/MHBAllPWm+bSgioAiEBOB2ESS/MaMGGe+ eP8H8/svg51NZMxnxIrWokVz07VbF7PWJiuZRRdbOEsaIZH84aDCEYKHVEoTiac3Tia+sB5i586d /SA9VwQUAUUgFAEhi3wUQyD5gODInxDL0IQaqAgoAopAPUQgEZGszfpBFCGNEEgWpMZertAe3eUq G2tT4vCBsNg5jiGyqHe5nqH5KAKKwLyBANpobHh5l0AoIZdCNOcNBLSWioAiMLcjUJVEEhIp2kem mlkyB7tMjmF7N5e7kWTxcezaVBQBRUARSIMATl4tW7Z0tt+8t3AaEy2lksk0iGoaRUARqEYEqpZI oo1EEwl5xKvaX9+xGoHUMikCioAiEIYAjleshACZRDOpWskwlDRMEVAE6isCVUskmdJmOSBIJEv7 rLrqqvUVYy23IqAIzMMIsBQUS19BJllmjClu1UjOwx1Cq64IzGUIVC2RFNsiFstmK7x11113LoO+ dqojZgJi6F/Op7LeY1AWWGCBWrFlDT43eI1dGnUv9zJVwedU4lqWDGIqlHZTyUegmvtesLTsTMX6 qaxTK7beSiSDKOm1IqAI1FcEqp5IMmCwmPeGG25YXzGu03LLPtqlLKgeVgHW+2T/76DstNNObieh YHhtXvtlO+KII0zHjh1r8/ElP+uqq65yTmasFqCa+Hw4/fb171ZD3/PLI+fs+87GCOxipURSUNGj IqAIzC0IVDWRZA1HdqthofKNNtpobsE8UT3QzD700ENOu7bLLrskXhT9iSeecNsWrrLKKm7LwkQP LxAZrdmTTz6ZXYaJ3VyQsP3IC2RTkVs4S91yyy0u7/pMJHfddVe3o1JFQKrHmVZz3wuDlb3XcRZk dyM05Kw+oRrJMKQ0TBFQBOojAvWCSKKRnFd3BWHQvO6661zfOuigg0zXrl0T9TP2+h44cKBha8vN N988UdokkSkjZVUimQS18LiikVQiGY5PMLSa+l6wbFx/8MEH7gNQiWQYOhqmCCgC9R2BqiSSsgC5 aCSVSKYnkrXVQatpMFeNZG21enU8p5r6XhgiQSIpC5SHxdUwRUARUATqGwJKJBO2GCT3jz/+cH8Q FjzL0TS0bdvWLVGEg0SU9O/f37C2HIb3THUNGzbM7cnMlox4dK644oqmffv2bsmjX3/91WXDEkhv vvmmO1977bVdWsmfdS7DlkUaNGiQe47E40gZsdMqJoMHD3Y2qaNGjXJrebZu3dosu+yyrlyF0iYZ zKkTWOBENX78eGc7RtnQmpZDgkSSNgITwsGe+rRp0ybyUZRpwIABZuTIkW7qHuzY2YitMqMkbtv6 6XEI+umnn1w/YKqTZ4DB9ddf72wkozSSmHrQB8GPdFIn2ipK0pQvKq844Un6EU5R9HfqxSoN2BFS p27dujkv52LPS9L30rQtv1nwA2tsjfnAZQcsNP2E8VsmnKV9wuSdd94xOKExm8BvttxEkqXSKAs4 IjwD/FQUAUVAEagNBJRIJkS5R48ebi/usGQM5Pvss0/kS/z+++93JG299dZzA+bPP/+cl82ZZ57p CEKvXr3y7gUDcCLBBjAoDzzwgCMnfngxG0kGS7aGFALrp+V8k002KTg1Hncwhzy/8MILJszrloF2 zz33dEQi+Pwk1z6R7NKli4HU+MJADklbaaWV/GB3/v333zscILtBweFriy22CPWkjtu2sqA+Hw/Y mEJsfIFMQhKRIJGEMLz77rvmk08+8ZO4c0jMzjvvHFonIiQtX94DYgYk7UeQMvoDxCwoOKfsvffe kb8niR+376VtWz4qsDVGDjnkEPP4449nt2qVMvCRt8MOO8hlzlG2XIVs8sFZbiIJhu+99172me3a tTOUR0URUAQUgdpAQIlkQpRvu+02g9foMsssY3hhQwwgA1999ZXTTrJO3Omnnx6qnZDBXB5JWogO Wkym79HIQCRZQ/Prr7920XC2+fjjj905GkvWoxOBuIZ59X7++edZgvLjjz86TVwhIokm47777nME lrwhM0sttZQjTJSLbSPXWmutyIGSNHEGc7RNd955p6sfg+kaa6xhqAPPYJBH0MhBxksRn0iSD9qg 1Vdf3WlYaScGXjRJJ510knu+PAst7N133+0ucYogDeVEawjxQ6JsQOO2LW0O3nyQsD4q5QAHlobh wwIsRIJE8rXXXjO0LYLmGo0dGnL6Cstkkdexxx7r+qXkIcck5ZM0SY9p+tGzzz7r8OVZaNc7derk 6kKdyA/t2sknn+wW8Y4qT5y+V0rb+kSS3yq2wJQTUohWmfv8vugbYaJEMgwVDVMEFIG5BQElkglb EmLWxZI/0SxJ8h9++ME8//zz7nL33Xd3A4vck6M/mC+55JJO28I0ngg7YBDOzhcipTrbxPHa/uKL L8yrr77qHhmmeRw6dKgb3MM0eFLOOIP5c889Z8AP7dmRRx7pBmJJj2cr2jakVE9rn0hC7I877jhH 1MgbQnHvvfc6ArbmmmsalowREVIDeYSQCWlnahzPedJGEZskbQthfOaZZ9xj0WKJ9ogPiJ49e2a1 yT6R5Nn33HOPI1dotvDghzgilO+OO+5wJhF8ABx88MEu3P+XpHx+uiTnSfuRT+6oE/UVgUj27t3b XUaRd4kbp++V0rY+kQTzvfbay6ywwgryeGdGwkcS5D5MlEiGoaJhioAiMLcgMFcQSQZStBdxBJLA X5o0hfJHc3jDDTcYjltttVXoupcymLPINNowtFDFpDaIJCSJ5XvQDp544omhU7fFyllsMGeq+Jpr rnHZbLbZZmbTTTfNyZL2uOmmmxx+/n20vXHbFm0RmkSfSKLtY8rXl6efftppWbFLPfXUU7O3KB/l DNPe+sTmmGOOcXZx2YT2JEnbQpDIj7KivfY/HCDaEG7EJ5Jvv/2200xDwtFas4SML3369DHvv/++ y+v888/Pa8O45aO/obGNK/QZIbRJ+xFT9G+99ZZ7FFpH8hKhzdH+Q9Cwad1///3lVt6xWN8jQSlt 6xPJsP6UV6BAAJpk3jn0K6brOS/nQvP8dmTWgkejKWX2QkURUAQUgdpAoN4TSV6ihRxcgiAeddRR bno1aRoGYoQBjqnOb775xmnpmOZmehGBRCIsVYQtXVBkMGfq+LDDDgveDr2uDSIJAYY8rL/++mab bbYJLUexwGKDOY4haAJF0BSKCFEUu0QGQbQ+7LN+4403SrSiR7RE2NT5RDJsUW8GXYgZg/mFF17o iBBTlDi5IBBPCIMv2HSi9UP23XdfN63s30/Sto899phzjsAmlCWdfPEX2/aJpCwsT1wfO67Bj74n OJ5wwglZbSr3kbjlQzONZjGuHH/88VnHpaT96PXXXzf9+vVzpgcQ6qBgO4nJAyYkaJWjpFjfK7Vt fSJ56KGHuhmJqLKEhavXdhgqGqYIKAJzCwJVSyQZGCE3LEiO3VjUOpIQSX96uFjDQCQhBEnTYEOI swNOMIM95w20MaIdEiKEM822226bVxQZzIPTeHkRvYBKE0nwu/baa90Tt9tuu9RbURYbzCHfTC8i YOZr4Vyg9w8NFISQ9oecxBWm3nHW8YnkgQcemOfZ/uWXXzqHGvKFwGBDiYc2U8cI2i/K4EsxnJK0 7V133eXsI8PsQfkoueKKK9yjfSLpO3mh0SokmA0EvXbjlk/IXaH8/XtosPFqL4aPn0bORTOM1zNa 3qCwWsGnn37qfqtnn3128Hb2uljfK7VtfSKJBhtNdhJRIpkELY2rCCgCMstTX5CocyIpWhQfMAZT 7MXiEEnSoXGIK5A+BuI0aXwbMMggXrxMVck0FQQVzVUxIhl1P6wOlSaSkGMWwKYdttxyy9Q7CBUb zLH/xNsVSWIDST+IK7QDfz6RDNMe+kTynHPOcRptPlhwBEIgsb4NHGG+djRMYylELU7bSlzRoJK/ iG8C4BNJ8cSPsoGU9FFHeWax8vHbEw17VF5+uJDaNP0Im2Jsi1mKCc1mUEQ7CtEP01hK/GJ9r9S2 9Ynkueeem6cRlnJEHZVIRiGj4YqAIlAKAtVCOOuESIaRRx/MpETST1vJc5leDNOgUGYIGceowTru YO7XwSeSYdo1P27YeRxnm9tvv915eeMBzlRwGmFaGHIeRUaxdeQ5SBhRS/PMqDQ+kdx+++3NOuus kxNV7AmZIoYYIBBW2g9hep9pfl/QitN+CM4sEDpfkrQtjjY43LAuJdpDX/DkRmOJ+ETyxRdfNN99 910k6fLzCDtPUr6w9HHCkvYjnKtwsqIdIPTBl6L03ahlrqRMxfpeqW1bKpGknthDd7FOepDicttI ggOmI5B5BDzFUcwF6D9FQBGY6xEIvj9rs8K1RiSLkUe/0j6RZGAtNLXtp6v0OdPaLPzL4tlMkfvC sjLinQmRDLM1RKtEXaLu+/nJuRBU8MNTF01oEmGtQgZCDP2jSCLEhiV+GOBwAmKwSypMC+OFy5Tw fvvtl5ec8jPgMwWKbSCkuFICkbz11ltd9gzerP3ni5SVD4Kjjz46e4v9ubFRxPs2SPBYVFocGoLL BpFBkraFWHz00UeOODFV6uONw0zfvn1dmfz25tmUATn88MMN5CqJJClfknz9uEn7kf+bOeCAA3JM EPgooT0ggYX6Ls+X9ozqe8QppW35/fA7QiC8QRtVd6PAP1kRgQ+1SqwjyaNx6JF3bMuWLfOc2QoU T28pAopAFSFQDkJYjjySQFIRIikvtCQF8dP4RLKYjaQ8w08vYeU+Yj8m6/hhR8dakgjkkmk6mS6P IoppB3PxXsXuDYLKGnYynV6sjnGIJOtXUjYw5Bk4ujBljzDVigaP52299daRj0NjhmMEpgN4rTP4 i+ZFOjX2buKlu8EGG5jNrPe2TI3yHKY5mXbm+b4Hb+RDI274RJIoLB/DUj+IT8iYomatSBGmIKkr Qh0oI0L7Ys+H3S6ayKCDDHGStC3mD2gdwZs+xLqZ2IzykcH0v/QjNJKyTij4MPXOgt+0DR8F/k47 tCGmF+CPrWtQkpQvmDbuddJ+xEcFWkzqi50luGJ/CHnk9ySL4xcjznH6Xiltq0Qybg/QeIqAIlAM ARkPi8WLup8kfZK4Uc+LE152IpmE0EXFFSKJXRpEkgFqo402ilOfisahHA8++GDWhkymqZi2hWhR bqTcRNLXUpE/pAMCBqEMLouCN7Is7k1cMARnysdyMyKsXeg7MImWTO4zoNMJIWXUi/hME0cJC3bL +ox+HF+bRD49e/Y0rEuJUAfWZaR8LKgt/aF79+5ZT2A/r7jnQSJJOln3EzwQyBjP8Z1+IDY4taCV REgDbnJNXLx2fQLnItp/SYnayy+/nF10niV9cP6i3IIB+fpEkmumw/FklilMsCMt5aPsCHaXEPGg JC1fMH3c66T9yP+4AGvqhG00xBlZbrnlnJd8oefH6XultG21E0l+V3zkiqhGUpDQoyJQfxGIQwLL FadUlMpKJP1BMKpgheLIPV6MaCXE2UaIpNyPyrs2wvE+fuONNxxBk+fx4mZha+y9IEnY16HRCsrD Dz9c8H4wvlxDHCCHaEOZ6gcbhGWEgtO2EBSWJiomYWVEA4SnLGv3+YK9FdrIsH29/XjUna3asNcS YrPyyivnTKnTtkzrohkUsiB5QNwgDthZJlmeSdLLEa0dU5kI2jnahTARcINs+cRa7kE0X3rppbwt +9CYsdA80+FhkrRt6ctoZ9EiggkCsQZnyBjYoHUEP18wH8CEgq0mfeGFwnQ39qBhe5YnLZ+fd9Lz pP2Ivs1vCntgEUjluuuu65bR4ryYxOl7adsWjbQ4ijG1DXlPIjK1jfab3xLtHKdOcZ/BxzaEXIRN DYLOYnJPj4qAIlCdCBQjhYXuF7ontY0TR+ImPZaNSBYjeWH3w8KoAMRJiCTTgEz5iUYyKk3SipcS n7JB6Bj4mIJNuhxIKc+ujbRC4MEarWsp08yFyosWUrRwaKJwSKhUZ0drxRQqA3kYgQyWEyIHaQMD tJei0QzGK/Wa6XKeQ71ZL9HXkBbKm/LRBzlCusGuFPJd6Flp7yXtR/zW6Q9oZ2mnuFgkLV9tta2U iw8Z7KrpR/S9chPJ/v37Oztongdmm2++eWI7TimrHhUBRaD2ESg07kXdSxoutYpKJ/fTHMtCJKPI XdzwYLwoIhmMl6bCmkYRUAQUgdpEoNJEkh2CMK9BsOFlD3YVRUARqF8IRBG8sPBgWPCamoeFCSKF 7kmcJMeSiWQUuQsL98P8c4gj2iI0fPxxztQo52it0NgEdxpJUkmNqwgoAopAXSGAdzprZYrWGK1h uaa2eY9iKsI7lHyxz0bjqaIIKAL1D4EgweO3zCoRzDbxx2yNP1MTjF/sWhAJxpPwtMeSiKRPBv0C BMP9a/+cKWLse7DJ88PFRlKIJNOSEEk/jv88PVcEFAFFoFoRqCSRpM6QSN6NDA7+IFOteGi5FAFF IB+BKHLnh3OOKR02+/4HYzCOn7t/L064HyfueWoiGUXqguH+tZxzxNOUrcsgjROnNzW//NXc/Dgk Y37+c6YZM2G2mTKtxgEhbkU0niKgCCgCioAioAgoAnMLAi2bNTSLLtTILN+xiVmhYwOzTNsppnXz mW5GA5t6fBh8oijnchQcgtcSzrHQPT9eofNURFIIYTBjPzzsXMKw50HLyPXnf7Q2b3492/ww6D+P zWC+eq0IKAKKgCKgCCgCisC8jMAqS81vtlqtkVm3y98OBkxmxBlWCKEciRB1HsTQjxe8F+c6MZEU MhjM3A8PO5cwlmHBC3vazAbmzR9bmyfeq1mzL5ifXisCioAioAgoAoqAIqAI5CJwwBYLmK2WH29a zJdxK0KwBCEihFCOfljwnGsRP76EJTkmIpJCBnnAn3/+6Xb6ECNQWDGF8ePIOUf+sOUZPHiwO/b+ ZmHzRJ//1vZLUmiNqwgoAoqAIqAIKAKKwLyKwAGbtzS7rDbO2UV3sVsBYx8NB/NJoZzLEaz8cx+7 qHA/TtR5aiLJosl4V4vAiNlSTgxAhTxyXwglC1WzTly/wa3MzS9OlaR6VAQUAUVAEVAEFAFFQBFI gMDpu7cw63QZ73YEY3tjRAhh1NGP4xLM+Sfx/bC457GJpJBByZjdHpimZhFh2TWEfYP5C5JIrll4 edCgQWaSday5/Y1mahMpQOpREVAEFAFFQBFQBBSBhAhgM9l966mmVbOZZkm7o1WTJk1ytJKQQ58g Rp3LY/37EhbnmJpIkjkEEYqbbWkAAEAASURBVK9rtJOs+8juDauttpp7rpBJjgjL/LATx1dDFzE3 Pl+z37G7of8qisDSSzQ1iyzU2IwcP8sMHlGzf3E5Hjh/04Zmu7Vb2k6am9vXv00r63Nyc4931bRx A7PRyi0MRev361QzaWr9WQEAPDe2ZW/SqIH5YfA0127xaj3vxKrmvjfvtILWVBFQBKoBgTP2aGHW 7DjWLQnEjmCITyCD51LmMNIYFibxCx1jEUkhg8GMJJx9k9FMYifJHs5BEsk1NpVMhff6dFHzej8l kkEsC103m6+hI0X/zPjXYlsoZv69Fy/rbJbpMJ/54td/zGHXD8mPkDJkVfsl9PgFnfJS3//qOHPb C2PywmszYLWlm5le53V0jzz7vr/Ma5/VH4eu1gs0Mh/c2tWV/a6Xxpq7e4+tTejqxbOque/VCwC1 kIqAIjDXILDDOi3NgeuNdouVd+rUKauBFAIp5DB4BAAJ88EIC/Pvh52nJpJCIsn0s88+c8v5QCTZ WUHu+YTyt99+c9rLC55eyAweWT7NWFil5qawLu2amleu7uKqdN4DI8zLn0xMVL0skexvieR15SOS 7RdtYq45ajGnkUQDuGKX+V25lEgmap68yEok8yDJC6jmvpdXWA1QBBQBRaCCCHRZrKm5cu+/nbPN 0ksvHaqNFHIYdfSLJ3H8sGLnJRNJyGK/fv3cNoZhGkkhk/3793dlOfb+lrrYeLFW8e4va7WJL1it InLpIyPNc+9P8O4WP73Wkr1unec3n/8y1Vz1+KjiCVLEaDF/Q/PZXUu7lEokUwDoJVEi6YER47Ta +l6MImsURUARUATKhgCLlt9zVM0KOMsuu2yWSEII5Y+HBc+lAEHiGLyWeIWOqYikaBzJmHPRSLZo 0cJssskmOVPbQiQHDBjgNJKH3FWz3lGhQum9/xAolUj+l1PlzqptMNep7cq1dbXlXG19r9rw0fIo AorA3I/AoydMdrvd4OwshDHsCBJCFINHQUnC5TrOsSQiKYTy66+/NkOHDnXP23zzzd3m4tzDEUeI JBpJzg/tsUCcclVtHEjKZqu2MKt1bWbatW5sGMiGjJ5pBgyb7mzx+lnNX5Scuueipm2rxuZz6wDy pZ1q3nG9Bc2GKzY3ndo2NSP/nmX6fDPZPPzGeLPU4k3NgVu2ctm0tc9Yb/nm7nzA0Ol2C8np2ez/ GjfL3PFivj3isTst7J6TjWhPfhky3Tz7f4W1mWjDDt2mtVmu43ymq3XSadywgRk2dqb55Kep5tm+ E8zoCbP8LLPnSQfz1S2Gu224oOnWaT6z+MJN3DN+/mO6uf/VsYY6lSo+kbzaamE7tGli1lquucWk kek/dIZ5/7sp5vF3x9v+GP6kPTZeyGxiHV7AYObsjNuy85vf/jEPvjHOTJ8Rnihu2/4z/T/Hnw1s 2/OslZec3/5WjPnaPuP1fpPM3ae2dwULs5Gcr2kDc8jWrV3/W6ZDU1eH/rZf9Plminnhg+j2TVO+ cHSKhybtR0xVH75da9PN9jv60r8W4l9tf6U+X9jfSSFJ2vfStC2ekftt3sqV66ZnRpv1bbvhEEWf +tcWFvz53X41oHBZC9VD7ykCioAikBaBR46f5AhimEayYcOGLlufWBIghFGO8uzgtYQXOpZMJCGH LAX0008/ued06NDBdOvWzc3X+2RSNJKH3b1gofJU/b3vHljWWH4VKgyAd/5vjLnvlXGh99+/patZ eMFGbsDpYAdPSGJQ9rvyT0fkLju0XfBW3vUIS7q2OmtgXnjfm5ey+3Pm5s2AXMhGcvPVWprLD2tn IAFh0vfbKebE24eF3XKDf9yp7RN3W8Qcs+Mi9uspP6sJU2ab03r8ZQqR8fxU+SE+kcy/WxPy1heT zJn3/uUInMRpYm09bzhmcbPVmuFac4j88bcNCyW7cdtWtgKFmJx/YNvIvkSZgkQSYntz9yUcwZUy +8ewOsn9pOWTdEmPSfvR+is0Nzcdt7hZsEV+v4Nc3/zcaNPzzfGRxYhLJEtp231tW110UFtXBoj+ 9uvkfwx/YD9Outu+oaIIKAKKQG0j0LP7xByNJOTRJ47+OWWTazn3y1srRBJyiPjHWbNmme+++85t fYgWEmnatKlZaKGF3HJAxBUiefg9C7n79fUfRBL56IcpBi3a+MmzzZLW2HVXq2Gbr0kNw9zfksHv Q/YOl8Fc6j75n3/NZz/b5WnsEU/UJa0mEiJJ+I7r1gxWaGt22aCGfEOw0GSKjLZazGdCtIyHbds6 SyT336KVK1chIrnYwo3NK1ctaea32i4ErSdau9lWG7dK1/nNRiu1MOUgktuuvYAjDTyDbvLSxxPM HyNnGtHyEs4yRTueP9hMsx7qaSVIJMET21I+APbZrFW2nudYj+5XPY9u7l18cA1hQPP4wocTzIxZ GbO1JZZLLNLEFYf4pAtK3LaFSKKVfvM6u+aXJa4I5OTPUTPdc9BGi/hEEuL9/CU1HvjcH/jXDPOG TdfYLhO096YLZT8ArnlilNW21uzDKvlwTFI+P12S86T9iPq/ds2SVitd89GD1veb36eZxewH1nZz yBofZ7teNNgMsvUNk7hEspS29YmklOGnP6ZZrekMS4AbOu31p1Zrr0RS0NGjIqAI1CYCDx9nxzc7 SMjUdiEiGUYiffLon8etQ1GNpBBGyVCu/SPnLDaOZnLq1JqpXQhlq1atzDrrrONIpxDJI+6tmbKV /Orbcef1F3QaxWFjZuYU/agdFjZMHyJRDif+YP6LJWsn3jHMoFVEIDmbWa3gxz9OzSFRpdpIxvHa vt5q4XaYQ1xf/HCic+qZzQg+RzZZpYVZ2Goq//dRuMd4nMEcz+5X55AGSOTRNw91JFqegcaHARu5 7qnR5rG3o7VQkibq6BNJqgGx/9GuyYigAbv/jA7unDbY67I/3DnrN751/VJZUsNSSSyZhLSx2t1n LunkjuS34/mDzBBL/HxJ0rZn7N3GTeWS/qHXx1mtW415woLNG5lnLu7kpuK55xNJnwh9aD9iTr5j uCO5xIPAQcjAGK3uxqf87qZhuSeSpHySJukxaT9imhktOEK/R9s7y368IMfvuog5fpdF3Hnvjyea 8x8c4c6D/+L0vVLbNkgkg2S9Y9sm9vfR2Hz7+38fecFy6rUioAgoApVC4KFj/44kklGkkrIIaZSj lC94LeFRx5KIJASSv+HDhxvsJCGPzZs3d1PbON6w9yNbJhIuRPLI+1pHlSVVODZj2621gAUkXvJh Y6z2dNA/idNg1+gLz2MaGJIBCVzCag5vO2EJFwVbxMseHelHd+f+YH7g1UNiDTy1QSQ/vK2radWy kZloScg25wxyGtG8whcIiDOYr9B5PkuSOrtcvhs4zVxiPdBFaLpOdjC+dQ5+aNqYdk7TtrSTTyTR HB97S+6UI+WgPLbrmjWPG+AIGe3Yx5oEIGFrbp5giU33OcSGslFGX5K0bc9zOpq1lm1mIOubnzHQ jJs4O5sVtoIQTcQnknee3N7Z5hLe/Vb7AWI1t4h0+4usJhXbU2TnC/M1eHHLJ5pxl1GMf+98NTnb X5L2o0sOaee0qTzm8OuHOttheSR9ChMN1lBFG0mdwiRO3yu1bX0iGdafwsqlYYqAIqAI1BYCEEnI X1AjGUUiiSt/lDFIHIPXxeqRiEiKFpJMhURy/Pbbb82QIUNc2Lrrrus0kYRDIOUoRPKo+xcuVqZE 91m/8OmLOsVOA4lhGZykaQ646k/3DNZswpllG0teZSo7+HC0ehc9nK9BkcEcbea2lrDFkUoTyYWs bdpHt9csgP2mtRs84+78adti5YwzmGNXdsOxixfLyt1nivOga4a4tSnTtJNPJHFGujdgs3reAW2z zkw7nDfITSv7i1zf8/JYa+uauxA4Dk8PnFmjyUSDiCbRlyRt+9b1S7qp8jCC5JfDJ5KvXNXF0Pfi yNE3DXUOUn7cuOXrcUp7gwY6rhxnSToa0jT96N7T2psNrdkEhH61YwY4Yu0/99FzO5o1lmnmHJzW 7D7Av5U9j9P3fEzTtK1PJNGMoiFVUQQUAUWgWhB44OhxWY2kkMfgUYijf6T8Qhrl6IfFrV8qIgk5 RDjyJ8v/YBe52WabuXs+iRSNJHHLTSSXaT+fefHyzu6Zcf6hsbr68dGJ06AxwYbxifM7mQWaW4O1 OQIU2POBSHOrPUHe+XKyObXHcHfu/5PBHLvII28c6t+KPK80kVzeek4/a23vkF7vjDfXPjk6sixR N+IM5kduv7A5ba+aqX/yifJ+5t73dhoax6A0bUs7+UTyil72o6FPrs3gxQe3s7aSNba6h1w7xJkq bLlGy6xG+ZonrZ3hO7lp8GR//tJonJK07Vf3LuOmobGLhMj60tkuQP/qnAXofSL55T3LZD9cCmFH XifdOcxNFfv5xi3fzd0Xdx9JftpC52ICkKYfsT4q/RtN+AYn/573mNtOXMJsuXqN49P6J/0WutVl nL5Xatv6RPJQ2y99O+W8QmuAIqAIKAK1jABEEiKIRhICGSSRcu2TSCGOwSNFl7C41UhNJH0yKUQS m0g0kkES6RPJox+osXuKW8A48ZgCjSvWL8hpPtKkwZ4Luy6EpXp6vDTW/DZ8hplpHTJwevjKDva2 DYsSySiiGVaHShNJnHlw/ECiNKlh5fLD4gzm+1iHkIvtVCaSRKuTpp18InmjXa4l6PV7uiW0R1hi i+xxyR9u+RbfdpItHrFz9cXPEw1ncNklIWpx2pYtEDGLwKlp7zk2mvIsn7D6RFI88ZNosyVPjnHL 18jaaVhrlNgipDZNP3rMbmPJdDwOTWscm69xxJaVdsEulftiP+kXLk7fK7VtfSK5u+0veO+rKAKK gCJQLQjcf9TYPCIp5FGOQiLlmrJLmJxLfWqVSIpG0t/ZRpxrII/+n2yReMyD/2mlpND15dj7yi5u jcex1qZtyzMH5gxs7GeNYwsSRSbiDuY+Hj6RDNOu+XHDzos522Df+YUlwDhqMEAyUCYV7Ng+77G0 S8YWjmzlGJS17Zp7D59dMzXM/tGQpEqJT/rwar88YK966/FLZJf4EU2XrwnEqejCh3LrwLqXVx6x mCvyxT1H5q3ZmKRtma7HJANN3ManDsyZ0t3WmkzcZLWCiE8ke55t7SqXs9O8MzNmQ6u9S+rVnqR8 7uEJ/6XpR9dZJy9ZnWCbsweZ4XbNUl/4wIGg4snP7y1M4vS9UttWiWQY8hqmCCgC1YLAfUeOcVpI tkiEKPp/kEIhj0Icg0eph08g/XO5H3UsqJEUraMkFuLItZxz/PDDD83ff/9t2CIRIhmlkST82Idq HAkkz/p0ZM9r9r6eZpeG2ch6xvqDOVsR7mQ9upFyEkmWncGmDnnkrfHmhqeTTT0XI5LkK84nnJ9m p+TftlPzvmALyjZMEOgo+fTOpV0cyACkICisn9n3pq62QxszftJss925g0K3ysRzeeLU6OcE8w27 9okkXsxbWIcWCBiCLd97Ny3lpolZugkPZwQi3c+SYTTLU6b964gLywaJiIMM10HHEMKSEDXfu5m1 OVlaSeQu61SzqV3wHvGJpG/XeYu10XwwYKNJfLDFvMIvN+FIkvLVpEj+P2k/Yk3R43aumaHoYT8u 0PCLrGttUh+cY5Ma5vwk8TgW63ultq0SSR9tPVcEFIFqQ+DeI0Y7shg2tS0kUo5hJFJIoxypn39e rL6xiaSQSv/I+ejRo91e25DE9u3bmxVXXNGRTF8bybk42xz3cM06fcUKVo33fc9ZPLMftzaFU6dn 7DRpa7fzhZS5nESSqcav7l3acITgPGHXCMRzdMLUf80US3SCWhyIGGvbiTx0Vgfn2MHuGyff+Z/d 5t+WRAnhYKce6oYwzQhReefLSVbjaszKdn1LpoIHj5wZuSA56R6xnshrWk9k5IPvp5jnLD6Ulx17 ZA3A8/a3Ti5b1Szxw05A19tlfn4cPN00n7+B29UEs4HNVm1pvazznUVcxjH/+USSJOB19ROjLYbG XGbNE8S7mYXjb/d2BrrULgK/1yY1pgvsMnP5o6NcHVjaSWwqWb9xN7uuIdOtviQhamgW0TAieGyf bdelHDhihtnfLn909I7/OaP5RJJdlHC4QQOHt/dDr4+3pggTzDhLyjvanXs2sjutsETQiHEzzcHW USkoScoXTBv3Omk/QtuIPSjknWlrdiF6z+7Qs0z7puYa+2Emi+qDz2veep/B8sTpe6W0rRLJIOJ6 rQgoAtWEwD2Hj8ojkqKVhBAKiZQjYfJHPYQ0ytEPi1PP1ETygw8+MBMmTMjRTK666qqmXbt2ORrJ 2bNnu2uZ2q7PRNIfKIPg4nRj28ZJOYkkGfq2mTVPqPnPdoJbB3a2EbsyP17Y+Ruf2yV27vnPQ9vX koXFL7QgOfF9OzQ/PYRMiA1OSk9d2Mkw1VhIxBO4UJxC94JEMiwuBG7Xiwc77ajch9jgUIP2NUwg j2hs37VL3gQlKVGL004+keR5B9jF5c+1HudMI0cJqxLICgN+nKTl89MmOU/aj87dv405aKvoJcF+ sov+73fFH3nE3S9TnL5XStsqkfTR1nNFQBGoNgSESDK1zbKLQhiFTMo1RNE/px5hhFLC49YzFZFE E9mnTx8zZUrNlFyzZs1Mx44dTefOnUO1kb5GsnvPGoeLuAWstnjsFMPC4xj5izB9euvzYwyeyezr HLWA8hvXLlnwvuQXPDJduafVlOGwQv6yI0rY8jG+1jSYj38dVkaeQd1a2zUlfYGw3mk1dy8VWfaE ZWNYaxFva9klJ7ju3vxNG5rT7DP2snUJLp80yWpZ/+/byVZLODZP0+qXp9i577CCjeQOdukhnxyy jzPa2eCi8uQLvpAh9lf2ZZS107vA2k2y73iYJG1b6n7F4Yu5HVyEGKKVQ9ONVtRt6WfNGDBn8AWt L17nbJcYFBZdZwefsD3Vk5YvmHeS6yT9iI8v9nc/abdF3bqh8hw7iWFe/nSiudJ63fv7k8v94DFO 30vbtmxCgIaUj8UdQhajD5ZFrxUBRUARqE0E7j5sZKRGUohj8CjaxzolkjNnznSaRhYch1jyJ9PZ /nlQI1nfiSSdA2K3lB3IUQxBfgaPDN++rTY7UjmfxRZ+aHCYvWUK/M9RM2zblvMJNTv5dGzb1BE8 SN5IS1aH2vU1wzxzS30yRK2bXebIfnuZMRNnGUhhMcGWku0KZ1pyN2bCrOwORMXSJb1P3dliE23n 73YFAN/utlBeaHe7LjGf28aSdho2eqbbrrNQmtq+l6QfYd+J/TEfaGDx2/DpBZeIKqUutdW2pZRR 0yoCioAiEBcBIZK+RtInjv65aCXJW0ikTyrlmRIm14WOqTWSQh79oxDJsKPYSB7/SI3na6FC6T1F QBFQBBQBRUARUAQUgeII9Dh0REGNZJBI+gRSznmKTx7982IlKBuRhDz6mkifTKKVFBtJJZLFmkTv KwKKgCKgCCgCioAiEA8BIZJBjSQEUv4ghkIohTz6R54UJI/B66jSlJVIhpFJf2qb8xMejbdNXlSB NVwRUAQUAUVAEVAEFAFFoAaBuw75yznZyDqS4nATRiKjyKRg6ZNH/1zuhx0rSiSFREIwZWpbiWRY M2iYIqAIKAKKgCKgCCgCyRGASEIQ/XUkhUT6R4hhnRNJpq4R3y5Szv2pbMJ8Esm5TG0rkUzeSTSF IqAIKAKKgCKgCCgCYQgIkSw0tS0EUo6QSv9P8vW1kP653A87JtJIRhHJsCltn1gqkQyDXsMUAUVA EVAEFAFFQBEoDYE4RBJSKNpJn0AKWQweKZGEFStdxYmkaCZlavvEx5YoVia9rwgoAoqAIqAIKAKK gCIQA4E7Dx6eM7UdtJEULWTVEknRRqKt9LWQch4kkptttlkMWDSKIqAIKAKKgCKgCCgCikAxBPr2 7ZtDJCGMQTKJdrFeEkkhkZBK0UgqkSzWJfS+IqAIKAKKgCKgCCgC8RAII5JBMilE0j9yzh8SPPph LkKBfyVPbRfSSCqRLIC83lIEFAFFQBFQBBQBRaBEBOYaIimEUqa0OQqR5Che26qRLLHHaHJFQBFQ BBQBRUARUATmICBEMsxrmylu0UKipZRzjvJHNpz7x+C5uxnxr8Gvv/5as6ZPSATx0uYW52HXQiDl vhBJroVIEvbHH3+49Pvtt1/IkzRIEVAEFAFFQBFQBBQBRSApAk899ZQjgp07d87aQYo9ZBh5lDAh jzxPzuXohxUrT9mmtoVQCpHkKERSNZLFmkHvKwKKgCKgCCgCioAikByBOtdIWs1hYo2kaB85+gRS roVMKpFM3iHqU4rp06fnFbdJkybuiyjvhgaUjAC/p1mzZuXkw5clmBeSam6ntHUqVF+9pwjEQUD7 XhyUNE59QECJZH1opXpcxksvvdS8+eabZu+99zann3562Wryzz//mNVWWy0vv5tvvtnsuOOOeeEa UDoC119/vXnwwQdzMlpyySXNG2+8kRPmX9RWO02dOtWst956znzlxRdfNNjqxJE0dYqTbznipK1T OZ5dah7PPvusufzyy023bt0M5yr5CFRz38svrYYoAtEIKJGMxkbvWATQ8h5//PHueO6555ouXbok wuWMM84wr7zyijnwwAPNxRdfnChtochouQ4//HBXLuJ99913Tlt20003mZ122qlQUr2XEoEnn3zS 9O7d26UePXq0GTJkiOsPfChESW2105QpU8waa6zhivHyyy+bZZddNqpIOeFp6pSTQQUv0tapgkWK nTW48hFJO9AeKvkIVHPfyy+thigC0QgokYzGRu9YBDATWH755R0WGNSuvvrqiXC58cYbDZ1s5513 Nscee2yitEkib7755mb48OFGiWQS1NLHff755835559flEgGn1CpdioH6Upbp2Ady3VdjjqVqyxJ 81EimQyxaut7yUqvsed1BJRIzus9oEj9SyWSRbIv2+1KEZSyFXAuyyjtwFepdioH6Upbp0o1bTnq VKmyFctXiWQxhHLvV1vfyy2dXikChRFQIlkYn6q8y5Riv379zF9//WUmT55ssFNjCmmVVVZx2xJF FfqHH34w48aNc/E7duxoRo0aZT744AO3688SSyxhtttuO9O2bVuX51dffeWygUiKJvHss882yyyz TDb7RRZZxKy44orZazlhF6G///5bLt1xscUWMzyzmPz555/mxx9/dGWaOXOmS8Pan5SrkCQhKNTp m2++Mb/88oubnu3UqZNZddVVzQorrFDoEanu/fzzz+aLL75wbdW4cWPTpk0bNwUbhpv/AKaEKSNY 0t6LLrqo0wxvsMEGoc5EcdvWfwbnlO/777834E7Z0D6vueaaBfsR6dIOfHHbacaMGa6Ps/7ryJEj zQILLOD6+EorrWToS0EJki6w/vTTT82wYcNcH8V+cuGFFw4my7lOWqdK96NS65SmbdP0I/oO76OB Awea5ZZbzqy//vrm3XffLTq1jXnE119/7X6HLPlB31t33XVdW+c0zJyLSZMmufg4eG200UZuVQ7S f/zxxy4G779NN900u4xIWB5JwpL+Bsk7DeakS9r3wOLzzz932PGexCYY047FF1+c7EIlTduGZqSB ikAAASWSAUCq/RJSR6OFCQTgtttuc4Qg7P6hhx7qBtcTTzzR8PK59957c6LhfQuB/Omnn8y+++6b cy/sYpNNNjH3339/3i1sF+XlLjeL2Ujy0r799tvNQw895KbTJR1HFjS95JJLCpYpLkEZMWKEOeus s9zA5z+D84MOOsicc845pmnTpsFbqa4vvPDCSEeDI4880kDMwwQCed5557mBOXgfMo5NIpj4Erdt pW4QtWuuucY88cQTfjbufJ111jE4LUEsoyTpwCf5xGknSMkxxxxjcNQJCuW/6KKLzD777JNzyydd Rx11VF4/goj36NHDfTDkJPQuktSpNvpR2jqV0rZJ+xGOTbQH7xORBRdc0H2UPvPMM5E2kk8//bTr f8E25oP2lltuCXWk44OM9wjSp08f58A3ZswYeaw78m476aSTcsLSXCT9DZaCOeVL0vcgz6eddpr7 OPXrNv/88zs79D333NMPzp4nbdtsQj1RBIogACfhA6/OFiS3zhyxl/8ZOmqCef+L38zPvw8xUyZP NXaJ8hpnC5tFTTY1R84zVuuUyfBXs0TQhLEj3fUDN58fCglfxI0bNzJNmzQ2jRrWrLAeGrGOA3fZ ZRczePBgw4CMFhKtIBorPCMnTJhg0K7hRRskGhRbXiRoDexC8E7LB2ngxY8W8Ntvv3V/EydONNhD IuDHAIzsscceOV+8aEKxfQwKZUE7gbz33nuuvMWIZPfu3V1c0qB1QzOBVglSS30gB4W8vuMQFLS3 aF3RhDRv3tyRkQ4dOjgtAgMiGiZIME5FpQraMPBGtthiC2dbyjN///138+qrrzqHoDDnI7QGkCSW BllooYXMrrvualjkFftPsBw0aJAhTnDJnbhty2CDXH311eaRRx5x55RvrbXWcv2IwZ9nozF94YUX 3P2wf0kGPj99nHZ6++23DYQA7TfaLfo0yw6hPf/oo49cdtdee63Zfffds1n7pIvA9u3bu/5KXeiP tHmLFi0MLzz6e5jErVNt9aO0dSqlbZP0I5/Yoc3fYYcdzNixY927QwhimLPNAw88YG644QbXBPQ7 +h9E7H//+597V/A74WMpOAvhP2/llVd2mnTeX/QTZkDef/9997HJh2IpkuY3WArmlDVu34M4b7nl lmbatGlulmKvvfYy/Kbfeust964kr7vvvtthyrkvSdrWT6fnikAxBOqaSEJUIsUO7JYP1vwNGjY2 c8a1T2ZOvapX5pSrHsuccuVjmZOvfDRz0hWPZE66vGfmxMsetn8PZU649MHM8Zc8kOl+0X2Z4y68 J3PsBXdnjj7vrsw+x1yc2fvoCzMTJk0t/Df5n8ys2bMjy1TXN+wLNjN+/Pi8Ytgv9Ix9abs/+0LN u0/AIYccko1jNZsZOz2SE88O0hk7YOeE2YE4m8ZqK3Puxbmw5M+lv+yyyyKj/9///V/2GVbDmRfP vtgzllzkhfsBdvrb5WE9RP3gnPPrrrvOxbGDV8aS8Zx7jz/+uLtnp9fy7uVEjHlxxBFHuPwOOOCA vBR2kA19Bn3dkkiXbptttslY8piT1g62GatFzmsjIiVpW0uqMnYa0D3niiuuyHmGJe0unL5kpydz 7vkXzz33XLacfnix8zjtZHehylgiHpqV/Zhxz7XLSeXct+QuW247jZ2xGsPsfdrami64+3fddVc2 PHgSt0611Y/S1KnUtk3Sj6xW3WFqPyYzdqmiLJx2NiLbFnYFhWw4J5TPOuy5+1deeaV7v0sE8rAf Gu6enRmQ4OzRTuVm87VEMmMHr+w9Tngv8q4oRdL8BkvFnPLG7XtXXXWVw8DOPmWsSUG2qmBnSaW7 Zz+wsuH+SZK29dPpuSJQDAH4B+O4NSVy715rNpexHz0Za0qXsQqujFVOZXif0U8Z/+wMZIbxzM5k uPEM3gHX4E84H8e4EptIXvfQW45EXnh778xtz3yeufflHzL3vPx95u6XvrV/32TuevHrzF0vfJW5 4/kvMrc/28/G+Sxzy1MfZ25+4qPMjb3ez5x9Q6/MWdc9mpkybWbo3+R/ZmQmTp7mSObkqdPilt/F AxT7hRjrT4hamjSFCkWDrL322u5FYg3dQ6PKi4RBlZdfHKkNInnccce5cltta87AEqd8EqcYQaFT CpmwmjhJlj3Sfla74crRq1evbHjadrJTsy6vww47LJtXsRMGQfkY4IMhiSRpWxm0IM1h/cBqllw5 wgZzKZPkAeFNIsXaqVhe1vTBlc1qrXOi+qTLaitz7nFhzQhcOqvhzbsnAXHqlKYf8ZuP+34gnkia Okkd0rZt3H7EgCB91U5TS5GzR4g+94NE8r777nPhVtPsBpJsgjknfEiSjo+BoPhEMqyN/fhpMU/z GywVc8oteRT7PVkbUIdP2If566+/7u6B39ChQ3043Hncts1LqAGKQBEE6ppIxt4i8awb7JSbnd5a evkVnQ2brVfN1LadjrQTsHZa0s6QM43NdLab1iZstj2vOY76608Xfukp+0draW16+wJi00ezYIua KcDoyDV3mJJhmiWusDA3U5pJ09iv9+wjcI5gKoQpbRwRxD6J6U/Kc+aZZ5qjjz46G19OZGqDqSSm P+KIHThLWv4nzjqS2267rZvSOvnkk80JJ5wQp1h5cYpNmYINcRDMAXC8oA+JcG5fvsYSRzc9xmLK adpW2om182gHBFvSrbbayhnDL7XUUqFmB8RjvU3wwiyBNg4zTyBemCRpW2xRrWbOdO3a1bz22mt5 2V1q1//D65Zpw8ceeyzvPgFxp+KCiYu1k8RnapQp6S+//NJgjyjOW5bAOCex+eabz60dKvH9aWDq Bt6+YJPH745pbZwUwiROndL0I5aksgQq7JGhYUzRtmvXzqSpU6ltG7cfYaLBVDZCv/Wd8AizWltn p2pJTc46ktj+ismEpJHfIUfaFydC5MMPP8yx0/WntsmjkMNaWszT/AZLxZy6xul79qPejRscb731 VrP99tuTNCtMe2+44Ybumt8tv19f4ratn6Y+ntOPpE9htxdHGOcwb/P3eY5KR1wkbt5R+cxN4XU9 tR2bSJ5+7ZOOKK6wml3H0HHG/4gkP6zx1huZwYfBf9ZMSwbn2EfSWBDQ8WOGu4bvcdUp8ETTIKKD zZpjNL5gy2ax2jkN2SiFSJKWQVGEzix2b9SfH1CUwbm8SOyXqbngggski4LHShNJ2g5vSwh80O6t YMECN4sRFJx/sH9EsL3kL0p4QVOWNG0rRJK2wCDefqnlPAabTBZ432233fKIIgSIQQn7Puwhk0iS tpXBHDvURx99NO8xd9xxh7nzzjsNZcX7NkziDHxh6Yq1E2mw36U+dqoymwXEEWJNP6FdJJ5E8ElX 2Hqn2NzxoYLgSNGsWf7vO06d0vSjtKQmTZ1Kbdu4/QiSh8MYAiZ8nPkidpBBIrn//vs7hz7iynvL T+efs/g99sEiPpHkYyDK1pX4aTFP8xssFXPKG6fv+R8xdtbE2BkokmaFdzXkmiNEnneML3Hb1k9T H89RrKAQYGzE3raY8E6xMwGORGJHXUgYr3i3I8QV4inEVa4L5VGf7oEl+GCTX2jMhEjiF8G7mfGc j0Tw54/3NrhwjqAkQQlGXN4b/MbxtxBHUB9D/7wQbiUTyRm2wwwfOtxq5WagkLR/NQ42YUSSxr7n mtNqymPJZKOG1vPVHn1JSiRJSyeMKzQIwKZJ884772Q1djiv8GJgsBfNFYbXNFIxIonWTwbVYuWu NJHk+Wx1yI8TTRiOJrSTdL5i5ZP7xQgK3ugMYghaOLRxcSRNO/n52qky89JLLzkvcZYbEjn44IMN Xt2+yOCLh7E4lfj3C53LIBGnbfGAh2yxXAiax6DgNXvPPfdEaiyJH2fgC+bLdbF2Ig4ORmAFoeaD h6V75AVv7XCcRzfxIJwiPukK08bgsHXKKae4lxltIr8ZSc8xTp3S9CMGH5k18J8XdS4EK02dSm3b uP3IJ3U4QQUdY5jxQGsWJJKyogMfa9xPIv4z/bYPyyMt5ml+g6ViTvnj9D1f4/jwww87p0S/7vQx lsdCwjSWcdvWz7M+ntcFkeS3yrjFB2/QEbI+YihllnpB8oToyT3/iMKEDz/eq8zA4SQZJJIQR8Yb ZlGFIMoRh0pWTQE7CSN//9x/Xt65BT9SLInJGl6eevXjzkbyvld/zNz3yo9ZG8mL734jc+aNL2Ru 7dUn88ugEZmRo8dlxowdlzn1miczp1z9hPs78fJHM+++1zfz+ptvW0eafzNT5thDTpoyPc9eUpxx IgtVhzfsl6+zgbEkJLQUYuNnlwAKvS82MlbrFXo/LNC+kLN2N5VytsE2ErseDMktcXN/PDeJWILi 8giz1yIfjH55Bn9RjhxJnpcmriVHGZxvKAM2YvZLLycb+6Hg7lmvemeYnHOzyEWStrUk0T0HzMIE 20jKiDNFlNipRRfHrucXFSU0vFg7Yawt7fTZZ5/l5WFJYvY+7wcR354wzOEKu1jytS85SZJ3jFOn 2uxHaepUatvG7Ud+O2FXGBT7UejwDtpIYttHO9gP4WCSote+jWTRyCkjpPkNloo5RY3T9+jvOBmB H/GDgl2k/Has1j14O+uQl+T9n5dJPQiwhMU5kloSFKu0lni6+PzeigltQP78+UJanFeD4X6c+nTO +GuVO65O1AtfgSghLk6b9iMxY02zMlZxkglztuEdbBUDGatAyWDrjjOnVWhk7Cyr+7OzY5V3tgkj kndaBxtI5AV39M6MGTfBVRoPoSgi2cd6FolMmjLNOdcEnW8qRSTpgIDLHx03jdj10dyLAo/roOCp LS+RchJJnmM1hi7vQl68wfLIdRyvbTofZbdTrRlrC+fw8UmC5FXouN9++7k8INtRYu2HXBy7tV9U lIqH4xkv7dS/f/+c5+GFCYnkfpj3ek7kwEVcAkAyq5HNlsEuoJyTEy9CHB0oQ5hBv0T26wGpiCvF 2glMBJ8wgiJOHMTx+4hPuuhzQeElR5qojzDix61TbfWjNHUqtW3j9iM+gsTz35pB5MDNwLLZnFUU gkSSgYN2sMsF5Xgd52QQcVEbRDLNb7BUzKlu3L5nNbkOP2sek4eS1VK6e7xD8JgNSty2Daarxmv/ tx8sH+8wyI9PJIkflSYJkQw+S65LJZKULanyJKo+UqY0Rwij1AUM5S+MSPpxD7NOpYWIpN1YIsO4 C5HkHUBa2gnsWZEFMnnJJZdkWLFD2ipJ/VAHR4qfYRiRvOXpzxyRfPDFT7OVHzF6bOaH/kPyNJLP /O/1zFtvv5t91tRpNV7aeGv7ZLKaiaS1+3EviuASNdbwPbP11lu7e7yky00kd9xxR5e3deDJWNuG LIZxTooRSX48aOoYWCg7Htx8DIjQB/Ci5iVZSOiEpMebl2UIwgRtJXHAz66XmBOF51i7r4w1C3Da y5ybKS7sOnkZa+eYo3WkrqJVhqz5Lzp5hHgXs0RKcMkjBjm7nmboh0iSQQKtr5AhO52QUw67Hp7D iMGIdokSOz3hcARPXhBhA1dY2mLtxFdwt27dXBnIV7S2tA/9mufJH2EiPumydmJuYJZ7do29bJ52 DU8JzjvGrVNt9aM0dSq1bZP0I+uQ5tqCvsxAIWLXnc22UZBIUj67DqK7b01N3HIhko4j/chOi2fw 7g5KbRBJnpn0N1gq5jwzbt8TzTrvMPq1CGOA/KZ5h4VJkrYNS582jH7Mn/97JS8J5zfvC795ueen gXjwzhRyQxyw9+OQj08kISrEkzQcSeNLFJEkX1YnkLLw/uaPMsi7m2cF8+da3lv+c4Ln5O9r/aSM hAXrRBj58jxImMT1n0M9fHwoO2HUl3DORagH9/nz8yCu5O0fw4ikH7cYkWQsFCLJSiE+keScd8kl dgzno4y6y5+Ut9ixJBvJyXabqL+G/2XWWLGz2WXj5ZyNQp8vB5n3Pv051NlmzRU6mdOOrbGTmzZj lrVbmm0aNmqYMw+fxkYyb74+JMACYbBxQVq3bl3QcDUkuQvCU5JFmC3wrszYFmK3wELiCMawtrM5 O8owG8hDvZ1tkuz+YF9ebgFr9xD7D7tM7Lgw9sau0ZeePXs6L04Js18YhgXOqTPpRKxmymDTaTuM sx/DqxUHD4Tt8OyL0tlbsEWe7Xhum0ZLSiV53tFqxZwXI9ggGOJjr8EuD7JAMc+y6zuaTz75xMVh lxiMfEkDttI+2OGFbcPnEsX8h0creWJMjOExRt/YeIEFYqcC8nZnIZwygIt4rrJTALhZTXZ220hs /IJ2OEnbloXH2ZEEwSbTEke3neDgwYNdGAvfy6LRLiDkn/3hZxeupzwtW7Z0sewyJK69Q5K4Z2Af V6idWBCeBeIRvOvp52BJX6Ks0k7YUYoNjX1ROptPeSa/BVZG4HeH3bB9cRpLUJ3HcJh9pKSLU6fa 6kdp61RK2ybpR/zmcOigT+O8BN5siuDbL1rSn+O1Dc446mDLawci9x7ht87i+ziTYLBvBzb3G7Cm LtIs7pjERjInYcKLNL/BUjCX4sXpe/xuLDl3W5pig4ZNJHZ5vBMs2XDtQFnAPShJ2jaYtpRrxiSE MUMcNvg9Ul4ReXdwbcmS++O3LbbRxCVNmBCP/ifOHJYwZd8vYfEJI6444tDf6Iv+83hv8Ex+64iU 3S83ZSOtvMtcxDn/KE+h9wz5WxLn3k9+Ov+c8kmdpP6UkbQi8hzBTMLDjr79pl8PP9zPmzx4ByFh NpJ+XN751tzCtGrVKtRGkk0msC/H7p0xmHpRF/nD6ZP3O2My90W4H0dSE8lJkyeZaVP/sd7a481a K3cxO224rAP4zU8HmA+/HGAHWnaoaeiWCJoxY7oZNewPs/Ky7c05JxzkyiVEsoHdxUYqw41qJpKU D29eyBsGqyIsFYKXHmQMD8qoZXTE0D3qvuQXPNLpWBYDT0E79Zh1FNpss83ytlnk5R/mCRzMU8og RJL7bI3HsjtW85YTHZKDZyQGvIWEfW7xtmY3HCFsONiAlwjPg+yyW4/94pJgd8RhgGVj2LqQH2gp Ag7sYMNOH77w8uGFDpGXl4R/n3NevGxfiJMOL0URXmYMIpDQYNo0bctuGKwC4HtH88Jge0IG+uAz pBxypF9A/u1XpGszeemGefFKGo7F2on602YsoSQCUbVr7Lmlmaxmxf1mIZIivJStFtdd4ix0/fXX Z8k4gRiAs+0jHymFJG6daqMflVKntG2btB9B/FiFYJDdcUmErVpZYowPEcg7/TgoxOdDBnLoD0gM vnygWg1HdrkuSSuOTryv/baX++U8pvkNpsVcyh237/Fus9odg/Oljx3vSbzVZVklyVeOSdtW0pV6 hIxQTn7DkBYkSHyEEHFPSJPE94khYeL04ZM4+o28s/345CdEiTJA+kjnhweJJPHCSCRpaCPuIbzL 6YvEF1JI2ShjMQIEcQ2WgzylLJzz/hWyK5gQjvAc7lNveT7hhHGPcPLySa7gQDy/HkKSCQ+KfASQ J39R0td6bbPdLgqcMGcbVppBSYFSgN3wKKfwLo6MISz1hsLJV4IVw1HKk5pI/tZ/AKsAubUht1x/ ebPxqh0doC+9/5P54vvBpk3bNrYR5rf3M5YwTDT9f/zWLNdlMXPRaYe6Z0+32sgZVisp0shuj4jU FpEESDo8je03vpQneBTCRXx+hKx5yAsF7+Mo7RlxSUen4o9z0hLONR2LZ/tCp5Rycc4XJD+MYDw/ TSnnUi/yoKPScVgzEA0UnZ29d31NZinPCqZF68dXEFgsvvji7mspbscN5hV2DX4sc8A6iGAKUaUu 8sILS+OHUX/Kh6aGHxjaU3mx+PFKOaeMaJYg7+ytXWidy1KekyYtmmhePvQLtFaFXmRh+UNWyIMB Fo1XpaTS/cgvd5I61Wbb0kfpq2jQC+3R7teFcwZIyCi/ebT3/D587VQwfm1fJ/0N1ibmYIf2l3cL 4wDa+2oUIU2MIfL+CiNG8vsW8iIER4goYxFhvlB3IUtC7PwwnzxJOslfysN4KBpJykfZGJcQKYOk 9QnY/7N3FgB2VFcfv1GiENytFIK7SxOgxaGUUop7keJaChSXFA0UT0KwtEhxDVooLuWDNoXikgBJ iG+yu9ls5ju/83Im983Oe/tWIpucA5OZuX7/9769/zlXjuWHn5UxLz+La3fShngi1Nnqbf5x+Y1g x3hly2T4MnZR/ngMi9OqpGxWBrsbVnnltDDc/9EIkeQUB/gKJ3DIMrwGRBIFmawTVixQGpnEdTG3 vHuLieTPNl41bLLmsqFHl45KJG9+4I3w3ahxYZlll1atJESyWhrtvx++Fxbt1SNcd2HhwGt+8FMh k3Ihs5NIohWhgShDLLB5GjsrdCLrqLEfPwTiQPTyhD/OdCT78VrnjcMyVWiNRVga235EcTjKnP0R x/7NfeaHyQ8ZobNaWZqbnsdzBBwBR8ARmHsQMKJGiYx8GUGBHJpiA9IUEzU+KGLSlSVQpJfnH5On vI+SmJThH5ePMdXGvzziFZfP6kI5bHzOi4N/LHF+cRoWJq6TpWdlZnwkTiyM68TJI9qEM6wtrThu Y88Wt6VEkhki+E6fPn1UYwnO1MUuiCjHiFGH+IzrSvlAi4nkRcfuqAUEyK++nxAGPfSasN12YYUV VxBwC5Zt6uunhQ/fe1s66bRwV/8/yJT3zHl3OQJIsZydRJIMTSNIp0JLiABu9mBfOgmdFInV+nyF 0KkBmi9R4mbFiKT9WAlj2kV+bORtRBL8bBqWcPxoSTueCkCrk/16yubZ1HfKQd6IE8mmoufhHQFH wBGYuxGAQNgYZuMKxIjxhXeeEUgd4w1jAuMjxDImXY3V0oiSEUnGMVOixHHNHzdIGeMo42lW8ohZ axBJm9an/llSaGXIEjgjknllyoa1NOxuRNPwMfdK7o2lbWk0ppHEyAXlkM2wQTbbNdBIcs6vGRnA kIcJGFUirUokP/t2XLjzsTeUSC6/AlPdmEssmEj88L23tFPeee2ZoaNssDGZE0SSDg75M5DoWCxS R1isahpGCJacW6dEmR9V/HXFjxM/wvBjzFv7ZUSSdCFpaC8tT9zI14ghHcZ+3Eyj8kNGyId0+EHT ifFrLaHs/KhN6OgujoAj4Ag4AvMWAkaEGNsYgxh7jBQZWWGMg0gyLhjpiUlfPHblocNYRvoWh/B5 RM38SSOrkcSN8ZkyIJTJxkLeW4NIGlkuVT7yMUyoE1eMX3actLCGGfFjaYq2NI7Hs6Vt5cj62/s/ GpnaHjRokG6SLLVGko06w4YN0yVmrNE3aazN03BCVIrnd81H7rFX1kSirZHcbvPeYcPey4TuCxQW nd5w/2th5OgJRVPbNfLFM+yDd8NCYvbwxksLZtLItW5afaidsU5ydmok6dzZLyV2ClLfeHrbtJF0 7KymEpjMH7DRLGbFiCT+pbSWFgdtJD+eLGHFn47PlDdCOvEPSx2b8E+WPBKV8vFHhXq6OAKOgCPg CMxbCJgWjr/x/L2HkKEA4e9+TJJMscD4SNiYuFn4xpDJEsVs+HhNIWNxrPUkX8pnGlSezY104vIQ F3+kKWStsfLFeVidY4yyRNLyziN7cAqrSymiqRUo8U9rEckHHnhA10KzT0DOwda2BTu7ME2KYoyT H/baa6+0NIZv6lDiocUaSTlwKGy7+eqhz/orKBF75B/DwnvDvpaNDYuHrpnNNqvJZpvzZmy2YW2k kUjKNjuJZN4UMSDSgfhCgswh7Co2lXseeaOT2JcTRDNLxIxI0sEa22zApgQkJrLqIP+Qh017xxpT 82/KnTryw42FcvMHpdJOE8f1Z0fAEXAEHIG5GwHGEBQfsRgRM5JpfowD+CExETINpoXjHpMuI58x UctqFIljxIsxFX8jknG+cRpoOY28xflZ+eM0KyFrcRpGFEnDJMbD6lSOSJof4yjhY4nrUUnZ4rg8 txaRFEtLYejQoTrGHyonMmASEby52IwqBjj0meP6zMwn+eNfiTSbSHL8T/XkKWH8uPFhs3VXDjtv uap2uqdf/yS8/v5nobM0foeOcvyPkC3scY8c8dVcffxPHpE0IlgJkHmaQoufp2WM06Rjkz9Siiga 0WyNTTe0iZFg8kboMBBeF0fAEXAEHIF5DwEjcNSMv/dGFmNihV9M3Hg3osRzTAwZQ/CDpMbpxeQJ d+KYkiUmaZZWHpEkL4ivKWosbFzWPCKZLbtN1ZO/kVHSNiyy5SM/6kTdjOgS3jDIpo9fXN9YK2n1 IgwSE0nyoWwIcfIUVfi1FpFEIcY6SerFqQ5iYUyX44HDkCFD9JxklGhymL5qqskbAZ9KpNlEkgLZ geQbr71i2G3rwoHkL7zzRfjH23K+nKyPRAhXLxqwcT9+FzZYY4Vw2jH7qTvaSLSSc8uB5OWIJB0A TWFTxYgkXyn2o81Lg05lGsc8bSlxjEjmaSzz0qzUjR82bYTEP7RK43s4R8ARcAQcgbkfAZtSpqRZ QmSEBT8jbTwjjE+xNtNIIe4msWYvJlbmb4TExpqYpBnhIkw8Tsb5ml8pIhnXjbCUhzyMjGa1hZan lS+vTjEO5YgkaVg+ll7ePSaScT1i92w8a5eYoGbD8P6PRtZIgkmslaS+cAnSB2feOV/ZNJWWB/Eq kRYRySnCZkcMHxFWX2XpsO8vClYsqqbUhu/HVIW7Hn1D8zciudVai4ZePRYIO+2wvbpX104TlXbL iSRAWOckYVh1XuUJYxY52LCCmj6WPCJJ2nQgfnRoCpsqlRJJ0jWimKdxpNM1prFsatksPD8o0kfo rHnYWVi/OwKOgCPgCLRNBGLyFBM/amNEiWfG0KxANiBrMXkkDOMFRCgeT41IQuTwJ99YslPkVi7C xkSSOLYxhmfygfBQViTWSDKGUT7jAkYCjeARLzvtTL6kb3E0UfmHchCfOCaGT5aAmz930iJNS490 GFNNWRMTxphIZtsiTrMpRPJvf/ubahn79u0bNttsMy0/dbB24Jmd2a+88kraJpQRzrGdGDBgIw6C m0n8bG559xYRybppdeGrz78U9t8pnH5QHz3Wh46GpvHSAUM1P0BFI7nXNjInL0eYU0n0X5OFcKII o5LikUpTDyS3TTKWQN5aRfwoR1OJJJ3HGjJv6tryLHVvCpE0IkvHy66njMtRqn6lytCYO+3FDx9x ItkYWu7vCDgCjsD8iwDjBRfjqZGUStCAYEFKiFMpOakk3WwYyoaQT6UCqSOela8pcfPyiIkk/sYh yhHGvHSa4oZGknJjkABOxbNdMZHEjfKxLhI+hAECLPMh1i52j900QJl/WkQkZaVdGP7Nt6Gmuias uqKYt9t81bCwaB3r66fnEkmmu/v06Rswj0gYbbjoKCDKOTcRSQDHfB0djS8RmLsS3xmA0vn4CkKy Xzu4NYVIxmQxnr4mb9IhL75omjPFTllKCek6kSyFjrs7Ao6AI+AIOAKlETCtKSQtywNMO0vsWINa OrXm+TSFSBph5m4XufIc37PP6lninxYTyak1teG7Ed8JGWGtHbkkobNssqmpLRzyDRlDIzl5wigJ My3cdNnJaVGy2kg85iYiSXlQS9sZk7xDKAEcgseF8KUBycxKU4hkTFpJB/U/+ZiqnGem1+MphGx+ zXmPiSR148fg4gg4Ao6AIzBvIGAasXmjNnNXLWwWDzKJwGlijgB/MHemy22Tjzq24j8nnHCC8gVm TuEK8WVjeuzGM2L37PP555/fwF8dSvzTYiLJ8T9YrBk7ZpxoJqt1nYASrJzNNsxp39zvZC28VS5b rjlFJNE8Qtri43+sbNSHo4BMc2fu3Ok0fIXQobLSFCJJXMgk50Va57P0II8Q1dYmkZan5UebUB8X R8ARcAQcgXkDgbxxa96o2ZyvBcSRcdPWUOaVCH9IJKTNFEN54Vriduedd2o5ll9++XRKm3zJ02ZR eTc33OMrzhv3vPWScZjsc8VE8owr71fN4k/XWEtJE6RH/xMiiRZyuliwQSU5XQgkxAuCqSYScRNT iaO/+0bzvuCkwq7tbEH0XcICtNQwLNi92Dh8bvjZ7KjaVakbWjwahAYC9NYW8lEcJGHrqK2dR5we RJI8Y3HtZIyGPzsCjoAj4Ag4AqURgLDHRNE4gs0ulo7Zcp82M7V95R3Ph++/HxV69FwwLL7U0qGL MOxSRBISCTExW9vcR33/jZLLUkRSw8u6ScwqdpB1k927urm+lnevylIw4gpBNnEiaUi0/btNu8Q1 8faN0fBnR8ARcATaLgJthkh+/f24cMPdzxa0jcxR6/9CJdFkyaV3qOWM5wKZNEI5PUwYM1L8poeB 15xdvrVEw9e9qxzQKRq/uU04SmDzzTfXOj788MO6Q2puK+Oll14a7r333rDtttuG66+/vlkItIY1 AAA570lEQVTFow1nhaa1WYWZSyJhYuqiiy4Kq6++euC5rQhTLjZNEZf5mmuuCbvuumvs5M+OgCPg CDgCbRCBNkMkIRfDR00Ir7z7Wfjo82/D5KopBY2kuAuzUnIFu2wukYS4dOzYQSzidNRjhObGtmSh 7IYbbqhFe/zxx8Nqq6021xXzggsuCJwn1bdv33DrrbfOdeVrqwUCU7ClzWn7tiJoIw877LAZv88Q PvzwQ51+ufrqq8Nuu+3WVqrh5XQEHAFHwBEogUCbIpKQRCQli/LOdCjv8Z1nLtZK2v2zzz7TZwhO WxUnkm215Vpe7rZKJLM1R1P93XffBSeSWWT83RFwBByBtomAE8k21G5OJNtQY7VyUZ1ItjKgnpwj 4Ag4Ao5AqyDgRLJVYJw9iWSJJLux3nzzzTBixIiw1lpr6fpJznHKE3ZGv/322wHN7MiRI/U4H6ZJ 11577bDUUkvlRUndmJ7ETuann34avv3227DYYouFNdZYI2y55Za6ezwNKA9Mv5aa2v76668DF8K6 ufhwc8r31ltvaT4cZbTRRhvpNP5//vMfPdKJsmYt7pAO/ljlWXnllQNHD4waNSr885//1LIus8wy YaeddgpLLLEEQVPhKCVMNX388cd6pBKn8bNkYOmll07D2APabsrFnTJzjEIs//73v9VywCqrrJLm Q9hXX31V42y88cZafrBnWpeybL311oHwpeSbb77Rtvriiy9C7969wxZbbBFeeOEFxXZWTG2T37Bh wxQzdv6BI5r7LG5W3o8++ihQb+Itvvji2hdoLzvmwcLl3ZuikWxKO1lexHn//fe1X4IzsxK8v/76 6xpk3XXXFaMEfXwNrgHmd0fAEXAEWoiAE8kWAjg7o8dE8sgjjwy33367TtdbGSB4N910U1hvvfXM Se+QmKOOOiq1ERp7Qtr+9Kc/hX322Sd2Tp8hkH/84x8DpCYrEI6hQ4cWEYhSRPK9997TMnA4LQP5 X/7yF7WUQ5qcd/n73/8+ECaWfffdNzz33HNhzJgxGn6HHXaIvfUZQ++Q6eOPP15JYXZdJruD//Wv f6XnbEIqTjnlFDkB4PuitDjU/bzzzgu//vWvi9wh0ZAP5KGHHlLCHgdgnR8EmwNU999/f/WK41x2 2WXh8ssv13NALR4Wgq666qqQVx82UdEe8dlrEG4I8f3339+qayQpJxuisv2IckIKqdNvf/tbK7ae L0pd/vrXv6Zu9rDpppsGNtBALMtJpUSyqe1keb777rvhgAMO0NeXXnop/OY3v0lNk1oY+goH6Lo4 Ao6AI+AItBwBJ5Itx3C2pRATSTJddtllw1577aVaF3byjh49Ws0g0aixtg8yxuC56qqrqnZrhRVW 0A0PaO5ee+01LX+/fv3Cr371q6K6oO2DYKLVQRv4y1/+Mqy44oq6xu3FF18MX375pWoEIWsmeUTy jTfeCMcee6wS2R133FEJR3y4OZsx0Bhx7hUD/0orrRRefvllJYiWLsQzj3gZkURz97///U+1aJAa 6o+W7YMPPtALoohtz+23317NSkK69957b7UK9Oyzz4b//ve/mtXNN9+sBuQt35gUNodIkg6Emx3K EE7IDet20ZY+//zzRSQ8JkFrrrlm2GWXXZREswue3c9InkYSDWhWKtn1TpvQjgja5c0220wPnQeL Z555JvCxcuqpp6ZJQ4o5eBbZbrvtAtpWNNQQXPoIWnEwKieVEMnmtJPlGWO4zjrrqOaU/kDf54Pl lVdeUXJ8xhlnWBS/OwKOgCPgCLQAgTlNJJn+Kyky4MopPoVLBqpEDtvUS7Q1iUyFJjLIJzLAJnIs TiKarkSmtRIxJ5iIlZhEtFiJTHMmYhw8kanfRIhJIoN4ybzaggd1FCKhlxwDpHWzcn/11VeJaCLV 78YbbzRnvct0ciJau9Rt+rTpyeTRVXoJEdU4QuBSfx7AXUik+gmBS2SDRJE/+Iv2T9sj9hAtlsYR Dag6P//0c8k6a6+jbqeffnqD8EL01I96CRlOk6KthcikfqL5TP3ih4MPPjgNc/TRR2sfiP2FKKd5 ytFEGlamYROZlk2D0X+EVKqfkOnUnQexZZ6mL8S6yI8XIYjqP2TIkNQvjiNTxNonzVOmvNP0RFNq zno/4ogj1G/33XfXPm2eQrLTOKIBNWe900708+xFGcoJvwfrSwMGDGgQlLrKB0jqLh8piWhmNc7F F1+cuvMgpDNNS6bgi/yyL+BBvqLV1D6W9ee9Oe1k6ciShbQsQiQT+QNnXnrnb0NeOxYF8hdHwBFw BByBihGAWzGmwLXgXIxHohBIZNmZjn9iMU85GmMtnA3uBoeAyxmvg+NxGefjXqnME0QSUBi4K7kA DWlOnJhIigaxAcZnnnmmDqKiOWzgFzvUT6tPJo8SIinXoEGDNI5opOIgOtga0Xji4SeSmvHVCfEa k5hIQv5ES6Xpn3PW2dpJsvGvuOIK9Zfp7pTwWRjRZKof5WiMSEKiITvlhDxI68ILL2wQ7Omnn07z Gj58eOofk8I8AtIYkRw4cGCalj2IJk/zIk8TfmCG93333WfO6R2ij39MJOlL/ChlzWt6UXYuPqiy /TFNTB6OOeYYTW+PPfYoSeji8H//+981vKyN1T8Wot3TPwwWRrSn6v+HP/zBnHLvRiQh3vzRyJPm tJOlExPJvN+IhfO7I+AIOAKOQOsgMKeJZMUmEqW6unkB7as9cxfWqu/xnWcuGajS+6w6/odNIkyh VSpM3bIWr6lxLrnkEjW4budIitYx/PznPy/KVgiIps20LptJYmFqlOlv1iHKF0MYJ7bJkeraat2g wro9NoOYPPHEE+G0007Tqde3XnxT7116dQntO3WwILl3m9pmUwrY0AZLLrFkePapZ0OXng3NTp50 0kk6jcqUd/YAc8psh1k3NrXNVCvT0qWEcoA59/79+4edd965KCjTqVtttZW63X333YHpUEQIf4vW SApR1801mtiMf8ibNadCaAPrQJHPP/9cp7J5BnumYmP585//rGsZhUym50hyhM5tt90WByv7zLTu kksuqWHAW7TY4cQTTwzHHXdc2Xh40jb0OTYJ0Y+E+Oq6U9sAZe0ObuBXSmxqm7qz/jI7Bd/cdrL8 4qntvKUIFs7vjoAj4Ag4Aq2DwJye2nYiWUE7Qj6zRJJ1cxtssEFRbDa+QAwQNsnYDmPWDrKWUKb1 0vAQRzZUiFZLCR8ehDOBNEAeWIf5xH2FA7CbQiQtHbuzwUW0YPaa3iETlJUNEhDsrED+IKSNEUmZ 4g7nnHNONnr6ztmFkBjknnvuCZtssknqxwMfHqzx4w5p23PPPdW/pUQyj8zkbdBhl7dMbWuerBdd dNFF9dn+Ec1muPLKK4vWSDaXSELW2EBE2+etjbU84zsbrqgL6ygh7FkiSfvccMMNYbnlltMd5nHc +NmIZKlzJJvbTpZHTCT5mIrXClsYvzsCjoAj4Ai0HgJzmkjOE1PbTC9WTajSq3pKdTJ50uRk0tiJ yYQfJyRV4yfpejfCcNnUtr1zj8NPlHhVE6s0rIWxOPHU9puvv5nUTZF1opNkrUFVrT4/9cRTOr0o ZvTSfFBcM33JtOi2fbdNnh36bDJh3IRk2lRZbyoXa8hsSpWwiJCp5NZbblX3LbfYMp0Gnzp5ajKt VuLNuOrrGk5N2tS2bH5J7hh8R3LRhRdpOkyJZtcEktehhx6q/kJUEtLTOkl9pkrdptZMTYhH+bJT 29Nlmp1yHHxQYY1k/2v7J5RPsaipI+kiYdrb6sm6SdZm2CXEStdrmP9TTz2Vxm1salu0i5puqTWS svtYlzFYgqwLsTh33XWXOSfxlCxT1YRjupt1v9yFpGk+eVPb1k+4s0ZFNsAkTD3H7jzHYutpKYOt LyYf8s2Tc889V/MX4q/T5qyBYf0LSzS4hOSqP3XLCv2JdLls2vqRRx7JBtN31tdYO9BOWSEN8xcL P1nvIhypFxdtSBnKCX3A+gN3F0fAEXAEHIHKEJjTU9vzBJGcXi+bV2asOYTY2bPdp/w4WUlSgyaR sa12Yk2D8MSrHjclId1YYiL54JC/N4g34MYBOsj+7Gc/S6NBLGzgfXnoyw3iQCTM3wbbeiGYTz70 hLpDCEd9NapBPMrIusmsGJE85MBDNM7Y4WOSXXYqrJ8TbVTRxhPiihZR8znogAMb5PHlsC/SsmWJ ZK2QTcpw4P4Hapir+11dFB/8kgg+6ibaTQ374IMPFq0fhJywrtBwEA1pWi1IPMQcP1kWkLrbg613 FC2nOWnalpbsjNeFx6TD4mMImEwra3psVqJNkbidWBua3TzD2kPSjIlkmmH0YHlAnsoJ6ZAe7ZXN iw0pEKtYZDmAhqdvZcPzLksU1P/www+Po+kz+Foc4pMva0ezeRAYMitnm2oY2ikrcTuxCSkr8WYm y5M7uFCOUoJfvKbUfgulwru7I+AIOAKOQAEBJ5Kt0BNiIgm5gTiiGeOaMnpygeDILumY2JBtTDoh ZWjUYmJZPVbIUCQxkTzpuBOVyBFHtXhCSA8+sKCdO+igg9JYn3zyiQ7KDN7vvy3aMSG6cR62iQN/ Gzypzxcff55AInG/qf+NWgfiWb1U81fdUHNjRPLII47UvKaMmZx8+NYHKYmTqfe0bDwYkUXzCHGM cbjthtvSspckkvsdoGGuvfLaAt6CPW3ABS6xmCZQzqwsIg2QiMGDB2s61BnSEYus+1O/Rx99NHZO YmwbI5Jo7yA0kDQrR0wkIZq2K1qm1nXjkGkj0S4aAWNTSzmplEiefPLJWieZqtZyQeDoX2huKSen HsRC3ekLXHIuqYYhL+JQJ9LBT9ZKxtH0mbpRFy7rb7LUIZdI0gc5JYC02BCUFdscRjvJWaBF3nI8 lu40t3LyzmUnOFC3PPJKIk4ki6D0F0fAEXAEKkbAiWTFUJUOGBNJSGSsSYx3SDNdaxLHqZ1UrD2a JlOzRoaYvjWJiSS7oeOpPzkLMdWcPfnkkxZFpzdNo3b22WfrlDdlqho5Kbnq8qtScsDga0TSItsu 8A3WXz954sHHEzSVJhyfw/E82WlAI5J2/E/NhILG9Y6BBaJGPrK+05JJqiZVJRzHg/t+v91XSQme HAsk6xjT8j395MwdzvinGskZRFLWc+KsgjYS/KrHFWtM5QxETQ/SCkamgZK1oYlstFE/OW/Tkknv djQQdzRiCG0RHz3UGJGEnDEFjNhOb+LE+MlB5FoGiCtlMpFD5lMc5GDyomULFsbulRJJseqTyFmV mi6EjV3eCGVkav2WW25RraGlC1aG0X777ZdwpBQEF5HzJTUdyB3plhNZB6thOb4qezSPxYNg0x9o J/q1iWxISjhdAD/rX+YHQYQocmQR/lwm9GvDhWMo8sSJZB4q7uYIOAKOQOMIzGki2eY327BcVTSN oXrMFF252qlbp9Cpe+eiVayiyQv1tfWy47l96NKrYGJvWo1scplUq+G6LtottGvfriiOaCNDUp+E Dl06hgV6LqB+2QPJOdSbzSjSzHrwsgymQUijboqIzdWdddZZAYspCCYUsXzz+aefh2+Gf6PmDmWQ VT9MBsa7aHHn0G6zAvPTVX4allt+Od3lzeHaQoIaPZC8dmKt1H1a6Ni1YzjhtBMDi3I5HFymLQOm CcHh/r/dFy6+4hLd6MKh5JSRvDHdyA5z5Jorrgm7/nJXfeYf0cSGaVPqwtEnHR3efu8dPXDdrJXU VdeFuqqpoV2HdqHrIt3SOEKSAhtdMO1HPmyuYdMRB5fLGkLdnGTWY9JI8mC74XEjHvix45n0hIDo phU2CplFFdzNGg67toVgado9evTQZClD1hoOHpgd5HB20dxpeNpWCF7RJqif/OQn2r62kUoTjP7B CpAQJ91kQt3KCZtm2MGO9OzZU00d0m9E06oHobP5Rz4m0iTABqs7CG3EznLMbYIFImtxdUOQvpT4 B+w5nB3cEDbDkCcWheyQcOrP4fcy3a94Y8aTusjxS9pO9B8ORrcd/aQjGlU91QAMOWgdiTePmT/9 m8PosyJaU8XN3DlkP/4tmLvfHQFHwBFwBIoRYFxnbGRM5+85z3bxzt9Se7dn7naRGs/xPfusniX+ meeI5AILdQkdOhcfkZMSGyGLkEakTohQnRChLNkxnCCZkKyYfDIY2k7tfhf2C/1v6h9+GFkgWsST 6U+1GgMpiEW0Z4HjWWRzQurMQLl9n+3Cfgftrzu6aUSIZFaIe/H5F4cnhz5ZZLaPwRxCJIdTawex eBzrggk9O44nJpJVUycHOWxbSSLk6rHHHktxePn1l8PAuwZpGSgbxxxBYg7Y/4BQNbkq3HydWJzZ aTvLJiWSx576+/Dm228WHWMjWtwwVQgs5NzwtoiikQqimVWrMhBwE8rDTuLssTv4QzKoF0TKBFOA 7O7mgrDER/lAkiCSpC9T5prmwgsvrFZjiA/hysbhIwCb4dgiZ4c0hMsE4ordaHbS80Nlx362jS1s U4gk9ZIvSd25LZpWS0LvHPMD/n3F5nYsWAGCTIo2MnXGzCYmODlGiD8W5YR6YrucHd6QadoDES2n 9lGL+6VYTcKSDtaX4naiXPRl+kdsHQnyKVpTJeMQSfozu99NSAOCjbAjvrFyWjy/OwKOgCPgCJRH wIlkeXwq8o01kl0W7hradyweTGPtY7fFu2uaeUQxziwlmlkyJNxHNZxT6zX41998HUaP+TH0XnW1 sOjSi4WOosEsJTL1p9ojBuCVl1wpdO7UWYlWVhuajS/rPPX8xZETR4YfRo0MkKKVV145dOs2U9uX jWPvMZHs3KOhhiyLA+QGEsBXTKyBffS+R8Lq669hyaZEEtIOeY8FDSj5BvnA6bZYAe/Yn2c0kJA5 tKqQEzRsjQn4cf7jEkssofVvLDxpG+FCC2ZfXHnxIJ9oH03Q9EHuVlpppQZHAUHiW0okjXhZfhA6 SCxEj7Mml156aW3f7t0b4sfHBThQRsqHlpT2qkSMMBO2HKGz8hEerTRYUiY7tirbXuBMmEqEuJWW t5L0PIwj4Ag4AvMzAk4kW6H1i4hkzqHdLSKSmelZK66YOVSN5XQhlLLe0px1CjmPsKUB5IHwNWML tpvzptXjsDxDJJFKzpHUgNE/lRDJ2sm1oVOXTum0v0UXayp6NmTXLl3DK8++HBZcciHzajGRTBOa hQ8xkUSDWU7isC0hOpVoJJl6N00gU+RcMbHivFEIPR8KeUQSgo92HE2kHUherm6xX6VEMsbDCCca W+JTpuxHjBFJiKafHRkj7s+OgCPgCMxaBJxItgK+MZFcYEE56HuBYq0gU9hoGONp7NQtq3GcUR7Z XR3qZWo7T+OWLTKkUnZRh+l1QijLaOEs3txEJMFh4IABYegLz4a99t5L13yiceMwadbvQVqOOuyo cPyxxxVpHm2NZB4+lWgkISQmaApnxVRnTIYaI5JMu0ICkV69egWm95sjRiTRWIJjnpi2jzzIKyus T2UqeE4SScpkdYE4QlohuEge0UZLipa5VJ00Ypl/4qlvgtEfymmQyyTlXo6AI+AIzFcIOJFsheaO iSQkEjIZixxpoyQvJj22jo9wedPhsvtbdvGEijSMpFEvmsnaCTU85qanHjP+aS6RzCPJcbp5z41p JMFhwC23yXrP6/Kih77b9A2XnX9p6LlwzxBrWltCJCENttmDTCENzSVuuYWe4dgUIkkUI07lpq7L 5YefaebKpYE2Eq1knkYxnmIvRSRt4wpLJFjm0BSpVCNJmqb5JB/apxxRxA8yieQRTfUo8w8a2Pjj gjxjLW2ZqO7lCDgCjsB8jYATyVZo/phIktwCMr3dYYZN6pgwFhExIYm6M1t2fOuGGtb5iWYMmSo7 jqfJzmMkSzIhUKQNKY3F1hqqRpINPTPSisPYc1OJZLqDXPKEzKFZrVQaI5KQ5RGfDw+vvv5qGPbx sDBu0njdFLGyrMFcb631wlYbb6lZ5eHAru2YnFuZGtNIzq1Eks0iaAuRPI0iJI8w7P4upUE1bSP+ pAFZzIoRNNxj0gWRYp2mEapSRDKeGmcamTwq1d41hUhC7kwLaXWg7nk71mlTwpI+pJO6x0QQjS/Y IdlpcdycSIKCiyPgCDgCTUfAiWTTMWsQI0skCWAbbph2tnfIUCyQRUgjwkDcTjbpyGGOeuwPbnna TSN1EEbyIJ6YFlTtJXE69+gsWszMtKgMsjXjC4MoYRh0OVoIad9BNgZFvDBbRsLYrnOeEd2cI3Eg tJ1nHE1U8JGwQu4gciaQVsiilpe8ZghltI1BzcFhXtRIAo1pFHmGCHHRXhCkSnYdx0SNNIzgQb5s vWM2jGlj0aBaHPIsRSTxY72ilYc8jNhCLNHmmRCWOplYXXiPw/Gep9209Zr4I7ZesvBW/G+sTcWH eunvQ7CjzkgpTa0TSYXH/3EEHAFHoMkIOJFsMmQNI8REsrNMa3OGIW4maM1wt0Hd3Lmr9ozzJGcG V++88yjxUG1ljQz4mfAQtU5CzrJnWBKHwbv6x8I5l7yXE9tVng3DhiEInxFj/PO0gbE2NZtG/J6t X1NxsF3teWUwjSR4d12s4c5y8Jgbp7YNH6aOuShnLJA1NpNACPP6koWFFDHNy93SyBIo6o/20sgg cU2LSd6QylJEkrAQM6aT0fJZHrjHxxzxjp+dU8p7OclbR2rT6MTLm4rPpke5qJeR4tgfYkmd8rS0 4BHXoyla1jgPf3YEHAFHYH5DwIlkK7R4TCS7LCLH/4jmDU0c7qY1bCwbNITEQdtn2sxycRIJKwY7 lFBqnIxmsVzcudmvqTjMzXVpadkgeaZJg+TFU7UtTZv4ECfSJx+0g6ZVbI2053Qacd0Mu3Lkm+l6 E3DOakvNz++OgCPgCDgCxQg4kSzGo1lveUSyWQl5JEfAEZjtCECkYw2mayNnexN4ho6AI9CGEXAi 2QqN50SyFUD0JByBOYQAWlmWASCujZxDjeDZOgKOQJtFwIlkKzSdE8lWANGTcAQcAUfAEXAEHIE2 h4ATydZoMlmqOFWssyCduslRKLLO0cURcAQcAUfAEXAEHIF5HQEnkvN6C3v9HAFHwBFwBBwBR8AR mEUIOJGcRcB6so6AI+AIOAKOgCPgCMzrCDiRnNdb2OvnCDgC8xUC8eYhqzhHINnB8+bmd0fAEXAE WgMBJ5KtgeJsSoPDmTfffHM9/+/hhx8OP/3pT2dTzk3Mpvgc7SLLOU1MaY4Hn9sxx8JMnz59FKf7 778/rLHGGnMcs3mlANtuu60epn7dddeF7bbbrs1U64orrgiDBg0qKu/KK68cnnnmmSI3f3EEHAFH oDUQcCLZGijOpjSwkbzhhhtqbo8//nhYbbXVZnnOHOz8+9//XsnraSeeGpZbarnUvCKZd1usexFR NMs2zzz3THj6+WfCGr3XCMf+7pjQdZGGFmZmeeFbIYPmYA5mZs0la+mlKUVCs2S2pjENmHegNvls tdVWmuyDDz4Y1l577TQLs93N4dp55gfTgJmHMWPG6CHlCy20UK4VmEzwefZ1yy23DGDxl7/8Jeyw ww5tpp5/+9vfwmOPPablHT16dPj222/DSiutFIYOHdpm6uAFdQQcgbaDgBPJttNWoTmkpqXV47Bm 03LdccvgsN7a6xWSnLExvduixUQSM4rTxNb2jbfeFG67/bawxaZbhJuvu8mJZDMaAiKJxhEpZWO6 HJHEhCGmEjkbcZFFFqm4BEYksZuNScb5VdoqkYzbi4+Ls88+24lkDIo/OwKOQKsi4ESyVeGctYnN DURy4802UZve2PYuJ0wH3nTTTU4kF1642eb2IPHjx49XmNEoNlUj6USyXA9t3M+JZOMYeQhHwBFw BJxItqE+kCWSTFm++eabYcSIEWGttdbS9ZN5miemtoYPH65arex0OFOnH3/8sU5hbrTRRooGWqx/ /etf+gyZOfroo/X5lONODmuut1Y6lY2WjHxNhg0bplOBvLOG86mnngq9V+0dTjz2hNC550zNFvl0 7y6azIx89NFH4d///nf45ptvwuKLL66aUMLm2Zj++uuvA9diiy0WVl999UDct956S4kXGlSmIvPi ZbJs9LU5mNvU9nfffRc++eSTMHLkSNUMsk4N/Nddd91Gy4bt5//7v/8Ln376qU5NUk/qBbmJbWKX 00jSji+//LLWcfnll9d84wpPnTpVMSMfzAKCNUsnXnvttcC0+Prrr6/tEMeZNGlSeP/997UMW2+9 tdrq5v3111/XYNSNNZtZ0ku8d955R/sa5ghZ30teSy+9dJy8Pje1vxIJzF999VW9b7zxxgH83n77 7fDhhx+GJZZYIlDWVVZZpUFeOFAe+s4HH3yg5d5kk00UC+LMiqntSts2LmxTfhtxvKZqJJvSTpbP f/7zH9Wc07/pZ6NGjQr//Oc/te8us8wyYaeddtI2sPB+dwQcgXkLASeSrdye06dND9Pr6mWNWaIH k7fv2D506NShQS71U+vVDf9SB5inYTpJmHbtiqa2jzziyHD74Nt1LZslDtlAC7jeejOmn2d4XHXV VWHAgAGBzQM3Xn9jaN+hXWjXoX3AIs/TTz0dTjntlLDIwosoGaAsEIvf/va3lmzJ+zZbbxMGDhqY +h9xxBE6mKcOJR4eeOCBIlIDobn88svDX//61wYxNt1003DNNdekhGZ6/XRdo3lN/2s0b+qEtu6h hx4qigsZGDhgYOjUoZNgF0L7TBuYSTwiQcxichYnFBPJI48UzG9vHHNIzeGHH56Sqzg9niFQ119/ fVqn2J+47733Xjj33HPDl19+GXvpMwM1a92MJMdEkrVxEFU+MPA/9dRTw7PPPqvT0/QLiJEJmk7W vpJXLPvuu6+mzwcGuO+6666xd3j33XfDAQccoG5PPvlkOPjgg9OPBwt4/PHHhxNOOEFfmZ4njzPP PDN8//33FkTvXbp0Ceedd1749a9/XeRu/ZUNLqxPNKGNnnvuuXDiiSfqVP0bb7xhXkocIbHIZZdd pv0JUmTCFD3pZtc6Us/jjjuuAQ577bVX4I8jSwtac40kv60//vGP4YsvvrCipfds2+LRlN9GmlD0 0BQiyQfBKaecUnE7WTaHHHKIftDS7pDyW2+91bz0zm5xPkz5WHFxBByBeQ8BJ5Kt1aZYt6mqDdNq CjZ742TbCxFcYMEuRYSxeswUJXKdunUKnbo3/AMLiaydUKPJdF20m8aNSQ0eyyy1TNhj1z1UK/Tw 4w+HH8f8qJo+GpX1bSY2MPfdpk+49vJrxfpOJ/Wqm1IXnv/HC+GMc88IC/daOLz4xAu6eWbU6FFh yN1DhBALaRNiM+COARp+j132CEstuZQlG1ZafsXw6/33TjWUbAAy8oOmFAJBGXffZbfQsWshTyLv t99+RSSKgf/OO+/UdPts3SdsuN4GYbhoWR96/CGtG1pPI4p1k6cGyn39bX8Jg+8anJZlt912C2g/ KIMRlvPPOS/sufOeQiLbhy69uqZhqRMDtAkEpdTRKFnMl1122QDJgCBBiNnMgHY1xpz0IWBo1tDO rbjiikp20Rw/8cQTYeLEiaq5iQmhlQWisf/++2v6tOGOO+4YlltuuTBhwoTw0ksvKb5ogKy8MZEc OHCgamcZzP/0pz8pqe/atasSqJ///OeWhd4PO+wwJbrUfffdd9c8rM0sYB6RRFsJSUbQkKIp22CD DcJPfvKTwA53tIJ8hJxxxhkaBu0ybYMWDg02uEDq0JSirUUgudtvv70+84/1V4hk//79U3fK+uKL LzZKJIkAKSMvNLrghmad/vH888+nJJxwRoIg3pBo2veFF14oIpatRSRpt3322Ufblo1Mv/zlL7Vv oLmmXvx24ralfPFvAzzQttKv2KFPH4x/G4TPSqVEkn5EG6CJ5oN07733DhB9PkT++9//arI333xz 7u51w7B3797hf//7n2of+QCk/zJLgaaXi/RcHAFHYN5DYE4TSYhKSZE//old8kczES2SXjJQJkIE EhmcElkHlsgAlsg0XiIaiEQG3ES0DIlMSSUyxZL88MMPiQzgiQxciQwoJfNqqUftpNpk8qgqvWrG VydTJ0v5JtakbtVjpxRlIaRT/ab8OLnI3V5qZsStHjczHnUUjZNem226WfL1J19pPuT18QcfJeut u5763XjDjZaM3q+88kp1P+qI3xXyHDMlzfvxhx8vpLfZZuomWkoV2TCTUMaaidXqT76vv/iauuFu V1FG0YsQAI13yIGHJFPG5NeR4ELEEtEkadjzzz4vibF79P5H07xlcNfUKRc4X3bhZanf4MGD1Y9/ 6COiMVO/Qw8+VMNS1ljoUzJgphd9qZTEmMvRS9qfLOxXX32ViPZX87rxxpmYk76QzOSzzz7TPkhf JB3RAiaPPPJIWu5XXnnFktI78X7zm9+ovxC/RIiWxqcf0/8pp2h7tI4WUUhImp6QPO33MrCrm0xV J/IDVzcLz10G9TSOaFj1dyOEOREykYiGMfUT0htHSwgjGsHUf5111kmEDKe/NdqSugoZSuNdcMEF Gl60sImQZP19goUstUj23HNP9RNClYbnwfrrMccck7YR7UX95QgbjUNbxIK//Tb69u2r+Zi/kNvU TzRj5qzlsTi0iwl/X2IcqGNLhbYVEqnlEK1oQrvFkte28W/j4osvjoOnOFB++20UBZjx8ve//z3N M8/f3C699FINR58R8m/O+rdVSKX6/epXv0rd44cYK1kGo/0p9qdf8rt0cQQcgXkTAbgVHAuuBedi zGI8kRkd/VssyhMdA+FqcDa4G3/z+FtrvI4xjou/lXZVitY8QSRrqmuSscPH6DXxxwlFg9/kCVWp 3+SJk9M/qNVTqlP3KZOmFMXR9EYU0qsaNymNM2niJP2DzuBx6cWXFmMsBPC0k05V/z1236PIzwZm I5IQMQgbjRUPzJC0rNCwNthCJCuVSokkhIv0RbuVfPfViKLkp9XUJTvtuJP6n3nGmQU/KXNMJGUK WztkHFG0mxqHuISlXnRWI490ZD447OIDxPzsbunFRLJfv37mnN5lylbziskQuPJDsh8T7yaQMdEq aZx77rnHnPUOATOsIS+U2dKhHfLk888/T+OIRjE58MAD9X0z+TBgACc+5C4W6kE+22yzjf64Y7+Y KMZEkvwhNrG/4UH9+KNBXvzBiOVnP/uZ5nXWWWcpKYn9jORQFoilifXX5hJJ0cxaUundMH/66adT NzlvUctGGbP4QvLjtrBIcT+yvlLubvGybWvu5e6GD78NsM/KLrvsomX8wx/+kPVK3y0NyGs5Ec25 pnXhhRc2CAZmhkXcThbQiCQfVXnltHB+dwQcgXkTgZecSLasYWHW9ke2kvs555yjbLySsBaGOMi4 UePSvBjQszLkriHqj1YhFhuYYyIpaw01SEwk4zj2PKuJ5LVXX6tl3nGHHRMrk+XN/ZyzzlH//ffb P3VGu2saSbQ8SPW46gT36dPqE1m7p3G22HwLJZIQHZkuVTfDtLE7X1VITCTzML/33ns1XYiKiRFJ vtBoO5kKTmSaNWEw55KzHjWOTOlaFL3LtLy6QxzsK60ckSQf2SiV1svIEnWjXHwN5hFJWRupcdAe ZQWtqWETE0kIMGmh/TL/WPNo/jGRoA7UhfD33XdfNqtEpmjTtGSzS+pv/RUiye/LLr5eS/VXyJyV SzZ6pGnZg2z4UH9ZR2pOyUknnaRusp4zdbMH6mPpxRrJ5vajbNtaPuXucvKBlmHnnXfODXb++eer Px8PpaQSIhm3k2yQa5AUbWpYxO1kAY1I0l4ujoAjMP8h4ESyhW0+O4nk2B/GpH/Q3/jH6zplzLSx XY89MHMqeHLVzOlkG5iNSKKNNCk1MJv/rCaSZ55e0OgdsN8BlmXR/dqrCkRz277bpu61k2pSIgkZ kvWkShjRPk6dMnP6k+l/WYuq8ZpLAGIiGU+LWmEMPwZa1PYIBE/WCKZthZ/sLE9kF7RespZM/a6+ +mpLRu833HCDussGIn1ngC9HJPGPiaQN9txlY40StTwiKZtbNB/7QIkLQdll3Z36x0QSTSNpxRpJ pvbRdnKZRpIwpt1jmsPKlDf9Cl7gQhjZ5Z8Ww/prHjExvMtNbccE1xKFyJPPkCFDzCmdapb1pKlb /GDLFlqDSGbbNs6n1DNaXMp80EEH5QaRDVvqL2snc/1xrIRIxu0kO90bpEV75rWTBTQieckll5iT 3x0BR2A+QsCJZCs09oRR45Mx3/6YjPthrM7/M3UaX0x34z9WpqsZ/BH8p0yeou74VU2sKsSRwZV3 dRs/Sd0szo8jZmoGXh76ckqeIFBcj9xXWH/HH/262pnr/mxgNiIJETNBA8FglR2YzX9WE8lz/1jQ OO6z9z6WZdH9qj9fqeXbSTSWJkx5m0YSssEaSMMAzaSRDYik1RUM4zZp7NnyiolknjbGpv3A3NpJ NihomcEVrRGEy/xIl2lw/LJEUnbWq7sc8aPZE6cckeQjJiaSkCXILusRSV920Wv87NS2TX+ffvrp Vs30TnubFjEmkqw7zhJJK1v2bnWNNVlgkhWWFFBOrlgTZv01j0iW6q+xRrJSImkESHbIZ4umHwNr rrmmli0mktStsb4T+1vC2bY193J32dGu+csmoNxgshlK/UtpLIlUCZGM24nlEFlhLVNeO1k4wxEN qosj4AjMfwg4kWyFNrdNNfHGmDhZIzp5m04gPpAg0kDqqusKpGh0lai24lSS5McRP6Z/0Jkqy4qt DWTNVyy2XvHgAw/WtOPNJxaHNXV5UkQkX2o4yOTFwc3ybGyzzY3XFbRwffv0zU3qjNMKmr3DZOOM CVPgMZEE98mCF5pWsHzm6WcUJ4hknZDOlkhMJCvFXI530fwhAEzHZoV1nQzMWSIpO4rVHY0l+TZG JBngYyIpx7doVmIeT9MhDzRhWSJp2lI2JWWFKX0jDXlEks075p+Nm31Hu8mGHMLHmkALJ0fgpGmx EcfE+s6hh85sc/Mr1V+bQyRN45c3xQ9mVs+YSFo5mnrPtm0l8W+55RYtg2mos3FYG0kZ+WAoJXLa gYZBQ11K4nYifFZYF2lYxO1k4YxIoiF1cQQcgfkPASeSrdDm7JqGwDS2AzueUrZsi4ijOBoZMmJp 4biPHTlzcJMzAmMvfZYjXfQPfnYq7O6771b37bfbvgGRZH0Yg0QpIknCTMkS5qmHn2yQZymHQYMG aZw9dtujJC7EtV3jpC9HyRQlB1GiXPidd855RX6XX1TYtX30UUdrnWom1CR1Mq1NOzz1+JOFOgmR zFt3SUKQNLsgy6UkJpKVYm6Y0h5ZIhlv4sgSSXbL2rQ3GqzGiCT+MZGUw9zTaqBtBDemqeWw8NSd B9OOoXm0taAWYPDgwRqPuDGRRHuI5pE/GPhxVSJyfJGG/d3vftcguJWDOjM1bmL9lZ3rtE3cToZt tr82h0jKcTZaNvq3LUuwMtgmMOrZGkQy27aWT7m7aV8pQ95vg1kE/PI2yFi6aBgJw8UUdilBq0kY 1s9mxfpEtp0snBNJQ8LvjsD8iQDjgu/abmHbo/WCwHDV1zUkJWjL8LNp1jg7tAEWNyWVEjZvB/X4 0ePSQQGCEE9DMXVo65jYbBILDWyDyd0D70qqJxTW8rFuzeJkB+Y4/q4zdocefsjhuu4u9iv1bNPL pP/YA48lNVNmTqfHcapkV/uWW2yp5TvwgAP1iBnzlzP01J0B7N//+tCc9d7vkn7qZ9P1tAGkESwf f7CgkUMjmSdgDvGwC8JaSmIiWSnmEETwhqixq9qE51/84hfqh3+WSBLOdoHL2YxKYGzaGEIFGZFD 0YvIaSkiCfHjGBzykfMBi3BlKpMNWfjJmZV6XBZ5cyxQvGEnJpIQLcoSr5EkTmNiZBEs4ultsGAK nzIcddRRRcnE/RVNJhtfaCsIXan+2hwiKRaH0vWgF110UVoGjuZh3SFl42oNIknicdtmN27ltS11 2mqrrbQMLEcAB5P4t0EfKCXU0ZYqiM3tIsIexzFNb147WRnkwPE4SvrsRDKFwh8cgfkSgTlNJNuB eqnjOWMvnu3dnrkLKVD3+M4zlwy+6V3O9NNnGVxLZdd8d6mB7BjWA8b18OuF5OBdzKmITK2aGqZV 1+lzl4W7BizZZEW0j6G+tmDpBj+sy3AIeVZkA03YcKMNU2csmMjUodYf04LUt/dqvcP9f70/dOk5 8/Bf3DmQmoOPkSWXXFIPHeYw6Z49e+ph11iH4UDqPBk8aHDod0W/1IsDsjlcGOsxck5g6h4/yDox tSIi5EOdu3XtFpZZdhl9lqnLsOqqqxaCC3ZD7rgnXNTvYn3nMGQhjmr2UdYWqtsuO+wSrr726iLs ruh3RRg0eFDgAPP+/a4NXReTQ9sF8+qx1eG5F54rHLJeok70GyGPhfzl36YcSJ6HuZAbPTDdrM3Q 1+TMPc2DMmFqEKseHMqMEE5IgZqexPpMLKKZ08Og7VB1zM5hRhBLNByuLRrOokOrMRMpO8E1CQ5I N+suQvzU7B9WW2h/ObMx/PnPf9Zw/DaEOAQ5/kZ/E9Qf05rkjTlBa7P4QHIwwwoMFkpIE+HwaRPS FOKjr926zey7WIbhcGvRhinOsmNdDySXdYyBPkI/ErIZOMDaJK+/cpi5EKaS/VXWi6Z15/B6If2W nN45FB38ZM2qHvhunvGB3xyqTv05RBv8KAfSWgeSZ9sWM5H8lsA7r23Jm4PHOVweyftt7LHHHkHW lKp/qX+os+ziV28Osu/Ro4c+y/pePSifF/ADIyG0ue3EwfaURYi1xo3/OSSybCMa49jLnx0BR2A+ QGBOH0g+bxBJ6SiQRUgjAnloJ4RRVuyrOT/cOizQUazbzLQ3jZtJfe20UDux1l7VCkznHp3Td3tg cMOKCNLvwn6h/039ww8jfzDvsNXmW4V+F1weei3Wq8i2NQEwf3b8ccer9RveITOiHVM7uCeffLIO UqLhxKuBTJ1SGx596NFw74P3hc+++CwlDJDyrDm0ODIk5/YBg8LQ554NEyZOUNKC/5BB94SNttw4 tfQDdk8/+Uy45IpLwvgJ49MkOnfqHA476LBw7NHHhq6RZRoCXH3V1eG2AbeFvtv0Dddd1T+1XIPl m6HPDA2nnX16WGzRxcJrrzesU1OIZIz5tddeq+TLSB7lkPWoakoQQm5C+nLAdRCNo1q+MXcIPGRO Di9Xu9PHHntsAHsT4kEYIZmQbdHqKnE0fyzCQBoxsQexQkS7mJo+xHwjBIp0ZDpY/e+4446AxRsk JkSiaVVzg/hDfCHIkFDMJkIUKYOs0VOzmhpZ/oF8Y7mGctPH+fDgDuEy0gUxjLEgHWyNU2/RNKYf g6QJKYEkQeAgSbHQXyEl1A+hv2J5Rc5OVMwIH/dXykb5DXvRrMXJBQgXxFemgdWCjXkSHqzByDCD NPGBBEGD/NFeWctAFr+pd3DHHOijjz5a1LbgBpGTg8cbmOsUTa6akoTIm/BhIppcbSs+BMoJbSNr ZYNMlStRhPQj2Ee3fsQ7FpdEa6nWf8DFhA87+nL68WceM+5mJQnTlfaRkQnir46AIzAPI+BEshUb VwnhJCGEM/8Ga+qlzCDGWcv6yjReKc2lhZcp3DBV8sGE4dfffB1Gi2nE1X66aliw54JqDrBTt86h Q+eG9r0njpoYPhWzdFOTqWH9jTcIDJiViBHdUprSxtKA3MlUfUqqCW9mHy0ueYg1n/Dd99+JecTh SgJXWmEl1azmmZAknmGGv5l9xM55zfiCZqwUjgySlWokrXzx/UsxZQfBYYDF1F1WSB8CgvYQYsgF WVpqqYJ5SQgBpAXNUNwGFs/SgwDIRgclYuSzwgorpOEXX3xxC6YkDhOKRubwQPME2YDIQRLROGcF P4gyZYEQEo67TDlrUNlc1EADRR4ybV5Egixd8kQbGdtUtjxw44LMgcsqq6yipiUhLxChmNBYemg4 0ZqjuZQd1IoXZZwVgkaOvCCs5MV9Vgo48qHFLAFtg+Y51uRm86ZvoNVFY0jb059mVRnBO24ntNUu joAj4AiUQsCJZClkWuCe1MuUu5A9iFfeVHYLki6OKoSVfGR3t+bVroNoQoUItGWZbdi1ZZBKlB1y wgXZqkRLBRGBoMREUo6LCXK+pBLWd955J7Xpnc2SeOSFdou8SKu1+x7lIg8TiGhr52Fp+90RcAQc AUegeQg4kWwebh7LEWjTCDCVy1QnaydZZ8vUKsSRaV60iExRMlU5JwWtMYQVgajOKm3knKyj5+0I OAKOQFtHwIlkW29BL78j0AwEIJKlNmmwFpE1cfG0ezOyaHEUpptNWB/q4gg4Ao6AIzD3IeBEcu5r Ey+RIzDLEZADt4OcaRk+/PBDXc/JFDXr9ORYoKINNrO8IJ6BI+AIOAKOQJtGwIlkm24+L7wj4Ag4 Ao6AI+AIOAJzDgEnknMOe8/ZEXAEHAFHwBFwBByBNo2AE8k23XxeeEfAEXAEHAFHwBFwBOYcAk4k 5xz2nrMj4Ag4Ao6AI+AIOAJtGgEnkm26+bzwjoAj4Ag4Ao6AI+AIzDkEnEjOOezni5yxwINVm05d O4VSFmrKAVE9pmDDfAGxX55nradc3KwfFnbqptSJucoOYq6yS9Z7rnu3A78pGFZjGhMO8MZqDGcv Et4s1ZSLR1jiEJeDxYk3qyymlCuH+zkCjoAj4Ai0TQScSLbNdmszpcaGOOYPO3btGDr3aPpZgGYG ETvl2CvPk9oJBZOIncQ+efsOpe0OT8VUI0RSzEdCTOdWgdhhujA244ht6VJWXSCDmEgkXiwQw169 epUkhpzTiInCrGCqr3v37llnf3cEHAFHwBFwBBog4ESyASTu0JoIQN6USHYRjWS3xrVq2bwrIZJT RoudcpEuvbqIrfHSNpLndiKJVrCqqqoBIaRu5YgktryNRHJwN4QTkgjBhExiy5l7LJBUyCeCBhLz g6bRxM3JJCi4OAKOgCPgCDSGgBPJxhBy/zmKwPxEJGtqasKkSZMUb5tixg0pRSQhkBBJpEePHqk1 GkjhuHHj1B3tIsQwFiOfkEiIpmk7IZeQTN4XXXTR1D2O68+OgCPgCDgCjoAh4ETSkGjBvX5qvcZm WpX1gKIK0mnY9h3bqzauvm564Lljl4ZTs0n99IA/d4kmU7PtNGyeZm16Xb2Gade+ECZb5KQ+CdMl HaS56wmJTzql8ojzTKZLftOmC9mQckeaQNzQhsXSXsrcrsy0M2HBkToi7WX6uYOkmUckSXu6YGaS Tm13l6ltwdkkW4esRpJyattJeu1onxJT55Ye1l+4TFrb9jOkEU0ipA8iGRPLUkQS4kk4COEiiyxi RSuKm/Vj7eXYsWM1bM+ePdXOtkXEHX8k9rNpduqc1W5aXAtD2cGJdAjbGE6EhfhCXokbC+4mpFUq bwszN99jk49WTurblutk9fC7I+AIzL8IOJFshba3qdUghCoYf5LnDp07KpG0LCCSnXvOXCcIATIS amHs3r5Te90QAhkysc0ivHdZuGsRaYJhVo+tDpA7SB3TvM0Ry4P8u/TqmpvEAw88EC666KLQe7Xe 4a5b7pT8isPWjK9JCaElUG6NJGWunUicmSSNeOBVIOZBsJi5RhKyeUW/K8OQ+4aE7ftuFy47/zLL puieXQsZE0lwnVYzk6QQUeuxkNR5JuRF6aH9i4kk08GmySsKKC+XXnppuPfee9Xc4PXXX5/1rui9 EiKJqUPK1KVLFyV+JAzRxj0m85BMCCVSXV2tU+g8o3U0IsO6zMmTC8sE8GOafMEFF+RRiSfEsNSU dzxVTprkQXoQJdZplhPyzAtL+Y2cEp9yPvLII9r3Vl999UA/bCsCHuuvv36D4l5zzTVh1113beDu Do6AI+AItBUE5jSR/H8AAAD//yLIHGEAAEAASURBVOydBZwcRfr3K7oRJAnuluDu9ofg7n5w+Bv8 DjjcEtz9gMMPghPc/XCXhOASCARCSIivZHfT7/N9dp9OTW/37MzsbHYD9exntrvL66nq7l8/UtUh EnIZ5Edxbtd2znH69Oka7h8551dfXx8fv/32Wz3v379/Rm2lB1f+PlUzd+jYwXWq6Ozqqmuda+xV xy6dXIcOztVPq9c0Pebu6ZxcQ1V/VLmofrrk6eQ6duroyD+9Porzc919rh4NiRv/V0+odtNr612H ThLXW+Iay6qZVOPqa+q0jG69u+sxJ2OBF7SzZmK1pu4xj7Q1he699143aNAg12+pfu6BO+53XXp0 cV16do1T0v/pdQ0MqJ9WJ32MXOfunV3X2SriNP5J9YQq6dN0DSJdh44dhV91cRgRFXNUKG85j6ZH 7sLzL3B33HWn23zTzd2l51xCsOvcjbyNDJHrDsJTwoymTZ3m6iplbBqJseoofKyrljZKmVDX2bpK W7s0psg91NZKv2ReGXXt2lXGdkZ9Fs4R/sAn5tuNN97oRxV8Xl1d7SZPnqzp55577tS6fv/9d42f bbbZXPfu3fWcPOTt0qWLo81Qr1699JrzqVOnusrKStdR+DzXXHMRpPfKH3/8oeedO8scrqvT9OSD 0vJoROM/v07yTJs2zU2cOFHbTNvzEelI36NHD9ez54w5x/1NuBHtHTJkiPJ26aWXdk888YRFtftj TU2NO+igg+Jn2LBhw5THl19+udt+++3bfftDAwMHAgcCB7I48L///U/fJ3379nWdOgmekWe1/bjm PWnXds7RfpTLuX9Mnmtkxr8O8rL40wDJijm7uU5dO7lpUwSwVNUqY7rP3QAEK8cK2JSeAvI6du6o 7AD4KdD0wA8RPpizMo1/AJ7q8QJA5QhI6jp7hQKhaZNrNElFL2mDgNeSSYajcmylZvfb6pdnQLLv Un3dg3c84JJt9NMawM0CkgBIgCREX3zg5wNMH0iS9qKLLnK3336723LLLd3FZ11EkOsmfYefWeQD SYAvANjI6iI/5aRRewOSgNpx48ZpU+eYYw5XUVGhwHHChAl60wLoDBxaPImnTJniqqqq9Ibv06eP 5icP/QPI8QEGEOUBYPGEWVk+KCUztzDt4GiAlvOxY8dq2b1793aA0ywiHennnHNOBzg3IuzPAiSt T3bcZJNN3C+//OICkDSOhGPgQODArMqBACTLMHImkezWR0CiSMEAkYDJjl06CihpkBIB/qbXTXeF Aj0DnmkSMh9oAohqRdIGJSWDcdcyoXqcYsaJfBRYW/26kYTK214lg/c9cL9KhfouKUDyzgccYNm+ JmYU1HDWHJCMQXeK9NXvZ1mBpPRRJcNeY2tlzGplzFTS2ydXCmzJkNL5Ekkkfln9HjQTJJK0Z/z4 8do8QBjt4RrQB3AElBmYM4BH4kmTJjkkZKQHFJrkE7AH6DPpI33zpYmUTZ1IPinPiLIoE/Ilp5be rxvACs0+++wKVH2A6uclDUDSJKpc80X74IMP6tyb1SSStN+nACR9boTzwIHAgVmZAwFIlmH0DEii hka1iqoUCaEv3TKJV1J6h0ROVcGi/o08tSnqYCgpObPmAh6//2aE++KrL9x3I75zdfV1bol+S7j+ okqdd955LZmCzNpGdS6SqA8/+dB9/e3XrlYAwZKLL+lWXWkVN/9888fp6UNtJRLVOpUOjh7/m3v3 7Xfd11987Zbu289tsNGG7tU3X42B5EN3D3EA6CShcv3444/dZ0M/U+np8iss5zbYeEMFEH7amknV opKvV/V+xRwJSaAACZOO5gOSg04a6D746AP32befu169e7nVVltNf349nCORrJw41X007GM3cvRI 99tvv2l7ACXLLr2s69O9t45f0pzAL2fkyJHus88+c998842CnEUWWaQJz0k/KA+Q/PHHHx0/aNVV V1XQpxeN/4h79913HeYYiy++uFt99dVVBf3DDz+oxHD55ZfXlD4I+/nnnx08n2+++TQP4O61115z n376qYahPl100UU1nwFJgCNSMeoiP31ZYYUV3LLLLqtAE+Bmqm9AHeUhyVxppZXcQgstFDeZ8j75 5BOVHq688srx/GO+wacxY8Zo2UsttZR7//333UcffaTglXI22mgjVbMbiI0LlRN4/d5777nvv//e LbPMMm699dZzL730kvK2NYBkoWNrbUSdT3++/PJLnQuodRirBRZYwJJkHosFkl988YWOJW2cZ555 3HLLLefWWGMNBeNpldA27j/GcMMNN9SPC67feustTc44bbzxxpkfQmllhrDAgcCBwIE0DgQgmcaV IsOygCRqboAjFANJz9YPsAnozEdpUkZAwjXXXONuu+22HAkZ5aCOHDhwoNtrr720WAAnQHLo8KHu lIGnutG/jc6prltFN3fK8Se7nbbbScMBUdhgIkl84rkn3bkXnZsjFZpj9jnc1tts7R544AGHRPKR Bx9uYvt4//33uwsvvFBBh1/Zggsu6K688koFTxZu0k9T01u4HY23WUAScDFx/ET3+ZefWxY97rHH Hgo4fJXqW6+95Y485khXVd2gSvczIL07+diT3K477dpEWkm6YnhO+kEZQPLDDz90AwYMUPUyL/Jr r71WVdLkgR577DF3+umn5/JcpIs77LCDu/vuu50PoAB3JnE87rjjFNQcfPDBqka+6aabGgps/I/0 EQBHPwF4gL9///vf7qGHHspJxwUA5ayzzlIAioQSov+AD+jWW29166yzjko0rQ1///vf3YgRI3Tu /e1vf9N05Ln44ou13QAnpJCPP/64xtk/gNdll12mam1fyvnII4+4M888swkftt66Ye75fLCySj0W O7bUAyiD57/++mtOtd26dVPe7bbbbjnhyYtCgSSqfe6le+65J1mEW3vttd0VV1yhwDIZ+cEHH7h9 991Xg1955RXH/WBzxdIeffTR7phjjrHLcAwcCBwIHCiJAwFIlsS23EwGdpISyXxAEvtIwBqE/WAX cfDAOcTIAFYakDziiCPcyy+/rEnXWWsdt9Zqa7qu3bq6r7772j377LPu0EMPdccff7wV5cb+PtZt tvlmKgVCfbj77rs7XnjPP/+8+/zzBgB2w/U3uE033VSdd7C/fPPlN90hRx2iZSy3zLJuy023dOMn jncPPjwkBmIAyccefcx1FqcVo1tuucVdeumlernmmmu6jdbfyNVUVbsnn3vK/TjyR3WoeO6552Kp lQHsUoGk1bvNFlu7lVdd2X30ycfuhRde0OAjjzzS/fOf/7Qk7pknnnHHnnCsw7Zz/Q3WVwkdqtrX X3/dvfnmm5runDPOdnv9fe84j534PF9//fUVSAFS4V8az9OA5Ntvv+0oB6neVlttpSDAB7qATANh /fr1c4Am7BIfffRRVTfTliSAMmcb+kl+8iEFRCq91lprKXD86quvtJ1Dhw7VccfRBnDCxwCExApA jlSSMCSdSAAHDx6sAI80SSC5yiqrKDA0tfj++++vkkM+YqwPmAGcd955CiQpA9piiy0cHxTwDIkw dOKJJzqAKDaekA+CkL5uu+22aoN53333xR8nST5oxhL/FTu2ALLNNmvmfrqh8X7KaFOhQPKCC8Sp 7I47tBTuT+6pn376KR4nJMgPP/xwk1p8HiL5RTIN8GR+YF6AdJmPTXgfKHAgcCBwoCUcaGsgiR1U JsmLSLS9DT95uUXy0tef2E1F8qUeycstkpdyJC/GSKQskahzIvEAjcQ2KxLj/0hUatHo0aOjUaNG Ra+++mokX+aZdbUkYuqYKRG/6fXTtRixt9NrAUlxsVXjKzVM1NgaJipdvSY8jab+3lDmtCk1OdH0 Q16i+rv+quuiqvFVWg71U+/w4cMjAVI5ec4//3xNL5KmSFRjcRx8E1CpcbvssksczslB+x+o4Tts v300duTvUfXE6khU3tErz7ys4bRh2623jftMHgE1kaiVNV4AhI4d+WjbhN/HR/Ly1LiTTz6Z5ErG B59XFgc/jbfGN4sTIBS34+LzLtZ04umt0SJN0zh56eq8sDzffvlt9Oqz/4vS6qL/9Gm3XXaz5PHR 57l4YMfz0BKk8VwAlZYn0kdNJjdaJC90DTvhhBO0DMtvR/kA0HgBTjqXmdvMYflo0HDaJypqS65H m+f77LNPnOawww7T/Iwv+fm98cYbcZ0CGOO2nHbaaXofWaEC8OJynnzySQuOBDDG4QK8dayJFFCi 5W+zzTYaL1LTOA8n5557bpxPpK96f9IukeRF1ub99tsv4v42OuSQQzSPSGF1/Oy+F7Afl5Xkg+Ut 9uiP7c0339wke9rYlnI/JQsWExTti3ieJ6Pia+4nkQJrOvjokz9Oou73o/RcVO4xr5h3zD+feEbS t0CBA4EDgQMt5QDYimcpWAvMxTtHPrgjEYToM180YPos59nPew3sBoYDy9nznXcAP8N8HAulPwWQ HD/qj+iPn8dFVZVV+sKdMmGKXk/8bYJe8xKe8Nt4DauZWq28mTRmYpM0pOM3ddJUjaPMyeMmxQCA jIcffri+ILbfdvuo8o+pWlbN5JoYcNXXzXgha6T8ExWq5jn77LMtKD4+88wz8QsHgAEx2AZW77r9 Li27VgCwATvAlgLJbbaNy+FE1KkaLtItnSSEGZCsmVwd8aIm37rrrkuU0pTxDbyir9VVDf03Phgf iZs6cUoOHwxIikQm+uXbUdpGA5uAZZGoaV0vvviiVRXVCCgHmKYByVtuuqWh7euuF6e3E+M5wIab wNqXb6L7QFIksBHtpO+irs0BTVaHz3MxDdBgA5LclCLl0/xJAMUHFPEGykRS2ATkcTP7JA4rWpbY 2UXfffedH6U3tkhLNV6kVXEcfbY5AZCkTr99gF/ik0DSQBegXuwxlXc8LMh/ww03aB7qM0rywXjN kYePqGg1T5IPxPlp853z4DKysd1xxx31AWbh+Y7F3k9pZRUCJGWpI+0r4wSoTJLx3P8wszQ+kJQV Diw4HAMHAgcCB8rOgbYGkrP88j/YMKE6KpR233V3N/DsgUXlwb4JFSG05RZbqor4iEMPd/88/lj1 MibcVOHJ9SXlpa11cbzqqqucSI5IHhNqug022ECvUWWi/hJwoepEAocMftAttcRSsWc2a19ecc3l 7s57B7t+4nzz5FNPxmWdeuqpsZoNFRok4FO9bznHNtFsykRCpmrTYnjn88GW/8Ex5L7b79W1KjEl YK1KeIC6FrUv9oaoXSGcbSb/Mck99szjbuhnQ518Oamaj7jKqZVuzO9jXEXXCjfs02EExYQaGkcX bMqwbzTC3rA5r208nJkj8H/++edXkwTsWJOEY812222nwayPCP8EDKk9I4EsdYRtooC1nPUTKRf1 t6m2UX8KQIs9scnre01zjX3tddddp045d911l3pqo2KXp4vyA7tGbBSZC8wJSIBabCNJ2BJLLKHh /MOh44ADDlCVugDoWLVNnI0TKljW0zTPbDy6MXEgPQ495gTizz2RiMYOQpQFr7GxxTbY50Ox96A/ j2xs//GPf7ijjjqKavJSKfdTWoGFqLZtnHBSevrpp5sUY+YT/jhZIl+1jeob/gcKHAgcCBxoDQ60 tWo7AMkCRtVefDVTa9zqa6+uS7BccN4Fbrc9Zhj0s7C5qLl1rUrf3hCvXF5aEKABuzmfRKqmLxmO AIidd97ZAfJEvajJXnriRTf3vHPHyxjhvIMd5FXXX90ESIpUTB06yIgTTz56ZMgjbuHFFy4ZUBtA AQTfeN2NunSP1Yfn/O777e6+/f477cdJJ52kUcM/Ge4OGXCImzCxYQkaArHLA9iJlCpesxCbQiOA A04mxIt0TZ1eLK4QIGlp7YiDhkjB7DI+YqeJbSv01FNPxbaJloCx+89//uOWXHJJBXnYuBrhPAPA xUZyzz33VCcQ2g3hZMPSQD7gNcCPowtgBQJIkgcwCVDjt/DCC6uXNPE+kMRWkTgjwPLee++dCiQv ueQSBcCME44hLDcEscQQ4OiMM85QIPvOO+9ouD/3AJe+Aw59uPPOO9UGtxxA0h9b5pOYN2gb8v0r 5X5KK68QIGnjhGMT/U4Sjlo4TPnjZGl8IIlnOctBBQocCBwIHGgNDrQ1kPxTqLbH/Tw2GvfT2Eik Wqrumzxhsl6jzkb9x2/8aLHblDSm2iZsiqhr/xg1TsOJ48c14ZZ+0tiJqtKVNShVLbvKyquouksW BW8injbbTNS3puZFJYbKkR82ZknCTsHi5cWu0b5a7IfPR0QiyYuzYYd49aVXaZ7tt8u11zvwwAa7 yqMPP0rbavaNaUez/TT+0E/jgR0nj58c82eK8NRXSZpqG/s6iL5X/dFgh0p9W2+1tbZRpLBx23fY fgcN679x/wiVN2pho5dfeCnmg4XZEXUxPBIwl6M+LUS1jYpdQEBsK4iaUrynrej4KCAwrl92PVHV L+pf+wkg03hxwNH5FGdsPBEPXY2HL5YH+8W0NpoNqThbxLbElge7FnGW0rKwezRCVWzzBNs65pXl wc4ly0bSyhJv8kjAoxWnpg/i2KNl+qYO/tzDjtJXUVPP9ddfr3mSqm2bR4Uc/XlkY5t2P8WN9U5K uZ+87PFpIaptGycB6XE+/0SAeZNxsnifjxYWjoEDgQOBA63BgbZWbf8pgGSLBkbsSetrxZGopi7H cSWrzJ122klfHiJByUqSEw6QMCcPUXHlxHGBXaQBBFkLUOMxmLWwNIN8UalpfPJljg0m+QA1JRG8 EKAqC5E3m92ApOxsk5oWmzzagj0g5PdJ1k1skkfUtXGfk+CrWJ5TuKhstTwAFAQggl+0CacjnMJ8 wkDZeA4ISJKo6DU+yXNLJ+p7jQc483GQ7IOl4yiSzbgdXItkTvMYwMLmjrbg9GJEnJgRaDigN0nG b8C2TwYksUVMkjmM+EDSHyfxMs8BkvQpa+4lyy70utixLeV+SmsLcwAemz1sWprkOCXTpI2TpQlA 0jgRjoEDgQOtzYEAJFubw2UuX9S0+gLi5etLePJVY9IiWQ6nSTKxvdPykJwhjYIADeYtKqqznDyA DpOmJEGNqDy1LFmyJcc7PKeAMl0YkORlLAtW55SKxM9AmSxorXFff/11HJYGjsV8II5PgrBSeG5A 0ry2aQRtMFAvNnk5bYavjCntJq9PSOIsLslzS2dAUlTVFpR5RPJs/JGFrnPSAUKtrqRzltjiaT5Z 6zInj8/blgJJf+5dffXVMZCEB/nmXk6DirgoZWyLvZ/SmoOUkTEQ9XVatIaVOk5kDkAyk60hInAg cKDMHAhAsswMbe3iAE0ANV5CSHl8yRYAiBc54NAnWYdO06NWlbUj4yg8dsV2TePEkSQO5+Scc87R cECFOILEcaZapP4kqEHqJuvraT68iJEu+QRQxVMX7+6Wkg8kWTYHr10IcG0ezLzwDRSi8jSJGkve mPSNeACLASuOlsfaWArPAYOU5QNJyvMlnwBvn8yLmfGVhbu1HQA7wIa1L8lzy18MkGScbNwxDfA/ SGTdQq2LDwvZscWK16MtFcXRPPwxD7C6aWNLgSQV2dwT28BI1ulUMEl4vrlHfClUytiWcj8l22bz Q9Yk1WUzkvFclzpO5A1AEi4EChwIHJgZHGhrIDnLO9u0huFqc2XilYsHNsRuIQIQ1WEEz188lWUd wZwFyXGUEACiW87hYbviiiuqk4lI5nSBZ5wlWIhagEBctYBAdbxhBxTi8a4W0Op8RxTS42HsE84S eL/KS1AXv6ZtOHvgpCAvbXVaYUF0HFdaQuZsY2XgEY13q0jHlAc4ZsAjFvU2OuWUU9RRhes+ffro Djt4CbMlId7EeLBDbHnnO6cQVizPzaNWpLfqrUwZRowPxsk4zLCzDFvrQWxrx24kxmMcJARIKi/Z +pAFvNN4Tt4DxGsah5VCdythvNk5BqLvAhwdY453OiTL4cQLy2uA/GPHIna8gZhHLEpOeuYX7RRw rvG2owrp2LVGln3Sxe7hoU94beMtzViwWLtRqXPP8hd7LHZsS7mfkm2ij/Kho7wjjrHG6YsdcfxF wksZJ8rznW1sPhEeKHAgcCBwoNwcaGtnmwAkSxxRAJuoHhUc+kUACPD2ZKcSnwCEIolz4mSinrkW R/rLL79cl5uxMDsC/NgdZoRsfWfE9nksMcPuNSy9w5Z+SSI9IIWXmXwNxdG8KPEaF6ec2JM8jizy xLyBWb6FXVzYQk5Un1oKnr7sCEKcT3g3A/B88ItXs9hZ6i4fIllTAAmQTKNieM7Y0CZbjscvj+V6 2PIQ4Ar//W0DRTroZPFp3W2H+MUWW0yXBQKMixRWwS+ALkkHHXSQLqFT6DI25GdnI4AhS/EY4YmO BzgfA4BFnwCK9AtwY8S+z3j78wOwEI8HtxGe2iz7w04wIlG0YD2yAxHAFyBrOwtZglLnnuUv9ljM 2FJ2KfdTsk3sn80HEbsjUR7EygfMUZ+KHSfysh0mZfFBlDWf/TrCeeBA4EDgQKkcCECyVM61k3xs d4ZUDRDF1nP+sixpTRQVr77wxeZMJXhIg5ojpIlI7ZCcARwKJeoCENBG1gqkbf5yLoWWU0g6Wcja ffbZZyr9pJ1JEOSXgdQWSRqgCYkpx2KoWJ4XU7af1qS6hJkEFskywL9cBNBHOiaLuOvYsrxQ2jqX fn3wj3EFwPvrSfppynVe6twrtf5ix7aU+6mUtpUyTqXUE/IEDgQOBA4Uy4EAJIvlWEgfONCKHOCD IAnkCENqKnaJ7thjj9X9uluxCaHowIHAgcCBwIHAgYI5EIBkwawKCQMHWp8D4nzhsKvcfPPN3SKL LKLqb2wMUf1iR4dpAmruQIEDgQOBA4EDgQPtgQMBSLaHUQhtCBxo5AAOLKi0kwR4RL2NzWWgwIHA gcCBwIHAgfbCgQAkyzESYmdWObZSS+rWu7vr2DnXSaEcVcyqZUybXONksXXXpXsX16VncbaIxfQ5 qo9ki8iGMeg+V48mXtfFlNWWaWXZFidrX6pNKvZ62KTijY4XNU4pScI5B/tQtnqc1bbBAzDjqc72 jL179052rd1ez8o8b7dMDQ0LHAgcmGU5EIBkOYYuAMlMLtZMqnH1AiQ7d+/sus5WkZmupRHTZa/x 6j9kr3EhBZKy3/ZfgfBEx+FjVgSStJv2YxNaiNNXexnPWZnn7YWHoR2BA4EDfx4OBCBZjrEMQDKT i7JPdwOQ7CYSyR5dMtO1NCKaHrnqCQ1AEqlwch3IlpbfXvPPyqAmAMn2OqtCuwIHAgcCBwrnQACS hfMqO2UAktm8CTGtyoEAJFuVvamFz8o8T+1QCAwcCBwIHGgBBwKQbAHz4qwJIOlEqzp9Wr2bLnZ7 Hbt0dJ26dHId8qhap9dNd9NrJb1I1UiHjSV5kkQaqSpOk4zHThAVL9Spa9P8yfQFXUt9ddPqXCRt tLo7dOqg5WdJ/eiPvxA59XSUfnXolG47qukb253Vpo5pPJQG1UtdSUrjHWkiqYMxMR5Tb72MEx3r IDzvXNE5WdSMa+FDPWMkPxF3yvh0lLHtJNfSV/ljzNL4IdstyrjOaCP2gOUkH9SwyxHrg/KjLSy2 zi8fscg4P5YYYu1N2pcvD+NK+ZCtv8k1O9tA5LVwDWj8R/mkoy7qIA07xND+fKpty2PLIlF+Ph6W 2j6/rc2dt4Tn1j74wLnxO23dU/pOGhuXZLvgCT8ojeetPfeS7QnXgQOBA39NDgQgWY5xl4e9Odt0 FqeSuqqGF60VzUu9Ys5uCiotTI8CTqZNEWeU6rqcYC4AoBVzdMsBoLWiJq6tbCi7iVOPtKFKbARR 8QJwuvXq1qTMYgMAWjUTqpuAQiun+9zpTi3VkkcBlyWUYz4byZqJ1Q2AzkufPIV/SXBMHdSVpCwb SdTsdcI/ygFMJvkOz7vN2V2AYm6J8LRmEn2aAQhJ0blbZ3UkEhwpY1XhOqUAUcCADyR54acBztwa C78yUAPAAnQAUHxiG0YAZpJIi9MI6uUkURaOO1ngBicgCLtGzv3+Ed6jRw/Xs2dPTpXMqcauOeo9 IQ5CxKUBScpktxf4lyS27KT8ND6Svtj2Jctv7rpUntM2+pTkF/UxRoyVT+bUQxjOSD6AZvzYkQgg yXj16tXLz6rnrT33mlQYAgIHAgf+khwIQLIcwy4PdQOSFAdIAWRAgBWACOAk6U08bYoAm0bQCbgB ACI1M4CDlAvA6JOBNKSC3Xv3iEGPObVQt9oIyrGlhM0h4IkyO1VI+0SiSF8aJHPTM51a6qoFPNVJ n4XqkWaKFDAfkFQepUgkrR7KSQOSlFtroB0Q1QjImwOSlAcB/DoKH+MxkrCus3WVtuZK8Yzn5GFc kazSLx9YtjWQpG0QTjcADkCESQmTwI50BoY4B9wCRgAltvQQZaR5UvtAjTQAV/JyDkCiTgN6lJ1M T/tI5wPYJJAEJLGNJOkAiwAs0lCXtY860nZJStbXXPtoY7Hk8468hfCcvowbN06rAqDTJ/qGVNbA P0s8JSWLgGL6RP8ZDwPPAFLyUhbhWaCfeo3K/RFj5YZj4EDgwF+bAwFIlmP8fSAJYOwjkrpGIAcw RFII4WxiS+AAyKrGNSxXkwRZeDkDDKEkgCJf9fgGySOgpuvsFQqEWGZH04skMku1qwkK/OdL+ypS ykRaWcgyRwZwk31srhnKnz+EP4JHAdnwIR8V4rVtEknKYRx85x8DzUlpLmDRnHjgtX0gUIYvSW0P QDIJGFlaB+AF+GCLSgMhPqhJAjLAie37nAZsfKAGD5JpKJsfwBKaOHGigkuukZpZGwCcxEFJIGlA jbSAJOKNzEGHaySifhxhxbaPPMWStY98hfLc8iT7BGgGLAIm4VESvMNLJI8cTbrMmDK2EDwFyKcR vCCfUQCSxolwDBwIHCgnBwKQLAc3PSCJNAuplk8GpnwJI1IwA39pErQqAVFI3DoJWKwQAOMTdn2A GAhAhMpbzz2gqgH2r0E4aFf5j42CTIAigBVCTQ7AKoWs70UBSWmvAjtpA5LXQrywiwKS0scec89Q vdIvJJu1IiFWSa98CBiZ1JgPA8bJJ38csoAkAMF/mfPSNzDll1XquQEU8gMWfckUEkYkexCqaiRn kA9EknmIJw95DbgQZuQDtSQItTR2BCSNHTtWL9NUtwAk+JMEkuzlDSFxpA6fKBPJHse0+GLb55ed 79wfs1J4TpuZB2k888F7c+AYlT7rhtL/JIhNtr+1516yvnAdOBA48NfkQACS5Rh3eaibajsNUKC+ BpCg3jYAY/aOSeBizdGFvAVsqt1er9yXKWksv6VPStIsPJnOwrOOPqg1MMtLtJOsA4mkk/b4L9Ws ciy8FCBpfYdfagua4aRjdXAsBkj6gN7KYNH0aSIFTgJGbCPra2T/a1HtY7OaQwJ4K8dO1aC0cc9J 20oXBmrSpFlUaQDGB11me5cEcNZEk2QCepO2dz5QQ3pmkkfL6x99IJuW1trut8PPAyhOm2ukgZoD uml1Wvt8kGth+Y5+XdbuYnhu4NgH9FYfANPU3lkSRhszy5M2NhYXjoEDgQOBAzOTAwFIloPbHpBM k975qmoFkgKQDCw1BxSTwMZvLqpxVMCQqtNFepeklgBJbTcq84REE9vCrj1FslYAwCsWSMagWzpS DDgrBkimqcrjMfLAPrxEKot0NkuiWvl7+wCSWcDCpIu+JCwfUKTPBloAckgsffKBJDvtpAE9S++r r9Mkn0jWqMsHkpaHY5IAbr7E1Qd3lrbQ9pUDSBbKcx8cZwFFA5ppklvrm30UcJ0mubR04Rg4EDgQ ODAzORCAZDm47QHJNHvCGKRIXT3maVCpFgwkcarxVK3WXF81TpjZS1p8zjEBBHPikhdJLCp5cZ5B jatL5Uj6R554xF10xcVu2eWWdQ8++GCyhJzrYoCkb5fp25PmFNh4cfnll7v//ve/bsstt3SctxqQ bPRAz+JvKUByk002UZXv1Vdf3eK9s0061hyo8dWghQJJH+DZGPhAje0b85GftlAgSZ7Ro0e7zTff vEnRV1xxhdtuu+2ahPsBfp3NtQ8wWSj5gLlYnvsSx6RNqdVvQDJNYkka3xyB6zQQTXigwIHAgcCB mc2BACTLwXEPSHaVZWCS6xHG9neenR3L+CAtzJI41ogksF5U22nSMx80odK2pXaSziDl6FpOGY2g 8u677nEXXHaB69e3n3vyqSdzkiQvCgWS6kTE8kXCy7Q+J8u96KKL3O23365A8tprr201IJkP8KtD UKPDVJb0FBDhAxbA2frrr6+qTNoNEG4JGahJA32Ui40i9fuSLpMEpkkcyWNAE+cMgI9PxQA1XxKX pmZOazv8+vXXX92xxx6rkkoA3LBhw9SWkg+G7bff3m9Ok/Ni2tckc4EBae32s6bx3ICiPw6Wx+dT msSSeOxJGUfGxKS1aWVZmRxJDz+NskwFLD4cAwcCBwIHSuFAAJKlcC2ZRx7YZiOJ2hdQ4ZMtH+Or sc0mj3RqByhL/fiktncC3JqoVCWsanyDI46VZw4hWlaf7rpMj19Wuc/vvO1Od/7F55cPSEqfinWu mVlA0le1+/aj8NQ+EDjPApIAG/9lDhDYYIMNyg4kaUNS3emDKh+g+M4daQDPgJCvDqd8yC+zOYkf 6Q1A+RJRwiFT1SZBsIWb1A0J7i+//KKS5/YEJOlDoTw3E4M0cO57oiclt4DB5HqRBmQB2Ywf/Esj nG0AoUaYBmSltTThGDgQOBA4UCwHApAslmNp6T0gSbS/ZI+v1s6RVgII8cwWG0cFhCxvIy8GKAcY yjqS/jI7JiHTdSllHUmcdSCz5VPnHW99SY0s4R9STlTZeKEjNTVCGjr4tsFllUj6fSrUuWZmAUkR 67hKpI4yXoyTLRKvywJNFK92CYfaA5AEpKAaBWAAQFheB+CXBGrEAWwAuKjEkTqa6tZACn1KA5nF AkkrLwl6TCpKPcn2+WpcpG7bbLNNDpBEIkcaHIh8m0nKKrZ95CmWrE/kK5TnPlj01dcAPVvUHa96 4nwy6XCSf77HO+Nk4+fnDUDS50Y4DxwIHGgtDgQgWQ7OJoAkRRr4w1FDr8UxpZtIC33ypV28CNim L0IVKsv+QEnppm8XCXAZ9dsv7rPPPnPffPONq5WX63x95nP/t97/uQUWXkDXl/Tr4pyX0vvvv+++ /PJLfeH27dvXrb766m6BBRZIJtUdW/Bi/mnUz+6joR+6H0b+4Pot1c+ttdpa7n9vvKpAcumll3ZP PPFETl5U9oDnsePGuqHDhrovv/5KX3LL9Fvarb3WOm52eflDAFRbk9Gkr4T7oJVrI0C4vz6mAcnN NtnMnT/wPPf+B++7T6S+OWefw626yqpulZVXsawq8eXC1pGsnFbphn31aQ4fVllxZdenR58cz3or AL7/8es4N3T4UAUu66+zvqpah30+zL3z3ruabLU1VnWbbL5pzgsdUPPmm2+qapZEa665pltnnXXc //3f/+WVSALwPvnkE23fTz/95BZddFG3yiqruOWXX96aFB8N1DCmAJLFF1/cLbLIIu63335zb7/9 thsxYoRbbLHFVCU877zzxvl8sAYYA8xRr0mw0kANmQ2ojRo1SlXQOvekn9TZv39/59dBelPLMveG Dh3qvv/+ey2DPq200kpuvvnmawIkyWcLcXO+++67q93kueee6zbbbLNYwpuU3pGW9jHHv/jiC5Xk ITVdbrnl3BprrKH1kCZJtO3jjz/Wsd1www21zVy/9dZbmnTllVd2G2+8cTy2xnMrx/hHX0367INF 0vmSRa6RDnLP016jJHD3xyhZnvGVck1ya+XYMQBJ40Q4Bg4EDrQmBwKQLAd3PSAJ4GE9QvOmpnhs /ghPkxqoxDLFMzrpbAK4RIIJ1Xeod/+5/UZ32223xS8ujZB/AIJTjz/F/e3vf1MgauG8GI877jh9 +VsYR15CZ511ltttt938YPVUHnLfg+6ci87NedkhIdpysy3dQ48+5NKAJNLU+++7z11+7RWuqjp3 +70F5lvAXXTOhW7lFVbOWZzdB5I5jfAufCkvwQYk115zbd2l5fMvP/dSO7fLDru40/51qr6wzcEJ m9QP3vvAnTLwVDf6t9E56eHDKced7HbefmfH1o9Jeu/td93fD9xfg58e8pT7+2H7Kxj00x199NHu mGOO0SAkRkcddZT78MMP/SRu1113ddx0SATTbCRxNDnxxBPde++9l5OPi/3228+dfPLJObufGKjB pvCDDz5wBx98sI7X4MGDc/Ijefzoo49y8qLiBkQBRnxKU0NbPPVhq3ifjLGBJotj7g0cONDttdde FqRHeMDcA9z6BM8J32mnnZosxE06pJb8mJvwhbK32GILBXwA3eQ2iUgqzz//fG2bXw/na6+9tsNZ J00dD9/23XdfzfLKK6+4PfbYI17/0srxx9Z4ThsAkf4uPdzj3CPEJQk+s9i72ThaPKCSPByNAIrM ESgLKOYDmuSjHn9skZ6mPYNIGyhwIHAgcKBUDgQgWSrnmsmHCljV1iJlLOThDVAkDxI5k2ZmVXHE EUe4l19+WaNx3EDKxUvo888/d88++6w79NBD3fHHHx9nx+YNSQ4vHpZsQcLDy+n555/XPCS84YYb cjyI/Zfr8sst77beemt9sd3/wP3xizMNSN5yyy3u0ksv1bqRwG266ab6Qnv00UfdDz/8oIsoP/fc c00kV3FjCzwxIGnJsZ1bccUVFbi98MILGnzkkUe6f/7zn5ZEwUGxfLDMPj+QpH366acKTpZYeHE3 cdJE9+a7bymAAgRCBxxwgHvnnXcU2O+9995uoYUWci+99FIOsEwCSQAKfMauEDC35557uoUXXlil a4888ogCt4MOOsidcsop1qz4aPUts8wy7quvvlL+Ap6QZCG1RhrIj3FPEqCFH6DIBzPJdFy3dO7t sssu2jfGiPkKJeeeBnr/zEbykksuUckqgDWNLrjgAnfHHXdoFPOO+YdE94EHHtD+rbDCCu7hhx9u kjVrbPv166eS0ddeey1nbJMFANaQ/nGfN8c/8lp6zukLfG8N4kPBiHoKaZulD8fAgcCBwIFCOdDW QJKHaiaJxEM0vQ0/edFF8rDWn6iDIvnajuRBGYk0IBKpRSQv4UikK5HYhUUiDYrEYD8aM2ZMJJKM SNRw0auvvhqJtCGzrlklgn4IgNPfzTff3KTZw4cPj+QlnRMuUhpNL+q9aOTIkXEcfBNQqXHygo/D OTnkkEM0fIcddlD+WqSo+zScNgh4s2A9CgCKVlttNY0/77zzdOwsAXUJINA4kapZcMnHCy+8MG6H SJpyyhEJq8YJkNB5YZGl8MHyiro0rk+AZCQ3TiTONtHUMVP0x5yD95CopeO0AqCtiIh5u//++8dx AqjjOE4uvvjiuN0CunPi7r77bo0TNW2UjCOhX+5hhx2m94JfgKjY9d7xw4o9n1lzL9kuUZlr38WM IhkVXzP3RAWt6UQFHodzIh9XGs6cFTCfE8dF2tj6ifyx9cPb8znPS/lwjH88RwMFDgQOBA60BgfA VrwfwFpgLrCXCLAi0aooJhNNjL6LwQFgNrAbGI53ouE6nln8DPMV88z6UwBJmOI/tPOdwzSolDzk O/zww/WluOOOO+YANeKySOy7NM/ZZ5/dJMkzzzwTv2R//vlnjWewDazef//9TfKI6k/jk0Dypptu 0vD11ltPJ0kyI8CXctddd904qlQ+GJAUKZN+OMQFyglgWSRzWteLL74YRxXLB8sotpXRmy+/oeXR /gsvuDCaVjktmvp7A4icNqXGkupRJGeadqONNtIbw48U6VZcjg8kuWnEDlLjRKrmZ9Fz5pRIGDX+ rrvuahJvQJIyAFX5qFSez4y5l9buQoDkkCFDlDcA7bT+b7vtthqf9hHjA0mRdKc1YZYL4zljzyEe 1oECBwIHAgdaiwNtDSQ70LEs8akfxbld2zlHeQFruH/knJ+g2/j47bff6rm8lLKqKykcOyRUnYUS 9lfYJBabRyR8WsVWW23lRCLl/vGPf6gNXnP1wgPq4njVVVepB6yfB7U3y9FA2NWhDv3uu++cvHg1 7Mknn3So+HwSyZnaZwqoynG2OfXUU2PVoeXxx0wAamyj+cYbb6i3cKl8MNX2sssu6x577DG/eXqO 04QACnf66ac7AVna/2L5YIXiQPTuW++6Q446RIPuufVut9wyy+m5rnnJ1okzHNt1DUQB6I6xuuaa a6wYPcIDkdrqua/aZnkbVLgQTiQsK2O8I4xzAfpOQKCqWc855xyCYzLVNipdVMVZVMp8nZlzL63d ptrOt44kfL7uuuvcUkst5Z5++ukmxQwaNMjde++9Or+T9qO+ahvVNyrwQIEDgQOBA4EDhXGgrVXb AUgWME6AT17mgEE8SEXaoM4m2Js1Rz5AEUmWW2uttXKyALh5cXIEIO68884OkCeqbU2H5yrAxiez g0wCyX322UcdOkibZovnl/H444+rt3hLgSQgGKejJGEziUcx/TjppJN0+RgDaoXywcrE1vW9d95z +x/U4GzzxksCgnvPqV7kAMkk4WyC1zXHJOAj7aqrrqp2pj6QhM/YP0LYsuWzZ2M5HIC0TwYkAc2A 5ywqFUjOrLmX1u5CgKR9xGAvfOeddzYpBl7/+9//VptTbFV98oEkHt/JJXj8tOE8cCBwIHAgcCCX A20NJJG0ZJKAm1hfLi+yWJfe3mwk0fkX+jPVdqHpSWd5YJSpP0W6ksk3PwI1H+pYftjJJQk7BYsX SY5G+6o+8bRNZomuv/56zZNUbR944IEaLg4uTfJkBZTKB1NtiydzatGmyhQprMaXwge/YJ8nfnja uamZzzjjjCbRzGlZxkf55Ku2xbM5HgeRnjfJ11yA1SnbLjaXtOC52hZzL63xhai2zS5WHJvSioiw o2WeCwhvEl/M2DbJHAICBwIHAgf+4hxoa9X2nwJIzsw5JEul6AuxUFsugItI/TSPqO2aNBW7SAOS OIlAGMxamDmQ+BlFTajxSSCJDSb5ZCkVP3mrnBuQlC0GU8vH0Ya2yF7gGl8KH/yCiwEb4lWtdeP0 kiScwIy3PpDEKNnCxds7ma3ZawOSouJtNm2pCWbG3Etrm0gklTdp9rqW/j//+Y+mIW0aYRsJf3Ei S1IxY5vMG64DBwIHAgf+6hwIQHIWmwGiptUXIg4rU6dOLaj1SGF4icpyOE3Sy37VGodzCl5WEBJQ 84AVdWBOHiTDJiFKAklZW1DLQuLme4fnFFCmCwOS9EsWuc4pVdZL1HYQJ+sxxnHF8iHOKCfFgA2x UdT6RYWd4/FOeQBb2sXPB5LEiZpew0877TQui6KZASRnxtxL6zRSRvgl6uu0aA1Dmm58lcXIc9Ih ded+IT7N4ayYsc0pOFwEDgQOBA4EDkQBSM5ikwDQZKpRvGhZ7sgIqRsevYBDn/AC5iWKR6usHRlH iVNNDF5kweU4nBOx7dM8vIB9VauptSkvCSTxEpV1GjWf2EuqZNMvFKAKyMK7u6XkA0lZN1O94CkT cE3dtA/gCE+MSuGD5S0GbGAOgDc5bYCPRmKvGokzjIYTlwSSSNwIZ5xk7UPLpkf6IbarEeOE9DJJ MwNIzqy5l+zbwIEDlS+yZqouMZGM55q5Z0Accwf/I0vWl9T8fCzJDkBNshcztk0yh4DAgcCBwIG/ OAfaGkjO8s42uSanM+cKr1w8sCF2xBDgoQsbf/P1N7o14YBDB7h/nfivuDF4+grocyIl1MWPWbib nTdEba1OH927dXeDbx3sVlpzhvc5W+DheMNOHN27d3crrbiSG//HePfNd9/E5QroyfHaJgJHHXZ0 kRe7OtzQNvZyxumH7fFwFGJBdHYgaQmZ17aVMf/886vH7tdff63e2iwODY9Y4NuoWT5IP1m8mn4l yXfIsO302C2mkMWxl1xySV0gnIXB8drGcQXynW24FrCoO9OwtSHEYuSLyfaGYhOsvMPDHpL1uhz9 9cmcbfwdWPz4fOeMCXXQLltUO2sXlKy5x6oIeMmLOj9nMfyW8NzazFyUjwL1WCcMZxj4zo43tgA8 4YzdmWeeyakuvM/i7ORllQNIlsyKF8vXgMZ//tiymHugwIHAgcCBwIHCOdDWzjYBSBY+VjkpAWyi plNw6EewH/apsvPJBhtt6AcrIBSVqZN1FXOWlVla9sC+4KzzXd++/Vz3xF7gAD92hxkh+zUbrbby qm6zLTd3l112mctaeof0vNB5QcuHmmXVlz9e4+KUEy91E0cWecIuJ7feeqsuscP+zvfcc08M0GaT /bzZ5YTld5IEME7jA6CD5WVs2aJkvnfffVeXEQJovf7663F01naC9Bsgi4c7QA0CkIt9qYIZQCHL 1Wy++eZxWZwA5sTeTz3R2enGJ/pJerzQKcsnPL7x/C50WSjyAlxFoh23zy8PkNyrVy8/KD7Pmnvw EO9pWUc0TstJqTz3C2HvbD4e2A2H8iBWCYCfPrFbE8trsUWlEaB4wIAB+oGTtosMW0dSFmPLnuWB AgcCBwIHAgcK50AAkoXzql2mnDBhgq77CADp3b2XW2j+hVyF7OvdqaJzanvFE1e30EMCxZp7c3Sf 3bE/dodOHZsASSsAaSJSnUXmWdjNPdfcrlvv7gVt+0hdgFHayBJCSNgAea1BSPqQ+CH97Nu3b7Pb ziX5wLqNWcSSOQAuCEkYwMSkeIRlgUnikMgBgsgnJgl6JDyL4BVjA3HOFn8APkDkggsuqOtLpoGh rPKywikTsMURAjiy5BAAmP7S3iwgaWX6c4+2Mb75qBie5yunuTj6gCQSCTx7ayMRpj+BAgcCBwIH AgfKz4EAJMvP0zYrsXLsVFm52uUFksnG1VXVNgskk3n+atcG7gAjvXv3jkE04BLQhSQLoMyxJQSA pC4IwG1SR0CrSdh69uypwLUl9ZAXaSfAjjajKgYc+0Sd+day9NOG88CBwIHAgcCBvy4HApAs09jX T2uwe+vUpZObXi8769Syq07kOnXu6DrKotVZICOStPW1sjuPHNECd+zUwXUkj5STj6iPOiDKp97m gKTVNb1uutbBYtr1NXXZQFIaVC9pk0RdWTSDDx21P7SR/nWQflFfR5F8ppL0vR6e0ScBN526NPBg OryRP3iSxUNTHVMu0rpySOysjUh6xblFL7FH9RdaJ5x4KBmngUX+k73i1bYUwOpLSLE3JQ5KxhVZ hSZHYifLEKn00QeshZRFXpOYGvjkGkANIdm08GR5pGOs4Bn9MCmon444i+dIHtLCd66R8NIGbHyz gC5SVpO0UnZWOr/ecB44EDgQOBA4UBoHApAsjW85udj5pGpcpYZ17t7FIeXzqUPHDq5izm4Khvzw monVzoCXH855RwFSFbL1Hnl9oq6aSdUCuHIBXudunV2dgMIsiWRdtQDGyTV+UbqtX2dRgROXptoG 1FVPqM7NI1fd5+rRpF2aSMCgglm56Dp7hQBUqU/CfEpTu5faJ8oFVBiI4RoQCUApFyG1M1tFpI4G UlGli2dwXA3ApqU7ogDuAECAJoAp5IM+qwyQCbgqlQBj2BkCzIuVpALsTGpKOzj3QRttSqr6iac+ 8iYJqStSVvtIML5yTd+N4C/5rS7ikQ6n8cFPR36ArZVv5YVj4EDgQOBA4EB5OBCAZBn46ANJigP8 Aeyguqq6hhei4MEec/XM2ZO56o8qlUR2qmiQ1JFven0kwE5euPIO5RrQ5lP1hKoYRHbu3lnSdBQw WheHkTYJ1nxAiGQP+0na7APeNCAZSVtqDRTLSx3ACRUCJElnfEACaoA5vU8A4wbJHnyjLc31ifKh 1gaSgEXADQAS0AUhGTMpJdIupGyA1+ZsCjVznn94PUO+lNCklJRvQIx6WgKWDaxRBoAViSdlw0v6 A5DNKp90BiT9vnMOyAPUGzikL5QJr4gDzFE24A+eUS9EerOdtbYRDngkn/Xb8gOECc9S85OeeKMA JI0T4Rg4EDgQOFB+DgQgWQae+kASoKTOKHKEUHNXC2CEuszW1XURiaURamVU2OTxCdCFtBJCkmn7 OSOFBEhCSPwMrHLtA8wkkDTJp4JFcZRxjdX59aQBSco18vtRCJBUPogXuEmC/Lq69RLpbKN6PF+f rN20Idkna1drA0mzJQT8mLoZIAVYAcgAKgFEfry1rZgjwAeJJIRk0yRw1AWIBTwaeLX4Ysr301qf AIvUSx+SlJQqWrwPJAnDuclXZVMeP4AlZHUxD5ISRF/aa1JWA5LkJz3ja8seGcC2fNRL/UkKQDLJ kXAdOBA4EDjQehwIQLIMvPWBZJceXVyXnrmOC6ii62vqVV3drVfusi1Z1Zu9Y1cBn6jLIbyrkSKm SfV8oJYDunx1s1eW1Vs9XiScIjEsN5CEB/DCJ+uT376S+uQVCtAAOBgBugzEWFhLjqhkkYABugBz Zq9oQMcklgClueeeu+SqkNCZQw3giPq4BuSZM0wSUJVamfXJ8gMaAa7wkv4YPwFySV76QNKXJFpZ yWOalNXSUF/SVtOAJO0xUwH6TVoDrUg9cXSyMbHy7AgvAbNGpLMPGgsLx8CBwIHAgcCB8nAgAMky 8NEHkr4E0YpGPVzLEjspqmokcqiyUWnLNiyWRVTeDfZhPiAzQIoqHPvJHJIXbeXYBjtNH6j5kkQk pai2fYqBXJ7lf0jvl1OIRDKND1V/VGq/fHCcv08zbC79Pvntb+1zA10AKoAMUkFAjYEsA5K+6ruU NvnqcuoBsAGqTOpGna0BJH17TNrtgzsfzFmffCBpPLC45NHvE/xJA3MmDbV2GJC0a8o021FT6Vsb DMwn6w3XgQOBA4EDgQMzjwMBSJaB1z6QTANrvqNLj3nETrKRcH4xu0MLSx59CadJD1Fpo9pOUuXv Dc4fPujyJZVpALC2UkDu1PzrSFJPsUAyjQ9pQDLuk9h7dp2tsD4l+92a16aaRXWNZAuJpC+JMxvG loIaHygiIQRQAbxQ+QLCkLAlVd+l9tv6RP40NXm+PhmIIy8S2DRwSBxkksOGq/z/DTimAUnAO4DT gKu1oaU8z9+iEBs4EDgQOBA4UAgHApAshEvNpMkBkp79n2VLA5LYR9ZMavCixmkG20nUy0YGsHKA ZKOjTTFA0ne0aZdAUrzCaWMxfTIezYyjARurC1AHuDMAZWtJmuTQ0pVyNDWw5TWbQK591bdJ5ixd sUe/T2lg0KSs9DGprjcQR50s9p2P/LRmA5kvPXHWNgOWhAUgCRcCBQ4EDgQOtE8OBCBZhnHxgaQv DbSiZ0j9xAu7T4MXtkkjWeYnzW7S7Al9IGl5cL5BdexTVhtQkSMJhNKkhFZmuW0k0+pKk0ha/Wl8 yOqT32/OTT3KOeAHsFcuMptIK8/s9Oza1K4+8LG4Yo8GmMiXtP8zBxPi/GWIuC6W/D6ZlM8vwySW aQ5EPjhsDkj6UtRCwW85gCTSXd9GMkut7vc5nAcOBA4EDgQOlMaBACRL41tOLh/wsLQOYNIn86j2 AaB5JPthlsdXR/tA0gAp6XrMnbuUkC/1TIJZU3n7ZVldrH9J+9sKSNrOOrQnKTE121Likn0iDAI0 tOY6kr7KOSl19KWESYDZ0Lri/pskkFxJgGeSz3Koc32Al7aEjnmlJ/tLu4oBkqQvFmiXA0gyLv7H BTwDFAcKHAgcCBwIHCg/BwKQLANPfSBJcRWi3rbdX1gkfFqjCtsHQ9glAgyh7iyT06jWxhYRkBk7 23he4H49qMPNppBwVOEcIb8erlkYnPUsWfZHJYWNdfnAtK2ApCBBV8li7tJ0fxF2XRZooix11NCl Jn2iX1BrA0nqMIcbzg3gUS+AC9CCxMvWmCRNqQT4QSoJ+RJOX4Loq7tLrYd8BkwBWEgLTYrbXF3F Akm/vLTdf/gIIA39og0BSLZkVEPewIHAgcCBmc+BACTLwHMf4Flx5h3N0joQ14A4I995xeIBegAT aegkAABAAElEQVQoJdZ6FBCVlCKalzVp2HYQT3CtoxFwEZ4EkqreHt8A1ogHsEVSDVsmGjUBkgKU /F1tAE4GbnWbw8a1KMkf90vaYDvbFKraJr8vTeUa9TT10bcscEw6aGYAScAioJG6ICRcgD67TnNY 0YQl/DO1MllNJWvSNdTdSD7NPrOE4uMsAELApPJZ+E2fOKevUJpam/BigSR5TMLJOeXyoy76ZSpo U9cHIAmXAgUOBA4EDsw6HAhAsgxj5QPJrqLWZqkfA0AUj/qa8CQAQIWNjaCfFvCERzbSQpxQkkCS 8nxpJteQ5hEpJ2UlgSTxSUknYQDKTl07a3mAw24iGTXiRV/VuJyQhWUdY0/0ZoFkw04+/vI/VibO R9pnA96yYDnpdAF2KTdtOSHy0s7WVG1TB4DHthU0UAfIQ/WLJI1lcspJqLixiaRvRtQFYE3OIYsv 5QhoRNpqfbIy6A/Sw7S6SgGSlAtA5Of3iXD4SH22TaIBSd8z3mxHTRpsbchS8zMf/HrgXVpfqD9Q 4EBbcYD7zj7crA3cD3wwBgocmJU4EIBkGUbLB5KAMUAZwI1wJJF5X2KCFXLSCpAsiMhXx44k4lwi gLBQQqpIfdquQutKFP7ggw+6c845xy277LKO81YjAVK2NqbxtdXqylPwJZdc4m699dacFEsssYR7 9tlnc8LKfcFLBkAEYMo7h1pYMXUMHDjQvfDCC26PPfZwxx9/fAtLzM6OBNKAKy9NpJPlIADouuuu q/y6//773VJLLaXFUj78a2sCDG+88cbajAceeMAtt9xybd2kP039m2yyia6xevXVV7tNN910lulX Wz1XZhkGhYbOMhwIQLIMQ5UGJMtQbLst4t5773WDBg1ySy+9tHviiSdarZ2+yjuWerZabdkF09/H H39cE7BEz08//eQWX3xx99xzz2VnmskxgMEjjzxSgdQpp5yi7SumCf/617/ck08+6fbdd1931lln FZO1XaRFirv66qtrWx566CHXr18/PW8v0kgWk99ggw3i9q244ortgm9/hkasv/766tR17bXXui23 3HKW6dKs8FyZZZgZGtqmHAhAsgzsD0CyZUxEpY1qu5MstN6JnXfEZq9e1Pqo8NPsRFtWW8tyA1JO O+20dgckkfSZlOu+++5zq622WlEdveyyyxwPgx122MEddthhReVtD4nTgGR7kUbCnwAkW2+WzKpA 0udIe32u+G0M54EDWRwIQDKLM0WEByBZBLNSkvre48loXR6J7SAL1Pgn85f7ur0+8FsKJMvNp5ld ng8kkZIjLW9PFIBk641GAJKtx9tQcuBAIRwIQLIQLjWXRuwVp01t2KWmSw8x7C/R9rC5apLxI0eO dJ999pn75ptv1Jt2kUUWcf3793fzzjtvMqles/Xd+++/77788ktN37dvX1UHLrDAAqnpCaSO9957 z33//fdumWWWceutt5576aWXmlVtowL++OOPtS7s+5CWrbPOOurEkawMII7jEc5FnEMdRDLJEkoA yXzE0jEvvviithPvYHZQWWyxxVSNiHNKGgG6PvnkE20baupFF13UrbLKKm755ZdPS54TViyQLIYP fkU499BGxpY2ssMMPOSliW0hhIf3Rx99pOf0ySSJJ510UqzaJRKP6BVWWEHT+f8oG575NP/88zvm UT764osv3Keffqo8Z1Fy2rXGGmuk2jv++OOPjh/tx6aWvO+++67WSz5UkeWwk0wCSewi33nnHTdq 1CjtO/aTzI00gr/M8V9//VV5iv0rQHTllVdutm2FjBN15gOS2Iy+/fbb6sHOUkzU6xPOQ/CM+YCq Hl6jxh8+fLg6gdFWvPl94l7n/mOubLjhhmqXyvVbb72lyagDm82k7W0xzwj49vPPP+v8SgL38ePH 6/1l7bW2YYLxxhtvqAnGmmuuqe2H98OGDdPnFm01+1bLY0ecrODD0KFDtd1rrbWW8oI8rFdabtV2 oWNr7eNYzL3h5yv2uVLMOFk9zBdsdZnf3ONjxoxxr7/+uj5jFlxwQbf11ltnvjusjHAMHEjjQACS aVxp52E84K655hp32223xcunWJN5KeM4sddee1mQHnmJHHfccfqy9CNYrxCbuN12280P1vNHHnnE nXnmmQo6LRJwxgMHhwFeHmk2kjg7XHjhhep5bPk48rC68sor3aqrruoHl3wOiB4wYIC+pJOFACR4 OSfB5OjRo92JJ56owCGZZ7/99nMnn3yyvqyTcXZdzAO/VD4AGE499VQF71avHXkBYJvJOJMuOc6W zj9utNFG7uabb/aD9Pyggw6KgYVF5rORBNAwrvfcc48lj49rr722u+KKK5psm4jKnLpxiMDr+uGH H47zcAIYwJGppZ7vPpA89NBDm9wbANnrr79ePxj8BgC+eQimEYANB46sHXwKHSfKzgKSgEjsU595 5hldO/S6665T4GftAehj+/rhhx9akB733ntvdY7KAlAffPCB2ruS+JVXXlEnKtrg09FHH+2OOeaY OKjYZ4SNLQ4uN9xwQ1wOJ8zRf/zjHwreuQ+NeHYZUL7gggt0PgGKjJgHlJu0dQSYHnXUUU34sOuu u+r4AZDKCSSLGVvaXsq9YX3mWMxzpdhxsnoOOOAA/bhi3AHlN954o0XpEW9xPkwB/4ECB4rhAM9Q PloRTvFu4tx+XPPBatd2ztF+1MW5f0yea2TGvw7yhdoggkpJ4Edxbtd2zhFJTPJIGD8e0nb89ttv 9by/SOxmdTriiCPcyy+/rN1AQoWkD+D0+eefqycxL1Lf85YXyGabbaYLP/NC3X333fWl9fzzz2se CuJF4Hs8+i8iJHXbbrutfvVjf8fSNFAakLzlllvcpZdeqvFIHCiTh+yjjz7qfvjhB9ejRw99yWRJ TTVjgf8APbQTgEo9OFjwYkUShZSDI+DFCAkeIBgpIe3Yc8893cILL6xSBEAzcwVwhbNKFhX6wC+V D0gNaBdzFynTTjvtpBLWX375Rcd8xIgRKonioY9EgfGAuAcAShAvV1/KjAQC28ck4XGPpBliPjE+ +YAkL/477rhD08NvxhepFB8VtBepZxIoGtjQTPJv++231/HiAwQJIMQKAIUAYk2c8c8HkiRZaKGF lA+0i34y5iwxxAPP/7jYcccdtd8AXeYz0lv6RB7W2URajXc+D0Ofihkn8qUBSe6Lf/7zn8p75iMv dgC5Twb2eQjjUb+4OHm9+uqrOrctXRqA8u/flVZaSSXIlM09Ajh97bXXlOd8VEGlPCNsbJkLpQBJ 6uXDaLvttlOpGICXe5D7GS2Dz3MDQYQBohlfNCM+wE7jA3UUS8WOLeWXcm/47Sr0uVLKOFk9xkM0 S1999ZVKH5kT3A98lCPp5YdwIVDgQDEcaGsgyQswk+ShEtlPXgiRLIeiP/maiuQhHMnXbSSgJpKl PyIBCZF82Uby8I/k6zUSQBHJizYSCVQk6q1IHr6RPKgy65pVIuiHvPD0J5KeJs2Wh2Aky7jkhJ9/ /vmaXiQskaiq4zj4JqBS43bZZZc4nJNDDjlEwwWAKH8tUlRjGk4bBBRYsB7lZR2Jk4fGn3feeTp2 loC65GWtcSL1s+CSj/LlHLdD1F1Nyvn66691rvgRF198seYRABQJaPKjorvvvlvjRN3aJM5POGTI EE0nEhM/OOe8VD4w1wVExuULeMwplzkvYKNJv0jE/WHzAt4US/LhofnPPvvs1Kz0SSRJmubcc8/N SSNAK65bXu45cfJREcfdfvvtcRz3soBWjTv44IPj8FJPuP+t/6LG1vveymKsxXRB40XiZ8F6FMmZ Pi9yAuWCZ4WVJ6ArJ7qUcYJ/Vp6YBehzi34TxnwUCVhOHVzISz3OI8A2jod38rEYx9GHJIkJSxwv QDKSB31OEp6RPCuMSnlG2NgefvjhVkx8tDnBWPgkpihxu+SjXp/XFi8q7zjOn8PwxngnH6SWPOI9 sP/++8dxaXyIExd4UurYlnJv+E0q5LlC+lLGyerxeSWSeH1fWhzHN998M/XZ4qcJ54EDaRzgeQk2 AWuBucBe8tETiaZA73FZr1gxGjgAzAZ2433GPWy4jncYP8N8HAulPwWQhCk8IAv5wTSolDzk46HN Q1UkKZGsBxmJTWGzJLZQmicNJIhKLX4Qi72TlsVg24Nb1LNNyhfJiMYngeRNN92k4WJHqZMkmRHg S7n+y6VUPvgvWYBkc7xn8hqYEFWqpmciMx5MWPLL17m276677ko2Pb4u5IFfCh+ogBe78b3Yl2Jr A0nrN0AbUJQkkVhr25MfCQY2RIXdZE6IdFPzkNeI8WhuLP14y+cDyYsuusiC46PYjWpdIuGNw/Kd 8ICjzYyHLNOSk7SUcfKBJPNVzCi0bNEmRKJJyCnfLmSdQU3D/WvPDYsTdbHG0b60ueIDyTR+WDl2 LPYZQT4b21KBpEjtrfr4CKimTzyXjIwPYqKhLxoL5wjIT7tnSp1HpYxtqfeG3w8rI98HKulLGSer x4Akz8G0e9jShWPgQLEcaGsgOcurtgWMOFRHhRLqKWwSi80jEj6tYssttnQ/jvzRHXHI4W7AQQM0 jK0Su/fpkdoEARhaF8errrrKbbPNNjnpfJXb4MGDVbX23XffqSqbhKwtaGvyWUaR7KkNmjzAc2wk sesz1ablkQmp2TgKQI3VmRjco7othQ8C/HRHCFRiOAOhjkQFjL0d5fmqS2szatStttpKL3G64Gdt szQ4DgiwVZUf6tY0KkQF5fNhySWXzLEDSeOD2eDBa+zlUN/hzGKqPWzIaBe7vaCeTSN4gvMKVMry P82tI4lNLvZ7OEI8/fTTTZowSNYVZV08VGXMIyNTf2IXi82oT5SD3S7mFiIN0ajLL7/cCRD3k+U9 R0U733zzOV+1TTs333zznHzUzX3H3MDhzCd4zbii0v7tt99im2DMCbi/TzjhBPf//t//i7NkjVOc IOXEv89oAzsKQfnU+qi9Uaszb+G/T5iXmK1xmkrXV21zT6Y5W1l5pTwjyGtjW6pqG9tYHGV84vmE uYV89KoKm7hjjz1WbUjT+MAzxZa68vlQ6jwqZWxLvTf8fhfyXCl1nKyeAxptJNPGy9KEY+BAKRxo a9V2AJIFjBrgEyDJgwRDdfnadueedY7bYesd1Ms5H5DkZYj9FySSNgVbfpUAEF4yHAGIO++8s3pV impbk+HlCVDzyez/kkByn332ib2Im7OzYYFv7PhKAZIiLdL2YiMFX7CLNAJ8YYeHYT7e20b0A3sz CHtSflnEy0ykOKnRhTzwfT7gPGBGxGkFwgdrJwCIlxL2X2YDSx5AhwFJtmRMIx9IMj549WaBzrT8 zQFJA8fY4955551NiuAl/u9//1ttThkXIwMbzMH//Oc/FqxHkaQ1ccgoFQD4QDINSFtdVIwjBaAc Alz6ABdbRJu7gDWAf9IpJWuctMCMfz6Q9JNgK8wc8G15LR67UdqaZbfKvQPQ9QGU5fWBJMA57ePK 0pbyjCCvjW0aMDF+88GW5WyTBnC5d1lNYKA4DP7tb3/TJhofOKZ94AGoGSufD6XOo1LGttR7w/jP sZDnSqnjZPUYkBTJpDv99NMtOBwDB1rMgbYGkn8K1TZq00J/pqIqND3pLI+81GL1LOq22qraaOqY KVHluKlEpZKvUsMGJkmod001JBIijfbVYiKhSWaJxKlD8yRV2wceeKCGiySlSZ6sgFL4YKpNAU9q vykSsEi8TyN5ocR9SapgxSg/jhPHq7g5lEF58KEQKkQFZXwQMKu2IuLcUEjRkan+xYEqJz1qW2x+ BSzlhPsX8pER909AaFRonVZGczaSAri0fHF0sCw5R/HY1ngB4Tnhxao/mevFzAmrzFdtp9nMmgmH LEEU30/YEtvcx+wDW0r/XpOVDDRewL1Vo8esccpJlLjw70ORpEfYAArY1/Jl5YFE6oZLm0cCVJrE M97McdrfnGq7SeZEgN+2Qp8RFJFvbHmW0DbfjIU83GvGc99GkzgI3hCPzbKRqWTPOOMMC4qP3L/i DNiED6XOo1LGttR7I+6EnBTyXCl1nKwe46OsRGBB4Rg4UBYOtLVq+08BJMsyEgUWgo0XD1rsngoB kjxoRXKheUQC0KQW7CLtwW4G/xjMWljaw17UmBqfBJK8jMmHE0VrkgHJZB3YdgKwxStR2yGSszgJ Rr/WJ/HmjsM5ySovJ1HjBTykHFHJpUVrmPEB0IXRcaGgTjxVtWzaDzAqhlobSIo0UduGw1QaYRsJ X3DS8ikf2MhyyPDzF3ruA0nxCG+SzewxsbMzAqDR5r///e8WlHM0m9nki7eUcfJBgCzfovWIJFLr pw3//e9/c+rmQqRGGg8ASBIG7eTj11IgWcozgvaIqYzWD+BNkvEbG1CfSgGSsoqC1oODSJL4wMrH h2T65q5LGdtS7w2/LYU8V0odJ6vHgGTyw8jiwzFwoFQOBCBZKufy5JteVx/VVotn+RTxTJJfbeW0 BseYjDyyHaCmqSG9pK2bVpeRMorMaYAv/YnjJjYrkaQgpEQ8bGU9uqiupm5Gu6SNshalxgFe8LKC +Jo3L8Rrr7lW89Anjauti/pv3F/zbLftdjn9EpWihiMhQLqDw4L9NHOZ/jUH/ABw9BcppU+y17GG yxaHfnBeIAkvcAiiHxASG3txAbh9AsyR1jzA4QPg3IAkZSBVBPTQhyThUW8gGO9spKT+z5eW+Xkp l3pNIstLCeBMmP/jRZRFYoem/ULqAyC3/lp6kzDRd1l0WYNJw4/0zEfiANE+tQWQRLqaJDFr0Pb5 oJH5QZvTAIrvxJEEkv44IcEqhHwgide2kdhfahvEvCSSJVgsWI98CNE+JI8AR58AnsTxaymQpFz/ GeHXw/ntt9+u9fjPCMLRBFC/2KNymUPG23IASVlaSOthfjPXfMKbPR8f/LSFnJcytmn3htXF/Zt1 b1gajvmeK366UsbJ8gcgaZwIx3JzIADJcnJU3tM1k2sU3KFyTv4AlDlE+knVTdKRr2p8ZQ5Is3xi iB6rcg4bcFg0+rtfY9U2QAGPYx78Ppl0gBfSE0Mej+v77P3h0frrra8PYrED87NEYouk4bwIhr/3 aQw+r760QQrBw3vbrbfVssxzHHAk61VqPsDciBEjYpBG2wCqvBTwam4JUQ9SRb6sxYkmpyjqNFVX sh480Gk3fJC1D+N8lIc6leVH4AMgzAjQh1SR5VIgVP2mUgSQGvgmztKSxvjA8kqyk1DE8geUw0/W cIvEviwCoCTBnX0o8NIUu6k4D/koh2VfkiAPoEq8OCNo/w444ABdOsbqs2Oa+h7wS99Qw8MbpD+W nuW0rH3wyIA4HscGhglnOSDyAjRoo09tASQBZb6KVtZLjVBp08annnoqbp7Y0WkY48mHj5E4m0Vb bLGFxpEnCSRJZ+PEclfJ5bYAI8lxygKS8FhsDLUuPHZ98wXOzYtZ7AXjOciKBeZRTvvKAST9ZwT8 MoIXNu7JZ4S/FBn3ln3osASU8bscQJL7iTGlrzyXjMRmMOZdFh8sbTHHYsc2eW/4YyjrS2q70+4N v035nit+ulLGyfIHIGmcCMdyc6CtgeQs72zjW6nWTKzWrf4I6+ht7yfSPFdfU++69OjiuvScsWvA tCnTXF1VrRbBVoDkierFI7m6TsM6yjaB3Xo3OAVoQOM/Fv/FAxvC+WLZpZd1XSq6OBZdlxeWbpXn L0heXVXttt9ue/fTqJ90dfkVll9BdxJhEdqq6irXvVt3d98997llV1i2sQanW8vheIOjB/HkYYHm b777Jk7Tb6m+7oE7HnA95hZP4g4NwXhj4+giD1d1WpAHqHpni0RFvTHlZaMLost6aHE5xZ6IlE0X NWcxZZxr8BBn4Wi8btn+UW4SXehYJAU5uzQIKHKydl9s/M9iyCzWLSBS22ZOO/KCdGwVCAn40n7j MIN3MTRQHAFsIXAWBjcHGJw2WFiaH7tPGB9wuKGNbH8HHwS0qMMUjgU4C5njB2XjlMGC8bZYN17f OCUxrgKS1aNYzA0c9RrBawGEuuMMDhBGOO1QNzu04BBAPTiTQCLRUo98xgPCYx3vcNrIgtDwEMLR C2cPiIXH2ekIghf0CQcAtkCEWNxbgKOe279SHDIsbzFHeXmrg5HlwZkKZxT6gVc2/GGLRpHWxt7w rE4g66eqIxPjK+Bd5wuLMkOUIYBZx5FdWnxKjhM7OrC4vYBwdRYRsB8vHE8+0gsg0yJwrFhxxRXj 4pgr8Jg2cs/h9GYktnPKc+YuY4fzCmUxP5lLkO9kYvl8ZxsWn26OuKeYjwKCtR7ax9xhrnF/MHds Nysri/biHc8cgGgTjnlsEzj77LPrfYMTERsDGFEPDoMQY4Gjn0+0IelsQ7y/4Df3BE5KPL9EQql8 I00aHwgvloodW8pP3hs890Rjofc68Wn3BuE+ZT1X2PXInLFKGSerQz4wdSySzmMWH46BA6VyoK2d bf40QJK9ogGSEGAR0OjT9DrZgUdAYqeKBm9h9pSuGlepSTp37+y6zlYRJ6+vqXM1kxr27q6Ys1vq ftMAtrMHne1G/jQyzscJDzBAg6zlGIcDWMeP+cMNuuhs98prr8QggQRL9+3nLhh4gYKCJGhlGY4j Dj/C/fDjD3FZgBK8NAEM+mJ+UF7Mif2wATyiItVdJwyQUACgjyV6xKYq9iSPCy7ihIcpLxE8q3nR 8ULzCY9l6k++pEjDCxkQxS4wACefeDnxYhSJRAzuaD8vFoiHOeCC+vBQBqjy4qVMiKVDAGIsa8Q2 Y+w0JKpe3S0iyQeWLAGk4c2c3CcZ8MJWhI899li8FA3l403Mi1YkgDEgJNyIdgFSWIaHsQNgQv37 92+yHRpAPs372sqyI977tiQRYeyGhKezSDEtifaV3ZREndmkXWybyI4t7KxkO+9YRpHkqUe0v/yP xRV7BFDYMjBswylrD8ZgnLLYJpK2AHB8wjt+kCxdJBKhOJjlhABzLEOEtz8gko+CJBUzTiLlju/J NAAFb0TyqVUkARFe8MTzkcQHBPObOQr4pA1py+iIM49j9QAAMvkKIT4aRcquu8r485VnCl7QtqSX XxYgmHHnQwfiHhdpru4gxbI9ybHlwwwgSfnsdiXSYL84BVwAX+4b0WrEcaTn45kVCezjB3DL2PEs 4h5NW/YpLqDIk2LG1orOujfYxpX5Yx9xlj55zHquJFfOKGWcqMt2Scqaz8n2hOvAgUI5EIBkoZxq Jp1JIzt2Eilin6ZSxGR2pI7TJjeAxe5z9XAdOjaK9BoTVv1RKcAzcp26dXYVs88AmX45lPH7qDFu xMgRrnPPLipJQiqSJAArwBXAWt9pum6PhcSENQHn7DlHDFpZi5KlhHyqnlDlRv08yv30809u+dVW cPPON68fnXnOwx4pEaASSSYgDQmgSe8yMxYQAZCEkJgABgFzABteLEjhTJrYXFFI/ZCmAQTJg3Qy bakeyqY/tJ06IFEn6xFgwsuTlwBgAeLlSTn0H4BDe+EBeZDYMEbk4WXFESlTGlEm7UPSjJSTF7qt OZmWnjCrEyCbBKjJPPby9/tlaXhxI6HlmIwnDAkmY0tf4RsAJ9+SSlbuzDzSPvoI3/LxAnBDWvqL tKvQ+WN9sXFCMsfHBvxgvMpNzEHmFXPGl8CKatstvvjiZasOCSRgzp4RWfPTKoR/SBGZ60gy7R6x +HIeuZeQeMIDMWHRYznLT5ZV7NhybyCJ5JnEvcp8oq2tQcWOU2u0IZQZOAAHApAs0zww4JdUX2cV Xzt1mqutrFXglraYOCAToNixiwDTXunA1MBovnUkqb/y96najK5zVLjOjRJRa5cvGa3oJdJPUa/7 BJCcXiuSVJE6Ih1tD+QDyXK0p7nyAHw8tJEIAhx5wRqQNJCF9A9QC5gyNZSBOj/M2kudSBaQUiTX 6bQ0diQd6XlBU18+sjqbA5I+8KUNaQCaNJD1O1+9Ia51OMAYpAERVN6sBcicYJ1I39ShdVoSSg0c CBwIHEjnQACS6XwpOjQGayI97CxSxOaoOaAYA02RVCKxTKNCgCRSTUAulAYUCc/XdgOSSfU7+dqK mgN+xbarufIM9PFCRzqD5AXABhlgM7Dpg718oM7KBMAh1ctHrQEkzfYzX70WF4CkcWLmH1HlYkKB 7SQ2n4wFwBE1L/MLlWnSfnPmtzLUGDgQOPBX5kAAkmUa/RiMzdZVVMi59pFpVRQMJEXVnCaxpMyC gOT0GbaYWfaWcdtTJJYGJAuVtKb1tdxhzQG/YutrrjxU3+aIA+hDTY2aESkQgIwwJJSEsYMIKneo PQNJX6oKOE6TehXLx5C+/BwASCYdmKwW7E6xXWxNVbLVFY6BA4EDgQNZHAhAMoszRYZXjxcVsDjU ACK7CphsjlBrI3XENjJN4ijLCLl6UW3nUynHQDKjDGtDDBRTpKW+xBIVOqp0n0oFkoAv7IWMyglU mgN+Vmehx0LKw/4RNaPtkwxYBEgiibQw6kNNbUb17RlI+uAYB6FSVKP+GCNZtX4XyveQrnkO8AHD fuLDhg1ThxJ4jg0mTm+29WnzpYQUgQOBA4EDrceBACTLxFu8rPG2duKr0gNVtLxY85EsDO6mNXpm 4y3NUj8+VY4V1angsHwqZd9TPM1Rxsoz+800UGqAlrRpTj+lAkkkXrz0jFABp9nhWXwxx0KAX7nL w/4RO0jsHU3yCPjiRW9hSXvHtgCSpnZPs8tM8oS2M0alqq5tHCiXsWWMAwUOBA4EDgQO/LU4EIBk mcZ7uiztU/1HlZYGYMOxxQdOrBeJgC5eFkjOFeCJ6lkdanBkaQSf/vqSaSDTmuw7ymCXybJDSe9v 0spWiq5WlgCCKqRdtgQRba6ZUK0e3Wkgk/QBSMIFGStxtkH6aIQ6m/E1j27CkVIinTRqCyAJuMOm EqIt+QC8OQiRFiciAKVPqO1Jg4NPmrQxAEmfW+E8cCBwIHDgr8mBACTLOO6+dA/JZIOUsYOuHwno S9oZAi4BjRCgpINIJWUrEV32hzAAH8AvH5mtZZymURCqEkpbUsgDraTTdkk6vLGNsgBrAJINHEIK aWsnIolEHQwZWOTcPLg5hyzOHHIaQhv+G+Bj3JPONoBWAJwRKnXMBEjrmwhgG5cEf6RDDW/SYPIY CARYIqn0CdtOpMcQZfOjDOq0Mnx1vZ83AEmfG+E8cCBwIHDgr8mBACTLPO6omwF3AEefOsj6kthO IvnzSRcfZz3J3ORNQKefJ3mOrSWqcuwdjZJqasABqnTa5xPtAqwmVeuWplokltNrm+7KY/FZxz+b apt+sugxfOzZs2e8TqDvtGILlhtPCgGSSXU4ec0D3MrJOrJWIW1JEiDQwCjtNUq2z8JRh/Pz0xJH 25CyUgeA1CdApgFQwgGgSZDqpw/ngQOBA4EDgQN/Tg4EINlK4wqQZCcbXuO8kJMLfSerBQSiakY1 nQXqknlKupYGsWWjtktAZJoqvKRyZ2ImVK6Annxq20KbQzmUB5m3daF5/2zpAIeAUIg560s/k31F QmtpiSvHWCTrCNeBA4EDgQOBA+2fAwFItv8xCi1McAAAA5AxsMOxFDLgxJEySvFcLqXeP0MeA/P0 JUgj/wwjGvoQOBA4EDhQGgcCkCyNbyFXG3MgqTpvSXNQ26KWLRWQtqTuWTWvbx/5V5fkzqpjGNod OBA4EDhQDg4EIFkOLoYy2oQDSCb5JW37imlMS6WaxdQV0gYOBA4EDgQOBA782TgQgOSfbURDfwIH AgcCBwIHAgcCBwIHZhIHApCcSYwO1QQOzOocMNtUvx/BttTnRjgPHAgcCBz463EgAMm/3pi3uMcP PvigO+ecc9yyyy7rOA/01+DAJZdc4m699daczi4h2/U9++yzOWHhInAgcCBwIHDgr8OBACT/OmNd tp7ee++9btCgQW7ppZd2TzzxRNnKLaUg7COPPPJItZM85ZRT3OKLL15KMa2W58knn3T8VlhhBXfM Mce0Wj0zo2DG/fHHH9eqfv/9d/fTTz8pv5977rmZUX2oI3AgcCBwIHCgHXIgAMl2OCjtvUntCUiy dM9yyy2nLLvvvvvcaqut1q7Yd/XVV7vrr7/ebbjhhk2keW3e0BlrlTc0JXfN8bzNe+ihh9xpp502 SwNJVPXV1TWuplYW9Je1VUuhiq5ddA3Niq5d253Xf5oTWnJh+eb6TBm2U1LWgvbNlRHiAwcCB4rj gG10wdJqffr0KS5zG6QOQLIcTJeHbeXYSi0pa6vBclRTahn+ntzlaF8AkjNGomqc7Agji89XyF7p yV2LSNVegaS/n7v1hkXz2VqzEJrVgSQgcvKUqW5a4/aQhfQ5X5pusgPQbD175AWTgDJ2R4JaG5T5 dfntZpvMYpZrst2Z/G1B/fLsnHVd/SW5eAGSJ9+i9sm8tJk8LMWVBXgZN+rhSHpbdaE1F8S3vlGn LRXWmvUZXwo9wgfaCBk/8uUlPTy0tXhbY5zy1d/e4hhXBBIQvMgi+Mb6uZYeXjNXmQutQXzAUVdy 693WqKulZQYg2VIOkl8mWFsAyZEjR7rPPvvMffPNN/pgWGSRRVz//v3dvPPOm9MrA5Jsvffpt8Pd V998pen79u3rVl99dbfAAgvkpPcvqOO9995z33//vVtmmWXceuut51566aVmVduoPj/++GP35Zdf 6sMXqeE666zjZp99dr/4ks7px0cffaR5eQAcdthhen7SSSe5fv36xWWyRzQq5SSR55NPPtG2oZ5d dNFF3SqrrOKWX375ZFL3wQcf6PaB88wzTyz59BN9O/wbN2LECN3ScsON/08fLIzJuHHjNNkjjzzi nn76ac17/PHH+1ndGmuskbrFYU6iIi5Y25F+MR/oF3t4w/f111+/CcBhn3e21fzy669kDg13IyX9 PPPM7VZeYxVtV3MAoFggOXnyZPf+++8rz3mJFTL3hg8frtIw7DCZ22PGjHGvv/669m/BBRd0W2+9 dZO5Xii7pk6tdFNlT3O2eEIwmxTOFloOQlwV5Mq/2Wfr6bp365aZlRfRzASSEydOjNsCz6FigCT3 ic3jrHyUy9jywksj9oLnRZgGDOEHbbS2WX5e0Oxln5yDkyZNcv76pZaeI3l4tpTzpU7/aZ+BNL8+ AAdtbEuCf2yFyo+2Qt27d1d+Z7UL/sHHJGVtt0q6YscJflEPbQJoMQfSxj/Zhpl9zbxja1jb2Yz6 eWamtZU5Xl1dndpE5ilzLw2EMjYG2PmAgx+FEnl519Ee3mVp7Sq0rNZOF4BkOTg8k4EkN+k111zj brvttvgBYt1gUg8cONDttddeFqQSs3defdudMvBUN/q30XE4J9zkZ511ltttt91ywrkABJ155pk5 D3peKLzAH3jggUwbyfvvv99deOGF+oDzC+Xlf+WVV7pVV13VDy76HLDk9y+rgI022sjdfPPNOdGj R492J554ooLjnAi52G+//dzJJ5+c8zK67rrrlNfwaciQITlAFWnNTjvs5H4a9ZNbb9313G2336Yv tEMOOcS98cYbyeKbXOOotPLKKzcJLyUAnpx66qkK+JP5AWHYMfovZh6ejNE999yTTO7WXnttd8UV VwiwnKdJnAUUAyT5oDjuuOPcr7/+atn1mG/ukeCAAw5w77zzjjv66KN1Dt544405+Xlw80FRCnj4 Y8IEecCLJKJUBJnTEgEyAiRRc88p90cWzUwgmWwDgJAXexYgTKbnmpcscxyQxossjXi58pKFeEny ox7/5ZwFbibIGBiI5CXLi5JnG3yiTqS2HI0MSFo9pCe/D/TKJemlD+PHj4+fr8w16qVt9I17qS2B JGPDj/b4lMVr0tBu+7ig/dw38M7GIAtMFjNOaUCVuhiX9gKE6DMAzfrt8y8LSJp0kD4wF5iX5LcP KMLpoz1jGRf45s9N6gFw8twrhCiD+5Zje5dKBiBZyIg2l0YGemZKJI844gj38ssva6uQNiHp4yH3 +eefqwftoYce6nzp1+9jfnebb765q66p1i+u3XffXSfz888/r3ko6IYbbnCbbrpp3FMkcfvuu69e I6nbdtttdVJjh8iXEpTmbHPLLbe4Sy+9VOPXXHNNLZMH2KOPPup++OEHx8MKUJOUmmqGAv8hmaId EDcZNojQrrvumiNdRZK1ww47aBz/eHgAgpGW0o4999zTLbzwwu6LL75Q0MzL46CDDnI47RgRdvDB B7u3335bQSRg0h4EJ5xwgjobzdVnLvfow4+4eReYT7PhgISUEgIIffjhh26hhRZyO++8s4bZv332 2ScvWLN0zR2R3NEXHmpzzjmn22mnndxiiy3mfvnlF50ntIU0/hfzBRdc4O644w4tepP+m7hVV1jF /fzrKPfwYw9rOUhyH3744cyqCwWSSOA222wz/ZrnIV3I3LNKDUgiCf/qq690zgByAUNIfYcOHao/ Gw/LV8hxzNgGiXE5gST1zjt3OuAijrk6sySS1OdTKUDS8vTs2VPvF788Owc48ON+4hlkRF/9FylA 1AeFvISJh/yXJC9eAByUrJc4yvDLIZ1fFnOhXFoPnnMABOZb8mOFtvj9pR0zk2xsaB/gkbbC83xA 0gBhEtgBLnlGU1ZS8uXztrlxon4DPowdzxuT+GWB1JnJM6vL//ihjfDDpI1ZQBIeMQeYX/DJyC/L n3v2EUb59J1nMx9l8Ch5L1hZaUczLaGN7dlWsq2BJIzNJHmJR/aTgYjk5tWfTO5IJn4kD7BIbqBI Bi0SkBDJl3EkAx7JgyiSCR0J4IhEAhWNGjUqevXVV6NXXnkls64WRUg7p46Zor/62vqovq4+qq2U 9k2uiWqra6Pp9dMzi59O2irpz5SahvSSr35aXWZ6+iEATn833XiTlk9eftT56bBPoxdeeCEn//nn na/pRY0d/TDihzgOvsmLXeME5Ei99XGcSNU0XIBYNGncxIa2STvffPNNDacN22+3fZyeEwFokTi7 aPy5Z5+rbbMEUyZOjvr3769xJ514kgXnHOGd8o3+SF/q8vABvolqNqqtqY3bI9IpLQ9+E5fk48UX XaRpBeBGAmoj6ps2dZrybvAdgzVOVMEa5zeMfglg1/jTTz1d0w95cIheyxJI0avP/i+qk3FOo6uu ukrTCRhNi84OkylD/20e0U76lCTuDwGRWseWW2wZjfz2x4a50DjvuE9Ekqf3jeWlPyIJ1Tznnivj JOPK/K0cNzWSpXw0nPEVEwbLknOEbw/cc7+m22KLLfKO0/nnN8w9UeNHI74bETFu0NQpU6Pddt1N y9h5p51T75H9998/bsuAAQP03vYbwlzkmVAK/fb72Ijfr2PK87Py8rWFseKZxI9nGM80eRHps4t7 sbm+kJ/08nLRZx1HrglvjgTAar2kL4Ron7W1uXZllUefrAye1T6JdFHjeE77xPPc8iTj/HTJc5EY aT6OLSX4yT1CO+hDeyT6yfjb2Nv7jndgGjGGxld47JPlJT4ZV8w42ZwRwBoXzxyn3HKMS1xoC0/o I23k2Qj5c874WUwVdm/5faR8+u3fO8bL5L2Qry7jKWXBy0KIPPYrNE8h5eZLA7YCm4C1wFy0F77A EzAZfQejcT/Bb3gA/2knPOJHW/kxBvbLV6cf14GLNCROmB/FuV3bOUepUMP9I+f8pFHx8dtvv9Vz ATNZ1ZUcPk2+yKeOnar5O3fr4gRU5JTFF0zFHN1cxy4Nxrl8XQgTXfWEKicv5Zy0dkHaitnl60d0 Znz5kgcyaeQySy/j7r31npyvI8vbdbaurnP3GUbD9Bm14l677ukGnXu269h5hrroiUeecCeccoJm feG5F9yiiy+qX7emfj7zpDPcrjvuakWrQdgBhx3ohg0f5vou1dc99fRTcRxq5Msuu0y/uJ556GnX pXMXdd6gn9hp3nHPHe6q6692vXv1dq+//Jrr0rOr8oE4AcJqsxcX1niSxQcBVq6ustZ16NzBrbpu g6e2eW3Xi+1fzaQabWuPuXtqScwVPLplEruT/3Wy22+ffWWcGgzUSVAzrcZttcvWqvpB1W/SWOJo H+097JjDdQ4dPeAod9vg211lVaU74tDD3YADB8j4VrhOFTMkMuSDCnW2Ya7KzaR5psucqBF+RPVN bw3mAw4x5jCBZA5JLHTZ+Ze5zTaeIVUmrOvsYpfTLbddJk1kTr322muu12y93LTJNc6cbbbbbjvH /bLLLru4iy66iGIaSJqj4yR8e+ypx9ygC892iy2yqHv03kd1bjPHaZ9PNvf23n0vd/KxJ6stKfG1 MnYvvPKiO+nMkzT5U0OedH1XFPtWL/sBjaptpCzYmaJq96Wqfj3Fnre1RBKpGRJye6ZZ+7NUz8wN pCI819IoS5JiaQUsaN6s8i2dHeVBH9vS5TNxsPRpR9ps0sVkvdYeX4oDLwj3eYIUxp59aXVYGLzh mcp9QV0tIet7moSuJeW2Zl55Yev7LksiyXOP+Qb5EjF5saukzNqW5F8x48S4Md5I7tCMQDzXaBv3 bVuaAlj/0o7ycRWbZzR3H6Xlt7nHPDWpoYXRZ3tmCZhS6T28SUq408olDJ6aFsMvK1967gMjpPdW v4W1xrGtJZKzPJBk0FZaaaWCx2aPPfZQm8Ri85x33nlax1ZbbeV+EBXxEYcIgDlogLzAO8XewiLt cfU19fqyBqRB3MjUxfHicy52O+62YwOQFFBQM6najRk9xm2+4xaadvDgwWof991336kqm8Ahgx9U xwgAMpMaJ40r/32lu/PewU2AJDZ6pg5dasmltMwGZ4YGQATwwkYReuW5V9zcC85dNO+MD8UCSdS8 m2yyidbdp3cftWfRC/5Jv0Smo6pgACX2lyy4bvT/2TsLOCuL7o+PhLQigiCiIphYKIqY2IiB3fk3 XjFfu7vjtRO7u7AwXvO1uzAAFRRFMUBql7z/8z13z8Pc2efu3nt3F3Zhzn7uzjzTc2ae5/k9Z86Z AQjPmj7L3XzHIDdIfka91+rtbrryRl1qqymQvOKKK9wtt9xiRVfrAgA7duyoS+sssfMQ++D1912z Vs0EjC0g82CGmzUjCzpCi3L0a9H97N69uwI0ALUPJM855xyHZT7LyMwJI9/S+5kXn3FnnX+2W3qp pd1TDzypSfhAYVcAI3/uXX7hZW7zvpsLWG0kAHmWAs5xE8a7TbbKjsmt193qNtpio1QgCRilzbX5 UJzbQBIeMWa8uAFc9vCnj7zoQ7JlSeLJQ15ApXzR688HB2Ferg0QhIAuLS1htbGklg+8UL5I/HBy lrXNoIEXH/2Cqnt5wgOAn4GkQvunhef5Z+CKdgD4ARq0h+cfH/WA3znxcs7TvNTg6oCkjac/vwzk USD9Yh7SLx/wFTtONs/gEWXCO8r11RQYM8KZH4zX3OZlTYGk32dTq7C5z30KuIfXhIUfJ9z31M/c MvAdDjBAknhftSBMY9eks2cJYbX5zLQ60twIJNO4UkTYnASSTEaMM7gxzzv9XLfTLjsnEh5rMuCB F7VJx3wAddv1t7n1N1nfNZKXefk/5QKOMDaY5dbu21tfSpdeeqnq8WEogsEI9Orzr7jO3ZZIJJ/k GXTjIJUshhJJdP7Mmrp5M0+h2JMyWTufevIpt0SXJeYYkHznnXdU/5H6ecDxyyFP+Nd/6/6JJA4A CZCEmrRq6vpt008BJ9dDnnredWrfCW+NJZKlAslrrxJQePMNrvPind2rYk0PUFOS/igAlvkQAjwD /OjW3nPPPSqZ9YHkdddd566//nrVH8VCHzLLf/xNWjRxz7z4bLKP5PNPP5eVAEucD1r9uXfHzbe7 NVbJSo7ZJmlBkeDy0EMXkxfLxRdeLPPZk3xLWSaRRDqMEVRtPhTnNpCkL0gvTN+K5whSDCgET4AY gGRaHGE8DyrNZ009+5+97AoFWiY98aVLs0ur3sfYAm4Y2xCcEEZ7IGuP9RG+0H/y+vF6UfEPXvFS phz6bgTA5kVuPLXwYl1AKeXTburguRtSfdL5o23VAUnrE8DGpGb2cQLIo48AGj++lHFiHJnHjL8R c4hxJo46AP4QYw04YtzmJtUESNpHB+0P71u7h6xvzEv4YADb5jDxVd1nNk6+9N7KDN0IJEOOyLU/ GfHbtflxmeyhS5g9AMyty6XtcnnoTJH9BCEkdywt+8Qyq+jr6Qu9TYeF9GZl8lZFoq8mDJAJJpLF Fgu11Dyk77l6T1dWXubOkCXnfQ/at6oiNI6vmfXXX1/9N199k9to875uuiwLA5BYRmzcqolbredq Gi/6fK5///7uow/F0GafrKHNay+/5jov1TmnnusEvFwv4CUEkhiqANi26reVu/jMizQPS+whP/zC Jo2fpMulhLFkGy6Nlo0Ty0RZ4gUYt27XOuFDsRJJAC5AF3ri/sfdymuton77J3qCbvokUTgP9lI0 KRztevnt/6rFt+XZdZdd3WnHnKqXORLJ2c9Qd8213obkt91uWWe7FSCbB/nUsqkJaG0mS9L2MTA7 8WwfDxXopmtvclffcLVKseC9T8kSvwQqb6Vv0Nli1Y8aAFs/IXkMJZJY1t98882JxJI8lgZ/i0Vb uieefCIBkhhPlf1dMU6yjE7bIX/uDbruZtd7jd4aTn74yYtllVWy42BzTxNU/DMgOXDgQHfEEUfo i6c6wOTnr8o/t4GkL6GxdprkwcCVhQOWbIk4fFlZmurcYoFkdcCkuvrsJcrL07dmJZ/fH6QwADb6 xz1A33mpwgsoTQrjv/g1kfwzsFJTEEl51nYrG9AI2OE9g2SPeQvVloW41VMTt7rxsj4ZqDcecj/R D5NYwj+Wd6FSx4l3LmAfF7CIG4ImpHSMWX0g4wVtKWZp2+dPPpUC5grpbF7CFx9I8xwnL3zKR+HY 5UtHOHPU5ifXlFtbz0zKy0dRIpmPM8WEy+CZ1XYOoKgog+VgAAnAzXT2rHgAHTqVswQsiYapBSf6 cSxRN205W99xwHYD3HfDvnMH7Lu/O/WM05L0+TxMLPZIZPIixdxua7FirgA6ALzf/x6bWGuzpQ9p R/882m22+WZapBiVuFVXy126P/sMASKPPlQJSLIcfP/997u1xVr7lquzy7TVbYAOqEVfLgRw1h8k ZYAYdCWbt529bFoskORF1adPHy32thtudRtuLsuoHrGn4jQB/AAcgI4Ry/+oC/w05ie3x3576gOR U2rE0ENv2ovOvtD136L/bImk8HZKhb4sZdx4203u1rtudev2XtfdeOUNVmzior+IHiNkbcDfskNW txN/VfT8k8+5Y085Th9UWIcDUIx8KWKztrJhuqhBQGyjw/Y+WJJj/W8g0cYAq3W2ftpwww0dVvhQ OE7Ekw7re/Z2TBsnf+6df9Z5btstt1U1DKSWkChmV5p7GlHxz4Ak2//U9vGScxtIpulJGRhIA08W x4uBlw+AgJ+9oHy+pfmLBZLcL7wA870g0+qwMF9Kg4TQPnosHsBIfyD4wIuPPCaVYd5UBSQBJuQh nUnSCEOaZhIfq6sU117c5KXttlzJNXXCS1zAJfXVB7L5kW+8rE+ACnhOevpgYNiAJPPLVCtqMk4A JgBaCJrgGeNU6LydE7wtBUgy35AUwiP6Ax/T+kQ6yk8D0oxFVQDS+m5jZ/eHhdcnNwLJ2hgNuSEN SDaXFzZ6iz75kiEFkhVSKHv5+mlDPyDS9B2JO/7fx7tnX3jWoef3yquv5N2Wwy+HrXvQe9xkw03c lRdfkUQBmh56+mFdxuUmABzxEJlWNs2tvc7aul3Q0Ucd7Y448ogkDzcG2wRhvBNKJNk/EkMVbpAn H3jCdencxbVoL9InKTsfGQ9CoGjpEwATADwDkiyT9tl4XX0R2RZGCb8D4I5klhfUjgPEiOTyS6wK dfPlKR9X5sTC2O136P5uxPcjVIp33333OZaib7/9dtmAuoV74Pb73QqrrpCVIAZA8l7RJb3yhqvc isuv6B6844GcOrnwgWS+vlbKVBGApHb4V8PcgN2315cC+2Oy9ZNPU/7IGoH5RjdDhgxxxxxzjCYb PHiwW7brsomOZJM2TR37b/KiYUmZ8YTCcUL6iQQaEos912Hh9tkPgmCcbO5t2ncTd8WFV+iy+IKt s8D5rrvu0r0s/bmnBVb8m5eBpL3A/f4aGEgDkryQWZ7k/vOJFzMfD7zMqqJigaTpKxb78vJfyvmW fwEwBhRJA4hkDrDkyouVPtJeKJTOpvWR8kyiybMH3taEbBmYMtLqN97URl01aaef1+ZOPiBpfWKe 8AHCOPlp0/pU7DgxVwBMaaCJ8aUNfJxAtAGAXt289ftYV35/zhYikYQvgEj6wnxlvoWAkA8d+OAD afjN/Up9zHkIvnD/EpePavJRl6/M2g6PQLI2OOoBSV/yY0UnIEUCTNLkh6Fz1lSWgBP9NkkHgEHf MQSS33z8tdtlv111EgPo0Gu0r2ImOBtMM4kPOOAAq173C2TfQG5ajB76b9tfdSRHjhzpDvn3v/Sh vuWWWzp04yD0IM89+1z30OMP68Md4IRhBgRYYxkSCoEkNw0Wv5yqssZqPd2FZ13ouq+6rKblHy8H NuGmHYcccoiGhwAlSVzhScBVuORcYbUNkNx57130tJO+ffsq8OnUoZNKF0MJ8AP3PuDOveBcrf/c c891GD4ZIRV+UyyzHxv8mLvwkouSlxF6hmedd7ZaKcNngBcbq/MQ2WOPPdyXX37pui/T3T368COu 1cKts8V5S9ss+x7976P1QXPN1de4jcVwhAduQh7GRjJLf0OpaJI28JjE8cwLztKPCx5Il10mRi2y Z6jRsM+/c5dceanutdm8VVYSyDixtyOK9BjU3HDNDa7JTJESCI+vHnSNA+DxgKOv7OEIheMk2zto X/giZ2/IowYe5RZqLvppwTihgylbACnPLzv/Utdvq376YcRJSbK9j7bBn3vWbtwIJH1uZKVhvIS4 v5H4cL8b1baxjUkVeUGahMrqyufSJtPzDCV5YR4z4rBwHzxzb/HyhApdyvfBQHW8sDrzudZ34tOA hUnvuEdsGThfWXMqvDog6feJNjGuvo6uWRmHHw7FjBPAmg8EygYYMQfw82FA+5ivBhyrk+TNKb5R jz930sbbbwt9gFfcg4w/85N+h2RzBH7CC3vmWzjpAdOUA/nzXwO8f/CUetOk+16yueqNQLI22C+D bBJJjAiaBNvAJPp3nrQmfDGHzdDlUXlPhEASgHnL7be4G269UbMwuTgGjxsUPVBufI4M9DckLy8r d7Lno57Awo2NXtqCTRfUTZ3Rt2Si20k1FApA+X7oCLfH/+2p2yIQj+U3NxAbQxuFQJJwDHXQZ+Pm xOBmpR4r6VIKhheAB14SAA/ABVQdeJK9ON1MWdoGMNqSqOarWBJH+vvw4IcdQNmIJdtmCzZzvXr2 chdccoEFu/KJ5e6QgYe4Dz76QMM48WWZZZbRr8bvR3zv/vwrq5cl+2G5Tp2yRjSPPvioO+OcMzQ9 lsNYzRuNGjlKtsjZwU2Wr8uddtjJXXzpxRaVuHyVApQAXhASGIAoBCD3j3T0Py5aiiRXnlSarqp/ SBz/+vsvt++/9nNjfhujSTl+kI3Wx/4+1g0fkT0+84tPv3DNWjZLimK8ObUIar9oe7dst2U1/6if R2nYgAEDko3lCUgbJ9O1JJ6HYquWsqwuTZa9KBMgDmjddtttHUdtMvdW7rGya96iuW6QDm/CuUdZ RgYkmU/8eHBTRm3Q3F7aLlYiGfaZFwv3GFIeqKoXEfEmkSz0ZeSDwkK2/+GFiJQGKmTJ14AP6Zk7 vJCNmBfWr0JBod/eNN5SNmXCNyN4xpwKyQcWaWVRDm3kmWuGK2EZgCerqzbnbViPXRs/uZ/oV0h+ n4gLVStsfoQfAFYueQoZJ57vIbAyEOu3zZZr0yS+8M2XvBv4pA11QT5vqgOSBrgZU3gIT9LI2h8+ rwwU2ry2j6Z8c4lyTDpf6EfVnJ579D8CybRZUGyYByQxkEBPkZO/NwAAQABJREFU0qfy8VkLaX/5 dqpYTcsG4JUAEvkIJx4KgaQa7og+37sfvusuuepSfUFrwop/SJCwyuVMbCOA4diRv+u+f6/977Xk AUf8ct2Xcxefc5Fbec1VcvaXBMgisTz2tOPcyFEjrSg9h3nDdTZQq+3ll1vePfPsM0mceb4fPsKd ecaZ7pPPP82pi5tl7bXXdgeItNS24vH1AtP0KQ1QI7W1JVHqMb1TpHcLtm3mnn32WYfkdNiwYfqC Jc2G64mO351ZHT+uWQ5nH8QHHn/Q3XLHLcneYcRBHdp3cJtstLE77azTFeCgw4eElZfGLjsI+L1E wK/33kG3cPDjT7nTzjtd84dAUwPl36hRo9xdIuUDYPGytYcM+zmasQlpsbYv+ztrIR7qxlpZoWtG LmXTy3QJHSmifeWSFjC/1RZbuYsuFYl0k9zlT042YunapD+k58tZNv9OjFsIg9LGCakC1t3s8QhQ tH6x7O1LsXhpnHziye61N3LnHnMVFQEfTGdry/434y1AJB9HPJTzPbj9fIX4GzqQtD4ynxjv6sCb pQuBgpUTuowtIAJKA1N+eurnBQsACCVafjrf70tmwvLtZV3M0rFfnr2k/frw20vcwvOl81/eSPn5 +PPJeFlVXw2YkS8EYH5ZteU3wOeDNb9sxob+Q2G7DcwQFwJMn6+ljpMBb79sA29p/LU42gMVCqCy qYv/79dXFZA08Ftqm2wMwnltcyXtg83/QKuqbX6vbTmdMAAv413XFIFkbXDYA5IU52+B4kuZfGml LdmSvkW7FsmytpzKoiDSNqMOgSTx5RVgAyndlFllKunjwY+kq9OiHeWBngWglA3ZEqj6ZXVz+PdZ KVW3bt1cS9dC43VJkj0AK77QTQJFnr8m/e1G/zZa95NcuPlCapxBOEvxtD0klsYBz0g7f5vwu4In HtpIySp9LUtbFQwJ2FWgjSFGRRvMYpryQ5Dpg22MhmwDdj8c0OcbN/l6lYwRep6APADuYosu5tq3 XlSXlf08Pu98MEs40mFcKM3ISiOK/GcfCrQ9tNwGaMKTHMlshbW5tcHJBu306ZfRv7hWTVq6pbos 5dos3CYnj98kHm4YV40YOjwrmVx+Wdd8IZmPAtBzqMRxsjJQEZg8cbL7cfSPLiMrQahK5JPmWB7a hqTJaH4FkrxM4AMgwZdw+GAv7YVsfMM1HTjyI5Us5OVSiG4WIARgxVhxH/mSRb9+Xmj8jPy2++DW f6n7UlbS0wd4QNv9svw84Uva6sMtFEiS1sCs9cn47tflt488Phk4IKyugCQ8NwJIAoDhpf+M9fnk AyEDhZTB+DGO9NH/AKTsYsfJ2uO7JmG2caZO+Mu8TpNI+jymnLoAkj7vqM8k4KanS70+7+z+Ibyq +8fmCenSyOag8d8k6cyztOeh1VvMHIpAMuC8P9j47dr8uNw8oUsYP24Cc+ty+x+Qmy1tWxfs9Bjb FJq9G5t7oMsHhOTR9PKc1W15COCZK8+JEEgS5YM80mXrWkAlWgCbMI8PhkJAZqCPcn1pKjwtHycb pQp4UapoD35ABmVWByRJazqh+PORSReJ5+ZdQDa2xoLdwLTfLr+MMtlyyYAcbeKn/La2iuuDwhBI +mUlgD/IQxof0AK4k3pmP8drDUjSHx+gUh9zh3CbSzk89QAeba00jyQsHHPShWSqFkk4PBTyt2Qq dZwoR/e0lB0KwrlJXD5iDkYgKQcHiHoAIAACKPHS4dnGyx/imheT/+LTCO+fDwgItrQAM0BoGhkA IC0Aw/L4aX2JlR8e+tMMb0xSRVpewJRPOyFenEiwrM6w/Zbenv+aSf7ZC9qufdde4haWTyJJvC9l pQ3wnfno8zztxW9l1zWQ9CVVVmfohsDQB/2kpU/wlX5BaaCO8GLGifQhUb4BXRtPwvLN2zkBJO1D IWyrf+2rgYS6on46358mVfTjbZmfMMaH+Qv5dWmA/COOeQTlGxuNDP5FIBkwxCY4wfjt2vy49iDx Xfz8uEnMnVNAEqkj+xEawKHtSA4Jt5uIMAjpGS9wPy0gBQtbwCIgL9+LNy0vZQLukNBRpxHlA7qg NFDhS0dzJGvC36nSl1nSTsoA1Kj+pzxYyQNoobyQfHCaA3rChN61AjnhhW1NZFH5+k889SDB8/nX uJmc9CPqBbqVj7QTq3Ej62eob0m8AUnGyM8T5rVrXB0n4QP15/DNT1SCn3nNHGLpPCTfytviSE9/ mRM+MRdoV/ZDw49J98MflrANwJPK9ny0HKWME3lNvaOq8bQ6zNV+zUcSSZMAhpIuAACSCQMxxh9c ABfpAQXVEfkBBbjwFjIpUVpe0hgACNtk6f0Xo4WluWlAknQAUQCrtYcwJI68OP3nJc9xeACA8tOS HiIPgLgqPhQDJCkTPgHgDdwSBqFGwIvfb182JvufthoAIKQ6abGft1B/KUCSsukLIMrvE4CG8aVf +ajQccqXn/qYe7QbYryok7pDCoErgD0fr8O8hV7PLSBJ+5jv/OAJYJr5kcZ7+0gLPwiq6iNzz3hM Osqv6p6oqqxi4l5//XUdS/TzqZM2249rxs+uzY9rP+rC77uhXyPz/GvwRyTm6ZfsCykSNQEYvMSN Qalp5Xmek1aAZDFEHUgNeS0wUIC9OiEqqCjaJHT5JIU1qR8QAz8A1AUBIOOfvPRUB7COuq99oq4Z gDVpm+xrOSdI54bwRPnB2FbcbKl1V7SPoUKKSZ66oqLHqa4aUmK5f4//R4GC3D61QrC6ieigtvOM RmqlYK8QABQvH14WPFPsge0lqXWvSSWpqyoJXE0rNnDLS6/K56VUZDyAHzzz7EVV0zbky089tA8q pH2+BJn21QUQytfWQsOZQ/DR+FdovmLGqdAyw3Sm70l4vg+YMM+8eG1S7WKkkYwP42oUqoFYeG27 EUjWNkfng/JsSblQg5D5gCWxiw2MA1NkJ4NJIg3jCwwsWSqeBKorXJd/rXSZeLYEvIGxJG9zTYLF C21OSDfyNqSBRJheG82dn4FQKcPlS3PrKwgvpV/F5kGqyDzifuO+K5RQBTKJPR9Yc+p+jUCy0BGa D9NhMc1SNkvBLJMi/bQld96euuxZlYRsPuRZ7HLD4MAskTJNmDDRTatYaqtpqxeUJeY2ravfGLym 9cT89Z8DJlEDCIXGK/W/9XO3hb40N4Lw4sfC149MWy4vvsTCckQgWRif5stUdipKpc4LiAwtiiul iQGRA/WcA4DJ8nI531yMWWzpstgms5zdTPZkbd48e/Rbsflj+nmPA0iSIF7kLC1GKpwDSNQAQ6g3 ACQjNQwORCDZMMZprrRyphizYGjDOeAiL1edOySTGHzUpf7dXOlsrDRyIHIgciByIHIgcqBoDkQg WTTLYobIgciByIHIgciByIHIgcgBOBCBZJwHkQORA5EDkQORA5EDkQORAyVxIALJktgWM0UORA5E DkQORA5EDkQORA5EIBnnQORA5EDkQORA5EDkQORA5EBJHIhAsiS21Z9MerSdnEbStEVTx76Oc4Jm lMvZvxPzn2wzJ9owt+rwNycudjPfudXmWG/kQORA5EDkQORAXXEgAsm64uwcKpcjAjm2rkmLJnI0 Yv4jrmqzOXbmMhbcLbzzw2uzjvpWFgDSjrZi01yIc4rjFhX1baRieyIHIgciByIH5iQHIpCck9yu g7qmyfnICiSbi0SyZdM6qKFykfMbkOQ8YX52YoBxJAJJ40R05wUO+JsZW384yxvJe6TIgciByIF8 HIhAMh9nYnheDsxvQNLOPGWTXMAjkklAZT4gCejs06ePpnnyyScdB9nXN7rwwgvdQw895DbZZBN3 7bXX1rfmNdj2PProo+68885zK664osPfUIg53bNnz0rNvfLKK90222xTKTwGRA5EDkQOGAcikDRO 1NCdNWOWy8zMLnnmK6pRUzlqsJGezJsvSUHhWpcAGZ8aSbksNacR7WJTcepu1KSRI/9M2WhcNxmX a45BzEfknTld8kse8nJcIhLQaZOmaX35lrafeeYZ9+wzz7oeK67kDj/0cM3biKMWgyMVZ8mm53TF 2ha2IyPtnlXBV+pOI/9UEqQn1UlQAIGHH364Ar1TTjnFde3aNa3YJGzcuHF6SgXAkfbbEWj5gORk OcN5zTXX1PyDBw/OAZJz6uzTpPF5POecc4578MEH3cYbb+wGDRqUJ1UMLpYD8BTeLr/88o57oKEQ 0sj/+7//03uCNn/xxRd62s8VV1zhtt1224bSjdjOyIHIgbnAgQgka4npU/8pz4KzKsprtnBzBWJV JCkoqnx8uQOA+VSVjiTL3zOmTM+emS1gckb5DD+ra9S0kWu+cAtBcznBmg5jnhySNABPysinI4nE 8uqrr3G33nWrW7f3uu7GK2/QIgCLzRZqJvXNBoTTpW2c3w01X6SFAk694J8AvrK/RfonZ3yTp3nb 5kmUeQCFHKtlBIhkOa4qQsdxpZVW0iRI5dZYY42qkleKKwZIIpHs3r17UgZHpoVgOomcg54IJOuG 2Q0VSIbcQFL966+/uggkQ87E68iByIGQAxFIhhwp8RpglSaR1GMGRaIH1RaQxGp61oysRHLmNOrN VGlsY0DSutZYgGCjxllACUiDFmy9oJQxG4ABVAGskEoiJQ9pAYlGaUASUAg4vPG2mxRIrr/u+m7Q jYMEeE7XdpK3xaItcySzBowXkDa1WKRlAmjNkAgACsjEDSkCyZAjhV1HIFkYn4pNFYFksRyL6SMH IgcaOgcikKzDEQR4lf09RSRrTqWBAMnapJ9++sl99tFnbviw4W5mZqbr2r2rLlUutthiOdUYkJw0 aZL7/Nsv3PAfh7vp06frkuvKy/Zwi7VbrJLEb/hXw9zIH0e69u07uNV7r+6++fYb9/7777txf41z 3Zfq7jbru6lrsmDTHKvtr778yo0Z9av299mXnnMvvPSCSv6OO+44DUO6CfDr1Xst165ju6SN8Kl8 XJn7448/3FfffeVGjPpeQeeyS3d3a6+xtlu0S3vX2JNiknHUqFH6W3TRRV23bt3ct99+6z788EM3 YcIEt/LKK7stt9zSNW48W/JJ3z/55BOtE4nkoYceqv6TTjrJLbfccurnH+WRvyoqViKJlPSDDz5Q Cc+qq67q1l13Xdeu3ez++3UhXSXtiBEj3O+//+7atGmjy6SrrLKK69Spk5+0kp/lyc8+k/kwfLj7 +eefZezaK//XW2+9Ssv9VQFJ4y0VoDe30EILJXXRPuYB9SBd7dWrly7jf/XVV476WdJdeOGFk/Tm IR6+LbPMMm7JJZd0Y8eOdf/73/+0rZ07d3ZbbbWVC+ftxIkTdUwZW5uvqAwsvvjiVmziMq9oFy5t Ru3Apy+//NIxB5AOWz2kfeuttzTPWmutpe2H9yzrkmaDDTbIkSb75eHn/iP9Dz/84FZYYQUd11de ecXB27pY2qa+oUOHKs/gB3zcWFQTrD9h+7755htHv8nXoUMHnQuMl39fhHnsuhiJZDHjZOWT59NP P9V5CZ9nzpyp1++8844mWW211Vzfvn3rhfTe2hzdyIHIgXQORCCZzpeahwp4LB9fprqFSNpUoubr B2YFgYXVEwjieGFjIHHHHXc424rGCuIlcfbZZ7vdd9/dghxA8uMPPnKnnH2q++3335JwPM2bN3en HHuy22HADgIKRRoISdsuPv9id9f9d7mNN9rYtWvfzj3xxBMaZf969VzT3XjNTa5tp7YW5A484ED3 9rtvJ9f5PPfeeo/rvdE6OdEP3v+gu/SyS11ZeVlOOKDh6quvrmQI8J///MfdeuutaiwCcHnqqady 8q299tru9ttvV91GIgA+Pk9yEnsXG220kZbrBVXyFgMkDzzwQHfXXXfljBMA78Ybb3Srr756TtmA kn/9619qzJMTIReAtjPPPNPttttuYZRe079TTz1VQU2YAMDx4osv5gCIfEDy448/1jYAuniRX3fd dQkPx48fr7qlpPFpjz32cC+//LLDKIn0gPiQ9t9/f/fee++5I488UkFhqJeJOgJAn35CgIxjjz3W jRkzJqco5utZZ53ldt5555xw7gnAB8RcDT8G0PMDYHNv7LXXXprOz3PRRRe5iy++2AFwjJo1a+aY Z2n9QWWB8QDQGQG4AcSPPPJIrQLJou93Afv05YEHHrCmJW7v3r0dBjQAy6qoUCBZ7DhZnR999JHb e++99fK1115zu+66q/vzzz8tWl3mylFHHZUTFi8iByIH6h8HIpCsozHRjcLRRRQQqLp/viGMALUp f04uuOYmzWWPyDaz94g87LDD3Kuvvqr5+/Tu49bq2cst2GJB992IYe6FF15wBx98sFMpYEUNY34a 47baditXPrVcpVS77LKLAsiXXnrJff3115rqmsuudltt31/9GLdceuGlCiQrilCFeyRHGBDYy/3M k890+xy4jyVxTz76pPvh+x/0+sNPPnSffv6p67x4Z7dd/9nK+iIEcrvusItbcvmlkqXq2267zV1+ +eWab83V13B9N+ireo/PvvicG/XTKNeyZUsFQr7kxYCkVQ5QCNuH9ayBRyRg6ENCSKIActBOO+2U I+FCYrbddttpXL5/xQBJylhiiSW0HqQuWPIieW3VqpXj5vOlfYAxXp5ISJFaLrXUUmrwgOTu7bez AP2SSy5xO+64Y07TkPYBMCkfUL399tu7pZdeWiWgzJMff/zRkcbXHU0Dku+++65jbmHB269fPwUc vnEQxhhIjJCw8uLHSOmNN95QgGgNqg5IIrn77rvvVIoGqKH/SNk+//xz/QEUARSbbbaZKy/PP19v uukmt+mmm1q1Kk2sCZCkIAA3FsoATsANH2nMqf/+9785INwHQT169HBbb721gmjmF7yDalMi6d/v SJfXWWcdx7hw76bd74Diu+++W9sBj5C2IqEG4DJHANnhh6Em9v4VAiRLGSerwuchUnokp8wH5j4f LG+++abeuyeeeKJliW7kQORAPeXA3AaSvNTzkjzIM/aTB2BGrHP1J1KAjCyxZeRLPSMP7oxst5IR CUpGpAmZf/75JyNWthmRjmQEPGR+++23zC+//JKRF15GXg5566rNiOlTpmUmj52kP9ENrFz0rEwS b+mqcqdOKE/KoB/yktKfSOQy5f+Ua1lTJ2bTCGDICCBJ0uM575zzNH2vNXtlZJkriYNvItnRuO23 2z4JnzF1Ruaicy9K6rnzzjtnx8kY7LXnXhp3wL4HJOF4ysZNSfp1+UWXa5r999k/CfP7OGvGTM0r oCojxi6a9oILLshM/iPLN007cXJGXmgad/LJJ+fUJcBTw+FF2D6RdGicSANz8tgFc8l4KFIwCy7Y tbnFfEsj5qKVL9sA6Ry0dCNHjsyIJFLjb7jhBgtWV5aUMyK1ywmzCwG8mkcAnAWpy/0hIFLjRHKW EQOJnHjuE5H+6X3jR4hkTvOIBFSD5UGQkRe6hp1wwgmV0gvQ0zj6JWA4KYp7Uj5ckjiRfCZxvme/ /fZL0ohagd6rfrwA5aRO2ZpI08oybKX5Kh9BGidg2s+eEdCZlM89EJIARI2///77kyg/jywR67PD ImXJOykvnCMHHXSQxskHhz57LI+A7CSPfNhYcI3c8H4PCwvvd+4nAdTajvPPPz8nuYDOpH2yBJ8T F17AD8ZaPhzDqOS6lHGyzKKGkrSFecf884lneNo4+mmiP3IgcqB+cABsxbMKrAXmAnvJh2ZGhC76 XBWVM8VoYA4wG9iNdxNYznAd72V+hvlwC6V5AkjCFF5K/KYI+Pl79F/6m/jXhCTc4mEaNLVc8pRJ ngJ+lod8AwcO1AfwgAEDlOEhkCRNSLJcq3nOOv2sMCrz3NPPJg/00aNHa7wY8CRAUpaIdcD9jHfc eofm6d+vvx8sQLJMQWP5P2UZWY7WNPnAnGW85ZZbNJ1I4DJTJswGogBJADRgmRcagMwnA5Jp7RNp jOYRSZGfJfEXAyT9sbUxFIlsBl5xo1gYro2TDyRFgpjUax7Ry9T2ieTQgqp1RY1B84hEKictL1sD rflAXE6GigsfSJJPpFRajizX6s0c5rnssss0Xpa7k35aGpFkVtsGA5KAaMBOVUQd9Oncc8+tlGzI kCFJXTZfSQT/jQ9pAKQ6IClS8Up1iSRPy6ROIx6EVs/DDz9swYkL0CfeB5LMC3+eVOdPChNPeL/7 cWn+xx57TOuXXQlS+cw9QfvCD7OwrEKAZCnjZPX4QDLtHrF00Y0ciByo/xyY20ByAViUT1rrR+G3 a/PjCmrVcN/Fz08AQ+JivECYPCDzVVdSOMYHLM0USiwJouNVbB6R1mkVLDmKVMsdffTR7ogjjnBm 2Zxv+x94QF24IiV0A3YekNPU33/9zW20SV8Nu/fee3V5CSvwSy68RJe2e67e0z38yMM5eZ5+fLA7 8bST3KLtFnXvvPtOEjdt0lSx6p6h2wkNuvsWXT5GkR5dxXyEXp8ts3XvVrFNjswIGW0dV3npujG/ ZfXkMIww3S5b2sawwtcFY2sdlvvQr0MX0ZaE/fqZB4Vs/1PK2DJO/j6S119/fc4SLMvCLDEyB1jW xUDIJ5ZGWf5GD1G+7HSZj3gBMGqggt4exiBGzz77rDv++ON16ZXlwUIMKchrS9sYpdBP5gfGPCyF p5Xx73//W/nK/As3MKfNtpl1dUvbLLWyLJ2P/PmKbmz//ll1C0vPcur666+vlzZfuRDAXyMdSeYo c9Un6saQRgCtQw8U+v7773UpGz+89w21CLv00ktVd1nAWrKPJFvoyAcT0QURy7odO3bUtOH9Xl0B jI1IutVI6Pnnn6+U3MadZWT4l4+qW9oudZysPn9pO02n1dJFN3IgcqD+c2BuL21HIFnAHAF8AlB4 eKMHJhIOZ7py1QFJ9oLjpQDdOegOt97G2ZewVTu9bJpbbc3VFWTzEtxhhx006uLzzNimrxt0a+5L 8JnHnnYnnH6iW2SRRXL04+zEGwq49f5b3Y0CGKoDknvuuWdiTd28WYVVu+iVKtknRsX1008/rbp/ xBmQpG/XXHNNNr38B6gBhgDaWEaj9xfSnASSspSa89GAbhs6d7QPwkjGLIzRHcQohQ3QjQCOADvG HMAHkc4I0AB4QA/T9GYtrirXAEWYBgAuUrAwWPXVaCsGEoDgkPhYoX3VAUmRTLrTTz89zJ5c+/P1 vvvucxhN+cTYoeOH68/XmgLJNDCTZqDDx4wsbWuT0BfFyt8n0/etDSCZdr/7daX57cMMPcp77rmn UhLGh4+bLl26OCzM81F1QLLUcbL6fCDJx5SvK2xpohs5EDnQMDgwt4HkPLG0zZr/P2PHZ/76+c/M X6P/zEyeNFn1AAgPf7b8GYZXdW15RAKb6NfJfnVcVtKR1EDvH8uILGXxe/2l17yYrLds4uylOpFg JPEikdQ8hxx4SGZmhT4jkWIBnhn8yGCNk5dVkl49otIgRkS6vP2fS/6jafylbTHi0fyUYXTAAQdo uiMHHqH6kXKCjkVlZOskLWvKX5MzskVQDtnSNkt//lKhgJmM6YKFy+FWgLygtU54Euq/WRpzbVxY 0rQfeiBivKB6IBaGa+PkL22jN+e3jzS2PCvH6CV5qA91BdokL/GMgE3VKbF2oENm42hhuLb0Hy55 +2nS/La0LcYvGQEcGfTpKJ8l0TSe2DgJUKlUHPwkH/nzLa/b0raA/kr5/QB/vqI3GRLja3zw5ys8 tvC0pW2RLmp8Ph3JtDxpy+H+kqxszxQ2LyNGXFpPuLRt86gQ1y/U9Gntfvfj0vwC8rV+kaCmRWfE Ylvj4UdVJCs3mi6fjmSp42R1+ny0sOhGDkQONEwOzO2l7XkCSDL0vpEIYCrtN0N0D2tKA7bLgo0L zrkgC7TMOEVcgJf9ppdljXxEcpMYUTxyf2WdrlE/jNIXBi9hkTglzbv8sss1HCCJviKGNFP+ygK7 vEBScmOoQ3oztsEgR7ZBSvKa7qNVdPZZWaOPPXfbIxMaJmGQY3z1DY7IO6eAJHUBXlAeruqHvqSR DyRlW6JKQNJ0ONFdNQKcGhCS/RAtOHFlGTKJZ0yNAJzkAxBSb6FkQNKAPkAM8ENZAFmM1nwSKaLG AQhDQrna2l4dkBTpaZg959qfryIlzInjAr1Iq8ufrwB0gDlxohZQKZ/pO4qUM4mrDnymAUl/nNLA p0h6tQ0+kEwqLMGDHi19KlSP8Oabb9b0jGEaoRtJeRgMVUXkJ12aHij5Sh0nqzMCSeNEdCMHGj4H IpCspTE0wANQyvcDZNWUTjjuBH3Ar9N7ncwfo8bmrUv0FZOqtuq3leYZeMjAJMw8t996u8YBRHww ZEDtkIOyQNL6BKB8bvBz2TaEEsmKQpFgDro++0IbsO2AnDaS3/iA9PGeW7OGMbKNSo6FrrUPQGx1 +0DT2leKRJKyRadP+1Cd9SppawIkjznmmBwgyQtYttHRuvfdd1+KVxo2bJiG8fJOAyhmxEG8DySx wmfsCEc6WSgZkDSrbfLRBlmi1rJk6T2nKKSW1IHkEeDok+yTmbS9pkCSck16KOeh+9Wo/84779S6 wvlKpOj9aZycb56Tz+dtTYEkgNWsomWJOKceJLMmyastIGmGWUjXRfc2p760C6S0jBM/2ZA8Jwnz mHKISzNk8hMj0SRdmgTa0pU6TuSPQNK4GN3IgYbPgQgkG9gYivJ/BtDFQx4Q5UuOABi8KHnZ+mQS MECA7B2ZRInhQEYMF7Qs2b8wCcfjAzUAH+CPpWmouqVjPw1SoiHPDcmUTS7LAUBakPxDKiR7Bmob RF9Stw+wOFzArRhnZLDu9slvnx+Ov5D2mbTpkEMO0WXqsIyaXPsSSayhWZamn2x1AP9Ncvbcc88l 1bDkaeGnnXZasuTNmLIczHjbzweSFGBgg22Uwq2fAJpsz0PdPqUBSeJ9yafsi5hkAcSYVE829NYt tohkWyAs561ttQEkS5mvtMW2BsI1i27GwpbVaWNNgST1yP6k2l9AmRjxEaRky9rUU1tAstj7nXlm 9/Q+++yTAz5lf0ltNyBcTguyZqe6Nj9QmWBbjzQqdZwoKwLJNI7GsMiBhsmBuQ0kG7yxzdxQhcXq FYtWiCP0BCCqQQaW6aK7pMf/+RuSY4ggLzY9Kg1jFI7bw4hDJF+6gTLGHnYah/XHjFnSrGwFLFRp zEIZAoz0RBBZDtYi2VSczZ0h2u5bu2LAgAW6vAR1o3T6w8baKPTLi1QNTdhEXfat0/z8q2n75CXo 2LjZCOMDNsPGuANDlJqQb7VNORjYYCCCRTmW1RhRCGhUa3XfQvqUU05xnJgCYSiEJTRWwhxZiAU6 FssQRwZSlhHh8Mc2il922WXVmALes7m2gMiCNiS38jg+EuVp+PH444/rUZrEydYyepqLAFk1aqKN 1I21NxbmUHXGNoWcVlLKfKVuWYZNDIGY55wcNFJ2OKA8kcbpPMJQyE5UKcVAh3pkeVuN0jiOk3sH QyP5oMsxghIwmVhtk6cmVOz9zr3MqTsQ80aAo7YZXkCii5scAKABKf/oo0gclXdEYwzDXOVEIdsk vNRxojzf2MY3HiMuUuRA5EDD4gDvC565vHt4TuC3H9e8r+za/Lj2o7f4fTf0a2S+f1XhbyQv9mPZ iGUlfkhXWKaRB1m93JC8qj7VVpycdpLZfPPNE0mQSYTYJBkDj5CQXApYS5ZB/fQs/YUkW5Zo2XKq RhilUjXyV2fgIS+uDDpjSG5M2kY+AVOVykTywkbitkxr7UOKikRJLJJz8tS0fcwj9BeRXtlSJXX6 S705FRZxgfTO2k8dto+nhSEhZIPWkNjgXLbySfKSHommWFLrRuVcw580Ii+STNJbPbj0jXDuH58Y F+KRaofEhuuMLfHMJ5/QyWRzdKTiGIKwTM8SqpyBremZl2lkxjrhcnBaWsKKna/k4blwxhln5PQf 6Rybi9MP+uMbrfD8sPkmp8RQRA6l5bEESPNla56cupCom/EThlO1ScXe70iGMYajz/aTD8gMOqrh XMjXTnjCvWeSaMpBUulTKeNEfvRYKS/ffPbriP7IgciB+s2BKJHMh3AbSDjHiSG1QsqFxA/JWlWE pBAJAFKq7t27q+SrqvRzOo72IYWkX2ytQn9at249p5tR6/X9KMcUIi2WF6dKW6uqgHRIjzh3Gums nT9dVR6LYx4gwUSay/ZMHPmINLi2SYC4fkHytelLYJFWd+3atdaqK2W+wj/mEEdq0v+6JPgMv/kS tz1O67K+Yu53efWoJFLUG7Rt3bp1U2lBXbSvlHGqi3bEMiMHIgfmPAfmtkQyLm3P+TGPNUYOlMQB QCrAMSSWvNkbkmVe0X3LOdM7TBuvIwciByIHIgfmLQ5EIDlvjWfsTeRAnXGAzbY5LYVN69ELRIcS 4IjOK1JJ9Fxto/U6a0QsOHIgciByIHKgXnEgAsl6NRyxMZED9ZcDdmpLWgvF8t5xFKCd0pOWJoZF DkQORA5EDsx7HIhAct4b09ijyIE64YAY4TjOgeasb6y1sd5GB7FXr17JMZx1UnEsNHIgciByIHKg 3nIgAsl6OzSxYZEDkQORA5EDkQORA5ED9ZsDEUjW7/GZL1qHdSlW5BhzIOWC2HOqadOmugdjdUzA gpj8lGN5bE+q6vLG+MiByIHIgciByIHIgdI5EIFk6bxLzSknwLiZ5TNcoyYChFotmJomBs7mAODx 77//nh0Q+Ng4nU3X04AhwJGNoAGRPgFC27Ztm2ph7KeL/siByIHIgciByIHIgZpxIALJmvGvUu7p k6e56VOmu0ZNG7vmbZtXio8BuRxAmjhu3DgFikgT2V4GqSQnkQAUIcAkJ2uExJ56BiJJA9jktA3y ASbZRxE3UuRA5EDkQORA5EDkQN1wIALJWuZrBJLFMRTQB5gERIaEtBFACbE5uQ8KAZAASYgNy81a 2IAp4a1ataqTzbgpO1LkQORA5EDkQORA5IBzEUjWwiyYNWOWy8zKSs9mlIuu39SZqUvbjZuKdKzi PEm/WvLPmo5+YMYt0EjOpJRl8cYi0UyjmdNmajDxs2bOztdY8jRaMHumZVo+CwNoGQHMfHBm4fXF BUQCJiHO3vZPeJEjAfVsbiSYnPlsxHndxEFhnKWBB0g9ifcloIRzjXQzjS/kAcAaDzlDmzaFy+4G fikLCSlEOtJzbfWwD2M+sjqIr+/jlK8PMTxyIHIgciByYN7nQASStTDG5ePLFQhWV1Tzti1kydtb ahXsOW2SAAvRqQyJdM0Waq7A0uIAq2V/TdHLJi2auhllubqBgNBmCzdXIGp5fBfpn4EcwgEoaZJA P8/c9AOmWPaGWKYGiBmxFQ3ADjCGDiVE/wjHNQJkAuh8siVxOzpwypQsT/007du3zwGIHAE3adIk P4n64SHL7j4f2RqHNgAwrS34AagAXSO/7RaGS56GNE5+26M/ciByIHIgcmD+4kAEkrUw3gDBjEgH oZlIFqfPUgDYpPls4EMc4A+wZzRt0rQEDDYWaSJ6lZRjwBLJZPNFWlhylXoakCSQsqyOGWXSBgCU FN9y0VbqJhkrPA0JoAAikSya9M6XOtIdzlOG/GVtk1IC6kx3EqMbH+SRx4AkwJTyDVDjmsTRB5IA TU5ugSjLJKOAQoyFAIm0j/yQAUmuDTwaoDQJpkkq/Xo0s/xrSONkbY5u5EDkQORA5MD8yYEIJGt5 3AvVkcyVLsoSaetmSUtmiuX31AnZJVEkjIBMyM8DiARkGjBlmbv87zJN17T1gq6pgNaQ6jtAAQgC zAB3BrwAaUj8DLzRJySRSB4h4gBrpjMJeAM8miW4xWviin8GJLmkXNJQjxHSQKuPuiiL9qCHCXA1 Ioy4UDJqQNKW45FkItGkbeh6QpYmlLQSV9/HiTZGihyIHIgciByIHIADEUjW8jwoFEgidZw2MQsW WyzaMgGE1pyyv6eIdDLjGotUs1mbLMj0gWTTlk0rbS80dYJIyNDPlGVxltFDAqCYpI44gI2/XBym L/aa8gslH7hZHluutmvcNIkiQNOWvAFrSAm5BoQa6ASoQb7EUgPknw8kQyMeS2OuSSN9EGhxuBZP f5AuQgYSbVndlsVpJ/2BaC/9SOtfXY+TNiD+qxEHTKLsF8L4Mk/mJ4p8mJ9GO/Y1ciCdAxFIpvOl 5NBCgaSlW6DxAq5Fu5aV6gNkAjZ9UOgDSZNU/u9//3ODBg1yP/zwQ9bIRLDcfnvt60487aRKZVrA 6NGj3a677qqXL774ooIviyvVBfwYeCukjDT9QCSBlIOED7/pCYaSQH/vSYAk4BhAhxSRa78tVQFJ S19Ve225nDShriVh1l78BkoNSNq1GQD59RmYNakl+ecmnXPOOY65wLw47rjj5mZT6n3dfBj07Nmz UjuvvPJKt80221QKn1cDIh/m1ZGN/YocKI4DEUgWx69qUxtArG4fyTSg6Bdu5bB0jcQS8oEky9pf fPWF23333ZNsgCYkInvtupc79qRjk/DQM3LkSNevXz8Nfu+999SQJUxT7LUP3grJmwYkw3wGwAj3 l6j9ujCYAUQiETQ9xbSlb79sA3EhQPXTmN/S2nVVrkkgiwGSfr+qKru6OHhy+OGHK7A95ZRTXNeu XavLkhN//PHHu2effdbtvffe7qyzzsqJixe5HEAK93//93/Ka2I4exzp8hVXXOG23Xbb3MTz8FXk wzw8uLFrkQNFcCACySKYVUhSA4C1BiQ9iWUOkJTNzk85/VQ3ePBgt9xyy7mrr77ade3SNVkub9lB DG7y0JgxY9whhxyisQ8++GBi9ZwnecHBgJlCKW1pOy0vOohIIEPgacY2lseXPPpL32lLxwYOAaHs NVkVWVr0MAF9hdDcAJKA55VWWkmb99BDD7k11lijkKYmaf7zn/84HgbbbbedO/TQQ5Pw6KmeA5ts son79ddf5zsgGXIm8iHkSLyOHJg/OBCBZC2Pc6FAktNvSOtLHP2mTJWlbY5axNCGZWzIB5LNFmrm 9t5/H/fpp5+6gQMHumOPPVZP1NEyPfDpl4kfUGYEmKvvOl0G5PxlYdpvABO/r3vItekk4rflZfxG VmYhQNIMZcI6rKw0tzaAJMDQgHkh41RTIJnWjxhWGAcigMryKfKhsPkSU0UOzGsciECylkfUAGK4 dU9YDWdyT6uwzGaZmvQ+TflTtpsRAV+TFrMturHMfnXIKwowkHhecOkFKgnZc8893aabbuqmCTDN yObmS3dd2i2/6gp+cbr8+9VXX+kSnEUAUHr37p2q+2dpRo0a5d5//33HcjgSrz59+ugy8o8//qjS vB49elhSbRdpAUDokNlpM5bgyy+/1L0Yu3fv7hZbbDELVhddREAxwHaDDTZQwPvJJ5+4V155ReNX X311t9VWWyXW1WzHw5I2AOqnn35yw4cPdz///LNbaqmlHOUvs8wyakiEVXRIxQBJH5SydP3LL7+4 oUOHan3oZi655JJu4403zumPAUna99FHH2m7MK6hTfRjtdVWU31W8vtL2+i5or/asWNHLe+DDz5w n3/+uRrxrLXWWprP7wsgFx5B8MEkiSeddJJKqS0tYHrllVe2y8SFZ/DCp06dOmmf/LDQ/8033zjG Er536NBB50WvXr1S5xHzhx+GSCuuuKIjL3OEeplPW265ZWq+sM5Cr9PmEfPqnXfe0SLgfd++fXUe MU9Lna9+e4oBUIzTZ5995r799ttkvjIn/PvIL7umfsaouvnq1wH/PvzwQ20f83PZZZd1a665plt8 8cX9ZKn+YvhAAcXMI9IXM7akjxQ5EDkwZzgQgWQt8zln6x6RGjZeUPaSnL2zzOzaBCSqZbZsMq4G NUgdBdhB/v6SPsgsLyt3q/dcfXYZeXwHHvB/7uRTT8mJBXAAOEOqSkeSZfPTTz89x9Ib4xD0wO6/ /363/PLLu2eeeSYpEp0pXtTQE088UQm8kA/wcvbZZ7u99tpL0wEIeaF//fXXbt9999Ww1157TY0+ AGQ+HXnkke6oo47SICSrvIzPP/98BaB+Ovw777yzO/nkk9X4JowrBkjSNkAggPLOO+/UfgMGfMII 59RTT03aT7tPPPHEBLz4afEDumg3INIHkhi8oGoAkMaCnRetT/vtt5/WY1JkAImvI+un9f0bbbSR u/XWW/0g9aPnZwDLIqvSkcT46eKLL3YPPPCAJU9cPkgwNgFY+sSSOXUDMgD1zAuf1l57bXf77bfr Fk5+eKl+gDt9gKqbR6XM17R2FQqgfvvtN50XfCCEtM8+++h8RfJeG0Tfrr32WnfHHXfoR4ZfJvOV ezCcOwBuVjZQffEJtRL0ZrmnqqJC+VDKPKLeYsa2qnbGuMiByIHa5UAEkrXLT5UiGkC0orHMhjip xpc8cjINoBFCOriASCUzAlLY9gdq3Ey2/hEwajRj+gx37ZXXKvAi7JEnHnHj/xnv1u+zvlt5pazE iaXyPhv0ceutt55lUxcdrnvvvVclfQApQCKUD0h+/PHHCdhDBxMQiAQMoIML1QaQnDBhgh4biOTt iCOO0HKRVAGi0PNDikd97777rr74AGgQYRgMAdqQfG6//fauc+fO7rvvvnNDhgzRlydACcOTkIoB kuTlxXfYYYe5t956S4sCNAEGAXTUB2AB5FldtIlrpIu8XLt166bSW4DE008/rcc+dunSRUEp4Ar9 S8iApF7IPyyA4QUvUG5U6IQTTkj0W8eOHevQh4QAvDfeeKP6d9pppxwJEjxE9zGkRx99VK39CX/1 1VdV6lwVkLzooovc3XffrcUgAUdKihT4kUce0XmF1DMEigYkrW7mEePEB4gBlvPOO68SqLH0xbo+ 2Fh11VVVcsp4MYcZ9zfffDOZR3MSSDJfkaij24tKxW677eaYA8zzJ598ssr5WiwPSM98ZUwhngXr rLOOSuj5YHvhhRfcwQcfnGOdz5zdbLPN9OQlpMe77LKL6iW/9NJL+pFHOTfddJOufOBPo0KBZCnz iPqKGdu09sWwyIHIgbrhwNwGkrwA85JIfgRXZX8igcqIEYX+ZMklIy/3jLwIMiIpysgSYkYe1BlZ +sjI2cwZkSBlRKKTkRdtRl7eGVmOzLzxxhsZeeHnras2I2bNmJmRPR0zk/+YlJk8dvZPTr2pVI2c zV0pHXnk6MRKaWVpOylvuuTbuv/WGQFzmbtuuUvDy8eXKb8qZawIgJdiCZ0R8KP5yCu6hqnJ5UWj abbeemvlqyUSyWaSV0CBBatL2ZTJT5bRc+K4EGCkcSLNTOIYP9rw8ssvJ3lXWWWVjADdjLx0dWxJ zJj6ZV566aWaXgBdRiQpOtaMN7/bbrtN4wSEZWRJPqnLPJRFOuZMIcTcsX6JUVNOXZQjIDcj4DUp inYLSNM5SCB8IZ0AGZ2DVpaAKY2zjCIlSuq56qqrNI68zHcBqRonoEDnveUxl/vDymWMiiXZ8kfz n3vuualZ6ZNImzWNSFNz0ggwSeoWVYScuMsvvzyJE4luEse9LKBV4w488MAkvKYeWZZN6hMgmZEH XE6R/jwqZb7mFFZxIaoNWifjmY9svgr4rjQnuR8Yu3zzNV+Z+cL9+SrS4ErJuI+433y68MILtQ3c T7IcnkTxbBVQqXE77rhjEp7mKYQPpc4j6itmbNPaF8MiByIH6oYDYCueO2AtMBfvO/k41Xc7mEwE Rvq+5XnCOx/sBobj3Wa4jncYP8N8uIXSPAEkYQovpUJ+MA0K85RNLstMnjA5M2XSlErlWB4fSM4U sAqQ4wV03733VQkgw8H48ccfNR9504Akg22g5OGHHw6zZ2RZWuNrA0ha4bLcl9QpEgudXBYXukww 0SvT9CIh02j7uDCwLFIojb/vvvs0Hh4WMj6Wxq9TjJm0rAEDBuhEpy7GD7eYyU6Z5JHlXC1PpLt+ NZmzK4AkAIgXrrWFOr7//nvNw7gAXEOqayD52GOPaf2AHdoWEh8ctE3UCXKiDEjSZx4cPjF25CGv UU3GiTJ8sHHJJZdYsaku/LV57n+kWOK0Dx+L893qAFTafPXz045wvhIfPiNsPqS59owgnz9fC52f ffv2VV6kfUjwkWR8Eik7VaRSdXwgU6nziLzFjC3pI0UORA7MGQ7MbSC5AN3MJ2z1o/Dbtflx5UGp 4b6Ln5+8XBN3xIgR6peHXb7qSgpn2ZMltEKJDZ/RNyo2zwUXXJBjtd28nSzn7rC9GzZsmC6Jpuk/ 5msThjNV7SMJr2xjZfYWZFnQJwEHTqR+tbK0beX6y1Zp+pWWDpdlepbRIAxJMIKxuUEYfpaV5UWs y5gsnbLH3y233EJ0QcQSKEYvELyCZ0cffXSy/F5IIRikPP7447r8+/vvvye6prSfeeMvU1OeLW2z RIwKAYQ+m50+hD4hqgAsDYb6asx3lsGhUrb/qW4fSfTtbrjhBjVkev7557Ue/5+1nWVkVCiMbGkb 4yv5KLFgdSkHnTyWUt9++20Nq8k4UUAx84j5UaxOrzYy+Ffdkm4p87WU5wrPCKjY+cpzkucRLtuI 9e/fP6eHLHuvv/76GsbYMsZpVB0fyFPqPCJvMWNL+kiRA5EDc4YDc3tpu9aApIFKA5E+kMSPkQdu BJJOQVFVQJLTctChgtJ0KAFkvPBFSlFjYxub5v5LQiQPVe7ZiIEI+o8QIMuAlpXlu7wURTJVMpDk 5QrYEImPliPLe37xef18LPjACX1KjBYgDHeYr77xEOEGxjCOuf766wlK9Cfxb7HFFmopnQZomdt1 CSQxJgLgo2t3zz330Jwcuu6667TN6P2ZpT0JDEgCMm6++eacPJykQ1/4EEAHFqpNIFndPJpTQLKU +VoqkCxlvvpAVyT4jg8Wn5hbfNzgyhK922GHHfzoxF8IkCx1HlFJMc+IpFHREzkQOVDnHDAgidCJ d539EISY37ax8121DakwMsYPmRv6NTLfP3mh5iV5cCXr5fKATNbSbRmTpR/TkRTr37w6kvKgrFMd SdpQ6M+WoApNTzrLk29pW6xo8/IwLaK6pW0xtEmWstB5CEkkUxpf7NK2gDrN5+tIWtn+spWF5XP9 9on0NF+ynHB4WAzP/cy2jB4uRftpfL+v78lSoUgzkzEknUgTlQ8infGzJUvb+XQGxRhC8wkgy8nH BfeHLT/WhY6kAGMtf4899qhUNwFisa3xjLFPtrTNcmtIplspW0olUTUZJwopZh5Vt7Rd1XxNGiwe +TjVvufTkSxlvlJ+MfPVnhHkK3a+oqpgc0ckwxSRQwJqk3iRIufE+RfV8YG0pc4j8hYztqSPFDkQ OTBnOGBL22AtX0cSnXR0JLFfwSah3utIpgFJHpB0qq6B5JwZKqlFdE+nTizXH6DSdCRrG0jCM3ux 8PAOSbYE0vgQSPIyk70CNY6XZ0gYGlCu6S368cW8JNDrtPaJxNQvpk78YhGu9VWnc2eVi9RF08t2 RhaU45o+3DXXXJMTbjqS6OaFxEeVAQSx/A6j6xxIAl7huUidKtVNALqRxB900EE58cUCyZzMJVwU M49qMl/9psET+p6mT0y6+j5fmVvo5dIHkTr7XVM/epHE8ZMtpyrFW0B1fCBdqfOIvMWMLekjRQ5E DswZDqQBSQye04AkH/AIAflARSjIc5gfwhB+vgCx0NazxJeX/ALzSSRpFCh3vgCSAafqCkjCa6RE vDgANz4x8BYXAknSGUjC6ton0eVMXkY1BZKUKzpbWt5pp53mV1MnftngW+ui38yz6kj2utT0skF4 paSie5nwIR+QXGGFFXIsZykEA5vqXuaih6hpQsvpSo1ICajOahtJlNUvW9bklMADweZEaKxRn4Ek nSh1vvoMQEoLb/iAyEf1eb7SZpO+ynntlbpwp1jb0z/mJZaY+agQPpQ6j6gzAsl8nI/hkQNzlwMh kESIN08BSTFyUIkkL/BwK5C5y/qa115XQJKWyZ5x+vKQEzcySMAA9QAGk7bxYkkDkrZVCK5ZeCLS ln0VEyBSG0AS6Q9twIpY9jHMYSZtlT0fM6KDmGqVnpO4gAs5cSYDH6iPJVpE9UbURX942RqJnl/S Npa1jbC8Fj3HhA/5gKTVA78h+CdGWppP9oO04iq5ZmUs56hnZH/HSvFVBVQHJPlgMzAkm2fnAGqs 7GkzQEM2ic+ppr4DyVLnq99JPrboP1szsQVGGtXn+Up7zYKe+0n2jky6wJy1ced+qooK4UOp84h6 I5CsivsxLnJg7nEAbAXGYvUXzDWngWSNjW2EdWq4IC90VQbHJUykask1frPalm0u8qlrNrhwNpku xGpbJLa6QbZ1UB7manzENcfWcY40hFIsm0tDHEfG5tRsuA1xAosAG92wGGtmrJDl5ZljbEM6DEww NIEoT5Zj1bgHwwbyiwhb4+30EU0o/3xFeqvT4tJcxll0CRMjDY4qZONt6pGXn25UTj55sTuO/asp sRkzFq1QmzZt1LAFRWLmldw0ejyhgDGNp36McmgLisNYLHNiCZuuQxgHCThUC3CMTYzM2Mau2bib PsEPLGfhJ0Ytm2++uSXJcdksHItuIwxfMPDBeIKyfbrrrrscFvlGHGOIRTgbpJPPSKRMujk118yN M888U6OwtBbgqEdGCljWMNkeyQlwVL/9M2MbNjCHhz6lGdv48aX4i51Hpc5Xv20cmykSPR1vwrlX mBtY1tsG+vV5vtJm5qp8GKoxF/NM9nJVQy/ZFkmNw9j0n/Hnns9HhfCBvKXMI/IVO7bkiRQ5EDlQ 9xzgPctzgyNVfQMbwvwf70OuccOftZJwI99vYWluUUCSAgw4hq4BScLN74NJXu6AGCxiC21cWoPr UxinuXBMoCwnOl74+QiAEFpipqVlgP1j+WQZV4/yw4obILP00kvrtkAck8hReWlbusBj2mOAlHo4 Ng9rT36AorT22hGOjA19KoQYZwARJ7oAfH3iLG8AF+dOh2d+++mK8XOyDW3n/GKfAFRYo6677rpJ MKeKAN4A3EYAcHiA1TuWvKH1NenZ9gdQAlhl6yDmMMQ11uf5QCRpSAs4FAmpfmDwwQBtLFteDRo0 SP32TzagTrW+tnhzwzZy0gkfCqL7YkkUJP/rX/9SYMwc8oljE6mbU1Ps5B2LF6MktVz3t/+xuFLd YudRqfM1bB/3DePDyTHcbxBbcjGmRvV5vtJG2i2qIu6///2vPmet3cxvrOnDbcAs3ncL4QPpi51H 5Cl2bMkTKXIgcqBuOQDmYrs8BCTdu3fPAY4+iDQAaS7vev9nrfTxme+3+DS3ToEkD24DkxzlhmSO PdBqC1ikdWhuhpX9NUX3mmwm53Y3XrBxQU2Rk3XctInT9OhGzvXOR7JhusuUZc+Yvva26/TcaSQY vGDSCCmdLAk7AB1StbomjttDqsbX0OKLL+6WWGKJOvtg4Kg9PkyYW0gNfQme308ksD/++KOem80x idVJRg1IsocnAAwgP3ToUJUS2g3ql1/bfkAV9wyElDq8iUU/NvmQkyUM3R8TEMj4wnf71Xa75kR5 cb7O5rJYi+sHH+PNvGN7progXkBIMfkw42OTe4Q5FClyIHKg4XCA54UcKKJHv7IyCFDkPvZBJO8S A5DmEub/rMf+e8f3W3yaW6tA0pdG8kK0Hy98UfzUHw9GQMa8SFP+nKxnfXM+N+d0F0J23vcCjRu5 FrLJuU/wzR7sYiXuyv8uU/C0w9476obfxxxzjJ7p6+dpKP6p/2SldU1bL+gaSd/rA4VAck62ibEW 6+KkSpa4w/05uYcMaCYJPU+rVq30YeIFRW/kQORA5EDkwDzMAT4GEaxwOAi/EEQaoAQU5gORBhjN NXaF1xYeurUGJPOBSAOT6AChy4WuGlJJOjSvUW0DSTEecBvLsijLqV2W6OJ+HfWru+veO927H7yn emAsgbHM3RBpyh8CuoWat23uGjWtH1KQuQkkxYBIdVhtLKsCkjwo0m5wJP226bqVE93IgciByIHI gXmTAwggZKs/tZ3o2rWr6iG3OusAADffSURBVFUbcAxd3hnFAMm0d0w+LpYMJCkQkAiAtJ+BRh9U 0lELl/0RVQ+IpbillloqX5sabHhtA0kMZUzPzmcK4BF9MAwoGipFIDl75BhjdEy5cbl3oKqAJMYk zZo1m11A9EUORA5EDkQOzHccQC0F9S3eCahuARR9iaSBRwOQvguziLefXRsTCS+UagQkDTD6QNLC DDz6LjprdBzdnzXWWMO1bdu20HZWm27mtKxRRGORbrEMPGs6ADbjGjcRqyXRV8zHlIyknTldALG4 vMMbNRbUTp5qpGTURx0Q5VNvdUDS6po1Y5bWgR7lzKkz3LRJ01za0vaHovfw/vsfqO7h+H/Guw7t s3pMO+y4g56PnMaU2XxopP2hjfRvAekX9eVdRpa+z4Rn9EkmUOOmWR7MgjfyB0/y8TCtHWGYzgsp yyhZ2m4lS9tSttECjbL8t2vfhW82rpYOvqfRbD4UPh+wYkbXhHOP0T814ubjVxfE/cGSNvzBoMeM lmobSJr+JQ8ZftRrVvxcA0zT+si9Sl5Ts0B3M1xyhy+UBVEWqw8Qqw+k5ZoyiMsnMbXnhGaUf2l1 WFx0IwciByIH5ncOYCsgBxTosxLBHM9mnrH2vvJd3t1c+669z3F9v/HVwuy6KrckIEmBBh7N5UWg YEFc3+9LJAln2xUMBegUErfaWJqVE2cchi5QkxZNHXqHPgE6MIDxAQvxgBkDHH56/I0ESDVbqLkj r0/UNXVCuQCa2aCI+CbNm7gZAgoFc0m+yjqSM8oFME7MvmCT8qToJqJLSVwakAQ0lY/P6hImecTT YtGWldql8VK3glm5WLBNMwGoUp+E+ZTWtlL75JdbnT9fX8J8gF3GKoekD/QFPoWUNk6lzgcrm3ls wIgw5qpt0WRpassFOCKRbNmypQIvHg5QbQNJygUUUg+E4VtIGO7Yw4N7FSti8oTEEjr6mJaWeHYV gG+E4UL4Aai+VB0gCWAOiXqo0wgQ6pdv4dGNHIgciByY3zmAKtQXX3yRGJy2bt06AZAGJnl+hmDS wnDt+Rr6jbcWb9dVubUGJNNAJC+G8AewZOsSXjzEse8RVrd0vlTygQNlAP4AdtCMshnZF5uAtpaL tpJIDdZ/ZWK8gpSwcbOspI58s2ZmBLDIy1PehVwD2nwqH1+WgMgmLZpImkYCRsXa1gOWIVjzQRRg FkMc2uwD3jQgmZG2TDdQLC9nA1KFAEnabHxAkmeAOb1PAOOsdBW+0Zbq+uTzpBB/2N/pU7IARevz wDp129hZuUhsjVcqVRUpJONm/ICnvsV7qfPB6ptTQBKwygOBuQ9wRGpXCJD0pXXkBeRWtxOCAUny Uo+BY1yTOhqQpP9ISbk/eZgA/qiHfAYKqY+Hl5EBScoz8GiA0kChSSqtHsuLG4Gkz43ojxyIHIgc qMwB8BPGNeyfzLOZZym7OviAMfSTjjDfxW8/asHvu6FfI6v4VzCQpAxeDPZyML/v8uLh2nfx8wsl k0g72PKDlxMvHiy5YQiSDl521rEq2p5E+cABoASowIXM2hk/FsJNRWJpxLIyS9iWNgmXZWtbevW3 8gEsAiQhJH4+4PEBZggkTfKpYJEtfirALODO6kkDktYeXL8fhQBJ5YNYgRsf/bp8A5eq+mTtpv6w T4TVhArVkfTHFuC+YOvZuoGM39QJWSmvP05+nmLmg/WHOVzXEknq4IOK+wKpPGALMFUIkLR2+i73 DOXwwEgjA5LEURc6NTY3CKO/hEOsGrClBPEAXP8jj3DiIe5XizMgaX2xMmgPloSQpUmTtkYgqSyK /yIHIgciBxIOGHbiecozHBDJxzzPXbb24znOM5ZrXP/H89uuzY8b/qiMMN8N/RpZxb8qgST5eOEZ mR833y8NRBqYDF1eXkg+kMpQnp83rXxrD3FG+FkyfvXUFzRomS2Xc8tvt5JFq/v5nR+53z751S3S vZ3rfcwGOXFpF0gCXzv9BTd98nTXY4/V3JLrd9VkwwZ/7X787wi1NN7ovC0S5hP559dj3cc3vafp eh68tuu4+uLqB8D99/jn1L/ynqu7LustrX77994Vb7p/Ro53bTov5NY7dWMLruROHjvZvXX+Kxq+ 6SVbuaaiWxgSUsWXj8vWtcIOPVzXzZbNSfLqyUMcksCeB67lOq7RWeOSPi3S3G10jvTJkw7+PexP 9+F172g6v08ANSSChVKob8qYvXT0M5p9neM2dG2XWSRvUb+895P76v7PtF19z99SAa2f+K0LX3WT f5vkOq+zpFt1nzU0ivnw2mkvqr+U+QCo8U/3ARyxP1dt0jPPPOPYEHzllVfWU3kom30/7fSeU045 RffI9OtkE3ok+MuIsRrSQIDoe++9p8rWpPPL8vPhv/7663WTdMCiHKWXurxMOsaG02C4NzkZJjyJ Ct6wITp7bMqxkW7DDTckm+ZB4njGGWfoA45N9B999FHdB/Hf//63puGUHXSk2WSdfviEuou//RGb b/OBGSlyIHIgcmBe4ICBNfoS+g3cWZxdAwRDP+8jPuJ5lhtQrMolv1+Olee7xl/CjHy/heVzawQk KZQXj/1CIBgCx3zXSCWRdIC07UeYleu7VqfvorP46ilZINnr8D6uw8odiU5o1Os/uG8e/dI1Fwnd xgJGfPpn1Hg3+t1Rrkz2gCwXnUkDSCx7I60DkC2zxXKa5fM7PnJjPv7FdRIQBrDyCemYgbg1/gWQ zAK1Sb9NFAD4qibd4IxNXOvFF/Kzue+eHKrgtM0SC7n1T9skJ86/mDx2kvvfuVkgudml/VW66sfj B0i+dEz22L21jlzXtV9psZwkb533ipv0+yQHoF1yg64a99ntHyrITu2TgOCXj82W5/cJ8PnDS8Nz yq7qYpML+7lmss2PEeP54pFP62WfEwCS+TdcHv7ct+77579zrTu1cRucWdlKfehDn7uf/zfStVt+ Udf739mPBP2wKHE+WBvr0gU0ccION/fpp5+eGE4BJK+66iqtmpN62Gy9OoKXnKSDkRAEaAtBGuEc 7chxnhy9d+ihhxKUSoA5gCaELiOAlTp8Yj9LAKWcAZ2c6HT88ccr+DzvvPNUignAvf/++/UI0COO OEKzA5LZ74xTeDBoihQ5EDkQOTA/ccAHZ+b3Xfz+j5UmVIvsh0oRYVUBRz+OskIQadfw3eoyv40F 4cVQyUCSSnyAZ/5iwCR5fHDpX1t5aa7VbS5LsIP3y55RvfkV27h2yy6a8/IDSH5w9Vsi1Wrkdn5s 70TqhgTxhxeHUYwS0jh08CAznOmxx+puZflBr4hE7+/v/nDd+i3veh3WR8P8f0/s/oBaYa93Sl+3 RJ+s5PG3T39JAOCAu3erZEjy3VND3Rd3fewWXnoRt+U12/nF5fgn/jLBvXDEUxq2/T27uwXFoCek WQL8Ht/tfg3e/IptVQLrp3nx6KfdhJ/GuzUPXcd177+CRlmfum+9glvzX+v4ydX/+K73KaD2+/Tl vZ+4bx//qlLafAHb3rGLbLY+W9cUieZjO92ryTcVULzoCh3yZXUfXvu2G/nq967Dqp0qfQSQCSD5 tfxaLdbabX3LTloO8+Hp/bPzYbP/ZOeDX0G++eCnqSs/8xlp4/Dhw1WixzF+RhxNyRF5EICSIzEL IQx29t9/f03K+ee+xbnlBxx++eWXesTmQQcdZMGVXM4j5xhKiOUSW7qulFACAJJHHXWURtEPJJJ3 3HGH7sbA2a/XXHONW2uttZI+WRtOPvlkt846ledaWh0xLHIgciByoKFzIARmdu27+MOfgT7fxR/+ yJcvzOLCsrmGQtcP0wQF/CsJSFJuGsCzsELAJGnTQKSFW1l27ddpfnMVSO7zMJduk8v6u/Yr5gKT ka997z646i21xN7lsX2Fc86xZPr2Ra9pnmW3WdEtP6CHa9WxdQIy/3vCs+7vYX+p9G7lPXtqutfP fNGN/fw3AZLLubWOWE/Dkn8Zp+AIXUaWqLusmwUBf379eyIt3e6uXXMAFXm/eeRL9+V9n7iFuy7i +l07ICku9AAkhxz2pAZvf98elZZ4iQBIPrbLfZpmi6sAklndNA2Qfy8eNdghgV1z4Dpu2a1X1OA3 znzJ/f75GNd18+Vc76Nz+wTge3xnAZJBn3R8p0uHCySMmXyi3Ed3uEeDNr1s60rj5af9+MZ33fcv DHPteyzmNr2kvx+lfkAt0uaFllzYbXXDDhqm82Hf7HxIKz9tPlQquI4CWDLebbfdtHSOpTO9RAIA YugRQhY3cODAgqR3AEikiZwTniZxPPPMMxVI7r777noGtVaS8o+zmpGGQiyH5zt+MsxKubT/Ljl7 nW29AJKAYc6YR+oKWRsA0n36VP4QC8uM15EDkQORA/MCBwysWV/s2nfxp/18EEl8CBj9eIuzdL6b VjbtIdx3Q79GVvOvKCBJWQA7cw3s2bUBSAu36zTAaGEGFP20lj+fa/WZO1W2yHlqn4e4VBBnOo3k h7597Ev3+d0f67LyNhVSqw+ueVuWlIe7xVZd3G1yUT9N5/97aq8H3VTRtVt5j55ulb2zQBKp5o+v jHCd117SbXjWZn5yNZqxNrBEbUAS3cZnD3pU02551XZuEZGW+oRUdMTz37q2IpHsd/32flSOHyD5 /MAnNGyH+/fMCyQf3Tkr6dvyaqkrAJIvHAmQHOd6DezjAM/QR6ID+f1Lw9xiqwkfZAnaJ7ZUevqA rGTP75OfphQ/QPKR7e/WrJsBJIMleL/Mbx79wn1xzycqcdz29l38KPW/L2MyUsZk8TWXcBudu4WG 6XzYt2I+nLJxouNqmdPmg8XhMhfHjh2bBLGcgF5KbRBAcpddKvcjX9mAunXXXTdftIYzzwGnADn0 FvfdVz6WAkJ3ke0ikBz6UtAgmW75s88++2jwhRdeWBCIJTH1o5Zyzz33JECSc+ABkgBIyNqQ1idU W2wPTdICRn2QTVikyIHIgciBhsYBA2p+uy3Md/Hn+4VgkXQGGs21sDQ3X7mEQ+ZaG8NrC8/n1ghI Umg+sBcCQ/8av39NGeF1vnKtTt8tH1fmnhTgB3XdrLvrc/xG6rd/r5z4vPtj6O9u8V5LOAw2oLfF SOPnt0e5zr2XFCOTzS2pumM++sW9cdZL6l95r56JEcfXD3/uvrj7E7XW3uHBPXUPSMv4w4vD3QfX vKWX6EJ2Wa+r+ukXUr2ZU2dqOZRnBKB65sBH3RQBm21FIrnVjVmJmsX7LkDyuUMe16AdH9orL5B8 pELSh3QzBK1DDn9SDXvQI11u26xB0vCnv3Yf3/y+SmJZeve3O/ruqa/dp7e8r3X6ffLbVaqfpW22 7wGQL9FnqbzF/PTmSPfOJa9pfL8btneLePqUbGs0WCSPSCCX3XZFt9bhWcAFkCx2PvgNABC9/362 34RjdYxuYW3RqFGjUotiuds3tsHAp2PHjnk38bZCaOv555+vl4A0lpxDYsncgOTee+8dRudcA0Qx 5Nliiy1U5zInMs8FhjkA2XvvvVd1JF9//XWHcQ3HoWKcA1kbkFCG4BiejBw5UtPxb6WVVlKjnSQg eiIHIgciBxo4B3yAZn7fxZ/284Ek8SF4TIu3cizOrs2Flfh9Vy+8cLuuzq0WSFIAoM7I/L5rfgOD XNvPwtLcMIw8Fmb5fdfaQpgRfjbtfnL3rG4gp8wAFs1q+qc3fnBvX/K6dMKpsYZJKz8XvUR06zjp Zetbdxar6TZa5ISf/3Fvnv2ym/jrBL1GGrnqvmuqv+xvkdCJLiYAhqVwABnEVjavnPicmyTWwxBG IVYP1x/f+J4bJoCtuWy0vdl/tpZl2LYEu6EPAkw/Vj+Wy/1v2lH9af8mjp7gnj34MY3a6RGAZPNK ybAQf2RAVtKHdBNdUZ+eHwiQHOcwxDEgyZ6Zg/d9RC3fO6zS0W149mauWZvmqgv6uix72/Y6YZ/8 ckvxW1s69+4ifFxXjWnSyqFPTx/wqCsX3i+2WifXV6zlmzRvqkk/EZD73RNDVVWhvyxrt+2WNdrR +bDHA5oGnddC5oNfN0ASYxEj9uqqTSBp5Ybu119/7U444QQNvuGGG9wyYp1t9Pjjj6vEr1+/folx DnEffvihgk+AH1K8QYMGpVpkAzDRfwREVgckX3jhBXfttdfqwwodSOo04n779NNP3ZAhQ1Q/ku0n oB133FGBJAY2bO/z2muvucsvv1yB5DnnnKNprA1IJjlH3ieAJEd9GfXo0SMCSWNGdCMHIgcaNAcM sFkn/OsQ2Nm17xoYNJc4/Hadz/XLCP20hTDfDf0aWcC/ooEkZRqQww39FmauAcN8LuksLvRbGeaG dVv/ysZNcU9UGJkQtkCTxm7R5dvrpt8Yx5C/3XLt3VbXi8Qvyzc1Onn+8KdErzB7Wkr7Hh31mMM/ v8kuabLJ9fQp09wq+6zpVtsvCyQp+xNZiv72ya/wKiBEgvf38D91w2wkjNCGZ22eWEVzPfn3iarf yMbaTZo1FeOS9rpsPv7Hv4lWwnJ560E72aWW98pJz8++Fukdy9LQIt0WVX1PvZCJYLqVgK6Ht71T g9EXpM8+PfevxxVIrn3Uem657XokUeggfnDV/5RPTKxmbVu4cuFpy/atkpNywj4lmUv0fCsA8JOb 301yt+7YxjWSjdo7Clhc++hcidoIsdr+4Or/adrmi7RUK+/JYye6iaP/0TC2OVrv5I2TstjTs9j5 kGQWD8usIZCcE1bGQ4cOdccdd5w25eabb84BkgC75557TuMAb0hJ0ae05WAeJCwhhwDN+oWBC8dp sWydtvRt6XC5H5EeAhihxRdfXHUlWZZn+x5AKwRoBGRD22+/vQLdhx56SIHkq6++qpbp6EKa8Y61 AQllKDXFYt2X1LKVEfukRYociByIHJiXOGDgjT6ZHzf0WxiuAUXfb2HmpsX5ZZjf6uXa/Oqp+Gfh flh1/hoDSSowoIfrX+cDiIWE+2X65Vr5vgtwYPmY2tc/fRMBe+87pIdGLJ2i49e0ZVaSZeG/vPuT e1+Wo8v+nJ22RfuWbr2T+qo1MHtPrrb/molEUvNJJexLyTI3p+BAbEzeW8DPp7d9IPWWub7nbu66 rN9V4+zfP0g6RcI3oQL8EI4lchdp26e3fiDgUIBkhf4mcYBOM0jhOh8tIPtP7/XSwRrNWdkPbX2n Sl+3HrRjJR3J5w55wgFeex+zfiKRtHJHvzNK9mv81I0b8ZdbQDZpX0y2UFrj0N7uZdlOiL0nN5G9 Kzuv1cWS19jFgGeUWGOzfD5+5N+69E+hS8h+kBsHupqE//zWj+59MZia+s9ULpU4D5ytjAD7/v6X Oh92yUqoi5kPVi5LtO+8845dquHLnJBIYuhiey7ecsstrmvXrkkb2HcS/UP2XA1p+eWXV+ngCius EEYl14A4gOF+++2nYDKJyOPhHn3iiScULLJnpE+AWADrIYcckiy7AyQB4OwdiT4pEkn2vQRIsiUQ ZG1AQhkCXtpmm7HzYGTpO+pI+lyP/siByIGGyoE0cGZhvhv6uebng8Xw2o/z/X5e+GbXuHbtuxoo /yzergtxawQkqcAAn++3sNDNByAtnR9vYX655vdd/IBG205mwD27qaTwn5/GSXi5ayebkHMKTT4C fE346R83VcDoQku1dS07yDGKBRDSv3Ej/hQA08gtspxICGWJvBBi8+yJv/zjFpalbH9LnELyzok0 ADyI/swQAPnQNgJMhQbIlkNYRs9VEtw+SaS7k0RftLlsJ7TQUnKSSwrf0ZktdT7M1f5VUzn3BCcb sI8jy+9IJtGj9I8qrKaIkqIxPKJeO00Bvc1SHjb5Kud0HzYw5/6H6BMbkkeKHIgciByY1zjgPzvN 77uhn2t+IUis7try+S685DrN1UAv3q4LcUsCkhTMSy10/TADgqGbBhbTwsKywrr8a4CDGZnscN/u rk2XuQx4lDMN5x8n+SzQODu5/FaPkM3A3738DddYdBL3eHZ/10hUBhoCMR8e3TG7vdD29wKAszqp DaHt82Mb2bbIltHZbBdpJeeHR4ociByIHGjoHDDgFvbDwtNcwuxHPvwhcLT46uKItzJ8vwZWlG1+ S+dfF+KvMZCkkhD0pV2HgJLrfAAyzB/W4V/jRyJpRiY7PLBHBA4wpQj66oHPdAsdNilvv+Jijn0f 2VuSJXekkqsd0Mv1PGjtIkqcu0n1w6LC6CjOh7k7FoXUjm4kFuvQMmJg1L1790KyxTSRA5EDkQMN igMG5KzRdp3mEuaH23VVgNLSpOWjTj/cv7b25Avz49P8JQNJCvMBX3htwNHC7boQN8xj177r+wEO tgS7k2yNwxK1H68X8V9eDnCWNRt/p9GSG3bVM7jRA20oxHx4eNu7tLk7yjZNNh8aSvvnt3byQckP YvncHnbzGx9ifyMHIgcaPgcKfX5ZOnPpuflx7Wfhdl2IG+axa98N/VxDlF8sFQQkKdRAo1+BH2Z+ 38Wfdm3h5lr5du3n8eOsbou362ll09wnN2S3a1n9oLVcc7E6jlQ4BwBeGNtgsT5FDY8yAr4WkS2U OuVsY1R4iXM35XTZ0ijOh7k7BrH2yIHIgciByIHKHAiBml2bSw789guvLZ3Fh66fPs1PGGTlZK+y /9PC/Ph8/loDklRgAM8AoYWF4WnXYZjlTXP9MPw+WTl+WPRHDkQORA5EDkQORA5EDswNDuQDaH64 +dNcwvzwQq7pp5/Orq3/Vp5dh/F+eHX+goEkBaWBND8s9Nu174b+8Nqvx4+zjlhYvmsLj27kQORA 5EDkQORA5EDkQH3jQFUgzuJ8t1g//fXz+Nehn2vI0mevivtfYyBJdT64S/MTZuG+m89fSJnWTSvD rqMbORA5EDkQORA5EDkQOVBfOZAG2izMXNqO367T3KrCLL/vhn6ujawsuy7GLQpIUnA+4OaHp/kt zHd9v1+2hfthoT/tmrBIkQORA5EDkQORA5EDkQP1mQNpwM3CzKX95k9z08L8PFX5iTOycuy6WLdo IEkFPtDzK/TD0/wWls/1y7Y0Vn5115ZuXnUnyibcg/d+SLu369P7pZ61PSf7/uE1b7sv7/vEdd1s ObepnHoTad7hAPcaW/J8+eWXbsyYMXqaDkchslH4RhttVO2JMxMmTNDjGNnSp3Pnzq5nz556zOK8 w6HYk8iByIHIgZpzIA3A+WHmz+fSgkLi/HRprbYy0uIKCSsJSFJwCOyssjDcvza/uX45aWF+vJWf L8yPD/1+2WFcQ7n+Z+R42SvzLm3uvm8eOtct09/7z5vuy3sAksu6La7ado6w8fsh3znO3W7fYzHX 67A+BdVZSp6CCp6HE5166qluyJAhqT3s1KmTO/30092GG26YGs/RiCeddJKbPn16TvzBBx/sjjzy yJyweBE5EDkQOTCvcqAYcBam9a/T/Glh8NHCzTXehtcW7ufxw4r1lwwkqSgfQAvD/etC/Gll+/n8 TuYL99PMC/5Jv010QwY+qV3htJaqjn2cE/3lxBuA5DIikdzi6jkDJD+6/h33yaD3XZf1lnZbD9qp oG6WkqeggufhRMcff7x79dVXXY8ePVy3bt1cq1at3Mcff+yGDRumvW7WrJmewR0eY8j55IBFjjxc aqml9IQa8nzyySea77DDDnMDBw6chzkXuxY5EDkQOVA9B/IBu7RwP6xYPy3x8/gtyxfupynUXyMg SSX5gFxauB+Wz5+vTD99IZ0rNn0hZcY0szkAkPzibgGSmy/rtrx6u9kRdegDFH58cxZIbnNL4UCy 2Dx12IUGUfTXX3/tkDy2a9cup70cY7j//vtr2C677OLOOuusnPiDDjrIffjhh7oE/tBDD7k2bdro 8+GYY45xSCoBpADUFi3iPq85jIsXkQORA/M0BwoFbWnpwjD/2vfDwOqujclhOgsv1a0xkKTifKCt 0PAwXXhtncsX/su7P7lZ02e5tsu2cz+8MMzNmDbDddtiObdIt0Xdj68M1+P+2nZt55bfvoecF93I ilN3wujx7tcPRjskftMmTXOLdF3EtVuuveuwWifXqHFuWss4beJU9/unY5yT6CU36OpmzZzlxn42 xv387ihN0nG1xd1SGy4jo2o5su4/P0ld7//sxo8aJ0cRdnBL9FlKI1i2btpqQdd+pQ45GaZPmeb+ /PqPnDAuOq3ROfVsbCfHn//81kgZEEmzVmc3c+pMN+aj0e73L8a4lh1aS1uXVp5UKrCEgHcuEyB5 18eu2+bLuU0u3cqN+XC0++3TX1R3s1PPzq6jtDEfwb8xH//i/vx2rIzbTLdI9/au05qdXetObSpl +fPrsa5MN0l37rvBQ90IWd6Gd+sck7u02qlXZ+UhBZSSx6+40PZN/HWCGz/ib9e6Sxs3cfQE9+uH P+sRk922XM5N+n2i++Gl4W5G+Qxd/m+/Qu7YWn1//vmnGzdunF26rl271utzpnfffXc3dOhQt8oq qzjAotGvv/7q+vXrp8+Ciy++2G23XfbjgiXunXfe2f3www+a1I+zvBMnTlSdSo7+Wn/99VWi+dln n7n33ntPk6y66qq6lB4+/DgN5/PPP3ffffedGz16tALY1VZbza200kpWtLroeY4YMcItscQSmu6j jz5yK6ywgttyyy3d77//7l566SU3depUt+mmm2p4TuaKi4Y2Tml9iGGRA5ED9ZcD4fPNWpoWHoaF 1+RNC6uqTIsrxa0VIEnF+UCeNSotPi2surLS8ty+5rVuetl0ATHN3NQJU7VK/Etv2t0Ne+pra4Jb addVXd/ztkyun5el4p/eyL7gksAKz+K9uqjuX8sOrcIoBUGD98m+RPd55RD3xB4PuCl/TM5Jt9YR 67q1jlwvCRv29Nfu9TNeUuBkgc3bNnfdt17RDZWzrhcVoLHr/7d3HuBVVdkeXwgBDIQWiqAYCUUN CIJ0UMIQJZQBpEooUmaeb2DU4T35xvdsiGVERSlKkY4CgrRAcERQkdBBBCwgGIJAAEGqQJAis//r Zl/PvWn3JhdI+a/v8562zz77/G4k/6y119qL+9pLuj289ZBJsJnjcQ4H/dYNkqKlU3t1rvx2WSbd O1rbR77SWta9tkogiqwVLFJIot5oK1WMyM6urRuxSoXkbU3C9BlHvz3i0SVY3/98VCrhfmTbIVn5 P3Fy9vCvHu2xBGPz51rJXZ1reZyP++tCObgm0eNcWged58VI+Xsq6qWs3GP79Gd826duEXhmg24O 0p8/20d49J1y5KuD7p+JoOAg6bKgt+CPGW+DEIIIsta8eXMpWbKkPcxxW4Sm4+PjVTS+9dZb7vF9 9NFHMmzYMD3+8ssvBck5sAkTJsjYsWN1Hx/t27eXESNGuI+xg7B5376un/0VK1ZIz549BcLNaYMG DZLBgwe7Tx05ckSefvpp9YC6T6bsxMTEyNChQ91JQdOmTZM333xTPaHJycnu5hC+eLZ9VnBwsOA9 IOa9Lbd9T97j5zEJkEDOJZAV0ZfePemdt2+f2XXbzp9twIQkHpqWyPMeTEZtMrqWUf9T6rqEZDHj 0YI3aNeCb+XSuYv66NuahUlQcGFJXLFHCplf+P03DpaChQvqtXkdZ8rpfSclrGW4hNYoKzeXCZYz B0/LrvnfyIVTFyTErNkd8+8Bqbx/h41IiO01V/soV7uCHNvxs1RqdJuUrlZWfjuVLPtX75OIHrWl 8VMPaBtn+9LmOdXb3aXez+/nbNMtGpUxQrJ7rKeQPGs8Xt988LX2gWUMf1j0ne73W5+BkKzjEpJo GFK5lHnWnXJizy/y0xd75ervV6VYpRLSa8XAdL2t+gAfPlRITvvK3bKaeafy99xiRPZBw/pHPX/f oMbS4Ilm7jYQ27MfnKxeOgj0u7rUkkJFgyTh091y3HgeYW3GP6zfh71pz9Kdcsp8R7CkjfvlyJYk KX5rSbmzU4Rtotuaj9QxXleX6M/KPejE3/GpkDSeWRje/9zRX41nNkmPi5QsqmP8cdkPZtnJc9Lg yWZpJgjlFoFy6tQpWbZsmbz66qv6//moUaPUo6cvaz7Gjx+vgrFcuXICIQlD5nfHjh31L+OqVasK QuZNmjSRKVOm6HX7ATHXp08fPYT3EdniDRs2lGrVqgmeC+HavXt3wdxN2NmzZ6Vdu3Zy7Ngxgfjr 1q2beht37dolixcv1nW7+/Xrp0k/aA8h+cYbb2BX7zt69KhbgEK0Y4wff/yxCsonnngizXmcueV7 0pfkBwmQQK4jkJnAy+h6RtcsCF/a2Lb+bgMqJPHwzMSgc4CZtc3suu1rsvHCYX1lJGCEtQiX9eaX +7apmyU4tJg8uvZv2mx6k3GSfPK8ev3K3lVez+1dsVsqNaicKgP6J+Ol/Pixhdqm3aQurjC1fZjZ QiwtTinFU7BwIWk9toM+1za5YMQkyvWUq1lBTy37r4VGXO41IdxQ6Ty3lxQuXljPIxS8qKfL4xha wwjJJa75Z7Yf5/ZU4kmZ08b1C7j/+sHpeiTfqzNKbwsxgrHbIlMmyAga2IF1+yRuwHzdf/jDGEH4 OTsGb+f26Vu0i/seaywNhzR3d7f6hRXy3dztUiSkiPRZ9Zg75Lzu1S9k+8yvzPsXMWPrIyWM0IVd Nt7k2L7z5Og3h5VZ1wUuUeHuMGUHJYe2jF+v63+3n9LV+3Kax/7c4+/4tk/ZIuveWCXla90iXeb3 1j8KpjYcq4L9gWEPCsTtt7O2SfxLK81c0uoS/U7HVGPMyQJl/fr1MnXqVBVzO3fuVIGGF0BI+PXX X3d7/HBu+PDhGuqGYFy6dClOSf/+/WXjxo2COZIIL8+dO1fF4ZIlS/S6/XAKycKFC8uYMWO0zJC9 DjGZlJQkNWvW1FMQhRCHJUqU0D7DwsJsU5kzZ4689NJLUrBgQYmLixNcwzvAI4n74XGEEG3cuLG+ zwsvvCAI18+ePVtefvlladWqlYcH1Xack78nO0ZuSYAE8g4BX4RfoNpkl1rAhSQG5KsAdA4+K/fY +yEkLyZflJ7Ge1iqShn3L2+EpzvNekSbLej6gSD8ioxniMeM7PfLv8uMZuPkwukL8sCLD0lN4110 mlNI3tu/gTT5ZwvnZY99hNwn13V5CVsMby0R3e/xuA5Biv4CLSSbDo2UOgPrezxrasN3TOj/gibH VDXhV9iVi1fwhXm0S++ggJlfaueNWiF5U1BBeTT+vz3E+JkDp2TWQ5NNvyLR73Yymd3VtMv3Iyfq XNRaMXVN2LuVx2MSPvlBPv2HS4BgukCI8Tp6mz+i0N7rzz3+js8KSXiYo0a210dOa/yu8WYny5+n dROE/e0fJbc2rCwdZvaww3JvMb8PIstagwYNNCnFHmdni+zpy5cv+9wFsrGdtnDhQnn22Wedp6RF ixYCb6R3W4hFzDVEzUiIstjYWEEZIcxFnD9/vowePVomT54spUuXlrVr13r06RSSTk+iR6OUA/w7 Ua9ePZ3TiP6tJ9O2xVzHyMhIrX2JsSPMbYVk27ZtVVCibdOmTVUg4xpEJbyoyCoH/xkzZtju3Ntr +T25H8IdEiCBPE/AF/GXEQR/7venbUbPzOzaNRGSaT00q0LRl/vUI2kEG7xfxSuGyK6F38oX//eJ y3M11eW5WhzjEmxtJjwsd7Ss6h7i0R1HZKcJhf9qxM+5n8/K75eNsDKGRAqIrMZP3S91/9rI3R47 SGCxHsmuC/u4PY8ejVIOTv54XD5sN02PesT100QeZzvMsds2ebNLSC591HnJY189ktFT9Fz/DRl4 JGu7PJLtJqf2pH4YPVVOJp6QB4Ybb1mPOvp+793ztsdzMjqI6FZbWrzsmmO61ngkd0zbImXvLC8o kO5tM5pPMKHis9Ls2T9J7T71NCEJz7p65aopF/RnqdbGJWTtfQj/zmg2Xg9V7Bvh5W2bRq+Rr8Zt 8Phevdt4H/t6DxKm/B3ftimb1ft9d5d7JPLV1vro91u+J5iSoF5fk3CERLAl/eZJuYgK0tV4Ya+n YQ7jpEmTfH7kqlWrpEKFCu72ELhIrLlw4YIkJiaqNw/hZBQmHzlypCAMbQ1hZ4SHkYSDZ0K0oTA5 PIRoB48gQtoIfa9evdreplskv1hBCNFpPY8ejVIOkNQDryEsNDRUhanz3wjsw3sJQYlw+IsvvqhC El7Mzp07yyuvvKL3IrEG74fxQfwisQceVJQ8WrBggbbhBwmQAAlcbwKBEH+B6MOf975uQtI5KOc/ /M7zWd2fZMK58PwhCSW4bDHZHfu9rBy6TAWjrTcY++hc/aUe/U4nnUeJZ616/lP5/sPt7scWuKmA mbNXSI/RHzxqDUzCjHOeHy5CSC6KmaPtBm5+3B0+1hNeH/tXJ0rcX1wh5QEb/54qJI26iBtGrtZk mx5L+3nd/cchhOTs1sbLZyytfnAeyTYTU4Rht4V9pVytP0QBrn/Yfpqc2P2LPPBClNTqVVeF5MRa b+GSTxbRvbZEvuwSTGv/ZcLURkhWbnaHet+8O4B4xtzMewc2kKb/jNRQ//stJ2qzTrN6Gq/wbR63 YP7mhIiRGhZuNaKt3PmwK4zpbLRp1BrZMs6EtpubZ07t5ryU7r6v92Aqgr/jwx8A615fJTV73ist XnxQx/BB1CQ5Y7LzLX/7s4Jkqoy+33RfIBsXIPb8EZLwyjmFpPejz507p2FgZEDD0wivozXMnZw5 c6bWj6xfv77Am4lSQfAawlAqaN68eZpRvWjRInubbiEke/furfubNm3SkLVHA8cBalUOGDBAzxQq VEjwX3rWpk0bQZY4BCyE5COPPOJOCEJ4fv/+/SoaIVztGLzfK72+eZ4ESIAEchKB6y0ene9+Q4Sk cwCBEJWphKTJkF75VMZCEsk3/x68WIcCUVWnX30pcVtJd2LN/K7vC7yVmQnJQbuHOl8n1T7K3Czq OVvP94XH1MxddNqWd9cLvGaZCQ2/haSZH2nnaNrneQtJnEd5Gl/tpqA/QttWSN7aqLKZLuCaPuDs Z05b4/003tj6g5pIw38010SW6Wa6AKzD9O5aVNzZHmWAJtR0idqHRnWQam09PZZo66sodPbr6z1I tPF3fGkJyVkmmei0Ke+UE4QkQtveK8w42XjvFy3qmk/rfd55jPmPyIiGwbNYvrxrvvHEiRPl7bf/ 8G6j1A7mKNqakY8//rggIxsr4niLWyvi0CcSZjIyFDdHuBqG5B/MyczM0hKSyNhGMhC8jxSSmRHk dRIggZxI4EaKRyePGy4knYNx7vsjMLMiJD83oe9dC77RWo4d05i7hvmEmOtWf3BTaWgybp1mvUw4 l5mQRLh8xv2ukO3Ds3tKxfqenrhVzy6X7+ftuGFC0vle/uxbIVmqSmmJWf6XVLdOaTBWfjNzTFu+ Eq1ll+DdnVj7bfWa/um1NqnK/PyadNp4BN/Tfrp81Fsq1HGV8nF27KsozNI9WRhfIIQkEklQR9Fa xYoVM/Sy2XY3aov5jSg8DkMYGqFsGBJosDSiNcyHRCkja9hHmR2Em5GY4zR/hCRqbiLzG4a5jI0a NXJ2leZ+IIQkvLH4rqyhvJH3PFF7jVsSIAESyA6BnCIQfX2HHCskfX0BtJtk5gVqaNuUxdHQNjyS /5vikUxZASW2b0po2yR/oETQ8r/HSsLy3a7wt9cqKRqOHugKR6MWZJpCMiXbetCejD2SCNlqxviJ 864QqJmfaM2V1DNeks019UjG9bOXUm3VI4kEFmMDNqUOkeO8hrZrubxCqEmZyiOJcDNC28NcoW3c k1VTIWnqKMJiPh2oSU62ryNbk2RhD5cXtpMRzzaMPQdzNBOOax3LNuM62ea6RZh8rcnqRhF3ZKXf HBrscR0HmJOIJJ+yZr6hd6mkVI1TTvhzj7/jUyE5IiW0nfK9zopK8UjCI2ymFugfHeZnJb3vF4W3 nXUk4bHLyXUk4XVEbUjYmjVrdM4j9jEfEsXEL168qAIS4s0a5llifiIM550CE+cgJHv16oVdLS6u Oxl84H7M1cTqOnbOYwbN9ZnIMkdoG3MmYQhtwyOJELz1SGIMCG17Z5Wj/Z49ezzGhoSfSpWyV/kA /dJIgARIILcTyLdCcsPIeNk6YYNmIfdcPlBKhpXS7/Lk3hPysSnXg/AkLLtCEn18NX6DbHwrXotz t3q9rVRvf7cm9Xz5/ArZaWpWwtITGnrRfORkIXm7KbkEYYj6nFiNJ27gAhVQKHeETHq7ws8Oszb3 mpc+0+kDrcd0dM9VBfPY3nM1OSf8oRom07ujfW2P7V4j/D8xfwBgLquWXIqs6q4J6tHQceDPPf6O Ly8KSSSqPPPMMyrSoqKixIa7ESZHGHjYsGG68gySUrznOg4ZMkQTbnAPyuzUqFFDUAAcBcZRPgjL LmKpRKxg4zR/hSTmWj733HNa4gfCEHUkrSGSgXmUWHUHnk9kiUO8UkhaQtySAAmQQGAJ5FshCc8Y CpLDiwehc0vdW1WU/GxWXoFhKUUsmRgIIYnVZVAv8vgPx7RvrLqDjHDMTyxWobhmi3sLSQiy2D6u oue46XLyZU1ewT7qYN5U2PXLGC5w1DCE3SiPJJ6N5Q0hHI8bjyeytcG09egOUtWRnY3xzWk7TZNR IAbLmfqLhYoUNGWZftZakigY3+WjXiqq0ae3wes823j8zh01/RvDijF2zmnrMR1SZcSjjT/3+Du+ vCgkkZ0dHR0NdCr4kHxTvHhxQbY0wrswhHRR4seGtfWk+UASDrKvT5w4offCu4eEFtyHuo7IIrd9 23uw9VdIYmlEJNygziUMWeRVqlTRTO2EhAT3SjVIHoJ4DYSQxNxNvJ81eiQtCW5JgATyO4G8ISRR kNysZINVa7A6zZ64nbJiSJyucdzWlPuBLXl0nhxc95OunFIlqpqe2/d5gnxpMrcxj9EahB28hsim RnuEtZ1LHaKdJtCYZREhljKbI2n7xfhWD/9MDsQnauJJSbOmN+oPomA4QroVTIFwiChrWOpxyn1j 7GG6Wwiyv/3wlF6HONUsbDPfD8XNy97tSoSwN89tP13FbAuU/zGZxtkxrGwDIVW1dQ0JNsy+M4W3 UUIHhoLrLf8VLbZWpfM5mDf5xf9/IntNshPmTVqDkH7w7fZpikHbBlusRLTdrPGdYNbcxhxWTB2A oQwTVtZJy/y5x5/xYWUbhPiRrIXpArDZZvoBvMfdYw3/iPLunxV8F2kVnN+xY4eKLTtu1GkMCQmx h9d9CxGI+oubN2/WcLX3AFCjEaV+4G1MyyDknnzySQ0F2+uYT4jC3wgnp2VIoIHXEn8UZZZsY++H mJw+fbqMGzfOY44priMBCN5UzNlEsg+Kl7/22muapINxwJBss2/fPvWqwrtqx4B1urE6jrdBtB4/ flxPQxSjfBDnSHpT4jEJkEB+JJAnhGR2vjiIr1MmtIp5iqXCy6hnLTv9+XIvPJG2zJCda4hwN4RU bjV4UI99d1TXOy9TvayGnzN6F3gKTxgP7ZVLvxtPZhn9AyCj9tf7Wk4f37XmgVA25m5CPJ0/f17K lCmjpX3gnfTFIEh3796tSxfCY3gtDfUgMd8RAg/JSsgYD+RkdbBYvny5e2Wf8PBwrTd5Ld+JfZMA CZBAbiGQ74Xk9fqiUIi7QEHjwnQYPHgI1WJ970ZD7hesTU0jARLIWQSQbY6C5TDUrYQ3Eks50kiA BEiABExw1kxOdwQYieRaEcDSeVhRB2H1EreX0vD21+9tkgNr92l4G8sC2nWxr9UY2C8JkID/BBCu R7IQrHr16prZ7X8vvIMESIAE8iYBCsnr9L1i+b20in8XLVVUUFfxjpT1qK/TcPgYEiABHwlgPibC 2zB4JAMZNvdxCGxGAiRAAjmWAIXkdfpqDm0+KIc27jdlhU5pkkhwuWKa5VyjQ4Rgn0YCJEACJEAC JEACuY0AhWRu+8Y4XhIgARIgARIgARLIIQQoJHPIF8FhkAAJkAAJkAAJkEBuI5BlIYlCw5cuXdKV L1CrDStIcO5Qbvv6OV4SIAESIAESIAESyDqBLAvJzz77TJc/s49GfTmsgYvJ6DQSIAESIAESIAES IIG8TyDLQnLv3r269BkKFp8961oZBkuioTwGjQRIgARIgARIgARIIO8TyLKQtGhQGmPlypVy8eJF qVSpkmANWhoJkAAJkAAJkAAJkEDeJ5BtIQlE69atEyyJhmXUmjZtmvep8Q1JgARIgARIgARIgAQC s7LNxo0b5dixYxSS/IEiARIgARIgARIggXxEICAeSQrJfPQTw1clARIgARIgARIggRQCARWSyNyO jIwkXBIgARIgARIgARIggXxAICBC8uuvv5akpCTF1apVK0FdSRoJkAAJkAAJkAAJkEDeJhAQIZmQ kCA7d+5UUrfffrtERESwnmTe/rnh25EACZAACZAACZBAYJJtrly5Itu3b5fDhw/L1atXFWuRIkV0 tZv69esTMwmQAAmQAAmQAAmQQB4kEBCPJLgkJiYKipQnJye7MWHZxGbNmrmPuUMCJEACJEACJEAC JJB3CARESB46dEi2bt2qVIoVK6ah7ZCQEAkKCtL/8g4uvgkJkAAJkAAJkAAJkIAlEBAhibD2gQMH tM8mTZpIaGio7Z9bEiABEiABEiABEiCBPEogIELS1pHEvMioqCgpUKBAHsXF1yIBEiABEiABEiAB ErAEAiokuUSixcotCZAACZAACZAACeR9AhSSef875huSAAmQAAmQAAmQwDUhEBAhGR8fL6dPn9a5 kZgjSSMBEiABEiABEiABEsj7BLItJH/55RfBHEnUj6xcubLUqVMn71PjG5IACZAACZAACZAACWS9 IDm8kGfOnHEXIAfLevXqSaVKlYiVBEiABEiABEiABEggHxDIskfy888/l/Pnz2uGdnBwsISFhUl4 eHg+QMZXJAESIAESIAESIAESAIEsC8lLly4pQRQdp5EACZAACZAACZAACeQ/AlkWkvkPFd+YBEiA BEiABEiABEjASYBC0kmD+yRAAiRAAiRAAiRAAj4ToJD0GRUbkgAJkAAJkAAJkAAJOAlQSDppcJ8E SIAESIAESIAESMBnAhSSPqNiQxIgARIgARIgARIgAScBCkknDe6TAAmQAAmQAAmQAAn4TIBC0mdU bEgCJEACJEACJEACJOAkQCHppMF9EiABEiABEiABEiABnwlQSPqMig1JgARIgARIgARIgAScBCgk nTS4TwIkQAIkQAIkQAIk4DOB/wC5MOgAz7H2rAAAAABJRU5ErkJggg== 446599 2021-12-09 13:22:36 -0800 2021-12-10 08:20:13 -0800 Patch 1.1 bug-233372-20211209222235.patch text/plain 5496 rcaliman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi SW5zcGVjdG9yVUkvQ2hhbmdlTG9nCmluZGV4IDA2OTJiNDQ5YjhmZmNhNTQ1NjlkMDkxNmY5Zjkx NTQ0NjlmMjFjNGQuLjcxMzk0ZWE1ODdjZTllYWEyMzA2MmU4OTcxZmE0MDRhZjk3NWRmY2MgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl Ykluc3BlY3RvclVJL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDIxLTEyLTA5ICBSYXp2 YW4gQ2FsaW1hbiAgPHJjYWxpbWFuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWIgSW5zcGVjdG9y OiBBZGQgQ1NTIHZhcmlhYmxlIG5hbWVzIHRvIHByb3BlcnR5IG5hbWUgY29tcGxldGlvbiBsaXN0 CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzMzNzIK KyAgICAgICAgPHJkYXI6Ly84MzIwNTk2OD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGQgdGhlIGxpc3Qgb2YgYXBwbGljYWJsZSBDU1MgdmFyaWFi bGVzIHRvIHRoZSBsaXN0IG9mIENTUyBwcm9wZXJ0eSBuYW1lIGNvbXBsZXRpb25zLgorCisgICAg ICAgIGBXSS5DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9uc2AgaXMgYSBsb25nLWxpdmVkIG9iamVj dCB0aGF0IGhvbGRzIGFsbCBzdXBwb3J0ZWQgcHJvcGVydHkgbmFtZXMuCisgICAgICAgIEl0IGRv ZXNuJ3QgbmVlZCB0byBjaGFuZ2Ugb3ZlciB0aW1lIGluIGEgV2ViIEluc3BlY3RvciBzZXNzaW9u LiBCdXQgdGhlIGxpc3Qgb2YgYXBwbGljYWJsZQorICAgICAgICBDU1MgdmFyaWFibGVzIGRlcGVu ZHMgb24gdGhlIHNlbGVjdGVkIG5vZGUuCisKKyAgICAgICAgVG8gYXZvaWQgdGhyYXNoaW5nIHRo ZSBsb25nIGxpc3Qgb2YgdmFsdWVzIGluIGBXSS5DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9uc2Ag d2UgZG9uJ3QgcHJvYWN0aXZlbHkgY29sbGVjdAorICAgICAgICBDU1MgdmFyaWFibGVzLiBJbnN0 ZWFkLCB3ZSBpbnRyb2R1Y2UgYSBmbGFnIHRvIGluZGljYXRlIHRoYXQgdGhlIGxpc3Qgb2YgQ1NT IHZhcmlhYmxlcyBtYXkKKyAgICAgICAgYmUgc3RhbGUgd2hlbmV2ZXIgdGhlIGluc3BlY3RlZCBu b2RlIGNoYW5nZXMuIE9ubHkgd2hlbiBhIHF1ZXJ5IGNvbXBsZXRpb25zIGNvbWVzIGluIGRvIHdl IGNoZWNrCisgICAgICAgIHRoaXMgZmxhZyBhbmQgYXVnbWVudCB0aGUgbGlzdCBvZiBDU1MgcHJv cGVydHkgbmFtZXMgd2l0aCB0aGUgbGF0ZXN0IGxpc3Qgb2YgQ1NTIHZhcmlhYmxlcy4KKworICAg ICAgICAqIFVzZXJJbnRlcmZhY2UvTW9kZWxzL0NTU0NvbXBsZXRpb25zLmpzOgorICAgICAgICAo V0kuQ1NTQ29tcGxldGlvbnMucHJvdG90eXBlLnNldCB2YWx1ZXMpOgorICAgICAgICBBbGxvdyBh IHN1Yi1jbGFzcyB0byByZXBsYWNlIHRoZSBsaXN0IG9mIHZhbHVlcyBpbiBvbmUgZ28uCisgICAg ICAgIElmIGEgYFdJLkNTU1F1ZXJ5Q29udHJvbGxlcmAgd2FzIHVzZWQsIHJlc2V0IGl0IGFuZCBw cm92aWRlIGl0IHRoZSBuZXcgbGlzdCBvZiB2YWx1ZXMuCisKKyAgICAgICAgKiBVc2VySW50ZXJm YWNlL01vZGVscy9DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9ucy5qczoKKyAgICAgICAgKFdJLkNT U1Byb3BlcnR5TmFtZUNvbXBsZXRpb25zKToKKyAgICAgICAgKFdJLkNTU1Byb3BlcnR5TmFtZUNv bXBsZXRpb25zLnByb3RvdHlwZS5leGVjdXRlUXVlcnkpOgorICAgICAgICAoV0kuQ1NTUHJvcGVy dHlOYW1lQ29tcGxldGlvbnMucHJvdG90eXBlLnN0YXJ0c1dpdGgpOgorICAgICAgICAoV0kuQ1NT UHJvcGVydHlOYW1lQ29tcGxldGlvbnMucHJvdG90eXBlLl91cGRhdGVWYWx1ZXNXaXRoTGF0ZXN0 Q1NTVmFyaWFibGVzKToKKyAgICAgICAgSG9sZGluZyBhIGNvcHkgb2YgdGhlIG9yaWdpbmFsIGxp c3Qgb2YgQ1NTIHByb3BlcnR5IG5hbWVzIGluIG9yZGVyIHRvIGNyZWF0ZSBhIG5ldyBsaXN0Cisg ICAgICAgIGFndW1lbnRlZCB3aXRoIHZhcmlhYmxlcyBvbiBkZW1hbmQuCisKKyAgICAgICAgKFdJ LkNTU1Byb3BlcnR5TmFtZUNvbXBsZXRpb25zLnByb3RvdHlwZS5faGFuZGxlSW5zcGVjdGVkTm9k ZUNoYW5nZWQpOgorICAgICAgICBDb25zaWRlciBjaGFuZ2luZyBvZiB0aGUgaW5zcGVjdGVkIG5v ZGUgYXMgYW4gaW5kaWNhdG9yIHRoYXQgdGhlIGxpc3Qgb2YgdmFyaWFibGVzIGlzIHN0YWxlLgor ICAgICAgICBUaGF0IG1heSBub3QgbmVjZXNzYXJpbHkgYmUgdHJ1ZSBmb3Igd2ViIHBhZ2VzIHdp dGggYWxsIENTUyB2YXJpYWJsZXMgZGVjbGFyZWQgb24gOnJvb3Qgb3IgPGh0bWw+LAorICAgICAg ICBidXQgaXRlcmF0aW5nIG92ZXIgdGhlbSB0byB2ZXJpZnkgaXMgbmVlZGxlc3NseSBleHBlbnNp dmUgZXNwZWNpYWxseSBpZiBjb21wbGV0aW9ucyB3ZXJlIG5vdCBldmVuIHJlcXVlc3RlZC4KKwog MjAyMS0xMi0wOCAgUmF6dmFuIENhbGltYW4gIDxyY2FsaW1hbkBhcHBsZS5jb20+CiAKICAgICAg ICAgV2ViIEluc3BlY3RvcjogRXh0cmFjdCBhIHNwZWNpYWxpemVkIENTU05hbWVDb21wbGV0aW9u cyBmcm9tIENTU0NvbXBsZXRpb25zCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkv VXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTQ29tcGxldGlvbnMuanMgYi9Tb3VyY2UvV2ViSW5zcGVj dG9yVUkvVXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTQ29tcGxldGlvbnMuanMKaW5kZXggMmE1Mjgz ZjA1MjdjZGM2YTIwMjAzYmRjNzAxYTg0MjRjMDQyYjhmYS4uODUyMzU3N2NmNzI1MzM2OTIwNDE2 NGRiMmIxYTIxZDIwZTdiZTE3OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1Vz ZXJJbnRlcmZhY2UvTW9kZWxzL0NTU0NvbXBsZXRpb25zLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNw ZWN0b3JVSS9Vc2VySW50ZXJmYWNlL01vZGVscy9DU1NDb21wbGV0aW9ucy5qcwpAQCAtMTM4LDYg KzEzOCwxOCBAQCBXSS5DU1NDb21wbGV0aW9ucyA9IGNsYXNzIENTU0NvbXBsZXRpb25zCiAgICAg ICAgIHJldHVybiB0aGlzLl92YWx1ZXM7CiAgICAgfQogCisgICAgc2V0IHZhbHVlcyh2YWx1ZXMp CisgICAgeworICAgICAgICBjb25zb2xlLmFzc2VydChBcnJheS5pc0FycmF5KHZhbHVlcyksIHZh bHVlcyk7CisgICAgICAgIHRoaXMuX3ZhbHVlcyA9IHZhbHVlczsKKyAgICAgICAgdGhpcy5fdmFs dWVzLnNvcnQoKTsKKworICAgICAgICBpZiAodGhpcy5fcXVlcnlDb250cm9sbGVyKSB7CisgICAg ICAgICAgICB0aGlzLl9xdWVyeUNvbnRyb2xsZXIucmVzZXQoKTsKKyAgICAgICAgICAgIHRoaXMu X3F1ZXJ5Q29udHJvbGxlci5hZGRWYWx1ZXModmFsdWVzKTsKKyAgICAgICAgfQorICAgIH0KKwog ICAgIGFkZFZhbHVlcyh2YWx1ZXMpCiAgICAgewogICAgICAgICBjb25zb2xlLmFzc2VydChBcnJh eS5pc0FycmF5KHZhbHVlcyksIHZhbHVlcyk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVj dG9yVUkvVXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTUHJvcGVydHlOYW1lQ29tcGxldGlvbnMuanMg Yi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTUHJvcGVydHlO YW1lQ29tcGxldGlvbnMuanMKaW5kZXggZTBhMTU3NTZiZmYwZjBkNjdlZjNiNDM0NTY2ZjUwNmQw OTJhMzg0OC4uNDc0OGE5ZTBmNGRjNjU2Y2E5YjBlMjE2ZGY5NDBlNzFhYTA3ZmJlNSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvTW9kZWxzL0NTU1Byb3Bl cnR5TmFtZUNvbXBsZXRpb25zLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50 ZXJmYWNlL01vZGVscy9DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9ucy5qcwpAQCAtNDAsNiArNDAs MTEgQEAgV0kuQ1NTUHJvcGVydHlOYW1lQ29tcGxldGlvbnMgPSBjbGFzcyBDU1NQcm9wZXJ0eU5h bWVDb21wbGV0aW9ucyBleHRlbmRzIFdJLkNTU0MKICAgICAgICAgfQogCiAgICAgICAgIHN1cGVy KHZhbHVlcywge2FjY2VwdEVtcHR5UHJlZml4fSk7CisKKyAgICAgICAgdGhpcy5fY2FjaGVkU29y dGVkUHJvcGVydHlOYW1lcyA9IHRoaXMudmFsdWVzLnNsaWNlKCk7CisgICAgICAgIHRoaXMuX25l ZWRzVmFyaWFibGVzRnJvbUluc3BlY3RlZE5vZGUgPSB0cnVlOworCisgICAgICAgIFdJLmRvbU1h bmFnZXIuYWRkRXZlbnRMaXN0ZW5lcihXSS5ET01NYW5hZ2VyLkV2ZW50Lkluc3BlY3RlZE5vZGVD aGFuZ2VkLCB0aGlzLl9oYW5kbGVJbnNwZWN0ZWROb2RlQ2hhbmdlZCwgdGhpcyk7CiAgICAgfQog CiAgICAgLy8gUHVibGljCkBAIC00OCw0ICs1Myw0MiBAQCBXSS5DU1NQcm9wZXJ0eU5hbWVDb21w bGV0aW9ucyA9IGNsYXNzIENTU1Byb3BlcnR5TmFtZUNvbXBsZXRpb25zIGV4dGVuZHMgV0kuQ1NT QwogICAgIHsKICAgICAgICAgcmV0dXJuIHRoaXMudmFsdWVzLmluY2x1ZGVzKG5hbWUpOwogICAg IH0KKworICAgIGV4ZWN1dGVRdWVyeShxdWVyeSkKKyAgICB7CisgICAgICAgIGlmICh0aGlzLl9u ZWVkc1ZhcmlhYmxlc0Zyb21JbnNwZWN0ZWROb2RlKQorICAgICAgICAgICAgdGhpcy5fdXBkYXRl VmFsdWVzV2l0aExhdGVzdENTU1ZhcmlhYmxlcygpOworCisgICAgICAgIHJldHVybiBzdXBlci5l eGVjdXRlUXVlcnkocXVlcnkpOworICAgIH0KKworICAgIHN0YXJ0c1dpdGgocHJlZml4KQorICAg IHsKKyAgICAgICAgaWYgKHRoaXMuX25lZWRzVmFyaWFibGVzRnJvbUluc3BlY3RlZE5vZGUpCisg ICAgICAgICAgICB0aGlzLl91cGRhdGVWYWx1ZXNXaXRoTGF0ZXN0Q1NTVmFyaWFibGVzKCk7CisK KyAgICAgICAgcmV0dXJuIHN1cGVyLnN0YXJ0c1dpdGgocHJlZml4KTsKKyAgICB9CisKKyAgICAv LyBQcml2YXRlCisKKyAgICBfdXBkYXRlVmFsdWVzV2l0aExhdGVzdENTU1ZhcmlhYmxlcygpCisg ICAgeworICAgICAgICBsZXQgbm9kZVN0eWxlcyA9IFdJLmNzc01hbmFnZXIuc3R5bGVzRm9yTm9k ZShXSS5kb21NYW5hZ2VyLmluc3BlY3RlZE5vZGUpOworICAgICAgICBjb25zb2xlLmFzc2VydChu b2RlU3R5bGVzIGluc3RhbmNlb2YgV0kuRE9NTm9kZVN0eWxlcywgbm9kZVN0eWxlcyk7CisKKyAg ICAgICAgbGV0IHZhcmlhYmxlcyA9IEFycmF5LmZyb20obm9kZVN0eWxlcy5hbGxDU1NWYXJpYWJs ZXMpOworICAgICAgICBjb25zb2xlLmFzc2VydChBcnJheS5pc0FycmF5KHZhcmlhYmxlcyksIHZh cmlhYmxlcyk7CisKKyAgICAgICAgbGV0IHZhbHVlcyA9IHZhcmlhYmxlczsKKyAgICAgICAgdmFs dWVzLnB1c2hBbGwodGhpcy5fY2FjaGVkU29ydGVkUHJvcGVydHlOYW1lcyk7CisKKyAgICAgICAg dGhpcy52YWx1ZXMgPSB2YWx1ZXM7CisgICAgICAgIHRoaXMuX25lZWRzVmFyaWFibGVzRnJvbUlu c3BlY3RlZE5vZGUgPSBmYWxzZTsKKyAgICB9CisKKyAgICBfaGFuZGxlSW5zcGVjdGVkTm9kZUNo YW5nZWQoKQorICAgIHsKKyAgICAgICAgdGhpcy5fbmVlZHNWYXJpYWJsZXNGcm9tSW5zcGVjdGVk Tm9kZSA9IHRydWU7CisgICAgfQogfTsK 446735 2021-12-10 08:20:17 -0800 2021-12-10 12:35:26 -0800 Patch 1.2 bug-233372-20211210172016.patch text/plain 5799 rcaliman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi SW5zcGVjdG9yVUkvQ2hhbmdlTG9nCmluZGV4IGYwYzdlYjRiMWY1MTAxMGY3NzBlZmM3NDEwMmZk MmY1YTBkNWU5OTQuLmFkZmFlMmQ5MzQwZjU4ZmViMGU5MmRmNTlhMGJmMTE3YjM1NGNhYWQgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl Ykluc3BlY3RvclVJL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDIxLTEyLTA5ICBSYXp2 YW4gQ2FsaW1hbiAgPHJjYWxpbWFuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWIgSW5zcGVjdG9y OiBBZGQgQ1NTIHZhcmlhYmxlIG5hbWVzIHRvIHByb3BlcnR5IG5hbWUgY29tcGxldGlvbiBsaXN0 CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzMzNzIK KyAgICAgICAgPHJkYXI6Ly84MzIwNTk2OD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGQgdGhlIGxpc3Qgb2YgYXBwbGljYWJsZSBDU1MgdmFyaWFi bGVzIHRvIHRoZSBsaXN0IG9mIENTUyBwcm9wZXJ0eSBuYW1lIGNvbXBsZXRpb25zLgorCisgICAg ICAgIGBXSS5DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9uc2AgaXMgYSBsb25nLWxpdmVkIG9iamVj dCB0aGF0IGhvbGRzIGFsbCBzdXBwb3J0ZWQgcHJvcGVydHkgbmFtZXMuCisgICAgICAgIEl0IGRv ZXNuJ3QgbmVlZCB0byBjaGFuZ2Ugb3ZlciB0aW1lIGluIGEgV2ViIEluc3BlY3RvciBzZXNzaW9u LiBCdXQgdGhlIGxpc3Qgb2YgYXBwbGljYWJsZQorICAgICAgICBDU1MgdmFyaWFibGVzIGRlcGVu ZHMgb24gdGhlIHNlbGVjdGVkIG5vZGUuCisKKyAgICAgICAgVG8gYXZvaWQgdGhyYXNoaW5nIHRo ZSBsb25nIGxpc3Qgb2YgdmFsdWVzIGluIGBXSS5DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9uc2Ag d2UgZG9uJ3QgcHJvYWN0aXZlbHkgY29sbGVjdAorICAgICAgICBDU1MgdmFyaWFibGVzLiBJbnN0 ZWFkLCB3ZSBpbnRyb2R1Y2UgYSBmbGFnIHRvIGluZGljYXRlIHRoYXQgdGhlIGxpc3Qgb2YgQ1NT IHZhcmlhYmxlcyBtYXkKKyAgICAgICAgYmUgc3RhbGUgd2hlbmV2ZXIgdGhlIGluc3BlY3RlZCBu b2RlIGNoYW5nZXMuIE9ubHkgd2hlbiBjb21wbGV0aW9ucyBhcmUgcmVxdWVzdGVkIGRvIHdlIGNo ZWNrCisgICAgICAgIHRoaXMgZmxhZyBhbmQgYXVnbWVudCB0aGUgbGlzdCBvZiBDU1MgcHJvcGVy dHkgbmFtZXMgd2l0aCB0aGUgbGF0ZXN0IGxpc3Qgb2YgQ1NTIHZhcmlhYmxlcy4KKworICAgICAg ICAqIFVzZXJJbnRlcmZhY2UvTW9kZWxzL0NTU0NvbXBsZXRpb25zLmpzOgorICAgICAgICAoV0ku Q1NTQ29tcGxldGlvbnMucHJvdG90eXBlLnNldCB2YWx1ZXMpOgorICAgICAgICBBbGxvdyBhIHN1 Yi1jbGFzcyB0byByZXBsYWNlIHRoZSBsaXN0IG9mIHZhbHVlcyBpbiBvbmUgZ28uCisgICAgICAg IElmIGEgYFdJLkNTU1F1ZXJ5Q29udHJvbGxlcmAgd2FzIHVzZWQsIHJlc2V0IGl0IGFuZCBwcm92 aWRlIGl0IHRoZSBuZXcgbGlzdCBvZiB2YWx1ZXMuCisKKyAgICAgICAgKiBVc2VySW50ZXJmYWNl L01vZGVscy9DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9ucy5qczoKKyAgICAgICAgKFdJLkNTU1By b3BlcnR5TmFtZUNvbXBsZXRpb25zKToKKyAgICAgICAgKFdJLkNTU1Byb3BlcnR5TmFtZUNvbXBs ZXRpb25zLnByb3RvdHlwZS5leGVjdXRlUXVlcnkpOgorICAgICAgICAoV0kuQ1NTUHJvcGVydHlO YW1lQ29tcGxldGlvbnMucHJvdG90eXBlLnN0YXJ0c1dpdGgpOgorICAgICAgICAoV0kuQ1NTUHJv cGVydHlOYW1lQ29tcGxldGlvbnMucHJvdG90eXBlLl91cGRhdGVWYWx1ZXNXaXRoTGF0ZXN0Q1NT VmFyaWFibGVzKToKKyAgICAgICAgSG9sZGluZyBhIGNvcHkgb2YgdGhlIG9yaWdpbmFsIGxpc3Qg b2YgQ1NTIHByb3BlcnR5IG5hbWVzIGluIG9yZGVyIHRvIGNyZWF0ZSBhIG5ldyBsaXN0CisgICAg ICAgIGFndW1lbnRlZCB3aXRoIHZhcmlhYmxlcyBvbiBkZW1hbmQuCisKKyAgICAgICAgKFdJLkNT U1Byb3BlcnR5TmFtZUNvbXBsZXRpb25zLnByb3RvdHlwZS5faGFuZGxlSW5zcGVjdGVkTm9kZUNo YW5nZWQpOgorICAgICAgICBDb25zaWRlciBjaGFuZ2luZyBvZiB0aGUgaW5zcGVjdGVkIG5vZGUg YXMgYW4gaW5kaWNhdG9yIHRoYXQgdGhlIGxpc3Qgb2YgdmFyaWFibGVzIGlzIHN0YWxlLgorICAg ICAgICBUaGF0IG1heSBub3QgbmVjZXNzYXJpbHkgYmUgdHJ1ZSBmb3Igd2ViIHBhZ2VzIHdpdGgg YWxsIENTUyB2YXJpYWJsZXMgZGVjbGFyZWQgb24gOnJvb3Qgb3IgPGh0bWw+LAorICAgICAgICBi dXQgaXRlcmF0aW5nIG92ZXIgdGhlbSB0byB2ZXJpZnkgaXMgbmVlZGxlc3NseSBleHBlbnNpdmUg ZXNwZWNpYWxseSBpZiBjb21wbGV0aW9ucyB3ZXJlIG5vdCBldmVuIHJlcXVlc3RlZC4KKwogMjAy MS0xMi0xMCAgUmF6dmFuIENhbGltYW4gIDxyY2FsaW1hbkBhcHBsZS5jb20+CiAKICAgICAgICAg V2ViIEluc3BlY3RvcjogRXh0cmFjdCBhIHNwZWNpYWxpemVkIENTU05hbWVDb21wbGV0aW9ucyBm cm9tIENTU0NvbXBsZXRpb25zCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNl ckludGVyZmFjZS9Nb2RlbHMvQ1NTQ29tcGxldGlvbnMuanMgYi9Tb3VyY2UvV2ViSW5zcGVjdG9y VUkvVXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTQ29tcGxldGlvbnMuanMKaW5kZXggMmE1MjgzZjA1 MjdjZGM2YTIwMjAzYmRjNzAxYTg0MjRjMDQyYjhmYS4uZWZmNDIzMmU0YmE4NjU3NWUzZjJkZjlj ZWE4OGU4M2ZjMmJkMDU1NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJ bnRlcmZhY2UvTW9kZWxzL0NTU0NvbXBsZXRpb25zLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0 b3JVSS9Vc2VySW50ZXJmYWNlL01vZGVscy9DU1NDb21wbGV0aW9ucy5qcwpAQCAtMTM4LDYgKzEz OCwxNSBAQCBXSS5DU1NDb21wbGV0aW9ucyA9IGNsYXNzIENTU0NvbXBsZXRpb25zCiAgICAgICAg IHJldHVybiB0aGlzLl92YWx1ZXM7CiAgICAgfQogCisgICAgc2V0IHZhbHVlcyh2YWx1ZXMpCisg ICAgeworICAgICAgICBjb25zb2xlLmFzc2VydChBcnJheS5pc0FycmF5KHZhbHVlcyksIHZhbHVl cyk7CisgICAgICAgIHRoaXMuX3ZhbHVlcyA9IHZhbHVlczsKKyAgICAgICAgdGhpcy5fdmFsdWVz LnNvcnQoKTsKKyAgICAgICAgdGhpcy5fcXVlcnlDb250cm9sbGVyPy5yZXNldCgpOworICAgICAg ICB0aGlzLl9xdWVyeUNvbnRyb2xsZXI/LmFkZFZhbHVlcyh2YWx1ZXMpOworICAgIH0KKwogICAg IGFkZFZhbHVlcyh2YWx1ZXMpCiAgICAgewogICAgICAgICBjb25zb2xlLmFzc2VydChBcnJheS5p c0FycmF5KHZhbHVlcyksIHZhbHVlcyk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9y VUkvVXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTUHJvcGVydHlOYW1lQ29tcGxldGlvbnMuanMgYi9T b3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTUHJvcGVydHlOYW1l Q29tcGxldGlvbnMuanMKaW5kZXggNjk4MmQ2YWZlOWQzZDE2MWVkOTE4YjJlNGNkMWUxMGE2OWM5 MjcxZi4uZjBiNDcxZjAwODEyOWNmNWE3ZWY2ZmU0NWY0YWEyMDQxYjY5MGUyNSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvTW9kZWxzL0NTU1Byb3BlcnR5 TmFtZUNvbXBsZXRpb25zLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJm YWNlL01vZGVscy9DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9ucy5qcwpAQCAtNDAsNiArNDAsMTEg QEAgV0kuQ1NTUHJvcGVydHlOYW1lQ29tcGxldGlvbnMgPSBjbGFzcyBDU1NQcm9wZXJ0eU5hbWVD b21wbGV0aW9ucyBleHRlbmRzIFdJLkNTU0MKICAgICAgICAgfQogCiAgICAgICAgIHN1cGVyKHZh bHVlcywgb3B0aW9ucyk7CisKKyAgICAgICAgdGhpcy5fY2FjaGVkU29ydGVkUHJvcGVydHlOYW1l cyA9IHRoaXMudmFsdWVzLnNsaWNlKCk7CisgICAgICAgIHRoaXMuX25lZWRzVmFyaWFibGVzRnJv bUluc3BlY3RlZE5vZGUgPSB0cnVlOworCisgICAgICAgIFdJLmRvbU1hbmFnZXIuYWRkRXZlbnRM aXN0ZW5lcihXSS5ET01NYW5hZ2VyLkV2ZW50Lkluc3BlY3RlZE5vZGVDaGFuZ2VkLCB0aGlzLl9o YW5kbGVJbnNwZWN0ZWROb2RlQ2hhbmdlZCwgdGhpcyk7CiAgICAgfQogCiAgICAgLy8gUHVibGlj CkBAIC00OCw0ICs1Myw1MSBAQCBXSS5DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9ucyA9IGNsYXNz IENTU1Byb3BlcnR5TmFtZUNvbXBsZXRpb25zIGV4dGVuZHMgV0kuQ1NTQwogICAgIHsKICAgICAg ICAgcmV0dXJuIHRoaXMudmFsdWVzLmluY2x1ZGVzKG5hbWUpOwogICAgIH0KKworICAgIGV4ZWN1 dGVRdWVyeShxdWVyeSkKKyAgICB7CisgICAgICAgIGlmICh0aGlzLl9uZWVkc1ZhcmlhYmxlc0Zy b21JbnNwZWN0ZWROb2RlKQorICAgICAgICAgICAgdGhpcy5fdXBkYXRlVmFsdWVzV2l0aExhdGVz dENTU1ZhcmlhYmxlcygpOworCisgICAgICAgIHJldHVybiBzdXBlci5leGVjdXRlUXVlcnkocXVl cnkpOworICAgIH0KKworICAgIHN0YXJ0c1dpdGgocHJlZml4KQorICAgIHsKKyAgICAgICAgaWYg KHRoaXMuX25lZWRzVmFyaWFibGVzRnJvbUluc3BlY3RlZE5vZGUpCisgICAgICAgICAgICB0aGlz Ll91cGRhdGVWYWx1ZXNXaXRoTGF0ZXN0Q1NTVmFyaWFibGVzKCk7CisKKyAgICAgICAgcmV0dXJu IHN1cGVyLnN0YXJ0c1dpdGgocHJlZml4KTsKKyAgICB9CisKKyAgICAvLyBQcml2YXRlCisKKyAg ICBfdXBkYXRlVmFsdWVzV2l0aExhdGVzdENTU1ZhcmlhYmxlcygpCisgICAgeworICAgICAgICBs ZXQgbm9kZVN0eWxlcyA9IFdJLmNzc01hbmFnZXIuc3R5bGVzRm9yTm9kZShXSS5kb21NYW5hZ2Vy Lmluc3BlY3RlZE5vZGUpOworICAgICAgICBub2RlU3R5bGVzLmFkZEV2ZW50TGlzdGVuZXIoV0ku RE9NTm9kZVN0eWxlcy5FdmVudC5OZWVkc1JlZnJlc2gsIHRoaXMuX2hhbmRsZU5vZGVzU3R5bGVz TmVlZHNSZWZyZXNoLCB0aGlzKTsKKworICAgICAgICBsZXQgdmFyaWFibGVzID0gQXJyYXkuZnJv bShub2RlU3R5bGVzLmFsbENTU1ZhcmlhYmxlcyk7CisgICAgICAgIGxldCB2YWx1ZXMgPSB2YXJp YWJsZXM7CisgICAgICAgIHZhbHVlcy5wdXNoQWxsKHRoaXMuX2NhY2hlZFNvcnRlZFByb3BlcnR5 TmFtZXMpOworCisgICAgICAgIHRoaXMudmFsdWVzID0gdmFsdWVzOworICAgICAgICB0aGlzLl9u ZWVkc1ZhcmlhYmxlc0Zyb21JbnNwZWN0ZWROb2RlID0gZmFsc2U7CisgICAgfQorCisgICAgX2hh bmRsZUluc3BlY3RlZE5vZGVDaGFuZ2VkKGV2ZW50KQorICAgIHsKKyAgICAgICAgdGhpcy5fbmVl ZHNWYXJpYWJsZXNGcm9tSW5zcGVjdGVkTm9kZSA9IHRydWU7CisKKyAgICAgICAgaWYgKCFldmVu dC5kYXRhLmxhc3RJbnNwZWN0ZWROb2RlPy5pZCkKKyAgICAgICAgICAgIHJldHVybjsKKworICAg ICAgICBsZXQgbm9kZVN0eWxlcyA9IFdJLmNzc01hbmFnZXIuc3R5bGVzRm9yTm9kZShldmVudC5k YXRhLmxhc3RJbnNwZWN0ZWROb2RlKTsKKyAgICAgICAgbm9kZVN0eWxlcy5yZW1vdmVFdmVudExp c3RlbmVyKFdJLkRPTU5vZGVTdHlsZXMuRXZlbnQuTmVlZHNSZWZyZXNoLCB0aGlzLl9oYW5kbGVO b2Rlc1N0eWxlc05lZWRzUmVmcmVzaCwgdGhpcyk7CisgICAgfQorCisgICAgX2hhbmRsZU5vZGVz U3R5bGVzTmVlZHNSZWZyZXNoKGV2ZW50KQorICAgIHsKKyAgICAgICAgdGhpcy5fbmVlZHNWYXJp YWJsZXNGcm9tSW5zcGVjdGVkTm9kZSA9IHRydWU7CisgICAgfQogfTsK 446782 2021-12-10 12:35:30 -0800 2021-12-10 12:59:25 -0800 Patch 1.3 bug-233372-20211210213529.patch text/plain 6198 rcaliman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi SW5zcGVjdG9yVUkvQ2hhbmdlTG9nCmluZGV4IGYwYzdlYjRiMWY1MTAxMGY3NzBlZmM3NDEwMmZk MmY1YTBkNWU5OTQuLmFkZmFlMmQ5MzQwZjU4ZmViMGU5MmRmNTlhMGJmMTE3YjM1NGNhYWQgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl Ykluc3BlY3RvclVJL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQwIEBACisyMDIxLTEyLTA5ICBSYXp2 YW4gQ2FsaW1hbiAgPHJjYWxpbWFuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWIgSW5zcGVjdG9y OiBBZGQgQ1NTIHZhcmlhYmxlIG5hbWVzIHRvIHByb3BlcnR5IG5hbWUgY29tcGxldGlvbiBsaXN0 CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzMzNzIK KyAgICAgICAgPHJkYXI6Ly84MzIwNTk2OD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBBZGQgdGhlIGxpc3Qgb2YgYXBwbGljYWJsZSBDU1MgdmFyaWFi bGVzIHRvIHRoZSBsaXN0IG9mIENTUyBwcm9wZXJ0eSBuYW1lIGNvbXBsZXRpb25zLgorCisgICAg ICAgIGBXSS5DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9uc2AgaXMgYSBsb25nLWxpdmVkIG9iamVj dCB0aGF0IGhvbGRzIGFsbCBzdXBwb3J0ZWQgcHJvcGVydHkgbmFtZXMuCisgICAgICAgIEl0IGRv ZXNuJ3QgbmVlZCB0byBjaGFuZ2Ugb3ZlciB0aW1lIGluIGEgV2ViIEluc3BlY3RvciBzZXNzaW9u LiBCdXQgdGhlIGxpc3Qgb2YgYXBwbGljYWJsZQorICAgICAgICBDU1MgdmFyaWFibGVzIGRlcGVu ZHMgb24gdGhlIHNlbGVjdGVkIG5vZGUuCisKKyAgICAgICAgVG8gYXZvaWQgdGhyYXNoaW5nIHRo ZSBsb25nIGxpc3Qgb2YgdmFsdWVzIGluIGBXSS5DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9uc2Ag d2UgZG9uJ3QgcHJvYWN0aXZlbHkgY29sbGVjdAorICAgICAgICBDU1MgdmFyaWFibGVzLiBJbnN0 ZWFkLCB3ZSBpbnRyb2R1Y2UgYSBmbGFnIHRvIGluZGljYXRlIHRoYXQgdGhlIGxpc3Qgb2YgQ1NT IHZhcmlhYmxlcyBtYXkKKyAgICAgICAgYmUgc3RhbGUgd2hlbmV2ZXIgdGhlIGluc3BlY3RlZCBu b2RlIGNoYW5nZXMuIE9ubHkgd2hlbiBjb21wbGV0aW9ucyBhcmUgcmVxdWVzdGVkIGRvIHdlIGNo ZWNrCisgICAgICAgIHRoaXMgZmxhZyBhbmQgYXVnbWVudCB0aGUgbGlzdCBvZiBDU1MgcHJvcGVy dHkgbmFtZXMgd2l0aCB0aGUgbGF0ZXN0IGxpc3Qgb2YgQ1NTIHZhcmlhYmxlcy4KKworICAgICAg ICAqIFVzZXJJbnRlcmZhY2UvTW9kZWxzL0NTU0NvbXBsZXRpb25zLmpzOgorICAgICAgICAoV0ku Q1NTQ29tcGxldGlvbnMucHJvdG90eXBlLnNldCB2YWx1ZXMpOgorICAgICAgICBBbGxvdyBhIHN1 Yi1jbGFzcyB0byByZXBsYWNlIHRoZSBsaXN0IG9mIHZhbHVlcyBpbiBvbmUgZ28uCisgICAgICAg IElmIGEgYFdJLkNTU1F1ZXJ5Q29udHJvbGxlcmAgd2FzIHVzZWQsIHJlc2V0IGl0IGFuZCBwcm92 aWRlIGl0IHRoZSBuZXcgbGlzdCBvZiB2YWx1ZXMuCisKKyAgICAgICAgKiBVc2VySW50ZXJmYWNl L01vZGVscy9DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9ucy5qczoKKyAgICAgICAgKFdJLkNTU1By b3BlcnR5TmFtZUNvbXBsZXRpb25zKToKKyAgICAgICAgKFdJLkNTU1Byb3BlcnR5TmFtZUNvbXBs ZXRpb25zLnByb3RvdHlwZS5leGVjdXRlUXVlcnkpOgorICAgICAgICAoV0kuQ1NTUHJvcGVydHlO YW1lQ29tcGxldGlvbnMucHJvdG90eXBlLnN0YXJ0c1dpdGgpOgorICAgICAgICAoV0kuQ1NTUHJv cGVydHlOYW1lQ29tcGxldGlvbnMucHJvdG90eXBlLl91cGRhdGVWYWx1ZXNXaXRoTGF0ZXN0Q1NT VmFyaWFibGVzKToKKyAgICAgICAgSG9sZGluZyBhIGNvcHkgb2YgdGhlIG9yaWdpbmFsIGxpc3Qg b2YgQ1NTIHByb3BlcnR5IG5hbWVzIGluIG9yZGVyIHRvIGNyZWF0ZSBhIG5ldyBsaXN0CisgICAg ICAgIGFndW1lbnRlZCB3aXRoIHZhcmlhYmxlcyBvbiBkZW1hbmQuCisKKyAgICAgICAgKFdJLkNT U1Byb3BlcnR5TmFtZUNvbXBsZXRpb25zLnByb3RvdHlwZS5faGFuZGxlSW5zcGVjdGVkTm9kZUNo YW5nZWQpOgorICAgICAgICBDb25zaWRlciBjaGFuZ2luZyBvZiB0aGUgaW5zcGVjdGVkIG5vZGUg YXMgYW4gaW5kaWNhdG9yIHRoYXQgdGhlIGxpc3Qgb2YgdmFyaWFibGVzIGlzIHN0YWxlLgorICAg ICAgICBUaGF0IG1heSBub3QgbmVjZXNzYXJpbHkgYmUgdHJ1ZSBmb3Igd2ViIHBhZ2VzIHdpdGgg YWxsIENTUyB2YXJpYWJsZXMgZGVjbGFyZWQgb24gOnJvb3Qgb3IgPGh0bWw+LAorICAgICAgICBi dXQgaXRlcmF0aW5nIG92ZXIgdGhlbSB0byB2ZXJpZnkgaXMgbmVlZGxlc3NseSBleHBlbnNpdmUg ZXNwZWNpYWxseSBpZiBjb21wbGV0aW9ucyB3ZXJlIG5vdCBldmVuIHJlcXVlc3RlZC4KKwogMjAy MS0xMi0xMCAgUmF6dmFuIENhbGltYW4gIDxyY2FsaW1hbkBhcHBsZS5jb20+CiAKICAgICAgICAg V2ViIEluc3BlY3RvcjogRXh0cmFjdCBhIHNwZWNpYWxpemVkIENTU05hbWVDb21wbGV0aW9ucyBm cm9tIENTU0NvbXBsZXRpb25zCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkvVXNl ckludGVyZmFjZS9Nb2RlbHMvQ1NTQ29tcGxldGlvbnMuanMgYi9Tb3VyY2UvV2ViSW5zcGVjdG9y VUkvVXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTQ29tcGxldGlvbnMuanMKaW5kZXggMmE1MjgzZjA1 MjdjZGM2YTIwMjAzYmRjNzAxYTg0MjRjMDQyYjhmYS4uZDcyNGI3MTAzNGY0YTRhNGYxMjZjN2Mw ZDkxMzI0NDEzMjI5YTk4YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJ bnRlcmZhY2UvTW9kZWxzL0NTU0NvbXBsZXRpb25zLmpzCisrKyBiL1NvdXJjZS9XZWJJbnNwZWN0 b3JVSS9Vc2VySW50ZXJmYWNlL01vZGVscy9DU1NDb21wbGV0aW9ucy5qcwpAQCAtMTcyLDYgKzE3 MiwxOSBAQCBXSS5DU1NDb21wbGV0aW9ucyA9IGNsYXNzIENTU0NvbXBsZXRpb25zCiAgICAgICAg IHJldHVybiByZXN1bHRzOwogICAgIH0KIAorICAgIC8vIFByb3RlY3RlZAorCisgICAgcmVwbGFj ZVZhbHVlcyh2YWx1ZXMpCisgICAgeworICAgICAgICBjb25zb2xlLmFzc2VydChBcnJheS5pc0Fy cmF5KHZhbHVlcyksIHZhbHVlcyk7CisgICAgICAgIHRoaXMuX3ZhbHVlcyA9IHZhbHVlczsKKyAg ICAgICAgdGhpcy5fdmFsdWVzLnNvcnQoKTsKKyAgICAgICAgdGhpcy5fcXVlcnlDb250cm9sbGVy Py5yZXNldCgpOworICAgICAgICB0aGlzLl9xdWVyeUNvbnRyb2xsZXI/LmFkZFZhbHVlcyh2YWx1 ZXMpOworICAgIH0KKworICAgIC8vIFByaXZhdGUKKwogICAgIF9maXJzdEluZGV4T2ZQcmVmaXgo cHJlZml4KQogICAgIHsKICAgICAgICAgaWYgKCF0aGlzLl92YWx1ZXMubGVuZ3RoKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvTW9kZWxzL0NTU1Byb3Bl cnR5TmFtZUNvbXBsZXRpb25zLmpzIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZh Y2UvTW9kZWxzL0NTU1Byb3BlcnR5TmFtZUNvbXBsZXRpb25zLmpzCmluZGV4IDY5ODJkNmFmZTlk M2QxNjFlZDkxOGIyZTRjZDFlMTBhNjljOTI3MWYuLjE0M2Y1OGU3M2RkMmEwYzRmN2M0NTQyY2My NTBjYjczYjM3YjlhODIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50 ZXJmYWNlL01vZGVscy9DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9ucy5qcworKysgYi9Tb3VyY2Uv V2ViSW5zcGVjdG9yVUkvVXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTUHJvcGVydHlOYW1lQ29tcGxl dGlvbnMuanMKQEAgLTQwLDYgKzQwLDExIEBAIFdJLkNTU1Byb3BlcnR5TmFtZUNvbXBsZXRpb25z ID0gY2xhc3MgQ1NTUHJvcGVydHlOYW1lQ29tcGxldGlvbnMgZXh0ZW5kcyBXSS5DU1NDCiAgICAg ICAgIH0KIAogICAgICAgICBzdXBlcih2YWx1ZXMsIG9wdGlvbnMpOworCisgICAgICAgIHRoaXMu X2NhY2hlZFNvcnRlZFByb3BlcnR5TmFtZXMgPSB0aGlzLnZhbHVlcy5zbGljZSgpOworICAgICAg ICB0aGlzLl9uZWVkc1ZhcmlhYmxlc0Zyb21JbnNwZWN0ZWROb2RlID0gdHJ1ZTsKKworICAgICAg ICBXSS5kb21NYW5hZ2VyLmFkZEV2ZW50TGlzdGVuZXIoV0kuRE9NTWFuYWdlci5FdmVudC5JbnNw ZWN0ZWROb2RlQ2hhbmdlZCwgdGhpcy5faGFuZGxlSW5zcGVjdGVkTm9kZUNoYW5nZWQsIHRoaXMp OwogICAgIH0KIAogICAgIC8vIFB1YmxpYwpAQCAtNDgsNCArNTMsNjEgQEAgV0kuQ1NTUHJvcGVy dHlOYW1lQ29tcGxldGlvbnMgPSBjbGFzcyBDU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9ucyBleHRl bmRzIFdJLkNTU0MKICAgICB7CiAgICAgICAgIHJldHVybiB0aGlzLnZhbHVlcy5pbmNsdWRlcyhu YW1lKTsKICAgICB9CisKKyAgICBleGVjdXRlUXVlcnkocXVlcnkpCisgICAgeworICAgICAgICB0 aGlzLl91cGRhdGVWYWx1ZXNXaXRoTGF0ZXN0Q1NTVmFyaWFibGVzSWZOZWVkZWQoKTsKKyAgICAg ICAgcmV0dXJuIHN1cGVyLmV4ZWN1dGVRdWVyeShxdWVyeSk7CisgICAgfQorCisgICAgc3RhcnRz V2l0aChwcmVmaXgpCisgICAgeworICAgICAgICB0aGlzLl91cGRhdGVWYWx1ZXNXaXRoTGF0ZXN0 Q1NTVmFyaWFibGVzSWZOZWVkZWQoKTsKKyAgICAgICAgcmV0dXJuIHN1cGVyLnN0YXJ0c1dpdGgo cHJlZml4KTsKKyAgICB9CisKKyAgICBhZGRWYWx1ZXMoKQorICAgIHsKKyAgICAgICAgdGhyb3cg bmV3IEVycm9yKCJBZGRpbmcgdmFsdWVzIHdpbGwgb3ZlcndyaXRlIHRoZSBsaXN0IG9mIHN1cHBv cnRlZCBDU1MgcHJvcGVydHkgbmFtZXMiKTsKKyAgICB9CisKKyAgICAvLyBQcml2YXRlCisKKyAg ICBfdXBkYXRlVmFsdWVzV2l0aExhdGVzdENTU1ZhcmlhYmxlc0lmTmVlZGVkKCkKKyAgICB7Cisg ICAgICAgIGlmICghdGhpcy5fbmVlZHNWYXJpYWJsZXNGcm9tSW5zcGVjdGVkTm9kZSkKKyAgICAg ICAgICAgIHJldHVybjsKKworICAgICAgICAvLyBBbiBpbnNwZWN0ZWQgbm9kZSBpcyBub3QgZ3Vh cmFudGVlZCB0byBleGlzdCB3aGVuIHVuaXQgdGVzdGluZy4KKyAgICAgICAgaWYgKCFXSS5kb21N YW5hZ2VyLmluc3BlY3RlZE5vZGUpIHsKKyAgICAgICAgICAgIHRoaXMuX25lZWRzVmFyaWFibGVz RnJvbUluc3BlY3RlZE5vZGUgPSBmYWxzZTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAg fQorCisgICAgICAgIGxldCBub2RlU3R5bGVzID0gV0kuY3NzTWFuYWdlci5zdHlsZXNGb3JOb2Rl KFdJLmRvbU1hbmFnZXIuaW5zcGVjdGVkTm9kZSk7CisgICAgICAgIG5vZGVTdHlsZXMuYWRkRXZl bnRMaXN0ZW5lcihXSS5ET01Ob2RlU3R5bGVzLkV2ZW50Lk5lZWRzUmVmcmVzaCwgdGhpcy5faGFu ZGxlTm9kZXNTdHlsZXNOZWVkc1JlZnJlc2gsIHRoaXMpOworCisgICAgICAgIGxldCB2YXJpYWJs ZXMgPSBBcnJheS5mcm9tKG5vZGVTdHlsZXMuYWxsQ1NTVmFyaWFibGVzKTsKKyAgICAgICAgbGV0 IHZhbHVlcyA9IHZhcmlhYmxlczsKKyAgICAgICAgdmFsdWVzLnB1c2hBbGwodGhpcy5fY2FjaGVk U29ydGVkUHJvcGVydHlOYW1lcyk7CisKKyAgICAgICAgdGhpcy5yZXBsYWNlVmFsdWVzKHZhbHVl cyk7CisgICAgICAgIHRoaXMuX25lZWRzVmFyaWFibGVzRnJvbUluc3BlY3RlZE5vZGUgPSBmYWxz ZTsKKyAgICB9CisKKyAgICBfaGFuZGxlSW5zcGVjdGVkTm9kZUNoYW5nZWQoZXZlbnQpCisgICAg eworICAgICAgICBpZiAodGhpcy5fbmVlZHNWYXJpYWJsZXNGcm9tSW5zcGVjdGVkTm9kZSB8fCAh ZXZlbnQuZGF0YS5sYXN0SW5zcGVjdGVkTm9kZSkKKyAgICAgICAgICAgIHJldHVybjsKKworICAg ICAgICB0aGlzLl9uZWVkc1ZhcmlhYmxlc0Zyb21JbnNwZWN0ZWROb2RlID0gdHJ1ZTsKKworICAg ICAgICBsZXQgbm9kZVN0eWxlcyA9IFdJLmNzc01hbmFnZXIuc3R5bGVzRm9yTm9kZShldmVudC5k YXRhLmxhc3RJbnNwZWN0ZWROb2RlKTsKKyAgICAgICAgbm9kZVN0eWxlcy5yZW1vdmVFdmVudExp c3RlbmVyKFdJLkRPTU5vZGVTdHlsZXMuRXZlbnQuTmVlZHNSZWZyZXNoLCB0aGlzLl9oYW5kbGVO b2Rlc1N0eWxlc05lZWRzUmVmcmVzaCwgdGhpcyk7CisgICAgfQorCisgICAgX2hhbmRsZU5vZGVz U3R5bGVzTmVlZHNSZWZyZXNoKGV2ZW50KQorICAgIHsKKyAgICAgICAgdGhpcy5fbmVlZHNWYXJp YWJsZXNGcm9tSW5zcGVjdGVkTm9kZSA9IHRydWU7CisgICAgfQogfTsK 446788 2021-12-10 12:59:30 -0800 2021-12-10 17:09:23 -0800 Patch 1.4 bug-233372-20211210215928.patch text/plain 6728 rcaliman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi SW5zcGVjdG9yVUkvQ2hhbmdlTG9nCmluZGV4IGYwYzdlYjRiMWY1MTAxMGY3NzBlZmM3NDEwMmZk MmY1YTBkNWU5OTQuLmFmYjg4ODA0NGMzODg3MWIwZTZmOTRjOWYxOWY5MGNhODQ4NmQ4ZmYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl Ykluc3BlY3RvclVJL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ4IEBACisyMDIxLTEyLTEwICBSYXp2 YW4gQ2FsaW1hbiAgPHJjYWxpbWFuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWIgSW5zcGVjdG9y OiBBZGQgQ1NTIHZhcmlhYmxlIG5hbWVzIHRvIHByb3BlcnR5IG5hbWUgY29tcGxldGlvbiBsaXN0 CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzMzNzIK KyAgICAgICAgPHJkYXI6Ly84MzIwNTk2OD4KKworICAgICAgICBSZXZpZXdlZCBieSBEZXZpbiBS b3Vzc28uCisKKyAgICAgICAgQWRkIHRoZSBsaXN0IG9mIGFwcGxpY2FibGUgQ1NTIHZhcmlhYmxl cyB0byB0aGUgbGlzdCBvZiBDU1MgcHJvcGVydHkgbmFtZSBjb21wbGV0aW9ucy4KKworICAgICAg ICBgV0kuQ1NTUHJvcGVydHlOYW1lQ29tcGxldGlvbnNgIGlzIGEgbG9uZy1saXZlZCBvYmplY3Qg dGhhdCBob2xkcyBhbGwgc3VwcG9ydGVkIHByb3BlcnR5IG5hbWVzLgorICAgICAgICBJdCBkb2Vz bid0IG5lZWQgdG8gY2hhbmdlIG92ZXIgdGltZSBpbiBhIFdlYiBJbnNwZWN0b3Igc2Vzc2lvbi4g QnV0IHRoZSBsaXN0IG9mIGFwcGxpY2FibGUKKyAgICAgICAgQ1NTIHZhcmlhYmxlcyBkZXBlbmRz IG9uIHRoZSBzZWxlY3RlZCBub2RlLgorCisgICAgICAgIFRvIGF2b2lkIHRocmFzaGluZyB0aGUg bG9uZyBsaXN0IG9mIHZhbHVlcyBpbiBgV0kuQ1NTUHJvcGVydHlOYW1lQ29tcGxldGlvbnNgIHdl IGRvbid0IHByb2FjdGl2ZWx5IGNvbGxlY3QKKyAgICAgICAgQ1NTIHZhcmlhYmxlcy4gSW5zdGVh ZCwgd2UgaW50cm9kdWNlIGEgZmxhZyB0byBpbmRpY2F0ZSB0aGF0IHRoZSBsaXN0IG9mIENTUyB2 YXJpYWJsZXMgbWF5CisgICAgICAgIGJlIHN0YWxlIHdoZW5ldmVyIHRoZSBpbnNwZWN0ZWQgbm9k ZSBjaGFuZ2VzLiBPbmx5IHdoZW4gY29tcGxldGlvbnMgYXJlIHJlcXVlc3RlZCBkbyB3ZSBjaGVj aworICAgICAgICB0aGlzIGZsYWcgYW5kIGF1Z21lbnQgdGhlIGxpc3Qgb2YgQ1NTIHByb3BlcnR5 IG5hbWVzIHdpdGggdGhlIGxhdGVzdCBsaXN0IG9mIENTUyB2YXJpYWJsZXMuCisKKyAgICAgICAg KiBVc2VySW50ZXJmYWNlL01vZGVscy9DU1NDb21wbGV0aW9ucy5qczoKKyAgICAgICAgKFdJLkNT U0NvbXBsZXRpb25zLnByb3RvdHlwZS5yZXBsYWNlVmFsdWVzKToKKyAgICAgICAgQWxsb3cgYSBz dWItY2xhc3MgdG8gcmVwbGFjZSB0aGUgbGlzdCBvZiB2YWx1ZXMgaW4gb25lIGdvLgorICAgICAg ICBJZiBhIGBXSS5DU1NRdWVyeUNvbnRyb2xsZXJgIHdhcyB1c2VkLCByZXNldCBpdCBhbmQgcHJv dmlkZSBpdCB0aGUgbmV3IGxpc3Qgb2YgdmFsdWVzLgorCisgICAgICAgICogVXNlckludGVyZmFj ZS9Nb2RlbHMvQ1NTUHJvcGVydHlOYW1lQ29tcGxldGlvbnMuanM6CisgICAgICAgIChXSS5DU1NQ cm9wZXJ0eU5hbWVDb21wbGV0aW9ucyk6CisgICAgICAgIChXSS5DU1NQcm9wZXJ0eU5hbWVDb21w bGV0aW9ucy5wcm90b3R5cGUuZXhlY3V0ZVF1ZXJ5KToKKyAgICAgICAgKFdJLkNTU1Byb3BlcnR5 TmFtZUNvbXBsZXRpb25zLnByb3RvdHlwZS5zdGFydHNXaXRoKToKKyAgICAgICAgKFdJLkNTU1By b3BlcnR5TmFtZUNvbXBsZXRpb25zLnByb3RvdHlwZS5fdXBkYXRlVmFsdWVzV2l0aExhdGVzdENT U1ZhcmlhYmxlc0lmTmVlZGVkKToKKyAgICAgICAgSG9sZGluZyBhIGNvcHkgb2YgdGhlIG9yaWdp bmFsIGxpc3Qgb2YgQ1NTIHByb3BlcnR5IG5hbWVzIGluIG9yZGVyIHRvIGNyZWF0ZSBhIG5ldyBs aXN0CisgICAgICAgIGFndW1lbnRlZCB3aXRoIHZhcmlhYmxlcyBvbiBkZW1hbmQuCisKKyAgICAg ICAgKFdJLkNTU1Byb3BlcnR5TmFtZUNvbXBsZXRpb25zLnByb3RvdHlwZS5hZGRWYWx1ZXMpOgor ICAgICAgICBXYXJuIHdoZW4gdHJ5aW5nIHRvIGFkZCBuZXcgcHJvcGVydHkgdmFsdWVzIHdoaWNo IHdvdWxkIG92ZXJ3cml0ZSB0aGUgY2FjaGVkIGFuZCBzb3J0ZWQgbGlzdCBvZiBDU1MgcHJvcGVy dHkgbmFtZXMuCisKKyAgICAgICAgKFdJLkNTU1Byb3BlcnR5TmFtZUNvbXBsZXRpb25zLnByb3Rv dHlwZS5faGFuZGxlSW5zcGVjdGVkTm9kZUNoYW5nZWQpOgorICAgICAgICBDb25zaWRlciBjaGFu Z2luZyBvZiB0aGUgaW5zcGVjdGVkIG5vZGUgYXMgYW4gaW5kaWNhdG9yIHRoYXQgdGhlIGxpc3Qg b2YgdmFyaWFibGVzIGlzIHN0YWxlLgorICAgICAgICBUaGF0IG1heSBub3QgbmVjZXNzYXJpbHkg YmUgdHJ1ZSBmb3Igd2ViIHBhZ2VzIHdpdGggYWxsIENTUyB2YXJpYWJsZXMgZGVjbGFyZWQgb24g OnJvb3Qgb3IgPGh0bWw+LAorICAgICAgICBidXQgaXRlcmF0aW5nIG92ZXIgdGhlbSB0byB2ZXJp ZnkgaXMgbmVlZGxlc3NseSBleHBlbnNpdmUgZXNwZWNpYWxseSBpZiBjb21wbGV0aW9ucyB3ZXJl IG5vdCBldmVuIHJlcXVlc3RlZC4KKworICAgICAgICAoV0kuQ1NTUHJvcGVydHlOYW1lQ29tcGxl dGlvbnMucHJvdG90eXBlLl9oYW5kbGVOb2Rlc1N0eWxlc05lZWRzUmVmcmVzaCk6CisgICAgICAg IENvbnNpZGVyIGFueSBjaGFuZ2UgdG8gdGhlIHN0eWxlcyBvZiB0aGUgaW5zcGVjdGVkIG5vZGUg YXMgYSBwb3RlbnRpYWwgY2hhbmdlIHRvIHRoZSBsaXN0IG9mIGFwcGxpY2FibGUgdmFyaWFibGVz LgorCisgICAgICAgIChXSS5DU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9ucyk6CisKIDIwMjEtMTIt MTAgIFJhenZhbiBDYWxpbWFuICA8cmNhbGltYW5AYXBwbGUuY29tPgogCiAgICAgICAgIFdlYiBJ bnNwZWN0b3I6IEV4dHJhY3QgYSBzcGVjaWFsaXplZCBDU1NOYW1lQ29tcGxldGlvbnMgZnJvbSBD U1NDb21wbGV0aW9ucwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRl cmZhY2UvTW9kZWxzL0NTU0NvbXBsZXRpb25zLmpzIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1Vz ZXJJbnRlcmZhY2UvTW9kZWxzL0NTU0NvbXBsZXRpb25zLmpzCmluZGV4IDJhNTI4M2YwNTI3Y2Rj NmEyMDIwM2JkYzcwMWE4NDI0YzA0MmI4ZmEuLmZkMWNhZGQ2MzZkYjJhM2Q5NDg1MTg0NjBkMjUy ZGQxMWYyNWRhY2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJm YWNlL01vZGVscy9DU1NDb21wbGV0aW9ucy5qcworKysgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkv VXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTQ29tcGxldGlvbnMuanMKQEAgLTE3Miw2ICsxNzIsMjIg QEAgV0kuQ1NTQ29tcGxldGlvbnMgPSBjbGFzcyBDU1NDb21wbGV0aW9ucwogICAgICAgICByZXR1 cm4gcmVzdWx0czsKICAgICB9CiAKKyAgICAvLyBQcm90ZWN0ZWQKKworICAgIHJlcGxhY2VWYWx1 ZXModmFsdWVzKQorICAgIHsKKyAgICAgICAgY29uc29sZS5hc3NlcnQoQXJyYXkuaXNBcnJheSh2 YWx1ZXMpLCB2YWx1ZXMpOworICAgICAgICBjb25zb2xlLmFzc2VydCh0eXBlb2YgdmFsdWVzWzBd ID09PSAic3RyaW5nIiwgIkV4cGVjdCBhbiBhcnJheSBvZiBzdHJpbmcgdmFsdWVzIiwgdmFsdWVz KTsKKworICAgICAgICB0aGlzLl92YWx1ZXMgPSB2YWx1ZXM7CisgICAgICAgIHRoaXMuX3ZhbHVl cy5zb3J0KCk7CisKKyAgICAgICAgdGhpcy5fcXVlcnlDb250cm9sbGVyPy5yZXNldCgpOworICAg ICAgICB0aGlzLl9xdWVyeUNvbnRyb2xsZXI/LmFkZFZhbHVlcyh2YWx1ZXMpOworICAgIH0KKwor ICAgIC8vIFByaXZhdGUKKwogICAgIF9maXJzdEluZGV4T2ZQcmVmaXgocHJlZml4KQogICAgIHsK ICAgICAgICAgaWYgKCF0aGlzLl92YWx1ZXMubGVuZ3RoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl Ykluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvTW9kZWxzL0NTU1Byb3BlcnR5TmFtZUNvbXBsZXRp b25zLmpzIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvTW9kZWxzL0NTU1By b3BlcnR5TmFtZUNvbXBsZXRpb25zLmpzCmluZGV4IDY5ODJkNmFmZTlkM2QxNjFlZDkxOGIyZTRj ZDFlMTBhNjljOTI3MWYuLjYxM2U1ZjlhNGU2NGVkNTBiNmNlOTk5YTZiNzNlYjBhOGMzMTg4Y2Ig MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL01vZGVscy9D U1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9ucy5qcworKysgYi9Tb3VyY2UvV2ViSW5zcGVjdG9yVUkv VXNlckludGVyZmFjZS9Nb2RlbHMvQ1NTUHJvcGVydHlOYW1lQ29tcGxldGlvbnMuanMKQEAgLTQw LDYgKzQwLDExIEBAIFdJLkNTU1Byb3BlcnR5TmFtZUNvbXBsZXRpb25zID0gY2xhc3MgQ1NTUHJv cGVydHlOYW1lQ29tcGxldGlvbnMgZXh0ZW5kcyBXSS5DU1NDCiAgICAgICAgIH0KIAogICAgICAg ICBzdXBlcih2YWx1ZXMsIG9wdGlvbnMpOworCisgICAgICAgIHRoaXMuX2NhY2hlZFNvcnRlZFBy b3BlcnR5TmFtZXMgPSB0aGlzLnZhbHVlcy5zbGljZSgpOworICAgICAgICB0aGlzLl9uZWVkc1Zh cmlhYmxlc0Zyb21JbnNwZWN0ZWROb2RlID0gdHJ1ZTsKKworICAgICAgICBXSS5kb21NYW5hZ2Vy LmFkZEV2ZW50TGlzdGVuZXIoV0kuRE9NTWFuYWdlci5FdmVudC5JbnNwZWN0ZWROb2RlQ2hhbmdl ZCwgdGhpcy5faGFuZGxlSW5zcGVjdGVkTm9kZUNoYW5nZWQsIHRoaXMpOwogICAgIH0KIAogICAg IC8vIFB1YmxpYwpAQCAtNDgsNCArNTMsNjIgQEAgV0kuQ1NTUHJvcGVydHlOYW1lQ29tcGxldGlv bnMgPSBjbGFzcyBDU1NQcm9wZXJ0eU5hbWVDb21wbGV0aW9ucyBleHRlbmRzIFdJLkNTU0MKICAg ICB7CiAgICAgICAgIHJldHVybiB0aGlzLnZhbHVlcy5pbmNsdWRlcyhuYW1lKTsKICAgICB9CisK KyAgICBleGVjdXRlUXVlcnkocXVlcnkpCisgICAgeworICAgICAgICB0aGlzLl91cGRhdGVWYWx1 ZXNXaXRoTGF0ZXN0Q1NTVmFyaWFibGVzSWZOZWVkZWQoKTsKKworICAgICAgICByZXR1cm4gc3Vw ZXIuZXhlY3V0ZVF1ZXJ5KHF1ZXJ5KTsKKyAgICB9CisKKyAgICBzdGFydHNXaXRoKHByZWZpeCkK KyAgICB7CisgICAgICAgIHRoaXMuX3VwZGF0ZVZhbHVlc1dpdGhMYXRlc3RDU1NWYXJpYWJsZXNJ Zk5lZWRlZCgpOworCisgICAgICAgIHJldHVybiBzdXBlci5zdGFydHNXaXRoKHByZWZpeCk7Cisg ICAgfQorCisgICAgYWRkVmFsdWVzKCkKKyAgICB7CisgICAgICAgIGNvbnNvbGUuYXNzZXJ0KGZh bHNlLCAiQWRkaW5nIHZhbHVlcyB3aWxsIG92ZXJ3cml0ZSB0aGUgbGlzdCBvZiBzdXBwb3J0ZWQg Q1NTIHByb3BlcnR5IG5hbWVzLiIpOworICAgIH0KKworICAgIC8vIFByaXZhdGUKKworICAgIF91 cGRhdGVWYWx1ZXNXaXRoTGF0ZXN0Q1NTVmFyaWFibGVzSWZOZWVkZWQoKQorICAgIHsKKyAgICAg ICAgaWYgKCF0aGlzLl9uZWVkc1ZhcmlhYmxlc0Zyb21JbnNwZWN0ZWROb2RlKQorICAgICAgICAg ICAgcmV0dXJuOworCisgICAgICAgIC8vIEFuIGluc3BlY3RlZCBub2RlIGlzIG5vdCBndWFyYW50 ZWVkIHRvIGV4aXN0IHdoZW4gdW5pdCB0ZXN0aW5nLgorICAgICAgICBpZiAoIVdJLmRvbU1hbmFn ZXIuaW5zcGVjdGVkTm9kZSkgeworICAgICAgICAgICAgdGhpcy5fbmVlZHNWYXJpYWJsZXNGcm9t SW5zcGVjdGVkTm9kZSA9IGZhbHNlOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisK KyAgICAgICAgbGV0IG5vZGVTdHlsZXMgPSBXSS5jc3NNYW5hZ2VyLnN0eWxlc0Zvck5vZGUoV0ku ZG9tTWFuYWdlci5pbnNwZWN0ZWROb2RlKTsKKyAgICAgICAgbm9kZVN0eWxlcy5hZGRFdmVudExp c3RlbmVyKFdJLkRPTU5vZGVTdHlsZXMuRXZlbnQuTmVlZHNSZWZyZXNoLCB0aGlzLl9oYW5kbGVO b2Rlc1N0eWxlc05lZWRzUmVmcmVzaCwgdGhpcyk7CisKKyAgICAgICAgbGV0IHZhbHVlcyA9IEFy cmF5LmZyb20obm9kZVN0eWxlcy5hbGxDU1NWYXJpYWJsZXMpOworICAgICAgICB2YWx1ZXMucHVz aEFsbCh0aGlzLl9jYWNoZWRTb3J0ZWRQcm9wZXJ0eU5hbWVzKTsKKyAgICAgICAgdGhpcy5yZXBs YWNlVmFsdWVzKHZhbHVlcyk7CisKKyAgICAgICAgdGhpcy5fbmVlZHNWYXJpYWJsZXNGcm9tSW5z cGVjdGVkTm9kZSA9IGZhbHNlOworICAgIH0KKworICAgIF9oYW5kbGVJbnNwZWN0ZWROb2RlQ2hh bmdlZChldmVudCkKKyAgICB7CisgICAgICAgIGlmICh0aGlzLl9uZWVkc1ZhcmlhYmxlc0Zyb21J bnNwZWN0ZWROb2RlIHx8ICFldmVudC5kYXRhLmxhc3RJbnNwZWN0ZWROb2RlKQorICAgICAgICAg ICAgcmV0dXJuOworCisgICAgICAgIHRoaXMuX25lZWRzVmFyaWFibGVzRnJvbUluc3BlY3RlZE5v ZGUgPSB0cnVlOworCisgICAgICAgIGxldCBub2RlU3R5bGVzID0gV0kuY3NzTWFuYWdlci5zdHls ZXNGb3JOb2RlKGV2ZW50LmRhdGEubGFzdEluc3BlY3RlZE5vZGUpOworICAgICAgICBub2RlU3R5 bGVzLnJlbW92ZUV2ZW50TGlzdGVuZXIoV0kuRE9NTm9kZVN0eWxlcy5FdmVudC5OZWVkc1JlZnJl c2gsIHRoaXMuX2hhbmRsZU5vZGVzU3R5bGVzTmVlZHNSZWZyZXNoLCB0aGlzKTsKKyAgICB9CisK KyAgICBfaGFuZGxlTm9kZXNTdHlsZXNOZWVkc1JlZnJlc2goZXZlbnQpCisgICAgeworICAgICAg ICB0aGlzLl9uZWVkc1ZhcmlhYmxlc0Zyb21JbnNwZWN0ZWROb2RlID0gdHJ1ZTsKKyAgICB9CiB9 Owo=