12845 2011-06-01 15:04:54 +0000 Disallow shadowing attributes 2016-05-03 07:54:59 +0000 1 1 1 Unclassified WebAppsWG WebIDL unspecified All All RESOLVED FIXED P2 normal --- 12844 1 Ms2ger cam allen brendan bugs bzbarsky dhtmlkitchen ian jan.varga jonas mike mounir powelld584 public-script-coord public-webapps-bugzilla oldest_to_newest 49015 0 Ms2ger 2011-06-01 15:04:54 +0000 The reasoning in bug 12844 applies generally, and it seems better to disallow them in WebIDL. One problem is the pattern interface Foo { readonly attribute DOMString quux; }; interface Bar : Foo { attribute DOMString quux; }; (currently used in HTMLOptionsCollection.length). Boris suggests he'd prefer a syntax for defining just a setter. 49016 1 bzbarsky 2011-06-01 15:15:23 +0000 After I suggested that, I realized that ES has no way to express it unless the ES binding says explicitly that the getter is copied from the ancestor interface when defining the property on the proto of the derived interface (which would be fine by me). 49018 2 jonas 2011-06-01 16:16:58 +0000 Are there other examples of this than HTMLOptionsCollection.length? Do we expect others to appear? This is a pretty strange so it seems likely to me that the answer to the above two questions is "no". If that's the case, we could just make the property read/write on the base interface and make the setter throw. In fact, can we do that for now and try to deal on a WebIDL level if the need artists in the future? 49019 3 bzbarsky 2011-06-01 16:21:58 +0000 There's apparently HTMLElement.disabled (which is readonly) vs HTMLInputElement.disabled (and textarea, etc)... 49020 4 allen 2011-06-01 16:43:29 +0000 (In reply to comment #2) > Are there other examples of this than HTMLOptionsCollection.length? Do we > expect others to appear? > > This is a pretty strange so it seems likely to me that the answer to the above > two questions is "no". > I think it would be fine for the Web IDL ES binding to explicitly say that the getter is copied down in these situations. I think this matches the expectation of interface designers. If you really want to over-ride both the getter and setter you would need to explicitly specify that anyway. The problem of clobbering the getter when defining a setter actually occurs anytime you use javascript objects to represent mix'n'match access and update behaviors that can be combined via prototype inheritance. See for example, here is code fragment from https://github.com/allenwb/jsmirrors/blob/master/mirrors.js that exhibits it: function mixinFunctionJSONMutableMirror(proto) { return Obj.create(proto,{ //Implements functionMutableMirrorInterface name: {get: inheritedGetter(proto,"name"), set: function(n) {this.__domain[this.__ser].name=jsonReflectedValue(n)}}, source: {get: inheritedGetter(proto,"source"), set: function(s) {this.__domain[this.__ser].src=jsonReflectedValue(s)}} }); }; Note that getters had to be explicitly defined in a manner that that "copy down" the inherited getter. There is even a proposal for adding syntax to ES.next to explicitly support this pattern. See http://wiki.ecmascript.org/doku.php?id=strawman:object_initialiser_super 49042 5 cam 2011-06-02 00:36:04 +0000 I'm not actually sure what the problem with the shadowing attribute is. As others say, the property on Bar.prototype will need to have both a getter and a setter. The spec defining these interfaces should just define what Bar::quux returns on getting. That definition could be "Returns the same thing as Foo::quux". One question is whether we need to make `Object.getOwnPropertyDescriptor(Foo.prototype, "quux").get == Object.getOwnPropertyDescriptor(Bar.prototype, "quux").get`. I don't think we do. 49044 6 brendan 2011-06-02 00:41:03 +0000 I don't understand what bug 12844 is about, maybe someone could clarify. This bug seems invalid on its face. Shadowing attributes is perfectly doable in ES5 as noted. /be 49049 7 allen 2011-06-02 01:43:18 +0000 (In reply to comment #5) > I'm not actually sure what the problem with the shadowing attribute is. As > others say, the property on Bar.prototype will need to have both a getter and a > setter. The spec defining these interfaces should just define what Bar::quux > returns on getting. That definition could be "Returns the same thing as > Foo::quux". My reading of the original question is that Bar wants to define the setter while continuing to inherit the getter from Foo. (of course, these are just interfaces, but the binding needs to say what concretely happens.) If that is the intended meaning, then it doesn't match a naive JS implementation because JS always defines getter/setter pairs. JS doesn't have the concept of over-riding just a getter or just a setter. There are at least 2 ways you might interpret this in a JS binding, 1) say that the implementation of Bar's quux (either in Bar.prototype or copied to avoid MI issues) uses the same getter function as Foo's quux. 2) say that the implementation of Bar's quux getter dynamically delegates Foo's guux getter as if by evaluating Foo.prototype.quux.call(this) In solution 1, if somebody dynamically changes the getter of Foo quux is won't be seen by objects that implement the Bar interface. In solution 2, such a dynamic change would be visible to Bars > > One question is whether we need to make > `Object.getOwnPropertyDescriptor(Foo.prototype, "quux").get == > Object.getOwnPropertyDescriptor(Bar.prototype, "quux").get`. I don't think we > do. For solution 1, it could be defined so it came out either way. For solution 2 it is going to have to be false. Solution 2 seems to be the directly we are heading in ES.next. I'd recommend you go that route. 49051 8 bzbarsky 2011-06-02 02:11:01 +0000 > I'm not actually sure what the problem with the shadowing attribute is. The main issue I see is that it's a footgun for spec writers. If you allow this, then it becomes easy for someone to introduce an attribute on Element, say, that's shadowed by preexisting attributes on Element subclasses, and then suddenly things get very weird. If shadowing were disallowed (and if it were, Mozilla's webidl impl at least would make it a compile-time error), this would be detected as soon as anyone tries to implement the new property. For that matter, defining a property on some Element subclass that shadows a preexisting Element property is a footgun too. If the getter or setter don't match what the Element property does (assuming it has both a getter and setter) you're introducing a compat issue. So in practice when you shadow you need to specify the same behavior for the shadower and shadowee getter/setter (whichever exists). At which point, why should WebIDL allow anything else? 49052 9 bzbarsky 2011-06-02 02:14:37 +0000 > I don't understand what bug 12844 is about It's about the fact that some HTML element interfaces already have a "label" attribute but HTML5 is adding a "label" attribute on HTMLElement. The question then arises whether that "label" is compatible with the preexisting ones and if not why not and if so why we need the attributes on the derived interfaces. As in, my concerns in comment 8 are very non-hypothetical. Feet are being shot off right as we speak. ;) 49239 10 cam 2011-06-07 04:48:56 +0000 A little Perl script tells me these are the shadowing attributes from HTML5: HTMLElement.checked (readonly) shadowed by HTMLCommandElement HTMLElement.checked (readonly) shadowed by HTMLInputElement HTMLElement.disabled (readonly) shadowed by HTMLButtonElement HTMLElement.disabled (readonly) shadowed by HTMLCommandElement HTMLElement.disabled (readonly) shadowed by HTMLFieldSetElement HTMLElement.disabled (readonly) shadowed by HTMLInputElement HTMLElement.disabled (readonly) shadowed by HTMLKeygenElement HTMLElement.disabled (readonly) shadowed by HTMLLinkElement HTMLElement.disabled (readonly) shadowed by HTMLOptGroupElement HTMLElement.disabled (readonly) shadowed by HTMLOptionElement HTMLElement.disabled (readonly) shadowed by HTMLSelectElement HTMLElement.disabled (readonly) shadowed by HTMLStyleElement HTMLElement.disabled (readonly) shadowed by HTMLTextAreaElement HTMLElement.icon (readonly) shadowed by HTMLCommandElement HTMLElement.label (readonly) shadowed by HTMLCommandElement HTMLElement.label (readonly) shadowed by HTMLMenuElement HTMLElement.label (readonly) shadowed by HTMLOptGroupElement HTMLElement.label (readonly) shadowed by HTMLOptionElement HTMLElement.label (readonly) shadowed by HTMLTrackElement The ones on HTMLElement are "command API attributes". Some of them are writable versions with compatible semantics on the shadowing interfaces (like HTMLCommandElement.checked and HTMLButtonElement.disabled). Some of them aren't compatible, like HTMLTrackElement.label. HTMLElement.onblur shadowed by HTMLBodyElement HTMLElement.onblur shadowed by HTMLFrameSetElement HTMLElement.onerror shadowed by HTMLBodyElement HTMLElement.onerror shadowed by HTMLFrameSetElement HTMLElement.onfocus shadowed by HTMLBodyElement HTMLElement.onfocus shadowed by HTMLFrameSetElement HTMLElement.onload shadowed by HTMLBodyElement HTMLElement.onload shadowed by HTMLFrameSetElement HTMLElement.onscroll shadowed by HTMLBodyElement HTMLElement.onscroll shadowed by HTMLFrameSetElement I think these all exist because on <body> and <frameset>s these event listener attributes cause listeners to be registered on the window rather than the element. Ian, do you expect <!DOCTYPE html> <body><script> document.body.onload = function() { }; var desc = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "onload"); alert(desc.get.call(document.body)); </script> to alert null? That's what I expect currently, footgun-ness aside. 49240 11 bzbarsky 2011-06-07 04:59:55 +0000 > Some of the aren't compatible That seems like the sort of footgun issue we're talking about here. Why shouldn't the command API be usable for <track>? If there's a good reason, why does it not apply to random other HTML elements? 49289 12 cam 2011-06-07 23:14:47 +0000 (In reply to comment #11) > That seems like the sort of footgun issue we're talking about here. Why > shouldn't the command API be usable for <track>? If there's a good reason, why > does it not apply to random other HTML elements? At a guess, I would say that the command API properties on HTMLElement exist to reflect the command-ness of elements that intrinsically define commands, such as <button>, <a href>, etc. <command> lets authors define a custom command that doesn't correspond to a visible element. The properties are defined to return ""/false on elements that don't define a command, including <track>. So I guess the properties were put on HTMLElement because that's the common ancestor of the different elements that define commands. 49290 13 bzbarsky 2011-06-07 23:18:33 +0000 And I argue that if that's the case that's a spec design bug: it's adding lots of useless properties to most HTML elements. 49291 14 brendan 2011-06-07 23:43:01 +0000 Some languages and systems with inheritance require you to say "override" or otherwise be explicit when shadowing. Would that suffice to save feet? /be 49292 15 bzbarsky 2011-06-07 23:44:58 +0000 Are there good situations where you'd really want to override with incompatible behavior? 49293 16 brendan 2011-06-07 23:47:42 +0000 Behavior is unspecified by types in such systems, and definitely in WebIDL. Can't write checks that WebIDL can't cash. Why is behavior an issue here? Bad behavior can happen lots of ways. We don't try to stop it by outlawing expressiveness along any given axis. /be 49294 17 allen 2011-06-07 23:57:24 +0000 (In reply to comment #15) > Are there good situations where you'd really want to override with incompatible > behavior? It's a pretty common situation to start with a class that defines mutable instances and then discover that you need to make a variation with immutable instances. In a perfect would you would refactor and make the mutable class inherit from the immutable class. But if you aren't allowed to do that refactoring (eg, you don't control the framework) you may expediently make the immutable version a sublass of the mutable version and over-ride all the mutation method to throw an error or perhaps silently do nothing. Either of these is probably an incompatible behavior from the perspective of the original class specification. 49295 18 allen 2011-06-08 00:11:21 +0000 (In reply to comment #16) > Behavior is unspecified by types in such systems, and definitely in WebIDL. > Can't write checks that WebIDL can't cash. > > Why is behavior an issue here? Bad behavior can happen lots of ways. We don't > try to stop it by outlawing expressiveness along any given axis. > > /be I think there were two actual issues at the beginning of this thread. First,if a super-interface says some attribute (property in JS terms) is readonly can an interface derived from it make that same attribute read/write. The answer should be yes. Adding write behavior is a specialization which is valid subtyping behavior. (this seems like a WebIDL question that should be independent of language bindings) The second issue is how does this map to JS if the attributes correspond to JS accessor properties as JS can't define an accessor set function without also defining its get function. This is presumably an issue for the WebIDL ECMAScript binding. My suggest is that the answer is that an implementation of the derived writable interface must also implement the required inherited read behavior. It can do this either by making the get side of the accessor delegate to the over-ridden get implementation or by providing a new get-side implementation that does the required. It really seems more like an implementation decision rather than something that needs to be specified in the Es binding. 49297 19 cam 2011-06-08 00:31:24 +0000 (In reply to comment #18) > I think there were two actual issues at the beginning of this thread. First,if > a super-interface says some attribute (property in JS terms) is readonly can an > interface derived from it make that same attribute read/write. The answer > should be yes. Adding write behavior is a specialization which is valid > subtyping behavior. (this seems like a WebIDL question that should be > independent of language bindings) I agree this should be allowed. > The second issue is how does this map to JS if the attributes correspond to JS > accessor properties as JS can't define an accessor set function without also > defining its get function. This is presumably an issue for the WebIDL > ECMAScript binding. My suggest is that the answer is that an implementation of > the derived writable interface must also implement the required inherited read > behavior. It can do this either by making the get side of the accessor > delegate to the over-ridden get implementation or by providing a new get-side > implementation that does the required. It really seems more like an > implementation decision rather than something that needs to be specified in the > Es binding. Whether the implementation has an independent implementation of the get behaviour or whether it defers to the super-interface's getter does sound like an implementation decision. But one thing that is visible to scripts is whether the actual getter on the two properties' descriptors are the same Function object or not. Web IDL doesn't say currently whether these Function objects need to be distinct objects or not. The more general issue, whether overriding with different behaviour should be allowed by Web IDL or not, I'm still unsure about. The problem is with *incompatible* behaviour, right? Different behaviour is OK, as long as it is consistent with the promises made by the definition of the super-interface. The difference between "different" and "incompatible" behaviour isn't one we can check for in the IDL. If we think that "different but compatible" behaviour will never come up when designing Web APIs, then we can get a small win by disallowing overriding in general (apart from the readonly-becoming-writable issue). OTOH, we could just file bugs on the specifications that specify incompatible behaviour on sub-interfaces as we find them... 49298 20 allen 2011-06-08 01:06:07 +0000 (In reply to comment #19) > > Whether the implementation has an independent implementation of the get > behaviour or whether it defers to the super-interface's getter does sound like > an implementation decision. But one thing that is visible to scripts is > whether the actual getter on the two properties' descriptors are the same > Function object or not. Web IDL doesn't say currently whether these Function > objects need to be distinct objects or not. In general, do you every say where you have the same or different function objects. For example, if two different kinds of objects a and b both implement the method foo specified by interface Bar do you require that a.foo === b.foo? What about on the same object at different points in time (could an implementation start out with a placeholder version of method and then replace it upon first invocation?) From an implementation perspective this would probably be best left unspecified. But if you feel you must specify something then it should be that that every function occurrence is different (it's easy to make to uses of the same function appear different (wrapper one). It's harder to make to different functions appear the same). > > The more general issue, whether overriding with different behaviour should be > allowed by Web IDL or not, I'm still unsure about. The problem is with > *incompatible* behaviour, right? Different behaviour is OK, as long as it is > consistent with the promises made by the definition of the super-interface. > The difference between "different" and "incompatible" behaviour isn't one we > can check for in the IDL. If we think that "different but compatible" > behaviour will never come up when designing Web APIs, then we can get a small > win by disallowing overriding in general (apart from the > readonly-becoming-writable issue). Can WebIDL really make any promises about what happens after user code starts changing things? WebIDL can define the initial state of the Web interface objects but if an implementation allows user code to changing or replacing methods of these object then nothing can really be guaranteed after that point. Since browser implementations already allow this (and I don't think anybody is seriously proposing disallowing it) it seem pointless to try to forbid it now. > OTOH, we could just file bugs on the > specifications that specify incompatible behaviour on sub-interfaces as we find > them... This seem like the right approach. Don't write buggy,internally inconsistent specifications and when you find one fix it. Nothing you say in a meta-specification is going to stop people from making mistakes or creating poor designs. 49299 21 cam 2011-06-08 02:35:54 +0000 (In reply to comment #20) > In general, do you every say where you have the same or different function > objects. For example, if two different kinds of objects a and b both implement > the method foo specified by interface Bar do you require that a.foo === b.foo? No. > What about on the same object at different points in time (could an > implementation start out with a placeholder version of method and then replace > it upon first invocation?) No, the document only gives requirements on what objects should look like at startup. > From an implementation perspective this would probably be best left > unspecified. But if you feel you must specify something then it should be that > that every function occurrence is different (it's easy to make to uses of the > same function appear different (wrapper one). It's harder to make to different > functions appear the same). That sounds reasonable. I think you are right though that this likely doesn't warrant specifying. > > The more general issue, whether overriding with different behaviour should be > > allowed by Web IDL or not, I'm still unsure about. The problem is with > > *incompatible* behaviour, right? Different behaviour is OK, as long as it is > > consistent with the promises made by the definition of the super-interface. > > The difference between "different" and "incompatible" behaviour isn't one we > > can check for in the IDL. If we think that "different but compatible" > > behaviour will never come up when designing Web APIs, then we can get a small > > win by disallowing overriding in general (apart from the > > readonly-becoming-writable issue). > > Can WebIDL really make any promises about what happens after user code starts > changing things? It can make promises about the behaviour of certain Function objects when they are called. > WebIDL can define the initial state of the Web interface > objects but if an implementation allows user code to changing or replacing > methods of these object then nothing can really be guaranteed after that > point. Guaranteeing nothing seems a bit much. I think there is plenty you can guarantee. If you have interface Node { readonly attribute Node? parentNode; }; and script does var f = Object.getOwnPropertyDescriptor(Node.prototype, "parentNode").get; Object.defineProperty(Node.prototype, "parentNode", { get: function() { } }); then it's not "all bets off"; the guarantee that calling 'f' on a Node object returns the Node's parent should still hold. The spec doesn't make guarantees on what `myNode.parentNode` will do explicitly. > Since browser implementations already allow this (and I don't think anybody is > seriously proposing disallowing it) it seem pointless to try to forbid it now. Allow user script to modify prototype objects such that sub-interfaces have incompatible behaviour, do you mean? They can of course, but I'm not sure that helps determine whether we want to allow or disallow specifications from doing it. > > OTOH, we could just file bugs on the > > specifications that specify incompatible behaviour on sub-interfaces as we find > > them... > > This seem like the right approach. Don't write buggy,internally inconsistent > specifications and when you find one fix it. Nothing you say in a > meta-specification is going to stop people from making mistakes or creating > poor designs. Although I did recently outlaw sequences from being used as the type of an attribute, since it has suboptimal behaviour when used in a natural way -- bug 12287 -- I'm inclined to agree with Allen in general here. There are only a few instances of this in HTML5 at the moment. If we consider them to be footguns, let's raise bugs on them (as Ms2ger has done). 49301 22 bzbarsky 2011-06-08 05:13:25 +0000 > you may expediently make the immutable version a sublass of the mutable version > and over-ride all the mutation method to throw an error That's not a workable solution for a web spec, because you can explicitly call the "superclass" methods on the "subclass" instance (just grab them off the higher-up-the-chain proto and use .call()). > Adding write behavior is a specialization which is valid subtyping behavior. I agree; I would be quite happy with explicit WebIDL syntax for this, as I said. > The second issue is how does this map to JS That's a solvable problem; it doesn't matter to me that much how exactly we solve it. > The problem is with *incompatible* behaviour, right? _A_ problem is when two prototypes on the proto chain of an element, say, both define a property and the two property getters do different things when called on that element. In particular it breaks grabbing a property off the higher-up prototype and then applying its getter to all things that have that proto on the proto chain... unless that operation somehow makes sense for this element which has some other getter definition lower down on its proto chain. I'm not sure I can think of an example of "different but compatible" behavior that doesn't run into that problem. Can you? 49303 23 allen 2011-06-08 05:42:33 +0000 (In reply to comment #22) > > I'm not sure I can think of an example of "different but compatible" behavior > that doesn't run into that problem. Can you? The conventional way this would be defined is you can replace a method with another that does everything the original did plus some other stuff. Presumably anybody who is dependent upon the original behavior doesn't care about the "other stuff". Adding a logging wrapper is a simple example. More generally, I don't think it is the job of these specs. to try to bullet proof against every crazy thing somebody might do via reflection or debugging APIs, or other "exploits". If you take a any method and apply it do the wrong kind of object, crazy things may happen. If everything is implemented in JavaScipt then at least memory safety will be guaranteed by the language. If part of the system is implemented outside of JavaScript then it is the responsibility of the host object implementation to maintain memory safety in those situations. Beyond that I don't think you can say very much that will be actionable by implementations without straitjacketing JavaScript code in ways that may not be either practical or desirable. 49304 24 bzbarsky 2011-06-08 05:47:01 +0000 My main point is that it doesn't make sense to put a property on HTMLElement if that property doesn't actually "work" for all HTML elements. In that situation, it should just go on more derived interfaces as needed. That is, every single instance of overriding I see in the HTML spec right now, with the exception of readwrite attributes overriding readonly ones, looks like a spec bug to me. Which raises the question of why we want to allow those sorts of spec bugs.... 49360 25 cam 2011-06-09 00:07:41 +0000 One example of the kind of thing I was thinking about was how objects stringify. Now, this isn't directly applicable because this is done with "stringifiers" in Web IDL as opposed to writing a toString operation, and besides operations are different from attributes -- but I think it's an analagous situation. To me, Allen's general pattern of derived things doing additional work (like logging) makes sense to allow. So I think we want to "allow these sort of spec bugs" only if there could never be non-buggy reasons for shadowing. All of this applies equally to operations too, right? The examples from HTML5 are deliberate, as far as I know, and not accidental shadowing. Maybe Ian can say why it's preferable to have these properties on HTMLElement rather than on the separate interfaces where they actually apply. 49550 26 cam 2011-06-14 02:24:56 +0000 (In reply to comment #25) > To me, Allen's general pattern of derived things doing additional work (like > logging) makes sense to allow. So I think we want to "allow these sort of spec > bugs" only if there could never be non-buggy reasons for shadowing. (I meant disallow rather than allow, of course.) 49553 27 ian 2011-06-14 04:26:38 +0000 The command API _does_ work on every HTML element, because you can use tabindex="" to make any element into a Command for the purposes of the command API. There are certain elements where it isn't useful, e.g. it doesn't make sense really for <input type=range>, though it does make sense for <input type=button>, but like most of the global features, it makes sense most of the time. So e.g. HTMLTrackElement.label vs the command API label is a minor issue (you wouldn't sanely use <track> as a command, though I guess there might be some contrived situations in which you could expose its commandy behaviour if you tried and especially if you didn't care too much about whether your document was valid), but if we cared we could just make label="" be the label of the command if it's a <track> element, like we do with <option>. I haven't done that so far because it isn't ever going to be done by someone sane. Some of the other ones, e.g. disabled on <textarea> and its cousin on the command API, or label on <menu>, are less easy to deal with. Maybe better would be to have certain elements on which you cannot specify tabindex="", though so far global attributes haven't had such constraints defined (e.g. you can use hidden="" on <style> even though that would make no sense, or indeed can use tabindex="" on elements like <source> or <meta> or even <option> where it really doesn't make sense). That's orthogonal to what the DOM APIs do, though. If you want the global attributes to be less global, please file a separate bug. My intent with shadowing these at the IDL level was that only the most derived one would exist. This stuff was written before we considered (or at least before I was aware of us considering) actually having stuff on non-leaf interfaces exposed on non-leaf interface objects. It's not a big deal that they both be there though, it'll just be one of those bits of trivia that is used in programming contests... I'd be fine with making shadowing illegal so long as we introduced a feature whereby one could explicitly override something, as seen in various programming languages, e.g. from comment 0: interface Bar : Foo { attribute DOMString quux; override; } That would avoid us making unintentional mistakes. Having said that, I'm not aware of us ever having made such a mistake. 49757 28 bzbarsky 2011-06-17 02:54:49 +0000 > Maybe better would be to have certain elements on which you cannot specify > tabindex="" Or maybe better would be to not use generic names for the command API that then lead to collisions? It's not like you can prevent people tabbing to <textarea> anyway! > It's not a big deal that they both be there though It is, though, since the spec needs to define behavior for the "superclass" functions/getters/setters being applied to the "subclass" and currently it may or my not do so in sane ways due to the assumption that such things can't happen. > Having said that, I'm not aware of us ever having made such a mistake. Given your comments about <textarea>, I'm not convinced at all. 49759 29 cam 2011-06-17 03:01:58 +0000 (In reply to comment #28) > > It's not a big deal that they both be there though > > It is, though, since the spec needs to define behavior for the "superclass" > functions/getters/setters being applied to the "subclass" and currently it may > or my not do so in sane ways due to the assumption that such things can't > happen. I've been assuming that the superclass version of the function would always keep working (or at least that the specification defines it so that it does). So you could still do // maybe this alerts "a" alert(Superclass.prototype.theFunction.call(theObject)); // and this alerts "b" theObject.theFunction(); If we are in the state that calling the superclass function would violate some invariants because the specification assumes that it cannot be called on the object, then that really would be a problem. I don't think that's the case, though. 50297 30 ian 2011-06-24 22:07:16 +0000 (In reply to comment #28) > > Or maybe better would be to not use generic names for the command API that then > lead to collisions? The idea is specifically to reuse the attributes that already exist with the semantics we want, rather than introducing a whole new set of properties that replicate existing ones. > It's not like you can prevent people tabbing to <textarea> anyway! Tabbing to textarea isn't the problem. The only way textarea is a "problem" is that you can set an accesskey for it, which then makes it a command; you can then disable it, but the command won't be disabled because accesskey commands are never disabled, but the <textarea> itself will be disabled, so textarea.disabled will claim the command is disabled even though it isn't. The problem here isn't that the attribute is shadowed, the problem is that the command API doesn't honour the <textarea disabled> state. The way to solve that is to make it honour that state. But that's a separate bug (please file it if you care about it). Similarly with <track>, the problem is that it makes no sense for that to be a command, just like it makes no sense for it to be contenteditable="", tabindex=""ed, accesskey=""ed, or have many of the other global attributes applied to it. If we care about fixing _that_, I can make the spec explicitly list all the elements on which these interactive attributes can be set. But that's a separate bug as well (please file it if you care about it). (In reply to comment #29) > > If we are in the state that calling the superclass function would violate some > invariants because the specification assumes that it cannot be called on the > object, then that really would be a problem. I don't think that's the case, > though. I don't think it's the case either. However, I never intended for there to be two copies of these attributes. I'd like a way whereby I can just redefine the attribute on the subclass, e.g. to change it so that it is not readonly. 50299 31 bzbarsky 2011-06-25 02:43:19 +0000 > The problem here isn't that the attribute is shadowed, the problem is that the > command API doesn't honour the <textarea disabled> state Or maybe that a single boolean is being used to track two separate bits of state? That is, .disabled on textarea does not have the same semantics as the command API .disabled... > I'd like a way whereby I can just redefine the attribute on the subclass, e.g. > to change it so that it is not readonly. I agree we need a way for subclasses to add a setter to a superclass readonly attribute, for sure. 50301 32 dhtmlkitchen 2011-06-25 04:47:43 +0000 (In reply to comment #31) > That is, .disabled on textarea does not have the same semantics as the command > API .disabled... > And most likely differs from MSIEs Element `disabled` property. http://msdn.microsoft.com/en-us/library/ms533732%28v=vs.85%29.aspx 50334 33 cam 2011-06-26 22:39:33 +0000 (In reply to comment #31) > > I'd like a way whereby I can just redefine the attribute on the subclass, e.g. > > to change it so that it is not readonly. > > I agree we need a way for subclasses to add a setter to a superclass readonly > attribute, for sure. I don't see any problem with allowing the SuperClass.prototype.quux to be a property with a getter only, and SubClass.prototype.quux to be a property with a getter and a setter, and both reflecting the same internal state. That works with Web IDL as it is written today. I don't see how allowing the derived interface to cause SuperClass.prototype.quux to grow a setter is any better. Alternatively, just define quux on the ancestor interface to be writable in the first place, and define it to throw if its setter is called on an object that isn't derived from SubClass. 50479 34 cam 2011-06-30 03:23:24 +0000 The more I think about having a derived interface affect something on the ancestor interface (making an accessor property grow a setter), the more weird it seems to me. If we are to keep HTMLElement.prototype.disabled etc., I recommend either making the ancestor attribute writable in the first place, as Jonas suggests in comment 2, or simply adding a writable attribute on HTMLDerivedInterface as needed. 50480 35 bzbarsky 2011-06-30 03:34:27 +0000 > The more I think about having a derived interface affect something on the > ancestor interface No one proposed that.... the proposal was to have an IDL syntax for the derived interface declaring a setter on itself, not on the ancestor interface, while picking up the ancestor interface getter automatically. 50481 36 cam 2011-06-30 03:45:45 +0000 (In reply to comment #35) > No one proposed that.... the proposal was to have an IDL syntax for the derived > interface declaring a setter on itself, not on the ancestor interface, while > picking up the ancestor interface getter automatically. Then I misread the earlier proposals, sorry. As I mention, it's not too much trouble to state in prose that a derived interface's attribute's get behaviour is the same as the one on the ancestor interface. But I can see that it would be advantageous to have that encoded in the IDL so that binding generators can implement that half of the writable property automatically, so... let me propose something. 50483 37 cam 2011-06-30 04:42:14 +0000 OK, I've added syntax for this: interface Ancestor { readonly attribute DOMString whatever; }; interface Derived : Ancestor { attribute DOMString whatever inherits getter; }; Object.getOwnPropertyDescriptor(Derived.protoype, "whatever").get will be a distinct object from Ancestor.prototype.whatever's, but they will have the same behaviour. There is no need to define Derived::whatever's get behaviour in prose. (I didn't use extended attributes for this since it's not really optional, language binding specific behaviour.) http://dev.w3.org/cvsweb/2006/webapi/WebIDL/Overview.xml.diff?r1=1.328;r2=1.329;f=h 50509 38 ian 2011-06-30 18:22:54 +0000 (In reply to comment #31) > > The problem here isn't that the attribute is shadowed, the problem is that the > > command API doesn't honour the <textarea disabled> state > > Or maybe that a single boolean is being used to track two separate bits of > state? Well, there's no state at the command level for <textarea> here. An accesskey=""-created command is never disabled currently. > That is, .disabled on textarea does not have the same semantics as the command > API .disabled... If these two having different semantics is a problem you care about, I can make them have the same semantics. Please file a separate bug for that. 126315 39 1641 powelld584 2016-05-03 07:52:40 +0000 Created attachment 1641 being shadowed can u tell me the source 126316 40 1641 powelld584 2016-05-03 07:54:59 +0000 Comment on attachment 1641 being shadowed can u tell me the source Help me get rid of screen hacker 1641 2016-05-03 07:52:40 +0000 2016-05-03 07:52:40 +0000 being shadowed can u tell me the source mirroring.pdf application/pdf 29988 powelld584 JVBERi0xLjMKJcfsj6IKNSAwIG9iago8PC9MZW5ndGggNiAwIFIvRmlsdGVyIC9GbGF0ZURlY29k ZT4+CnN0cmVhbQp4nM1cW3PcthXu8/4KvlWbydIEAV6Qt7p2EmXiaeyo0+l4+rDSSrJT3Vdy4r/R mfb3BuAF5wD4FuRKVifOjM2QxO3g4DvfuXBvsyIXZVbY/8aLk8vFi3dNdr5ddLezu/OFyD4uZFPl StdZpas6rzJVaPOXaHJt7t2dLs6+WhS51I1W2nRVF6KqZSZs41v7bt11pYTOZKO6NrYfO9bLw8WL wzfZ/d3D6eLFPzJRLF583/398qe/ZmJx+Cr7E/izeH2YvR0m+O47muntos2l/dPd4Ncnl9nLI7My nZl1Hp2ZNdm7IqukWU6ZNULljXlwuTjIlke/LF4fLd4uVNmYNZeZLES/ZJW1pZ29mLHkqp+CylRZ dyuWRdH9+0UW/bi1qjKvVWZWLMKl3mZt1b8mm4Ztkm57hRBF9uravjc5qOla56YtG7e2QjMCaYoq r4OBreY5IbZF0bRi2NHo9qw1J4avtcqLlsYXIlfZ0Y+Lo6/eH7xZrsoyV2V58HFpBtSirA/uljJX VVO37Op6uYpvUpMrenw+XGphRhufs+Y38BL2f79cqVyqVquDB3rOxqIJsFfp5ulS5E1bVuXB1l3R nH5drqpcyLJVuJ8PNA41+mk5Pr5w99auczY1Gpt12fdTNlI4wUsZSV6Lil0NkvFvZst/Hf3gFGlv MBBqt7I0Ii+UpywGJoy2mP/9c/+X1ZteDrpujBxGKa6XK1HkZa20EYRdvXR7IDvRjsvMzIsiN7ih jRhEXjdKWf0b+7nrBWY7Z5fXriN2k/VktpO0bZT9wzClis9zw5TBNafHNJF/m8dtXjSlZNuZMV2J B2Q9XvY7LHTrra3Ja63LalyFVQtqfsd1xfX0eTlOg68MthlntF2u6rwolWBNzqjHe34KYj3uu6wK 03zYv6I++Jrt33h11ulhKSqrM0V2tFm8Z4u9sJMw6ir9ozjMjPezpn26cm9ugMzZht6AF9f81I2L BWN7S3AvhvvQCQC+GQnINqKrvG9TSda6P7KrQVar4VxtACb/xZ2tY6fz4X7ae0y8D+CUndJxvOgU WdfmTdKlxMK6wecu7Mi0rvKqqLSBzLgJU090iEKli150UyPFuAb9nDgBcR2In6IpknD5+ux2+ej3 xwQ+ao/Um2R1RUcHbQTECQR2SIIRDreGw2BcQzhME/+PEa952iiMzVBbztHCqMt7gFtrJBWEN5cj P2rYarY96pkHsh5RD42yEzBkbhC1ObgN0LxSHCjZzPihRujohoEQjpT/I2HHp+XwNI2TUD++sY/b tmq1w7deKiG+WVLuKEfLH6/6x4ySSCbWbm1amEEOfnTngDT+ik4eQeBv3MLYSfHBV3Kcntpv+O+I Lq7dUE49mJ3kwts9+r6rJ9xZA2CZiW9pgew7pVdEHRgy0eYEisUQzJ7aZ5oUGc8bN+oNt4QxzcOm A+DrNWIpz7SOb7lDFNhk37w8AtX+Rrp8w/QFrI7a/LxcjdR1goWSPOlQfFlmykhC3/lz6E8WWDzJ 6KfRpHNoBoMDYecJue05EnsSbPnjEyDDy64f2Uh2BVkYNf64FE0uWq73dD722DFm+5OGCPPIgRb7 sNwZDcu3mKo+hDDi7xK7SRCJyBERqit2iNwiNu4mkZFTZIsnmG2Cl5l1nyGAgQ4T9bhBRIe1SRt1 M11R2+CSYE5AjrgeXR0iLjOXFHrycTMnoSKWsQbL7p1MoRtzPmc6maFWBOp3S9MhBPN4eCepdhff Gjs/7sy/FFJDv8o7+e6Sv+lkStPYBugZnKFj4OvyJm4Y5K7z/epfLBvoL0GH+4kzm+ezIdOzi0f3 LLzqI/idWpw6Hj26vHUVbY0qCzxHFu9hb/bMq1GDx1dqjSH9NJBj1zhblo3pspAdyqlSMqP0/ulO 4K5QVABphIcbduVMGcIs6LTiiBcL8sanCkanoD2fdFMCVmH2IXTcCxuE6C3Kox324nkcdgR2yEdF pzENlBhm6U1ieB+Q/UBhldGtEWX0otQ6oguikL0nyAJdnfw5JSsLq/aPcLzIBnFzHeh7QSzfW53H w2LJMv26BhKZFSUMdJudAmyE4yYV3zZH9wi22LZ62z6a82dyQWogbhbsg14dze8YWTwUyODaDYQM iQfaLI8IUYAgxdL5AUzvL0P8kPh/aQ+EudUkYri4EBJ3RlFhrIjWOdEPV1TQD6XEQgsYcKAdGoHj 9DGbunb4A1UCJwFSvHLLHCEnXVKY0I31Gwtw7wfX4iFNEJj0Snez6PmMMr25XEpB/ZQpZSuVystH aRvzr3bHa7TapQVhnFSUHjUHJJ2HU6JwBbZwDNlv0sc9nQWYQHsIRIiZIldgvj83x5oH/srjIrwp mNgM5FnbyoACx2lXpTRbqp5PrXxwoZPA7GHxGF2jEN+EdX9ShmFy78erCVO3cbi2w6mfhvtAXSDc I5sIqf1EfgeJitvRXq9EXrZMLUqZl0UlZnAagps+LqTMaHE6YUyXDiyTF78Uo8qqfvTXIHB+4q5g kceGSA7zFD73eRtRea61o2uTlSE+bxqCzPExeMO12y8MmSrJaYJFxLUoFwwLx6tPmDePjbfM7sSN 2boywO1+o75PgFpteXABOpRjwcsZMkQlmNpIUIPoZ6eVsrW6MWjl2jU+piafXW7uHh2sLToQUfmP ne+GLmluLbP1AOFIrYr0i14UcZwl7ckF24jd8q167jXEua7RfNnNhJL4bSo29fjqaxLbrDV2MZQb mgaNzebGnl9QKyLnOQ/H9NSJGTADMa0NLNqJ1cqDmCD1TxEAQpKrMQIoYASQ4Ti1YVGB8zD64Dlb k2H+2EnfEeePIRsF+mmUlC9tI2GYXc3Lk+EsiWf7UsUqsPPQHelORBzvScbrYLxHepZzxBHJrNsd P0TALDNFTofPoBPyCWwi9FuO58pvy5yUJMGGq0EhYlYjsQcfm6kiTypLCSN1QUHX7KB7EGf0Cx56 bQCpq3TgahtwdukFbxlG0BJxSN9J5QMAE1jPNbt4iMcGQQIMxmlRjnMHTQqw0Wfns45nJeo4HGs7 T1VX+iQCJyFAugpOg0SwI/ne10fWLEcROYVkoyh8uhrahMT3j1mCBg8pu4T2iSucKHMtdeVB2zil c6Acw9MKu17pvNI9yz0Dl5Ka/ILcR+i6HgOtRZoMZ5uO82Ob0WuV8bRHpeIlwjuzMAH8HaM30Q6g pdB7dPUNk+ygxHaKcS2Y8ejitMDwyn+jEAOPL+iyztvyUdUxdNhcgRi0dshATuVY0pb9qcGxZPiA 7fdEqHwiKXcC1o0yVHGaqPRZoi0Tsr4orPSmEpEPQPaTGfExRKr9oFNM/Z5uW0Lq504Qu5yoGEcR koTp7qfmtnOCvdygsakN25w4adRabijtt29FFceiAoNPW8Ys2wXQ1DU3fMCRQ4VEkVJa9wKF3kcv jiW5GIwYL662l0TDng1HkN7CRBICUMCJJpNdyGljCr7jQ5G5ufh9gpd97wpuQP1/AXHuszBJxvHF +QLwNN2l3lAS+BhpOk8LoI5IqBuGOiFp13jDJ+o4t4DooCjxVH1V+guYeyb9ibTWhJM+Pj4ccNzs movHDfWl1nAQjjPwgHSyvyqED7AIHbQd6jk19FGHEFROMgNwnNxySKonUrnzGSZjBf7HZ1ZV00nS iGqXXhkeBV5h7ne2Ek1XQ85MnMSfE3RZ/j7U0zDPDdneRGGAbxh4gcwc/9rzT7hdjkVPygUZGdqP dBJyAnYmTUZcMrjLaMvAyZ11LKlGG333Rs4q9OpQwPIESOPBqekNksa+Xxqa7cS2C7DB6ByaxgoR B0g2YFwY7fcN0FfINDdI20eYK+HO7s8G/rmMow20vV7MeKx7OgVngQf/UtXQMIEDwQXGl9DQCEhh 0fWu5BFpWVQPVlVTdgXGY739AnwfxmYJL6KC2Gl78ahceJ8zrvPK6cWGbSPwgrD42bLcYtJqaisc qufTVR6IStoyBjHXSIERhKfKuncUKmz4MF/AvyPa2lXeTlTgxdpUSRjn2JdMBXA1n9CjYNcEKRkK HKRi1BXGL6bmO2kai5Gx7uHP/p3WGxJFXzMnw/BAj5DqvXHpyHlheGtPoRc28WMKa4AHHkzGRv0q RlHTETJ66zTgTcRU0h+CbcDTfUgqhWuS3+1fD2pZ5IolJulsTB0odwlPFM0ISgABPSK5pwhzSE9h tdw90JB0jm7HeZJ1vr8D+H34DaL/1dgG4SVGDUBfSIA4a5Lmp+QcQt8SRW4RKf0fmG06L4pB5Mun 2veItwKYmPtxGVM6bujGT4uoFBeiDYwITQgD1WVMBAgROF5HA44/C7Qyj9E3+AfuF3yM2rek9p6d sT8/wmxIbDnW4N49BUc+wN90eoh/H8pcsndhKRyvIwMYQjVqJwyKVgQssfqByj3NKqdscY3Ka6Hc MrXmE4Y/eIVOxme+TUAIRnvbvNJFEBUbrxKxsOEcx7WTn5gMglnayqhzutwiTfa/VaQytu4gVH45 JxlGMNAJO6JUtgUmjPYHls2xH+qiN1nR3hasHJbveXwbzK3fFUNmFS+sgz/AZe2g8RyUrnD9H6p2 RII7m4CxrqCtbaXQvLZtfFXFimYHf8A/GcZDqWOm5SPd9WrnYN0g/5RRFMIvzH2P94kO6Y4PcGCd 2bgNn+bqyLd0853pcygneO0Oz2twjPy6TzA3DrXDi2zfYS3iVVir6Fen+lVuCaAKP5D3SxZNs50A 3/0o3NvF78XrHkNlbmRzdHJlYW0KZW5kb2JqCjYgMCBvYmoKMzUzNAplbmRvYmoKMjMgMCBvYmoK PDwvTGVuZ3RoIDI0IDAgUi9GaWx0ZXIgL0ZsYXRlRGVjb2RlPj4Kc3RyZWFtCniczVzdct22Ee71 eQr2Kud4Ipr44Q96k8ZJ2rgTt46jTibj9EK2jhW1tiTbspO8Rl+mr1f875L8QB7Jilt7RoK4WHCx +HaxWAB8XTW1kFXj/qfC81eb+0/66uztxj+u3pxtVN/W2nRVa9qubivdGPtD9LWxz97sNy/ubZpa md5oY5vpGtF2qhKO8bWr2/lmtDCV6rXnce249zx4uLn/8FF1/ebdfnP/+0o0m/tf+58PHn9Ric3D L6vfgX+brx5W30bhnvyZpHy9GWrl/vkHvPz8VfXg2PbKVLaPxy82wj8VVatsd2TVC133lvBqs612 x//cfHW8+XajZW/7LCvViNBlXQ3SSS8O6HIbRNCVlp3vsWoa//tOOn27vmpZd7qyPRbTrr6uhjZU U33PBskMAQyiqb68dPVWXyp0ZWrLy97bOaVZhfSNxdBAbxbCqf74G/fnJ+4vzf8IpON7T7cPd009 GCG77YvdkaVYTRtbKxd/3SkH3abdXtqHTS07bbbvdqLuB2WZPrEP675v+m57mh8y9pe7thZKDnp7 nkv/suShbnqptnvGk+S4zqVLT5WtZNSr/OyNbaZzIBGs4vPdUVc3UovYtHtGpVPWYBbx591Rapxk vCb6T7HfbR/FkL0SUQWuqbf5lSTlWyDGNejhuatnhDWU7UWueAa6/Y6EuALkE/Ds1e5IylpL2bN+ WaXpWrWNlYwVL3f/OP7LRgrl7LSpjk83TyNZG623n+Y2qXWmtT3SKg0JdeylH3jT2d7+uksQoCYv qI948CbjMFY0vZB1fA/0QiznO+tkxSA4xxWTNikNtXIKJGSgoQEh3VODWYRu+wemWzcIR3EUjqKV nkZ7vv9EdmT8g6XLWmpP/0+gM+eg67ZL4+jGpOmt/W+Pbamt26Z1mE52hyyQBEWGdQIQzXCMBh7i ouRvEjCo5jtu8w6Ug9EQ/IxM8jL7pbF4PzFQ1aQBGCn6yGvS6VrIG+n6azIP5jd/3lGPp2YqeD+5 9EvYO59DirtXBHoC+Al4HYI6eglRmc6J+XVQqjGsT1MnFFny4JyCV79AwGGOC80aPwHLhC2+Y6ae 4UvYhzzImvfcMXlHKtsQ7XlQTOHpBUcDzIxoCk9H/syXWh0tdRjawUDMSmnq7lYe4jdF7TKM0Pgt c5BmfmHgBlMIiXUNmGFMcE0TPQpCzpDHuaR3s8nxs9/EvXy/O1KiNo3qnbpUPSjRRqCpkTL5hE2W lAXlJpB0DefZZ9CoJvoqW1+uiNp5C8YHIm0aS/nxoRdewjGdGvEg1lzJcmjHw1OgqBtFXRMUuVhr MfT2I+Y9jG5YqPYZ0nSGiFObQ0jDxbxCKiD9Mo+3X1bWcrSOVIm88hMymLc0fVEscAGMGXmWUUxB fc3auwTy8HgwtfMM2AVz89OAWMtGMh4WrF8TnVVFwRSPlmRv+92oEA/ahbIcWDz4lK20kIekxmmZ hnpbgZFbtuNR9AUm5ivWDpgxUWRI4tTh1a1KgbDqfKc1xcBuvco83z57vmcgiEWdp2A3WVzXQ41Q fEwD9H4HAAwCfh6nLS5orlA7NAJM2wxQUVrZKegtH+8SDwH3hLgvgBi8mSzGI0vu+lZ0OGwbTXvA P3yK2kRYh7NvwZ6ZY0xRVp4a4Zz2791R7wIq3c5mBG+GLOxbyE6Mx3TZ30FvAYDDVMVG5wyMDjS0 6YKo6JMZGbliqjgfMNMV1sJZ3BPQ4rLKiGNFy6tdDTJGlEtjcgpD2sg4geIMOX42/hyQcBnC/bBW g0uwcT98lb1E1A+PwaZrqklijKeagK1cZp4Lzi1VbeMBMVslq9Fci/00dQxHqhdgtC/RaJ+CcWfv mS4w3SqQIzu3GDx+4/IRweX77KT/YUNgSdmOmLx07v/JNO2kYsxlw+ROS/zwmZ0zat323ZBfb5c1 b3bpIcpvMfZz6hvxUOmS0ir08JxntdLDMyry4IUin5nR99vPd2nMH+zcQsEo026/c46tM8YC7m+7 ozRY31Dzfyc1sazPV3lyYFV/CG31PRfqT4FufSPXuOf3Bkil6bQ9TlKPktD+R2EOV9CJEripNEpv JIXM8gSTOZ4WPzBZhNYL18jxVrm3yOWxFt+DoPICefpC6gvMZr+P5q8Hbi5Onwcn9lhFIp/kMCqv XWbJNbaobPlQ4XADeFUcbqTSI19R9erG0UZcM0XkYZ/xM5nIuBizv/WkOw4wL4ECLrgbIa046xms QI9ooXrOJmDoMOYPSYjn3E8ncnJHKg2+6xiJdjqvqSV2Qn909uxsr3MRaH58UIdjaJ8G4wN95HqX ha47YaM37Fo6sKV1wBTyxSjJBdTGtHLCnMnctb9l7imzXCAnzwyPzOMZ0j6OhnLFF3Bq52ZIw8ii fs/fSYHHcWSIH4Bhaue7LBD3jqnee56RJwwAZ/F2lj0rzi7S1MKtGPu672jJGDZgN8JoVSmp++pV LDetql5urNfrx2VX5+XmJ1tr6ColjPEcvtyEWlaCcdnWcRzf36su+K710DT9IMKuNb1TSMsjjMqb +1a+IlN6rRByqExL2+M32anmZhA3jaUenJbcVrRT1isbyz7OM/rUE0RPnuKBKYIma49HPP81RpDj ptIlNUkPaX49WmpcDLdpfOYO3cOzVEwBTESMElbVETGhHFCiVd+Oywkxyk7NCTGx3IRaSk7KByCG 3nkDxNBr7xoxahhcIvr/FjGW5Wi+PkyuMWZeQUPEPtn7cN66Vywmj/6y10lMv4RcRVJT960yTVfN C3YsehnOrXgQ+RFuTP7th+2QGppqeLCMyBY5ZoGbPOOclTwiZCUTmbOSaUDWFXLutMN/ooxMIPSq SCa/DslkxJB8E1OZn8gx0mVPbPutDVGCqfyJz5Z5UbKfxup5mrPrvTpn93/ICAZbJj4rYKwma0v/ fDe3LlqnsJ0JMtOXYD8TbnyiBCbagr9ipTyh81NAOeVW6M1NLafRZsUuXI2SXRS544wNWSO6SqzR dUPWiLyyzKFXcuiIInozAX6Z7EUrk/3ry+Q7Ar4NxVoZkP9dXlGdUOZlkhAd5+gPXxDDbcVCTo8l vCgDl6F4yrz8ZAug6eK2q7EdOcAWLWtvl9PrNW+Iczto7TLOfY0CzsvcHucF1gSmAqvHeYE1Aa0o c+xV50LcDMVhivMiOYhWJIfXF8l3hHMhk4OHaUm0TZcPLfIMDDqgcNABm8lm4/KW+tpm9pJX96lw h9jR2dHZGUDXGdqLuyKLp3X0yh7HvbBI7IfRTNjGNd0Bk6EXsjEjJpbNxOd3UD4bbOizJTU6v8jP NoCTAejUVoLDwKdDBId0dLJrR69mGxT2YQd2iWf5/qTpCzQ9XzI/CnZEwGFMcQtX1g1yxZW5GiVX VuQOrgyzJn9RYA2uDLMmX1KUOfZKm4aFk2LqyorkIFqRHF5fJN+NK5ODqlWcstnewRXwZTwhDKJD ZEJXAEBre1Qn3uyUUBQGBEeh2tbKutXcewyDtiY6hGhj4h1G22to/wxEFnBXdc2KYNgMT9dw5z3X zOisSzoBxHVwU3PTbBrE5uZqlMytyB3MDbNGTJdYg7lh1oj3ssyxV9JIZhHTpWGZHEQrksPri+Q7 MrfWuGyKNzeZ7UmDHZt7LLmaQdWDiuyYHDpng7abZ3spzhgXbiSkWFj2uqvF/zIWlsOwgmhXo4To IndANGaNsCmxBkRj1gipssyxV+5eE4FOThFdJAfRiuTw+iL5jhCt2trECWSUSZsv8FCMS/BkOD6Z 4G/sJidQ06Zvt3+dvTlBdjAWSHcPxMaIFSC6GiUgFrkDEDFrGu0CawAiZk1IKMoceiUG0y+41jLZ i1Ym+9eXyXcERHeYOrpWttPHNzXnznPp+MD4Msly8gveeKE5nuIglpBA12n2I/AKbVv52NC246SW oe1rFKBd5vbQLrAm/BRYPbQLrAlbRZljr/qmWfCxZXIQrUgOry+S7wbawu3BRB/7DTgZc8ZKeeU9 P36iDbxhuHoYbjEfAc9Ys5oHXXmcJNs+OuQ7sxIo+xolyBe5A+Qxa8BVkTVAHrMGzC3IHHvVNkuB cpkcRCuSw+uL5DuCfEf7jZ/nVPLpbp5KRg6eu+1FSH8ZkdZ1DnR0ym5+QOIWx77Q5DHZv+mVrpuP H77YoGkljvY1SoAvcgfAY9aAqiJrADxmDYhbkDn2SjWFUJfVWAuBFmpoqlHSTFGCRF6K+wotB8UV W07kpbCw0HLQa7HlRC60vEL+MD+Qvm5gQyB3rrvwdYM7uBsNL9TtJz5l7DRWb4UupcTgMVQUXBay /yBptZz9X/GALCBlE/QbOvOwmp5OPCgzjhNi8Mb+Wlg9Pyf3C+wtSOVRM3z/2+8yWP9LF3aXvy4w yhKm5H3UiRD4AN+PW5QGpPOPZ+DZ6knkuCMT/L23lvi1FnFrc1ODP0QnpIpfMXm6vb+oDPipheWr vDzoy5i7z4AIdy1ue0vBzaDsYFCUV5hhNg7+OA9C1X7Xtt1I0zf9Lg7QdCtMPeiRpn/ckbV9Cq8N ssuE+Jrt6L6KncrsG/IVuqf46MnrXKILc2tXc4HfQz4OXQeHqwyU3lm4ll3ergS5eOg/z6b+091R QSfY8S5FhOMEMbT9d4XwuHAFZmzu81PDvTr8owbLUxH6PsHyINKzd5Oeui8RoHB4ZWuaDJj5tcL8 sfzVkLVLyhhMxZxPceOHu6RU+rB7U6xn7UQ0Dyqk1ufA/aJ7lHwQx/eI/aDzHWJaM71ANgZvy978 ixuj0GIONX7JMIOgsNO+9hWZQ0Ur3lWbOId9dg6zu2rpevIdf6OHbqAwnVOKh85Hz5LsU3cNPAKc ej/OQZO1G+90hgK8BO5y0eVCdD5h9djF3EksHbsY+SV0XZAHR0C1j+mSHb4oNf+ow0EXtNVofA/8 zIQLMG7+WRZ8ZRnd5EdGBTXOQgC0KXRwRnKUUpxfu0Y9ZCzPkAM6/Op3OFMg5WFnCpjyJ57+PN1k ZlHePl5qbhIoSs7dLsLTRyJisHeLzx+gYGR2tXBsZiuL12VsEXZG+pyfBdmjEYJTRE0XZ1k27NvN fwEOCyTOZW5kc3RyZWFtCmVuZG9iagoyNCAwIG9iagozNzc5CmVuZG9iago0IDAgb2JqCjw8L1R5 cGUvUGFnZS9NZWRpYUJveCBbMCAwIDYxMiA3OTJdCi9Sb3RhdGUgMC9QYXJlbnQgMyAwIFIKL1Jl c291cmNlczw8L1Byb2NTZXRbL1BERiAvSW1hZ2VCIC9JbWFnZUMgL1RleHRdCi9FeHRHU3RhdGUg MTkgMCBSCi9YT2JqZWN0IDIwIDAgUgovRm9udCAyMSAwIFIKPj4KL0NvbnRlbnRzIDUgMCBSCj4+ CmVuZG9iagoyMiAwIG9iago8PC9UeXBlL1BhZ2UvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXQovUm90 YXRlIDAvUGFyZW50IDMgMCBSCi9SZXNvdXJjZXM8PC9Qcm9jU2V0Wy9QREYgL0ltYWdlQiAvSW1h Z2VDIC9UZXh0XQovRXh0R1N0YXRlIDI3IDAgUgovWE9iamVjdCAyOCAwIFIKL0ZvbnQgMjkgMCBS Cj4+Ci9Db250ZW50cyAyMyAwIFIKPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9L aWRzIFsKNCAwIFIKMjIgMCBSCl0gL0NvdW50IDIKL1JvdGF0ZSAwPj4KZW5kb2JqCjEgMCBvYmoK PDwvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMyAwIFIKPj4KZW5kb2JqCjcgMCBvYmoKPDwvVHlwZS9F eHRHU3RhdGUKL09QTSAxPj5lbmRvYmoKMTkgMCBvYmoKPDwvUjcKNyAwIFI+PgplbmRvYmoKMjAg MCBvYmoKPDwvUjEwCjEwIDAgUj4+CmVuZG9iagoxMCAwIG9iago8PC9TdWJ0eXBlL0ltYWdlCi9D b2xvclNwYWNlL0RldmljZVJHQgovV2lkdGggMTM2Ci9IZWlnaHQgNjAKL0JpdHNQZXJDb21wb25l bnQgOAovRmlsdGVyL0RDVERlY29kZS9MZW5ndGggNDcwMD4+c3RyZWFtCv/Y/+4ADkFkb2JlAGQA AAAAAf/bAEMABAMDBAMDBAQDBAUEBAUGCgcGBgYGDAkJBwoPDQ8PDg0ODhASFxQQERYRDg4UGxQW GBkaGhoQExweHBkeFxkaGf/bAEMBBAUFBgUGDAcHDBkRDhEZGRkZGRkZGRkZGRkZGRkZGRkZGRkZ GRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGf/AABEIADwAiAMBEQACEQEDEQH/xAAfAAABBQEB AQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYT UWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZX WFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPE xcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/xAAfAQADAQEBAQEBAQEBAAAAAAAA AQIDBAUGBwgJCgv/xAC1EQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGh scEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlq c3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV 1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/AOqr92Pzst6VpV9rl6lnpFu9zcP0 UdFHqx7CuTE4ilhafPVlZG9OjKrLliev+HvgbEsaS+JL13lP3oLbAA9i55NfD4rief8AzDR08z3q OUw/5enZRfCfwlEu3+yVk/2mlfP6GvGlnmZP/l4d6y/DL7JT1H4O+Fr1MQW0ti3ZoZT/ACbNbUs/ x8N5XInluHkeYeLvhJqvh2J7rT2/tSyXk7V/ep9V7j6V9XgOIKGKlyVfdkeLictlS+HVHnq47V9Y eUWdMigm1GzhuwxhlmVH8vhsE4yM/WuTEznClKUN0XTj7x7fN8FvD1qoNxqlzCD0MkiD+dfAriXG y+Gmj6T+y8MQ/wDCofC3/Qdk/wC/8dX/AKw5h/z5/AX9m4b+Yqaj8C4ZYDL4f1fc/wDCJVBU/iK1 pcTz5v39MynlP8sjyPVNNudEvpbPU4GhmgP7xP8AA9Poa+1oYiGKpe1pHh1Kfspcsj2jTfgvoWpa fa3gur5BPGsoUsvGRnFfB1eI8XSqSjpofRU8toSjzHjWs2X9maxf2flvH9nmZNsn3sA8fmK+7wdb 6xQjU7nztaHJLlKFdxgeq+AfhjYeK9BXUL+S7tmMzImxhtcD+IfjkV8PmueVsDifZ07M97CYCNen zSMP4k+EdN8G3dhaWElzNLOhkZ5GGAoOMV6OTZjWzCMpTtZHNjsPHC/Cclpem3GsX9tYWKb57h9q Dt9T7CvcxFeOHpSqz2R59OHtZcp9ReDvCNl4R04W1ooed+Z5u7t/h6V+RY/MKuOq88tuh9ph8NHD w5UdMOleedYUAUdT1GLS9Pur64OIbeMu34VdGm69SMI7smcuWPMeNRfHm584mbRk8g/dUSkMPrxi vuJcLRcf4mp89/bH905fXbOy8V6TceJdDgWzvLc/8TWxTouekqe3rXq4SpVwFaODr6p/A/0OOty4 qPt47rdHI6Z/yFbD/r5i/wDQxXu1/wCFL0Z59L4/me1/HohdD0rdx/pZ/wDQDXwPDH+8y9D6PNv4 cTwjen95f++q/R/ePlzuPhadZ/4Suy/ss3P2Mv8A6V18vy8H73avmc8WF+qS57c3Q9XAe09pHkvY 3fj0kK63YMn+ua1bzPpu+WuPhVy9jK/c6c2/iRO71LxEfC3hLwpfEfuGmt4px6xtE+fy6185SwX1 /GYil1s/zR6TrewoU5eZyHxq8OLm18SWA3xTAR3LL06fI/49K9jhrG8vNhKnTY4M1of8v4nluk6b PrWq2enWn+uuJAg/2R3P4DmvssTXjh6UqstkeHTh7WXKfQsmpwaJ4k8MeE9K+WOKMvNj+6EO0H6n mvzFUJV8JWx1T5H1vPGlUp0InB/Hj/kYdJ/682/9Dr6bhb/d6nqeXm/xR9C78CtBWSXUNamX5l/0 eA+meW/wrk4oxMvdwy9TXKaOntD28DFfDn0ItADJGVFLPwo5JoA+ffF/ip9fa81YmWbw/tFpbWMs xjE02Ms+Fzu29etff4DA+wcaG1X4r+XY+XxGJ9r732ex5gP8mvuDwzovBGrDR/ElrJLza3P+i3SH o8T8EH6HmvGzTD/WMNLutV6o7sLU9lVIrzSzonjFtPP/AC76iiKfVd42n/vnFa0a6xOB9qusf0In D2Vfl8z6L8beJtJ8NWdtNrtobuKaTYgESvtbGehr8ty/BV8dUlGhK1j63E4inQjeZxn/AAtjwZ/0 BH/8Aov8a+i/sHM/+fn/AJMzzf7Rwv8AL+BWvPjjYW8BTRNHbP8ACJGCL+S1VLhivKV61QmWbRj/ AA4nkWvazeeIb641DVH8y4kX8FH91fYV9rhMLTwdP2VPY8KpUlVlzSPXviX/AMkt8Pf9dbf/ANEv XxmS/wDI1rej/NHuY3/cYk/w01ODxh4QvPDGrHdLbxeWD3MR+631BrDOqE8uxscXS2b/ABLwNT61 Q9jIqfDXwr/wisut654gTy/7O3wxE+g+8w+owBWuc4/+0PZYah9oWBw31eUqkuhzXgXWJtf+Kltq dx965kmYD+6uw7V/AV62ZYaOFyiVGPSxw4Wp7XG8xpfHj/kYdI/682/9Drm4W/3ep6mucfFH0Ot+ D17b2fhnT7Js+dez3Mi+nybd2fzrxOIIOeMlU6JI78tl+65e7Z6Nf39vptnNd3siw28K7nduwr5m nCVWXJHc9eT5Tn9N+I/hnVfLFtqsKSyY2xy5RsnoCDXo1srxtD4qZzRxdGX2jo7loxA/2gqIth3k 9MV50VLm93c6W/dPkHULySYpbeZvtbTesAC4GC2S2PU1+00qSXv9ZbnwlSX2ehTrsRkCnmokuYDt /HGP+FhWzH5Wmaykf/eISvnsr/5Fsv8At89HFf7z9x33x6P/ABJNJ/6/D/6Aa+c4X/3mXoerm38O J4VX6OfLhQAyT/VH/dpge3fEoj/hVvhz/rtb/wDop6/P8l/5G9b0f5o+lxv+5RPLfCWvyeGNes9R i+4j4mX1iP3h/Wvq8wwscbhpUev6ni4et9Xqcx6h8Z/Fsb6ZZaRp0quL1Rcykd4v4R+J5r5LhzL5 e1lXq/Z0+Z7WZ4j3OSPU4f4UnHj3Sv8Atp/6Aa+h4g/3CR52A/3mJ0fx5/5GHSf+vRv/AEOvL4V/ 3ep6nVnC96JleGdWmtfBq3th8134f1QXTIOrwSja2faujHYeM8f7OW1WNvmiKM5ew937DNX4keIb jxxeW2neFPN1GyjgE1xHb8jcf7/0FcmUYWnl0JVcXZNuyuXjqksV/C2seUkfMQw5FfbL4Tw7HRP4 rvr3QotGv7mW6gS4Vk7uiDqobOTn0IrxP7Op0sT7elo7HZ9aqSp+ykVf7J+0Wc0mmWupXBimx5hg xGYjwucchs+9b+35Z+/KKuu5Hs+aPu3Idbtns76SOaKKznjPlyW0ef3ZUY7+tb4Spz0k07ruTWhy SGaLp76vrFlYQ8tcTrGPxPJ/Ac08VW+r0JVZdETRXtZcsTb8W6yZfHV/qFls/c3ISAuodfk+UcHj +HNedgcMv7OjSqdV+Z04mp/tPMbXiW68Ta5Hd6XquradqU9opmktY1i8xNoyxHyjoPSvPwccBhuW rSpyjfS+p14l4mr7mlzgre1nvBIbWNpBDGZJCn8CDgk/nX09SrCl8fU8iMeYirczLD2N3FZw3r2z raSybY5ivyO45K89a5Pb0pz9lze8b8koe/0OjuvFXibxRps1jL/ptlbp5jxx2kf7lBxu4XIxnrXl RwWBwFX2u035vU6XXr4qPJ2OYktpoIYZ5Y2SG4BMMh+7IAcEj6GvZhVhObh1RwuJpw+HNc1K3juo bC5uLcptjl9VHGBk9BXF9dwdGXs+azN/Z1Zx5h/hi51nT9T3+G03agqkf6pHYfTcKnHRwlWl/tHw /MuhOpSl7hd8Y6n4mvzAPGEeyRM+V5kEaN7jKjNc+WYfA0uaWDNMVUryl+8KvhHXU0LVt12vm6dd xm2vYv78TdwPUdRW+ZYP61Q9341t6kYat7KXkyzrdpqfg957CxvX/snUQJIp4mwtzH1X5h3HcVhh Z0cx/e1I/vIdOw6ilhfh2Zy9e7E4z0r4KRWEvie5+2IrXK2xNtu6Dn5z9cYr5DiZ1o4ePLtc9jK+ X2nvH0FH5ez91t2g44xj9K/OZf3j6hHifxU0C01jxUi6dLHbXMVmZtTuJP8AV28a/dZsd8dv92vt 8jxdXDYT39Ve0F3Z89j6Malb3N92Urp9I8H6XDqum2rQahJam10/zVxLJnhrpk/h9FFbQeKzCpKh V1hfml/8h/mKfs8LHmjvb+meXA8hv9oZzX3DPDOo8SeM73U9R1D+z7mSCyuOAnlqjlCOVYjJ5+te Dgssp06VPn+JHZXxMpS90oeHL+0sG1NNQeWGK8sHtw8UQcqxZSONw/u+tdOOpVZqnKnq4yTMqE4w 5ubqjOvYbSJ0FjdPcqfvNJB5RU/7u5v51106lWcLzjb+vkYyUTrbzxVo91o1zof2WeOxW2RbWfq3 nJ827ZnC7mJzjtXhU8vxMa/1jmXPfVeR6H1inKn7LoYnh/X5NBi1FrWR4r6eFBAwXIyJUY7s9iqk V6WMwn1yUFL4U/0Zy06vsuYn8Ua5ZazDpP8AZtr9iMMcnnwj7nmO247eTx7VlgMJWwvtPayve33I vEVo1Yx5Ylv+19HvfD2mafdMsM9pHIjyNpa3DDe+QVfzFK/lWP1bEwxNSrDZ2+3b8LGntqc48vby OUjKJOn8UayA/gDXty5pROBfF8zS8Sahb6t4h1K/sgywXUxdA64OMd65cBQnh8NGE90aV589XmMy vQMDo9C8UR2lm+la9a/2nokhz5W7Etux/jjY9D7V42LwHPP29CXJU/B+p30cT9mrqi1J4GGpBpvB mowazb9rd5BFdp/slTwT9K54Zp7LTGR5H33iW8JzfwNV+Jj3HhbXbVts2iakD/16Of5A16KzDCT2 qR+85vq9aP2WbvhnRvG2mTCbRra+0+3z+8aVvIix33b+B9cV5WOxGV1Vy1bSf3/kdmHp4uPw3SL8 2o6T4Yu729uLr+3tZuD81pHOz2kZzkCR8DzcH2xXPCjiMdCNLl9nTXW2vyXQ0lOnQlzfHL1OI1TV LzWr2S+1Wb7Rcy/eY9MdlA7ACvo8PhqeFp+zpaI8upUlVl7xRk+6/wDu12IyPWtWOl/2smq3AiS7 0YxwfY/+fln2+S2PYk7v92vhKDxPsvY/ZqX17d/+Ae9P2fNzdjiPGEQHjbWI1C4+2kY7dR2r6HL3 /sFP0PPxMf35F4nsoLDxbqNnbR+XapdlI0Gcbc9PWqwU5VcFCcvisRWhGNflOr8V6No9tYeITYWl tusJo4o0tIJUmtiT96Ri5DoRxkDrXiYHFYl1aPPJ+93as/Tsd2Ip0uWXkYXhW0sH0vXLrVFtv9HE OyW5ikmSPc2D8qMpOfrXo5lKt7WlCk3rfbQ5sNGPLLmt8yHxhp1pYeJvskMX2O2KReY+07XJGWlj Bydh7DNa5dWq1cNzP3nr/wAM/MMRTjGv2R0Nzo8P2rWLe70eCy0O1t3a11JN24kf6pvMJw5Y9Riv Ip15xhTdOo3Ub1j+ehvyR+Hl905/wdbWM8etTarHA622nmVXnieVUbegyUVgT19a9PM5VISpQpN6 y2Whz4VRlzddA8aafa6ffWQso40WazjkaaFWW3nJ/iiBJIHqCetXldapVhLn6N+q9RYqEY/D2Ocr 3DhCgoE4OV+U+3FTYDVtvEutW67LfVr6JP7q3Lgfzrhlg8LU+KnF/I2Var/Myre6le6h/wAf15cX P/XSVm/nW9PDUaK9yKRLqSqfEVK6TEKACgB2Cx3MzE/Wo5UVcbkvlm5J6mnYGI7F2Jc7iepPWiKQ Mk55+Zvm+9z9760uVDuR7j8y54PUUWEG4vt3HOPlH0quRAx5d2iwXbaOi7jj8qj2cR87GKxXOD16 1VhASWCg9B0oA//ZCmVuZHN0cmVhbQplbmRvYmoKMjEgMCBvYmoKPDwvUjE4CjE4IDAgUi9SMTIK MTIgMCBSL1IxNAoxNCAwIFIvUjE2CjE2IDAgUi9SOQo5IDAgUj4+CmVuZG9iagoyNyAwIG9iago8 PC9SNwo3IDAgUj4+CmVuZG9iagoyOCAwIG9iago8PC9SMTAKMTAgMCBSPj4KZW5kb2JqCjI5IDAg b2JqCjw8L1IxMgoxMiAwIFIvUjE0CjE0IDAgUi9SMjYKMjYgMCBSL1I5CjkgMCBSPj4KZW5kb2Jq CjMwIDAgb2JqCjw8L1N1YnR5cGUvVHlwZTFDL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMzEg MCBSPj5zdHJlYW0KeJxlVmlUU9cWviHkcp2iEKMES5IWRUDFgvoUxacMAg6VSUAZpCBhkEAiBEKU MBYFDgiIjA3zKCigiCLWCtQZa7FO1Mpb+tQuVrva2mntSw9t370gdng/knXGvc/+9vftfTmEvh7B 4XAWuMnkiTJV1L6QFY4KeZh7qDzqQIKM3VlOL+LQb+nRplyEFb+ajWt4psQO3Xdz0Gwumq1f99as L4zgG0NomwvZ8wguh5NUVO2kUGrioiIiVVILHy8/y2XLlv+5YmNnZycN1UzvSJ1l8VERsVJzZpAo kyuUMbJY1QapE3NaLo/aJ42Qa5SR8dKQsDBZGHvNN0Qui5a6RMmjlEpFotTCyVJq++67NiuYP9ud UTGhCfFS75DYeOkOKRuGdKsqhLHytw2CIKQOmth9ijClLNxjS1yES3yklyrKO2FroloekhQTKl1u TRDvEP6EO+FMeBBbCE/ChXAlbAhzwptwI5YSu4itxCrCh9hGrCZ8CSvCj9hNvEc4EnuInYQTwSHm EHOJtxlUCX1iI5FJDHM2cao5f+gF6n3BlXIPcc9xv9dP1z/L28orI53IQvKigZ9BnUGfwSglomyp H2dYzaie8cdMvZlLZ9pDG388HNWCERjSW2s4dCssFVbhpTxYQVqNx/CwAzmx7LcYdvoEmNVSMBRi TxKsoZPHp/uxArjjFHOtiO4SYr8J0wjalIetyUcTXXnJPK/gCJfUwyg/TazCnPLsktxaJDqPzhSd KD2nq6vrvA2/jhsZ82lAtfQRxkY8WHHBhTVkMNHFAyl5G67oRvs/voNEF5uUASk52iMJEjf8Kbs1 Ar8XVOdXoSrRl56XbR18lNt9xFWj7JNUoA+vgMsZATMu/RK+Eh5tyDuOSlDPwW55m+x0kM4NrUAO 0X47PLaE4BloOdpT5d8e2Rk6qH6AQIi+fdQDJhQ2IeXO+5U+iHKPPTXcX36t4aKk5VpX0yA6iRpT yxOLk/NT88Io5u3T7kbBDKpZlzb0BeFiZBPsYR+wQ74UraEw/+lGMAbivz1Pboj7brV/j55RMG/t I2wqTsD6whtngpz9tb7xIRK5d5Dcj/EY1vs5CB79/FIyZd62ll7NOFldY/QYzBYKkmjLBQwAsJLN jpTchctUAyGNrki0HtkF+W32d461QXaUoBcbfWb3053+xv4L4nDaSDhwKngLNnLAxL98o3rvwZyH oPcf1kE8Y/oH0I+tMaIzWPNdcJvNgJTEa37LZZG+Dh217j2Ku0gEa5gw7CBIIhgGgduXb7t5x3gE iYGrYozvdcECxvga38jez8DoAeg9k7zOhekYzGTwGWLwyWLxuQuJwrLeoh50Gl042KfojOj1bHBE G9EGeaD/drcgJiVLKTzv2VowhDmvhoA7KMZiUi0LjgtAlJesa/A4Kj7aIoGMMSFWksfbi6vKdQ3t 3dXdqAO1HixXHEvOT0PRFB+eMaxaNfbNTxx6I90kXEeW9Re1VlY0IlEJKsxtzq772Tgk/2CeBlki 3xC1tXab8SZSbc0bIa0n3Niwx2g33ijJH1/JaCOTeYsCDDn012DJhVNQLgR38jG62tB/ZeBKx1M0 gi6r+kLbIlpCS90QhW+QeCUrGStylBYKL4CCB9bkQGd0YGxaWHKiJD4y6pAvoljTjF1P5mfH2IaP 4I4QfiCbwJCHfyA7wI5H88lmZjbROGWP7pmaSkg+LZqSzN/UcgO6daMfnx1FokpUkluVfQLeMc7M O4yOoO1oe0igY/0vrNZw7MufJynLprwJzK3ZpI/QNYwhzTqe4MVNZegJj0Wb0GaZ71ZP53Csh6wo rPdgw6ub3dXXhsSHHLXbPPY6IpFgxD+8rlWSV8bDi8mc1Nw0lIlkTbKz6k7N+cybCNYj4Nxrhvkw ix40FrzAJxYLP+kMcMD8TWa2ftHnhmHuQ+CNSibVDxemQTjPgnBvMk58fxIE+H0q6uNvQP1T40Yg AEtYBBZSMF0oGKOf0HrCgipG7aXUy02D2MjeLVH2vvh9mcIL7UHeZ8Oexz6OMxa8uqUuz1CZRL+v 2hkpL65IEmvLskpz6ylsSmYn52ahDLS3NfB83BlVX/pNRMG/gRiF+dfDzqxrlCxr2V2pLUE1ovaO 2n6xYGzwpDo6K/dITsZUHOPO01UsbjxGOPXeqSr2pP/yEBL1NSn92SqW+P9V7LFn/2pnb8UOX/FV aOBNleRaBhUvMDSij8FKPAMs3MFyoeAFg1GPEDaTgrErLZrw1OyUjAiJ4FWSywfhB0xQan56URIF q8ii5pSSwyWoQoSK8krySyjBWD3MLexoNEGnDzT76fqbmnQNjZTgxZnuxlufMIuHziibo9v3VXgi amLOG6if07bCbvDigT15AdVnVSdXpBQfRElIkSrXqA/EylP3IFZptNsYh7ZlVLaRbIMlbFWS4yU8 F1ZPw+QW/DRbm6NFKaJd3fL7JxuOFreIa77V5mQylBGpkksqC/PLCnSSm9DH+4LkQ9sks2EjQ+6H rwvRa36zFY+dK7EhO2X0o4L5dCHMN3oEFo4METLAEhNgvlBwfzyELhAWteRXoBoKCOshvMpqU/we L7GXf+Rm5IzWXQqGWfHfqo0FY19pWtWBJm5uwWbv+p28Uph3PO+4GJuT2ercdKRFvjVBnfsvBg8n foOAj8Y6rt7p6Wu+jz5FI7suL6nBnDpjwf0V1coPT5sMfdL91dO+WJ/DuRm5GeI3Pe05Qwb69AIw oLtYWFzx5wfX+/ltQ6I9B5o+qmACr5fchS/ZrQ0Ts48k5WiQRrThqt/zBwPNQwPiZFfeJCCTvNJn o7f6qwpe14AfF8AAa96CxLsnJDG0hB0+YDDjj1e/7qwRv3Dp3xaAjj22hMRrJ/hMccGLDfCqCf5h ms8udrEgLyZhPT2vcGLen37h9ynUp9k8pb6pnmR0iSnqR+Adtik16ITJuqxyVMkQ7lh+8S3oNy6o yq9EZahV06Gqjm7yL9uCsA1a76XACyhYSOoG22qGEPVxXUpMojZBnS5RpyHklO6ZYRyQGa6VJ/jK 9u9E7khWJWuNZ9pZYuOp9HOLrqKP6q8PZCejw+gDSpCE0vOzCtMo5uMEz4UYoaDXThMQ5LooIE53 sq/r5O1SyaXiD4+W5B/LK8gTleYfzSs7Rr3BjV4JzUJIh2oetmeu47W7YS07BC6uxlrczJIe5oL9 NWzPDvm/zpm6N14AFlxw+kvhHYaRyru9564i0elGVWRqbnpOmsQBfze9da/37C0k6qpVR6TmJGdr JU547LX2i1oZhjLa9+uzcfWJ89ol1l4KaH8PbUOBcR7bdE+M/9n/6SwW617Yz6REkDSdkbJBnqDX t+5c3J1FzGeZGTixRcNl9G1X3zifvZJBKOMN4l62RTsyxZft/2yLNnw42aKZrz9oU9dwvgZzoRyb 856RKa4RYe+lpXobg96H169Ug14rmBpPsoEDOcwphoLsQZaBqnq6i1VqQD0JvJmwZBbwKmbPJoj/ AVo2rroKZW5kc3RyZWFtCmVuZG9iagozMSAwIG9iagoyNjE1CmVuZG9iagozMiAwIG9iago8PC9T dWJ0eXBlL1R5cGUxQy9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDMzIDAgUj4+c3RyZWFtCnic XVZ3XBPZ9p8ImYw0F+IAwprEAgoCYkUsqyIQQMGCWHARkJYoIQhIsyxlrRdX14YrSABBmiUuiCio 4Ko8USlWXEGfz7d2n4isZ3g3+z7vTtjye78/Jrlz55Zzvud7vucIKMNBlEAgGOITFZsclaSMCHf2 UMdG8lNOnK2A+3IQN9wAYfW/5f2bhcOpBfmvTJGJATIxPP7lkA4LTmQOlUMg/QvKQCBI3ZU7Tx2f lqCMUSTJxgYtWe4wbpzTXzMT3N3dZWvS/vgi84xKVMbEyezJIDkqVh2viopLmiGbR1bHxiojZDGx afGKRFl4ZGRUJL9tWXhs1DqZtzJWGR+vTpaNnecgm+jqOsGZ/EwMUKrWbEiUBYbHJcoWyHj7/2eG oiiXBXPT4iL8PdSRK+fFRy2MXuSVEOOdqFiSpAz02bA0OSglNjxVtUbm5OziOnHOlGkU5UyNpIKp hZQn5UKNohZRXtR0ajS1mPKmXCk5NYGypwIpH2oMtZTypSZRQZQfNZlyoJZRU6jl1FRqBeVPeVAr qQBqHiWgTCkzaghlTompEZQlNYwaTxCnDMkFq6hi6heBmyBR8HKQ66A9gxoNJAYbDf5u6Gv4rWGz 4WfhJKFW+DMdTdeIvhKliI4yFsw8ZitTztweLB7sNzhicL/ReKN9Rh+N+oy/NHY1nmd81URqam6q MtVBpRkHCMy5Lo3gMTgaQHq/isWOv6m47WCOP9Jm/dGoECzIAl+NgNsJY9h6PEYILjTe268S4uk0 zv1NJQRnugHI9CYwZ/ES+g2cEZpxjVjd2/8F2SXhtCw21A3HxtxwIXahIUR3XbhLtEO0IioyOCM7 Z2+aZKSocEfurnx0Cp3dd+zgj3n5xcU3IaFfbM1bV8g5g3GcxqIFZBAKMitxXQs5Uaclr50icefN urNtzRVr50vwMzLzHxEY+7ZhkUdw/MIIibjukYhYkgRC+BcIBSdBZsAVwAs2E6wn/YxtEYOnOI/A C7D3q1EwGaxedAF7WIpt6DQvdXwQYjzDbvZdOlifXyXNq6jMq0ZX0fH4PE/GrP8+Kuz31AhugyPn wqMWy91iwUp3SwiONLDcLaHuFjj2q3CyCA/VdWJrrlOIk35Tka88oGAOi8njDuYW3eAIRTAKm8Fo K3FftyV00U/RT3nntOe0ZTfQNXQ38qp7/d3zZWfRDXQxoXHN6TDtirxZxO5HNDhicxbcaDHXro0L WhYd5y3FbjQ2NwQ5Le67d2atf0DUWg8pltMExD8QOEUg2kdQgCbuPIvd7bEAe2HvHkzBdJjWCwKY C/PHfsazpDlYyHZe9B5hv9xrzuwVHb29lzoeSvUHDXYu5MbDYJissSgnp2XwEdnEOViCjDgsw7m0 ounrEh9iIuuAv8BuHkVzTy+XihuWa28rb9u2ogslpxoZbMSZsncueI92WCX38lrV/q8P9R0dUrP+ 8QO4EkgcDTg3KGZhIxcqxDNpLMUPsAM8EOIZNGzTkblicBQRMJPAgtsHQwXnyI7+r7hkdlvLlurY msD7E2qwgBixBg/FY3AG3gJiPIbQxxdM+2DGASm2p7NcFi1zIUsY+WuYBFPuvAWjy7VpijJpXsr+ 1AORDPE2kfj5EgYT8l37w9U6COb5LPttF5k5RZ9cWK9uQwxYvgUzmPZww8OYi1Jx56UYn5N+tnK0 Kk65kAEj9YCvwd7eXqvaenrq24mvhJWfYeQrGPJZwBVCMpuTi/aifagp++KWMzHvJ1/XWz/eCRti Xzz39QhwBtP37b9WSrGETg+LTFiBItC6/JSKLZptx3ZeYna/Yg90n6q5QTKoKl2jPpzyffJ30YSo BUkwlNtL8KkmVLXnUbXpT2PtkJvS38fPK9oOkWuwQDv6lneLvHvtJ/QJdZ9oaWtp/fFX1IuAjv7o 1zG/fXrVSMTk4KEsDHk0Bk/EDtPtsQk2ndFDjHJ+3AOmUjN4RtJ00qs3nwS/8Oy6zZWy0xrpstwf SnPzdu3MlfSJ1u9W5KQixmV1qKvUb7bLQ50PyDifJyJ90CGb5IMazAUPST4c5DMqGQ6zsJAGm2dv YCzYT3uMnQgF9CnEsYZkrUz0WKuYMzdaMUPPm79ySvAzvz8NWln4yGsYuHOmYK47RjTtLPmXknQY RowdBtIBTbESa//Uk2qRuL27pqb7yMFdOwokMFKUnbMNbUfzUWC4yoMRa38lagI47pc+wosXel4Q SYEtMMxK3MU5kVOmicTvboaHlPnb4qHjsDmegWc+x4YwrOVMwfXLUg+RX/Bqr2WKopoMCbajc8Lz 4k6rahXN6U8Ig9xe3wOxlJxzhZyBv8cU23HZY4zDCh8P35DW9x/P32mT6tUQzv/u533ezyTez7vE z7tk7j/EvwMDMsOL3iDog0EW9cRCP7DF5ryrPdxubhC7E+hJ7diOEGz4VG9sEHMotiBZWpCan3U5 HWYstxa/OpWRm7HBZm1kil9M3L7cNMmmQ1sPbS0ny+k92Ogf/jANPUBX86qrqquOXUSNqENR51mI vS5ZR+Zm7kdFTEWVpkEi7mlFJxJzgpk/NZxIhqCVWLOMUKSV1BliKS/hN+rOtVQcy9iQJ8lN27MZ KRj8RC/kqDWtProytnT1kdXIG61URy5iQCMaqEiFBIMlRD9JzYI8cMJDwcFKzEE6nGVhDn2rbH3A VpS5a4t0VypKQxlIvmdDgYKBKcfppMNZR1DVdli3/aBLdXdVzXX0T3QtpVFxeu3JkDx/xOhsBzg2 0ZCc7yuqRUe3H93EiPuObjqQoLRBikx1+qaNm1O2hSGGkJ7zeSV4MiCnpewssCP6Z+ft0o7/Tk+t C39ZWfLd/hLJe9Hmndm7MhETnXWoXgoXSEWCSgLIds1NEsRWfneEXlF4BtL9KkNyCIkVqRTjk8CE aIOJoA5GQROMMuA+cXtY1LrpXEx1cNP0cpKVeJ69Ox6JhVeXwli19GPKh1StGi0aFhAY7Wq3pPbR NgnRuQPY9fNUCCAUWwQGz0k2iRY3Y9tSKaaLZIWxhahx2JWGU51vGiPm7pUMoNtC0P1eI2gj4J7l NWMPPGXxU31FG4dLcQ2U8i0C+fpUpC8JxuN4d/QaqS/QqdwZS05L/HghEtfNXx0uX6iquiWBD8RH ExE2vi0H0b2G483VEnHqfNEAPR4TLOAb/jKW62FBSZjcRWBYr+sZYLMeMAH0WkIApxXisTQW6KR4 MCflx7BYpxXqi8FQrkejF5FK/qgcQjJdlmjS6nBn59Vnn0u4LOxI3pF70eKG0MZVneufo+eos7Sx vuFc0TXUzXBZhF4FA1dx/ZbgzF9lR7vrzKZzZkIs40dT+JEdDU7kShhNP+PMu3TmQn1I+dI1EE++ iZLx9B5IROEEIo4gtCgjAC2E4TxAhflsQvG3R1AZA40iGDTnJ2yP7Wf7Y/MsCdjS+34qPtqOmKbj aTFpWRs3ZUtTMxHyzgjMtJalLV+KHFHI4aiSeEZct67yQmq9bTO6UtpwiRGnIvV3mYc3MuBE41mg YsV10yNCPL+OK6k+W6S5liupP6Dd9/3uvP3D/gIUoIQFTyjki+xk7DYJ3PgReOJC7INLhDCTfgkz X+CZ/Mjs36Z/NmPNxJU5A4+VuKH5/zRkXbdPVzdfKI8Pk2CdfuZ/3jkLUd/8G5iSr0oMDJesvxRU 7oP8UURyyFJG3NAq+v8dxvU/O4zrvwsGUceGZScvJLTZAvsehoDbvQ33Yy5Loxt9T/oiH7QqQRnE QK4IjPBFtr3Ba4xDsJe359dtve/1VZf0u1CZohHcBHsW2z/bIULyeMWib5hAUc3eskPHC6srf9Ci RwwMJ0n6DCLAVgCX4A2LS7AtlNB8lMFeAGv53Y7Y/g+hNeEOkd6K74Yi+fCX9ivY2chvXdiiNUtT XREejrB5/sQTQWd92qOeoE7UUnmuubpJ8xKBNQLLjc+VV8LbvLXTSDYLDU+j8pT86B9U+2eRKM/M npGp3hiuSopA0UhdkH56c0X2A/QaPdnfdbA8r7biWDVRIRJK0p6nAU1qvA2E8C3uAb4Pb6SPninS fHoIQ3453YTeEp+cn2MHPGbKZOy4FWXnZEjAppj+WXv+5o0zYZ6zEmKxKzaQYBP36AXfYiuGSybx jsCSR8B0QcsdcOwUHH8HNu849E+DfmtuL7vRP/GisigQDZMjb8XqwJAl6tnIh3G6N/vFlZ/KLvwo 2Z+wP1OzuSS9MusEakbNFfVNV1qOt6Mn6LPi6ez7U7uxoBZbIPwlwkbB450muS7FlggzDMLGV7Dw 7Zwnfm9VICbO3vuho0p9z3rx+q82zUOuaEq5z+VZf4t4ij6gD2d6bj24++RtLTDoPepSdfjfXlQl RzPR4rQla0OYtaHhagViVKkFFbkI7a+QPoITQpwYwF6uilywYr1PdJg0Ua1IjUPMysgLzR8f9TyS DkQTjoFBH9Ej0jcQMDf3r2R1Q+gFOqkQLOgjp6oKahFzp3bFlGmhK7wClJVXd/A92W78xWs3kBCR dfr0ifRFdhM+YKuvFd/ErpEWw1ghnP+dKbD5DQQQKSgCGWYIfWPAlPwTgvdyzpwle+zwoX2HDjLi d+XH82vP24DBuC5sha3HTceG8rKwm0qJuNc9VBnkZoNtel3AAcb2vgKbp8om93MSbAMbWPG7G7VR S4NCIwP8Q3+80lR7pkW6E59kxb3ttSFz5aGr5fKwuo675863Ss2SijmtBmZpVhXTYGQEI4zB6ICJ CYw4aGJKUf8Fsz7mTAplbmRzdHJlYW0KZW5kb2JqCjMzIDAgb2JqCjM1NDkKZW5kb2JqCjM0IDAg b2JqCjw8L1N1YnR5cGUvVHlwZTFDL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMzUgMCBSPj5z dHJlYW0KeJxVVwlYE9f2nxAyMyJLJW9ARZMIKovIbl0QUHYwyCYoCEUUBJRNQLaCdeuiV6v1aaXW CqIC2qqIohZQEetGVaRFS8AgELBBbbVP+86kN3z/dxP6+v79vvkyd27mnnvP7/zO75wRUIYGlEAg MApOzSxMLchYk6x7cuStBPwUA36qsARn/zFHUyKaSskPPzNBxkJkbFg9xXyWOe89AZrNoPgdSigQ FO8+5JeTW5KXkZZeILOLiVpuP2uW4/9mXOfPny9bXfLff2T+qfkZadmymWRQmJqZk5uVml3gKfMj b2dmZqyRpWWW5Kbny5JTUlJTdMtikzNT18sCMzIzcnNzCmV2fvYyNxcX19nkx21pRtbqjfmy6OTs fJlcFpWatjEzOe9vkxRFLZYvLsleE5aTErfULzc13H/D2oi8tMD89Kiggozo4I3rloUUro8JLcpM Ls5avdzeQeY4bbaTs4ur2z47jznvzv18ga0PRc2mrKl4Kpzyp5yoCCqAWkA5U9OpSCqQcqFmUFFU EOVKRVPBlC21jAqh3Ck7KoYKpTwoeyqWWkLNoRyo5ZScepeaRa2gwihfKo5aSvlR8ygjajwloEwo A8qUMqPeoSZQ5pSYYqlxFEdZUJbURCqHsqLSKRnlSwJFGVISssGXVK/AVpAgOGpAGTgbxBu0Cq2E pcJHhmLDdYbHDUdEDqIWUT+9hEb0H0w2U8vcZqPZcvYy+9s4s3EzxgWPKxvXMk5j5Gjka9Q7fsL4 zPE3xmuN3Y1XGa8x/tj4jHGrcafxC5NFJikmt02em04zjTGtN5tmFmaWZPa+2RdmGjhlyrcipYap FPSqhbBYk8U5jWbxcUqspU01zqgK4hW8S6WAz4Yc7jHOEb2h8X5Nlggb07hiNEv0K90NOSL4p4LD ZTQYQ7/IlP8EZys1/yBrJvJVHJ6hdcSTeUeRGw0B2ur18zatLS5PR5M+QOW7S/awi5jDWw9/fBTV oLr9R788ceTQ0S8boVxjOlF3rCo+siu90ryz2/spfNpnKb7QSQyKv9FWPYVGRtz17xudA/cb18gl +P/6eBkzGHpjpldclm+iRHxBxZBjFHTzjt2CU4NCfj285j6+uvmborq0FnmdL2LxNGdsiH2x17AM rGFCz2P4xwHpXLp87qpkf8Q6L3sM74DldcWzzkurfQ9ITTWPUJXGv1LwWMXvUwn5dAtI5kGkBZUm C3MMTh81w5kaMxHmRrNUPNCwRgsEh9axA5wdhNZBIRznz3LY1s0a+2N/lTXYg+3wW1gEIR5v8Czp Lm9u5IY3tsBmkV7OTlHdIAbz7xRqqc6IYlkVL1eAd6X5iUG4RmAo47eRMM3Dx+j01ujaAOLNFDcs wJ5ScQsOGMQCmPbjlZp7lyXissBHDC7lk7nh7zzxBN3fJpGe7s5Ln4ApmN558kyij7DOMWhSC3lL aOCghg8XYSGNUzDgdQAizNBwWkvmGtSMqWbt2Os/qXiJSqiZTI7hrlXT2gm8WjRT57uK5k20KtFb wp21BUr+pVLQrBZqHHjEZYOHswJ7IHu0MDMmPMQvzQZhI4SN66c/9L8R+WPucwSB6NWLoxDDzqK3 xW3JKMvOCg/L8CLezXAGFkIhXAUMTLvVVpJzUlqTdyjz8xhWDw/voCAkua4jydVBS/E313E29xRO 0JdiWvI7EAtWQyAAAk4X+M8BAyz1j1oflkI40uPNiO9BqZz7+fYCPAGPX7rAxT2yF8zA7GavSo98 NwR3gEe34MKAkD8AmzjU+2FzWUPGgOc1e3KsmbMJhRbhRc+mgS0Y93UAXUUoVBCYkBaMYtF7x3Iu FZ3cfnLnNXZ3B7fv5a32p4hVtgfN2YF27NxBKHVkDJ9zav4QwX6SpoTDqdgaO+FiXAzkDmtVPTVX bkl7HjSBCMF4Fj7AUpiN10nmG4Lbb9gYy7G/Nbk5YWcbknnBEPyG3Jykuigp+btKwZCan6IWDlnA aRrkIAIJFEEhNgQJDpPi07R61Irj78IiBqb/5ICXYrmPPZ4u/X+Q/km3bn4bQVR8WVO6OIARd7el RJwMtMISVywiCeQ9YA2SrisnvmuQ4lMMnqnx5IYI2cyx8V9MM7mj/FlqCqdIOgd1gFWXQNUnhM9J Jnso6TOVX53b9ynaeUTykCnes3lXKWK9E5MWSd0Cgjq1CX18wiAzpkIXlLBfKXimhqGXQuLMXQ5K 6O/Q5cMNZy6dP9KEHrAwdUE3ni7B10ez1DRvZQj7IZYZal3p6Rm70o1sP0C291URrx4SoliK6x/q pKROJyXHGfT4SMv5Olb88MSR45/d3MX2M+W7t+/ajGLQ6vUrvVhx/XMiJ604uxMm6DKaGKkbhAvE yhPehZjxYcQv7yavqAu2wpNcMYu951QHXIyTNiTd2NCG7qNva5vus7kM8t+6qjB7Y+aqkhUoFWUc KPiq+NC2Lz46xb5L77frjgAzpEAPjp9uPN986D4CM5YYDyWGcXEYN9zqgy3xhBgfd5dlemm4oRgi gQKCy/dKKFcKhol0L4F+Dl4r8Wso52VKbbkOh79EsGkQthIdDOVNuZ3/CrqJTQh/TRfKHeY3psA7 WVJF8c3y6kKUOik+fp3ve6kVRwslmw59eOijetad3oNNOiJhKkmkiU/vvVYkXbQ5LvU8EvRl9lFU P6n54qmOB2ezl+2W/KnXP4JPpaCzj8i1sJOow2hWH5FqnVDX1Gwtq5QcKz2Qh9ayY4KtkrfNWPxe wZJ4CZwc0xb4Vgl7lOZqNeDhBS8txW9hKTzgYDvdV7/GVSrmd4ai9/6ZVJE1CUTVdPqx7Sd2vNwJ xsVnF55mxW+V57+52jcZzBc+xDYSPKTngcwQ9sBG5ho6ua266HhhxTqUxM5JSrGT6PNPXgUNSqhR ml9S85uURFg1cTzH4e/mQ14RTdTSYtZsPGlxcE3TKsnKa9mDaJiFoN/ACJxA2Bs1u1LynN4Adtiw H3siN+RXEJUwN2AlFiFsyeICmIpdIO7XnvqeH4gQVzuIbtEkBwq6eIcOQT9JgH2EOHNg+jw83T/o B62Mjj2bda+ycvfeWkkns/mTTTvfR2zalgP1UsADjCnkEWyLKiGsUvCArHUga+dpq/poTZbhXOun ukJNxOS1wrxZFaKGX1RBal3WqvmD3E6wse/DC0m0Pezm44luTdEv8qQQslIkHvo5v3Ft1GSUUrgm c2N2UeLmCLQQxRxJb8z9+oMzuy6TwO8KrkiqW3Ml6GkaCNEg+qGy6WxLw6l7qB0NR9+3q8FLWiaK u92Pra+9MfnRvZZfgL0X67hLMhZHQsvmSkHfCG9EtK2ZMBP3qzVZTrhDOx46SIMxAv26lCroitP5 ZX6vD/YQpSnmCy34qnn4CiO+LIsO8AhJPt8u4Zl5WjvG4170b90tNQ9bJOJiXx0gOPuRZooekU5C NQKI9iWzvLR0xScI7SqV+DMHduzdWYHYkZZzP0g1JgwkG86z7qP1SaOhlQL4gqTMvzVWHGxTah/O h+2jVmpaL1K6+vZqRAixhL6zyUl1SaRHXwDnLCCRrxLNprGd1gvLeC8yBLm2SvTfV3THuUkCNE1X n3XcX0U/6YUAXC/6F02q6QtSxUJEMhrn4TyRvkJqJJWCfrUepRayRrufsfcPx+NikiqOp0vSakvr URvL73ci89jud2dYDD5gMAIzJfx+fYOj0FhXCg4/hw3EmQHd+gMMivxwXWleSU5G6VrEBqQ09Uub HJcw2EixCCaAuKcHzCX8pbFs0/nEX7UAJ71PNlrH6aRNm0Hbah1lZOBMgyNxbYR+zTv/rnUW6Umo A6fjqRAcyWZzR7MI9UgQOwO6eJdu88ZBqNAH8esWUi12bP0YfWSV/f6hE1K4w6iDrmDOR74xJV2S n7sla8dy9im97/tzdQrEPm7MiZNuZFB6YVnINmxUVvLx+k1L8zITUBArLna8H/77/dbq67ckn8We yL+ODqOK3TX7SO2FIA7lbCvNK8jIXP1+PGJDU0+1ttXXDlVIVQe/2lNbwf4vapfhGAf+8JkubuY4 CptDlMiRBj98AIfhStFzGiZBIljiRNFLWt/p/dl1PoVc3WUpbtHTi1QKJSN+8lPbnY67Z1KDJXhU N6F7vHM2JUT3yE9lRmKu2QckF0bESzJvJB8LQgEoccN7clbc8oj5eyt3vQ+ukWal7LpeJB8/YMQt S8+3ZndZgWSYlGpf8J7zFkv8VuRGpEihjoGZuIpTj/UpYX/vU/7wHwuLpswCwkhnbkPjydohvIAf EtnS+F0ynEqGNjSEk3b9Nxrm8i9gofYFieeAJo7A4/dEqMbp3CuwbIdQBK4I3OQQaguW7DJahW1a iHqQtg27x2Mvd2xNcJ2kX+ZBDr4XG047VxwBVFag25W0dvVdp6tnA4aAOll8a1rqXjAke5wiF7Y9 N1QpGHwrHHzD2dwuYVDgpqKEHWwq03nm8oAUjJm/8g7eIdxK0Te3z+ijOF/UQB+FfBE+bzjXhnAN BmD7jwKoh3sc3uoHW/UJ+0Yw+EYI0cS0zRvdRFGVZgWxVEKs4C2jW0RtNGzRbNG34128QiG4OAz1 w0Ko1cRxISg8e218YliBo16zt/ViMTiCg5KU2HKQbPw54XvJ2isRtcGI9TJ83jSLcCcxcba9U8Iv EAuxTc+fS/VFT0M+j+CgSggH+d2cdrdKExfJZGJBURmeUsrKdXFHg3xjt4CfPyzkPx3ktOPo/Te/ rh+8+ur6xF+vX+0i2norvy35XPK55V8FI1cUvD4lPC91c9IOP1ZFf9r8Wd3B6uqL355oRWzv7Sif 6HUr5WlS5+XYbu6q4G3YZRKfSbzeoIvJ92rh98Rrm2ZmV2R5bvpHBOHbe7/5FvWyr5k/o931RAib yTu22FKOQxF2RditHYe+Iu630e5gEw8LEXggcG8BLxXook0cBPseXk587CU+9oI3h71V4P22x5pf Fcrgx9ookRMD13o4nEdDHrTrkVbAoAKcBwW8J/E5l0CtNaBjtRaiJ/SFltOH2xD7/Hao9YyIsFne CQ29hVJ3+mDkgZyqDedjfszsJZ2Gzas34AAypxd4StyaTVmrpbUQL4Jmesz0HUVf1YBCcGkILhLr H5HkLAXW5yGmkBcKSE2WJwUWEcJyCI//yqdRfi7qbqZC9xnw8hVIYaKrGosDluUuT5XugsU3XrxG d9HFlC+CWJJZc7j+1ghHt/DQBfPDOp6pbt8ZHAsw/wtx5LDOiWwPXkxjL/xhILaLxeXsCN0ARUOw HDwgQ4eVjp78TUJPbbsf3z5GT3j4RgAGhKLrxijKVxmOMTVaE1ApaB4RNhPLWMjU4Mmi83QNTBaB kBkjloVC0N2vGB4idO2DlVwTgy59frij/XHH8cvoPgvj5j0mX4zTF3liJ0k/jb7dW3vw2JH681WE Kd1XE4MSN6bEJkgjYhEqLSjM2V6A0thlzLAj52ozTJsWVPNVunIlr6YVRn3jFXuNjfv3G5tQ1H8A Pb8X8AplbmRzdHJlYW0KZW5kb2JqCjM1IDAgb2JqCjQxMDIKZW5kb2JqCjM2IDAgb2JqCjw8L1N1 YnR5cGUvVHlwZTFDL0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggMzcgMCBSPj5zdHJlYW0KeJxj ZGBhYmBkZORwzi8tykwtArF1f0gz/pBh+iHL3N39I+6HGqssg4NJHm8PD2M3D3M3D8uC7/OFvtcK fq/i/14uwMDMyFjRO8s5v6CyKDM9o0RBIzQoXFNbWwchYmhpaamQVAmTUXBJLc5Mz1NQAzLKUnPy C3JT80qsFZyBqnNyMpMV0nMqCzKKFRJTUlJTQNrCEnNSsxXcMnMyCwryyxQ0nDUVjAwMDHWBhJFf Zm5SabGCb35evoKPQlBqemlOYhGKIAMDA+NUBoYSBiZGRhbZH2/4frz5/v6Hmqh3RKSvz76Ikyf3 7Tt5ImK/vzxf+fwfpvO/C82fP59tG9cW7m08PFt4eBkYAHzlYREKZW5kc3RyZWFtCmVuZG9iagoz NyAwIG9iagoyNjkKZW5kb2JqCjM4IDAgb2JqCjw8L1N1YnR5cGUvVHlwZTFDL0ZpbHRlci9GbGF0 ZURlY29kZS9MZW5ndGggMzkgMCBSPj5zdHJlYW0KeJyNkc1qU0EUx2eSqKBp/QBXtvS4KH4QLrgQ abuSikEINTSU0p2Te89NBiYzw8wJ7S24dXPFjbuI1rcQX8CXSN8huOp059yEGpfuzsz//M/vfHDW qDHO+Y1eMeobVYVJeMDDWi2s1csyJGFybZ11vn1ZCetNVjbrZbPxOfy6F77fDV9vh8kdVq/8p/wj /3mwfwg9k9OxcNiCXWMLJwdDgmdbWy+gX0DUE+ghAg0RcqkQdt92j97steFxe+8A2qjRCQXdcV/J FDoyRe3xCeTGgVo8IDU6kySN9gm89CDAW0xlNOFJirYSWmDRjaT3MQbpYeCEJsyADEidqnFW4eN/ bjSBdSbqo6jEUl3jyadOWoJI7L56veiRhoIqrpdRBpPHzMyk4xFG/5VGQmoPhCdUcfoImfRWiSJy Yynr5LyFsZd6sKS3wOFAuEyhn9ettrKcD/6ZWlirirnXzLP+8iV5VHnSI6GzWAkWR/TQWS7/P47C GOM/GCNW47zx8OLTangXPpzxi/dhcn9ze+fR5nR7NptOf892zp9urF4+P7te3ixvMfYHKavJGApl bmRzdHJlYW0KZW5kb2JqCjM5IDAgb2JqCjQyNAplbmRvYmoKNDAgMCBvYmoKPDwvU3VidHlwZS9U eXBlMUMvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0MSAwIFI+PnN0cmVhbQp4nGVPTUsCURR9 z7GEGi2DaFHCXYWmgkqbwaXSSgzEbP1sXuOj994M82HMX2igTbgU27q0bYs2rew3BPor3ixzgmoR XA73nHPPhYNROoUwxnqfCepVe7YgMuFn8TGOT1JxQYsitVCTrQLqTLVspGuRnn5W6wP1nldve+p1 H2kYLz4+W7YTuswa+VC86l2XyuXKn1I3DAOG4Y8DbeoxS8LpZhlTbjuCSr8Jrc015+wGLB46Iw+I aVIziQ0Ip3dwwThzHHsMxVYJGrVavbqBRhO6gaCuXQEmb5lkfghEmnApqEVAEJMmD9qC+W4I5zUm f9NdJoaBB9+FoWsb0IEetQJO3P8OQigFVYQwyiVt05kj9ZhLZq0GS/yiJocd9bDM5O5n8WCm+rPt +c5qd/6k66upnkXoC4VOdagKZW5kc3RyZWFtCmVuZG9iago0MSAwIG9iagozMTIKZW5kb2JqCjE4 IDAgb2JqCjw8L0Jhc2VGb250L1JNU05TTStIZWx2ZXRpY2EtQm9sZE9ibGlxdWUvRm9udERlc2Ny aXB0b3IgMTcgMCBSL1R5cGUvRm9udAovRmlyc3RDaGFyIDMyL0xhc3RDaGFyIDEyMS9XaWR0aHNb CjI3OCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMjc4IDAgMjc4IDAKMCAwIDAgMCAwIDAgMCAwIDAg MCAwIDAgMCAwIDAgMAowIDcyMiAwIDAgMCA2NjcgNjExIDAgMCAyNzggMCAwIDAgMCAwIDAKNjY3 IDAgNzIyIDY2NyAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMAowIDU1NiA2MTEgNTU2IDYxMSA1NTYg MzMzIDYxMSA2MTEgMjc4IDAgMCAyNzggODg5IDYxMSA2MTEKNjExIDAgMzg5IDU1NiAzMzMgNjEx IDU1NiA3NzggNTU2IDU1Nl0KL0VuY29kaW5nL1dpbkFuc2lFbmNvZGluZy9TdWJ0eXBlL1R5cGUx Pj4KZW5kb2JqCjEyIDAgb2JqCjw8L0Jhc2VGb250L1pJQ1hFRCtIZWx2ZXRpY2EtQm9sZC9Gb250 RGVzY3JpcHRvciAxMSAwIFIvVHlwZS9Gb250Ci9GaXJzdENoYXIgMzIvTGFzdENoYXIgMTIxL1dp ZHRoc1sKMjc4IDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAyNzggMzMzIDI3OCAwCjU1NiAwIDU1NiAw IDAgNTU2IDAgMCA1NTYgMCAwIDAgMCAwIDAgMAo5NzUgNzIyIDcyMiA3MjIgMCA2NjcgNjExIDAg NzIyIDAgMCAwIDYxMSA4MzMgMCA3NzgKNjY3IDAgNzIyIDY2NyA2MTEgNzIyIDAgMCAwIDY2NyAw IDAgMCAwIDAgMAowIDU1NiA2MTEgNTU2IDYxMSA1NTYgMzMzIDYxMSA2MTEgMjc4IDAgMCAyNzgg ODg5IDYxMSA2MTEKNjExIDAgMzg5IDU1NiAzMzMgNjExIDU1NiA3NzggNTU2IDU1Nl0KL0VuY29k aW5nL1dpbkFuc2lFbmNvZGluZy9TdWJ0eXBlL1R5cGUxPj4KZW5kb2JqCjE0IDAgb2JqCjw8L0Jh c2VGb250L1hBUE5MRitIZWx2ZXRpY2EvRm9udERlc2NyaXB0b3IgMTMgMCBSL1R5cGUvRm9udAov Rmlyc3RDaGFyIDMyL0xhc3RDaGFyIDE1MC9XaWR0aHNbCjI3OCAyNzggMCAwIDAgMCAwIDE5MSAz MzMgMzMzIDM4OSAwIDI3OCAzMzMgMjc4IDI3OAo1NTYgNTU2IDU1NiAwIDU1NiA1NTYgNTU2IDU1 NiAwIDAgMjc4IDAgMCAwIDAgNTU2CjAgNjY3IDAgNzIyIDcyMiAwIDYxMSA3NzggNzIyIDI3OCA1 MDAgMCA1NTYgODMzIDcyMiA3NzgKNjY3IDAgNzIyIDY2NyA2MTEgNzIyIDAgOTQ0IDAgNjY3IDAg MCAwIDAgMCAwCjAgNTU2IDU1NiA1MDAgNTU2IDU1NiAyNzggNTU2IDU1NiAyMjIgMjIyIDUwMCAy MjIgODMzIDU1NiA1NTYKNTU2IDU1NiAzMzMgNTAwIDI3OCA1NTYgNTAwIDcyMiA1MDAgNTAwIDAg MCAwIDAgMCAwCjAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAKMCAwIDIyMSAwIDAgMCA1 NTZdCi9FbmNvZGluZy9XaW5BbnNpRW5jb2RpbmcvU3VidHlwZS9UeXBlMT4+CmVuZG9iagoxNiAw IG9iago8PC9CYXNlRm9udC9HRk9DSkYrQ291cmllci9Gb250RGVzY3JpcHRvciAxNSAwIFIvVHlw ZS9Gb250Ci9GaXJzdENoYXIgMTQ5L0xhc3RDaGFyIDE0OS9XaWR0aHNbIDYwMF0KL0VuY29kaW5n L1dpbkFuc2lFbmNvZGluZy9TdWJ0eXBlL1R5cGUxPj4KZW5kb2JqCjI2IDAgb2JqCjw8L0Jhc2VG b250L01XVU5JUCtTeW1ib2wvRm9udERlc2NyaXB0b3IgMjUgMCBSL1R5cGUvRm9udAovRmlyc3RD aGFyIDE4My9MYXN0Q2hhciAxODMvV2lkdGhzWyA0NjBdCi9FbmNvZGluZyA0MiAwIFIvU3VidHlw ZS9UeXBlMT4+CmVuZG9iago0MiAwIG9iago8PC9UeXBlL0VuY29kaW5nL0Jhc2VFbmNvZGluZy9X aW5BbnNpRW5jb2RpbmcvRGlmZmVyZW5jZXNbCjE4My9idWxsZXRdPj4KZW5kb2JqCjkgMCBvYmoK PDwvQmFzZUZvbnQvT1hIU0pTK1RpbWVzLVJvbWFuL0ZvbnREZXNjcmlwdG9yIDggMCBSL1R5cGUv Rm9udAovRmlyc3RDaGFyIDMyL0xhc3RDaGFyIDQ1L1dpZHRoc1sKMjUwIDAgMCAwIDAgMCAwIDAg MCAwIDAgMCAwIDMzM10KL0VuY29kaW5nL1dpbkFuc2lFbmNvZGluZy9TdWJ0eXBlL1R5cGUxPj4K ZW5kb2JqCjE3IDAgb2JqCjw8L1R5cGUvRm9udERlc2NyaXB0b3IvRm9udE5hbWUvUk1TTlNNK0hl bHZldGljYS1Cb2xkT2JsaXF1ZS9Gb250QkJveFswIC0yMTkgOTExIDc0MV0vRmxhZ3MgNAovQXNj ZW50IDc0MQovQ2FwSGVpZ2h0IDc0MQovRGVzY2VudCAtMjE5Ci9JdGFsaWNBbmdsZSAwCi9TdGVt ViAxMzYKL01pc3NpbmdXaWR0aCAyNzgKL0NoYXJTZXQoL0EveS9uL2Mvby9kL3AvZS9mL1AvRS9y L2cvRi9zL2gvUi90L2kvUy91L0kvdi93L2wvYS94L20vYi9zcGFjZS9jb21tYS9wZXJpb2QpL0Zv bnRGaWxlMyAzMCAwIFI+PgplbmRvYmoKMTEgMCBvYmoKPDwvVHlwZS9Gb250RGVzY3JpcHRvci9G b250TmFtZS9aSUNYRUQrSGVsdmV0aWNhLUJvbGQvRm9udEJCb3hbMCAtMjE5IDk0NyA3NDVdL0Zs YWdzIDQKL0FzY2VudCA3NDUKL0NhcEhlaWdodCA3NDUKL0Rlc2NlbnQgLTIxOQovSXRhbGljQW5n bGUgMAovU3RlbVYgMTQyCi9NaXNzaW5nV2lkdGggMjc4Ci9DaGFyU2V0KC9ML0EveS9uL2MvYXQv Zml2ZS9NL0Ivby9kL1kvQy9wL2UvTy9mL2VpZ2h0L1AvRS9yL2cvRi9zL2gvUi90L2kvUy9IL3Uv VC92L1Uvdy9sL2EveC9tL2Ivc3BhY2UvY29tbWEvaHlwaGVuL3BlcmlvZC96ZXJvL3R3bykvRm9u dEZpbGUzIDMyIDAgUj4+CmVuZG9iagoxMyAwIG9iago8PC9UeXBlL0ZvbnREZXNjcmlwdG9yL0Zv bnROYW1lL1hBUE5MRitIZWx2ZXRpY2EvRm9udEJCb3hbLTE4IC0yMTggOTI5IDc0MV0vRmxhZ3Mg NAovQXNjZW50IDc0MQovQ2FwSGVpZ2h0IDc0MQovRGVzY2VudCAtMjE4Ci9JdGFsaWNBbmdsZSAw Ci9TdGVtViAxMzkKL01pc3NpbmdXaWR0aCAyNzgKL0NoYXJTZXQoL2ZvdXIvTC9BL3kvbi9jL2Zp dmUvTS9vL2QvWS9zaXgvTi9DL3AvZS9zZXZlbi9PL0QvcS9mL1AvZW5kYXNoL3IvZy9GL3MvaC9j b2xvbi9SL0cvdC9pL1MvSC91L2ovVC9JL3YvcXVvdGVzaW5nbGUvay9VL0ovdy9sL2EveC9tL2Iv cXVlc3Rpb24vVy9wYXJlbnJpZ2h0L2FzdGVyaXNrL3NwYWNlL2NvbW1hL2V4Y2xhbS9oeXBoZW4v cGVyaW9kL3NsYXNoL3plcm8vb25lL3R3by9xdW90ZXJpZ2h0L3BhcmVubGVmdCkvRm9udEZpbGUz IDM0IDAgUj4+CmVuZG9iagoxNSAwIG9iago8PC9UeXBlL0ZvbnREZXNjcmlwdG9yL0ZvbnROYW1l L0dGT0NKRitDb3VyaWVyL0ZvbnRCQm94WzAgMCA0NTggNDAyXS9GbGFncyA1Ci9Bc2NlbnQgNDAy Ci9DYXBIZWlnaHQgNDAyCi9EZXNjZW50IDAKL0l0YWxpY0FuZ2xlIDAKL1N0ZW1WIDY4Ci9BdmdX aWR0aCA2MDAKL01heFdpZHRoIDYwMAovTWlzc2luZ1dpZHRoIDYwMAovQ2hhclNldCgvYnVsbGV0 KS9Gb250RmlsZTMgMzYgMCBSPj4KZW5kb2JqCjI1IDAgb2JqCjw8L1R5cGUvRm9udERlc2NyaXB0 b3IvRm9udE5hbWUvTVdVTklQK1N5bWJvbC9Gb250QkJveFswIDAgNDEwIDUxOF0vRmxhZ3MgNAov QXNjZW50IDUxOAovQ2FwSGVpZ2h0IDUxOAovRGVzY2VudCAwCi9JdGFsaWNBbmdsZSAwCi9TdGVt ViA2MQovTWlzc2luZ1dpZHRoIDI1MAovQ2hhclNldCgvYnVsbGV0KS9Gb250RmlsZTMgMzggMCBS Pj4KZW5kb2JqCjggMCBvYmoKPDwvVHlwZS9Gb250RGVzY3JpcHRvci9Gb250TmFtZS9PWEhTSlMr VGltZXMtUm9tYW4vRm9udEJCb3hbMCAwIDI4NSAyNTddL0ZsYWdzIDQKL0FzY2VudCAyNTcKL0Nh cEhlaWdodCAyNTcKL0Rlc2NlbnQgMAovSXRhbGljQW5nbGUgMAovU3RlbVYgNDIKL01pc3NpbmdX aWR0aCAyNTAKL0NoYXJTZXQoL3NwYWNlL2h5cGhlbikvRm9udEZpbGUzIDQwIDAgUj4+CmVuZG9i agoyIDAgb2JqCjw8L1Byb2R1Y2VyKEdQTCBHaG9zdHNjcmlwdCA4LjE1KQovQ3JlYXRpb25EYXRl KEQ6MjAwNTA5MDkxODAwMTMpCi9Nb2REYXRlKEQ6MjAwNTA5MDkxODAwMTMpCi9UaXRsZShNaWNy b3NvZnQgV29yZCAtIFBsYW5ldCBNaXJyb3IgLSBtaXJyb3JpbmcuZG9jKQovQ3JlYXRvcihQU2Ny aXB0NS5kbGwgVmVyc2lvbiA1LjIpCi9BdXRob3IobWNiZXRoKT4+ZW5kb2JqCnhyZWYKMCA0Mwow MDAwMDAwMDAwIDY1NTM1IGYgCjAwMDAwMDc5NzIgMDAwMDAgbiAKMDAwMDAyODc4NyAwMDAwMCBu IAowMDAwMDA3ODk3IDAwMDAwIG4gCjAwMDAwMDc1MTEgMDAwMDAgbiAKMDAwMDAwMDAxNSAwMDAw MCBuIAowMDAwMDAzNjE5IDAwMDAwIG4gCjAwMDAwMDgwMjAgMDAwMDAgbiAKMDAwMDAyODU2NyAw MDAwMCBuIAowMDAwMDI2ODM5IDAwMDAwIG4gCjAwMDAwMDgxMjMgMDAwMDAgbiAKMDAwMDAyNzMy NyAwMDAwMCBuIAowMDAwMDI1NDg5IDAwMDAwIG4gCjAwMDAwMjc2NjggMDAwMDAgbiAKMDAwMDAy NTkyMSAwMDAwMCBuIAowMDAwMDI4MTE4IDAwMDAwIG4gCjAwMDAwMjY0NDQgMDAwMDAgbiAKMDAw MDAyNzAyNSAwMDAwMCBuIAowMDAwMDI1MDc4IDAwMDAwIG4gCjAwMDAwMDgwNjEgMDAwMDAgbiAK MDAwMDAwODA5MSAwMDAwMCBuIAowMDAwMDEyOTY5IDAwMDAwIG4gCjAwMDAwMDc3MDMgMDAwMDAg biAKMDAwMDAwMzYzOSAwMDAwMCBuIAowMDAwMDA3NDkwIDAwMDAwIG4gCjAwMDAwMjgzNTcgMDAw MDAgbiAKMDAwMDAyNjYwMiAwMDAwMCBuIAowMDAwMDEzMDQzIDAwMDAwIG4gCjAwMDAwMTMwNzMg MDAwMDAgbiAKMDAwMDAxMzEwNSAwMDAwMCBuIAowMDAwMDEzMTY4IDAwMDAwIG4gCjAwMDAwMTU4 NjkgMDAwMDAgbiAKMDAwMDAxNTg5MCAwMDAwMCBuIAowMDAwMDE5NTI1IDAwMDAwIG4gCjAwMDAw MTk1NDYgMDAwMDAgbiAKMDAwMDAyMzczNCAwMDAwMCBuIAowMDAwMDIzNzU1IDAwMDAwIG4gCjAw MDAwMjQxMTAgMDAwMDAgbiAKMDAwMDAyNDEzMCAwMDAwMCBuIAowMDAwMDI0NjQwIDAwMDAwIG4g CjAwMDAwMjQ2NjAgMDAwMDAgbiAKMDAwMDAyNTA1OCAwMDAwMCBuIAowMDAwMDI2NzUwIDAwMDAw IG4gCnRyYWlsZXIKPDwgL1NpemUgNDMgL1Jvb3QgMSAwIFIgL0luZm8gMiAwIFIKL0lEIFsoIye6 XCmmv+IPhhzE7vpzSFxcKSgjJ7pcKaa/4g+GHMTu+nNIXFwpXQo+PgpzdGFydHhyZWYKMjkwMDIK JSVFT0YK