From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!not-for-mail From: Bruno Loff Newsgroups: gmane.comp.gnu.lightning.general,gmane.lisp.guile.devel Subject: Re: Reinterpreting the compiler source code Date: Thu, 4 Sep 2014 21:57:03 +0100 Message-ID: References: NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="===============5353731062740623714==" X-Trace: ger.gmane.org 1409864249 21413 80.91.229.3 (4 Sep 2014 20:57:29 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Thu, 4 Sep 2014 20:57:29 +0000 (UTC) Cc: Richard Stallman , guile-devel-mXXj517/zsQ@public.gmane.org, Theo deRaadt , Markus Kuhn , Linus Torvalds , lightning , schellr-EkmVulN54Sk@public.gmane.org To: Ian Grant Original-X-From: lightning-bounces+gcglg-lightning=m.gmane.org-mXXj517/zsQ@public.gmane.org Thu Sep 04 22:57:22 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 1XPe5o-00017E-4s for gcglg-lightning@m.gmane.org; Thu, 04 Sep 2014 22:57:20 +0200 Original-Received: from localhost ([::1]:54130 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XPe5n-0004cS-PC for gcglg-lightning@m.gmane.org; Thu, 04 Sep 2014 16:57:19 -0400 Original-Received: from eggs.gnu.org ([2001:4830:134:3::10]:33148) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XPe5e-0004Zr-Vt for lightning-mXXj517/zsQ@public.gmane.org; Thu, 04 Sep 2014 16:57:15 -0400 Original-Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1XPe5Y-0004ud-N6 for lightning-mXXj517/zsQ@public.gmane.org; Thu, 04 Sep 2014 16:57:10 -0400 Original-Received: from mail-qg0-x229.google.com ([2607:f8b0:400d:c04::229]:40186) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XPe5Y-0004uT-EV; Thu, 04 Sep 2014 16:57:04 -0400 Original-Received: by mail-qg0-f41.google.com with SMTP id i50so10721772qgf.0 for ; Thu, 04 Sep 2014 13:57:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=mime-version:in-reply-to:references:date:message-id:subject:from:to :cc:content-type; bh=nAtI6bDZIvlsN46e4l/mfRniHjUrwD7vIyJElsyQeVQ=; b=XsrAWl7Q8lndeIhVO3oLInw9aOvBYRue6aQ+LbzFNvWEFEM3wDyZ+Uo8HaLxV+o8LF JuLgf0K5xT6jN7IB83erf8hVOfK132lD0KczhOO3j/XHmBdmCm8TMWPc3X8M082bcFBk Ng6CXXy/rZhnID83cj2N7IqfT0MZi/2DeUjRE34nrH45KjVQggG6ljGatO0FQY3Oxwr8 QYr2ZgGaG2PRUPJeYl0RK1XBv/XFAqaYdyh3GfwB/6t7P1oiXrWim+4BVEChsenIbIFM r3Q9MFW+bw6Rv0La9y50oaj1PTIORcWvSmUhaWTC4u83a30ehmtGbY12iqMUe8xeCp4N XaIg== X-Received: by 10.140.89.133 with SMTP id v5mr10471957qgd.65.1409864223325; Thu, 04 Sep 2014 13:57:03 -0700 (PDT) Original-Received: by 10.140.38.135 with HTTP; Thu, 4 Sep 2014 13:57:03 -0700 (PDT) In-Reply-To: X-detected-operating-system: by eggs.gnu.org: Error: Malformed IPv6 address (bad octet value). X-Received-From: 2607:f8b0:400d:c04::229 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:564 gmane.lisp.guile.devel:17400 Archived-At: --===============5353731062740623714== Content-Type: multipart/alternative; boundary=001a11c13eae36911905024398ac --001a11c13eae36911905024398ac Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Even if the threat you describe is real, why couldn't it be resolved in a simpler way? I'm thinking certificates and signatures... 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 compiler package from a clean source which signed the package, all that is necessary 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 would happen then. 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. Happy hacking :-) 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 qlToStr= ing > 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) assum= s > 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 > > --001a11c13eae36911905024398ac Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: base64 PGRpdiBkaXI9Imx0ciI+RXZlbiBpZiB0aGUgdGhyZWF0IHlvdSBkZXNjcmliZSBpcyByZWFsLCB3 aHkgY291bGRuJiMzOTt0IGl0IGJlIHJlc29sdmVkIGluIGEgc2ltcGxlciB3YXk/PGRpdj48YnI+ PC9kaXY+PGRpdj5JJiMzOTttIHRoaW5raW5nIGNlcnRpZmljYXRlcyBhbmQgc2lnbmF0dXJlcy4u LjxkaXY+PGJyPjwvZGl2PjxkaXY+SSBtZWFuLCBmb3IgZWFjaCBkaXN0cmlidXRpb24gaW4gZWFj aCBhcmNoaXRlY3R1cmUsIHRoZXJlIGlzIGJhc2ljYWxseSBhIHNpbmdsZSBidWlsZCBjb25maWd1 cmF0aW9uIHdoaWNoIG5lZWRzIHRvIGJlIGNlcnRpZmllZCBhcyAmcXVvdDt0cm9qYW4tZnJlZSZx dW90Oy4gQW5kIHRoaXMgaXMgYmFzaWNhbGx5IGFscmVhZHkgaW1wbGVtZW50ZWQsIHByb3ZpZGVk IHRoYXQgSSBnZXQgbXkgY29tcGlsZXIgcGFja2FnZSBmcm9tIGEgY2xlYW4gc291cmNlIHdoaWNo IHNpZ25lZCB0aGUgcGFja2FnZSwgYWxsIHRoYXQgaXMgbmVjZXNzYXJ5IGlzIHRoYXQgdGhlIGNs ZWFuIHNvdXJjZSB0b29rIHNwZWNpYWwgY2FyZSBpbiBlbnN1cmluZyB0aGF0IHRoZWlyIHZlcnNp b24gaXMgaW4gZmFjdCBidWctZnJlZS4uLjwvZGl2Pg0KPGRpdj48YnI+PC9kaXY+PGRpdj5UaGF0 IHNvbHZlcyA5OSUgb2YgdGhlIHVzZS1jYXNlcywgd2hlbiB5b3UgdXNlIGEgc3RhbmRhcmQgY29t cGlsZXIgcHJvdmlkZWQgYnkgYSBjbGVhbiBzb3VyY2UuIEZvciB0aGUgcmVtYWluaW5nIC45OSUs IHdoZW4geW91IHVzZSBhIGN1c3RvbS1idWlsdCBjb21waWxlciwgc2F5LCB5b3UgY291bGQgc3Rh cnQgd2l0aCBhIGNvbXBpbGVyIGZyb20gYSBjbGVhbiBzb3VyY2UgYW5kIHVzZSB0aGF0IHRvIGNv bXBpbGUgeW91ciBjdXN0b20tYnVpbGQuLi4gTm8gYnVnIGluamVjdGlvbiB3b3VsZCBoYXBwZW4g dGhlbi48L2Rpdj4NCjxkaXY+PGJyPjwvZGl2PjxkaXY+V291bGRuJiMzOTt0IHRoYXQgYmUgZW5v dWdoPyBGb3JtYWwgY2VydGlmaWNhdGlvbiBvZiB0aGUgY2xlYW5saW5lc3Mgb2YgdGhlIGNvbXBp bGVyIChpZiBJIHVuZGVyc3Rvb2QgY29ycmVjdGx5IGFuZCB0aGlzIGlzIHdoYXQgeW91IHByb3Bv c2UpIHNlZW1zIG92ZXItdGhlLXRvcCB0byBtZS48L2Rpdj48ZGl2Pjxicj48L2Rpdj48ZGl2Pjxi cj48L2Rpdj4NCjxkaXY+SGFwcHkgaGFja2luZyA6LSk8L2Rpdj48ZGl2Pjxicj48L2Rpdj48L2Rp dj48L2Rpdj48ZGl2IGNsYXNzPSJnbWFpbF9leHRyYSI+PGJyPjxicj48ZGl2IGNsYXNzPSJnbWFp bF9xdW90ZSI+T24gNCBTZXB0ZW1iZXIgMjAxNCAxODozMywgSWFuIEdyYW50IDxzcGFuIGRpcj0i bHRyIj4mbHQ7PGEgaHJlZj0ibWFpbHRvOmlhbi5hLm4uZ3JhbnRAZ29vZ2xlbWFpbC5jb20iIHRh cmdldD0iX2JsYW5rIj5pYW4uYS5uLmdyYW50QGdvb2dsZW1haWwuY29tPC9hPiZndDs8L3NwYW4+ IHdyb3RlOjxicj4NCjxibG9ja3F1b3RlIGNsYXNzPSJnbWFpbF9xdW90ZSIgc3R5bGU9Im1hcmdp bjowIDAgMCAuOGV4O2JvcmRlci1sZWZ0OjFweCAjY2NjIHNvbGlkO3BhZGRpbmctbGVmdDoxZXgi PjxkaXYgZGlyPSJsdHIiPlBlcmhhcHMgcGVvcGxlIHdvdWxkIGVuam95IHJlYWRpbmcgYWJvdXQg aG93IG9uZSBjb3VsZCBpbmplY3QgdHJvamFuPGJyPnNlbWFudGljcyBpbnRvIGEgY29tcGlsZXIg aW4gc3VjaCBhIHdheSB0aGF0IHRoZXkgaGF2ZSBzb21lIHJlc2lsaWVuY2U8YnI+DQp0byBhbGwg YnV0IHF1aXRlIG1ham9yIHN0cnVjdHVyYWwgY2hhbmdlcyB0byB0aGUgdGFyZ2V0IHNvdXJjZSBj b2RlPzxicj4NCjxicj5UaGlzIGlzIG5vdCBqdXN0IGZvciB0aGUgcHVycG9zZXMgb2YgZnJpZ2h0 ZW5pbmcgdGhlIGJpcmRzLiBJdCB3aWxsPGJyPnNob3cgaG93IHVzZWZ1bCB0b29scyB3aGljaCBh dXRvbWF0aWNhbGx5IGFuYWx5c2UgYW5kIHRyYW5zZm9ybTxicj5wcm9ncmFtIHN5bnRheCBjb3Vs ZCBiZS4gSW1hZ2luZSB0aGlzIGluIGEgJiMzOTt3aG9sZSBwcm9ncmFtJiMzOTsgSURFLCBzbzxi cj4NCnRoYXQgb25lIGNvdWxkIHF1ZXJ5IGNlcnRhaW4gY2xhc3NlcyBvZiB2YXJpYWJsZSBhc3Np Z25tZW50IGluIGFuPGJyPg0KT3BlcmF0aW5nIFN5c3RlbSBrZXJuZWwsIHNheSwgYW5kIHByb2dy YW0gZ2xvYmFsIHJlLXdyaXRlcyBiYXNlZCBvbjxicj5wYXR0ZXJuIG1hdGNoaW5nIG9mIHdob2xl IHN5bnRhY3RpYyBzdHJ1Y3R1cmVzLCByYXRoZXIgdGhhbiBqdXN0IHRoZTxicj5zdWItbGV4aWNh bCBtYXRjaGluZyB3aGljaCByZWd1bGFyIGV4cHJlc3Npb25zIG9mZmVyLjxicj48YnI+SGVyZSBp cyBhbiBpbXBsZW1lbnRhdGlvbiBvZiBhIFByb2xvZyBpbnRlcnByZXRlci4gVGhlIGludGVycHJl dGVyPGJyPg0KDQppdHNlbGYgaXMgb25seSA4OCBsaW5lcyBvZiBTdGFuZGFyZCBNTC4gTW9zdCBv ZiBpdCBpcyB3cml0dGVuIHVzaW5nPGJyPmxpc3QgZnVuY3Rpb25hbHMgbGlrZSBtYXAsIGV4aXN0 cywgZmluZCwgcGFydGl0aW9uIGV0Yy4gU28gaXQgc2hvdWxkPGJyPmJlIGNsZWFyIHRoYXQgaXQg Y291bGQgYmUgcXVpdGUgZWFzaWx5IHRyYW5zbGF0ZWQgaW50byBhIGZhaXJseTxicj5lZmZpY2ll bnQgQyBwcm9ncmFtLjxicj4NCg0KPGJyPigqIChBcGFydCBmcm9tIHRoZSAhPSBwcmVkaWNhdGUp IFRoaXMgaXMgYSB0cmFuc2xpdGVyYXRpb24gb2YgdGhlPGJyPsKgwqAgUHJvbG9nIGludGVycHJl dGVyIGluIEpvaG4gSGFycmlzb24mIzM5O3MgQ2FtYnJpZGdlIGxlY3R1cmUgbm90ZXMuICopPGJy Pjxicj5kYXRhdHlwZSB0ZXJtID08YnI+wqDCoCBGbiBvZiBzdHJpbmcgKiB0ZXJtIGxpc3Q8YnI+ wqB8IFZhciBvZiBzdHJpbmc8YnI+DQoNCjxicj5kYXRhdHlwZSBvdXRjb21lID08YnI+wqDCoCBZ ZXMgb2YgKHN0cmluZyAqIHRlcm0pIGxpc3Q8YnI+wqB8IE5vPGJyPjxicj5sb2NhbCBvcGVuIEdy YW1tYXJTeW50YXg8YnI+wqDCoCBmdW4gcGFyc2VyIHN0YXJ0c3ltYm9sID0gPGJyPsKgwqDCoMKg wqDCoCBsZXQgZnVuIHBhcnNlIGZpbGUgc3RyZWFtIGxleGJ1ZiA9PGJyPsKgwqDCoMKgwqDCoMKg wqDCoCBsZXQgdmFsIGV4cHIgPSBzdGFydHN5bWJvbCBQcm9sb2dMZXhlci5Ub2tlbiBsZXhidWY8 YnI+DQoNCsKgwqDCoMKgwqDCoMKgwqDCoCBpbiBQYXJzaW5nLmNsZWFyUGFyc2VyKCk7PGJyPsKg wqAgwqDCoMKgIMKgwqDCoMKgIGV4cHI8YnI+wqDCoMKgwqDCoMKgwqDCoMKgIGVuZCBoYW5kbGUg ZXhuID0mZ3Q7IChQYXJzaW5nLmNsZWFyUGFyc2VyKCk7IHJhaXNlIGV4bik8YnI+wqDCoMKgwqDC oMKgIGluIHBhcnNlIGVuZDxicj7CoMKgIGZ1biBwcm9jZXNzU3RyaW5nIHBmbiA9IGZuIHMgPSZn dDs8YnI+wqDCoMKgwqDCoCBwZm4gJnF1b3Q7c3RyaW5nJnF1b3Q7IHMgKExleGluZy5jcmVhdGVM ZXhlclN0cmluZyBzKTxicj4NCg0KwqDCoCBmdW4gcWxUb1N0cmluZyBsID08YnI+wqDCoMKgwqDC oCBsZXQgZnVuIGl0ZXIgciBbXSA9IHI8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8IGl0ZXIg ciAoKFFVT1RFIHMpOjpmcykgPSBpdGVyIChyXnMpIGZzPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgfCBpdGVyIHIgKChBTlRJUVVPVEUgcyk6OmZzKSA9IGl0ZXIgKHJecykgZnM8YnI+wqDCoMKg wqDCoCBpbiBpdGVyICZxdW90OyZxdW90OyBsPGJyPsKgwqDCoMKgwqAgZW5kPGJyPsKgwqAgdmFs IHBhcnNlcnVsZXNxID0gcHJvY2Vzc1N0cmluZyAocGFyc2VyIFByb2xvZ1BhcnNlci5GaWxlKSBv IHFsVG9TdHJpbmc8YnI+DQoNCsKgwqAgdmFsIHBhcnNldGVybXEgPSBwcm9jZXNzU3RyaW5nIChw YXJzZXIgUHJvbG9nUGFyc2VyLk9uZVRlcm0pIG8gcWxUb1N0cmluZzxicj7CoMKgIGZ1biBmYWls cyBzIHQgPSAocHJpbnRUcmVlIHQ7cmFpc2UgRmFpbCAoc14mcXVvdDs6IG5vIGNhc2UuJnF1b3Q7 KSk8YnI+wqDCoCBmdW4gbWtUZXJtIChOb25UZXJtKCZxdW90O2F0b20mcXVvdDssPGJyPsKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIFtOb25UZXJtKCZxdW90O2Nv bnN0YW50JnF1b3Q7LDxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgW1Rlcm0obmFtZSldKSw8YnI+wqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBsIGFzIE5vblRlcm0oJnF1b3Q7dGVy bS1saXN0JnF1b3Q7LF8pXSkpPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgID0gRm4obmFtZSxta0Fy Z3MgbCk8YnI+wqDCoMKgwqAgfCBta1Rlcm0gKE5vblRlcm0oJnF1b3Q7YXRvbSZxdW90OyxbTm9u VGVybSgmcXVvdDtjb25zdGFudCZxdW90OyxbVGVybShuYW1lKV0pXSkpPGJyPg0KDQrCoMKgwqDC oMKgwqDCoMKgwqDCoCA9IEZuKG5hbWUsW10pPGJyPsKgwqDCoMKgIHwgbWtUZXJtIChOb25UZXJt KCZxdW90O2F0b20mcXVvdDssW05vblRlcm0oJnF1b3Q7dmFyaWFibGUmcXVvdDssW1Rlcm0obmFt ZSldKV0pKTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoCA9IFZhcihuYW1lKTxicj7CoMKgwqDCoCB8 IG1rVGVybSAoTm9uVGVybSgmcXVvdDthdG9tJnF1b3Q7LFtsIGFzIE5vblRlcm0oJnF1b3Q7bGlz dCZxdW90OyxfKV0pKTxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgwqAgPSBta0xpc3QobCk8YnI+ wqDCoMKgwqAgfCBta1Rlcm0gdCA9IGZhaWxzICZxdW90O21rVGVybSZxdW90OyB0PGJyPsKgwqAg YW5kIG1rTGlzdCAoTm9uVGVybSgmcXVvdDtsaXN0JnF1b3Q7LFthIGFzIE5vblRlcm0oJnF1b3Q7 YXRvbSZxdW90OyxfKSw8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIGwgYXMgTm9uVGVybSgmcXVvdDtsaXN0JnF1b3Q7LF8pXSkp PGJyPg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDCoCA9IEZuKCZxdW90Oy4mcXVvdDssW21rVGVybSBh LG1rTGlzdCBsXSk8YnI+wqDCoMKgwqAgfCBta0xpc3QgKE5vblRlcm0oJnF1b3Q7bGlzdCZxdW90 OyxbYSBhcyBOb25UZXJtKCZxdW90O2F0b20mcXVvdDssXyldKSk8YnI+wqDCoMKgwqDCoMKgwqDC oMKgwqAgPSBGbigmcXVvdDsuJnF1b3Q7LFtta1Rlcm0gYSxGbigmcXVvdDtbXSZxdW90OyxbXSld KTxicj7CoMKgwqDCoCB8IG1rTGlzdCAoTm9uVGVybSgmcXVvdDtsaXN0JnF1b3Q7LFthIGFzIE5v blRlcm0oJnF1b3Q7YXRvbSZxdW90OyxfKSw8YnI+DQoNCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBhJiMzOTsgYXMgTm9uVGVybSgm cXVvdDthdG9tJnF1b3Q7LF8pXSkpPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgID0gRm4oJnF1b3Q7 LiZxdW90OyxbbWtUZXJtIGEsbWtUZXJtIGEmIzM5O10pPGJyPsKgwqDCoMKgIHwgbWtMaXN0IChO b25UZXJtKCZxdW90O2xpc3QmcXVvdDssW10pKTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoCA9IEZu KCZxdW90O1tdJnF1b3Q7LFtdKTxicj4NCsKgwqDCoMKgIHwgbWtMaXN0IHQgPcKgIGZhaWxzICZx dW90O21rTGlzdCZxdW90OyB0PGJyPg0KwqDCoCBhbmQgbWtBcmdzIChOb25UZXJtKCZxdW90O3Rl cm0tbGlzdCZxdW90OyxbYSBhcyBOb25UZXJtKCZxdW90O2F0b20mcXVvdDssXyksPGJyPsKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgbCBhcyBOb25UZXJtKCZxdW90O3Rlcm0tbGlzdCZxdW90OyxfKV0pKTxicj7CoMKg wqDCoMKgwqDCoMKgwqDCoCA9IChta1Rlcm0gYSk6Oihta0FyZ3MgbCk8YnI+wqDCoMKgwqAgfCBt a0FyZ3MgKE5vblRlcm0oJnF1b3Q7dGVybS1saXN0JnF1b3Q7LFthIGFzIE5vblRlcm0oJnF1b3Q7 YXRvbSZxdW90OyxfKV0pKTxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgwqAgPSBbbWtUZXJtIGFd PGJyPsKgwqDCoMKgIHwgbWtBcmdzIHQgPSBmYWlscyAmcXVvdDtta0FyZ3MmcXVvdDsgdDxicj7C oMKgIGZ1biBta1Rlcm1zIChOb25UZXJtKCZxdW90O3Rlcm1zJnF1b3Q7LFthIGFzIE5vblRlcm0o JnF1b3Q7YXRvbSZxdW90OyxfKSw8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0cyBhcyBOb25UZXJtKCZxdW90O3Rlcm1z JnF1b3Q7LF8pXSkpPGJyPg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCA9ICht a1Rlcm0gYSk6Oihta1Rlcm1zIHRzKTxicj7CoMKgwqDCoCB8IG1rVGVybXMgKE5vblRlcm0oJnF1 b3Q7dGVybXMmcXVvdDssW2EgYXMgTm9uVGVybSgmcXVvdDthdG9tJnF1b3Q7LF8pXSkpPGJyPsKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgID0gW21rVGVybSBhXTxicj7CoMKgwqDCoCB8 IG1rVGVybXMgdCA9wqAgZmFpbHMgJnF1b3Q7bWtUZXJtcyZxdW90OyB0PGJyPsKgwqAgYW5kIG1r UnVsZSAoTm9uVGVybSgmcXVvdDtydWxlJnF1b3Q7LFthIGFzIE5vblRlcm0oJnF1b3Q7YXRvbSZx dW90OyxfKSw8YnI+DQoNCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCB0cyBhcyBOb25UZXJtKCZxdW90O3Rlcm1zJnF1b3Q7LF8pXSkp PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgID0gKG1rVGVybSBhLCBta1Rlcm1z IHRzKTxicj7CoMKgwqDCoCB8IG1rUnVsZSAoTm9uVGVybSgmcXVvdDtydWxlJnF1b3Q7LFthIGFz IE5vblRlcm0oJnF1b3Q7YXRvbSZxdW90OyxfKV0pKTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoCA9IChta1Rlcm0gYSxbXSk8YnI+DQoNCsKgwqDCoMKgIHwgbWtSdWxlIHQgPSBm YWlscyAmcXVvdDtta1J1bGUmcXVvdDsgdDxicj7CoMKgIGFuZCBta1J1bGVzIChOb25UZXJtKCZx dW90O3J1bGUtbGlzdCZxdW90OyxbbCBhcyBOb25UZXJtKCZxdW90O3J1bGUtbGlzdCZxdW90Oyxf KSw8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIHIgYXMgTm9uVGVybSgmcXVvdDtydWxlJnF1b3Q7LF8pXSkp PGJyPsKgwqDCoMKgwqDCoMKgwqAgPSAobWtSdWxlKHIpKTo6KG1rUnVsZXMgbCk8YnI+DQoNCsKg wqDCoMKgIHwgbWtSdWxlcyAoTm9uVGVybSgmcXVvdDtydWxlLWxpc3QmcXVvdDssW3IgYXMgTm9u VGVybSgmcXVvdDtydWxlJnF1b3Q7LF8pXSkpPGJyPsKgwqDCoMKgwqDCoMKgwqAgPSBbbWtSdWxl KHIpXTxicj7CoMKgwqDCoCB8IG1rUnVsZXMgdCA9IGZhaWxzICZxdW90O21rUnVsZXMmcXVvdDsg dDxicj5pbjxicj7CoMKgIHZhbCBydWxlcyA9IExpc3QucmV2IG8gbWtSdWxlcyBvIHBhcnNlcnVs ZXNxPGJyPsKgwqAgdmFsIGdvYWwgPSBta1Rlcm0gbyBwYXJzZXRlcm1xPGJyPg0KDQplbmQ8YnI+ PGJyPmxvY2FsPGJyPsKgwqAgZnVuIG9jY3Vyc19pbiB4ID08YnI+wqDCoMKgwqDCoCBmbiAoVmFy IHkpID0mZ3Q7IHggPSB5PGJyPsKgwqDCoMKgwqDCoCB8IChGbihfLGwpKSA9Jmd0OyBMaXN0LmV4 aXN0cyAob2NjdXJzX2luIHgpIGw8YnI+wqDCoCBmdW4gYXNzb2MgaSA9PGJyPsKgwqDCoMKgwqAg KE9wdGlvbi5tYXAgKGZuIChfLHYpID0mZ3Q7IHYpKSBvIChMaXN0LmZpbmQgKGZuIChrLF8pID0m Z3Q7IGsgPSBpKSk8YnI+DQoNCsKgwqAgZnVuIHN1YnMgaW5zdHMgPTxicj7CoMKgwqDCoCBmbiAo dG0gYXMgKFZhciB5KSkgPSZndDs8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqAgKGNhc2UgYXNzb2Mg eSBpbnN0cyBvZiBOT05FID0mZ3Q7IHRtIHwgU09NRSB2ID0mZ3Q7IHYpPGJyPsKgwqDCoMKgwqAg fCAoRm4ocyxsKSkgPSZndDs8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqAgRm4ocyxMaXN0Lm1hcCAo c3VicyBpbnN0cykgbCk8YnI+wqDCoCBmdW4gYXVnbWVudDEgdGhldGEgKHgscykgPTxicj4NCg0K wqDCoMKgwqDCoCBsZXQgdmFsIHMmIzM5OyA9IHN1YnMgdGhldGEgczxicj7CoMKgwqDCoMKgIGlu IGlmIG9jY3Vyc19pbiB4IHMgYW5kYWxzbyBub3QgKHMgPSBWYXIoeCkpPGJyPsKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgdGhlbiByYWlzZSBGYWlsICZxdW90O09jY3VycyBjaGVjay4mcXVvdDs8YnI+ wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBlbHNlICh4LHMmIzM5Oyk8YnI+wqDCoMKgwqDCoCBlbmQ8 YnI+wqDCoCBmdW4gcmF3X2F1Z21lbnQgcCBpbnN0cyA9IHA6OihMaXN0Lm1hcCAoYXVnbWVudDEg W3BdKSBpbnN0cyk8YnI+DQoNCsKgwqAgZnVuIGF1Z21lbnQgKHYsdCkgaW5zdHMgPTxicj7CoMKg wqDCoMKgIGxldCB2YWwgdCYjMzk7ID0gc3VicyBpbnN0cyB0PGJyPsKgwqDCoMKgwqAgaW4gY2Fz ZSB0JiMzOTs8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqAgb2YgVmFyICh3KSA9Jmd0OyA8YnI+wqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlmIHcgJmx0Oz0gdiA8YnI+wqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0aGVuIGlmIHcgPSB2PGJyPsKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHRoZW4gaW5zdHM8YnI+DQoNCsKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGVsc2UgcmF3X2F1 Z21lbnQgKHYsdCYjMzk7KSBpbnN0czxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIGVsc2UgcmF3X2F1Z21lbnQgKHcsVmFyKHYpKSBpbnN0cyA8YnI+wqDCoMKgwqDCoMKgwqDC oMKgwqDCoCB8IF8gPSZndDsgaWYgb2NjdXJzX2luIHYgdCYjMzk7IDxicj7CoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdGhlbiByYWlzZSBGYWlsICZxdW90O09jY3Vy cyBjaGVjay4mcXVvdDs8YnI+DQoNCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCBlbHNlIHJhd19hdWdtZW50ICh2LHQmIzM5OykgaW5zdHM8YnI+wqDCoMKgwqDCoCBl bmQ8YnI+wqDCoMKgIGZ1biBpdGxpc3QyIGYgPTxicj7CoMKgwqDCoMKgIGxldCBmdW4gaXRlciBb XSBbXSA9IChmbiBiID0mZ3Q7IGIpPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfCBpdGVyICho Ojp0KSAoaCYjMzk7Ojp0JiMzOTspID0gKGZuIGIgPSZndDsgZiBoIGgmIzM5OyAoaXRsaXN0MiBm IHQgdCYjMzk7IGIpKTxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8IGl0ZXIgXyBfID0g cmFpc2UgRmFpbCAmcXVvdDtBcml0eS4mcXVvdDs8YnI+wqDCoMKgwqDCoCBpbiBpdGVyPGJyPsKg wqDCoMKgwqAgZW5kPGJyPsKgwqAgZnVuIHVuaWZ5IHRtMSB0bTIgaW5zdHMgPTxicj7CoMKgwqDC oMKgIGNhc2UgdG0xPGJyPsKgwqDCoMKgwqDCoMKgIG9mIFZhcih4KSA9Jmd0OyA8YnI+wqDCoMKg wqDCoMKgwqDCoMKgwqAgKGNhc2UgYXNzb2MgeCBpbnN0czxicj7CoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCBvZiBOT05FID0mZ3Q7IGF1Z21lbnQgKHgsdG0yKSBpbnN0czxicj4NCg0KwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8IFNPTUUgdG0xJiMzOTsgPSZndDsgdW5pZnkgdG0xJiMz OTsgdG0yIGluc3RzKTxicj7CoMKgwqDCoMKgwqDCoMKgIHwgRm4oZjEsYXJnczEpID0mZ3Q7PGJy PsKgwqDCoMKgwqDCoMKgwqDCoMKgIChjYXNlIHRtMjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBvZiAoVmFyKHkpKSA9Jmd0OyA8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgKGNhc2UgYXNzb2MgeSBpbnN0czxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCBvZiBOT05FID0mZ3Q7IGF1Z21lbnQgKHksdG0xKSBpbnN0czxicj4NCg0KwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8IFNPTUUgdG0yJiMzOTsgPSZndDsg dW5pZnkgdG0xIHRtMiYjMzk7IGluc3RzKTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IHwgRm4oZjIsYXJnczIpID0mZ3Q7PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBpZiBmMSA9IGYyIHRoZW4gaXRsaXN0MiB1bmlmeSBhcmdzMSBhcmdzMiBpbnN0czxicj7C oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IGVsc2UgcmFpc2UgRmFpbCAoJnF1b3Q7Q29uc3RhbnRzOiBtaXNtYXRjaDogJnF1b3Q7XmYxXiZx dW90OyZsdDsmZ3Q7JnF1b3Q7XmYyKSk8YnI+DQoNCsKgwqAgZnVuIHJlbmFtZSBzID08YnI+wqDC oMKgwqDCoCBmbiAoVmFyIHYpID0mZ3Q7IFZhcigmcXVvdDt+JnF1b3Q7XnZecyk8YnI+wqDCoMKg wqDCoMKgIHwgKEZuKGYsYXJncykpID0mZ3Q7IEZuKGYsTGlzdC5tYXAgKHJlbmFtZSBzKSBhcmdz KTxicj7CoMKgIGZ1biByZW5hbWVfcnVsZSBzIChjb25jLGFzc3VtcykgPTxicj7CoMKgwqDCoMKg wqAgKHJlbmFtZSBzIGNvbmMsTGlzdC5tYXAgKHJlbmFtZSBzKSBhc3N1bXMpPGJyPg0KDQrCoMKg IGZ1biBleHBhbmQgbiBydWxlcyBpbnN0cyBnb2FscyA9PGJyPsKgwqDCoMKgwqAgbGV0IGZ1biBm aXJzdCBmID08YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIChmbiBbXSA9Jmd0OyBy YWlzZSBGYWlsICZxdW90O05vIHJ1bGVzIGFwcGx5LiZxdW90Ozxicj7CoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIHwgKGg6OnQpID0mZ3Q7IChmIGggaGFuZGxlIEZhaWwgXyA9Jmd0 OyBmaXJzdCBmIHQpKTxicj7CoMKgwqDCoMKgwqDCoMKgwqAgZnVuIHNlYXJjaCBydWxlID0gPGJy Pg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaWYgZ29hbHMgPSBbXTxicj7CoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgdGhlbiBpbnN0czxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgZWxzZTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgbGV0 IGZ1biBlcWdvYWwgKEZuKCZxdW90OyE9JnF1b3Q7LFthLGJdKSkgPSBub3QgKGEgPSBiKTxicj7C oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfCBlcWdvYWwg XyA9IGZhbHNlPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IHZhbCAoY29uYyxhc3N1bXMpID0gcmVuYW1lX3J1bGUgKEludC50b1N0cmluZyBuKSBydWxlPGJy Pg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB2YWwgZ29h bCA9IGhkIGdvYWxzPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIHZhbCBpbnN0cyYjMzk7ID0gaWYgZXFnb2FsIGdvYWw8YnI+wqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCB0aGVuIGluc3RzICgqIENIRUNLISBUaGlzIGlzIHByb2JhYmx5IHdyb25nLiAqKTxicj7CoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIGVsc2UgdW5pZnkgY29uYyBnb2FsIGluc3RzPGJyPg0KDQrCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBmdW4gb2NjdXJzICh2LF8pID0g b2NjdXJzX2luIHYgY29uYzxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBvcmVsc2UgTGlzdC5leGlzdHMgKG9jY3Vy c19pbiB2KSBhc3N1bXM8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqAgdmFsIChsb2MsZ2xvYikgPSBMaXN0LnBhcnRpdGlvbiBvY2N1cnMgaW5zdHMmIzM5Ozxi cj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB2YWwgZ29hbHMm IzM5OyA9IChMaXN0Lm1hcCAoc3VicyBsb2MpIGFzc3VtcykgQCAodGwgZ29hbHMpPGJyPg0KDQrC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaW4gZXhwYW5kIChuKzEpIHJ1bGVz IGdsb2IgZ29hbHMmIzM5Ozxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg ZW5kPGJyPsKgwqDCoMKgwqAgaW48YnI+wqDCoMKgwqDCoMKgwqDCoCBmaXJzdCBzZWFyY2ggcnVs ZXM8YnI+wqDCoMKgwqDCoCBlbmQ8YnI+aW48YnI+wqDCoCBmdW4gcHJvbG9nIHJ1bGVzIGdvYWwg PTxicj7CoMKgwqDCoMKgIGxldCB2YWwgaW5zdHMgPSBleHBhbmQgMCBydWxlcyBbXSBbZ29hbF08 YnI+DQoNCsKgwqDCoMKgwqAgaW4gWWVzIChMaXN0LmZpbHRlciAoZm4gKHYsXykgPSZndDsgb2Nj dXJzX2luIHYgZ29hbCkgaW5zdHMpPGJyPsKgwqDCoMKgwqAgZW5kIGhhbmRsZSBGYWlsIF8gPSZn dDsgTm88YnI+ZW5kPGJyPjxicj5IZXJlIGlzIGFuIGV4YW1wbGUgb2Ygd2hhdCBpdCBjYW4gZG8g KGEgcmF0aGVyIHRpcmVkIG9sZCBvbmUsIGJ1dCBiZWFyPGJyPndpdGggdXMsIGJlY2F1c2Ugd2Ug d2lsbCBzaG9ydGx5IHJlaW50ZXJwcmV0IHRoaXMgYXMgc29tZXRoaW5nPGJyPg0KDQptb3JlIGlu dGVyZXN0aW5nKTo8YnI+PGJyPnZhbCAoKSA9IGxvYWQgJnF1b3Q7UHJvbG9nJnF1b3Q7Ozxicj48 YnI+dmFsICgpID0gTWV0YS5xdW90YXRpb24gOj0gdHJ1ZTs8YnI+PGJyPnZhbCBycyA9IFByb2xv Zy5ydWxlcyBgPGJyPsKgwqAgbWFsZShhbGJlcnQpLjxicj7CoMKgIG1hbGUoZWR3YXJkKS48YnI+ PGJyPsKgwqAgZmVtYWxlKGFsaWNlKS48YnI+wqDCoCBmZW1hbGUodmljdG9yaWEpLjxicj4NCg0K PGJyPsKgwqAgZmF0aGVyX29mKGFsYmVydCxlZHdhcmQpLjxicj7CoMKgIGZhdGhlcl9vZihhbGJl cnQsYWxpY2UpLjxicj48YnI+wqDCoCBtb3RoZXJfb2YodmljdG9yaWEsZWR3YXJkKS48YnI+wqDC oCBtb3RoZXJfb2YodmljdG9yaWEsYWxpY2UpLjxicj48YnI+wqDCoCBwYXJlbnRzKFgsTSxGKTot bW90aGVyX29mKE0sWCksZmF0aGVyX29mKEYsWCkuPGJyPjxicj7CoMKgIHNpc3Rlcl9vZihYLFkp Oi08YnI+DQoNCsKgwqDCoMKgwqAgZmVtYWxlKFgpLDxicj7CoMKgwqDCoMKgIHBhcmVudHMoWCxN LEYpLDxicj7CoMKgwqDCoMKgIHBhcmVudHMoWSxNLEYpLjxicj48YnI+wqDCoCBicm90aGVyX29m KFgsWSk6LTxicj7CoMKgwqDCoMKgICE9KFgsWSksPGJyPsKgwqDCoMKgwqAgbWFsZShYKSw8YnI+ wqDCoMKgwqDCoCBwYXJlbnRzKFgsTSxGKSw8YnI+wqDCoMKgwqDCoCBwYXJlbnRzKFksTSxGKS48 YnI+YDs8YnI+PGJyPlRoaXMgZGVmaW5lcyBhIGRhdGFiYXNlIG9mIGZhY3RzLCB0aGUgc28tY2Fs bGVkIGdyb3VuZCB0ZXJtcywgd2hpY2g8YnI+DQoNCmFyZSB0aG9zZSB3aGljaCBkb24mIzM5O3Qg Y29udGFpbiBhbnkgbG9naWNhbCB2YXJpYWJsZXMgKHdoaWNoIGluIFByb2xvZzxicj5hcmUgdHlw aWNhbGx5IGFsbC11cHBlci1jYXNlIGlkZW50aWZpZXJzKS4gVGhlbiB0aGVyZSBhcmUgX3J1bGVz Xzxicj53aGljaCBkZWZpbmUgcmVsYXRpb25zIChpbiB0aGUgc2V0LXRoZW9yZXRpY2FsIHNlbnNl IG9mIHRoZSB0ZXJtLCBidXQ8YnI+aGVyZSBhbHNvIGluIHRoZSBnZW5lYWxvZ2ljYWwgc2Vuc2Up Ljxicj4NCg0KPGJyPk5vdGUgdGhhdCB0aGUgdHdvLXBsYWNlIHByZWRpY2F0ZSBzaXN0ZXJfb2Yg aXMgaW5kaXJlY3RseSBkZWZpbmVkIGluPGJyPnRlcm1zIGFub3RoZXIgcnVsZSwgd2hpY2ggZGVm aW5lcyB0aGUgcGFyZW50cyByZWxhdGlvbi4gQnV0IHRoZXNlIDg4PGJyPmxpbmVzIG9mIGNvZGUg d2lsbCByZXNvbHZlIHRoZSBpbmRpcmVjdGlvbiBhbmQgc28gdGhleSBjYW4gY29ycmVjdGx5PGJy Pg0KZGVkdWNlLCBmb3IgZXhhbXBsZTo8YnI+DQo8YnI+wqDCoCB2YWwgZyA9IFByb2xvZy5nb2Fs IGBzaXN0ZXJfb2YoYWxpY2UsZWR3YXJkKWA8YnI+wqDCoCB2YWwgciA9IFByb2xvZy5wcm9sb2cg cnMgZzxicj48YnI+Z2l2aW5nIDxicj48YnI+wqAgdmFsIHIgPSBQcm9sb2cuWWVzIFtdIDogb3V0 Y29tZTxicj48YnI+Tm93IGxvb2sgYXQgdGhlIGRhdGFiYXNlIG9mIGZhY3RzLCBhbmQgbm90ZSB0 aGF0IGl0IGlzIHJlYWxseSBqdXN0IGFuPGJyPg0KDQphYnN0cmFjdCBzeW50YXggcmVwcmVzZW50 YXRpb24gb2YgYSBjb2xsZWN0aW9uIG9mIHN0YXRlbWVudHMgaW4gYW48YnI+YXJiaXRyYXJ5IGxh bmd1YWdlIChpLmUuIGEgbGFuZ3VhZ2Ugd2l0aCB1bmRlZmluZWQgc3ludGF4KS4gVGhlcmVmb3Jl PGJyPm9uZSBjYW4gYXBwbHkgUHJvbG9nIGRlZHVjdGlvbnMsIHF1aXRlIHRyaXZpYWxseSwgdG8g c2VudGVuY2VzIGluIGE8YnI+ZGVmaW5lZCBwcm9ncmFtbWluZyBsYW5ndWFnZSBzdWNoIGFzIEMu IE5vdyB0aGUgQyBjb21waWxlciwgd2hpY2ggd2U8YnI+DQoNCmltYWdpbmUgd2UgYXJlIGF0dGFj a2luZywgYWxyZWFkeSBoYXMgYWxsIHRoZSBjb2RlIHRvIGFuYWx5c2UgYW5kPGJyPm1hbmlwdWxh dGUgYWJzdHJhY3Qgc3ludGF4IHJlcHJlc2VudGF0aW9ucyBvZiBDIHByb2dyYW1zLCBiZWNhdXNl IHRoYXQ8YnI+aXMgaXRzIGpvYiEgU28gSSBob3BlIHBlb3BsZSBjYW4gc2VlLCB3aXRob3V0IG15 IGhhdmluZyB0byBpbnN0YWxsIGl0PGJyPmludG8gR0NDIDQuOSwgdGhhdCBvbmUgY2FuIGVhc2ls eSBpbXBsZW1lbnQgYSBQcm9sb2cgaW50ZXJwcmV0ZXIgaW48YnI+DQoNCnZlcnkgbGl0dGxlIGNv ZGUsIHdoaWNoIGNhbiBkZWNpZGUgYSBxdWl0ZSBnZW5lcmFsIGNsYXNzIG9mIHByZWRpY2F0ZXM8 YnI+Y29uY2VybmluZyBhIHByb2dyYW0sIHRoZSBzdHJ1Y3R1cmUgb2Ygd2hpY2ggaXMgcmVwcmVz ZW50ZWQgaW4gdGhlPGJyPmNvbXBpbGVyIGFzIGFic3RyYWN0IHN5bnRheC48YnI+PGJyPk5vdyBu b3RlIHRoYXQgdGhlIHByZWRpY2F0ZXMgbmVlZCBub3QgaGF2ZSBhIGZpeGVkICYjMzk7ZGVwdGgu JiMzOTsgSGVyZSBhcmU8YnI+DQoNCnR3byBydWxlcyBkZWZpbmluZyBhIHBhdGggaW4gYW4gYXJi aXRyYXJ5IGRpcmVjdGVkIGdyYXBoLCB3aGljaCBpcyBhPGJyPm5vbi13ZWxsZm91bmRlZCBzdHJ1 Y3R1cmUgY2FwYWJsZSBvZiByZXByZXNlbnRpbmcgYWxtb3N0IGFueXRoaW5nLDxicj5pbmNsdWRp bmcgdGhlIHNlbnRlbmNlcyBvZiBhbnkgbGFuZ3VhZ2UgZGVmaW5lZCBieSBhIGNvbnRleHQtZnJl ZTxicj5ncmFtbWFyLjxicj4NCg0KPGJyPkhlcmUgdGhlIGdyb3VuZCB0ZXJtcyByZXByZXNlbnQg YSBncmFwaCBpbiB0aHJlZSBkaXNqb2ludCBwYXJ0cywgd2l0aDxicj50d28gY3ljbGVzLjxicj48 YnI+dmFsIHJzJiMzOTsmIzM5OyA9IFByb2xvZy5ydWxlcyBgPGJyPsKgwqAgZWRnZShnLGgpLjxi cj7CoMKgIGVkZ2UoZSxmKS48YnI+wqDCoCBlZGdlKGYsZSkuPGJyPsKgwqAgZWRnZShhLGIpLjxi cj7CoMKgIGVkZ2UoYixjKS48YnI+wqDCoCBlZGdlKGMsZCkuPGJyPg0KDQrCoMKgIGVkZ2UoZCxh KS48YnI+wqDCoCBwYXRoKEEsQik6LWVkZ2UoQSxCKS48YnI+wqDCoCBwYXRoKEEsQik6LWVkZ2Uo QSxDKSxwYXRoKEMsQikuPGJyPmA7PGJyPjxicj5Qcm9sb2cgY2FuIGRldGVybWluZSB3aGV0aGVy IG9yIG5vdCB0aGVyZSBpcyBhIHBhdGggZnJvbSBvbmUgdmVydGV4IHRvPGJyPmFub3RoZXIsIG5v IG1hdHRlciBob3cgZmFyIGFwYXJ0IHRoZXkgbWF5IGJlOjxicj48YnI+DQrCoMKgIHZhbCBnMiA9 IFByb2xvZy5nb2FsIGBwYXRoKGEsZClgPGJyPg0KwqDCoCB2YWwgcjIgPSBQcm9sb2cucHJvbG9n IHJzJiMzOTsmIzM5OyBnMjxicj48YnI+SXQgcHJpbnRzPGJyPjxicj7CoCB2YWwgcjIgPSBQcm9s b2cuWWVzIFtdIDogb3V0Y29tZTxicj48YnI+QW5kIGl0IGNhbiB0ZWxsIHdoaWNoIHZlcnRpY2Vz IGFyZSByZWFjaGFibGUgZnJvbSBhIGdpdmVuIHZlcnRleDo8YnI+PGJyPsKgwqAgdmFsIGczID0g UHJvbG9nLmdvYWwgYHBhdGgoYixYKWA8YnI+DQrCoMKgIHZhbCByMyA9IFByb2xvZy5wcm9sb2cg cnMmIzM5OyYjMzk7IGczPGJyPg0KPGJyPlRoZSByZXN1bHQgaXM8YnI+PGJyPsKgIHZhbCByMyA9 IFByb2xvZy5ZZXMgWygmcXVvdDtYJnF1b3Q7LCBQcm9sb2cuRm4oJnF1b3Q7YyZxdW90OywgW10p KV0gOiBvdXRjb21lPGJyPjxicj5JbiB0aGlzIGltcGxlbWVudGF0aW9uIGl0IG9ubHkgcHJpbnRz IHRoZSBmaXJzdCBzdWNoIGVkZ2UsIGJ1dCBpdDxicj5jb3VsZCBmaW5kIHRoZW0gYWxsLjxicj48 YnI+U28gaXQgc2hvdWxkIG5vdCByZXF1aXJlIGFueSBncmVhdCBzdHJldGNoaW5nIG9mIHBlb3Bs ZSYjMzk7cyBjcmVkdWxpdHkgdG88YnI+DQoNCnNlZSB0aGF0IGEgdmVyeSBmZXcgbGluZXMgb2Yg aW50ZWxsaWdlbnRseSB3cml0dGVuIGNvZGUgY2FuIHJlY29nbmlzZTxicj5sYXJnZS1zY2FsZSBz dHJ1Y3R1cmUgaW4gYWJzdHJhY3Qgc3ludGF4LCBldmVuIHdoZW4gcXVpdGUgZXh0ZW5zaXZlPGJy PmNoYW5nZXMgbWF5IGhhdmUgYmVlbiBtYWRlIHRvIHRoZSBsZWF2ZXMuPGJyPjxicj5Ob3cgd2Ug bmVlZCB0byBzaG93IGl0IGNvdWxkIHJlLXdyaXRlIHRob3NlIHByb2dyYW1zLiBUaGlzIGlzIGVh c3ksPGJyPg0KDQpiZWNhdXNlIGluIGZhY3QgYSBDIGNvbXBpbGVyIGFscmVhZHkgZG9lcyB0aGlz LiBJdCBoYXMgdG8sIGJlY2F1c2UgdGhlPGJyPnN5bnRheCBvZiBDIGlzIG5vdCBzdWZmaWNpZW50 IHRvIGRldGVybWluZSB3aGF0IGlzIGEgd2VsbC1mb3JtZWQgQzxicj5wcm9ncmFtIGFuZCB3aGF0 IGlzIG5vdC4gSGVyZSBpcyBhbiBleGFtcGxlIG9mIHByb2dyYW1tZWQgcmUtd3JpdGluZzxicj5v ZiBhcmJpdHJhcnkgZnJhZ21lbnRzIG9mIGEgQyBwcm9ncmFtLiBXaGF0IHRoaXMgZG9lcyBpcyBz cGxpdCBhPGJyPg0KDQpjb21wb3VuZCB0eXBlZGVmIHN0YXRlbWVudCAoYW55IGNvbXBvdW5kIHR5 cGVkZWYgc3RhdGVtZW50IHdoYXRzb2V2ZXIpPGJyPmludG8gc2VwYXJhdGUgcGFydHM6PGJyPjxi cj7CoMKgIHZhbCByZXdyaXRlX3R5cGVkZWYgPTxicj7CoMKgwqDCoMKgwqDCoMKgIHJld3JpdGVx IGA8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCDin6ZkZWNsYXJhdGlvbjxicj7CoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIOKMnHc6ZGVjbGFyYXRpb24tc3BlY2lmaWVyc+KMnTxicj4NCg0K wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAoaW5pdC1kZWNsYXJhdG9yLWxpc3Q8YnI+wqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCDijJx4OmluaXQtZGVjbGFyYXRvci1saXN0 4oydPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg4oyceTppbml0LWRlY2xh cmF0b3LijJ0p4p+nID08YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAoZGVjbGFyYXRp b24tbGlzdDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIChkZWNsYXJhdGlv bi1saXN0PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg4p+mZGVj bGFyYXRpb24g4oycd+KMnSDijJx44oyd4p+nKTxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoCAoZGVjbGFyYXRpb24g4oycd+KMnSAoaW5pdC1kZWNsYXJhdG9yLWxpc3Qg 4oyceeKMnSkpKWA8YnI+PGJyPlNvIHRha2luZyB0aGlzIHR5cGVkZWY6PGJyPjxicj7CoMKgIHZh bCB0ZCA9IGFic3ludHEgYHR5cGVkZWYgdW5zaWduZWQgaW50IHVpLCAqcHVpLCAoKmZ1bmNwKSAo aW50IGkpO2A8YnI+PGJyPndlIHByb2R1Y2UgdGhpcyByZXdyaXR0ZW4gYWJzdHJhY3Qgc3ludGF4 IHdpdGggdGhyZWUgc2VwYXJhdGU8YnI+DQoNCnR5cGVkZWYgZGVjbGFyYXRpb25zOjxicj48YnI+ ZXh0ZXJuYWwtZGVjbGFyYXRpb25zOjxicj7CoCBleHRlcm5hbC1kZWNsYXJhdGlvbjo8YnI+wqDC oMKgIGRlY2xhcmF0aW9uLWxpc3Q6PGJyPsKgwqDCoMKgwqAgZGVjbGFyYXRpb24tbGlzdDo8YnI+ wqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRpb24tbGlzdDo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgIGRl Y2xhcmF0aW9uLWxpc3Q6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRpb246PGJy Pg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkZWNsYXJhdGlvbi1zcGVjaWZpZXJzOjxi cj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgc3RvcmFnZS1jbGFzcy1zcGVjaWZpZXI6 IHR5cGVkZWY8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9uLXNw ZWNpZmllcnM6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdHlwZS1zcGVj aWZpZXI6IHVuc2lnbmVkPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGVj bGFyYXRpb24tc3BlY2lmaWVyczo8YnI+DQoNCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIHR5cGUtc3BlY2lmaWVyOiBpbnQ8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgaW5pdC1kZWNsYXJhdG9yLWxpc3Q6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBpbml0LWRlY2xhcmF0b3I6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg ZGVjbGFyYXRvcjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGly ZWN0LWRlY2xhcmF0b3I6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBpZGVudGlmaWVyOiB1aTxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9u Ojxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9uLXNwZWNpZmllcnM6PGJyPsKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHN0b3JhZ2UtY2xhc3Mtc3BlY2lmaWVyOiB0eXBlZGVm PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9uLXNwZWNpZmllcnM6PGJy PsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0eXBlLXNwZWNpZmllcjogdW5zaWduZWQ8 YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9uLXNwZWNpZmllcnM6 PGJyPg0KDQrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHR5cGUtc3BlY2lmaWVy OiBpbnQ8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpbml0LWRlY2xhcmF0b3ItbGlzdDo8YnI+ wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaW5pdC1kZWNsYXJhdG9yOjxicj7CoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRvcjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoCBwb2ludGVyOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIGRpcmVjdC1kZWNsYXJhdG9yOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCBpZGVudGlmaWVyOiBwdWk8YnI+DQoNCsKgwqDCoMKgwqAgZGVjbGFyYXRpb246PGJy PsKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9uLXNwZWNpZmllcnM6PGJyPsKgwqDCoMKgwqDCoMKg wqDCoCBzdG9yYWdlLWNsYXNzLXNwZWNpZmllcjogdHlwZWRlZjxicj7CoMKgwqDCoMKgwqDCoMKg wqAgZGVjbGFyYXRpb24tc3BlY2lmaWVyczo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0eXBl LXNwZWNpZmllcjogdW5zaWduZWQ8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkZWNsYXJhdGlv bi1zcGVjaWZpZXJzOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0eXBlLXNwZWNpZmll cjogaW50PGJyPg0KDQrCoMKgwqDCoMKgwqDCoCBpbml0LWRlY2xhcmF0b3ItbGlzdDo8YnI+wqDC oMKgwqDCoMKgwqDCoMKgIGluaXQtZGVjbGFyYXRvcjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBkZWNsYXJhdG9yOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkaXJlY3QtZGVjbGFy YXRvcjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRpcmVjdC1kZWNsYXJhdG9y Ojxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0b3I6PGJyPsKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHBvaW50ZXI6PGJyPg0KDQrCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkaXJlY3QtZGVjbGFyYXRvcjo8YnI+ wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlkZW50aWZpZXI6IGZ1 bmNwPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBwYXJhbWV0ZXItdHlwZS1saXN0 Ojxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHBhcmFtZXRlci1saXN0Ojxi cj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBwYXJhbWV0ZXItZGVjbGFy YXRpb246PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkZWNs YXJhdGlvbi1zcGVjaWZpZXJzOjxicj4NCg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCB0eXBlLXNwZWNpZmllcjogaW50PGJyPsKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkZWNsYXJhdG9yOjxicj7CoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRpcmVjdC1kZWNsYXJhdG9yPGJyPsKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlkZW50aWZpZXIg aTxicj48YnI+VGhlIGdlbmVyYWwgc3lzdGVtLCBjYXBhYmxlIG9mIGhhbmRsaW5nIGV4dHJlbWVs eSBjb21wbGV4IHJld3JpdGVzPGJyPg0KDQpsaWtlIHRoaXMsIHdoaWNoIGNhbiBiZSBuZXN0ZWQg YW5kIGNhbGxlZCAoY29uZGl0aW9uYWxseSBhbmQvb3I8YnI+cmVjdXJzaXZlbHkpIG9uZSBmcm9t IGFub3RoZXIsIHdpdGggcGFyYW1ldGVycywgaXMgaW1wbGVtZW50ZWQgaW48YnI+YWJvdXQgNDAw IGxpbmVzIG9mIHJhdGhlciBiYWRseSB3cml0dGVuIFN0YW5kYXJkIE1MLiBJdCBpcyBub3QgUHJv bG9nLDxicj5idXQgaXQgdXNlcyBhIHNpbWlsYXIgdW5pZmljYXRpb24gYWxnb3JpdGhtIHRvIGlk ZW50aWZ5IGNlcnRhaW48YnI+DQoNCmxhcmdlLXNjYWxlIHN0cnVjdHVyZXMgaW5kZXBlbmRlbnRs eSBvZiBtYW55IGRldGFpbHMgb2YgcGFydGljdWxhcjxicj5pbnN0YW5jZXMsIHdoaWNoIGNhbiB2 YXJ5IHF1aXRlIHNpZ25pZmljYW50bHkuPGJyPjxicj5UaGVzZSBwcm9ncmFtcywgdGhlIFByb2xv ZyBpbnRlcnByZXRlciBhbmQgdGhlIFJld3JpdGUgZW5naW5lLCBjb21waWxlPGJyPnRvIDE1LDUz MyBhbmQgMjQsNTM1KzI4LDk0NCBieXRlcyByZXNwZWN0aXZlbHkgb2YgQ0FNTCBieXRlY29kZS4g STxicj4NCg0Kd291bGQgbm90IGV4cGVjdCBhIEMgaW1wbGVtZW50YXRpb24gb2Ygc2ltaWxhciBh bGdvcml0aG1zIHRvIGJlIG11Y2g8YnI+bW9yZSB0aGFuIHRoaXMuIElmIGFueW9uZSBkb3VidHMg c29tZW9uZSYjMzk7cyBjaGFuY2VzIG9mIGVmZmVjdGl2ZWx5PGJyPmhpZGluZyB0aGlzIG11Y2gg Y29kZSBpbiBhIEMgY29tcGlsZXIgYmluYXJ5LCB0aGVuIHRoZXkgc2hvdWxkPGJyPmNvbnNpZGVy IHRoYXQgb24gbXkgc3lzdGVtLCBiZXR3ZWVuIEdDQyA0LjUgYW5kIEdDQyA0LjksIHRoZSBjb21i aW5lZDxicj4NCg0KY29tcGlsZXIgYmluYXJpZXM6IGdjYywgY3BwLCBjYzEsIGFzIGFuZCBsZCBn cmV3IGZyb20gMTAgTUIgdG8gb3ZlciA3MDxicj5NQi4gU28gSSB0aGluayBpdCB3b3VsZCBub3Qg YmUgdG9vIGRpZmZpY3VsdCB0byBoaWRlIGFuIGV4dHJhIDgwayBvZjxicj5vYmplY3QgY29kZSBp biBhIGJpbmFyeS4gVGhhdCByZXByZXNlbnRzIGFuIGluY3JlYXNlIG9mIGFyb3VuZCBvbmU8YnI+ dGVudGggb2Ygb25lIHBlcmNlbnQgb3ZlciB0aGUgdG90YWwgNzBNQiAod2hpY2ggSSBjb25zaWRl ciBxdWl0ZTxicj4NCg0KcmlkaWN1bG91cywgYnkgdGhlIHdheS4gT25lIHBvc3NpYmxlIGV4cGxh bmF0aW9uIGlzIHRoYXQgR0NIUSBhbmQgdGhlPGJyPk5TQSBhcmUgcGxheWluZyBjb3JlLXdhcnMg aW4gdGhlIEdDQyBiaW5hcmllcy4pPGJyPjxicj5Ob3cgdGhvc2Ugc3RpbGwgcmVhZGluZyB0aGlz IHdpbGwgYXBwcmVjaWF0ZSB0aGF0IHRoZSByZXdyaXRlIGVuZ2luZSw8YnI+YW5kIHRoZSBQcm9s b2cgaW50ZXJwcmV0ZXIsIGFyZSBxdWl0ZSBhYnN0cmFjdCBpbiB0aGUgc2Vuc2UgdGhhdCB0aGV5 PGJyPg0KDQppbnRlcnByZXQgX2FyYml0cmFyeV8gcnVsZXMsIGFuZCBzbyB0aGV5IGNvdWxkIGVh c2lseSBiZSBpbXBsZW1lbnRlZDxicj5pbiBzdWNoIGEgd2F5IHRoYXQgdGhlIHJ1bGVzIGNhbiBi ZSBjaGFuZ2VkIGFmdGVyIHRoZSBmYWN0LCBieSBjb2Rpbmc8YnI+bmV3IHJ1bGVzIGludG8gdGhl IGNvbXBpbGVyJiMzOTtzIHNvdXJjZSBjb2RlLiBUaGUgY29kaW5nIGNvdWxkIGJlIGluPGJyPmNv bW1lbnRzLCBvciBpdCBjb3VsZCBiZSBpbiB0aGUgY2hvaWNlIG9mIHZhcmlhYmxlIG5hbWVzLCBv ciBpdCBjb3VsZDxicj4NCg0KYmUgaW4gdGVybXMgb2YgdGhlIG51bWJlciBvZiBzcGFjZXMgYXBw ZWFyaW5nIGF0IHRoZSBlbmRzIG9mIGxpbmVzPGJyPndoaWNoIGFyZSBjZXJ0YWluIHN1Y2Nlc3Np dmUgcHJpbWUgbXVsdGlwbGVzIG9mIGxpbmVzIGFwYXJ0LiBUaGVuLCBieTxicj5hcHBseWluZyBh IHB1YmxpY2x5IHNjcnV0aW5pc2VkIHBhdGNoIHRvIHRoZSBjb21waWxlciBzb3VyY2UsIHRoZTxi cj5wZW5ldHJhdG9ycyBjb3VsZCByZXByb2dyYW0gdGhlIHRyYXAgZG9vciBhbHJlYWR5IGluIGFs bCB0aGUgYmluYXJpZXM8YnI+DQoNCm9mIHRoZSBwcmV2aW91cyB2ZXJzaW9ucyBvZiB0aGUgbmV3 IGNvbXBpbGVyLCBzbyB0aGF0IHRoZXkgcmVjb2duaXNlPGJyPmFuZCBlZmZlY3RpdmVseSBjb21w cm9taXNlIHRoZSBuZXcgY29tcGlsZXImIzM5O3Mgc291cmNlIHN0cnVjdHVyZS4gQW5kPGJyPndo aWxlIHRoZXkmIzM5O3JlIGF0IGl0LCB0aGV5IG1heSBhcyB3ZWxsIGNoYW5nZSB0aGUgY29kaW5n IHN5c3RlbSB1c2VkIHRvPGJyPg0KDQp0cmFuc21pdCBuZXcgcnVsZXMsIHNvIHRoYXQgbm8gbW9y ZSB0aGFuIG9uZSBpbnN0YW5jZSBvZiBhbnkgZW5jcnlwdGVkPGJyPm1lc3NhZ2UgZXZlciBleGlz dHMuPGJyPjxicj5UaGlzIGlzIG9ubHkgdGhlIHRpcCBvZiB0aGUgaWNlLWJ1cmc7IGFuZCB0aGUg bGVzcyBldmlkZW5jZSBJIHNlZSB0aGF0PGJyPnBlb3BsZSBhcmUgcHJvcGVybHkgYWRkcmVzc2lu ZyB0aGlzICYjMzk7aXNzdWUmIzM5OywgdGhlIG1vcmUgb2YgdGhlc2U8YnI+DQoNCiYjMzk7c3Vn Z2VzdGlvbnMmIzM5OyBJIHdpbGwgcHVibGlzaCBvdmVyIHRoZSBuZXh0IGZldyBkYXlzLiBBbmQg SSB0aGluayB0aGF0PGJyPmFmdGVyIG5vdCBzbyB2ZXJ5IGxvbmcsIHBlb3BsZSB3aWxsIGJlIGxl c3MgaW5jbGluZWQgdG8gbWFrZSB1bmZvdW5kZWQ8YnI+Y2xhaW1zIGFib3V0IHRoZSByZWxhdGl2 ZSBpbXByb2JhYmlsaXR5IG9mIHN1Y2ggYW4gYXR0YWNrLiBJJiMzOTttIGxvb2tpbmc8YnI+DQoN CmZvcndhcmQgdG8gaXQ6IHNvbWUgb2YgdGhlbSBhcmUgcmVhbGx5LCByZWFsbHkgd2hhY2t5ISBB bmQgbmVlZGxlc3MgdG88YnI+c2F5LCBub25lIG9mIHRoZW0gYXJlIG9yaWdpbmFsLiBUaGlzIGxh c3QgaXMganVzdCBhIHN0YW5kYXJkIGluc3RhbmNlPGJyPm9mIHRoZSB0ZWxldHlwZSBzdHJpbmcg dHJpZ2dlciB0cmFwIGRvb3IgdGhhdCBLYXJnIGFuZCBTY2hlbGw8YnI+ZGVzY3JpYmVkIDQwIHll YXJzIGFnbyBpbiB0aGUgTXVsdGljcyBTZWN1cml0eSBFdmFsdWF0aW9uOjxicj4NCg0KVnVsbmVy YWJpbGl0eSBBbmFseXNpcy4gVGhhdCBkb2N1bWVudCBpcyB3ZWxsIHdvcnRoIGEgY2FyZWZ1bDxi cj5yZWFkLiBUaGUgRmlyc3QgV29ybGQgSW5mb3JtYXRpb24gV2FyIHN0YXJ0ZWQgZGVjYWRlcyBh Z28sIHdlIHRoaW5rLDxicj5idXQgc29tZSBwZW9wbGUgYXBwYXJlbnRseSBoYXZlbiYjMzk7dCBj b3R0b25lZC1vbiB5ZXQuPGJyPjxicj5IYXBweSBoYWNraW5nLCBldmVyeW9uZSE8c3BhbiBjbGFz cz0iSE9FblpiIj48Zm9udCBjb2xvcj0iIzg4ODg4OCI+PGJyPg0KDQo8YnI+SWFuPGJyPjxicj48 L2ZvbnQ+PC9zcGFuPjwvZGl2Pg0KPGJyPl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fPGJyPg0KTGlnaHRuaW5nIG1haWxpbmcgbGlzdDxicj4NCjxhIGhyZWY9 Im1haWx0bzpMaWdodG5pbmdAZ251Lm9yZyI+TGlnaHRuaW5nQGdudS5vcmc8L2E+PGJyPg0KPGEg aHJlZj0iaHR0cHM6Ly9saXN0cy5nbnUub3JnL21haWxtYW4vbGlzdGluZm8vbGlnaHRuaW5nIiB0 YXJnZXQ9Il9ibGFuayI+aHR0cHM6Ly9saXN0cy5nbnUub3JnL21haWxtYW4vbGlzdGluZm8vbGln aHRuaW5nPC9hPjxicj4NCjxicj48L2Jsb2NrcXVvdGU+PC9kaXY+PGJyPjwvZGl2Pg0K --001a11c13eae36911905024398ac-- --===============5353731062740623714== 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 --===============5353731062740623714==--