// File: /workspace/github_c_makefile_star2_O1/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 0x2e81
movq %rsi, %r14
leal -0x1(%rdi), %eax
movq %rax, 0x8(%rsp)
movl $0x1, %r12d
xorl %r15d, %r15d
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq %rdi, (%rsp)
movslq %r12d, %rbx
movq (%r14,%rbx,8), %rbp
cmpb $0x2d, (%rbp)
jne 0x27bd
leaq 0x1(%rbp), %r13
movq %r13, %rdi
leaq 0xcee3(%rip), %rsi      # 0xf55c
callq 0x2070
testl %eax, %eax
je 0x27d0
movq %r13, %rdi
leaq 0xc974(%rip), %rsi      # 0xf004
callq 0x2070
testl %eax, %eax
je 0x27da
movq %r13, %rdi
leaq 0xcdd9(%rip), %rsi      # 0xf480
callq 0x2070
testl %eax, %eax
je 0x27eb
movq %r13, %rdi
leaq 0xdf73(%rip), %rsi      # 0x10631
callq 0x2070
testl %eax, %eax
je 0x282a
movq %r13, %rdi
leaq 0xc98a(%rip), %rsi      # 0xf05f
callq 0x2070
testl %eax, %eax
je 0x2888
movq %r13, %rdi
leaq 0xcdf2(%rip), %rsi      # 0xf4de
callq 0x2070
testl %eax, %eax
je 0x28f2
movq %r13, %rdi
leaq 0xe374(%rip), %rsi      # 0x10a77
callq 0x2070
testl %eax, %eax
je 0x291c
movq %r13, %rdi
leaq 0xdce2(%rip), %rsi      # 0x103fc
callq 0x2070
testl %eax, %eax
je 0x294e
movq %r13, %rdi
leaq 0xca88(%rip), %rsi      # 0xf1b9
callq 0x2070
testl %eax, %eax
je 0x2979
movq %r13, %rdi
leaq 0xc94c(%rip), %rsi      # 0xf094
callq 0x2070
testl %eax, %eax
je 0x29d0
movq %r13, %rdi
leaq 0xca58(%rip), %rsi      # 0xf1b7
callq 0x2070
testl %eax, %eax
je 0x2a18
movq %r13, %rdi
leaq 0xca66(%rip), %rsi      # 0xf1dc
callq 0x2070
testl %eax, %eax
je 0x2a7b
movq %r13, %rdi
leaq 0xca53(%rip), %rsi      # 0xf1e0
callq 0x2070
testl %eax, %eax
je 0x2a94
movq %r13, %rdi
leaq 0xca40(%rip), %rsi      # 0xf1e4
callq 0x2070
testl %eax, %eax
jne 0x2eda
leaq 0x133c0(%rip), %rax     # 0x15b78
jmp 0x2a9b
movslq %r15d, %rax
incl %r15d
movq %rbp, 0x140(%rsp,%rax,8)
jmp 0x2877
callq 0x2ee2
jmp 0x2869
movq 0x12817(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
callq 0x3127
jmp 0x2869
cmpl 0x8(%rsp), %r12d
jge 0x2e72
callq 0x2300
movq (%rax), %rax
movq 0x8(%r14,%rbx,8), %rcx
movzbl (%rcx), %ecx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x2e72
incl %r12d
movq 0x8(%r14,%rbx,8), %rdi
callq 0xe393
movq 0x8(%r14,%rbx,8), %rdi
movl $0x1, %esi
jmp 0x2864
cmpl 0x8(%rsp), %r12d
jge 0x2e77
callq 0x2300
movq (%rax), %rax
movq 0x8(%r14,%rbx,8), %rcx
movzbl (%rcx), %ecx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x2e77
incl %r12d
movq 0x8(%r14,%rbx,8), %rdi
callq 0xe393
movq 0x8(%r14,%rbx,8), %rdi
xorl %esi, %esi
callq 0x31a8
movb $0x1, %al
movq (%rsp), %rdi
testb %al, %al
je 0x2aca
incl %r12d
cmpl %edi, %r12d
jl 0x265a
jmp 0x2aa2
cmpl 0x8(%rsp), %r12d
jge 0x2e7c
movq 0x8(%r14,%rbx,8), %rax
cmpb $0x2d, (%rax)
je 0x2e7c
movq 0x8(%rsp), %rax
movq (%r14,%rax,8), %rdi
leaq 0xc7e2(%rip), %rsi      # 0xf093
callq 0x21d0
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq 0x8(%r14,%rbx,8), %rdi
callq 0xbea4
leaq 0x132b9(%rip), %rdx     # 0x15b88
movslq (%rdx), %rcx
leaq 0x132d7(%rip), %rsi     # 0x15bb0
movq %rax, (%rsi,%rcx,8)
testq %rax, %rax
je 0x2e8d
incl %r12d
incl %ecx
movl %ecx, (%rdx)
jmp 0x2869
cmpl 0x8(%rsp), %r12d
jge 0x2e88
movq 0x8(%r14,%rbx,8), %rax
cmpb $0x2d, (%rax)
je 0x2e88
incl %r12d
movq 0x8(%r14,%rbx,8), %rsi
leaq 0xde74(%rip), %rdi      # 0x1078e
jmp 0x2944
cmpl 0x8(%rsp), %r12d
jge 0x2eba
movq 0x8(%r14,%rbx,8), %rax
cmpb $0x2d, (%rax)
je 0x2eba
incl %r12d
movq 0x8(%r14,%rbx,8), %rsi
leaq 0xde2b(%rip), %rdi      # 0x1076f
callq 0x3242
jmp 0x2869
cmpl 0x8(%rsp), %r12d
jge 0x2ebf
movq 0x8(%r14,%rbx,8), %rax
cmpb $0x2d, (%rax)
je 0x2ebf
incl %r12d
movq 0x8(%r14,%rbx,8), %rax
movq %rax, 0x20(%rsp)
jmp 0x2869
cmpl 0x8(%rsp), %r12d
jge 0x2ec4
movq 0x8(%r14,%rbx,8), %rax
cmpb $0x2d, (%rax)
jne 0x2998
cmpb $0x0, 0x1(%rax)
jne 0x2ec4
incl %r12d
movq 0x8(%r14,%rbx,8), %rbx
movq %rbx, %rdi
leaq 0xc7ed(%rip), %rsi      # 0xf197
callq 0x21d0
testl %eax, %eax
movq %rbx, 0x18(%rsp)
je 0x2a62
movq %rbx, %rdi
leaq 0xc7d3(%rip), %rsi      # 0xf199
callq 0x2270
jmp 0x2a6c
cmpl 0x8(%rsp), %r12d
jne 0x2ed5
leaq 0x131a6(%rip), %rax     # 0x15b88
cmpl $0x0, (%rax)
jle 0x2a8d
xorl %ebx, %ebx
leaq 0x13194(%rip), %r13     # 0x15b88
leaq 0x131b5(%rip), %rbp     # 0x15bb0
movq (%rbp,%rbx,8), %rdi
callq 0xc4e9
incq %rbx
movslq (%r13), %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
jl 0x29fb
jmp 0x286b
cmpl 0x8(%rsp), %r12d
jge 0x2ec9
movq 0x8(%r14,%rbx,8), %rdi
leaq 0x28(%rsp), %rsi
movl $0xa, %edx
callq 0x2210
movq 0x28(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x2ec9
leal -0x41(%rax), %ecx
cmpl $-0x3c, %ecx
jbe 0x2ec9
incl %r12d
leaq 0x1308d(%rip), %rcx     # 0x15ae8
movl %eax, (%rcx)
jmp 0x2869
movq 0x1254f(%rip), %rax     # 0x14fb8
movq (%rax), %rax
leaq 0x14bed(%rip), %rcx     # 0x17660
movq %rax, (%rcx)
jmp 0x2869
leaq 0x14bfe(%rip), %rax     # 0x17680
movl $0x1, (%rax)
jmp 0x2869
xorl %eax, %eax
jmp 0x286b
leaq 0x14bcd(%rip), %rax     # 0x17668
incl (%rax)
jmp 0x2869
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2ad1
leaq 0xc747(%rip), %rsi      # 0xf1fa
callq 0x2270
movq %rax, %rbx
testq %rax, %rax
jne 0x2ad3
movl $0x1, %eax
jmp 0x2e27
xorl %eax, %eax
jmp 0x2e27
xorl %ebx, %ebx
leaq 0x12776(%rip), %rdi     # 0x15250
callq 0xa297
xorl %r14d, %r14d
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc797
leaq 0xc706(%rip), %rdi      # 0xf1fd
callq 0x22e0
movq %rax, %rdi
callq 0xe34f
leaq 0x13085(%rip), %rcx     # 0x15b90
movq %rax, (%rcx)
movl $0x1, %edi
callq 0x7766
leaq 0x13081(%rip), %rcx     # 0x15ba0
movq %rax, (%rcx)
leaq 0x10(%rsp), %rdi
callq 0xe085
leal -0x1(%r15), %eax
movl %eax, %ebp
movq %r15, (%rsp)
testl %r15d, %r15d
jle 0x2b6d
leaq 0x1(%rbp), %r13
leaq 0x10(%rsp), %r15
movq 0x138(%rsp,%r13,8), %r12
movq %r12, %rdi
callq 0xe006
testq %rax, %rax
je 0x2e55
movq %r15, %rdi
movq %rax, %rsi
callq 0xe0ab
decq %r13
jg 0x2b44
leaq 0x14ad4(%rip), %rax     # 0x17648
movq (%rax), %rax
movl %r14d, 0x8(%rax)
leaq 0x126ce(%rip), %rcx     # 0x15250
movq %rcx, 0x18(%rax)
leaq 0x14acb(%rip), %rax     # 0x17658
movq $0x0, (%rax)
leaq 0x12fc5(%rip), %rax     # 0x15b60
movl %r14d, (%rax)
leaq 0x12fbf(%rip), %rax     # 0x15b64
movl %r14d, (%rax)
leaq 0x12fb9(%rip), %rax     # 0x15b68
movl %r14d, (%rax)
leaq 0x12fb7(%rip), %rax     # 0x15b70
movl $0x1, (%rax)
leaq 0x12fa6(%rip), %rax     # 0x15b6c
movl %r14d, (%rax)
leaq 0x12fa4(%rip), %rcx     # 0x15b74
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rcx)
leaq 0x125c6(%rip), %rcx     # 0x151a4
movl $0x7fff, (%rcx)         # imm = 0x7FFF
leaq 0x148c5(%rip), %r13     # 0x174b0
movl %eax, (%r13)
leaq 0x14a4a(%rip), %rcx     # 0x17640
movl %eax, (%rcx)
leaq 0x12f85(%rip), %rax     # 0x15b84
movl %r14d, (%rax)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x339d
leaq 0x14a50(%rip), %rax     # 0x17668
cmpl %r14d, (%rax)
je 0x2c2f
leaq 0x14a3c(%rip), %rax     # 0x17660
cmpq $0x0, (%rax)
je 0x2c2f
callq 0xb9e2
cmpq $0x0, 0x10(%rsp)
jne 0x2e9b
callq 0x5e9b
movq %rbx, %rdi
callq 0x6a55
leaq 0x28(%rsp), %rdi
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc797
leaq 0x10(%rsp), %rdi
callq 0xe085
cmpl $0x0, (%rsp)
jle 0x2c9b
incq %rbp
leaq 0x10(%rsp), %r15
movq 0x138(%rsp,%rbp,8), %r12
movq %r12, %rdi
callq 0xe006
testq %rax, %rax
je 0x2e55
movq %r15, %rdi
movq %rax, %rsi
callq 0xe0ab
decq %rbp
jg 0x2c72
leaq 0x149a6(%rip), %rax     # 0x17648
movq (%rax), %rax
movl %r14d, 0x8(%rax)
leaq 0x125a0(%rip), %rcx     # 0x15250
movq %rcx, 0x18(%rax)
leaq 0x1499d(%rip), %rax     # 0x17658
movq $0x0, (%rax)
movl $0x1, %eax
leaq 0x12e92(%rip), %rcx     # 0x15b60
movl %eax, (%rcx)
leaq 0x12e8d(%rip), %rcx     # 0x15b64
movl %r14d, (%rcx)
leaq 0x12e87(%rip), %rcx     # 0x15b68
movl %r14d, (%rcx)
leaq 0x12e85(%rip), %rcx     # 0x15b70
movl %eax, (%rcx)
leaq 0x12e78(%rip), %rax     # 0x15b6c
movl %r14d, (%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x12e71(%rip), %rax     # 0x15b74
movl %ebp, (%rax)
leaq 0x12498(%rip), %rax     # 0x151a4
movl $0x7fff, (%rax)         # imm = 0x7FFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x6789
leaq 0x1491d(%rip), %rax     # 0x17640
movl %ebp, (%rax)
leaq 0x12e58(%rip), %rax     # 0x15b84
movl %r14d, (%rax)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x339d
movl %eax, %ebp
movq %r14, %rdi
callq 0xc7ca
movl (%r13), %eax
testl %eax, %eax
js 0x2d9b
leaq 0x12f56(%rip), %r15     # 0x15cb0
leaq 0xc4ee(%rip), %r14      # 0xf24f
leaq 0x12e48(%rip), %r12     # 0x15bb0
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movq 0x8(%r15,%rax,8), %rdx
movl 0x10(%r15,%rax,8), %ecx
xorl %edi, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x7b5a
movl (%r13), %edi
decl %edi
callq 0x6789
incl %ebp
movl (%r13), %eax
testl %eax, %eax
jns 0x2d68
jmp 0x2da2
leaq 0x12e0e(%rip), %r12     # 0x15bb0
leaq 0x12ddf(%rip), %r15     # 0x15b88
cmpl $0x0, (%r15)
jle 0x2dc6
xorl %r14d, %r14d
movq (%r12,%r14,8), %rdi
callq 0xc225
incq %r14
movslq (%r15), %rax
cmpq %rax, %r14
jl 0x2db2
movq %rbx, %rdi
callq 0xdcf3
testq %rbx, %rbx
je 0x2ddb
movq %rbx, %rdi
callq 0x20d0
testl %ebp, %ebp
movq 0x18(%rsp), %r14
jg 0x2e39
leaq 0x14875(%rip), %rax     # 0x17660
cmpq $0x0, (%rax)
je 0x2df6
callq 0xb9e2
leaq 0x14863(%rip), %rax     # 0x17660
movq (%rax), %rbx
testq %rbx, %rbx
je 0x2e20
leaq 0xc38b(%rip), %rsi      # 0xf197
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
je 0x2e20
movq %rbx, %rdi
callq 0x20d0
xorl %eax, %eax
testl %ebp, %ebp
setg %al
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x121b8(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xc426(%rip), %rsi      # 0xf270
movl %ebp, %edx
xorl %eax, %eax
callq 0x21e0
jmp 0x2de4
leaq 0xc3a8(%rip), %rsi      # 0xf204
xorl %edi, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x7b5a
movl $0x1, %edi
callq 0x22c0
callq 0x244a
callq 0x242b
callq 0x240c
callq 0x2ee2
jmp 0x2e68
callq 0x23c5
incq %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23e4
leaq 0xc37a(%rip), %rdi      # 0xf21c
leaq 0xc385(%rip), %rsi      # 0xf22e
leaq 0xc388(%rip), %rcx      # 0xf238
movl $0x174, %edx            # imm = 0x174
callq 0x2120
callq 0x23a6
callq 0x2387
callq 0x2368
leaq 0xc2eb(%rip), %rdi      # 0xf1bb
callq 0x25fc
callq 0x2349
movq %rbp, %rdi
callq 0x2320