5795 2008-06-24 12:57:56 +0000 CVS: Static Typing: K2-Steps-2, K2-FunctionProlog-14 2010-03-16 16:02:21 +0000 1 1 1 Unclassified XML Query Test Suite XML Query Test Suite unspecified PC Windows NT CLOSED WONTFIX P2 normal --- 1 tim frans.englich frans.englich jim.melton mike zhen.liu public-qt-comments oldest_to_newest 20784 0 tim 2008-06-24 12:57:56 +0000 This query can also return the empty sequence. In this context e[928] is effectively (fn:error('err:XPDY0002'))[928] which can be evaluated through type analysis to be the empty sequence. K2-FunctionProlog-14 has a similar problem. (:*******************************************************:) (: Test: K2-Steps-2 :) (: Written by: Frans Englich :) (: Date: 2007-11-22T11:31:21+01:00 :) (: Purpose: A numeric predicate combined with a name test inside a function. :) (:*******************************************************:) declare function local:myFunc() { e[928] }; local:myFunc() 20791 1 frans.englich 2008-06-24 13:45:28 +0000 But isn't this extremely counter intuitive? The user has done wrong: she's using an axis step inside a function. Instead of that it gets reported as an error, it evaluates to a perfectly valid result: an empty sequence. It's not helpful, in my opinion. What says an expression that happens to contain a dynamic error, can be rewritten to a call to fn:error? I'd say e[928] isn't effectively equal to (fn:error('err:XPDY0002'))[928] because in the latter case it has the static type none, which the former doesn't have. 20794 2 tim 2008-06-24 14:00:10 +0000 Refer to: http://www.w3.org/TR/xquery/#id-errors-and-opt "Consider an expression Q that has an operand (sub-expression) E. In general the value of E is a sequence. At an intermediate stage during evaluation of the sequence, some of its items will be known and others will be unknown. If, at such an intermediate stage of evaluation, a processor is able to establish that there are only two possible outcomes of evaluating Q, namely the value V or an error, then the processor may deliver the result V without evaluating further items in the operand E. For this purpose, two values are considered to represent the same outcome if their items are pairwise the same, where nodes are the same if they have the same identity, and values are the same if they are equal and have exactly the same type." I agree it isn't intuitive, but I'm sure it is correct. I rather wish the type of fn:error was, in Haskell style: empty-sequence() IO (indicating an expression with side effects) rather than none which I believe would help to get rid of these oddities (and clean up XQuery Update). 20836 3 frans.englich 2008-06-25 10:43:43 +0000 I can't see how that paragraph applies, I need further help with this! My understanding is that that paragraph says that an implementation can choose between delivering a sequence of items or an error, if both are the outcome of evaluating an expression. However in the case of: declare function local:myFunc() { e[928] }; local:myFunc() where does the empty sequence come from? Maybe one can infer it from the fn:error() function, but hasn't yet been clarified how that one enters the picture. I agree, the none type surely gives us a lot of trouble :} 20838 4 tim 2008-06-25 11:03:29 +0000 The context item has static type 'none' because accessing it is equivalent to calling fn:error (whose return type is none). So we can rewrite the path expression $fs:dot/e as a call to fn:error. declare function local:myFunc() { (fn:error('err:XPDY0002'))[928] }; The quantifier of fn:error is 1, so we either have a sequence of one item or an error. But we're not interested in the first item, so there's no need to evaluate it to cause an error. We want item 928 - therefore we get the result as (). 20897 5 frans.englich 2008-06-26 11:12:37 +0000 "The context item has static type 'none' because accessing it is equivalent to calling fn:error (whose return type is none). So we can rewrite the path expression $fs:dot/e as a call to fn:error." So, if an expression yields an error, it's ok to rewrite it to fn:error? So for any expression that raise an expression one can potentially rewrite to fn:error and then proceed to reduce using the type none? I don't see how that holds. I'd say that just because an expression raise an error, doesn't make it ok to rewrite to function fn:error. 20903 6 tim 2008-06-26 12:04:05 +0000 > I don't see how that holds. I'd say that just because an expression raise an > error, doesn't make it ok to rewrite to function fn:error. We only do this wtih dynamic errors. Why wouldn't this rewrite be valid? Could a user see a difference between an expression raising an error and a call to fn:error? Does anyone else have an opinion on this? 20905 7 mike 2008-06-26 12:10:47 +0000 >So, if an expression yields an error, it's ok to rewrite it to fn:error? So for any expression that raise an expression one can potentially rewrite to fn:error and then proceed to reduce using the type none? It seems to me to be perfectly reasonable to rewrite the expression as fn:error() - but not reasonable to then do type inferencing on error() and further reduction that causes the error not to be raised! Frankly, I think that we haven't formalized error behaviour to the level where such rewrites are safe. I've found that it's generally better to infer a type of item()* for expressions known to throw an error - but that's in an optimistic environment, of course. 20906 8 tim 2008-06-26 12:23:04 +0000 Consider: declare function local:something() as xs:integer { 1 } (local:something())[928] Do you think it is reasonable to return () here without evaluating the function? If we redefine the functions as: declare function local:something() as xs:integer { fn:error() } do you still think it reasonable? As I've said before, I think fn:error should have been treated in the way that exceptions are treated in Haskell, since the error is a side-effect, and the same goes for updating expressions. As I'm sure you are aware, the reason fn:error can't be treated as item()* is that static type checking would end up with type check errors all over the place. e.g. declare function local:maybe-error($arg as xs:boolean) as xs:integer { if ($arg) then fn:error() else 1 } With fn:error() as 'none', this type checks correctly. Were it item()*, the call to fn:error would cause a static type check error. 20908 9 mike 2008-06-26 12:35:18 +0000 >do you still think it reasonable? I have found it necessary to be pragmatic with error situations: the criterion for what is reasonable is based on how helpful it is to the user. Failing to report a simple error that can be detected statically, and returning an empty sequence instead, does not seem helpful. I'm well aware that treating error() as item()* doesn't work in a static typing environment, but fortunately I don't have that problem. (Well, not fortunately, it was by deliberate choice...) But of course we're dealing with a test suite here, and it's testing for conformance not for usability. Unfortunately I don't think that static typing is spec'ed well enough to ensure interoperable results especially in error situations, so I personally think this is a losing battle. There's probably a chain of reasoning that says 42 is a valid answer to the query 2+2. 20913 10 tim 2008-06-26 12:47:12 +0000 > But of course we're dealing with a test suite here, and it's testing for > conformance not for usability. You are right. So do you think it conformant behaviour? 20916 11 mike 2008-06-26 13:01:10 +0000 >So do you think it conformant behaviour? I wouldn't dare to venture an opinion. With static typing, nothing (not even a failure to report a statically detectable error) would surprise me. But I think there comes a time when a test suite has to take a pragmatic view. The rules on errors and optimization license an implementation to throw an error for the query 2+2. I don't think that means the test suite should list this as an approved result. There comes a time when you have to report that you consider your result conformant even though it's not the expected result that was published. 20917 12 frans.englich 2008-06-26 13:08:41 +0000 For what it's worth I'm not convinced this is conformant behavior, but I think we can add a static typing query that follows the line of thinking of the static typing community. Tim, could you provide a query which unconditionally raise XPDY0002 for static typing implementations? Will "node-test", without quotes, do? I'll add that as a @static-name test. 20918 13 tim 2008-06-26 13:12:15 +0000 Thanks Mike. fn:error really has caused us a lot of head scratching. On some days, I can convince myself that count(fn:error()) is 1. I don't like it. but I think it is correct. I may post a further question to clarify whether both: (1, fn:error())[1] and (fn:error(), 1)[2] can be conformantly executed without error. 20919 14 tim 2008-06-26 13:12:25 +0000 Frans - we get this result whether we use static typing or not. The result isn't really resulting from type analysis as much from the rule quoted in Comment 2. 20921 15 tim 2008-06-26 13:14:37 +0000 Is the [928] important? How about: declare function local:myFunc() { e[1] }; local:myFunc() 20926 16 frans.englich 2008-06-26 13:29:54 +0000 Added the query in comments #15 as static typing queries for the two tests in question. Feel free to verify, and close if everything looks ok. 20966 17 tim 2008-06-27 16:14:04 +0000 Frans - I've looked a little further into why we are returning empty sequence here. In K2-Steps-2, e[928] ends up being transformed into fs:item-at($fs:seq, 928) (see Bug 4841 for details of fs:item-at). The type checking rule is: statEnv |- QName of func expands to (FS-URI,"item-at") statEnv |- Expr1 : Type1 -------------------------------------------------------- statEnv |- QName(Expr1, Expr2) : prime(Type1) ? which here is fs:item-at( something of type none, 928) prime(none) = none none? = empty Therefore it is definitely correct to say that e[928] is empty sequence.. A static typing implementation would be required to raise XPST0005 here (that's an expected result), but any implementation is free to return () here. Would this persuade you to add this as a possible result? 20986 18 tim 2008-06-30 09:01:03 +0000 In Bug 5810, Michael Dyck has confirmed that fs:item-at(fn:error(), Expr) can be rewritten as the empty sequence by virtual of its static type. "I don't see how that holds. I'd say that just because an expression raise an error, doesn't make it ok to rewrite to function fn:error." This can all be proved without actually performing a rewrite to fn:error. $fs:dot has type none (because it is an error). From FS. statEnv |- axis Axis of none : none So $fs:dot/child::e is also of type none. fs:item-at( $fs:dot/child::e (of type none), 928) is empty Any expression of type empty can be rewritten as the empty sequence. 20987 19 mike 2008-06-30 09:28:35 +0000 >Any expression of type empty can be rewritten as the empty sequence. Section 4 states: During static analysis, it is a type error for an expression to have the empty type, except for the following expressions and function calls: * Empty parentheses (), which denote the empty sequence. * The fn:data function and all functions in the fs namespace applied to empty parentheses (). * Any function which returns the empty type. If this rule is to make sense at all, then it must surely be applied before doing any rewrites. You can't rewrite an expression as "()" as a way of getting around this rule. 20988 20 tim 2008-06-30 10:32:47 +0000 This is the paragraph which gives rise to XPST0005 - an error distinct to the static typing feature (2.3.1 Kinds of Errors, paragraph 7). If the static typing feature isn't in effect, an implementation isn't required to throw this error. Incidentally, many static typing implementations appear to ignore, apply selectively (e.g. only in path expressions) or allow this error to be switched off. If the static typing feature is switched off, the extent to which the static typing rules are used during query analysis is not prescribed by the standard. I'm specifically concerned here with running the tests with static typing feature switched off. The test case already correctly lists XPST0005 as a valid result. 21304 21 frans.englich 2008-07-23 11:25:26 +0000 Regarding: "fs:dot has type none (because it is an error)". Could you elaborate on how the spec backs this up? Here's how I understand it: if fs:dot has type none because it raises an error(the context is undefined), then that means XPDY0002 never appears in the cases where subsequent code starts inferring based on the none type. And can the same kind of logic be applied to other expressions? E.g 1) it's statically detected an expression will raise an error; 2) the expression's type changes to none(which I don't understand why); 3) inference goes to work and the error is not reported. 21368 22 561 tim 2008-07-29 13:05:07 +0000 Created attachment 561 Tests involving fn:error() Attached are a set of queries which I believe show how fn:error() can be optimized away through static analysis of the queries. 21369 23 tim 2008-07-29 13:27:22 +0000 > Regarding: "fs:dot has type none (because it is an error)". Could you elaborate > on how the spec backs this up? I can only state the equivalence of a dynmaic error (namely accessing an undefined context item) and a call to fn:error. This is backed up by Formal Semantics, which shows how the dynamic error raised by the "treat as" expression is normalized to a call to fn:error. [Expr treat as SequenceType]Expr == typeswitch ([ Expr ]Expr) case $fs:new as SequenceType return $fs:new default $fs:new return fn:error() 21374 24 tim 2008-07-29 15:42:41 +0000 I've just had a play with Saxon to see what it does here. For the original query: declare function local:myFunc() { e[928] }; local:myFunc() it throws an error, but it returns empty sequence for: declare function local:myFunc() { e[false()] }; local:myFunc() Regarding Comment #1, in both these queries "The user has done wrong: she's using an axis step inside a function." 21376 25 mike 2008-07-29 16:00:30 +0000 I think we're in the realms of usability rather than conformance here: it's going to be very hard to formalize the rules on error handling to ensure all products are compatible in such cases. But I think the test suite needs to make assumptions about what's reasonable: for example it can legitimately assume that the implementation's limit on the length of strings will be greater than 10, and I don't think the expected results should be changed because some implementation blows its limits. I think that the rewrite from e[928] to error()[928] to () is simply poor design from a usability point of view. Once you've decided there is an error here you should take care to ensure the user knows about it. The difference with e[false()] is that the sequence of rewrites never went via error() to something else. Yes, arguably the processor should have tried harder to check for error conditions before doing the rewrite, but it's hard to argue against doing context-independent rewrites before starting to look at the context. 21377 26 tim 2008-07-29 16:07:28 +0000 We're following the rules for static typing here, which (like it or not) make it quite clear that: e[1] is of type empty if the context item's value is undefined. This isn't really comparable to differences due to implementation limits. As an aside, I rather think the usability problem here is that this accessing of the undefined context item in a function body is considered to be a dynamic error rather than a static error. 21390 27 562 tim 2008-07-30 12:16:14 +0000 Created attachment 562 Tests involving fn:error() Attached is an updated set of 35 queries where a call to fn:error() can be optimized away through static analysis of the queries. 21391 28 tim 2008-07-30 12:34:43 +0000 "The difference with e[false()] is that the sequence of rewrites never went via error() to something else. Yes, arguably the processor should have tried harder to check for error conditions before doing the rewrite, but it's hard to argue against doing context-independent rewrites before starting to look at the context." For the query: error()[928] we normalize to: let $fs:seq_7 as item()* := fn:error() return fs:item-at($fs:seq_7, 928) We then perform static type analysis which spots that the expression has type empty. In the original query, we necessarily look at the static context to get the context item's type. Once that's done, the only (context-independent) rewrite is to replace an expression with type empty with (). I agree that it is hard for a processor to check for error conditions, since the type system does not capture a difference between a function which, say, returns an integer from one which may return an integer or raise an error. 21395 29 tim 2008-07-30 13:27:35 +0000 Other queries which can return () or raise XPST0005 are: K2-Steps-3 K2-FilterExpr-8 K-SeqRemoveFunc-13 (reported in Bug 5991) 21478 30 frans.englich 2008-08-08 10:15:06 +0000 Hi, There is unfortunately some administrative details to my W3C membership to attend to, which has as result that I can't do W3C work until end of august(and let's hope it doesn't stretch out more than that). As a result, progress on this report as well as others assigned to me/XQTS will have to wait. 23917 31 zhen.liu 2009-02-24 22:17:16 +0000 In K2-Steps-2, the query e[928] makes a reference of a context item, however, the input variable binding is $input-context, not context item, therefore, this shall result as XPDY0002 errors. Furthermore, xquery spec allows implementation to do static analysis and catch and raise such error statically. However, using static anlaysis to infer types and compute results while there are errors detected in previous steps are not very sounded and not very well defined (at least not covered by the xquery spec or formal semantic spec). So per working group discussion, we close this bug as resolved. 24000 32 jim.melton 2009-03-01 18:56:32 +0000 Based on the solution Zhen provided in comment 31, we're marking this bug RESOLVED/WONTFIX. If this resolution is satisfactory, please mark the bug CLOSED. 561 2008-07-29 13:05:07 +0000 2008-07-30 12:16:14 +0000 Tests involving fn:error() ErrorFunc.zip application/octet-stream 9979 tim UEsDBAoAAAAAAE9v/TgAAAAAAAAAAAAAAAAKAJUARXJyb3JGdW5jL1NEgAAEAQAAAAgAI/L84mNk YGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMTAwMTww4GDrC0BMN/RnkGkBhI rQKQUACxuSVAfAEMcQYRiHpGiLgQiOQWgahFFgOq288oDFfHDVfH+ABFDGj/SgYhFPsVEfYvQBcH AFVUDQAH9ROPSPUTj0iMCI9IUEsDBBQAAAAIAGVr/TiMfZzwoQAAAN8AAAAbAHwARXJyb3JGdW5j L2NiY2wtZXJyb3ItMDAxLnhxU0RnAKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH8 55/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwb qn8lgxCKfkUgGwBVVA0AB54Mj0ieDI9IDAmPSFWOuwrCQBRE+0D+YQqLTRFY06jXSrDVyh/YbG6S hc2u3DxAxH83CSjaDufMjCJcTccEW1qfs0iUXOstKEsTRThzb8XdBxcDoQ60AipDZx4IPLGgZPBk /GgGrtCy8Ec9jUMbhXBzHS7O+/7bOaOEQut9rnd5cVjzNKnYejPr9RjssgcfrfHkmhCF1cZIkyFN nmkCDDKymqXXcRH/uN+TM/EGUEsDBBQAAAAIAAts/Tj13bmbfwAAAKIAAAAbAHwARXJyb3JGdW5j L2NiY2wtZXJyb3ItMDAyLnhxU0RnAKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH8 55/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwb qn8lgxCKfkUgGwBVVA0AB9YNj0jWDY9IlwyPSE2NQQrCMBRE94XeYZYpEgjZqH8nuK0rL5DGLw0k aflNC729oaC4nXnzRhEeLjHBDz5qFplEG2NBXdsowp0XL2EuYcqEd6YDUB2S25F5Y8HA4M3F1RV+ YWTh7/S2lnESwjMk9CHG5eesKMEac9HmrO31yNuG01x2Vd2nv6PafABQSwMEFAAAAAgASWz9OO9t viV/AAAAogAAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMDMueHFTRGcArAAAAAAIAOyGKU1j ZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gM pFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHSg6PSEoOj0j+DY9ITY3LCsIw FET3hf7DLBMkEOpCvTvBra78gTReaSCPcpsW+veWguJ25pwZRXi4xATf+2hYpIix9gjSbaMIN568 hLGGkgnvTDugNJJbkXlhQc/gxcXZVX5hYOGvep3rUITwDAn3EOP029xQQmft2diT6S573jacxrqq v48DlN6aD1BLAwQUAAAACABDbP04qT8vW4AAAACjAAAAGwB8AEVycm9yRnVuYy9jYmNsLWVycm9y LTAwNC54cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fki lgW3HCMTAwMTQwIDC1haguE/ozwDSAykVgFIKIDZIhBxRoi4EANEbD+jMFyMG6p/JYMQin5FIBsA VVQNAAc+Do9IPg6PSCcOj0hNjcsKwjAURPeF/sMs00UgFEG9O8GtrvyBNF5pII96mxb694aC4nbm zBlFuNvIBDe4oFkkizbmAOraRhGuPDvxU/E5EV6JdkB1iHZD4pUFA4NXGxZb+ImRhb/Ty1LGLISH j7j5EOafs6KE3piTNkfdn/e8bThOZVPVze+/p1p9AFBLAwQUAAAACABMbP04mRSm5X8AAACjAAAA GwB8AEVycm9yRnVuYy9jYmNsLWVycm9yLTAwNS54cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBgMGCA AB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAykVgFIKIDZIhBx Roi4EANEbD+jMFyMG6p/JYMQin5FIBsAVVQNAAdPDo9ITw6PSCMOj0hNjTsKwzAQRHuD7zClVAiE miTbBdLGVS4gOxss0MdZywbfPsaQkHbmvRlF6HxiwtAP0bBIEWOtA+m2UYQbz4OEqYaSCa9MB6A0 kt+QeWVBz+DVx8VXfmJk4a96XepYhPAICfcQ4/zb3FGCs/Zs7Mm4y5G3Daepburvg99Qeq8+UEsD BBQAAAAIAIps/Th3/bbCegAAAJsAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDA2LnhxU0Rn AKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMDAxND AgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0AB8QOj0jE Do9Ieg6PSE2MvQrCQBAG+0De4SsvxcGSwp8FC8FWK1/gcq7k4H5kcwn49oaAYjvMjGHcXBKGH3y0 olrUEu3AXdsYxkUmr+FVQ8mMZ+ZNMB2SeyPLIopBIIuLs6vywCgq3/Q817Eo4x4SriHG6fdcVUZP dLC0t/1x423zdz/BrOgDUEsDBBQAAAAIAJFs/ThSJsOdewAAAJsAAAAbAHwARXJyb3JGdW5jL2Ni Y2wtZXJyb3ItMDA3LnhxU0RnAKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/Y PXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8l gxCKfkUgGwBVVA0AB9IOj0jSDo9IfQ6PSE2NOwrDMBBEe4PvMKVUCIQbJwspAmmTyheQlQ0W6BPW ssG3jzEkpJ15b0YRHi4xwY8+GhYpYqztQbptFOHGs5fwrqFkwivTASiN5DZkXlkwMnh1cXGVn5hY +KtelzoVIQwh4R5inH+bO0rorD0Z25vufOR7o3H5u2ibD1BLAwQUAAAACAC8bP048vjzln8AAACj AAAAGwB8AEVycm9yRnVuYy9jYmNsLWVycm9yLTAwOC54cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBg MGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAykVgFIKIDZ IhBxRoi4EANEbD+jMFyMG6p/JYMQin5FIBsAVVQNAAckD49IJA+PSO4Oj0hNjTsKwzAQRHuD7zCl VAiEmyTbBdImVS4gOxss0MesZINvH2FISDvzZp4iPFxkwjROwbBIFmPtGaT7ThFuXCbxS/U5Ed6J DkBpRLcj8caCkcGbC6ur/MLMwt/pda1zFsLTR9x9COX32VDC0CzGnsxwOfK+47jUXf05fIHSrfoA UEsDBBQAAAAIAMBs/ThyoFB2fgAAAKMAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDA5Lnhx U0RnAKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMD AxNDAgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0ABygP j0goD49I6g6PSE2NvQrCMBRG90Lf4RvTIRC6qHcTXHXyBdJ4pYH8lJu00Lc3KIrzd75zFOFmIxPc 5IJmkSzamBNo6DtFuHBx4pfqcyI8E70BNSDaHYk3FkwM3mxYbeUHZhb+Xs9rnbMQ7j7i6kMoP2dD CaMxR20Oevy0+o7jUnfV3L78ldr0AlBLAwQUAAAACADbbP04+msuuH4AAACiAAAAGwB8AEVycm9y RnVuYy9jYmNsLWVycm9yLTAxMC54cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBgMGCAAB8gZmQFM1lF gUTx/Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAykVgFIKIDZIhBxRoi4EANEbD+j MFyMG6p/JYMQin5FIBsAVVQNAAdeD49IXg+PSE0Pj0hNjL0KwjAURvdC3+Eb0yEQu6h3E1zr5Auk 6S0N5Edu0oJvbykort93zlGEh41McKMLmkWyaHMyoK5tFOHOxYl/VZ8TYU50AKpDtG8k3lgwMniz YbWVJyws/FVva12yEJ4+YvAhlF9zRwm9MRdtzrq/Hnvb/NVtmjDbUFjtzwdQSwMEFAAAAAgA52z9 OPwWMhN/AAAAogAAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTEueHFTRGcArAAAAAAIAOyG KU1jZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8 A0gMpFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHcg+PSHIPj0hnD49ITY2x CsIwFEX3QP7hjukQSLuobxNcdfIH0vaVBpJUXtKCf28pKK6Xc88xhIdPTBj6IVoWWcS6tgU1WhnC jcsg4VXDkglTpgMwDZJ/I/PGgp7Bm4+rrzxiZuHv9brWeRHCMyTcQ4zl59xRQufc2bqT7S7HrtXk Y+Fd7fP4V9LqA1BLAwQUAAAACADzbP04xOt6rXsAAACgAAAAGwB8AEVycm9yRnVuYy9jYmNsLWVy cm9yLTAxMi54cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ 3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAykVgFIKIDZIhBxRoi4EANEbD+jMFyMG6p/JYMQin5F IBsAVVQNAAeJD49IiQ+PSHkPj0hNjL0KwjAURvdC3+Eb0yEQs6h3E1zr5Auk8UoD+ZHbpODbWwqK 6+Gcowg3l5jgJx81ixTR5mBBQ98pwpUXL+FVQ8mEZ6ZdUAOSeyPzyoKJwauLzVV+YGbhb3ppdS5C uIeEMcS4/J6bSrDGnLQ5anveed/93YugSmO18Q9QSwMEFAAAAAgA92z9OPloDV19AAAAoAAAABsA fABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTMueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFgYDBggAAf IGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA2SIQcUaI uBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHkQ+PSJEPj0h8D49ITY2xCsIwFEX3QP7hjukQiHVQ 3ya46uQPpPFJA0kjr0nBv7cUFNfLuecYws1nJoQhJMsiRazb7UGdVoZw4TlIfNVYJsJzog0wHbJ/ Y+KFBQODF5+ar/zAyMLf67nVsQjhHjOuMaX551xRQu/c0bqD7U/brlWVxqu5yF9Hqw9QSwMEFAAA AAgASm39OK/hBSGJAAAAsQAAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTQueHFTRGcArAAA AAAIAOyGKU1jZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtY WoLhP6M8A0gMpFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHLBCPSCwQj0gC EI9ITc2xCsIwGATgvZB3uMEhHQKxCOq/Ca46+QJp/UsDaVL+JkXf3lJQXI/v7jTh7kYmdG0XDIsk MXZ/ANWq0oQrz534KfsUCX2kDegao3sj8sKClsGLC8VlfmJg4W/1UvKQhPDwI24+hPm3uVJCY+3J 2KNpzluuqj4Jdi/4+P8jnItEVQFZCusVfgBQSwMEFAAAAAgAnW39OA/Zv4qMAAAAtwAAABsAfABF cnJvckZ1bmMvY2JjbC1lcnJvci0wMTUueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFgYDBggAAfIGZk BTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA2SIQcUaIuBAD RGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHyhCPSMoQj0h8EI9ITc2xCoMwGATgXfAdbnCIQyAVStt/ E7q2U18g2l8MxER+E2nfviK0dD2+u1OEu52Y0He91ywSRZvDEVSXhSJceenFzcnFQBgC7UDVmOwb gVcWdAxerc828RMjC3+rbU5jFMLDTbg575ff5kYJjTFnbU66uex5WQxRUL1gE6oZLvy/CacsoSyA JJnVxj9QSwMEFAAAAAgAoW39OJfPrzuKAAAAsQAAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJvci0w MTYueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35IpYF txwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAbAFVU DQAHzRCPSM0Qj0iqEI9ITc29CsIwFAXgPZB3OINDOgRiB38udBBcdfIF0nqlgTSV26To21sKiuvh O+cYwtUPTOjaLloWGcW67Q5UaWUIZ546Cc8cxkR4JFqBqTD4NxLPLGgZPPtYfOY7ehb+Vk8l96MQ bmHAJcQ4/TYXSqidO1i3t/VxzbWKnLF5gZr/H+FcJGkFZClsFvgBUEsDBBQAAAAIAM5t/TgFhMbw hQAAALUAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDE3LnhxU0RnAKwAAAAACADshilNY2Rg aRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+jPANIDKRW AUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0AByQRj0gkEY9IABGPSEWNsQqDMBiE d8F3uDEOgdTF9t8KXdupLxDtiYEYy28U+vYVoXa8j+/ujODhRwq6touWqpNad2ogVVkYwY1zp+Gd w5QEfZJdMBVG/0HiSkVLcPVx8ZkvDFT+qtclD5MKnmHEPcQ4H5ubKqidO1vX2Pqy87IIPcz/YUN5 YELWhWYLjDOP8AVQSwMEFAAAAAgA8W39OE+nt2+KAAAAswAAABsAfABFcnJvckZ1bmMvY2JjbC1l cnJvci0wMTgueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3q Cd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+ RSAbAFVUDQAHZRGPSGURj0g7EY9ITc29CsJAEATgPpB3mMLiUhycaYzbCbZa+QKXuCEH9xP2LkHf 3hBQbIdvZhThbgMThn7wmkWSaHPsQE1dKcKV8yBuLi5FwhhpB6pBsG9EXlnQM3i1frGFn5hY+Fu9 LGVKQni4gJvzPv82N0pojem0Oen2vOd1lVNgHF5w8f8o2+Ly6DhjtD6z2ugHUEsDBBQAAAAIAAxu /TizsfiXhgAAALMAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDE5LnhxU0RnAKwAAAAACADs hilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+j PANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0AB5cRj0iXEY9IixGPSE2N vQ6CMBDHdxLe4T84lKFJZVFvM3HVyRcoeIRLSjHXQuTtRY3G/fdhCBc/MKFt2mBZdVTrtgdQVRaG cOLUqtyzjJHQRXoDpsLgF0SeWdEwePZh8plv6Fn5qx6n3I9KuMqAs4SQfs0VJdTO7a3b2frzKotX bcHmAYn/p+SzpE44IevEZkWfUEsDBBQAAAAIAChu/TjBH+TbgwAAAK0AAAAbAHwARXJyb3JGdW5j L2NiY2wtZXJyb3ItMDIwLnhxU0RnAKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH8 55/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwb qn8lgxCKfkUgGwBVVA0AB8sRj0jLEY9IvRGPSE2NuwrCMBSG90Df4R/bIRC7qGcTXHXyBdJ4agO5 lJO06NsriuL+XVrC2UYmuMEFzSJZtNnsQV2jWsKRixM/V58TYUz0BtoO0T6QeGXBwODVhsVWvmJi 4a96WOqUhXDxEScfQvk1XyihN2anzVb3n1ej/uo+lWqTY+QR90I+Vb6xNOoJUEsDBBQAAAAIAFJu /TiZFJx1nAAAAOAAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDIxLnhxU0RnAKwAAAAACADs hilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+j PANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0ABxwSj0gcEo9I3hGPSE2N sQ6CMBRFdxL/4Y5lIEEW9W0mrjr5A6U+pEkp5PUV9e8lGI3zOfceQ7jYgQmudaFikVGqensAlZvC EE6cnPhJ/RgJXaRVMCUG+0LkmQUtg2cbslW+oWfh7/SYtR+FcPUDzj6E9PtcVEJT1/uq3lXNp7Up 9DVxenh1Pcx/aoGAs4nxTOSj8n2pCmuWCJXMZhVu3Nkc9As6G9JK3lBLAwQUAAAACABSbv04mRSc dZwAAADgAAAAGwB8AEVycm9yRnVuYy9jYmNsLWVycm9yLTAyMi54cVNEZwCsAAAAAAgA7IYpTWNk YGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAyk VgFIKIDZIhBxRoi4EANEbD+jMFyMG6p/JYMQin5FIBsAVVQNAAccEo9ILBKPSCwSj0hNjbEOgjAU RXcS/+GOZSBBFvVtJq46+QOlPqRJKeT1FfXvJRiN8zn3HkO42IEJrnWhYpFRqnp7AJWbwhBOnJz4 Sf0YCV2kVTAlBvtC5JkFLYNnG7JVvqFn4e/0mLUfhXD1A84+hPT7XFRCU9f7qt5Vzae1KfQ1cXp4 dT3Mf2qBgLOJ8Uzko/J9qQprlgiVzGYVbtzZHPQLOhvSSt5QSwMEFAAAAAgAsm79OKPN0ZF/AAAA oAAAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMjMueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFg YDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA 2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHzxKPSM8Sj0ixEo9IRY09C8IwFEX3Qv/D HdMhkHZR3ya46uQmDml80kA+ymta6L+3KOp6OfccRbjYyATXu6BZJIs27QHU1JUinHhy4sficyI8 E70B1SDaFYkXFvQMXmyYbeEHBhb+Xo9zGbIQrj7i7EOYfs4NJXTG7LXZ6e7TqiuOY1nVv3Fr79v+ AlBLAwQUAAAACAAIb/04bxBC6IQAAACmAAAAGwB8AEVycm9yRnVuYy9jYmNsLWVycm9yLTAyNC54 cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMT AwMTQwIDC1haguE/ozwDSAykVgFIKIDZIhBxRoi4EANEbD+jMFyMG6p/JYMQin5FIBsAVVQNAAdw E49IcBOPSEkTj0hFjbsKwkAURPtA/mHKTbGwBEG9nWCrlZ1YbOINWdhHuLsJ5O8NAbWdOWdGEe42 MKHveq9ZJIk27QHU1JUiXDn34qbiUiQMkXZANQh2ReSFBR2DF+tnW/iNkYW/6mUuYxLCwwXcnPf5 t7mhhNaYkzZH3Z73vK44TGVV/4/nYH1m1by29gNQSwECFwsKAAAAAABPb/04AAAAAAAAAAAAAAAA CgARAAAAAAAAABAA/0EAAAAARXJyb3JGdW5jL1NEBAAEAQAAVVQFAAf1E49IUEsBAhcLFAAAAAgA ZWv9OIx9nPChAAAA3wAAABsAEQAAAAAAAQAgALaBvQAAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAw MS54cVNEBACsAAAAVVQFAAeeDI9IUEsBAhcLFAAAAAgAC2z9OPXduZt/AAAAogAAABsAEQAAAAAA AQAgALaBEwIAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAwMi54cVNEBACsAAAAVVQFAAfWDY9IUEsB AhcLFAAAAAgASWz9OO9tviV/AAAAogAAABsAEQAAAAAAAQAgALaBRwMAAEVycm9yRnVuYy9jYmNs LWVycm9yLTAwMy54cVNEBACsAAAAVVQFAAdKDo9IUEsBAhcLFAAAAAgAQ2z9OKk/L1uAAAAAowAA ABsAEQAAAAAAAQAgALaBewQAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAwNC54cVNEBACsAAAAVVQF AAc+Do9IUEsBAhcLFAAAAAgATGz9OJkUpuV/AAAAowAAABsAEQAAAAAAAQAgALaBsAUAAEVycm9y RnVuYy9jYmNsLWVycm9yLTAwNS54cVNEBACsAAAAVVQFAAdPDo9IUEsBAhcLFAAAAAgAimz9OHf9 tsJ6AAAAmwAAABsAEQAAAAAAAQAgALaB5AYAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAwNi54cVNE BACsAAAAVVQFAAfEDo9IUEsBAhcLFAAAAAgAkWz9OFImw517AAAAmwAAABsAEQAAAAAAAQAgALaB EwgAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAwNy54cVNEBACsAAAAVVQFAAfSDo9IUEsBAhcLFAAA AAgAvGz9OPL485Z/AAAAowAAABsAEQAAAAAAAQAgALaBQwkAAEVycm9yRnVuYy9jYmNsLWVycm9y LTAwOC54cVNEBACsAAAAVVQFAAckD49IUEsBAhcLFAAAAAgAwGz9OHKgUHZ+AAAAowAAABsAEQAA AAAAAQAgALaBdwoAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAwOS54cVNEBACsAAAAVVQFAAcoD49I UEsBAhcLFAAAAAgA22z9OPprLrh+AAAAogAAABsAEQAAAAAAAQAgALaBqgsAAEVycm9yRnVuYy9j YmNsLWVycm9yLTAxMC54cVNEBACsAAAAVVQFAAdeD49IUEsBAhcLFAAAAAgA52z9OPwWMhN/AAAA ogAAABsAEQAAAAAAAQAgALaB3QwAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAxMS54cVNEBACsAAAA VVQFAAdyD49IUEsBAhcLFAAAAAgA82z9OMTreq17AAAAoAAAABsAEQAAAAAAAQAgALaBEQ4AAEVy cm9yRnVuYy9jYmNsLWVycm9yLTAxMi54cVNEBACsAAAAVVQFAAeJD49IUEsBAhcLFAAAAAgA92z9 OPloDV19AAAAoAAAABsAEQAAAAAAAQAgALaBQQ8AAEVycm9yRnVuYy9jYmNsLWVycm9yLTAxMy54 cVNEBACsAAAAVVQFAAeRD49IUEsBAhcLFAAAAAgASm39OK/hBSGJAAAAsQAAABsAEQAAAAAAAQAg ALaBcxAAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAxNC54cVNEBACsAAAAVVQFAAcsEI9IUEsBAhcL FAAAAAgAnW39OA/Zv4qMAAAAtwAAABsAEQAAAAAAAQAgALaBsREAAEVycm9yRnVuYy9jYmNsLWVy cm9yLTAxNS54cVNEBACsAAAAVVQFAAfKEI9IUEsBAhcLFAAAAAgAoW39OJfPrzuKAAAAsQAAABsA EQAAAAAAAQAgALaB8hIAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAxNi54cVNEBACsAAAAVVQFAAfN EI9IUEsBAhcLFAAAAAgAzm39OAWExvCFAAAAtQAAABsAEQAAAAAAAQAgALaBMRQAAEVycm9yRnVu Yy9jYmNsLWVycm9yLTAxNy54cVNEBACsAAAAVVQFAAckEY9IUEsBAhcLFAAAAAgA8W39OE+nt2+K AAAAswAAABsAEQAAAAAAAQAgALaBaxUAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAxOC54cVNEBACs AAAAVVQFAAdlEY9IUEsBAhcLFAAAAAgADG79OLOx+JeGAAAAswAAABsAEQAAAAAAAQAgALaBqhYA AEVycm9yRnVuYy9jYmNsLWVycm9yLTAxOS54cVNEBACsAAAAVVQFAAeXEY9IUEsBAhcLFAAAAAgA KG79OMEf5NuDAAAArQAAABsAEQAAAAAAAQAgALaB5RcAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAy MC54cVNEBACsAAAAVVQFAAfLEY9IUEsBAhcLFAAAAAgAUm79OJkUnHWcAAAA4AAAABsAEQAAAAAA AQAgALaBHRkAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAyMS54cVNEBACsAAAAVVQFAAccEo9IUEsB AhcLFAAAAAgAUm79OJkUnHWcAAAA4AAAABsAEQAAAAAAAQAgALaBbhoAAEVycm9yRnVuYy9jYmNs LWVycm9yLTAyMi54cVNEBACsAAAAVVQFAAccEo9IUEsBAhcLFAAAAAgAsm79OKPN0ZF/AAAAoAAA ABsAEQAAAAAAAQAgALaBvxsAAEVycm9yRnVuYy9jYmNsLWVycm9yLTAyMy54cVNEBACsAAAAVVQF AAfPEo9IUEsBAhcLFAAAAAgACG/9OG8QQuiEAAAApgAAABsAEQAAAAAAAQAgALaB8xwAAEVycm9y RnVuYy9jYmNsLWVycm9yLTAyNC54cVNEBACsAAAAVVQFAAdwE49IUEsFBgAAAAAZABkAuQgAACwe AAAAAA== 562 2008-07-30 12:16:14 +0000 2008-07-30 12:16:14 +0000 Tests involving fn:error() ErrorFunc.Zip application/octet-stream 14975 tim UEsDBAoAAAAAAChp/jgAAAAAAAAAAAAAAAAKAJUARXJyb3JGdW5jL1NEgAAEAQAAAAgAI/L84mNk YGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMTAwMTww4GDrC0BMN/RnkGkBhI rQKQUACxuSVAfAEMcQYRiHpGiLgQiOQWgahFFgOq288oDFfHDVfH+ABFDGj/SgYhFPsVEfYvQBcH AFVUDQAH7FmQSOxZkEiMCI9IUEsDBBQAAAAIAGVr/TiMfZzwoQAAAN8AAAAbAHwARXJyb3JGdW5j L2NiY2wtZXJyb3ItMDAxLnhxU0RnAKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH8 55/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwb qn8lgxCKfkUgGwBVVA0AB54Mj0ieDI9IDAmPSFWOuwrCQBRE+0D+YQqLTRFY06jXSrDVyh/YbG6S hc2u3DxAxH83CSjaDufMjCJcTccEW1qfs0iUXOstKEsTRThzb8XdBxcDoQ60AipDZx4IPLGgZPBk /GgGrtCy8Ec9jUMbhXBzHS7O+/7bOaOEQut9rnd5cVjzNKnYejPr9RjssgcfrfHkmhCF1cZIkyFN nmkCDDKymqXXcRH/uN+TM/EGUEsDBBQAAAAIAAts/Tj13bmbfwAAAKIAAAAbAHwARXJyb3JGdW5j L2NiY2wtZXJyb3ItMDAyLnhxU0RnAKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH8 55/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwb qn8lgxCKfkUgGwBVVA0AB9YNj0jWDY9IlwyPSE2NQQrCMBRE94XeYZYpEgjZqH8nuK0rL5DGLw0k aflNC729oaC4nXnzRhEeLjHBDz5qFplEG2NBXdsowp0XL2EuYcqEd6YDUB2S25F5Y8HA4M3F1RV+ YWTh7/S2lnESwjMk9CHG5eesKMEac9HmrO31yNuG01x2Vd2nv6PafABQSwMEFAAAAAgASWz9OO9t viV/AAAAogAAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMDMueHFTRGcArAAAAAAIAOyGKU1j ZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gM pFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHSg6PSEoOj0j+DY9ITY3LCsIw FET3hf7DLBMkEOpCvTvBra78gTReaSCPcpsW+veWguJ25pwZRXi4xATf+2hYpIix9gjSbaMIN568 hLGGkgnvTDugNJJbkXlhQc/gxcXZVX5hYOGvep3rUITwDAn3EOP029xQQmft2diT6S573jacxrqq v48DlN6aD1BLAwQUAAAACABDbP04qT8vW4AAAACjAAAAGwB8AEVycm9yRnVuYy9jYmNsLWVycm9y LTAwNC54cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fki lgW3HCMTAwMTQwIDC1haguE/ozwDSAykVgFIKIDZIhBxRoi4EANEbD+jMFyMG6p/JYMQin5FIBsA VVQNAAc+Do9IPg6PSCcOj0hNjcsKwjAURPeF/sMs00UgFEG9O8GtrvyBNF5pII96mxb694aC4nbm zBlFuNvIBDe4oFkkizbmAOraRhGuPDvxU/E5EV6JdkB1iHZD4pUFA4NXGxZb+ImRhb/Ty1LGLISH j7j5EOafs6KE3piTNkfdn/e8bThOZVPVze+/p1p9AFBLAwQUAAAACABMbP04mRSm5X8AAACjAAAA GwB8AEVycm9yRnVuYy9jYmNsLWVycm9yLTAwNS54cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBgMGCA AB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAykVgFIKIDZIhBx Roi4EANEbD+jMFyMG6p/JYMQin5FIBsAVVQNAAdPDo9ITw6PSCMOj0hNjTsKwzAQRHuD7zClVAiE miTbBdLGVS4gOxss0MdZywbfPsaQkHbmvRlF6HxiwtAP0bBIEWOtA+m2UYQbz4OEqYaSCa9MB6A0 kt+QeWVBz+DVx8VXfmJk4a96XepYhPAICfcQ4/zb3FGCs/Zs7Mm4y5G3Daepburvg99Qeq8+UEsD BBQAAAAIAIps/Th3/bbCegAAAJsAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDA2LnhxU0Rn AKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMDAxND AgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0AB8QOj0jE Do9Ieg6PSE2MvQrCQBAG+0De4SsvxcGSwp8FC8FWK1/gcq7k4H5kcwn49oaAYjvMjGHcXBKGH3y0 olrUEu3AXdsYxkUmr+FVQ8mMZ+ZNMB2SeyPLIopBIIuLs6vywCgq3/Q817Eo4x4SriHG6fdcVUZP dLC0t/1x423zdz/BrOgDUEsDBBQAAAAIAJFs/ThSJsOdewAAAJsAAAAbAHwARXJyb3JGdW5jL2Ni Y2wtZXJyb3ItMDA3LnhxU0RnAKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/Y PXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8l gxCKfkUgGwBVVA0AB9IOj0jSDo9IfQ6PSE2NOwrDMBBEe4PvMKVUCIQbJwspAmmTyheQlQ0W6BPW ssG3jzEkpJ15b0YRHi4xwY8+GhYpYqztQbptFOHGs5fwrqFkwivTASiN5DZkXlkwMnh1cXGVn5hY +KtelzoVIQwh4R5inH+bO0rorD0Z25vufOR7o3H5u2ibD1BLAwQUAAAACAC8bP048vjzln8AAACj AAAAGwB8AEVycm9yRnVuYy9jYmNsLWVycm9yLTAwOC54cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBg MGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAykVgFIKIDZ IhBxRoi4EANEbD+jMFyMG6p/JYMQin5FIBsAVVQNAAckD49IJA+PSO4Oj0hNjTsKwzAQRHuD7zCl VAiEmyTbBdImVS4gOxss0MesZINvH2FISDvzZp4iPFxkwjROwbBIFmPtGaT7ThFuXCbxS/U5Ed6J DkBpRLcj8caCkcGbC6ur/MLMwt/pda1zFsLTR9x9COX32VDC0CzGnsxwOfK+47jUXf05fIHSrfoA UEsDBBQAAAAIAMBs/ThyoFB2fgAAAKMAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDA5Lnhx U0RnAKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMD AxNDAgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0ABygP j0goD49I6g6PSE2NvQrCMBRG90Lf4RvTIRC6qHcTXHXyBdJ4pYH8lJu00Lc3KIrzd75zFOFmIxPc 5IJmkSzamBNo6DtFuHBx4pfqcyI8E70BNSDaHYk3FkwM3mxYbeUHZhb+Xs9rnbMQ7j7i6kMoP2dD CaMxR20Oevy0+o7jUnfV3L78ldr0AlBLAwQUAAAACADbbP04+msuuH4AAACiAAAAGwB8AEVycm9y RnVuYy9jYmNsLWVycm9yLTAxMC54cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBgMGCAAB8gZmQFM1lF gUTx/Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAykVgFIKIDZIhBxRoi4EANEbD+j MFyMG6p/JYMQin5FIBsAVVQNAAdeD49IXg+PSE0Pj0hNjL0KwjAURvdC3+Eb0yEQu6h3E1zr5Auk 6S0N5Edu0oJvbykort93zlGEh41McKMLmkWyaHMyoK5tFOHOxYl/VZ8TYU50AKpDtG8k3lgwMniz YbWVJyws/FVva12yEJ4+YvAhlF9zRwm9MRdtzrq/Hnvb/NVtmjDbUFjtzwdQSwMEFAAAAAgA52z9 OPwWMhN/AAAAogAAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTEueHFTRGcArAAAAAAIAOyG KU1jZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8 A0gMpFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHcg+PSHIPj0hnD49ITY2x CsIwFEX3QP7hjukQSLuobxNcdfIH0vaVBpJUXtKCf28pKK6Xc88xhIdPTBj6IVoWWcS6tgU1WhnC jcsg4VXDkglTpgMwDZJ/I/PGgp7Bm4+rrzxiZuHv9brWeRHCMyTcQ4zl59xRQufc2bqT7S7HrtXk Y+Fd7fP4V9LqA1BLAwQUAAAACADzbP04xOt6rXsAAACgAAAAGwB8AEVycm9yRnVuYy9jYmNsLWVy cm9yLTAxMi54cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ 3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAykVgFIKIDZIhBxRoi4EANEbD+jMFyMG6p/JYMQin5F IBsAVVQNAAeJD49IiQ+PSHkPj0hNjL0KwjAURvdC3+Eb0yEQs6h3E1zr5Auk8UoD+ZHbpODbWwqK 6+Gcowg3l5jgJx81ixTR5mBBQ98pwpUXL+FVQ8mEZ6ZdUAOSeyPzyoKJwauLzVV+YGbhb3ppdS5C uIeEMcS4/J6bSrDGnLQ5anveed/93YugSmO18Q9QSwMEFAAAAAgA92z9OPloDV19AAAAoAAAABsA fABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTMueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFgYDBggAAf IGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA2SIQcUaI uBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHkQ+PSJEPj0h8D49ITY2xCsIwFEX3QP7hjukQiHVQ 3ya46uQPpPFJA0kjr0nBv7cUFNfLuecYws1nJoQhJMsiRazb7UGdVoZw4TlIfNVYJsJzog0wHbJ/ Y+KFBQODF5+ar/zAyMLf67nVsQjhHjOuMaX551xRQu/c0bqD7U/brlWVxqu5yF9Hqw9QSwMEFAAA AAgASm39OK/hBSGJAAAAsQAAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTQueHFTRGcArAAA AAAIAOyGKU1jZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtY WoLhP6M8A0gMpFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHLBCPSCwQj0gC EI9ITc2xCsIwGATgvZB3uMEhHQKxCOq/Ca46+QJp/UsDaVL+JkXf3lJQXI/v7jTh7kYmdG0XDIsk MXZ/ANWq0oQrz534KfsUCX2kDegao3sj8sKClsGLC8VlfmJg4W/1UvKQhPDwI24+hPm3uVJCY+3J 2KNpzluuqj4Jdi/4+P8jnItEVQFZCusVfgBQSwMEFAAAAAgAnW39OA/Zv4qMAAAAtwAAABsAfABF cnJvckZ1bmMvY2JjbC1lcnJvci0wMTUueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFgYDBggAAfIGZk BTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA2SIQcUaIuBAD RGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHyhCPSMoQj0h8EI9ITc2xCoMwGATgXfAdbnCIQyAVStt/ E7q2U18g2l8MxER+E2nfviK0dD2+u1OEu52Y0He91ywSRZvDEVSXhSJceenFzcnFQBgC7UDVmOwb gVcWdAxerc828RMjC3+rbU5jFMLDTbg575ff5kYJjTFnbU66uex5WQxRUL1gE6oZLvy/CacsoSyA JJnVxj9QSwMEFAAAAAgAoW39OJfPrzuKAAAAsQAAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJvci0w MTYueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35IpYF txwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAbAFVU DQAHzRCPSM0Qj0iqEI9ITc29CsIwFAXgPZB3OINDOgRiB38udBBcdfIF0nqlgTSV26To21sKiuvh O+cYwtUPTOjaLloWGcW67Q5UaWUIZ546Cc8cxkR4JFqBqTD4NxLPLGgZPPtYfOY7ehb+Vk8l96MQ bmHAJcQ4/TYXSqidO1i3t/VxzbWKnLF5gZr/H+FcJGkFZClsFvgBUEsDBBQAAAAIAM5t/TgFhMbw hQAAALUAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDE3LnhxU0RnAKwAAAAACADshilNY2Rg aRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+jPANIDKRW AUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0AByQRj0gkEY9IABGPSEWNsQqDMBiE d8F3uDEOgdTF9t8KXdupLxDtiYEYy28U+vYVoXa8j+/ujODhRwq6touWqpNad2ogVVkYwY1zp+Gd w5QEfZJdMBVG/0HiSkVLcPVx8ZkvDFT+qtclD5MKnmHEPcQ4H5ubKqidO1vX2Pqy87IIPcz/YUN5 YELWhWYLjDOP8AVQSwMEFAAAAAgA8W39OE+nt2+KAAAAswAAABsAfABFcnJvckZ1bmMvY2JjbC1l cnJvci0wMTgueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3q Cd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+ RSAbAFVUDQAHZRGPSGURj0g7EY9ITc29CsJAEATgPpB3mMLiUhycaYzbCbZa+QKXuCEH9xP2LkHf 3hBQbIdvZhThbgMThn7wmkWSaHPsQE1dKcKV8yBuLi5FwhhpB6pBsG9EXlnQM3i1frGFn5hY+Fu9 LGVKQni4gJvzPv82N0pojem0Oen2vOd1lVNgHF5w8f8o2+Ly6DhjtD6z2ugHUEsDBBQAAAAIAAxu /TizsfiXhgAAALMAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDE5LnhxU0RnAKwAAAAACADs hilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+j PANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0AB5cRj0iXEY9IixGPSE2N vQ6CMBDHdxLe4T84lKFJZVFvM3HVyRcoeIRLSjHXQuTtRY3G/fdhCBc/MKFt2mBZdVTrtgdQVRaG cOLUqtyzjJHQRXoDpsLgF0SeWdEwePZh8plv6Fn5qx6n3I9KuMqAs4SQfs0VJdTO7a3b2frzKotX bcHmAYn/p+SzpE44IevEZkWfUEsDBBQAAAAIAChu/TjBH+TbgwAAAK0AAAAbAHwARXJyb3JGdW5j L2NiY2wtZXJyb3ItMDIwLnhxU0RnAKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH8 55/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwb qn8lgxCKfkUgGwBVVA0AB8sRj0jLEY9IvRGPSE2NuwrCMBSG90Df4R/bIRC7qGcTXHXyBdJ4agO5 lJO06NsriuL+XVrC2UYmuMEFzSJZtNnsQV2jWsKRixM/V58TYUz0BtoO0T6QeGXBwODVhsVWvmJi 4a96WOqUhXDxEScfQvk1XyihN2anzVb3n1ej/uo+lWqTY+QR90I+Vb6xNOoJUEsDBBQAAAAIAFJu /TiZFJx1nAAAAOAAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDIxLnhxU0RnAKwAAAAACADs hilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+j PANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0ABxwSj0gcEo9I3hGPSE2N sQ6CMBRFdxL/4Y5lIEEW9W0mrjr5A6U+pEkp5PUV9e8lGI3zOfceQ7jYgQmudaFikVGqensAlZvC EE6cnPhJ/RgJXaRVMCUG+0LkmQUtg2cbslW+oWfh7/SYtR+FcPUDzj6E9PtcVEJT1/uq3lXNp7Up 9DVxenh1Pcx/aoGAs4nxTOSj8n2pCmuWCJXMZhVu3Nkc9As6G9JK3lBLAwQUAAAACABSbv04mRSc dZwAAADgAAAAGwB8AEVycm9yRnVuYy9jYmNsLWVycm9yLTAyMi54cVNEZwCsAAAAAAgA7IYpTWNk YGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAyk VgFIKIDZIhBxRoi4EANEbD+jMFyMG6p/JYMQin5FIBsAVVQNAAccEo9ILBKPSCwSj0hNjbEOgjAU RXcS/+GOZSBBFvVtJq46+QOlPqRJKeT1FfXvJRiN8zn3HkO42IEJrnWhYpFRqnp7AJWbwhBOnJz4 Sf0YCV2kVTAlBvtC5JkFLYNnG7JVvqFn4e/0mLUfhXD1A84+hPT7XFRCU9f7qt5Vzae1KfQ1cXp4 dT3Mf2qBgLOJ8Uzko/J9qQprlgiVzGYVbtzZHPQLOhvSSt5QSwMEFAAAAAgAAlz+OL/FBq1/AAAA oAAAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMjMueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFg YDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA 2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAHI0OQSCNDkEixEo9IRY2xCsIwFEX3Qv/h jukQCHFQ3ya41slNHNL4pIGkKa9poX9vKajr4dxzFeHmEhN856NmkSza2AOoqStFuPLkJYwl5IHw HmgXVIPkVgy8sKBj8OLi7Aq/0LPwd3qZS5+FcA8JbYhx+jU3lWCNOWlz1Pa887riNJZV/T8e9rnx D1BLAwQUAAAACAAIb/04bxBC6IQAAACmAAAAGwB8AEVycm9yRnVuYy9jYmNsLWVycm9yLTAyNC54 cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMT AwMTQwIDC1haguE/ozwDSAykVgFIKIDZIhBxRoi4EANEbD+jMFyMG6p/JYMQin5FIBsAVVQNAAdw E49IcBOPSEkTj0hFjbsKwkAURPtA/mHKTbGwBEG9nWCrlZ1YbOINWdhHuLsJ5O8NAbWdOWdGEe42 MKHveq9ZJIk27QHU1JUiXDn34qbiUiQMkXZANQh2ReSFBR2DF+tnW/iNkYW/6mUuYxLCwwXcnPf5 t7mhhNaYkzZH3Z73vK44TGVV/4/nYH1m1by29gNQSwMEFAAAAAgAi0X+OCNexs6HAAAApQAAABsA fABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMjUueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFgYDBggAAf IGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA2SIQcUaI uBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAH1huQSNYbkEiUGI9IPYyxCoMwFEV3wX+4YzIEUqG0 fVvBtZ26lQ5RnxhIVF6i4N9XhHY999yjCE8XmdA2bTAsMomx1Rmky0IRak6t+Dn7aST0Ix2C0ohu w8grCxoGry4sLnOHgYV/1/uSh0kILx/x8CGkf3NXCZW1V2MvprodvCw4znlT6oTOr7D63buQWOnP Pn4BUEsDBBQAAAAIAGZW/jg6+/g4xgAAACEBAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDI2 LnhxU0RnAKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbcc IxMDAxNDAgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0A B5A5kEiQOZBIZhuQSE1PMW7DMAzcA+QPt0UeBKge2kZbga7J1A8oMg0LkCWDooP495WFJijAgbw7 8o7K4upmsvA3HzUxZ9amf4ftjgdl8U3Fc1gk5GQxJtsEqsPsNiS6E+NGoLuLqxMaMBHTc/VrlSmz xU+YcQkxltfNKrXojfnU5kP354Y3RiZCESfBQ7aFkMcG+ZyGsEdwEfRYmEqpA0IBzYtsf/utV8cD EEYovzJTEj1Us5o3Ch7FtuFUnc/avNU6dd2urx7p33M7RLEQ1E7/AlBLAwQUAAAACABtVv44usZJ 3cUAAAAhAQAAGwB8AEVycm9yRnVuYy9jYmNsLWVycm9yLTAyNy54cVNEZwCsAAAAAAgA7IYpTWNk YGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAyk VgFIKIDZIhBxRoi4EANEbD+jMFyMG6p/JYMQin5FIBsAVVQNAAedOZBInTmQSL8bkEhNT0GKwzAM vBf6h7nVORjcXNr6Vtjr7mk/4DoKMTh2kJXS/L6u2S0FHUajkWakLH7cTBb+5qMm5sza9CfYbr9T Fl9UPIdFQk4WY7JNoDrMbkOiOzFuBLq7uDqhARMx/a9eV5kyW/yGGd8hxvK+WaUWvTFnbU66vzS+ TWQiFHESPGRbCHlslM9pCK8ILoIeC1MptUEooHmR7W+/YbXfAWGE8iszJdFDNat5o+BRbGsO1fmi zbHWoete+uqRoBqkWOjjz8o9AVBLAwQUAAAACACyWP44SsdbPQgBAACfAQAAGwB8AEVycm9yRnVu Yy9jYmNsLWVycm9yLTAyOC54cVNEZwCsAAAAAAgA7IYpTWNkYGkQYWBgMGCAAB8gZmQFM1lFgUTx /Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1haguE/ozwDSAykVgFIKIDZIhBxRoi4EANEbD+jMFyM G6p/JYMQin5FIBsAVVQNAAfwPJBI8DyQSOM8kEhVkE1OxDAMhfeVeoen2Uy6qJR2A4QVEltYcYFM 6tJIaVol7jAV4u4kYfiTsnDsZ7/PFgrPeiYFczKupRCW0Mr+DqqpK6HwSNEEu7JdvMLoVRGIBrPe 4elMAScCnbXbNNOAiQJ9tz5sPC1B4cXOeLLOxZ+ZSarQS3nbypv26lVXAxmnU/u4eZP94BajnbJM s0iC97oC7AhhthDIczukMYnEMS5Rlc+xl13fdjK9Y9NkPU/k0eWIXCQcFk+Huvq4z36JJJURWbM1 4H0lLGNJ5Ti+WTYT6LIGijHj2AiaV96vuCUWxeRXLv5BozAARifvBGk902s6WSDegv9zzi/ZQKPe 0jrXssgrfAJQSwMEFAAAAAgAUFj+OJHquX0HAQAAnwEAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJv ci0wMjkueHFTRGcArAAAAAAIAOyGKU1jZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35 IpYFtxwjEwMDE0MCAwtYWoLhP6M8A0gMpFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAb AFVUDQAHODyQSDg8kEg6OZBIVZCxboQwDIZ3JN7h1y0XBiSOpW1uqtS1nfoCuWBKpBBQYq6Hqr57 HUR7qpTBsX/7/2yl8WZG0rAX62uKcYp10z5BV2WhNF4o2ehmdlPQ6IPeBKrCaFYEulLEhUBX4xfD 1GGgSL+tzwsPU9R4dyNenffpb6ZINdqmeaybh3r3KouOrDfS3i/BZj/4yRqvHdOoRPBVFoDroewS IwWuOxkjJJ5xS3r7HNvm1NanRt6xqrKeBwo45Yh8IhymQIey+D5nPyGRMhIbdha8zoSp31I5Tp+O 7QC6zZFSyjgugcaZ1x13i9Vmcperf9DYGABrxFsgXWD6kJNF4iUGqL3cUW8WWWNP368s9R9QSwME FAAAAAgAoFb+OAT7bZidAAAA5AAAABsAfABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMzAueHFTRGcA rAAAAAAIAOyGKU1jZGBpEGFgYDBggAAfIGZkBTNZRYFE8fznn9g9dt3qCd35IpYFtxwjEwMDE0MC AwtYWoLhP6M8A0gMpFYBSCiA2SIQcUaIuBADRGw/ozBcjBuqfyWDEIp+RSAbAFVUDQAH/DmQSPw5 kEi+OZBITY5NCsIwEIX3gnd4yxQsxLpQsxPc6soLpHFKA0lTJtNCb28JWtwNb773owyeNpKBa12o iTlxrU8aptrvlMGdsmM/ik+DQTeYAqgK0S4YaCZGS6DZhskKvdET0896m6RPbPDyEQ8fQt4yV9Sg 0fpS63PdXItePtITsljxDrKMhNQVae1limkmOBsCfAbFUZavr9xqY9TfzAOO1cp8AFBLAwQUAAAA CADjVv44QMqfXaYAAADsAAAAGwB8AEVycm9yRnVuYy9jYmNsLWVycm9yLTAzMS54cVNEZwCsAAAA AAgA7IYpTWNkYGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1ha guE/ozwDSAykVgFIKIDZIhBxRoi4EANEbD+jMFyMG6p/JYMQin5FIBsAVVQNAAd6OpBIpTqQSAc6 kEhNjsEKwjAQRO+C/zDHFCzUelBzE7zqyR9I45QGkqYmaaF/bwgqwh6W2TczKyTuylFCd9rWDMGH ujnsIavtRkhcGXUwUzJ+lOhHWQBRwakVIxcGdAQXZWeV+MTAwK/1MqfBB4mHcbgZa+MvM6MSbdOc 6uZYt+eil0saiJhUMhppnQjfFyn3Bjq/EFpZCxNBN6X14yu7yEycu8jXzFFT/P26Q5unyuwbUEsD BBQAAAAIABxX/jjNm+22nAAAAOkAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDMyLnhxU0Rn AKwAAAAACADshilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMDAxND AgMLWFqC4T+jPANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0AB+c6kEjn OpBIpTqQSE2OwQrCMBBE74L/MMf0UIj1oOYmeNWTP5DGLQ2kTdhsi/17S6jibXnzZlhl8LADGbjW hZqYI9f6eICp9jtlcKPs2CfxcTToRlMEVWGwC0aaidESaLZhskIv9MT0rV4n6SMbPP2Auw8h/zZX 1aDR+lzrU91cCi+J9IQsVryDLIkQu4Lo7SgJYiK2Ehk+g4Yky1Yst/p7bvP/yOp9AFBLAwQUAAAA CAASV/44sQZqzZ0AAADvAAAAGwB8AEVycm9yRnVuYy9jYmNsLWVycm9yLTAzMy54cVNEZwCsAAAA AAgA7IYpTWNkYGkQYWBgMGCAAB8gZmQFM1lFgUTx/Oef2D123eoJ3fkilgW3HCMTAwMTQwIDC1ha guE/ozwDSAykVgFIKIDZIhBxRoi4EANEbD+jMFyMG6p/JYMQin5FIBsAVVQNAAfTOpBI0zqQSKU6 kEhNjr0KwzAMBvdC3+EbkyHgpkNbbYWu7dQXcFyFGBI7yEogb99g+pNNnO6ECsLDDkxwjesrFolS meMBVO53BeHGyYkf1cdAaANloSgx2AWBZxY0DJ5tP1nlFzoW/qbXSbsohKcfcPd9n343V5VQG3Ou zKmqL5nnjXaMpFa9gy4jI7YZ+aAsiZ0ijixWo8An8DDq8mnzXGz++ycbuKpvUEsDBBQAAAAIABNY /jhibu9zngAAAOgAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDM0LnhxU0RnAKwAAAAACADs hilNY2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+j PANIDKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0AB8Y7kEjGO5BIiDuQSF2O ywrCMBBF94L/cJfpIhCqoM5OcKsrfyCNIw3kUZK0UL/eGnyAu+HOuQ9BuGjPBNMZJzmlmKTabEHN eiUIJ84m2aHYGAj3QBUQDbyeEXjihI7Bk3ajLnxDz4k/1uNY+pgIV+txts7lb+aCElql9lLtZHuo ev2UnpGLLtagzAMj3l+dD05RLrNiYBjtHGwG+6HMb2O9xR8pfmMbLNgTUEsDBBQAAAAIAIda/jhC ZZc8pAAAAPYAAAAbAHwARXJyb3JGdW5jL2NiY2wtZXJyb3ItMDM1LnhxU0RnAKwAAAAACADshilN Y2RgaRBhYGAwYIAAHyBmZAUzWUWBRPH855/YPXbd6gnd+SKWBbccIxMDAxNDAgMLWFqC4T+jPANI DKRWAUgogNkiEHFGiLgQA0RsP6MwXIwbqn8lgxCKfkUgGwBVVA0AB15AkEheQJBIKkCQSE2OyQoC MRBE74L/UMfxEBhGQc1N8KonfyDGkgnMZqdHnL83Brdb1/KaKiyOrqWFP/vGUKQXUy5XsIv5rLDY M3oJg4a+s7h2NheKBVo3oeOdgjPBu2tGp7ygpvCD7kate7E4hRaH0DTx+zNVLaqy3Jhybapt9nOi NRHVafDQaSD6a7ZU6BQugo9BGGMag5BUO+j0hvNd/C/8Qa/IRN5Gdp4pScATUEsBAhcLCgAAAAAA KGn+OAAAAAAAAAAAAAAAAAoAEQAAAAAAAAAQAP9BAAAAAEVycm9yRnVuYy9TRAQABAEAAFVUBQAH 7FmQSFBLAQIXCxQAAAAIAGVr/TiMfZzwoQAAAN8AAAAbABEAAAAAAAEAIAC2gb0AAABFcnJvckZ1 bmMvY2JjbC1lcnJvci0wMDEueHFTRAQArAAAAFVUBQAHngyPSFBLAQIXCxQAAAAIAAts/Tj13bmb fwAAAKIAAAAbABEAAAAAAAEAIAC2gRMCAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMDIueHFTRAQA rAAAAFVUBQAH1g2PSFBLAQIXCxQAAAAIAEls/Tjvbb4lfwAAAKIAAAAbABEAAAAAAAEAIAC2gUcD AABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMDMueHFTRAQArAAAAFVUBQAHSg6PSFBLAQIXCxQAAAAI AENs/TipPy9bgAAAAKMAAAAbABEAAAAAAAEAIAC2gXsEAABFcnJvckZ1bmMvY2JjbC1lcnJvci0w MDQueHFTRAQArAAAAFVUBQAHPg6PSFBLAQIXCxQAAAAIAExs/TiZFKblfwAAAKMAAAAbABEAAAAA AAEAIAC2gbAFAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMDUueHFTRAQArAAAAFVUBQAHTw6PSFBL AQIXCxQAAAAIAIps/Th3/bbCegAAAJsAAAAbABEAAAAAAAEAIAC2geQGAABFcnJvckZ1bmMvY2Jj bC1lcnJvci0wMDYueHFTRAQArAAAAFVUBQAHxA6PSFBLAQIXCxQAAAAIAJFs/ThSJsOdewAAAJsA AAAbABEAAAAAAAEAIAC2gRMIAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMDcueHFTRAQArAAAAFVU BQAH0g6PSFBLAQIXCxQAAAAIALxs/Tjy+POWfwAAAKMAAAAbABEAAAAAAAEAIAC2gUMJAABFcnJv ckZ1bmMvY2JjbC1lcnJvci0wMDgueHFTRAQArAAAAFVUBQAHJA+PSFBLAQIXCxQAAAAIAMBs/Thy oFB2fgAAAKMAAAAbABEAAAAAAAEAIAC2gXcKAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMDkueHFT RAQArAAAAFVUBQAHKA+PSFBLAQIXCxQAAAAIANts/Tj6ay64fgAAAKIAAAAbABEAAAAAAAEAIAC2 gaoLAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTAueHFTRAQArAAAAFVUBQAHXg+PSFBLAQIXCxQA AAAIAOds/Tj8FjITfwAAAKIAAAAbABEAAAAAAAEAIAC2gd0MAABFcnJvckZ1bmMvY2JjbC1lcnJv ci0wMTEueHFTRAQArAAAAFVUBQAHcg+PSFBLAQIXCxQAAAAIAPNs/TjE63qtewAAAKAAAAAbABEA AAAAAAEAIAC2gREOAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTIueHFTRAQArAAAAFVUBQAHiQ+P SFBLAQIXCxQAAAAIAPds/Tj5aA1dfQAAAKAAAAAbABEAAAAAAAEAIAC2gUEPAABFcnJvckZ1bmMv Y2JjbC1lcnJvci0wMTMueHFTRAQArAAAAFVUBQAHkQ+PSFBLAQIXCxQAAAAIAEpt/Tiv4QUhiQAA ALEAAAAbABEAAAAAAAEAIAC2gXMQAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTQueHFTRAQArAAA AFVUBQAHLBCPSFBLAQIXCxQAAAAIAJ1t/TgP2b+KjAAAALcAAAAbABEAAAAAAAEAIAC2gbERAABF cnJvckZ1bmMvY2JjbC1lcnJvci0wMTUueHFTRAQArAAAAFVUBQAHyhCPSFBLAQIXCxQAAAAIAKFt /TiXz687igAAALEAAAAbABEAAAAAAAEAIAC2gfISAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTYu eHFTRAQArAAAAFVUBQAHzRCPSFBLAQIXCxQAAAAIAM5t/TgFhMbwhQAAALUAAAAbABEAAAAAAAEA IAC2gTEUAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTcueHFTRAQArAAAAFVUBQAHJBGPSFBLAQIX CxQAAAAIAPFt/ThPp7dvigAAALMAAAAbABEAAAAAAAEAIAC2gWsVAABFcnJvckZ1bmMvY2JjbC1l cnJvci0wMTgueHFTRAQArAAAAFVUBQAHZRGPSFBLAQIXCxQAAAAIAAxu/TizsfiXhgAAALMAAAAb ABEAAAAAAAEAIAC2gaoWAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMTkueHFTRAQArAAAAFVUBQAH lxGPSFBLAQIXCxQAAAAIAChu/TjBH+TbgwAAAK0AAAAbABEAAAAAAAEAIAC2geUXAABFcnJvckZ1 bmMvY2JjbC1lcnJvci0wMjAueHFTRAQArAAAAFVUBQAHyxGPSFBLAQIXCxQAAAAIAFJu/TiZFJx1 nAAAAOAAAAAbABEAAAAAAAEAIAC2gR0ZAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMjEueHFTRAQA rAAAAFVUBQAHHBKPSFBLAQIXCxQAAAAIAFJu/TiZFJx1nAAAAOAAAAAbABEAAAAAAAEAIAC2gW4a AABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMjIueHFTRAQArAAAAFVUBQAHHBKPSFBLAQIXCxQAAAAI AAJc/ji/xQatfwAAAKAAAAAbABEAAAAAAAEAIAC2gb8bAABFcnJvckZ1bmMvY2JjbC1lcnJvci0w MjMueHFTRAQArAAAAFVUBQAHI0OQSFBLAQIXCxQAAAAIAAhv/ThvEELohAAAAKYAAAAbABEAAAAA AAEAIAC2gfMcAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMjQueHFTRAQArAAAAFVUBQAHcBOPSFBL AQIXCxQAAAAIAItF/jgjXsbOhwAAAKUAAAAbABEAAAAAAAEAIAC2gSweAABFcnJvckZ1bmMvY2Jj bC1lcnJvci0wMjUueHFTRAQArAAAAFVUBQAH1huQSFBLAQIXCxQAAAAIAGZW/jg6+/g4xgAAACEB AAAbABEAAAAAAAEAIAC2gWgfAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMjYueHFTRAQArAAAAFVU BQAHkDmQSFBLAQIXCxQAAAAIAG1W/ji6xkndxQAAACEBAAAbABEAAAAAAAEAIAC2geMgAABFcnJv ckZ1bmMvY2JjbC1lcnJvci0wMjcueHFTRAQArAAAAFVUBQAHnTmQSFBLAQIXCxQAAAAIALJY/jhK x1s9CAEAAJ8BAAAbABEAAAAAAAEAIAC2gV0iAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMjgueHFT RAQArAAAAFVUBQAH8DyQSFBLAQIXCxQAAAAIAFBY/jiR6rl9BwEAAJ8BAAAbABEAAAAAAAEAIAC2 gRokAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMjkueHFTRAQArAAAAFVUBQAHODyQSFBLAQIXCxQA AAAIAKBW/jgE+22YnQAAAOQAAAAbABEAAAAAAAEAIAC2gdYlAABFcnJvckZ1bmMvY2JjbC1lcnJv ci0wMzAueHFTRAQArAAAAFVUBQAH/DmQSFBLAQIXCxQAAAAIAONW/jhAyp9dpgAAAOwAAAAbABEA AAAAAAEAIAC2gSgnAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMzEueHFTRAQArAAAAFVUBQAHejqQ SFBLAQIXCxQAAAAIABxX/jjNm+22nAAAAOkAAAAbABEAAAAAAAEAIAC2gYMoAABFcnJvckZ1bmMv Y2JjbC1lcnJvci0wMzIueHFTRAQArAAAAFVUBQAH5zqQSFBLAQIXCxQAAAAIABJX/jixBmrNnQAA AO8AAAAbABEAAAAAAAEAIAC2gdQpAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMzMueHFTRAQArAAA AFVUBQAH0zqQSFBLAQIXCxQAAAAIABNY/jhibu9zngAAAOgAAAAbABEAAAAAAAEAIAC2gSYrAABF cnJvckZ1bmMvY2JjbC1lcnJvci0wMzQueHFTRAQArAAAAFVUBQAHxjuQSFBLAQIXCxQAAAAIAIda /jhCZZc8pAAAAPYAAAAbABEAAAAAAAEAIAC2gXksAABFcnJvckZ1bmMvY2JjbC1lcnJvci0wMzUu eHFTRAQArAAAAFVUBQAHXkCQSFBLBQYAAAAAJAAkAJcMAADSLQAAAAA=