From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 11989 invoked by alias); 11 Jul 2009 12:09:42 -0000 Received: (qmail 11964 invoked by uid 22791); 11 Jul 2009 12:09:38 -0000 X-SWARE-Spam-Status: No, hits=-1.4 required=5.0 tests=AWL,BAYES_00,J_CHICKENPOX_37,SARE_MSGID_LONG40,SPF_PASS X-Spam-Check-By: sourceware.org Received: from mail-pz0-f203.google.com (HELO mail-pz0-f203.google.com) (209.85.222.203) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sat, 11 Jul 2009 12:09:27 +0000 Received: by pzk41 with SMTP id 41so1030054pzk.12 for ; Sat, 11 Jul 2009 05:09:25 -0700 (PDT) MIME-Version: 1.0 Received: by 10.142.13.13 with SMTP id 13mr825433wfm.23.1247314165813; Sat, 11 Jul 2009 05:09:25 -0700 (PDT) In-Reply-To: <8363dzy38t.fsf@gnu.org> References: <8363dzy38t.fsf@gnu.org> Date: Sat, 11 Jul 2009 14:15:00 -0000 Message-ID: Subject: Re: Add a new modifier /c to "disassemble" command to make it output binary code From: Hui Zhu To: Eli Zaretskii Cc: tromey@redhat.com, msnyder@vmware.com, dje@google.com, mark.kettenis@xs4all.nl, gdb-patches@sourceware.org Content-Type: multipart/mixed; boundary=000e0cd5097ac6d203046e6cf54c X-IsSubscribed: yes 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 X-SW-Source: 2009-07/txt/msg00332.txt.bz2 --000e0cd5097ac6d203046e6cf54c Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Content-length: 14175 On Sat, Jul 11, 2009 at 17:32, Eli Zaretskii wrote: >> Date: Sat, 11 Jul 2009 16:46:28 +0800 >> From: Hui Zhu >> Cc: gdb-patches ml >> >> @@ -1454,6 +1458,7 @@ With two args if one is empty it stands >> =A0Disassemble a specified section of memory.\n\ >> =A0Default is the function surrounding the pc of the selected frame.\n\ >> =A0With a /m modifier, source lines are included (if available).\n\ >> +With a /r modifier, instruction in hex are included.\n\ > > =A0With a /r modifier, raw instructions in hex are included. > > (Use "raw" explicitly to help people remember why there's an `r' in > "/r".) > >> +++ b/doc/gdb.texinfo >> @@ -6178,9 +6178,11 @@ Variables}). >> =A0@cindex listing machine instructions >> =A0@item disassemble >> =A0@itemx disassemble /m >> +@itemx disassemble /r >> =A0This specialized command dumps a range of memory as machine >> =A0instructions. =A0It can also print mixed source+disassembly by specif= ying >> -the @code{/m} modifier. >> +the @code{/m} modifier and print the instruction in hex as well as in >> +symbolic form by specifying the @code{/r}. > > =A0and print the raw instructions in hex as well as in symbolic form > > Again, please use the word "raw" in the text. > > Also, what about NEWS? didn't we agree that an entry there would be a > Good Thing? > I have add "raw" and "NEWS". Please help me review it. Thanks, Hui 2009-07-11 Hui Zhu * cli/cli-cmds.c (disassemble_command): Add a new modifier /r to "disassemble" command to print the raw instruction in hex as well as in symbolic form. (init_cli_cmds): Ditto. (print_disassembly): Change "mixed" to "flags" to translate the behavior of disassemble. (disassemble_current_function): Ditto. * mi/mi-cmd-disas.c (mi_cmd_disassemble): Ditto. * stack.c (gdb_disassembly_stub): Ditto. * disasm.c (do_mixed_source_and_assembly): Ditto. (do_mixed_source_and_assembly): Ditto. (do_assembly_only): Ditto. (gdb_disassembly): Ditto. (dump_insns): print the raw instruction in hex as well as in symbolic form if DISASSEMBLY_RAW_INSN and flags is true. * disasm.h (DISASSEMBLY_SOURCE): Include source code with the assembly if it and flags is true. (DISASSEMBLY_RAW_INSN): Include the raw instruction in hex with the assembly if it and flags is true. (gdb_disassembly): Update extern. * NEWS: Document disassemble/r support. --- NEWS | 3 +++ cli/cli-cmds.c | 31 ++++++++++++++++++------------- disasm.c | 39 ++++++++++++++++++++++++++++----------- disasm.h | 3 +++ mi/mi-cmd-disas.c | 2 +- stack.c | 4 +++- 6 files changed, 56 insertions(+), 26 deletions(-) --- a/NEWS +++ b/NEWS @@ -3,6 +3,9 @@ *** Changes since GDB 6.8 +* "disassemble" command with a /r modifier, print the raw instruction +in hex as well as in symbolic form." + * Process record and replay In a architecture environment that supports ``process record and --- a/cli/cli-cmds.c +++ b/cli/cli-cmds.c @@ -908,7 +908,7 @@ list_command (char *arg, int from_tty) static void print_disassembly (struct gdbarch *gdbarch, const char *name, - CORE_ADDR low, CORE_ADDR high, int mixed) + CORE_ADDR low, CORE_ADDR high, int flags) { #if defined(TUI) if (!tui_is_window_visible (DISASSEM_WIN)) @@ -922,7 +922,7 @@ print_disassembly (struct gdbarch *gdbar paddress (gdbarch, low), paddress (gdbarch, high)); /* Dump the specified range. */ - gdb_disassembly (gdbarch, uiout, 0, mixed, -1, low, high); + gdb_disassembly (gdbarch, uiout, 0, flags, -1, low, high); printf_filtered ("End of assembler dump.\n"); gdb_flush (gdb_stdout); @@ -940,7 +940,7 @@ print_disassembly (struct gdbarch *gdbar MIXED is non-zero to print source with the assembler. */ static void -disassemble_current_function (int mixed) +disassemble_current_function (int flags) { struct frame_info *frame; struct gdbarch *gdbarch; @@ -961,20 +961,21 @@ disassemble_current_function (int mixed) #endif low +=3D gdbarch_deprecated_function_start_offset (gdbarch); - print_disassembly (gdbarch, name, low, high, mixed); + print_disassembly (gdbarch, name, low, high, flags); } /* Dump a specified section of assembly code. Usage: - disassemble [/m] + disassemble [/mr] - dump the assembly code for the function of the current pc - disassemble [/m] addr + disassemble [/mr] addr - dump the assembly code for the function at ADDR - disassemble [/m] low high + disassemble [/mr] low high - dump the assembly code in the range [LOW,HIGH) - A /m modifier will include source code with the assembly. */ + A /m modifier will include source code with the assembly. + A /r modifier will include raw instruction in hex with the assembly. */ static void disassemble_command (char *arg, int from_tty) @@ -984,10 +985,10 @@ disassemble_command (char *arg, int from char *name; CORE_ADDR pc, pc_masked; char *space_index; - int mixed_source_and_assembly; + int flags; name =3D NULL; - mixed_source_and_assembly =3D 0; + flags =3D 0; if (arg && *arg =3D=3D '/') { @@ -1001,7 +1002,10 @@ disassemble_command (char *arg, int from switch (*arg++) { case 'm': - mixed_source_and_assembly =3D 1; + flags |=3D DISASSEMBLY_SOURCE; + break; + case 'r': + flags |=3D DISASSEMBLY_RAW_INSN; break; default: error (_("Invalid disassembly modifier.")); @@ -1014,7 +1018,7 @@ disassemble_command (char *arg, int from if (! arg || ! *arg) { - disassemble_current_function (mixed_source_and_assembly); + disassemble_current_function (flags); return; } @@ -1044,7 +1048,7 @@ disassemble_command (char *arg, int from high =3D parse_and_eval_address (space_index + 1); } - print_disassembly (gdbarch, name, low, high, mixed_source_and_assembly); + print_disassembly (gdbarch, name, low, high, flags); } static void @@ -1454,6 +1458,7 @@ With two args if one is empty it stands Disassemble a specified section of memory.\n\ Default is the function surrounding the pc of the selected frame.\n\ With a /m modifier, source lines are included (if available).\n\ +With a /r modifier, raw instruction in hex are included.\n\ With a single argument, the function surrounding that address is dumped.\n\ Two arguments are taken as a range of memory to dump.")); set_cmd_completer (c, location_completer); --- a/disasm.c +++ b/disasm.c @@ -88,7 +88,7 @@ static int dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout, struct disassemble_info * di, CORE_ADDR low, CORE_ADDR high, - int how_many, struct ui_stream *stb) + int how_many, int flags, struct ui_stream *stb) { int num_displayed =3D 0; CORE_ADDR pc; @@ -135,7 +135,23 @@ dump_insns (struct gdbarch *gdbarch, str xfree (name); ui_file_rewind (stb->stream); - pc +=3D gdbarch_print_insn (gdbarch, pc, di); + if (flags & DISASSEMBLY_RAW_INSN) + { + CORE_ADDR old_pc =3D pc; + bfd_byte data; + int status; + pc +=3D gdbarch_print_insn (gdbarch, pc, di); + for (;old_pc < pc; old_pc++) + { + status =3D (*di->read_memory_func) (old_pc, &data, 1, di); + if (status !=3D 0) + (*di->memory_error_func) (status, old_pc, di); + ui_out_message (uiout, 0, " %02x", (unsigned)data); + } + ui_out_text (uiout, "\t"); + } + else + pc +=3D gdbarch_print_insn (gdbarch, pc, di); ui_out_field_stream (uiout, "inst", stb); ui_file_rewind (stb->stream); do_cleanups (ui_out_chain); @@ -154,7 +170,7 @@ do_mixed_source_and_assembly (struct gdb struct linetable_entry *le, CORE_ADDR low, CORE_ADDR high, struct symtab *symtab, - int how_many, struct ui_stream *stb) + int how_many, int flags, struct ui_stream *stb) { int newlines =3D 0; struct dis_line_entry *mle; @@ -278,7 +294,7 @@ do_mixed_source_and_assembly (struct gdb num_displayed +=3D dump_insns (gdbarch, uiout, di, mle[i].start_pc, mle[i].end_pc, - how_many, stb); + how_many, flags, stb); /* When we've reached the end of the mle array, or we've seen the la= st assembly range for this source line, close out the list/tuple. */ @@ -301,14 +317,15 @@ static void do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout, struct disassemble_info * di, CORE_ADDR low, CORE_ADDR high, - int how_many, struct ui_stream *stb) + int how_many, int flags, struct ui_stream *stb) { int num_displayed =3D 0; struct cleanup *ui_out_chain; ui_out_chain =3D make_cleanup_ui_out_list_begin_end (uiout, "asm_insns"); - num_displayed =3D dump_insns (gdbarch, uiout, di, low, high, how_many, s= tb); + num_displayed =3D dump_insns (gdbarch, uiout, di, low, high, how_many, + flags, stb); do_cleanups (ui_out_chain); } @@ -356,7 +373,7 @@ gdb_disassemble_info (struct gdbarch *gd void gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout, char *file_string, - int mixed_source_and_assembly, + int flags, int how_many, CORE_ADDR low, CORE_ADDR high) { struct ui_stream *stb =3D ui_out_stream_new (uiout); @@ -377,13 +394,13 @@ gdb_disassembly (struct gdbarch *gdbarch nlines =3D symtab->linetable->nitems; } - if (!mixed_source_and_assembly || nlines <=3D 0 + if (!(flags & DISASSEMBLY_SOURCE) || nlines <=3D 0 || symtab =3D=3D NULL || symtab->linetable =3D=3D NULL) - do_assembly_only (gdbarch, uiout, &di, low, high, how_many, stb); + do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb= ); - else if (mixed_source_and_assembly) + else if (flags & DISASSEMBLY_SOURCE) do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low, - high, symtab, how_many, stb); + high, symtab, how_many, flags, stb); do_cleanups (cleanups); gdb_flush (gdb_stdout); --- a/disasm.h +++ b/disasm.h @@ -19,6 +19,9 @@ #ifndef DISASM_H #define DISASM_H +#define DISASSEMBLY_SOURCE (0x1 << 0) +#define DISASSEMBLY_RAW_INSN (0x1 << 1) + struct ui_out; struct ui_file; --- a/mi/mi-cmd-disas.c +++ b/mi/mi-cmd-disas.c @@ -156,6 +156,6 @@ mi_cmd_disassemble (char *command, char gdb_disassembly (gdbarch, uiout, file_string, - mixed_source_and_assembly, how_many, low, high); + DISASSEMBLY_SOURCE, how_many, low, high); } --- a/stack.c +++ b/stack.c @@ -481,7 +481,9 @@ static void gdb_disassembly_stub (void *args) { struct gdb_disassembly_stub_args *p =3D args; - gdb_disassembly (p->gdbarch, uiout, 0, 0, p->how_many, p->low, p->high); + gdb_disassembly (p->gdbarch, uiout, 0, + DISASSEMBLY_SOURCE | DISASSEMBLY_RAW_INSN, p->how_many, + p->low, p->high); } /* Use TRY_CATCH to catch the exception from the gdb_disassembly 2009-07-11 Hui Zhu * gdb.texinfo (disassemble): Add a new modifier /r to "disassemble" command to make it print the raw instruction in hex as well as in symbolic form. --- doc/gdb.texinfo | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) --- a/doc/gdb.texinfo +++ b/doc/gdb.texinfo @@ -6178,9 +6178,11 @@ Variables}). @cindex listing machine instructions @item disassemble @itemx disassemble /m +@itemx disassemble /r This specialized command dumps a range of memory as machine instructions. It can also print mixed source+disassembly by specifying -the @code{/m} modifier. +the @code{/m} modifier and print the raw instruction in hex as well as +in symbolic form by specifying the @code{/r}. The default memory range is the function surrounding the program counter of the selected frame. A single argument to this command is a program counter value; @value{GDBN} dumps the function 2009-07-11 Hui Zhu * gdb.base/help.exp (disassemble): Update expected help text. --- testsuite/gdb.base/help.exp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) --- a/testsuite/gdb.base/help.exp +++ b/testsuite/gdb.base/help.exp @@ -124,7 +124,7 @@ gdb_test "help disable breakpoints" "Dis # test help disable display gdb_test "help disable display" "Disable some expressions to be displayed when program stops\.\[\r\n\]+Arguments are the code numbers of the expressions to stop displaying\.\[\r\n\]+No argument means disable all automatic-display expressions\.\[\r\n\]+Do \"info display\" to see current list of code numbers\." "help disable display" # test help disassemble -gdb_test "help disassemble" "Disassemble a specified section of memory\.\[\r\n\]+Default is the function surrounding the pc of the selected frame\.\[\r\n\]+With a /m modifier, source lines are included \\(if available\\)\.\[\r\n\]+With a single argument, the function surrounding that address is dumped\.\[\r\n\]+Two arguments are taken as a range of memory to dump\." "help disassemble" +gdb_test "help disassemble" "Disassemble a specified section of memory\.\[\r\n\]+Default is the function surrounding the pc of the selected frame\.\[\r\n\]+With a /m modifier, source lines are included \\(if available\\)\.\[\r\n\]+With a /r modifier, raw instruction in hex are included\.\[\r\n\]+With a single argument, the function surrounding that address is dumped\.\[\r\n\]+Two arguments are taken as a range of memory to dump\." "help disassemble" # test help display gdb_test "help display" "Print value of expression EXP each time the program stops\.\[\r\n\]+/FMT may be used before EXP as in the \"print\" command\.\[\r\n\]+/FMT \"i\" or \"s\" or including a size-letter is allowed,\[\r\n\]+as in the \"x\" command, and then EXP is used to get the address to examine\[\r\n\]+and examining is done as in the \"x\" command\.\[\r\n\]+With no argument, display all currently requested auto-display expressions\.\[\r\n\]+Use \"undisplay\" to cancel display requests previously made\." "help display" # test help do --000e0cd5097ac6d203046e6cf54c Content-Type: text/plain; charset=US-ASCII; name="disassemble-output-code.txt" Content-Disposition: attachment; filename="disassemble-output-code.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_fx0amvrm0 Content-length: 11721 LS0tCiBORVdTICAgICAgICAgICAgICB8ICAgIDMgKysrCiBjbGkvY2xpLWNt ZHMuYyAgICB8ICAgMzEgKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0t LQogZGlzYXNtLmMgICAgICAgICAgfCAgIDM5ICsrKysrKysrKysrKysrKysr KysrKysrKysrKystLS0tLS0tLS0tLQogZGlzYXNtLmggICAgICAgICAgfCAg ICAzICsrKwogbWkvbWktY21kLWRpc2FzLmMgfCAgICAyICstCiBzdGFjay5j ICAgICAgICAgICB8ICAgIDQgKysrLQogNiBmaWxlcyBjaGFuZ2VkLCA1NiBp bnNlcnRpb25zKCspLCAyNiBkZWxldGlvbnMoLSkKCi0tLSBhL05FV1MKKysr IGIvTkVXUwpAQCAtMyw2ICszLDkgQEAKIAogKioqIENoYW5nZXMgc2luY2Ug R0RCIDYuOAogCisqICJkaXNhc3NlbWJsZSIgY29tbWFuZCB3aXRoIGEgL3Ig bW9kaWZpZXIsIHByaW50IHRoZSByYXcgaW5zdHJ1Y3Rpb24KK2luIGhleCBh cyB3ZWxsIGFzIGluIHN5bWJvbGljIGZvcm0uIgorCiAqIFByb2Nlc3MgcmVj b3JkIGFuZCByZXBsYXkKIAogICBJbiBhIGFyY2hpdGVjdHVyZSBlbnZpcm9u bWVudCB0aGF0IHN1cHBvcnRzIGBgcHJvY2VzcyByZWNvcmQgYW5kCi0tLSBh L2NsaS9jbGktY21kcy5jCisrKyBiL2NsaS9jbGktY21kcy5jCkBAIC05MDgs NyArOTA4LDcgQEAgbGlzdF9jb21tYW5kIChjaGFyICphcmcsIGludCBmcm9t X3R0eSkKIAogc3RhdGljIHZvaWQKIHByaW50X2Rpc2Fzc2VtYmx5IChzdHJ1 Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgY29uc3QgY2hhciAqbmFtZSwKLQkJICAg Q09SRV9BRERSIGxvdywgQ09SRV9BRERSIGhpZ2gsIGludCBtaXhlZCkKKwkJ ICAgQ09SRV9BRERSIGxvdywgQ09SRV9BRERSIGhpZ2gsIGludCBmbGFncykK IHsKICNpZiBkZWZpbmVkKFRVSSkKICAgaWYgKCF0dWlfaXNfd2luZG93X3Zp c2libGUgKERJU0FTU0VNX1dJTikpCkBAIC05MjIsNyArOTIyLDcgQEAgcHJp bnRfZGlzYXNzZW1ibHkgKHN0cnVjdCBnZGJhcmNoICpnZGJhcgogCQkJIHBh ZGRyZXNzIChnZGJhcmNoLCBsb3cpLCBwYWRkcmVzcyAoZ2RiYXJjaCwgaGln aCkpOwogCiAgICAgICAvKiBEdW1wIHRoZSBzcGVjaWZpZWQgcmFuZ2UuICAq LwotICAgICAgZ2RiX2Rpc2Fzc2VtYmx5IChnZGJhcmNoLCB1aW91dCwgMCwg bWl4ZWQsIC0xLCBsb3csIGhpZ2gpOworICAgICAgZ2RiX2Rpc2Fzc2VtYmx5 IChnZGJhcmNoLCB1aW91dCwgMCwgZmxhZ3MsIC0xLCBsb3csIGhpZ2gpOwog CiAgICAgICBwcmludGZfZmlsdGVyZWQgKCJFbmQgb2YgYXNzZW1ibGVyIGR1 bXAuXG4iKTsKICAgICAgIGdkYl9mbHVzaCAoZ2RiX3N0ZG91dCk7CkBAIC05 NDAsNyArOTQwLDcgQEAgcHJpbnRfZGlzYXNzZW1ibHkgKHN0cnVjdCBnZGJh cmNoICpnZGJhcgogICAgTUlYRUQgaXMgbm9uLXplcm8gdG8gcHJpbnQgc291 cmNlIHdpdGggdGhlIGFzc2VtYmxlci4gICovCiAKIHN0YXRpYyB2b2lkCi1k aXNhc3NlbWJsZV9jdXJyZW50X2Z1bmN0aW9uIChpbnQgbWl4ZWQpCitkaXNh c3NlbWJsZV9jdXJyZW50X2Z1bmN0aW9uIChpbnQgZmxhZ3MpCiB7CiAgIHN0 cnVjdCBmcmFtZV9pbmZvICpmcmFtZTsKICAgc3RydWN0IGdkYmFyY2ggKmdk YmFyY2g7CkBAIC05NjEsMjAgKzk2MSwyMSBAQCBkaXNhc3NlbWJsZV9jdXJy ZW50X2Z1bmN0aW9uIChpbnQgbWl4ZWQpCiAjZW5kaWYKICAgbG93ICs9IGdk YmFyY2hfZGVwcmVjYXRlZF9mdW5jdGlvbl9zdGFydF9vZmZzZXQgKGdkYmFy Y2gpOwogCi0gIHByaW50X2Rpc2Fzc2VtYmx5IChnZGJhcmNoLCBuYW1lLCBs b3csIGhpZ2gsIG1peGVkKTsKKyAgcHJpbnRfZGlzYXNzZW1ibHkgKGdkYmFy Y2gsIG5hbWUsIGxvdywgaGlnaCwgZmxhZ3MpOwogfQogCiAvKiBEdW1wIGEg c3BlY2lmaWVkIHNlY3Rpb24gb2YgYXNzZW1ibHkgY29kZS4KIAogICAgVXNh Z2U6Ci0gICAgIGRpc2Fzc2VtYmxlIFsvbV0KKyAgICAgZGlzYXNzZW1ibGUg Wy9tcl0KICAgICAgICAtIGR1bXAgdGhlIGFzc2VtYmx5IGNvZGUgZm9yIHRo ZSBmdW5jdGlvbiBvZiB0aGUgY3VycmVudCBwYwotICAgICBkaXNhc3NlbWJs ZSBbL21dIGFkZHIKKyAgICAgZGlzYXNzZW1ibGUgWy9tcl0gYWRkcgogICAg ICAgIC0gZHVtcCB0aGUgYXNzZW1ibHkgY29kZSBmb3IgdGhlIGZ1bmN0aW9u IGF0IEFERFIKLSAgICAgZGlzYXNzZW1ibGUgWy9tXSBsb3cgaGlnaAorICAg ICBkaXNhc3NlbWJsZSBbL21yXSBsb3cgaGlnaAogICAgICAgIC0gZHVtcCB0 aGUgYXNzZW1ibHkgY29kZSBpbiB0aGUgcmFuZ2UgW0xPVyxISUdIKQogCi0g ICBBIC9tIG1vZGlmaWVyIHdpbGwgaW5jbHVkZSBzb3VyY2UgY29kZSB3aXRo IHRoZSBhc3NlbWJseS4gICovCisgICBBIC9tIG1vZGlmaWVyIHdpbGwgaW5j bHVkZSBzb3VyY2UgY29kZSB3aXRoIHRoZSBhc3NlbWJseS4KKyAgIEEgL3Ig bW9kaWZpZXIgd2lsbCBpbmNsdWRlIHJhdyBpbnN0cnVjdGlvbiBpbiBoZXgg d2l0aCB0aGUgYXNzZW1ibHkuICAqLwogCiBzdGF0aWMgdm9pZAogZGlzYXNz ZW1ibGVfY29tbWFuZCAoY2hhciAqYXJnLCBpbnQgZnJvbV90dHkpCkBAIC05 ODQsMTAgKzk4NSwxMCBAQCBkaXNhc3NlbWJsZV9jb21tYW5kIChjaGFyICph cmcsIGludCBmcm9tCiAgIGNoYXIgKm5hbWU7CiAgIENPUkVfQUREUiBwYywg cGNfbWFza2VkOwogICBjaGFyICpzcGFjZV9pbmRleDsKLSAgaW50IG1peGVk X3NvdXJjZV9hbmRfYXNzZW1ibHk7CisgIGludCBmbGFnczsKIAogICBuYW1l ID0gTlVMTDsKLSAgbWl4ZWRfc291cmNlX2FuZF9hc3NlbWJseSA9IDA7Cisg IGZsYWdzID0gMDsKIAogICBpZiAoYXJnICYmICphcmcgPT0gJy8nKQogICAg IHsKQEAgLTEwMDEsNyArMTAwMiwxMCBAQCBkaXNhc3NlbWJsZV9jb21tYW5k IChjaGFyICphcmcsIGludCBmcm9tCiAJICBzd2l0Y2ggKCphcmcrKykKIAkg ICAgewogCSAgICBjYXNlICdtJzoKLQkgICAgICBtaXhlZF9zb3VyY2VfYW5k X2Fzc2VtYmx5ID0gMTsKKwkgICAgICBmbGFncyB8PSBESVNBU1NFTUJMWV9T T1VSQ0U7CisJICAgICAgYnJlYWs7CisJICAgIGNhc2UgJ3InOgorCSAgICAg IGZsYWdzIHw9IERJU0FTU0VNQkxZX1JBV19JTlNOOwogCSAgICAgIGJyZWFr OwogCSAgICBkZWZhdWx0OgogCSAgICAgIGVycm9yIChfKCJJbnZhbGlkIGRp c2Fzc2VtYmx5IG1vZGlmaWVyLiIpKTsKQEAgLTEwMTQsNyArMTAxOCw3IEBA IGRpc2Fzc2VtYmxlX2NvbW1hbmQgKGNoYXIgKmFyZywgaW50IGZyb20KIAog ICBpZiAoISBhcmcgfHwgISAqYXJnKQogICAgIHsKLSAgICAgIGRpc2Fzc2Vt YmxlX2N1cnJlbnRfZnVuY3Rpb24gKG1peGVkX3NvdXJjZV9hbmRfYXNzZW1i bHkpOworICAgICAgZGlzYXNzZW1ibGVfY3VycmVudF9mdW5jdGlvbiAoZmxh Z3MpOwogICAgICAgcmV0dXJuOwogICAgIH0KIApAQCAtMTA0NCw3ICsxMDQ4 LDcgQEAgZGlzYXNzZW1ibGVfY29tbWFuZCAoY2hhciAqYXJnLCBpbnQgZnJv bQogICAgICAgaGlnaCA9IHBhcnNlX2FuZF9ldmFsX2FkZHJlc3MgKHNwYWNl X2luZGV4ICsgMSk7CiAgICAgfQogCi0gIHByaW50X2Rpc2Fzc2VtYmx5IChn ZGJhcmNoLCBuYW1lLCBsb3csIGhpZ2gsIG1peGVkX3NvdXJjZV9hbmRfYXNz ZW1ibHkpOworICBwcmludF9kaXNhc3NlbWJseSAoZ2RiYXJjaCwgbmFtZSwg bG93LCBoaWdoLCBmbGFncyk7CiB9CiAKIHN0YXRpYyB2b2lkCkBAIC0xNDU0 LDYgKzE0NTgsNyBAQCBXaXRoIHR3byBhcmdzIGlmIG9uZSBpcyBlbXB0eSBp dCBzdGFuZHMgCiBEaXNhc3NlbWJsZSBhIHNwZWNpZmllZCBzZWN0aW9uIG9m IG1lbW9yeS5cblwKIERlZmF1bHQgaXMgdGhlIGZ1bmN0aW9uIHN1cnJvdW5k aW5nIHRoZSBwYyBvZiB0aGUgc2VsZWN0ZWQgZnJhbWUuXG5cCiBXaXRoIGEg L20gbW9kaWZpZXIsIHNvdXJjZSBsaW5lcyBhcmUgaW5jbHVkZWQgKGlmIGF2 YWlsYWJsZSkuXG5cCitXaXRoIGEgL3IgbW9kaWZpZXIsIHJhdyBpbnN0cnVj dGlvbiBpbiBoZXggYXJlIGluY2x1ZGVkLlxuXAogV2l0aCBhIHNpbmdsZSBh cmd1bWVudCwgdGhlIGZ1bmN0aW9uIHN1cnJvdW5kaW5nIHRoYXQgYWRkcmVz cyBpcyBkdW1wZWQuXG5cCiBUd28gYXJndW1lbnRzIGFyZSB0YWtlbiBhcyBh IHJhbmdlIG9mIG1lbW9yeSB0byBkdW1wLiIpKTsKICAgc2V0X2NtZF9jb21w bGV0ZXIgKGMsIGxvY2F0aW9uX2NvbXBsZXRlcik7Ci0tLSBhL2Rpc2FzbS5j CisrKyBiL2Rpc2FzbS5jCkBAIC04OCw3ICs4OCw3IEBAIHN0YXRpYyBpbnQK IGR1bXBfaW5zbnMgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBzdHJ1Y3Qg dWlfb3V0ICp1aW91dCwKIAkgICAgc3RydWN0IGRpc2Fzc2VtYmxlX2luZm8g KiBkaSwKIAkgICAgQ09SRV9BRERSIGxvdywgQ09SRV9BRERSIGhpZ2gsCi0J ICAgIGludCBob3dfbWFueSwgc3RydWN0IHVpX3N0cmVhbSAqc3RiKQorCSAg ICBpbnQgaG93X21hbnksIGludCBmbGFncywgc3RydWN0IHVpX3N0cmVhbSAq c3RiKQogewogICBpbnQgbnVtX2Rpc3BsYXllZCA9IDA7CiAgIENPUkVfQURE UiBwYzsKQEAgLTEzNSw3ICsxMzUsMjMgQEAgZHVtcF9pbnNucyAoc3RydWN0 IGdkYmFyY2ggKmdkYmFyY2gsIHN0cgogCXhmcmVlIChuYW1lKTsKIAogICAg ICAgdWlfZmlsZV9yZXdpbmQgKHN0Yi0+c3RyZWFtKTsKLSAgICAgIHBjICs9 IGdkYmFyY2hfcHJpbnRfaW5zbiAoZ2RiYXJjaCwgcGMsIGRpKTsKKyAgICAg IGlmIChmbGFncyAmIERJU0FTU0VNQkxZX1JBV19JTlNOKQorICAgICAgICB7 CisgICAgICAgICAgQ09SRV9BRERSIG9sZF9wYyA9IHBjOworICAgICAgICAg IGJmZF9ieXRlIGRhdGE7CisgICAgICAgICAgaW50IHN0YXR1czsKKyAgICAg ICAgICBwYyArPSBnZGJhcmNoX3ByaW50X2luc24gKGdkYmFyY2gsIHBjLCBk aSk7CisgICAgICAgICAgZm9yICg7b2xkX3BjIDwgcGM7IG9sZF9wYysrKQor ICAgICAgICAgICAgeworICAgICAgICAgICAgICBzdGF0dXMgPSAoKmRpLT5y ZWFkX21lbW9yeV9mdW5jKSAob2xkX3BjLCAmZGF0YSwgMSwgZGkpOworICAg ICAgICAgICAgICBpZiAoc3RhdHVzICE9IDApCisgICAgICAgICAgICAgICAg KCpkaS0+bWVtb3J5X2Vycm9yX2Z1bmMpIChzdGF0dXMsIG9sZF9wYywgZGkp OworICAgICAgICAgICAgICB1aV9vdXRfbWVzc2FnZSAodWlvdXQsIDAsICIg JTAyeCIsICh1bnNpZ25lZClkYXRhKTsKKyAgICAgICAgICAgIH0KKyAgICAg ICAgICB1aV9vdXRfdGV4dCAodWlvdXQsICJcdCIpOworICAgICAgICB9Cisg ICAgICBlbHNlCisgICAgICAgIHBjICs9IGdkYmFyY2hfcHJpbnRfaW5zbiAo Z2RiYXJjaCwgcGMsIGRpKTsKICAgICAgIHVpX291dF9maWVsZF9zdHJlYW0g KHVpb3V0LCAiaW5zdCIsIHN0Yik7CiAgICAgICB1aV9maWxlX3Jld2luZCAo c3RiLT5zdHJlYW0pOwogICAgICAgZG9fY2xlYW51cHMgKHVpX291dF9jaGFp bik7CkBAIC0xNTQsNyArMTcwLDcgQEAgZG9fbWl4ZWRfc291cmNlX2FuZF9h c3NlbWJseSAoc3RydWN0IGdkYgogCQkJICAgICAgc3RydWN0IGxpbmV0YWJs ZV9lbnRyeSAqbGUsCiAJCQkgICAgICBDT1JFX0FERFIgbG93LCBDT1JFX0FE RFIgaGlnaCwKIAkJCSAgICAgIHN0cnVjdCBzeW10YWIgKnN5bXRhYiwKLQkJ CSAgICAgIGludCBob3dfbWFueSwgc3RydWN0IHVpX3N0cmVhbSAqc3RiKQor CQkJICAgICAgaW50IGhvd19tYW55LCBpbnQgZmxhZ3MsIHN0cnVjdCB1aV9z dHJlYW0gKnN0YikKIHsKICAgaW50IG5ld2xpbmVzID0gMDsKICAgc3RydWN0 IGRpc19saW5lX2VudHJ5ICptbGU7CkBAIC0yNzgsNyArMjk0LDcgQEAgZG9f bWl4ZWRfc291cmNlX2FuZF9hc3NlbWJseSAoc3RydWN0IGdkYgogCiAgICAg ICBudW1fZGlzcGxheWVkICs9IGR1bXBfaW5zbnMgKGdkYmFyY2gsIHVpb3V0 LCBkaSwKIAkJCQkgICBtbGVbaV0uc3RhcnRfcGMsIG1sZVtpXS5lbmRfcGMs Ci0JCQkJICAgaG93X21hbnksIHN0Yik7CisJCQkJICAgaG93X21hbnksIGZs YWdzLCBzdGIpOwogCiAgICAgICAvKiBXaGVuIHdlJ3ZlIHJlYWNoZWQgdGhl IGVuZCBvZiB0aGUgbWxlIGFycmF5LCBvciB3ZSd2ZSBzZWVuIHRoZSBsYXN0 CiAgICAgICAgICBhc3NlbWJseSByYW5nZSBmb3IgdGhpcyBzb3VyY2UgbGlu ZSwgY2xvc2Ugb3V0IHRoZSBsaXN0L3R1cGxlLiAgKi8KQEAgLTMwMSwxNCAr MzE3LDE1IEBAIHN0YXRpYyB2b2lkCiBkb19hc3NlbWJseV9vbmx5IChzdHJ1 Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgc3RydWN0IHVpX291dCAqdWlvdXQsCiAJ CSAgc3RydWN0IGRpc2Fzc2VtYmxlX2luZm8gKiBkaSwKIAkJICBDT1JFX0FE RFIgbG93LCBDT1JFX0FERFIgaGlnaCwKLQkJICBpbnQgaG93X21hbnksIHN0 cnVjdCB1aV9zdHJlYW0gKnN0YikKKwkJICBpbnQgaG93X21hbnksIGludCBm bGFncywgc3RydWN0IHVpX3N0cmVhbSAqc3RiKQogewogICBpbnQgbnVtX2Rp c3BsYXllZCA9IDA7CiAgIHN0cnVjdCBjbGVhbnVwICp1aV9vdXRfY2hhaW47 CiAKICAgdWlfb3V0X2NoYWluID0gbWFrZV9jbGVhbnVwX3VpX291dF9saXN0 X2JlZ2luX2VuZCAodWlvdXQsICJhc21faW5zbnMiKTsKIAotICBudW1fZGlz cGxheWVkID0gZHVtcF9pbnNucyAoZ2RiYXJjaCwgdWlvdXQsIGRpLCBsb3cs IGhpZ2gsIGhvd19tYW55LCBzdGIpOworICBudW1fZGlzcGxheWVkID0gZHVt cF9pbnNucyAoZ2RiYXJjaCwgdWlvdXQsIGRpLCBsb3csIGhpZ2gsIGhvd19t YW55LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmxhZ3MsIHN0 Yik7CiAKICAgZG9fY2xlYW51cHMgKHVpX291dF9jaGFpbik7CiB9CkBAIC0z NTYsNyArMzczLDcgQEAgZ2RiX2Rpc2Fzc2VtYmxlX2luZm8gKHN0cnVjdCBn ZGJhcmNoICpnZAogdm9pZAogZ2RiX2Rpc2Fzc2VtYmx5IChzdHJ1Y3QgZ2Ri YXJjaCAqZ2RiYXJjaCwgc3RydWN0IHVpX291dCAqdWlvdXQsCiAJCWNoYXIg KmZpbGVfc3RyaW5nLAotCQlpbnQgbWl4ZWRfc291cmNlX2FuZF9hc3NlbWJs eSwKKwkJaW50IGZsYWdzLAogCQlpbnQgaG93X21hbnksIENPUkVfQUREUiBs b3csIENPUkVfQUREUiBoaWdoKQogewogICBzdHJ1Y3QgdWlfc3RyZWFtICpz dGIgPSB1aV9vdXRfc3RyZWFtX25ldyAodWlvdXQpOwpAQCAtMzc3LDEzICsz OTQsMTMgQEAgZ2RiX2Rpc2Fzc2VtYmx5IChzdHJ1Y3QgZ2RiYXJjaCAqZ2Ri YXJjaAogICAgICAgbmxpbmVzID0gc3ltdGFiLT5saW5ldGFibGUtPm5pdGVt czsKICAgICB9CiAKLSAgaWYgKCFtaXhlZF9zb3VyY2VfYW5kX2Fzc2VtYmx5 IHx8IG5saW5lcyA8PSAwCisgIGlmICghKGZsYWdzICYgRElTQVNTRU1CTFlf U09VUkNFKSB8fCBubGluZXMgPD0gMAogICAgICAgfHwgc3ltdGFiID09IE5V TEwgfHwgc3ltdGFiLT5saW5ldGFibGUgPT0gTlVMTCkKLSAgICBkb19hc3Nl bWJseV9vbmx5IChnZGJhcmNoLCB1aW91dCwgJmRpLCBsb3csIGhpZ2gsIGhv d19tYW55LCBzdGIpOworICAgIGRvX2Fzc2VtYmx5X29ubHkgKGdkYmFyY2gs IHVpb3V0LCAmZGksIGxvdywgaGlnaCwgaG93X21hbnksIGZsYWdzLCBzdGIp OwogCi0gIGVsc2UgaWYgKG1peGVkX3NvdXJjZV9hbmRfYXNzZW1ibHkpCisg IGVsc2UgaWYgKGZsYWdzICYgRElTQVNTRU1CTFlfU09VUkNFKQogICAgIGRv X21peGVkX3NvdXJjZV9hbmRfYXNzZW1ibHkgKGdkYmFyY2gsIHVpb3V0LCAm ZGksIG5saW5lcywgbGUsIGxvdywKLQkJCQkgIGhpZ2gsIHN5bXRhYiwgaG93 X21hbnksIHN0Yik7CisJCQkJICBoaWdoLCBzeW10YWIsIGhvd19tYW55LCBm bGFncywgc3RiKTsKIAogICBkb19jbGVhbnVwcyAoY2xlYW51cHMpOwogICBn ZGJfZmx1c2ggKGdkYl9zdGRvdXQpOwotLS0gYS9kaXNhc20uaAorKysgYi9k aXNhc20uaApAQCAtMTksNiArMTksOSBAQAogI2lmbmRlZiBESVNBU01fSAog I2RlZmluZSBESVNBU01fSAogCisjZGVmaW5lIERJU0FTU0VNQkxZX1NPVVJD RQkoMHgxIDw8IDApCisjZGVmaW5lIERJU0FTU0VNQkxZX1JBV19JTlNOCSgw eDEgPDwgMSkKKwogc3RydWN0IHVpX291dDsKIHN0cnVjdCB1aV9maWxlOwog Ci0tLSBhL21pL21pLWNtZC1kaXNhcy5jCisrKyBiL21pL21pLWNtZC1kaXNh cy5jCkBAIC0xNTYsNiArMTU2LDYgQEAgbWlfY21kX2Rpc2Fzc2VtYmxlIChj aGFyICpjb21tYW5kLCBjaGFyIAogCiAgIGdkYl9kaXNhc3NlbWJseSAoZ2Ri YXJjaCwgdWlvdXQsCiAgIAkJICAgZmlsZV9zdHJpbmcsCi0JCSAgIG1peGVk X3NvdXJjZV9hbmRfYXNzZW1ibHksIGhvd19tYW55LCBsb3csIGhpZ2gpOwor CQkgICBESVNBU1NFTUJMWV9TT1VSQ0UsIGhvd19tYW55LCBsb3csIGhpZ2gp OwogCiB9Ci0tLSBhL3N0YWNrLmMKKysrIGIvc3RhY2suYwpAQCAtNDgxLDcg KzQ4MSw5IEBAIHN0YXRpYyB2b2lkCiBnZGJfZGlzYXNzZW1ibHlfc3R1YiAo dm9pZCAqYXJncykKIHsKICAgc3RydWN0IGdkYl9kaXNhc3NlbWJseV9zdHVi X2FyZ3MgKnAgPSBhcmdzOwotICBnZGJfZGlzYXNzZW1ibHkgKHAtPmdkYmFy Y2gsIHVpb3V0LCAwLCAwLCBwLT5ob3dfbWFueSwgcC0+bG93LCBwLT5oaWdo KTsKKyAgZ2RiX2Rpc2Fzc2VtYmx5IChwLT5nZGJhcmNoLCB1aW91dCwgMCwK KyAgICAgICAgICAgICAgICAgICBESVNBU1NFTUJMWV9TT1VSQ0UgfCBESVNB U1NFTUJMWV9SQVdfSU5TTiwgcC0+aG93X21hbnksCisgICAgICAgICAgICAg ICAgICAgcC0+bG93LCBwLT5oaWdoKTsKIH0KIAogLyogVXNlIFRSWV9DQVRD SCB0byBjYXRjaCB0aGUgZXhjZXB0aW9uIGZyb20gdGhlIGdkYl9kaXNhc3Nl bWJseQo= --000e0cd5097ac6d203046e6cf54c Content-Type: text/plain; charset=US-ASCII; name="disassemble-output-code-doc.txt" Content-Disposition: attachment; filename="disassemble-output-code-doc.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_fx0amzk21 Content-length: 1001 LS0tCiBkb2MvZ2RiLnRleGluZm8gfCAgICA0ICsrKy0KIDEgZmlsZSBjaGFu Z2VkLCAzIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCi0tLSBhL2Rv Yy9nZGIudGV4aW5mbworKysgYi9kb2MvZ2RiLnRleGluZm8KQEAgLTYxNzgs OSArNjE3OCwxMSBAQCBWYXJpYWJsZXN9KS4KIEBjaW5kZXggbGlzdGluZyBt YWNoaW5lIGluc3RydWN0aW9ucwogQGl0ZW0gZGlzYXNzZW1ibGUKIEBpdGVt eCBkaXNhc3NlbWJsZSAvbQorQGl0ZW14IGRpc2Fzc2VtYmxlIC9yCiBUaGlz IHNwZWNpYWxpemVkIGNvbW1hbmQgZHVtcHMgYSByYW5nZSBvZiBtZW1vcnkg YXMgbWFjaGluZQogaW5zdHJ1Y3Rpb25zLiAgSXQgY2FuIGFsc28gcHJpbnQg bWl4ZWQgc291cmNlK2Rpc2Fzc2VtYmx5IGJ5IHNwZWNpZnlpbmcKLXRoZSBA Y29kZXsvbX0gbW9kaWZpZXIuCit0aGUgQGNvZGV7L219IG1vZGlmaWVyIGFu ZCBwcmludCB0aGUgcmF3IGluc3RydWN0aW9uIGluIGhleCBhcyB3ZWxsIGFz CitpbiBzeW1ib2xpYyBmb3JtIGJ5IHNwZWNpZnlpbmcgdGhlIEBjb2Rley9y fS4KIFRoZSBkZWZhdWx0IG1lbW9yeSByYW5nZSBpcyB0aGUgZnVuY3Rpb24g c3Vycm91bmRpbmcgdGhlCiBwcm9ncmFtIGNvdW50ZXIgb2YgdGhlIHNlbGVj dGVkIGZyYW1lLiAgQSBzaW5nbGUgYXJndW1lbnQgdG8gdGhpcwogY29tbWFu ZCBpcyBhIHByb2dyYW0gY291bnRlciB2YWx1ZTsgQHZhbHVle0dEQk59IGR1 bXBzIHRoZSBmdW5jdGlvbgo= --000e0cd5097ac6d203046e6cf54c Content-Type: text/plain; charset=US-ASCII; name="disassemble-output-code-test.txt" Content-Disposition: attachment; filename="disassemble-output-code-test.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_fx0an0ay2 Content-length: 2741 LS0tCiB0ZXN0c3VpdGUvZ2RiLmJhc2UvaGVscC5leHAgfCAgICAyICstCiAx IGZpbGUgY2hhbmdlZCwgMSBpbnNlcnRpb24oKyksIDEgZGVsZXRpb24oLSkK Ci0tLSBhL3Rlc3RzdWl0ZS9nZGIuYmFzZS9oZWxwLmV4cAorKysgYi90ZXN0 c3VpdGUvZ2RiLmJhc2UvaGVscC5leHAKQEAgLTEyNCw3ICsxMjQsNyBAQCBn ZGJfdGVzdCAiaGVscCBkaXNhYmxlIGJyZWFrcG9pbnRzIiAiRGlzCiAjIHRl c3QgaGVscCBkaXNhYmxlIGRpc3BsYXkKIGdkYl90ZXN0ICJoZWxwIGRpc2Fi bGUgZGlzcGxheSIgIkRpc2FibGUgc29tZSBleHByZXNzaW9ucyB0byBiZSBk aXNwbGF5ZWQgd2hlbiBwcm9ncmFtIHN0b3BzXC5cW1xyXG5cXStBcmd1bWVu dHMgYXJlIHRoZSBjb2RlIG51bWJlcnMgb2YgdGhlIGV4cHJlc3Npb25zIHRv IHN0b3AgZGlzcGxheWluZ1wuXFtcclxuXF0rTm8gYXJndW1lbnQgbWVhbnMg ZGlzYWJsZSBhbGwgYXV0b21hdGljLWRpc3BsYXkgZXhwcmVzc2lvbnNcLlxb XHJcblxdK0RvIFwiaW5mbyBkaXNwbGF5XCIgdG8gc2VlIGN1cnJlbnQgbGlz dCBvZiBjb2RlIG51bWJlcnNcLiIgImhlbHAgZGlzYWJsZSBkaXNwbGF5Igog IyB0ZXN0IGhlbHAgZGlzYXNzZW1ibGUKLWdkYl90ZXN0ICJoZWxwIGRpc2Fz c2VtYmxlIiAiRGlzYXNzZW1ibGUgYSBzcGVjaWZpZWQgc2VjdGlvbiBvZiBt ZW1vcnlcLlxbXHJcblxdK0RlZmF1bHQgaXMgdGhlIGZ1bmN0aW9uIHN1cnJv dW5kaW5nIHRoZSBwYyBvZiB0aGUgc2VsZWN0ZWQgZnJhbWVcLlxbXHJcblxd K1dpdGggYSAvbSBtb2RpZmllciwgc291cmNlIGxpbmVzIGFyZSBpbmNsdWRl ZCBcXChpZiBhdmFpbGFibGVcXClcLlxbXHJcblxdK1dpdGggYSBzaW5nbGUg YXJndW1lbnQsIHRoZSBmdW5jdGlvbiBzdXJyb3VuZGluZyB0aGF0IGFkZHJl c3MgaXMgZHVtcGVkXC5cW1xyXG5cXStUd28gYXJndW1lbnRzIGFyZSB0YWtl biBhcyBhIHJhbmdlIG9mIG1lbW9yeSB0byBkdW1wXC4iICJoZWxwIGRpc2Fz c2VtYmxlIgorZ2RiX3Rlc3QgImhlbHAgZGlzYXNzZW1ibGUiICJEaXNhc3Nl bWJsZSBhIHNwZWNpZmllZCBzZWN0aW9uIG9mIG1lbW9yeVwuXFtcclxuXF0r RGVmYXVsdCBpcyB0aGUgZnVuY3Rpb24gc3Vycm91bmRpbmcgdGhlIHBjIG9m IHRoZSBzZWxlY3RlZCBmcmFtZVwuXFtcclxuXF0rV2l0aCBhIC9tIG1vZGlm aWVyLCBzb3VyY2UgbGluZXMgYXJlIGluY2x1ZGVkIFxcKGlmIGF2YWlsYWJs ZVxcKVwuXFtcclxuXF0rV2l0aCBhIC9yIG1vZGlmaWVyLCByYXcgaW5zdHJ1 Y3Rpb24gaW4gaGV4IGFyZSBpbmNsdWRlZFwuXFtcclxuXF0rV2l0aCBhIHNp bmdsZSBhcmd1bWVudCwgdGhlIGZ1bmN0aW9uIHN1cnJvdW5kaW5nIHRoYXQg YWRkcmVzcyBpcyBkdW1wZWRcLlxbXHJcblxdK1R3byBhcmd1bWVudHMgYXJl IHRha2VuIGFzIGEgcmFuZ2Ugb2YgbWVtb3J5IHRvIGR1bXBcLiIgImhlbHAg ZGlzYXNzZW1ibGUiCiAjIHRlc3QgaGVscCBkaXNwbGF5CiBnZGJfdGVzdCAi aGVscCBkaXNwbGF5IiAiUHJpbnQgdmFsdWUgb2YgZXhwcmVzc2lvbiBFWFAg ZWFjaCB0aW1lIHRoZSBwcm9ncmFtIHN0b3BzXC5cW1xyXG5cXSsvRk1UIG1h eSBiZSB1c2VkIGJlZm9yZSBFWFAgYXMgaW4gdGhlIFwicHJpbnRcIiBjb21t YW5kXC5cW1xyXG5cXSsvRk1UIFwiaVwiIG9yIFwic1wiIG9yIGluY2x1ZGlu ZyBhIHNpemUtbGV0dGVyIGlzIGFsbG93ZWQsXFtcclxuXF0rYXMgaW4gdGhl IFwieFwiIGNvbW1hbmQsIGFuZCB0aGVuIEVYUCBpcyB1c2VkIHRvIGdldCB0 aGUgYWRkcmVzcyB0byBleGFtaW5lXFtcclxuXF0rYW5kIGV4YW1pbmluZyBp cyBkb25lIGFzIGluIHRoZSBcInhcIiBjb21tYW5kXC5cW1xyXG5cXStXaXRo IG5vIGFyZ3VtZW50LCBkaXNwbGF5IGFsbCBjdXJyZW50bHkgcmVxdWVzdGVk IGF1dG8tZGlzcGxheSBleHByZXNzaW9uc1wuXFtcclxuXF0rVXNlIFwidW5k aXNwbGF5XCIgdG8gY2FuY2VsIGRpc3BsYXkgcmVxdWVzdHMgcHJldmlvdXNs eSBtYWRlXC4iICJoZWxwIGRpc3BsYXkiCiAjIHRlc3QgaGVscCBkbwo= --000e0cd5097ac6d203046e6cf54c--