From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!not-for-mail From: Ian Grant Newsgroups: gmane.comp.gnu.lightning.general,gmane.lisp.guile.devel Subject: Re: Reinterpreting the compiler source code Date: Thu, 4 Sep 2014 20:44:06 -0400 Message-ID: References: NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="===============6340058973206741165==" X-Trace: ger.gmane.org 1409877874 12472 80.91.229.3 (5 Sep 2014 00:44:34 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Fri, 5 Sep 2014 00:44:34 +0000 (UTC) To: Bruno Loff , guile-devel-mXXj517/zsQ@public.gmane.org, lightning , Richard Stallman , Theo deRaadt , Markus Kuhn , Linus Torvalds , schellr-EkmVulN54Sk@public.gmane.org Original-X-From: lightning-bounces+gcglg-lightning=m.gmane.org-mXXj517/zsQ@public.gmane.org Fri Sep 05 02:44:28 2014 Return-path: Envelope-to: gcglg-lightning@m.gmane.org Original-Received: from lists.gnu.org ([208.118.235.17]) by plane.gmane.org with esmtp (Exim 4.69) (envelope-from ) id 1XPhdY-0008Qs-44 for gcglg-lightning@m.gmane.org; Fri, 05 Sep 2014 02:44:24 +0200 Original-Received: from localhost ([::1]:54753 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XPhdX-0001g0-FJ for gcglg-lightning@m.gmane.org; Thu, 04 Sep 2014 20:44:23 -0400 Original-Received: from eggs.gnu.org ([2001:4830:134:3::10]:39099) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XPhdO-0001dv-VI for lightning-mXXj517/zsQ@public.gmane.org; Thu, 04 Sep 2014 20:44:19 -0400 Original-Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1XPhdI-0000kH-Tp for lightning-mXXj517/zsQ@public.gmane.org; Thu, 04 Sep 2014 20:44:14 -0400 Original-Received: from mail-wg0-x22f.google.com ([2a00:1450:400c:c00::22f]:49682) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XPhdI-0000k5-8B; Thu, 04 Sep 2014 20:44:08 -0400 Original-Received: by mail-wg0-f47.google.com with SMTP id z12so10782646wgg.6 for ; Thu, 04 Sep 2014 17:44:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=googlemail.com; s=20120113; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :content-type; bh=WtUVfNNwLlnXNlAezKSEGD2wsRqCT+ZQdXGYPpn2DHk=; b=aJSkbdnJzrzwuBexjzRUaqNbpEUMemyVQZyJb8bTcoG4sWKAZCwGs2V/isqYpGYNCc w0lmKZRCyXWq31lyut7pAmRfo6Wvx/rBCFoHedT4TNuY9+5dpEZRmG9bxXQmy1ZSaNuv hbr3y/S9bkCXf8wxUZeYDRLK68jBvRghbAlJTj2uZRUTO6i2b6YRkJwMVNHBl38TODv2 E7RjhljmWgeic5C7HAZVc1mcw6VI6JblvZ7DNeUJmbsXtMFNRbelMm9XfigK/MYdnK9c BEex2fEdHt9q5Rk5bKfeoQ6X9YwyGDA7+HdCVn6fDizFPuXxT/h9A3Oa0vPSyA7MOHLx rfKw== X-Received: by 10.194.57.237 with SMTP id l13mr10622228wjq.102.1409877847005; Thu, 04 Sep 2014 17:44:07 -0700 (PDT) Original-Received: by 10.194.219.234 with HTTP; Thu, 4 Sep 2014 17:44:06 -0700 (PDT) In-Reply-To: X-detected-operating-system: by eggs.gnu.org: Error: Malformed IPv6 address (bad octet value). X-Received-From: 2a00:1450:400c:c00::22f X-BeenThere: lightning-mXXj517/zsQ@public.gmane.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: lightning-bounces+gcglg-lightning=m.gmane.org-mXXj517/zsQ@public.gmane.org Original-Sender: lightning-bounces+gcglg-lightning=m.gmane.org-mXXj517/zsQ@public.gmane.org Xref: news.gmane.org gmane.comp.gnu.lightning.general:567 gmane.lisp.guile.devel:17406 Archived-At: --===============6340058973206741165== Content-Type: multipart/alternative; boundary=047d7b86c92e3f60d3050246c473 --047d7b86c92e3f60d3050246c473 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable On Thu, Sep 4, 2014 at 4:57 PM, Bruno Loff wrote: > Even if the threat you describe is real, why couldn't it be resolved in a > simpler way? > First, here's a slightly philosophical question: do you accept that a threat can be a real threat, even if it's not carried out? So if I say to you, "You will do what I say, otherwise I'll destroy your project and ruin your whole life!" Then that is a threat, whether I carry it out or not, because it restricts your freedom: so it is real because it is an immediate cause of your acting in a way that you would not otherwise act. If not, then all threats would be what Richard calls "imponderables" you wouldn't be able to know anything about them until they were carried out. > > I'm thinking certificates and signatures... > Certificates and signatures are simpler, but only if you forget how it is you actually know they are secure. The so-called "mathematical" basis of all public-key cryptography that I know of is the assumption that some one-way "trapdoor" function is easy to compute, but its inverse is computationally infeasible. Yet the knowledge this represents is not knowledge. It's certainly nothing to do with mathematics. It is simply the absence of knowledge to the contrary. So these protocols are secure solely because of _some_ people's complete ignorance of any evidence that they are not! But if someone had such contrary evidence, would you really expect them to tell the world? I am not suggesting for one minute that the NSA, say, have a polynomial-time time solution to NP-complete problems: that is not even a necessary condition for these algorithms being insecure. I am just saying that there is not even any remotely plausible justification for the belief that the ignorance we are assuming exists is actually real!!! We are ignorant of the ignorance as well as the knowledge! This is really funny. People should laugh about it a lot more than they do. > I mean, for each distribution in each architecture, there is basically a > single build configuration which needs to be certified as "trojan-free". > And this is basically already implemented, provided that I get my compile= r > package from a clean source which signed the package, all that is necessa= ry > is that the clean source took special care in ensuring that their version > is in fact bug-free... > > That solves 99% of the use-cases, when you use a standard compiler > provided by a clean source. For the remaining .99%, when you use a > custom-built compiler, say, you could start with a compiler from a clean > source and use that to compile your custom-build... No bug injection woul= d > happen then. > How do you know that? If you can't know what the C compiler did when it compiled the LibreTLS code that Apache runs, or the OpenSSL CA signing app on the OpenBSD box in the offices of the company who sold you a certificate?. > Wouldn't that be enough? Formal certification of the cleanliness of the > compiler (if I understood correctly and this is what you propose) seems > over-the-top to me. > Formal semantics are not as boring as they sound. It's all about writing real code that works, and which interprets languages and does stuff. It's fun. If you try it, then I think you'll believe me. > Happy hacking :-) > Thank you! You too. Ian > > > > On 4 September 2014 18:33, Ian Grant wrote= : > >> Perhaps people would enjoy reading about how one could inject trojan >> semantics into a compiler in such a way that they have some resilience >> to all but quite major structural changes to the target source code? >> >> This is not just for the purposes of frightening the birds. It will >> show how useful tools which automatically analyse and transform >> program syntax could be. Imagine this in a 'whole program' IDE, so >> that one could query certain classes of variable assignment in an >> Operating System kernel, say, and program global re-writes based on >> pattern matching of whole syntactic structures, rather than just the >> sub-lexical matching which regular expressions offer. >> >> Here is an implementation of a Prolog interpreter. The interpreter >> itself is only 88 lines of Standard ML. Most of it is written using >> list functionals like map, exists, find, partition etc. So it should >> be clear that it could be quite easily translated into a fairly >> efficient C program. >> >> (* (Apart from the !=3D predicate) This is a transliteration of the >> Prolog interpreter in John Harrison's Cambridge lecture notes. *) >> >> datatype term =3D >> Fn of string * term list >> | Var of string >> >> datatype outcome =3D >> Yes of (string * term) list >> | No >> >> local open GrammarSyntax >> fun parser startsymbol =3D >> let fun parse file stream lexbuf =3D >> let val expr =3D startsymbol PrologLexer.Token lexbuf >> in Parsing.clearParser(); >> expr >> end handle exn =3D> (Parsing.clearParser(); raise exn) >> in parse end >> fun processString pfn =3D fn s =3D> >> pfn "string" s (Lexing.createLexerString s) >> fun qlToString l =3D >> let fun iter r [] =3D r >> | iter r ((QUOTE s)::fs) =3D iter (r^s) fs >> | iter r ((ANTIQUOTE s)::fs) =3D iter (r^s) fs >> in iter "" l >> end >> val parserulesq =3D processString (parser PrologParser.File) o qlToSt= ring >> val parsetermq =3D processString (parser PrologParser.OneTerm) o >> qlToString >> fun fails s t =3D (printTree t;raise Fail (s^": no case.")) >> fun mkTerm (NonTerm("atom", >> [NonTerm("constant", >> [Term(name)]), >> l as NonTerm("term-list",_)])) >> =3D Fn(name,mkArgs l) >> | mkTerm (NonTerm("atom",[NonTerm("constant",[Term(name)])])) >> =3D Fn(name,[]) >> | mkTerm (NonTerm("atom",[NonTerm("variable",[Term(name)])])) >> =3D Var(name) >> | mkTerm (NonTerm("atom",[l as NonTerm("list",_)])) >> =3D mkList(l) >> | mkTerm t =3D fails "mkTerm" t >> and mkList (NonTerm("list",[a as NonTerm("atom",_), >> l as NonTerm("list",_)])) >> =3D Fn(".",[mkTerm a,mkList l]) >> | mkList (NonTerm("list",[a as NonTerm("atom",_)])) >> =3D Fn(".",[mkTerm a,Fn("[]",[])]) >> | mkList (NonTerm("list",[a as NonTerm("atom",_), >> a' as NonTerm("atom",_)])) >> =3D Fn(".",[mkTerm a,mkTerm a']) >> | mkList (NonTerm("list",[])) >> =3D Fn("[]",[]) >> | mkList t =3D fails "mkList" t >> and mkArgs (NonTerm("term-list",[a as NonTerm("atom",_), >> l as NonTerm("term-list",_)])) >> =3D (mkTerm a)::(mkArgs l) >> | mkArgs (NonTerm("term-list",[a as NonTerm("atom",_)])) >> =3D [mkTerm a] >> | mkArgs t =3D fails "mkArgs" t >> fun mkTerms (NonTerm("terms",[a as NonTerm("atom",_), >> ts as NonTerm("terms",_)])) >> =3D (mkTerm a)::(mkTerms ts) >> | mkTerms (NonTerm("terms",[a as NonTerm("atom",_)])) >> =3D [mkTerm a] >> | mkTerms t =3D fails "mkTerms" t >> and mkRule (NonTerm("rule",[a as NonTerm("atom",_), >> ts as NonTerm("terms",_)])) >> =3D (mkTerm a, mkTerms ts) >> | mkRule (NonTerm("rule",[a as NonTerm("atom",_)])) >> =3D (mkTerm a,[]) >> | mkRule t =3D fails "mkRule" t >> and mkRules (NonTerm("rule-list",[l as NonTerm("rule-list",_), >> r as NonTerm("rule",_)])) >> =3D (mkRule(r))::(mkRules l) >> | mkRules (NonTerm("rule-list",[r as NonTerm("rule",_)])) >> =3D [mkRule(r)] >> | mkRules t =3D fails "mkRules" t >> in >> val rules =3D List.rev o mkRules o parserulesq >> val goal =3D mkTerm o parsetermq >> end >> >> local >> fun occurs_in x =3D >> fn (Var y) =3D> x =3D y >> | (Fn(_,l)) =3D> List.exists (occurs_in x) l >> fun assoc i =3D >> (Option.map (fn (_,v) =3D> v)) o (List.find (fn (k,_) =3D> k =3D i= )) >> fun subs insts =3D >> fn (tm as (Var y)) =3D> >> (case assoc y insts of NONE =3D> tm | SOME v =3D> v) >> | (Fn(s,l)) =3D> >> Fn(s,List.map (subs insts) l) >> fun augment1 theta (x,s) =3D >> let val s' =3D subs theta s >> in if occurs_in x s andalso not (s =3D Var(x)) >> then raise Fail "Occurs check." >> else (x,s') >> end >> fun raw_augment p insts =3D p::(List.map (augment1 [p]) insts) >> fun augment (v,t) insts =3D >> let val t' =3D subs insts t >> in case t' >> of Var (w) =3D> >> if w <=3D v >> then if w =3D v >> then insts >> else raw_augment (v,t') insts >> else raw_augment (w,Var(v)) insts >> | _ =3D> if occurs_in v t' >> then raise Fail "Occurs check." >> else raw_augment (v,t') insts >> end >> fun itlist2 f =3D >> let fun iter [] [] =3D (fn b =3D> b) >> | iter (h::t) (h'::t') =3D (fn b =3D> f h h' (itlist2 f t t'= b)) >> | iter _ _ =3D raise Fail "Arity." >> in iter >> end >> fun unify tm1 tm2 insts =3D >> case tm1 >> of Var(x) =3D> >> (case assoc x insts >> of NONE =3D> augment (x,tm2) insts >> | SOME tm1' =3D> unify tm1' tm2 insts) >> | Fn(f1,args1) =3D> >> (case tm2 >> of (Var(y)) =3D> >> (case assoc y insts >> of NONE =3D> augment (y,tm1) insts >> | SOME tm2' =3D> unify tm1 tm2' insts) >> | Fn(f2,args2) =3D> >> if f1 =3D f2 then itlist2 unify args1 args2 insts >> else raise Fail ("Constants: mismatch: >> "^f1^"<>"^f2)) >> fun rename s =3D >> fn (Var v) =3D> Var("~"^v^s) >> | (Fn(f,args)) =3D> Fn(f,List.map (rename s) args) >> fun rename_rule s (conc,assums) =3D >> (rename s conc,List.map (rename s) assums) >> fun expand n rules insts goals =3D >> let fun first f =3D >> (fn [] =3D> raise Fail "No rules apply." >> | (h::t) =3D> (f h handle Fail _ =3D> first f t)) >> fun search rule =3D >> if goals =3D [] >> then insts >> else >> let fun eqgoal (Fn("!=3D",[a,b])) =3D not (a =3D b) >> | eqgoal _ =3D false >> val (conc,assums) =3D rename_rule (Int.toString n= ) >> rule >> val goal =3D hd goals >> val insts' =3D if eqgoal goal >> then insts (* CHECK! This is >> probably wrong. *) >> else unify conc goal insts >> fun occurs (v,_) =3D occurs_in v conc >> orelse List.exists (occurs_in v) assu= ms >> val (loc,glob) =3D List.partition occurs insts' >> val goals' =3D (List.map (subs loc) assums) @ (tl >> goals) >> in expand (n+1) rules glob goals' >> end >> in >> first search rules >> end >> in >> fun prolog rules goal =3D >> let val insts =3D expand 0 rules [] [goal] >> in Yes (List.filter (fn (v,_) =3D> occurs_in v goal) insts) >> end handle Fail _ =3D> No >> end >> >> Here is an example of what it can do (a rather tired old one, but bear >> with us, because we will shortly reinterpret this as something >> more interesting): >> >> val () =3D load "Prolog"; >> >> val () =3D Meta.quotation :=3D true; >> >> val rs =3D Prolog.rules ` >> male(albert). >> male(edward). >> >> female(alice). >> female(victoria). >> >> father_of(albert,edward). >> father_of(albert,alice). >> >> mother_of(victoria,edward). >> mother_of(victoria,alice). >> >> parents(X,M,F):-mother_of(M,X),father_of(F,X). >> >> sister_of(X,Y):- >> female(X), >> parents(X,M,F), >> parents(Y,M,F). >> >> brother_of(X,Y):- >> !=3D(X,Y), >> male(X), >> parents(X,M,F), >> parents(Y,M,F). >> `; >> >> This defines a database of facts, the so-called ground terms, which >> are those which don't contain any logical variables (which in Prolog >> are typically all-upper-case identifiers). Then there are _rules_ >> which define relations (in the set-theoretical sense of the term, but >> here also in the genealogical sense). >> >> Note that the two-place predicate sister_of is indirectly defined in >> terms another rule, which defines the parents relation. But these 88 >> lines of code will resolve the indirection and so they can correctly >> deduce, for example: >> >> val g =3D Prolog.goal `sister_of(alice,edward)` >> val r =3D Prolog.prolog rs g >> >> giving >> >> val r =3D Prolog.Yes [] : outcome >> >> Now look at the database of facts, and note that it is really just an >> abstract syntax representation of a collection of statements in an >> arbitrary language (i.e. a language with undefined syntax). Therefore >> one can apply Prolog deductions, quite trivially, to sentences in a >> defined programming language such as C. Now the C compiler, which we >> imagine we are attacking, already has all the code to analyse and >> manipulate abstract syntax representations of C programs, because that >> is its job! So I hope people can see, without my having to install it >> into GCC 4.9, that one can easily implement a Prolog interpreter in >> very little code, which can decide a quite general class of predicates >> concerning a program, the structure of which is represented in the >> compiler as abstract syntax. >> >> Now note that the predicates need not have a fixed 'depth.' Here are >> two rules defining a path in an arbitrary directed graph, which is a >> non-wellfounded structure capable of representing almost anything, >> including the sentences of any language defined by a context-free >> grammar. >> >> Here the ground terms represent a graph in three disjoint parts, with >> two cycles. >> >> val rs'' =3D Prolog.rules ` >> edge(g,h). >> edge(e,f). >> edge(f,e). >> edge(a,b). >> edge(b,c). >> edge(c,d). >> edge(d,a). >> path(A,B):-edge(A,B). >> path(A,B):-edge(A,C),path(C,B). >> `; >> >> Prolog can determine whether or not there is a path from one vertex to >> another, no matter how far apart they may be: >> >> val g2 =3D Prolog.goal `path(a,d)` >> val r2 =3D Prolog.prolog rs'' g2 >> >> It prints >> >> val r2 =3D Prolog.Yes [] : outcome >> >> And it can tell which vertices are reachable from a given vertex: >> >> val g3 =3D Prolog.goal `path(b,X)` >> val r3 =3D Prolog.prolog rs'' g3 >> >> The result is >> >> val r3 =3D Prolog.Yes [("X", Prolog.Fn("c", []))] : outcome >> >> In this implementation it only prints the first such edge, but it >> could find them all. >> >> So it should not require any great stretching of people's credulity to >> see that a very few lines of intelligently written code can recognise >> large-scale structure in abstract syntax, even when quite extensive >> changes may have been made to the leaves. >> >> Now we need to show it could re-write those programs. This is easy, >> because in fact a C compiler already does this. It has to, because the >> syntax of C is not sufficient to determine what is a well-formed C >> program and what is not. Here is an example of programmed re-writing >> of arbitrary fragments of a C program. What this does is split a >> compound typedef statement (any compound typedef statement whatsoever) >> into separate parts: >> >> val rewrite_typedef =3D >> rewriteq ` >> =E2=9F=A6declaration >> =E2=8C=9Cw:declaration-specifiers=E2=8C=9D >> (init-declarator-list >> =E2=8C=9Cx:init-declarator-list=E2=8C=9D >> =E2=8C=9Cy:init-declarator=E2=8C=9D)=E2=9F=A7 =3D >> (declaration-list >> (declaration-list >> =E2=9F=A6declaration =E2=8C=9Cw=E2=8C=9D =E2=8C=9Cx= =E2=8C=9D=E2=9F=A7) >> (declaration =E2=8C=9Cw=E2=8C=9D (init-declarator-list= =E2=8C=9Cy=E2=8C=9D)))` >> >> So taking this typedef: >> >> val td =3D absyntq `typedef unsigned int ui, *pui, (*funcp) (int i);` >> >> we produce this rewritten abstract syntax with three separate >> typedef declarations: >> >> external-declarations: >> external-declaration: >> declaration-list: >> declaration-list: >> declaration-list: >> declaration-list: >> declaration: >> declaration-specifiers: >> storage-class-specifier: typedef >> declaration-specifiers: >> type-specifier: unsigned >> declaration-specifiers: >> type-specifier: int >> init-declarator-list: >> init-declarator: >> declarator: >> direct-declarator: >> identifier: ui >> declaration: >> declaration-specifiers: >> storage-class-specifier: typedef >> declaration-specifiers: >> type-specifier: unsigned >> declaration-specifiers: >> type-specifier: int >> init-declarator-list: >> init-declarator: >> declarator: >> pointer: >> direct-declarator: >> identifier: pui >> declaration: >> declaration-specifiers: >> storage-class-specifier: typedef >> declaration-specifiers: >> type-specifier: unsigned >> declaration-specifiers: >> type-specifier: int >> init-declarator-list: >> init-declarator: >> declarator: >> direct-declarator: >> direct-declarator: >> declarator: >> pointer: >> direct-declarator: >> identifier: funcp >> parameter-type-list: >> parameter-list: >> parameter-declaration: >> declaration-specifiers: >> type-specifier: int >> declarator: >> direct-declarator >> identifier i >> >> The general system, capable of handling extremely complex rewrites >> like this, which can be nested and called (conditionally and/or >> recursively) one from another, with parameters, is implemented in >> about 400 lines of rather badly written Standard ML. It is not Prolog, >> but it uses a similar unification algorithm to identify certain >> large-scale structures independently of many details of particular >> instances, which can vary quite significantly. >> >> These programs, the Prolog interpreter and the Rewrite engine, compile >> to 15,533 and 24,535+28,944 bytes respectively of CAML bytecode. I >> would not expect a C implementation of similar algorithms to be much >> more than this. If anyone doubts someone's chances of effectively >> hiding this much code in a C compiler binary, then they should >> consider that on my system, between GCC 4.5 and GCC 4.9, the combined >> compiler binaries: gcc, cpp, cc1, as and ld grew from 10 MB to over 70 >> MB. So I think it would not be too difficult to hide an extra 80k of >> object code in a binary. That represents an increase of around one >> tenth of one percent over the total 70MB (which I consider quite >> ridiculous, by the way. One possible explanation is that GCHQ and the >> NSA are playing core-wars in the GCC binaries.) >> >> Now those still reading this will appreciate that the rewrite engine, >> and the Prolog interpreter, are quite abstract in the sense that they >> interpret _arbitrary_ rules, and so they could easily be implemented >> in such a way that the rules can be changed after the fact, by coding >> new rules into the compiler's source code. The coding could be in >> comments, or it could be in the choice of variable names, or it could >> be in terms of the number of spaces appearing at the ends of lines >> which are certain successive prime multiples of lines apart. Then, by >> applying a publicly scrutinised patch to the compiler source, the >> penetrators could reprogram the trap door already in all the binaries >> of the previous versions of the new compiler, so that they recognise >> and effectively compromise the new compiler's source structure. And >> while they're at it, they may as well change the coding system used to >> transmit new rules, so that no more than one instance of any encrypted >> message ever exists. >> >> This is only the tip of the ice-burg; and the less evidence I see that >> people are properly addressing this 'issue', the more of these >> 'suggestions' I will publish over the next few days. And I think that >> after not so very long, people will be less inclined to make unfounded >> claims about the relative improbability of such an attack. I'm looking >> forward to it: some of them are really, really whacky! And needless to >> say, none of them are original. This last is just a standard instance >> of the teletype string trigger trap door that Karg and Schell >> described 40 years ago in the Multics Security Evaluation: >> Vulnerability Analysis. That document is well worth a careful >> read. The First World Information War started decades ago, we think, >> but some people apparently haven't cottoned-on yet. >> >> Happy hacking, everyone! >> >> Ian >> >> >> _______________________________________________ >> Lightning mailing list >> Lightning-mXXj517/zsQ@public.gmane.org >> https://lists.gnu.org/mailman/listinfo/lightning >> >> > --047d7b86c92e3f60d3050246c473 Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: base64 PGRpdiBkaXI9Imx0ciI+T24gVGh1LCBTZXAgNCwgMjAxNCBhdCA0OjU3IFBNLCBCcnVubyBMb2Zm IDxzcGFuIGRpcj0ibHRyIj4mbHQ7PGEgaHJlZj0ibWFpbHRvOmJydW5vLmxvZmZAZ21haWwuY29t IiB0YXJnZXQ9Il9ibGFuayI+YnJ1bm8ubG9mZkBnbWFpbC5jb208L2E+Jmd0Ozwvc3Bhbj4gd3Jv dGU6PGJyPjxkaXYgY2xhc3M9ImdtYWlsX2V4dHJhIj48ZGl2IGNsYXNzPSJnbWFpbF9xdW90ZSI+ PGJsb2NrcXVvdGUgY2xhc3M9ImdtYWlsX3F1b3RlIiBzdHlsZT0ibWFyZ2luOjBweCAwcHggMHB4 IDAuOGV4O2JvcmRlci1sZWZ0OjFweCBzb2xpZCByZ2IoMjA0LDIwNCwyMDQpO3BhZGRpbmctbGVm dDoxZXgiPjxkaXYgZGlyPSJsdHIiPkV2ZW4gaWYgdGhlIHRocmVhdCB5b3UgZGVzY3JpYmUgaXMg cmVhbCwgd2h5IGNvdWxkbiYjMzk7dCBpdCBiZSByZXNvbHZlZCBpbiBhIHNpbXBsZXIgd2F5Pzwv ZGl2PjwvYmxvY2txdW90ZT48ZGl2Pjxicj48L2Rpdj48ZGl2PkZpcnN0LCBoZXJlJiMzOTtzIGEg c2xpZ2h0bHkgcGhpbG9zb3BoaWNhbCBxdWVzdGlvbjogZG8geW91IGFjY2VwdCB0aGF0IGEgdGhy ZWF0IGNhbiBiZSBhIHJlYWwgdGhyZWF0LCBldmVuIGlmIGl0JiMzOTtzIG5vdCBjYXJyaWVkIG91 dD8gU28gaWYgSSBzYXkgdG8geW91LCAmcXVvdDtZb3Ugd2lsbCBkbyB3aGF0IEkgc2F5LCBvdGhl cndpc2UgSSYjMzk7bGwgZGVzdHJveSB5b3VyIHByb2plY3QgYW5kIHJ1aW4geW91ciB3aG9sZSBs aWZlISZxdW90OyBUaGVuIHRoYXQgaXMgYSB0aHJlYXQsIHdoZXRoZXIgSSBjYXJyeSBpdCBvdXQg b3Igbm90LCBiZWNhdXNlIGl0IHJlc3RyaWN0cyB5b3VyIGZyZWVkb206IHNvIGl0IGlzIHJlYWwg YmVjYXVzZSBpdCBpcyBhbiBpbW1lZGlhdGUgY2F1c2Ugb2YgeW91ciBhY3RpbmcgaW4gYSB3YXkg dGhhdCB5b3Ugd291bGQgbm90IG90aGVyd2lzZSBhY3QuIElmIG5vdCwgdGhlbiBhbGwgdGhyZWF0 cyB3b3VsZCBiZSB3aGF0IFJpY2hhcmQgY2FsbHMgJnF1b3Q7aW1wb25kZXJhYmxlcyZxdW90OyB5 b3Ugd291bGRuJiMzOTt0IGJlIGFibGUgdG8ga25vdyBhbnl0aGluZyBhYm91dCB0aGVtIHVudGls IHRoZXkgd2VyZSBjYXJyaWVkIG91dC48YnI+PC9kaXY+PGJsb2NrcXVvdGUgY2xhc3M9ImdtYWls X3F1b3RlIiBzdHlsZT0ibWFyZ2luOjBweCAwcHggMHB4IDAuOGV4O2JvcmRlci1sZWZ0OjFweCBz b2xpZCByZ2IoMjA0LDIwNCwyMDQpO3BhZGRpbmctbGVmdDoxZXgiPjxkaXYgZGlyPSJsdHIiPjxk aXY+PGJyPjwvZGl2PjxkaXY+SSYjMzk7bSB0aGlua2luZyBjZXJ0aWZpY2F0ZXMgYW5kIHNpZ25h dHVyZXMuLi48L2Rpdj48L2Rpdj48L2Jsb2NrcXVvdGU+PGRpdj48YnI+PC9kaXY+PGRpdj5DZXJ0 aWZpY2F0ZXMgYW5kIHNpZ25hdHVyZXMgYXJlIHNpbXBsZXIsIGJ1dCBvbmx5IGlmIHlvdSBmb3Jn ZXQgaG93IGl0IGlzIHlvdSBhY3R1YWxseSBrbm93IHRoZXkgYXJlIHNlY3VyZS4gVGhlIHNvLWNh bGxlZCAmcXVvdDttYXRoZW1hdGljYWwmcXVvdDsgYmFzaXMgb2YgYWxsIHB1YmxpYy1rZXkgY3J5 cHRvZ3JhcGh5IHRoYXQgSSBrbm93IG9mIGlzIHRoZSBhc3N1bXB0aW9uIHRoYXQgc29tZSBvbmUt d2F5ICZxdW90O3RyYXBkb29yJnF1b3Q7IGZ1bmN0aW9uIGlzIGVhc3kgdG8gY29tcHV0ZSwgYnV0 IGl0cyBpbnZlcnNlIGlzIGNvbXB1dGF0aW9uYWxseSBpbmZlYXNpYmxlLiBZZXQgdGhlIGtub3ds ZWRnZSB0aGlzIHJlcHJlc2VudHMgaXMgbm90IGtub3dsZWRnZS4gSXQmIzM5O3MgY2VydGFpbmx5 IG5vdGhpbmcgdG8gZG8gd2l0aCBtYXRoZW1hdGljcy4gSXQgaXMgc2ltcGx5IHRoZSBhYnNlbmNl IG9mIGtub3dsZWRnZSB0byB0aGUgY29udHJhcnkuPGJyPjxicj5TbyB0aGVzZSBwcm90b2NvbHMg YXJlIHNlY3VyZSBzb2xlbHkgYmVjYXVzZSBvZiBfc29tZV8gcGVvcGxlJiMzOTtzIGNvbXBsZXRl IGlnbm9yYW5jZSBvZiBhbnkgZXZpZGVuY2UgdGhhdCB0aGV5IGFyZSBub3QhIEJ1dCBpZiBzb21l b25lIGhhZCBzdWNoIGNvbnRyYXJ5IGV2aWRlbmNlLCB3b3VsZCB5b3UgcmVhbGx5IGV4cGVjdCB0 aGVtIHRvIHRlbGwgdGhlIHdvcmxkPyBJIGFtIG5vdCBzdWdnZXN0aW5nIGZvciBvbmUgbWludXRl IHRoYXQgdGhlIE5TQSwgc2F5LCBoYXZlIGEgcG9seW5vbWlhbC10aW1lIHRpbWUgc29sdXRpb24g dG8gTlAtY29tcGxldGUgcHJvYmxlbXM6IHRoYXQgaXMgbm90IGV2ZW4gYSBuZWNlc3NhcnkgY29u ZGl0aW9uIGZvciB0aGVzZSBhbGdvcml0aG1zIGJlaW5nIGluc2VjdXJlLiBJIGFtIGp1c3Qgc2F5 aW5nIHRoYXQgdGhlcmUgaXMgbm90IGV2ZW4gYW55IHJlbW90ZWx5IHBsYXVzaWJsZSBqdXN0aWZp Y2F0aW9uIGZvciB0aGUgYmVsaWVmIHRoYXQgdGhlIGlnbm9yYW5jZSB3ZSBhcmUgYXNzdW1pbmcg ZXhpc3RzIGlzIGFjdHVhbGx5IHJlYWwhISEgV2UgYXJlIGlnbm9yYW50IG9mIHRoZSBpZ25vcmFu Y2UgYXMgd2VsbCBhcyB0aGUga25vd2xlZGdlISBUaGlzIGlzIHJlYWxseSBmdW5ueS4gUGVvcGxl IHNob3VsZCBsYXVnaCBhYm91dCBpdCBhIGxvdCBtb3JlIHRoYW4gdGhleSBkby48YnI+PGJyPjwv ZGl2PjxibG9ja3F1b3RlIGNsYXNzPSJnbWFpbF9xdW90ZSIgc3R5bGU9Im1hcmdpbjowcHggMHB4 IDBweCAwLjhleDtib3JkZXItbGVmdDoxcHggc29saWQgcmdiKDIwNCwyMDQsMjA0KTtwYWRkaW5n LWxlZnQ6MWV4Ij48ZGl2IGRpcj0ibHRyIj48ZGl2PjxkaXY+PGJyPjwvZGl2PjxkaXY+SSBtZWFu LCBmb3IgZWFjaCBkaXN0cmlidXRpb24gaW4gZWFjaCBhcmNoaXRlY3R1cmUsIHRoZXJlIGlzIGJh c2ljYWxseSBhIHNpbmdsZSBidWlsZCBjb25maWd1cmF0aW9uIHdoaWNoIG5lZWRzIHRvIGJlIGNl cnRpZmllZCBhcyAmcXVvdDt0cm9qYW4tZnJlZSZxdW90Oy4gQW5kIHRoaXMgaXMgYmFzaWNhbGx5 IGFscmVhZHkgaW1wbGVtZW50ZWQsIHByb3ZpZGVkIHRoYXQgSSBnZXQgbXkgY29tcGlsZXIgcGFj a2FnZSBmcm9tIGEgY2xlYW4gc291cmNlIHdoaWNoIHNpZ25lZCB0aGUgcGFja2FnZSwgYWxsIHRo YXQgaXMgbmVjZXNzYXJ5IGlzIHRoYXQgdGhlIGNsZWFuIHNvdXJjZSB0b29rIHNwZWNpYWwgY2Fy ZSBpbiBlbnN1cmluZyB0aGF0IHRoZWlyIHZlcnNpb24gaXMgaW4gZmFjdCBidWctZnJlZS4uLjwv ZGl2Pg0KPGRpdj48YnI+PC9kaXY+PGRpdj5UaGF0IHNvbHZlcyA5OSUgb2YgdGhlIHVzZS1jYXNl cywgd2hlbiB5b3UgdXNlIGEgc3RhbmRhcmQgY29tcGlsZXIgcHJvdmlkZWQgYnkgYSBjbGVhbiBz b3VyY2UuIEZvciB0aGUgcmVtYWluaW5nIC45OSUsIHdoZW4geW91IHVzZSBhIGN1c3RvbS1idWls dCBjb21waWxlciwgc2F5LCB5b3UgY291bGQgc3RhcnQgd2l0aCBhIGNvbXBpbGVyIGZyb20gYSBj bGVhbiBzb3VyY2UgYW5kIHVzZSB0aGF0IHRvIGNvbXBpbGUgeW91ciBjdXN0b20tYnVpbGQuLi4g Tm8gYnVnIGluamVjdGlvbiB3b3VsZCBoYXBwZW4gdGhlbi48L2Rpdj48L2Rpdj48L2Rpdj48L2Js b2NrcXVvdGU+PGRpdj48YnI+PC9kaXY+PGRpdj5Ib3cgZG8geW91IGtub3cgdGhhdD8gSWYgeW91 IGNhbiYjMzk7dCBrbm93IHdoYXQgdGhlIEMgY29tcGlsZXIgZGlkIHdoZW4gaXQgY29tcGlsZWQg dGhlIExpYnJlVExTIGNvZGUgdGhhdCBBcGFjaGUgcnVucywgb3IgdGhlIE9wZW5TU0wgQ0Egc2ln bmluZyBhcHAgb24gdGhlIE9wZW5CU0QgYm94IGluIHRoZSBvZmZpY2VzIG9mIHRoZSBjb21wYW55 IHdobyBzb2xkIHlvdSBhIGNlcnRpZmljYXRlPy4gPGJyPjwvZGl2PjxkaXY+wqA8L2Rpdj48Ymxv Y2txdW90ZSBjbGFzcz0iZ21haWxfcXVvdGUiIHN0eWxlPSJtYXJnaW46MHB4IDBweCAwcHggMC44 ZXg7Ym9yZGVyLWxlZnQ6MXB4IHNvbGlkIHJnYigyMDQsMjA0LDIwNCk7cGFkZGluZy1sZWZ0OjFl eCI+PGRpdiBkaXI9Imx0ciI+PGRpdj4NCjxkaXY+V291bGRuJiMzOTt0IHRoYXQgYmUgZW5vdWdo PyBGb3JtYWwgY2VydGlmaWNhdGlvbiBvZiB0aGUgY2xlYW5saW5lc3Mgb2YgdGhlIGNvbXBpbGVy IChpZiBJIHVuZGVyc3Rvb2QgY29ycmVjdGx5IGFuZCB0aGlzIGlzIHdoYXQgeW91IHByb3Bvc2Up IHNlZW1zIG92ZXItdGhlLXRvcCB0byBtZS48L2Rpdj48L2Rpdj48L2Rpdj48L2Jsb2NrcXVvdGU+ PGRpdj48YnI+Rm9ybWFsIHNlbWFudGljcyBhcmUgbm90IGFzIGJvcmluZyBhcyB0aGV5IHNvdW5k LiBJdCYjMzk7cyBhbGwgYWJvdXQgd3JpdGluZyByZWFsIGNvZGUgdGhhdCB3b3JrcywgYW5kIHdo aWNoIGludGVycHJldHMgbGFuZ3VhZ2VzIGFuZCBkb2VzIHN0dWZmLiBJdCYjMzk7cyBmdW4uIElm IHlvdSB0cnkgaXQsIHRoZW4gSSB0aGluayB5b3UmIzM5O2xsIGJlbGlldmUgbWUuIDwvZGl2Pjxk aXY+wqA8L2Rpdj48YmxvY2txdW90ZSBjbGFzcz0iZ21haWxfcXVvdGUiIHN0eWxlPSJtYXJnaW46 MHB4IDBweCAwcHggMC44ZXg7Ym9yZGVyLWxlZnQ6MXB4IHNvbGlkIHJnYigyMDQsMjA0LDIwNCk7 cGFkZGluZy1sZWZ0OjFleCI+PGRpdiBkaXI9Imx0ciI+PGRpdj48ZGl2PkhhcHB5IGhhY2tpbmcg Oi0pPC9kaXY+PC9kaXY+PC9kaXY+PC9ibG9ja3F1b3RlPjxkaXY+PGJyPjwvZGl2PjxkaXY+VGhh bmsgeW91ISBZb3UgdG9vLjxicj48YnI+PC9kaXY+PGRpdj5JYW48YnI+wqA8YnI+PC9kaXY+PGJs b2NrcXVvdGUgY2xhc3M9ImdtYWlsX3F1b3RlIiBzdHlsZT0ibWFyZ2luOjBweCAwcHggMHB4IDAu OGV4O2JvcmRlci1sZWZ0OjFweCBzb2xpZCByZ2IoMjA0LDIwNCwyMDQpO3BhZGRpbmctbGVmdDox ZXgiPjxkaXYgZGlyPSJsdHIiPjxkaXY+PGRpdj48YnI+PC9kaXY+PC9kaXY+PC9kaXY+PGRpdiBj bGFzcz0iZ21haWxfZXh0cmEiPjxicj48YnI+PGRpdiBjbGFzcz0iZ21haWxfcXVvdGUiPjxkaXY+ PGRpdiBjbGFzcz0iaDUiPk9uIDQgU2VwdGVtYmVyIDIwMTQgMTg6MzMsIElhbiBHcmFudCA8c3Bh biBkaXI9Imx0ciI+Jmx0OzxhIGhyZWY9Im1haWx0bzppYW4uYS5uLmdyYW50QGdvb2dsZW1haWwu Y29tIiB0YXJnZXQ9Il9ibGFuayI+aWFuLmEubi5ncmFudEBnb29nbGVtYWlsLmNvbTwvYT4mZ3Q7 PC9zcGFuPiB3cm90ZTo8YnI+DQo8L2Rpdj48L2Rpdj48YmxvY2txdW90ZSBjbGFzcz0iZ21haWxf cXVvdGUiIHN0eWxlPSJtYXJnaW46MHB4IDBweCAwcHggMC44ZXg7Ym9yZGVyLWxlZnQ6MXB4IHNv bGlkIHJnYigyMDQsMjA0LDIwNCk7cGFkZGluZy1sZWZ0OjFleCI+PGRpdj48ZGl2IGNsYXNzPSJo NSI+PGRpdiBkaXI9Imx0ciI+UGVyaGFwcyBwZW9wbGUgd291bGQgZW5qb3kgcmVhZGluZyBhYm91 dCBob3cgb25lIGNvdWxkIGluamVjdCB0cm9qYW48YnI+c2VtYW50aWNzIGludG8gYSBjb21waWxl ciBpbiBzdWNoIGEgd2F5IHRoYXQgdGhleSBoYXZlIHNvbWUgcmVzaWxpZW5jZTxicj4NCnRvIGFs bCBidXQgcXVpdGUgbWFqb3Igc3RydWN0dXJhbCBjaGFuZ2VzIHRvIHRoZSB0YXJnZXQgc291cmNl IGNvZGU/PGJyPg0KPGJyPlRoaXMgaXMgbm90IGp1c3QgZm9yIHRoZSBwdXJwb3NlcyBvZiBmcmln aHRlbmluZyB0aGUgYmlyZHMuIEl0IHdpbGw8YnI+c2hvdyBob3cgdXNlZnVsIHRvb2xzIHdoaWNo IGF1dG9tYXRpY2FsbHkgYW5hbHlzZSBhbmQgdHJhbnNmb3JtPGJyPnByb2dyYW0gc3ludGF4IGNv dWxkIGJlLiBJbWFnaW5lIHRoaXMgaW4gYSAmIzM5O3dob2xlIHByb2dyYW0mIzM5OyBJREUsIHNv PGJyPg0KdGhhdCBvbmUgY291bGQgcXVlcnkgY2VydGFpbiBjbGFzc2VzIG9mIHZhcmlhYmxlIGFz c2lnbm1lbnQgaW4gYW48YnI+DQpPcGVyYXRpbmcgU3lzdGVtIGtlcm5lbCwgc2F5LCBhbmQgcHJv Z3JhbSBnbG9iYWwgcmUtd3JpdGVzIGJhc2VkIG9uPGJyPnBhdHRlcm4gbWF0Y2hpbmcgb2Ygd2hv bGUgc3ludGFjdGljIHN0cnVjdHVyZXMsIHJhdGhlciB0aGFuIGp1c3QgdGhlPGJyPnN1Yi1sZXhp Y2FsIG1hdGNoaW5nIHdoaWNoIHJlZ3VsYXIgZXhwcmVzc2lvbnMgb2ZmZXIuPGJyPjxicj5IZXJl IGlzIGFuIGltcGxlbWVudGF0aW9uIG9mIGEgUHJvbG9nIGludGVycHJldGVyLiBUaGUgaW50ZXJw cmV0ZXI8YnI+DQoNCml0c2VsZiBpcyBvbmx5IDg4IGxpbmVzIG9mIFN0YW5kYXJkIE1MLiBNb3N0 IG9mIGl0IGlzIHdyaXR0ZW4gdXNpbmc8YnI+bGlzdCBmdW5jdGlvbmFscyBsaWtlIG1hcCwgZXhp c3RzLCBmaW5kLCBwYXJ0aXRpb24gZXRjLiBTbyBpdCBzaG91bGQ8YnI+YmUgY2xlYXIgdGhhdCBp dCBjb3VsZCBiZSBxdWl0ZSBlYXNpbHkgdHJhbnNsYXRlZCBpbnRvIGEgZmFpcmx5PGJyPmVmZmlj aWVudCBDIHByb2dyYW0uPGJyPg0KDQo8YnI+KCogKEFwYXJ0IGZyb20gdGhlICE9IHByZWRpY2F0 ZSkgVGhpcyBpcyBhIHRyYW5zbGl0ZXJhdGlvbiBvZiB0aGU8YnI+wqDCoCBQcm9sb2cgaW50ZXJw cmV0ZXIgaW4gSm9obiBIYXJyaXNvbiYjMzk7cyBDYW1icmlkZ2UgbGVjdHVyZSBub3Rlcy4gKik8 YnI+PGJyPmRhdGF0eXBlIHRlcm0gPTxicj7CoMKgIEZuIG9mIHN0cmluZyAqIHRlcm0gbGlzdDxi cj7CoHwgVmFyIG9mIHN0cmluZzxicj4NCg0KPGJyPmRhdGF0eXBlIG91dGNvbWUgPTxicj7CoMKg IFllcyBvZiAoc3RyaW5nICogdGVybSkgbGlzdDxicj7CoHwgTm88YnI+PGJyPmxvY2FsIG9wZW4g R3JhbW1hclN5bnRheDxicj7CoMKgIGZ1biBwYXJzZXIgc3RhcnRzeW1ib2wgPSA8YnI+wqDCoMKg wqDCoMKgIGxldCBmdW4gcGFyc2UgZmlsZSBzdHJlYW0gbGV4YnVmID08YnI+wqDCoMKgwqDCoMKg wqDCoMKgIGxldCB2YWwgZXhwciA9IHN0YXJ0c3ltYm9sIFByb2xvZ0xleGVyLlRva2VuIGxleGJ1 Zjxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgIGluIFBhcnNpbmcuY2xlYXJQYXJzZXIoKTs8YnI+ wqDCoCDCoMKgwqAgwqDCoMKgwqAgZXhwcjxicj7CoMKgwqDCoMKgwqDCoMKgwqAgZW5kIGhhbmRs ZSBleG4gPSZndDsgKFBhcnNpbmcuY2xlYXJQYXJzZXIoKTsgcmFpc2UgZXhuKTxicj7CoMKgwqDC oMKgwqAgaW4gcGFyc2UgZW5kPGJyPsKgwqAgZnVuIHByb2Nlc3NTdHJpbmcgcGZuID0gZm4gcyA9 Jmd0Ozxicj7CoMKgwqDCoMKgIHBmbiAmcXVvdDtzdHJpbmcmcXVvdDsgcyAoTGV4aW5nLmNyZWF0 ZUxleGVyU3RyaW5nIHMpPGJyPg0KDQrCoMKgIGZ1biBxbFRvU3RyaW5nIGwgPTxicj7CoMKgwqDC oMKgIGxldCBmdW4gaXRlciByIFtdID0gcjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwgaXRl ciByICgoUVVPVEUgcyk6OmZzKSA9IGl0ZXIgKHJecykgZnM8YnI+wqDCoMKgwqDCoMKgwqDCoMKg wqDCoCB8IGl0ZXIgciAoKEFOVElRVU9URSBzKTo6ZnMpID0gaXRlciAocl5zKSBmczxicj7CoMKg wqDCoMKgIGluIGl0ZXIgJnF1b3Q7JnF1b3Q7IGw8YnI+wqDCoMKgwqDCoCBlbmQ8YnI+wqDCoCB2 YWwgcGFyc2VydWxlc3EgPSBwcm9jZXNzU3RyaW5nIChwYXJzZXIgUHJvbG9nUGFyc2VyLkZpbGUp IG8gcWxUb1N0cmluZzxicj4NCg0KwqDCoCB2YWwgcGFyc2V0ZXJtcSA9IHByb2Nlc3NTdHJpbmcg KHBhcnNlciBQcm9sb2dQYXJzZXIuT25lVGVybSkgbyBxbFRvU3RyaW5nPGJyPsKgwqAgZnVuIGZh aWxzIHMgdCA9IChwcmludFRyZWUgdDtyYWlzZSBGYWlsIChzXiZxdW90Ozogbm8gY2FzZS4mcXVv dDspKTxicj7CoMKgIGZ1biBta1Rlcm0gKE5vblRlcm0oJnF1b3Q7YXRvbSZxdW90Oyw8YnI+wqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgW05vblRlcm0oJnF1b3Q7 Y29uc3RhbnQmcXVvdDssPGJyPg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBbVGVybShuYW1lKV0pLDxicj7CoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGwgYXMgTm9uVGVybSgmcXVvdDt0 ZXJtLWxpc3QmcXVvdDssXyldKSk8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqAgPSBGbihuYW1lLG1r QXJncyBsKTxicj7CoMKgwqDCoCB8IG1rVGVybSAoTm9uVGVybSgmcXVvdDthdG9tJnF1b3Q7LFtO b25UZXJtKCZxdW90O2NvbnN0YW50JnF1b3Q7LFtUZXJtKG5hbWUpXSldKSk8YnI+DQoNCsKgwqDC oMKgwqDCoMKgwqDCoMKgID0gRm4obmFtZSxbXSk8YnI+wqDCoMKgwqAgfCBta1Rlcm0gKE5vblRl cm0oJnF1b3Q7YXRvbSZxdW90OyxbTm9uVGVybSgmcXVvdDt2YXJpYWJsZSZxdW90OyxbVGVybShu YW1lKV0pXSkpPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgID0gVmFyKG5hbWUpPGJyPsKgwqDCoMKg IHwgbWtUZXJtIChOb25UZXJtKCZxdW90O2F0b20mcXVvdDssW2wgYXMgTm9uVGVybSgmcXVvdDts aXN0JnF1b3Q7LF8pXSkpPGJyPg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDCoCA9IG1rTGlzdChsKTxi cj7CoMKgwqDCoCB8IG1rVGVybSB0ID0gZmFpbHMgJnF1b3Q7bWtUZXJtJnF1b3Q7IHQ8YnI+wqDC oCBhbmQgbWtMaXN0IChOb25UZXJtKCZxdW90O2xpc3QmcXVvdDssW2EgYXMgTm9uVGVybSgmcXVv dDthdG9tJnF1b3Q7LF8pLDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgbCBhcyBOb25UZXJtKCZxdW90O2xpc3QmcXVvdDssXyld KSk8YnI+DQoNCsKgwqDCoMKgwqDCoMKgwqDCoMKgID0gRm4oJnF1b3Q7LiZxdW90OyxbbWtUZXJt IGEsbWtMaXN0IGxdKTxicj7CoMKgwqDCoCB8IG1rTGlzdCAoTm9uVGVybSgmcXVvdDtsaXN0JnF1 b3Q7LFthIGFzIE5vblRlcm0oJnF1b3Q7YXRvbSZxdW90OyxfKV0pKTxicj7CoMKgwqDCoMKgwqDC oMKgwqDCoCA9IEZuKCZxdW90Oy4mcXVvdDssW21rVGVybSBhLEZuKCZxdW90O1tdJnF1b3Q7LFtd KV0pPGJyPsKgwqDCoMKgIHwgbWtMaXN0IChOb25UZXJtKCZxdW90O2xpc3QmcXVvdDssW2EgYXMg Tm9uVGVybSgmcXVvdDthdG9tJnF1b3Q7LF8pLDxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGEmIzM5OyBhcyBOb25UZXJt KCZxdW90O2F0b20mcXVvdDssXyldKSk8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqAgPSBGbigmcXVv dDsuJnF1b3Q7LFtta1Rlcm0gYSxta1Rlcm0gYSYjMzk7XSk8YnI+wqDCoMKgwqAgfCBta0xpc3Qg KE5vblRlcm0oJnF1b3Q7bGlzdCZxdW90OyxbXSkpPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgID0g Rm4oJnF1b3Q7W10mcXVvdDssW10pPGJyPg0KwqDCoMKgwqAgfCBta0xpc3QgdCA9wqAgZmFpbHMg JnF1b3Q7bWtMaXN0JnF1b3Q7IHQ8YnI+DQrCoMKgIGFuZCBta0FyZ3MgKE5vblRlcm0oJnF1b3Q7 dGVybS1saXN0JnF1b3Q7LFthIGFzIE5vblRlcm0oJnF1b3Q7YXRvbSZxdW90OyxfKSw8YnI+wqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoCBsIGFzIE5vblRlcm0oJnF1b3Q7dGVybS1saXN0JnF1b3Q7LF8pXSkpPGJyPsKg wqDCoMKgwqDCoMKgwqDCoMKgID0gKG1rVGVybSBhKTo6KG1rQXJncyBsKTxicj7CoMKgwqDCoCB8 IG1rQXJncyAoTm9uVGVybSgmcXVvdDt0ZXJtLWxpc3QmcXVvdDssW2EgYXMgTm9uVGVybSgmcXVv dDthdG9tJnF1b3Q7LF8pXSkpPGJyPg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDCoCA9IFtta1Rlcm0g YV08YnI+wqDCoMKgwqAgfCBta0FyZ3MgdCA9IGZhaWxzICZxdW90O21rQXJncyZxdW90OyB0PGJy PsKgwqAgZnVuIG1rVGVybXMgKE5vblRlcm0oJnF1b3Q7dGVybXMmcXVvdDssW2EgYXMgTm9uVGVy bSgmcXVvdDthdG9tJnF1b3Q7LF8pLDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHRzIGFzIE5vblRlcm0oJnF1b3Q7dGVy bXMmcXVvdDssXyldKSk8YnI+DQoNCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgID0g KG1rVGVybSBhKTo6KG1rVGVybXMgdHMpPGJyPsKgwqDCoMKgIHwgbWtUZXJtcyAoTm9uVGVybSgm cXVvdDt0ZXJtcyZxdW90OyxbYSBhcyBOb25UZXJtKCZxdW90O2F0b20mcXVvdDssXyldKSk8YnI+ wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgPSBbbWtUZXJtIGFdPGJyPsKgwqDCoMKg IHwgbWtUZXJtcyB0ID3CoCBmYWlscyAmcXVvdDtta1Rlcm1zJnF1b3Q7IHQ8YnI+wqDCoCBhbmQg bWtSdWxlIChOb25UZXJtKCZxdW90O3J1bGUmcXVvdDssW2EgYXMgTm9uVGVybSgmcXVvdDthdG9t JnF1b3Q7LF8pLDxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIHRzIGFzIE5vblRlcm0oJnF1b3Q7dGVybXMmcXVvdDssXyld KSk8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgPSAobWtUZXJtIGEsIG1rVGVy bXMgdHMpPGJyPsKgwqDCoMKgIHwgbWtSdWxlIChOb25UZXJtKCZxdW90O3J1bGUmcXVvdDssW2Eg YXMgTm9uVGVybSgmcXVvdDthdG9tJnF1b3Q7LF8pXSkpPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgID0gKG1rVGVybSBhLFtdKTxicj4NCg0KwqDCoMKgwqAgfCBta1J1bGUgdCA9 IGZhaWxzICZxdW90O21rUnVsZSZxdW90OyB0PGJyPsKgwqAgYW5kIG1rUnVsZXMgKE5vblRlcm0o JnF1b3Q7cnVsZS1saXN0JnF1b3Q7LFtsIGFzIE5vblRlcm0oJnF1b3Q7cnVsZS1saXN0JnF1b3Q7 LF8pLDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgciBhcyBOb25UZXJtKCZxdW90O3J1bGUmcXVvdDssXyld KSk8YnI+wqDCoMKgwqDCoMKgwqDCoCA9IChta1J1bGUocikpOjoobWtSdWxlcyBsKTxicj4NCg0K wqDCoMKgwqAgfCBta1J1bGVzIChOb25UZXJtKCZxdW90O3J1bGUtbGlzdCZxdW90OyxbciBhcyBO b25UZXJtKCZxdW90O3J1bGUmcXVvdDssXyldKSk8YnI+wqDCoMKgwqDCoMKgwqDCoCA9IFtta1J1 bGUocildPGJyPsKgwqDCoMKgIHwgbWtSdWxlcyB0ID0gZmFpbHMgJnF1b3Q7bWtSdWxlcyZxdW90 OyB0PGJyPmluPGJyPsKgwqAgdmFsIHJ1bGVzID0gTGlzdC5yZXYgbyBta1J1bGVzIG8gcGFyc2Vy dWxlc3E8YnI+wqDCoCB2YWwgZ29hbCA9IG1rVGVybSBvIHBhcnNldGVybXE8YnI+DQoNCmVuZDxi cj48YnI+bG9jYWw8YnI+wqDCoCBmdW4gb2NjdXJzX2luIHggPTxicj7CoMKgwqDCoMKgIGZuIChW YXIgeSkgPSZndDsgeCA9IHk8YnI+wqDCoMKgwqDCoMKgIHwgKEZuKF8sbCkpID0mZ3Q7IExpc3Qu ZXhpc3RzIChvY2N1cnNfaW4geCkgbDxicj7CoMKgIGZ1biBhc3NvYyBpID08YnI+wqDCoMKgwqDC oCAoT3B0aW9uLm1hcCAoZm4gKF8sdikgPSZndDsgdikpIG8gKExpc3QuZmluZCAoZm4gKGssXykg PSZndDsgayA9IGkpKTxicj4NCg0KwqDCoCBmdW4gc3VicyBpbnN0cyA9PGJyPsKgwqDCoMKgIGZu ICh0bSBhcyAoVmFyIHkpKSA9Jmd0Ozxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoCAoY2FzZSBhc3Nv YyB5IGluc3RzIG9mIE5PTkUgPSZndDsgdG0gfCBTT01FIHYgPSZndDsgdik8YnI+wqDCoMKgwqDC oCB8IChGbihzLGwpKSA9Jmd0Ozxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoCBGbihzLExpc3QubWFw IChzdWJzIGluc3RzKSBsKTxicj7CoMKgIGZ1biBhdWdtZW50MSB0aGV0YSAoeCxzKSA9PGJyPg0K DQrCoMKgwqDCoMKgIGxldCB2YWwgcyYjMzk7ID0gc3VicyB0aGV0YSBzPGJyPsKgwqDCoMKgwqAg aW4gaWYgb2NjdXJzX2luIHggcyBhbmRhbHNvIG5vdCAocyA9IFZhcih4KSk8YnI+wqDCoMKgwqDC oMKgwqDCoMKgwqDCoCB0aGVuIHJhaXNlIEZhaWwgJnF1b3Q7T2NjdXJzIGNoZWNrLiZxdW90Ozxi cj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGVsc2UgKHgscyYjMzk7KTxicj7CoMKgwqDCoMKgIGVu ZDxicj7CoMKgIGZ1biByYXdfYXVnbWVudCBwIGluc3RzID0gcDo6KExpc3QubWFwIChhdWdtZW50 MSBbcF0pIGluc3RzKTxicj4NCg0KwqDCoCBmdW4gYXVnbWVudCAodix0KSBpbnN0cyA9PGJyPsKg wqDCoMKgwqAgbGV0IHZhbCB0JiMzOTsgPSBzdWJzIGluc3RzIHQ8YnI+wqDCoMKgwqDCoCBpbiBj YXNlIHQmIzM5Ozxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoCBvZiBWYXIgKHcpID0mZ3Q7IDxicj7C oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaWYgdyAmbHQ7PSB2IDxicj7CoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHRoZW4gaWYgdyA9IHY8YnI+wqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdGhlbiBpbnN0czxicj4NCg0KwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZWxzZSByYXdf YXVnbWVudCAodix0JiMzOTspIGluc3RzPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqAgZWxzZSByYXdfYXVnbWVudCAodyxWYXIodikpIGluc3RzIDxicj7CoMKgwqDCoMKgwqDC oMKgwqDCoMKgIHwgXyA9Jmd0OyBpZiBvY2N1cnNfaW4gdiB0JiMzOTsgPGJyPsKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0aGVuIHJhaXNlIEZhaWwgJnF1b3Q7T2Nj dXJzIGNoZWNrLiZxdW90Ozxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIGVsc2UgcmF3X2F1Z21lbnQgKHYsdCYjMzk7KSBpbnN0czxicj7CoMKgwqDCoMKg IGVuZDxicj7CoMKgwqAgZnVuIGl0bGlzdDIgZiA9PGJyPsKgwqDCoMKgwqAgbGV0IGZ1biBpdGVy IFtdIFtdID0gKGZuIGIgPSZndDsgYik8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8IGl0ZXIg KGg6OnQpIChoJiMzOTs6OnQmIzM5OykgPSAoZm4gYiA9Jmd0OyBmIGggaCYjMzk7IChpdGxpc3Qy IGYgdCB0JiMzOTsgYikpPGJyPg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwgaXRlciBfIF8g PSByYWlzZSBGYWlsICZxdW90O0FyaXR5LiZxdW90Ozxicj7CoMKgwqDCoMKgIGluIGl0ZXI8YnI+ wqDCoMKgwqDCoCBlbmQ8YnI+wqDCoCBmdW4gdW5pZnkgdG0xIHRtMiBpbnN0cyA9PGJyPsKgwqDC oMKgwqAgY2FzZSB0bTE8YnI+wqDCoMKgwqDCoMKgwqAgb2YgVmFyKHgpID0mZ3Q7IDxicj7CoMKg wqDCoMKgwqDCoMKgwqDCoCAoY2FzZSBhc3NvYyB4IGluc3RzPGJyPsKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIG9mIE5PTkUgPSZndDsgYXVnbWVudCAoeCx0bTIpIGluc3RzPGJyPg0KDQrCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwgU09NRSB0bTEmIzM5OyA9Jmd0OyB1bmlmeSB0bTEm IzM5OyB0bTIgaW5zdHMpPGJyPsKgwqDCoMKgwqDCoMKgwqAgfCBGbihmMSxhcmdzMSkgPSZndDs8 YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqAgKGNhc2UgdG0yPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgIG9mIChWYXIoeSkpID0mZ3Q7IDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCAoY2FzZSBhc3NvYyB5IGluc3RzPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIG9mIE5PTkUgPSZndDsgYXVnbWVudCAoeSx0bTEpIGluc3RzPGJyPg0KDQrCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwgU09NRSB0bTImIzM5OyA9Jmd0 OyB1bmlmeSB0bTEgdG0yJiMzOTsgaW5zdHMpPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgfCBGbihmMixhcmdzMikgPSZndDs8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgIGlmIGYxID0gZjIgdGhlbiBpdGxpc3QyIHVuaWZ5IGFyZ3MxIGFyZ3MyIGluc3RzPGJy PsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgZWxzZSByYWlzZSBGYWlsICgmcXVvdDtDb25zdGFudHM6IG1pc21hdGNoOiAmcXVvdDteZjFe JnF1b3Q7Jmx0OyZndDsmcXVvdDteZjIpKTxicj4NCg0KwqDCoCBmdW4gcmVuYW1lIHMgPTxicj7C oMKgwqDCoMKgIGZuIChWYXIgdikgPSZndDsgVmFyKCZxdW90O34mcXVvdDtedl5zKTxicj7CoMKg wqDCoMKgwqAgfCAoRm4oZixhcmdzKSkgPSZndDsgRm4oZixMaXN0Lm1hcCAocmVuYW1lIHMpIGFy Z3MpPGJyPsKgwqAgZnVuIHJlbmFtZV9ydWxlIHMgKGNvbmMsYXNzdW1zKSA9PGJyPsKgwqDCoMKg wqDCoCAocmVuYW1lIHMgY29uYyxMaXN0Lm1hcCAocmVuYW1lIHMpIGFzc3Vtcyk8YnI+DQoNCsKg wqAgZnVuIGV4cGFuZCBuIHJ1bGVzIGluc3RzIGdvYWxzID08YnI+wqDCoMKgwqDCoCBsZXQgZnVu IGZpcnN0IGYgPTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgKGZuIFtdID0mZ3Q7 IHJhaXNlIEZhaWwgJnF1b3Q7Tm8gcnVsZXMgYXBwbHkuJnF1b3Q7PGJyPsKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgfCAoaDo6dCkgPSZndDsgKGYgaCBoYW5kbGUgRmFpbCBfID0m Z3Q7IGZpcnN0IGYgdCkpPGJyPsKgwqDCoMKgwqDCoMKgwqDCoCBmdW4gc2VhcmNoIHJ1bGUgPSA8 YnI+DQoNCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpZiBnb2FscyA9IFtdPGJyPsKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0aGVuIGluc3RzPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoCBlbHNlPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBs ZXQgZnVuIGVxZ29hbCAoRm4oJnF1b3Q7IT0mcXVvdDssW2EsYl0pKSA9IG5vdCAoYSA9IGIpPGJy PsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8IGVxZ29h bCBfID0gZmFsc2U8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgdmFsIChjb25jLGFzc3VtcykgPSByZW5hbWVfcnVsZSAoSW50LnRvU3RyaW5nIG4pIHJ1bGU8 YnI+DQoNCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHZhbCBn b2FsID0gaGQgZ29hbHM8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqAgdmFsIGluc3RzJiMzOTsgPSBpZiBlcWdvYWwgZ29hbDxicj7CoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIHRoZW4gaW5zdHMgKCogQ0hFQ0shIFRoaXMgaXMgcHJvYmFibHkgd3JvbmcuICopPGJyPsKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqAgZWxzZSB1bmlmeSBjb25jIGdvYWwgaW5zdHM8YnI+DQoNCsKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGZ1biBvY2N1cnMgKHYsXykg PSBvY2N1cnNfaW4gdiBjb25jPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIG9yZWxzZSBMaXN0LmV4aXN0cyAob2Nj dXJzX2luIHYpIGFzc3Vtczxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCB2YWwgKGxvYyxnbG9iKSA9IExpc3QucGFydGl0aW9uIG9jY3VycyBpbnN0cyYjMzk7 PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHZhbCBnb2Fs cyYjMzk7ID0gKExpc3QubWFwIChzdWJzIGxvYykgYXNzdW1zKSBAICh0bCBnb2Fscyk8YnI+DQoN CsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpbiBleHBhbmQgKG4rMSkgcnVs ZXMgZ2xvYiBnb2FscyYjMzk7PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBlbmQ8YnI+wqDCoMKgwqDCoCBpbjxicj7CoMKgwqDCoMKgwqDCoMKgIGZpcnN0IHNlYXJjaCBy dWxlczxicj7CoMKgwqDCoMKgIGVuZDxicj5pbjxicj7CoMKgIGZ1biBwcm9sb2cgcnVsZXMgZ29h bCA9PGJyPsKgwqDCoMKgwqAgbGV0IHZhbCBpbnN0cyA9IGV4cGFuZCAwIHJ1bGVzIFtdIFtnb2Fs XTxicj4NCg0KwqDCoMKgwqDCoCBpbiBZZXMgKExpc3QuZmlsdGVyIChmbiAodixfKSA9Jmd0OyBv Y2N1cnNfaW4gdiBnb2FsKSBpbnN0cyk8YnI+wqDCoMKgwqDCoCBlbmQgaGFuZGxlIEZhaWwgXyA9 Jmd0OyBObzxicj5lbmQ8YnI+PGJyPkhlcmUgaXMgYW4gZXhhbXBsZSBvZiB3aGF0IGl0IGNhbiBk byAoYSByYXRoZXIgdGlyZWQgb2xkIG9uZSwgYnV0IGJlYXI8YnI+d2l0aCB1cywgYmVjYXVzZSB3 ZSB3aWxsIHNob3J0bHkgcmVpbnRlcnByZXQgdGhpcyBhcyBzb21ldGhpbmc8YnI+DQoNCm1vcmUg aW50ZXJlc3RpbmcpOjxicj48YnI+dmFsICgpID0gbG9hZCAmcXVvdDtQcm9sb2cmcXVvdDs7PGJy Pjxicj52YWwgKCkgPSBNZXRhLnF1b3RhdGlvbiA6PSB0cnVlOzxicj48YnI+dmFsIHJzID0gUHJv bG9nLnJ1bGVzIGA8YnI+wqDCoCBtYWxlKGFsYmVydCkuPGJyPsKgwqAgbWFsZShlZHdhcmQpLjxi cj48YnI+wqDCoCBmZW1hbGUoYWxpY2UpLjxicj7CoMKgIGZlbWFsZSh2aWN0b3JpYSkuPGJyPg0K DQo8YnI+wqDCoCBmYXRoZXJfb2YoYWxiZXJ0LGVkd2FyZCkuPGJyPsKgwqAgZmF0aGVyX29mKGFs YmVydCxhbGljZSkuPGJyPjxicj7CoMKgIG1vdGhlcl9vZih2aWN0b3JpYSxlZHdhcmQpLjxicj7C oMKgIG1vdGhlcl9vZih2aWN0b3JpYSxhbGljZSkuPGJyPjxicj7CoMKgIHBhcmVudHMoWCxNLEYp Oi1tb3RoZXJfb2YoTSxYKSxmYXRoZXJfb2YoRixYKS48YnI+PGJyPsKgwqAgc2lzdGVyX29mKFgs WSk6LTxicj4NCg0KwqDCoMKgwqDCoCBmZW1hbGUoWCksPGJyPsKgwqDCoMKgwqAgcGFyZW50cyhY LE0sRiksPGJyPsKgwqDCoMKgwqAgcGFyZW50cyhZLE0sRikuPGJyPjxicj7CoMKgIGJyb3RoZXJf b2YoWCxZKTotPGJyPsKgwqDCoMKgwqAgIT0oWCxZKSw8YnI+wqDCoMKgwqDCoCBtYWxlKFgpLDxi cj7CoMKgwqDCoMKgIHBhcmVudHMoWCxNLEYpLDxicj7CoMKgwqDCoMKgIHBhcmVudHMoWSxNLEYp Ljxicj5gOzxicj48YnI+VGhpcyBkZWZpbmVzIGEgZGF0YWJhc2Ugb2YgZmFjdHMsIHRoZSBzby1j YWxsZWQgZ3JvdW5kIHRlcm1zLCB3aGljaDxicj4NCg0KYXJlIHRob3NlIHdoaWNoIGRvbiYjMzk7 dCBjb250YWluIGFueSBsb2dpY2FsIHZhcmlhYmxlcyAod2hpY2ggaW4gUHJvbG9nPGJyPmFyZSB0 eXBpY2FsbHkgYWxsLXVwcGVyLWNhc2UgaWRlbnRpZmllcnMpLiBUaGVuIHRoZXJlIGFyZSBfcnVs ZXNfPGJyPndoaWNoIGRlZmluZSByZWxhdGlvbnMgKGluIHRoZSBzZXQtdGhlb3JldGljYWwgc2Vu c2Ugb2YgdGhlIHRlcm0sIGJ1dDxicj5oZXJlIGFsc28gaW4gdGhlIGdlbmVhbG9naWNhbCBzZW5z ZSkuPGJyPg0KDQo8YnI+Tm90ZSB0aGF0IHRoZSB0d28tcGxhY2UgcHJlZGljYXRlIHNpc3Rlcl9v ZiBpcyBpbmRpcmVjdGx5IGRlZmluZWQgaW48YnI+dGVybXMgYW5vdGhlciBydWxlLCB3aGljaCBk ZWZpbmVzIHRoZSBwYXJlbnRzIHJlbGF0aW9uLiBCdXQgdGhlc2UgODg8YnI+bGluZXMgb2YgY29k ZSB3aWxsIHJlc29sdmUgdGhlIGluZGlyZWN0aW9uIGFuZCBzbyB0aGV5IGNhbiBjb3JyZWN0bHk8 YnI+DQpkZWR1Y2UsIGZvciBleGFtcGxlOjxicj4NCjxicj7CoMKgIHZhbCBnID0gUHJvbG9nLmdv YWwgYHNpc3Rlcl9vZihhbGljZSxlZHdhcmQpYDxicj7CoMKgIHZhbCByID0gUHJvbG9nLnByb2xv ZyBycyBnPGJyPjxicj5naXZpbmcgPGJyPjxicj7CoCB2YWwgciA9IFByb2xvZy5ZZXMgW10gOiBv dXRjb21lPGJyPjxicj5Ob3cgbG9vayBhdCB0aGUgZGF0YWJhc2Ugb2YgZmFjdHMsIGFuZCBub3Rl IHRoYXQgaXQgaXMgcmVhbGx5IGp1c3QgYW48YnI+DQoNCmFic3RyYWN0IHN5bnRheCByZXByZXNl bnRhdGlvbiBvZiBhIGNvbGxlY3Rpb24gb2Ygc3RhdGVtZW50cyBpbiBhbjxicj5hcmJpdHJhcnkg bGFuZ3VhZ2UgKGkuZS4gYSBsYW5ndWFnZSB3aXRoIHVuZGVmaW5lZCBzeW50YXgpLiBUaGVyZWZv cmU8YnI+b25lIGNhbiBhcHBseSBQcm9sb2cgZGVkdWN0aW9ucywgcXVpdGUgdHJpdmlhbGx5LCB0 byBzZW50ZW5jZXMgaW4gYTxicj5kZWZpbmVkIHByb2dyYW1taW5nIGxhbmd1YWdlIHN1Y2ggYXMg Qy4gTm93IHRoZSBDIGNvbXBpbGVyLCB3aGljaCB3ZTxicj4NCg0KaW1hZ2luZSB3ZSBhcmUgYXR0 YWNraW5nLCBhbHJlYWR5IGhhcyBhbGwgdGhlIGNvZGUgdG8gYW5hbHlzZSBhbmQ8YnI+bWFuaXB1 bGF0ZSBhYnN0cmFjdCBzeW50YXggcmVwcmVzZW50YXRpb25zIG9mIEMgcHJvZ3JhbXMsIGJlY2F1 c2UgdGhhdDxicj5pcyBpdHMgam9iISBTbyBJIGhvcGUgcGVvcGxlIGNhbiBzZWUsIHdpdGhvdXQg bXkgaGF2aW5nIHRvIGluc3RhbGwgaXQ8YnI+aW50byBHQ0MgNC45LCB0aGF0IG9uZSBjYW4gZWFz aWx5IGltcGxlbWVudCBhIFByb2xvZyBpbnRlcnByZXRlciBpbjxicj4NCg0KdmVyeSBsaXR0bGUg Y29kZSwgd2hpY2ggY2FuIGRlY2lkZSBhIHF1aXRlIGdlbmVyYWwgY2xhc3Mgb2YgcHJlZGljYXRl czxicj5jb25jZXJuaW5nIGEgcHJvZ3JhbSwgdGhlIHN0cnVjdHVyZSBvZiB3aGljaCBpcyByZXBy ZXNlbnRlZCBpbiB0aGU8YnI+Y29tcGlsZXIgYXMgYWJzdHJhY3Qgc3ludGF4Ljxicj48YnI+Tm93 IG5vdGUgdGhhdCB0aGUgcHJlZGljYXRlcyBuZWVkIG5vdCBoYXZlIGEgZml4ZWQgJiMzOTtkZXB0 aC4mIzM5OyBIZXJlIGFyZTxicj4NCg0KdHdvIHJ1bGVzIGRlZmluaW5nIGEgcGF0aCBpbiBhbiBh cmJpdHJhcnkgZGlyZWN0ZWQgZ3JhcGgsIHdoaWNoIGlzIGE8YnI+bm9uLXdlbGxmb3VuZGVkIHN0 cnVjdHVyZSBjYXBhYmxlIG9mIHJlcHJlc2VudGluZyBhbG1vc3QgYW55dGhpbmcsPGJyPmluY2x1 ZGluZyB0aGUgc2VudGVuY2VzIG9mIGFueSBsYW5ndWFnZSBkZWZpbmVkIGJ5IGEgY29udGV4dC1m cmVlPGJyPmdyYW1tYXIuPGJyPg0KDQo8YnI+SGVyZSB0aGUgZ3JvdW5kIHRlcm1zIHJlcHJlc2Vu dCBhIGdyYXBoIGluIHRocmVlIGRpc2pvaW50IHBhcnRzLCB3aXRoPGJyPnR3byBjeWNsZXMuPGJy Pjxicj52YWwgcnMmIzM5OyYjMzk7ID0gUHJvbG9nLnJ1bGVzIGA8YnI+wqDCoCBlZGdlKGcsaCku PGJyPsKgwqAgZWRnZShlLGYpLjxicj7CoMKgIGVkZ2UoZixlKS48YnI+wqDCoCBlZGdlKGEsYiku PGJyPsKgwqAgZWRnZShiLGMpLjxicj7CoMKgIGVkZ2UoYyxkKS48YnI+DQoNCsKgwqAgZWRnZShk LGEpLjxicj7CoMKgIHBhdGgoQSxCKTotZWRnZShBLEIpLjxicj7CoMKgIHBhdGgoQSxCKTotZWRn ZShBLEMpLHBhdGgoQyxCKS48YnI+YDs8YnI+PGJyPlByb2xvZyBjYW4gZGV0ZXJtaW5lIHdoZXRo ZXIgb3Igbm90IHRoZXJlIGlzIGEgcGF0aCBmcm9tIG9uZSB2ZXJ0ZXggdG88YnI+YW5vdGhlciwg bm8gbWF0dGVyIGhvdyBmYXIgYXBhcnQgdGhleSBtYXkgYmU6PGJyPjxicj4NCsKgwqAgdmFsIGcy ID0gUHJvbG9nLmdvYWwgYHBhdGgoYSxkKWA8YnI+DQrCoMKgIHZhbCByMiA9IFByb2xvZy5wcm9s b2cgcnMmIzM5OyYjMzk7IGcyPGJyPjxicj5JdCBwcmludHM8YnI+PGJyPsKgIHZhbCByMiA9IFBy b2xvZy5ZZXMgW10gOiBvdXRjb21lPGJyPjxicj5BbmQgaXQgY2FuIHRlbGwgd2hpY2ggdmVydGlj ZXMgYXJlIHJlYWNoYWJsZSBmcm9tIGEgZ2l2ZW4gdmVydGV4Ojxicj48YnI+wqDCoCB2YWwgZzMg PSBQcm9sb2cuZ29hbCBgcGF0aChiLFgpYDxicj4NCsKgwqAgdmFsIHIzID0gUHJvbG9nLnByb2xv ZyBycyYjMzk7JiMzOTsgZzM8YnI+DQo8YnI+VGhlIHJlc3VsdCBpczxicj48YnI+wqAgdmFsIHIz ID0gUHJvbG9nLlllcyBbKCZxdW90O1gmcXVvdDssIFByb2xvZy5GbigmcXVvdDtjJnF1b3Q7LCBb XSkpXSA6IG91dGNvbWU8YnI+PGJyPkluIHRoaXMgaW1wbGVtZW50YXRpb24gaXQgb25seSBwcmlu dHMgdGhlIGZpcnN0IHN1Y2ggZWRnZSwgYnV0IGl0PGJyPmNvdWxkIGZpbmQgdGhlbSBhbGwuPGJy Pjxicj5TbyBpdCBzaG91bGQgbm90IHJlcXVpcmUgYW55IGdyZWF0IHN0cmV0Y2hpbmcgb2YgcGVv cGxlJiMzOTtzIGNyZWR1bGl0eSB0bzxicj4NCg0Kc2VlIHRoYXQgYSB2ZXJ5IGZldyBsaW5lcyBv ZiBpbnRlbGxpZ2VudGx5IHdyaXR0ZW4gY29kZSBjYW4gcmVjb2duaXNlPGJyPmxhcmdlLXNjYWxl IHN0cnVjdHVyZSBpbiBhYnN0cmFjdCBzeW50YXgsIGV2ZW4gd2hlbiBxdWl0ZSBleHRlbnNpdmU8 YnI+Y2hhbmdlcyBtYXkgaGF2ZSBiZWVuIG1hZGUgdG8gdGhlIGxlYXZlcy48YnI+PGJyPk5vdyB3 ZSBuZWVkIHRvIHNob3cgaXQgY291bGQgcmUtd3JpdGUgdGhvc2UgcHJvZ3JhbXMuIFRoaXMgaXMg ZWFzeSw8YnI+DQoNCmJlY2F1c2UgaW4gZmFjdCBhIEMgY29tcGlsZXIgYWxyZWFkeSBkb2VzIHRo aXMuIEl0IGhhcyB0bywgYmVjYXVzZSB0aGU8YnI+c3ludGF4IG9mIEMgaXMgbm90IHN1ZmZpY2ll bnQgdG8gZGV0ZXJtaW5lIHdoYXQgaXMgYSB3ZWxsLWZvcm1lZCBDPGJyPnByb2dyYW0gYW5kIHdo YXQgaXMgbm90LiBIZXJlIGlzIGFuIGV4YW1wbGUgb2YgcHJvZ3JhbW1lZCByZS13cml0aW5nPGJy Pm9mIGFyYml0cmFyeSBmcmFnbWVudHMgb2YgYSBDIHByb2dyYW0uIFdoYXQgdGhpcyBkb2VzIGlz IHNwbGl0IGE8YnI+DQoNCmNvbXBvdW5kIHR5cGVkZWYgc3RhdGVtZW50IChhbnkgY29tcG91bmQg dHlwZWRlZiBzdGF0ZW1lbnQgd2hhdHNvZXZlcik8YnI+aW50byBzZXBhcmF0ZSBwYXJ0czo8YnI+ PGJyPsKgwqAgdmFsIHJld3JpdGVfdHlwZWRlZiA9PGJyPsKgwqDCoMKgwqDCoMKgwqAgcmV3cml0 ZXEgYDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIOKfpmRlY2xhcmF0aW9uPGJyPsKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAg4oycdzpkZWNsYXJhdGlvbi1zcGVjaWZpZXJz4oydPGJyPg0K DQrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIChpbml0LWRlY2xhcmF0b3ItbGlzdDxicj7C oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIOKMnHg6aW5pdC1kZWNsYXJhdG9yLWxp c3TijJ08YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCDijJx5OmluaXQtZGVj bGFyYXRvcuKMnSnin6cgPTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIChkZWNsYXJh dGlvbi1saXN0PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgKGRlY2xhcmF0 aW9uLWxpc3Q8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCDin6Zk ZWNsYXJhdGlvbiDijJx34oydIOKMnHjijJ3in6cpPGJyPg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIChkZWNsYXJhdGlvbiDijJx34oydIChpbml0LWRlY2xhcmF0b3ItbGlz dCDijJx54oydKSkpYDxicj48YnI+U28gdGFraW5nIHRoaXMgdHlwZWRlZjo8YnI+PGJyPsKgwqAg dmFsIHRkID0gYWJzeW50cSBgdHlwZWRlZiB1bnNpZ25lZCBpbnQgdWksICpwdWksICgqZnVuY3Ap IChpbnQgaSk7YDxicj48YnI+d2UgcHJvZHVjZSB0aGlzIHJld3JpdHRlbiBhYnN0cmFjdCBzeW50 YXggd2l0aCB0aHJlZSBzZXBhcmF0ZTxicj4NCg0KdHlwZWRlZiBkZWNsYXJhdGlvbnM6PGJyPjxi cj5leHRlcm5hbC1kZWNsYXJhdGlvbnM6PGJyPsKgIGV4dGVybmFsLWRlY2xhcmF0aW9uOjxicj7C oMKgwqAgZGVjbGFyYXRpb24tbGlzdDo8YnI+wqDCoMKgwqDCoCBkZWNsYXJhdGlvbi1saXN0Ojxi cj7CoMKgwqDCoMKgwqDCoCBkZWNsYXJhdGlvbi1saXN0Ojxicj7CoMKgwqDCoMKgwqDCoMKgwqAg ZGVjbGFyYXRpb24tbGlzdDo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkZWNsYXJhdGlvbjo8 YnI+DQoNCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9uLXNwZWNpZmllcnM6 PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBzdG9yYWdlLWNsYXNzLXNwZWNpZmll cjogdHlwZWRlZjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRpb24t c3BlY2lmaWVyczo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0eXBlLXNw ZWNpZmllcjogdW5zaWduZWQ8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBk ZWNsYXJhdGlvbi1zcGVjaWZpZXJzOjxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgdHlwZS1zcGVjaWZpZXI6IGludDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBpbml0LWRlY2xhcmF0b3ItbGlzdDo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIGluaXQtZGVjbGFyYXRvcjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBkZWNsYXJhdG9yOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBk aXJlY3QtZGVjbGFyYXRvcjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgIGlkZW50aWZpZXI6IHVpPGJyPg0KDQrCoMKgwqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRp b246PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRpb24tc3BlY2lmaWVyczo8YnI+ wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgc3RvcmFnZS1jbGFzcy1zcGVjaWZpZXI6IHR5cGVk ZWY8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRpb24tc3BlY2lmaWVyczo8 YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHR5cGUtc3BlY2lmaWVyOiB1bnNpZ25l ZDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRpb24tc3BlY2lmaWVy czo8YnI+DQoNCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdHlwZS1zcGVjaWZp ZXI6IGludDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGluaXQtZGVjbGFyYXRvci1saXN0Ojxi cj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpbml0LWRlY2xhcmF0b3I6PGJyPsKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkZWNsYXJhdG9yOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIHBvaW50ZXI6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqAgZGlyZWN0LWRlY2xhcmF0b3I6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIGlkZW50aWZpZXI6IHB1aTxicj4NCg0KwqDCoMKgwqDCoCBkZWNsYXJhdGlvbjo8 YnI+wqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRpb24tc3BlY2lmaWVyczo8YnI+wqDCoMKgwqDCoMKg wqDCoMKgIHN0b3JhZ2UtY2xhc3Mtc3BlY2lmaWVyOiB0eXBlZGVmPGJyPsKgwqDCoMKgwqDCoMKg wqDCoCBkZWNsYXJhdGlvbi1zcGVjaWZpZXJzOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHR5 cGUtc3BlY2lmaWVyOiB1bnNpZ25lZDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0 aW9uLXNwZWNpZmllcnM6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHR5cGUtc3BlY2lm aWVyOiBpbnQ8YnI+DQoNCsKgwqDCoMKgwqDCoMKgIGluaXQtZGVjbGFyYXRvci1saXN0Ojxicj7C oMKgwqDCoMKgwqDCoMKgwqAgaW5pdC1kZWNsYXJhdG9yOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDC oMKgIGRlY2xhcmF0b3I6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRpcmVjdC1kZWNs YXJhdG9yOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGlyZWN0LWRlY2xhcmF0 b3I6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRvcjo8YnI+ wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcG9pbnRlcjo8YnI+DQoNCsKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRpcmVjdC1kZWNsYXJhdG9yOjxi cj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaWRlbnRpZmllcjog ZnVuY3A8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHBhcmFtZXRlci10eXBlLWxp c3Q6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcGFyYW1ldGVyLWxpc3Q6 PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHBhcmFtZXRlci1kZWNs YXJhdGlvbjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRl Y2xhcmF0aW9uLXNwZWNpZmllcnM6PGJyPg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIHR5cGUtc3BlY2lmaWVyOiBpbnQ8YnI+wqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0b3I6PGJyPsKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGlyZWN0LWRlY2xhcmF0b3I8YnI+wqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaWRlbnRpZmll ciBpPGJyPjxicj5UaGUgZ2VuZXJhbCBzeXN0ZW0sIGNhcGFibGUgb2YgaGFuZGxpbmcgZXh0cmVt ZWx5IGNvbXBsZXggcmV3cml0ZXM8YnI+DQoNCmxpa2UgdGhpcywgd2hpY2ggY2FuIGJlIG5lc3Rl ZCBhbmQgY2FsbGVkIChjb25kaXRpb25hbGx5IGFuZC9vcjxicj5yZWN1cnNpdmVseSkgb25lIGZy b20gYW5vdGhlciwgd2l0aCBwYXJhbWV0ZXJzLCBpcyBpbXBsZW1lbnRlZCBpbjxicj5hYm91dCA0 MDAgbGluZXMgb2YgcmF0aGVyIGJhZGx5IHdyaXR0ZW4gU3RhbmRhcmQgTUwuIEl0IGlzIG5vdCBQ cm9sb2csPGJyPmJ1dCBpdCB1c2VzIGEgc2ltaWxhciB1bmlmaWNhdGlvbiBhbGdvcml0aG0gdG8g aWRlbnRpZnkgY2VydGFpbjxicj4NCg0KbGFyZ2Utc2NhbGUgc3RydWN0dXJlcyBpbmRlcGVuZGVu dGx5IG9mIG1hbnkgZGV0YWlscyBvZiBwYXJ0aWN1bGFyPGJyPmluc3RhbmNlcywgd2hpY2ggY2Fu IHZhcnkgcXVpdGUgc2lnbmlmaWNhbnRseS48YnI+PGJyPlRoZXNlIHByb2dyYW1zLCB0aGUgUHJv bG9nIGludGVycHJldGVyIGFuZCB0aGUgUmV3cml0ZSBlbmdpbmUsIGNvbXBpbGU8YnI+dG8gMTUs NTMzIGFuZCAyNCw1MzUrMjgsOTQ0IGJ5dGVzIHJlc3BlY3RpdmVseSBvZiBDQU1MIGJ5dGVjb2Rl LiBJPGJyPg0KDQp3b3VsZCBub3QgZXhwZWN0IGEgQyBpbXBsZW1lbnRhdGlvbiBvZiBzaW1pbGFy IGFsZ29yaXRobXMgdG8gYmUgbXVjaDxicj5tb3JlIHRoYW4gdGhpcy4gSWYgYW55b25lIGRvdWJ0 cyBzb21lb25lJiMzOTtzIGNoYW5jZXMgb2YgZWZmZWN0aXZlbHk8YnI+aGlkaW5nIHRoaXMgbXVj aCBjb2RlIGluIGEgQyBjb21waWxlciBiaW5hcnksIHRoZW4gdGhleSBzaG91bGQ8YnI+Y29uc2lk ZXIgdGhhdCBvbiBteSBzeXN0ZW0sIGJldHdlZW4gR0NDIDQuNSBhbmQgR0NDIDQuOSwgdGhlIGNv bWJpbmVkPGJyPg0KDQpjb21waWxlciBiaW5hcmllczogZ2NjLCBjcHAsIGNjMSwgYXMgYW5kIGxk IGdyZXcgZnJvbSAxMCBNQiB0byBvdmVyIDcwPGJyPk1CLiBTbyBJIHRoaW5rIGl0IHdvdWxkIG5v dCBiZSB0b28gZGlmZmljdWx0IHRvIGhpZGUgYW4gZXh0cmEgODBrIG9mPGJyPm9iamVjdCBjb2Rl IGluIGEgYmluYXJ5LiBUaGF0IHJlcHJlc2VudHMgYW4gaW5jcmVhc2Ugb2YgYXJvdW5kIG9uZTxi cj50ZW50aCBvZiBvbmUgcGVyY2VudCBvdmVyIHRoZSB0b3RhbCA3ME1CICh3aGljaCBJIGNvbnNp ZGVyIHF1aXRlPGJyPg0KDQpyaWRpY3Vsb3VzLCBieSB0aGUgd2F5LiBPbmUgcG9zc2libGUgZXhw bGFuYXRpb24gaXMgdGhhdCBHQ0hRIGFuZCB0aGU8YnI+TlNBIGFyZSBwbGF5aW5nIGNvcmUtd2Fy cyBpbiB0aGUgR0NDIGJpbmFyaWVzLik8YnI+PGJyPk5vdyB0aG9zZSBzdGlsbCByZWFkaW5nIHRo aXMgd2lsbCBhcHByZWNpYXRlIHRoYXQgdGhlIHJld3JpdGUgZW5naW5lLDxicj5hbmQgdGhlIFBy b2xvZyBpbnRlcnByZXRlciwgYXJlIHF1aXRlIGFic3RyYWN0IGluIHRoZSBzZW5zZSB0aGF0IHRo ZXk8YnI+DQoNCmludGVycHJldCBfYXJiaXRyYXJ5XyBydWxlcywgYW5kIHNvIHRoZXkgY291bGQg ZWFzaWx5IGJlIGltcGxlbWVudGVkPGJyPmluIHN1Y2ggYSB3YXkgdGhhdCB0aGUgcnVsZXMgY2Fu IGJlIGNoYW5nZWQgYWZ0ZXIgdGhlIGZhY3QsIGJ5IGNvZGluZzxicj5uZXcgcnVsZXMgaW50byB0 aGUgY29tcGlsZXImIzM5O3Mgc291cmNlIGNvZGUuIFRoZSBjb2RpbmcgY291bGQgYmUgaW48YnI+ Y29tbWVudHMsIG9yIGl0IGNvdWxkIGJlIGluIHRoZSBjaG9pY2Ugb2YgdmFyaWFibGUgbmFtZXMs IG9yIGl0IGNvdWxkPGJyPg0KDQpiZSBpbiB0ZXJtcyBvZiB0aGUgbnVtYmVyIG9mIHNwYWNlcyBh cHBlYXJpbmcgYXQgdGhlIGVuZHMgb2YgbGluZXM8YnI+d2hpY2ggYXJlIGNlcnRhaW4gc3VjY2Vz c2l2ZSBwcmltZSBtdWx0aXBsZXMgb2YgbGluZXMgYXBhcnQuIFRoZW4sIGJ5PGJyPmFwcGx5aW5n IGEgcHVibGljbHkgc2NydXRpbmlzZWQgcGF0Y2ggdG8gdGhlIGNvbXBpbGVyIHNvdXJjZSwgdGhl PGJyPnBlbmV0cmF0b3JzIGNvdWxkIHJlcHJvZ3JhbSB0aGUgdHJhcCBkb29yIGFscmVhZHkgaW4g YWxsIHRoZSBiaW5hcmllczxicj4NCg0Kb2YgdGhlIHByZXZpb3VzIHZlcnNpb25zIG9mIHRoZSBu ZXcgY29tcGlsZXIsIHNvIHRoYXQgdGhleSByZWNvZ25pc2U8YnI+YW5kIGVmZmVjdGl2ZWx5IGNv bXByb21pc2UgdGhlIG5ldyBjb21waWxlciYjMzk7cyBzb3VyY2Ugc3RydWN0dXJlLiBBbmQ8YnI+ d2hpbGUgdGhleSYjMzk7cmUgYXQgaXQsIHRoZXkgbWF5IGFzIHdlbGwgY2hhbmdlIHRoZSBjb2Rp bmcgc3lzdGVtIHVzZWQgdG88YnI+DQoNCnRyYW5zbWl0IG5ldyBydWxlcywgc28gdGhhdCBubyBt b3JlIHRoYW4gb25lIGluc3RhbmNlIG9mIGFueSBlbmNyeXB0ZWQ8YnI+bWVzc2FnZSBldmVyIGV4 aXN0cy48YnI+PGJyPlRoaXMgaXMgb25seSB0aGUgdGlwIG9mIHRoZSBpY2UtYnVyZzsgYW5kIHRo ZSBsZXNzIGV2aWRlbmNlIEkgc2VlIHRoYXQ8YnI+cGVvcGxlIGFyZSBwcm9wZXJseSBhZGRyZXNz aW5nIHRoaXMgJiMzOTtpc3N1ZSYjMzk7LCB0aGUgbW9yZSBvZiB0aGVzZTxicj4NCg0KJiMzOTtz dWdnZXN0aW9ucyYjMzk7IEkgd2lsbCBwdWJsaXNoIG92ZXIgdGhlIG5leHQgZmV3IGRheXMuIEFu ZCBJIHRoaW5rIHRoYXQ8YnI+YWZ0ZXIgbm90IHNvIHZlcnkgbG9uZywgcGVvcGxlIHdpbGwgYmUg bGVzcyBpbmNsaW5lZCB0byBtYWtlIHVuZm91bmRlZDxicj5jbGFpbXMgYWJvdXQgdGhlIHJlbGF0 aXZlIGltcHJvYmFiaWxpdHkgb2Ygc3VjaCBhbiBhdHRhY2suIEkmIzM5O20gbG9va2luZzxicj4N Cg0KZm9yd2FyZCB0byBpdDogc29tZSBvZiB0aGVtIGFyZSByZWFsbHksIHJlYWxseSB3aGFja3kh IEFuZCBuZWVkbGVzcyB0bzxicj5zYXksIG5vbmUgb2YgdGhlbSBhcmUgb3JpZ2luYWwuIFRoaXMg bGFzdCBpcyBqdXN0IGEgc3RhbmRhcmQgaW5zdGFuY2U8YnI+b2YgdGhlIHRlbGV0eXBlIHN0cmlu ZyB0cmlnZ2VyIHRyYXAgZG9vciB0aGF0IEthcmcgYW5kIFNjaGVsbDxicj5kZXNjcmliZWQgNDAg eWVhcnMgYWdvIGluIHRoZSBNdWx0aWNzIFNlY3VyaXR5IEV2YWx1YXRpb246PGJyPg0KDQpWdWxu ZXJhYmlsaXR5IEFuYWx5c2lzLiBUaGF0IGRvY3VtZW50IGlzIHdlbGwgd29ydGggYSBjYXJlZnVs PGJyPnJlYWQuIFRoZSBGaXJzdCBXb3JsZCBJbmZvcm1hdGlvbiBXYXIgc3RhcnRlZCBkZWNhZGVz IGFnbywgd2UgdGhpbmssPGJyPmJ1dCBzb21lIHBlb3BsZSBhcHBhcmVudGx5IGhhdmVuJiMzOTt0 IGNvdHRvbmVkLW9uIHlldC48YnI+PGJyPkhhcHB5IGhhY2tpbmcsIGV2ZXJ5b25lITxzcGFuPjxm b250IGNvbG9yPSIjODg4ODg4Ij48YnI+DQoNCjxicj5JYW48YnI+PGJyPjwvZm9udD48L3NwYW4+ PC9kaXY+DQo8YnI+PC9kaXY+PC9kaXY+X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX188YnI+DQpMaWdodG5pbmcgbWFpbGluZyBsaXN0PGJyPg0KPGEgaHJlZj0i bWFpbHRvOkxpZ2h0bmluZ0BnbnUub3JnIiB0YXJnZXQ9Il9ibGFuayI+TGlnaHRuaW5nQGdudS5v cmc8L2E+PGJyPg0KPGEgaHJlZj0iaHR0cHM6Ly9saXN0cy5nbnUub3JnL21haWxtYW4vbGlzdGlu Zm8vbGlnaHRuaW5nIiB0YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9saXN0cy5nbnUub3JnL21haWxt YW4vbGlzdGluZm8vbGlnaHRuaW5nPC9hPjxicj4NCjxicj48L2Jsb2NrcXVvdGU+PC9kaXY+PGJy PjwvZGl2Pg0KPC9ibG9ja3F1b3RlPjwvZGl2Pjxicj48L2Rpdj48L2Rpdj4NCg== --047d7b86c92e3f60d3050246c473-- --===============6340058973206741165== Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Lightning mailing list Lightning-mXXj517/zsQ@public.gmane.org https://lists.gnu.org/mailman/listinfo/lightning --===============6340058973206741165==--