From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 13224 invoked by alias); 28 May 2013 00:02:23 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 13212 invoked by uid 89); 28 May 2013 00:02:22 -0000 X-Spam-SWARE-Status: No, score=-3.0 required=5.0 tests=AWL,BAYES_00,FREEMAIL_FROM,KHOP_THREADED,RCVD_IN_DNSWL_LOW,RCVD_IN_HOSTKARMA_YE,SPF_PASS,TW_XP autolearn=ham version=3.3.1 Received: from mail-oa0-f51.google.com (HELO mail-oa0-f51.google.com) (209.85.219.51) by sourceware.org (qpsmtpd/0.84/v0.84-167-ge50287c) with ESMTP; Tue, 28 May 2013 00:02:15 +0000 Received: by mail-oa0-f51.google.com with SMTP id f4so9257210oah.38 for ; Mon, 27 May 2013 17:02:14 -0700 (PDT) X-Received: by 10.182.236.104 with SMTP id ut8mr212610obc.75.1369699334223; Mon, 27 May 2013 17:02:14 -0700 (PDT) MIME-Version: 1.0 Received: by 10.60.38.193 with HTTP; Mon, 27 May 2013 17:01:34 -0700 (PDT) In-Reply-To: <519CBE2B.7060007@redhat.com> References: <1361192891-29341-1-git-send-email-yao@codesourcery.com> <8738wpd3qe.fsf@fleche.redhat.com> <5176C14B.6010603@redhat.com> <51774714.9060306@codesourcery.com> <51969A92.80003@redhat.com> <519CBE2B.7060007@redhat.com> From: Hui Zhu Date: Tue, 28 May 2013 00:02:00 -0000 Message-ID: Subject: Re: [RFC] PR 15075 dprintf interferes with "next" To: Pedro Alves , Tom Tromey Cc: gdb-patches@sourceware.org, Keith Seitz , Yao Qi Content-Type: multipart/mixed; boundary=001a11c3183843ffc804ddbbfa85 X-Virus-Found: No X-SW-Source: 2013-05/txt/msg00958.txt.bz2 --001a11c3183843ffc804ddbbfa85 Content-Type: text/plain; charset=ISO-8859-1 Content-length: 13273 Hi Pedro and Tom, Thanks for your review. On Wed, May 22, 2013 at 8:46 PM, Pedro Alves wrote: > On 05/22/2013 11:21 AM, Hui Zhu wrote: > >> I tried it on fedora and looks it works OK most of times. I only got >> trouble is when run this test with remote, [runto main] with >> "non-stop" is open will fail sometime. > > Sorry, but "most of the times" is not acceptable. Can you please > figure out why that is so? This should never fail. I found a issue about remote test and non-stop. Because it doesn't have a lot of relation with dprintf, I will post a separate patch for that later. > >>> > Not sure even that is necessary, given bs->stop==0 and: >>> > >>> > /* Print nothing for this entry if we don't stop or don't >>> > print. */ >>> > if (!bs->stop || !bs->print) >>> > bs->print_it = print_it_noop; >> I am not sure about this part. >> If my understanding about Tom's review in before is right, the action >> of dprintf command should be handled when GDB check the condition. >> And after that, dprintf not need be handled. > > Yes, but I don't see how that counters my suggestion. Added dprintf_create_breakpoints_sal. When dprintf is created, auto set silent to 0. > >>> > >>>> >> + bpstat_do_actions_1 (&bs); >>>> >> + bs->next = tmp; >>>> >> +} >>> > >>> > Could you add some comments explaining what this is >>> > doing, and why? >> I update this function to following part: >> /* Implement the "after_cond" breakpoint_ops method for dprintf. */ >> >> static void >> dprintf_after_cond (struct bpstats *bs) > > >> { >> struct cleanup *old_chain; >> struct breakpoint *b = bs->breakpoint_at; >> >> bs->commands = b->commands; >> incref_counted_command_line (bs->commands); > > I still think there's no point in moving this to the > after_condition_true hook, if both existing implementations > end up doing it themselves. See below. > >> >> /* Because function bpstat_do_actions_1 will execute all the command >> list of BS and follow it by BS->NEXT, temporarily set BS->NEXT to >> NULL. */ >> old_chain = make_cleanup_restore_ptr ((void **)&bs->next); > > That cast is invalid actually. Older gcc's will complain about > the aliasing violation. I think we can get away without this, by > passing a separate list with only one entry to bpstat_do_actions_1. > >> bs->next = NULL; >> bpstat_do_actions_1 (&bs); >> do_cleanups (old_chain); >> >> /* This dprintf need not be handled after this function >> because its command list is executed by bpstat_do_actions_1. >> Clear STOP and PRINT for that. */ >> bs->stop = 0; >> bs->print = 0; > > Thanks. I was more looking for general design comments on why we > run the command list here. This also should explain why clear stop > here, instead of on the more natural check_status. > > So all in all, if it works for you (seems to work fine for me), I'd > rather do as this patch on top of yours does: > Thanks for this patch. I merged it to dprintf-continue patch. > ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ > gdb/breakpoint.c | 62 ++++++++++++++++++++++++++++++++---------------------- > 1 file changed, 37 insertions(+), 25 deletions(-) > > diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c > index 7ef5703..181aecc 100644 > --- a/gdb/breakpoint.c > +++ b/gdb/breakpoint.c > @@ -5292,6 +5292,15 @@ bpstat_stop_status (struct address_space *aspace, > b->enable_state = bp_disabled; > removed_any = 1; > } > + > + if (b->silent) > + bs->print = 0; > + bs->commands = b->commands; > + incref_counted_command_line (bs->commands); > + if (command_line_is_silent (bs->commands > + ? bs->commands->commands : NULL)) > + bs->print = 0; > + > b->ops->after_condition_true (bs); > } > > @@ -12742,15 +12751,7 @@ base_breakpoint_explains_signal (struct breakpoint *b) > static void > base_breakpoint_after_condition_true (struct bpstats *bs) > { > - struct breakpoint *b = bs->breakpoint_at; > - > - if (b->silent) > - bs->print = 0; > - bs->commands = b->commands; > - incref_counted_command_line (bs->commands); > - if (command_line_is_silent (bs->commands > - ? bs->commands->commands : NULL)) > - bs->print = 0; > + /* Nothing to do. */ > } > > struct breakpoint_ops base_breakpoint_ops = > @@ -13368,30 +13369,41 @@ dprintf_print_recreate (struct breakpoint *tp, struct ui_file *fp) > } > > /* Implement the "after_condition_true" breakpoint_ops method for > - dprintf. */ > + dprintf. > + > + dprintf's are implemented with regular commands in their command > + list, but we run the commands here instead of before presenting the > + stop to the user, as dprintf's don't actually cause a stop. This > + also makes it so that the commands of multiple dprintfs at the same > + address are all handled. */ > > static void > dprintf_after_condition_true (struct bpstats *bs) > { > struct cleanup *old_chain; > - struct breakpoint *b = bs->breakpoint_at; > + struct bpstats tmp_bs = { NULL }; > + struct bpstats *tmp_bs_p = &tmp_bs; > > - bs->commands = b->commands; > - incref_counted_command_line (bs->commands); > + /* dprintf's never cause a stop. This wasn't set in the > + check_status hook instead because that would make the dprintf's > + condition not be evaluated. */ > + bs->stop = 0; > > - /* Because function bpstat_do_actions_1 will execute all the command > - list of BS and follow it by BS->NEXT, temporarily set BS->NEXT to > - NULL. */ > - old_chain = make_cleanup_restore_ptr ((void **)&bs->next); > - bs->next = NULL; > - bpstat_do_actions_1 (&bs); > - do_cleanups (old_chain); > + /* Run the command list here. Take ownership of it instead of > + copying. We never want these commands to run later in > + bpstat_do_actions, if a breakpoint that causes a stop happens to > + be set at same address as this dprintf, or even if running the > + commands here throws. */ > + tmp_bs.commands = bs->commands; > + bs->commands = NULL; > + old_chain = make_cleanup_decref_counted_command_line (&tmp_bs.commands); > > - /* This dprintf need not be handled after this function > - because its command list is executed by bpstat_do_actions_1. > - Clear STOP and PRINT for that. */ > - bs->stop = 0; > - bs->print = 0; > + bpstat_do_actions_1 (&tmp_bs_p); > + > + /* 'tmp_bs.commands' will usually be NULL by now, but > + bpstat_do_actions_1 may return early without processing the whole > + list. */ > + do_cleanups (old_chain); > } > > /* The breakpoint_ops structure to be used on static tracepoints with > ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ > >>>> >> +if [prepare_for_testing $expfile $executable $srcfile {debug}] { >>>> >> + untested "failed to prepare for trace tests" >>> > >>> > This is not a trace test. Actually, prepare_for_testing >>> > already calls untested with whatever we pass it as first argument. >>> > I think it'd be the first such call in the testsuite, but I >>> > think this would be better: >>> > >>> > if [prepare_for_testing "failed to prepare for trace tests" \ >>> > $executable $srcfile {debug}] { >>> > return -1 >>> > } >> After I use this part of code, I got: >> ERROR: tcl error sourcing ../../../src/gdb/testsuite/gdb.base/dprintf-next.exp. >> ERROR: wrong # args: should be "prepare_for_testing testname >> executable ?sources? ?options?" >> while executing >> "prepare_for_testing "failed to prepare for dprintf next tests"" >> invoked from within >> "if [prepare_for_testing "failed to prepare for dprintf next tests" >> $executable $srcfile {debug}] { >> return -1 >> }" > > Hmm? Oh, it looks like you forgot the '\' at the end of the line. > Please try again. Fixed both dprintf-next.exp and dprintf-non-stop.exp. > >> So I change this part to: >> if { [prepare_for_testing dprintf-next.exp "dprintf-next" {} {debug}] } { > > 'dprintf-next.exp' really isn't magical. It's just a string. :-) > >> return -1 >> } > >>>> >> +gdb_test "next" ".*" "next 1" >>>> >> +gdb_test "next" ".*" "next 2" >>> > >>> > Please use more string regexes for these, that confirm the next stopped >>> > at the right lines. >> Fixed. > > Sorry, I should have been clearer. Don't do that by checking > line numbers though, as those change when more functions are > added to the test. Just make each line look different instead. > >> + >> +gdb_test "dprintf $dp_location, \"%d\\n\", x" \ >> + "Dprintf .*" > > Please add an explicit 3rd parameter to gdb_test, so that > the line number doesn't appear in gdb.sum. > >> + >> +gdb_test "next" "23.*\\+\\+x.*" "next 1" >> +gdb_test "next" "24.*\\+\\+x.*" "next 2" > > Do something like this: > > gdb_test "next" "\\+\\+x;" "next 1" > gdb_test "next" "\\+\\+x; /* set dprintf here" "next 2" > > You could add a comment to the first stepped line to > make that clearer: > > gdb_test "next" "\\+\\+x; /* step here.*" "next 1" > gdb_test "next" "\\+\\+x; /* set dprintf here" "next 2" This part is fixed. > > >> --- /dev/null >> +++ b/gdb/testsuite/gdb.base/dprintf-non-stop.c >> @@ -0,0 +1,30 @@ >> +/* This testcase is part of GDB, the GNU debugger. >> + >> + Copyright (C) 2013 Free Software Foundation, Inc. >> + Contributed by Hui Zhu >> + >> + This program is free software; you can redistribute it and/or modify >> + it under the terms of the GNU General Public License as published by >> + the Free Software Foundation; either version 3 of the License, or >> + (at your option) any later version. >> + >> + This program is distributed in the hope that it will be useful, >> + but WITHOUT ANY WARRANTY; without even the implied warranty of >> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >> + GNU General Public License for more details. >> + >> + You should have received a copy of the GNU General Public License >> + along with this program. If not, see . */ >> + >> +void >> +foo () >> +{ >> +} >> + >> +int >> +main () >> +{ >> + foo (); >> + while (1); > > If something goes wrong, like GDB crashing, this could leave the test > running forever, pegging the CPU. Just make it sleep for some > time instead. Changed this part to sleep(3) > >> + return 0; > >> +} >> \ No newline at end of file > > Please watch out for these, and add a newline. > Fixed. >> +gdb_test "dprintf foo,\"At foo entry\\n\"" "Dprintf .*" >> + >> +send_gdb "continue &\n" >> +exec sleep 1 >> +set test "interrupt" >> +gdb_test_multiple $test $test { >> + -re "interrupt\r\n$gdb_prompt " { >> + pass $test >> + } >> +} >> + >> +set test "inferior stopped" >> +gdb_test_multiple "" $test { >> + -re "\r\n\\\[.* \[0-9\]+\\\] #1 stopped\\\.\r\n" { >> + pass $test >> + } >> +} > > This leaves the prompt in the expect buffer. I think > this is likely to confuse the following test that runs. > After change this part to: gdb_test_multiple "" $test { -re "\r\n\\\[.* \[0-9\]+\\\] #1 stopped\\\.\r\n$gdb_prompt" { pass $test } } I got: Running ../../../src/gdb/testsuite/gdb.base/dprintf-non-stop.exp ... FAIL: gdb.base/dprintf-non-stop.exp: inferior stopped (timeout) I thought the reason is: (gdb) PASS: gdb.base/dprintf-non-stop.exp: interrupt [process 24118] #1 stopped. 0x00002aaaaad8f830 in nanosleep () from /lib/x86_64-linux-gnu/libc.so.6 FAIL: gdb.base/dprintf-non-stop.exp: inferior stopped (timeout) There is not $gdb_prompt. On Wed, May 22, 2013 at 10:04 PM, Tom Tromey wrote: >>>>>> "Hui" == Hui Zhu writes: > > Hui> So I change this part to: > Hui> if { [prepare_for_testing dprintf-next.exp "dprintf-next" {} {debug}] } { > Hui> return -1 > Hui> } > > I think it is better to use the variables created by standard_testfile. Fixed. The attachments are the new patches. Best, Hui 2013-05-28 Yao Qi Hui Zhu Pedro Alves PR breakpoints/15075 PR breakpoints/15434 * breakpoint.c (bpstat_stop_status): Call b->ops->after_condition_true. (update_dprintf_command_list): Don't append "continue" command to the command list of dprintf breakpoint. (base_breakpoint_after_condition_true): New function. (base_breakpoint_ops): Add base_breakpoint_after_condition_true. (dprintf_create_breakpoints_sal, dprintf_after_condition_true): New functions. (initialize_breakpoint_ops): Set dprintf_create_breakpoints_sal and dprintf_after_condition_true. * breakpoint.h (breakpoint_ops): Add after_condition_true. 2013-05-28 Yao Qi Hui Zhu PR breakpoints/15075 PR breakpoints/15434 * gdb.base/dprintf-next.c: New file. * gdb.base/dprintf-next.exp: New file. * gdb.base/dprintf-non-stop.c: New file. * gdb.base/dprintf-non-stop.exp: New file. * gdb.base/dprintf.exp: Don't check "continue" in the output of "info breakpoints". * gdb.mi/mi-breakpoint-changed.exp (test_insert_delete_modify): Don't check "continue" in script field. --001a11c3183843ffc804ddbbfa85 Content-Type: text/plain; charset=US-ASCII; name="dprintf-continue.txt" Content-Disposition: attachment; filename="dprintf-continue.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_hh8bkfeu0 Content-length: 7308 LS0tIGEvZ2RiL2JyZWFrcG9pbnQuYworKysgYi9nZGIvYnJlYWtwb2ludC5j CkBAIC01Mjk5LDYgKzUyOTksOCBAQCBicHN0YXRfc3RvcF9zdGF0dXMgKHN0 cnVjdCBhZGRyZXNzX3NwYWNlCiAJICAgICAgaWYgKGNvbW1hbmRfbGluZV9p c19zaWxlbnQgKGJzLT5jb21tYW5kcwogCQkJCQkgID8gYnMtPmNvbW1hbmRz LT5jb21tYW5kcyA6IE5VTEwpKQogCQlicy0+cHJpbnQgPSAwOworCisJICAg ICAgYi0+b3BzLT5hZnRlcl9jb25kaXRpb25fdHJ1ZSAoYnMpOwogCSAgICB9 CiAKIAl9CkBAIC04OTQ4LDI1ICs4OTUwLDE2IEBAIHVwZGF0ZV9kcHJpbnRm X2NvbW1hbmRfbGlzdCAoc3RydWN0IGJyZWEKIAkJICAgIF8oIkludmFsaWQg ZHByaW50ZiBzdHlsZS4iKSk7CiAKICAgZ2RiX2Fzc2VydCAocHJpbnRmX2xp bmUgIT0gTlVMTCk7Ci0gIC8qIE1hbnVmYWN0dXJlIGEgcHJpbnRmL2NvbnRp bnVlIHNlcXVlbmNlLiAgKi8KKyAgLyogTWFudWZhY3R1cmUgYSBwcmludGYg c2VxdWVuY2UuICAqLwogICB7Ci0gICAgc3RydWN0IGNvbW1hbmRfbGluZSAq cHJpbnRmX2NtZF9saW5lLCAqY29udF9jbWRfbGluZSA9IE5VTEw7Ci0KLSAg ICBpZiAoc3RyY21wIChkcHJpbnRmX3N0eWxlLCBkcHJpbnRmX3N0eWxlX2Fn ZW50KSAhPSAwKQotICAgICAgewotCWNvbnRfY21kX2xpbmUgPSB4bWFsbG9j IChzaXplb2YgKHN0cnVjdCBjb21tYW5kX2xpbmUpKTsKLQljb250X2NtZF9s aW5lLT5jb250cm9sX3R5cGUgPSBzaW1wbGVfY29udHJvbDsKLQljb250X2Nt ZF9saW5lLT5ib2R5X2NvdW50ID0gMDsKLQljb250X2NtZF9saW5lLT5ib2R5 X2xpc3QgPSBOVUxMOwotCWNvbnRfY21kX2xpbmUtPm5leHQgPSBOVUxMOwot CWNvbnRfY21kX2xpbmUtPmxpbmUgPSB4c3RyZHVwICgiY29udGludWUiKTsK LSAgICAgIH0KKyAgICBzdHJ1Y3QgY29tbWFuZF9saW5lICpwcmludGZfY21k X2xpbmUKKyAgICAgID0geG1hbGxvYyAoc2l6ZW9mIChzdHJ1Y3QgY29tbWFu ZF9saW5lKSk7CiAKICAgICBwcmludGZfY21kX2xpbmUgPSB4bWFsbG9jIChz aXplb2YgKHN0cnVjdCBjb21tYW5kX2xpbmUpKTsKICAgICBwcmludGZfY21k X2xpbmUtPmNvbnRyb2xfdHlwZSA9IHNpbXBsZV9jb250cm9sOwogICAgIHBy aW50Zl9jbWRfbGluZS0+Ym9keV9jb3VudCA9IDA7CiAgICAgcHJpbnRmX2Nt ZF9saW5lLT5ib2R5X2xpc3QgPSBOVUxMOwotICAgIHByaW50Zl9jbWRfbGlu ZS0+bmV4dCA9IGNvbnRfY21kX2xpbmU7CisgICAgcHJpbnRmX2NtZF9saW5l LT5uZXh0ID0gTlVMTDsKICAgICBwcmludGZfY21kX2xpbmUtPmxpbmUgPSBw cmludGZfbGluZTsKIAogICAgIGJyZWFrcG9pbnRfc2V0X2NvbW1hbmRzIChi LCBwcmludGZfY21kX2xpbmUpOwpAQCAtMTI3NTIsNiArMTI3NDUsMTQgQEAg YmFzZV9icmVha3BvaW50X2V4cGxhaW5zX3NpZ25hbCAoc3RydWN0CiAgIHJl dHVybiBCUFNUQVRfU0lHTkFMX0hJREU7CiB9CiAKKy8qIFRoZSBkZWZhdWx0 ICJhZnRlcl9jb25kaXRpb25fdHJ1ZSIgbWV0aG9kLiAgKi8KKworc3RhdGlj IHZvaWQKK2Jhc2VfYnJlYWtwb2ludF9hZnRlcl9jb25kaXRpb25fdHJ1ZSAo c3RydWN0IGJwc3RhdHMgKmJzKQoreworICAvKiBOb3RoaW5nIHRvIGRvLiAg ICovCit9CisKIHN0cnVjdCBicmVha3BvaW50X29wcyBiYXNlX2JyZWFrcG9p bnRfb3BzID0KIHsKICAgYmFzZV9icmVha3BvaW50X2R0b3IsCkBAIC0xMjc3 MSw3ICsxMjc3Miw4IEBAIHN0cnVjdCBicmVha3BvaW50X29wcyBiYXNlX2Jy ZWFrcG9pbnRfb3AKICAgYmFzZV9icmVha3BvaW50X2NyZWF0ZV9zYWxzX2Zy b21fYWRkcmVzcywKICAgYmFzZV9icmVha3BvaW50X2NyZWF0ZV9icmVha3Bv aW50c19zYWwsCiAgIGJhc2VfYnJlYWtwb2ludF9kZWNvZGVfbGluZXNwZWMs Ci0gIGJhc2VfYnJlYWtwb2ludF9leHBsYWluc19zaWduYWwKKyAgYmFzZV9i cmVha3BvaW50X2V4cGxhaW5zX3NpZ25hbCwKKyAgYmFzZV9icmVha3BvaW50 X2FmdGVyX2NvbmRpdGlvbl90cnVlLAogfTsKIAogLyogRGVmYXVsdCBicmVh a3BvaW50X29wcyBtZXRob2RzLiAgKi8KQEAgLTEzMzY1LDYgKzEzMzY3LDc2 IEBAIGRwcmludGZfcHJpbnRfcmVjcmVhdGUgKHN0cnVjdCBicmVha3BvaW4K ICAgcHJpbnRfcmVjcmVhdGVfdGhyZWFkICh0cCwgZnApOwogfQogCisvKiBJ bXBsZW1lbnQgdGhlICJjcmVhdGVfYnJlYWtwb2ludHNfc2FsIiBicmVha3Bv aW50X29wcyBtZXRob2QgZm9yCisgICBkcHJpbnRmLiAgKi8KKworc3RhdGlj IHZvaWQKK2RwcmludGZfY3JlYXRlX2JyZWFrcG9pbnRzX3NhbCAoc3RydWN0 IGdkYmFyY2ggKmdkYmFyY2gsCisJCQkJc3RydWN0IGxpbmVzcGVjX3Jlc3Vs dCAqY2Fub25pY2FsLAorCQkJCXN0cnVjdCBsaW5lc3BlY19zYWxzICpsc2Fs LAorCQkJCWNoYXIgKmNvbmRfc3RyaW5nLAorCQkJCWNoYXIgKmV4dHJhX3N0 cmluZywKKwkJCQllbnVtIGJwdHlwZSB0eXBlX3dhbnRlZCwKKwkJCQllbnVt IGJwZGlzcCBkaXNwb3NpdGlvbiwKKwkJCQlpbnQgdGhyZWFkLAorCQkJCWlu dCB0YXNrLCBpbnQgaWdub3JlX2NvdW50LAorCQkJCWNvbnN0IHN0cnVjdCBi cmVha3BvaW50X29wcyAqb3BzLAorCQkJCWludCBmcm9tX3R0eSwgaW50IGVu YWJsZWQsCisJCQkJaW50IGludGVybmFsLCB1bnNpZ25lZCBmbGFncykKK3sK KyAgc3RydWN0IGJyZWFrcG9pbnQgKmI7CisKKyAgY3JlYXRlX2JyZWFrcG9p bnRzX3NhbF9kZWZhdWx0IChnZGJhcmNoLCBjYW5vbmljYWwsIGxzYWwsCisJ CQkJICBjb25kX3N0cmluZywgZXh0cmFfc3RyaW5nLAorCQkJCSAgdHlwZV93 YW50ZWQsCisJCQkJICBkaXNwb3NpdGlvbiwgdGhyZWFkLCB0YXNrLAorCQkJ CSAgaWdub3JlX2NvdW50LCBvcHMsIGZyb21fdHR5LAorCQkJCSAgZW5hYmxl ZCwgaW50ZXJuYWwsIGZsYWdzKTsKKworICBiID0gZ2V0X2JyZWFrcG9pbnQg KGJyZWFrcG9pbnRfY291bnQpOworICBnZGJfYXNzZXJ0IChiICE9IE5VTEwp OworCisgIGJyZWFrcG9pbnRfc2V0X3NpbGVudCAoYiwgMCk7Cit9CisKKy8q IEltcGxlbWVudCB0aGUgImFmdGVyX2NvbmRpdGlvbl90cnVlIiBicmVha3Bv aW50X29wcyBtZXRob2QgZm9yCisgICBkcHJpbnRmLgorCisgICBkcHJpbnRm J3MgYXJlIGltcGxlbWVudGVkIHdpdGggcmVndWxhciBjb21tYW5kcyBpbiB0 aGVpciBjb21tYW5kCisgICBsaXN0LCBidXQgd2UgcnVuIHRoZSBjb21tYW5k cyBoZXJlIGluc3RlYWQgb2YgYmVmb3JlIHByZXNlbnRpbmcgdGhlCisgICBz dG9wIHRvIHRoZSB1c2VyLCBhcyBkcHJpbnRmJ3MgZG9uJ3QgYWN0dWFsbHkg Y2F1c2UgYSBzdG9wLiAgVGhpcworICAgYWxzbyBtYWtlcyBpdCBzbyB0aGF0 IHRoZSBjb21tYW5kcyBvZiBtdWx0aXBsZSBkcHJpbnRmcyBhdCB0aGUgc2Ft ZQorICAgYWRkcmVzcyBhcmUgYWxsIGhhbmRsZWQuICAqLworCitzdGF0aWMg dm9pZAorZHByaW50Zl9hZnRlcl9jb25kaXRpb25fdHJ1ZSAoc3RydWN0IGJw c3RhdHMgKmJzKQoreworICBzdHJ1Y3QgY2xlYW51cCAqb2xkX2NoYWluOwor ICBzdHJ1Y3QgYnBzdGF0cyB0bXBfYnMgPSB7IE5VTEwgfTsKKyAgc3RydWN0 IGJwc3RhdHMgKnRtcF9ic19wID0gJnRtcF9iczsKKworICAvKiBkcHJpbnRm J3MgbmV2ZXIgY2F1c2UgYSBzdG9wLiAgVGhpcyB3YXNuJ3Qgc2V0IGluIHRo ZQorICAgICBjaGVja19zdGF0dXMgaG9vayBpbnN0ZWFkIGJlY2F1c2UgdGhh dCB3b3VsZCBtYWtlIHRoZSBkcHJpbnRmJ3MKKyAgICAgY29uZGl0aW9uIG5v dCBiZSBldmFsdWF0ZWQuICAqLworICBicy0+c3RvcCA9IDA7CisKKyAgLyog UnVuIHRoZSBjb21tYW5kIGxpc3QgaGVyZS4gIFRha2Ugb3duZXJzaGlwIG9m IGl0IGluc3RlYWQgb2YKKyAgICAgY29weWluZy4gIFdlIG5ldmVyIHdhbnQg dGhlc2UgY29tbWFuZHMgdG8gcnVuIGxhdGVyIGluCisgICAgIGJwc3RhdF9k b19hY3Rpb25zLCBpZiBhIGJyZWFrcG9pbnQgdGhhdCBjYXVzZXMgYSBzdG9w IGhhcHBlbnMgdG8KKyAgICAgYmUgc2V0IGF0IHNhbWUgYWRkcmVzcyBhcyB0 aGlzIGRwcmludGYsIG9yIGV2ZW4gaWYgcnVubmluZyB0aGUKKyAgICAgY29t bWFuZHMgaGVyZSB0aHJvd3MuICAqLworICB0bXBfYnMuY29tbWFuZHMgPSBi cy0+Y29tbWFuZHM7CisgIGJzLT5jb21tYW5kcyA9IE5VTEw7CisgIG9sZF9j aGFpbiA9IG1ha2VfY2xlYW51cF9kZWNyZWZfY291bnRlZF9jb21tYW5kX2xp bmUgKCZ0bXBfYnMuY29tbWFuZHMpOworCisgIGJwc3RhdF9kb19hY3Rpb25z XzEgKCZ0bXBfYnNfcCk7CisKKyAgLyogJ3RtcF9icy5jb21tYW5kcycgd2ls bCB1c3VhbGx5IGJlIE5VTEwgYnkgbm93LCBidXQKKyAgICAgYnBzdGF0X2Rv X2FjdGlvbnNfMSBtYXkgcmV0dXJuIGVhcmx5IHdpdGhvdXQgcHJvY2Vzc2lu ZyB0aGUgd2hvbGUKKyAgICAgbGlzdC4gICovCisgIGRvX2NsZWFudXBzIChv bGRfY2hhaW4pOworfQorCiAvKiBUaGUgYnJlYWtwb2ludF9vcHMgc3RydWN0 dXJlIHRvIGJlIHVzZWQgb24gc3RhdGljIHRyYWNlcG9pbnRzIHdpdGgKICAg IG1hcmtlcnMgKGAtbScpLiAgKi8KIApAQCAtMTU4NjEsNiArMTU5MzMsOCBA QCBpbml0aWFsaXplX2JyZWFrcG9pbnRfb3BzICh2b2lkKQogICBvcHMtPnBy aW50X2l0ID0gYmtwdF9wcmludF9pdDsKICAgb3BzLT5wcmludF9tZW50aW9u ID0gYmtwdF9wcmludF9tZW50aW9uOwogICBvcHMtPnByaW50X3JlY3JlYXRl ID0gZHByaW50Zl9wcmludF9yZWNyZWF0ZTsKKyAgb3BzLT5jcmVhdGVfYnJl YWtwb2ludHNfc2FsID0gZHByaW50Zl9jcmVhdGVfYnJlYWtwb2ludHNfc2Fs OworICBvcHMtPmFmdGVyX2NvbmRpdGlvbl90cnVlID0gZHByaW50Zl9hZnRl cl9jb25kaXRpb25fdHJ1ZTsKIH0KIAogLyogQ2hhaW4gY29udGFpbmluZyBh bGwgZGVmaW5lZCAiZW5hYmxlIGJyZWFrcG9pbnQiIHN1YmNvbW1hbmRzLiAg Ki8KLS0tIGEvZ2RiL2JyZWFrcG9pbnQuaAorKysgYi9nZGIvYnJlYWtwb2lu dC5oCkBAIC02MTQsNiArNjE0LDEwIEBAIHN0cnVjdCBicmVha3BvaW50X29w cwogICAgICAnY2F0Y2ggc2lnbmFsJyBpbnRlcmFjdCBwcm9wZXJseSB3aXRo ICdoYW5kbGUnOyBzZWUKICAgICAgYnBzdGF0X2V4cGxhaW5zX3NpZ25hbC4g ICovCiAgIGVudW0gYnBzdGF0X3NpZ25hbF92YWx1ZSAoKmV4cGxhaW5zX3Np Z25hbCkgKHN0cnVjdCBicmVha3BvaW50ICopOworCisgIC8qIENhbGxlZCBh ZnRlciBldmFsdWF0aW5nIHRoZSBicmVha3BvaW50J3MgY29uZGl0aW9uLAor ICAgICBhbmQgb25seSBpZiBpdCBldmFsdWF0ZWQgdHJ1ZS4gICovCisgIHZv aWQgKCphZnRlcl9jb25kaXRpb25fdHJ1ZSkgKHN0cnVjdCBicHN0YXRzICpi cyk7CiB9OwogCiAvKiBIZWxwZXIgZm9yIGJyZWFrcG9pbnRfb3BzLT5wcmlu dF9yZWNyZWF0ZSBpbXBsZW1lbnRhdGlvbnMuICBQcmludHMK --001a11c3183843ffc804ddbbfa85 Content-Type: text/plain; charset=US-ASCII; name="dprintf-continue-test.txt" Content-Disposition: attachment; filename="dprintf-continue-test.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_hh8bkukt1 Content-length: 8020 LS0tIC9kZXYvbnVsbAorKysgYi9nZGIvdGVzdHN1aXRlL2dkYi5iYXNlL2Rw cmludGYtbmV4dC5jCkBAIC0wLDAgKzEsMjYgQEAKKy8qIFRoaXMgdGVzdGNh c2UgaXMgcGFydCBvZiBHREIsIHRoZSBHTlUgZGVidWdnZXIuCisKKyAgIENv cHlyaWdodCAoQykgMjAxMyBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIElu Yy4KKworICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAgIGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5CisgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uOyBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgorICAg KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgVGhp cyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQg d2lsbCBiZSB1c2VmdWwsCisgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7 IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZQorICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKworICAgWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UK KyAgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0 dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LiAgKi8KKworaW50CittYWlu ICh2b2lkKQoreworICBpbnQgeCA9IDU7CisKKyAgKyt4OyAvKiBOZXh0IHdp dGhvdXQgZHByaW50Zi4gKi8KKyAgKyt4OyAvKiBTZXQgZHByaW50ZiBoZXJl LiAqLworICByZXR1cm4geCAtIDc7Cit9Ci0tLSAvZGV2L251bGwKKysrIGIv Z2RiL3Rlc3RzdWl0ZS9nZGIuYmFzZS9kcHJpbnRmLW5leHQuZXhwCkBAIC0w LDAgKzEsMzYgQEAKKyMgQ29weXJpZ2h0IDIwMTMgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uLCBJbmMuCisjIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3 YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cisj IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGlj IExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5CisjIHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2Us IG9yCisjIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisj CisjIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorIyBidXQgV0lUSE9VVCBBTlkgV0FS UkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgor IyBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlCisjIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlIGZvciBtb3JlIGRldGFpbHMuCisjCisjIFlvdSBzaG91bGQgaGF2ZSBy ZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNl bnNlCisjIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUg PGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgorCitzdGFuZGFyZF90 ZXN0ZmlsZQorCitzZXQgZXhlY3V0YWJsZSAkdGVzdGZpbGUKK3NldCBleHBm aWxlICR0ZXN0ZmlsZS5leHAKKworc2V0IGRwX2xvY2F0aW9uIFtnZGJfZ2V0 X2xpbmVfbnVtYmVyICJTZXQgZHByaW50ZiBoZXJlIl0KKworaWYgW3ByZXBh cmVfZm9yX3Rlc3RpbmcgImZhaWxlZCB0byBwcmVwYXJlIGZvciBkcHJpbnRm IHdpdGggbmV4dCIgXAorICAgICR7dGVzdGZpbGV9ICR7c3JjZmlsZX0ge2Rl YnVnfV0geworICAgIHJldHVybiAtMQorfQorCitpZiAhW3J1bnRvX21haW5d IHsKKyAgICBmYWlsICJDYW4ndCBydW4gdG8gbWFpbiIKKyAgICByZXR1cm4g LTEKK30KKworZ2RiX3Rlc3QgImRwcmludGYgJGRwX2xvY2F0aW9uLCBcIiVk XFxuXCIsIHgiIFwKKyAgICAiRHByaW50ZiAuKiIKKworZ2RiX3Rlc3QgIm5l eHQiICJcXCtcXCt4XDsuKlwvXCogTmV4dCB3aXRob3V0IGRwcmludGYuKiIg Im5leHQgMSIKK2dkYl90ZXN0ICJuZXh0IiAiXFwrXFwreFw7LipcL1wqIFNl dCBkcHJpbnRmIGhlcmUuKiIgIm5leHQgMiIKLS0tIC9kZXYvbnVsbAorKysg Yi9nZGIvdGVzdHN1aXRlL2dkYi5iYXNlL2RwcmludGYtbm9uLXN0b3AuYwpA QCAtMCwwICsxLDMwIEBACisvKiBUaGlzIHRlc3RjYXNlIGlzIHBhcnQgb2Yg R0RCLCB0aGUgR05VIGRlYnVnZ2VyLgorCisgICBDb3B5cmlnaHQgKEMpIDIw MTMgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuCisgICBDb250cmli dXRlZCBieSBIdWkgWmh1ICA8aHVpQGNvZGVzb3VyY2VyeS5jb20+CisKKyAg IFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgICBpdCB1bmRlciB0aGUgdGVy bXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxp c2hlZCBieQorICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0 aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IKKyAgIChhdCB5b3Vy IG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisKKyAgIFRoaXMgcHJvZ3Jh bSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUg dXNlZnVsLAorICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAgIE1FUkNIQU5UQUJJ TElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNl ZSB0aGUKKyAgIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCisKKyAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgICBhbG9u ZyB3aXRoIHRoaXMgcHJvZ3JhbS4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3 LmdudS5vcmcvbGljZW5zZXMvPi4gICovCisKK3ZvaWQKK2ZvbyAoKQorewor fQorCitpbnQKK21haW4gKCkKK3sKKyAgZm9vICgpOworICBzbGVlcCAoMyk7 CisgIHJldHVybiAwOworfQotLS0gL2Rldi9udWxsCisrKyBiL2dkYi90ZXN0 c3VpdGUvZ2RiLmJhc2UvZHByaW50Zi1ub24tc3RvcC5leHAKQEAgLTAsMCAr MSw0OCBAQAorIyAgIENvcHlyaWdodCAoQykgMjAxMyBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIEluYy4KKyMgICBDb250cmlidXRlZCBieSBIdWkgWmh1 ICA8aHVpQGNvZGVzb3VyY2VyeS5jb20+CisKKyMgVGhpcyBwcm9ncmFtIGlz IGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9v ciBtb2RpZnkKKyMgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyMgdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMyBvZiB0 aGUgTGljZW5zZSwgb3IKKyMgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIg dmVyc2lvbi4KKyMKKyMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGlu IHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisjIGJ1dCBXSVRI T1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisjIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyMgR05VIEdlbmVyYWwg UHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyMKKyMgWW91IHNo b3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwg UHVibGljIExpY2Vuc2UKKyMgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJ ZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uCisK K3N0YW5kYXJkX3Rlc3RmaWxlCisKK2lmIFtwcmVwYXJlX2Zvcl90ZXN0aW5n ICJmYWlsZWQgdG8gcHJlcGFyZSBmb3IgZHByaW50ZiB3aXRoIG5vbi1zdG9w IiBcCisgICAgJHt0ZXN0ZmlsZX0gJHtzcmNmaWxlfSB7ZGVidWd9XSB7Cisg ICAgcmV0dXJuIC0xCit9CisKK2dkYl90ZXN0X25vX291dHB1dCAic2V0IHRh cmdldC1hc3luYyBvbiIKK2dkYl90ZXN0X25vX291dHB1dCAic2V0IG5vbi1z dG9wIG9uIgorCitpZiAhW3J1bnRvIG1haW5dIHsKKyAgICBmYWlsICJDYW4n dCBydW4gdG8gbWFpbiIKKyAgICByZXR1cm4gLTEKK30KKworZ2RiX3Rlc3Qg ImRwcmludGYgZm9vLFwiQXQgZm9vIGVudHJ5XFxuXCIiICJEcHJpbnRmIC4q IgorCitzZW5kX2dkYiAiY29udGludWUgJlxuIgorZXhlYyBzbGVlcCAxCitz ZXQgdGVzdCAiaW50ZXJydXB0IgorZ2RiX3Rlc3RfbXVsdGlwbGUgJHRlc3Qg JHRlc3QgeworICAgIC1yZSAiaW50ZXJydXB0XHJcbiRnZGJfcHJvbXB0ICIg eworCXBhc3MgJHRlc3QKKyAgICB9Cit9CisKK3NldCB0ZXN0ICJpbmZlcmlv ciBzdG9wcGVkIgorZ2RiX3Rlc3RfbXVsdGlwbGUgIiIgJHRlc3QgeworICAg IC1yZSAiXHJcblxcXFsuKiBcWzAtOVxdK1xcXF0gIzEgc3RvcHBlZFxcXC5c clxuIiB7CisJcGFzcyAkdGVzdAorICAgIH0KK30KLS0tIGEvZ2RiL3Rlc3Rz dWl0ZS9nZGIuYmFzZS9kcHJpbnRmLmV4cAorKysgYi9nZGIvdGVzdHN1aXRl L2dkYi5iYXNlL2RwcmludGYuZXhwCkBAIC01MCwxMCArNTAsOCBAQCBnZGJf dGVzdF9zZXF1ZW5jZSAiaW5mbyBicmVha3BvaW50cyIgImRwCiAgICAgIlxb XHJcblxdMiAgICAgICBicmVha3BvaW50IgogICAgICJcW1xyXG5cXTMgICAg ICAgZHByaW50ZiIKICAgICAiXFtcclxuXF0gICAgICAgIHByaW50ZiBcIkF0 IGZvbyBlbnRyeVxcXFxuXCIiCi0gICAgIlxbXHJcblxdICAgICAgICBjb250 aW51ZSIKICAgICAiXFtcclxuXF00ICAgICAgIGRwcmludGYiCiAgICAgIlxb XHJcblxdICAgICAgICBwcmludGYgXCJhcmc9JWQsIGc9JWRcXFxcblwiLCBh cmcsIGciCi0gICAgIlxbXHJcblxdICAgICAgICBjb250aW51ZSIKIH0KIAog Z2RiX3Rlc3QgImJyZWFrICRicF9sb2NhdGlvbjEiIFwKQEAgLTEzNSw0ICsx MzMsMyBAQCBpZiAkdGFyZ2V0X2Nhbl9kcHJpbnRmIHsKIAogZ2RiX3Rlc3Qg InNldCBkcHJpbnRmLXN0eWxlIGZvb2JhciIgIlVuZGVmaW5lZCBpdGVtOiBc ImZvb2JhclwiLiIgXAogICAgICJTZXQgZHByaW50ZiBzdHlsZSB0byBhbiB1 bnJlY29nbml6ZWQgdHlwZSIKLQotLS0gYS9nZGIvdGVzdHN1aXRlL2dkYi5t aS9taS1icmVha3BvaW50LWNoYW5nZWQuZXhwCisrKyBiL2dkYi90ZXN0c3Vp dGUvZ2RiLm1pL21pLWJyZWFrcG9pbnQtY2hhbmdlZC5leHAKQEAgLTk2LDcg Kzk2LDcgQEAgcHJvYyB0ZXN0X2luc2VydF9kZWxldGVfbW9kaWZ5IHsgfSB7 CiAJJHRlc3QKICAgICBzZXQgdGVzdCAiZHByaW50ZiBtYXJrZXIsIFwiYXJn XCIgXCIiCiAgICAgbWlfZ2RiX3Rlc3QgJHRlc3QgXAotCXsuKj1icmVha3Bv aW50LWNyZWF0ZWQsYmtwdD1ce251bWJlcj0iNiIsdHlwZT0iZHByaW50ZiIu KixzY3JpcHQ9XHtcInByaW50ZiBcXFxcXCJhcmdcXFxcXCIgXFxcXFwiXCIs XCJjb250aW51ZVwiXH0uKlx9XHJcblxeZG9uZX0gXAorCXsuKj1icmVha3Bv aW50LWNyZWF0ZWQsYmtwdD1ce251bWJlcj0iNiIsdHlwZT0iZHByaW50ZiIu KixzY3JpcHQ9XHtcInByaW50ZiBcXFxcXCJhcmdcXFxcXCIgXFxcXFwiXCJc fS4qXH1cclxuXF5kb25lfSBcCiAJJHRlc3QKIAogICAgICMgMi4gd2hlbiBt b2RpZnlpbmcgY29uZGl0aW9uCg== --001a11c3183843ffc804ddbbfa85--