Return-Path: X-Original-To: apmail-accumulo-user-archive@www.apache.org Delivered-To: apmail-accumulo-user-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 86653112B7 for ; Tue, 15 Jul 2014 18:08:43 +0000 (UTC) Received: (qmail 72187 invoked by uid 500); 15 Jul 2014 18:08:43 -0000 Delivered-To: apmail-accumulo-user-archive@accumulo.apache.org Received: (qmail 72139 invoked by uid 500); 15 Jul 2014 18:08:43 -0000 Mailing-List: contact user-help@accumulo.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: user@accumulo.apache.org Delivered-To: mailing list user@accumulo.apache.org Received: (qmail 72129 invoked by uid 99); 15 Jul 2014 18:08:43 -0000 Received: from athena.apache.org (HELO athena.apache.org) (140.211.11.136) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 15 Jul 2014 18:08:43 +0000 X-ASF-Spam-Status: No, hits=3.2 required=5.0 tests=FREEMAIL_REPLY,HTML_MESSAGE,RCVD_IN_DNSWL_NONE,SPF_PASS,WEIRD_PORT X-Spam-Check-By: apache.org Received-SPF: pass (athena.apache.org: domain of michael.moss@gmail.com designates 209.85.192.49 as permitted sender) Received: from [209.85.192.49] (HELO mail-qg0-f49.google.com) (209.85.192.49) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 15 Jul 2014 18:08:39 +0000 Received: by mail-qg0-f49.google.com with SMTP id 63so5136947qgz.36 for ; Tue, 15 Jul 2014 11:08:18 -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 :content-type; bh=K90mogyv9g/MihSPWKmILUm3yRlrZNI6hbhNnbhdLI0=; b=lRk4azmliPd7FKZ2BcBtoQ+N0GMxarRaYks7kT3EnXbSoWPd+g2/0CYNs2V62UColY 0kzakYNmbrFhD74T58sn9M08PS7x197jPpkw0TGPvyq6inVKn24VH5nCnU1gGKCFow6I ZlWmen4R3P8ifNsNgeuQxDo7uKo1zQRzSvk3gzD6ufGF00LBCPRSqntbs3syQJF81+RF W8NtDkoSXE5O68YqLa4/M7VY+b+WSy1TJbVuyxR8IayhydgB4DI/OiZdRop9HT/pVeDa tDveRoQwx7VeKHGjgXN6M5kQR7uMx/pbBohePEdWm/V9YhRpKbPqfA5U5L+xNdeRuKQZ foBQ== MIME-Version: 1.0 X-Received: by 10.224.136.70 with SMTP id q6mr37813253qat.14.1405447698098; Tue, 15 Jul 2014 11:08:18 -0700 (PDT) Received: by 10.96.207.74 with HTTP; Tue, 15 Jul 2014 11:08:17 -0700 (PDT) In-Reply-To: <53C556D1.5030906@gmail.com> References: <53C45034.7000504@gmail.com> <53C556D1.5030906@gmail.com> Date: Tue, 15 Jul 2014 14:08:17 -0400 Message-ID: Subject: Re: Iterating/Aggregating/Combining Complex (Java POJO/Avro) Values From: Michael Moss To: user@accumulo.apache.org Content-Type: multipart/alternative; boundary=001a11c22826cbb15404fe3f4ad6 X-Virus-Checked: Checked by ClamAV on apache.org --001a11c22826cbb15404fe3f4ad6 Content-Type: text/plain; charset=UTF-8 Cool. I'll write something up and share. I'm curious how to get my Counter (WrappingIterator) implementation to aggregate by row (which, for some reason, I assumed was default?) Let's say I have rows (and CF="", CQ="" and versioningiterator off): 1 (Value1, Value 2...Value N) 2 3 How can my iterator return? 1 (Count of values 1..N) 2 (Count of values 1..N) 3 ... I tried scan -b "1" -e "1" and it counts an individual row. But if I don't specify anything, it returns, 3 (Count of all values across all rows) Code: http://pastebin.com/8xFNLHFS Example: root@dev pe> listiter -scan -t pojo - - Iterator counter, scan scope options: - iteratorPriority = 10 - iteratorClassName = iterators.Counter - root@dev pe> scan -b "1_1_20140101" -e "1_1_20140101" 1_1_20140101 : [public] 65 root@dev pe> scan -b "1_1_20140101" -e "3_9_20140727" 3_9_20140727 : [public] 100000 root@dev pe> scan 3_9_20140727 : [public] 100000 Thanks. -Mike On Tue, Jul 15, 2014 at 12:29 PM, Josh Elser wrote: > There's been some mention about a desire to rethink the Iterator interface > as it has some deficiencies (notably the lack of a "cleanup" before the > iterators are torn down), but no one has stated that they're actively > working on this. > > Getting better documentation wrt to convetions: let us know where the > Accumulo documentation falls short (and give us patches to fix the > documentation :D). Additionally, write up your own findings from problems > that you've run into. It's the entire community (users specifically) that > we need to help encourage to grow. > > Even things as simple as "how do I count entries in an iterator" are big > as you are now an "expert" on the subject :) > > > On 7/15/14, 12:17 PM, Michael Moss wrote: > >> That worked ;) - Thanks! >> >> What a journey... >> >> I like Accumulo's architecture and promise, but the difficulty in >> querying it (lack of documentation, conventions) is a major concern and >> I'd imagine has to have an impact on adoption. I'm curious if there have >> been any conversations around changing the interface around iterators >> which are still confusing to me. Let me know how I can help! >> >> >> On Tue, Jul 15, 2014 at 12:03 PM, William Slacum >> > >> >> wrote: >> >> Herp... serves me right for not setting up a proper test case. >> >> I think you need to override seek as well: >> >> @Override >> public void seek(...) throws IOException { >> super.seek(...); >> next(); >> } >> >> I think I just realized the wrapping iterator could use some clean >> up, because this isn't obvious. Basically after the wrapping >> iterator's seek is called, it never calls the implementor's next() >> to actually set up the first top key and value. >> >> >> >> On Tue, Jul 15, 2014 at 9:50 AM, Michael Moss >> > wrote: >> >> I set up debugging and am rethrowing the exception. What's >> strange is it appears that despite the iterator instance being >> properly set to iterator.Counter (my implementation), my >> breakpoints aren't being hit, only in the parent classes >> (Wrapping Iterator) and (SortedKeyValueIterator). >> >> I have two rows in the table, when I scan with no iterator: >> 2014-07-15 06:46:26,577 [Audit ] INFO : operation: permitted; >> user: root; action: scan; targetTable: pojo; authorizations: >> public,; range: (-inf,+inf); columns: []; iterators: []; >> iteratorOptions: {}; >> 2014-07-15 06:46:26,589 [tserver.TabletServer] DEBUG: ScanSess >> tid 10.0.2.15:45073 8*2 entries* in >> >> 0.01 secs, nbTimes = [7 7 7.00 1] >> >> When I scan with the iterator (0 entries?): >> 2014-07-15 06:45:58,036 [Audit ] INFO : operation: permitted; >> user: root; action: scan; targetTable: pojo; authorizations: >> public,; range: (-inf,+inf); columns: []; iterators: []; >> iteratorOptions: {}; >> 2014-07-15 06:45:58,047 [tserver.TabletServer] DEBUG: ScanSess >> tid 10.0.2.15:44992 8 *0 entries* in >> >> 0.01 secs, nbTimes = [6 6 6.00 1] >> >> No exceptions otherwise. Really appreciate all the ongoing help. >> >> Best, >> >> -Mike >> >> >> On Mon, Jul 14, 2014 at 6:40 PM, William Slacum >> > > wrote: >> >> Anything in your Tserver log? I think you should just >> rethrow that IOExcepton on your source's next() method, >> since they're usually not recoverable (ie, just make >> Counter#next throw IOException) >> >> >> On Mon, Jul 14, 2014 at 5:48 PM, Josh Elser >> > wrote: >> >> A quick sanity check is to make sure you have data in >> the table and that you can read the data without your >> iterator (I've thought I had a bug because I didn't have >> proper visibilities more times than I'd like to admit). >> >> Alternatively, you can also enable remote-debugging via >> Eclipse into the TabletServer which might help you >> understand more of what's going on. >> >> Lots of articles on how to set this up [1]. In short, >> add -Xdebug >> -Xrunjdwp:transport=dt_socket,__server=y,address=8000 to >> >> ACCUMULO_TSERVER_OPTS in accumulo-env.sh, restart the >> tserver, connect eclipse to 8000 via the Debug >> configuration menu, set a breakpoint in your init, seek >> and next methods, and `scan` in the shell. >> >> >> [1] >> http://javarevisited.blogspot. >> __com/2011/02/how-to-setup-__remote-debugging-in.html >> >> > setup-remote-debugging-in.html> >> >> >> On 7/14/14, 5:33 PM, Michael Moss wrote: >> >> Hmm...Still doesn't return anything from the shell. >> >> http://pastebin.com/ndRhspf8 >> >> Any thoughts? What's the best way to debug these? >> >> >> On Mon, Jul 14, 2014 at 5:14 PM, William Slacum >> > >> > >> >> >> >> wrote: >> >> Ah, an artifact of me just willy nilly writing >> an iterator :) Any >> reference to `this.source` should be replaced >> with >> `this.getSource()`. In `next()`, your >> workaround ends up calling >> `this.hasTop()` as the while loop condition. It >> will always return >> false because two lines up we set `top_key` to >> null. We need to make >> sure that the source iterator has a top, >> because we want to read >> data from it. We'll have to change the loop >> condition to >> `while(this.getSource().__hasTop())`. On line >> >> 38 of your code we'll >> need to call `this.getSource().next()` instead >> of `this.next()`. >> >> The iterator interface is documented, but there >> hasn't been a >> definitive go-to for making one. I've been >> drafting a blog post, but >> since it doesn't exist yet, hopefully the >> following will suffice. >> >> The lifetime of an iterator is (usually) as >> follows: >> >> (1) A new instance is called via >> Class.newInstance (so a no-args >> constructor is needed) >> (2) Init is called. This allows users to >> configure the iterator, set >> its source, and possible check the environment. >> We can also call >> `deepCopy` on the source if we want to have >> multiple sources (we'd >> do this if we wanted to do a merge read out of >> multiple column >> families within a row). >> (3) seek() is called. This gets our readers to >> the correct positions >> in the data that are within the scan range the >> user requested, as >> well as turning column families on or off. The >> name should >> reminiscent of seeking to some key on disk. >> (4) hasTop() is called. If true, that means we >> have data, and the >> iterator has a key/value pair that can be >> retrieved by calling >> getTopKey() and getTopValue(). If fasle, we're >> done because there's >> no data to return. >> (5) next() is called. This will attempt find a >> new top key and >> value. We go back to (4) to see if next was >> successful in finding a >> new top key/value and will repeat until the >> client is satisfied or >> hasTop() returns false. >> >> You can kind of make a state machine out of >> those steps where we >> loop between (4) and (5) until there's no data. >> There are more >> advanced workflows where next() can be reading >> from multiple >> sources, as well as seeking them to different >> positions in the tablet. >> >> >> On Mon, Jul 14, 2014 at 4:51 PM, Michael Moss >> > >> > >> __>> wrote: >> >> Thanks, William. I was just hitting you up >> for an example :) >> >> I adapted your pseudocode >> (http://pastebin.com/ufPJq0g3)__, but >> >> noticed that "this.source" in your example >> didn't have >> visibility. Did I worked around it correctly? >> >> When I add my iterator to my table and run >> scan from the shell, >> it returns nothing - what should I expect >> here? In general I've >> found the iterator interface pretty >> confusing and haven't spent >> the time wrapping my head around it yet. >> Any documentation or >> examples (beyond what I could find on the >> site or in the code) >> appreciated! >> >> /root@dev> table pojo/ >> /root@dev pojo> listiter -scan -t pojo/ >> /-/ >> /- Iterator counter, scan scope options:/ >> /- iteratorPriority = 10/ >> /- iteratorClassName = >> iterators.Counter/ >> /-/ >> /root@dev pojo> scan/ >> /root@dev pojo>/ >> >> >> Best, >> >> -Mike >> >> >> >> >> On Mon, Jul 14, 2014 at 4:07 PM, William >> Slacum >> > >> > >> >> wrote: >> >> For a bit of psuedocode, I'd probably >> make a class that did >> something akin to: >> http://pastebin.com/pKqAeeCR >> >> I wrote that up real quick in a text >> editor-- it won't >> compile or anything, but should point >> you in the right >> direction. >> >> >> On Mon, Jul 14, 2014 at 3:44 PM, >> William Slacum >> > >> >> > >> >> wrote: >> >> Hi Mike! >> >> The Combiner interface is only for >> aggregating keys >> within a single row. You can >> probably get away with >> implementing your combining logic >> in a WrappingIterator >> that reads across all the rows in a >> given tablet. >> >> To do some combine/fold/reduce >> operation, Accumulo needs >> the input type to be the same as >> the output type. The >> combiner doesn't have a notion of a >> "present" type (as >> you'd see in something like >> Algebird's Groups), but you >> can use another iterator to perform >> your transformation. >> >> If you wanted to extract the >> "count" field from your >> Avro object, you could write a new >> Iterator that took >> your Avro object, extracted the >> desired field, and >> returned it as its top value. You >> can then set this >> iterator as the source of the >> aggregator, either >> programmatically or via by wrapping >> the source object >> passed to the aggregator in its >> SortedKeyValueIterator#init call. >> >> This is a bit inefficient as you'd >> have to serialize to >> a Value and then immediately >> deserialize it in the >> iterator above it. You could >> mitigate this by exposing a >> method that would get the extracted >> value before >> serializing it. >> >> This kind of counting also requires >> client side logic to >> do a final combine operation, since >> the aggregations >> from all the tservers are partial >> results. >> >> I believe that CountingIterator is >> not meant for user >> consumption, but I do not know if >> it's related to your >> issue in trying to use it from the >> shell. Iterators set >> through the shell, in previous >> versions of Accumulo, >> have a requirement to implement >> OptionDescriber. Many >> default iterators do not implement >> this, and thus can't >> set in the shell. >> >> >> >> On Mon, Jul 14, 2014 at 2:44 PM, >> Michael Moss >> > >> > __>> >> >> >> wrote: >> >> Hi, All. >> >> I'm curious what the best >> practices are around >> persisting complex types/data >> in Accumulo (and >> aggregating on fields within >> them). >> >> Let's say I have (row, column >> family, column >> qualifier, value): >> "A" "foo" "" >> MyHugeAvroObject(count=2) >> "A" "foo" "" >> MyHugeAvroObject(count=3) >> >> Let's say MyHugeAvroObject has >> a field "Integer >> count" with the values above. >> >> What is the best way to >> aggregate on row, column >> family, column qualifier by >> count? In my above example: >> "A" "foo" "" 5 >> >> The >> TypedValueCombiner.typedReduce method can >> deserialize any "V", in my case >> MyHugeAvroObject, >> but it needs to return a value >> of type "V". What are >> the best practices for deeply >> nested/complex >> objects? It's not always >> straightforward to map a >> complex Avro type into Row -> >> Column Family -> >> Column Qualifier. >> >> Rather than using a >> TypedCombiner, I looked into >> using an Aggregator (which >> appears deprecated as of >> 1.4), which appears to let me >> return arbitrary >> values, but despite running >> setiter, my aggregator >> doesn't seem to do anything. >> >> I also tried looking at >> implementing a >> WrappingIterator, which also >> appears to allow me to >> return arbitary values (such as >> Accumulo's >> CountingIterator), but I get >> cryptic errors when >> trying to setiter, I'm on >> Accumulo 1.6: >> >> root@dev kyt> setiter -t kyt >> -scan -p 10 -n >> countingIter -class >> >> org.apache.accumulo.core.__iterators.system.__ >> CountingIterator >> >> 2014-07-14 11:12:55,623 >> [shell.Shell] ERROR: >> >> java.lang.__IllegalArgumentException: >> >> org.apache.accumulo.core.__iterators.system.__ >> CountingIterator >> >> >> This is odd because other >> included implementations >> of WrappingIterator seem to >> work (perhaps the >> implementation of >> CountingIterator is dated): >> root@dev kyt> setiter -t kyt >> -scan -p 10 -n >> deletingIterator -class >> >> org.apache.accumulo.core.__iterators.system.__ >> DeletingIterator >> >> The iterator class does not >> implement >> OptionDescriber. Consider this >> for better iterator >> configuration using this >> setiter command. >> Name for iterator (enter to >> skip): >> >> All in all, how can I aggregate >> simple values, like >> counters from rows with complex >> Avro objects as >> Values without having to add >> aggregations fields to >> these Value objects? >> >> Thanks! >> >> -Mike >> >> >> >> >> >> >> >> >> >> >> --001a11c22826cbb15404fe3f4ad6 Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: base64 PGRpdiBkaXI9Imx0ciI+Q29vbC4gSSYjMzk7bGwgd3JpdGUgc29tZXRoaW5nIHVwIGFuZCBzaGFy ZS48ZGl2Pjxicj48L2Rpdj48ZGl2PkkmIzM5O20gY3VyaW91cyBob3cgdG8gZ2V0IG15IENvdW50 ZXIgKFdyYXBwaW5nSXRlcmF0b3IpIGltcGxlbWVudGF0aW9uIHRvIGFnZ3JlZ2F0ZSBieSByb3cg KHdoaWNoLCBmb3Igc29tZSByZWFzb24sIEkgYXNzdW1lZCB3YXMgZGVmYXVsdD8pPC9kaXY+DQo8 ZGl2Pjxicj48L2Rpdj48ZGl2PkxldCYjMzk7cyBzYXkgSSBoYXZlIHJvd3MgKGFuZCBDRj0mcXVv dDsmcXVvdDssIENRPSZxdW90OyZxdW90OyBhbmQgdmVyc2lvbmluZ2l0ZXJhdG9yIG9mZik6PC9k aXY+PGRpdj4xIChWYWx1ZTEsIFZhbHVlIDIuLi5WYWx1ZSBOKTwvZGl2PjxkaXY+MjwvZGl2Pjxk aXY+MzwvZGl2PjxkaXY+PGJyPjwvZGl2PjxkaXY+SG93IGNhbiBteSBpdGVyYXRvciByZXR1cm4/ PC9kaXY+DQo8ZGl2PjEgKENvdW50IG9mIHZhbHVlcyAxLi5OKTwvZGl2PjxkaXY+MiAoQ291bnQg b2YgdmFsdWVzIDEuLk4pPC9kaXY+PGRpdj4zIC4uLjwvZGl2PjxkaXY+PGJyPjwvZGl2PjxkaXY+ SSB0cmllZCBzY2FuIC1iICZxdW90OzEmcXVvdDsgLWUgJnF1b3Q7MSZxdW90OyBhbmQgaXQgY291 bnRzIGFuIGluZGl2aWR1YWwgcm93LiBCdXQgaWYgSSBkb24mIzM5O3Qgc3BlY2lmeSBhbnl0aGlu ZywgaXQgcmV0dXJucyzCoDwvZGl2Pg0KPGRpdj4zIChDb3VudCBvZiBhbGwgdmFsdWVzIGFjcm9z cyBhbGwgcm93cyk8L2Rpdj48ZGl2Pjxicj48L2Rpdj48ZGl2PkNvZGU6PC9kaXY+PGRpdj48YSBo cmVmPSJodHRwOi8vcGFzdGViaW4uY29tLzh4Rk5MSEZTIj5odHRwOi8vcGFzdGViaW4uY29tLzh4 Rk5MSEZTPC9hPjxicj48L2Rpdj48ZGl2Pjxicj48L2Rpdj48ZGl2PkV4YW1wbGU6PC9kaXY+PGRp dj48ZGl2PnJvb3RAZGV2IHBlJmd0OyBsaXN0aXRlciAtc2NhbiAtdCBwb2pvPC9kaXY+DQo8ZGl2 Pi08L2Rpdj48ZGl2Pi0gwqAgwqBJdGVyYXRvciBjb3VudGVyLCBzY2FuIHNjb3BlIG9wdGlvbnM6 PC9kaXY+PGRpdj4tIMKgIMKgIMKgIMKgaXRlcmF0b3JQcmlvcml0eSA9IDEwPC9kaXY+PGRpdj4t IMKgIMKgIMKgIMKgaXRlcmF0b3JDbGFzc05hbWUgPSBpdGVyYXRvcnMuQ291bnRlcjwvZGl2Pjxk aXY+LTwvZGl2PjwvZGl2PjxkaXY+PGRpdj48ZGl2PnJvb3RAZGV2IHBlJmd0OyBzY2FuIC1iICZx dW90OzFfMV8yMDE0MDEwMSZxdW90OyAtZSAmcXVvdDsxXzFfMjAxNDAxMDEmcXVvdDs8L2Rpdj4N CjxkaXY+MV8xXzIwMTQwMTAxIDogW3B1YmxpY10gwqAgwqA2NTwvZGl2PjwvZGl2PjxkaXY+PGRp dj48YnI+PC9kaXY+PGRpdj48ZGl2PnJvb3RAZGV2IHBlJmd0OyBzY2FuIC1iICZxdW90OzFfMV8y MDE0MDEwMSZxdW90OyAtZSAmcXVvdDszXzlfMjAxNDA3MjcmcXVvdDs8L2Rpdj48ZGl2PjNfOV8y MDE0MDcyNyA6IFtwdWJsaWNdIMKgIMKgMTAwMDAwPC9kaXY+PC9kaXY+PC9kaXY+PGRpdj48YnI+ DQo8L2Rpdj48ZGl2PnJvb3RAZGV2IHBlJmd0OyBzY2FuPC9kaXY+PGRpdj4zXzlfMjAxNDA3Mjcg OiBbcHVibGljXSDCoCDCoDEwMDAwMDwvZGl2PjwvZGl2PjxkaXY+PGJyPjwvZGl2PjxkaXY+PGJy PjwvZGl2PjxkaXY+VGhhbmtzLjwvZGl2PjxkaXY+PGJyPjwvZGl2PjxkaXY+LU1pa2U8L2Rpdj48 ZGl2Pjxicj48L2Rpdj48L2Rpdj48ZGl2IGNsYXNzPSJnbWFpbF9leHRyYSI+PGJyPjxicj48ZGl2 IGNsYXNzPSJnbWFpbF9xdW90ZSI+DQpPbiBUdWUsIEp1bCAxNSwgMjAxNCBhdCAxMjoyOSBQTSwg Sm9zaCBFbHNlciA8c3BhbiBkaXI9Imx0ciI+Jmx0OzxhIGhyZWY9Im1haWx0bzpqb3NoLmVsc2Vy QGdtYWlsLmNvbSIgdGFyZ2V0PSJfYmxhbmsiPmpvc2guZWxzZXJAZ21haWwuY29tPC9hPiZndDs8 L3NwYW4+IHdyb3RlOjxicj48YmxvY2txdW90ZSBjbGFzcz0iZ21haWxfcXVvdGUiIHN0eWxlPSJt YXJnaW46MCAwIDAgLjhleDtib3JkZXItbGVmdDoxcHggI2NjYyBzb2xpZDtwYWRkaW5nLWxlZnQ6 MWV4Ij4NClRoZXJlJiMzOTtzIGJlZW4gc29tZSBtZW50aW9uIGFib3V0IGEgZGVzaXJlIHRvIHJl dGhpbmsgdGhlIEl0ZXJhdG9yIGludGVyZmFjZSBhcyBpdCBoYXMgc29tZSBkZWZpY2llbmNpZXMg KG5vdGFibHkgdGhlIGxhY2sgb2YgYSAmcXVvdDtjbGVhbnVwJnF1b3Q7IGJlZm9yZSB0aGUgaXRl cmF0b3JzIGFyZSB0b3JuIGRvd24pLCBidXQgbm8gb25lIGhhcyBzdGF0ZWQgdGhhdCB0aGV5JiMz OTtyZSBhY3RpdmVseSB3b3JraW5nIG9uIHRoaXMuPGJyPg0KDQo8YnI+DQpHZXR0aW5nIGJldHRl ciBkb2N1bWVudGF0aW9uIHdydCB0byBjb252ZXRpb25zOiBsZXQgdXMga25vdyB3aGVyZSB0aGUg QWNjdW11bG8gZG9jdW1lbnRhdGlvbiBmYWxscyBzaG9ydCAoYW5kIGdpdmUgdXMgcGF0Y2hlcyB0 byBmaXggdGhlIGRvY3VtZW50YXRpb24gOkQpLiBBZGRpdGlvbmFsbHksIHdyaXRlIHVwIHlvdXIg b3duIGZpbmRpbmdzIGZyb20gcHJvYmxlbXMgdGhhdCB5b3UmIzM5O3ZlIHJ1biBpbnRvLiBJdCYj Mzk7cyB0aGUgZW50aXJlIGNvbW11bml0eSAodXNlcnMgc3BlY2lmaWNhbGx5KSB0aGF0IHdlIG5l ZWQgdG8gaGVscCBlbmNvdXJhZ2UgdG8gZ3Jvdy48YnI+DQoNCjxicj4NCkV2ZW4gdGhpbmdzIGFz IHNpbXBsZSBhcyAmcXVvdDtob3cgZG8gSSBjb3VudCBlbnRyaWVzIGluIGFuIGl0ZXJhdG9yJnF1 b3Q7IGFyZSBiaWcgYXMgeW91IGFyZSBub3cgYW4gJnF1b3Q7ZXhwZXJ0JnF1b3Q7IG9uIHRoZSBz dWJqZWN0IDopPGRpdiBjbGFzcz0iIj48YnI+DQo8YnI+DQpPbiA3LzE1LzE0LCAxMjoxNyBQTSwg TWljaGFlbCBNb3NzIHdyb3RlOjxicj4NCjwvZGl2PjxibG9ja3F1b3RlIGNsYXNzPSJnbWFpbF9x dW90ZSIgc3R5bGU9Im1hcmdpbjowIDAgMCAuOGV4O2JvcmRlci1sZWZ0OjFweCAjY2NjIHNvbGlk O3BhZGRpbmctbGVmdDoxZXgiPjxkaXYgY2xhc3M9IiI+DQpUaGF0IHdvcmtlZCA7KSAtIFRoYW5r cyE8YnI+DQo8YnI+DQpXaGF0IGEgam91cm5leS4uLjxicj4NCjxicj4NCkkgbGlrZSBBY2N1bXVs byYjMzk7cyBhcmNoaXRlY3R1cmUgYW5kIHByb21pc2UsIGJ1dCB0aGUgZGlmZmljdWx0eSBpbjxi cj4NCnF1ZXJ5aW5nIGl0IChsYWNrIG9mIGRvY3VtZW50YXRpb24sIGNvbnZlbnRpb25zKSBpcyBh IG1ham9yIGNvbmNlcm4gYW5kPGJyPg0KSSYjMzk7ZCBpbWFnaW5lIGhhcyB0byBoYXZlIGFuIGlt cGFjdCBvbiBhZG9wdGlvbi4gSSYjMzk7bSBjdXJpb3VzIGlmIHRoZXJlIGhhdmU8YnI+DQpiZWVu IGFueSBjb252ZXJzYXRpb25zIGFyb3VuZCBjaGFuZ2luZyB0aGUgaW50ZXJmYWNlIGFyb3VuZCBp dGVyYXRvcnM8YnI+DQp3aGljaCBhcmUgc3RpbGwgY29uZnVzaW5nIHRvIG1lLiBMZXQgbWUga25v dyBob3cgSSBjYW4gaGVscCE8YnI+DQo8YnI+DQo8YnI+DQpPbiBUdWUsIEp1bCAxNSwgMjAxNCBh dCAxMjowMyBQTSwgV2lsbGlhbSBTbGFjdW08YnI+PC9kaXY+DQombHQ7PGEgaHJlZj0ibWFpbHRv OndpbGhlbG0udm9uLmNsb3VkQGFjY3VtdWxvLm5ldCIgdGFyZ2V0PSJfYmxhbmsiPndpbGhlbG0u dm9uLmNsb3VkQGFjY3VtdWxvLjx1PjwvdT5uZXQ8L2E+ICZsdDttYWlsdG86PGEgaHJlZj0ibWFp bHRvOndpbGhlbG0udm9uLmNsb3VkQGFjY3VtdWxvLm5ldCIgdGFyZ2V0PSJfYmxhbmsiPndpbGhl bG0udm9uLmNsb3VkQDx1PjwvdT5hY2N1bXVsby5uZXQ8L2E+Jmd0OyZndDs8ZGl2IGNsYXNzPSIi Pg0KPGJyPg0Kd3JvdGU6PGJyPg0KPGJyPg0KwqAgwqAgSGVycC4uLiBzZXJ2ZXMgbWUgcmlnaHQg Zm9yIG5vdCBzZXR0aW5nIHVwIGEgcHJvcGVyIHRlc3QgY2FzZS48YnI+DQo8YnI+DQrCoCDCoCBJ IHRoaW5rIHlvdSBuZWVkIHRvIG92ZXJyaWRlIHNlZWsgYXMgd2VsbDo8YnI+DQo8YnI+DQrCoCDC oCBAT3ZlcnJpZGU8YnI+DQrCoCDCoCBwdWJsaWMgdm9pZCBzZWVrKC4uLikgdGhyb3dzIElPRXhj ZXB0aW9uIHs8YnI+DQrCoCDCoCDCoCDCoHN1cGVyLnNlZWsoLi4uKTs8YnI+DQrCoCDCoCDCoCDC oG5leHQoKTs8YnI+DQrCoCDCoCB9PGJyPg0KPGJyPg0KwqAgwqAgSSB0aGluayBJIGp1c3QgcmVh bGl6ZWQgdGhlIHdyYXBwaW5nIGl0ZXJhdG9yIGNvdWxkIHVzZSBzb21lIGNsZWFuPGJyPg0KwqAg wqAgdXAsIGJlY2F1c2UgdGhpcyBpc24mIzM5O3Qgb2J2aW91cy4gQmFzaWNhbGx5IGFmdGVyIHRo ZSB3cmFwcGluZzxicj4NCsKgIMKgIGl0ZXJhdG9yJiMzOTtzIHNlZWsgaXMgY2FsbGVkLCBpdCBu ZXZlciBjYWxscyB0aGUgaW1wbGVtZW50b3ImIzM5O3MgbmV4dCgpPGJyPg0KwqAgwqAgdG8gYWN0 dWFsbHkgc2V0IHVwIHRoZSBmaXJzdCB0b3Aga2V5IGFuZCB2YWx1ZS48YnI+DQo8YnI+DQo8YnI+ DQo8YnI+DQrCoCDCoCBPbiBUdWUsIEp1bCAxNSwgMjAxNCBhdCA5OjUwIEFNLCBNaWNoYWVsIE1v c3M8YnI+PC9kaXY+PGRpdiBjbGFzcz0iIj4NCsKgIMKgICZsdDs8YSBocmVmPSJtYWlsdG86bWlj aGFlbC5tb3NzQGdtYWlsLmNvbSIgdGFyZ2V0PSJfYmxhbmsiPm1pY2hhZWwubW9zc0BnbWFpbC5j b208L2E+ICZsdDttYWlsdG86PGEgaHJlZj0ibWFpbHRvOm1pY2hhZWwubW9zc0BnbWFpbC5jb20i IHRhcmdldD0iX2JsYW5rIj5taWNoYWVsLm1vc3NAZ21haWwuY29tPC9hPjx1PjwvdT4mZ3Q7Jmd0 OyB3cm90ZTo8YnI+DQo8YnI+DQrCoCDCoCDCoCDCoCBJIHNldCB1cCBkZWJ1Z2dpbmcgYW5kIGFt IHJldGhyb3dpbmcgdGhlIGV4Y2VwdGlvbi4gV2hhdCYjMzk7czxicj4NCsKgIMKgIMKgIMKgIHN0 cmFuZ2UgaXMgaXQgYXBwZWFycyB0aGF0IGRlc3BpdGUgdGhlIGl0ZXJhdG9yIGluc3RhbmNlIGJl aW5nPGJyPg0KwqAgwqAgwqAgwqAgcHJvcGVybHkgc2V0IHRvIGl0ZXJhdG9yLkNvdW50ZXIgKG15 IGltcGxlbWVudGF0aW9uKSwgbXk8YnI+DQrCoCDCoCDCoCDCoCBicmVha3BvaW50cyBhcmVuJiMz OTt0IGJlaW5nIGhpdCwgb25seSBpbiB0aGUgcGFyZW50IGNsYXNzZXM8YnI+DQrCoCDCoCDCoCDC oCAoV3JhcHBpbmcgSXRlcmF0b3IpIGFuZCAoU29ydGVkS2V5VmFsdWVJdGVyYXRvcikuPGJyPg0K PGJyPg0KwqAgwqAgwqAgwqAgSSBoYXZlIHR3byByb3dzIGluIHRoZSB0YWJsZSwgd2hlbiBJIHNj YW4gd2l0aCBubyBpdGVyYXRvcjo8YnI+DQrCoCDCoCDCoCDCoCAyMDE0LTA3LTE1IDA2OjQ2OjI2 LDU3NyBbQXVkaXQgwqAgXSBJTkZPIDogb3BlcmF0aW9uOiBwZXJtaXR0ZWQ7PGJyPg0KwqAgwqAg wqAgwqAgdXNlcjogcm9vdDsgYWN0aW9uOiBzY2FuOyB0YXJnZXRUYWJsZTogcG9qbzsgYXV0aG9y aXphdGlvbnM6PGJyPg0KwqAgwqAgwqAgwqAgcHVibGljLDsgcmFuZ2U6ICgtaW5mLCtpbmYpOyBj b2x1bW5zOiBbXTsgaXRlcmF0b3JzOiBbXTs8YnI+DQrCoCDCoCDCoCDCoCBpdGVyYXRvck9wdGlv bnM6IHt9Ozxicj4NCsKgIMKgIMKgIMKgIDIwMTQtMDctMTUgMDY6NDY6MjYsNTg5IFt0c2VydmVy LlRhYmxldFNlcnZlcl0gREVCVUc6IFNjYW5TZXNzPGJyPjwvZGl2Pg0KwqAgwqAgwqAgwqAgdGlk IDxhIGhyZWY9Imh0dHA6Ly8xMC4wLjIuMTU6NDUwNzMiIHRhcmdldD0iX2JsYW5rIj4xMC4wLjIu MTU6NDUwNzM8L2E+ICZsdDs8YSBocmVmPSJodHRwOi8vMTAuMC4yLjE1OjQ1MDczIiB0YXJnZXQ9 Il9ibGFuayI+aHR0cDovLzEwLjAuMi4xNTo0NTA3MzwvYT4mZ3Q7IDgqMiBlbnRyaWVzKiBpbjxk aXYgY2xhc3M9IiI+PGJyPg0KwqAgwqAgwqAgwqAgMC4wMSBzZWNzLCBuYlRpbWVzID0gWzcgNyA3 LjAwIDFdPGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgV2hlbiBJIHNjYW4gd2l0aCB0aGUgaXRlcmF0 b3IgKDAgZW50cmllcz8pOjxicj4NCsKgIMKgIMKgIMKgIDIwMTQtMDctMTUgMDY6NDU6NTgsMDM2 IFtBdWRpdCDCoCBdIElORk8gOiBvcGVyYXRpb246IHBlcm1pdHRlZDs8YnI+DQrCoCDCoCDCoCDC oCB1c2VyOiByb290OyBhY3Rpb246IHNjYW47IHRhcmdldFRhYmxlOiBwb2pvOyBhdXRob3JpemF0 aW9uczo8YnI+DQrCoCDCoCDCoCDCoCBwdWJsaWMsOyByYW5nZTogKC1pbmYsK2luZik7IGNvbHVt bnM6IFtdOyBpdGVyYXRvcnM6IFtdOzxicj4NCsKgIMKgIMKgIMKgIGl0ZXJhdG9yT3B0aW9uczog e307PGJyPg0KwqAgwqAgwqAgwqAgMjAxNC0wNy0xNSAwNjo0NTo1OCwwNDcgW3RzZXJ2ZXIuVGFi bGV0U2VydmVyXSBERUJVRzogU2NhblNlc3M8YnI+PC9kaXY+DQrCoCDCoCDCoCDCoCB0aWQgPGEg aHJlZj0iaHR0cDovLzEwLjAuMi4xNTo0NDk5MiIgdGFyZ2V0PSJfYmxhbmsiPjEwLjAuMi4xNTo0 NDk5MjwvYT4gJmx0OzxhIGhyZWY9Imh0dHA6Ly8xMC4wLjIuMTU6NDQ5OTIiIHRhcmdldD0iX2Js YW5rIj5odHRwOi8vMTAuMC4yLjE1OjQ0OTkyPC9hPiZndDsgOCAqMCBlbnRyaWVzKiBpbjxkaXYg Y2xhc3M9IiI+PGJyPg0KwqAgwqAgwqAgwqAgMC4wMSBzZWNzLCBuYlRpbWVzID0gWzYgNiA2LjAw IDFdPGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgTm8gZXhjZXB0aW9ucyBvdGhlcndpc2UuIFJlYWxs eSBhcHByZWNpYXRlIGFsbCB0aGUgb25nb2luZyBoZWxwLjxicj4NCjxicj4NCsKgIMKgIMKgIMKg IEJlc3QsPGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgLU1pa2U8YnI+DQo8YnI+DQo8YnI+DQrCoCDC oCDCoCDCoCBPbiBNb24sIEp1bCAxNCwgMjAxNCBhdCA2OjQwIFBNLCBXaWxsaWFtIFNsYWN1bTxi cj4NCsKgIMKgIMKgIMKgICZsdDs8YSBocmVmPSJtYWlsdG86d2lsaGVsbS52b24uY2xvdWRAYWNj dW11bG8ubmV0IiB0YXJnZXQ9Il9ibGFuayI+d2lsaGVsbS52b24uY2xvdWRAYWNjdW11bG8uPHU+ PC91Pm5ldDwvYT48YnI+PC9kaXY+PGRpdiBjbGFzcz0iIj4NCsKgIMKgIMKgIMKgICZsdDttYWls dG86PGEgaHJlZj0ibWFpbHRvOndpbGhlbG0udm9uLmNsb3VkQGFjY3VtdWxvLm5ldCIgdGFyZ2V0 PSJfYmxhbmsiPndpbGhlbG0udm9uLmNsb3VkQDx1PjwvdT5hY2N1bXVsby5uZXQ8L2E+Jmd0OyZn dDsgd3JvdGU6PGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgQW55dGhpbmcgaW4geW91ciBU c2VydmVyIGxvZz8gSSB0aGluayB5b3Ugc2hvdWxkIGp1c3Q8YnI+DQrCoCDCoCDCoCDCoCDCoCDC oCByZXRocm93IHRoYXQgSU9FeGNlcHRvbiBvbiB5b3VyIHNvdXJjZSYjMzk7cyBuZXh0KCkgbWV0 aG9kLDxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIHNpbmNlIHRoZXkmIzM5O3JlIHVzdWFsbHkgbm90 IHJlY292ZXJhYmxlIChpZSwganVzdCBtYWtlPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgQ291bnRl ciNuZXh0IHRocm93IElPRXhjZXB0aW9uKTxicj4NCjxicj4NCjxicj4NCsKgIMKgIMKgIMKgIMKg IMKgIE9uIE1vbiwgSnVsIDE0LCAyMDE0IGF0IDU6NDggUE0sIEpvc2ggRWxzZXI8YnI+PC9kaXY+ PGRpdiBjbGFzcz0iIj4NCsKgIMKgIMKgIMKgIMKgIMKgICZsdDs8YSBocmVmPSJtYWlsdG86am9z aC5lbHNlckBnbWFpbC5jb20iIHRhcmdldD0iX2JsYW5rIj5qb3NoLmVsc2VyQGdtYWlsLmNvbTwv YT4gJmx0O21haWx0bzo8YSBocmVmPSJtYWlsdG86am9zaC5lbHNlckBnbWFpbC5jb20iIHRhcmdl dD0iX2JsYW5rIj5qb3NoLmVsc2VyQGdtYWlsLmNvbTwvYT4mZ3Q7Jmd0OyB3cm90ZTo8YnI+DQo8 YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBBIHF1aWNrIHNhbml0eSBjaGVjayBpcyB0byBt YWtlIHN1cmUgeW91IGhhdmUgZGF0YSBpbjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIHRo ZSB0YWJsZSBhbmQgdGhhdCB5b3UgY2FuIHJlYWQgdGhlIGRhdGEgd2l0aG91dCB5b3VyPGJyPg0K wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgaXRlcmF0b3IgKEkmIzM5O3ZlIHRob3VnaHQgSSBoYWQg YSBidWcgYmVjYXVzZSBJIGRpZG4mIzM5O3QgaGF2ZTxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIHByb3BlciB2aXNpYmlsaXRpZXMgbW9yZSB0aW1lcyB0aGFuIEkmIzM5O2QgbGlrZSB0byBh ZG1pdCkuPGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgQWx0ZXJuYXRpdmVseSwg eW91IGNhbiBhbHNvIGVuYWJsZSByZW1vdGUtZGVidWdnaW5nIHZpYTxicj4NCsKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIEVjbGlwc2UgaW50byB0aGUgVGFibGV0U2VydmVyIHdoaWNoIG1pZ2h0IGhl bHAgeW91PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgdW5kZXJzdGFuZCBtb3JlIG9mIHdo YXQmIzM5O3MgZ29pbmcgb24uPGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgTG90 cyBvZiBhcnRpY2xlcyBvbiBob3cgdG8gc2V0IHRoaXMgdXAgWzFdLiBJbiBzaG9ydCw8YnI+DQrC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBhZGQgLVhkZWJ1Zzxicj48L2Rpdj4NCsKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIC1YcnVuamR3cDp0cmFuc3BvcnQ9ZHRfc29ja2V0LDx1PjwvdT5fX3NlcnZl cj15LGFkZHJlc3M9ODAwMCB0bzxkaXYgY2xhc3M9IiI+PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgQUNDVU1VTE9fVFNFUlZFUl9PUFRTIGluIGFjY3VtdWxvLWVudi5zaCwgcmVzdGFydCB0 aGU8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCB0c2VydmVyLCBjb25uZWN0IGVjbGlwc2Ug dG8gODAwMCB2aWEgdGhlIERlYnVnPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgY29uZmln dXJhdGlvbiBtZW51LCBzZXQgYSBicmVha3BvaW50IGluIHlvdXIgaW5pdCwgc2Vlazxicj4NCsKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIGFuZCBuZXh0IG1ldGhvZHMsIGFuZCBgc2NhbmAgaW4gdGhl IHNoZWxsLjxicj4NCjxicj4NCjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIFsxXTxicj48 L2Rpdj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIDxhIGhyZWY9Imh0dHA6Ly9qYXZhcmV2aXNp dGVkLmJsb2dzcG90LiIgdGFyZ2V0PSJfYmxhbmsiPmh0dHA6Ly9qYXZhcmV2aXNpdGVkLmJsb2dz cG90LjwvYT48dT48L3U+X19jb20vMjAxMS8wMi9ob3ctdG8tc2V0dXAtX188dT48L3U+cmVtb3Rl LWRlYnVnZ2luZy1pbi5odG1sPGRpdiBjbGFzcz0iIj48YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCAmbHQ7PGEgaHJlZj0iaHR0cDovL2phdmFyZXZpc2l0ZWQuYmxvZ3Nwb3QuY29tLzIwMTEv MDIvaG93LXRvLXNldHVwLXJlbW90ZS1kZWJ1Z2dpbmctaW4uaHRtbCIgdGFyZ2V0PSJfYmxhbmsi Pmh0dHA6Ly9qYXZhcmV2aXNpdGVkLjx1PjwvdT5ibG9nc3BvdC5jb20vMjAxMS8wMi9ob3ctdG8t PHU+PC91PnNldHVwLXJlbW90ZS1kZWJ1Z2dpbmctaW4uaHRtbDwvYT48dT48L3U+Jmd0Ozxicj4N Cg0KPGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgT24gNy8xNC8xNCwgNTozMyBQ TSwgTWljaGFlbCBNb3NzIHdyb3RlOjxicj4NCjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIEhtbS4uLlN0aWxsIGRvZXNuJiMzOTt0IHJldHVybiBhbnl0aGluZyBmcm9tIHRoZSBz aGVsbC48YnI+DQo8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCA8YSBocmVmPSJo dHRwOi8vcGFzdGViaW4uY29tL25kUmhzcGY4IiB0YXJnZXQ9Il9ibGFuayI+aHR0cDovL3Bhc3Rl YmluLmNvbS9uZFJoc3BmODwvYT48YnI+DQo8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCBBbnkgdGhvdWdodHM/IFdoYXQmIzM5O3MgdGhlIGJlc3Qgd2F5IHRvIGRlYnVnIHRoZXNl Pzxicj4NCjxicj4NCjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIE9uIE1vbiwg SnVsIDE0LCAyMDE0IGF0IDU6MTQgUE0sIFdpbGxpYW0gU2xhY3VtPGJyPjwvZGl2Pg0KwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgJmx0O3dpbGhlbG0udm9uLmNsb3VkQGFjY3VtdWxvLl9f PHU+PC91Pm5ldDxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgICZsdDttYWlsdG86 PGEgaHJlZj0ibWFpbHRvOndpbGhlbG0udm9uLmNsb3VkQGFjY3VtdWxvLm5ldCIgdGFyZ2V0PSJf YmxhbmsiPndpbGhlbG0udm9uLmNsb3VkQDx1PjwvdT5hY2N1bXVsby5uZXQ8L2E+Jmd0Ozxicj4N CsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgICZsdDttYWlsdG86PGEgaHJlZj0ibWFpbHRv OndpbGhlbG0udm9uLmNsb3VkQCIgdGFyZ2V0PSJfYmxhbmsiPndpbGhlbG0udm9uLmNsb3VkQDwv YT5fXzxhIGhyZWY9Imh0dHA6Ly9hY2N1bXVsby5uZXQiIHRhcmdldD0iX2JsYW5rIj5hYzx1Pjwv dT5jdW11bG8ubmV0PC9hPjxkaXYgY2xhc3M9IiI+PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgJmx0O21haWx0bzo8YSBocmVmPSJtYWlsdG86d2lsaGVsbS52b24uY2xvdWRAYWNj dW11bG8ubmV0IiB0YXJnZXQ9Il9ibGFuayI+d2lsaGVsbS52b24uY2xvdWRAPHU+PC91PmFjY3Vt dWxvLm5ldDwvYT4mZ3Q7Jmd0OyZndDs8YnI+DQo8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCB3cm90ZTo8YnI+DQo8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoEFoLCBhbiBhcnRpZmFjdCBvZiBtZSBqdXN0IHdpbGx5IG5pbGx5IHdyaXRpbmc8YnI+ DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBhbiBpdGVyYXRvciA6KSBBbnk8YnI+DQrC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHJlZmVyZW5jZSB0byBgdGhpcy5z b3VyY2VgIHNob3VsZCBiZSByZXBsYWNlZCB3aXRoPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqBgdGhpcy5nZXRTb3VyY2UoKWAuIEluIGBuZXh0KClgLCB5b3VyPGJy Pg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgd29ya2Fyb3VuZCBlbmRzIHVwIGNhbGxp bmc8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGB0aGlzLmhhc1Rv cCgpYCBhcyB0aGUgd2hpbGUgbG9vcCBjb25kaXRpb24uIEl0PGJyPg0KwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgd2lsbCBhbHdheXMgcmV0dXJuPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqBmYWxzZSBiZWNhdXNlIHR3byBsaW5lcyB1cCB3ZSBzZXQgYHRv cF9rZXlgIHRvPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgbnVsbC4gV2UgbmVl ZCB0byBtYWtlPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBzdXJl IHRoYXQgdGhlIHNvdXJjZSBpdGVyYXRvciBoYXMgYSB0b3AsPGJyPg0KwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgYmVjYXVzZSB3ZSB3YW50IHRvIHJlYWQ8YnI+DQrCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGRhdGEgZnJvbSBpdC4gV2UmIzM5O2xsIGhhdmUgdG8g Y2hhbmdlIHRoZSBsb29wPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgY29uZGl0 aW9uIHRvPGJyPjwvZGl2Pg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBg d2hpbGUodGhpcy5nZXRTb3VyY2UoKS5fXzx1PjwvdT5oYXNUb3AoKSlgLiBPbiBsaW5lPGRpdj48 ZGl2IGNsYXNzPSJoNSI+PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgMzggb2Yg eW91ciBjb2RlIHdlJiMzOTtsbDxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgbmVlZCB0byBjYWxsIGB0aGlzLmdldFNvdXJjZSgpLm5leHQoKWAgaW5zdGVhZDxicj4N CsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIG9mIGB0aGlzLm5leHQoKWAuPGJyPg0KPGJy Pg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBUaGUgaXRlcmF0b3IgaW50 ZXJmYWNlIGlzIGRvY3VtZW50ZWQsIGJ1dCB0aGVyZTxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIGhhc24mIzM5O3QgYmVlbiBhPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqBkZWZpbml0aXZlIGdvLXRvIGZvciBtYWtpbmcgb25lLiBJJiMzOTt2ZSBi ZWVuPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgZHJhZnRpbmcgYSBibG9nIHBv c3QsIGJ1dDxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgc2luY2Ug aXQgZG9lc24mIzM5O3QgZXhpc3QgeWV0LCBob3BlZnVsbHkgdGhlPGJyPg0KwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgZm9sbG93aW5nIHdpbGwgc3VmZmljZS48YnI+DQo8YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoFRoZSBsaWZldGltZSBvZiBhbiBpdGVy YXRvciBpcyAodXN1YWxseSkgYXM8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBm b2xsb3dzOjxicj4NCjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg KDEpIEEgbmV3IGluc3RhbmNlIGlzIGNhbGxlZCB2aWE8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCBDbGFzcy5uZXdJbnN0YW5jZSAoc28gYSBuby1hcmdzPGJyPg0KwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBjb25zdHJ1Y3RvciBpcyBuZWVkZWQpPGJyPg0K wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAoMikgSW5pdCBpcyBjYWxsZWQu IFRoaXMgYWxsb3dzIHVzZXJzIHRvPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg Y29uZmlndXJlIHRoZSBpdGVyYXRvciwgc2V0PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqBpdHMgc291cmNlLCBhbmQgcG9zc2libGUgY2hlY2sgdGhlIGVudmlyb25t ZW50Ljxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIFdlIGNhbiBhbHNvIGNhbGw8 YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGBkZWVwQ29weWAgb24g dGhlIHNvdXJjZSBpZiB3ZSB3YW50IHRvIGhhdmU8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCBtdWx0aXBsZSBzb3VyY2VzICh3ZSYjMzk7ZDxicj4NCsKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgZG8gdGhpcyBpZiB3ZSB3YW50ZWQgdG8gZG8gYSBtZXJnZSBy ZWFkIG91dCBvZjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIG11bHRpcGxlIGNv bHVtbjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgZmFtaWxpZXMg d2l0aGluIGEgcm93KS48YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCgzKSBzZWVrKCkgaXMgY2FsbGVkLiBUaGlzIGdldHMgb3VyIHJlYWRlcnMgdG88YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCB0aGUgY29ycmVjdCBwb3NpdGlvbnM8YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGluIHRoZSBkYXRhIHRoYXQgYXJlIHdp dGhpbiB0aGUgc2NhbiByYW5nZSB0aGU8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCB1c2VyIHJlcXVlc3RlZCwgYXM8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoHdlbGwgYXMgdHVybmluZyBjb2x1bW4gZmFtaWxpZXMgb24gb3Igb2ZmLiBUaGU8YnI+ DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBuYW1lIHNob3VsZDxicj4NCsKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgcmVtaW5pc2NlbnQgb2Ygc2Vla2luZyB0byBz b21lIGtleSBvbiBkaXNrLjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgKDQpIGhhc1RvcCgpIGlzIGNhbGxlZC4gSWYgdHJ1ZSwgdGhhdCBtZWFucyB3ZTxicj4NCsKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIGhhdmUgZGF0YSwgYW5kIHRoZTxicj4NCsKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgaXRlcmF0b3IgaGFzIGEga2V5L3ZhbHVl IHBhaXIgdGhhdCBjYW4gYmU8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCByZXRy aWV2ZWQgYnkgY2FsbGluZzxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgZ2V0VG9wS2V5KCkgYW5kIGdldFRvcFZhbHVlKCkuIElmIGZhc2xlLCB3ZSYjMzk7cmU8YnI+ DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBkb25lIGJlY2F1c2UgdGhlcmUmIzM5O3M8 YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoG5vIGRhdGEgdG8gcmV0 dXJuLjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgKDUpIG5leHQo KSBpcyBjYWxsZWQuIFRoaXMgd2lsbCBhdHRlbXB0IGZpbmQgYTxicj4NCsKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIG5ldyB0b3Aga2V5IGFuZDxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgdmFsdWUuIFdlIGdvIGJhY2sgdG8gKDQpIHRvIHNlZSBpZiBuZXh0 IHdhczxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIHN1Y2Nlc3NmdWwgaW4gZmlu ZGluZyBhPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBuZXcgdG9w IGtleS92YWx1ZSBhbmQgd2lsbCByZXBlYXQgdW50aWwgdGhlPGJyPg0KwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgY2xpZW50IGlzIHNhdGlzZmllZCBvcjxicj4NCsKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgaGFzVG9wKCkgcmV0dXJucyBmYWxzZS48YnI+DQo8YnI+ DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoFlvdSBjYW4ga2luZCBvZiBt YWtlIGEgc3RhdGUgbWFjaGluZSBvdXQgb2Y8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCB0aG9zZSBzdGVwcyB3aGVyZSB3ZTxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgbG9vcCBiZXR3ZWVuICg0KSBhbmQgKDUpIHVudGlsIHRoZXJlJiMzOTtzIG5v IGRhdGEuPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgVGhlcmUgYXJlIG1vcmU8 YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGFkdmFuY2VkIHdvcmtm bG93cyB3aGVyZSBuZXh0KCkgY2FuIGJlIHJlYWRpbmc8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCBmcm9tIG11bHRpcGxlPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqBzb3VyY2VzLCBhcyB3ZWxsIGFzIHNlZWtpbmcgdGhlbSB0byBkaWZmZXJlbnQ8 YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBwb3NpdGlvbnMgaW4gdGhlIHRhYmxl dC48YnI+DQo8YnI+DQo8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oE9uIE1vbiwgSnVsIDE0LCAyMDE0IGF0IDQ6NTEgUE0sIE1pY2hhZWwgTW9zczxicj4NCsKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgJmx0OzxhIGhyZWY9Im1haWx0bzptaWNo YWVsLm1vc3NAZ21haWwuY29tIiB0YXJnZXQ9Il9ibGFuayI+bWljaGFlbC5tb3NzQGdtYWlsLmNv bTwvYT48YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCAmbHQ7bWFpbHRvOjxhIGhy ZWY9Im1haWx0bzptaWNoYWVsLm1vc3NAZ21haWwuY29tIiB0YXJnZXQ9Il9ibGFuayI+bWljaGFl bC5tb3NzQGdtYWlsLmNvbTwvYT48dT48L3U+Jmd0Ozxicj48L2Rpdj48L2Rpdj4NCsKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgICZsdDttYWlsdG86PGEgaHJlZj0ibWFpbHRvOm1pY2hhZWwu bW9zc0BnbWFpbC5jb20iIHRhcmdldD0iX2JsYW5rIj5taWNoYWVsLm1vc3NAZ21haWwuY29tPC9h PjxkaXYgY2xhc3M9IiI+PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgJmx0O21h aWx0bzo8YSBocmVmPSJtYWlsdG86bWljaGFlbC5tb3NzQGdtYWlsLmNvbSIgdGFyZ2V0PSJfYmxh bmsiPm1pY2hhZWwubW9zc0BnbWFpbC5jb208L2E+PHU+PC91PiZndDtfXyZndDsmZ3Q7IHdyb3Rl Ojxicj4NCjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg VGhhbmtzLCBXaWxsaWFtLiBJIHdhcyBqdXN0IGhpdHRpbmcgeW91IHVwPGJyPg0KwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgZm9yIGFuIGV4YW1wbGUgOik8YnI+DQo8YnI+DQrCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoEkgYWRhcHRlZCB5b3VyIHBzZXVk b2NvZGU8YnI+PC9kaXY+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCAoPGEgaHJlZj0i aHR0cDovL3Bhc3RlYmluLmNvbS91ZlBKcTBnMylfXyIgdGFyZ2V0PSJfYmxhbmsiPmh0dHA6Ly9w YXN0ZWJpbi5jb20vdWZQSnEwZzMpPHU+PC91Pl9fPC9hPiwgYnV0PGRpdj48ZGl2IGNsYXNzPSJo NSI+PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBub3Rp Y2VkIHRoYXQgJnF1b3Q7dGhpcy5zb3VyY2UmcXVvdDsgaW4geW91ciBleGFtcGxlPGJyPg0KwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgZGlkbiYjMzk7dCBoYXZlPGJyPg0KwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqB2aXNpYmlsaXR5LiBEaWQgSSB3b3Jr ZWQgYXJvdW5kIGl0IGNvcnJlY3RseT88YnI+DQo8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoFdoZW4gSSBhZGQgbXkgaXRlcmF0b3IgdG8gbXkgdGFibGUg YW5kIHJ1bjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIHNjYW4gZnJvbSB0aGUg c2hlbGwsPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBp dCByZXR1cm5zIG5vdGhpbmcgLSB3aGF0IHNob3VsZCBJIGV4cGVjdDxicj4NCsKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIGhlcmU/IEluIGdlbmVyYWwgSSYjMzk7dmU8YnI+DQrCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGZvdW5kIHRoZSBpdGVyYXRvciBp bnRlcmZhY2UgcHJldHR5PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgY29uZnVz aW5nIGFuZCBoYXZlbiYjMzk7dCBzcGVudDxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgdGhlIHRpbWUgd3JhcHBpbmcgbXkgaGVhZCBhcm91bmQgaXQgeWV0 Ljxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIEFueSBkb2N1bWVudGF0aW9uIG9y PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBleGFtcGxl cyAoYmV5b25kIHdoYXQgSSBjb3VsZCBmaW5kIG9uIHRoZTxicj4NCsKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIHNpdGUgb3IgaW4gdGhlIGNvZGUpPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBhcHByZWNpYXRlZCE8YnI+DQo8YnI+DQrCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoC9yb290QGRldiZndDsgdGFibGUg cG9qby88YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoC9y b290QGRldiBwb2pvJmd0OyBsaXN0aXRlciAtc2NhbiAtdCBwb2pvLzxicj4NCsKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgLy0vPGJyPg0KwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAvLSDCoCDCoEl0ZXJhdG9yIGNvdW50ZXIsIHNj YW4gc2NvcGUgb3B0aW9uczovPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAvLSDCoCDCoCDCoCDCoGl0ZXJhdG9yUHJpb3JpdHkgPSAxMC88YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoC8tIMKgIMKgIMKgIMKgaXRl cmF0b3JDbGFzc05hbWUgPTxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIGl0ZXJh dG9ycy5Db3VudGVyLzxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgLy0vPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAvcm9vdEBkZXYgcG9qbyZndDsgc2Nhbi88YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoC9yb290QGRldiBwb2pvJmd0Oy88YnI+DQo8YnI+DQo8YnI+DQrC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoEJlc3QsPGJyPg0KPGJy Pg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAtTWlrZTxicj4N Cjxicj4NCjxicj4NCjxicj4NCjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgT24gTW9uLCBKdWwgMTQsIDIwMTQgYXQgNDowNyBQTSwgV2lsbGlhbSBTbGFj dW08YnI+PC9kaXY+PC9kaXY+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCZsdDt3aWxoZWxtLnZvbi5jbG91ZEBhY2N1bXVsby5fXzx1PjwvdT5uZXQ8YnI+DQrC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCAmbHQ7bWFpbHRvOjxhIGhyZWY9Im1haWx0bzp3 aWxoZWxtLnZvbi5jbG91ZEBhY2N1bXVsby5uZXQiIHRhcmdldD0iX2JsYW5rIj53aWxoZWxtLnZv bi5jbG91ZEA8dT48L3U+YWNjdW11bG8ubmV0PC9hPiZndDs8YnI+DQrCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCZsdDttYWlsdG86PGEgaHJlZj0ibWFpbHRvOndp bGhlbG0udm9uLmNsb3VkQCIgdGFyZ2V0PSJfYmxhbmsiPndpbGhlbG0udm9uLmNsb3VkQDwvYT5f XzxhIGhyZWY9Imh0dHA6Ly9hY2N1bXVsby5uZXQiIHRhcmdldD0iX2JsYW5rIj5hYzx1PjwvdT5j dW11bG8ubmV0PC9hPjxkaXYgY2xhc3M9IiI+PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgJmx0O21haWx0bzo8YSBocmVmPSJtYWlsdG86d2lsaGVsbS52b24uY2xvdWRAYWNjdW11 bG8ubmV0IiB0YXJnZXQ9Il9ibGFuayI+d2lsaGVsbS52b24uY2xvdWRAPHU+PC91PmFjY3VtdWxv Lm5ldDwvYT4mZ3Q7Jmd0OyZndDsgd3JvdGU6PGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBGb3IgYSBiaXQgb2YgcHN1ZWRvY29kZSwg SSYjMzk7ZCBwcm9iYWJseTxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIG1ha2Ug YSBjbGFzcyB0aGF0IGRpZDxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgc29tZXRoaW5nIGFraW4gdG86PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgPGEgaHJlZj0iaHR0cDovL3Bhc3RlYmluLmNvbS9wS3FBZWVDUiIgdGFyZ2V0 PSJfYmxhbmsiPmh0dHA6Ly9wYXN0ZWJpbi5jb20vcEtxQWVlQ1I8L2E+PGJyPg0KPGJyPg0KwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBJIHdyb3RlIHRo YXQgdXAgcmVhbCBxdWljayBpbiBhIHRleHQ8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCBlZGl0b3ItLSBpdCB3b24mIzM5O3Q8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGNvbXBpbGUgb3IgYW55dGhpbmcsIGJ1dCBzaG91bGQg cG9pbnQ8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCB5b3UgaW4gdGhlIHJpZ2h0 PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBk aXJlY3Rpb24uPGJyPg0KPGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqBPbiBNb24sIEp1bCAxNCwgMjAxNCBhdCAzOjQ0IFBNLDxicj4N CsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIFdpbGxpYW0gU2xhY3VtPGJyPjwvZGl2Pg0K wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAmbHQ7d2ls aGVsbS52b24uY2xvdWRAYWNjdW11bG8uX188dT48L3U+bmV0PGJyPg0KwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgJmx0O21haWx0bzo8YSBocmVmPSJtYWlsdG86d2lsaGVsbS52b24uY2xv dWRAYWNjdW11bG8ubmV0IiB0YXJnZXQ9Il9ibGFuayI+d2lsaGVsbS52b24uY2xvdWRAPHU+PC91 PmFjY3VtdWxvLm5ldDwvYT4mZ3Q7PGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgJmx0O21haWx0bzo8YSBocmVmPSJtYWlsdG86d2lsaGVsbS52b24uY2xvdWRAIiB0YXJn ZXQ9Il9ibGFuayI+d2lsaGVsbS52b24uY2xvdWRAPC9hPl9fPGEgaHJlZj0iaHR0cDovL2FjY3Vt dWxvLm5ldCIgdGFyZ2V0PSJfYmxhbmsiPmFjPHU+PC91PmN1bXVsby5uZXQ8L2E+PGRpdj48ZGl2 IGNsYXNzPSJoNSI+PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgJmx0O21haWx0 bzo8YSBocmVmPSJtYWlsdG86d2lsaGVsbS52b24uY2xvdWRAYWNjdW11bG8ubmV0IiB0YXJnZXQ9 Il9ibGFuayI+d2lsaGVsbS52b24uY2xvdWRAPHU+PC91PmFjY3VtdWxvLm5ldDwvYT4mZ3Q7Jmd0 OyZndDsgd3JvdGU6PGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBIaSBNaWtlITxicj4NCjxicj4NCsKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgVGhlIENvbWJpbmVyIGlu dGVyZmFjZSBpcyBvbmx5IGZvcjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIGFn Z3JlZ2F0aW5nIGtleXM8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoHdpdGhpbiBhIHNpbmdsZSByb3cuIFlvdSBjYW48YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBwcm9iYWJseSBnZXQgYXdheSB3aXRoPGJyPg0KwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBpbXBs ZW1lbnRpbmcgeW91ciBjb21iaW5pbmcgbG9naWM8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCBpbiBhIFdyYXBwaW5nSXRlcmF0b3I8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHRoYXQgcmVhZHMgYWNyb3NzIGFsbCB0 aGUgcm93cyBpbiBhPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgZ2l2ZW4gdGFi bGV0Ljxicj4NCjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgVG8gZG8gc29tZSBjb21iaW5lL2ZvbGQvcmVkdWNlPGJyPg0KwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgb3BlcmF0aW9uLCBBY2N1bXVsbyBuZWVkczxicj4NCsKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgdGhl IGlucHV0IHR5cGUgdG8gYmUgdGhlIHNhbWUgYXM8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCB0aGUgb3V0cHV0IHR5cGUuIFRoZTxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgY29tYmluZXIgZG9lc24mIzM5O3QgaGF2 ZSBhIG5vdGlvbiBvZiBhPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgJnF1b3Q7 cHJlc2VudCZxdW90OyB0eXBlIChhczxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgeW91JiMzOTtkIHNlZSBpbiBzb21ldGhpbmcgbGlr ZTxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIEFsZ2ViaXJkJiMzOTtzIEdyb3Vw cyksIGJ1dCB5b3U8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoGNhbiB1c2UgYW5vdGhlciBpdGVyYXRvciB0byBwZXJmb3JtPGJyPg0K wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgeW91ciB0cmFuc2Zvcm1hdGlvbi48YnI+DQo8 YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoElmIHlvdSB3YW50ZWQgdG8gZXh0cmFjdCB0aGU8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCAmcXVvdDtjb3VudCZxdW90OyBmaWVsZCBmcm9tIHlvdXI8YnI+DQrCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoEF2cm8gb2Jq ZWN0LCB5b3UgY291bGQgd3JpdGUgYSBuZXc8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCBJdGVyYXRvciB0aGF0IHRvb2s8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHlvdXIgQXZybyBvYmplY3QsIGV4dHJhY3RlZCB0 aGU8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBkZXNpcmVkIGZpZWxkLCBhbmQ8 YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoHJldHVybmVkIGl0IGFzIGl0cyB0b3AgdmFsdWUuIFlvdTxicj4NCsKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIGNhbiB0aGVuIHNldCB0aGlzPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBpdGVyYXRvciBhcyB0aGUgc291 cmNlIG9mIHRoZTxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIGFnZ3JlZ2F0b3Is IGVpdGhlcjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgcHJvZ3JhbW1hdGljYWxseSBvciB2aWEgYnkgd3JhcHBpbmc8YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCB0aGUgc291cmNlIG9iamVjdDxicj4NCsKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgcGFzc2VkIHRv IHRoZSBhZ2dyZWdhdG9yIGluIGl0czxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgU29ydGVkS2V5VmFsdWVJdGVyYXRvciNpbml0IGNh bGwuPGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqBUaGlzIGlzIGEgYml0IGluZWZmaWNpZW50IGFzIHlvdSYjMzk7ZDxicj4N CsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIGhhdmUgdG8gc2VyaWFsaXplIHRvPGJyPg0K wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBh IFZhbHVlIGFuZCB0aGVuIGltbWVkaWF0ZWx5PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgZGVzZXJpYWxpemUgaXQgaW4gdGhlPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBpdGVyYXRvciBhYm92ZSBpdC4gWW91IGNv dWxkPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgbWl0aWdhdGUgdGhpcyBieSBl eHBvc2luZyBhPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqBtZXRob2QgdGhhdCB3b3VsZCBnZXQgdGhlIGV4dHJhY3RlZDxicj4NCsKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIHZhbHVlIGJlZm9yZTxicj4NCsKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgc2VyaWFsaXppbmcg aXQuPGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqBUaGlzIGtpbmQgb2YgY291bnRpbmcgYWxzbyByZXF1aXJlczxicj4NCsKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIGNsaWVudCBzaWRlIGxvZ2ljIHRvPGJyPg0KwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBkbyBh IGZpbmFsIGNvbWJpbmUgb3BlcmF0aW9uLCBzaW5jZTxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIHRoZSBhZ2dyZWdhdGlvbnM8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGZyb20gYWxsIHRoZSB0c2VydmVycyBhcmUg cGFydGlhbDxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIHJlc3VsdHMuPGJyPg0K PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqBJIGJlbGlldmUgdGhhdCBDb3VudGluZ0l0ZXJhdG9yIGlzPGJyPg0KwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgbm90IG1lYW50IGZvciB1c2VyPGJyPg0KwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBjb25zdW1wdGlvbiwgYnV0 IEkgZG8gbm90IGtub3cgaWY8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBpdCYj Mzk7cyByZWxhdGVkIHRvIHlvdXI8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGlzc3VlIGluIHRyeWluZyB0byB1c2UgaXQgZnJvbSB0 aGU8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBzaGVsbC4gSXRlcmF0b3JzIHNl dDxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgdGhyb3VnaCB0aGUgc2hlbGwsIGluIHByZXZpb3VzPGJyPg0KwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgdmVyc2lvbnMgb2YgQWNjdW11bG8sPGJyPg0KwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBoYXZlIGEgcmVxdWlyZW1l bnQgdG8gaW1wbGVtZW50PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgT3B0aW9u RGVzY3JpYmVyLiBNYW55PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqBkZWZhdWx0IGl0ZXJhdG9ycyBkbyBub3QgaW1wbGVtZW50PGJy Pg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgdGhpcywgYW5kIHRodXMgY2FuJiMzOTt0 PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqBzZXQgaW4gdGhlIHNoZWxsLjxicj4NCjxicj4NCjxicj4NCjxicj4NCsKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgT24gTW9uLCBKdWwg MTQsIDIwMTQgYXQgMjo0NCBQTSw8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBN aWNoYWVsIE1vc3M8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCZsdDs8YSBocmVmPSJtYWlsdG86bWljaGFlbC5tb3NzQGdtYWlsLmNv bSIgdGFyZ2V0PSJfYmxhbmsiPm1pY2hhZWwubW9zc0BnbWFpbC5jb208L2E+PGJyPg0KwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgJmx0O21haWx0bzo8YSBocmVmPSJtYWlsdG86bWljaGFl bC5tb3NzQGdtYWlsLmNvbSIgdGFyZ2V0PSJfYmxhbmsiPm1pY2hhZWwubW9zc0BnbWFpbC5jb208 L2E+PHU+PC91PiZndDs8YnI+PC9kaXY+PC9kaXY+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCAmbHQ7bWFpbHRvOjxhIGhyZWY9Im1haWx0bzptaWNoYWVsLm1vc3NAZ21haWwuY29tIiB0 YXJnZXQ9Il9ibGFuayI+bWljaGFlbC5tb3NzQGdtYWlsLmNvbTwvYT48YnI+DQrCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCAmbHQ7bWFpbHRvOjxhIGhyZWY9Im1haWx0bzptaWNoYWVsLm1v c3NAZ21haWwuY29tIiB0YXJnZXQ9Il9ibGFuayI+bWljaGFlbC5tb3NzQGdtYWlsLmNvbTwvYT48 dT48L3U+Jmd0O19fJmd0OyZndDs8ZGl2PjxkaXYgY2xhc3M9Img1Ij48YnI+DQo8YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHdyb3Rl Ojxicj4NCjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgSGksIEFsbC48YnI+DQo8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoEkmIzM5O20gY3VyaW91 cyB3aGF0IHRoZSBiZXN0PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgcHJhY3Rp Y2VzIGFyZSBhcm91bmQ8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHBlcnNpc3RpbmcgY29tcGxleCB0eXBlcy9kYXRhPGJy Pg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgaW4gQWNjdW11bG8gKGFuZDxicj4NCsKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgYWdncmVnYXRpbmcgb24gZmllbGRzIHdpdGhpbiB0aGVtKS48YnI+DQo8YnI+DQrCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoExl dCYjMzk7cyBzYXkgSSBoYXZlIChyb3csIGNvbHVtbjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIGZhbWlseSwgY29sdW1uPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBxdWFsaWZpZXIsIHZhbHVlKTo8YnI+ DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCZxdW90O0EmcXVvdDsgJnF1b3Q7Zm9vJnF1b3Q7ICZxdW90OyZxdW90Ozxicj4NCsKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIE15SHVnZUF2cm9PYmplY3QoY291bnQ9Mik8YnI+ DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCZxdW90O0EmcXVvdDsgJnF1b3Q7Zm9vJnF1b3Q7ICZxdW90OyZxdW90Ozxicj4NCsKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIE15SHVnZUF2cm9PYmplY3QoY291bnQ9Myk8YnI+ DQo8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoExldCYjMzk7cyBzYXkgTXlIdWdlQXZyb09iamVjdCBoYXM8YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBhIGZpZWxkICZxdW90O0ludGVnZXI8YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oGNvdW50JnF1b3Q7IHdpdGggdGhlIHZhbHVlcyBhYm92ZS48YnI+DQo8YnI+DQrCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoFdoYXQg aXMgdGhlIGJlc3Qgd2F5IHRvPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgYWdn cmVnYXRlIG9uIHJvdywgY29sdW1uPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBmYW1pbHksIGNvbHVtbiBxdWFsaWZpZXIg Ynk8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBjb3VudD8gSW4gbXkgYWJvdmUg ZXhhbXBsZTo8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCZxdW90O0EmcXVvdDsgJnF1b3Q7Zm9vJnF1b3Q7ICZxdW90OyZx dW90OyA1PGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBUaGU8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCBUeXBlZFZhbHVlQ29tYmluZXIudHlwZWRSZWR1Y2UgbWV0aG9kIGNhbjxicj4NCsKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg ZGVzZXJpYWxpemUgYW55ICZxdW90O1YmcXVvdDssIGluIG15IGNhc2U8YnI+DQrCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCBNeUh1Z2VBdnJvT2JqZWN0LDxicj4NCsKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgYnV0IGl0IG5l ZWRzIHRvIHJldHVybiBhIHZhbHVlPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg b2YgdHlwZSAmcXVvdDtWJnF1b3Q7LiBXaGF0IGFyZTxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgdGhlIGJlc3QgcHJhY3Rp Y2VzIGZvciBkZWVwbHk8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBuZXN0ZWQv Y29tcGxleDxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgb2JqZWN0cz8gSXQmIzM5O3Mgbm90IGFsd2F5czxicj4NCsKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIHN0cmFpZ2h0Zm9yd2FyZCB0byBtYXAgYTxicj4NCsKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgY29tcGxleCBBdnJvIHR5cGUgaW50byBSb3cgLSZndDs8YnI+DQrCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCBDb2x1bW4gRmFtaWx5IC0mZ3Q7PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBDb2x1bW4gUXVhbGlm aWVyLjxicj4NCjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgUmF0aGVyIHRoYW4gdXNpbmcgYTxicj4NCsKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIFR5cGVkQ29tYmluZXIsIEkgbG9va2VkIGludG88YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oHVzaW5nIGFuIEFnZ3JlZ2F0b3IgKHdoaWNoPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgYXBwZWFycyBkZXByZWNhdGVkIGFzIG9mPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAxLjQpLCB3aGljaCBhcHBl YXJzIHRvIGxldCBtZTxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIHJldHVybiBh cmJpdHJhcnk8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoHZhbHVlcywgYnV0IGRlc3BpdGUgcnVubmluZzxicj4NCsKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIHNldGl0ZXIsIG15IGFnZ3JlZ2F0b3I8YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oGRvZXNuJiMzOTt0IHNlZW0gdG8gZG8gYW55dGhpbmcuPGJyPg0KPGJyPg0KwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBJIGFsc28g dHJpZWQgbG9va2luZyBhdDxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIGltcGxl bWVudGluZyBhPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqBXcmFwcGluZ0l0ZXJhdG9yLCB3aGljaCBhbHNvPGJyPg0KwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgYXBwZWFycyB0byBhbGxvdyBtZSB0bzxicj4NCsKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgcmV0dXJuIGFyYml0YXJ5IHZhbHVlcyAoc3VjaCBhczxicj4NCsKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIEFjY3VtdWxvJiMzOTtzPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBDb3VudGluZ0l0ZXJhdG9yKSwg YnV0IEkgZ2V0PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgY3J5cHRpYyBlcnJv cnMgd2hlbjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgdHJ5aW5nIHRvIHNldGl0ZXIsIEkmIzM5O20gb248YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBBY2N1bXVsbyAxLjY6PGJyPg0KPGJyPg0KwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBy b290QGRldiBreXQmZ3Q7IHNldGl0ZXIgLXQga3l0PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgLXNjYW4gLXAgMTAgLW48YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGNvdW50aW5nSXRlciAtY2xhc3M8YnI+ DQo8YnI+PC9kaXY+PC9kaXY+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBvcmcuYXBh Y2hlLmFjY3VtdWxvLmNvcmUuX188dT48L3U+aXRlcmF0b3JzLnN5c3RlbS5fXzx1PjwvdT5Db3Vu dGluZ0l0ZXJhdG9yPGRpdiBjbGFzcz0iIj48YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoDIwMTQtMDctMTQgMTE6MTI6NTUs NjIzPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgW3NoZWxsLlNoZWxsXSBFUlJP Ujo8YnI+DQo8YnI+PC9kaXY+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBqYXZhLmxh bmcuX188dT48L3U+SWxsZWdhbEFyZ3VtZW50RXhjZXB0aW9uOjxicj4NCjxicj4NCsKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIG9yZy5hcGFjaGUuYWNjdW11bG8uY29yZS5fXzx1PjwvdT5p dGVyYXRvcnMuc3lzdGVtLl9fPHU+PC91PkNvdW50aW5nSXRlcmF0b3I8ZGl2IGNsYXNzPSIiPjxi cj4NCjxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgVGhpcyBpcyBvZGQgYmVjYXVzZSBvdGhlcjxicj4NCsKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIGluY2x1ZGVkIGltcGxlbWVudGF0aW9uczxicj4NCsKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgb2Yg V3JhcHBpbmdJdGVyYXRvciBzZWVtIHRvPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgd29yayAocGVyaGFwcyB0aGU8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGltcGxlbWVudGF0aW9uIG9mPGJyPg0KwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgQ291bnRpbmdJdGVyYXRvciBpcyBkYXRlZCk6PGJy Pg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqByb290QGRldiBreXQmZ3Q7IHNldGl0ZXIgLXQga3l0PGJyPg0KwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgLXNjYW4gLXAgMTAgLW48YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGRlbGV0aW5nSXRlcmF0 b3IgLWNsYXNzPGJyPg0KPGJyPjwvZGl2Pg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg b3JnLmFwYWNoZS5hY2N1bXVsby5jb3JlLl9fPHU+PC91Pml0ZXJhdG9ycy5zeXN0ZW0uX188dT48 L3U+RGVsZXRpbmdJdGVyYXRvcjxkaXYgY2xhc3M9IiI+PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBUaGUgaXRlcmF0b3Ig Y2xhc3MgZG9lcyBub3Q8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBpbXBsZW1l bnQ8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoE9wdGlvbkRlc2NyaWJlci4gQ29uc2lkZXIgdGhpczxicj4NCsKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIGZvciBiZXR0ZXIgaXRlcmF0b3I8YnI+DQrCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGNvbmZp Z3VyYXRpb24gdXNpbmcgdGhpczxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIHNl dGl0ZXIgY29tbWFuZC48YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoE5hbWUgZm9yIGl0ZXJhdG9yIChlbnRlciB0byBza2lw KTo8YnI+DQo8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoEFsbCBpbiBhbGwsIGhvdyBjYW4gSSBhZ2dyZWdhdGU8YnI+DQrC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBzaW1wbGUgdmFsdWVzLCBsaWtlPGJyPg0KwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqBjb3VudGVycyBmcm9tIHJvd3Mgd2l0aCBjb21wbGV4PGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgQXZybyBvYmplY3RzIGFzPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBWYWx1ZXMgd2l0aG91dCBoYXZp bmcgdG8gYWRkPGJyPg0KwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgYWdncmVnYXRpb25z IGZpZWxkcyB0bzxicj4NCsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgdGhlc2UgVmFsdWUgb2JqZWN0cz88YnI+DQo8YnI+DQrCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oFRoYW5rcyE8YnI+DQo8YnI+DQrCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoC1NaWtlPGJyPg0KPGJyPg0KPGJyPg0KPGJyPg0KPGJy Pg0KPGJyPg0KPGJyPg0KPGJyPg0KPGJyPg0KPGJyPg0KPGJyPg0KPC9kaXY+PC9ibG9ja3F1b3Rl Pg0KPC9ibG9ja3F1b3RlPjwvZGl2Pjxicj48L2Rpdj4NCg== --001a11c22826cbb15404fe3f4ad6--