From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!not-for-mail From: Ian Grant Newsgroups: gmane.lisp.guile.devel,gmane.comp.gnu.lightning.general Subject: Reinterpreting the compiler source code Date: Thu, 4 Sep 2014 13:33:38 -0400 Message-ID: NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Type: multipart/alternative; boundary=047d7b86c92ec328bf050240c02e X-Trace: ger.gmane.org 1409853672 13394 80.91.229.3 (4 Sep 2014 18:01:12 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Thu, 4 Sep 2014 18:01:12 +0000 (UTC) To: Richard Stallman , Markus Kuhn , Theo deRaadt , Linus Torvalds , guile-devel@gnu.org, lightning , schellr@ieee.org Original-X-From: guile-devel-bounces+guile-devel=m.gmane.org@gnu.org Thu Sep 04 20:01:07 2014 Return-path: Envelope-to: guile-devel@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 1XPbLG-0004Xk-8S for guile-devel@m.gmane.org; Thu, 04 Sep 2014 20:01:06 +0200 Original-Received: from localhost ([::1]:53295 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XPbLF-0006iW-SH for guile-devel@m.gmane.org; Thu, 04 Sep 2014 14:01:05 -0400 Original-Received: from eggs.gnu.org ([2001:4830:134:3::10]:43838) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XPav1-0002wq-Ht for guile-devel@gnu.org; Thu, 04 Sep 2014 13:34:03 -0400 Original-Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1XPauu-0007f5-Kt for guile-devel@gnu.org; Thu, 04 Sep 2014 13:33:59 -0400 Original-Received: from mail-we0-x22a.google.com ([2a00:1450:400c:c03::22a]:64669) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XPaui-0007Wg-3o; Thu, 04 Sep 2014 13:33:40 -0400 Original-Received: by mail-we0-f170.google.com with SMTP id p10so10647756wes.29 for ; Thu, 04 Sep 2014 10:33:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=googlemail.com; s=20120113; h=mime-version:date:message-id:subject:from:to:content-type; bh=D0S4RCBN3EgypPokDVnU5PdX+Saj1kERy6uRdiV3FEo=; b=oOndqyQt4MSC+msatv8DHDqQhFQPOqvgizVWJMjsF/Ok7AZ4FZ6pcGGxRfuMf1Ql4N XSH2yQR78NeRTR8M/H86uRTh2k77rutVBaylzTBFdIiA3Ydp6KgY016odaTPoW6gYSFi UX139rpOiqE9KZdDwqmXUdXd81BXmYdXvSjGdutjDMgxoC8VGV7F+ao2ngIEM8h05K6i 9UV9nHxV8BgTElvzyKW12yAEmKirwIUR4oGaP7EVsnmsrfXUNNXDpztyq/ePQjLJyVMF 0TlgTVXVYIWMMEodM12V82py2zh6t2kPkMvgss5ahYmfDvIAn2cITHVmDoKmVU0PSk1z itYg== X-Received: by 10.194.57.237 with SMTP id l13mr8110144wjq.102.1409852018729; Thu, 04 Sep 2014 10:33:38 -0700 (PDT) Original-Received: by 10.194.219.234 with HTTP; Thu, 4 Sep 2014 10:33:38 -0700 (PDT) X-detected-operating-system: by eggs.gnu.org: Error: Malformed IPv6 address (bad octet value). X-Received-From: 2a00:1450:400c:c03::22a X-BeenThere: guile-devel@gnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: "Developers list for Guile, the GNU extensibility library" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: guile-devel-bounces+guile-devel=m.gmane.org@gnu.org Original-Sender: guile-devel-bounces+guile-devel=m.gmane.org@gnu.org Xref: news.gmane.org gmane.lisp.guile.devel:17398 gmane.comp.gnu.lightning.general:563 Archived-At: --047d7b86c92ec328bf050240c02e Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable 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 qlToStrin= g val parsetermq =3D processString (parser PrologParser.OneTerm) o qlToStr= ing 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) r= ule 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) assums 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 --047d7b86c92ec328bf050240c02e Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: base64 PGRpdiBkaXI9Imx0ciI+UGVyaGFwcyBwZW9wbGUgd291bGQgZW5qb3kgcmVhZGluZyBhYm91dCBo b3cgb25lIGNvdWxkIGluamVjdCB0cm9qYW48YnI+c2VtYW50aWNzIGludG8gYSBjb21waWxlciBp biBzdWNoIGEgd2F5IHRoYXQgdGhleSBoYXZlIHNvbWUgcmVzaWxpZW5jZTxicj50byBhbGwgYnV0 IHF1aXRlIG1ham9yIHN0cnVjdHVyYWwgY2hhbmdlcyB0byB0aGUgdGFyZ2V0IHNvdXJjZSBjb2Rl Pzxicj4NCjxicj5UaGlzIGlzIG5vdCBqdXN0IGZvciB0aGUgcHVycG9zZXMgb2YgZnJpZ2h0ZW5p bmcgdGhlIGJpcmRzLiBJdCB3aWxsPGJyPnNob3cgaG93IHVzZWZ1bCB0b29scyB3aGljaCBhdXRv bWF0aWNhbGx5IGFuYWx5c2UgYW5kIHRyYW5zZm9ybTxicj5wcm9ncmFtIHN5bnRheCBjb3VsZCBi ZS4gSW1hZ2luZSB0aGlzIGluIGEgJiMzOTt3aG9sZSBwcm9ncmFtJiMzOTsgSURFLCBzbzxicj50 aGF0IG9uZSBjb3VsZCBxdWVyeSBjZXJ0YWluIGNsYXNzZXMgb2YgdmFyaWFibGUgYXNzaWdubWVu dCBpbiBhbjxicj4NCk9wZXJhdGluZyBTeXN0ZW0ga2VybmVsLCBzYXksIGFuZCBwcm9ncmFtIGds b2JhbCByZS13cml0ZXMgYmFzZWQgb248YnI+cGF0dGVybiBtYXRjaGluZyBvZiB3aG9sZSBzeW50 YWN0aWMgc3RydWN0dXJlcywgcmF0aGVyIHRoYW4ganVzdCB0aGU8YnI+c3ViLWxleGljYWwgbWF0 Y2hpbmcgd2hpY2ggcmVndWxhciBleHByZXNzaW9ucyBvZmZlci48YnI+PGJyPkhlcmUgaXMgYW4g aW1wbGVtZW50YXRpb24gb2YgYSBQcm9sb2cgaW50ZXJwcmV0ZXIuIFRoZSBpbnRlcnByZXRlcjxi cj4NCml0c2VsZiBpcyBvbmx5IDg4IGxpbmVzIG9mIFN0YW5kYXJkIE1MLiBNb3N0IG9mIGl0IGlz IHdyaXR0ZW4gdXNpbmc8YnI+bGlzdCBmdW5jdGlvbmFscyBsaWtlIG1hcCwgZXhpc3RzLCBmaW5k LCBwYXJ0aXRpb24gZXRjLiBTbyBpdCBzaG91bGQ8YnI+YmUgY2xlYXIgdGhhdCBpdCBjb3VsZCBi ZSBxdWl0ZSBlYXNpbHkgdHJhbnNsYXRlZCBpbnRvIGEgZmFpcmx5PGJyPmVmZmljaWVudCBDIHBy b2dyYW0uPGJyPg0KPGJyPigqIChBcGFydCBmcm9tIHRoZSAhPSBwcmVkaWNhdGUpIFRoaXMgaXMg YSB0cmFuc2xpdGVyYXRpb24gb2YgdGhlPGJyPsKgwqAgUHJvbG9nIGludGVycHJldGVyIGluIEpv aG4gSGFycmlzb24mIzM5O3MgQ2FtYnJpZGdlIGxlY3R1cmUgbm90ZXMuICopPGJyPjxicj5kYXRh dHlwZSB0ZXJtID08YnI+wqDCoCBGbiBvZiBzdHJpbmcgKiB0ZXJtIGxpc3Q8YnI+wqB8IFZhciBv ZiBzdHJpbmc8YnI+DQo8YnI+ZGF0YXR5cGUgb3V0Y29tZSA9PGJyPsKgwqAgWWVzIG9mIChzdHJp bmcgKiB0ZXJtKSBsaXN0PGJyPsKgfCBObzxicj48YnI+bG9jYWwgb3BlbiBHcmFtbWFyU3ludGF4 PGJyPsKgwqAgZnVuIHBhcnNlciBzdGFydHN5bWJvbCA9IDxicj7CoMKgwqDCoMKgwqAgbGV0IGZ1 biBwYXJzZSBmaWxlIHN0cmVhbSBsZXhidWYgPTxicj7CoMKgwqDCoMKgwqDCoMKgwqAgbGV0IHZh bCBleHByID0gc3RhcnRzeW1ib2wgUHJvbG9nTGV4ZXIuVG9rZW4gbGV4YnVmPGJyPg0KwqDCoMKg wqDCoMKgwqDCoMKgIGluIFBhcnNpbmcuY2xlYXJQYXJzZXIoKTs8YnI+wqDCoCDCoMKgwqAgwqDC oMKgwqAgZXhwcjxicj7CoMKgwqDCoMKgwqDCoMKgwqAgZW5kIGhhbmRsZSBleG4gPSZndDsgKFBh cnNpbmcuY2xlYXJQYXJzZXIoKTsgcmFpc2UgZXhuKTxicj7CoMKgwqDCoMKgwqAgaW4gcGFyc2Ug ZW5kPGJyPsKgwqAgZnVuIHByb2Nlc3NTdHJpbmcgcGZuID0gZm4gcyA9Jmd0Ozxicj7CoMKgwqDC oMKgIHBmbiAmcXVvdDtzdHJpbmcmcXVvdDsgcyAoTGV4aW5nLmNyZWF0ZUxleGVyU3RyaW5nIHMp PGJyPg0KwqDCoCBmdW4gcWxUb1N0cmluZyBsID08YnI+wqDCoMKgwqDCoCBsZXQgZnVuIGl0ZXIg ciBbXSA9IHI8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8IGl0ZXIgciAoKFFVT1RFIHMpOjpm cykgPSBpdGVyIChyXnMpIGZzPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfCBpdGVyIHIgKChB TlRJUVVPVEUgcyk6OmZzKSA9IGl0ZXIgKHJecykgZnM8YnI+wqDCoMKgwqDCoCBpbiBpdGVyICZx dW90OyZxdW90OyBsPGJyPsKgwqDCoMKgwqAgZW5kPGJyPsKgwqAgdmFsIHBhcnNlcnVsZXNxID0g cHJvY2Vzc1N0cmluZyAocGFyc2VyIFByb2xvZ1BhcnNlci5GaWxlKSBvIHFsVG9TdHJpbmc8YnI+ DQrCoMKgIHZhbCBwYXJzZXRlcm1xID0gcHJvY2Vzc1N0cmluZyAocGFyc2VyIFByb2xvZ1BhcnNl ci5PbmVUZXJtKSBvIHFsVG9TdHJpbmc8YnI+wqDCoCBmdW4gZmFpbHMgcyB0ID0gKHByaW50VHJl ZSB0O3JhaXNlIEZhaWwgKHNeJnF1b3Q7OiBubyBjYXNlLiZxdW90OykpPGJyPsKgwqAgZnVuIG1r VGVybSAoTm9uVGVybSgmcXVvdDthdG9tJnF1b3Q7LDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBbTm9uVGVybSgmcXVvdDtjb25zdGFudCZxdW90Oyw8YnI+ DQrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCBbVGVybShuYW1lKV0pLDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIGwgYXMgTm9uVGVybSgmcXVvdDt0ZXJtLWxpc3QmcXVvdDssXyldKSk8 YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqAgPSBGbihuYW1lLG1rQXJncyBsKTxicj7CoMKgwqDCoCB8 IG1rVGVybSAoTm9uVGVybSgmcXVvdDthdG9tJnF1b3Q7LFtOb25UZXJtKCZxdW90O2NvbnN0YW50 JnF1b3Q7LFtUZXJtKG5hbWUpXSldKSk8YnI+DQrCoMKgwqDCoMKgwqDCoMKgwqDCoCA9IEZuKG5h bWUsW10pPGJyPsKgwqDCoMKgIHwgbWtUZXJtIChOb25UZXJtKCZxdW90O2F0b20mcXVvdDssW05v blRlcm0oJnF1b3Q7dmFyaWFibGUmcXVvdDssW1Rlcm0obmFtZSldKV0pKTxicj7CoMKgwqDCoMKg wqDCoMKgwqDCoCA9IFZhcihuYW1lKTxicj7CoMKgwqDCoCB8IG1rVGVybSAoTm9uVGVybSgmcXVv dDthdG9tJnF1b3Q7LFtsIGFzIE5vblRlcm0oJnF1b3Q7bGlzdCZxdW90OyxfKV0pKTxicj4NCsKg wqDCoMKgwqDCoMKgwqDCoMKgID0gbWtMaXN0KGwpPGJyPsKgwqDCoMKgIHwgbWtUZXJtIHQgPSBm YWlscyAmcXVvdDtta1Rlcm0mcXVvdDsgdDxicj7CoMKgIGFuZCBta0xpc3QgKE5vblRlcm0oJnF1 b3Q7bGlzdCZxdW90OyxbYSBhcyBOb25UZXJtKCZxdW90O2F0b20mcXVvdDssXyksPGJyPsKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBs IGFzIE5vblRlcm0oJnF1b3Q7bGlzdCZxdW90OyxfKV0pKTxicj4NCsKgwqDCoMKgwqDCoMKgwqDC oMKgID0gRm4oJnF1b3Q7LiZxdW90OyxbbWtUZXJtIGEsbWtMaXN0IGxdKTxicj7CoMKgwqDCoCB8 IG1rTGlzdCAoTm9uVGVybSgmcXVvdDtsaXN0JnF1b3Q7LFthIGFzIE5vblRlcm0oJnF1b3Q7YXRv bSZxdW90OyxfKV0pKTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoCA9IEZuKCZxdW90Oy4mcXVvdDss W21rVGVybSBhLEZuKCZxdW90O1tdJnF1b3Q7LFtdKV0pPGJyPsKgwqDCoMKgIHwgbWtMaXN0IChO b25UZXJtKCZxdW90O2xpc3QmcXVvdDssW2EgYXMgTm9uVGVybSgmcXVvdDthdG9tJnF1b3Q7LF8p LDxicj4NCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoCBhJiMzOTsgYXMgTm9uVGVybSgmcXVvdDthdG9tJnF1b3Q7LF8pXSkpPGJyPsKg wqDCoMKgwqDCoMKgwqDCoMKgID0gRm4oJnF1b3Q7LiZxdW90OyxbbWtUZXJtIGEsbWtUZXJtIGEm IzM5O10pPGJyPsKgwqDCoMKgIHwgbWtMaXN0IChOb25UZXJtKCZxdW90O2xpc3QmcXVvdDssW10p KTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoCA9IEZuKCZxdW90O1tdJnF1b3Q7LFtdKTxicj7CoMKg wqDCoCB8IG1rTGlzdCB0ID3CoCBmYWlscyAmcXVvdDtta0xpc3QmcXVvdDsgdDxicj4NCsKgwqAg YW5kIG1rQXJncyAoTm9uVGVybSgmcXVvdDt0ZXJtLWxpc3QmcXVvdDssW2EgYXMgTm9uVGVybSgm cXVvdDthdG9tJnF1b3Q7LF8pLDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGwgYXMgTm9uVGVybSgmcXVvdDt0 ZXJtLWxpc3QmcXVvdDssXyldKSk8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqAgPSAobWtUZXJtIGEp OjoobWtBcmdzIGwpPGJyPsKgwqDCoMKgIHwgbWtBcmdzIChOb25UZXJtKCZxdW90O3Rlcm0tbGlz dCZxdW90OyxbYSBhcyBOb25UZXJtKCZxdW90O2F0b20mcXVvdDssXyldKSk8YnI+DQrCoMKgwqDC oMKgwqDCoMKgwqDCoCA9IFtta1Rlcm0gYV08YnI+wqDCoMKgwqAgfCBta0FyZ3MgdCA9IGZhaWxz ICZxdW90O21rQXJncyZxdW90OyB0PGJyPsKgwqAgZnVuIG1rVGVybXMgKE5vblRlcm0oJnF1b3Q7 dGVybXMmcXVvdDssW2EgYXMgTm9uVGVybSgmcXVvdDthdG9tJnF1b3Q7LF8pLDxicj7CoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IHRzIGFzIE5vblRlcm0oJnF1b3Q7dGVybXMmcXVvdDssXyldKSk8YnI+DQrCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCA9IChta1Rlcm0gYSk6Oihta1Rlcm1zIHRzKTxicj7CoMKgwqDC oCB8IG1rVGVybXMgKE5vblRlcm0oJnF1b3Q7dGVybXMmcXVvdDssW2EgYXMgTm9uVGVybSgmcXVv dDthdG9tJnF1b3Q7LF8pXSkpPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgID0g W21rVGVybSBhXTxicj7CoMKgwqDCoCB8IG1rVGVybXMgdCA9wqAgZmFpbHMgJnF1b3Q7bWtUZXJt cyZxdW90OyB0PGJyPsKgwqAgYW5kIG1rUnVsZSAoTm9uVGVybSgmcXVvdDtydWxlJnF1b3Q7LFth IGFzIE5vblRlcm0oJnF1b3Q7YXRvbSZxdW90OyxfKSw8YnI+DQrCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdHMgYXMgTm9uVGVybSgm cXVvdDt0ZXJtcyZxdW90OyxfKV0pKTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCA9IChta1Rlcm0gYSwgbWtUZXJtcyB0cyk8YnI+wqDCoMKgwqAgfCBta1J1bGUgKE5vblRlcm0o JnF1b3Q7cnVsZSZxdW90OyxbYSBhcyBOb25UZXJtKCZxdW90O2F0b20mcXVvdDssXyldKSk8YnI+ wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgPSAobWtUZXJtIGEsW10pPGJyPg0KwqDC oMKgwqAgfCBta1J1bGUgdCA9IGZhaWxzICZxdW90O21rUnVsZSZxdW90OyB0PGJyPsKgwqAgYW5k IG1rUnVsZXMgKE5vblRlcm0oJnF1b3Q7cnVsZS1saXN0JnF1b3Q7LFtsIGFzIE5vblRlcm0oJnF1 b3Q7cnVsZS1saXN0JnF1b3Q7LF8pLDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgciBhcyBOb25UZXJtKCZx dW90O3J1bGUmcXVvdDssXyldKSk8YnI+wqDCoMKgwqDCoMKgwqDCoCA9IChta1J1bGUocikpOjoo bWtSdWxlcyBsKTxicj4NCsKgwqDCoMKgIHwgbWtSdWxlcyAoTm9uVGVybSgmcXVvdDtydWxlLWxp c3QmcXVvdDssW3IgYXMgTm9uVGVybSgmcXVvdDtydWxlJnF1b3Q7LF8pXSkpPGJyPsKgwqDCoMKg wqDCoMKgwqAgPSBbbWtSdWxlKHIpXTxicj7CoMKgwqDCoCB8IG1rUnVsZXMgdCA9IGZhaWxzICZx dW90O21rUnVsZXMmcXVvdDsgdDxicj5pbjxicj7CoMKgIHZhbCBydWxlcyA9IExpc3QucmV2IG8g bWtSdWxlcyBvIHBhcnNlcnVsZXNxPGJyPsKgwqAgdmFsIGdvYWwgPSBta1Rlcm0gbyBwYXJzZXRl cm1xPGJyPg0KZW5kPGJyPjxicj5sb2NhbDxicj7CoMKgIGZ1biBvY2N1cnNfaW4geCA9PGJyPsKg wqDCoMKgwqAgZm4gKFZhciB5KSA9Jmd0OyB4ID0geTxicj7CoMKgwqDCoMKgwqAgfCAoRm4oXyxs KSkgPSZndDsgTGlzdC5leGlzdHMgKG9jY3Vyc19pbiB4KSBsPGJyPsKgwqAgZnVuIGFzc29jIGkg PTxicj7CoMKgwqDCoMKgIChPcHRpb24ubWFwIChmbiAoXyx2KSA9Jmd0OyB2KSkgbyAoTGlzdC5m aW5kIChmbiAoayxfKSA9Jmd0OyBrID0gaSkpPGJyPg0KwqDCoCBmdW4gc3VicyBpbnN0cyA9PGJy PsKgwqDCoMKgIGZuICh0bSBhcyAoVmFyIHkpKSA9Jmd0Ozxicj7CoMKgwqDCoMKgwqDCoMKgwqDC oCAoY2FzZSBhc3NvYyB5IGluc3RzIG9mIE5PTkUgPSZndDsgdG0gfCBTT01FIHYgPSZndDsgdik8 YnI+wqDCoMKgwqDCoCB8IChGbihzLGwpKSA9Jmd0Ozxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoCBG bihzLExpc3QubWFwIChzdWJzIGluc3RzKSBsKTxicj7CoMKgIGZ1biBhdWdtZW50MSB0aGV0YSAo eCxzKSA9PGJyPg0KwqDCoMKgwqDCoCBsZXQgdmFsIHMmIzM5OyA9IHN1YnMgdGhldGEgczxicj7C oMKgwqDCoMKgIGluIGlmIG9jY3Vyc19pbiB4IHMgYW5kYWxzbyBub3QgKHMgPSBWYXIoeCkpPGJy PsKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdGhlbiByYWlzZSBGYWlsICZxdW90O09jY3VycyBjaGVj ay4mcXVvdDs8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBlbHNlICh4LHMmIzM5Oyk8YnI+wqDC oMKgwqDCoCBlbmQ8YnI+wqDCoCBmdW4gcmF3X2F1Z21lbnQgcCBpbnN0cyA9IHA6OihMaXN0Lm1h cCAoYXVnbWVudDEgW3BdKSBpbnN0cyk8YnI+DQrCoMKgIGZ1biBhdWdtZW50ICh2LHQpIGluc3Rz ID08YnI+wqDCoMKgwqDCoCBsZXQgdmFsIHQmIzM5OyA9IHN1YnMgaW5zdHMgdDxicj7CoMKgwqDC oMKgIGluIGNhc2UgdCYjMzk7PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgIG9mIFZhciAodykgPSZn dDsgPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpZiB3ICZsdDs9IHYgPGJyPsKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdGhlbiBpZiB3ID0gdjxicj7CoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0aGVuIGluc3RzPGJy Pg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZWxz ZSByYXdfYXVnbWVudCAodix0JiMzOTspIGluc3RzPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgZWxzZSByYXdfYXVnbWVudCAodyxWYXIodikpIGluc3RzIDxicj7CoMKgwqDC oMKgwqDCoMKgwqDCoMKgIHwgXyA9Jmd0OyBpZiBvY2N1cnNfaW4gdiB0JiMzOTsgPGJyPsKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0aGVuIHJhaXNlIEZhaWwgJnF1 b3Q7T2NjdXJzIGNoZWNrLiZxdW90Ozxicj4NCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoCBlbHNlIHJhd19hdWdtZW50ICh2LHQmIzM5OykgaW5zdHM8YnI+wqDCoMKg wqDCoCBlbmQ8YnI+wqDCoMKgIGZ1biBpdGxpc3QyIGYgPTxicj7CoMKgwqDCoMKgIGxldCBmdW4g aXRlciBbXSBbXSA9IChmbiBiID0mZ3Q7IGIpPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfCBp dGVyIChoOjp0KSAoaCYjMzk7Ojp0JiMzOTspID0gKGZuIGIgPSZndDsgZiBoIGgmIzM5OyAoaXRs aXN0MiBmIHQgdCYjMzk7IGIpKTxicj4NCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfCBpdGVyIF8g XyA9IHJhaXNlIEZhaWwgJnF1b3Q7QXJpdHkuJnF1b3Q7PGJyPsKgwqDCoMKgwqAgaW4gaXRlcjxi cj7CoMKgwqDCoMKgIGVuZDxicj7CoMKgIGZ1biB1bmlmeSB0bTEgdG0yIGluc3RzID08YnI+wqDC oMKgwqDCoCBjYXNlIHRtMTxicj7CoMKgwqDCoMKgwqDCoCBvZiBWYXIoeCkgPSZndDsgPGJyPsKg wqDCoMKgwqDCoMKgwqDCoMKgIChjYXNlIGFzc29jIHggaW5zdHM8YnI+wqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqAgb2YgTk9ORSA9Jmd0OyBhdWdtZW50ICh4LHRtMikgaW5zdHM8YnI+DQrCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwgU09NRSB0bTEmIzM5OyA9Jmd0OyB1bmlmeSB0bTEm IzM5OyB0bTIgaW5zdHMpPGJyPsKgwqDCoMKgwqDCoMKgwqAgfCBGbihmMSxhcmdzMSkgPSZndDs8 YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqAgKGNhc2UgdG0yPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgIG9mIChWYXIoeSkpID0mZ3Q7IDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCAoY2FzZSBhc3NvYyB5IGluc3RzPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIG9mIE5PTkUgPSZndDsgYXVnbWVudCAoeSx0bTEpIGluc3RzPGJyPg0KwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8IFNPTUUgdG0yJiMzOTsgPSZndDsg dW5pZnkgdG0xIHRtMiYjMzk7IGluc3RzKTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IHwgRm4oZjIsYXJnczIpID0mZ3Q7PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBpZiBmMSA9IGYyIHRoZW4gaXRsaXN0MiB1bmlmeSBhcmdzMSBhcmdzMiBpbnN0czxicj7C oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IGVsc2UgcmFpc2UgRmFpbCAoJnF1b3Q7Q29uc3RhbnRzOiBtaXNtYXRjaDogJnF1b3Q7XmYxXiZx dW90OyZsdDsmZ3Q7JnF1b3Q7XmYyKSk8YnI+DQrCoMKgIGZ1biByZW5hbWUgcyA9PGJyPsKgwqDC oMKgwqAgZm4gKFZhciB2KSA9Jmd0OyBWYXIoJnF1b3Q7fiZxdW90O152XnMpPGJyPsKgwqDCoMKg wqDCoCB8IChGbihmLGFyZ3MpKSA9Jmd0OyBGbihmLExpc3QubWFwIChyZW5hbWUgcykgYXJncyk8 YnI+wqDCoCBmdW4gcmVuYW1lX3J1bGUgcyAoY29uYyxhc3N1bXMpID08YnI+wqDCoMKgwqDCoMKg IChyZW5hbWUgcyBjb25jLExpc3QubWFwIChyZW5hbWUgcykgYXNzdW1zKTxicj4NCsKgwqAgZnVu IGV4cGFuZCBuIHJ1bGVzIGluc3RzIGdvYWxzID08YnI+wqDCoMKgwqDCoCBsZXQgZnVuIGZpcnN0 IGYgPTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgKGZuIFtdID0mZ3Q7IHJhaXNl IEZhaWwgJnF1b3Q7Tm8gcnVsZXMgYXBwbHkuJnF1b3Q7PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqAgfCAoaDo6dCkgPSZndDsgKGYgaCBoYW5kbGUgRmFpbCBfID0mZ3Q7IGZp cnN0IGYgdCkpPGJyPsKgwqDCoMKgwqDCoMKgwqDCoCBmdW4gc2VhcmNoIHJ1bGUgPSA8YnI+DQrC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaWYgZ29hbHMgPSBbXTxicj7CoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqAgdGhlbiBpbnN0czxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgZWxzZTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgbGV0IGZ1biBl cWdvYWwgKEZuKCZxdW90OyE9JnF1b3Q7LFthLGJdKSkgPSBub3QgKGEgPSBiKTxicj7CoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgfCBlcWdvYWwgXyA9IGZh bHNlPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHZhbCAo Y29uYyxhc3N1bXMpID0gcmVuYW1lX3J1bGUgKEludC50b1N0cmluZyBuKSBydWxlPGJyPg0KwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdmFsIGdvYWwgPSBoZCBn b2Fsczxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB2YWwg aW5zdHMmIzM5OyA9IGlmIGVxZ29hbCBnb2FsPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdGhlbiBp bnN0cyAoKiBDSEVDSyEgVGhpcyBpcyBwcm9iYWJseSB3cm9uZy4gKik8YnI+wqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCBlbHNlIHVuaWZ5IGNvbmMgZ29hbCBpbnN0czxicj4NCsKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGZ1biBvY2N1cnMgKHYsXykgPSBvY2N1cnNfaW4g diBjb25jPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIG9yZWxzZSBMaXN0LmV4aXN0cyAob2NjdXJzX2luIHYpIGFz c3Vtczxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB2YWwg KGxvYyxnbG9iKSA9IExpc3QucGFydGl0aW9uIG9jY3VycyBpbnN0cyYjMzk7PGJyPsKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHZhbCBnb2FscyYjMzk7ID0gKExp c3QubWFwIChzdWJzIGxvYykgYXNzdW1zKSBAICh0bCBnb2Fscyk8YnI+DQrCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaW4gZXhwYW5kIChuKzEpIHJ1bGVzIGdsb2IgZ29hbHMm IzM5Ozxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZW5kPGJyPsKgwqDC oMKgwqAgaW48YnI+wqDCoMKgwqDCoMKgwqDCoCBmaXJzdCBzZWFyY2ggcnVsZXM8YnI+wqDCoMKg wqDCoCBlbmQ8YnI+aW48YnI+wqDCoCBmdW4gcHJvbG9nIHJ1bGVzIGdvYWwgPTxicj7CoMKgwqDC oMKgIGxldCB2YWwgaW5zdHMgPSBleHBhbmQgMCBydWxlcyBbXSBbZ29hbF08YnI+DQrCoMKgwqDC oMKgIGluIFllcyAoTGlzdC5maWx0ZXIgKGZuICh2LF8pID0mZ3Q7IG9jY3Vyc19pbiB2IGdvYWwp IGluc3RzKTxicj7CoMKgwqDCoMKgIGVuZCBoYW5kbGUgRmFpbCBfID0mZ3Q7IE5vPGJyPmVuZDxi cj48YnI+SGVyZSBpcyBhbiBleGFtcGxlIG9mIHdoYXQgaXQgY2FuIGRvIChhIHJhdGhlciB0aXJl ZCBvbGQgb25lLCBidXQgYmVhcjxicj53aXRoIHVzLCBiZWNhdXNlIHdlIHdpbGwgc2hvcnRseSBy ZWludGVycHJldCB0aGlzIGFzIHNvbWV0aGluZzxicj4NCm1vcmUgaW50ZXJlc3RpbmcpOjxicj48 YnI+dmFsICgpID0gbG9hZCAmcXVvdDtQcm9sb2cmcXVvdDs7PGJyPjxicj52YWwgKCkgPSBNZXRh LnF1b3RhdGlvbiA6PSB0cnVlOzxicj48YnI+dmFsIHJzID0gUHJvbG9nLnJ1bGVzIGA8YnI+wqDC oCBtYWxlKGFsYmVydCkuPGJyPsKgwqAgbWFsZShlZHdhcmQpLjxicj48YnI+wqDCoCBmZW1hbGUo YWxpY2UpLjxicj7CoMKgIGZlbWFsZSh2aWN0b3JpYSkuPGJyPg0KPGJyPsKgwqAgZmF0aGVyX29m KGFsYmVydCxlZHdhcmQpLjxicj7CoMKgIGZhdGhlcl9vZihhbGJlcnQsYWxpY2UpLjxicj48YnI+ wqDCoCBtb3RoZXJfb2YodmljdG9yaWEsZWR3YXJkKS48YnI+wqDCoCBtb3RoZXJfb2YodmljdG9y aWEsYWxpY2UpLjxicj48YnI+wqDCoCBwYXJlbnRzKFgsTSxGKTotbW90aGVyX29mKE0sWCksZmF0 aGVyX29mKEYsWCkuPGJyPjxicj7CoMKgIHNpc3Rlcl9vZihYLFkpOi08YnI+DQrCoMKgwqDCoMKg IGZlbWFsZShYKSw8YnI+wqDCoMKgwqDCoCBwYXJlbnRzKFgsTSxGKSw8YnI+wqDCoMKgwqDCoCBw YXJlbnRzKFksTSxGKS48YnI+PGJyPsKgwqAgYnJvdGhlcl9vZihYLFkpOi08YnI+wqDCoMKgwqDC oCAhPShYLFkpLDxicj7CoMKgwqDCoMKgIG1hbGUoWCksPGJyPsKgwqDCoMKgwqAgcGFyZW50cyhY LE0sRiksPGJyPsKgwqDCoMKgwqAgcGFyZW50cyhZLE0sRikuPGJyPmA7PGJyPjxicj5UaGlzIGRl ZmluZXMgYSBkYXRhYmFzZSBvZiBmYWN0cywgdGhlIHNvLWNhbGxlZCBncm91bmQgdGVybXMsIHdo aWNoPGJyPg0KYXJlIHRob3NlIHdoaWNoIGRvbiYjMzk7dCBjb250YWluIGFueSBsb2dpY2FsIHZh cmlhYmxlcyAod2hpY2ggaW4gUHJvbG9nPGJyPmFyZSB0eXBpY2FsbHkgYWxsLXVwcGVyLWNhc2Ug aWRlbnRpZmllcnMpLiBUaGVuIHRoZXJlIGFyZSBfcnVsZXNfPGJyPndoaWNoIGRlZmluZSByZWxh dGlvbnMgKGluIHRoZSBzZXQtdGhlb3JldGljYWwgc2Vuc2Ugb2YgdGhlIHRlcm0sIGJ1dDxicj5o ZXJlIGFsc28gaW4gdGhlIGdlbmVhbG9naWNhbCBzZW5zZSkuPGJyPg0KPGJyPk5vdGUgdGhhdCB0 aGUgdHdvLXBsYWNlIHByZWRpY2F0ZSBzaXN0ZXJfb2YgaXMgaW5kaXJlY3RseSBkZWZpbmVkIGlu PGJyPnRlcm1zIGFub3RoZXIgcnVsZSwgd2hpY2ggZGVmaW5lcyB0aGUgcGFyZW50cyByZWxhdGlv bi4gQnV0IHRoZXNlIDg4PGJyPmxpbmVzIG9mIGNvZGUgd2lsbCByZXNvbHZlIHRoZSBpbmRpcmVj dGlvbiBhbmQgc28gdGhleSBjYW4gY29ycmVjdGx5PGJyPmRlZHVjZSwgZm9yIGV4YW1wbGU6PGJy Pg0KPGJyPsKgwqAgdmFsIGcgPSBQcm9sb2cuZ29hbCBgc2lzdGVyX29mKGFsaWNlLGVkd2FyZClg PGJyPsKgwqAgdmFsIHIgPSBQcm9sb2cucHJvbG9nIHJzIGc8YnI+PGJyPmdpdmluZyA8YnI+PGJy PsKgIHZhbCByID0gUHJvbG9nLlllcyBbXSA6IG91dGNvbWU8YnI+PGJyPk5vdyBsb29rIGF0IHRo ZSBkYXRhYmFzZSBvZiBmYWN0cywgYW5kIG5vdGUgdGhhdCBpdCBpcyByZWFsbHkganVzdCBhbjxi cj4NCmFic3RyYWN0IHN5bnRheCByZXByZXNlbnRhdGlvbiBvZiBhIGNvbGxlY3Rpb24gb2Ygc3Rh dGVtZW50cyBpbiBhbjxicj5hcmJpdHJhcnkgbGFuZ3VhZ2UgKGkuZS4gYSBsYW5ndWFnZSB3aXRo IHVuZGVmaW5lZCBzeW50YXgpLiBUaGVyZWZvcmU8YnI+b25lIGNhbiBhcHBseSBQcm9sb2cgZGVk dWN0aW9ucywgcXVpdGUgdHJpdmlhbGx5LCB0byBzZW50ZW5jZXMgaW4gYTxicj5kZWZpbmVkIHBy b2dyYW1taW5nIGxhbmd1YWdlIHN1Y2ggYXMgQy4gTm93IHRoZSBDIGNvbXBpbGVyLCB3aGljaCB3 ZTxicj4NCmltYWdpbmUgd2UgYXJlIGF0dGFja2luZywgYWxyZWFkeSBoYXMgYWxsIHRoZSBjb2Rl IHRvIGFuYWx5c2UgYW5kPGJyPm1hbmlwdWxhdGUgYWJzdHJhY3Qgc3ludGF4IHJlcHJlc2VudGF0 aW9ucyBvZiBDIHByb2dyYW1zLCBiZWNhdXNlIHRoYXQ8YnI+aXMgaXRzIGpvYiEgU28gSSBob3Bl IHBlb3BsZSBjYW4gc2VlLCB3aXRob3V0IG15IGhhdmluZyB0byBpbnN0YWxsIGl0PGJyPmludG8g R0NDIDQuOSwgdGhhdCBvbmUgY2FuIGVhc2lseSBpbXBsZW1lbnQgYSBQcm9sb2cgaW50ZXJwcmV0 ZXIgaW48YnI+DQp2ZXJ5IGxpdHRsZSBjb2RlLCB3aGljaCBjYW4gZGVjaWRlIGEgcXVpdGUgZ2Vu ZXJhbCBjbGFzcyBvZiBwcmVkaWNhdGVzPGJyPmNvbmNlcm5pbmcgYSBwcm9ncmFtLCB0aGUgc3Ry dWN0dXJlIG9mIHdoaWNoIGlzIHJlcHJlc2VudGVkIGluIHRoZTxicj5jb21waWxlciBhcyBhYnN0 cmFjdCBzeW50YXguPGJyPjxicj5Ob3cgbm90ZSB0aGF0IHRoZSBwcmVkaWNhdGVzIG5lZWQgbm90 IGhhdmUgYSBmaXhlZCAmIzM5O2RlcHRoLiYjMzk7IEhlcmUgYXJlPGJyPg0KdHdvIHJ1bGVzIGRl ZmluaW5nIGEgcGF0aCBpbiBhbiBhcmJpdHJhcnkgZGlyZWN0ZWQgZ3JhcGgsIHdoaWNoIGlzIGE8 YnI+bm9uLXdlbGxmb3VuZGVkIHN0cnVjdHVyZSBjYXBhYmxlIG9mIHJlcHJlc2VudGluZyBhbG1v c3QgYW55dGhpbmcsPGJyPmluY2x1ZGluZyB0aGUgc2VudGVuY2VzIG9mIGFueSBsYW5ndWFnZSBk ZWZpbmVkIGJ5IGEgY29udGV4dC1mcmVlPGJyPmdyYW1tYXIuPGJyPg0KPGJyPkhlcmUgdGhlIGdy b3VuZCB0ZXJtcyByZXByZXNlbnQgYSBncmFwaCBpbiB0aHJlZSBkaXNqb2ludCBwYXJ0cywgd2l0 aDxicj50d28gY3ljbGVzLjxicj48YnI+dmFsIHJzJiMzOTsmIzM5OyA9IFByb2xvZy5ydWxlcyBg PGJyPsKgwqAgZWRnZShnLGgpLjxicj7CoMKgIGVkZ2UoZSxmKS48YnI+wqDCoCBlZGdlKGYsZSku PGJyPsKgwqAgZWRnZShhLGIpLjxicj7CoMKgIGVkZ2UoYixjKS48YnI+wqDCoCBlZGdlKGMsZCku PGJyPg0KwqDCoCBlZGdlKGQsYSkuPGJyPsKgwqAgcGF0aChBLEIpOi1lZGdlKEEsQikuPGJyPsKg wqAgcGF0aChBLEIpOi1lZGdlKEEsQykscGF0aChDLEIpLjxicj5gOzxicj48YnI+UHJvbG9nIGNh biBkZXRlcm1pbmUgd2hldGhlciBvciBub3QgdGhlcmUgaXMgYSBwYXRoIGZyb20gb25lIHZlcnRl eCB0bzxicj5hbm90aGVyLCBubyBtYXR0ZXIgaG93IGZhciBhcGFydCB0aGV5IG1heSBiZTo8YnI+ PGJyPsKgwqAgdmFsIGcyID0gUHJvbG9nLmdvYWwgYHBhdGgoYSxkKWA8YnI+DQrCoMKgIHZhbCBy MiA9IFByb2xvZy5wcm9sb2cgcnMmIzM5OyYjMzk7IGcyPGJyPjxicj5JdCBwcmludHM8YnI+PGJy PsKgIHZhbCByMiA9IFByb2xvZy5ZZXMgW10gOiBvdXRjb21lPGJyPjxicj5BbmQgaXQgY2FuIHRl bGwgd2hpY2ggdmVydGljZXMgYXJlIHJlYWNoYWJsZSBmcm9tIGEgZ2l2ZW4gdmVydGV4Ojxicj48 YnI+wqDCoCB2YWwgZzMgPSBQcm9sb2cuZ29hbCBgcGF0aChiLFgpYDxicj7CoMKgIHZhbCByMyA9 IFByb2xvZy5wcm9sb2cgcnMmIzM5OyYjMzk7IGczPGJyPg0KPGJyPlRoZSByZXN1bHQgaXM8YnI+ PGJyPsKgIHZhbCByMyA9IFByb2xvZy5ZZXMgWygmcXVvdDtYJnF1b3Q7LCBQcm9sb2cuRm4oJnF1 b3Q7YyZxdW90OywgW10pKV0gOiBvdXRjb21lPGJyPjxicj5JbiB0aGlzIGltcGxlbWVudGF0aW9u IGl0IG9ubHkgcHJpbnRzIHRoZSBmaXJzdCBzdWNoIGVkZ2UsIGJ1dCBpdDxicj5jb3VsZCBmaW5k IHRoZW0gYWxsLjxicj48YnI+U28gaXQgc2hvdWxkIG5vdCByZXF1aXJlIGFueSBncmVhdCBzdHJl dGNoaW5nIG9mIHBlb3BsZSYjMzk7cyBjcmVkdWxpdHkgdG88YnI+DQpzZWUgdGhhdCBhIHZlcnkg ZmV3IGxpbmVzIG9mIGludGVsbGlnZW50bHkgd3JpdHRlbiBjb2RlIGNhbiByZWNvZ25pc2U8YnI+ bGFyZ2Utc2NhbGUgc3RydWN0dXJlIGluIGFic3RyYWN0IHN5bnRheCwgZXZlbiB3aGVuIHF1aXRl IGV4dGVuc2l2ZTxicj5jaGFuZ2VzIG1heSBoYXZlIGJlZW4gbWFkZSB0byB0aGUgbGVhdmVzLjxi cj48YnI+Tm93IHdlIG5lZWQgdG8gc2hvdyBpdCBjb3VsZCByZS13cml0ZSB0aG9zZSBwcm9ncmFt cy4gVGhpcyBpcyBlYXN5LDxicj4NCmJlY2F1c2UgaW4gZmFjdCBhIEMgY29tcGlsZXIgYWxyZWFk eSBkb2VzIHRoaXMuIEl0IGhhcyB0bywgYmVjYXVzZSB0aGU8YnI+c3ludGF4IG9mIEMgaXMgbm90 IHN1ZmZpY2llbnQgdG8gZGV0ZXJtaW5lIHdoYXQgaXMgYSB3ZWxsLWZvcm1lZCBDPGJyPnByb2dy YW0gYW5kIHdoYXQgaXMgbm90LiBIZXJlIGlzIGFuIGV4YW1wbGUgb2YgcHJvZ3JhbW1lZCByZS13 cml0aW5nPGJyPm9mIGFyYml0cmFyeSBmcmFnbWVudHMgb2YgYSBDIHByb2dyYW0uIFdoYXQgdGhp cyBkb2VzIGlzIHNwbGl0IGE8YnI+DQpjb21wb3VuZCB0eXBlZGVmIHN0YXRlbWVudCAoYW55IGNv bXBvdW5kIHR5cGVkZWYgc3RhdGVtZW50IHdoYXRzb2V2ZXIpPGJyPmludG8gc2VwYXJhdGUgcGFy dHM6PGJyPjxicj7CoMKgIHZhbCByZXdyaXRlX3R5cGVkZWYgPTxicj7CoMKgwqDCoMKgwqDCoMKg IHJld3JpdGVxIGA8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCDin6ZkZWNsYXJhdGlvbjxicj7C oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIOKMnHc6ZGVjbGFyYXRpb24tc3BlY2lmaWVyc+KM nTxicj4NCsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgKGluaXQtZGVjbGFyYXRvci1saXN0 PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg4oyceDppbml0LWRlY2xhcmF0 b3ItbGlzdOKMnTxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIOKMnHk6aW5p dC1kZWNsYXJhdG9y4oydKeKfpyA9PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgKGRl Y2xhcmF0aW9uLWxpc3Q8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAoZGVj bGFyYXRpb24tbGlzdDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IOKfpmRlY2xhcmF0aW9uIOKMnHfijJ0g4oyceOKMneKfpyk8YnI+DQrCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIChkZWNsYXJhdGlvbiDijJx34oydIChpbml0LWRlY2xhcmF0b3It bGlzdCDijJx54oydKSkpYDxicj48YnI+U28gdGFraW5nIHRoaXMgdHlwZWRlZjo8YnI+PGJyPsKg wqAgdmFsIHRkID0gYWJzeW50cSBgdHlwZWRlZiB1bnNpZ25lZCBpbnQgdWksICpwdWksICgqZnVu Y3ApIChpbnQgaSk7YDxicj48YnI+d2UgcHJvZHVjZSB0aGlzIHJld3JpdHRlbiBhYnN0cmFjdCBz eW50YXggd2l0aCB0aHJlZSBzZXBhcmF0ZTxicj4NCnR5cGVkZWYgZGVjbGFyYXRpb25zOjxicj48 YnI+ZXh0ZXJuYWwtZGVjbGFyYXRpb25zOjxicj7CoCBleHRlcm5hbC1kZWNsYXJhdGlvbjo8YnI+ wqDCoMKgIGRlY2xhcmF0aW9uLWxpc3Q6PGJyPsKgwqDCoMKgwqAgZGVjbGFyYXRpb24tbGlzdDo8 YnI+wqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRpb24tbGlzdDo8YnI+wqDCoMKgwqDCoMKgwqDCoMKg IGRlY2xhcmF0aW9uLWxpc3Q6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRpb246 PGJyPg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRpb24tc3BlY2lmaWVyczo8 YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHN0b3JhZ2UtY2xhc3Mtc3BlY2lmaWVy OiB0eXBlZGVmPGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkZWNsYXJhdGlvbi1z cGVjaWZpZXJzOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHR5cGUtc3Bl Y2lmaWVyOiB1bnNpZ25lZDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRl Y2xhcmF0aW9uLXNwZWNpZmllcnM6PGJyPg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgdHlwZS1zcGVjaWZpZXI6IGludDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBpbml0LWRlY2xhcmF0b3ItbGlzdDo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IGluaXQtZGVjbGFyYXRvcjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBk ZWNsYXJhdG9yOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkaXJl Y3QtZGVjbGFyYXRvcjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIGlkZW50aWZpZXI6IHVpPGJyPg0KwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9uOjxi cj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9uLXNwZWNpZmllcnM6PGJyPsKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIHN0b3JhZ2UtY2xhc3Mtc3BlY2lmaWVyOiB0eXBlZGVmPGJy PsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9uLXNwZWNpZmllcnM6PGJyPsKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0eXBlLXNwZWNpZmllcjogdW5zaWduZWQ8YnI+ wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9uLXNwZWNpZmllcnM6PGJy Pg0KwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0eXBlLXNwZWNpZmllcjogaW50 PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaW5pdC1kZWNsYXJhdG9yLWxpc3Q6PGJyPsKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIGluaXQtZGVjbGFyYXRvcjo8YnI+wqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0b3I6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgcG9pbnRlcjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBk aXJlY3QtZGVjbGFyYXRvcjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgaWRlbnRpZmllcjogcHVpPGJyPg0KwqDCoMKgwqDCoCBkZWNsYXJhdGlvbjo8YnI+wqDCoMKg wqDCoMKgwqAgZGVjbGFyYXRpb24tc3BlY2lmaWVyczo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgIHN0 b3JhZ2UtY2xhc3Mtc3BlY2lmaWVyOiB0eXBlZGVmPGJyPsKgwqDCoMKgwqDCoMKgwqDCoCBkZWNs YXJhdGlvbi1zcGVjaWZpZXJzOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHR5cGUtc3BlY2lm aWVyOiB1bnNpZ25lZDxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0aW9uLXNwZWNp ZmllcnM6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHR5cGUtc3BlY2lmaWVyOiBpbnQ8 YnI+DQrCoMKgwqDCoMKgwqDCoCBpbml0LWRlY2xhcmF0b3ItbGlzdDo8YnI+wqDCoMKgwqDCoMKg wqDCoMKgIGluaXQtZGVjbGFyYXRvcjo8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkZWNsYXJh dG9yOjxicj7CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkaXJlY3QtZGVjbGFyYXRvcjo8YnI+ wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRpcmVjdC1kZWNsYXJhdG9yOjxicj7CoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGRlY2xhcmF0b3I6PGJyPsKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHBvaW50ZXI6PGJyPg0KwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGlyZWN0LWRlY2xhcmF0b3I6PGJyPsKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpZGVudGlmaWVyOiBmdW5jcDxicj7CoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcGFyYW1ldGVyLXR5cGUtbGlzdDo8YnI+wqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBwYXJhbWV0ZXItbGlzdDo8YnI+wqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcGFyYW1ldGVyLWRlY2xhcmF0aW9uOjxicj7C oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZGVjbGFyYXRpb24tc3Bl Y2lmaWVyczo8YnI+DQrCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgIHR5cGUtc3BlY2lmaWVyOiBpbnQ8YnI+wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgIGRlY2xhcmF0b3I6PGJyPsKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqAgZGlyZWN0LWRlY2xhcmF0b3I8YnI+wqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgaWRlbnRpZmllciBpPGJyPjxicj5UaGUg Z2VuZXJhbCBzeXN0ZW0sIGNhcGFibGUgb2YgaGFuZGxpbmcgZXh0cmVtZWx5IGNvbXBsZXggcmV3 cml0ZXM8YnI+DQpsaWtlIHRoaXMsIHdoaWNoIGNhbiBiZSBuZXN0ZWQgYW5kIGNhbGxlZCAoY29u ZGl0aW9uYWxseSBhbmQvb3I8YnI+cmVjdXJzaXZlbHkpIG9uZSBmcm9tIGFub3RoZXIsIHdpdGgg cGFyYW1ldGVycywgaXMgaW1wbGVtZW50ZWQgaW48YnI+YWJvdXQgNDAwIGxpbmVzIG9mIHJhdGhl ciBiYWRseSB3cml0dGVuIFN0YW5kYXJkIE1MLiBJdCBpcyBub3QgUHJvbG9nLDxicj5idXQgaXQg dXNlcyBhIHNpbWlsYXIgdW5pZmljYXRpb24gYWxnb3JpdGhtIHRvIGlkZW50aWZ5IGNlcnRhaW48 YnI+DQpsYXJnZS1zY2FsZSBzdHJ1Y3R1cmVzIGluZGVwZW5kZW50bHkgb2YgbWFueSBkZXRhaWxz IG9mIHBhcnRpY3VsYXI8YnI+aW5zdGFuY2VzLCB3aGljaCBjYW4gdmFyeSBxdWl0ZSBzaWduaWZp Y2FudGx5Ljxicj48YnI+VGhlc2UgcHJvZ3JhbXMsIHRoZSBQcm9sb2cgaW50ZXJwcmV0ZXIgYW5k IHRoZSBSZXdyaXRlIGVuZ2luZSwgY29tcGlsZTxicj50byAxNSw1MzMgYW5kIDI0LDUzNSsyOCw5 NDQgYnl0ZXMgcmVzcGVjdGl2ZWx5IG9mIENBTUwgYnl0ZWNvZGUuIEk8YnI+DQp3b3VsZCBub3Qg ZXhwZWN0IGEgQyBpbXBsZW1lbnRhdGlvbiBvZiBzaW1pbGFyIGFsZ29yaXRobXMgdG8gYmUgbXVj aDxicj5tb3JlIHRoYW4gdGhpcy4gSWYgYW55b25lIGRvdWJ0cyBzb21lb25lJiMzOTtzIGNoYW5j ZXMgb2YgZWZmZWN0aXZlbHk8YnI+aGlkaW5nIHRoaXMgbXVjaCBjb2RlIGluIGEgQyBjb21waWxl ciBiaW5hcnksIHRoZW4gdGhleSBzaG91bGQ8YnI+Y29uc2lkZXIgdGhhdCBvbiBteSBzeXN0ZW0s IGJldHdlZW4gR0NDIDQuNSBhbmQgR0NDIDQuOSwgdGhlIGNvbWJpbmVkPGJyPg0KY29tcGlsZXIg YmluYXJpZXM6IGdjYywgY3BwLCBjYzEsIGFzIGFuZCBsZCBncmV3IGZyb20gMTAgTUIgdG8gb3Zl ciA3MDxicj5NQi4gU28gSSB0aGluayBpdCB3b3VsZCBub3QgYmUgdG9vIGRpZmZpY3VsdCB0byBo aWRlIGFuIGV4dHJhIDgwayBvZjxicj5vYmplY3QgY29kZSBpbiBhIGJpbmFyeS4gVGhhdCByZXBy ZXNlbnRzIGFuIGluY3JlYXNlIG9mIGFyb3VuZCBvbmU8YnI+dGVudGggb2Ygb25lIHBlcmNlbnQg b3ZlciB0aGUgdG90YWwgNzBNQiAod2hpY2ggSSBjb25zaWRlciBxdWl0ZTxicj4NCnJpZGljdWxv dXMsIGJ5IHRoZSB3YXkuIE9uZSBwb3NzaWJsZSBleHBsYW5hdGlvbiBpcyB0aGF0IEdDSFEgYW5k IHRoZTxicj5OU0EgYXJlIHBsYXlpbmcgY29yZS13YXJzIGluIHRoZSBHQ0MgYmluYXJpZXMuKTxi cj48YnI+Tm93IHRob3NlIHN0aWxsIHJlYWRpbmcgdGhpcyB3aWxsIGFwcHJlY2lhdGUgdGhhdCB0 aGUgcmV3cml0ZSBlbmdpbmUsPGJyPmFuZCB0aGUgUHJvbG9nIGludGVycHJldGVyLCBhcmUgcXVp dGUgYWJzdHJhY3QgaW4gdGhlIHNlbnNlIHRoYXQgdGhleTxicj4NCmludGVycHJldCBfYXJiaXRy YXJ5XyBydWxlcywgYW5kIHNvIHRoZXkgY291bGQgZWFzaWx5IGJlIGltcGxlbWVudGVkPGJyPmlu IHN1Y2ggYSB3YXkgdGhhdCB0aGUgcnVsZXMgY2FuIGJlIGNoYW5nZWQgYWZ0ZXIgdGhlIGZhY3Qs IGJ5IGNvZGluZzxicj5uZXcgcnVsZXMgaW50byB0aGUgY29tcGlsZXImIzM5O3Mgc291cmNlIGNv ZGUuIFRoZSBjb2RpbmcgY291bGQgYmUgaW48YnI+Y29tbWVudHMsIG9yIGl0IGNvdWxkIGJlIGlu IHRoZSBjaG9pY2Ugb2YgdmFyaWFibGUgbmFtZXMsIG9yIGl0IGNvdWxkPGJyPg0KYmUgaW4gdGVy bXMgb2YgdGhlIG51bWJlciBvZiBzcGFjZXMgYXBwZWFyaW5nIGF0IHRoZSBlbmRzIG9mIGxpbmVz PGJyPndoaWNoIGFyZSBjZXJ0YWluIHN1Y2Nlc3NpdmUgcHJpbWUgbXVsdGlwbGVzIG9mIGxpbmVz IGFwYXJ0LiBUaGVuLCBieTxicj5hcHBseWluZyBhIHB1YmxpY2x5IHNjcnV0aW5pc2VkIHBhdGNo IHRvIHRoZSBjb21waWxlciBzb3VyY2UsIHRoZTxicj5wZW5ldHJhdG9ycyBjb3VsZCByZXByb2dy YW0gdGhlIHRyYXAgZG9vciBhbHJlYWR5IGluIGFsbCB0aGUgYmluYXJpZXM8YnI+DQpvZiB0aGUg cHJldmlvdXMgdmVyc2lvbnMgb2YgdGhlIG5ldyBjb21waWxlciwgc28gdGhhdCB0aGV5IHJlY29n bmlzZTxicj5hbmQgZWZmZWN0aXZlbHkgY29tcHJvbWlzZSB0aGUgbmV3IGNvbXBpbGVyJiMzOTtz IHNvdXJjZSBzdHJ1Y3R1cmUuIEFuZDxicj53aGlsZSB0aGV5JiMzOTtyZSBhdCBpdCwgdGhleSBt YXkgYXMgd2VsbCBjaGFuZ2UgdGhlIGNvZGluZyBzeXN0ZW0gdXNlZCB0bzxicj4NCnRyYW5zbWl0 IG5ldyBydWxlcywgc28gdGhhdCBubyBtb3JlIHRoYW4gb25lIGluc3RhbmNlIG9mIGFueSBlbmNy eXB0ZWQ8YnI+bWVzc2FnZSBldmVyIGV4aXN0cy48YnI+PGJyPlRoaXMgaXMgb25seSB0aGUgdGlw IG9mIHRoZSBpY2UtYnVyZzsgYW5kIHRoZSBsZXNzIGV2aWRlbmNlIEkgc2VlIHRoYXQ8YnI+cGVv cGxlIGFyZSBwcm9wZXJseSBhZGRyZXNzaW5nIHRoaXMgJiMzOTtpc3N1ZSYjMzk7LCB0aGUgbW9y ZSBvZiB0aGVzZTxicj4NCiYjMzk7c3VnZ2VzdGlvbnMmIzM5OyBJIHdpbGwgcHVibGlzaCBvdmVy IHRoZSBuZXh0IGZldyBkYXlzLiBBbmQgSSB0aGluayB0aGF0PGJyPmFmdGVyIG5vdCBzbyB2ZXJ5 IGxvbmcsIHBlb3BsZSB3aWxsIGJlIGxlc3MgaW5jbGluZWQgdG8gbWFrZSB1bmZvdW5kZWQ8YnI+ Y2xhaW1zIGFib3V0IHRoZSByZWxhdGl2ZSBpbXByb2JhYmlsaXR5IG9mIHN1Y2ggYW4gYXR0YWNr LiBJJiMzOTttIGxvb2tpbmc8YnI+DQpmb3J3YXJkIHRvIGl0OiBzb21lIG9mIHRoZW0gYXJlIHJl YWxseSwgcmVhbGx5IHdoYWNreSEgQW5kIG5lZWRsZXNzIHRvPGJyPnNheSwgbm9uZSBvZiB0aGVt IGFyZSBvcmlnaW5hbC4gVGhpcyBsYXN0IGlzIGp1c3QgYSBzdGFuZGFyZCBpbnN0YW5jZTxicj5v ZiB0aGUgdGVsZXR5cGUgc3RyaW5nIHRyaWdnZXIgdHJhcCBkb29yIHRoYXQgS2FyZyBhbmQgU2No ZWxsPGJyPmRlc2NyaWJlZCA0MCB5ZWFycyBhZ28gaW4gdGhlIE11bHRpY3MgU2VjdXJpdHkgRXZh bHVhdGlvbjo8YnI+DQpWdWxuZXJhYmlsaXR5IEFuYWx5c2lzLiBUaGF0IGRvY3VtZW50IGlzIHdl bGwgd29ydGggYSBjYXJlZnVsPGJyPnJlYWQuIFRoZSBGaXJzdCBXb3JsZCBJbmZvcm1hdGlvbiBX YXIgc3RhcnRlZCBkZWNhZGVzIGFnbywgd2UgdGhpbmssPGJyPmJ1dCBzb21lIHBlb3BsZSBhcHBh cmVudGx5IGhhdmVuJiMzOTt0IGNvdHRvbmVkLW9uIHlldC48YnI+PGJyPkhhcHB5IGhhY2tpbmcs IGV2ZXJ5b25lITxicj4NCjxicj5JYW48YnI+PGJyPjwvZGl2Pg0K --047d7b86c92ec328bf050240c02e--