From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wr1-f46.google.com (mail-wr1-f46.google.com [209.85.221.46]) by sourceware.org (Postfix) with ESMTPS id CD0B13858D1E for ; Fri, 30 Sep 2022 18:28:20 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org CD0B13858D1E Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=palves.net Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-wr1-f46.google.com with SMTP id bq9so8086666wrb.4 for ; Fri, 30 Sep 2022 11:28:20 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-language:in-reply-to:mime-version:user-agent:date :message-id:from:references:cc:to:subject:x-gm-message-state:from:to :cc:subject:date; bh=oLC5pLLtugR0S85bx46nufQ0vA/rZTk/uPS0ea3+QgE=; b=yxw+YlH6d/h+bHpnOmPQG3q+MH5kkdcJ9W/5160UdAy0dZVUoUsmEajb9CcLGrOzkm TuEZ4TM1ws3LgMvhx1LwemEkYcvLH3ZUfGTb3K3r1dhuATsMueE6nEpJ49/pjrdanx+R Teb4w3dxmx4/lUeGIkyrTV8IzHI7J9giUDzVtnoGhnXZ5+BEiFMiBqVVkaxIkWARQ7rb EFMM9/tEQnimyvxiImDvkPOKuS1eCGL3tzAsh/0zoTDMWcVsmxSGVf8pitiVjVeQCOrP KTrwS63wWiSsQkIZYSLUxfy8rfqbNxPXHn1TrSd18/ShgwtZgJCcCHjdOm9i10gRMbjM ky6Q== X-Gm-Message-State: ACrzQf2scwfM+HQAZ8ygdTMKXq7kr24+pScIgvTBHhRCGe9b5bhsBMCd N1hlWXaeRJmXt310SMDNyfuZKCKl9gIdeg== X-Google-Smtp-Source: AMsMyM6vrs3YpeSeNP3QX6+ZdLCuzviBKtimrl8a1PG4ZqIQDpQZTXqnq/7PB/ULmpg8RreDxen/JA== X-Received: by 2002:adf:e309:0:b0:22c:c332:9af7 with SMTP id b9-20020adfe309000000b0022cc3329af7mr6775380wrj.217.1664562499271; Fri, 30 Sep 2022 11:28:19 -0700 (PDT) Received: from ?IPv6:2001:8a0:f93a:3b00:e038:5cdc:b8bf:4653? ([2001:8a0:f93a:3b00:e038:5cdc:b8bf:4653]) by smtp.gmail.com with ESMTPSA id m28-20020adfa3dc000000b0022860e8ae7csm2709056wrb.77.2022.09.30.11.28.17 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Fri, 30 Sep 2022 11:28:17 -0700 (PDT) Subject: Re: [PATCH v3 2/2] gdb/reverse: Fix stepping over recursive functions To: Bruno Larsen , gdb-patches@sourceware.org References: <20220831120727.2742360-1-blarsen@redhat.com> <20220831120727.2742360-3-blarsen@redhat.com> From: Pedro Alves Message-ID: <2b2701f2-3624-75ca-6af5-02abb6126804@palves.net> Date: Fri, 30 Sep 2022 19:28:17 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.10.1 MIME-Version: 1.0 In-Reply-To: <20220831120727.2742360-3-blarsen@redhat.com> Content-Type: multipart/mixed; boundary="------------7A2452831060DF7C690EFA5C" Content-Language: en-US X-Spam-Status: No, score=-10.5 required=5.0 tests=BAYES_00, FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM, GIT_PATCH_0, HEADER_FROM_DIFFERENT_DOMAINS, KAM_DMARC_STATUS, KAM_SHORT, NICE_REPLY_A, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 30 Sep 2022 18:28:25 -0000 This is a multi-part message in MIME format. --------------7A2452831060DF7C690EFA5C Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 7bit On 2022-08-31 1:07 p.m., Bruno Larsen wrote: > Currently, when using GDB to do reverse debugging, if we try to use the > command "reverse next" to skip a recursive function, instead of skipping > all of the recursive calls and stopping in the previous line, we stop at > the second to last recursive call, and need to manually step backwards > until we leave the first call. This is well documented in PR gdb/16678. > > This bug happens because when GDB notices that a reverse step has > entered into a function, GDB will add a step_resume_breakpoint at the > start of the function, then single step out of the prologue once that > breakpoint is hit. The problem was happening because GDB wouldn't give > that step_resume_breakpoint a frame-id, so the first time the breakpoint > was hit, the inferior would be stopped. This is fixed by giving the > current frame-id to the breakpoint. > > This commit also changes gdb.reverse/step-reverse.c to contain a > recursive function and attempt to both, skip it altogether, and to skip > the second call from inside the first call, as this setup broke a > previous version of the patch. > --- > gdb/infrun.c | 2 +- > gdb/testsuite/gdb.reverse/step-precsave.exp | 6 ++- > gdb/testsuite/gdb.reverse/step-reverse.c | 18 ++++++- > gdb/testsuite/gdb.reverse/step-reverse.exp | 58 +++++++++++++++++++-- > 4 files changed, 76 insertions(+), 8 deletions(-) > > diff --git a/gdb/infrun.c b/gdb/infrun.c > index 033699bc3f7..679a0c83ece 100644 > --- a/gdb/infrun.c > +++ b/gdb/infrun.c > @@ -7133,7 +7133,7 @@ process_event_stop_test (struct execution_control_state *ecs) > sr_sal.pc = ecs->stop_func_start; > sr_sal.pspace = get_frame_program_space (frame); > insert_step_resume_breakpoint_at_sal (gdbarch, > - sr_sal, null_frame_id); > + sr_sal, get_stack_frame_id (frame)); > } > } > else > diff --git a/gdb/testsuite/gdb.reverse/step-precsave.exp b/gdb/testsuite/gdb.reverse/step-precsave.exp > index 0836ed2629f..3279b6ce879 100644 > --- a/gdb/testsuite/gdb.reverse/step-precsave.exp > +++ b/gdb/testsuite/gdb.reverse/step-precsave.exp > @@ -86,7 +86,8 @@ gdb_test "step 3" ".*STEP TEST 2.*" "step test 2" > > # step over call > > -gdb_test "step" ".*NEXT OVER THIS CALL.*" "step up to call" > +gdb_test "step" ".*NEXT OVER THIS RECURSION.*" "step up to call" > +gdb_test "next" ".*NEXT OVER THIS CALL.*" "skip recursive call" > gdb_test "next" ".*STEP INTO THIS CALL.*" "next over call" > > # step into call > @@ -280,9 +281,10 @@ gdb_test_multiple "step" "$test_message" { > } > } > > -# next backward over call > +# Next backward over calls. > > gdb_test "next" ".*NEXT OVER THIS CALL.*" "reverse next over call" > +gdb_test "next" ".*NEXT OVER THIS RECURSION.*" "reverse next over recursive call" > > # step/next backward with count > > diff --git a/gdb/testsuite/gdb.reverse/step-reverse.c b/gdb/testsuite/gdb.reverse/step-reverse.c > index aea2a98541d..3d647b9b29d 100644 > --- a/gdb/testsuite/gdb.reverse/step-reverse.c > +++ b/gdb/testsuite/gdb.reverse/step-reverse.c > @@ -26,6 +26,19 @@ int callee() { /* ENTER CALLEE */ > return myglob++; /* ARRIVED IN CALLEE */ > } /* RETURN FROM CALLEE */ > > +/* We need to make this function take more than a single instruction > + to run, otherwise it could hide PR gdb/16678, as reverse execution can > + step over a single-instruction function. */ > +int > +recursive_callee (int val) > +{ > + if (val == 0) return 0; > + val /= 2; > + if (val > 1) > + val++; > + return recursive_callee (val); /* RECURSIVE CALL */ > +} /* EXIT RECURSIVE FUNCTION */ Could you make the function follow GNU formatting? I know that the file has other bits that don't follow the style, but we can just not add more cases. > + > /* A structure which, we hope, will need to be passed using memcpy. */ > struct rhomboidal { > int rather_large[100]; > @@ -51,6 +64,9 @@ int main () { > y = y + 4; > z = z + 5; /* STEP TEST 2 */ > > + /* Test that next goes over recursive calls too */ > + recursive_callee (32); /* NEXT OVER THIS RECURSION */ > + > /* Test that "next" goes over a call */ > callee(); /* NEXT OVER THIS CALL */ > > @@ -60,7 +76,7 @@ int main () { > /* Test "stepi" */ > a[5] = a[3] - a[4]; /* FINISH TEST */ > callee(); /* STEPI TEST */ > - > + > /* Test "nexti" */ > callee(); /* NEXTI TEST */ > > diff --git a/gdb/testsuite/gdb.reverse/step-reverse.exp b/gdb/testsuite/gdb.reverse/step-reverse.exp > index 997b62604d5..a540b1f88ce 100644 > --- a/gdb/testsuite/gdb.reverse/step-reverse.exp > +++ b/gdb/testsuite/gdb.reverse/step-reverse.exp > @@ -47,9 +47,11 @@ gdb_test "step" ".*STEP TEST 1.*" "step test 1" > gdb_test "next 2" ".*NEXT TEST 2.*" "next test 2" > gdb_test "step 3" ".*STEP TEST 2.*" "step test 2" > > +# Next through a recursive function call. > +gdb_test "next 2" "NEXT OVER THIS CALL.*" "next over recursion" > + > # step over call > > -gdb_test "step" ".*NEXT OVER THIS CALL.*" "step up to call" > gdb_test "next" ".*STEP INTO THIS CALL.*" "next over call" > > # step into call > @@ -118,7 +120,7 @@ gdb_test_multiple "stepi" "$test_message" { > > set test_message "stepi back from function call" > gdb_test_multiple "stepi" "$test_message" { > - -re "NEXTI TEST.*$gdb_prompt $" { > + -re -wrap "NEXTI TEST.*" { > pass "$test_message" > } > -re "ARRIVED IN CALLEE.*$gdb_prompt $" { > @@ -143,7 +145,6 @@ gdb_test_multiple "stepi" "$test_message" { > ### > > # Set reverse execution direction > - > gdb_test_no_output "set exec-dir reverse" "set reverse execution" > > # stepi backward thru return and into a function > @@ -243,10 +244,59 @@ gdb_test_multiple "step" "$test_message" { > } > } > > -# next backward over call > +# Next backward over call. > > gdb_test "next" ".*NEXT OVER THIS CALL.*" "reverse next over call" > > +set step_out 0 > +gdb_test_multiple "next" "reverse next over recursion" { > + -re -wrap ".*NEXT OVER THIS RECURSION.*" { > + pass "$gdb_test_name" > + } > + -re -wrap ".*RECURSIVE CALL.*" { > + fail "$gdb_test_name" > + set step_out 1 > + } > +} > +if { "$step_out" == 1 } { > + gdb_test_multiple "next" "stepping out of recursion" { > + -re -wrap "NEXT OVER THIS RECURSION.*" { > + set step_out 0 > + } > + -re -wrap ".*" { > + send_gdb "reverse-next\n" > + exp_continue The command passed to gdb_test_multiple was "next", but here you do "reverse-next". Seems best to be consistent. After, this can potentially infinite loop of the reverse-next never takes you to the expected line, which seems a bit dangerous. > + } > + } > +} > + > +# Step forward over recursion again so we can test stepping over calls > +# inside the recursion itself. > +gdb_test_no_output "set exec-dir forward" "forward again to test recursion" > +gdb_test "next" "NEXT OVER THIS CALL.*" "reverse next over recursion again" > +gdb_test_no_output "set exec-dir reverse" "reverse again to test recursion" > + > +gdb_test "step" ".*EXIT RECURSIVE FUNCTION.*" "enter recursive function" > +set step_pass 1 > +gdb_test_multiple "next" "step over recursion inside the recursion" { > + -re -wrap ".*EXIT RECURSIVE FUNCTION.*" { > + set step_pass 0 > + send_gdb "next\n" > + exp_continue > + } > + -re -wrap ".*NEXT OVER THIS RECURSION.*" { > + if {$step_pass} { > + pass "step over recursion inside the recursion" > + } else { > + fail "step over recursion inside the recursion" > + } gdb_assert > + } > + -re -wrap ".*" { > + send_gdb "next\n" Ditto, re. infinite loop. > + exp_continue > + } > +} > + Other than that, it looks fine to me. I still see this failing on Ubuntu 20.04, though. I haven't investigated why. I've attached the gdb.log, in case something jumps out as obvious to you. The before/after gdb.sum diff shows that some other tests FAIL on this machine, so maybe it's just more of the same. @@ -13,7 +13,7 @@ PASS: gdb.reverse/step-reverse.exp: next PASS: gdb.reverse/step-reverse.exp: step test 1 PASS: gdb.reverse/step-reverse.exp: next test 2 PASS: gdb.reverse/step-reverse.exp: step test 2 -PASS: gdb.reverse/step-reverse.exp: step up to call +PASS: gdb.reverse/step-reverse.exp: next over recursion PASS: gdb.reverse/step-reverse.exp: next over call PASS: gdb.reverse/step-reverse.exp: step into call PASS: gdb.reverse/step-reverse.exp: finish out of fn call @@ -27,14 +27,20 @@ PASS: gdb.reverse/step-reverse.exp: simp FAIL: gdb.reverse/step-reverse.exp: reverse step into fn call FAIL: gdb.reverse/step-reverse.exp: reverse step out of called fn FAIL: gdb.reverse/step-reverse.exp: reverse next over call -FAIL: gdb.reverse/step-reverse.exp: reverse step test 1 -FAIL: gdb.reverse/step-reverse.exp: reverse next test 1 -FAIL: gdb.reverse/step-reverse.exp: reverse step test 2 -FAIL: gdb.reverse/step-reverse.exp: reverse next test 2 +FAIL: gdb.reverse/step-reverse.exp: reverse next over recursion +PASS: gdb.reverse/step-reverse.exp: forward again to test recursion +FAIL: gdb.reverse/step-reverse.exp: reverse next over recursion again +PASS: gdb.reverse/step-reverse.exp: reverse again to test recursion +FAIL: gdb.reverse/step-reverse.exp: enter recursive function +PASS: gdb.reverse/step-reverse.exp: step over recursion inside the recursion +PASS: gdb.reverse/step-reverse.exp: reverse step test 1 +PASS: gdb.reverse/step-reverse.exp: reverse next test 1 +PASS: gdb.reverse/step-reverse.exp: reverse step test 2 --------------7A2452831060DF7C690EFA5C Content-Type: text/x-log; name="gdb.log" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="gdb.log" VGVzdCBydW4gYnkgcGVkcm8gb24gRnJpIFNlcCAzMCAxNzo1MjozMCAyMDIyCk5hdGl2ZSBj b25maWd1cmF0aW9uIGlzIHg4Nl82NC1wYy1saW51eC1nbnUKCgkJPT09IGdkYiB0ZXN0cyA9 PT0KClNjaGVkdWxlIG9mIHZhcmlhdGlvbnM6CiAgICB1bml4CgpSdW5uaW5nIHRhcmdldCB1 bml4ClVzaW5nIC91c3Ivc2hhcmUvZGVqYWdudS9iYXNlYm9hcmRzL3VuaXguZXhwIGFzIGJv YXJkIGRlc2NyaXB0aW9uIGZpbGUgZm9yIHRhcmdldC4KVXNpbmcgL3Vzci9zaGFyZS9kZWph Z251L2NvbmZpZy91bml4LmV4cCBhcyBnZW5lcmljIGludGVyZmFjZSBmaWxlIGZvciB0YXJn ZXQuClVzaW5nIC9ob21lL3BlZHJvL2dkYi9iaW51dGlscy1nZGIvc3JjL2dkYi90ZXN0c3Vp dGUvY29uZmlnL3VuaXguZXhwIGFzIHRvb2wtYW5kLXRhcmdldC1zcGVjaWZpYyBpbnRlcmZh Y2UgZmlsZS4KUnVubmluZyAvaG9tZS9wZWRyby9nZGIvYmludXRpbHMtZ2RiL3NyYy9nZGIv dGVzdHN1aXRlL2dkYi5yZXZlcnNlL3N0ZXAtcmV2ZXJzZS5leHAgLi4uCkV4ZWN1dGluZyBv biBob3N0OiBnY2MgICAtZmRpYWdub3N0aWNzLWNvbG9yPW5ldmVyIC1jIC1vIC9ob21lL3Bl ZHJvL2dkYi9iaW51dGlscy1nZGIvYnVpbGQvZ2RiL3Rlc3RzdWl0ZS90ZW1wLzE0NjU0Njgv Y2NvcHRzMTQ2NTQ2OC5vIC9ob21lL3BlZHJvL2dkYi9iaW51dGlscy1nZGIvYnVpbGQvZ2Ri L3Rlc3RzdWl0ZS90ZW1wLzE0NjU0NjgvY2NvcHRzMTQ2NTQ2OC5jICAgICh0aW1lb3V0ID0g MzAwKQpidWlsdGluX3NwYXduIC1pZ25vcmUgU0lHSFVQIGdjYyAtZmRpYWdub3N0aWNzLWNv bG9yPW5ldmVyIC1jIC1vIC9ob21lL3BlZHJvL2dkYi9iaW51dGlscy1nZGIvYnVpbGQvZ2Ri L3Rlc3RzdWl0ZS90ZW1wLzE0NjU0NjgvY2NvcHRzMTQ2NTQ2OC5vIC9ob21lL3BlZHJvL2dk Yi9iaW51dGlscy1nZGIvYnVpbGQvZ2RiL3Rlc3RzdWl0ZS90ZW1wLzE0NjU0NjgvY2NvcHRz MTQ2NTQ2OC5jDQpnZXRfY29tcGlsZXJfaW5mbzogZ2NjLTktNC0wCkV4ZWN1dGluZyBvbiBo b3N0OiBnY2MgIC1mbm8tc3RhY2stcHJvdGVjdG9yICAtZmRpYWdub3N0aWNzLWNvbG9yPW5l dmVyIC1jIC1nICAtbyAvaG9tZS9wZWRyby9nZGIvYmludXRpbHMtZ2RiL2J1aWxkL2dkYi90 ZXN0c3VpdGUvb3V0cHV0cy9nZGIucmV2ZXJzZS9zdGVwLXJldmVyc2Uvc3RlcC1yZXZlcnNl MC5vIC9ob21lL3BlZHJvL2dkYi9iaW51dGlscy1nZGIvc3JjL2dkYi90ZXN0c3VpdGUvZ2Ri LnJldmVyc2Uvc3RlcC1yZXZlcnNlLmMgICAgKHRpbWVvdXQgPSAzMDApCmJ1aWx0aW5fc3Bh d24gLWlnbm9yZSBTSUdIVVAgZ2NjIC1mbm8tc3RhY2stcHJvdGVjdG9yIC1mZGlhZ25vc3Rp Y3MtY29sb3I9bmV2ZXIgLWMgLWcgLW8gL2hvbWUvcGVkcm8vZ2RiL2JpbnV0aWxzLWdkYi9i dWlsZC9nZGIvdGVzdHN1aXRlL291dHB1dHMvZ2RiLnJldmVyc2Uvc3RlcC1yZXZlcnNlL3N0 ZXAtcmV2ZXJzZTAubyAvaG9tZS9wZWRyby9nZGIvYmludXRpbHMtZ2RiL3NyYy9nZGIvdGVz dHN1aXRlL2dkYi5yZXZlcnNlL3N0ZXAtcmV2ZXJzZS5jDQpFeGVjdXRpbmcgb24gaG9zdDog Z2NjICAtZm5vLXN0YWNrLXByb3RlY3RvciAvaG9tZS9wZWRyby9nZGIvYmludXRpbHMtZ2Ri L2J1aWxkL2dkYi90ZXN0c3VpdGUvb3V0cHV0cy9nZGIucmV2ZXJzZS9zdGVwLXJldmVyc2Uv c3RlcC1yZXZlcnNlMC5vICAtZmRpYWdub3N0aWNzLWNvbG9yPW5ldmVyIC1nICAtbG0gICAt byAvaG9tZS9wZWRyby9nZGIvYmludXRpbHMtZ2RiL2J1aWxkL2dkYi90ZXN0c3VpdGUvb3V0 cHV0cy9nZGIucmV2ZXJzZS9zdGVwLXJldmVyc2Uvc3RlcC1yZXZlcnNlICAgICh0aW1lb3V0 ID0gMzAwKQpidWlsdGluX3NwYXduIC1pZ25vcmUgU0lHSFVQIGdjYyAtZm5vLXN0YWNrLXBy b3RlY3RvciAvaG9tZS9wZWRyby9nZGIvYmludXRpbHMtZ2RiL2J1aWxkL2dkYi90ZXN0c3Vp dGUvb3V0cHV0cy9nZGIucmV2ZXJzZS9zdGVwLXJldmVyc2Uvc3RlcC1yZXZlcnNlMC5vIC1m ZGlhZ25vc3RpY3MtY29sb3I9bmV2ZXIgLWcgLWxtIC1vIC9ob21lL3BlZHJvL2dkYi9iaW51 dGlscy1nZGIvYnVpbGQvZ2RiL3Rlc3RzdWl0ZS9vdXRwdXRzL2dkYi5yZXZlcnNlL3N0ZXAt cmV2ZXJzZS9zdGVwLXJldmVyc2UNCmJ1aWx0aW5fc3Bhd24gL2hvbWUvcGVkcm8vZ2RiL2Jp bnV0aWxzLWdkYi9idWlsZC9nZGIvdGVzdHN1aXRlLy4uLy4uL2dkYi9nZGIgLW53IC1ueCAt aWV4IHNldCBoZWlnaHQgMCAtaWV4IHNldCB3aWR0aCAwIC1kYXRhLWRpcmVjdG9yeSAvaG9t ZS9wZWRyby9nZGIvYmludXRpbHMtZ2RiL2J1aWxkL2dkYi90ZXN0c3VpdGUvLi4vZGF0YS1k aXJlY3RvcnkNCkdOVSBnZGIgKEdEQikgMTMuMC41MC4yMDIyMDkzMC1naXQNCkNvcHlyaWdo dCAoQykgMjAyMiBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4NCkxpY2Vuc2UgR1BM djMrOiBHTlUgR1BMIHZlcnNpb24gMyBvciBsYXRlciA8aHR0cDovL2dudS5vcmcvbGljZW5z ZXMvZ3BsLmh0bWw+DQpUaGlzIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBhcmUgZnJlZSB0byBj aGFuZ2UgYW5kIHJlZGlzdHJpYnV0ZSBpdC4NClRoZXJlIGlzIE5PIFdBUlJBTlRZLCB0byB0 aGUgZXh0ZW50IHBlcm1pdHRlZCBieSBsYXcuDQpUeXBlICJzaG93IGNvcHlpbmciIGFuZCAi c2hvdyB3YXJyYW50eSIgZm9yIGRldGFpbHMuDQpUaGlzIEdEQiB3YXMgY29uZmlndXJlZCBh cyAieDg2XzY0LXBjLWxpbnV4LWdudSIuDQpUeXBlICJzaG93IGNvbmZpZ3VyYXRpb24iIGZv ciBjb25maWd1cmF0aW9uIGRldGFpbHMuDQpGb3IgYnVnIHJlcG9ydGluZyBpbnN0cnVjdGlv bnMsIHBsZWFzZSBzZWU6DQo8aHR0cHM6Ly93d3cuZ251Lm9yZy9zb2Z0d2FyZS9nZGIvYnVn cy8+Lg0KRmluZCB0aGUgR0RCIG1hbnVhbCBhbmQgb3RoZXIgZG9jdW1lbnRhdGlvbiByZXNv dXJjZXMgb25saW5lIGF0Og0KICAgIDxodHRwOi8vd3d3LmdudS5vcmcvc29mdHdhcmUvZ2Ri L2RvY3VtZW50YXRpb24vPi4NCg0KRm9yIGhlbHAsIHR5cGUgImhlbHAiLg0KVHlwZSAiYXBy b3BvcyB3b3JkIiB0byBzZWFyY2ggZm9yIGNvbW1hbmRzIHJlbGF0ZWQgdG8gIndvcmQiLg0K KGdkYikgc2V0IGhlaWdodCAwDQooZ2RiKSBzZXQgd2lkdGggMA0KKGdkYikgZGlyDQpSZWlu aXRpYWxpemUgc291cmNlIHBhdGggdG8gZW1wdHk/ICh5IG9yIG4pIHkNClNvdXJjZSBkaXJl Y3RvcmllcyBzZWFyY2hlZDogJGNkaXI6JGN3ZA0KKGdkYikgZGlyIC9ob21lL3BlZHJvL2dk Yi9iaW51dGlscy1nZGIvc3JjL2dkYi90ZXN0c3VpdGUvZ2RiLnJldmVyc2UNClNvdXJjZSBk aXJlY3RvcmllcyBzZWFyY2hlZDogL2hvbWUvcGVkcm8vZ2RiL2JpbnV0aWxzLWdkYi9zcmMv Z2RiL3Rlc3RzdWl0ZS9nZGIucmV2ZXJzZTokY2RpcjokY3dkDQooZ2RiKSBraWxsDQpUaGUg cHJvZ3JhbSBpcyBub3QgYmVpbmcgcnVuLg0KKGdkYikgZmlsZSAvaG9tZS9wZWRyby9nZGIv YmludXRpbHMtZ2RiL2J1aWxkL2dkYi90ZXN0c3VpdGUvb3V0cHV0cy9nZGIucmV2ZXJzZS9z dGVwLXJldmVyc2Uvc3RlcC1yZXZlcnNlDQpSZWFkaW5nIHN5bWJvbHMgZnJvbSAvaG9tZS9w ZWRyby9nZGIvYmludXRpbHMtZ2RiL2J1aWxkL2dkYi90ZXN0c3VpdGUvb3V0cHV0cy9nZGIu cmV2ZXJzZS9zdGVwLXJldmVyc2Uvc3RlcC1yZXZlcnNlLi4uDQooZ2RiKSBkZWxldGUgYnJl YWtwb2ludHMNCihnZGIpIGluZm8gYnJlYWtwb2ludHMNCk5vIGJyZWFrcG9pbnRzIG9yIHdh dGNocG9pbnRzLg0KKGdkYikgYnJlYWsgLXF1YWxpZmllZCBtYWluDQpCcmVha3BvaW50IDEg YXQgMHgxMWYxOiBmaWxlIC9ob21lL3BlZHJvL2dkYi9iaW51dGlscy1nZGIvc3JjL2dkYi90 ZXN0c3VpdGUvZ2RiLnJldmVyc2Uvc3RlcC1yZXZlcnNlLmMsIGxpbmUgNTguDQooZ2RiKSBy dW4gDQpTdGFydGluZyBwcm9ncmFtOiAvaG9tZS9wZWRyby9nZGIvYmludXRpbHMtZ2RiL2J1 aWxkL2dkYi90ZXN0c3VpdGUvb3V0cHV0cy9nZGIucmV2ZXJzZS9zdGVwLXJldmVyc2Uvc3Rl cC1yZXZlcnNlIA0KDQpCcmVha3BvaW50IDEsIG1haW4gKCkgYXQgL2hvbWUvcGVkcm8vZ2Ri L2JpbnV0aWxzLWdkYi9zcmMvZ2RiL3Rlc3RzdWl0ZS9nZGIucmV2ZXJzZS9zdGVwLXJldmVy c2UuYzo1OA0KNTgJICAgdyA9IDA7CS8qIEJSRUFLIEFUIE1BSU4gKi8NCihnZGIpIHJlY29y ZA0KKGdkYikgUEFTUzogZ2RiLnJldmVyc2Uvc3RlcC1yZXZlcnNlLmV4cDogdHVybiBvbiBw cm9jZXNzIHJlY29yZApuZXh0DQo1OQkgICB4ID0gMTsJLyogTkVYVCBURVNUIDEgKi8NCihn ZGIpIFBBU1M6IGdkYi5yZXZlcnNlL3N0ZXAtcmV2ZXJzZS5leHA6IG5leHQgdGVzdCAxCnN0 ZXANCjYwCSAgIHkgPSAyOwkvKiBTVEVQIFRFU1QgMSAqLw0KKGdkYikgUEFTUzogZ2RiLnJl dmVyc2Uvc3RlcC1yZXZlcnNlLmV4cDogc3RlcCB0ZXN0IDEKbmV4dCAyDQo2MgkgICB3ID0g dyArIDI7CS8qIE5FWFQgVEVTVCAyICovDQooZ2RiKSBQQVNTOiBnZGIucmV2ZXJzZS9zdGVw LXJldmVyc2UuZXhwOiBuZXh0IHRlc3QgMgpzdGVwIDMNCjY1CSAgIHogPSB6ICsgNTsJLyog U1RFUCBURVNUIDIgKi8NCihnZGIpIFBBU1M6IGdkYi5yZXZlcnNlL3N0ZXAtcmV2ZXJzZS5l eHA6IHN0ZXAgdGVzdCAyCm5leHQgMg0KNzEJICAgY2FsbGVlKCk7CS8qIE5FWFQgT1ZFUiBU SElTIENBTEwgKi8NCihnZGIpIFBBU1M6IGdkYi5yZXZlcnNlL3N0ZXAtcmV2ZXJzZS5leHA6 IG5leHQgb3ZlciByZWN1cnNpb24KbmV4dA0KNzQJICAgY2FsbGVlKCk7CS8qIFNURVAgSU5U TyBUSElTIENBTEwgKi8NCihnZGIpIFBBU1M6IGdkYi5yZXZlcnNlL3N0ZXAtcmV2ZXJzZS5l eHA6IG5leHQgb3ZlciBjYWxsCnN0ZXANCmNhbGxlZSAoKSBhdCAvaG9tZS9wZWRyby9nZGIv YmludXRpbHMtZ2RiL3NyYy9nZGIvdGVzdHN1aXRlL2dkYi5yZXZlcnNlL3N0ZXAtcmV2ZXJz ZS5jOjI2DQoyNgkgIHJldHVybiBteWdsb2IrKzsJLyogQVJSSVZFRCBJTiBDQUxMRUUgKi8N CihnZGIpIFBBU1M6IGdkYi5yZXZlcnNlL3N0ZXAtcmV2ZXJzZS5leHA6IHN0ZXAgaW50byBj YWxsCmZpbmlzaA0KUnVuIHRpbGwgZXhpdCBmcm9tICMwICBjYWxsZWUgKCkgYXQgL2hvbWUv cGVkcm8vZ2RiL2JpbnV0aWxzLWdkYi9zcmMvZ2RiL3Rlc3RzdWl0ZS9nZGIucmV2ZXJzZS9z dGVwLXJldmVyc2UuYzoyNg0KbWFpbiAoKSBhdCAvaG9tZS9wZWRyby9nZGIvYmludXRpbHMt Z2RiL3NyYy9nZGIvdGVzdHN1aXRlL2dkYi5yZXZlcnNlL3N0ZXAtcmV2ZXJzZS5jOjc3DQo3 NwkgICBhWzVdID0gYVszXSAtIGFbNF07IC8qIEZJTklTSCBURVNUICovDQpWYWx1ZSByZXR1 cm5lZCBpcyAkMSA9IDENCihnZGIpIFBBU1M6IGdkYi5yZXZlcnNlL3N0ZXAtcmV2ZXJzZS5l eHA6IGZpbmlzaCBvdXQgb2YgZm4gY2FsbApzdGVwaQ0KNzcJICAgYVs1XSA9IGFbM10gLSBh WzRdOyAvKiBGSU5JU0ggVEVTVCAqLw0KKGdkYikgc3RlcGkNCjc3CSAgIGFbNV0gPSBhWzNd IC0gYVs0XTsgLyogRklOSVNIIFRFU1QgKi8NCihnZGIpIHN0ZXBpDQoweDAwMDA1NTU1NTU1 NTUyNDMJNzcJICAgYVs1XSA9IGFbM10gLSBhWzRdOyAvKiBGSU5JU0ggVEVTVCAqLw0KKGdk Yikgc3RlcGkNCjc3CSAgIGFbNV0gPSBhWzNdIC0gYVs0XTsgLyogRklOSVNIIFRFU1QgKi8N CihnZGIpIHN0ZXBpDQo3OAkgICBjYWxsZWUoKTsJLyogU1RFUEkgVEVTVCAqLw0KKGdkYikg UEFTUzogZ2RiLnJldmVyc2Uvc3RlcC1yZXZlcnNlLmV4cDogc2ltcGxlIHN0ZXBpCnN0ZXBp DQoweDAwMDA1NTU1NTU1NTUyNGQJNzgJICAgY2FsbGVlKCk7CS8qIFNURVBJIFRFU1QgKi8N CihnZGIpIHN0ZXBpDQpjYWxsZWUgKCkgYXQgL2hvbWUvcGVkcm8vZ2RiL2JpbnV0aWxzLWdk Yi9zcmMvZ2RiL3Rlc3RzdWl0ZS9nZGIucmV2ZXJzZS9zdGVwLXJldmVyc2UuYzoyNQ0KMjUJ aW50IGNhbGxlZSgpIHsJCS8qIEVOVEVSIENBTExFRSAqLw0KKGdkYikgc3RlcGkNCjB4MDAw MDU1NTU1NTU1NTE2ZAkyNQlpbnQgY2FsbGVlKCkgewkJLyogRU5URVIgQ0FMTEVFICovDQoo Z2RiKSBzdGVwaQ0KMHgwMDAwNTU1NTU1NTU1MTZlCTI1CWludCBjYWxsZWUoKSB7CQkvKiBF TlRFUiBDQUxMRUUgKi8NCihnZGIpIHN0ZXBpDQoyNgkgIHJldHVybiBteWdsb2IrKzsJLyog QVJSSVZFRCBJTiBDQUxMRUUgKi8NCihnZGIpIFBBU1M6IGdkYi5yZXZlcnNlL3N0ZXAtcmV2 ZXJzZS5leHA6IHN0ZXBpIGludG8gZnVuY3Rpb24gY2FsbApzdGVwaQ0KMHgwMDAwNTU1NTU1 NTU1MTc3CTI2CSAgcmV0dXJuIG15Z2xvYisrOwkvKiBBUlJJVkVEIElOIENBTExFRSAqLw0K KGdkYikgc3RlcGkNCjB4MDAwMDU1NTU1NTU1NTE3YQkyNgkgIHJldHVybiBteWdsb2IrKzsJ LyogQVJSSVZFRCBJTiBDQUxMRUUgKi8NCihnZGIpIHN0ZXBpDQoyNwl9CQkJLyogUkVUVVJO IEZST00gQ0FMTEVFICovDQooZ2RiKSBzdGVwaQ0KMHgwMDAwNTU1NTU1NTU1MTgxCTI3CX0J CQkvKiBSRVRVUk4gRlJPTSBDQUxMRUUgKi8NCihnZGIpIHN0ZXBpDQptYWluICgpIGF0IC9o b21lL3BlZHJvL2dkYi9iaW51dGlscy1nZGIvc3JjL2dkYi90ZXN0c3VpdGUvZ2RiLnJldmVy c2Uvc3RlcC1yZXZlcnNlLmM6ODENCjgxCSAgIGNhbGxlZSgpOwkvKiBORVhUSSBURVNUICov DQooZ2RiKSBQQVNTOiBnZGIucmV2ZXJzZS9zdGVwLXJldmVyc2UuZXhwOiBzdGVwaSBiYWNr IGZyb20gZnVuY3Rpb24gY2FsbApzZXQgZXhlYy1kaXIgcmV2ZXJzZQ0KKGdkYikgUEFTUzog Z2RiLnJldmVyc2Uvc3RlcC1yZXZlcnNlLmV4cDogc2V0IHJldmVyc2UgZXhlY3V0aW9uCnN0 ZXBpDQoweDAwMDA1NTU1NTU1NTUxODEgaW4gY2FsbGVlICgpIGF0IC9ob21lL3BlZHJvL2dk Yi9iaW51dGlscy1nZGIvc3JjL2dkYi90ZXN0c3VpdGUvZ2RiLnJldmVyc2Uvc3RlcC1yZXZl cnNlLmM6MjcNCjI3CX0JCQkvKiBSRVRVUk4gRlJPTSBDQUxMRUUgKi8NCihnZGIpIHN0ZXBp DQoyNwl9CQkJLyogUkVUVVJOIEZST00gQ0FMTEVFICovDQooZ2RiKSBzdGVwaQ0KMHgwMDAw NTU1NTU1NTU1MTdhCTI2CSAgcmV0dXJuIG15Z2xvYisrOwkvKiBBUlJJVkVEIElOIENBTExF RSAqLw0KKGdkYikgc3RlcGkNCjB4MDAwMDU1NTU1NTU1NTE3NwkyNgkgIHJldHVybiBteWds b2IrKzsJLyogQVJSSVZFRCBJTiBDQUxMRUUgKi8NCihnZGIpIHN0ZXBpDQoyNgkgIHJldHVy biBteWdsb2IrKzsJLyogQVJSSVZFRCBJTiBDQUxMRUUgKi8NCihnZGIpIFBBU1M6IGdkYi5y ZXZlcnNlL3N0ZXAtcmV2ZXJzZS5leHA6IHJldmVyc2Ugc3RlcGkgdGhydSBmdW5jdGlvbiBy ZXR1cm4Kc3RlcGkNCjB4MDAwMDU1NTU1NTU1NTE2ZQkyNQlpbnQgY2FsbGVlKCkgewkJLyog RU5URVIgQ0FMTEVFICovDQooZ2RiKSBzdGVwaQ0KMHgwMDAwNTU1NTU1NTU1MTZkCTI1CWlu dCBjYWxsZWUoKSB7CQkvKiBFTlRFUiBDQUxMRUUgKi8NCihnZGIpIHN0ZXBpDQoyNQlpbnQg Y2FsbGVlKCkgewkJLyogRU5URVIgQ0FMTEVFICovDQooZ2RiKSBzdGVwaQ0KMHgwMDAwNTU1 NTU1NTU1MjRkIGluIG1haW4gKCkgYXQgL2hvbWUvcGVkcm8vZ2RiL2JpbnV0aWxzLWdkYi9z cmMvZ2RiL3Rlc3RzdWl0ZS9nZGIucmV2ZXJzZS9zdGVwLXJldmVyc2UuYzo3OA0KNzgJICAg Y2FsbGVlKCk7CS8qIFNURVBJIFRFU1QgKi8NCihnZGIpIHN0ZXBpDQo3OAkgICBjYWxsZWUo KTsJLyogU1RFUEkgVEVTVCAqLw0KKGdkYikgUEFTUzogZ2RiLnJldmVyc2Uvc3RlcC1yZXZl cnNlLmV4cDogcmV2ZXJzZSBzdGVwaSBmcm9tIGEgZnVuY3Rpb24gY2FsbApzdGVwaQ0KNzcJ ICAgYVs1XSA9IGFbM10gLSBhWzRdOyAvKiBGSU5JU0ggVEVTVCAqLw0KKGdkYikgUEFTUzog Z2RiLnJldmVyc2Uvc3RlcC1yZXZlcnNlLmV4cDogc2ltcGxlIHJldmVyc2Ugc3RlcGkKc3Rl cA0KNzcJICAgYVs1XSA9IGFbM10gLSBhWzRdOyAvKiBGSU5JU0ggVEVTVCAqLw0KKGdkYikg RkFJTDogZ2RiLnJldmVyc2Uvc3RlcC1yZXZlcnNlLmV4cDogcmV2ZXJzZSBzdGVwIGludG8g Zm4gY2FsbApzdGVwDQpjYWxsZWUgKCkgYXQgL2hvbWUvcGVkcm8vZ2RiL2JpbnV0aWxzLWdk Yi9zcmMvZ2RiL3Rlc3RzdWl0ZS9nZGIucmV2ZXJzZS9zdGVwLXJldmVyc2UuYzoyNw0KMjcJ fQkJCS8qIFJFVFVSTiBGUk9NIENBTExFRSAqLw0KKGdkYikgRkFJTDogZ2RiLnJldmVyc2Uv c3RlcC1yZXZlcnNlLmV4cDogcmV2ZXJzZSBzdGVwIG91dCBvZiBjYWxsZWQgZm4KbmV4dA0K MjYJICByZXR1cm4gbXlnbG9iKys7CS8qIEFSUklWRUQgSU4gQ0FMTEVFICovDQooZ2RiKSBG QUlMOiBnZGIucmV2ZXJzZS9zdGVwLXJldmVyc2UuZXhwOiByZXZlcnNlIG5leHQgb3ZlciBj YWxsCm5leHQNCm1haW4gKCkgYXQgL2hvbWUvcGVkcm8vZ2RiL2JpbnV0aWxzLWdkYi9zcmMv Z2RiL3Rlc3RzdWl0ZS9nZGIucmV2ZXJzZS9zdGVwLXJldmVyc2UuYzo3NA0KNzQJICAgY2Fs bGVlKCk7CS8qIFNURVAgSU5UTyBUSElTIENBTEwgKi8NCihnZGIpIEZBSUw6IGdkYi5yZXZl cnNlL3N0ZXAtcmV2ZXJzZS5leHA6IHJldmVyc2UgbmV4dCBvdmVyIHJlY3Vyc2lvbgpzZXQg ZXhlYy1kaXIgZm9yd2FyZA0KKGdkYikgUEFTUzogZ2RiLnJldmVyc2Uvc3RlcC1yZXZlcnNl LmV4cDogZm9yd2FyZCBhZ2FpbiB0byB0ZXN0IHJlY3Vyc2lvbgpuZXh0DQo3NwkgICBhWzVd ID0gYVszXSAtIGFbNF07IC8qIEZJTklTSCBURVNUICovDQooZ2RiKSBGQUlMOiBnZGIucmV2 ZXJzZS9zdGVwLXJldmVyc2UuZXhwOiByZXZlcnNlIG5leHQgb3ZlciByZWN1cnNpb24gYWdh aW4Kc2V0IGV4ZWMtZGlyIHJldmVyc2UNCihnZGIpIFBBU1M6IGdkYi5yZXZlcnNlL3N0ZXAt cmV2ZXJzZS5leHA6IHJldmVyc2UgYWdhaW4gdG8gdGVzdCByZWN1cnNpb24Kc3RlcA0KY2Fs bGVlICgpIGF0IC9ob21lL3BlZHJvL2dkYi9iaW51dGlscy1nZGIvc3JjL2dkYi90ZXN0c3Vp dGUvZ2RiLnJldmVyc2Uvc3RlcC1yZXZlcnNlLmM6MjcNCjI3CX0JCQkvKiBSRVRVUk4gRlJP TSBDQUxMRUUgKi8NCihnZGIpIEZBSUw6IGdkYi5yZXZlcnNlL3N0ZXAtcmV2ZXJzZS5leHA6 IGVudGVyIHJlY3Vyc2l2ZSBmdW5jdGlvbgpuZXh0DQoyNgkgIHJldHVybiBteWdsb2IrKzsJ LyogQVJSSVZFRCBJTiBDQUxMRUUgKi8NCihnZGIpIG5leHQNCm1haW4gKCkgYXQgL2hvbWUv cGVkcm8vZ2RiL2JpbnV0aWxzLWdkYi9zcmMvZ2RiL3Rlc3RzdWl0ZS9nZGIucmV2ZXJzZS9z dGVwLXJldmVyc2UuYzo3NA0KNzQJICAgY2FsbGVlKCk7CS8qIFNURVAgSU5UTyBUSElTIENB TEwgKi8NCihnZGIpIG5leHQNCjcxCSAgIGNhbGxlZSgpOwkvKiBORVhUIE9WRVIgVEhJUyBD QUxMICovDQooZ2RiKSBuZXh0DQo2OAkgICByZWN1cnNpdmVfY2FsbGVlICgzMik7IC8qIE5F WFQgT1ZFUiBUSElTIFJFQ1VSU0lPTiAqLw0KKGdkYikgUEFTUzogZ2RiLnJldmVyc2Uvc3Rl cC1yZXZlcnNlLmV4cDogc3RlcCBvdmVyIHJlY3Vyc2lvbiBpbnNpZGUgdGhlIHJlY3Vyc2lv bgpzdGVwIDMNCjYzCSAgIHggPSB4ICsgMzsJLyogUkVWRVJTRSBTVEVQIFRFU1QgMSAqLw0K KGdkYikgUEFTUzogZ2RiLnJldmVyc2Uvc3RlcC1yZXZlcnNlLmV4cDogcmV2ZXJzZSBzdGVw IHRlc3QgMQpuZXh0IDINCjYxCSAgIHogPSAzOwkvKiBSRVZFUlNFIE5FWFQgVEVTVCAxICov DQooZ2RiKSBQQVNTOiBnZGIucmV2ZXJzZS9zdGVwLXJldmVyc2UuZXhwOiByZXZlcnNlIG5l eHQgdGVzdCAxCnN0ZXANCjYwCSAgIHkgPSAyOwkvKiBTVEVQIFRFU1QgMSAqLw0KKGdkYikg UEFTUzogZ2RiLnJldmVyc2Uvc3RlcC1yZXZlcnNlLmV4cDogcmV2ZXJzZSBzdGVwIHRlc3Qg MgpuZXh0DQo1OQkgICB4ID0gMTsJLyogTkVYVCBURVNUIDEgKi8NCihnZGIpIFBBU1M6IGdk Yi5yZXZlcnNlL3N0ZXAtcmV2ZXJzZS5leHA6IHJldmVyc2UgbmV4dCB0ZXN0IDIKdGVzdGNh c2UgL2hvbWUvcGVkcm8vZ2RiL2JpbnV0aWxzLWdkYi9zcmMvZ2RiL3Rlc3RzdWl0ZS9nZGIu cmV2ZXJzZS9zdGVwLXJldmVyc2UuZXhwIGNvbXBsZXRlZCBpbiAwIHNlY29uZHMKCgkJPT09 IGdkYiBTdW1tYXJ5ID09PQoKIyBvZiBleHBlY3RlZCBwYXNzZXMJCTIzCiMgb2YgdW5leHBl Y3RlZCBmYWlsdXJlcwk2CkV4ZWN1dGluZyBvbiBob3N0OiAvaG9tZS9wZWRyby9nZGIvYmlu dXRpbHMtZ2RiL2J1aWxkL2dkYi90ZXN0c3VpdGUvLi4vLi4vZ2RiL2dkYiAtbncgLW54IC1p ZXggInNldCBoZWlnaHQgMCIgLWlleCAic2V0IHdpZHRoIDAiIC1kYXRhLWRpcmVjdG9yeSAv aG9tZS9wZWRyby9nZGIvYmludXRpbHMtZ2RiL2J1aWxkL2dkYi90ZXN0c3VpdGUvLi4vZGF0 YS1kaXJlY3RvcnkgLS12ZXJzaW9uICAgICh0aW1lb3V0ID0gMzAwKQpidWlsdGluX3NwYXdu IC1pZ25vcmUgU0lHSFVQIC9ob21lL3BlZHJvL2dkYi9iaW51dGlscy1nZGIvYnVpbGQvZ2Ri L3Rlc3RzdWl0ZS8uLi8uLi9nZGIvZ2RiIC1udyAtbnggLWlleCBzZXQgaGVpZ2h0IDAgLWll eCBzZXQgd2lkdGggMCAtZGF0YS1kaXJlY3RvcnkgL2hvbWUvcGVkcm8vZ2RiL2JpbnV0aWxz LWdkYi9idWlsZC9nZGIvdGVzdHN1aXRlLy4uL2RhdGEtZGlyZWN0b3J5IC0tdmVyc2lvbg0K R05VIGdkYiAoR0RCKSAxMy4wLjUwLjIwMjIwOTMwLWdpdA0KQ29weXJpZ2h0IChDKSAyMDIy IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLg0KTGljZW5zZSBHUEx2Mys6IEdOVSBH UEwgdmVyc2lvbiAzIG9yIGxhdGVyIDxodHRwOi8vZ251Lm9yZy9saWNlbnNlcy9ncGwuaHRt bD4NClRoaXMgaXMgZnJlZSBzb2Z0d2FyZTogeW91IGFyZSBmcmVlIHRvIGNoYW5nZSBhbmQg cmVkaXN0cmlidXRlIGl0Lg0KVGhlcmUgaXMgTk8gV0FSUkFOVFksIHRvIHRoZSBleHRlbnQg cGVybWl0dGVkIGJ5IGxhdy4NCi9ob21lL3BlZHJvL2dkYi9iaW51dGlscy1nZGIvYnVpbGQv Z2RiL2dkYiB2ZXJzaW9uICAxMy4wLjUwLjIwMjIwOTMwLWdpdCAtbncgLW54IC1pZXggInNl dCBoZWlnaHQgMCIgLWlleCAic2V0IHdpZHRoIDAiIC1kYXRhLWRpcmVjdG9yeSAvaG9tZS9w ZWRyby9nZGIvYmludXRpbHMtZ2RiL2J1aWxkL2dkYi90ZXN0c3VpdGUvLi4vZGF0YS1kaXJl Y3RvcnkgCgpydW50ZXN0IGNvbXBsZXRlZCBhdCBGcmkgU2VwIDMwIDE3OjUyOjMwIDIwMjIK --------------7A2452831060DF7C690EFA5C--