From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 4785 invoked by alias); 11 Jul 2009 08:46:44 -0000 Received: (qmail 4774 invoked by uid 22791); 11 Jul 2009 08:46:40 -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 08:46:31 +0000 Received: by pzk41 with SMTP id 41so981851pzk.12 for ; Sat, 11 Jul 2009 01:46:29 -0700 (PDT) MIME-Version: 1.0 Received: by 10.142.13.13 with SMTP id 13mr798432wfm.23.1247301988802; Sat, 11 Jul 2009 01:46:28 -0700 (PDT) In-Reply-To: References: Date: Sat, 11 Jul 2009 09:28:00 -0000 Message-ID: Subject: Re: Add a new modifier /c to "disassemble" command to make it output binary code From: Hui Zhu To: Tom Tromey , Eli Zaretskii , Michael Snyder , Doug Evans , Mark Kettenis Cc: gdb-patches ml Content-Type: multipart/mixed; boundary=000e0cd5097af86116046e6a1f1e 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/msg00328.txt.bz2 --000e0cd5097af86116046e6a1f1e Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit Content-length: 12655 Thanks everybody, 1. I added a argument "flags". It include "DISASSEMBLY_SOURCE" and "DISASSEMBLY_RAW_INSN". 2. I change the introduce to "With a /r modifier, print the instruction in hex as well as in symbolic form." It get from objdump's man. Wish you like it. :) 3. /c changed /r. 4. I have make a patch for testsuite. Please help me review them. Thanks, Hui 2009-07-11 Hui Zhu * cli/cli-cmds.c (disassemble_command): Add a new modifier /r to "disassemble" command to print the 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 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 instruction in hex with the assembly if it and flags is true. (gdb_disassembly): Update extern. --- cli/cli-cmds.c | 31 ++++++++++++++++++------------- disasm.c | 39 ++++++++++++++++++++++++++++----------- disasm.h | 3 +++ mi/mi-cmd-disas.c | 2 +- stack.c | 4 +++- 5 files changed, 53 insertions(+), 26 deletions(-) --- 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 += 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 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 = NULL; - mixed_source_and_assembly = 0; + flags = 0; if (arg && *arg == '/') { @@ -1001,7 +1002,10 @@ disassemble_command (char *arg, int from switch (*arg++) { case 'm': - mixed_source_and_assembly = 1; + flags |= DISASSEMBLY_SOURCE; + break; + case 'r': + flags |= 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 = 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, 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 = 0; CORE_ADDR pc; @@ -135,7 +135,23 @@ dump_insns (struct gdbarch *gdbarch, str xfree (name); ui_file_rewind (stb->stream); - pc += gdbarch_print_insn (gdbarch, pc, di); + if (flags & DISASSEMBLY_RAW_INSN) + { + CORE_ADDR old_pc = pc; + bfd_byte data; + int status; + pc += gdbarch_print_insn (gdbarch, pc, di); + for (;old_pc < pc; old_pc++) + { + status = (*di->read_memory_func) (old_pc, &data, 1, di); + if (status != 0) + (*di->memory_error_func) (status, old_pc, di); + ui_out_message (uiout, 0, " %02x", (unsigned)data); + } + ui_out_text (uiout, "\t"); + } + else + pc += 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 = 0; struct dis_line_entry *mle; @@ -278,7 +294,7 @@ do_mixed_source_and_assembly (struct gdb num_displayed += 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 last 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 = 0; struct cleanup *ui_out_chain; ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns"); - num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many, stb); + num_displayed = 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 = ui_out_stream_new (uiout); @@ -377,13 +394,13 @@ gdb_disassembly (struct gdbarch *gdbarch nlines = symtab->linetable->nitems; } - if (!mixed_source_and_assembly || nlines <= 0 + if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0 || symtab == NULL || symtab->linetable == 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 = 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 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 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, 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 --000e0cd5097af86116046e6a1f1e 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_fx03bso10 Content-length: 11290 LS0tCiBjbGkvY2xpLWNtZHMuYyAgICB8ICAgMzEgKysrKysrKysrKysrKysr KysrLS0tLS0tLS0tLS0tLQogZGlzYXNtLmMgICAgICAgICAgfCAgIDM5ICsr KysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLQogZGlzYXNt LmggICAgICAgICAgfCAgICAzICsrKwogbWkvbWktY21kLWRpc2FzLmMgfCAg ICAyICstCiBzdGFjay5jICAgICAgICAgICB8ICAgIDQgKysrLQogNSBmaWxl cyBjaGFuZ2VkLCA1MyBpbnNlcnRpb25zKCspLCAyNiBkZWxldGlvbnMoLSkK Ci0tLSBhL2NsaS9jbGktY21kcy5jCisrKyBiL2NsaS9jbGktY21kcy5jCkBA IC05MDgsNyArOTA4LDcgQEAgbGlzdF9jb21tYW5kIChjaGFyICphcmcsIGlu dCBmcm9tX3R0eSkKIAogc3RhdGljIHZvaWQKIHByaW50X2Rpc2Fzc2VtYmx5 IChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgY29uc3QgY2hhciAqbmFtZSwK LQkJICAgQ09SRV9BRERSIGxvdywgQ09SRV9BRERSIGhpZ2gsIGludCBtaXhl ZCkKKwkJICAgQ09SRV9BRERSIGxvdywgQ09SRV9BRERSIGhpZ2gsIGludCBm bGFncykKIHsKICNpZiBkZWZpbmVkKFRVSSkKICAgaWYgKCF0dWlfaXNfd2lu ZG93X3Zpc2libGUgKERJU0FTU0VNX1dJTikpCkBAIC05MjIsNyArOTIyLDcg QEAgcHJpbnRfZGlzYXNzZW1ibHkgKHN0cnVjdCBnZGJhcmNoICpnZGJhcgog CQkJIHBhZGRyZXNzIChnZGJhcmNoLCBsb3cpLCBwYWRkcmVzcyAoZ2RiYXJj aCwgaGlnaCkpOwogCiAgICAgICAvKiBEdW1wIHRoZSBzcGVjaWZpZWQgcmFu Z2UuICAqLwotICAgICAgZ2RiX2Rpc2Fzc2VtYmx5IChnZGJhcmNoLCB1aW91 dCwgMCwgbWl4ZWQsIC0xLCBsb3csIGhpZ2gpOworICAgICAgZ2RiX2Rpc2Fz c2VtYmx5IChnZGJhcmNoLCB1aW91dCwgMCwgZmxhZ3MsIC0xLCBsb3csIGhp Z2gpOwogCiAgICAgICBwcmludGZfZmlsdGVyZWQgKCJFbmQgb2YgYXNzZW1i bGVyIGR1bXAuXG4iKTsKICAgICAgIGdkYl9mbHVzaCAoZ2RiX3N0ZG91dCk7 CkBAIC05NDAsNyArOTQwLDcgQEAgcHJpbnRfZGlzYXNzZW1ibHkgKHN0cnVj dCBnZGJhcmNoICpnZGJhcgogICAgTUlYRUQgaXMgbm9uLXplcm8gdG8gcHJp bnQgc291cmNlIHdpdGggdGhlIGFzc2VtYmxlci4gICovCiAKIHN0YXRpYyB2 b2lkCi1kaXNhc3NlbWJsZV9jdXJyZW50X2Z1bmN0aW9uIChpbnQgbWl4ZWQp CitkaXNhc3NlbWJsZV9jdXJyZW50X2Z1bmN0aW9uIChpbnQgZmxhZ3MpCiB7 CiAgIHN0cnVjdCBmcmFtZV9pbmZvICpmcmFtZTsKICAgc3RydWN0IGdkYmFy Y2ggKmdkYmFyY2g7CkBAIC05NjEsMjAgKzk2MSwyMSBAQCBkaXNhc3NlbWJs ZV9jdXJyZW50X2Z1bmN0aW9uIChpbnQgbWl4ZWQpCiAjZW5kaWYKICAgbG93 ICs9IGdkYmFyY2hfZGVwcmVjYXRlZF9mdW5jdGlvbl9zdGFydF9vZmZzZXQg KGdkYmFyY2gpOwogCi0gIHByaW50X2Rpc2Fzc2VtYmx5IChnZGJhcmNoLCBu YW1lLCBsb3csIGhpZ2gsIG1peGVkKTsKKyAgcHJpbnRfZGlzYXNzZW1ibHkg KGdkYmFyY2gsIG5hbWUsIGxvdywgaGlnaCwgZmxhZ3MpOwogfQogCiAvKiBE dW1wIGEgc3BlY2lmaWVkIHNlY3Rpb24gb2YgYXNzZW1ibHkgY29kZS4KIAog ICAgVXNhZ2U6Ci0gICAgIGRpc2Fzc2VtYmxlIFsvbV0KKyAgICAgZGlzYXNz ZW1ibGUgWy9tcl0KICAgICAgICAtIGR1bXAgdGhlIGFzc2VtYmx5IGNvZGUg Zm9yIHRoZSBmdW5jdGlvbiBvZiB0aGUgY3VycmVudCBwYwotICAgICBkaXNh c3NlbWJsZSBbL21dIGFkZHIKKyAgICAgZGlzYXNzZW1ibGUgWy9tcl0gYWRk cgogICAgICAgIC0gZHVtcCB0aGUgYXNzZW1ibHkgY29kZSBmb3IgdGhlIGZ1 bmN0aW9uIGF0IEFERFIKLSAgICAgZGlzYXNzZW1ibGUgWy9tXSBsb3cgaGln aAorICAgICBkaXNhc3NlbWJsZSBbL21yXSBsb3cgaGlnaAogICAgICAgIC0g ZHVtcCB0aGUgYXNzZW1ibHkgY29kZSBpbiB0aGUgcmFuZ2UgW0xPVyxISUdI KQogCi0gICBBIC9tIG1vZGlmaWVyIHdpbGwgaW5jbHVkZSBzb3VyY2UgY29k ZSB3aXRoIHRoZSBhc3NlbWJseS4gICovCisgICBBIC9tIG1vZGlmaWVyIHdp bGwgaW5jbHVkZSBzb3VyY2UgY29kZSB3aXRoIHRoZSBhc3NlbWJseS4KKyAg IEEgL3IgbW9kaWZpZXIgd2lsbCBpbmNsdWRlIGluc3RydWN0aW9uIGluIGhl eCB3aXRoIHRoZSBhc3NlbWJseS4gICovCiAKIHN0YXRpYyB2b2lkCiBkaXNh c3NlbWJsZV9jb21tYW5kIChjaGFyICphcmcsIGludCBmcm9tX3R0eSkKQEAg LTk4NCwxMCArOTg1LDEwIEBAIGRpc2Fzc2VtYmxlX2NvbW1hbmQgKGNoYXIg KmFyZywgaW50IGZyb20KICAgY2hhciAqbmFtZTsKICAgQ09SRV9BRERSIHBj LCBwY19tYXNrZWQ7CiAgIGNoYXIgKnNwYWNlX2luZGV4OwotICBpbnQgbWl4 ZWRfc291cmNlX2FuZF9hc3NlbWJseTsKKyAgaW50IGZsYWdzOwogCiAgIG5h bWUgPSBOVUxMOwotICBtaXhlZF9zb3VyY2VfYW5kX2Fzc2VtYmx5ID0gMDsK KyAgZmxhZ3MgPSAwOwogCiAgIGlmIChhcmcgJiYgKmFyZyA9PSAnLycpCiAg ICAgewpAQCAtMTAwMSw3ICsxMDAyLDEwIEBAIGRpc2Fzc2VtYmxlX2NvbW1h bmQgKGNoYXIgKmFyZywgaW50IGZyb20KIAkgIHN3aXRjaCAoKmFyZysrKQog CSAgICB7CiAJICAgIGNhc2UgJ20nOgotCSAgICAgIG1peGVkX3NvdXJjZV9h bmRfYXNzZW1ibHkgPSAxOworCSAgICAgIGZsYWdzIHw9IERJU0FTU0VNQkxZ X1NPVVJDRTsKKwkgICAgICBicmVhazsKKwkgICAgY2FzZSAncic6CisJICAg ICAgZmxhZ3MgfD0gRElTQVNTRU1CTFlfUkFXX0lOU047CiAJICAgICAgYnJl YWs7CiAJICAgIGRlZmF1bHQ6CiAJICAgICAgZXJyb3IgKF8oIkludmFsaWQg ZGlzYXNzZW1ibHkgbW9kaWZpZXIuIikpOwpAQCAtMTAxNCw3ICsxMDE4LDcg QEAgZGlzYXNzZW1ibGVfY29tbWFuZCAoY2hhciAqYXJnLCBpbnQgZnJvbQog CiAgIGlmICghIGFyZyB8fCAhICphcmcpCiAgICAgewotICAgICAgZGlzYXNz ZW1ibGVfY3VycmVudF9mdW5jdGlvbiAobWl4ZWRfc291cmNlX2FuZF9hc3Nl bWJseSk7CisgICAgICBkaXNhc3NlbWJsZV9jdXJyZW50X2Z1bmN0aW9uIChm bGFncyk7CiAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC0xMDQ0LDcgKzEw NDgsNyBAQCBkaXNhc3NlbWJsZV9jb21tYW5kIChjaGFyICphcmcsIGludCBm cm9tCiAgICAgICBoaWdoID0gcGFyc2VfYW5kX2V2YWxfYWRkcmVzcyAoc3Bh Y2VfaW5kZXggKyAxKTsKICAgICB9CiAKLSAgcHJpbnRfZGlzYXNzZW1ibHkg KGdkYmFyY2gsIG5hbWUsIGxvdywgaGlnaCwgbWl4ZWRfc291cmNlX2FuZF9h c3NlbWJseSk7CisgIHByaW50X2Rpc2Fzc2VtYmx5IChnZGJhcmNoLCBuYW1l LCBsb3csIGhpZ2gsIGZsYWdzKTsKIH0KIAogc3RhdGljIHZvaWQKQEAgLTE0 NTQsNiArMTQ1OCw3IEBAIFdpdGggdHdvIGFyZ3MgaWYgb25lIGlzIGVtcHR5 IGl0IHN0YW5kcyAKIERpc2Fzc2VtYmxlIGEgc3BlY2lmaWVkIHNlY3Rpb24g b2YgbWVtb3J5LlxuXAogRGVmYXVsdCBpcyB0aGUgZnVuY3Rpb24gc3Vycm91 bmRpbmcgdGhlIHBjIG9mIHRoZSBzZWxlY3RlZCBmcmFtZS5cblwKIFdpdGgg YSAvbSBtb2RpZmllciwgc291cmNlIGxpbmVzIGFyZSBpbmNsdWRlZCAoaWYg YXZhaWxhYmxlKS5cblwKK1dpdGggYSAvciBtb2RpZmllciwgaW5zdHJ1Y3Rp b24gaW4gaGV4IGFyZSBpbmNsdWRlZC5cblwKIFdpdGggYSBzaW5nbGUgYXJn dW1lbnQsIHRoZSBmdW5jdGlvbiBzdXJyb3VuZGluZyB0aGF0IGFkZHJlc3Mg aXMgZHVtcGVkLlxuXAogVHdvIGFyZ3VtZW50cyBhcmUgdGFrZW4gYXMgYSBy YW5nZSBvZiBtZW1vcnkgdG8gZHVtcC4iKSk7CiAgIHNldF9jbWRfY29tcGxl dGVyIChjLCBsb2NhdGlvbl9jb21wbGV0ZXIpOwotLS0gYS9kaXNhc20uYwor KysgYi9kaXNhc20uYwpAQCAtODgsNyArODgsNyBAQCBzdGF0aWMgaW50CiBk dW1wX2luc25zIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgc3RydWN0IHVp X291dCAqdWlvdXQsCiAJICAgIHN0cnVjdCBkaXNhc3NlbWJsZV9pbmZvICog ZGksCiAJICAgIENPUkVfQUREUiBsb3csIENPUkVfQUREUiBoaWdoLAotCSAg ICBpbnQgaG93X21hbnksIHN0cnVjdCB1aV9zdHJlYW0gKnN0YikKKwkgICAg aW50IGhvd19tYW55LCBpbnQgZmxhZ3MsIHN0cnVjdCB1aV9zdHJlYW0gKnN0 YikKIHsKICAgaW50IG51bV9kaXNwbGF5ZWQgPSAwOwogICBDT1JFX0FERFIg cGM7CkBAIC0xMzUsNyArMTM1LDIzIEBAIGR1bXBfaW5zbnMgKHN0cnVjdCBn ZGJhcmNoICpnZGJhcmNoLCBzdHIKIAl4ZnJlZSAobmFtZSk7CiAKICAgICAg IHVpX2ZpbGVfcmV3aW5kIChzdGItPnN0cmVhbSk7Ci0gICAgICBwYyArPSBn ZGJhcmNoX3ByaW50X2luc24gKGdkYmFyY2gsIHBjLCBkaSk7CisgICAgICBp ZiAoZmxhZ3MgJiBESVNBU1NFTUJMWV9SQVdfSU5TTikKKyAgICAgICAgewor ICAgICAgICAgIENPUkVfQUREUiBvbGRfcGMgPSBwYzsKKyAgICAgICAgICBi ZmRfYnl0ZSBkYXRhOworICAgICAgICAgIGludCBzdGF0dXM7CisgICAgICAg ICAgcGMgKz0gZ2RiYXJjaF9wcmludF9pbnNuIChnZGJhcmNoLCBwYywgZGkp OworICAgICAgICAgIGZvciAoO29sZF9wYyA8IHBjOyBvbGRfcGMrKykKKyAg ICAgICAgICAgIHsKKyAgICAgICAgICAgICAgc3RhdHVzID0gKCpkaS0+cmVh ZF9tZW1vcnlfZnVuYykgKG9sZF9wYywgJmRhdGEsIDEsIGRpKTsKKyAgICAg ICAgICAgICAgaWYgKHN0YXR1cyAhPSAwKQorICAgICAgICAgICAgICAgICgq ZGktPm1lbW9yeV9lcnJvcl9mdW5jKSAoc3RhdHVzLCBvbGRfcGMsIGRpKTsK KyAgICAgICAgICAgICAgdWlfb3V0X21lc3NhZ2UgKHVpb3V0LCAwLCAiICUw MngiLCAodW5zaWduZWQpZGF0YSk7CisgICAgICAgICAgICB9CisgICAgICAg ICAgdWlfb3V0X3RleHQgKHVpb3V0LCAiXHQiKTsKKyAgICAgICAgfQorICAg ICAgZWxzZQorICAgICAgICBwYyArPSBnZGJhcmNoX3ByaW50X2luc24gKGdk YmFyY2gsIHBjLCBkaSk7CiAgICAgICB1aV9vdXRfZmllbGRfc3RyZWFtICh1 aW91dCwgImluc3QiLCBzdGIpOwogICAgICAgdWlfZmlsZV9yZXdpbmQgKHN0 Yi0+c3RyZWFtKTsKICAgICAgIGRvX2NsZWFudXBzICh1aV9vdXRfY2hhaW4p OwpAQCAtMTU0LDcgKzE3MCw3IEBAIGRvX21peGVkX3NvdXJjZV9hbmRfYXNz ZW1ibHkgKHN0cnVjdCBnZGIKIAkJCSAgICAgIHN0cnVjdCBsaW5ldGFibGVf ZW50cnkgKmxlLAogCQkJICAgICAgQ09SRV9BRERSIGxvdywgQ09SRV9BRERS IGhpZ2gsCiAJCQkgICAgICBzdHJ1Y3Qgc3ltdGFiICpzeW10YWIsCi0JCQkg ICAgICBpbnQgaG93X21hbnksIHN0cnVjdCB1aV9zdHJlYW0gKnN0YikKKwkJ CSAgICAgIGludCBob3dfbWFueSwgaW50IGZsYWdzLCBzdHJ1Y3QgdWlfc3Ry ZWFtICpzdGIpCiB7CiAgIGludCBuZXdsaW5lcyA9IDA7CiAgIHN0cnVjdCBk aXNfbGluZV9lbnRyeSAqbWxlOwpAQCAtMjc4LDcgKzI5NCw3IEBAIGRvX21p eGVkX3NvdXJjZV9hbmRfYXNzZW1ibHkgKHN0cnVjdCBnZGIKIAogICAgICAg bnVtX2Rpc3BsYXllZCArPSBkdW1wX2luc25zIChnZGJhcmNoLCB1aW91dCwg ZGksCiAJCQkJICAgbWxlW2ldLnN0YXJ0X3BjLCBtbGVbaV0uZW5kX3BjLAot CQkJCSAgIGhvd19tYW55LCBzdGIpOworCQkJCSAgIGhvd19tYW55LCBmbGFn cywgc3RiKTsKIAogICAgICAgLyogV2hlbiB3ZSd2ZSByZWFjaGVkIHRoZSBl bmQgb2YgdGhlIG1sZSBhcnJheSwgb3Igd2UndmUgc2VlbiB0aGUgbGFzdAog ICAgICAgICAgYXNzZW1ibHkgcmFuZ2UgZm9yIHRoaXMgc291cmNlIGxpbmUs IGNsb3NlIG91dCB0aGUgbGlzdC90dXBsZS4gICovCkBAIC0zMDEsMTQgKzMx NywxNSBAQCBzdGF0aWMgdm9pZAogZG9fYXNzZW1ibHlfb25seSAoc3RydWN0 IGdkYmFyY2ggKmdkYmFyY2gsIHN0cnVjdCB1aV9vdXQgKnVpb3V0LAogCQkg IHN0cnVjdCBkaXNhc3NlbWJsZV9pbmZvICogZGksCiAJCSAgQ09SRV9BRERS IGxvdywgQ09SRV9BRERSIGhpZ2gsCi0JCSAgaW50IGhvd19tYW55LCBzdHJ1 Y3QgdWlfc3RyZWFtICpzdGIpCisJCSAgaW50IGhvd19tYW55LCBpbnQgZmxh Z3MsIHN0cnVjdCB1aV9zdHJlYW0gKnN0YikKIHsKICAgaW50IG51bV9kaXNw bGF5ZWQgPSAwOwogICBzdHJ1Y3QgY2xlYW51cCAqdWlfb3V0X2NoYWluOwog CiAgIHVpX291dF9jaGFpbiA9IG1ha2VfY2xlYW51cF91aV9vdXRfbGlzdF9i ZWdpbl9lbmQgKHVpb3V0LCAiYXNtX2luc25zIik7CiAKLSAgbnVtX2Rpc3Bs YXllZCA9IGR1bXBfaW5zbnMgKGdkYmFyY2gsIHVpb3V0LCBkaSwgbG93LCBo aWdoLCBob3dfbWFueSwgc3RiKTsKKyAgbnVtX2Rpc3BsYXllZCA9IGR1bXBf aW5zbnMgKGdkYmFyY2gsIHVpb3V0LCBkaSwgbG93LCBoaWdoLCBob3dfbWFu eSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsYWdzLCBzdGIp OwogCiAgIGRvX2NsZWFudXBzICh1aV9vdXRfY2hhaW4pOwogfQpAQCAtMzU2 LDcgKzM3Myw3IEBAIGdkYl9kaXNhc3NlbWJsZV9pbmZvIChzdHJ1Y3QgZ2Ri YXJjaCAqZ2QKIHZvaWQKIGdkYl9kaXNhc3NlbWJseSAoc3RydWN0IGdkYmFy Y2ggKmdkYmFyY2gsIHN0cnVjdCB1aV9vdXQgKnVpb3V0LAogCQljaGFyICpm aWxlX3N0cmluZywKLQkJaW50IG1peGVkX3NvdXJjZV9hbmRfYXNzZW1ibHks CisJCWludCBmbGFncywKIAkJaW50IGhvd19tYW55LCBDT1JFX0FERFIgbG93 LCBDT1JFX0FERFIgaGlnaCkKIHsKICAgc3RydWN0IHVpX3N0cmVhbSAqc3Ri ID0gdWlfb3V0X3N0cmVhbV9uZXcgKHVpb3V0KTsKQEAgLTM3NywxMyArMzk0 LDEzIEBAIGdkYl9kaXNhc3NlbWJseSAoc3RydWN0IGdkYmFyY2ggKmdkYmFy Y2gKICAgICAgIG5saW5lcyA9IHN5bXRhYi0+bGluZXRhYmxlLT5uaXRlbXM7 CiAgICAgfQogCi0gIGlmICghbWl4ZWRfc291cmNlX2FuZF9hc3NlbWJseSB8 fCBubGluZXMgPD0gMAorICBpZiAoIShmbGFncyAmIERJU0FTU0VNQkxZX1NP VVJDRSkgfHwgbmxpbmVzIDw9IDAKICAgICAgIHx8IHN5bXRhYiA9PSBOVUxM IHx8IHN5bXRhYi0+bGluZXRhYmxlID09IE5VTEwpCi0gICAgZG9fYXNzZW1i bHlfb25seSAoZ2RiYXJjaCwgdWlvdXQsICZkaSwgbG93LCBoaWdoLCBob3df bWFueSwgc3RiKTsKKyAgICBkb19hc3NlbWJseV9vbmx5IChnZGJhcmNoLCB1 aW91dCwgJmRpLCBsb3csIGhpZ2gsIGhvd19tYW55LCBmbGFncywgc3RiKTsK IAotICBlbHNlIGlmIChtaXhlZF9zb3VyY2VfYW5kX2Fzc2VtYmx5KQorICBl bHNlIGlmIChmbGFncyAmIERJU0FTU0VNQkxZX1NPVVJDRSkKICAgICBkb19t aXhlZF9zb3VyY2VfYW5kX2Fzc2VtYmx5IChnZGJhcmNoLCB1aW91dCwgJmRp LCBubGluZXMsIGxlLCBsb3csCi0JCQkJICBoaWdoLCBzeW10YWIsIGhvd19t YW55LCBzdGIpOworCQkJCSAgaGlnaCwgc3ltdGFiLCBob3dfbWFueSwgZmxh Z3MsIHN0Yik7CiAKICAgZG9fY2xlYW51cHMgKGNsZWFudXBzKTsKICAgZ2Ri X2ZsdXNoIChnZGJfc3Rkb3V0KTsKLS0tIGEvZGlzYXNtLmgKKysrIGIvZGlz YXNtLmgKQEAgLTE5LDYgKzE5LDkgQEAKICNpZm5kZWYgRElTQVNNX0gKICNk ZWZpbmUgRElTQVNNX0gKIAorI2RlZmluZSBESVNBU1NFTUJMWV9TT1VSQ0UJ KDB4MSA8PCAwKQorI2RlZmluZSBESVNBU1NFTUJMWV9SQVdfSU5TTgkoMHgx IDw8IDEpCisKIHN0cnVjdCB1aV9vdXQ7CiBzdHJ1Y3QgdWlfZmlsZTsKIAot LS0gYS9taS9taS1jbWQtZGlzYXMuYworKysgYi9taS9taS1jbWQtZGlzYXMu YwpAQCAtMTU2LDYgKzE1Niw2IEBAIG1pX2NtZF9kaXNhc3NlbWJsZSAoY2hh ciAqY29tbWFuZCwgY2hhciAKIAogICBnZGJfZGlzYXNzZW1ibHkgKGdkYmFy Y2gsIHVpb3V0LAogICAJCSAgIGZpbGVfc3RyaW5nLAotCQkgICBtaXhlZF9z b3VyY2VfYW5kX2Fzc2VtYmx5LCBob3dfbWFueSwgbG93LCBoaWdoKTsKKwkJ ICAgRElTQVNTRU1CTFlfU09VUkNFLCBob3dfbWFueSwgbG93LCBoaWdoKTsK IAogfQotLS0gYS9zdGFjay5jCisrKyBiL3N0YWNrLmMKQEAgLTQ4MSw3ICs0 ODEsOSBAQCBzdGF0aWMgdm9pZAogZ2RiX2Rpc2Fzc2VtYmx5X3N0dWIgKHZv aWQgKmFyZ3MpCiB7CiAgIHN0cnVjdCBnZGJfZGlzYXNzZW1ibHlfc3R1Yl9h cmdzICpwID0gYXJnczsKLSAgZ2RiX2Rpc2Fzc2VtYmx5IChwLT5nZGJhcmNo LCB1aW91dCwgMCwgMCwgcC0+aG93X21hbnksIHAtPmxvdywgcC0+aGlnaCk7 CisgIGdkYl9kaXNhc3NlbWJseSAocC0+Z2RiYXJjaCwgdWlvdXQsIDAsCisg ICAgICAgICAgICAgICAgICAgRElTQVNTRU1CTFlfU09VUkNFIHwgRElTQVNT RU1CTFlfUkFXX0lOU04sIHAtPmhvd19tYW55LAorICAgICAgICAgICAgICAg ICAgIHAtPmxvdywgcC0+aGlnaCk7CiB9CiAKIC8qIFVzZSBUUllfQ0FUQ0gg dG8gY2F0Y2ggdGhlIGV4Y2VwdGlvbiBmcm9tIHRoZSBnZGJfZGlzYXNzZW1i bHkK --000e0cd5097af86116046e6a1f1e 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_fx03btnl1 Content-length: 997 LS0tCiBkb2MvZ2RiLnRleGluZm8gfCAgICA0ICsrKy0KIDEgZmlsZSBjaGFu Z2VkLCAzIGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKCi0tLSBhL2Rv Yy9nZGIudGV4aW5mbworKysgYi9kb2MvZ2RiLnRleGluZm8KQEAgLTYxNzgs OSArNjE3OCwxMSBAQCBWYXJpYWJsZXN9KS4KIEBjaW5kZXggbGlzdGluZyBt YWNoaW5lIGluc3RydWN0aW9ucwogQGl0ZW0gZGlzYXNzZW1ibGUKIEBpdGVt eCBkaXNhc3NlbWJsZSAvbQorQGl0ZW14IGRpc2Fzc2VtYmxlIC9yCiBUaGlz IHNwZWNpYWxpemVkIGNvbW1hbmQgZHVtcHMgYSByYW5nZSBvZiBtZW1vcnkg YXMgbWFjaGluZQogaW5zdHJ1Y3Rpb25zLiAgSXQgY2FuIGFsc28gcHJpbnQg bWl4ZWQgc291cmNlK2Rpc2Fzc2VtYmx5IGJ5IHNwZWNpZnlpbmcKLXRoZSBA Y29kZXsvbX0gbW9kaWZpZXIuCit0aGUgQGNvZGV7L219IG1vZGlmaWVyIGFu ZCBwcmludCB0aGUgaW5zdHJ1Y3Rpb24gaW4gaGV4IGFzIHdlbGwgYXMgaW4K K3N5bWJvbGljIGZvcm0gYnkgc3BlY2lmeWluZyB0aGUgQGNvZGV7L3J9Lgog VGhlIGRlZmF1bHQgbWVtb3J5IHJhbmdlIGlzIHRoZSBmdW5jdGlvbiBzdXJy b3VuZGluZyB0aGUKIHByb2dyYW0gY291bnRlciBvZiB0aGUgc2VsZWN0ZWQg ZnJhbWUuICBBIHNpbmdsZSBhcmd1bWVudCB0byB0aGlzCiBjb21tYW5kIGlz IGEgcHJvZ3JhbSBjb3VudGVyIHZhbHVlOyBAdmFsdWV7R0RCTn0gZHVtcHMg dGhlIGZ1bmN0aW9uCg== --000e0cd5097af86116046e6a1f1e 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_fx03bujl2 Content-length: 2737 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 ZVxcKVwuXFtcclxuXF0rV2l0aCBhIC9yIG1vZGlmaWVyLCBpbnN0cnVjdGlv biBpbiBoZXggYXJlIGluY2x1ZGVkXC5cW1xyXG5cXStXaXRoIGEgc2luZ2xl IGFyZ3VtZW50LCB0aGUgZnVuY3Rpb24gc3Vycm91bmRpbmcgdGhhdCBhZGRy ZXNzIGlzIGR1bXBlZFwuXFtcclxuXF0rVHdvIGFyZ3VtZW50cyBhcmUgdGFr ZW4gYXMgYSByYW5nZSBvZiBtZW1vcnkgdG8gZHVtcFwuIiAiaGVscCBkaXNh c3NlbWJsZSIKICMgdGVzdCBoZWxwIGRpc3BsYXkKIGdkYl90ZXN0ICJoZWxw IGRpc3BsYXkiICJQcmludCB2YWx1ZSBvZiBleHByZXNzaW9uIEVYUCBlYWNo IHRpbWUgdGhlIHByb2dyYW0gc3RvcHNcLlxbXHJcblxdKy9GTVQgbWF5IGJl IHVzZWQgYmVmb3JlIEVYUCBhcyBpbiB0aGUgXCJwcmludFwiIGNvbW1hbmRc LlxbXHJcblxdKy9GTVQgXCJpXCIgb3IgXCJzXCIgb3IgaW5jbHVkaW5nIGEg c2l6ZS1sZXR0ZXIgaXMgYWxsb3dlZCxcW1xyXG5cXSthcyBpbiB0aGUgXCJ4 XCIgY29tbWFuZCwgYW5kIHRoZW4gRVhQIGlzIHVzZWQgdG8gZ2V0IHRoZSBh ZGRyZXNzIHRvIGV4YW1pbmVcW1xyXG5cXSthbmQgZXhhbWluaW5nIGlzIGRv bmUgYXMgaW4gdGhlIFwieFwiIGNvbW1hbmRcLlxbXHJcblxdK1dpdGggbm8g YXJndW1lbnQsIGRpc3BsYXkgYWxsIGN1cnJlbnRseSByZXF1ZXN0ZWQgYXV0 by1kaXNwbGF5IGV4cHJlc3Npb25zXC5cW1xyXG5cXStVc2UgXCJ1bmRpc3Bs YXlcIiB0byBjYW5jZWwgZGlzcGxheSByZXF1ZXN0cyBwcmV2aW91c2x5IG1h ZGVcLiIgImhlbHAgZGlzcGxheSIKICMgdGVzdCBoZWxwIGRvCg== --000e0cd5097af86116046e6a1f1e--