27514 2009-07-21 13:38:12 -0700 add support for watched expressions 2009-09-16 13:16:21 -0700 1 1 1 Unclassified WebKit Web Inspector (Deprecated) 528+ (Nightly build) All All RESOLVED FIXED P2 Enhancement --- 0 pmuellr webkit-unassigned aroben commit-queue kmccullough pfeldman timothy yurys oldest_to_newest 133580 0 pmuellr 2009-07-21 13:38:12 -0700 Firefox has a concept of "watch expressions", which are expressions the use can type into the same area as the currently visible objects (during a debug pause). Note these are expressions, and not simple variable names. The expressions are evaluated each time the debugger pauses. The expressions are rendered in the UI exactly the same as variables, only instead of the variable/property name, the expression is listed. Developers I work with that use FireBug have indicated that this support is quite valuable to them. We should add this to Web Inspector. 133582 1 pmuellr 2009-07-21 13:38:33 -0700 I've started working on this. 133817 2 33275 pmuellr 2009-07-22 11:26:58 -0700 Created attachment 33275 mock up of watched expressions UI Mock up of the UI. The Watched Expressions is a new sidebar pane as a peer of Call Stack, Scope Variables, etc. Somehow we need to have a way to add a new expression. Something like a button where the italic "Add watched expression" label is in the image. Looks like the ObjectPropertiesSection class can be largely reused, with a bit of refactoring. The "property names" in this case, like "19+23" are the expressions, the values are the results of evaluating the expression. Objects with properties should be drill-down-able, like window.HTMLElement is in the example, which ObjectPropertiesSection handles already. Evaluations which cause exceptions need to be reported, as they are in the bare "x" example (ReferenceError), though this needs to be prettied up with an icon of some kind, and probably a different color. There will need to be affordances/gestures to delete an expression, and to edit the expression. May want to add an accelerator to watch the expression indicated by text selected in the source view. The expressions should be sorted by time added. Perhaps they should be positionable via drag-drop, eventually. 135869 3 pmuellr 2009-07-30 10:00:31 -0700 Some notes from IRC yesterday: [1:18p] pmuellr: BTW, I'm in need of a gesture to add new watched expressions; hacked something you can see here ("Add watched expressions" is clickable, adds a new empty expression): https://bugs.webkit.org/attachment.cgi?id=33275 [1:30p] xenon: pmuellr: i would sugesst making "add watched expression" be at the bottom and be a rounded bubble button [1:32p] pmuellr: xenon: makes sense; is there an example of rounded bubble button style I can borrow? not many "button" in the UI right now [1:33p] xenon: pmuellr: yes, the "enable" views in the inspector have them [1:33p] JoePeck: pmuellr: on the splash screen to enable / disable Scripts Panel or something [1:34p] JoePeck: pmuellr: in the css ".panel-enabler-view button" [1:34p] JoePeck: and the related styles [1:35p] pmuellr: I'll need to get the button smaller :-) will play with, thx [1:36p] JoePeck: pmuellr: I threw it in a pane, this is what it looked like: http://tr.im/uCN1?grabup maybe it is too big [1:28p] xenon: pmuellr: i guess every time it is paused/stepped you eval the expressions? [1:30p] pmuellr: xenon: in FireBug, the expressions also show when not paused - ie, when you're "running". Also, evaluated in the current frame. Again, all seems doable right now. [1:37p] pmuellr: I also want a "hover over expression enables 'delete me' button", on the right, like style's checkboxes appear when hovered. Suggestions? mini-trashcan? [1:44p] xenon: pmuellr: apple usually uses the "no smoking" don't symbol [1:45p] xenon: pmuellr: or a X 135874 4 pmuellr 2009-07-30 10:16:51 -0700 Also happened to think: per Bug 27502 , we might want to add a hot key to allow the selected text in a source view to be added to the watched expressions list. 137417 5 34170 pmuellr 2009-08-05 13:35:09 -0700 Created attachment 34170 patch containing work so far a mostly working version of the watch expressions based off of revision 46507 (slightly old). Not ready for review, but thought I'd get the work up here, in a state where folks can play with it. Couple of things to add: - refresh list when debugger pauses, when the call stack frame changes - provide a better gesture for delete; currently you edit the expression, delete all the text. Some kind of hover enabled button, like CSS properties checkboxes? - save / reload watched expressions between debugger invocations Not sure what to do with the "Add" button; kinda sticks out. Maybe a slightly smaller font? Not sure if we want to keep the "Refresh" button, but I think so; there is no way I can think of that we could keep the list updated while an application is running (not paused), without just refreshing it every so often. Which doesn't make any sense. But someone may want to refresh the values without pausing the application. 144804 6 pmuellr 2009-09-04 07:13:23 -0700 cc'ing some folks; should be posting a proposed patch today 144808 7 39057 pmuellr 2009-09-04 08:16:56 -0700 Created attachment 39057 proposed patch - 2009/09/04 final for now, definitely working version Couple things to clean up, which I'd like to do later, after getting the meat of the code in: - I suspect folks won't like the red delete icon that shows up in the right column; I don't, but couldn't find anything better. Suggestions? I was thinking maybe taking the existing icon I'm using, but convert it to grayscale. - not really happy with the Add and Refresh buttons. Too big. I tried a smaller font at one point, one pt smaller, but that seemed too small. Was wondering about making these link-like instead of button-like. - there are some changes to existing code elsewhere that should be made; pfeldman suggested some proposed changes to make the Object.describe() vs proxy.description stuff simpler, making the console.eval code "public" (maybe we should move it somewhere else since it's not console specific any more), and property sorting should move to utilities. I'd like to do these later. 144810 8 39058 pmuellr 2009-09-04 08:25:21 -0700 Created attachment 39058 current watch expressions pane Current version of the Watch Expressions pane. You can see the HUUUUGE Add/Refresh buttons, the red delete buttons on the right, the general layout of the expressions and their values, and the color coding of eval errors. 144892 9 pfeldman 2009-09-04 12:21:27 -0700 > + > + // WebInspector.ConsoleView._evalInInspectedWindow should be made 'public' > + WebInspector.console._evalInInspectedWindow("(" + this.expression + ")", callback); _evalInInspectedWindow is used in console where we don't know whether we are on breakpoint or not. If watch expressions are only applicable to the paused state, you should use ScriptsPanel.prototype.evaluateInSelectedCallFrame or doEvalInCallFrame (your watch expressions are not supposed to mutate the app state). > + > + // Note, should provide a better way to get the "description"; > + // would prefer to just use Object.describe(), but returns > + // "Object" for new Date() compared to the proxy which returns > + // the date string > + > + // if a proxy object, get description from there > + if (value && value.objectId && value.description) > + this.valueElement.textContent = value.description; > + > + // if not a proxy object, use Object.describe() > + else > + this.valueElement.textContent = Object.describe(value, true); > + Object.describe is not available (will soon be not available) in the frontend. It is declared in the InjectedScript and should only be applied to the real objects (not proxies) in the InjectedScript.js. Look at how values are formatted in ConsoleView's _format method for reverence on how to render evaluation results instead. > + _refreshExpressionPropertiesCallback: function(properties) > + { > + this.removeChildren(); > + > + if (!properties) { > + this.hasChildren = false; > + return; > + } > + > + // WebInspector.ObjectPropertiesSection.prototype._displaySort should be > + // moved to something like utilities.js > + properties.sort(WebInspector.ObjectPropertiesSection.prototype._displaySort); > + > + for (var i = 0; i < properties.length; ++i) { > + this.appendChild(new this.treeOutline.section.treeElementConstructor(properties[i])); > + } > + this.hasChildren = properties.length > 0; > + }, > + This snippet as well as the InspectorController.getProperties(value, true, callback) above seems to be a large functionality dupe of what happens in ObjectPropertiesSection. Why not to use ObjectPropertiesSection explicitly? It would handle all the bits of rendering and expansion. Doesn't it work for you? I now recall that ObjectPropertiesSection can have problems rendering primitive values that are being returned from the evaluate without being wrapped with ObjectProxies. But that should be fairly easy to fix in the InjectedScript.evaluateOn body. It would actually simplify ConsoleView's formatting as well. If that is the case, I can fix that in the evaluate code and you would be able to nuke most of the duplicated code. 144933 10 pmuellr 2009-09-04 15:18:26 -0700 (In reply to comment #9) > _evalInInspectedWindow is used in console where we don't know whether we are on > breakpoint or not. If watch expressions are only applicable to the paused > state, you should use ScriptsPanel.prototype.evaluateInSelectedCallFrame or > doEvalInCallFrame (your watch expressions are not supposed to mutate the app > state). As currently implemented, watch expressions are applicable outside of paused states. For instance, you can bring up the Web Inspector, go to the Scripts panel, add watch expressions, and use the Refresh key to update without having to set a break point. Whether or not this is useful, don't know. I can imagine it could be. I'm not sure if FB does this or not. I understand the thought that watches shouldn't mutate app state, but of course it's impossible to prevent that. I'm not sure it's such a bad thing. Some power user might be able to do something useful with it. So, for the time being, I do still need something like _evalInInspectedWindow() > Object.describe is not available (will soon be not available) in the frontend. > It is declared in the InjectedScript and should only be applied to the real > objects (not proxies) in the InjectedScript.js. Look at how values > are formatted in ConsoleView's _format method for reverence on how to render > evaluation results instead. I haven't looked at those, but I will. It would be nice to be consistent in terms of what we're displaying for a particular object, in the various places it can be displayed. > This snippet as well as the InspectorController.getProperties(value, true, > callback) above seems to be a large functionality dupe of what happens in > ObjectPropertiesSection. Why not to use ObjectPropertiesSection explicitly? > It would handle all the bits of rendering and expansion. Doesn't it work for > you? I needed more behaviour than the plain old ObjectPropertiesSection had. I did try that first though; the watch expressions were keys in an object whose values were the eval()'d version of the keys. For various reasons it turned out to be too much work to make it all work in the existing framework instead of writing the relatively small amount of code that I did. I do reuse a lot of the behaviour out of the ObjectProperties code; and especially all the stuff underneath the roots of the trees - the children of the expressions themselves are ObjectPropertiesElements (or whatever). > I now recall that ObjectPropertiesSection can have problems rendering primitive > values that are being returned from the evaluate without being wrapped with > ObjectProxies. But that should be fairly easy to fix in the > InjectedScript.evaluateOn body. It would actually simplify ConsoleView's > formatting as well. > If that is the case, I can fix that in the evaluate code and you would be able > to nuke most of the duplicated code. 144934 11 timothy 2009-09-04 15:23:31 -0700 (In reply to comment #10) > (In reply to comment #9) > > > _evalInInspectedWindow is used in console where we don't know whether we are on > > breakpoint or not. If watch expressions are only applicable to the paused > > state, you should use ScriptsPanel.prototype.evaluateInSelectedCallFrame or > > doEvalInCallFrame (your watch expressions are not supposed to mutate the app > > state). > > As currently implemented, watch expressions are applicable outside of paused > states. For instance, you can bring up the Web Inspector, go to the Scripts > panel, add watch expressions, and use the Refresh key to update without having > to set a break point. Whether or not this is useful, don't know. I can > imagine it could be. I'm not sure if FB does this or not. I do think that will be useful. I will look at the patch in detail later, likely after the holidy. Can you attach a screenshot? 144960 12 pmuellr 2009-09-04 17:06:31 -0700 attachment 39058 from comment 8 shows a flat list of expressions. In that shot, you can see the disclosure triangle for "this", which is a DOMWindow, which when expanded is the same thing you'd see in the locals pane while paused, for instance. The expressions are the purple bits to the left, and are editable by double clicking anywhere on the line. Reading the manual test case in the patch might explain a little better how it works. Maybe doing a movie would be better. if I only had Snow Leopard installed!! Actually I think I have some other screen capture software. 144985 13 pfeldman 2009-09-04 23:22:38 -0700 >> I needed more behaviour than the plain old ObjectPropertiesSection had. >> I did try that first though; the watch expressions were keys in an >> object whose values were the eval()'d version of the keys. >> For various reasons it turned out to be too much work to make it all >> work in the existing framework instead >> of writing the relatively small amount of code that I did. >> I do reuse a lot of the behaviour out of the ObjectProperties code; >> and especially all the stuff underneath the roots of the trees - >> the children of the expressions themselves are >> ObjectPropertiesElements (or whatever). So each watched expression is an ObjectPropertiesSection with the watched expression as atitle and ObjectProxy value. Why doesn't it work? Try opening console and typing "dir(document.documentElement)". You'll get ObjectPropertySection formatted for the result. I'd like that code only to deal with rendering objects that came from the inspected page. InspectorController.getProperties should not be called anywhere else. Frontend is only dealing with visual representation of stuff, it should only call it in order to render the result and the renderer is already there. 144988 14 pfeldman 2009-09-05 00:44:47 -0700 I looked at the code and I think I know what you should try. Inherit WebInspector.WatchExpressionsSection from WebInspector.ObjectPropertiesSection. In the inherited class, override update() method so that instead of the original code: var self = this; var callback = function(properties) { if (!properties) return; self._update(properties); }; InjectedScriptAccess.getProperties(this.object, this.ignoreHasOwnProperty, callback); you would do something like: var properties = []; for (all watch expressions) { properties.push(new WebInspector.ObjectPropertyProxy(watchExpression /* name */, evalResultObjectProxy /* value */); } this.update(properties); This way your section will get populated with exactly what you want. Instead of property names you will have your watch expressions. They will be infinitely expandable (allowing browsing their substructures). There are couple of things to do before it works nice: 1. It will not work for primitive values until InspectorController::wrapObject is changed to wrap them. I could not do it within 2 minutes since primitive unconditional wrapping spoils autocomplete code. I'll see if I can complete it before my flight today. 2. You should render evaluation exceptions manually. 145005 15 39114 pfeldman 2009-09-05 05:52:44 -0700 Created attachment 39114 WebInspector.ObjectPropertiesSection - based rendering Here is how I would approach the rendering. It is just few lines of code and they don't touch internals / query for properties via injected script, etc. I removed all the editing-related functionality and error-handling for the sake of the snippet simplicity - everything can be added on top of this. Note that it also gives one ability to edit values in place (such as in object properties section). I will attach a screenshot with how it looks shortly. 145006 16 39115 pfeldman 2009-09-05 05:55:11 -0700 Created attachment 39115 WebInspector.ObjectPropertiesSection - based screenshot 145007 17 timothy 2009-09-05 06:42:51 -0700 Pavel's approch makes sense to me. That is how I would approch it. 145015 18 pmuellr 2009-09-05 11:30:24 -0700 Yup. Looks good! 145885 19 pmuellr 2009-09-09 11:58:36 -0700 (In reply to comment #18) > Yup. Looks good! Looked good for a minute anyway. :-) I'm finding I'm having to greatly complicate the code, including some light (but safe!) refactoring of the ObjectProperties* classes, in order to make this work. For instance, I still need the top level entries in the section to be a new class of TreeElement, but want to use ObjectPropertyTreeElement for everything below, and this will require making the treeElement constructor parameterized, instead of using the one the section says to use. I suspect, the result, assuming I can get it working, will be a little less clear as to what's going on here than the original version I wrote. Everyone ok with that? At this point, it seems like I'm purely trying to avoid using InjectedScriptAccess.getProperties(), which seems kind of silly for the effort. 145902 20 timothy 2009-09-09 13:36:40 -0700 Refactoring the ObjectProperties classes to be more flexable is the correct approch. When we get around to improving those in the future (we have some planned improvments) I don't want to do the changes twice. Refactoring and sharing now means the watchpoints will get any benefits in the future. It isn't about avoiding InjectedScriptAccess.getProperties(). 146679 21 39458 pmuellr 2009-09-11 11:42:04 -0700 Created attachment 39458 proposed patch - 2009/09/11 Refactored version of previous patch, to subclass ObjectPropertiesSection and friends rather than use it compositionally. The code is smaller than before, but less clear, as it relies on intimate knowledge superclass/framework behavior (my opinion). Two changes were required in ObjectPropertiesSection.js: - needed to allow additional customization of the tree element constructor - in this case, I needed a special class for the root level entries in the tree (the expressions), which have different behaviour than properties. This could be shaped differently somehow, haven't thought about the best way to do it - perhaps something like a Strategy object. The change I've made should make it easier for people who need a unique tree element constructor in the roots rather than below the roots. - second change was to make nameElement an "instance variable" instead of a local, as I need access to it later. As a local, the reference to it was lost after it was created. Note that StylesSidebarPane.js also appears to creates an instance of nameElement in the same vein, but that class doesn't use ObjectPropertiesSection, so there's no conflict. I saw no other potential conflcts for exposing this property. There are some comments in WatchExpressionSidebarPane.js for things that didn't feel quite right, or were working around some existing bugs. 146960 22 39458 timothy 2009-09-12 17:50:07 -0700 Comment on attachment 39458 proposed patch - 2009/09/11 > + _update: function(properties, treeElementConstructor) This optional argument should be called rootTreeElementConstructor to better match what you use it for. > this.sidebarPanes.callstack = new WebInspector.CallStackSidebarPane(); > + this.sidebarPanes.watchExpressions = new WebInspector.WatchExpressionsSidebarPane(); > this.sidebarPanes.scopechain = new WebInspector.ScopeChainSidebarPane(); Watch Expressions should go after this.sidebarPanes.scopechain, since callstack is closly related to scopechain they should be next to each other visually. > + // ideally we'd intelligently expand if we have any watch expressions, > + // but there's a timing error of some kind with the InjectedScriptAccess, > + // so forcing expanded = false, and refresh upon expansion > + this.expanded = false; > + this.onexpand = this.refreshExpressions.bind(this); I can see how this would be too early to expand, but I think you might be able to expand in ScriptsPanel.reset, which should be called at a good time. > +//------------------------------------------------------------------------------ No need for the comment divider, but I guess it dosen't hurt. > + this.treeElementConstructor = WebInspector.ObjectPropertyTreeElement; The default is already WebInspector.ObjectPropertyTreeElement. You shouldn't need to se this. > +WebInspector.WatchExpressionsSection.prototype = { > + > + update: function() Remove the extra line before update. > + // the null check catches some other cases, like null itself, > + // and NaN Just make this one comment on one line. I also find comments with a starting capital letter easier to read. > + properties.push(property); > + if (properties.length == propertyCount) > + this._update(properties, WebInspector.WatchExpressionTreeElement); And extra line before the if would help readability and separate things. A comment before the if would also help, it took me a bit to undertstand, I had to find the other comment later when you are setting propertyCount. > + for (var i=0; i<this.watchExpressions.length; ++i) { Need spaces around the "=" and "<". > + for (var i=0; i<this.watchExpressions.length; ++i) { Ditto. > + WebInspector.console._evalInInspectedWindow(expression, appendResult.bind(this, expression, i)); You should make _evalInInspectedWindow public. I would recomend moving it to inspector.js can calling it WebInspector.evalInInspectedWindow. That is where it should have been all along. > + this.expanded = (propertyCount != 0); I don't think you should do this for every update. I think expanding once when there are expressions to show is fine, but I don't want this pane to auto expand all the time when stepping through JS. Wack-a-Mole is not fun when you can't win! > + _displaySort: function(propertyA, propertyB) > + { > + if (propertyA.watchIndex == propertyB.watchIndex) > + return 0; > + else if (propertyA.watchIndex < propertyB.watchIndex) > + return -1; > + else > + return 1; > + }, This function looks unused. Remove. > + // unpretty code here; nowhere else do we drill down > + // into tree elements, but we need to do it here as > + // the newly added element needs to be added to the > + // tree BEFORE we start editing it. This comment isn't helpful. The code is fine. > + for (var i=0; i<children.length; ++i) Need spaces around "=" and "<". > + if (!window.JSON) > + return []; When will this fail? Can be removed. > + } > + catch(e) { This should be "} catch (e) {". > + if (!window.JSON) > + return; Ditto. Can be removed. > + for (var i=0; i<this.watchExpressions.length; i++) Need spaces around the "=" and "<". > + } > + > +} Remove the empty line. > + var deleteButton; > + deleteButton = document.createElement("input"); Can be combined onto one line. Also "button" elements are better to use. > + if (this.property.name === "") > + this.nameElement.textContent = "\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0"; Why do you do this? If my guess is correct, I think a single (normal) space will be fine. > + WebInspector.startEditing( > + this.nameElement, > + this.editingCommitted.bind(this), > + this.editingCancelled.bind(this), > + context); Just put this on one line. Wrapped function calls are annoying to read. > + if (expression === "") > + expression = undefined; It is better to use null than undefined. But why do you even need this? Testing !expression is true for "" as well as undefined and null. > + }, > + > +} Remove the empty line. > + background-image: url(Images/errorIcon.png); I don't think errorIcon is the best thing to use. You should add a FIXME comment and file a bug requesting new art and assign it to me. This patch is much nicer than the earlier version! Viva less code! 147043 23 pmuellr 2009-09-14 06:41:38 -0700 (In reply to comment #22) > Watch Expressions should go after this.sidebarPanes.scopechain, since callstack > is closly related to scopechain they should be next to each other visually. Actually, I'm wondering if it should go BEFORE scopechain (callstack). Rationale would be that while Call Stack and Scope Variables grow and shrink, sometimes wildly as you traverse around your code (step/go), Watch Expressions grows/shrinks at a user-controlled pace - and probably not at all in most cases. This would provide some stability to the location of the pane, especially if it's something you're watching closely. In terms of the space it eats, my intention was to have the Watch Expressions pane only be expanded upon opening of the inspector if there are actually Watch Expressions in the list. If there are none, it should open in expanded=false mode. So if you're not using Watch Expressions, they only eat the section header in terms of vertical space. > > +//------------------------------------------------------------------------------ > > No need for the comment divider, but I guess it dosen't hurt. Woops. This is a personal coding style of mine - I put these comment dividers in front of every function to help break the code visually into distinct chunks. Will remove, unless we're going for a new coding style :-) > > + WebInspector.console._evalInInspectedWindow(expression, appendResult.bind(this, expression, i)); > > You should make _evalInInspectedWindow public. I would recomend moving it to > inspector.js can calling it WebInspector.evalInInspectedWindow. That is where > it should have been all along. I agree this API needs to be made public and moved somewhere else. But I'd like to do it in a separate patch: - I would need to patch ConsoleView.js which otherwise has nothing to do with this patch - I'd like to actually step back and see if we can find a good home for all these target-introspective APIs. Putting it just on WebInspector itself probably doesn't make too much sense - perhaps a new class called TargetMirror or something? > > > > + this.expanded = (propertyCount != 0); > > I don't think you should do this for every update. I think expanding once when > there are expressions to show is fine, but I don't want this pane to auto > expand all the time when stepping through JS. Wack-a-Mole is not fun when you > can't win! This isn't the pane expanding, this is the treeoutline inside the pane expanding. The problem was that if the list of Watch Expressions is empty, but the Watch Expressions pane is expanded, you get a free 25px or so empty vertical space. This hack defeats that. But it was a bit of a hack, from memory. I believe the existing panes (Call Stack et al) don't run into this problem, as they all have a "No [whatevers]" tree element they add when their list is empty. Now that we have the ability to add "menu buttons" to the pane headers (like the Styles header), perhaps the best thing to do is to move the buttons in Watch Expressions to new buttons in the header, and then provide a "No Watch Expressions" label like the other panes. If so, I'd like to do this in a separate patch, as it's not immediately clear to me if we would want two header buttons, or one 'tool' button with two drop downs, or something else. > > + _displaySort: function(propertyA, propertyB) > > + { > > + if (propertyA.watchIndex == propertyB.watchIndex) > > + return 0; > > + else if (propertyA.watchIndex < propertyB.watchIndex) > > + return -1; > > + else > > + return 1; > > + }, > > This function looks unused. Remove. The hidden pain points of dealing with subclassing. This method is used by a superclass. If I deleted it, the Watch Expressions would be sorted alphabetically (or something - it would assume the expressions are property names). I'll make this method "public" in the superclass, rename it to something better - comparePropertyNames?, and add a comment in the Watch Expressions code indicating that this is used by the superclass. > > + // unpretty code here; nowhere else do we drill down > > + // into tree elements, but we need to do it here as > > + // the newly added element needs to be added to the > > + // tree BEFORE we start editing it. > > This comment isn't helpful. The code is fine. I happen to disagree, I find the code rather icky. But it was a bit of a passive/aggressive comment, so will delete :-) > > + if (!window.JSON) > > + return []; > > When will this fail? Can be removed. The original code was written when window.JSON wasn't always available! Will remove the checks. > > + if (this.property.name === "") > > + this.nameElement.textContent = "\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0"; > > Why do you do this? If my guess is correct, I think a single (normal) space > will be fine. I'm curious what your guess is. Using these non-breaking spaces allows for an obvious visual selection box when a new Watch Expression is added. A single space yields a text box that's so small you wouldn't even know you can edit text in there. If there was a way to css this issue away, that'd be great. Something in the WebInspector.element editing protocol that would set an initial interesting horizontal width when the initial element contents are empty. Beyond my css-foo though. The way it works now seems pretty pleasing to me. You start with an "interesting width" - maybe 5-7 char wide text box, selected, which makes it pretty obvious where to start typing your expression. As you start typing, the initially selected nbsp's are replaced with the user-entered contents. It might be a little clearer to make the entire horizontal line selected during the entire edit, but I don't have a clue how we'd do that with the current element editing framework. 147090 24 timothy 2009-09-14 10:15:42 -0700 (In reply to comment #23) > (In reply to comment #22) > > > Watch Expressions should go after this.sidebarPanes.scopechain, since callstack > > is closly related to scopechain they should be next to each other visually. > > Actually, I'm wondering if it should go BEFORE scopechain (callstack). > Rationale would be that while Call Stack and Scope Variables grow and shrink, > sometimes wildly as you traverse around your code (step/go), Watch Expressions > grows/shrinks at a user-controlled pace - and probably not at all in most > cases. This would provide some stability to the location of the pane, > especially if it's something you're watching closely. > > In terms of the space it eats, my intention was to have the Watch Expressions > pane only be expanded upon opening of the inspector if there are actually Watch > Expressions in the list. If there are none, it should open in expanded=false > mode. So if you're not using Watch Expressions, they only eat the section > header in terms of vertical space. Before seems fine too, but the main part about the Scripts panel is the debugger and those two panes. But not shifting too much is always good. > > > + WebInspector.console._evalInInspectedWindow(expression, appendResult.bind(this, expression, i)); > > > > You should make _evalInInspectedWindow public. I would recomend moving it to > > inspector.js can calling it WebInspector.evalInInspectedWindow. That is where > > it should have been all along. > > I agree this API needs to be made public and moved somewhere else. But I'd > like to do it in a separate patch: > > - I would need to patch ConsoleView.js which otherwise has nothing to do with > this patch > > - I'd like to actually step back and see if we can find a good home for all > these target-introspective APIs. Putting it just on WebInspector itself > probably doesn't make too much sense - perhaps a new class called TargetMirror > or something? Either make it public and leave it on ConsoleView in this patch or move it to the WebInspector object. I don't want this to land with a private function being used. Feel free to file follow up bugs to give it a better home, but this can't land until the underscrore is dropped. Don't feel bad about touching ConsoleView.js. > > > + this.expanded = (propertyCount != 0); > > > > I don't think you should do this for every update. I think expanding once when > > there are expressions to show is fine, but I don't want this pane to auto > > expand all the time when stepping through JS. Wack-a-Mole is not fun when you > > can't win! > > This isn't the pane expanding, this is the treeoutline inside the pane > expanding. The problem was that if the list of Watch Expressions is empty, but > the Watch Expressions pane is expanded, you get a free 25px or so empty > vertical space. This hack defeats that. But it was a bit of a hack, from > memory. I believe the existing panes (Call Stack et al) don't run into this > problem, as they all have a "No [whatevers]" tree element they add when their > list is empty. > > Now that we have the ability to add "menu buttons" to the pane headers (like > the Styles header), perhaps the best thing to do is to move the buttons in > Watch Expressions to new buttons in the header, and then provide a "No Watch > Expressions" label like the other panes. If so, I'd like to do this in a > separate patch, as it's not immediately clear to me if we would want two header > buttons, or one 'tool' button with two drop downs, or something else. I see. Yes, this would be a better UI. Fine to fix in a follow up patch. > > > + _displaySort: function(propertyA, propertyB) > > > + { > > > + if (propertyA.watchIndex == propertyB.watchIndex) > > > + return 0; > > > + else if (propertyA.watchIndex < propertyB.watchIndex) > > > + return -1; > > > + else > > > + return 1; > > > + }, > > > > This function looks unused. Remove. > > The hidden pain points of dealing with subclassing. This method is used by a > superclass. If I deleted it, the Watch Expressions would be sorted > alphabetically (or something - it would assume the expressions are property > names). I'll make this method "public" in the superclass, rename it to > something better - comparePropertyNames?, and add a comment in the Watch > Expressions code indicating that this is used by the superclass. I see. Yes, make it public. The "comparePropertyNames" name is good. > > > + if (this.property.name === "") > > > + this.nameElement.textContent = "\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0"; > > > > Why do you do this? If my guess is correct, I think a single (normal) space > > will be fine. > > I'm curious what your guess is. Using these non-breaking spaces allows for an > obvious visual selection box when a new Watch Expression is added. A single > space yields a text box that's so small you wouldn't even know you can edit > text in there. If there was a way to css this issue away, that'd be great. > Something in the WebInspector.element editing protocol that would set an > initial interesting horizontal width when the initial element contents are > empty. Beyond my css-foo though. > > The way it works now seems pretty pleasing to me. You start with an > "interesting width" - maybe 5-7 char wide text box, selected, which makes it > pretty obvious where to start typing your expression. As you start typing, the > initially selected nbsp's are replaced with the user-entered contents. It > might be a little clearer to make the entire horizontal line selected during > the entire edit, but I don't have a clue how we'd do that with the current > element editing framework. My guess was what you described. It would be better to do this with CSS. Settign the width of the element to be 100% should work. Maybe you can make new (empty) watchpoints have a special style class that you can use to control the width. 147360 25 39610 pmuellr 2009-09-15 13:05:18 -0700 Created attachment 39610 proposed patch - 2009/09/15 All the suggested changes were made. Additional things: - I had to move the displaySort business around - turns out I wasn't sorting the properties inside the expressions themselves in the WatchExpressions correctly. To get this to work right for all the ObjectProperty* bits, the functionality was moved to the tree element prototype. The sort logic itself was unchanged. - the callback in ObjectPropertyTreeElement.onpopulate() wasn't working correctly, but I couldn't figure out why; changed from using the "self = this" type of closure reference to bind(this) on the callback, which worked fine. - had to make the ": " element in the property items a span itself, so I could hide it during edit - changed the edit code to use css to turn the name span into a block element with width:100%. Looks better. No nbsp hacks! 147434 26 39610 timothy 2009-09-15 17:55:06 -0700 Comment on attachment 39610 proposed patch - 2009/09/15 > + properties.sort(rootTreeElementConstructor.prototype.comparePropertyNames); This should just be rootTreeElementConstructor.comparePropertyNames, to allow instances to override the prototype. > + if (property.name === " ") Maybe everywhere you check for " " you should just trim whitspace (String.trimWhitespace in utilities.js) and look for "" or !property.name? I would r+ this, but I would like to see the prototype thing fixed, even though it isn't an issue today. 147448 27 pmuellr 2009-09-15 18:41:07 -0700 (In reply to comment #26) > (From update of attachment 39610 [details]) > > + properties.sort(rootTreeElementConstructor.prototype.comparePropertyNames); > > This should just be rootTreeElementConstructor.comparePropertyNames, to allow > instances to override the prototype. Whats uber-confusing about this, is that the sorting takes place before passing the names to the class which is going to handle them. And it needs to be inheritable, so that ScopeVariableTreeElement picks up the default from ObjectProperties, but allowing the root collection of WatchExpressions to do something different. Took me a while to even get it to work correctly in all cases with this scheme. Let me noodle on this a bit more, clearly the code is more complicated than it should be. It might well be that making it instance-based customizable is actually the simplest thing to do. > > + if (property.name === " ") > > Maybe everywhere you check for " " you should just trim whitspace > (String.trimWhitespace in utilities.js) and look for "" or !property.name? > > I would r+ this, but I would like to see the prototype thing fixed, even though > it isn't an issue today. I'm down to using a single " " character as the signal for "this is a newly added element which needs to be edited". Empty space, or actually, as you suggest testing for (!whatever) is used everywhere else to signal "this item needs to be deleted". A little confusing. Since I don't really use the " " character productively (or don't need to), I'm thinking maybe I should making this some kind of non-string constant that I check for, just to make this more clear. 147540 28 39648 pmuellr 2009-09-16 09:13:58 -0700 Created attachment 39648 proposed patch - 2009/09/16 Since the previous patch: - element added when user selects "Add" now uses a 'constant' for the name, WebInspector.WatchExpressionsSection.NEW_WATCH_EXPRESSION, rather than just " " as a special case, to make things a little clearer. The value has also been changed to "\xA0", which works as well as space where it needs to (evaluates without issues, is stripped with trimWhitespace(), etc), and is less likely in negatively interact with functioning in the future if for some reason someone wants to use " " for a valid or special purpose in the expressions. - WatchExpressionsSection.update() was previously calling ObjectPropertiesSection._update(). I renamed the _update() method to updateProperties() in all callers and the single implementation, to make it public, and make the name a little more obvious. - property compare has been jiggled around. It's now available as a 'class property' - WebInspector.ObjectPropertiesSection.PropertyComparer for ObjectProperties* stuff, and WebInspector.WatchExpressionsSection.PropertyComparer for Watch Expressions. The reason it can't easily be just a regular instance method, is for two reasons: - it's not an instance method, it's a function - it doesn't get called with a this. It would be confusing to have it as an instance method (function on a prototype), since there is no reason to ever call it that way. - it's used in two places in ObjectProperties*; once in ObjectPropertiesSection to sort the top level list of properties, and then in ObjectPropertyTreeElement to sort all the further nested properties. That second one needs to reference the comparer function somehow. It's very confusing to sort out how the second reference should be obtained, programmatically, as the hierarchies get tangly, and most confusingly, the properties are sorted before being handed off to the element tree constructors (which is one place you might think to hang this function). To make things a little more straight-forward, what I've done is added the comparator functions to the relevent section contructors as properties (not on the prototype, just properties off the constructor), as mentioned above. I've then added a further customization parameter in the top-level element building function in ObjectPropertiesSection, now called updateProperties (see above), to take an optional comparator. This will default to use the version in ObjectPropertiesSection. WatchExpressions will pass in an override. In the second use of the comparator, in the ObjectPropertyTreeElement, I've hardcoded the reference to the ObjectPropertiesSection, since today that's all anyone uses. I think the result is fairly easy to understand. It doesn't neccessarily feel like the best shape, but I think that's largely because the ObjectProperties* class hierarchies are getting a bit convoluted in general. It was the most natural thing I came up with. If we need to extend them further, it might be time for some more serious refactoring. 147545 29 timothy 2009-09-16 09:25:35 -0700 (In reply to comment #27) > (In reply to comment #26) > > (From update of attachment 39610 [details] [details]) > > > + properties.sort(rootTreeElementConstructor.prototype.comparePropertyNames); > > > > This should just be rootTreeElementConstructor.comparePropertyNames, to allow > > instances to override the prototype. > > Whats uber-confusing about this, is that the sorting takes place before passing > the names to the class which is going to handle them. And it needs to be > inheritable, so that ScopeVariableTreeElement picks up the default from > ObjectProperties, but allowing the root collection of WatchExpressions to do > something different. Took me a while to even get it to work correctly in all > cases with this scheme. > > Let me noodle on this a bit more, clearly the code is more complicated than it > should be. It might well be that making it instance-based customizable is > actually the simplest thing to do. All I was saying is that you should be able to just change it to rootTreeElementConstructor.comparePropertyNames and it will just work. I don't see the problem where the instance hasn't been told about the properties yet. This function is designed to not need internal data. Just like _displaySort was. All you needed to do was rename it. > > > + if (property.name === " ") > > > > Maybe everywhere you check for " " you should just trim whitspace > > (String.trimWhitespace in utilities.js) and look for "" or !property.name? > > > > I would r+ this, but I would like to see the prototype thing fixed, even though > > it isn't an issue today. > > I'm down to using a single " " character as the signal for "this is a newly > added element which needs to be edited". Empty space, or actually, as you > suggest testing for (!whatever) is used everywhere else to signal "this item > needs to be deleted". A little confusing. Since I don't really use the " " > character productively (or don't need to), I'm thinking maybe I should making > this some kind of non-string constant that I check for, just to make this more > clear. Yes, using a named constant is good. 147547 30 39648 timothy 2009-09-16 09:46:43 -0700 Comment on attachment 39648 proposed patch - 2009/09/16 > +WebInspector.ObjectPropertiesSection.PropertyComparer = function(propertyA, propertyB) WebInspector.ObjectPropertiesSection.CompareProperties would be a better name. PropertyComparer sounds more like a class name. > +}; No need for the semicolon. > + > WebInspector.ObjectPropertiesSection.prototype = { The compare function you added should come after the prototype, so the prototype and the constructor are next to each other. > + updateProperties: function(properties, rootTreeElementConstructor, propertyComparer) I think propertyComparer should be rootPropertyComparer since it is only used for root items. > +WebInspector.WatchExpressionsSection.NEW_WATCH_EXPRESSION = "\xA0"; This should not be all caps, it should be camelcase. > +WebInspector.WatchExpressionsSection.PropertyComparer = function(propertyA, propertyB) Ditto (re: the PropertyComparer name) > +}; No need for the semicolon. You also need to add WatchExpressionsSidebarPane.js to the inspector/front-end/WebKit.qrc, WebCore.gypi and WebCore.vcproj/WebCore.vcproj for the other platforms. 147549 31 timothy 2009-09-16 09:51:39 -0700 (In reply to comment #28) > - element added when user selects "Add" now uses a 'constant' for the name, > WebInspector.WatchExpressionsSection.NEW_WATCH_EXPRESSION, rather than just " " > as a special case, to make things a little clearer. The value has also been > changed to "\xA0", which works as well as space where it needs to (evaluates > without issues, is stripped with trimWhitespace(), etc), and is less likely in > negatively interact with functioning in the future if for some reason someone > wants to use " " for a valid or special purpose in the expressions. This is fine, but we don't use all caps. Should be CamelCase. > - property compare has been jiggled around. It's now available as a 'class > property' - WebInspector.ObjectPropertiesSection.PropertyComparer for > ObjectProperties* stuff, and > WebInspector.WatchExpressionsSection.PropertyComparer for Watch Expressions. This is a good solution. > It's very confusing to sort out how the second reference should be obtained, > programmatically, as the hierarchies get tangly, and most confusingly, the > properties are sorted before being handed off to the element tree constructors > (which is one place you might think to hang this function). It could be passed to the ObjectPropertiesSection constructor to store and hold. There is a argument on the constructor already for the tree element constructor. > I think the result is fairly easy to understand. It doesn't neccessarily feel > like the best shape, but I think that's largely because the ObjectProperties* > class hierarchies are getting a bit convoluted in general. It was the most > natural thing I came up with. If we need to extend them further, it might be > time for some more serious refactoring. The solution is good. Better than it was before. But I don't see what is wrong with the class hierarchies. 147584 32 39657 pmuellr 2009-09-16 12:32:10 -0700 Created attachment 39657 proposed patch - 2009/09/16 - 2 all issues fixed. I didn't actually test the gypi, vcproj or qrc file - I'm getting set up now to build on Windows (dusting off a dusty ole box). 147594 33 39657 commit-queue 2009-09-16 13:16:14 -0700 Comment on attachment 39657 proposed patch - 2009/09/16 - 2 Clearing flags on attachment: 39657 Committed r48431: <http://trac.webkit.org/changeset/48431> 147595 34 commit-queue 2009-09-16 13:16:21 -0700 All reviewed patches have been landed. Closing bug. 33275 2009-07-22 11:26:58 -0700 2009-09-04 08:25:21 -0700 mock up of watched expressions UI watched-expressions-mockup.png image/png 32853 pmuellr iVBORw0KGgoAAAANSUhEUgAAARwAAAEWCAYAAAC0byiGAAAgAElEQVR4Aex9CWAV1dX/L2TfE7ZA CEuAELawhCWo7KJQQUFxqQu2aO2n1Vqxtlrbr4pt/37q1/ZT27rVYq0ILigIKLsoQfawLyEEQkgC 2cielz3/c2beeblvMi8vgSQszoXJufee9Z6ZOe/OnZkzHnBdPBSUWle6Yew3tlVaq255wPLAleuB eoPpxrag1X61ruFdBQi1X+oCRbCxzf1mfU3RC86ClgcsD1x6DzQKEIpJZjhjn7QFMrtaNw0QEjSM kJmlz1iXNuNVGu63iuUBywNXtgc4aMimjkQNJmZ16RPYKDhIsHAFWZmK47q0BSdtgdLP0CqWBywP XN4ecAQHMlPqDKXO1ktb+gQKziU0BoXmtJlG6KQukBVJXWi4j4uxrfdafy0PWB64XDygBg62ySyw NKdP5ZWxaXxe0jJANThIvQPRGOvclo3xXKQttAJ1bIMMaVvQ8oDlgUvrAbNAwxYZg0udoY/x3Mfn uNSpqtUZSj/XtSLBgKFZnYkk0DCe61p73759xYy0Svt44OTyX+K25zc6lF37+Dt467Fr0KGDH1KW PI85//2BHTcVH237C4bUHsZ/jb8XW6l3wC0PIi7lXSwLWojv/hGHF8b8Lx7c/g/E+DGLB4KCyrGE ZP33Gl3E2Gc+wts/7I3Vj45D6S+34q6+gUD1SfyM+BY4+HRa/tuUbUfeexp3/HGZXfDvse3t25C3 +mf4delTWHJXX72/6iR+PfYVPLjtDcR6ncTTY25D/Q2xWLc+WcM//u9teHx0AEprPHHyk6dw2x/J 0Ck0lpfi8OLY27BSl4K5f1iOP8zugyo+BazSbA/85fnr0KVjB3h6esDLE7R5UL0BdqAz3rMD9RHk ugdFAoaPLiwIISUSaNRgpO4BCVpsT71ZoJHAwwRcJ9Ua5Dqp0TcKOAVUt0o7ecAvrAsC620oK6sA /AIR4lOH/PMlqKXdERDWEf71FaisBXwD/VGem4sKryB0CfZEeSUQ6O+FurpK2KrrUV5ah05dglGW m4NyOSw6+CKsUxjqbWWo9fRFgEc5cgorEda1CzxK8lBgI8Ed/NGV+EpVPvvYm7ItMLwT/OpsZJsn AgM8kJtTCJ+wrgj1KEF2gU2X4OGHLl1DNNm2Sg5sf8bvUz/FkPoyVHoGwqeuEOdLaCB0GAaEd4Z3 XZV2FJYUVdJYQlFVptvt72FDXmG54+e1nXbNFa/mIgJOOA2ejyLZJLjQAeO0G6S/Xi6p1MAjDpQA o0Kml6AjdBZsBw9UFOaikn5WOvBPS3kJcihw6KUO5YV5sFE/76iy0lJ9T1eVIuc80VNnKdN6cL2e Ak89crPtJ7rYTcGoMDdbl40ylBINl8KcbKGgQ8qGHCOfHduUbWUFuSi326bZQTwVhTmgsNlQKFjm ZktPDQpwHsVkz/kAHlMp2SOkFDBJnuaD+jqwmcyntRW7hdqCbe4BjgcSbGqozgcOtzlGMNQPJKpQ 4cMTzKBVuEFF6gyZSSDXeabDm9SpapX29EB9XR1qaTMrjFP3rkZjPykb1c0EUF+dC9kuyJ26W2yb E7fS8B2BL0+shK28lC6NTMZEpEY7jW1FmlVtWw9w/ODZjMQNrnPhQ1ENOozXDk9mkCJM3JZgowYY CTjM41lf3+jwFjkWtDxw4R6oLUNxuSfqa+sbB9ALl2pxto0HvEksxwqe3RgLBx/GSRDSgo4EHDXY cJ03NehwsNECjR2yIqtYHmgTD9TVyjHaJuItoa3nAR8SVW0Xp8YQdYbD/TI78ZCAIyZIoOE2Bxx1 46DDgYZ5rIBDTrCK5YHvuQckDkiwkXUbjhtcGq3nSMARBoYSdAQys3o5xUp8Fi5cSMAqlgcsD1zp HuB72xdYeIYjhYOLGnDMZjlOMxwJNizAOLPhwCQzG1bis2yZ/dkKpr6I8uGHH+Lee+9Fe68JedDD BLt378bo0aMt3Rex/1rCKj4fNWpUS9gs2jb2wPy5FxxyjAGHgwxvEnikLrFFuy3ODbVIm6EEHlnD cQSd1g4QrS1PHZBZnQ9+KZZu8UTbQvF5e/u7bUf1vZbOAUeCCi+8caCRxWKuc+ETjWm0wgFEzjyG snGg4bpcSglsk4DDB2B7H4SiUyCNtd2K6BTYbopJkegUeKl0t6deS1ebeYADjgQZvlMlcUL6OI5w XeKK04N/1K8VCTYCmZjrHGxk8+YDtjVLa8trjm2iU2BzeFqLRnQKbC25zZEjOgU2h6e1aFjnpdDb WvZbcpw8wOu5HGgkLnBdgosEG4HM2GgNhzu5qExyOSVQm+W05kFzKQ5C0SlQH3b7/BWdAttHq65F dAq8VLrbU6+lq808wAGHb4tzTJD4wEGHL6skhlBVK9x2zHDsfU5EwiAzHZkuadGMD9jWLK0trzm2 iU6BzeFpLRrRKbC5cj///HN89tlnGvmzzz6LQYMGNZfVQSc6BToQbirl5eV47rnnNCq+SxkQEOCG ozGadbZUb2MpVs9l4gGZ2Uhs4Jgh8YLrXCSOaAGDGaQIQqAwMmSBApsMOOvXr8cNN9ygyXRVF4UC L8VBKAd9S3TzCbd27VokJSXh9OnT6Ny5M/iOy6233tqik+9CdIuv1Mf4uS6yBO8OCn1Lxs0yeezP P/880tLSNBUceLjdkqCj6taEWH/ayAOlOLQzBRHxI9FFPcNbX5sWC0isGh/UuCGxRKA2FTIzQwiE mduqUE/1wFcF8EHlSe+2V1dXayeDWV2l5zrzuJJnpP3mm2+wefNm9OnTBz/60Y/wxhtvaLAlB76q s7m6OcC8/vrryKU3seVuC9fXrFmDLVu24Omnn8aZM2eQmJiIZ555xmi2U1t0CnRCumkwj5QL5ZdA 1Vyfc7B54YUXHMGG9XPg4YDz+9//vtlBR+xtrl4Z5xUJK/bhwU7XYand+FlPvYn/++956N62AUDX VnoYYyZNxvrsMnQKalPvycxGJiNmccPJAOPwhYEhF2lL4HEEHfXA10n1v9zvblPppe5KnuAFZmdn 4+jRo1qTeTgA7dq1Sws6EydOFLJmQdEp0BVTXl4e/ud//kf7ledg06tXL+0k4xMxPT2dUkaUafjY 2FgcOXKkWbMO0SnQlW7uFz1cZ1uksG4pYpO0m4KiU2BTtBJsOOAaCwcdvrRqadBpjl6jriuuTcdm FoZi9anNGF6wCffE34klM2dhwZiwth+Krz9mYSK8tHOxTdU54gFp4VghccIYP6TtmOFIhwq5rm4i jKHblzfVg8pVneRohfEqjfSbQaFTefik4JnO119/jYcffhhdu3Y1Y3XqE36BTkhD45133tFO+t69 e+O+++7DwIEDHRQ8o3n77bc1POUI0lIliI0OIkNFdAo0oBs1eUawdOlS7TJORfJDkxwA2a6nnnqq WT4UnQJVeWZ11v3AAw9osk+dOoV///vfGtmkSZMwZcoUTT/TsDx3RXQ2h9adrMser/mD8hT5+SI0 5gbMHQoUU1/q6hcx/K4/aebP+u3nWPTMNPjRbOgXjx3Cn/55H4IoHcfHP7kLpQs+wgNDgrDvg2cw 4ZG/a/Svbj+r9eXt+xg/mvAgvqXe3360H8/c1Jdqhfj4mR/gwb8f0mhBIedp7byyN9sGSMDhOCHx QY0ZXOfigMYZjo52/qsKYKGa4JKSEmcqe8tms6GqqgqMd1U3Mgq9sd+szbRcaukFP6MNx44dwxNP PIGZM2filltuMWN39AUHB2tBwp3uHTt2gOXyes2TTz4JLy8vFBQ05B4bPnw45s+fj0WLFjlkG+1y IOyV5upW+RYsWIA///nP2mWb9HOw6dmzJxjHJ707vcx3Ibp79OihqSylXDtSQkJCEBUVpTXN9oXQ qVB0N8dOle+KrFeU0/3iXOSdO4eDR/6NX1AceCeomnL4TMR3KY+iT8XXiIx7Fjt+nIB4FCHrQCYK 6Zypp7w+WQe+RWVRIUpyD+BpCjbv7TyJG8PLUORZjZKCvXiEgs1d353EUv9vETnyEUw8+Sm6fvsb PLhpDnae/BLY/2+MvfUrFJWWoMT978DFuJdjgyMmUF1ihUuZZgHHEY0UASJIICu5bIu3N9+ta51y 9uxZbdbCv/J8gvPJxZdxXMaOHaut3fAvtp4EqnV0mklh3b/85S+dgg4HG+5jXFsWHjMXdWbCAU76 21L3lSy7O47izpExNIQZ+OvnOzEzinO6xuBo4mq8u4uPod7KW9C+jqHy03Sc3xB+vfCDa4Ef/+j3 eOeVxzEzvhNq0pKxhlCdl7yBtIqTVCtAdW0N9m/4AHMf+w5RfnRKj7oW1+IrltDWRZt8kBKJC0bI +p0OTrOAI0QqoVGQimP6y6Lwpc4jjzwC/vWVmdDFGnbXXXdpl1E8W+MTjG9J86I1l5SUFMyePVur t8cfNeiwvvYINu0xrqtVx1k67T8/+ikSQmWE+fjH9XFYNv6veGX2NRj0ymJHbgd7iCFCvkqREooH lx5E3yVv495ZYzH379/if/qfI+QMTJo+Dd2Je9Jsf/TzrcTePUDkLcHC2F6wqbggOCdbXAUcITJj MusT+ksC/f39MW/ePIwfPx4VFRWtFmx4MJWVldomA8vMzHTMKDgI/eAHPxCUA7ZWsHMIVCoSdLir rWc2ilqtyjOq3/72t1o9NNRxFhnJrLbiAW/1DCs7jWV0v2PhZ3chvmQ1zX8aLs1PH12GY0U/RY+k N/A00fyBZdSUISPfD1Pm/QZrSzZgeloxXqcpzwz8N05Xv4KZCZ2IpoLyV/th7NxBmP6vDfjZ+LuQ u2k5viP21pvnKwNyrprFArM+B5fqDkfn5VzhtRSeycj6wfTp0zF37lztVjwHgLYu06ZNw4kTJzQ1 I0eObNXg1hzbeU2JH/7j8thjjzn80Bzei6XZu3cvPv74Y00ML1JbQce9R51O+sBYPHbfINw5KBK4 di7mDjqKWT//CCn/mox7ZhzFrYN60eTlPgooXOjUrDmJ34+crl1CEQP+vrEfXWaF4pW1f8Wd0+Pw R41uBtam/AsxtyzE3D/eiUGRC0BPgxKmt4a93P5wNOKgIws/XOeN/cQXlXw5yRee/rTRt0IcW1BW VlbDKikh1MKLg7Iw6Kou9Bs3bsScOXMc9NLvCvKiLa/R8BoCzz58fX2dZiCu+Iz9bNfWrVtx3XXX NVs3y+DninhGxYX18/NGLS0Xqpv1PP/88zh//rymsn///nj88cdbpP5idP/mN79x6I6JidHujLVE uegeNmxYS9iuOlqehfv58WlVgbIKLwTyugstMZeVVSIwkE8ztdSggvoJoZ2IDRjiLaulr3QEaies 3u9KRgOXWe2Zn8Vc6Gdi5pM8vpNQpmz8q88Z8fnuDi9F8QnCrzvwVscjbU7hwCSlySkTE0mwaaou wloKa2pqwJsUPunbs/A6jnq3pj11sy5+3kbukvFsrz0L65Zg16VLl/ZUfVXp0oMND8mPgo0MjQJP oNnp6EVfBTLrJ15jbKLQYy5DdLQ6NMYCNU6YKjMbiSmh1Xl5eICfrpZF68mTJ7erUT/96U/Br6tw kddX2tUAS9kV74ELDThuI9kV75nLdAB8SScL1W25OG02fNYtzze1t24ze6y+S+6BFseBCw04l3yk 32cDLuXJfil1f5/3+dUydl4storlAcsDlgfaxQNWwGkXN1tKLA9YHmAPXPAl1YEDB1rNg3x7+lIV S3f7e741j532t97SeDEeuOCAww/cSVm+fLn2PErHjh21Fzb52RR+CpZv//n4+GjPzTCUOi8+8u1l flCPc8rwszBWsTxgeeDSeODDN9tP7wUHHNVEfhiPUyRER0drLzHywiI/q8JpI/ilRg40/ICeBB0J OJxHJjk5GcXFxao4pzoHLn5p0NVj/IJTXyx0EtDChlFfa8tvoTnauMUGM17BWeNvndeiv+/73+wY a82+Vgk4HEA4sKjBJSgoCEVFRVrg4SeDGceBiTem5x3LkAs/NewqoAiOoVlhPqExw7vrM56wxgOO +S/mZDbKN9pjpk+lkbFZ47f2v3pcSL01jn+R1R6wVQIOD1ot3OYAw4+y8yxGgg0HGA443OYTUQIO 87o6qV31iz7BC5R+1NpQXKa/duBJAc+PXkdQ38N10Cm6z6fswb4zlYgelYDoUE8Y2yqPWq+1laGs upbGQ3oCG+tpZJvCLDiBCkqv1hZj3449KPKKwrixMdq7JiqN8AlUcc2tq7xSF9hcGU3RNSVLcALN 5DQH1xSNmUy1T+WVukCV7kLrTckSnEAzHc3BNUVjJvNS9bVKwJEZCwcaNfjIzIYDjOAkGHEfb1zY WWYO4191/qTwuHHjtEf6hZZlCL3UGeqlDIe/Xo2v9qTb2wK6UL6QH6GPr355ZsZflrETe/aUorbP MPQJCYSxLZIaYBmSVi7BpuTChq7AUXjskSnwpTGZFaO9bIf0mdJX5WHb1t0o8fXAqDH9tbSRKr3U GTanGPW1lN+dDqN8I71R38XSG+UZ9RnbRn0t5TfKM7aN8o14o76LpTfKM+ozto36mL89S6sEHNVg GRD38WA4sTi/6CcBhvtkk4Ajlw3MI/wMeePLMv5SAq8PJSQkgC/VVHqpM+R3xra//wa+47S/vlGY c8/NiA7zQmHeGezfmYUAT6ZxvgRT+b3pTVx+F83PT6cxtgnpVAoOrNOCjW/UBNx/x2h4FZ7CoRTa gWRLTfYu/GPxFgTG34EHJvd08PGYuAhkX4gN0s99gq/39EMIIUpC/ECZ69mpTvTCq4+fJTRdjPpa yt+0dB0rtpvRCk6g0R7udxq/G3+11H6jvpbym43J2CdjM/ZzW3ACjfZcivGb2dlWfa0ecNiBUnJy crQ3sjmNAaep5ADDeNmEjqHsAGNdaDifbkZGBjglxODBgx2zI3WHVWXt0YMNovDIcwsQWVmIipp6 hPTrioHDxqEk+ywOfPMVNu47TpdALNkbfcf8ALPG99MutyjE6erkIHe0G+xjfXJQVFTZ02EEBCOM vtHkFzIKNw2oQ37mEXxMwYZVFB5egdeTIzB7/u2ILD2C5Z9sQrr9Ui+sezxmzp2MCHonn2VmH0nE 2i17kWfH953wQ8weIY9K6QG4rugEPl36FWpif4AfTuqn+VJOGjZebBN/qvYyXmgZShFabhvp3ckz 4kWmK2gmn2lVG4x14VHphIZxMibBq/RSZ8hFaK3xN+x/zTHt9KfVAo4cAKrd27Zt0w6k3bt3IzIy 0nFQGWn5FrkcECo/HxRygDAPvxnO+WCOHz+Oa6+9FhEREU4ys+1fMQgddyM65Z9Bvp4Zk0SWglLE UqnC+YxziBo/B9f28cLuVZ/i4K4vsC36UVwXqWQuIV3qAYn6hiThYg/D3kNHAd9mofL4l3jl5Z0Y P2MGRvejN7h9OmNwbCjSk4vgGxKNMUNj0NGzHtVlxSgPi8fddw5G8f5VWE3ft1rxbS88OKU38g99 gcUbT5GNvoifOhNhhUeR7eNJOXDlwPCCR10JNiz9AmfKovHITcNRTzlrxZcCeZRmdbM+pjUWoRPI eLWujp9xvN+kj9vuitAy5GIMCEZ+1i00ZvRim0CmMaub9Rl1qbyu6M3slz4zecY+ob1cx2+0t7Xb rRJw5HJJNY6DAs9w+GDhlAapqakYOpRS11PhPrWoO9esX8VzneWtXr0a119/vZZEXHj8vfV3/eur S1FSY5ZuMQAznloI37IcnMkrRu8g4GAuJQPyqKKTxpMOVF0SQ9YjbZ7oyAHCFGKPLWQMnn+oCi++ sxaV1XlIXPkBkmKmYt5NozDuhrFYk7weIUOm4KZpkSjKzadZySw8O44+H5Kei7BBQ4CkzfAP8Cd5 NiTv4GADjJv/W9za3wM1XlPgXVWAzOyTWj98bNi3aQUOlvlizq9+gvDybJRKLNIptL9ychp9LCRs u9BInwoFJ/xm9DJ+4VPbRnozecxn5BFZZlClNZ6wRnqjPiPeaJ8Rb+Q3o1ftYX61baQ3k2fGY7RD bavy23r8qt62qLdKwGGHqE7h53D27Nnj1Mdfq+SEUQ25QBqGo/JyXXYSO1fFMQfjwsLCHDOcBim0 4+2XQJXVFY4AIbIY0heesHnRH7HhUL7KRjLlsqWhW9Ntb7JcsUOVV1+eh5KICXjp5TFI/Ow9fLo9 A+Upm7DlVB9MCCrXuWsKcS6b85jRZ0L2fo43Vu8mK9TCsj1BN7doItYFA8IKKcjUOPTRFEcnztyB LZlc7YHgyhwt65GOcP5rPCBVe5lSxiHQiDfyqzxcd0fPeJGh8oo+I1RppC46uG0sRvlGvOhmyEVk MeRi1G/EG/lVHq67o2e8yFB5jXqlrdJIXXRw21iM8o140d2S8RtltGW78Zl2gdrYEVIOHjyo3Q5X ncpZzvi7TWqf0HOfq01oGPJdr9GjR+Pmm28GJ4Bip6pbxOCBGnnlgTXYn6PfEhfHM6zM3KsHm77T 8YdXX8XPp+pJpLw8O+hyHMpqdXsc7YaphCpPk1l4DicyKzB09gLMi9fz/GafK0CHWt0flcWVmqy6 unJaP+JgE4q7n/kLXn35EWjavXhmRZdbWh6xXByivLVOvhAbaGF6zoQoamXiP/9ORIlh7GyLapuw qX1cZ9kC1Tr3Sb9AxnMRyHXGCRQ6gUxn3ATHUK0b6ZrbVmWITBWKbZqR9Idx0qfyij61T60Lnnm5 LsWdPOETqMpU64JvKVRlcN24sZ3cJ0XqQsf6uC56BS/0bQ1bZYYjRkrQ4e9tc2DgzHz86gI/ZczB gqHQCA9DcQLX1QguTuF+fpJ5zJgx2l0qtZ/rzMPQFjQKc/quwfKTVfj2o3eROfY6DOoaBFthFvYl ZWL0TP2SDsU52LJ6KV2i0PUUlfTjaRg0Jlqra39oVsHyHIWqsmNUfWd3rcZ3xREY1r8b0o5+i11J RRpLXFxv+HjVazlaiw98h93dxiG2bxf4a+G9Aqf2fInko9vpq0VUju5H9uDrMTAhClvXZyDp8+Xw vCEBEXXnkUN5aUfH0NoV01V4YvCMHyF955+QVLQHK7d0x13je2t2yviZTOoMpTiNRTrtUB0Pdxn5 hVeFQtMceqYRXq4bC/uV5Yl/pc6QS3Psa8oekaEJM/nTHPmqjJbSq7wm6rVxy5gZL/X2HL+ZXW3V 12ozHLnFrRoqB5EccOqBodIJnvukzpA3vg3OicsnT55M6RMDG+GdeGhRdsQjf8DdE2KpuxqpOzdj 1apV2JiYRAvIndG91zBMjaJUzXl7sW7dNkROiNeCQvqujcjiLKz24kUPKIod3OVFd9fEHm4LjpZf kJ28E+tXf4FV63Yim3Cx0+djYuc6VAf2xjRaOCYKbFv3FfKqAzFwPNtVie3rN+B06BBo6PxDOJJZ iM4Tf0p29yV8HnatX41VG7fhRCmnhfXUbIRHNXIzyzH357dr7TxadN6ZzfgGe9S62OsOqjxq3RWf SqPWXdG761dlqHXhU/vUenPxQucKqjLVemvRu5Ij/apOtd5aeJHjCrLO9iz8M8KzHA48vHGdN2MS 9QDq4y2QNlpqRTAN4F2CWtmwYQO6deumzUL4fSkJLJzbmN+n4pmNbPIwIN+Z4qeQOSDwjEgiusgU yI5ScdJmaF580KVnFDp716KgXM937OkbgBD/OmSknEUoPc/jaSuBZ2AIPYxcDp8ONajyDEDxmROo jeiHHsHeKMk8gcySGgT3aGhnFOuXaDI2hkHd+6K7HyWuLq9BLf3zDQmHZ2kOTmflo87DD92ie8O/ toIwHVCceQq1Xfqim38tKms94eNBPF4etNhMzz8XZyCrsB6do3qR3TWgqzB48btnVTk4ca4e/WIi 4V1TQl+LyERNQBfE9upETxPRLff04zhLibRbUlT7m8Nn9LeRv6V4o06jPCPe2DbqM+LdtS9Wn5Hf aI87vNE+I70Rb2wb9Rnx7tpm+l78zegLTaL+IOnjT/BKInVenuTtopOok4ymCzuCC0Oe2fDLm/xS JgcY6RcaHrRauF9war/UjThjW+h0WImc9FTkeHrBl9ZHuNTX5iCjRj8xi1OOwouCYn11BmrJZA8v H/pQejVquHEmhT662lCKDG3BiP6SrFSUdKDg4U16iL323FnQYz96oTtPWanH4EmvctAFH11eEoLo i8kuTw9ukz0eXvDh2+VUZ7ac9BOa3XQ3HHUUkDWbqD/liPIkc2k2jh7hudSFFbFdYHOkGGnVttRd QZYvODNdghNoRmPsawmtK96WyDDSqm2pu4KsX3BGW1RcUzRGvpbQuuK9GBlGmS1pt8oaDhsvA+DU FHl5edrsRdJRqHgz44SXccYIzDjpaw7eIb+mmh7602cljj57pVr90kNNFartOhht1GfkFVsFehAv 65EgauSvMXxGpp5oHUt6FOgqHQ1dkwd9trWSgpMreeILV3ijve7aLZUn4xbI/LIOw7qM43en34h3 Z487vFGeu3ZL5cm4BV4N43fno9bEt0rAkedweJGYnwY+evSoNrvhfDe8BdBTuJwrhxd+hw8frq3F qIOQncd9cvDK+o/ZDmU6lUetM64lRXgFMq9adyfLnb3u+I14d/LENoHMr9aN8ty1hVdgS+W5s9ed fiPenTyxU2BL7TXqEzkCWyrPnb1Gfe7a7uSJnQJbaq9RvyrHiGuLdqsEHHYSbxxoDh8+rN2d4gVe fltcCj8lzLfLs7OztbtNvOYjhXnVYnSCsW2klV8ptf9C6yKLIRfWLX1mMhknBwnjpW4ckxmvqz7j eI1tlc+dfSptc+oyVmv838/935xj5GJoWiXg8MHJT/+ePn1am73wjIYDDqei4DUcPin4YUDe+Hkc /mQsLxTLVwb5EswqlgcsD1z9HmiVgMOXVGfPntUCCN/G5oAjwUYSbnHQ4Y1nOrygnJZGz75o30AG xo4de/V72hqh5YHL1AP/bke7WiXg8NoNf29bbn3LYjHPbuQ2OOfM4csMpuOAxGkneONipRh1vceN lzhGykt9SWW0p7Xb1vgbshOY+ba197+ZjgYQn/wAACAASURBVNbsa7WAI8FGMvqpMxwOOtwW50hu Y77E4iLrHmYDE5yrNRE+IIXGjN9dn9jEkIvZAS44d7LM8Eb5RhozfSqNjM0av/M6n/jI2v8Xf/yL L9sDtkrA4ZOKL6skyBhnOBJw+ODgwnS88S10Ka5Oalf9Rj6Vzl3KT+EVqPJKXaDQXAxsSpbgBJrp aRJHOX/OnbfBy78jOofqL4mayeC+2oIUbN2XgaCoEYiPCXeQifza8yn4bt8ZBPQcgVExHR34i62I fDM5ghPYFE1TuKb4zfjUPpVX6gJVugutNyVLcALNdDQH1xSNmcxL1dcqAYcDCQcQDjp86SRQAosE HO5nWr4EYygBiJ1l5jD+VW9ZilHXKT/1xBWN7zqxDaxbbLnYHSGyGo+nAlve/Tt20jN8w2c/jBti +IFt3Z7qrES8tmQHxt7xKCb0Ekt1S4z2GeVXpm/Dfz4/CAy6FU/N7KczufhbVZqJHZSbKLimD0b0 0180VeVXl2VgO73lH1Qbjfj+DQHJhTjTbqN9RiJVH+Mult4oz6jP2Dbqaym/UZ6xbZRvxBv1XSy9 UZ5Rn7Ft1Mf87VlaJeBITmMOKGqw4X4JNhKQZHDqQOWygXGqQ7jekhSjTaX8lAk561X1SZ1haxW2 u3EJQPw1fbHzq5PYvycFk/sN17IMsj0p+/cReSyuGUjvipXpwVhkGKHRfp++4zHv7qHwC4/UxtVY r9JjzxfkF8xvqejFafyC9/N1L0sEmECx2QTl+GERGuN4uJ/7BG+ERnon+80UGvoult8gzrQpNpsh BSfQaA/3t/f4zexsq75WCThsnMxe1BkO19WNabiIQ6XNfbIDjHVuc2lOilGXKT9zCundJg+TFJ53 YfboSFTlHsO6r77B8bwy0uSN7oPHYcYNYxBOrxhUZe7CB58loeOIMZRFcBd2nSyDd2Bf3HjnzYgl gvp6ethx9wZ8ueUImDuw82DMumM6Ip0nKoSpQachCQilgFOUsRdpZcPRj95Mq6/MxN4jlQidcC0C yipxOJFSoO51ToF684T+6EAHYtbuFfgsqRiDhkUjd9suVMffjnuGFmPz2t0IGfEDTB8RgZrzhxul Mb1p7iR086FfMgmE5afx7efLHGO54Y5Z9rGQmVqRgFmL9F3r8ZUytpvvnIHunIiesg/uXb8OO4+k a+Pm1+yuuet+jGs8cBGqQdn3DLnIfheo9kldeKStQsZJ0JF+lV7qDLkILUMpqm4jPeOkj+mlLvKM eJHpCprxM61qg7EuPCqd0DBOxiR4lV7qDLkIrTp+DdFOf/QI0ArKZEAMOZDwJsFHbQtecKyaX+Rk B7ja2LmMkxSj/KXPc+fOaTuJ+wXfO45SflLRU36+ha+TkulBwwJ6v6keOfs/x+I1OylfcActhefU +L7w96GF7NJkLPrPl1qwiZ95O6bG+uPskS1YtPg7lLNNXnUorC7DyV2bsSsvDFF0JVJddhKrF69D Admdm/Q5PqETsqbvBNw+Mx5leUfw0ae7UEU62S51K+vQB9dxShucx4GjWdq4C08dwTnqmTy8K2x1 lAL1jJ4CdT7lQI7rUk16v8B3GZXa+D3pRdDqsjwcoGBzll7uDA71o8vTUpyhZ6DOleo+dKQxnT8f M+O7oPBsEr749pTGL2Ekd883TmP58sMNKGJb2TSt6P7O2fMZPjWMbeknO7SxFaRsw9ccbLqMw7z5 8zAhLgqhvg1v1avjVuu8r7nNUPa7QFf7X+1nXtnnal1o1D617grPNOomsl3RG+1nXulT5biqCy1D 3liPQNHZFGS5jBf5UheeluKZvj1LqwUcNpqDidkmAYdpuM40XASK88wg06lO4bqkGOUHDcXRDG3B nPJzup7OwZ7y8+3VB2AzpPC86/pxuP7On+FHk3sjff8e7Rc6dNxDuHNcHK7/ySOIY6V5h5FRyjtD t9W3LyXtWvgkFvz6IT1xFr3JXUCvbSQfPMPUGDNpLAYPHw8tB1cuvW1ergdQtlcOivrKCgyaGK/R n9qbqp24p/fTN9p9x6FfUBWNU0+B+pMpgxASEqGlQGXiDpSaQoMddFv6Tn0Ir770Eh69vhfqHb7U f70COI3pkzejR0gIenEaUyp6GtOGA6vxWLJxnu2Vg4+glvbUaWzX2ceWqo2tvkp/Ex+VlKcZHXHT vJ/g2h5+jrHKfnEavybX+QRnfFMb2894KSyXi8g3Qnf6mF5ojLwqTmxS+9S64I1QpVHrRrrmtnms TCuFZXJhaLYxreg10yE4lVdktwdstUsqCTQSXFQoOIHsCK4zDRfVoYJjKM5RHcF8LlOMukz5GYWu LlJ4+nvrLqgoykdWLucXrkdXTsWXW4IzOSXoqa/tIoRSXhScTEOudwhGEH59bgf400J5IF12cUlc 9Gck6lX6Ww67WMfY9DHSG+K9RtM3JZKQUXIMB1KDkJoBRM0ciQ7l9HY4vdVvngJVnzbLRUDPviFI PXnSoU2t5O39jNKY7tFyBDT0y0mt98hYcrzUsTRQc62uroPLsXnRG+5dx8xA/K6/UTKwI1i2iDZ0 w5S7bkZchL+233g/cdHH7RqqNFJnXuHjPrUwjo8Lka/iuC44hlxEltCLXIFGvJGfZQitmTwjPcuT PpVXZBihSiN1sYnbxmKUb8SLboZcRBZDLkb93N87ZgZ6RHak9VZ6M4AyLHhR9gOG3gQ5N5QnZcT0 ojZDT7568aSv5mrn7u80mS3502oBpyVKjbTiBO6XOkOpCz0vQI8YMUJ7QpmDlThV8AyrirJxosRX S/npX/UC/kNZ+LLPFSJc+0HWU3jyL7GUeg/9lzokLMAurxIlWpcv+vWgaCP5KuhLntWUEqjedgaH tFR9dGlFO1VPDQpMeOh53D6UcuxwFgzaIefTaK2mRh+P7HTWWWnrhIk0DfqQ7Nq6+mvqCcU9sSGU F6cc1WeVFKi/uAk5K/6I1ykrIadAVX1RUVKMOlrY5WI/ruz1chz6hoMNpzF9DuM6puCPv36DnkPQ H7qU9Mj8VdKqeorAFWe0JPLMzGNRZbG+psZWaAvEnc+/ipvS92HDJx9iO30N4+stxzF07jAnW1mO On7WpY7F2BacQMarRfoFqjiusy456bgtdfVYUXmlLpB51LrYzpCLO3lMo/JzXWQwjouKN7YFJ1Bj UP5Iv0AFpVUvZPy96ZNDffv2hTwfp0K56SNQXZMFruCAIweE6jB2qji2OSlGXaf87I9+oQ0pPL1u HIeutflaCs+JIyfS9OQzWoRdhR0dp6Dz2d3YWUz7zncEegbUoYISY3HJpcXcHQHXwef0DpzlDsrY F0l5dTqO74utX57Eln//DZUTxiLCtxwnkwsQe/14dLd/eUbGwGyoKUbPcfQqR9J6rYkuYxFJ+YvK OR8PJQrTiosUqA1yGvyiTLbpZKiHnzZpNKYxPUBpTCeiI/mTC49lJ48lfae2fqSPhcaqYfkPX3b4 Yojp2M7T2Cagw5Hl+Orbbhg7YggGDe1DAScZvuHh2gnJEhpsda4zTi3GE1jd/0zHctQTVuoMm4MX Go3Y5E9z5KsyWkqv8pqobxTALsX4zexqq77LfobD72bxp375Q3pc5EAWqPZpKT93UcrPZI1U+6On /KQcM30ohWfFe1iy5SR2rlul4TomdMcYnzj8bn4ZXl+0FrtWf671+3aJxwM/m4UOuWeVhdRyBx98 Y/HQL6bAIy8bYQkPYH7Ff7BoUzJ2bvzSrrgX4m7goGBvGkB50BCM812P7TSTips6BFUV+hPX3j2G UwrUrdhEd7HWrQNGUArUoi1JdKeIUqDG/UT7AieL8qZprjp+Tby2J4O0NKZbv0zW0pjyXbHYkh1I zj9IaUzjcR1/wpNKaFSA6Vh0LP0lWfWUq6epsXlT5sLUxG+QmvSNzhYai7tvGkC39Tn5W8uKOhap C2RJZnWzPpVWxbuzRqWVukAzXhUndYFm9O76VF6pC2Res7pZn0qr4t3pb088/0zwocq/i7xxnbcW pRjlT/Hy51944zfAGcq7VfLUMT+Hw9GbN16V56eMeWvNFKPBkf1MUn5mU8rP85Tm04tSj/ZunMIz swh+HbujV1c/VNA6CucQ9vepxbkzZ1BUSZcVBQfwz6VbETX9Mfzqpr703lclAoM9kUsvnxYSvr6+ AzpF9UZXmpwUU7pPL19PBNB3wLNSTqKYxPGO5zE7HwD+6DWwDwLJ+7a8NKTl2jQamuKgR78+LlOg 1lEK1EhOgZp1AhlF+kKyV0gPxPQIoYlTFlJoLCGU9tRVGtPs2i4abR35vUOHOs1edSxewT3Qv0cw akrO0pco+FrSE+GRvRBBt+/VsWUeT0UdpUvtSQGsvFL3WQBdpWann0ZBhb4oy2PmYj5+DaX9Ed8I fQPGvOZOnjlXQ+/F6jPyG+1xh2+wRK8Z6Y14Y9uoz4h31zbTt3Xr1gu6pKJz/EHSd2lSjLobaFN4 diJvrooRZ2wLXzHlIi6hFJ7eXnQnjP45pfykFRhXKTzL8zJxLI8WyCjHMJ0ievpPu1DO0MclNycD R47U0AuqXsjMoD7HCVWD/IyTlPq8A6UapfUDujSq0RZy7AIINLa3HKePHmkgcNDYKMtp0ylQlWSj Gn91Edkl60zUU9RkGlOF1oNTo3qgOoO+gWW3pKrojJMsvrTKz0hFvp2Wx1ZLCz08Ho9zJ3E0mxYS 6WeKXVFdTQtWSlHHrNYVEq0qOIFGvFm7JbRGfuEVaMSbtY20alvqriDLE1xTspuiMfK1hNYV78XI MMpsSZtnM5e8qIM3RmDGSR8bKnWGXIx4DhCVzse+Ruf4Y8A3yKO7RCaLvH7dJ2LBz6+Dpx/NCIps lM9Hv/whxZpI5tfXITjnT2N7HHqbWWF5nAJVxldHK7d861t81GCv+fhZjbs0ppop9MAiZ1ptjjwS qNGqQ9DtoeBTp9sm9hr3h8rTnLo7e9zhm6NDpWmpPNkPAplf1qFY7pU4ftUfbV2/7AKO7DyGXMx2 KPfLDjfWud2SInIEMq9ar6qthF+AD2or9A/aGWW7s9dI767tTp7YJpDlqXV38o144RXYUnnu7DXq c9d2J0/sFNhSe436RY7AlspzZ69Rn7u2O3lip8CW2mvUr8ox4tqifVkEHHayWoxOMLaNtPIrpfZf aF1kMeRSX1mOoiqby5PaGBCNB8yF2GEcr7GtymSc2Kz2X2hdZDnG70a+NX7nGc6VuP+PHf4ORfkn tBew+VkcfubGm9Zcvbguryepz+HwszjaczgtP8oui4BjpRht+Y6zOCwPtJYHjh3ejnMZ/vRgn/5A nwaVh/w60I8v9zH0oKfdNWj/QW6pDZdFwLFSjLZ0t1n0lgeuTA9cFgHHSjHq+uAxXuIYKS/1JZXR ntZuW+N3XpQ3+re1979Rfmu3L4uAI9e9ZoMTHEOzYlxDMKNpqs+4w8wOcKa50GKUb5Rjpk+lscav vzdl7f+2O/7V462t65dFwOFBNnVSNwfXFI07J6q8Uhfojhe1xdi/Yw+KvKIwbmwMzJJ8NiVLcDos xuHv9iGf3oUakTAcIfYXQ4XGzBbBCTSjcden8kpdoDve5uCdZVWhIPc8Kum9tC5dQugzy3owd6Zx ltocXFM0ztIat1ReqQtsTN3ynqZkCU6gmfTm4JqiMZN5qfoui4DDzjJzmPy6M45nAlykLvT8Mpne V4L1b7yN/WVdcOfjP0IvOvOr0rfgtY93IGz4HPzkhv7EXYs9H/8VXxcn4NEHx4Nf4XQ3w2CdTZaq PGzbuhsl9HTxqDH94WW3Vewz8hr1OY2nIg/fbt1Bb1YFI2pkHILo/cxG9JWnseT1T5BlEBw4fC4e uSHa0Nu46aSP0Eb5jTla1mOUb+T2qEzHP9/jV0gG4WdPzYT/xfiLpLTUfqN9LeU3jsfYNso34o36 LpbeKM+oz9g26mP+9iyXRcCRwMIDF4fw6w8ff/yx9o1y1SGqgzlNxW233aYddHV1IegX7Yv99Cr3 6XPliIryQ25musZaeDIDJXV9EVibi1Tq6nJDHOWn4/Bj/vZvbfYu/GPxFgTG34EHJvdU1Teue/pp 7ziV+PrBh5/CJQoeg6siOIE8Hsf4/UJpbgMKOPSaCEliMUIn0KODN+yPHiJ++hz0DfbSckT7hnfT 5LjSK/1O+qhTdDNsrSK2msmr94/GI/PuRqlfOPxZpzp+YmBe2cfML7IEXqz9F8tvNiZjn9hq7Oe2 4AQa7eH+9h6/mZ1t1XdZBBx1R0id7/MnJCRg06ZNTmOXHcXwmmuu0XD6SdMBUQMHAIcOIv10PiWD ikDWSe29bnrb4xTOV01EYGE6OATdQAnEK/IP4fNPNuFMmf7qQmj3eMzkVJz0LvjnFGy4t/DwCrye HIE58+9AlHe9lqJ0XeI+yhqo8/Sd8EPMHkHP9nMJrsepw5vx5dok4g1E/E23YVJsZw1VkX0Eq1aT Ln7/yTsM18yai2uiObRQcKE3tpct34I8QoWFBUFeXZCQ1egApHOUJj5U6BJu4ih0o9cNtIO2qgzH 6a335Tsz4R8Rjztmj4ZfcTKWvr8eXqNvwx2jPLDqg5U433EYRvfIxxpKJcFpQYdNm43r4yLo3YQs rP7PKpzvNByjeuRhLeHjb/0ZJvXxMk2h2sOffhnpcjJpPb30euRMozSj1XnJWLdhK46f1d+78O5+ DX7yw3Hwt+Xju81rkR0yGnOnD4Uv7ccqpv1ys5sUr9egR9k+bDmSp6V4nfXDWehD15yc6nSPwYZr f/gjJHTXvSQnL0MuZgFWjinGG+mN/neHZxlNFTN+pldtMNaFR6UTGsbJmASv0kudIRehZXgpiv1s uRSqG3S6SrHIKSkiIyO1ncEO4o0dzbB///6IiIhQ+mrh3z1WOxnPnjhH+V7ykGGPN6BVkayCSuRk ppHSKPSlNDecitMWFo+77ak4iyQVp08nDI7Vg4FvSDQSxg6n3MZ1yD2wHB+u3WVIUarkqclMxAoK NmGcg5ROv6QNh1BKtnIK0/c/XEvBpium3z4Hsf6F2Eb5hFPpRc/a4uP44BM92MROnYkh4XogY8/U 17vO6MZ4IAOJ67Zge2Iitmw7iLySCvSaOAPRZWXIO7kFa5NOYNeGL3G2OgzTp/YjP1Fi00LGbaNg c5pmgLqdBzZ8iKTz9D4VvaJwvojx32nBxteXZlv0dqmrFKoVNAPlNKObOdg0SjNag8ObKG0rBZvY qbdj/t3TMTCik5aXuZbSpGaeoZSoZ0r11JqUiGzR+6tdpnit9ay1p3jdgC2pNDsN9dVSvK7fc0Y7 FgpTtjeyIYTyN/NxIseKQPX4EbwRqjRqXej4WOU6Q7UueHdQ5eE66xDIdXcbyxe71LrwqX1q3RWe adqzXBYBhwftauNZDK/TSGE6/uhefHx8o51j8+uKIfzDlp9BSdfPIpUuUGbOGaexnss6g4wT6RRv RtJnUOhLoQPsqTiDg5VUnHQhUxuAcTfonx4OGTIFN00bi3APG47tOKXJGTf/t7jTkaK0j+PFR06k NWfBy/jNgvsopFGpSkc+pe1MT7KnMI27DqPjBtHnV/hEL6RsgqXIPn5YT28aPw8/IZmzHranL9U0 6T7hqnpQONKAUv+Bb9bhS8pjse7Lo5QPuQ5lhQG4/efTNe6T36xE4mkg/u6foFtFGerpwS39Nz8K 859/CQsWPI+74/TAejItF5Tgz47ncbyIl156Htf3Bo450oyOoRSqkmb0BLJsZJ8jzWgRbI40o75k L73Pxu8QUykpLIdnj2vpyxJj4Mf7mR4o0+yg/Me8YJx+oCHF610mKV4dT7RSUHvmpWfx6x9fq8n1 t39Zoq7KnsWnskhJdco2mB9TcrLKCWiEzCc0al3o1D4zHcLbXHozGWofD5bbUlguF5FvhEzLfaoM tS44lU9ktwe8LC6pVIdyXaaB7ABOdzF06FDs3btX8wfjRo4cqaW/aOSgyiDEDPBF0sFUfLvxDJ1B IxETM4ByEG9H6tY1SKXFj743R9IvSj0K9n2GNxul4uQdWYGz58t10TUFOHuOM3V0QJAjRWkRMs9V aTYyUb2k0aNEWkN8M5GWnG8PQvT2OHnX0193cdHBj/Gng7pY/utDb5170b0arR5YhzPZlEawJs9x l6te+7XT0E5/9Ikxd4VS4HgOIyhFRC2daplpOaiup9cwgq7F7bGb8Wkyy46lpPA19Ng63Vp22DkQ nUpPIi2/Hv5dOH8qfXK5mBxTT6vsXGgcQ/1orSuVZ1t1CLLH+sRFf2mUQrUhzehRfLqINrognfrD WzCkSyAm3jMTe95cjaykL/FP2gKiEjB3dgLCGs4dLYcyp2nlwileM5tI8dplSBzqUk/hRH7DLJD5 VBuWkQ2c6lS3QQ+vcizJJYUcawKNeD4RuY+hFKHltjt64WXIRXhdQZVG6qKD28ZilG/EG+0XWa7s kX6jnLZqX5YBhwcrO4jrHHBOnKDUEyUl6NixIwYMGOB0QDCNXsrRecAQ4GASSkvpJIrrDa+acNBa MnIrqU1lcK8g1NQV4aCLVJys16NWP1gq+USkwn16uk1OUVpEX17Q8/ZqSMefcuTRlxMoCWBDIb56 e1Dxjb0bL/6MZls0jeY8MxV5adh7RpdfWaVP00EzBj0EEQnzKienCG3oC6JcPaeQkk8ngUauE9ec 3IgvtGDDHMlYmXgWNw6iTHwiq9IGG+WsYZ58ytvMpVc0XZrWF2h1zsecW1KlJUQiI1ymGc0/lYoi kzSjm749jsG3DUVVx3F46dXxSN29GUv/sxa5GTuQlDYYU3rb1RBgvzakeKVvcmljrkCp5gQ9xWu9 pN6wUbJ2ykKo7xldBp9c5aY2JGMIpTrlYjwBuY/1SJG6QCPeeMK6k2fkZ7kiw6jTrC12CBQagdIv UPoFsi6xkfukzlCKyqvWBd+W8LIJOOIQo8PYIbKAvGHDBm2hWHUS19Ud6t8tmqbsSdqJG9s3HLYq D/ShWc/Og3wUx6GHP731baMvGWgXk5yKczWSj+4AzS+Ao/spFeckdA/rrE37iw98h93dxiG2bx8M THBOUdqFZiM56I2xsZSnWPYQ2VJXLSFGzxPcd8z18E38CJXJS/Dav88irkcA8tNT0aHfeIweOBTY uhnFOz7DFyX9UXrkCK026aWaZNF/7eRQx+dBnbq+TGyhRdmuFExpNYGmTN0xKr4jvv78W1T5xmPe bYH4z5ItSN6wFjG970RvHw5+VIq3YsV3fhgRfg7rDmq5VDGkJ+VzruRnY/TCsyv9axCN04x29SnH qeMFGDCVUnYc5TSjlDVx+CAlzWgY2WzDzmXvITFqKEYM7I0hUb7YTJ+66RjGlzrldj08vnpEOlK8 rsR2e4rXHUqKV5s9xStbxseIY99r/qGF/N1mNjSkOmU+Bw83DMV4/IivGXIRXhUKDeOl7opelcF1 YzEGBJYjfUzbHPvEBqaXutgjMhiaFRmXGa4t+i6bNRwZnDiAoVrnxeOpU6dqMxymNeKF3+bbTV/H oZARE+lDdFUIoxkRF9+4AQikdZX6+kAtFSeHiu3rN+I05SfW1onpztWRzFLUBPbGNK0jG9vWfUV3 kKrReSKlKJ3Ql6Tkaek5V2+iyzS6W1Vf76mvSRBGs4nWm4JZGV0c+XWoR7lHLJ55ZA7onENa0mas XPklvtufDA8fSmzeeSLmTeAVnyqcpmDjERur3RZnXm/iVceviaQ/qr7Th5OwKykJSUn7kXQoB1m7 vsYJmjRNf2iWlol/Hn2XiuZ2WLfxEPGJBLpDd3gjVm08rN1eH3f3zxHTgSIwzbrIREfR/WtPMzqV oio9b8QpVFd9tRmHUwtAiQ3pspbSjNKYli56A4vWJNNVnj3NKPnEuziV6Ffg7b+/rQWbqPg5uDaK 90eDHtZh8+EUr9Np3IVaitevks6AU7w+8gyleLU1/Crbp1wUNO2/kXSly/yubdD9p4/DdZ0HzDRS pO6Kr6X0ruRIvzt5F4sXPa6gjLu9IIdx3oMceHjjOm+XTYpRssWpsOMkijshHA1/9Kb0nQEe9P2q 0ynIprShAV36oHdn+gSMLQ/HT+dpawehlIozgk6YylrKfOdRg1rK9ldZTWdRcSayCj3QLbo3/OmO Si25pTgrDQWEM0tRmnKW7pgN6AFvSo6ekpJJckLRNyaSQkY1pRmly44aSmwe1g1R3UJQXVJG3vWi XOkBKM1MQVZxPTr3jEYInfCVNV6UmpS+y04L4h2I9yzz8tWXodR3CNb1GfpRV4pzxT7oFuaDIk02 femzdwylPqWP/dG4j508hi/epgcGu9yA//fbWfCgLz/ANwT1JWdwhr846knPMZHd3jUldPmaSZ+s 0UtTKVRrO0c3SjOak06L5RS/uvePQXAdzWY4G5pvILxri+hxhWxUkR4nf9Evul84pXiNME/xyilU +0c2pD31DO5OaVJDHSlVAyP6ohetfRtTnZ63mTiPhiTHjjoDMLpSbRuPNyN/S/GqbK4b5RnxxrZR nxHvrm2m71e/mIuw0Ja/Lf4/r216kPTxdTknsqaDiK7H9Y1X8nm9gCfNvOjGhxNvdfafC6pewsJO 5K25pWnacqQZ0neW5ZzCkRxn6YWUirOI0pF6UmCqqaGD08MLPvS9pWqqsyVZqcfgScGBbrASnn9p 67QUpble3vrsg6b3NbT4zLacOFrcYH91IU4ckadpdJ22grNIKTgHLx+K48RXS6kFZbS56Sk47+VD qTrrKGOgnObOtjq1aP0pRc0p6oSkW99ZDR15acdpPmYvNC4tvXlxEV1CHkEQLzbVZtAY7Pi6QpLr bLeOqUPemVTk2dOM0t168pH+/XNQmtEj5zpoKV35Nr7mR7u4rBSasbF/OQdpbbXmKw1VY7Cf/Fee Tyle881TvFYVUtpTxay6okxKg5pp10JH+rlUHKFUp150F47mKk42OIiUihw7AhWUy6qRVm1L3RVk oYIzUyA4gWY0xr6W0LrivRgZRpktktvxIQAAIABJREFUaV82AUeMNkZgdoz0MY3UGXIx4rXOZv7h VJySvtODAjCf76q8GrqUMpb66irHWgfj2I6mrrkb+HkBVlZJGnq5VkMr0hJq3I3PHd5ZstLy74OH f7WA7mTRgnVxscOWZsszpBmVA9aDAjYHSpbDRfWflupUBqaYYl6tobzI7vevqb00D62mtbMLKaby aCwyPqNM6RfI/M3b/0ZJ5m139rjDm0t13cvy2rNcdgFHdh5DLmY7lPtlhxvr3G5JETkCmVetu5Pl zl53/Ea8O3lim0DmV+tGeY52VTmqfAJppYa+U05BXE5P4RXYbHl2we7sdehvZsWdPLFTYEvtNZoh cgS2VJ47e4363LXdyRM7BbbUXqN+VY4R1xbtyyLgsJPVYnSCsW2klaiv9l9oXWRJ5Gfd0mcmk3Fy kDBe6sYxmfG66jOO19hW+dzZ10Bbh5Ji5dqkAeFUk7FefeN3GqbLxvd9/C4d00qIyyLgWClGW2lv WmIsD1zmHrgsAg7f7raK5QHLA5fGA399qf308q1wq1gesDxgeaBdPGAFnHZxs6XE8oDlAfaAFXCs 48DygOWBdvOAFXDazdWWIssDlgesgGMdA5YHLA+0mwesgNNurrYUWR6wPGAFHOsYsDxgeaDdPGAF nDZ2tS3rEL6h9KTyjmQjdSX78OLC13BKz8WloAvxycKFWHOKU0e0T7GdWoWFC1dpr/+2WKPLcbRY Ursx5B/bgR0nJANRu6n9XiuyAk6b7v4sfPLOMmxesxbpjQKKrrgk9Qiqgoagh5opkFElaTiCcMT2 4NymF18Kj32Dbw41/WrDuWTKaTO4vz2fT8t0uhxHy8S0I3Utzp5IpTfojY5vRxO+h6ouiyeNr1a/ H1u+BKd8KG9wFb1hrkxxSs7sw5qv98DWsT+6ZqcgfMg1+mFPuWk2rvkaabaO6N81G4RoFIiy923F 2e5jMCLCByVnduCb44G48fqh8KnNxjdfncCgCb1wdMt2nM62IaRPPKYTrvLEViz9aDOyfSjZetl0 zEiIhi37GL75dicyKS1OxMAJmHVdNyQfLkX06DJ8s/xDnC6PwLRbr0ekFu9KsG/NGmxPK0bM+Fm4 fmiEtstcjsO4Q+3jSin2x/g5szG0kw9O7ViDk17DcP2oSKK2Yc+ajfAceSMGex3Hpn1l6BZUgD17 M9FjzI2YMaonpbjIxtb1xxDYjZLH7ynAlHlz0LNS95cqF7WF9NmY9dhHA/PvMQq3zxhBvq2lzI6b sWVfGqr9e2DW7TMQ4ZmHIv9+GBGtp0vLOrQVm3ccg807ApNuuRH9Ka+Q6OzUPwjHvjuM6q7DMIvk tc5PgNFJ34+2NcNpo/1cdWYjPtofhgceuw0RKMCJTP3SqPDYcvzlX1+h69ipiPc6ih0ZwJAhPWhG cwh//su/kNk1HlPjvejgz0DEkAGNfn8L6LMoR3I5euVj5b/WYM/ONG0Ep776AJttoag/dRw13Udj 2qQe2J9In6MhtZ50kUThC6OmjkOfyHAUHlqOl9/8COdZ16Rh6N4pgILiOaRRwpxTmzcTf29UpyRi 62nOrVSI5S/+Bdu943Dr9P5IXPaBllXQ5Tg0a5Q/hfq4EDcd0/rnY9nbmyi8UCwNLEHiqiUkqwr7 PnwZq3K6IJaCaOa+TdiRSMEtNxhDB/ljx6qPcYwYqujSdMOOzVixvQCxo4YjotxMLn1ZdfGrWHW+ F37wg0mIjeqq+S9/z2K8vyob1866EaNiKTkbxRJb+i5sSEylfD30KbPlf8Y7y1IxeOqNlJQ+GYtf XaddVlal6zo/WnES3WM74siOrzR/KqOzqi30gBVwWuiw5pHnY8W/EhEzi36Fg8PpOwJ0gFdwLpxC rP9oPwbPfQyTBkZj6KTx1BeOvnSiHVq5DKWD78L9k4Yieuh1GEyYPgM601/n4kU/r2ez85C9Zy1S GBUYjFrbISzdE4gHKHl5xIgJGNqxFuc57R59sKYjnVwBAfybHIPxCSMwsGctvly2H1EzHsY9rKv/ CIwaGAFbZjIFpSg89Ltf4vqEIdrXRDsG+qJw33rsp8vBbl5FSEvnLGacDNL1OAjpVPatp3HRGL3K MnA6h5LCkT1cwobOwvjwUix+8UV8VTMNv74/gWYONiTvK0DM7F/g4VnXIWHSNQiyf2c08/A+Gs4M PPfwHCSMiMYRU7lVKOTk1MW5KPfthVFDefbETb6UtCG/JAAjRg3ULhm1y8eYYQgr3INlNMC5v76f Zjs9ETe0F9Ge11LXZSaTzohp+N0v70DC4CjqD0cgBSirXLgHrIBz4b5zyXlqzSe0/gKkrPobLcK+ iv1UP5uWh9r8ZG1dZvQAfRpfknoA0NZvspFE0SNhdG9dpo2y2PH6TUTjyTtlC0ZV5nZ8tK4G9//i LgoROdj44Ur0mHEHIrK30gL0i9iYnI2MQ3voBKUARCdIFiWHR/RghLH0wjQKVEGYNDJC12X/ey75 MK3fJCCSTyjNzggMoJzQaUdOkJxR6O5XgwqvSMyYfSt6lbgah5NIFkRZBJl9OPwqKuAXOQ6zb6Ov bzJZbQEy7R+KuPGW6/S+qkwcLvXBsH6apbCdOkzBqgfC/SkQ7S0l8yi3slZcyfXHhB/fRcH6IBb/ 7UVszdIXzqJvuAuTB1djzeK/4d2tWSRBlxczLAr5abRu5TMS/eyuLuFAHUQ67TSDxw+jGSKN5Djt q/BBjS5xdXusv831gBVwmuupZtLVZu/A+zvKMPfJ3+G5557TtntHBaHgPH0sjlKNcuEvxVRl78Oi ZbR+M4Ium2x08mkISo9XlY3l/1hBB/dw84ObVt2qTh1BIH2pM5q+glBWcAR7cuhyJyEYW5ZsQOD4 B3DPDPpECk0moob2oZPFhuM0a4jo113Trd8uK0UmrfGQJfTpHT4p6QSk9ZuYQfwrTicXn4R0cnGw qq0hfEgf+uzydZh0HX3Mb0RPihUuxqFxO/+hJH7EPhwJxHvddeNoFkHBpDYLH/7xHXjNuAvjKe6t W39IY6rKPEEBpivo45pU8rF26R6ET56CCA5EVT709Qk9EDHWTK6tMB+1nQbijod/RJexdJVKC2e1 tkIUVtG6zB0PYVo4xdsSmmna5Q0meZVFtIhF+RbJ88RwAp+sOYXBM0fBx6FT/3FIO3yKdklfmaAx tVUuwAPWovEFOM01iw3rP1iD6FkPY2gw/y7qJbgLnSgHz6K+1yjE+OzH4pcXwic8XLtYGM+XTf6d MTXGh36B/4IdPuEIonM8YnwTB7fPcMxJ6EQnjj5FmHzfjXSZ4IlO9M2tgsR/YeE+XUbpXloETRiv 9SdueBMfej2EexIGY0bMZqz518vYTOaFj7oXj98IHC8NwlT7CX02ORMRw6doJ9fgaTOwle60LVy4 TBtMwv2/xgxX49CHq/zthMkzBtP6yKvQ2SNw76/vwKH/ewe2aQ/gwYSeqIqcjMR/rcShwqEIPJlG vNn414sLNRkRw2fj4Uk9aaazhgLRIPTTz33Cmcl9GPnL/oY1tCbGJWLUbEyN9kfe1k/w5oZT0omH b6AF8/QGecFjpyN68/v4y8I9Gs3gaffjjoFhpHO7orMQJ0nEkGkcxqxyMR7ghKYcdHimwxvXeeML df6d4StuP9poVVHbAgny5xqDKdPcuwS1snbtWvj5+WkbfymT6/7+/toneX0oWbe3tzd9rIASklN2 PN74W8rVlMCWt1WrVuG+++4TUd8DWAsbfVHA359d61yqbDb6Uidlz3fublGrihZh2ec8e6Eq1XVp Nhv1k06Rzbr4q30+ymeUXSuq0mz2cbLN9Tgayamij+/R1zHMxtxAa8OaF19Gya1P4o4YL6L3gb/d 9gYaQ81ELo+r1tOfeBtoa8kR9K3BJvTrY1H908B99ddunj7k+/XVhqt/l6oj5BNPTnu1n85/OqEv tujBhqXQ52+Uk854srdMF538jUxzPY5GY/ChANCo09DBd8mqwjG+B01jyD0uXOTMZCLXbFye5Iim 9bdgLM4WfK9a5wsraJKgfwr5QnOv82zGKpYHLr0HfKLx8HOPX3o7vocW7D+cQz9O3nT1oX+0oIjW 9fjTSJLX2ggvxkVWwLkY71m8lgeuAg8UFlfS80gNn/qRANMWQ7PuUrWFVy2ZlgcsD5h6wAo4pm6x Oi0PWB5oCw9YAactvGrJtDxgecDUA1bAMXWL1Wl5wPJAW3jACjht4VVLpuUBywOmHrACjqlbrE7L A5YH2sIDVsBpC69aMi0PWB4w9YAVcEzdYnVaHrA80BYe+J4FHHonqKBCf2G6Jd6kN6ZtJSZ89v4q 7VXjlgh0TVtTUUJvcFe4JrAwlgeuYA9cdU8a52zaiI+fOoyy9BDceurHsKeeQenB7Xh7yk4trQEo x8oPT81Fb8fbx673YMaSj7D459na26zV9EbOpK/vwbi4QNgObsZrUw7Am/I1VacDsYvuwpybW/Y2 8Y7X5mDcpjkoXv5jetu7BB/OC8G9H9htmfIbHFjx/xDXDBtdW29hLA9cXh646mY4XmFRmPraWAoQ nDFFShk2U7DpSyf203mP46YncrD0OUqo5FQqcHpHlj2/XAMieOQ1eCjjcTxJfDc/YcM3S9M0pH/M GDx86lE8mfQ4Hvq4N5LnH6KsMs0vJQffw7hfUN4beqxcL95I+DXlHK6vR319Jl74+kUs2ZXVfIEW peWBNvSAl583vCk3K28+lAmStwspV13A6Rgfi8HjIpwTJVXkII1mJ3GjQzQfxd4+CHj/DIpUj5Wc xrKZexsFnNCBvdCRE3RQCelK7xwfLdFp/AIRKjlvyugSaGKgI/UDKg5insdsbKccwaal5hieGjYf L7z6BOWZkoDjh35xA7VcIEBH9JwCHEnn5FBWsTzQth4I6hqK0MiO6Ni3K7oM6K5tXQdGouugHoig 1Kq8de7XDZ2iu6JT3wh969ey2byM4KoLONrAjGsqfgGUo9eGM2mc3Y7y2+XxSZ6FbM4RLoUSqASO 8HMOVIJjWJOFTc/a0Ou/+jtozq7diHdvew3vzM/Gze+Oc/TDLwqPfvUU+toDlSqG65t+Pwgpbx7A r2YOp08QGLFARepnmP818MCN/RsjrR7LA63sAS9fL3j7e6NDh7YPB1fdGo75vojAdf/bEZ+OfxPp d3TE2U/OE1kPBFCasRwKGisX59ElWDElDK/B0icLgbwaDHh2NsYNtEeMiiwsifoUxU9PxyPTGxKb h8UNxeSnuyAJlEHvD7vQ/y9j7EEnHONmTDA1pWDHy7j+xSnYmBaFtP1LiMaGtNwKxHXRdVWkfgr/ /vfipW8zcUvk92T3mHrK6rwaPfC9OaL7/fg+PDo1HdnlwQh/KAnv/IQSVfI5HjcIE56ogWfhSaz4 Mh8j549BQHktgiM46SGXAiynYFP+v3Pw2I85o39D8Y+MQD/e3qrFS4N248zCMUoazAY6tZZx9CxA KYcX3DIZBw7o05thvxuD4rfuQXDuJiT0vwOLDhTjx9Zqseo2q36VeODqDDiUwlNLjF3DUM+uV1tR haBevSg/ajHWxB9G2K9u17PARUbS1wmIrKKWLqlq0T+ul1N2uNNvr0AyeuP+ud3olnoZar28ERRM qfToKwQ2WnHxp6B1PpkXdztC+xoL1QiJrBM5COnP+pxL3I//ivof630VB1+DPwUfGwUbPwps7z10 PQ48sQKzYyjMFRTAyz8cwfZJlrMUq2V54Mr0wFUXcE6//QGWPsuXTMDKmL8jfd2DmBEfiLR3/o1P F/LiTjW8/2sCHrmbo4xzYWdwiGooFTi1hhdui/F+9Jt694hheHzDZFrR3YrXbjzsuC0+5ON70F28 WXGEEpWPwt9L6jHBGHEahOv30Yb5atCv4hQ20k0rYDY6/p9ONJvWeZb/V5zCYVUtD1zZHvgeJVGn RNk0Q6miuURoOM1QWqHU8iyH0jF6BodoM51WEGmJsDzQ7h7oNSQavv6+8KBFY48O+ocONMht+4cP dEim2dugyHFg454HqYdvvfD9WPowkfb9wHKC/OQq36HhuzP8fAr/0vNWJ7/JVL/aCyXKDqfA0IrD 9KSvUwTRZhXLA5YHmueBtr8P1jw7LCrLA5YHvgcesAJOkzuZnz4+hSKeDF4tpaYUqVvStTnw1TKk NhlHTQGSthykpfzLo9SU8Dt2JaioubIPxu9VwEl95R946RX7VxibcxyVZGDpzJXIbMk7C03JpYXh tzq/h1TlgcPTr7+Hv72ejM33v4aXOjfe3nr9FL23lajhNiTxZbK9VKTjfaJ/9+106qjAhmmvYU2S 80ufp9/7wEnmW2/T2CvO4dM5y5Hu6ilokX8pYUUS5njMQZLip4P03tnU1xLx3jz7GoPT2oIH5ryW hIPvzaMlhnlOfPwKCa8/vHWQhZXgrakeeE0VTL06X4PcOW8lkZ+SMWriMBy61H4qScVr84bDOyQE IbT500clp9JYr9Ry2a/hfPHFF47nVYxOvuWWWzBsGN1XbmaJvPc2PODdqZnUREZPH4fRqk9rOom+ N+p0J6yG2lUVPpjw9sNIoFv4nvR967cHbcKkAw9icMc67TZ87dHTms0HlqVhWvwQrV60+yDoiR6E 0fezudTQjbkaJ8nUWUKR8onrseCZGPrGdh191ZPWm2pO0SdUL+7rnprCFv45/fo7WFoxDU//KrpZ nMV0Z1B9G66a2vkVAbjvHRvmvkNPxpZsw01dH8PvMndgYsdq1Hj5I+VdDior8OmulxA/Vb8LuW/5 XzV9ldU8M/BCZT6HZ8MsoTgTeGEjbL+5FtU2uovpT2/M1iRhMv2Tp7GaZXQrEB18bSqGVfwv6n8d T9JKKMD2xy9OvYQTtv3oR7uvouA0UrL5Q7hXZrnsZziTJ082feQ6ICAAQ4cOVbyeh+XT3sPBXO6q wu4n38C776Vr+NId9ArCKyeQ/81WfLVBI0DGe8vw1m834hOaGfDMYvnKbLusMiQSrzbb6LYchXTI yXcyM1audswY3n39MGlxr9Mu1AnQl2gdxddXr3r60dch/ehrmfyMD50YvgR5UdrHS7TTcv9bh5Ch nStVOLo41SHDVYVJvUODSQbJpgd6fBpFzlqkLllmH9N72J2qz5A03zy5FkvsvtmQeMrhk7deSbaH tWLqe0fnnbYWZ+2TKzO/Vh3bjqULKfi9tBIv3Z+ov+Tq7n0ztl3xU4DdT17kk2A/L/gF81enOyGQ xuXlFww/+pQ0fYGaNuDFRZu12ySgd9Y++L3JuyMaVcMfDmzDQruQDJIdzLIacHotFx8umKrfsZn6 MuxuwrH3FmDOgpexgGZN2ixqSxLRDdfqc17eYg9rZryUGeC/5uDZ116mmRzzzsEXNO2tOPYhhv2C 3ml5ehQ85r2HkqytmE+PSqz44kkt2LAtfuG9ETewi9HAK6Z92QccnkaOGjWqkUPnzJljCETh6BZZ jL3b+ao7D3ver0beF+nayZHy3mEEjOqEytzzyMvgu3b0vE1VCQrfOozwP92Dexf1oLe992nrGudX rsLWzX0xP+NRzF/Oswl9RlKVmojF87NwU9JP8VTKHAQs3Ihla+vc6tSUKX+86XTb8PNlWPIkbb9d hrVv2uDj7kZXdS06PxGP2F7Z2HeAzmy6nNq9owcSng5Btf1EV1Q4ql6+9M78om+x/JXV+OS3mx1B QQiqjm3Dpz+vwf3n6I33xcHYeMd2LRhovnk/GT3/Og8/fKsH9sxZiTNjZuChxLEofGkXMkhnxnuf YWveCDyV9yhuHJaMJe/ol6pmfq0aGE9v6NNcgZ5/evjvY/U7hW7eNwvB13jh0QVYsIC2ZxfgT//4 Wn8yXIw3gdWVAXhh8SIM++Cf2M9u2vMFtv/0Tbw0m+om9NLl7RuCA+++jD+8/Ac8++xbjoAi+GPv PYR7836G6vpqfDX8adz2tn5JU115Civ+72mMeTUTBz55Ag9PHIVdYxYh8+hirHj6bRwlpa54q1JW 4MVffIdfZmZiBT/suewI/Abeho0v0Iz9NyuQ848f0ou9PLP9KQb0aBQBxbQrDl4RI5kwYQL27dtH 3zXWJ9mhoaHo06ePwdmeGHBHBL75kt4C73MeZRM7IpDeR8ooyMbBT/wx7uVw4BCz6DOGmkqaOj99 M6YldEbVwTBNlieFp5NfZqPzryajK802MC4GgTip4c5uPAHcNAKDe/mRhF6Y8P/8sXhXMaa706lx O//pfdNA9CJz4O2FrPOZOOaMNmnVoCa0L0Y+fhRLl53G2EIayN3DEd0lEUn6hM2Eh7r4KYg+XdB7 VHfUlvkigPe2cjVRmMKzOpqp/M9q1Byny4r0IC1Ai2/Gx4XTLI59E4Y5d0fDn06gQBxEZXUVzu+g ByKzTmLlH3OQ/z6F5Sfsl3amfvVBSChdBvmG0Rv28gyU6/fNSKFWps68GSPZT/QZ2iP5/4eP7P0u QUU2QgdOwIIp87Fi12mUfbYY9z7wGbr+ht6Zc8lECPZTdBzGjB6GqtJAhDj5qQKHttE0IzMCL/7h KI7TQ5kHXtCPw+rKYgx7aQ/uiYukgMaXiq/ihXviEUx+moJ/opx+Dc644OVLu5f2/AcTIoNxMHoK XUbxxZsfuoR2wjDfKHShmRtfIIIugNv7sk5T20Z/roiAw5dPCQkJSExM1NzQeHaje6fjuEHwnn+A fhttGPz0rQiL+Bzf/TMReRPj0Idm22dcOFE/VRhJs6IdlIbiDmUuLzx0IqGzr+Pyinm8aZrvTqew C+QkXjE3DHFMkQN3fguetLgr1RWeiJo7AnhqEz54qxpjk26G5xr9wHfFy+tD3lMGYeRU5R0wJeDY ztIhPaIXhtw0AF43xGLUr3jFyrk0+Ebtr0NpCgWfyX0Rd1M4aonXt3t3lUCrq7yK2kZ0Zh3FdMqO v3Eq4u2zv7AdU/CPZvipwrvr/2/vW8Crqq51/1wSSMSkhvc7PBIEeklqciyoGExQCr6SIohK9MD1 aKqnV8BTm0IPeAo9NxfkK5BjKw/9kiJErdDbgB5B5VGxCl8lSlCIJRFCDVpSoBAkIQnljjHXHtlr 76ydZLEb8mDMfCvzscZ8rH+t+e+55ppjDkyd8zhmJc9CNsaiZHl/7KbO3Zjj+aH41MmYlDraK1bf 4FqcpGtNSbkDd901EBMnTsSP+wz3ynlCzncicF7mOGF/e157OCKqO8mswGcnlpPOnsnQ7v+1+Vcq QZgJJ5ze3/v06YOBAwdKsq/fczCGDzqFz18Pw8ikHhh6exSOLSlHX9uWEr4ZPLH6uxyOuAfD8MXz Reb16su3PjbLJ3lM1OuWobSHziHzOsEKnYfoVehbA4jFmqjz4vEj2JVX5PNp/WJ9ffLIObbKN5Em hzv1ux7XE4nUkm7X6EGdcdF6ao2c+VE+T4s7SX+shvTGLlKH4bTaM1U0arHS/LdC7ZscC3xyDBg4 BMPHxGJYXJRvnQFj4RiREUUjiLPokRhr8vbt5fBeaLtO+p6L2gu8+FQc65s1/nneM6A1GexFSQlO /oXzYeh363Q6RXMh86ZjGIVsMIGngi58Q/NJ9Hm5mlaK81dmHkEUnfkbDf6sNGqqzUVi/CNp2Lnx OAYmjjE/fHG96b43y11G3uqTKLpgfY0MjZmAVSmk7JKxFMWVVqPqTpdibyG/arGrQ0VpKWjXXOOq K8pQVmGNi0Cf9UtLK0iibbl2QzgRERFITk5GWhq9kAd0URj+IP1G0ysL6zV1/04MSUYg4bs9TA7u gDwqYcfh+rmTMKIUzyBg4PRk9HivEL+kieQNzx4nKWtAG5F4K+7MqsKGATzJ/DIOjknE1Ad70/nG 66z5mh6Qf3sfXwf4dfZpB5VmOe9EtTeFxwtRSH7zVkx4Mxnf8pyQawgdDHye/jKW9Pkllg9YhRdf oDmVLoTFim1Y1sNKW36/Z8KWrt7UO+ImTKVtO7aMtCbOl939Ab1C+WHD9QxiyvU6jg2YOYU635+w yvMpf81aIi5yPtdjw7XfPTeYtiyZIpPGrG8Wg4/PmWxN/uO7YLT7fSSjGrxudOFZqOibsa/gdez5 4c0kbVEVTS2bnF3ozWdhcn+E0Odlfqam/ormY7r050SEhVhpEVNpwtZIR5ntRkbMXIvcsS+hl5ng DcGda6yJ6AZtIr04u+PzgfKypLSJ55DExd2bZdoSks5tiEZmwSEsicrCyKgwMxkd1i0WzxfRNRpX hdzYWKw9yPOWpN6XOxiDVx004cpDLyM2NtdzHSapTfwLoVbwnWDi4YPDfDBWjAm/cPNPF3+H44M/ DbA6YuSlS5deIt+4bdu2mdEHj0C6du1qwnwzu9AnmM6daVtCurmh9BVB9DIuXrxo5mN4TuaNN95A RkaGFNVGfNK7qqSXHwdVbdY6504ZQV+VOoxjnbDa/0HX6/6aanhzee68POfVlONN5+tIxaQ5sk2V 1Qrnq2nhXS19OuOvZG6dq7x11aisC/Wpp5J2D+DRSkvsIKC6VG7v5j9cnjqFbB/qV7b5fO2X1u6j 9EPBS3Qux3V2IOWA5fDnefd9NWBxV/pEOH8yv8xKXeXlz/N+OEVG8+x5+3ft5pWq/UOtV6AIKAJK OPoMtBwCbUwfqeUuVEtuLgIdjnB4vQ7PEV31TvWRPI8Aqwd49aQS0udj9/EAM/hX/UPT8gB0OMLZ tGkTnnvuORw+fBh///vfWxxB1hFqWiG0Bu8m5uANP+XKlm5cY/pIZ0lnqOrEe7TaJR7bSTu1tuos Xn2SVrle4O8z60kfib/QWc5XH4lEaF1LQH2k2iqcPUtlPUq6QDRn01r6SCFL6euTx12gj0qLaBFo 7alDmHokGz9cv19ONe3XHUBqSAKaunW8XWxISE6jK5qbrqzjS3Q4wuFb9s0332DdunVYsWIFyspk zYLDzSQVgVduz8PvfurRqr69AKUVPDqqxvtP5GEdqR6wTtUbpKVdVfxH0vT2aHM/sh0n6EfSSUfI Se7LV7Zg3zHgs4lrSLv7U2xdwkfCAAAf+ElEQVS9/QV4Nb9FH8tT588L8AtTz1q8X0irecldrDiC V4iwuC2rf15k1A/MCdVHalofiYDidThdukYiNHoEpj2aYizzVBbnITU1E3PTafSTkEMrq05j8+J0 z5fUBOTs4OemGhv/NYNW9BQhKYI0zo2WuYNcdTHmxc8m+dmIIG317duWgj9rWx+raUH21sVIX7wb Vp1zMZ+0v/mLbercfFR4FspUFOYTsVkjscWbS6msjuk6JOHIreKNyF988UW88MILqKhw0gG4iLOf nKVN0r+Nxw5PRwLKsHF1icled/gsvloNTC2ciQmjziB/3IfoT/sWZ339KMb3+Ay584vQyV9HiGxX Ocn1nTaeFuwBQzdMxUOPjMTQ7wH71loPVVXhPnz+yUBSU6DHm+ukpfP3HZqJe54Nwx8m7iZjfTXY /eAWnP/pdLIa+hCiVuzC7+XnVvWRmtRH4iV6vL7jwjencLp0K35CypGPD6V1WbUXsHPnGiBjH07s moVT+U8hbePNOEojv1NFCzB7wmBsPh6Ku59dTmPAeBQcOoF/jo9EqZPcqVg8s30R1bIIh078CuO/ Ox7xBbPo1Y2SaCXMxskLcfNEUjQ2ddINnrYeJ45up3s5A6s+pOeSlEwfS5qBfympwqXyAixMe6zJ ERWX3B5dhyYcuSFMPCUlFpFImvisajD1ZzegW3RvjF9KtLDiS7PKuPoU8O2378KwQbQo6/AhUgft jaRUelBDuyLxcXr1WPcVjTQ8OkLXWTpCVYcCyIVeSxYjaO1Oz25mDcqw6f8EvF6IL2kFcPGKz9E3 N8EsbuItJhJ2TkZMzyiMmjmOFkORsT5q+1efkGWHd/fgdz//PY5Rw6tJmdNylj5SL79PqHJt7LM+ 0pQpdKRNwbix9jMBwvX6SDuNPtIHr7I+0u3oZQ22AmSiZB5GGH2kGzF27ChLH6leWvSR3iF9pGxs oD5XdMZakGfXR4q7fgjlsPSR+g0eQa975UYfydJlapjXq4/UD0NYH8ksH/PoI5HJZ9ZHYmct9huM brGTMYqUWVdOHUap3GCqa2oietIX53eXrEfGArI3T2tsokffjVV0i/f/uRLh3a4jnfTuGEA6aeGh lQHlInvyUsxvoX9PHkklYUEGPUpv049KxU4a98zB9DFUCREO4ldh4b2j0TMmFQuXxGPjh1+gruxT 2lQD+P1Lz2Hxc69T6CStUyOvA7pGHtX2f7W86PCWW27BTTfdZFaVBrwiHtY6IuHp2Obmh5tfSqsM TrcycNZ614ickfEQRadBo/DtQR9id95unPzvKExeQ0Tmefuvq/Wbd6o7T5o+tLL39hEYPaATRt2R gOuGN281iOojWXeGlLqxaM8pLOBO73H+/Znpp8e1vppkPDISZwiAYG9KzpIPxYQfLsG0x19C3p/3 IGXlMlJGobEOL6elErhu7x2k/QPO8FAoDXek3QXS1sLEB67BcN+mcMYO4TrkCIdNlrLu1dNPP03v 6amNkw2NU746yl8tLmL/2s8R9uzQBrakIuKG0hLrMhwstr5ulLzzBdkSt5a923WEGpOro6FJ1Tcy MumKpJ/2x7EfFaEmk4zneZ6+0G5k4+oIDXPIffX2PtQOisPAnv1x/XdoOwh6JoeRvtPwMUNwXYSs 6lV9JAOW/z+bPhKfYpKgnToacZEYR3M7KzbsslQBKv6I14qI5HtQryemOUl/lh5aY3L8bFR7fjZI uyLpPswpysashSfx4wcTvXUXHUE5z8vXlWJ1VhEenRyHyFEpRDcF+KJmoHluxyTFtesFkt6LbRjq cISTmJho9lC5++67jZpFw0v2TeHn8A/j1tCE7C/x+70xuH8mD+ut8Uuo6IZHDsH9v7neI5eDLT/r hu+vTjR6Hz46QgHlwvE//6s/vrg/D6vNlqBA39QRpp7Eh3l4b7nQKCKazI1mcnhd5imMzx9LL3y0 G+Ard6L7z7aZdG7njoOWch+M/SvVR2L0AusjWXM4orfkgdrybLpPiU/mYmXlDETxxG2vZMTl0rYT /EsQOQpZjxfRroLWNqWB5CJHTaYXpyzSt/JscRo6DFPmUTVpc3Ebzc9ZjsdMK0gviuoIi8WeOa9j FltYDR+NtftysSG5lzVpHfYADlrKXJKxw/ghdCX8bsDEwweH+bg6dKloj+HnB7yLyUf+Fw1la8m+ FO9104hjXSDSm+Nd+Xzk/HWEAshdZL0j0iHgnfdqindh+bgzeOyvZPjOVFlNFkFpEvPXZLgvrhNq aHm7/w59VZSftwn1T2+kxW3ulCudIr/Wu8rroI/kV5xjlDXI+YWHtD18XDVhH0rPB3cOds5ydbTR eR3tGsiZq5GXGoH9/16O5Z7tTisLcxA1qwvO7s+k96tqj5wpzvOPdKiMDh/NA9mTWzisulQtDLC9 +AgaQ4C0mjs3R6GQdYH4s4e/89cRCiDnJbSL+GzNIfT9rykesrEKDB8cRgp6RGX0tHf2r4PiTsqk DmJtOsmVTpHflbjK66CP5FecY5QVkJ1cuGcCWs45y5HCpUcJqq7sbSzfOQevvd1PsvAwjCbWeZRD Aye/8iwh3uLUuX7rfPv/fyWJtO2hFT4Ej/7VeoW6so3rhBt+8QRu8Kk0HLf99gmfFI20XwRCY+7F /kv3+lxA5OhMXPqdT9JVF+lQczhVx47hYOHXNP0bwJ37Kw7uPoJzPp+WGspWlh1AYelxlBYWoizg u3Qdygr30kLB4ziw90Cb23ek4VVpiiLQ+gh0KMI58dY2bLljv3clrh++NUc+xRbaEPyY9bHJ76w3 enBdPGZt+ghvzkrC6k9kvaj3vBWqxGtJY5G/7yPMHhuPTwISk38+jSsCVy8CHYpwet04CGH/PKDB Z225vZ3jBtAuYoPQh7cQa8T1GZlBS71qUN09BckjvGs3fLNEYmgapdTU0D588zDMaW7HN4PGFIGr HoEORTidyLbQqBTa1PtYEZ7vsZbsLPHefPSpecsm/OLpj4lCrkEcrbMxa6oa0UPqP+GnWHbvjbh3 2TIkRZZhcUII5nv0W+rKNiMhZD5KaUe2Cf93H6b9041YuOcR9LrqHyUFQBFoGoEONWnceVgiJpll Lf0w+f8UYuOYd9CnMBa/mVWOlKJ08yVq0lOerwaN6CGxkl+iGdjw+lAyXpm7ClFJsUgm9Yg/xaYh 9a1yDGPkSJfKiNk+RJgM+k8RUAQcEehQhGO/wmGPT8OYrS9hQ2IpBq2ejhv6+aycIdGm7SJJeZGJ mSha9T7iacNqkNGyqknKMIKN+oqAGwQ61CuV74V7CSayt3mJ8j19mbGUvtE2PZjLLESzKQJXKQId lnDK8l7FXnwXM8hc72fpG3Cwwe4UTeshyTNRXZyH+B8Aew5tJ7vPyVi8u0FhIqq+IqAINIJAhySc i8c+xqs/Ar7/67EYMG4C7iFTP1se3GW2najHorl6SHVlmDdyFlbuy8GYEal47b0lZMKI9ivRz+D1 UGpAEWguAh1yDqfToBtosyrvOt5RzzyBUc/4QRKeiKJLl/wSHaKhMVhuk+t5649hizpk0CRFQBEI hECHHOEEulhNVwQUgdZFQAmndfHX2hWBqwoBJZzLvN2VZbTOJy8fm3eXtjmD8Zd5SUFl460jKmnL hbom9NScKzmHA7t3o+R0MzJXlmHrxnzkb96L5oj71ldJem+F9RuX+55rwVhA+1x1KCncg2NNKfe1 YNOudNFtnnCuiJ0psuH0sGfHfN5NP30+7abf2J2gVcppg5NQSJtInPvL8VYnnAN5D1sbN3muIX11 YWOt/4eeq6SNyTOp3oioKERFRZAd+RDkuJ1Rp32JnkpORv7nTc3EV2J12mBkFdag87k/44Ol8bCb g2nywioPIn5sEoppT6N/pDtXSFYaQlb6fpSwV1D1JyQlx+PTBpdXjd8m3YS8hifsuTtUuM1PGrOd qa1bt+K+++7DsGHDwNuHtoQrZ/tMJ/bihq/fwG3x0/DbB+9BJu/G5uhqSX9qEZ6ZOdVaaewocwUT z5bTpr3bUTXvZrIvVYswx017WqA9RLxP0sbk5YvewtkFk8BonS4rxl+uaXQ/z4YNoW1C0kePxvVD o8H2nSLiaTvWS085rne6cDIFy5+ZiVRa4n3u+HdQFjqgYXmBUiKuoa08Uxz3GgqUpTnp4cMzcKgs IqAOH7Ew1ZqCrgYWHsV5u13UaIo6bX7UnIrboUzL9N5/MBDNtTN1YtubWJJYgK/MyLwGHz29Fq9s +ovVmkZ0pyyB7riONj+KHj0eqZRw5rw1vG9oL4gsOT6WRDvQLkQ3MpCWd6ASdRWFmEv6VmZ0tHir tVUF1Tc3NR3z57Oto1TspZ3gCvPnekYi6dhcav3cGVtFZA0yZ36qOZdK+UWZvXgz/3J6yjWjFucy eFPueNIjC+dNpyIjyacE//or/NtDm84Vb0S6p/yQh3NQZiquRH5mOjLnW21dWngaxTSCSlnZcNR0 /INXyGTeHOR6yIZxjI4ZgRE9w1FNOmdiZykkfSlKbWXPz1nqqdeLw/WPPonBnX3tO/kPlA7kPYnZ RTsxgbb7zMw7gC93/RL/+e5RrpbaOJdGpjmYn2rh5bXtdBr5cy07UCFhZO6Ffioa0mEFcmjv63yr kWa/4fkJmSg8XYrFnvJCQtKx1QLI1JWaOd9cQwIZ3Kv78m1k/edbZoRTunmx957Z7mUUWbd6eRGP RMMQkjofhR6DVLzfsriGzxrdRloDFpKyynH0VEb2rkISWK+PS6jG5rmpmLuxVIprk367IBxBrik7 U72+dxuSupVh3bOf4cTendi+rhe+d19vK3sjulOWwE4U7z+ArTn/TrvOPo7JCfQT6mgvKBL3kbG6 lHi2QbQLD4wMw/rpSfjrghL6XH4UQxZORq7pKbU4srMA2VUZOHpiE75dvh5JM86jpPYSyt8agrQp +RYxsa2igmzsiMlGeUkBdi7Mwn7iourSfIxMy8Kq947Stqan8KspcfTwOZfB+/kWvbQUi5cuJoJb 7encvvUnRfrFI4rx5MhpuHn7UVyqPYXXe8zG4HlbzethzeECrMkm21lHT+CJ+Gj0HvevWJQ6QG5D vX/y8B6y63QLGdBxcGFDsKzkLGFSjkUFWdi039rmg8vOnv0B/q28HAWkJpK26SBlvhaTZv8AI64b 4WPficxA+bjRD/wHFsWnGBtRyx4YifMVn+DDL/9mZGrJNENB9mzEZB/FoYI5ZNtpkzFEd3zzTzBj xwxjb+roeytJ9qyxmuBTMHpiTMpJzMj/o0k+vS8f2UhEXEQEJi4jfC7V4r1FBZj82n5znuvaSQDd v+8odj0Rj7rzZ7B5TYUpN2LIXSg5ewmXTryFAs+9lLpWYBrKT5WQcZpsJK36UJIt3/FZo7FQ73HY vuA2x9FezKQfYlX3bMQu3IGyvTlIWzEWzxgTOL5Ft6WYd2zXllrVRFvEzlTPnvW7U3tydMXt/+8e lA3ZgtzVwPi9P7Bt4dm47lQUlbCE7E0V0W79qw5VYTTt9FhXatkL6k32gkrpPVzsBUX27k2/k2yD iNQcaPf9/TuB8riXsJjykcklLKq1RkdspmVf9lSydQSUfcgP62G8lL0YVX8iqaIlpnOHeuwjvZw5 BpE0l5RCG2OwO/zub+j/Sjx0a4x52Po1UoYpwtiEikfNua6WTShqgr1+0DyJPV554GUanTyOktQY U9/dmauAkUWoXH4Lzp4kLPYtQmKMp8fHjsWtRsrh3zWdbS8I3vPh/Uajz4EdyMv5A/22A+meYYXX llQkDrAtqWrf8YZl3wmWfSdvcVYovBe+1T0Kvfv3hHcnTut9ROxbZY6JocGdbIRfh4/eXIOMrBJj bwo38YuN85Z7SQ/R6tDY9Ti+4FZ89PxCzFlSTnX0Q0KfA/RxYCve2QikPGq1Vep6KNHC7pznEtiL Hj0KB3ZsRM4f3qHYkPrRlMF+0b3oRz1u1rIlmJ30MU4vuKH+CsU2lf+zFhodS5ZH6sX8AtHILNiH 96OSMJh+IF4nQ3ptXcuvXRFOs+1MmdvCk5jNfznmB2L9/rdRPjcMk3/yKh763Ux6rzpOJTnYC/JM OhpaqTuDIySVcsdk3DWwMyZOfAB9hnt/msWe0dmvSCplEibfdTs6T5yIB37cx8x5eIoyLbb/u4Ze jXiYbHeByqglKolPnYxJqaO94hbnWQbViKzESXusn/nu1lYd5iQP7m2CzZgKj+obB6zZifLV9xq7 S1IH+7uXpiJ5w1hsz51MFk29V2K9QliN41dBd87KV9NEJm+5VTi6Bxg4nX9OGnehw+6gWbkZWL95 PD5Yn4bFa/uhYvdS9EregNztazCeOv3hxougsxVYmtALG1JzseYBsr658EXf0RQ3P0CPC942VRp6 R9nvX5ONbRWBdvFK1Xw7U9XY9f0twLI7yVRuLbaM3EamcsU1rTt1vjIUk7L3IY3MtP6I3oUbtxfk IYPwUUhPAXYSNyWSLawxY5LQO6LhUxU3Pp2EttLTn2hsDyXFOb6ISGMRcwvv7rUB24r5VaSOTBWf RqAy+Je16MzfSKrOWBOo9pBNfWEOgci4cUSx2dhVTO9v5P74Nv3yp/WzEZA3U/XpYyg5fs6b4AnF pGRSGSswi+YqrBcmmjQuLURh2Vf4eMNOzHv+GaQm9sN5I98QkwYFckIt4+q17+Qo01RiPeOQHakZ 8cjOedO0r/i/XzGjLc+AxK+UnpiWm4GstBk4Mu8pM8L9+iDdrznLMTM1CdfSRZz03HK/jN5o5RfY QCPk5QtnYkyfzmSR/KT3HNVcfJSxrsO21VmIXznO54NDwGeNPqmXlJygXE6O5hPTkoDcPXhv5Vkk 91ra+NdVpyKucFqbJxw3dqZObHmTFDbjMX1mLEb976lk3fJzvLqGxx/kmqE7ZR5EUnn4FdmJXjPt MeyoHBnYXlB3+TUJR8Zre5AwO9kzWRiGNQel+3knKMNHZGAfmfRN7mVNaobd+WvvVqg2+0jyWxwa M5Xkx2LayG5morHX9N+gNlAZXfqDFLwQRhOSETTvEDE1z7PHsrd+CwRbPDKRfrmXYMbIKNPu5NkJ 2LM23Yxx2K6A1yAK/bKvuxtxL35qFWH/T2VsOkTTsDRv1c0z+dwtNglFVddiYtYcZCdz2x+jeZ54 ZCU9iQPUYe1l221JSbEN7DvJCQef71d3LpCcCcstYesI8Vb6qOnLkUE/INy+kQvepERB2Dpv/z/i rhkm29xHbjTJg2/+FzIjNcHg/zoyUJSVZD4S+NQlBYymOo0Nq3gzqR0yq4AuuwhjH6Z7QQTItVpY h2Hannl4bZZlHI+b34VbH8A21blD6xAXJ/dTKrP8ss0LMQurkDNzDG59aj2WxGfhsSu4JMK3Nc2L Xd12qZqHEUk1z15QJS1+40/S5itRoLKraYFcbVizzYHUkXwVPZCRdvMlLssI1BSTzvab6L2OTdA0 cwziUFwdTp/mX+9QRETT9Xsk6tjGE7Wby+VFgc03gWK37+RQneskLq/KfMFzn5VHW2Snii7C3zZV oLLYZpVlRoawrSbTMZSZF0SGhlrtiKDX5cBYN+9ZC1T35aSrXarLQa1F8zTPXhB/km7ShUfaJjyb lEYoy/uLuSzDP7tP3HxK90m5jEgooqOjG+QLtZFk88mGi/Had2pQ6GUlcHkNUGxeSYSPEKi/bapA BXhtVtFz48kcahimOe1o3rMWqO62nt7mX6naOoDaPkVAEWg+Ako4zcdKJRUBRSBIBJRwggRQsysC ikDzEVDCaT5WKqkIKAJBIhB4sjzIgt1k37FjhxtxlVUEFIF2ikCbIJyxY8e2U/i02YqAIuAGAX2l coOWyioCikBQCCjhBAWfZlYEFAE3CCjhuEFLZRUBRSAoBJRwgoJPMysCioAbBJRw3KClsoqAIhAU Ako4QcGnmRUBRcANAko4btBSWUVAEQgKASWcoODTzIqAIuAGASUcN2iprCKgCASFgBJOUPBpZkVA EXCDgBKOG7RUVhFQBIJCQAknKPg0syKgCLhBQAnHDVoqqwgoAkEhoIQTFHyaWRFQBNwgoITjBi2V VQQUgaAQUMIJCj7NrAgoAm4QUMJxg5bKKgKKQFAIKOEEBZ9mVgQUATcIKOG4QUtlFQFFICgElHCC gk8zKwKKgBsElHDcoKWyioAiEBQCSjhBwaeZFQFFwA0CSjhu0FJZRUARCAoBJZyg4NPMioAi4AYB JRw3aKmsIqAIBIWAEk5Q8GlmRUARcIOAEo4btFRWEVAEgkJACSco+DSzIqAIuEFACccNWiqrCCgC QSGghBMUfJpZEVAE3CCghOMGLZVVBBSBoBBQwgkKPs2sCCgCbhBQwnGDlsoqAopAUAgo4QQFn2ZW BBQBNwgo4bhBS2UVAUUgKASUcIKCTzMrAoqAGwSUcNygpbKKgCIQFAJKOEHBp5kVAUXADQJKOG7Q UllFQBEICgElnKDg08yKgCLgBgElHDdoqawioAgEhYASTlDwaWZFQBFwg4ASjhu0VFYRUASCQkAJ Jyj4NLMioAi4QUAJxw1aKqsIKAJBIaCEExR8mlkRUATcIKCE4wYtlVUEFIGgEFDCCQo+zawIKAJu EFDCcYOWyioCikBQCCjhBAWfZlYEFAE3CCjhuEFLZRUBRSAoBJRwgoJPMysCioAbBJRw3KClsoqA IhAUAko4QcGnmRUBRcANAko4btBSWUVAEQgKASWcoODTzIqAIuAGASUcN2iprCKgCASFgBJOUPBp ZkVAEXCDgBKOG7RUVhFQBIJCQAknKPg0syKgCLhB4HIJ55KbSlRWEVAEOiQCrnngcgmnQ6KnF6UI KAIti0BzCcfOZBy2x1u2hVq6IqAItFUE/LmgSV5ojHD8M/sX3lZB0HYpAorAlUXAiRv8+cO0qDHC ubJN1toUAUWgwyPQFOEEYi5H9urwaOkFKgKKgB0B1/wQiHD8C5K43bdXrGFFQBG4+hCw84GEBQX/ uEl3IhwWZCcZnPy/WyL6XxFQBK5iBJgHnPhB0hgaDtc7J8KpP+kJSGb2uQKpxF9O44qAInB1IeDP CcIVAVEQwmFBdnZfMosvRMP+RSOt/xQBReBqRoB5wM4LwhV2n/HhOLtLIfQvlA72O9HBBMRxPjp7 ji7kh9NxDR0RdHT1hNmXg9P5YDk+JC+XI+Wyz/XYD4qqUwQUgVZCwE4MHBYCYb+OjhrPUU0+H1We 4xvy5TjvCfM5DrPcBTokL5fDhxmoMCE4OWmIsJd/Y6RBXFAtHUJSQipcpuThNElnsmFSY1+dIqAI tD4C3E/9+7n0b+7bTB7s2w8hEZbjw5AJ+U68QcleZyccERZfGiGFiS+VCdlwQ5hQ7ETCZXBDZIQj hCOvcOKTiDpFQBFoRQS4X7OT/i4kYu/fTDoyahHisfOAnXSkHPGFT9g3hMC+ODnJcQlLRntDpDIe NgnZCIlwPpEVwuFzcl5eqSjJOB3tCBLqKwJXBgHT+T1VST/nKPd1Prj/+hOOvCIJ8QgHsC/9ncsS vpA67OX7EA6fkM4vQvbKmTykEmY5bgCTiIxeOI80WOSEjETGTjokbpzUKXH1FQFFoGUR4L4qTsJC FEwe0u9lNMN93T7KEfLh89LXhaQkv3CITz3ySsUnpeNzZUwM0gA+x2EpmH2uSMhESEQq4PNhdMjo xk42Iit1kZg6RUARaEUEuN+y4z4ufV5GLNLX2ZeRjfhMOnbCYRnJL5whPp0y7hKTAicyAbAvB2dk cuCKxRcG40o4zU4aLC+N5DKFcFhOiInlJY/4lFSfxmF1ioAi0PIIcD8XJ2F73+e+zH3aTjgyqmHf /iVKSEf6v/hcnp2ATD12wqHzxtkbwBmETLhyJ/LgTHYZLlMOJhw5lHAYKXWKQOsjIH2cWyJh9vmQ Ps8+93k5mFj4YMIJNMoRouK89nIpajkmBnFSIRMDZxCC4EIkzORhd5KHG8WjGj6YlLhc9vngvJxP yqCgcRxXpwgoAq2HgJACt0D6spCFjFS4b3NYCIfj9tEOh2WUI7JchhwUrC+7ftKYK2MCsFfKJCGZ uEKOc4Hi7LJMMHyOK+Ywy/LhPyJyIhmnNMqqThFQBFoIAe67/k76M/vc77nPS//nvm0/ZKRjJyEh KMkj5Ui5VATMHA4HxIkQEwVnZMc+kwIXyI5lxHGY05lkZFRjJxoOc1722Qm5iG+l6n9FQBFoLQSk P4vP/Z3DQhxCPOzbSUcGGDK6ETnJxz47Kc9EmCTYcQVCAhyWCjmNCxLH6ezkPFfaHLKRsv19U5j+ UwQUgVZDwN6nuRHSt8VnwhAysZOOhO0+h/mQvOzzIc5nhMMnhBC4Eh6VcGZ/Zy+M5fhg4pHXJ84n B5cnZfqH6ZQ6RUARaGUEhBDY9w9L/xaf+YDDQizc7/3T5LzwBIkYZ8rm0QkHhBQkLMJMHFwAO5PB 43OYD65MJobthCPkYvdJtL4eDqtTBBSBtoOAU/+Wfm4nHOn3QixyjsmHz3Hc7vMVctw4IQSOSJh9 cRwWQuGwjFycfDnPvj1sL4vT1SkCikDbQ4BJoZ4YPGEhDzuBCME4+VIGD0T8yzLnnEY4DIUQg1Qk JMLn2Ek6E4+dXOxhlpNy/H0+p04RUATaDgJCEE5+IOJhWeECu4yUwVcnMuZKhQg4wmGJ230JC7mw rIQlD/ucxs6eJnFzwvNPyrOnaVgRUARaDwE7QXArJC5kIXF/UuF0TmPnH5Y8dt9n0tjKZv1nISEG ycAFC5lIJRJn3ynNKs36L+XZ0zSsCCgCbQcB6evSIo7LwWkSFj9QGqezYzkf508CEg/kc2b7OQ5L XM5JXHxJZ1+dIqAItG0E7CQhYTvBcOslbj8vV+Wf5hO3k4JkkDR/n89Lmn9Y4nzeLsPp6hQBRaB9 I+BPMHI1QiYcdwpLmvgBycFOGhIWXyrzj3O6U1pj8nJOfUVAEWh9BOqJwaEpTuf80yQuPhdjD+P/ A9G2W3H5LMB0AAAAAElFTkSuQmCC 34170 2009-08-05 13:35:09 -0700 2009-09-04 08:16:56 -0700 patch containing work so far patch-27514--2009-08-05-a.patch text/plain 13684 pmuellr SW5kZXg6IFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9TY3JpcHRzUGFuZWwuanMKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1NjcmlwdHNQYW5lbC5qcwkocmV2 aXNpb24gNDY1MDcpCisrKyBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvU2NyaXB0c1BhbmVs LmpzCSh3b3JraW5nIGNvcHkpCkBAIC0xMjcsNiArMTI3LDcgQEAgV2ViSW5zcGVjdG9yLlNjcmlw dHNQYW5lbCA9IGZ1bmN0aW9uKCkKIAogICAgIHRoaXMuc2lkZWJhclBhbmVzID0ge307CiAgICAg dGhpcy5zaWRlYmFyUGFuZXMuY2FsbHN0YWNrID0gbmV3IFdlYkluc3BlY3Rvci5DYWxsU3RhY2tT aWRlYmFyUGFuZSgpOworICAgIHRoaXMuc2lkZWJhclBhbmVzLndhdGNoZWRFeHByZXNzaW9ucyA9 IG5ldyBXZWJJbnNwZWN0b3IuV2F0Y2hlZEV4cHJlc3Npb25zU2lkZWJhclBhbmUoKTsKICAgICB0 aGlzLnNpZGViYXJQYW5lcy5zY29wZWNoYWluID0gbmV3IFdlYkluc3BlY3Rvci5TY29wZUNoYWlu U2lkZWJhclBhbmUoKTsKICAgICB0aGlzLnNpZGViYXJQYW5lcy5icmVha3BvaW50cyA9IG5ldyBX ZWJJbnNwZWN0b3IuQnJlYWtwb2ludHNTaWRlYmFyUGFuZSgpOwogCkBAIC0xMzksNiArMTQwLDgg QEAgV2ViSW5zcGVjdG9yLlNjcmlwdHNQYW5lbCA9IGZ1bmN0aW9uKCkKICAgICB0aGlzLnNpZGVi YXJQYW5lcy5zY29wZWNoYWluLmV4cGFuZGVkID0gdHJ1ZTsKICAgICB0aGlzLnNpZGViYXJQYW5l cy5icmVha3BvaW50cy5leHBhbmRlZCA9IHRydWU7CiAKKyAgICB0aGlzLnNpZGViYXJQYW5lcy53 YXRjaGVkRXhwcmVzc2lvbnMuZXhwYW5kZWQgPSB0cnVlOworICAgIAogICAgIHZhciBwYW5lbEVu YWJsZXJIZWFkaW5nID0gV2ViSW5zcGVjdG9yLlVJU3RyaW5nKCJZb3UgbmVlZCB0byBlbmFibGUg ZGVidWdnaW5nIGJlZm9yZSB5b3UgY2FuIHVzZSB0aGUgU2NyaXB0cyBwYW5lbC4iKTsKICAgICB2 YXIgcGFuZWxFbmFibGVyRGlzY2xhaW1lciA9IFdlYkluc3BlY3Rvci5VSVN0cmluZygiRW5hYmxp bmcgZGVidWdnaW5nIHdpbGwgbWFrZSBzY3JpcHRzIHJ1biBzbG93ZXIuIik7CiAgICAgdmFyIHBh bmVsRW5hYmxlckJ1dHRvbiA9IFdlYkluc3BlY3Rvci5VSVN0cmluZygiRW5hYmxlIERlYnVnZ2lu ZyIpOwpJbmRleDogV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1dhdGNoZWRFeHByZXNzaW9u c1NpZGViYXJQYW5lLmpzCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVu ZC9XYXRjaGVkRXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5qcwkocmV2aXNpb24gMCkKKysrIFdlYkNv cmUvaW5zcGVjdG9yL2Zyb250LWVuZC9XYXRjaGVkRXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5qcwko cmV2aXNpb24gMCkKQEAgLTAsMCArMSwzMzggQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMDkg SW50ZXJuYXRpb25hbCBCdXNpbmVzcyBNYWNoaW5lcyBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQu CisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jt cywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlk ZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2lu ZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRv Y3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0 cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMu IGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9G IE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NF IEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUws IFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAq IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKK1dlYkluc3BlY3Rv ci5Db25zb2xlLmxvZyA9IGZ1bmN0aW9uKG1lc3NhZ2UpIHsKKyAgICB2YXIgbXNnID0gbmV3IFdl Ykluc3BlY3Rvci5Db25zb2xlTWVzc2FnZSgKKyAgICAgICAgV2ViSW5zcGVjdG9yLkNvbnNvbGVN ZXNzYWdlLk1lc3NhZ2VTb3VyY2UuT3RoZXIsIAorICAgICAgICBXZWJJbnNwZWN0b3IuQ29uc29s ZU1lc3NhZ2UuTWVzc2FnZVR5cGUuTG9nLCAKKyAgICAgICAgV2ViSW5zcGVjdG9yLkNvbnNvbGVN ZXNzYWdlLk1lc3NhZ2VMZXZlbC5Mb2csIAorICAgICAgICAwLCAKKyAgICAgICAgIj8/PyIsIAor ICAgICAgICAwLCAKKyAgICAgICAgMCwKKyAgICAgICAgbWVzc2FnZQorICAgICAgICApOworICAg ICAgICAKKyAgICBXZWJJbnNwZWN0b3IuY29uc29sZS5hZGRNZXNzYWdlKG1zZyk7Cit9CisKK1dl Ykluc3BlY3Rvci5XYXRjaGVkRXhwcmVzc2lvbnNTaWRlYmFyUGFuZSA9IGZ1bmN0aW9uKCkKK3sK KyAgICBXZWJJbnNwZWN0b3IuU2lkZWJhclBhbmUuY2FsbCh0aGlzLCBXZWJJbnNwZWN0b3IuVUlT dHJpbmcoIldhdGNoZWQgRXhwcmVzc2lvbnMiKSk7CisKKyAgICB2YXIgc2VjdGlvbiA9IG5ldyBX ZWJJbnNwZWN0b3IuV2F0Y2hlZEV4cHJlc3Npb25zU2VjdGlvbigpOworICAgIHNlY3Rpb24ucGFu ZSA9IHRoaXM7CisgICAgc2VjdGlvbi5leHBhbmRlZCA9IHRydWU7CisKKyAgICB0aGlzLmJvZHlF bGVtZW50LmFwcGVuZENoaWxkKHNlY3Rpb24uZWxlbWVudCk7ICAgIAorCisgICAgdmFyIGFkZEVs ZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJidXR0b24iKTsKKyAgICBhZGRFbGVtZW50 LnNldEF0dHJpYnV0ZSgidHlwZSIsICJidXR0b24iKTsKKyAgICBhZGRFbGVtZW50LnRleHRDb250 ZW50ID0gV2ViSW5zcGVjdG9yLlVJU3RyaW5nKCJBZGQiKTsKKyAgICBhZGRFbGVtZW50LmFkZEV2 ZW50TGlzdGVuZXIoImNsaWNrIiwgc2VjdGlvbi5hZGRFeHByZXNzaW9uQW5kRWRpdC5iaW5kKHNl Y3Rpb24pLCBmYWxzZSk7CisKKyAgICB2YXIgcmVmcmVzaEVsZW1lbnQgPSBkb2N1bWVudC5jcmVh dGVFbGVtZW50KCJidXR0b24iKTsKKyAgICByZWZyZXNoRWxlbWVudC5zZXRBdHRyaWJ1dGUoInR5 cGUiLCAiYnV0dG9uIik7CisgICAgcmVmcmVzaEVsZW1lbnQudGV4dENvbnRlbnQgPSBXZWJJbnNw ZWN0b3IuVUlTdHJpbmcoIlJlZnJlc2giKTsKKyAgICByZWZyZXNoRWxlbWVudC5hZGRFdmVudExp c3RlbmVyKCJjbGljayIsIHNlY3Rpb24ucmVmcmVzaEV4cHJlc3Npb25zLmJpbmQoc2VjdGlvbiks IGZhbHNlKTsKKworICAgIHZhciBjZW50ZXJFbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVu dCgiY2VudGVyIik7CisgICAgY2VudGVyRWxlbWVudC5hcHBlbmRDaGlsZChhZGRFbGVtZW50KTsK KyAgICBjZW50ZXJFbGVtZW50LmFwcGVuZENoaWxkKHJlZnJlc2hFbGVtZW50KTsKKyAgICB0aGlz LmJvZHlFbGVtZW50LmFwcGVuZENoaWxkKGNlbnRlckVsZW1lbnQpOworfQorCisKK1dlYkluc3Bl Y3Rvci5XYXRjaGVkRXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5wcm90b3R5cGUgPSB7CisgICAgbG9n OiBmdW5jdGlvbihtZXNzYWdlKSAKKyAgICB7CisgICAgICAgIHZhciBtc2cgPSBuZXcgV2ViSW5z cGVjdG9yLkNvbnNvbGVNZXNzYWdlKAorICAgICAgICAgICAgV2ViSW5zcGVjdG9yLkNvbnNvbGVN ZXNzYWdlLk1lc3NhZ2VTb3VyY2UuT3RoZXIsIAorICAgICAgICAgICAgV2ViSW5zcGVjdG9yLkNv bnNvbGVNZXNzYWdlLk1lc3NhZ2VUeXBlLkxvZywgCisgICAgICAgICAgICBXZWJJbnNwZWN0b3Iu Q29uc29sZU1lc3NhZ2UuTWVzc2FnZUxldmVsLkxvZywgCisgICAgICAgICAgICAwLCAKKyAgICAg ICAgICAgICI/Pz8iLCAKKyAgICAgICAgICAgIDAsIAorICAgICAgICAgICAgMCwKKyAgICAgICAg ICAgIG1lc3NhZ2UKKyAgICAgICAgICAgICk7CisgICAgICAgICAgICAKKyAgICAgICAgV2ViSW5z cGVjdG9yLmNvbnNvbGUuYWRkTWVzc2FnZShtc2cpOworICAgIH0KK30KKworV2ViSW5zcGVjdG9y LldhdGNoZWRFeHByZXNzaW9uc1NpZGViYXJQYW5lLnByb3RvdHlwZS5fX3Byb3RvX18gPSBXZWJJ bnNwZWN0b3IuU2lkZWJhclBhbmUucHJvdG90eXBlOworCisvLy0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQorCitXZWJJbnNwZWN0b3IuV2F0Y2hlZEV4cHJlc3Npb25zU2VjdGlvbiA9IGZ1bmN0aW9uKHdh dGNoZWRFeHByZXNzaW9ucykKK3sKKyAgICBXZWJJbnNwZWN0b3IuUHJvcGVydGllc1NlY3Rpb24u Y2FsbCh0aGlzLCAiIiwgIiIpOworICAgIHRoaXMuZWxlbWVudC5yZW1vdmVDaGlsZCh0aGlzLmhl YWRlckVsZW1lbnQpOworICAgIAorICAgIHRoaXMuZWRpdGFibGUgPSB0cnVlOworICAgIAorICAg IHRoaXMudHJlZUVsZW1lbnRDb25zdHJ1Y3RvciA9IFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0 eVRyZWVFbGVtZW50OworCisgICAgdGhpcy53YXRjaGVkRXhwcmVzc2lvbnMgPSBbXTsKKyAgICAK KyAgICB2YXIgc2F2ZWRFeHByZXNzaW9ucyA9IFtdOyAvLyB0aGlzLmxvYWRTYXZlZEV4cHJlc3Np b25zKCk7CisgICAgZm9yICh2YXIgaT0wOyBpPHNhdmVkRXhwcmVzc2lvbnMubGVuZ3RoOyBpKysp IHsKKyAgICAgICAgdGhpcy5hZGRFeHByZXNzaW9uKHNhdmVkRXhwcmVzc2lvbnNbaV0pOworICAg IH0KK30KKworV2ViSW5zcGVjdG9yLldhdGNoZWRFeHByZXNzaW9uc1NlY3Rpb24ucHJvdG90eXBl ID0geworICAgIGxvZzogV2ViSW5zcGVjdG9yLldhdGNoZWRFeHByZXNzaW9uc1NpZGViYXJQYW5l LnByb3RvdHlwZS5sb2csCisgICAgCisgICAgcmVmcmVzaEV4cHJlc3Npb25zOiBmdW5jdGlvbigp CisgICAgeworICAgICAgICB2YXIgY2hpbGRyZW4gPSB0aGlzLnByb3BlcnRpZXNUcmVlT3V0bGlu ZS5jaGlsZHJlbjsKKyAgICAgICAgZm9yICh2YXIgaT0wOyBpPGNoaWxkcmVuLmxlbmd0aDsgaSsr KSB7CisgICAgICAgICAgICBjaGlsZHJlbltpXS5yZWZyZXNoRXhwcmVzc2lvbigpOworICAgICAg ICB9CisgICAgfSwKKworICAgIGFkZEV4cHJlc3Npb246IGZ1bmN0aW9uKGV4cHJlc3Npb24pIHsK KyAgICAgICAgaWYgKGV4cHJlc3Npb24gPT0gbnVsbCkgcmV0dXJuOworICAgICAgICAKKyAgICAg ICAgdmFyIGluZGV4ID0gdGhpcy53YXRjaGVkRXhwcmVzc2lvbnMubGVuZ3RoOworICAgICAgICB0 aGlzLndhdGNoZWRFeHByZXNzaW9ucy5wdXNoKGV4cHJlc3Npb24pOworCisgICAgICAgIHZhciBl bGVtZW50ID0gbmV3IFdlYkluc3BlY3Rvci5XYXRjaGVkRXhwcmVzc2lvblRyZWVFbGVtZW50KHRo aXMsIGluZGV4KTsKKyAgICAgICAgdGhpcy5wcm9wZXJ0aWVzVHJlZU91dGxpbmUuYXBwZW5kQ2hp bGQoZWxlbWVudCk7CisgICAgICAgIAorICAgICAgICByZXR1cm4gZWxlbWVudDsKKyAgICB9LAor ICAgIAorICAgIGFkZEV4cHJlc3Npb25BbmRFZGl0OiBmdW5jdGlvbigpCisgICAgeworICAgICAg ICB2YXIgZWxlbWVudCA9IHRoaXMuYWRkRXhwcmVzc2lvbigiIik7CisgICAgICAgIGVsZW1lbnQu c3RhcnRFZGl0aW5nKCk7CisgICAgICAgIHJldHVybiBlbGVtZW50OworICAgIH0sCisKKyAgICBk ZWxldGVFeHByZXNzaW9uOiBmdW5jdGlvbihlbGVtZW50KSAKKyAgICB7CisgICAgICAgIHRoaXMu cHJvcGVydGllc1RyZWVPdXRsaW5lLnJlbW92ZUNoaWxkKGVsZW1lbnQpOworICAgICAgICBkZWxl dGUgdGhpcy53YXRjaGVkRXhwcmVzc2lvbnNbZWxlbWVudC5pbmRleF07CisgICAgICAgIHRoaXMu c2F2ZUV4cHJlc3Npb25zKCk7CisgICAgfSwKKyAgICAKKyAgICBtb2RpZnlFeHByZXNzaW9uOiBm dW5jdGlvbihlbGVtZW50LCBleHByZXNzaW9uKSAKKyAgICB7CisgICAgICAgIHRoaXMud2F0Y2hl ZEV4cHJlc3Npb25zW2VsZW1lbnQuaW5kZXhdID0gZXhwcmVzc2lvbjsKKyAgICAgICAgdGhpcy5z YXZlRXhwcmVzc2lvbnMoKTsKKworICAgICAgICBlbGVtZW50LnJlZnJlc2hFeHByZXNzaW9uKCk7 CisgICAgfSwKKyAgICAKKyAgICBsb2FkU2F2ZWRFeHByZXNzaW9uczogZnVuY3Rpb24oKSAKKyAg ICB7CisgICAgICAgIGlmICghd2luZG93LkpTT04pIHJldHVybiBbXTsKKworICAgICAgICB2YXIg anNvbiA9IEluc3BlY3RvckNvbnRyb2xsZXIuc2V0dGluZygid2F0Y2hlZEV4cHJlc3Npb25zIik7 CisgICAgICAgIGlmICghanNvbikgcmV0dXJuIFtdOworICAgICAgICAKKyAgICAgICAgdHJ5IHsK KyAgICAgICAgICAgIGpzb24gPSBKU09OLnBhcnNlKGpzb24pOworICAgICAgICB9CisgICAgICAg IGNhdGNoKGUpIHsKKyAgICAgICAgICAgIHJldHVybiBbXTsKKyAgICAgICAgfQorICAgICAgICAK KyAgICAgICAgcmV0dXJuIGpzb24uZXhwcmVzc2lvbnMgfHwgW107CisgICAgfSwKKyAgICAKKyAg ICBzYXZlRXhwcmVzc2lvbnM6IGZ1bmN0aW9uKCkgCisgICAgeworICAgICAgICBpZiAoIXdpbmRv dy5KU09OKSByZXR1cm47CisgICAgICAgIAorICAgICAgICB2YXIgdG9TYXZlID0gW107CisgICAg ICAgIGZvciAodmFyIGk9MDsgaTx0aGlzLndhdGNoZWRFeHByZXNzaW9ucy5sZW5ndGg7IGkrKykg eworICAgICAgICAgICAgaWYgKHRoaXMud2F0Y2hlZEV4cHJlc3Npb25zW2ldKSB7CisgICAgICAg ICAgICAgICAgdG9TYXZlLnB1c2godGhpcy53YXRjaGVkRXhwcmVzc2lvbnNbaV0pOworICAgICAg ICAgICAgfQorICAgICAgICB9CisgICAgICAgIAorICAgICAgICB2YXIganNvbiA9IEpTT04uc3Ry aW5naWZ5KHtleHByZXNzaW9uczogdG9TYXZlfSk7CisgICAgICAgIAorICAgICAgICBJbnNwZWN0 b3JDb250cm9sbGVyLnNldFNldHRpbmcoIndhdGNoZWRFeHByZXNzaW9ucyIsIGpzb24pOworICAg IH0KKyAgICAKK30KKworV2ViSW5zcGVjdG9yLldhdGNoZWRFeHByZXNzaW9uc1NlY3Rpb24ucHJv dG90eXBlLl9fcHJvdG9fXyA9IFdlYkluc3BlY3Rvci5Qcm9wZXJ0aWVzU2VjdGlvbi5wcm90b3R5 cGU7CisKKy8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK1dlYkluc3BlY3Rvci5XYXRjaGVkRXhw cmVzc2lvblRyZWVFbGVtZW50ID0gZnVuY3Rpb24oc2VjdGlvbiwgaW5kZXgpCit7CisgICAgdGhp cy5zZWN0aW9uID0gc2VjdGlvbjsKKyAgICB0aGlzLndhdGNoZWRFeHByZXNzaW9ucyA9IHNlY3Rp b24ud2F0Y2hlZEV4cHJlc3Npb25zOworICAgIHRoaXMuaW5kZXggPSBpbmRleDsKKyAgICB0aGlz LmV4cHJlc3Npb24gPSB0aGlzLndhdGNoZWRFeHByZXNzaW9uc1t0aGlzLmluZGV4XTsKKworICAg IFRyZWVFbGVtZW50LmNhbGwodGhpcywgIiIsIG51bGwsIGZhbHNlKTsKK30KKworV2ViSW5zcGVj dG9yLldhdGNoZWRFeHByZXNzaW9uVHJlZUVsZW1lbnQucHJvdG90eXBlID0geworICAgIGxvZzog V2ViSW5zcGVjdG9yLldhdGNoZWRFeHByZXNzaW9uc1NpZGViYXJQYW5lLnByb3RvdHlwZS5sb2cs CisKKyAgICByZWZyZXNoRXhwcmVzc2lvbjogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgdmFy IGNhbGxiYWNrID0gdGhpcy5fcmVmcmVzaEV4cHJlc3Npb25DYWxsYmFjay5iaW5kKHRoaXMpOwor ICAgICAgICAKKyAgICAgICAgLy8gRXZhbHVhdGUgaW4gdGhlIGN1cnJlbnRseSBzZWxlY3RlZCBj YWxsIGZyYW1lIGlmIHRoZSBkZWJ1Z2dlciBpcyBwYXVzZWQuCisgICAgICAgIC8vIE90aGVyd2lz ZSBldmFsdWF0ZSBpbiBhZ2FpbnN0IHRoZSBpbnNwZWN0ZWQgd2luZG93LgorICAgICAgICB2YXIg c2NyaXB0c1BhbmVsID0gV2ViSW5zcGVjdG9yLnBhbmVscy5zY3JpcHRzOworICAgICAgICB2YXIg Y2FsbEZyYW1lID0gc2NyaXB0c1BhbmVsLnNpZGViYXJQYW5lcy5jYWxsc3RhY2suc2VsZWN0ZWRD YWxsRnJhbWU7CisgICAgICAgIAorICAgICAgICBpZiAoc2NyaXB0c1BhbmVsICYmIHNjcmlwdHNQ YW5lbC5wYXVzZWQgJiYgY2FsbEZyYW1lKSB7CisgICAgICAgICAgICBzY3JpcHRzUGFuZWwuZG9F dmFsSW5DYWxsRnJhbWUoY2FsbEZyYW1lLCAiKCIgKyB0aGlzLmV4cHJlc3Npb24gKyAiKSIsIGNh bGxiYWNrKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgICAgICAKKyAgICAg ICAgdHJ5IHsKKyAgICAgICAgICAgIHZhciByZXN1bHQgPSBJbnNwZWN0b3JDb250cm9sbGVyLmlu c3BlY3RlZFdpbmRvdygpLmV2YWwoIigiICsgdGhpcy5leHByZXNzaW9uICsgIikiKTsKKyAgICAg ICAgICAgIGNhbGxiYWNrKHJlc3VsdCk7CisgICAgICAgIH0gY2F0Y2ggKGUpIHsKKyAgICAgICAg ICAgIGNhbGxiYWNrKGUsIHRydWUpOworICAgICAgICB9CisgICAgICAgIAorICAgIH0sCisgICAg CisgICAgX3JlZnJlc2hFeHByZXNzaW9uQ2FsbGJhY2s6IGZ1bmN0aW9uKHZhbHVlKQorICAgIHsK KyAgICAgICAgaWYgKCJzdHJpbmciID09IHR5cGVvZiB2YWx1ZSkgdmFsdWUgPSBuZXcgU3RyaW5n KHZhbHVlKTsKKyAgICAgICAgCisgICAgICAgIHRoaXMudmFsdWUgPSB2YWx1ZTsKKyAgICAgICAg dGhpcy52YWx1ZUVsZW1lbnQudGV4dENvbnRlbnQgPSBPYmplY3QuZGVzY3JpYmUodmFsdWUsIHRy dWUpOworICAgICAgICAKKyAgICAgICAgdGhpcy5yZW1vdmVDaGlsZHJlbigpOworCisgICAgICAg IHZhciBwcm9wZXJ0aWVzID0gT2JqZWN0LnNvcnRlZFByb3BlcnRpZXModmFsdWUpOworICAgICAg ICBmb3IgKHZhciBpID0gMDsgaSA8IHByb3BlcnRpZXMubGVuZ3RoOyArK2kpIHsKKyAgICAgICAg ICAgIHZhciBwcm9wZXJ0eU5hbWUgPSBwcm9wZXJ0aWVzW2ldOworICAgICAgICAgICAgdGhpcy5h cHBlbmRDaGlsZChuZXcgdGhpcy50cmVlT3V0bGluZS5zZWN0aW9uLnRyZWVFbGVtZW50Q29uc3Ry dWN0b3IodGhpcy52YWx1ZSwgcHJvcGVydHlOYW1lKSk7CisgICAgICAgIH0KKyAgICAgICAgdGhp cy5oYXNDaGlsZHJlbiA9IHByb3BlcnRpZXMubGVuZ3RoID4gMDsKKyAgICB9LAorICAgIAorICAg IG9uYXR0YWNoOiBmdW5jdGlvbigpCisgICAgeworICAgICAgICB0aGlzLmV4cHJlc3Npb25FbGVt ZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpOworICAgICAgICB0aGlzLmV4cHJl c3Npb25FbGVtZW50LmNsYXNzTmFtZSA9ICJuYW1lIjsKKyAgICAgICAgCisgICAgICAgIGlmICh0 aGlzLmV4cHJlc3Npb24udHJpbVdoaXRlc3BhY2UoKSA9PSAiIikgeworICAgICAgICAgICAgdGhp cy5leHByZXNzaW9uRWxlbWVudC5pbm5lckhUTUwgPSAiJm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7 Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7IjsKKyAgICAgICAgfQorICAgICAg ICBlbHNlIHsKKyAgICAgICAgICAgIHRoaXMuZXhwcmVzc2lvbkVsZW1lbnQudGV4dENvbnRlbnQg PSB0aGlzLmV4cHJlc3Npb247CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIHRoaXMudmFs dWVFbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpOworICAgICAgICB0aGlz LnZhbHVlRWxlbWVudC5jbGFzc05hbWUgPSAidmFsdWUiOworICAgICAgICB0aGlzLnZhbHVlRWxl bWVudC50ZXh0Q29udGVudCA9ICIiOworICAgICAgICAKKyAgICAgICAgdGhpcy5zZXBhcmF0b3JF bGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUoIjogIik7CisgICAgICAgIAorICAgICAg ICB0aGlzLmxpc3RJdGVtRWxlbWVudC5hcHBlbmRDaGlsZCh0aGlzLmV4cHJlc3Npb25FbGVtZW50 KTsKKyAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQuYXBwZW5kQ2hpbGQodGhpcy5zZXBhcmF0 b3JFbGVtZW50KTsKKyAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQuYXBwZW5kQ2hpbGQodGhp cy52YWx1ZUVsZW1lbnQpOworICAgIAorICAgICAgICBpZiAodGhpcy5leHByZXNzaW9uICE9ICIi KQorICAgICAgICAgICAgdGhpcy5yZWZyZXNoRXhwcmVzc2lvbigpOworICAgIH0sCisgICAgCisg ICAgb25wb3B1bGF0ZTogZnVuY3Rpb24oKSAKKyAgICB7CisgICAgICAgIHRoaXMucmVmcmVzaEV4 cHJlc3Npb24oKTsKKyAgICB9LAorICAgIAorICAgIG9uZGJsY2xpY2s6IGZ1bmN0aW9uKGVsZW1l bnQsIGV2ZW50KQorICAgIHsKKyAgICAgICAgIHRoaXMuc3RhcnRFZGl0aW5nKCk7CisgICAgfSwK KyAgICAKKyAgICB1cGRhdGU6IGZ1bmN0aW9uKCkKKyAgICB7CisgICAgICAgIHRoaXMucmVmcmVz aEV4cHJlc3Npb24oKTsKKyAgICB9LAorICAgIAorICAgIHN0YXJ0RWRpdGluZzogZnVuY3Rpb24o KQorICAgIHsKKyAgICAgICAgaWYgKFdlYkluc3BlY3Rvci5pc0JlaW5nRWRpdGVkKHRoaXMudmFs dWVFbGVtZW50KSB8fCAhdGhpcy50cmVlT3V0bGluZS5zZWN0aW9uLmVkaXRhYmxlKQorICAgICAg ICAgICAgcmV0dXJuOworCisgICAgICAgIHZhciBjb250ZXh0ID0geyBleHBhbmRlZDogdGhpcy5l eHBhbmRlZCB9OworCisgICAgICAgIC8vIExpZSBhYm91dCBvdXIgY2hpbGRyZW4gdG8gcHJldmVu dCBleHBhbmRpbmcgb24gZG91YmxlIGNsaWNrIGFuZCB0byBjb2xsYXBzZSBzdWJwcm9wZXJ0aWVz LgorICAgICAgICB0aGlzLmhhc0NoaWxkcmVuID0gZmFsc2U7CisKKyAgICAgICAgdGhpcy5saXN0 SXRlbUVsZW1lbnQuYWRkU3R5bGVDbGFzcygiZWRpdGluZy1zdWItcGFydCIpOworCisgICAgICAg IFdlYkluc3BlY3Rvci5zdGFydEVkaXRpbmcodGhpcy5leHByZXNzaW9uRWxlbWVudCwgdGhpcy5l ZGl0aW5nQ29tbWl0dGVkLmJpbmQodGhpcyksIHRoaXMuZWRpdGluZ0NhbmNlbGxlZC5iaW5kKHRo aXMpLCBjb250ZXh0KTsKKyAgICB9LAorCisgICAgZWRpdGluZ0VuZGVkOiBmdW5jdGlvbihjb250 ZXh0KQorICAgIHsKKyAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQuc2Nyb2xsTGVmdCA9IDA7 CisgICAgICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50LnJlbW92ZVN0eWxlQ2xhc3MoImVkaXRpbmct c3ViLXBhcnQiKTsKKyAgICAgICAgaWYgKGNvbnRleHQuZXhwYW5kZWQpCisgICAgICAgICAgICB0 aGlzLmV4cGFuZCgpOworICAgIH0sCisKKyAgICBlZGl0aW5nQ2FuY2VsbGVkOiBmdW5jdGlvbihl bGVtZW50LCBjb250ZXh0KQorICAgIHsKKyAgICAgICAgaWYgKHRoaXMuZXhwcmVzc2lvbiA9PSAi IikgeworICAgICAgICAgICAgdGhpcy5zZWN0aW9uLmRlbGV0ZUV4cHJlc3Npb24odGhpcyk7Cisg ICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICAgICAgCisgICAgICAgIHRoaXMuZWRp dGluZ0VuZGVkKGNvbnRleHQpOworICAgIH0sCisKKyAgICBlZGl0aW5nQ29tbWl0dGVkOiBmdW5j dGlvbihlbGVtZW50LCB1c2VySW5wdXQsIHByZXZpb3VzQ29udGVudCwgY29udGV4dCkKKyAgICB7 CisgICAgICAgIHVzZXJJbnB1dCA9IHVzZXJJbnB1dC50cmltV2hpdGVzcGFjZSgpOworICAgICAg ICAKKyAgICAgICAgaWYgKHVzZXJJbnB1dCA9PT0gcHJldmlvdXNDb250ZW50KQorICAgICAgICAg ICAgcmV0dXJuIHRoaXMuZWRpdGluZ0NhbmNlbGxlZChlbGVtZW50LCBjb250ZXh0KTsgLy8gbm90 aGluZyBjaGFuZ2VkLCBzbyBjYW5jZWwKKworICAgICAgICBpZiAodXNlcklucHV0ID09ICIiKSB7 CisgICAgICAgICAgICB0aGlzLnNlY3Rpb24uZGVsZXRlRXhwcmVzc2lvbih0aGlzKTsKKyAgICAg ICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgICAgICAKKyAgICAgICAgdGhpcy5leHByZXNz aW9uID0gdXNlcklucHV0LnRyaW1XaGl0ZXNwYWNlKCk7CisgICAgICAgIHRoaXMud2F0Y2hlZEV4 cHJlc3Npb25zW3RoaXMuaW5kZXhdID0gdGhpcy5leHByZXNzaW9uOworICAgICAgICB0aGlzLmVk aXRpbmdFbmRlZChjb250ZXh0KTsKKyAgICAgICAgdGhpcy5yZWZyZXNoRXhwcmVzc2lvbigpOwor ICAgIH0sCisKK30KKworV2ViSW5zcGVjdG9yLldhdGNoZWRFeHByZXNzaW9uVHJlZUVsZW1lbnQu cHJvdG90eXBlLl9fcHJvdG9fXyA9IFRyZWVFbGVtZW50LnByb3RvdHlwZTsKXCBObyBuZXdsaW5l IGF0IGVuZCBvZiBmaWxlCkluZGV4OiBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVj dG9yLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3Bl Y3Rvci5odG1sCShyZXZpc2lvbiA0NjUwNykKKysrIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVu ZC9pbnNwZWN0b3IuaHRtbAkod29ya2luZyBjb3B5KQpAQCAtNTYsNiArNTYsNyBAQCBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPCiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0 L2phdmFzY3JpcHQiIHNyYz0iQnJlYWtwb2ludHNTaWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAg ICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iQ2FsbFN0YWNrU2lkZWJhclBh bmUuanMiPjwvc2NyaXB0PgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9 IlNjb3BlQ2hhaW5TaWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CisgICAgPHNjcmlwdCB0eXBlPSJ0 ZXh0L2phdmFzY3JpcHQiIHNyYz0iV2F0Y2hlZEV4cHJlc3Npb25zU2lkZWJhclBhbmUuanMiPjwv c2NyaXB0PgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9Ik1ldHJpY3NT aWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3Jp cHQiIHNyYz0iUHJvcGVydGllc1NpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0 IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJTdHlsZXNTaWRlYmFyUGFuZS5qcyI+PC9zY3Jp cHQ+Cg== 39057 2009-09-04 08:16:56 -0700 2009-09-11 11:42:04 -0700 proposed patch - 2009/09/04 27514.patch text/plain 54605 pmuellr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0ODA0OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNDYgQEAKKzIwMDktMDktMDQgIFBhdHJpY2sgTXVlbGxlciAgPFBhdHJpY2tfTXVl bGxlckB1cy5pYm0uY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIGFkZCBzdXBwb3J0IGZvciB3YXRjaGVkIGV4cHJlc3Npb25zCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzUxNAorCisgICAgICAgIE1h bnVhbCB0ZXN0IGNhc2UgYWRkZWQsIHNlZSBiZWxvdy4KKworICAgICAgICAqIEVuZ2xpc2gubHBy b2ovbG9jYWxpemVkU3RyaW5ncy5qczoKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL1Nj cmlwdHNQYW5lbC5qczoKKyAgICAgICAgKFdlYkluc3BlY3Rvci5TY3JpcHRzUGFuZWwpOgorICAg ICAgICAoV2ViSW5zcGVjdG9yLlNjcmlwdHNQYW5lbC5wcm90b3R5cGUuX2NhbGxGcmFtZVNlbGVj dGVkKToKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL1dhdGNoRXhwcmVzc2lvbnNTaWRl YmFyUGFuZS5qczogQWRkZWQuCisgICAgICAgIChXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9u c1NpZGViYXJQYW5lKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2lk ZWJhclBhbmUucHJvdG90eXBlLnJlZnJlc2hFeHByZXNzaW9ucyk6CisgICAgICAgIChXZWJJbnNw ZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24pOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldh dGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS5yZWZyZXNoRXhwcmVzc2lvbnMpOgorICAg ICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS5hZGRF eHByZXNzaW9uKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlv bi5wcm90b3R5cGUuYWRkRXhwcmVzc2lvbkFuZEVkaXQpOgorICAgICAgICAoV2ViSW5zcGVjdG9y LldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS5kZWxldGVFeHByZXNzaW9uKToKKyAg ICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5wcm90b3R5cGUubW9k aWZ5RXhwcmVzc2lvbik6CisgICAgICAgIChXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1Nl Y3Rpb24ucHJvdG90eXBlLmxvYWRTYXZlZEV4cHJlc3Npb25zKToKKyAgICAgICAgKFdlYkluc3Bl Y3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5wcm90b3R5cGUuc2F2ZUV4cHJlc3Npb25zKToK KyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudCk6CisgICAg ICAgIChXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1lbnQucHJvdG90eXBlLnJl ZnJlc2hFeHByZXNzaW9uLmNhbGxiYWNrKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4 cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUucmVmcmVzaEV4cHJlc3Npb24pOgorICAgICAg ICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvblRyZWVFbGVtZW50LnByb3RvdHlwZS5fcmVm cmVzaEV4cHJlc3Npb25DYWxsYmFjay5jYWxsYmFjayk6CisgICAgICAgIChXZWJJbnNwZWN0b3Iu V2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1lbnQucHJvdG90eXBlLl9yZWZyZXNoRXhwcmVzc2lvbkNh bGxiYWNrKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVu dC5wcm90b3R5cGUuX3JlZnJlc2hFeHByZXNzaW9uUHJvcGVydGllc0NhbGxiYWNrKToKKyAgICAg ICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUub25h dHRhY2gpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvblRyZWVFbGVtZW50 LnByb3RvdHlwZS5fZGVsZXRlQnV0dG9uQ2xpY2tlZCk6CisgICAgICAgIChXZWJJbnNwZWN0b3Iu V2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1lbnQucHJvdG90eXBlLm9ucG9wdWxhdGUpOgorICAgICAg ICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvblRyZWVFbGVtZW50LnByb3RvdHlwZS5vbmRi bGNsaWNrKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVu dC5wcm90b3R5cGUudXBkYXRlKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Np b25UcmVlRWxlbWVudC5wcm90b3R5cGUuc3RhcnRFZGl0aW5nKToKKyAgICAgICAgKFdlYkluc3Bl Y3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUuZWRpdGluZ0VuZGVkKToK KyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5 cGUuZWRpdGluZ0NhbmNlbGxlZCk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNz aW9uVHJlZUVsZW1lbnQucHJvdG90eXBlLmVkaXRpbmdDb21taXR0ZWQpOgorICAgICAgICAqIGlu c3BlY3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmNzczoKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJv bnQtZW5kL2luc3BlY3Rvci5odG1sOgorICAgICAgICAqIG1hbnVhbC10ZXN0cy9pbnNwZWN0b3Iv ZGVidWdnZXItd2F0Y2gtZXhwcmVzc2lvbnMuaHRtbDogQWRkZWQuCisKIDIwMDktMDktMDQgIFhh biBMb3BleiAgPHhsb3BlekBpZ2FsaWEuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEd1c3Rh dm8gTm9yb25oYS4KSW5kZXg6IFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9TY3JpcHRzUGFu ZWwuanMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1NjcmlwdHNQ YW5lbC5qcwkocmV2aXNpb24gNDgwMzcpCisrKyBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQv U2NyaXB0c1BhbmVsLmpzCSh3b3JraW5nIGNvcHkpCkBAIC0xMjcsNiArMTI3LDcgQEAgV2ViSW5z cGVjdG9yLlNjcmlwdHNQYW5lbCA9IGZ1bmN0aW9uKCkKIAogICAgIHRoaXMuc2lkZWJhclBhbmVz ID0ge307CiAgICAgdGhpcy5zaWRlYmFyUGFuZXMuY2FsbHN0YWNrID0gbmV3IFdlYkluc3BlY3Rv ci5DYWxsU3RhY2tTaWRlYmFyUGFuZSgpOworICAgIHRoaXMuc2lkZWJhclBhbmVzLndhdGNoRXhw cmVzc2lvbnMgPSBuZXcgV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZSgp OwogICAgIHRoaXMuc2lkZWJhclBhbmVzLnNjb3BlY2hhaW4gPSBuZXcgV2ViSW5zcGVjdG9yLlNj b3BlQ2hhaW5TaWRlYmFyUGFuZSgpOwogICAgIHRoaXMuc2lkZWJhclBhbmVzLmJyZWFrcG9pbnRz ID0gbmV3IFdlYkluc3BlY3Rvci5CcmVha3BvaW50c1NpZGViYXJQYW5lKCk7CiAKQEAgLTcwNCw2 ICs3MDUsNyBAQCBXZWJJbnNwZWN0b3IuU2NyaXB0c1BhbmVsLnByb3RvdHlwZSA9IHsKICAgICAg ICAgICAgIHJldHVybjsKIAogICAgICAgICB0aGlzLnNpZGViYXJQYW5lcy5zY29wZWNoYWluLnVw ZGF0ZShjdXJyZW50RnJhbWUpOworICAgICAgICB0aGlzLnNpZGViYXJQYW5lcy53YXRjaEV4cHJl c3Npb25zLnJlZnJlc2hFeHByZXNzaW9ucygpOwogCiAgICAgICAgIHZhciBzY3JpcHRPclJlc291 cmNlID0gdGhpcy5fc291cmNlSURNYXBbY3VycmVudEZyYW1lLnNvdXJjZUlEXTsKICAgICAgICAg dGhpcy5fc2hvd1NjcmlwdE9yUmVzb3VyY2Uoc2NyaXB0T3JSZXNvdXJjZSwgY3VycmVudEZyYW1l LmxpbmUpOwpJbmRleDogV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1dhdGNoRXhwcmVzc2lv bnNTaWRlYmFyUGFuZS5qcwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1l bmQvV2F0Y2hFeHByZXNzaW9uc1NpZGViYXJQYW5lLmpzCShyZXZpc2lvbiAwKQorKysgV2ViQ29y ZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1dhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5qcwkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSwzNTkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIElCTSBDb3Jw LiAyMDA5ICBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2Ug Y29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBS ZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisg KiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0 ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0 aGVyIHRoZSBuYW1lIG9mIElCTSBDb3JwLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJp YnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVk IGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBl cm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJ R0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8s IFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNI QUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9S IEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZ LCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRF RCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBP RiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhP V0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVH TElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQor ICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBP RiBTVUNIIERBTUFHRS4KKyAqLworCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NpZGVi YXJQYW5lID0gZnVuY3Rpb24oKQoreworICAgIFdlYkluc3BlY3Rvci5TaWRlYmFyUGFuZS5jYWxs KHRoaXMsIFdlYkluc3BlY3Rvci5VSVN0cmluZygiV2F0Y2ggRXhwcmVzc2lvbnMiKSk7CisKKyAg ICB0aGlzLnNlY3Rpb24gPSBuZXcgV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9u KHRoaXMpOworCisgICAgdGhpcy5ib2R5RWxlbWVudC5hcHBlbmRDaGlsZCh0aGlzLnNlY3Rpb24u ZWxlbWVudCk7CisKKyAgICB2YXIgYWRkRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQo ImJ1dHRvbiIpOworICAgIGFkZEVsZW1lbnQuc2V0QXR0cmlidXRlKCJ0eXBlIiwgImJ1dHRvbiIp OworICAgIGFkZEVsZW1lbnQudGV4dENvbnRlbnQgPSBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoIkFk ZCIpOworICAgIGFkZEVsZW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigiY2xpY2siLCB0aGlzLnNlY3Rp b24uYWRkRXhwcmVzc2lvbkFuZEVkaXQuYmluZCh0aGlzLnNlY3Rpb24pLCBmYWxzZSk7CisKKyAg ICB2YXIgcmVmcmVzaEVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJidXR0b24iKTsK KyAgICByZWZyZXNoRWxlbWVudC5zZXRBdHRyaWJ1dGUoInR5cGUiLCAiYnV0dG9uIik7CisgICAg cmVmcmVzaEVsZW1lbnQudGV4dENvbnRlbnQgPSBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoIlJlZnJl c2giKTsKKyAgICByZWZyZXNoRWxlbWVudC5hZGRFdmVudExpc3RlbmVyKCJjbGljayIsIHRoaXMu c2VjdGlvbi5yZWZyZXNoRXhwcmVzc2lvbnMuYmluZCh0aGlzLnNlY3Rpb24pLCBmYWxzZSk7CisK KyAgICB2YXIgY2VudGVyRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImRpdiIpOwor ICAgIGNlbnRlckVsZW1lbnQuYWRkU3R5bGVDbGFzcygid2F0Y2gtZXhwcmVzc2lvbnMtYnV0dG9u cy1jb250YWluZXIiKTsKKyAgICBjZW50ZXJFbGVtZW50LmFwcGVuZENoaWxkKGFkZEVsZW1lbnQp OworICAgIGNlbnRlckVsZW1lbnQuYXBwZW5kQ2hpbGQocmVmcmVzaEVsZW1lbnQpOworICAgIHRo aXMuYm9keUVsZW1lbnQuYXBwZW5kQ2hpbGQoY2VudGVyRWxlbWVudCk7Cit9CisKK1dlYkluc3Bl Y3Rvci5XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUucHJvdG90eXBlID0geworICAgIHJlZnJl c2hFeHByZXNzaW9uczogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgdGhpcy5zZWN0aW9uLnJl ZnJlc2hFeHByZXNzaW9ucygpOworICAgIH0KK30KKworV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVz c2lvbnNTaWRlYmFyUGFuZS5wcm90b3R5cGUuX19wcm90b19fID0gV2ViSW5zcGVjdG9yLlNpZGVi YXJQYW5lLnByb3RvdHlwZTsKKworLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworV2ViSW5zcGVj dG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uID0gZnVuY3Rpb24ocGFuZSkKK3sKKyAgICBXZWJJ bnNwZWN0b3IuUHJvcGVydGllc1NlY3Rpb24uY2FsbCh0aGlzLCAiIiwgIiIpOworCisgICAgdGhp cy5wYW5lID0gcGFuZTsKKyAgICB0aGlzLmVsZW1lbnQucmVtb3ZlQ2hpbGQodGhpcy5oZWFkZXJF bGVtZW50KTsKKyAgICB0aGlzLmVkaXRhYmxlID0gdHJ1ZTsKKyAgICB0aGlzLnRyZWVFbGVtZW50 Q29uc3RydWN0b3IgPSBXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydHlUcmVlRWxlbWVudDsKKyAg ICB0aGlzLndhdGNoRXhwcmVzc2lvbnMgPSBbXTsKKyAgICB0aGlzLmV4cGFuZGVkID0gZmFsc2U7 CisKKyAgICB2YXIgc2F2ZWRFeHByZXNzaW9ucyA9IHRoaXMubG9hZFNhdmVkRXhwcmVzc2lvbnMo KTsKKyAgICBpZiAoc2F2ZWRFeHByZXNzaW9ucy5sZW5ndGggPiAwKSAKKyAgICAgICAgdGhpcy5w YW5lLmV4cGFuZGVkID0gdHJ1ZTsKKworICAgIGZvciAodmFyIGk9MDsgaTxzYXZlZEV4cHJlc3Np b25zLmxlbmd0aDsgaSsrKSB7CisgICAgICAgIHRoaXMuYWRkRXhwcmVzc2lvbihzYXZlZEV4cHJl c3Npb25zW2ldKTsKKyAgICB9Cit9CisKK1dlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2Vj dGlvbi5wcm90b3R5cGUgPSB7CisgICAgcmVmcmVzaEV4cHJlc3Npb25zOiBmdW5jdGlvbigpCisg ICAgeworICAgICAgICB2YXIgY2hpbGRyZW4gPSB0aGlzLnByb3BlcnRpZXNUcmVlT3V0bGluZS5j aGlsZHJlbjsKKyAgICAgICAgZm9yICh2YXIgaT0wOyBpPGNoaWxkcmVuLmxlbmd0aDsgaSsrKSB7 CisgICAgICAgICAgICBjaGlsZHJlbltpXS5yZWZyZXNoRXhwcmVzc2lvbigpOworICAgICAgICB9 CisgICAgfSwKKworICAgIGFkZEV4cHJlc3Npb246IGZ1bmN0aW9uKGV4cHJlc3Npb24pCisgICAg eworICAgICAgICBpZiAoZXhwcmVzc2lvbiA9PT0gbnVsbCkKKyAgICAgICAgICAgIHJldHVybjsK KworICAgICAgICB0aGlzLmV4cGFuZGVkID0gdHJ1ZTsKKworICAgICAgICB2YXIgaW5kZXggPSB0 aGlzLndhdGNoRXhwcmVzc2lvbnMubGVuZ3RoOworICAgICAgICB0aGlzLndhdGNoRXhwcmVzc2lv bnMucHVzaChleHByZXNzaW9uKTsKKworICAgICAgICB2YXIgZWxlbWVudCA9IG5ldyBXZWJJbnNw ZWN0b3IuV2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1lbnQodGhpcywgaW5kZXgpOworICAgICAgICB0 aGlzLnByb3BlcnRpZXNUcmVlT3V0bGluZS5hcHBlbmRDaGlsZChlbGVtZW50KTsKKworICAgICAg ICByZXR1cm4gZWxlbWVudDsKKyAgICB9LAorCisgICAgYWRkRXhwcmVzc2lvbkFuZEVkaXQ6IGZ1 bmN0aW9uKCkKKyAgICB7CisgICAgICAgIHZhciBlbGVtZW50ID0gdGhpcy5hZGRFeHByZXNzaW9u KCIiKTsKKyAgICAgICAgZWxlbWVudC5zdGFydEVkaXRpbmcoKTsKKyAgICAgICAgcmV0dXJuIGVs ZW1lbnQ7CisgICAgfSwKKworICAgIGRlbGV0ZUV4cHJlc3Npb246IGZ1bmN0aW9uKGVsZW1lbnQp CisgICAgeworICAgICAgICB0aGlzLnByb3BlcnRpZXNUcmVlT3V0bGluZS5yZW1vdmVDaGlsZChl bGVtZW50KTsKKyAgICAgICAgdGhpcy53YXRjaEV4cHJlc3Npb25zW2VsZW1lbnQuaW5kZXhdID0g dW5kZWZpbmVkOworICAgICAgICBpZiAodGhpcy5zYXZlRXhwcmVzc2lvbnMoKSA9PT0gMCkKKyAg ICAgICAgICAgIHRoaXMuZXhwYW5kZWQgPSBmYWxzZTsKKyAgICB9LAorCisgICAgbW9kaWZ5RXhw cmVzc2lvbjogZnVuY3Rpb24oZWxlbWVudCkKKyAgICB7CisgICAgICAgIHRoaXMud2F0Y2hFeHBy ZXNzaW9uc1tlbGVtZW50LmluZGV4XSA9IGVsZW1lbnQuZXhwcmVzc2lvbjsKKworICAgICAgICBl bGVtZW50LnJlZnJlc2hFeHByZXNzaW9uKCk7CisgICAgICAgIHRoaXMuc2F2ZUV4cHJlc3Npb25z KCk7CisgICAgfSwKKworICAgIGxvYWRTYXZlZEV4cHJlc3Npb25zOiBmdW5jdGlvbigpCisgICAg eworICAgICAgICBpZiAoIXdpbmRvdy5KU09OKQorICAgICAgICAgICAgcmV0dXJuIFtdOworCisg ICAgICAgIHZhciBqc29uID0gSW5zcGVjdG9yQ29udHJvbGxlci5zZXR0aW5nKCJ3YXRjaEV4cHJl c3Npb25zIik7CisgICAgICAgIGlmICghanNvbikKKyAgICAgICAgICAgIHJldHVybiBbXTsKKwor ICAgICAgICB0cnkgeworICAgICAgICAgICAganNvbiA9IEpTT04ucGFyc2UoanNvbik7CisgICAg ICAgIH0KKyAgICAgICAgY2F0Y2goZSkgeworICAgICAgICAgICAgcmV0dXJuIFtdOworICAgICAg ICB9CisKKyAgICAgICAgcmV0dXJuIGpzb24uZXhwcmVzc2lvbnMgfHwgW107CisgICAgfSwKKwor ICAgIHNhdmVFeHByZXNzaW9uczogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgaWYgKCF3aW5k b3cuSlNPTikKKyAgICAgICAgICAgIHJldHVybjsKKworICAgICAgICB2YXIgdG9TYXZlID0gW107 CisgICAgICAgIGZvciAodmFyIGk9MDsgaTx0aGlzLndhdGNoRXhwcmVzc2lvbnMubGVuZ3RoOyBp KyspIHsKKyAgICAgICAgICAgIGlmICh0aGlzLndhdGNoRXhwcmVzc2lvbnNbaV0pCisgICAgICAg ICAgICAgICAgdG9TYXZlLnB1c2godGhpcy53YXRjaEV4cHJlc3Npb25zW2ldKTsKKyAgICAgICAg fQorCisgICAgICAgIHZhciBqc29uID0gSlNPTi5zdHJpbmdpZnkoe2V4cHJlc3Npb25zOiB0b1Nh dmV9KTsKKyAgICAgICAgSW5zcGVjdG9yQ29udHJvbGxlci5zZXRTZXR0aW5nKCJ3YXRjaEV4cHJl c3Npb25zIiwganNvbik7CisKKyAgICAgICAgcmV0dXJuIHRvU2F2ZS5sZW5ndGg7CisgICAgfQor Cit9CisKK1dlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5wcm90b3R5cGUuX19w cm90b19fID0gV2ViSW5zcGVjdG9yLlByb3BlcnRpZXNTZWN0aW9uLnByb3RvdHlwZTsKKworLy8t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KKworV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvblRyZWVF bGVtZW50ID0gZnVuY3Rpb24oc2VjdGlvbiwgaW5kZXgpCit7CisgICAgdGhpcy5zZWN0aW9uID0g c2VjdGlvbjsKKyAgICB0aGlzLmluZGV4ID0gaW5kZXg7CisgICAgdGhpcy5leHByZXNzaW9uID0g c2VjdGlvbi53YXRjaEV4cHJlc3Npb25zW2luZGV4XTsKKworICAgIFRyZWVFbGVtZW50LmNhbGwo dGhpcywgIiIsIG51bGwsIGZhbHNlKTsKK30KKworV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lv blRyZWVFbGVtZW50LnByb3RvdHlwZSA9IHsKKyAgICByZWZyZXNoRXhwcmVzc2lvbjogZnVuY3Rp b24oKQorICAgIHsKKyAgICAgICAgdmFyIHNlbGYgPSB0aGlzOworICAgICAgICBmdW5jdGlvbiBj YWxsYmFjayhyZXN1bHQsIGlzRXhjZXB0aW9uKQorICAgICAgICB7CisgICAgICAgICAgICBzZWxm Ll9yZWZyZXNoRXhwcmVzc2lvbkNhbGxiYWNrKHJlc3VsdCwgaXNFeGNlcHRpb24pOworICAgICAg ICB9CisKKyAgICAgICAgLy8gV2ViSW5zcGVjdG9yLkNvbnNvbGVWaWV3Ll9ldmFsSW5JbnNwZWN0 ZWRXaW5kb3cgc2hvdWxkIGJlIG1hZGUgJ3B1YmxpYycKKyAgICAgICAgV2ViSW5zcGVjdG9yLmNv bnNvbGUuX2V2YWxJbkluc3BlY3RlZFdpbmRvdygiKCIgKyB0aGlzLmV4cHJlc3Npb24gKyAiKSIs IGNhbGxiYWNrKTsKKyAgICB9LAorCisgICAgX3JlZnJlc2hFeHByZXNzaW9uQ2FsbGJhY2s6IGZ1 bmN0aW9uKHZhbHVlLCBpc0V4Y2VwdGlvbikKKyAgICB7CisgICAgICAgIGlmIChpc0V4Y2VwdGlv bikgeworICAgICAgICAgICAgdGhpcy52YWx1ZUVsZW1lbnQuYWRkU3R5bGVDbGFzcygiZXJyb3It bWVzc2FnZSIpOworICAgICAgICAgICAgdGhpcy52YWx1ZUVsZW1lbnQudGV4dENvbnRlbnQgPSB2 YWx1ZS50b1N0cmluZygpOworICAgICAgICAgICAgdGhpcy52YWx1ZUVsZW1lbnQudGl0bGUgICAg ICAgPSB0aGlzLnZhbHVlRWxlbWVudC50ZXh0Q29udGVudDsKKyAgICAgICAgICAgIHJldHVybjsK KyAgICAgICAgfQorCisgICAgICAgIHRoaXMudmFsdWVFbGVtZW50LnJlbW92ZVN0eWxlQ2xhc3Mo ImVycm9yLW1lc3NhZ2UiKTsKKworICAgICAgICAvLyBOb3RlLCBzaG91bGQgcHJvdmlkZSBhIGJl dHRlciB3YXkgdG8gZ2V0IHRoZSAiZGVzY3JpcHRpb24iOworICAgICAgICAvLyB3b3VsZCBwcmVm ZXIgdG8ganVzdCB1c2UgT2JqZWN0LmRlc2NyaWJlKCksIGJ1dCByZXR1cm5zCisgICAgICAgIC8v ICJPYmplY3QiIGZvciBuZXcgRGF0ZSgpIGNvbXBhcmVkIHRvIHRoZSBwcm94eSB3aGljaCByZXR1 cm5zCisgICAgICAgIC8vIHRoZSBkYXRlIHN0cmluZworICAgICAgICAKKyAgICAgICAgLy8gaWYg YSBwcm94eSBvYmplY3QsIGdldCBkZXNjcmlwdGlvbiBmcm9tIHRoZXJlCisgICAgICAgIGlmICh2 YWx1ZSAmJiB2YWx1ZS5vYmplY3RJZCAmJiB2YWx1ZS5kZXNjcmlwdGlvbikKKyAgICAgICAgICAg IHRoaXMudmFsdWVFbGVtZW50LnRleHRDb250ZW50ID0gdmFsdWUuZGVzY3JpcHRpb247CisgICAg ICAgICAgICAKKyAgICAgICAgLy8gaWYgbm90IGEgcHJveHkgb2JqZWN0LCB1c2UgT2JqZWN0LmRl c2NyaWJlKCkKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgdGhpcy52YWx1ZUVsZW1lbnQudGV4 dENvbnRlbnQgPSBPYmplY3QuZGVzY3JpYmUodmFsdWUsIHRydWUpOworCisgICAgICAgIHZhciBz ZWxmID0gdGhpczsKKyAgICAgICAgZnVuY3Rpb24gY2FsbGJhY2socHJvcGVydGllcykgeworICAg ICAgICAgICAgc2VsZi5fcmVmcmVzaEV4cHJlc3Npb25Qcm9wZXJ0aWVzQ2FsbGJhY2socHJvcGVy dGllcyk7CisgICAgICAgIH0KKworICAgICAgICBJbnNwZWN0b3JDb250cm9sbGVyLmdldFByb3Bl cnRpZXModmFsdWUsIHRydWUsIGNhbGxiYWNrKTsKKyAgICB9LAorCisgICAgX3JlZnJlc2hFeHBy ZXNzaW9uUHJvcGVydGllc0NhbGxiYWNrOiBmdW5jdGlvbihwcm9wZXJ0aWVzKQorICAgIHsKKyAg ICAgICAgdGhpcy5yZW1vdmVDaGlsZHJlbigpOworCisgICAgICAgIGlmICghcHJvcGVydGllcykg eworICAgICAgICAgICAgdGhpcy5oYXNDaGlsZHJlbiA9IGZhbHNlOworICAgICAgICAgICAgcmV0 dXJuOworICAgICAgICB9CisKKyAgICAgICAgLy8gV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnRp ZXNTZWN0aW9uLnByb3RvdHlwZS5fZGlzcGxheVNvcnQgc2hvdWxkIGJlCisgICAgICAgIC8vIG1v dmVkIHRvIHNvbWV0aGluZyBsaWtlIHV0aWxpdGllcy5qcworICAgICAgICBwcm9wZXJ0aWVzLnNv cnQoV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnRpZXNTZWN0aW9uLnByb3RvdHlwZS5fZGlzcGxh eVNvcnQpOworCisgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgcHJvcGVydGllcy5sZW5ndGg7 ICsraSkgeworICAgICAgICAgICAgdGhpcy5hcHBlbmRDaGlsZChuZXcgdGhpcy50cmVlT3V0bGlu ZS5zZWN0aW9uLnRyZWVFbGVtZW50Q29uc3RydWN0b3IocHJvcGVydGllc1tpXSkpOworICAgICAg ICB9CisgICAgICAgIHRoaXMuaGFzQ2hpbGRyZW4gPSBwcm9wZXJ0aWVzLmxlbmd0aCA+IDA7Cisg ICAgfSwKKworICAgIG9uYXR0YWNoOiBmdW5jdGlvbigpCisgICAgeworICAgICAgICB0aGlzLmV4 cHJlc3Npb25FbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpOworICAgICAg ICB0aGlzLmV4cHJlc3Npb25FbGVtZW50LmNsYXNzTmFtZSA9ICJuYW1lIjsKKworICAgICAgICBp ZiAodGhpcy5leHByZXNzaW9uLnRyaW1XaGl0ZXNwYWNlKCkgPT09ICIiKQorICAgICAgICAgICAg dGhpcy5leHByZXNzaW9uRWxlbWVudC5pbm5lckhUTUwgPSAiJm5ic3A7Jm5ic3A7Jm5ic3A7Jm5i c3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7IjsKKyAgICAgICAgZWxzZQor ICAgICAgICAgICAgdGhpcy5leHByZXNzaW9uRWxlbWVudC50ZXh0Q29udGVudCA9IHRoaXMuZXhw cmVzc2lvbjsKKworICAgICAgICB0aGlzLnZhbHVlRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVs ZW1lbnQoInNwYW4iKTsKKyAgICAgICAgdGhpcy52YWx1ZUVsZW1lbnQuY2xhc3NOYW1lID0gInZh bHVlIjsKKyAgICAgICAgdGhpcy52YWx1ZUVsZW1lbnQudGV4dENvbnRlbnQgPSAiIjsKKworICAg ICAgICB0aGlzLnNlcGFyYXRvckVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZSgiOiAi KTsKKworICAgICAgICB0aGlzLmRlbGV0ZUJ1dHRvbiA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQo ImlucHV0Iik7CisgICAgICAgIHRoaXMuZGVsZXRlQnV0dG9uLnR5cGUgPSAiYnV0dG9uIjsKKyAg ICAgICAgdGhpcy5kZWxldGVCdXR0b24udGl0bGUgPSBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoIkRl bGV0ZSB3YXRjaCBleHByZXNzaW9uLiIpOworICAgICAgICB0aGlzLmRlbGV0ZUJ1dHRvbi5hZGRT dHlsZUNsYXNzKCJlbmFibGVkLWJ1dHRvbiIpOworICAgICAgICB0aGlzLmRlbGV0ZUJ1dHRvbi5h ZGRTdHlsZUNsYXNzKCJkZWxldGUtYnV0dG9uIik7CisgICAgICAgIHRoaXMuZGVsZXRlQnV0dG9u LmFkZEV2ZW50TGlzdGVuZXIoImNsaWNrIiwgdGhpcy5fZGVsZXRlQnV0dG9uQ2xpY2tlZC5iaW5k KHRoaXMpLCBmYWxzZSk7CisKKyAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQuYXBwZW5kQ2hp bGQodGhpcy5kZWxldGVCdXR0b24pOworICAgICAgICB0aGlzLmxpc3RJdGVtRWxlbWVudC5hcHBl bmRDaGlsZCh0aGlzLmV4cHJlc3Npb25FbGVtZW50KTsKKyAgICAgICAgdGhpcy5saXN0SXRlbUVs ZW1lbnQuYXBwZW5kQ2hpbGQodGhpcy5zZXBhcmF0b3JFbGVtZW50KTsKKyAgICAgICAgdGhpcy5s aXN0SXRlbUVsZW1lbnQuYXBwZW5kQ2hpbGQodGhpcy52YWx1ZUVsZW1lbnQpOworCisgICAgICAg IGlmICh0aGlzLmV4cHJlc3Npb24gIT0gIiIpCisgICAgICAgICAgICB0aGlzLnJlZnJlc2hFeHBy ZXNzaW9uKCk7CisgICAgfSwKKworICAgIF9kZWxldGVCdXR0b25DbGlja2VkOiBmdW5jdGlvbigp CisgICAgeworICAgICAgICB0aGlzLnNlY3Rpb24uZGVsZXRlRXhwcmVzc2lvbih0aGlzKTsKKyAg ICB9LAorCisgICAgb25wb3B1bGF0ZTogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgdGhpcy5y ZWZyZXNoRXhwcmVzc2lvbigpOworICAgIH0sCisKKyAgICBvbmRibGNsaWNrOiBmdW5jdGlvbihl bGVtZW50LCBldmVudCkKKyAgICB7CisgICAgICAgICB0aGlzLnN0YXJ0RWRpdGluZygpOworICAg IH0sCisKKyAgICB1cGRhdGU6IGZ1bmN0aW9uKCkKKyAgICB7CisgICAgICAgIHRoaXMucmVmcmVz aEV4cHJlc3Npb24oKTsKKyAgICB9LAorCisgICAgc3RhcnRFZGl0aW5nOiBmdW5jdGlvbigpCisg ICAgeworICAgICAgICBpZiAoV2ViSW5zcGVjdG9yLmlzQmVpbmdFZGl0ZWQodGhpcy52YWx1ZUVs ZW1lbnQpIHx8ICF0aGlzLnRyZWVPdXRsaW5lLnNlY3Rpb24uZWRpdGFibGUpCisgICAgICAgICAg ICByZXR1cm47CisKKyAgICAgICAgdmFyIGNvbnRleHQgPSB7IGV4cGFuZGVkOiB0aGlzLmV4cGFu ZGVkIH07CisKKyAgICAgICAgLy8gY29sbGFwc2UgdGVtcG9yYXJpbHksIGlmIHJlcXVpcmVkCisg ICAgICAgIHRoaXMuaGFzQ2hpbGRyZW4gPSBmYWxzZTsKKworICAgICAgICB0aGlzLmxpc3RJdGVt RWxlbWVudC5hZGRTdHlsZUNsYXNzKCJlZGl0aW5nLXN1Yi1wYXJ0Iik7CisKKyAgICAgICAgV2Vi SW5zcGVjdG9yLnN0YXJ0RWRpdGluZygKKyAgICAgICAgICAgIHRoaXMuZXhwcmVzc2lvbkVsZW1l bnQsIAorICAgICAgICAgICAgdGhpcy5lZGl0aW5nQ29tbWl0dGVkLmJpbmQodGhpcyksIAorICAg ICAgICAgICAgdGhpcy5lZGl0aW5nQ2FuY2VsbGVkLmJpbmQodGhpcyksIAorICAgICAgICAgICAg Y29udGV4dCk7CisgICAgfSwKKworICAgIGVkaXRpbmdFbmRlZDogZnVuY3Rpb24oY29udGV4dCkK KyAgICB7CisgICAgICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50LnNjcm9sbExlZnQgPSAwOworICAg ICAgICB0aGlzLmxpc3RJdGVtRWxlbWVudC5yZW1vdmVTdHlsZUNsYXNzKCJlZGl0aW5nLXN1Yi1w YXJ0Iik7CisgICAgICAgIGlmIChjb250ZXh0LmV4cGFuZGVkKQorICAgICAgICAgICAgdGhpcy5l eHBhbmQoKTsKKyAgICB9LAorCisgICAgZWRpdGluZ0NhbmNlbGxlZDogZnVuY3Rpb24oZWxlbWVu dCwgY29udGV4dCkKKyAgICB7CisgICAgICAgIGlmICh0aGlzLmV4cHJlc3Npb24gPT09ICIiKSB7 CisgICAgICAgICAgICB0aGlzLnNlY3Rpb24uZGVsZXRlRXhwcmVzc2lvbih0aGlzKTsKKyAgICAg ICAgICAgIHJldHVybjsKKyAgICAgICAgfQorCisgICAgICAgIHRoaXMuZWRpdGluZ0VuZGVkKGNv bnRleHQpOworICAgIH0sCisKKyAgICBlZGl0aW5nQ29tbWl0dGVkOiBmdW5jdGlvbihlbGVtZW50 LCB1c2VySW5wdXQsIHByZXZpb3VzQ29udGVudCwgY29udGV4dCkKKyAgICB7CisgICAgICAgIHVz ZXJJbnB1dCA9IHVzZXJJbnB1dC50cmltV2hpdGVzcGFjZSgpOworCisgICAgICAgIGlmICh1c2Vy SW5wdXQgPT09IHByZXZpb3VzQ29udGVudCkKKyAgICAgICAgICAgIHJldHVybiB0aGlzLmVkaXRp bmdDYW5jZWxsZWQoZWxlbWVudCwgY29udGV4dCk7IAorCisgICAgICAgIGlmICh1c2VySW5wdXQg PT09ICIiKSB7CisgICAgICAgICAgICB0aGlzLnNlY3Rpb24uZGVsZXRlRXhwcmVzc2lvbih0aGlz KTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorCisgICAgICAgIHRoaXMuZXhwcmVz c2lvbiA9IHVzZXJJbnB1dDsKKyAgICAgICAgdGhpcy5zZWN0aW9uLm1vZGlmeUV4cHJlc3Npb24o dGhpcyk7CisKKyAgICAgICAgdGhpcy5lZGl0aW5nRW5kZWQoY29udGV4dCk7CisgICAgfSwKKwor fQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1lbnQucHJvdG90eXBlLl9f cHJvdG9fXyA9IFRyZWVFbGVtZW50LnByb3RvdHlwZTsKSW5kZXg6IFdlYkNvcmUvaW5zcGVjdG9y L2Zyb250LWVuZC9pbnNwZWN0b3IuY3NzCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaW5zcGVjdG9y L2Zyb250LWVuZC9pbnNwZWN0b3IuY3NzCShyZXZpc2lvbiA0ODAzNykKKysrIFdlYkNvcmUvaW5z cGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuY3NzCSh3b3JraW5nIGNvcHkpCkBAIC0xMjA2LDYg KzEyMDYsMTAgQEAgYm9keS5pbmFjdGl2ZSAucGxhY2FyZC5zZWxlY3RlZCB7CiAgICAgbWFyZ2lu LWJvdHRvbTogMXB4OwogfQogCisud2F0Y2gtZXhwcmVzc2lvbnMtYnV0dG9ucy1jb250YWluZXIg eworICAgIHRleHQtYWxpZ246IGNlbnRlcjsKK30KKwogLnNlY3Rpb24gLmhlYWRlciB7CiAgICAg cGFkZGluZzogMnB4IDhweCA0cHggMThweDsKICAgICBib3JkZXItdG9wOiAxcHggc29saWQgcmdi KDE0NSwgMTYwLCAxOTIpOwpAQCAtMTQwOSw2ICsxNDEzLDE2IEBAIGxpLmVkaXRpbmcgLnN3YXRj aCwgbGkuZWRpdGluZyAuZW5hYmxlZC0KICAgICB6LWluZGV4OiAxOwogfQogCisuc2VjdGlvbiAu cHJvcGVydGllcyAuZGVsZXRlLWJ1dHRvbiB7CisgICAgd2lkdGg6IDEwcHg7CisgICAgaGVpZ2h0 OiAxMHB4OworICAgIGJhY2tncm91bmQtaW1hZ2U6IHVybChJbWFnZXMvZXJyb3JJY29uLnBuZyk7 CisgICAgYmFja2dyb3VuZC1wb3NpdGlvbjogMCAwOworICAgIGJhY2tncm91bmQtY29sb3I6IHRy YW5zcGFyZW50OworICAgIGJhY2tncm91bmQtcmVwZWF0OiBuby1yZXBlYXQ7CisgICAgYm9yZGVy OiAwIG5vbmUgdHJhbnNwYXJlbnQ7Cit9CisKIC5zZWN0aW9uOmhvdmVyIC5wcm9wZXJ0aWVzIC5l bmFibGVkLWJ1dHRvbiB7CiAgICAgZGlzcGxheTogYmxvY2s7CiB9CkluZGV4OiBXZWJDb3JlL2lu c3BlY3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9p bnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5odG1sCShyZXZpc2lvbiA0ODAzNykKKysrIFdl YkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuaHRtbAkod29ya2luZyBjb3B5KQpA QCAtNjEsNiArNjEsNyBAQCBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iQnJlYWtwb2ludHNTaWRl YmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQi IHNyYz0iQ2FsbFN0YWNrU2lkZWJhclBhbmUuanMiPjwvc2NyaXB0PgogICAgIDxzY3JpcHQgdHlw ZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IlNjb3BlQ2hhaW5TaWRlYmFyUGFuZS5qcyI+PC9zY3Jp cHQ+CisgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iV2F0Y2hFeHByZXNz aW9uc1NpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2 YXNjcmlwdCIgc3JjPSJNZXRyaWNzU2lkZWJhclBhbmUuanMiPjwvc2NyaXB0PgogICAgIDxzY3Jp cHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IlByb3BlcnRpZXNTaWRlYmFyUGFuZS5qcyI+ PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iQ29sb3Iu anMiPjwvc2NyaXB0PgpJbmRleDogV2ViQ29yZS9tYW51YWwtdGVzdHMvaW5zcGVjdG9yL2RlYnVn Z2VyLXdhdGNoLWV4cHJlc3Npb25zLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9tYW51YWwt dGVzdHMvaW5zcGVjdG9yL2RlYnVnZ2VyLXdhdGNoLWV4cHJlc3Npb25zLmh0bWwJKHJldmlzaW9u IDApCisrKyBXZWJDb3JlL21hbnVhbC10ZXN0cy9pbnNwZWN0b3IvZGVidWdnZXItd2F0Y2gtZXhw cmVzc2lvbnMuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxMTcgQEAKKzxwPlRlc3QgZm9y IAorPGEgaHJlZj0iaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI3NTE0 Ij5CdWcgMjc1MTQgLSBhZGQgc3VwcG9ydCBmb3Igd2F0Y2hlZCBleHByZXNzaW9uPC9hPi4KKwor PHA+VG8gYmVnaW4gdGVzdCwgb3BlbiB3ZWIgaW5zcGVjdG9yLCBnbyB0aGUgc2NyaXB0cyBwYW5l bCAKKyhlbmFibGluZyBzY3JpcHQgZGVidWdnaW5nIGlmIG5lY2NjZXNzYXJ5KSwgYW5kIHRoZW4g Y2xpY2sgdGhpcyBsaW5rOgorPGEgaHJlZj0iamF2YXNjcmlwdDpydW5UZXN0KCkiPltiZWdpbiB0 ZXN0XTwvYT4uCisKKzxwPlBlcmZvcm0gdGhlIGZvbGxvd2luZyBzdGVwcywgYW5kIG5vdGUgdGhl IGV4cGVjdGVkIHJlc3VsdHM6CisgICAgCis8b2w+CisgICAgCis8bGk+PHA+QWZ0ZXIgY2xpY2tp bmcgdGhlIGxpbmsgYWJvdmUsIHlvdSBzaG91bGQgbm93IGJlIHBhdXNlZCBpbiB0aGUgYm9keSBv ZiAKK3RoZSB0ZXN0IG1ldGhvZCwgdGhhbmtzIHRvIHRoZSA8Y29kZT5kZWJ1Z2dlcjwvY29kZT4g c3RhdGVtZW50LgorCis8bGk+PHA+QWRkIHRoZSBmb2xsb3dpbmcgZXhwcmVzc2lvbnMgdG8gdGhl ICJXYXRjaCBFeHByZXNzaW9ucyIgc2VjdGlvbiBvZiB0aGUKK1NjcmlwdHMgcGFuZWwgc2lkZWJh ciBwYW5lOiAiPGNvZGU+dGhpczwvY29kZT4iLCAiPGNvZGU+YTwvY29kZT4iLCAKKyI8Y29kZT5i PC9jb2RlPiIsICI8Y29kZT5jPC9jb2RlPiIgYW5kICI8Y29kZT5kPC9jb2RlPiIuIERvIDxiPk5P VDwvYj4gZW50ZXIgdGhlIHF1b3Rlcy4KKworPGxpPjxwPlRoZSB2YWx1ZXMgb2YgdGhlIGV4cHJl c3Npb25zIGFzIHNob3duIGluIHRoZSB3aW5kb3cgc2hvdWxkIGEgCis8Y29kZT5ET01XaW5kb3c8 L2NvZGU+IGZvciA8Y29kZT50aGlzPC9jb2RlPiwgPGNvZGU+dW5kZWZpbmVkPC9jb2RlPiBmb3IK K3RoZSA8Y29kZT5hPC9jb2RlPiwgPGNvZGU+YjwvY29kZT4sIGFuZCA8Y29kZT5jPC9jb2RlPiB2 YXJpYWJsZXMsIGFuZCBhIHJlZAordmFsdWUgb2YgPHNwYW4gc3R5bGU9ImNvbG9yOnJlZCI+UmVm ZXJlbmNlRXJyb3I6IENhbid0IGZpbmQgdmFyaWFibGU6IGQ8L3NwYW4+Citmb3IgdGhlIDxjb2Rl PmQ8L2NvZGU+IHZhcmlhYmxlLgorCis8bGk+PHA+Tm90ZSB0aGF0IHRoZSB2YWx1ZSBmb3IgPGNv ZGU+ZDwvY29kZT4gaGFzIGEgaG92ZXIgdG9vbCB0aXAgYXZhaWxhYmxlLAord2hpY2ggc2ltcGx5 IHJlcGVhdHMgdGhlIHZhbHVlLiAgVGhpcyB2YWx1ZSBzaG91bGQgbm90IGNoYW5nZSBmb3IgdGhl IGxpZmUgb2YgCit0aGUgdGVzdCwgYXMgdGhlIHZhcmlhYmxlIDxjb2RlPmQ8L2NvZGU+IGlzIG5l dmVyIGludHJvZHVjZWQgaW4gdGhlIHByb2dyYW0uCisKKzxsaT48cD5TdGVwIHRocm91Z2ggdGhl IGNvZGUsIGFuZCB5b3UnbGwgc2VlIHRoZSB2YWx1ZXMgb2YgPGNvZGU+YTwvY29kZT4sCis8Y29k ZT5iPC9jb2RlPiwgYW5kIDxjb2RlPmM8L2NvZGU+IGNoYW5nZSwgYXMgdGhlIHZhcmlhYmxlcyBh cmUgYXNzaWduZWQuCitBbHNvIG5vdGUgdGhhdCBhcyB0aGUgc2NvcGUgY2hhbmdlcyBkdWUgdG8g dGhlIGZ1bmN0aW9uIGludm9jYXRpb24sIHZhbHVlcword2lsbCBiZSBjaGFuZ2VkIHRvIHJlZmVy IHRvIHRoZWlyIGN1cnJlbnQgc2NvcGUuICBUaGUgPGNvZGU+dGhpczwvY29kZT4KK2V4cHJlc3Np b24gd2lsbCBjaGFuZ2Ugd2hlbiB0aGUgbWV0aG9kIGlzIGludm9rZWQgb24gdGhlIG9iamVjdCBj b25zdHJ1Y3RlZCBieQordGhlIHRlc3QuCisKKzxsaT48cD5DbGljayBkaWZmZXJlbnQgc3RhY2sg ZnJhbWVzIGluIHRoZSBDYWxsIFN0YWNrIHNlY3Rpb24gdG8gZW5zdXJlIHRoZQorZXhwcmVzc2lv bnMgY2hhbmdlIHZhbHVlIGFwcHJvcHJpYXRlbHkgYXMgdGhlIGN1cnJlbnQgc3RhY2sgZnJhbWUg Y2hhbmdlcy4KKworPGxpPjxwPkRyaXZlIHRoZSBkZWJ1Z2dlciB0aHJvdWdoIHRoZSBlbmQgb2Yg dGhlIG91dGVybW9zdCBmdW5jdGlvbiwgc28gdGhhdAordGhlIGRlYnVnZ2VyIGlzIG5vIGxvbmdl ciBpbiBwYXVzZWQgc3RhdGUuICBUaGUgdmFsdWVzIHNob3VsZCByZXRhaW4gdGhlaXIKK2xhc3Qg c3RhdGUsIGFzIHRoZSBzdGF0ZSBpcyBvbmx5IHJlZnJlc2hlZCBhdCBkZWJ1Z2dlciBwYXVzZXMs IHdoZW4geW91CitzZWxlY3QgZGlmZmVyZW50IHN0YWNrIGZyYW1lcywgb3IgeW91IGNsaWNrIHRo ZSBSZWZyZXNoIGJ1dHRvbi4gIAorCis8bGk+PHA+Q2xpY2sgdGhlIFJlZnJlc2ggYnV0dG9uLiAg QXQgdGhpcyBwb2ludCwgdGhlIHZhbHVlcyBvZiAKKzxjb2RlPmE8L2NvZGU+LCA8Y29kZT5iPC9j b2RlPiwgYW5kIDxjb2RlPmM8L2NvZGU+IHNob3VsZCBhbGwgYmUgYSByZWQKK1JlZmVyZW5jZUVy cm9yIGxpa2UgPGNvZGU+ZDwvY29kZT4sIHNpbmNlIHRoZXNlIHZhcmlhYmxlcyBhcmUgZGVmaW5l ZCBpbiB0aGUKKzxjb2RlPnJ1blRlc3QoKTwvY29kZT4gZnVuY3Rpb24sIGFuZCB0aGUgZXhwcmVz c2lvbnMgYXJlIGJlaW5nIGV2YWx1YXRlZCBhZ2FpbnN0Cit0aGUgZ2xvYmFsIG9iamVjdC4KKwor PGxpPjxwPkZyb20gdGhlIGNvbnNvbGUsIGV4ZWN1dGUgdGhlIHN0YXRlbWVudCAiPGNvZGU+YSA9 IDE8L2NvZGU+Ii4gIFRoZQord2F0Y2ggZXhwcmVzc2lvbnMgZG8gbm90IGN1cnJlbnRseSByZWZy ZXNoLCBzbyB0aGUgdmFsdWUgZm9yIDxjb2RlPmE8L2NvZGU+CitzaG91bGQgc3RpbGwgYmUgUmVm ZXJlbmNlRXJyb3IuCisKKzxsaT48cD5DbGljayB0aGUgIlJlZnJlc2giIGJ1dHRvbiBpbiB0aGUg V2F0Y2ggRXhwcmVzc2lvbnMgc2VjdGlvbiBhbmQgdGhlCit2YWx1ZSBmb3IgIjxjb2RlPmE8L2Nv ZGU+IiBzaG91bGQgbm93IGJlICI8Y29kZT4xPC9jb2RlPiIuCisKKzxsaT48cD5DbG9zZSBkb3du IHRoZSBicm93c2VyLCBzdGFydCBpdCBiYWNrIHVwLCB0cmF2ZXJzZSB0byBhIHdlYiBzaXRlLAor YnJpbmcgdXAgd2ViIGluc3BlY3RvciwgZ28gdG8gdGhlIFNjcmlwdHMgcGFuZWwuICBZb3Ugc2hv dWxkIHNlZSB0aGUgc2FtZQorc2V0IG9mIFdhdGNoIEV4cHJlc3Npb25zIGluIHRoZSBsaXN0IGFz IHlvdSBoYWQgd2hlbiB5b3UgbGFzdCB1c2VkIHdlYgoraW5zcGVjdG9yLgorCis8bGk+PHA+RGVs ZXRlIGFuIGV4cHJlc3Npb24gYnkgbW92aW5nIHRoZSBtb3VzZSBpbnRvIHRoZSBXYXRjaCBFeHBy ZXNzaW9uCitzZWN0aW9uLCBhbmQgY2xpY2tpbmcgdGhlIFggaWNvbiB3aGljaCBhcHBlYXJzIHRv IHRoZSByaWdodCBvZiBhbiAKK2V4cHJlc3Npb24gKG9uIGhvdmVyKS4KKworPGxpPjxwPkRlbGV0 ZSBhbiBleHByZXNzaW9uIGJ5IGRvdWJsZS1jbGlja2luZyBhbnl3aGVyZSBvbiBhIHRvcC1sZXZl bCBsaW5lCitvZiBhIHdhdGNoIGV4cHJlc3Npb24sIGFuZCBjaGFuZ2luZyB0aGUgZXhwcmVzc2lv biB0byBhbiBlbXB0eSBzdHJpbmcgb3IgCitub3RoaW5nIGJ1dCB3aGl0ZS1zcGFjZS4KKworPGxp PjxwPk1vZGlmeSBhbiBlbnRyeSBieSBkb3VibGUtY2xpY2tpbmcgYW55d2hlcmUgb24gYSB0b3At bGV2ZWwgbGluZQorb2YgYSB3YXRjaCBleHByZXNzaW9uLCBhbmQgY2hhbmdpbmcgdGhlIGV4cHJl c3Npb24uCisKKzxsaT48cD5FbnRlciBhIG5ldyBleHByZXNzaW9uLCAiPGNvZGU+bmV3IERhdGUo KTwvY29kZT4iLiAgVGhlIHZhbHVlIHNob3VsZCBiZQorYSB0b1N0cmluZygpIHZlcnNpb24gb2Yg dGhlIGRhdGUuICBSZXBlYXRlZGx5IHByZXNzIHRoZSBSZWZyZXNoIGJ1dHRvbiB0byBzZWUKK3Ro ZSB2YWx1ZSB1cGRhdGVkIHdpdGggdGhlIGN1cnJlbnQgdGltZS4KKworPC9vbD4KKworPHNjcmlw dD4KK2Z1bmN0aW9uIHJ1blRlc3QoKSB7CisgICAgCisgICAgLy8gYSBuZXN0ZWQgZnVuY3Rpb24K KyAgICBmdW5jdGlvbiBzdWJGdW5jdGlvbigpIHsKKyAgICAgICAgZGVidWdnZXI7CisgICAgICAg IHZhciBhID0gImEgaW4gc3ViRnVuY3Rpb24oKSI7CisgICAgICAgIAorICAgICAgICBzdWJTdWJG dW5jdGlvbigpOworICAgICAgICAKKyAgICAgICAgLy8gYW5vdGhlciBuZXN0ZWQgZnVuY3Rpb24K KyAgICAgICAgZnVuY3Rpb24gc3ViU3ViRnVuY3Rpb24oKSB7CisgICAgICAgICAgICBkZWJ1Z2dl cjsKKyAgICAgICAgICAgIHZhciBiID0gImIgaW4gc3ViU3ViRnVuY3Rpb24oKSI7CisgICAgICAg IH0KKyAgICB9CisgICAgCisgICAgLy8gYSBjbGFzcworICAgIGZ1bmN0aW9uIGFDbGFzcygpIHt9 CisgICAgCisgICAgYUNsYXNzLnByb3RvdHlwZS5hTWV0aG9kID0gZnVuY3Rpb24oKSB7CisgICAg ICAgIGRlYnVnZ2VyOworICAgICAgICB2YXIgYyA9ICJjIGluIGFNZXRob2QoKSI7CisgICAgfQor ICAgIAorICAgIC8vIG1haW4gbG9naWMKKyAgICBkZWJ1Z2dlcjsKKyAgICAKKyAgICB2YXIgYSA9 ICJhIGluIHJ1blRlc3QoKSI7CisgICAgdmFyIGIgPSAiYiBpbiBydW5UZXN0KCkiOworICAgIHZh ciBjID0gImMgaW4gcnVuVGVzdCgpIjsKKyAgICAKKyAgICBzdWJGdW5jdGlvbigpOworICAgIAor ICAgIHZhciBvYmplY3QgPSBuZXcgYUNsYXNzKCk7CisgICAgb2JqZWN0LmFNZXRob2QoKTsKKyAg ICAKK30KKzwvc2NyaXB0PgpJbmRleDogV2ViQ29yZS9FbmdsaXNoLmxwcm9qL2xvY2FsaXplZFN0 cmluZ3MuanMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQpDYW5ub3QgZGlzcGxheTogZmlsZSBtYXJrZWQgYXMgYSBiaW5h cnkgdHlwZS4Kc3ZuOm1pbWUtdHlwZSA9IGFwcGxpY2F0aW9uL29jdGV0LXN0cmVhbQoKLy81MkFH RUFjZ0FnQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFJQUE5QUNB QWJnQmxBSGNBSUFCUApBR0lBYWdCbEFHTUFkQUE3QUFvQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdV QVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQWdBQ2dBCkpRQmtBQ2tBSWdCZEFDQUFQUUFnQUNJ QUlBQW9BQ1VBWkFBcEFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnkKQUdr QWJnQm5BSE1BV3dBaUFDQUFLQUJ5QUdVQWNBQmxBR0VBZEFCbEFHUUFJQUFsQUdRQUlBQjBBR2tB YlFCbEFITUFLUUFpQUYwQQpJQUE5QUNBQUlnQWdBQ2dBY2dCbEFIQUFaUUJoQUhRQVpRQmtBQ0FB SlFCa0FDQUFkQUJwQUcwQVpRQnpBQ2tBSWdBN0FBb0FiQUJ2CkFHTUFZUUJzQUdrQWVnQmxBR1FB VXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBSlFBdUFEQUFaZ0JDQUNJQVhRQWdBRDBBSUFBaUFDVUEK TGdBd0FHWUFRZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQWxBQzRBTUFCbQpBRzBBY3dBaUFGMEFJQUE5QUNBQUlnQWxBQzRBTUFCbUFHMEFj d0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBCmNnQnBBRzRBWndCekFGc0FJ Z0FsQUM0QU1RQm1BQ0FBWkFCaEFIa0Fjd0FpQUYwQUlBQTlBQ0FBSWdBbEFDNEFNUUJtQUNBQVpB QmgKQUhrQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3 QnpBRnNBSWdBbEFDNEFNUUJtQUdnQQpjZ0J6QUNJQVhRQWdBRDBBSUFBaUFDVUFMZ0F4QUdZQWFB QnlBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwCkFISUFhUUJ1QUdjQWN3 QmJBQ0lBSlFBdUFERUFaZ0J0QUdrQWJnQWlBRjBBSUFBOUFDQUFJZ0FsQUM0QU1RQm1BRzBBYVFC dUFDSUEKT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dB aUFDVUFMZ0F5QUdZQUpRQWxBQ0lBWFFBZwpBRDBBSUFBaUFDVUFMZ0F5QUdZQUpRQWxBQ0lBT3dB S0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BCld3QWlBQ1VBTGdB eUFHWUFTd0JDQUNJQVhRQWdBRDBBSUFBaUFDVUFMZ0F5QUdZQVN3QkNBQ0lBT3dBS0FHd0Fid0Jq QUdFQWJBQnAKQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBQ1VBTGdBeUFHWUFjd0Fp QUYwQUlBQTlBQ0FBSWdBbEFDNEFNZ0JtQUhNQQpJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0Js QUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQXVBRE1BWmdCTkFFSUFJZ0JkCkFDQUFQUUFn QUNJQUpRQXVBRE1BWmdCTkFFSUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBB SElBYVFCdUFHY0EKY3dCYkFDSUFKUUF1QURNQVpnQnRBSE1BSWdCZEFDQUFQUUFnQUNJQUpRQXVB RE1BWmdCdEFITUFJZ0E3QUFvQWJBQnZBR01BWVFCcwpBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVB R2NBY3dCYkFDSUFKUUJrQUNBQVpRQnlBSElBYndCeUFDSUFYUUFnQUQwQUlBQWlBQ1VBClpBQWdB R1VBY2dCeUFHOEFjZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFH NEFad0J6QUZzQUlnQWwKQUdRQUlBQmxBSElBY2dCdkFISUFMQUFnQUNVQVpBQWdBSGNBWVFCeUFH NEFhUUJ1QUdjQUlnQmRBQ0FBUFFBZ0FDSUFKUUF4QUNRQQpaQUFnQUdVQWNnQnlBRzhBY2dBc0FD QUFKUUF5QUNRQVpBQWdBSGNBWVFCeUFHNEFhUUJ1QUdjQUlnQTdBQW9BYkFCdkFHTUFZUUJzCkFH a0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQmtBQ0FBWlFCeUFISUFid0J5QUN3 QUlBQWxBR1FBSUFCM0FHRUEKY2dCdUFHa0FiZ0JuQUhNQUlnQmRBQ0FBUFFBZ0FDSUFKUUF4QUNR QVpBQWdBR1VBY2dCeUFHOEFjZ0FzQUNBQUpRQXlBQ1FBWkFBZwpBSGNBWVFCeUFHNEFhUUJ1QUdj QWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNB CklnQWxBR1FBSUFCbEFISUFjZ0J2QUhJQWN3QWlBRjBBSUFBOUFDQUFJZ0FsQUdRQUlBQmxBSElB Y2dCdkFISUFjd0FpQURzQUNnQnMKQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRB WndCekFGc0FJZ0FsQUdRQUlBQmxBSElBY2dCdkFISUFjd0FzQUNBQQpKUUJrQUNBQWR3QmhBSElB YmdCcEFHNEFad0FpQUYwQUlBQTlBQ0FBSWdBbEFERUFKQUJrQUNBQVpRQnlBSElBYndCeUFITUFM QUFnCkFDVUFNZ0FrQUdRQUlBQjNBR0VBY2dCdUFHa0FiZ0JuQUNJQU93QUtBR3dBYndCakFHRUFi QUJwQUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFXd0FpQUNVQVpBQWdBR1VBY2dCeUFHOEFj Z0J6QUN3QUlBQWxBR1FBSUFCM0FHRUFjZ0J1QUdrQWJnQm5BSE1BSWdCZApBQ0FBUFFBZ0FDSUFK UUF4QUNRQVpBQWdBR1VBY2dCeUFHOEFjZ0J6QUN3QUlBQWxBRElBSkFCa0FDQUFkd0JoQUhJQWJn QnBBRzRBClp3QnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJn Qm5BSE1BV3dBaUFDVUFaQUFnQUcwQVlRQjAKQUdNQWFBQmxBSE1BSWdCZEFDQUFQUUFnQUNJQUpR QmtBQ0FBYlFCaEFIUUFZd0JvQUdVQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QQphUUI2QUdVQVpB QlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQWxBR1FBSUFCekFIUUFlUUJzQUdVQUlBQmpBR2dBWVFC dUFHY0FaUUFpCkFGMEFJQUE5QUNBQUlnQWxBR1FBSUFCekFIUUFlUUJzQUdVQUlBQmpBR2dBWVFC dUFHY0FaUUFpQURzQUNnQnNBRzhBWXdCaEFHd0EKYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndC ekFGc0FJZ0FsQUdRQUlBQnpBSFFBZVFCc0FHVUFJQUJqQUdnQVlRQnVBR2NBWlFCegpBQ0lBWFFB Z0FEMEFJQUFpQUNVQVpBQWdBSE1BZEFCNUFHd0FaUUFnQUdNQWFBQmhBRzRBWndCbEFITUFJZ0E3 QUFvQWJBQnZBR01BCllRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFKUUJr QUNBQWR3QmhBSElBYmdCcEFHNEFad0FpQUYwQUlBQTkKQUNBQUlnQWxBR1FBSUFCM0FHRUFjZ0J1 QUdrQWJnQm5BQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0Ju QUhNQVd3QWlBQ1VBWkFBZ0FIY0FZUUJ5QUc0QWFRQnVBR2NBY3dBaUFGMEFJQUE5QUNBQUlnQWxB R1FBSUFCM0FHRUFjZ0J1CkFHa0FiZ0JuQUhNQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxB R1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBSlFCa0FDQUEKMXdBZ0FDVUFaQUFpQUYwQUlBQTlB Q0FBSWdBbEFERUFKQUJrQUNBQTF3QWdBQ1VBTWdBa0FHUUFJZ0E3QUFvQWJBQnZBR01BWVFCcwpB R2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFKUUJ6QUNBQUtBQm1BSElBYndCdEFD QUFZd0JoQUdNQWFBQmxBQ2tBCklnQmRBQ0FBUFFBZ0FDSUFKUUJ6QUNBQUtBQm1BSElBYndCdEFD QUFZd0JoQUdNQWFBQmxBQ2tBSWdBN0FBb0FiQUJ2QUdNQVlRQnMKQUdrQWVnQmxBR1FBVXdCMEFI SUFhUUJ1QUdjQWN3QmJBQ0lBSlFCekFDQUFaQUJ2QUhjQWJnQnNBRzhBWVFCa0FDSUFYUUFnQUQw QQpJQUFpQUNVQWN3QWdBR1FBYndCM0FHNEFiQUJ2QUdFQVpBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3 QWFRQjZBR1VBWkFCVEFIUUFjZ0JwCkFHNEFad0J6QUZzQUlnQWxBSE1BSUFCc0FHRUFkQUJsQUc0 QVl3QjVBQ0lBWFFBZ0FEMEFJQUFpQUNVQWN3QWdBR3dBWVFCMEFHVUEKYmdCakFIa0FJZ0E3QUFv QWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQnpBQ0FB YkFCaApBSFFBWlFCdUFHTUFlUUFzQUNBQUpRQnpBQ0FBWkFCdkFIY0FiZ0JzQUc4QVlRQmtBQ0FB S0FBbEFITUFJQUIwQUc4QWRBQmhBR3dBCktRQWlBRjBBSUFBOUFDQUFJZ0FsQURFQUpBQnpBQ0FB YkFCaEFIUUFaUUJ1QUdNQWVRQXNBQ0FBSlFBeUFDUUFjd0FnQUdRQWJ3QjMKQUc0QWJBQnZBR0VB WkFBZ0FDZ0FKUUF6QUNRQWN3QWdBSFFBYndCMEFHRUFiQUFwQUNJQU93QUtBR3dBYndCakFHRUFi QUJwQUhvQQpaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUNnQVlRQnVBRzhBYmdCNUFHMEFi d0IxQUhNQUlBQm1BSFVBYmdCakFIUUFhUUJ2CkFHNEFLUUFpQUYwQUlBQTlBQ0FBSWdBb0FHRUFi Z0J2QUc0QWVRQnRBRzhBZFFCekFDQUFaZ0IxQUc0QVl3QjBBR2tBYndCdUFDa0EKSWdBN0FBb0Fi QUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFLQUJ3QUhJQWJ3 Qm5BSElBWVFCdApBQ2tBSWdCZEFDQUFQUUFnQUNJQUtBQndBSElBYndCbkFISUFZUUJ0QUNrQUln QTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBClV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUtB QndBSElBYndCbkFISUFZUUJ0QUNrQU9nQWdBQ1VBY3dBaUFGMEFJQUE5QUNBQUlnQW8KQUhBQWNn QnZBR2NBY2dCaEFHMEFLUUE2QUNBQUpRQnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFC a0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlBQ2dBZEFCbEFIZ0FkQUFwQUNJQVhRQWdBRDBBSUFB aUFDZ0FkQUJsQUhnQWRBQXBBQ0lBT3dBS0FHd0Fid0JqCkFHRUFiQUJwQUhvQVpRQmtBRk1BZEFC eUFHa0FiZ0JuQUhNQVd3QWlBQ2dBZHdCb0FHa0FkQUJsQUhNQWNBQmhBR01BWlFBcEFDSUEKWFFB Z0FEMEFJQUFpQUNnQWR3Qm9BR2tBZEFCbEFITUFjQUJoQUdNQVpRQXBBQ0lBT3dBS0FHd0Fid0Jq QUdFQWJBQnBBSG9BWlFCawpBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBREVBSUFCdEFHRUFkQUJq QUdnQUlnQmRBQ0FBUFFBZ0FDSUFNUUFnQUcwQVlRQjBBR01BCmFBQWlBRHNBQ2dCc0FHOEFZd0Jo QUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCQkFHd0FiQUFpQUYwQUlBQTkK QUNBQUlnQkJBR3dBYkFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBB RzRBWndCekFGc0FJZ0JCQUd3QQpkd0JoQUhrQWN3QWdBR1VBYmdCaEFHSUFiQUJsQUNJQVhRQWdB RDBBSUFBaUFFRUFiQUIzQUdFQWVRQnpBQ0FBWlFCdUFHRUFZZ0JzCkFHVUFJZ0E3QUFvQWJBQnZB R01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVFRQnVBQ0FBWlFCeUFI SUEKYndCeUFDQUFid0JqQUdNQWRRQnlBSElBWlFCa0FDQUFkQUJ5QUhrQWFRQnVBR2NBSUFCMEFH OEFYQUJ1QUhJQVpRQmhBR1FBSUFCMApBR2dBWlFBZ0FCd2dKUUJ6QUIwZ0lBQjBBR0VBWWdCc0FH VUFMZ0FpQUYwQUlBQTlBQ0FBSWdCQkFHNEFJQUJsQUhJQWNnQnZBSElBCklBQnZBR01BWXdCMUFI SUFjZ0JsQUdRQUlBQjBBSElBZVFCcEFHNEFad0FnQUhRQWJ3QmNBRzRBY2dCbEFHRUFaQUFnQUhR QWFBQmwKQUNBQUhDQWxBSE1BSFNBZ0FIUUFZUUJpQUd3QVpRQXVBQ0lBT3dBS0FHd0Fid0JqQUdF QWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlBRUVBYmdBZ0FIVUFiZ0JsQUhn QWNBQmxBR01BZEFCbEFHUUFJQUJsQUhJQWNnQnZBSElBSUFBbEFITUFJQUJ2CkFHTUFZd0IxQUhJ QWNnQmxBR1FBTGdBaUFGMEFJQUE5QUNBQUlnQkJBRzRBSUFCMUFHNEFaUUI0QUhBQVpRQmpBSFFB WlFCa0FDQUEKWlFCeUFISUFid0J5QUNBQUpRQnpBQ0FBYndCakFHTUFkUUJ5QUhJQVpRQmtBQzRB SWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbApBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lB UVFCMkFHVUFjZ0JoQUdjQVpRQWlBRjBBSUFBOUFDQUFJZ0JCQUhZQVpRQnlBR0VBClp3QmxBQ0lB T3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFSUFj Z0JsQUdFQWF3QncKQUc4QWFRQnVBSFFBY3dBaUFGMEFJQUE5QUNBQUlnQkNBSElBWlFCaEFHc0Fj QUJ2QUdrQWJnQjBBSE1BSWdBN0FBb0FiQUJ2QUdNQQpZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFh UUJ1QUdjQWN3QmJBQ0lBUXdCUEFFOEFTd0JKQUVVQVV3QWlBRjBBSUFBOUFDQUFJZ0JECkFFOEFU d0JMQUVrQVJRQlRBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJn Qm5BSE1BV3dBaUFFTUEKWVFCc0FHd0FJQUJUQUhRQVlRQmpBR3NBSWdCZEFDQUFQUUFnQUNJQVF3 QmhBR3dBYkFBZ0FGTUFkQUJoQUdNQWF3QWlBRHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpB QlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkRBR0VBYkFCc0FITUFJZ0JkQUNBQVBRQWdBQ0lBClF3 QmhBR3dBYkFCekFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdC bkFITUFXd0FpQUVNQWJBQmwKQUdFQWNnQWdBR01BYUFCaEFHNEFad0JsQUhNQUlBQnNBRzhBWndB dUFDSUFYUUFnQUQwQUlBQWlBRU1BYkFCbEFHRUFjZ0FnQUdNQQphQUJoQUc0QVp3QmxBSE1BSUFC c0FHOEFad0F1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju CkFITUFXd0FpQUVNQWJBQmxBR0VBY2dBZ0FHTUFid0J1QUhNQWJ3QnNBR1VBSUFCc0FHOEFad0F1 QUNJQVhRQWdBRDBBSUFBaUFFTUEKYkFCbEFHRUFjZ0FnQUdNQWJ3QnVBSE1BYndCc0FHVUFJQUJz QUc4QVp3QXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCawpBRk1BZEFCeUFHa0FiZ0Ju QUhNQVd3QWlBRU1BYkFCdkFITUFkUUJ5QUdVQUlnQmRBQ0FBUFFBZ0FDSUFRd0JzQUc4QWN3QjFB SElBClpRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpB RnNBSWdCREFHOEFiUUJ3QUhVQWRBQmwKQUdRQUlBQlRBSFFBZVFCc0FHVUFJZ0JkQUNBQVBRQWdB Q0lBUXdCdkFHMEFjQUIxQUhRQVpRQmtBQ0FBVXdCMEFIa0FiQUJsQUNJQQpPd0FLQUd3QWJ3QmpB R0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVNQWJ3QnZBR3NBYVFCbEFI TUFJZ0JkCkFDQUFQUUFnQUNJQVF3QnZBRzhBYXdCcEFHVUFjd0FpQURzQUNnQnNBRzhBWXdCaEFH d0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEEKWndCekFGc0FJZ0JFQUVFQVZBQkJBRUlBUVFCVEFF VUFVd0FpQUYwQUlBQTlBQ0FBSWdCRUFFRUFWQUJCQUVJQVFRQlRBRVVBVXdBaQpBRHNBQ2dCc0FH OEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCRUFFOEFUUUFpQUYw QUlBQTlBQ0FBCklnQkVBRThBVFFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JFQUdFQWRBQmgKQUdJQVlRQnpBR1VBSUFCdUFHOEFJQUJzQUc4 QWJnQm5BR1VBY2dBZ0FHZ0FZUUJ6QUNBQVpRQjRBSEFBWlFCakFIUUFaUUJrQUNBQQpkZ0JsQUhJ QWN3QnBBRzhBYmdBdUFDSUFYUUFnQUQwQUlBQWlBRVFBWVFCMEFHRUFZZ0JoQUhNQVpRQWdBRzRB YndBZ0FHd0Fid0J1CkFHY0FaUUJ5QUNBQWFBQmhBSE1BSUFCbEFIZ0FjQUJsQUdNQWRBQmxBR1FB SUFCMkFHVUFjZ0J6QUdrQWJ3QnVBQzRBSWdBN0FBb0EKYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FB VXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCawpBR2tB Y3dCaEFHSUFiQUJsQUdRQUxnQWdBRU1BYkFCcEFHTUFhd0FnQUhRQWJ3QWdBR1VBYmdCaEFHSUFi QUJsQUM0QUlnQmRBQ0FBClBRQWdBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCa0FHa0Fj d0JoQUdJQWJBQmxBR1FBTGdBZ0FFTUFiQUJwQUdNQWF3QWcKQUhRQWJ3QWdBR1VBYmdCaEFHSUFi QUJsQUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQQpj d0JiQUNJQVJBQmxBR0lBZFFCbkFHY0FhUUJ1QUdjQUlBQmxBRzRBWVFCaUFHd0FaUUJrQUM0QUlB QkRBR3dBYVFCakFHc0FJQUIwCkFHOEFJQUJrQUdrQWN3QmhBR0lBYkFCbEFDNEFJZ0JkQUNBQVBR QWdBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCbEFHNEEKWVFCaUFHd0FaUUJrQUM0QUlB QkRBR3dBYVFCakFHc0FJQUIwQUc4QUlBQmtBR2tBY3dCaEFHSUFiQUJsQUM0QUlnQTdBQW9BYkFC dgpBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVJBQmxBR0lBZFFC bkFHY0FhUUJ1QUdjQUlBQnpBR01BCmNnQnBBSEFBZEFCekFDQUFjZ0JsQUhFQWRRQnBBSElBWlFC ekFDQUFlUUJ2QUhVQUlBQjBBRzhBSUFCekFIUUFZUUJ5QUhRQUlBQjAKQUdnQVpRQWdBR1FBWlFC aUFIVUFad0JuQUdVQWNnQXVBQ0lBWFFBZ0FEMEFJQUFpQUVRQVpRQmlBSFVBWndCbkFHa0FiZ0Ju QUNBQQpjd0JqQUhJQWFRQndBSFFBY3dBZ0FISUFaUUJ4QUhVQWFRQnlBR1VBY3dBZ0FIa0Fid0Ix QUNBQWRBQnZBQ0FBY3dCMEFHRUFjZ0IwCkFDQUFkQUJvQUdVQUlBQmtBR1VBWWdCMUFHY0Fad0Js QUhJQUxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUEKY2dCcEFHNEFad0J6 QUZzQUlnQkVBR1VBYkFCbEFIUUFaUUFpQUYwQUlBQTlBQ0FBSWdCRUFHVUFiQUJsQUhRQVpRQWlB RHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkVB R2tBYlFCbEFHNEFjd0JwQUc4QWJnQnpBQ0lBClhRQWdBRDBBSUFBaUFFUUFhUUJ0QUdVQWJnQnpB R2tBYndCdUFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjAKQUhJQWFRQnVB R2NBY3dCYkFDSUFSQUJ2QUdNQWF3QWdBSFFBYndBZ0FHMEFZUUJwQUc0QUlBQjNBR2tBYmdCa0FH OEFkd0F1QUNJQQpYUUFnQUQwQUlBQWlBRVFBYndCakFHc0FJQUIwQUc4QUlBQnRBR0VBYVFCdUFD QUFkd0JwQUc0QVpBQnZBSGNBTGdBaUFEc0FDZ0JzCkFHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFI UUFjZ0JwQUc0QVp3QnpBRnNBSWdCRUFHOEFZd0IxQUcwQVpRQnVBSFFBY3dBaUFGMEEKSUFBOUFD QUFJZ0JFQUc4QVl3QjFBRzBBWlFCdUFIUUFjd0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdV QVpBQlRBSFFBY2dCcApBRzRBWndCekFGc0FJZ0JFQUc4QWJRQmhBR2tBYmdBaUFGMEFJQUE5QUNB QUlnQkVBRzhBYlFCaEFHa0FiZ0FpQURzQUNnQnNBRzhBCll3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JFQUc4QWJnQW5BSFFBSUFCd0FHRUFkUUJ6QUdVQUlBQnYKQUc0 QUlBQmxBSGdBWXdCbEFIQUFkQUJwQUc4QWJnQnpBQzRBSWdCZEFDQUFQUUFnQUNJQVJBQnZBRzRB R1NCMEFDQUFjQUJoQUhVQQpjd0JsQUNBQWJ3QnVBQ0FBWlFCNEFHTUFaUUJ3QUhRQWFRQnZBRzRB Y3dBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrCkFGTUFkQUJ5QUdrQWJnQm5BSE1B V3dBaUFFUUFid0IxQUdJQWJBQmxBQzBBUXdCc0FHa0FZd0JyQUNBQWRBQnZBQ0FBUVFCa0FHUUEK SWdCZEFDQUFQUUFnQUNJQVJBQnZBSFVBWWdCc0FHVUFMUUJEQUd3QWFRQmpBR3NBSUFCMEFHOEFJ QUJCQUdRQVpBQWlBRHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQkVBRzhBZFFCaUFHd0FaUUF0QUVNQWJBQnBBR01BCmF3QWdBSFFBYndBZ0FIUUFi d0JuQUdjQWJBQmxBQ0FBWWdCbEFIUUFkd0JsQUdVQWJnQWdBRlVBVWdCTUFDQUFaUUJ1QUdNQWJ3 QmsKQUdVQVpBQWdBR0VBYmdCa0FDQUFaQUJsQUdNQWJ3QmtBR1VBWkFBZ0FHWUFid0J5QUcwQVlR QjBBSE1BSWdCZEFDQUFQUUFnQUNJQQpSQUJ2QUhVQVlnQnNBR1VBTFFCREFHd0FhUUJqQUdzQUlB QjBBRzhBSUFCMEFHOEFad0JuQUd3QVpRQWdBR0lBWlFCMEFIY0FaUUJsCkFHNEFJQUJWQUZJQVRB QWdBR1VBYmdCakFHOEFaQUJsQUdRQUlBQmhBRzRBWkFBZ0FHUUFaUUJqQUc4QVpBQmxBR1FBSUFC bUFHOEEKY2dCdEFHRUFkQUJ6QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFC eUFHa0FiZ0JuQUhNQVd3QWlBRVVBYkFCbApBRzBBWlFCdUFIUUFjd0FpQUYwQUlBQTlBQ0FBSWdC RkFHd0FaUUJ0QUdVQWJnQjBBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBCmVnQmxBR1FBVXdC MEFISUFhUUJ1QUdjQWN3QmJBQ0lBUlFCdUFHRUFZZ0JzQUdVQUlBQkVBR1VBWWdCMUFHY0Fad0Jw QUc0QVp3QWkKQUYwQUlBQTlBQ0FBSWdCRkFHNEFZUUJpQUd3QVpRQWdBRVFBWlFCaUFIVUFad0Ju QUdrQWJnQm5BQ0lBT3dBS0FHd0Fid0JqQUdFQQpiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju QUhNQVd3QWlBRVVBYmdCaEFHSUFiQUJsQUNBQVVBQnlBRzhBWmdCcEFHd0FhUUJ1CkFHY0FJZ0Jk QUNBQVBRQWdBQ0lBUlFCdUFHRUFZZ0JzQUdVQUlBQlFBSElBYndCbUFHa0FiQUJwQUc0QVp3QWlB RHNBQ2dCc0FHOEEKWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkZB RzRBWVFCaUFHd0FaUUFnQUhJQVpRQnpBRzhBZFFCeQpBR01BWlFBZ0FIUUFjZ0JoQUdNQWF3QnBB RzRBWndBaUFGMEFJQUE5QUNBQUlnQkZBRzRBWVFCaUFHd0FaUUFnQUhJQVpRQnpBRzhBCmRRQnlB R01BWlFBZ0FIUUFjZ0JoQUdNQWF3QnBBRzRBWndBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFH VUFaQUJUQUhRQWNnQnAKQUc0QVp3QnpBRnNBSWdCRkFHNEFZUUJpQUd3QWFRQnVBR2NBSUFCa0FH VUFZZ0IxQUdjQVp3QnBBRzRBWndBZ0FIY0FhUUJzQUd3QQpJQUJ0QUdFQWF3QmxBQ0FBY3dCakFI SUFhUUJ3QUhRQWN3QWdBSElBZFFCdUFDQUFjd0JzQUc4QWR3QmxBSElBTGdBaUFGMEFJQUE5CkFD QUFJZ0JGQUc0QVlRQmlBR3dBYVFCdUFHY0FJQUJrQUdVQVlnQjFBR2NBWndCcEFHNEFad0FnQUhj QWFRQnNBR3dBSUFCdEFHRUEKYXdCbEFDQUFjd0JqQUhJQWFRQndBSFFBY3dBZ0FISUFkUUJ1QUNB QWN3QnNBRzhBZHdCbEFISUFMZ0FpQURzQUNnQnNBRzhBWXdCaApBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JGQUc0QVlRQmlBR3dBYVFCdUFHY0FJQUJ3QUhJQWJ3Qm1BR2tB CmJBQnBBRzRBWndBZ0FIY0FhUUJzQUd3QUlBQnRBR0VBYXdCbEFDQUFjd0JqQUhJQWFRQndBSFFB Y3dBZ0FISUFkUUJ1QUNBQWN3QnMKQUc4QWR3QmxBSElBTGdBaUFGMEFJQUE5QUNBQUlnQkZBRzRB WVFCaUFHd0FhUUJ1QUdjQUlBQndBSElBYndCbUFHa0FiQUJwQUc0QQpad0FnQUhjQWFRQnNBR3dB SUFCdEFHRUFhd0JsQUNBQWN3QmpBSElBYVFCd0FIUUFjd0FnQUhJQWRRQnVBQ0FBY3dCc0FHOEFk d0JsCkFISUFMZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQkZBRzRBWVFCaUFHd0EKYVFCdUFHY0FJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFJ QUIwQUhJQVlRQmpBR3NBYVFCdUFHY0FJQUIzQUdrQWJBQnNBQ0FBY2dCbApBR3dBYndCaEFHUUFJ QUIwQUdnQVpRQWdBSEFBWVFCbkFHVUFJQUJoQUc0QVpBQWdBRzBBWVFCckFHVUFJQUJ3QUdFQVp3 QmxBQ0FBCmJBQnZBR0VBWkFCcEFHNEFad0FnQUhNQWJBQnZBSGNBWlFCeUFDNEFJZ0JkQUNBQVBR QWdBQ0lBUlFCdUFHRUFZZ0JzQUdrQWJnQm4KQUNBQWNnQmxBSE1BYndCMUFISUFZd0JsQUNBQWRB QnlBR0VBWXdCckFHa0FiZ0JuQUNBQWR3QnBBR3dBYkFBZ0FISUFaUUJzQUc4QQpZUUJrQUNBQWRB Qm9BR1VBSUFCd0FHRUFad0JsQUNBQVlRQnVBR1FBSUFCdEFHRUFhd0JsQUNBQWNBQmhBR2NBWlFB Z0FHd0Fid0JoCkFHUUFhUUJ1QUdjQUlBQnpBR3dBYndCM0FHVUFjZ0F1QUNJQU93QUtBR3dBYndC akFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFXd0FpQUVVQWRnQmxBRzRBZEFB Z0FFUUFid0JqQUhVQWJRQmxBRzRBZEFBaUFGMEFJQUE5QUNBQUlnQkZBSFlBWlFCdQpBSFFBSUFC RUFHOEFZd0IxQUcwQVpRQnVBSFFBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0Iw QUhJQWFRQnVBR2NBCmN3QmJBQ0lBUlFCMkFHVUFiZ0IwQUNBQVZBQmhBSElBWndCbEFIUUFJZ0Jk QUNBQVBRQWdBQ0lBUlFCMkFHVUFiZ0IwQUNBQVZBQmgKQUhJQVp3QmxBSFFBSWdBN0FBb0FiQUJ2 QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFSUUI0QUdNQQpiQUIx QUdRQVpRQWdBSE1BWlFCc0FHVUFZd0IwQUdVQVpBQWdBR1lBZFFCdUFHTUFkQUJwQUc4QWJnQXVB Q0lBWFFBZ0FEMEFJQUFpCkFFVUFlQUJqQUd3QWRRQmtBR1VBSUFCekFHVUFiQUJsQUdNQWRBQmxB R1FBSUFCbUFIVUFiZ0JqQUhRQWFRQnZBRzRBTGdBaUFEc0EKQ2dCc0FHOEFZd0JoQUd3QWFRQjZB R1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCRkFIZ0FjQUJwQUhJQVpRQnpBQ0lBWFFBZwpB RDBBSUFBaUFFVUFlQUJ3QUdrQWNnQmxBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFH UUFVd0IwQUhJQWFRQnVBR2NBCmN3QmJBQ0lBUmdCcEFHd0FaUUFnQUhNQWFRQjZBR1VBSWdCZEFD QUFQUUFnQUNJQVJnQnBBR3dBWlFBZ0FITUFhUUI2QUdVQUlnQTcKQUFvQWJBQnZBR01BWVFCc0FH a0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVJnQnZBR01BZFFCekFDQUFjd0JsQUd3 QQpaUUJqQUhRQVpRQmtBQ0FBWmdCMUFHNEFZd0IwQUdrQWJ3QnVBQzRBSWdCZEFDQUFQUUFnQUNJ QVJnQnZBR01BZFFCekFDQUFid0J1CkFDQUFjd0JsQUd3QVpRQmpBSFFBWlFCa0FDQUFaZ0IxQUc0 QVl3QjBBR2tBYndCdUFDNEFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0EKZWdCbEFHUUFVd0IwQUhJ QWFRQnVBR2NBY3dCYkFDSUFSZ0J2QUc0QWRBQnpBQ0lBWFFBZ0FEMEFJQUFpQUVZQWJ3QnVBSFFB Y3dBaQpBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNB SWdCR0FHOEFjZ0J0QUNBQVJBQmhBSFFBCllRQWlBRjBBSUFBOUFDQUFJZ0JHQUc4QWNnQnRBQ0FB UkFCaEFIUUFZUUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlQKQUhRQWNnQnBBRzRB WndCekFGc0FJZ0JHQUhVQWJnQmpBSFFBYVFCdkFHNEFJZ0JkQUNBQVBRQWdBQ0lBUmdCMUFHNEFZ d0IwQUdrQQpid0J1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0Fi Z0JuQUhNQVd3QWlBRWNBVWdCQkFGQUFTQUJUCkFDSUFYUUFnQUQwQUlBQWlBRWNBVWdCQkFGQUFT QUJUQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFX d0FpQUVjQWJBQnZBR0lBWVFCc0FDSUFYUUFnQUQwQUlBQWlBRWNBYkFCdkFHSUFZUUJzQUNJQU93 QUtBR3dBYndCagpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVnQVZB QlVBRkFBSWdCZEFDQUFQUUFnQUNJQVNBQlVBRlFBClVBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFR QjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCSUFHVUFZUUIyQUhrQUlBQW8KQUVJQWJ3 QjBBSFFBYndCdEFDQUFWUUJ3QUNrQUlnQmRBQ0FBUFFBZ0FDSUFTQUJsQUdFQWRnQjVBQ0FBS0FC Q0FHOEFkQUIwQUc4QQpiUUFnQUZVQWNBQXBBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFC a0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFZ0FhUUJrCkFHVUFJQUJqQUdnQVlRQnVBR2NBWlFC ekFDQUFkZ0JwQUdVQWR3QXVBQ0lBWFFBZ0FEMEFJQUFpQUVnQWFRQmtBR1VBSUFCakFHZ0EKWVFC dUFHY0FaUUJ6QUNBQWRnQnBBR1VBZHdBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJr QUZNQWRBQnlBR2tBYmdCbgpBSE1BV3dBaUFFZ0FhUUJrQUdVQUlBQmpBRzhBYmdCekFHOEFiQUJs QUM0QUlnQmRBQ0FBUFFBZ0FDSUFTQUJwQUdRQVpRQWdBR01BCmJ3QnVBSE1BYndCc0FHVUFMZ0Fp QURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkoK QUcwQVlRQm5BR1VBY3dBaUFGMEFJQUE5QUNBQUlnQkpBRzBBWVFCbkFHVUFjd0FpQURzQUNnQnNB RzhBWXdCaEFHd0FhUUI2QUdVQQpaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JMQUdVQWVRQWlB RjBBSUFBOUFDQUFJZ0JMQUdVQWVRQWlBRHNBQ2dCc0FHOEFZd0JoCkFHd0FhUUI2QUdVQVpBQlRB SFFBY2dCcEFHNEFad0J6QUZzQUlnQk1BRThBUXdCQkFFd0FJQUJUQUZRQVR3QlNBRUVBUndCRkFD SUEKWFFBZ0FEMEFJQUFpQUV3QVR3QkRBRUVBVEFBZ0FGTUFWQUJQQUZJQVFRQkhBRVVBSWdBN0FB b0FiQUJ2QUdNQVlRQnNBR2tBZWdCbApBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVEFCdkFH TUFZUUJzQUNJQVhRQWdBRDBBSUFBaUFFd0Fid0JqQUdFQWJBQWlBRHNBCkNnQnNBRzhBWXdCaEFH d0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQk5BRWtBVFFCRkFDQUFkQUI1QUhB QVpRQWkKQUYwQUlBQTlBQ0FBSWdCTkFFa0FUUUJGQUNBQWRBQjVBSEFBWlFBaUFEc0FDZ0JzQUc4 QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQQpjZ0JwQUc0QVp3QnpBRnNBSWdCTkFHVUFkQUJ5QUdr QVl3QnpBQ0lBWFFBZ0FEMEFJQUFpQUUwQVpRQjBBSElBYVFCakFITUFJZ0E3CkFBb0FiQUJ2QUdN QVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFUZ0JoQUcwQVpRQWlBRjBB SUFBOUFDQUEKSWdCT0FHRUFiUUJsQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1B ZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRTRBYndBZwpBRUlBY2dCbEFHRUFhd0J3QUc4QWFRQnVBSFFB Y3dBaUFGMEFJQUE5QUNBQUlnQk9BRzhBSUFCQ0FISUFaUUJoQUdzQWNBQnZBR2tBCmJnQjBBSE1B SWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFU Z0J2QUNBQVVBQnkKQUc4QWNBQmxBSElBZEFCcEFHVUFjd0FpQUYwQUlBQTlBQ0FBSWdCT0FHOEFJ QUJRQUhJQWJ3QndBR1VBY2dCMEFHa0FaUUJ6QUNJQQpPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0Fa UUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUU0QWJ3QWdBRllBWVFCeUFHa0FZUUJpCkFHd0Fa UUJ6QUNJQVhRQWdBRDBBSUFBaUFFNEFid0FnQUZZQVlRQnlBR2tBWVFCaUFHd0FaUUJ6QUNJQU93 QUtBR3dBYndCakFHRUEKYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUU0QWJ3 QjBBQ0FBUmdCdkFIVUFiZ0JrQUNJQVhRQWdBRDBBSUFBaQpBRTRBYndCMEFDQUFSZ0J2QUhVQWJn QmtBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BCld3 QWlBRTRBYndCMEFDQUFVQUJoQUhVQWN3QmxBR1FBSWdCZEFDQUFQUUFnQUNJQVRnQnZBSFFBSUFC UUFHRUFkUUJ6QUdVQVpBQWkKQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dC cEFHNEFad0J6QUZzQUlnQlBBRzRBYkFCNUFDQUFaUUJ1QUdFQQpZZ0JzQUdVQUlBQm1BRzhBY2dB Z0FIUUFhQUJwQUhNQUlBQnpBR1VBY3dCekFHa0Fid0J1QUNJQVhRQWdBRDBBSUFBaUFFOEFiZ0Jz CkFIa0FJQUJsQUc0QVlRQmlBR3dBWlFBZ0FHWUFid0J5QUNBQWRBQm9BR2tBY3dBZ0FITUFaUUJ6 QUhNQWFRQnZBRzRBSWdBN0FBb0EKYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1 QUdjQWN3QmJBQ0lBVHdCMEFHZ0FaUUJ5QUNJQVhRQWdBRDBBSUFBaQpBRThBZEFCb0FHVUFjZ0Fp QURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlFB R0VBCmRBQm9BQ0lBWFFBZ0FEMEFJQUFpQUZBQVlRQjBBR2dBSWdBN0FBb0FiQUJ2QUdNQVlRQnNB R2tBZWdCbEFHUUFVd0IwQUhJQWFRQnUKQUdjQWN3QmJBQ0lBVUFCaEFIVUFjd0JsQUNBQWJ3QnVB Q0FBWlFCNEFHTUFaUUJ3QUhRQWFRQnZBRzRBY3dBdUFDSUFYUUFnQUQwQQpJQUFpQUZBQVlRQjFB SE1BWlFBZ0FHOEFiZ0FnQUdVQWVBQmpBR1VBY0FCMEFHa0Fid0J1QUhNQUxnQWlBRHNBQ2dCc0FH OEFZd0JoCkFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlFBR0VBZFFCekFH VUFJQUJ6QUdNQWNnQnBBSEFBZEFBZ0FHVUEKZUFCbEFHTUFkUUIwQUdrQWJ3QnVBQzRBSWdCZEFD QUFQUUFnQUNJQVVBQmhBSFVBY3dCbEFDQUFjd0JqQUhJQWFRQndBSFFBSUFCbApBSGdBWlFCakFI VUFkQUJwQUc4QWJnQXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdr QWJnQm5BSE1BCld3QWlBRkFBWVFCMUFITUFaUUJrQUNJQVhRQWdBRDBBSUFBaUFGQUFZUUIxQUhN QVpRQmtBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnAKQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhN QVd3QWlBRkFBWVFCMUFITUFhUUJ1QUdjQUlnQmRBQ0FBUFFBZ0FDSUFVQUJoQUhVQQpjd0JwQUc0 QVp3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNB SWdCUUFISUFid0JtCkFHa0FiQUJsQUNBQUpRQmtBQ0lBWFFBZ0FEMEFJQUFpQUZBQWNnQnZBR1lB YVFCc0FHVUFJQUFsQUdRQUlnQTdBQW9BYkFCdkFHTUEKWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElB YVFCdUFHY0Fjd0JiQUNJQVVBQnlBRzhBWmdCcEFHd0FaUUJ6QUNJQVhRQWdBRDBBSUFBaQpBRkFB Y2dCdkFHWUFhUUJzQUdVQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFj Z0JwQUc0QVp3QnpBRnNBCklnQlFBSElBYndCbUFHa0FiQUJwQUc0QVp3QWdBR1FBYVFCekFHRUFZ Z0JzQUdVQVpBQXVBQ0FBUXdCc0FHa0FZd0JyQUNBQWRBQnYKQUNBQVpRQnVBR0VBWWdCc0FHVUFM Z0FpQUYwQUlBQTlBQ0FBSWdCUUFISUFid0JtQUdrQWJBQnBBRzRBWndBZ0FHUUFhUUJ6QUdFQQpZ Z0JzQUdVQVpBQXVBQ0FBUXdCc0FHa0FZd0JyQUNBQWRBQnZBQ0FBWlFCdUFHRUFZZ0JzQUdVQUxn QWlBRHNBQ2dCc0FHOEFZd0JoCkFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUln QlFBSElBYndCbUFHa0FiQUJwQUc0QVp3QWdBR1VBYmdCaEFHSUEKYkFCbEFHUUFMZ0FnQUVNQWJB QnBBR01BYXdBZ0FIUUFid0FnQUdRQWFRQnpBR0VBWWdCc0FHVUFMZ0FpQUYwQUlBQTlBQ0FBSWdC UQpBSElBYndCbUFHa0FiQUJwQUc0QVp3QWdBR1VBYmdCaEFHSUFiQUJsQUdRQUxnQWdBRU1BYkFC cEFHTUFhd0FnQUhRQWJ3QWdBR1FBCmFRQnpBR0VBWWdCc0FHVUFMZ0FpQURzQUNnQnNBRzhBWXdC aEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlEKQUhJQWJ3QndBR1VBY2dC MEFHa0FaUUJ6QUNJQVhRQWdBRDBBSUFBaUFGQUFjZ0J2QUhBQVpRQnlBSFFBYVFCbEFITUFJZ0E3 QUFvQQpiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVQUJ5 QUc4QWRBQnZBSFFBZVFCd0FHVUFJZ0JkCkFDQUFQUUFnQUNJQVVBQnlBRzhBZEFCdkFIUUFlUUJ3 QUdVQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUEKYVFCdUFHY0Fjd0Ji QUNJQVVRQjFBR1VBY2dCNUFDSUFYUUFnQUQwQUlBQWlBRkVBZFFCbEFISUFlUUFpQURzQUNnQnNB RzhBWXdCaApBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JSQUhVQVpRQnlB SGtBSUFCVEFIUUFjZ0JwQUc0QVp3QWdBRkFBCllRQnlBR0VBYlFCbEFIUUFaUUJ5QUhNQUlnQmRB Q0FBUFFBZ0FDSUFVUUIxQUdVQWNnQjVBQ0FBVXdCMEFISUFhUUJ1QUdjQUlBQlEKQUdFQWNnQmhB RzBBWlFCMEFHVUFjZ0J6QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFH a0FiZ0JuQUhNQQpXd0FpQUZJQVJRQlRBRThBVlFCU0FFTUFSUUJUQUNJQVhRQWdBRDBBSUFBaUFG SUFSUUJUQUU4QVZRQlNBRU1BUlFCVEFDSUFPd0FLCkFHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FG TUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGSUFaUUJtQUhJQVpRQnpBR2dBSWdCZEFDQUEKUFFBZ0FD SUFVZ0JsQUdZQWNnQmxBSE1BYUFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCegpBRnNBSWdCU0FHVUFjUUIxQUdVQWN3QjBBQ0FBU0FCbEFHRUFaQUJsQUhJ QWN3QWlBRjBBSUFBOUFDQUFJZ0JTQUdVQWNRQjFBR1VBCmN3QjBBQ0FBU0FCbEFHRUFaQUJsQUhJ QWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnoKQUZz QUlnQlNBR1VBY1FCMUFHVUFjd0IwQUNBQVVBQmhBSGtBYkFCdkFHRUFaQUFpQUYwQUlBQTlBQ0FB SWdCU0FHVUFjUUIxQUdVQQpjd0IwQUNBQVVBQmhBSGtBYkFCdkFHRUFaQUFpQURzQUNnQnNBRzhB WXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6CkFGc0FJZ0JTQUdVQWN3QnZBSFVB Y2dCakFHVUFJQUJwQUc0QWRBQmxBSElBY0FCeUFHVUFkQUJsQUdRQUlBQmhBSE1BSUFBbEFITUEK SUFCaUFIVUFkQUFnQUhRQWNnQmhBRzRBY3dCbUFHVUFjZ0J5QUdVQVpBQWdBSGNBYVFCMEFHZ0FJ QUJOQUVrQVRRQkZBQ0FBZEFCNQpBSEFBWlFBZ0FDVUFjd0F1QUNJQVhRQWdBRDBBSUFBaUFGSUFa UUJ6QUc4QWRRQnlBR01BWlFBZ0FHa0FiZ0IwQUdVQWNnQndBSElBClpRQjBBR1VBWkFBZ0FHRUFj d0FnQUNVQU1RQWtBSE1BSUFCaUFIVUFkQUFnQUhRQWNnQmhBRzRBY3dCbUFHVUFjZ0J5QUdVQVpB QWcKQUhjQWFRQjBBR2dBSUFCTkFFa0FUUUJGQUNBQWRBQjVBSEFBWlFBZ0FDVUFNZ0FrQUhNQUxn QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QQphUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUln QlNBR1VBY3dCdkFIVUFjZ0JqQUdVQUlBQjBBSElBWVFCakFHc0FhUUJ1CkFHY0FJQUJrQUdrQWN3 QmhBR0lBYkFCbEFHUUFMZ0FnQUVNQWJBQnBBR01BYXdBZ0FIUUFid0FnQUdVQWJnQmhBR0lBYkFC bEFDNEEKSWdCZEFDQUFQUUFnQUNJQVVnQmxBSE1BYndCMUFISUFZd0JsQUNBQWRBQnlBR0VBWXdC ckFHa0FiZ0JuQUNBQVpBQnBBSE1BWVFCaQpBR3dBWlFCa0FDNEFJQUJEQUd3QWFRQmpBR3NBSUFC MEFHOEFJQUJsQUc0QVlRQmlBR3dBWlFBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBCmJBQnBBSG9BWlFC a0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGSUFaUUJ6QUc4QWRRQnlBR01BWlFBZ0FIUUFjZ0Jo QUdNQWF3QnAKQUc0QVp3QWdBR1VBYmdCaEFHSUFiQUJsQUdRQUxnQWdBRU1BYkFCcEFHTUFhd0Fn QUhRQWJ3QWdBR1FBYVFCekFHRUFZZ0JzQUdVQQpMZ0FpQUYwQUlBQTlBQ0FBSWdCU0FHVUFjd0J2 QUhVQWNnQmpBR1VBSUFCMEFISUFZUUJqQUdzQWFRQnVBR2NBSUFCbEFHNEFZUUJpCkFHd0FaUUJr QUM0QUlBQkRBR3dBYVFCakFHc0FJQUIwQUc4QUlBQmtBR2tBY3dCaEFHSUFiQUJsQUM0QUlnQTdB QW9BYkFCdkFHTUEKWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVVnQmxB SE1BYndCMUFISUFZd0JsQUhNQUlnQmRBQ0FBUFFBZwpBQ0lBVWdCbEFITUFid0IxQUhJQVl3QmxB SE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBCmN3QmJB Q0lBVWdCbEFITUFjQUJ2QUc0QWN3QmxBQ0FBU0FCbEFHRUFaQUJsQUhJQWN3QWlBRjBBSUFBOUFD QUFJZ0JTQUdVQWN3QncKQUc4QWJnQnpBR1VBSUFCSUFHVUFZUUJrQUdVQWNnQnpBQ0lBT3dBS0FH d0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlBRklBWlFCekFI UUFid0J5QUdVQUlBQmhBR3dBYkFBZ0FHWUFkUUJ1QUdNQWRBQnBBRzhBYmdCekFDNEFJZ0JkCkFD QUFQUUFnQUNJQVVnQmxBSE1BZEFCdkFISUFaUUFnQUdFQWJBQnNBQ0FBWmdCMUFHNEFZd0IwQUdr QWJ3QnVBSE1BTGdBaUFEc0EKQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0 QVp3QnpBRnNBSWdCU0FIVUFiZ0FnQUNVQVpBQWlBRjBBSUFBOQpBQ0FBSWdCU0FIVUFiZ0FnQUNV QVpBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNB CklnQlRBRVVBVXdCVEFFa0FUd0JPQUNBQVV3QlVBRThBVWdCQkFFY0FSUUFpQUYwQUlBQTlBQ0FB SWdCVEFFVUFVd0JUQUVrQVR3Qk8KQUNBQVV3QlVBRThBVWdCQkFFY0FSUUFpQURzQUNnQnNBRzhB WXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQQpJZ0JUQUdNQWJ3QndBR1VB SUFCV0FHRUFjZ0JwQUdFQVlnQnNBR1VBY3dBaUFGMEFJQUE5QUNBQUlnQlRBR01BYndCd0FHVUFJ QUJXCkFHRUFjZ0JwQUdFQVlnQnNBR1VBY3dBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFa QUJUQUhRQWNnQnBBRzRBWndCekFGc0EKSWdCVEFHTUFjZ0JwQUhBQWRBQnpBQ0lBWFFBZ0FEMEFJ QUFpQUZNQVl3QnlBR2tBY0FCMEFITUFJZ0E3QUFvQWJBQnZBR01BWVFCcwpBR2tBZWdCbEFHUUFV d0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVd0JsQUdFQWNnQmpBR2dBSUFBbEFITUFJZ0JkQUNBQVBR QWdBQ0lBClV3QmxBR0VBY2dCakFHZ0FJQUFsQUhNQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVn QmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmIKQUNJQVV3QmxBR01BZFFCeUFHVUFJZ0JkQUNBQVBR QWdBQ0lBVXdCbEFHTUFkUUJ5QUdVQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQQplZ0JsQUdRQVV3 QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVV3QmxBR3dBWlFCakFIUUFJQUJoQUc0QUlBQmxBR3dBWlFC dEFHVUFiZ0IwCkFDQUFhUUJ1QUNBQWRBQm9BR1VBSUFCd0FHRUFad0JsQUNBQWRBQnZBQ0FBYVFC dUFITUFjQUJsQUdNQWRBQWdBR2tBZEFBdUFDSUEKWFFBZ0FEMEFJQUFpQUZNQVpRQnNBR1VBWXdC MEFDQUFZUUJ1QUNBQVpRQnNBR1VBYlFCbEFHNEFkQUFnQUdrQWJnQWdBSFFBYUFCbApBQ0FBY0FC aEFHY0FaUUFnQUhRQWJ3QWdBR2tBYmdCekFIQUFaUUJqQUhRQUlBQnBBSFFBTGdBaUFEc0FDZ0Jz QUc4QVl3QmhBR3dBCmFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFHVUFiQUJt QUNJQVhRQWdBRDBBSUFBaUFGTUFaUUJzQUdZQUlnQTcKQUFvQWJBQnZBR01BWVFCc0FHa0FlZ0Js QUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVV3QmxBSE1BY3dCcEFHOEFiZ0FpQUYwQQpJQUE5 QUNBQUlnQlRBR1VBY3dCekFHa0Fid0J1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtB Rk1BZEFCeUFHa0FiZ0JuCkFITUFXd0FpQUZNQWFBQnZBSGNBSUFCaEFHSUFjd0J2QUd3QWRRQjBB R1VBSUFCMEFHOEFkQUJoQUd3QUlBQmhBRzRBWkFBZ0FITUEKWlFCc0FHWUFJQUIwQUdrQWJRQmxB SE1BTGdBaUFGMEFJQUE5QUNBQUlnQlRBR2dBYndCM0FDQUFZUUJpQUhNQWJ3QnNBSFVBZEFCbApB Q0FBZEFCdkFIUUFZUUJzQUNBQVlRQnVBR1FBSUFCekFHVUFiQUJtQUNBQWRBQnBBRzBBWlFCekFD NEFJZ0E3QUFvQWJBQnZBR01BCllRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFD SUFVd0JvQUc4QWR3QWdBR01BYUFCaEFHNEFad0JsQUhNQUlBQjIKQUdrQVpRQjNBQzRBSWdCZEFD QUFQUUFnQUNJQVV3Qm9BRzhBZHdBZ0FHTUFhQUJoQUc0QVp3QmxBSE1BSUFCMkFHa0FaUUIzQUM0 QQpJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJ QVV3Qm9BRzhBZHdBZ0FHTUFid0J1CkFITUFid0JzQUdVQUxnQWlBRjBBSUFBOUFDQUFJZ0JUQUdn QWJ3QjNBQ0FBWXdCdkFHNEFjd0J2QUd3QVpRQXVBQ0lBT3dBS0FHd0EKYndCakFHRUFiQUJwQUhv QVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRk1BYUFCdkFIY0FJQUJwQUc0QWFBQmxBSElB YVFCMApBR1VBWkFBaUFGMEFJQUE5QUNBQUlnQlRBR2dBYndCM0FDQUFhUUJ1QUdnQVpRQnlBR2tB ZEFCbEFHUUFJZ0E3QUFvQWJBQnZBR01BCllRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NB Y3dCYkFDSUFVd0JvQUc4QWR3QWdBSFFBYUFCbEFDQUFiZ0JsQUhnQWRBQWcKQUhNQVl3QnlBR2tB Y0FCMEFDQUFjZ0JsQUhNQWJ3QjFBSElBWXdCbEFDNEFJZ0JkQUNBQVBRQWdBQ0lBVXdCb0FHOEFk d0FnQUhRQQphQUJsQUNBQWJnQmxBSGdBZEFBZ0FITUFZd0J5QUdrQWNBQjBBQ0FBY2dCbEFITUFi d0IxQUhJQVl3QmxBQzRBSWdBN0FBb0FiQUJ2CkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFh UUJ1QUdjQWN3QmJBQ0lBVXdCb0FHOEFkd0FnQUhRQWFBQmxBQ0FBY0FCeUFHVUEKZGdCcEFHOEFk UUJ6QUNBQWN3QmpBSElBYVFCd0FIUUFJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFMZ0FpQUYwQUlB QTlBQ0FBSWdCVApBR2dBYndCM0FDQUFkQUJvQUdVQUlBQndBSElBWlFCMkFHa0Fid0IxQUhNQUlB QnpBR01BY2dCcEFIQUFkQUFnQUhJQVpRQnpBRzhBCmRRQnlBR01BWlFBdUFDSUFPd0FLQUd3QWJ3 QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZNQWFBQnYKQUhjQUlB QjBBRzhBZEFCaEFHd0FJQUJoQUc0QVpBQWdBSE1BWlFCc0FHWUFJQUIwQUdrQWJRQmxBSE1BSUFC aEFITUFJQUJ3QUdVQQpjZ0JqQUdVQWJnQjBBR0VBWndCbEFITUFMZ0FpQUYwQUlBQTlBQ0FBSWdC VEFHZ0Fid0IzQUNBQWRBQnZBSFFBWVFCc0FDQUFZUUJ1CkFHUUFJQUJ6QUdVQWJBQm1BQ0FBZEFC cEFHMEFaUUJ6QUNBQVlRQnpBQ0FBY0FCbEFISUFZd0JsQUc0QWRBQmhBR2NBWlFCekFDNEEKSWdB N0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVd0Jw QUhvQVpRQWlBRjBBSUFBOQpBQ0FBSWdCVEFHa0FlZ0JsQUNJQU93QUtBR3dBYndCakFHRUFiQUJw QUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRk1BCmJ3QnlBSFFBSUFCaUFIa0FJQUJF QUhVQWNnQmhBSFFBYVFCdkFHNEFJZ0JkQUNBQVBRQWdBQ0lBVXdCdkFISUFkQUFnQUdJQWVRQWcK QUVRQWRRQnlBR0VBZEFCcEFHOEFiZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRB SFFBY2dCcEFHNEFad0J6QUZzQQpJZ0JUQUc4QWNnQjBBQ0FBWWdCNUFDQUFSUUJ1QUdRQUlBQlVB R2tBYlFCbEFDSUFYUUFnQUQwQUlBQWlBRk1BYndCeUFIUUFJQUJpCkFIa0FJQUJGQUc0QVpBQWdB RlFBYVFCdEFHVUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFH Y0EKY3dCYkFDSUFVd0J2QUhJQWRBQWdBR0lBZVFBZ0FFd0FZUUIwQUdVQWJnQmpBSGtBSWdCZEFD QUFQUUFnQUNJQVV3QnZBSElBZEFBZwpBR0lBZVFBZ0FFd0FZUUIwQUdVQWJnQmpBSGtBSWdBN0FB b0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBCmN3QmJBQ0lBVXdCdkFI SUFkQUFnQUdJQWVRQWdBRklBWlFCekFIQUFid0J1QUhNQVpRQWdBRlFBYVFCdEFHVUFJZ0JkQUNB QVBRQWcKQUNJQVV3QnZBSElBZEFBZ0FHSUFlUUFnQUZJQVpRQnpBSEFBYndCdUFITUFaUUFnQUZR QWFRQnRBR1VBSWdBN0FBb0FiQUJ2QUdNQQpZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdj QWN3QmJBQ0lBVXdCdkFISUFkQUFnQUdJQWVRQWdBRk1BYVFCNkFHVUFJZ0JkCkFDQUFQUUFnQUNJ QVV3QnZBSElBZEFBZ0FHSUFlUUFnQUZNQWFRQjZBR1VBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tB ZWdCbEFHUUEKVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVXdCdkFISUFkQUFnQUdJQWVRQWdBRk1B ZEFCaEFISUFkQUFnQUZRQWFRQnRBR1VBSWdCZApBQ0FBUFFBZ0FDSUFVd0J2QUhJQWRBQWdBR0lB ZVFBZ0FGTUFkQUJoQUhJQWRBQWdBRlFBYVFCdEFHVUFJZ0E3QUFvQWJBQnZBR01BCllRQnNBR2tB ZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVd0J2QUhVQWNnQmpBR1VBSWdCZEFDQUFQ UUFnQUNJQVV3QnYKQUhVQWNnQmpBR1VBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFV d0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVd0IwQUdFQQpjZ0IwQUNBQWNBQnlBRzhBWmdCcEFHd0Fh UUJ1QUdjQUxnQWlBRjBBSUFBOUFDQUFJZ0JUQUhRQVlRQnlBSFFBSUFCd0FISUFid0JtCkFHa0Fi QUJwQUc0QVp3QXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJn Qm5BSE1BV3dBaUFGTUEKZEFCbEFIQUFJQUJwQUc0QWRBQnZBQ0FBYmdCbEFIZ0FkQUFnQUdZQWRR QnVBR01BZEFCcEFHOEFiZ0FnQUdNQVlRQnNBR3dBTGdBaQpBRjBBSUFBOUFDQUFJZ0JUQUhRQVpR QndBQ0FBYVFCdUFIUUFid0FnQUc0QVpRQjRBSFFBSUFCbUFIVUFiZ0JqQUhRQWFRQnZBRzRBCklB QmpBR0VBYkFCc0FDNEFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFC dUFHY0Fjd0JiQUNJQVV3QjAKQUdVQWNBQWdBRzhBZFFCMEFDQUFid0JtQUNBQVl3QjFBSElBY2dC bEFHNEFkQUFnQUdZQWRRQnVBR01BZEFCcEFHOEFiZ0F1QUNJQQpYUUFnQUQwQUlBQWlBRk1BZEFC bEFIQUFJQUJ2QUhVQWRBQWdBRzhBWmdBZ0FHTUFkUUJ5QUhJQVpRQnVBSFFBSUFCbUFIVUFiZ0Jq CkFIUUFhUUJ2QUc0QUxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0Jw QUc0QVp3QnpBRnNBSWdCVEFIUUEKWlFCd0FDQUFid0IyQUdVQWNnQWdBRzRBWlFCNEFIUUFJQUJt QUhVQWJnQmpBSFFBYVFCdkFHNEFJQUJqQUdFQWJBQnNBQzRBSWdCZApBQ0FBUFFBZ0FDSUFVd0Iw QUdVQWNBQWdBRzhBZGdCbEFISUFJQUJ1QUdVQWVBQjBBQ0FBWmdCMUFHNEFZd0IwQUdrQWJ3QnVB Q0FBCll3QmhBR3dBYkFBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlB R2tBYmdCbkFITUFXd0FpQUZNQWRBQmwKQUhBQWNBQnBBRzRBWndBaUFGMEFJQUE5QUNBQUlnQlRB SFFBWlFCd0FIQUFhUUJ1QUdjQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQQplZ0JsQUdRQVV3QjBB SElBYVFCdUFHY0Fjd0JiQUNJQVV3QjBBRzhBY0FBZ0FIQUFjZ0J2QUdZQWFRQnNBR2tBYmdCbkFD NEFJZ0JkCkFDQUFQUUFnQUNJQVV3QjBBRzhBY0FBZ0FIQUFjZ0J2QUdZQWFRQnNBR2tBYmdCbkFD NEFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0EKZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFD SUFVd0IwQUc4QWNnQmhBR2NBWlFBaUFGMEFJQUE5QUNBQUlnQlRBSFFBYndCeQpBR0VBWndCbEFD SUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZN QWRBQjVBR3dBClpRQWdBRUVBZEFCMEFISUFhUUJpQUhVQWRBQmxBQ0lBWFFBZ0FEMEFJQUFpQUZN QWRBQjVBR3dBWlFBZ0FFRUFkQUIwQUhJQWFRQmkKQUhVQWRBQmxBQ0lBT3dBS0FHd0Fid0JqQUdF QWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGTUFkQUI1QUd3QQpaUUJ6QUNJ QVhRQWdBRDBBSUFBaUFGTUFkQUI1QUd3QVpRQnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9B WlFCa0FGTUFkQUJ5CkFHa0FiZ0JuQUhNQVd3QWlBRk1BZEFCNUFHd0FaUUJ6QUdnQVpRQmxBSFFB Y3dBaUFGMEFJQUE5QUNBQUlnQlRBSFFBZVFCc0FHVUEKY3dCb0FHVUFaUUIwQUhNQUlnQTdBQW9B YkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVkFCbwpBR1VB SUFBY0lDVUFjd0FkSUZ3QWJnQjBBR0VBWWdCc0FHVUFJQUJwQUhNQUlBQmxBRzBBY0FCMEFIa0FM Z0FpQUYwQUlBQTlBQ0FBCklnQlVBR2dBWlFBZ0FCd2dKUUJ6QUIwZ1hBQnVBSFFBWVFCaUFHd0Fa UUFnQUdrQWN3QWdBR1VBYlFCd0FIUUFlUUF1QUNJQU93QUsKQUd3QWJ3QmpBR0VBYkFCcEFIb0Fa UUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZRQWFBQnBBSE1BSUFCekFHa0FkQUJsQUNBQQph QUJoQUhNQUlBQnVBRzhBSUFCakFHOEFid0JyQUdrQVpRQnpBQzRBSWdCZEFDQUFQUUFnQUNJQVZB Qm9BR2tBY3dBZ0FITUFhUUIwCkFHVUFJQUJvQUdFQWN3QWdBRzRBYndBZ0FHTUFid0J2QUdzQWFR QmxBSE1BTGdBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUEKWkFCVEFIUUFjZ0JwQUc0QVp3 QnpBRnNBSWdCVUFHZ0FhUUJ6QUNBQWN3QjBBRzhBY2dCaEFHY0FaUUFnQUdrQWN3QWdBR1VBYlFC dwpBSFFBZVFBdUFDSUFYUUFnQUQwQUlBQWlBRlFBYUFCcEFITUFJQUJ6QUhRQWJ3QnlBR0VBWndC bEFDQUFhUUJ6QUNBQVpRQnRBSEFBCmRBQjVBQzRBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdC bEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFWQUJwQUcwQVpRQWkKQUYwQUlBQTlBQ0FBSWdC VUFHa0FiUUJsQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju QUhNQQpXd0FpQUZRQWJ3QjBBR0VBYkFBaUFGMEFJQUE5QUNBQUlnQlVBRzhBZEFCaEFHd0FJZ0E3 QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsCkFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFWQUJ5 QUdVQVpRQWdBQ2dBVkFCdkFIQUFJQUJFQUc4QWR3QnVBQ2tBSWdCZEFDQUEKUFFBZ0FDSUFWQUJ5 QUdVQVpRQWdBQ2dBVkFCdkFIQUFJQUJFQUc4QWR3QnVBQ2tBSWdBN0FBb0FiQUJ2QUdNQVlRQnNB R2tBZWdCbApBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVlFCdUFHUUFid0JqQUdzQUlBQnBB RzRBZEFCdkFDQUFjd0JsQUhBQVlRQnlBR0VBCmRBQmxBQ0FBZHdCcEFHNEFaQUJ2QUhjQUxnQWlB RjBBSUFBOUFDQUFJZ0JWQUc0QVpBQnZBR01BYXdBZ0FHa0FiZ0IwQUc4QUlBQnoKQUdVQWNBQmhB SElBWVFCMEFHVUFJQUIzQUdrQWJnQmtBRzhBZHdBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFI b0FaUUJrQUZNQQpkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGVUFjd0JsQUNBQWJBQmhBSElBWndCbEFD QUFjZ0JsQUhNQWJ3QjFBSElBWXdCbEFDQUFjZ0J2CkFIY0Fjd0F1QUNJQVhRQWdBRDBBSUFBaUFG VUFjd0JsQUNBQWJBQmhBSElBWndCbEFDQUFjZ0JsQUhNQWJ3QjFBSElBWXdCbEFDQUEKY2dCdkFI Y0Fjd0F1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhN QVd3QWlBRlVBY3dCbApBQ0FBY3dCdEFHRUFiQUJzQUNBQWNnQmxBSE1BYndCMUFISUFZd0JsQUNB QWNnQnZBSGNBY3dBdUFDSUFYUUFnQUQwQUlBQWlBRlVBCmN3QmxBQ0FBY3dCdEFHRUFiQUJzQUNB QWNnQmxBSE1BYndCMUFISUFZd0JsQUNBQWNnQnZBSGNBY3dBdUFDSUFPd0FLQUd3QWJ3QmoKQUdF QWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGWUFZUUJzQUhVQVpRQWlBRjBB SUFBOUFDQUFJZ0JXQUdFQQpiQUIxQUdVQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FB VXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVndCcEFIUUFhQUFnCkFFSUFiQUJ2QUdNQWF3QWlBRjBB SUFBOUFDQUFJZ0JYQUdrQWRBQm9BQ0FBUWdCc0FHOEFZd0JyQUNJQU93QUtBR3dBYndCakFHRUEK YkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZnQVNBQlNBQ0lBWFFBZ0FEMEFJ QUFpQUZnQVNBQlNBQ0lBT3dBSwpBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0Fi Z0JuQUhNQVd3QWlBRmtBYndCMUFDQUFZd0J2QUhVQWJBQmtBQ0FBCmN3QmhBSFlBWlFBZ0FHSUFZ UUJ1QUdRQWR3QnBBR1FBZEFCb0FDQUFZZ0I1QUNBQWFBQmhBSFlBYVFCdUFHY0FJQUI1QUc4QWRR QnkKQUNBQWR3QmxBR0lBSUFCekFHVUFjZ0IyQUdVQWNnQWdBR01BYndCdEFIQUFjZ0JsQUhNQWN3 QWdBSFFBYUFCcEFITUFJQUIwQUhJQQpZUUJ1QUhNQVpnQmxBSElBSUFCM0FHa0FkQUJvQUNBQVp3 QjZBR2tBY0FBZ0FHOEFjZ0FnQUhvQWJBQnBBR0lBTGdBaUFGMEFJQUE5CkFDQUFJZ0JaQUc4QWRR QWdBR01BYndCMUFHd0FaQUFnQUhNQVlRQjJBR1VBSUFCaUFHRUFiZ0JrQUhjQWFRQmtBSFFBYUFB Z0FHSUEKZVFBZ0FHZ0FZUUIyQUdrQWJnQm5BQ0FBZVFCdkFIVUFjZ0FnQUhjQVpRQmlBQ0FBY3dC bEFISUFkZ0JsQUhJQUlBQmpBRzhBYlFCdwpBSElBWlFCekFITUFJQUIwQUdnQWFRQnpBQ0FBZEFC eUFHRUFiZ0J6QUdZQVpRQnlBQ0FBZHdCcEFIUUFhQUFnQUdjQWVnQnBBSEFBCklBQnZBSElBSUFC NkFHd0FhUUJpQUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1 QUdjQWN3QmIKQUNJQVdRQnZBSFVBSUFCdUFHVUFaUUJrQUNBQWRBQnZBQ0FBWlFCdUFHRUFZZ0Jz QUdVQUlBQmtBR1VBWWdCMUFHY0Fad0JwQUc0QQpad0FnQUdJQVpRQm1BRzhBY2dCbEFDQUFlUUJ2 QUhVQUlBQmpBR0VBYmdBZ0FIVUFjd0JsQUNBQWRBQm9BR1VBSUFCVEFHTUFjZ0JwCkFIQUFkQUJ6 QUNBQWNBQmhBRzRBWlFCc0FDNEFJZ0JkQUNBQVBRQWdBQ0lBV1FCdkFIVUFJQUJ1QUdVQVpRQmtB Q0FBZEFCdkFDQUEKWlFCdUFHRUFZZ0JzQUdVQUlBQmtBR1VBWWdCMUFHY0Fad0JwQUc0QVp3QWdB R0lBWlFCbUFHOEFjZ0JsQUNBQWVRQnZBSFVBSUFCagpBR0VBYmdBZ0FIVUFjd0JsQUNBQWRBQm9B R1VBSUFCVEFHTUFjZ0JwQUhBQWRBQnpBQ0FBY0FCaEFHNEFaUUJzQUM0QUlnQTdBQW9BCmJBQnZB R01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVdRQnZBSFVBSUFCdUFH VUFaUUJrQUNBQWRBQnYKQUNBQVpRQnVBR0VBWWdCc0FHVUFJQUJ3QUhJQWJ3Qm1BR2tBYkFCcEFH NEFad0FnQUdJQVpRQm1BRzhBY2dCbEFDQUFlUUJ2QUhVQQpJQUJqQUdFQWJnQWdBSFVBY3dCbEFD QUFkQUJvQUdVQUlBQlFBSElBYndCbUFHa0FiQUJsQUhNQUlBQndBR0VBYmdCbEFHd0FMZ0FpCkFG MEFJQUE5QUNBQUlnQlpBRzhBZFFBZ0FHNEFaUUJsQUdRQUlBQjBBRzhBSUFCbEFHNEFZUUJpQUd3 QVpRQWdBSEFBY2dCdkFHWUEKYVFCc0FHa0FiZ0JuQUNBQVlnQmxBR1lBYndCeUFHVUFJQUI1QUc4 QWRRQWdBR01BWVFCdUFDQUFkUUJ6QUdVQUlBQjBBR2dBWlFBZwpBRkFBY2dCdkFHWUFhUUJzQUdV QWN3QWdBSEFBWVFCdUFHVUFiQUF1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1B CmRBQnlBR2tBYmdCbkFITUFXd0FpQUZrQWJ3QjFBQ0FBYmdCbEFHVUFaQUFnQUhRQWJ3QWdBR1VB YmdCaEFHSUFiQUJsQUNBQWNnQmwKQUhNQWJ3QjFBSElBWXdCbEFDQUFkQUJ5QUdFQVl3QnJBR2tB YmdCbkFDQUFkQUJ2QUNBQWRRQnpBR1VBSUFCMEFHZ0FhUUJ6QUNBQQpjQUJoQUc0QVpRQnNBQzRB SWdCZEFDQUFQUUFnQUNJQVdRQnZBSFVBSUFCdUFHVUFaUUJrQUNBQWRBQnZBQ0FBWlFCdUFHRUFZ Z0JzCkFHVUFJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFJQUIwQUhJQVlRQmpBR3NBYVFCdUFHY0FJ QUIwQUc4QUlBQjFBSE1BWlFBZ0FIUUEKYUFCcEFITUFJQUJ3QUdFQWJnQmxBR3dBTGdBaUFEc0FD Z0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCegpBRnNBSWdCaUFHOEFj Z0JrQUdVQWNnQWlBRjBBSUFBOUFDQUFJZ0JpQUc4QWNnQmtBR1VBY2dBaUFEc0FDZ0JzQUc4QVl3 QmhBR3dBCmFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCakFHOEFiZ0IwQUdVQWJn QjBBQ0lBWFFBZ0FEMEFJQUFpQUdNQWJ3QnUKQUhRQVpRQnVBSFFBSWdBN0FBb0FiQUJ2QUdNQVlR QnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFaQUJ2QUdNQQpkUUJ0QUdVQWJn QjBBQ0lBWFFBZ0FEMEFJQUFpQUdRQWJ3QmpBSFVBYlFCbEFHNEFkQUFpQURzQUNnQnNBRzhBWXdC aEFHd0FhUUI2CkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JsQUd3QVpRQnRBR1VBYmdC MEFCa2djd0FnQUJ3Z0pRQnpBQjBnSUFCaEFIUUEKZEFCeUFHa0FZZ0IxQUhRQVpRQWlBRjBBSUFB OUFDQUFJZ0JsQUd3QVpRQnRBR1VBYmdCMEFCa2djd0FnQUJ3Z0pRQnpBQjBnSUFCaApBSFFBZEFC eUFHa0FZZ0IxQUhRQVpRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0Jw QUc0QVp3QnpBRnNBCklnQm1BRzhBYmdCMEFDSUFYUUFnQUQwQUlBQWlBR1lBYndCdUFIUUFJZ0E3 QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjAKQUhJQWFRQnVBR2NBY3dCYkFDSUFhUUJ0 QUdFQVp3QmxBQ0lBWFFBZ0FEMEFJQUFpQUdrQWJRQmhBR2NBWlFBaUFEc0FDZ0JzQUc4QQpZd0Jo QUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCcEFHNEFiQUJwQUc0QVpRQWdB SE1BZEFCNUFHd0FaUUJ6CkFHZ0FaUUJsQUhRQUlnQmRBQ0FBUFFBZ0FDSUFhUUJ1QUd3QWFRQnVB R1VBSUFCekFIUUFlUUJzQUdVQWN3Qm9BR1VBWlFCMEFDSUEKT3dBS0FHd0Fid0JqQUdFQWJBQnBB SG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFHd0FhUUJ1QUdVQUlBQWxBR1FBSWdCZApB Q0FBUFFBZ0FDSUFiQUJwQUc0QVpRQWdBQ1VBWkFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFH VUFaQUJUQUhRQWNnQnBBRzRBClp3QnpBRnNBSWdCdEFHRUFjZ0JuQUdrQWJnQWlBRjBBSUFBOUFD QUFJZ0J0QUdFQWNnQm5BR2tBYmdBaUFEc0FDZ0JzQUc4QVl3QmgKQUd3QWFRQjZBR1VBWkFCVEFI UUFjZ0JwQUc0QVp3QnpBRnNBSWdCdkFIUUFhQUJsQUhJQUlnQmRBQ0FBUFFBZ0FDSUFid0IwQUdn QQpaUUJ5QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhN QVd3QWlBSEFBWVFCa0FHUUFhUUJ1CkFHY0FJZ0JkQUNBQVBRQWdBQ0lBY0FCaEFHUUFaQUJwQUc0 QVp3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUEKY2dCcEFHNEFad0J6QUZz QUlnQndBRzhBY3dCcEFIUUFhUUJ2QUc0QUlnQmRBQ0FBUFFBZ0FDSUFjQUJ2QUhNQWFRQjBBR2tB YndCdQpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1B V3dBaUFITUFZd0J5QUdrQWNBQjBBQ0lBClhRQWdBRDBBSUFBaUFITUFZd0J5QUdrQWNBQjBBQ0lB T3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm4KQUhNQVd3QWlBSE1B ZEFCNUFHd0FaUUJ6QUdnQVpRQmxBSFFBSWdCZEFDQUFQUUFnQUNJQWN3QjBBSGtBYkFCbEFITUFh QUJsQUdVQQpkQUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQjFBSE1BWlFCeUFDQUFZUUJuCkFHVUFiZ0IwQUNBQWN3QjBBSGtBYkFCbEFITUFh QUJsQUdVQWRBQWlBRjBBSUFBOUFDQUFJZ0IxQUhNQVpRQnlBQ0FBWVFCbkFHVUEKYmdCMEFDQUFj d0IwQUhrQWJBQmxBSE1BYUFCbEFHVUFkQUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpB QlRBSFFBY2dCcApBRzRBWndCekFGc0FJZ0IxQUhNQVpRQnlBQ0FBY3dCMEFIa0FiQUJsQUhNQWFB QmxBR1VBZEFBaUFGMEFJQUE5QUNBQUlnQjFBSE1BClpRQnlBQ0FBY3dCMEFIa0FiQUJsQUhNQWFB QmxBR1VBZEFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnAKQUc0QVp3 QnpBRnNBSWdCMkFHa0FZUUFnQUdrQWJnQnpBSEFBWlFCakFIUUFid0J5QUNJQVhRQWdBRDBBSUFB aUFIWUFhUUJoQUNBQQphUUJ1QUhNQWNBQmxBR01BZEFCdkFISUFJZ0E3QUFvQWJBQnZBR01BWVFC c0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiCkFDSUFRd0JRQUZVQUlBQlFBRklBVHdC R0FFa0FUQUJGQUZNQUlnQmRBQ0FBUFFBZ0FDSUFRd0JRQUZVQUlBQlFBRklBVHdCR0FFa0EKVEFC RkFGTUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0Ji QUNJQVNBQkZBRUVBVUFBZwpBRk1BVGdCQkFGQUFVd0JJQUU4QVZBQlRBQ0lBWFFBZ0FEMEFJQUFp QUVnQVJRQkJBRkFBSUFCVEFFNEFRUUJRQUZNQVNBQlBBRlFBClV3QWlBRHNBQ2dCc0FHOEFZd0Jo QUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVUFHRUFhd0JsQUNBQWFBQmwK QUdFQWNBQWdBSE1BYmdCaEFIQUFjd0JvQUc4QWRBQXVBQ0lBWFFBZ0FEMEFJQUFpQUZRQVlRQnJB R1VBSUFCb0FHVUFZUUJ3QUNBQQpjd0J1QUdFQWNBQnpBR2dBYndCMEFDNEFJZ0E3QUFvQWJBQnZB R01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiCkFDSUFWd0JoQUhRQVl3Qm9B Q0FBUlFCNEFIQUFjZ0JsQUhNQWN3QnBBRzhBYmdCekFDSUFYUUFnQUQwQUlBQWlBRmNBWVFCMEFH TUEKYUFBZ0FFVUFlQUJ3QUhJQVpRQnpBSE1BYVFCdkFHNEFjd0FpQURzQUNnQnNBRzhBWXdCaEFH d0FhUUI2QUdVQVpBQlRBSFFBY2dCcApBRzRBWndCekFGc0FJZ0JFQUdVQWJBQmxBSFFBWlFBZ0FI Y0FZUUIwQUdNQWFBQWdBR1VBZUFCd0FISUFaUUJ6QUhNQWFRQnZBRzRBCkxnQWlBRjBBSUFBOUFD QUFJZ0JFQUdVQWJBQmxBSFFBWlFBZ0FIY0FZUUIwQUdNQWFBQWdBR1VBZUFCd0FISUFaUUJ6QUhN QWFRQnYKQUc0QUxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0 QVp3QnpBRnNBSWdCQkFHUUFaQUFpQUYwQQpJQUE5QUNBQUlnQkJBR1FBWkFBaUFEc0FDZ0E9Cgo= 39058 2009-09-04 08:25:21 -0700 2009-09-04 08:25:21 -0700 current watch expressions pane watch-expressions.png image/png 45682 pmuellr iVBORw0KGgoAAAANSUhEUgAAARQAAAEiCAYAAAA4Uy3JAAAK+WlDQ1BJQ0MgUHJvZmlsZQAAeAGF Vnk4lG0Xv2cwlrFv2Q0lu2Tfk7EkhDGWhIyxjaxjLNlCKknZt0iFQilliRBCsr6iRGXptQ1SSMgy +Z7J917v9f3xvt+5ruc6v/s8v3Oe5z7nvq9zAED+wAUG+sIBAH7+JCLGxADlcNoRRT8KkIAJMABB QIfDBwcet7Iyhyj/IBvvAYz66q08NZZgt9yhmulrft2TZaVLRzwu/oPTX2YWIvRBAGAoyMDttY9V qNhtH5+g4jBSIAniOFEx3hvnDuFACMsRsRg0hAsgzOq1jyuo2G0fN1FxKN6L6tsHAILT353gDwD9 ZwBoWN09gvEAMK1AnDx8IBHiIJMhrO/nFwDFR0J8IEXNBaQhwTEBoGEN+Tr8bQs8CcATIgDiKX/b JOIAOGAPQLne37Y1zO/8wHgHgj2VlX6HgzEbAEA3sbe3dhiKmQ4AJW1vb6dob49SDP3bGACtvvgQ YuhvLvTzsH4A/t96f5//9aCBCgIVFS5Dq4IA9C2MMUgt5m+siewojnouC+63vGcOTPPjBT4JYYVf iSqh7oozHfQ7NHRYXjJRiiyjKXtdbkJB9kiEYpsSk7KVSprqsDqnhrVmslanDtBV0ws4dlf/vQEC rW7oZZRt3Gny3VTspJnZefMSi8FTu1aHrS0xoTaF2DZbsj29g8xpI0f3M5FOWc6lLo1nX7u+x427 zeHn3Bc8ZjwnvIa9uwmNPqXnsn2j/Tz9zQMUA3kC14NGiM+Cs0khIZjQo2EsYV/Cu8/fj0iIdIs6 Hi0WA4+ZvdAVWxGXER910SvB9pLRZa0rRxPlryokKV/TSTa5bnvDPSUkNTHtVnp1Rk/mdBYlhz9X Nc/mZnB+ekH1rXeFm3f47+oUuRTHl5Tc67q/UMZcLv/g1EO/iuRH5Y9fVU4++VnFVn2oRqPW9JlD nUd94PPwhujGuKa4F7HNES0hrYSXLm0W7dodkq9YX210Dr9+1pXefa7HsJe3d7Gvof/KH7YDIgPk N08HSUOaQ5S3ze9ih/WHf71vGjk/qjq6+qHio8cn0U+jY6njphOwibrJgM8Sn8f+zJgyndqbrp3x nRWf/TCXQjYiU+arFwiLqMWRL8lL6KWfXyu+4ZZ5lrtWIlflV8e/X1/TXVv8kbtutL68kbeJ3lz8 mbqltvVxO2pHZKd113l3h5L3S+VX357H3h50cKzgC7TudHcRaww6jGFMrcglFilWW7bL7FUcE1zM 3Co87ryXD1TxDQsAQQkhS2GSSIFoG2pRnPugziGCROrhJskZaXYZbVmCXLZ8h8KaovhRrFKCcr0K WU1A3UIjTrNGa05HQNdML/ZYpf6fBpxoE8MYo3rjjROqpuEnW8zpLaxP3bScs1bCRNm8tmW2w9hn Ogw5spzRdwp2vunSdnbCddsNiRdxl/fQ9TT1svd2JZzzCToX4XvB77J/UkBKYFpQBjEzOJOUGZIR mhGWGp5y/lpEYmRCVFx0VEz4heBY/zhCvPtF1wTHS7aXra6YJ5pcNUjSu6aVrH5d+YZiilyqdJpE uniGSKZgFl82dw5HLkse001EPjyfUrB960fhyu3FO7N3J4pGiwdLeu61328orS4rL7/9IOthUsWF R8THnpUOT8yealfJVgvUMNZs1s48G6xrrL//PKUhrNG1yeiFXDNb81rL+9a6l3lt4e32HWqvuF6t dva9Lu2K73bqUetl7SX3tfRn/+E3gH7D/2Z5sGMo763/O4Nh3uGF9y9GUkfxH9Q/Mn4c+1Q5FjeO nTg8sTXZ97nwz6Apw2ne6cWZptkbcziy8jxifnShfDHqi/mS8NLy15ZvqcuuK0dW9lb7vxes+fxQ X6ddf7NRsEn4qfyTstW1nbpzeldsd55S+Yu0p/m7/iU0mXSGiGmGUMZZpAvzB1ZNtgL2LU5Trtvc ZF7ZA/589/lnBTmE0MIEkTTRatSg2NeDdIeEJRQO60qekLKRPiNzVtZdzk0er+B0xFHx1FETJW1l RZWDqlxqdGrf1ac1+jUbtUq103Uu6BL07I5p6ovqU44PG1SiIw1NjXiMPhkXm3ifkDmxbFp1MsRM y4xi3m5x7ZStJcpyxarDOh8TbYPHmtuq20nYs9nvOsyeHnBsOFPsdMM5zMXtrJmrKg7lhnTbxE+5 D3i88Hzole+dTIjxIZ7z8j3r5+CPDcAE2gTZEZ2DvUlhIcmhJWHt4bMRyEjlKOfoqzF1F8hx/PGn LiYkNF5av6KY6Hv1QdJ8stR17xvlKV/S5NMDMp5mfs9WziHmPs37li9b4H7rVuG7O/R3NYs8izNL Gu9NlcLLxMt1H9g+JFREPLr8OLUy60nu08yqtOpLNRG13s+wddr1gvWU590N2Y0uTYJNH16kNxs1 b7aUtWJaKS/L2izavrfndmh3jL+K7TzY2fHao4u+q7zbrPtbT3qveu94X0K/Qv/oHxcHVAfm3+QP 2g/xDL17W/QucNj4vewI+8jOKPnD248tnyrGcscvT5Am3T9j/zSe0piWnzk4KzjHTeaYZ1vgWOT5 Irwk9VXjm8Wy18ql1Yrvoz/Y1y028jfXthy3P+z6/xKj1n+/31F7Ag0CgGyo1znMA2DDB0CSCwCS OQDwlgFgxQIAVhPAK1QA3JgZwHnvAhoQTu0fkEYCfiAPjIEHSAK1YA4mDHOE3YKR4RrwFPhXGgxN C60S7SM6RboGhDlijj6RQYlhhrGQyRUpg6Qwj7A8Zy1my2RP5rjGmcFVwt3MM3WAg8+cP0tgSchG uFfUHrUh/vAQ8bC5lIaMkpy2gpVigFK2yku1ZU0hbbQu/ljo8Rj0JaNkkwzTArN7Fk8tm60HbKZt dx0EHPWcCC4FrqN4UQ+i15CPvm9LgGXQD9LjsAsRPtFBsTkXP1+xTJq6kZcelO1zM66wtpiu1O/h 0pO4Wsnn48232/26TPvVh3RGnMcKp+jIOV9Pr2G2rlDzBegADzgCbEAceA52YCawAtg23A0+RHOS ppcWSztDF4kQQLTS+zKIMowy5jA5IaWQW8yDLE9Ys9ji2UM4fDhxXI7cWB4ML/aAI58Xf7RAvmCn MBA5KVomJiCee0hM4pmknTRMpk7uvIKRotBRivKC6oT6uOas9roeq76CgZ1hgnHDiZ9muhZJlpMY HWyRPcfpq05IlxycPL7fM4Jw9NyGf2fQPVJaWHJETvTT2PEEgSuEpJ4b2mnNWda5PwpK7xBKNMv4 Kmgrd2tg9RxNsq2WHVFdtX1bgyeHyz/yTKRNi5CblnxXFTcYt3/+3i8tYAUooAkcQTyoAl9gcrBQ WA9cEp5CA6eJpWWivU1nQLeKeEQfxmDJqMokhZRm1mDBskaxPWHf5HThmuVJPHCcn0lgTKhS5DxK XmzyYIGEp6SWNJ8skFtWmFX8rDSpMqk2qTGuNaLTo1etn2pAMDQwFoAmhm6zIotISztrZRtO7Lrd mEOXY6NTrUuda7vbR/dfXooE4rnX/kcCHwUbhqyHd0RWxXTEIy7du5p/fTwdlyOQv3Nn497Og+3K 6Zqi5xIv7F9Kd5C7HvYFv9F5Bx9p/xQ1KT31es56oeOr0Ap2zWsDs8W2k0f5Qt3v/sxHvQ+ABx3g G0BEmaMNUWicL8GNiCN5QHPfvvAANAgAvtBDhNJjDq0MIY0GOMhGAG6QFQdI0JX47fCvkf6K+P81 ySMcmkEBQAcEnicSvLxJqOPQNO2BMvXHK8ihlBQVNf49xv7cSuUg2AEowFFRqzP1UP+v/AcijMxL CWoOXwAAIABJREFUeAHsfQdgVUX29y+9kQAhoQZCC71IkKYUQRRZVLBiAZXVddV1V9mG5a/r6rqu +u0quruWVUFF7Aoq0ntvoSdAElIgCSmQXt9L8p0z952Xm5uXvIS8JBDugZuZO3PmnDNnZs6bmXvn XDfUDm66LH1clwxjuvFej2vGTQ2YGrh4NVBpEM14L9n6dH1c5ddmAPTpEpdQCBvvOd1RWl34kmeG pgZMDTS9BmoYAB1LR3nGNLmXkIvr4w4NgBgFY8iFJc0Yl3vO1+NwugmmBkwNXNwaYKMgl15SvbFw FJc0CWsMfjEGtYXMTJ/HcbmXPLmXUNI5NMHUgKmBltWAffCTGBLnUOIsndxLmoSSV2toHPT1uWcc wZO4hMxI4oLDaQzGey3V/GtqwNRAc2lAbxiYpyPDUZ80fVmRXZXzlDtDqB/8EncnHGOc7+XifAa5 F1wJtdwqGnJvhqYGTA00rQYcGRLmaDQeFYY0zuc0HsMSp6iKcyjpHFcgg51DR3FGEkPC+RxX9++8 804eZ5pgasAlGvDshMH92iM97jiyylxC0STiRAOnTp1Cnz594OHh4fC68847g4iEGBK9seG4gBgl vq/kGYoYEk7QGxa5d2RQOM0EUwOu04A1HSfislFhGhPX6bTxlDyIhCPjoTciYj84DbLkMRoSzuM0 MSYSMj7H3SsrVXmKmmBqwDUasJSWuoaQScVVGuDxzgaFLytdPOg5zjaAQ70RUIbF0QyF8GoYEybA 1ooviVPUBFMDpgZasQbYPpTTJbMQjjOwIdEbFc5XxoULCEghvmdkvtcbEDEoXMZjzZo1FJhgasDU wKWqgYiICGeiexEC2wKenRiBjQvniZFRRkUMit6YcJwvvVFhY6IMiS30+vbbbyl64bB06VLce++9 aO6lk5ubG/bt24crr7zS5H3hzdegkqLzkSNHNqicidy0GnjqqaecMfAmBIsNSW8j9DMUTpelj5sY FCEshoTv2aDoLzYqbLG4jJerDIGr6JBM9QLu3AImb9FE04ai8+bWd9PW6rKgzuOdQQaN7JuwXWCo sZ8iBkUKcMiXzE7EoOiXO8zE2xWdg2m4gg7JU28QnhLWu6ALEIWnhC4gWW8SwlPCehd0AaLw5NCE S0oDPEMRYOOhNyiOZinVZihiTJiAGBIOZbmjZiZ0z0xcYlCITrMbFD3PlujgwlNClqe5QHhK2Fx8 mQ/zbAm+zVnHVsjLaFDYiPAlhkXiYjtqvIfCOuFMBpmpODQqrugcLdHJhKeEWlWb56/wlLB5uGpc hKeELcW7OfmavBqtATYoYjR485UNiWzGcpyB7QTjKOBZh96AcFwMCYey1JHQPkvhjukKcBWdhsgi PCVsSNnG4gpPCetL7/vvv8d3332n0J955hkMHDiwvkXteMJTQnuGk0hRURH+8pe/KKy//vWv8Pf3 d1KiZjbzbCjfmlTMlGbWABsUMSL8pEfsgKTxZIPjYjfUDIXu7UaF44ykNyoSZ2MiV41N2bVr1+K6 667j8qgtrjJ1f1qik0mnbghvHlCrV69GVFQUkpKSEBISAn5iccsttzRocF0Ib1FXRYX8IFALUlxo Sb6zUPAbUm+myXV/4YUXkJiYqFiwYeH7hhgVPW9FxPzTRBoowNE9segUOQKhPFIbD7xfyoZExj3H xXiIMZGQudXYQ+FEBn0h2UORkIl76Ts4F+BOw2cCLBZLrXHG0wOXMdLR5+vjmzdvxqZNm9CzZ0/c f//9oLNEKmxIx2Z6wlNCPQ9HcTYgb7/9NjIzMyFPKzi+atUqbN26FQsWLMDp06exbds2OHsMJzwl dMSvtjQuI3Ch5cUQ1VfnbExefPFFuzFh/mxY2KA8//zz9TYqIm99+Uo9L8mw5CAe7HA1vrAJf+Mf 38Wbz81FF9cM8LpVUnAMoyZdg7XphejQpm7UeuayQeHHxiy9jH82KrzsERtBUQV8b5+h2NKqIUkB mbHIdIeJe+o7OBfme2eXMNGHRjr6PH08PT0dMTExKonLsIHZu3evMioTJ07UozqNC08JayuQlZWF f/zjH+pXmo1Jjx491CDigZacnIzCwkKV379/f0RHR6v610ZL0oWnhJLuKBQ+nMeyCDBvAZFJ7usK haeEdeGKMWGDagQ2Krz0aahRqQ9fI69L7p76ZiqGYEXCJgzP3oB7Iu/E5zNuxPxR7Zq+Kj5+uBET eXBSX3QJOzXWiZKMfbYJYg84ziB2QnHU203JkFAKcsgEJXRoUJgyg77T1BbXMKuMkNzXFQotDiXO nZ5nKhs3bsQjjzyCjh071kVC5Ul5Cesq8L///U8Zk/DwcMyZMwcDBgywo/OM5P3331f5Bw8ehLu7 u10uO5IhIjwlNGTXuOVf9C+++EIts/SZ/FIgGziW649//KNTvlxWeEqop+cozrx/+ctfqnIJCQn4 +OOPFdqkSZMwefJkxZ9xmJ4zEJ71wXVG66LPV/oIhp+vD9pGXIfbhgB5lBa/4hUMn/2yEv/GZ7/H oqemwpdmM088fhQvfzAHbVCArx6ajYL5X+KXg9vg4JKnMOHR/yj8hbvSVFrWwa9w/4QHsYVSn/3y EJ76RW+K5eCrp6bjwf8cVbggk7JAjRHbbeMCvUGR8c8h2wgJxV5wqKYyHBpBkPSF9EbFIz8/v1qZ 4uJilJWVgdNri1crQDeCb0x3dM+4DOXl5YqHHuf48eN48sknMWPGDNx88836rBrxwMBAZQSc8d69 ezeYLu+X/P73v4enpyeys7Pt9IYPH4558+Zh0aJF9jSjTuwZtkh9eevLzZ8/H//85z/VskrS2Zh0 794dnMeD2hlfLnchvLt166ZYFhQUCGsEBQUhLCxM3TtqCzuiLiK86yOnrtilGS0pok2HTGSdPYsj 0R/jCRrn/2tjQUXlROyI/Q16lmxE16HPYPcDYxCJXKQeTkEOjZlKFFJ8C0pzc5CfeRgLyJgs3nMK 17cvRK6HBfnZB/AoGZPZO07hC78t6DriUUw89Q06bnkaD26YhT2nfgYOfYzRt6xEbkE+8p3b+fro V2YmYkwc2YVqdPQzFM6QAsra6O7FsOiNSjVCF8ONlxcv+VwDaWlpatbBv9I8gHnw8DKLYfTo0Wrv hH9xeWbSlMC8//CHP1QzKmxMOI3zmhK4zgz6mQUbMElvSt6XMu0uiMGdIyKoCjfgje/3YEaYL8Uj ELNtBT7cy30oXL1yrtXRRwvoLz9SUeetfXtg+lXAA/c/j/+9/jvMiOwAa+IJrKL8kM/fQWLJKYpl w1JuxaF1S3Db4zsQ5ktDeeRVuAorKc9loB/v3NnEDkjH41AuxVQMih6BMwRJHwoxDpnRRQO8FHn0 0UfVr6fMZBor3OzZs9Uyh2dbPID4kS1vCjPExsZi5syZKt4cf/RGhfk1hzFpjnq1Vh5pNKy/j/kG Y9pKDc/hv9cOxbfj38DrM8dh4Ouf2Q/I2EwIIeqHVFs8+MUR9P78fdx742jc9p8t+Effs4RzAyZN m4ouVHrSTD/08SnFgf1A15sDhZGrQzEobAdk/OttAscZ7KEYFC3Z8V89ASYqhB1jN2Oqn58f5s6d i/Hjx6OkpEQtoVzFvpR8c/AlkJKSYp8RsJGZPn26ZNlDVxkzO0FdRIwKJzX1zETHVkV5RvTss8+q eNu29lFiRDPvdRrw0o+swiR8S88T/vrdbETmr6D5S9XSOSnmWxzPfRjdot7BAsJ5iWlYC3HmnC8m z30aq/PXYVpiHt6mKcsNeA5JltcxY0wHwilBiacvRt82ENM+WofHxs9G5oZl2EHFXTdPV4ZCP+bF FuhqWj2qr7bk2K0NJQgBY8hMmhV4L4NnIrJ+nzZtGm677Tb1qJoHeFPD1KlTERcXp9iMGDHCpcar PrLzng6/3Mbw+OOP2/VQn7KNxTlw4AC++uorRYY3gU2j4lyj1QZ1QH88Pmcg7hzYFbjqNtw2MAY3 /vZLxH50De65IQa3DOxBk485ZDAYaEhaT+H5EdPUEocK4D/r+wC+bfH66jdw57Sh+JvCuwGrYz9C xM1/xW1/uxMDu84Hve1IOeEq10V/ZPJgHP9yz2w4bge+YaMiVojjfLE+eEnHFy8A+dVIvgJsV5vU 1NTFFK8GvPkmG2+1xaXA+vXrMWvWLDu+pNcW8qYo75HwGp5nDj4+PtVmELWVM6azXNu3b8fVV19d b95Mg9+x4RkRA/Pn920aChfKm/m88MILOH/+vGLZt29f/O53v2sQ+8bwfvrpp+282YcGG5WGgPAe NmxYQ4q1OlyeRfv68nAqQWGJJwJ434O2cAsLSxEQwENLD1aUUDplqAFYlUNlC8vhQ+lcWoPaaEi+ 4/CNN95w5lP2ASrJO/KFtquIQr5K6OKnJHzxQOB3U/iqqJKJ7hyA3hJJtqM0lSfGhG9qiwuRhoZW qxV8CeiXI5LWlCHvo+ifdjQlL0e0+X0TecrEs7XmBOYtxiw0NLQ5WbcqXpox4Sr5kjGRqpFhCXA0 DD3h6zCdyhptD5kWxzSExwWHjsa6ozQ7A0c1sWeakYtHA/x2sGwKX3PNNc0q2MMPP6yOUzBTOV7R rAKYzC4ZDdRlUNgS6aFOy6RHNOOu1wAvuWQjuCk3fx1Jzrzl/Z7m5u1IHjOt2TXgaOwb7YMSqi6D opdaX9gRcT2uGW8iDbTkYG5J3k2kTpOscw0Yx7reDjgs3exPaxxKYSaaGjA10Co0cKEGxamlahXa MSthauDy1kCDx3l9lzw11Hr48OEaaQ1N4Me3LQUm7+bXvCv6TPNLbXJsiAYu2KDwi2XLli1T72ME BwerA4H8bga/xcmPx7y9vdV7IxxKnDf3+PErv4jGPkX4XRATTA2YGmgZDfC7YK6GCzYoLAi/bMZH 6Hv16qUOyfHGHb+rwW4F+NAcGxJ+AU2MihgU9iNy4sQJ5OXV/r11Nkx8KK2218wlT39wrTHKMfJz Nf2GymaUx1je1fIZ+bmavlF+Z/dGeYz4rpbPyM/V9I3yO7s3ymPEb2n5jPLIfaMMChsINhx649Gm TRvk5uYqw8JvtnIeGx6+GJ8VxSEDv/XK945A8jh0BFxOcBzlO0szNoijBmScCwUjfSMdR/z0OFI3 s/5m++v7hcRd0f+FlivDRhkUrpQe+J4NCL9qzbMQMSZsQNig8D0PNDEoXLauQVufvBo45cXIK9Re i/cgg+ZLr8tr5ksvqRaXsudj9+Pg6VL0GjkGvdp6wHhfs6SWUl5ciEJLOdWH+ATU5CP0HZWXPAlr 4JTn4eDu/cj1DMPY0RHqDIQeR8pJqM+rb1xfVuIS1pdGXXh10ZI8CR3RqU9eXTiOaOrT9GUlLqEe 70LjddGSPAkd8ahPXl04jmg2dVqjDIrMONiQ6I2LzEzYgEieGBtO44uBleFIIfLrzHlCV+KCz7wl TVNSIY5tXIGV+5O1W/vfUPIXcT96+mi0pDzTlfKFZ/Zg//4ClPcchp5BATDe20nZI4WI+vFzbDiR Y09BwEg8/uhk+NQyq9Hz40LCW+SpIqTF3MqysHP7PuT7uGHkqL7KrZ/QYAyJc1gfMPJraHlnPIz0 jfhGfo3FN9Iz8jPeG/k1tLyRnvHeSN+Yb+TXWHwjPSM/472RH5dvCmiUQdELJAJzGgu7f/9+tekq BoTT5BKDIoaDy0h53rTlk608w9EDlxWcdu3a4dZbb1X0tCVBCXZ98g52sNtVnzDMuucm9GrniZys 0zi0JxX+Hjxtrr5EEt4cetFJTj4D5eur4Rjv9XJwPPvwGmVMfMIm4L47roRnTgKOxlIDES1r+l78 97OtCIi8A7+8pru9KMvOICHXR2SQdKmjuvfwRRBF8oN84cHLPgO+lOWwPmDk19Dy9eEhdXOEK3kS GuXh9Gr1d6Kvhspv5NfQ8o7qZEyTuhnT+V7yJDTK0xL1dyRnY9NcZlBYQQInT55Uvl75INngwYPV jITz5RI8DkXBEmdjM2bMGGzYsEGPZsdj/HHjxqk86RRlqfs1Y4IwPPqX+ehamoMSayWC+nTEgGFj kZ+ehsObV2L9wZO0ROGiXug9ajpuHN9HLYdonqTxkk5sv6+Sj2WXRi8ps7lL8A9EO/pGjW/QSPyi XwXOpUTjKzImzCLn2HK8faITZs67HV0LorHs6w1Iti3F2nWJxIzbrkEnOsvNNNOjt2H11gPIsuX3 nnAXZl4hrwhps7iK3Dh888VKWPtPx12T+tiNqehdZOOQQS8v34uuOBQQXL434jujZ8wXmrWFjugz rl4GY1zK6PEEh/OkTpKvx5c4hwyCa9a/qv2VYlz8R3rtBZOVBtYT+OCDD9TtkiVL1GNiwZFQcHk2 wg1svPjJUdeuXVVnkzwuy3E+ut+pUycVl7R0mxf4tmOvR4dzp3EuN59mOAXIzTmHtJSzKLCW4fyZ swgbP4v8wN6OoaEWnNr7A3amlFXr0HSj6Ip8qNScMDMfllXC8CEjFUrpyZ/x+mvvYWPUCaSnZ8Pq HYJB/TUHRD5BvTBm9HAEe1TCUpiHonaRuJt80M6IDEVOWhSWbzmlaGYc+h6frdpDxsQdkVNmYEpk b/h5e5APUtkQ9oRbRT7WffEDThfS7OsXw+16kfqzXiTOoT5u1J/kG0M9DX1c8PT118cl31moL8Nx 5iGhyFhXyPRFLn1cyujT9PHa8hlHfwnt2vCN8nNZSdPTqS0uuBzyxXwkFJ51hUyX84W+xKVMQ/MZ vymgUQZFljN6wfjZNs9QGPhzC1u2bFFK4Hv5teA4gyjHUcizEOPmLT+CjoyMVIoVRXLo56WdBa+0 FCCfZiY16fnjhj/+FQ9NHkgbxp0Qbvtmibtbma2RRB6RSbvniYrwYZoc57A4aBRe+NU0KG+glixs +3EJ3l9xGMXl/hh73WhVOGjwZPxi6mi0d6uEf/8b8czvb0I3cvDcY+Bgle/n70e0inFid4K6Hzvv Wcy+diyunf0Y7r+mp0pTf7yLcXDDchwp9MGsPz2E9kW5dplENpFLwpr1r5JdX0Yf19dPHxccfVp9 6DvDd0RDn8Z153sBloNB5DGGzvgxvuAYy+rzRAZ9mj4u+cZQj6OPG/Hqe891ZVwBpsnAoaOLcYWv Ix6Spy8rtF0ZNmrJI4KLQPz+yeeff15NEfwZiAkTJtgcywimFuoVxnGZpnIuO5wZMmQI2FsYA+ex pzRxcqQSbX/IhKhYqaVEKZVvhJZmxIqwadHfsO7oOVsJLXBzq2lPleJtWExXZNTTqyzKQn6nCXj1 tVHY9t1ifLPrDIpiN2BrQk9MaMP+ZwisOTibzv6p6DMKB77HOyv2Kc80KkH9YdoeoIdDtH0Tin7t cpCSbrXzoymKhpqyG1tTONoNgaUZytuNllH9L8vNMnLIoJeX76UeEhrzjeX1ZTjuDF94c6gvK/yM oR5H4sJDETD8MdI3ZKt6Cw7nCS0OGYz8jfmXY/2VYlz8p+aIaiADaTAutnz5cpw7V33Q8otuX375 pb1B9eS5keu62KDwI2gGfhu3X79+quNw4+uvToMGKJzSw6twKEN7ZMz5DByWphzQjEnvaXhp4UL8 dormJMjTw12jozD5j7as0f0u2HP09BTNnLOISynBkJnzMTdSW+akn82Ge7nWgUvzSlXdKiqKaP+G jUlb3P3Uv7DwtUehuHtqT6ksym1tJo6S39BquhDOtPE7a0IY3aXg04+3Id9Qd5ZFL5sU06dxnGlL qI9zmqRLyPkMEnKc8yQUPAkZz3hJHof6uBGvvvd6GkJTH4psSkj6w3mSpi8r/PRp+rjkc1mOCzij J+Uk1NPUxyW/oaGeBseNF8vJaQISFzzmx3HhK/mC76qwUTMUEUKMyt1334177rlHeVbjV+t5icKP kDkUHCnDoVSS45zPlRQ8zpMN2nXr1qmNWE4T4DjjcljcZiRm9V6FZafKsOXLD5Ey+moM7NgGxTmp OBiVgitn0NeWGPIysHXFF7SEyFS3yScTMXBULxVXf2hWoOchSx7O0/NL27sCO/I6YVjfzkiM2YK9 Ubmq+NCh4fD2rFRLobzDO7Cv81j07x0KP2W2S5Cw/2eciNlFX20hiDmE9EHXYsCYMGxfewZR3y+D x3Vj0KniPDLIL+iVEZXaJxVKPDDohvuRvOdlROXux49bu2D2+PBq8jA50YXoj9Oq1YUTdKCvDycb y0tZfSg49cFnHCnLcSNIW0vHZtqSxrj1ka8ueYSGka/c14e+nkZD8fVlhac+lLq2ZP318rgq3ugZ ijwC1gskSpIOpW94PZ7kc5rEOdTHeXN2ypQpaoYiePp8lUabnlc8+hLuntCfbi2I37MJP/30E9Zv i8K58hB06TEMU8JoxyPrANas2YmuEyLVoE/eux6p7B3TBp62d1vs9/TEySgP59H2B9JP7MHaFT/g pzV7kE5p/afNw8SQClgCwjFVbcymY+ealciyBGDAeJarFLvWrkNS28FQ2eeOIjolByETHya5e1N+ FvauXYGf1u9EXAG76vTQ9mjcLMhMKcJtv71d3Wcd+gl70jm/Smf6uMjrLNSX0cdrK6fH0cdrw3eW rqehj0s5fZo+Xt98wast1NPUx12FXxsdSdfz1MddlS90aguZZ1MAz895lsKGhS+O88VOqnnP0ZGT at7SDCRBP+SZQ+fOndV5Hj6vI4aD/cnyfgrPTOSSl914Z5vfMeEBP3LkSFWG6DkFVozQd4zsjdDu YQjxKkd2kfb5Cw8ffwT5VeBMbBra0nkjj+J8eAQEoby4CN7uVpR5+CPvdBzKO/VBt0Av5KfEISXf isBuVfdn8rQllPDmsE2X3ujiS46Bi6y0SCKHwUHt4VGQgaTUc6hw80XnXuHwKy+hHHfkpSSgPLQ3 OvuVo7TcA95uVMbTDaUWen837wxScyoREtaD5LaCVknwJJ15l2Ug7mwl+kR0hZc1n7ztp8DqH4r+ PTooF+M5ySeRRo6KGwJ6+etTzqhvY/mG5ht5GukZ8433Rn7GfGf3jeVnLG+Ux1m+UT4jvjHfeG/k Z8x3du+I30cffeTMSfWDRJc/ESqOqo1Oqnmg8QBhZ898OXVSTTh1A1eUgUOemfCeCR/6YwMi6YLD ldIDp0uePr22eN24pchIjkeGhyd8aH+CobI8A2es2sDLi42BJxm9SssZlJPIbp7e8Ki0wMo3p2Pp o5BVkGu4lxzhn58aj3x3Mg5exIeKl59NAz1c0oCe3KTGH4cHHTWgBRkt/yiD8PNILg964mNledw8 4c2PkynOxTKS45Tc9LQYFWRwlUyUHhutexO3gD4WH81zoQsDkV3C+lAx4urvJV5byPQlzxEvyZPQ EY4xrSG4tZVtCA0jrv5e4rWFzF/yjLLo8+rCMZZrCG5tZRtDw0jT0X2j9lBYOBGQXRdkZWWp2Ye4 K9DnO2IuZTnPaEE5T9Lqk2+nb7XQS23arMKeZotYdB/uAr2bYrHx4GwjP2NZkVVCNyrLfMRIGstb DZ/ZqCRc+5YZGbJS+43GyY0+K1lKxqc2eqKL2vKN8jq7byg9qbeEXF72AZiXsf7O+BvzncnjLN9I z9l9Q+lJvSVsDfV3pqMLyW+UQZH3UPjzFmfOnEFMTIyanbC/E7786S1SfjrDL6rxx8WN3x6RxmHB pXPK/oujBmM8fRl9nPMaAlJWQi6rjzuj5UxeZ+WN+c7oiWwScnl93EjP2b2UlbCh9JzJ64y/Md8Z PZFTwobKa+QndCRsKD1n8hr5Obt3Rk/klLCh8hr56+kY8xpz3yiDwkrgiw3JsWPH1NMdNhryqJcF 4+/nHDlyhN4kTceoUaPUnosIzGX1YKyk8d6IK78y+vQLjQstDhmYt6Q5osl50gk4X+LGOjkqW1ua sb7Ge305Z/LpcesTl7qa9b88278+faQ+OI0yKNz5+ANQSUlJavbBMxI2KOyqgPdQuNOz0yW++Ktp /JIab8TKTIWXSCaYGjA10Ho00CiDwkuetLQ0ZSDYsRIbFDEm4lCJjQpfPFPhDdvERHr3Q32DFepx cOtRpVkTUwOXlgZWrVrlcoEbZVB474RfhZdHw7IZy7MTeUzM53F4GcB4bHDYmxtfDG99vNnlFTIJ mhowNdByGmi0QRFjIh7Z9DMUNip8L+t98S0rH41q3157ZZ2rLzgcasBrWY5ra9qquJZfc83PT4qY jq20LW7bEqlJX5CrEKoTUHyr+NdEN+6xVJfXiK9JVftfs/5169Nsf+mLruv/Z2rvjhec0yiDwoOA lz1iRIwzFDEostHHeHzxI2aG8nI6W6CMBpsNfmuDXr1XA5lzbZbBHurTOFfD5VBBdX3bN1SFd40B W3381+BfP/q6owJGeTSp7H+1+tGgsdWP6y1pjKTFzfqLfsz2b4b+b++dros0yqDwYGUDwUaFlzYS iuEQg8LpjMtLJA5lkKsnIvxTTlBJvkcoQwvrUz/BtZXXpia2aQnT04hWN0cyfeE8Ps3LZW2neiuV gaFhronDGFRWGpVvOF5FX+Xr6GmYuhKcx/RtOJIjob2uNvnN+pvtb+8T3LmcAfUb6TMK1dA/VX+k NK1fasSqZv90L6fZnfFpYH6jDAobETYObDD0xoTTxZiIwRG5xJjwfbl6bKyNYP7L1dfuJM6zFlGJ hqEGtSLGMxNOs81QVJr+jwHfMMBZDm4QkcfZjIQbmx0uqVCxMfKvzk+7q399Goqv1ZtLmfXXt3pV vHp7KMOu2lDrT2b7s35cD40yKCyOzD70MxSO6y/GYdAaUVsm8X0FvfZuX7Jwgg5qNLht8CurTHg1 lgg1+o9mLARfR1pFtfJVSxBlm5TRsWFyvxOanESvzSvbxiFBjSWUSq39j1HeGgbMUPRSqH9w5/bw yctBWpGmE0MV4OEfgO5tK5GcVqQWhFJnxpN4q21/d2/06OaL86fz1EGYi7H9je3livtGGxTu+Awc 6mcqEueQjQsvbyTOIUMFGwk1armDVd9TUDM4TrX1VebCbhE1bvy7rJXlUIG2ZiFCNgzClWXqnSJa AAAgAElEQVQM52sDlMrb5DWWHzD+SkwO084fMXU+2KedCALO7D2AH+P4HBQbFZFAZJPBxOkc1/K9 fLzhS+el8m3v2GsDh2dcmrxcb5GBCnFNKaVqRtbc9Veia4LwXw2kanxn1C9pJyKiI9zjC5BayKef q9efi3gFdUD/vpXISC2iQaXN6FpP/etuf3j6Y1DPTjiZnkd9gNv34qs/t5GrodEGhQXiQeroEqPC OByXt0jtg1rnf4THufarz9gcdzLDoAKC4wifeVSSERNeEudQAx4AWiPzfcKReHiTh7XSck8MG8Gn f4uwjzzml5ITptyz7AmOO1CVQZI4hxroBpRPCObd2g9eqXF4Z4N2oE/JY6sT40tdpXxL11/jz22p 1cZYP01+ff2hHIF7W9k3quixyqCqIUR7ZpU0Cy1mH6p0wrqScO3toXSp6YE5XlL19wjC9eO74MSO E0gsc9D+XCH6XpOlshxlpexDVhsj1fsr67Kl68+CuhYabVC4g/AlxkMfSp6E0kkZh4H3UGz9lwaY VjF7SLd8AK+qubRfb/4VZ5CBqELfUNx/Rx8UnDqPYHJodH73IWQNGILB7llYsiwOlp59MW9CKOK2 7seas0GE2xe5sRloE9EF7cmonD5wFMuOZiEqi2l7oMdwMigW8uV64iyKbfw8gzvjjuv7kKEhFEse 1v94GMcKK9F/1BBMHdBOm82UZuLjr08ibFw4zU4IuhLfScBHm9LtszGelTEwJ94Xc0n9FcXqv5ia HiWNESQuGtXSVFHOVQXYSEs+x8VQsKzcVm4IG9ALwzuzZwsNskh/XKZdty4Y26+d8n2Rk3Ia204W MEf6JfEn51gD0Ia+L2QtzMHO/anIcW+Ha0cFYOeOFNKvF0Zc1Ruep05h71kL2pL/G6HD3EsyUrD+ WC48A4MxIbIz2lDXUb8J9GWDTbvSUFTpjRGje6JbAGVYC7FvVxLOWrxwxZjeaE8GzT/QB+dPxmNH CnvQY5mlfhz3x3jyhpdFX0M4nu+OIaP7oXNhKtYRv8DuPTAmpABHC4JwZZg/I6MsLwub9p/DgNFd qJ5uGHzVAIScjMXeFDcMGRGOnu20GW7WyTjsyuCfK3d0G9obg9uRvqz0A0WypVnqan93hJN+hyj9 WpF4JAFHsmzuM4gf69Nh/1fSVW9fqau9Obl0jfqrgi79o41sl5KsP7EK+mUrp1HFF88AJOS48dI8 hGuexjle/WIHLh7oSsakNJOOAuSRTxN/2sfx1ZZaleRqgJ5BkTNrNyrnpnC7kzEpPX0e9H1DdB/Y GQHMn+lWkEpsineXtHJf3DydjAnOY9XaWJz3CsK1E7qhwjsU49mYFGXgm+8PYOux83RiuBxJ8edo yUQGM58+1nX0PNGkxY2qqxZKvSWUektorLvSDf/K2+Ux1p/lFvlFj5pueVbIF88iJOS4pj8Ja5bX dFGlb8U7MBTDOnni5P6TWLX/LEpJTzy4y90CMSqiLdIOHcfyfVnKKPSgbyGp1wLIb245GYXNUeko 92+HIV291bzQg1w/uNna34viNIEhOkEYHdEO+QmJ+GnTKWTQSsqHXTpQmwwf3gl+uRlYuy4GMefo aSH5emAZuwzsga4e2eSYKgZxJf4YMbCt0oUb0fRrU4kjB+IRRV60HNe/ELlWd3Tp6E1l/NGF7IZP uwBiWIluXQNgyS5CSW429mw7iuV7MuFFRq2btxXR0ZnkAqMCCUfjcSC1DB0HhCOc9opiDpBedsbj GAnObc6Gtq1/KXbuOY1cDz/06eip+oG0u4TS7p6hnTG4E7B30zFsS7IinG58SRZpdwm1tjP0gQto //qP1PpjNnqGUn9WNTHVnojtB4PfSGHry6Ej4Dw1ZaRQAQeMKj/xFD0fcxiLd2VTzAc38YhmdyXc IEKSGlg+T8G4S3fl4qa7JyCCljX8MS2WgHnY0SlN/Z7QsYJgNr3uAejf35O8wxIEt0Nw0WnlfSbA vyNumOSOndtiUMg/A6m5KENX+iJYJo7QcolB/bpQFocM2h4vcbQxa2z9jUs6pS/iZf9F47ieP9dV n2+bgWizEiUiCWsTziZvx47k37ckByfOl9Hu0HlkV3SiLxrS73A7f+WJq32v7pjgzr/SNGMlZpXu 1DgVudhxnL6TRLyOZ4diSLA/KtIIxdYWPOi4TdyJjjcNZi/ybHcyLl957UnNsSKUXGqy06q21FNP n8pU+k3OKMagECbhgZAgamSPNrhqpC/8yBa4W7VDm57E/9zxRMRnsd8f8hQW2gmT+pNzLZaXDJSH hwVH9yQgmQZ/j5BAtM33gWcZ+cfx9kNXIsQOsRLOFCKTzqCF9+mCccHsV4x81VBnKilgVxQVyDtH p+otnugeQobiXAqOZ5VSzUlFiiHJQvjHdiYjvcwDPakjedHyj+vqQ4ZDZPEgWdxtsljoo27caSOu 6Al3crQF8tbnZuuDzvr/hbQ/i+lqaFmDQr9QaiGpasWdV6wEJ0icQwLqCNqiUw1xW5zK8EKUGoo3 UPOzCpU1J2TqMFyoHCX0K+bFOASsdPqvwyWnR1oOyvjXkvGYjy2Nf0EqOE2SSspQWJCPmBP5NIPN pQF1Hku+OIyZUyIQ0TEE1918NYJ/2oaNuVUTPyvxZ2AJpIZaAvOyya8SJJdDBkOJuuqvFaC/Upaj JLS+PhLnUIHg2kKRhUMGhU9xHb6PHznWpkFXxkqkLDbUbLC9vPhtaCu5qjyPfPqSALmwwtkSmlHR WFbkeHZFJHkw0ZyH2oANN+UpnVs1OpTA+meDZlGDiOLqng0KvcfE+TT7K6e25ovL81NCYg0LtUly Wincz+ZQnLZ/SSbm5UYbyfxrzmDJzUNsIg11Ksfg7l6JHEsledTLQXlYewwNd0dmQhKKw8LRpz/N DMpykVTojfFT+6F9cQ656yxAcFBbNcC12Qe3EPUP8mNTRnTcyIBxfxF9cd2UjFRfa7kmv5otUrqF jp7EJpEsLBo1hyZLBYJpOlZpKUIK/SCVu5NzLVp2F3JdWGCH7UmVsbePQuI/GjjEr5LPrgjBd1HY ogaFp3pVo5U7OqvO1uGdKkRwKeQOzkBFtQ5Uilz+kmm7QIwe3gcDRnVQ2dwo3NkUuFHHpuWPdkeN Run868U/49XSWCb6cBj7TvOjT5XmJCTjIBmMvvRIsBxtcGVPN6xethPxU6/CDb19iSX9LuVr8njT yetOtHeQVmyTT+Ns+8tpUmdOkvgF1N9Gsa6gxoyFB5xtwKpy3DFF5yrBIB8p5Wx6ESoHtkMPrzRk tO+CTqSrDKKTR97+SwcEwt+tEHtP0VcV2WseDXZPapdKN2+0p+9K55cFok87N2QezaPlQBB5r/ND Z383+HTrodEh/RdlkkGo7IEhA4LhVuCPK4Jp3yWDDH1RPrJpK6HngM44G1uKoYPb0MCjQVdRhmTa Y+gU6omsxNM0Z6K5qTfpn1xtqsFcwUs5TfcVhfk4mUB1Vnqmqkr9S7PJ73AoQvysiKIvDxT7WdCD /A/nJ9KnUciFaDuq48kDiTju0w2DSQfsUU/ZATJWZK4U/aTMUoSRUermcw7JNBsJ9qvEedqsVbMv qhf3LZaH79XSlD5Cd/IUe1bkttZ6G8eLUsk3ckgQKs6fwvFc0p8PDU82ojTXCe7UBtbsPORZSGdB bWjvrwRnaWkPDy906+COdJq1aXMx1Xg1/jhq/xpILkhoUYPCChaFag2sKZ3rpfVv7vS2Wiq9c6vY 7lVgu6GAG5nvFEm6izmVjRGR7XHlqDBkZBShTUd/5X5RNagNj+OqEaiwanwqLCaGCXKaxiEXX6+O x/1T+2D8jHEYz7wtGUhIzMCVY4fgmrGcwJt2Z7Ethp4I4Rxiabo+rEMP3HePP9794JAySBqW/LXJ buPQqPoLyTpCtalKypRNYYWqKUtFVddW9dcTERk1XRSkpSO9V2+MmDRM6Ulph55kVNKg3HosEJMH 98Ot5K2f3Yse2hyNVDcezL4YNXEYRlGsoiALW87Q1xrpoyJZZW4YdPUQUlopLXKIEk1nKkvPY/Ox AIwfTBuz9LnX8/R+SxD1UHKCgV17T2PyyG4YO6ICWbTkCiDj5E7yJh04ha4T+2LytOFKcCt9z3rZ vnzVH9hAShVrr38R+fUtR4h/HlLIY155Bv0ShXni9BnaVCbfxGeKuqD/1cPRjzz8FdPyZMi4Hji9 PpXSu2Hg+GFofyQG248m4UxwhKrnlSxtxhn8eJS1Q8aQBOC25ckLy8txDaqHnF6SehoHOkbginFD MYiQKq25WLUukZZ/7hg6ohcQHYNNyWUI698bV7in0PegshDQiXQ11B1rVpGbURtlR4HD+jtCbGQa 9yM2KmqHwBbne14I81Z+nU6qV69erT7g5evrq1wYcCinj+VcD78pK095ePbA53j4YifViXkdqWOK xSBudQI3gOr2Cqv6XVWOUON8Hz9f2scvQTb9aBottJ2UvQCVUFaMSzoCjXdAoB85jrYgp5hNEae5 I4AcXHvRE4WqNC5fSenkHr+Epq3061pTXjZdVb+YXKJuqE6h+p3j+msSa1RdVX/m5OtH3aOYfNzY lcg8mBt/uMwdpcW0F6FqTJutNLSt9Jc/aFZIOhPtuilcD0rTnmJoUtIvcbAP8s7zr60Xxk4ZjE45 iVgelYMA2ntBbhEKaeYTPnwwxnTKxw9rkukpkQZ+fuQjmJYfhWXajKSmfgz6FuVwyMADvZb29/X2 REkZ/2RR/bwrbTwqlR6sqq5MwKYX6uMlSobqElS/Y2yDPExCwNsLAeRzmPVVBdUpVL/TtC9pXEbi HDLU4Ef1zk1Ye/E5qdbEvbC/vP6mmirQfqFJyWLBDQ2uKUR7dMkFeDByYS3kFIlLDyFvcUUl2rdt 7PhSjvuPNpiFn6JPv2gcMshgF/qaOJUoyNO6sJbPePTyGk09qxpMFVd/BFfRs3VY4cdsVNwmrpKH OrQ+31ZFRetC6i+dSfFXxLR6iTxanTUsLe68/ixucRHPMlh/VfS0uAUFRbYKMRMyJpq5IB3RI/bq S6xyStPOdjGmVn8vDLiiPy0dKIHIVBTlYPPB82qPpVN4T4zsQl9WYOSKUhzdTY+cSXRpnyqZqvi7 qv5FpbQ5Sv/IrTgKSjX6zLe4yGLnz6lFNKNhvCqokkBr6+rtq6Vp2Fr9bfklpbQXRelc3EZO41+9 far6PNNg+XQFbMU5h0H0ZA9lnGnZLvvbokse3qSqAtYc32sa5IprStQaRTojhwzVGsBWSq9OiWul VZFqf2o2kNZYti0wG299Axry1eCnNLs8WrzaUxIdR5ZaZNIl66Jm/clUYcua/UonxvY/ue8ITvCP gF3f1Q2UUb+ia7P9dV1MF61u+HQZjYy2qEHRNmW1GvBA1IyGZmQkLh3IvmHIG4cM3LE4butgWmJd f41dzNAFbTMIslQaEUWf4tXoV3VPp/LWJYqDPKf0pK5m/XXtY7Z/9f7poGPZkxz1f3umyyItalB4 ySNTMLaYauNIN0Phn3TJVzWWwU43xufuRo3I7EYssfaLp6cnxkELlQGjGZMYsPrQ18srcQ4dgWN5 ZJrK8zKz/qJD1p9qd7P9m6H/O+qtF57WogaF39GQAVy13NEGpHHCYKyiMgA0eKvKs2GQWQdjS5xD ATEi1GGJgUZDZ1BsaYLN3doORoGczmCq07fTsUVqys/1ZlnN+rOKjOrmND3U1J/Z/lV9njXlvP/r 9emqeIsalFf+dLOr6mHSMTVgaqCBGvjzn7c1sIRz9BY1KJn8xVQTTA2YGmg1Gqh6R7zVVMmsiKkB UwMtpQHToLSU5k2+pgZaoQZMg9IKG9WskqmBltJAqzIoBWlJoCM0Fz9Ys3EmjQ+HmXBZaaCcvpx5 PIl88LReaD0GJe0H9O73dweH8C7CxvPMw3v9grD69KVg/S5C/V2qIllS8Nzzv8UZ8lxQcuo7zL3z BzoP1XjIOvoj/k5PTOfe+TLiXUGwESK1EoOSjf/dOhMvb/1/6Nmiz63q2xLheHbXQswd9K9LwwDW t1omXt0acPfEQAxVPni8ul6DV/87RXMVWncpp7keAX1w24N/QHc6xd3S0CoMivX0ejx79GncdAV5 FCMfat89MQt//MczuCbQDR0Dp+C7g5lKz7FL5uOWJ57B/ZR+zZtRQMER/HMG4/D1a2w9bTPv1lR8 99QULX3ccHQcNx8x/Ii75AiemzELL78wS9HdnxOvKz8LG2zlmc/9T71GuBrtj3dEET2iQ3zuf3Mr HSekQ/2D78YC+rfhVAv/pCjNmH+aWwPl5w7gy+/2qxlKScp6/P31T7H682dplnEz/v5tlO1QJXm7 +1hLm/vX78jzm2Mp2/cahP4RYeSdp+WhVRiUknOpwMR+aGfTZ37ccnzyMvBOQgZ+eC0Ij0x4F1mU Zy1LwPaPXsHMrYlY9lA/fPerYfjxuvU4lW/B5k/9cdugF8nbGBD7xWN4ZPMNiMq04PBbjwFHD9ls vwXJW5ZjYckcRCV8i+G+frjm5URkUPkfnl2Ou749pCRgPiv/swAjXiNfqp8+iT9NG4kDkYtweP9n WPnc+4hVNiQQvW4kb5G208s20c3gMtFARWkhotaRkyiub7kFMXu/RnTIfXjr7f9DzJeLkUx9JHXT v/FO3gws/up7/KnnYixcH1+7dhSh2rObK6dVGJS0o3tx9Y0j7dPHMnLd9fKu5zEwJBRj5z5Nzmo2 IolmGJbSPAx6aT9uvSIc7TxPYvlPwB9um0iWnaaiN/4SV2MF0gtKcHzTcty+YDbCfD3RecRVlF4F eZiMdS/cjrCQ9vD07UpOhfPw45IP8c1y4GofdiOj40OOgnpF9KKUhVhwZyQ69xhAtFJQpLZOfDHw upnYG8UmzITLTgO2pbnmgpSdPPwKj17XH+3bd6BlEc+0y3Amdjc5SqZvQn37NbavIJ+6Wse5qFXV KgxKlyFDsX3LkWobXKW2D7LXpX32cEW+cwxgQWEafWCBnNxoYAG7vdaDxbaXmrXjNfToNweF3a/A VZP0GFXx2rddrYjbsRzDhoZVIZsxUwN2DZSjgCbeA4eMwBWRI3D9y6/j75O62XMv1kirMCieQR2B n+LtBsU7GEhMTFE6T1z3EaKHzEZ/4wLTNwKzhgDLt8YpvKw9K7EdYxHkG4jht03GJ7P/jf2njuO7 P4xENGGIedE3ZObxVcBv3sBdk0YigPwuZfPHBesN+Uj6Eghhd+4mmBqooQE/DJg0BjG7ziG4V3/0 ieiPzkHk9q42UL9y5DydDty2JLQKg+LbewZtbz6P5ce0DU6fIOCTuQPVJujoubvw4cf3qA0rNgrt 2RuYgkDM/mo9Ch/U8AZN+wxvbf0bImh8D7zvS7z7h2hMHz4bB3q9qLA1z2McDbIbl+5jHgL+cy3x 8cJyzEH0cyPxxbF8lV/Fh4oMsTNVtFgO66nleJH+TevH01sTLh8N+NEC2wY9dD9T4VVxMRtdr3kc v+q3Fr+hjVrerH19faKUrBaeXvsvzJ33J8QgEX+bdwtWJ7TcITk+48z1Y8PCF8f54trxKGhSn7LT Zs0hFq4BK72H0rXfLkTlP42V48iifHAev+pDvkA9A0FbIXWAlb6zQtOLNoRnw7IWZNLj3PYIaeOJ gpNL0XskzV6yP1XGpgYhawnNjHwVjxLaf/Fs41vVYWogS0IqXg7shmHRFtzUvU7hpIAZXsYasJBf 4nL6+LovfdzMlfD6i39uXT5lXakczy4341T0YPreLhDYcxj5kqWBSssXMRK18/KELxkTPViTVmDQ 2Hm2pGF4ffVKx8aEMTzJmNgwfcmY1Ausfrg3Og89TWNSL3Vd7khe9DSxav5ycWujVf08tuneRy1t 7vpce3x7oar3HfwAPQp+4EKLOy/n2Z6MiXM0E8PUwKWmgVaxh3KpKd2U19RAa9WAaVBaa8ua9TI1 0AIaMA1KCyjdZGlqoLVqoEX3UI7s2dBa9WrWy9TAZamBFjUoo0ePviyVblba1MDFoIFVq+jFTBdD ixqUvLzaP+8sn7jg0BEYP4PhCKchaUZ+rqbfEFkY1yiPsbyr5TPyczV9o/zO7o3yGPFdLZ+Rn6vp G+V3dm+Ux4jf0vIZ5ZH7FjUo/ClSVpwjkLzqnyutwuRyglOVWv+YsUEcNSDjXCgY6RvpOOKnx5G6 mfXXvlOk1w3HzfZvfP836tQV9y1qULgCdQ3a+uTVheNMQfqyEpfQWVmU5+HQ7v3I9QzD2NER6pVi Y5m6aEmehMayfF+fvLpwHNHUp+nLSlxCPV5VvAzZmefppUF/hIYGKUdBVXk1Y3XRkjwJa5a+GOvv SMra0+pTt/rgOOIg5SR0hNMSaS1qUFgZjhQiv86cx79EDBIXfA8PD1taPta+8z4OFYbizt/djx50 WKAseSve+mo32g2fhYeu60uly7H/qzewMW8MfvPgePVmq7MZgmJa15+yLOzcvg/5Pm4YOaovPG2y inzGoopfaRI+f/tr0CHSahAw/FY8MrVXtTSjfMb6G/OrFXZw09jyimRJMj5Y/D1FB+KxP84gs1IF RvpVOVrMKG9j8Y30jPyM90Z+DS1vpGe8N9I35hv5NRbfSM/Iz3hv5MflmwJa1KCI4eCKSYXL6bTk V199hcLC6q589Qps164dbr31Vtu0Nwh9evng0NFMJJ0tQliYLzJTkpWuck6dQX5FbwSUZyKekkKv G4oAyuHzmMJbv6QoT9+L/362FQGRd+CX1zh5ldXDl44Jkn84H19409KNF0dch9pA5bl5kpcLDSKn zULvQE9YrVb4BHex119oGEOuv8jMFCSul99G2mHQ2PKKqF8vPDr3bhT4tocf1dm4GBGZHQkgeRIa 5eF0aWMuL3gSGvFbpP6OKqZLE1l1Sfao5ElorA+nN3f97cK5MNKiBoXrIQqWuLu7O8aMGYMNG6o/ UhY8DseNG6dUoHUqd4QN6Ede1Y4gOekcrurWCamn0lQ+8hNwvmwiAnKSwSbmuj5tUXLuKL7/egNO F2rnh9t2icSM2yahM9LwPRkTTs05thxvn+iEWfPuQJhXJdKjt2HNtoPIspXpPeEuzLzC9gpPYCUS jm3Cz6vZbV8AIn9xKyb1D9H46/5qncVNnbgEaJlELg86W7VOVFFWiJPbvsOyPSnw6xSJO2eNgk/u cXzxyVp4Xnkrbh9J3hk+/QnnOwzDyG7nsHrrSaIcgGFTZ2LqsM40JUul/B8pfzjlZ6n8yFsew6Se njizbx1+3hqtPK0HhAzCjXdMQ1c+ckRLtqh1a7A3+rTNC3sAxs2+D+O6+aEs6wTWrN2Gk2m5qgZe XcbhV3ePg09xJnZsWo30oCtx6/WD4UtGrizzONas3IyTWfwD4IUug8Zi2tQr0Z7OsVlS9+HT76LQ 4Ypx6FZ4EFujs+AV0Bs33n0TegURAsuwdg32RCfbZbjqrvsxlgRs6AAz4svg5JDBkQGSPsX5Rnxn 9Iz5TKMucESf8fUyGONSRo8nOJwndZJ8Pb7EOWQQXA6bEmyjoilZ1E6bZyNcQeMVHh6Orl27KmVL HiuS43379kWnTp1UXEsrh1+X/mqgpsWdRVllFn2iQnieQyo5KclISaSEMPQmnyiWwjwUt4vE3fPm YUZkKHLTovDDlgRUeHfAoP5tVUGfoF4YM3o4DYoKZB5ehqWr95IxcUfklBmYEtkbft7uVR0hZRuW kzFpF8Zl2a3fURSQrCyb/uK68r0GZ7Bt9Vbs3LYNW3ceQVZ+CXpMvAG9aFaWdWorVu2PxZ61PyPN 0g7TJvdGBU2pzudy3k4yFkk0C9N4HV63FPvPWUgXkr9DGRMfn7ZoG+CGzKjv8TUZE2vvCbh9RiQK s6Lx5Td7SUeVyI3bjU1sTELH0tH3uZhAjp7a+rgTLQuOrV+hjEn/Kbdj3t3TMKBTB7ix/BVlSDl9 HmdPF6CCaJTnxWDRpz8rYxI543ZM6e+HtOitWLx0J4opv8KzArmWQpzauw5b42mG2NaH9H8Ka/cl qfbLjt2JjWxMdDIEeWsDRdpdQq2taSZIdPXxC80XOhIyHaGrj0u+tB+H+rjkOwv1ZTjOPCSUOtQV imzCRy+jPl7ffMZrCmhRgyKVdxTyLIT3SQQYx8fHB5GRkaox9Mov9u2Iwexs4dwZJCSkIR5tMWPW WFX0bOppnIlLJnsyAm3KrfDrdyOe+f1N6BYYiB4DByscP3/6RSz3x9jrtPdiggZPxi+mjkZ7t2Ic 352gcMbOexZ3XjsW1975GO6/pqda4qgM4jVr/mt4ev4cMlkEZck4V1TVOavVTSug/h7evAYr16zB mp9jUEJ1K8r1x+2/nabyTm3+EdtJ5Mi7H0Ln0iI60exun9nMe+FVzJ//Au4eqhm/U4mZqKBW5OpD yfIKXn31BVwbDpw4clqljpo0GoOGX41ILpIZhxSSr6JM8x2D0lzylxuMX8x9iGZ3PjSoLCi1fTIo P6cIHt2uwty7aMZEMla422ZYZHh4z+j04Sg1s2g79le4c+xQXPvQo+TTnSDrGM4UcIe1rdPJYDz1 6jP48wNXcS78fLUZSGWZzSMVueYstsug5TEe606A25tB3+76OOPyfTV9U5rcS56+jD5uLG/EN+YL XQkbii/lagu5rpwnwPQZ9DLr44wrMjiiKXn6MkLblWGLLnn0CuO4TNO4ggEBARgyZAgOHDig6st5 I0aMgJ+fuJ/RqaG0DSL6+SDqSDy2rKdB5DMCERH9EIpdiN++CvG0cdH7pq70i1CJ7IPf4d0V+2t8 cKCiogRp52nwMtCHuNLO8oFxd7RhdgWh6NcuFylny5SMjFJZYWvs0NFkzFKQeOKczci4K7eSUrdq ob2DtMW8F/6CK2gTppwkSUnMQFlFIfICr8Lt/TfhmxM80PpjSj8Lcs9TRyK5FYQOQIeCU0g6Ty4q O7ILulzk5tEirdJ2uF3JkoH4eCvJWYkAmz3etuif2KZRoL9F8PSoRMdRNyBy778RlfojLB8AACAA SURBVBuDbxfRRYu+KXfdjMGhAZh4zwzsf3cFUqN+xgd0+YeNwW0zx6BdVf9GOXVwPy+t+5Tk0kww 008NgI6hxCIzH6czC9DD5iUvdPBQVMQnII5mUwKsl45XTiMZ4kiGaHyziC6SYfLsmzCkY003ENz+ PBhkCi90JJQ8DhmkLwl+tXZwkG8szzSkDMeN9Iz4nC9p+rJCwxjqcSQuPPjeCEb6xnzhzSGD0OKQ wchf0lWmC/9ctDMUVgAblECaSTAEBwejX79+tVjoIoT002YbBQVkPfqFw9PaHrRXSzMGuicYRL3b WlGEI5vZmLTF3U/9Cwtfe5SMDoGn7YlRuab80jytDMtgUT+imTiaqO0ncIPxVTW2ipBVQMsBerpk ByqncGyhPW4vRLLkJCI2IYFcVZIxITzmVRK/Hj8oY8KUTuDH7WdVur1YaTGKSzT+WRnaNKJHr460 /BDOJEshOYQhYJ6a7MCEX72AhQv/hX/9i66Ff0V/H5oRFQfgzhcW4v/mz8PYMFbUWWzYcoL40Qwl eAxeXfgKfjt3mtJP0ZndiEq0TVsUda2DVrppM4ygdv6anJUlKFBJPujTNYDSbMjFeSiiG027WhrX t6ikTQ0ZNtL+EOcZL7sObfrne/3FVPleQOKCw/Q4LnQlXls+02FcAcZjqA1f6ErojL7g1Tc00hM5 JBTZlJA2OSVNX1b4cVpTQIsbFF5H6teX+grLBi1XnJdAksehXkkc9+3cyzbtp9/23u1RXOaGnjRr 0WAouvmVUnmabqsalyBh/wp8/Nan4C/2ZMYcom+eVMK7XYiikXd4B/adSEaB1QcDxqiFDKK+X4bd JxKQEL0Pu6MzlSzacCICLA+Vl3uLreOKjHq5NZwUbKFNzz3bt2Pbtk3YvjeWjEo2Vn+/BWU+kZh7 9wQl9ol1q5HAyxOyGKpr523H8h3k6C9mI1Ye4beMfTC4u5/KF950Y9MN5Y3vrehs/fjf+OyHddi4 7gd8+NZixBRV4uy+Zfjfp98jLoe87w/pqfB82renqhRj77cfY+kPu1AaFI7BytiQ68x23mrfROOj DfiuIyaqcpk7V2B3Qgrid6zCbiXWFejuT3LoBqToQBWgdG7zdCXDdw5kqNm++jbXx1nHji49jvDW h9I2UtaIb8wXPAmd4Rvz9bw5ru/z+rjgGfkb6RnzRS4JjfhCV0LGawq4qJY8XEGusADHeXN2ypQp aobiKF9wi306q32UqFIfRHT1JjplaEczGhw5Ap+h/RBAA7OEnowMGN8f238+gV1r16PD4DHon78b J+jJT3TKSIT2D8dU2phdcSIdO9esRIcHH8LgiQ/j7pLF+HzrKexZQ9/dIAge0xWjKn3tBkw1Eu33 8Fwqi15x83XnAadQq/+p9LCXSToWhSTJJVeTXcoPqaXZtMdvRHiwD+ZGHsenUZlYu+EYHrqBnuQo oKdUx9bjJ5v1GHv3bxHhXoTz9IqZmE4li8K1oN2YX2JeyadYtOEE9qz/2UajB4ZeVwkvv3LEkzGL j9qkpbftj7t/0Q+VhTnwyovHNvoGzJ71WlZY5CxcTYYlP7c6n2Lvofi/eYV4e9Fq7PnpO4XsExqJ Xz52I9wz06pmcbQi0+SydTfbCs1XybCZZNhskEHzicplBCQuIac7iuvTpGxtoR5X4hI6KqPPk7iE jvCdpenLSlxCLuso7ihNj6vPd8a/KfJ5FsqtzL/bfHGcL25y7qM8kecFLb/DxBe/xsEr40AS/MPV q1fDlzbY+OI9Dw55j4M3T729veHl5QVPT0+1nuM1G1tiC33egq+ffvoJI0eOVHlEzymwomRd6BjZ D+EDesKf9g7OJ8Uivagc/qE9ER5Ca/viLJxMylK/mG279EYn6sil5R7wdrOi3NMNpRbabMhLQWqO Gzr3CodfeQntbbgjLzUR2ZQX2j0cIV5W5NFA9uS6lWUgNo2eOPXrBi9rHmJjU4hOW/SO6EoKsyA1 Nh65tkfC1RrYI0grY6xARQHO5nmjM80CclPjkJZnRYcefRHq76lkP5FwAsvf+wqpodfh78/eCLd8 mgaQJ+7KfHocnkmPa4WuTRZt0cNMPBDcLRydqNXyCstJdg/404t4qbGnUB7SC91pD6eotFzh0b40 MpKTcb6EdNCnLwJpeVhaSpR8AuBVnovTyRkodQ+01Tmf6nwG5dSmvu27oEcnX5SQvpmfn3c5PQU6 jRxamnm1DUPfroGw5qUiNiUXnkFdEdGtrbqPS82jfaBe6EEbxTVlYFrVwXn7V8c33knfqe/egZGf sXxD810tj5Ges3uj/Iz/0UcftS6fstwofNUX6sYtoqVAdDVShRkJiM6oloScVBrsHp7wIMNjtVLH pZfNvGmT0kJxliQ1/jg82AjSndXK08IKGmhxyPT0ghfPPGiqaKVNUpYlLiavSn5LDuKic6oxqyGv NRex0dpeTDVE28351KrUzMSTajmmUugTCeo3Oy8XJ6iObchYo/wMyWHDr5WulR58xeOcGxlPL9o0 JLntn1lIi0f0WQ/aPuLfFJsubORSY6PhxjryoN8Y+qod11d1SOLDdWbgunHJonMpOH6O6JBhNtIp yzkNvUosuSmIpkug4CzJkO5YBsHRhzX0qc90EpeyEjpBV9lGXP29xGsLmYDkOeIleRI6wjGmNQS3 trKNoWGk6ejeNgd1lNX0afrKGS0o50kaSyJxDhmM+Sqxnn8qrRZUEh1Fg740XEY/xHp6VgcfCau0 lNn3SJgNy8HrUFfII/REBr6XOIfw64lH/jQfFloylebTt1doo7laPheoCyqtNNuojqD0WWGFtdKx PllHlG0HJQfdSVi9/jzzrN5e9oLOIiSbhey2ksfW5lzEWD9n+c7YGPMbSk/qLWH1+teU18jP2b0z eZzlO6NvzGd6TQEXjUGRwSmbRY4ajBUgDWqMN1Q5QkfChtJzJm9D5amTXlkRyrwDaEFRqh7Xynaa XvaG8pOyEl7U9SfhRE4JGyqvUT9CR8KG0quzvYzM6nHvjJ7IKWFD5TWKoKdjzGvMfYsaFFaiHoyV NN4bccVq69MvNC60xHIzb0lzRJPzpBNwvsSNdXJUtrY0Y32r7mnJk199qeRMvtp41JYudb04619T arP+dffPmhprnpQWNShZWVnNU0uTi6kBUwPNooEWNSj8ONgEUwOmBlpGA03hApIfFZtgasDUgKkB l2jANCguUaNJxNSAqQHWQIsuecwmMDVgauDCNMCb0hk/LkfGl0vhRj6E1KY6OesKvetedLxppv11 hgujfuGlWuUMpYBOtsYn247nX7huLqhkCb0nks3vilxQaRcXyk/C7t3xF4csLq7a5U7u/NYtyP33 m+iWm4MuhQXoTFdXevEx5+03cI7yWgouWoNy8OBB9ar+hSgm/bsf8c0nZ2oULY5ajVc7rCPfGxcA JVGYS4+K+ZdAu4bjmfe20vkgG5TE4625bvALCkIwXV5us/DD8WxbZj4WU57brPcgKZxxZPGvidZc 7NxPvzJuz9h9zR55bxbc5n5jo23FN3OH462oNCwk3q9F6SnYyNcS5Md+grFjv0X1c8K1IJvJl4wG Un/4Hqm/fxxdhw6H+xWR9LoyHb8gg8LxbsOuQBrlpf60vEXqc9EalG+//Ravv/46nRmJVe941Kkd azL+HfIO4mV0+/rRORI+hlQdvPuNxr0HxsKBR5XqiLXcpWAY1qcUw5J3HjHrH8Mrj0zErxYfIewS LL2rL55IWYgUemOUXQDsXxSImQPnIcomUym/cb78v9idKnOXTCyb9z4l5sOndyRm4hXsU6/e52P/ SuoMS7YjhVGtcVi+pBfGDwrFHaSLBwa1p8T6gZd/R0L0Nde19VPXJYN19N8LEVJWjILcXHjfez+K u/VQF8c5jfOOvP1mi9TnojUorA12VP3JJ5/gzTffRFJSUi0KKsOu364gz2EWfBP2FtbRCPaks42W vUfw9a1v4dWQt7Dsx3RVtvzMMfz0yhFthkKeyz6P1PJfvXWbllZyhGYhM7FLO+zqgF8HBATSAA1s jwFTfo2YRXOwZN7nSMrchHvJBixf8jt0VbtSnoh84FU8jeV476d4jQ4dxAMO47NNceq+JH4tntdy aCerJ2ZNBjYeZmcKKVivflw2IJYnI0m7sGTydET4lmDT63/AukQWLh9Lfz0Lz7z1GmapGRPNhuJt 85DsI5g/XJtF+Q18BJgs55Cz8cNLNPNR+DTj2ZAEa+oqzJrymjYzssbjmeHDsfiIRmf3a3Px1u76 z4akKmbY9Bqw0KFbq38bFO/YiDPPP4MOf9YujnMa55XTebSWgIvaoIhCsrOz8cEHH+Cdd95BZiYP Oj14I/K5iWRCvHDttgcwcRgdm+Ux9HM82i+4B/cu6oYT8w6qw3XlRSXI/apQeb1P+n4jkoeMw/ys 3+CRf4/QvqvjG4bfrPwjehOJ+kDfCdMJbRdOxbOxexiDeUJgh66Y/iLlnuKX9+gsDeUv+uxpLHl1 jVqCRH/7FR5+dxHmUK6FZhFj75uJN7ccR0lSFFLmLMSrMw9j76lsxO9eRl7MrlKuETJ3/oAzRZrX s7LY5XjliR34Q0oKlj+5HDO/5YORVqx6ahg23LsFxZY8bFk4k9xiaod44pf+DjO/uQqJxRacP/wc nri2J35GL3TauAD7WKVxW/HK4cNYtoOnUpn4YsFh9CO/MiZcfBooJv845bQpW0qhetecNmVBF8c5 jfNKDG+hN1ctLgmDIspgwxIXp/3CSxqH3sH+ZBA80b5nkHK/aC21wGvBTZg6JgQde7YjDDo5y4he /IcP2QMdhvcmo7MTX7wehdJAPifD0B5jb5iAjvU07rwi0YAHrX+NpYW3zzBBIP8BRRh49UzMPPwE 9tKJ528WAHNuGEbGRTu923MsGacVO7Fj+15ETL8e06fPxMbdu7F1ZQJmT4qoomOLlZ4DXt3/KSaQ v5hevSbTYowqZ03CalpFLZg9Dr6egRg1eQpPigjyse7VJZjz3G0I9yU9Db0R75Joh04HY8bDxHZ/ Enmy24nJD89EwsooZKZuxpvDHsTVyp1dDdZmQgtroKSkBNbiIrhdPRlhf/sHTjz1R3VxnNM4r7is yt1mc4pbz6HTnCLV5MW+Va6++mrltc2hT1lbETppr3lv0ZGQE/66JBVtM+ZaPLIxFGv+sgmLXj2F e8/MBn3Sp0GQfmwz4U/GgB49KXwC8dlvINw+CLOxmX7lh33W1kYzH16dhuOXNICvnXMrWZPn8GI3 L5s5IbF7XoU5h4fh2nuBRXGvIyJ3CjaOnI6NeJKWVixY9XWYNu/QTJq965B7gUNkWm4iPyoKvHiq pmHy3xDlIFfL4r8+ZAKvvOVpzHz3PfiTwfvrkpewpNtzWDSIxJv/DzUrqsI2YxeLBkb/9kmc+POT GEiGJenVl1FxeJ8SLZHi/nSsPLqoFGMef7JFxL2oZyjiAvL3v/+98tpWqzGxlNMHtOgoftWUoUqZ 9tFWlcSx4lTyrTZ0GO5Y+gv6bT8P9vXMm6up5CG/+tDldIFzKONfBys15O7F6DnzfTy5/D506ToZ i2h1ce3vF9uf4hz55kUsIGPz+E0DpLBa2kyY/SJvluDpeZNoOOuE8+2Ja4kGaHt2ZDdP+PYaQqUJ Hr4afetr9n17YRZNSd5awRvF+Vjz3iPAMDYqgRj/4GS8+dkmtdxC5l58STOXMHI+1XXkVAxb/gre xHiM6zoU181ZjgWvLMcd1/dl7iZchBrod+vtGPDuhzi4dxfc9u2ET/tQ+lhcCDwozmkD3/kQfW+h H60WgPp21WYXjT+XMXnyZPBXAp1CYBhG32HBjxFvIXXjw+AFgrfMNrxoMdNDN0/poVU5gzzGffFM niLtdd849GD/jSXRuCFiJP6TX4kJbWpy7UaDdWJHP1vGZLy7Pg6/nhKu7h/4NAYZcwci2G2eLX8m vo75FmOYrg14Ftp+4oNY/tlwDJ9IUxnraZWjrcQCMZKWOcibjp4su+8AZVCGzxhlX0qxadDWbfRJ ERXX6uJF3tu0Z8ztMXP9QtofGQYWYxivuDooREQ+tggLb++JILd7VcLDi/bjnj7MaCgeJLy9D7GB A0bMpCnU4T5kXC7arqFV6DL/2/va61HwwsvY+M6/4UZeBOnZIn1byh+TnnocvadObTHtuBFn7jk8 U+GL43xxH+c+600X97omcQE5Z84cIu06KMsvg0egt20/xDnd8pIy8CD3ozKugnza5ymhmVJgaHul OFfRbRAdmkHl08s2gfREygi8/uYmJW+dJlzmGvjzn//culxAuro9vRtoGDx8vemjU66VIpA8x+sm Ja4lXl9qnr5kTBwjs99fE0wNNJUGeDZigqkBUwOXmAbMszyXWIM5Ezc/9Qii7K/W14adj6hV32Dp 0h9wPNvRjnFt5epIN8/n1KGcyyfLPMvTyto6dskwjPz6ZJ21OvIePbFZEEWfFClA8o7X6C3VhXU8 QaqTlD3TPJ9jV8VlGzHP8rTCpvdvSy+T+WjPZ2qtXmkQnn7jT7j99nswZdIDiEm6T33UqFb8emSY 53PqoaRWjmKe5WnqBramY9lU27mckMU4kKx9mxh1nc2h08O/nrtYey+D/i6dOwXv8TkWKvPrKXSO 5a352rmXKS/ZDx1mH1mK4eosjBsGPrIRHWz7m9bMKPv5mVkvrVI0848sxrAn6PX4a4Pp5PBSZJ9Z gwUvr1QzlPzjizFl1jN465kpiscUKqOdIbQiaqmNL59Wdno+p6kVa9K/GDVgnuVp6laxemPQa/dg AZ3LuenJPKz5MlnjWNfZHPr2TvrhDLuvkKzDG5FLH9TikzXpG5fgiQ0DkJgRg6c3Po+lh7IpPQkv DrsX925JhKU4Ee+ql9CYTQmWzB6JrOfi6JRxIno9Px2LovIROPQ2rHx6Mp5eHoO8/94Kv6Jc/PB+ pvYqG33FfCO9TLYh/BWkxC3HxucX4BDbsuNLMPLeIsTRieWUlb0w89alZJxqP5/D3E24/DRwMZ/l aR1PeXzbo2fnZOxafBQnv6Pvpc7TTubI2Zzau1zVI1R+6UabJdC7ZfRK2a4vfk3nXkoQTi995dLK xpq0l94mfRhxE8LVizpXTZ+M/+ZSIWsKDm2kM8IRH+KlmGLCAV5Uhqk9OrYLgl+nTup9kALb6ogD 7bPqC/Hpr8cgkGZKk21vn6WfPES5sfjwlZdQfJIoHX6V3sq1nc9J5PM5ntr5nCcIzYTLVgP6szzd 6KQxn+Vh6Pv315Dy2t9h3bujxc7y8MtslzzkbluNN4atQEmPMPS+piHVERNiG+36ouqteIv9a4HF 51IpNwxBNhx7CTo/k0Bpk6+bjhnX34Vdu3bhvn61vASip+8gnpdGlCbfgOkzZuCux3dh1+HZCLSd z+lc7XyOg8Jm0mWjAXWWp6gYXrqzPHyeh8/ycNpx8yxP4/pCTjQtce6biGum9IIvvSFaJnaC5hx1 nc1JOPwZjtLj3KRVr+MROttSNV+pKU9gxBg6dvc8Vhyh5U/+cXwieyi+gzRfJmRvIseMwZgxI+lj 7Bc28YuYNIvO+awCukcSnTEYGdGJhKrtfE5NGc2Uy0MDF/NZnlYxQ+k4bijwyXpypvQfOm0bDMur P2LTEbIq6mxOOA44Ou0X2B0Pks+RicFe6PnuGTqSxyCGgFw42vqmj+0sDAKH442FczBvGG2yBg3E CsrXZiu+mPPlLgx/YqK2ievmhfejyehIeYlwOFQ7gaOS1KE9LVNmPb4D5pCnt+F0XkhzkOT1i4/J 8ZN2Pmf5PDqf4xaE5zZQGZFJK27+vQw1wGd5+vBZnrYdsDmoLTYFtsW6tiHo+8LfzbM8LukPVjqX Q0ePvMkm1P9MjxX5dOglsLb31B0IZi3Jp0EeCAfHZIgWuSjwC6S9DgcFG5JEPPItXtXP4tRxPqch pE1cUwOiAfMsj2jCUehJxsSWXv8zPZ4NMiZM3tOXjIkj/pTWEMNUCwktmXkY1191nM+pk5aZaWqg GTXQ2N/SZhTVZGVqwNSAaMA8yyOaaIrQWoj4bXU5RmoKprQ3a57naRrFmlSdasA8y+NURY1AKE7D N7OWIZleDmtOMM/zNKe2TV6iAfMsj2iiqULyyhZAX9vRjtbovLM1FT8bXfM8TxMr2CTvUAPmWR6H anFtohc9e9nz0hL16PjVqcsRn2kzLOZ5Htcq2qTW4howz/I0UxMkYzB+FTsbw+nczTfvxWlczfM8 zaR9k01zacA8y9MMmrbQkuf2v45AMD23mvRafxy6/gwK/q8/uQvQvrVTuwhVz2fN8zy1a8nMuXg0 UJ+zPEWlZXRYtVIJzV+LbC5oFW/K2pV1QU7R5D19eTfWTo0PHhOY53l0GjGjF4EGnJ3liSkswajH fkcHS60oLy9X3wYX49LU4rcig1KMtEQ2DuU49L8T8PpLb5szI/M8T1N3IpN+82qgrrM8B/bsRP// /A9h0+l7U/QNZJ7NlNLHvyro06TNYVRah0GhmQTPL7aPf19tym7eHY47H+iltbJ5nqd5e7vJrVk0 UNdZnh7XXIO8PO2bU23atEFBQUGzGRVeXPHbsmxY+OI4Xzw+eUuB32bnTYaL/rs85bTc8fAsR3G+ Bd703rp4RCHZnYB5nseJgszsS0gDPAvhWUlqaqr65s7gwYNx7NgxZGZmIiAgAD70UTD+IifvqzTF WZ7WMUOhBvdgM0hmxK9BxoTLXOB5nqq9XCZiBz7P0+jDgUyNz/MYD/So8zy1MLZLYEYudw2wUeH9 E4bo6GiwUQkNDUVhYWGTz1TUMLzcG8Csv6mBS00DbDQyflyOjC+Xws0246gkIxIy+x4ETr2+2n6J GBWZqXBdeabSFHsqrWaG0twdwjzH09waN/npNVDnWZ7t2/SoKi5GRT9TYYPiaqNiGpQaqq9fgnmO p356MrFcrwFnZ3nOPvV7ZGxcX4Ox0ajwI2VXGxXToNRQe/0SzHM89dOTieV6DTg7y9OhrBgnP/vY IWO9Uenevbvaa3GlUWk1BuXMj6vpkbH2bZ733me30QTmOR5ND+bfVqUBZ2d5yv3aoFx7SuGw3mJU 5s+fj+BgcplKn5RxlVFpFQalLH4XPpt3AiOX3YP5Zx7EHbd00RRpnuNx2KHMxEtbA/U5y1NKL7LV BWxUhgwZgnvuuQchISHqjVpX7Ke0CoOStv446W4wrh4fAm/fAASHyqNV7RxPx1qfZQme9tKNNID9 uzyhPdV3edgtgnyX5zb+Lo9vOPi7POf4xVz5Ls9a+i7PS/+/vS8BrKK6+v+F7MEECPu+I6AJFERQ RCXuUIu1Ii7gJ3+qWLWuVT/9ql+rrRaXKtRW0c9CFXHfcEGRRQUVRIIEyh72sCUsSYDs5P87d+a8 N2/ykveSPIjSucm8e+fec88959w5Z+4+z5jv8lgfDEsO+C6PnnptLfAvYUbruzzt2ncI+l2eJ16V 7/Lk+7/LM0a+y5NsfZeHJ/R77j9XAs69PB3+9BfzXR75No+Eo4YOR3nxEZSYb0P5ZdS3b19zI762 RlatWmXirrzySpSWWnt/6mtUqlU1Pyk//lBcsrBRl408IfbxJNRyH0/HOFzIb/O0qfd3ec5H3IUX 4qp72/C7PPt4kn86Lg34Lo8YJM/9p0rA7OW59w70cXyXR2Qh3+VJZNwqfpcnfeJ1PvGIEXnnnXfw q1/9yqxLmTp1qlmb8pe//AXdunVDs2bNTCulvsZECjwhWiithp5MVjZhxdrD9CuQnyu+OG8fjyUH 7/dEkkBNe3l+WLoYvSc/h84XXGhYFmMi60/27t2L2267zcRNmTIFZ511FlJSUtC8eXNzuLrs+5EV tPV19cdQXwoikD+60yBc8WQqvjzrJbOX5/mrl/K4JTpvH08EpOuh+DFKoKa9PF0zMszSeqFbjMnM mTOxZ88eTJw4EWJgZPxk+vTpGMkvVMpy/KSkJLORUJbj1/eogxNmL48Ir4LNvVI2uhIT9IMaEluT 8/bx1CQdL+2nJwHptsgYy65du0x35tNPP0XTpk0NI2I85FO5N954ozEsYlS++OIL00KJi4tDDL+d HR0d7bs4tjKBGeWkZvlUnjT7j9iXjBWU8pK+txzyIeMNch09IVooZMS46ISEWhgTyeLt47Ek5/2e SBKQrou0OqR10rVrV3Tu3Bnt2rVDfn4+brjhBl8r5bTTTovY7I7K74QYlFVmPN+TwH+KBKQlUt1e nhYjLzXjI9rqEF/ORJHpYZnZEUMjTlookRiIdcr8hGqhKGP7V27EjgPH6PT7rZmsiZnAwmwt7j/b 5+dXUcgWcF0m2aQlvXAhwA/Wh3SFW4G3KfdZS+pQFmlcwnoLo5iQdNQGoJzfuF64sjY5woatbi9P /rPP4AD38sjmPxl0lW6OGJTExEQzmyPTw9IN+uyzz7BgwQKTVt9xEyfRJ6BBKcY3wz/B9+t1StjJ ritczIdMztvU6wE+sDU5rrxFl4GEiAP27KwJ8vikTR/np114mEp+jpfL/tQqmw8tUhJ5gg7Lz6Ti 1sYVc0Xz2WcD60LlY/qoLsTPbvuh7cDj6bxqwWvhamAI682M1NeGwBCwmY9TBpOrBypaT/5Iayj2 qscQNCXkXp67f4s9sz/yjYWIwZDxETEwsty+T58+6N27t2/sRM9HCVpYLSNPQIPSCCf15+iItYIs DHGwwvfySct6C3jsWmBlTbUv408PA9dfAVwxLAzcxxikIIfkzOOwGOmXE7omDDjGBdroxbD2uIRl zwbbzNa1ZQ3QMWyhW4gSugJpaUC3ZpT7FConr+rcvuHAPdcD11D217/Ly1qoVR14QHyinA/G/JF2 vcYCW/3rPaqgjxV5sFwjlsg1j0Lt5WnBvTwr//aMb8ZGZ2+k1SIDtK1btzaX3Iuh8VooVWqO9fra O/Zenuex5AcZbrXPbKtpP4/B05xfOeeK2bRzLKxH7IrPZGtFWy6zpHtDQ3PDHVcdlwAAIABJREFU QPoPMb6fZXhy+ZbsF2XBPcI3tjhRtozLgAd4RWUwG/HNvNPGxbhs4hG3djpw2QOEI4yUo/klbZa8 +Wy8ptVRDQ6BbdKSzJJ+Huxkztpzl5/rpod51r7txz+OSmwac6RrotBt05rJ5rq0gCaTR7f75jXG 3AE8eLE/pXNvQFYob53lx30Z+XDinqJ8OeQw4WY2+NYC6bcTF68olmmLyId8OmGyFgCplMl08vPF 34G5W6zk6aT3AfKQYcvL1JUkkf47+1m0xPKlgRQLPuA3l/ko/2xDJLtErOd+E5mVvuKLIq1b7XQp ayLrTOpGWkg75gB/plEVN+sRP9/OugTpfpg8RdGqZDBvbv0NS6i9POVJ3MtDQ+F0YjSkJSIGRAyJ XHIfydaJlNfIWehPNrxzOV7/7X6MyLoRd2ZdhKaGkQqLnZr28xgIVvgKPqRTfs+7G/lANeODxQd8 IFsrG/nmz/mAze0bqBhU2D8xnP4wWzRfAH34gIwZSKXayDf0FtoZvrFNk5+tmAWEKxpLuHeYfwZw LWfbyiqB2V2By2moxJVxxu2Dx4DOvDYS/qH7LEXKZvoohr/aQhz7Cd+TBqAaHPFUkpeopI/zYX5g qq28rvKTXfeJ5K3PaGAe8ZcRfwsq8f2fCkXABtJBcrBlL/lsBpx1C5Wgg0kK+NmwGBg7NCDKdxNL HjcWUCY55I98rKBiixPct39DeTD+DobfYTdEjhG//SagKY3RPMpVWn97/0HjKBkc7qo/kJ7hwBrS dVUfKuUPVOaDFkDJZtJMHh7bwvLuoOwoc3Gz/huYfy1lSP6/mswI0lTF0RgP30eDv9RKWSZ1MwAc cACe3EIemPdh0vrGCitdynqBAlrGtN+kcxI1n/c0SuK6jmQRrOO9s/11aaXwl/Lez+dEhPv8t77Y ugbC2ctTXM1eHm2tqF9XGqrLF2jGqoP6kcfvXbYeGNEffdvJWbJd0b2TrVuG7lDf5SHQjXw4suiv KbJO0M1eZXH80hN8IIkbfOj4bLGdyJ8mfBM3s95mC3jb8yUrH4Pw7Z/gw/8Ym+Z8YeNbeRg38J5K v/4ZljNJIOlkCn8y33iDSWwmw80lkm/eN/nDeO4ZMq4mHIKiaxpwGuk/1NhqoZRLLkf5Mk7hvF/5 Cu9vpKGw8U98ngaGzD891LCJZVTqzsmChN2aIZYf7DcpLlgs0I70rJxPA/21lR5rg1GEWMay2xF3 V9JXrAl2ekvKVVxLu2zrzvpNaEXxpADtaQBEHsbZ5ZfQUExaBgwmPyu72mkUwscvAPdRieU8zjNY Ht6301zeNfeRTxrsB4cBz7L1OYkGL6Ed0IYvmek0tGzMYYJNq5Y1wJadk4W0vjRgBP76c2ZQOqQs lv3wL6y6eZJ1P3C5VZYk1dE59/K0v/cBs5dHUPV49HHkPP4oypd+g6JSeWCPv2t0/IuMfIlFW/hQ dUzSTk4tC2CFr6Dw+XLDf79u5c3fSX8U//nWuepWYDEfOL60rO/0WCAoz7cCF1wCcP8OVwwBzj08 Wp+7qNDDLwaXJQK3EiZrjI2gGk+6LlY/wQ9QLQ7yncHyM4j/F1QI5+tBy1csem9823iZNLFKCQpF 31gkx32QYNuefDMvCJLAqMcz2HqZy9bNuUHSw8AdJFdYNAXkK2J9MKINjVAo1/0CQtD4zJoJzGCd n0tjsvBxGq+xQKf+lG0oBJKey5YtH5APD/FZOIf3rBenqyvbThyOcKjv8qzlXp7Bt8oDffzdCWFQ Wg1lk2TqcmwtZINi7Qos2+bUrZr38xiRF1ITH+Nb7oPxfCNlA31pZPAB1wJ25JuPLYiBVCCfshZb tZTAN5KAie0RmMEDaXR8QBaM/J5zGbtAfNN1HGDB9WztTwsWGsqHGq+ym3OAPp/EXPo14cg/aMFx dWQ4tgA9zyI8m95rKSxxc96n4aQSBXMHKMidVBK3Gz6RMc8EjvtkZ3KsYRdJp6F59h72HBRnEJm4 8cl9mcjVlm2w9HDi1GhKn+nadLaSPrZyffJaDbnZ6plG4zHqWnb9brNs62rW1x1P05iwTtlbDUlW 4SarhfvQ9TRi0nLa5yiP8tgismZdTr2PjU+Rv7hy5GZn44DNcnHuVmzNteuE083Z2bnVVmeovTx9 nnsJPX55uVXMcf49IQxKYt+B6DdiP17vOgVTzvreFmG05de0n8cp7AQqvPTjR9/AsYw+bJ5P45Qf m9oyABd7lX+gsLm+zem/wdfg7Wfbg3GxPGJcjIA4x5uxNx/Waf2AVsQjuEb8ywKR3/R4f1hDndlV mjaE3ZBUayBvDLtA1eGIb8/+upTPsqXff8V0G4ujfBPjuE8WPicRP+OEnttJ24s0ej7nMAAv/xz4 v1W+FF9AcKyhwZVxI8EhVw8qX9FJ7GbcQbkJ7ZTj2HQa45sdCmnjlrEft+tLXKDCBRuUdcPKvVN0 WiWxjGSRxo2hQZAXhND2oBiWIGXaoBhJYyLuukGWf+avaS/PY17KFay/+8ibzv5pWRYkB/NZZjJf LtJtlkHj8ZRLehYwbrq/RWtkTVyL72c6ZWdcEab16IEX7Wdm9bQu6PL8apNSuOYV9OgxrcrYtJ3R eDXt5el2/vlO0OMapgTMu1cMi1xS43KJJKXKxNyKCJPsix1180G+ZK6we0kWxyRwubtcsoBGfFlA IyPIsphGdjDqtJQMAskZlnI6lFwfffQRxo5lZUXQlcoCK87YCNGRccTH7/yYGZSaEMrirkS+FUVy 1bliwpRRrO5PY9QEL9VAmfpcbXH4MgYJlJO3IsaHS08QFOate4B8CePNyL86aS0p3XadaFLNfjnl zateNDlLEHxk0nQjnfFhhEU+8uhLnYbLg49v5i1mRhm/IQmIqQcdYZBaV5Bj8V0eEdcJ4+QDX5F1 xBcOznAeWH5nJ2CoIhShAu92tcXhzu+8N1PNzoi6hPn48CyNKk6NiSSEIz8fAuIzZ9v4IuoZEHxB 5BgOVpGPunB58PHNvJrdaFg96FAafiK+YfcnQqtHpicBTwK2BKrby9PyqmvR6tJR7OlJ5+P4uxNi DOX4iy2CJRYeQO7mPOyXnsNxdIXsphUWS3s8go5dsgPSPaijK66WpmIcYNcqGLWFBw4gGBvV46oj cUGzyfEXhUHLRz1lEbQ4R2R1e3kO/u1p7Fv4lQPy+AY9gxJK3lzH8ZJ9mr51qv5zeOuFdeYwiFBZ Q6fn4a2ur2DD7o14ses72Bs6A/vmmRjHt48uTIriSs6qW2gOYTJhHpfVrm53IJMLSKPMvo6UxFhk TMl0Q9TpfufCKYhKTEEq9/X0e2BWlQHFA0uYzgHXqrSyOK7unUh6E+UUMaHpgbdlnatx5TsX4rKo RJ7OnoLYfg9grc9e7cSUy8gHT21PjO2HWboCmTnf5grZRO5bEVx3zlxpY6rqbZ0/BRmUhchwicOg F2+dj4kZ/YyMpwSTIVEVr53O9FiknJXC8qPwwNv+ckLJoioltYsJtZdn1123YudHHBxuAOcZlDCE XsTB0RFZN+F3myfg2jf7YNMDn+GV6duqz1m+Dc+2eM63ors6wOwn3sP2/70UZ54xBFc9uh8znthY HWhAfA6nMublFHELTxEKil7HgCrDBAkYvWEDt7tUHd/Inv00nkl/C0Xy1biCvXjxip4BuOt0Q4Nw 89m3YxoXBlZW7sW1j43CMwu5NkMd08cPuZ13Dq3VNPFj2uDWNTmoXLEClXvnYcFjo7HEZC/GjLGc xZq2xmyz/+qKj9HniYUm51oux7+d0+vCx96vrsCoHs/JahAULnkRo5+5FnuFv5zZXCybjk93Bmvb cOah6c/wx2dfpTQLDE7fT2xTjPnjs+CcTPUzxs2HYQ3roHKFlP8wHhv9mllBIMaxRln4Cql7INy9 PHUvoe45TwyDUrwNL58/A5/+zd7Pc/7H2GXeZBXI9u3xmY7vuWejYmcWpp7/GfaLzMr34K0Bz+GL ldZrb/0TxLHkcBBpcv9DchyikxujQ8a5uJbHTeb9bjlbFKX4/n9e9H0P6KPP9jBvKRb/9mMeb1WG tztMwdxMwV2ARXfZcCzb0Mayv55UhOFXdTXldR59JsomLcYOefb5UI6LGoXFQZaAGGCuqm3ZKoFb eBI45imjf4WYyX04E7kPR1ouj2fuwhdP3M3tLlURHJEZqaxN2CNkJbdEd1m5SpfLvUsZdsvnEXs/ TCHfwhkZd+KBcdbbOuPOmUG3ohRuWMBVO5Pxq95CS0tcMnk4Hpq91uAVlXz7Bk6pPjzJLNvhnFlV F9MSab3tdSvNWhq4/QUkkFP+Ly8grqt6mzyDLpvAqeovaDgKMefpDzDpoUvN2GfLQSOZ51WzdGfD l69ytev5pIKu3bm4mUUvzdb2TmDR7QYMw7AzeusaZV9iQrsByBg2yHzxwBfJwFrubRpu721KaNkd vbkyW1xySy4vwHYIydXL4hCmj4ri1qjgtBhEYf7UZS9PmKjrDXZiGBQeTF30w36sWNAc49dcgW4/ ZGPJisMoXfst3v5tOa7bfRtueDUZ80YvRmm71kj8YR02yets4wZs2laGdd+KeSnAskmFaN2tcUih th3WgzB7cZC62fIXF+GWvNtw0/vd8e9rf+AJH3EY8ODZbNPE4rxF13P3egJ2TH8XX+f1x+/ybsGF 6evw2oubacyOsMRUpGrrIpknj3Me94hM5YbYf5TCDWevvTQTM6dP5/EgsrKOZox7ZaxtJnu5zaQZ cr+dhR1Hqqpv2jWP4Mas+9AlMQNT52ebvLJ36QbuXfo19y5Vcu/SQ9y7ZOwg9xstWMAFbKNnYO+W eUjhm//5b03TwcpXzW/zU4dw7dxy023ZOf9hjM56Hq/c/wuuBCngUoJqMtnR2e8/S+7ux9DulrJK NFcZGJfQvBf9Bdjka+jYLY+ENhjCvRPfbj6A5t1Y9jdr7ZbFfuRzScjb326yEAT7Dd54IaT/iwea rTX3Nj1cZW9TMT56+iYuhLsWPfwkaxb4ZZGAs+6fx61RWuE+kFoH6rOXp9aF1TLDCTPLU8a18b+c eS5aJZSiWSe+3PjgHtwgLQa2Dv7yMcrX5wDbuAuTatt3NNegZeah5dYcNB6dgsOfbkP+z6OxrVMv XGZebTVLscKXHIfO/ZKx8p1FyP6aXaD+fczy/7jUJJqVGDTrkoK4mFLsWMIm9c5N+PBPe7HvZT6q d1SgdMtuHO7UgfTayGJaoHP/ImzLKUav3qH3HxWVFLItVIJD9p6Ngn2ypeVhDDD7cKq2THwkJ6dh alkOLnjsZow+rwcWPb8Y087fLuuC0Zp7l7LtvUtGiWUDY/rzeOgXaaYl8NCkdIyncj44rGYh+WzG gSW45LzHMOmrLSjeuJRlLMCVG3IxIC14/uxZd6LH6A3szv0dnX0EOwKxssKIjNLJIik2CHwuUUI0 PJ3Pm4ixowci8bIvMXbzC5jB6Bu7NfHB1SfQjHubhgUgKMSsO1MwevEk5Ky4OOgyJJ8smNpjSEZA 7rre/Jj38pwwBsVUjrzJEo76ZgOKdvFV1r8TThnRCzEXnIyB9zSl2YlGt8s6Y97Ur/FNQRkyXs7A 9+nzsfDv3Hh724Vmy06oij64eitB2qF18To82/UzNH/yPPQb1ArrvvCbGsFRYdNzaAPQ+NxuSBvR DBWkI75tW8RxeKPxtmXYxzdkB6kFLrfe+UMihrRXCyMYgjv5ENm4mydigK/29JVd7es2EFFMO1zx 4PvYMuhOdLmELZJlbZg+Chdw71JHXMitSUnoJRpqtKFE9NS3rMKODMQnAOxaqNu9ajGXsf8eMTvW mIRPb/0F7stiU4Hu2vTfI61oKtJcbO6c/wh6jDqCrIL5SHO9xLVVU7xbVu2yBcr0JYIs1hZA8W6a KuD3cq4K18W8wl3U9y7bjJRe/8stRe2R3629QNfauY2WG8H8R87CqLxXUbDiGv8G6WpkUXU0y40t /PuavsuTxKMeV3t7ecIXZm0g257dA/iBLYeOXdFrcA9075lisqcO6IHYr7ZiGzrg5Had0GtEAf49 tQD9LmxdDfpyfo2tFBXlpdi7ZBGmjd+DTtMGI277Fo6VdMel15+CFidRmVmUcWVsgdCslRv9TuDK ebaC3i1AC5YrdLSVZgkP/UnkSE6B2oKig8ijBstXCuXdu3PjNnPUuIWw6q+cqVQXdyB7Lfc8WYYn Nk6sRlM05d6lUWw/bOLepcHclzSYe5d825KyNiNHaORZIVPvy8KES3pWKTZZ8mfdjs+yBW8uFrzE Tsv5aUhOux4rKldgvgy2li2jGRyOZUGMCQozcfN5D/FUg3vRM5ZTzzIVLKUk9MR1wxdg6kdW12zF 7PdpqIZyfCQZw28ehfue/cy8PA6smEuD8jCshk858zZD2uABSFn/Nm7KGotfpLsslJMDOd6ArZ5S q7IcKeVmP3jJYUtWklDMvU0b7b1NhSun4ryHsvDBHy5BLKf+ZVpbXHWykLQD2zZya5Ti8/byiEx+ xC7Wt9s4JtUiM673GeZ7PR/2sT6i/uTPv6Gi07XsiL7sFrWY0Mvk6TyKhqTTyejZzt7/4+Iyke/o D/s8jyfbPI9pI9dg4JtjcPWlLZDYsw86IRt/57Tym2/Ju/vfeFlmf5I74PTRzNOTg7Ic8O1w/eVU 1PV43p5+fuFFwrCVcAa3vcx/y7JCO975FmUTORAob+5w9x856JS3KYdpfTFyH281MXxxEtgx92Z0 SYk1g7ft2R2ZPG8Mz0VKw4vcu/Qq9y6Z6ejYq7Da6IdgeYbbfji1GtsDi+94C+PdzQdByvz/4P6g 0T0Ebyu8lPEB7s9wdWuMHtGgi/66XOEW6Q6xpFE9uHWDU8+cCv7XSiEgGWNnzMOe0T0MXUPuG4I1 D2WY3GkT/oFJG0bz5MkopA55FW+tucMaiC1chhGcxu3H6eDUIe8z/h/o7RdLQMkrp45DVOoQGqMs bj+KhU4Ri7GIikrF7WxUPUSZXGZPrW/g3qae9t6mLd8sMrhG9eC0dQrHwlI5JS5WsFpZHMLLnXty a5RleGTfg7eXh610iow7wPCj3MtjajjYD/dYFJXxez2cqYm8Y2uED1JcAo0Ryynlku04+wEuLSzl zBBnh+xCZa9RBdvviQJrXB5ea/EWen5+BuZdkM3B41+hbTUPv50hIl45F10VspWSyO6BbDfxu2LG czSKy9UlujBzClLGx7NJP5E3xVzF7uqn+DOaULm8qbmHpWWwM01csLW6LS/kputyzqaQ3oCM5TjA 3dgxnBlyrtgX/mSBXTLjA/kLyHxMb46ZLCJItbeXp67C5NRqYuCTWFdMQfJF05jY0SzHabLiXAas 6l6jFrh682jsyqvA+A39Uf1H3YMUW4+oGO4JaqY0B+DhNLTTaMju3a7SSuEbxBkfkMd/E8OZqkjb EoOdH4lv6WrwWKVy4DtIgvDXMtheKD+pxzx0zGRxzCmvXwEB76f6ofJy10kCyS3QtoYufp1wRihT ctpEVHLYwnOeBMKVQKNwAT04TwKeBDwJhJKAZ1BCSchL9yTgSSBsCXgGJWxReYCeBDwJhJKAN4YS SkLHKV3OtzjKTx/IqXZyHQsXHR1tviZXn2+xHA86I8l7JHiOJD0nOi7PoDRwDYvxyMvLwxtvvIF1 69bxszU5nH02y7oiTpkc0dmhQwf06tULY8aMMR/PFoULxx1POsOhJ1yY+vAcbhkenF8CnkHxy+K4 h+Rs3VdeeQVz5szBWTwLZMKECejZsydOOkmW+kTeHTp0CBt4rME333yD2267DRdeeCGuu+46c/Zv TaUdbzproqW2aXXlubblePCWBDyD0kBPQmlpKZ566ins27cPf/zjH3nKeQ/UpysSDhtiqPr374/0 9HQMHz4cL77wAp588kncfffd5lDxYDgags5gdNQ1ri4817UsL591prcnh+MsAXnjv/zyy/z2SjYe fvhh7mdrxn0/1h6PY30WaGWljNMcRedOnXHnXXfh0UcfxYwZMzBu3LgqLZWGpDOSVVIbniNZ7n8i Lm+W5zjXuoxFbN26FZ9//jmuuuoq0zKQODEoxq+wfAmHd5Vg2dsz8dXmw0HgA9OkjPLyCmvw92gF y47H5ZdfbmgRmqQ8dRKOLJ1+fkryN2Dmk7/HzTf/HvOC0u2HDS2DQB7d8LXhWXn3/LpLwDModZdd nXIW8djG999/Hz/72c/QpnUbMwArLYEyo+w0JlR4Swmo/IdW45akJAz681f+OBvOB1N+CHOvHY8v cg4Fgakpjbtyi4vQtm070w368MMPIbSpC4vOQ99jPOlL0mvQLXhnRV4QOsSQ+a8v/3Aqxs88inPP 7IYKDkA702ofrplHN76aeFbePb/uEvDGUOouu1rnlCnXw4cPm5mcjIwMNIpuZJS4nK2SBLYWYvlx tEaN5PMH1icQdvM4Q36/EPjzS1h2y+noF3T/DT9YdxaQ18hSWDdRzjQWz9ZJBUp4ZoZcomyxPFPk lFNO4clsCwxt8sE2cWHRSeMne2fvf38ZftO3CP+84yyMuycN22Zdb3aQGkRVfoqx4UvgD8/ejZE2 Q0JH3R15OIV8NYox/LjxhMvzse5quuk6Ue+9FspxrFkxKPLZBRl8bdeunfmqopm2paKXspUiSlxY eBgyM3HoUA7efOhpXMgB0wvxFmbMXmfHM+3gOkz97VCzzX/oyOtx6yIyUWTnqyHtMPFKGaLAokBS tnzZUWiRsNAmNIZN5+Eic8xjShKPJUjohDN5Yh0WFSDf0L8P86f+1tCYmjoU0xZuNfR/P+0e3PVv GpTh7ZA6YRr27PsB94z8Ld58c4qBfXJxTgB/qUPvwcKtBy3e9/yAJydYfKemTsDiPSKnw7Qm3Ay9 aS6evEqOEUjFVX/+CHsMDeQ3TJ6P42NwQhflGZTjWL3Svy8oKDCfsJCWgCizKLJcYmTkXloM4pdv mYs/rDkT991+N35zTx+89ORcHGa8pC1++gzcv/kafLdpG96cdA3OJA/R0aHTYmzcaki0fOmyJPPI AqFNxyDCopN0y+GKmzaswprF7+Cvj67B2KeHoTlp3LfwcVxxfyq+2bYTG+bdiLtH/QlbeCjCqb+8 Bfcwz29f/QprHv0F85ch59tXcdPkffjsu+UY37sJFj5G/pLuw7adOzHvxhyMun82ygVn5mt49L3z 8R1xblrzMHo2tnhO6Aw8NeE6JP76Gyyf93fMeeoxZJdYaeHyfBwfgxO6KK/LcxyrV1bCyniJGBNp BahiizHRKWNtei9/507gkid4aBDPARkyGnjiQXy5+b9wec88zPsbD/6ZPQZdTmIfqHcGfslvdRdS uWNidteQZlW10CBOfA0LLUKT0KZxYdEZE226Ni/+/X/40W9+6Hvi69h7bRqxF2PVZy/SH4o3nprE o8o+Z3g1Dpc/h5iT2qCV0Nu6A5o353qbYraMmPrOOw/iZy0YKN+Cr0zW+Xhq0nIUr/8U+PR0Y1Ca dxlIgJtw/V1JeOi3/4WMPsJTNPjVEhadhYnntiG+Iyw11TawTKZTnkLxbEF7v/WRgGdQ6iO9WuYV oyEfkBdfBj2lVeBsoahRAQc7X5osyKcjvdM9ZoyDwwT42zvLMeb+NuZowiR+UEtw8eRaRHPIJTqG 5+xHWSe1B00jrBgOcapYqmiyMtdJm8CERWdFDPYQ9q8zvsToff9AxwuuwlvXbcc1fWM5psGEEb/C L68ZzO7YL3HlxER0SiaNpLPC0Btl0U8cjXj0c4qkCTtRlYa/EZf+AtcM43cAyn6J6/7QGs2YGNN3 DHatScO7L0/GVef0xV0zs/DgJTynl/jatWnmwMfWHuEFX214Zumeq6cEvC5PPQVYm+xiPFL4RTsZ w5DxCquLIw9+4LVtzv/hEzyO7YWLDdzixYvx3nt3499/fRGryjth8NnAf780BwdZ+LavXzFjEonS 5eE4RrVp7DJIOc4yJSyXjNkITUKbGrhw6IxhC4W6jHKeu9p0yF346O5TccvQ32FV8Uk4Y9QtwCfz UdKsFwYOHIi+3drx9DSrPBl3bmR30SwcHM+x02ISesFkXZSDZn0Hmrzd2jW16Ny1CQeapuO6ByZj MmUwJzvPxFv4uKjK4BCa/PjC5bk29ejBVi8Bz6BUL5uIp0h3Rloloqz5+flmpkUUWB76OM7wWFc+ PpnwBm776Eq0jo9HvH11Oe96/Bof4V9fHsTlz7yOc/45AV25IK7fEz/gHFIaw/zx8c1rSIt3lBHn M2KyElaMm6woFdqExvDolPLieMQ1zwVtbNF54SNv4T68gWEPfow2Ix/Dgr+2wUW9eDwj8TZrews2 VVpwjWlQLHrlXnBEIc7Ha2OMfGwj/p5yO3o1SzZ52459F5VMz/3mKfTlaVTJyW1x+1fX4Klxpxn5 NG4eiE8MiuLzy7VmniNe2f+hCOUFI90eMSxySVguaXzK2X9yoqFMVibZl8wp/vTOlCXRPxYnsyzf f/89MjMz+VW+DHTt2pUHM/PjHjQs0u0I25XzA+I8/zWZSlel31pTGguQro4MvkpXRxavzZs3z6xF Oe2008xYitAQKTrlfFc5WF7PqQ2bPwLKB8/L+CgGHD9J3gqJsLb4wuG5NrSdCLDH4kzZWjzBJ4II G54H2f0qGwBlub0YFplNEVcrYyIZeBh2s2DGJFSaoyzp6ggNTZo0MTQJbeoiRaec7yotlCpGTwuq wU9gvgBjIrDkuy74VL418VwDKV5SmBLwDEqYgooUmLREWvJg5WHDhplZFVmhun//ftP9kVaDDiJG qjwnHsEtZciitoMHD2LWrFmmlSK0CE1Cm7qGpFNpiIRfG54jUd5/Oo66vDj+02VWb/5lzKRjx464 4IILsGjRIvz1r381O4BlJ3CXLl183Y56F+RCcOTIEWzZsgUr+OEtufr27WuOTRBahCa3ayg63XTU 5762PNenLC+vNV7iyaEBJCCDhZ06dTJnkogRWbt2LWbOnOlbXHYsSJIToyohAAAgAElEQVRWhwwI S7kjRowwBy21aNEiqDHR8huCTi07En5deI5Euf+pOLwWSgPWvLQAWrdubcYw+vTpY2ZbZMZFuiSR 7vrIzI3MGMn4g1wyqyPjJDq2UJMYjiedNdFR27T68Fzbsjx4SwKeQWngJ0EUWpa+y0yPtBZkjENm JI6FQZGy5I2tU8O1Yf140VkbmkLBCp/14TkUfi+9qgQa1KDMnz+/KkVejCcBTwI/WQk0qEE5/fTT f7KC8wj3JPBTl8Cnn3KfVIRdgxoUXYMRjCdprkqzX/xgTtMi1TVwlxdp/MF4qCnOTY8bNtL0ucuL NH43/aHu3fS44SNNn7u8SON30x/q3k2PG76h6XPTo/cNalBkrEAEF8xpmvjBnORTmGDpoeLcFRKs AgWmrs6N340nWHlOGOXN49+rf+dzoeFIPP+KK5J+gxoUYaQmpQ0nzQlTwUOGDpdx9210LBIaczl7 CEk582pY/RBZw0quCZemqR8MYY1pJQexe38RYhJT0aKJ7JCo3lUc2ICvf9iBkzr0x4CezXyAir9i Pz+t8cN2JHXsj4E9U33p9Q0o/mB4NE39mmBqSqspf7B8zjhnXg2r74Sra7gmXJqmfrAywkmrCSYY zmMd16AGRYQRTCD6dpY0scTiNKzwMluhcdx5gswPX8P8dbL/1naNB+LW3ww3G5EkRmE1f6gWgqIJ 13fj9+crxsKX/o7vSFq/UTfhgp7WN3cEvmznIkx5bQlOH30LhnXyL3uXvG763PhLtn2LV95bCfT5 JX43sru/uCChUp7+toRL7JPLu6B/dzkSKRB/2eEdWLxsGU6q6IoBPfwGJwiqaqPc9LkBQ/FTW3g3 Pnd+972bvtrmd+Nz37vxu9Pd5dUX3o3PXZ773l2e5D8WrkENihoOYUwZlmnTN99802xOczLsFGDT pk3Nae0SJzgOZM0xxiS+wzBcN/o0xBzcjFUbKDCmaYNZYVWQWrb4kXLCQ1WXhAFndMN3szdhxbIN OLd7P9NyEjo2rPiB4CfjjN48cIlHAEic4nD7bvrjuvH81qtPRUKzdkYGVct1xMRaxiohWfZ4Wi6A f01PiA+NSxEE8ZXmIElV+HLzI3lrw38A/cEKdMW5y6ttfhe6oLc/Nf6DMlHPyAY1KEK7sxIkLOsG Bg8eDPeUssKJf8YZZxi29aEoLrVPa09KRlOu6UhIGYgRvY5i396DOEol3bN6ET5buBx5h7ntla7b sDEYdVo7lOauxZzZX2J9Hs8l5a7Wtn2H4OILBqEZ+0qlOUsx491MpPYfhOb7lmLppsOIbdwNF155 KU4mQGVlOXZ8PxefLORJZMzduEVf/Hz0RWgX2NBgSjmanzIYTWhQ8ncsx5bD/dCde7YrS3KwfHUJ mgw7E0mHS/DvRbMxb/l6dtmYhbR0G3QJLh3Gj3+R353ff4B3MwvQJ70rcr9dirIBV+CaUwvwxWff I6X/Jbiof2uU7/833n9rPrbZPDZtO4DnG52DNnE0rMRh3JGt+Oq9d3y8XDD65zYvVjIB7UAFti39 HLMdvF165cVoG0+lP1qI5Z/PwXertxm+yTnOGHMdhlRlXJEaX42F+OKc9WkiHHGarnn03um7DYTg c8JrWHxx+qyIr05pkHs3fCh87nTFWZ0fDL/AOmlwhzWPE05hJE150nQnvIbFF6ewTv5NQoR/GnRz oC7iEiadV+fOnc3BySI8jdewfGFPVpdKvMZ1TpOjAYGS9Z/gicenYkHmOuzZcwDlzL93xXt49dPv aEwaYUDGSGQM6IbEuBhUHlqHaa98YozJgJFXIOPkROxavRDTXv0GR4SemKM4WHYYm5Z+gaV5TdGB PYWyw5vw8atzcICtqNzM9/AWFa682zBcMXIADuetxhtvL0UpyxS6nNfhRl0wtINQuB9Za3aaxWsH N6/Gbsac268Vio6WYv/23ehw1mUYP/4KpLUsY7mz8M2OEsNndEUxy85DFo3JLlnt2iSBByIdwnZu Ktx9yFoIV3a4AEeaDsDV48dj5ICWOLgrE7O+2mzJSYqmy132ZQAvn8yci3yh1UrmryXvvcvexdsu 3l5/a4nh7cCGb7FAjEnLIRg3fhyGpXVAk/hGAfw6edew1LWExdd6V1/ruCZf8mqdO8OaxxnnDFeX LjDOS3FXB++mX/JqnBNPdWGFFV8uKUd9LbMmX/BKuuLXsOapbbrAHwvXoAZFhRPMl1aIjJOoExhZ Oj5gwAAjWBWk+EXJg/CHGy4yB7igLA+LPpyBFz7OQlFlEdYt2WxQDBn/Pxhz3hCcd+XN+K9zO2Pb imXmDdtkyA24ckgazvv1byCnoSLv39hxSIRtWfb4bhfhkT/ehTvvvYHnu9KV7sUBHt+4buV2ucOg c05H335nYYAMTeRuRM4RyzgKvVrplSXF6HP2AAO/eXm2UcytK7J44swQdD+plA9JEi7+3R/x6+F9 uNemNTrbnzZuxCMdxVmf1mDLKuMGTJ40Cbec1wmV9ptHPCkn6eSf44G7LkV72avTRw6M5BkkSYnm ATQ3/KnKyx7sF3r14aJfKTIL4G2ozVu24a2ytMRCV0IDxrNbR4z7Nc5sn+DjVeslgH+DN1CBg9W5 M04KkXt1glec4nf7ocoTeIVx53WmKQ3OOGdY092+E8YZdsOFey+8Cqw6wSlO/GCXwGq5wcrQNGde xR1Jv0G7PE6BSVibacKgHJp86qmnYvny5YZfSZOPY8kSdberPJLHQ4+HYdLjg7Do3el4e/EOHNkw Hws3d0ArAT/UEr2aHkTOnnJfJSXyBHhxxfn7sDPXUrxWYjFyC7F9byE62kqd0rEDDmzagtzYFPRn +ue5jZDIowYb27Zu0bSnsMhgkp8jPDPVulHeLJ9f5Ot0GjogEzsK1yIr+yRk7wA6jPwZGh3hh714 qPMX0/6Euav2+TBJQHg2D4Ad27FbCrI3bQqA0Zu85e/iuY+XkQKnUyW24pSXvTFOXpzw8sA2qpa3 mOhKtBp0MQYsfRaZ+avxzjReaIPhYy5FWutEQ6s2sQP59yuHxkup7rCz/gOp8stC8bvTRU4qL0lT XAqvZanvTnfnFxwKGwyfG17Lrq48xaW+G7/EK02S5nZu/O70YPQoToHVctVXOt146ntvP/71RVO3 /Mqc5Naw+hInBmXjxo1m05x8b6VXr17moZU0tyvN34ONhfE4ddSdSCx9GK9k5mPP7oNoZl6ouVi1 pcC8STVfZZT1pk1pmmTjLEGhiYpH9/a0Jvk2ZEURTw1LQmXRdqzKteLK+PCWWdkx7IY/4IpTU9h8 ZRpPi96/hWMl/G6V8OF8QEqKmuNsNmNmkq6vP15A4Ca45uQUlJQdQdmu5ZYxkdbQ7SOw94M/4W/z cxHDD4E55VFcWICjHDgVZ7+w7PARrPpSjEkTXP3f/4shqRvwp3uf417yaMPbUX3RkZfSSlrY4u1Y 6eDFiUvKq4m3g0WNceUfJmPEth8w962ZWLxjNxYsXI9Tf5UeQKubfyHUyYv7XtPUN4w5fjRefUeS CboVzq1gAuTMq2H13elad6p4ofC58wtexSFp4pxlue81TX2TwfGj8eo7kkywrvy78dT3vsENilSU OLdARHA6QDt37lwzEOsUpoS1wnYt/RjfFLRGeo822LLmKyyl0opLS+uB7k064OvPdyDzvfcRc+EQ tKrYh73ojLN/djY/SvUuBzk/wpLU4Wix63t8J4enxfdHx6SjKD5oaWEuB0uXJA1F3NYl2CVIm5yC djx6IPWsbvj6k01Y+K9nUTLsdJ7/egSb1h3Ayeedhbb20SJOelFegI5DuNUg83PBArQ8He1wCEcq WE68PftSsBcLP34dP9CYiNu2fgv6DOrqeBCtFoekqY2gaaHRqESC6bwWY/OyT7BuzWIYDGuysKfv 2UilrMQJL98JL9u+M+M3Fi/k1aTKj3QL4nFKUN72k7dhaLT6fcz+qg1O738K+pzahQZlHeJ5+pzW o5NnZ9hXhB1wK2iw+tf6lSwaFl+cs/7l3p2uMOIHc6HyK+1OX8sQfBp20iPxCu8Oy73T/Rj4d9IT qXCDGxRlRCtCfYmXsHzVTs5elRaKxpmAnS5hDhVgz9Lv8Pk6TeFk7EXjcXaLcpR0uRFXF0/Haws3 4bs5HxmA1MFtMSguDb8ffxh/m/YZln78nomPbzkA/+/mn6NR7i6Hwh7x5UP8ybjh9uGIytuDpoP/ H8YXv4Jp89fhu3mf2AV3QtoFovR+OpyhIyedgiHxn2MxWzdpGaegtLjUJMe274eMDl9jPmeB5swB +g8bgPyFmZxpmYedab8Gv8tnwdlrb+xbyzM1eBJ6n3UyDdw6LP58rplVOrlwCdbtW4nVOQMw1EbQ pENSUF58+IirsrKsRt5iEyuQvehLZGd+aWVrcjKuHtGL096HfGjCDbjrWvIFi3PG1yY9FB3BcDnj 3PmdaRpW3w0bzr0zr4bVl/zBwsHinLDO9HBoiDSMmHt5JOX9JpeE5Touh1TL5xXUwrPMGp0ISt8K bsDkdt3RNqEch4/wY+P8i09phuhDe7B1537exaBlx85oEVuOAipyDAd24ziwujEnHwmpbdGpVQK/ DWX6K5z9qcDu7duRX8Jm/4Es/N/rX6PDRbfinhHdePBRCRonRyOXJ54dZHplZSM079AZrdi4KDjM UuKjkRQfhZ0bNqGA6ILTy2/T9OaJbJR6Ud4WbMktsvmPR/vuXRBdVIjoxuw+FR1BHL9VXBqdhILt G3G0dXe043drCnduxI58a6A2JqU9erbnJzkK+GU+8pLSthvaUNlLKqIRF0U5xESxO8WBnoId2FPR 0sAe5Ye8GjU6auh18hKT3B492iejvHCXkYt8PKtZu05o3TiQt5z12Tjashs60kAdKbFklsRp8j3b tuJAsTXoqfUZnH9/zWldKrw/JXgoFL7gufyx9S3Pnd9NT6h0PyVWyA3vTnffu8tzp4e6D1beP//5 T3Tv3t1MfsgEiPu68sorJxBvIS95W8jqCBmik0satfI2lI6/PJDycWq5jorxaDAnQpIrXFcdbEEO x1n4nZfYmEacm4lCxe5dnDJWrGXYu20j9jI9jvp1lIMd5dLNoDuSl4O1efLFPbGrlZyKFSWxXGW5 pbi5e3dg9epyzjDFIGcH43xN7nLs27EJebTDcbEcPCXOcjOQohgC3zBW7BFsXbPaD8CQxVMRtm9Y Yz4tUVm2A0JeVEwcotlaMLRu32C+wePMWJZPunSchwn5O7NRQB6j+aEsw0eU8EvDSJ4q4YCNosEh vWU7OEBtIyzN3x6AS7o++3ZkY58NK7xVsGsqtEbt3oQ1e/jw8fUjoigrk+fI75x15Az7IayQpqnv Tg92XxtYd37Nq747Pdi9G9Z5r+HqfMGnaTXhrgnGna82sNXlrQ8ON85g9w1uUJQotwUVxjVOYDQs vjh3uhiAksBn28D5flzpfnw0MMznxpfQ9mzcyQ+SRyfwjZ5fxMOcre4JAQ1KyW/1gyvBT9tUye8r N8yA4CvjSW3K31GOjMrUsD4AfnqD8y/FiAysESm5oTx8Nw4iuCCPxYSUp8lhwzpy2/TQuBwN3A3u lp8zTzjhUPyFSg+nDCdMbfFpPagv+XUcRPD+FPl3yiNS4R+NQdHKEV9csAqTeK1Qd1jua+MUj/qS 1xkurShBQlIcKoqDH8cYit7a0CKwofApbepLHmdY7mvjNK/6ktcZDoUrFL2h8rvTQ+FT2tSX/M6w G1+oe82rfm3xhaI3VPnu9FD4lE71a0uvuzwnHndafe4b1KCIEJ3OzaT73g2rbxlnfF3Dikt8cZUl R5DPJf3V0eA2eO4Hoi50uMty3ztxSprS7Iyva1hx+fgPgd/jP7CF8lOv/7o+N+58DWpQ8vLy3PR4 954EPAn8hCXQoAZFpoM950nAk0DDSOCEOwJyyr++bBhJeqV6EvAkcEwk0KAtlGbNZEed5aqOCchY hsyoWGMa/rB/lkXzCAaZfJHhD3sSxhe2h0TMWIiOEwh8EAB/nAXAX3/5irtafIbO6uENyhp+lBfx Lefx75S/P2zJR+vSP+YTWH0h66sqQCCCEPUZqr7c6GuoepMUCt+x4H9HKKLqkN6gBqWigtOP9moI WT/C/ZL8dRoQ4UgVLDCssOIbp7psg1d94FyDmC59dZcfHn7/mbhV4C2qfL8WftJg8yd8a5wAucv3 8+3x7xOi41moIm+v/uUh8j02YT3/fsFGLNSgBkUWgqmCyWIqSyKWgXA9H1UYDq6AARKlcInF16QQ 9LwXxHTBFdqv8FblSH4L3odLWxDuV5DgrQG/jcXnVaXf498Stlf/8pCYx8n2fQ+NI1D1+XHlCOP5 dKCLWLBBDYo080QM4ixTIAptOStFWi2BEKrhVsvEatXYWegprAZ5r1FqXGyDIBb8aKW/hcEtdiyb cdri8el3FDp3a42k4oNYs5Mrjn0GygYgDsuRcoPb4kB+pf3l5Md6CCyC9FfJEzjLyFnYfjz8W/QY vmWa3+PfrqCffv3bNRtRr0ENiizptgxDVZ6sJptf4Stt5RdfXICFjm+Jsb/sxu25GzHjW+tMETe8 uwRVbvGNMxpN9fZbACtcGYO+p3VCh71H8e8dPGpSWiF0Vfu8JrranwB6Jb9twCLCv5RqWSQf/ZHj 32ZJW18e/0YgJ0L92zUbUa9BDYrp8thvPHcF/axPO/To3MKnIE6uFy7djN15hXxZyvJvGhiOxch5 R424pVHGZcS58bn7lFW6WGJLqJR2A8bgsH6iIdt6ysweIHbRqqG3Kn4HCkOPZRx9BtGmvXb4tD0j dAbDxxZR2PTZb1i7ReZqwAUSzzs3f6HlG4giOL3OF4ZFu+AV5y7Pwubxb8khUvWv2CLnN6hBETbk LA9xogcStvUBK9fvQrdOzbn1TpsMBgwlpeXYlVtgHjhdnWilWL+6+lYeyKNHE5FxcR/0bWEdSlSw axven7cdcuxJ39NOxTm9m1jf7inJxctvb0bf8/rhtNYWbAWPOPxyzipumtOHmK0ph7XRsN+X8gXG okPC5MrESYxFj1+BlNfq+FfelB/B4XRV8Vm4FT5UukWbGhWVv+VLOcKX4FD+NE5p0Hi/byA8/n9S 9a+1GTm/QQ2KtSs2ODOyYW/1xt04pWcbA6BdlAVLuIXeGCGtOfq2UZKnWXbFihP4ARel0ZhEY1vW GmyKa49ze3fCZWcWYNb+DsigManI34t5K/KR2pz7sGVXblEBFn2+FTuS2mH00Hb4WY+TsGppsTEN 8oaVcrWF4bMVtr1T+sT3O6Wx6hvFnd+fxw5JVr898im3KLnlFLflS+dRaZB0DSs9IdNdBsQyJn4D 6G5h+Gjz+DfV4ZZ3YB39OOvfojGyvw1qUKy3qe+J9L/UhUfqyaoNu9GrSytzLIEoxKEjpdh3wDrI J0DfzPSz5KHSy95/cVEJaJ/KjhAPrZ6bmYuD3Dmb3jsNqR3boFs8D/rg8Q1fz1mDLEGXLfBRWPTt DpzDb+ic17Sxabk0TklgF0qOf6AjWjml3NJyExPw4x4T0be7zwBI00WMgfjGCd8Srp5/n9IaeG1N WAZTc/qxWQPUakB8M07VjHm4Srdocw66atg20BadSoMhKODH45/Gl386JvZTqP+ACozQTQMbFKqD rU+WovFGFY5JRzl28cOaHAxK62jYnfftel+yRKgyaUDGT2TmxrhKOQfEclbLogyl5riTKDQyPs8N KZUWh0VAZXRTjL86HakVh7Fq4yGkNo3n4Ux8PKRVYiE0YW0guN/4AqKQNrh1bxNhdSGEPTvCaDTD NfBv0hScBWsrweA35WmIsrIHecU3zvDFzDZ/IjgryofQosVmyOAWhfDJj1h0IFaCpmr8XVKP/8AW ocj8p1b/QnOkXYMaFOme6BvcUjh5oK0HXpuQa7P3Iq1XWxQeLkZ+gXQ/AtPNG9lulSSmpKJ3Rzk9 jYc7Fx/Bfg6WdGueisFdYvB9fHu0YYOlNCcXWw7GYUinZJyR0RU7v9iN5NZx2L4nDnLQfT5PXFu+ pwVOPZnnljXiIc9qAOibsN29ciuU+42kyu9TUFfNVYUPHLNQ/g1/zFulBSDKzz9Nt4wPZWMbKHf5 pjyHvE03UWBr4odpWj9hwVNGCu8u38W+gdM6lzQNu+tf+fP4d7WAIlH/7kqJwH2DGhTnmISlYE4D Y4Ur2FX5dvlm7Nl3yJyIFvSB5YNvGh1NW2PkBa0tsVTsxXOvZ6ENT2NPyxhqvrlTenA33v48B9vK 87C05WkY1LYzxl7dmX2ZPDz/f1sgy0y6sFs0rjuNF1tHTdp2waAkPV/W+jCT2hc3vdJGsLTZbiEY zda4qjXlVjg3vtqmu0uwWhRWy8JKE+shxtiyOFUUuEoLSGm3+BG+Fafgc9Pr8R8oL0vOGicSC3S1 rV+3vN35A7H760rqzHJV619TIuk3rEGRp9TWUH0zqS9ManjT9n2+N5oyb2XjO1p05EgO/vZ8jgmr AFV1Xp4+l2fBJiC2shQHD7GCTYYifP7+QnyZmICkmAocKSxDGTPOnPY5mqUk4mAhLQuP1W2ayK8H FlXg25fmGlqsShXMllP65E7ClsJZ6Rp20+PLTXgTNvT4eXXjtIsyXmCaKdVih0GrPMuXFNpYy6Rp gdKVMUDykFvOiU9i3PeMsSE1zd+CdMNLXuVZ0jQsvjjBpI+0FeHxb6TbgPVv6iHCPw1qUCo4syJK Go4LZZF9T6uiczzBBQcOm3Ksh14BeNLuYR7taBeuTeq8g3IWLx3HYPJkwNbWqVBviCrp9piG4DXO QY/cu+EtoOp/68N/OOUp/+HS66bHzU9t8VXPuZXiLq8KvForrd5ayru29Lrp+anzX0WedYxoWIPi 6NOrsutb0v18WO83Uc5qnhi3RREwJ3jVV7aNy7YYJr8zQ5UnUl7TYgksUWvYfsNYdGkeC8RnjXir 4x32e7mKgfP4t8ZfvPq3nsfj8/zrcxo5v0ENijw8+gCJQorVV4NhKZ418CjsWgLmQ2fzbimopahW lFURPiVWVOKLk4waZ24FtzXQJcnuN44xHNpNMAB2ZnsWxAyaMlzdoGGVNj7LN7zaDCjf6nv8e/V/ vJ9/eawj7RrUoMigrHYpVLnFF2cU1qnwdtiXzpaCGgGTQRsHaldcBqSSZZlmqZTpwy8GytJwy0A5 DZgV1nQDZlolJruvbOshqEqvgXcYMOUzwJeibXo9/i3j7KtfClBlIhLXsC/dq3/fM2ieyDo8/yZf hH8a1KCY81DsLoO7D+rTNNU4n9QsCagxUYV2y8XCZxkRSZOWgMbJvfRcjH2w7InE8HJaAA1bBk5h bXJtXNZMlODz57XgDdkOg+EusCo9LgPp41stpJThD3v8W7L36t9+3uTxcDh91sUXV/V5cwBHMNig BuXR310aQVY8VJ4EPAnURgL33ruoNuBhwfL7b57zJOBJwJNAZCTgGZTIyNHD4knAkwAl4BmUOj4G hTtXInPtgRC5C5H56duYOXMW1h6o6TupIdA4kwu3Ygl3XEcImxOzF/YkUG8JeAaljiLcMCMdA99a X2PulVNHYeB9mYiLO4Rt3zzOcdnJ5jP2NWYKkVi44WUMGfIOCkPAecmeBBpCAnUdlPVPNzQE1T+C MpOaDEd6Po+Iq8mVpOD+p+/BFRnNUH5oJ9ZsTTQbEGvKEiotNqkVQUpQ14oLhd9L9yTgkECt9fzE aKGU78H750/BpBZyTcfybaWWTIpXYlzUKCy2jlBxyInB4kxMHDfdftMXYua4DExdyfc+80zMGIcp U+40U8NRGY8g216ff2DlTPTjNJxMxfW5aQGaJ1goy3MzcWc/K/6yRz41OAtXTkf67R/gsfNSETVu Jg7smIP7/jzbtFAK105HxmUPYMoDGQZXBvNYRZQjc6ZdbtRlmJVtt0MOrPThT+xzEzDcOlUukCHv zpNAw0sgXIPitFQSdt43PBflcej7+DW4L+8WXHpHAea8sc2iKaEDbpn9O3SzFT+A0LIy7Mna6xuL yMtawB3GMjLB+AUzcPv83tiydw3uX/AQZq6QsZKteDj9Wlz71RaUFW3B86MUWzFmjBmIvAc3cq5/ C7o+dAmmZRYiOe1XmH3/cNz/wRoU/ONyJB7Jx6wXcoldiijBgg8ew/zOjyFn4wdY8NB9WCG2bO0M DLz2CDaWVSJndleMunwmjVM5Pv3vdMy/9isUlRXgq8kseF+JFu75ngSOpQTcuh5S72tqObszu5Ef S0ZqhzuhGbq02YbF01dh/btA4/FyZLW4Zhhy8TArGPTXb2nknW83RHjm7HAsfn0iOicUo3M6z0hh z6Z861I8gxuxcVhn090485Lh+Ec+M5XnYMUCIKfnS3hkTRFhgIeNYWqGVk1TkNi6NZK52/mQ3TsS r5JdFmAyXpk4GMlsKQ1Hc94De9av4O8GvPTYIyhaT0xZk1BevhWfvQDct+UMJMTEYNDwDOB2A+79 eBI4XhIIpvtu+2BoCbeFcrwIr1M5+Ys+w9PpH6O4Uwd0O7c2KNSE2NruzGo1JYzqS3TRvp387YAU G8aXozwfmxk3/IJLMPLCq7B48WJc1yvZhqqdV7CLmIZfjEtGjsRVty7G4qwxSCb+FUhHmyTb9sd6 3Z3aSdWDPp4SCGVQqrNMQa3T8STcWdbB1eziXHc2zuUJbAn8dE6p2gm2OXZu3FbtzMrmrFexitO5 Wz99AjdlAf72ihO7FU7uOZhq/RA+XsnuT+FavKxjKAl9cdlwYAHtzYDBgzF48EC0Tqyp4VcVt8b0 POcyIvoU6DiAeAZjYE8eFpXQFZchC1M+XkmwQsyZyjGUdM+oqMw8/5hKoNb6X51BcSPSe6d/TDmp DfJWZ6QBL8/jgOzf+TZPRdmkD/HFSlqV4tW4uGdnLA82KJvcERNGZeHs1Fh0eX4HrCERNQQpPF7J cvFWbwRI7oenJ4/F+HQOsqb0wcdMtlorCRj7xmL0u/1saxA3Kg8wRYwAAAb4SURBVBYvrKbRsV2A 6qc57hxGQVs9Cb3HYtm0fji7lTXAGzviXyhit23UvMn4YHw68afgwflErDRpIZ7vSeDYSMCp7xrW ktz3Jl52DokWiWGRS8IyACH6JJdogLy4E3kl8ZLj4s3FzUavfPbZZ0hISDBX48aNjZ+YmIj4+Hiu vYhDbGwsYtjvl1kRueTU+DIOhsr10UcfYezYsUQXIVdeilLEIY4clBaWIjo5zvrmTo3oy1FYWMQx jvC7KOXFhVTyZHBYpIorLCxEbGIyxzqqJNUugmUUlsWasRdfxvJikNTAOF+iF/AkUHsJ3Hvvveje vTuio6ODXldeeeU4YpUTx/SST0DwKTTDjTIQKAMDcskJrDKjcTScR18tkfiytVEuCf+4XAyNiU1R HI1JeC6mVsZEcMYk0JhUg7w2hqkaFFa0lOE2WDEJpLXGXF6iJ4FIS8Ct82oLqi1HuzxqIJy+ZlZf DYn4YpE850nAk8CJLQHRc6feqy1w+iIBuRdnvtQirRTp+khXR7s9Eievebm02yNdHun6SJcnoPtj x0uavFfl0ryCR/GKL+U4L956zpOAJ4FjJAGn4ktYDYR2UWQFqFwyjSGXdGfk0i6O+NLNEV/iJSxw 0t3RvNLVMd0d+hXVdXmUELVObmKUIEEkfSjBo8ZDDIY4zSOGxGlMxGgpjMB5zpOAJ4FjJwHRQ7ce q/6K7jrHQnRMRI2EwMmlvZJgdoHJfuc0KAqsvhKhyNTXwtSYCBHaClFDITiEEDUyalC0i6W+nxIv 5EnAk8CxkIDorTjVZzUSTv0Vo6KtDrdRETinUVE86qu9EN8ovPjqNFHuNawZnYSoUZFmjxoTNRKS T2HVoEiapmuXh1HGqRHSe8/3JOBJoH4SMMpto1A9llvRZblEP90GRbswalhUx9WgSB7BpfZAy3Di DzAokqDKrUDOwsU4aCFixYQAMRLa+pA8SrDCqbFRGKdRIbhxWqbee74nAU8C9ZOA6KI6DashEMOg eq2tEdFlZytFjYukqy6rEdL8aiMCytEujySqYkthovhKgKRJWBGLLwWpsVAjoQVIuqxh0daJ05go rJZFMM95EvAkcAwlIHopTnRYdVqMghoINRraMlFfjIqmqe5rfrUJ6hPUuEpReokUBRdfL8koyi+F qu8kQOKcRkHglUjBqQZF4NTwCLzmUZ9RvjgJe86TgCeB+ktA9Fidhp26LboqOquNA/G1VSK+cyZH jYrqt/qCz2lgTDlOg8J045wESAY1FlJoMOMgmZwwglMvMSh6eQZFJOU5TwLHXgKqw1KShsWXS3Va fG15qGER4yEGpbpWihoiyevEy1vLieKr0wJF8SWDGgBBomExDk6neYQgXa4vRkfwii+X5JV8ioNB 4+Tec54EPAkcOwmo0ksJqqtqDLSlIborYTEm2hpxtlYkrPEKKzj0YtCH2zcoK4WJgjsLFSOgmaRA uReE6pywYkAkTQqWsMDK5W7RBDMiweKY1XOeBDwJ1FECoptup/oqvui16LTqt+iu8xI9VkOixkQN kOZRPIqXWWDGUCSgToHEEEhGceKL0gtCcQKjTsISL0ZEWyVOQyJhySu+ODUe6lux3q8nAU8Cx0oC qq/qiz5LWA2DGhbxnUZFGwhOg6J51BeaFZ+Eq7RQJE4K0wKdhkTT1BdEUmg4xkQNiNsXXJ7zJOBJ 4NhJQA2J01cjoIYhmFFRA+P0JSyX2gfxFa9wENBCkQRVeClIWhWS2e2cyJQgMSzavZF8egk+xekO u/F6954EPAlEXgKq8OK7w6q/6ou+S1gNh+i1O07T1Q4QxDiDW1oXElCl17ACi2EQBOJMBtuXsFxS mA68Og2KGg+nT1BfORL2nCcBTwLHTwLB9Ff12GlQVK/VcGiaGBdJk3unLxzIvXGq8HKjYfHVSVgN hoS15RHM13TxnWEnLon3nCcBTwLHXwKi9D7Ft8NqHJwGQg1IMF9xSEPCjcukBWuhCKuq+FqQGglJ E6fxYlicxsMZFjjF4/YlzXOeBDwJHD8JqAEI5ldnWARWdd0JoziEeoUxnKiiy42E9d7pa1iNh8Bq WPOIL3HinHF6bxLsH8XnjPPCngQ8CRw7CTgNgJSi92oM9N5tNCRe4sS5w5rH6QcMylrZrF8BUsXX DIJYjYUWovfiB4uzsFm/is8Z54U9CXgSOH4SUF3WEuVeL4nTsPrVxUm8OIELcG4l1/vqfMnsTJOw 3mua3quv8eJ7zpOAJ4GGlYDTCGjYaUCEOr13pivV7riAe6fSawaNc/uSrnHusN5LuhNG4j3nScCT wI9bAm4DotSqsZD7YGGNU79a5XcaBQ2rr4W57yU+WFxN8Jrm+Z4EPAkcewn4FD9IUcHS3HF6r76g cYbx/wFiC1Fk4Zr49wAAAABJRU5ErkJggg== 39114 2009-09-05 05:52:44 -0700 2009-09-05 05:52:44 -0700 WebInspector.ObjectPropertiesSection - based rendering watches text/plain 7273 pfeldman ZGlmZiAtLWdpdCBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9TY3JpcHRzUGFuZWwuanMg Yi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvU2NyaXB0c1BhbmVsLmpzCmluZGV4IDU0YWJl M2EuLjBlODI5NTkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9TY3Jp cHRzUGFuZWwuanMKKysrIGIvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1NjcmlwdHNQYW5l bC5qcwpAQCAtMTI3LDYgKzEyNyw3IEBAIFdlYkluc3BlY3Rvci5TY3JpcHRzUGFuZWwgPSBmdW5j dGlvbigpCiAKICAgICB0aGlzLnNpZGViYXJQYW5lcyA9IHt9OwogICAgIHRoaXMuc2lkZWJhclBh bmVzLmNhbGxzdGFjayA9IG5ldyBXZWJJbnNwZWN0b3IuQ2FsbFN0YWNrU2lkZWJhclBhbmUoKTsK KyAgICB0aGlzLnNpZGViYXJQYW5lcy53YXRjaEV4cHJlc3Npb25zID0gbmV3IFdlYkluc3BlY3Rv ci5XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUoKTsKICAgICB0aGlzLnNpZGViYXJQYW5lcy5z Y29wZWNoYWluID0gbmV3IFdlYkluc3BlY3Rvci5TY29wZUNoYWluU2lkZWJhclBhbmUoKTsKICAg ICB0aGlzLnNpZGViYXJQYW5lcy5icmVha3BvaW50cyA9IG5ldyBXZWJJbnNwZWN0b3IuQnJlYWtw b2ludHNTaWRlYmFyUGFuZSgpOwogCmRpZmYgLS1naXQgYS9XZWJDb3JlL2luc3BlY3Rvci9mcm9u dC1lbmQvV2F0Y2hFeHByZXNzaW9uc1NpZGViYXJQYW5lLmpzIGIvV2ViQ29yZS9pbnNwZWN0b3Iv ZnJvbnQtZW5kL1dhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5qcwpuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwLi4wZjEzOTdiCi0tLSAvZGV2L251bGwKKysrIGIvV2ViQ29yZS9p bnNwZWN0b3IvZnJvbnQtZW5kL1dhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5qcwpAQCAtMCww ICsxLDEwOCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgSUJNIENvcnAuIDIwMDkgIEFsbCByaWdo dHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5k IGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJt aXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6 CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIK KyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQg d2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2Yg SUJNIENvcnAuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVz ZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBz b2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQg Q09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VM QVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdI VAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKK1dlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUgPSBmdW5jdGlv bigpCit7CisgICAgV2ViSW5zcGVjdG9yLlNpZGViYXJQYW5lLmNhbGwodGhpcywgV2ViSW5zcGVj dG9yLlVJU3RyaW5nKCJXYXRjaCBFeHByZXNzaW9ucyIpKTsKKworICAgIHRoaXMuc2VjdGlvbiA9 IG5ldyBXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24oKTsKKworICAgIHRoaXMu Ym9keUVsZW1lbnQuYXBwZW5kQ2hpbGQodGhpcy5zZWN0aW9uLmVsZW1lbnQpOworCisgICAgdmFy IGFkZEVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJidXR0b24iKTsKKyAgICBhZGRF bGVtZW50LnNldEF0dHJpYnV0ZSgidHlwZSIsICJidXR0b24iKTsKKyAgICBhZGRFbGVtZW50LnRl eHRDb250ZW50ID0gV2ViSW5zcGVjdG9yLlVJU3RyaW5nKCJBZGQiKTsKKyAgICBhZGRFbGVtZW50 LmFkZEV2ZW50TGlzdGVuZXIoImNsaWNrIiwgdGhpcy5zZWN0aW9uLmFkZEV4cHJlc3Npb25BbmRF ZGl0LmJpbmQodGhpcy5zZWN0aW9uKSwgZmFsc2UpOworCisgICAgdmFyIHJlZnJlc2hFbGVtZW50 ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiYnV0dG9uIik7CisgICAgcmVmcmVzaEVsZW1lbnQu c2V0QXR0cmlidXRlKCJ0eXBlIiwgImJ1dHRvbiIpOworICAgIHJlZnJlc2hFbGVtZW50LnRleHRD b250ZW50ID0gV2ViSW5zcGVjdG9yLlVJU3RyaW5nKCJSZWZyZXNoIik7CisgICAgcmVmcmVzaEVs ZW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigiY2xpY2siLCB0aGlzLnNlY3Rpb24ucmVmcmVzaEV4cHJl c3Npb25zLmJpbmQodGhpcy5zZWN0aW9uKSwgZmFsc2UpOworCisgICAgdmFyIGNlbnRlckVsZW1l bnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJkaXYiKTsKKyAgICBjZW50ZXJFbGVtZW50LmFk ZFN0eWxlQ2xhc3MoIndhdGNoLWV4cHJlc3Npb25zLWJ1dHRvbnMtY29udGFpbmVyIik7CisgICAg Y2VudGVyRWxlbWVudC5hcHBlbmRDaGlsZChhZGRFbGVtZW50KTsKKyAgICBjZW50ZXJFbGVtZW50 LmFwcGVuZENoaWxkKHJlZnJlc2hFbGVtZW50KTsKKyAgICB0aGlzLmJvZHlFbGVtZW50LmFwcGVu ZENoaWxkKGNlbnRlckVsZW1lbnQpOworfQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9u c1NpZGViYXJQYW5lLnByb3RvdHlwZS5fX3Byb3RvX18gPSBXZWJJbnNwZWN0b3IuU2lkZWJhclBh bmUucHJvdG90eXBlOworCisvLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCitXZWJJbnNwZWN0b3Iu V2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24gPSBmdW5jdGlvbigpCit7CisgICAgV2ViSW5zcGVjdG9y Lk9iamVjdFByb3BlcnRpZXNTZWN0aW9uLmNhbGwodGhpcyk7CisgICAgdGhpcy5oZWFkZXJFbGVt ZW50LmNsYXNzTmFtZSA9ICJoaWRkZW4iOworICAgIHRoaXMud2F0Y2hFeHByZXNzaW9ucyA9IFtd OworfQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24ucHJvdG90eXBlID0g eworICAgIHVwZGF0ZTogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgdGhpcy5leHBhbmRlZCA9 IHRydWU7CisgICAgICAgIHZhciBwcm9wZXJ0aWVzID0gW107CisgICAgICAgIHZhciBleHByZXNz aW9uQ291bnQgPSB0aGlzLndhdGNoRXhwcmVzc2lvbnMubGVuZ3RoOworCisgICAgICAgIGZ1bmN0 aW9uIGFwcGVuZFJlc3VsdChleHByZXNzaW9uLCByZXN1bHQsIGV4Y2VwdGlvbikKKyAgICAgICAg eworICAgICAgICAgICAgaWYgKHR5cGVvZiByZXN1bHQgIT09ICJvYmplY3QiKSB7CisgICAgICAg ICAgICAgICAgLy8gV3JhcCBwcmltaXRpdmUgdmFsdWUgd2l0aCBvYmplY3QgcHJveHkuIFNob3Vs ZCBiZSBwcm9iYWJseSBkb25lIGluIEluamVjdGVkU2NyaXB0IHRvIGNhcHR1cmUgbmljZQorICAg ICAgICAgICAgICAgIC8vIHN0cmluZ3MgYW5kIHJlZ2V4IGZvcm1hdHRpbmcuCisgICAgICAgICAg ICAgICAgcmVzdWx0ID0gbmV3IFdlYkluc3BlY3Rvci5PYmplY3RQcm94eShudWxsLCBbXSwgMCwg U3RyaW5nKHJlc3VsdCksIGZhbHNlKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICAgIHByb3Bl cnRpZXMucHVzaChuZXcgV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnR5UHJveHkoZXhwcmVzc2lv biwgcmVzdWx0KSk7CisgICAgICAgICAgICBpZiAocHJvcGVydGllcy5sZW5ndGggPT0gZXhwcmVz c2lvbkNvdW50KQorICAgICAgICAgICAgICAgIHRoaXMuX3VwZGF0ZShwcm9wZXJ0aWVzKTsKKyAg ICAgICAgfQorCisgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgZXhwcmVzc2lvbkNvdW50OyAr K2kpCisgICAgICAgIHsKKyAgICAgICAgICAgIHZhciBleHByZXNzaW9uID0gdGhpcy53YXRjaEV4 cHJlc3Npb25zW2ldOworICAgICAgICAgICAgV2ViSW5zcGVjdG9yLmNvbnNvbGUuX2V2YWxJbklu c3BlY3RlZFdpbmRvdyhleHByZXNzaW9uLCBhcHBlbmRSZXN1bHQuYmluZCh0aGlzLCBleHByZXNz aW9uKSk7CisgICAgICAgIH0KKyAgICB9LAorCisgICAgYWRkRXhwcmVzc2lvbkFuZEVkaXQ6IGZ1 bmN0aW9uKCkKKyAgICB7CisgICAgICAgIHRoaXMud2F0Y2hFeHByZXNzaW9ucy5wdXNoKCJkb2N1 bWVudCIpOworICAgICAgICB0aGlzLndhdGNoRXhwcmVzc2lvbnMucHVzaCgiZG9jdW1lbnQuZG9j dW1lbnRFbGVtZW50Iik7CisgICAgICAgIHRoaXMud2F0Y2hFeHByZXNzaW9ucy5wdXNoKCIxMjMi KTsKKyAgICAgICAgdGhpcy53YXRjaEV4cHJlc3Npb25zLnB1c2goImJsYXEsZTI6MTIzJCUyIik7 CisgICAgICAgIHRoaXMudXBkYXRlKCk7CisgICAgfSwKKworICAgIHJlZnJlc2hFeHByZXNzaW9u czogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgdGhpcy51cGRhdGUoKTsKKyAgICB9Cit9CisK K1dlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5wcm90b3R5cGUuX19wcm90b19f ID0gV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnRpZXNTZWN0aW9uLnByb3RvdHlwZTsKZGlmZiAt LWdpdCBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuY3NzIGIvV2ViQ29y ZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5jc3MKaW5kZXggYTNmNmVkMS4uZWM3MmNk MSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5jc3MK KysrIGIvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5jc3MKQEAgLTEyMDYs NiArMTIwNiwxMCBAQCBib2R5LmluYWN0aXZlIC5wbGFjYXJkLnNlbGVjdGVkIHsKICAgICBtYXJn aW4tYm90dG9tOiAxcHg7CiB9CiAKKy53YXRjaC1leHByZXNzaW9ucy1idXR0b25zLWNvbnRhaW5l ciB7CisgICAgdGV4dC1hbGlnbjogY2VudGVyOworfQorCiAuc2VjdGlvbiAuaGVhZGVyIHsKICAg ICBwYWRkaW5nOiAycHggOHB4IDRweCAxOHB4OwogICAgIGJvcmRlci10b3A6IDFweCBzb2xpZCBy Z2IoMTQ1LCAxNjAsIDE5Mik7CkBAIC0xNDA5LDYgKzE0MTMsMTYgQEAgbGkuZWRpdGluZyAuc3dh dGNoLCBsaS5lZGl0aW5nIC5lbmFibGVkLWJ1dHRvbiB7CiAgICAgei1pbmRleDogMTsKIH0KIAor LnNlY3Rpb24gLnByb3BlcnRpZXMgLmRlbGV0ZS1idXR0b24geworICAgIHdpZHRoOiAxMHB4Owor ICAgIGhlaWdodDogMTBweDsKKyAgICBiYWNrZ3JvdW5kLWltYWdlOiB1cmwoSW1hZ2VzL2Vycm9y SWNvbi5wbmcpOworICAgIGJhY2tncm91bmQtcG9zaXRpb246IDAgMDsKKyAgICBiYWNrZ3JvdW5k LWNvbG9yOiB0cmFuc3BhcmVudDsKKyAgICBiYWNrZ3JvdW5kLXJlcGVhdDogbm8tcmVwZWF0Owor ICAgIGJvcmRlcjogMCBub25lIHRyYW5zcGFyZW50OworfQorCiAuc2VjdGlvbjpob3ZlciAucHJv cGVydGllcyAuZW5hYmxlZC1idXR0b24gewogICAgIGRpc3BsYXk6IGJsb2NrOwogfQpkaWZmIC0t Z2l0IGEvV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5odG1sIGIvV2ViQ29y ZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5odG1sCmluZGV4IDZmNWRhNDMuLjYwMTYx MzQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuaHRt bAorKysgYi9XZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmh0bWwKQEAgLTYx LDYgKzYxLDcgQEAgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KICAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIg c3JjPSJCcmVha3BvaW50c1NpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0IHR5 cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJDYWxsU3RhY2tTaWRlYmFyUGFuZS5qcyI+PC9zY3Jp cHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iU2NvcGVDaGFpblNp ZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KKyAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlw dCIgc3JjPSJXYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUuanMiPjwvc2NyaXB0PgogICAgIDxz Y3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9Ik1ldHJpY3NTaWRlYmFyUGFuZS5qcyI+ PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iUHJvcGVy dGllc1NpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2 YXNjcmlwdCIgc3JjPSJDb2xvci5qcyI+PC9zY3JpcHQ+Cg== 39115 2009-09-05 05:55:11 -0700 2009-09-05 05:55:11 -0700 WebInspector.ObjectPropertiesSection - based screenshot Picture 19.png image/png 182499 pfeldman iVBORw0KGgoAAAANSUhEUgAAA50AAAJeCAYAAAA3J2HkAAAPRmlDQ1BJQ0MgUHJvZmlsZQAAeAGt WHk4lF3/P/fMmLEvYcg6logoyb5mGSn7Hsk29r0Ze7YoZV+iRZZshRRJSSQkSVnTIolKUiFPZMvy nqGe53p/v+u93n/ec19z35/zOd/lnPM9933OdwBg43MODPRFAQD8/IPI5ge0CYdt7Qi4IUALGAET vHDOJEqglqmpIRT5D2XhJUCoTc+lqbZYOWPydn67MCv2mq5Z0VRo8j8o/aGZydAhAIgUJDg8tvB+ KnbZwpZUHBoUGARlPKmY5OnsCnEkxFJkS3MdiMshZvbYwnep2GULd1JxCMmDqvsaAOw2f1cvfwBw UxBruLpRSLCZ6tfVlULygzgDAJSGn18AtM/aB/mdpEAy1GVdgliUOi/wCYsT9K3MCABN0z9cABmA GkcA+BL/4cTg2PHVkB/9h5sz35wrBN9Lcd8nu2kOYdSGtt5tbMyJwb5lAbCWubHxq3hjY60EAPRb AFp8ScHkkE1ZOBCkG4D/Vt8a828NNAwONcACwAu8QRyRVVQfepiGgH1O+5xBjRnDWsguyOnPVbS9 kDeKX1NgjEAR2hCJFP0lFiw+IWEl2SYlIZ2xe1nGZe/zffpyrQqKigVKayrWqlfUZjXkNUP212ut 6KjrxhPb9Zb0hQ8aHPI2OGWYZ1Rj3G4yZDprzmAhYWluFWldZTNsS28nf8TWnnI01uGUY6wTxTnL pYn0zY3f3dLjjGeb14rPHl8Xv3T/yoCzgR7HdMm7KDxBbMFsIVyhgmE7w/dEyB1Xi9SJOhCtF6Md q3RCMo43njF+9eTMqQ8JL08/OdOQeCUpIzk8xTnVIE0pfWcGbyZrFk3W/NnR7M6cqnPp5/0uGFzc lcuYO3vpVV5zfkFBSKHBZYHLM0WNxQkl5qWCpTNlLVeyrgaVH6kgVu69xl+Fq5q53n/jWnVkDfEm +83vtW9v9dS13r53p7q+7G5uQ/K9442uTZr3ae43NFMeyD1YbXnaWtIW+9CpXeuRcAe64+Pjjs6S J5FdZk9Fnv541tSd0GPci+9911fW7zEgPvD5ecmgwwueFy9eZr+yfM31emSo5A1pWGj43ducEaN3 mHeNo0FjMmPf39d+oHyU/fh9/MonuwnGiXufPSfxk+1fgr+Kfx35ljdlOY2ezp3ZMVP0nft7wvfl 2by/XH4Q5xjn0ufZ5lN+0v/MWZBceLlYsXRjeX3VaWMDxp8LmIKryHakCuWFtsVE0wzjEumiGO4y 87IWsPNy+nElbY/h1eEbElAVzCR8FFYTuSi6KmYr3iQhJpm6a07abnerzI69J2XH5DTkMxU+Kskp h6k0qs6rS2kc0UyGq+CdDkaXQNyvZ33AWz/iYMKhdIMLhoVGpcblJhWm18xqzR9ZjFj+sMbacB/e abvPTuPIAXuTo9YODo4kJ3/nEJcTpAzXQrdq94cePZ6Pveq8C30SfYP8XPxNAzQCpY8JkFkpaMpi 0EzwRMho6Juw1+GvIgaPd0c2RuVHR8TYxaqfEIljiJuPHz357FRDQtnp9DMRiR5JJsmKKXwpG6lj aS3pBRlJmf5Z1mdVswVzQM7oufvnL1w4dlE/VyB37tKjvJx89wL5QlRh7+XComPFViXqpTvKmMsW roxcfVheXpFSGXjNskrpOu/11Rvvqh/UFN+Mq3W9RawTqVu5/fTOxXrfu5oN7A1f7rU25jdF3Ldt Vnkg0IJu+dLa3Xb3YUH7mUeUDrvHyp0snR+f1HedfRrwzKhbqoepZ6a3r6+6P3XA47nG4LbB8RfV L0Nfqb5afd02dP1N7vDpt8dGbN6pjvKMzo/1vi+BK0FznG584NO5CdvPfJ9HJvO/2H8V+jr/7clU 1rTNDM/Mq+/ZsyZ/4f5q/3FiTmseMz/ws3IhfTFhKWf5yS/jNb/N+DMDGUACV8EyQkLeok6hHTBh NP24VDpfBhXGGeYkViY2322N7GucEnhDLh/u49vjeBJ4U/nO8RcLXBdsIDwUeircK9Iv2rWjSaxS PGdnpISzJHGXpBSb1C/pz7sH9zTLFO4NlzXbJ7xvRq5ePkZBT5FBcVCpUNlfhagqpIZS+6TeqVGp eXq/k5aM1qL2XZ3juuZERT2BA7QH5vRHDz47dNfgsmGCkYexrvEXk1TTfabvzc6Zm1pwWAxbllr5 WyvaAJtnh3Nt3e1k7BaO3LM/flT96LpDq+MpJ0Nnduchl3ySgyuf65DbOXdzj20eg57nvY56E7xH ffJ8bfxY/Dr8owMUA34E1hw7RlYgL1HuBAUGiwa/CkkIlQ0dCTsTLhf+ISLrODESG9kbdSnaO0Y1 liF26ERJnHu8UPyrk4mnbBNkTjOdnjrTk3gzKTs5LMUmVT6NJe11emqGaMb9TIcsXFbdWe9s0ez3 OZfPOZ4XPD9+oeoiJVcxd/lSQ15ovnz+fEFdYfBl5cvrRY+Kk0vMSvGlw2VFV7yuKpRjy99U1Fam XfOu0r0ucH3xxvPqmpqMm2FwfdnUmdzWv6NRv/cuoYG+YfbeYOOdprz7sc0eD8xbtFqV2uQeyrUr PFLuUHms1Cn7RKyLo2vl6Vi3dE9Fn/4A8yDTS9IQ/q3n2JlPHVOfF6Oo8d/a+6h7AlYBgPNfADhi CoDlJQDSrAEQLwWA0wkAUybIKQOU/U6AEjoAEKIA+LN/8AAlYA73kBiQCUpAHWgHz8EHMAvWEUaE F5FC1BBjxAkJQs4gBUgd8gyZQKFQgigNlCMqDlWO6kUtoYXRJuhI9DX0MIYJo4UJwVRhxmkEaGxp smn6sSxYI2wytgtHhzuES8H1026nJdFW067TmdCV0C3Tm9FfY6BhcGZoZuRljGAcYdJjqmUmMJ9l oWOJY9lgjWJdY4veBradYEezn+BAOGI5AWccngafwsXNVcGtzf1hexKPOs8LXi/eVb40fiH+WwL6 AsOCgQQcoUhIXWhEOFbEWFRpB8+OebHHcGU7SIhJzEjW7zolZSUtKr2wu3tPhUzy3iBZl30Wcnry qgq7FUWVeJW5VXhUhdWk1VU1Dmpa7nfQ8tD214nSzSHe1HupDw7uPeQGv39dRismEqZuZtUWwNLO qslG7HCG7coRJ/sOB05HB6cy5ymSgutpt1EPA89Ob3ufQT8puE77jvGR/SktwfiQoNCX4cSI4ciG 6ORY4omZ+IRT+ITiMzKJLcmWKZ/S4jN2ZY6eLczxPa9xkTN3Nq+3oPVyfXFj6cMrveUDlc+rum60 1wzWTt/mqtdpCGm8fL/1wVDrUrt4h2dn01OR7pTelQHHwXsvF4Yc36qMtny8M+E9afrVZfrJX+T5 24v2y5RfbKvOa9JrS+tJG9iN+M3vhzDQBkdBCEiF0a8HXWAEzCAAYUOEETmEiNggXkgkko6UIg1I H/IFhYaxV0c5wNhXoF6hsWgltA+6AD2AwWHUMEEw8p9+R34Ay4o1wWZgB3B4nD2uBPeNVoE2nraf TogumK6LXpg+mn6YQY2hgBHF6M04yLQfxl2EOZeFnSWDlZU1m42HrXjbbvjVMmIf4wjmxHBm4AXx N7mIXMPcwdvZt9fyWPGs8BbxHeT7yV8oYCSwIniVYCVEI3RLmCQiLPJDtGNHgViouMlOCQmsxEfJ ll2FUtHSDrvV9wjs2ZAZ3ftAtnjfGblw+WiFFMXzSsXKFSq3VJvUHqp3a7zR/LZ/TZtZR1KXSPTU yzjQpP/9EKuBuqGH0QXjblN6s4PmmRYjVjLWCTbjtvp2N+x5jqY6rDl5Od8m0bhaul11X/W09qrz 4fQN9RsJ0A28SRakZAajQyJCZ8N9IuYi06NlY3pO+MbTnSxJUD79LNEhaTolIg2XfjFTKKsuWzun 57znRf7ckbzCArPLNEX1Jd5lPFe6yxMqiVWs18er227W3rp++0F9RwO5UaxpuDm/hdSm2L790frj +SfLzxh6RPuMB44P1rycHpIaVhkhjoa8rx2nmbCffPRNdDr6+8APzDzXAv1i/3LAyugqfg27NrKe v2G8GX9l4Aey4XvfB77CuOPhG6+D2COhyFnkJjKA/ETxofRQFFQJ6jWaFX0InYjuxnBiHDAVmJ80 OjRnaT5hVbBZ2GmcAa4GvtunaZfpAui+0LvRf2BwYhhldGL8zBTGzMxcxWLGssZ6nc15G+e2LvZw DjGOfs5ovDT+A1cBt9t2ZR4+ns+8V/k8+MX5JwWuCQYQlIVwQm+F74p83sEpJieuv9NM4rCkwy5v qTDpuN2Ze67KdOyd3sctR5SnKBQodisDFQ3VeLUeDX5Nz/218Nyqr3tFj/5AqP7kITuDx0Yyxtmm iFmcBYtlpbXFYZRt7RGHo2iHOMcVZ3+X965H3N56ULwEvT/5+viNBZgFNpOlKLnB9CHxYUh4ynH3 qLKYlhPN8aWnok6bJYonraQ8SEvOcM7SypY8h78ALn691JtfU5hTFFXiW2Z7VbuCULlY1X4jpcay VvTW4u3O+vMNzo38TX3N4S18rW0PAx+JdUx21nUlPXPtUenj6P/8/M6L8Fd7Xo+9SX+rOvJltPD9 kY+i48sTHyZHv+p8i5wqmm6Yafv+YLb8r+QfVnPccz3zIT8Ff1YvKC+0L+5frF4SXEpbmls+tFy8 vLxiulK6Mv5L9Jfbr7JfE6tiq+6rmav3VyfX2Nc017zXctZa16bWudf112PW76xPbYhs2G1kbnRS 47+VL1H3D0CvE+AbQCYY6uhuVv93Nz/fYJiTbZZt8M7o72JsAp9UPBkYZErNBfHwt0IJsSDCJytM h1jdvfQO/sYEV2ddA4j5IC8T4aljDDHM0xBDd7KeOcTQDnLY2/kQ3PcAM8Tebv5WFr/5sEDfzRyX KpMUGKRNleeGOM+NQvwjUxfhaWnzW7eDHGxuBbEolBn0CTCgylN9Lbm66f7uGwrj72tsCHnYZxSH V9BBav85IJYEesAZkIEHcAPSwBDoAN3fdwLkCbAeAFvdAAXKjW/K/ZGy3qx7/R8taeC+aS9kU8cH TEAdP0evODK0tWX9CTz5kaGM/x9G5prMF5nVP7VNj76bXv9oGMDavzNblrZ6t9XiBVyh1B+e9EeD 6tmv1j3kQkC4irUnRgwji5HHaGPUMRoYZUDA4DE8QBojh1GCZwBNjCpsU+6Zqp/6uy9bc+Py9xgN YD/cQPDmjPj/zf4/r/BkArZydzjLAAvXRl48FbWxYan5+7+VILcwmNcDoBMQGE728vAMImjBfy7c pAgH/Um7pQiyMjLK4F8YLnN7GIN7VQAAAAlwSFlzAAALEwAACxMBAJqcGAAAIABJREFUeAHsfQeA nUW1/9neSzbZ9LJJSC8kIRASIBBCEZQgoMJDRYIF8Sn4FFQQRMTCk/D0LxZAkfKABwoiQWlJIJBQ EiCV9Eb67iab7b3c//nN3XN3dvZ+3713SxLgTPLtzJw5M3Pm95U7v2/KR6ROEVAEFAFFQBFQBBQB RUARUAQUAUVAEVAEFAFFQBFQBBQBRUARUAQUAUVAEVAEFAFFQBFQBBQBRUARUAQUAUVAEVAEFAFF QBFQBBQBRUARUAQUAUVAEVAEFAFFQBFQBBQBRaCnEYjr6QqOQfkfxzYdAxi1SkVAEVAEFAFFQBFQ BBQBRUAROEYIBI5RvT1S7fFO0I53+3rkpGihioAioAgoAoqAIqAIKAKKgCKgCMSIwHFLVI8XUtdV O7qaP8bzqeqKgCKgCCgCioAioAgoAoqAIqAIHBUEukomu5q/y408VmQtlnpj0XUB6UpetyyNKwKK gCKgCCgCioAioAgoAoqAItBTCHSFHMaSNxbdbmnr0SRlfnWh4Uj305EGh9OR/KLj+uHy2DqR8tu6 4cKaP7pzFw47yBQ/xS/SPep17ej1o/ePPj/0+aHPD78npH+a3j96/+j943+P+KV25/2DsmJ1LZwh 0vnzK1fs99OJ1SZP/UiGemaMMiGa8r10vORSdaR00VNfEVAEFAFFQBFQBBQBRUARUAQUgY8DApFI ole6l9zGJBodWz/qcE8Rt0jleqWHk4eThWtgtHqSN1Z9yae+IqAIKAKKgCKgCCgCioAioAgoAp1B IFZiF61+OL1wMtjsJZf2REoXvaj97iZefuV5pblyN+42xivdSy75kQ4AI+mJfjhf8yt+ev2EuzOi k+n9o/eP3j/R3SvhtPT+0ftH759wd0Z0Mr1/9P45nu8fXJ9+zm8arV9eN82NS51ecqT7pUn+qPyu nAC3Aq+ywsldmRuXsl25G4deOBkAgjxcGvJEcpI/kp5XuubvPPbAVPFT/Dp77+r1o/ePPj/0+aHP D6/eSWS53j96/+j9E/k+8dLojvvHq2zIUb7rXJkbF31X7sahF07mJ5eyo/K7cmFJBX5luGmR4ijT 1rHDblq4OGS2c/PbaXY4Wj07j4YVAUVAEVAEFAFFQBFQBBQBRUARiISAF6Fz80XSc9P94m4a6nJl keK2fa6unRYx3FWy5ZXflccSt3W9wnbDbB3I3bjoesklXX1FQBFQBBQBRUARUAQUAUVAEVAEjiYC XmTOlbtxsdGWRxNGPlsvmni4ukQWld8VIuaV15XbcTsMA+24hMV30924reemhYtDBgeQvfKGSzOZ rD9+On5pUoSfjl+a5g8i4IeRX5rip/gBAb9rxC9Nrx+9fvT60fvH7xnhl6bPD31+6PNDnx9+6zLl GSE+nie284tHk2br2GHUYcftsJvmZ4+d5hl2yZenopPglc+We4VRVLg0kYnvpWfLAU48BI6zy0CS Gxd15LfT7LDo+Plufj/dcGmavz3+4TDykyl+il+s96x9Pen1o9ePXj/2HRFbWO8fvX/0/ontnrG1 9f755Nw/ONeuC3f+XT03jjJEJr6Ua8fDhUUmvl1WtGWInvh2WSLz9Tv7wHDz+cWRBsNEJ5IPg10d kYkccTg77hWGHuoPR06RFo2z7Y9G39XR/O3PlYtPpLjip/jZ93ek68VN1+tHrx+9fty7Ivq43j96 /+j9E/394mrq/aP3TzT3D64T10Em14+dboeRR+LhfMhQf7g0Oy/CcKInYckvcfjibF2R+frRAOEW 4Obxi9tpEvbyUY+dZofFhmhlom+XKTIpQ+LqKwKKgCKgCCgCioAioAgoAoqAInA0EXCJmxsXW0Qu PuQSFt+ViVx8Nz1c3Ja54Wji0PF0sRIwV98rHkku6bYPUDAaKTIYjbDEvXzRQ35bX8pDuuukLFsu +UXmxkXu5bv6btwrn8hdfTcuel6+q+/GvfKJ3NV346Ln5bv6btwrn8hdfTcuel6+q+/GvfKJ3NV3 46Ln5bv6btwrn8hdfTcuel6+q+/GvfKJ3NV346Ln5bv6btwrn8hdfTcuel6+q+/GvfKJ3NV346Ln 5bv6btwrn8hdfTcuel6+q+/GvfKJ3NV346Ln5bv6btwrn8hdfTcuel6+q+/GvfKJ3NV346Ln5bv6 btwrn8hdfTcuel6+q+/GvfKJ3NV346Ln5bv6btwrn8hdfTcuel6+q+/GvfKJ3NV346Ln5bv6btwr n8hdfTcuel6+q+/GvfKJ3NV346Ln5bv6btwrn8hdfTcuel6+q+/GvfKJ3NV346Ln5bv6btwrn8hd fTcuel6+q+/GvfKJ3NV346Ln5bv6btwrn8hdfTcuel6+q+/GvfKJ3NV346Ln5bv6btwvH9JcfXvt J9LEhQtD5sq94iJ3falP5G59XnJXT+Kefjjy5anMCa6+HZew+FKOxOHbYaTbcTssabZMwkiDQxwH wHCnztq6dphVQ3lEjvwSFh96fs7OY4f98thpdh47bOv4he08dtgvj51m57HDto5f2M5jh/3y2Gl2 Hjts6/iF7Tx22C+PnWbnscO2jl/YzmOH/fLYaXYeO2zr+IXtPHbYL4+dZuexw7aOX9jOY4f98thp dh47bOv4he08dtgvj51m57HDto5f2M5jh/3y2Gl2Hjts6/iF7Tx22C+PnWbnscO2jl/YzmOH/fLY aXYeO2zr+IXtPHbYL4+dZuexw7aOX9jOY4f98thpdh47bOv4he08dtgvj51m57HDto5f2M5jh/3y 2Gl2Hjts6/iF7Tx22C+PnWbnscO2jl/YzmOH/fLYaXYeO2zr+IXtPHbYL4+dZuexw7aOX9jOY4f9 8thpdh47bOv4he08dtgvj51m57HDto5f2M5jh/3y2Gl2Hjts6/iF7Tx22C+PnWbnscO2jl/YzmOH /fLYaXYeO2zr+IXtPHbYL4+dZuexw7aOX9jOY4cj5ZF0Ow/CrrNldhh6iNsyNyxxW8+VSVzKE1/k 4kMOJ3HxbZlRsHQk7ulHS7JQgKtrx/3CkhbOt2Vu2I7b9UMuaa7cjksYQIXTR7o4O11k4rv5RR6t r/nb4x8tbqKn+Cl+fvenXCdevl4/ev3o9eN1d0SW6/2j94/eP5HvEy8NvX/0/rHvH1wPrvOT2WkS Fh/lICzxcL6bbuvYYSlLfEmTOHw4L7mbZpTD/bHBCJduy2zdaMOiF86HTA7U05mw5AvnuzKA5doB nWidnT/aPLae5m/D38Yl2rDip/jJ/RvtNWPr6fWj149eP/YdEVtY7x+9f/T+ie2esbX1/tH7J9z9 g+vCdhIXH2kIu3GRu76ta4cxfVacyMV35YiHS7P1IoUlvYMfDoQOSixw9SQuPvJIOJzvJbPlErbX dUImcglLXOqUOHwAZeeHDpzo2GHoilx8W2aHkc914dJtmR128yIeLt2W2WHN3xGBcPjYMjvcMbfi Hw4fW2aHFb+OCITDx5bZ4Y659foLh48ts8OKX0cEwuFjy+xwx9x6/YXDx5bZYcWvIwLh8LFldrhj br3+wuFjy+yw4tcRgXD42DI73DH3sbv+YBecbZ8tC6a2/UWam27LoClxe12mnUfSxbfz2Hq2XMLh fC+ZLUc4rEsMK+26UEgcfL+wnS7rMkUmfgqXkd16JLeaJmnwxYkMcVfuyuw8CAN4O4+kR+trfsVP r59o75aOenr/6P2j90/H+yJaid4/ev/o/RPt3dJRT+8fvX+O9v2Da06cXH8iEx/pEg7nQybyeg5X 8VHOB8J2GkcNvxGZ5IEcDnG0X3xXhjic6ARjbX/tfG1Sj1BnSKecHNdHFZDZcjccLi55XB/lpfLR 9zvf+c6U888/f86wYcPOTEtLG4IEdYqAIqAIKAKKgCKgCCgCioAioAh8EhGora3dw275okWLlvz2 t79dxxgU8VHbigV4FUghDi8nOki3CaQbRrro2j7kUTtkjORsnXBhkdm+G5a412gm0sMd+TfccMOp l19++bdTU1On1NfXU0uLPTU5kumarggoAoqAIqAIKAKKgCKgCCgCisDHC4H4+HhKSUmhhoaGNY8/ /vi97FZwCw/xIWQzkg9AhFjZupBLXMLhfFvmhhFv5xLaxcJHhDAiVcKuL2lCHO24G5Y1l7Yu7EAc afbR/wc/+MHlOTk55yrhBIzqFAFFQBFQBBQBRUARUAQUAUXgk45AIBCgxsZGYvLZPz8/v/qpp57C aGcZH8Kx4Hs5kErX2fp2GLpSJvLYaW4ZnnEZefRUiDLBr3IxEr5LOBF3CafoIy21f//+ZzQ1NRkz 4uL8qjEq+kcRUAQUAUVAEVAEFAFFQBFQBBSBTwQC4El9+/adzY3FPjjgT8K3JGz7Ns+SsPhCRF3C hfxddrGs6XQNkLjtIxwuLnI/XwCCjoTjmWgOAZP3c8L0Sw4epPf+uZAOrF9PDZWVJktyVhYNnDSJ pn92HvUeMICSkpIoGvJql7nun89S0QfrqK4Ma3SZCefmUr+Jk2jyZy/pVJmFxQfp+df+SRt3rKfK mgpCXZnpWTTxhMl00ZxLqH/f6O00BukfRUARUAQUAUVAEVAEFAFFQBH4RCLA3GYwN1zIJYiTkCfI ZAotsBGehrDroCt5bT3IELd9yStyiXv6doHhlOx0CYfzbRnCkQ4hlZLPHu2UvNAZs2zZslfCGSYy EDZMvV3zyiJ66y9/pUye25zfN5/6DBpkyFzJ/v1UXHyIqhsaaNbXrqEp551r5j/7EU8pc+PiV2j9 /z5I6SnJ1HdAf8odNJRbFkdl+/dSMRPcmrp6mvTlr9L4c86LuszFb75Mjyz8C6VmJrGNfahvfj9q bm6mIiaiJQeOUGNNM33l4q/TOaedH7FMwUB9RUAROL4RqDm8g7YXp9KE8YPM1I7j29qPvnWK90fz HOK8bSvi+2TCIIrljfhHs7VqtSKgCCgC3YvAGWeccR6XuIUPkEwhjxIW35VL3M+HoZIu4XC+LUO4 nYu0plNIofjILKRQwuKL3PWR7pJMicO3w9CFTTggz7/mmmu+xL6nw1zmtYsW09t/vI+GpqXRqcOG 0rnz5tGFP/wBnfKp82hgfQOlHyqm+uoq2vjWO5Tcpzf1HV5ACQneTUeZm5e8Qpsf/gONzE+lOacO p9Mvu4BO/9b1NOWCc2l4XjP1bymhxvIy2v7WmxSf24fyCoZHLHPJW6/QX575PeUMTqUps0fS5z59 Kd1wxY00Z+aZlJRXR/XpR6iiqoreWvEW5WX3oYJB/mV6gqIJioAi0DUEGnbTw7f9mrbnTqTxAzOD ZZVtpHt/9hsqzD+RxvZLD8oqWXbHs9Rn5kmUl+Rd5e7nv0/f+EkKXX7NBJLvPnlrE+1f/gT96pHN NG7mBMr2flT5FfGJTosV754Aq7loBf3iN+/Q2NPHUyZ+zSznl2apfeKCHy78Pl17ewpdEeV9cjwA pOfyeDgLaoMioAgAgYceeuhx9o7w4fI2JMPZ8qAk+BeEEs4rPZjalu7quXHRb+fH+jIxXKGQhZNL RZIuvpBMyQNfZPDlQP54jDr6udLiYnr/oUdodHoanZKRQUOaWyjvwAFq2bqVAi3NlHfwAE3iHW97 pWfQSi4LusOmnEh9eSTUy5UXF9GHTz9IkwsyaMakPpTdP4XSEngabEUhWxRP6fHlNHxoMncy82nF +gBtZ92Bk6fwyCVGtsO74sNF9BiPcPYZkUET5wzgEc4Makwpp+KaPVTTUEUt6dU08IQsSskbSBuX FhrdyWOm0KAB3mWGr0mlioAi0GUEUvIpt3gZ3bPsAvrstL7mLVjZh6vpb8uW0egTvkDzJvU2VRze /DrLmug/0gI8s8K71tQ81h/Ti5JYyUctVEBz1SZa/ko1zb/xc77lhjIc9UAz7XzzFdqZNY3Omdzv qNceqcJIeJftXEVvfFBLsz99GuW2kvpwskj1+KXvW/MveqV8Lv0ooeO14ZfmV+bHPS2tN98no6O/ T44HPPRcHg9nQW1QBBSBVgSETwnHghgjnJDDoQuCNPiQIQ1Owl5dFCnPTZeygqVE+CtGRFCLqp+E ir0OlI801Cc6CLuH6ECOrkDEd/zr//UC5TKpPJ0J5wg2s3dlBaV98AG1PPdPCjy3kNI3bqQ+VZU0 gkuGDnSRx8/tXvw85aW38AjkQOo1KIvXcMZTYnMhNe1dTk17llNC0wFKyYk3adCBLvL4uZfeeJ7i k1to+meGUf7gbErKDtDhlt205tBS2lD6JlUlHKK0XknUb0iO0YEu8qhTBBSBY4BASxbN+PwMomc2 UlFzsP79G1eZwNY3t5ut4YiaafubTxBdfQ4NxJPLz5nHdCD4QOPp9Pzf18XF4RHIL6F8tY5lYgtt uflX9LMPa46lEd51t+Itv44u3uXrH6MFC/5BJfJzyyWFk3lXECmlklb/bSld8cVplCJGhLL4pYWU PpGBQAvAagn1go4NCM38+YH2NyiWwIR3ei7D46JSRUAROEYICHcSfmXzKsjsuIThex1oBtK6xcGA aJxdoYRdA6UcV464NBQ6dlzk8HEArHZhjHT6HbRtG52Ynk5DeASyDx+5TDwzS49QyrvvUcr771Nm WRnLiPokxBsd6CKPX5lphetp6oQ8SuubRWn9svnIoNTsZkpq3ElJDTsoNavJyNL6cTrrQDe96APf Mnce3kgjTs6nfoN7UXavTMrMSqW45Do61LSNSpt2U2JaM2Vmp5m0voNyafj0fEIePzs1zf/aUHwU n85fA43Ue9I5/OR4jLYWNvF9WEo73l/JcXZb19P+Csa2qZBWPEP0zdnDqI47y4GKHfTwLbNp9mwc 8+m5tYfa7l/iKbq5DbRxxRM0e84cmjNnNt3ywFIq9Xi+BSviV5Gt6fuWPkA33LuIdqx9geab8jn/ w8upojW9/tBaeuCW+a11z6Y7X9jRmreali64gRY8t5wWPXBDyLYnVuwLle1rd6CeNix6OFQn2vbc jmra8cL/o1/ByAV3mrR7F+0Olle9m57m+oIYzKb5C56m3dVyHbIt9wZteeFe2DqfNoTSRKebfNjG D/49G4J4Gbxb8arf/QJ9+Z73WOFdmj8XNi6i0jCyasY2iPsLtAHnTXC3zlv9h4tYfjftqHHs5mvh nq1EZ0/sTU3uObbT+Bp6gs/bA0vlfNTT8gduofl3Phe6Niq2PEfzr/89PXBzN+rd8DAVNjk2Gzur acXTC0JtXfDAA3TL/BtoEZ/z4LVYT2tfeCCUPnv2nbR0S2nbtcTXi3+6f/k4bXBy3QcC1fS+Zc8t T6wgnJe29Pbh0h1LacENcg+yf+eiVn1/u+T+2vL+c9y2OXTOOXNowaIdVFG4gm7h8z6H79n5C57r iJl9Ln3s8rJX5e3Pn+KheOg10LVrgB+fYbkUy4WbId3mYRwNpYmO64fTERn8qB0qj+RQOZz4wVj4 v2IoUvHKUuLiS2MRl7D4IkNcZBFHOjPKK6h/UiL1Sk2hLJ5im5aZSSnZWZTE6zuTOJ6Sw6SR41kZ 6dQrLZX6JydRJufxc7kJldR3cC6l5vMoZ99sSu2TTcm90yk5J5GSeIQzJS+dZa1prAPdnHj/Mqta KmjgiDzKzEw3dsLWLLYnMyWR/UTKZnshy4Q8K4MGsG5VS3C3XD9bNU0RUAR6BoHU/uMItHPdrhKi hmJayJzzprtuYsmrtKO4gahkGz1DY2jW8CyWFdGfPzOf/pr3M3rpneX0yM+m0z3f+SGtwteyjMsg WvHf9J83baV7Hvk7Pfizb9Lyx35Cd/BIajQuUH+AVv+dCd53/kFXPPgE3XfrPFr+11vo7T1sB7ut L/2OHls+nf6+9B1a/OwT9JXpA1uLTaBA9WpaeM8tdGfDhfTE35+gW+cl0n03XUmL92CU0t/urc/8 jK6786804aZ76aWlS+nZJx6kU/qm0PCzPk9XcO4xV3+VfvX3v9OVs7EMoIgeueDL9LuFo+nB55fS 0pcepOmbf0dfvuCR1tFitqUkaMtdcVfQI0/cTSP5HWDPOJ7yu+JO+up1HfFKHXYW/Wweah1DtzKW d18zi/LCyGBaEPe76Lqb9oU9b/E5/enqyydSjrOe9/DWdzj3TTQytR4VtXPt0hL70uhBO+ix59eS GTOu2UmvPLacdix6nrYcxuhaM2148R7aMeY0mja4G/VGT6WBYRbXbHzmx3TT7xbSTfc9S8uXPktT G1bS8h2rqb71lxjXw3fueoxuQPryl+ieb7bQT75+ceu1xNdhhPRI5bcDiiNbn/kl/dfvCuleXE/P 3kuN991E971e5KqZeMOexXTx/J/QwuRv0iPPL6bFz/N9duVkwnmMZJfcX1//rzfoLr4/771pHi28 cz595gs30YR7HqEn+GXJjoX30Os7K9vV3e5ctkvRiCKgCCgCxwQBPK1dPiW8SriV+KIHQxGWQ+bn SBx+NC6iXpifHVNupIySDt8Oi1Ei9/KhhzRpeDhAjAxvPfxcPI9gpiSm8MghT0XjnWsTmMjF8TRa YhKHnWapro7iamoorraWMnm32dS4SorHqIRPuc1JCRTPI5EpeZmUnJtGCenJFM/kkJJgErumFoqr b+KRSpbxNLiErApCHr8yE9nOVCbGmamplMThZN7IKC0xiVITEpmdB6iuuYlqG5uonqfxNCW0UBrv mJsQ719m0Bj9qwgoAj2BQGPCADqdZ9j+dMMuumJgKW2ly2nOrJm0hyvbxLtiT45nYjHmczQoqYFq tr7HY6JE1549mpr2l1De+JlMaZ6iXUUVNDUni+/wak79Ci3a8CPqU8truKd8nX71+n1089vbqeLS cTyRtr3DMwEOvnlUxeNxOYP+9NoDdFp2AzVNvopm/HwhNbY0cDp/BiqwjdN70eZNe+iMk0bRmEAD Vdc2mhIaq9i79i+05YZTqKK6nibe8Ut6e+Fl9NLqAzSrcYu33WmH6B+/W0Y091d0x1WnU31lLeWN msIEvJrq44bTJMZm14ATaHhBAbU01NGRDe/RX7mqH//jRprSt5HqA1PoRwvuoKfm3U5v7biEPjsq mRoBw+X30Krbz6WWat48jZ/NjfYjvrmSNq7dRnWJiZF3L+XvkjWl9qMTw+wIHMQ7PF7NjNPkGcw6 F1bT1HGjaHBCI9UyN+wgq2VCb3DHefshn7fqDuctJ/9Uuun2JKo4fITqQ1N1G2jT4idoxo+fotQG /nA3N7nNuWnxNPFT1xLNf5Z21lxAQ7esoqVGeSut3VRKp5xeQS/+g+nrk1NoYm136k2iZvwOthnG 53UnLfzdKhpz/eN01SmDqKKO6NLbFtBLf5tnfqwD9TvM9TDmpsfpa0ivbaGzv/0Duvy+JeZamtsv LmK6b/kYKRR7EGZ7zPU375c0LK6CKhJ601hOf+TVtTy74FziX/h2bvfqlzg+gx6/99t8/Vcy7jk0 ZUALVR3Z4G/XkJGt53ke/e3dX9No7iM09eKL++6FdMc/3qXLhsdRbXMWzaX/R1nJ9m+yey7bmaMR RUARUASOBQIgKiCeoV8kDuPR2kpgQo9ZdCrg4CMNOiKTeOiRzGlwki66kg65hF09xEPOi3SGFJyA VAixG0bcPezskobG4EA8nC/p4ttldAinDBxI1YcPURJ/OzOeyWYcj2wSh3m40HyPM1BdTXE8xTa+ ooKSeGfYav68SkrvPh3KsQXNOX15lJEokae7JmSmUXwad+pS+RwK6WxsoQTuFBGTwkTWq+SjhfP4 uQG9B1JtWQOlJibzkUjpPDqbmZTKxDOVs3EXqamOEuPrKbGJO2vcmaotb6T+nEedIqAIHCMEmlNo 4oVziW5fQcsz9jD5+iL1iu9Dk1n047ffoj41L9CMK79KKU1sX0Zwh9v7v3sF3R8ydwx9KUtWZTLz G1NA8byhWLl5NMdTwQzu2D6THuW6Tc4/40KawpuPHcEDp6kGE3b5GYfHJNFJ1zxP1++6iG677gsc G0Hf+Z876bJpg0waHrQzeqXRweIjJl7dBObHjy/+ZnGyn914vrHe3DNOoMqS8uAvGH96KuhqqBaB lhqq5mcsXHIuLBpDg1OqifkpuwYmnvwsZpeCl3bsjC1jh1A12xJ2lRzPCFm76Dnak9a7A6kwBdh/ +EVibb85NI5Jp0tAiHzwYqJezQQSrqqimmrwCGYXTmbKMeetOOx5a2moJN4cvb1rOECLXyC6+NqB THycVnZIa6GMYacxVbqf1u3cT5Vv3M8c/2901cHb6Curt9OFeXuZhM6j7xUkUEZNd+rxy846XLiW i08x53twbguVVJhxVyotrDTXmdGS9LS29PLDKeZ+eGr1bqq9cEwwf6R0r/ItU6Q+8zJm4S00b2Fb 4pgsfgncFm0N1dKeLe9y+CuUXnuYqsw9Vk9mnDmS3fNGcj5cL6dTv/pCKmNYas0FPJfG5NfT4XIW NFZCo12vijqcy1ZT1FMEFAFF4NghYHMnPAkRhy8HkxnzwySPUe5QmJ9mpOMnWnwOGgeZOKTBiZ4b Nol+f6IlnXalfuXZegjjQMNELjJbLg2HL4ekR9y9ttfUqbRv8SJqzM3hDX+4g9OrF1FeHsVlM/mE q+LOBY+AxiXzW3YeWdxfWES9ePdav1HJlIKptKf4TZqWksSEM5kJJ8OUHE9xIJ1x/AaW145ihJMl PP2qmfYcqqLk4bN8y5w0cjq9s/UlSmhOoPTUZMpgwpmZzKQzITV4hrm8QCAIT1NdgAp3ltGsMZ/y LTPYQP2rCCgCPYNAI49Yns5F30G/fYAH6H57K9XxsNzo0+ex6AF6hFPuvqEXj9QFqIFHL+F+/I9V dNUEnmlhXIBqS4uptJaJh3lUN/OO2jKaU0sb317BL8jONfmd2Zmt+vD4H/LiKGukMn7eGI7EQjPR DyNCfNQ259PX791CV5fvpGduvYB+8b37aeLLd9Do5Nb6uILQMy+A3xzi508EuyuDPw9L3t1EPziz DyWbXO3/8Hu0ULkNNcBgC+0taaCx6cEWNVYXBTO02mlgYLK9aHzmAAAgAElEQVSIdY5hXfII+vY9 f6IE6IdVsIQ8kyWuuZYOH+aZJpbYBCPg1STcObEVX84UThY0IobzxuXU7l7HRPFy+n7vFgq0G8YN n9aQNIwu5hcZt/zmHqLtRL/9egEVDDyf6Hc/pHvWMo2/9iHKr2ukuu7WcwHmOKjm3sM1oXNaW7iD lrBsujl/wfTKOm5X6Pwdok2sMOb7oyijNX+kdO/yuQBTbtBHEPaMufYRWvi9UzkUdAE+58VFpc45 z6BRY/klzr830WFeX5vb+iLB5IhoV4COsA6VNfNso4B5CYRfYn6dTPVVjRRoV1bwfkOq33lGujpF QBFQBI4BAsKjpGqQShxwSENY/CDpCHK04GOvja/hqQgHueQ3Ao8/0JM8HirBij0TfRJs4xCWA1nc sMjQSEmDDycy9IIkjDTE4UPm64aedw7F9cmnlbwrbUsr4TTEE6QzJ4dJKBNRJqFIe5d14vL70tBz z/Etc+Csz1J1Qzyt2VzIo5vc8cJ0Wz5gURx3dOITOYw4p61jnZrGOBo487O+Zc6ZegGPbqbT1vcO UmIcjzDEJ/HAKabQJpojyciSiaW0ZeUB1k2jOdMu9C1TExUBRaBnEUjsO5bHmYLupOF4kdVCvcdO bZV8hb/jGyRmGaPPJp78SL+49Kf0z+XraceOLfTe8lfp/YNmyI9T+jIf+znd/9J6KuNpmwfWv0J3 vkY073MnEUr1cjzG0s7JgxPCtnADrXv5X/Tau+vpSEMCDRo5hlNziDfdNi6JByBX3Hk/vb6piHfl LKO3/u9/mEiMoctnM1Hwszt5JH3xx3O5I/8T+sPzq6iksowObF1FK7eWcLmJlIEm/eZF2lpWS9js M2PELKZaRL/8y79oJ8tqy3h65H2/ZMnlNNOsezXm2Ia3CiyvpY4OFxVREX8KqzjSAb1whNMqrg2j 9tX2GzWetZbQbl6vW9s6ehtOFum8NZdspIULX6ciIbFc6s53/4cH3M6n3rwMw3Vh05riaNJFjNz2 Vax+PY3L5tk5g2fw6CfRKiahV54/gvg9JLPibtbjIve//mfeJOe/aMkevk75fF990wza+sdr6ZeP Pk/PP/k/dOGXf8JanGT+jKQvXT+GVv76TlqyNXgtrX/+GTM9+3NTB1Iz54+U7lu+qcn6A3v4+tty /1forv9bSlt27KCNq9+hVxav5TF0x3amoENmf46lK+nrv3mSthaVUVnRTlq5cis1RLLLqrJ9kK8e +wJqn+h7nh1VjSoCioAicLQQEC5l+0xYzNMMTzThVQjbh9gnTz1Jg1zKsmWiJ/mi8oM9pqhUQ49f qUh85MZPosThR3NIIwQA+B2OtjeqnBrO8SjmiMsupd2vLqH3eRRhCu9Om8zrJgM8smnWdDLRbExL pzWBErMWa/glF5uRzwBPYfVygeQ0GjDratqw9lFKzcugyScNDTUuOBrJXU9u8fqNB2jjpoM0YObV XF8a72bpXWYyT6P97OlfpVdWP8QfnC+kiVOGUlM8T9MN8Ftj/of1NU28KGjb6oN0YFcpXTr767zu M5WafMr0sl/lioAi0D0INAX6kVn+t/Ar/JlNntnARCKh31he30W07yvTKZ/XYWMwq6k+i769ciGl 3DyPfvjVtrmAP3z4RRqegzsc0zk514rr6ZL/Dto29/o/061z+1FVGS+ec1wgOThdNzU+OBIXAHPk 92d4HuJhiz/QCPAjM8DPkPJNP6fbft5WyI1/XEBDknitOB5UcGPq6PFvXUE/NREekX18CU1Lq6cK X7traPjnf0F/rM+gby34Pi1kLgV3wa2P0Mmj+tApV95B9PztdO0lT9K1f3yOLh/fl37w6uO8ne8X 6auX/C6oPPor9PCr11Nf3hStTkbH2KSIz/Vg7k7/9ccrwGT7LLp2zL28CQ4TlRHfoX//5RLKDiOL dN4aynfQb36zkO4/bzb1NVAX0ZsPMHV8dHAb9qFWeKU1Uc7YOWYN8OAfn0YZ9TwCnTTQjH6uWHIt nTKA8apF4d2th+sHG+CtoZYWvo6aa2jMl/5AD2f+mR79F5POzLPo4Wf+TP972dd5mipfd5w+8Wt/ pQX136Mbr70i1Kob//gCfX5UEh2pjpzuWz6ubVz3/K7YXOdc3+DP30UP0wK6+qfX0kNS4wU/phcm DmlvO+eNz59Lrz5+B133Rb4mX2md5H7mrfTiyaMi2M27Uzv3V/BSZVtgE6DnI3i/IQ6B17kUI9VX BBQBReCYIAAeBZKJt554WMGHDGE4icO3eRt0IIMTeTDW8S/SUR58KUfK76htSbwKFrntu2HEccBQ OPgSFx9yNF7S3LDEXR/6kI1ZsmTJ/7Lv6eJ5qms6E80j69dT8cp3aWDBMBrEH5jOxmZCPCpZwRtV HCgpoYO791Cfk6ZR3qRJVMOyFiajXk7KPLRlBRVvfpqGjsqhEaP6Ui6vi0KZ5aU19OGOQ7R7Wzn1 GXUZ5Y+ZEXWZm/auoeWbnqQB/bNo0JDePBiLqXgBKi2rpv17DtNBXkMze8KVNG7IlIhletmvckVA EeguBBKoV79+PA2+iY4cLA6OOCWkU/9+vIac10YeLC4PPcn5u0fUp08vJggVvCEYr8HLzqDG0iI6 wtNr0/LyefYCr5HkafR1VTwdNIE3FUtqpEMeI3VpvfrxbtvEa+qKiPdr4W/49ucduhuo6GDrWsh4 tqF/LjWWFVEJz0HMZRtT2J5qnn6bkpHNG6iVUkk5j17xmNCrN19Aiy/8Jz18+QlUwWsYEzg9sbqE SqrMijcetPS2GyOaOfw8TeU159U8mpnCz9XEhlIqKq2lpIw8yk9tZuLKWvxpi7LqJt5wLZPye2dQ HdfTzI/w7OwUXg96mCrNLjsJlDeA7eTR1oMwugedP17ckIQ0yufPYdUCD15vWlVSxueko2zvqzfT lxdfTO//9VJK4PNW75y3hPTe1C83hcqLDhh8mg+8Qed9+SV68rW7Kb+l/RZCfmlxydk0oE8mtdSX UaHBhq+7/nzdxTdSyYFDwbWJjFd36wWvswSq4+voSA3jwv+z8vMpA0tLAo20Z9kf6Pxv3k8L/r6I pubhZzmJcvP7UAKvZeVLzbnWcEIjpEcov8N542soi/dgyKI6vs74ikrJoIxEvg94em2yuUcs27n2 lMw86p3Bv/u8YZbR5U2+igoxFdffLrfehLQ86tcrmUdLeSYT20yh+62Y77cm8juXQEGdIqAIKALH AoG5c+dexfVu5gOjYEI6JYynGQ4QIL8D+aAHBz0px45DJgfkblhk8EMO5DCcE7nt22H8+sBBJoQS YRwgixJGmt/hkk03Po5J58Nchq/DlNdM/lRKMr/V3/7qq9RcXk6pvHst5LW8fiiRNxcaOedsauCd CKt4M6Fo3rJLmYmBJtr81j8oULOdP2fCk3q4ZdU1vEY07QQaM+sSnvHEHZYYyyTenXbpmn9TccUW ikvkjiG/OW1pSqd+2aPprKmf4VMdH3WZvsBooiKgCBx1BOJ5R+p4Xvvd3MRrAUO187R8lmHgEZuQ xfHoZFMznuXd5+J4458Efsa18E7YMsAJ0vny3Avo19/9My25aCQl8tKAAKc3txkWMiC83cHkON5t O4GffS28u3Zb2ZyGzYb4Ce+2NYHr4XFhnqkhv1uhao6jQFwQj5ZmM9OktaXtZHtevo7m//oCWrhk HmXxeYuPcN4OvvcY3fn+iXT/t3h3WKfpfmnHCyglb/+JvnDrKrrsytmUUrGGnvjXGqKL7qY3fjSd Gnktp7jgtYLrwb7WJBWXBe6BjunRlt9WUmvIXGd8RbU7Vx20ggJ+sYPd4sPpetnlUZKn+KNwLj2N 1wRFQBH42CLApPNqbtwmPoRU4pcIB+KuLzrhfCGRyCNh+NCVHoQdFh1ODqWLHmTG8c9CWCdy+HYY BQiJtNMgQ9xOk7DtQwfE0iaXkCXyIT70kY74uMWLFz/EfkQHkpjEuzGCfGLkM5E7CHCYnoqRTRDD xkbeFMBMjYlYnFH4qJQZXWtUSxFQBD6JCBzZuYHKeo2iETxyoy42BJor9tLmw5k0bkQv8+MWKXdq Tj7lpTZSIa8pxK+x7fzSbL1jGU5oqaZNa1fRtl08uhqXRsOnz6ZzTx7MI+7uxj2ds7Kny++cVbHn +iicy9hbpTkUAUXgo47AOeecM5/bYJNO/BTZxFPi8GUEFOFwBzifLeeoJwEVggnfDiNPyIHYhXMi hx8uDGIoaXYYMonb5FFIJmQi9/JFF/7YRYsWPch+1A5TY0EWccCZtSEYSfSZThup8I9KmZHaoemK gCLwSUMgjtKzc/hTTNW81KD9dM9PGhKdaW9iWhZPg+YpxPwJEfzyftxdHG9gl82fCUuSkeq6Giqv 7L6293T5H/fzo+1TBBQBRcAPgXPPPfcaTt/CB36yhGwKuURc5LaPsBu3CacQSZFJHHngJB4ubBTk T3A4UGLevhBPaNhhNwfScIBQhtOTdBgoYfElD+IShh+T6wq59Kroo1Kml/0qVwQUgU8qAgGqqSj7 pDa+y+1uqq3k3Ya7XMxHpoBAYy3vWdBzDe7p8j8yQKuhioAioAj0DAIyUxRcCg48CjIQTpHZvoQ5 uR0vQxwO6eBs4ZydZofD6RpZtKTTLUCMFB/pErZ9hIVAIiyHLZO8ti5kRieW6bDIpE4RUAQUAUVA EVAEFAFFQBFQBBSBTxgCwqVAFMGjhGza/EsG/gCNyF3fzS/EE3qSX2QoJyrXWdJpFw4DonG2nt04 mU4r6QBJmHq8ks5ooP1k6WCdLqZPY9rzR8lhxBzXs6w3/ijZrrYqAoqAIqAIKAKKgCKgCBzXCJgB O7YQPqa/wheSaHMvhJEmpNSLQELPK42TYnNdJZ1iiBBGu0GwxI5LWACRPLaepMGXMNLVKQIhBEA6 Qdx6YtpzqJIeCIBwiu09ULwWqQgoAoqAIqAIKAKKgCLwyUUA3Ar8CQ6+EE4JSxzpwsskD0iqcDPx oQcnceF94gdTo/wbLem0jZSixUg7LmH4SJdD5GK0yIVYStxNj9ORToFOfUGgoYE/XcMugT/j8FFy zfwNBdiekpLyUTJbbVUEFAFFQBFQBBQBRUAROP4RCMerhGPBeglDT0Y5pVWSBl9IpfA/iYsO8ohM 8kf0oyWdUon4XgUjHc7VExDcNNETH3qiC5lOrwVi6tohgNFCEE7Zobhd4nEcAemE7foi5Tg+SWqa IqAIKAKKgCKgCCgCH00EhE+JD04lu8yKDC2TsPjQAwmFExlIpZ3fJFp/oCcuKgIaLemUQr18VOxW iLhtkDRCZHbclgnpFN+rTpV/QhEAccM3WSORN6RjZLG+vt5MxbU/pSPQCXGFbnJysiGzILQ9sV4U 04FhuzpFQBFQBBQBRUARUAQUAUWgmxEAnwJ/EsIoXEzIo3AvVCvcC2FxkLl8DmlecqSF04e8g+sO 0ilGo0FwiMthx6Xhoi++rSMyyX9URjojkRcYGIsTIhNLHtWNHoHGxsYQQfTLhZHFnTt30rx589qp yYgjSKAQQZBByOvq6qisrIzS0tIoPT2dqqurI5LbdoX7RFA+bO/K9Xbw4EF6//33TTmZmZl01lln GQLuU+1xnwRcSktLqbi42GBfW1vHo9j8EIlP5IM3jOLHiXkJwE+YhLh4ik+Ip+am4KhxWnoa5ebk UP/+/Ql46L133J9uNVARUAQUAUVAEVAEegYBcDHhUKjB5VXhuJit7+aRuOSTUVPIxSF/VMSzO0in VApfGidh2xAhpUiTMNIlbAMFuTm60kFHRV4O5QrpgN9d9aDTiw6yHMdrJxgdfRAyOBsHCdv4IAx9 +HK4ceSDTMpLTU01hMgIuvmPEETU6edgT0VFBcUzUTFXU+stI+eouRlEsyW0Ey7KRRqO/fv3U+/e vSkrK4uqqqqovLzcr6qo0mAP6gCGnXFbtmwxtnz605+mCRMm0ObNm2nZsmU0a9aszhR3TPOA3K9e vdqQzdTUdOrdJ58GDhxEI08YS/l9+1Jubi9D+nEd4cAodKKzhreRscT5xUuCrVs208ZNW6jk8CHO m0MTJ05UAnpMz7BWrggoAoqAIqAIKAJHGYEQf+J6JQx+Jes3EUbnWdI4aMKuj45qa6+5HaFEvs51 YjljLKRTKhfDbIMh83JoIJzkl3ziB1PbABC58TvbQZdCw/lCkGpbSql22ApqyT5E8Wn14VRjlrXU plB8RT6l7jqF0hPzzHTNnpiqGbNhTgZgUFlZSbfeequTEl1UyKfro1zIfvSjH3WaXEWyIFrSKbZg tMw48VqJZZBgNoeIJnQgg/3Z2dl0+PBhmjJlCmF0MYdH00DSu3Iuu0I6YcOHH35IfZmQYcow7EQc 04xBiCsqKs35rK6uodra4MfdMVqbkZFuiHN2dpZpUxCIY/t3z549tGbdeho9agydMGqcGVU2xDIl he3NoOSkZArwdYRRYXl5g3PSwm01U59bz18S72DcOy+PSWYuDRkyhE4/Y7YhoRs2fECLFr1MZ5xx miGsx7a1WrsioAgoAoqAIqAIKAJHDYF2PKq11tYecIhsio5tFGQ2oZS4K5OybLldjmc4GtIphYsf rjBJs4mlrYd0IZ+uXNKkDPj2Yet3OYzOKzr/5c37KX7aW3RC5nRKSzidkuLSulw2CmhMr6Xa3EO0 O28Jla+aRdmBgebzHl0hK91iWDcWImQOWIY7kA7C0FMOpFNs8KtDbANBc12QcAblbhj5QIJAOocN G2aul6KiIh6JG2hGQDt7LmEzbI/VActNmzYZMonpvhjZw+grptb+7ne/pwEDBtO4ceNo8OBBZnQW 00zhoFNSUkL79u3nUdGtbHshk9Y+rJMXqwndqv/ee+/T0GHDmWBmGjxAovEJnEQmlbg34XBOgDNI tRyCewsIKOsBF4yY4gDRruMDZYG4Dho8hEl4lZLObj1zWpgioAgoAoqAIqAIHMcIgGu5HAoyd3RT moC0cORRyoCedKLD6Uk5ouerE450hqvILtQNQz8c2RQjxReDJI6Gug5p7Q4QgO506NSig1o97D0a l3EiVccdoZKmXdREwZFOdHYDATk3bXXH8RTNoC0ig5kB2rW+hA7vqzIm9hmcSaMmDaLU+BwakjmZ Ng54j5J3n2emCaLc48m5uL755pvGPJAUuJNPPtmM7EkcMuSR46STTgqlQ4Y4/H79+hm/K9NIUZef i3WkE4QGLnhug+cPtiIOQgMyKKOQKBtyTOesqakx+UaMGGFG2DDaOGDAgE4TT6kDdcfiMLoHGzHd F+tMQYZ37dpFffr0oW9+8xtmPSOIKM4VRj+DdsezbqoZ5RwwoD+T0rFmxHblu+/Sjh27aNCgAcfs 0y3Y2GndurVsQ4lpw5AhQw3hBFnOzsqmDPZBHDFSi8/LJDD5tB3wa+DzhHZiem0Vj9iXlpXSIV4T um/fXjpy5Ai39QAVDBvC5fe2s2pYEVAEFAFFQBFQBBSBjysC7TgUN1LIhxBPtFvCQSITRELyIWbL g6ltOm4H1o1LfZKvXXo40imKsfhirFuZlCENCJeOxtv5RcfkibWDLhV6+SAVplPe6xDVxg2kuuZD RhU8gCkVGxKsPjEuwEQ0QAmtywYDASYjrAkdQXD3hhIamnwqfevy60wZ/155Hy1buJhbE6C0uBw6 VPEhJWxJpXPOOccQmeOJeAJXG9vTTjutA2QgWHCi6/qY6unKZARS/A6FdoMA5C2a8sU2GSED/hs2 bKCnn37aTMn89re/baz5wx/+YEYPL7nkEho5cqRpE0Y6MWomTkY8Dxw4YEgeRj5jdbAZtsOuWN3M mTNp48aNTCxLmYylmg2OTjzxRDO1Fus6t23bRoWFhaFRUJQPEoepp9hkZ9SoUTRmzBj61Pnn07o1 62gDj5xiSmpGRveM8EfbHvucNPFIJUjj3r17DGnMyswyJBkvCVKZcML+1JRUMwqKc2dGNuvrzAgu iKbsSoyXSDU11ea+xr2NkU/oynVyPN130eKkeoqAIqAIKAKKgCKgCHQCAZtHIWzHpQMqMpuAoiqR 23qQSRw6tvNLs/VMuDOkUwzqUFirwE63w2gYHGQ40ABJF5kd5+Tu/U6ndPrRWaV4HttsOmIoJDrC 8dypZTbQalZwHBoGC8ptVBNmsWsJUPGeKrrui9dRZmqOEV0++4eEw3Zf+9rXTOe3pz7DYdcVS1g6 /5LHHekUuZC76dOntxvZFOIk6dOmTTNkSkY6RS7ldKcPMghCgcPP2aQD9iIOwgkbv/SlL4XWZ+Ic PfbYY/TPf/6Tbr75ZlMkiA9G2mxnj3hihBTkJhaH+mG7YBdLXpBgTKHdtWs3TZ8+jcaOHWNGNUE4 9+3dSwMGDaLZs2ezfKwhkyh7L8t3Mrlcw2R1yZLFhI2IzjjjDJo8ZTIlpSTzLriraPjwYR3aGYtd serabY/jEUwzusnrZTN5qi3W0WKUE/cKjgDfY3hJFM9h3JvwkxKTKINHe4E/0hobGyilmkdDocMO MqxxhR9MD64LlfRY7VV9RUARUAQUgZ5HAC8PsW8CZvJgaQie33hhqC8Nex57reHoIoB+EA70M9EH wqw19C/dPmcnrXJ5lM2vQGlAbaTz7OoK5UHVkoawl4OOncdLLySPlXSGKxyycMaJTHxUKvkhQ8Ph i4yDxkEmR6uo+zycaPMw46V1TQEmACg6wNVhSi17qDiAOI9WIhFcFC6ohzQTokR4PHLVmgKVsA7k C8fx7sKNdIrNcoNgTSOIk8SFWEpcfMkn7ZaRRpF31Zd64Ps5Lz0QZEzfRDp+0BCG7MUXXzQyPAgw vbZXr1502223hcgpRnYxYggcMAosu//62WCniT22LJbwgQMHaRyPVp5wwihas2Ytvf3W2+b6/Nzn P8+Ecw418mNk/foPqKyyhbJzsmnY8HE07uBh+tTNt9Ibb7xGSxYvphe4jbN41HTixEn8w17NxHUX j+6OiMWMbtV1MQE5BAFN4HOAzYSSkpP4nmy9CbnmNrJZQ9XcMSmvKDc+1m9W1/DBfgVkvPYVG2XB x/nFNaidl249dVqYIqAIKALdgsCaNWvM8o+CggKzVCc/P990xvF7oM/tboFYCzmOEEC/B31pvFw5 dOiQGSBYunSp6Vdi88ouOnSY7EOKQ4dZ5DKmJp1o8YWQQs91ouPKY4rHSjphkOvCGSc6kmb7EoYO GoEhCsjsg6PGxeHkdJeTDi78libeZZVHUkyv3RBOrp6jwdpCASYhzC2beZSFWx7P+gjjCxygkX0G ZdDzb/+RLjr1W8bEf73zJ1qx+WUOx9FvrnvNyIR4Sd1GeBz8ce2RkU68bXmX1/2Jw1rNlStXmija gpE6dOTxTUUpA58VweghHIga5EjfsWOHWYcIWXc6GekUbL3KRrrYGE5HyDB+1ISUIA9GMNFGTNEE +QTZxHck8RYKRBPTXDG1FTqxvJnqykjnoUOH2cZEGjcBo5076e233zbE8oor/oP2Hyym0oo6Suap qL3zeU1ta2PjCnkK8O7d9MEq/oTIiSfxm7SR9OST/2fygohN4LL27NnL5+oQ5ef3CQdRj8ji8e1N DxKI89XU1EiVVZU8EvseNfCsBJt0NvFnbnD+G3iEExsHYdZCfV091fG022CYNxWq4zXbfG6aGutN xwU7D48fP97U2SMN0kIVAUVAEVAEYkYAexGsX7/edLa/8IUvmBe66E9gLT9e/irhjBlSzfARQSDY 1+EZl9yHwQtyLN1atWoVDxC8QZMmTTJLozrZlFAXkPPbvAr8zR0BE5no2VVCJmVB7sZF10su6e38 WEgnCradHbfD0LHjYjRkttyNu2WbdJyY7nJCQODXN7QYEhn8nEYcj3piPWcQYfFrKhto1ZJ91FKf SGd9brAhoK89uZVymWxOnNGPho3tRXs2vkV3PLrI5MwblEmnnjeI3nlpbzuT7XrbJRzDiIurPdI5 b968EFnDqPDESZN585wDZoR429atdN1110a0/FOf+pTRwbpJrGntTgdiCAIH388hXXSwBvPRRx81 6vjGJX7MbLI5efJkeumllwjrO6+++mqza62shwTxxNQf+PJ2CusnsbEQ3sxG68RmF/to8h88WEhn 8idBysrL6B0mnAlJCXTllV+k3v0G0yuLlxJ2hL36mmt5mkZ+qLjU15YQb2lLOby7bUNjHKWm55g8 Dz74gCGeOC+Tp06m5a8vO6ob7mCa8BtvvEm5ObmGCOJtNg55CQCcQCjLSo/QNd//TKg9EqipraLp wy+QaET/9ttvD13PEZVVQRFQBBQBRaDHEcAyiA8++MDMMsJMI0wxxEZ5mM3i9VKyx43SChSBo4gA +oLoo6KviY0iMYMOxBPfMMe3xvHCvBMORBI0xsuBVCFddOww8ogcYZuAQS5xOww9Nw5ZWBcL6Qxb AAttA8PphDNG8rg+8kMmh+kshiu0MzKcXHRocaKbGkFIsJYzOMUygaEECcHmQWWHa2ntq/uoiYkp dNMy+cIA1CA5HD+8t4pe56NXfhpNmBkkn7CHk5jIYgS1jQwhv310xu6eyCM2Sdky0gl5eXkFHS45 YtbGJfI3E4uLi6hg6FAaVlBgdm6VPNH4MiIajW60OjiHch798qAtcME2lYfWYII8yrQd/LjhwI8d ZDKSi5sfU3zwMMAaE7OpDa+rxAga3sKmpaWbEWCpw88OSYvWbtEXH7uxJvM00z4D+poHUhGPIl96 6aVmhDOQkEGfv/zLdON3r+WdW/cwxxxqsrXwlI0WnrLUeO75lMffshSXmppCZ599Dj3zzD9ox7Yd NI3Xh6Js7Hxr64l+T/ggnbjXVq1aSzW1NYxzXzNSjvsT02pbmnm0md/+YbMgPOPG958dMmNj4Rss kuUIIbFvAC8MUDbqVKcIKAKKgCJw7BHYyi+wZ8yYQaeccoqZIYVZQ0I29Vl97M+PWnB0EMA1j74n +qXoW6IvijCIJ/ZS6YRDx1c4lN3pEZmMbqLoYCfZuxquMsIAACAASURBVBI7P7TcuHdOj5RoSadb kRuX4qWxEhdf9JHuNlLS4EvYzSfxLvk4sXAgCiCU6IgGEuMJIDRzzRWHamjty3vIrPRstRIbCA0d kxucist6+UOzqHA3d4a5jNLiGlr23E7KzEmhqacPpJR07jCzPs7oR8mBZOb2yqO9+/ZR4cEiquKd QHN5U5epPIV04JBBNIx3OcVUF0wBeH/VezE1DR3+7nYgbzh3OPyc6OCmxs6t2CTorrvuMt+8xLRh XA84kI5dbXGj33rrraatuEaee+45Xj95An/eY50hrNjM58wzzzTkBW9jUT5GgpE/Ggd92B6rO3Kk lEdeh1IFj/zt5U+iYNfZ006bTbv3FJqiMF31G9/6Lj3wx9/SHb+4x9hX86/nKIl34q3P5mu3Mfht 0J3bN1O//gP5R34mrVixgnZ+uJOGFAwx3/fcx9/yzM0NvlWLjw/eJ7HaGa3+zp0f8kuNMioYPtxM Ycb0kg937TKfgQFG+NxJLe9Ce+DAPjr93Yn0WtnyUNE5/BKgvq6KGgrbiHQo0Qqg04Lzgg4Npkmr UwQUAUVAETg+EMBu69gpHp9mwwgnOtt4ZmMpz9q1a81u7LB09OjRhFlIIKdKRI+Pc6dWdC8CuK7l kMEP3BfY2R/3CfYRidG5HVKbW3nxL1ThpkHmcjJbB2l+ceTv4KIlnR0ytgrcCl0DJZ/I4cuBNOS3 y4CsnYtlJKldxjARnFgpr7mBRzjN8CVvKMQ7sCx9chsTTzal1RpMtp00qy/1HZIdJJGto2YTTu1H Y6fn04ebjtCuD44Y/arSelr2/E6eFpJMp13E03BbyxUTUKccIjuWPohPaWk5VVTW0JN/e5o3Y6kg EKoB/frTjFNPYZI52LxtERtXlBL9Yx/Rj4cFqHfr+kwQMriLL77YkDPRtX2k9US7hUzC93NIl/MN AgKiKNcASLSQTiGe2D0VI5rIg7xYB4jRP9l0CGsHkY41g81NQfIYyQbbPujaNtlpfuFSJpsnnTSN z1kZlZeV05lnnWk2DerD50vc2LHjadCQYfTmsldp5pTpVPbCC5Twy19RVWkxlR85wPYG10nWVBdT SVE69c9Ppw82MtHbttbgUlm2n2qqeC1NajbFJbXftVfq6C5/6/atPGsgjsbz9JG+PMqZyWt4cG4w yoxF9cuXv06/+OL8tuoygsFa3vho5EXntckjhJbywnzBuyeuwwjVa7IioAgoAoqAgwCe89g3AaM4 +H0F4cTv8/PPP0/PPvuseTErv6uYKYX9C+BfdNFFSjwdLDX68UEAfVPcB7gfcF/g/sAXFfBSHgMi 3eSEi0lxNv+yR0AlXXzkg66d384rehH9aEmnW5kU7DJqkcOHcWJguPxIQ37R4WA7Bzn3FTvVrnYF SQQjHtL5lKmzCbwxUG1tE+8fzPWY//iTRXOv6M/GsQmthBFlBE1hOsojSyPH51HBmF70+tPbg1Nv WbWhgRcF1za0a5DUJ77Ycqx8jMxt2LiVErgNI4YPp/H8iY2hQwe3W7S8vZro2c1Ef9xC9CH7VBG0 9m7+bGXyrhSaPz9INqUNIJderifaLSOdKDuSgw5IJZxsTIBPiWANq6wdwY2OHzXMqYcMefCjh13E JPzyE0/QuVdcYYgRdDCCi/KQjiMahzJhe7T6UiZGorG5AggZpqOO5Le/XFQHd9XV19JtP/4vGrpz F6Uyoavm9QB7dn1Ac07vzboprUcw29TJsziAo9VdfrIJPPTQIsrOGynSHvFTGL+SI2W0hzc5KuMN mkaMGEn9B/TnFxp5BtN0nrqMe3Hg3LZvxx5Y8ibPqo0OZzEaa4aUdAoa6isCioAicOwRwP4KmHmE JSx42Y3fX8y8eeaZZ8wLXsxOwUYqcNhkCKOfSMOGfqeeeuqxb4BaoAj0EAJCPM0gEN8fuE+wf8hg 3psjRgf+JC5cxwnpckAPYdGz5UgTOcJwoit+UBrl32hJJwqPxbn6bhxlSUOQJuniS13xsXbQJaOX LyNdIJ1x3HFH+YnJcZTAvpmEyFbFUSW9+n/VNP6UPtS/IJuLArEIbrMLfXR+d8hIp1TE6anp8fwx +45TE00e5EMhx9ChfnTEgfZtt91iHvYwp7ie6KEdRM9sJ/r3WhZg1iZeByTxgSsEPlxV0MPfD3ma ZyRXUFBg2tzd7QZxBnnD4eeEnAqRRBzfscTmBfgUyt13320IKabdYjQTUxpAUGHvvx55hM667DIz fRZTHm7habkzP/MZs1vtSv7syF7eaWwYkzq8yEAeXFeRHOqH7bHiUV1dZcgwiG4D1zeof3969/33 qaBghFkLI/WmpaXSFz7/RXru8Yfoq//5fTrCI7KVZSWcDNIZdFUVVZSZnWki9bX1VM1l5uXlSjJv 4FNJWT14naLtWKOKzxKhswHifujwIcIuhrv58y0YdV+z+j16b9Q4Klv+RsgurK2tq6qh4n5ZIVm4 gDy00XGRtZyoU45weVSmCCgCioAicHQQwG/gsGHDQvso4Nn83nvvmd9GkEpsZCgjO9hNH78TL7/8 stHBcx1xdYrAxxUB9GHQp0S/E/fJPl72hnskBud2RnHDoLMMuRx2gaIvvlSFOPTEF3mX/GhJZzSV wDj7aSCNshuCsMTFl7IlLjomf4xgS1mevnQ+gyOdhnXyCY6nM68YRVUl9bTqtb3BDYT4HG1YUUgb 3imkcdP60sCR2dTEG5ysf7uQCj+sNBeBGJyZk0yTZ/an5NR4/sRDMzXUta0hQ332aIunYUchQUba KnjkbCeTxhP4gT78ISaQ+CIKzhxG8HGk8iEOl2oYbgdCGa3r7nMoZDJSuXKu8QMmRPXKK6805w43 NAgPfsBAPnGjC3FEvgu+9CWayqOF7zC5e5nDv+A3r29dd51p8r6pU+k8Xtu5iefbg3zW8ZRbGTWV MsJhI/hHstvNi/ZiShLyJ/LDCDYPHBj+zdcpM0+nqdNPNWS4qXg/E3MenobjKeRPvv4mZfNmDf17 59K0saNo9fadNHrQgGB661/ox2pfuwIiRFB2E09Nxr1Uw5sypaenmekkgYREs3nQlfNvpSvnBwsR ellVXUsXnXNChJLbkmVaLc45MBPXk+2SOtRXBBQBRUAR8EYAv5UYtYSP30s8ozdv3mx+d7B2E0tY 0OmGgw5k2FkeOuoUgU8CArgv7PukE30X8CfhUoBM6IrAJ3Hxbb6GsMQlrx2XMmw/UnpIt7OkExWI sVJYpLhtlFdYyoLvlmendTncaHam5c+msCXYbZZnm1JWr2SafclIqiqvp/cW7yWs+4TbtfkI9SvI pPqqRtqz/gjV1jfyDpvEI0ZJNHJib/58RRwd3N06B5X1Dx+sM/nwByNhdsc3lHCMAiAsSfy5jS2b thjSOYivgA+BdFrrKfEgmcZc621LtCOdPdFM4Ikj0o0o6biBcWCuPH7MQEJxQ9sjlEgXh3w4b0v4 e0lLrr6aprJuMqfXMlGPZwLYj6fivsLKf+JPsFx31VWUyB/4rWMyJ+VLOa4vdrvySPFkthujgzh3 2OEPn2oZNHAE8admwzqQaRBV/sgtxuiNzhHeBGpQ7150xsTxhnxO4I2Jqmrr2o1yQlEwC1twNwoN 3owpLqkmtrWuopw3sTpg4mfPGhSq6dW3mDhb110owScg02rlRYOPqiYpAoqAIqAIHEUEMHUQxBK/ Z/gdwG+O9JHw22z/LuO3TEY9o/nNP4rN0KoUgR5DAPcF7g/cJ7hfOuHaOrQdM7d29k2ChEXfjkvY LSGcHPnDyd28ZvJkB2EUAjEwCtWQIXYe20Bb3qG87uwEoyw56nlEMp477S3c4YVDvxbTbQ35zEqi OZeMoOqKBlr9+gFq5O90NtQ0UemBSrpidoCmj8vmB6OY3X531vUbq2nOp88yZeLPzJmn0Pbt280a he5sS6iCGAN4oIO4bNy0iT796QvoSxOJ3nyBCwEYkRx/ZkZcQUGBBH19wdtXKcZE/PiAVOHwc6ID gokDnzsBYcMP2Y4dO8w8eUzb7MWbI2EqJm5u2bYdN/w7//mfhnD25emscJlM/EqYYCbyJgg5vMAb TohnKa9NRFn4gUTecA72dOaHM50fPMXFh4zdsG/P7j00cPAIvnjD1RJehim0lZu2GcI5iQnnsvUb 6YxJ48meboucPXG+XIswswBkWHBq4Tc4jQ2NVM27JmODpieeXRXKkt+7j9noC7jJiw5cexKGoh0f Pnx4aFot8uCAOxrtMhXpH0VAEVAEFAFPBPAbid9gedELH9No8X3CNfyZLzzPbQcZHHSOhz6UbZuG FYGeQgD3hbx06cbrHsQQ5EUIIsK2s9MgFz0/HTstYjiWkU4xNmKhjoI0yjVe5I56+2g3gt2u49nc GGDS0kQJLdwBZstwgk3HlHfV5CEiA3V6ZhKdceFQ7gi3UEVJHfWqK6GZ0zNNRzaO1zkGuAxxKANu 34F6uvyanwQj/Pea+VfTDd+90XzotTvbEqogxgBIZ2ZGOu3bf4B3xWqgy8Ym03VlXIjMZfQrr23W cLtOv53F/cFAWne3O1ryJvWC3CCMLaj//ve/my2osXEQiCLI6FlnnUW7eVMbLNYu5O3aL/nqV810 WoxwCuEMMNEs5Thv5EubuazPnXsuncifWXmD15gMGTiQNvMPpox0yo+pjQvCIECwXexy073ivXhX 3b1799GoE0YYUrxz1046Y/ZZ9O6779NQZ12nVxmQX3hacLOgI7yJTyWv99zA5LWQP11Sz9NQLzlz pskK22K1z6/OcGlYt7Ns2TKqqqo0Hz/GJ1qwORcebw1NDXTlJdNC2f796nYztRijlrKY3g5D0Y4D Y8QFayWdISg1oAgoAorAMUcAv8eYSSQOv5f4LApI51LecRwdbfk+4bvvvmtk0MWmKl6/rVKW+orA xwkB3CfSf42hXW3EpGMm4V3iQyMafT+djrX4SGIhnbaRXkX6GYb8drod9iqvWzvA0qGG34xRO94Q KI6PFiaZLUw2E9lv4g1OMILE28mwTUxE8ZcHrrDDbRJ/dqKpCTuWsow/iwJfnHTUzZRcW84loBMs dYv+sfLxQMc6OpyKNevW0gzePGfsZCZSu7mRyWYrpfamMSmnmtbNkaoT6KJBG0x6OHLZPmNbTLBp k3QtJKRTCIVXaUgXHfxYgbR873vfMz9cKANbUcNhe2qMdsLBf4O3aF/2jW+YKbWQgXAe5sXcZfxj +QHnAeFs4PUl2Pymgbd4f4zfwGKUU6ZSS53IazvIO0M68R0zfEd05Mjh/HmRTNrHBHTt2lW863Db NFS7nkjhDbv30iljR9PfeI3nlz91Ni1euZqn75aFptp29/ly7UF7RnMHYhuvKd25cwelpaYZ0llZ Xclrohvo57/9RyjLhDFjefOkenMP4cWA67DQ3pbju6q434Az1u0Cc3lo93S7XNs0rggoAoqAItAe ATyHMesIu8WLw4tIzEJ65ZVX6OmnnzafTkEanuN4nsPh0ymzZ882LyqNQP8oAh9jBOQ+gR9j3yVW rib6FnPpACx0/NI7ZPASxEI6vcqAXIwR47107XQJS16vPD0ib+L1mvFmVITXvjEhiWfCGWB2GSKb xiqsG0T1TEp545NGztNSz4yU13AK4Swta6K/P3uYvvof/ejPjxbytx3T6Z0lP6EZc39m7H7q8buO q4ckRjoxupeakkKbNm4ypPNS/nLGL9fx6cjmxnLzqIF3E+JZw4k1RBlDiT79KR4lO4loUNMuevXf HXfnNQ09in/wQ4TDi9yJKUjHzWpIB59DfD8VxBB5QS6Rhp3BQMRxYHot0it5/SMc1nBiSi1GOEE4 1/KmQSCcNbt2UWVNDVW0XgTAFPlxHaFOL7vEbrEvWh8kLZE32tm1azf1659PVWwfdvu7+OLPUq/k FMIK4rWr36dhw0F+g+TZq+zd+wspL5O/x5mWQtNGjqAnF79BfbKzQoTTK193ytfx7sEBfskzetRo M4qJDgg+B1PG345taKinW797aai6p55bbV4OoOMxaFBHku3KBX/4d/GOw9iAAlvz6xvyEKQaUAQU AUXgmCGAZzNmGeF5jt9O/D7jBSF2rQURxQvWXfwbCzecl0tgWu1bb71Fe/bsoXvuuYduvPFGwje1 1SkCH1cE0DdFfxH3iVd/sottF/6FYgzLYd+WxVK85I8qT3eRTi9jbWO8wl550QDG3s4WVZs8lVCW lNdYF8ckspkSeWofHnrNxoogAQXzClaLuvE5Ff7Lm4DW8+goXweGmNbUttCfHy+inKwEuurzfam5 roWuujSf16Mdon+/+DStWfkipSbH08YDOTRgyOdMvVK3p4FHKQEP+lQeXfpgfXDU8jKezXgPf0mF ynkRP39N4/TZRJ86lb/FyfIReW1Gbd2abjZ9aZNEF+ruduMmjJZ0yg3LWwnR3n176bnnnjMvAc4/ /3yenvoubdmyhUbzdy/hMMUHP3pYNwmHTYOwhhNTamWEs5RJagM/CA4y6WxofQO7nqcF/fJHP6K1 nIa2Sp2mEOuP2BwrHiBMQ4YOoa1bt/CPbab5wcUaz9cWL6K5c+ZSdmoyDRg4qPWaDVa4c/sW/gxM sB2WCdSbR0qH9c03ogmjCgiH62K1z83vF0fZB5m8N/MMg/HjJ5hvdKbxyHs5jxo38tTaOh5JvvHO h0NFTOKRzloeacbLAHQ64IYOHRoKS9wk8B+8UBGc+/XrZz6Dg2+cwvVku0wF+kcRUAQUAUXAFwE8 o/GtTpBJhPH7hpe2IJIYycRnUfAMx/Ma6eivTJs2jX7/+98bMrpgwQK66aabzLerfSvSREXgI4oA rv0a7mPiPsE90Mm+ixd5cuVeHMzV80IT+aPV7fRGQl6VQ25XbjfGDdt6XuXxBpzRqHllby+XskAy k2tyqOhQAw3A9q1sMkiJGani2aSoElNtjT5HYEGA4/W84y1GOsv4WPCn/XTWrByac3K2WdvZAj1e 43nFp/vQayvL6Y0VFXTDVwZQcWOGMQJlSf3trTr6MTzEMzJSafOWzVTFo0zThmTQ7TcTzZlAdOqI NnuqmHC9+fZ6Q05379lLu3bu5DcvR9oUoghh04CeanekciUd5xvnGFMxr7/++pDVF110EX2Gv70J B52gHlEdkxy4PdhYiDcYkjWcGOEUwnmwlXBC78Tp02kRE09MscWPp5SDtHBO7AqX5iUD0cJoIEjy hAkTeFezDNrBI7E1L79I06aexBtVTcZXUZgIB6ckFRYX0aiRBXwdty9RvtHZXtoWg22dsa+tBO+Q lJ2Wmk41jCve4uHBmpfXm6dQ8Qg0Y1rHa00X3HZ1qJD7H33NyEA6MWIJZ4clbhL4DzorMq0W1x7O Ca73nmqT1Ku+IqAIKAKKQGQE8PuIpSmYTovvYwvxxHMau3VCJs9r9MmgjxfB3/72tw3xxHKKrVu3 0kkn8fQrdYrAxwwBXPuYwYX7A/cJrn+5H2JsqtP7M7lBZyD3Ila23E8vRlPa1GMd6RSD20oIGm83 zg7begi7DXJlHfQ7CbZbTigub9VyG8fymsb3KNCcS316pVJyCm9mwv+CFJM3JwnlCAYCjU28iy1G 2AKUnRJPP7p2ED34VBHt/bCOvnBBb74w4ngUMEBPLTxMFVXN9P2rBlB6agLnCVBi647H3d0Wx8So o+YhzoQqiadsYmfdKSeeSDdfFOywb9y8nbZt3WZ2dz10uIQyeBQqh99Ajuc1gFNPnGhI1c9//nM6 fPiw6fyjUrtdEl6xYoUZORw5cmS79KiNjKCI8xibi+MdYIvMdNqCggKzw2l/3pX2AI+65fXKM2sK QTbz84OjgCj7CIfxPdPrzjvPrOHElFqMcIJwlvNRyiOuS3mKUAY/JEB28KCA7+XEZsHIS89LPmrU KHqfvxu6ceMG3lRotBnJLOIH08vFL/I3zDYS2oV1qxitPev0k1nvAzpYuJ+Lm0S7tu3xKjYkHz6K 51Kz66x9oYI8AigX+Bw6VMT3G6/j5HOYy9Oc0dmo4E+m4CVHLY90fvf2v4RKKOD21LAM2GIqtO3Q VluGOEaZb731Nvr1rxcwFgNNHNe7OkVAEVAEFIHjBwFMoc3JySHMSMFvAH4PvJ7VWPqC6bggnjv5 5fe4cePM75T8ph4/rVJLFIHOI9DWRzpkRvV7oC8mHWfxhZOJD7mE3YZ4yV0933ispFMMtQsNJ/My ztWFnitD2ZI/XJpdd8xhPNTwAOuXO5iaiprpnUMbqSm1iOISUWVwlEceZDjhEq460kAjkuqoaUo6 EZNIqF/7hX505FAjPfJ0MV11cT49+s9D9JmzelEuk03kbWriqZaBthG0mI3toQx4wONITE7kkbNt VHK4lLbzhi57+A1iEq8RzMnJpt68uc6IEQWGcGLkCJhhFA+fFsF0RazDw4gT2ik3hoTh420kRuTw FrO7HWzHeZRz41W+pIuPHzlMqcXnUnBccMEFtHr1ajPahvaAIM+dO9fYnnnddbTuhz+kc/iHbhOv ManiN05Yw4kptdXc7lIOP89kvJg3FJpx+ulmdA0YyVvbcDbBZtjeWQfcJ02aROvWraN169cxyRxO GVxnHduDH+IdfA75ZJj1x81Mvmprq/k7tBWmOiGUna27O/LhugApxHVDcQlmbSpGI9Ow4Q+vmc5g v76+jn57x9dC1f337/9J9fwyAKQTLwls58oQR/n9Bww0xDu/T56Jo165Buz8GlYEFAFFQBE4Ngjg 29Pbtm0zv4nYtwC/jV7PacixO/yQIUNoIO8Wj7CX7rFpjdaqCHQNAfRT8FIeAzq4L+Tb7J0oVfhT NFmFY4mPPF75oeOVFk1dRidW0hltwZEaIIbbenbZITlORHc6PKjQ0cUbtkBgKGWU51BtVa3p1KIe r/pSysspLnsLNVbwWgOs6uRNhaCbzWs6v3RRPq/pDNAXz+9tzkhzS9DmAK/zbOQNU+Th6FV2d7Yv mrJgBx7wKSnJZpOWHTu2G7J00rSpvMFOrpnKAqIJnOBgPw506CEHscJGPIijLPdAHuALHRCt7m63 4Ck+6gvnxG7RO3HyiYTdTRGfOXOmsQ8/YiBBINOY2oNpPHjzCrvH3nknLb7ttnBFU9Pll1P8yy/T ybNm0cVMOt/nEVEh5lJfuIxI6woemC6Ktaebmezi+2X4AR44cIA5V3I+muN4tJUfXmZzI+w+zO54 GekEMcSRnMK3eOt1Bfv4KmJceHowbyR05/88BVHI1TfURb1xBDAAOZePjwsmXcE8ZIgGFAFFQBFQ BLoFAfwWYqYKntH4XcYsI5tMur+jiEufpFsM0EIUgWOMgPRL4ONrClhChdmHmIHXhb5iiD95NC8S qbLzR9L1qMJb3FOk064RDXANj7pRclLsArsaRmcc5ALEAj5IBzrCfg6d2Lrq3VTPH7BvYVIZz1Ns 4dBRDmCtJ0goL6ADGcX6TrgWnlrb1BQc3eqJdphKOvkHpDOdR8lOnDzR7CCKh7l8ZxJFygMfvnTc RQb8kB9twiHptinYFEBGOXui7WKLXWekcAavg8QhDnbJJjMhGV+qffv2DZHr5p/+1CzmBinFWyi0 9cH77qP/5OsB7cN18SYTQBDOSE5s7iweqBvXKcoBWcZVtm/fXt5UZ7eZIpyLFwYgzq0vC5rqG/lz I7wNMbtoRzrxzczO2mcq8vmDcnEkJgY3+wF+uI7QHvhpaen0xkt/NWs74/jehF5iIka1E+jqq/9l Sm5uCe5cbMhrI09557WgJsy4oAysB8rk3XlxrnA9S5091Saf5mqSIqAIKAKKQAQE9u/fb5ZWFBQU EEY88ZuK/oh5acq/DeoUgY8jAuiToO/S0NBgrn+McH7IgxflPMDVRefyLbc4+6aKRdctp1Px7iad Xg2QRiLd1ZG0TjUg1kzS8ZcOLzqm6Mzj8HPQ//DDIbTz8DoamsudZd69VpwZ9cSOLTU88sdCvpa4 PP4cR00zT8fsbzq/onu8+Hig4+F+yy23mIscuAg2XbEROGKEEx9yBqnvCRdruV7tErlNSLCuNz4x 3pAXTOeEDl5M4DMqaBtIz7MPPkhreC0l5LJRDdoZ6RqCTqy2I4/tQKbwRgzTgdOY6OLtcC2Hy8rL qLCo0DzAsCEPXnwkcjuyMpLoG9feSelp/KmcxGSuP7huJoEJXSqPdCclQcZTlZmwpSSnMWltW9Nq 19sdYWAJYjhz5qlmC3xMwYZsEK/FzEjPoJNPmcGbddXz52ESeCQ0xbQvJTWFEuLbHlMtjH9DI+9y y1Nua6treQ0oH7V1VM8vBbDzbS2/FCqvqOBOS6J5e27axnWoUwQUAUVAETg+EUBHe+3ateYlMPoP mCmF31f8XqhTBD6OCKAvh8EMXPvYVFE+1dcNbfXr8PjxLzctnCnR6ITLF5K19eZCopgCrgF2Y900 FIx0VyecXsgImxCEhN0UkA5pNHXgIThgwER6YT2PNAX4kw+B4Mgo8qLjLGUgDBefwFuB0yAqKBgf GnHpJrO7rRiM6GErcrxp6U6Ht5TY9EYw6c6yURbOm5w7v7LlXIgP3XA2hUsHKcdoLXyMhgIjkEqM ipcyAcVOqhjdlB9GlCtvZu3ybPvE7nA22HpeYeRDGcAX05zh8DIENuTwAwwPMRywE7qBQDMTNp6S xN+VTWACyr/gfF3yet6kRCaYKZTSaj9IHkYWQUQTeHOpztrnZbfIUS46EXm8Xvjss8/mjZ2Kae/e vbR921bGLoFy+Buj/Xlqc37f/jzanE/92O/Fumgr7GrBQ5p3t8WObsWFB6koUEilZUfoEG8rXlJS Ytreu3cvmjhhnCHjGPWUTktPtUnapr4ioAgoAopA1xCo4BeGONQpAopAjyDgx7/ctHAGQEc4m/jh 9Dxl0ZJOFG4bJAWGk4VL8zIO+f3K4L6iV1appuu+F0mwS8aIaHDa5SwzyoRhcS/bUB7IADrLICwg I166dh1HMwwbQapw9ITryfbC9mjOGdqF83bayq2i4wAAIABJREFUaaeFRnNjbavbDsRx7jFKfCLv +isj5lIuSKGXE7vdMr30XTnyg0QJ0QWpsommkE0ZcYXPWQzxRCDBEEsmnTxdNYFJXhKmrzIBFZvj 4th2Pjprn2uvVxyYAT+QdqyfBaGX0VvsYltYeIDeXVkXIvrmc0Q8sQDtj08IYpDE9xTuL2DRr18+ DR8+zJxrnG+UizqkXT3dHq92qlwRUAQUAUVAEVAEFIFjiIBLoiTu8i+Rw1SkSVx8twm2jpvmGY+W dKLwrjjJbxtvh73Klnxe6V2WR0te0IFFZxajTJhSGakjazrInAf5oq2jy435hBQQLabAHWtEQA5B bLp6HuScg+jhRQJeQsAWHNE4uSai0fXSQV2oGwdIpRBM6It9tg/SCSdth2/bEa3twVK6/lfqhw8C jfsJ9qIdNoGWEVvIpT3SDsEc+REWX+R2HV23WEtQBBQBRUARUAQUAUXgI4mAy6MQD8e/XD1prJe+ pMfkR0s6oynUbYQbRxl2o+xwuPJNfrvDGU7paMqko4xObqzueGpHrLYfb/o2ufCzDecJLwhwHA9O 7P7/7H0JYBRF9vcvyeSGEC4RBDkEuUUBBRVB/fDGA5X1VlzY/YuusF4r6Lq4F3isNwoqKroerCKi qIggqygKcsly32eAhARC7sn5vdeTl9RUumd6JpOAUAWTevXuel09U6+ruru2Y4HHIRfuXzhjMVgs autfMP1Cl+SQ29wPXp2MZKmvfkTSZ6PLRMBEwETARMBEwETARKAWEbDLv1R1ev6l8+ttVdYOds0f btLJBnSng7VVp5xgtTOWPjNxVENiYI6AJF2/xmiw72ZM/xqPnPHZRMBEwETARMBEwETAROCoj4Ce j6kO2+Vfwi80bgusyjJshw/E7yfvbl+gn4jVEAdrUmpixEFVRnVQxdeUNhgTAS0CvGL4a0w82Wf2 3RQTARMBEwETARMBEwETARMBE4F6jADnY4HyLz0fk/xNdVHnUWlB4VBWOsXZoEo1BnFQd17wGrt/ 06wK+cfDtHxPr+UE7teWeErSaca0GcUmAiYCJgImAiYCJgImAiYCEY6Anmup6iXvkpppbvgD8aj6 g8KhJJ2qk06KAznG8ipdhZ30RWQrYlnOTixeX4az+nVAZO8ac3TbEOowArLS6ZS8efPyUAJ672RS ImKPooXF+ks6C7B5yUIs3nQAJ595OQZ1aVp1NHJ2/oJNxW3Qt1M1ropYR0ARvWKGj0cCPW02NvTb oevIK6PWRMBEwETARMBE4MhFoP5+G8uwc/kyFLfrjU5N3c2C68+3Ixf/Y9RyqLma8AfKyfT8LezQ hZJ0BjIizorzTrwqXWCRdZJxjy/Ziamj/o7FikSXmx7D6B678NbrUehLSecxV/Q+tx6EUSOvQ5/W vvc4HnP9pQ5J8lZjq2pJJha880/MXiO97ogHnrgHreOlHaSmWD71p+dx/RPPoYNbmSAqVbIkyyrO D65xLPtj1J03oE/bhn5swRrZa+bjydd3488TrqGrPNGYP3IkCh95AVd2SEbhrkmYUvoPTO0UTEsE 6CUZ+Oq1RzBjpejqgscmPYi2CdI2tYmAiYCJgImAicBxFoF6/20sw67Jr6P0ny8j6E9/bX0r2Ybx oybg1klT0cn81h+tA1vyL/ZPcjAVF4rfIu9KJlJJp5OzqjNOsJOsFQyn1Szb3sWkIo4Id730KW4/ PQXeUkpQig9i4/psiz2OXs2gOmGro06QJVj08t34qcfjeHDQSZG1IH2e8ilu6ViEj/5+A16c0QEv jTkHx+r5zq8L4cRTHxs5u1dRwnkDPvrvGJzkKcDOLXuQl3cQuSUuQ55wOp556wMU5e5DNo0dx1Ke gTcffAJdH3oSZ7d0d9WQdbHP7Lvud5Udv2NZim9euQ6P/709nn39QoSSdpYVrgVGj8f5fVqiojQP Z3z8H1QUFSK7oAQJKX3QsSTJ2YcqZ2oPZG9fSgnnzfj0xwfQmo7Hjs27UejNR17aItz12C94/JV7 cJL78NXeIaPBRMBEwETARMBE4AhHwOm3sbCsrhyLQSPKNkvovdYVFYGN1Nq3hNPw/Hsfo9R7EHmB TJXtx8t3PYYej7+CQWYiUBcH3ind0fFOOZjO5+Qjy7vlRaSSTtUZ1bjaGR1W+VR5FVZlVLwjnE+U BnEF2LgtBx7aWlleWkx/fKbo/fK07gNkb/4OLzz1LvYQPHD4ONx2Lq+AFmHJv99A3mkDkDNvEr7c CAweOQ4DEtbh8UmfEv10jJkwAj2aUypXloXv3p+EdxeShtaDMe7+69GhYQz2L/kP5uV1QbfCHzDl 019I5Hr8fcQliFn7IaZRE788jt+9O5Am27ehadYqvPfqJCxmJ04fjpfuOTfsJNHqc1kutqUn4Yye 9M0yKZk2M3IpwebvpuOpdxcS3BrDx92Pcztw+lKENXPfwwszFjMTbn38JTrpuV/ZWPLZe5j6JTtL /R/+J1x7bifakkyxeWMSii79g4+vJA3/nrAAgx6+DScnFGE5xS2zW39kTJmCbdc/hvGXtMS2JXMx cSrHjUpl/2KyN2P6C0/BCtvA4bj/tnOtZKpof2ix4ORNVjt9Bnx/E6zVyYNY89NipDVIRLPmjVCe y+/RLKGtJQvw3L/n+Bh73ownR5yF7OWf4Lv8Dmi9/y18uONaTLivBz6YvARnjLwMTcrT8clr36HD oNaYO/VD7CXJwbc9iMv7tMDqj58AL6auefphLDrnNoz5TR9kr1mAt6d+ZvH1/M2DGHFOa58t5a/4 raBqgHws48oOW8eyx4CbgZl5KCvYj/+8Mg8dL2iFKVOm4/rHXsAlJxXbHqsySugefnUrabkdg18c iMdeuhG5X02H99wb0Ls5XZKhCy/Why07jGMU7cfc917FDGtw9icdI+g4s0BoJdbDvzhZWLNkKTJS EtG4aUNU5G/FB49NsxQ9fvfv6Px7nM6/k5C9bRGmTpwGOu2AzoPxp5HXolNqLEr2L8FrX+Shf8e9 mPJuOsa9NAbF372DZyrHbueBt2LkzYOQSgO+JGsDpk96xhpfnU8/HfmZzTDy4RvAQ9v+nLfcMH9M BEwETARMBEwE6i0Ctr+NRfzr7zBno9/qudMmVf4m07z11j/h5kGdEFNCc4MXAs8NTr/1MdxD8xgP /fTnZa7B3HeexQyenl49BiOG9Kgx7wzkm928Ltua93bEyXun4N1tN+KFR3rhy2d+wJl/uAbNyyv9 u+hkfD7JN+e+fORjuKpfS/zywWPwTYvvxrcDR+Lh2/ohe9VcvDpphjU39/l9cr0dk2PQkF3+xMkQ 431JUc1Oq/hAfDUlXWI4BwulqA6JnI6z66gdr/Dp8sLLNS0K0eqk6w8lnCQ089038cnHH+H99+di T0EZRZdNVOo59AseooTzvtmLsGzhu0icNhGLMorJRiyS6RSYPukL9Hp0Dma9dBfmT52Ix5e3xax5 szH+sl/w2boM4ivDmo/H4t2W92HJsmWY/lsvJr63HMXkY1KyFwunT8KmtiMxb9503PzLDKzJyEfH q0bjLsoFO935EuYt/Au6JZRhx2JKOM97ydKxYOLVSHLdRz0evj5v37wGm5d/hsmTNuPa8WegAek7 tGYWJZztMGvJMvLrt5g28WPsKyP5Q1ushPOlOUuwbNECDO3IK1/cr4cwdf8AzFq4BAtnT4Z32lP4 zy+ZVmziMjdS/6IJJvmYZOTtyUODWPYlllaXf8GMKXNx4buz8PaIHpZdTjjHT5uNRYsWYs7jQ6h/ mZj10FNoed8sLFu2AOQN3luyz7Ibaiz4nY6cwOmlVf+b8Ls+8/DXR+7Hh98ux9Z9GSikKw2H18+x Es4/T/0E3377DWaPH2KNk5SUUvw48y1EXTIVX75FFwI8sdi1Pt2XsFMfSzf/iLeWxOOfs7/E9Ofu wfx//wtrMmNxxejn0JGM3/HcdLz12FCk4BBWUsJ51lOf4KefvsWEa7vrrllt9pl9dx7PvmOZe+gA Du9agqn3vw9cOwBtEuPg3bgQU+bG4N3ZczCiR4rjsWrY8zpMpsFmjbUFj6IHXWMo2rAQpbHWyUS2 2RU+bs7j+NCOxfTjNhizadwsWvAXdE1i/tA/rc6+DXf1nYtH77sL//76Z2zbn4nC6C4YM/ku8qET np0xD3/5TTcaj2vwECWcF0+eRefDQrw+xIunHpqFTHY2ic7KxdMxt/wSzJ73CnrTxZ329AM1Z9Ey LFswDQ3oHF69v5D8o/E19hnkDZ2MhUuWYOLwAdiz5yDieYw6nvOh9ymcOBgZE2czBswYMGPAjAEZ A7a/jTQ3c5yzRTWiC7RPYyHNORdMexAL3/0OacUUT5p92c4NvuyC12cvwKKF8/CPoV2t328PbbJ7 c8KzaDlyFuZM/wd++fQzZBTWPCaBfKs5r5N57xSUXzIN896+HY1jorF9zV5E0WJPlX8LPZg4Zx5m vDQaX079O1ZlxOCKMS9ZW33vfGkG3v7LNWhIv+GLKeE869nZNEdchImVfkvMTF3zWNnFxJpsOv+R ibPUkn9JLXg7DcJjR3ON87jm9DHaOWSHc3JO52U+HceWRN6O5vPE4S8Ldu47CBednAxvWSya0uKO 11vNfGAvr1kB37wxAfNLSzCX4DvAa6AxiCbSna+/iv/XMBMHk3rRCdEXjz4xFMW709G6S1/EFDSm VdOD2DmP2Ht/g78+Nh/Rh78Hlne2NESVFgA3v4R/Dm2HrWm5OIkSzdzG8cjem4PURkCjlHKkb9uD olIPOvW9FvjrvRiTPxxXXnoeWoR6JMgFKYkEfPzpdGD7Dsv+8+elYs22/Ujf9DVReuPtvz6GkhJe Q9oGT+kdQIvuIOu49//GYPh1V2JQrxZWvzZRv0a/eQmKt63GtoQ2GPlgX9yxaC9+06uxtUIcVfW6 D3plCf2TKxYxHLfJr+Kc5GykpWf77F77JM5pnI+NG7PoATIelGZlwPLmm9fx2PxoHF5IYWvPnQ49 Fk73Rh5ML8MNL3yDcxfOxPBHXqaE8hw8OIGO3/YFwDUTcFbDw1i7dj8Skz3gNbjoskI6+C/h92c0 xLYd+1HIY4D6FcOjjpbJCym1nPrMHUjYsx2l7QbQOHkZ5XElSM+JRitiaVCehx07vPDSKnL/a4DH /zQa3puH4qKBXatiQ2xVxW51topYCfCxfOvPD+Atqq8e/STmDOuJtA3rQCMLk1+9C8kHdyOdtv86 HyvaUhvXCBVRNNb2pKO4ONrqT0WUHK1KQwHGcYtOfYnpr7hnzEFcd+Wl6BXm4Mw+UIGbXlmIAf+d gVsffhEL/zMQf37+ViR4kkl/I8R607EnpwhZ6ZuoPRoXtynG6hXb0OLikehLcd974Go0TuR9znfh 1VF9cXBnGgqKY9GyTTyW/mcK1h4s8V08SI5ByYG9NL464c3L22Db6tVI6tCbzt6frK0czuc8qTbF RMBEwETARMBEoB4jYP/beAMKneZsCY3QJukgPp70PLIqisjTeDTgeUqsp8bcgOen1z55PVrk78HG rGj6vfXdK1ScxtPDObi2XS725Tam38emSKH5sV4C+qbN63i+bc1775yMUX0bY2daBu2L882jrOli DPvXCdNevBMN9u5GaYeBuBMvosRTjAN55dY8KqW8EGl7clCMk3A2TUz/fP89KB1+Ay69oHudbMXU +3sMtvmwuC2SY0nNck7yzONEc2uvzo5psA6I4yqf6nQVnjN514V4eYNC/+6n4eQWdP9cdBky96bT VR6fBtbVsAEnmJdh8DXDkFJajltu/C0SYwqQmeOlQQ8k5G7D1nIyH1VAK1gVyFizCY0oNzpcwkrK CZNgRX3Q+YNx02kpKI66Bbfen4CCrCxkklin1HL8bxOd3ShFAYlU8NUeSm7oghLVJcivzICbnvMA XW26ADPfeA6P3j0Nd0+cjF5NtMSAtAQt1KcMYnrkmQ9wac4HdDXsXrza8QWcc1I84vkLZdDFuOKm LrRrIxq3jqAVzbws5JQ2wQOL5uCCuTPx3N8exbTLRmPy1e2sxLn80F4c4uViL03wi8jpWFJSGcDY Ct9KJypKcJhY5CqLFTfvTmzP4NhW+OxSn3ftP2zpLDnsRVkiJxrA+Zdei9No5Szqlhtwf2IMsjJz EGosnJJOlNDW2mX5aNHjavz09Rl4nJKXtfsvQk/edltG9xTuy/b5k+27ClFKx6tjfBFWb9tn+eb3 h7tCIyBzwxrQdyOQk00bX2jhje7JLMktRB7B5d48FFY+jbX3H7/Fu4Pm0ZfrP3H/+4Mx/tkhaKwd Tkk6Hcc0xZmTy9HTFuB2Ws305mZix4adKKMroKCfiPyd6+ALcUKAY+VFAW8nL6exVkhJtTVaqaJa tRtoHJc2PQeL5tDq4sw38LdH78Zld0/ENb2asJLQSskhbFiZj+a9htKqZG88duFwrNpzGVq24h/N Cniz8xFH51ZiDAe4HHvTDln6923PtbyOo/FBI4VOqjjsXLfD6jOKduGpof+kPeFj8btL2+P7d9+m czAKsU2bkSwdr91paETd99IqZzZbCXjO8xE1xUTARMBEwETARKAeI2D723gJejrM2TJ2fYGhf3sP t/7lOQw+KR9L3v6Ednvx3LLm3IAxsYX7sO+wL6MssaY7Fdb8JbV8LzalURJaQbuD+B/9PlZO76o7 H8g3bV7HQjyP6pTgxTq6cG8VdoAL67b8S0HWpg3wMj43y/IjjnZ8leR6rXlUWQnNo7w8WapA3wcW YfoFc/HGc3/D3dMuw8TJ1yCcaTGbP44LHZGARY6QE5MqH4zXSYcjXpsWO/LVhsAd0B2vs05xvpS+ ewP27tyJLVt2IttLE1pe1qosLbqeQ9AcbNxdjCZNUpEUX4LsXE6bfEuu5eVWtkFz4EqXKyNUFaiY Vhh0M/Ddkm0oTGyCxg2TUJJ32EpYrdOGEktf4TUzKXQTd3Na2cv3JTs8wd6yeD52ezrg1kf+gUHE VsT3noZZ2M7hTcuwNXUoJt/ZCW//bTp2FcWiu+XoQqQXxqFJagNE0cmdS9835TlbMJ9WMDucdyv+ 8QhZn0MJN/Xr/11Gt4N+tsJKfFCUhm8mLcdlg0+DPAd35Y4MymUOYsGrY7GF1pgq8y2rn+Wl0rdK u5++jWW02st9zc3OhaflqXSFC1iyhlYamzRBw6R45BE+nFjwFlVJPDmRk09+xh5k5OQiY/t6/Lwu 3boAceJJLdB94I3A7Hexcl++9UWdn5NPK4GVK7UVpVXyrIeL6EvGCiznLdWEL9y3Ee8TrUPjREQl JKMNwfnFXh9vRQ4Wf/0Totudi7F/e5go21BOFy5Ej9TsM/seqPBFk3K6N3H58uVYs2mnL+G1BCro /uRKySDHqmqsBjIUYBznbFmMRXs9OO/Wh/EILXpuKhLDgRTWpOXu34X92Tk4sHMTlm/IsI5Hi1ZN 6KJEKjEfRn6Z71w7oedAak/CijROuYH9//saNPLQvVUsX7sBNpdbFdOKDu3HEqpvGnYBUgszsZXg KOKJSjqRJJbjlY9+xK60LfjixT9VjdFA5zzrNMVEwETARMBEwESgviJg/9tIcxWHOVtO1nZy7U4M PacDyg5lYLOfo/5zA1bxn7fnI40eHIjyIprf8kVe3/y2rIQvRAcuAX3T5nX8C27Ne6smJzV1N6Df 5aWr91sXjQvS1uNdYumQmkCLtUk4meB8r88/mphiyfzF8HQ4D4/84xGibEJpeFOPmk4cX5jK5MWx 09WpSc3cTBdSeXVaWG3e3xjJ4tRZcZzpOo/QbP1QV2dsGVQkXVmhoUzbSf+EtwXf5VY8+3va29qR DBP9UEVPzH7lAVx59+/xaiXPzY+9iIEneRBLbCV8dYY+cvknxmrTiWV5zVducnDqiNkY99SV+P0N k3waut6OF+lpsdE0RyYFPnnqpq/J7WicesW9tJ/1UfzfW/3wyPO3IOvz8Rg3vtKByx7AqK6NkJ1Z efJVol1V5B8n2nFxMfDu34iTbn8Sw9+6Fv+c2RNvPTQCrz/wEn73e/oWsgqtNr34e5xYtAPjx42r xAEP0FNEG9FDhE544AP8359uwn3/V8k9/AlM7BeP7dvL0G/kcEwa+xgWEem6++5Fx5WrrPtYOVa+ uMnTZEtQceoIvHLvIdz9twd9iroNx4ujL8Yts1/BpCvvxg2v+dBdb34MYwY2x44QY6EmnD5Nvr+l +7/DhDeXVqF63zEBV9O7Tw7F/haT/nAIf3jyUR+ty+145u6+8PCFQLpMJ8kmEyk156yzCrd3Jd3/ O2WXJXfH0zPoftz92JXfCIP/MBD3Pv4w3ul5C57+bSd8N+FxTLC4gEvvn4LuDYuRIXl4JZ7tsO+O Y7ryWMbSVlg/nko84+g/XUTJQQ/HY1VYPVYtZjo+KdRNS5ZeoMKDsjTwOM7fMR9/rh6ceGXsqajI 9K1CVnbFVeXdMw/jX/+5ircPjaer2ydin7c7Hhi0BeNHj0KvW+ghB1ecg4+e+D8MG3tfJW9vPPHB RDTI2Y4ifvpB5bnLXW/Y7f/h3r5v4I9XXwK0OR83XtYRr46diqYvj8UDn7yCN559Gv/8WwPcO/Ev 6DvuC2uMOp/zvivBVQ4awETARMBEwETARKCOI2D/2xiHw7H2c7YeZw9D35fvw3WXvoU2g67DZR2X 408v/Ijnx/Sw5n/q3ODUEZ/ggbSh+Nt9n1q96HbreIwe0MJ/nmbNDXxz4kqwqseBfKs5r+uvzXtJ DSnkOSnXvn/AnmVvYtRLOy0bw5/5BN0TDtDzVhrhonsH4e5H78Nbve7A87/vhPnj/4zxFhftR3zg NXRNLkdmcSXCVG4jECin4mmUWlRenabyCeyGR3hta9WgMDBO8ALrNV/cEBwv3TDMOP5wW+ic1AqO 8U4fngozjfnVuuuUKVOeIJy74mmO03qdbCV7VQLlh7FhVxS6tAXdL7bZWpFMaUUPWjkhHgXeMsTQ 1RZv2mpsPkBz2zN6ImbPWmw8QMkf6TqjV2vsWb0SB2jQN+t0Bk6O3oMVG4nRk4KO3TohoaSAFlFj kERPcF29cgtSOhJPTCUP3eDdsTfp2+3T16BVZ3RuEkv3/1XQPY+b0bBrT6TQlk9vGcnHerF5zWbk +BZ+qlx3BZCfvajP+TtXYwufndGp6HbGKUgszsSq1Wlo3qkrWsSXkh2+sBSHtNWraPtsB/Rqn4KC Aq+v/xkbsXlvHmWuzdCle1t4irhf8UiIOoT163bSHn0gtW03tGtIWyIJH+0tRHxKgqUrvZj6qcbN ctqDVp274YTYEl//KuNTntIKXTudgFKyS4aRQFt4V24+jA69QotFZmYmEunR37GxPGyqS/NTe+Pk xGKrX3wVLRk5WLtmO92bGYvWXXugBd2PacU7oRCrlm1Cyql90S5mN5bSw4Os4jkBvXufjL2/LMP+ 4gJMG/0R7lkwCV1IgzeG1nsPb8aaHZx80T2dXU9H8zheQi/AhnXZFPP2KC+guFG/Yr37sGrDXt92 UJ9m629JSQkKactrs2bNFKwC6sdSSBa+NfbTWEyXL+AAx8pvrPI4VI5PUxqjbWWMOo3jDqehLd1/ zOdHfFIsMjauw9680C85NuvYC60TipHPx5uOR4Oo3Mrx1ACdenVGPK0U0+NpsWZLJpq07YL2jen+ D8tmAg7tXI+ddBEmrlkn9KTLoXLuIjoFnXt1QHSRF0mJ9FxlumhQTvuHMjdvQKanMbp1bk/3sFQg bfHbuObetXj+1ZuQQF+T9ue8BFMCbWoTARMBEwETAROBuo2A82+jBy1t5mxZCa3Rq0Mq6GcPifRw vFJ6ZkMJzT+3bipAV5qn+s0NPKno1P0U+n31zUdknqXOA2R+u1edU1R2OZBvdvM6/3kvKVHnK95c vD7qP7j321fQJco3j4rK2Yp1u/jml2i07NwTTWN986hNG3LQpVdbZR6VjjWb99WYR9Xtkfn1a7/r rrvGUi/W04cDyxM3p1ponHkwj3y4zTROMIXGNX8Ep7YZZ/chdBWeYatwsqgXSSYZr8KSSEqCKbXg uZYE0w6WhFJNPAXnVHeZPHnyk7qDEWlHe+h+smjrlSp0a2dYxRMXRx0up4e1uJyQ0/2AHuIvrTQY TUttnugQ5MPykg6KZYdGUXGxNWp8aqJpdZS8oW29ev99/SqlfvkHxtJDY7FYF3Dwy75/Pru8V1TV Y89rrzg7Oxvx8fHWOy91juhYvpeVhhP1q9ArW50re0y0WIq3V8PrOnztHFqdnYbhz49GaiLJldMD g/zV+ZJe2k5dUhmmWPIpmu6l9ApCU1xKe0W8dE9vaipvL41McTpWoWi3HceV54f/mAlFq4+XjyuP Mz4eRdp54uHxR7iqUebapm8MFdN45q+cuLhoGqvFWPX2PZiyGPQ4AiCNPsOfmI4rmh5CppyeETjn fb0yf00ETARMBEwETATCj0Cg30bffEibs1m/X/DNN6PpdzXafw6le2L9rmvzLJ3HqR3cN5fz1ops 2lX2Bka89ACa0KKHp7yY5n3+Vvnd5TwflGllbfz213x8tkaNGqUnnRxxSSgZVtuC55rxPB3jD7cF Zrwkm1IzTWC7hJNxXITma9FfTvbcFE4wa1NEXhxhXSrspFvknOjh4/lkrOVCB0/IQyqUdPDRk8IJ X4gaRDSk2t4Of2nYW3fql70eZ1fs+e3t2vPa63baXsvcFZzc0IeLum2W20xjio5nWo0S2xlT//sq 9m9ehwNeluMtt/5cnETydRnBS9yc9Mv2Wn8ttWuJzdposdURgfODfeLjKsdD97FU//VxbVMdQwzz 958HVz/1A4YV5aCwtAxxyc0RX7CTHm6gWHWtX5ExoImAiYCJgImAiUCEIxDot9F2PqT+fnHyxj97 AYrt73oAfpUUsm+qsArTPOrN715H+hbaiUTzTbsZp28eVS1UG7+rtRhIiYA2c7UWE+3yL51PVDDe jl/oIdVuk043SnWn9DbrUDulwnb67eQoSwKrAAAgAElEQVTt+AzuOIuA+iChOut6aTo2bslGWXF1 UllbW24eJFRbG8evfDl2rF+PhIQE2j1A+w/27aXXqwT5VT5+g2V6biJgImAiYCJgIlC3EbDmUYdo R1PdmjHaa0QgWP6k5186v96uYUBDuOYPN+lkA7rTwdqqU06w2g9Ln98DVVSqgY/bCPB2DE7g6rqU qC94jYAx9pl9N2M6AsG0U0FbnQvztT3QdnwGZyJgImAiYCJgImAiUOcRiPQ8qs4dPjYM6PmY2iu7 /Ev4hcZtgVVZhu3wgfj95MNNOsVBP2UODXFQlVEdVPEOKgzaRKA6ArzSyVtVnbaxVnMefVCwV6Yc fR4bj0wETARMBEwETARMBEwETAR+5RHgfCxQ/qXSuKuSv6nd1nlUWlA4lKRTnA2qVGOQpFJ3XvAa u3/z66+/9keYlomAiYCJgImAiYCJgImAiYCJgImAiYCJgBoBPddSaZJ3Sc00N/yBeFT9QeFQkk7V SSfFgRxjeZWuwk76MHPmzHrfjsgraBs3bkTnzp2PiO1ly5ahb9++9W7b8SAYgokARYDPCx6bffr0 MfEwETARMBEwETAR8IvA+++/j1tuuaXe5y7y23Qk5k1Her54JOeqe/fuRcuWLf3GgGkc2QjQbrpQ czXhD5ST6flb2J0MJekMZEScFeedeFW6wCJrK+N76W1AFlu5SCCPpG3239z7F4mjaHREKgL848rF jMtIRdToMREwETAROPYiUN+/EepvU33blqPHdo8320eyzxJ3U4cVAcm/WFgSLBUXilKRdyUTqaTT yVnVGSfYSdYKxpEa1OXl5dYXyJH4EpE+HwnbrkaNYTouI2DG5XF52E2nTQRMBEwEXEdAfidcC0SA UWxKHQGVIak4kvPFI2n7SMU7pINz/DKrOZcaBR3vlIPpfKoOFWZ5t7yu39OpGggGq8bVzuiwyuek M+pIDuojZZvtcpHaKTgGbyJQ3xE4UudEfffT2DMRMBEwETARCC8CR2LuIr9NR8I2R0nshxex2kkd KdtHym7tonXcSKs5l3Sak4tASaKalwXiE30h16GudIrDqiEdZ9dR4dc7xHgVJ3xSW7T6/hLhrRp8 9YjLkbAtJ3J925agm9pEwC4CZlzaRcXgTARMBEwETAQkAvI7Ie36qFWb9T1vOtLzxaNhrlofx9jY iEgEJD+TWvIvqQMlmsJTK0dCTTrFUdWoHc7JOZ2X+XQc6xb5I7LSKV9a6heZ2uG6hFWb4kdd2jO6 TQQkAitWrEDv3r2laVur49OWwSBNBEwETARMBI7rCByJuYv8NtW3bbEn9kM58OvXrwd/uJx33nlo 3rx5KOJViyLh2C4pKcF///tfy94FF1yA2NjYkG2HYzckI4Y5nAhI/uRGVvIvqVnGSZ55nGhubFk8 oSadbhUH64A4rvKpuqvwkRrUhw8fRqNGjVQbjjDb5BKK7VD0OxqutBnUdul+fPXeXJT0uARX9jkx kDpDq9MIFGHVV59gXcmpGHplHyTUqa26Vb506VJMmDAB48aNw1lnnWVrTD0vbBkM0kTARMBEwETg mInAvHnzcNFFF1n9cYL1zoYyb9Jlw22rv00CB9PFSdfWrVuxb98+ZGdnIykpCa1atUKXLl1CSsDE Xjj9Fln2tTbyocpy37/99lur32ybk8/zzz8/7H6zDlOOmghU5U8OHkn+5UD2WwgMxuukwxFfV0mn apADoDuuBkWnqbLWiSjbB/wILhucDPKVpD179uD66693JSXbJfhEdmt77ty5aN26Nbp27eo6ubVz xpXtgnS8NWUKcm/tjivOOMFOTeRxmQtw7tXvY/I3U3GaX3a1HxPPvQ4nvT4Xt3drEHm7R7XGYqx6 8UVMxm9xyRVnIO4o8/X7iefilZNexwe3dwvoWWlpKV599VUUFRXhtddew+mnnw6Pp+ZXg5wPbs+J gEYN0UTARMBEwETgqI4Af+fTKxjASYoTrHdAfid0vF377bffxo4dO9CuXTvccccdFosdzk5WxYlN qVWaHczzwiVLlqCgoKCKnJ+fj82bN1v+DBgwAMyza9cuMByouJqzOShgf/nDxa3vqqpwbPOx/O67 76oSTtZ36NAhK/EcNGiQ68RTbJv5gHpEjgo4YE5FHrrOvzTeiHSu5syydmqdOiudZLrOIzRby+pJ acvggMzJybGSzd27d1dxyMldhXAA5OQPxTbzsi3+tGnTxko+U1JSHCw4o1WbDNsWOmoNiRCVklT1 hVXFV7Qeowf/Diva/B7zP7jdWn3bPP1h3DlpEYa/Ph8ju/pljFViwYAdP30KdL8KXRL4S7Kau3TP j/gcZ+LfXRrU9KWa7ZiF4lpR1/IS4KGgKGE58v0t3YEvPgeum94x6HH54osvkJaWZvnMNbevuuoq 2z6o49OWwSBNBEwETARMBI6JCMj3faDarqOOcxeNmRNO2V4qMnY4Tcy2qfpoy1CJ5ETz+++/txJp RvEOON5ayskYJ5rFxcUWvWnTpsjIyAj6+8l2OfES+4FsM03sMMyJrvSbV1sFFp+YJ1AJx7aecIp+ Tjx59dNt4qnaFh2mPioiECin0qepKq9Os+uMGx47uSpcdBUUHqA7EKwDTNd5dB1+nvDADuXDyebP P/+Mr7/+2koAVWWh6GG5UPnFFieebJ/9YH9C0eOO15e5J+esw/SJN1lX4oaMnordJRVY9+EUrGBH dr+GwQMexrrsVZhECSeXab8bjIenr0NF4TqMHzIE46fOxNSHh1TKv4xNuRUo2jQbN9KVvQkfb1L8 zsWS95dh4A19EVvufzw2/XcOMPBanAL60rX0DvDZoON2YPFUDBkwBNPX5Vq6Fr88EqPfWYd1M8dj wJDxWEX2KioO4J3RQzDk4ZnI5WN94HuMJL9XZbKPwXX5x+sQZj872urPgAEjMf7h0Rhy03iss+zQ RYHF0zGSdPKVywFDRuKd77dX9TEQbd3sZ6kfLDcED49/GDcNuQkzK/vkyzQlJrn4fir1zeIl319e 4OuTNoZ3L56J0eIH8frik4vF0ydW2hmAISPH4/vtvrgVbpqJmwbchJdnTsfDlbrHT1+M5eSXz9ZI zN1eWNUXjknhtu/xPS7BuW1i/fD+8aqwrnB++OGH4KuWUj766CMLr/OathxnU5uxYMaAGQPH/hiQ 3wQ+1lJ0WB0HzKO23cB2MnY4N7rc8CxfvtxK/Dix4/soL7zwwqq6T58+bNqi79+/3/pddKMzVH/X rFmDH374wVpJtQzSn9WrV1s4prmxKTyh2j7jjDOsrbS8o0kKrzTz9lqmiV43dai23eg0PLX7XpFj 6lBXT/R8aUT1iV0zN7NTocvb8QTEuV3pZMdUY6LUDmdHUzsmdK5ZPpCOCr4qxVeeghXm2bhhA3bs 3OnImpub60hTCXFxcdYVKLe2Wdbr9aoqLJi3avCnXdu26Ez3CbDeYIV5xK6jv8VFSCRFy999BrlD RmHExV/gja+n4ePFl+C2fuej8WvLcajxxZjw5B1o4WmIiy9ujOVfH8J5oybgrgtbIDd/O/bSVbX1 055F71sewphW/8ULH32A3z7XDjOG5mIP6W5bnI8q+/n/w793Nca4Xo2Q4xfDw5j36jpc9WwnZDM+ qhFa0NF8/92F2H95ayz9eBqySden89bh8tbJeO+DDTjl6UZoVNECyH4f3626C+1P/BGvrWCujyjR HIxmCz8EcaF5ojtdVT6ShrXT78eTMzej260T8JdLPJg6+k/IPtQVhwuoT2um46aH3gH6jsC/x56P H18YjcnjbkPOxH/jas88R9p1RPv9kzNBSvHW3y7ByucfxaLs3cgsyKH4eFDKI7uiFPnU/9XTx2Dc O5sx4vnpuKjkc9z40F/wXMdp+OPZ1VugD6+t9IOPz2u3oVHmNpTEF2Px6w/iIZLtO+JpjKVbaF64 8SGMu20XJn7wAjqR/7SGjg+enYRbxoyC953J+GbSg/imzRUYM+JivPDG15j21SqcfUv1NtpVc/4D XPUYUg6Tn+SiU+FttG+88YZf0slf+nw+qbFl+YYNG1pjU8c76TZ4EwETARMBE4FfbwQKCwurfguc YL13dr8dOo+0y8rKLJBr+V2xwwm/Uy2/TTJ3cuLj26x4Nw/fv8kPzYuOjrZWN4W/cePG6NatG1au XCmoKr+qEBoQznyRk7uffvrJzzar5USYaXyrC3+ClXBsyzyUt02r89b4+HjLXCi28/LygsYnWB8M vc4joOdf0ubciz9SBM9txktbauGTWuURXNDa7Uqn6lhQpTYMIq86r8I2IhZK5JzoVXjeHtGMnvzV oMHRdV8h+8N+hfpksKqOOQB8J0Ljq/6Kj8bdhFtvHmpxNUiMRvyJnShlo9KyM8445QTEl8fhlM4W Bt1PPwMnJPu+WJil8bDnMemuIbjunrvQlxEb9qCs443WvQ5P39CVMVbJWkM3nDceiu7xpYKqJKym VPFkXNaJN/tSqUjFuTdS4pP9HdbsWotlP/nQuxevxNa1K7ES3XBhj1Skdj2XIOCnFRuwcdUSHxMl VWvWbMQvX67EyaMuQaMyd7oqhamie3f/u5nqbhh9x9lo2vJM3Hq71SvEEjZj/RqLddRdN6JlSksM HXm71V60dm9A2q5VP1t8I0bfgjYkd83vfLGueeLkY/3PbB9YNHc2Zi9aZ8FLN2VYtfwRP0Y88QDO PqUlupw9CD1bllTKdsPIG/sipWlfjBzDvm/G2p2Hq74Vhj39Be66bhjOacnauuHltx7BdcOHWbGM ilWvH2Xgu4+yMeKyU6EdMXGjquYEk3945IeGa24z3hQTARMBEwETAROBYyUCnCTxrh5O7Ljm3zne zssf3vbKt5bwU9zrurDts88+2+/5H5xwMk7ddVQXfnCf9d93wen4urBvdNZ7BPQ8itt2EzydTxx1 wgs9pFqdqYYkaMOsd0Jvs4jqvArbqLMNih2fheMTtUWLFmhG+/D30bYIXmHkq15HqvCVtE6dOqHl iScihlaT6uKLpGXLJjh4OA8FedX9LC8sQj53uoJqbwmSCCwqsjAoK8lHSRljfKVl4zhaoSRaWVFl sGNoX0kesrLyhIXqUqz+7Ct0u/1NeOjVpb63l/rIe1d8S7nPDWgbS1crLUIZ2vcdTMQX8deHHwJO vhXP3+XFHx95F3+mJs57hBLiMpTFtsfllFP968PHcB+hh/31acS/8RDefexxagEPPdqKudzpsiT4 TxxirBFFW4TzC1FCi8r70jnhS7Y4YmIKrbqUYlFcGofiIl86FuWJpwclBKBVDtmyomKSq0DO3nRL T80/0ZX2gU4dO6BzakdMOOt6JJ7Yzo9VbJUV5qHQm0g0XsWPqvK9jHwn91BkLaGCHuhTnd42jvci N68QhdaZVYESuv8kL5ruCfGzQEds7yp8RZcR3uxA6XaZesQ0RmryPSwPPvig3xXX1NRUPP30034/ iDUlDcZEwETARMBEwETg1xOB7t2747TTTrMSTE6w+H5STji5HDx4EJ07d7bg+vgjiSeveHKpj4Sz PvplbBwVEdCnhbpTev6l8+ttXV5vu+avntHqKgK37QzondDbqowTrFrV5VWaLcxbJWJpeyo/RZb3 6vfo0cPVllZbZWEieesC22X77Af7w37VRckr8m1N8QtUQiKasrH927Blb5a10pXY2MJg28YtOJxf vfa1bs5nWJWRhbVzPsdyEmncrwcSdn6F0TfeiOe+2upz2bsNn9JOk2v6tfJLOGlDMX6e8SPOG3Y6 opS8JuqkvriYJQ9TzjnwbPqC70droVYTV13SC3RLKCWoUeh5kcVFjZMxoF9fnNlPuIahb0tfvNzo 2jjzcVx++eWYvhHodUU30rce/3r2HcycOhbjpu+itq80P9X3/smPZnyNjPwsLJn/jUXo1/kEBKJ1 OHOQxTftX89g5sxXcOO46ZUa9SoZ3c9m+/QkuJwYnNq3Nzq0bIzyAtp6u3Gm5eNYclJsTfvXNKyi 45OxayO2Znlwam/u/3p89PVa5B/eivnfWEcEHVr5kmbW67WCV320rSNZ3WQWq+z6+UtK8K9AK3q4 QbDCCeZvfvMba4zyOOXPsGHDwHhTTARMBEwETARMBI6VCPDWXd7+Kyt6/MwNKbzSyQsF+kfodVFL 4nkkEk5+0OXAgQOtT1u6BcyUYyoCNjPDqv7Z5V/CLzRpVwkpgPAoKL8FRRVfAw43GwrkkG5EHFRl GLbD67Jhta3kk7bb8ol0wfnnh/zepXCM8vZZfr8T22O73K6rZJP9S6JPg3h/T2mBDIhpixtGnEeZ zzcYO/IPWEsLmSf3u9baPvvNS2Nx0/S1lhDLI28dxg2/DQ+98pV1z+Ir/9cbJaX52EJfxLtJjkv+ 1kXYiGHo00wOlw+P/A34kB4MPOS05lUHkikVFc1x4TBOoIArBrZBkecUDLaa3TCoR+NK3gq0Ov08 KxlF36FoX1GINgN4hZTdGIDG9EAkLm50xdKKKJe4qAp0HfZPPHRxN+xZOB0z0nvSva4+Pzg5S+0z Eq89NAzZ376C4cNuw8SPNuCqMS/jnv7NAtLiuvwGL4+5Co33LMTUGYcwiu6hrFGsHd3l6HnnM/jr rX3xw9uP48arr8aNd46i+1UzEcX7e6kUx0VV2cKe2Rg38jYMv+s+LMkoRJ+7XsGjV3XDt688hGE3 3YuPNpyMMS+/hfOa0epzZfEdbg/irIOXRKugPoI1FqyDz+3DWPzhRlw15DSKX6VggIp/fAcPHmy9 n4zZ+D1l3JYf5QCihmQiYCJgImAiYCIQdgR4rsTzJjXpscOFbSCIYIcOHao4WrZsCU5K9U8VQx0A fI/pN998Y33UBLgOTNVQyQ9K4lVW/nAibspxEQGeFQbKv9Q8jQNiN4vUeUIKnJ0w4wQvsLQ5SWVY rXWYZ8mM44/AUvM0mWH5SNup7pqZmflEbU4Injzz46z5KlZCgrvXhfBq5QZ6KBF/Gbq1zffCSaJZ m620bHvZsmU499xznW/QjopHapMGiPLm4VCeF9FxDdC4YTy8eYeQ561AfMNGSCgvRBGHubAA3qgE WrmKR2FeEXi3Zv7h1Xjgmj8iatSbeGt4Z3pfUxFSU+KQk52L0tgGaEK6yr25pLsYPzx9OSac9ALm 3typMr2jo0cl44enMXxCB8yaex3ifHmfj0DDIzGlMZJio+DNJX/ou6xhk8aUFJYjnx7JXSSLb55E NGmUhKgyLw5l03be+IZo3CAO5cXUp1yva11xDVLRMJ5uiM87iOwDO7BiRxR6dG0DT956PH3Lg1iE AXj180fQJjoK8ckN0cBThjzaWutJaABPWR5yKH4V5LMz7SBWLd2D1t27ooknG18+/Ue8vOgQ7n/z Uww+MR4N6MEDFHl62mserQRHI6lhCj3hl2JPmS7biCvLRXZxXGVM+XgVa7YSEF2Ui1xvFJIakWxp gSWb0CAZZXk5dDxLaxzfBqlNEB9D/TiYTZb9xwIdGFw+fDJe/Hw6Okb7HZjKmNpX/MQ83lLLW217 9uxpy8QPa1i0aJG1PcmWwSBNBEwETARMBI6pCPD3vjzkxwmWDnMCdc0111TxC96p5ofX8MV5nqPJ Q23scE7ygpffpr59+7qes7Esz9XkeRv8vupw3jkZznxR/P7222/BD2ji0qRJE/Tr109Irura2J4/ f36VbX49zDnnnOPKpjCxbX5TA9/WZsrREwFaOHiYvNlAH54A8ppLoFpoPDNnmD8Ccy0w4zkB5Y/g BRa8XhNrlQzDVqlcK5FmwFoSz0BMbNSpsLxKV2EnmVrj+UuFn9LFn7osbhPaiPhQ4UV2liRmNAIo UVPvw/TmZqM4KppSqWLfdlZKP5k/mhKv4goaLzQMeSEz91AWyeVY+KxDlfr8dHnRqMcoPH+Of8LJ fahI6oExz5+DBBqKPAKrC72uI+cgfF+jPmzuwaxqskClhTiYpXBRkqt0qZIruK7ivGzILajlWavw +NgpYoHqxhj1/P04hQ59MV188ObnUAIehWj6FBdnKSuBAWjeg/hw/Fh6CFJ1OW/U87iiTRy8JeXI oxhW3wFbjgKKfRTHnkY728i3Rnmx//Hx86N6q0/B4UPVslkHq04W/fjmZas2/ceCtyIJI8b8BR0p udYOTHUHbCC+z2XcuHHWk/vC+eG1UWlQJgImAiYCJgK/8ghIwsndcILD7aIkmqq8HU6lRxLmRQm3 CwuRtCu6+OFBknTyc0DqsxxJ2/XZz+PQVqi5mvAHysn0/C3ssIaSdAYyIs6K8068Kl1gkXWSMfgw IlBByaV/YHnFtxKTdCqmfEn3/VlFwdewE4+el11ZA8uIFr0vo7dAhpTX2OqJJDKu/VX48suraqgs VgPBK9/0sS12tPiO+GdVrKqlvJVbgKsx1ZAVewcTVVx2tojoSrZKSU0gvkVvXBfGgeFEkx8VbxLO mjE1GBMBEwETARMBE4FIR6BXr15VD+xr165dpNUH1MfvJN22bZvFo24zDihkiMdKBCT/4v7IbFXF hdJPkXclE6mk08lZ1Rkn2ElWDYarzhgmEwETgfAjYBLO8GNnJE0ETARMBEwETARCiQBvLeYHF3GR 95OGIl8bXrYtT+utb9u18dvIuo6AmnOpQjreKQfT+VQdKszybnkRqaRTdUA1rnZGh1U+VV6FVRkV b2ATARMBEwETARMBEwETARMBE4FfbQSOZMJ3JG3/ag/Yr8dxu/yJ8y7GO+VfKj4QX9hR4If9hFJU h0ROx9l11I5X+HR54eU6EE3lM7CJgImAiYCJgImAiYCJgImAiYCJgImAiUDNCEjeJbXkWFILvqZk hPKxUJNOO4fscNIB3XGdl/l0HMuIvB1N12naJgImAiYCJgImAiYCJgImAiYCJgImAsdzBCR/chMD ybGkZhkneZXHjW5bHjsljBO8wHrNySrjuNZhfkys4BlmPt7Gy7B8mM44wTvVXb/66qsniM8UEwET ARMBEwETARMBEwETgaM0AgcOHEDz5s2PUu+MWyYCx34ELr300rHUy/X04dec2L0yRXBMt/vwCykY r9YM84cTUh1mnN2H0FV4hq3CyV5dF0469cyZcVJ0muCtun///n7t+mosXboUgwcPri9zxo6JgImA iYCJgImAiYCJwBGNwKxZs6z3mvN7I/l1HvyOc371HL8Wjt/NyO+15Fpgfh0d3xvIvJx08jvGTTER MBEIPwL8DlU+78I5B8lqwJyK6K7zL403/A4pkpFOOp06K51kus4jNMUtA5oImAiYCJgImAiYCJgI mAjUZwQ8Hg/atm2L9u3b0zu8o633WObl5aGgoMBqc7IZHx9flXhK0pmfn4+NGzciJyfH0V1OXvnd mFzbFaFxHYmi24u0/lB91P3R5SPtn24v0vp1/4O1dX90/kj7p9uLtH7d/2Bt3R+dX/yrzTlIOu1P Lp8x/cRSeXWa7h633fDYyVXheJtrbYruQLAOMF3n0XXUxp8jLvvdd98F9CEYPZBwbWQD6Q1EC2Qz EM1JZzgyqq4nm/5VbfrBgWh+jEojHBlFHLWVV3WpcF3pVW0IHAlbr12sntai2Vc70Zzw/tL124qE TxJPqSPdg5NO+iAiKkPVEyp/qE5KvKQOVT5c/kgcc7Ydqh7pp9Tif6Ti7EaP8EgtPqh1IJrKp8Lh yKjyTnBd6XWyp+JDsa3zSptr/cM2dJzwq/brC+YkkpNN/nCC2bBhQ5x44olo2rSptcrJK51M44mx +mE5LvzqLZ482314RZTxXNt9hGYn6wYntrm2+7AO4XGjT+cRWTvdKk2Xk7bpvzn+PBbsxr46Nmp7 Dgb4rlAnapx7qfmXTrNT44bHTq4K53alkx1TjYkCO5wdTe2Y0Llm+UA6nORUHWHDOdvXIiu1C9o3 9n1Zhq3ICJoImAgcExH4/dd1+pVzTMTIdMJEwEQgvAikpd1kCXJSKbBo0tuCr++ak0qe9PKqjHzY B8bJ1lpe6eSPJKA8Yea2FJ5YOxU3tBo8ZYXIyS+xVMaQfwmJidYDQuxsiOzBzcvxy24v2vfph/aN YqC37WQZV1aYj/ySMuov2UmuaUf028kLTeoaPGU5+GXJchz2tEb/szohTmMQOak1squmKiuw1K4U BGEKpEtoUtupckMLxGOnU8WpsgJLrfKFCwfSJTSp7Wy4oUXiHFRs6yejtPX8S/AsyjRpS62otECV R6c5tt0mnYESQ0flCkHkVedVWGH1A0XOD1n7RjHSt6zCl58vQvMh7SjpTK69ygAanFb3VPygQYOq NNjhBSe18HNbYFYgbbVmvM7DOC4q3oex/2tnlzmd8KxXfLDXWDusrA48nDXeUiRtqXU8t5km+NpZ rymt22UOwTGs2lXxKk3HMy3UIjrs+is01in+CE5qwTOP4BjmotJ8mJp/ZbVHkjdpS+0Gzzw6f01L 1RjhZYzoZ1jFC41xOo+0hV/aoiNQm3ncFnX1Qp1g2uFlUio04Ze21IJnHwTHsOAZx7DQVLwqI3jG 2RWRl1r4Rb/ISFutmSb8DIsOHc/tUIocL5bRj5HoEbwcd5FR8cyr41Ucwyo/wzq/tKUWfpYNpUhs pA4WN4mz2JC2yEut6tF5pc21zi9tqUWP2mZY8KouO1iVs6OrOOFlnK5faCpecKKDaYLTYeYRGsNO egQvvFILnmWPxSITY655BS83N9faNssrm+oqH/edE1O1sIzIq3iW07cXMp/gmJcTW8H5ZPOx9r9f YM7yXaoqgpvjuj/cgXbx/vKii+v8PT9j+fI8lLU7De1Skmu0NYXUzMeK2R9gwcbsalJyH/xh1AWI d0iiVXssJL7b9Z/pUcWZ+GnRMuTGR6HPmR3h0fqv62OZQEW3F6p8IN1M0/Xr/Lq92vLr+nR7elu3 F6q8rk9v6/p1um6vtvyij+2wLqlDPQctweo//ieof0JZzeXDq22BWd5Nvib8AWu3SWdAJZVE3Sm9 zWxq51XYTr+dvB1f6LjiQ1i/Zt2mTUUAACAASURBVCsOk2SbWi5y6kmX7oyeeAm/Hd4uURM+O5pu S2+LLOMFllp49bbg1VrlETiQPypN+FV9Ksx0LiwTqKgJEMOSAAnMbYF1PSrNiUdkmM5F9Ater4WP 8apOgaUWOWlLreJ1HdJW61D8seuvnV3mU3nFJ7Gr2mT5YIUn3DLZFlgm6IIXHU54pousDousWqu8 Kr8dXpWzg8UnO1ooOImb1CzLk1V1oiptqUW/2raDWYeKt5PT7an8AjvpEX16HSq/kw9iX/SrbYmX 1MJjV9sdXzl+6lhT+exgOxm2p/LqbZUmsJMeO98FJ/2UmvFOcVbjxHzSVvkFF0gP05yKKi+wql+X U2nCr/OE29b1qW07WMWxTW5zER/t6EyTInSpdbzoUWWEJ1K1+Mz66tJOMH95sisTXq/Xi/T0dCvp 5Akxr2byA06Ki4stNbzNlvFqkeSScTIJ55XQDz/8EHzfp1pkks11amoqrr32Wksf6wCKsPidyfgx k8D41rjm5ivRPtWD7MzdWPXzXiTFME+UlQSLD2Kb69iERkTPowcg+Xj0NhH9yqH/fW0lnPGtz8Pt w/rCk70dazZT30hXafpSvPLe90juPQy/Pb9NlZzESWr2Q3xgJum/0CtiEpBC+NyUBMRwHzV+keXa TdHthSrvxob4bscrNKl1fxjPOKHrtc4fqv+1lbfrk44Tn3U8t4Umte4P48PpP8uJznDOQXbNzl8F 53/S1uQPJq+oskDX/OEmnWxAdzpYW3XKCVY7outTabWD41rg/GuGAS+/RF9r4RW3yVJ42qulgiVj gRI8J1nxvdpKYMhJT2Apd1TRLT5JW6Ql2ZGJmZ48CV+katUO65S26A/FH+EV2XBqsS+6pC26dLy0 ha7WgWgqX7iwOtkPVwfLhaqHJ/51VdRkQhIMtmUXS/3YBPLJzaTSDY9qQ520qvhQ9aiywWDWLRN1 qUXGya6TnyIXTu1mzLjhUW07jatQ9NR2nKj+OMVNPQYqfyBYP1bM63S8AukJlRauDVVOhd3a12W4 LfFkWKUL3o1uO15VlxsdwhOunMhHqpZEkie727Ztwy+//IKMjAxkZ2eDHyjET7Hl+zs7duyIfv36 oUWLFlUrlOKDTJi5zTDrZN4FCxYIi1ULH9dnn322hZPEo3jvcl/CidYYNf4+tPJmo6i0AimnnIAu p/VHbvo+/O+7Ofjml020HZZFY9HhzMswZMAp1tZbmrZb+sgBq65uVycLkhBwXVRc6ONPaojUpCQk pPTB5aeWIyttHT6khJNNZK/9FC9tbIGr77werfLWYdZHC7CrcttvasveuOK689GC9sxyf9LX/YC5 369EZiW9w3k34urT5TEqvqSi/PAWzJg+B6WdL8ONg06pSrjZHy6sR3zktsBCl1hxLUViascfTJ9O F51Ote6P2Jaa5XRYZFSa8DBN+iR0lV9grrkI77HW/wicg4EmRXb5l/ALjdsCW7FW/tjhA/Eror73 ZPohXDbEQTfs4qAqozqo4t3oixBPifUCm1CVOSVHoeo5kvx6YnckfRHb4pPEd/G131qkUCbyoisS tdjVJ42Cd2MjFN5g+kTX0eJPMH8jTbdLAGTyL3WkbQbSJ8cjEE990yIxaY3kJNqp/5Hw00l3JPGR GFeRHCeRihsf40jpimS861uXxECPh+Dd+BMKrxt9Ok99nI+6TZ7Al5aWYuXKlZj/7Ur8tDEa2wpa IzO2L+ITgRYeehdn5i602vSt9bRafrVct27dqpILXtWUpEDVzU/EbdWqFY29tCpeSSJOPfVUK3mV 5IGTkPRdvi21jfpfjKZZu5HFbw60Sh4OWztgi3Fwz360HnANzmnnwbLPZ2D10s/wU/t7cG6rWGHm rMdKTqoQFb4HHXFbTVra9ugDLNwL76Yv8fRTP2PApZei7ynNgLhm6Na5EXZtPIz4lPY4s0cnNImp QEl+DgpSe+Om33RDzqrP8cWKFfh04ckYcUFbZK35DO99s50sxKP3hVcgNXs90uNiUE62fcWDqPJc zJ/+GXbnt8eoy3uhIi+3Ki6ShDGvHWyHq1TsVwmf1Lo+tf9M4+MhOD9FDg3h5ZqLHE+748909kN4 7PjFT6lFhmsugpdaxVkM2h/hk1rnt/NfcJoq26bwRrr/rK/GOVjUGgfjetNugyi0KMhE86xd+J/D OWjrrA/J+Vig/EulsYTkbz5p31+dR6UFhUNZ6RRngyrVGCSp1J0XvMZ+dDf15Eja4rXeFjzXklCp uGAwy9jpVPFMV9vBdKr0cOVUHQzXVg/Lc5G+DsoaZLUlyQp18sZyocpYBiv/ONl1wquydrCdP6JL 57fDC07vkxNe16m3WU7XxTx2eLGh6winra4WqvJOeOFxmwDY6bFLWFmvE15sSs22db12MbGLp+jQ a32iq9Pdtp30OOGd9Aq/20m08LM+llHbTjbs8OHK6br046PT3bad9DjhnfQKf12NEzVuAktt51Mg mh2/E662eliei9txJn6EYldsiKxdreoLNH5VPlWP4O1shdo3Va8OR1KXrtupzRN03lL7+byN+Gp1 E2wtaYPoRrFomBKPRimxtG31BHgTeiLt4GqU7liJkjlzrJXMdu3aWSrVCb5ug1czP/nkE2tCzTTm 5S27vXv39k8MiZYYm2CJV5TkIbe0oQX7/0nCpQ/+FfH5GdidmYO2DYDVB4DoqGLSxfeG+ri5ZjvS 5mm0JAnMIf4WppyJx39XjImvz4W3JBM/zH4XKzpdiNsu74P+F52FrzbOQ0r3C3D54FY4fCCLVieH 4JH+Fdi76wBSu3YHVnyLxKRE0leIjUu2W8b73/kohnaMQqnnAsTSbV1p6dt8TsUV4pcFn2J1fjyu eWgkGhekI0/yUR+H9VcSNLdJnCJqK899FZ3CK/23a+v8Iiv+iKzUrEOFRadaq3Q9aVP5GNbt6XTW JTw6zU7ejl/1h2XUts4vtuq6/2zXOgfnb8JXa5pja1lreFLjkdIwFo0aehCbeCKK40/DfjoHy3bW OAcrR75dRKp2qKr5lxv+QDy2hpyQoSSdqpNO+gI5xvIqXYWd9NUp3mNdDAvvpk5JjvRkSU++JCHk jjjBQpNadEqbay66vA/r/NdOj6pDdDprCExRdTHstqgxEh+d5GUibzd50+0xr/CJnM5j12YZ4Q8m r/PZ6WOc6ou0pVZtBINVOsvrpbb+sD7VV9Gn48QP3b6btiRtzKsmj054nrBLUfkFp9aqDsYLv4p3 A6s6JWFQcToscdLxTm2Z2ApdJpNOeOGzq1WZSOuxsyc4O7tCs6vVCXlt/LTTrR5TptsddxVvp0Nw qq5I6wl1nLBPdnFWccLDtSQ/grNrC03n57abotqW4+hGTvXFDb/Ko9pkfDC7Kr8KyxjUfVF5VP1O eOERfcwnOAvQ/gTSo7Eelc2V/9uFeWtSsNXbClFNE9CwUTwaN4pDowaxSEmMQ1J8NGKb9kdRWix2 pv+ApUuXWi+y584EmrQnJyejR48e1ioq8/Lk/YwzzkAiPY1WL7Id1ltSVJUk+k/6C/DtW//A/DVZ fqJRUbKFtRrNyY1MOFmv+Kjqq6DVo9wW5+HJp87EDzOnYcbiPSjYvADfb2+H8xoU+JSVZmN/uu+Z szkrP8HkL5ahklJpjHXHgB56S7eTNsepqdmUaJZW2aOlTh9f2hJ8n8bgSWjozaA7T+2LnpSp/rKE 9ENqna7LqzIMB+NnuuhQZcWeXqs8AosNbutF16/TxTbXXEQX11x0+zpdl1dlGA7Gz3TRocrqdqWt 8ggsNritF12/SrfOwbUNsbW4FWKaxCGFLvg0ofMwJSkGDRM9SKRzML5pP3j3eLDL/xysnkCpCv1h OR0YK/wqzp/bxxOIrvM7tsWYysA4wQus13xWM45rOcM5e2NYahVmnN2Hk17m4/SP6dxW6650H8ET hKv3wl+ivG3k11DUJE78tcMJzdQmAkdrBNwkfOH4Xld6w/HlWJPRJ/TcPzvcsdbvX2N/jobjcjT4 8Gs8dvXl8+eff45pnx7Ax2uaIapZElKaJtHqShwlnfFoQg/ASUlOQFJSPBJi6ZUqZSU4uPQddErK wiWXXIJ9+/ZZ927yZJoLT8b1STdvv501a5b1cCK+N3TIkCEWj96/hLIt+Nfkrwgdh4E3/Ba9Toj1 01eybxle/Xgx0OES/H3M5cj49B94acEBDLhlFE6n1+BlrZyJDxbtRb8bf4czm8X7tc9qXrmKauMf 6GE/zU5sia0f/Q3/XnEYTc8ait+0P4DJ//kBKacNxR2DWpMfhfhx2lSsyGuEm8aOR/8mm/GPP00G GccNpzfEynemYFEO0HvoSJzbmlc/K+fr5Zn45JXpSKOHFV3Tfjtmfb8HaNQHd952NuzeoSCxCxRP PW6B2qHqq2v+QL4yLVT7kdYXqv1Q+Z383bhxI6bNonNwVTPEtEhGUtNEuuDjsS76NKFzsWFSHF2o oU8Cvd6ITrVsOgdPTfadg5S3jCW96+nDG9JLg9TCw1k9w/wRmGsd5oEseBUmtHVdh3HyUXEMW4WT vEgU3zdMTU1sXIoT7CTLcqqM6DG1EgGTXCrBMKCJgIlAvUbAJBD1Gu5aG5MVulorClOBGS9hBq4e xYqKirB2Zxzik+Nxbv8T0Sw1FgdoKS6/OMpakUxMSkZKA5rwJidZKwTFbXqjYPenOHjwoOUlJ1jq ypS+UiQPFZo/f7718KCqhIyk1SS1sEEfXNPhK8zaVoyF/3kDaWedi64nNEBh9l78siINfa/o4YtK Tga+/2I6bVelvbVUdm3aga5ntvfR+C+tLqo2eFYp/qn29i39Aj/mtMBpHU/EjvULsZQSTi49e7ZF nIe2AROc878fsezE/ujcoTkSreWWImxf/iU2rl8My/r6VUjv9v/QpV9rLJq3Bys+mYWYi+hhS+UH kYG26NupAl5WWhSDbpfegV0//xMrDi/H7O9b4oYBbf36z2x6EsM4v74wQilqfxity4usWguPG37m EVmG9SLHWuLLugXHvG78C+SP6NDtStuNflVHqPyqrNhUa+lrbftvnYPbopFMF3ouHHiitcqZRfuv D2SXIC7WQ1vSE9CAtnIn0Yff6VnK5+Ce6nOw0ien/EnHO+VgOp/aVRVmebe8VauUqoLawqpxtTM6 rPI52VRlnHiOa7zTtlQn/HEdLNP5oz4Csr0x0o7Wld5I+/lr0+eUxDjhf239M/5GNgJmXEQ2nnWh jSfMuzM86H9GM5zfsxFOo5sle7dLpsSL7uf0xCAhnrbXUsKZTPdQNqT3fzTr0AcFBQXWq1TYHzUp EZhrFeYHCl144YV+W3JVuqWHHtRz+qi/46bzOlOzBFt//ha8CvvNDyvooULN0PLk03Bha0oFM1fi 669/Qqvz6CErxLlr6TfYq7yWwFP57k/WycVDT9LV/WE8zd+RvvFnzPviM3z+9c9IJ1znS+7EwGbl KElui8H0MCHiwE9fz0FmSTK6DGC/vFg8bz52NuoOi5y1BuvSstFs4O/J7w5Ez8TSeV/g829+wpY8 fs1MjOUjokpwIK0A1917vdXOpAcR/Zzuew2NxIGY/WImPgeqVRkVdpJReVTYiT8YXtWhwiKn4lTY LV34nGpVpwpHit9Jj+BVmyocKt06Bw8k4Ow+zXFut1Sc2ioJZ7RrgNg4uhiUmGTdO5zUoAEaNEpC arNYND3F/xxk21Ts8ifOuxjvlH+peDt51lurEupKpzisGtVxgRy165CKU/UyHIim85q2iYCJgImA iYCJgImAiYCJQJgR4AlyfnEsutIkNyk+BqW04Y7v4fREl8LDiSdNfD00c6Tn/4BApJ7YBAcq39vJ JmW1J5j5k046qYqXbdYs5di/9QA6XjoCL1xZhkMF1hohYuJpy29iOfZs3oeOf3wSFxXmIiY5BWWF BYi7fCiKY5KQs3sLyi67Hy/8Jha5aVuQlluKNkp7T471jhW/lcBWg/+AZ4eUIr+glPYYltGTahsj Ji8DO/dmoSIqAWeNeByDyoqIEo2ctO0o6zcCz55fBm9ZDOKiSMZzDT2AiO4Oy9mDvXvZ71Hkdyly yG0PBSuuOANb9lfgvhdeQGxpLrZsScOeim54kto8ac7etQn78nl3o/siq4JcuykcZ5FhfoFFPlS6 blPXp9P1tm5Ppwdr19aeLq/7E4yu+6fz63S9rdsTOuPzi6PRpW0yvY4oisZXBUppaMXQ6npsHD1I iD4JifG084AeuJVE9yi2aoIs5RwUPTa1DBSp5cSTmvEC6+JOeJ0vYDvUpFMcVZXa4Zyc03mZT8ex bpG3o6m2DWwiYCJgImAiYCJgImAiYCIQgQjE0Mog37bVkB5Y4qEZGKdBMTRTjKbJbzRNfnniS4uF VsLpocQzhpIqniTztllOOBnmj9sSmNeLjF1bkUEOxNMqK5eKsgzs4UyYSs7m9fBQ5ltRsgdlZDLK E4eYCnodHjd2b4Zvg6zFisNa24f1+c5w7t6tyI2mBDKW7JB42f59oNeC+grdw7l36waKA73qhIil TCD+HPIrhhMC9ifKgzh+lQrBLJaxa4vlN70pBeV0H6vlE+E3r7Pe9+LTm5eO9et4TTW8IrGT2o0W nVdtC+xUs36h2dkSmtR2PDouFF4n2VB06LxqW2Cnmu0LTfdFpQXi0eXseH3nIGhXQQydd2yUTjg6 F2NorDMtlrbXRtOTcGLo/ONzkE831sPnIHPrNgK0JceSOpA884Si29ZsqEmnrRIbZLAOiOMqn6rG Ca/yGNhEwETARMBEwETARMBEwEQgkhGomqFxikWrY5ZuqmkGzItq0fRhFrqdDCW02skrPFLUSbS+ 8sM0wTG/wCKv00UnSktQRB+7UuL1rYBatNJilFTa4LajvkpF4qvUUSTLdpz8KS3x96GCePmpKlah ZNdb1fChospK4aUE1Umf6/5XmghWhapP+i01y6sr1YwXncFs29FFlmsuur5gdDudgXCh6pN+S83y R0P/rT7y+2757OMLKPSfrm3Qh48HpW0Ec37JCWkMnYOldApIjEm2+mS0DxZJByyqfDDegIrsiFZa bEeIII47oDtep52KoO+2qvhhCPJRGeS1ElKrtFDgQPJ2NDuc2AtEE55gNQ9m+QTjDZeunDDhqvCT U/utwn5M1LCj2eFELhBNeI6GOhQ/Q+EN1rdwj2O4csH8qWt6JP1mXaJPat1/4VFr4bHDCc2uFhtS M48Kq21Vt8B2OnWcrk90hqJD1xmordtT22JTxUXaHzvdTv46+SP8ui7B63UwPTq/aZsIBI0ATXh5 +aSMVi6tyRolU9REBbXpv5VoVVBNOZVVeAxWrrJYiQVP4vnDT6qVWoWFLiujXKuw0EOtVR0q7FaP 6qMKu5XX+VQdKix8qo8qLPRQa1WHCrvVo/qowm7ldT5VhwoLn+qjCgs91FrVocJu9ag+qrBbeZ1P 1aHCwqf6qMJyfnr46g6dgZx+ltOrgPhTyudmDK3u8/lIVH4LTwWxKecgowOVUPIvlTeQTte0SK90 OnVWHGe6ziM0104fSUb96Xt6u659C+e9b7XxiQcynyBS9Lbgf611fcezvuJ0pPqljpX66uuxYCeU 88opxowPRU+ocXOyG0iPLqP7p7cD6XJLc9JpFx+dV2+7tRkqn25Hb7M+PXZ2NnQ5vW0nY3AmAkEj 0CyZttbSZJeTTWIuodUWAukTbd3TyJtbSynh5F1/Mj3gsceFJ89q0cex3tZ5IzmGRZf4ZvcdoNpn PvZf+AXW+6TKBIP1/uptVT6YfyqvG9j03zd/leMZLL5Hy/G3ju0JyYhKjKH7qaMQSydcHG0vb0pb 3pvx+zoTo9CYH+RF93Om0MO8iiqzqMp+BsqpqifzvgGk8uo0uyHmhsdOrgpX26RTdyBYB5iu8+g6 qpw7HgFZdZJaTR4C4exoTvETXqar+p34Vbz6hSknMtNDxesyqg2BnfQL3anm/km/pK9SC55lA+Hs aIHsCU3VLzi3tdhkflWPHV5wzKfCLKu3BReI106G5fTCx0Q/1tKW4yVtlhV+J5quX2QEL7pEj+D1 tuDVWmwKTtWl47it8guvjue2SuO2Xpz06Hxu2276GkyX+BTM92B6QqG7sSn+SB91GWmrdllG+AWv twUfrBb7Op+uT20zLMVJXuhSi4wbfuFlWeFX7TNe2kJnnCkmApGMQDllnLwVzmu9coSSTJr48v2K pZRtllXEWfd6Mq5YWe1k+5mZmZF0w+gyEThuI8AXdmgTrZU1caJkrXTS+VjKuwyozTje8e3VzkFC O5XqHy+fuJp/6TQ7HcwjMlLb8Tni3CadrFx1SBTa4exoTs6xfCAdTnJio95rfuQ7r25KUR8BL4mC 1MzjdjKv8jGs6hBbatKg4+z4hUetdd3SVu2r/E6wTHqELm2p3eCFx6520qPzBvNbYmYXH6GpOgVn x6/yCSzx09vB/FL5BVZtil6phUfa4qe0hc610FQcwyqvwMKr2hZernU845wKT4D5uOlFPZYCSy28 ImeHD2dibaeHbdnhxW/VjvBJrfspbb2241f16vzB2ro+5meclNroFlmpRadTHapd1qvKsF4dp9pW +yqwE93JR9WGKhuIX2hiU9p2tc6jtgWWWuTVtgoLXa/Fb+Z1W4RXZN3KGT4TAacIVFg3jdGTM4mh lJ4oxM/X8dDDhGI90YiloUkPsgW9PQXlCf4aLrzwQn+EaZkImAiEFIEZM2ZY/BUVZbR9tpwu8lAq VB5lXfAp54tAROVbnEv4QhBvLAj8U6HnUdJmKVVS8Gyb8dKWmvFqUXlUfEDYbdKpOhZQoQNR5FXn VdhBzC8gTjz1ite30+pt3RmZtPMkn4u0hc8JL/S6qMWmqlv8Epq0VZ76ntiIPdUHgZ38ZLyd7yJX F7X4ouoWH4QmbeGxw6s4nV/kdLzeFj67Ohxe1SdVJx8btxNct3yqfic4FLtOOuoabzdu7XDB4uLU 12Bydv0LR0bXEwkdrFPVo/ZRxeu2VT6dFom2k34dzz4yjgvDgXwWv+x4VD3CF6gWfrVW+cWG7q/K Y2ATgZAiQMOcn17L94xZT6ylJ5nwk1hjKRnlpJNyTnpSLG374+VQU0wETAQiHoEoXtGkc6yCbtr0 ltHWdm7Thx+ebMGUdBJI904HNO37wapm4TaL6UXnE7oTv9BDqt0mnW6U6p3Q26xD7ZQK2+m3k7fj +1XgZMIvk3hxWvDSro86kE2h6X6yXzLhqQ8fxZ5uS/wSP1U60+zwKk9dwIFsCk38FvuClzbXgjtS /VB9EVj1SXCmDhwBSQBULjsc09UERuVnWM43J1md/0i0xX/VdqT9DSeRktipfjnBoeqX/qlyEge1 Fj4nuypd5Jx4Q8Xb6VPtharP8B9/EYiiFc0oepBJNM8Si/n9gLH0pMwYem2ID8cLobzaWUY0U0wE TATqIAKUYFbQVR/eQlteXkbb28tRTMubpbSnvazCY91XzSue3prnYLD8Sc+/dH69HaxzrvnDTTrZ gO50sLbqlBOsdkzXp9J+dbAkHTKJlw444VW6LiM0uzrUhEXn1/0ZG/W4nZla4ewmRMEUsgxPmiQW up/B5IWu91fwTnVt+Z381PGqHe6j2lZ9c8KrPLWBdf3c5iJxfxjjrUSJj4Uck9rYY1k340G1Z2dX dNhNrIVWH37qNsRXOx/YV/FX+HR5td86LZS22Bd7ocgG4g1Vn1M/nWy44Ze+OekIhHfSr8Zd5VFh lYdtqLEIxSdVZyBfdXvM6ySr+hJIp6GZCDhGgGZg9KtLr0fh93NGIwal9KE2fXibLeWg9I5K38dR hyGYCJgIhB0BfkVnMS910jnI909bT7Gls7CEnuBVzFtr6V7O4srVUM1IoPzJLv8SfqFxW2BNtS0+ EL+ffLhJpzjop8yhIY6rMqqDKt5BxdGDDnRPp52X+qRd55HJvMonSQfzCl2V0xODUPhVXlW/al+1 JRMdwclkpjZ4XVZ0qxMonUfsCq/ERfxmvOCER2q1z3Y89RlP1SeGxX/VR8aLn054kdN9Z1kpOk1k mC76BRaa4PW26HRTq8fRiV89vk4wy+rH3UmfjnfSqeJV/W7wOo/YVPur83BbtSMyodSiU3SxPbXo eNUflc8NLLaEV3RLO5xa9SeQfrVfql0Vz/aZpupRYdU/HS96VH+YX/Aiy3JORdcZiFd0qPpVfsGr OJFxW4fjj1vdhu84jwB9z8TQp4ImubTo6UswaZ+th5Y46f301qoDPVATJTwzNsVEwEQg4hEI9WFe LhzgH7dA+ZdKY3V2P4Y6jwuz/5+9L4Gzqrjy/vfezd6sCsi+CYLSRMDEFUkkRgNxS0zEiU5cspmY yTLxy2RzvnF08hkly7hMAqPRxC0RjUpUcMMFERRQFqFlUUD2phvo9XV/59zXpzldXXXfva9fQwNV /B6n6iz/c+rct9zTdW/dgyrNz16SfOYJX/oy5qv3ua+p2eevIObxS/pCucjlvrxk7KInlpWV/Sfp H/K2ePFiTJ069ZD7PVYcmid+rZ23WWC1Fu9osz/W85Op91umcMz3V1vhmn7a6/hYn7/tuPic2LLi eW2dAd7E5NLbC/HDb43B4L4daYUlC1W0ovLq2mr06N4J3bt1RY8eWehSDHTqSI9rOAC8/MuZmD59 OqqqqnDFFVe0dYge32fgqM5A02fwayeid78Owf2bB2qz8NKaavr8daLPYVcUd8tFZ/oMdqZHplTu B977VfIzeOmll/6IkrOaXnynJ+9rG0ZFRuulgR6Ppc9U+sznApRfwpe+8E1Kqk023A8aF3tRmxSe Yfrs1NXYXst132Xj+UdRBvgkSlpr/rovGJrKCp3m+f6xnYFMvd8yhXNsHw0/+ygZ8O+1KFnyOock A7SiyT/ZvKqZTTtn5tKyJl9Wm0v3dObQpbXBagPJ1M/6IQnLO/EZOGYyQJ+/NDbzOnii7U6Urr9E X/NMS9YJk5v6znGcotMJwd6xCQAAIABJREFUooKR4F26Wi79jEzE5dDz208GMl1otp+Ztf9IjsWi PFPvt0zhhL1L2IcUHIfCX1gsh0N2LM7ZlmefB1tWPO9wZIBPzHjnWt7IhL+beAOhPKpAg51sic/3 c+bSGSRvJuSbz4DPQOYz0IabeUn9xUFLDaZ5cSYj9pFs+I9VmWiuYHUwrr7LluPSNpmI02P4DPgM +Ay0ywxwweGLjnZ5aHxQPgPHXAb4uZz0iEA6Ccuiy/vogfS0cyY/qoELUb6+jk/O+OH1tS13zjzm cpWJCdfsWodXF63mjYIbWwLrl7yK1bsOckQSlQaYL72El+j16qJ3sa2Sr5I8RK3iHdzyi1lYn374 hyjQduyGqqPkZl50ZUGwmRffYS2bedHjisI383LVTybfVYOZeq5Eueyt+pkqOjW4DlQHY/a1nrbX fW2j+b7vM+Az4DPgM+Az4DPgM+Az0BYZoF0zs6i8TNBDAHlvrQQXnbSFJhea/JgGempDwPdLA5lJ /qbX5+L5eQ9h8TYpDHdiwd+fx95gCxSXjzK89PeXsMsh3vTKI3j+tY10zCqwZN5juOv3z6HSoZtp dkXpStR0GoN++ZlGPobw+AqD4MWbeXGfL3dvuZlXNu+S07LZ6ieuu5jvqr8032bf0ktMTtzLayVg 7cbkhQVqm5DmaVzuh8lMXT/2GfAZ8BnwGfAZ8BnwGfAZaGUGuLgM7tykMzo+EaunlZY6XvGkZU7Z VYSfH1gd6LXS2TFvXoF1a/YFWXjj9VX41IyTgF0b8BGGY0YPrigq8e5L87Fo1Uco6j8e5312Enqg DK/+9S94ceU2rCqvxHkXfhqDO+vqowKrV9Vg+IVfwLkndcaIyjX445o8JCo+pJXPN7BxWyW6DCrB eeeehCLCf2f+a+g04WwM65aDXatfwjtVo3DuKX2QKFuPF597BRvKa9FvwgWYRjygAu/Mm4c3NpRj +OkXED7ziPvhO5j3whJUdh+G3tvWonjMafA1Z5CatP5ryKJVTSoys+kDx5e1c9HJjyzKJn4uFaN5 tNLJ93zmRV8+lPpMqNRYQpkvfTNmF9/UCx1HDzUJI4FqUBvPFZypy3omj7HF3ibTvg95n+9tkJfp XPhMdZOxUC0z+y4d5psvtjX1ZWzTFV9aJrwwqjFNPZEJX2NL3yaz8aLoi52Nij1T3Wx8zZO+2MiY qW4uvtbR/TD9MGyxM7HMsegJ1XJbX/SYms3kaV3paxsbj+U2PvNEFnRC/hNdm4pgmzpx+FpX+jZf mif+hNpkwhNMTW0yG09sbDLhhVGxZ6qbja950hcbGTPVzcXXOrofph+GLXYmljkWPaFabuuLHlOz mTytK31tY+Ox3MZnnsiCTsh/omtTEWxTJy7fhq15gqd5cfoSn1Bta/LEl6ain4on8jB9kdmo2DPV zcbXPOmLjYyZ6ubiax3dD9MPwxY7E8sci55QLbf1GxoSdCktrXQSBT2Yvo6q0HoqOvnkjFc66Rn1 qOXrbJtP2wbleakyULkZ7+3rj2lTR2PfsoX4kPTL1r0LDB4dFJeP33IbHttYhCmfn4oOa+bhnidp c1KqLys2bQP6T8LkcYNQ3EEXnARAmGtq8jF6YGfUbHsHDy/Zh9HnTcD+0vdRd/wnMPWsfli28DGU 8tJnRSnmLnwTdQWMkcDqZ1/E2v38p4VteOjO+7BtwCfx2bMmoH/vDsQrw+O33I438sbiC+cNw8LH /oR1dAlt2erHcfsfn0HviVNQkrsKiz4CxozpR/q+pZ0BvZkXrXRG3MxL6qcobuXTK5RtXPZaJwq2 VSfuSqcVxMLUwdkmIDytp2FcfK1z2Ppy3xV/edv6HJiWZSpQ8RUVT+vreJivx1HxTD3GsDXTL+uY /vRY6wueltvsRU+oS9/FZzvtl/W4ufRd/MDI8l+YvvgyzWzxsE5cfRNXMEx8GcfFN+cm/lx8kbeG mtgyFirYeszz02PRkXnLOF3K2Lam8UXHjEOPtb7gaTnzzLHoCTXlMhZq09N+WY+bS9/FF1yThumL L9PGFg/rxNU3cQXDxJdxXHxzbuLPxRd5a6iJLWOhgq3HPD89Fp0wGlc/DMuUMbatyXFgmeiYceix 1hc8LRccm14q/TAcjcd6Nj9iL9TlT/hCw/TFl+gKtcXDsrj6gmfSLF7RpDO1hoYsVCeyg8c2JIjH 93Uypatug7NTpr61LgOVm1djX6dR+MSnBuPt5+/FG+9uw/DS7Rg85gSUvfM0ltWcjO9deS46k5vE AGBZOT0jg0ad6ZE1g0+ZjFNO6tYigMrNG7CP7hCde/svMJfWG0+eeiUuJL0cnAGs34Qd27na7I/u tBRZsXEV3SA4HgOL2ME2rNgDjB9Fq5c1m7CTWPk7dqFg/CScRLpl7zxC8QAn5+7Fhk3bSco7SZXh uYeWYfTF38NZoyjKgafjsUULMKSPX+ek5KTduFDie6hjbuZl/6I9GAXDhjVtn0o3DMcqa6uiUzvj CZiBt+mktPO27POXvvljkUl/UbB1DFH0U8UnP1j6B81mI75EX3Rcdi6+2LWWRsHXsbr0Xfy48blw 4uYtrr4rzkzHY/qROE1+a8ZhmK75uPhR42Cf3FLhSGyiL/guOxdf7FpLo+DrWF36Ln7c+Fw4cfMW V98VZ6bjMf1InCa/NeMwTNd8XHwzDsbmFkVfdG36IkuFI3MR/cB5iP9UeGKfLo2Cr2N16bv4ceNy 4cTNW1z90DipsOSTXb6Etp5WOmvputoaWt6so5s5Ew25Tfd2VvuNYkLTGEW4+d1SFJ8ygQrCvjj7 5E54iFcPqVD8zPk9sOGJtXTZ65VBwclYe8uB4kG9qTjcgiW00PmpoS0LTtbbvPo9qkgvwA+/Mhb5 OfnBnaE1W17Fbfc+j4GTpqL75iVUc05DH1rcXLuCvI29lC6z5ZpzLa1vDsag4LLewfjKF8/GI3+b h98uWYNrfnIltq9cR3YTcHxhHT2/tS+mTZ+MARVr8ACKceUILot54XQ5PcTV388ZJKMV/6W5mZdZ b5kRxKm/tK6Jk9Y47uW1qZy4JiuBs9zUEVkq7CNWLj8oQqNMRH48tC7z5KX5jGvT1zqt6UvcQhlL 913YrphMvsyJaSaaic+YNp74cslcfLGLSjVO3LzF1Y8SU2viYXy2l5f2JzymuskchGqZq88YUfRZ x+U3DFtsXDqaL3EIZZnua13dd83B5EssTDPRTHzGtPHEl0vm4otdVKpx4uYtrn6UmFoTD+Ozvby0 P+Ex1U3mIFTLXH3GiKLPOi6/Luw4fImD/YivVPYSt1DW132Xvfgy5SY/0/M18dm/jSdxuWQuvthF pRonbt7i6ofFxBda1vBSJ72daf8guuiStxXKQW1DNvHp0lq6l7OGVzzNM7owUC+zZIDvvdyHESNo ZZHa8NNOp/95jXIABnWrwf4DvGlTdSCrWDcff/8oH1MmnoCaLe9hD61UHm+tOQlzxT4MHzcURY0F J6HglT8/j46nX40vTxsH0GJp/5MG0RGl+0lX1uDEYXz/5mrMufdF0BIretIRL9tVhh6jzsL1/3Q2 +S+jFW863nX0V4YugzBp0qdw1qc+hU+ccgISe7YG8fGqN1/KO/sxup/zlBH+fs4gK634L73NvJr/ ADV3b35ata4pa26ZHEXRsdk18Vq70mkGkGoCLDd1TIym4I7Vjv7R0TmI8oOi9RlHWlTbqHqCG5fa 5qZ9ipx5Ov6ofsRe69t4Wm7rmzaZjMfm71DxzHml49d2vBjHxY/rI26Mcf1qfTO2MJmpm87YNjft U+TM437cJvbazsbTclvftMlkPDZ/h4pnzisdv7bjxTguflwfcWNMx6+2SRUfx+NqcXBcGGF8Wy60 T5EzLyxOlw+x13IbT8ttfdMmk/HY/B0KXj1dQ8urEtV8HyedpXHhWRvsXssrnfnBZkLM411sfWtF Bmq20b2XfXBZ3+SlqDl9xuH04nl48/gT6X7OfJScdzZevu8h/GIZ+yjG1Cu/BdoXCImaXuiERbj3 lgdxzQ+/jL76ls4AMx/nDtIVaQ56DOiEPQv/iF+8U4xOVDvue3s1Kiedhl6DgXkP3Y5lnYqDQnH4 GCpG6TLbJ357L9Y3Tm3C9OsxmEI8buo0vHrvY/jFLx4LJJOu/CGmDZiA4fnL8MBtv0B+cXHw2JfT R/RstPQk3Qy0wWZe+sucay9df5kyW9isIzZCbXpOXtSik8F1QAJo49lkruDYPgzDZSc+jkoqP1j6 xzVsovKDJ1R0o9qLfiapGQtj23hhMWoZ26ZqNny20Tgmhs3GxjNxWhOPGYMeu3xrHd2Pox9HV3yk YyO26VI+XofDb7rx2uxs8dt4Ye9NLWPbVM2GzzYax8Sw2dh4Jk5r4jFj0GOXb62j+3H04+iKj3Rs xDZdejje/zxPbrb3io2X7txcdrY823hhsWiZzMflj/k2fOZrHB7rZrOx8dhG47QmHu3f7Lt8m3oy jqPfQJuY0DaZQRFSR1tk8qV+ubR9Zl5uNvLo7ZJLt/IVUBFSXyjonqaVgfxh+JefDVOmRTj3hp/h 3EZO0eCz8OOfnAZ+xGZR/sF7JHN6TMC//Hg07TubT6uZypy7AeaPDWYOTrn0XzC6pgb5AU4C1CXr HEy68icYRw6Kig7is/GVP/sJaipJqagoeB8wr6jvJNzws/GoJP184iddn4Av//gnAc/EYBvf0svA wc28qBSqz0p3My+zjpIxf+nrEwvhc7DMl7FQ5uumdTQ/tB+16NSBhQI6hGKvg9d9h1mzhLh0Dhs/ zhe4K0j5MdI/UKzL4yj4WieqjSsW5rviCbOJItNxRtHXOjZbM06bjsaI2o+CY9Npq3iixm3qtbd4 zPhkbMYp/FTvZTkGQsWutdQVTyZwzc94VEzbHM04bTpR8bVeFBybTlvFo2OL029v8bhiN+MUvbZ+ /5t+5b3JfOlLLJqachNH67amb/qJg2WzNeO06cTxIbpRcGw6bRWPxJURSmdt/DgG3siEH9fAj2nI pwojj4pRLjp5+5gckuVn+iatjAR/lIHQJbItCkueYn5RcB9mnNkmC062yKHiUyxzqK40K9dGHSos WzaKpwXbhdHS2nOiZSBDm3lJ/SVOeWyrv0y9VPoij0WjFp1RQM1JmGPG0JPSfRu+zd6md8h55g8G ByAnCRJM2A+36KSigilY4lfshC/jqFRwmLYWg30KXios0ZM4Wd/GE7nIUuGa+jJmO9NHFCzxq3G4 L/woGFpf4wiGlofhxdUXXzaqsVhu5kbkYfGYNqLr4tviiMoTTKbSF1sec3PxWSbzYSr6ms99blqW 5KT+X7BZU/qpcERP0M3Yma8xRF/zxNZGRV9kbGf6iIJlw2FM4UfB0Po6HsHQ8jC8uPriy0Y1FsvN 3Ig8LB7TRnRdfFscUXmCyVT6Ystjbi4+y2Q+TEWf+XFaGH4cHImFbaSfKibREz9mLMzXGKKveWJr o6IvMrYzfUTBsuEwpvCjYGh9HY9gaHkYXlx98WWjWbSimUUrndl8lkiLXXn5ecih5c4cqkSZxwuh vNqZIJlvPgM+A22QgfQ380pVP5n1l6lvjlNNLrJ+ukUnOzCDTjXWQbn6emImnpYdtn7YF77I9Bd/ qkDZRusLhtjJWKjwhZp8GQsVPU3TlUXFYD3ThzkWLBffhiE2IgvLm6mrx7pv+jfHYbqmLEo8YfiM Z8rNsfZp0xc527VFPKl8iv+oNFWcev66r/Hj8F26gpdKHlXPxDHHUXBcNmzLsijHV3TFn0lNH+ZY 66eSRYknDMMWa1x9iZft2iIeW4zap/Sj0lRx6vnrvsaPy2dbl43GlX6YbphM7Jmm0jPl5liwXPxU PtguyvshCo7EElfXtIsST9h8bf7j6uuYWvTpDIz+XEErnFRkZmXTulgdvWhML77MlmrQ4GH1/MB6 33wGfAYynwFee05u5kWX1tLl1TE28wr7VNrqL9EXGY+lb07Mxg/Tb2af7oUREmAzMMdAAtQ2OkDN d0AcWWz5gdM/Kq4ZsE6qHwqX7bHMb2958/Gk925sb3lLbxaH3qq95c3Hk957oL3lLb1ZtH+r9pbn 9haP9QjSuUlO8MpBLq14cnGZQ9fZ5tISZw6dDfOJWy7RbNtVmVZAz/QZ8BmIkwHZzKs22MyrwdjM i4vQ5AZfMTbz4nosrP4y6zGp33TYpo6WpezHWemUYFOCGgoSoBm88A31o2MYtZCMqnd0ZCVzs2hv efPxpHds21ve0pvFobdqb3nz8aT3HmiPeeOCiFt7iy29DCet2ttc2ls8ttw20D2c2VRkZtOZLd/T yUUnr3LyvZ259B7Jo5VOvuczL92lC5tTz/MZ8BloykCam3mZtVYTHnWk7hLKsij6YToaP2U/TtGp g3QBhwXG9lqu+y48z/cZ8BnwGfAZ8BnwGThEGTgSCqJDlIpj2w2taPLfH3hVM5t2zsylZU2+rDaX Ks0cKji51sziFc8oZ4bHdib97H0G0ssAfbbS2MwryidS11+ir3lmvKwTJjf1neNM/Y1KgpHgXQ61 XPpi67LxfJ8BnwGfAZ8BnwGfAZ8Bn4FDlAE+MeOdaxvov6D4pLPfPKpAg51sic8rn7m0bMGbCfnm M+AzkPkMHNzMK1kuuTbz4s9kzCb1F5tJDaZ5ceDEPpJNnJXOMEBXsDoYV99ly/60TZh/L/MZ8Bnw GfAZ8BnwGfAZ8BnIQAb4uZwNvHsmXZGXoMKzrq4edXRGxoUosYOTM354fa2xe+2CBQsy4N1D+Az4 DPDFsK3YzMtVP5l8Vw1m6rkOCNtH1UWmik4djHauJ2P2tZ62131to/ntsi/3wnBw5iVK5sYBWlcm o21ErnmsZ+MLtlDBS4fGwRBdoRKfjllkTM2m9UyZjMVexkw1VhQMbZuqb/rTY5dfFz+VL5tc+2O5 OdY2qfyG2cbBiarrikfiEMp4ohv1+GlbMx6NIXpCtW6qvtgITaXvkou9UNbjPjcda8Dw//kM+Az4 DLTHDCS43KRCk+7pbGjIQYKLThpwoVlXS7tqEi3kszjjTG7ixIntcTY+Jp+BIyYD8+bNS8ZK5w28 mVcD7RtNTzBybuZVa9/Mq+VJd/LTynzjU9uUGs0P02syiNuJW3RyQOZETJ4p1zGZE2KZ5mndVDJT 97CO9QkmB6LHcsJpBqhPQLWOttU2Lr7WaW1fx9RaLNM+HWzTxsyBOTZ9pjN2YXIspizVOB3/UWyi +DVzZ8ONgmPaCa621X3WN8dRMEydo2lsy9nRND8/F58Bn4GjKwNcXAZ3btIZHZ+k1dNjU+p4xZOW OXnXTObVUvFZHejRoLGVl5dLtwWV3wWmtmb7jbXpReWZ/jKNHzUO0TPjEb7QTMdn+ss0vsQdlZrx mHaZjs/0l2l8M/5UYzMeU1/iE34bbOYlHzyhUn8JZb70JQyhLr7II9G4RacEqsFtPFdwpi7rmTzG FnubTPtuN31+s9ia602WSt/EEhyTn86YsaTpOISveaIXJhOdTNMoPiVW1uW+aSNjHZvoiS3LxF7r RelrDK1v4umxjsllr7G4LzZR9EWX7URf+xc8lomceXEb25q4cTHS0c+ET8lRlPmLLscq+hKDyISf znzYJlM46fr3dj4DPgM+AzoDDQ0JupS2Hgk+t6GNhOqoCq2nopPPdHils5Yqz1q+zvbg6URgXl9f 3/R9pvG4LzKmtsbfg6Jjk6fimb9J5vc027fmu9rEN+Ox+dM6Mjc/f3/89ftC+vL+lzHS28zLXow0 gTbryKdXKAtd9qzjkjUDDRvELTrDsLQs1QQkcK3nstf8I6IvXzwcbJQvOK3PNjyWpu1dfNERKrY2 avMldky1D5u95mk7zXf1NbbYunSZb4vH5GkcPTfpu+RR/GrbMH2RiU8Z26ipo8fSFyr2eqz7Ijep xM26UZvoim1Uuyh6gik0io1LxzZ/id1lE5Uv8QllO9OfHrv6Yi80qn+v5zPgM+Az0F4ykMUrmnSm 1tCQhepENt3XSWN68X2dQZ8vu6VgE7zsabSw774osjAdw1WLobaVvtAWyiYjUY5li5Zgb25/TJ44 HPmmnMZhWCITajFvtb0NU/O0b+kL1XoH+zXYs2M3qtEBvXp1oQs5w1sYlsiE2pCiyMJ0bJiap22l L1TrpdsPwxKZUJuPODL+fPE91MnNvOhS22ibeaU68WPYsKbtU+mG4VhlbVV0amc8ATPwNp2Udn6o +/pENF3f+k2p8Vz8uH4YM27TvuPain4mMBhL47jyIz6Faj3hZZK68E0+x848btzXc3HFY9PROC47 zRd9TU05j814tc7h7rti0/mR3KaKVduk0nVhxsFI5SOTWKl8ebnPgM+Az0DKDFCBySe7fAltfX0C tXRdbQ0tb9bRzZyJhtymezurjY2E+LvM9n0mq3wsk+9U6Yt+Du2Om+RV4Ln/vgfL9vfCZTf8EwZQ 9Vez6RXMengRup08A1/79DAKP4ElD/8aL5RPwjf/+XQUEkd+IwQ/5RxNhZqdeP3Vt1BRkIUJpw5D bmOsEp+pHvir3og//+YRbDGEHU++CNdPHdyMa8Znzt+UNzO2DFprH0BWbcL/zPkbdU/EN77/OSo9 DzYT/6Ak2TPjba2+iWf6M8emv7j2Jp45NvFNuemvtfqCJ37S3MzLrLcETqguAOLoin2raKaLTtcE ZJIsN3VE1qqJtAdj8w0TJaZ0bKLghunwB6O9NJ6/2TIdXzo5li8PMzbbOC6+zE/bSR40FT2bT+Zp udi5dOPybXjaX1w8lz5jiq9U+KKbSs/lK11+Jv3JHDiWTOKmOzdv5zPgM+AzYMsAr3jV8FIn/Ubz ZkKJYFuhHNQ2ZBOfLq2lezlrGldDtb0Ul8yT77sELYc+/PDD2L9/v1ZtViR269YNF110UcCrr++C oYMLsOzdHdj48QH071+IHZs3BbZlH3yEivoh6JjYgVJi9fr0WHQkCS+4im99+Wpi22L8/oFX0LHk Ulx99gnN/LcY5BSiCzErCgqRT5cAByesIedLwXd4Vi6k7i45bwaGdOaCvA4F3Y9vmr9815uUf/sk Zo5F+jr+FjEqRmvtA6iiwfj6zMuxr7AYRTRnOqTNmsTcjNk4EJlQMx7mM0/kJjX1D8v8bRNTPIlZ sZq6IhNqzof56cy/yUF6m3m1PKluAgytv6IUBlF0Dnqz9FpbdJoB6MmaMnbPclPHpmcJtX2x+I3E Tb/ZpN+eIjXjNGPTHwhTpsepcLRunH7cnEWNV2KIoi9zE5s41IWvv2y0ju5rHfapcxEnJo0ZFrvp j3VdtjoWF6bL1qVv47swmM/NjMM2BxtuKp4LP4qdGVMqGy2PO19t6/s+Az4DPgOHKgP1dA0tP/6v mu/jpLM0Ljxrg91reaUzPyjymMe72JpNf0dyP5vuTZs0aRLMx6mIHtPTTjstgEkWHtnoP2oE8O4K bNq4C5/s1wdbPtiadFOxHrtrzkTHsk3gMvTTQ7uiate7+NsjC/DhflqWpdb1+BJ87uKzcBy24m9U cDK37L25+M2aPphx1aXon9eAbSsX4tmF72Bno82QM76E6afwjKl1bsD6917E0/9YSrYdUXL+RThr ZM+kTP2f/D7PQkHAo0tyz5qA4+j6Y+bX1+zH+wv/isff3IyiPiW4bMapKNi7Gn+57znkfuIiXDIB +Pv9f8fuHuMwod8u/OOV9wmlI8ZNnY6p446jxG4h+ZMkP5nkOwN5yRe+gbMG5eKjt57H06+sBJfw HXuOxgWXnoe+vNRLlwcvff5ZLF75YSBjvNO+eCVO61eEmp1r8OxzC/H+1r1BtHnHn4ZrLj8NBZU7 8NqL/8C2Lp/ARZ8Zg0KKvWbHajz7zEt4fyd7yMPxoyfjvKmfQDH9JaJ2y1u4/69L0eOU09Bv/zt4 ZeVO5HUcggsuvxCDu5ACx/Dcs3hz5aamGD75pX/CZAqQj7P+DdTHn4MK8qbuCTb1xZYpN1uRKpgs N/VT4ZlyxghrNnzW1zGYfbHReqLDMv0Hh3Q38wqJOaz+MmU2GNaRmk2oTc/Ja/yEOeUicIHrIEVX qJaF2Ws9sRXqshN5u6L8htEvDk7GZt8VuLzpxU7ejC6+C8fFj4LDvtNtUfDjYut4wvAlZ0xZT5rm C5bG0bpiw9Tki61Q0bXhi8yk2i/bmT5MfR5rfK0vfM2z2YfxWhOP9psOTlhcYTLxFabDMsmP0FT6 Nrn4Egw9Z5u+5/kM+Az4DBwNGWigQhHZWcjPyUIuPa+BL/XLpX4e9+kUITcPKKDLXmlRsFnjVU0+ cTZfAwcORN++fYPfPJHx9yn3hw0bhj59+gT9JC+BouNHBsXc1nUfo6ZhJz5qrDmBXdiypxrbN28g v/0xpBMVQvvLUdmtBJdfdRU+V9ILe7cuxRMvr0d9fg+MHtk1iK+gy2BMmngyFU712LH8cTz4j8VU cGajZMrnMKVkCIrysw/+Hm9eiLlUcHbrz7b7qZB7F/soVo5Nv3iuPE62j7DwH6/g9YUL8crrK7Cz ogoDzpyGwbS6u/ODVzBvyVq8+dzT2FrbDeedMwR0xTJ272XZ61RQbqTV3KSv5c8/iCW7aikXIn8t KDgLCrqia8cs7Fj6NzxCBWfdkDNwyedKsH/nSjz06GLKUQP2rluEF7ng7DUZM6+aiTPG9kfXgmzC qsV7858KCs6RUy7BVZefh1F9eiCL46+vweYPd+PjD/fR/YMNVDOuwuz7nw4KzpLPXYIpI4uwdeUr mPPg66gkeX1uPfbW7scHi5/HK6W00ty1gPL/AZ57a2Nw/PasfR0vcMGpYuiSnyym5LgLTR5rWlEm XN1PVy44QhlHcHVf5HL8mOq+yFNRbcN99iFU5hBGJTbxIzE2vqEodtnMi94s9IaJupmX2DdSeYMK W8Z8oq9P9oXPei6+YJg6mh/aj1p06gBCAR1CsdeT0n2HWbOJu3QOC5/fJLrJm0ZTluux9E07PTZt tEzsmUZtNt0wHJFJOWi0AAAgAElEQVSZ+C6+qcdj0WUqTfeFF4UKltYVnolp42ue9AVLj7nPTajW 0X1tI/rCE6r1RUd4Mnbpih7LTV3haR2TJzIXtekzT14uO+GLXhiO6LaGmviucRifZfql4xG+5rn6 ostUmu4zzxyLXlTaWvuofryez4DPgM9ApAzQWRvtW4Is+trLCerPBipAad2LilEuOqnmRA7JqFZr 1vi7zPXi1Uy+b1Ma6xUUFKCkpCQ4Ydcn6JWFvTGGlxB3fYT167eiFF3xuRmTA9OPt3yIj9Ztoppz PDol6lA04gLc9L0L0a9zZww4cUygU9SBVtYSHTD508nnhnYZcw7OnzoRxVmVWL1ofaAz+ar/g8vO nYxzL/sG/unsQU1LOLRWihk33oYf33gFlbXUajZh14GDBUyz+QVIyf+Wv/Qsnnn2WTz79CpU0dwO 7O2AS759XiD84KUn8SqFXHL513Bc9QFKbnbTCulVP78VN974c1w+Nlkgf7BhB+opr8kVVI7lFtx6 689x7kBgzYoPA7xTz5qI0Sd/CiVssmMdNlN89TVVyUCq9+IAuuP8mV+jVeICOh61qK5IiirKDiCn 3ycx80u08kox1tMfFgI/VJzyPawfLl8arFB2nXwNLps8Fud+7esYy6Y738NH++iAy2k5FZX/eutN +OFXPxkAFxUmVzIbaqqDMarpDwFNMSRlLODcSePjzU0fd91nXR43yzfxZCwybaP7pr2pb8oFV2hc fbFzUZ4ry6QxPjcds/CY35rNvNi+sdGntVnj8cEgDopMPZG4+CKPRVt7ea12Zk7CHLOuDl73NY70 bfYiO+yUVz70m+ewB+QI4EiJ0xG+Z8fMAB9vaYfr/cl+JY50YzjW3rfH2nzlPeqpz4DPQPvMQBYV RVlUkGTzWSLdtJiXn4ccWu7kHTSZxwuhvNqZkBsaG6ehv/Plt0B4HTt2xEknnYS333470ObvvfHj x6OoqKhlEqo7YfiIAixdUYqX51OhVTAew4ePQC+8gdJX56GU/A65sC+tLDVgzzt/xV1PLaFCq3mr r6/C1t2N3Lo92Poxl8rZ6MTu9vXCiG57sfnjmoO/V7xVKLdeE6ng3YwNa3Y1np1nI5/mLPNoRpuK iK646uc/wyl0U2iCItm8YTvd87of5Z0/iUtGvohH13AxNhJTRtRi724qNvh+WW69RqHHvg+wcTfQ oTct22Iv9pbTBcENHCu1IJbtKC2tozgb0LGxZl84+/9hYVKD/j9Aq9AN6H3qNJQs/i2W7l2Fx2bT iy4wnvKlz2NMr44488ufw5K7nsKWpU/jf+jVof8kXDx9ErqpM+0EFUFFeXzAgaq9tKK8oyiYc+9e xNhRgQ937MMADpFarzFjUV+6HutoVVYa56X3J86jGNZRDCvx6Gx6UQznfPFCnNTbWBInIz7+XGQx tTWRSSEmv5Oi3+w4NOIxT+SmPfsQG+6beKY+y4WnbQXDpFpH+uKDx2Yz8U0532CbzmZehKOOagtU ZpgJN/XNsRVEMSPr09dGWs3mwJyEOdY2rr4OxrTXssPelzfbYQ8kRQBHSpwpppFSfKzMM1UiOA/y SqXblvJUMfCXbdiX8dF2PI+1+bble8tj+wz4DByCDNAZGP1pna+wpVc2PUqjIXjRRahU4NAKJ9VE dLVt8NLRyHe/i3LR2ZlWJLl1794dI0aMaLHSwyf69fUH0HNEctVy3z6qMEcMRG5dMWh/ISqCk5Xu aKqA6khvxUtccHbF5f96O+687etUmFKjIDmGrETyVLK6PGnDvNpgMW4H3t2QvL8x6Y9W1NguaAew cx9dekqXDzc1smM9tm/S536TEcVStgFr16/HBi44Sca6VaXz8URQcDLSGjz56sfJ32gBrq5EZVXy cuSd25PLkQMG91a4FMv+5I2z7DcZO3DGNT/HnXfejttvp9edv8DIAlpZreyIy35+J35y41WY3J8T 9TEWvLyG/NFKZ/dJuPXOW/DtmecF+Tnw0SIs3dC4/NkYC8fbkJVcqezSrUMyzoYq7AtYBRjatyPx GpUry3GABsnsJnlsf6CqU4sYXqD7VQNsxlcvM5+SV6GMyn1p0hc5Y3FfMKXvkjMO60pjPW4ufcEV mgpf9KJSE0/ikPj47wvJzbyS91RH3cyLzPRhETihBxNwsDgVfZHJWGw0FR3NC9PXesF94s0YEQeR HRCeBKhtuG/jR3Tv1XwGfAaO5AzIl/KRPIc4sR9r842TG6/rM+Az0A4zQH8YzAleOXQlKPepwKTr bHNpiZOvkOWTOC4+s/nMWDX+ruP72vT9bvL9xyfVsqkQm/DltiJjap6EFx43uPESU1ojHFKMypos DKLVz2Qbi35F1WQPFAXLJ1VYv+Qp/O+s+7GDFHasWoZtNXRJcLeeAUb58tfw1ppN2FdXgFGTgotm sfRvj2PRmvVYv/ItLFq5I4glWXIRAMdD9jKubSxuJEYdd1JnM16mjXrefPVVLFz4Il5dvJYKzz34 x99eRk1BCWZefkYQ9prn/4H1fCksb9DEnPJXMfe1Vdiw6gU8s6KcGAUYc0JRIBffNGjMDclOHxLg vPK/v8UDTzyPF55/An+YNQerDjTg47cex733/w3rygpx4kmDAr2C4mKaSiUWP/a/ePCJN1DdZSDG BAUpUNwtP7iPM+knWRD2HX9mYLfj9aewaP1mlL42D4uCsE7BCR0oDk54Y5McBEPi8zHfFsTwV0sM LY+vPua6L8WXSbWO+NZUjo3YmfqmXPSEptI35do39/V7XvdFz/Rv4olc8iubedXye4Xwm2/mxSvq yWLUtpmXYBiUD15Y/cUy3Q4e7INcU+egJEIvuY4eQZFUJNho2ge1JEAzeOEf1PQ9nwGfAZ8BnwGf AZ8BnwGfgcOagQa6lDObisxsOrPlezq56ORVzmzi51IxmkcrnXzPZ15Q8B0MlU+OpUlfKPO5zxsK TZkyJVjpFJ5pw+PKguOC+zqXVhdgeN98sq1BN1oZxYoVKBg7Ah2peKuiHVpHnT4Srz69Bm88Nx89 xkzCyIpFWEM72q7cPAG9Rg7EVNpM6Kk12/D6s8+gxz9/DWPOvBaXV83Bn1/5AG8++/fAdfdJfXFq Q2FTkctxNlB1zWuyO5GPwmw+8Q9Um//XkNNks/G9pdgo0k65OD6xLLgM+LxvXYCB3Qsws2Q17l+6 A88teA9fm0Y71AaNdt99bz7+3lhhTr782xiefQC7aV1ZyusglkC3Ft0mXY2rqu7H7AVr8Ob8pxsx BmDspxuQV5RAKRW8pUtfTPK7jsTl549Aw/4y5JWXYuH8UrJJivqXzMCnqPis2NvcT2X+WPzkqv34 zex/4M2//zVQLuhVgqu/cQGyd2xNFsrMpeOfjKuxjGi8GrgwiOEliuGlpKOmGPYFY7aRJn2hzLf1 NU9sXVTrSl+ozUbLpC/Upp+Kp22lL5RtbX0bL9Dla9jpDz684F5HHzbXZl71za9cPphgBmne6BMb NKE8iKIfppNEjPi/diwmzBO+9E3KXzPMY6r7zON3oPD5b2DcZyp9lkuf36bcF55JTywrK/tPkh/y tnjxYkydOvWQ+/UOfQZ8BnwGfAZ8BnwGfAYORwYeffRRXHp7IX54w1gMOZ5W3BqyUFmbhddLa9Gj uAO6F3dFd3p6SGe6t68j3b9YRbXES7+YienTp6OqqgoTJkxouqcuVfx8sh12mwWtYWLgqEHoQIXu 7o1rse1AAh16DcLAnnSvYeVOvL9xZ7Dy1vX4IehDxU51Igf5WfRIFzpBr66lU8vyzdhSloXjBg9E UaKKVoayUb5lA/aQrNcJA9Ezrw7lVOzl0mZG+TXbsXYr7aQ7oh/y6sqxdu1mwumKIcP70kl/Lbas LcXexseh6CIBOV2SNuZk6/fh4/J8HEeriXu3rMPW8jr0GDAMvTrkBrGvWb8Gc+9+GFt6fRr/8X8u QFYFLScWdEFDBT0KZgc9qkRwG2M5+GSaHHTvNxB96OGk5fsTFHsOOhRkUXwfINFzME6gY3KgmtfA iE/FyPZNm7C7inIwdBg606XI1dWEVNAReYm9+HDTdlRnd26ccwXN+SMk6A8KhcXHY0CfQlRRvhmn KD9Bu9t+iDK6DDiva38M69sZdeVbsHbzXuR26Yvh/boG43Vbyum+1MEYQJsbtYyBsZq31Me/ub45 kvcO0yjN9Gfax5WbPk08U26OTX8if++995KfwWtORN9+HYLHElXVZ+HF1VXo3b0zfQaLUdw1G527 0WeQ/irC+0e9fVvyM3jppZf+K+GsohcnnN82Nso34vK1xSyTF+syT/i2Phefwpc+U9uL2E187geN i7xMNHbILdWR13Lpi20Swf/vM+Az4DPgM+Az4DPgM+AzcNgywCdmfL8ib2TCJ9O8gVAerfwFO9kS n1c+c+kMkjcT0o1PpPkVtYXrHqDLTlc2g9q/fT1Wbm/GQtkWKghzcikmugSRr0HMyqWdduneTepz JFtKV1P8uXSCyvLkOfP2Teuwg4LP4xVMuny1jjb24VjWrSo/GH9tGdatLGvmrEW8dXuxdmXy3tBm io2D3VsOcndseD+49Dfg1NYhWPsr34s1NMdO+bSelfgouIQykDtx62hD31LsyqICm7YRrqe46+iy 1qBtLcXKj+lyaD44wVwb+TTasnYlsjhHfAATtcF8gyKJ/PCcufHc2PLArs1YvYtweCnbwKkp+xA6 JbV7N2MlvaTt+5hi2GaPQXQ0bZFPLUzRF1uhKdQDsamrx9J3UQYQmc2XyITadExemG66m3mZPixj PrDS5MOqeSKLQsU+im6wwhhJMYWSK1gdjKvvsmWX2iZFCPHEe9a9jSXrdqHjCaMxcUzfYLk1HoLX 9hnwGfAZ8BnwGfAZ8Bk4+jLAl/I1UH3GZUiCCk8u1mihLyhEuWzjkzN+eH1tcn+epgTok2hz5Ydl wmMD6TPlZsoDZsT/GupqaROc5FMFsmiBh+9z03h1tQd3WRXIBgq+6b5JYnIcfF9dJuJhH6HzKxqE 639wI2rp8tzqigrU0eZIOl6J0Ukb6mjVsrk08FdfR8fJnk/OEYmbGvvjJrT5/BOorW1+vJoMU3Uo tlp6k4TOnzBSyVO5MeVx8WTeQpvPv/n7x/QVZZwqHpe8CZsOY3IzL9oxOtjMq45qFbrEnV78hwXX Zl6N9q76yeS7ajBTrykso8P2UXUzVnTqGLRzPRmzr/W0ve5rG81vVb98zTz87zNbMWnKSdj43MNY V34ZZp7Wt1WY3thnwGfAZ8BnwGfAZ8Bn4KjIAK2gUQkWrLw1UGGU4KKTVg650KTaJSjqCvkszjiT kxN4zoEUcEy52U7qma9tdJ9lcZrYCmVb3U+FlSreVPamPBSv5gBq8jtSEVFNRT1t0NNoHCde05/Y CmW57pv65jg0XlM5wjgVnsQmlCF1P4KLZipiKzQuXqp4mzmLMEiFJ3EKbREvX2HAf0ihdwk9wSi4 usC2mRdfSW5ptvqJP63MNz61TdaaH6bXZBC3E/fyWglY+zF5tomKvjkh5mue6AkNk4lObLp97SYM +uxXcNrIjpjYbRfuWtp82+jYgN7AZ8BnwGfAZ8BnwGfAZ+AoyQAXl8GWHHRGxydi9bTSUscrnlQd 8UWbzOPFQ75FUDc+0dZNn1Az3xyburL6o/np9gWLKTf2LTwbJsukUGC59M052WxdPHO+B8d0eW1F 88tyU8Xn8uHiy1zb5/xbRu3nn3x/SmbS3cxL7C1U6jOhUmMJZb70TXMX39QLHcctOiVQDWrjuYIz dVnP5DG22Ntk2nda/WEXXIthZJnYvx5/++tq9PjU+LRwvJHPgM+Az4DPgM+Az4DPwNGWgYaGBF1K W48EX4JJm5jUURUqj/nglc5aqjz5EkrzDG7nzp1HWyr8fHwGDk8GaPda/nsJP6Iomz6DufSMIr6s lu+1zaF7qXmXVrq1N9BRAUr9pFjOrtRYQlnRZc86LpnTgSmIW3Sa9q5xqglI4FpPY7n4WqcV/Rq8 9/xDeO7dcpzy6ctx9pg+rcDypj4DPgM+Az4DPgM+Az4DR08GsnhFk87UGuj+wOpENl0CSmN68X2d QZ+KTj6Rkz1sZOZTpkyRrqc+Az4DaWSAd5Dmxp+vNDbzSlU/MWxY0/apdMNwrLK2Kjq1M56AGXib Tko7t/W3LaaC88PBuPq7p4N2l/bNZ8BnwGfAZ8BnwGfAZ8BnQDJABSbvXMuX0NbX06YydF1tDS1v 1tEOPYmG3KZ7O6uNjYTE3FOfAZ+B1mUgzc28zHrLDCJO/aV1TZy0xpkuOl2TlcBZbuqILK0JxDeq wabSXcDectz/u2X0hUrPnjplOmaePTg+lLfwGfAZ8BnwGfAZ8BnwGTjKMsB7k9TwUidd38dPIUkE 2wrl0G6r2cSnS2vpXs6axtXQo2zqfjo+A+0jA+lt5hVWU4XVX6bMloMoOja7Jl5ri04zAD1ZU8ZO WW7q2PSaAsx8Jx+nfum7ODXzwB7RZ8BnwGfAZ8BnwGfAZ+CIz0A9XUPL94xV02on39bJhSc/95Lv 7Uw05AebCTGPH03im8+Az0DmM5DuZl4hkYTVX6bMBsM6UrMJtek5efydEqW5wHWQJo6WhdlrPRPD ZWfq+bHPgM+Az4DPgM+Az4DPgM9ABjLQQJuY0MMBkR9sXJINvtSPNzHJo2c35NFZWy5tZFKQT6/C DDhLAyJRVYXKipbX9gb8PVVBUZwGbAuTuqoKVFRU2fl76PmaLSSe4TOQmQwc3MyL/rpDl7hH3czL 8G7WUTLm2kvXX8JncxdfQ2sdzQ/tRy060wJXnsVeT0r3lWqzrtg1Y/qBz4DPgM+Az4DPgM+Az4DP QBtlgM6+aJNMZNGZWk5QfzZQAQrkUTHKRSfVnMghWX7Us8g0wty+YD5+WzILt/acg/ebnmxXhYVX zsKv+t+DWYPvwq1T52Jjo2zjPXMC/n8Pvwe/6nkv3iptWZTawti4YBamnJxFVxLPwKImPxV4cCYV 2UVd0KVLEbKm3IQVjbIVd88I+Kd370K5mIInSlsWpTY/nuczECcD6W7mZfgw6yge2+ovU09gXHyR x6KZ/LowJ2GOOTAdvO7bgrbZ2/Q8z2fAZ8BnwGfAZ8BnwGfAZyBDGciiFc0sWunM5sqTWl5+Hj2m IQc5NM6mG7N4IZRXO7kgbauW260/psyaSAUu7WbU1LIx9AeX4MadN+BHO2di5Dsb8ebiPYH0+Esv wg0f34Dvkez86yrx8l83N1mFdfK6jccvfvsAxqFcqeVh0g9XoZKuLW5o2IxfvnAL/rx4SyAfftm9 KK9twDKSzf/xC/i3x1YqO9/1GchQBpo282qwbOZFl7zTMjs/vsiymVeq+smsv0x9c5xqQpH10/26 sDkwJ2GOtY2rrydm2muZ7/sM+Az4DPgM+Az4DPgM+Ay0RQboDCyLFkSo7qRXNnKoz69setHjAkE1 KOhq2+DVFu4Zs3vJSIye3Ad0Fa9q+Th+bN9GXkd0OwXYvakykOcXd0FR404ldbuBjr0KknZVKzAz azre2KdgVLdvyRk447RR6KF4QCGGjh1F/3PrjhPOAVZuShalhcW90LnRTw3tSzm4d4dmln7gM5CJ DBzczCt5T3WMzbzok+lstvpL9EUmYxuI6GhZmL7WQ7obCUV2QN4kQG3DfRu/WXB+4DPgM+Az4DPg M3CoMpBFO3U28K4pvvkMHOsZoM9CDn8eqNSkRc9kgUnLmrm0xMkPq+eTOC4+a/nMuC1byE2TNaVL segd4Nz75FnrNXj7N0/izdmbUbZpKK7/777JyAr745vPfB9Dwu4/DfFTVfpXXPUCMPdPwxpnWoV5 s36Mu/5wB+Yu/yW23z2qLTPgsY/RDLTBZl784xZWf2kZZ932Y2jqxDo6cVY6bc6jOOMAuZn2wk9K j5L/+aQlnZauXTq+MmnTnuKWWISmM0+XrYsf5kNshIbpppKli5GuXap42lqeibjDMMJkbT03Fz7H ZMZljl22Uflx8Mx44tjqeEwcLdP9dPE1BvfTxWE7X3Ca2fTjYzUDDXQzZzYVmbzSyZfQ8qomr3Jm E5+vuM2jlc6AxjmLzGAya0oX49eT3sSYx2fiE32l8s3BwE+fijNuKUE3lOLpx7Y1eizG5GlnoHca yyxVpY+iaNhXcOvLm/H5vgKQi3GfuRr/cutsTMdP8R+PlmZwZh7KZyCZgTQ38zJrLZ1OKVCEsiyK fpiOxk/Zl09QSkVS0EG69MMCY3st130XXhvxE9jy3ptYubUavYeehHGDe2bMjz9pyVgqPZDKgH9f qWRkoNve8tneCp5MxZMpnAwc8lCIIyXO0El4oc9AJjNAK5r8N3Re1cyuz0IuLWvy7rW5VGnmUMHJ tWYWydL8O3vrIt3xHn476XVMeuFanD1WL1/moPuoAcHruAc2496vvIt9F/dBp3S97ViAScMuxezl 5fjq2M4KJRd9R40NXkOfeR39PvsUftpwA4qVhu/6DLQ6A/T54z/s0FOL4mzmxbVWqqbrL9HXPNOe dcLkpr5znKm/UUkwErzLoZZLX2xdNhnnb1v8CB5+biO69sjFG3P/hOc3Rd95jE9OdNNj7usx68nY JYvKFxzxbY6Fr6lgCxWZjE2MKHzTRjA1deFoHd236YsfkWn9OH3BERs9FmzN03pR+KIjWGKfipr6 giN2emzqso7IXbKofMGx+RWeSQVbqMhlbMMUmegyFZ5QLbP1RY9pqiY6YqP1U/HEVmxEX/OFxzq6 r8daX7AyQcWfia/5Wqb5pn+RmXxzLHgufRffxOGx6Aqm8IRqvuaJnebZ+iaPx9I0hvBsVGKw6QtP dNhe921jmw/P8xlozxngEzM+2W2g//grlzcQyqMKlFc9s4nPK5+5tGzBmwm1aaukx0XQg0nq+KGg QduPF6+bj9orz8AnhgP79uxHZeMpXE3FfiT3q03g48V0U+f53VEU2FRhy7pNcNzSmYSt5M2KdtFz R+U62z2Yc825WP7duZhOfvbs2QN5ckpVxR4kXdahdPEbwBWDoEvSJKD/32egdRlow8289EmU1GCa FydwsY9kk6mi0xWsDsbVd9nyBLRNpAlFUareD5x00UU4dfzpmDaqK6qCL7UoluE6rtUTPiFhGb/k 5ETztJ3JF/1wzy2lJo5omHzBj8oXHBd14aSjr7EkThcO8yWPQsN0NbY+LmyjZdpvXL7EITQsnjCZ y94Wj+ZpO5PP43SaiSMYJl/wo/IFx0VdOC59mTtT6YuuOdZ88ZMqfsEQfduYeYIjPlpLtT+Nb/LF j4sv8qhU5sdU+lFttZ4ZD4+5CaaJb+oLluhreRiO2NmoYJgy4bMv7nPTPM03bf3YZ+BIzwA/l7OB d8+ki9wSVHjW1dWjjs7IuBAldnByxvVZbbSnkqSVjo33/Am3Dn8a+2n32ieH/w7zltLJW9V2lL5M cPe9gt/RY1N+N/wPuO++TQH+h3MexK97zsLtPX+HJ+8owvn/PobuSKVWtRLThg/E246qc8XdM5HV fTJewHKc2T0Ps5bSbrhV6zF/LtneMR3d6bEp3bt3x8z/XRH4WTn7YhTRd8LJWXk486eDMf/fP5P2 BikBoP/PZ8CWAfrZ4buq09zMy1U/mXzXyaCpZ4uQeS57q36cy2utABamDlQHY/a1ngUmYGkbl05s /oCzv4QBiS14/J6HseEA8KlP6MszosHJyUcUbTlBiqKbSieO31RYbSWXE7Qo+PrEjfs6V7ovWDZs m57oC7XlzYbF+i68uHzxbaMuLFucNnvmuTBc+mH8OH7DcNpS5jpebemTscP8mseAx6LPfZELT8cq Ms071P1MxRAVh/UkF9yPaufKS1z7OPouXYnfFhPLXHY2fc/zGWi3GUhwuUmFJi0wNjTkIMFFJw3k MQ01VHAW8llclDO5NCc58Nor8KNrTePB+Gd6JIqtDf321bjxq1XBymdRr44Hd70tLMFy+r5xtbHX 3Y8GejVvxbifbEwu65Tc8Cwqr6oIVj479ypu3OG2ubUf+Qy0OgP0e9KKzbxs9RN/CJjv+jBofphe 2lOLu9KpAxKnJs82UZuu6Jn2oss0TKb1YvVrquhPczl9MO0rV+PTtNL59lvJv5LFAvHKzgzwSZd+ ORUbBaIbdjInGKKrqcjiUo3Bfd/adwYO1/GK61f09ftZeJpytlmnPRUqmYonDEdywDpHYpP4hR6J c/Ax+wykykDyKlM6RaTHpfCvYz3ROl7xpGVOvtCVebX8jEC5GjUV4CGR5yC/c0d01QVnm/jNRWHn YvTyBWebZNeDJjPQBpt5yY+uUDnxFSp82yEQHZssMi9u0WkLyMZzBWfqsp7J4+DF3iaLPDm7YhVe vuv3eHFLAoUdu+CEvp1R23SvgN1Cc/lEQ04ShWp5Ov0oJ1+p/DKGC8fFjxtrOjimDY81T/dljmFx ib2mYfqCqalNX8dhk2eaJ/ELro6PZTxubYsyp1R+zTh1TFHwtb6rnw6OaRMWJ/s19V2xpOKnwtFy ya34lxiFMp91tF4q/1HkOgatb+PrWFg3ajwmVlQcbRc2b60nc7DxROaipg2PTZ7LNgpfsGQumkax 9zo+A+01Aw0NCbqUth4JoqjnFc46ekA9fV9RwPxA+lpi1/J1tm1wltZec+Lj8hk4pBnQm3nRNbYR N/OKc/Ion16hPD2XvdZJOw1tcXktB6ODs01AeFpPT8LF1zpp9gsx8bMn4Y8P/x7vd8jDgQMdcNbl A9LEspvxiQiffIQ1OTlhHVdfZGE4LpkLU/M1fhS+qSO+9XxNHR6HtXT0w/CiysL8yokkY6WKn3Xi 6rNNOk3n2WWv5+Xqs22Uedl8uDA1X+NH4Zs64lfP19ThcaqmbWz6Gt+FpTFYR3DkmJsYLn2xc/kJ 42sfYfgSk9Zx9cP8uWQmlksvjK8xWI/H0rRM+CZP5qip6IbhiMxGxYeJE6Yrsig2ouupz8CRlIEs XtGkj2dDQwNGDFwAACAASURBVBaqE9l0XyeN6cX3dQZ9vuyWJpTgZc+2aHX7UfrGLvQ5fYCx+2wC W5euR+6IwejVKbhjM/Pe62pQWVlPq6aFyXtC43pw2Tfyc4oKkW+efdftwfvLgREl4XvgJmg3owTF lU8x1XCfnl1TVBgvDxUVFfTMmyJ0LjSDiDtRr9+WGeDPF99DndzMiy61jbaZV6r6iWHDmrZPpRuG Y5UdinccT8AMvE0nZZ2pYnYZORXfHXw6yqtotbOLuu5f6YR15URDqNY1eWFjLXP1bdhaV+RReaxv 002H77Jx4cfRNzHMMWNFbWIrVOzMMfNtPBtf6+m+YKeibCMnzqIrOEKFz9TkhY21zNW3YWtdkUfl 2WIMwwjTd8lssaTrw8SSsUkzGYvEGodKPNrGxjPj1Dquvmmjfbj6GkvruPhaR/phujaZ5klfqGCa 1CV38VPZazvd13bCF6plvu8zcKRlIIfO2uqo6qyly2f5fs4a6lfXJOiS2gba4TUruNezhu5Uqm6r orNyKx6d8TQuXH8DRjfbGrYWSz79NOqeuhozJqf9MBTn4fjozw/hgW9vA2/KW0t73571wpcxeWzH FvrbF8zHw99/D/s3dcEX1n8VIxpjdNlXrngRs85Zjjxa46ilO7pGzv4iZlzYJ8Ddt2IxHjjndZTx aEA/fOm1izGwch3+fOlz2Lq7CBP/5yKcXtIFiU2L8auSLbjmo/H4e//HsXUARbmpFh2vOw1f/b+n GsV5i5BpC96luPHsCbiDiltu59y5BAtuKEkODsX/VUsxs2gC/tTkazqWlD+OkmbHt0mY2Y7he/qP Z+P3v/wqmh69mllvGUFLczMvs94yY4lTf2ldEyetcaaLTtdkJXCWmzoiS2sCaRvlF6IL/6noKG66 qGnNiVCmcI7iVMeeGue0NccktsMMGmTq/ZApnAxOzUMdoxngz+KR/Jk8Rg+bn3ZbZYDv3aQzNfqZ Sr7oGSl8opZNz0ihvWzp2Z1Ek7d7tjyjy1RMdMbdkYq+Aq7+grtID67mFVLhVtVG52+dx59GRR09 65P2l1z577Pw5F82UNE5psWscrv1x5RZHTFvRnJHW1Fw2RcNPxXXrz8DXTvnYPeCubj3sndRubMP zbAGb/3sdRT9bCS6oz/OOr842Al3+4IlqP36l/CdMUtx5/1bqegE/lryOs5d/k10z92PsxbOxMBR tCpKzyy99cT5WPvdUzG+l0Rhp6XP/Bp3jHsElcsuQWHFDpRWxN9Es2rFLBSNAyrpuaTxrYHNGIf5 mxfRLsG1qKzNQ+dDUXA2piPwvX0Rxu96FhefOB1/mj4dP5wUvrJsz+Qh4qa3mVdYTRVWf5ky2ySj 6Njsmnhx7+lsMmzsmAHoyZoyNmG5qWPTa4T3pDUZ4BMpebUHnNbE0F5t0y0c07VrD3mQ91Rr55Ap nPaQk9bGwLngokcX4q3FbI19puLJFE5r5hLVVmKNqu/1fAaO2gzQZbR8YqZPEPnz0ZCopfs6E7Ty mbyvk+/tJHbQ2uK7Kw+VePNmemwKPQLl1qlzUbojuazatHdR3TY8PnUWyfk1B29vanx+y55N+HNJ kn870du//gYhmS2B0j8/1mT7VmnyyZtdRyULTtbu0pue8rmqIvnsz6pN+EOP2VjT+NiV7iUjMXpy n4M75DbCO+0LaYMjKjiDtp98ndmx8dJd2hV4A1DUuQB5BR3Qe2jfoOCt3EXrrH2KkNOlC7oWVWPF fz2E8t98EZ/oSxi5XZIFJ4MVd6biHNhf3jj3qhWYmTUdb1geD3OAL6td/gG28VQ798JQ2tPkldtm YMbdSxmJWh0W3DQDN7+yA6vn3IgZN83CTVOSv0s3P1FKlf5q/Hjcd0jvO/TImJlYSnClT9zc9Ns1 4+Z5wfNLN84j3sk3oTQ4UFV44sYpuPFRsg9aD/TqXYjcws5UcCbLVvY15bqbMIN+A0++bWngW49p iRZP3Dyj0c/JmLVgY4BUsXoOpky5DjfOoBhPnoU9IXMX3x0LC1E86nx8kQpnbrb4QTg3TpmBmygX WVlTsIgK9Dk0h+RvdHLenKulD97YyJuBJ0opGRlutXQ1Jl9hUEOfx2r6K1AFHeKKqnrso9f+anpG Lb3K6DjvbfnmdkUSVn+ZMhtGFB2bXRNPf6c0MS0dV2GoAzDNtCzMXuuZGC47U8+PfQZ8BnwGjugM BCd1cgbXDmaSqXgyhXMoUsKx+uYzcMxngD4HVdW0iVCQCCo2aeUzUVMb3L9Zy5SKTbo9MXhGZw2d +ObSCmg2bXrSFm0TxuCatV/EydiIR+9e19xFXT5G3/Zl/GjnN3Hhd8vx7EObSJ7A2zfRpaeXn4cb d16LaVd1Qe0ier6n0WpWv45Hv12HKz++Adc80BnzLzUK07otVIBVYsB1w5KFZWF3nP7gJ3GcXt5r qn4NcB6a9sTa+o/5+MNFs3DvVdtw4R8mNxashZj8PyX44PvLsWZ1WbLAJd3+00biwxn3475/fQd1 SxfhuQ/G4ouXJi/HZXhpW+e+Ts8xHYgRQxuXfgv745vPfB9DdJyNymO/fDOuXf4jDCqagrsXJIvA k876JOZefz9ll1rFEtx4y3p85pReqK1ej7m3fAcDb9mAVXO/i59Ofwx7CkfhB/N/SYq/xKrtv8c4 WqUsGvw5rCun98j2ZzD3pz/CMqq9Bk77Fu7qcQuG/XQBNi6ahel3TMYPLhnKHtCFnoZ6209vxs03 3YRZ85IxsK8X7rkFly3ZgBe/Pi7wrcelD96A6Y9+Ehsqa7F7+b/hO+cOwhNbKPm11XjhhXuAK5Zg +4tXoThk7oFz7MJ+KrxL592O6+kS4yHHFVnj5wur178wF7dUXoEN2x/DmM1P4ao7hmMdXVpevv32 4HLvqtV/woSvHAh4m58ZjOkXPYiMlp18Myc1LnT588dPx6UHFwV/CMqiG675p4qLpxz+2FFRGtLM HzUZs7muv4TPUC6+dqN1ND+0z+FGaWmBK2Cx15PSfaXarCt2zZh+4DPgM+Az4DPgM+Az4DPgM5DZ DHDx2Cm3Fqs37aMda2mVhVZa+N7OBJ341tJJfk11Naoqq2mjHVr4olWW3Zt3o6ioCHm0oU2mG99T eckvxqN7cR+cddtI4I6P0GwBr7AYg447gDfmvIK3/gp05A116nZi9SPAxC9ysViIYWefQPc9toys bO02YpZj4X8+hX88sJl0qhuLbGJXbcGfj3sU5T86D5ed17PRuBNGnjcSXaPclGa1B7qNPQln/+hs DDkTmHfz4qYCs1PJ6bhh4WnAfa/g11cuDOaYM+BUfGf9TEz/2SeRuwE4vmgd7pn437j9yhextzGi rU8+hvuuK8f5yy9A70YeLX1i8rQz0NsWZ+exuLt2Mx75ZRdcf+4wzLx7EYonXIxrcQfm0bLkjhf+ iOXX3owJVEzWVpdj3K1LcN2kgRg0eDCh0+ok/d+5V1f6vyv69eocjPuOHY0Dix/FrLv+RvzBwb2w HMN1c5fgilvOxaDJP8Ij636KviSVNrbkVHzqzMkY369LwBJfXy4ZSAu3uU2+k+NKPH/rn3DFv9F9 rrTxUfHYC3AXrVIu+5BLPPqLB+7ELy8pQS9a8Q2dO0n7YTnOJZ/DPvsaZr+8AZcMLIQ9fn5nnIMl t1yCgfRYnE59TqTRPbjom7dh5YHC4LLibe8vI8S1+MMtN+O/HriDVpD30tpnBltQSFKJRpUSreMS zQ7KTvaQRX3eVJoLJP7jT4Je3BxXG5h1FI9t9ZepF2AyrHQyQaMWnVF8mZMwx4yhg9d9G77N3qZ3 1PEcb5yjap56jrp/VE3ST8ZnwGfAZ8Bn4IjNgP5t0n1zQi6Zi2/at6cxxzyguAavv70LC1ftxbqP K7Fs0wEqPutQU1VJK6DVOFB1gFaMKrF3Tx32rH8b3bp1CwrPNplHyJn83oX/wK/HPYWqAf0x5OxG 73UHaD0rjy5JpQKUG+/GYmmVW6loOWUAxpw/GhO+eT6+8MIEKnG57cHj/R/FgV/NwLd+MDKN3Wvd 9kV9+2DopHG49O4zUHvfOwjqpsbYigb1xMjvjsOQd5firdJkFZHTORsrfvAy+twyCdjQC9cuvRYl +zZg0x4q9hc8hfuuqsOX1l+DsXzJbdSW2xeX/Nvj2PDMd/Gn6+diS+5QXH3rOfj9b/+Au+64B3de d05QTGo4Wth2tB247eQiXPHkPkz6zFl0t2Y5rRGabTr6dDm47MrF3NQZ0zBl2udxxtgUN6E2QnFp 2bNT8ugIeoF0YtDN5Pvl3Xzb2eP46hkDyTI8fn4ObdCKJ+HZ7cvxjR6vYfKgLnhwdRXKt66nnZim 4bOf+xy+9K038MbyLyKjt6fSUmbFgdrg2bj11K+rr09e2k6PMaqnPv0dKCg4+UoDjtO42iBV/WTW X6a+OW5MhJNE1k+36LQ5MCdhjrWNq69nZNpr2WHr8xeyvKIGEfeHhy/ximsTNRbWs2HLnDTVmDYb LY/TZyx9GZttvhKHiRuXb9rrcSbnxLiu2LRP6afrO1078Xu4aFvGnUnsdLHStUvneNh82XiMzXzz lcqnCyuVXSbkNt8Sv4nv4pt6emzD13JXP107F14Y3+bLxmMM5puvMGyxSaXTVnLXPNrKnwvXzJkt Lual+p1y4afLt8URBStdOxs2n7yOH0r3CO6pxNMvbcXcV3dgxQdltHNtDarp7LaaCs59dIlixd4y lO3agaqtK9C3b190oXsPM98qsXUD34CYwLJ71yDvZ0Oa7dBatpKWMK88E2dPGYxCWnmtYdXC3hhG pc9rT5GMLjxdfg9dRzmgsSijx5IsnvN6cG/o8WcOA94hnRMGY8SkYRg6PBn/xnvmYg1drnr+xceh cs9+mmvjMhJh7i7d2fze0EpabqL1rTr1rHenfVUVKjk+arvXbKH/u6MD11EU08oFW7Bv9wFUbt6L 8k1F6NE9eans9sf+hldPnIILzuuDWsoDe6O6jm7mW49HLivFgNln4/i8KuyjOCVKWqbFlnWbmq8I sx21PaWrsbEiWcXn5bPzbsHK5ISLv4Hld1yPn77wS1xi20pWii8GqeVJVNE/ahUf4AFK769/+lVM Oi6f1hF3MZdaBeZMnwDMfgMv31mOM3vfRuWdNLrEdQ9Z1xEG5STkbwqNBp1x+j+fgzseeDF5+eqO xXiIfPbv2bwITSq75y7emz2qxhm/aCdpXcUWbC8ci+v+437cSqxSuoly+FkzgBfm0funBJMmTcKE 4XLpM60Yl5bS/aVJ26odG7FxB6/KUqNjXVq6I+Wc5WqDVR/tRyXd0MlX11bSQ3F5O686el5RNT83 l+/zpINeRUXn3p0trjYIq59s9Zfoi0zGybib/y86mhumr/Va/EGjmTBkENkBYUiA2ob7Nn6Iy/Yj kh8i80cpkxFKISa+MoltwxI/rjmJ3GYbhxeGr2XiT/PYT1x+nNhao2vGmQpL5pFKz8sPbQaOxuNy JM9Jf66i9FO9W47kXLjmdjTOyTXXTPElZ/o9pbFdfLZzybR9un2JK137TNjxCe/ZJYVYvrECK/bm Y29uTnCylpWTQ3OnlRe65LaquhYH8mgHW1r9ObFTJQYNGouuXfmyyww2KnT4gt1XT78HrzLsgIH4 ym2DqVPVeOKai96njQVumo9b75uPnpd2R+2tT+LFabQa+PAYLLvscdz6fcIYQCbdGYBaXRne+JfF OGHUWAydfBou+dU2PHoi7VDLslPG4YbnJ2P9PK7qynHf4LuY28g/G0VVH2HOxCcxbSM9woWe1LLx nj/hLzftDlSeHP47bHr2nzGtJMdpj5WvYtZn3mt6ZMqYh7+M4/l6Vbo+8oPfzsWTLycruwG/uRCj aUNVfjzK7OtycdVOuqyY2uTrq3BXyT3odvZ4XFy2MXi8StlVD+HXgRSY8MK1mDqWVhSrVmLa8An4 XUUDzjCeKPPR89/AuOtfaLSgC1Pnb0Cw1jj0LLpLE1gye0bTZbCc+x6yQJlH64rjeL2RLq8d/Vl8 l9Y0e2etoMed/B4/unYczu1Op/TnXIErxi3H5Jlz8N7Vy3AV7sLur06iC21pI6g/9MM1d0/F4/+U vMT1TN6gqbHdtbwcn6R+ky/qN/NN45JvzMadlwxCl6yvBFbXzl6CLw8tRMUKGo5Ta54hcw8M6T/G bmqdR1vjL/8LXb9Ld5+KbuWGJ9Fv3PVJs3E/xnI6QIWdr6B8LcOE3o2lzTl3oXzBdbTaWYnZw+gP Gkt244f0zNWVswdhQvUbaPi3SahYdT+GjavC7oYfUl7cjb9jBhRX440lO2gjqXz07pKHXfupyKzO Qi2t4FfRFQcHsuhPEIkOwT2dO0vfxvHRrjbguius/tIyDlDqNB2sqaNlKfuN2WqmxzzhS1/G2Y0y Tc0+/0mJefySvlD+iHFfXjJ20RPLysr+k/QPeVu8eDGmTp3awq/5g6PH3NdNfqBMnoy1vu3HRmOL jY1qHJYLlubbeFpXcG0+BUcwWFfzTBuRRcVP5Vv7DdNlmRmL1ue+YOkYbXzWEx3piy3rm37ijDUu Y3ETe5csqZX8X+IQXeZqnvSZL7jcdzWNwzpir/nCY3kUvsYRG40hPKbcTFmSe/B/mYf4Fn0Zi6bw ZWxSwRG+HguWxhC5SyY4TMVOdE2eyJkvuNx3NY3DOmxv47FM8EQuvoTPOrqZfBmLvegKDo+1TPjC 07FJXyjbir6JY5OZunrM+twk3uTo4P8mX491rGIhcpdM9JhKHKJr8kTOfMHlvqtpHNZhexuPZYIn cvElfNbRzeTLWOxFV3B4rGXCF56OTfpC2Vb0TRybTOuy3NbMeLWNxCR2IovCF12xFT8yFuris9wm s/FsuqaeHnOfm45R5C5ZYND4n9iJrsYSHNE3x8Jn+swzzwSbAi19rwJ/frmGCs8eyO7Kj7bIR1c6 +e1UlIsiuney8/73aSOZLTjz5BMwciQ97qN7dyxYsABXXHGFhmtVn3fJzclNoLKiFvm00ymfOLZo VLTV0N2bvIJVQ6uSORRnoEf8StpoKGfDi/j16QncsPNcuny2Ci9+4X50/N3VOFUuSeUVyNps2j22 cSOeFg4yx0iwryDGLpRDA7dqG95+KwfjT2+8h7SKVllrC9FJdrw11NMd1lXRKjWtdhYVU+HEZ97c aLfWGfQclOu3N2BapCte6wIM2X2WVywLaVdY/oNARVUuOjcBB+gZ+4/98L2lgauMoVLUUeKnldkK 2sios/mMF85n8OgX84CmH+CTTz6Jh57dhwcWdUJWzw7oQK9u9P4s7lqA7nSpcpeOhbRKXoDCArrS hXb1qlz+EM4YkhusuE6cOPFH5Hk1vXhhnBeSw6jI+A5S7vNL+kylz3wuQPklfOkL36Sk2mTD/aDJ W07GYbR5RWXXZKeuxvZarvsumyOGb36Jyxc//xCYMp6UyTPHrOOyZZk0047H3Gx8xouCKdhCxUbG QoVvo6Kj49B9kWuqcTS/LfouX8JPFWtrYhIfJob2KX2hostjbjY+48ZtNpwwfJu+zEf7lzhd8bhw XPpmTGJv8x2GESYTLFNHfOkYNE/4Qs086LGJ7Rq78CVGG6a2MfviR+w0jtbVfLFhqnX0WPRNudbR fVOPx2FN8Jnq5uJrHbMvNiZfxyR9oaIrcdr4ZmxiE0ZtOKwvMdowtY3ZF19ip3G0ruaLDVOto8ei b8q1ju6bejxOt2ks6QsVTMGPw5ccCYZJTSxTLjlJhWPapRoLrqmn45G+UNHlMTcbP26cvNLJmwJN OoWeGnl8Fea9WYa3PsrGR/u7oKI+C91qyjEoqxwTB9fjlFGjMWDAgOCezrbYSIgeB0othwpCa7nJ QrqZjQrOZI8KU+kl+VQfU0Gai7xTGhXq9qHHt8/DaCk4mU0VTIsCsFE90ySHfHVyVUyFfajgVB7p ESudMlfHNAHzo0qKDdyNz/4Rc694BH+JVHAyFBWWtOGPtGTByaNCKjiFm3l60E9msQ/ihsSfSzLb 5PjRLxmec9PVBh/sxYo92difQ8Ul3cvJWwnx84p4B+nKAweQn9OA7J3LMabTAQwaNE6uNojypat/ UEVf88wEs06Y3NR3jg++a5wqkQQSjATvMtJy6Yuty+ao5csPRVtNsK3xXXEfLr+ueJgf94fX1JcT Ak3D/InMPAkQvo2aPm06UXlx/EbFzLRe3PdJnPzYsLV9nPxou9bmII7fuL5ccYbx48Rjy6nEaPNh 44l+VCrxCRU7GQsVvlAXX+SaZiJOwYvjV2yiUlecYfw48bCuq9l82Hgu+3T4mcIPm1c6cWXCJs5x yVQeOO6ofvmkNz8/H6OGdcbwwd1Rw/dz0gZCdXV1tGFJV3Tq1C+4h7OYVss6dOgQrIwmErwY0v5a /qjT8b3nG+PK7YmxU9pfjIc7ooGf/zUaPn+4o/D+JQP8+TuhbwdcPoU+Uy9R4VmWi3389UzVEm8q VEP3d1YWZqNL5fs4ma42mHjySCo6B9Hn0rieWgBbUv1lLzWY5rW0cHPE3q2hJJkqOl3B6mBcfZct h6ltVNhHRzeTPya2jLQ1vs0n8zLpl7HkpEHjxuW7Ym0t3xZbazGPFXt9PDM957bEznSsRwre4cyp fN6FSs5kLFT4nsbPAOfwaGxH67za8ljx71oO3cNZUFAQrHpyAcpj3mSIVzT5xTwec+OCk3fUbMu2 e8U6HOg/GP2LQ1Y92zIAj+0zcIgy0HS1wXi+2qCSrjbYjbc+BD7a1w0ViWx067gXQ7Ir6GqDBox3 X23g+kI3+a4azNRzzZ7to+oG9126gNLla+d6MmZf67l8aRuXzmHju/5qKIWILTCXzMU3MVjPpevi M4ZL5uKbftMdtxaf7fmkwTxxSIcfFkuYTObOMYhfzRO+8JgKT1MtT6cfN0YzVvbJPBeOix831nRw TBsem7wocYiN2GvK9vp4sIzHrW3iMwwnlV+J04YRhh8ms2FpHttKXJqv+y58F1/bpurHxZBYzWOm +bov80sVRyp5lDhT+WUMF46Lz3GFyaLELXG5dF34Lr4Lx8aPg8G6cfTZn0vfxQ+zscXfFjw5Hpq2 1k/YfAVb+2N9HkdpcvLLxWfHjnS5J62kyEsKUtaJ2t55552gQI2qf1CvCq+d8zTeep/v6TtKWtVS zMiagaWNG5vyrFbMmoEpsxZizszk54GPlX7NmLUUK+bMJN7MZnYVK+YEenevYLAK3D0lC7M0MGMH dgfxTp5xExZsPIryyQk8ihp/rviy31HDe+PbXxqMe7/TD49/Mxd/ubIev/5iMb5/8WhccO5pOOmk k3Dcccc1XXGgUmCrn/iDz3zXF4Dm2+wVfHrd6N8WSXwdkHg0eWGBal3R0zzBFBomE51DTuVLQH9x y5e67QvdJtM8mw1PysXXE9Y43Jem+SaOlmkbsXVRxknVNLbLrwvD1HfpZYqvY5U8yByFZsqXDSeK D1uMjKX5rcmbxpEchOFrfe1X8zWOnreer9bXOFrf7LOevLQPjSV8pubLxHONdZwuHZtP1tX8qPOy +dA43NfNJZPcmH41n/vctI7giQ8Z23QES2LSeGIfRm3Ypr5gMl/rSzyacl+PTSzbmPVTNe1X5so2 mi9+U2HZ5BpH45s+tEzmavrVfO5z0zriKxDQfzK26QiW+NV4Yh9GbdimvmCafHMssTCVeFz4Ufga x/Slx4KlebofFUfbxOkzfqomMZqxaL4pS4UZJmcsfvGJML9kHGZjkz322GP4r//6L6xduzbmymg2 OtF9mbmynagNvB3walbQTro956vHl4QHVW4817KWxruqOuCKeytRTpvWVG5/mZ4sOQ7zN1eitrIc f/kG7apazYXln/Do4i1N4O88ntzDtrqW940hFXpySYuHkZRvBn45nzZNqsTu7avwjT634NxB12BF O687V8yagqzbljbN9Vjp8GdMrjbgnaH79euH4cOHY+zYsRg3blywedfAgQODDby4OGVdtknRREGo nFwIFb4NRnRsssi8uEWnLSAbzxWcqct6Jo+DF3ubLPLk2kKRv9TlZeJrPvd10zLhC8/UFbmNio2W 2XgsF74NX2QaR2xMnvA1jvRNqnVFZsM71DxXLMzXMhlrnsTKH2gbX+QmFV2hWs48zdd91tNjrWvj a562NfkiM/k8Nnla15SJvovPtmYTG80XnonDOiJrjb621X3xJ9SUab7us54ec1/GQkVHywRfdIQK X9uk4oncxJexUFNP+Ey5CdV60he5TUdwRFfGNl3RETwZi43Jl7ENy2YjPNF3UfFrwxcb0dFj7stY qMbQPOFrKpjCs+mbPLFhvpbJWKipJ3yxEar1pM9U9G08bSt6mif2pq2MxcalZ2KJnskXHBdf7Gx+ hSc6gqX5IjN5bT2W+QjV/sw4TR091ro2vubpuZp87f9Q9Pfv34/77rsPd9xxBzZu3BjqcuOfH6Mi bha97sKid3j7muSltZWrF+PugE+yK+dje2PhVLn6bfxB+FNfDJ6pufGexzBvKT1vglrN6oW4/aKF Ab+S+r+9aC7+/r17Ax/3zVmD98XfRfOxO7BIoFR4Pef8f/beBT6q6tof/1KSkIBBwkt5P4M8JGhS G1RAg6gIVVIvVkWg0l6BW1uF/m252tb7qfZqsXwuSB8XsF74IOADsCCgoCJWscAPiRAKBCVgkDfI IxEzJBP973VmVrKys8/MOckkBNibz8xae63veuw1Q3JW9nng4/xQoAPzlmL2r9di8RDKbSaWrTiq urxDWJq1Q1ntwPSWC5BPvaG6K+yYBiOw8SvHmfEtvuLpIWgcfvpHnGoi6A6wiclNlE0LNFF3qqEb ACU6pzMnO36enfu+aizVCOZhwZPqwZVRBj2QJa1RM+UjESmtemLC87kYrZrX/3s79BnkvfF0+R8T xsx8L+Rb2RTlvaHWEP6D7+DZah9VPYNzzGRsCu/Q5s2bgDGztzvR8+ZNRvbk5zBZ7bTS8dLsD3Ow aHI/z9h9FQAAIABJREFUh89+7sPw8ymPK5lqJMnn4OcQKmkRFk3IxhMzn1O7v2SbjTdUAQN5i5D2 6DpgSgYajJmnIl96g/7IQ6ez+zjboHLzEblk3GMxJbSbvcRE9hpB67fpjOCqkkomZ1oAyyROOnCT S8xFzftpcJz/vOEfCuf7F0q0D4Xyo3z14We9uq2XeU3919TeS47nC0Nr41dNvj/s42KuVV1+Rrae dVntuo9lP9/Y1jyW9fT7e8rt56abPLYrvzC9nTp1Cn/729/wv//7vzh+/HjVRRz6BK/8/CSG5Y7H 5Nzb0cxBqBurBA9h0YANaKeecznlyE9wU8sdmPtErrqpJ8k/BJ65HY8cGY+J89Odu9oGz6jmJfQI TJR9fQ6lH4SeNwm1K3j2gwKcvO52PLTuehx+bA3+vrkjHtqVjTYf7EBOXkA1qRuw5OdBjD3yCB5a mIy192x0GtaykiKcnr0DKf89Cg/MbYfd47biq8S2uP21birLbnhg10h0pt4wsT0efusxdHW5u2lT rMNTD0/G5Mnq9cRk/Pdf11V6XmXVogCl5xrjqYVzkbbgb9imus7AljewcfwsTB2heJOBmywxFSNG A+/lHUEgfx56jViHtZ8XovRkLlo+egseX13gNLQ/7aUcz/oAhaWFOLbgbvXYmSAKD+4r3839uvAz 5J4JFbj03D4snzEF1z1/ELmLJ2HioAxsvm4uDu5aiOVT5mCXSjBv3kN44MRPUfptKd7qNwV3zwnt YpZ8thzPPvpP/H8HD2L5pOUYsXQnEnvejbVPqd3dx5fj2F/vU8/AvHQH/3zzcLZB1QPsymXj/quy tGIm7aNhK6w8crG6kVCkcLQAPfFaXVSkZC4EHX25/Pyy8oOtD+unfOUaJc/5kYyGvja/cvan+2G5 VxrNntdE/qJhvcasK1ys8o2VH9O6a9O3KV59kF2Ka64Pda+rHOzn617p6tSmOjbuGYR+jsvfTZKP ZGd1/ipAzeeePXvQqlXl53Uc2/IpMOwa9XgTej5nF3TrGGqqinftwglcgWGDQ8+zTB+fhn8MOIxT 404qeRJGjr0K9KiUJGVXZVQ6PZfuttsH993fEQmBMjRRtnc8cx2aJ5agLcU6U4bTx9QOpjrldf0f ViH4qTo9df9loYcenitF/JQ7MSSzJUq2h9ph2oNNahWK2ULR0J5sCvoPHVglDSkYPPxOXJuiJAnx 2PnlDLwqlSZePc/z8p4DMTlrHJZvLsDZ1xfigR+/jtaPA8dMeA+yz95dBoz+KQZ1Sla7yX0xYVYW em0+gqfabVV7oVnY8qOBoCekJLeltu+Uq8fSc4VIm7oFo/q2VQ1wF4V7Hk+NSkeyajaz8Dd8XRrA FxuWAwevwLNP78KnM4Dcp0INK50SPHXLSxioYmzvok4qDtCHlYhWl7dQO7Tt0SrWzyVxXcUFr9D7 LX1BfvovidX9VGse66bTbbGcOOl1DOuqtYCL0SjWvzzrY43kGiXPuZpkpPMrZ391Qd1yq4vYNoat gK2ArYCtQGwrIH+mSz62US5Nb3T32xtvvBHXX389kpLEOabhchSrXTd0aBxu3kSNnB4lEeEzUZWC mkd14m1javiCKCO9od9U0qq+lIyseYRsvwmdBqp6nuLD6oTOazqiz7AeiLv1KmT8splqTSsPaV9Z E31WqFqxAbcNRno432absvBXD9uVgfjWGDlpPMYNGodn0R97prfDh6pp8zeO4qMFwMgPugKfqFq3 vExVMTSohGmqwPGNqcn8EqURalqpjw/bE3E+JjEPsaX48jPVgGbdiuHDO+C2227Dr67s4ahC+8+h a1KlreSruLMCUwUi9VSR+i9dZ/LtBWOyK5fV9PRaPQG5WF1HQUmvY0y48gQtYytgK2ArYCtgK2Ar YCtgK3DhV4BOD8zMzMQvfvELDB482Nhw0ipb36i2G2d/ggLV9xXnbcOW/dRaqt3E1K5qV7IAO9Xp rzT2vLMXGNQUTTp1QRvV6mx5O3SDneLjheFTQIux+50D6vTbo3jzR+qay2tCe5COcZS3NoO6A1tV 4A5d0COzO7qlNq1qIbsi50Y+wfJTT2lv9tCe/YhwSWeooQt7la6qBqqQnPs6Hm0H3qsE69Spp/eq E3rVzYMq1E5Dfu5sserBgwgE1C2FVC9HzWHuubOqoVayogJ1XWVnzMAkjL2+FToPyAZm/B2hkh7C OnWab1r7lkjslInxyMUra/Ic70XqNOgAfQrrluP9rYovWI3R6prLFi5NvkgpzCbjprEjsG7JIXRI z3S+B6lXUGMbYQS+dPKOgLAq7xWI1H/pOpNXLxiTXbmM/7BRLnBhqDGUwRhmkpl0bo0l2Ufy4WbH MSy1FbAVsBUor4CXU+C8YModWsZWwFbAVsBWICYVSE9PV7tcWWjWrFlUf0m9M9Bv2CK80mWmwvJ+ mmoYk7vgh69dhbkD5uAjx0s7/GCXun4zriFGrErHrOFLMHUCKZpi5L4HkXK92knLXoNp6lTONmPV PqW8505H2YDGl++Ehg6MGyKh5/UYOe0olvSaiRXk8po0PPLuzU7zm8CNVrzy0TG035nUuxc6Yhlm tTyuYo9Gt/idGJqagb8UfYuBl5GDyINWWbWBa1q+erZuRFeWptyALcsXo/S7NyhxqF1VtxtyII26 AE8OaocnwwYjnt+Cpxu1IyHiw8IsdR3onsIJ6EQm6eOxdup96JUUOhxPGz8X746iVhb4/ca5aN2/ l2pQaYzAlsIluPb5ERg0qLXyPwLj1SWfnzm60KdUKX/aLhWD1tfzwRcwd8MQtG7wqKPJUrm990hq eOc6lH98I9Xch3d8U++aAvQahAZb5qJw2YOX9HWdopR+WL2P4rnef7GcfJOO50z1mBKj61znoW9Y ZbVMhHmd0g4pyYjqPP0vZjnzRJmnbxXz9B0knmU67XX69Ok/KH2dj82bN2PIkCG1Gvd8HvyaYpOM hn4akZs8UnFM/iPhWVddO7aPBT2fOZzP2LJ2lIc+6HvBcv07omO9zP2s1QtWYiRvyiWSnnQ0Yr1e Ux5WZitgK2ArUJ8qsGbNGuf5gPQYBno2J1E6/ZXunkmnxNKdNOPUXVTp5yS9ysrK1G5dqfNauXIl Ro9Wd6eJ4SgpUt2Hup4vQfcZLEGx6r0SkhPKm0UHYpCXqd2+EnXObRI3irqvaHNlX1z6HSSpWNFH GYqLyjxio3urS0SQ1qkCJqvPvNIIBlCkFEl0F92wIlCktqCT1R11KwG9T8i+VN26l+7SG3VQ/GCc N2xUZ/UfUJP/gykpKf+pVrhLvegvIXS+sonSXym+CetIL18sJ6rz1ICynHmippcSl8uJd4aHT5uh USkFlUOfk04eyUpe2jFvsmedpTGugDwI98JHCx+LpiRaDKuvvQrw5ye/CxTNTV57mXjzrOcZzYob Sl4P43U/rNfljLfUVsBWwFbAVqD2KpDgdgOZuATVBBniGuQNqXE2QD2LyN5zd9VQ5UV7KRfecB7V YkpbPWZF9ZeVRqIuqKSNPiF7zyWl+LHsVqKnd6EjovVPev+l4/V5tHp4xlf3Y6QAetLR5jIpN14u TPcndfWSpwNTHm4Hq3zwylimjCd7lhHPcpbRXOd1GdnRYFxoVuGL526UY+p6KSffbnOOa9K76fRY NGcs8ewrUlzCmYYfP4xlynHJL8uIZznLaK7zuozsaDAuNKvwxXMvlHz49e8WV8p5XV5y0DFufqSc bGTerJNxWcZYGYd1Ei/1Ou8Xr9vbua2ArYCtgK2ArYCtgK3ABVSBimakatKm/ovxrKM587oHkzwS vpI9nQZbncEJerHlBKWNTFDKvfirlxg6uKUDYX7Jg13mGUML4INmxvOiGMNytmW81JtsGC9xbMt4 EyUM20q9m1xidN4tnsyJY0mZtNPljNdjRZu7+ZHrYgz54hyIMk9yxrCc82GM1BOehpQxXsrYNoT2 /y59RfMvsTKuLmc/frNx86PL2S/nQJR50ul4mY/UmeTsm6kbnvUUV/phuaW2ArYCtgK2AvWrAie3 78GBU3QW4MUwAijYtA9n6OTHC3yUnTqC3TknKt0F+AJf0sWcPvVjkfovvR/j/k3WRMdIXVTeT9Np Ch41gAJwgro9y734uCAwdADLL5kwH9zKg2up13n2YTogNvkwyXSf0eYUi/OUWDc5Y0w5sk6nsciT ffqJS1h+sT1RXq/XvNiHKbbJh0km49eUj5X/SOuqbo6xyk36kbyXvPzivfi0GFsBWwFbAVuBuq5A AP/MehMffxq+u0xdh491vKIDeGX4ChykCygvmBHA+2NnYmrLitfqHHWt7L4tWHbrFuda0Hq7lEAO shtkI0ddhspj+8xsDJ65HvPGVBwfymOh7Jk52D5vjDp2HFPJrmj7POd4cvZ2claE2YMbYKZ0zAHO H9V7LZkJ911MSecFHwkj/Ufl/ZxeK5N0cxwpMbKXesm7+bug5LE6yI2Vn+oUj2LTfzym7IPnTFl+ IVDKORYjVn5ikUssfVRnXfJ7UB37WOYfC1/8hwS3tVxs641FzawPWwFbAVsBPxV44403kJsrbx9b YX3XXXchLS2tQlCJ+w4uuwb4im49WY9Hyfa1mJ4FTD5xS9UbH8m8kxJAT/z0cwAuzeuKL/jTC3gl MARTftnFCRn8F3DVa2Nw56AmKFENM93EqWR76A61dXsVawneTZ+FwN/G4/v8kNMoRSlEYaVnh5aq +ZeBxhj9QjH+7YU4xBdtwLDWP8NvDm7CoOalCMYl4bMXqbFcjiWbpyJ9cFsnwtZl0x16znk8ThzO fUk32q1XW9Z+ezXGRzpQJkwkvVMTL2+x+s5zMpy8W2ypZ55t3WzqpTzaQSo3bpQ880xNC3LTuclN Ptxk5MPP4ANspmzLc6I0ODemjKsu9ZKnzMEUl31wjnou0oZ5pjqW5m46N7nJh5uMfHgdjHVbl8kP 2+g6NznhSOclRjScSV+duCY/+npiMec1u8Vzk8citvVhK2ArYCtwKVTg5ptvxr/+9S988w3dALNi NG7cGFdffXWFIMwVvLwUr/z8YLm8X/g+tcV5mzF/wAacJs2wPhg35xa0VnelKc77BIsGfIgTJA8/ 3uTYnKXY9d2hGJquGqW89fjzE8B/vD4AUPyLT3yJzp2PYcf8YrSZdjv6N/oX/k7xBvXBQ6/fgubq pNH8l5dhiZNDU9yy6T58t1siDsxbilWfNUPzTTuwd6tqxObei+xby7A0Sz0HVI3pLQ+HHplS6eY7 Z7H+F/Px0fzQ403okS7cqB1YsQoLx+U7ti3/6xaM+Xkfp2k9sGKNku925M2euRMTxrdRu42r0PYv /4YeyveBea9iTcn1+Mn4jqGcci9D09zd2K9yylh2JxJfX+3Eazbldvz7L69S8QpVDq8qmeoYr7kK Y1fejjaJAaz/j1dwuHcbnPzdblXT0DrTSrfild/RVuwKTN2ejkfmf9dprRJbNUFDw82aKMmy4/vw 2u0rsH8/0GzSzRj7mzTVWof8f9G1Fb6cmo+zuAJ3rrsG27LWQMHQRzWx3x+cYrYN7Mf873+A1iOS sO136nO5ppvKeTjK/r7CeW4rbpuDo6ouPxnfRXV+2zEm6Td4uGg5+rs8nkbdLLd8NKZeWW2cV9w8 qYkStEATukOvunFUqDkKfYDPzn0fTw4ehcRgHhY8af6jSbnjC4ORB5/cg0mZn1WwvScbP6fXRnLo lqxMxo13s6V40iZS/POuo4NWOjDll+kgljGcLM/lAa2USTnxNJiyDzcq/RBvGtKXxHNcSYmXc5M/ XUb4aEPGlXlKOceN5sukd/MjfTKG7XluwpBMyomnwZR9uFGTbx3r1Rfh+EV+abj59yInX+xHzyna XPqXfqRc923SSZn0Eyk+2+gYro2bHze57sfObQVsBWwFbAVqXoGmTZsiIyOjiqPs7Gx85zva4eih T1TDeRLDcsdjcu7tameQhrqmM3hINZYb0O61UZhy5Ce4qeUOzH0iF2WO/EPgmdvxyJHxmDhfPbtT WQTPFCEQ7vPKvj6H0g/OOZ6gdqrOflCAk9fdjofWXY/Dj63B3zd3xEO7stHmgx3IyVOnjuZtUA1n EGOPPIKHFiZj7T0bndNIy0qKcHr2DqT89yg8MLcddo/biq8S2+L217op393wwK6R6Fyp4QROrliJ j97vinEHHsa4ZX0UrtS5DrIkf71qLA9hWM54PPZZNhr/bi2WrjmBkvyNTsOZsWwUJh/4Ce75QRtl U4bAoaLyfbVzRYU4cyZ0nauT0/zd6DB9DO6b3Q5bslfgi+uG4qH138PpqZtxQDVYB+a9jo9OXIPH TjyM29J24+UX9jm1CH5WiL2/O4yBuWNwy9hCrH39gHpGaTqGTVJbyxMGYuJfvufc/TeuObDzj29h 2e+XY/GfctVjaOQowYf3r8DXv74XU06MQtMZ7+Mf6vRbGuR//9SvcMeuMbhp7EmsUA1nh3WU5xXY 8cwO5cfNVj1+ZutJbFvXAuNUTbtuzcembWfR/p6bcJXy23XhSIwa29GJgcT2ePitx9DV5Za4TbEO Tz08GZMnq9cTk/Hff11neCZqyBW/l55rjKcWzkXagr9hm1pKYMsb2KiebzpVPZs0tDJG1ktqPvCv 2le5Hai72euLdbPXcc48Vjud0rlMVCaj8xIn7SUvbaT8vPP6ATQl5EWmY/S5Vz9cAN1ezt14rzHY nqkek+VMWW/yr2Pk3Atv8i3tWF9dmW6nz01rcpOZ5NKfG2+yIxkNaROSmGU6VtpJnn3oeCmPpvOK lXEl7+Zfx5hwJozMJ5peYi1vK2ArYCtgK1A3FRg4cCC2bt3qPNeTIl5++eXo3LlzleDHtnyqdjGv Qe+2iWqHrgu6qd6CDvSLd+1SO5lXYNjglo5N+vg0/GPAYZwad1LJkzBy7FVIUke2ScquylA9VMWg Zq0P7ru/IxICZWiibO945jo0TyxBW4qlmrnTx44qjNod/MMqBD9VO237L3MaxeC5UsRPuRNDMluq 00tD7TDtWia1CsVsoSjvYobilWHvm0fR8pc3qx1ZpemfquLtdVSH1+4JrbMj2XTEwGeSsHDzaRwu yFP6PrhxQEuneW7uuD4bcmd455wG9E1RLRzl1AzZ93dBkipaE2zHudISnNxUCBzaixW/P4Yv56u2 d1KoYQ2eVJHevs+pdUGXJMQHKPsENL1cnXbaqBkud55PGmqzmvRti24ZjRBMaOmsMeRBwYOncFjt sBa/uxHLdgWdXcykUtI2RMDxPwLdVF3iuiifU4YilKf6DLeeQ4mrLbXmSfjBIqpbCVLoc6HPMO4y XEZ8q+bqUTZc6RT0HzpQKd3H4OF34toUpU+Ix84vZ+BVd2hIEziKy3sOxOSscVi+uQBnX1+IB378 Olo/DhyLZnv+9ab+ifoukrv1X1IeCVft1fltOjlhGVCXmRbKeH1BJJcyxjGNpGOMpbYCtgIeKkA7 ezwutqaM1uNn59IPlmtmqa2ArYCtgK1AzSpAp9JmZmZi/fr1jiPjLqfSFH+uGqQOjbXmTSmcXctE hK4kJBfU2MShYWPqyoIoI72h31TSqr6UrLxpIt6x/Sa0k6iam+LD6pq+azqiz7AeiLv1KmT8kq7E rDykfWWNnJXixCZ1Qu09urXCqAYWLRuV50b+4tXiEpwHU0a+VtDtAN6c0zf46jPVgN7cFX2HqdNZ 1XoataHdU6oajZCVjCh5QlBz2mloP/TtS3vI2gh+rdpzoP2QnujbviF639oPzXrQB0FFpVHVP+fZ 0NU2ZOm4SAx/LmGRQ5ymVgrc+UJkYcBtg8GXgDbblIW/hvpodyOlCcS3xshJ4zFu0Dg8i/7YM70d Pvwyokl9VvJBIFPusZiSnHl9HW5yHRdxrp3PEBFLSk5UAk0yt+R0LOF0Gflme5NOxra8rcAlWYHq NI1kw6/qFo2atfrasHHjGW1tkfJnH4ShUZ/XG22dVm8rYCtgK1AfK0BNZ6K6bu7KK69Ehw4djCm2 vlFtZc3+BAWq7yvO2+Zcw0dNVlJqV7VzV4Cd6vRXGnveUTuGg5qiSacuaKO6ky1vH3LkxccLw6d/ FmP3OwfU6bdH8eaP1DWX1/DOmAOL+NZmUHe1E7dfNb9d0COzO7qlNq2K556KNM7NZYLhuOqU2pwc vL9iv2q3EpF6fzz2/jkXXynYgbc+Udc2hprg1jd2Bebvck5/BU5h16xiXN4+Ga1vpBNI92JbHiHL cOZ42GJrIT7dpta2PxdL1TWXCS4NtjLSRiJ6jm6qdusK0TK9u7OeNnQhbKQRCKL0XMVJtFT/wBmV R7AMJYGScBsZdpDYDlddo9amyt9N1apHZhc0S/JY62rYBtXHUnyW21bKIYBDe/Y79Q1nVIWUis9K sFVwUnDu63i0HXivEq0DHr9XnTyt/k4gAPTHj3Nn1bWvwSACAXVLIadTD+J4fj5OhZvawPECFByn mxKpoXZ18/OPl58iHRLG9J37Jy9OucdiSjZu9hLjxbcR4/aHEiPYh1AmZ1oAyyROuneTS4zlbQVs Beq4AtSU1efhJb9oGKmXfH1et83NVsBWwFbgQqlAUlISBg0ahC5durimnNQ7A/2GLcIrXWYqDJ8X q5qY5C744WtXYe6AOfjIsW6HH+xS12/GNcSIVemYNXwJpk4gRVN1M58HkXJ9DyB7DabNANqMVTuN uY5R6K2jbIriy3cbQwfGDdV1jddj5LSjWNJrprqdjhrhmxORvrzZi1c+Ooaan6TevdQJssswq+Vx 50ZCWL8Rm37XA5lfdkSHeweh5dS1+EvLHIWn9YR2PZPSB2LYlEVY2J7WqVZ6Tzp+cv8VKpcrVOy9 WDLgRfyDFE7sgej4X02xInsedqv1tRlEJ/+GRqWcSFRpbaEGt/2DdyNz00KV3w7HqMl/3Ymf/bxN +KY5oVrENVK5hZultndeCwxYg6k5x/HI699FXGdgd/ZLmOpYqxN4n8nG2OsplhMdA18ehsO93sTU 361xEP3e/om6gVPDyv6Vprx2hHLyTDDb9iaA+Fyaq56NRKqJv/pP7bDwh/MwW+UwQd1ICYGdGJqa gb8UfYuBLjcSckzDb/QJtKjSczct/6YxthFdxZtyA7YsX4zS796gxKF2lW811Eh9hZ8c1A5Phg1G PK8eIfNIKuZ27w5sOYlfpadg59zOyDi3Ed/+NhNFu15C97QATn77K9CZvrUwovVP0Q7ipH00rO/0 pXM2JhnLmdcp7ZCSjKjO0zeX5ZKnbyXN5YtkhKXPn+SMYdrr9OnTf1DyOh+bN2/GkCFD6jyuDWgr YCtgK2ArYCtgK2ArcD4qsGbNGmcXknYimzRp4vDUJDZq1AgJCQmIj49HXFxc+VkgZWVlzvWZpWob aeXKlRg9enRM0y4pUh2QuqNolRM6gyUoVv0APbaDDh7Lh0FepnagSlSjklSlySi3iswo++LS7yDJ ubYxMpR2JYuLylywpFNXKar16KNM7RzSnmJSYuWVhnJXsYXctSa6U5c52Zepz7HiekgXIImpnsGG 3rBhN8XKf0NV7AQ6kvc5/NiW0TqqGcdnWnUKr8n/wZSUlCkq2Tz1or+EUI8ejX4TxhCOXjwnqvPU hLKceaKmlxKXy4l3RjW+EmxqpBTYNLiJ5cQkhnVSZnlbAVsBWwFbAVsBWwFbAVuBS7gCCYYGzSmH y2M7YJA3VA204WpK71Ul+6p9oou9atCSK7XBAueua6iaSlOOptxdayIiRWJ92VM9fXYKpqY6Uj5S 58e2ofpuuFVa+rzE+Eg9ld6jSayuM5XNC8ZkVy6jXcaaDD2BaAsgvY7RfdQkn/Nuy9eC+U2kunZ+ 48QaH8u8a+rLj300rJver9yt3m5+3PBWbitgK2ArYCtgK2ArYCtgK2ArUM0KROq/dJ0phBeMya5c 5vXvF9QYymDswCQz6dwaS7KP5MPNjmPUjJYcxeZtReh3Xfeqp25U07O9BqyahVNm9al2tZmLbTir /x2xlrYCtgK2ArYCtgIXcgWKCrbjs2ALXH7mCOJSU1G483O06NoYXxyJQ2bfThfy0mzu9a8Ceh/F c73/YjmtgHQ8Z6qvTGJ0nevc605npMbQ1blQsL1MXvICWollu0rC2EzK8MkbL+Ojjz4vv6GzF796 wyDnxMs5+eO5m86rnP1wjvqc5ZKyb6as47nuw4tct2Gfkrr5kRjJu+FNcpaRvc7rMhkjEk9+5JB+ pTwWPPmO1NDWZuxY5G992ArYCtgK2ArYClzsFSjOUTfQafEu3UYm5mPn/DSMW/oxVo3LwOx/bkRa /0fx8Zal6J82X92/1g5bgZhWoPIBbuWGUgbScaxzk7PeF/W60+nFqd5E6nPyIZOXvMm/yd6Eq5bs VO4K/ONoY8Srh9/GalAzoTcw5Fs2Gswz5dhsZ5JHalLYXqcmP4QxyTlvGYdxTNk/zSMNE176Ndmy Xvp288O56nqWsy9THJNM90MY9mXC11TmN7+axrP2tgK2ArYCtgK2ArYC/iqQ0ON7eOATdbMdf2ae 0Ff2Go0We0sQaJGFQeld8YW6E21JyTmkTbqxtu5o6ikvC7poKhCtf9IP5HW8Po9WGM/46nZcFEBP OtpcJuXGy4Xp/qSuZnzhDix+D/jRxKFYOf/Tal2IbGpW3JKKZaPhJ65bPrUtpxxrOmTjR7xeQ31e nXi1WUtTDbzk7AVTnbVaG1sBWwFbAVsBW4GLtQKrh7yAy2b/CAO6qbu/qmdyLv7e+0j/x0hg5TIs +flBteymuGXTffhut0QcmLcUyzbFIX5xAc5OuRO/eLAML9/+JvbvV7BB6erxIAPQ8MAOrHy+IX70 v9erxvMsPv79YqydQQ8oiUe/1+7B0MEt1fND1+PFJ75E917HsG12MZpMuhnjf5MWulwrsB1jkn6D h4uWo7/2CI92t/wa065OQuMh09AipRNSNz6JuA6NMadHi4v147HrqtsKRDoIN/VfjGcdzZnXMzfV FRSvAAAgAElEQVTJI+Er2Xs9vbaSkZpwgrrcNOcEpY1MUMpN9jGWlWD9S+/g685X4Ninn6Lw68PY vvtojGNc2u6ocZKv6laDfZgauOr6lHbkvzZ9c/5MZWzL2wrYCtgK2ArYCtgKxKYCXW8O4qOX9znO vtryMfaq51y2PLhBNZxBjD3yCB5amIy192x0TpctKynCWdVw9nl7FMZP7IiCv6/D/quvx+QTD2Pi n691msayrwM489pZ5xkSh1/+O9a+3gbjDjyMh9d9F9t+uAgfH1JPlygN4uwHBSjolIWHNg3E2Rkf 4fOi8HoS2+Phtx5DV8Ndb+NSeiK9Zyf0TE9HK/X4mW6Z6ejUticye7aKTTGsF1sBcwWoH4vUf+n9 GPdv0puOkbqovJ+m0xQ8agAF4AR1e5Z78RFDTEN0vXkwbuqUiMJCegJuEOfOnfPsnxsVST0buwC9 ND4yHuFpLgfJ3Py4yaW9F746fnQbmusyU2yJ4bWbcG4yae+GIXl1fEfyxzpep6Ssi0QZHwljdbYC tgK2ArYCtgK2AhUV6Hb/tcCMrTipRHl/yUfHZ/vh3Ge0oVCI9X9YhTUL1W7n/nOhhxaeK0W82uEc kN4Sl6nHm7To1xV4cwNe+WMOziU3CZ39Rk+PV6MhAtjxx5No+etr0DqxIS7r2w8ZHYEDX9DxIz3W sA/Gju+O5u2aoYnzqHmyopGC/kMHonV1zycMObHvtgJ+K1C5OahszX0XU9J6wUfCVI4QZean6ZRJ urmNlBjZS73k3fzVgrwh2vZJw7XXXovrru+Dxo074Htp6idIDIeXhoebHcLKBlLKdZ2fFKUfL/4l XsaVculH5iLXK/HSj8R74d38cCym0pe0cctV4plnO54zNcUgnRc5+dRfbMv2RJnnmJbaCtgK2ArY CtgK2Ar4q0DDbr1xFY7inys2YsubTXHDTSkoPqy2Ha/piD7DeiPj4WH4wboM4zWal2XegonrbkbS hg2Y2+VVHKB+Uoyg4htfpk7bFcP2kqIYlq1PFfDbqzE+Uk/GmBqv00/TGSkYJxstMalnnm0j+a8d XcMuGDd+iO/HpXBDw1Qmx40Gy3SMnEusSS5l5I/nTDkG63Q5zXWZxOo6xrvJZTzm2YbnkfxLncS7 8exb5mOSSXvWs4wbO0lJJ326zXUM4/zIyUYOzk9SXS/nlrcVsBWwFbAVsBWwFYhWgab47rTm2DHu /+HshOugTmZDm0Hdga37gQ5d0COzO7qlNjU6KT50Agl903DPomHqis2TKCyVsESkjkvC/oW7Q3ey Pb4Pecpls5bhrVAJrcQHcGjPfnxVSWYntgL1ogLcf1Ey3INJmZ8k2d6TTaz+WOOWrEzGjXezlcXw tBgLqlwBuYtmapQqo91nsfJjilCbvileTdZtyre2ZVSPCy3n2q6J9W8rYCtgK2ArYCsQrQLth6ch /jF1A6Ex3RxoQs/rMXLaUSzpNRMrSHJNGh5592bnJNgEca3lsZUr8coTdJMgdZugsdejY7LDAh1D h8jd/uMH6LduEWa2/H+Oos00dWquumFR8XY17dgwDKZbDIkR2ImhqRn4S9G3GKjdSEigLGsrUFsV kD2XjKHL3XowHSd9SJ7svWLLr7fUHXASRE0v2iElOVGdpzn9L9QpyeSL9PR/lGT0P9tEe50+ffoP SlfnY/PmzRgyZEidx7UBbQVsBWwFbAVsBWwFbAXORwXWrFmDxMRE59WkSROHJiUloVGjRkhISEB8 fDzi1M1v6A+k9CorK0NpaanzWqmat9GjR5+PtCPHDARQXPodJCVXPkVWGpUFSlCidjgjYUoUBurc ONmwSh+WtxWIRQVq8n8wJSXlP1UOu9SLLjimM8MlpT38b9SLKenki/DUQJKMcPSSPOlYzjxR00uJ y+XEO8PvTic55oY07MJxKmWSZwxTsufBOCljHdNIOsZYaitgK2ArYCtgK2ArYCtgK2ArULUCqolO EjubVQFq1yMxISomQWHssBW4gCvAfRdT7rGYkpx5fZluch0XcU67jX4GJyptTDK35HQs4XQZ+WZ7 k07GtrytgK2ArYCtgK2ArYCtgK2ArYCtgK3ApV4B7p+81IF7LKZk42YvMV58GzF+m06jE4NQJmda AMskTrpxk0uM5W0FbAXqaQXktbqSr6fp2rQu0grUxnevNny6lf9ijeW2Xiu3FbAV8F6BooLtyMk/ hPycHBTw80EjmJ/Kz0GOF2AEH6wKntqDjTn7nfM3WVZdGjyVj005BTHxxTkc2r4JeafobNFLbkTr n7j/ciuMtI+GdfPhKq+tplMGpAXoidfqomTwS4n3c4DiB0s19Iv3U/dIviPp/MRww5L/2ooRyW8k nVuutS2PVU7kR94MifhIvkkXSR/LdddVHMrZTyyvWK84rzUjf358+sHKHKprx3V0y9NNznbye8g5 MDXlJ3XMM2V8tO8z4yTVfbCO5JF0nL8bhv34oRxT9xltXWznJ5bF2gpcbBUo3r4WU4e8H7qTrbO4 AN4dMhOrP96DF1vOxFTDa3XOl3h/rNLd/X6lu9kWzHtV4RcgnxrGwD7MbjkvxHss2s75aRi39GOs GpeB2VtPRbXatzQDGfN3RsV5AQT2LcL1Ga/AQ68b1V2x8tU/49WY+AoFK8KCtP5Y/Gkssouafn0D 6P2Wnp+f/ktidT/Vmse66XRbLCdOeh3DumotoHpGZ7FnRy5yd+xAbm4uDhXSdbIX/uADlAt/JRUr qM010UEU+a/NGBUrqcydj5iVM6g6i0VOXFPdO/nWD3IJw/hYxNZjnu95fV9TdWpf12uSOerfIanT P2vW6fJYzfVcovk11Y1zjKSL5tevXsY0rcEkoxjSzm9Mi7cVqJ8VKMG76TOxMkd7KKeXZLdWPmYM nlR3bPlOG4w5MB6TDzyMiauuUl664SHFT943EbemNUHwkBJ9sAufHWLbQnzy2FElrNiNU7djcu7a 4iUFwlzZazRaoASBFlkY1DPFbBY4jkOnwmtMzELa5Y2r4ALbZ6r/4zPhqxLxlys/jZy7gQaLDqHg eMU6qgQwCgIoKAg3yuQr7fLQM1T9ujH6jkfrLJWdczvhIA7lF/hbm/IZOH4IXDZjiPorjNRTReq/ dJ1phV4wJrtyWU2bTj0BuVhdR0FJr2NMuPIEa4MpO/Up1ryzBfu/+AJ79+7FieJKD2WKGJJ++coh 58TLF+F4rvPSh1eefTFlO54T5SF5kulzxtWEmuJyLNZJ/yxjylimJJdD4kxyiWc+mg37ccOz3IQj mck/y6Qt86xjf24+pJxtWcZUyknmd3AuTNme59K/5Akn5yY8+6oplXEixWUc58JYlkfLQ9pFw7rp 2QdTxvGcKA/Jk0yfM84r5RiMl3PJk57nRHkwzzqWR6ImbCQ/jGcM+zbJTRjGmyjj2ZcJ40Um7aVP L7YmjPTHejcZ6U06tjNRv3iTD5aRr+oO3VbOOUemFMONr258a2crYKrAgRWryncaX/zTDtWOqaF2 EOePXR/emQxg/dgX8O72AA68vAJb9gM7bpuDF+fsU8Ay5L+8NGw/Dx/nh1qwA/OW4s//sVztQs7E //yRcGqox6TQ4xZCQ93NN8wlqBsWJSQ2REJjktDNixSv7pjbkKbOI0JLkfMPajSBkvyd2O1wUd4C 2zGmwQhsNDzws90tv8a0u67DXdOmIaNKzxnA9jdUM5nUGgv2FTtB4lUSuZuX4Yns0LHq02/kq/rk 4fG0R5X+USQ1GIMctTmYN28ysic/h8mDQ7jZH+Zg0eR+zv/j7Oc+FG1yKPfg5yvQuXU8JsxcDS+9 56Htb6g1JeGuV8P1JDe56zHziWw0iG+AwU+vDjeJx1XcwaGfH4OfQ/gjQf4bT5f/TMkuxwLbF00O y5Mwbh19AlT4Yrz9UGe1tglYvf14KOFI74FDeGPmGCS1vgOfUmug6j9h8Bg899yEkO8J87B907xw nDF471BMuuRIGcVSJ3/of6sc04uHrmO5pF4wEl+F99p0ysSkE5mAlBMvdZHsJU734Wan43zNS08f RXz3G3Db4JsxLDsbaVdEua2ZB+/0S5X+SswvNqE5DalnnR8q7dkn2+sxWV6bVM+H5jS8yjk3Xotp DaxjbCT/uo7zkbaSZ9+muBInebk29i9l5Ivlkfyzzs239EMYGYP9S1svvPShx6e5LnPzqfuR+bDO zVZflxvOJGffeq6ct9Sb7KVMYomvzpA+OAf2o+fI8lhRGZvz5xykjuLJOWF0vJ9cOYa+DhmD/UuZ tNPljJe5MUaPI+fskyjzrHezZxxTwkt7lrtR9s+UcJw/y0yU/Ukdy4gyz3q3/FlOeI5LlHm290LZ lwkr/Zv0kWTsV18Xr1HqI/mxOlsBvxUoyV+PheMOYVjOeDz2WTYa/24tlq45oR4OUYbif50t30H8 6l/FCChZ+3tuAu1Hdl04EqPGdkRJ3gYs+XkQY488gocWJmPtPRudRrWspAhnFxegz9ujMH5iR2Wh 2s39uXjlF8vx8i+WqtcS5Krmldob91GmGrUrkPmnTjjxx12O3y9ez0ObZ9LRUhnx3qfRPrE9Hn7r MXQ1HKbGpfREes9O6JmejlYigYJNizBYNXVpM45g7Z6T+FV6uCNtpCIseBKdHv8cu5ZPwpMjluJU Yk/8cu1TSvEUdh37K9LUM0pLz+3D8hlTcN3zB5G7eBImDsrA5uvm4uCuhVg+ZQ52aVuiiX0noPTk LqTvm4LWqml8eskm46myRQUf4gnVyLZLm4Fb1u7Bll+lh5fsJIZ/dnocB/csx7onp2Cb0/w+hAdO /BSl35birX5TcPecHAef1GU49hSqn53H3sLyMBaH3kDaA9uw9mAhig9+gBEOkhrCZDz4Xil2rU3H lLTWaJD9NDYZr2stwqZFT6gmvR1m7LsFu05uQabzvNZSHF23AFPyb8LBY7l4fM44pPXfhi0HD2Lx +AWY+TY9naReD72P4jkd/MgDIJbTYtzkcqESI+URea9NZ7Wci8hsLxcleQGtxLJdJWFNJyePHMfX e97Cwlfn468zZmDD/rOeXcpfyPwL1Isx/9L1go0lhnL0Mginv7zYRcPU5bojxSJdJH20dZDei70X jJdYElMbPqX/mvCxzo388XeWqFf/XnG0VhNW/+5zDjWpjck2Fn5N+XMsk06ujXGxpKaYkfy75UN+ SOfXX6RYda2j3Gsrf5Nfjsc15fXyXFKpM/livRdK9uSbBlGv/rzivORgMbYCsgKHVRODYdegd8dE NEzpiIHPJGH/5tNhSEVHVs7FXYbLVA+Z1Kq5syN5+jPagSzE+j+swpqFB1Vjec5pBoPnShE/5U4M SG+Jy5Jpf5NaxCvQ++6e6Pf9q9Hv7h5O4xgO5E4KS9H2xj5otn8H9hw6ipypwHeHtlPNaLQz7VLQ f+hAtC5P3D1EUf5qTOjXAJ37/w2Tdp3Et+89g8HdKrZAS88VIm3qFkzI7ITOXbooR6G9wORW6vRW XI52rZKd5plxo/q2RepVhHseT41KR9vOPZGFg/jakDI1wBOmb1PNZy7wdH80bdAP8zbROcVqFOVh 5ph+aNp5EJJ+tUv9vHgPDw7uJhr1cwr0PF6akIm27dqrGC3UPIB/bVgOHHwHzz79LBbOUJuhZ0KB 2/btja83L8HMWX9XuC7OKb4FH68CRv8Ug9omI7HtdbgjjTzwiEPPwROwTTWvuT8uRv/OTdFvwjzw JmX+6pno16Ap+v+tmWo2S/He9AfRM6Wi4IUqoy3Pj0LbVqnopPxO3fIU0tu2xVV9srDv2NccpL5S vQmguan/0nG8Hjc5631Rr02nF6f6IvQ5+ZDJS97k32RvwvmWtUz7Pn48cRLGjRmPH9/aHjm5h337 uNgM6GBAf11sa7TrqT8V4IPh+nIQqn/360tesfjE9LXFwmdNfNSnfPh7SOshXlJncoG8cU15PTyX lJdCMq9D+vNqY3G2AuelAqo5RMtG5ae9UmsYTxtozuBTIA2HvGrXk0bxYbW1dk1H9BnWGxkPD8MP 1mWErjF0tNpbxyuQNuAq9B6sXgP6oK1qXjmChhTTIBq27oiMe4A3x76OvcP64Kq2DaO2nMJBVDa5 XQZ+/NupSMM6/N/85RHv3mroG43+veIc4+BxfPDay3hS9Z3jn38aWT1ah3wmd8bwn/0W41XD9uSs +Xgvz8NprqoyX34GZGXdiuHDb8PPNm5E7tgeyt9xPNcvCaNXfIXM225Say10alj4uQJ3aC4a2arL OZ73AV6e8axyOglPT8gqb+TbZQ7Hb6eOB9ZNwfzlHxhPES51ClEKao/50w7VxrlwtGqw8yuJ9kNe 7790vD6PthrPeMP/wGi+Hb0pgL4IfS5t3HgZXLeXuhrxee+sQe6x0N9ASr6O/qNCD0a/tOmXsdsv bz540e1iNffiX+YYKVfOiTD6i3U1oaZcTTKOEUnHmOpQXpsf2+rk4mbjJveTT6ywfnOJhI+ki5Qv fT/5O6rjWE7UNKob0+SLZeRTf7EuGvWSj1wT4d3WpsfinHR5dedeciXfsYwbKabUEc91qu76/Nrx 5yAp8359ET6WdfMTn+NS7vTiuaR+/DFW+mMZU45D1DQoth22AnVVgdY3dgXm78IB59DuFHbNKsbl 7Z3zI3F2/17sP1WGY2veca7j5D2s4H7VbJ4NNZ1tBnUHtipBhy7okdkd3VKbuqe+v0ycEvuNh4Yz 5KoMCeh5TzcVpxRdH7xKNcih2BWBgggG1JWowRKUKBrSBnBoz/5Kd72twGtcYitkjvwVtpWexCM9 PkWv5vHIfnoJDlVs+VUYhDqm0LyUAAGxM1gB88QFT4VOTY1vjd8XXK1OfS3F7EfuQqfy3cJEdMsc idnbSrHnkR74fa/waa7GxDhiMm4aOwLrlhxCh/RMZGZmIvUK9XkW7cVC1dROf/JBZF6ZgFx86Rh0 HjAUeHYutqu/HRTlrcREheEzkvm03ta9ZqLH7/ag9L3puCu9U3mDmpjSDSN/Nds5RbjHtt+HTxHO 8VmPII7n55fffChwvEDdXEklQ0PVJz//uOfvScioRu+RfvjKH9jMM16fm5JgjNSxvZQZ+eo2nZ4D qKicoLQh3iQ3JhlrYeerr8THr8/CnDl/wYKPSjFkUJcah+BfwPSLVv4S5l+8TKsbyM1/df2RncyJ /Osv3beOpzm/eM0yT9KZ5Cxj/9JG15ny5JjSP/uqKY2Wi+5f4vV8pO5CXpfMXa7Jbb16jXiu41nu hcq4Mh/ySYOpF1+E5Rf7Iqq/IvkirO4jEt6Lzs8adH9sy5T1Mk/S0bymQ49h8ifjyphSLvORPGPI L/OklxhTTJaxDc9ri3rNh+MT3stwy59rIOOyjGzoxYPnkpKO5mwj/bAdUTe5xLjx0j/xPMgnDaYs t9RWIFYVSEofiGFTirGwPT225CXszEzHyPuvUJf0tUDvQaVYkfoXzJ39FZo5Aek02URc/ad22PvD eZg9Zz8Sel6PkdOaY4VqTOixJ9O+/0/nRkTUoCZw98LJ0qWdYhAmrnyPNaxQNxvSR1A1epcNugG3 /Gkgbhqkmtrwngcjk9Se3YpeszD1ylmY3n4W3qE76wZ2YmhqJ3xiuJGQ7r98HpeCwQ8+g2+LD+LH WI4l2045KtqTa8FroW1gtfNII7n3HZgEdT1m+EZClXAESCvfMqaZczqrw/QNyYtyX8P4165UmznF eO+ZUeiWzG29gxJvceg2+EG8920xckcD/7dkW4VOxOB2v+eDL2Bu/xdVXqGf/8PmqE4yuTemqC3T W5or2bjlGJ2Wi/5j5gG978XzoxcgrWkDNO31dNgv5VGERY/+F5r9KlddG7oMDw6Up/VWhCeOThF+ cPp7KD62BVg+G+GyKU3T8jXTikMnJYfqUF5PdaXu3O7d8cLOUK13zu2MzrNCj6cp2vUSunefa7zO leLW4aAfyvTDmH8467+U9DnjZIo6Ruqi8iZjkrGceZ5Tk0q8pDpP/39IRi/mmdI3gHh+8dyN9jp9 +vQfFD72o6wEZwOlSGzSRP9R4cTavHkzhgwZEvu4UTyafinLX95sbjowMMkYb2nogMdUy4upNuf7 +xPpO2jSmWT16fM43/WsT7W4kHKpi++VWww3uZ/6xcKHn3gSa4ptkkkby188FVizZg0S1V1Y6dVE HR8RTUpKQqNGjZCQkID4eHW31ri48j9elJWVoVSde0ivlStXYvRo1U2cx1GmdgjprrVJiQkiC3Uz oaJSJCVzx1WhKisKoCxJ3XWWjkJpBAIoLv2Owkr7kOrifg+iqCiIZEONzve6A0VFKI1PQnIif0j0 MQWc7ybt0BYF4sp1hFWLKN/lPN+5Vyd+Tf4PpqSkTFEx89SLNsrpzxqRKOu+CeNozjxR5klODSi9 WM48y3WqoOU2xDuj4hNkiTvlxtMdUdE9mzBkT0nxkDzL6o42TFA/UOvfD5VITRH94ufBOJOMMZZW VOBSOWji70XFyis403fFJKuw8M9RfFOtTTL/3uve4nzXs+5XfHFEdPsexmp1bt9nN7nfuLWdv1s+ scrfzb+V2wrUdgUaqmYzqUqQhqqJpL2OqqOharIqaajJrtqbVjW86CSqcXPdoTy/i000NJH0x5DQ SFQNZ0V+hL3ER0Wj4F4I2X8xXsp0S71/0/We536azkhOOVlO3g0r9cyzrZuNlYcrYDoANslswapW wNZJ/cVHnO7GFTLJWFddSj7lwavkdZ+MJXlt5KLHi+XclK9JFsuY1pf3CvB3K9afSbTvs/cMIyNr K3+3qNHWRXoasa6nWz5WbitgK2ArYCtQKxXg/ouccw8mZX6Csr0nm1g1nW7JymTceDdbWQxPi7Eg WwFbgfpRAXlgKnlTdtH0JhsrsxXwUoHa+G7Vhk+3tdSnWHWZi1s9rNxWwFcFgl8hf8NJXDGwIy7z ZVi/wUUF2/FZsAUuP3MEcampKNz5OVp0bYwvjsQhs2+n+p28za6uKiB7LhlTl7v1YDpO+pA82XvF OtddSuNY8DK4XIzOS5xbXGnjhrFyWwFbAVsBWwFbAVsBWwFbAVuBigoEjmBJ9jLs93MTngrrSlzB nHmYevd6dbuY8Ajsw+yW85AfvkEpi+uC7pyfhnFLP8aqcRmY/c+NSOv/KD7eshT90+YjdBubusjC xqjnFTD1T9R3kdyt/5Jyk32Nl0w3+/EzZEJsp8siJSqxjJMy9sk0ko4xltoK1JsK8ClosUyoNny6 5ec3lle8Vxzl5Qfrto76LveyRi+Y+r7OusqvNmpVGz7rqh42jq2ArYCqQFxDNFZXeFa6ZrMmhfkg B2veq2jr1O2Tqjz0pCbuvdpe2Ws0WqjbJQVaZGFQeleMVndXLSk5h7RJNyLFqxOLuxQrwH0XU+6x mLLcVBvGmHSeZX5PrzUlZJK5JadjCafLKHm2N+k8L+5CB9JBj9dTmrxiveK81o4PzLzm6cevX5/V WVt1bNzWIH1J3g1vkpvsqA4mucmeZW54ktMw1dbNhvAmnVcZ2ZuGWy7VWa/Jv5SZcpV64r1gdBvT PJqfaHr26VYHsqehf4Zucvbnh3rNUfdZXTvyw/kT72dtekyeMyV/PFjGlOTMM2WsW/1Zb6mtgK1A /arAgRVrsHDcbiepZs/ciQljRX7Bo1g29FXs3kqyprgtZxSu7ZiAM5vW46XhOTirpM2eycaE8R2N MnooCo3dP3wbBQfuRSdnFn5z8X1g3lKsyr0MTXN3Y7+Km7HsTiS+vhofzS9Fsym3499/Sc/qLMT6 X7yqZGoP9ZqrMHbl7WhDN8YJbMeYpN/g4aLl6K+dG9zull9j2tVJaDxkGlqkdELqxicR16Ex5vRo IbOy/KVZAe6fvKyeeyymZONmTxg3nZdYDsbvTqdXx9EWwIlLnPTtJpeYi57XD7zq24L5IK2+5xmp brHKnWsRKVY0HflwG3wA7KbX5aZ1cY6RdLoftzn7ctNHk7O927rc5NH81nc9r9trnnod2N6r3Gsc HUf+63LIdUVam54T2+nyWM31XGLl1/qxFbAViG0FSvI3Og1nxrJRmHzgJ7jnB20qBwgmoPdzozDl xMO4c1Ih3n51v9KX4JNf56DpXJKPx333XOkiU8+eOAP0W5WNfh2PYum0PephjWL/1OhbPauipAin 5+9Gh+ljcN/sdtiSvQJfXDcUD63/Hk5P3YwD6jGcB+a9jo9OXIPHVF63pe3Gyy/sC+Wd2B4Pv/UY uoo7s/KC6HmS6T07oWd6Olqpx9d0U88k7dS2JzJ7tmKIpZduBdwPJEM1ifbLXdpHw/qucm01nTIR WoCeeK0uSgavDZ4OdOSrujGkD+J5SLmUMU9U4qXcK88xGC/nkic9z4nyYJ51LI9EGcu2hJW829yE YV8cjzEmuRddND+cG/tnn2znRhnvpmc54apzoG/y7yajWCYd5+BGvebGOKJ+htd1c+5MvcbgvCLh OWeTb5Yxhv2Y5IxhHWMjUcYyjYSVOre66XL2y1T6MPEmHMlouOm8ytkPx9XnLGfKepN/xnih0l76 9GJrMbYCtgL1vwKH19KjCfvgxgEtkZDYBM1bad1aYgo6X/k1Ns77EB+/DjRxmsYEtB2RhMPjFmPl 0gNISKHH6JlktP4ggvFXYujidJTOeBMbc4oqHs1i9K0szpUifsqdGNA3BW16NHPyy76/C5p3vgJN 1NWh50pLcGBTIXBoL1b8fjVy5gOlZ+iRiDRS0H/oQLT2ez5iyNi+X7oV0PstvRLyAM0PVvdTrXms m063BfAiSa9jWFetBdS1ER2w0EEdv6obP5KfmvqOlpOMzQdgfKAqdeRHzgmj473m6uYnUq7ShuNK mZd83NZFcVmn5yBjuMWVNoyXMuJZLvNkDPvluVsurCdq8iP1zJt8sYwo84znPHkejfrFm/xRDnoN dJzEcExT/rpddeZcE92/HpdzdpO7+aGc2EbmxzI9rsSQjuNK3g0j5V78SzzxvAZdLn1xPhbL4W0A ACAASURBVFIm7XQ542X+jNHjyDn7JMo8693sGceU8NKe5W6U/TMlHOfPMkttBWwF6lcFEpxnTAZd kzqzfg2mp61CoGN7dL25Atbj5z/GfQt74eCENzFz7Ea19wmYZGQRLC0Fug3AsEnx+Mdta3EC8c71 om6+K6KoXU85Kee/wVefqQb45q7oO+wqDFw1DPeN1XZoy7GWsRXwVIFIPVWk/kvXmYJ5wZjsymU1 bTr1BORidR0FJb2OMeHKE7xQGDoo0V+1kXssDn74YMuUn0kn12Wy8SLjAzfO3xRH92PCVMcP+TX5 0uPx3A+WbUw0Vn5MvllGMWozDn1eXvxLHOH5c+Y8dcr4aDjdTp+Tvf6SGI4jZX556Z9teY2ko+Gl RmxbE8rr4bjsy03O+lhQv2uknPgl43Pt/PqTPs4Xz+uRlHKRc+bPV442rq3ApViB1jdepZa9F9vy 6OrMMpw5TrRinN65Hxg7CDcP7oJEdflkiTq1lXAn9xei0+03Y9zbyv7NM6rpNMkq/BDX97HhaClE Zt8C4Momoufopjj7eiFapndHj8zuaNOad2gDOLRnP2Jw413X6FZxyVUgUv+l60zF8YIx2ZXLvDad bo2hTKDcaZiRukj2Eqf7cLPTced9TgdQ+uu8JxWjBGK1LvZDB2U1GbHyU5McqmsrD0glX11/tWlH +VGtvQwdp8/dfBCOvw9M3bAmOdnrL8b5yZ9tTNTNP8urk7cpjh8Zxea4TMneTe7Hd6ywXB+msfJb HT9UI66TTv3447VISvZyzjzJOa6kJLfDVsBWILYVaNjxOoyc1hz/GPAiprb8C2bdvzn8eJM45xZA ra/vC8xf6+i2oTlKp67A+9uLkDvpJSWbiem37UbHP/VSz/MsNchCuZaf6ZrYET94rVv5Asy+A07c BO4hCd1RXAeqpjRr/+DdyMz8FLNUDpTHnBdUc0wjsBNDUzvhE9t1huph36tbAf0gjud0IC4PxllO cdzkMgeJkfKIvMmIZCxnXqfUrJKMqM7T/yOWM0+Uefp/y3x8mGeZTnudPn36DwpT52Pz5s0YMmRI lbh08EAHFTT44IXmzEsDxkkZ825+WE9UYuRcl0sd8XJwXpyLbivnkmcfukzOJc94pqSjES2u9CFt pJz88JwpyWjIuRc+ZFXxLm10f3IuccTTcFubtHOA6k3am/RuOJYzNfkhHefihiO5bhsJWx08+zNR PXa0OftgHFPOiyitmeT64FpIGx3DdowlvcQzz5Ttec5Ul7v50eVudiSXOek4t7he5ITR/ZtkhHHz 5zgQeomTvqRc98c6prpen0sc6Xi4yVmvU8Yz1fWR5mxDVB/Rvoc63s5tBepzBdasWYPExETn1aRJ E4cmJSWhUaNGSEhIQHx8POLUzWvo/wK9ysrKUKpOO6XXypUrMXr06PO6vLJAQO1WfgdJiXR9pjaC JUqXgAR1pFlSVIKGyQnOwWhJUQBl8YnKpgJvklVoDZyLbwPSKArFi1c50OGxHZdyBWryfzAlJeU/ Ve12qRed0U3nm5uoOk8c34R1pJcvlhPVeWp+WM48UdNLicvlxDuDmrxYDQoqhz4nnfyNLXlpx7zJ nnXnjcoDDJ33k5RuazqY8eOPsOSD/FZncHzdh8yT/FbXv5sfKZc8xeKcZFwdQ3MeUsdy9qGvi22I RtIxTvfNfknPOo7JNjqG5SYqscyb/Okyky+WkR8veMLoWH3OPoma8FLvhWcfjOU5UR4yB9aTTucZ L6m0lfJIvMmvlJEtzZlSDB4s13UmuUmm27FfonItZKvHZX00uW4rY5h49mvSsUz6dOMJSzoa0ifj iTLvgNQb43luomzjBWuy9yrTczbZ1XYOpphWZitgK1C1Ag1Vw5xUVRySxKmGM6xLUA0nj4Rk0W2W 66vKGG+kLr6NWIPQlIMBZkW2Al4qUHEgZUZXHLyE9Dpen5u9VEg946vbdFIAPeloc5mUG1+xhKr+ pe688vIAQ/KmpOSBIOvZhinLo1HGM5V4k4z0utxtrsur4zuajVsMKWeeqfTJvB9dJCz50/WR5rqO 8zHRaFhdr89NPk0ysov0HZM21Y0hfcSS1/PR53qsaHodH2nu5sskN8nIt5s8mk7PS/qRvI7juY7h OVMdJ+WSJ5w+1229zKUPN96vH8YTlT6l3C/Pfpj6tbd4WwFbAVsBWwFbgQugAno/JlM29V+MZx3N mZe2xJvkkfCV7Ok02OoMTtCLLScobWSCUu7F3wWFoQMc/cULoGaBX3wgxHOiLGO8pee3ApE+G/qs SF9bw+374Cb3m4eef7Tvno6PFi+aP92+puvyG0+PX1tzv3WraR1qax31xa/fevrN29bfb8Us3lbA ViCWFSgq2I6c/EPIz8lBQVH1PQdP5WNTToFzvmX1vVxYlkWHVO3yTl1YSdduttSPReq/9INY7t9k VjpG6qLyfppOU/CoARSAE9TtWe7Fx0WJoQMmfvECeU7UjvpVgWifDenpIDXWI9KBbyy/J37z94v3 WpdI62UfsVw3+6wr6rVuXupQVznX5zhe6+l3Dbb+fitm8bYC57ECX+3B/7T4K3bX0o13SvLWOzf6 oZv9VH7NQ34NmsFoFds5Pw3jln6MVeMy8My0H6LB5NVhkyLMHtwAYxbR80nVCOZjQoNsqMeHGkfx vkXon/EqXNQVNoEcjGgwAjm1VMeKQH64IszLboDJqw9VMvrw6cHO+nOeS0OD53Iq6Wjy2YI0ZCz+ tIr8IhdEah74AJUplcILPhLGVzn9NJ0ySbcgkRIje6mXvJs/K7cVuKAqUBvNUG34dCuq31h+8W5x pbw2fEr/9YH3skYvmPqwlvqQQ23UqjZ81oda2RxsBS7KClzWHvd/9EN0uax2VpfQ83pM3jcek49M xA+mqHtgTrjF4R/ZNwqdk/3FLNlOd9Fd6zwTNJrllb1Go4VCBlpkYfjtw4AZH8BpvQKfY/06YMHm T53dy2DBh5iTdgdS3XKJvxxIuzx0vav740yddApR6Cm3aLnHTp+MrNHjMWPKCtE052PBk+vwwK09 0WP06yh4sHeVcI0vz0JaI7pf6SU1/PZqjI/UkzGmxoX003RGCsbJRktM6pln20j+rc5WwFbAVsBW wFbAVsBWwFbAVqBqBQLH8P7D/8Bh9fzNYrUr+ee7l2P1r19wdiX//PvcUBMV2I/5QxZg9Z+WhnYr h6xy8OTsTM5G/Dm8i7lsxVHHv+NnyKt4+W61u5n+PkrUDYcS1A2DGiXGIb5ZY4dPCt8B12T/iYr/ P7/+JBQ7eBSL01/Axp0FWJq1Q/nfgektF4R2SQPbMUbtLm407C62u+XXmHbXdbhr2jRcn56BEXgW uceV+cHtWEBZztgGOoG04MNlyPrJDaCe83jOIgwOX7719Bv5hFKjEZD7Fh4f0w8N4htg8ORFOB6l +SzKm4fB2U/gucmDnbO4Jsz7EJsWTQ5dFpY9M9T8qh3Wp9WOK50Z0kDttK4uUB+AGsHjmzC5X0je T9F+ExaFG8bjWBT212Dwc8gPwXF8k4oVzjl79nbHh3zrdMtopOVOxGZauxpF21epJvt53NgKOPD+ X/Df737uyE9tX4R+YT+9Jq5Di/D9oILHc8rzyX56dXnzWpS3BNlhfIMxMxFOHznzwutUutnq0ToX 2eD+i5bFPZiU+Vku23uyiVXT6ZasTMaNd7OVxfC0mEsJRP/BvQyvOPLlB+sldiwxem76nGO5yVkv qR+stDufvJec3TBu8vO5nos9tq35xf4J2/XZCtgK1I8KlOHE1pMIUCNVGsTZDwpQ0CkLD20aiLMz PsLnTt9QhmKF2bauBcbtGomuW9V1jtvOqg7pEF657f/hmk0TMSV3IHaPeyPUDJGfraoBfeBOTFx7 o3qGZ2hU6dVc7K/9zyFoMvtDLH/vED6d/jr23pyJ/r074XbnGZ/d8IDKwdklTWyPh996DF0NN8yN S+mJ9J6d0DM9Ha0SU5GdBXyQdxwFn/wDo5+fhdFYh7yiImxathz3ZnVWa8nDQxkP4N/3FOPbg8vx 5IiHkBNu7IDlSLpnAY59vhZNZzyAWRvCHVx4XVVI6TmsW/4s8q97HgdzF2POuEHov/lGHDyWi/HL H8WKPFXUYBJum/a5ulSsFB88tRx3vLpNuQlgwb398d4Da1H4bTHm/HQEcjeecNznzXsID5z4KUoV /q1+U3D3HDotNoBVj49D6nLyU4gXfphaJRWkXIcpI4CZ7+Q5us3/9yhGTxnuNNlfH9+KDQdOK3kB nkp7AA988DlKiz/HLIUPDconAyd+u0f5/xxdnrwDc+k8ZFWrn/a6BzesVXFLT2Jxy0fR+fHVCKpT jB8bNwPLP1c1LDyGH6a63g+ZA9RHKnsumZ8ud2smdJz0IXk3e4kp56t799pyBwZGJiqT0XmJM7hx RNLGDXNe5HQwqZ9+xQeYXuWUuMmPXJBJ71Um/UjeLU/K2+Rb2vrlo/mLpqd4OobmJrkjNLwxXv9c vKxXj21wXyU/E8aLLFqsaHqO4bYuNznbudWJ9V6p1zzJnx+s1/hecHURV4/Bc6amPCPpTPhYyyLF Jx0P/f8Syy21FbAVsBU4/xWgxw72wdjx3ZEU2IcmqDjULVUnmP5g0c1onViClI6q3VFnX5YVHAS1 LHv/7x2cKKZ9wyDK6EmGzuML+yD737q4P4aFUG72yV0wdl0aZmYtwV60w9gjaeQUSa1C3WULRUNP 5UxB/6EDHV3kt0Rk3DsC09/fgKtPHsUdP7sTJcsmYsNHHyF/+Wj8bEkyggX/Uq0lcMWLf0R+MV3P +KV6hqoiqoFE2iw8eVdfUPQnp6prRTfsxW8Hqq1C16Fs8DyeH6VsAqXIUv+mPTsSbRMDSFdLOXNG td+JbdHvyu1YMm813lkCtduqCho8iA3rgN/OHaSawjj0u2EwMJGCBPCvDSq7g1fg2ad34dMZavP1 KUouEb1UNz1uxF3otngO/mNkJoG1kYhbH3kcD9zyNopGJWHuDJX/sW4Ck6DWvhkzMB57BnZyPvEb 7sjCX88oiMpnm8rnYOqLeHpXscIAT6k/KBTtelvtFiv84E6On+9PmAX0ykXR9Iec5n7EXY9i8Zwn MDIzUo1ECvWLrfiFXZEX9V0kJ2oaUh4JZ7L1JKv4n+gJ7iSqL4QXwR50PcuJ6gvSZRIbTadj62wu D744qDxY88KznV8qffu1Jby0lzz7itaYMK6uqJ4jz3Xqlg/jSC95xte39XJeOjXlrmPk3G1dbnK/ /mUsnacYl/qIZT3rQy319ejz+pCjzcFWwFbAVsBTBZw+55vyO7mWnClUZk3R467eaK4azd73JqCt j80tT/bXNENjv0fchsWk3pCN3LQReEA1S7umt8XX2SOQcccdwPjFeF75Lz5DV3yOwK0jhqMDbsNt 9zVGD1qL6gWBcwi1eMTTcIQhNsK7tHEa2MRS5SlkfvzD59B60ELMXTsHN6ne8jOSB7/G14okxPOC aauVWt1SfKkAWVm3Yvhwld1tt+FXV/ZQciDzkbeR2+NF/PaO/pgyeiGKXxrlWDjK8FurG+5XKxuN /529Dwuyfoq/ar1g8Ze09vbqkwyN8tUFz2CfEmXdegeGd0hQce/DlT3UicgkVFfMVnzUtCrKMwWP vH0MPV6cjjv6d8bohbvw0qieBL7QB/dnTPlgjSnJmdfX6ibXcRHnfk+v5USlU5PMLTkdSzhdRr7Z 3qSTseuc93Kw5XbQ7SZ3W4SXWGTLOKJ+htd8yC+/pH+WMWUdz4l6HWzjFc84r2sgvB8s4SmnaDa8 RlP+LGMM+aRhkjOGdSFk5HfGMo2Mjp2W4zFlzzwnykPyJNPnjItG2Tf7kH5Yp8tM2EhxpB/dF+uk PcskVur98uRHft/c/HuRc06MpVwkL+eMlfnqWJmXxFneVsBWwFbgQq9AUu9UNFM3zzlR2gI9Mruj R8aV6npN76tytadrSLNykfl2Nvqpazhf/P3ukFO1y0a7qSXlIQI4tGc/DJd0liOYSUzNUG2XGlnp 6KxIh2tvoBnG33qt0y4l985Sjdly7C3pgMzMTGRmpCKJ15K7DwfpNGN1HebsKbn4yR2pjm1N3o7s XA1Mmo4HB2fgMtVpfun0l50xIEu1vn9cgvz8TXg0bYrKV11TqvY9bxo7AuuWHEKHdJWbyi/1CroK NYhDBcfQd+gEvLJlqro70gEUm5JK7IWJjwNTJs7ApElDnVNrJSw5NRNpeBKrtqvd6qI8zOdrOhN7 OzuX61RPmk41yczAFaooyakD1N7ts3ifThNWY/Pby1TSbZEULELBsUQMnfAMtqgd4QX5tF2qjyCO 5+fjFK1XjcBxdTr38ZAfBE+pdR8v/6NGCFFn79w/eQnIB2tMycbNXmK8+DZi/DadRicGoUzOtACW SZx04yaXmPPCux18kdx08OYmr07y5N8tvld/XvKRGI5Jskhyjq/jWR6JShviebCc50RlDlLuxnvB e8FE8k868kEvHpw7y3ldbnK2ZTz7Ico2JpkJzzjScVyWEXWTS4wbz7mY4ppkbn78ysk3DRlfn+vr klhTHRyH4TeJ5ViR/Ot46Z910j/x7Jeprpdz9kFYerF/r3L2xbGkHenkXPrXdRyX/Um9lFneVsBW wFbg/FcgruJE2o6hE1cpp/IdLyfB+PAprUBc83DGiR1x39vp+DR7XugGQ1cuwhfh/gHCTxjtxEig DTEeLvYfT16G0v+6Ezend8TQl29Bwow1eDfnLJJ690JH7Mas8hsJ7cTQ1E74xFPXGWrosrKvc5rM Vt3SVKMFDL+uUyibxL54YctcLBzU2vk53yD+PuyktZRS0zcDvZqqTYT47tg4aTHG9XW71a3apQx5 U6fkkh2PpuW1JGmiqkTnG/5dub1FxYrHYtUO507JwLztwE9e3YLH9z2N7t2fRbepqk3+8pzThPV8 8AXM7f8iWqtjPfr9MmxOrvJUjLcfbefMkzKmYNLCO9Reo2nE4caRP1WKLNytTqHlQZ9vC6en7Yfp z4/GuLTmaNC0F1YpeWjXMxGjX92Ifo8OCtVE5Tpnp2pMk9PVDu1UPNCrqSMf9Gg/bHwhG4nBz/Bo u5AsY0oLLMwO7cZyvBAtxtzu3fEC+VFj59zO6Dxrp8MX7XpJrXtu+c2KHGHdvVUcRJtjVhyomvXS PhrW7CGCVDpnGMlYzrxOqVklGVGdp//pLJc8/a2F5vJFMsLSd4bkjGHa6/Tp039Q8jofmzdvxpAh Q1zj8kEbA3jONJpc1/Ocqe6H5F5kOsZtrss5LlPWM2U5U13Oc6Y6juT64INdPjAmvbSXvG7L/qSt bi/nkXxJHMeJhmecyZZlEkM85+o1d7Y35aLL9HkkW9LpeH3O9jrVcfpc9816nbJflvM8EjVhSaaP aN8rwuu+3Oa6nGO5xTX5ZptI1BSHY/D3hn3rfqKt18239Ms+dWy0OdtZaitgK3BxVGDNmjVITEx0 Xk2aNHFoUlISGjVqhISEBMTHxyMuLs75GUo/H8rKytQ1g6XOa+XKlRg92tmHu0CLUYLiom+QoO5S Swek/ocfe3VTo6Iy0N1va2cEUFSkrmBNpqsqaQTVP2rKSa76LbXGmI1gQHlV3xkVKFAUQJzyXXxI bSu2botkJctbNAa9/nYHit+rOGU2oJIojU9CMhmFR0iWrGQsqR4NBopUG2v2U6TixiclO7mWe1f5 F6mt1SQVuCKboFqLEqr61TCd8jBemZr8H0xJSVHbyshTL7qwmbbUo9FvwhjC0YvnRHWemlCWM0/U 9FLicjnxzqCGL5aDApsGHxlyYhLDOim7YHk+AKQF0A9kHm5y1kuqH+hJnc7rB476XMfz3E8+bFMT SvH0V038ka1cQzRfEis/F5Odn/qb7Fnmtl6WR8uD/dQmpRxitd7azDOSb64n00jYWOo4HtPq+nar P/vVvycsZ1rduNbOVsBWwFbAVkBWIMFpPKrXcJIfP/YNa7HhpFwSVb/EDSfNeReY5DFuo+JCDacT Ndy4ff72FDRVj2ah31+9pjbGBwvurtS8JarcZMMZsjU3iqTzM+IS3f1QTUSfG3Kr8qeaVDScJI4D 5RjjSvlZRnWxFY1HVQ96jyaxuq6qdaiJNMk9yyrX2LNZOVBPMtoCSK9jdB/lzi9Uhg4G+UBSHjBK Oa+NZOdrmPKJlguvS+LkGt3kJkx11m6KL2NG4quzXt0fr8Mtd7f8WM6U/EbKR+L0HPQ5Yas7eB1+ 4nEsL3HlGv3EYN+cH8eMRv3EcPPFsU16N/9ucpMPLzLpT9ZQt5U41pHM7zD5Mfnw+3mYfFiZrYCt gK2ArcDFXYG+D76Eb9XLjnpVAXlwQM2HbEB0nSlxwrANUxPOVea16STnMiF2aJKZdG7JkX0kH252 HKPOqTygY54OxPjAkBPiOVOTnGT6wZ4+Zzui7ItodQf7YHueS58yB9ZLPPFS7pVnH14p+yXKg2U0 l3myXqcSTzqeS5/Sj+R1X25z9sn+mZIvHhxPYhknMWzDeMboeUk/kmdfRHUb1rnJWR+JyliSj2QT TeclH8LQ0LF6DjTnwTY0l3KpZ7n048ZLPxIj5czreXJMnbrh3Px7kUsM10CPIzGcs56baa77MWGs zFbAVsBWoP5UIICCTYfRLKMLLo9yxFtUsB2fBVvg8jNHEJeaisKdn6NF18b44kgcMvt2qj9LspnY CnivQMVBUciG53r/xXJCkY7nTEPWFe8SUyGNwnk9vTZ0xBfFWQQ128vkJe9mynZu+jqX08Ga/uIk pJxkNGfKOp47CvXGGJ7XBeVcODZTt9g6nnEsp7n04SZnO0mlne5H4iTPNkylzsRzPoxnasJGk7Ev HWeSs0yP5yYnn6zT/ZvmEqvHMOH9yKi50F9sL+OyLBLl3JhKrJsvXc7zSD50nRcbt1ykLzc/bnLp sya8m/9ocopJGKaMdwTijeWMZbyAlPthmcSyzFJbAVsBW4HzXoGv9uB/WvwVu/Wb8RQdwCvDV+Cg 8XaolbPeOV89+3Hpx1g1LgOz/7kRaf0fxcdblqJ/2nyEbhdTGW9ntgIXQAX0Pormpv5Lx/HS3OSs 90Wj/N3Hly99EfqcnMnkJW8KZLI34S4qWbSDOtL72W2I5k8vnh/fum1tzN3W67YuN7lbbvp6/dq7 +Y213K0ObnH0dTHOTc56ppHqQD7+f/a+BbzK6kr7tSSQgKDhpiISQUHAEpwwbeivUEGqVlulVquO wEj/R22H8dbHll6d39qnLZZntLSdepmODPXWClaqqDhVO4qKVaJCxRsXQURFRCQqMZf23+ucvMnK Zu/vcs7JSQJ7+5ystdd617vWXifhfMtz4yLOZSNmX5RJ7y/2b1/sUThz6EDoQOhAwTqw/1Cc+/hX MGB/i7G8p/k6lHLr/XoWpmV78JgZGLChAfUDpmBy9Qi8bj77tKHhY1Rddqzn01TdPMEaOtDJHYib n9ou4rKF2nh7H3ecxPhch05JYBcdt9dF+XR9MJtP+/ZpPekFbdomJR1I0vLmi9/XzuvrV9I++O5H n13ykZu6rwafX+K70uoK9bCnXaGWrnTfhFpCB0IHQgcK3oH6bfjznKfxf5Z9GZVlH2LFNxbh8UWN LWn6tX0abf0azCz/PubULcVEa0A99ITvYf4ny9F72nwMqKjEyJVXouSw3rhx1ICClxsIQwc6sANR 85O+WKNOvN5Tt8t02SXeZbdjE/3Pnz2CjIEFuny2jYXoGF2gttuxYe/pQEdcyHYEp6f81OaOqK0j OFMfLGVAkpp9GJ+dJcT5iQsyeQdCT5P3KiBDB0IHQgdy70Aztj+3A/XmSyJ23HMvHv/zCMzeMg14 5s+4efqGzHdBZLjLhmLO/VdghONjSUsqRqM68wWRlRnooJrqjKwckntVITJ0oAt1QOaxqPlL+6Rs zm/6CDZG+2L1pO/pFCJX8tgEBsCh0o6nPQlHwIQOhA6EDoQOhA6EDoQOhA6EDkR0oBkb7nsbA795 DAaX9cDgiSPRpx26AhNPnoTBub7Orx1X2IQOdLkO2LOWLpBzF6X4kuCjMJo/Vk8zdOoifcRRhUm8 9mvdxxfs3aQD+j19SUpOik+Kk5xpsElq3Ncx+1o/97Xz7uu/3+H8oQOhA3tjBxqx/Smg30Hle+Ph wplCB+I6kHZWIz5qJiMmLnesP83QGUXGYuMK037qjI3i71I+XpxSdqnirGKKUaPk8L2M0JXfhXfh rKO0bgXrwksNLrsE+mJaSRMq5LHz2PuonD4OxkSV4soThdc+xlLSxz0l7VH9JEZLxlPSJ3vbRl+u Mo4vyk8fJWtIe17GJZV2vqRxhcDZuWVv2ySPz55LDS7+XHjSxvAMOj9tPq44vy8uiV3XYeOjfDY2 7EMHQgeSdKAMI88txYZfroZ8kO2W+5/Fh0b2aA2tx9Z1mzO+VlNQQgf2rQ5w/pJTcwbTtjTdYHyi mEK9wMBXrC7Gp/tidTMSHSaAit8BuWjyDZyuatLibQ4dr3XiODjomlw44nORmtsXr3NqXfCMFzuX jbH3xBVbuvqZpgZ9Dq2n4SgmNt/zFrPWpLmk7/bSv4PUBUO9O9xX9plkb9fNfdS5iHHxdbSNdXV0 nsAfOrBvdKAk80Elh509GQPnPYRfDawFhpWao6tnPevX4uSRE/Crur9jkvVBQvtGj8Ip95EO6JlL H9m273mBkEXbOM2hdYlPis35g4R0QlvXyfVhbF3jbA7udQxt3U7KRY1eURcaxApG6xLPvejkEJsL Kxjf0jyC0VyMoU32Gq/txPoka/P5aSeOkvY4maQW1k7JGOay7XE5XX7NRX6Nc9m0X3TBsBby2Rjb TjxxSfIQ2xnSrk/Xr33aLnXSZ9uTnIEx5EgS48LYPHqvdYnlXnTmpY1S26kzVvYaZ+u2X+J8S2I1 3oeLs9s1CJ510+ey0aex1AVv16drpU6p+UWPW8wdhSOGkrWxLsZyr6X4iBedHNpOzaS/uQAAIABJ REFUG6ULr21RPIJz8UhMWKED+3wHyobj4neHZ9uw/9H4v9tHY3ddI8r7Wp8YVFaN1eZvKazQgb28 A+0Hj+xh5Rdf7L4/AG2PwuXcurTPdLJgndC2uQ5KvH0gsWsbcZRRPmKKLnmRQKkLkIsCbXftNd7W eWHhivPxaqzWbW7Z237Z++ysJUneDEnMDzt3DNzpdtVkAzVG6zZO16N1G5fLPipvLnx2jF2v7OOW 1CSLknjuKWmnFLsrn43nnlLiXbFi9/G57D682KOW5tI666O0OXw1axwxmlf8vj3xvpyaW3TibT7x aZvWxWevpPnsOHvvq8fOzz3xSfMTz3idX9u0rjG2TpzIqMW8SesULnJrXdu0PYqfPsFz+XjEr31a Z2yQoQOhA7oDPczA2faiWu0JeujAPtoBPiBScsaiFDt1u0U+u42L3KcdOlmoJnXZfMXZWMHZNuFm vMunc++1uusiSC40XMuFdeHS2DSnL28UX9KLIo3jRZjObecgntL2p9m78givvVw4YnQdun7aKYn3 SeJsSTzt3HcXybopfXVH9dgXI3bhtRe5KG1/Lnsfl8vuqimXnBLj4nfZcuVPG+fK3dXOG/e7lvbM Nt7Vg1wwdkzcPkneOI7gDx0IHQgdCB3YqzvA+SnJIXkBRSkxvnjB+HxJcmUwaYfOpMRxB2DhGqe5 fXaN6VK6vvCiXuiLhELzJW1g2rxpLvpsbnvvq1FwzEPpw6axJ81PThvv2rM+SsZq6YqjPyqOmGJJ qYWLul07/VoKhudgnPbnqifJnSt3rnFdsSbfWXi/iF/X7bO7eHScy19sW1Q9ac5V7LpDvtCB0IFi dKAZb9ZuRMmo4Ri0f/pnQus2rcGrTQNwwPtvoWTkSOxa+xoGjOiN198qQc24ymIcIOQIHYjqQNtF mhvF+cvtbf9EYBzWx+G1F+rTa70JjEMaYBeum2L7ori6rE8uZnixo3VdsOtiW2wuu45z6bnE2DxR HD6fz25zF2PPC0j2vRA55Xz2LV/eNHXmchbXfcIz5Fu7HS/1sUat2zjXXvBSF+M1xncGjaGusTyn lsQVUpI/LaeuVce67C6bjukIXXK67kefPa4G3xlcdpctjj9ffy7nyqVOX4zPnu+5QnzoQOhA+w6s /9l/YN7PNrY3ZnaNWPW5+/D4X3c7fPGmtYuqMHvJM1g2ewJueGIlqiZeimdWLcHEqkV4Lz48IEIH OroDcTNVmvlLYwtSd6GHTt9hWbj4bQx9BTlQVyPhhTYvduLq40UJJfGax+aSPW9xF/SaR2O1XfP7 7FIXfaxRpI7VdtFdeBsTtyeHPq/oekXVYOM0j/iE377pmKR6kjqTcPnOovlF78jlqyFJTl0nebQU nXvh03h9rii7+PQtSV1RGF2PDycYWZTE6TptHu0TXZbLJnbyUootlyXx5NB6Wi7NoWN1/YLhuQSj fbS7bIL18YsvzdL8dj258rD2qPiovNrn4uLZhV9j86k/qtbgCx3YKzvQtBm/HPhrrK/Pnm7IeWfg q+cPzWw2/eKmdgNo2TCgpGduXTh4zAwMQAPqB0zB5OoRmIF+aGj4GFWXHYuK3ChDVOhAITvQ/oK4 PbN9saixtq99ZHaXBOOKa7Xl+/Jau4C4A4jfxtgcrcV1R8V1UaFtWpfzxe11D2wsfT67i9+26Vit k9vGa3tn6Xad9t6uy+f32e34XPc2v73PlZdxUXzi0xezjCmUjMpt57Cx3FNG4TXGp9vxstdY194V E2UTPt1Pm1/HpvVpPHVKzSu6bbf3cXjbn3QflSetT+OpU9r12HZ7b+NlnwSj43x4badOyXi91zr9 lD6fy57E5sIwV5ChA/tiB1ZevMx8H2cjFg9dgAkPXojRLz+Oh/EZnPMPm3HHVfKs5j2Yt6Yalyz6 RzSpBr1fuxK/PfEvme/yPOrmszH9iwcB9Wsws/z7mFO3FBOtr1U59ITvYf4ny9F72nwMqKjEyJVX ouSw3rhx1ADFGtTQgS7Zgaj5y/a5DiAYzmyULpzXlnToFHJdEAldNpfPV5zER3H44pgjyE7ugFz8 6P8jH3cxZOPjyo/js+N1LbavO+6jzh81BBWqD4Xi6S69953XZ+8u5wp1hg6EDoQO7M0dqP7BZDxx 56OYvOI8VB1ZhtdX7MD2jz9Cz3Orccplz+K+3RPxtW8fbb6x829tbWjaijvMwHnMU1/DceUvYF7V H7F+ywU4omwo5tx/BUZY37YigSUVo1GdeUqzMsMzqKY6IyuHZET4ETrQ1Tpgz1Hc2/MX7VK/+Lin tM+lMbbPu086dEYNhl5y5WC8Ll7rCtpOZVw7Y9i0dSBqKGlDdayWyyDZERfxaTjz6ZvkkZUrB+Pz vVei8kf5kuZN08+knF0ZF3XeQvSzK52dv4P2uXz2rlR7LrXsrefKpRchJnRgb+xAz/690dN89XzF 4f3Qs/XKVj4oqCf6HVCC0l4H4oC+8praltffGq150xvYaeSG//ofbN8t78hsQnOjEWUVmHjyJKOE FTrQ7Ttgz1Gyd81fNo4H9+HpTyVb/zRTRbnB9iHsvUTpQ2ndxeiKd+GCrQt0wL54jSspLT6OT/wd wWnnLUSOQnDYdXXEvrvUWaiz70vn9Z3VZy9UjzuLZ289V2f1M+QNHeiqHcgOje2r0y+n1Z6G93eZ bT+MOm0s+qMZY8/uiSHlGhH00IFu2YG4+cmev2y8vY9rQmJ8rh8k5EpgH8Le6xifrg9mx2tf0EMH QgdCB0IHQgdCB0IHQgdCB4DGZvPxPk1ock2Y9U1o/Lhhjy6Vjx2JA7EL2xsHYFTNkRg14eCWZ0nr sXXdZnywR0QwhA50iw5EzU+u+Yt4+rh3HZYY7YvCaxxyHToTJzDZWKCOEd1lb1dc2Jinhlteyim9 0HqhetMRnIWqLfCEDnR0B/Tvv9Z1Xp9dY4Ie3YG9qYd701mi77XgDR3oRh3oOxSfPqsR94xcgD+t qTcvtIV5SW22/iFf/AfguuWYd8YKyEcKia9EfpqPsT3nwWq8Mn0h5g1cgHkH34bX64yzfi1OHlmJ Z8PUmW1g+Lm3dEDmrqj5S89pcmbOafr8Nkb7YvU0L69lsbGkFoAF2sXTbsH33q1crKR5mZeNl1jb prvFiyGdIw6vsZrL1qN4bKze5xqnOQqlp6klKTYpLu4MUTzik2XfVz57VK6oPB0RF8WZqy/XM9j5 bB7f35fP7uu/z27nj9vb9Qme3DpW/164YjS2I/S4nHH+pDXlwyOx9mLftI82wfrsrt8HYnW8nS/s QwdCBzqyA2U47teX4NPXNKCHee9mj3EX4OKWdOWjJ2LuW9XY3dTDfJBQD0x79pLWQg6oPg7f2P5p 7K77G3r2LTNeWdVYba63wgod6IYdiPrF5QMhpRwvCT4Kk6pFaYZOXaQvSVRhEq/9Wvfx7VX2NBck chHjwrsueKRJPryvgWnxrlp83F3V3h3PoO+nJHpc77tjD+wzFeIMupeaX7hdPtuuMUl0nSMfnWfX OTUf/drWmbqvzlxqyvdsrni7Pu4pWae9Fy5tI7e2MTbI0IHQgeJ1oGfmw4Ic+cwXc5Z7r3iNr68j JphCB7pfB9LOasRHzWT2/JZzV7x/gikZWSyL94VrP3XG+mK6jV0uOPTSFyK0axsvXMRHO3HFlvbF kt7zXLpG+n0+V/3Eio9c5CHe3tOeRGp+wescjNc26uLLJy/jRdqcYuOiT9dJGzH02Xbxu2y23T6H 3ru46ff5WJeWxOrc5CHO3tOeRGp+Owfj2Qs7j95rHuIZX0jp47btvnpcdtoobS5X/S6stomueegT rji7K1ZiyEGpeVw1RtnIQQy5tF3bdH7aGZuL1Hl0vM+uMXE6OQpRZ1yu4A8dCB0IHQgdCB2I6IAe VjiDaVtE6B4uxu/hcBkKNXT6itXF+HRfrNSrY1z1dxmbXFToCwpeZGQO0fIyDW0Tu47x6a4D8mJL 53PhfDady4fRdubTNtE1D3VKYmVvY1174nOVvrzCxz6xllxz+OJ0buqUjGFul13XZ+vsPe3k89np d0nG2D5dE3VKYmUvy2W3a2NMLtLFTx7mYS20u6SLR8dTd8WKz44XnLZrXXP47DYf95Tk4N7HQ5xL Msb20e6SxDIvpW3n3paa0/bZXLZf722s7Lkkhyxt4177qGfAjh863sYyv8boHLZdfMLBOEe6YAod CB0oZgeaPsD6J3fgoEnDsH8R8tZtWoNXmwbggPffQsnIkdi19jUMGNEbr79VgppxlUWoIKQIHYjs gG9+su1tD7bt6Wxce2/bTuKTYnP+IKG2dHtqOrk+jK1r3J4sWYuO8WG6rd2+8OkKB3FdXPnqKmT9 afL66snFXoi8afrAC1Xm1bFa51kExxjaRPrsxJCf+yjpyhuFj/KlyRvFU2hfIc8otfn677PzPmR/ dD1i463Q547iY07WFIXtij7dwyT1CZ43fWbRXVw+e5JcNoZ5bXvYhw6EDhSoA/VvYfH0u7G5SB/+ s3ZRFWYveQbLZk/ADU+sRNXES/HMqiWYWLUI8o2fYYUOdHIHXPOTzF1i981f2u6Kz/tIaZ/pZME6 sW2LKtR1IG3TvKJH+WzsPrnnxZPrommfbEg3ODTvqzQXtRJDPO9zOarP3g3asFeU6Ou/bZe93GTx fmQDaOe+WLKz8hbrfDpP1Fl9Pp9d89q6xPDvM5d4my/sQwdCBxJ2oKQHemc+JighPk/YwWNmYMCG BtQPmILJ1SPwuvm+z4aGj1F12bGoyJM7hIcOdFAHOJ9RcsaiFDt1uwSf3cZF7tMOnSxUk7psvuJs rOBsm3Az3uXTubukzouOYhTHCxv7Qpa56efeJ3mxpKUPm9SepA86n+sM5Eh6DqmNMVF1xuX1xZI7 13r0GXUNvnzarvGsQ/zaLnvmoBRbPkvn8vHoGlx5ySG4pIsxhcC7akrKG4ezz068befZtZ1YSl+d Pjvj8pVp+AXrW2l4ojh8vqR21sieJ43LF+c7f2fVk+95QnzoQHfsQMPmZ3Fj9WP4UIqffBRm3XYS Dimrx4qv34E3xx6CHVe9jJ1mSDzhqXPwj0eUofmddfj9Sfdh82bzNSvDTEzNp/H1X09Eef0azCz/ PubULcVE6zW7h57wPcz/ZDl6T5uPARWVGLnySpQc1hs3jhrQHVsWat57OpD8Iqtt/tIP6r54wfh8 ibuX6/d0xiWIOwAL1zjN6bNrTJfSeSHpu+hwFStY3vTFEblcMWJLm8PmieO38dxL3rhFbrtGbbd9 cZxJ/Jpf9EKsJOf15fHVo+1J+uDCM04kb8T56tF2iYlb5GMu4rXd9hGTj9T8osctH17b7Trp83Hb eOK0nRxio13LJHbhdfEwn/aJnnRJ7riluVm3xCSx27XoGO2jPa4WO6/miIplj3X9PrzGajxrpJ+5 fXbNr3m0PeihA6EDndyBkgH4/FMXYu72mTjq0Zex6vnM+ImmV3dhw1VvYtLqmThh1i48dNcWU2gD Hjv3Prx57gm4ZPvX8IWv9UPjU1k8yoZizv1XYETZnucpqRiN6tGVGF1djUElJTiiphqVQ0ajZvSg PcHBEjpQvA7EXQDEXUzo+Dhs6lOlfaYzdQITIAewC+/QQ+VSZNIYudCwl75QsX1Re8ZFYfL1pclB LKXObdui9trn013cGku/beuI/ts5JLfL5rLbOL1PovvO6YvVNWiMy277NSZtXs2ldfJobpfftnXE /ahrsHVdZ6F0+0zcUzIP95S0U/rs4vf5ktqJs2W+3ORLcgZiRHbU/a5ziC716Vx2vRrv8/nsOjap bteTNC7gQgdCB9J3oOeQYahY8wL+/IvXIGPlkaVZjqYdwNEPnoOxQ8qwaXg5SuvNt3I2vYfNzwH/ 579GZ16ce/hnDgO+y5wVmHjyJG6CDB3oDh2w5y27Zj3EpMHaPDntC/1Mp+8APKT4bQx9OR2g2EFy 8WDfWINc5PDGCxbuRdJGfJQUrMTYKy2PHc+9j5/+riqlbvvGWl29dtmID7LzOmDfh7Lnct1nLhvx uUjJJ5z2EpuuhX6fnf4g3R2w+yx7+8ZI133sshEfJTv6/krLnxYfdbbgCx0IHYjuwNqf3YSb/nkd Bhx7JOTFrk0t8KxszuxoQ9PHaDSWEvOe0Oxq9bTsgwgd6FYd2PPCpq38tgutrE1jbV9bVJuWBNOG dmj5Dp12AXEHEL+NsTkcZXYPk76YYsUum/jEHrcEIxcrXFEXLsRqPON8kjE+f3ezy3l4Y+3ciwyr e3TAdZ+5bPmeRjj134vv78tnzzf/vhJv99l3btd97LJJvNijVpw/KjbO5/p9EJvLTq6OrIc5ggwd CB2QDtRj8+27MWLBNIyrPjAzUAIcKB0dKhuMymOAh+Y/jTfXr8MdU14GjiG+HlvXbUaRPhDXUVww hQ4UtANtA0X2CUD9QGr7XImTYFxxrbakQ6curDXYKLoAbRdd+6LiNc7m8MXZuL12ry9WtO46sPjj MHZcWrwdH/ahA925A/r3X+v6TD67xgQ9ugN7Uw9dZxGbyx7dleANHQgdKGwHSlCCMnzym4diw/Tf YN7APwKnlOKFExdjU715NtMkK2kZQEt6tbzm1uCn3P5FjHjtGSyqWYH+c/sDO5qReT60fi1OHlmJ Z8PUWdi7KbAVswP2HMW9zF56/qJdavPZdd0ao+2RetL3dOZErjIzXh9K6wraTmVcO2PYhA6EDoQO hA6EDoQOhA6EDoQOZDpQNhwXvzs824xzv4wrvtQAlPXMjJi76xpQbvTK2ktam1V54fn4RsuuofFA fOH3X0e5uSLecvsteKF/H/QUX1k1Vse8qqKVMCihA12zA/YcJXvX/GXjeBofnv5UMunQmYTUPoS9 Fw59KK27+F3xLlywhQ7k3QH90jit500cCEIHQgdCB0IHQgdCB4ragR5myOQq79um06bltgeX4Y4r zKcMyRp2EL54b3V26Mxaws/Qge7Wgbj5yZ6/bLy9jzt/YnzSl9faCV0J7EPYex3j03UeO177uqwu A0suK9e4XHLFxeRbi8S7OHz2uHrS+l25ozgEr18aJ3paDvLPG3AV1YLKNLxpsLkUmQt/LjF2bUnu ExdGbLbd3jOXz05/rjJX3qRxUbgoX5rzCA9vaeKSYDuKN0nuQmGS9NmFcZ3dhZM6ffZCnSHwhA7s ix2oPH+G+XqVS7K32rPNp9tGD6n7Yo/CmbtVB6IGEdf8RTx93LsOTYz2ReE1LvMS93aGhJvECQwf C9QxorvsCdPnD6t/+2WsXLMRJYPH4tNVwwr2f7X08JJ/lZ3DkM8Z5KKI8Un0jjgh8yfh1jVqvHD4 fBpXLH3uu/9WrFR7VZ6092Ga351iNKqr1GP30d7n2wues9C8+dbV0fFpz8s+dXRdgT90oLt3YMea dfho6HAMreCHAqU/Ud2mNXi1aQAOeP8tlIwciV1rX8OAEb3x+lslqBlXmZ4wRIQOdG4HZO6Kmr+0 TyrlnKartjHaF6uneabTlTw2gQFIgbLseNqz3mL+3LUa199+PzB4CLY/fBd+9/TbibPLRYJeei+6 3guOe58vqZ08zG3vaU8imZOSMdxrbur0EZtE+i6QfPYknIJhLZSM414kF3X6aO8IKc/m6eFQ9rzp fLSJ5KJN9lp37WmjtHlcdrGlXawjCb/GSB5778rt4nfhxBZ1P/K+JcbHEWcnj8aR0+dz2XW8rbvw tInUi3ZtE512Su23bbLXMRobZbdxUXvmZC6bV9vJwxjuc5HkoCQH95QuO20+qWNFj1vE6DjG0EYM 7WkleXQcOX0+l13HBz10YO/sQD2emHIfnnnFfHqQ+TTbBwYswL216T8NaO2iKsxe8gyWzZ6AG55Y iaqJl+KZVUswsWoR3ts7GxdO1f07YM9a+kR8MKMUXxJ8FEbzx+pp3tOpi/QRRxUm8dqvdR9fh9g3 /mUVhn52Bo4/uh92DemLNz8qL0geGaZ4EaAJxcZBizolcYxz2RlLbD7SxU8+5mEttOsYrdOvJXtA Lvp8dvqTSju/rpU5tU14dYxPd+WPqplDlR4yNYf4tY97SmK5F6zo3NMvkj5tE11jqROrcxMr0raL TS/h4dLYOH7GJJXkI5575te5BeO7L/T9KTj7vhdb0sUcNl7noE5JrL2nXUuNoU5JnN676tF+iZE9 l/ZRJ4fIfBZ5yEE+5qFd7xmjJXH5Sp1HuGRPydq4p7Ttep8Jtn7ouu18FnSv+P20zxT2oQPdtwOf wP7ma1A+yHxAbSk+/ZevoMeh+6c+zsFjZmDAhgbUD5iCydUj8Dr6oaHhY1RddiwqUrOFgNCBonSg 7aLAn05fEBCvbXakYKL8Nt67TzN0eklUMSzeh9V+6gU5iC+hy95c/z62/O8tuPmvvfH+u42oOeN8 FyzSFncRooPjLm40Nk5PkzeOK6k/Tf2sj5I5uKekvRgyTf1x9fiGIg5NjJehSWPtIUrjqIv04TSG ei5YXRN5RLrs2haXS/yC11Lzu3Tyax/z0Me9xhRb9/3+yO9ymlUoHl9OH78PL/akMfbfrd6n7UOa vFG15+NLeu58chQr1neWXO6XYtUc8oQOdEQHNt2+BHdc/EYr9fjMZ9c2Yu1888q2S8/FcYdvw+1f eBglNcCGGxrxpY0XYFTpGsws/z7m1C3FRGsuPfSE72H+J8vRe9p8DKioxMiVV6LksN64cdSA1hxB CR3ohh3QFy+cwbQtzZEYnyimUEOnr1hdjE/3xcoBdEyiA8WDGvDOO8g803nmPwzEhy/fi5ueWI/P DKuKDw2IxB2QCyFemOqLH9vuu2BKnKhIwKghiMOWXQoHJp/fxhdjr2vS+Wh32TqqfldO5qcvqu/E uiR/5zry98vFzby6JhcujV9ju6Ied740NQsXe1hI3jQ1FANbjDO6+se8+owunPYHPXSgW3Rg67Nm 4NyBU1ZfiKOwCTdXLTdly7dt9sAHK+vQdEFTZr/ruV3YWfUZzH5xLAb0lZMNxZz7r8CIMtHbr5KK 0ajOPKVZmXEMqqnOyMoh7XFhFzrQBTvgm59su28Gs3G+I0p8UizSvKfTl9C26+T6MLaucTYH9zqG tjxlTxxq/k9VXb35DiezmpvMP0Qlyd9ozosiLfMsqPUiK4pH55MLB/tCQWyuC4oozrT4KC6XT9es /T67xiTRO7p+XYMMQXKTIYiDkPbbusYwzsbIXuNc/nxtNr/s5cbzUNLOfDouaf3EiUy7dD6JZT2s z+Zz3ffaJr9j/D2zYztiz9zMq2WafORJEpMGSz47Rva2TbA+O3l80sXlwvr4xc7e6TgfXjC+nD57 VIzOmY/uyq1tPKO25ZMvLpZ5mFfLuNjgDx3oDh3YtuoV4JRjzCfPlqHnkOE4YhggY6a9GlGOM3/8 KQwe1CfzPCjMC2UnnjwJgwv1FIydMOxDBzqnA675SeYusfvmL213xed9krR/ZixYJ7ZtUYW6DqRt mlf0KJ+NTbwfdtzn0Pf63+O6WvOC/8bemDpjZOLYJEB5gJcH9aglfn0h4NIlPo4nKofL58vrwtLG 2mQfV4/mJ579sHloZ54kUvNrPSrWzkss40W6lqs+DlR6SKJNc4jNhfHZiRXp4hNu28cY8ekYnYN2 YrmXGL1o1zjqgqOfOn3arvlcusQQL5Ic5BRJG3Gah/eX2Hif2TZ9X+tYl+66fwXns2sOnVfsrEdj kuhJeHQ9Gq/1qFwaJ3ouS3NIPHl89lxypInRedPquv40OeOwdh3Mw99J7Y/jEr++3zXeZ9cYO5fs wwod2Js7sPu1XYB5QiHJUwjNjaYTjmc29+b+hLOFDpgOcD6j5AMDpdip2w3z2W1c5D7t0MlCNanL 5ivOxgrOtgk3410+nTs3vWw4zrzsYny4qx6l/fqk/roUPoBT6iJsW9Re+3y6i1tj6bdtvNChXyQx lNoXpeeLZzwlc9l72kV2Zv26Dp/OoYhDkgtHjO1z2V02Hefyu2yMsX32njhbapzWo3D06aGSNkoX V1IbOUS6fme0Tes6ztZ9ONsetbd9dg69t7F6r3UdI7rLl8RmY+w986Sx54JlDKXO6/obp9+Wdrz4 XTbbrjFaJ7+rBsERa0vG+STx2q9tWtcYW/fhbHvU3vbZOcI+dGBv6sDgY81Tmyc+i03fPhqD33ge qzYD4xMdsB5b121DvyOHwXpLZ6LoAAod6GId4PyUpCzOWJQS44sXjM+XJFcGk3boTEocdwAWrnGa 22fXmDz1HuhjBs69dUVdcOgLLeJcts7sDety1eCq1WVzxdo2ySOxdj6XzY6VvWtwcuH2dlvUwLm3 n73Y58v1d73YdUblS/r3FcdBv/33S3uczDUujjf4QwdCB4rbgfKxEzD+lNtwx/AFJnHmY2uNzD7v mb3Q5eVuaftnQ+vX4uSRE/Crur9jUpg6i3unhWwd0YG4+Ynzly+3jo/D+ji8dv4VegEFcMgB7MI7 9FAFqHmvpnBdaLls0gSfvTMb5KrJZUtav8Tqi2Ctd+Y5o3J3tWG3q9XD3vG+Tfq7wLiuLH2/6125 Zrs2+wwcpG27Haf3abA6rivpcoZczt6VzhBqCR3oEh0oG4iTF12CqXXmuzn7mvd1qqKmPXtJy244 /nX7cOUxalk1Vpu/w7BCB/aSDsT9MqeZvzS2IO0p9NDpOywLF7+Noa8gBwokoQO5dEBfwGo9F64Q 07U6EO7PrnV/uKrZl++jffnsrt+FYAsdyKcDPc3AGVbowD7cgaiZKmr+sn2uFibBuOJabfl+eq1d gD6s7ZOk4rcxLlxrgUEJHQgdCB0IHQgdCB0IHQgdCB0IHQgdCB3IuQNR85ftcyVJgnHFtdqSDp2+ wVAX0EraomhfVLzG2Ry+OBsX9qEDoQOhA6EDoQOhA6EDoQOhA3t9B+o2rUHt+q1YX1uLTXXxx31v fS1qkwDjqVoQdVjzVC3ecX0vTWKOTgI2vYfax9bgvU5KX+S09hzFvcxeev6z+TLTAAAgAElEQVSi Xcrz2XXpGqPtkXrSoTMncpWZ8fpQWlfQdirj2hk7c8P336StIWlcFC7K56vHjpG9ffPF5mInty82 zu+LS2MvRg67HsmZz8ol3hfjs+dTn44Vft6S2DUmV92VT7jyPWs+8Ulik2By7Uk+cUnqEoyNc9nS 1mFzJokvRF7J48vtsyepLR9M2rxp8fnUFmJDB7pVBz5Yh38f8B94+YOOq3r3mocwb9qfsbs1RT3+ NG0BHlizE3+etQDzBu55u+EXG7Fp4S3GdwvWq+Fw95oVGfyf1pj3oKKFp1b0ZGvtoirMXvIMls2e gBueix+fNi6ZgAmL1iYjT4KqW4uqiRPwUlszkkR1DczuVzBhchX+qu6PrlFYh1RhX5zK3jV/2TgW 47PTn0omHTqTkNqHsPfCoYvXuovfFe/CdQtbZ7xvx3eBIrXwVujmkdeVW2z0Fzov+YqRg7m0lHPt C0v3V87M+9lnL1RP+HvDfIXiDTzuDuj7kwiXjb6OlIXM29X+TrtaPR15Pwbu0IEO7cD+Q3Hu41/B 8I7+BNrnmtsdo2kH0NRYikk3fg2XbJmDy188CX3Mp+eesvpruGLLhZj9dfNVLg3ydOAO1D7dNhxu XLomw9PUmOXL8KA9d7tE1ubgMTMwAA2oHzAFk0dXWN6Wbf072PpeyyBbNgVVB/R243KxlvfG6ZjS 8oFNTdi6fpMZndOtdzZtTR2zR4amNZi633ikmNfNhxuXmsqnoE+5xWZx1a9ZYK5xFuRfo5WmCNu4 C1J7/rLx9j6u5MT4XIdOVwL7EPZex/h0fTA7Xvs6XZcLIbnpRZvPrrGia3xcDP2M8XHRLjjXBY3L xloomYt7cvr2Gq+xWidGJHX6adN22piTPttODp+MwtNHGZVL+zRe23UNgvH5NM7WbW7NQU7aKJPY NdbGc08pWC6xabvv94d4kRpP3eahnXGuvW0j1iVtfsHQZvO47C6MKw9txJOLdpG0EaN9Ll3j42Lo Z4yLL40tKU9UXnIQI/mp08eafHb6bRmFJzelxNq65tM+bXfpgtXLtffZdB6fLtzaZ+eiT2Suy8eh 7eTXkjrzajxtQYYOdLkO1G/Dn+f8L940k8/ul1bgl2csxQPfuynzbOIvf7TajGdm1W/Gomm34IFf LMk+KzltWQYvrvdrV+KXLc9U3n3P22LK8kz7HW4/wzyDWf0QPhTjsB7qK1dKwU/j7FHWE+VlPdCz r3xubgl6GdmjzHyKbol8bUsWtWHhy9k6mrbimesahS161a/BzP1Ox0rHs7eHnvA9zD/tUzht/nxM 2GPmrMeaP5qBqXwwbtmYfSqyFP2w+um78d3p2cf0q/+4viX3O7jt8qnZf4+mXoP1mcmxHn/8bovN /Bt0zQPEvmew47PY0iosNZzZL6fZjQcvOBzl+11knvV9J/pMxlu/tRYLZu6HwYcvRqYL5pwXTZ2J a665KMt90ULz0t2FLf9GzsTDW7Ov4W16pxaXj8/WP/3qB1BnxsHFc2bgEazGhPL9cEOtsWz6oxlC s5j9pvM8e5bUz0Qt+/fLW859tTm3xfXkKnyn6lITeKk510wYary08HJMv/xqzGyp4bu31aKLvro4 6oHDNX8RTx/3ezYu3bOke8TnOnRGFWQncR1C4l12O7ZL7uVBWC6+5cYHaG3TdjmA60LdxuuDah/5 ySGSuo6x9SQY5mEs9xKr81Knn/g0kvWIpC7x5KSduYjRfuYTH+3E0+eSLjzjmZdxvrw+vMQxhhyU OiZJnS68tvEcOqevftvu4yEX/SKTLsZofJTNrp+5XDGaM05nvObXtih7HLfPL5yyRFKXvZ1XbFEr LV64dIzoua40PDxj3Hl1PS5+H4/vDD685iaGHLKnX9dj44gvhGQ+yaHzUNd+5qOPe5Ea5/JrbJRu 88helm3XHNrnw9Ou44IeOtA1OtCM7c/tQL1MAY1N+PDRTdhUOQUXPDUJH173OF7LvJSyGbsN5vlH BmD2i2dixHPr8dTzZpQ0Q+AdJ/4Fxzz1NcxdPQkvz/5jdvgSnufMAHreF/G1h441z2CaAXLzatzx jaW4/RtLzG0xVm/mSOnvQtPHpTjqF9UovW8NXjNDXcOqNdh+VhWOnmxS+8PM17kMxZz7r8AIxwfy llSMRvXoSoyursYgTr6Ga9NTt5mhqxxV172Fh9btwLeqWybSXsZ5y5Wo/M5reHHpZbjy9CWZ9zS+ tPACnLf9X9D490bcP34uzrixNlPR8NN/jh3m37Ntj/4Qcz+fxW7947dx3sPn4bXdjXjt0Z8b3K7s 0Ii+OP/hRrz4UDXmVg3GftOvxlOu94/WrcdtZpgtP3QCNp7wEHY0XmIiZTXi7Uduwdz1n8Ub21bj OzfONi/dfR6r3ngDd154CxY8+KLB1OOWsydg+w/WmX9jX8PwKz+Pm2sb8YV/uxZV5r+lL27DP1cZ ttLhmL9ul8G8gR8unYslz7c9u5xJpX5c+cRovLbtRXznkStx2/O723N9agK++dAPDfqHeHHbf0Co Gz/eiKXXLcbpt7yROf9PzpuAJ/30KlOXUeXCJWr+si8oOKfpA9gY7YvV0wydruSxCQyABdrxtCfh 6FIY38WAPCDzlk/BPv4oTonJJU5z+uLFLudy+cXmsmvefPSO5I6qqxB503KkxUfVXyif1OSqy/X7 4LJJHa542qNifHH22ZLi7Di9Fw6pRZavJo3vTL0Q55X6C8Xj60VH8/vyFsIe9/sg/jTnS4MtZP38 nU6S34URm3Ck4SlE/YEjdCC/DsjLVI/GrAuPRP9DDzTDYttU1ohyfOm24zF40EBUmFe+lpin6po3 vYGdJmLDf/0P7p7/gtGa0Jx5Ci7LM/3Lw3FAhUx+sj8IY88YjfFf+CTGnzEKA40ldtXvRtlRI1F9 zG48/8x2vPy7DRh1/hjsvysusgITT56EwW3lewPq1j+Ai8wzcIdP/E9c9uIO/P3hH2PqEW1PgTZ+ vAtV81bhoppKHD58uOEpM12px1+fXAq88T/4ydU/wa3XAavfl4OXYdz4AXh28UJcf9diYMoBBtuE Z5bdiBlzv4zKshJUfkZeoKpXCUZPvQjPm+F19Vd3Y+Lh/TD+ooXIPklZhwcWmGcx+x2J/yz/VmaY vfb8qahQ59pl2Fb9/J8wZNBIVFYB81b9ENVDhuCoo6dg47aPzF3yhvmfBVLqb3D11dfBlIr3zf8U KOt/oHmZ8QAMPXwQTFkoGzIOB3/0NBYu+I15LtPss0/F6kIzuuRbecdFqBx0eCZfL4OzufoOOsBg D8Chg/pmfoMyPfz5LThz3BBUTpqJecb75Ctdbuq0Zy19ds5dlOJLgo/CaP5YPc3QqYv0EUcVJvHa r3UfX7eyywO0vnXl4uUiwnWRUaia7YuVQvH6eHhh1JFn8uVOY2edWqaJ7wpY3+9OMXpf7N+rrtDv YtbA38ti3Jf6XMyrpfYHPX0H5D7k30v66LYIF4++n6i3RQQtdKCLdyAzUP6t9VnGhvdl+uuHUaeN xdizJ+JLy07FkHLPGYYdhKrjjsLYqeZ23NEYYgbXyGcrW2iaSg9A1aUHYcP0P+C+Rf0xocYMhOb9 oIVafc2zh1/9wTzznN8j+K9FS/HSe/6qMsfPJG7Eu6+amXLK53DqqSfiX1euxOpZo4B3HsPU8kNx zwfDcPynpgLvfmzQu/HaSuCwg/tFlvzOS4/i9ut+Ykgvw9UXTWkZmPui5tSv4ucXTsEjV16PpQ+/ 5OxZY6awRkg2djVbq5kIm97HRmOd8rnP49QTz8FKU+usUdnnSQWdjQUeu2YqDp3xJww77niMN/bM q4UF4Frt8rUByNVmUVp9tiJ5fjvzBLRnqFURxVbTzmrER81kxOR9ljRDZ1QyFhtXmPZTZ2wUf7fz yQNx0pUGS047piMf+IXbd/Hiy8sYiSvGcl0YJc0rtaZZafGam3Vqqf256r6afPakeSRec4heqPuU XJqfdYnNZ2fviM1V2vzCKzbX+Xz1MLfNJXafzWXPBc/cWvrq9Nl1rOjsra9GG5/vnnmYV8uk3ORI ik+Kk1qEW6S9xO7L67PbHHH7NDx2PTqW57DzaYzt415jNI/o9o0xQYYOdLcOlI8diQPNS0W3Nw7A qJojMWrCwea9mJ5TbG5WH/fTNrh60K3mpo8+gf7HfdLszXssL/okDjGaHgslXdNH5p2nTc1oqG9A c8ZZj63rNsPxls5W3lalbBBqzvwWnm/cgUtGvYIx/Usx/erF2Oqaujg3mRe3fnbW6Xhk8VYcVl2D mpoajDyoL+pef9KMrj/ElebZyGH7m2cZV0uWvjjuvCr8ZMGy7Mty77s980wiZ666TY/hu1PN+zTH LMCoq9ah8eFrcVp1ZeYZQomuOKIGl9zwMHasuwSv/GgMSvebjsW1W8WVbJWNxfQpwCMmpNrUWVMz AQeVm66ZCfFd81/ms5rMuzyfvfURfOeX38TU6iEwlZvluyMdadtxGX+jNK++dXCVs65ev8FkMXfT puXm3Z5TMG2kPJvchHfWrwc/s6n+HfPS7ncyr+c2rvewfv077e5rE9DZS1/08gFO29LUx/hEMYUa On3F6mJ8ui9WDqBjEh2os0B8QOaDv+zt5XoAF5sLa8fKXueIi2EdEqd12fsWcbomrTO/Lz4XOzmZ m+eSvSzKXLijYnRe5tT57Lw+vM5hx2hfEl3ieWNNOq/4aBc+7Yuza6zNk6Q2jWGNlHYtNj9x2q51 1qZzpNFd/OSkj/3RdtrS5NJYF5fLpmNsPS1e4nkm3UObt1h7XX/SenSM6LmsfDikTtfy2V1Y2+ar h5yUdpzstc/Ho+M0Xtu1rnkEL3tZ2k6bjrN1jdc8Ni7sQwe6RgdK2kYM84E/XByMsvvS1g8CKunf gigbhnMerMYr0xdmP2Do4NvwesvMIB8c1G6ZZzb1kpGmpJWRnrYctJTIux8rRuLMmz+DL80Zacx/ y7gYW3I48PL032Lewb/CtUOvx3/+eqOZd9bi5JGVeDbR1NmSqaQCU8//Mf6++w181XzUz+KW9zRK DwbwvaGl5g2e5iWsskaffxNunvgbDG65/jjlxtXoO/LzMO/6RH9jm32nQC/FzIVrzLPA12LG0tkZ +5gfLDPRfNazDrdd+m848FurzXtD78b5k45oux8yWdp+VBwxFT9+2LxXdPUMLL32HvVdmfxQIkDe fiov/pXVVncZZvxuJcZfOrnlMbAUN641L23tOxZzL1yNyf3NBwmtAU6cexl+Mrm/wVwAzKjC3An/ gsy30mTY9A+Vb0CLvR1XnaGWPsw1vcl+kBB6mfPeeBb6mb6UHn4WvnPnf6A682Trbtx85JG4Seox a+3Nh+Pw67NfT1P34m9x5JE3ZwbVlizFEr4HV9vufkBMPn/54p3ndIHFRjt1W8qwKjaRti57+Su1 pdj0Tfzy+yQ2+e1yyTE7d+78qfEVfT399NOYNm1a0fJ29gN6PvldsS5bMZpZrLzFylOMnnVkjnz6 5Ip12QpVfxx3nD9pHWl5NF7rvnxJML5Y2gvBQa7uKrtbD7pbvd3192Jvr3v58uUoM5+6Krc+ffpk ZHl5OXr16oWePXuab5swn9haUtL6P7+am5vNk02Nmdu9996LGTNmdOMWNWB33d/MJ9CWZS5Iu/FB UpdeX1eHxtJy9JU3RmZWE8wHupr73+zrzafClvTNvGdSntWrq9uNvn3bXtqaOlmeAXWm1tJy1pMl q6+rR4m536T6pmzhGb3O2Psae5qlubLnbcpw1C6YitmYj+cvGYu6+hLVqzTs8dh8/gYrKiq+bTLI Jy/JG5Dl+XIt5Tlu+b8dlOLTN8HLUCo2wclN6+KjnbpI182YW+2iZxZ/u7iPk0LMgZRY22b7iRMp WC7itI0+yigfMd1WykUCV5L/60xsV5L70oXO3nB/daXfnahaiv17FZcvzh91Fu1Ly9PReF1b0Ns6 kLbvbZGdo3W3ejunSyFr6EBcB8zXnnTeLBVXXIf6y8wQ2X40M+9ZpKFM+8yw1YkDpzTBlb9MDZYl rYULlodI3j7NJc+J9e2bHZVKex2K4ZnnysrMwJmcrwshOXRQcsaiFDt1u2yf3cZF7tMOnSxUk7ps vuJsrOBsm3Az3uXTubu13pUGzVxrsePk4keWbS/WHSV5O6qGzjpTsXrXEXly7Zkd11H3Kc9s56Od Ms5PXJxMy2Pj7b2dL85v43174enonvtydwV7ofpYrLN0t3qL1ZeQJ3QgdCB0oFAdGHfRb3F3ocg6 jofzU5IMnLEoJcYXLxifL0muDEZe4toRK+4ALFzjdB0+u8YEvQt2QC5+OvsCqCvU0AXvmm5dUrhP i3/3hZ4Xv+chY+hA6MC+1YEda9Zhy3vyCsb064P1G7F+856fFNT83lt4uXZ75nWR6VmBuk1rULt+ K9bX1oJft7m19gHctnAxHlvv/oqQpvfWYWXt5nQfmFO3CU/VrsfW9WuwholyKTjE6A7EzU+cv3SM 1nV8HFbHJdI7aujUyeUAduEdeiidPOihA6EDoQOhA6EDoQOhA6EDoQPF7MCmhbdkP5ho4IKMvOHG jVb6ejwx5T4880r2U1IfGLAA99Ym/9Sgt++6B4sXbbE4gYaNq3D351bJ5+TmtNYuqsLsJc9g2ewJ uOG591C/5gYcOmEuGswHL729Vb5eZs9Vv/E2fGbCHak+MKdu7SJMnL0Eq5fNQNUNz+1JGiy5dMCe t2yONPOXxto8Oe3Tvrw2LonvsCxc/DaGvjju4A8dCB0IHQgdCB0IHQgdCB0IHeiADjTgT9XXo/4/ L8QXqtO/aa9hzUO4dgpw+fYT0FOqMx+4g8tOwOXfHonm3X9Dj3Kb8xPY/xjgA/lITfNewU//5Svo cej+Rk9YR1k5SssymTLPasqncWaWfDqtWa37zC75j4PHzMCADQ2oHzAFk0ebrwR562NUXXYtzj9t qp/EfA+prMxR/Kh2nvKDjzD7LeYrYobjssmih1WADkTNVFHzl+1zlZIE44prteX7TKddgD6s7ZOk 4rcxLlxrgXu7wvdN2ecUu/bZextv73Ws7eM+LSfjtEySR+PT6uSnlHjWrW3kpY/7XGUheFz15VNP rrFxcTyrXa/PHsen/eTQtnz1QnDaZ823Jjue/JTiZ93aFmW3OTXW5fPZ7Hw+XJw9CY8LIzaXPS6f y+/jse323sWVq024eSOHvac9SuZao86VK0dUXeLrKN64vMEfOpBPB7bcs7z1mUU+q7jlnmWttt/8 4gUzzsmqx4qvL8Sdv1iOGzLPQi7EM+vrseX2e7BqM/DCiTfiN5lnJZux/vYlLfFZjETvfmkFfnnG UjzwvZsyvl/+aLUZnLZiyZQXjPcFXDvwFqw3X7kiHwVaekBf852f8gFFZa3f/bmplfN6PGWe4Mt+ bUoj1s6/H2tec9TR9DbunpZ9tnTewIV4dnP2FCW9StH4yNP4TfUCzDfnuPP2jY6X1O7Cim9k65w3 bTne5Ktx69dg5n6nY6XjidVDT/ge5p/2KZw2fz4mlK/BBVWXYvV1J5h/Fy4yXz9Sjz9+d2rrv4HX PLBeWtJ+vfMULh/f8u+k+Rqa7LfPvIPbLm+Jm3oNTLtRUvl5rLrxNIw/7UpcNGFwe46w64gORM1f ts+VPwnGFddqSzp0+gZDXUAraYuifVHxGmdz+OJsXLfdu97/KA/49vupuC/UxYArR3dooq5beqL7 oX35nKVQPPnUYMe6fk9sTC57fVbdT589bY7we5vtmK+fPruvz4Xupy9Poez6fIXiTMJT7L+XYt0v ndXPJD0PmNCBzuxAw/qVuHX2y5hw9z/h8i3/F2d96RA0rF9hbFtxSu2FuOLV6eh91UNYsnx7psym V3dhw1VvYtLqmThh1i48dNcWDD3rszjKeEfceib+adYwNLz0JBZf3IRZb12CC27ti4fOWpl9yWpj Ez58dBM2VU7BBU9NwofXPY7XGofgpN/Ls3VH4LwXz8Th5lNwM0PhzY/i7p8tw53f+3N24Nv6LO64 eAdOWX0hLl99Eg7MVJN9T+cHK+uw86OmPepAU0+MveafMHf7HHzxsl148HdmMuZ6dBuO/u+ZmH33 0dhw8T142XrL5ZaFd+Hx7cfgChN7YtXLuP2mjdnIsqGYc/8VGGE/+Wq8JRWjUT26EqOrqzFo/3H4 0f3fwZTvLMW2XfMxxuCHn/5z7DDXX9se/SHmfn6J+q7NLPWau76D66ruxO6/N2Lbf5yOcmN+aeEF OG/7v5jv8WzE/ePn4owba421AtU1o1E5uhqjBxX6hZfZWsLPPV5dyrlKZi89f9EuLfPZdTs1Rtsj 9aRDZ07kKjPj9aG0rqDtVMa1M3b2Rh74edO10CaSizbZa921p41S84gtl2XnjOIg1s7rs/u4XHja JEbr5LBtei8643wXk4KJ8mk+5iQn+bmn1HZt03bqIqkTS6ntYvMtcth42nUcbVrS77LZPu59PaNf pPBxUWcO2+7b055EkpsyLoY4kXr57BqjdReeNsFpnXG2Te9FZxzxrj19xOu95qM9jSSni4c2YqJ4 iWGMxtJGjPbZOjGM0X7aKOnjXqRecXYbK3vG2D7afTk0nrqNpT2JZCzz6hjaiNE+n84Y7adN89Am OK3rvcb77DpW64IPK3SgMzrw5kMvmbRH49jjBqJnWR/0H1SGNx9aB5xyDMYOM9+7WTEMk35cjs1P 78yU17TDoB88B2OHVGDQcPMyVXkxasn+2H8YUD6oP8rLemDnq28brHmm8KfLsPzWN4DNH7c8kyhD 4tGYdeGR6H/ogeiT+UZIiZMJrgwDjDRswMfmdvggVE44DMMnHoLeZq7atuqVbE1DzDOfQ4bjCJNP nhFtt6w6UFaBww/+CCsXPoZn7gL6mNpkNX3ciNJ/OxUTx1Vg8HETTUXAhlc+zPiyPxqw5SnzHsyt G3DPjx5A7SLzBY3vZwdcGfgmnjwJgxPMev0Hm9G4/CAMMl+VYr5IBePGD8Czixfi+rsWA1MOaDl9 W9qhx0wHbjkLl15zNz7qW2H89fjrk0uBN/4HP7n6J7j1OmD1+/JVkWEVoQPtHzjNP/0mp2v+snEs zWenP5VMOnQmIbUPYe+FQxevdRe/K96FK6pNHmD5f7VF8gHaZ+dFvfazYPq4F0mbSOran0bXOVmn L15jJS/xPntaHp5F8/k4xK7Pz1hK8QsPuWQvizaRXMSQT/uI0ZI5iKcvikf7yO/jIZ8tNYfEkkdw 5NIxrI8+yigeHe/SGat9UTbJyTq17orRnFE6Y4WPZ0qDZz02D+0+Lh+eNWi/j0Psum7GUoqfPKLr Zdu5J5/sc1nMTR5ypOVPykP+KKlz81zaxlzCkdYuMTpe9lyaKy4vY3ySXD5/nJ01iqQuMeSlnXVG 8ekY4rVNuGhnLu135WU+jUvCw7ggQweK3YGeme9StMY3M5RhYK/W9zbKuNXydseWQS87gFlRZjLL 2ne/aV4YeswwHH3KWEyYcwq+9MiEzLN2Sc/WBDMUThmDf5hahX/84lE4wAx4u18zQ+BhvVtriuRq qeP9FctxbdUy1A8bihHHWxH1HCJ7ZIe/dm+q/Bs+eNUMqcePwLhTjsKkZafgnFmHWAQpt+88hqnl h+KeD4bh+E9NBd6Vybr9qqi5BNtW348BT5yFw/tdhJfqG/GuqWPKlM/h1FNPxL+uXInVs0a1Dwq7 QnYgbn6yLyhsvL2Pqy0xPteh05XAPoS91zE+XR/Mjte+TtP5wGs/iEtBYuPNLpAP9ra9I/f55Mwn NupMPl6x+3wuPuJ5PwiGNpHaruPtHIzRmLS6zZk2XvCsmXUn5RS8jRUbb3YtgrXxgvHxuLAum3CI 3cUjvmItX2355vfxit3ns3P6euOz6/ikOXRMlC58kldusgrNH5c7yt9RvlzOKDF2XJL7K9czSK60 94tdX5LcaWJYD39XNH8aHh0X9NCBQndg8LHywtgNeP4leaavGe+/8yEGHzsCWPQitmTex/geXrx+ Nw4Yal73GrGaNpvB8MPsIHfI5COB54zhsOEYVXMkjhjZLyLSuMzLbuV5y+w7Ls0Tp2J6f7epptm8 57MBDcY9+Fjz1OYNz2a+imT3S89n3kPqerJR17Fzralh1mQcP3U4ysxnEzW0vC8zw79he+Ylv82b 1+B5MxKPGdlH1ViG0TP64cO7dmFg9ZGZMxwymK+nrcfWdZvheEunit9TrXv9STyCH+LK86di2P4f macsHZitm1A27mT8+I6VqMJKvNPYF5+ddToeWbwVh1XXoKamBiMPir4f9mQNlhQdiJqfXPMX8fRx 70pJjPZF4TUOn2i3S75JnMBQskAdI7rLnryCTkTKA63c7Adh2ik7okTmtXMnzcULCOHpyot1So08 K2VXrjuuNp5LS8bw9ybpOQXnuh/JQ0l+n4zi8cWktUstPHPaWMEz1nXeXPg6KoZ1smYtfbX77FE1 5ttP4RYO8kTlysXHPuRytlzyFTMm6kzsp5w/1yUc5CFHZ/aT9VCyJpdknVq6cMEWOlDoDvQY9imc Ob8//ve435gP9/kVrj/3aaB6Ek6Zuxu3DpUP4fkt1tZU48xzD8qkloEt+wE+RpoP5MmuMnzyF4di w1cW4oYbN6Pn6M9kOO8Zk/0Qn/lfeKJ1oMSw7EtcJY7R5WPHYBhexvUtHySEXubdjNctNx/y8ytc O/R6XPuVFcDYCRh/yg7cMXwBFhz3TEveLFe2JvnZvo7BnxlnhueHMud6Hv3ROO8e/HlNvRlvTeY7 n8QC8yFC86ufxIgbTsURnOWGCQ8w9PwzzJD3iqkpe4YbbzIDrKz6tTh5ZCWeTTh1ctzuO/LzuAxX or/5N272nTBD5aWYuXBNlnNc9lNzX7vnUvQz/v3KJ5pP7/0BPmlqGn3+Tbh54m8wWOzmdsqNjmk1 yxJ+dlwH5MI/av6yH7hcg4KNSVWtK1hstFPnXoZU0bW0dfnrEZvcqId4BXkAACAASURBVFPKX4Ho vHHvk2N27tz5U4Mv+nr66acxbdq0PfLKH4s8+HJxT2nbZW/7iPH50uLJI5K12Ry57nONk1pk6Xit Z71tP8Uni/WLTjyltokuiz7KrDXernGiu/ISIzIXfh2jdc1L3fan3afhESzPa+eJ47Hxek+dklwi XTbaRbrqkRjtE93m8e199gxhCh5XTnLQJ5L10yZ7XYPWfZgkdsHIsvmy1qxddFc9Ymccpdhk2fus tf1PjaFOSQ6RvtzEuPw+nrR2ySFLx0XtNU50WXZ92qbxYo/bC0aWj5u5yEOZjYrn9+F9dtbCvK48 EitLMGl5yBdk9+3A8uXLUVZWlrn16dMnI8vLy9GrVy/07NkTpaWlKCkpyfxuyO9Hc3MzGhsbM7d7 770XM2bM6NTDN5tPV20wl5/lLV8lIsU0y7OMRmpbVJHNdfVoNl9v0lOuTGUZzt2NhrNv9utJskbf z2bsrmuOxTaYHJBPtPXRGHu7OprkDD0zNTXUNaCHqaVHk3lGtsRcTkt9ZgCV96H6luRrNvddFMYX u6e9SVKa3w3ToPo61Jf0hah6NWV6Zo5ozqhXfV0dGkvLzdGtAA3ax/V8/gYrKirmmva9ZG7ydL08 9R4l6ftbC0721EVSF7sMPnKjnTrttjTQ1hjRMyvNvZ59JGKkW0pS35J47de6L6bL2flAzML44O2z 8wHcfvBmvMgon8Z1pO6r32fXtej6ffgkfdCcPt3Hn9bu4/fZffw+vNh1jOhRS2MZa+N1n8XHnhIn HEl4iKdMy6PxPJeujTXQxzxJJGMFq3VfrI1hTp9d87hqpp88PKvGEpNG+upJa0+Tk1idg+fSNsHR zhiX1DHE2zb2yxVPm8bE8fj4fXbmEJnkPkvCozk1Xuyyz3VpLvJoW1L+uH5qHmLt3ui8Pj0JT669 CHGhA4XqQA8zMMunperVwwygtk37bb2HGZTajW/C2X52skPUvocZONtFK1+b2tMaxto8bVq7OszX rnBA7cnhVwZOWY4zZx1tP5Pka0PHaebjhNiPMjNwOuAlBuA6Ypn5MCIX3kERTLl1IO2sRnzUg5k9 v+VWmYlKM3RGJWGxLN6H1X7qjPXFdDk7LxDswlx2l03Hufwum45x6XZM3D4JBzE2F+0iXb6ktqQ8 Np+9J09aO+vnhVguPHbOuD1zuKQdqzG2z95HYaN8ufC4Ymybvdc1aN2Fc9l0jK378D67xLt8SW06 f1SM7bP35ElrZ5xLpuHyYV28tLlitE3rjLGlD6Pt+eiST8fH7W2srtflc9l0jEv3xbjsLpuLU2xR WJfPZSO39vl0F5a2IEMHQgdCB0IHukUHOH9JsZzBtC3NIRifKEZeAluI5StWF+PTfbFSl44pRJ2B I3SgXQfs/+Pfzhk2oQOhA3t9B+TfAN70sLXXHzwcMHRgn+tAM96sXYdt5uWvea+67Xjlqbczr13M mysQhA4UvgO++cm2+2YwG+er0BfvxBdq6NTkulBdjK1rnI7Xuo7R9n1OL/RFkVxckXOfa6Y6cLjI VM1IoKbtF3/H0saxFDtO9uQkZl+SPLvdl67aA/v+6op1S0285drHYt0vdj9zrTfEhQ7smx1oxKoT 78MTa80bEq21acHN+MWCjZbVv9396lP4w6nPZT451o8qrGfTwwswdbz8T7LpeMp8m0tYoQMRHXDN TzJ3id03f2m7Kz4iXTJX2qFTF8QMti2qUI0lTtvISRnlI2afkPleFLma1BGcrjzBtu92oCN+xzqC s7vcQ93x7N2x5rS/D8U8YzFzpe1DwIcOdFoHzHeM/HLgr7F+z3myXUklw8xbIHvz82bbXE3mM1ca 9/zKyTaApfXoLV9Nws+/tZwdtC098B9w1S9vNZ8Ya77rM6zQgfQd4NxFyRmLknYXMzEuX2Jb2vd0 ugpy2XzF2VjB2TYpnvEuX+LDBWDoQOhA6EDoQOhA6EDoQOjA3t2BlRcvw4doxGLz9SgTHrwQR7/x EBbNXp859IGXHY/Z36/KfBBPSX/z0Z4334N/X/SGQZfj2AfPxnHV/EIQgddjxdfvwJtjD8GOq17G TvTDCU+dg388wnz8zXubcfsJd2Pz5pZeHlPVouzCim/8Do8vMl+iecxRmHXvSTikZDvu/vRtaLzq bJz1xYPQvPlZ/Lx6M85963Qc0rQGM8u/jzl1SzFx/xaKBGKI+QqYIU21GJAAGyD7bAc4PyVpAGcs SonxxQvG50uSK4NJ+0xnUuK4A7BwjdPcPrvGBD10IHQgdCB0IHQgdCB0IHRgH+9A9Q8mmy8NKcUJ K87H5Koy9Dp8LGZtvARzXzweO697HK+1vBxVnmn5cFEJvvzi+fjiv5Xi8RMfw/tW75pe3YUNV72J Satn4oRZu/DQXVsMohnPfvduvHnuSbj8rQtNrBlUd2TfG7pl4V14fPsxuGL7HJxY9TJuv2mjeRJ0 IE76zypsmP07PLv+bfxP9WM45NbJZhg1VGVDMef+KzAil49xlS/BCCt0wN+BuPmJ85ePQcfHYX0c XnvaZzq9RBEOOYBdeIceKqKWTnPJe37kZVH28tltXFfd++r32TvqHJJPlqvHueZ0cbpsafmL0Zuk OaJwUT77zGmwOjYuLs5PLsHJyuf+T5qLOX0yF55cYnz5O8Nu1y97Wb77g3hKX81xfl9clF3Xlit/ 0rgoXJTPVb/guXRffXZik0hyaN4kcTbGdyaf3Y7PdZ+U34UTmyw5u8ufa006rqN4dY59Xe/Zv7d5 JrMEFYf3y3yXZf9xh2LTw0/jgSc2mNaUt34FSv0OYPwjn0flIPMFJOcfhweuegRvm4FUf8lJk8Ec /eA5GDukDJuGl6O03nibtuOlO4FP1x5p+HvgyOMPA66Srjdgy1Pm5a5bN+CeH23Du4uAxsuyw2h5 9fE458dbcEfN74BZk3D5SRUtd1MFJp48qUVvL+rX/xGX/r9l6N27Nz7q/RE+2n4EvnfTtzA6lwG1 PXXY7Rsd2HPQaH/utgcS889ee9ceO43dw5mLodBDp+8ALFz8Noa+XOoPMaEDmQ7wYqlQD+4uHpet q7af/eiq9RWyru50vxTy3F2Zi79/Xe2+KVQ9PF+x7gO7bu4pWYe9pz1O8jy5xsfxd1X/vnberno/ FLKu5kbDVrYL91YvxCvHV+MLZ1di7XVr2n3KbFOjfL+9f2WfTMwOjq1PLDZ9hHfNM6mfLG8ZT0tF CuZv+OBVoM/xIzDulAo0f+4o9DrkkD3I+xwiQ3H8Khk8Hhf961CYVJnV2FiKgwp9pR5fRkB03w5E zVRR85ftc3UgCcYV12rL9+W1dgH6sLZPkorfxrhwrQV2RUUeqHjT9dEmMp+lecilJXXm0HjaRPrs 2pcEH8Wj4+N0zSO6LC2pk0fjaWMMfdru04nV/LSRzxdLO2N1nPbZdh/eZyeXLYmnXe9F541+kS6b trv8tk32OiazUT9sPF0uO23kJNYno/D0MZactl38tBFDG2USu2B9Kxd+cunctNnSxU8MfXovum3X Np1T46J08ts8mktj4nQ7F3kp6bf5adf8tFFqDlvXcS5dc9BPm0i9aNc20Wmn1H7bJnsdo7EuO4dC G+ez+/hpJ4+9pz2JlFh90zG0a5voPruNi9qTg1Jjo2ziS7qS8mic1iUP9yL1ctlp03E6JugJOtDY bJ5zNB8HJFNi3Ta8Yt53+bkfHIdRh/Qw791sHR0h7+nc8bJ5KtOsNx9chcZhI3FY38w2+kfZYBxp mJ5YZojN+z5X37gaGCaDZxlGz+iHD+/ahYHVR2JUzZE4ZHD2acmGl1bgju8CX1pxAjBvOe5eYZ4R zax6bF23GR+07LQo6VuJ6ppqVFdnbzU141Chh87dMlW/i4bMQXVk0EMHYjug/zGS2UvPX7bPRZYE 44prtSUdOnVhrcFG0QVou+jaFxWvcTaHL87GFW0vDw7yQM8bH1B89rSF2Tw6Xvvi8mqs1Eq85tO6 D++z69gkus2jY7RPdFnapuv32TWf1qPw5KXUcbYuGFkiqcs+il/7RJfFWJsn40zxQ3MLF/l1Dk1n 430+8uRSp85BHm2z69Q1ULfxtPukr06bh/UIj/bR7uPx5dUc+lxpedLy+/Bi1zXxXNrmqlP7yU0c pc3NMxKfRkos47XUddBOXu0TXZa2aTx17SePT2qsj5924WAOzac5bL/2kYcYkdQ1X5ROPhtj27kX fp2XOv02T5I9Y131ax9zCafPniQfMZrD7pv2Ma+22Xhy2lLH+HhoJ6eOET69J8Zlj+Oxawv7iA70 HYpPn9WIe0YuwJ9eG2j0Utxn9HlffRkDhzXiD/+8ovXrTd782WLMG7gAiy7agc/eNtG8+FY+h9Y8 udgryy86P5e2pBc/6bYPqn9/NHZecbeJvRGP/tmAzAAra+j5Z6Cm5hVcbziF98abzGBqXo675Lha jH/wSxg1+mjMvPsovDz9LqyX95bWr8XJIyvxrGvqzDC6f6y5YSb26z8Rj2A1JvcvxYLa99zAYA0d aOuAPUdxLw+m2QfULJZ22fnsWWT2p8Zoe6TuChIb7dRtKcOq2ETauvyvH9qpi6Quf8/U5a9ZdNps OWbnzp0/Nf6ir6effhrTpk3bIy8fTGyHbY/bMz4ORz+lK058suwHN2IptZ82SpvfZ7dx9j5tnB2v 96LL0nXTxjwufxI889iSvLRzLzKJjRhKxuu91un3SWJd0o6xz51kT15y6b3W6fdJG8s9JePy3ZNH S5tTfLaNe0rG673W6Y+Sgpel+yx7Hw/tlILlsm2yt5edR/td8YL32SXW9mkbfbZkTtp9+6R28lDa cWntEm/HkNPls7Hci7SX7j9xxPj2PrurFnJFSZuPWNuedu/jod2WPv60dps3bp+W34dnnqT+KJzt E27bxr1Ie/H3ihjbX+z98uXLUVZWlrn16dMnI8vLy9GrVy/07NkTpaWlKCkpyZxRam5ubkZjY2Pm du+992LGjBnFLrldvoa6BvTo2zNzYdlQ34CeZfKi1gbsNu/LLC/rgeamZvQw78lsqDPfrVJelnn/ ZzuCuE2T4TIfUltucthLOJtNfyRPWKEDuXYgn7/BioqKb5u8L5qbvPZbnuJ3SXm6XF5jLj77RrtI W5fBlHbqIl03Y261i55ZMuQVaklSvey9+PS/uFrXcdRd8fQFqTrge9CiXUG7lcr67Qdj2l2HER8f 2ImjdOFtmx1r+ztqz7yaP67uOL/mCnpuHYi6X9h/wVDPLYs7qiM43Zk6zipnYA+1Lhlpp+y4Ktpy pelpGmxH1k5u3++Zz864NFLfR13t/GnOEYfl71xnnDFNTtapz5MmXsftK3pPNQxmB045eU+ZLzNL Bk5ZPfvm+Mk8JYbL83LcnDkzFYUfoQMF60Dc/GTPXzbe3scVlhgvz0jmslwJ7EPYex3j03Utdrz2 dRnd9aBQqOKScGuMPBjpva7DtsvetkXhtS9fPSovuTUm7bkE73tg1rzMpSVj43A6Jh+deZhXS+GV vWC0dOUjj8tn29JgGWvHyN62EVso6eIvRl6pn7n1/UFd+0XnfSO6vcgjduJEpl2aR2KL1QdXnXYt LgxtgtV949m1pK5jqCeRSephDUmwrpxp4tJgmcuOkb22iW73SWJ9dvK6JGM0P3H02bnE7sJLnM9O ziTSx++z55JX15nv70OSMxGj89JGGeUTDOvUkrFBhg6EDoQOeDoQNT/pCxDqxNt7Fz0x2sd4bXPq uQ6diROYrCxQx4jusjuL7EpG+cefD4QiZS/LZ9e1+x5gtF3zkJscafJqHl0nuWzpw/vsOl7X77Nr HtH16oxz6fz56PpcSfosuXSM3YuktWgOX159v2h80pxpY9Lcj/qc+dapuajr2n39IZZSx8T1SGNt fu2L42Fukb4+2Pw6Jk7XtWge5qJMw+M7U1IuVy5dp80vvLzR58OzBkpXriQ2zS9czKtjdQ6Nd2F1 HPW0MZJP38ijbbombWdNYqPO/ORJIxmr+RjvyktfvjJt3ii8rxZX/ZpHn1l0WZTk1HjRubQ9CQ/j gkzfgR1r1mHLe/LKweKu5vfexiu12zOvWWyXuekDrH/M/eFB7XBRm7pNeGDxbbjtj0/hvbbPRmqL aHoPtY+tQXinZ1tLgtauA/KPUdT8pec0CWz7x6uNxsa0eRJoaYZOV/IEKVpfUmvH51V4ksQdhZEH Dt50DtpE2ou+JHaN1Vy0a5vwpbXrGF1PoXji+Oln7rR5fXjy2dKFF5ssW9qxek+stokexU+sHcsY +qMkYymJJYdtFz99xEbZbIy9T8LPfJQujiQ8dp12jL0nXuejzlp0jNZdsYwhR5Qk1uYkr23XF5k2 L7m0nTabx8VvY/TexeOykdclaSMvpdhlkS+7i/7JWEqiXRy0URIrUttE1zbuM8aIHzZO70XnzaZw 2X02HSsYvVwx4rft3Gupcbbd9sleluD0svfap3XyJ7XZeDtP3J55bB6xR9mifIwlt0synlJjaBPJ 5bLZPtnHxUTxkC/INB2oxxNT7sMzr5j3bRZ5NWx8Bn84cVXrhxa1pq9/C4un343NKT88qDUedbjh 9MMxt9a8T/WD17HLNXTWv4wJk6vw15xztGULWrftQNs/UHsegXMXpSCS4KMwe2aJsKR5T6cu0kcZ VZjEa7/WfXzBHjoQOlCgDuj/G68vggpEXxSaqMGtKAXkmKS71p3jcXMK6+6/n929/rR3WiHPm+bv o5B505454LtLBz6B/Y8BPuAHzxaz7FLzXlHzVSqZjxmSwZBX2ea9pL3N5+Tm8xFDH787Bdd+83xM rfAcyLzf9HjzX2cc21NRMBe/A2lnNeKjZjJ7fsv5VPxzyJmgJZDFsngfn/ZTZ6wvJthNB7rrkBB3 5xXqXLwQKRSf8BSaM64XHe0vVG86us4o/u56hu5ad9R9EeXL5W+nGD2SHLnUFnVW+opRP3PFybS1 5NKTtDmiak7DlQYblVN8wpXL2eN4g79zOrDp9iW44+I3WpOPz4x49Vjx9TuwoX9fvHnDGzj6wVk4 eMmdeOgG8xG0Zh1969n4wkkHmc/5fA8rvrUYjy8y9mEytg3GOf/7ZVT2bcb62+/G4gxvdpyreWQ2 jh/3CTzzvf/ek0dybn4NS2b9Gpvva0SfWZ/GzGsm4oBMNv7QnP1wwlPn4B+PMMNq/RrMLP8+5tQt xcT9ic3KNQv/BZeufsR8Tct+uPDm1fhW/7tx5OlXZpyn//B+3PGDk803hur1DhZefjZmX2diMAOr dv0W1X2bUHvbNzHhvOuM7XQsXfdbnHaE51ORNFXQ97YOcP6Sc3EG07Y052V8opg0L6+NIvQVq4vx 6b5YyadjovIH3z7eAbl4KOTFiLSzIzj38bspHH8f6UBX/tvpyrV11q/HvtyTffnsnfX71iF5tz5r Bs4dOGX1hbh89Uk4MJMk+57Opld3mYETOLP2fJxQ1RuDTjsJc7Zfgq/dfQReOO85yKtRt9yyFI// eRhmb5mDC349xgyOO/CxsTe89KQZOA1vreF98XMYiEbUN2Z5XTzZs+1CyVmn4mu1J6B00V/wyMpd WXPLzyxnE2a9dQkuuLUvHjprZfbluGVDMef+KzCi/fSYiRp3zv/DD6umYOmL2zD/nDEoH34q1u0y 1z3b7sfSK+fiefn+T7XqX1pmBs6RWNf4d+za9u8Ya2bL+pduMQPnRxnbG/cPx+ln3GZetBvWXtoB 3/xk230zmI3ztckX78QXaujU5LpQXYyta5yO17qO0faghw6EDoQOhA6EDoQOhA6EDoQOYNuqV4BT jsHYIea7N4cMxxHDsl9SKK2p32Ge0XzwVGPrh3LzEtTK8X2xcckKPHLXZuCYXua5yQZseXgXBn5v Agab79jsP2EE+rT09N0XzDOnwjvM8A4ahspWXhePCZKBdFgVTv/iMBww7GhMm1uKDU9ua2HLip2v vm2UXVjx02VYfqvh3/xxywcPVWDiyZMw2PUaxLLBOGBAPxx06CD0LSvBkHFj8dHTi7Hg+j8YruF7 vKS27KAxmIIbccaca7D2I/O9qwb19ivPm5+v4jc/uRo/u9U827n6/cwXORpjWHtfB1zzk8xdYvfN X9ruis+7S2mHTl0Qk9u2qEI1ljhtIydllI+YIEMHQgdCB0IHQgdCB0IHQgf20Q7sfs08m3hY74j3 TLZ8ku07L+OXQ3+Lv9ZVYNSnBgM7xP431G8FSnvyHZfNZgzNruY683LbPiWtvE1mTs0sJ4/xZF6B 22x9ei15s6G73zTPLx4zDEefMhYT5pyCLz0ywbzbM25lPzkoW9c7uGZ8OWbc8wFqTvwsqswA22iH V9TgwW2r8S8DnsDEw/vhtpfqsevNjcCUk/H5U0/FOf+6EitXn43w4lq7cXv1nnMXJWcsStpdTSDG 5UtsSzt0ugpy2XzF2VjB2TYpnvEuX+LDdRSQ7wHpKH7hLUaONPX76vHZyR3nt3FJ8ILhjfG2JA9x Wmos7domOuNtu2/v4/HhXfa0OV0cwRY6EDoQOhA6EDqwr3Vg8LHmKcgbnsUmM8/tful5rDLDoesJ w92vv4YPcQS+eP7RGLi/GeQyQ2QZhn+lHG/OfhSvrN+KFRffkxniZFQcPOFw4M7HsKLWfBXK7X+A PFdYZkZQN09L1zfvxLvyutWmt/H4vEaMPfmQFkdWHDL5SOA5k/iw4RhVcySOGNmvxV+PresSfK1K 3Qbcuhq49srzUXNwT6zGu+34ZdNUtxXbysbhoh//FvPMfv37uzHys9OBRx4weatRU1ODCSPNe1nD 2ts6wPkpybk4Y1FKjC9eY5JwOzFph04nicOoi3MdgDaN0zQ+u8bstXp3Gj7k/TDFXNIbvgdHZJJe abyuVXPZdr2P0308cXHBHzoQOhA6EDoQOhA6kH8HysdOwPhTduCO4Quw4LhnWgizzzDK8MnnKstH jsEwrMevBi7A7++UJyZfwKKFm1H51bNx7EXv4Q81S/H6iCMy8fIcaM9xk3DmLyrxlxN/h0f+eiBk fKw3z2P6eNAoOd/AraaOeQf/DttnfQafHcc3aZZkBuGeoz+DM+f3xz1jDMbUMf8LT2SfWa1fi5NH VuLZuK886TsWcy+swgnmQ4X2m70UM6pWY+LMhS3vz+yX+eTc3a/dg0P7yf+g74e5Vd/B9LEVKBtt PlDo5vGYPDj7P+5LT/nv7HtJM6cNP/aSDsTNT3EX7To+Dpu6ZZqcwWKjnbotZVgVm0hbl7842rUu f/ey1zexCVZekCB2YijH7Ny586fGXvT19NNPY9q0aXvktYccPXRpH+0cSOijncS2XeM1Vtsllj7a NR99tNmSOcWusT674Ow8tInUHNouuizbn7Vmf+qc2i4x2kcOuw6913jhYozmJd6H1X5fvOb28QhG +8il+ZPyCC6s0IHQgdCB0IHQgY7uwPLly1FWZt4DaG59/j97bwNeVXXljf+oSUjAgAFFReVDBAFL sMnbN4wKNfGjiq2krVZHgiPtCE5tVebxLWM7Os/IjFbrMyKd9gWsA48FWiv6Fz+q2CptxYovNQpU wEpEKOAHikC0uZCk/ve69/6SlZ29zz3n5uYDOJvnZq+91m/91trr3nDvyjn3nL59k3NRURF69+6N goIC5OfnIy8vL/n+Ju9nzc3NaGxsTD6efPJJ1NTUdHaKgfwH6829OYvN9y8DUeb0WQMrMN/fRCKB g3nm2GXDfnNBob7oX2yOYm5eYxrXLZj6bg1ONi3mno/MRWOPM41j/XY8OPwxDFl9Hc4dLRHa8xTk yam1R5l/B9FgjnYWFQdkYmI3NH4mGBOwj4Txl+dJ2uD6RF7yu55t4E1G39CI4mLrJNpEPeob842e zXAbr3jRzRXoyO9gSUnJbJP+ZvOQv5nIOdmZ5r+lMYKTB9cy27I0odRTltn1MOoWvcjJIc1dLocE dg02sUxMY2jTuh4rS/PAxkEnaev02idrf8psTrjWs4tH56Pt2k/LNoZrzsTaa+r1zNhaZ/vJOmhw v/SzZ/pSz7U923ZZ20NjmDvjE2uvqffNPh4dS3z12iX7eHxxY31cgbgCcQXiCsQViCvQtgIFoRop cx9N9lumaZO28ODb6zG/sjZNlo/yx67EyfIJOfE+/r8xj+GDtOXEO76IicmGUxTteUQnR1BMS2ua yaTg/2FiFzEPP8prSTWcYi6UPrv9MM20s7EsLHbj2zPEmkOvAu0//Lbuwe7RNNa2tXq1SmEwrWiH 1NGm004g0wbEbmNsDkeah7YqqJEJstm79mGjNCzECrfIPk47dnevmafOvztyYh4diZ0Ljo7Ej33j CsQViCsQVyCuQFyB1goUjDsHsz84p1VBqXAIvmlurxKPuAKHQQWC+i/b5tquYNizcXbhvDo5tTXM 8JHrJG0ebQvy1zibw+dn4+J1hApI09PdzRvTlaN+8pBhz8TYM/OP0rzpo4s2X09esz567sn5xrnF FYgrEFcgrkBcgbgCuatA/bYNqDUXOKqrrU1eKClb5qaP6vBy7bYj6jYp9btM7Tab86OP3GH3UVzL B2/df1EvlfLpdRU1RusD5bBNZ1bkKjL99aa0rKBtRPq1UfakBRulbHNiM5Gtv/gJR9gmUucb1ifb 3HQsHwcbRz1T1j4uLu5b40R2YW1Mtmvh7kx+5sUYUgv7QUw8xxWIKxBXIK5AXIG4Al1TgYObVycv /CMX/2n7WIw6uVptJ42ND5Zi+iN/xFPTy3HHPV9Hr1nPpCPVY0FVL0xbJl/hM6OpDjN7VaPWk0vD 1mWYUP5Q+oJDKRfnz0QtpvSagtpMFzRyOneWsh6Lq3th1jO72gR4YU5Vcv+1d5ei1908PboV8uaS UpQ/bO7heuQOu4+Stav/snGsmE9Pe6Q5bNMZhtTehL0WDp28ll38Ln8Xrst10gSw+WCDpHVio16S I9bWuxInVvsRR5vm0TJzIN41E0Mu5unTaw7xcQ2t1zzkdvlkSDpaLgAAIABJREFU0mkevUfxs3MX ncZ3JC65dRyRow6dj52/j0v7dGQPPv5YH1cgrkBcgbgCcQXiCkgFDuI3ZfPwZK25olDIIVednbV1 Bma9ex2+Mttc/3LmeUn5hq1XYVim729aMQ5ueM40rs+13A/UMrdZnjCmBgMNMjGwEpd8cTIw9/dI tl6Jt7F6FbBk7Z+TRy+btr2AhaUXY6Qvl/z+QGn/1D1B5RIzAWO/ufcn71UaAOtCUzEqa2Zg7uwn VNNchyW3rcLUC0ZjVM2j2HbN2Hb59OlfidLeyZuntrMdxopM/ZP9Yd7G2+tMpQqNz7bpdAWwN2Gv tY9P1huz/bWt22VpCuzGgLqwetkEfbghrvXssmkdZZnt2NpG2cVNX9qI5RxFr7EiZxrEcCaePD49 cZyJl7XLhzjONoZ+5OFMPO167dNRb3PYMV1rW2fHi9dxBeIKxBWIKxBXIK5A2wrseOKpliOQD/zo 9VTTlNiKB69enb41SAKrr74fv9mQwI6fP5G8l+frFy7EAwu3GqJm1P38kbT/YvyxLtWM7lj8CP77 n1ZggTm6+V8/3A65UFFBXgF6F+Yh/5g+SVmuUHuUy7/pAzxmGtuHn3gvmWjz9lfxX8euwDsf78Ij la8b3eu499glqaOkiQ2YZo4urnEcXTzpvO/jnks/j0vvuQd/V1aOKbgT63cb950bsESY566DnEC6 7YXHUPnNsyA95+7aZahKn5k15/E6QZnRG1j/NG6ZNh698nuhatYy7M7QfNZvXoyq6u/h7llVyT/4 z1z8Al5eNiv1x//qeanm1xxhnWOOuKb+aF+NZ7alate0+2XMGp/Sjzfz+JnL0g3jbixL8/Wquhvp UmP3yyZWOufqBRtSKaufQ8+rQen667BW9m5G/YanTJN9H84+Dtjx2x/jP3/zdlL/0YZlGJ/mGXPd KgxMX2SpaXdtSz7Vc55paV7rNy9HdRrfa9o8pNNH7eL0Po1twQbP4eNkxB73I6h/0h/KKRNvr10b I0bb6K91TjnbpjN0ABOVCWofkV16Z5KxMq5AT6lA2KOWPSXfOI+4AnEF4grEFYgrcLhX4GDdaiyd vguTa2fg5jer0effn8MjK801Zxub0fCnT5L3gpAafPynBiSM7uTLv4DTzfrUpZfhqquH4ODml7D8 O024+t0bcO3SYjx3+Zpko9p8sB6fPLwNZzx7FWZcN6SljHav5vTPOxZf/Gkp3pr+EF6tew+/LnsB Jy6dhBOPHowv/nKE4RqBqZsuSx0lLTwZ1z99M051XIU2r2Q0ykYPxeiyMhxXOBLVlcDvN+/Gtld/ h5r75qMGq7C5vh4vP7YCV1QOM6fZbsa15VPxj1sa8OnOFbhtyrVoPaC7AkWXL8H7bz+HfnOnYv5L 6Q6uZWeW0HgAq1bcibrP34ed6x/GwumTMGHt2dj5/nrMWHEjnthsmrGmIlx4z9vmj/2N+P3tK3Dx Q+sMSQJLrpiA56c+h/2fNmDht6Zg/ZrUNYA3L74WUz/4FhoN/unxs/HVhXJabAJP3TIdI1cIz37c //WRViJmWfJ5zJ4CzPt16nTitf9zI2pmX5Jssv+6+zW8tGOvAW3D7aVTMfX3b6Ox4W3MN/jUkHzK 8cGtWwz/2xh+28VYJOchm1p9a8zlOOs5E7dxDx4+9kYMu+UZNJlTjG+ePhcr3jY13P8+vj6yiESH 8ix9V1D/pfs02Sf7NL1nG6NtGeUoTacreMYABsAEbX/qw3AcsphcHbXKFc8hW8geknj8PPSQJyJO I65AXIG4AnEF4gqkK/DOc1uAyWdi7BBzz82SIZh4RxG2r5UmREbrjRpapLyjcbTpIYuOG2BuW3IU 9r4pRyP3Y/UPnsLKpTuB7QeSjWrTgUbkz/4yzik7Fkebe3j6hs+/qOxcXHnHADxb8RDWXT0RX/ti SZKiSO77aW51MtDMKdYSTLhoIga1JOiLVIjyK6bgqd++hBdffA8XX/JlnFe5Ci+9+CJ+t6IGZ40p RtO2P2GFcf/dAz/EnB8+bKQPzX1UzWQaSJTOx22XjsNxQ6tw212lWP7SW75Aab3xwX2476pxGDzy VFSaf6/ceRkGHzcSZaXAvn2m/S4cjPEn7MfyxQ9gyXKgstCcztq0Ey+tAm69YpJpCgsx/qwqc5RV KBP400smu52/xp1z7sTSuUa9T5IrxBjTTS+ccinuXr4RhSWO7ttgLrjhFqyY+qw5SrkNi+aa77pe IM07R4HZ+1rMxQx8beJQ5BUOxVkXV+JDOfBq8lln8tn56wcwZ85cgzG5NzahftOz5mixwVcNNS+T Enxp5nxz5Hg96guHJ5v7KZfeiOUb/4oSc2T7EBl2r6XTZt/FWWxh8EEYzZ9RjtJ06iR9xEGJib+2 a9nHF+vjCsQViCsQVyCuQFyBuAJxBeIK+CtgmkMc2zvdwKXucp9vziZNDR6XdHzkNUc9ZTS8Y456 nTkEZ0wei/LrJ+Mrq8pT331MEWT8Gca/74nmdNyMTJkBI8+qxvrbpmDq3ONRNmIwSqunYPbFF2Ph jCkYaXqjhn3yjc8puGDKJbjwym9jzZolGCUH6kwvCByAtHitI6lsXXok7ZNsYA2LtKPCufuFu1F0 Ug0+HnImvmB6y+Ro+iv+aoSCfDZr0vnJaMSHb5rGtPICXHLJhfj2mjVYf/WopKXihmfN2b/fwh8u n4B+05aZ9rT9OO6svzc7ewD/d8FcLKn8Fj5vTq3Vo+FD2fvJ6JdWtuyuaR+2Gl3lBRfjkguvNDVZ g6tHmRORkxsbqJ5r2ZU0vCW44dn38fS3BuLyCcNaL9aU5u3BU9RejfignoyYDm/b8RuYFSeTzZSY tlOmb1aBY6e4AnEF4grEFYgrEFcgrkBcgSO3AoPOPhV4cBN2JDuVj7BpfgP6n5y6os4n29/C9o+a 8f7KXye/x8k2qGm7adA+STWdJ046DXjNKE4ZjlEVp2HESLYt4Wrq85cr3v7ie8BXVp8H3LUSj63e nyI0R9nM4Td1sZ4Edm3ZDsdXOtslUDiy3JxSa0ZlGYaZ6ZTPnSUrzLjgc8l2qXhspWnMVuCtg6eg oqICFeUjUcRNr9+KnfL1RPM9zAWz1+ObF49M+nbkx7sbnwFuuhfXVJXjaNNpJo8sFg7DOZWm9f3h ctTVvYwbS2ebfOWvAMX4wtVTsGr5LpxSZnIz+Y08Xp6nJuza9j7GXTQTv3jlLnN1pB3p7+FamRWO wXW3ALOvm4ubbrooeWqtRhSPrEApbsNTG8y3XOs340F+p7NwbPLI5SrTk5ZJTSrKcbwpSvHIc8yx 2zvxWzlN2Iy1zz5mkh6MoiZzLPX9Qlw08w68Yo4IL6nbp8Ok5SbsrqvDR+nuOLF7G7btTvGg6SOz 79099fY07L9kH+zBtM6xV6+K/l6ANuSq6fQlq5PxyT5fyVP76LxjOa5AXIG4AnEF4grEFYgrEFcg rgCKyiZi8uwGLD1ZbmfyM2ysKMNlf3+86XEGYuykRjwx8sdYtOBjHJOslZzQWojP/ugkvPX1xViw 0FwgyFyZ9rJ7BuCJManbodzzpT8kG0Lp1QocZ3raeqe/uZDQI+fUYvyzX8Go0Wdg2mOn443qR5MX DioaOwZD8Abmt1xIaCMuGjkUr4bqOlMNXWX155NN5nEjSk2jBVzy+aHJ3aFwHO5/ZRGWThqUurhP /pXYKL1QozR9czGmn7m4T/5pWHPTw5g+LtWYpxzb/izgsrTlkLHR9EsdMDWSaAvNqcvDzvpHQ3ue iZWPh007vH52ORZvAL750Cu4ZescnHbanRhxl2mTPzyQbMJGX3M/Fk14AIPSF++ZvFDOu23Aszee lMy3qHw2blp6sTnW6Bp5OPuybxlDJb5qTqHlkCOaA5M97Xjce18NppcOQK9+Y/CU0af+fFCImofW YPyNk1I1Mbku3Gga0+IyLHruLkwd0y+pn3TjeKy5vxqFTW/ixpNSuvLZA7G0OnU0lvFScwMWnXYa 7hceMzYuGoZh8zcm5fpNPzP7XtRysaKksmt/+PonW+/rwWycL3ufvxPvAouOesr2LM2q6GS2ZVnL b7Q9i04/xC6vE9HJ769rHrN3794fGFuXj7Vr1+L888+PHLezLzTTUX7xl9HR7yb68vDpdSF1DmHw 2pdyWL8gXJCNcfQseI6O1o88YWdXri4d+YJsxORyznW8KHxRsEF7zhWPL4bwc7heP50dn7H1nCmm tmuZHC4dbUGzy090HLo+QfowOHLKzLictU3LHbVrLpHJx9m2c53JTlzYmXycfX6Z7D4/0YuvDHku OsKTJEn/yBWP5sylHDY/4jgzB1nL0K9fWUfVi49r2PFcGJ9u5cqVKCwsTD769u2bnIuKitC7d28U FBQgPz8feXl5yVwlTnNzs/m+YGPy8eSTT6KmJnkMzkff6frmxMFks1hU2NIymZjmYkL1jSgyV561 R3N9As1FckXatCWRQEPjZwxW+9teAetI/pJXc/axAtJImRKoT+67OP2t1ibT9OWZf6I3/ZajHhkp fYCmhGE1rxtTx4SpaZ7hbti1Cxg0GMVGt3nZNIz56cVoeP6qZKMsNAmTRGN+EYrV9yVTumKj8wUK p29K1Js21s1Tb+LmF5lvmvI5F0qTf32D+Y6vCdyqbjI5GmWxfCu160ZHfgdLSkr+xWS6yTzkEL4c TteznEz8N/PgLDb9ELw0m6ITnDy0LDbqKcvsehh1i17k5JDGL8oQYnvYutZPDjYylQC1xNn+tMsc ZNO4HiPbbyK5TIxvSB3hlPz44aAjPNn68s2wo3XqqH/U/HXe3VG/qPuNio9ajxgfrQKZXj+5+N2O llEK3R2vE9deffXJpLe5ZD/ysPXZ1CbIpzvqFpRPd9n089NdORxqcX01i6o/1PbdVfkeZZrNtg2n RD7K2XAmLabJaGk4RWEa7qwbzsj+kleWza3EyjgKTb/EhlPA0nDKEH2O26i8VMOZZE83bm8/Oxv9 zK1Z5LU95q4++P2Sr7Zp3gpNbrrhTPm6G0WxRRl5hX4eqUmbhlOITf5Sk9aGM6mE5JjjSkXZRq6x 7Ls4s8fiTL0rLjEuW2hd2/pmdnMl5NL5krOxgrN1kgX9XbbMWXYyQn6BOPSHD+pdOuJlpp14rSOO No0VmXqN03obb+O4jjLbMRlDOGjTuiC9L66Lhzrx0fzUa52OyRjabvtwzVljNZet1zbG0TrihVdk Fz914ke85vDpXVhyuWxa5+MPylP7aC7GFLsMl82l82FtvaztwTyp55q5cA4TVzhsPNecM/EITjAu vItf83EPnG0u+rv4ibV99VpkxgvCZ8qdnDITy5n8xITVC07vi/56JpfWiezT02bnpP21L2WZXblo HmIz6XQsLdOfOXLuSFzy65yo49xZcYNiMrbMjK/x1BFHm9ZTRwy5tF7jxS426myZ/jLLII/gKYue az1rPDEyu4aOL3autezSMQfaOGfSMwcbT71rJlZs5HfhYl1cgVxVYNw1P8On5hGPLq0A+6cwQdnM cBYfn79gfLYwsZKYqEc6wxJn2gAT1zjN7dNrTLfI8h+3/IfNR6b/yInjf/Kcg3hcG6Ofy6a5mI/g KdPu8s2ko6/w2TloG2MJn0/vi+XCa53ei3DYeYjOxouOQ9tElkEOmSkTHzSTKwhDG7HCz7haF0Yv XK78qJOZMuPaa9H74to25kkue7Z5tF3byKN1klcmveYLI3OvMlMWP19cHyd9o/DoGNyXj1/r6Sc6 LWuMtklO5NdykK/N5Vpzz9pGTrsOxNp6X56aU8vk0TotM77WiWzrhYc6zraPXuu8mYPm0Hb6kZc4 6unPddCseelHPtqoJ48rrtbZePrpmdyiI17mIB5tE1mG1tE/aQj4oX18PHTXWBc/7T489dwj8a61 i5/+etYcIsvQOnJrH1sWDHF6dsniG1Vvx8u0tvPnvjL5HfL2pk9QtzrDxXmaPkbdC27Mng1bsMNc gOiwHXJKqTnVNJGQsyqDx0dbalG7PfWFUy0He8XWbqhApv6J/ZcvNe2fCevj8Oo7q+nUAWUDduKd uikdPNeyvDnIf9j8T5tvFpni8D99jSMPubRNeMNy+3Cid8XVcToiB8WNwuvjCapPLviDOCQnO6+g Wrrwtn+meNyv4KL4BvGGsQXFcu3Lx+niEV137YtxZbZHlH3Zvly79qttLrvkYuuZp/jqXG2c5nbx iF18XH6alzy5ml3xyO3Lh3Y9+/bk0ws3bZ2xv6B96bxzLfekuKwx6xsmtzAYX820L59bH9al1/4u exhdNhzik41fmHyCMFHiSj35COI8rGwN72B59WPYLhfRaTMSeGbgPDxZa5qoxLspTLsL+CTwh8pf 4Y9/Tl+atI1/jheJWlT3qkatynPDvGpUzVuNxdNanzc+fzJXz6vFhsXTzHM6rY1f/YbFyed5wQYh q8eCql6Yp4mTqdfj+XkzzcWEitCvXz8UFeWjV9WCwIvebH20HOWL/5T01nK2lfi49m6T532hrtab bYwj1M/ut+wy6A9EUbA2T1brqKfXZgri2wA3KXYbQ1sm7h5j55uL/OJTDkrOhwvjG8TbEZvElrxk dEUe2cTqiryi1LCz8yG/7/USJdeehO2ufTFuT6mF63nVObrsPSX3rshD10LH8+lZL3sWX/ERvS3L mnrOSVAn/dAxKHPupJBJWh2DMueocVl/8dey8HAdlTMMns9hZ8YIk0c2GF1ryrp+2XB21OdQrOPj jz+O9evlyqbtx6WXXorSUrlma8DIPwp9zR0Ye8s9KtuMfPzv//d1HHXS0UZ7FPoYjFzJsu34DI4+ E/i45UaPba25Xu3H/tQtI9PEjWb9YaIPau5vwNfuz0N+/UuYPOjb+NedL2PSgEY05RXhzQeksVyB 5WvvQlnV4KTna4/dm5wPJG/JkocDH5q+Onk9mTSxmTabZvW8G/fj6S37cdEIc/XaxEfY/OaelqvS tiKV1PtcjONdRrWsIIFi0wZU5dfgnoZ1KDNfkiwcVYNN24ogz0A8clqBoJ4qqP+yba6kwmBcfi26 jh7ptBPQm7VtElTsNsaFa0mwpwl8A5G8+KYYlGPYNxrNK3yytnVBcVw2xnbx0Ga/EYnehWdOrjhh dBInTL18XL6cXPgoWPrbPrK2dcS65qh4m0PHyqZO2t/m7sg6aF9hYmpMNvty5a45bbvPZutlbes0 V5BN43yyzS9r2X8uBrlcOdpxWXM9h83BxU/fIBsxMtv5aFtHZOENqiftxLhm6phH2D0R75rt/TKG ninTP2pcF76z4upYkjfXIus19xJmJocLa9uCYthYF18YXVQeF150Wi95y9Az5TA5hcXYcaP4hcV2 J+7cc8/FZz7T/mNqnz598NnPfrZdajueWGlul5K65cmChVuT9nxzDdMN9z6S0p//FN5JHrhsxMZ7 nsaGt9sfxdz28zT22Pl4+TW59I60owms/qfFePD7KduTtZ9gX+0a/Hc61mNPvJfKJbEdD56/BM/8 yI4nFBswrdcUrGl3RDXlKj/NgceW0Sd9l5I8c2EjudhOYXFfYxuIvnKxG3ORnEJzBWFzWdUk/s5F vzUZmtG0GUtuczfpSWDyxy48OH0FZqxYlGo4RVdYgtHjRqQumFO/AXPM0dHUa2smnt/WvkatXMDu 2mWoSr/+5zxe12La/LgcyUzxVC94Ccuvr8EqrEd5US8sMEdem3Y8i9n/+XT6SOdHeHxOdRo/HvOe 35bkqd+8GFXV38O871UlbVVznkntsyVKLESsQFD/Zdtc1GEwLr8WXfvf5hZTG8H3aUkn0MbBLLQt yF/jbA6fn43rsjXfBPnL5HojEZsexHIWWxgeF4foNI9ei575aJmxNF9Ymb6aj77Mw2UjJttZx/Xx i55D40UOM6L4aKwvHzum4PhgTj4en15z6v2KXvuQ34fX2LD5ay7KmseOyb1qfo0Po2ccmQXPoXns uC6b1um45HPN2ocxtM7mkTUfxLt4qSOWM/W+mTiZya9l5ubzD6sXTg5y6jhhbMRkmoWX8bSs4+rY Pr2OQ4zMUQd9dUxyMD+XTTCiz3ZEjRuEj5JDEI9rvxrvq4MdPxOPcHKE4SdGfCjbuchaBufkwvzQ eO2j9SJnGlHxmfi6wq5rofPXdeiKPDoSQ079LC8vb0dRXV3drhk9WLcGS6e/gfLHrsKsHd/E5V85 scXvjZcGYvqmy3Dqa3V4ed0nSf3Ha+qx96/Wdxl3vYpffGcPJq+fgVnrv5i+p2fqO51Nb+7HOwuA y2qvwXlj9+EXF/4/nPnydZi9fiLemP446pK9mbkFymt7sG5V+3goPBnXP30zTvVcCrWfacluv34W Zs0yj+/Nwn/+ZBUGerDcWOOBPrh96SKULvkp1pn4iVcex5oZ83HXFGmTPaP+Xawxpi+cYe5h2m4k sGxaKZZf9Bz2f9qI9Q/3wXnDbse2dri0wjS515ZPxT9uacCnO1fgtinXolbyqFuGMVNmY/7v30ZD wx785KufxZf+7V5zL9FSrNj0Pv6htBhNf92HxxfuTh7drVt2A6YsPwtvNzRiz/pbceN5w/D4LvPc NB7AqhV34vmhd2LnlhVYddtsrFOnIPvSivVtKmD/B8e1/Kep38SoF2efXhNrjNYHymFPr82KXEWm v96UlhW0jUi/NsruXgS9Sdk2e61zj2KLgpUYNt5e6zy07MKF1WUT1+bWay3rHF1xwupsTnvNOC69 S6fx+k3el082+mx8XLmG0dkYe23nQjtnsdvDZ/Ppxd9l0zoth8G7crKfr6g8dg46hm2z1xpL2cbY a1d+NkbW9r6I4cx4Lj5bZ/vkep0pFzsf4jPlQZye6cOZNnstepeO+CC7+IWtvyuGS8e4mWzdEZe5 cc6Uowvn8rF1eq1lFx91nF14sWk9Zc4uX23Tss1l+4bB+jiC9LTZzzv1Muth56FtPVmeOHEiXnvt teR9QCXP/v37Y9iwYe1Sfue5zUZ3Bs4+59jkSaADpGEzDZC5Oye+suxcDCo8iJIhRhVwuuz7r/wZ mHwmxg4uNMc3h2OE4NOREnsM+7OXGF0hmuvewF6jf+t/fo0PGj4yUhOa5c6HhtsfrwQTLpqYZnNP VZd8GZ8rMbaCfGz8cC4ecsNatYn30H/0RMyqnI4Va7fhk0eXYuo3HsWgW4D3W1FOqSB5pNQyJTbi lyuAW++bZI6h5mFc9TdQiRq8W3+H89Tbpm1/Mif3Asc/8EPUNZja4UPzPAFv/uaXRr4PV00cmjx6 asppCnmMOU47ECcPOy55uxKetpxvvkn6m7uWoObWLRgq9zEZ9yXMN2dNr/tLPSr7HEjy/GxmBYrN 914rjX88IlfA7qNk7eq/bBwD+fC0R5rDNp1hSO1N2Gvh0JvSsovf5e/CxbpOroB+U+vJb1zdmafE 7sm16eSXyCFHf7g+X4frvjrzBZbL/zei1D9q3CB8Z8btzNpnwx1Uh2z4DmWfKM/7obpPOZW2oqIC q1evTm7BdZRTDAXF8nHWOnKZ9DA/pCEs/JvPShQa3t4PnNLH8f1OQlJHPQ/uMzj0w6hLx2IAmjH2 igIMllNjGT5kPLLKvN+0VOdcWJX8vqOsj3m5Ej9hxysKz0jkD8JlN83A9EnTcScmYMu9J+EF8z1O 7yjqj/HG+OK6nbhs6NB2MNmZ6XlDjYZ9uwxuCi6YcglOwYW48Mo+GGXqsMfc27K1XW9LJU2pfeNL aS2PPVqdW2zW6bOL2zrHq7AVyNQ/2f2XjbfXmeKGxoc9vdYO6Apgb8Jeax+frOPY/toWy+kKRG10 5E0q6huVxOCjo4UXHubQUS7bnznK3NXDjmmvuzqfOF5wBTr6/HTUPzi7tkdhMmG1vbPz0rF6osz/ W6LUQbB8dHRPnRmXObpiuHS+vQTx+Hx8euFizX2YXOtzmX+uc+tqvijPe1fnlst40nQWmu82nnDC CTjllFOc1IPOPt3o38K6zXL6bDP27U6dRusEe5SDzjaHNhe8im3mFM6Gzevwynb5Tmf7UTR2pDn1 dj8+aByIURWnYVT5CShwAdu4JrBri/vWLIQlG7L0QnqzMOPAX/MxeOIVBroKuOUKjDCSNHEc0rwd +KTBNMRN5tYockmhEZh2XyXmTpmOx+vkKK0ZTR+h9oUNqC8ciSvMUcaHf7slqd790tOGdQL6t+0H kzb5UTy20rScK/DWwVOSfxioKB+JIlOHoWeb83uxFCs3p44C795tZrO5D82/g2zMW1lwzjdNPkt/ m7p67u61eMh8LfXkYz1BW/xiIaACQf2T/oBMmXh77QpBjLbRX+uccrZNZ+gAJioT1D4iu/TOJGNl 7irAN+zcMUZn6gk5RM869ogrEFegp1cg/r+l65+huOZdX/MjLWJRUREmTZqEKVOkmXGPo4Z8Hpfd MwC/O+cBc9GgH2P+3681lxCSkd9y5DJvQKuv9Ih5LS1lSioaW47xk/fgF8PnYd45f0yDU9e1TeFT MgqH4Mpny/Dn6sWpCxSdsAzmbND0cMeDOXX1opFD8WrAhYTIILMcbGz/nc5+7U5z7S27LDkLr6x4 GGu+fZbxSrWr5nJDQoPew4HbJp1kbo+Sb26NUoTLflKLshsewYrb+2HKaQNSfzTKH4DyhRsMuhj/ 8PhzqJ86JqkfNGkpFr3yHxhtqJL5pA8/tsiF43D/K4uwdNKgNM+V2GjqkDf0MryyaAIuHyP8+Rh0 xS9RXzwWs2esN1feNRcSSt7OxYQblyIs+9Yi3Fc/Ff3koMigSRi56BVcNSL9hdbSdFAD72ce8ehQ BaTvCuq/dJ8mgdin6aA2Rtsyyi5n0VFPmWtpUkXWsy3Lb6Xo5EGZs/wWiMwH1755zN69e39g8F0+ 1q5di/PPP7/L48YB4wrEFYgrEFcgrkBcgbgC3VGBlStXJo8qypHFvn37JmVpVnr37o2CggLkm+Yl z3wfkEe4m5ubk9+3bDRHsp588knU1NR0R9otMZvN0bx2UDqBAAAgAElEQVSD5uNnUWFBiy6qcLDe nNdqrhKbmeEgGur/Zk7tle+AHnqjqf4j1Jsjj3l5xShOnp7MPZijovWmmTWnyaZbPxo8cwL19ebb rAYvH+Y5mhL1piXON6VsZUmY2ubJFXgJUrMciZVzbxVcWY8csSO/gyUlJbNNpTabh5wLLseVg2ba /pbGyZqyzJRFLw2oPKinTL09G2iLj8jJ4XreabNnNp62Xq8lqG+Iv7Zr2ecT6+MKxBWIKxBXIK5A XIG4AnEF4gpkrMBRpmPp6ImZ0kSGGwWm0QqH7ImovOISyHWL2g+5RUuUjZnbujhqJrd2sVkKHTjG lz90xKPDFYjaqxEf1JPZ/VvWScrRyFwMJsvkfZzaTpm+Pp8eqedf+XRyoosyyBHVL0oMH9YV06Wj f5CNmFzOuY4XhS8KNmjPPY1HcvXl5NMH7S+KLSq/4G0fex0lvo2NymXj7XVYfp+fS+/S2XEyrTNx ZGvP5Jcpr1zZs80jW79Mebt4RceH9qfO9nHpqdP+WiYHZ23Tckftmktk8nG27VxnshPnmsWX/pxd uI7oDjXejuw19o0rEFfgiK+AblbYg2ldlALRP5RPrppOX7I6GZ/s85UNaJ9QG+oKkLxBdfR7LJpD uDrrTc9XD4kZZUTFR+GOsd1fgZ70/Orfjc6qTNT99jR8ruoSdV+5ipsrnp6Uv+v/cP1allyJiaoX X+2fq/rZPD2pnpKbrpOda09f87nu6Xke8fmZUzo/rj94xJVh14aXsfmjdlf1aalD00dbsKZ2e8sF eVsMsXCoVMD3Id/W+3owG+fbt8/fic9V06nJdaI6GVvWOO2vZe2j9d0m841EZsqSDGVbz0R9eu1L LHXk5Jqz1mtdVL34ctBXZsraZuvERqy2UaaNHJxdeuo4EytzkE5sehBr6zWGso3hWs+UtY/obL3Y bT0xtl5jiaFOZg7a9EyZGN8sOP3w4agnlmvO1HMWvcicKScV6R8aq/UumVjNQ5k2+vn02k6M6LRs r21um8Pla+tsH64Zy4fXOMqufOhv26jXvpRltvG0ufQuneZwxXL5UKfxlGljHpxtPdd6JtY3E6vt opPhs4XVk4fcrrXWiZypYdN48jJXvabsw9NOX+Jcs+j48PlR78LRZs8aK7IMPdNOHf2p55p+1Nt4 jdMy8S6d5tA4LdtxO8KjucgjsVyvB+bmyoW+5NPrWO6cCuxZ/RzuOnkhfjx8Pv7r+6+mLzyUIZa5 X2R1r2rUtlw4CNgwrxpV81Zj8bTW3zc+xzJXz6vFhsXTzO/ItDZ+9RsWJ39vUhfWqceCql6Yp4lN Kinu2takHPFbjWGleiwpnYCH/yybqG+Xt+SQ2LoMf1f+i9QVZcPSxrieVIG2H5BTmUnfJXpf/6X1 Lv8O7y/KdzolGBPWgW1dUKKuDWmd5mU8W9eta/612X5D8ekzJSv/IdE3LFZw2k/nkkkvvq541Gku wcqgLbVK/WQc6vTaJxOrZ40Vvaw5tI0yZxvj0xMXduZe7TpE5Y/Ko/E6ltaH2YP2FbysMw3G0Lgg Hm3TsvbPJNt+XDMXmfXw6TUmrEwujWd86vTahRecxmjZhye3Pbvw1Mnc0aFz0zJjaH5tF72sOetc gvTEaS4tJwmtH/RxxbKgLUtX/rY/43Kms6xtrF6TW8/0dc06f5ed8RmXmKh6+nFmXM3jylnHJVY4 tEw/cgfNuYqr4zOfoLjE+OLTl7zcE9e2Xa9tbr328dDfnpmfrdecWia/nl2+sS64Ao8//jjWrzf3 23CMSy+9FKWl5n4gHInteLj6dVSsvg7njk7gyWMXY+XFI1B9TuZrpO43t0vRtzRpNOsPE31Qc38D vnZ/HvLrX8LkQd/Gv+582VyttRFNeUV48wFp8FZg+dq7UFY1OJnFa4/dm5wPNMoRxzwc+FDubtn2 6GOKOwlr+WHHbzGEFswVZSuB99P34zxgSnb7cztxy6QBaDDXDyoy37tMbOifZEtDQjN3DJjAgvFF 2LdoP75bZn8btGPMsXeyAvxAyJkfMDiLnrJdMp/exgWuox7pZKKa1KXzJWdjBWfrhJv+LpuOfcjI 8mZivxHZb4R6My687a/xtixY4ZeHjCi+NlfUdVAssQXZdSwXTnTdtS/GZU3tXF35agxlHw/3FpaH fF09B+UntiC7ztVXB40JK9txZc3nSeZMORFPn0x4ySsMJmz+YXHMU/CufYndzsteh40VFid58KF9 guK68hRf1540Zxg5KK7Ln7nLrIfw+PLx5a/9Kfs4ourJ19E5an06Go/+uYqbDU8UH3le+GDunH08 ovfZ6MvZhxO97zVB33gOrsC5556Lz3ym/cfaPn364LOf/Wwb54Y338RenIGK0XKN2n4Y929FeOPp d1KYxAZM6zUFawJub5KvrlbUJ31XjzxzIZziQrkIT1/DMxB9TfMmF9MpNFf7lduRyLhz0W9NY2lG 02Ysuc3dIIu5zShUrZ+WsRvLZlWlXq9Vd6MuSQzUPT6n5TVcPeeZVDxDuGHZrLS+CNNXyXViU8ed 5L6e/Y8bYK5im7ogkH00qml3LWaNT/1eCF/yIK+p0cyqabj77pkpzpmLseHlxWn+aXh+V6p5DvKd Ny+dT9WcZO6bl92C60xJZpf3w7QF6uhum2LEiwwVYP+UAZY0802Psyh9/hoThtuJsV9bTlAWSp2c awPUaZwO49NrzCEv+958crUx8h9ub2TdtS/G7ejzkwseeU7tkQtem7Mz1z0tX+ZzuP2+dOZzKNys W0fjuOreFa/zXOXv27+PP6qetWZNxJ+y2Chz9uWTC72OQZlzLvl9NcpFDB9Hd8T05RLro1WgX79+ KC8vh9zyTo/q6mpnM6oxxWcMAv59Bz7+z9NxdOHJuP7pm3Gq52Kq/bAKt18/C8P7GAbTfH7w1CoM /KZmay83HuiD25cuwvKpP8W6+6/C+HWPY82M+bjrvetamsL2Xub+mL37Yf11t2LWu8OROv93q4me Ohq7efG1mPrBt9D46bP4zax8fHXh+Vh3QxmKhl+CLftvxYjEM+a+l7Ox7qaLUFH/OEqnrsNzO/fj LLyGK0+aZMKljrD2Hgj85O7bsW+UCdF/Em674SKVSgJLrijHB7duwaeX5WFWr2FYdMl+3DC2Ee+t WoKFI5di5/vfxn8PKkXpwpvwys6deOvfT8K8Z7+LqmtGBvv2m4+339+EBYPGYNm6b+PWr9+E26fO RcPTm3DLuaepHGIxQgXafzhs68z+q622daX9M2FbvUJKndV06vCyATvxTt2UDt5dsrwB6zcvviFr XVBuUfE2l44vMfXaxrrWUfEuDpcuaF+0ufyo03llsy/y6Dkoro5n++jnkhxaF4SnTfNT5kyMnmnz xbGxep2tLDHDDmLD5Kc5uS+tC5JtvCuu5GDjfJwaF8XPx5drfdj8XHXINhdy2f4+veB0nrafXpOD rxOfH+3at6MyY7t4dB6UOWs8OTojPx3Hlu1c9GtV25if+GvZ5gu7Jgf32xlxGUNyYhzRUQ6ba1Sc jmv7ho1Pjo7kylic7VzidbgKTJw4Ea+99lry3qHi0b9/fwwbNiyjc9v7bJZgwkUTA32qLvkyPif3 GynIx8YP5+KhQLQxJt5D/9ETMatyOlas3YZPHl2Kqd94FINuMae5BvnKYciaKnx1yufQaK53lP/J RsydK9ES+NNLK4Cdx+POOZvw57nA+ttTJ/0OHjcWG55fjnkv/trghps7ZQLb/viU4fkWJg2We2l+ HhebM433GT3H8HFlOPt/HY2D+cOSxz9bTvJt2ol1q0yYkQ9gzqYGmDC4PXk6MMxJxZV45b6rMLgw gaGG765Ft6PM8OefUYmt7//V9LTBvmt+MRND0777JMm8ATC9K/YNOil5xJi5xXOkCtj9lu2sP9BF wdo8Wa1z3XT6NsBNit3G0JbVBnqSE9+IJadMbz4aGwYvGL6xabyPx6cXXw77zU37iGwPjddYwbnw tr9rrXm0LNjO3K+OpWWJq9ci2zquk4aAH1F4XLV1xabOF9aOqWtIHx2LOpm1PgyP9g0j+/jFN9O+ iOF+wuAz5RQ1H40XbubC3Ox4Np72sHr7OaB/rmedjx2Tewyjl7w68rwwFvcXlkvnT197jpq/5qRv UD46d8qCpy/zIUdUPf3Dzppfy+LP/ERmPiJz6L1TF3bWsbQs/q64GqPloHiZeMRXuGQQa+9Jx/LJ 4p+JRzCuwbhio2xziU3rKMts5yvYeISrgJxKW1FRgdWrVycdvEc5pT8b0sq593XT+s08DUe3qryS NFvnXFiFsvSR0GNersRP0qe2ep2MIZE/CJfdNAPTJ03HnZiALfeehBfM9ziDhnyns/TzlZhYMS4F azrGRJemsxEfvglUVl6ASy45BRdeeCG+e4I5VGlOub17/CAsrVqEhVd+AaW3/TT5/dP9bxvwKVek T6htG1G+S1p18ZdQNc5xaLdpH7YaeOUFF+OSUwpMnCtxwqjUqcLC0ih1LGyE9MapI6eSmQzTRWbw TQJbfJNOqR/pplZpYjF8BYJ6KvuDvcbaNlfEMBiXX4uu/cnvLaZQgp1Apg2I3cbYHKECdyeIbw6u HMTmsrv01PnwNr8PH1UvvPTxxQijJ4fMHFoWnWsdpKNNZv0gPzlpC6PXPi487T4b9Ywpsz1cOsHQ R+Op0z5app/LR+t8Mvmj8Ggf8vp0tOeKP9Pe7Xg23pUHfVxY4m2brPmgP2dbzzVn4jh3pj7oA6kd V9Z6uNZBOm0TmWvOwk29rcsU17ZrHs2lcbZMH+ptP73WWJfe1pFTZm3jWutEth/013rqNIfmCdJr Xy3TnzNtjMu1zNRx1jZtd+l9uo7G9eVix9P5uXyo0/m4dOSljby2PiwP/X14HUdjbTzjE6PXsRyt AtJ0FprvV55wwgk45ZRTnM5FY0fimO2vY11ds7Hvx6ZFDTj1PGIT2LVlOwK+0plqttLMqSbLGaaN 8sBf8zF44hVGtwq45QqMMFKqWUvB5KuhBz4xV/JpakLC3MrFTKmRUBGaKBfjC1dPwarlu3BKWUWy 0R55vGkG69/CUvO9yHtvuwYVJxRgPUxHacawc8wps3cuwgbzhcz6zU8mvzvJFlPi7tu7pzVu0iP9 o3AsqitNxruAMlPXiopyHF8U8nhVFr5yUaO9n3DjOpFYzkEFgvov2+YKFwbj8mvRhW06235yaXFv 00C2alNSmOQEo3E2hy+ujTvs1kEfLA+7zR4GGzocny/ZEx/6A1JPfLoOx/q76ny47PNw2YfrOeop Ov7u5qLWUTiixo2K7yn1jfPouRUoKirCpEmTMGXKFH+ShUNw+S9Px+8qfoy7jl2MjedOxJeq+qXw iY24aORQvBrUdSpmOTN0IDu4Fn2/5GmtLUsj9JYvZZachVdWPIw13z7LaFINJC/o03s4cNukk9Ar Px+yh8t+Upvi8HCPvuZ+LJrwAAal36snLzQdW/FYzJ5RivMGmPfv6StQU7oeE6YtBsZegftqlqC0 Xy/0GzMnnVaqeWwXd8GGlH2ctKOFqHloDcbfOCn9eSAfCzd+lPZv3WMKmeJrrUdIX/Od0tQoxoVL b8Kd5w1CNXOgKZ6zrYDdR3Ft91/USxzdl2m9zkFjtD5QdjnpRCjbszSropPZluXUeOopy0xZXpWU 5bUpMnX2PGbv3r0/MPYuH/JF9PPPP7/L48YB4wrEFYgrEFcgroCugDRmMnr6H390zrmSj+S956qG UXhWrlyZPEooRwr79u2blKUB6t27NwoKCpBvGqI8czVW/rGgubk5+f3JRnOe5ZNPPomampoo4bod 21z/CT5OHGWu3tqus+v23MImkKivR6O5nK5cOZdDjpTKcyjf/axP5LXYBItic0VdAiPM9cY3v0iu xhvBKQ2N4ttk4jRlGSd6Zj3PoyO/gyUlJf9idrTJPOQQvhwyds3y146/pW1i1w/qZbZlaUCppyyz 62HULXqRkyOLlw5d280SVA97LbbUO2cKpWXtR9nlT1s8xxWIKxBXIK5AXIEjogJHYrPJJ/ZI3jtr EM+dV4GjzO1N+rd+RbHzAnUic6GjiUw1nBJUbuPSGlyw2Y7iLvLNM3Fy2Zxku99D2C9T/2T3Xzbe XmcqRWi8HJHMZrgC2Juw19rHJ+tcbH9ti+W4AnEF4grEFYgrEFcgrkBcgbgCcQXiCsQVaK1AUP/k 6r+Ip43rVsZWiZhWTdsDilrfTs72jwlBCdlBmKD2Edmlt33jdVyBuAJxBeIKxBWIKxBXIK5AXIFD vgJ7atdj4/oDGDBxLMaO6JvaT9PHqHtpD46fOCTU1XPtItRv24A3mwai/753kTdyJPZvfBsDT+2D v7ybh4pxQ214vD5yKyB9V1D/pW1SJfZpumI2RtsyylGOdLqCZwxgAJKgDNuf+pT1MP/J76XY2/Tp ieuonTxR50xxo/Jli+/sPMjPOShPwfDhw5GHOD1rH+q1TmT623rfmnjO5Aji11gfbyY9OTh3Z1xf rqyBnaMPH0WvuSlH8Q+L1bmH9RFctn6ZYrh4uX/b5tO78iPWF5/cnH24rtRnyjlKLr592Xp7HSVG EDYbXp+PTx8UP6xNuO1HWN8YF1eguytwcMNvcf+FL8L0h9hf9wb+a+BP8IZcrCjxLpZXP4btIS9c ZO9j44OlmP7IH/HU9HIs+MMalE64EX985RFMKH0QvOSP7ROvD9sK2L2W3ij7Ls5iC4MPwmj+jHKU I506SR9xUGLir+1a9vEd9vr4+yqHxlMsH3T0c2WvXbuw8cT4fEXf0WFz67WWOxrH9re59VrLtl9n re2Y9joXcX3Pby64yaFjUNdds9TQHnZdueZMvF6LbA/uU+NsTE9ad1eerFNPqkVX56Jr4HotdXU+ cby4AuEr0Iz8qyfh3C+fYVwSGPriEAyUG4OaCxn1QVHyqprhuVqRJ4ypwcC3DiIxsBKTyk7FX9AP Bw8eQOlNZ6OkFRZLR0YF2r/Btt+37r+I1zrbQzBBdhvvXUdpOr0kKhkm78NqO+WcbMQXsDP0+o3O 9wao9b4cyGNjqXf50ebz0XpihYd66mStZcFwLbIeWh+GR/tq2cUjdp9e+2rZhafOtS8dw85f24RD +4uNeJF9g7G13edHLGfiXLE1ny3TX/SUyWFjiWEs205/0fsw9NFYyt0dl3kwR9lD2H1onItHOLWe eM6Mac/0IY5rjaNN67RMH40Tnax9Nu1PmVhZk4s8GkOb6OhDHfHU00/PPpvWh+HxcZLHx8G6MGfh IZYyuW2MrWcscopd+xDPmXG0n7ZRlpk8xGqbyJn09CfWl6PNo/3smFzTR2OpEwz11HHOpBdfYl08 4i928ghGBn2o55yytv6kr42nnkh7TX08xxXIWIHEdvz8S8+jqCIPbyww97Q8cygu+/mXMOK4Rqz+ p1/grQHFeGfBTpzx7DdxXp+NePCcl7BXSCefgekLz8MgbMfPKl83N0l5HXc9+CdcueXv8Ifr1+Ks p76GoW2C78fqf34ILz5obq9y5um4+skv4sTkRWg3YFrRv+L6+hWYII2qGied933c89ki9Dn/Hgws GYqRa25D3il9sHBUy71IFDoW4wq0nIEqpWAPxp4sannoH8ovyum1QYS+ZHUyPtnnK/G0T1D8LrPx TUve/OTBNzmfPigx1xuozRPkT5v2yZQPY2of4dFrYlx68hOj/ZiPa9Y48SWPT+/iyGU+kgP3oOeO 5uPKm5xi07Eoa73L36UTX/rbs+Alpo6rdaLnIIZ82kaMnokTXU+Ia+evc6VMjL2W/LlfYvT+BG/r iSeXxmidLZPXVTMbyzWxXHPWOTEfrdN+tp54wVAmhvyuWXO67D4OW5+Jx+YWPH30TF5tt3312sbL WoZPz1jarvlcssb6+OmnsYwlNp9ebBonaw7tkykufVxzGB7yMxeZKQsnZVuvucVGHvrQrvWuHLWO PtRxrfm1TDvx8RxXIFoFmrH/tf14A2fg2jevwHhsw/IFW5IUTW/uNw0ncFntNThv7D4sMw3nSb+8 CrPf/Sa+cOzrWPS99Wg29wX98tKh6DtzIq7bOgUnFzbjg9f2ICE3tVBjx+JH8eIHZ+LmD67HhaVv 4Of3b01ZC0/G9U/fjFPVlWjpllcyGmWjh2J0WRmOM7ezGVFRhqGDR6Ni9HGExPORVwFf/2TrWz8Q tq2RjWtrbV35/FsRSspV06ko2zSKOhlbDrMh7aNjdJvMNzG+Ocq6K4fEs2Pa6zD5RPGRvfJhc0fh 0b7Z+mkOl+zjFb3P5uKhjj4yswZ87onpiTP3q3Oljntx5S22jgzG6Oq4vpwlD3tP9trnS71w8EFd ppl1sHGufGxMpnWu8hceXz6+/F25+Th8ehdHZ+u4V8lJhq6h6Piw89A422avo2Bt346scxU3Vzwd 2YvtKzmFzcuHE31Pei3ae4zXh04FGs0psJf9++cwoOR4fOHu04G5O5D8SqY58HnGs5dgxJB+wJub 8AGOR3nVseYO9H1RNqMUePAdmOOWKJZ7gZr7T/Y39zCRG9S3Hwex4+X9wK638MR/PIPaB4HGfXIL RRklmHDRRAzK1fmJKdL45+FbAVf/JB/wRO/7oKf1Lv8OVyvqy5cJ68C2LihR14a0TvOKHGSzsV22 5pvbkfJGxv2GKbDUxB5R/G3fzlrrPClz9sXU+8iEJYfgtB/1HZ11fMqdFUvnyliio9ydcXVutpyr vIKevygxXFjR2SMono0Ns841nx3Tx+/T2/56LT6siZYFQz1n7RdGZj7iT1n8tJyJh7Gj+GTi7Eo7 89cxD8W92M+h3k8sxxXo1ArIkUnnJ+d0c9go0QvRuyUJ0TsdWhCtwt/w8ZtA33NPxbjJJWi+4HT0 PvHEVnMsxRXoWAX4gYMzeyzOoqdsR/LpbVzgOuqRTiaqSV06X3I2VnC2Trjp77Lp2F0u6zdtebPW 61wn4+IWnUufy9hB/EE2yUFqYj9cuWXicfl0RCfxdEx+0NIzZR1H+1AvurBY+uR6Znw9i+zKN0rs TP46nvDKujvj6r3p3H3Pkcb7ZM1jY4JsGis4jRWZtdM41k/P2p6NrOPa/trGnLSOeNG59LR31syc WCvXTB1z8OWp9VoWf70mj8w+PTHiG+RPnGv2cUfVu7iDdJqf+es5yDesTcfQPj69xgTJ4p8Ljmyf s6DcYtuRWIEGvPN2wmy8GevufwP5/3Zqu1ucFI08FX3NqbcbNwsO2PLrt4BJ/VCQXGX6UYjRNf3w yaP7cWzZaRhVcRpOHMTzaRPYtWV78shqJpbYfkRXgP1TmCKwx+IsPj5/jQnD7cSE/fOL0zlAqZNz bYA6jdN0Pr3GdItsv3nJWoZPr5OUN0/ifXrNo2WNt2X9pkx+25d6Yu1cNN4nS9xMPHZuXGtOzePT 009mnasP79uX5gkj+/iZh8yC4dB4LdMedmb+gqes44TlsXMgR1R92HjEReX34ckXdtY8WhZ/1pFc Yrf11Glfnyy+xCeJIv7w5ZOJRvwyxfXlrPUShzyakxjaXPno3CkLnr70IYdPT1/BU6YPOcLMmj+q LPyMqX21nrnJTGymvOijeTR/R2QdO0xOvliax5Yz5a/3RZk+ukZ2bBvLtcy5HMxFOJmPrhXzoi2X sWOuI6MC+WabL56zEC/KdocMxdS7hxshkT6OmT5htng4vv7L07GIOJyEr2wqSzadcoqtcLSOPHUM NCWffM1XUfHyUsw33wWV0fffvoxvf8fESWzERSPL8eP6TzHRupBQK18sxRVwHsjTZWn9AKu1rbLu vzJhW71CSp3VdOrwsgE78U7dlA7eGbLvTcunlxx8Npde67RMHtebq2ufti/9XVjbpn21TF+Xjjbf 7PPx6e2cyOvCu3TEZ+Kxfe01ecLobYy9zpQLY4WZyc2ZPvY6Wz397Jn8nGm319nq6WfP5OdMu15T 5kwMZ59e7Nrmk8nDWeOok1n0YX9PtZ8t2/xBa23zyeTXdtFFXZPH5UubzRmEpY9rJg9nYuy1S68x WiZWZpfepdM+Ltnno/UdkV25aj7bbttcOVMXhM3G5vIJ0tHGOVNeNs7eu8/f5UdsPMcVyFSB5Hc6 t34Dp5hr0B7V8r3MQpxfe0Mb10FVXzQXEapEg+kyC4oLWr6/WVT2RcwsS0MLh+M7H5pmMjm03A/n /t9/wll3J9Ccn4+iwnQzW1iG9eoP3mnHeIorYFfA7rdse5T+S2NtnqzWuW46fZtl4mK3MbRltYEj zUn/5fZI23u837gCh0oF4t/Tzn+mctHUd36W3Rchrk/31T6OfHhWoMhcSAj5R6GAjWDQNvMK5JpB WY8C09TGI65AFhUI6qmC+i/b5godBuPya9F1tOm0E9CbtW0SVOw2xoVrSTAW2lYg/ktt23rEq7gC PbEC8e9ptGeFDVKUukXBRssmM1pi65y7Mxdftj0xJ1+uHdUfSXvtaK1i/ywrYI5MfvOD4Vk6x25x BXpEBYL6L9vmSlgw7Nk4u3BeXdgLCfnIdZJ2EG0L8tc4m8PnZ+PidVyBuAJxBeIKHKIVkKbhUGsc DsWcD9GXR5x2XIG4At1QgfptG1Bbtwt1tbXYVp85gY/qalEbBpiZKo2ox4aXa7HbupdpaPcYKBWw +yiupffS/Rf14uPTi41DY6jLOIc90pkVuYpOf70pLStoG5F+bZTxIq5AXIG4AnEF4grEFYgrEFcg rsDhVIGGDc9h3qyjcMNvzpWTec1I4DfnL0TTDyZj50W/MvcAbT/GPzsVhXOX4uWPS3H9o+e2XFF3 2+KH8IubG3HZ1hqMyN+KBSf/DudvvQYjQp72u/HBUszovQLfXDoF7/73HtwxsaR9cKXZ+kg5yg+s wae3VihtB8T6jSidMAG/3/8pjguZcweiHa6udh8la1f/ZeNYDx+e9khz2COdYUjtTdhr4dCb0rKL 3+XvwsW6uAJxBeIKxBWIKxBXIK5AXIG4Aj2kArAhz9wAACAASURBVAfxm7J5eLI2deuUSEm9lr7n Z9qpaQ/Q9JkTMW3HDMzacT2ue+p0YxmBa408a+t1uKC0L5p2GdXvN+HNXfTdj1dvfs8oWw8TNpoL INGapg6cThhTg4E4iMTASkwa7Wk4E7ux66P0HgsrUdq/TyBnJGNRH0xBZfp2M03YVbfNtODRxu5t uyL7tIvQtAFVvcYjm6eyHVfXKDL1T3b/ZePtdaasQ+OzbTpdAexN2Gvt45P1xmx/bet2md/nsRPx 6W1cLte5ihmVJyret+dc8Qi/j8un9+WUK33YuEE4l010Lj3zpo0z9facyW7js10zDudseXLpJ7nY +bh0UWPanFH9NT6XXJqXsoufNXDZ6Nddsy8nW2+vc5lvZ3Izz86O4eP36ZlXZ8y5iuniEZ1Lz31k shMXdrZj2euwPDGuZ1ZgxxNP4a5j5yUfD/zoddOOmZHYigevXg25HYoclVx99f34zYYEdvz8Cbyy HXj9woV4YOFWY2tG3c8fSfsvxh/rUu3TjsWP4L//aQUWGN7/+qHgzBhyVMsVb+UmKzwlsaCwMHkR o4I+oilMXtk2eXVcWfYTx0bU/k4aTeBg3Ua8kZQy/EhswLReU7Dm4/a4k877Pu659PO49J57UN6u 50xgw+Pz0KtoEJZsTe0+3ySxfu1j+F516vduzuN1adLdWDarKvm72KvqbqS2nsDj30vrzO/p3c8Q +5HBjk9h80uxwnCmbjPTgGevHYaiXjPxzIbd7ZO1NIldtZg3rRcGDVtuqmKG2efMqmm4++6ZKe6Z i82pu4tTcq9peH5Xqjlv2l2LWeNT+VfPeQb15jldfn0NVmE9yot6YUGt0Wx73DShKUyvau7HSqB7 l0H9k6v/Ip42rl27IEbbgvAah2ybztABTDQmqH1EdunbJHcoLg617yUdijXOJufuel46Ky6/TxZ/ qMnm1ZD64wRrSAappa2jrbvmznr9yH5crx1dA4ntwnRXLaLE7cy6RckjG2x31vxQrpur1rIf3+tY v9Y7q+aHWz1dNT5SdAfrVmPp9F2YXDsDN79ZjT7//hweWWlOdm1sRsOfPmk5gvjxnxqQMLqTL/8C 5HjkqUsvw1VXD8HBzS9h+XeacPW7N+DapcV47vI1yUa1+WA9Pnl4G8549irMuG6I8TC3SNm+Hr/4 5xX4+T8/Yh7Lsd40r2w83fVuNsczj0fFj4bigx9uSvL+5dHNOPGOMhxrHAKPbhaejOufvhmnOi6W m1cyGmWjh2J0WRmOUwlse3mZabqKUDr3XTy3ZQ++W5buSHubYEtuw9Bb3samFTfhtimP4COj2rz4 Wkz94Fto/LQRT4+fja8urE1uY/iU+7DH/I6+//vbMfviFHbX4/+Cqc9PxdsNjXj79/cZ3P5U04hi XPN8IzY9V4bZpYPQq3oOXnZ9f7S+DstMM1t0Ujm2nvcc9jTeYDxlNOK9VUswu+4L2Pn+etyycLo5 dXcdXtm5Ew/PWIJ5z24ymASWXFGOD27dYv7feBvDb7sYi2ob8aV/uxel5t+KTe/jH0oNW/5w3LNl v8HsxO0rZuORdbLLQ2JI3xXUf+k+TTbEPk1vzsZoW0Y5StPpCp4xgAEwQduf+jAchwRG3rjsNy+t 0zbK2s5NUkeM6KlzybZO1jLow5k6zja/Sy86GZqDa86aR+u0XsvE2LONEbtrCE4/XBitI1brRKae M3WcRW8PjbVxQTbNQxxnl406wchwYYnRs8ZpX82hMfQN0mmbTyaPPdt45sGZdpmpSwrpH9TTRryN sfV6rWXtp2XByHBhqSOGOM5h9IL1DRe/YKnXftTpmXaXzrbptesDsUsnPsLNmTLXSUP6h7bRrnWU ZaZMf+o4u/TUaW4fj43VPraNMW0ujaM/Zxvr4iCGNhcfMeR1PQfE2DzUk9deUx9mtrmZDzk5U89Z 67VO60Xm2pa1j8gcxHEWvYsjSE8uexYe1pmc5OGaM31lzQd12seH11gbb/vY2HjdcyrwznNbgMln YuyQQhxVMgQT7yjC9rV70wm2dmQtUt7RONr0kEXHDUgekdz7phyB3I/VP3gKK5fuNI3lgWQz2HSg Efmzv4xzyo7F0cVyT05pEY/H2K+OxvgvfRbjvzoq2TimA/mn/Y0YfPYZOGb769iy6z3U3gX8r4tO Ms1o8jif3w8lmHDRRAxqSdwPra97BjPNUcBhE36KmzbtwafP34GqEa2HQBsP7EfpXa9gZsVQDBs+ 3BAVmmY5gT+9tALY+WvcOedOLJ0LrN8nORVi3PiBeHX5Ysx/dDlQ2d9gm/DHpxaiZvbXMLQwD0P/ rtKcXKtHHkZXzcQ607yu/0YDJgzrh/HmiGXqIGU9nplnjmL2Ow0/Lfpuspm995oqlKh97Tdsr9x3 FQYfNxJDS4G7XrkdZYMH4/QzKrH1/b+aM5F3Yt0qSfUBzJkzFyZV7GtsQuGAY8xpxgNx8rDjYNJC 4eBxOOGva7F43gPmCKhZpw7F6kS7U7Z7LZ1L6o3c/FeqlGHwQRhFlVmM0nTqJH3MQYmJv7Zr2cd3 SOn5JmYnLXp5c+FMO3Var3VaL7IMbZc19TJTtnFab9uETwYxNk/S6Pjhw+v8BKP5KROTTVz6hs1T x9DbCOLRNpGDBuugfYinjWuZNc62axvjEiMzZc1nyxpHvMyam3r6ahvjap3GU9Z28rhmwdNHz9qf epc/dTZe1jJ8enJqO7lcM/EyUw7it23Mh742jyumzSE+5BEbubQveWnjrPcpOs2j/SnTj2t7Fn9y 0sa15tcy7cT7ZuJcvqKTB4fGhtGLn8aRR2bNJbKt8/klgekfxMhM2cVDftum9ZqXsuakjrMrf8GT k3bio86+2IzBmbyMp/Vap/Uiy9B2WVMvM2Ubp/W2TfhkEGPzJI0BP5iPhggH9eTnmvw+vc2j1yLb PLY9XvfgCpjmEMf2bjntVVrDfDmylxz83qTjI7U56imj4R1z+dczh+CMyWNRfv1kfGVVefpCQUlz 2x9DjkfpOadjbJV5nHMGBpvmlRHaAvWqCUcNGoLyy4FfXf0o3pp8Bk4ffFTGllMzZJKLzdHDb9x6 lznmtwr/8+AKbP7In1Vrq9uID980PWXlBbjkkgvx7TVrsP7qUcDuF1BVdBKe+HgIzv18FfDhARO+ AW+vAU45IXmusDed3Zt/j5/PvdOQ3oQ5MyvTDXMxKi75Bu6bUYlVt83Hiuc3O2vWmEysERKNVU3l ajrHpn3YarSVF1yMSy68EmtMrlePar2CUcoXeOHuKpxU8xsMOedcjDf4qN8zlcidOII/tKYCt77J mv+W0rlonZ0eMbY+8trxGxKZQxyYbKbEtJ0yfbMKfCg78Y0yyh6y8bH5s+Hgm63N5VrLGysf2i4c fNPV+p4mB9XHV4cgn7D7ywVH2Fgal03cbHx0zKiyxNOvKR2fepntoXG2raPrXHAH7SsoP9fvUaY6 RMlXsMyNefj8iXPZRWfr7TX5O3vuiXFd9fHVwZe/6F2vBx9PrvS+fIL4s/Gx+XLBYXOGWQf9foXx jzGHdgUGnX0q8OAm7Eh2GB9h0/wG9D851ZB8sv0tbP+oGe+v/HXye5w8uNa03bRRn6SazhMnnQa8 ZhSnDMeoitMwYmRAY7W9WZ0S+zdn8+SqZrO55M7oy0eYOI049ZrTTYOcit2KbUJTwnwTtekgDpo5 ZU1g15btcHyls9WNUuFxqLjsu1jXuAc3jPozxgzIR/Wc5djl6rpaus5ifOHqKVi1fBdOKatARUUF Rh5fjPq/vGRa19txmzkaOeRoc5RxvQQpxjlTS3HnvKdSp+X+6ufJI4k8kFi/7QV8r8p8T3PMPIz6 9y1ofP5eXFo2tOXU45IRFbhhwfPYs+UG/Pk/xiC/VzWW18oVlkKOwrGorgRWGZcyk2dFRTmOLzLP puk2PzT/DiZ77Hq8unQVbvnv/4OqssEwmZvR8oxjd10deF2lxO5t2LY7fa+Zpo9QV7c79HMZMuNs YfrDEnswrYvCS/9QPrlqOn3J6mR8ss9XNqB9Qm0oBnV/BeRDgX5kk5F+g6ecDc/h7iN11vWxZdm/ 6Lpr5DIfvqbs/VDPOWivzEewXTkYV8+Mz7ztfdFuz4Jz5U8ezrZfvA5fAf08UQ7vHSN7WgXkd8L1 PFIfJl/+XnEO4xNjDp8KFJVNxOTZDVh6slxI6GfYWFGGy/7+eNMnDcTYSY14YuSPsWjBxzgmuWU5 TbYQn/3RSXjr64uxYOF2FIz+O1x2zwA8YRomuRjRPV/6Q/JCRNKuFNjfpzRHNvUQTF7LMda0xVxs yB5NptE7etJZOO9HE/GFSaapTR+IJLLIHPd8Ysx83HXCfNx78nz8Wi7HmtiIi0YOxauhus50xLwS VF1zBz5t2IlvmEv9LE9/p1Gaw4HcixwGNqewyhh9zf1YNOEBDDLvXfJ7OHnhehSPvBjmW58YYNbT HxbojZi2eAPGXnEvalZMT+rH3PqU8WZzXo9lN/4bjvnuevPd0MdwzcQRLa1eMoj6UTKiCnc8b74r ur4GK+59ItnApsy8KBEgB6nl5F8ZrXkXouahNRh/46T0/xf5WLjRfF+zeCxmz1iPSQPMhYQ2ABfO vgl3ThpgMNcCNaWYXf4tmGtHmdGARaedhvvFx4yNi4Zh2PyNSbl+089w2mmLzIWJumz4PuTYet8H RBvnS9zn78S7wKKjnrI9S7MqOpltWdbyGrdn0emH2OW5Fp088655zN69e39gbF0+1q5di/PPPz9y XPmFkjclDq59sw9n62VNDto4az1lzvSTmW+wrvyIo03700YOmWVoDGXOKUT2GPrbs+YXWQZzFlnb Zc1h6/Va82i9+LrWog8T0+dP37BxdQ5advFrncbasuAkD60P8iVeY0S2h/DJ4B5FZgzOWkdZZjsf zaV96WPjtd6WZa2HzSe2MDpiOJNTr30ysXrWWNFHXZMrjJ9g9fMi6zB+Yetsc5FfZsa1MVxztn2i 6sVfhvYLWmucyDKYa3Lh+GH7BNVHY4XKtRa9HdOF0xhtp8xZ+LIdNgfXvplxbLutlzUxtHHWesqc 6SdzUJ2JY420v22TtQwbo3W02XPSUfnSTl+ZmQN1vrX42vikopt/rFy5EoXmKqny6Nu3b3IuKipC 7969UVBQgPx8czXVvLxk/WQPzc3N5kCQuRmHeTz55JOoqanp5h10bvhmc4RQrlpbVFigApmLCdU3 oqiYHVerqbk+geYic9XZVH9jmrwEGho/Y7DavxV/OEuJ+no05hehWL4YmRxNUg7zGjPrhLkqbF5x 8juT0i3X1zeguLj11Naurku9yTW/iPmkoifMc5lnnmPJvimVeFKuN/pix3Ofbc4d+R0sKSn5FxNX rookB7Llzw56luPPfzMPzmLTD8FLAyM6wclDy2KjnrLMrodRt+hFTg4+81xnmoU49T9lK9LW2fZW ZCoBrokTf98Isvl8ukSv32zsgEE2jeWbjuj4xiSzS0+di1v7uHi0Xce3ZY0jj43Raxde6wRLHp03 MbRxrfE6jpZtLOuiMTqWTx+GR/v6ZMb3xRQ/bcsmru3jyyVIb3Mwb+ZHX8HJ8OHpp/dE3yizjz+M nvlxZk5cy0xdLvPU/CL7hr0HH070Gsu1jbf3wL0RJxxheIiXWXNQzsRDnPgLVoboKDMHrpMAxw8X D30F3hFZh9O5ab2WfbE0xpZtH7FrHdf0c+2XNnvWWMrCLYNrkbWOMnPgWnC+IVw+XJBN87nyYQ7E MQaxLm7tQ7ytoz95XbPt48JoncaLnrE1hrIPq/Vapp/Mes8ao2WNj+WeXYGjTLNZ1C7Fo0wTKcdN 2o+jTDPSxmKaedODHpGj0DSRbbeeZxrOdCkKtS2vWxtOycjV8BaqxjKvJXHBchM9/mll38WZPRZn 0VO2N+PT27jAddSmk4lqUpfOl5yNFZytE276u2w6drfJ8obhGraea3sWX+psHpfepdN+LrvWUeZM 30xrjXO98dv+gg+jszH2mnFds8Zq2Rfbp7d9XTgbk2lt52vjXTFcOtvPXttx9JpYzrTZa1dcYm0b fTlrnJbFbr9O6MOZeHvt0muMlomV2aV36bSPS/b5uPS2LtPaFY8625d6mW2bvQ7CBtmy4XH52DrX 2vd60PmJrH07IttcmdY6lmDDDJePSydcPr3LFgUb1V/wHL44tp5rexYe6sjJ2aV36YiX2WXXOsqc 6ZtpTZxv9vlTz1n8taz5tF7LPh+N0bLmjOW4AnEF4gpkWQF3c+ImY4/FWVA+f8H4bG52hzZq0+mg cKoybYCJa5wm8uk1Jpa7sAL6r7VdGLZTQ+kPw1355n84x43yOumuOnTqiyomb1OBKK+HNo5duIhf h11Y7DhUXIHDqQJNH6PupT04fuIQHH0Y7at+2wa82TQQ/fe9i7yRI7F/49sYeGof/OXdPFSMG3oY 7fSw3Eqm/on9l2/z2j8T1sfh1cv3Kjt7yAbsxDt1U529oVzwd2WTcyTmG2bP8hzwEQafKwxjduQ1 IB+Uo36gz0XcTDWIsqeuyMeXr8RmDX2YWN9agSjPa6tX+6ND2fJozlzLnfk6zNV+c8WTq9r1tHx8 ++Lv+KGSr28fsb6HViDxLpZXP4btUS7C49nKtoWLcddXV5tL0aRHYisWHLsYdV145RmG3vhgKaY/ 8kc8Nb0cC/6wBqUTbsQfX3kEE0ofVBflITqee1gF7H7LTi9K/6WxNk9W61w3nb7NMnGx2xjastpA 7BRX4EisgHyIij9IdeyZj2vYsfrF3nEFenoF4t/xnv4MHeL55R2FPuYbnm2+s9mRLf2+FiufT135 VGjM5ZmSV3HpCGU2vieMqcFAc7mkxMBKTCo7FTXmCrIHDx5A6U1noyQbwtinKysQ1FMF9V+2zZVz GIzLr0XX0dNr7QT0Zm2bBBW7jXHhWhKMhbgCcQXiCsQViCsQVyCuQFyBuALdWYEdT6zE0ulvJFM4 5o4vY+bVKpum9/DYRQ/hjddE1w8X1l6Fzw0pwL6XV+Nnl9TiE6M95o5qzJwxxKnjvR7f+Pqz2Lbj CgxV1PBw71j8CJ5afzT6rX8D203c8se+jMJHn8GLDzbimNlfxD/+H7lX536s/ueHjM4cQz3zdFz9 5Bdxolz3JrEB04r+FdfXr8AE69zgk877Pu75bBH6nH8PBpYMxcg1tyHvlD5YOGqgziqWD70KBPVf ts21O8GwZ+Pswnl1YY90+sh1knYQbQvy1zibw+dn4+J1XIG4AnEF4grEFYgrEFcgrkBcgZxX4GDd mmTDWf7YVZi145u4/Csnto3RVICxd1+F2R9cjy/ftB/PPrTd2A/i1e/Xot8i0c/AlZef4NGZe1vs A8Y/VY3xQ97DI/dsMfcRUcdPndzmXhYH67H3wTdwyr3TcOWCk/BK9RP4y+cvwrWr/zf23rUWO8zt SHYsfhQvfnAmbjZ5XVj6Bn5+/9ZU3oUn4/qnb8apjguv5pWMRtnooRhdVobjzO1xRph7kg4dPBoV o49ru+d4dShUwO6juJbeS/df1MuefHq9X43R+kA5bNOZFbmKTH+9KS0raBuRfm2UPXkh3yFxDZ9e sPzeicsvky6Il9yZOLKxB8XlfnwY2juSn4/b3ksQLshm8zBXnTsx1EXlo39PmDs797D8QbggW9ga Cof9COvb1big/QbZouSZK54oMWNsXIG4AnEFDrUKvPPcZpPyGTj7nGNRUNgXA46zurXCEgw74a9Y s/gF/PFRoG+yaSzA4ClFeGf6w3jykR0oKJF7c7p0Uo0mNOWfgIseLkPj3F9hTW19661ZnNzG40Aj 8md/GeeMK8GJo45J5lf998MxYNjx6Gu+HXqg8SB2vLwf2PUWnviPZ1D7oDlld5/cdlFGCSZcNBGD Onq+Y4os/tlzK2A3JbJ29V82jjvy6WmPNIdtOsOQ2puw18Khk9eyi9/l78Id0jr50NdZ3zvpjg+U ej+yLzsHbe/IEyfcXTl03npfPn1X5paLWJ1dz87mj1IDyUU/ovj2FGxPqmdPqUmcR1yBuAJxBTqr AgXF0p01een3rV6Je0ufQmLIyTj13FbYqO98A1cuHYOdM3+FeVevMcc+AZdOPJoaG4ER52DyTfn4 3YXP4QPkJ78v6uNujWKOeupFi/w3fPymaYDPPRXjJp+OiU9NxpVXW0doW7CxcBhVINMHZLv/svH2 OlNpQuOzbTpdAexN2Gvt45P1xmx/betWWRoN/eiqZHRMkfWgjTpZ5+qDKbk5M4bMti7bmDaP5hab Hi6sjc/kQ3smLsb17cun9/FTT17XWutE5pqz9qWdNq51PYLwLhx1nMlNHtccJq7tRx/O2m7rZC3D 1tPHp6c9zEwOxhIf6ijbPNruwri4XDr60qZnyowta1un/W0b8ZzJE89xBeIKxBWIKxCuAoPOPt0A 38K6zfLtzGbs2y1z69i7cTtw9SScWzUchebrkwfNqa2C27N9P4Z+8VxMf9b4/2qfaTpdulYekcbd fAmOVSo3twJ4xUKMrumHTx7dj2PLTsOoitNw4iAeoU1g15btyMGFd73RY0O3VaDth+a2abj6L+Jp 47qtZ2pFjLYF4TUO2TadoQOYaExQ+4js0rdJricu5IObNBp8dFWOQXG1TWQZvmYoar6a2+bUNsYl v6xpp843Eyf85NE6rRcOOw/R2XjRcWgb+ckhM2XiM83ks3G2nmvh13Ep///svQt8VNW1P76QJCS8 NATQAiWAoEBraEMVrMIVpV5sa6HWtj6gf6n1UbU++lHRetvePn7Xon5apbZVbAsXqdpbvS2+pYJe HxVFUKGCD17xgRaQV5AMecB/rzP5JmtW9j5zzswkmYS9+UzW67see82c5CzOmRnYdRwtwx+U7fBl HT+wwEt7GJ5t8EEMUBmD+bCFGNIHeNggM5U4bZc25AWGKXgZLw7PMfGAn8zJ8ZGX7ZBB4ROHuuJj L9KOnKDAIJ+WWS/9ZZ1ajxie+g74DvgO+A5E70DXwcfSmbf0of878Q80u+9v6I6zlzd+vUkB8TXQ /scfQ7RgSWB7jfpQ3eyH6OnV1bTqyruNbg796tQ3afCvR5nv86yz6JJ1NN3pWjyYvvo/RzYVZ4+d CPIWYYZk9GDxPlAjsjTovDNo3Li36A5TA9cx9y4zHPNKrKEpI8rpFT91JvtxcPzkk8Ww+Uuf6DWf XDb3R2OaLRE4mzProAcPmYdU5iXVPL/OWccP8KB8TDGPB2QXHbVz585fGHybr+XLl9PkyZNb5MVJ HAzpZBcunR52UFcel97lB31U6orv0uu46XAuO+v1kifbLj/4wA6q9SxrGzBh1OWj9XFlV07EcVH4 wc6y5G12G0b7pJMRV1LtE2bTWMig8JWy5GGPS3UMyEz1wvBmoxorZRkTr1lXfPYDXsYI09tsUWNo nJZ1DV72HfAdOLg68MQTT1BxcXHw6NGjR0BLSkqoW7duVFRURIWFhVRgPlyGf3fwo6GhgerMbaH8 ePjhh2n69OmdumENiYS5WnkIlRTz+zPVqq81tiIqMme0tdW11LVXUXCyW1udoIbCYuPTjLfpmq0W zhHbgrSqkvkKTQ18+u1XPncgm2OwtLR0ltkbvwGZ77jm+8HDKGz7G3Esg2cKnvU8gPIDevDQa2qg TT7MB4uHvair5VlZS09O6lrsL+2Sd/l0Wj3/suaFk9JOu9HGjWWy33zrDe/BVpNL3xmfUzyPcm+2 nkh7PvFhtYbZcrGH1o6fixo7+vObix74GL4DvgO+A64OdDUDeYnLWGAGzkZbkRk4sYp6iWmzyd5S B7yVOmJbsRalrQYLzKs6fgfizmrAh81ken7LuEt8NTIXC8WieFdMaQcPX5dP3uptJ2hRi+UTUH64 YrA+zBY1jwvniu/ScxxXPTKHC5NuvzKGjXfFzRYLfx2fZalj3jY0uPSIa6PwkfGBY51ND7uNtjZe 5sTzKKm0Z8LHrZ9zaB+WtQ44mz5dnVF9bHm5N6y3vV6QN2r8XOKj5JTPK3jU4KnvgO+A74DvgO+A 70CH7wDmL94IZjCpi7NB+EfyydXQ6SpWFuPiXb6yGZE20xYgnFCGnVS6Tu5c+ih1h+XluHgwjhdk zQfGGD/i5pV4rgH1xEgZQKPE4fhYEh81Z1wf9BQUuSGD2vSoiTHgkR/4OBS+Mh77syxpIJgfLjzs Nh9pS8e78ko/YFgXpR7pm6mPjsE1yAfXoWOzHXrtn6ks9yvjM88LVMaXPrZ6pI/EyvhSb4vhyi3r 8LzvgO+A74DvQOfsQHXValq5fjOtX7mSqqrFHhPVVF1dTYmE+xN7BTomW0/rVi6jd/a0RmxHKdVV 9OKL60M+f9jh13HVcuaSu9D65hNpiWoeRlO1LSWXf0uk0cS5vdYawKKUG5LFaF7iLGEClfRxYdpc L0/eJM+FaBnFufSwa2rDR9VxLBtW5mC7PGmFzeYXVRcWAzZNdWwpSz6dH9tteK1LJyNPpjj4Z1OP fF5Qh6Y6vs0ua9H4dDbEA07L0INmYrf5aF06OV3+qP4cR2OlDjZQmVc+X1IPHlT7st6mAz7MbvOz 6XQMjdGyzO153wHfAd8B34HGDuxZR78sX0xfqrqEju6Z+67UvvEc/erElZbAvenMjefRkb0sphyo 1iyooAu7LaLz/zSVPrx9O/3XhAJaOudqOuWKuc3RJ91Bu5deRLkrIUH/O/Z4SrywnX40vrQ5Twxu 5U0VNJbm04FrKyN5Vb+9gMaP70bbD1xrvqH0oFi2+YnnLta75i+pD8Nl3MC4QycKlgm1zrZR4PWG WC91wIGG2YA5aKg8uc32ZJFjRY2Ry7yt+WR1lDrDehDneQmLY7PlW3/yrR5bz9LpWvP5Spfb230H fAd8B3wH2qgDPQfR2c9/g8paYeDkHRSNPJ6u2vg5opJDaNOv/kB/3TmRrvrJCGowX79SFHPaq129 hH41ieiqbac0vcfU1aUjRk2nsg21lCibxmAozAAAIABJREFURBNHltIb86eZgXM3PbZuN03hSTex g954e7v5xtDcrt7H8KYzj3nU9P+lqoJBkQMUdu9vsPta5Upb5CLaH4j5DBQzFijrwetqXXqNC5Xj 3l6LQmVQm85VnMYyTus4NvxtNpm7w/M8+PGJqzwBd22KsXi4MFH1UQdOjoeccXxcdXCMqPt1xXDp c1mnK0dUfaa9ytQvSl351B+uN9/qidJDjWnN50vn8rLvgO+A74DvQDt1ILGFnr70/+gD8/2bNeaq 5O1nLKLHb7gr+BqS23++ynxqrVmJd2jB5IX0+K8fCPSzJz8S4Nm0y9xOenvj15b87aF/sSoZZ/Kf 6d4zzNeZVD5NteYDh4rMBwZ1Ky6gwsO6B3xJ4yfg2vxfMfl/ecMrydz1/6K/VN5Fy9ZU0QOTXjfR X6df9V1I6/mW2cRqmtFlKi2zfD3KwFNuoFu+cix95ZZbaGzpZlowcxFduGhecuDkIotLaeQxR1Ly Y4920IM/m9Z4DjeG5iytYkSw3njwZ03ndjPmLKXga0rNzawr77mqCd+lyxiab75Ghte+4Gfyx9aV 99DJjefBP3vQ3AK7+XGadvJNtJnN9evpB2Oa/V68aQbNeXEHvff0b+j/PbkpCPDG/Kto2g/m0A9O Tp5Lc4xg7VhNV41J6kpGXUw0qVtSb362rLeKfnbyNFq6lSEJevCqMTRj/uoAv+PFOTTjphcDvvmH e2/NmHbhMD9FSY4ZC5R9XP4SEyW2FRN36LQGsShlcbYNQCdxMoxLLzGdhsfJd6fZUJqNHGz7TdMO b/Yd8B3wHfAd8B3wHcjrDjTQtle3U/AWx7p6+viZKqoqn0QXvDiBPr71edoUzFINVGMwrz1VRjPX nknDXl1PL772sRmcNtN9p75En3nxYpq1agK9OfNBWs9TGcd51Qyg555OFy85wXyHZ3K1eKejw/+z 102mHnc+S4uWbqa3fvW/tOGkcTR+dDn9e/Adn0fSuaaGIXyVtHgQXfrY1TTM8oG5BaUjqXJkOY2s rKR+NR/SMgP/t08d3lhJKll/z+U09f7P06aaOtq+6od0xSlD6MHN9ZRYP59GTX2KlmzaTXXbV1Hf K06h6x+vosQbC2nsua8F+potc2k6raLdZs8pq/4NumDsufSddTV04P1F9KOpF9CqPiPo8Kdm0cs8 AK57lm5ctYr+9o/3jbCV7pu1io4aVkp7t75KL7y3MwhVt28jLbrxCiq/cROtXXSlifEA7TAD7+PX VdDSc5+hmrrd9MxtU4k+So669nrradTARfTnF3jU3UR/vHUVLfzbiuA9oC/+8Qrq+7lPBrnwI9Le AG5bmm5+wvzlqkr6p8O6Yjj1cW+vdQYKMfAGdOGtuqmQWrzJd8B3wHfAd8B3wHfAd8B3wHcgww7w 1xZ+ir514XAqSWykHuKmzTrzhSpfveck6l9cS6WDzTUzc19qQ9X7xOPRhj/+nbbV7DBcPTXUcepk nGlfG+r+GhZGufx7DaVvPVVBcybdTxtoIH3rwwoOSiX9ktNlmaHJb+UspfFTJgS2KD+KzPewYtVv XUn/8/c6OuOc0fTk7IU0/YfrqNxciaVjvkx3mHSvvVtNQ1/9G9H0S2hieS/TiWPoojsm0ajlH9Jl e14Q+jF0osHvQuBGWl/1T1pk+MP/cDOtr3nLcB+Z73wtpy9dSPTIiioaWvUCTbpwKm18bCVtPb2I bq04n37aj+jtwD95f27dvt1UMXsFXTSu3FzUHRpYCuqr6AnzttRZm46nYrOfYyedTHRFYKK3n7TV u42u+fqF9PVHVtHPh1bRxqnTadKiF2jtjgn017mT6Nu3DEg6N/58/5/p95bi0HaCnrd05jjzl8Tq OBnJza+sjNxbOLk2i8LZrjGwtQjmFb4DvgO+A74DvgO+A74DvgO+Ax2mAzxQFu8PrpJxzbW7dpuf vemor4ymPmbQHP3NIhrg/LJP9khdkfw/cxh1z/aMvuRQGmNSP792C51Znhyyat59ks49l2i7GTr5 OmHfnqmFBzesmqHPGJpGb95+hTHU7TFXcbsXNen3rUrdF0s1u/jK4lT6wtQv0SfpVDr1rO50VEkB ffKr19PUO+6k7rv30k8W/owWDvwhzRttZtirfhH6gUacO1j1u+g1qqDT0ZRCrrTxpl5HvQOO/ypV TP0T3UHv0/nXz6MBh8+kP951Oy2b+h26Tb2vNsreGitpaxI2U4XNX9pmqzsKxubXpMv29lpdgNys tnFStmuMDddUYEdjXO/NdOlzsb9cxOYYYXFgA3XVnc7u8gvTc0wd16bjGBoXFtdlyyRGXB9b/bYY Nhz2acO79uTSh8VAbhcGdlts7aNlm08UXa7i6Fzp4qaz63haztZfx0snu/JpvZbTxc2FnXPikYt4 UWIgn6RR/DQG/lqfK5njh6109jDfTGxh+dCLMEwmOcN8wnKlqwf2sPjpbGH50/lGsSM+KPugbqkL 00fJ4zFt24GS0SPoMNpN2+rK6Khxw+mosUeY92tGr8Hpz+8hnbSKxi2eZobF1+kPP38zGTS4hbU+ +V7PQJOgzeveIctbOlOLKDiSZtw2iW497RJ6PHgzKMzFZnDsRSeeb2x/epqCO4m3Lqc/myFyUN8S GnLiNKJb/0pvBG/k3ExP/fYpqhjUl4aMPY1o7lS6Z6W5zfieK4ILjYc2jaDJ2L1GTzIj5yLaUPtJ GjduHI0bO4LMzEkDxk6mikU30q10Ih0/4Bj6wvRFNOvGRfT1U4ejKDvF1Fk8lKaZ23nnPMLvy6ym xXea93TyJGyWq17qN5bOrVhIP5rbmyaNLadjvzCCbp11K5188QnBe1rrN6+k+fMfpy3mDuHwvdXT 1vXraUfyja2U2Gpuxd4adM1c5N5B69dvbfoPiaCgtvsh/8Dw7CXnL22zVRUFY/Nr0kUdOmVhTc6G kQVIPfPSFuYvcTqGy0/j8l7O9w8cwfss9R+29m4s14PaUItNB1tHoHHqx9718+LS52r/skbOpfNL e5ScHMOv/OtAWz8v8nVje121Zoc4n3xkkgv++njIJFZcn/bI6aqxPZ9HW03p6pF2m3++6mTd8nhx 6fN1H52nroLmkWlw8sZV3lvqJ7sWNt7Sar6TsE/jzosH01mLK+mtafOTHzB0xD1k7kpNLhGnURPk KJLvv3T4v3zV36jux6fTSZWDacq95pNqb32Cnlz5MZWMHkWD6U26o+mDhNbQlBHl9EraqZOo8vIH aNFPiU4b3jv4u9977CxzebF3UFrlJfPotupzqTf/x2H/iTRi3go658hi6lV5IS2Z/S8aVcL/oTiQ /jB+Hv3yHPPhQ8ecTyv+dD3NHjucbvznkWTumDW31ybf08njXzfuXPExdNeKefSnif2T/8FSeBat 4d70O4bON7fjTv/OvwX9+OxU410x2wygyWmde16WnCGD/pehX3xF0/iR+WKUqUtuo0UzK0zc3vTD pezAenLWa5LSv507yST9Bo0waQZ+9t8MehKdYW7b5ZX48FmaOfNa2mCGybC9meu3NG/4cLprDd9K TbRm3hAacseagK9eezcNHz4vObgHmlb/oU++IPPsJecv6Lkgl14WKzFSH8rbnFgHPXhNeVhlHVPN 85EIPXim4PkVA55fN8xDp+monTt3/sLY23wtX76cJk+ebM3Lv/Dl4j8GWPhjAJkp8BIn9cDijwoo 610+0CO2jAFe2iQ+XXxgOY6MgbhMZQzooQMFDnYdS+NgZz0W67QMG1NpY1njoWPKS+KRL2lx7wl2 pvCRcaC36eALG/yj6oGz7cuVFz6a2nIjLmyo0+YrbfCTOMSADnjoIcMOPcuwIS5s0Esfmw52xEIc 6G0ysExhzzSvrAkxbPFlLuax4IM4YfUAC1/pAx3TqHrg2CeTvPBjKmOxnG4hH+PkvhAHOpYlNl1c bQ/zRQ72iZrXFk/GkbF0LZBteMSFTdYTtweIgXyIBVlTG95Vj803k/g6jpRzWQ/24Yova5d5pZ59 o8ZBDPaXPPJrHWTYJUUNwCCmTc9+wDEPDPNR1xNPPEHFxcXBo0ePHgEtKSmhbt26UVFRERUWFlKB eY8c5+FHQ0ODeQ9eXfB4+OGHafr06VFTHYS4Wqqp3m++AgXvtYzbgjj+5kONqhuIP/02k1VfvYN2 mPmwuKCEepl65Uok+BIev0ak1lzEM3rzDS/UC4b6atps5q4B/cy9qdWr6aLeFXT82ho6b6RyDMIk qLravCO2F78vNIer3sQ1Rek9cIYW9cZJG2tvcQITZXMMlpaWXmeyrTUPfsMwT/g2yteD9zfa2C4f 0DPVPJ+cQw+eqe1h1E165oPFw2GuFieVS8tsk9Oa5KUfeJs/bO1G+Zcs/yLHI0ohtl/8YXGkjfmw hdi6HhmDbTKOtEm9LY+MK3PJGNDDX9oQX+okHry0I46NAs8UvA0HnYzL+Kj1RI2PPJq68qJmHd+l 13EzlXU9Mo60oT82u9RpXsbAXoDRMus1XuaVNqlHPEkl1pZHYtPxMlbcvMDLGFwP9MgNO+QwCqyM I3Vyv3H1nFf6yzpkLOZ5SZ3LT8aIwiOmLT7ysg37B40S24bhmHjAjho4to4PGRQ+Nqrj2DBSF4aX NuZ5cQ1xlowRxTcML22oR9YCu9RpHhiupTXr4TzIpWuQMjCoh2VeLr30lbwLjz1Ku/TTPOpgPXxB WYc4zMul9ZARj2W/8qkDRWaoynTg5H3E8e+a8cDJmQp6lVK/0lLrsJb8TwlGpa4CM2w2DZxsqt9E s/onr5h2MQMn3fEMTbcOnAw2vrkeODlsAce1DblsUvUyPuqKtbeoQXOGS/cHQ/9i0HgtpyssMj7T /1DgBLrodLIsysXLjel40tapefnHRm80zKaxLjkXMVyxWZ9J/Ex8wmpoLVucOjvKH/ywPeEkJtf9 5JzoD/OyBslnmhfxJZWxbDlsOumTCS9jhvVS4pDHpoOtNWkmeeP62HqB10Nr7U3WKPO3dt64+5F1 xvVtDXxYPbKPrZHbFjOsHtji1gU/W75sdK64Lr0tl2svLr2MESeP9PO870BOOmBunb3b/H2/OyfB 8ixIfu8tbH6yzV/Aw8YyeN14mz4Mn+Kf6dCJAlOCOQQUKH1kgVLvCOHVbdUB/iPFf8x4SZ5l6EFZ 11oLOTryH81c1i6fCxnXpc/F88LPgczFMXP5vCC2LU8u6s+3GHiusO98q6+t6nE9363Zl7DYYTZX T9gnl8eCK08+613PYz7V3FGeI9TJvQMP6np9uvT51P+Do5YEVb34AR02digdmuaMurpqNb1dX0aH 7vqQCkaMoN1rNlHZsO707ocFNO6Y8oOjXX6X7dkBnsfC5i9p4zoxv8maNUba0vJxbq+1JU+bwACS E0zL4qGPEiMvMfijkG1xceIwNgwfZotSJ/vzHzP8QbNR6BAvbs4oeNQQBYs6MqVhObSNZa2Lkjeu j8azjJ7IfGF6HQN+Lj3sTBFX6phHDWExwmyIJzEcU8rAxKU6BuIy1YuxGq8xuZB1DtSkY2dSj46N mHH18ItKbfFd9Ws9y7bnQ+e25dCYMFnnDcNKW9S82IdtL7YYYfXY8LKmKHzc+HHxugb2t+0duLjx 4+KRB5T9bYtr5IfLDp90duByRfV+0UtJwWeTs633lU2tee+7Zx39suy39Kb+MJ7q9+i+Lz1E7/Ob GdOsNQsqaOYDL9MjM8fSnf9YRhXjr6CXVzxA4ysWUPIjZ9IE8GbfgfQdaHnC0+yDX5SgbImCD8M0 R4/Apfl/mZQIssgUgxDCCmN/aZe8CJHfrPwDJnlZNf+it/3BkHrpK3kZJyov/ZFX6jgO9MzLP0RS z7aoS8aXPPvb4kuM5IGVvYlagwsnY8lcjGcZFLltGGkLHCL8iJI3LIysA3WG4ePYdGzsj2NIXuaV esZJG8tyhcUHLmp/ZF5bTlccWQNyxqGZ5uUcqFPXAL2sAxibTeJs9cAXOYGJq9d50tXiii/jROVR M/AcW8Znfbp64BuV2nIij7RlmlfWL3lXfRIjecbb6pE68OznWjKm5DPBIx/7ypxSr206j6xB8hoH WWIkz3aZl228NAb6wGj54cK79DIE50d8Fx41SqyMEZV3xY+rj5rP40I60HMQnf38N6isp8KUFJmv QymJ9OE3R4yaTmUbailRNokmVg6jd813d9bW7qOKK08wn7Xql+9ATjoQd1YD3v0HxfzaNZWF2SMX HmfoDAuKYlC8Cyvt4OHr8sk7Pf7gcGGSt8koXuNcWI1LJ8eN78qLODaKGkCB0XK62BIPHhQxo9Aw H5vNptO1aoyWUVccfRxsuviwR6W23FF1nMOGTZdb+kjeFU9jEN+ljxJH+oad8EmcKy7qcdl1DOBt eq2zyThRDYuja5Fx4vI6VjpZxkeNoC6b1msZ/rbcUgc/UOln4zVOy9LHZoNOU+mneWBZL3mbHEfn wrIei/OFvX46ez3cB71H9MZFXXiX3pXDhrfpZB02O3SgwGs5Uz38PM2wA4kt9PSly+nzj3yNyos/ pue+v4CeX4Avhezd9DUplFhNM0r+gy6tXkTj1YA68JQb6JZPl1D3ybdQWWk5jVj2Iyr4ZHeae1Tj d3lkWJp38x2I2QHMX+yGGUzq4oSDfySfXA2drmJlMS7e5SubEWkzHQ0kTxJcf1jyeU8dvf587m1r 1HYwPV+81450THWEeg+m109rHH86Zi77mYvXT2euR/fey74D8TvQQNte3U4J8yUU2x96mJ5/ehjN fG8y0ctP07xpG4LvnAhiFg+iSx+7moZZPjC1oHQkVQaXNMsDaL9xlQEtHxC/Gu/hO5CmA3LmklCt d81gGidjSJ79o2Ij3REgg0fhZXK5Gc1LnCuu9HFhOqy+PU6KXTlxwuGy25ocB2vzj6LjHJnUFiV2 R8C49u7Sh+0pl89Xaz0vuaoxV3HC+plLm65Xy7nMlWmsfKwp071k6pfJcefKlct+5iJWLmJgr7mI lYsYsp5cPneI6+nB2IEG2vDov6jvNSdR/2LzNfPjR1AP2iAaUUrjp0wQsmd9B9qlA7b5iecu1rvm L6kPw2W8oTgfJMRJZEFIqnW2jdqwwGl/YJmG2STO81l2gP/A5/KPfJblpLjnc20phbaC4Nq7S98K JThD5kMNzuK8wXegFTrgX/Ot0NQ2CumfuzZqdKdPU0fbXiTqfXhJp9+p32Cn6wDmLlDMWKDQ2zYO jM0WWRd36LQVZNO5itNYxmkdFw9/my3y5jzQd8B3wHfAd8B3wHfAd8B3wHcgNx0ophFnF9KG21cR f5Dte4+9Qh8baq55Nq4EbV73TmCDxlPfgTbsAOanKCkxY4Gyj8tfYqLEtmJy9Z5OHVwWZ9sAdBIn Y7j0EuN53wHfAd8B3wHfAd8B3wHfAd+BNuhAQfCetE9+cyL1nb2EftN3JdHgQpNXXPVMrKEpI8bS b6oP0AT1QUJtUKBP4TuQbn7C/OXqlPRPh3XFcOpba+iUCXkDuvBW3ZRM3lo8vz+Eb9fRy6XXuFzK ucppi8M6Xra9xtmDLTb8kSMXeRATNJu8qAt7D4uFfFFoNnGy8Y1SWxRMWA1htiix2wvDdfPCc53r OsL6gtxR8ofFyXXNrniol3uVq3pyFcdVc7b6qPUBB8p5mcfSry/YtB741qKyvtbIgfigyOHab1w9 4nnqO9BmHSgeSt/7aGgyXc9P0fnbRlJNdR2V9FKfGFRcSass54ZtVqdPdLB3oOVgktqR5j9ILWez VKT9TlSNiSXneuh0bRabZLvGwBar8HwFt/XJQ2v3AfvRJw+5yqvjajlXeXQcnSedrP29bO8AXi92 a/5qUbd+HbR2xTqflls7f9z4+V5f3P20Nl73S8qSb+068iG+a79x9fmwF1+D7wDfUFvSq/mmWt8R 34E86UDYTBU2f2mbbTtRMDa/Jl22Q6cuQG5W2zgp2zXGhmsqsCMx/MeTF05gmZc6+ccVvLQznhd0 zCMWdCzbeKljP17QJaVkLNbpGBILH+SFbxyKGPCRsWCDDhTYbChiI4aMDRt0oMCmo/AHlf7QcQzo WQee9ZCBBZUYxtkWsNom9TJOHD2w7C95zgUZeSUGNlteqdNxYGN/GQ965NLxw/DAsi/ixMUjr43K +DKHDcu6MDxsqBM0XSyN03F0XuAZBx4YyIjBeq1jGXbYGOdaNix08EEcqYcOGKZsl3qJZzvboNM8 /JnyQhxbTPiCSjzzyMG8XrDJ+MDApnPCzjSdDVjEh4zYUg8dY6LoEUtTWxzoOK7k4at1kNkOHlTq UCdsoOn0yOup74DvgO+A70DsDoTNX9pmC84YzGygNpxTF3Xo5OCyIAS06Ww2V3HsHxbD5YcceUXl H2ZZGPSSsp3/0Mo/stouMbBJH7ZDjzis46Vx+KOubcC54gTBYvxAPLikywscU+0rbel47Rs1L3C6 fzqfqz+2vIyVeImRep3DJktftqNem94WGzhQ5IAMH8jaLmXmgWeqF2xSHxZX2iQv/SUvMeBBgZOy jZc69tEy4oBqO8thKwwvbZJHPJsONkklDjwocFqGHlTbIeM5hAx8GJVY8KDwY5mXTS9fS1HsHMdV Zzp/9tVL+oAHBZblsIU9wA8UPvAHjvXQMQ+9zQ82xunlwrv02h+yC8+52abt8NMUtQIPyjjJww/x 4ZdOD7unvgP524EG+mDlRio4aij16xn/Smh11Wp6u76MDt31IRWMGEG712yismHd6d0PC2jcMeX5 u21fWb52QJ+sQeY/avIPG/S8D9ZDBmW9XBIj9aF81E+vlYWFBnQY4S+Ll7zDLaUhLkyH1es/tFE2 komPjpuLGDpmFDksr+2EJErMKJiwvGzjB+fPdLEvHjIG4obll/i4PHKG1R41d1Rc3BrD8GE52abt Wg6LzTYXPkrf0sXOxO6qh2NxTTY767Rey2G1MBavD50jrA9xc4TVEGaTeXR9YX6wSX/o4tJMYrBP HD/g8VxwjdAxlXpZv84BH4mRvMZLWza8K266erLJ6X19B/K5A+tv/i3NvnmjpcQ6WvGFR+n5f9ZY bOlVaxZU0MwHXqZHZo6lO/+xjCrGX0Evr3iAxlcsoB3p3T3Cd0B3QJ/csmybvzQOcVx62GPRqENn lKB6E1rmGLJ4ydvi2/xtOK9rgw7wyQVOUnOdLpOTzVzXgHjYo+skCzhJceIFKm1ReeSVNJ0v8oGm w3t7sgPoF6jsC+vwHEh9a/Kcj/O29cL+QcPyoyetWSfH5jwdcaE/XDv2ANoR95Npzb4PmXbO++V9 B+rfodv7/o7WJ5KVDjj3DPr2eYMCoerXd6UMoMWDiQqKMtvREaOmUxnVUqJsEk2sHEbTqTfV1u6j iitPoNLMQnqvg68D6U4o9B9ajddyug5Gxke9vVYn5AS66HSyLMrFyzw6nrS1O9+aJ1/ZbI7/6Ova Mjn50XG0jBoRW+dkO2zA2qgrLrCIoeO79OwHG2LYqCsv8rjsiOWySz14UPhKChvySpvmGetaiKPt Lr3GhcmZ5A2LF8WGnFH6EiWeC6P7o2Xph5psOludNrz0ZT4sH+xMbfFZH2Wxb5Q8YTlgSxfHVk9Y H3S8sFrD4tjyunRx49jw0KEvsm62QS95Vz1heu2v82pfjdf2XMu6Hlcfcp3Xx2vdDvDzyI/9+/e3 eMDGFYAHtnWrat/oy773iPk+zjq6f9AcGrv4Qhr55vO0lI6nsz77Dt33E76q+RDNXl1Jly/4HNWL UnetXEZ3n/pS8F2eR8/7Jk07/XCixGqaUfIfdGn1IhqvvlZl4Ck30C2fLqHuk2+hstJyGrHsR1Tw ye4096gyEdWznb0DOLYyPAbdJ4upVzkxiwEvZfC61TY9+9v02jf4yqEWyggKFBgB2lSI9JEFSn2U eHmBCfvjHmaTxeMPNuv4BQZq00Nni82+sNviSHuQxPFD4hDHAXWqdQzUxQ6Sl/GlnnHSxnKUFTev xHP8KDmlD/BSJ+PwnjRGyxLPvG3J+C6e/Wyxo+jRe1kv/GCTeW021sklY9l8JTZbPm78bPDa11a7 xEiesegn82zDknptAyYd1blkfJuvC49a5HNo85c6+LAOeWV8Fy/xMh7wTMEDi1ySMgZL4uEDCh+N ga+kEiN5iYnCa1+WecXVu3JlE4f7ka4e9ExiXbV4fefqAL82bA+cBHft2jUYSOVrqHN1IHU3lT+c SP/4yzM08blzqWJ4Mb373Hbatm8vFZ1dSV+88hV6tGY8XXzdp8w3du5vdqzfTPeZgfMzL15MJ5a8 TrMrHqT1711ARxYPoksfu5qGqW9bYceC0pFUGVzSLA/i9BtXGdDyAQHxPw6iDtiOP9ZlcQzyH6Cw +UvauNPNf1yb+64xzZYIXJwrnSg2QtgUCIZKXTz0KeCOIuAXra5X6yFryn7QpYsRhoWvLZbUgQd1 +Wk7cC5qw0fVcUwbVuZiO058tF7KzNti2XTwC7MBo6nNJ4pOY7Ss80hZYl28C59OL+NJLPPSJnlt k34a58JqXDay9rXllBjJy9pdvMRL3pYnjs6FlXWkyyftkpcxXHlseJtOx5JyGF7aXDxiSbuuV9u0 HTFAbXjtAwyozVfaJK9jad8oWFeMMD1s+vehzqfrgSypzSeqLmocHU/LiBNXDz9PW68DeE6Y4gS3 oaGhiWcdFvOwQdcZaVGf7lRkrtOUDulNRU1nzvxBQUXU+9ACKux2GB3ai++pbbz/1nANVe/TTkM3 /PHvtK2G35FZTw11hhSX0vgpEwzjl++AvQNZHIN61pIJMHeBsi0KPgwj46flmw6dtMjkdJwOFlYY b1LaJZ8urrd3oA7IkyIcOJmWH+d/2HOZN9N6vZ/vgH8d5vY14PvZ3M84vw+bvTznOxCvAzxI8t9u DJNM8TjkkEOC/wjG33Zg5CAaL1vHQieHxtSa5e200lK7a7cRe9NRXxlNfaiBRn+ziAaUSITnfQfs HcjiGJQDpT146iwGfNhMpuc3V9xcAJbiAAAgAElEQVS0+jhDZ1gwFIviXVhpBw9fl0+n1OMXdr5v Did8ceqNg023/zix4mCj5M1k7+nient+diCXz3UuX4f51i3eWy57FWV/nbmfUfYvMb4Xshueb40O 8BCJW2dxFbO+vj7Q1dXVNR3/GD7Zxnp+dOpV12A+3qeezHZbroTpwb7aFvqS0SPoMHqdttWV0fgT e5sLnbVUG5x1J2jzui3Ue/hgUm/pbBHDKw6+DrTBMYj5i5uLGUzq4jQd/pF8cvXpta5iZTEu3uUr mxFpMx6U+w7wSc7BeqJzMO8996+k/I7on+voz4/vVfReeaTvQEfrAB/fPEhi4ARlnRwwa2trad++ feaTVc0g1fjoaHuNVW+vQXTc1+vooRFz6MnVieADUQq7JSMMOP2zRLc+QbPPeI74I4V4rizgn+Zj bM9aXElvTZtPs/vOodlH3EPvVhtjYg1NGVFOr+xJ+vufvgOyAzk6BuXMlRJeCoZ3zWAuf+Xu9Ne4 QM7VlU4ZXBYqN6N5iZP+kpc+Uu953wHfAd8B3wHfAd8B3wHfgRx2gO9kwEkv87iiCT3bcOsf6/gK Jw+dnX8V04m/u5yOu6mWupr3bnY95gL6XuOmS0aOp1kfVlJNfVfzQUJdafIrlze149DKE+n7246j mur9VNSr2Fh5VdIq00e/fAdsHcCxxv/Jk8UxaJuf+EXHeteLT+rDcLayI+niDp0oWAbXOttGgdcb Yr3UAQcaZgPGU98B3wHfAd8B3wHfAd8B34EsO1BQUEB79+4NovAJb2FhYXCFk3lePHDiSigPoDxw 7tq1iwYOHBjYO/uPouDDgiy7NF/MWeI8oza2XhYfr/IdsHSgFY9BzGegmLFAWQ9eV+bSa1yoHPf2 WhQqg9p0ruI0lnFax7Hhb7PJ3O3G4xewLsCl17hcyrnKaYvDOps+av2zy36SFhoFo4Nk4qNjtKc8 99Twl3Y6O9c+cOC9sbeQiU/UJFFq1rEy8dExpKz3p2WJjcPnKk6cnO2JHX7FUVmnRwxQW0Bt0zL7 QAeaaRybX651/Hsp299N2frLPeX6+JKxw/h8O17aqw9hPcpXG5/w1tTU0Mcff9x0+yzfRsuPRCIR ULbxYLpz507asmVLcI5w6KGH5uuWfF2+Ax2qA1keg5ifouwZJ6Kg7OPyl5gosa0Y5//LWNHRlbI4 2wagkzgZ3aWXmLzk+X/+OtPCfnjwBN+Z9tdee7lwced6nbRXH9Plff/9s9NBvD0POsAD5brb3mqq RMtNhjSM9tNyGveszDwszvrox1nFyLVze/yeybeBM9c97ezx+ErmJz7xCaqqqgquYvKg2aNHD+IT Yb7qiaubfIWTbfyhQyNHjgxuw+3UvanfQ+tf2E6HT2ibD/+prlpNb9eX0aG7PqSCESNo95pNVDas O737YQGNO6a8U7f6YN9clsdguvkp3cmn9E+Hjf1UtdbQKQvhDejCW3VTMnlb8rgiKIczqZODG3hp R63QsYxY0LFs46XOFgexGKdjsA3+oMiLWJlQfRIm/wcfJ2fQgUo9eM6tY9nqQQy2SV8b1qVDHsRC HClLnuNAZh545l0L/+uuTwihd/lJPU7sQDFcSVny0lfzwLEecTRGyrJO7AE6UKkHzzHYLmUZFzxi sJwOyxhZP8tY0Os9Qc842FjHPGzQI5aNAgsb/KUv4gIDH2Bg13rGQ8d8pnj2zdclB0IeOFnmJfVR apf4bOJEyeXC4HcAqPw9AB37Qs865mGTesZpPetcy3W8QC+PIehkLNilDTqJi8Lr13MUHxcGPYAd PYKsadz6JZ5jYc9SDx3bXXq22ZY8ftmOY9iGzScd/+3v06cPFRUV0euvvx7cOstDZ7dujZ+aY4rl q558pbN///702c9+NqB89bNTr8SHdP+0R+n0qstpdBt85OyaBRV0YbdFdP6fptKHNy2mG6fcSIse m0JTT9tH2w/8kEo7dbMP7s1leQzqeUs3M878JbE6TkZyrodO12ZRONs1BraMNpBPTnKYk3VBLynb MQBKXuqkHr7aDj1TuTSOZSxpA++KA590FCcIrhMDtksbZNaBT5cjzK5jQGbKS+a2xQGObfCVPOqU Nmlnnpe2J7WpP/lERp7AsJVl1wlOqndS4hMYnOBJO/Q2m8SB1zgtAwdqq5Prxp7kHuATh7riu2Lo elnGQi8gM7XhcTIobZKX/uC1neVMl4wFHhQxpWzjpY59ION1ne71j4FPXm1E7kwpYoG2d5w4+aP2 Q/bXduxrnZRtPH7PpHu+sJew4wXHJLBM5fEpfSXPOC2zLsrCsaSxvFde6fYFnMZKfRBI/dD1alnB W+yP8by0H2RQxNEy9KA4/qQMPt8pf3AQP0aNGkW9evWitWvX0u7du4Phk2+77d69ezCUHnPMMTRm zJjgKii/x7PTr4Ku1D34mKC22ekRo6ZT2QZzNblsEk2sHEbvmu/7rK3dRxVXnuAHzrZ5CtotS5bH YPPJfssdpA4KqW9v1LaW3i3nNxsmVJft0KmLlJvVNi6E7Rpjw4UW3VmMelCMsq9MfHTcXMRATJwM 6JMJ1ksd8xIrbYglKfCSSruNR3xpQx7YIAOj9SxrDLBMbTbEkLhc8bbYthp0PtfJn8ZpOZ2fPJFl Xp7E6lgsAy+pDSd1fEKnV6Z90HF4f3xCyIt5uV/Ja7+oMuJLKn1tOWw66aN5Fx77kni8VtA/yMBE Ha6AzxWVVyc5JmRN0+UDHjjImsIelWJQ5ji8IMPf1U/Yo1D9XETx0RgcV6xnnh9Rlm1oas3jDnt1 9U3rIUfZiw0TtQ/a19VPl95WJ/aqY3cUmW/t4wffTjtkyBDq2bNn8P5OvvJZXFwcXAGVfEfZVy7r rH3nFZpb+SwF13YnHk3fuuff6RPFCXruu/fRB6M/Qdt/8ibtNEPiKS+eRZ87spgatq6j//n3R+md d4gKB5tKxh1H3/3deCpJrKYZJf9Bl1YvovHq6unAU26gWz5dQt0n30JlpeU0YtmPqOCT3WnuUWW5 3IqPlYcdaMVjUJ5c8R8L+QdD22ydYQx8QG04py7q0MnBZUEIaNPZbK7i2D8shssPOTxtow7gSiin Yx5/bG1/YNlm00Pnsme7FcS3xYENdQMDPeRMaC5iuPK2ZmxXznR6nNDZTlzT+UaxI77E5rIPGNr0 1QiZryPy2JetdvQPr/+7pv8pgOlhyubLOgxf0s6+Lr3EaR4DodTrOrQsseDjxHHV6dIjB+oA7oKF 5wYm9BO49qQ4XqIejy4c4si9uPZp+w+OsNcfYiIeXodaD7k9Kfqg+2TTYz/tWW+uc/PdT7gzit/D ecQRR9CePXuCq52cS9pznbvDxCsoo9NevJCOPLKG/tb3blrx2on05XFdqf7t3bThL0Snr5pBe2+5 m5b873v0uWsG07NnP0ofnH0KXX7NCHp37j301zsab0UuHkSXPnY1DStuufOC0pFUGdxDWx4Y+42r DGj5gJZYr+lcHZDHWA6OQT1HQdbzF/TcTLZBBtVNlhhtc8pRh86wwdAZXBjgL4uXvICmsPBLUeaD kMurhbncD79YdW34AxInj46jZfyxxckDZFcOxgHDVMrSR+rDcNLHxss4bGeZF2oIBPPDpYc9LtV5 4/oznk92sFAfZKZ6D6zL1QCVLo48EeOTMClzHVhSH4YD3kURJ0ofbCfCOq7cH58kS1ljo8o6b1hc YKOcoEfNb8PpfaF/eO3Moh8HbhimMFwhVjrZhYM+U6rz5iqOK65Lj7wt+nNb0qL7CXyuKefBc2aL jeODbVGOM4m3xYMOOOwTeqZcT6avX8TTe3LpOR9szEddqD8KnrFY0k/206W31ab3hmMeOToCxTkD U77Vr3fv3sGwKb9KBRh9vtER9pdtjUUDBlPp6tfp6V9vovdMsOGFyYj124k+tfgsGj2gmKqGllBh wnwrZ/0OeudVos//cWRwc+6Q4z9J9ANUUErjp0yA4KnvQFMHcHzl4Bhs/gWXjM6ybf7SONTiwsMe i0YdOqME1ZvQMseQm5K8Lb7N34ZrFx2/EFy/bMNssli8qFiHWExteuhssaWPLY60y/yalzjE0Rgt 4w+s/OMLncSyzoWRNpuvjCN5jge8jMEY6JETsvS34VgHH5td5oTdhmdbumU7kWEfnOww76qbbRhu wDPFCY4eOtiGJW0yBtvTnUzK2hjPMpa0ST3sLurqA+MRx9UHWb/kZa6o+0Xv2NfWB1ccV15ZQ1xe x7TVI2O68HhtuvqHoUsPVyzDJvNky+cqbq7iuPaj+6Fx6Ge6/jIOGI4BPx1PytInHV4ecxwDx4uM J48v1rMsF/u44qTLL+MwL48h8PzaRA9c8aCXOBuv80F21Q87U9kHiXfx7MM2UNk36FF3ABI/5PEo eQHJa5bPM3DOwYXy4FlSUhJ8eBCfG/DtfzhHkLi83lQOi1tz81300L396Yu/H0lltJ7wjtYkbQgy QUf1+6jOaArMe0KTiy25PPVuDOtJp+pAlsdg84mZvSupfwRaDqHp/HXUyHidmAOxDnrwNsrf8YkH 28HzkaV56PhIkzzLjOX/J2I97KCjzPdA/cLo23wtX76cJk+e3Gp5+QWFX9qtliSHgaPWyycKrj/E ccvJZayoudsjZ9TaOipOnuzl6x7kQJltjbmMlW0t+eafq2ExV3HyrT++ns7ZgY70O+Hvf/87HX74 4TR06NDgK1J44MQJ8KJFi+iEE04I3tfJn2bL7+3kr0zhDxLiq6APP/wwTZ8+vXM+iYmN9OuBT9Kp VTNo48S5VD3nfPr6iXtoQd8/U5/FF9KXzd2vj1fOpfrfn2/4HrT+13fRosRk+v41n6AnJ8+lFRXH 07cuLaW/jzO32n6mgi5/8iRz5TNBm9dtod7D2+ZrWDrnE9P5dpXNMVhaWnqd6cha8+D//eD/4dAU Ouj3N2Ig8wDJPOthAw8bU36wHrymxtRkYz5YPPBlsjCURvHlQnhJH+Zt+gDof3TcDnTkgbPjdj1/ K+8IA2cuu9eRTi5zue+osXJ19TRXcaLW7XG+AwdjB3jYxHrrrbfod7/7HTHl/zCXw6jEAd85aYG5 MlJMn75mIG2Y9gea3fdBoi8W0uun3k9VieRVk4Lg+onhuzXec2vwk+49nYZtepkWjHuO+szqQ7S9 ITirp8QamjKinF7Z0zm75XeVfQfksZWDY5DnrrD5q/mAT5aOOU1uRGOkLS3PVxSjLhQbFQ8cCtTF Qw/cQUU7ylVOvODbut5cDa9xX1TtlTdunR0Fj9vQ8r1evgUuFytXcXJRi4/hO+A7kB8d6Gi/F2x/ 73//+98HzVy4cCH9/Oc/b7pTy4bNj67nuIriofS9j4Ymg579Nbr6q7VExeZKr9HUVNdSieHLV17e lLT8wvPo+41Sbd1h9OX/+S6VmDPu9+5dSK/36UFFbCuupFVmgPfLd0B3wHZcRTwGw15QmLtAOW0U fBhGlx4qxxk6ZZGuoGGFsb+0S94Vz+vbuQO2F347l+TT+w74DvgO+A74DvgOtEIH+AomP+RasmRJ cIWTdZs2baJnnnmGTjvttACC/5iW+IOB72qGTKySXs08dJJuWfwI3Xe1+ZQhXoMPp9MfrkwOnUmN /+k7kNKBLI/BuLMa8GEzmZ7fUuqNI8QZOsPiolgU78JKO3j4uny83nfAd8B3wHfAd8B3wHfAd6CV O8D/0Sz/s5nfq3nvvfem6O677z6aMGFC8L2drVxOpwhfft50mnVep9iK30QbdKANjkHMX7wbzGBS F2eX8I/kk/rfWZFcrCBXsbIYF+/y5UTSx5rYK30HfAfcHeD3GLbVastcbbUnn8d3wHfAd+Bg64C8 eskfHvTRRx+ltIC/t/PPf/5zyiCaAjgIhO2r19F7O/jzVjJf1VWraeX6zbR+5Uqqqq6m1S+ups1b 19OLq6syD+o9O0UHcnAMuuYnrXfNYBrn6qvL34rP1ZVOGVwWKovRvMRJf8lLH6nvULzto9axAdcH rbj08AONigNe0mw/qTUfPzQl05oy9ZP9zJaXQ1su3gOk96Rlrtemk/tIZ5dYrjkOPl3+bF+fsjbP +w74DvgO+A5E7wBOes8++2w655xzgk+o3bp1K/Gn1vIX1jMFJnrUzoJM0D8mPUr1j5xPg8Z1pcfL zKfW/v3b5lNre8ba4JoFFXRht0V0/p+m0oc3LaYbp9xIix6bQlNP20fbD/yQSmNF8+DO1gEcXxke g7b5iecu1rvmL6kPw2Xc6rhDJwqWCbXOtlHg9YZYL3XAgYbZgMlrqodCLbuK7ygfwOKqv730uRjW 2qN2PaxpOW5N2fojX9x+xhk8uUa/fAd8B3wHfAd8BzpWBw6hnp8h2hN8QG0hHffSN6jrwHgDJ+/3 iFHTqWxDLSXKJtHEymH0LvWm2tp9VHHlCX7g7FgviI5SLeYzUMxYoGGDJjBZ7TXu0IlCZVKbzlWc xjJO6zg2/G02mbtdeB4csTAcYpiEDXrgQF162Jm6YkDPGFsc1MD2uAsDAIYG9sfAAZtNB5vEgmc8 23VM6WOzs59rAQ+7lGVcbXfZgJMUWNZhLzIP67XMOr1kHLbJWMBCBwq9pHHiSD/JIwaozmfT23Qc E3rmdRzW2RZ8gGeZeehtPl7nO+A74DvgO+A7kC8dqLr3Abrve+83lTMm+OzaOlpzy2NEV5xNJw7Z Qvd+eSkVjCPacGcdfXXjBXRU4WqaUfIfdGn1Ihqv5tKBp9xAt3y6hLpPvoXKSstpxLIfUcEnu9Pc o8qacnjGdyBmBzA/RXHDMAPKPi5/xrhsUXIFmLhDZ9TA6TaAwiVOxnbpJaZdeD3YSdnFxy2UB0qO JZeMzfp0svR18fLrQTAAYBiAj0sGHkME8C4KvI7HeKmTvCuWS48c2i5jggcFlmVeNn3UPSKWK45L r+PLGiQPf1DpJ3GSZywv9Eb6JC2pe5a+8AGOqbTbZNbBz5aL7bzCbEkEkXx9Quep74DvgO+A74Dv QJt3YPMrZuDcTl9cdSEdTVU0r+IJUwK/p7Mr7VlWTfUX1Afy7ld3086K42nm2tFU1ourHESXPnY1 DStmPnUVlI6kyuAe2vLA0G9cZUDLB6TivOQ7EKMDqcNDS0fMXy0tSY30T4d1xXDqW2volAl5A7rw Vt2UTN6WvO3qY2vll7n0AMo5+f1wekU5ibcNAzxo5GrZ4tt06fLp4ScMn0l8V7w4eW0xuBb0k3ld W9T46eLYcrt0ugYXjvWZ5o2TIyy/t/kO+A74DvgO+A60dQe2rHiL6IufodEDis2YOZSOHEyUsBRR RyV05n8dS/2bhsxSGj9lggXpVb4DrdIBPW/pJHHmL4nVcTKScz10ujaLwtmuMbBltAHvlLzVVg+e UQbMqL3zA0PUTkXDoZ9RB0xX1FzFccV36dsrr6ser/cd8B3wHfAdyE0HtmzZQh9//HHwibWJRILq 6uqooaGB9u/fT7t27aKioqLg0aNHDzr00EOJac+e6r7R3JSSV1FqNu0mMre+do1QVUOdATUNnREc PMR3QHQgy2MwbKYKm7+0TVTUxEbBNIFtTLZDpy5AblbbOD/bNcaGs9XaKXR6OMx0UzoObsnFFdBM r3Smq8c1KNn0rMv14oEHuUCzzRGlznR5EQMDmawJNtbJmmVM4G3+sMWJAx8XlXW4MDa99LPVb/Nh HWoP25/L1+t9B3wHfAd8B9qmA/3796fDDz+chg4dGnxKLX+CJj/q6+tJf3ptcXEx8RfZs40H1c68 +p9gLm2e+gpVXfcp6v/+a7TiHaIxkTacoM3rtlDv4YOp84/mkRriQWk60IrHYNj8pW22KhmDmQ3U hnPqog6dHFwWhIA2nc3mKo79w2K4/JCjzSmGOyTGkAdZ0yh4PUAihtRHiQMM07hXOjEUyKGC68Bg gZrk0CBt0GudjMsxdHzEzSWNksNVp9RzTdhX3PpkHBdvi69rd/lKvY4DG1O5oNd4ibHxsiYZwxVH 4m3xWMcYLPC6Xtg99R3wHfAd8B3wHWjPDpSMHktjvngP3Td0jikj+NhaQ5PXPZMn0jidLky9GppY Q1NGjKXfVB+gCX7qbM+n8GDNrecoyHr+gp77xDbIoLp/EqNtTtk28MlCwGt6iInIOqaa56MQevBM wfORCZ6PXOah03TUzp07f2Hsbb6WL19OkydPbvO8PmHn7ECUQSzKzqPGiYqLkjMupj1zx63V430H fAd8B3wHmjvw5JNPZnyl8+GHH6bp06c3B+uEXG21eSdnr2Iq6oR781vKjw5kcwyWlpZeZ3ax1jz4 U66Sn27VkvIN4PsbMYyTD+iZap4HUOjBM7U9jLpJz3yweDjM1eKkcmmZbTyoYkkeOklt/tLued8B 3wFHB/QVSQcs52o/cOa8pT6g74DvgO+A70CedKDID5x58kz4MkI6kG5+0vOXxms5JFVgiozPdOi0 JdCb0LL0cfFyY9pf2jzvO9ChOpCrW0fjxGnrwdMPnB3qJemL9R3wHfAd8B3wHfAd6HwdCJufbPMX 8LBBtnUGGGkLw0tccFtriiKiEDmBiYcCpQ/zNn3E9B7mO+A7EKUDcYbUKPHCMG2ZK6wOb/Md8B3w HfAdyK4DBw4kT9Huvfde+stf/kIs79u3L/jgIP7woC9+8Yt0ySWXZJfEe+dtB6qrVtPb9WV06K4P qWBEJZUH3zmaJ+XW76CVL7xHQyccQ8HXnOZJWbkuoxWOQT6ow+YvaePtYE6TW9MYaUvLx7nSaUue NoEBcIG8tD/0Sav/6TvgO+A74DvgO+A74DvgO9CuHcDJLhcxdepUKisrS6mHvyLlm9/8ZvCptimG zizsWUe/LPstvbmn9TZZs3oJzZ78NNU0pUjQk5Pn0OOrd9LT35pDs/u2fNz5641UNX+hsS2k9dVN jlSz+rkA/+Rq/jbRxjgrbd8s2uwjuTULKmjmAy/TIzPH0p2v7pCm9udr3qKxEyvon2K/7V9UbivI 4hjUs5YsDHMXKNui4MMwMn5aPs7QKYt0BQ4rjP2lXfKueF7vO+A74DvgO+A74DvgO+A70AYdwFek IFX37t3p7LPPThkwzzrrrOC7OeWJMfCdlvYcRGc//w0a2tqfQPsqf6ZL86rfbj4Fpq6QJsy9mC5/ 71K6au2/Uw/z6blfXHUxXf3ehTTzu4OJavnzYrbTyuXNw+HGRauDIPV1yXhBnODzYppjh3FHjJpO ZVRLibJJNHGk43piYitt3hF9kHXlWz3nZOpy00qXuaW+sJAmmX89SpSpfjWd3GUMYbZOrJ5jXrdz zMjdsVaWx2DcWQ34sJkMmKwbGWfoDEuGYtMVJu3g4RsWP29s/DUmuVwcL25M+R2cXbo0/5LRdbls Lr32jyO7Ymq9ljkH6/BATsiSwuaicbAcIy4ePq78Lj3nwZI5wbMNvKTwkXapkzz7YSEGZEklTupd fFgsl49Nb8ubi9iIISnn1/m0bKvRptN+kEHhAxlU61lmGx6wg2o/6G0UMeL46DguXxkbvPaVclic MJzLT/p43nfAd6DtO7B//37ih1ynnHIKHXXUUYFqyJAhNHHiRPO7LHkudNAMnokt9PSl/0cfmAmm 5o3n6PYzFtHjN9wVXE28/eerzHhmVuIdWjB5IT3+6weSVyUnPxLg2bRr5TK6vfFK5d8e+herknEm /5nuPcNcwaxcQsE3nQ7uKr5ypbDpPXBdi4uopLgrFfXiz80toG6GdjXfk1pUgC+AINow/81kHfWb 6eVb+QNK06zEaprRZSots1y9HXjKDXTLV46lr9xyC41tMXMmaPWDZqAr6U8LNyavy74x/yqadtVN dNXJye91vfPZlXTPVWOC18m0m54NPkaVP0R15T1XBbouXabRg+bSbOKNe6jiiqeIZo2lLjPmk9HQ gz8wQ2jj98Pe9Ph66yZ601P0yC8bY538M1qfSND9l0432lU0tqQL3fnCCrq+4grjewWVdJlBK81V 0WSNP6MZY5I1/uCelY11WVMYZct6A+SO1XRVY4wxho656B5Td+5WGxyDcpDBDCZ1cTYD/0g+uRo6 XcXKYly8y5c3IH0ibagjgfA9nPy9mgfDsp1osu7AgdKmh8RIfbr+hMWx+cbFcwxZmy2mTWfzkfti HkvqoWMqa5V6Gy+xrtw2P5tOxrLZo+psdcjYNnvU2LJnspfsn03cqPmj4uR+uc5Ma8tVHFfdYf10 +cTVZ7r3uHk83nfAdyCzDmCglN7f+c53ApG/EqVr167md1jy1A1UYjsn30DbXt1OCb6oWFdPHz9T RVXlk+iCFyfQx7c+T5uCqaOBagzmtafKaObaM2nYq+vpxdfMKGmGwPtOfYk+8+LFNGvVBHpz5oNm SGqM86oZQM89nS5ecoK5gmkGyHdW0X3fX0T3fv8B87ifVr2T/E7BsJ7W7yuko39dSYWPrqZNJm7t itW07esV9KmJPDaFrOJBdOljV9Ow4paYgtKRVDmynEZWVlI//jLDxlX14j3mamIJVdz6IS1Zt52u rUyew9Tt20iLbp1Fx972Pq36y5V08cSxtPzYefT+2j/Rollzaa2pK/HGQhp77l5aV3eA3n9sKE09 4x6qG3kGLflpBdH1i2jLb88ifuvo0Km30XbzHuItz/yUZp32ADX/lzqqSNIf/WMkbdqylq5/6kd0 z2s19OUf/4oqzL9Fa7fQ/3fsWLpmyU8N8Ke0dstvqcIETtZ4P01d+D5teuY2uvHcsfSCK7jxtNVb bTr6+HUVtPTcZ6jmwG66/fyptGrZttTCciDZjquYx6BrsNB61wymca5dufytePFSstozUcpCZTGa lzhXHunjwrSLHlcnMTBKWfJcHGTmNR426BmTycKJHE68IYNG0cuTYeBRi44DPVO2abzWA4M48Lf5 sc2lh18Y1TnCsGyLgnfVj9iIIetO5wNfptJP6hFD6jTvwuiYUWqED7Cg0HNu6JiXepb1YixjpI/G 6BgSq23aV8rIJXWa1xgpy8QWGtsAACAASURBVLzsJ3NLnI7ZWnJYPTqnrk/KMo7cE8eATethg17G 0zaWeWlMUpv6ExjkTbV6yXfAdyCfOsBXMXHyy1c6v/vd7wZXPFnHV2PYjkc+1d36tfAtq5+ib104 nEoSG82w2HwqXUcl9NV7TqL+xbVUau58TZhvo2+oep92Go8Nf/w7bavhKaeeGoILkck407421HiZ K5/vsXw4jT5jJHXnS6dFe6luQfKqqJHcK1FDxUePoMrPrKTXXt5G+/53Ax113hnU84ZVZLmIKeKU 0vgpE4TsZqvXP05Xn3EazV01yQx122mpuuW2bt9uqpi9gs45ZoC5VjnUBLqNfnpOJfUyw+Yk+j3t Nfv911uvGf3b9Icbf0Y1b91KtGq26UQx9Tu0jCq6DaJ+5utoeB0zpoyW3j+fnn/+fuN8iehuYA5+ 7DZRl913EZUXJ6jczKy7TJ+L+xxmbgkuo0FD+lGxeUp69Ts0wA7s1yuIEdR420I609RININmm6ug L7y1g47t+yxd8Z+PEN9Kvrf7Xtq77Ui64a5rqcRWb30VPTHXXJjddLypvICOnXQyX0xttZXFMWib n3juYr1r/pL6MFzG+20+UqKFQMESrXW2jQKvN8R6qQMONMwGTJtTHhQxJIJnmXnIKMolA484wEeh sz76cQoMJ3KsBM8ni+Al2KWXvpqX/pnyOHkN87fVG7cWxGAaZUXFR6lf5kNcqQMva7PF1b7p8IjL NOz5hU3imZf5wAOr64MdMbQMPaj2l3qbr9ZpGf6a2nC2PUid9JE8x2a5PVeu6rHFwXMibZLH/oGL 0gft7/KJE9MVw+t9B3wH2qYDGDg5G5/8jh07NqC4/Q8DJ1N9S27bVJinWXigLN5vBqrkqt212zC9 6aivjKY+5n2Vo79ZRAN4yrStwYdTxYlHE99Ea65Z0ubBz0Z6T2J94aHmNtXD6a5pf6UNJsu3fllK b5r3g+Zq9Ro4lr79w9m07Ouz6I8LFtFR10ynkaX2EcJ1Y+/uDzaaIXIKnfalyVR06ql01rVHBFc2 U/Bbn6WT+0+kMfOW0BnHmoFu6T73FoI+15FG1AV6h1sC2QrM0Jj8T4GC/mPoossGkXmrbLDqzHto Dzdbe89Wb/1H9Jq5mnp698a9F3YzPrqCZJxc/MzxMYj5DBQzFmjYoAlMVtuyv2LcIVGoRNh0ruI0 lnFax7Hhb7PJ3O3Chw2KNhsPnlGXfL8mfPSQCT1ork7kwuK4bK6TTZceNWsaF6/9WY4bIy7elhM6 W384PpbMJbFSD6ymYXjtDxlUx7LJMr7NHkXH+fQKi4v6QOHLPojFPGJABxxT2KQuCo8cmfpHyaEx yKn1ceV0cXQ/Ob6td6zPZP+u+DoW6pSUc/rlO+A7kN8daGhoCAZLDJQ46a0zZ/KuYRP6/N5Z+1VX MnoEHUav07a6Mhp/Ym9zobOWas3ZN1/XbLHeaRD65sG1BU4p6vceQn1O/LTRLiG66PP0CcO9LjB8 sp/Yay6f1hebzx1qoK4F5j2hBQnavG4L9R4+mNJ+PlJxPxp35rX0Wt0FtHThzTSqTyFN/elf6LfX nEkDLLfnitRN7Ih/m0Z08QKiT15L4/qZUsz7MIOV+IhW7Qve0UrV775g3pf5U3rgvJNp94N/NldD m9zTM+Y1+pH5F3yuEqPrkvH5J9+2yzPlqvUbzPsvK6mk6glzgXISrRhRSgW9SqlyXLmxpq4SW73F vWmaKWrOI+ZDi84bRIvvvJio4o5Gx3raur6KCgYeSaWmJ4mtVfQv8x8A5eZKK5mveVlfVU/lR/az XrmVmbM8BjE/yZAuHsMJKONc/oxx2VzxW+jjDp0tAjgU6TaAwiVOhnLpJabD8LZB1FV8ugHT5dce etsJKNfh0rtqDMOH2XQ8feKr7VqOi9f+YbKMLfcg9TZ/ibXZpS4My3lgB5W+uebT7cuVz1YnYsm6 obPFkThtR3ytjyrDX9Kovhon98A1Z7rixpH4KDnD+mnzz0VvbP2IW7etNq/zHfAdiNcBHjblwlXM 6urqYBjlAbO+vp4KCgoCyu/vZB2fKHf+VdA8MJgP/MFqvEDWKBY2fRBQQR8za7C2eDCdtbiS/nDq fHNLJ6/edObG84hv8iQRh0Uyt+TKlTxJb86VtDXnALaAzBW80hF05ry91DB2hFEnPwyqoLGagiFE b067uzE/0WE/Pp0uumAHTRkxln5TfYAmpJ06GzMVlJph67/owFmX0YM3z6L7XzuFLh9XGgx0ZXL4 rOArgM2Le1Q8cjqtmPcaje3feIo/6Q7avfQiGvGVWUSjzIdTrZhHu+8+ja40VxL7dPkRTZp+oeGu oBnzJ9HfzjumOVjA9caFSepWZgY81vUaTbMuXEUT+3ShO1btpotGJ2P177KaVuy+mwq7mYF/7tep t7k9ltf1f1lLlTyNOpar3qlLbqMrTqmgLjPNvGlu7TV39DauGpo3fDjRiuR7XdfMG0Jj9y2jAz8c R9Vr76bhFQnzXtVr0363aJbHYLr5KfUAR+nNVPqnwzZ7ReRkcLiwDnrwmh7SiGGqeT46oJc8Hzss ywfrGMuvR9YDAzpq586dvzD6Nl/Lly+nyZMnt8jrul2Wgdpm00mM5JEo7pVOfYIo5Ti8xHItNpn1 8kRQY9jOy6W32cKwNjzreLEfL9Sj49jkbPBBMvNDx5V6GR96pi4fm01jw2Rtyzae9o8Tn7F64bnR ccNknROyKz7sOrfUwxf1wAaq64mLl/4yptTL+jTGhpMYXQ9iSYyMIfWSd2HC9Mjlwsj4koefTSdj Aeep74DvQH504OGHH6aBAwfS0KFD6ZBDDqHa2lras2cP7d27N5CLioqoW7duxJQfPHTywPnxxx/T 0qVLiT9oyC9XB2qppnq/+QTa4sZR0IXr5PpENVWbW1h7Nb6HM9htfYKq6wuoF78Z04zqfBG0mHmD TRT0Ct6jGbUrieqEuXrJ77jkVU/V1fVBrpXmq1lm0i302uWjqTqBXBGiOustpsJNd1LJqH20+8Dl wdXUCNHSQrI5Bs2xayZ4esM8+H+B+P880lH+3wnG4AGZqeZ5CIUePFPbw6ib9MwHK/mcQMqecmLb whCLwiQGNqnrcDwPkLz0IMlXOWFje7qrnrm80skn2XzSxwsn3OBteuiAYepacU8mZWzwqAkyckEP OQqVe2V8uhhx8bJG8Oly2OqGL2zpYrjq5Dg2XxteY7WMWqJQW3z2s9XCerlf8Iy1xUFdwMm4rvg6 h/RhnpfMhRxSr+uR+CCA5YfGsCxjwgV6lrEvqQMOdtiYSjx44JgCy7xryTiMieIjc0X1AY59w3LI 2ODD8BzXL98B34G26wBfxVy3bh1t376dampqiG+r5Vtsi/nrOcyQWWi+IxEDJ/MYOhnrV7oOmK89 Cbmyls6709iLe5nhUu2moJh6NU0k5v2WsBssWOXhFItTgpvhsjFwYTfznynBNS6TK07QkHoT1I0q JjlLyciQ5TEYNlPpGU1itc1WexSMza9JJxNCyTrowWuKq5us5yuUTPXVTdbxS4j18uqmjXde6Xzp pZd+Yfz98h3wHfAd8B3wHfAd8B3wHfAd8B3wHfAdsHTguOOOu86o15pHuiucuAqKq5nySifbeMCE TV/dlDLjbA+jbtIzH6ym/1eAwkE5IA+Retl0wEgb+9sWYyROYw587nOfM/9z7nLX8NzI/L96L7/8 MvncuelnlCjoOX86nl++A74DvgO+A74DvgO+A74DvgO+A1l1QA9QkPX8BT0nYxtkUF2ExGibU446 dIYNhs7gwgB/WbzkBTSFDfzaY+hEFT43OtG6FJ+Q19b9bt1d+ei+A74DvgO+A74DvgO+A74DvgPt 0gHMX0jOsm3+0rh0eNhj0ahDZ5SgehNa5hhyU5K3xQ/8eQhp60EEOUFtxbWWDjlBWyuPLS5ygtow raVDTqZ++Q74DvgO+A74DvgO+A74DvgO+A7E7kC6E2k9f2m8ltMVEBmf6dDJCXTR6WRZlIuXG2uK 1x6DCHKCysJam0dO0NbOJ+MjJ6i0tTbPOdsjb2vvy8f3HfAd8B3wHfAd8B3wHfAd8B1ogw40zU+W XLb5C3jYWAavQ9j0YfgU/0yHThSYEswhoEDpIwuU+hYh2mMQQU7QFkW1ogI5QVsxVYvQyAnaAmBR 8Kds8ftfd+3aFVj5Nln2P+KII8z3F5nvMTJylIWcTP3yHfAd8B3wHfAd8B3wHfAd8B3wHchZB/gE O2z+kjZOajsh15hYxcUZOlFsrAQGjKlDFw992nhhg8ipp56a1t8FWLx4scvUdMUtLLfTOUsDcoJm E27X3gN088MJuuQL3WhAKX+QcPhCTtAwNH+U+rx58+j+++9vAeMvjr744ovp9NNPjz14tgjmFb4D vgO+A74DvgO+A74DvgO+A74DYR3Qs5bEYu4CZVsUfBhGxk/Lxxk6ZZGuwGGFsb+0S94VLxj+ogxA zgAhBldc6JmCt4X5xS+S3+Zy3XX8CcXNK2wQPvnkk0njmz1Ngxqv9KXLLX1c/JsfNNAvFu2jLbv3 04JniGZ9JfyLieLk5oFz/vz51oGT6+EroL/73e9o//79weDJXzIdtmTuMJy3+Q74DvgO+A74DvgO +A74DvgO5E0HarfRrmePC8o5dMJLREV9naUl9uyhevO9pD2L44xgznDaEHdWAz5sJtPzm84ZWc7V jlEsincVIO3g4Wv14WGEB5d0K+yqpfbFUOiKi5yg2l/KS5cuDQbFWbNmNanT3VLqyssBkBO0KWhM 5qX1DTT7oX1Uy9+2Y9Zzb9bTJTUN1KMb2p7Uy5/ICSptkueB87//+7+DgTNsrw0NDXTHHXdEGjyR M6w3sgbP+w74DvgO+A74DvgO+A74DvgOtHcHum78CR3e84OgjH2GbxhxW8uSEq/T98qOoz9++tNE //wnTbz6T3TvT6bRYS2Rra2RgwBmMKmLkx/+kXxyNXS6ipXFuHiXL28g8OGBxLVg4ytrURd8QG1+ sIHaMBg0efDkde211wb0iSeeCKjtB8dLN1ghJ6gtTpjurQ/3pwycw/ofEtxe272o+Uqqyx85QW24 ZcuWNV3hZBy/d5PXqlWrAjpjxoyA3n333cSD59y5c2nAgAHB954GBscPjhWW1+Hm1b4DvgO+A74D vgO+A74DvgO+A23fgYYE7Vz/Fzq8VzI18z2Hmjshu6q7C7v2o4tWvk1zjvoE0db/M5gv0UuX7qEv 9GuVkl2Dk9a7ZjCNcxXJ/lGxlKuhUxYjk8vNaF7ipL/ku0QdRDIZVlw+yAkqC5I8D1QYNHHFk+U4 A7CMxzxygmq7lPebDv51eT2dWtGVehUn2/vBzgP0s7/WNl3hHDe8gK6f2o26HGgwsaV3Sx45QVsi kppt27almC6//HIaNGgQTZkyJdCfc8459N577xEPnby4T++//z6NHTs2kG0/kJOpX74DvgO+A74D vgO+A74DvgO+A/negcL3fkfVH+2iw0/bEJS6++5hdJjR1Q2+MrX0rn1p9IjGiz+HldFEY92+u4YO 9FXDaapXppKcuRCDT7BZ7zrRlvowHOLFpnGHThQsE2mdbaPA6w2xXuqAAz1QW1tL1dXVkFtQXDUM w2indD69evWivXv3UrrciHvZZZcFg+aSJUsCnyuuuCIw3XbbbfTMM+bNlGJNnDiRYBfqJjZq7upE F/rtU11p9Xtd6I33a+nyyQ3EQ+jNDxXQrr3Jp+D44V3ossn1tMe8qKOsqLm5L+ghx+Xe86fXQrd7 927aY+5Zh8yYffv2hT6PyB3neeS4fvkO+A74DvgO+A74DvgO+A74DrRHBxre/BWVdjOZ97wXpO9j ZsitRte19HxnOZseuZ2eoe/RLf3qzLlxnRMX1bBp0yYaMmRIOjjmM1DMX6CsB69jufQaFyqHf7pL S1cUKi02nas4jWWcTYc3cWqbzJs3PL/HkQcsfn+j/MAc5m2PbAvn4fKPzyUHTo710sZD6B/rutCi V7rS+q3Jln1uaBe6/AvmdtWG7F/M2dbr/X0HfAd8B3wHfAd8B3wHfAd8BzpTB0p2LqQ+3bdTEU8t fHJuaDdzOa/M6NhmW5sW/5g+f8EG+p9XrqFBNkBMHQ+cjzzyCLwwfzEFD5ummLFA2e7ykRgdJ7Ic 90pnusAoVhbHT0VX4SgbIXE2PeIJdzv7ta99zW6waOVgaDHHVvEVzWeffZYmTZpEV155JfEQyuv7 3/8+XXPNNSnx+FZT2FMMMYRDTNeuPq0LLV3bhf7wfweo3nR4/vMFTbfUlvftQleYgbOh3g+cMdrq ob4DvgO+A74DvgO+A74DvgO+A5E6sOeN22lQH6K6QnOhc+VXA59uZnIpNFc7PzK2ruOnp8T513O/ os+fV0NL3r6fRvVIMWUkbNy4kR599FGaOXOmy1/OVoyRc5XkYXPNZa74sfRxr3RGDS43whuADAod yzyUQi/j23TSnsLbrii6dCmOWQqugZPD8nCZSCRSHtkOnCiX45x0dANdf/ohVGCexb215mtKTCfL enah679sLh8fqKPpdxUGevjkipaUlKSE2rFjh/kgrn826ZhnnVw9euTg6JIBPe874DvgO+A74Dvg O+A74DvgO9AOHei2+zHqceBd8/Uo5rNLPiLqOWxu8GCedT0L3yXGNK2PV9P137iZLph/CQ3t+nHw trREkzE+IwfO7t27IwDPTrb5Sephlzr4g7JNDqDQZ0WzvdKJwlGETUbR2BwofGCH3GGoa+AMu+qa 7j2dUTfPA+XCC+po1BEH6LIvFNKcxfuDK/vfPZlf6GYCbcVVWVlJY8aModdeey3I8uMf/zig+PqU //zP/0yRTzrpJBo/fnyg8z98B3wHfAd8B3wHfAd8B3wHfAc6cgf2bbiJPlGWHHuKzZVO6nt0sJ2A N9xhvQ7QBwZDnzkt0H/8zqv0OHPnfZ7uCjREs5e8TTMyuOS5fv16evzxx4MrnDxwivd0hs1UyWKT uZkHlnm+AMhLYpKa5p9sC7M3Ix1cLodOLoSvnDLljfAGWJaL9dgk6+UGJK9tLOfd4iup+pZaLjLs 9t0wWyYb5PeSHjekjr5zUiFVmQ+VHf0Jfn9pJpGi+/CH/vCtw7/85S+DwRPDJiJImQfOiy66iAoK sn2pIbqnvgO+A74DvgO+A74DvgO+A74D7deBFes/Re+88mZTAV1eHhPwPMzQy0n14M9+isZ+Jsn3 GDWDNm9OfqVgUpPZz7fffpv4qxm//e1vEwZOfk/npZdeygHDZinX/MV+0oYpIthKY0yNgY31kVfU SYCDy4KQwKaz2dIVJ+3MQwZFzLyiPHjx0rfMPvTQQ846c/GeTh2cB89JR9fTgaO70P4GvFY0Krcy v9Cvuuoquvnmm+n111+3Bj/xxBODg8IPnNb2eKXvgO+A74DvgO+A74DvgO9AB+zA2K/dTvxoy6UH zg0bNtBjjz1me08nZinMUZAxJPD8Jmc44Hg7rIcMynq5JEbqQ/moQ6cOwkWgWMlrHGRgebP8oULs Ax4YTV0bTcGFDXgpQIvA77fMZulhE7GyjYs46SjfYtty2XQtUdlo+Ls0+Womv0/zuuuuoyeffDL4 OhRc4WQ7Xw3l23ALC1u/nmz24n19B3wHfAd8B3wHfAd8B3wHfAfyuQO2gZM/RAhXPBtr59lJzk+Y v6BjmecvyKDANYZpIqwHBpSNkrfJrGuxMh06ORAnRJE6OexMebGdH7j9lnXSF3ZNGRe62mrACy2i HYz3f09+ILC7gEQi959gi+GSsxYXF9PUqVODIVRWwYMnX4Fl6pfvgO+A74DvgO+A74DvgO+A74Dv QPwOvPXWW7R48eKmAZOvcMqBk+Vhw4YhsJ6lcCIOKucv9pFDKMvAMY8ldZJnu5bh04Lq91y2AAiF DCp5QLAJltnOMlNgQY2qSS/trOclddInafU/gw7oT8V1yW3RLr5luL6+PuXBOj9wtkX3fQ7fAd8B 3wHfAd8B3wHfAd+BztgBHijTDZw8gDYuzE1yloKNqRwwgcX8BhvmN+kHHj6QY9E4QycHRjIUaEsG jKbASj3z2Bzz0sZ4yMz75TvgO+A74DvgO+A74DvgO+A74DvgO9DpO2C7oqmvcEJubAbmJkmZh8ww m8x6zHbA8hCqFzDQAws5lMa5vZYDY0DUSTmJKzF82A4MYsEPNlCpZ94v3wHfAd8B3wHfAd8B3wHf Ad8B3wHfgYOiA3zL7GWXXda013SyAeJqJftgpsLwyDIvzGXMaxvrsIADBnpQxIOclsYZOm2Dpk7A hcmrp9gw41A8imQsPlSI7byAb6LmA2muNnrG8YNjMOUcoMyznql8sA56wwY8dEw5B+N5scyLdeAD RcgPG9amc4WwYW0672/vgK1XNp3d2/5ce3//+vfHv+uISdXbjhWbLtWrWbJhbbpmj1TOhrXpUr2a JRvWpmv2SOVsWJsu1atZsmFtumaPVM6GtelSvZolG9ama/ZI5WxYmy7Vq1myYW26Zo9Uzoa16VK9 miUb1qZr9kjlbFibLtWrWbJhbbpmj1TOhrXpUr2aJRvWpmv2SOVsWJsu1atZsmFtumaPVM6GtelS vZolG9ama/ZI5WxYmy7Vq1myYW26Zo9Uzoa16VK9miUb1qZr9kjlbFibLtWrWbJhbbpmj1TOhrXp Ur2aJRvWpmv2SOVsWJsu1St53sk6nn8wh7AfP6BjKnUs4wEcyw1Cz3J9o2xIkz/icC7Gs8yL8bxY xjkPsMAEAIHRethj0ThDpyswCsVQCJwsUPKwM4WeG4ABEPGYvtWolwMmeFBuGD+kzDwayXGBkdSo UxbwKUojcB0uG7BhmDCb9092IKxHYTbfP98/7kDYayTM5l8//vXjXz/++An7HRFm878//O8P//vD //4I+x2hbSzLxbIcALWMQZExeACDoZOHTa1jGQ/DBjxTXqyXC/mlTmPYJuOlw0p7Cs/DmV4YzFhv 46GLQzFQwodjy2EQduhAZQ3AcAzoQWVc2NkmG+fiEUPaWceLdYgn7ZIPgI1Y8KDe3/fPv36SR4M8 ZiQvjxXwoP748cePP3788cMdkL8zJC9/V4AH9b8//O8P//sjeTTIY0by8lgBD+qPn9wfP9zTqA8e Bhkrh02WMYjKOEbdhLP5wYdtkgcWsVjmhbzQgyatzb+PWR9r4YDUTtAzDXvwIIgBEVRfcWQ9dEzB s56vtLLMFDIocNqHZa4JdsazzBQ823hBb9sDN4v1vECZl3qWXcuFc+l1HBfOpff+qR1w9cmlT/V2 P8/eP/V40H2D7OqTSw8/UBfOpYcfqAvn0sMP1IVz6eEH6sK59PADdeFceviBunAuPfxAXTiXHn6g LpxLDz9QF86lhx+oC+fSww/UhXPp4Qfqwrn08AN14Vx6+IG6cC49/EBdOJcefqAunEsPP1AXzqWH H6gL59LDD9SFc+nhB+rCufTwA3XhXHr4gbpwLj38QF04lx5+oC6cSw8/UBfOpYcfqAvn0sMP1IVz 6eEH6sK59PADdeFceviBunAuPfxAXTiXHn6gLpxLDz9QF86lhx+oC+fSww/UhXPp4Qfqwrn00o95 4JjKhxwCGceyfDAWMoZHplIHmSluuZVU6tmPZfjgqinLyCV56NhP1m3jDSTAMG1acW+v5cByQONA 6XQohrFcKA+GcqF4ULaxD8ucS/LQcQzmebGdh0zIsMGXMcyjbs2zP/swBYZ5XlLnkoEBBQ4UMV0y /ECBA/X+3Inkkj1iDcvQgUIP6vvHnUgu2SPW+P751w9eE/9/e2e35MiO3OALv/8T+8aCNF8TlQNS pe7x+dkFI0qZiQRYJQxZZxgar4msC2L3j5x4DfdISPdP9w9rgsi6IHb/yInXcI+EdP90/7AmiKwL 4n/a/tH30tD31eBMw/mFPaEojKh81upxIISn6Pmj/Npn6IUxwNCBKwrzMWvv3c79D9RF4IqnS4c1 +sq5hPkvkeQelVOnXzo1F324zEv0+ykXnuID/npOcXT5mLXMvYP5HJ5XX/+6fnxHvF5g05MrY1Xd P90/c62kNbFWzDVL3IRdVatK3IQtxTVL3IRdVatK3IQtxTVL3IRdVatK3IQtxTVL3IRdVatK3IQt xTVL3IRdVatK3IQtxTVL3IRdVatK3IQtxTVL3IRdVatK3IQtxTVL3IRdVatK3IQtxTVL3IRdVatK 3IQtxTVL3IRdVatK3IQtxTVL3IRdVatK3IQtxTVL3IRdVatK3IQtxTVL3IRdVatK3IQtxTVLXDBF H6r9Uk8HSQ3h87DpGAdOj8p1oeMXzv/9NR81PLgelft9mMsPqJ7783v+mOa3g+vzn7Wq8aeGbqih vzCQ+0OA6YF1OJw94dLOKB4ajw/4OfgLiub0PnNxEFUNl6gJyHUfz9V7h4nDeMdVX8N5L+T16Xji Jqz65UD96/rt/l3vEmXv9sTaPe+5ff8sb1ln9W858G6tdf10/cgBXydr9VzxtFYSVv1ywH1NXiVs qev/X+Gf7jHvA5aiDoAaOtfoEmfmYFPvvIfsqZ1cx9XT0H/bpNVgzlf1Bz7Tfzg1LbiiX/Q4xBHF IdevktTCwPk1c/56qb73+FXTeeIwL9HnJlfk3jy3MBlHD/wBPQc96hTFkS6NUw/+iXPqVf9y4OTR qVf/6p8cOK2RU6/rp+un66f75/SOOPX6/uj7o++Pvj/8HaHcRzrcCRNPF7nizKn5ZdJ/rVRPtS5+ 3XSMHhp6in7pGcTxZ/FcXNUain6BKX6N3UEKnAParHWA01D0XDwOi+RE8TgwKnIJ59BJzhwzqu/z KRcGnmphfskU8TWEaxDVI382wseJc+ox1Ylz6lX/cuDk0alX/+qfHDitkVOv66frp+un++f0jjj1 +v7o+6Pvj74/dEjTGUPvCg2P6mkI4+JQR+QAqL6weXGIJHLgVK1LtbTU6L2mn+4hDPyRfh2EhWnQ 9/rV+fWpw95PBhMzgGYtpgAAGEdJREFUBwc2cMVpMLV6+sIaimjJVZPDE1cHRq+FaS4On/QcY25F 5pVOg96rWp88+0J+z06cU4+ZTpxTr/qXAyePTr36V//kwGmNnHpdP10/XT/dP6d3xKnX90ffH31/ /Pe+P/Ru4GIdqCbXGUYXZxX1wMgVdVCkTn1h6vv1KL9q7wtnTD64op5JfQ3iq7r5uTtwgSvOXDW/ FCrCAefwp1q/VILzqyV91WDkaPjlkz44Wo/M71G5X4/y+cxgqjVUaxBlIvmz8etjhztH+Y63w6u/ OrDzaYdf1fV/59MOr39XB3Y+7fCruutv59MOr39XB3Y+7fCruutv59MOr39XB3Y+7fCruutv59MO r39XB3Y+7fCr+t+x/vRdNIjkqnUI1FDulx8OyRVPl/9ymX7d9D7zCGN+P9CSz2d60L/46mk4h/rZ 4OPuL53zIKaJhRGZjwiuyFCuL8RcynV4FE5Ph0xy8cTREI/8Cfz6EJc5PErLfYQzF3x6xF/TvQ3S f6rxSauvf10/viM+y7t/un+6fz7bM87u/un+6f7xHfFZ3v3T/fOn9o/WkobizDnr0FOtPEVh6XLt g/LFmTi1ogY1uaK+M33HHRN+a9w9dPpkutE0npsr0pcR4vHA4M4hVxSfg6Nqna59aB5xfDA3uhTh 8yw+hzCG7nmq4e1i9fWv62ftjrkfVidnkz/rrFro5M96MXM2+bPOqoVO/qwXM2eTP+usWujkz3ox czb5s86qhU7+rBczZ5M/66xa6OTPejFzNvmzzqqFTv6sFzNnkz/rrFro5M96MXM2+bPOqoVO/qwX M2eTP+usWujkz3oxczb5s86qhU7+rBczZ5M/66xa6OTPejFzNvmzzqqFTv6sFzNnkz/rrFro5M96 MXM2+bPOqoVO/qwXM2eTP+usWujkz3oxczb5s86qhU7+rBczZ5M/66xa6OTPejFzNvmzzqqFTv6s F/OVqc9Q7ucS5br090lF9eGkGkyRi18n6XE/5npQv+ZlbudIpzH5L3R9usb//rsYI9uRwBVTzq+H 9InC6aVcmH7N1OCf0EpLrp7XzDGjOHCVq684czBFDWoZ5bn0nwz00nh+dw7XeF79PQfcM8/vqa9/ ZtW/9sJd78Rzzzy/O4drPK/+ngPumef31P3zc888r3/3HHDPPL+n7vpzzzyvf/cccM88v6fu+nPP PK9/9xxwzzy/oxZfF4PcIxyiHxw994OlcF0TUy18/hNbzU0PLVG9XU7vQXl+D/E0eNaUPwl8fPpL pybmAKdcg1p5ujEaenpIHfIU/eBH/wE/e4oawufgnoqaSxwOnuTSMD8RTFGDedI9XozX3PDAPoma u/pPHLty61/XT/fPdU98UnX/dP90/3yyY67c7p/un+6f6574pOr+ue4f+aFB9FyYX+rpnARGnqIw x6l1sGQwj2q4YO8icxDFZ3gOto13Dp2acG46x7hh4jhPX5IDonC/MEZziEP9SJ+1GySMeylqHuZF L0xDNVeqhWmI825ozju83TzV17+un93ueI93/3T/dP+83yc7RvdP90/3z253vMe7f7p//sT+0Try oRqMnCiecg6Qqv0sRK5fMTXg6fyEDhyMuT2Ko1pj4i8042jgoPf6t/zOofM30QbgARTnHw6YTOGA SK7I/4AQh03V5I/0OfwwqvmZk/mEOS6RavUZcBR9UDOn9z7Jq//9z77+3Xeg66frh3fR/VWzmF0/ XT9dP2s/fJp1/3T/dP98umsWv/vn/f6RRz5Uc4HrTARPkRoeNRHcD5acn8TRpUE+52QeeC/265O5 HftR/p1Dpx5CG5OoB9DD6qDIUE/DIxphaKXzw6RyYeKSM8cDeuL0hYvDXGi8lga+cnG4VDPQUH8a q3/5+qlv8Otf/dO+/O7o+un66fr57u5Z/w397gzdf91/3X/f3T3df//N7w99d51RGKp1aZDDSbW0 6OFR0yOipz/reU/1fXhNzhy39/+7Q6cmZLKUc2NxyIl6WH05DoYzV1864TqwKlIznyI91z/gr19H xdHFIVUR7JFuc/UY4nfUgTpQB+pAHagDdaAO1IE6UAf+tAN+PmJuYeAp19lHQ1H9VDum3C9p5i+f 6vu9vAYXpkGdcmE6P4nD8BzsK747dH4R3yS6CQc3bug1mKK+yDyIgimiE4eDpHSe8yWFKafnuDSq dWl4/kKuPbDGOlAH6kAdqAN1oA7UgTpQB+rAn3LAz0I+p3Dvea5zEbUfHtEQxYM7c92LXuKDEcXX UM3wHOzjePfQqZtxoOMQB8ZNeSDvz56+tH65FFcXJjzSry/H4ZCeeDpUMr/0cMDU14DHH4ww8TV4 Ls8de5L6UQfqQB2oA3WgDtSBOlAH6kAd+H9wgLMLUbcg97OPzijUihricc2e18q91rlIOjDm2MUH 9Tm8z5lJ2BwJm5zn/3/M38AbgCbXzbmJ58J0cRD03gN+fmH19MXhkCvC53D5gL7uA18cXRrC/Hk0 hwZc77lOHOZQfndIozm/O6qvf10/39096/3w3Rm6/7r/uv++u3u6//r+6Puj74++P77rAO8PrSFd 1MwnzM9B8DjXUHtUz2t+dBNObxelo6dcQ7WGz6mcZ4U341P07uPuL53v5uGBxCPngfQFOADy0GAe uYc44ss4RTjkzMuhVDxpdGmIp1w6sBkfra+e5zy7MMZdTPy73MSrvv6ldXEX6/rp+rm7VhKv66fr J62Lu1jXT9fP3bWSeF0/XT9pXdzF/i3rR9/Hv5NyDcfJhescowFGFKYetSKHTeX0wFSDzfhoXeZJ NZjij8bu0KmH1tBhTfkuiqPBoQ7uC12fzKcvq0OhBrlM0QFStQZzecQ49dErZ3DQ5DmFK2eOWTuu Z5tzzu8xa83HSL2JzRqtYupNbNbVLweSNxOb9VLX/+TNxGZd/5YDyZuJzXqpu/6SNxObdf1bDiRv Jjbrpe76S95MbNb1bzmQvJnYrJe66y95M7FZ17/lQPJmYrNe6r9+/elZfOjc4+cW9Z2jnLMRPfrC wR7pV46GnvPIiZOreg7HmBPsXZxzffuf186JuLGbNznUHDJVSyeNDNDBTz0OgMzFgVI956IFe7Sf A74K9TSIrnFc99eg/6p+/1Rfg/le1fqsfu+NXKp/r7XS9bP2jGfdP90/u72hddL3x2u37Dzq/un+ 2a2N7p++P/r+/Oe8P/mz8H25w4T7hcYx5ZxjdgdK4XDQTm6a2zHlPxq7Xzp3k+pB50vNMeXvhvT6 on7IVC5MPc2BMcKZ3w+TYI/2U6OeBnqPynUxPD9hfg94M4qjkeasPvvycuz1Wf9ePnT9+KpYayP5 4syun64fOZDWSd+/2Zfun+VA3x8vL7p/1pog6/uj74+0L1gfij95f0iLfs5JT/cnh+s15yTphaum T2/i9BX5F6RgD+hLD0ZUT0P1HAmbnK/67qFTk/ofALVHTQpnPoRqDobiacgUDpXKpUVPDv5oPb8s OFG4cp6DWpiG3xeM+GK8PsF8HvTqTdy1nk8eNdG5KZ88amLSODZ51ETnpnzyqIlJ49jkUROdm/LJ oyYmjWOTR010bsonj5qYNI5NHjXRuSmfPGpi0jg2edRE56Z88qiJSePY5FETnZvyyaMmJo1jk0dN dG7KJ4+amDSOTR410bkpnzxqYtI4NnnUROemfPKoiUnj2ORRE52b8smjJiaNY5NHTXRuyiePmpg0 jk0eNdG5KZ88amLSODZ51ETnpnzyqIlJ49jkUROdm/LJoyYmjWOTR010bsonj5qYNI5NHjXRuSmf PGpi0jg2edRE56Z88qiJSePY5FETnZvyyaMmJo1jk0dNdG7KJ4+amDSOTR410bkpnzxqYtI4NnnU ROemfPKoiUnj2ORRE52b8smjJiaNY5NHTXRuyiePmpg0jk0eNVFc5XOA3YniOI9a0Q+ajs/D5Ynr OuUa7+KLtXjUMd49dLpYD8AhzXHlPJwf1ODTcw0Hz4lJPy8M9cOrcniaQ7mGR3TC9QzoeS7h8JWf hms8P2m85xrPnXPKXeP5SeM913junFPuGs9PGu+5xnPnnHLXeH7SeM81njvnlLvG85PGe67x3Dmn 3DWenzTec43nzjnlrvH8pPGeazx3zil3jecnjfdc47lzTrlrPD9pvOcaz51zyl3j+UnjPdd47pxT 7hrPTxrvucZz55xy13h+0njPNZ4755S7xvOTxnuu8dw5p9w1np803nON58455a7x/KTxnms8d84p d43nJ433XOO5c065azw/abznGs+dc8pd4/lJ4z3XeO6cU+4az08a77nGc+ecctd4ftJ4zzWeO+eU u8bzk8Z7rvHcOafcNZ6fNN5zjefOOeWu8fyk8Z5rPHfOKXeN5yeN91zjuXNOuWs8P2m8Jw3D9Y6r rxrMo+fzXIMmRZ9TfWkTDwy+R+VpSPPR+M6hkxvoZjqscVNFDnTiqKan2rmqGTKAQx+HSEXh1Opz YbZqzx/lF0c93VtRg6h8PpMwDeen+kk6fFT/u8/u+8G6Z6v+1T9fL3M9dP2cHZh+zfqs7vtv+jXr +nd2YPo167O662/6Nev6d3Zg+jXrs7rrb/o16/p3dmD6NeupVp+hHD64147tcs5C6utSrb9PKYLd jQ/J1/Mo10D7ql41+Ufx3aFTN+Ivgp6nm4gnDoN66nl4P6BKA185hsFVzy/hridnDmrNJYyRcs3l +KzROr7LxfUe2ok7x/PJq3454D7t8vrX9edrY62eqy/O8bzr5+pT/VsO+DrZ5V0/XT++Ntbqufri HM+7fq4+1b/lgK+TXd718+9bP5x19GfHAXH9qb++D3+uRDRaB7o0yKmFMZ/3lAvXAH9V61M4Z6kd Z7FfmXgMz8G+oh+2vsCROCflE6NWnHmqd7yE69HAfS7wFB1TroH2VZ0/+QM4s/bd6j/zezpZ/+rf J/u16+fqQPdP90/3z3VPfFJ1/3T/dP98smOu3O6f8/6RP3OAKZKLQ+7ROQn3AyZzoCFO3OuZU3s8 5epdxp3NNDleK/dakzvmuXr8AgmO1mvPmU9RQ3o0quGSe1SuAV8Gc/9nwz7gGPRbKv0d3m/CX0D1 9a/rZ7c73uPdP90/3T/v98mO0f3T/dP9s9sd7/Hun+6fP7F/tI7ScNxzcVU7tqvheIR7OnzOe6CZ uGoN71M/G78+uL9jX/ldEyePmqgJyVPcYY6TczBUDXaK9PhSrvPn8r5yGTO1CUM3Y+ImbOqoEzdh 8GdM3IRNHXXiJgz+jImbsKmjTtyEwZ8xcRM2ddSJmzD4MyZuwqaOOnETBn/GxE3Y1FEnbsLgz5i4 CZs66sRNGPwZEzdhU0eduAmDP2PiJmzqqBM3YfBnTNyETR114iYM/oyJm7Cpo07chMGfMXETNnXU iZsw+DMmbsKmjjpxEwZ/xsRN2NRRJ27C4M+YuAmbOurETRj8GRM3YVNHnbgJgz9j4iZs6qgTN2Hw Z0zchE0ddeImDP6MiZuwqaNO3ITBnzFxEzZ11ImbMPgzJm7Cpo46cRMGf8bETdjUUSduwuDPmLgJ mzrqxE0Y/BkTN2FTR524CYM/Y+ImbOqonatcA4wazCM5HI/kiaMel/fRePQcrkfP4QrTmPULtc95 6LLWJZ08r5XrRhwWJaTvkZy+6h2266H1qFzDNT7vq3u9F5jHpPH+Kdf3r/7k0LlX/7p+un/Oe+TU 7f7p/un+Oe2Qc6/7p/un++e8R07d7p/7+0dezYF/u5749IiO6VdMrV/1Zh8M3KP3pt55upfGDhPO /oHzFKQPiKnn2OR5/S6nn6JjnuveXpOD64txyJ09cTSEuxnOcxyu4hyTR3+H0yfueDscHXHH2+Ho iDveDkdH3PF2ODrijrfD0RF3vB2Ojrjj7XB0xB1vh6Mj7ng7HB1xx9vh6Ig73g5HR9zxdjg64o63 w9ERd7wdjo644+1wdMQdb4ejI+54Oxwdccfb4eiIO94OR0fc8XY4OuKOt8PREXe8HY6OuOPtcHTE HW+HoyPueDscHXHH2+HoiDveDkdH3PF2ODrijrfD0RF3vB2Ojrjj7XB0xB1vh6Mj7ng7HB1xx9vh 6Ig73g5HR9zxdjg64o63w9ERd7wdjo644+1wdMQdb4ejI+54Oxwdccfb4eiIO94OR0fc8XY4OuKO t8PREXe8HY6OuOPtcHTEHW+HoyMmnrCESyPcB4dJYd4DByM6T1jiwVX0fGq9vptPnurfhh/EfmsO YHJ3teMzpz5Ferq9cuoZebyEg8HxeOo5r3kdqAN1oA7UgTpQB+pAHagDdeD/wwEOf2lu75ET4VN7 JBdHOfUp0kOjqAFOfKEL39Xgl/jJASxxHdvluuHsUZ8iPdfrS89fOB0TV8O1L+SFiTt7CUMzY+Im bOqoEzdh8GdM3IRNHXXiJgz+jImbsKmjTtyEwZ8xcRM2ddSJmzD4MyZuwqaOOnETBn/GxE3Y1FEn bsLgz5i4CZs66sRNGPwZEzdhU0eduAmDP2PiJmzqqBM3YfBnTNyETR114iYM/oyJm7Cpo07chMGf MXETNnXUiZsw+DMmbsKmjjpxEwZ/xsRN2NRRJ27C4M+YuAmbOurETRj8GRM3YVNHnbgJgz9j4iZs 6qgTN2HwZ0zchE0ddeImDP6MiZuwqaNO3ITBnzFxEzZ11ImbMPgzJm7Cpo46cRMGf8bETdjUUSdu wuDPmLgJmzrqxE0Y/BkTN2FTR524CYM/Y+ImbOqoE9cx5XM45rl4qhPGHN73HO0p+hzv8tQH+y3O A9hvhAEk/sSoiUxBTRSufNbO3/XQenSdDEZLpH8nuv4Of3KqX/5Pb+7U9a/+fWffsra6frp+un7Y DZ/H7p/un+6fz/cNiu6f7p+f7B/+WayvJ3JFrS8N4qtatePkRHSzBmcur53reOI6FvP/iegZTGY6 5rlmmjWzT3zW4vmX9Zw54KhH3+PEqWf0+WbOfBO/W1d/16nMq3/Zl7to/bvrVObVv+zLXbT+3XUq 8+pf9uUuWv/uOpV59S/7chetf3edyrz/NP/0fT695IxrcMq9SbljzHGKaV4w4pzT54NzjOmgdxT8 aibdxLz2XFN4TU6c/Vk7b/ZSLWw35lw7XvE6UAfqQB2oA3WgDtSBOlAH6sBPHEiHt918k3uq7/Sc 47nu77Xns8ezTg74Nn730LXTTfyT2rm73L+Ic4TPGu4Op99YB+pAHagDdaAO1IE6UAfqQB34Ox3Y HeQmPmue2fE7uXTOu1One4Ed43f+ea1PmA50d7DE8Xk9n2aoh957yrmmHjxF536aa76fjOp/4t7v G+XT2er/p45d+fXv6senVf371LErv/5d/fi0qn+fOnbl17+rH59W9e9Tx678+nf149Pq7/RP99b/ 7aaGcr+e4K+PHa62enNMzGvP0U1s1uLdxZjzGDm8HUlvmrs5HNdDq3ZM085amEbCJzbrlzJruT+c T2P12de7Pta/+rfbr3fWUNdP10/Xz52dkjndP90/3T95b9xBu3+6f/7O/TP/h4VYs1qXc0xMdVq/ ifduLvpTC34r/sRIv8FpntS7i3GPxFdvh6O7y3F+8zpQB+pAHagDdaAO1IE6UAfqwF/pwJ1D3Y6z w/X8qXcX4/snPr1b8af/vHbe5HQI3PXA/cuAzfln7RrPnSfcL+95vtM755RXf3Lnfa/+vffoxKh/ J3fe9+rfe49OjPp3cud9r/699+jEqH8nd9736t97j06M+ndy533vv9k/fXf/p7bv3EpeJUzzJDxh Oy7PstPQvx3vHu5uT/gg3pnzxPlu75NnLLcO1IE6UAfqQB2oA3WgDtSBOvBvduB0KPxuDz9Oeji3 4+mAd3uSA/HO/H+K449xZ07nN68DdaAO1IE6UAfqQB2oA3WgDvwTHPj0wHeH/6c43/LnrzycfXKv T7j+xb+r8zma14E6UAfqQB2oA3WgDtSBOlAH/m4H7hwU0zN+ovuEm+51C/s7D2k/vfdP9bcMKqkO 1IE6UAfqQB2oA3WgDtSBOvAPceCnh8Sf6r9lw5/+HxL61kMM0XcOkz81r/rxh/BhWf8+NGzQ698w 5MOy/n1o2KDXv2HIh2X9+9CwQa9/w5APy/r3oWGDXv+GIR+W9e9Dwwb9T/h3Ojf9dP7xuD8rTw/6 s5n/OvV/wnf469zqnepAHagDdaAO1IE6UAfqQB34tznwjzpE/tvM6/PWgTpQB+pAHagDdaAO1IE6 UAfqQB2oA3WgDtSBOlAH6kAdqAN1oA7UgTpQB+pAHagDdaAO1IE6UAfqQB2oA3WgDtSBOlAH6kAd qAN1oA7UgTpQB+pAHagDdeC/wYH/AyTaV6jIVfM3AAAAAElFTkSuQmCC 39458 2009-09-11 11:42:04 -0700 2009-09-15 13:05:18 -0700 proposed patch - 2009/09/11 27514.patch text/plain 54297 pmuellr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0ODMwOSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMzkgQEAKKzIwMDktMDktMTEgIFBhdHJpY2sgTXVlbGxlciAgPFBhdHJpY2tfTXVl bGxlckB1cy5pYm0uY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFkZGVkIFdhdGNoIEV4cHJlc3Npb24gc3VwcG9ydCB0byBJbnNwZWN0b3IKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI3NTE0CisKKyAg ICAgICAgTWFudWFsIHRlc3QgYWRkZWQuCisKKyAgICAgICAgKiBFbmdsaXNoLmxwcm9qL2xvY2Fs aXplZFN0cmluZ3MuanM6CisgICAgICAgICogaW5zcGVjdG9yL2Zyb250LWVuZC9PYmplY3RQcm9w ZXJ0aWVzU2VjdGlvbi5qczoKKyAgICAgICAgKFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0aWVz U2VjdGlvbi5wcm90b3R5cGUuX3VwZGF0ZSk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuT2JqZWN0 UHJvcGVydHlUcmVlRWxlbWVudC5wcm90b3R5cGUudXBkYXRlKToKKyAgICAgICAgKiBpbnNwZWN0 b3IvZnJvbnQtZW5kL1NjcmlwdHNQYW5lbC5qczoKKyAgICAgICAgKFdlYkluc3BlY3Rvci5TY3Jp cHRzUGFuZWwpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLlNjcmlwdHNQYW5lbC5wcm90b3R5cGUu X2NhbGxGcmFtZVNlbGVjdGVkKToKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL1dhdGNo RXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5qczogQWRkZWQuCisgICAgICAgIChXZWJJbnNwZWN0b3Iu V2F0Y2hFeHByZXNzaW9uc1NpZGViYXJQYW5lKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRj aEV4cHJlc3Npb25zU2lkZWJhclBhbmUucHJvdG90eXBlLnJlZnJlc2hFeHByZXNzaW9ucyk6Cisg ICAgICAgIChXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24pOgorICAgICAgICAo V2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS51cGRhdGUpOgor ICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS5f ZGlzcGxheVNvcnQpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0 aW9uLnByb3RvdHlwZS5hZGRFeHByZXNzaW9uKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRj aEV4cHJlc3Npb25zU2VjdGlvbi5wcm90b3R5cGUudXBkYXRlRXhwcmVzc2lvbik6CisgICAgICAg IChXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24ucHJvdG90eXBlLmZpbmRFZGl0 YWJsZVRyZWVFbGVtZW50KToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25z U2VjdGlvbi5wcm90b3R5cGUubG9hZFNhdmVkRXhwcmVzc2lvbnMpOgorICAgICAgICAoV2ViSW5z cGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS5zYXZlRXhwcmVzc2lvbnMp OgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvblRyZWVFbGVtZW50KToKKyAg ICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUu dXBkYXRlKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVu dC5wcm90b3R5cGUuX2RlbGV0ZUJ1dHRvbkNsaWNrZWQpOgorICAgICAgICAoV2ViSW5zcGVjdG9y LldhdGNoRXhwcmVzc2lvblRyZWVFbGVtZW50LnByb3RvdHlwZS5zdGFydEVkaXRpbmcpOgorICAg ICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvblRyZWVFbGVtZW50LnByb3RvdHlwZS5h cHBseUV4cHJlc3Npb24pOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVjdG9y LmNzczoKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5odG1sOgorICAg ICAgICAqIG1hbnVhbC10ZXN0cy9pbnNwZWN0b3IvZGVidWdnZXItd2F0Y2gtZXhwcmVzc2lvbnMu aHRtbDogQWRkZWQuCisKIDIwMDktMDktMTEgIFN0ZXZlIEZhbGtlbmJ1cmcgIDxzZmFsa2VuQGFw cGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KSW5kZXg6IFdlYkNv cmUvaW5zcGVjdG9yL2Zyb250LWVuZC9PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5qcwo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvT2JqZWN0UHJvcGVydGllc1NlY3Rp b24uanMJKHJldmlzaW9uIDQ4Mjc2KQorKysgV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL09i amVjdFByb3BlcnRpZXNTZWN0aW9uLmpzCSh3b3JraW5nIGNvcHkpCkBAIC01Myw4ICs1MywxMSBA QCBXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydGllc1NlY3Rpb24ucHJvCiAgICAgICAgIEluamVj dGVkU2NyaXB0QWNjZXNzLmdldFByb3BlcnRpZXModGhpcy5vYmplY3QsIHRoaXMuaWdub3JlSGFz T3duUHJvcGVydHksIGNhbGxiYWNrKTsKICAgICB9LAogCi0gICAgX3VwZGF0ZTogZnVuY3Rpb24o cHJvcGVydGllcykKKyAgICBfdXBkYXRlOiBmdW5jdGlvbihwcm9wZXJ0aWVzLCB0cmVlRWxlbWVu dENvbnN0cnVjdG9yKQogICAgIHsKKyAgICAgICAgaWYgKCF0cmVlRWxlbWVudENvbnN0cnVjdG9y KQorICAgICAgICAgICAgdHJlZUVsZW1lbnRDb25zdHJ1Y3RvciA9IHRoaXMudHJlZUVsZW1lbnRD b25zdHJ1Y3RvcjsKKyAgICAgICAgICAgIAogICAgICAgICBpZiAodGhpcy5leHRyYVByb3BlcnRp ZXMpCiAgICAgICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IHRoaXMuZXh0cmFQcm9wZXJ0aWVz Lmxlbmd0aDsgKytpKQogICAgICAgICAgICAgICAgIHByb3BlcnRpZXMucHVzaCh0aGlzLmV4dHJh UHJvcGVydGllc1tpXSk7CkBAIC02Myw3ICs2Niw3IEBAIFdlYkluc3BlY3Rvci5PYmplY3RQcm9w ZXJ0aWVzU2VjdGlvbi5wcm8KICAgICAgICAgdGhpcy5wcm9wZXJ0aWVzVHJlZU91dGxpbmUucmVt b3ZlQ2hpbGRyZW4oKTsKIAogICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IHByb3BlcnRpZXMu bGVuZ3RoOyArK2kpCi0gICAgICAgICAgICB0aGlzLnByb3BlcnRpZXNUcmVlT3V0bGluZS5hcHBl bmRDaGlsZChuZXcgdGhpcy50cmVlRWxlbWVudENvbnN0cnVjdG9yKHByb3BlcnRpZXNbaV0pKTsK KyAgICAgICAgICAgIHRoaXMucHJvcGVydGllc1RyZWVPdXRsaW5lLmFwcGVuZENoaWxkKG5ldyB0 cmVlRWxlbWVudENvbnN0cnVjdG9yKHByb3BlcnRpZXNbaV0pKTsKIAogICAgICAgICBpZiAoIXRo aXMucHJvcGVydGllc1RyZWVPdXRsaW5lLmNoaWxkcmVuLmxlbmd0aCkgewogICAgICAgICAgICAg dmFyIHRpdGxlID0gIjxkaXYgY2xhc3M9XCJpbmZvXCI+IiArIHRoaXMuZW1wdHlQbGFjZWhvbGRl ciArICI8L2Rpdj4iOwpAQCAtMTU1LDkgKzE1OCw5IEBAIFdlYkluc3BlY3Rvci5PYmplY3RQcm9w ZXJ0eVRyZWVFbGVtZW50LnAKIAogICAgIHVwZGF0ZTogZnVuY3Rpb24oKQogICAgIHsKLSAgICAg ICAgdmFyIG5hbWVFbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpOwotICAg ICAgICBuYW1lRWxlbWVudC5jbGFzc05hbWUgPSAibmFtZSI7Ci0gICAgICAgIG5hbWVFbGVtZW50 LnRleHRDb250ZW50ID0gdGhpcy5wcm9wZXJ0eS5uYW1lOworICAgICAgICB0aGlzLm5hbWVFbGVt ZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpOworICAgICAgICB0aGlzLm5hbWVF bGVtZW50LmNsYXNzTmFtZSA9ICJuYW1lIjsKKyAgICAgICAgdGhpcy5uYW1lRWxlbWVudC50ZXh0 Q29udGVudCA9IHRoaXMucHJvcGVydHkubmFtZTsKIAogICAgICAgICB0aGlzLnZhbHVlRWxlbWVu dCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoInNwYW4iKTsKICAgICAgICAgdGhpcy52YWx1ZUVs ZW1lbnQuY2xhc3NOYW1lID0gInZhbHVlIjsKQEAgLTE2Nyw3ICsxNzAsNyBAQCBXZWJJbnNwZWN0 b3IuT2JqZWN0UHJvcGVydHlUcmVlRWxlbWVudC5wCiAKICAgICAgICAgdGhpcy5saXN0SXRlbUVs ZW1lbnQucmVtb3ZlQ2hpbGRyZW4oKTsKIAotICAgICAgICB0aGlzLmxpc3RJdGVtRWxlbWVudC5h cHBlbmRDaGlsZChuYW1lRWxlbWVudCk7CisgICAgICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50LmFw cGVuZENoaWxkKHRoaXMubmFtZUVsZW1lbnQpOwogICAgICAgICB0aGlzLmxpc3RJdGVtRWxlbWVu dC5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZSgiOiAiKSk7CiAgICAgICAgIHRo aXMubGlzdEl0ZW1FbGVtZW50LmFwcGVuZENoaWxkKHRoaXMudmFsdWVFbGVtZW50KTsKICAgICAg ICAgdGhpcy5oYXNDaGlsZHJlbiA9IHRoaXMucHJvcGVydHkudmFsdWUuaGFzQ2hpbGRyZW47Cklu ZGV4OiBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvU2NyaXB0c1BhbmVsLmpzCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9TY3JpcHRzUGFuZWwuanMJKHJldmlz aW9uIDQ4Mjc2KQorKysgV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1NjcmlwdHNQYW5lbC5q cwkod29ya2luZyBjb3B5KQpAQCAtMTI3LDYgKzEyNyw3IEBAIFdlYkluc3BlY3Rvci5TY3JpcHRz UGFuZWwgPSBmdW5jdGlvbigpCiAKICAgICB0aGlzLnNpZGViYXJQYW5lcyA9IHt9OwogICAgIHRo aXMuc2lkZWJhclBhbmVzLmNhbGxzdGFjayA9IG5ldyBXZWJJbnNwZWN0b3IuQ2FsbFN0YWNrU2lk ZWJhclBhbmUoKTsKKyAgICB0aGlzLnNpZGViYXJQYW5lcy53YXRjaEV4cHJlc3Npb25zID0gbmV3 IFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUoKTsKICAgICB0aGlzLnNp ZGViYXJQYW5lcy5zY29wZWNoYWluID0gbmV3IFdlYkluc3BlY3Rvci5TY29wZUNoYWluU2lkZWJh clBhbmUoKTsKICAgICB0aGlzLnNpZGViYXJQYW5lcy5icmVha3BvaW50cyA9IG5ldyBXZWJJbnNw ZWN0b3IuQnJlYWtwb2ludHNTaWRlYmFyUGFuZSgpOwogCkBAIC03MDQsNiArNzA1LDcgQEAgV2Vi SW5zcGVjdG9yLlNjcmlwdHNQYW5lbC5wcm90b3R5cGUgPSB7CiAgICAgICAgICAgICByZXR1cm47 CiAKICAgICAgICAgdGhpcy5zaWRlYmFyUGFuZXMuc2NvcGVjaGFpbi51cGRhdGUoY3VycmVudEZy YW1lKTsKKyAgICAgICAgdGhpcy5zaWRlYmFyUGFuZXMud2F0Y2hFeHByZXNzaW9ucy5yZWZyZXNo RXhwcmVzc2lvbnMoKTsKIAogICAgICAgICB2YXIgc2NyaXB0T3JSZXNvdXJjZSA9IHRoaXMuX3Nv dXJjZUlETWFwW2N1cnJlbnRGcmFtZS5zb3VyY2VJRF07CiAgICAgICAgIHRoaXMuX3Nob3dTY3Jp cHRPclJlc291cmNlKHNjcmlwdE9yUmVzb3VyY2UsIGN1cnJlbnRGcmFtZS5saW5lKTsKSW5kZXg6 IFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUu anMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1dhdGNoRXhwcmVz c2lvbnNTaWRlYmFyUGFuZS5qcwkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvaW5zcGVjdG9yL2Zy b250LWVuZC9XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUuanMJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsMjcyIEBACisvKgorICogQ29weXJpZ2h0IChDKSBJQk0gQ29ycC4gMjAwOSAgQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1l dDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l cgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBv ZiBJQk0gQ29ycC4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUg dXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlz IHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFO RCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElD VUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJ R0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVO VElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFU QSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RI RVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CisgKi8KKworV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZSA9IGZ1bmN0 aW9uKCkKK3sKKyAgICBXZWJJbnNwZWN0b3IuU2lkZWJhclBhbmUuY2FsbCh0aGlzLCBXZWJJbnNw ZWN0b3IuVUlTdHJpbmcoIldhdGNoIEV4cHJlc3Npb25zIikpOworCisgICAgdGhpcy5zZWN0aW9u ID0gbmV3IFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbigpOworCisgICAgdGhp cy5ib2R5RWxlbWVudC5hcHBlbmRDaGlsZCh0aGlzLnNlY3Rpb24uZWxlbWVudCk7CisKKyAgICB2 YXIgYWRkRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImJ1dHRvbiIpOworICAgIGFk ZEVsZW1lbnQuc2V0QXR0cmlidXRlKCJ0eXBlIiwgImJ1dHRvbiIpOworICAgIGFkZEVsZW1lbnQu dGV4dENvbnRlbnQgPSBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoIkFkZCIpOworICAgIGFkZEVsZW1l bnQuYWRkRXZlbnRMaXN0ZW5lcigiY2xpY2siLCB0aGlzLnNlY3Rpb24uYWRkRXhwcmVzc2lvbi5i aW5kKHRoaXMuc2VjdGlvbiksIGZhbHNlKTsKKworICAgIHZhciByZWZyZXNoRWxlbWVudCA9IGRv Y3VtZW50LmNyZWF0ZUVsZW1lbnQoImJ1dHRvbiIpOworICAgIHJlZnJlc2hFbGVtZW50LnNldEF0 dHJpYnV0ZSgidHlwZSIsICJidXR0b24iKTsKKyAgICByZWZyZXNoRWxlbWVudC50ZXh0Q29udGVu dCA9IFdlYkluc3BlY3Rvci5VSVN0cmluZygiUmVmcmVzaCIpOworICAgIHJlZnJlc2hFbGVtZW50 LmFkZEV2ZW50TGlzdGVuZXIoImNsaWNrIiwgdGhpcy5zZWN0aW9uLnVwZGF0ZS5iaW5kKHRoaXMu c2VjdGlvbiksIGZhbHNlKTsKKworICAgIHZhciBjZW50ZXJFbGVtZW50ID0gZG9jdW1lbnQuY3Jl YXRlRWxlbWVudCgiZGl2Iik7CisgICAgY2VudGVyRWxlbWVudC5hZGRTdHlsZUNsYXNzKCJ3YXRj aC1leHByZXNzaW9ucy1idXR0b25zLWNvbnRhaW5lciIpOworICAgIGNlbnRlckVsZW1lbnQuYXBw ZW5kQ2hpbGQoYWRkRWxlbWVudCk7CisgICAgY2VudGVyRWxlbWVudC5hcHBlbmRDaGlsZChyZWZy ZXNoRWxlbWVudCk7CisgICAgdGhpcy5ib2R5RWxlbWVudC5hcHBlbmRDaGlsZChjZW50ZXJFbGVt ZW50KTsKKworICAgIC8vIGlkZWFsbHkgd2UnZCBpbnRlbGxpZ2VudGx5IGV4cGFuZCBpZiB3ZSBo YXZlIGFueSB3YXRjaCBleHByZXNzaW9ucywKKyAgICAvLyBidXQgdGhlcmUncyBhIHRpbWluZyBl cnJvciBvZiBzb21lIGtpbmQgd2l0aCB0aGUgSW5qZWN0ZWRTY3JpcHRBY2Nlc3MsCisgICAgLy8g c28gZm9yY2luZyBleHBhbmRlZCA9IGZhbHNlLCBhbmQgcmVmcmVzaCB1cG9uIGV4cGFuc2lvbgor ICAgIHRoaXMuZXhwYW5kZWQgPSBmYWxzZTsKKyAgICB0aGlzLm9uZXhwYW5kID0gdGhpcy5yZWZy ZXNoRXhwcmVzc2lvbnMuYmluZCh0aGlzKTsKK30KKworV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVz c2lvbnNTaWRlYmFyUGFuZS5wcm90b3R5cGUgPSB7CisgICAgcmVmcmVzaEV4cHJlc3Npb25zOiBm dW5jdGlvbigpCisgICAgeworICAgICAgICB0aGlzLnNlY3Rpb24udXBkYXRlKCk7CisgICAgfQor fQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NpZGViYXJQYW5lLnByb3RvdHlwZS5f X3Byb3RvX18gPSBXZWJJbnNwZWN0b3IuU2lkZWJhclBhbmUucHJvdG90eXBlOworCisvLy0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24g PSBmdW5jdGlvbigpCit7CisgICAgV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnRpZXNTZWN0aW9u LmNhbGwodGhpcyk7CisKKyAgICB0aGlzLndhdGNoRXhwcmVzc2lvbnMgPSB0aGlzLmxvYWRTYXZl ZEV4cHJlc3Npb25zKCk7CisKKyAgICB0aGlzLmhlYWRlckVsZW1lbnQuY2xhc3NOYW1lID0gImhp ZGRlbiI7CisgICAgdGhpcy5lZGl0YWJsZSA9IHRydWU7CisgICAgdGhpcy50cmVlRWxlbWVudENv bnN0cnVjdG9yID0gV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnR5VHJlZUVsZW1lbnQ7CisgICAg dGhpcy5leHBhbmRlZCA9IHRydWU7Cit9CisKK1dlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25z U2VjdGlvbi5wcm90b3R5cGUgPSB7CisKKyAgICB1cGRhdGU6IGZ1bmN0aW9uKCkKKyAgICB7Cisg ICAgICAgIGZ1bmN0aW9uIGFwcGVuZFJlc3VsdChleHByZXNzaW9uLCB3YXRjaEluZGV4LCByZXN1 bHQsIGV4Y2VwdGlvbikKKyAgICAgICAgeworICAgICAgICAgICAgLy8gdGhlIG51bGwgY2hlY2sg Y2F0Y2hlcyBzb21lIG90aGVyIGNhc2VzLCBsaWtlIG51bGwgaXRzZWxmLAorICAgICAgICAgICAg Ly8gYW5kIE5hTgorICAgICAgICAgICAgaWYgKCh0eXBlb2YgcmVzdWx0ICE9PSAib2JqZWN0Iikg fHwgKHJlc3VsdCA9PSBudWxsKSkKKyAgICAgICAgICAgICAgICByZXN1bHQgPSBuZXcgV2ViSW5z cGVjdG9yLk9iamVjdFByb3h5KG51bGwsIFtdLCAwLCBTdHJpbmcocmVzdWx0KSwgZmFsc2UpOwor CisgICAgICAgICAgICB2YXIgcHJvcGVydHkgPSBuZXcgV2ViSW5zcGVjdG9yLk9iamVjdFByb3Bl cnR5UHJveHkoZXhwcmVzc2lvbiwgcmVzdWx0KTsKKyAgICAgICAgICAgIHByb3BlcnR5LndhdGNo SW5kZXggPSB3YXRjaEluZGV4OworCisgICAgICAgICAgICAvLyBmb3IgbmV3bHkgYWRkZWQsIGVt cHR5IGV4cHJlc3Npb25zLCBzZXQgZGVzY3JpcHRpb24gdG8gIiIsCisgICAgICAgICAgICAvLyBz aW5jZSBvdGhlcndpc2UgeW91IGdldCBET01XaW5kb3cKKyAgICAgICAgICAgIGlmIChwcm9wZXJ0 eS5uYW1lID09PSAiIikgCisgICAgICAgICAgICAgICAgcHJvcGVydHkudmFsdWUuZGVzY3JpcHRp b24gPSAiIjsKKyAgICAgICAgICAgIAorICAgICAgICAgICAgcHJvcGVydGllcy5wdXNoKHByb3Bl cnR5KTsKKyAgICAgICAgICAgIGlmIChwcm9wZXJ0aWVzLmxlbmd0aCA9PSBwcm9wZXJ0eUNvdW50 KQorICAgICAgICAgICAgICAgIHRoaXMuX3VwZGF0ZShwcm9wZXJ0aWVzLCBXZWJJbnNwZWN0b3Iu V2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1lbnQpOworICAgICAgICB9CisKKyAgICAgICAgdmFyIHBy b3BlcnRpZXMgPSBbXTsKKworICAgICAgICAvLyBjb3VudCB0aGUgcHJvcGVydGllcywgc28gd2Ug a25vd24gd2hlbiB0byBjYWxsIHRoaXMuX3VwZGF0ZSgpCisgICAgICAgIC8vIGluIGFwcGVuZFJl c3VsdCgpCisgICAgICAgIHZhciBwcm9wZXJ0eUNvdW50ID0gMDsKKyAgICAgICAgZm9yICh2YXIg aT0wOyBpPHRoaXMud2F0Y2hFeHByZXNzaW9ucy5sZW5ndGg7ICsraSkgeworICAgICAgICAgICAg aWYgKHRoaXMud2F0Y2hFeHByZXNzaW9uc1tpXSA9PT0gdW5kZWZpbmVkKSAKKyAgICAgICAgICAg ICAgICBjb250aW51ZTsKKyAgICAgICAgICAgICsrcHJvcGVydHlDb3VudDsKKyAgICAgICAgfQor CisgICAgICAgIGZvciAodmFyIGk9MDsgaTx0aGlzLndhdGNoRXhwcmVzc2lvbnMubGVuZ3RoOyAr K2kpIHsKKyAgICAgICAgICAgIHZhciBleHByZXNzaW9uID0gdGhpcy53YXRjaEV4cHJlc3Npb25z W2ldOworICAgICAgICAgICAgaWYgKGV4cHJlc3Npb24gPT09IHVuZGVmaW5lZCkgCisgICAgICAg ICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgICAgIFdlYkluc3BlY3Rvci5jb25zb2xlLl9l dmFsSW5JbnNwZWN0ZWRXaW5kb3coZXhwcmVzc2lvbiwgYXBwZW5kUmVzdWx0LmJpbmQodGhpcywg ZXhwcmVzc2lvbiwgaSkpOworICAgICAgICB9CisKKyAgICAgICAgdGhpcy5leHBhbmRlZCA9IChw cm9wZXJ0eUNvdW50ICE9IDApOworICAgIH0sCisKKyAgICBfZGlzcGxheVNvcnQ6IGZ1bmN0aW9u KHByb3BlcnR5QSwgcHJvcGVydHlCKQorICAgIHsKKyAgICAgICAgaWYgKHByb3BlcnR5QS53YXRj aEluZGV4ID09IHByb3BlcnR5Qi53YXRjaEluZGV4KQorICAgICAgICAgICAgcmV0dXJuIDA7Cisg ICAgICAgIGVsc2UgaWYgKHByb3BlcnR5QS53YXRjaEluZGV4IDwgcHJvcGVydHlCLndhdGNoSW5k ZXgpCisgICAgICAgICAgICByZXR1cm4gLTE7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHJl dHVybiAxOworICAgIH0sCisKKyAgICBhZGRFeHByZXNzaW9uOiBmdW5jdGlvbigpCisgICAgewor ICAgICAgICB0aGlzLndhdGNoRXhwcmVzc2lvbnMucHVzaCgiIik7CisgICAgICAgIHRoaXMudXBk YXRlKCk7CisKKyAgICAgICAgLy8gdW5wcmV0dHkgY29kZSBoZXJlOyBub3doZXJlIGVsc2UgZG8g d2UgZHJpbGwgZG93bgorICAgICAgICAvLyBpbnRvIHRyZWUgZWxlbWVudHMsIGJ1dCB3ZSBuZWVk IHRvIGRvIGl0IGhlcmUgYXMgCisgICAgICAgIC8vIHRoZSBuZXdseSBhZGRlZCBlbGVtZW50IG5l ZWRzIHRvIGJlIGFkZGVkIHRvIHRoZSAKKyAgICAgICAgLy8gdHJlZSBCRUZPUkUgd2Ugc3RhcnQg ZWRpdGluZyBpdC4KKyAgICAgICAgdHJlZUVsZW1lbnQgPSB0aGlzLmZpbmRFZGl0YWJsZVRyZWVF bGVtZW50KCk7CisgICAgICAgIGlmICh0cmVlRWxlbWVudCkKKyAgICAgICAgICAgIHRyZWVFbGVt ZW50LnN0YXJ0RWRpdGluZygpOworICAgIH0sCisKKyAgICB1cGRhdGVFeHByZXNzaW9uOiBmdW5j dGlvbihlbGVtZW50LCB2YWx1ZSkKKyAgICB7CisgICAgICAgIHRoaXMud2F0Y2hFeHByZXNzaW9u c1tlbGVtZW50LnByb3BlcnR5LndhdGNoSW5kZXhdID0gdmFsdWU7CisgICAgICAgIHRoaXMuc2F2 ZUV4cHJlc3Npb25zKCk7CisgICAgICAgIHRoaXMudXBkYXRlKCk7CisgICAgfSwKKworICAgIGZp bmRFZGl0YWJsZVRyZWVFbGVtZW50OiBmdW5jdGlvbigpCisgICAgeworICAgICAgICB2YXIgY2hp bGRyZW4gPSB0aGlzLnByb3BlcnRpZXNUcmVlT3V0bGluZS5jaGlsZHJlbjsKKyAgICAgICAgZm9y ICh2YXIgaT0wOyBpPGNoaWxkcmVuLmxlbmd0aDsgKytpKQorICAgICAgICAgICAgaWYgKGNoaWxk cmVuW2ldLnByb3BlcnR5Lm5hbWUgPT09ICIiKQorICAgICAgICAgICAgICAgIHJldHVybiBjaGls ZHJlbltpXTsKKyAgICB9LAorCisgICAgbG9hZFNhdmVkRXhwcmVzc2lvbnM6IGZ1bmN0aW9uKCkK KyAgICB7CisgICAgICAgIGlmICghd2luZG93LkpTT04pCisgICAgICAgICAgICByZXR1cm4gW107 CisKKyAgICAgICAgdmFyIGpzb24gPSBJbnNwZWN0b3JDb250cm9sbGVyLnNldHRpbmcoIndhdGNo RXhwcmVzc2lvbnMiKTsKKyAgICAgICAgaWYgKCFqc29uKQorICAgICAgICAgICAgcmV0dXJuIFtd OworCisgICAgICAgIHRyeSB7CisgICAgICAgICAgICBqc29uID0gSlNPTi5wYXJzZShqc29uKTsK KyAgICAgICAgfQorICAgICAgICBjYXRjaChlKSB7CisgICAgICAgICAgICByZXR1cm4gW107Cisg ICAgICAgIH0KKworICAgICAgICByZXR1cm4ganNvbi5leHByZXNzaW9ucyB8fCBbXTsKKyAgICB9 LAorCisgICAgc2F2ZUV4cHJlc3Npb25zOiBmdW5jdGlvbigpCisgICAgeworICAgICAgICBpZiAo IXdpbmRvdy5KU09OKQorICAgICAgICAgICAgcmV0dXJuOworCisgICAgICAgIHZhciB0b1NhdmUg PSBbXTsKKyAgICAgICAgZm9yICh2YXIgaT0wOyBpPHRoaXMud2F0Y2hFeHByZXNzaW9ucy5sZW5n dGg7IGkrKykKKyAgICAgICAgICAgIGlmICh0aGlzLndhdGNoRXhwcmVzc2lvbnNbaV0pCisgICAg ICAgICAgICAgICAgdG9TYXZlLnB1c2godGhpcy53YXRjaEV4cHJlc3Npb25zW2ldKTsKKworICAg ICAgICB2YXIganNvbiA9IEpTT04uc3RyaW5naWZ5KHtleHByZXNzaW9uczogdG9TYXZlfSk7Cisg ICAgICAgIEluc3BlY3RvckNvbnRyb2xsZXIuc2V0U2V0dGluZygid2F0Y2hFeHByZXNzaW9ucyIs IGpzb24pOworCisgICAgICAgIHJldHVybiB0b1NhdmUubGVuZ3RoOworICAgIH0KKworfQorCitX ZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24ucHJvdG90eXBlLl9fcHJvdG9fXyA9 IFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5wcm90b3R5cGU7CisKKy8vLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCisKK1dlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxl bWVudCA9IGZ1bmN0aW9uKHByb3BlcnR5KQoreworICAgIFdlYkluc3BlY3Rvci5PYmplY3RQcm9w ZXJ0eVRyZWVFbGVtZW50LmNhbGwodGhpcywgcHJvcGVydHkpOworfQorCitXZWJJbnNwZWN0b3Iu V2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1lbnQucHJvdG90eXBlID0geworICAgIHVwZGF0ZTogZnVu Y3Rpb24oKQorICAgIHsKKyAgICAgICAgV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnR5VHJlZUVs ZW1lbnQucHJvdG90eXBlLnVwZGF0ZS5jYWxsKHRoaXMpOworCisgICAgICAgIHZhciBkZWxldGVC dXR0b247CisgICAgICAgIGRlbGV0ZUJ1dHRvbiA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImlu cHV0Iik7CisgICAgICAgIGRlbGV0ZUJ1dHRvbi50eXBlID0gImJ1dHRvbiI7CisgICAgICAgIGRl bGV0ZUJ1dHRvbi50aXRsZSA9IFdlYkluc3BlY3Rvci5VSVN0cmluZygiRGVsZXRlIHdhdGNoIGV4 cHJlc3Npb24uIik7CisgICAgICAgIGRlbGV0ZUJ1dHRvbi5hZGRTdHlsZUNsYXNzKCJlbmFibGVk LWJ1dHRvbiIpOworICAgICAgICBkZWxldGVCdXR0b24uYWRkU3R5bGVDbGFzcygiZGVsZXRlLWJ1 dHRvbiIpOworICAgICAgICBkZWxldGVCdXR0b24uYWRkRXZlbnRMaXN0ZW5lcigiY2xpY2siLCB0 aGlzLl9kZWxldGVCdXR0b25DbGlja2VkLmJpbmQodGhpcyksIGZhbHNlKTsKKworICAgICAgICB0 aGlzLmxpc3RJdGVtRWxlbWVudC5pbnNlcnRCZWZvcmUoZGVsZXRlQnV0dG9uLCB0aGlzLmxpc3RJ dGVtRWxlbWVudC5maXJzdENoaWxkKTsKKyAgICB9LAorCisgICAgX2RlbGV0ZUJ1dHRvbkNsaWNr ZWQ6IGZ1bmN0aW9uKCkKKyAgICB7CisgICAgICAgIHRoaXMudHJlZU91dGxpbmUuc2VjdGlvbi51 cGRhdGVFeHByZXNzaW9uKHRoaXMsIHVuZGVmaW5lZCk7CisgICAgfSwKKworICAgIHN0YXJ0RWRp dGluZzogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgaWYgKFdlYkluc3BlY3Rvci5pc0JlaW5n RWRpdGVkKHRoaXMubmFtZUVsZW1lbnQpIHx8ICF0aGlzLnRyZWVPdXRsaW5lLnNlY3Rpb24uZWRp dGFibGUpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgaWYgKHRoaXMucHJvcGVydHku bmFtZSA9PT0gIiIpCisgICAgICAgICAgICB0aGlzLm5hbWVFbGVtZW50LnRleHRDb250ZW50ID0g Ilx4QTBceEEwXHhBMFx4QTBceEEwXHhBMFx4QTBceEEwXHhBMCI7CisKKyAgICAgICAgdmFyIGNv bnRleHQgPSB7IGV4cGFuZGVkOiB0aGlzLmV4cGFuZGVkIH07CisKKyAgICAgICAgLy8gY29sbGFw c2UgdGVtcG9yYXJpbHksIGlmIHJlcXVpcmVkCisgICAgICAgIHRoaXMuaGFzQ2hpbGRyZW4gPSBm YWxzZTsKKworICAgICAgICB0aGlzLmxpc3RJdGVtRWxlbWVudC5hZGRTdHlsZUNsYXNzKCJlZGl0 aW5nLXN1Yi1wYXJ0Iik7CisKKyAgICAgICAgV2ViSW5zcGVjdG9yLnN0YXJ0RWRpdGluZygKKyAg ICAgICAgICAgIHRoaXMubmFtZUVsZW1lbnQsCisgICAgICAgICAgICB0aGlzLmVkaXRpbmdDb21t aXR0ZWQuYmluZCh0aGlzKSwKKyAgICAgICAgICAgIHRoaXMuZWRpdGluZ0NhbmNlbGxlZC5iaW5k KHRoaXMpLAorICAgICAgICAgICAgY29udGV4dCk7CisgICAgfSwKKworICAgIGFwcGx5RXhwcmVz c2lvbjogZnVuY3Rpb24oZXhwcmVzc2lvbiwgdXBkYXRlSW50ZXJmYWNlKQorICAgIHsKKyAgICAg ICAgZXhwcmVzc2lvbiA9IGV4cHJlc3Npb24udHJpbVdoaXRlc3BhY2UoKTsKKworICAgICAgICBp ZiAoZXhwcmVzc2lvbiA9PT0gIiIpCisgICAgICAgICAgICBleHByZXNzaW9uID0gdW5kZWZpbmVk OworCisgICAgICAgIHRoaXMucHJvcGVydHkubmFtZSA9IGV4cHJlc3Npb247CisgICAgICAgIHRo aXMudHJlZU91dGxpbmUuc2VjdGlvbi51cGRhdGVFeHByZXNzaW9uKHRoaXMsIGV4cHJlc3Npb24p OworICAgIH0sCisKK30KKworV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvblRyZWVFbGVtZW50 LnByb3RvdHlwZS5fX3Byb3RvX18gPSBXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydHlUcmVlRWxl bWVudC5wcm90b3R5cGU7CkluZGV4OiBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVj dG9yLmNzcwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVj dG9yLmNzcwkocmV2aXNpb24gNDgyNzYpCisrKyBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQv aW5zcGVjdG9yLmNzcwkod29ya2luZyBjb3B5KQpAQCAtMTIwNiw2ICsxMjA2LDEwIEBAIGJvZHku aW5hY3RpdmUgLnBsYWNhcmQuc2VsZWN0ZWQgewogICAgIG1hcmdpbi1ib3R0b206IDFweDsKIH0K IAorLndhdGNoLWV4cHJlc3Npb25zLWJ1dHRvbnMtY29udGFpbmVyIHsKKyAgICB0ZXh0LWFsaWdu OiBjZW50ZXI7Cit9CisKIC5zZWN0aW9uIC5oZWFkZXIgewogICAgIHBhZGRpbmc6IDJweCA4cHgg NHB4IDE4cHg7CiAgICAgYm9yZGVyLXRvcDogMXB4IHNvbGlkIHJnYigxNDUsIDE2MCwgMTkyKTsK QEAgLTE0MDksNiArMTQxMywxNiBAQCBsaS5lZGl0aW5nIC5zd2F0Y2gsIGxpLmVkaXRpbmcgLmVu YWJsZWQtCiAgICAgei1pbmRleDogMTsKIH0KIAorLnNlY3Rpb24gLnByb3BlcnRpZXMgLmRlbGV0 ZS1idXR0b24geworICAgIHdpZHRoOiAxMHB4OworICAgIGhlaWdodDogMTBweDsKKyAgICBiYWNr Z3JvdW5kLWltYWdlOiB1cmwoSW1hZ2VzL2Vycm9ySWNvbi5wbmcpOworICAgIGJhY2tncm91bmQt cG9zaXRpb246IDAgMDsKKyAgICBiYWNrZ3JvdW5kLWNvbG9yOiB0cmFuc3BhcmVudDsKKyAgICBi YWNrZ3JvdW5kLXJlcGVhdDogbm8tcmVwZWF0OworICAgIGJvcmRlcjogMCBub25lIHRyYW5zcGFy ZW50OworfQorCiAuc2VjdGlvbjpob3ZlciAucHJvcGVydGllcyAuZW5hYmxlZC1idXR0b24gewog ICAgIGRpc3BsYXk6IGJsb2NrOwogfQpJbmRleDogV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5k L2luc3BlY3Rvci5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVu ZC9pbnNwZWN0b3IuaHRtbAkocmV2aXNpb24gNDgyNzYpCisrKyBXZWJDb3JlL2luc3BlY3Rvci9m cm9udC1lbmQvaW5zcGVjdG9yLmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTYxLDYgKzYxLDcgQEAg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQTwogICAgIDxzY3JpcHQgdHlw ZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IkJyZWFrcG9pbnRzU2lkZWJhclBhbmUuanMiPjwvc2Ny aXB0PgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IkNhbGxTdGFja1Np ZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlw dCIgc3JjPSJTY29wZUNoYWluU2lkZWJhclBhbmUuanMiPjwvc2NyaXB0PgorICAgIDxzY3JpcHQg dHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IldhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5q cyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iTWV0 cmljc1NpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2 YXNjcmlwdCIgc3JjPSJQcm9wZXJ0aWVzU2lkZWJhclBhbmUuanMiPjwvc2NyaXB0PgogICAgIDxz Y3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IkNvbG9yLmpzIj48L3NjcmlwdD4KSW5k ZXg6IFdlYkNvcmUvbWFudWFsLXRlc3RzL2luc3BlY3Rvci9kZWJ1Z2dlci13YXRjaC1leHByZXNz aW9ucy5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbWFudWFsLXRlc3RzL2luc3BlY3Rvci9k ZWJ1Z2dlci13YXRjaC1leHByZXNzaW9ucy5odG1sCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9t YW51YWwtdGVzdHMvaW5zcGVjdG9yL2RlYnVnZ2VyLXdhdGNoLWV4cHJlc3Npb25zLmh0bWwJKHJl dmlzaW9uIDApCkBAIC0wLDAgKzEsMTEyIEBACis8cD5UZXN0IGZvciAKKzxhIGhyZWY9Imh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzUxNCI+QnVnIDI3NTE0IC0gYWRk IHN1cHBvcnQgZm9yIHdhdGNoZWQgZXhwcmVzc2lvbjwvYT4uCisKKzxwPlRvIGJlZ2luIHRlc3Qs IG9wZW4gd2ViIGluc3BlY3RvciwgZ28gdGhlIHNjcmlwdHMgcGFuZWwgCisoZW5hYmxpbmcgc2Ny aXB0IGRlYnVnZ2luZyBpZiBuZWNjY2Vzc2FyeSksIGFuZCB0aGVuIGNsaWNrIHRoaXMgbGluazoK KzxhIGhyZWY9ImphdmFzY3JpcHQ6cnVuVGVzdCgpIj5bYmVnaW4gdGVzdF08L2E+LgorCis8cD5Q ZXJmb3JtIHRoZSBmb2xsb3dpbmcgc3RlcHMsIGFuZCBub3RlIHRoZSBleHBlY3RlZCByZXN1bHRz OgorICAgIAorPG9sPgorICAgIAorPGxpPjxwPkFmdGVyIGNsaWNraW5nIHRoZSBsaW5rIGFib3Zl LCB5b3Ugc2hvdWxkIG5vdyBiZSBwYXVzZWQgaW4gdGhlIGJvZHkgb2YgCit0aGUgdGVzdCBtZXRo b2QsIHRoYW5rcyB0byB0aGUgPGNvZGU+ZGVidWdnZXI8L2NvZGU+IHN0YXRlbWVudC4KKworPGxp PjxwPkFkZCB0aGUgZm9sbG93aW5nIGV4cHJlc3Npb25zIHRvIHRoZSAiV2F0Y2ggRXhwcmVzc2lv bnMiIHNlY3Rpb24gb2YgdGhlCitTY3JpcHRzIHBhbmVsIHNpZGViYXIgcGFuZTogIjxjb2RlPnRo aXM8L2NvZGU+IiwgIjxjb2RlPmE8L2NvZGU+IiwgCisiPGNvZGU+YjwvY29kZT4iLCAiPGNvZGU+ YzwvY29kZT4iIGFuZCAiPGNvZGU+ZDwvY29kZT4iLiBEbyA8Yj5OT1Q8L2I+IGVudGVyIHRoZSBx dW90ZXMuCisKKzxsaT48cD5UaGUgdmFsdWVzIG9mIHRoZSBleHByZXNzaW9ucyBhcyBzaG93biBp biB0aGUgd2luZG93IHNob3VsZCBhIAorPGNvZGU+RE9NV2luZG93PC9jb2RlPiBmb3IgPGNvZGU+ dGhpczwvY29kZT4sIDxjb2RlPnVuZGVmaW5lZDwvY29kZT4gZm9yCit0aGUgPGNvZGU+YTwvY29k ZT4sIDxjb2RlPmI8L2NvZGU+LCBhbmQgPGNvZGU+YzwvY29kZT4gdmFyaWFibGVzLCBhbmQgYSAK K3ZhbHVlIG9mIDxjb2RlPlJlZmVyZW5jZUVycm9yOiBDYW4ndCBmaW5kIHZhcmlhYmxlOiBkPC9j b2RlPgorZm9yIHRoZSA8Y29kZT5kPC9jb2RlPiB2YXJpYWJsZS4KKworPGxpPjxwPk5vdGUgdGhh dCB0aGUgdmFsdWUgZm9yIDxjb2RlPmQ8L2NvZGU+IHNob3VsZCBub3QgY2hhbmdlIGZvciB0aGUg bGlmZSBvZiAKK3RoZSB0ZXN0LCBhcyB0aGUgdmFyaWFibGUgPGNvZGU+ZDwvY29kZT4gaXMgbmV2 ZXIgaW50cm9kdWNlZCBpbiB0aGUgcHJvZ3JhbS4KKworPGxpPjxwPlN0ZXAgdGhyb3VnaCB0aGUg Y29kZSwgYW5kIHlvdSdsbCBzZWUgdGhlIHZhbHVlcyBvZiA8Y29kZT5hPC9jb2RlPiwKKzxjb2Rl PmI8L2NvZGU+LCBhbmQgPGNvZGU+YzwvY29kZT4gY2hhbmdlLCBhcyB0aGUgdmFyaWFibGVzIGFy ZSBhc3NpZ25lZC4KK0Fsc28gbm90ZSB0aGF0IGFzIHRoZSBzY29wZSBjaGFuZ2VzIGR1ZSB0byB0 aGUgZnVuY3Rpb24gaW52b2NhdGlvbiwgdmFsdWVzCit3aWxsIGJlIGNoYW5nZWQgdG8gcmVmZXIg dG8gdGhlaXIgY3VycmVudCBzY29wZS4gIFRoZSA8Y29kZT50aGlzPC9jb2RlPgorZXhwcmVzc2lv biB3aWxsIGNoYW5nZSB3aGVuIHRoZSBtZXRob2QgaXMgaW52b2tlZCBvbiB0aGUgb2JqZWN0IGNv bnN0cnVjdGVkIGJ5Cit0aGUgdGVzdC4KKworPGxpPjxwPkNsaWNrIGRpZmZlcmVudCBzdGFjayBm cmFtZXMgaW4gdGhlIENhbGwgU3RhY2sgc2VjdGlvbiB0byBlbnN1cmUgdGhlCitleHByZXNzaW9u cyBjaGFuZ2UgdmFsdWUgYXBwcm9wcmlhdGVseSBhcyB0aGUgY3VycmVudCBzdGFjayBmcmFtZSBj aGFuZ2VzLgorCis8bGk+PHA+RHJpdmUgdGhlIGRlYnVnZ2VyIHRocm91Z2ggdGhlIGVuZCBvZiB0 aGUgb3V0ZXJtb3N0IGZ1bmN0aW9uLCBzbyB0aGF0Cit0aGUgZGVidWdnZXIgaXMgbm8gbG9uZ2Vy IGluIHBhdXNlZCBzdGF0ZS4gIFRoZSB2YWx1ZXMgb2YgCis8Y29kZT5hPC9jb2RlPiwgPGNvZGU+ YjwvY29kZT4sIGFuZCA8Y29kZT5jPC9jb2RlPiBzaG91bGQgYWxsIGJlIGEKK1JlZmVyZW5jZUVy cm9yIGxpa2UgPGNvZGU+ZDwvY29kZT4sIHNpbmNlIHRoZXNlIHZhcmlhYmxlcyBhcmUgZGVmaW5l ZCBpbiB0aGUKKzxjb2RlPnJ1blRlc3QoKTwvY29kZT4gZnVuY3Rpb24sIGFuZCB0aGUgZXhwcmVz c2lvbnMgYXJlIGJlaW5nIGV2YWx1YXRlZCBhZ2FpbnN0Cit0aGUgZ2xvYmFsIG9iamVjdC4KKwor PGxpPjxwPkZyb20gdGhlIGNvbnNvbGUsIGV4ZWN1dGUgdGhlIHN0YXRlbWVudCAiPGNvZGU+YSA9 IDE8L2NvZGU+Ii4gIFRoZQord2F0Y2ggZXhwcmVzc2lvbnMgZG8gbm90IGN1cnJlbnRseSByZWZy ZXNoLCBzbyB0aGUgdmFsdWUgZm9yIDxjb2RlPmE8L2NvZGU+CitzaG91bGQgc3RpbGwgYmUgUmVm ZXJlbmNlRXJyb3IuCisKKzxsaT48cD5DbGljayB0aGUgIlJlZnJlc2giIGJ1dHRvbiBpbiB0aGUg V2F0Y2ggRXhwcmVzc2lvbnMgc2VjdGlvbiBhbmQgdGhlCit2YWx1ZSBmb3IgIjxjb2RlPmE8L2Nv ZGU+IiBzaG91bGQgbm93IGJlICI8Y29kZT4xPC9jb2RlPiIuCisKKzxsaT48cD5DbG9zZSBkb3du IHRoZSBicm93c2VyLCBzdGFydCBpdCBiYWNrIHVwLCB0cmF2ZXJzZSB0byBhIHdlYiBzaXRlLAor YnJpbmcgdXAgd2ViIGluc3BlY3RvciwgZ28gdG8gdGhlIFNjcmlwdHMgcGFuZWwuICBZb3Ugc2hv dWxkIHNlZSB0aGUgc2FtZQorc2V0IG9mIFdhdGNoIEV4cHJlc3Npb25zIGluIHRoZSBsaXN0IGFz IHlvdSBoYWQgd2hlbiB5b3UgbGFzdCB1c2VkIHdlYgoraW5zcGVjdG9yLgorCis8bGk+PHA+RGVs ZXRlIGFuIGV4cHJlc3Npb24gYnkgbW92aW5nIHRoZSBtb3VzZSBpbnRvIHRoZSBXYXRjaCBFeHBy ZXNzaW9uCitzZWN0aW9uLCBhbmQgY2xpY2tpbmcgdGhlIFggaWNvbiB3aGljaCBhcHBlYXJzIHRv IHRoZSByaWdodCBvZiBhbiAKK2V4cHJlc3Npb24gKG9uIGhvdmVyKS4KKworPGxpPjxwPkRlbGV0 ZSBhbiBleHByZXNzaW9uIGJ5IGRvdWJsZS1jbGlja2luZyBhbnl3aGVyZSBvbiBhIHRvcC1sZXZl bCBsaW5lCitvZiBhIHdhdGNoIGV4cHJlc3Npb24sIGFuZCBjaGFuZ2luZyB0aGUgZXhwcmVzc2lv biB0byBhbiBlbXB0eSBzdHJpbmcgb3IgCitub3RoaW5nIGJ1dCB3aGl0ZS1zcGFjZS4KKworPGxp PjxwPk1vZGlmeSBhbiBlbnRyeSBieSBkb3VibGUtY2xpY2tpbmcgYW55d2hlcmUgb24gYSB0b3At bGV2ZWwgbGluZQorb2YgYSB3YXRjaCBleHByZXNzaW9uLCBhbmQgY2hhbmdpbmcgdGhlIGV4cHJl c3Npb24uCisKKzxsaT48cD5FbnRlciBhIG5ldyBleHByZXNzaW9uLCAiPGNvZGU+bmV3IERhdGUo KTwvY29kZT4iLiAgVGhlIHZhbHVlIHNob3VsZCBiZQorYSB0b1N0cmluZygpIHZlcnNpb24gb2Yg dGhlIGRhdGUuICBSZXBlYXRlZGx5IHByZXNzIHRoZSBSZWZyZXNoIGJ1dHRvbiB0byBzZWUKK3Ro ZSB2YWx1ZSB1cGRhdGVkIHdpdGggdGhlIGN1cnJlbnQgdGltZS4KKworPC9vbD4KKworPHNjcmlw dD4KK2Z1bmN0aW9uIHJ1blRlc3QoKSB7CisgICAgCisgICAgLy8gYSBuZXN0ZWQgZnVuY3Rpb24K KyAgICBmdW5jdGlvbiBzdWJGdW5jdGlvbigpIHsKKyAgICAgICAgZGVidWdnZXI7CisgICAgICAg IHZhciBhID0gImEgaW4gc3ViRnVuY3Rpb24oKSI7CisgICAgICAgIAorICAgICAgICBzdWJTdWJG dW5jdGlvbigpOworICAgICAgICAKKyAgICAgICAgLy8gYW5vdGhlciBuZXN0ZWQgZnVuY3Rpb24K KyAgICAgICAgZnVuY3Rpb24gc3ViU3ViRnVuY3Rpb24oKSB7CisgICAgICAgICAgICBkZWJ1Z2dl cjsKKyAgICAgICAgICAgIHZhciBiID0gImIgaW4gc3ViU3ViRnVuY3Rpb24oKSI7CisgICAgICAg IH0KKyAgICB9CisgICAgCisgICAgLy8gYSBjbGFzcworICAgIGZ1bmN0aW9uIGFDbGFzcygpIHt9 CisgICAgCisgICAgYUNsYXNzLnByb3RvdHlwZS5hTWV0aG9kID0gZnVuY3Rpb24oKSB7CisgICAg ICAgIGRlYnVnZ2VyOworICAgICAgICB2YXIgYyA9ICJjIGluIGFNZXRob2QoKSI7CisgICAgfQor ICAgIAorICAgIC8vIG1haW4gbG9naWMKKyAgICBkZWJ1Z2dlcjsKKyAgICAKKyAgICB2YXIgYSA9 ICJhIGluIHJ1blRlc3QoKSI7CisgICAgdmFyIGIgPSAiYiBpbiBydW5UZXN0KCkiOworICAgIHZh ciBjID0gImMgaW4gcnVuVGVzdCgpIjsKKyAgICAKKyAgICBzdWJGdW5jdGlvbigpOworICAgIAor ICAgIHZhciBvYmplY3QgPSBuZXcgYUNsYXNzKCk7CisgICAgb2JqZWN0LmFNZXRob2QoKTsKKyAg ICAKK30KKzwvc2NyaXB0PgpJbmRleDogV2ViQ29yZS9FbmdsaXNoLmxwcm9qL2xvY2FsaXplZFN0 cmluZ3MuanMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQpDYW5ub3QgZGlzcGxheTogZmlsZSBtYXJrZWQgYXMgYSBiaW5h cnkgdHlwZS4Kc3ZuOm1pbWUtdHlwZSA9IGFwcGxpY2F0aW9uL29jdGV0LXN0cmVhbQoKLy81MkFH RUFjZ0FnQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFJQUE5QUNB QWJnQmxBSGNBSUFCUApBR0lBYWdCbEFHTUFkQUE3QUFvQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdV QVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQWdBQ2dBCkpRQmtBQ2tBSWdCZEFDQUFQUUFnQUNJ QUlBQW9BQ1VBWkFBcEFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnkKQUdr QWJnQm5BSE1BV3dBaUFDQUFLQUJ5QUdVQWNBQmxBR0VBZEFCbEFHUUFJQUFsQUdRQUlBQjBBR2tB YlFCbEFITUFLUUFpQUYwQQpJQUE5QUNBQUlnQWdBQ2dBY2dCbEFIQUFaUUJoQUhRQVpRQmtBQ0FB SlFCa0FDQUFkQUJwQUcwQVpRQnpBQ2tBSWdBN0FBb0FiQUJ2CkFHTUFZUUJzQUdrQWVnQmxBR1FB VXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBSlFBdUFEQUFaZ0JDQUNJQVhRQWdBRDBBSUFBaUFDVUEK TGdBd0FHWUFRZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQWxBQzRBTUFCbQpBRzBBY3dBaUFGMEFJQUE5QUNBQUlnQWxBQzRBTUFCbUFHMEFj d0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBCmNnQnBBRzRBWndCekFGc0FJ Z0FsQUM0QU1RQm1BQ0FBWkFCaEFIa0Fjd0FpQUYwQUlBQTlBQ0FBSWdBbEFDNEFNUUJtQUNBQVpB QmgKQUhrQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3 QnpBRnNBSWdBbEFDNEFNUUJtQUdnQQpjZ0J6QUNJQVhRQWdBRDBBSUFBaUFDVUFMZ0F4QUdZQWFB QnlBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwCkFISUFhUUJ1QUdjQWN3 QmJBQ0lBSlFBdUFERUFaZ0J0QUdrQWJnQWlBRjBBSUFBOUFDQUFJZ0FsQUM0QU1RQm1BRzBBYVFC dUFDSUEKT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dB aUFDVUFMZ0F5QUdZQUpRQWxBQ0lBWFFBZwpBRDBBSUFBaUFDVUFMZ0F5QUdZQUpRQWxBQ0lBT3dB S0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BCld3QWlBQ1VBTGdB eUFHWUFTd0JDQUNJQVhRQWdBRDBBSUFBaUFDVUFMZ0F5QUdZQVN3QkNBQ0lBT3dBS0FHd0Fid0Jq QUdFQWJBQnAKQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBQ1VBTGdBeUFHWUFjd0Fp QUYwQUlBQTlBQ0FBSWdBbEFDNEFNZ0JtQUhNQQpJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0Js QUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQXVBRE1BWmdCTkFFSUFJZ0JkCkFDQUFQUUFn QUNJQUpRQXVBRE1BWmdCTkFFSUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBB SElBYVFCdUFHY0EKY3dCYkFDSUFKUUF1QURNQVpnQnRBSE1BSWdCZEFDQUFQUUFnQUNJQUpRQXVB RE1BWmdCdEFITUFJZ0E3QUFvQWJBQnZBR01BWVFCcwpBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVB R2NBY3dCYkFDSUFKUUJrQUNBQVpRQnlBSElBYndCeUFDSUFYUUFnQUQwQUlBQWlBQ1VBClpBQWdB R1VBY2dCeUFHOEFjZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFH NEFad0J6QUZzQUlnQWwKQUdRQUlBQmxBSElBY2dCdkFISUFMQUFnQUNVQVpBQWdBSGNBWVFCeUFH NEFhUUJ1QUdjQUlnQmRBQ0FBUFFBZ0FDSUFKUUF4QUNRQQpaQUFnQUdVQWNnQnlBRzhBY2dBc0FD QUFKUUF5QUNRQVpBQWdBSGNBWVFCeUFHNEFhUUJ1QUdjQUlnQTdBQW9BYkFCdkFHTUFZUUJzCkFH a0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQmtBQ0FBWlFCeUFISUFid0J5QUN3 QUlBQWxBR1FBSUFCM0FHRUEKY2dCdUFHa0FiZ0JuQUhNQUlnQmRBQ0FBUFFBZ0FDSUFKUUF4QUNR QVpBQWdBR1VBY2dCeUFHOEFjZ0FzQUNBQUpRQXlBQ1FBWkFBZwpBSGNBWVFCeUFHNEFhUUJ1QUdj QWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNB CklnQWxBR1FBSUFCbEFISUFjZ0J2QUhJQWN3QWlBRjBBSUFBOUFDQUFJZ0FsQUdRQUlBQmxBSElB Y2dCdkFISUFjd0FpQURzQUNnQnMKQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRB WndCekFGc0FJZ0FsQUdRQUlBQmxBSElBY2dCdkFISUFjd0FzQUNBQQpKUUJrQUNBQWR3QmhBSElB YmdCcEFHNEFad0FpQUYwQUlBQTlBQ0FBSWdBbEFERUFKQUJrQUNBQVpRQnlBSElBYndCeUFITUFM QUFnCkFDVUFNZ0FrQUdRQUlBQjNBR0VBY2dCdUFHa0FiZ0JuQUNJQU93QUtBR3dBYndCakFHRUFi QUJwQUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFXd0FpQUNVQVpBQWdBR1VBY2dCeUFHOEFj Z0J6QUN3QUlBQWxBR1FBSUFCM0FHRUFjZ0J1QUdrQWJnQm5BSE1BSWdCZApBQ0FBUFFBZ0FDSUFK UUF4QUNRQVpBQWdBR1VBY2dCeUFHOEFjZ0J6QUN3QUlBQWxBRElBSkFCa0FDQUFkd0JoQUhJQWJn QnBBRzRBClp3QnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJn Qm5BSE1BV3dBaUFDVUFaQUFnQUcwQVlRQjAKQUdNQWFBQmxBSE1BSWdCZEFDQUFQUUFnQUNJQUpR QmtBQ0FBYlFCaEFIUUFZd0JvQUdVQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QQphUUI2QUdVQVpB QlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQWxBR1FBSUFCekFIUUFlUUJzQUdVQUlBQmpBR2dBWVFC dUFHY0FaUUFpCkFGMEFJQUE5QUNBQUlnQWxBR1FBSUFCekFIUUFlUUJzQUdVQUlBQmpBR2dBWVFC dUFHY0FaUUFpQURzQUNnQnNBRzhBWXdCaEFHd0EKYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndC ekFGc0FJZ0FsQUdRQUlBQnpBSFFBZVFCc0FHVUFJQUJqQUdnQVlRQnVBR2NBWlFCegpBQ0lBWFFB Z0FEMEFJQUFpQUNVQVpBQWdBSE1BZEFCNUFHd0FaUUFnQUdNQWFBQmhBRzRBWndCbEFITUFJZ0E3 QUFvQWJBQnZBR01BCllRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFKUUJr QUNBQWR3QmhBSElBYmdCcEFHNEFad0FpQUYwQUlBQTkKQUNBQUlnQWxBR1FBSUFCM0FHRUFjZ0J1 QUdrQWJnQm5BQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0Ju QUhNQVd3QWlBQ1VBWkFBZ0FIY0FZUUJ5QUc0QWFRQnVBR2NBY3dBaUFGMEFJQUE5QUNBQUlnQWxB R1FBSUFCM0FHRUFjZ0J1CkFHa0FiZ0JuQUhNQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxB R1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBSlFCa0FDQUEKMXdBZ0FDVUFaQUFpQUYwQUlBQTlB Q0FBSWdBbEFERUFKQUJrQUNBQTF3QWdBQ1VBTWdBa0FHUUFJZ0E3QUFvQWJBQnZBR01BWVFCcwpB R2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFKUUJ6QUNBQUtBQm1BSElBYndCdEFD QUFZd0JoQUdNQWFBQmxBQ2tBCklnQmRBQ0FBUFFBZ0FDSUFKUUJ6QUNBQUtBQm1BSElBYndCdEFD QUFZd0JoQUdNQWFBQmxBQ2tBSWdBN0FBb0FiQUJ2QUdNQVlRQnMKQUdrQWVnQmxBR1FBVXdCMEFI SUFhUUJ1QUdjQWN3QmJBQ0lBSlFCekFDQUFaQUJ2QUhjQWJnQnNBRzhBWVFCa0FDSUFYUUFnQUQw QQpJQUFpQUNVQWN3QWdBR1FBYndCM0FHNEFiQUJ2QUdFQVpBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3 QWFRQjZBR1VBWkFCVEFIUUFjZ0JwCkFHNEFad0J6QUZzQUlnQWxBSE1BSUFCc0FHRUFkQUJsQUc0 QVl3QjVBQ0lBWFFBZ0FEMEFJQUFpQUNVQWN3QWdBR3dBWVFCMEFHVUEKYmdCakFIa0FJZ0E3QUFv QWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQnpBQ0FB YkFCaApBSFFBWlFCdUFHTUFlUUFzQUNBQUpRQnpBQ0FBWkFCdkFIY0FiZ0JzQUc4QVlRQmtBQ0FB S0FBbEFITUFJQUIwQUc4QWRBQmhBR3dBCktRQWlBRjBBSUFBOUFDQUFJZ0FsQURFQUpBQnpBQ0FB YkFCaEFIUUFaUUJ1QUdNQWVRQXNBQ0FBSlFBeUFDUUFjd0FnQUdRQWJ3QjMKQUc0QWJBQnZBR0VB WkFBZ0FDZ0FKUUF6QUNRQWN3QWdBSFFBYndCMEFHRUFiQUFwQUNJQU93QUtBR3dBYndCakFHRUFi QUJwQUhvQQpaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUNnQVlRQnVBRzhBYmdCNUFHMEFi d0IxQUhNQUlBQm1BSFVBYmdCakFIUUFhUUJ2CkFHNEFLUUFpQUYwQUlBQTlBQ0FBSWdBb0FHRUFi Z0J2QUc0QWVRQnRBRzhBZFFCekFDQUFaZ0IxQUc0QVl3QjBBR2tBYndCdUFDa0EKSWdBN0FBb0Fi QUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFLQUJ3QUhJQWJ3 Qm5BSElBWVFCdApBQ2tBSWdCZEFDQUFQUUFnQUNJQUtBQndBSElBYndCbkFISUFZUUJ0QUNrQUln QTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBClV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUtB QndBSElBYndCbkFISUFZUUJ0QUNrQU9nQWdBQ1VBY3dBaUFGMEFJQUE5QUNBQUlnQW8KQUhBQWNn QnZBR2NBY2dCaEFHMEFLUUE2QUNBQUpRQnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFC a0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlBQ2dBZEFCbEFIZ0FkQUFwQUNJQVhRQWdBRDBBSUFB aUFDZ0FkQUJsQUhnQWRBQXBBQ0lBT3dBS0FHd0Fid0JqCkFHRUFiQUJwQUhvQVpRQmtBRk1BZEFC eUFHa0FiZ0JuQUhNQVd3QWlBQ2dBZHdCb0FHa0FkQUJsQUhNQWNBQmhBR01BWlFBcEFDSUEKWFFB Z0FEMEFJQUFpQUNnQWR3Qm9BR2tBZEFCbEFITUFjQUJoQUdNQVpRQXBBQ0lBT3dBS0FHd0Fid0Jq QUdFQWJBQnBBSG9BWlFCawpBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBREVBSUFCdEFHRUFkQUJq QUdnQUlnQmRBQ0FBUFFBZ0FDSUFNUUFnQUcwQVlRQjBBR01BCmFBQWlBRHNBQ2dCc0FHOEFZd0Jo QUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCQkFHd0FiQUFpQUYwQUlBQTkK QUNBQUlnQkJBR3dBYkFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBB RzRBWndCekFGc0FJZ0JCQUd3QQpkd0JoQUhrQWN3QWdBR1VBYmdCaEFHSUFiQUJsQUNJQVhRQWdB RDBBSUFBaUFFRUFiQUIzQUdFQWVRQnpBQ0FBWlFCdUFHRUFZZ0JzCkFHVUFJZ0E3QUFvQWJBQnZB R01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVFRQnVBQ0FBWlFCeUFI SUEKYndCeUFDQUFid0JqQUdNQWRRQnlBSElBWlFCa0FDQUFkQUJ5QUhrQWFRQnVBR2NBSUFCMEFH OEFYQUJ1QUhJQVpRQmhBR1FBSUFCMApBR2dBWlFBZ0FCd2dKUUJ6QUIwZ0lBQjBBR0VBWWdCc0FH VUFMZ0FpQUYwQUlBQTlBQ0FBSWdCQkFHNEFJQUJsQUhJQWNnQnZBSElBCklBQnZBR01BWXdCMUFI SUFjZ0JsQUdRQUlBQjBBSElBZVFCcEFHNEFad0FnQUhRQWJ3QmNBRzRBY2dCbEFHRUFaQUFnQUhR QWFBQmwKQUNBQUhDQWxBSE1BSFNBZ0FIUUFZUUJpQUd3QVpRQXVBQ0lBT3dBS0FHd0Fid0JqQUdF QWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlBRUVBYmdBZ0FIVUFiZ0JsQUhn QWNBQmxBR01BZEFCbEFHUUFJQUJsQUhJQWNnQnZBSElBSUFBbEFITUFJQUJ2CkFHTUFZd0IxQUhJ QWNnQmxBR1FBTGdBaUFGMEFJQUE5QUNBQUlnQkJBRzRBSUFCMUFHNEFaUUI0QUhBQVpRQmpBSFFB WlFCa0FDQUEKWlFCeUFISUFid0J5QUNBQUpRQnpBQ0FBYndCakFHTUFkUUJ5QUhJQVpRQmtBQzRB SWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbApBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lB UVFCMkFHVUFjZ0JoQUdjQVpRQWlBRjBBSUFBOUFDQUFJZ0JCQUhZQVpRQnlBR0VBClp3QmxBQ0lB T3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFSUFj Z0JsQUdFQWF3QncKQUc4QWFRQnVBSFFBY3dBaUFGMEFJQUE5QUNBQUlnQkNBSElBWlFCaEFHc0Fj QUJ2QUdrQWJnQjBBSE1BSWdBN0FBb0FiQUJ2QUdNQQpZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFh UUJ1QUdjQWN3QmJBQ0lBUXdCUEFFOEFTd0JKQUVVQVV3QWlBRjBBSUFBOUFDQUFJZ0JECkFFOEFU d0JMQUVrQVJRQlRBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJn Qm5BSE1BV3dBaUFFTUEKWVFCc0FHd0FJQUJUQUhRQVlRQmpBR3NBSWdCZEFDQUFQUUFnQUNJQVF3 QmhBR3dBYkFBZ0FGTUFkQUJoQUdNQWF3QWlBRHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpB QlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkRBR0VBYkFCc0FITUFJZ0JkQUNBQVBRQWdBQ0lBClF3 QmhBR3dBYkFCekFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdC bkFITUFXd0FpQUVNQWJBQmwKQUdFQWNnQWdBR01BYUFCaEFHNEFad0JsQUhNQUlBQnNBRzhBWndB dUFDSUFYUUFnQUQwQUlBQWlBRU1BYkFCbEFHRUFjZ0FnQUdNQQphQUJoQUc0QVp3QmxBSE1BSUFC c0FHOEFad0F1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju CkFITUFXd0FpQUVNQWJBQmxBR0VBY2dBZ0FHTUFid0J1QUhNQWJ3QnNBR1VBSUFCc0FHOEFad0F1 QUNJQVhRQWdBRDBBSUFBaUFFTUEKYkFCbEFHRUFjZ0FnQUdNQWJ3QnVBSE1BYndCc0FHVUFJQUJz QUc4QVp3QXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCawpBRk1BZEFCeUFHa0FiZ0Ju QUhNQVd3QWlBRU1BYkFCdkFITUFkUUJ5QUdVQUlnQmRBQ0FBUFFBZ0FDSUFRd0JzQUc4QWN3QjFB SElBClpRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpB RnNBSWdCREFHOEFiUUJ3QUhVQWRBQmwKQUdRQUlBQlRBSFFBZVFCc0FHVUFJZ0JkQUNBQVBRQWdB Q0lBUXdCdkFHMEFjQUIxQUhRQVpRQmtBQ0FBVXdCMEFIa0FiQUJsQUNJQQpPd0FLQUd3QWJ3QmpB R0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVNQWJ3QnZBR3NBYVFCbEFI TUFJZ0JkCkFDQUFQUUFnQUNJQVF3QnZBRzhBYXdCcEFHVUFjd0FpQURzQUNnQnNBRzhBWXdCaEFH d0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEEKWndCekFGc0FJZ0JFQUVFQVZBQkJBRUlBUVFCVEFF VUFVd0FpQUYwQUlBQTlBQ0FBSWdCRUFFRUFWQUJCQUVJQVFRQlRBRVVBVXdBaQpBRHNBQ2dCc0FH OEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCRUFFOEFUUUFpQUYw QUlBQTlBQ0FBCklnQkVBRThBVFFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JFQUdFQWRBQmgKQUdJQVlRQnpBR1VBSUFCdUFHOEFJQUJzQUc4 QWJnQm5BR1VBY2dBZ0FHZ0FZUUJ6QUNBQVpRQjRBSEFBWlFCakFIUUFaUUJrQUNBQQpkZ0JsQUhJ QWN3QnBBRzhBYmdBdUFDSUFYUUFnQUQwQUlBQWlBRVFBWVFCMEFHRUFZZ0JoQUhNQVpRQWdBRzRB YndBZ0FHd0Fid0J1CkFHY0FaUUJ5QUNBQWFBQmhBSE1BSUFCbEFIZ0FjQUJsQUdNQWRBQmxBR1FB SUFCMkFHVUFjZ0J6QUdrQWJ3QnVBQzRBSWdBN0FBb0EKYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FB VXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCawpBR2tB Y3dCaEFHSUFiQUJsQUdRQUxnQWdBRU1BYkFCcEFHTUFhd0FnQUhRQWJ3QWdBR1VBYmdCaEFHSUFi QUJsQUM0QUlnQmRBQ0FBClBRQWdBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCa0FHa0Fj d0JoQUdJQWJBQmxBR1FBTGdBZ0FFTUFiQUJwQUdNQWF3QWcKQUhRQWJ3QWdBR1VBYmdCaEFHSUFi QUJsQUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQQpj d0JiQUNJQVJBQmxBR0lBZFFCbkFHY0FhUUJ1QUdjQUlBQmxBRzRBWVFCaUFHd0FaUUJrQUM0QUlB QkRBR3dBYVFCakFHc0FJQUIwCkFHOEFJQUJrQUdrQWN3QmhBR0lBYkFCbEFDNEFJZ0JkQUNBQVBR QWdBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCbEFHNEEKWVFCaUFHd0FaUUJrQUM0QUlB QkRBR3dBYVFCakFHc0FJQUIwQUc4QUlBQmtBR2tBY3dCaEFHSUFiQUJsQUM0QUlnQTdBQW9BYkFC dgpBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVJBQmxBR0lBZFFC bkFHY0FhUUJ1QUdjQUlBQnpBR01BCmNnQnBBSEFBZEFCekFDQUFjZ0JsQUhFQWRRQnBBSElBWlFC ekFDQUFlUUJ2QUhVQUlBQjBBRzhBSUFCekFIUUFZUUJ5QUhRQUlBQjAKQUdnQVpRQWdBR1FBWlFC aUFIVUFad0JuQUdVQWNnQXVBQ0lBWFFBZ0FEMEFJQUFpQUVRQVpRQmlBSFVBWndCbkFHa0FiZ0Ju QUNBQQpjd0JqQUhJQWFRQndBSFFBY3dBZ0FISUFaUUJ4QUhVQWFRQnlBR1VBY3dBZ0FIa0Fid0Ix QUNBQWRBQnZBQ0FBY3dCMEFHRUFjZ0IwCkFDQUFkQUJvQUdVQUlBQmtBR1VBWWdCMUFHY0Fad0Js QUhJQUxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUEKY2dCcEFHNEFad0J6 QUZzQUlnQkVBR1VBYkFCbEFIUUFaUUFpQUYwQUlBQTlBQ0FBSWdCRUFHVUFiQUJsQUhRQVpRQWlB RHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkVB R2tBYlFCbEFHNEFjd0JwQUc4QWJnQnpBQ0lBClhRQWdBRDBBSUFBaUFFUUFhUUJ0QUdVQWJnQnpB R2tBYndCdUFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjAKQUhJQWFRQnVB R2NBY3dCYkFDSUFSQUJ2QUdNQWF3QWdBSFFBYndBZ0FHMEFZUUJwQUc0QUlBQjNBR2tBYmdCa0FH OEFkd0F1QUNJQQpYUUFnQUQwQUlBQWlBRVFBYndCakFHc0FJQUIwQUc4QUlBQnRBR0VBYVFCdUFD QUFkd0JwQUc0QVpBQnZBSGNBTGdBaUFEc0FDZ0JzCkFHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFI UUFjZ0JwQUc0QVp3QnpBRnNBSWdCRUFHOEFZd0IxQUcwQVpRQnVBSFFBY3dBaUFGMEEKSUFBOUFD QUFJZ0JFQUc4QVl3QjFBRzBBWlFCdUFIUUFjd0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdV QVpBQlRBSFFBY2dCcApBRzRBWndCekFGc0FJZ0JFQUc4QWJRQmhBR2tBYmdBaUFGMEFJQUE5QUNB QUlnQkVBRzhBYlFCaEFHa0FiZ0FpQURzQUNnQnNBRzhBCll3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JFQUc4QWJnQW5BSFFBSUFCd0FHRUFkUUJ6QUdVQUlBQnYKQUc0 QUlBQmxBSGdBWXdCbEFIQUFkQUJwQUc4QWJnQnpBQzRBSWdCZEFDQUFQUUFnQUNJQVJBQnZBRzRB R1NCMEFDQUFjQUJoQUhVQQpjd0JsQUNBQWJ3QnVBQ0FBWlFCNEFHTUFaUUJ3QUhRQWFRQnZBRzRB Y3dBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrCkFGTUFkQUJ5QUdrQWJnQm5BSE1B V3dBaUFFUUFid0IxQUdJQWJBQmxBQzBBUXdCc0FHa0FZd0JyQUNBQWRBQnZBQ0FBUVFCa0FHUUEK SWdCZEFDQUFQUUFnQUNJQVJBQnZBSFVBWWdCc0FHVUFMUUJEQUd3QWFRQmpBR3NBSUFCMEFHOEFJ QUJCQUdRQVpBQWlBRHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQkVBRzhBZFFCaUFHd0FaUUF0QUVNQWJBQnBBR01BCmF3QWdBSFFBYndBZ0FIUUFi d0JuQUdjQWJBQmxBQ0FBWWdCbEFIUUFkd0JsQUdVQWJnQWdBRlVBVWdCTUFDQUFaUUJ1QUdNQWJ3 QmsKQUdVQVpBQWdBR0VBYmdCa0FDQUFaQUJsQUdNQWJ3QmtBR1VBWkFBZ0FHWUFid0J5QUcwQVlR QjBBSE1BSWdCZEFDQUFQUUFnQUNJQQpSQUJ2QUhVQVlnQnNBR1VBTFFCREFHd0FhUUJqQUdzQUlB QjBBRzhBSUFCMEFHOEFad0JuQUd3QVpRQWdBR0lBWlFCMEFIY0FaUUJsCkFHNEFJQUJWQUZJQVRB QWdBR1VBYmdCakFHOEFaQUJsQUdRQUlBQmhBRzRBWkFBZ0FHUUFaUUJqQUc4QVpBQmxBR1FBSUFC bUFHOEEKY2dCdEFHRUFkQUJ6QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFC eUFHa0FiZ0JuQUhNQVd3QWlBRVVBYkFCbApBRzBBWlFCdUFIUUFjd0FpQUYwQUlBQTlBQ0FBSWdC RkFHd0FaUUJ0QUdVQWJnQjBBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBCmVnQmxBR1FBVXdC MEFISUFhUUJ1QUdjQWN3QmJBQ0lBUlFCdUFHRUFZZ0JzQUdVQUlBQkVBR1VBWWdCMUFHY0Fad0Jw QUc0QVp3QWkKQUYwQUlBQTlBQ0FBSWdCRkFHNEFZUUJpQUd3QVpRQWdBRVFBWlFCaUFIVUFad0Ju QUdrQWJnQm5BQ0lBT3dBS0FHd0Fid0JqQUdFQQpiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju QUhNQVd3QWlBRVVBYmdCaEFHSUFiQUJsQUNBQVVBQnlBRzhBWmdCcEFHd0FhUUJ1CkFHY0FJZ0Jk QUNBQVBRQWdBQ0lBUlFCdUFHRUFZZ0JzQUdVQUlBQlFBSElBYndCbUFHa0FiQUJwQUc0QVp3QWlB RHNBQ2dCc0FHOEEKWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkZB RzRBWVFCaUFHd0FaUUFnQUhJQVpRQnpBRzhBZFFCeQpBR01BWlFBZ0FIUUFjZ0JoQUdNQWF3QnBB RzRBWndBaUFGMEFJQUE5QUNBQUlnQkZBRzRBWVFCaUFHd0FaUUFnQUhJQVpRQnpBRzhBCmRRQnlB R01BWlFBZ0FIUUFjZ0JoQUdNQWF3QnBBRzRBWndBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFH VUFaQUJUQUhRQWNnQnAKQUc0QVp3QnpBRnNBSWdCRkFHNEFZUUJpQUd3QWFRQnVBR2NBSUFCa0FH VUFZZ0IxQUdjQVp3QnBBRzRBWndBZ0FIY0FhUUJzQUd3QQpJQUJ0QUdFQWF3QmxBQ0FBY3dCakFI SUFhUUJ3QUhRQWN3QWdBSElBZFFCdUFDQUFjd0JzQUc4QWR3QmxBSElBTGdBaUFGMEFJQUE5CkFD QUFJZ0JGQUc0QVlRQmlBR3dBYVFCdUFHY0FJQUJrQUdVQVlnQjFBR2NBWndCcEFHNEFad0FnQUhj QWFRQnNBR3dBSUFCdEFHRUEKYXdCbEFDQUFjd0JqQUhJQWFRQndBSFFBY3dBZ0FISUFkUUJ1QUNB QWN3QnNBRzhBZHdCbEFISUFMZ0FpQURzQUNnQnNBRzhBWXdCaApBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JGQUc0QVlRQmlBR3dBYVFCdUFHY0FJQUJ3QUhJQWJ3Qm1BR2tB CmJBQnBBRzRBWndBZ0FIY0FhUUJzQUd3QUlBQnRBR0VBYXdCbEFDQUFjd0JqQUhJQWFRQndBSFFB Y3dBZ0FISUFkUUJ1QUNBQWN3QnMKQUc4QWR3QmxBSElBTGdBaUFGMEFJQUE5QUNBQUlnQkZBRzRB WVFCaUFHd0FhUUJ1QUdjQUlBQndBSElBYndCbUFHa0FiQUJwQUc0QQpad0FnQUhjQWFRQnNBR3dB SUFCdEFHRUFhd0JsQUNBQWN3QmpBSElBYVFCd0FIUUFjd0FnQUhJQWRRQnVBQ0FBY3dCc0FHOEFk d0JsCkFISUFMZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQkZBRzRBWVFCaUFHd0EKYVFCdUFHY0FJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFJ QUIwQUhJQVlRQmpBR3NBYVFCdUFHY0FJQUIzQUdrQWJBQnNBQ0FBY2dCbApBR3dBYndCaEFHUUFJ QUIwQUdnQVpRQWdBSEFBWVFCbkFHVUFJQUJoQUc0QVpBQWdBRzBBWVFCckFHVUFJQUJ3QUdFQVp3 QmxBQ0FBCmJBQnZBR0VBWkFCcEFHNEFad0FnQUhNQWJBQnZBSGNBWlFCeUFDNEFJZ0JkQUNBQVBR QWdBQ0lBUlFCdUFHRUFZZ0JzQUdrQWJnQm4KQUNBQWNnQmxBSE1BYndCMUFISUFZd0JsQUNBQWRB QnlBR0VBWXdCckFHa0FiZ0JuQUNBQWR3QnBBR3dBYkFBZ0FISUFaUUJzQUc4QQpZUUJrQUNBQWRB Qm9BR1VBSUFCd0FHRUFad0JsQUNBQVlRQnVBR1FBSUFCdEFHRUFhd0JsQUNBQWNBQmhBR2NBWlFB Z0FHd0Fid0JoCkFHUUFhUUJ1QUdjQUlBQnpBR3dBYndCM0FHVUFjZ0F1QUNJQU93QUtBR3dBYndC akFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFXd0FpQUVVQWRnQmxBRzRBZEFB Z0FFUUFid0JqQUhVQWJRQmxBRzRBZEFBaUFGMEFJQUE5QUNBQUlnQkZBSFlBWlFCdQpBSFFBSUFC RUFHOEFZd0IxQUcwQVpRQnVBSFFBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0Iw QUhJQWFRQnVBR2NBCmN3QmJBQ0lBUlFCMkFHVUFiZ0IwQUNBQVZBQmhBSElBWndCbEFIUUFJZ0Jk QUNBQVBRQWdBQ0lBUlFCMkFHVUFiZ0IwQUNBQVZBQmgKQUhJQVp3QmxBSFFBSWdBN0FBb0FiQUJ2 QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFSUUI0QUdNQQpiQUIx QUdRQVpRQWdBSE1BWlFCc0FHVUFZd0IwQUdVQVpBQWdBR1lBZFFCdUFHTUFkQUJwQUc4QWJnQXVB Q0lBWFFBZ0FEMEFJQUFpCkFFVUFlQUJqQUd3QWRRQmtBR1VBSUFCekFHVUFiQUJsQUdNQWRBQmxB R1FBSUFCbUFIVUFiZ0JqQUhRQWFRQnZBRzRBTGdBaUFEc0EKQ2dCc0FHOEFZd0JoQUd3QWFRQjZB R1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCRkFIZ0FjQUJwQUhJQVpRQnpBQ0lBWFFBZwpB RDBBSUFBaUFFVUFlQUJ3QUdrQWNnQmxBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFH UUFVd0IwQUhJQWFRQnVBR2NBCmN3QmJBQ0lBUmdCcEFHd0FaUUFnQUhNQWFRQjZBR1VBSWdCZEFD QUFQUUFnQUNJQVJnQnBBR3dBWlFBZ0FITUFhUUI2QUdVQUlnQTcKQUFvQWJBQnZBR01BWVFCc0FH a0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVJnQnZBR01BZFFCekFDQUFjd0JsQUd3 QQpaUUJqQUhRQVpRQmtBQ0FBWmdCMUFHNEFZd0IwQUdrQWJ3QnVBQzRBSWdCZEFDQUFQUUFnQUNJ QVJnQnZBR01BZFFCekFDQUFid0J1CkFDQUFjd0JsQUd3QVpRQmpBSFFBWlFCa0FDQUFaZ0IxQUc0 QVl3QjBBR2tBYndCdUFDNEFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0EKZWdCbEFHUUFVd0IwQUhJ QWFRQnVBR2NBY3dCYkFDSUFSZ0J2QUc0QWRBQnpBQ0lBWFFBZ0FEMEFJQUFpQUVZQWJ3QnVBSFFB Y3dBaQpBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNB SWdCR0FHOEFjZ0J0QUNBQVJBQmhBSFFBCllRQWlBRjBBSUFBOUFDQUFJZ0JHQUc4QWNnQnRBQ0FB UkFCaEFIUUFZUUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlQKQUhRQWNnQnBBRzRB WndCekFGc0FJZ0JHQUhVQWJnQmpBSFFBYVFCdkFHNEFJZ0JkQUNBQVBRQWdBQ0lBUmdCMUFHNEFZ d0IwQUdrQQpid0J1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0Fi Z0JuQUhNQVd3QWlBRWNBVWdCQkFGQUFTQUJUCkFDSUFYUUFnQUQwQUlBQWlBRWNBVWdCQkFGQUFT QUJUQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFX d0FpQUVjQWJBQnZBR0lBWVFCc0FDSUFYUUFnQUQwQUlBQWlBRWNBYkFCdkFHSUFZUUJzQUNJQU93 QUtBR3dBYndCagpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVnQVZB QlVBRkFBSWdCZEFDQUFQUUFnQUNJQVNBQlVBRlFBClVBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFR QjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCSUFHVUFZUUIyQUhrQUlBQW8KQUVJQWJ3 QjBBSFFBYndCdEFDQUFWUUJ3QUNrQUlnQmRBQ0FBUFFBZ0FDSUFTQUJsQUdFQWRnQjVBQ0FBS0FC Q0FHOEFkQUIwQUc4QQpiUUFnQUZVQWNBQXBBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFC a0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFZ0FhUUJrCkFHVUFJQUJqQUdnQVlRQnVBR2NBWlFC ekFDQUFkZ0JwQUdVQWR3QXVBQ0lBWFFBZ0FEMEFJQUFpQUVnQWFRQmtBR1VBSUFCakFHZ0EKWVFC dUFHY0FaUUJ6QUNBQWRnQnBBR1VBZHdBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJr QUZNQWRBQnlBR2tBYmdCbgpBSE1BV3dBaUFFZ0FhUUJrQUdVQUlBQmpBRzhBYmdCekFHOEFiQUJs QUM0QUlnQmRBQ0FBUFFBZ0FDSUFTQUJwQUdRQVpRQWdBR01BCmJ3QnVBSE1BYndCc0FHVUFMZ0Fp QURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkoK QUcwQVlRQm5BR1VBY3dBaUFGMEFJQUE5QUNBQUlnQkpBRzBBWVFCbkFHVUFjd0FpQURzQUNnQnNB RzhBWXdCaEFHd0FhUUI2QUdVQQpaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JMQUdVQWVRQWlB RjBBSUFBOUFDQUFJZ0JMQUdVQWVRQWlBRHNBQ2dCc0FHOEFZd0JoCkFHd0FhUUI2QUdVQVpBQlRB SFFBY2dCcEFHNEFad0J6QUZzQUlnQk1BRThBUXdCQkFFd0FJQUJUQUZRQVR3QlNBRUVBUndCRkFD SUEKWFFBZ0FEMEFJQUFpQUV3QVR3QkRBRUVBVEFBZ0FGTUFWQUJQQUZJQVFRQkhBRVVBSWdBN0FB b0FiQUJ2QUdNQVlRQnNBR2tBZWdCbApBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVEFCdkFH TUFZUUJzQUNJQVhRQWdBRDBBSUFBaUFFd0Fid0JqQUdFQWJBQWlBRHNBCkNnQnNBRzhBWXdCaEFH d0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQk5BRWtBVFFCRkFDQUFkQUI1QUhB QVpRQWkKQUYwQUlBQTlBQ0FBSWdCTkFFa0FUUUJGQUNBQWRBQjVBSEFBWlFBaUFEc0FDZ0JzQUc4 QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQQpjZ0JwQUc0QVp3QnpBRnNBSWdCTkFHVUFkQUJ5QUdr QVl3QnpBQ0lBWFFBZ0FEMEFJQUFpQUUwQVpRQjBBSElBYVFCakFITUFJZ0E3CkFBb0FiQUJ2QUdN QVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFUZ0JoQUcwQVpRQWlBRjBB SUFBOUFDQUEKSWdCT0FHRUFiUUJsQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1B ZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRTRBYndBZwpBRUlBY2dCbEFHRUFhd0J3QUc4QWFRQnVBSFFB Y3dBaUFGMEFJQUE5QUNBQUlnQk9BRzhBSUFCQ0FISUFaUUJoQUdzQWNBQnZBR2tBCmJnQjBBSE1B SWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFU Z0J2QUNBQVVBQnkKQUc4QWNBQmxBSElBZEFCcEFHVUFjd0FpQUYwQUlBQTlBQ0FBSWdCT0FHOEFJ QUJRQUhJQWJ3QndBR1VBY2dCMEFHa0FaUUJ6QUNJQQpPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0Fa UUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUU0QWJ3QWdBRllBWVFCeUFHa0FZUUJpCkFHd0Fa UUJ6QUNJQVhRQWdBRDBBSUFBaUFFNEFid0FnQUZZQVlRQnlBR2tBWVFCaUFHd0FaUUJ6QUNJQU93 QUtBR3dBYndCakFHRUEKYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUU0QWJ3 QjBBQ0FBUmdCdkFIVUFiZ0JrQUNJQVhRQWdBRDBBSUFBaQpBRTRBYndCMEFDQUFSZ0J2QUhVQWJn QmtBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BCld3 QWlBRTRBYndCMEFDQUFVQUJoQUhVQWN3QmxBR1FBSWdCZEFDQUFQUUFnQUNJQVRnQnZBSFFBSUFC UUFHRUFkUUJ6QUdVQVpBQWkKQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dC cEFHNEFad0J6QUZzQUlnQlBBRzRBYkFCNUFDQUFaUUJ1QUdFQQpZZ0JzQUdVQUlBQm1BRzhBY2dB Z0FIUUFhQUJwQUhNQUlBQnpBR1VBY3dCekFHa0Fid0J1QUNJQVhRQWdBRDBBSUFBaUFFOEFiZ0Jz CkFIa0FJQUJsQUc0QVlRQmlBR3dBWlFBZ0FHWUFid0J5QUNBQWRBQm9BR2tBY3dBZ0FITUFaUUJ6 QUhNQWFRQnZBRzRBSWdBN0FBb0EKYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1 QUdjQWN3QmJBQ0lBVHdCMEFHZ0FaUUJ5QUNJQVhRQWdBRDBBSUFBaQpBRThBZEFCb0FHVUFjZ0Fp QURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlFB R0VBCmRBQm9BQ0lBWFFBZ0FEMEFJQUFpQUZBQVlRQjBBR2dBSWdBN0FBb0FiQUJ2QUdNQVlRQnNB R2tBZWdCbEFHUUFVd0IwQUhJQWFRQnUKQUdjQWN3QmJBQ0lBVUFCaEFIVUFjd0JsQUNBQWJ3QnVB Q0FBWlFCNEFHTUFaUUJ3QUhRQWFRQnZBRzRBY3dBdUFDSUFYUUFnQUQwQQpJQUFpQUZBQVlRQjFB SE1BWlFBZ0FHOEFiZ0FnQUdVQWVBQmpBR1VBY0FCMEFHa0Fid0J1QUhNQUxnQWlBRHNBQ2dCc0FH OEFZd0JoCkFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlFBR0VBZFFCekFH VUFJQUJ6QUdNQWNnQnBBSEFBZEFBZ0FHVUEKZUFCbEFHTUFkUUIwQUdrQWJ3QnVBQzRBSWdCZEFD QUFQUUFnQUNJQVVBQmhBSFVBY3dCbEFDQUFjd0JqQUhJQWFRQndBSFFBSUFCbApBSGdBWlFCakFI VUFkQUJwQUc4QWJnQXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdr QWJnQm5BSE1BCld3QWlBRkFBWVFCMUFITUFaUUJrQUNJQVhRQWdBRDBBSUFBaUFGQUFZUUIxQUhN QVpRQmtBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnAKQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhN QVd3QWlBRkFBWVFCMUFITUFhUUJ1QUdjQUlnQmRBQ0FBUFFBZ0FDSUFVQUJoQUhVQQpjd0JwQUc0 QVp3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNB SWdCUUFISUFid0JtCkFHa0FiQUJsQUNBQUpRQmtBQ0lBWFFBZ0FEMEFJQUFpQUZBQWNnQnZBR1lB YVFCc0FHVUFJQUFsQUdRQUlnQTdBQW9BYkFCdkFHTUEKWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElB YVFCdUFHY0Fjd0JiQUNJQVVBQnlBRzhBWmdCcEFHd0FaUUJ6QUNJQVhRQWdBRDBBSUFBaQpBRkFB Y2dCdkFHWUFhUUJzQUdVQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFj Z0JwQUc0QVp3QnpBRnNBCklnQlFBSElBYndCbUFHa0FiQUJwQUc0QVp3QWdBR1FBYVFCekFHRUFZ Z0JzQUdVQVpBQXVBQ0FBUXdCc0FHa0FZd0JyQUNBQWRBQnYKQUNBQVpRQnVBR0VBWWdCc0FHVUFM Z0FpQUYwQUlBQTlBQ0FBSWdCUUFISUFid0JtQUdrQWJBQnBBRzRBWndBZ0FHUUFhUUJ6QUdFQQpZ Z0JzQUdVQVpBQXVBQ0FBUXdCc0FHa0FZd0JyQUNBQWRBQnZBQ0FBWlFCdUFHRUFZZ0JzQUdVQUxn QWlBRHNBQ2dCc0FHOEFZd0JoCkFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUln QlFBSElBYndCbUFHa0FiQUJwQUc0QVp3QWdBR1VBYmdCaEFHSUEKYkFCbEFHUUFMZ0FnQUVNQWJB QnBBR01BYXdBZ0FIUUFid0FnQUdRQWFRQnpBR0VBWWdCc0FHVUFMZ0FpQUYwQUlBQTlBQ0FBSWdC UQpBSElBYndCbUFHa0FiQUJwQUc0QVp3QWdBR1VBYmdCaEFHSUFiQUJsQUdRQUxnQWdBRU1BYkFC cEFHTUFhd0FnQUhRQWJ3QWdBR1FBCmFRQnpBR0VBWWdCc0FHVUFMZ0FpQURzQUNnQnNBRzhBWXdC aEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlEKQUhJQWJ3QndBR1VBY2dC MEFHa0FaUUJ6QUNJQVhRQWdBRDBBSUFBaUFGQUFjZ0J2QUhBQVpRQnlBSFFBYVFCbEFITUFJZ0E3 QUFvQQpiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVQUJ5 QUc4QWRBQnZBSFFBZVFCd0FHVUFJZ0JkCkFDQUFQUUFnQUNJQVVBQnlBRzhBZEFCdkFIUUFlUUJ3 QUdVQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUEKYVFCdUFHY0Fjd0Ji QUNJQVVRQjFBR1VBY2dCNUFDSUFYUUFnQUQwQUlBQWlBRkVBZFFCbEFISUFlUUFpQURzQUNnQnNB RzhBWXdCaApBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JSQUhVQVpRQnlB SGtBSUFCVEFIUUFjZ0JwQUc0QVp3QWdBRkFBCllRQnlBR0VBYlFCbEFIUUFaUUJ5QUhNQUlnQmRB Q0FBUFFBZ0FDSUFVUUIxQUdVQWNnQjVBQ0FBVXdCMEFISUFhUUJ1QUdjQUlBQlEKQUdFQWNnQmhB RzBBWlFCMEFHVUFjZ0J6QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFH a0FiZ0JuQUhNQQpXd0FpQUZJQVJRQlRBRThBVlFCU0FFTUFSUUJUQUNJQVhRQWdBRDBBSUFBaUFG SUFSUUJUQUU4QVZRQlNBRU1BUlFCVEFDSUFPd0FLCkFHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FG TUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGSUFaUUJtQUhJQVpRQnpBR2dBSWdCZEFDQUEKUFFBZ0FD SUFVZ0JsQUdZQWNnQmxBSE1BYUFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCegpBRnNBSWdCU0FHVUFjUUIxQUdVQWN3QjBBQ0FBU0FCbEFHRUFaQUJsQUhJ QWN3QWlBRjBBSUFBOUFDQUFJZ0JTQUdVQWNRQjFBR1VBCmN3QjBBQ0FBU0FCbEFHRUFaQUJsQUhJ QWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnoKQUZz QUlnQlNBR1VBY1FCMUFHVUFjd0IwQUNBQVVBQmhBSGtBYkFCdkFHRUFaQUFpQUYwQUlBQTlBQ0FB SWdCU0FHVUFjUUIxQUdVQQpjd0IwQUNBQVVBQmhBSGtBYkFCdkFHRUFaQUFpQURzQUNnQnNBRzhB WXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6CkFGc0FJZ0JTQUdVQWN3QnZBSFVB Y2dCakFHVUFJQUJwQUc0QWRBQmxBSElBY0FCeUFHVUFkQUJsQUdRQUlBQmhBSE1BSUFBbEFITUEK SUFCaUFIVUFkQUFnQUhRQWNnQmhBRzRBY3dCbUFHVUFjZ0J5QUdVQVpBQWdBSGNBYVFCMEFHZ0FJ QUJOQUVrQVRRQkZBQ0FBZEFCNQpBSEFBWlFBZ0FDVUFjd0F1QUNJQVhRQWdBRDBBSUFBaUFGSUFa UUJ6QUc4QWRRQnlBR01BWlFBZ0FHa0FiZ0IwQUdVQWNnQndBSElBClpRQjBBR1VBWkFBZ0FHRUFj d0FnQUNVQU1RQWtBSE1BSUFCaUFIVUFkQUFnQUhRQWNnQmhBRzRBY3dCbUFHVUFjZ0J5QUdVQVpB QWcKQUhjQWFRQjBBR2dBSUFCTkFFa0FUUUJGQUNBQWRBQjVBSEFBWlFBZ0FDVUFNZ0FrQUhNQUxn QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QQphUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUln QlNBR1VBY3dCdkFIVUFjZ0JqQUdVQUlBQjBBSElBWVFCakFHc0FhUUJ1CkFHY0FJQUJrQUdrQWN3 QmhBR0lBYkFCbEFHUUFMZ0FnQUVNQWJBQnBBR01BYXdBZ0FIUUFid0FnQUdVQWJnQmhBR0lBYkFC bEFDNEEKSWdCZEFDQUFQUUFnQUNJQVVnQmxBSE1BYndCMUFISUFZd0JsQUNBQWRBQnlBR0VBWXdC ckFHa0FiZ0JuQUNBQVpBQnBBSE1BWVFCaQpBR3dBWlFCa0FDNEFJQUJEQUd3QWFRQmpBR3NBSUFC MEFHOEFJQUJsQUc0QVlRQmlBR3dBWlFBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBCmJBQnBBSG9BWlFC a0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGSUFaUUJ6QUc4QWRRQnlBR01BWlFBZ0FIUUFjZ0Jo QUdNQWF3QnAKQUc0QVp3QWdBR1VBYmdCaEFHSUFiQUJsQUdRQUxnQWdBRU1BYkFCcEFHTUFhd0Fn QUhRQWJ3QWdBR1FBYVFCekFHRUFZZ0JzQUdVQQpMZ0FpQUYwQUlBQTlBQ0FBSWdCU0FHVUFjd0J2 QUhVQWNnQmpBR1VBSUFCMEFISUFZUUJqQUdzQWFRQnVBR2NBSUFCbEFHNEFZUUJpCkFHd0FaUUJr QUM0QUlBQkRBR3dBYVFCakFHc0FJQUIwQUc4QUlBQmtBR2tBY3dCaEFHSUFiQUJsQUM0QUlnQTdB QW9BYkFCdkFHTUEKWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVVnQmxB SE1BYndCMUFISUFZd0JsQUhNQUlnQmRBQ0FBUFFBZwpBQ0lBVWdCbEFITUFid0IxQUhJQVl3QmxB SE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBCmN3QmJB Q0lBVWdCbEFITUFjQUJ2QUc0QWN3QmxBQ0FBU0FCbEFHRUFaQUJsQUhJQWN3QWlBRjBBSUFBOUFD QUFJZ0JTQUdVQWN3QncKQUc4QWJnQnpBR1VBSUFCSUFHVUFZUUJrQUdVQWNnQnpBQ0lBT3dBS0FH d0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlBRklBWlFCekFI UUFid0J5QUdVQUlBQmhBR3dBYkFBZ0FHWUFkUUJ1QUdNQWRBQnBBRzhBYmdCekFDNEFJZ0JkCkFD QUFQUUFnQUNJQVVnQmxBSE1BZEFCdkFISUFaUUFnQUdFQWJBQnNBQ0FBWmdCMUFHNEFZd0IwQUdr QWJ3QnVBSE1BTGdBaUFEc0EKQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0 QVp3QnpBRnNBSWdCU0FIVUFiZ0FnQUNVQVpBQWlBRjBBSUFBOQpBQ0FBSWdCU0FIVUFiZ0FnQUNV QVpBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNB CklnQlRBRVVBVXdCVEFFa0FUd0JPQUNBQVV3QlVBRThBVWdCQkFFY0FSUUFpQUYwQUlBQTlBQ0FB SWdCVEFFVUFVd0JUQUVrQVR3Qk8KQUNBQVV3QlVBRThBVWdCQkFFY0FSUUFpQURzQUNnQnNBRzhB WXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQQpJZ0JUQUdNQWJ3QndBR1VB SUFCV0FHRUFjZ0JwQUdFQVlnQnNBR1VBY3dBaUFGMEFJQUE5QUNBQUlnQlRBR01BYndCd0FHVUFJ QUJXCkFHRUFjZ0JwQUdFQVlnQnNBR1VBY3dBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFa QUJUQUhRQWNnQnBBRzRBWndCekFGc0EKSWdCVEFHTUFjZ0JwQUhBQWRBQnpBQ0lBWFFBZ0FEMEFJ QUFpQUZNQVl3QnlBR2tBY0FCMEFITUFJZ0E3QUFvQWJBQnZBR01BWVFCcwpBR2tBZWdCbEFHUUFV d0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVd0JsQUdFQWNnQmpBR2dBSUFBbEFITUFJZ0JkQUNBQVBR QWdBQ0lBClV3QmxBR0VBY2dCakFHZ0FJQUFsQUhNQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVn QmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmIKQUNJQVV3QmxBR01BZFFCeUFHVUFJZ0JkQUNBQVBR QWdBQ0lBVXdCbEFHTUFkUUJ5QUdVQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQQplZ0JsQUdRQVV3 QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVV3QmxBR3dBWlFCakFIUUFJQUJoQUc0QUlBQmxBR3dBWlFC dEFHVUFiZ0IwCkFDQUFhUUJ1QUNBQWRBQm9BR1VBSUFCd0FHRUFad0JsQUNBQWRBQnZBQ0FBYVFC dUFITUFjQUJsQUdNQWRBQWdBR2tBZEFBdUFDSUEKWFFBZ0FEMEFJQUFpQUZNQVpRQnNBR1VBWXdC MEFDQUFZUUJ1QUNBQVpRQnNBR1VBYlFCbEFHNEFkQUFnQUdrQWJnQWdBSFFBYUFCbApBQ0FBY0FC aEFHY0FaUUFnQUhRQWJ3QWdBR2tBYmdCekFIQUFaUUJqQUhRQUlBQnBBSFFBTGdBaUFEc0FDZ0Jz QUc4QVl3QmhBR3dBCmFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFHVUFiQUJt QUNJQVhRQWdBRDBBSUFBaUFGTUFaUUJzQUdZQUlnQTcKQUFvQWJBQnZBR01BWVFCc0FHa0FlZ0Js QUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVV3QmxBSE1BY3dCcEFHOEFiZ0FpQUYwQQpJQUE5 QUNBQUlnQlRBR1VBY3dCekFHa0Fid0J1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtB Rk1BZEFCeUFHa0FiZ0JuCkFITUFXd0FpQUZNQWFBQnZBSGNBSUFCaEFHSUFjd0J2QUd3QWRRQjBB R1VBSUFCMEFHOEFkQUJoQUd3QUlBQmhBRzRBWkFBZ0FITUEKWlFCc0FHWUFJQUIwQUdrQWJRQmxB SE1BTGdBaUFGMEFJQUE5QUNBQUlnQlRBR2dBYndCM0FDQUFZUUJpQUhNQWJ3QnNBSFVBZEFCbApB Q0FBZEFCdkFIUUFZUUJzQUNBQVlRQnVBR1FBSUFCekFHVUFiQUJtQUNBQWRBQnBBRzBBWlFCekFD NEFJZ0E3QUFvQWJBQnZBR01BCllRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFD SUFVd0JvQUc4QWR3QWdBR01BYUFCaEFHNEFad0JsQUhNQUlBQjIKQUdrQVpRQjNBQzRBSWdCZEFD QUFQUUFnQUNJQVV3Qm9BRzhBZHdBZ0FHTUFhQUJoQUc0QVp3QmxBSE1BSUFCMkFHa0FaUUIzQUM0 QQpJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJ QVV3Qm9BRzhBZHdBZ0FHTUFid0J1CkFITUFid0JzQUdVQUxnQWlBRjBBSUFBOUFDQUFJZ0JUQUdn QWJ3QjNBQ0FBWXdCdkFHNEFjd0J2QUd3QVpRQXVBQ0lBT3dBS0FHd0EKYndCakFHRUFiQUJwQUhv QVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRk1BYUFCdkFIY0FJQUJwQUc0QWFBQmxBSElB YVFCMApBR1VBWkFBaUFGMEFJQUE5QUNBQUlnQlRBR2dBYndCM0FDQUFhUUJ1QUdnQVpRQnlBR2tB ZEFCbEFHUUFJZ0E3QUFvQWJBQnZBR01BCllRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NB Y3dCYkFDSUFVd0JvQUc4QWR3QWdBSFFBYUFCbEFDQUFiZ0JsQUhnQWRBQWcKQUhNQVl3QnlBR2tB Y0FCMEFDQUFjZ0JsQUhNQWJ3QjFBSElBWXdCbEFDNEFJZ0JkQUNBQVBRQWdBQ0lBVXdCb0FHOEFk d0FnQUhRQQphQUJsQUNBQWJnQmxBSGdBZEFBZ0FITUFZd0J5QUdrQWNBQjBBQ0FBY2dCbEFITUFi d0IxQUhJQVl3QmxBQzRBSWdBN0FBb0FiQUJ2CkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFh UUJ1QUdjQWN3QmJBQ0lBVXdCb0FHOEFkd0FnQUhRQWFBQmxBQ0FBY0FCeUFHVUEKZGdCcEFHOEFk UUJ6QUNBQWN3QmpBSElBYVFCd0FIUUFJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFMZ0FpQUYwQUlB QTlBQ0FBSWdCVApBR2dBYndCM0FDQUFkQUJvQUdVQUlBQndBSElBWlFCMkFHa0Fid0IxQUhNQUlB QnpBR01BY2dCcEFIQUFkQUFnQUhJQVpRQnpBRzhBCmRRQnlBR01BWlFBdUFDSUFPd0FLQUd3QWJ3 QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZNQWFBQnYKQUhjQUlB QjBBRzhBZEFCaEFHd0FJQUJoQUc0QVpBQWdBSE1BWlFCc0FHWUFJQUIwQUdrQWJRQmxBSE1BSUFC aEFITUFJQUJ3QUdVQQpjZ0JqQUdVQWJnQjBBR0VBWndCbEFITUFMZ0FpQUYwQUlBQTlBQ0FBSWdC VEFHZ0Fid0IzQUNBQWRBQnZBSFFBWVFCc0FDQUFZUUJ1CkFHUUFJQUJ6QUdVQWJBQm1BQ0FBZEFC cEFHMEFaUUJ6QUNBQVlRQnpBQ0FBY0FCbEFISUFZd0JsQUc0QWRBQmhBR2NBWlFCekFDNEEKSWdB N0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVd0Jw QUhvQVpRQWlBRjBBSUFBOQpBQ0FBSWdCVEFHa0FlZ0JsQUNJQU93QUtBR3dBYndCakFHRUFiQUJw QUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRk1BCmJ3QnlBSFFBSUFCaUFIa0FJQUJF QUhVQWNnQmhBSFFBYVFCdkFHNEFJZ0JkQUNBQVBRQWdBQ0lBVXdCdkFISUFkQUFnQUdJQWVRQWcK QUVRQWRRQnlBR0VBZEFCcEFHOEFiZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRB SFFBY2dCcEFHNEFad0J6QUZzQQpJZ0JUQUc4QWNnQjBBQ0FBWWdCNUFDQUFSUUJ1QUdRQUlBQlVB R2tBYlFCbEFDSUFYUUFnQUQwQUlBQWlBRk1BYndCeUFIUUFJQUJpCkFIa0FJQUJGQUc0QVpBQWdB RlFBYVFCdEFHVUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFH Y0EKY3dCYkFDSUFVd0J2QUhJQWRBQWdBR0lBZVFBZ0FFd0FZUUIwQUdVQWJnQmpBSGtBSWdCZEFD QUFQUUFnQUNJQVV3QnZBSElBZEFBZwpBR0lBZVFBZ0FFd0FZUUIwQUdVQWJnQmpBSGtBSWdBN0FB b0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBCmN3QmJBQ0lBVXdCdkFI SUFkQUFnQUdJQWVRQWdBRklBWlFCekFIQUFid0J1QUhNQVpRQWdBRlFBYVFCdEFHVUFJZ0JkQUNB QVBRQWcKQUNJQVV3QnZBSElBZEFBZ0FHSUFlUUFnQUZJQVpRQnpBSEFBYndCdUFITUFaUUFnQUZR QWFRQnRBR1VBSWdBN0FBb0FiQUJ2QUdNQQpZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdj QWN3QmJBQ0lBVXdCdkFISUFkQUFnQUdJQWVRQWdBRk1BYVFCNkFHVUFJZ0JkCkFDQUFQUUFnQUNJ QVV3QnZBSElBZEFBZ0FHSUFlUUFnQUZNQWFRQjZBR1VBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tB ZWdCbEFHUUEKVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVXdCdkFISUFkQUFnQUdJQWVRQWdBRk1B ZEFCaEFISUFkQUFnQUZRQWFRQnRBR1VBSWdCZApBQ0FBUFFBZ0FDSUFVd0J2QUhJQWRBQWdBR0lB ZVFBZ0FGTUFkQUJoQUhJQWRBQWdBRlFBYVFCdEFHVUFJZ0E3QUFvQWJBQnZBR01BCllRQnNBR2tB ZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVd0J2QUhVQWNnQmpBR1VBSWdCZEFDQUFQ UUFnQUNJQVV3QnYKQUhVQWNnQmpBR1VBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFV d0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVd0IwQUdFQQpjZ0IwQUNBQWNBQnlBRzhBWmdCcEFHd0Fh UUJ1QUdjQUxnQWlBRjBBSUFBOUFDQUFJZ0JUQUhRQVlRQnlBSFFBSUFCd0FISUFid0JtCkFHa0Fi QUJwQUc0QVp3QXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJn Qm5BSE1BV3dBaUFGTUEKZEFCbEFIQUFJQUJwQUc0QWRBQnZBQ0FBYmdCbEFIZ0FkQUFnQUdZQWRR QnVBR01BZEFCcEFHOEFiZ0FnQUdNQVlRQnNBR3dBTGdBaQpBRjBBSUFBOUFDQUFJZ0JUQUhRQVpR QndBQ0FBYVFCdUFIUUFid0FnQUc0QVpRQjRBSFFBSUFCbUFIVUFiZ0JqQUhRQWFRQnZBRzRBCklB QmpBR0VBYkFCc0FDNEFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFC dUFHY0Fjd0JiQUNJQVV3QjAKQUdVQWNBQWdBRzhBZFFCMEFDQUFid0JtQUNBQVl3QjFBSElBY2dC bEFHNEFkQUFnQUdZQWRRQnVBR01BZEFCcEFHOEFiZ0F1QUNJQQpYUUFnQUQwQUlBQWlBRk1BZEFC bEFIQUFJQUJ2QUhVQWRBQWdBRzhBWmdBZ0FHTUFkUUJ5QUhJQVpRQnVBSFFBSUFCbUFIVUFiZ0Jq CkFIUUFhUUJ2QUc0QUxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0Jw QUc0QVp3QnpBRnNBSWdCVEFIUUEKWlFCd0FDQUFid0IyQUdVQWNnQWdBRzRBWlFCNEFIUUFJQUJt QUhVQWJnQmpBSFFBYVFCdkFHNEFJQUJqQUdFQWJBQnNBQzRBSWdCZApBQ0FBUFFBZ0FDSUFVd0Iw QUdVQWNBQWdBRzhBZGdCbEFISUFJQUJ1QUdVQWVBQjBBQ0FBWmdCMUFHNEFZd0IwQUdrQWJ3QnVB Q0FBCll3QmhBR3dBYkFBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlB R2tBYmdCbkFITUFXd0FpQUZNQWRBQmwKQUhBQWNBQnBBRzRBWndBaUFGMEFJQUE5QUNBQUlnQlRB SFFBWlFCd0FIQUFhUUJ1QUdjQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQQplZ0JsQUdRQVV3QjBB SElBYVFCdUFHY0Fjd0JiQUNJQVV3QjBBRzhBY0FBZ0FIQUFjZ0J2QUdZQWFRQnNBR2tBYmdCbkFD NEFJZ0JkCkFDQUFQUUFnQUNJQVV3QjBBRzhBY0FBZ0FIQUFjZ0J2QUdZQWFRQnNBR2tBYmdCbkFD NEFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0EKZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFD SUFVd0IwQUc4QWNnQmhBR2NBWlFBaUFGMEFJQUE5QUNBQUlnQlRBSFFBYndCeQpBR0VBWndCbEFD SUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZN QWRBQjVBR3dBClpRQWdBRUVBZEFCMEFISUFhUUJpQUhVQWRBQmxBQ0lBWFFBZ0FEMEFJQUFpQUZN QWRBQjVBR3dBWlFBZ0FFRUFkQUIwQUhJQWFRQmkKQUhVQWRBQmxBQ0lBT3dBS0FHd0Fid0JqQUdF QWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGTUFkQUI1QUd3QQpaUUJ6QUNJ QVhRQWdBRDBBSUFBaUFGTUFkQUI1QUd3QVpRQnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9B WlFCa0FGTUFkQUJ5CkFHa0FiZ0JuQUhNQVd3QWlBRk1BZEFCNUFHd0FaUUJ6QUdnQVpRQmxBSFFB Y3dBaUFGMEFJQUE5QUNBQUlnQlRBSFFBZVFCc0FHVUEKY3dCb0FHVUFaUUIwQUhNQUlnQTdBQW9B YkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVkFCbwpBR1VB SUFBY0lDVUFjd0FkSUZ3QWJnQjBBR0VBWWdCc0FHVUFJQUJwQUhNQUlBQmxBRzBBY0FCMEFIa0FM Z0FpQUYwQUlBQTlBQ0FBCklnQlVBR2dBWlFBZ0FCd2dKUUJ6QUIwZ1hBQnVBSFFBWVFCaUFHd0Fa UUFnQUdrQWN3QWdBR1VBYlFCd0FIUUFlUUF1QUNJQU93QUsKQUd3QWJ3QmpBR0VBYkFCcEFIb0Fa UUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZRQWFBQnBBSE1BSUFCekFHa0FkQUJsQUNBQQph QUJoQUhNQUlBQnVBRzhBSUFCakFHOEFid0JyQUdrQVpRQnpBQzRBSWdCZEFDQUFQUUFnQUNJQVZB Qm9BR2tBY3dBZ0FITUFhUUIwCkFHVUFJQUJvQUdFQWN3QWdBRzRBYndBZ0FHTUFid0J2QUdzQWFR QmxBSE1BTGdBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUEKWkFCVEFIUUFjZ0JwQUc0QVp3 QnpBRnNBSWdCVUFHZ0FhUUJ6QUNBQWN3QjBBRzhBY2dCaEFHY0FaUUFnQUdrQWN3QWdBR1VBYlFC dwpBSFFBZVFBdUFDSUFYUUFnQUQwQUlBQWlBRlFBYUFCcEFITUFJQUJ6QUhRQWJ3QnlBR0VBWndC bEFDQUFhUUJ6QUNBQVpRQnRBSEFBCmRBQjVBQzRBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdC bEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFWQUJwQUcwQVpRQWkKQUYwQUlBQTlBQ0FBSWdC VUFHa0FiUUJsQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju QUhNQQpXd0FpQUZRQWJ3QjBBR0VBYkFBaUFGMEFJQUE5QUNBQUlnQlVBRzhBZEFCaEFHd0FJZ0E3 QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsCkFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFWQUJ5 QUdVQVpRQWdBQ2dBVkFCdkFIQUFJQUJFQUc4QWR3QnVBQ2tBSWdCZEFDQUEKUFFBZ0FDSUFWQUJ5 QUdVQVpRQWdBQ2dBVkFCdkFIQUFJQUJFQUc4QWR3QnVBQ2tBSWdBN0FBb0FiQUJ2QUdNQVlRQnNB R2tBZWdCbApBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVlFCdUFHUUFid0JqQUdzQUlBQnBB RzRBZEFCdkFDQUFjd0JsQUhBQVlRQnlBR0VBCmRBQmxBQ0FBZHdCcEFHNEFaQUJ2QUhjQUxnQWlB RjBBSUFBOUFDQUFJZ0JWQUc0QVpBQnZBR01BYXdBZ0FHa0FiZ0IwQUc4QUlBQnoKQUdVQWNBQmhB SElBWVFCMEFHVUFJQUIzQUdrQWJnQmtBRzhBZHdBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFI b0FaUUJrQUZNQQpkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGVUFjd0JsQUNBQWJBQmhBSElBWndCbEFD QUFjZ0JsQUhNQWJ3QjFBSElBWXdCbEFDQUFjZ0J2CkFIY0Fjd0F1QUNJQVhRQWdBRDBBSUFBaUFG VUFjd0JsQUNBQWJBQmhBSElBWndCbEFDQUFjZ0JsQUhNQWJ3QjFBSElBWXdCbEFDQUEKY2dCdkFI Y0Fjd0F1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhN QVd3QWlBRlVBY3dCbApBQ0FBY3dCdEFHRUFiQUJzQUNBQWNnQmxBSE1BYndCMUFISUFZd0JsQUNB QWNnQnZBSGNBY3dBdUFDSUFYUUFnQUQwQUlBQWlBRlVBCmN3QmxBQ0FBY3dCdEFHRUFiQUJzQUNB QWNnQmxBSE1BYndCMUFISUFZd0JsQUNBQWNnQnZBSGNBY3dBdUFDSUFPd0FLQUd3QWJ3QmoKQUdF QWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGWUFZUUJzQUhVQVpRQWlBRjBB SUFBOUFDQUFJZ0JXQUdFQQpiQUIxQUdVQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FB VXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVndCcEFIUUFhQUFnCkFFSUFiQUJ2QUdNQWF3QWlBRjBB SUFBOUFDQUFJZ0JYQUdrQWRBQm9BQ0FBUWdCc0FHOEFZd0JyQUNJQU93QUtBR3dBYndCakFHRUEK YkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZnQVNBQlNBQ0lBWFFBZ0FEMEFJ QUFpQUZnQVNBQlNBQ0lBT3dBSwpBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0Fi Z0JuQUhNQVd3QWlBRmtBYndCMUFDQUFZd0J2QUhVQWJBQmtBQ0FBCmN3QmhBSFlBWlFBZ0FHSUFZ UUJ1QUdRQWR3QnBBR1FBZEFCb0FDQUFZZ0I1QUNBQWFBQmhBSFlBYVFCdUFHY0FJQUI1QUc4QWRR QnkKQUNBQWR3QmxBR0lBSUFCekFHVUFjZ0IyQUdVQWNnQWdBR01BYndCdEFIQUFjZ0JsQUhNQWN3 QWdBSFFBYUFCcEFITUFJQUIwQUhJQQpZUUJ1QUhNQVpnQmxBSElBSUFCM0FHa0FkQUJvQUNBQVp3 QjZBR2tBY0FBZ0FHOEFjZ0FnQUhvQWJBQnBBR0lBTGdBaUFGMEFJQUE5CkFDQUFJZ0JaQUc4QWRR QWdBR01BYndCMUFHd0FaQUFnQUhNQVlRQjJBR1VBSUFCaUFHRUFiZ0JrQUhjQWFRQmtBSFFBYUFB Z0FHSUEKZVFBZ0FHZ0FZUUIyQUdrQWJnQm5BQ0FBZVFCdkFIVUFjZ0FnQUhjQVpRQmlBQ0FBY3dC bEFISUFkZ0JsQUhJQUlBQmpBRzhBYlFCdwpBSElBWlFCekFITUFJQUIwQUdnQWFRQnpBQ0FBZEFC eUFHRUFiZ0J6QUdZQVpRQnlBQ0FBZHdCcEFIUUFhQUFnQUdjQWVnQnBBSEFBCklBQnZBSElBSUFC NkFHd0FhUUJpQUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1 QUdjQWN3QmIKQUNJQVdRQnZBSFVBSUFCdUFHVUFaUUJrQUNBQWRBQnZBQ0FBWlFCdUFHRUFZZ0Jz QUdVQUlBQmtBR1VBWWdCMUFHY0Fad0JwQUc0QQpad0FnQUdJQVpRQm1BRzhBY2dCbEFDQUFlUUJ2 QUhVQUlBQmpBR0VBYmdBZ0FIVUFjd0JsQUNBQWRBQm9BR1VBSUFCVEFHTUFjZ0JwCkFIQUFkQUJ6 QUNBQWNBQmhBRzRBWlFCc0FDNEFJZ0JkQUNBQVBRQWdBQ0lBV1FCdkFIVUFJQUJ1QUdVQVpRQmtB Q0FBZEFCdkFDQUEKWlFCdUFHRUFZZ0JzQUdVQUlBQmtBR1VBWWdCMUFHY0Fad0JwQUc0QVp3QWdB R0lBWlFCbUFHOEFjZ0JsQUNBQWVRQnZBSFVBSUFCagpBR0VBYmdBZ0FIVUFjd0JsQUNBQWRBQm9B R1VBSUFCVEFHTUFjZ0JwQUhBQWRBQnpBQ0FBY0FCaEFHNEFaUUJzQUM0QUlnQTdBQW9BCmJBQnZB R01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVdRQnZBSFVBSUFCdUFH VUFaUUJrQUNBQWRBQnYKQUNBQVpRQnVBR0VBWWdCc0FHVUFJQUJ3QUhJQWJ3Qm1BR2tBYkFCcEFH NEFad0FnQUdJQVpRQm1BRzhBY2dCbEFDQUFlUUJ2QUhVQQpJQUJqQUdFQWJnQWdBSFVBY3dCbEFD QUFkQUJvQUdVQUlBQlFBSElBYndCbUFHa0FiQUJsQUhNQUlBQndBR0VBYmdCbEFHd0FMZ0FpCkFG MEFJQUE5QUNBQUlnQlpBRzhBZFFBZ0FHNEFaUUJsQUdRQUlBQjBBRzhBSUFCbEFHNEFZUUJpQUd3 QVpRQWdBSEFBY2dCdkFHWUEKYVFCc0FHa0FiZ0JuQUNBQVlnQmxBR1lBYndCeUFHVUFJQUI1QUc4 QWRRQWdBR01BWVFCdUFDQUFkUUJ6QUdVQUlBQjBBR2dBWlFBZwpBRkFBY2dCdkFHWUFhUUJzQUdV QWN3QWdBSEFBWVFCdUFHVUFiQUF1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1B CmRBQnlBR2tBYmdCbkFITUFXd0FpQUZrQWJ3QjFBQ0FBYmdCbEFHVUFaQUFnQUhRQWJ3QWdBR1VB YmdCaEFHSUFiQUJsQUNBQWNnQmwKQUhNQWJ3QjFBSElBWXdCbEFDQUFkQUJ5QUdFQVl3QnJBR2tB YmdCbkFDQUFkQUJ2QUNBQWRRQnpBR1VBSUFCMEFHZ0FhUUJ6QUNBQQpjQUJoQUc0QVpRQnNBQzRB SWdCZEFDQUFQUUFnQUNJQVdRQnZBSFVBSUFCdUFHVUFaUUJrQUNBQWRBQnZBQ0FBWlFCdUFHRUFZ Z0JzCkFHVUFJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFJQUIwQUhJQVlRQmpBR3NBYVFCdUFHY0FJ QUIwQUc4QUlBQjFBSE1BWlFBZ0FIUUEKYUFCcEFITUFJQUJ3QUdFQWJnQmxBR3dBTGdBaUFEc0FD Z0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCegpBRnNBSWdCaUFHOEFj Z0JrQUdVQWNnQWlBRjBBSUFBOUFDQUFJZ0JpQUc4QWNnQmtBR1VBY2dBaUFEc0FDZ0JzQUc4QVl3 QmhBR3dBCmFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCakFHOEFiZ0IwQUdVQWJn QjBBQ0lBWFFBZ0FEMEFJQUFpQUdNQWJ3QnUKQUhRQVpRQnVBSFFBSWdBN0FBb0FiQUJ2QUdNQVlR QnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFaQUJ2QUdNQQpkUUJ0QUdVQWJn QjBBQ0lBWFFBZ0FEMEFJQUFpQUdRQWJ3QmpBSFVBYlFCbEFHNEFkQUFpQURzQUNnQnNBRzhBWXdC aEFHd0FhUUI2CkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JsQUd3QVpRQnRBR1VBYmdC MEFCa2djd0FnQUJ3Z0pRQnpBQjBnSUFCaEFIUUEKZEFCeUFHa0FZZ0IxQUhRQVpRQWlBRjBBSUFB OUFDQUFJZ0JsQUd3QVpRQnRBR1VBYmdCMEFCa2djd0FnQUJ3Z0pRQnpBQjBnSUFCaApBSFFBZEFC eUFHa0FZZ0IxQUhRQVpRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0Jw QUc0QVp3QnpBRnNBCklnQm1BRzhBYmdCMEFDSUFYUUFnQUQwQUlBQWlBR1lBYndCdUFIUUFJZ0E3 QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjAKQUhJQWFRQnVBR2NBY3dCYkFDSUFhUUJ0 QUdFQVp3QmxBQ0lBWFFBZ0FEMEFJQUFpQUdrQWJRQmhBR2NBWlFBaUFEc0FDZ0JzQUc4QQpZd0Jo QUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCcEFHNEFiQUJwQUc0QVpRQWdB SE1BZEFCNUFHd0FaUUJ6CkFHZ0FaUUJsQUhRQUlnQmRBQ0FBUFFBZ0FDSUFhUUJ1QUd3QWFRQnVB R1VBSUFCekFIUUFlUUJzQUdVQWN3Qm9BR1VBWlFCMEFDSUEKT3dBS0FHd0Fid0JqQUdFQWJBQnBB SG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFHd0FhUUJ1QUdVQUlBQWxBR1FBSWdCZApB Q0FBUFFBZ0FDSUFiQUJwQUc0QVpRQWdBQ1VBWkFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFH VUFaQUJUQUhRQWNnQnBBRzRBClp3QnpBRnNBSWdCdEFHRUFjZ0JuQUdrQWJnQWlBRjBBSUFBOUFD QUFJZ0J0QUdFQWNnQm5BR2tBYmdBaUFEc0FDZ0JzQUc4QVl3QmgKQUd3QWFRQjZBR1VBWkFCVEFI UUFjZ0JwQUc0QVp3QnpBRnNBSWdCdkFIUUFhQUJsQUhJQUlnQmRBQ0FBUFFBZ0FDSUFid0IwQUdn QQpaUUJ5QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhN QVd3QWlBSEFBWVFCa0FHUUFhUUJ1CkFHY0FJZ0JkQUNBQVBRQWdBQ0lBY0FCaEFHUUFaQUJwQUc0 QVp3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUEKY2dCcEFHNEFad0J6QUZz QUlnQndBRzhBY3dCcEFIUUFhUUJ2QUc0QUlnQmRBQ0FBUFFBZ0FDSUFjQUJ2QUhNQWFRQjBBR2tB YndCdQpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1B V3dBaUFITUFZd0J5QUdrQWNBQjBBQ0lBClhRQWdBRDBBSUFBaUFITUFZd0J5QUdrQWNBQjBBQ0lB T3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm4KQUhNQVd3QWlBSE1B ZEFCNUFHd0FaUUJ6QUdnQVpRQmxBSFFBSWdCZEFDQUFQUUFnQUNJQWN3QjBBSGtBYkFCbEFITUFh QUJsQUdVQQpkQUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQjFBSE1BWlFCeUFDQUFZUUJuCkFHVUFiZ0IwQUNBQWN3QjBBSGtBYkFCbEFITUFh QUJsQUdVQWRBQWlBRjBBSUFBOUFDQUFJZ0IxQUhNQVpRQnlBQ0FBWVFCbkFHVUEKYmdCMEFDQUFj d0IwQUhrQWJBQmxBSE1BYUFCbEFHVUFkQUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpB QlRBSFFBY2dCcApBRzRBWndCekFGc0FJZ0IxQUhNQVpRQnlBQ0FBY3dCMEFIa0FiQUJsQUhNQWFB QmxBR1VBZEFBaUFGMEFJQUE5QUNBQUlnQjFBSE1BClpRQnlBQ0FBY3dCMEFIa0FiQUJsQUhNQWFB QmxBR1VBZEFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnAKQUc0QVp3 QnpBRnNBSWdCMkFHa0FZUUFnQUdrQWJnQnpBSEFBWlFCakFIUUFid0J5QUNJQVhRQWdBRDBBSUFB aUFIWUFhUUJoQUNBQQphUUJ1QUhNQWNBQmxBR01BZEFCdkFISUFJZ0E3QUFvQWJBQnZBR01BWVFC c0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiCkFDSUFRd0JRQUZVQUlBQlFBRklBVHdC R0FFa0FUQUJGQUZNQUlnQmRBQ0FBUFFBZ0FDSUFRd0JRQUZVQUlBQlFBRklBVHdCR0FFa0EKVEFC RkFGTUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0Ji QUNJQVNBQkZBRUVBVUFBZwpBRk1BVGdCQkFGQUFVd0JJQUU4QVZBQlRBQ0lBWFFBZ0FEMEFJQUFp QUVnQVJRQkJBRkFBSUFCVEFFNEFRUUJRQUZNQVNBQlBBRlFBClV3QWlBRHNBQ2dCc0FHOEFZd0Jo QUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVUFHRUFhd0JsQUNBQWFBQmwK QUdFQWNBQWdBSE1BYmdCaEFIQUFjd0JvQUc4QWRBQXVBQ0lBWFFBZ0FEMEFJQUFpQUZRQVlRQnJB R1VBSUFCb0FHVUFZUUJ3QUNBQQpjd0J1QUdFQWNBQnpBR2dBYndCMEFDNEFJZ0E3QUFvQWJBQnZB R01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiCkFDSUFTQUJsQUhnQUlBQkRB RzhBYkFCdkFISUFjd0FpQUYwQUlBQTlBQ0FBSWdCSUFHVUFlQUFnQUVNQWJ3QnNBRzhBY2dCekFD SUEKT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFG SUFSd0JDQUNBQVF3QnZBR3dBYndCeQpBSE1BSWdCZEFDQUFQUUFnQUNJQVVnQkhBRUlBSUFCREFH OEFiQUJ2QUhJQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBClpBQlRBSFFBY2dCcEFH NEFad0J6QUZzQUlnQklBRk1BVEFBZ0FFTUFid0JzQUc4QWNnQnpBQ0lBWFFBZ0FEMEFJQUFpQUVn QVV3Qk0KQUNBQVF3QnZBR3dBYndCeUFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdR QVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQQpRd0JzQUdrQVl3QnJBQ0FBZEFCdkFDQUFZd0JvQUdF QWJnQm5BR1VBSUFCakFHOEFiQUJ2QUhJQUlBQm1BRzhBY2dCdEFHRUFkQUFpCkFGMEFJQUE5QUNB QUlnQkRBR3dBYVFCakFHc0FJQUIwQUc4QUlBQmpBR2dBWVFCdUFHY0FaUUFnQUdNQWJ3QnNBRzhB Y2dBZ0FHWUEKYndCeUFHMEFZUUIwQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1B ZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRmNBWVFCMApBR01BYUFBZ0FFVUFlQUJ3QUhJQVpRQnpBSE1B YVFCdkFHNEFjd0FpQUYwQUlBQTlBQ0FBSWdCWEFHRUFkQUJqQUdnQUlBQkZBSGdBCmNBQnlBR1VB Y3dCekFHa0Fid0J1QUhNQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFh UUJ1QUdjQWN3QmIKQUNJQVFRQmtBR1FBSWdCZEFDQUFQUUFnQUNJQVFRQmtBR1FBSWdBN0FBb0Fi QUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQQphUUJ1QUdjQWN3QmJBQ0lBUkFCbEFHd0Fa UUIwQUdVQUlBQjNBR0VBZEFCakFHZ0FJQUJsQUhnQWNBQnlBR1VBY3dCekFHa0Fid0J1CkFDNEFJ Z0JkQUNBQVBRQWdBQ0lBUkFCbEFHd0FaUUIwQUdVQUlBQjNBR0VBZEFCakFHZ0FJQUJsQUhnQWNB QnlBR1VBY3dCekFHa0EKYndCdUFDNEFJZ0E3QUFvQQoK 39610 2009-09-15 13:05:18 -0700 2009-09-16 09:13:58 -0700 proposed patch - 2009/09/15 27514.patch text/plain 63000 pmuellr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0ODM5OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNDkgQEAKKzIwMDktMDktMTUgIFBhdHJpY2sgTXVlbGxlciAgPFBhdHJpY2tfTXVl bGxlckB1cy5pYm0uY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIGFkZCBzdXBwb3J0IGZvciB3YXRjaGVkIGV4cHJlc3Npb25zIGluIGluc3BlY3Rv cgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjc1MTQK KworICAgICAgICBNYW51YWwgdGVzdCBhZGRlZCAoc2VlIGJlbG93KQorCisgICAgICAgICogRW5n bGlzaC5scHJvai9sb2NhbGl6ZWRTdHJpbmdzLmpzOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9u dC1lbmQvQ29uc29sZVZpZXcuanM6CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ29uc29sZVZpZXcu cHJvdG90eXBlLmNvbXBsZXRpb25zKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5Db25zb2xlVmll dy5wcm90b3R5cGUuZXZhbEluSW5zcGVjdGVkV2luZG93KToKKyAgICAgICAgKFdlYkluc3BlY3Rv ci5Db25zb2xlVmlldy5wcm90b3R5cGUuX2VudGVyS2V5UHJlc3NlZCk6CisgICAgICAgICogaW5z cGVjdG9yL2Zyb250LWVuZC9PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5qczoKKyAgICAgICAgKFdl Ykluc3BlY3Rvci5PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5wcm90b3R5cGUuX3VwZGF0ZSk6Cisg ICAgICAgIChXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydHlUcmVlRWxlbWVudC5wcm90b3R5cGUu b25wb3B1bGF0ZS5jYWxsYmFjayk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVy dHlUcmVlRWxlbWVudC5wcm90b3R5cGUub25wb3B1bGF0ZSk6CisgICAgICAgIChXZWJJbnNwZWN0 b3IuT2JqZWN0UHJvcGVydHlUcmVlRWxlbWVudC5wcm90b3R5cGUudXBkYXRlKToKKyAgICAgICAg KFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlwZS5hcHBseUV4 cHJlc3Npb24pOgorICAgICAgICAoV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnR5VHJlZUVsZW1l bnQucHJvdG90eXBlLmNvbXBhcmVQcm9wZXJ0eU5hbWVzKToKKyAgICAgICAgKiBpbnNwZWN0b3Iv ZnJvbnQtZW5kL1NjcmlwdHNQYW5lbC5qczoKKyAgICAgICAgKFdlYkluc3BlY3Rvci5TY3JpcHRz UGFuZWwpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLlNjcmlwdHNQYW5lbC5wcm90b3R5cGUucmVz ZXQpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLlNjcmlwdHNQYW5lbC5wcm90b3R5cGUuX2NhbGxG cmFtZVNlbGVjdGVkKToKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL1dhdGNoRXhwcmVz c2lvbnNTaWRlYmFyUGFuZS5qczogQWRkZWQuCisgICAgICAgIChXZWJJbnNwZWN0b3IuV2F0Y2hF eHByZXNzaW9uc1NpZGViYXJQYW5lKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJl c3Npb25zU2lkZWJhclBhbmUucHJvdG90eXBlLnJlZnJlc2hFeHByZXNzaW9ucyk6CisgICAgICAg IChXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24pOgorICAgICAgICAoV2ViSW5z cGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS51cGRhdGUpOgorICAgICAg ICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS5hZGRFeHBy ZXNzaW9uKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5w cm90b3R5cGUudXBkYXRlRXhwcmVzc2lvbik6CisgICAgICAgIChXZWJJbnNwZWN0b3IuV2F0Y2hF eHByZXNzaW9uc1NlY3Rpb24ucHJvdG90eXBlLmZpbmRBZGRlZFRyZWVFbGVtZW50KToKKyAgICAg ICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5wcm90b3R5cGUubG9hZFNh dmVkRXhwcmVzc2lvbnMpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNT ZWN0aW9uLnByb3RvdHlwZS5zYXZlRXhwcmVzc2lvbnMpOgorICAgICAgICAoV2ViSW5zcGVjdG9y LldhdGNoRXhwcmVzc2lvblRyZWVFbGVtZW50KToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRj aEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUudXBkYXRlKToKKyAgICAgICAgKFdlYklu c3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUuX2RlbGV0ZUJ1dHRv bkNsaWNrZWQpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvblRyZWVFbGVt ZW50LnByb3RvdHlwZS5zdGFydEVkaXRpbmcpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNo RXhwcmVzc2lvblRyZWVFbGVtZW50LnByb3RvdHlwZS5lZGl0aW5nQ2FuY2VsbGVkKToKKyAgICAg ICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUuYXBw bHlFeHByZXNzaW9uKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVl RWxlbWVudC5wcm90b3R5cGUuY29tcGFyZVByb3BlcnR5TmFtZXMpOgorICAgICAgICAqIGluc3Bl Y3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmNzczoKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQt ZW5kL2luc3BlY3Rvci5odG1sOgorICAgICAgICAqIG1hbnVhbC10ZXN0cy9pbnNwZWN0b3IvZGVi dWdnZXItd2F0Y2gtZXhwcmVzc2lvbnMuaHRtbDogQWRkZWQuCisKIDIwMDktMDktMTQgIEFuZHJl dyBSaWNoYXJkcyAgPHJhbmRyZXdAZ21haWwuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNh bSBXZWluaWcuCkluZGV4OiBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvQ29uc29sZVZpZXcu anMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0NvbnNvbGVWaWV3 LmpzCShyZXZpc2lvbiA0ODM1NSkKKysrIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9Db25z b2xlVmlldy5qcwkod29ya2luZyBjb3B5KQpAQCAtMjk4LDcgKzI5OCw3IEBAIFdlYkluc3BlY3Rv ci5Db25zb2xlVmlldy5wcm90b3R5cGUgPSB7CiAgICAgICAgICAgICByZXBvcnRDb21wbGV0aW9u cyhyZXN1bHQsIGlzRXhjZXB0aW9uKTsKICAgICAgICAgfQogCi0gICAgICAgIHRoaXMuX2V2YWxJ bkluc3BlY3RlZFdpbmRvdygKKyAgICAgICAgdGhpcy5ldmFsSW5JbnNwZWN0ZWRXaW5kb3coCiAg ICAgICAgICAgICAiKGZ1bmN0aW9uKCkgeyIgKwogICAgICAgICAgICAgICAgICJ2YXIgcHJvcHMg PSB7fTsiICsKICAgICAgICAgICAgICAgICAiZm9yICh2YXIgcHJvcCBpbiAoIiArIGV4cHJlc3Np b25TdHJpbmcgKyAiKSkgcHJvcHNbcHJvcF0gPSB0cnVlOyIgKwpAQCAtMzk0LDcgKzM5NCw3IEBA IFdlYkluc3BlY3Rvci5Db25zb2xlVmlldy5wcm90b3R5cGUgPSB7CiAgICAgICAgIHRoaXMucHJv bXB0LmhhbmRsZUtleUV2ZW50KGV2ZW50KTsKICAgICB9LAogCi0gICAgX2V2YWxJbkluc3BlY3Rl ZFdpbmRvdzogZnVuY3Rpb24oZXhwcmVzc2lvbiwgY2FsbGJhY2spCisgICAgZXZhbEluSW5zcGVj dGVkV2luZG93OiBmdW5jdGlvbihleHByZXNzaW9uLCBjYWxsYmFjaykKICAgICB7CiAgICAgICAg IGlmIChXZWJJbnNwZWN0b3IucGFuZWxzLnNjcmlwdHMgJiYgV2ViSW5zcGVjdG9yLnBhbmVscy5z Y3JpcHRzLnBhdXNlZCkgewogICAgICAgICAgICAgV2ViSW5zcGVjdG9yLnBhbmVscy5zY3JpcHRz LmV2YWx1YXRlSW5TZWxlY3RlZENhbGxGcmFtZShleHByZXNzaW9uLCBmYWxzZSwgY2FsbGJhY2sp OwpAQCAtNDQyLDcgKzQ0Miw3IEBAIFdlYkluc3BlY3Rvci5Db25zb2xlVmlldy5wcm90b3R5cGUg PSB7CiAgICAgICAgICAgICBzZWxmLnByb21wdC50ZXh0ID0gIiI7CiAgICAgICAgICAgICBzZWxm LmFkZE1lc3NhZ2UobmV3IFdlYkluc3BlY3Rvci5Db25zb2xlQ29tbWFuZFJlc3VsdChyZXN1bHQs IGV4Y2VwdGlvbiwgY29tbWFuZE1lc3NhZ2UpKTsKICAgICAgICAgfQotICAgICAgICB0aGlzLl9l dmFsSW5JbnNwZWN0ZWRXaW5kb3coc3RyLCBwcmludFJlc3VsdCk7CisgICAgICAgIHRoaXMuZXZh bEluSW5zcGVjdGVkV2luZG93KHN0ciwgcHJpbnRSZXN1bHQpOwogICAgIH0sCiAKICAgICBfZm9y bWF0OiBmdW5jdGlvbihvdXRwdXQsIGZvcmNlT2JqZWN0Rm9ybWF0KQpJbmRleDogV2ViQ29yZS9p bnNwZWN0b3IvZnJvbnQtZW5kL09iamVjdFByb3BlcnRpZXNTZWN0aW9uLmpzCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5q cwkocmV2aXNpb24gNDgzNTUpCisrKyBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvT2JqZWN0 UHJvcGVydGllc1NlY3Rpb24uanMJKHdvcmtpbmcgY29weSkKQEAgLTUzLDYzICs1MywyNyBAQCBX ZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydGllc1NlY3Rpb24ucHJvCiAgICAgICAgIEluamVjdGVk U2NyaXB0QWNjZXNzLmdldFByb3BlcnRpZXModGhpcy5vYmplY3QsIHRoaXMuaWdub3JlSGFzT3du UHJvcGVydHksIGNhbGxiYWNrKTsKICAgICB9LAogCi0gICAgX3VwZGF0ZTogZnVuY3Rpb24ocHJv cGVydGllcykKKyAgICBfdXBkYXRlOiBmdW5jdGlvbihwcm9wZXJ0aWVzLCByb290VHJlZUVsZW1l bnRDb25zdHJ1Y3RvcikKICAgICB7CisgICAgICAgIGlmICghcm9vdFRyZWVFbGVtZW50Q29uc3Ry dWN0b3IpCisgICAgICAgICAgICByb290VHJlZUVsZW1lbnRDb25zdHJ1Y3RvciA9IHRoaXMudHJl ZUVsZW1lbnRDb25zdHJ1Y3RvcjsKKyAgICAgICAgICAgIAogICAgICAgICBpZiAodGhpcy5leHRy YVByb3BlcnRpZXMpCiAgICAgICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IHRoaXMuZXh0cmFQ cm9wZXJ0aWVzLmxlbmd0aDsgKytpKQogICAgICAgICAgICAgICAgIHByb3BlcnRpZXMucHVzaCh0 aGlzLmV4dHJhUHJvcGVydGllc1tpXSk7Ci0gICAgICAgIHByb3BlcnRpZXMuc29ydCh0aGlzLl9k aXNwbGF5U29ydCk7CisgICAgICAgICAgICAgICAgCisgICAgICAgIHByb3BlcnRpZXMuc29ydChy b290VHJlZUVsZW1lbnRDb25zdHJ1Y3Rvci5wcm90b3R5cGUuY29tcGFyZVByb3BlcnR5TmFtZXMp OwogCiAgICAgICAgIHRoaXMucHJvcGVydGllc1RyZWVPdXRsaW5lLnJlbW92ZUNoaWxkcmVuKCk7 CiAKICAgICAgICAgZm9yICh2YXIgaSA9IDA7IGkgPCBwcm9wZXJ0aWVzLmxlbmd0aDsgKytpKQot ICAgICAgICAgICAgdGhpcy5wcm9wZXJ0aWVzVHJlZU91dGxpbmUuYXBwZW5kQ2hpbGQobmV3IHRo aXMudHJlZUVsZW1lbnRDb25zdHJ1Y3Rvcihwcm9wZXJ0aWVzW2ldKSk7CisgICAgICAgICAgICB0 aGlzLnByb3BlcnRpZXNUcmVlT3V0bGluZS5hcHBlbmRDaGlsZChuZXcgcm9vdFRyZWVFbGVtZW50 Q29uc3RydWN0b3IocHJvcGVydGllc1tpXSkpOwogCiAgICAgICAgIGlmICghdGhpcy5wcm9wZXJ0 aWVzVHJlZU91dGxpbmUuY2hpbGRyZW4ubGVuZ3RoKSB7CiAgICAgICAgICAgICB2YXIgdGl0bGUg PSAiPGRpdiBjbGFzcz1cImluZm9cIj4iICsgdGhpcy5lbXB0eVBsYWNlaG9sZGVyICsgIjwvZGl2 PiI7CiAgICAgICAgICAgICB2YXIgaW5mb0VsZW1lbnQgPSBuZXcgVHJlZUVsZW1lbnQodGl0bGUs IG51bGwsIGZhbHNlKTsKICAgICAgICAgICAgIHRoaXMucHJvcGVydGllc1RyZWVPdXRsaW5lLmFw cGVuZENoaWxkKGluZm9FbGVtZW50KTsKICAgICAgICAgfQotICAgIH0sCi0KLSAgICBfZGlzcGxh eVNvcnQ6IGZ1bmN0aW9uKHByb3BlcnR5QSwgcHJvcGVydHlCKSB7Ci0gICAgICAgIHZhciBhID0g cHJvcGVydHlBLm5hbWU7Ci0gICAgICAgIHZhciBiID0gcHJvcGVydHlCLm5hbWU7Ci0KLSAgICAg ICAgLy8gaWYgdXNlZCBlbHNld2hlcmUgbWFrZSBzdXJlIHRvCi0gICAgICAgIC8vICAtIGNvbnZl cnQgYSBhbmQgYiB0byBzdHJpbmdzIChub3QgbmVlZGVkIGhlcmUsIHByb3BlcnRpZXMgYXJlIGFs bCBzdHJpbmdzKQotICAgICAgICAvLyAgLSBjaGVjayBpZiBhID09IGIgKG5vdCBuZWVkZWQgaGVy ZSwgbm8gdHdvIHByb3BlcnRpZXMgY2FuIGJlIHRoZSBzYW1lKQotCi0gICAgICAgIHZhciBkaWZm ID0gMDsKLSAgICAgICAgdmFyIGNodW5rID0gL15cZCt8XlxEKy87Ci0gICAgICAgIHZhciBjaHVu a2EsIGNodW5rYiwgYW51bSwgYm51bTsKLSAgICAgICAgd2hpbGUgKGRpZmYgPT09IDApIHsKLSAg ICAgICAgICAgIGlmICghYSAmJiBiKQotICAgICAgICAgICAgICAgIHJldHVybiAtMTsKLSAgICAg ICAgICAgIGlmICghYiAmJiBhKQotICAgICAgICAgICAgICAgIHJldHVybiAxOwotICAgICAgICAg ICAgY2h1bmthID0gYS5tYXRjaChjaHVuaylbMF07Ci0gICAgICAgICAgICBjaHVua2IgPSBiLm1h dGNoKGNodW5rKVswXTsKLSAgICAgICAgICAgIGFudW0gPSAhaXNOYU4oY2h1bmthKTsKLSAgICAg ICAgICAgIGJudW0gPSAhaXNOYU4oY2h1bmtiKTsKLSAgICAgICAgICAgIGlmIChhbnVtICYmICFi bnVtKQotICAgICAgICAgICAgICAgIHJldHVybiAtMTsKLSAgICAgICAgICAgIGlmIChibnVtICYm ICFhbnVtKQotICAgICAgICAgICAgICAgIHJldHVybiAxOwotICAgICAgICAgICAgaWYgKGFudW0g JiYgYm51bSkgewotICAgICAgICAgICAgICAgIGRpZmYgPSBjaHVua2EgLSBjaHVua2I7Ci0gICAg ICAgICAgICAgICAgaWYgKGRpZmYgPT09IDAgJiYgY2h1bmthLmxlbmd0aCAhPT0gY2h1bmtiLmxl bmd0aCkgewotICAgICAgICAgICAgICAgICAgICBpZiAoIStjaHVua2EgJiYgIStjaHVua2IpIC8v IGNodW5rcyBhcmUgc3RyaW5ncyBvZiBhbGwgMHMgKHNwZWNpYWwgY2FzZSkKLSAgICAgICAgICAg ICAgICAgICAgICAgIHJldHVybiBjaHVua2EubGVuZ3RoIC0gY2h1bmtiLmxlbmd0aDsKLSAgICAg ICAgICAgICAgICAgICAgZWxzZQotICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGNodW5r Yi5sZW5ndGggLSBjaHVua2EubGVuZ3RoOwotICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAg IH0gZWxzZSBpZiAoY2h1bmthICE9PSBjaHVua2IpCi0gICAgICAgICAgICAgICAgcmV0dXJuIChj aHVua2EgPCBjaHVua2IpID8gLTEgOiAxOwotICAgICAgICAgICAgYSA9IGEuc3Vic3RyaW5nKGNo dW5rYS5sZW5ndGgpOwotICAgICAgICAgICAgYiA9IGIuc3Vic3RyaW5nKGNodW5rYi5sZW5ndGgp OwotICAgICAgICB9Ci0gICAgICAgIHJldHVybiBkaWZmOwogICAgIH0KIH0KIApAQCAtMTI5LDE4 ICs5MywxOCBAQCBXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydHlUcmVlRWxlbWVudC5wCiAgICAg ICAgIGlmICh0aGlzLmNoaWxkcmVuLmxlbmd0aCAmJiAhdGhpcy5zaG91bGRSZWZyZXNoQ2hpbGRy ZW4pCiAgICAgICAgICAgICByZXR1cm47CiAKLSAgICAgICAgdmFyIHNlbGYgPSB0aGlzOwogICAg ICAgICB2YXIgY2FsbGJhY2sgPSBmdW5jdGlvbihwcm9wZXJ0aWVzKSB7Ci0gICAgICAgICAgICBz ZWxmLnJlbW92ZUNoaWxkcmVuKCk7CisgICAgICAgICAgICB0aGlzLnJlbW92ZUNoaWxkcmVuKCk7 CiAgICAgICAgICAgICBpZiAoIXByb3BlcnRpZXMpCiAgICAgICAgICAgICAgICAgcmV0dXJuOwog Ci0gICAgICAgICAgICBwcm9wZXJ0aWVzLnNvcnQoc2VsZi5fZGlzcGxheVNvcnQpOworICAgICAg ICAgICAgdmFyIHRyZWVFbGVtZW50Q29uc3RydWN0b3IgPSB0aGlzLnRyZWVPdXRsaW5lLnNlY3Rp b24udHJlZUVsZW1lbnRDb25zdHJ1Y3RvcjsKKyAgICAgICAgICAgIHByb3BlcnRpZXMuc29ydCh0 cmVlRWxlbWVudENvbnN0cnVjdG9yLnByb3RvdHlwZS5jb21wYXJlUHJvcGVydHlOYW1lcyk7CiAg ICAgICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IHByb3BlcnRpZXMubGVuZ3RoOyArK2kpIHsK LSAgICAgICAgICAgICAgICBzZWxmLmFwcGVuZENoaWxkKG5ldyBzZWxmLnRyZWVPdXRsaW5lLnNl Y3Rpb24udHJlZUVsZW1lbnRDb25zdHJ1Y3Rvcihwcm9wZXJ0aWVzW2ldKSk7CisgICAgICAgICAg ICAgICAgdGhpcy5hcHBlbmRDaGlsZChuZXcgdHJlZUVsZW1lbnRDb25zdHJ1Y3Rvcihwcm9wZXJ0 aWVzW2ldKSk7CiAgICAgICAgICAgICB9CiAgICAgICAgIH07Ci0gICAgICAgIEluamVjdGVkU2Ny aXB0QWNjZXNzLmdldFByb3BlcnRpZXModGhpcy5wcm9wZXJ0eS52YWx1ZSwgZmFsc2UsIGNhbGxi YWNrKTsKKyAgICAgICAgSW5qZWN0ZWRTY3JpcHRBY2Nlc3MuZ2V0UHJvcGVydGllcyh0aGlzLnBy b3BlcnR5LnZhbHVlLCBmYWxzZSwgY2FsbGJhY2suYmluZCh0aGlzKSk7CiAgICAgfSwKIAogICAg IG9uZGJsY2xpY2s6IGZ1bmN0aW9uKGVsZW1lbnQsIGV2ZW50KQpAQCAtMTU1LDEwICsxMTksMTQg QEAgV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnR5VHJlZUVsZW1lbnQucAogCiAgICAgdXBkYXRl OiBmdW5jdGlvbigpCiAgICAgewotICAgICAgICB2YXIgbmFtZUVsZW1lbnQgPSBkb2N1bWVudC5j cmVhdGVFbGVtZW50KCJzcGFuIik7Ci0gICAgICAgIG5hbWVFbGVtZW50LmNsYXNzTmFtZSA9ICJu YW1lIjsKLSAgICAgICAgbmFtZUVsZW1lbnQudGV4dENvbnRlbnQgPSB0aGlzLnByb3BlcnR5Lm5h bWU7Ci0KKyAgICAgICAgdGhpcy5uYW1lRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQo InNwYW4iKTsKKyAgICAgICAgdGhpcy5uYW1lRWxlbWVudC5jbGFzc05hbWUgPSAibmFtZSI7Cisg ICAgICAgIHRoaXMubmFtZUVsZW1lbnQudGV4dENvbnRlbnQgPSB0aGlzLnByb3BlcnR5Lm5hbWU7 CisKKyAgICAgICAgdmFyIHNlcGFyYXRvckVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50 KCJzcGFuIik7CisgICAgICAgIHNlcGFyYXRvckVsZW1lbnQuY2xhc3NOYW1lID0gInNlcGFyYXRv ciI7CisgICAgICAgIHNlcGFyYXRvckVsZW1lbnQudGV4dENvbnRlbnQgPSAiOiAiOworICAgICAg ICAKICAgICAgICAgdGhpcy52YWx1ZUVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJz cGFuIik7CiAgICAgICAgIHRoaXMudmFsdWVFbGVtZW50LmNsYXNzTmFtZSA9ICJ2YWx1ZSI7CiAg ICAgICAgIHRoaXMudmFsdWVFbGVtZW50LnRleHRDb250ZW50ID0gdGhpcy5wcm9wZXJ0eS52YWx1 ZS5kZXNjcmlwdGlvbjsKQEAgLTE2Nyw4ICsxMzUsOCBAQCBXZWJJbnNwZWN0b3IuT2JqZWN0UHJv cGVydHlUcmVlRWxlbWVudC5wCiAKICAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQucmVtb3Zl Q2hpbGRyZW4oKTsKIAotICAgICAgICB0aGlzLmxpc3RJdGVtRWxlbWVudC5hcHBlbmRDaGlsZChu YW1lRWxlbWVudCk7Ci0gICAgICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50LmFwcGVuZENoaWxkKGRv Y3VtZW50LmNyZWF0ZVRleHROb2RlKCI6ICIpKTsKKyAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1l bnQuYXBwZW5kQ2hpbGQodGhpcy5uYW1lRWxlbWVudCk7CisgICAgICAgIHRoaXMubGlzdEl0ZW1F bGVtZW50LmFwcGVuZENoaWxkKHNlcGFyYXRvckVsZW1lbnQpOwogICAgICAgICB0aGlzLmxpc3RJ dGVtRWxlbWVudC5hcHBlbmRDaGlsZCh0aGlzLnZhbHVlRWxlbWVudCk7CiAgICAgICAgIHRoaXMu aGFzQ2hpbGRyZW4gPSB0aGlzLnByb3BlcnR5LnZhbHVlLmhhc0NoaWxkcmVuOwogICAgIH0sCkBA IC0yNDEsNiArMjA5LDQ3IEBAIFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0eVRyZWVFbGVtZW50 LnAKICAgICAgICAgICAgIH0KICAgICAgICAgfTsKICAgICAgICAgSW5qZWN0ZWRTY3JpcHRBY2Nl c3Muc2V0UHJvcGVydHlWYWx1ZSh0aGlzLnByb3BlcnR5LnBhcmVudE9iamVjdFByb3h5LCB0aGlz LnByb3BlcnR5Lm5hbWUsIGV4cHJlc3Npb24udHJpbVdoaXRlc3BhY2UoKSwgY2FsbGJhY2spOwor ICAgIH0sCisgICAgCisgICAgY29tcGFyZVByb3BlcnR5TmFtZXM6IGZ1bmN0aW9uKHByb3BlcnR5 QSwgcHJvcGVydHlCKSAKKyAgICB7CisgICAgICAgIHZhciBhID0gcHJvcGVydHlBLm5hbWU7Cisg ICAgICAgIHZhciBiID0gcHJvcGVydHlCLm5hbWU7CisgICAgCisgICAgICAgIC8vIGlmIHVzZWQg ZWxzZXdoZXJlIG1ha2Ugc3VyZSB0bworICAgICAgICAvLyAgLSBjb252ZXJ0IGEgYW5kIGIgdG8g c3RyaW5ncyAobm90IG5lZWRlZCBoZXJlLCBwcm9wZXJ0aWVzIGFyZSBhbGwgc3RyaW5ncykKKyAg ICAgICAgLy8gIC0gY2hlY2sgaWYgYSA9PSBiIChub3QgbmVlZGVkIGhlcmUsIG5vIHR3byBwcm9w ZXJ0aWVzIGNhbiBiZSB0aGUgc2FtZSkKKyAgICAKKyAgICAgICAgdmFyIGRpZmYgPSAwOworICAg ICAgICB2YXIgY2h1bmsgPSAvXlxkK3xeXEQrLzsKKyAgICAgICAgdmFyIGNodW5rYSwgY2h1bmti LCBhbnVtLCBibnVtOworICAgICAgICB3aGlsZSAoZGlmZiA9PT0gMCkgeworICAgICAgICAgICAg aWYgKCFhICYmIGIpCisgICAgICAgICAgICAgICAgcmV0dXJuIC0xOworICAgICAgICAgICAgaWYg KCFiICYmIGEpCisgICAgICAgICAgICAgICAgcmV0dXJuIDE7CisgICAgICAgICAgICBjaHVua2Eg PSBhLm1hdGNoKGNodW5rKVswXTsKKyAgICAgICAgICAgIGNodW5rYiA9IGIubWF0Y2goY2h1bmsp WzBdOworICAgICAgICAgICAgYW51bSA9ICFpc05hTihjaHVua2EpOworICAgICAgICAgICAgYm51 bSA9ICFpc05hTihjaHVua2IpOworICAgICAgICAgICAgaWYgKGFudW0gJiYgIWJudW0pCisgICAg ICAgICAgICAgICAgcmV0dXJuIC0xOworICAgICAgICAgICAgaWYgKGJudW0gJiYgIWFudW0pCisg ICAgICAgICAgICAgICAgcmV0dXJuIDE7CisgICAgICAgICAgICBpZiAoYW51bSAmJiBibnVtKSB7 CisgICAgICAgICAgICAgICAgZGlmZiA9IGNodW5rYSAtIGNodW5rYjsKKyAgICAgICAgICAgICAg ICBpZiAoZGlmZiA9PT0gMCAmJiBjaHVua2EubGVuZ3RoICE9PSBjaHVua2IubGVuZ3RoKSB7Cisg ICAgICAgICAgICAgICAgICAgIGlmICghK2NodW5rYSAmJiAhK2NodW5rYikgLy8gY2h1bmtzIGFy ZSBzdHJpbmdzIG9mIGFsbCAwcyAoc3BlY2lhbCBjYXNlKQorICAgICAgICAgICAgICAgICAgICAg ICAgcmV0dXJuIGNodW5rYS5sZW5ndGggLSBjaHVua2IubGVuZ3RoOworICAgICAgICAgICAgICAg ICAgICBlbHNlCisgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gY2h1bmtiLmxlbmd0aCAt IGNodW5rYS5sZW5ndGg7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfSBlbHNlIGlm IChjaHVua2EgIT09IGNodW5rYikKKyAgICAgICAgICAgICAgICByZXR1cm4gKGNodW5rYSA8IGNo dW5rYikgPyAtMSA6IDE7CisgICAgICAgICAgICBhID0gYS5zdWJzdHJpbmcoY2h1bmthLmxlbmd0 aCk7CisgICAgICAgICAgICBiID0gYi5zdWJzdHJpbmcoY2h1bmtiLmxlbmd0aCk7CisgICAgICAg IH0KKyAgICAgICAgcmV0dXJuIGRpZmY7CiAgICAgfQogfQogCkluZGV4OiBXZWJDb3JlL2luc3Bl Y3Rvci9mcm9udC1lbmQvU2NyaXB0c1BhbmVsLmpzCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaW5z cGVjdG9yL2Zyb250LWVuZC9TY3JpcHRzUGFuZWwuanMJKHJldmlzaW9uIDQ4MzU1KQorKysgV2Vi Q29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1NjcmlwdHNQYW5lbC5qcwkod29ya2luZyBjb3B5KQpA QCAtMTI2LDYgKzEyNiw3IEBAIFdlYkluc3BlY3Rvci5TY3JpcHRzUGFuZWwgPSBmdW5jdGlvbigp CiAgICAgdGhpcy50b3BTdGF0dXNCYXIuYXBwZW5kQ2hpbGQodGhpcy5zaWRlYmFyUmVzaXplV2lk Z2V0RWxlbWVudCk7CiAKICAgICB0aGlzLnNpZGViYXJQYW5lcyA9IHt9OworICAgIHRoaXMuc2lk ZWJhclBhbmVzLndhdGNoRXhwcmVzc2lvbnMgPSBuZXcgV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVz c2lvbnNTaWRlYmFyUGFuZSgpOwogICAgIHRoaXMuc2lkZWJhclBhbmVzLmNhbGxzdGFjayA9IG5l dyBXZWJJbnNwZWN0b3IuQ2FsbFN0YWNrU2lkZWJhclBhbmUoKTsKICAgICB0aGlzLnNpZGViYXJQ YW5lcy5zY29wZWNoYWluID0gbmV3IFdlYkluc3BlY3Rvci5TY29wZUNoYWluU2lkZWJhclBhbmUo KTsKICAgICB0aGlzLnNpZGViYXJQYW5lcy5icmVha3BvaW50cyA9IG5ldyBXZWJJbnNwZWN0b3Iu QnJlYWtwb2ludHNTaWRlYmFyUGFuZSgpOwpAQCAtNDcxLDYgKzQ3Miw4IEBAIFdlYkluc3BlY3Rv ci5TY3JpcHRzUGFuZWwucHJvdG90eXBlID0gewogICAgICAgICB9CiAKICAgICAgICAgdGhpcy5f c291cmNlSURNYXAgPSB7fTsKKyAgICAgICAgCisgICAgICAgIHRoaXMuc2lkZWJhclBhbmVzLndh dGNoRXhwcmVzc2lvbnMucmVmcmVzaEV4cHJlc3Npb25zKCk7CiAgICAgfSwKIAogICAgIGdldCB2 aXNpYmxlVmlldygpCkBAIC03MDQsNiArNzA3LDcgQEAgV2ViSW5zcGVjdG9yLlNjcmlwdHNQYW5l bC5wcm90b3R5cGUgPSB7CiAgICAgICAgICAgICByZXR1cm47CiAKICAgICAgICAgdGhpcy5zaWRl YmFyUGFuZXMuc2NvcGVjaGFpbi51cGRhdGUoY3VycmVudEZyYW1lKTsKKyAgICAgICAgdGhpcy5z aWRlYmFyUGFuZXMud2F0Y2hFeHByZXNzaW9ucy5yZWZyZXNoRXhwcmVzc2lvbnMoKTsKIAogICAg ICAgICB2YXIgc2NyaXB0T3JSZXNvdXJjZSA9IHRoaXMuX3NvdXJjZUlETWFwW2N1cnJlbnRGcmFt ZS5zb3VyY2VJRF07CiAgICAgICAgIHRoaXMuX3Nob3dTY3JpcHRPclJlc291cmNlKHNjcmlwdE9y UmVzb3VyY2UsIGN1cnJlbnRGcmFtZS5saW5lKTsKSW5kZXg6IFdlYkNvcmUvaW5zcGVjdG9yL2Zy b250LWVuZC9XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUuanMKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1dhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5qcwko cmV2aXNpb24gMCkKKysrIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9XYXRjaEV4cHJlc3Np b25zU2lkZWJhclBhbmUuanMJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjcyIEBACisvKgorICog Q29weXJpZ2h0IChDKSBJQk0gQ29ycC4gMjAwOSAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJp YnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBJQk0gQ29ycC4gbm9yIHRoZSBu YW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9yIHBy b21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3Bl Y2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMg UFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05UUklCVVRPUlMKKyAqICJB UyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5U QUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRSBESVND TEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisgKiBPV05FUiBPUiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwK KyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZCisgKiBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworV2ViSW5zcGVjdG9y LldhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZSA9IGZ1bmN0aW9uKCkKK3sKKyAgICBXZWJJbnNw ZWN0b3IuU2lkZWJhclBhbmUuY2FsbCh0aGlzLCBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoIldhdGNo IEV4cHJlc3Npb25zIikpOworCisgICAgdGhpcy5zZWN0aW9uID0gbmV3IFdlYkluc3BlY3Rvci5X YXRjaEV4cHJlc3Npb25zU2VjdGlvbigpOworCisgICAgdGhpcy5ib2R5RWxlbWVudC5hcHBlbmRD aGlsZCh0aGlzLnNlY3Rpb24uZWxlbWVudCk7CisKKyAgICB2YXIgYWRkRWxlbWVudCA9IGRvY3Vt ZW50LmNyZWF0ZUVsZW1lbnQoImJ1dHRvbiIpOworICAgIGFkZEVsZW1lbnQuc2V0QXR0cmlidXRl KCJ0eXBlIiwgImJ1dHRvbiIpOworICAgIGFkZEVsZW1lbnQudGV4dENvbnRlbnQgPSBXZWJJbnNw ZWN0b3IuVUlTdHJpbmcoIkFkZCIpOworICAgIGFkZEVsZW1lbnQuYWRkRXZlbnRMaXN0ZW5lcigi Y2xpY2siLCB0aGlzLnNlY3Rpb24uYWRkRXhwcmVzc2lvbi5iaW5kKHRoaXMuc2VjdGlvbiksIGZh bHNlKTsKKworICAgIHZhciByZWZyZXNoRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQo ImJ1dHRvbiIpOworICAgIHJlZnJlc2hFbGVtZW50LnNldEF0dHJpYnV0ZSgidHlwZSIsICJidXR0 b24iKTsKKyAgICByZWZyZXNoRWxlbWVudC50ZXh0Q29udGVudCA9IFdlYkluc3BlY3Rvci5VSVN0 cmluZygiUmVmcmVzaCIpOworICAgIHJlZnJlc2hFbGVtZW50LmFkZEV2ZW50TGlzdGVuZXIoImNs aWNrIiwgdGhpcy5zZWN0aW9uLnVwZGF0ZS5iaW5kKHRoaXMuc2VjdGlvbiksIGZhbHNlKTsKKwor ICAgIHZhciBjZW50ZXJFbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgiZGl2Iik7Cisg ICAgY2VudGVyRWxlbWVudC5hZGRTdHlsZUNsYXNzKCJ3YXRjaC1leHByZXNzaW9ucy1idXR0b25z LWNvbnRhaW5lciIpOworICAgIGNlbnRlckVsZW1lbnQuYXBwZW5kQ2hpbGQoYWRkRWxlbWVudCk7 CisgICAgY2VudGVyRWxlbWVudC5hcHBlbmRDaGlsZChyZWZyZXNoRWxlbWVudCk7CisgICAgdGhp cy5ib2R5RWxlbWVudC5hcHBlbmRDaGlsZChjZW50ZXJFbGVtZW50KTsKKworICAgIHRoaXMuZXhw YW5kZWQgPSB0aGlzLnNlY3Rpb24ubG9hZFNhdmVkRXhwcmVzc2lvbnMoKS5sZW5ndGggPiAwOwor ICAgIHRoaXMub25leHBhbmQgPSB0aGlzLnJlZnJlc2hFeHByZXNzaW9ucy5iaW5kKHRoaXMpOwor fQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NpZGViYXJQYW5lLnByb3RvdHlwZSA9 IHsKKyAgICByZWZyZXNoRXhwcmVzc2lvbnM6IGZ1bmN0aW9uKCkKKyAgICB7CisgICAgICAgIHRo aXMuc2VjdGlvbi51cGRhdGUoKTsKKyAgICB9Cit9CisKK1dlYkluc3BlY3Rvci5XYXRjaEV4cHJl c3Npb25zU2lkZWJhclBhbmUucHJvdG90eXBlLl9fcHJvdG9fXyA9IFdlYkluc3BlY3Rvci5TaWRl YmFyUGFuZS5wcm90b3R5cGU7CisKK1dlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlv biA9IGZ1bmN0aW9uKCkKK3sKKyAgICBXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydGllc1NlY3Rp b24uY2FsbCh0aGlzKTsKKworICAgIHRoaXMud2F0Y2hFeHByZXNzaW9ucyA9IHRoaXMubG9hZFNh dmVkRXhwcmVzc2lvbnMoKTsKKworICAgIHRoaXMuaGVhZGVyRWxlbWVudC5jbGFzc05hbWUgPSAi aGlkZGVuIjsKKyAgICB0aGlzLmVkaXRhYmxlID0gdHJ1ZTsKKyAgICB0aGlzLmV4cGFuZGVkID0g dHJ1ZTsKKyAgICB0aGlzLnByb3BlcnRpZXNFbGVtZW50LmFkZFN0eWxlQ2xhc3MoIndhdGNoLWV4 cHJlc3Npb25zIik7Cit9CisKK1dlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5w cm90b3R5cGUgPSB7CisgICAgdXBkYXRlOiBmdW5jdGlvbigpCisgICAgeworICAgICAgICBmdW5j dGlvbiBhcHBlbmRSZXN1bHQoZXhwcmVzc2lvbiwgd2F0Y2hJbmRleCwgcmVzdWx0LCBleGNlcHRp b24pCisgICAgICAgIHsKKyAgICAgICAgICAgIC8vIFRoZSBudWxsIGNoZWNrIGNhdGNoZXMgc29t ZSBvdGhlciBjYXNlcywgbGlrZSBudWxsIGl0c2VsZiwgYW5kIE5hTgorICAgICAgICAgICAgaWYg KCh0eXBlb2YgcmVzdWx0ICE9PSAib2JqZWN0IikgfHwgKHJlc3VsdCA9PSBudWxsKSkKKyAgICAg ICAgICAgICAgICByZXN1bHQgPSBuZXcgV2ViSW5zcGVjdG9yLk9iamVjdFByb3h5KG51bGwsIFtd LCAwLCBTdHJpbmcocmVzdWx0KSwgZmFsc2UpOworCisgICAgICAgICAgICB2YXIgcHJvcGVydHkg PSBuZXcgV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnR5UHJveHkoZXhwcmVzc2lvbiwgcmVzdWx0 KTsKKyAgICAgICAgICAgIHByb3BlcnR5LndhdGNoSW5kZXggPSB3YXRjaEluZGV4OworCisgICAg ICAgICAgICAvLyBGb3IgbmV3bHkgYWRkZWQsIGVtcHR5IGV4cHJlc3Npb25zLCBzZXQgZGVzY3Jp cHRpb24gdG8gIiIsCisgICAgICAgICAgICAvLyBzaW5jZSBvdGhlcndpc2UgeW91IGdldCBET01X aW5kb3cKKyAgICAgICAgICAgIGlmIChwcm9wZXJ0eS5uYW1lID09PSAiICIpIAorICAgICAgICAg ICAgICAgIHByb3BlcnR5LnZhbHVlLmRlc2NyaXB0aW9uID0gIiI7CisgICAgICAgICAgICAKKyAg ICAgICAgICAgIC8vIFRvIGNsYXJpZnkgd2hhdCdzIGdvaW5nIG9uIGhlcmU6IAorICAgICAgICAg ICAgLy8gSW4gdGhlIG91dGVyIGZ1bmN0aW9uLCB3ZSBjYWxjdWxhdGUgdGhlIG51bWJlciBvZiBw cm9wZXJ0aWVzCisgICAgICAgICAgICAvLyB0aGF0IHdlJ3JlIGdvaW5nIHRvIGJlIHVwZGF0aW5n LCBhbmQgc2V0IHRoYXQgaW4gdGhlCisgICAgICAgICAgICAvLyBwcm9wZXJ0eUNvdW50IHZhcmlh YmxlLiAgCisgICAgICAgICAgICAvLyBJbiB0aGlzIGZ1bmN0aW9uLCB3ZSB0ZXN0IHRvIHNlZSB3 aGVuIHdlIGFyZSBwcm9jZXNzaW5nIHRoZSAKKyAgICAgICAgICAgIC8vIGxhc3QgcHJvcGVydHks IGFuZCB0aGVuIGNhbGwgdGhlIHN1cGVyY2xhc3MncyBfdXBkYXRlKCkgCisgICAgICAgICAgICAv LyBtZXRob2QgdG8gZ2V0IGFsbCB0aGUgcHJvcGVydGllcyByZWZyZXNoZWQgYXQgb25jZS4KKyAg ICAgICAgICAgIHByb3BlcnRpZXMucHVzaChwcm9wZXJ0eSk7CisgICAgICAgICAgICAKKyAgICAg ICAgICAgIGlmIChwcm9wZXJ0aWVzLmxlbmd0aCA9PSBwcm9wZXJ0eUNvdW50KQorICAgICAgICAg ICAgICAgIHRoaXMuX3VwZGF0ZShwcm9wZXJ0aWVzLCBXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNz aW9uVHJlZUVsZW1lbnQpOworICAgICAgICB9CisKKyAgICAgICAgdmFyIHByb3BlcnRpZXMgPSBb XTsKKworICAgICAgICAvLyBDb3VudCB0aGUgcHJvcGVydGllcywgc28gd2Uga25vd24gd2hlbiB0 byBjYWxsIHRoaXMuX3VwZGF0ZSgpCisgICAgICAgIC8vIGluIGFwcGVuZFJlc3VsdCgpCisgICAg ICAgIHZhciBwcm9wZXJ0eUNvdW50ID0gMDsKKyAgICAgICAgZm9yICh2YXIgaSA9IDA7IGkgPCB0 aGlzLndhdGNoRXhwcmVzc2lvbnMubGVuZ3RoOyArK2kpIHsKKyAgICAgICAgICAgIGlmICghdGhp cy53YXRjaEV4cHJlc3Npb25zW2ldKSAKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAg ICAgICAgICsrcHJvcGVydHlDb3VudDsKKyAgICAgICAgfQorCisgICAgICAgIC8vIE5vdyBwcm9j ZXNzIGFsbCB0aGUgZXhwcmVzc2lvbnMsIHNpbmNlIHdlIGhhdmUgdGhlIGFjdHVhbCBjb3VudCwK KyAgICAgICAgLy8gd2hpY2ggaXMgY2hlY2tlZCBpbiB0aGUgYXBwZW5kUmVzdWx0IGlubmVyIGZ1 bmN0aW9uLgorICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IHRoaXMud2F0Y2hFeHByZXNzaW9u cy5sZW5ndGg7ICsraSkgeworICAgICAgICAgICAgdmFyIGV4cHJlc3Npb24gPSB0aGlzLndhdGNo RXhwcmVzc2lvbnNbaV07CisgICAgICAgICAgICBpZiAoIWV4cHJlc3Npb24pIAorICAgICAgICAg ICAgICAgIGNvbnRpbnVlOworCisgICAgICAgICAgICBXZWJJbnNwZWN0b3IuY29uc29sZS5ldmFs SW5JbnNwZWN0ZWRXaW5kb3coZXhwcmVzc2lvbiwgYXBwZW5kUmVzdWx0LmJpbmQodGhpcywgZXhw cmVzc2lvbiwgaSkpOworICAgICAgICB9CisKKyAgICAgICAgLy8gbm90ZSB0aGlzIGlzIHNldHRp bmcgdGhlIGV4cGFuc2lvbiBvZiB0aGUgdHJlZSwgbm90IHRoZSBzZWN0aW9uOworICAgICAgICAv LyB3aXRoIG5vIGV4cHJlc3Npb25zLCBhbmQgZXhwYW5kZWQgdHJlZSwgd2UgZ2V0IHNvbWUgZXh0 cmEgdmVydGljYWwKKyAgICAgICAgLy8gd2hpdGUgc3BhY2UKKyAgICAgICAgLy8gRklYTUU6IHNo b3VsZCBjaGFuZ2UgdG8gdXNlIGhlYWRlciBidXR0b25zIGluc3RlYWQgb2YgdGhlIGJ1dHRvbnMK KyAgICAgICAgLy8gYXQgdGhlIGJvdHRvbSBvZiB0aGUgc2VjdGlvbiwgdGhlbiB3ZSBjYW4gYWRk IGEgIk5vIFdhdGNoIEV4cHJlc3Npb25zCisgICAgICAgIC8vIGVsZW1lbnQgd2hlbiB0aGVyZSBh cmUgbm8gd2F0Y2ggZXhwcmVzc2lvbnMsIGFuZCB0aGlzIGlzc3VlIHNob3VsZAorICAgICAgICAv LyBnbyBhd2F5LgorICAgICAgICB0aGlzLmV4cGFuZGVkID0gKHByb3BlcnR5Q291bnQgIT0gMCk7 CisgICAgfSwKKworICAgIGFkZEV4cHJlc3Npb246IGZ1bmN0aW9uKCkKKyAgICB7CisgICAgICAg IHRoaXMud2F0Y2hFeHByZXNzaW9ucy5wdXNoKCIgIik7CisgICAgICAgIHRoaXMudXBkYXRlKCk7 CisKKyAgICAgICAgLy8gQWZ0ZXIgdXBkYXRlKCksIHRoZSBuZXcgZW1wdHkgZXhwcmVzc2lvbiB0 byBiZSBlZGl0ZWQKKyAgICAgICAgLy8gd2lsbCBiZSBpbiB0aGUgdHJlZSwgYnV0IHdlIGhhdmUg dG8gZmluZCBpdC4KKyAgICAgICAgdHJlZUVsZW1lbnQgPSB0aGlzLmZpbmRBZGRlZFRyZWVFbGVt ZW50KCk7CisgICAgICAgIGlmICh0cmVlRWxlbWVudCkKKyAgICAgICAgICAgIHRyZWVFbGVtZW50 LnN0YXJ0RWRpdGluZygpOworICAgIH0sCisKKyAgICB1cGRhdGVFeHByZXNzaW9uOiBmdW5jdGlv bihlbGVtZW50LCB2YWx1ZSkKKyAgICB7CisgICAgICAgIHRoaXMud2F0Y2hFeHByZXNzaW9uc1tl bGVtZW50LnByb3BlcnR5LndhdGNoSW5kZXhdID0gdmFsdWU7CisgICAgICAgIHRoaXMuc2F2ZUV4 cHJlc3Npb25zKCk7CisgICAgICAgIHRoaXMudXBkYXRlKCk7CisgICAgfSwKKworICAgIGZpbmRB ZGRlZFRyZWVFbGVtZW50OiBmdW5jdGlvbigpCisgICAgeworICAgICAgICB2YXIgY2hpbGRyZW4g PSB0aGlzLnByb3BlcnRpZXNUcmVlT3V0bGluZS5jaGlsZHJlbjsKKyAgICAgICAgZm9yICh2YXIg aSA9IDA7IGkgPCBjaGlsZHJlbi5sZW5ndGg7ICsraSkKKyAgICAgICAgICAgIGlmIChjaGlsZHJl bltpXS5wcm9wZXJ0eS5uYW1lID09PSAiICIpCisgICAgICAgICAgICAgICAgcmV0dXJuIGNoaWxk cmVuW2ldOworICAgIH0sCisKKyAgICBsb2FkU2F2ZWRFeHByZXNzaW9uczogZnVuY3Rpb24oKQor ICAgIHsKKyAgICAgICAgdmFyIGpzb24gPSBJbnNwZWN0b3JDb250cm9sbGVyLnNldHRpbmcoIndh dGNoRXhwcmVzc2lvbnMiKTsKKyAgICAgICAgaWYgKCFqc29uKQorICAgICAgICAgICAgcmV0dXJu IFtdOworCisgICAgICAgIHRyeSB7CisgICAgICAgICAgICBqc29uID0gSlNPTi5wYXJzZShqc29u KTsKKyAgICAgICAgfSBjYXRjaChlKSB7CisgICAgICAgICAgICByZXR1cm4gW107CisgICAgICAg IH0KKworICAgICAgICByZXR1cm4ganNvbi5leHByZXNzaW9ucyB8fCBbXTsKKyAgICB9LAorCisg ICAgc2F2ZUV4cHJlc3Npb25zOiBmdW5jdGlvbigpCisgICAgeworICAgICAgICB2YXIgdG9TYXZl ID0gW107CisgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgdGhpcy53YXRjaEV4cHJlc3Npb25z Lmxlbmd0aDsgaSsrKQorICAgICAgICAgICAgaWYgKHRoaXMud2F0Y2hFeHByZXNzaW9uc1tpXSkK KyAgICAgICAgICAgICAgICB0b1NhdmUucHVzaCh0aGlzLndhdGNoRXhwcmVzc2lvbnNbaV0pOwor CisgICAgICAgIHZhciBqc29uID0gSlNPTi5zdHJpbmdpZnkoe2V4cHJlc3Npb25zOiB0b1NhdmV9 KTsKKyAgICAgICAgSW5zcGVjdG9yQ29udHJvbGxlci5zZXRTZXR0aW5nKCJ3YXRjaEV4cHJlc3Np b25zIiwganNvbik7CisKKyAgICAgICAgcmV0dXJuIHRvU2F2ZS5sZW5ndGg7CisgICAgfQorfQor CitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24ucHJvdG90eXBlLl9fcHJvdG9f XyA9IFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5wcm90b3R5cGU7CisKK1dl Ykluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudCA9IGZ1bmN0aW9uKHByb3BlcnR5 KQoreworICAgIFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0eVRyZWVFbGVtZW50LmNhbGwodGhp cywgcHJvcGVydHkpOworfQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1l bnQucHJvdG90eXBlID0geworICAgIHVwZGF0ZTogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAg V2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnR5VHJlZUVsZW1lbnQucHJvdG90eXBlLnVwZGF0ZS5j YWxsKHRoaXMpOworCisgICAgICAgIHZhciBkZWxldGVCdXR0b24gPSBkb2N1bWVudC5jcmVhdGVF bGVtZW50KCJpbnB1dCIpOworICAgICAgICBkZWxldGVCdXR0b24udHlwZSA9ICJidXR0b24iOwor ICAgICAgICBkZWxldGVCdXR0b24udGl0bGUgPSBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoIkRlbGV0 ZSB3YXRjaCBleHByZXNzaW9uLiIpOworICAgICAgICBkZWxldGVCdXR0b24uYWRkU3R5bGVDbGFz cygiZW5hYmxlZC1idXR0b24iKTsKKyAgICAgICAgZGVsZXRlQnV0dG9uLmFkZFN0eWxlQ2xhc3Mo ImRlbGV0ZS1idXR0b24iKTsKKyAgICAgICAgZGVsZXRlQnV0dG9uLmFkZEV2ZW50TGlzdGVuZXIo ImNsaWNrIiwgdGhpcy5fZGVsZXRlQnV0dG9uQ2xpY2tlZC5iaW5kKHRoaXMpLCBmYWxzZSk7CisK KyAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQuaW5zZXJ0QmVmb3JlKGRlbGV0ZUJ1dHRvbiwg dGhpcy5saXN0SXRlbUVsZW1lbnQuZmlyc3RDaGlsZCk7CisgICAgfSwKKworICAgIF9kZWxldGVC dXR0b25DbGlja2VkOiBmdW5jdGlvbigpCisgICAgeworICAgICAgICB0aGlzLnRyZWVPdXRsaW5l LnNlY3Rpb24udXBkYXRlRXhwcmVzc2lvbih0aGlzLCBudWxsKTsKKyAgICB9LAorCisgICAgc3Rh cnRFZGl0aW5nOiBmdW5jdGlvbigpCisgICAgeworICAgICAgICBpZiAoV2ViSW5zcGVjdG9yLmlz QmVpbmdFZGl0ZWQodGhpcy5uYW1lRWxlbWVudCkgfHwgIXRoaXMudHJlZU91dGxpbmUuc2VjdGlv bi5lZGl0YWJsZSkKKyAgICAgICAgICAgIHJldHVybjsKKworICAgICAgICB0aGlzLm5hbWVFbGVt ZW50LnRleHRDb250ZW50ID0gdGhpcy5wcm9wZXJ0eS5uYW1lLnRyaW1XaGl0ZXNwYWNlKCk7CisK KyAgICAgICAgdmFyIGNvbnRleHQgPSB7IGV4cGFuZGVkOiB0aGlzLmV4cGFuZGVkIH07CisKKyAg ICAgICAgLy8gY29sbGFwc2UgdGVtcG9yYXJpbHksIGlmIHJlcXVpcmVkCisgICAgICAgIHRoaXMu aGFzQ2hpbGRyZW4gPSBmYWxzZTsKKworICAgICAgICB0aGlzLmxpc3RJdGVtRWxlbWVudC5hZGRT dHlsZUNsYXNzKCJlZGl0aW5nLXN1Yi1wYXJ0Iik7CisKKyAgICAgICAgV2ViSW5zcGVjdG9yLnN0 YXJ0RWRpdGluZyh0aGlzLm5hbWVFbGVtZW50LCB0aGlzLmVkaXRpbmdDb21taXR0ZWQuYmluZCh0 aGlzKSwgdGhpcy5lZGl0aW5nQ2FuY2VsbGVkLmJpbmQodGhpcyksIGNvbnRleHQpOworICAgIH0s CisKKyAgICBlZGl0aW5nQ2FuY2VsbGVkOiBmdW5jdGlvbihlbGVtZW50LCBjb250ZXh0KQorICAg IHsKKyAgICAgICAgaWYgKCF0aGlzLm5hbWVFbGVtZW50LnRleHRDb250ZW50KQorICAgICAgICAg ICAgdGhpcy50cmVlT3V0bGluZS5zZWN0aW9uLnVwZGF0ZUV4cHJlc3Npb24odGhpcywgbnVsbCk7 CisgICAgICAgICAgICAKKyAgICAgICAgdGhpcy51cGRhdGUoKTsKKyAgICAgICAgdGhpcy5lZGl0 aW5nRW5kZWQoY29udGV4dCk7CisgICAgfSwKKworICAgIGFwcGx5RXhwcmVzc2lvbjogZnVuY3Rp b24oZXhwcmVzc2lvbiwgdXBkYXRlSW50ZXJmYWNlKQorICAgIHsKKyAgICAgICAgZXhwcmVzc2lv biA9IGV4cHJlc3Npb24udHJpbVdoaXRlc3BhY2UoKTsKKworICAgICAgICBpZiAoIWV4cHJlc3Np b24pCisgICAgICAgICAgICBleHByZXNzaW9uID0gbnVsbDsKKworICAgICAgICB0aGlzLnByb3Bl cnR5Lm5hbWUgPSBleHByZXNzaW9uOworICAgICAgICB0aGlzLnRyZWVPdXRsaW5lLnNlY3Rpb24u dXBkYXRlRXhwcmVzc2lvbih0aGlzLCBleHByZXNzaW9uKTsKKyAgICB9LAorICAgIAorICAgIGNv bXBhcmVQcm9wZXJ0eU5hbWVzOiBmdW5jdGlvbihwcm9wZXJ0eUEsIHByb3BlcnR5QikKKyAgICB7 CisgICAgICAgIGlmIChwcm9wZXJ0eUEud2F0Y2hJbmRleCA9PSBwcm9wZXJ0eUIud2F0Y2hJbmRl eCkKKyAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICBlbHNlIGlmIChwcm9wZXJ0eUEud2F0 Y2hJbmRleCA8IHByb3BlcnR5Qi53YXRjaEluZGV4KQorICAgICAgICAgICAgcmV0dXJuIC0xOwor ICAgICAgICBlbHNlCisgICAgICAgICAgICByZXR1cm4gMTsKKyAgICB9Cit9CisKK1dlYkluc3Bl Y3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUuX19wcm90b19fID0gV2Vi SW5zcGVjdG9yLk9iamVjdFByb3BlcnR5VHJlZUVsZW1lbnQucHJvdG90eXBlOwpJbmRleDogV2Vi Q29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5jc3MKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5jc3MJKHJldmlzaW9uIDQ4MzU1KQor KysgV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5jc3MJKHdvcmtpbmcgY29w eSkKQEAgLTEyMDYsNiArMTIwNiwxMCBAQCBib2R5LmluYWN0aXZlIC5wbGFjYXJkLnNlbGVjdGVk IHsKICAgICBtYXJnaW4tYm90dG9tOiAxcHg7CiB9CiAKKy53YXRjaC1leHByZXNzaW9ucy1idXR0 b25zLWNvbnRhaW5lciB7CisgICAgdGV4dC1hbGlnbjogY2VudGVyOworfQorCiAuc2VjdGlvbiAu aGVhZGVyIHsKICAgICBwYWRkaW5nOiAycHggOHB4IDRweCAxOHB4OwogICAgIGJvcmRlci10b3A6 IDFweCBzb2xpZCByZ2IoMTQ1LCAxNjAsIDE5Mik7CkBAIC0xMzcyLDEwICsxMzc2LDE5IEBAIGJv ZHkuaW5hY3RpdmUgLnBsYWNhcmQuc2VsZWN0ZWQgewogICAgIHRleHQtb3ZlcmZsb3c6IGNsaXA7 CiB9CiAKLWxpLmVkaXRpbmcgLnN3YXRjaCwgbGkuZWRpdGluZyAuZW5hYmxlZC1idXR0b24gewor bGkuZWRpdGluZyAuc3dhdGNoLCBsaS5lZGl0aW5nIC5lbmFibGVkLWJ1dHRvbiwgIGxpLmVkaXRp bmctc3ViLXBhcnQgLmRlbGV0ZS1idXR0b24gewogICAgIGRpc3BsYXk6IG5vbmUgIWltcG9ydGFu dDsKIH0KIAorLndhdGNoLWV4cHJlc3Npb25zID4gbGkuZWRpdGluZy1zdWItcGFydCAubmFtZSB7 CisgICAgZGlzcGxheTogYmxvY2s7IAorICAgIHdpZHRoOiAxMDAlOworfQorCisud2F0Y2gtZXhw cmVzc2lvbnMgPiBsaS5lZGl0aW5nLXN1Yi1wYXJ0IC52YWx1ZSwgLndhdGNoLWV4cHJlc3Npb25z ID4gbGkuZWRpdGluZy1zdWItcGFydCAuc2VwYXJhdG9yICB7CisgICAgZGlzcGxheTogbm9uZTsK K30KKwogLnNlY3Rpb24gLnByb3BlcnRpZXMgbGkuZWRpdGluZy1zdWItcGFydCB7CiAgICAgcGFk ZGluZzogM3B4IDZweCA4cHggMThweDsKICAgICBtYXJnaW46IC0zcHggLTZweCAtOHB4IC02cHg7 CkBAIC0xNDA5LDYgKzE0MjIsMTcgQEAgbGkuZWRpdGluZyAuc3dhdGNoLCBsaS5lZGl0aW5nIC5l bmFibGVkLQogICAgIHotaW5kZXg6IDE7CiB9CiAKKy8qIEZJWE1FOiBuZWVkIGEgYmV0dGVyIGlj b24gKGNvbW1lbnQgaW4gYnVnIDI3NTE0KSAqLworLnNlY3Rpb24gLnByb3BlcnRpZXMgLmRlbGV0 ZS1idXR0b24geworICAgIHdpZHRoOiAxMHB4OworICAgIGhlaWdodDogMTBweDsKKyAgICBiYWNr Z3JvdW5kLWltYWdlOiB1cmwoSW1hZ2VzL2Vycm9ySWNvbi5wbmcpOworICAgIGJhY2tncm91bmQt cG9zaXRpb246IDAgMDsKKyAgICBiYWNrZ3JvdW5kLWNvbG9yOiB0cmFuc3BhcmVudDsKKyAgICBi YWNrZ3JvdW5kLXJlcGVhdDogbm8tcmVwZWF0OworICAgIGJvcmRlcjogMCBub25lIHRyYW5zcGFy ZW50OworfQorCiAuc2VjdGlvbjpob3ZlciAucHJvcGVydGllcyAuZW5hYmxlZC1idXR0b24gewog ICAgIGRpc3BsYXk6IGJsb2NrOwogfQpJbmRleDogV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5k L2luc3BlY3Rvci5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVu ZC9pbnNwZWN0b3IuaHRtbAkocmV2aXNpb24gNDgzNTUpCisrKyBXZWJDb3JlL2luc3BlY3Rvci9m cm9udC1lbmQvaW5zcGVjdG9yLmh0bWwJKHdvcmtpbmcgY29weSkKQEAgLTYxLDYgKzYxLDcgQEAg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQTwogICAgIDxzY3JpcHQgdHlw ZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IkJyZWFrcG9pbnRzU2lkZWJhclBhbmUuanMiPjwvc2Ny aXB0PgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IkNhbGxTdGFja1Np ZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlw dCIgc3JjPSJTY29wZUNoYWluU2lkZWJhclBhbmUuanMiPjwvc2NyaXB0PgorICAgIDxzY3JpcHQg dHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IldhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5q cyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0iTWV0 cmljc1NpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2 YXNjcmlwdCIgc3JjPSJQcm9wZXJ0aWVzU2lkZWJhclBhbmUuanMiPjwvc2NyaXB0PgogICAgIDxz Y3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9IkNvbG9yLmpzIj48L3NjcmlwdD4KSW5k ZXg6IFdlYkNvcmUvbWFudWFsLXRlc3RzL2luc3BlY3Rvci9kZWJ1Z2dlci13YXRjaC1leHByZXNz aW9ucy5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvbWFudWFsLXRlc3RzL2luc3BlY3Rvci9k ZWJ1Z2dlci13YXRjaC1leHByZXNzaW9ucy5odG1sCShyZXZpc2lvbiAwKQorKysgV2ViQ29yZS9t YW51YWwtdGVzdHMvaW5zcGVjdG9yL2RlYnVnZ2VyLXdhdGNoLWV4cHJlc3Npb25zLmh0bWwJKHJl dmlzaW9uIDApCkBAIC0wLDAgKzEsMTE1IEBACis8cD5UZXN0IGZvciAKKzxhIGhyZWY9Imh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzUxNCI+QnVnIDI3NTE0IC0gYWRk IHN1cHBvcnQgZm9yIHdhdGNoZWQgZXhwcmVzc2lvbjwvYT4uCisKKzxwPlRvIGJlZ2luIHRlc3Qs IG9wZW4gd2ViIGluc3BlY3RvciwgZ28gdGhlIHNjcmlwdHMgcGFuZWwgCisoZW5hYmxpbmcgc2Ny aXB0IGRlYnVnZ2luZyBpZiBuZWNjY2Vzc2FyeSksIGFuZCB0aGVuIGNsaWNrIHRoaXMgbGluazoK KzxhIGhyZWY9ImphdmFzY3JpcHQ6cnVuVGVzdCgpIj5bYmVnaW4gdGVzdF08L2E+LgorCis8cD5Q ZXJmb3JtIHRoZSBmb2xsb3dpbmcgc3RlcHMsIGFuZCBub3RlIHRoZSBleHBlY3RlZCByZXN1bHRz OgorICAgIAorPG9sPgorICAgIAorPGxpPjxwPkFmdGVyIGNsaWNraW5nIHRoZSBsaW5rIGFib3Zl LCB5b3Ugc2hvdWxkIG5vdyBiZSBwYXVzZWQgaW4gdGhlIGJvZHkgb2YgCit0aGUgdGVzdCBtZXRo b2QsIHRoYW5rcyB0byB0aGUgPGNvZGU+ZGVidWdnZXI8L2NvZGU+IHN0YXRlbWVudC4KKworPGxp PjxwPkFkZCB0aGUgZm9sbG93aW5nIGV4cHJlc3Npb25zIHRvIHRoZSAiV2F0Y2ggRXhwcmVzc2lv bnMiIHNlY3Rpb24gb2YgdGhlCitTY3JpcHRzIHBhbmVsIHNpZGViYXIgcGFuZTogIjxjb2RlPnRo aXM8L2NvZGU+IiwgIjxjb2RlPmE8L2NvZGU+IiwgCisiPGNvZGU+YjwvY29kZT4iLCAiPGNvZGU+ YzwvY29kZT4iIGFuZCAiPGNvZGU+ZDwvY29kZT4iLiBEbyA8Yj5OT1Q8L2I+IGVudGVyIHRoZSBx dW90ZXMuCisKKzxsaT48cD5UaGUgdmFsdWVzIG9mIHRoZSBleHByZXNzaW9ucyBhcyBzaG93biBp biB0aGUgd2luZG93IHNob3VsZCBhIAorPGNvZGU+RE9NV2luZG93PC9jb2RlPiBmb3IgPGNvZGU+ dGhpczwvY29kZT4sIDxjb2RlPnVuZGVmaW5lZDwvY29kZT4gZm9yCit0aGUgPGNvZGU+YTwvY29k ZT4sIDxjb2RlPmI8L2NvZGU+LCBhbmQgPGNvZGU+YzwvY29kZT4gdmFyaWFibGVzLCBhbmQgYSAK K3ZhbHVlIG9mIDxjb2RlPlJlZmVyZW5jZUVycm9yOiBDYW4ndCBmaW5kIHZhcmlhYmxlOiBkPC9j b2RlPgorZm9yIHRoZSA8Y29kZT5kPC9jb2RlPiB2YXJpYWJsZS4KKworPGxpPjxwPk5vdGUgdGhh dCB0aGUgdmFsdWUgZm9yIDxjb2RlPmQ8L2NvZGU+IHNob3VsZCBub3QgY2hhbmdlIGZvciB0aGUg bGlmZSBvZiAKK3RoZSB0ZXN0LCBhcyB0aGUgdmFyaWFibGUgPGNvZGU+ZDwvY29kZT4gaXMgbmV2 ZXIgaW50cm9kdWNlZCBpbiB0aGUgcHJvZ3JhbS4KKworPGxpPjxwPlN0ZXAgdGhyb3VnaCB0aGUg Y29kZSwgYW5kIHlvdSdsbCBzZWUgdGhlIHZhbHVlcyBvZiA8Y29kZT5hPC9jb2RlPiwKKzxjb2Rl PmI8L2NvZGU+LCBhbmQgPGNvZGU+YzwvY29kZT4gY2hhbmdlLCBhcyB0aGUgdmFyaWFibGVzIGFy ZSBhc3NpZ25lZC4KK0Fsc28gbm90ZSB0aGF0IGFzIHRoZSBzY29wZSBjaGFuZ2VzIGR1ZSB0byB0 aGUgZnVuY3Rpb24gaW52b2NhdGlvbiwgdmFsdWVzCit3aWxsIGJlIGNoYW5nZWQgdG8gcmVmZXIg dG8gdGhlaXIgY3VycmVudCBzY29wZS4gIFRoZSA8Y29kZT50aGlzPC9jb2RlPgorZXhwcmVzc2lv biB3aWxsIGNoYW5nZSB3aGVuIHRoZSBtZXRob2QgaXMgaW52b2tlZCBvbiB0aGUgb2JqZWN0IGNv bnN0cnVjdGVkIGJ5Cit0aGUgdGVzdC4KKworPGxpPjxwPkNsaWNrIGRpZmZlcmVudCBzdGFjayBm cmFtZXMgaW4gdGhlIENhbGwgU3RhY2sgc2VjdGlvbiB0byBlbnN1cmUgdGhlCitleHByZXNzaW9u cyBjaGFuZ2UgdmFsdWUgYXBwcm9wcmlhdGVseSBhcyB0aGUgY3VycmVudCBzdGFjayBmcmFtZSBj aGFuZ2VzLgorCis8bGk+PHA+RHJpdmUgdGhlIGRlYnVnZ2VyIHRocm91Z2ggdGhlIGVuZCBvZiB0 aGUgb3V0ZXJtb3N0IGZ1bmN0aW9uLCBzbyB0aGF0Cit0aGUgZGVidWdnZXIgaXMgbm8gbG9uZ2Vy IGluIHBhdXNlZCBzdGF0ZS4gIFRoZSB2YWx1ZXMgb2YgCis8Y29kZT5hPC9jb2RlPiwgPGNvZGU+ YjwvY29kZT4sIGFuZCA8Y29kZT5jPC9jb2RlPiBzaG91bGQgYWxsIGJlIGEKK1JlZmVyZW5jZUVy cm9yIGxpa2UgPGNvZGU+ZDwvY29kZT4sIHNpbmNlIHRoZXNlIHZhcmlhYmxlcyBhcmUgZGVmaW5l ZCBpbiB0aGUKKzxjb2RlPnJ1blRlc3QoKTwvY29kZT4gZnVuY3Rpb24sIGFuZCB0aGUgZXhwcmVz c2lvbnMgYXJlIGJlaW5nIGV2YWx1YXRlZCBhZ2FpbnN0Cit0aGUgZ2xvYmFsIG9iamVjdC4KKwor PGxpPjxwPkZyb20gdGhlIGNvbnNvbGUsIGV4ZWN1dGUgdGhlIHN0YXRlbWVudCAiPGNvZGU+YSA9 IDE8L2NvZGU+Ii4gIFRoZQord2F0Y2ggZXhwcmVzc2lvbnMgZG8gbm90IGN1cnJlbnRseSByZWZy ZXNoLCBzbyB0aGUgdmFsdWUgZm9yIDxjb2RlPmE8L2NvZGU+CitzaG91bGQgc3RpbGwgYmUgUmVm ZXJlbmNlRXJyb3IuCisKKzxsaT48cD5DbGljayB0aGUgIlJlZnJlc2giIGJ1dHRvbiBpbiB0aGUg V2F0Y2ggRXhwcmVzc2lvbnMgc2VjdGlvbiBhbmQgdGhlCit2YWx1ZSBmb3IgIjxjb2RlPmE8L2Nv ZGU+IiBzaG91bGQgbm93IGJlICI8Y29kZT4xPC9jb2RlPiIuCisKKzxsaT48cD5DbG9zZSBkb3du IHRoZSBicm93c2VyLCBzdGFydCBpdCBiYWNrIHVwLCB0cmF2ZXJzZSB0byBhIHdlYiBzaXRlLAor YnJpbmcgdXAgd2ViIGluc3BlY3RvciwgZ28gdG8gdGhlIFNjcmlwdHMgcGFuZWwuICBZb3Ugc2hv dWxkIHNlZSB0aGUgc2FtZQorc2V0IG9mIFdhdGNoIEV4cHJlc3Npb25zIGluIHRoZSBsaXN0IGFz IHlvdSBoYWQgd2hlbiB5b3UgbGFzdCB1c2VkIHdlYgoraW5zcGVjdG9yLgorCis8bGk+PHA+RGVs ZXRlIGFuIGV4cHJlc3Npb24gYnkgbW92aW5nIHRoZSBtb3VzZSBpbnRvIHRoZSBXYXRjaCBFeHBy ZXNzaW9uCitzZWN0aW9uLCBhbmQgY2xpY2tpbmcgdGhlIFggaWNvbiB3aGljaCBhcHBlYXJzIHRv IHRoZSByaWdodCBvZiBhbiAKK2V4cHJlc3Npb24gKG9uIGhvdmVyKS4KKworPGxpPjxwPkRlbGV0 ZSBhbiBleHByZXNzaW9uIGJ5IGRvdWJsZS1jbGlja2luZyBhbnl3aGVyZSBvbiBhIHRvcC1sZXZl bCBsaW5lCitvZiBhIHdhdGNoIGV4cHJlc3Npb24sIGFuZCBjaGFuZ2luZyB0aGUgZXhwcmVzc2lv biB0byBhbiBlbXB0eSBzdHJpbmcgb3IgCitub3RoaW5nIGJ1dCB3aGl0ZS1zcGFjZS4KKworPGxp PjxwPk1vZGlmeSBhbiBlbnRyeSBieSBkb3VibGUtY2xpY2tpbmcgYW55d2hlcmUgb24gYSB0b3At bGV2ZWwgbGluZQorb2YgYSB3YXRjaCBleHByZXNzaW9uLCBhbmQgY2hhbmdpbmcgdGhlIGV4cHJl c3Npb24uCisKKzxsaT48cD5FbnRlciBhIG5ldyBleHByZXNzaW9uLCAiPGNvZGU+bmV3IERhdGUo KTwvY29kZT4iLiAgVGhlIHZhbHVlIHNob3VsZCBiZQorYSB0b1N0cmluZygpIHZlcnNpb24gb2Yg dGhlIGRhdGUuICBSZXBlYXRlZGx5IHByZXNzIHRoZSBSZWZyZXNoIGJ1dHRvbiB0byBzZWUKK3Ro ZSB2YWx1ZSB1cGRhdGVkIHdpdGggdGhlIGN1cnJlbnQgdGltZS4KKworPC9vbD4KKworPHNjcmlw dD4KK2Z1bmN0aW9uIHJ1blRlc3QoKSB7CisgICAgCisgICAgLy8gYSBuZXN0ZWQgZnVuY3Rpb24K KyAgICBmdW5jdGlvbiBzdWJGdW5jdGlvbigpIHsKKyAgICAgICAgZGVidWdnZXI7CisgICAgICAg IHZhciBhID0gImEgaW4gc3ViRnVuY3Rpb24oKSI7CisgICAgICAgIAorICAgICAgICBzdWJTdWJG dW5jdGlvbigpOworICAgICAgICAKKyAgICAgICAgLy8gYW5vdGhlciBuZXN0ZWQgZnVuY3Rpb24K KyAgICAgICAgZnVuY3Rpb24gc3ViU3ViRnVuY3Rpb24oKSB7CisgICAgICAgICAgICBkZWJ1Z2dl cjsKKyAgICAgICAgICAgIHZhciBiID0gImIgaW4gc3ViU3ViRnVuY3Rpb24oKSI7CisgICAgICAg IH0KKyAgICB9CisgICAgCisgICAgLy8gYSBjbGFzcworICAgIGZ1bmN0aW9uIGFDbGFzcygpIHsK KyAgICAgICAgdGhpcy54ID0gInh4eCI7CisgICAgICAgIHRoaXMueSA9ICJ5eXkiOworICAgIH0K KyAgICAKKyAgICBhQ2xhc3MucHJvdG90eXBlLmFNZXRob2QgPSBmdW5jdGlvbigpIHsKKyAgICAg ICAgZGVidWdnZXI7CisgICAgICAgIHZhciBjID0gImMgaW4gYU1ldGhvZCgpIjsKKyAgICB9Cisg ICAgCisgICAgLy8gbWFpbiBsb2dpYworICAgIGRlYnVnZ2VyOworICAgIAorICAgIHZhciBhID0g ImEgaW4gcnVuVGVzdCgpIjsKKyAgICB2YXIgYiA9ICJiIGluIHJ1blRlc3QoKSI7CisgICAgdmFy IGMgPSAiYyBpbiBydW5UZXN0KCkiOworICAgIAorICAgIHN1YkZ1bmN0aW9uKCk7CisgICAgCisg ICAgdmFyIG9iamVjdCA9IG5ldyBhQ2xhc3MoKTsKKyAgICBvYmplY3QuYU1ldGhvZCgpOworICAg IAorfQorPC9zY3JpcHQ+CkluZGV4OiBXZWJDb3JlL0VuZ2xpc2gubHByb2ovbG9jYWxpemVkU3Ry aW5ncy5qcwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09CkNhbm5vdCBkaXNwbGF5OiBmaWxlIG1hcmtlZCBhcyBhIGJpbmFy eSB0eXBlLgpzdm46bWltZS10eXBlID0gYXBwbGljYXRpb24vb2N0ZXQtc3RyZWFtCgovLzUyQUdF QWNnQWdBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQUlBQTlBQ0FB YmdCbEFIY0FJQUJQCkFHSUFhZ0JsQUdNQWRBQTdBQW9BQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VB WkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdBZ0FDZ0EKSlFCa0FDa0FJZ0JkQUNBQVBRQWdBQ0lB SUFBb0FDVUFaQUFwQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeQpBR2tB YmdCbkFITUFXd0FpQUNBQUtBQnlBR1VBY0FCbEFHRUFkQUJsQUdRQUlBQWxBR1FBSUFCMEFHa0Fi UUJsQUhNQUtRQWlBRjBBCklBQTlBQ0FBSWdBZ0FDZ0FjZ0JsQUhBQVpRQmhBSFFBWlFCa0FDQUFK UUJrQUNBQWRBQnBBRzBBWlFCekFDa0FJZ0E3QUFvQWJBQnYKQUdNQVlRQnNBR2tBZWdCbEFHUUFV d0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFKUUF1QURBQVpnQkNBQ0lBWFFBZ0FEMEFJQUFpQUNVQQpM Z0F3QUdZQVFnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3 QnpBRnNBSWdBbEFDNEFNQUJtCkFHMEFjd0FpQUYwQUlBQTlBQ0FBSWdBbEFDNEFNQUJtQUcwQWN3 QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUEKY2dCcEFHNEFad0J6QUZzQUln QWxBQzRBTVFCbUFDQUFaQUJoQUhrQWN3QWlBRjBBSUFBOUFDQUFJZ0FsQUM0QU1RQm1BQ0FBWkFC aApBSGtBY3dBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndC ekFGc0FJZ0FsQUM0QU1RQm1BR2dBCmNnQnpBQ0lBWFFBZ0FEMEFJQUFpQUNVQUxnQXhBR1lBYUFC eUFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjAKQUhJQWFRQnVBR2NBY3dC YkFDSUFKUUF1QURFQVpnQnRBR2tBYmdBaUFGMEFJQUE5QUNBQUlnQWxBQzRBTVFCbUFHMEFhUUJ1 QUNJQQpPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0Fp QUNVQUxnQXlBR1lBSlFBbEFDSUFYUUFnCkFEMEFJQUFpQUNVQUxnQXlBR1lBSlFBbEFDSUFPd0FL QUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUEKV3dBaUFDVUFMZ0F5 QUdZQVN3QkNBQ0lBWFFBZ0FEMEFJQUFpQUNVQUxnQXlBR1lBU3dCQ0FDSUFPd0FLQUd3QWJ3QmpB R0VBYkFCcApBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFDVUFMZ0F5QUdZQWN3QWlB RjBBSUFBOUFDQUFJZ0FsQUM0QU1nQm1BSE1BCklnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxB R1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBSlFBdUFETUFaZ0JOQUVJQUlnQmQKQUNBQVBRQWdB Q0lBSlFBdUFETUFaZ0JOQUVJQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFI SUFhUUJ1QUdjQQpjd0JiQUNJQUpRQXVBRE1BWmdCdEFITUFJZ0JkQUNBQVBRQWdBQ0lBSlFBdUFE TUFaZ0J0QUhNQUlnQTdBQW9BYkFCdkFHTUFZUUJzCkFHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFH Y0Fjd0JiQUNJQUpRQmtBQ0FBWlFCeUFISUFid0J5QUNJQVhRQWdBRDBBSUFBaUFDVUEKWkFBZ0FH VUFjZ0J5QUc4QWNnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0 QVp3QnpBRnNBSWdBbApBR1FBSUFCbEFISUFjZ0J2QUhJQUxBQWdBQ1VBWkFBZ0FIY0FZUUJ5QUc0 QWFRQnVBR2NBSWdCZEFDQUFQUUFnQUNJQUpRQXhBQ1FBClpBQWdBR1VBY2dCeUFHOEFjZ0FzQUNB QUpRQXlBQ1FBWkFBZ0FIY0FZUUJ5QUc0QWFRQnVBR2NBSWdBN0FBb0FiQUJ2QUdNQVlRQnMKQUdr QWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBSlFCa0FDQUFaUUJ5QUhJQWJ3QnlBQ3dB SUFBbEFHUUFJQUIzQUdFQQpjZ0J1QUdrQWJnQm5BSE1BSWdCZEFDQUFQUUFnQUNJQUpRQXhBQ1FB WkFBZ0FHVUFjZ0J5QUc4QWNnQXNBQ0FBSlFBeUFDUUFaQUFnCkFIY0FZUUJ5QUc0QWFRQnVBR2NB Y3dBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0EK SWdBbEFHUUFJQUJsQUhJQWNnQnZBSElBY3dBaUFGMEFJQUE5QUNBQUlnQWxBR1FBSUFCbEFISUFj Z0J2QUhJQWN3QWlBRHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQWxBR1FBSUFCbEFISUFjZ0J2QUhJQWN3QXNBQ0FBCkpRQmtBQ0FBZHdCaEFISUFi Z0JwQUc0QVp3QWlBRjBBSUFBOUFDQUFJZ0FsQURFQUpBQmtBQ0FBWlFCeUFISUFid0J5QUhNQUxB QWcKQUNVQU1nQWtBR1FBSUFCM0FHRUFjZ0J1QUdrQWJnQm5BQ0lBT3dBS0FHd0Fid0JqQUdFQWJB QnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlBQ1VBWkFBZ0FHVUFjZ0J5QUc4QWNn QnpBQ3dBSUFBbEFHUUFJQUIzQUdFQWNnQnVBR2tBYmdCbkFITUFJZ0JkCkFDQUFQUUFnQUNJQUpR QXhBQ1FBWkFBZ0FHVUFjZ0J5QUc4QWNnQnpBQ3dBSUFBbEFESUFKQUJrQUNBQWR3QmhBSElBYmdC cEFHNEEKWndCekFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdC bkFITUFXd0FpQUNVQVpBQWdBRzBBWVFCMApBR01BYUFCbEFITUFJZ0JkQUNBQVBRQWdBQ0lBSlFC a0FDQUFiUUJoQUhRQVl3Qm9BR1VBY3dBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBCmFRQjZBR1VBWkFC VEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdBbEFHUUFJQUJ6QUhRQWVRQnNBR1VBSUFCakFHZ0FZUUJ1 QUdjQVpRQWkKQUYwQUlBQTlBQ0FBSWdBbEFHUUFJQUJ6QUhRQWVRQnNBR1VBSUFCakFHZ0FZUUJ1 QUdjQVpRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QQphUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6 QUZzQUlnQWxBR1FBSUFCekFIUUFlUUJzQUdVQUlBQmpBR2dBWVFCdUFHY0FaUUJ6CkFDSUFYUUFn QUQwQUlBQWlBQ1VBWkFBZ0FITUFkQUI1QUd3QVpRQWdBR01BYUFCaEFHNEFad0JsQUhNQUlnQTdB QW9BYkFCdkFHTUEKWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQmtB Q0FBZHdCaEFISUFiZ0JwQUc0QVp3QWlBRjBBSUFBOQpBQ0FBSWdBbEFHUUFJQUIzQUdFQWNnQnVB R2tBYmdCbkFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBCmJnQm5B SE1BV3dBaUFDVUFaQUFnQUhjQVlRQnlBRzRBYVFCdUFHY0Fjd0FpQUYwQUlBQTlBQ0FBSWdBbEFH UUFJQUIzQUdFQWNnQnUKQUdrQWJnQm5BSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFH UUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFKUUJrQUNBQQoxd0FnQUNVQVpBQWlBRjBBSUFBOUFD QUFJZ0FsQURFQUpBQmtBQ0FBMXdBZ0FDVUFNZ0FrQUdRQUlnQTdBQW9BYkFCdkFHTUFZUUJzCkFH a0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQnpBQ0FBS0FCbUFISUFid0J0QUNB QVl3QmhBR01BYUFCbEFDa0EKSWdCZEFDQUFQUUFnQUNJQUpRQnpBQ0FBS0FCbUFISUFid0J0QUNB QVl3QmhBR01BYUFCbEFDa0FJZ0E3QUFvQWJBQnZBR01BWVFCcwpBR2tBZWdCbEFHUUFVd0IwQUhJ QWFRQnVBR2NBY3dCYkFDSUFKUUJ6QUNBQVpBQnZBSGNBYmdCc0FHOEFZUUJrQUNJQVhRQWdBRDBB CklBQWlBQ1VBY3dBZ0FHUUFid0IzQUc0QWJBQnZBR0VBWkFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dB YVFCNkFHVUFaQUJUQUhRQWNnQnAKQUc0QVp3QnpBRnNBSWdBbEFITUFJQUJzQUdFQWRBQmxBRzRB WXdCNUFDSUFYUUFnQUQwQUlBQWlBQ1VBY3dBZ0FHd0FZUUIwQUdVQQpiZ0JqQUhrQUlnQTdBQW9B YkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBSlFCekFDQUFi QUJoCkFIUUFaUUJ1QUdNQWVRQXNBQ0FBSlFCekFDQUFaQUJ2QUhjQWJnQnNBRzhBWVFCa0FDQUFL QUFsQUhNQUlBQjBBRzhBZEFCaEFHd0EKS1FBaUFGMEFJQUE5QUNBQUlnQWxBREVBSkFCekFDQUFi QUJoQUhRQVpRQnVBR01BZVFBc0FDQUFKUUF5QUNRQWN3QWdBR1FBYndCMwpBRzRBYkFCdkFHRUFa QUFnQUNnQUpRQXpBQ1FBY3dBZ0FIUUFid0IwQUdFQWJBQXBBQ0lBT3dBS0FHd0Fid0JqQUdFQWJB QnBBSG9BClpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBQ2dBWVFCdUFHOEFiZ0I1QUcwQWJ3 QjFBSE1BSUFCbUFIVUFiZ0JqQUhRQWFRQnYKQUc0QUtRQWlBRjBBSUFBOUFDQUFJZ0FvQUdFQWJn QnZBRzRBZVFCdEFHOEFkUUJ6QUNBQVpnQjFBRzRBWXdCMEFHa0Fid0J1QUNrQQpJZ0E3QUFvQWJB QnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUtBQndBSElBYndC bkFISUFZUUJ0CkFDa0FJZ0JkQUNBQVBRQWdBQ0lBS0FCd0FISUFid0JuQUhJQVlRQnRBQ2tBSWdB N0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUEKVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBS0FC d0FISUFid0JuQUhJQVlRQnRBQ2tBT2dBZ0FDVUFjd0FpQUYwQUlBQTlBQ0FBSWdBbwpBSEFBY2dC dkFHY0FjZ0JoQUcwQUtRQTZBQ0FBSlFCekFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJr QUZNQWRBQnlBR2tBCmJnQm5BSE1BV3dBaUFDZ0FkQUJsQUhnQWRBQXBBQ0lBWFFBZ0FEMEFJQUFp QUNnQWRBQmxBSGdBZEFBcEFDSUFPd0FLQUd3QWJ3QmoKQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5 QUdrQWJnQm5BSE1BV3dBaUFDZ0Fkd0JvQUdrQWRBQmxBSE1BY0FCaEFHTUFaUUFwQUNJQQpYUUFn QUQwQUlBQWlBQ2dBZHdCb0FHa0FkQUJsQUhNQWNBQmhBR01BWlFBcEFDSUFPd0FLQUd3QWJ3QmpB R0VBYkFCcEFIb0FaUUJrCkFGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFERUFJQUJ0QUdFQWRBQmpB R2dBSWdCZEFDQUFQUUFnQUNJQU1RQWdBRzBBWVFCMEFHTUEKYUFBaUFEc0FDZ0JzQUc4QVl3QmhB R3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JCQUd3QWJBQWlBRjBBSUFBOQpB Q0FBSWdCQkFHd0FiQUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFH NEFad0J6QUZzQUlnQkJBR3dBCmR3QmhBSGtBY3dBZ0FHVUFiZ0JoQUdJQWJBQmxBQ0lBWFFBZ0FE MEFJQUFpQUVFQWJBQjNBR0VBZVFCekFDQUFaUUJ1QUdFQVlnQnMKQUdVQUlnQTdBQW9BYkFCdkFH TUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBUVFCdUFDQUFaUUJ5QUhJ QQpid0J5QUNBQWJ3QmpBR01BZFFCeUFISUFaUUJrQUNBQWRBQnlBSGtBYVFCdUFHY0FJQUIwQUc4 QVhBQnVBSElBWlFCaEFHUUFJQUIwCkFHZ0FaUUFnQUJ3Z0pRQnpBQjBnSUFCMEFHRUFZZ0JzQUdV QUxnQWlBRjBBSUFBOUFDQUFJZ0JCQUc0QUlBQmxBSElBY2dCdkFISUEKSUFCdkFHTUFZd0IxQUhJ QWNnQmxBR1FBSUFCMEFISUFlUUJwQUc0QVp3QWdBSFFBYndCY0FHNEFjZ0JsQUdFQVpBQWdBSFFB YUFCbApBQ0FBSENBbEFITUFIU0FnQUhRQVlRQmlBR3dBWlFBdUFDSUFPd0FLQUd3QWJ3QmpBR0VB YkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBCmJnQm5BSE1BV3dBaUFFRUFiZ0FnQUhVQWJnQmxBSGdB Y0FCbEFHTUFkQUJsQUdRQUlBQmxBSElBY2dCdkFISUFJQUFsQUhNQUlBQnYKQUdNQVl3QjFBSElB Y2dCbEFHUUFMZ0FpQUYwQUlBQTlBQ0FBSWdCQkFHNEFJQUIxQUc0QVpRQjRBSEFBWlFCakFIUUFa UUJrQUNBQQpaUUJ5QUhJQWJ3QnlBQ0FBSlFCekFDQUFid0JqQUdNQWRRQnlBSElBWlFCa0FDNEFJ Z0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsCkFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFR UUIyQUdVQWNnQmhBR2NBWlFBaUFGMEFJQUE5QUNBQUlnQkJBSFlBWlFCeUFHRUEKWndCbEFDSUFP d0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVJQWNn QmxBR0VBYXdCdwpBRzhBYVFCdUFIUUFjd0FpQUYwQUlBQTlBQ0FBSWdCQ0FISUFaUUJoQUdzQWNB QnZBR2tBYmdCMEFITUFJZ0E3QUFvQWJBQnZBR01BCllRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFR QnVBR2NBY3dCYkFDSUFRd0JQQUU4QVN3QkpBRVVBVXdBaUFGMEFJQUE5QUNBQUlnQkQKQUU4QVR3 QkxBRWtBUlFCVEFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdC bkFITUFXd0FpQUVNQQpZUUJzQUd3QUlBQlRBSFFBWVFCakFHc0FJZ0JkQUNBQVBRQWdBQ0lBUXdC aEFHd0FiQUFnQUZNQWRBQmhBR01BYXdBaUFEc0FDZ0JzCkFHOEFZd0JoQUd3QWFRQjZBR1VBWkFC VEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCREFHRUFiQUJzQUhNQUlnQmRBQ0FBUFFBZ0FDSUEKUXdC aEFHd0FiQUJ6QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju QUhNQVd3QWlBRU1BYkFCbApBR0VBY2dBZ0FHTUFhQUJoQUc0QVp3QmxBSE1BSUFCc0FHOEFad0F1 QUNJQVhRQWdBRDBBSUFBaUFFTUFiQUJsQUdFQWNnQWdBR01BCmFBQmhBRzRBWndCbEFITUFJQUJz QUc4QVp3QXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm4K QUhNQVd3QWlBRU1BYkFCbEFHRUFjZ0FnQUdNQWJ3QnVBSE1BYndCc0FHVUFJQUJzQUc4QVp3QXVB Q0lBWFFBZ0FEMEFJQUFpQUVNQQpiQUJsQUdFQWNnQWdBR01BYndCdUFITUFid0JzQUdVQUlBQnNB RzhBWndBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrCkFGTUFkQUJ5QUdrQWJnQm5B SE1BV3dBaUFFTUFiQUJ2QUhNQWRRQnlBR1VBSWdCZEFDQUFQUUFnQUNJQVF3QnNBRzhBY3dCMUFI SUEKWlFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFG c0FJZ0JEQUc4QWJRQndBSFVBZEFCbApBR1FBSUFCVEFIUUFlUUJzQUdVQUlnQmRBQ0FBUFFBZ0FD SUFRd0J2QUcwQWNBQjFBSFFBWlFCa0FDQUFVd0IwQUhrQWJBQmxBQ0lBCk93QUtBR3dBYndCakFH RUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRU1BYndCdkFHc0FhUUJsQUhN QUlnQmQKQUNBQVBRQWdBQ0lBUXdCdkFHOEFhd0JwQUdVQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3 QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QQpad0J6QUZzQUlnQkVBRUVBVkFCQkFFSUFRUUJUQUVV QVV3QWlBRjBBSUFBOUFDQUFJZ0JFQUVFQVZBQkJBRUlBUVFCVEFFVUFVd0FpCkFEc0FDZ0JzQUc4 QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JFQUU4QVRRQWlBRjBB SUFBOUFDQUEKSWdCRUFFOEFUUUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFB Y2dCcEFHNEFad0J6QUZzQUlnQkVBR0VBZEFCaApBR0lBWVFCekFHVUFJQUJ1QUc4QUlBQnNBRzhB YmdCbkFHVUFjZ0FnQUdnQVlRQnpBQ0FBWlFCNEFIQUFaUUJqQUhRQVpRQmtBQ0FBCmRnQmxBSElB Y3dCcEFHOEFiZ0F1QUNJQVhRQWdBRDBBSUFBaUFFUUFZUUIwQUdFQVlnQmhBSE1BWlFBZ0FHNEFi d0FnQUd3QWJ3QnUKQUdjQVpRQnlBQ0FBYUFCaEFITUFJQUJsQUhnQWNBQmxBR01BZEFCbEFHUUFJ QUIyQUdVQWNnQnpBR2tBYndCdUFDNEFJZ0E3QUFvQQpiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFV d0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFSQUJsQUdJQWRRQm5BR2NBYVFCdUFHY0FJQUJrCkFHa0Fj d0JoQUdJQWJBQmxBR1FBTGdBZ0FFTUFiQUJwQUdNQWF3QWdBSFFBYndBZ0FHVUFiZ0JoQUdJQWJB QmxBQzRBSWdCZEFDQUEKUFFBZ0FDSUFSQUJsQUdJQWRRQm5BR2NBYVFCdUFHY0FJQUJrQUdrQWN3 QmhBR0lBYkFCbEFHUUFMZ0FnQUVNQWJBQnBBR01BYXdBZwpBSFFBYndBZ0FHVUFiZ0JoQUdJQWJB QmxBQzRBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBCmN3 QmJBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCbEFHNEFZUUJpQUd3QVpRQmtBQzRBSUFC REFHd0FhUUJqQUdzQUlBQjAKQUc4QUlBQmtBR2tBY3dCaEFHSUFiQUJsQUM0QUlnQmRBQ0FBUFFB Z0FDSUFSQUJsQUdJQWRRQm5BR2NBYVFCdUFHY0FJQUJsQUc0QQpZUUJpQUd3QVpRQmtBQzRBSUFC REFHd0FhUUJqQUdzQUlBQjBBRzhBSUFCa0FHa0Fjd0JoQUdJQWJBQmxBQzRBSWdBN0FBb0FiQUJ2 CkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBUkFCbEFHSUFkUUJu QUdjQWFRQnVBR2NBSUFCekFHTUEKY2dCcEFIQUFkQUJ6QUNBQWNnQmxBSEVBZFFCcEFISUFaUUJ6 QUNBQWVRQnZBSFVBSUFCMEFHOEFJQUJ6QUhRQVlRQnlBSFFBSUFCMApBR2dBWlFBZ0FHUUFaUUJp QUhVQVp3Qm5BR1VBY2dBdUFDSUFYUUFnQUQwQUlBQWlBRVFBWlFCaUFIVUFad0JuQUdrQWJnQm5B Q0FBCmN3QmpBSElBYVFCd0FIUUFjd0FnQUhJQVpRQnhBSFVBYVFCeUFHVUFjd0FnQUhrQWJ3QjFB Q0FBZEFCdkFDQUFjd0IwQUdFQWNnQjAKQUNBQWRBQm9BR1VBSUFCa0FHVUFZZ0IxQUdjQVp3QmxB SElBTGdBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQQpjZ0JwQUc0QVp3QnpB RnNBSWdCRUFHVUFiQUJsQUhRQVpRQWlBRjBBSUFBOUFDQUFJZ0JFQUdVQWJBQmxBSFFBWlFBaUFE c0FDZ0JzCkFHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCRUFH a0FiUUJsQUc0QWN3QnBBRzhBYmdCekFDSUEKWFFBZ0FEMEFJQUFpQUVRQWFRQnRBR1VBYmdCekFH a0Fid0J1QUhNQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMApBSElBYVFCdUFH Y0Fjd0JiQUNJQVJBQnZBR01BYXdBZ0FIUUFid0FnQUcwQVlRQnBBRzRBSUFCM0FHa0FiZ0JrQUc4 QWR3QXVBQ0lBClhRQWdBRDBBSUFBaUFFUUFid0JqQUdzQUlBQjBBRzhBSUFCdEFHRUFhUUJ1QUNB QWR3QnBBRzRBWkFCdkFIY0FMZ0FpQURzQUNnQnMKQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JFQUc4QVl3QjFBRzBBWlFCdUFIUUFjd0FpQUYwQQpJQUE5QUNB QUlnQkVBRzhBWXdCMUFHMEFaUUJ1QUhRQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VB WkFCVEFIUUFjZ0JwCkFHNEFad0J6QUZzQUlnQkVBRzhBYlFCaEFHa0FiZ0FpQUYwQUlBQTlBQ0FB SWdCRUFHOEFiUUJoQUdrQWJnQWlBRHNBQ2dCc0FHOEEKWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFB Y2dCcEFHNEFad0J6QUZzQUlnQkVBRzhBYmdBbkFIUUFJQUJ3QUdFQWRRQnpBR1VBSUFCdgpBRzRB SUFCbEFIZ0FZd0JsQUhBQWRBQnBBRzhBYmdCekFDNEFJZ0JkQUNBQVBRQWdBQ0lBUkFCdkFHNEFH U0IwQUNBQWNBQmhBSFVBCmN3QmxBQ0FBYndCdUFDQUFaUUI0QUdNQVpRQndBSFFBYVFCdkFHNEFj d0F1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmsKQUZNQWRBQnlBR2tBYmdCbkFITUFX d0FpQUVRQWJ3QjFBR0lBYkFCbEFDMEFRd0JzQUdrQVl3QnJBQ0FBZEFCdkFDQUFRUUJrQUdRQQpJ Z0JkQUNBQVBRQWdBQ0lBUkFCdkFIVUFZZ0JzQUdVQUxRQkRBR3dBYVFCakFHc0FJQUIwQUc4QUlB QkJBR1FBWkFBaUFEc0FDZ0JzCkFHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3 QnpBRnNBSWdCRUFHOEFkUUJpQUd3QVpRQXRBRU1BYkFCcEFHTUEKYXdBZ0FIUUFid0FnQUhRQWJ3 Qm5BR2NBYkFCbEFDQUFZZ0JsQUhRQWR3QmxBR1VBYmdBZ0FGVUFVZ0JNQUNBQVpRQnVBR01BYndC awpBR1VBWkFBZ0FHRUFiZ0JrQUNBQVpBQmxBR01BYndCa0FHVUFaQUFnQUdZQWJ3QnlBRzBBWVFC MEFITUFJZ0JkQUNBQVBRQWdBQ0lBClJBQnZBSFVBWWdCc0FHVUFMUUJEQUd3QWFRQmpBR3NBSUFC MEFHOEFJQUIwQUc4QVp3Qm5BR3dBWlFBZ0FHSUFaUUIwQUhjQVpRQmwKQUc0QUlBQlZBRklBVEFB Z0FHVUFiZ0JqQUc4QVpBQmxBR1FBSUFCaEFHNEFaQUFnQUdRQVpRQmpBRzhBWkFCbEFHUUFJQUJt QUc4QQpjZ0J0QUdFQWRBQnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5 QUdrQWJnQm5BSE1BV3dBaUFFVUFiQUJsCkFHMEFaUUJ1QUhRQWN3QWlBRjBBSUFBOUFDQUFJZ0JG QUd3QVpRQnRBR1VBYmdCMEFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0EKZWdCbEFHUUFVd0Iw QUhJQWFRQnVBR2NBY3dCYkFDSUFSUUJ1QUdFQVlnQnNBR1VBSUFCRUFHVUFZZ0IxQUdjQVp3QnBB RzRBWndBaQpBRjBBSUFBOUFDQUFJZ0JGQUc0QVlRQmlBR3dBWlFBZ0FFUUFaUUJpQUhVQVp3Qm5B R2tBYmdCbkFDSUFPd0FLQUd3QWJ3QmpBR0VBCmJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5B SE1BV3dBaUFFVUFiZ0JoQUdJQWJBQmxBQ0FBVUFCeUFHOEFaZ0JwQUd3QWFRQnUKQUdjQUlnQmRB Q0FBUFFBZ0FDSUFSUUJ1QUdFQVlnQnNBR1VBSUFCUUFISUFid0JtQUdrQWJBQnBBRzRBWndBaUFE c0FDZ0JzQUc4QQpZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCRkFH NEFZUUJpQUd3QVpRQWdBSElBWlFCekFHOEFkUUJ5CkFHTUFaUUFnQUhRQWNnQmhBR01BYXdCcEFH NEFad0FpQUYwQUlBQTlBQ0FBSWdCRkFHNEFZUUJpQUd3QVpRQWdBSElBWlFCekFHOEEKZFFCeUFH TUFaUUFnQUhRQWNnQmhBR01BYXdCcEFHNEFad0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdV QVpBQlRBSFFBY2dCcApBRzRBWndCekFGc0FJZ0JGQUc0QVlRQmlBR3dBYVFCdUFHY0FJQUJrQUdV QVlnQjFBR2NBWndCcEFHNEFad0FnQUhjQWFRQnNBR3dBCklBQnRBR0VBYXdCbEFDQUFjd0JqQUhJ QWFRQndBSFFBY3dBZ0FISUFkUUJ1QUNBQWN3QnNBRzhBZHdCbEFISUFMZ0FpQUYwQUlBQTkKQUNB QUlnQkZBRzRBWVFCaUFHd0FhUUJ1QUdjQUlBQmtBR1VBWWdCMUFHY0Fad0JwQUc0QVp3QWdBSGNB YVFCc0FHd0FJQUJ0QUdFQQphd0JsQUNBQWN3QmpBSElBYVFCd0FIUUFjd0FnQUhJQWRRQnVBQ0FB Y3dCc0FHOEFkd0JsQUhJQUxnQWlBRHNBQ2dCc0FHOEFZd0JoCkFHd0FhUUI2QUdVQVpBQlRBSFFB Y2dCcEFHNEFad0J6QUZzQUlnQkZBRzRBWVFCaUFHd0FhUUJ1QUdjQUlBQndBSElBYndCbUFHa0EK YkFCcEFHNEFad0FnQUhjQWFRQnNBR3dBSUFCdEFHRUFhd0JsQUNBQWN3QmpBSElBYVFCd0FIUUFj d0FnQUhJQWRRQnVBQ0FBY3dCcwpBRzhBZHdCbEFISUFMZ0FpQUYwQUlBQTlBQ0FBSWdCRkFHNEFZ UUJpQUd3QWFRQnVBR2NBSUFCd0FISUFid0JtQUdrQWJBQnBBRzRBClp3QWdBSGNBYVFCc0FHd0FJ QUJ0QUdFQWF3QmxBQ0FBY3dCakFISUFhUUJ3QUhRQWN3QWdBSElBZFFCdUFDQUFjd0JzQUc4QWR3 QmwKQUhJQUxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3 QnpBRnNBSWdCRkFHNEFZUUJpQUd3QQphUUJ1QUdjQUlBQnlBR1VBY3dCdkFIVUFjZ0JqQUdVQUlB QjBBSElBWVFCakFHc0FhUUJ1QUdjQUlBQjNBR2tBYkFCc0FDQUFjZ0JsCkFHd0Fid0JoQUdRQUlB QjBBR2dBWlFBZ0FIQUFZUUJuQUdVQUlBQmhBRzRBWkFBZ0FHMEFZUUJyQUdVQUlBQndBR0VBWndC bEFDQUEKYkFCdkFHRUFaQUJwQUc0QVp3QWdBSE1BYkFCdkFIY0FaUUJ5QUM0QUlnQmRBQ0FBUFFB Z0FDSUFSUUJ1QUdFQVlnQnNBR2tBYmdCbgpBQ0FBY2dCbEFITUFid0IxQUhJQVl3QmxBQ0FBZEFC eUFHRUFZd0JyQUdrQWJnQm5BQ0FBZHdCcEFHd0FiQUFnQUhJQVpRQnNBRzhBCllRQmtBQ0FBZEFC b0FHVUFJQUJ3QUdFQVp3QmxBQ0FBWVFCdUFHUUFJQUJ0QUdFQWF3QmxBQ0FBY0FCaEFHY0FaUUFn QUd3QWJ3QmgKQUdRQWFRQnVBR2NBSUFCekFHd0Fid0IzQUdVQWNnQXVBQ0lBT3dBS0FHd0Fid0Jq QUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlBRVVBZGdCbEFHNEFkQUFn QUVRQWJ3QmpBSFVBYlFCbEFHNEFkQUFpQUYwQUlBQTlBQ0FBSWdCRkFIWUFaUUJ1CkFIUUFJQUJF QUc4QVl3QjFBRzBBWlFCdUFIUUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBB SElBYVFCdUFHY0EKY3dCYkFDSUFSUUIyQUdVQWJnQjBBQ0FBVkFCaEFISUFad0JsQUhRQUlnQmRB Q0FBUFFBZ0FDSUFSUUIyQUdVQWJnQjBBQ0FBVkFCaApBSElBWndCbEFIUUFJZ0E3QUFvQWJBQnZB R01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVJRQjRBR01BCmJBQjFB R1FBWlFBZ0FITUFaUUJzQUdVQVl3QjBBR1VBWkFBZ0FHWUFkUUJ1QUdNQWRBQnBBRzhBYmdBdUFD SUFYUUFnQUQwQUlBQWkKQUVVQWVBQmpBR3dBZFFCa0FHVUFJQUJ6QUdVQWJBQmxBR01BZEFCbEFH UUFJQUJtQUhVQWJnQmpBSFFBYVFCdkFHNEFMZ0FpQURzQQpDZ0JzQUc4QVl3QmhBR3dBYVFCNkFH VUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JGQUhnQWNBQnBBSElBWlFCekFDSUFYUUFnCkFE MEFJQUFpQUVVQWVBQndBR2tBY2dCbEFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdR QVV3QjBBSElBYVFCdUFHY0EKY3dCYkFDSUFSZ0JwQUd3QVpRQWdBSE1BYVFCNkFHVUFJZ0JkQUNB QVBRQWdBQ0lBUmdCcEFHd0FaUUFnQUhNQWFRQjZBR1VBSWdBNwpBQW9BYkFCdkFHTUFZUUJzQUdr QWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBUmdCdkFHTUFkUUJ6QUNBQWN3QmxBR3dB ClpRQmpBSFFBWlFCa0FDQUFaZ0IxQUc0QVl3QjBBR2tBYndCdUFDNEFJZ0JkQUNBQVBRQWdBQ0lB UmdCdkFHTUFkUUJ6QUNBQWJ3QnUKQUNBQWN3QmxBR3dBWlFCakFIUUFaUUJrQUNBQVpnQjFBRzRB WXdCMEFHa0Fid0J1QUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQQplZ0JsQUdRQVV3QjBBSElB YVFCdUFHY0Fjd0JiQUNJQVJnQnZBRzRBZEFCekFDSUFYUUFnQUQwQUlBQWlBRVlBYndCdUFIUUFj d0FpCkFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJ Z0JHQUc4QWNnQnRBQ0FBUkFCaEFIUUEKWVFBaUFGMEFJQUE5QUNBQUlnQkdBRzhBY2dCdEFDQUFS QUJoQUhRQVlRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVApBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQkdBSFVBYmdCakFIUUFhUUJ2QUc0QUlnQmRBQ0FBUFFBZ0FDSUFSZ0IxQUc0QVl3 QjBBR2tBCmJ3QnVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJn Qm5BSE1BV3dBaUFFY0FVZ0JCQUZBQVNBQlQKQUNJQVhRQWdBRDBBSUFBaUFFY0FVZ0JCQUZBQVNB QlRBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3 QWlBRWNBYkFCdkFHSUFZUUJzQUNJQVhRQWdBRDBBSUFBaUFFY0FiQUJ2QUdJQVlRQnNBQ0lBT3dB S0FHd0Fid0JqCkFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRWdBVkFC VUFGQUFJZ0JkQUNBQVBRQWdBQ0lBU0FCVUFGUUEKVUFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFC NkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JJQUdVQVlRQjJBSGtBSUFBbwpBRUlBYndC MEFIUUFid0J0QUNBQVZRQndBQ2tBSWdCZEFDQUFQUUFnQUNJQVNBQmxBR0VBZGdCNUFDQUFLQUJD QUc4QWRBQjBBRzhBCmJRQWdBRlVBY0FBcEFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJr QUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVnQWFRQmsKQUdVQUlBQmpBR2dBWVFCdUFHY0FaUUJ6 QUNBQWRnQnBBR1VBZHdBdUFDSUFYUUFnQUQwQUlBQWlBRWdBYVFCa0FHVUFJQUJqQUdnQQpZUUJ1 QUdjQVpRQnpBQ0FBZGdCcEFHVUFkd0F1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtB Rk1BZEFCeUFHa0FiZ0JuCkFITUFXd0FpQUVnQWFRQmtBR1VBSUFCakFHOEFiZ0J6QUc4QWJBQmxB QzRBSWdCZEFDQUFQUUFnQUNJQVNBQnBBR1FBWlFBZ0FHTUEKYndCdUFITUFid0JzQUdVQUxnQWlB RHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCSgpB RzBBWVFCbkFHVUFjd0FpQUYwQUlBQTlBQ0FBSWdCSkFHMEFZUUJuQUdVQWN3QWlBRHNBQ2dCc0FH OEFZd0JoQUd3QWFRQjZBR1VBClpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkxBR1VBZVFBaUFG MEFJQUE5QUNBQUlnQkxBR1VBZVFBaUFEc0FDZ0JzQUc4QVl3QmgKQUd3QWFRQjZBR1VBWkFCVEFI UUFjZ0JwQUc0QVp3QnpBRnNBSWdCTUFFOEFRd0JCQUV3QUlBQlRBRlFBVHdCU0FFRUFSd0JGQUNJ QQpYUUFnQUQwQUlBQWlBRXdBVHdCREFFRUFUQUFnQUZNQVZBQlBBRklBUVFCSEFFVUFJZ0E3QUFv QWJBQnZBR01BWVFCc0FHa0FlZ0JsCkFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFUQUJ2QUdN QVlRQnNBQ0lBWFFBZ0FEMEFJQUFpQUV3QWJ3QmpBR0VBYkFBaUFEc0EKQ2dCc0FHOEFZd0JoQUd3 QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCTkFFa0FUUUJGQUNBQWRBQjVBSEFB WlFBaQpBRjBBSUFBOUFDQUFJZ0JOQUVrQVRRQkZBQ0FBZEFCNUFIQUFaUUFpQURzQUNnQnNBRzhB WXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBCmNnQnBBRzRBWndCekFGc0FJZ0JOQUdVQWRBQnlBR2tB WXdCekFDSUFYUUFnQUQwQUlBQWlBRTBBWlFCMEFISUFhUUJqQUhNQUlnQTcKQUFvQWJBQnZBR01B WVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVRnQmhBRzBBWlFBaUFGMEFJ QUE5QUNBQQpJZ0JPQUdFQWJRQmxBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFk QUJ5QUdrQWJnQm5BSE1BV3dBaUFFNEFaUUIzCkFDQUFVd0IwQUhrQWJBQmxBQ0FBVWdCMUFHd0Fa UUFpQUYwQUlBQTlBQ0FBSWdCT0FHVUFkd0FnQUZNQWRBQjVBR3dBWlFBZ0FGSUEKZFFCc0FHVUFJ Z0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVRn QnZBQ0FBUWdCeQpBR1VBWVFCckFIQUFid0JwQUc0QWRBQnpBQ0lBWFFBZ0FEMEFJQUFpQUU0QWJ3 QWdBRUlBY2dCbEFHRUFhd0J3QUc4QWFRQnVBSFFBCmN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFR QjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCT0FHOEFJQUJRQUhJQWJ3QncKQUdVQWNn QjBBR2tBWlFCekFDSUFYUUFnQUQwQUlBQWlBRTRBYndBZ0FGQUFjZ0J2QUhBQVpRQnlBSFFBYVFC bEFITUFJZ0E3QUFvQQpiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dC YkFDSUFUZ0J2QUNBQVZnQmhBSElBYVFCaEFHSUFiQUJsCkFITUFJZ0JkQUNBQVBRQWdBQ0lBVGdC dkFDQUFWZ0JoQUhJQWFRQmhBR0lBYkFCbEFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0EKZWdC bEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFUZ0J2QUhRQUlBQkdBRzhBZFFCdUFHUUFJZ0Jk QUNBQVBRQWdBQ0lBVGdCdgpBSFFBSUFCR0FHOEFkUUJ1QUdRQUlnQTdBQW9BYkFCdkFHTUFZUUJz QUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBClRnQnZBSFFBSUFCUUFHRUFkUUJ6 QUdVQVpBQWlBRjBBSUFBOUFDQUFJZ0JPQUc4QWRBQWdBRkFBWVFCMUFITUFaUUJrQUNJQU93QUsK QUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUU4QWJnQnNB SGtBSUFCbEFHNEFZUUJpQUd3QQpaUUFnQUdZQWJ3QnlBQ0FBZEFCb0FHa0Fjd0FnQUhNQVpRQnpB SE1BYVFCdkFHNEFJZ0JkQUNBQVBRQWdBQ0lBVHdCdUFHd0FlUUFnCkFHVUFiZ0JoQUdJQWJBQmxB Q0FBWmdCdkFISUFJQUIwQUdnQWFRQnpBQ0FBY3dCbEFITUFjd0JwQUc4QWJnQWlBRHNBQ2dCc0FH OEEKWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlBBSFFBYUFCbEFI SUFJZ0JkQUNBQVBRQWdBQ0lBVHdCMApBR2dBWlFCeUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFI b0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZBQVlRQjBBR2dBCklnQmRBQ0FBUFFBZ0FD SUFVQUJoQUhRQWFBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0 QVp3QnoKQUZzQUlnQlFBR0VBZFFCekFHVUFJQUJ2QUc0QUlBQmxBSGdBWXdCbEFIQUFkQUJwQUc4 QWJnQnpBQzRBSWdCZEFDQUFQUUFnQUNJQQpVQUJoQUhVQWN3QmxBQ0FBYndCdUFDQUFaUUI0QUdN QVpRQndBSFFBYVFCdkFHNEFjd0F1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwCkFIb0FaUUJrQUZN QWRBQnlBR2tBYmdCbkFITUFXd0FpQUZBQVlRQjFBSE1BWlFBZ0FITUFZd0J5QUdrQWNBQjBBQ0FB WlFCNEFHVUEKWXdCMUFIUUFhUUJ2QUc0QUxnQWlBRjBBSUFBOUFDQUFJZ0JRQUdFQWRRQnpBR1VB SUFCekFHTUFjZ0JwQUhBQWRBQWdBR1VBZUFCbApBR01BZFFCMEFHa0Fid0J1QUM0QUlnQTdBQW9B YkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBClVBQmhBSFVB Y3dCbEFHUUFJZ0JkQUNBQVBRQWdBQ0lBVUFCaEFIVUFjd0JsQUdRQUlnQTdBQW9BYkFCdkFHTUFZ UUJzQUdrQWVnQmwKQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVVBQmhBSFVBY3dCcEFHNEFa d0FpQUYwQUlBQTlBQ0FBSWdCUUFHRUFkUUJ6QUdrQQpiZ0JuQUNJQU93QUtBR3dBYndCakFHRUFi QUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRkFBY2dCdkFHWUFhUUJzCkFHVUFJ QUFsQUdRQUlnQmRBQ0FBUFFBZ0FDSUFVQUJ5QUc4QVpnQnBBR3dBWlFBZ0FDVUFaQUFpQURzQUNn QnNBRzhBWXdCaEFHd0EKYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JRQUhJQWJ3 Qm1BR2tBYkFCbEFITUFJZ0JkQUNBQVBRQWdBQ0lBVUFCeQpBRzhBWmdCcEFHd0FaUUJ6QUNJQU93 QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRkFBCmNn QnZBR1lBYVFCc0FHa0FiZ0JuQUNBQVpBQnBBSE1BWVFCaUFHd0FaUUJrQUM0QUlBQkRBR3dBYVFC akFHc0FJQUIwQUc4QUlBQmwKQUc0QVlRQmlBR3dBWlFBdUFDSUFYUUFnQUQwQUlBQWlBRkFBY2dC dkFHWUFhUUJzQUdrQWJnQm5BQ0FBWkFCcEFITUFZUUJpQUd3QQpaUUJrQUM0QUlBQkRBR3dBYVFC akFHc0FJQUIwQUc4QUlBQmxBRzRBWVFCaUFHd0FaUUF1QUNJQU93QUtBR3dBYndCakFHRUFiQUJw CkFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZBQWNnQnZBR1lBYVFCc0FHa0FiZ0Ju QUNBQVpRQnVBR0VBWWdCc0FHVUEKWkFBdUFDQUFRd0JzQUdrQVl3QnJBQ0FBZEFCdkFDQUFaQUJw QUhNQVlRQmlBR3dBWlFBdUFDSUFYUUFnQUQwQUlBQWlBRkFBY2dCdgpBR1lBYVFCc0FHa0FiZ0Ju QUNBQVpRQnVBR0VBWWdCc0FHVUFaQUF1QUNBQVF3QnNBR2tBWXdCckFDQUFkQUJ2QUNBQVpBQnBB SE1BCllRQmlBR3dBWlFBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlB R2tBYmdCbkFITUFXd0FpQUZBQWNnQnYKQUhBQVpRQnlBSFFBYVFCbEFITUFJZ0JkQUNBQVBRQWdB Q0lBVUFCeUFHOEFjQUJsQUhJQWRBQnBBR1VBY3dBaUFEc0FDZ0JzQUc4QQpZd0JoQUd3QWFRQjZB R1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCUUFISUFid0IwQUc4QWRBQjVBSEFBWlFBaUFG MEFJQUE5CkFDQUFJZ0JRQUhJQWJ3QjBBRzhBZEFCNUFIQUFaUUFpQURzQUNnQnNBRzhBWXdCaEFH d0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEEKWndCekFGc0FJZ0JSQUhVQVpRQnlBSGtBSWdCZEFD QUFQUUFnQUNJQVVRQjFBR1VBY2dCNUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcApBSG9BWlFCa0FG TUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGRUFkUUJsQUhJQWVRQWdBRk1BZEFCeUFHa0FiZ0JuQUNB QVVBQmhBSElBCllRQnRBR1VBZEFCbEFISUFjd0FpQUYwQUlBQTlBQ0FBSWdCUkFIVUFaUUJ5QUhr QUlBQlRBSFFBY2dCcEFHNEFad0FnQUZBQVlRQnkKQUdFQWJRQmxBSFFBWlFCeUFITUFJZ0E3QUFv QWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQQpVZ0JGQUZN QVR3QlZBRklBUXdCRkFGTUFJZ0JkQUNBQVBRQWdBQ0lBVWdCRkFGTUFUd0JWQUZJQVF3QkZBRk1B SWdBN0FBb0FiQUJ2CkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lB VWdCbEFHWUFjZ0JsQUhNQWFBQWlBRjBBSUFBOUFDQUEKSWdCU0FHVUFaZ0J5QUdVQWN3Qm9BQ0lB T3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaQpBRklB WlFCeEFIVUFaUUJ6QUhRQUlBQklBR1VBWVFCa0FHVUFjZ0J6QUNJQVhRQWdBRDBBSUFBaUFGSUFa UUJ4QUhVQVpRQnpBSFFBCklBQklBR1VBWVFCa0FHVUFjZ0J6QUNJQU93QUtBR3dBYndCakFHRUFi QUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWkKQUZJQVpRQnhBSFVBWlFCekFIUUFJ QUJRQUdFQWVRQnNBRzhBWVFCa0FDSUFYUUFnQUQwQUlBQWlBRklBWlFCeEFIVUFaUUJ6QUhRQQpJ QUJRQUdFQWVRQnNBRzhBWVFCa0FDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRB QnlBR2tBYmdCbkFITUFXd0FpCkFGSUFaUUJ6QUc4QWRRQnlBR01BWlFBZ0FHa0FiZ0IwQUdVQWNn QndBSElBWlFCMEFHVUFaQUFnQUdFQWN3QWdBQ1VBY3dBZ0FHSUEKZFFCMEFDQUFkQUJ5QUdFQWJn QnpBR1lBWlFCeUFISUFaUUJrQUNBQWR3QnBBSFFBYUFBZ0FFMEFTUUJOQUVVQUlBQjBBSGtBY0FC bApBQ0FBSlFCekFDNEFJZ0JkQUNBQVBRQWdBQ0lBVWdCbEFITUFid0IxQUhJQVl3QmxBQ0FBYVFC dUFIUUFaUUJ5QUhBQWNnQmxBSFFBClpRQmtBQ0FBWVFCekFDQUFKUUF4QUNRQWN3QWdBR0lBZFFC MEFDQUFkQUJ5QUdFQWJnQnpBR1lBWlFCeUFISUFaUUJrQUNBQWR3QnAKQUhRQWFBQWdBRTBBU1FC TkFFVUFJQUIwQUhrQWNBQmxBQ0FBSlFBeUFDUUFjd0F1QUNJQU93QUtBR3dBYndCakFHRUFiQUJw QUhvQQpaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZJQVpRQnpBRzhBZFFCeUFHTUFaUUFn QUhRQWNnQmhBR01BYXdCcEFHNEFad0FnCkFHUUFhUUJ6QUdFQVlnQnNBR1VBWkFBdUFDQUFRd0Jz QUdrQVl3QnJBQ0FBZEFCdkFDQUFaUUJ1QUdFQVlnQnNBR1VBTGdBaUFGMEEKSUFBOUFDQUFJZ0JT QUdVQWN3QnZBSFVBY2dCakFHVUFJQUIwQUhJQVlRQmpBR3NBYVFCdUFHY0FJQUJrQUdrQWN3QmhB R0lBYkFCbApBR1FBTGdBZ0FFTUFiQUJwQUdNQWF3QWdBSFFBYndBZ0FHVUFiZ0JoQUdJQWJBQmxB QzRBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBCmVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJB Q0lBVWdCbEFITUFid0IxQUhJQVl3QmxBQ0FBZEFCeUFHRUFZd0JyQUdrQWJnQm4KQUNBQVpRQnVB R0VBWWdCc0FHVUFaQUF1QUNBQVF3QnNBR2tBWXdCckFDQUFkQUJ2QUNBQVpBQnBBSE1BWVFCaUFH d0FaUUF1QUNJQQpYUUFnQUQwQUlBQWlBRklBWlFCekFHOEFkUUJ5QUdNQVpRQWdBSFFBY2dCaEFH TUFhd0JwQUc0QVp3QWdBR1VBYmdCaEFHSUFiQUJsCkFHUUFMZ0FnQUVNQWJBQnBBR01BYXdBZ0FI UUFid0FnQUdRQWFRQnpBR0VBWWdCc0FHVUFMZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0EKYVFCNkFH VUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JTQUdVQWN3QnZBSFVBY2dCakFHVUFjd0FpQUYw QUlBQTlBQ0FBSWdCUwpBR1VBY3dCdkFIVUFjZ0JqQUdVQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3 QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBCklnQlNBR1VBY3dCd0FHOEFiZ0J6QUdV QUlBQklBR1VBWVFCa0FHVUFjZ0J6QUNJQVhRQWdBRDBBSUFBaUFGSUFaUUJ6QUhBQWJ3QnUKQUhN QVpRQWdBRWdBWlFCaEFHUUFaUUJ5QUhNQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FB VXdCMEFISUFhUUJ1QUdjQQpjd0JiQUNJQVVnQmxBSE1BZEFCdkFISUFaUUFnQUdFQWJBQnNBQ0FB WmdCMUFHNEFZd0IwQUdrQWJ3QnVBSE1BTGdBaUFGMEFJQUE5CkFDQUFJZ0JTQUdVQWN3QjBBRzhB Y2dCbEFDQUFZUUJzQUd3QUlBQm1BSFVBYmdCakFIUUFhUUJ2QUc0QWN3QXVBQ0lBT3dBS0FHd0EK YndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRklBZFFCdUFDQUFK UUJrQUNJQVhRQWdBRDBBSUFBaQpBRklBZFFCdUFDQUFKUUJrQUNJQU93QUtBR3dBYndCakFHRUFi QUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRk1BClJRQlRBRk1BU1FCUEFFNEFJ QUJUQUZRQVR3QlNBRUVBUndCRkFDSUFYUUFnQUQwQUlBQWlBRk1BUlFCVEFGTUFTUUJQQUU0QUlB QlQKQUZRQVR3QlNBRUVBUndCRkFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRB QnlBR2tBYmdCbkFITUFXd0FpQUZNQQpZd0J2QUhBQVpRQWdBRllBWVFCeUFHa0FZUUJpQUd3QVpR QnpBQ0lBWFFBZ0FEMEFJQUFpQUZNQVl3QnZBSEFBWlFBZ0FGWUFZUUJ5CkFHa0FZUUJpQUd3QVpR QnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dB aUFGTUEKWXdCeUFHa0FjQUIwQUhNQUlnQmRBQ0FBUFFBZ0FDSUFVd0JqQUhJQWFRQndBSFFBY3dB aUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNgpBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdC VEFHVUFZUUJ5QUdNQWFBQWdBQ1VBY3dBaUFGMEFJQUE5QUNBQUlnQlRBR1VBCllRQnlBR01BYUFB Z0FDVUFjd0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6 QUZzQUlnQlQKQUdVQVl3QjFBSElBWlFBaUFGMEFJQUE5QUNBQUlnQlRBR1VBWXdCMUFISUFaUUFp QURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQQpaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JU QUdVQWJBQmxBR01BZEFBZ0FHRUFiZ0FnQUdVQWJBQmxBRzBBWlFCdUFIUUFJQUJwCkFHNEFJQUIw QUdnQVpRQWdBSEFBWVFCbkFHVUFJQUIwQUc4QUlBQnBBRzRBY3dCd0FHVUFZd0IwQUNBQWFRQjBB QzRBSWdCZEFDQUEKUFFBZ0FDSUFVd0JsQUd3QVpRQmpBSFFBSUFCaEFHNEFJQUJsQUd3QVpRQnRB R1VBYmdCMEFDQUFhUUJ1QUNBQWRBQm9BR1VBSUFCdwpBR0VBWndCbEFDQUFkQUJ2QUNBQWFRQnVB SE1BY0FCbEFHTUFkQUFnQUdrQWRBQXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BClpRQmtB Rk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRk1BWlFCc0FHWUFJZ0JkQUNBQVBRQWdBQ0lBVXdCbEFH d0FaZ0FpQURzQUNnQnMKQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFG c0FJZ0JUQUdVQWN3QnpBR2tBYndCdUFDSUFYUUFnQUQwQQpJQUFpQUZNQVpRQnpBSE1BYVFCdkFH NEFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiCkFD SUFVd0JvQUc4QWR3QWdBR0VBWWdCekFHOEFiQUIxQUhRQVpRQWdBSFFBYndCMEFHRUFiQUFnQUdF QWJnQmtBQ0FBY3dCbEFHd0EKWmdBZ0FIUUFhUUJ0QUdVQWN3QXVBQ0lBWFFBZ0FEMEFJQUFpQUZN QWFBQnZBSGNBSUFCaEFHSUFjd0J2QUd3QWRRQjBBR1VBSUFCMApBRzhBZEFCaEFHd0FJQUJoQUc0 QVpBQWdBSE1BWlFCc0FHWUFJQUIwQUdrQWJRQmxBSE1BTGdBaUFEc0FDZ0JzQUc4QVl3QmhBR3dB CmFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFHZ0Fid0IzQUNBQVl3Qm9BR0VB YmdCbkFHVUFjd0FnQUhZQWFRQmwKQUhjQUxnQWlBRjBBSUFBOUFDQUFJZ0JUQUdnQWJ3QjNBQ0FB WXdCb0FHRUFiZ0JuQUdVQWN3QWdBSFlBYVFCbEFIY0FMZ0FpQURzQQpDZ0JzQUc4QVl3QmhBR3dB YVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JUQUdnQWJ3QjNBQ0FBWXdCdkFHNEFj d0J2CkFHd0FaUUF1QUNJQVhRQWdBRDBBSUFBaUFGTUFhQUJ2QUhjQUlBQmpBRzhBYmdCekFHOEFi QUJsQUM0QUlnQTdBQW9BYkFCdkFHTUEKWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fj d0JiQUNJQVV3Qm9BRzhBZHdBZ0FHa0FiZ0JvQUdVQWNnQnBBSFFBWlFCawpBQ0lBWFFBZ0FEMEFJ QUFpQUZNQWFBQnZBSGNBSUFCcEFHNEFhQUJsQUhJQWFRQjBBR1VBWkFBaUFEc0FDZ0JzQUc4QVl3 QmhBR3dBCmFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFHZ0Fid0IzQUNBQWRB Qm9BR1VBSUFCdUFHVUFlQUIwQUNBQWN3QmoKQUhJQWFRQndBSFFBSUFCeUFHVUFjd0J2QUhVQWNn QmpBR1VBTGdBaUFGMEFJQUE5QUNBQUlnQlRBR2dBYndCM0FDQUFkQUJvQUdVQQpJQUJ1QUdVQWVB QjBBQ0FBY3dCakFISUFhUUJ3QUhRQUlBQnlBR1VBY3dCdkFIVUFjZ0JqQUdVQUxnQWlBRHNBQ2dC c0FHOEFZd0JoCkFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBR2dBYndC M0FDQUFkQUJvQUdVQUlBQndBSElBWlFCMkFHa0EKYndCMUFITUFJQUJ6QUdNQWNnQnBBSEFBZEFB Z0FISUFaUUJ6QUc4QWRRQnlBR01BWlFBdUFDSUFYUUFnQUQwQUlBQWlBRk1BYUFCdgpBSGNBSUFC MEFHZ0FaUUFnQUhBQWNnQmxBSFlBYVFCdkFIVUFjd0FnQUhNQVl3QnlBR2tBY0FCMEFDQUFjZ0Js QUhNQWJ3QjFBSElBCll3QmxBQzRBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0Iw QUhJQWFRQnVBR2NBY3dCYkFDSUFVd0JvQUc4QWR3QWcKQUhRQWJ3QjBBR0VBYkFBZ0FHRUFiZ0Jr QUNBQWN3QmxBR3dBWmdBZ0FIUUFhUUJ0QUdVQWN3QWdBR0VBY3dBZ0FIQUFaUUJ5QUdNQQpaUUJ1 QUhRQVlRQm5BR1VBY3dBdUFDSUFYUUFnQUQwQUlBQWlBRk1BYUFCdkFIY0FJQUIwQUc4QWRBQmhB R3dBSUFCaEFHNEFaQUFnCkFITUFaUUJzQUdZQUlBQjBBR2tBYlFCbEFITUFJQUJoQUhNQUlBQndB R1VBY2dCakFHVUFiZ0IwQUdFQVp3QmxBSE1BTGdBaUFEc0EKQ2dCc0FHOEFZd0JoQUd3QWFRQjZB R1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFHa0FlZ0JsQUNJQVhRQWdBRDBBSUFBaQpB Rk1BYVFCNkFHVUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFH Y0Fjd0JiQUNJQVV3QnZBSElBCmRBQWdBR0lBZVFBZ0FFUUFkUUJ5QUdFQWRBQnBBRzhBYmdBaUFG MEFJQUE5QUNBQUlnQlRBRzhBY2dCMEFDQUFZZ0I1QUNBQVJBQjEKQUhJQVlRQjBBR2tBYndCdUFD SUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZN QQpid0J5QUhRQUlBQmlBSGtBSUFCRkFHNEFaQUFnQUZRQWFRQnRBR1VBSWdCZEFDQUFQUUFnQUNJ QVV3QnZBSElBZEFBZ0FHSUFlUUFnCkFFVUFiZ0JrQUNBQVZBQnBBRzBBWlFBaUFEc0FDZ0JzQUc4 QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0EKSWdCVEFHOEFjZ0IwQUNB QVlnQjVBQ0FBVEFCaEFIUUFaUUJ1QUdNQWVRQWlBRjBBSUFBOUFDQUFJZ0JUQUc4QWNnQjBBQ0FB WWdCNQpBQ0FBVEFCaEFIUUFaUUJ1QUdNQWVRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VB WkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBCklnQlRBRzhBY2dCMEFDQUFZZ0I1QUNBQVVnQmxBSE1B Y0FCdkFHNEFjd0JsQUNBQVZBQnBBRzBBWlFBaUFGMEFJQUE5QUNBQUlnQlQKQUc4QWNnQjBBQ0FB WWdCNUFDQUFVZ0JsQUhNQWNBQnZBRzRBY3dCbEFDQUFWQUJwQUcwQVpRQWlBRHNBQ2dCc0FHOEFZ d0JoQUd3QQphUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBRzhBY2dCMEFDQUFZ Z0I1QUNBQVV3QnBBSG9BWlFBaUFGMEFJQUE5CkFDQUFJZ0JUQUc4QWNnQjBBQ0FBWWdCNUFDQUFV d0JwQUhvQVpRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUEKY2dCcEFHNEFa d0J6QUZzQUlnQlRBRzhBY2dCMEFDQUFZZ0I1QUNBQVV3QjBBR0VBY2dCMEFDQUFWQUJwQUcwQVpR QWlBRjBBSUFBOQpBQ0FBSWdCVEFHOEFjZ0IwQUNBQVlnQjVBQ0FBVXdCMEFHRUFjZ0IwQUNBQVZB QnBBRzBBWlFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBCmFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3 QnpBRnNBSWdCVEFHOEFkUUJ5QUdNQVpRQWlBRjBBSUFBOUFDQUFJZ0JUQUc4QWRRQnkKQUdNQVpR QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdC VEFIUUFZUUJ5QUhRQQpJQUJ3QUhJQWJ3Qm1BR2tBYkFCcEFHNEFad0F1QUNJQVhRQWdBRDBBSUFB aUFGTUFkQUJoQUhJQWRBQWdBSEFBY2dCdkFHWUFhUUJzCkFHa0FiZ0JuQUM0QUlnQTdBQW9BYkFC dkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVXdCMEFHVUEKY0FB Z0FHa0FiZ0IwQUc4QUlBQnVBR1VBZUFCMEFDQUFaZ0IxQUc0QVl3QjBBR2tBYndCdUFDQUFZd0Jo QUd3QWJBQXVBQ0lBWFFBZwpBRDBBSUFBaUFGTUFkQUJsQUhBQUlBQnBBRzRBZEFCdkFDQUFiZ0Js QUhnQWRBQWdBR1lBZFFCdUFHTUFkQUJwQUc4QWJnQWdBR01BCllRQnNBR3dBTGdBaUFEc0FDZ0Jz QUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JUQUhRQVpRQncK QUNBQWJ3QjFBSFFBSUFCdkFHWUFJQUJqQUhVQWNnQnlBR1VBYmdCMEFDQUFaZ0IxQUc0QVl3QjBB R2tBYndCdUFDNEFJZ0JkQUNBQQpQUUFnQUNJQVV3QjBBR1VBY0FBZ0FHOEFkUUIwQUNBQWJ3Qm1B Q0FBWXdCMUFISUFjZ0JsQUc0QWRBQWdBR1lBZFFCdUFHTUFkQUJwCkFHOEFiZ0F1QUNJQU93QUtB R3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRk1BZEFCbEFI QUEKSUFCdkFIWUFaUUJ5QUNBQWJnQmxBSGdBZEFBZ0FHWUFkUUJ1QUdNQWRBQnBBRzhBYmdBZ0FH TUFZUUJzQUd3QUxnQWlBRjBBSUFBOQpBQ0FBSWdCVEFIUUFaUUJ3QUNBQWJ3QjJBR1VBY2dBZ0FH NEFaUUI0QUhRQUlBQm1BSFVBYmdCakFIUUFhUUJ2QUc0QUlBQmpBR0VBCmJBQnNBQzRBSWdBN0FB b0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVd0IwQUdV QWNBQncKQUdrQWJnQm5BQ0lBWFFBZ0FEMEFJQUFpQUZNQWRBQmxBSEFBY0FCcEFHNEFad0FpQURz QUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQQpaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JUQUhR QWJ3QndBQ0FBY0FCeUFHOEFaZ0JwQUd3QWFRQnVBR2NBTGdBaUFGMEFJQUE5CkFDQUFJZ0JUQUhR QWJ3QndBQ0FBY0FCeUFHOEFaZ0JwQUd3QWFRQnVBR2NBTGdBaUFEc0FDZ0JzQUc4QVl3QmhBR3dB YVFCNkFHVUEKWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFIUUFid0J5QUdFQVp3QmxBQ0lB WFFBZ0FEMEFJQUFpQUZNQWRBQnZBSElBWVFCbgpBR1VBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tB ZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVd0IwQUhrQWJBQmxBQ0FBClFRQjBBSFFB Y2dCcEFHSUFkUUIwQUdVQUlnQmRBQ0FBUFFBZ0FDSUFVd0IwQUhrQWJBQmxBQ0FBUVFCMEFIUUFj Z0JwQUdJQWRRQjAKQUdVQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFh UUJ1QUdjQWN3QmJBQ0lBVXdCMEFIa0FiQUJsQUhNQQpJZ0JkQUNBQVBRQWdBQ0lBVXdCMEFIa0Fi QUJsQUhNQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1CkFHY0Fj d0JiQUNJQVV3QjBBSGtBYkFCbEFITUFhQUJsQUdVQWRBQnpBQ0lBWFFBZ0FEMEFJQUFpQUZNQWRB QjVBR3dBWlFCekFHZ0EKWlFCbEFIUUFjd0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpB QlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlVBR2dBWlFBZwpBQndnSlFCekFCMGdYQUJ1QUhRQVlR QmlBR3dBWlFBZ0FHa0Fjd0FnQUdVQWJRQndBSFFBZVFBdUFDSUFYUUFnQUQwQUlBQWlBRlFBCmFB QmxBQ0FBSENBbEFITUFIU0JjQUc0QWRBQmhBR0lBYkFCbEFDQUFhUUJ6QUNBQVpRQnRBSEFBZEFC NUFDNEFJZ0E3QUFvQWJBQnYKQUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dC YkFDSUFWQUJvQUdrQWN3QWdBSE1BYVFCMEFHVUFJQUJvQUdFQQpjd0FnQUc0QWJ3QWdBR01BYndC dkFHc0FhUUJsQUhNQUxnQWlBRjBBSUFBOUFDQUFJZ0JVQUdnQWFRQnpBQ0FBY3dCcEFIUUFaUUFn CkFHZ0FZUUJ6QUNBQWJnQnZBQ0FBWXdCdkFHOEFhd0JwQUdVQWN3QXVBQ0lBT3dBS0FHd0Fid0Jq QUdFQWJBQnBBSG9BWlFCa0FGTUEKZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRlFBYUFCcEFITUFJQUJ6 QUhRQWJ3QnlBR0VBWndCbEFDQUFhUUJ6QUNBQVpRQnRBSEFBZEFCNQpBQzRBSWdCZEFDQUFQUUFn QUNJQVZBQm9BR2tBY3dBZ0FITUFkQUJ2QUhJQVlRQm5BR1VBSUFCcEFITUFJQUJsQUcwQWNBQjBB SGtBCkxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpB RnNBSWdCVUFHa0FiUUJsQUNJQVhRQWcKQUQwQUlBQWlBRlFBYVFCdEFHVUFJZ0E3QUFvQWJBQnZB R01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQQpWQUJ2QUhRQVlRQnNB Q0lBWFFBZ0FEMEFJQUFpQUZRQWJ3QjBBR0VBYkFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFH VUFaQUJUCkFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVUFISUFaUUJsQUNBQUtBQlVBRzhBY0FBZ0FF UUFid0IzQUc0QUtRQWlBRjBBSUFBOUFDQUEKSWdCVUFISUFaUUJsQUNBQUtBQlVBRzhBY0FBZ0FF UUFid0IzQUc0QUtRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVApBSFFBY2dCcEFH NEFad0J6QUZzQUlnQlZBRzRBWkFCdkFHTUFhd0FnQUdrQWJnQjBBRzhBSUFCekFHVUFjQUJoQUhJ QVlRQjBBR1VBCklBQjNBR2tBYmdCa0FHOEFkd0F1QUNJQVhRQWdBRDBBSUFBaUFGVUFiZ0JrQUc4 QVl3QnJBQ0FBYVFCdUFIUUFid0FnQUhNQVpRQncKQUdFQWNnQmhBSFFBWlFBZ0FIY0FhUUJ1QUdR QWJ3QjNBQzRBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQQphUUJ1QUdj QWN3QmJBQ0lBVlFCekFHVUFJQUJzQUdFQWNnQm5BR1VBSUFCeUFHVUFjd0J2QUhVQWNnQmpBR1VB SUFCeUFHOEFkd0J6CkFDNEFJZ0JkQUNBQVBRQWdBQ0lBVlFCekFHVUFJQUJzQUdFQWNnQm5BR1VB SUFCeUFHVUFjd0J2QUhVQWNnQmpBR1VBSUFCeUFHOEEKZHdCekFDNEFJZ0E3QUFvQWJBQnZBR01B WVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVZRQnpBR1VBSUFCegpBRzBB WVFCc0FHd0FJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFJQUJ5QUc4QWR3QnpBQzRBSWdCZEFDQUFQ UUFnQUNJQVZRQnpBR1VBCklBQnpBRzBBWVFCc0FHd0FJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFJ QUJ5QUc4QWR3QnpBQzRBSWdBN0FBb0FiQUJ2QUdNQVlRQnMKQUdrQWVnQmxBR1FBVXdCMEFISUFh UUJ1QUdjQWN3QmJBQ0lBVmdCaEFHd0FkUUJsQUNJQVhRQWdBRDBBSUFBaUFGWUFZUUJzQUhVQQpa UUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUln QlhBR2tBZEFCb0FDQUFRZ0JzCkFHOEFZd0JyQUNJQVhRQWdBRDBBSUFBaUFGY0FhUUIwQUdnQUlB QkNBR3dBYndCakFHc0FJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0EKZWdCbEFHUUFVd0IwQUhJQWFR QnVBR2NBY3dCYkFDSUFXQUJJQUZJQUlnQmRBQ0FBUFFBZ0FDSUFXQUJJQUZJQUlnQTdBQW9BYkFC dgpBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVdRQnZBSFVBSUFC akFHOEFkUUJzQUdRQUlBQnpBR0VBCmRnQmxBQ0FBWWdCaEFHNEFaQUIzQUdrQVpBQjBBR2dBSUFC aUFIa0FJQUJvQUdFQWRnQnBBRzRBWndBZ0FIa0Fid0IxQUhJQUlBQjMKQUdVQVlnQWdBSE1BWlFC eUFIWUFaUUJ5QUNBQVl3QnZBRzBBY0FCeUFHVUFjd0J6QUNBQWRBQm9BR2tBY3dBZ0FIUUFjZ0Jo QUc0QQpjd0JtQUdVQWNnQWdBSGNBYVFCMEFHZ0FJQUJuQUhvQWFRQndBQ0FBYndCeUFDQUFlZ0Jz QUdrQVlnQXVBQ0lBWFFBZ0FEMEFJQUFpCkFGa0Fid0IxQUNBQVl3QnZBSFVBYkFCa0FDQUFjd0Jo QUhZQVpRQWdBR0lBWVFCdUFHUUFkd0JwQUdRQWRBQm9BQ0FBWWdCNUFDQUEKYUFCaEFIWUFhUUJ1 QUdjQUlBQjVBRzhBZFFCeUFDQUFkd0JsQUdJQUlBQnpBR1VBY2dCMkFHVUFjZ0FnQUdNQWJ3QnRB SEFBY2dCbApBSE1BY3dBZ0FIUUFhQUJwQUhNQUlBQjBBSElBWVFCdUFITUFaZ0JsQUhJQUlBQjNB R2tBZEFCb0FDQUFad0I2QUdrQWNBQWdBRzhBCmNnQWdBSG9BYkFCcEFHSUFMZ0FpQURzQUNnQnNB RzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQloKQUc4QWRRQWdB RzRBWlFCbEFHUUFJQUIwQUc4QUlBQmxBRzRBWVFCaUFHd0FaUUFnQUdRQVpRQmlBSFVBWndCbkFH a0FiZ0JuQUNBQQpZZ0JsQUdZQWJ3QnlBR1VBSUFCNUFHOEFkUUFnQUdNQVlRQnVBQ0FBZFFCekFH VUFJQUIwQUdnQVpRQWdBRk1BWXdCeUFHa0FjQUIwCkFITUFJQUJ3QUdFQWJnQmxBR3dBTGdBaUFG MEFJQUE5QUNBQUlnQlpBRzhBZFFBZ0FHNEFaUUJsQUdRQUlBQjBBRzhBSUFCbEFHNEEKWVFCaUFH d0FaUUFnQUdRQVpRQmlBSFVBWndCbkFHa0FiZ0JuQUNBQVlnQmxBR1lBYndCeUFHVUFJQUI1QUc4 QWRRQWdBR01BWVFCdQpBQ0FBZFFCekFHVUFJQUIwQUdnQVpRQWdBRk1BWXdCeUFHa0FjQUIwQUhN QUlBQndBR0VBYmdCbEFHd0FMZ0FpQURzQUNnQnNBRzhBCll3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JaQUc4QWRRQWdBRzRBWlFCbEFHUUFJQUIwQUc4QUlBQmwKQUc0 QVlRQmlBR3dBWlFBZ0FIQUFjZ0J2QUdZQWFRQnNBR2tBYmdCbkFDQUFZZ0JsQUdZQWJ3QnlBR1VB SUFCNUFHOEFkUUFnQUdNQQpZUUJ1QUNBQWRRQnpBR1VBSUFCMEFHZ0FaUUFnQUZBQWNnQnZBR1lB YVFCc0FHVUFjd0FnQUhBQVlRQnVBR1VBYkFBdUFDSUFYUUFnCkFEMEFJQUFpQUZrQWJ3QjFBQ0FB YmdCbEFHVUFaQUFnQUhRQWJ3QWdBR1VBYmdCaEFHSUFiQUJsQUNBQWNBQnlBRzhBWmdCcEFHd0EK YVFCdUFHY0FJQUJpQUdVQVpnQnZBSElBWlFBZ0FIa0Fid0IxQUNBQVl3QmhBRzRBSUFCMUFITUFa UUFnQUhRQWFBQmxBQ0FBVUFCeQpBRzhBWmdCcEFHd0FaUUJ6QUNBQWNBQmhBRzRBWlFCc0FDNEFJ Z0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBCmFRQnVBR2NBY3dCYkFDSUFX UUJ2QUhVQUlBQnVBR1VBWlFCa0FDQUFkQUJ2QUNBQVpRQnVBR0VBWWdCc0FHVUFJQUJ5QUdVQWN3 QnYKQUhVQWNnQmpBR1VBSUFCMEFISUFZUUJqQUdzQWFRQnVBR2NBSUFCMEFHOEFJQUIxQUhNQVpR QWdBSFFBYUFCcEFITUFJQUJ3QUdFQQpiZ0JsQUd3QUxnQWlBRjBBSUFBOUFDQUFJZ0JaQUc4QWRR QWdBRzRBWlFCbEFHUUFJQUIwQUc4QUlBQmxBRzRBWVFCaUFHd0FaUUFnCkFISUFaUUJ6QUc4QWRR QnlBR01BWlFBZ0FIUUFjZ0JoQUdNQWF3QnBBRzRBWndBZ0FIUUFid0FnQUhVQWN3QmxBQ0FBZEFC b0FHa0EKY3dBZ0FIQUFZUUJ1QUdVQWJBQXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFC a0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaQpBR0lBYndCeUFHUUFaUUJ5QUNJQVhRQWdBRDBBSUFB aUFHSUFid0J5QUdRQVpRQnlBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BClpRQmtBRk1BZEFC eUFHa0FiZ0JuQUhNQVd3QWlBR01BYndCdUFIUUFaUUJ1QUhRQUlnQmRBQ0FBUFFBZ0FDSUFZd0J2 QUc0QWRBQmwKQUc0QWRBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0Jw QUc0QVp3QnpBRnNBSWdCa0FHOEFZd0IxQUcwQQpaUUJ1QUhRQUlnQmRBQ0FBUFFBZ0FDSUFaQUJ2 QUdNQWRRQnRBR1VBYmdCMEFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrCkFGTUFkQUJ5 QUdrQWJnQm5BSE1BV3dBaUFHVUFiQUJsQUcwQVpRQnVBSFFBR1NCekFDQUFIQ0FsQUhNQUhTQWdB R0VBZEFCMEFISUEKYVFCaUFIVUFkQUJsQUNJQVhRQWdBRDBBSUFBaUFHVUFiQUJsQUcwQVpRQnVB SFFBR1NCekFDQUFIQ0FsQUhNQUhTQWdBR0VBZEFCMApBSElBYVFCaUFIVUFkQUJsQUNJQU93QUtB R3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBR1lBCmJ3QnVB SFFBSWdCZEFDQUFQUUFnQUNJQVpnQnZBRzRBZEFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFH VUFaQUJUQUhRQWNnQnAKQUc0QVp3QnpBRnNBSWdCcEFHMEFZUUJuQUdVQUlnQmRBQ0FBUFFBZ0FD SUFhUUJ0QUdFQVp3QmxBQ0lBT3dBS0FHd0Fid0JqQUdFQQpiQUJwQUhvQVpRQmtBRk1BZEFCeUFH a0FiZ0JuQUhNQVd3QWlBR2tBYmdCc0FHa0FiZ0JsQUNBQWN3QjBBSGtBYkFCbEFITUFhQUJsCkFH VUFkQUFpQUYwQUlBQTlBQ0FBSWdCcEFHNEFiQUJwQUc0QVpRQWdBSE1BZEFCNUFHd0FaUUJ6QUdn QVpRQmxBSFFBSWdBN0FBb0EKYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdj QWN3QmJBQ0lBYkFCcEFHNEFaUUFnQUNVQVpBQWlBRjBBSUFBOQpBQ0FBSWdCc0FHa0FiZ0JsQUNB QUpRQmtBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1B Cld3QWlBRzBBWVFCeUFHY0FhUUJ1QUNJQVhRQWdBRDBBSUFBaUFHMEFZUUJ5QUdjQWFRQnVBQ0lB T3dBS0FHd0Fid0JqQUdFQWJBQnAKQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRzhB ZEFCb0FHVUFjZ0FpQUYwQUlBQTlBQ0FBSWdCdkFIUUFhQUJsQUhJQQpJZ0E3QUFvQWJBQnZBR01B WVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQWNBQmhBR1FBWkFCcEFHNEFa d0FpCkFGMEFJQUE5QUNBQUlnQndBR0VBWkFCa0FHa0FiZ0JuQUNJQU93QUtBR3dBYndCakFHRUFi QUJwQUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFXd0FpQUhBQWJ3QnpBR2tBZEFCcEFHOEFi Z0FpQUYwQUlBQTlBQ0FBSWdCd0FHOEFjd0JwQUhRQWFRQnZBRzRBSWdBNwpBQW9BYkFCdkFHTUFZ UUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBY3dCakFISUFhUUJ3QUhRQUln QmRBQ0FBClBRQWdBQ0lBY3dCakFISUFhUUJ3QUhRQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVn QmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmIKQUNJQWN3QjBBSGtBYkFCbEFITUFhQUJsQUdVQWRB QWlBRjBBSUFBOUFDQUFJZ0J6QUhRQWVRQnNBR1VBY3dCb0FHVUFaUUIwQUNJQQpPd0FLQUd3QWJ3 QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUhVQWN3QmxBSElBSUFC aEFHY0FaUUJ1CkFIUUFJQUJ6QUhRQWVRQnNBR1VBY3dCb0FHVUFaUUIwQUNJQVhRQWdBRDBBSUFB aUFIVUFjd0JsQUhJQUlBQmhBR2NBWlFCdUFIUUEKSUFCekFIUUFlUUJzQUdVQWN3Qm9BR1VBWlFC MEFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbgpBSE1BV3dB aUFIVUFjd0JsQUhJQUlBQnpBSFFBZVFCc0FHVUFjd0JvQUdVQVpRQjBBQ0lBWFFBZ0FEMEFJQUFp QUhVQWN3QmxBSElBCklBQnpBSFFBZVFCc0FHVUFjd0JvQUdVQVpRQjBBQ0lBT3dBS0FHd0Fid0Jq QUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm4KQUhNQVd3QWlBSFlBYVFCaEFDQUFhUUJ1 QUhNQWNBQmxBR01BZEFCdkFISUFJZ0JkQUNBQVBRQWdBQ0lBZGdCcEFHRUFJQUJwQUc0QQpjd0J3 QUdVQVl3QjBBRzhBY2dBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBB RzRBWndCekFGc0FJZ0JECkFGQUFWUUFnQUZBQVVnQlBBRVlBU1FCTUFFVUFVd0FpQUYwQUlBQTlB Q0FBSWdCREFGQUFWUUFnQUZBQVVnQlBBRVlBU1FCTUFFVUEKVXdBaUFEc0FDZ0JzQUc4QVl3QmhB R3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JJQUVVQVFRQlFBQ0FBVXdCTwpB RUVBVUFCVEFFZ0FUd0JVQUZNQUlnQmRBQ0FBUFFBZ0FDSUFTQUJGQUVFQVVBQWdBRk1BVGdCQkFG QUFVd0JJQUU4QVZBQlRBQ0lBCk93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFH a0FiZ0JuQUhNQVd3QWlBRlFBWVFCckFHVUFJQUJvQUdVQVlRQncKQUNBQWN3QnVBR0VBY0FCekFH Z0Fid0IwQUM0QUlnQmRBQ0FBUFFBZ0FDSUFWQUJoQUdzQVpRQWdBR2dBWlFCaEFIQUFJQUJ6QUc0 QQpZUUJ3QUhNQWFBQnZBSFFBTGdBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JJCkFHVUFlQUFnQUVNQWJ3QnNBRzhBY2dCekFDSUFYUUFnQUQw QUlBQWlBRWdBWlFCNEFDQUFRd0J2QUd3QWJ3QnlBSE1BSWdBN0FBb0EKYkFCdkFHTUFZUUJzQUdr QWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVWdCSEFFSUFJQUJEQUc4QWJBQnZBSElB Y3dBaQpBRjBBSUFBOUFDQUFJZ0JTQUVjQVFnQWdBRU1BYndCc0FHOEFjZ0J6QUNJQU93QUtBR3dB YndCakFHRUFiQUJwQUhvQVpRQmtBRk1BCmRBQnlBR2tBYmdCbkFITUFXd0FpQUVnQVV3Qk1BQ0FB UXdCdkFHd0Fid0J5QUhNQUlnQmRBQ0FBUFFBZ0FDSUFTQUJUQUV3QUlBQkQKQUc4QWJBQnZBSElB Y3dBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJ Z0JEQUd3QQphUUJqQUdzQUlBQjBBRzhBSUFCakFHZ0FZUUJ1QUdjQVpRQWdBR01BYndCc0FHOEFj Z0FnQUdZQWJ3QnlBRzBBWVFCMEFDSUFYUUFnCkFEMEFJQUFpQUVNQWJBQnBBR01BYXdBZ0FIUUFi d0FnQUdNQWFBQmhBRzRBWndCbEFDQUFZd0J2QUd3QWJ3QnlBQ0FBWmdCdkFISUEKYlFCaEFIUUFJ Z0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVZ3 QmhBSFFBWXdCbwpBQ0FBUlFCNEFIQUFjZ0JsQUhNQWN3QnBBRzhBYmdCekFDSUFYUUFnQUQwQUlB QWlBRmNBWVFCMEFHTUFhQUFnQUVVQWVBQndBSElBClpRQnpBSE1BYVFCdkFHNEFjd0FpQURzQUNn QnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkIKQUdRQVpB QWlBRjBBSUFBOUFDQUFJZ0JCQUdRQVpBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFC VEFIUUFjZ0JwQUc0QQpad0J6QUZzQUlnQkVBR1VBYkFCbEFIUUFaUUFnQUhjQVlRQjBBR01BYUFB Z0FHVUFlQUJ3QUhJQVpRQnpBSE1BYVFCdkFHNEFMZ0FpCkFGMEFJQUE5QUNBQUlnQkVBR1VBYkFC bEFIUUFaUUFnQUhjQVlRQjBBR01BYUFBZ0FHVUFlQUJ3QUhJQVpRQnpBSE1BYVFCdkFHNEEKTGdB aUFEc0FDZ0FLQUE9PQoK 39648 2009-09-16 09:13:58 -0700 2009-09-16 12:32:10 -0700 proposed patch - 2009/09/16 27514.patch text/plain 63894 pmuellr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0ODQyMCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNTAgQEAKKzIwMDktMDktMTYgIFBhdHJpY2sgTXVlbGxlciAgPFBhdHJpY2tfTXVl bGxlckB1cy5pYm0uY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFkZCBXYXRjaCBFeHByZXNzaW9uIHN1cHBvcnQgdG8gaW5zcGVjdG9yCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzUxNAorCisgICAg ICAgIE1hbnVhbCB0ZXN0IGFkZGVkLgorCisgICAgICAgICogRW5nbGlzaC5scHJvai9sb2NhbGl6 ZWRTdHJpbmdzLmpzOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvQ29uc29sZVZpZXcu anM6CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ29uc29sZVZpZXcucHJvdG90eXBlLmNvbXBsZXRp b25zKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5Db25zb2xlVmlldy5wcm90b3R5cGUuZXZhbElu SW5zcGVjdGVkV2luZG93KToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5Db25zb2xlVmlldy5wcm90 b3R5cGUuX2VudGVyS2V5UHJlc3NlZCk6CisgICAgICAgICogaW5zcGVjdG9yL2Zyb250LWVuZC9P YmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5qczoKKyAgICAgICAgKFdlYkluc3BlY3Rvci5PYmplY3RQ cm9wZXJ0aWVzU2VjdGlvbi5Qcm9wZXJ0eUNvbXBhcmVyKToKKyAgICAgICAgKFdlYkluc3BlY3Rv ci5PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5wcm90b3R5cGUudXBkYXRlLmNhbGxiYWNrKToKKyAg ICAgICAgKFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5wcm90b3R5cGUudXBk YXRlKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5wcm90 b3R5cGUudXBkYXRlUHJvcGVydGllcyk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuT2JqZWN0UHJv cGVydHlUcmVlRWxlbWVudC5wcm90b3R5cGUub25wb3B1bGF0ZS5jYWxsYmFjayk6CisgICAgICAg IChXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydHlUcmVlRWxlbWVudC5wcm90b3R5cGUub25wb3B1 bGF0ZSk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydHlUcmVlRWxlbWVudC5w cm90b3R5cGUudXBkYXRlKToKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL1NjcmlwdHNQ YW5lbC5qczoKKyAgICAgICAgKFdlYkluc3BlY3Rvci5TY3JpcHRzUGFuZWwpOgorICAgICAgICAo V2ViSW5zcGVjdG9yLlNjcmlwdHNQYW5lbC5wcm90b3R5cGUucmVzZXQpOgorICAgICAgICAoV2Vi SW5zcGVjdG9yLlNjcmlwdHNQYW5lbC5wcm90b3R5cGUuX2NhbGxGcmFtZVNlbGVjdGVkKToKKyAg ICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL1dhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5q czogQWRkZWQuCisgICAgICAgIChXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NpZGViYXJQ YW5lKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUu cHJvdG90eXBlLnJlZnJlc2hFeHByZXNzaW9ucyk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuV2F0 Y2hFeHByZXNzaW9uc1NlY3Rpb24pOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVz c2lvbnNTZWN0aW9uLlByb3BlcnR5Q29tcGFyZXIpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldh dGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS51cGRhdGUpOgorICAgICAgICAoV2ViSW5z cGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS5hZGRFeHByZXNzaW9uKToK KyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5wcm90b3R5cGUu dXBkYXRlRXhwcmVzc2lvbik6CisgICAgICAgIChXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9u c1NlY3Rpb24ucHJvdG90eXBlLmZpbmRBZGRlZFRyZWVFbGVtZW50KToKKyAgICAgICAgKFdlYklu c3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5wcm90b3R5cGUubG9hZFNhdmVkRXhwcmVz c2lvbnMpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnBy b3RvdHlwZS5zYXZlRXhwcmVzc2lvbnMpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhw cmVzc2lvblRyZWVFbGVtZW50KToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Np b25UcmVlRWxlbWVudC5wcm90b3R5cGUudXBkYXRlKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5X YXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUuX2RlbGV0ZUJ1dHRvbkNsaWNrZWQp OgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvblRyZWVFbGVtZW50LnByb3Rv dHlwZS5zdGFydEVkaXRpbmcpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lv blRyZWVFbGVtZW50LnByb3RvdHlwZS5lZGl0aW5nQ2FuY2VsbGVkKToKKyAgICAgICAgKFdlYklu c3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUuYXBwbHlFeHByZXNz aW9uKToKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL2luc3BlY3Rvci5jc3M6CisgICAg ICAgICogaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuaHRtbDoKKyAgICAgICAgKiBtYW51 YWwtdGVzdHMvaW5zcGVjdG9yL2RlYnVnZ2VyLXdhdGNoLWV4cHJlc3Npb25zLmh0bWw6IEFkZGVk LgorCiAyMDA5LTA5LTE2ICBWaXRhbHkgUmVwZXNoa28gIDx2aXRhbHlyQGNocm9taXVtLm9yZz4K IAogICAgICAgICBSZXZpZXdlZCBieSBEaW1pdHJpIEdsYXprb3YuCkluZGV4OiBXZWJDb3JlL2lu c3BlY3Rvci9mcm9udC1lbmQvQ29uc29sZVZpZXcuanMKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9p bnNwZWN0b3IvZnJvbnQtZW5kL0NvbnNvbGVWaWV3LmpzCShyZXZpc2lvbiA0ODM5OCkKKysrIFdl YkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9Db25zb2xlVmlldy5qcwkod29ya2luZyBjb3B5KQpA QCAtMjk4LDcgKzI5OCw3IEBAIFdlYkluc3BlY3Rvci5Db25zb2xlVmlldy5wcm90b3R5cGUgPSB7 CiAgICAgICAgICAgICByZXBvcnRDb21wbGV0aW9ucyhyZXN1bHQsIGlzRXhjZXB0aW9uKTsKICAg ICAgICAgfQogCi0gICAgICAgIHRoaXMuX2V2YWxJbkluc3BlY3RlZFdpbmRvdygKKyAgICAgICAg dGhpcy5ldmFsSW5JbnNwZWN0ZWRXaW5kb3coCiAgICAgICAgICAgICAiKGZ1bmN0aW9uKCkgeyIg KwogICAgICAgICAgICAgICAgICJ2YXIgcHJvcHMgPSB7fTsiICsKICAgICAgICAgICAgICAgICAi Zm9yICh2YXIgcHJvcCBpbiAoIiArIGV4cHJlc3Npb25TdHJpbmcgKyAiKSkgcHJvcHNbcHJvcF0g PSB0cnVlOyIgKwpAQCAtMzk0LDcgKzM5NCw3IEBAIFdlYkluc3BlY3Rvci5Db25zb2xlVmlldy5w cm90b3R5cGUgPSB7CiAgICAgICAgIHRoaXMucHJvbXB0LmhhbmRsZUtleUV2ZW50KGV2ZW50KTsK ICAgICB9LAogCi0gICAgX2V2YWxJbkluc3BlY3RlZFdpbmRvdzogZnVuY3Rpb24oZXhwcmVzc2lv biwgY2FsbGJhY2spCisgICAgZXZhbEluSW5zcGVjdGVkV2luZG93OiBmdW5jdGlvbihleHByZXNz aW9uLCBjYWxsYmFjaykKICAgICB7CiAgICAgICAgIGlmIChXZWJJbnNwZWN0b3IucGFuZWxzLnNj cmlwdHMgJiYgV2ViSW5zcGVjdG9yLnBhbmVscy5zY3JpcHRzLnBhdXNlZCkgewogICAgICAgICAg ICAgV2ViSW5zcGVjdG9yLnBhbmVscy5zY3JpcHRzLmV2YWx1YXRlSW5TZWxlY3RlZENhbGxGcmFt ZShleHByZXNzaW9uLCBmYWxzZSwgY2FsbGJhY2spOwpAQCAtNDQyLDcgKzQ0Miw3IEBAIFdlYklu c3BlY3Rvci5Db25zb2xlVmlldy5wcm90b3R5cGUgPSB7CiAgICAgICAgICAgICBzZWxmLnByb21w dC50ZXh0ID0gIiI7CiAgICAgICAgICAgICBzZWxmLmFkZE1lc3NhZ2UobmV3IFdlYkluc3BlY3Rv ci5Db25zb2xlQ29tbWFuZFJlc3VsdChyZXN1bHQsIGV4Y2VwdGlvbiwgY29tbWFuZE1lc3NhZ2Up KTsKICAgICAgICAgfQotICAgICAgICB0aGlzLl9ldmFsSW5JbnNwZWN0ZWRXaW5kb3coc3RyLCBw cmludFJlc3VsdCk7CisgICAgICAgIHRoaXMuZXZhbEluSW5zcGVjdGVkV2luZG93KHN0ciwgcHJp bnRSZXN1bHQpOwogICAgIH0sCiAKICAgICBfZm9ybWF0OiBmdW5jdGlvbihvdXRwdXQsIGZvcmNl T2JqZWN0Rm9ybWF0KQpJbmRleDogV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL09iamVjdFBy b3BlcnRpZXNTZWN0aW9uLmpzCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250 LWVuZC9PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5qcwkocmV2aXNpb24gNDgzOTgpCisrKyBXZWJD b3JlL2luc3BlY3Rvci9mcm9udC1lbmQvT2JqZWN0UHJvcGVydGllc1NlY3Rpb24uanMJKHdvcmtp bmcgY29weSkKQEAgLTM2LDYgKzM2LDQ3IEBAIFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0aWVz U2VjdGlvbiA9IGYKICAgICBXZWJJbnNwZWN0b3IuUHJvcGVydGllc1NlY3Rpb24uY2FsbCh0aGlz LCB0aXRsZSwgc3VidGl0bGUpOwogfQogCitXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydGllc1Nl Y3Rpb24uUHJvcGVydHlDb21wYXJlciA9IGZ1bmN0aW9uKHByb3BlcnR5QSwgcHJvcGVydHlCKSAK K3sKKyAgICB2YXIgYSA9IHByb3BlcnR5QS5uYW1lOworICAgIHZhciBiID0gcHJvcGVydHlCLm5h bWU7CisKKyAgICAvLyBpZiB1c2VkIGVsc2V3aGVyZSBtYWtlIHN1cmUgdG8KKyAgICAvLyAgLSBj b252ZXJ0IGEgYW5kIGIgdG8gc3RyaW5ncyAobm90IG5lZWRlZCBoZXJlLCBwcm9wZXJ0aWVzIGFy ZSBhbGwgc3RyaW5ncykKKyAgICAvLyAgLSBjaGVjayBpZiBhID09IGIgKG5vdCBuZWVkZWQgaGVy ZSwgbm8gdHdvIHByb3BlcnRpZXMgY2FuIGJlIHRoZSBzYW1lKQorCisgICAgdmFyIGRpZmYgPSAw OworICAgIHZhciBjaHVuayA9IC9eXGQrfF5cRCsvOworICAgIHZhciBjaHVua2EsIGNodW5rYiwg YW51bSwgYm51bTsKKyAgICB3aGlsZSAoZGlmZiA9PT0gMCkgeworICAgICAgICBpZiAoIWEgJiYg YikKKyAgICAgICAgICAgIHJldHVybiAtMTsKKyAgICAgICAgaWYgKCFiICYmIGEpCisgICAgICAg ICAgICByZXR1cm4gMTsKKyAgICAgICAgY2h1bmthID0gYS5tYXRjaChjaHVuaylbMF07CisgICAg ICAgIGNodW5rYiA9IGIubWF0Y2goY2h1bmspWzBdOworICAgICAgICBhbnVtID0gIWlzTmFOKGNo dW5rYSk7CisgICAgICAgIGJudW0gPSAhaXNOYU4oY2h1bmtiKTsKKyAgICAgICAgaWYgKGFudW0g JiYgIWJudW0pCisgICAgICAgICAgICByZXR1cm4gLTE7CisgICAgICAgIGlmIChibnVtICYmICFh bnVtKQorICAgICAgICAgICAgcmV0dXJuIDE7CisgICAgICAgIGlmIChhbnVtICYmIGJudW0pIHsK KyAgICAgICAgICAgIGRpZmYgPSBjaHVua2EgLSBjaHVua2I7CisgICAgICAgICAgICBpZiAoZGlm ZiA9PT0gMCAmJiBjaHVua2EubGVuZ3RoICE9PSBjaHVua2IubGVuZ3RoKSB7CisgICAgICAgICAg ICAgICAgaWYgKCErY2h1bmthICYmICErY2h1bmtiKSAvLyBjaHVua3MgYXJlIHN0cmluZ3Mgb2Yg YWxsIDBzIChzcGVjaWFsIGNhc2UpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBjaHVua2Eu bGVuZ3RoIC0gY2h1bmtiLmxlbmd0aDsKKyAgICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAg ICAgICAgICAgIHJldHVybiBjaHVua2IubGVuZ3RoIC0gY2h1bmthLmxlbmd0aDsKKyAgICAgICAg ICAgIH0KKyAgICAgICAgfSBlbHNlIGlmIChjaHVua2EgIT09IGNodW5rYikKKyAgICAgICAgICAg IHJldHVybiAoY2h1bmthIDwgY2h1bmtiKSA/IC0xIDogMTsKKyAgICAgICAgYSA9IGEuc3Vic3Ry aW5nKGNodW5rYS5sZW5ndGgpOworICAgICAgICBiID0gYi5zdWJzdHJpbmcoY2h1bmtiLmxlbmd0 aCk7CisgICAgfQorICAgIHJldHVybiBkaWZmOworfTsKKyAgICAKIFdlYkluc3BlY3Rvci5PYmpl Y3RQcm9wZXJ0aWVzU2VjdGlvbi5wcm90b3R5cGUgPSB7CiAgICAgb25wb3B1bGF0ZTogZnVuY3Rp b24oKQogICAgIHsKQEAgLTQ4LDY4ICs4OSwzNSBAQCBXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVy dGllc1NlY3Rpb24ucHJvCiAgICAgICAgIHZhciBjYWxsYmFjayA9IGZ1bmN0aW9uKHByb3BlcnRp ZXMpIHsKICAgICAgICAgICAgIGlmICghcHJvcGVydGllcykKICAgICAgICAgICAgICAgICByZXR1 cm47Ci0gICAgICAgICAgICBzZWxmLl91cGRhdGUocHJvcGVydGllcyk7CisgICAgICAgICAgICBz ZWxmLnVwZGF0ZVByb3BlcnRpZXMocHJvcGVydGllcyk7CiAgICAgICAgIH07CiAgICAgICAgIElu amVjdGVkU2NyaXB0QWNjZXNzLmdldFByb3BlcnRpZXModGhpcy5vYmplY3QsIHRoaXMuaWdub3Jl SGFzT3duUHJvcGVydHksIGNhbGxiYWNrKTsKICAgICB9LAogCi0gICAgX3VwZGF0ZTogZnVuY3Rp b24ocHJvcGVydGllcykKKyAgICB1cGRhdGVQcm9wZXJ0aWVzOiBmdW5jdGlvbihwcm9wZXJ0aWVz LCByb290VHJlZUVsZW1lbnRDb25zdHJ1Y3RvciwgcHJvcGVydHlDb21wYXJlcikKICAgICB7Cisg ICAgICAgIGlmICghcm9vdFRyZWVFbGVtZW50Q29uc3RydWN0b3IpCisgICAgICAgICAgICByb290 VHJlZUVsZW1lbnRDb25zdHJ1Y3RvciA9IHRoaXMudHJlZUVsZW1lbnRDb25zdHJ1Y3RvcjsKKyAg ICAgICAgICAgIAorICAgICAgICBpZiAoIXByb3BlcnR5Q29tcGFyZXIpCisgICAgICAgICAgICBw cm9wZXJ0eUNvbXBhcmVyID0gV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnRpZXNTZWN0aW9uLlBy b3BlcnR5Q29tcGFyZXI7CisgICAgICAgICAgICAKICAgICAgICAgaWYgKHRoaXMuZXh0cmFQcm9w ZXJ0aWVzKQogICAgICAgICAgICAgZm9yICh2YXIgaSA9IDA7IGkgPCB0aGlzLmV4dHJhUHJvcGVy dGllcy5sZW5ndGg7ICsraSkKICAgICAgICAgICAgICAgICBwcm9wZXJ0aWVzLnB1c2godGhpcy5l eHRyYVByb3BlcnRpZXNbaV0pOwotICAgICAgICBwcm9wZXJ0aWVzLnNvcnQodGhpcy5fZGlzcGxh eVNvcnQpOworICAgICAgICAgICAgICAgIAorICAgICAgICBwcm9wZXJ0aWVzLnNvcnQocHJvcGVy dHlDb21wYXJlcik7CiAKICAgICAgICAgdGhpcy5wcm9wZXJ0aWVzVHJlZU91dGxpbmUucmVtb3Zl Q2hpbGRyZW4oKTsKIAogICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IHByb3BlcnRpZXMubGVu Z3RoOyArK2kpCi0gICAgICAgICAgICB0aGlzLnByb3BlcnRpZXNUcmVlT3V0bGluZS5hcHBlbmRD aGlsZChuZXcgdGhpcy50cmVlRWxlbWVudENvbnN0cnVjdG9yKHByb3BlcnRpZXNbaV0pKTsKKyAg ICAgICAgICAgIHRoaXMucHJvcGVydGllc1RyZWVPdXRsaW5lLmFwcGVuZENoaWxkKG5ldyByb290 VHJlZUVsZW1lbnRDb25zdHJ1Y3Rvcihwcm9wZXJ0aWVzW2ldKSk7CiAKICAgICAgICAgaWYgKCF0 aGlzLnByb3BlcnRpZXNUcmVlT3V0bGluZS5jaGlsZHJlbi5sZW5ndGgpIHsKICAgICAgICAgICAg IHZhciB0aXRsZSA9ICI8ZGl2IGNsYXNzPVwiaW5mb1wiPiIgKyB0aGlzLmVtcHR5UGxhY2Vob2xk ZXIgKyAiPC9kaXY+IjsKICAgICAgICAgICAgIHZhciBpbmZvRWxlbWVudCA9IG5ldyBUcmVlRWxl bWVudCh0aXRsZSwgbnVsbCwgZmFsc2UpOwogICAgICAgICAgICAgdGhpcy5wcm9wZXJ0aWVzVHJl ZU91dGxpbmUuYXBwZW5kQ2hpbGQoaW5mb0VsZW1lbnQpOwogICAgICAgICB9Ci0gICAgfSwKLQot ICAgIF9kaXNwbGF5U29ydDogZnVuY3Rpb24ocHJvcGVydHlBLCBwcm9wZXJ0eUIpIHsKLSAgICAg ICAgdmFyIGEgPSBwcm9wZXJ0eUEubmFtZTsKLSAgICAgICAgdmFyIGIgPSBwcm9wZXJ0eUIubmFt ZTsKLQotICAgICAgICAvLyBpZiB1c2VkIGVsc2V3aGVyZSBtYWtlIHN1cmUgdG8KLSAgICAgICAg Ly8gIC0gY29udmVydCBhIGFuZCBiIHRvIHN0cmluZ3MgKG5vdCBuZWVkZWQgaGVyZSwgcHJvcGVy dGllcyBhcmUgYWxsIHN0cmluZ3MpCi0gICAgICAgIC8vICAtIGNoZWNrIGlmIGEgPT0gYiAobm90 IG5lZWRlZCBoZXJlLCBubyB0d28gcHJvcGVydGllcyBjYW4gYmUgdGhlIHNhbWUpCi0KLSAgICAg ICAgdmFyIGRpZmYgPSAwOwotICAgICAgICB2YXIgY2h1bmsgPSAvXlxkK3xeXEQrLzsKLSAgICAg ICAgdmFyIGNodW5rYSwgY2h1bmtiLCBhbnVtLCBibnVtOwotICAgICAgICB3aGlsZSAoZGlmZiA9 PT0gMCkgewotICAgICAgICAgICAgaWYgKCFhICYmIGIpCi0gICAgICAgICAgICAgICAgcmV0dXJu IC0xOwotICAgICAgICAgICAgaWYgKCFiICYmIGEpCi0gICAgICAgICAgICAgICAgcmV0dXJuIDE7 Ci0gICAgICAgICAgICBjaHVua2EgPSBhLm1hdGNoKGNodW5rKVswXTsKLSAgICAgICAgICAgIGNo dW5rYiA9IGIubWF0Y2goY2h1bmspWzBdOwotICAgICAgICAgICAgYW51bSA9ICFpc05hTihjaHVu a2EpOwotICAgICAgICAgICAgYm51bSA9ICFpc05hTihjaHVua2IpOwotICAgICAgICAgICAgaWYg KGFudW0gJiYgIWJudW0pCi0gICAgICAgICAgICAgICAgcmV0dXJuIC0xOwotICAgICAgICAgICAg aWYgKGJudW0gJiYgIWFudW0pCi0gICAgICAgICAgICAgICAgcmV0dXJuIDE7Ci0gICAgICAgICAg ICBpZiAoYW51bSAmJiBibnVtKSB7Ci0gICAgICAgICAgICAgICAgZGlmZiA9IGNodW5rYSAtIGNo dW5rYjsKLSAgICAgICAgICAgICAgICBpZiAoZGlmZiA9PT0gMCAmJiBjaHVua2EubGVuZ3RoICE9 PSBjaHVua2IubGVuZ3RoKSB7Ci0gICAgICAgICAgICAgICAgICAgIGlmICghK2NodW5rYSAmJiAh K2NodW5rYikgLy8gY2h1bmtzIGFyZSBzdHJpbmdzIG9mIGFsbCAwcyAoc3BlY2lhbCBjYXNlKQot ICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGNodW5rYS5sZW5ndGggLSBjaHVua2IubGVu Z3RoOwotICAgICAgICAgICAgICAgICAgICBlbHNlCi0gICAgICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gY2h1bmtiLmxlbmd0aCAtIGNodW5rYS5sZW5ndGg7Ci0gICAgICAgICAgICAgICAgfQot ICAgICAgICAgICAgfSBlbHNlIGlmIChjaHVua2EgIT09IGNodW5rYikKLSAgICAgICAgICAgICAg ICByZXR1cm4gKGNodW5rYSA8IGNodW5rYikgPyAtMSA6IDE7Ci0gICAgICAgICAgICBhID0gYS5z dWJzdHJpbmcoY2h1bmthLmxlbmd0aCk7Ci0gICAgICAgICAgICBiID0gYi5zdWJzdHJpbmcoY2h1 bmtiLmxlbmd0aCk7Ci0gICAgICAgIH0KLSAgICAgICAgcmV0dXJuIGRpZmY7CiAgICAgfQogfQog CkBAIC0xMjksMTggKzEzNywxNyBAQCBXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydHlUcmVlRWxl bWVudC5wCiAgICAgICAgIGlmICh0aGlzLmNoaWxkcmVuLmxlbmd0aCAmJiAhdGhpcy5zaG91bGRS ZWZyZXNoQ2hpbGRyZW4pCiAgICAgICAgICAgICByZXR1cm47CiAKLSAgICAgICAgdmFyIHNlbGYg PSB0aGlzOwogICAgICAgICB2YXIgY2FsbGJhY2sgPSBmdW5jdGlvbihwcm9wZXJ0aWVzKSB7Ci0g ICAgICAgICAgICBzZWxmLnJlbW92ZUNoaWxkcmVuKCk7CisgICAgICAgICAgICB0aGlzLnJlbW92 ZUNoaWxkcmVuKCk7CiAgICAgICAgICAgICBpZiAoIXByb3BlcnRpZXMpCiAgICAgICAgICAgICAg ICAgcmV0dXJuOwogCi0gICAgICAgICAgICBwcm9wZXJ0aWVzLnNvcnQoc2VsZi5fZGlzcGxheVNv cnQpOworICAgICAgICAgICAgcHJvcGVydGllcy5zb3J0KFdlYkluc3BlY3Rvci5PYmplY3RQcm9w ZXJ0aWVzU2VjdGlvbi5Qcm9wZXJ0eUNvbXBhcmVyKTsKICAgICAgICAgICAgIGZvciAodmFyIGkg PSAwOyBpIDwgcHJvcGVydGllcy5sZW5ndGg7ICsraSkgewotICAgICAgICAgICAgICAgIHNlbGYu YXBwZW5kQ2hpbGQobmV3IHNlbGYudHJlZU91dGxpbmUuc2VjdGlvbi50cmVlRWxlbWVudENvbnN0 cnVjdG9yKHByb3BlcnRpZXNbaV0pKTsKKyAgICAgICAgICAgICAgICB0aGlzLmFwcGVuZENoaWxk KG5ldyB0aGlzLnRyZWVPdXRsaW5lLnNlY3Rpb24udHJlZUVsZW1lbnRDb25zdHJ1Y3Rvcihwcm9w ZXJ0aWVzW2ldKSk7CiAgICAgICAgICAgICB9CiAgICAgICAgIH07Ci0gICAgICAgIEluamVjdGVk U2NyaXB0QWNjZXNzLmdldFByb3BlcnRpZXModGhpcy5wcm9wZXJ0eS52YWx1ZSwgZmFsc2UsIGNh bGxiYWNrKTsKKyAgICAgICAgSW5qZWN0ZWRTY3JpcHRBY2Nlc3MuZ2V0UHJvcGVydGllcyh0aGlz LnByb3BlcnR5LnZhbHVlLCBmYWxzZSwgY2FsbGJhY2suYmluZCh0aGlzKSk7CiAgICAgfSwKIAog ICAgIG9uZGJsY2xpY2s6IGZ1bmN0aW9uKGVsZW1lbnQsIGV2ZW50KQpAQCAtMTU1LDEwICsxNjIs MTQgQEAgV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnR5VHJlZUVsZW1lbnQucAogCiAgICAgdXBk YXRlOiBmdW5jdGlvbigpCiAgICAgewotICAgICAgICB2YXIgbmFtZUVsZW1lbnQgPSBkb2N1bWVu dC5jcmVhdGVFbGVtZW50KCJzcGFuIik7Ci0gICAgICAgIG5hbWVFbGVtZW50LmNsYXNzTmFtZSA9 ICJuYW1lIjsKLSAgICAgICAgbmFtZUVsZW1lbnQudGV4dENvbnRlbnQgPSB0aGlzLnByb3BlcnR5 Lm5hbWU7Ci0KKyAgICAgICAgdGhpcy5uYW1lRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1l bnQoInNwYW4iKTsKKyAgICAgICAgdGhpcy5uYW1lRWxlbWVudC5jbGFzc05hbWUgPSAibmFtZSI7 CisgICAgICAgIHRoaXMubmFtZUVsZW1lbnQudGV4dENvbnRlbnQgPSB0aGlzLnByb3BlcnR5Lm5h bWU7CisKKyAgICAgICAgdmFyIHNlcGFyYXRvckVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVt ZW50KCJzcGFuIik7CisgICAgICAgIHNlcGFyYXRvckVsZW1lbnQuY2xhc3NOYW1lID0gInNlcGFy YXRvciI7CisgICAgICAgIHNlcGFyYXRvckVsZW1lbnQudGV4dENvbnRlbnQgPSAiOiAiOworICAg ICAgICAKICAgICAgICAgdGhpcy52YWx1ZUVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50 KCJzcGFuIik7CiAgICAgICAgIHRoaXMudmFsdWVFbGVtZW50LmNsYXNzTmFtZSA9ICJ2YWx1ZSI7 CiAgICAgICAgIHRoaXMudmFsdWVFbGVtZW50LnRleHRDb250ZW50ID0gdGhpcy5wcm9wZXJ0eS52 YWx1ZS5kZXNjcmlwdGlvbjsKQEAgLTE2Nyw4ICsxNzgsOCBAQCBXZWJJbnNwZWN0b3IuT2JqZWN0 UHJvcGVydHlUcmVlRWxlbWVudC5wCiAKICAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQucmVt b3ZlQ2hpbGRyZW4oKTsKIAotICAgICAgICB0aGlzLmxpc3RJdGVtRWxlbWVudC5hcHBlbmRDaGls ZChuYW1lRWxlbWVudCk7Ci0gICAgICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50LmFwcGVuZENoaWxk KGRvY3VtZW50LmNyZWF0ZVRleHROb2RlKCI6ICIpKTsKKyAgICAgICAgdGhpcy5saXN0SXRlbUVs ZW1lbnQuYXBwZW5kQ2hpbGQodGhpcy5uYW1lRWxlbWVudCk7CisgICAgICAgIHRoaXMubGlzdEl0 ZW1FbGVtZW50LmFwcGVuZENoaWxkKHNlcGFyYXRvckVsZW1lbnQpOwogICAgICAgICB0aGlzLmxp c3RJdGVtRWxlbWVudC5hcHBlbmRDaGlsZCh0aGlzLnZhbHVlRWxlbWVudCk7CiAgICAgICAgIHRo aXMuaGFzQ2hpbGRyZW4gPSB0aGlzLnByb3BlcnR5LnZhbHVlLmhhc0NoaWxkcmVuOwogICAgIH0s CkluZGV4OiBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvU2NyaXB0c1BhbmVsLmpzCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9TY3JpcHRzUGFuZWwuanMJKHJl dmlzaW9uIDQ4Mzk4KQorKysgV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1NjcmlwdHNQYW5l bC5qcwkod29ya2luZyBjb3B5KQpAQCAtMTI2LDYgKzEyNiw3IEBAIFdlYkluc3BlY3Rvci5TY3Jp cHRzUGFuZWwgPSBmdW5jdGlvbigpCiAgICAgdGhpcy50b3BTdGF0dXNCYXIuYXBwZW5kQ2hpbGQo dGhpcy5zaWRlYmFyUmVzaXplV2lkZ2V0RWxlbWVudCk7CiAKICAgICB0aGlzLnNpZGViYXJQYW5l cyA9IHt9OworICAgIHRoaXMuc2lkZWJhclBhbmVzLndhdGNoRXhwcmVzc2lvbnMgPSBuZXcgV2Vi SW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZSgpOwogICAgIHRoaXMuc2lkZWJh clBhbmVzLmNhbGxzdGFjayA9IG5ldyBXZWJJbnNwZWN0b3IuQ2FsbFN0YWNrU2lkZWJhclBhbmUo KTsKICAgICB0aGlzLnNpZGViYXJQYW5lcy5zY29wZWNoYWluID0gbmV3IFdlYkluc3BlY3Rvci5T Y29wZUNoYWluU2lkZWJhclBhbmUoKTsKICAgICB0aGlzLnNpZGViYXJQYW5lcy5icmVha3BvaW50 cyA9IG5ldyBXZWJJbnNwZWN0b3IuQnJlYWtwb2ludHNTaWRlYmFyUGFuZSgpOwpAQCAtNDcxLDYg KzQ3Miw4IEBAIFdlYkluc3BlY3Rvci5TY3JpcHRzUGFuZWwucHJvdG90eXBlID0gewogICAgICAg ICB9CiAKICAgICAgICAgdGhpcy5fc291cmNlSURNYXAgPSB7fTsKKyAgICAgICAgCisgICAgICAg IHRoaXMuc2lkZWJhclBhbmVzLndhdGNoRXhwcmVzc2lvbnMucmVmcmVzaEV4cHJlc3Npb25zKCk7 CiAgICAgfSwKIAogICAgIGdldCB2aXNpYmxlVmlldygpCkBAIC03MDQsNiArNzA3LDcgQEAgV2Vi SW5zcGVjdG9yLlNjcmlwdHNQYW5lbC5wcm90b3R5cGUgPSB7CiAgICAgICAgICAgICByZXR1cm47 CiAKICAgICAgICAgdGhpcy5zaWRlYmFyUGFuZXMuc2NvcGVjaGFpbi51cGRhdGUoY3VycmVudEZy YW1lKTsKKyAgICAgICAgdGhpcy5zaWRlYmFyUGFuZXMud2F0Y2hFeHByZXNzaW9ucy5yZWZyZXNo RXhwcmVzc2lvbnMoKTsKIAogICAgICAgICB2YXIgc2NyaXB0T3JSZXNvdXJjZSA9IHRoaXMuX3Nv dXJjZUlETWFwW2N1cnJlbnRGcmFtZS5zb3VyY2VJRF07CiAgICAgICAgIHRoaXMuX3Nob3dTY3Jp cHRPclJlc291cmNlKHNjcmlwdE9yUmVzb3VyY2UsIGN1cnJlbnRGcmFtZS5saW5lKTsKSW5kZXg6 IFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUu anMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1dhdGNoRXhwcmVz c2lvbnNTaWRlYmFyUGFuZS5qcwkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvaW5zcGVjdG9yL2Zy b250LWVuZC9XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUuanMJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsMjc0IEBACisvKgorICogQ29weXJpZ2h0IChDKSBJQk0gQ29ycC4gMjAwOSAgQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1l dDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l cgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBv ZiBJQk0gQ29ycC4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUg dXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlz IHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoK KyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFO RCBDT05UUklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElD VUxBUiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJ R0hUCisgKiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJ TkRJUkVDVCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVO VElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVN RU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFU QSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBB TkQgT04gQU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBT VFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RI RVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0Uu CisgKi8KKworV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZSA9IGZ1bmN0 aW9uKCkKK3sKKyAgICBXZWJJbnNwZWN0b3IuU2lkZWJhclBhbmUuY2FsbCh0aGlzLCBXZWJJbnNw ZWN0b3IuVUlTdHJpbmcoIldhdGNoIEV4cHJlc3Npb25zIikpOworCisgICAgdGhpcy5zZWN0aW9u ID0gbmV3IFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbigpOworCisgICAgdGhp cy5ib2R5RWxlbWVudC5hcHBlbmRDaGlsZCh0aGlzLnNlY3Rpb24uZWxlbWVudCk7CisKKyAgICB2 YXIgYWRkRWxlbWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImJ1dHRvbiIpOworICAgIGFk ZEVsZW1lbnQuc2V0QXR0cmlidXRlKCJ0eXBlIiwgImJ1dHRvbiIpOworICAgIGFkZEVsZW1lbnQu dGV4dENvbnRlbnQgPSBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoIkFkZCIpOworICAgIGFkZEVsZW1l bnQuYWRkRXZlbnRMaXN0ZW5lcigiY2xpY2siLCB0aGlzLnNlY3Rpb24uYWRkRXhwcmVzc2lvbi5i aW5kKHRoaXMuc2VjdGlvbiksIGZhbHNlKTsKKworICAgIHZhciByZWZyZXNoRWxlbWVudCA9IGRv Y3VtZW50LmNyZWF0ZUVsZW1lbnQoImJ1dHRvbiIpOworICAgIHJlZnJlc2hFbGVtZW50LnNldEF0 dHJpYnV0ZSgidHlwZSIsICJidXR0b24iKTsKKyAgICByZWZyZXNoRWxlbWVudC50ZXh0Q29udGVu dCA9IFdlYkluc3BlY3Rvci5VSVN0cmluZygiUmVmcmVzaCIpOworICAgIHJlZnJlc2hFbGVtZW50 LmFkZEV2ZW50TGlzdGVuZXIoImNsaWNrIiwgdGhpcy5zZWN0aW9uLnVwZGF0ZS5iaW5kKHRoaXMu c2VjdGlvbiksIGZhbHNlKTsKKworICAgIHZhciBjZW50ZXJFbGVtZW50ID0gZG9jdW1lbnQuY3Jl YXRlRWxlbWVudCgiZGl2Iik7CisgICAgY2VudGVyRWxlbWVudC5hZGRTdHlsZUNsYXNzKCJ3YXRj aC1leHByZXNzaW9ucy1idXR0b25zLWNvbnRhaW5lciIpOworICAgIGNlbnRlckVsZW1lbnQuYXBw ZW5kQ2hpbGQoYWRkRWxlbWVudCk7CisgICAgY2VudGVyRWxlbWVudC5hcHBlbmRDaGlsZChyZWZy ZXNoRWxlbWVudCk7CisgICAgdGhpcy5ib2R5RWxlbWVudC5hcHBlbmRDaGlsZChjZW50ZXJFbGVt ZW50KTsKKworICAgIHRoaXMuZXhwYW5kZWQgPSB0aGlzLnNlY3Rpb24ubG9hZFNhdmVkRXhwcmVz c2lvbnMoKS5sZW5ndGggPiAwOworICAgIHRoaXMub25leHBhbmQgPSB0aGlzLnJlZnJlc2hFeHBy ZXNzaW9ucy5iaW5kKHRoaXMpOworfQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1Np ZGViYXJQYW5lLnByb3RvdHlwZSA9IHsKKyAgICByZWZyZXNoRXhwcmVzc2lvbnM6IGZ1bmN0aW9u KCkKKyAgICB7CisgICAgICAgIHRoaXMuc2VjdGlvbi51cGRhdGUoKTsKKyAgICB9Cit9CisKK1dl Ykluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUucHJvdG90eXBlLl9fcHJvdG9f XyA9IFdlYkluc3BlY3Rvci5TaWRlYmFyUGFuZS5wcm90b3R5cGU7CisKK1dlYkluc3BlY3Rvci5X YXRjaEV4cHJlc3Npb25zU2VjdGlvbiA9IGZ1bmN0aW9uKCkKK3sKKyAgICBXZWJJbnNwZWN0b3Iu T2JqZWN0UHJvcGVydGllc1NlY3Rpb24uY2FsbCh0aGlzKTsKKworICAgIHRoaXMud2F0Y2hFeHBy ZXNzaW9ucyA9IHRoaXMubG9hZFNhdmVkRXhwcmVzc2lvbnMoKTsKKworICAgIHRoaXMuaGVhZGVy RWxlbWVudC5jbGFzc05hbWUgPSAiaGlkZGVuIjsKKyAgICB0aGlzLmVkaXRhYmxlID0gdHJ1ZTsK KyAgICB0aGlzLmV4cGFuZGVkID0gdHJ1ZTsKKyAgICB0aGlzLnByb3BlcnRpZXNFbGVtZW50LmFk ZFN0eWxlQ2xhc3MoIndhdGNoLWV4cHJlc3Npb25zIik7Cit9CisKK1dlYkluc3BlY3Rvci5XYXRj aEV4cHJlc3Npb25zU2VjdGlvbi5ORVdfV0FUQ0hfRVhQUkVTU0lPTiA9ICJceEEwIjsKKworV2Vi SW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLlByb3BlcnR5Q29tcGFyZXIgPSBmdW5j dGlvbihwcm9wZXJ0eUEsIHByb3BlcnR5QikgCit7CisgICAgaWYgKHByb3BlcnR5QS53YXRjaElu ZGV4ID09IHByb3BlcnR5Qi53YXRjaEluZGV4KQorICAgICAgICByZXR1cm4gMDsKKyAgICBlbHNl IGlmIChwcm9wZXJ0eUEud2F0Y2hJbmRleCA8IHByb3BlcnR5Qi53YXRjaEluZGV4KQorICAgICAg ICByZXR1cm4gLTE7CisgICAgZWxzZQorICAgICAgICByZXR1cm4gMTsKK307CisKK1dlYkluc3Bl Y3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5wcm90b3R5cGUgPSB7CisgICAgdXBkYXRlOiBm dW5jdGlvbigpCisgICAgeworICAgICAgICBmdW5jdGlvbiBhcHBlbmRSZXN1bHQoZXhwcmVzc2lv biwgd2F0Y2hJbmRleCwgcmVzdWx0LCBleGNlcHRpb24pCisgICAgICAgIHsKKyAgICAgICAgICAg IC8vIFRoZSBudWxsIGNoZWNrIGNhdGNoZXMgc29tZSBvdGhlciBjYXNlcywgbGlrZSBudWxsIGl0 c2VsZiwgYW5kIE5hTgorICAgICAgICAgICAgaWYgKCh0eXBlb2YgcmVzdWx0ICE9PSAib2JqZWN0 IikgfHwgKHJlc3VsdCA9PSBudWxsKSkKKyAgICAgICAgICAgICAgICByZXN1bHQgPSBuZXcgV2Vi SW5zcGVjdG9yLk9iamVjdFByb3h5KG51bGwsIFtdLCAwLCBTdHJpbmcocmVzdWx0KSwgZmFsc2Up OworCisgICAgICAgICAgICB2YXIgcHJvcGVydHkgPSBuZXcgV2ViSW5zcGVjdG9yLk9iamVjdFBy b3BlcnR5UHJveHkoZXhwcmVzc2lvbiwgcmVzdWx0KTsKKyAgICAgICAgICAgIHByb3BlcnR5Lndh dGNoSW5kZXggPSB3YXRjaEluZGV4OworCisgICAgICAgICAgICAvLyBGb3IgbmV3bHkgYWRkZWQs IGVtcHR5IGV4cHJlc3Npb25zLCBzZXQgZGVzY3JpcHRpb24gdG8gIiIsCisgICAgICAgICAgICAv LyBzaW5jZSBvdGhlcndpc2UgeW91IGdldCBET01XaW5kb3cKKyAgICAgICAgICAgIGlmIChwcm9w ZXJ0eS5uYW1lID09PSBXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24uTkVXX1dB VENIX0VYUFJFU1NJT04pIAorICAgICAgICAgICAgICAgIHByb3BlcnR5LnZhbHVlLmRlc2NyaXB0 aW9uID0gIiI7CisgICAgICAgICAgICAKKyAgICAgICAgICAgIC8vIFRvIGNsYXJpZnkgd2hhdCdz IGdvaW5nIG9uIGhlcmU6IAorICAgICAgICAgICAgLy8gSW4gdGhlIG91dGVyIGZ1bmN0aW9uLCB3 ZSBjYWxjdWxhdGUgdGhlIG51bWJlciBvZiBwcm9wZXJ0aWVzCisgICAgICAgICAgICAvLyB0aGF0 IHdlJ3JlIGdvaW5nIHRvIGJlIHVwZGF0aW5nLCBhbmQgc2V0IHRoYXQgaW4gdGhlCisgICAgICAg ICAgICAvLyBwcm9wZXJ0eUNvdW50IHZhcmlhYmxlLiAgCisgICAgICAgICAgICAvLyBJbiB0aGlz IGZ1bmN0aW9uLCB3ZSB0ZXN0IHRvIHNlZSB3aGVuIHdlIGFyZSBwcm9jZXNzaW5nIHRoZSAKKyAg ICAgICAgICAgIC8vIGxhc3QgcHJvcGVydHksIGFuZCB0aGVuIGNhbGwgdGhlIHN1cGVyY2xhc3Mn cyB1cGRhdGVQcm9wZXJ0aWVzKCkgCisgICAgICAgICAgICAvLyBtZXRob2QgdG8gZ2V0IGFsbCB0 aGUgcHJvcGVydGllcyByZWZyZXNoZWQgYXQgb25jZS4KKyAgICAgICAgICAgIHByb3BlcnRpZXMu cHVzaChwcm9wZXJ0eSk7CisgICAgICAgICAgICAKKyAgICAgICAgICAgIGlmIChwcm9wZXJ0aWVz Lmxlbmd0aCA9PSBwcm9wZXJ0eUNvdW50KQorICAgICAgICAgICAgICAgIHRoaXMudXBkYXRlUHJv cGVydGllcyhwcm9wZXJ0aWVzLCBXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1l bnQsIFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5Qcm9wZXJ0eUNvbXBhcmVy KTsKKyAgICAgICAgfQorCisgICAgICAgIHZhciBwcm9wZXJ0aWVzID0gW107CisKKyAgICAgICAg Ly8gQ291bnQgdGhlIHByb3BlcnRpZXMsIHNvIHdlIGtub3duIHdoZW4gdG8gY2FsbCB0aGlzLnVw ZGF0ZVByb3BlcnRpZXMoKQorICAgICAgICAvLyBpbiBhcHBlbmRSZXN1bHQoKQorICAgICAgICB2 YXIgcHJvcGVydHlDb3VudCA9IDA7CisgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgdGhpcy53 YXRjaEV4cHJlc3Npb25zLmxlbmd0aDsgKytpKSB7CisgICAgICAgICAgICBpZiAoIXRoaXMud2F0 Y2hFeHByZXNzaW9uc1tpXSkgCisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAgICAg ICArK3Byb3BlcnR5Q291bnQ7CisgICAgICAgIH0KKworICAgICAgICAvLyBOb3cgcHJvY2VzcyBh bGwgdGhlIGV4cHJlc3Npb25zLCBzaW5jZSB3ZSBoYXZlIHRoZSBhY3R1YWwgY291bnQsCisgICAg ICAgIC8vIHdoaWNoIGlzIGNoZWNrZWQgaW4gdGhlIGFwcGVuZFJlc3VsdCBpbm5lciBmdW5jdGlv bi4KKyAgICAgICAgZm9yICh2YXIgaSA9IDA7IGkgPCB0aGlzLndhdGNoRXhwcmVzc2lvbnMubGVu Z3RoOyArK2kpIHsKKyAgICAgICAgICAgIHZhciBleHByZXNzaW9uID0gdGhpcy53YXRjaEV4cHJl c3Npb25zW2ldOworICAgICAgICAgICAgaWYgKCFleHByZXNzaW9uKSAKKyAgICAgICAgICAgICAg ICBjb250aW51ZTsKKworICAgICAgICAgICAgV2ViSW5zcGVjdG9yLmNvbnNvbGUuZXZhbEluSW5z cGVjdGVkV2luZG93KCIoIiArIGV4cHJlc3Npb24gKyAiKSIsIGFwcGVuZFJlc3VsdC5iaW5kKHRo aXMsIGV4cHJlc3Npb24sIGkpKTsKKyAgICAgICAgfQorCisgICAgICAgIC8vIG5vdGUgdGhpcyBp cyBzZXR0aW5nIHRoZSBleHBhbnNpb24gb2YgdGhlIHRyZWUsIG5vdCB0aGUgc2VjdGlvbjsKKyAg ICAgICAgLy8gd2l0aCBubyBleHByZXNzaW9ucywgYW5kIGV4cGFuZGVkIHRyZWUsIHdlIGdldCBz b21lIGV4dHJhIHZlcnRpY2FsCisgICAgICAgIC8vIHdoaXRlIHNwYWNlCisgICAgICAgIC8vIEZJ WE1FOiBzaG91bGQgY2hhbmdlIHRvIHVzZSBoZWFkZXIgYnV0dG9ucyBpbnN0ZWFkIG9mIHRoZSBi dXR0b25zCisgICAgICAgIC8vIGF0IHRoZSBib3R0b20gb2YgdGhlIHNlY3Rpb24sIHRoZW4gd2Ug Y2FuIGFkZCBhICJObyBXYXRjaCBFeHByZXNzaW9ucworICAgICAgICAvLyBlbGVtZW50IHdoZW4g dGhlcmUgYXJlIG5vIHdhdGNoIGV4cHJlc3Npb25zLCBhbmQgdGhpcyBpc3N1ZSBzaG91bGQKKyAg ICAgICAgLy8gZ28gYXdheS4KKyAgICAgICAgdGhpcy5leHBhbmRlZCA9IChwcm9wZXJ0eUNvdW50 ICE9IDApOworICAgIH0sCisKKyAgICBhZGRFeHByZXNzaW9uOiBmdW5jdGlvbigpCisgICAgewor ICAgICAgICB0aGlzLndhdGNoRXhwcmVzc2lvbnMucHVzaChXZWJJbnNwZWN0b3IuV2F0Y2hFeHBy ZXNzaW9uc1NlY3Rpb24uTkVXX1dBVENIX0VYUFJFU1NJT04pOworICAgICAgICB0aGlzLnVwZGF0 ZSgpOworCisgICAgICAgIC8vIEFmdGVyIHVwZGF0ZSgpLCB0aGUgbmV3IGVtcHR5IGV4cHJlc3Np b24gdG8gYmUgZWRpdGVkCisgICAgICAgIC8vIHdpbGwgYmUgaW4gdGhlIHRyZWUsIGJ1dCB3ZSBo YXZlIHRvIGZpbmQgaXQuCisgICAgICAgIHRyZWVFbGVtZW50ID0gdGhpcy5maW5kQWRkZWRUcmVl RWxlbWVudCgpOworICAgICAgICBpZiAodHJlZUVsZW1lbnQpCisgICAgICAgICAgICB0cmVlRWxl bWVudC5zdGFydEVkaXRpbmcoKTsKKyAgICB9LAorCisgICAgdXBkYXRlRXhwcmVzc2lvbjogZnVu Y3Rpb24oZWxlbWVudCwgdmFsdWUpCisgICAgeworICAgICAgICB0aGlzLndhdGNoRXhwcmVzc2lv bnNbZWxlbWVudC5wcm9wZXJ0eS53YXRjaEluZGV4XSA9IHZhbHVlOworICAgICAgICB0aGlzLnNh dmVFeHByZXNzaW9ucygpOworICAgICAgICB0aGlzLnVwZGF0ZSgpOworICAgIH0sCisKKyAgICBm aW5kQWRkZWRUcmVlRWxlbWVudDogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgdmFyIGNoaWxk cmVuID0gdGhpcy5wcm9wZXJ0aWVzVHJlZU91dGxpbmUuY2hpbGRyZW47CisgICAgICAgIGZvciAo dmFyIGkgPSAwOyBpIDwgY2hpbGRyZW4ubGVuZ3RoOyArK2kpCisgICAgICAgICAgICBpZiAoY2hp bGRyZW5baV0ucHJvcGVydHkubmFtZSA9PT0gV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNT ZWN0aW9uLk5FV19XQVRDSF9FWFBSRVNTSU9OKQorICAgICAgICAgICAgICAgIHJldHVybiBjaGls ZHJlbltpXTsKKyAgICB9LAorCisgICAgbG9hZFNhdmVkRXhwcmVzc2lvbnM6IGZ1bmN0aW9uKCkK KyAgICB7CisgICAgICAgIHZhciBqc29uID0gSW5zcGVjdG9yQ29udHJvbGxlci5zZXR0aW5nKCJ3 YXRjaEV4cHJlc3Npb25zIik7CisgICAgICAgIGlmICghanNvbikKKyAgICAgICAgICAgIHJldHVy biBbXTsKKworICAgICAgICB0cnkgeworICAgICAgICAgICAganNvbiA9IEpTT04ucGFyc2UoanNv bik7CisgICAgICAgIH0gY2F0Y2goZSkgeworICAgICAgICAgICAgcmV0dXJuIFtdOworICAgICAg ICB9CisKKyAgICAgICAgcmV0dXJuIGpzb24uZXhwcmVzc2lvbnMgfHwgW107CisgICAgfSwKKwor ICAgIHNhdmVFeHByZXNzaW9uczogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgdmFyIHRvU2F2 ZSA9IFtdOworICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IHRoaXMud2F0Y2hFeHByZXNzaW9u cy5sZW5ndGg7IGkrKykKKyAgICAgICAgICAgIGlmICh0aGlzLndhdGNoRXhwcmVzc2lvbnNbaV0p CisgICAgICAgICAgICAgICAgdG9TYXZlLnB1c2godGhpcy53YXRjaEV4cHJlc3Npb25zW2ldKTsK KworICAgICAgICB2YXIganNvbiA9IEpTT04uc3RyaW5naWZ5KHtleHByZXNzaW9uczogdG9TYXZl fSk7CisgICAgICAgIEluc3BlY3RvckNvbnRyb2xsZXIuc2V0U2V0dGluZygid2F0Y2hFeHByZXNz aW9ucyIsIGpzb24pOworCisgICAgICAgIHJldHVybiB0b1NhdmUubGVuZ3RoOworICAgIH0KK30K KworV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS5fX3Byb3Rv X18gPSBXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydGllc1NlY3Rpb24ucHJvdG90eXBlOworCitX ZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1lbnQgPSBmdW5jdGlvbihwcm9wZXJ0 eSkKK3sKKyAgICBXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydHlUcmVlRWxlbWVudC5jYWxsKHRo aXMsIHByb3BlcnR5KTsKK30KKworV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvblRyZWVFbGVt ZW50LnByb3RvdHlwZSA9IHsKKyAgICB1cGRhdGU6IGZ1bmN0aW9uKCkKKyAgICB7CisgICAgICAg IFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlwZS51cGRhdGUu Y2FsbCh0aGlzKTsKKworICAgICAgICB2YXIgZGVsZXRlQnV0dG9uID0gZG9jdW1lbnQuY3JlYXRl RWxlbWVudCgiaW5wdXQiKTsKKyAgICAgICAgZGVsZXRlQnV0dG9uLnR5cGUgPSAiYnV0dG9uIjsK KyAgICAgICAgZGVsZXRlQnV0dG9uLnRpdGxlID0gV2ViSW5zcGVjdG9yLlVJU3RyaW5nKCJEZWxl dGUgd2F0Y2ggZXhwcmVzc2lvbi4iKTsKKyAgICAgICAgZGVsZXRlQnV0dG9uLmFkZFN0eWxlQ2xh c3MoImVuYWJsZWQtYnV0dG9uIik7CisgICAgICAgIGRlbGV0ZUJ1dHRvbi5hZGRTdHlsZUNsYXNz KCJkZWxldGUtYnV0dG9uIik7CisgICAgICAgIGRlbGV0ZUJ1dHRvbi5hZGRFdmVudExpc3RlbmVy KCJjbGljayIsIHRoaXMuX2RlbGV0ZUJ1dHRvbkNsaWNrZWQuYmluZCh0aGlzKSwgZmFsc2UpOwor CisgICAgICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50Lmluc2VydEJlZm9yZShkZWxldGVCdXR0b24s IHRoaXMubGlzdEl0ZW1FbGVtZW50LmZpcnN0Q2hpbGQpOworICAgIH0sCisKKyAgICBfZGVsZXRl QnV0dG9uQ2xpY2tlZDogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgdGhpcy50cmVlT3V0bGlu ZS5zZWN0aW9uLnVwZGF0ZUV4cHJlc3Npb24odGhpcywgbnVsbCk7CisgICAgfSwKKworICAgIHN0 YXJ0RWRpdGluZzogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgaWYgKFdlYkluc3BlY3Rvci5p c0JlaW5nRWRpdGVkKHRoaXMubmFtZUVsZW1lbnQpIHx8ICF0aGlzLnRyZWVPdXRsaW5lLnNlY3Rp b24uZWRpdGFibGUpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAgdGhpcy5uYW1lRWxl bWVudC50ZXh0Q29udGVudCA9IHRoaXMucHJvcGVydHkubmFtZS50cmltV2hpdGVzcGFjZSgpOwor CisgICAgICAgIHZhciBjb250ZXh0ID0geyBleHBhbmRlZDogdGhpcy5leHBhbmRlZCB9OworCisg ICAgICAgIC8vIGNvbGxhcHNlIHRlbXBvcmFyaWx5LCBpZiByZXF1aXJlZAorICAgICAgICB0aGlz Lmhhc0NoaWxkcmVuID0gZmFsc2U7CisKKyAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQuYWRk U3R5bGVDbGFzcygiZWRpdGluZy1zdWItcGFydCIpOworCisgICAgICAgIFdlYkluc3BlY3Rvci5z dGFydEVkaXRpbmcodGhpcy5uYW1lRWxlbWVudCwgdGhpcy5lZGl0aW5nQ29tbWl0dGVkLmJpbmQo dGhpcyksIHRoaXMuZWRpdGluZ0NhbmNlbGxlZC5iaW5kKHRoaXMpLCBjb250ZXh0KTsKKyAgICB9 LAorCisgICAgZWRpdGluZ0NhbmNlbGxlZDogZnVuY3Rpb24oZWxlbWVudCwgY29udGV4dCkKKyAg ICB7CisgICAgICAgIGlmICghdGhpcy5uYW1lRWxlbWVudC50ZXh0Q29udGVudCkKKyAgICAgICAg ICAgIHRoaXMudHJlZU91dGxpbmUuc2VjdGlvbi51cGRhdGVFeHByZXNzaW9uKHRoaXMsIG51bGwp OworICAgICAgICAgICAgCisgICAgICAgIHRoaXMudXBkYXRlKCk7CisgICAgICAgIHRoaXMuZWRp dGluZ0VuZGVkKGNvbnRleHQpOworICAgIH0sCisKKyAgICBhcHBseUV4cHJlc3Npb246IGZ1bmN0 aW9uKGV4cHJlc3Npb24sIHVwZGF0ZUludGVyZmFjZSkKKyAgICB7CisgICAgICAgIGV4cHJlc3Np b24gPSBleHByZXNzaW9uLnRyaW1XaGl0ZXNwYWNlKCk7CisKKyAgICAgICAgaWYgKCFleHByZXNz aW9uKQorICAgICAgICAgICAgZXhwcmVzc2lvbiA9IG51bGw7CisKKyAgICAgICAgdGhpcy5wcm9w ZXJ0eS5uYW1lID0gZXhwcmVzc2lvbjsKKyAgICAgICAgdGhpcy50cmVlT3V0bGluZS5zZWN0aW9u LnVwZGF0ZUV4cHJlc3Npb24odGhpcywgZXhwcmVzc2lvbik7CisgICAgfQorfQorCitXZWJJbnNw ZWN0b3IuV2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1lbnQucHJvdG90eXBlLl9fcHJvdG9fXyA9IFdl Ykluc3BlY3Rvci5PYmplY3RQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlwZTsKSW5kZXg6IFdl YkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuY3NzCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdl YkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuY3NzCShyZXZpc2lvbiA0ODM5OCkK KysrIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuY3NzCSh3b3JraW5nIGNv cHkpCkBAIC0xMjA2LDYgKzEyMDYsMTAgQEAgYm9keS5pbmFjdGl2ZSAucGxhY2FyZC5zZWxlY3Rl ZCB7CiAgICAgbWFyZ2luLWJvdHRvbTogMXB4OwogfQogCisud2F0Y2gtZXhwcmVzc2lvbnMtYnV0 dG9ucy1jb250YWluZXIgeworICAgIHRleHQtYWxpZ246IGNlbnRlcjsKK30KKwogLnNlY3Rpb24g LmhlYWRlciB7CiAgICAgcGFkZGluZzogMnB4IDhweCA0cHggMThweDsKICAgICBib3JkZXItdG9w OiAxcHggc29saWQgcmdiKDE0NSwgMTYwLCAxOTIpOwpAQCAtMTM3MiwxMCArMTM3NiwxOSBAQCBi b2R5LmluYWN0aXZlIC5wbGFjYXJkLnNlbGVjdGVkIHsKICAgICB0ZXh0LW92ZXJmbG93OiBjbGlw OwogfQogCi1saS5lZGl0aW5nIC5zd2F0Y2gsIGxpLmVkaXRpbmcgLmVuYWJsZWQtYnV0dG9uIHsK K2xpLmVkaXRpbmcgLnN3YXRjaCwgbGkuZWRpdGluZyAuZW5hYmxlZC1idXR0b24sICBsaS5lZGl0 aW5nLXN1Yi1wYXJ0IC5kZWxldGUtYnV0dG9uIHsKICAgICBkaXNwbGF5OiBub25lICFpbXBvcnRh bnQ7CiB9CiAKKy53YXRjaC1leHByZXNzaW9ucyA+IGxpLmVkaXRpbmctc3ViLXBhcnQgLm5hbWUg eworICAgIGRpc3BsYXk6IGJsb2NrOyAKKyAgICB3aWR0aDogMTAwJTsKK30KKworLndhdGNoLWV4 cHJlc3Npb25zID4gbGkuZWRpdGluZy1zdWItcGFydCAudmFsdWUsIC53YXRjaC1leHByZXNzaW9u cyA+IGxpLmVkaXRpbmctc3ViLXBhcnQgLnNlcGFyYXRvciAgeworICAgIGRpc3BsYXk6IG5vbmU7 Cit9CisKIC5zZWN0aW9uIC5wcm9wZXJ0aWVzIGxpLmVkaXRpbmctc3ViLXBhcnQgewogICAgIHBh ZGRpbmc6IDNweCA2cHggOHB4IDE4cHg7CiAgICAgbWFyZ2luOiAtM3B4IC02cHggLThweCAtNnB4 OwpAQCAtMTQwOSw2ICsxNDIyLDE3IEBAIGxpLmVkaXRpbmcgLnN3YXRjaCwgbGkuZWRpdGluZyAu ZW5hYmxlZC0KICAgICB6LWluZGV4OiAxOwogfQogCisvKiBGSVhNRTogbmVlZCBhIGJldHRlciBp Y29uIChjb21tZW50IGluIGJ1ZyAyNzUxNCkgKi8KKy5zZWN0aW9uIC5wcm9wZXJ0aWVzIC5kZWxl dGUtYnV0dG9uIHsKKyAgICB3aWR0aDogMTBweDsKKyAgICBoZWlnaHQ6IDEwcHg7CisgICAgYmFj a2dyb3VuZC1pbWFnZTogdXJsKEltYWdlcy9lcnJvckljb24ucG5nKTsKKyAgICBiYWNrZ3JvdW5k LXBvc2l0aW9uOiAwIDA7CisgICAgYmFja2dyb3VuZC1jb2xvcjogdHJhbnNwYXJlbnQ7CisgICAg YmFja2dyb3VuZC1yZXBlYXQ6IG5vLXJlcGVhdDsKKyAgICBib3JkZXI6IDAgbm9uZSB0cmFuc3Bh cmVudDsKK30KKwogLnNlY3Rpb246aG92ZXIgLnByb3BlcnRpZXMgLmVuYWJsZWQtYnV0dG9uIHsK ICAgICBkaXNwbGF5OiBibG9jazsKIH0KSW5kZXg6IFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVu ZC9pbnNwZWN0b3IuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1l bmQvaW5zcGVjdG9yLmh0bWwJKHJldmlzaW9uIDQ4Mzk4KQorKysgV2ViQ29yZS9pbnNwZWN0b3Iv ZnJvbnQtZW5kL2luc3BlY3Rvci5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC02Miw2ICs2Miw3IEBA IFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE8KICAgICA8c2NyaXB0IHR5 cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJCcmVha3BvaW50c1NpZGViYXJQYW5lLmpzIj48L3Nj cmlwdD4KICAgICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJDYWxsU3RhY2tT aWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3Jp cHQiIHNyYz0iU2NvcGVDaGFpblNpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KKyAgICA8c2NyaXB0 IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJXYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUu anMiPjwvc2NyaXB0PgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9Ik1l dHJpY3NTaWRlYmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2ph dmFzY3JpcHQiIHNyYz0iUHJvcGVydGllc1NpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAgICA8 c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJDb2xvci5qcyI+PC9zY3JpcHQ+Cklu ZGV4OiBXZWJDb3JlL21hbnVhbC10ZXN0cy9pbnNwZWN0b3IvZGVidWdnZXItd2F0Y2gtZXhwcmVz c2lvbnMuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL21hbnVhbC10ZXN0cy9pbnNwZWN0b3Iv ZGVidWdnZXItd2F0Y2gtZXhwcmVzc2lvbnMuaHRtbAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUv bWFudWFsLXRlc3RzL2luc3BlY3Rvci9kZWJ1Z2dlci13YXRjaC1leHByZXNzaW9ucy5odG1sCShy ZXZpc2lvbiAwKQpAQCAtMCwwICsxLDExNSBAQAorPHA+VGVzdCBmb3IgCis8YSBocmVmPSJodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjc1MTQiPkJ1ZyAyNzUxNCAtIGFk ZCBzdXBwb3J0IGZvciB3YXRjaGVkIGV4cHJlc3Npb248L2E+LgorCis8cD5UbyBiZWdpbiB0ZXN0 LCBvcGVuIHdlYiBpbnNwZWN0b3IsIGdvIHRoZSBzY3JpcHRzIHBhbmVsIAorKGVuYWJsaW5nIHNj cmlwdCBkZWJ1Z2dpbmcgaWYgbmVjY2Nlc3NhcnkpLCBhbmQgdGhlbiBjbGljayB0aGlzIGxpbms6 Cis8YSBocmVmPSJqYXZhc2NyaXB0OnJ1blRlc3QoKSI+W2JlZ2luIHRlc3RdPC9hPi4KKworPHA+ UGVyZm9ybSB0aGUgZm9sbG93aW5nIHN0ZXBzLCBhbmQgbm90ZSB0aGUgZXhwZWN0ZWQgcmVzdWx0 czoKKyAgICAKKzxvbD4KKyAgICAKKzxsaT48cD5BZnRlciBjbGlja2luZyB0aGUgbGluayBhYm92 ZSwgeW91IHNob3VsZCBub3cgYmUgcGF1c2VkIGluIHRoZSBib2R5IG9mIAordGhlIHRlc3QgbWV0 aG9kLCB0aGFua3MgdG8gdGhlIDxjb2RlPmRlYnVnZ2VyPC9jb2RlPiBzdGF0ZW1lbnQuCisKKzxs aT48cD5BZGQgdGhlIGZvbGxvd2luZyBleHByZXNzaW9ucyB0byB0aGUgIldhdGNoIEV4cHJlc3Np b25zIiBzZWN0aW9uIG9mIHRoZQorU2NyaXB0cyBwYW5lbCBzaWRlYmFyIHBhbmU6ICI8Y29kZT50 aGlzPC9jb2RlPiIsICI8Y29kZT5hPC9jb2RlPiIsIAorIjxjb2RlPmI8L2NvZGU+IiwgIjxjb2Rl PmM8L2NvZGU+IiBhbmQgIjxjb2RlPmQ8L2NvZGU+Ii4gRG8gPGI+Tk9UPC9iPiBlbnRlciB0aGUg cXVvdGVzLgorCis8bGk+PHA+VGhlIHZhbHVlcyBvZiB0aGUgZXhwcmVzc2lvbnMgYXMgc2hvd24g aW4gdGhlIHdpbmRvdyBzaG91bGQgYSAKKzxjb2RlPkRPTVdpbmRvdzwvY29kZT4gZm9yIDxjb2Rl PnRoaXM8L2NvZGU+LCA8Y29kZT51bmRlZmluZWQ8L2NvZGU+IGZvcgordGhlIDxjb2RlPmE8L2Nv ZGU+LCA8Y29kZT5iPC9jb2RlPiwgYW5kIDxjb2RlPmM8L2NvZGU+IHZhcmlhYmxlcywgYW5kIGEg Cit2YWx1ZSBvZiA8Y29kZT5SZWZlcmVuY2VFcnJvcjogQ2FuJ3QgZmluZCB2YXJpYWJsZTogZDwv Y29kZT4KK2ZvciB0aGUgPGNvZGU+ZDwvY29kZT4gdmFyaWFibGUuCisKKzxsaT48cD5Ob3RlIHRo YXQgdGhlIHZhbHVlIGZvciA8Y29kZT5kPC9jb2RlPiBzaG91bGQgbm90IGNoYW5nZSBmb3IgdGhl IGxpZmUgb2YgCit0aGUgdGVzdCwgYXMgdGhlIHZhcmlhYmxlIDxjb2RlPmQ8L2NvZGU+IGlzIG5l dmVyIGludHJvZHVjZWQgaW4gdGhlIHByb2dyYW0uCisKKzxsaT48cD5TdGVwIHRocm91Z2ggdGhl IGNvZGUsIGFuZCB5b3UnbGwgc2VlIHRoZSB2YWx1ZXMgb2YgPGNvZGU+YTwvY29kZT4sCis8Y29k ZT5iPC9jb2RlPiwgYW5kIDxjb2RlPmM8L2NvZGU+IGNoYW5nZSwgYXMgdGhlIHZhcmlhYmxlcyBh cmUgYXNzaWduZWQuCitBbHNvIG5vdGUgdGhhdCBhcyB0aGUgc2NvcGUgY2hhbmdlcyBkdWUgdG8g dGhlIGZ1bmN0aW9uIGludm9jYXRpb24sIHZhbHVlcword2lsbCBiZSBjaGFuZ2VkIHRvIHJlZmVy IHRvIHRoZWlyIGN1cnJlbnQgc2NvcGUuICBUaGUgPGNvZGU+dGhpczwvY29kZT4KK2V4cHJlc3Np b24gd2lsbCBjaGFuZ2Ugd2hlbiB0aGUgbWV0aG9kIGlzIGludm9rZWQgb24gdGhlIG9iamVjdCBj b25zdHJ1Y3RlZCBieQordGhlIHRlc3QuCisKKzxsaT48cD5DbGljayBkaWZmZXJlbnQgc3RhY2sg ZnJhbWVzIGluIHRoZSBDYWxsIFN0YWNrIHNlY3Rpb24gdG8gZW5zdXJlIHRoZQorZXhwcmVzc2lv bnMgY2hhbmdlIHZhbHVlIGFwcHJvcHJpYXRlbHkgYXMgdGhlIGN1cnJlbnQgc3RhY2sgZnJhbWUg Y2hhbmdlcy4KKworPGxpPjxwPkRyaXZlIHRoZSBkZWJ1Z2dlciB0aHJvdWdoIHRoZSBlbmQgb2Yg dGhlIG91dGVybW9zdCBmdW5jdGlvbiwgc28gdGhhdAordGhlIGRlYnVnZ2VyIGlzIG5vIGxvbmdl ciBpbiBwYXVzZWQgc3RhdGUuICBUaGUgdmFsdWVzIG9mIAorPGNvZGU+YTwvY29kZT4sIDxjb2Rl PmI8L2NvZGU+LCBhbmQgPGNvZGU+YzwvY29kZT4gc2hvdWxkIGFsbCBiZSBhCitSZWZlcmVuY2VF cnJvciBsaWtlIDxjb2RlPmQ8L2NvZGU+LCBzaW5jZSB0aGVzZSB2YXJpYWJsZXMgYXJlIGRlZmlu ZWQgaW4gdGhlCis8Y29kZT5ydW5UZXN0KCk8L2NvZGU+IGZ1bmN0aW9uLCBhbmQgdGhlIGV4cHJl c3Npb25zIGFyZSBiZWluZyBldmFsdWF0ZWQgYWdhaW5zdAordGhlIGdsb2JhbCBvYmplY3QuCisK KzxsaT48cD5Gcm9tIHRoZSBjb25zb2xlLCBleGVjdXRlIHRoZSBzdGF0ZW1lbnQgIjxjb2RlPmEg PSAxPC9jb2RlPiIuICBUaGUKK3dhdGNoIGV4cHJlc3Npb25zIGRvIG5vdCBjdXJyZW50bHkgcmVm cmVzaCwgc28gdGhlIHZhbHVlIGZvciA8Y29kZT5hPC9jb2RlPgorc2hvdWxkIHN0aWxsIGJlIFJl ZmVyZW5jZUVycm9yLgorCis8bGk+PHA+Q2xpY2sgdGhlICJSZWZyZXNoIiBidXR0b24gaW4gdGhl IFdhdGNoIEV4cHJlc3Npb25zIHNlY3Rpb24gYW5kIHRoZQordmFsdWUgZm9yICI8Y29kZT5hPC9j b2RlPiIgc2hvdWxkIG5vdyBiZSAiPGNvZGU+MTwvY29kZT4iLgorCis8bGk+PHA+Q2xvc2UgZG93 biB0aGUgYnJvd3Nlciwgc3RhcnQgaXQgYmFjayB1cCwgdHJhdmVyc2UgdG8gYSB3ZWIgc2l0ZSwK K2JyaW5nIHVwIHdlYiBpbnNwZWN0b3IsIGdvIHRvIHRoZSBTY3JpcHRzIHBhbmVsLiAgWW91IHNo b3VsZCBzZWUgdGhlIHNhbWUKK3NldCBvZiBXYXRjaCBFeHByZXNzaW9ucyBpbiB0aGUgbGlzdCBh cyB5b3UgaGFkIHdoZW4geW91IGxhc3QgdXNlZCB3ZWIKK2luc3BlY3Rvci4KKworPGxpPjxwPkRl bGV0ZSBhbiBleHByZXNzaW9uIGJ5IG1vdmluZyB0aGUgbW91c2UgaW50byB0aGUgV2F0Y2ggRXhw cmVzc2lvbgorc2VjdGlvbiwgYW5kIGNsaWNraW5nIHRoZSBYIGljb24gd2hpY2ggYXBwZWFycyB0 byB0aGUgcmlnaHQgb2YgYW4gCitleHByZXNzaW9uIChvbiBob3ZlcikuCisKKzxsaT48cD5EZWxl dGUgYW4gZXhwcmVzc2lvbiBieSBkb3VibGUtY2xpY2tpbmcgYW55d2hlcmUgb24gYSB0b3AtbGV2 ZWwgbGluZQorb2YgYSB3YXRjaCBleHByZXNzaW9uLCBhbmQgY2hhbmdpbmcgdGhlIGV4cHJlc3Np b24gdG8gYW4gZW1wdHkgc3RyaW5nIG9yIAorbm90aGluZyBidXQgd2hpdGUtc3BhY2UuCisKKzxs aT48cD5Nb2RpZnkgYW4gZW50cnkgYnkgZG91YmxlLWNsaWNraW5nIGFueXdoZXJlIG9uIGEgdG9w LWxldmVsIGxpbmUKK29mIGEgd2F0Y2ggZXhwcmVzc2lvbiwgYW5kIGNoYW5naW5nIHRoZSBleHBy ZXNzaW9uLgorCis8bGk+PHA+RW50ZXIgYSBuZXcgZXhwcmVzc2lvbiwgIjxjb2RlPm5ldyBEYXRl KCk8L2NvZGU+Ii4gIFRoZSB2YWx1ZSBzaG91bGQgYmUKK2EgdG9TdHJpbmcoKSB2ZXJzaW9uIG9m IHRoZSBkYXRlLiAgUmVwZWF0ZWRseSBwcmVzcyB0aGUgUmVmcmVzaCBidXR0b24gdG8gc2VlCit0 aGUgdmFsdWUgdXBkYXRlZCB3aXRoIHRoZSBjdXJyZW50IHRpbWUuCisKKzwvb2w+CisKKzxzY3Jp cHQ+CitmdW5jdGlvbiBydW5UZXN0KCkgeworICAgIAorICAgIC8vIGEgbmVzdGVkIGZ1bmN0aW9u CisgICAgZnVuY3Rpb24gc3ViRnVuY3Rpb24oKSB7CisgICAgICAgIGRlYnVnZ2VyOworICAgICAg ICB2YXIgYSA9ICJhIGluIHN1YkZ1bmN0aW9uKCkiOworICAgICAgICAKKyAgICAgICAgc3ViU3Vi RnVuY3Rpb24oKTsKKyAgICAgICAgCisgICAgICAgIC8vIGFub3RoZXIgbmVzdGVkIGZ1bmN0aW9u CisgICAgICAgIGZ1bmN0aW9uIHN1YlN1YkZ1bmN0aW9uKCkgeworICAgICAgICAgICAgZGVidWdn ZXI7CisgICAgICAgICAgICB2YXIgYiA9ICJiIGluIHN1YlN1YkZ1bmN0aW9uKCkiOworICAgICAg ICB9CisgICAgfQorICAgIAorICAgIC8vIGEgY2xhc3MKKyAgICBmdW5jdGlvbiBhQ2xhc3MoKSB7 CisgICAgICAgIHRoaXMueCA9ICJ4eHgiOworICAgICAgICB0aGlzLnkgPSAieXl5IjsKKyAgICB9 CisgICAgCisgICAgYUNsYXNzLnByb3RvdHlwZS5hTWV0aG9kID0gZnVuY3Rpb24oKSB7CisgICAg ICAgIGRlYnVnZ2VyOworICAgICAgICB2YXIgYyA9ICJjIGluIGFNZXRob2QoKSI7CisgICAgfQor ICAgIAorICAgIC8vIG1haW4gbG9naWMKKyAgICBkZWJ1Z2dlcjsKKyAgICAKKyAgICB2YXIgYSA9 ICJhIGluIHJ1blRlc3QoKSI7CisgICAgdmFyIGIgPSAiYiBpbiBydW5UZXN0KCkiOworICAgIHZh ciBjID0gImMgaW4gcnVuVGVzdCgpIjsKKyAgICAKKyAgICBzdWJGdW5jdGlvbigpOworICAgIAor ICAgIHZhciBvYmplY3QgPSBuZXcgYUNsYXNzKCk7CisgICAgb2JqZWN0LmFNZXRob2QoKTsKKyAg ICAKK30KKzwvc2NyaXB0PgpJbmRleDogV2ViQ29yZS9FbmdsaXNoLmxwcm9qL2xvY2FsaXplZFN0 cmluZ3MuanMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQpDYW5ub3QgZGlzcGxheTogZmlsZSBtYXJrZWQgYXMgYSBiaW5h cnkgdHlwZS4Kc3ZuOm1pbWUtdHlwZSA9IGFwcGxpY2F0aW9uL29jdGV0LXN0cmVhbQoKLy81MkFH RUFjZ0FnQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFJQUE5QUNB QWJnQmxBSGNBSUFCUApBR0lBYWdCbEFHTUFkQUE3QUFvQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdV QVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQWdBQ2dBCkpRQmtBQ2tBSWdCZEFDQUFQUUFnQUNJ QUlBQW9BQ1VBWkFBcEFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnkKQUdr QWJnQm5BSE1BV3dBaUFDQUFLQUJ5QUdVQWNBQmxBR0VBZEFCbEFHUUFJQUFsQUdRQUlBQjBBR2tB YlFCbEFITUFLUUFpQUYwQQpJQUE5QUNBQUlnQWdBQ2dBY2dCbEFIQUFaUUJoQUhRQVpRQmtBQ0FB SlFCa0FDQUFkQUJwQUcwQVpRQnpBQ2tBSWdBN0FBb0FiQUJ2CkFHTUFZUUJzQUdrQWVnQmxBR1FB VXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBSlFBdUFEQUFaZ0JDQUNJQVhRQWdBRDBBSUFBaUFDVUEK TGdBd0FHWUFRZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQWxBQzRBTUFCbQpBRzBBY3dBaUFGMEFJQUE5QUNBQUlnQWxBQzRBTUFCbUFHMEFj d0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBCmNnQnBBRzRBWndCekFGc0FJ Z0FsQUM0QU1RQm1BQ0FBWkFCaEFIa0Fjd0FpQUYwQUlBQTlBQ0FBSWdBbEFDNEFNUUJtQUNBQVpB QmgKQUhrQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3 QnpBRnNBSWdBbEFDNEFNUUJtQUdnQQpjZ0J6QUNJQVhRQWdBRDBBSUFBaUFDVUFMZ0F4QUdZQWFB QnlBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwCkFISUFhUUJ1QUdjQWN3 QmJBQ0lBSlFBdUFERUFaZ0J0QUdrQWJnQWlBRjBBSUFBOUFDQUFJZ0FsQUM0QU1RQm1BRzBBYVFC dUFDSUEKT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dB aUFDVUFMZ0F5QUdZQUpRQWxBQ0lBWFFBZwpBRDBBSUFBaUFDVUFMZ0F5QUdZQUpRQWxBQ0lBT3dB S0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BCld3QWlBQ1VBTGdB eUFHWUFTd0JDQUNJQVhRQWdBRDBBSUFBaUFDVUFMZ0F5QUdZQVN3QkNBQ0lBT3dBS0FHd0Fid0Jq QUdFQWJBQnAKQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBQ1VBTGdBeUFHWUFjd0Fp QUYwQUlBQTlBQ0FBSWdBbEFDNEFNZ0JtQUhNQQpJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0Js QUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQXVBRE1BWmdCTkFFSUFJZ0JkCkFDQUFQUUFn QUNJQUpRQXVBRE1BWmdCTkFFSUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBB SElBYVFCdUFHY0EKY3dCYkFDSUFKUUF1QURNQVpnQnRBSE1BSWdCZEFDQUFQUUFnQUNJQUpRQXVB RE1BWmdCdEFITUFJZ0E3QUFvQWJBQnZBR01BWVFCcwpBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVB R2NBY3dCYkFDSUFKUUJrQUNBQVpRQnlBSElBYndCeUFDSUFYUUFnQUQwQUlBQWlBQ1VBClpBQWdB R1VBY2dCeUFHOEFjZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFH NEFad0J6QUZzQUlnQWwKQUdRQUlBQmxBSElBY2dCdkFISUFMQUFnQUNVQVpBQWdBSGNBWVFCeUFH NEFhUUJ1QUdjQUlnQmRBQ0FBUFFBZ0FDSUFKUUF4QUNRQQpaQUFnQUdVQWNnQnlBRzhBY2dBc0FD QUFKUUF5QUNRQVpBQWdBSGNBWVFCeUFHNEFhUUJ1QUdjQUlnQTdBQW9BYkFCdkFHTUFZUUJzCkFH a0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQmtBQ0FBWlFCeUFISUFid0J5QUN3 QUlBQWxBR1FBSUFCM0FHRUEKY2dCdUFHa0FiZ0JuQUhNQUlnQmRBQ0FBUFFBZ0FDSUFKUUF4QUNR QVpBQWdBR1VBY2dCeUFHOEFjZ0FzQUNBQUpRQXlBQ1FBWkFBZwpBSGNBWVFCeUFHNEFhUUJ1QUdj QWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNB CklnQWxBR1FBSUFCbEFISUFjZ0J2QUhJQWN3QWlBRjBBSUFBOUFDQUFJZ0FsQUdRQUlBQmxBSElB Y2dCdkFISUFjd0FpQURzQUNnQnMKQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRB WndCekFGc0FJZ0FsQUdRQUlBQmxBSElBY2dCdkFISUFjd0FzQUNBQQpKUUJrQUNBQWR3QmhBSElB YmdCcEFHNEFad0FpQUYwQUlBQTlBQ0FBSWdBbEFERUFKQUJrQUNBQVpRQnlBSElBYndCeUFITUFM QUFnCkFDVUFNZ0FrQUdRQUlBQjNBR0VBY2dCdUFHa0FiZ0JuQUNJQU93QUtBR3dBYndCakFHRUFi QUJwQUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFXd0FpQUNVQVpBQWdBR1VBY2dCeUFHOEFj Z0J6QUN3QUlBQWxBR1FBSUFCM0FHRUFjZ0J1QUdrQWJnQm5BSE1BSWdCZApBQ0FBUFFBZ0FDSUFK UUF4QUNRQVpBQWdBR1VBY2dCeUFHOEFjZ0J6QUN3QUlBQWxBRElBSkFCa0FDQUFkd0JoQUhJQWJn QnBBRzRBClp3QnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJn Qm5BSE1BV3dBaUFDVUFaQUFnQUcwQVlRQjAKQUdNQWFBQmxBSE1BSWdCZEFDQUFQUUFnQUNJQUpR QmtBQ0FBYlFCaEFIUUFZd0JvQUdVQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QQphUUI2QUdVQVpB QlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQWxBR1FBSUFCekFIUUFlUUJzQUdVQUlBQmpBR2dBWVFC dUFHY0FaUUFpCkFGMEFJQUE5QUNBQUlnQWxBR1FBSUFCekFIUUFlUUJzQUdVQUlBQmpBR2dBWVFC dUFHY0FaUUFpQURzQUNnQnNBRzhBWXdCaEFHd0EKYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndC ekFGc0FJZ0FsQUdRQUlBQnpBSFFBZVFCc0FHVUFJQUJqQUdnQVlRQnVBR2NBWlFCegpBQ0lBWFFB Z0FEMEFJQUFpQUNVQVpBQWdBSE1BZEFCNUFHd0FaUUFnQUdNQWFBQmhBRzRBWndCbEFITUFJZ0E3 QUFvQWJBQnZBR01BCllRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFKUUJr QUNBQWR3QmhBSElBYmdCcEFHNEFad0FpQUYwQUlBQTkKQUNBQUlnQWxBR1FBSUFCM0FHRUFjZ0J1 QUdrQWJnQm5BQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0Ju QUhNQVd3QWlBQ1VBWkFBZ0FIY0FZUUJ5QUc0QWFRQnVBR2NBY3dBaUFGMEFJQUE5QUNBQUlnQWxB R1FBSUFCM0FHRUFjZ0J1CkFHa0FiZ0JuQUhNQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxB R1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBSlFCa0FDQUEKMXdBZ0FDVUFaQUFpQUYwQUlBQTlB Q0FBSWdBbEFERUFKQUJrQUNBQTF3QWdBQ1VBTWdBa0FHUUFJZ0E3QUFvQWJBQnZBR01BWVFCcwpB R2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFKUUJ6QUNBQUtBQm1BSElBYndCdEFD QUFZd0JoQUdNQWFBQmxBQ2tBCklnQmRBQ0FBUFFBZ0FDSUFKUUJ6QUNBQUtBQm1BSElBYndCdEFD QUFZd0JoQUdNQWFBQmxBQ2tBSWdBN0FBb0FiQUJ2QUdNQVlRQnMKQUdrQWVnQmxBR1FBVXdCMEFI SUFhUUJ1QUdjQWN3QmJBQ0lBSlFCekFDQUFaQUJ2QUhjQWJnQnNBRzhBWVFCa0FDSUFYUUFnQUQw QQpJQUFpQUNVQWN3QWdBR1FBYndCM0FHNEFiQUJ2QUdFQVpBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3 QWFRQjZBR1VBWkFCVEFIUUFjZ0JwCkFHNEFad0J6QUZzQUlnQWxBSE1BSUFCc0FHRUFkQUJsQUc0 QVl3QjVBQ0lBWFFBZ0FEMEFJQUFpQUNVQWN3QWdBR3dBWVFCMEFHVUEKYmdCakFIa0FJZ0E3QUFv QWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQnpBQ0FB YkFCaApBSFFBWlFCdUFHTUFlUUFzQUNBQUpRQnpBQ0FBWkFCdkFIY0FiZ0JzQUc4QVlRQmtBQ0FB S0FBbEFITUFJQUIwQUc4QWRBQmhBR3dBCktRQWlBRjBBSUFBOUFDQUFJZ0FsQURFQUpBQnpBQ0FB YkFCaEFIUUFaUUJ1QUdNQWVRQXNBQ0FBSlFBeUFDUUFjd0FnQUdRQWJ3QjMKQUc0QWJBQnZBR0VB WkFBZ0FDZ0FKUUF6QUNRQWN3QWdBSFFBYndCMEFHRUFiQUFwQUNJQU93QUtBR3dBYndCakFHRUFi QUJwQUhvQQpaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUNnQVlRQnVBRzhBYmdCNUFHMEFi d0IxQUhNQUlBQm1BSFVBYmdCakFIUUFhUUJ2CkFHNEFLUUFpQUYwQUlBQTlBQ0FBSWdBb0FHRUFi Z0J2QUc0QWVRQnRBRzhBZFFCekFDQUFaZ0IxQUc0QVl3QjBBR2tBYndCdUFDa0EKSWdBN0FBb0Fi QUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFLQUJ3QUhJQWJ3 Qm5BSElBWVFCdApBQ2tBSWdCZEFDQUFQUUFnQUNJQUtBQndBSElBYndCbkFISUFZUUJ0QUNrQUln QTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBClV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUtB QndBSElBYndCbkFISUFZUUJ0QUNrQU9nQWdBQ1VBY3dBaUFGMEFJQUE5QUNBQUlnQW8KQUhBQWNn QnZBR2NBY2dCaEFHMEFLUUE2QUNBQUpRQnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFC a0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlBQ2dBZEFCbEFIZ0FkQUFwQUNJQVhRQWdBRDBBSUFB aUFDZ0FkQUJsQUhnQWRBQXBBQ0lBT3dBS0FHd0Fid0JqCkFHRUFiQUJwQUhvQVpRQmtBRk1BZEFC eUFHa0FiZ0JuQUhNQVd3QWlBQ2dBZHdCb0FHa0FkQUJsQUhNQWNBQmhBR01BWlFBcEFDSUEKWFFB Z0FEMEFJQUFpQUNnQWR3Qm9BR2tBZEFCbEFITUFjQUJoQUdNQVpRQXBBQ0lBT3dBS0FHd0Fid0Jq QUdFQWJBQnBBSG9BWlFCawpBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBREVBSUFCdEFHRUFkQUJq QUdnQUlnQmRBQ0FBUFFBZ0FDSUFNUUFnQUcwQVlRQjBBR01BCmFBQWlBRHNBQ2dCc0FHOEFZd0Jo QUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCQkFHd0FiQUFpQUYwQUlBQTkK QUNBQUlnQkJBR3dBYkFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBB RzRBWndCekFGc0FJZ0JCQUd3QQpkd0JoQUhrQWN3QWdBR1VBYmdCaEFHSUFiQUJsQUNJQVhRQWdB RDBBSUFBaUFFRUFiQUIzQUdFQWVRQnpBQ0FBWlFCdUFHRUFZZ0JzCkFHVUFJZ0E3QUFvQWJBQnZB R01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVFRQnVBQ0FBWlFCeUFI SUEKYndCeUFDQUFid0JqQUdNQWRRQnlBSElBWlFCa0FDQUFkQUJ5QUhrQWFRQnVBR2NBSUFCMEFH OEFYQUJ1QUhJQVpRQmhBR1FBSUFCMApBR2dBWlFBZ0FCd2dKUUJ6QUIwZ0lBQjBBR0VBWWdCc0FH VUFMZ0FpQUYwQUlBQTlBQ0FBSWdCQkFHNEFJQUJsQUhJQWNnQnZBSElBCklBQnZBR01BWXdCMUFI SUFjZ0JsQUdRQUlBQjBBSElBZVFCcEFHNEFad0FnQUhRQWJ3QmNBRzRBY2dCbEFHRUFaQUFnQUhR QWFBQmwKQUNBQUhDQWxBSE1BSFNBZ0FIUUFZUUJpQUd3QVpRQXVBQ0lBT3dBS0FHd0Fid0JqQUdF QWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlBRUVBYmdBZ0FIVUFiZ0JsQUhn QWNBQmxBR01BZEFCbEFHUUFJQUJsQUhJQWNnQnZBSElBSUFBbEFITUFJQUJ2CkFHTUFZd0IxQUhJ QWNnQmxBR1FBTGdBaUFGMEFJQUE5QUNBQUlnQkJBRzRBSUFCMUFHNEFaUUI0QUhBQVpRQmpBSFFB WlFCa0FDQUEKWlFCeUFISUFid0J5QUNBQUpRQnpBQ0FBYndCakFHTUFkUUJ5QUhJQVpRQmtBQzRB SWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbApBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lB UVFCMkFHVUFjZ0JoQUdjQVpRQWlBRjBBSUFBOUFDQUFJZ0JCQUhZQVpRQnlBR0VBClp3QmxBQ0lB T3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFSUFj Z0JsQUdFQWF3QncKQUc4QWFRQnVBSFFBY3dBaUFGMEFJQUE5QUNBQUlnQkNBSElBWlFCaEFHc0Fj QUJ2QUdrQWJnQjBBSE1BSWdBN0FBb0FiQUJ2QUdNQQpZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFh UUJ1QUdjQWN3QmJBQ0lBUXdCUEFFOEFTd0JKQUVVQVV3QWlBRjBBSUFBOUFDQUFJZ0JECkFFOEFU d0JMQUVrQVJRQlRBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJn Qm5BSE1BV3dBaUFFTUEKWVFCc0FHd0FJQUJUQUhRQVlRQmpBR3NBSWdCZEFDQUFQUUFnQUNJQVF3 QmhBR3dBYkFBZ0FGTUFkQUJoQUdNQWF3QWlBRHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpB QlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkRBR0VBYkFCc0FITUFJZ0JkQUNBQVBRQWdBQ0lBClF3 QmhBR3dBYkFCekFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdC bkFITUFXd0FpQUVNQWJBQmwKQUdFQWNnQWdBR01BYUFCaEFHNEFad0JsQUhNQUlBQnNBRzhBWndB dUFDSUFYUUFnQUQwQUlBQWlBRU1BYkFCbEFHRUFjZ0FnQUdNQQphQUJoQUc0QVp3QmxBSE1BSUFC c0FHOEFad0F1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju CkFITUFXd0FpQUVNQWJBQmxBR0VBY2dBZ0FHTUFid0J1QUhNQWJ3QnNBR1VBSUFCc0FHOEFad0F1 QUNJQVhRQWdBRDBBSUFBaUFFTUEKYkFCbEFHRUFjZ0FnQUdNQWJ3QnVBSE1BYndCc0FHVUFJQUJz QUc4QVp3QXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCawpBRk1BZEFCeUFHa0FiZ0Ju QUhNQVd3QWlBRU1BYkFCdkFITUFkUUJ5QUdVQUlnQmRBQ0FBUFFBZ0FDSUFRd0JzQUc4QWN3QjFB SElBClpRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpB RnNBSWdCREFHOEFiUUJ3QUhVQWRBQmwKQUdRQUlBQlRBSFFBZVFCc0FHVUFJZ0JkQUNBQVBRQWdB Q0lBUXdCdkFHMEFjQUIxQUhRQVpRQmtBQ0FBVXdCMEFIa0FiQUJsQUNJQQpPd0FLQUd3QWJ3QmpB R0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVNQWJ3QnZBR3NBYVFCbEFI TUFJZ0JkCkFDQUFQUUFnQUNJQVF3QnZBRzhBYXdCcEFHVUFjd0FpQURzQUNnQnNBRzhBWXdCaEFH d0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEEKWndCekFGc0FJZ0JFQUVFQVZBQkJBRUlBUVFCVEFF VUFVd0FpQUYwQUlBQTlBQ0FBSWdCRUFFRUFWQUJCQUVJQVFRQlRBRVVBVXdBaQpBRHNBQ2dCc0FH OEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCRUFFOEFUUUFpQUYw QUlBQTlBQ0FBCklnQkVBRThBVFFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JFQUdFQWRBQmgKQUdJQVlRQnpBR1VBSUFCdUFHOEFJQUJzQUc4 QWJnQm5BR1VBY2dBZ0FHZ0FZUUJ6QUNBQVpRQjRBSEFBWlFCakFIUUFaUUJrQUNBQQpkZ0JsQUhJ QWN3QnBBRzhBYmdBdUFDSUFYUUFnQUQwQUlBQWlBRVFBWVFCMEFHRUFZZ0JoQUhNQVpRQWdBRzRB YndBZ0FHd0Fid0J1CkFHY0FaUUJ5QUNBQWFBQmhBSE1BSUFCbEFIZ0FjQUJsQUdNQWRBQmxBR1FB SUFCMkFHVUFjZ0J6QUdrQWJ3QnVBQzRBSWdBN0FBb0EKYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FB VXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCawpBR2tB Y3dCaEFHSUFiQUJsQUdRQUxnQWdBRU1BYkFCcEFHTUFhd0FnQUhRQWJ3QWdBR1VBYmdCaEFHSUFi QUJsQUM0QUlnQmRBQ0FBClBRQWdBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCa0FHa0Fj d0JoQUdJQWJBQmxBR1FBTGdBZ0FFTUFiQUJwQUdNQWF3QWcKQUhRQWJ3QWdBR1VBYmdCaEFHSUFi QUJsQUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQQpj d0JiQUNJQVJBQmxBR0lBZFFCbkFHY0FhUUJ1QUdjQUlBQmxBRzRBWVFCaUFHd0FaUUJrQUM0QUlB QkRBR3dBYVFCakFHc0FJQUIwCkFHOEFJQUJrQUdrQWN3QmhBR0lBYkFCbEFDNEFJZ0JkQUNBQVBR QWdBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCbEFHNEEKWVFCaUFHd0FaUUJrQUM0QUlB QkRBR3dBYVFCakFHc0FJQUIwQUc4QUlBQmtBR2tBY3dCaEFHSUFiQUJsQUM0QUlnQTdBQW9BYkFC dgpBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVJBQmxBR0lBZFFC bkFHY0FhUUJ1QUdjQUlBQnpBR01BCmNnQnBBSEFBZEFCekFDQUFjZ0JsQUhFQWRRQnBBSElBWlFC ekFDQUFlUUJ2QUhVQUlBQjBBRzhBSUFCekFIUUFZUUJ5QUhRQUlBQjAKQUdnQVpRQWdBR1FBWlFC aUFIVUFad0JuQUdVQWNnQXVBQ0lBWFFBZ0FEMEFJQUFpQUVRQVpRQmlBSFVBWndCbkFHa0FiZ0Ju QUNBQQpjd0JqQUhJQWFRQndBSFFBY3dBZ0FISUFaUUJ4QUhVQWFRQnlBR1VBY3dBZ0FIa0Fid0Ix QUNBQWRBQnZBQ0FBY3dCMEFHRUFjZ0IwCkFDQUFkQUJvQUdVQUlBQmtBR1VBWWdCMUFHY0Fad0Js QUhJQUxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUEKY2dCcEFHNEFad0J6 QUZzQUlnQkVBR1VBYkFCbEFIUUFaUUFpQUYwQUlBQTlBQ0FBSWdCRUFHVUFiQUJsQUhRQVpRQWlB RHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkVB R2tBYlFCbEFHNEFjd0JwQUc4QWJnQnpBQ0lBClhRQWdBRDBBSUFBaUFFUUFhUUJ0QUdVQWJnQnpB R2tBYndCdUFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjAKQUhJQWFRQnVB R2NBY3dCYkFDSUFSQUJ2QUdNQWF3QWdBSFFBYndBZ0FHMEFZUUJwQUc0QUlBQjNBR2tBYmdCa0FH OEFkd0F1QUNJQQpYUUFnQUQwQUlBQWlBRVFBYndCakFHc0FJQUIwQUc4QUlBQnRBR0VBYVFCdUFD QUFkd0JwQUc0QVpBQnZBSGNBTGdBaUFEc0FDZ0JzCkFHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFI UUFjZ0JwQUc0QVp3QnpBRnNBSWdCRUFHOEFZd0IxQUcwQVpRQnVBSFFBY3dBaUFGMEEKSUFBOUFD QUFJZ0JFQUc4QVl3QjFBRzBBWlFCdUFIUUFjd0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdV QVpBQlRBSFFBY2dCcApBRzRBWndCekFGc0FJZ0JFQUc4QWJRQmhBR2tBYmdBaUFGMEFJQUE5QUNB QUlnQkVBRzhBYlFCaEFHa0FiZ0FpQURzQUNnQnNBRzhBCll3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JFQUc4QWJnQW5BSFFBSUFCd0FHRUFkUUJ6QUdVQUlBQnYKQUc0 QUlBQmxBSGdBWXdCbEFIQUFkQUJwQUc4QWJnQnpBQzRBSWdCZEFDQUFQUUFnQUNJQVJBQnZBRzRB R1NCMEFDQUFjQUJoQUhVQQpjd0JsQUNBQWJ3QnVBQ0FBWlFCNEFHTUFaUUJ3QUhRQWFRQnZBRzRB Y3dBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrCkFGTUFkQUJ5QUdrQWJnQm5BSE1B V3dBaUFFUUFid0IxQUdJQWJBQmxBQzBBUXdCc0FHa0FZd0JyQUNBQWRBQnZBQ0FBUVFCa0FHUUEK SWdCZEFDQUFQUUFnQUNJQVJBQnZBSFVBWWdCc0FHVUFMUUJEQUd3QWFRQmpBR3NBSUFCMEFHOEFJ QUJCQUdRQVpBQWlBRHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQkVBRzhBZFFCaUFHd0FaUUF0QUVNQWJBQnBBR01BCmF3QWdBSFFBYndBZ0FIUUFi d0JuQUdjQWJBQmxBQ0FBWWdCbEFIUUFkd0JsQUdVQWJnQWdBRlVBVWdCTUFDQUFaUUJ1QUdNQWJ3 QmsKQUdVQVpBQWdBR0VBYmdCa0FDQUFaQUJsQUdNQWJ3QmtBR1VBWkFBZ0FHWUFid0J5QUcwQVlR QjBBSE1BSWdCZEFDQUFQUUFnQUNJQQpSQUJ2QUhVQVlnQnNBR1VBTFFCREFHd0FhUUJqQUdzQUlB QjBBRzhBSUFCMEFHOEFad0JuQUd3QVpRQWdBR0lBWlFCMEFIY0FaUUJsCkFHNEFJQUJWQUZJQVRB QWdBR1VBYmdCakFHOEFaQUJsQUdRQUlBQmhBRzRBWkFBZ0FHUUFaUUJqQUc4QVpBQmxBR1FBSUFC bUFHOEEKY2dCdEFHRUFkQUJ6QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFC eUFHa0FiZ0JuQUhNQVd3QWlBRVVBYkFCbApBRzBBWlFCdUFIUUFjd0FpQUYwQUlBQTlBQ0FBSWdC RkFHd0FaUUJ0QUdVQWJnQjBBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBCmVnQmxBR1FBVXdC MEFISUFhUUJ1QUdjQWN3QmJBQ0lBUlFCdUFHRUFZZ0JzQUdVQUlBQkVBR1VBWWdCMUFHY0Fad0Jw QUc0QVp3QWkKQUYwQUlBQTlBQ0FBSWdCRkFHNEFZUUJpQUd3QVpRQWdBRVFBWlFCaUFIVUFad0Ju QUdrQWJnQm5BQ0lBT3dBS0FHd0Fid0JqQUdFQQpiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju QUhNQVd3QWlBRVVBYmdCaEFHSUFiQUJsQUNBQVVBQnlBRzhBWmdCcEFHd0FhUUJ1CkFHY0FJZ0Jk QUNBQVBRQWdBQ0lBUlFCdUFHRUFZZ0JzQUdVQUlBQlFBSElBYndCbUFHa0FiQUJwQUc0QVp3QWlB RHNBQ2dCc0FHOEEKWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkZB RzRBWVFCaUFHd0FaUUFnQUhJQVpRQnpBRzhBZFFCeQpBR01BWlFBZ0FIUUFjZ0JoQUdNQWF3QnBB RzRBWndBaUFGMEFJQUE5QUNBQUlnQkZBRzRBWVFCaUFHd0FaUUFnQUhJQVpRQnpBRzhBCmRRQnlB R01BWlFBZ0FIUUFjZ0JoQUdNQWF3QnBBRzRBWndBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFH VUFaQUJUQUhRQWNnQnAKQUc0QVp3QnpBRnNBSWdCRkFHNEFZUUJpQUd3QWFRQnVBR2NBSUFCa0FH VUFZZ0IxQUdjQVp3QnBBRzRBWndBZ0FIY0FhUUJzQUd3QQpJQUJ0QUdFQWF3QmxBQ0FBY3dCakFI SUFhUUJ3QUhRQWN3QWdBSElBZFFCdUFDQUFjd0JzQUc4QWR3QmxBSElBTGdBaUFGMEFJQUE5CkFD QUFJZ0JGQUc0QVlRQmlBR3dBYVFCdUFHY0FJQUJrQUdVQVlnQjFBR2NBWndCcEFHNEFad0FnQUhj QWFRQnNBR3dBSUFCdEFHRUEKYXdCbEFDQUFjd0JqQUhJQWFRQndBSFFBY3dBZ0FISUFkUUJ1QUNB QWN3QnNBRzhBZHdCbEFISUFMZ0FpQURzQUNnQnNBRzhBWXdCaApBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnBBRzRBWndCekFGc0FJZ0JGQUc0QVlRQmlBR3dBYVFCdUFHY0FJQUJ3QUhJQWJ3Qm1BR2tB CmJBQnBBRzRBWndBZ0FIY0FhUUJzQUd3QUlBQnRBR0VBYXdCbEFDQUFjd0JqQUhJQWFRQndBSFFB Y3dBZ0FISUFkUUJ1QUNBQWN3QnMKQUc4QWR3QmxBSElBTGdBaUFGMEFJQUE5QUNBQUlnQkZBRzRB WVFCaUFHd0FhUUJ1QUdjQUlBQndBSElBYndCbUFHa0FiQUJwQUc0QQpad0FnQUhjQWFRQnNBR3dB SUFCdEFHRUFhd0JsQUNBQWN3QmpBSElBYVFCd0FIUUFjd0FnQUhJQWRRQnVBQ0FBY3dCc0FHOEFk d0JsCkFISUFMZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQkZBRzRBWVFCaUFHd0EKYVFCdUFHY0FJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFJ QUIwQUhJQVlRQmpBR3NBYVFCdUFHY0FJQUIzQUdrQWJBQnNBQ0FBY2dCbApBR3dBYndCaEFHUUFJ QUIwQUdnQVpRQWdBSEFBWVFCbkFHVUFJQUJoQUc0QVpBQWdBRzBBWVFCckFHVUFJQUJ3QUdFQVp3 QmxBQ0FBCmJBQnZBR0VBWkFCcEFHNEFad0FnQUhNQWJBQnZBSGNBWlFCeUFDNEFJZ0JkQUNBQVBR QWdBQ0lBUlFCdUFHRUFZZ0JzQUdrQWJnQm4KQUNBQWNnQmxBSE1BYndCMUFISUFZd0JsQUNBQWRB QnlBR0VBWXdCckFHa0FiZ0JuQUNBQWR3QnBBR3dBYkFBZ0FISUFaUUJzQUc4QQpZUUJrQUNBQWRB Qm9BR1VBSUFCd0FHRUFad0JsQUNBQVlRQnVBR1FBSUFCdEFHRUFhd0JsQUNBQWNBQmhBR2NBWlFB Z0FHd0Fid0JoCkFHUUFhUUJ1QUdjQUlBQnpBR3dBYndCM0FHVUFjZ0F1QUNJQU93QUtBR3dBYndC akFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFXd0FpQUVVQWRnQmxBRzRBZEFB Z0FFUUFid0JqQUhVQWJRQmxBRzRBZEFBaUFGMEFJQUE5QUNBQUlnQkZBSFlBWlFCdQpBSFFBSUFC RUFHOEFZd0IxQUcwQVpRQnVBSFFBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0Iw QUhJQWFRQnVBR2NBCmN3QmJBQ0lBUlFCMkFHVUFiZ0IwQUNBQVZBQmhBSElBWndCbEFIUUFJZ0Jk QUNBQVBRQWdBQ0lBUlFCMkFHVUFiZ0IwQUNBQVZBQmgKQUhJQVp3QmxBSFFBSWdBN0FBb0FiQUJ2 QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFSUUI0QUdNQQpiQUIx QUdRQVpRQWdBSE1BWlFCc0FHVUFZd0IwQUdVQVpBQWdBR1lBZFFCdUFHTUFkQUJwQUc4QWJnQXVB Q0lBWFFBZ0FEMEFJQUFpCkFFVUFlQUJqQUd3QWRRQmtBR1VBSUFCekFHVUFiQUJsQUdNQWRBQmxB R1FBSUFCbUFIVUFiZ0JqQUhRQWFRQnZBRzRBTGdBaUFEc0EKQ2dCc0FHOEFZd0JoQUd3QWFRQjZB R1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCRkFIZ0FjQUJwQUhJQVpRQnpBQ0lBWFFBZwpB RDBBSUFBaUFFVUFlQUJ3QUdrQWNnQmxBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFH UUFVd0IwQUhJQWFRQnVBR2NBCmN3QmJBQ0lBUmdCcEFHd0FaUUFnQUhNQWFRQjZBR1VBSWdCZEFD QUFQUUFnQUNJQVJnQnBBR3dBWlFBZ0FITUFhUUI2QUdVQUlnQTcKQUFvQWJBQnZBR01BWVFCc0FH a0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVJnQnZBR01BZFFCekFDQUFjd0JsQUd3 QQpaUUJqQUhRQVpRQmtBQ0FBWmdCMUFHNEFZd0IwQUdrQWJ3QnVBQzRBSWdCZEFDQUFQUUFnQUNJ QVJnQnZBR01BZFFCekFDQUFid0J1CkFDQUFjd0JsQUd3QVpRQmpBSFFBWlFCa0FDQUFaZ0IxQUc0 QVl3QjBBR2tBYndCdUFDNEFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0EKZWdCbEFHUUFVd0IwQUhJ QWFRQnVBR2NBY3dCYkFDSUFSZ0J2QUc0QWRBQnpBQ0lBWFFBZ0FEMEFJQUFpQUVZQWJ3QnVBSFFB Y3dBaQpBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNB SWdCR0FHOEFjZ0J0QUNBQVJBQmhBSFFBCllRQWlBRjBBSUFBOUFDQUFJZ0JHQUc4QWNnQnRBQ0FB UkFCaEFIUUFZUUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlQKQUhRQWNnQnBBRzRB WndCekFGc0FJZ0JHQUhVQWJnQmpBSFFBYVFCdkFHNEFJZ0JkQUNBQVBRQWdBQ0lBUmdCMUFHNEFZ d0IwQUdrQQpid0J1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0Fi Z0JuQUhNQVd3QWlBRWNBVWdCQkFGQUFTQUJUCkFDSUFYUUFnQUQwQUlBQWlBRWNBVWdCQkFGQUFT QUJUQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFX d0FpQUVjQWJBQnZBR0lBWVFCc0FDSUFYUUFnQUQwQUlBQWlBRWNBYkFCdkFHSUFZUUJzQUNJQU93 QUtBR3dBYndCagpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVnQVZB QlVBRkFBSWdCZEFDQUFQUUFnQUNJQVNBQlVBRlFBClVBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFR QjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCSUFHVUFZUUIyQUhrQUlBQW8KQUVJQWJ3 QjBBSFFBYndCdEFDQUFWUUJ3QUNrQUlnQmRBQ0FBUFFBZ0FDSUFTQUJsQUdFQWRnQjVBQ0FBS0FC Q0FHOEFkQUIwQUc4QQpiUUFnQUZVQWNBQXBBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFC a0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFZ0FhUUJrCkFHVUFJQUJqQUdnQVlRQnVBR2NBWlFC ekFDQUFkZ0JwQUdVQWR3QXVBQ0lBWFFBZ0FEMEFJQUFpQUVnQWFRQmtBR1VBSUFCakFHZ0EKWVFC dUFHY0FaUUJ6QUNBQWRnQnBBR1VBZHdBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJr QUZNQWRBQnlBR2tBYmdCbgpBSE1BV3dBaUFFZ0FhUUJrQUdVQUlBQmpBRzhBYmdCekFHOEFiQUJs QUM0QUlnQmRBQ0FBUFFBZ0FDSUFTQUJwQUdRQVpRQWdBR01BCmJ3QnVBSE1BYndCc0FHVUFMZ0Fp QURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkoK QUcwQVlRQm5BR1VBY3dBaUFGMEFJQUE5QUNBQUlnQkpBRzBBWVFCbkFHVUFjd0FpQURzQUNnQnNB RzhBWXdCaEFHd0FhUUI2QUdVQQpaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JMQUdVQWVRQWlB RjBBSUFBOUFDQUFJZ0JMQUdVQWVRQWlBRHNBQ2dCc0FHOEFZd0JoCkFHd0FhUUI2QUdVQVpBQlRB SFFBY2dCcEFHNEFad0J6QUZzQUlnQk1BRThBUXdCQkFFd0FJQUJUQUZRQVR3QlNBRUVBUndCRkFD SUEKWFFBZ0FEMEFJQUFpQUV3QVR3QkRBRUVBVEFBZ0FGTUFWQUJQQUZJQVFRQkhBRVVBSWdBN0FB b0FiQUJ2QUdNQVlRQnNBR2tBZWdCbApBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVEFCdkFH TUFZUUJzQUNJQVhRQWdBRDBBSUFBaUFFd0Fid0JqQUdFQWJBQWlBRHNBCkNnQnNBRzhBWXdCaEFH d0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQk5BRWtBVFFCRkFDQUFkQUI1QUhB QVpRQWkKQUYwQUlBQTlBQ0FBSWdCTkFFa0FUUUJGQUNBQWRBQjVBSEFBWlFBaUFEc0FDZ0JzQUc4 QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQQpjZ0JwQUc0QVp3QnpBRnNBSWdCTkFHVUFkQUJ5QUdr QVl3QnpBQ0lBWFFBZ0FEMEFJQUFpQUUwQVpRQjBBSElBYVFCakFITUFJZ0E3CkFBb0FiQUJ2QUdN QVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFUZ0JoQUcwQVpRQWlBRjBB SUFBOUFDQUEKSWdCT0FHRUFiUUJsQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1B ZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRTRBWlFCMwpBQ0FBVXdCMEFIa0FiQUJsQUNBQVVnQjFBR3dB WlFBaUFGMEFJQUE5QUNBQUlnQk9BR1VBZHdBZ0FGTUFkQUI1QUd3QVpRQWdBRklBCmRRQnNBR1VB SWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFU Z0J2QUNBQVFnQnkKQUdVQVlRQnJBSEFBYndCcEFHNEFkQUJ6QUNJQVhRQWdBRDBBSUFBaUFFNEFi d0FnQUVJQWNnQmxBR0VBYXdCd0FHOEFhUUJ1QUhRQQpjd0FpQURzQUNnQnNBRzhBWXdCaEFHd0Fh UUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQk9BRzhBSUFCUUFISUFid0J3CkFHVUFj Z0IwQUdrQVpRQnpBQ0lBWFFBZ0FEMEFJQUFpQUU0QWJ3QWdBRkFBY2dCdkFIQUFaUUJ5QUhRQWFR QmxBSE1BSWdBN0FBb0EKYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3 QmJBQ0lBVGdCdkFDQUFWZ0JoQUhJQWFRQmhBR0lBYkFCbApBSE1BSWdCZEFDQUFQUUFnQUNJQVRn QnZBQ0FBVmdCaEFISUFhUUJoQUdJQWJBQmxBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBCmVn QmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVGdCdkFIUUFJQUJHQUc4QWRRQnVBR1FBSWdC ZEFDQUFQUUFnQUNJQVRnQnYKQUhRQUlBQkdBRzhBZFFCdUFHUUFJZ0E3QUFvQWJBQnZBR01BWVFC c0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQQpUZ0J2QUhRQUlBQlFBR0VBZFFC ekFHVUFaQUFpQUYwQUlBQTlBQ0FBSWdCT0FHOEFkQUFnQUZBQVlRQjFBSE1BWlFCa0FDSUFPd0FL CkFHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFOEFiZ0Jz QUhrQUlBQmxBRzRBWVFCaUFHd0EKWlFBZ0FHWUFid0J5QUNBQWRBQm9BR2tBY3dBZ0FITUFaUUJ6 QUhNQWFRQnZBRzRBSWdCZEFDQUFQUUFnQUNJQVR3QnVBR3dBZVFBZwpBR1VBYmdCaEFHSUFiQUJs QUNBQVpnQnZBSElBSUFCMEFHZ0FhUUJ6QUNBQWN3QmxBSE1BY3dCcEFHOEFiZ0FpQURzQUNnQnNB RzhBCll3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JQQUhRQWFBQmxB SElBSWdCZEFDQUFQUUFnQUNJQVR3QjAKQUdnQVpRQnlBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBB SG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGQUFZUUIwQUdnQQpJZ0JkQUNBQVBRQWdB Q0lBVUFCaEFIUUFhQUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFH NEFad0J6CkFGc0FJZ0JRQUdFQWRRQnpBR1VBSUFCdkFHNEFJQUJsQUhnQVl3QmxBSEFBZEFCcEFH OEFiZ0J6QUM0QUlnQmRBQ0FBUFFBZ0FDSUEKVUFCaEFIVUFjd0JsQUNBQWJ3QnVBQ0FBWlFCNEFH TUFaUUJ3QUhRQWFRQnZBRzRBY3dBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcApBSG9BWlFCa0FG TUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGQUFZUUIxQUhNQVpRQWdBSE1BWXdCeUFHa0FjQUIwQUNB QVpRQjRBR1VBCll3QjFBSFFBYVFCdkFHNEFMZ0FpQUYwQUlBQTlBQ0FBSWdCUUFHRUFkUUJ6QUdV QUlBQnpBR01BY2dCcEFIQUFkQUFnQUdVQWVBQmwKQUdNQWRRQjBBR2tBYndCdUFDNEFJZ0E3QUFv QWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQQpVQUJoQUhV QWN3QmxBR1FBSWdCZEFDQUFQUUFnQUNJQVVBQmhBSFVBY3dCbEFHUUFJZ0E3QUFvQWJBQnZBR01B WVFCc0FHa0FlZ0JsCkFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVQUJoQUhVQWN3QnBBRzRB WndBaUFGMEFJQUE5QUNBQUlnQlFBR0VBZFFCekFHa0EKYmdCbkFDSUFPd0FLQUd3QWJ3QmpBR0VB YkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZBQWNnQnZBR1lBYVFCcwpBR1VB SUFBbEFHUUFJZ0JkQUNBQVBRQWdBQ0lBVUFCeUFHOEFaZ0JwQUd3QVpRQWdBQ1VBWkFBaUFEc0FD Z0JzQUc4QVl3QmhBR3dBCmFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCUUFISUFi d0JtQUdrQWJBQmxBSE1BSWdCZEFDQUFQUUFnQUNJQVVBQnkKQUc4QVpnQnBBR3dBWlFCekFDSUFP d0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZBQQpj Z0J2QUdZQWFRQnNBR2tBYmdCbkFDQUFaQUJwQUhNQVlRQmlBR3dBWlFCa0FDNEFJQUJEQUd3QWFR QmpBR3NBSUFCMEFHOEFJQUJsCkFHNEFZUUJpQUd3QVpRQXVBQ0lBWFFBZ0FEMEFJQUFpQUZBQWNn QnZBR1lBYVFCc0FHa0FiZ0JuQUNBQVpBQnBBSE1BWVFCaUFHd0EKWlFCa0FDNEFJQUJEQUd3QWFR QmpBR3NBSUFCMEFHOEFJQUJsQUc0QVlRQmlBR3dBWlFBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFC cApBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGQUFjZ0J2QUdZQWFRQnNBR2tBYmdC bkFDQUFaUUJ1QUdFQVlnQnNBR1VBClpBQXVBQ0FBUXdCc0FHa0FZd0JyQUNBQWRBQnZBQ0FBWkFC cEFITUFZUUJpQUd3QVpRQXVBQ0lBWFFBZ0FEMEFJQUFpQUZBQWNnQnYKQUdZQWFRQnNBR2tBYmdC bkFDQUFaUUJ1QUdFQVlnQnNBR1VBWkFBdUFDQUFRd0JzQUdrQVl3QnJBQ0FBZEFCdkFDQUFaQUJw QUhNQQpZUUJpQUd3QVpRQXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5 QUdrQWJnQm5BSE1BV3dBaUFGQUFjZ0J2CkFIQUFaUUJ5QUhRQWFRQmxBSE1BSWdCZEFDQUFQUUFn QUNJQVVBQnlBRzhBY0FCbEFISUFkQUJwQUdVQWN3QWlBRHNBQ2dCc0FHOEEKWXdCaEFHd0FhUUI2 QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlFBSElBYndCMEFHOEFkQUI1QUhBQVpRQWlB RjBBSUFBOQpBQ0FBSWdCUUFISUFid0IwQUc4QWRBQjVBSEFBWlFBaUFEc0FDZ0JzQUc4QVl3QmhB R3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBClp3QnpBRnNBSWdCUkFIVUFaUUJ5QUhrQUlnQmRB Q0FBUFFBZ0FDSUFVUUIxQUdVQWNnQjVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnAKQUhvQVpRQmtB Rk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRkVBZFFCbEFISUFlUUFnQUZNQWRBQnlBR2tBYmdCbkFD QUFVQUJoQUhJQQpZUUJ0QUdVQWRBQmxBSElBY3dBaUFGMEFJQUE5QUNBQUlnQlJBSFVBWlFCeUFI a0FJQUJUQUhRQWNnQnBBRzRBWndBZ0FGQUFZUUJ5CkFHRUFiUUJsQUhRQVpRQnlBSE1BSWdBN0FB b0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUEKVWdCRkFG TUFUd0JWQUZJQVF3QkZBRk1BSWdCZEFDQUFQUUFnQUNJQVVnQkZBRk1BVHdCVkFGSUFRd0JGQUZN QUlnQTdBQW9BYkFCdgpBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJ QVVnQmxBR1lBY2dCbEFITUFhQUFpQUYwQUlBQTlBQ0FBCklnQlNBR1VBWmdCeUFHVUFjd0JvQUNJ QU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWkKQUZJ QVpRQnhBSFVBWlFCekFIUUFJQUJJQUdVQVlRQmtBR1VBY2dCekFDSUFYUUFnQUQwQUlBQWlBRklB WlFCeEFIVUFaUUJ6QUhRQQpJQUJJQUdVQVlRQmtBR1VBY2dCekFDSUFPd0FLQUd3QWJ3QmpBR0VB YkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpCkFGSUFaUUJ4QUhVQVpRQnpBSFFB SUFCUUFHRUFlUUJzQUc4QVlRQmtBQ0lBWFFBZ0FEMEFJQUFpQUZJQVpRQnhBSFVBWlFCekFIUUEK SUFCUUFHRUFlUUJzQUc4QVlRQmtBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFk QUJ5QUdrQWJnQm5BSE1BV3dBaQpBRklBWlFCekFHOEFkUUJ5QUdNQVpRQWdBR2tBYmdCMEFHVUFj Z0J3QUhJQVpRQjBBR1VBWkFBZ0FHRUFjd0FnQUNVQWN3QWdBR0lBCmRRQjBBQ0FBZEFCeUFHRUFi Z0J6QUdZQVpRQnlBSElBWlFCa0FDQUFkd0JwQUhRQWFBQWdBRTBBU1FCTkFFVUFJQUIwQUhrQWNB QmwKQUNBQUpRQnpBQzRBSWdCZEFDQUFQUUFnQUNJQVVnQmxBSE1BYndCMUFISUFZd0JsQUNBQWFR QnVBSFFBWlFCeUFIQUFjZ0JsQUhRQQpaUUJrQUNBQVlRQnpBQ0FBSlFBeEFDUUFjd0FnQUdJQWRR QjBBQ0FBZEFCeUFHRUFiZ0J6QUdZQVpRQnlBSElBWlFCa0FDQUFkd0JwCkFIUUFhQUFnQUUwQVNR Qk5BRVVBSUFCMEFIa0FjQUJsQUNBQUpRQXlBQ1FBY3dBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFC cEFIb0EKWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGSUFaUUJ6QUc4QWRRQnlBR01BWlFB Z0FIUUFjZ0JoQUdNQWF3QnBBRzRBWndBZwpBR1FBYVFCekFHRUFZZ0JzQUdVQVpBQXVBQ0FBUXdC c0FHa0FZd0JyQUNBQWRBQnZBQ0FBWlFCdUFHRUFZZ0JzQUdVQUxnQWlBRjBBCklBQTlBQ0FBSWdC U0FHVUFjd0J2QUhVQWNnQmpBR1VBSUFCMEFISUFZUUJqQUdzQWFRQnVBR2NBSUFCa0FHa0Fjd0Jo QUdJQWJBQmwKQUdRQUxnQWdBRU1BYkFCcEFHTUFhd0FnQUhRQWJ3QWdBR1VBYmdCaEFHSUFiQUJs QUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQQplZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0Ji QUNJQVVnQmxBSE1BYndCMUFISUFZd0JsQUNBQWRBQnlBR0VBWXdCckFHa0FiZ0JuCkFDQUFaUUJ1 QUdFQVlnQnNBR1VBWkFBdUFDQUFRd0JzQUdrQVl3QnJBQ0FBZEFCdkFDQUFaQUJwQUhNQVlRQmlB R3dBWlFBdUFDSUEKWFFBZ0FEMEFJQUFpQUZJQVpRQnpBRzhBZFFCeUFHTUFaUUFnQUhRQWNnQmhB R01BYXdCcEFHNEFad0FnQUdVQWJnQmhBR0lBYkFCbApBR1FBTGdBZ0FFTUFiQUJwQUdNQWF3QWdB SFFBYndBZ0FHUUFhUUJ6QUdFQVlnQnNBR1VBTGdBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBCmFRQjZB R1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCU0FHVUFjd0J2QUhVQWNnQmpBR1VBY3dBaUFG MEFJQUE5QUNBQUlnQlMKQUdVQWN3QnZBSFVBY2dCakFHVUFjd0FpQURzQUNnQnNBRzhBWXdCaEFH d0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQQpJZ0JTQUdVQWN3QndBRzhBYmdCekFH VUFJQUJJQUdVQVlRQmtBR1VBY2dCekFDSUFYUUFnQUQwQUlBQWlBRklBWlFCekFIQUFid0J1CkFI TUFaUUFnQUVnQVpRQmhBR1FBWlFCeUFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdR QVV3QjBBSElBYVFCdUFHY0EKY3dCYkFDSUFVZ0JsQUhNQWRBQnZBSElBWlFBZ0FHRUFiQUJzQUNB QVpnQjFBRzRBWXdCMEFHa0Fid0J1QUhNQUxnQWlBRjBBSUFBOQpBQ0FBSWdCU0FHVUFjd0IwQUc4 QWNnQmxBQ0FBWVFCc0FHd0FJQUJtQUhVQWJnQmpBSFFBYVFCdkFHNEFjd0F1QUNJQU93QUtBR3dB CmJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZJQWRRQnVBQ0FB SlFCa0FDSUFYUUFnQUQwQUlBQWkKQUZJQWRRQnVBQ0FBSlFCa0FDSUFPd0FLQUd3QWJ3QmpBR0VB YkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZNQQpSUUJUQUZNQVNRQlBBRTRB SUFCVEFGUUFUd0JTQUVFQVJ3QkZBQ0lBWFFBZ0FEMEFJQUFpQUZNQVJRQlRBRk1BU1FCUEFFNEFJ QUJUCkFGUUFUd0JTQUVFQVJ3QkZBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFk QUJ5QUdrQWJnQm5BSE1BV3dBaUFGTUEKWXdCdkFIQUFaUUFnQUZZQVlRQnlBR2tBWVFCaUFHd0Fa UUJ6QUNJQVhRQWdBRDBBSUFBaUFGTUFZd0J2QUhBQVpRQWdBRllBWVFCeQpBR2tBWVFCaUFHd0Fa UUJ6QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3 QWlBRk1BCll3QnlBR2tBY0FCMEFITUFJZ0JkQUNBQVBRQWdBQ0lBVXdCakFISUFhUUJ3QUhRQWN3 QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjYKQUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUln QlRBR1VBWVFCeUFHTUFhQUFnQUNVQWN3QWlBRjBBSUFBOUFDQUFJZ0JUQUdVQQpZUUJ5QUdNQWFB QWdBQ1VBY3dBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndC ekFGc0FJZ0JUCkFHVUFZd0IxQUhJQVpRQWlBRjBBSUFBOUFDQUFJZ0JUQUdVQVl3QjFBSElBWlFB aUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUEKWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdC VEFHVUFiQUJsQUdNQWRBQWdBR0VBYmdBZ0FHVUFiQUJsQUcwQVpRQnVBSFFBSUFCcApBRzRBSUFC MEFHZ0FaUUFnQUhBQVlRQm5BR1VBSUFCMEFHOEFJQUJwQUc0QWN3QndBR1VBWXdCMEFDQUFhUUIw QUM0QUlnQmRBQ0FBClBRQWdBQ0lBVXdCbEFHd0FaUUJqQUhRQUlBQmhBRzRBSUFCbEFHd0FaUUJ0 QUdVQWJnQjBBQ0FBYVFCdUFDQUFkQUJvQUdVQUlBQncKQUdFQVp3QmxBQ0FBZEFCdkFDQUFhUUJ1 QUhNQWNBQmxBR01BZEFBZ0FHa0FkQUF1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQQpaUUJr QUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZNQVpRQnNBR1lBSWdCZEFDQUFQUUFnQUNJQVV3QmxB R3dBWmdBaUFEc0FDZ0JzCkFHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpB RnNBSWdCVEFHVUFjd0J6QUdrQWJ3QnVBQ0lBWFFBZ0FEMEEKSUFBaUFGTUFaUUJ6QUhNQWFRQnZB RzRBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYgpB Q0lBVXdCb0FHOEFkd0FnQUdFQVlnQnpBRzhBYkFCMUFIUUFaUUFnQUhRQWJ3QjBBR0VBYkFBZ0FH RUFiZ0JrQUNBQWN3QmxBR3dBClpnQWdBSFFBYVFCdEFHVUFjd0F1QUNJQVhRQWdBRDBBSUFBaUFG TUFhQUJ2QUhjQUlBQmhBR0lBY3dCdkFHd0FkUUIwQUdVQUlBQjAKQUc4QWRBQmhBR3dBSUFCaEFH NEFaQUFnQUhNQVpRQnNBR1lBSUFCMEFHa0FiUUJsQUhNQUxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3 QQphUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBR2dBYndCM0FDQUFZd0JvQUdF QWJnQm5BR1VBY3dBZ0FIWUFhUUJsCkFIY0FMZ0FpQUYwQUlBQTlBQ0FBSWdCVEFHZ0Fid0IzQUNB QVl3Qm9BR0VBYmdCbkFHVUFjd0FnQUhZQWFRQmxBSGNBTGdBaUFEc0EKQ2dCc0FHOEFZd0JoQUd3 QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFHZ0Fid0IzQUNBQVl3QnZBRzRB Y3dCdgpBR3dBWlFBdUFDSUFYUUFnQUQwQUlBQWlBRk1BYUFCdkFIY0FJQUJqQUc4QWJnQnpBRzhB YkFCbEFDNEFJZ0E3QUFvQWJBQnZBR01BCllRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NB Y3dCYkFDSUFVd0JvQUc4QWR3QWdBR2tBYmdCb0FHVUFjZ0JwQUhRQVpRQmsKQUNJQVhRQWdBRDBB SUFBaUFGTUFhQUJ2QUhjQUlBQnBBRzRBYUFCbEFISUFhUUIwQUdVQVpBQWlBRHNBQ2dCc0FHOEFZ d0JoQUd3QQphUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBR2dBYndCM0FDQUFk QUJvQUdVQUlBQnVBR1VBZUFCMEFDQUFjd0JqCkFISUFhUUJ3QUhRQUlBQnlBR1VBY3dCdkFIVUFj Z0JqQUdVQUxnQWlBRjBBSUFBOUFDQUFJZ0JUQUdnQWJ3QjNBQ0FBZEFCb0FHVUEKSUFCdUFHVUFl QUIwQUNBQWN3QmpBSElBYVFCd0FIUUFJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFMZ0FpQURzQUNn QnNBRzhBWXdCaApBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JUQUdnQWJ3 QjNBQ0FBZEFCb0FHVUFJQUJ3QUhJQVpRQjJBR2tBCmJ3QjFBSE1BSUFCekFHTUFjZ0JwQUhBQWRB QWdBSElBWlFCekFHOEFkUUJ5QUdNQVpRQXVBQ0lBWFFBZ0FEMEFJQUFpQUZNQWFBQnYKQUhjQUlB QjBBR2dBWlFBZ0FIQUFjZ0JsQUhZQWFRQnZBSFVBY3dBZ0FITUFZd0J5QUdrQWNBQjBBQ0FBY2dC bEFITUFid0IxQUhJQQpZd0JsQUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdC MEFISUFhUUJ1QUdjQWN3QmJBQ0lBVXdCb0FHOEFkd0FnCkFIUUFid0IwQUdFQWJBQWdBR0VBYmdC a0FDQUFjd0JsQUd3QVpnQWdBSFFBYVFCdEFHVUFjd0FnQUdFQWN3QWdBSEFBWlFCeUFHTUEKWlFC dUFIUUFZUUJuQUdVQWN3QXVBQ0lBWFFBZ0FEMEFJQUFpQUZNQWFBQnZBSGNBSUFCMEFHOEFkQUJo QUd3QUlBQmhBRzRBWkFBZwpBSE1BWlFCc0FHWUFJQUIwQUdrQWJRQmxBSE1BSUFCaEFITUFJQUJ3 QUdVQWNnQmpBR1VBYmdCMEFHRUFad0JsQUhNQUxnQWlBRHNBCkNnQnNBRzhBWXdCaEFHd0FhUUI2 QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBR2tBZWdCbEFDSUFYUUFnQUQwQUlBQWkK QUZNQWFRQjZBR1VBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVB R2NBY3dCYkFDSUFVd0J2QUhJQQpkQUFnQUdJQWVRQWdBRVFBZFFCeUFHRUFkQUJwQUc4QWJnQWlB RjBBSUFBOUFDQUFJZ0JUQUc4QWNnQjBBQ0FBWWdCNUFDQUFSQUIxCkFISUFZUUIwQUdrQWJ3QnVB Q0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFG TUEKYndCeUFIUUFJQUJpQUhrQUlBQkZBRzRBWkFBZ0FGUUFhUUJ0QUdVQUlnQmRBQ0FBUFFBZ0FD SUFVd0J2QUhJQWRBQWdBR0lBZVFBZwpBRVVBYmdCa0FDQUFWQUJwQUcwQVpRQWlBRHNBQ2dCc0FH OEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBCklnQlRBRzhBY2dCMEFD QUFZZ0I1QUNBQVRBQmhBSFFBWlFCdUFHTUFlUUFpQUYwQUlBQTlBQ0FBSWdCVEFHOEFjZ0IwQUNB QVlnQjUKQUNBQVRBQmhBSFFBWlFCdUFHTUFlUUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdV QVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQQpJZ0JUQUc4QWNnQjBBQ0FBWWdCNUFDQUFVZ0JsQUhN QWNBQnZBRzRBY3dCbEFDQUFWQUJwQUcwQVpRQWlBRjBBSUFBOUFDQUFJZ0JUCkFHOEFjZ0IwQUNB QVlnQjVBQ0FBVWdCbEFITUFjQUJ2QUc0QWN3QmxBQ0FBVkFCcEFHMEFaUUFpQURzQUNnQnNBRzhB WXdCaEFHd0EKYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JUQUc4QWNnQjBBQ0FB WWdCNUFDQUFVd0JwQUhvQVpRQWlBRjBBSUFBOQpBQ0FBSWdCVEFHOEFjZ0IwQUNBQVlnQjVBQ0FB VXdCcEFIb0FaUUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBCmNnQnBBRzRB WndCekFGc0FJZ0JUQUc4QWNnQjBBQ0FBWWdCNUFDQUFVd0IwQUdFQWNnQjBBQ0FBVkFCcEFHMEFa UUFpQUYwQUlBQTkKQUNBQUlnQlRBRzhBY2dCMEFDQUFZZ0I1QUNBQVV3QjBBR0VBY2dCMEFDQUFW QUJwQUcwQVpRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QQphUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQlRBRzhBZFFCeUFHTUFaUUFpQUYwQUlBQTlBQ0FBSWdCVEFHOEFkUUJ5CkFHTUFa UUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUln QlRBSFFBWVFCeUFIUUEKSUFCd0FISUFid0JtQUdrQWJBQnBBRzRBWndBdUFDSUFYUUFnQUQwQUlB QWlBRk1BZEFCaEFISUFkQUFnQUhBQWNnQnZBR1lBYVFCcwpBR2tBYmdCbkFDNEFJZ0E3QUFvQWJB QnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVV3QjBBR1VBCmNB QWdBR2tBYmdCMEFHOEFJQUJ1QUdVQWVBQjBBQ0FBWmdCMUFHNEFZd0IwQUdrQWJ3QnVBQ0FBWXdC aEFHd0FiQUF1QUNJQVhRQWcKQUQwQUlBQWlBRk1BZEFCbEFIQUFJQUJwQUc0QWRBQnZBQ0FBYmdC bEFIZ0FkQUFnQUdZQWRRQnVBR01BZEFCcEFHOEFiZ0FnQUdNQQpZUUJzQUd3QUxnQWlBRHNBQ2dC c0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFIUUFaUUJ3 CkFDQUFid0IxQUhRQUlBQnZBR1lBSUFCakFIVUFjZ0J5QUdVQWJnQjBBQ0FBWmdCMUFHNEFZd0Iw QUdrQWJ3QnVBQzRBSWdCZEFDQUEKUFFBZ0FDSUFVd0IwQUdVQWNBQWdBRzhBZFFCMEFDQUFid0Jt QUNBQVl3QjFBSElBY2dCbEFHNEFkQUFnQUdZQWRRQnVBR01BZEFCcApBRzhBYmdBdUFDSUFPd0FL QUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZNQWRBQmxB SEFBCklBQnZBSFlBWlFCeUFDQUFiZ0JsQUhnQWRBQWdBR1lBZFFCdUFHTUFkQUJwQUc4QWJnQWdB R01BWVFCc0FHd0FMZ0FpQUYwQUlBQTkKQUNBQUlnQlRBSFFBWlFCd0FDQUFid0IyQUdVQWNnQWdB RzRBWlFCNEFIUUFJQUJtQUhVQWJnQmpBSFFBYVFCdkFHNEFJQUJqQUdFQQpiQUJzQUM0QUlnQTdB QW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVXdCMEFH VUFjQUJ3CkFHa0FiZ0JuQUNJQVhRQWdBRDBBSUFBaUFGTUFkQUJsQUhBQWNBQnBBRzRBWndBaUFE c0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUEKWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFI UUFid0J3QUNBQWNBQnlBRzhBWmdCcEFHd0FhUUJ1QUdjQUxnQWlBRjBBSUFBOQpBQ0FBSWdCVEFI UUFid0J3QUNBQWNBQnlBRzhBWmdCcEFHd0FhUUJ1QUdjQUxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3 QWFRQjZBR1VBClpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBSFFBYndCeUFHRUFad0JsQUNJ QVhRQWdBRDBBSUFBaUFGTUFkQUJ2QUhJQVlRQm4KQUdVQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdr QWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVXdCMEFIa0FiQUJsQUNBQQpRUUIwQUhR QWNnQnBBR0lBZFFCMEFHVUFJZ0JkQUNBQVBRQWdBQ0lBVXdCMEFIa0FiQUJsQUNBQVFRQjBBSFFB Y2dCcEFHSUFkUUIwCkFHVUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElB YVFCdUFHY0Fjd0JiQUNJQVV3QjBBSGtBYkFCbEFITUEKSWdCZEFDQUFQUUFnQUNJQVV3QjBBSGtB YkFCbEFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdQpBR2NB Y3dCYkFDSUFVd0IwQUhrQWJBQmxBSE1BYUFCbEFHVUFkQUJ6QUNJQVhRQWdBRDBBSUFBaUFGTUFk QUI1QUd3QVpRQnpBR2dBClpRQmxBSFFBY3dBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFa QUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JVQUdnQVpRQWcKQUJ3Z0pRQnpBQjBnWEFCdUFIUUFZ UUJpQUd3QVpRQWdBR2tBY3dBZ0FHVUFiUUJ3QUhRQWVRQXVBQ0lBWFFBZ0FEMEFJQUFpQUZRQQph QUJsQUNBQUhDQWxBSE1BSFNCY0FHNEFkQUJoQUdJQWJBQmxBQ0FBYVFCekFDQUFaUUJ0QUhBQWRB QjVBQzRBSWdBN0FBb0FiQUJ2CkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3 QmJBQ0lBVkFCb0FHa0Fjd0FnQUhNQWFRQjBBR1VBSUFCb0FHRUEKY3dBZ0FHNEFid0FnQUdNQWJ3 QnZBR3NBYVFCbEFITUFMZ0FpQUYwQUlBQTlBQ0FBSWdCVUFHZ0FhUUJ6QUNBQWN3QnBBSFFBWlFB ZwpBR2dBWVFCekFDQUFiZ0J2QUNBQVl3QnZBRzhBYXdCcEFHVUFjd0F1QUNJQU93QUtBR3dBYndC akFHRUFiQUJwQUhvQVpRQmtBRk1BCmRBQnlBR2tBYmdCbkFITUFXd0FpQUZRQWFBQnBBSE1BSUFC ekFIUUFid0J5QUdFQVp3QmxBQ0FBYVFCekFDQUFaUUJ0QUhBQWRBQjUKQUM0QUlnQmRBQ0FBUFFB Z0FDSUFWQUJvQUdrQWN3QWdBSE1BZEFCdkFISUFZUUJuQUdVQUlBQnBBSE1BSUFCbEFHMEFjQUIw QUhrQQpMZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6 QUZzQUlnQlVBR2tBYlFCbEFDSUFYUUFnCkFEMEFJQUFpQUZRQWFRQnRBR1VBSWdBN0FBb0FiQUJ2 QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUEKVkFCdkFIUUFZUUJz QUNJQVhRQWdBRDBBSUFBaUFGUUFid0IwQUdFQWJBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZB R1VBWkFCVApBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlVBSElBWlFCbEFDQUFLQUJVQUc4QWNBQWdB RVFBYndCM0FHNEFLUUFpQUYwQUlBQTlBQ0FBCklnQlVBSElBWlFCbEFDQUFLQUJVQUc4QWNBQWdB RVFBYndCM0FHNEFLUUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlQKQUhRQWNnQnBB RzRBWndCekFGc0FJZ0JWQUc0QVpBQnZBR01BYXdBZ0FHa0FiZ0IwQUc4QUlBQnpBR1VBY0FCaEFI SUFZUUIwQUdVQQpJQUIzQUdrQWJnQmtBRzhBZHdBdUFDSUFYUUFnQUQwQUlBQWlBRlVBYmdCa0FH OEFZd0JyQUNBQWFRQnVBSFFBYndBZ0FITUFaUUJ3CkFHRUFjZ0JoQUhRQVpRQWdBSGNBYVFCdUFH UUFid0IzQUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUEKYVFCdUFH Y0Fjd0JiQUNJQVZRQnpBR1VBSUFCc0FHRUFjZ0JuQUdVQUlBQnlBR1VBY3dCdkFIVUFjZ0JqQUdV QUlBQnlBRzhBZHdCegpBQzRBSWdCZEFDQUFQUUFnQUNJQVZRQnpBR1VBSUFCc0FHRUFjZ0JuQUdV QUlBQnlBR1VBY3dCdkFIVUFjZ0JqQUdVQUlBQnlBRzhBCmR3QnpBQzRBSWdBN0FBb0FiQUJ2QUdN QVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFWUUJ6QUdVQUlBQnoKQUcw QVlRQnNBR3dBSUFCeUFHVUFjd0J2QUhVQWNnQmpBR1VBSUFCeUFHOEFkd0J6QUM0QUlnQmRBQ0FB UFFBZ0FDSUFWUUJ6QUdVQQpJQUJ6QUcwQVlRQnNBR3dBSUFCeUFHVUFjd0J2QUhVQWNnQmpBR1VB SUFCeUFHOEFkd0J6QUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzCkFHa0FlZ0JsQUdRQVV3QjBBSElB YVFCdUFHY0Fjd0JiQUNJQVZnQmhBR3dBZFFCbEFDSUFYUUFnQUQwQUlBQWlBRllBWVFCc0FIVUEK WlFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJ Z0JYQUdrQWRBQm9BQ0FBUWdCcwpBRzhBWXdCckFDSUFYUUFnQUQwQUlBQWlBRmNBYVFCMEFHZ0FJ QUJDQUd3QWJ3QmpBR3NBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBCmVnQmxBR1FBVXdCMEFISUFh UUJ1QUdjQWN3QmJBQ0lBV0FCSUFGSUFJZ0JkQUNBQVBRQWdBQ0lBV0FCSUFGSUFJZ0E3QUFvQWJB QnYKQUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFXUUJ2QUhVQUlB QmpBRzhBZFFCc0FHUUFJQUJ6QUdFQQpkZ0JsQUNBQVlnQmhBRzRBWkFCM0FHa0FaQUIwQUdnQUlB QmlBSGtBSUFCb0FHRUFkZ0JwQUc0QVp3QWdBSGtBYndCMUFISUFJQUIzCkFHVUFZZ0FnQUhNQVpR QnlBSFlBWlFCeUFDQUFZd0J2QUcwQWNBQnlBR1VBY3dCekFDQUFkQUJvQUdrQWN3QWdBSFFBY2dC aEFHNEEKY3dCbUFHVUFjZ0FnQUhjQWFRQjBBR2dBSUFCbkFIb0FhUUJ3QUNBQWJ3QnlBQ0FBZWdC c0FHa0FZZ0F1QUNJQVhRQWdBRDBBSUFBaQpBRmtBYndCMUFDQUFZd0J2QUhVQWJBQmtBQ0FBY3dC aEFIWUFaUUFnQUdJQVlRQnVBR1FBZHdCcEFHUUFkQUJvQUNBQVlnQjVBQ0FBCmFBQmhBSFlBYVFC dUFHY0FJQUI1QUc4QWRRQnlBQ0FBZHdCbEFHSUFJQUJ6QUdVQWNnQjJBR1VBY2dBZ0FHTUFid0J0 QUhBQWNnQmwKQUhNQWN3QWdBSFFBYUFCcEFITUFJQUIwQUhJQVlRQnVBSE1BWmdCbEFISUFJQUIz QUdrQWRBQm9BQ0FBWndCNkFHa0FjQUFnQUc4QQpjZ0FnQUhvQWJBQnBBR0lBTGdBaUFEc0FDZ0Jz QUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JaCkFHOEFkUUFn QUc0QVpRQmxBR1FBSUFCMEFHOEFJQUJsQUc0QVlRQmlBR3dBWlFBZ0FHUUFaUUJpQUhVQVp3Qm5B R2tBYmdCbkFDQUEKWWdCbEFHWUFid0J5QUdVQUlBQjVBRzhBZFFBZ0FHTUFZUUJ1QUNBQWRRQnpB R1VBSUFCMEFHZ0FaUUFnQUZNQVl3QnlBR2tBY0FCMApBSE1BSUFCd0FHRUFiZ0JsQUd3QUxnQWlB RjBBSUFBOUFDQUFJZ0JaQUc4QWRRQWdBRzRBWlFCbEFHUUFJQUIwQUc4QUlBQmxBRzRBCllRQmlB R3dBWlFBZ0FHUUFaUUJpQUhVQVp3Qm5BR2tBYmdCbkFDQUFZZ0JsQUdZQWJ3QnlBR1VBSUFCNUFH OEFkUUFnQUdNQVlRQnUKQUNBQWRRQnpBR1VBSUFCMEFHZ0FaUUFnQUZNQVl3QnlBR2tBY0FCMEFI TUFJQUJ3QUdFQWJnQmxBR3dBTGdBaUFEc0FDZ0JzQUc4QQpZd0JoQUd3QWFRQjZBR1VBWkFCVEFI UUFjZ0JwQUc0QVp3QnpBRnNBSWdCWkFHOEFkUUFnQUc0QVpRQmxBR1FBSUFCMEFHOEFJQUJsCkFH NEFZUUJpQUd3QVpRQWdBSEFBY2dCdkFHWUFhUUJzQUdrQWJnQm5BQ0FBWWdCbEFHWUFid0J5QUdV QUlBQjVBRzhBZFFBZ0FHTUEKWVFCdUFDQUFkUUJ6QUdVQUlBQjBBR2dBWlFBZ0FGQUFjZ0J2QUdZ QWFRQnNBR1VBY3dBZ0FIQUFZUUJ1QUdVQWJBQXVBQ0lBWFFBZwpBRDBBSUFBaUFGa0Fid0IxQUNB QWJnQmxBR1VBWkFBZ0FIUUFid0FnQUdVQWJnQmhBR0lBYkFCbEFDQUFjQUJ5QUc4QVpnQnBBR3dB CmFRQnVBR2NBSUFCaUFHVUFaZ0J2QUhJQVpRQWdBSGtBYndCMUFDQUFZd0JoQUc0QUlBQjFBSE1B WlFBZ0FIUUFhQUJsQUNBQVVBQnkKQUc4QVpnQnBBR3dBWlFCekFDQUFjQUJoQUc0QVpRQnNBQzRB SWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQQphUUJ1QUdjQWN3QmJBQ0lB V1FCdkFIVUFJQUJ1QUdVQVpRQmtBQ0FBZEFCdkFDQUFaUUJ1QUdFQVlnQnNBR1VBSUFCeUFHVUFj d0J2CkFIVUFjZ0JqQUdVQUlBQjBBSElBWVFCakFHc0FhUUJ1QUdjQUlBQjBBRzhBSUFCMUFITUFa UUFnQUhRQWFBQnBBSE1BSUFCd0FHRUEKYmdCbEFHd0FMZ0FpQUYwQUlBQTlBQ0FBSWdCWkFHOEFk UUFnQUc0QVpRQmxBR1FBSUFCMEFHOEFJQUJsQUc0QVlRQmlBR3dBWlFBZwpBSElBWlFCekFHOEFk UUJ5QUdNQVpRQWdBSFFBY2dCaEFHTUFhd0JwQUc0QVp3QWdBSFFBYndBZ0FIVUFjd0JsQUNBQWRB Qm9BR2tBCmN3QWdBSEFBWVFCdUFHVUFiQUF1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpR QmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWkKQUdJQWJ3QnlBR1FBWlFCeUFDSUFYUUFnQUQwQUlB QWlBR0lBYndCeUFHUUFaUUJ5QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQQpaUUJrQUZNQWRB QnlBR2tBYmdCbkFITUFXd0FpQUdNQWJ3QnVBSFFBWlFCdUFIUUFJZ0JkQUNBQVBRQWdBQ0lBWXdC dkFHNEFkQUJsCkFHNEFkQUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dC cEFHNEFad0J6QUZzQUlnQmtBRzhBWXdCMUFHMEEKWlFCdUFIUUFJZ0JkQUNBQVBRQWdBQ0lBWkFC dkFHTUFkUUJ0QUdVQWJnQjBBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCawpBRk1BZEFC eUFHa0FiZ0JuQUhNQVd3QWlBR1VBYkFCbEFHMEFaUUJ1QUhRQUdTQnpBQ0FBSENBbEFITUFIU0Fn QUdFQWRBQjBBSElBCmFRQmlBSFVBZEFCbEFDSUFYUUFnQUQwQUlBQWlBR1VBYkFCbEFHMEFaUUJ1 QUhRQUdTQnpBQ0FBSENBbEFITUFIU0FnQUdFQWRBQjAKQUhJQWFRQmlBSFVBZEFCbEFDSUFPd0FL QUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUdZQQpid0J1 QUhRQUlnQmRBQ0FBUFFBZ0FDSUFaZ0J2QUc0QWRBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZB R1VBWkFCVEFIUUFjZ0JwCkFHNEFad0J6QUZzQUlnQnBBRzBBWVFCbkFHVUFJZ0JkQUNBQVBRQWdB Q0lBYVFCdEFHRUFad0JsQUNJQU93QUtBR3dBYndCakFHRUEKYkFCcEFIb0FaUUJrQUZNQWRBQnlB R2tBYmdCbkFITUFXd0FpQUdrQWJnQnNBR2tBYmdCbEFDQUFjd0IwQUhrQWJBQmxBSE1BYUFCbApB R1VBZEFBaUFGMEFJQUE5QUNBQUlnQnBBRzRBYkFCcEFHNEFaUUFnQUhNQWRBQjVBR3dBWlFCekFH Z0FaUUJsQUhRQUlnQTdBQW9BCmJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFH Y0Fjd0JiQUNJQWJBQnBBRzRBWlFBZ0FDVUFaQUFpQUYwQUlBQTkKQUNBQUlnQnNBR2tBYmdCbEFD QUFKUUJrQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhN QQpXd0FpQUcwQVlRQnlBR2NBYVFCdUFDSUFYUUFnQUQwQUlBQWlBRzBBWVFCeUFHY0FhUUJ1QUNJ QU93QUtBR3dBYndCakFHRUFiQUJwCkFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUc4 QWRBQm9BR1VBY2dBaUFGMEFJQUE5QUNBQUlnQnZBSFFBYUFCbEFISUEKSWdBN0FBb0FiQUJ2QUdN QVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFjQUJoQUdRQVpBQnBBRzRB WndBaQpBRjBBSUFBOUFDQUFJZ0J3QUdFQVpBQmtBR2tBYmdCbkFDSUFPd0FLQUd3QWJ3QmpBR0VB YkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBCmJnQm5BSE1BV3dBaUFIQUFid0J6QUdrQWRBQnBBRzhB YmdBaUFGMEFJQUE5QUNBQUlnQndBRzhBY3dCcEFIUUFhUUJ2QUc0QUlnQTcKQUFvQWJBQnZBR01B WVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQWN3QmpBSElBYVFCd0FIUUFJ Z0JkQUNBQQpQUUFnQUNJQWN3QmpBSElBYVFCd0FIUUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0Fl Z0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiCkFDSUFjd0IwQUhrQWJBQmxBSE1BYUFCbEFHVUFk QUFpQUYwQUlBQTlBQ0FBSWdCekFIUUFlUUJzQUdVQWN3Qm9BR1VBWlFCMEFDSUEKT3dBS0FHd0Fi d0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFIVUFjd0JsQUhJQUlB QmhBR2NBWlFCdQpBSFFBSUFCekFIUUFlUUJzQUdVQWN3Qm9BR1VBWlFCMEFDSUFYUUFnQUQwQUlB QWlBSFVBY3dCbEFISUFJQUJoQUdjQVpRQnVBSFFBCklBQnpBSFFBZVFCc0FHVUFjd0JvQUdVQVpR QjBBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm4KQUhNQVd3 QWlBSFVBY3dCbEFISUFJQUJ6QUhRQWVRQnNBR1VBY3dCb0FHVUFaUUIwQUNJQVhRQWdBRDBBSUFB aUFIVUFjd0JsQUhJQQpJQUJ6QUhRQWVRQnNBR1VBY3dCb0FHVUFaUUIwQUNJQU93QUtBR3dBYndC akFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuCkFITUFXd0FpQUhZQWFRQmhBQ0FBYVFC dUFITUFjQUJsQUdNQWRBQnZBSElBSWdCZEFDQUFQUUFnQUNJQWRnQnBBR0VBSUFCcEFHNEEKY3dC d0FHVUFZd0IwQUc4QWNnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0Jw QUc0QVp3QnpBRnNBSWdCVQpBR2dBWlFBZ0FHSUFjZ0JsQUdFQWF3QndBRzhBYVFCdUFIUUFJQUJ2 QUc0QUlBQnNBR2tBYmdCbEFDQUFKUUJrQUNBQWR3QnBBR3dBCmJBQWdBSE1BZEFCdkFIQUFJQUJ2 QUc0QWJBQjVBQ0FBYVFCbUFDQUFkQUJvQUdrQWN3QWdBR1VBZUFCd0FISUFaUUJ6QUhNQWFRQnYK QUc0QUlBQnBBSE1BSUFCMEFISUFkUUJsQURvQUlnQmRBQ0FBUFFBZ0FDSUFWQUJvQUdVQUlBQmlB SElBWlFCaEFHc0FjQUJ2QUdrQQpiZ0IwQUNBQWJ3QnVBQ0FBYkFCcEFHNEFaUUFnQUNVQVpBQWdB SGNBYVFCc0FHd0FJQUJ6QUhRQWJ3QndBQ0FBYndCdUFHd0FlUUFnCkFHa0FaZ0FnQUhRQWFBQnBB SE1BSUFCbEFIZ0FjQUJ5QUdVQWN3QnpBR2tBYndCdUFDQUFhUUJ6QUNBQWRBQnlBSFVBWlFBNkFD SUEKT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFF TUFVQUJWQUNBQVVBQlNBRThBUmdCSgpBRXdBUlFCVEFDSUFYUUFnQUQwQUlBQWlBRU1BVUFCVkFD QUFVQUJTQUU4QVJnQkpBRXdBUlFCVEFDSUFPd0FLQUd3QWJ3QmpBR0VBCmJBQnBBSG9BWlFCa0FG TUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFZ0FSUUJCQUZBQUlBQlRBRTRBUVFCUUFGTUFTQUJQQUZR QVV3QWkKQUYwQUlBQTlBQ0FBSWdCSUFFVUFRUUJRQUNBQVV3Qk9BRUVBVUFCVEFFZ0FUd0JVQUZN QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQQplZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJ QVZBQmhBR3NBWlFBZ0FHZ0FaUUJoQUhBQUlBQnpBRzRBWVFCd0FITUFhQUJ2CkFIUUFMZ0FpQUYw QUlBQTlBQ0FBSWdCVUFHRUFhd0JsQUNBQWFBQmxBR0VBY0FBZ0FITUFiZ0JoQUhBQWN3Qm9BRzhB ZEFBdUFDSUEKT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1B V3dBaUFFZ0FaUUI0QUNBQVF3QnZBR3dBYndCeQpBSE1BSWdCZEFDQUFQUUFnQUNJQVNBQmxBSGdB SUFCREFHOEFiQUJ2QUhJQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBClpBQlRBSFFB Y2dCcEFHNEFad0J6QUZzQUlnQlNBRWNBUWdBZ0FFTUFid0JzQUc4QWNnQnpBQ0lBWFFBZ0FEMEFJ QUFpQUZJQVJ3QkMKQUNBQVF3QnZBR3dBYndCeUFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0Fl Z0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQQpTQUJUQUV3QUlBQkRBRzhBYkFCdkFISUFj d0FpQUYwQUlBQTlBQ0FBSWdCSUFGTUFUQUFnQUVNQWJ3QnNBRzhBY2dCekFDSUFPd0FLCkFHd0Fi d0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFTUFiQUJwQUdNQWF3 QWdBSFFBYndBZ0FHTUEKYUFCaEFHNEFad0JsQUNBQVl3QnZBR3dBYndCeUFDQUFaZ0J2QUhJQWJR QmhBSFFBSWdCZEFDQUFQUUFnQUNJQVF3QnNBR2tBWXdCcgpBQ0FBZEFCdkFDQUFZd0JvQUdFQWJn Qm5BR1VBSUFCakFHOEFiQUJ2QUhJQUlBQm1BRzhBY2dCdEFHRUFkQUFpQURzQUNnQnNBRzhBCll3 QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JYQUdFQWRBQmpBR2dBSUFC RkFIZ0FjQUJ5QUdVQWN3QnoKQUdrQWJ3QnVBSE1BSWdCZEFDQUFQUUFnQUNJQVZ3QmhBSFFBWXdC b0FDQUFSUUI0QUhBQWNnQmxBSE1BY3dCcEFHOEFiZ0J6QUNJQQpPd0FLQUd3QWJ3QmpBR0VBYkFC cEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVFQVpBQmtBQ0lBWFFBZ0FEMEFJQUFp CkFFRUFaQUJrQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju QUhNQVd3QWlBRVFBWlFCc0FHVUEKZEFCbEFDQUFkd0JoQUhRQVl3Qm9BQ0FBWlFCNEFIQUFjZ0Js QUhNQWN3QnBBRzhBYmdBdUFDSUFYUUFnQUQwQUlBQWlBRVFBWlFCcwpBR1VBZEFCbEFDQUFkd0Jo QUhRQVl3Qm9BQ0FBWlFCNEFIQUFjZ0JsQUhNQWN3QnBBRzhBYmdBdUFDSUFPd0FLQUE9PQoK 39657 2009-09-16 12:32:10 -0700 2009-09-16 13:16:14 -0700 proposed patch - 2009/09/16 - 2 27514.patch text/plain 65481 pmuellr SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0ODQyNCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsNTMgQEAKKzIwMDktMDktMTYgIFBhdHJpY2sgTXVlbGxlciAgPFBhdHJpY2tfTXVl bGxlckB1cy5pYm0uY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFkZCBXYXRjaCBFeHByZXNzaW9uIHN1cHBvcnQgdG8gaW5zcGVjdG9yCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzUxNAorCisgICAg ICAgIE1hbnVhbCB0ZXN0IGFkZGVkLgorCisgICAgICAgICogRW5nbGlzaC5scHJvai9sb2NhbGl6 ZWRTdHJpbmdzLmpzOgorICAgICAgICAqIFdlYkNvcmUuZ3lwaToKKyAgICAgICAgKiBXZWJDb3Jl LnZjcHJvai9XZWJDb3JlLnZjcHJvajoKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL0Nv bnNvbGVWaWV3LmpzOgorICAgICAgICAoV2ViSW5zcGVjdG9yLkNvbnNvbGVWaWV3LnByb3RvdHlw ZS5jb21wbGV0aW9ucyk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ29uc29sZVZpZXcucHJvdG90 eXBlLmV2YWxJbkluc3BlY3RlZFdpbmRvdyk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuQ29uc29s ZVZpZXcucHJvdG90eXBlLl9lbnRlcktleVByZXNzZWQpOgorICAgICAgICAqIGluc3BlY3Rvci9m cm9udC1lbmQvT2JqZWN0UHJvcGVydGllc1NlY3Rpb24uanM6CisgICAgICAgIChXZWJJbnNwZWN0 b3IuT2JqZWN0UHJvcGVydGllc1NlY3Rpb24ucHJvdG90eXBlLnVwZGF0ZS5jYWxsYmFjayk6Cisg ICAgICAgIChXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydGllc1NlY3Rpb24ucHJvdG90eXBlLnVw ZGF0ZSk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydGllc1NlY3Rpb24ucHJv dG90eXBlLnVwZGF0ZVByb3BlcnRpZXMpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLk9iamVjdFBy b3BlcnRpZXNTZWN0aW9uLkNvbXBhcmVQcm9wZXJ0aWVzKToKKyAgICAgICAgKFdlYkluc3BlY3Rv ci5PYmplY3RQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlwZS5vbnBvcHVsYXRlLmNhbGxiYWNr KToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3Rv dHlwZS5vbnBvcHVsYXRlKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0eVRy ZWVFbGVtZW50LnByb3RvdHlwZS51cGRhdGUpOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1l bmQvU2NyaXB0c1BhbmVsLmpzOgorICAgICAgICAoV2ViSW5zcGVjdG9yLlNjcmlwdHNQYW5lbCk6 CisgICAgICAgIChXZWJJbnNwZWN0b3IuU2NyaXB0c1BhbmVsLnByb3RvdHlwZS5yZXNldCk6Cisg ICAgICAgIChXZWJJbnNwZWN0b3IuU2NyaXB0c1BhbmVsLnByb3RvdHlwZS5fY2FsbEZyYW1lU2Vs ZWN0ZWQpOgorICAgICAgICAqIGluc3BlY3Rvci9mcm9udC1lbmQvV2F0Y2hFeHByZXNzaW9uc1Np ZGViYXJQYW5lLmpzOiBBZGRlZC4KKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Np b25zU2lkZWJhclBhbmUpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNT aWRlYmFyUGFuZS5wcm90b3R5cGUucmVmcmVzaEV4cHJlc3Npb25zKToKKyAgICAgICAgKFdlYklu c3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbik6CisgICAgICAgIChXZWJJbnNwZWN0b3Iu V2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24ucHJvdG90eXBlLnVwZGF0ZSk6CisgICAgICAgIChXZWJJ bnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24ucHJvdG90eXBlLmFkZEV4cHJlc3Npb24p OgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlw ZS51cGRhdGVFeHByZXNzaW9uKToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Np b25zU2VjdGlvbi5wcm90b3R5cGUuZmluZEFkZGVkVHJlZUVsZW1lbnQpOgorICAgICAgICAoV2Vi SW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0aW9uLnByb3RvdHlwZS5sb2FkU2F2ZWRFeHBy ZXNzaW9ucyk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24u cHJvdG90eXBlLnNhdmVFeHByZXNzaW9ucyk6CisgICAgICAgIChXZWJJbnNwZWN0b3IuV2F0Y2hF eHByZXNzaW9uc1NlY3Rpb24uQ29tcGFyZVByb3BlcnRpZXMpOgorICAgICAgICAoV2ViSW5zcGVj dG9yLldhdGNoRXhwcmVzc2lvblRyZWVFbGVtZW50KToKKyAgICAgICAgKFdlYkluc3BlY3Rvci5X YXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUudXBkYXRlKToKKyAgICAgICAgKFdl Ykluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUuX2RlbGV0ZUJ1 dHRvbkNsaWNrZWQpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvblRyZWVF bGVtZW50LnByb3RvdHlwZS5zdGFydEVkaXRpbmcpOgorICAgICAgICAoV2ViSW5zcGVjdG9yLldh dGNoRXhwcmVzc2lvblRyZWVFbGVtZW50LnByb3RvdHlwZS5lZGl0aW5nQ2FuY2VsbGVkKToKKyAg ICAgICAgKFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25UcmVlRWxlbWVudC5wcm90b3R5cGUu YXBwbHlFeHByZXNzaW9uKToKKyAgICAgICAgKiBpbnNwZWN0b3IvZnJvbnQtZW5kL1dlYktpdC5x cmM6CisgICAgICAgICogaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuY3NzOgorICAgICAg ICAqIGluc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmh0bWw6CisgICAgICAgICogbWFudWFs LXRlc3RzL2luc3BlY3Rvci9kZWJ1Z2dlci13YXRjaC1leHByZXNzaW9ucy5odG1sOiBBZGRlZC4K KwogMjAwOS0wOS0xNiAgVml0YWx5IFJlcGVzaGtvICA8dml0YWx5ckBjaHJvbWl1bS5vcmc+CiAK ICAgICAgICAgUmV2aWV3ZWQgYnkgRGltaXRyaSBHbGF6a292LgpJbmRleDogV2ViQ29yZS9XZWJD b3JlLmd5cGkKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9XZWJDb3JlLmd5cGkJKHJldmlzaW9uIDQ4 Mzk4KQorKysgV2ViQ29yZS9XZWJDb3JlLmd5cGkJKHdvcmtpbmcgY29weSkKQEAgLTM1MTgsNiAr MzUxOCw3IEBACiAgICAgICAgICAgICAnaW5zcGVjdG9yL2Zyb250LWVuZC90cmVlb3V0bGluZS5q cycsCiAgICAgICAgICAgICAnaW5zcGVjdG9yL2Zyb250LWVuZC91dGlsaXRpZXMuanMnLAogICAg ICAgICAgICAgJ2luc3BlY3Rvci9mcm9udC1lbmQvVmlldy5qcycsCisgICAgICAgICAgICAnaW5z cGVjdG9yL2Zyb250LWVuZC9XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUuanMnLAogICAgICAg ICAgICAgJ2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVjdG9yLmNzcycsCiAgICAgICAgIF0sCiAg ICAgICAgICd3ZWJpbnNwZWN0b3JfaW1hZ2VfZmlsZXMnOiBbCkluZGV4OiBXZWJDb3JlL1dlYkNv cmUudmNwcm9qL1dlYkNvcmUudmNwcm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvV2ViQ29yZS52 Y3Byb2ovV2ViQ29yZS52Y3Byb2oJKHJldmlzaW9uIDQ4Mzk4KQorKysgV2ViQ29yZS9XZWJDb3Jl LnZjcHJvai9XZWJDb3JlLnZjcHJvagkod29ya2luZyBjb3B5KQpAQCAtMzE2MjYsNiArMzE2MjYs MTAgQEAKIAkJCQkJUmVsYXRpdmVQYXRoPSIuLlxpbnNwZWN0b3JcZnJvbnQtZW5kXFZpZXcuanMi DQogCQkJCQk+DQogCQkJCTwvRmlsZT4NCisJCQkJPEZpbGUNCisJCQkJCVJlbGF0aXZlUGF0aD0i Li5caW5zcGVjdG9yXGZyb250LWVuZFxXYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUuanMiDQor CQkJCQk+DQorCQkJCTwvRmlsZT4NCiAJCQk8L0ZpbHRlcj4NCiAJCTwvRmlsdGVyPg0KIAkJPEZp bHRlcg0KSW5kZXg6IFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9Db25zb2xlVmlldy5qcwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvQ29uc29sZVZpZXcuanMJ KHJldmlzaW9uIDQ4Mzk4KQorKysgV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL0NvbnNvbGVW aWV3LmpzCSh3b3JraW5nIGNvcHkpCkBAIC0yOTgsNyArMjk4LDcgQEAgV2ViSW5zcGVjdG9yLkNv bnNvbGVWaWV3LnByb3RvdHlwZSA9IHsKICAgICAgICAgICAgIHJlcG9ydENvbXBsZXRpb25zKHJl c3VsdCwgaXNFeGNlcHRpb24pOwogICAgICAgICB9CiAKLSAgICAgICAgdGhpcy5fZXZhbEluSW5z cGVjdGVkV2luZG93KAorICAgICAgICB0aGlzLmV2YWxJbkluc3BlY3RlZFdpbmRvdygKICAgICAg ICAgICAgICIoZnVuY3Rpb24oKSB7IiArCiAgICAgICAgICAgICAgICAgInZhciBwcm9wcyA9IHt9 OyIgKwogICAgICAgICAgICAgICAgICJmb3IgKHZhciBwcm9wIGluICgiICsgZXhwcmVzc2lvblN0 cmluZyArICIpKSBwcm9wc1twcm9wXSA9IHRydWU7IiArCkBAIC0zOTQsNyArMzk0LDcgQEAgV2Vi SW5zcGVjdG9yLkNvbnNvbGVWaWV3LnByb3RvdHlwZSA9IHsKICAgICAgICAgdGhpcy5wcm9tcHQu aGFuZGxlS2V5RXZlbnQoZXZlbnQpOwogICAgIH0sCiAKLSAgICBfZXZhbEluSW5zcGVjdGVkV2lu ZG93OiBmdW5jdGlvbihleHByZXNzaW9uLCBjYWxsYmFjaykKKyAgICBldmFsSW5JbnNwZWN0ZWRX aW5kb3c6IGZ1bmN0aW9uKGV4cHJlc3Npb24sIGNhbGxiYWNrKQogICAgIHsKICAgICAgICAgaWYg KFdlYkluc3BlY3Rvci5wYW5lbHMuc2NyaXB0cyAmJiBXZWJJbnNwZWN0b3IucGFuZWxzLnNjcmlw dHMucGF1c2VkKSB7CiAgICAgICAgICAgICBXZWJJbnNwZWN0b3IucGFuZWxzLnNjcmlwdHMuZXZh bHVhdGVJblNlbGVjdGVkQ2FsbEZyYW1lKGV4cHJlc3Npb24sIGZhbHNlLCBjYWxsYmFjayk7CkBA IC00NDIsNyArNDQyLDcgQEAgV2ViSW5zcGVjdG9yLkNvbnNvbGVWaWV3LnByb3RvdHlwZSA9IHsK ICAgICAgICAgICAgIHNlbGYucHJvbXB0LnRleHQgPSAiIjsKICAgICAgICAgICAgIHNlbGYuYWRk TWVzc2FnZShuZXcgV2ViSW5zcGVjdG9yLkNvbnNvbGVDb21tYW5kUmVzdWx0KHJlc3VsdCwgZXhj ZXB0aW9uLCBjb21tYW5kTWVzc2FnZSkpOwogICAgICAgICB9Ci0gICAgICAgIHRoaXMuX2V2YWxJ bkluc3BlY3RlZFdpbmRvdyhzdHIsIHByaW50UmVzdWx0KTsKKyAgICAgICAgdGhpcy5ldmFsSW5J bnNwZWN0ZWRXaW5kb3coc3RyLCBwcmludFJlc3VsdCk7CiAgICAgfSwKIAogICAgIF9mb3JtYXQ6 IGZ1bmN0aW9uKG91dHB1dCwgZm9yY2VPYmplY3RGb3JtYXQpCkluZGV4OiBXZWJDb3JlL2luc3Bl Y3Rvci9mcm9udC1lbmQvT2JqZWN0UHJvcGVydGllc1NlY3Rpb24uanMKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g V2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL09iamVjdFByb3BlcnRpZXNTZWN0aW9uLmpzCShy ZXZpc2lvbiA0ODM5OCkKKysrIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9PYmplY3RQcm9w ZXJ0aWVzU2VjdGlvbi5qcwkod29ya2luZyBjb3B5KQpAQCAtNDgsNzMgKzQ4LDgxIEBAIFdlYklu c3BlY3Rvci5PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5wcm8KICAgICAgICAgdmFyIGNhbGxiYWNr ID0gZnVuY3Rpb24ocHJvcGVydGllcykgewogICAgICAgICAgICAgaWYgKCFwcm9wZXJ0aWVzKQog ICAgICAgICAgICAgICAgIHJldHVybjsKLSAgICAgICAgICAgIHNlbGYuX3VwZGF0ZShwcm9wZXJ0 aWVzKTsKKyAgICAgICAgICAgIHNlbGYudXBkYXRlUHJvcGVydGllcyhwcm9wZXJ0aWVzKTsKICAg ICAgICAgfTsKICAgICAgICAgSW5qZWN0ZWRTY3JpcHRBY2Nlc3MuZ2V0UHJvcGVydGllcyh0aGlz Lm9iamVjdCwgdGhpcy5pZ25vcmVIYXNPd25Qcm9wZXJ0eSwgY2FsbGJhY2spOwogICAgIH0sCiAK LSAgICBfdXBkYXRlOiBmdW5jdGlvbihwcm9wZXJ0aWVzKQorICAgIHVwZGF0ZVByb3BlcnRpZXM6 IGZ1bmN0aW9uKHByb3BlcnRpZXMsIHJvb3RUcmVlRWxlbWVudENvbnN0cnVjdG9yLCByb290UHJv cGVydHlDb21wYXJlcikKICAgICB7CisgICAgICAgIGlmICghcm9vdFRyZWVFbGVtZW50Q29uc3Ry dWN0b3IpCisgICAgICAgICAgICByb290VHJlZUVsZW1lbnRDb25zdHJ1Y3RvciA9IHRoaXMudHJl ZUVsZW1lbnRDb25zdHJ1Y3RvcjsKKyAgICAgICAgICAgIAorICAgICAgICBpZiAoIXJvb3RQcm9w ZXJ0eUNvbXBhcmVyKQorICAgICAgICAgICAgcm9vdFByb3BlcnR5Q29tcGFyZXIgPSBXZWJJbnNw ZWN0b3IuT2JqZWN0UHJvcGVydGllc1NlY3Rpb24uQ29tcGFyZVByb3BlcnRpZXM7CisgICAgICAg ICAgICAKICAgICAgICAgaWYgKHRoaXMuZXh0cmFQcm9wZXJ0aWVzKQogICAgICAgICAgICAgZm9y ICh2YXIgaSA9IDA7IGkgPCB0aGlzLmV4dHJhUHJvcGVydGllcy5sZW5ndGg7ICsraSkKICAgICAg ICAgICAgICAgICBwcm9wZXJ0aWVzLnB1c2godGhpcy5leHRyYVByb3BlcnRpZXNbaV0pOwotICAg ICAgICBwcm9wZXJ0aWVzLnNvcnQodGhpcy5fZGlzcGxheVNvcnQpOworICAgICAgICAgICAgICAg IAorICAgICAgICBwcm9wZXJ0aWVzLnNvcnQocm9vdFByb3BlcnR5Q29tcGFyZXIpOwogCiAgICAg ICAgIHRoaXMucHJvcGVydGllc1RyZWVPdXRsaW5lLnJlbW92ZUNoaWxkcmVuKCk7CiAKICAgICAg ICAgZm9yICh2YXIgaSA9IDA7IGkgPCBwcm9wZXJ0aWVzLmxlbmd0aDsgKytpKQotICAgICAgICAg ICAgdGhpcy5wcm9wZXJ0aWVzVHJlZU91dGxpbmUuYXBwZW5kQ2hpbGQobmV3IHRoaXMudHJlZUVs ZW1lbnRDb25zdHJ1Y3Rvcihwcm9wZXJ0aWVzW2ldKSk7CisgICAgICAgICAgICB0aGlzLnByb3Bl cnRpZXNUcmVlT3V0bGluZS5hcHBlbmRDaGlsZChuZXcgcm9vdFRyZWVFbGVtZW50Q29uc3RydWN0 b3IocHJvcGVydGllc1tpXSkpOwogCiAgICAgICAgIGlmICghdGhpcy5wcm9wZXJ0aWVzVHJlZU91 dGxpbmUuY2hpbGRyZW4ubGVuZ3RoKSB7CiAgICAgICAgICAgICB2YXIgdGl0bGUgPSAiPGRpdiBj bGFzcz1cImluZm9cIj4iICsgdGhpcy5lbXB0eVBsYWNlaG9sZGVyICsgIjwvZGl2PiI7CiAgICAg ICAgICAgICB2YXIgaW5mb0VsZW1lbnQgPSBuZXcgVHJlZUVsZW1lbnQodGl0bGUsIG51bGwsIGZh bHNlKTsKICAgICAgICAgICAgIHRoaXMucHJvcGVydGllc1RyZWVPdXRsaW5lLmFwcGVuZENoaWxk KGluZm9FbGVtZW50KTsKICAgICAgICAgfQotICAgIH0sCi0KLSAgICBfZGlzcGxheVNvcnQ6IGZ1 bmN0aW9uKHByb3BlcnR5QSwgcHJvcGVydHlCKSB7Ci0gICAgICAgIHZhciBhID0gcHJvcGVydHlB Lm5hbWU7Ci0gICAgICAgIHZhciBiID0gcHJvcGVydHlCLm5hbWU7Ci0KLSAgICAgICAgLy8gaWYg dXNlZCBlbHNld2hlcmUgbWFrZSBzdXJlIHRvCi0gICAgICAgIC8vICAtIGNvbnZlcnQgYSBhbmQg YiB0byBzdHJpbmdzIChub3QgbmVlZGVkIGhlcmUsIHByb3BlcnRpZXMgYXJlIGFsbCBzdHJpbmdz KQotICAgICAgICAvLyAgLSBjaGVjayBpZiBhID09IGIgKG5vdCBuZWVkZWQgaGVyZSwgbm8gdHdv IHByb3BlcnRpZXMgY2FuIGJlIHRoZSBzYW1lKQotCi0gICAgICAgIHZhciBkaWZmID0gMDsKLSAg ICAgICAgdmFyIGNodW5rID0gL15cZCt8XlxEKy87Ci0gICAgICAgIHZhciBjaHVua2EsIGNodW5r YiwgYW51bSwgYm51bTsKLSAgICAgICAgd2hpbGUgKGRpZmYgPT09IDApIHsKLSAgICAgICAgICAg IGlmICghYSAmJiBiKQotICAgICAgICAgICAgICAgIHJldHVybiAtMTsKLSAgICAgICAgICAgIGlm ICghYiAmJiBhKQotICAgICAgICAgICAgICAgIHJldHVybiAxOwotICAgICAgICAgICAgY2h1bmth ID0gYS5tYXRjaChjaHVuaylbMF07Ci0gICAgICAgICAgICBjaHVua2IgPSBiLm1hdGNoKGNodW5r KVswXTsKLSAgICAgICAgICAgIGFudW0gPSAhaXNOYU4oY2h1bmthKTsKLSAgICAgICAgICAgIGJu dW0gPSAhaXNOYU4oY2h1bmtiKTsKLSAgICAgICAgICAgIGlmIChhbnVtICYmICFibnVtKQotICAg ICAgICAgICAgICAgIHJldHVybiAtMTsKLSAgICAgICAgICAgIGlmIChibnVtICYmICFhbnVtKQot ICAgICAgICAgICAgICAgIHJldHVybiAxOwotICAgICAgICAgICAgaWYgKGFudW0gJiYgYm51bSkg ewotICAgICAgICAgICAgICAgIGRpZmYgPSBjaHVua2EgLSBjaHVua2I7Ci0gICAgICAgICAgICAg ICAgaWYgKGRpZmYgPT09IDAgJiYgY2h1bmthLmxlbmd0aCAhPT0gY2h1bmtiLmxlbmd0aCkgewot ICAgICAgICAgICAgICAgICAgICBpZiAoIStjaHVua2EgJiYgIStjaHVua2IpIC8vIGNodW5rcyBh cmUgc3RyaW5ncyBvZiBhbGwgMHMgKHNwZWNpYWwgY2FzZSkKLSAgICAgICAgICAgICAgICAgICAg ICAgIHJldHVybiBjaHVua2EubGVuZ3RoIC0gY2h1bmtiLmxlbmd0aDsKLSAgICAgICAgICAgICAg ICAgICAgZWxzZQotICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGNodW5rYi5sZW5ndGgg LSBjaHVua2EubGVuZ3RoOwotICAgICAgICAgICAgICAgIH0KLSAgICAgICAgICAgIH0gZWxzZSBp ZiAoY2h1bmthICE9PSBjaHVua2IpCi0gICAgICAgICAgICAgICAgcmV0dXJuIChjaHVua2EgPCBj aHVua2IpID8gLTEgOiAxOwotICAgICAgICAgICAgYSA9IGEuc3Vic3RyaW5nKGNodW5rYS5sZW5n dGgpOwotICAgICAgICAgICAgYiA9IGIuc3Vic3RyaW5nKGNodW5rYi5sZW5ndGgpOwotICAgICAg ICB9Ci0gICAgICAgIHJldHVybiBkaWZmOwogICAgIH0KIH0KIAogV2ViSW5zcGVjdG9yLk9iamVj dFByb3BlcnRpZXNTZWN0aW9uLnByb3RvdHlwZS5fX3Byb3RvX18gPSBXZWJJbnNwZWN0b3IuUHJv cGVydGllc1NlY3Rpb24ucHJvdG90eXBlOwogCitXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydGll c1NlY3Rpb24uQ29tcGFyZVByb3BlcnRpZXMgPSBmdW5jdGlvbihwcm9wZXJ0eUEsIHByb3BlcnR5 QikgCit7CisgICAgdmFyIGEgPSBwcm9wZXJ0eUEubmFtZTsKKyAgICB2YXIgYiA9IHByb3BlcnR5 Qi5uYW1lOworCisgICAgLy8gaWYgdXNlZCBlbHNld2hlcmUgbWFrZSBzdXJlIHRvCisgICAgLy8g IC0gY29udmVydCBhIGFuZCBiIHRvIHN0cmluZ3MgKG5vdCBuZWVkZWQgaGVyZSwgcHJvcGVydGll cyBhcmUgYWxsIHN0cmluZ3MpCisgICAgLy8gIC0gY2hlY2sgaWYgYSA9PSBiIChub3QgbmVlZGVk IGhlcmUsIG5vIHR3byBwcm9wZXJ0aWVzIGNhbiBiZSB0aGUgc2FtZSkKKworICAgIHZhciBkaWZm ID0gMDsKKyAgICB2YXIgY2h1bmsgPSAvXlxkK3xeXEQrLzsKKyAgICB2YXIgY2h1bmthLCBjaHVu a2IsIGFudW0sIGJudW07CisgICAgd2hpbGUgKGRpZmYgPT09IDApIHsKKyAgICAgICAgaWYgKCFh ICYmIGIpCisgICAgICAgICAgICByZXR1cm4gLTE7CisgICAgICAgIGlmICghYiAmJiBhKQorICAg ICAgICAgICAgcmV0dXJuIDE7CisgICAgICAgIGNodW5rYSA9IGEubWF0Y2goY2h1bmspWzBdOwor ICAgICAgICBjaHVua2IgPSBiLm1hdGNoKGNodW5rKVswXTsKKyAgICAgICAgYW51bSA9ICFpc05h TihjaHVua2EpOworICAgICAgICBibnVtID0gIWlzTmFOKGNodW5rYik7CisgICAgICAgIGlmIChh bnVtICYmICFibnVtKQorICAgICAgICAgICAgcmV0dXJuIC0xOworICAgICAgICBpZiAoYm51bSAm JiAhYW51bSkKKyAgICAgICAgICAgIHJldHVybiAxOworICAgICAgICBpZiAoYW51bSAmJiBibnVt KSB7CisgICAgICAgICAgICBkaWZmID0gY2h1bmthIC0gY2h1bmtiOworICAgICAgICAgICAgaWYg KGRpZmYgPT09IDAgJiYgY2h1bmthLmxlbmd0aCAhPT0gY2h1bmtiLmxlbmd0aCkgeworICAgICAg ICAgICAgICAgIGlmICghK2NodW5rYSAmJiAhK2NodW5rYikgLy8gY2h1bmtzIGFyZSBzdHJpbmdz IG9mIGFsbCAwcyAoc3BlY2lhbCBjYXNlKQorICAgICAgICAgICAgICAgICAgICByZXR1cm4gY2h1 bmthLmxlbmd0aCAtIGNodW5rYi5sZW5ndGg7CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAg ICAgICAgICAgICAgICByZXR1cm4gY2h1bmtiLmxlbmd0aCAtIGNodW5rYS5sZW5ndGg7CisgICAg ICAgICAgICB9CisgICAgICAgIH0gZWxzZSBpZiAoY2h1bmthICE9PSBjaHVua2IpCisgICAgICAg ICAgICByZXR1cm4gKGNodW5rYSA8IGNodW5rYikgPyAtMSA6IDE7CisgICAgICAgIGEgPSBhLnN1 YnN0cmluZyhjaHVua2EubGVuZ3RoKTsKKyAgICAgICAgYiA9IGIuc3Vic3RyaW5nKGNodW5rYi5s ZW5ndGgpOworICAgIH0KKyAgICByZXR1cm4gZGlmZjsKK30KKwogV2ViSW5zcGVjdG9yLk9iamVj dFByb3BlcnR5VHJlZUVsZW1lbnQgPSBmdW5jdGlvbihwcm9wZXJ0eSkKIHsKICAgICB0aGlzLnBy b3BlcnR5ID0gcHJvcGVydHk7CkBAIC0xMjksMTggKzEzNywxNyBAQCBXZWJJbnNwZWN0b3IuT2Jq ZWN0UHJvcGVydHlUcmVlRWxlbWVudC5wCiAgICAgICAgIGlmICh0aGlzLmNoaWxkcmVuLmxlbmd0 aCAmJiAhdGhpcy5zaG91bGRSZWZyZXNoQ2hpbGRyZW4pCiAgICAgICAgICAgICByZXR1cm47CiAK LSAgICAgICAgdmFyIHNlbGYgPSB0aGlzOwogICAgICAgICB2YXIgY2FsbGJhY2sgPSBmdW5jdGlv bihwcm9wZXJ0aWVzKSB7Ci0gICAgICAgICAgICBzZWxmLnJlbW92ZUNoaWxkcmVuKCk7CisgICAg ICAgICAgICB0aGlzLnJlbW92ZUNoaWxkcmVuKCk7CiAgICAgICAgICAgICBpZiAoIXByb3BlcnRp ZXMpCiAgICAgICAgICAgICAgICAgcmV0dXJuOwogCi0gICAgICAgICAgICBwcm9wZXJ0aWVzLnNv cnQoc2VsZi5fZGlzcGxheVNvcnQpOworICAgICAgICAgICAgcHJvcGVydGllcy5zb3J0KFdlYklu c3BlY3Rvci5PYmplY3RQcm9wZXJ0aWVzU2VjdGlvbi5Db21wYXJlUHJvcGVydGllcyk7CiAgICAg ICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IHByb3BlcnRpZXMubGVuZ3RoOyArK2kpIHsKLSAg ICAgICAgICAgICAgICBzZWxmLmFwcGVuZENoaWxkKG5ldyBzZWxmLnRyZWVPdXRsaW5lLnNlY3Rp b24udHJlZUVsZW1lbnRDb25zdHJ1Y3Rvcihwcm9wZXJ0aWVzW2ldKSk7CisgICAgICAgICAgICAg ICAgdGhpcy5hcHBlbmRDaGlsZChuZXcgdGhpcy50cmVlT3V0bGluZS5zZWN0aW9uLnRyZWVFbGVt ZW50Q29uc3RydWN0b3IocHJvcGVydGllc1tpXSkpOwogICAgICAgICAgICAgfQogICAgICAgICB9 OwotICAgICAgICBJbmplY3RlZFNjcmlwdEFjY2Vzcy5nZXRQcm9wZXJ0aWVzKHRoaXMucHJvcGVy dHkudmFsdWUsIGZhbHNlLCBjYWxsYmFjayk7CisgICAgICAgIEluamVjdGVkU2NyaXB0QWNjZXNz LmdldFByb3BlcnRpZXModGhpcy5wcm9wZXJ0eS52YWx1ZSwgZmFsc2UsIGNhbGxiYWNrLmJpbmQo dGhpcykpOwogICAgIH0sCiAKICAgICBvbmRibGNsaWNrOiBmdW5jdGlvbihlbGVtZW50LCBldmVu dCkKQEAgLTE1NSwxMCArMTYyLDE0IEBAIFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0eVRyZWVF bGVtZW50LnAKIAogICAgIHVwZGF0ZTogZnVuY3Rpb24oKQogICAgIHsKLSAgICAgICAgdmFyIG5h bWVFbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpOwotICAgICAgICBuYW1l RWxlbWVudC5jbGFzc05hbWUgPSAibmFtZSI7Ci0gICAgICAgIG5hbWVFbGVtZW50LnRleHRDb250 ZW50ID0gdGhpcy5wcm9wZXJ0eS5uYW1lOwotCisgICAgICAgIHRoaXMubmFtZUVsZW1lbnQgPSBk b2N1bWVudC5jcmVhdGVFbGVtZW50KCJzcGFuIik7CisgICAgICAgIHRoaXMubmFtZUVsZW1lbnQu Y2xhc3NOYW1lID0gIm5hbWUiOworICAgICAgICB0aGlzLm5hbWVFbGVtZW50LnRleHRDb250ZW50 ID0gdGhpcy5wcm9wZXJ0eS5uYW1lOworCisgICAgICAgIHZhciBzZXBhcmF0b3JFbGVtZW50ID0g ZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpOworICAgICAgICBzZXBhcmF0b3JFbGVtZW50 LmNsYXNzTmFtZSA9ICJzZXBhcmF0b3IiOworICAgICAgICBzZXBhcmF0b3JFbGVtZW50LnRleHRD b250ZW50ID0gIjogIjsKKyAgICAgICAgCiAgICAgICAgIHRoaXMudmFsdWVFbGVtZW50ID0gZG9j dW1lbnQuY3JlYXRlRWxlbWVudCgic3BhbiIpOwogICAgICAgICB0aGlzLnZhbHVlRWxlbWVudC5j bGFzc05hbWUgPSAidmFsdWUiOwogICAgICAgICB0aGlzLnZhbHVlRWxlbWVudC50ZXh0Q29udGVu dCA9IHRoaXMucHJvcGVydHkudmFsdWUuZGVzY3JpcHRpb247CkBAIC0xNjcsOCArMTc4LDggQEAg V2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnR5VHJlZUVsZW1lbnQucAogCiAgICAgICAgIHRoaXMu bGlzdEl0ZW1FbGVtZW50LnJlbW92ZUNoaWxkcmVuKCk7CiAKLSAgICAgICAgdGhpcy5saXN0SXRl bUVsZW1lbnQuYXBwZW5kQ2hpbGQobmFtZUVsZW1lbnQpOwotICAgICAgICB0aGlzLmxpc3RJdGVt RWxlbWVudC5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZSgiOiAiKSk7CisgICAg ICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50LmFwcGVuZENoaWxkKHRoaXMubmFtZUVsZW1lbnQpOwor ICAgICAgICB0aGlzLmxpc3RJdGVtRWxlbWVudC5hcHBlbmRDaGlsZChzZXBhcmF0b3JFbGVtZW50 KTsKICAgICAgICAgdGhpcy5saXN0SXRlbUVsZW1lbnQuYXBwZW5kQ2hpbGQodGhpcy52YWx1ZUVs ZW1lbnQpOwogICAgICAgICB0aGlzLmhhc0NoaWxkcmVuID0gdGhpcy5wcm9wZXJ0eS52YWx1ZS5o YXNDaGlsZHJlbjsKICAgICB9LApJbmRleDogV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5kL1Nj cmlwdHNQYW5lbC5qcwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQv U2NyaXB0c1BhbmVsLmpzCShyZXZpc2lvbiA0ODM5OCkKKysrIFdlYkNvcmUvaW5zcGVjdG9yL2Zy b250LWVuZC9TY3JpcHRzUGFuZWwuanMJKHdvcmtpbmcgY29weSkKQEAgLTEyNiw2ICsxMjYsNyBA QCBXZWJJbnNwZWN0b3IuU2NyaXB0c1BhbmVsID0gZnVuY3Rpb24oKQogICAgIHRoaXMudG9wU3Rh dHVzQmFyLmFwcGVuZENoaWxkKHRoaXMuc2lkZWJhclJlc2l6ZVdpZGdldEVsZW1lbnQpOwogCiAg ICAgdGhpcy5zaWRlYmFyUGFuZXMgPSB7fTsKKyAgICB0aGlzLnNpZGViYXJQYW5lcy53YXRjaEV4 cHJlc3Npb25zID0gbmV3IFdlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUo KTsKICAgICB0aGlzLnNpZGViYXJQYW5lcy5jYWxsc3RhY2sgPSBuZXcgV2ViSW5zcGVjdG9yLkNh bGxTdGFja1NpZGViYXJQYW5lKCk7CiAgICAgdGhpcy5zaWRlYmFyUGFuZXMuc2NvcGVjaGFpbiA9 IG5ldyBXZWJJbnNwZWN0b3IuU2NvcGVDaGFpblNpZGViYXJQYW5lKCk7CiAgICAgdGhpcy5zaWRl YmFyUGFuZXMuYnJlYWtwb2ludHMgPSBuZXcgV2ViSW5zcGVjdG9yLkJyZWFrcG9pbnRzU2lkZWJh clBhbmUoKTsKQEAgLTQ3MSw2ICs0NzIsOCBAQCBXZWJJbnNwZWN0b3IuU2NyaXB0c1BhbmVsLnBy b3RvdHlwZSA9IHsKICAgICAgICAgfQogCiAgICAgICAgIHRoaXMuX3NvdXJjZUlETWFwID0ge307 CisgICAgICAgIAorICAgICAgICB0aGlzLnNpZGViYXJQYW5lcy53YXRjaEV4cHJlc3Npb25zLnJl ZnJlc2hFeHByZXNzaW9ucygpOwogICAgIH0sCiAKICAgICBnZXQgdmlzaWJsZVZpZXcoKQpAQCAt NzA0LDYgKzcwNyw3IEBAIFdlYkluc3BlY3Rvci5TY3JpcHRzUGFuZWwucHJvdG90eXBlID0gewog ICAgICAgICAgICAgcmV0dXJuOwogCiAgICAgICAgIHRoaXMuc2lkZWJhclBhbmVzLnNjb3BlY2hh aW4udXBkYXRlKGN1cnJlbnRGcmFtZSk7CisgICAgICAgIHRoaXMuc2lkZWJhclBhbmVzLndhdGNo RXhwcmVzc2lvbnMucmVmcmVzaEV4cHJlc3Npb25zKCk7CiAKICAgICAgICAgdmFyIHNjcmlwdE9y UmVzb3VyY2UgPSB0aGlzLl9zb3VyY2VJRE1hcFtjdXJyZW50RnJhbWUuc291cmNlSURdOwogICAg ICAgICB0aGlzLl9zaG93U2NyaXB0T3JSZXNvdXJjZShzY3JpcHRPclJlc291cmNlLCBjdXJyZW50 RnJhbWUubGluZSk7CkluZGV4OiBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvV2F0Y2hFeHBy ZXNzaW9uc1NpZGViYXJQYW5lLmpzCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaW5zcGVjdG9yL2Zy b250LWVuZC9XYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUuanMJKHJldmlzaW9uIDApCisrKyBX ZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvV2F0Y2hFeHByZXNzaW9uc1NpZGViYXJQYW5lLmpz CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDI3NCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgSUJN IENvcnAuIDIwMDkgIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgorICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNv dXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAg ICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJv dmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhl ciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAq IE5laXRoZXIgdGhlIG5hbWUgb2YgSUJNIENvcnAuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBj b250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRl cml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0 ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBD T1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQ UkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRF RCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5F U1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZF TlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJM RSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVN UExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBM T1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElP TikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUg VVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKK1dlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25z U2lkZWJhclBhbmUgPSBmdW5jdGlvbigpCit7CisgICAgV2ViSW5zcGVjdG9yLlNpZGViYXJQYW5l LmNhbGwodGhpcywgV2ViSW5zcGVjdG9yLlVJU3RyaW5nKCJXYXRjaCBFeHByZXNzaW9ucyIpKTsK KworICAgIHRoaXMuc2VjdGlvbiA9IG5ldyBXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1Nl Y3Rpb24oKTsKKworICAgIHRoaXMuYm9keUVsZW1lbnQuYXBwZW5kQ2hpbGQodGhpcy5zZWN0aW9u LmVsZW1lbnQpOworCisgICAgdmFyIGFkZEVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50 KCJidXR0b24iKTsKKyAgICBhZGRFbGVtZW50LnNldEF0dHJpYnV0ZSgidHlwZSIsICJidXR0b24i KTsKKyAgICBhZGRFbGVtZW50LnRleHRDb250ZW50ID0gV2ViSW5zcGVjdG9yLlVJU3RyaW5nKCJB ZGQiKTsKKyAgICBhZGRFbGVtZW50LmFkZEV2ZW50TGlzdGVuZXIoImNsaWNrIiwgdGhpcy5zZWN0 aW9uLmFkZEV4cHJlc3Npb24uYmluZCh0aGlzLnNlY3Rpb24pLCBmYWxzZSk7CisKKyAgICB2YXIg cmVmcmVzaEVsZW1lbnQgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCJidXR0b24iKTsKKyAgICBy ZWZyZXNoRWxlbWVudC5zZXRBdHRyaWJ1dGUoInR5cGUiLCAiYnV0dG9uIik7CisgICAgcmVmcmVz aEVsZW1lbnQudGV4dENvbnRlbnQgPSBXZWJJbnNwZWN0b3IuVUlTdHJpbmcoIlJlZnJlc2giKTsK KyAgICByZWZyZXNoRWxlbWVudC5hZGRFdmVudExpc3RlbmVyKCJjbGljayIsIHRoaXMuc2VjdGlv bi51cGRhdGUuYmluZCh0aGlzLnNlY3Rpb24pLCBmYWxzZSk7CisKKyAgICB2YXIgY2VudGVyRWxl bWVudCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoImRpdiIpOworICAgIGNlbnRlckVsZW1lbnQu YWRkU3R5bGVDbGFzcygid2F0Y2gtZXhwcmVzc2lvbnMtYnV0dG9ucy1jb250YWluZXIiKTsKKyAg ICBjZW50ZXJFbGVtZW50LmFwcGVuZENoaWxkKGFkZEVsZW1lbnQpOworICAgIGNlbnRlckVsZW1l bnQuYXBwZW5kQ2hpbGQocmVmcmVzaEVsZW1lbnQpOworICAgIHRoaXMuYm9keUVsZW1lbnQuYXBw ZW5kQ2hpbGQoY2VudGVyRWxlbWVudCk7CisKKyAgICB0aGlzLmV4cGFuZGVkID0gdGhpcy5zZWN0 aW9uLmxvYWRTYXZlZEV4cHJlc3Npb25zKCkubGVuZ3RoID4gMDsKKyAgICB0aGlzLm9uZXhwYW5k ID0gdGhpcy5yZWZyZXNoRXhwcmVzc2lvbnMuYmluZCh0aGlzKTsKK30KKworV2ViSW5zcGVjdG9y LldhdGNoRXhwcmVzc2lvbnNTaWRlYmFyUGFuZS5wcm90b3R5cGUgPSB7CisgICAgcmVmcmVzaEV4 cHJlc3Npb25zOiBmdW5jdGlvbigpCisgICAgeworICAgICAgICB0aGlzLnNlY3Rpb24udXBkYXRl KCk7CisgICAgfQorfQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NpZGViYXJQYW5l LnByb3RvdHlwZS5fX3Byb3RvX18gPSBXZWJJbnNwZWN0b3IuU2lkZWJhclBhbmUucHJvdG90eXBl OworCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24gPSBmdW5jdGlvbigpCit7 CisgICAgV2ViSW5zcGVjdG9yLk9iamVjdFByb3BlcnRpZXNTZWN0aW9uLmNhbGwodGhpcyk7CisK KyAgICB0aGlzLndhdGNoRXhwcmVzc2lvbnMgPSB0aGlzLmxvYWRTYXZlZEV4cHJlc3Npb25zKCk7 CisKKyAgICB0aGlzLmhlYWRlckVsZW1lbnQuY2xhc3NOYW1lID0gImhpZGRlbiI7CisgICAgdGhp cy5lZGl0YWJsZSA9IHRydWU7CisgICAgdGhpcy5leHBhbmRlZCA9IHRydWU7CisgICAgdGhpcy5w cm9wZXJ0aWVzRWxlbWVudC5hZGRTdHlsZUNsYXNzKCJ3YXRjaC1leHByZXNzaW9ucyIpOworfQor CitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24uTmV3V2F0Y2hFeHByZXNzaW9u ID0gIlx4QTAiOworCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24ucHJvdG90 eXBlID0geworICAgIHVwZGF0ZTogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgZnVuY3Rpb24g YXBwZW5kUmVzdWx0KGV4cHJlc3Npb24sIHdhdGNoSW5kZXgsIHJlc3VsdCwgZXhjZXB0aW9uKQor ICAgICAgICB7CisgICAgICAgICAgICAvLyBUaGUgbnVsbCBjaGVjayBjYXRjaGVzIHNvbWUgb3Ro ZXIgY2FzZXMsIGxpa2UgbnVsbCBpdHNlbGYsIGFuZCBOYU4KKyAgICAgICAgICAgIGlmICgodHlw ZW9mIHJlc3VsdCAhPT0gIm9iamVjdCIpIHx8IChyZXN1bHQgPT0gbnVsbCkpCisgICAgICAgICAg ICAgICAgcmVzdWx0ID0gbmV3IFdlYkluc3BlY3Rvci5PYmplY3RQcm94eShudWxsLCBbXSwgMCwg U3RyaW5nKHJlc3VsdCksIGZhbHNlKTsKKworICAgICAgICAgICAgdmFyIHByb3BlcnR5ID0gbmV3 IFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0eVByb3h5KGV4cHJlc3Npb24sIHJlc3VsdCk7Cisg ICAgICAgICAgICBwcm9wZXJ0eS53YXRjaEluZGV4ID0gd2F0Y2hJbmRleDsKKworICAgICAgICAg ICAgLy8gRm9yIG5ld2x5IGFkZGVkLCBlbXB0eSBleHByZXNzaW9ucywgc2V0IGRlc2NyaXB0aW9u IHRvICIiLAorICAgICAgICAgICAgLy8gc2luY2Ugb3RoZXJ3aXNlIHlvdSBnZXQgRE9NV2luZG93 CisgICAgICAgICAgICBpZiAocHJvcGVydHkubmFtZSA9PT0gV2ViSW5zcGVjdG9yLldhdGNoRXhw cmVzc2lvbnNTZWN0aW9uLk5ld1dhdGNoRXhwcmVzc2lvbikgCisgICAgICAgICAgICAgICAgcHJv cGVydHkudmFsdWUuZGVzY3JpcHRpb24gPSAiIjsKKyAgICAgICAgICAgIAorICAgICAgICAgICAg Ly8gVG8gY2xhcmlmeSB3aGF0J3MgZ29pbmcgb24gaGVyZTogCisgICAgICAgICAgICAvLyBJbiB0 aGUgb3V0ZXIgZnVuY3Rpb24sIHdlIGNhbGN1bGF0ZSB0aGUgbnVtYmVyIG9mIHByb3BlcnRpZXMK KyAgICAgICAgICAgIC8vIHRoYXQgd2UncmUgZ29pbmcgdG8gYmUgdXBkYXRpbmcsIGFuZCBzZXQg dGhhdCBpbiB0aGUKKyAgICAgICAgICAgIC8vIHByb3BlcnR5Q291bnQgdmFyaWFibGUuICAKKyAg ICAgICAgICAgIC8vIEluIHRoaXMgZnVuY3Rpb24sIHdlIHRlc3QgdG8gc2VlIHdoZW4gd2UgYXJl IHByb2Nlc3NpbmcgdGhlIAorICAgICAgICAgICAgLy8gbGFzdCBwcm9wZXJ0eSwgYW5kIHRoZW4g Y2FsbCB0aGUgc3VwZXJjbGFzcydzIHVwZGF0ZVByb3BlcnRpZXMoKSAKKyAgICAgICAgICAgIC8v IG1ldGhvZCB0byBnZXQgYWxsIHRoZSBwcm9wZXJ0aWVzIHJlZnJlc2hlZCBhdCBvbmNlLgorICAg ICAgICAgICAgcHJvcGVydGllcy5wdXNoKHByb3BlcnR5KTsKKyAgICAgICAgICAgIAorICAgICAg ICAgICAgaWYgKHByb3BlcnRpZXMubGVuZ3RoID09IHByb3BlcnR5Q291bnQpCisgICAgICAgICAg ICAgICAgdGhpcy51cGRhdGVQcm9wZXJ0aWVzKHByb3BlcnRpZXMsIFdlYkluc3BlY3Rvci5XYXRj aEV4cHJlc3Npb25UcmVlRWxlbWVudCwgV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVzc2lvbnNTZWN0 aW9uLkNvbXBhcmVQcm9wZXJ0aWVzKTsKKyAgICAgICAgfQorCisgICAgICAgIHZhciBwcm9wZXJ0 aWVzID0gW107CisKKyAgICAgICAgLy8gQ291bnQgdGhlIHByb3BlcnRpZXMsIHNvIHdlIGtub3du IHdoZW4gdG8gY2FsbCB0aGlzLnVwZGF0ZVByb3BlcnRpZXMoKQorICAgICAgICAvLyBpbiBhcHBl bmRSZXN1bHQoKQorICAgICAgICB2YXIgcHJvcGVydHlDb3VudCA9IDA7CisgICAgICAgIGZvciAo dmFyIGkgPSAwOyBpIDwgdGhpcy53YXRjaEV4cHJlc3Npb25zLmxlbmd0aDsgKytpKSB7CisgICAg ICAgICAgICBpZiAoIXRoaXMud2F0Y2hFeHByZXNzaW9uc1tpXSkgCisgICAgICAgICAgICAgICAg Y29udGludWU7CisgICAgICAgICAgICArK3Byb3BlcnR5Q291bnQ7CisgICAgICAgIH0KKworICAg ICAgICAvLyBOb3cgcHJvY2VzcyBhbGwgdGhlIGV4cHJlc3Npb25zLCBzaW5jZSB3ZSBoYXZlIHRo ZSBhY3R1YWwgY291bnQsCisgICAgICAgIC8vIHdoaWNoIGlzIGNoZWNrZWQgaW4gdGhlIGFwcGVu ZFJlc3VsdCBpbm5lciBmdW5jdGlvbi4KKyAgICAgICAgZm9yICh2YXIgaSA9IDA7IGkgPCB0aGlz LndhdGNoRXhwcmVzc2lvbnMubGVuZ3RoOyArK2kpIHsKKyAgICAgICAgICAgIHZhciBleHByZXNz aW9uID0gdGhpcy53YXRjaEV4cHJlc3Npb25zW2ldOworICAgICAgICAgICAgaWYgKCFleHByZXNz aW9uKSAKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICAgICAgV2ViSW5zcGVj dG9yLmNvbnNvbGUuZXZhbEluSW5zcGVjdGVkV2luZG93KCIoIiArIGV4cHJlc3Npb24gKyAiKSIs IGFwcGVuZFJlc3VsdC5iaW5kKHRoaXMsIGV4cHJlc3Npb24sIGkpKTsKKyAgICAgICAgfQorCisg ICAgICAgIC8vIG5vdGUgdGhpcyBpcyBzZXR0aW5nIHRoZSBleHBhbnNpb24gb2YgdGhlIHRyZWUs IG5vdCB0aGUgc2VjdGlvbjsKKyAgICAgICAgLy8gd2l0aCBubyBleHByZXNzaW9ucywgYW5kIGV4 cGFuZGVkIHRyZWUsIHdlIGdldCBzb21lIGV4dHJhIHZlcnRpY2FsCisgICAgICAgIC8vIHdoaXRl IHNwYWNlCisgICAgICAgIC8vIEZJWE1FOiBzaG91bGQgY2hhbmdlIHRvIHVzZSBoZWFkZXIgYnV0 dG9ucyBpbnN0ZWFkIG9mIHRoZSBidXR0b25zCisgICAgICAgIC8vIGF0IHRoZSBib3R0b20gb2Yg dGhlIHNlY3Rpb24sIHRoZW4gd2UgY2FuIGFkZCBhICJObyBXYXRjaCBFeHByZXNzaW9ucworICAg ICAgICAvLyBlbGVtZW50IHdoZW4gdGhlcmUgYXJlIG5vIHdhdGNoIGV4cHJlc3Npb25zLCBhbmQg dGhpcyBpc3N1ZSBzaG91bGQKKyAgICAgICAgLy8gZ28gYXdheS4KKyAgICAgICAgdGhpcy5leHBh bmRlZCA9IChwcm9wZXJ0eUNvdW50ICE9IDApOworICAgIH0sCisKKyAgICBhZGRFeHByZXNzaW9u OiBmdW5jdGlvbigpCisgICAgeworICAgICAgICB0aGlzLndhdGNoRXhwcmVzc2lvbnMucHVzaChX ZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24uTmV3V2F0Y2hFeHByZXNzaW9uKTsK KyAgICAgICAgdGhpcy51cGRhdGUoKTsKKworICAgICAgICAvLyBBZnRlciB1cGRhdGUoKSwgdGhl IG5ldyBlbXB0eSBleHByZXNzaW9uIHRvIGJlIGVkaXRlZAorICAgICAgICAvLyB3aWxsIGJlIGlu IHRoZSB0cmVlLCBidXQgd2UgaGF2ZSB0byBmaW5kIGl0LgorICAgICAgICB0cmVlRWxlbWVudCA9 IHRoaXMuZmluZEFkZGVkVHJlZUVsZW1lbnQoKTsKKyAgICAgICAgaWYgKHRyZWVFbGVtZW50KQor ICAgICAgICAgICAgdHJlZUVsZW1lbnQuc3RhcnRFZGl0aW5nKCk7CisgICAgfSwKKworICAgIHVw ZGF0ZUV4cHJlc3Npb246IGZ1bmN0aW9uKGVsZW1lbnQsIHZhbHVlKQorICAgIHsKKyAgICAgICAg dGhpcy53YXRjaEV4cHJlc3Npb25zW2VsZW1lbnQucHJvcGVydHkud2F0Y2hJbmRleF0gPSB2YWx1 ZTsKKyAgICAgICAgdGhpcy5zYXZlRXhwcmVzc2lvbnMoKTsKKyAgICAgICAgdGhpcy51cGRhdGUo KTsKKyAgICB9LAorCisgICAgZmluZEFkZGVkVHJlZUVsZW1lbnQ6IGZ1bmN0aW9uKCkKKyAgICB7 CisgICAgICAgIHZhciBjaGlsZHJlbiA9IHRoaXMucHJvcGVydGllc1RyZWVPdXRsaW5lLmNoaWxk cmVuOworICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IGNoaWxkcmVuLmxlbmd0aDsgKytpKQor ICAgICAgICAgICAgaWYgKGNoaWxkcmVuW2ldLnByb3BlcnR5Lm5hbWUgPT09IFdlYkluc3BlY3Rv ci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5OZXdXYXRjaEV4cHJlc3Npb24pCisgICAgICAgICAg ICAgICAgcmV0dXJuIGNoaWxkcmVuW2ldOworICAgIH0sCisKKyAgICBsb2FkU2F2ZWRFeHByZXNz aW9uczogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgdmFyIGpzb24gPSBJbnNwZWN0b3JDb250 cm9sbGVyLnNldHRpbmcoIndhdGNoRXhwcmVzc2lvbnMiKTsKKyAgICAgICAgaWYgKCFqc29uKQor ICAgICAgICAgICAgcmV0dXJuIFtdOworCisgICAgICAgIHRyeSB7CisgICAgICAgICAgICBqc29u ID0gSlNPTi5wYXJzZShqc29uKTsKKyAgICAgICAgfSBjYXRjaChlKSB7CisgICAgICAgICAgICBy ZXR1cm4gW107CisgICAgICAgIH0KKworICAgICAgICByZXR1cm4ganNvbi5leHByZXNzaW9ucyB8 fCBbXTsKKyAgICB9LAorCisgICAgc2F2ZUV4cHJlc3Npb25zOiBmdW5jdGlvbigpCisgICAgewor ICAgICAgICB2YXIgdG9TYXZlID0gW107CisgICAgICAgIGZvciAodmFyIGkgPSAwOyBpIDwgdGhp cy53YXRjaEV4cHJlc3Npb25zLmxlbmd0aDsgaSsrKQorICAgICAgICAgICAgaWYgKHRoaXMud2F0 Y2hFeHByZXNzaW9uc1tpXSkKKyAgICAgICAgICAgICAgICB0b1NhdmUucHVzaCh0aGlzLndhdGNo RXhwcmVzc2lvbnNbaV0pOworCisgICAgICAgIHZhciBqc29uID0gSlNPTi5zdHJpbmdpZnkoe2V4 cHJlc3Npb25zOiB0b1NhdmV9KTsKKyAgICAgICAgSW5zcGVjdG9yQ29udHJvbGxlci5zZXRTZXR0 aW5nKCJ3YXRjaEV4cHJlc3Npb25zIiwganNvbik7CisKKyAgICAgICAgcmV0dXJuIHRvU2F2ZS5s ZW5ndGg7CisgICAgfQorfQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uc1NlY3Rpb24u cHJvdG90eXBlLl9fcHJvdG9fXyA9IFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0aWVzU2VjdGlv bi5wcm90b3R5cGU7CisKK1dlYkluc3BlY3Rvci5XYXRjaEV4cHJlc3Npb25zU2VjdGlvbi5Db21w YXJlUHJvcGVydGllcyA9IGZ1bmN0aW9uKHByb3BlcnR5QSwgcHJvcGVydHlCKSAKK3sKKyAgICBp ZiAocHJvcGVydHlBLndhdGNoSW5kZXggPT0gcHJvcGVydHlCLndhdGNoSW5kZXgpCisgICAgICAg IHJldHVybiAwOworICAgIGVsc2UgaWYgKHByb3BlcnR5QS53YXRjaEluZGV4IDwgcHJvcGVydHlC LndhdGNoSW5kZXgpCisgICAgICAgIHJldHVybiAtMTsKKyAgICBlbHNlCisgICAgICAgIHJldHVy biAxOworfQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1lbnQgPSBmdW5j dGlvbihwcm9wZXJ0eSkKK3sKKyAgICBXZWJJbnNwZWN0b3IuT2JqZWN0UHJvcGVydHlUcmVlRWxl bWVudC5jYWxsKHRoaXMsIHByb3BlcnR5KTsKK30KKworV2ViSW5zcGVjdG9yLldhdGNoRXhwcmVz c2lvblRyZWVFbGVtZW50LnByb3RvdHlwZSA9IHsKKyAgICB1cGRhdGU6IGZ1bmN0aW9uKCkKKyAg ICB7CisgICAgICAgIFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3Rv dHlwZS51cGRhdGUuY2FsbCh0aGlzKTsKKworICAgICAgICB2YXIgZGVsZXRlQnV0dG9uID0gZG9j dW1lbnQuY3JlYXRlRWxlbWVudCgiaW5wdXQiKTsKKyAgICAgICAgZGVsZXRlQnV0dG9uLnR5cGUg PSAiYnV0dG9uIjsKKyAgICAgICAgZGVsZXRlQnV0dG9uLnRpdGxlID0gV2ViSW5zcGVjdG9yLlVJ U3RyaW5nKCJEZWxldGUgd2F0Y2ggZXhwcmVzc2lvbi4iKTsKKyAgICAgICAgZGVsZXRlQnV0dG9u LmFkZFN0eWxlQ2xhc3MoImVuYWJsZWQtYnV0dG9uIik7CisgICAgICAgIGRlbGV0ZUJ1dHRvbi5h ZGRTdHlsZUNsYXNzKCJkZWxldGUtYnV0dG9uIik7CisgICAgICAgIGRlbGV0ZUJ1dHRvbi5hZGRF dmVudExpc3RlbmVyKCJjbGljayIsIHRoaXMuX2RlbGV0ZUJ1dHRvbkNsaWNrZWQuYmluZCh0aGlz KSwgZmFsc2UpOworCisgICAgICAgIHRoaXMubGlzdEl0ZW1FbGVtZW50Lmluc2VydEJlZm9yZShk ZWxldGVCdXR0b24sIHRoaXMubGlzdEl0ZW1FbGVtZW50LmZpcnN0Q2hpbGQpOworICAgIH0sCisK KyAgICBfZGVsZXRlQnV0dG9uQ2xpY2tlZDogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgdGhp cy50cmVlT3V0bGluZS5zZWN0aW9uLnVwZGF0ZUV4cHJlc3Npb24odGhpcywgbnVsbCk7CisgICAg fSwKKworICAgIHN0YXJ0RWRpdGluZzogZnVuY3Rpb24oKQorICAgIHsKKyAgICAgICAgaWYgKFdl Ykluc3BlY3Rvci5pc0JlaW5nRWRpdGVkKHRoaXMubmFtZUVsZW1lbnQpIHx8ICF0aGlzLnRyZWVP dXRsaW5lLnNlY3Rpb24uZWRpdGFibGUpCisgICAgICAgICAgICByZXR1cm47CisKKyAgICAgICAg dGhpcy5uYW1lRWxlbWVudC50ZXh0Q29udGVudCA9IHRoaXMucHJvcGVydHkubmFtZS50cmltV2hp dGVzcGFjZSgpOworCisgICAgICAgIHZhciBjb250ZXh0ID0geyBleHBhbmRlZDogdGhpcy5leHBh bmRlZCB9OworCisgICAgICAgIC8vIGNvbGxhcHNlIHRlbXBvcmFyaWx5LCBpZiByZXF1aXJlZAor ICAgICAgICB0aGlzLmhhc0NoaWxkcmVuID0gZmFsc2U7CisKKyAgICAgICAgdGhpcy5saXN0SXRl bUVsZW1lbnQuYWRkU3R5bGVDbGFzcygiZWRpdGluZy1zdWItcGFydCIpOworCisgICAgICAgIFdl Ykluc3BlY3Rvci5zdGFydEVkaXRpbmcodGhpcy5uYW1lRWxlbWVudCwgdGhpcy5lZGl0aW5nQ29t bWl0dGVkLmJpbmQodGhpcyksIHRoaXMuZWRpdGluZ0NhbmNlbGxlZC5iaW5kKHRoaXMpLCBjb250 ZXh0KTsKKyAgICB9LAorCisgICAgZWRpdGluZ0NhbmNlbGxlZDogZnVuY3Rpb24oZWxlbWVudCwg Y29udGV4dCkKKyAgICB7CisgICAgICAgIGlmICghdGhpcy5uYW1lRWxlbWVudC50ZXh0Q29udGVu dCkKKyAgICAgICAgICAgIHRoaXMudHJlZU91dGxpbmUuc2VjdGlvbi51cGRhdGVFeHByZXNzaW9u KHRoaXMsIG51bGwpOworICAgICAgICAgICAgCisgICAgICAgIHRoaXMudXBkYXRlKCk7CisgICAg ICAgIHRoaXMuZWRpdGluZ0VuZGVkKGNvbnRleHQpOworICAgIH0sCisKKyAgICBhcHBseUV4cHJl c3Npb246IGZ1bmN0aW9uKGV4cHJlc3Npb24sIHVwZGF0ZUludGVyZmFjZSkKKyAgICB7CisgICAg ICAgIGV4cHJlc3Npb24gPSBleHByZXNzaW9uLnRyaW1XaGl0ZXNwYWNlKCk7CisKKyAgICAgICAg aWYgKCFleHByZXNzaW9uKQorICAgICAgICAgICAgZXhwcmVzc2lvbiA9IG51bGw7CisKKyAgICAg ICAgdGhpcy5wcm9wZXJ0eS5uYW1lID0gZXhwcmVzc2lvbjsKKyAgICAgICAgdGhpcy50cmVlT3V0 bGluZS5zZWN0aW9uLnVwZGF0ZUV4cHJlc3Npb24odGhpcywgZXhwcmVzc2lvbik7CisgICAgfQor fQorCitXZWJJbnNwZWN0b3IuV2F0Y2hFeHByZXNzaW9uVHJlZUVsZW1lbnQucHJvdG90eXBlLl9f cHJvdG9fXyA9IFdlYkluc3BlY3Rvci5PYmplY3RQcm9wZXJ0eVRyZWVFbGVtZW50LnByb3RvdHlw ZTsKSW5kZXg6IFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9XZWJLaXQucXJjCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9XZWJLaXQucXJjCShyZXZpc2lvbiA0 ODM5OCkKKysrIFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9XZWJLaXQucXJjCSh3b3JraW5n IGNvcHkpCkBAIC02Miw2ICs2Miw3IEBACiAgICAgPGZpbGU+dHJlZW91dGxpbmUuanM8L2ZpbGU+ CiAgICAgPGZpbGU+dXRpbGl0aWVzLmpzPC9maWxlPgogICAgIDxmaWxlPlZpZXcuanM8L2ZpbGU+ CisgICAgPGZpbGU+V2F0Y2hFeHByZXNzaW9uc1NpZGViYXJQYW5lLmpzPC9maWxlPgogICAgIDxm aWxlPmluc3BlY3Rvci5jc3M8L2ZpbGU+CiAgICAgPGZpbGU+SW1hZ2VzL2JhY2sucG5nPC9maWxl PgogICAgIDxmaWxlPkltYWdlcy9jaGVja2VyLnBuZzwvZmlsZT4KSW5kZXg6IFdlYkNvcmUvaW5z cGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuY3NzCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvaW5z cGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuY3NzCShyZXZpc2lvbiA0ODM5OCkKKysrIFdlYkNv cmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0b3IuY3NzCSh3b3JraW5nIGNvcHkpCkBAIC0x MjA2LDYgKzEyMDYsMTAgQEAgYm9keS5pbmFjdGl2ZSAucGxhY2FyZC5zZWxlY3RlZCB7CiAgICAg bWFyZ2luLWJvdHRvbTogMXB4OwogfQogCisud2F0Y2gtZXhwcmVzc2lvbnMtYnV0dG9ucy1jb250 YWluZXIgeworICAgIHRleHQtYWxpZ246IGNlbnRlcjsKK30KKwogLnNlY3Rpb24gLmhlYWRlciB7 CiAgICAgcGFkZGluZzogMnB4IDhweCA0cHggMThweDsKICAgICBib3JkZXItdG9wOiAxcHggc29s aWQgcmdiKDE0NSwgMTYwLCAxOTIpOwpAQCAtMTM3MiwxMCArMTM3NiwxOSBAQCBib2R5LmluYWN0 aXZlIC5wbGFjYXJkLnNlbGVjdGVkIHsKICAgICB0ZXh0LW92ZXJmbG93OiBjbGlwOwogfQogCi1s aS5lZGl0aW5nIC5zd2F0Y2gsIGxpLmVkaXRpbmcgLmVuYWJsZWQtYnV0dG9uIHsKK2xpLmVkaXRp bmcgLnN3YXRjaCwgbGkuZWRpdGluZyAuZW5hYmxlZC1idXR0b24sICBsaS5lZGl0aW5nLXN1Yi1w YXJ0IC5kZWxldGUtYnV0dG9uIHsKICAgICBkaXNwbGF5OiBub25lICFpbXBvcnRhbnQ7CiB9CiAK Ky53YXRjaC1leHByZXNzaW9ucyA+IGxpLmVkaXRpbmctc3ViLXBhcnQgLm5hbWUgeworICAgIGRp c3BsYXk6IGJsb2NrOyAKKyAgICB3aWR0aDogMTAwJTsKK30KKworLndhdGNoLWV4cHJlc3Npb25z ID4gbGkuZWRpdGluZy1zdWItcGFydCAudmFsdWUsIC53YXRjaC1leHByZXNzaW9ucyA+IGxpLmVk aXRpbmctc3ViLXBhcnQgLnNlcGFyYXRvciAgeworICAgIGRpc3BsYXk6IG5vbmU7Cit9CisKIC5z ZWN0aW9uIC5wcm9wZXJ0aWVzIGxpLmVkaXRpbmctc3ViLXBhcnQgewogICAgIHBhZGRpbmc6IDNw eCA2cHggOHB4IDE4cHg7CiAgICAgbWFyZ2luOiAtM3B4IC02cHggLThweCAtNnB4OwpAQCAtMTQw OSw2ICsxNDIyLDE3IEBAIGxpLmVkaXRpbmcgLnN3YXRjaCwgbGkuZWRpdGluZyAuZW5hYmxlZC0K ICAgICB6LWluZGV4OiAxOwogfQogCisvKiBGSVhNRTogbmVlZCBhIGJldHRlciBpY29uIChjb21t ZW50IGluIGJ1ZyAyNzUxNCkgKi8KKy5zZWN0aW9uIC5wcm9wZXJ0aWVzIC5kZWxldGUtYnV0dG9u IHsKKyAgICB3aWR0aDogMTBweDsKKyAgICBoZWlnaHQ6IDEwcHg7CisgICAgYmFja2dyb3VuZC1p bWFnZTogdXJsKEltYWdlcy9lcnJvckljb24ucG5nKTsKKyAgICBiYWNrZ3JvdW5kLXBvc2l0aW9u OiAwIDA7CisgICAgYmFja2dyb3VuZC1jb2xvcjogdHJhbnNwYXJlbnQ7CisgICAgYmFja2dyb3Vu ZC1yZXBlYXQ6IG5vLXJlcGVhdDsKKyAgICBib3JkZXI6IDAgbm9uZSB0cmFuc3BhcmVudDsKK30K KwogLnNlY3Rpb246aG92ZXIgLnByb3BlcnRpZXMgLmVuYWJsZWQtYnV0dG9uIHsKICAgICBkaXNw bGF5OiBibG9jazsKIH0KSW5kZXg6IFdlYkNvcmUvaW5zcGVjdG9yL2Zyb250LWVuZC9pbnNwZWN0 b3IuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2luc3BlY3Rvci9mcm9udC1lbmQvaW5zcGVj dG9yLmh0bWwJKHJldmlzaW9uIDQ4Mzk4KQorKysgV2ViQ29yZS9pbnNwZWN0b3IvZnJvbnQtZW5k L2luc3BlY3Rvci5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC02Miw2ICs2Miw3IEBAIFRISVMgU09G VFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE8KICAgICA8c2NyaXB0IHR5cGU9InRleHQv amF2YXNjcmlwdCIgc3JjPSJCcmVha3BvaW50c1NpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAg ICA8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJDYWxsU3RhY2tTaWRlYmFyUGFu ZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiIHNyYz0i U2NvcGVDaGFpblNpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KKyAgICA8c2NyaXB0IHR5cGU9InRl eHQvamF2YXNjcmlwdCIgc3JjPSJXYXRjaEV4cHJlc3Npb25zU2lkZWJhclBhbmUuanMiPjwvc2Ny aXB0PgogICAgIDxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0IiBzcmM9Ik1ldHJpY3NTaWRl YmFyUGFuZS5qcyI+PC9zY3JpcHQ+CiAgICAgPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQi IHNyYz0iUHJvcGVydGllc1NpZGViYXJQYW5lLmpzIj48L3NjcmlwdD4KICAgICA8c2NyaXB0IHR5 cGU9InRleHQvamF2YXNjcmlwdCIgc3JjPSJDb2xvci5qcyI+PC9zY3JpcHQ+CkluZGV4OiBXZWJD b3JlL21hbnVhbC10ZXN0cy9pbnNwZWN0b3IvZGVidWdnZXItd2F0Y2gtZXhwcmVzc2lvbnMuaHRt bAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL21hbnVhbC10ZXN0cy9pbnNwZWN0b3IvZGVidWdnZXIt d2F0Y2gtZXhwcmVzc2lvbnMuaHRtbAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvbWFudWFsLXRl c3RzL2luc3BlY3Rvci9kZWJ1Z2dlci13YXRjaC1leHByZXNzaW9ucy5odG1sCShyZXZpc2lvbiAw KQpAQCAtMCwwICsxLDExNSBAQAorPHA+VGVzdCBmb3IgCis8YSBocmVmPSJodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mjc1MTQiPkJ1ZyAyNzUxNCAtIGFkZCBzdXBwb3J0 IGZvciB3YXRjaGVkIGV4cHJlc3Npb248L2E+LgorCis8cD5UbyBiZWdpbiB0ZXN0LCBvcGVuIHdl YiBpbnNwZWN0b3IsIGdvIHRoZSBzY3JpcHRzIHBhbmVsIAorKGVuYWJsaW5nIHNjcmlwdCBkZWJ1 Z2dpbmcgaWYgbmVjY2Nlc3NhcnkpLCBhbmQgdGhlbiBjbGljayB0aGlzIGxpbms6Cis8YSBocmVm PSJqYXZhc2NyaXB0OnJ1blRlc3QoKSI+W2JlZ2luIHRlc3RdPC9hPi4KKworPHA+UGVyZm9ybSB0 aGUgZm9sbG93aW5nIHN0ZXBzLCBhbmQgbm90ZSB0aGUgZXhwZWN0ZWQgcmVzdWx0czoKKyAgICAK KzxvbD4KKyAgICAKKzxsaT48cD5BZnRlciBjbGlja2luZyB0aGUgbGluayBhYm92ZSwgeW91IHNo b3VsZCBub3cgYmUgcGF1c2VkIGluIHRoZSBib2R5IG9mIAordGhlIHRlc3QgbWV0aG9kLCB0aGFu a3MgdG8gdGhlIDxjb2RlPmRlYnVnZ2VyPC9jb2RlPiBzdGF0ZW1lbnQuCisKKzxsaT48cD5BZGQg dGhlIGZvbGxvd2luZyBleHByZXNzaW9ucyB0byB0aGUgIldhdGNoIEV4cHJlc3Npb25zIiBzZWN0 aW9uIG9mIHRoZQorU2NyaXB0cyBwYW5lbCBzaWRlYmFyIHBhbmU6ICI8Y29kZT50aGlzPC9jb2Rl PiIsICI8Y29kZT5hPC9jb2RlPiIsIAorIjxjb2RlPmI8L2NvZGU+IiwgIjxjb2RlPmM8L2NvZGU+ IiBhbmQgIjxjb2RlPmQ8L2NvZGU+Ii4gRG8gPGI+Tk9UPC9iPiBlbnRlciB0aGUgcXVvdGVzLgor Cis8bGk+PHA+VGhlIHZhbHVlcyBvZiB0aGUgZXhwcmVzc2lvbnMgYXMgc2hvd24gaW4gdGhlIHdp bmRvdyBzaG91bGQgYSAKKzxjb2RlPkRPTVdpbmRvdzwvY29kZT4gZm9yIDxjb2RlPnRoaXM8L2Nv ZGU+LCA8Y29kZT51bmRlZmluZWQ8L2NvZGU+IGZvcgordGhlIDxjb2RlPmE8L2NvZGU+LCA8Y29k ZT5iPC9jb2RlPiwgYW5kIDxjb2RlPmM8L2NvZGU+IHZhcmlhYmxlcywgYW5kIGEgCit2YWx1ZSBv ZiA8Y29kZT5SZWZlcmVuY2VFcnJvcjogQ2FuJ3QgZmluZCB2YXJpYWJsZTogZDwvY29kZT4KK2Zv ciB0aGUgPGNvZGU+ZDwvY29kZT4gdmFyaWFibGUuCisKKzxsaT48cD5Ob3RlIHRoYXQgdGhlIHZh bHVlIGZvciA8Y29kZT5kPC9jb2RlPiBzaG91bGQgbm90IGNoYW5nZSBmb3IgdGhlIGxpZmUgb2Yg Cit0aGUgdGVzdCwgYXMgdGhlIHZhcmlhYmxlIDxjb2RlPmQ8L2NvZGU+IGlzIG5ldmVyIGludHJv ZHVjZWQgaW4gdGhlIHByb2dyYW0uCisKKzxsaT48cD5TdGVwIHRocm91Z2ggdGhlIGNvZGUsIGFu ZCB5b3UnbGwgc2VlIHRoZSB2YWx1ZXMgb2YgPGNvZGU+YTwvY29kZT4sCis8Y29kZT5iPC9jb2Rl PiwgYW5kIDxjb2RlPmM8L2NvZGU+IGNoYW5nZSwgYXMgdGhlIHZhcmlhYmxlcyBhcmUgYXNzaWdu ZWQuCitBbHNvIG5vdGUgdGhhdCBhcyB0aGUgc2NvcGUgY2hhbmdlcyBkdWUgdG8gdGhlIGZ1bmN0 aW9uIGludm9jYXRpb24sIHZhbHVlcword2lsbCBiZSBjaGFuZ2VkIHRvIHJlZmVyIHRvIHRoZWly IGN1cnJlbnQgc2NvcGUuICBUaGUgPGNvZGU+dGhpczwvY29kZT4KK2V4cHJlc3Npb24gd2lsbCBj aGFuZ2Ugd2hlbiB0aGUgbWV0aG9kIGlzIGludm9rZWQgb24gdGhlIG9iamVjdCBjb25zdHJ1Y3Rl ZCBieQordGhlIHRlc3QuCisKKzxsaT48cD5DbGljayBkaWZmZXJlbnQgc3RhY2sgZnJhbWVzIGlu IHRoZSBDYWxsIFN0YWNrIHNlY3Rpb24gdG8gZW5zdXJlIHRoZQorZXhwcmVzc2lvbnMgY2hhbmdl IHZhbHVlIGFwcHJvcHJpYXRlbHkgYXMgdGhlIGN1cnJlbnQgc3RhY2sgZnJhbWUgY2hhbmdlcy4K KworPGxpPjxwPkRyaXZlIHRoZSBkZWJ1Z2dlciB0aHJvdWdoIHRoZSBlbmQgb2YgdGhlIG91dGVy bW9zdCBmdW5jdGlvbiwgc28gdGhhdAordGhlIGRlYnVnZ2VyIGlzIG5vIGxvbmdlciBpbiBwYXVz ZWQgc3RhdGUuICBUaGUgdmFsdWVzIG9mIAorPGNvZGU+YTwvY29kZT4sIDxjb2RlPmI8L2NvZGU+ LCBhbmQgPGNvZGU+YzwvY29kZT4gc2hvdWxkIGFsbCBiZSBhCitSZWZlcmVuY2VFcnJvciBsaWtl IDxjb2RlPmQ8L2NvZGU+LCBzaW5jZSB0aGVzZSB2YXJpYWJsZXMgYXJlIGRlZmluZWQgaW4gdGhl Cis8Y29kZT5ydW5UZXN0KCk8L2NvZGU+IGZ1bmN0aW9uLCBhbmQgdGhlIGV4cHJlc3Npb25zIGFy ZSBiZWluZyBldmFsdWF0ZWQgYWdhaW5zdAordGhlIGdsb2JhbCBvYmplY3QuCisKKzxsaT48cD5G cm9tIHRoZSBjb25zb2xlLCBleGVjdXRlIHRoZSBzdGF0ZW1lbnQgIjxjb2RlPmEgPSAxPC9jb2Rl PiIuICBUaGUKK3dhdGNoIGV4cHJlc3Npb25zIGRvIG5vdCBjdXJyZW50bHkgcmVmcmVzaCwgc28g dGhlIHZhbHVlIGZvciA8Y29kZT5hPC9jb2RlPgorc2hvdWxkIHN0aWxsIGJlIFJlZmVyZW5jZUVy cm9yLgorCis8bGk+PHA+Q2xpY2sgdGhlICJSZWZyZXNoIiBidXR0b24gaW4gdGhlIFdhdGNoIEV4 cHJlc3Npb25zIHNlY3Rpb24gYW5kIHRoZQordmFsdWUgZm9yICI8Y29kZT5hPC9jb2RlPiIgc2hv dWxkIG5vdyBiZSAiPGNvZGU+MTwvY29kZT4iLgorCis8bGk+PHA+Q2xvc2UgZG93biB0aGUgYnJv d3Nlciwgc3RhcnQgaXQgYmFjayB1cCwgdHJhdmVyc2UgdG8gYSB3ZWIgc2l0ZSwKK2JyaW5nIHVw IHdlYiBpbnNwZWN0b3IsIGdvIHRvIHRoZSBTY3JpcHRzIHBhbmVsLiAgWW91IHNob3VsZCBzZWUg dGhlIHNhbWUKK3NldCBvZiBXYXRjaCBFeHByZXNzaW9ucyBpbiB0aGUgbGlzdCBhcyB5b3UgaGFk IHdoZW4geW91IGxhc3QgdXNlZCB3ZWIKK2luc3BlY3Rvci4KKworPGxpPjxwPkRlbGV0ZSBhbiBl eHByZXNzaW9uIGJ5IG1vdmluZyB0aGUgbW91c2UgaW50byB0aGUgV2F0Y2ggRXhwcmVzc2lvbgor c2VjdGlvbiwgYW5kIGNsaWNraW5nIHRoZSBYIGljb24gd2hpY2ggYXBwZWFycyB0byB0aGUgcmln aHQgb2YgYW4gCitleHByZXNzaW9uIChvbiBob3ZlcikuCisKKzxsaT48cD5EZWxldGUgYW4gZXhw cmVzc2lvbiBieSBkb3VibGUtY2xpY2tpbmcgYW55d2hlcmUgb24gYSB0b3AtbGV2ZWwgbGluZQor b2YgYSB3YXRjaCBleHByZXNzaW9uLCBhbmQgY2hhbmdpbmcgdGhlIGV4cHJlc3Npb24gdG8gYW4g ZW1wdHkgc3RyaW5nIG9yIAorbm90aGluZyBidXQgd2hpdGUtc3BhY2UuCisKKzxsaT48cD5Nb2Rp ZnkgYW4gZW50cnkgYnkgZG91YmxlLWNsaWNraW5nIGFueXdoZXJlIG9uIGEgdG9wLWxldmVsIGxp bmUKK29mIGEgd2F0Y2ggZXhwcmVzc2lvbiwgYW5kIGNoYW5naW5nIHRoZSBleHByZXNzaW9uLgor Cis8bGk+PHA+RW50ZXIgYSBuZXcgZXhwcmVzc2lvbiwgIjxjb2RlPm5ldyBEYXRlKCk8L2NvZGU+ Ii4gIFRoZSB2YWx1ZSBzaG91bGQgYmUKK2EgdG9TdHJpbmcoKSB2ZXJzaW9uIG9mIHRoZSBkYXRl LiAgUmVwZWF0ZWRseSBwcmVzcyB0aGUgUmVmcmVzaCBidXR0b24gdG8gc2VlCit0aGUgdmFsdWUg dXBkYXRlZCB3aXRoIHRoZSBjdXJyZW50IHRpbWUuCisKKzwvb2w+CisKKzxzY3JpcHQ+CitmdW5j dGlvbiBydW5UZXN0KCkgeworICAgIAorICAgIC8vIGEgbmVzdGVkIGZ1bmN0aW9uCisgICAgZnVu Y3Rpb24gc3ViRnVuY3Rpb24oKSB7CisgICAgICAgIGRlYnVnZ2VyOworICAgICAgICB2YXIgYSA9 ICJhIGluIHN1YkZ1bmN0aW9uKCkiOworICAgICAgICAKKyAgICAgICAgc3ViU3ViRnVuY3Rpb24o KTsKKyAgICAgICAgCisgICAgICAgIC8vIGFub3RoZXIgbmVzdGVkIGZ1bmN0aW9uCisgICAgICAg IGZ1bmN0aW9uIHN1YlN1YkZ1bmN0aW9uKCkgeworICAgICAgICAgICAgZGVidWdnZXI7CisgICAg ICAgICAgICB2YXIgYiA9ICJiIGluIHN1YlN1YkZ1bmN0aW9uKCkiOworICAgICAgICB9CisgICAg fQorICAgIAorICAgIC8vIGEgY2xhc3MKKyAgICBmdW5jdGlvbiBhQ2xhc3MoKSB7CisgICAgICAg IHRoaXMueCA9ICJ4eHgiOworICAgICAgICB0aGlzLnkgPSAieXl5IjsKKyAgICB9CisgICAgCisg ICAgYUNsYXNzLnByb3RvdHlwZS5hTWV0aG9kID0gZnVuY3Rpb24oKSB7CisgICAgICAgIGRlYnVn Z2VyOworICAgICAgICB2YXIgYyA9ICJjIGluIGFNZXRob2QoKSI7CisgICAgfQorICAgIAorICAg IC8vIG1haW4gbG9naWMKKyAgICBkZWJ1Z2dlcjsKKyAgICAKKyAgICB2YXIgYSA9ICJhIGluIHJ1 blRlc3QoKSI7CisgICAgdmFyIGIgPSAiYiBpbiBydW5UZXN0KCkiOworICAgIHZhciBjID0gImMg aW4gcnVuVGVzdCgpIjsKKyAgICAKKyAgICBzdWJGdW5jdGlvbigpOworICAgIAorICAgIHZhciBv YmplY3QgPSBuZXcgYUNsYXNzKCk7CisgICAgb2JqZWN0LmFNZXRob2QoKTsKKyAgICAKK30KKzwv c2NyaXB0PgpJbmRleDogV2ViQ29yZS9FbmdsaXNoLmxwcm9qL2xvY2FsaXplZFN0cmluZ3MuanMK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQpDYW5ub3QgZGlzcGxheTogZmlsZSBtYXJrZWQgYXMgYSBiaW5hcnkgdHlwZS4K c3ZuOm1pbWUtdHlwZSA9IGFwcGxpY2F0aW9uL29jdGV0LXN0cmVhbQoKLy81MkFHRUFjZ0FnQUd3 QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFJQUE5QUNBQWJnQmxBSGNB SUFCUApBR0lBYWdCbEFHTUFkQUE3QUFvQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFB Y2dCcEFHNEFad0J6QUZzQUlnQWdBQ2dBCkpRQmtBQ2tBSWdCZEFDQUFQUUFnQUNJQUlBQW9BQ1VB WkFBcEFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnkKQUdrQWJnQm5BSE1B V3dBaUFDQUFLQUJ5QUdVQWNBQmxBR0VBZEFCbEFHUUFJQUFsQUdRQUlBQjBBR2tBYlFCbEFITUFL UUFpQUYwQQpJQUE5QUNBQUlnQWdBQ2dBY2dCbEFIQUFaUUJoQUhRQVpRQmtBQ0FBSlFCa0FDQUFk QUJwQUcwQVpRQnpBQ2tBSWdBN0FBb0FiQUJ2CkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFh UUJ1QUdjQWN3QmJBQ0lBSlFBdUFEQUFaZ0JDQUNJQVhRQWdBRDBBSUFBaUFDVUEKTGdBd0FHWUFR Z0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUln QWxBQzRBTUFCbQpBRzBBY3dBaUFGMEFJQUE5QUNBQUlnQWxBQzRBTUFCbUFHMEFjd0FpQURzQUNn QnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBCmNnQnBBRzRBWndCekFGc0FJZ0FsQUM0QU1R Qm1BQ0FBWkFCaEFIa0Fjd0FpQUYwQUlBQTlBQ0FBSWdBbEFDNEFNUUJtQUNBQVpBQmgKQUhrQWN3 QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdB bEFDNEFNUUJtQUdnQQpjZ0J6QUNJQVhRQWdBRDBBSUFBaUFDVUFMZ0F4QUdZQWFBQnlBSE1BSWdB N0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwCkFISUFhUUJ1QUdjQWN3QmJBQ0lBSlFB dUFERUFaZ0J0QUdrQWJnQWlBRjBBSUFBOUFDQUFJZ0FsQUM0QU1RQm1BRzBBYVFCdUFDSUEKT3dB S0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFDVUFMZ0F5 QUdZQUpRQWxBQ0lBWFFBZwpBRDBBSUFBaUFDVUFMZ0F5QUdZQUpRQWxBQ0lBT3dBS0FHd0Fid0Jq QUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BCld3QWlBQ1VBTGdBeUFHWUFTd0JD QUNJQVhRQWdBRDBBSUFBaUFDVUFMZ0F5QUdZQVN3QkNBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnAK QUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBQ1VBTGdBeUFHWUFjd0FpQUYwQUlBQTlB Q0FBSWdBbEFDNEFNZ0JtQUhNQQpJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBB SElBYVFCdUFHY0Fjd0JiQUNJQUpRQXVBRE1BWmdCTkFFSUFJZ0JkCkFDQUFQUUFnQUNJQUpRQXVB RE1BWmdCTkFFSUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFH Y0EKY3dCYkFDSUFKUUF1QURNQVpnQnRBSE1BSWdCZEFDQUFQUUFnQUNJQUpRQXVBRE1BWmdCdEFI TUFJZ0E3QUFvQWJBQnZBR01BWVFCcwpBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFD SUFKUUJrQUNBQVpRQnlBSElBYndCeUFDSUFYUUFnQUQwQUlBQWlBQ1VBClpBQWdBR1VBY2dCeUFH OEFjZ0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZz QUlnQWwKQUdRQUlBQmxBSElBY2dCdkFISUFMQUFnQUNVQVpBQWdBSGNBWVFCeUFHNEFhUUJ1QUdj QUlnQmRBQ0FBUFFBZ0FDSUFKUUF4QUNRQQpaQUFnQUdVQWNnQnlBRzhBY2dBc0FDQUFKUUF5QUNR QVpBQWdBSGNBWVFCeUFHNEFhUUJ1QUdjQUlnQTdBQW9BYkFCdkFHTUFZUUJzCkFHa0FlZ0JsQUdR QVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQmtBQ0FBWlFCeUFISUFid0J5QUN3QUlBQWxBR1FB SUFCM0FHRUEKY2dCdUFHa0FiZ0JuQUhNQUlnQmRBQ0FBUFFBZ0FDSUFKUUF4QUNRQVpBQWdBR1VB Y2dCeUFHOEFjZ0FzQUNBQUpRQXlBQ1FBWkFBZwpBSGNBWVFCeUFHNEFhUUJ1QUdjQWN3QWlBRHNB Q2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBCklnQWxBR1FB SUFCbEFISUFjZ0J2QUhJQWN3QWlBRjBBSUFBOUFDQUFJZ0FsQUdRQUlBQmxBSElBY2dCdkFISUFj d0FpQURzQUNnQnMKQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJ Z0FsQUdRQUlBQmxBSElBY2dCdkFISUFjd0FzQUNBQQpKUUJrQUNBQWR3QmhBSElBYmdCcEFHNEFa d0FpQUYwQUlBQTlBQ0FBSWdBbEFERUFKQUJrQUNBQVpRQnlBSElBYndCeUFITUFMQUFnCkFDVUFN Z0FrQUdRQUlBQjNBR0VBY2dCdUFHa0FiZ0JuQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpR QmtBRk1BZEFCeUFHa0EKYmdCbkFITUFXd0FpQUNVQVpBQWdBR1VBY2dCeUFHOEFjZ0J6QUN3QUlB QWxBR1FBSUFCM0FHRUFjZ0J1QUdrQWJnQm5BSE1BSWdCZApBQ0FBUFFBZ0FDSUFKUUF4QUNRQVpB QWdBR1VBY2dCeUFHOEFjZ0J6QUN3QUlBQWxBRElBSkFCa0FDQUFkd0JoQUhJQWJnQnBBRzRBClp3 QnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dB aUFDVUFaQUFnQUcwQVlRQjAKQUdNQWFBQmxBSE1BSWdCZEFDQUFQUUFnQUNJQUpRQmtBQ0FBYlFC aEFIUUFZd0JvQUdVQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QQphUUI2QUdVQVpBQlRBSFFBY2dC cEFHNEFad0J6QUZzQUlnQWxBR1FBSUFCekFIUUFlUUJzQUdVQUlBQmpBR2dBWVFCdUFHY0FaUUFp CkFGMEFJQUE5QUNBQUlnQWxBR1FBSUFCekFIUUFlUUJzQUdVQUlBQmpBR2dBWVFCdUFHY0FaUUFp QURzQUNnQnNBRzhBWXdCaEFHd0EKYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0Fs QUdRQUlBQnpBSFFBZVFCc0FHVUFJQUJqQUdnQVlRQnVBR2NBWlFCegpBQ0lBWFFBZ0FEMEFJQUFp QUNVQVpBQWdBSE1BZEFCNUFHd0FaUUFnQUdNQWFBQmhBRzRBWndCbEFITUFJZ0E3QUFvQWJBQnZB R01BCllRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFKUUJrQUNBQWR3QmhB SElBYmdCcEFHNEFad0FpQUYwQUlBQTkKQUNBQUlnQWxBR1FBSUFCM0FHRUFjZ0J1QUdrQWJnQm5B Q0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlB Q1VBWkFBZ0FIY0FZUUJ5QUc0QWFRQnVBR2NBY3dBaUFGMEFJQUE5QUNBQUlnQWxBR1FBSUFCM0FH RUFjZ0J1CkFHa0FiZ0JuQUhNQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFI SUFhUUJ1QUdjQWN3QmJBQ0lBSlFCa0FDQUEKMXdBZ0FDVUFaQUFpQUYwQUlBQTlBQ0FBSWdBbEFE RUFKQUJrQUNBQTF3QWdBQ1VBTWdBa0FHUUFJZ0E3QUFvQWJBQnZBR01BWVFCcwpBR2tBZWdCbEFH UUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFKUUJ6QUNBQUtBQm1BSElBYndCdEFDQUFZd0JoQUdN QWFBQmxBQ2tBCklnQmRBQ0FBUFFBZ0FDSUFKUUJ6QUNBQUtBQm1BSElBYndCdEFDQUFZd0JoQUdN QWFBQmxBQ2tBSWdBN0FBb0FiQUJ2QUdNQVlRQnMKQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdj QWN3QmJBQ0lBSlFCekFDQUFaQUJ2QUhjQWJnQnNBRzhBWVFCa0FDSUFYUUFnQUQwQQpJQUFpQUNV QWN3QWdBR1FBYndCM0FHNEFiQUJ2QUdFQVpBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VB WkFCVEFIUUFjZ0JwCkFHNEFad0J6QUZzQUlnQWxBSE1BSUFCc0FHRUFkQUJsQUc0QVl3QjVBQ0lB WFFBZ0FEMEFJQUFpQUNVQWN3QWdBR3dBWVFCMEFHVUEKYmdCakFIa0FJZ0E3QUFvQWJBQnZBR01B WVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUpRQnpBQ0FBYkFCaApBSFFB WlFCdUFHTUFlUUFzQUNBQUpRQnpBQ0FBWkFCdkFIY0FiZ0JzQUc4QVlRQmtBQ0FBS0FBbEFITUFJ QUIwQUc4QWRBQmhBR3dBCktRQWlBRjBBSUFBOUFDQUFJZ0FsQURFQUpBQnpBQ0FBYkFCaEFIUUFa UUJ1QUdNQWVRQXNBQ0FBSlFBeUFDUUFjd0FnQUdRQWJ3QjMKQUc0QWJBQnZBR0VBWkFBZ0FDZ0FK UUF6QUNRQWN3QWdBSFFBYndCMEFHRUFiQUFwQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQQpa UUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUNnQVlRQnVBRzhBYmdCNUFHMEFid0IxQUhNQUlB Qm1BSFVBYmdCakFIUUFhUUJ2CkFHNEFLUUFpQUYwQUlBQTlBQ0FBSWdBb0FHRUFiZ0J2QUc0QWVR QnRBRzhBZFFCekFDQUFaZ0IxQUc0QVl3QjBBR2tBYndCdUFDa0EKSWdBN0FBb0FiQUJ2QUdNQVlR QnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFLQUJ3QUhJQWJ3Qm5BSElBWVFC dApBQ2tBSWdCZEFDQUFQUUFnQUNJQUtBQndBSElBYndCbkFISUFZUUJ0QUNrQUlnQTdBQW9BYkFC dkFHTUFZUUJzQUdrQWVnQmxBR1FBClV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQUtBQndBSElBYndC bkFISUFZUUJ0QUNrQU9nQWdBQ1VBY3dBaUFGMEFJQUE5QUNBQUlnQW8KQUhBQWNnQnZBR2NBY2dC aEFHMEFLUUE2QUNBQUpRQnpBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5 QUdrQQpiZ0JuQUhNQVd3QWlBQ2dBZEFCbEFIZ0FkQUFwQUNJQVhRQWdBRDBBSUFBaUFDZ0FkQUJs QUhnQWRBQXBBQ0lBT3dBS0FHd0Fid0JqCkFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju QUhNQVd3QWlBQ2dBZHdCb0FHa0FkQUJsQUhNQWNBQmhBR01BWlFBcEFDSUEKWFFBZ0FEMEFJQUFp QUNnQWR3Qm9BR2tBZEFCbEFITUFjQUJoQUdNQVpRQXBBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBB SG9BWlFCawpBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBREVBSUFCdEFHRUFkQUJqQUdnQUlnQmRB Q0FBUFFBZ0FDSUFNUUFnQUcwQVlRQjBBR01BCmFBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZB R1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCQkFHd0FiQUFpQUYwQUlBQTkKQUNBQUlnQkJB R3dBYkFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFG c0FJZ0JCQUd3QQpkd0JoQUhrQWN3QWdBR1VBYmdCaEFHSUFiQUJsQUNJQVhRQWdBRDBBSUFBaUFF RUFiQUIzQUdFQWVRQnpBQ0FBWlFCdUFHRUFZZ0JzCkFHVUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FH a0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVFRQnVBQ0FBWlFCeUFISUEKYndCeUFD QUFid0JqQUdNQWRRQnlBSElBWlFCa0FDQUFkQUJ5QUhrQWFRQnVBR2NBSUFCMEFHOEFYQUJ1QUhJ QVpRQmhBR1FBSUFCMApBR2dBWlFBZ0FCd2dKUUJ6QUIwZ0lBQjBBR0VBWWdCc0FHVUFMZ0FpQUYw QUlBQTlBQ0FBSWdCQkFHNEFJQUJsQUhJQWNnQnZBSElBCklBQnZBR01BWXdCMUFISUFjZ0JsQUdR QUlBQjBBSElBZVFCcEFHNEFad0FnQUhRQWJ3QmNBRzRBY2dCbEFHRUFaQUFnQUhRQWFBQmwKQUNB QUhDQWxBSE1BSFNBZ0FIUUFZUUJpQUd3QVpRQXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9B WlFCa0FGTUFkQUJ5QUdrQQpiZ0JuQUhNQVd3QWlBRUVBYmdBZ0FIVUFiZ0JsQUhnQWNBQmxBR01B ZEFCbEFHUUFJQUJsQUhJQWNnQnZBSElBSUFBbEFITUFJQUJ2CkFHTUFZd0IxQUhJQWNnQmxBR1FB TGdBaUFGMEFJQUE5QUNBQUlnQkJBRzRBSUFCMUFHNEFaUUI0QUhBQVpRQmpBSFFBWlFCa0FDQUEK WlFCeUFISUFid0J5QUNBQUpRQnpBQ0FBYndCakFHTUFkUUJ5QUhJQVpRQmtBQzRBSWdBN0FBb0Fi QUJ2QUdNQVlRQnNBR2tBZWdCbApBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBUVFCMkFHVUFj Z0JoQUdjQVpRQWlBRjBBSUFBOUFDQUFJZ0JCQUhZQVpRQnlBR0VBClp3QmxBQ0lBT3dBS0FHd0Fi d0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFSUFjZ0JsQUdFQWF3 QncKQUc4QWFRQnVBSFFBY3dBaUFGMEFJQUE5QUNBQUlnQkNBSElBWlFCaEFHc0FjQUJ2QUdrQWJn QjBBSE1BSWdBN0FBb0FiQUJ2QUdNQQpZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3 QmJBQ0lBUXdCUEFFOEFTd0JKQUVVQVV3QWlBRjBBSUFBOUFDQUFJZ0JECkFFOEFUd0JMQUVrQVJR QlRBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dB aUFFTUEKWVFCc0FHd0FJQUJUQUhRQVlRQmpBR3NBSWdCZEFDQUFQUUFnQUNJQVF3QmhBR3dBYkFB Z0FGTUFkQUJoQUdNQWF3QWlBRHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dC cEFHNEFad0J6QUZzQUlnQkRBR0VBYkFCc0FITUFJZ0JkQUNBQVBRQWdBQ0lBClF3QmhBR3dBYkFC ekFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0Fp QUVNQWJBQmwKQUdFQWNnQWdBR01BYUFCaEFHNEFad0JsQUhNQUlBQnNBRzhBWndBdUFDSUFYUUFn QUQwQUlBQWlBRU1BYkFCbEFHRUFjZ0FnQUdNQQphQUJoQUc0QVp3QmxBSE1BSUFCc0FHOEFad0F1 QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuCkFITUFXd0Fp QUVNQWJBQmxBR0VBY2dBZ0FHTUFid0J1QUhNQWJ3QnNBR1VBSUFCc0FHOEFad0F1QUNJQVhRQWdB RDBBSUFBaUFFTUEKYkFCbEFHRUFjZ0FnQUdNQWJ3QnVBSE1BYndCc0FHVUFJQUJzQUc4QVp3QXVB Q0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCawpBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlB RU1BYkFCdkFITUFkUUJ5QUdVQUlnQmRBQ0FBUFFBZ0FDSUFRd0JzQUc4QWN3QjFBSElBClpRQWlB RHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCREFH OEFiUUJ3QUhVQWRBQmwKQUdRQUlBQlRBSFFBZVFCc0FHVUFJZ0JkQUNBQVBRQWdBQ0lBUXdCdkFH MEFjQUIxQUhRQVpRQmtBQ0FBVXdCMEFIa0FiQUJsQUNJQQpPd0FLQUd3QWJ3QmpBR0VBYkFCcEFI b0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVNQWJ3QnZBR3NBYVFCbEFITUFJZ0JkCkFD QUFQUUFnQUNJQVF3QnZBRzhBYXdCcEFHVUFjd0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdV QVpBQlRBSFFBY2dCcEFHNEEKWndCekFGc0FJZ0JFQUVFQVZBQkJBRUlBUVFCVEFFVUFVd0FpQUYw QUlBQTlBQ0FBSWdCRUFFRUFWQUJCQUVJQVFRQlRBRVVBVXdBaQpBRHNBQ2dCc0FHOEFZd0JoQUd3 QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCRUFFOEFUUUFpQUYwQUlBQTlBQ0FB CklnQkVBRThBVFFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRB WndCekFGc0FJZ0JFQUdFQWRBQmgKQUdJQVlRQnpBR1VBSUFCdUFHOEFJQUJzQUc4QWJnQm5BR1VB Y2dBZ0FHZ0FZUUJ6QUNBQVpRQjRBSEFBWlFCakFIUUFaUUJrQUNBQQpkZ0JsQUhJQWN3QnBBRzhB YmdBdUFDSUFYUUFnQUQwQUlBQWlBRVFBWVFCMEFHRUFZZ0JoQUhNQVpRQWdBRzRBYndBZ0FHd0Fi d0J1CkFHY0FaUUJ5QUNBQWFBQmhBSE1BSUFCbEFIZ0FjQUJsQUdNQWRBQmxBR1FBSUFCMkFHVUFj Z0J6QUdrQWJ3QnVBQzRBSWdBN0FBb0EKYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFh UUJ1QUdjQWN3QmJBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCawpBR2tBY3dCaEFHSUFi QUJsQUdRQUxnQWdBRU1BYkFCcEFHTUFhd0FnQUhRQWJ3QWdBR1VBYmdCaEFHSUFiQUJsQUM0QUln QmRBQ0FBClBRQWdBQ0lBUkFCbEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCa0FHa0Fjd0JoQUdJQWJB QmxBR1FBTGdBZ0FFTUFiQUJwQUdNQWF3QWcKQUhRQWJ3QWdBR1VBYmdCaEFHSUFiQUJsQUM0QUln QTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQQpjd0JiQUNJQVJB QmxBR0lBZFFCbkFHY0FhUUJ1QUdjQUlBQmxBRzRBWVFCaUFHd0FaUUJrQUM0QUlBQkRBR3dBYVFC akFHc0FJQUIwCkFHOEFJQUJrQUdrQWN3QmhBR0lBYkFCbEFDNEFJZ0JkQUNBQVBRQWdBQ0lBUkFC bEFHSUFkUUJuQUdjQWFRQnVBR2NBSUFCbEFHNEEKWVFCaUFHd0FaUUJrQUM0QUlBQkRBR3dBYVFC akFHc0FJQUIwQUc4QUlBQmtBR2tBY3dCaEFHSUFiQUJsQUM0QUlnQTdBQW9BYkFCdgpBR01BWVFC c0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVJBQmxBR0lBZFFCbkFHY0FhUUJ1 QUdjQUlBQnpBR01BCmNnQnBBSEFBZEFCekFDQUFjZ0JsQUhFQWRRQnBBSElBWlFCekFDQUFlUUJ2 QUhVQUlBQjBBRzhBSUFCekFIUUFZUUJ5QUhRQUlBQjAKQUdnQVpRQWdBR1FBWlFCaUFIVUFad0Ju QUdVQWNnQXVBQ0lBWFFBZ0FEMEFJQUFpQUVRQVpRQmlBSFVBWndCbkFHa0FiZ0JuQUNBQQpjd0Jq QUhJQWFRQndBSFFBY3dBZ0FISUFaUUJ4QUhVQWFRQnlBR1VBY3dBZ0FIa0Fid0IxQUNBQWRBQnZB Q0FBY3dCMEFHRUFjZ0IwCkFDQUFkQUJvQUdVQUlBQmtBR1VBWWdCMUFHY0Fad0JsQUhJQUxnQWlB RHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUEKY2dCcEFHNEFad0J6QUZzQUlnQkVB R1VBYkFCbEFIUUFaUUFpQUYwQUlBQTlBQ0FBSWdCRUFHVUFiQUJsQUhRQVpRQWlBRHNBQ2dCcwpB RzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkVBR2tBYlFCbEFH NEFjd0JwQUc4QWJnQnpBQ0lBClhRQWdBRDBBSUFBaUFFUUFhUUJ0QUdVQWJnQnpBR2tBYndCdUFI TUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjAKQUhJQWFRQnVBR2NBY3dCYkFD SUFSQUJ2QUdNQWF3QWdBSFFBYndBZ0FHMEFZUUJwQUc0QUlBQjNBR2tBYmdCa0FHOEFkd0F1QUNJ QQpYUUFnQUQwQUlBQWlBRVFBYndCakFHc0FJQUIwQUc4QUlBQnRBR0VBYVFCdUFDQUFkd0JwQUc0 QVpBQnZBSGNBTGdBaUFEc0FDZ0JzCkFHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0 QVp3QnpBRnNBSWdCRUFHOEFZd0IxQUcwQVpRQnVBSFFBY3dBaUFGMEEKSUFBOUFDQUFJZ0JFQUc4 QVl3QjFBRzBBWlFCdUFIUUFjd0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFB Y2dCcApBRzRBWndCekFGc0FJZ0JFQUc4QWJRQmhBR2tBYmdBaUFGMEFJQUE5QUNBQUlnQkVBRzhB YlFCaEFHa0FiZ0FpQURzQUNnQnNBRzhBCll3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRB WndCekFGc0FJZ0JFQUc4QWJnQW5BSFFBSUFCd0FHRUFkUUJ6QUdVQUlBQnYKQUc0QUlBQmxBSGdB WXdCbEFIQUFkQUJwQUc4QWJnQnpBQzRBSWdCZEFDQUFQUUFnQUNJQVJBQnZBRzRBR1NCMEFDQUFj QUJoQUhVQQpjd0JsQUNBQWJ3QnVBQ0FBWlFCNEFHTUFaUUJ3QUhRQWFRQnZBRzRBY3dBdUFDSUFP d0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrCkFGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFUUFi d0IxQUdJQWJBQmxBQzBBUXdCc0FHa0FZd0JyQUNBQWRBQnZBQ0FBUVFCa0FHUUEKSWdCZEFDQUFQ UUFnQUNJQVJBQnZBSFVBWWdCc0FHVUFMUUJEQUd3QWFRQmpBR3NBSUFCMEFHOEFJQUJCQUdRQVpB QWlBRHNBQ2dCcwpBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUln QkVBRzhBZFFCaUFHd0FaUUF0QUVNQWJBQnBBR01BCmF3QWdBSFFBYndBZ0FIUUFid0JuQUdjQWJB QmxBQ0FBWWdCbEFIUUFkd0JsQUdVQWJnQWdBRlVBVWdCTUFDQUFaUUJ1QUdNQWJ3QmsKQUdVQVpB QWdBR0VBYmdCa0FDQUFaQUJsQUdNQWJ3QmtBR1VBWkFBZ0FHWUFid0J5QUcwQVlRQjBBSE1BSWdC ZEFDQUFQUUFnQUNJQQpSQUJ2QUhVQVlnQnNBR1VBTFFCREFHd0FhUUJqQUdzQUlBQjBBRzhBSUFC MEFHOEFad0JuQUd3QVpRQWdBR0lBWlFCMEFIY0FaUUJsCkFHNEFJQUJWQUZJQVRBQWdBR1VBYmdC akFHOEFaQUJsQUdRQUlBQmhBRzRBWkFBZ0FHUUFaUUJqQUc4QVpBQmxBR1FBSUFCbUFHOEEKY2dC dEFHRUFkQUJ6QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0Ju QUhNQVd3QWlBRVVBYkFCbApBRzBBWlFCdUFIUUFjd0FpQUYwQUlBQTlBQ0FBSWdCRkFHd0FaUUJ0 QUdVQWJnQjBBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBCmVnQmxBR1FBVXdCMEFISUFhUUJ1 QUdjQWN3QmJBQ0lBUlFCdUFHRUFZZ0JzQUdVQUlBQkVBR1VBWWdCMUFHY0Fad0JwQUc0QVp3QWkK QUYwQUlBQTlBQ0FBSWdCRkFHNEFZUUJpQUd3QVpRQWdBRVFBWlFCaUFIVUFad0JuQUdrQWJnQm5B Q0lBT3dBS0FHd0Fid0JqQUdFQQpiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlB RVVBYmdCaEFHSUFiQUJsQUNBQVVBQnlBRzhBWmdCcEFHd0FhUUJ1CkFHY0FJZ0JkQUNBQVBRQWdB Q0lBUlFCdUFHRUFZZ0JzQUdVQUlBQlFBSElBYndCbUFHa0FiQUJwQUc0QVp3QWlBRHNBQ2dCc0FH OEEKWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkZBRzRBWVFCaUFH d0FaUUFnQUhJQVpRQnpBRzhBZFFCeQpBR01BWlFBZ0FIUUFjZ0JoQUdNQWF3QnBBRzRBWndBaUFG MEFJQUE5QUNBQUlnQkZBRzRBWVFCaUFHd0FaUUFnQUhJQVpRQnpBRzhBCmRRQnlBR01BWlFBZ0FI UUFjZ0JoQUdNQWF3QnBBRzRBWndBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhR QWNnQnAKQUc0QVp3QnpBRnNBSWdCRkFHNEFZUUJpQUd3QWFRQnVBR2NBSUFCa0FHVUFZZ0IxQUdj QVp3QnBBRzRBWndBZ0FIY0FhUUJzQUd3QQpJQUJ0QUdFQWF3QmxBQ0FBY3dCakFISUFhUUJ3QUhR QWN3QWdBSElBZFFCdUFDQUFjd0JzQUc4QWR3QmxBSElBTGdBaUFGMEFJQUE5CkFDQUFJZ0JGQUc0 QVlRQmlBR3dBYVFCdUFHY0FJQUJrQUdVQVlnQjFBR2NBWndCcEFHNEFad0FnQUhjQWFRQnNBR3dB SUFCdEFHRUEKYXdCbEFDQUFjd0JqQUhJQWFRQndBSFFBY3dBZ0FISUFkUUJ1QUNBQWN3QnNBRzhB ZHdCbEFISUFMZ0FpQURzQUNnQnNBRzhBWXdCaApBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRB WndCekFGc0FJZ0JGQUc0QVlRQmlBR3dBYVFCdUFHY0FJQUJ3QUhJQWJ3Qm1BR2tBCmJBQnBBRzRB WndBZ0FIY0FhUUJzQUd3QUlBQnRBR0VBYXdCbEFDQUFjd0JqQUhJQWFRQndBSFFBY3dBZ0FISUFk UUJ1QUNBQWN3QnMKQUc4QWR3QmxBSElBTGdBaUFGMEFJQUE5QUNBQUlnQkZBRzRBWVFCaUFHd0Fh UUJ1QUdjQUlBQndBSElBYndCbUFHa0FiQUJwQUc0QQpad0FnQUhjQWFRQnNBR3dBSUFCdEFHRUFh d0JsQUNBQWN3QmpBSElBYVFCd0FIUUFjd0FnQUhJQWRRQnVBQ0FBY3dCc0FHOEFkd0JsCkFISUFM Z0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUln QkZBRzRBWVFCaUFHd0EKYVFCdUFHY0FJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFJQUIwQUhJQVlR QmpBR3NBYVFCdUFHY0FJQUIzQUdrQWJBQnNBQ0FBY2dCbApBR3dBYndCaEFHUUFJQUIwQUdnQVpR QWdBSEFBWVFCbkFHVUFJQUJoQUc0QVpBQWdBRzBBWVFCckFHVUFJQUJ3QUdFQVp3QmxBQ0FBCmJB QnZBR0VBWkFCcEFHNEFad0FnQUhNQWJBQnZBSGNBWlFCeUFDNEFJZ0JkQUNBQVBRQWdBQ0lBUlFC dUFHRUFZZ0JzQUdrQWJnQm4KQUNBQWNnQmxBSE1BYndCMUFISUFZd0JsQUNBQWRBQnlBR0VBWXdC ckFHa0FiZ0JuQUNBQWR3QnBBR3dBYkFBZ0FISUFaUUJzQUc4QQpZUUJrQUNBQWRBQm9BR1VBSUFC d0FHRUFad0JsQUNBQVlRQnVBR1FBSUFCdEFHRUFhd0JsQUNBQWNBQmhBR2NBWlFBZ0FHd0Fid0Jo CkFHUUFhUUJ1QUdjQUlBQnpBR3dBYndCM0FHVUFjZ0F1QUNJQU93QUtBR3dBYndCakFHRUFiQUJw QUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFXd0FpQUVVQWRnQmxBRzRBZEFBZ0FFUUFid0Jq QUhVQWJRQmxBRzRBZEFBaUFGMEFJQUE5QUNBQUlnQkZBSFlBWlFCdQpBSFFBSUFCRUFHOEFZd0Ix QUcwQVpRQnVBSFFBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVB R2NBCmN3QmJBQ0lBUlFCMkFHVUFiZ0IwQUNBQVZBQmhBSElBWndCbEFIUUFJZ0JkQUNBQVBRQWdB Q0lBUlFCMkFHVUFiZ0IwQUNBQVZBQmgKQUhJQVp3QmxBSFFBSWdBN0FBb0FiQUJ2QUdNQVlRQnNB R2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFSUUI0QUdNQQpiQUIxQUdRQVpRQWdB SE1BWlFCc0FHVUFZd0IwQUdVQVpBQWdBR1lBZFFCdUFHTUFkQUJwQUc4QWJnQXVBQ0lBWFFBZ0FE MEFJQUFpCkFFVUFlQUJqQUd3QWRRQmtBR1VBSUFCekFHVUFiQUJsQUdNQWRBQmxBR1FBSUFCbUFI VUFiZ0JqQUhRQWFRQnZBRzRBTGdBaUFEc0EKQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFI UUFjZ0JwQUc0QVp3QnpBRnNBSWdCRkFIZ0FjQUJwQUhJQVpRQnpBQ0lBWFFBZwpBRDBBSUFBaUFF VUFlQUJ3QUdrQWNnQmxBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJ QWFRQnVBR2NBCmN3QmJBQ0lBUmdCcEFHd0FaUUFnQUhNQWFRQjZBR1VBSWdCZEFDQUFQUUFnQUNJ QVJnQnBBR3dBWlFBZ0FITUFhUUI2QUdVQUlnQTcKQUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdR QVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVJnQnZBR01BZFFCekFDQUFjd0JsQUd3QQpaUUJqQUhR QVpRQmtBQ0FBWmdCMUFHNEFZd0IwQUdrQWJ3QnVBQzRBSWdCZEFDQUFQUUFnQUNJQVJnQnZBR01B ZFFCekFDQUFid0J1CkFDQUFjd0JsQUd3QVpRQmpBSFFBWlFCa0FDQUFaZ0IxQUc0QVl3QjBBR2tB YndCdUFDNEFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0EKZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NB Y3dCYkFDSUFSZ0J2QUc0QWRBQnpBQ0lBWFFBZ0FEMEFJQUFpQUVZQWJ3QnVBSFFBY3dBaQpBRHNB Q2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCR0FHOEFj Z0J0QUNBQVJBQmhBSFFBCllRQWlBRjBBSUFBOUFDQUFJZ0JHQUc4QWNnQnRBQ0FBUkFCaEFIUUFZ UUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlQKQUhRQWNnQnBBRzRBWndCekFGc0FJ Z0JHQUhVQWJnQmpBSFFBYVFCdkFHNEFJZ0JkQUNBQVBRQWdBQ0lBUmdCMUFHNEFZd0IwQUdrQQpi d0J1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3 QWlBRWNBVWdCQkFGQUFTQUJUCkFDSUFYUUFnQUQwQUlBQWlBRWNBVWdCQkFGQUFTQUJUQUNJQU93 QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0EKYmdCbkFITUFXd0FpQUVjQWJB QnZBR0lBWVFCc0FDSUFYUUFnQUQwQUlBQWlBRWNBYkFCdkFHSUFZUUJzQUNJQU93QUtBR3dBYndC agpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVnQVZBQlVBRkFBSWdC ZEFDQUFQUUFnQUNJQVNBQlVBRlFBClVBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFC VEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCSUFHVUFZUUIyQUhrQUlBQW8KQUVJQWJ3QjBBSFFBYndC dEFDQUFWUUJ3QUNrQUlnQmRBQ0FBUFFBZ0FDSUFTQUJsQUdFQWRnQjVBQ0FBS0FCQ0FHOEFkQUIw QUc4QQpiUUFnQUZVQWNBQXBBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5 QUdrQWJnQm5BSE1BV3dBaUFFZ0FhUUJrCkFHVUFJQUJqQUdnQVlRQnVBR2NBWlFCekFDQUFkZ0Jw QUdVQWR3QXVBQ0lBWFFBZ0FEMEFJQUFpQUVnQWFRQmtBR1VBSUFCakFHZ0EKWVFCdUFHY0FaUUJ6 QUNBQWRnQnBBR1VBZHdBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlB R2tBYmdCbgpBSE1BV3dBaUFFZ0FhUUJrQUdVQUlBQmpBRzhBYmdCekFHOEFiQUJsQUM0QUlnQmRB Q0FBUFFBZ0FDSUFTQUJwQUdRQVpRQWdBR01BCmJ3QnVBSE1BYndCc0FHVUFMZ0FpQURzQUNnQnNB RzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQkoKQUcwQVlRQm5B R1VBY3dBaUFGMEFJQUE5QUNBQUlnQkpBRzBBWVFCbkFHVUFjd0FpQURzQUNnQnNBRzhBWXdCaEFH d0FhUUI2QUdVQQpaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JMQUdVQWVRQWlBRjBBSUFBOUFD QUFJZ0JMQUdVQWVRQWlBRHNBQ2dCc0FHOEFZd0JoCkFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFH NEFad0J6QUZzQUlnQk1BRThBUXdCQkFFd0FJQUJUQUZRQVR3QlNBRUVBUndCRkFDSUEKWFFBZ0FE MEFJQUFpQUV3QVR3QkRBRUVBVEFBZ0FGTUFWQUJQQUZJQVFRQkhBRVVBSWdBN0FBb0FiQUJ2QUdN QVlRQnNBR2tBZWdCbApBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVEFCdkFHTUFZUUJzQUNJ QVhRQWdBRDBBSUFBaUFFd0Fid0JqQUdFQWJBQWlBRHNBCkNnQnNBRzhBWXdCaEFHd0FhUUI2QUdV QVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQk5BRWtBVFFCRkFDQUFkQUI1QUhBQVpRQWkKQUYw QUlBQTlBQ0FBSWdCTkFFa0FUUUJGQUNBQWRBQjVBSEFBWlFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dB YVFCNkFHVUFaQUJUQUhRQQpjZ0JwQUc0QVp3QnpBRnNBSWdCTkFHVUFkQUJ5QUdrQVl3QnpBQ0lB WFFBZ0FEMEFJQUFpQUUwQVpRQjBBSElBYVFCakFITUFJZ0E3CkFBb0FiQUJ2QUdNQVlRQnNBR2tB ZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFUZ0JoQUcwQVpRQWlBRjBBSUFBOUFDQUEK SWdCT0FHRUFiUUJsQUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0Fi Z0JuQUhNQVd3QWlBRTRBWlFCMwpBQ0FBVXdCMEFIa0FiQUJsQUNBQVVnQjFBR3dBWlFBaUFGMEFJ QUE5QUNBQUlnQk9BR1VBZHdBZ0FGTUFkQUI1QUd3QVpRQWdBRklBCmRRQnNBR1VBSWdBN0FBb0Fi QUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFUZ0J2QUNBQVFn QnkKQUdVQVlRQnJBSEFBYndCcEFHNEFkQUJ6QUNJQVhRQWdBRDBBSUFBaUFFNEFid0FnQUVJQWNn QmxBR0VBYXdCd0FHOEFhUUJ1QUhRQQpjd0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpB QlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQk9BRzhBSUFCUUFISUFid0J3CkFHVUFjZ0IwQUdrQVpR QnpBQ0lBWFFBZ0FEMEFJQUFpQUU0QWJ3QWdBRkFBY2dCdkFIQUFaUUJ5QUhRQWFRQmxBSE1BSWdB N0FBb0EKYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVGdC dkFDQUFWZ0JoQUhJQWFRQmhBR0lBYkFCbApBSE1BSWdCZEFDQUFQUUFnQUNJQVRnQnZBQ0FBVmdC aEFISUFhUUJoQUdJQWJBQmxBSE1BSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBCmVnQmxBR1FBVXdC MEFISUFhUUJ1QUdjQWN3QmJBQ0lBVGdCdkFIUUFJQUJHQUc4QWRRQnVBR1FBSWdCZEFDQUFQUUFn QUNJQVRnQnYKQUhRQUlBQkdBRzhBZFFCdUFHUUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0Js QUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQQpUZ0J2QUhRQUlBQlFBR0VBZFFCekFHVUFaQUFp QUYwQUlBQTlBQ0FBSWdCT0FHOEFkQUFnQUZBQVlRQjFBSE1BWlFCa0FDSUFPd0FLCkFHd0Fid0Jq QUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFOEFiZ0JzQUhrQUlBQmxB RzRBWVFCaUFHd0EKWlFBZ0FHWUFid0J5QUNBQWRBQm9BR2tBY3dBZ0FITUFaUUJ6QUhNQWFRQnZB RzRBSWdCZEFDQUFQUUFnQUNJQVR3QnVBR3dBZVFBZwpBR1VBYmdCaEFHSUFiQUJsQUNBQVpnQnZB SElBSUFCMEFHZ0FhUUJ6QUNBQWN3QmxBSE1BY3dCcEFHOEFiZ0FpQURzQUNnQnNBRzhBCll3QmhB R3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JQQUhRQWFBQmxBSElBSWdCZEFD QUFQUUFnQUNJQVR3QjAKQUdnQVpRQnlBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FG TUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGQUFZUUIwQUdnQQpJZ0JkQUNBQVBRQWdBQ0lBVUFCaEFI UUFhQUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6CkFG c0FJZ0JRQUdFQWRRQnpBR1VBSUFCdkFHNEFJQUJsQUhnQVl3QmxBSEFBZEFCcEFHOEFiZ0J6QUM0 QUlnQmRBQ0FBUFFBZ0FDSUEKVUFCaEFIVUFjd0JsQUNBQWJ3QnVBQ0FBWlFCNEFHTUFaUUJ3QUhR QWFRQnZBRzRBY3dBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcApBSG9BWlFCa0FGTUFkQUJ5QUdr QWJnQm5BSE1BV3dBaUFGQUFZUUIxQUhNQVpRQWdBSE1BWXdCeUFHa0FjQUIwQUNBQVpRQjRBR1VB Cll3QjFBSFFBYVFCdkFHNEFMZ0FpQUYwQUlBQTlBQ0FBSWdCUUFHRUFkUUJ6QUdVQUlBQnpBR01B Y2dCcEFIQUFkQUFnQUdVQWVBQmwKQUdNQWRRQjBBR2tBYndCdUFDNEFJZ0E3QUFvQWJBQnZBR01B WVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQQpVQUJoQUhVQWN3QmxBR1FB SWdCZEFDQUFQUUFnQUNJQVVBQmhBSFVBY3dCbEFHUUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0Fl Z0JsCkFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFVQUJoQUhVQWN3QnBBRzRBWndBaUFGMEFJ QUE5QUNBQUlnQlFBR0VBZFFCekFHa0EKYmdCbkFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0Fa UUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZBQWNnQnZBR1lBYVFCcwpBR1VBSUFBbEFHUUFJ Z0JkQUNBQVBRQWdBQ0lBVUFCeUFHOEFaZ0JwQUd3QVpRQWdBQ1VBWkFBaUFEc0FDZ0JzQUc4QVl3 QmhBR3dBCmFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCUUFISUFid0JtQUdrQWJB QmxBSE1BSWdCZEFDQUFQUUFnQUNJQVVBQnkKQUc4QVpnQnBBR3dBWlFCekFDSUFPd0FLQUd3QWJ3 QmpBR0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZBQQpjZ0J2QUdZQWFR QnNBR2tBYmdCbkFDQUFaQUJwQUhNQVlRQmlBR3dBWlFCa0FDNEFJQUJEQUd3QWFRQmpBR3NBSUFC MEFHOEFJQUJsCkFHNEFZUUJpQUd3QVpRQXVBQ0lBWFFBZ0FEMEFJQUFpQUZBQWNnQnZBR1lBYVFC c0FHa0FiZ0JuQUNBQVpBQnBBSE1BWVFCaUFHd0EKWlFCa0FDNEFJQUJEQUd3QWFRQmpBR3NBSUFC MEFHOEFJQUJsQUc0QVlRQmlBR3dBWlFBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcApBSG9BWlFC a0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGQUFjZ0J2QUdZQWFRQnNBR2tBYmdCbkFDQUFaUUJ1 QUdFQVlnQnNBR1VBClpBQXVBQ0FBUXdCc0FHa0FZd0JyQUNBQWRBQnZBQ0FBWkFCcEFITUFZUUJp QUd3QVpRQXVBQ0lBWFFBZ0FEMEFJQUFpQUZBQWNnQnYKQUdZQWFRQnNBR2tBYmdCbkFDQUFaUUJ1 QUdFQVlnQnNBR1VBWkFBdUFDQUFRd0JzQUdrQVl3QnJBQ0FBZEFCdkFDQUFaQUJwQUhNQQpZUUJp QUd3QVpRQXVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5B SE1BV3dBaUFGQUFjZ0J2CkFIQUFaUUJ5QUhRQWFRQmxBSE1BSWdCZEFDQUFQUUFnQUNJQVVBQnlB RzhBY0FCbEFISUFkQUJwQUdVQWN3QWlBRHNBQ2dCc0FHOEEKWXdCaEFHd0FhUUI2QUdVQVpBQlRB SFFBY2dCcEFHNEFad0J6QUZzQUlnQlFBSElBYndCMEFHOEFkQUI1QUhBQVpRQWlBRjBBSUFBOQpB Q0FBSWdCUUFISUFid0IwQUc4QWRBQjVBSEFBWlFBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFH VUFaQUJUQUhRQWNnQnBBRzRBClp3QnpBRnNBSWdCUkFIVUFaUUJ5QUhrQUlnQmRBQ0FBUFFBZ0FD SUFVUUIxQUdVQWNnQjVBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnAKQUhvQVpRQmtBRk1BZEFCeUFH a0FiZ0JuQUhNQVd3QWlBRkVBZFFCbEFISUFlUUFnQUZNQWRBQnlBR2tBYmdCbkFDQUFVQUJoQUhJ QQpZUUJ0QUdVQWRBQmxBSElBY3dBaUFGMEFJQUE5QUNBQUlnQlJBSFVBWlFCeUFIa0FJQUJUQUhR QWNnQnBBRzRBWndBZ0FGQUFZUUJ5CkFHRUFiUUJsQUhRQVpRQnlBSE1BSWdBN0FBb0FiQUJ2QUdN QVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUEKVWdCRkFGTUFUd0JWQUZJ QVF3QkZBRk1BSWdCZEFDQUFQUUFnQUNJQVVnQkZBRk1BVHdCVkFGSUFRd0JGQUZNQUlnQTdBQW9B YkFCdgpBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVVnQmxBR1lB Y2dCbEFITUFhQUFpQUYwQUlBQTlBQ0FBCklnQlNBR1VBWmdCeUFHVUFjd0JvQUNJQU93QUtBR3dB YndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWkKQUZJQVpRQnhBSFVB WlFCekFIUUFJQUJJQUdVQVlRQmtBR1VBY2dCekFDSUFYUUFnQUQwQUlBQWlBRklBWlFCeEFIVUFa UUJ6QUhRQQpJQUJJQUdVQVlRQmtBR1VBY2dCekFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0Fa UUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpCkFGSUFaUUJ4QUhVQVpRQnpBSFFBSUFCUUFHRUFl UUJzQUc4QVlRQmtBQ0lBWFFBZ0FEMEFJQUFpQUZJQVpRQnhBSFVBWlFCekFIUUEKSUFCUUFHRUFl UUJzQUc4QVlRQmtBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJn Qm5BSE1BV3dBaQpBRklBWlFCekFHOEFkUUJ5QUdNQVpRQWdBR2tBYmdCMEFHVUFjZ0J3QUhJQVpR QjBBR1VBWkFBZ0FHRUFjd0FnQUNVQWN3QWdBR0lBCmRRQjBBQ0FBZEFCeUFHRUFiZ0J6QUdZQVpR QnlBSElBWlFCa0FDQUFkd0JwQUhRQWFBQWdBRTBBU1FCTkFFVUFJQUIwQUhrQWNBQmwKQUNBQUpR QnpBQzRBSWdCZEFDQUFQUUFnQUNJQVVnQmxBSE1BYndCMUFISUFZd0JsQUNBQWFRQnVBSFFBWlFC eUFIQUFjZ0JsQUhRQQpaUUJrQUNBQVlRQnpBQ0FBSlFBeEFDUUFjd0FnQUdJQWRRQjBBQ0FBZEFC eUFHRUFiZ0J6QUdZQVpRQnlBSElBWlFCa0FDQUFkd0JwCkFIUUFhQUFnQUUwQVNRQk5BRVVBSUFC MEFIa0FjQUJsQUNBQUpRQXlBQ1FBY3dBdUFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0EKWlFC a0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGSUFaUUJ6QUc4QWRRQnlBR01BWlFBZ0FIUUFjZ0Jo QUdNQWF3QnBBRzRBWndBZwpBR1FBYVFCekFHRUFZZ0JzQUdVQVpBQXVBQ0FBUXdCc0FHa0FZd0Jy QUNBQWRBQnZBQ0FBWlFCdUFHRUFZZ0JzQUdVQUxnQWlBRjBBCklBQTlBQ0FBSWdCU0FHVUFjd0J2 QUhVQWNnQmpBR1VBSUFCMEFISUFZUUJqQUdzQWFRQnVBR2NBSUFCa0FHa0Fjd0JoQUdJQWJBQmwK QUdRQUxnQWdBRU1BYkFCcEFHTUFhd0FnQUhRQWJ3QWdBR1VBYmdCaEFHSUFiQUJsQUM0QUlnQTdB QW9BYkFCdkFHTUFZUUJzQUdrQQplZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVVnQmxB SE1BYndCMUFISUFZd0JsQUNBQWRBQnlBR0VBWXdCckFHa0FiZ0JuCkFDQUFaUUJ1QUdFQVlnQnNB R1VBWkFBdUFDQUFRd0JzQUdrQVl3QnJBQ0FBZEFCdkFDQUFaQUJwQUhNQVlRQmlBR3dBWlFBdUFD SUEKWFFBZ0FEMEFJQUFpQUZJQVpRQnpBRzhBZFFCeUFHTUFaUUFnQUhRQWNnQmhBR01BYXdCcEFH NEFad0FnQUdVQWJnQmhBR0lBYkFCbApBR1FBTGdBZ0FFTUFiQUJwQUdNQWF3QWdBSFFBYndBZ0FH UUFhUUJ6QUdFQVlnQnNBR1VBTGdBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBCmFRQjZBR1VBWkFCVEFI UUFjZ0JwQUc0QVp3QnpBRnNBSWdCU0FHVUFjd0J2QUhVQWNnQmpBR1VBY3dBaUFGMEFJQUE5QUNB QUlnQlMKQUdVQWN3QnZBSFVBY2dCakFHVUFjd0FpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdV QVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQQpJZ0JTQUdVQWN3QndBRzhBYmdCekFHVUFJQUJJQUdV QVlRQmtBR1VBY2dCekFDSUFYUUFnQUQwQUlBQWlBRklBWlFCekFIQUFid0J1CkFITUFaUUFnQUVn QVpRQmhBR1FBWlFCeUFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElB YVFCdUFHY0EKY3dCYkFDSUFVZ0JsQUhNQWRBQnZBSElBWlFBZ0FHRUFiQUJzQUNBQVpnQjFBRzRB WXdCMEFHa0Fid0J1QUhNQUxnQWlBRjBBSUFBOQpBQ0FBSWdCU0FHVUFjd0IwQUc4QWNnQmxBQ0FB WVFCc0FHd0FJQUJtQUhVQWJnQmpBSFFBYVFCdkFHNEFjd0F1QUNJQU93QUtBR3dBCmJ3QmpBR0VB YkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZJQWRRQnVBQ0FBSlFCa0FDSUFY UUFnQUQwQUlBQWkKQUZJQWRRQnVBQ0FBSlFCa0FDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0Fa UUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZNQQpSUUJUQUZNQVNRQlBBRTRBSUFCVEFGUUFU d0JTQUVFQVJ3QkZBQ0lBWFFBZ0FEMEFJQUFpQUZNQVJRQlRBRk1BU1FCUEFFNEFJQUJUCkFGUUFU d0JTQUVFQVJ3QkZBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJn Qm5BSE1BV3dBaUFGTUEKWXdCdkFIQUFaUUFnQUZZQVlRQnlBR2tBWVFCaUFHd0FaUUJ6QUNJQVhR QWdBRDBBSUFBaUFGTUFZd0J2QUhBQVpRQWdBRllBWVFCeQpBR2tBWVFCaUFHd0FaUUJ6QUNJQU93 QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlBRk1BCll3 QnlBR2tBY0FCMEFITUFJZ0JkQUNBQVBRQWdBQ0lBVXdCakFISUFhUUJ3QUhRQWN3QWlBRHNBQ2dC c0FHOEFZd0JoQUd3QWFRQjYKQUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBR1VBWVFC eUFHTUFhQUFnQUNVQWN3QWlBRjBBSUFBOUFDQUFJZ0JUQUdVQQpZUUJ5QUdNQWFBQWdBQ1VBY3dB aUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JU CkFHVUFZd0IxQUhJQVpRQWlBRjBBSUFBOUFDQUFJZ0JUQUdVQVl3QjFBSElBWlFBaUFEc0FDZ0Jz QUc4QVl3QmhBR3dBYVFCNkFHVUEKWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFHVUFiQUJs QUdNQWRBQWdBR0VBYmdBZ0FHVUFiQUJsQUcwQVpRQnVBSFFBSUFCcApBRzRBSUFCMEFHZ0FaUUFn QUhBQVlRQm5BR1VBSUFCMEFHOEFJQUJwQUc0QWN3QndBR1VBWXdCMEFDQUFhUUIwQUM0QUlnQmRB Q0FBClBRQWdBQ0lBVXdCbEFHd0FaUUJqQUhRQUlBQmhBRzRBSUFCbEFHd0FaUUJ0QUdVQWJnQjBB Q0FBYVFCdUFDQUFkQUJvQUdVQUlBQncKQUdFQVp3QmxBQ0FBZEFCdkFDQUFhUUJ1QUhNQWNBQmxB R01BZEFBZ0FHa0FkQUF1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQQpaUUJrQUZNQWRBQnlB R2tBYmdCbkFITUFXd0FpQUZNQVpRQnNBR1lBSWdCZEFDQUFQUUFnQUNJQVV3QmxBR3dBWmdBaUFE c0FDZ0JzCkFHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFH VUFjd0J6QUdrQWJ3QnVBQ0lBWFFBZ0FEMEEKSUFBaUFGTUFaUUJ6QUhNQWFRQnZBRzRBSWdBN0FB b0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYgpBQ0lBVXdCb0FH OEFkd0FnQUdFQVlnQnpBRzhBYkFCMUFIUUFaUUFnQUhRQWJ3QjBBR0VBYkFBZ0FHRUFiZ0JrQUNB QWN3QmxBR3dBClpnQWdBSFFBYVFCdEFHVUFjd0F1QUNJQVhRQWdBRDBBSUFBaUFGTUFhQUJ2QUhj QUlBQmhBR0lBY3dCdkFHd0FkUUIwQUdVQUlBQjAKQUc4QWRBQmhBR3dBSUFCaEFHNEFaQUFnQUhN QVpRQnNBR1lBSUFCMEFHa0FiUUJsQUhNQUxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QQphUUI2QUdV QVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBR2dBYndCM0FDQUFZd0JvQUdFQWJnQm5BR1VB Y3dBZ0FIWUFhUUJsCkFIY0FMZ0FpQUYwQUlBQTlBQ0FBSWdCVEFHZ0Fid0IzQUNBQVl3Qm9BR0VB YmdCbkFHVUFjd0FnQUhZQWFRQmxBSGNBTGdBaUFEc0EKQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VB WkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFHZ0Fid0IzQUNBQVl3QnZBRzRBY3dCdgpBR3dB WlFBdUFDSUFYUUFnQUQwQUlBQWlBRk1BYUFCdkFIY0FJQUJqQUc4QWJnQnpBRzhBYkFCbEFDNEFJ Z0E3QUFvQWJBQnZBR01BCllRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFV d0JvQUc4QWR3QWdBR2tBYmdCb0FHVUFjZ0JwQUhRQVpRQmsKQUNJQVhRQWdBRDBBSUFBaUFGTUFh QUJ2QUhjQUlBQnBBRzRBYUFCbEFISUFhUUIwQUdVQVpBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QQph UUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBR2dBYndCM0FDQUFkQUJvQUdVQUlB QnVBR1VBZUFCMEFDQUFjd0JqCkFISUFhUUJ3QUhRQUlBQnlBR1VBY3dCdkFIVUFjZ0JqQUdVQUxn QWlBRjBBSUFBOUFDQUFJZ0JUQUdnQWJ3QjNBQ0FBZEFCb0FHVUEKSUFCdUFHVUFlQUIwQUNBQWN3 QmpBSElBYVFCd0FIUUFJQUJ5QUdVQWN3QnZBSFVBY2dCakFHVUFMZ0FpQURzQUNnQnNBRzhBWXdC aApBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JUQUdnQWJ3QjNBQ0FBZEFC b0FHVUFJQUJ3QUhJQVpRQjJBR2tBCmJ3QjFBSE1BSUFCekFHTUFjZ0JwQUhBQWRBQWdBSElBWlFC ekFHOEFkUUJ5QUdNQVpRQXVBQ0lBWFFBZ0FEMEFJQUFpQUZNQWFBQnYKQUhjQUlBQjBBR2dBWlFB Z0FIQUFjZ0JsQUhZQWFRQnZBSFVBY3dBZ0FITUFZd0J5QUdrQWNBQjBBQ0FBY2dCbEFITUFid0Ix QUhJQQpZd0JsQUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1 QUdjQWN3QmJBQ0lBVXdCb0FHOEFkd0FnCkFIUUFid0IwQUdFQWJBQWdBR0VBYmdCa0FDQUFjd0Js QUd3QVpnQWdBSFFBYVFCdEFHVUFjd0FnQUdFQWN3QWdBSEFBWlFCeUFHTUEKWlFCdUFIUUFZUUJu QUdVQWN3QXVBQ0lBWFFBZ0FEMEFJQUFpQUZNQWFBQnZBSGNBSUFCMEFHOEFkQUJoQUd3QUlBQmhB RzRBWkFBZwpBSE1BWlFCc0FHWUFJQUIwQUdrQWJRQmxBSE1BSUFCaEFITUFJQUJ3QUdVQWNnQmpB R1VBYmdCMEFHRUFad0JsQUhNQUxnQWlBRHNBCkNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRB SFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBR2tBZWdCbEFDSUFYUUFnQUQwQUlBQWkKQUZNQWFRQjZB R1VBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFD SUFVd0J2QUhJQQpkQUFnQUdJQWVRQWdBRVFBZFFCeUFHRUFkQUJwQUc4QWJnQWlBRjBBSUFBOUFD QUFJZ0JUQUc4QWNnQjBBQ0FBWWdCNUFDQUFSQUIxCkFISUFZUUIwQUdrQWJ3QnVBQ0lBT3dBS0FH d0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFGTUEKYndCeUFI UUFJQUJpQUhrQUlBQkZBRzRBWkFBZ0FGUUFhUUJ0QUdVQUlnQmRBQ0FBUFFBZ0FDSUFVd0J2QUhJ QWRBQWdBR0lBZVFBZwpBRVVBYmdCa0FDQUFWQUJwQUcwQVpRQWlBRHNBQ2dCc0FHOEFZd0JoQUd3 QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBCklnQlRBRzhBY2dCMEFDQUFZZ0I1QUNB QVRBQmhBSFFBWlFCdUFHTUFlUUFpQUYwQUlBQTlBQ0FBSWdCVEFHOEFjZ0IwQUNBQVlnQjUKQUNB QVRBQmhBSFFBWlFCdUFHTUFlUUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFB Y2dCcEFHNEFad0J6QUZzQQpJZ0JUQUc4QWNnQjBBQ0FBWWdCNUFDQUFVZ0JsQUhNQWNBQnZBRzRB Y3dCbEFDQUFWQUJwQUcwQVpRQWlBRjBBSUFBOUFDQUFJZ0JUCkFHOEFjZ0IwQUNBQVlnQjVBQ0FB VWdCbEFITUFjQUJ2QUc0QWN3QmxBQ0FBVkFCcEFHMEFaUUFpQURzQUNnQnNBRzhBWXdCaEFHd0EK YVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JUQUc4QWNnQjBBQ0FBWWdCNUFDQUFV d0JwQUhvQVpRQWlBRjBBSUFBOQpBQ0FBSWdCVEFHOEFjZ0IwQUNBQVlnQjVBQ0FBVXdCcEFIb0Fa UUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBCmNnQnBBRzRBWndCekFGc0FJ Z0JUQUc4QWNnQjBBQ0FBWWdCNUFDQUFVd0IwQUdFQWNnQjBBQ0FBVkFCcEFHMEFaUUFpQUYwQUlB QTkKQUNBQUlnQlRBRzhBY2dCMEFDQUFZZ0I1QUNBQVV3QjBBR0VBY2dCMEFDQUFWQUJwQUcwQVpR QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QQphUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUln QlRBRzhBZFFCeUFHTUFaUUFpQUYwQUlBQTlBQ0FBSWdCVEFHOEFkUUJ5CkFHTUFaUUFpQURzQUNn QnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBSFFBWVFC eUFIUUEKSUFCd0FISUFid0JtQUdrQWJBQnBBRzRBWndBdUFDSUFYUUFnQUQwQUlBQWlBRk1BZEFC aEFISUFkQUFnQUhBQWNnQnZBR1lBYVFCcwpBR2tBYmdCbkFDNEFJZ0E3QUFvQWJBQnZBR01BWVFC c0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVV3QjBBR1VBCmNBQWdBR2tBYmdC MEFHOEFJQUJ1QUdVQWVBQjBBQ0FBWmdCMUFHNEFZd0IwQUdrQWJ3QnVBQ0FBWXdCaEFHd0FiQUF1 QUNJQVhRQWcKQUQwQUlBQWlBRk1BZEFCbEFIQUFJQUJwQUc0QWRBQnZBQ0FBYmdCbEFIZ0FkQUFn QUdZQWRRQnVBR01BZEFCcEFHOEFiZ0FnQUdNQQpZUUJzQUd3QUxnQWlBRHNBQ2dCc0FHOEFZd0Jo QUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFIUUFaUUJ3CkFDQUFid0Ix QUhRQUlBQnZBR1lBSUFCakFIVUFjZ0J5QUdVQWJnQjBBQ0FBWmdCMUFHNEFZd0IwQUdrQWJ3QnVB QzRBSWdCZEFDQUEKUFFBZ0FDSUFVd0IwQUdVQWNBQWdBRzhBZFFCMEFDQUFid0JtQUNBQVl3QjFB SElBY2dCbEFHNEFkQUFnQUdZQWRRQnVBR01BZEFCcApBRzhBYmdBdUFDSUFPd0FLQUd3QWJ3QmpB R0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUZNQWRBQmxBSEFBCklBQnZB SFlBWlFCeUFDQUFiZ0JsQUhnQWRBQWdBR1lBZFFCdUFHTUFkQUJwQUc4QWJnQWdBR01BWVFCc0FH d0FMZ0FpQUYwQUlBQTkKQUNBQUlnQlRBSFFBWlFCd0FDQUFid0IyQUdVQWNnQWdBRzRBWlFCNEFI UUFJQUJtQUhVQWJnQmpBSFFBYVFCdkFHNEFJQUJqQUdFQQpiQUJzQUM0QUlnQTdBQW9BYkFCdkFH TUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVXdCMEFHVUFjQUJ3CkFH a0FiZ0JuQUNJQVhRQWdBRDBBSUFBaUFGTUFkQUJsQUhBQWNBQnBBRzRBWndBaUFEc0FDZ0JzQUc4 QVl3QmhBR3dBYVFCNkFHVUEKWkFCVEFIUUFjZ0JwQUc0QVp3QnpBRnNBSWdCVEFIUUFid0J3QUNB QWNBQnlBRzhBWmdCcEFHd0FhUUJ1QUdjQUxnQWlBRjBBSUFBOQpBQ0FBSWdCVEFIUUFid0J3QUNB QWNBQnlBRzhBWmdCcEFHd0FhUUJ1QUdjQUxnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VB ClpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlRBSFFBYndCeUFHRUFad0JsQUNJQVhRQWdBRDBB SUFBaUFGTUFkQUJ2QUhJQVlRQm4KQUdVQUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FB VXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVXdCMEFIa0FiQUJsQUNBQQpRUUIwQUhRQWNnQnBBR0lB ZFFCMEFHVUFJZ0JkQUNBQVBRQWdBQ0lBVXdCMEFIa0FiQUJsQUNBQVFRQjBBSFFBY2dCcEFHSUFk UUIwCkFHVUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fj d0JiQUNJQVV3QjBBSGtBYkFCbEFITUEKSWdCZEFDQUFQUUFnQUNJQVV3QjBBSGtBYkFCbEFITUFJ Z0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdQpBR2NBY3dCYkFDSUFV d0IwQUhrQWJBQmxBSE1BYUFCbEFHVUFkQUJ6QUNJQVhRQWdBRDBBSUFBaUFGTUFkQUI1QUd3QVpR QnpBR2dBClpRQmxBSFFBY3dBaUFEc0FDZ0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNn QnBBRzRBWndCekFGc0FJZ0JVQUdnQVpRQWcKQUJ3Z0pRQnpBQjBnWEFCdUFIUUFZUUJpQUd3QVpR QWdBR2tBY3dBZ0FHVUFiUUJ3QUhRQWVRQXVBQ0lBWFFBZ0FEMEFJQUFpQUZRQQphQUJsQUNBQUhD QWxBSE1BSFNCY0FHNEFkQUJoQUdJQWJBQmxBQ0FBYVFCekFDQUFaUUJ0QUhBQWRBQjVBQzRBSWdB N0FBb0FiQUJ2CkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3QmJBQ0lBVkFC b0FHa0Fjd0FnQUhNQWFRQjBBR1VBSUFCb0FHRUEKY3dBZ0FHNEFid0FnQUdNQWJ3QnZBR3NBYVFC bEFITUFMZ0FpQUYwQUlBQTlBQ0FBSWdCVUFHZ0FhUUJ6QUNBQWN3QnBBSFFBWlFBZwpBR2dBWVFC ekFDQUFiZ0J2QUNBQVl3QnZBRzhBYXdCcEFHVUFjd0F1QUNJQU93QUtBR3dBYndCakFHRUFiQUJw QUhvQVpRQmtBRk1BCmRBQnlBR2tBYmdCbkFITUFXd0FpQUZRQWFBQnBBSE1BSUFCekFIUUFid0J5 QUdFQVp3QmxBQ0FBYVFCekFDQUFaUUJ0QUhBQWRBQjUKQUM0QUlnQmRBQ0FBUFFBZ0FDSUFWQUJv QUdrQWN3QWdBSE1BZEFCdkFISUFZUUJuQUdVQUlBQnBBSE1BSUFCbEFHMEFjQUIwQUhrQQpMZ0Fp QURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6QUZzQUlnQlVB R2tBYlFCbEFDSUFYUUFnCkFEMEFJQUFpQUZRQWFRQnRBR1VBSWdBN0FBb0FiQUJ2QUdNQVlRQnNB R2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUEKVkFCdkFIUUFZUUJzQUNJQVhRQWdB RDBBSUFBaUFGUUFid0IwQUdFQWJBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVApB SFFBY2dCcEFHNEFad0J6QUZzQUlnQlVBSElBWlFCbEFDQUFLQUJVQUc4QWNBQWdBRVFBYndCM0FH NEFLUUFpQUYwQUlBQTlBQ0FBCklnQlVBSElBWlFCbEFDQUFLQUJVQUc4QWNBQWdBRVFBYndCM0FH NEFLUUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlQKQUhRQWNnQnBBRzRBWndCekFG c0FJZ0JWQUc0QVpBQnZBR01BYXdBZ0FHa0FiZ0IwQUc4QUlBQnpBR1VBY0FCaEFISUFZUUIwQUdV QQpJQUIzQUdrQWJnQmtBRzhBZHdBdUFDSUFYUUFnQUQwQUlBQWlBRlVBYmdCa0FHOEFZd0JyQUNB QWFRQnVBSFFBYndBZ0FITUFaUUJ3CkFHRUFjZ0JoQUhRQVpRQWdBSGNBYVFCdUFHUUFid0IzQUM0 QUlnQTdBQW9BYkFCdkFHTUFZUUJzQUdrQWVnQmxBR1FBVXdCMEFISUEKYVFCdUFHY0Fjd0JiQUNJ QVZRQnpBR1VBSUFCc0FHRUFjZ0JuQUdVQUlBQnlBR1VBY3dCdkFIVUFjZ0JqQUdVQUlBQnlBRzhB ZHdCegpBQzRBSWdCZEFDQUFQUUFnQUNJQVZRQnpBR1VBSUFCc0FHRUFjZ0JuQUdVQUlBQnlBR1VB Y3dCdkFIVUFjZ0JqQUdVQUlBQnlBRzhBCmR3QnpBQzRBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tB ZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFWUUJ6QUdVQUlBQnoKQUcwQVlRQnNBR3dB SUFCeUFHVUFjd0J2QUhVQWNnQmpBR1VBSUFCeUFHOEFkd0J6QUM0QUlnQmRBQ0FBUFFBZ0FDSUFW UUJ6QUdVQQpJQUJ6QUcwQVlRQnNBR3dBSUFCeUFHVUFjd0J2QUhVQWNnQmpBR1VBSUFCeUFHOEFk d0J6QUM0QUlnQTdBQW9BYkFCdkFHTUFZUUJzCkFHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fj d0JiQUNJQVZnQmhBR3dBZFFCbEFDSUFYUUFnQUQwQUlBQWlBRllBWVFCc0FIVUEKWlFBaUFEc0FD Z0JzQUc4QVl3QmhBR3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JYQUdrQWRB Qm9BQ0FBUWdCcwpBRzhBWXdCckFDSUFYUUFnQUQwQUlBQWlBRmNBYVFCMEFHZ0FJQUJDQUd3QWJ3 QmpBR3NBSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tBCmVnQmxBR1FBVXdCMEFISUFhUUJ1QUdjQWN3 QmJBQ0lBV0FCSUFGSUFJZ0JkQUNBQVBRQWdBQ0lBV0FCSUFGSUFJZ0E3QUFvQWJBQnYKQUdNQVlR QnNBR2tBZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFXUUJ2QUhVQUlBQmpBRzhBZFFC c0FHUUFJQUJ6QUdFQQpkZ0JsQUNBQVlnQmhBRzRBWkFCM0FHa0FaQUIwQUdnQUlBQmlBSGtBSUFC b0FHRUFkZ0JwQUc0QVp3QWdBSGtBYndCMUFISUFJQUIzCkFHVUFZZ0FnQUhNQVpRQnlBSFlBWlFC eUFDQUFZd0J2QUcwQWNBQnlBR1VBY3dCekFDQUFkQUJvQUdrQWN3QWdBSFFBY2dCaEFHNEEKY3dC bUFHVUFjZ0FnQUhjQWFRQjBBR2dBSUFCbkFIb0FhUUJ3QUNBQWJ3QnlBQ0FBZWdCc0FHa0FZZ0F1 QUNJQVhRQWdBRDBBSUFBaQpBRmtBYndCMUFDQUFZd0J2QUhVQWJBQmtBQ0FBY3dCaEFIWUFaUUFn QUdJQVlRQnVBR1FBZHdCcEFHUUFkQUJvQUNBQVlnQjVBQ0FBCmFBQmhBSFlBYVFCdUFHY0FJQUI1 QUc4QWRRQnlBQ0FBZHdCbEFHSUFJQUJ6QUdVQWNnQjJBR1VBY2dBZ0FHTUFid0J0QUhBQWNnQmwK QUhNQWN3QWdBSFFBYUFCcEFITUFJQUIwQUhJQVlRQnVBSE1BWmdCbEFISUFJQUIzQUdrQWRBQm9B Q0FBWndCNkFHa0FjQUFnQUc4QQpjZ0FnQUhvQWJBQnBBR0lBTGdBaUFEc0FDZ0JzQUc4QVl3QmhB R3dBYVFCNkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JaCkFHOEFkUUFnQUc0QVpRQmxB R1FBSUFCMEFHOEFJQUJsQUc0QVlRQmlBR3dBWlFBZ0FHUUFaUUJpQUhVQVp3Qm5BR2tBYmdCbkFD QUEKWWdCbEFHWUFid0J5QUdVQUlBQjVBRzhBZFFBZ0FHTUFZUUJ1QUNBQWRRQnpBR1VBSUFCMEFH Z0FaUUFnQUZNQVl3QnlBR2tBY0FCMApBSE1BSUFCd0FHRUFiZ0JsQUd3QUxnQWlBRjBBSUFBOUFD QUFJZ0JaQUc4QWRRQWdBRzRBWlFCbEFHUUFJQUIwQUc4QUlBQmxBRzRBCllRQmlBR3dBWlFBZ0FH UUFaUUJpQUhVQVp3Qm5BR2tBYmdCbkFDQUFZZ0JsQUdZQWJ3QnlBR1VBSUFCNUFHOEFkUUFnQUdN QVlRQnUKQUNBQWRRQnpBR1VBSUFCMEFHZ0FaUUFnQUZNQVl3QnlBR2tBY0FCMEFITUFJQUJ3QUdF QWJnQmxBR3dBTGdBaUFEc0FDZ0JzQUc4QQpZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0 QVp3QnpBRnNBSWdCWkFHOEFkUUFnQUc0QVpRQmxBR1FBSUFCMEFHOEFJQUJsCkFHNEFZUUJpQUd3 QVpRQWdBSEFBY2dCdkFHWUFhUUJzQUdrQWJnQm5BQ0FBWWdCbEFHWUFid0J5QUdVQUlBQjVBRzhB ZFFBZ0FHTUEKWVFCdUFDQUFkUUJ6QUdVQUlBQjBBR2dBWlFBZ0FGQUFjZ0J2QUdZQWFRQnNBR1VB Y3dBZ0FIQUFZUUJ1QUdVQWJBQXVBQ0lBWFFBZwpBRDBBSUFBaUFGa0Fid0IxQUNBQWJnQmxBR1VB WkFBZ0FIUUFid0FnQUdVQWJnQmhBR0lBYkFCbEFDQUFjQUJ5QUc4QVpnQnBBR3dBCmFRQnVBR2NB SUFCaUFHVUFaZ0J2QUhJQVpRQWdBSGtBYndCMUFDQUFZd0JoQUc0QUlBQjFBSE1BWlFBZ0FIUUFh QUJsQUNBQVVBQnkKQUc4QVpnQnBBR3dBWlFCekFDQUFjQUJoQUc0QVpRQnNBQzRBSWdBN0FBb0Fi QUJ2QUdNQVlRQnNBR2tBZWdCbEFHUUFVd0IwQUhJQQphUUJ1QUdjQWN3QmJBQ0lBV1FCdkFIVUFJ QUJ1QUdVQVpRQmtBQ0FBZEFCdkFDQUFaUUJ1QUdFQVlnQnNBR1VBSUFCeUFHVUFjd0J2CkFIVUFj Z0JqQUdVQUlBQjBBSElBWVFCakFHc0FhUUJ1QUdjQUlBQjBBRzhBSUFCMUFITUFaUUFnQUhRQWFB QnBBSE1BSUFCd0FHRUEKYmdCbEFHd0FMZ0FpQUYwQUlBQTlBQ0FBSWdCWkFHOEFkUUFnQUc0QVpR QmxBR1FBSUFCMEFHOEFJQUJsQUc0QVlRQmlBR3dBWlFBZwpBSElBWlFCekFHOEFkUUJ5QUdNQVpR QWdBSFFBY2dCaEFHTUFhd0JwQUc0QVp3QWdBSFFBYndBZ0FIVUFjd0JsQUNBQWRBQm9BR2tBCmN3 QWdBSEFBWVFCdUFHVUFiQUF1QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFC eUFHa0FiZ0JuQUhNQVd3QWkKQUdJQWJ3QnlBR1FBWlFCeUFDSUFYUUFnQUQwQUlBQWlBR0lBYndC eUFHUUFaUUJ5QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQQpaUUJrQUZNQWRBQnlBR2tBYmdC bkFITUFXd0FpQUdNQWJ3QnVBSFFBWlFCdUFIUUFJZ0JkQUNBQVBRQWdBQ0lBWXdCdkFHNEFkQUJs CkFHNEFkQUFpQURzQUNnQnNBRzhBWXdCaEFHd0FhUUI2QUdVQVpBQlRBSFFBY2dCcEFHNEFad0J6 QUZzQUlnQmtBRzhBWXdCMUFHMEEKWlFCdUFIUUFJZ0JkQUNBQVBRQWdBQ0lBWkFCdkFHTUFkUUJ0 QUdVQWJnQjBBQ0lBT3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCawpBRk1BZEFCeUFHa0FiZ0Ju QUhNQVd3QWlBR1VBYkFCbEFHMEFaUUJ1QUhRQUdTQnpBQ0FBSENBbEFITUFIU0FnQUdFQWRBQjBB SElBCmFRQmlBSFVBZEFCbEFDSUFYUUFnQUQwQUlBQWlBR1VBYkFCbEFHMEFaUUJ1QUhRQUdTQnpB Q0FBSENBbEFITUFIU0FnQUdFQWRBQjAKQUhJQWFRQmlBSFVBZEFCbEFDSUFPd0FLQUd3QWJ3QmpB R0VBYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUdZQQpid0J1QUhRQUlnQmRB Q0FBUFFBZ0FDSUFaZ0J2QUc0QWRBQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFI UUFjZ0JwCkFHNEFad0J6QUZzQUlnQnBBRzBBWVFCbkFHVUFJZ0JkQUNBQVBRQWdBQ0lBYVFCdEFH RUFad0JsQUNJQU93QUtBR3dBYndCakFHRUEKYkFCcEFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFI TUFXd0FpQUdrQWJnQnNBR2tBYmdCbEFDQUFjd0IwQUhrQWJBQmxBSE1BYUFCbApBR1VBZEFBaUFG MEFJQUE5QUNBQUlnQnBBRzRBYkFCcEFHNEFaUUFnQUhNQWRBQjVBR3dBWlFCekFHZ0FaUUJsQUhR QUlnQTdBQW9BCmJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJ QWJBQnBBRzRBWlFBZ0FDVUFaQUFpQUYwQUlBQTkKQUNBQUlnQnNBR2tBYmdCbEFDQUFKUUJrQUNJ QU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQQpXd0FpQUcw QVlRQnlBR2NBYVFCdUFDSUFYUUFnQUQwQUlBQWlBRzBBWVFCeUFHY0FhUUJ1QUNJQU93QUtBR3dB YndCakFHRUFiQUJwCkFIb0FaUUJrQUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUc4QWRBQm9BR1VB Y2dBaUFGMEFJQUE5QUNBQUlnQnZBSFFBYUFCbEFISUEKSWdBN0FBb0FiQUJ2QUdNQVlRQnNBR2tB ZWdCbEFHUUFVd0IwQUhJQWFRQnVBR2NBY3dCYkFDSUFjQUJoQUdRQVpBQnBBRzRBWndBaQpBRjBB SUFBOUFDQUFJZ0J3QUdFQVpBQmtBR2tBYmdCbkFDSUFPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0Fa UUJrQUZNQWRBQnlBR2tBCmJnQm5BSE1BV3dBaUFIQUFid0J6QUdrQWRBQnBBRzhBYmdBaUFGMEFJ QUE5QUNBQUlnQndBRzhBY3dCcEFIUUFhUUJ2QUc0QUlnQTcKQUFvQWJBQnZBR01BWVFCc0FHa0Fl Z0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQWN3QmpBSElBYVFCd0FIUUFJZ0JkQUNBQQpQ UUFnQUNJQWN3QmpBSElBYVFCd0FIUUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3 QjBBSElBYVFCdUFHY0Fjd0JiCkFDSUFjd0IwQUhrQWJBQmxBSE1BYUFCbEFHVUFkQUFpQUYwQUlB QTlBQ0FBSWdCekFIUUFlUUJzQUdVQWN3Qm9BR1VBWlFCMEFDSUEKT3dBS0FHd0Fid0JqQUdFQWJB QnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFIVUFjd0JsQUhJQUlBQmhBR2NBWlFC dQpBSFFBSUFCekFIUUFlUUJzQUdVQWN3Qm9BR1VBWlFCMEFDSUFYUUFnQUQwQUlBQWlBSFVBY3dC bEFISUFJQUJoQUdjQVpRQnVBSFFBCklBQnpBSFFBZVFCc0FHVUFjd0JvQUdVQVpRQjBBQ0lBT3dB S0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm4KQUhNQVd3QWlBSFVBY3dC bEFISUFJQUJ6QUhRQWVRQnNBR1VBY3dCb0FHVUFaUUIwQUNJQVhRQWdBRDBBSUFBaUFIVUFjd0Js QUhJQQpJQUJ6QUhRQWVRQnNBR1VBY3dCb0FHVUFaUUIwQUNJQU93QUtBR3dBYndCakFHRUFiQUJw QUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuCkFITUFXd0FpQUhZQWFRQmhBQ0FBYVFCdUFITUFjQUJs QUdNQWRBQnZBSElBSWdCZEFDQUFQUUFnQUNJQWRnQnBBR0VBSUFCcEFHNEEKY3dCd0FHVUFZd0Iw QUc4QWNnQWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBWkFCVEFIUUFjZ0JwQUc0QVp3QnpB RnNBSWdCVQpBR2dBWlFBZ0FHSUFjZ0JsQUdFQWF3QndBRzhBYVFCdUFIUUFJQUJ2QUc0QUlBQnNB R2tBYmdCbEFDQUFKUUJrQUNBQWR3QnBBR3dBCmJBQWdBSE1BZEFCdkFIQUFJQUJ2QUc0QWJBQjVB Q0FBYVFCbUFDQUFkQUJvQUdrQWN3QWdBR1VBZUFCd0FISUFaUUJ6QUhNQWFRQnYKQUc0QUlBQnBB SE1BSUFCMEFISUFkUUJsQURvQUlnQmRBQ0FBUFFBZ0FDSUFWQUJvQUdVQUlBQmlBSElBWlFCaEFH c0FjQUJ2QUdrQQpiZ0IwQUNBQWJ3QnVBQ0FBYkFCcEFHNEFaUUFnQUNVQVpBQWdBSGNBYVFCc0FH d0FJQUJ6QUhRQWJ3QndBQ0FBYndCdUFHd0FlUUFnCkFHa0FaZ0FnQUhRQWFBQnBBSE1BSUFCbEFI Z0FjQUJ5QUdVQWN3QnpBR2tBYndCdUFDQUFhUUJ6QUNBQWRBQnlBSFVBWlFBNkFDSUEKT3dBS0FH d0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFTUFVQUJWQUNB QVVBQlNBRThBUmdCSgpBRXdBUlFCVEFDSUFYUUFnQUQwQUlBQWlBRU1BVUFCVkFDQUFVQUJTQUU4 QVJnQkpBRXdBUlFCVEFDSUFPd0FLQUd3QWJ3QmpBR0VBCmJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdr QWJnQm5BSE1BV3dBaUFFZ0FSUUJCQUZBQUlBQlRBRTRBUVFCUUFGTUFTQUJQQUZRQVV3QWkKQUYw QUlBQTlBQ0FBSWdCSUFFVUFRUUJRQUNBQVV3Qk9BRUVBVUFCVEFFZ0FUd0JVQUZNQUlnQTdBQW9B YkFCdkFHTUFZUUJzQUdrQQplZ0JsQUdRQVV3QjBBSElBYVFCdUFHY0Fjd0JiQUNJQVZBQmhBR3NB WlFBZ0FHZ0FaUUJoQUhBQUlBQnpBRzRBWVFCd0FITUFhQUJ2CkFIUUFMZ0FpQUYwQUlBQTlBQ0FB SWdCVUFHRUFhd0JsQUNBQWFBQmxBR0VBY0FBZ0FITUFiZ0JoQUhBQWN3Qm9BRzhBZEFBdUFDSUEK T3dBS0FHd0Fid0JqQUdFQWJBQnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFZ0Fa UUI0QUNBQVF3QnZBR3dBYndCeQpBSE1BSWdCZEFDQUFQUUFnQUNJQVNBQmxBSGdBSUFCREFHOEFi QUJ2QUhJQWN3QWlBRHNBQ2dCc0FHOEFZd0JoQUd3QWFRQjZBR1VBClpBQlRBSFFBY2dCcEFHNEFa d0J6QUZzQUlnQlNBRWNBUWdBZ0FFTUFid0JzQUc4QWNnQnpBQ0lBWFFBZ0FEMEFJQUFpQUZJQVJ3 QkMKQUNBQVF3QnZBR3dBYndCeUFITUFJZ0E3QUFvQWJBQnZBR01BWVFCc0FHa0FlZ0JsQUdRQVV3 QjBBSElBYVFCdUFHY0Fjd0JiQUNJQQpTQUJUQUV3QUlBQkRBRzhBYkFCdkFISUFjd0FpQUYwQUlB QTlBQ0FBSWdCSUFGTUFUQUFnQUVNQWJ3QnNBRzhBY2dCekFDSUFPd0FLCkFHd0Fid0JqQUdFQWJB QnBBSG9BWlFCa0FGTUFkQUJ5QUdrQWJnQm5BSE1BV3dBaUFFTUFiQUJwQUdNQWF3QWdBSFFBYndB Z0FHTUEKYUFCaEFHNEFad0JsQUNBQVl3QnZBR3dBYndCeUFDQUFaZ0J2QUhJQWJRQmhBSFFBSWdC ZEFDQUFQUUFnQUNJQVF3QnNBR2tBWXdCcgpBQ0FBZEFCdkFDQUFZd0JvQUdFQWJnQm5BR1VBSUFC akFHOEFiQUJ2QUhJQUlBQm1BRzhBY2dCdEFHRUFkQUFpQURzQUNnQnNBRzhBCll3QmhBR3dBYVFC NkFHVUFaQUJUQUhRQWNnQnBBRzRBWndCekFGc0FJZ0JYQUdFQWRBQmpBR2dBSUFCRkFIZ0FjQUJ5 QUdVQWN3QnoKQUdrQWJ3QnVBSE1BSWdCZEFDQUFQUUFnQUNJQVZ3QmhBSFFBWXdCb0FDQUFSUUI0 QUhBQWNnQmxBSE1BY3dCcEFHOEFiZ0J6QUNJQQpPd0FLQUd3QWJ3QmpBR0VBYkFCcEFIb0FaUUJr QUZNQWRBQnlBR2tBYmdCbkFITUFXd0FpQUVFQVpBQmtBQ0lBWFFBZ0FEMEFJQUFpCkFFRUFaQUJr QUNJQU93QUtBR3dBYndCakFHRUFiQUJwQUhvQVpRQmtBRk1BZEFCeUFHa0FiZ0JuQUhNQVd3QWlB RVFBWlFCc0FHVUEKZEFCbEFDQUFkd0JoQUhRQVl3Qm9BQ0FBWlFCNEFIQUFjZ0JsQUhNQWN3QnBB RzhBYmdBdUFDSUFYUUFnQUQwQUlBQWlBRVFBWlFCcwpBR1VBZEFCbEFDQUFkd0JoQUhRQVl3Qm9B Q0FBWlFCNEFIQUFjZ0JsQUhNQWN3QnBBRzhBYmdBdUFDSUFPd0FLQUE9PQoK