// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro11/macro11.c
// Function: main
int main(
    int argc,
    char *argv[])
{
    char           *fnames[32];
    int             nr_files = 0;
    FILE           *obj = NULL;
    TEXT_RLD        tr;
    char           *objname = NULL;
    char           *lstname = NULL;
    int             arg;
    int             i;
    STACK           stack;
    int             errcount;

    if (argc <= 1) {
        print_help();
        exit(EXIT_FAILURE);
    }

    for (arg = 1; arg < argc; arg++)
        if (*argv[arg] == '-') {
            char           *cp;

            cp = argv[arg] + 1;
            if (!stricmp(cp, "h")) {
                print_help();
            } else if (!stricmp(cp, "v")) {
                print_version(stderr);
            } else if (!stricmp(cp, "e")) {
                /* Followed by options to enable */
                /* Since /SHOW and /ENABL option names don't overlap,
                   I consolidate. */
                if(arg >= argc-1 || !isalpha((unsigned char)*argv[arg+1])) {
                    usage("-e must be followed by an option to enable\n");
                }
                upcase(argv[++arg]);
                enable_tf(argv[arg], 1);
            } else if (!stricmp(cp, "d")) {
                /* Followed by an option to disable */
                if(arg >= argc-1 || !isalpha((unsigned char)*argv[arg+1])) {
                    usage("-d must be followed by an option to disable\n");
                }
                upcase(argv[++arg]);
                enable_tf(argv[arg], 0);
            } else if (!stricmp(cp, "m")) {
                /* Macro library */
                /* This option gives the name of an RT-11 compatible
                   macro library from which .MCALLed macros can be
                   found. */
                if(arg >= argc-1 || *argv[arg+1] == '-') {
                    usage("-m must be followed by a macro library file name\n");
                }
                arg++;
                int allow_olb = strcmp(argv[argc-1], "-x") == 0;
                mlbs[nr_mlbs] = mlb_open(argv[arg], allow_olb);
                if (mlbs[nr_mlbs] == NULL) {
                    fprintf(stderr, "Unable to register macro library %s\n", argv[arg]);
                    exit(EXIT_FAILURE);
                }
                nr_mlbs++;
            } else if (!stricmp(cp, "p")) {
                /* P for search path */
                /* The -p option gives the name of a directory in
                   which .MCALLed macros may be found.  */  {

                    if(arg >= argc-1 || *argv[arg+1] == '-') {
                        usage("-p must be followed by a macro search directory\n");
                    }

                    append_env("MCALL", argv[arg+1]);
                    arg++;
                }
            } else if (!stricmp(cp, "I")) {
                /* I for include path */
                /* The -I option gives the name of a directory in
                   which .included files may be found.  */  {

                    if(arg >= argc-1 || *argv[arg+1] == '-') {
                        usage("-I must be followed by a include file search directory\n");
                    }
                    append_env("INCLUDE", argv[arg+1]);

                    arg++;
                }
            } else if (!stricmp(cp, "o")) {
                /* The -o option gives the object file name (.OBJ) */
                if(arg >= argc-1 || *argv[arg+1] == '-') {
                    usage("-o must be followed by the object file name\n");
                }
                ++arg;
                objname = argv[arg];
            } else if (!stricmp(cp, "l")) {
                /* The option -l gives the listing file name (.LST) */
                /* -l - enables listing to stdout. */
                if(arg >= argc-1 ||
                        (argv[arg+1][0] == '-' && argv[arg+1][1] != '\0')) {
                    usage("-l must be followed by the listing file name (- for standard output)\n");
                }
                lstname = argv[++arg];
                if (strcmp(lstname, "-") == 0)
                    lstfile = stdout;
                else
                    lstfile = fopen(lstname, "w");
            } else if (!stricmp(cp, "x")) {
                /* The -x option invokes macro11 to expand the
                   contents of the registered macro libraries (see -m)
                   into individual .MAC files in the current
                   directory.  No assembly of input is done.  This
                   must be the last command line option.  */
                int             m;

                if(arg != argc-1) {
                    usage("-x must be the last option\n");
                }
                for (m = 0; m < nr_mlbs; m++)
                    mlb_extract(mlbs[m]);
                return EXIT_SUCCESS;
            } else if (!stricmp(cp, "ysl")) {
                /* set symbol_len */
                if (arg >= argc-1) {
                    usage("-s must be followed by a number\n");
                } else {
                    char           *s = argv[++arg];
                    char           *endp;
                    int             sl = strtol(s, &endp, 10);

                    if (*endp || sl < SYMMAX_DEFAULT || sl > SYMMAX_MAX) {
                        usage("-s must be followed by a number\n");
                    }
                    symbol_len = sl;
                }
            } else if (!stricmp(cp, "yus")) {
                /* allow underscores */
                symbol_allow_underscores = 1;
            } else if (!stricmp(cp, "yl1")) {
                /* list the first pass, in addition to the second */
                list_pass_0++;
            } else if (!stricmp(cp, "yd")) {
                enabl_debug++;
            } else {
                fprintf(stderr, "Unknown option %s\n", argv[arg]);
                print_help();
                exit(EXIT_FAILURE);
            }
        } else {
            fnames[nr_files++] = argv[arg];
        }

    if (objname) {
        obj = fopen(objname, "wb");
        if (obj == NULL)
            return EXIT_FAILURE;
    }

    add_symbols(&blank_section);

    text_init(&tr, NULL, 0);

    module_name = memcheck(strdup(".MAIN."));

    xfer_address = new_ex_lit(1);      /* The undefined transfer address */

    stack_init(&stack);
    /* Push the files onto the input stream in reverse order */
    for (i = nr_files - 1; i >= 0; --i) {
        STREAM         *str = new_file_stream(fnames[i]);

        if (str == NULL) {
            report(NULL, "Unable to open file %s\n", fnames[i]);
            exit(EXIT_FAILURE);
        }
        stack_push(&stack, str);
    }

    DOT = 0;
    current_pc->section = &blank_section;
    last_dot_section = NULL;
    pass = 0;
    stmtno = 0;
    lsb = 0;
    next_lsb = 1;
    lsb_used = 0;
    last_macro_lsb = -1;
    last_locsym = 32767;
    last_cond = -1;
    sect_sp = -1;
    suppressed = 0;

    assemble_stack(&stack, &tr);

    if (list_pass_0 && lstfile) {
        list_symbol_table();
    }
#if 0
    if (enabl_debug > 1)
        dump_all_macros();
#endif

    assert(stack.top == NULL);

    migrate_implicit();                /* Migrate the implicit globals */
    write_globals(obj);                /* Write the global symbol dictionary */

#if 0
    sym_hist(&symbol_st, "symbol_st"); /* Draw a symbol table histogram */
#endif


    text_init(&tr, obj, 0);

    stack_init(&stack);                /* Superfluous... */
    /* Re-push the files onto the input stream in reverse order */
    for (i = nr_files - 1; i >= 0; --i) {
        STREAM         *str = new_file_stream(fnames[i]);

        if (str == NULL) {
            report(NULL, "Unable to open file %s\n", fnames[i]);
            exit(EXIT_FAILURE);
        }
        stack_push(&stack, str);
    }

    DOT = 0;

    current_pc->section = &blank_section;
    last_dot_section = NULL;

    pass = 1;
    stmtno = 0;
    lsb = 0;
    next_lsb = 1;
    lsb_used = 0;
    last_macro_lsb = -1;
    last_locsym = 32767;
    pop_cond(-1);
    sect_sp = -1;
    suppressed = 0;

    errcount = assemble_stack(&stack, &tr);

    text_flush(&tr);

    while (last_cond >= 0) {
        report(NULL, "%s:%d: Unterminated conditional\n", conds[last_cond].file, conds[last_cond].line);
        pop_cond(last_cond - 1);
        errcount++;
    }

    for (i = 0; i < nr_mlbs; i++)
        mlb_close(mlbs[i]);

    write_endmod(obj);

    if (obj != NULL)
        fclose(obj);

    if (errcount > 0)
        fprintf(stderr, "%d Errors\n", errcount);

    if (lstfile) {
        list_symbol_table();
    }

    if (lstfile && strcmp(lstname, "-") != 0)
        fclose(lstfile);

    return errcount > 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
cmpl $0x2, %edi
jl 0x2c85
movq %rsi, %r14
leal -0x1(%rdi), %eax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
pushq $0x1
popq %r12
movq $0x0, 0x20(%rsp)
xorl %r13d, %r13d
movq %rdi, (%rsp)
cmpl %edi, %r12d
jge 0x281e
movslq %r12d, %r15
movq (%r14,%r15,8), %rbx
cmpb $0x2d, (%rbx)
jne 0x25d1
leaq 0x1(%rbx), %rbp
movq %rbp, %rdi
leaq 0xc0c6(%rip), %rsi      # 0xe553
callq 0x2070
testl %eax, %eax
je 0x25e4
movq %rbp, %rdi
leaq 0xbb60(%rip), %rsi      # 0xe004
callq 0x2070
testl %eax, %eax
je 0x25ee
movq %rbp, %rdi
leaq 0xbfbc(%rip), %rsi      # 0xe477
callq 0x2070
testl %eax, %eax
je 0x25ff
movq %rbp, %rdi
leaq 0xd19f(%rip), %rsi      # 0xf671
callq 0x2070
testl %eax, %eax
je 0x2637
movq %rbp, %rdi
leaq 0xbb76(%rip), %rsi      # 0xe05f
callq 0x2070
testl %eax, %eax
je 0x267d
movq %rbp, %rdi
leaq 0xbfd5(%rip), %rsi      # 0xe4d5
callq 0x2070
testl %eax, %eax
je 0x26e2
movq %rbp, %rdi
leaq 0xd5bc(%rip), %rsi      # 0xfad3
callq 0x2070
testl %eax, %eax
je 0x2707
movq %rbp, %rdi
leaq 0xcef2(%rip), %rsi      # 0xf420
callq 0x2070
testl %eax, %eax
je 0x2734
movq %rbp, %rdi
leaq 0xbc71(%rip), %rsi      # 0xe1b6
callq 0x2070
testl %eax, %eax
je 0x275a
movq %rbp, %rdi
leaq 0xbc3a(%rip), %rsi      # 0xe196
callq 0x2070
testl %eax, %eax
je 0x2b7b
movq %rbp, %rdi
leaq 0xbc41(%rip), %rsi      # 0xe1b4
callq 0x2070
testl %eax, %eax
je 0x2793
movq %rbp, %rdi
leaq 0xbc4f(%rip), %rsi      # 0xe1d9
callq 0x2070
testl %eax, %eax
je 0x27fe
movq %rbp, %rdi
leaq 0xbc3c(%rip), %rsi      # 0xe1dd
callq 0x2070
testl %eax, %eax
je 0x2810
movq %rbp, %rdi
leaq 0xbc29(%rip), %rsi      # 0xe1e1
callq 0x2070
testl %eax, %eax
jne 0x2c6a
leaq 0x135ac(%rip), %rax     # 0x15b78
jmp 0x2817
movslq %r13d, %rax
incl %r13d
movq %rbx, 0x140(%rsp,%rax,8)
jmp 0x2675
callq 0x2c9b
jmp 0x2671
movq 0x12a03(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
callq 0x2ecd
jmp 0x2671
cmpl 0x8(%rsp), %r12d
jge 0x2bca
callq 0x2300
movq (%rax), %rax
movq 0x8(%r14,%r15,8), %rdi
movzbl (%rdi), %ecx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x2bca
incl %r12d
callq 0xcd86
movq 0x8(%r14,%r15,8), %rdi
pushq $0x1
popq %rsi
jmp 0x266c
cmpl 0x8(%rsp), %r12d
jge 0x2bd6
callq 0x2300
movq (%rax), %rax
movq 0x8(%r14,%r15,8), %rdi
movzbl (%rdi), %ecx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x2bd6
incl %r12d
callq 0xcd86
movq 0x8(%r14,%r15,8), %rdi
xorl %esi, %esi
callq 0x2f4b
movq (%rsp), %rdi
incl %r12d
jmp 0x2466
cmpl 0x8(%rsp), %r12d
jge 0x2be2
movq 0x8(%r14,%r15,8), %rdi
cmpb $0x2d, (%rdi)
je 0x2be2
movq 0x8(%rsp), %rax
movq (%r14,%rax,8), %rax
xorl %esi, %esi
cmpb $0x2d, (%rax)
jne 0x26b6
cmpb $0x78, 0x1(%rax)
jne 0x26b6
xorl %esi, %esi
cmpb $0x0, 0x2(%rax)
sete %sil
incl %r12d
callq 0xb3b4
leaq 0x134c3(%rip), %rdx     # 0x15b88
movslq (%rdx), %rcx
leaq 0x134e1(%rip), %rsi     # 0x15bb0
movq %rax, (%rsi,%rcx,8)
testq %rax, %rax
je 0x2bfa
incl %ecx
movl %ecx, (%rdx)
jmp 0x2671
cmpl 0x8(%rsp), %r12d
jge 0x2bee
movq 0x8(%r14,%r15,8), %rsi
cmpb $0x2d, (%rsi)
je 0x2bee
incl %r12d
leaq 0xd0e5(%rip), %rdi      # 0xf7ea
jmp 0x272a
cmpl 0x8(%rsp), %r12d
jge 0x2c3a
movq 0x8(%r14,%r15,8), %rsi
cmpb $0x2d, (%rsi)
je 0x2c3a
incl %r12d
leaq 0xd0a1(%rip), %rdi      # 0xf7cb
callq 0x2fe7
jmp 0x2671
cmpl 0x8(%rsp), %r12d
jge 0x2c46
movq 0x8(%r14,%r15,8), %rcx
movq %rcx, 0x20(%rsp)
cmpb $0x2d, (%rcx)
je 0x2c46
incl %r12d
jmp 0x2671
cmpl 0x8(%rsp), %r12d
jge 0x2c52
movq 0x8(%r14,%r15,8), %rax
cmpb $0x2d, (%rax)
movq %rax, 0x18(%rsp)
jne 0x27db
cmpb $0x0, 0x1(%rax)
jne 0x2c52
incl %r12d
cmpb $0x0, 0x1(%rax)
jne 0x27de
movq 0x1282a(%rip), %rax     # 0x14fb8
movq (%rax), %rax
jmp 0x27ef
cmpl 0x8(%rsp), %r12d
jge 0x2c5e
movq 0x8(%r14,%r15,8), %rdi
leaq 0x28(%rsp), %rsi
pushq $0xa
popq %rdx
callq 0x2210
movq 0x28(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x2c5e
leal -0x41(%rax), %ecx
cmpl $-0x3c, %ecx
jbe 0x2c5e
incl %r12d
leaq 0x13314(%rip), %rcx     # 0x15ae8
movl %eax, (%rcx)
jmp 0x2671
incl %r12d
movq 0x18(%rsp), %rdi
leaq 0xb9aa(%rip), %rsi      # 0xe194
callq 0x2270
leaq 0x14e6a(%rip), %rcx     # 0x17660
movq %rax, (%rcx)
jmp 0x2671
leaq 0x14e7b(%rip), %rax     # 0x17680
movl $0x1, (%rax)
jmp 0x2671
leaq 0x14e51(%rip), %rax     # 0x17668
incl (%rax)
jmp 0x2671
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2841
leaq 0xb9c8(%rip), %rsi      # 0xe1f7
callq 0x2270
testq %rax, %rax
jne 0x2843
pushq $0x1
popq %rbx
jmp 0x2b4b
xorl %eax, %eax
movq %rax, (%rsp)
leaq 0x12a02(%rip), %r14     # 0x15250
movq %r14, %rdi
callq 0x9909
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xbba0
leaq 0xb98f(%rip), %rdi      # 0xe1fa
callq 0x22e0
movq %rax, %rdi
callq 0xcd2d
leaq 0x13311(%rip), %rcx     # 0x15b90
movq %rax, (%rcx)
pushq $0x1
popq %rdi
callq 0x7316
leaq 0x1330f(%rip), %rcx     # 0x15ba0
movq %rax, (%rcx)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xcaec
decl %r13d
movl %r13d, %ebx
testl %ebx, %ebx
js 0x28d5
movl %ebx, %eax
movq 0x140(%rsp,%rax,8), %r12
movq %r12, %rdi
callq 0xca72
testq %rax, %rax
je 0x2baf
movq %r15, %rdi
movq %rax, %rsi
callq 0xcb0f
decl %ebx
jmp 0x28a7
leaq 0x14d6c(%rip), %rax     # 0x17648
movq (%rax), %rax
andl $0x0, 0x8(%rax)
movq %r14, 0x18(%rax)
leaq 0x14d6a(%rip), %rax     # 0x17658
andq $0x0, (%rax)
leaq 0x13267(%rip), %rax     # 0x15b60
andl $0x0, (%rax)
leaq 0x13261(%rip), %rax     # 0x15b64
andl $0x0, (%rax)
leaq 0x1325b(%rip), %rax     # 0x15b68
andl $0x0, (%rax)
leaq 0x13255(%rip), %rax     # 0x15b6c
andl $0x0, (%rax)
leaq 0x13253(%rip), %rax     # 0x15b74
orl $-0x1, (%rax)
leaq 0x13245(%rip), %rbp     # 0x15b70
movl $0x1, (%rbp)
leaq 0x1286b(%rip), %r14     # 0x151a4
movl $0x7fff, (%r14)         # imm = 0x7FFF
leaq 0x14b69(%rip), %rbx     # 0x174b0
orl $-0x1, (%rbx)
leaq 0x14cef(%rip), %rax     # 0x17640
orl $-0x1, (%rax)
leaq 0x13229(%rip), %rax     # 0x15b84
andl $0x0, (%rax)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x313e
xorl %eax, %eax
leaq 0x14cf2(%rip), %rcx     # 0x17668
cmpl %eax, (%rcx)
je 0x298c
leaq 0x14cdf(%rip), %rax     # 0x17660
cmpq $0x0, (%rax)
je 0x298c
callq 0xafee
cmpq $0x0, 0x10(%rsp)
jne 0x2c1b
callq 0x5b7e
movq (%rsp), %r15
movq %r15, %rdi
callq 0x6702
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xbba0
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xcaec
testl %r13d, %r13d
js 0x29f6
movl %r13d, %eax
movq 0x140(%rsp,%rax,8), %r12
movq %r12, %rdi
callq 0xca72
testq %rax, %rax
je 0x2baf
movq %r15, %rdi
movq %rax, %rsi
callq 0xcb0f
decl %r13d
jmp 0x29c5
leaq 0x14c4b(%rip), %rax     # 0x17648
movq (%rax), %rax
andl $0x0, 0x8(%rax)
leaq 0x12845(%rip), %rcx     # 0x15250
movq %rcx, 0x18(%rax)
leaq 0x14c42(%rip), %rax     # 0x17658
andq $0x0, (%rax)
leaq 0x13143(%rip), %rax     # 0x15b64
andl $0x0, (%rax)
pushq $0x1
popq %rax
leaq 0x13132(%rip), %rcx     # 0x15b60
movl %eax, (%rcx)
leaq 0x13131(%rip), %rcx     # 0x15b68
andl $0x0, (%rcx)
movl %eax, (%rbp)
leaq 0x13128(%rip), %rax     # 0x15b6c
andl $0x0, (%rax)
leaq 0x13126(%rip), %rax     # 0x15b74
orl $-0x1, (%rax)
movl $0x7fff, (%r14)         # imm = 0x7FFF
pushq $-0x1
popq %rdi
callq 0x6440
leaq 0x14bd9(%rip), %rax     # 0x17640
orl $-0x1, (%rax)
leaq 0x13113(%rip), %rax     # 0x15b84
andl $0x0, (%rax)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x313e
movl %eax, %ebp
movq %r14, %rdi
callq 0xbbd3
leaq 0x13219(%rip), %r15     # 0x15cb0
leaq 0xb7ae(%rip), %r14      # 0xe24c
leaq 0x14bbb(%rip), %r12     # 0x17660
leaq 0x130dc(%rip), %r13     # 0x15b88
movslq (%rbx), %rax
testq %rax, %rax
js 0x2adb
imulq $0x18, %rax, %rax
movq 0x8(%r15,%rax), %rdx
movl 0x10(%r15,%rax), %ecx
xorl %edi, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x7668
movl (%rbx), %edi
decl %edi
callq 0x6440
incl %ebp
jmp 0x2aac
xorl %ebx, %ebx
movq 0x18(%rsp), %r14
movslq (%r13), %rax
cmpq %rax, %rbx
jge 0x2b00
leaq 0x130be(%rip), %rax     # 0x15bb0
movq (%rax,%rbx,8), %rdi
callq 0xb6de
incq %rbx
jmp 0x2ae2
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0xc782
testq %rbx, %rbx
je 0x2b19
movq %rbx, %rdi
callq 0x20d0
testl %ebp, %ebp
jg 0x2b5f
cmpq $0x0, (%r12)
je 0x2b44
callq 0xafee
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2b44
cmpb $0x2d, (%r14)
jne 0x2b3f
cmpb $0x0, 0x1(%r14)
je 0x2b44
callq 0x20d0
xorl %ebx, %ebx
testl %ebp, %ebp
setg %bl
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x12492(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xb6fd(%rip), %rsi      # 0xe26d
movl %ebp, %edx
xorl %eax, %eax
callq 0x21e0
jmp 0x2b1d
cmpl 0x8(%rsp), %r12d
jne 0x2c8f
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x12ff6(%rip), %r15     # 0x15b88
movslq (%r15), %rax
cmpq %rax, %r14
jge 0x2b4b
leaq 0x1300f(%rip), %rax     # 0x15bb0
movq (%rax,%r14,8), %rdi
callq 0xb912
incq %r14
jmp 0x2b92
leaq 0xb64b(%rip), %rsi      # 0xe201
xorl %edi, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x7668
pushq $0x1
popq %rdi
callq 0x22c0
leaq 0xb435(%rip), %rdi      # 0xe006
callq 0x240c
leaq 0xb455(%rip), %rdi      # 0xe032
callq 0x240c
leaq 0xb478(%rip), %rdi      # 0xe061
callq 0x240c
leaq 0xb4c3(%rip), %rdi      # 0xe0b8
callq 0x240c
movslq %r12d, %rax
movq 0x123f4(%rip), %rcx     # 0x14ff8
movq (%rcx), %rdi
movq (%r14,%rax,8), %rdx
leaq 0xb481(%rip), %rsi      # 0xe093
xorl %eax, %eax
callq 0x21e0
jmp 0x2bc2
leaq 0xb5f7(%rip), %rdi      # 0xe219
leaq 0xb602(%rip), %rsi      # 0xe22b
leaq 0xb605(%rip), %rcx      # 0xe235
movl $0x174, %edx            # imm = 0x174
callq 0x2120
leaq 0xb4a8(%rip), %rdi      # 0xe0e9
callq 0x240c
leaq 0xb4d4(%rip), %rdi      # 0xe121
callq 0x240c
leaq 0xb4f5(%rip), %rdi      # 0xe14e
callq 0x240c
leaq 0xb553(%rip), %rdi      # 0xe1b8
callq 0x240c
movq 0x12387(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xb569(%rip), %rsi      # 0xe1e4
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21e0
callq 0x2c9b
jmp 0x2bc2
leaq 0xb502(%rip), %rdi      # 0xe198
callq 0x240c