// File: /workspace/github_c_makefile_star2_O3/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 0x2e05
movq %rsi, %r14
leal -0x1(%rdi), %eax
movq %rax, 0x8(%rsp)
movl $0x1, %ebp
xorl %r15d, %r15d
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq %rdi, (%rsp)
movslq %ebp, %r12
movq (%r14,%r12,8), %rbx
cmpb $0x2d, (%rbx)
jne 0x27bb
leaq 0x1(%rbx), %r13
movq %r13, %rdi
leaq 0xcedc(%rip), %rsi      # 0xf553
callq 0x2070
testl %eax, %eax
je 0x27ce
movq %r13, %rdi
leaq 0xc976(%rip), %rsi      # 0xf004
callq 0x2070
testl %eax, %eax
je 0x27d8
movq %r13, %rdi
leaq 0xcdd2(%rip), %rsi      # 0xf477
callq 0x2070
testl %eax, %eax
je 0x27e9
movq %r13, %rdi
leaq 0xdf65(%rip), %rsi      # 0x10621
callq 0x2070
testl %eax, %eax
je 0x2821
movq %r13, %rdi
leaq 0xc98c(%rip), %rsi      # 0xf05f
callq 0x2070
testl %eax, %eax
je 0x286c
movq %r13, %rdi
leaq 0xcdeb(%rip), %rsi      # 0xf4d5
callq 0x2070
testl %eax, %eax
je 0x28cf
movq %r13, %rdi
leaq 0xe382(%rip), %rsi      # 0x10a83
callq 0x2070
testl %eax, %eax
je 0x28f2
movq %r13, %rdi
leaq 0xdcdc(%rip), %rsi      # 0x103f4
callq 0x2070
testl %eax, %eax
je 0x291d
movq %r13, %rdi
leaq 0xca87(%rip), %rsi      # 0xf1b6
callq 0x2070
testl %eax, %eax
je 0x2941
movq %r13, %rdi
leaq 0xca50(%rip), %rsi      # 0xf196
callq 0x2070
testl %eax, %eax
je 0x2d97
movq %r13, %rdi
leaq 0xca57(%rip), %rsi      # 0xf1b4
callq 0x2070
testl %eax, %eax
je 0x2978
movq %r13, %rdi
leaq 0xca65(%rip), %rsi      # 0xf1d9
callq 0x2070
testl %eax, %eax
je 0x29e2
movq %r13, %rdi
leaq 0xca52(%rip), %rsi      # 0xf1dd
callq 0x2070
testl %eax, %eax
je 0x29f4
movq %r13, %rdi
leaq 0xca3f(%rip), %rsi      # 0xf1e1
callq 0x2070
testl %eax, %eax
jne 0x2e50
leaq 0x133c2(%rip), %rax     # 0x15b78
jmp 0x29fb
movslq %r15d, %rax
incl %r15d
movq %rbx, 0x140(%rsp,%rax,8)
jmp 0x285d
callq 0x2e5d
jmp 0x2859
movq 0x12819(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
callq 0x30a2
jmp 0x2859
cmpl 0x8(%rsp), %ebp
jge 0x2df1
callq 0x2300
movq (%rax), %rax
movq 0x8(%r14,%r12,8), %rdi
movzbl (%rdi), %ecx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x2df1
incl %ebp
callq 0xe0d8
movq 0x8(%r14,%r12,8), %rdi
movl $0x1, %esi
jmp 0x2854
cmpl 0x8(%rsp), %ebp
jge 0x2df6
callq 0x2300
movq (%rax), %rax
movq 0x8(%r14,%r12,8), %rdi
movzbl (%rdi), %ecx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x2df6
incl %ebp
callq 0xe0d8
movq 0x8(%r14,%r12,8), %rdi
xorl %esi, %esi
callq 0x3123
movq (%rsp), %rdi
incl %ebp
cmpl %edi, %ebp
jl 0x2659
jmp 0x2a02
cmpl 0x8(%rsp), %ebp
jge 0x2dfb
movq 0x8(%r14,%r12,8), %rdi
cmpb $0x2d, (%rdi)
je 0x2dfb
movq 0x8(%rsp), %rax
movq (%r14,%rax,8), %rax
xorl %esi, %esi
cmpb $0x2d, (%rax)
jne 0x28a4
cmpb $0x78, 0x1(%rax)
jne 0x28a4
xorl %esi, %esi
cmpb $0x0, 0x2(%rax)
sete %sil
incl %ebp
callq 0xbcdc
leaq 0x132d6(%rip), %rdx     # 0x15b88
movslq (%rdx), %rcx
leaq 0x132f4(%rip), %rsi     # 0x15bb0
movq %rax, (%rsi,%rcx,8)
testq %rax, %rax
je 0x2e0c
incl %ecx
movl %ecx, (%rdx)
jmp 0x2859
cmpl 0x8(%rsp), %ebp
jge 0x2e00
movq 0x8(%r14,%r12,8), %rsi
cmpb $0x2d, (%rsi)
je 0x2e00
incl %ebp
leaq 0xdeaa(%rip), %rdi      # 0x1079a
jmp 0x2913
cmpl 0x8(%rsp), %ebp
jge 0x2e35
movq 0x8(%r14,%r12,8), %rsi
cmpb $0x2d, (%rsi)
je 0x2e35
incl %ebp
leaq 0xde68(%rip), %rdi      # 0x1077b
callq 0x31cc
jmp 0x2859
cmpl 0x8(%rsp), %ebp
jge 0x2e3a
movq 0x8(%r14,%r12,8), %rcx
movq %rcx, 0x20(%rsp)
cmpb $0x2d, (%rcx)
je 0x2e3a
incl %ebp
jmp 0x2859
cmpl 0x8(%rsp), %ebp
jge 0x2e3f
movq 0x8(%r14,%r12,8), %rax
cmpb $0x2d, (%rax)
movq %rax, 0x18(%rsp)
jne 0x29c0
cmpb $0x0, 0x1(%rax)
jne 0x2e3f
incl %ebp
cmpb $0x0, 0x1(%rax)
jne 0x29c2
movq 0x12645(%rip), %rax     # 0x14fb8
movq (%rax), %rax
jmp 0x29d3
cmpl 0x8(%rsp), %ebp
jge 0x2e44
movq 0x8(%r14,%r12,8), %rdi
leaq 0x28(%rsp), %rsi
movl $0xa, %edx
callq 0x2210
movq 0x28(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x2e44
leal -0x41(%rax), %ecx
cmpl $-0x3c, %ecx
jbe 0x2e44
incl %ebp
leaq 0x1312f(%rip), %rcx     # 0x15ae8
movl %eax, (%rcx)
jmp 0x2859
incl %ebp
movq 0x18(%rsp), %rdi
leaq 0xc7c6(%rip), %rsi      # 0xf194
callq 0x2270
leaq 0x14c86(%rip), %rcx     # 0x17660
movq %rax, (%rcx)
jmp 0x2859
leaq 0x14c97(%rip), %rax     # 0x17680
movl $0x1, (%rax)
jmp 0x2859
leaq 0x14c6d(%rip), %rax     # 0x17668
incl (%rax)
jmp 0x2859
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2a2a
leaq 0xc7e4(%rip), %rsi      # 0xf1f7
callq 0x2270
movq %rax, %rbx
testq %rax, %rax
jne 0x2a2c
movl $0x1, %ebx
jmp 0x2d67
xorl %ebx, %ebx
leaq 0x1281d(%rip), %rdi     # 0x15250
callq 0xa0d4
xorl %r14d, %r14d
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc52f
leaq 0xc7aa(%rip), %rdi      # 0xf1fa
callq 0x22e0
movq %rax, %rdi
callq 0xe094
leaq 0x1312c(%rip), %rcx     # 0x15b90
movq %rax, (%rcx)
movl $0x1, %edi
callq 0x7642
leaq 0x13128(%rip), %rcx     # 0x15ba0
movq %rax, (%rcx)
leaq 0x10(%rsp), %rdi
callq 0xddd0
leal -0x1(%r15), %eax
movl %eax, %ebp
movq %r15, (%rsp)
testl %r15d, %r15d
jle 0x2ac6
leaq 0x1(%rbp), %r13
leaq 0x10(%rsp), %r15
movq 0x138(%rsp,%r13,8), %r12
movq %r12, %rdi
callq 0xdd51
testq %rax, %rax
je 0x2dd4
movq %r15, %rdi
movq %rax, %rsi
callq 0xddf6
decq %r13
jg 0x2a9d
leaq 0x14b7b(%rip), %rax     # 0x17648
movq (%rax), %rax
movl %r14d, 0x8(%rax)
leaq 0x12775(%rip), %rcx     # 0x15250
movq %rcx, 0x18(%rax)
leaq 0x14b72(%rip), %rax     # 0x17658
movq $0x0, (%rax)
leaq 0x1306c(%rip), %rax     # 0x15b60
movl %r14d, (%rax)
leaq 0x13066(%rip), %rax     # 0x15b64
movl %r14d, (%rax)
leaq 0x13060(%rip), %rax     # 0x15b68
movl %r14d, (%rax)
leaq 0x1305e(%rip), %rax     # 0x15b70
movl $0x1, (%rax)
leaq 0x1304d(%rip), %rax     # 0x15b6c
movl %r14d, (%rax)
leaq 0x1304b(%rip), %rcx     # 0x15b74
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rcx)
leaq 0x1266d(%rip), %rcx     # 0x151a4
movl $0x7fff, (%rcx)         # imm = 0x7FFF
leaq 0x1496c(%rip), %r13     # 0x174b0
movl %eax, (%r13)
leaq 0x14af1(%rip), %rcx     # 0x17640
movl %eax, (%rcx)
leaq 0x1302c(%rip), %rax     # 0x15b84
movl %r14d, (%rax)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3325
leaq 0x14af7(%rip), %rax     # 0x17668
cmpl %r14d, (%rax)
leaq 0x14ae5(%rip), %rax     # 0x17660
je 0x2b88
cmpq $0x0, (%rax)
je 0x2b88
callq 0xb81f
cmpq $0x0, 0x10(%rsp)
jne 0x2e16
callq 0x5dab
movq %rbx, %rdi
callq 0x6958
leaq 0x28(%rsp), %rdi
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc52f
leaq 0x10(%rsp), %rdi
callq 0xddd0
cmpl $0x0, (%rsp)
jle 0x2bf4
incq %rbp
leaq 0x10(%rsp), %r15
movq 0x138(%rsp,%rbp,8), %r12
movq %r12, %rdi
callq 0xdd51
testq %rax, %rax
je 0x2dd4
movq %r15, %rdi
movq %rax, %rsi
callq 0xddf6
decq %rbp
jg 0x2bcb
leaq 0x14a4d(%rip), %rax     # 0x17648
movq (%rax), %rax
movl %r14d, 0x8(%rax)
leaq 0x12647(%rip), %rcx     # 0x15250
movq %rcx, 0x18(%rax)
leaq 0x14a44(%rip), %rax     # 0x17658
movq $0x0, (%rax)
movl $0x1, %eax
leaq 0x12f39(%rip), %rcx     # 0x15b60
movl %eax, (%rcx)
leaq 0x12f34(%rip), %rcx     # 0x15b64
movl %r14d, (%rcx)
leaq 0x12f2e(%rip), %rcx     # 0x15b68
movl %r14d, (%rcx)
leaq 0x12f2c(%rip), %rcx     # 0x15b70
movl %eax, (%rcx)
leaq 0x12f1f(%rip), %rax     # 0x15b6c
movl %r14d, (%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x12f18(%rip), %rax     # 0x15b74
movl %ebp, (%rax)
leaq 0x1253f(%rip), %rax     # 0x151a4
movl $0x7fff, (%rax)         # imm = 0x7FFF
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x668c
leaq 0x149c4(%rip), %rax     # 0x17640
movl %ebp, (%rax)
leaq 0x12eff(%rip), %rax     # 0x15b84
movl %r14d, (%rax)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x3325
movl %eax, %ebp
movq %r14, %rdi
callq 0xc562
movl (%r13), %eax
testl %eax, %eax
js 0x2ceb
leaq 0x12ffd(%rip), %r15     # 0x15cb0
leaq 0xc592(%rip), %r14      # 0xf24c
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 0x7a34
movl (%r13), %edi
decl %edi
callq 0x668c
incl %ebp
movl (%r13), %eax
testl %eax, %eax
jns 0x2cba
leaq 0x12e96(%rip), %r15     # 0x15b88
cmpl $0x0, (%r15)
leaq 0x12eb3(%rip), %r12     # 0x15bb0
jle 0x2d16
xorl %r14d, %r14d
movq (%r12,%r14,8), %rdi
callq 0xc009
incq %r14
movslq (%r15), %rax
cmpq %rax, %r14
jl 0x2d02
movq %rbx, %rdi
callq 0xda3b
testq %rbx, %rbx
je 0x2d2b
movq %rbx, %rdi
callq 0x20d0
testl %ebp, %ebp
leaq 0x1492c(%rip), %rbx     # 0x17660
movq 0x18(%rsp), %r14
jg 0x2d7b
cmpq $0x0, (%rbx)
je 0x2d60
callq 0xb81f
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2d60
cmpb $0x2d, (%r14)
jne 0x2d5b
cmpb $0x0, 0x1(%r14)
je 0x2d60
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 0x12276(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xc4e1(%rip), %rsi      # 0xf26d
movl %ebp, %edx
xorl %eax, %eax
callq 0x21e0
jmp 0x2d3b
cmpl 0x8(%rsp), %ebp
jne 0x2e58
leaq 0x12de0(%rip), %r15     # 0x15b88
cmpl $0x0, (%r15)
leaq 0x12dfd(%rip), %r12     # 0x15bb0
jle 0x2dd0
xorl %ebx, %ebx
xorl %r14d, %r14d
movq (%r12,%r14,8), %rdi
callq 0xc282
incq %r14
movslq (%r15), %rax
cmpq %rax, %r14
jl 0x2dba
jmp 0x2d67
xorl %ebx, %ebx
jmp 0x2d67
leaq 0xc426(%rip), %rsi      # 0xf201
xorl %edi, %edi
movq %r12, %rdx
xorl %eax, %eax
callq 0x7a34
movl $0x1, %edi
callq 0x22c0
callq 0x244a
callq 0x242b
callq 0x240c
callq 0x23c5
callq 0x2e5d
jmp 0x2de7
movl %ebp, %edi
movq %r14, %rsi
callq 0x23e4
leaq 0xc3fc(%rip), %rdi      # 0xf219
leaq 0xc407(%rip), %rsi      # 0xf22b
leaq 0xc40a(%rip), %rcx      # 0xf235
movl $0x174, %edx            # imm = 0x174
callq 0x2120
callq 0x23a6
callq 0x2387
callq 0x2368
leaq 0xc36d(%rip), %rdi      # 0xf1b8
callq 0x25fc
movq %rbx, %rdi
callq 0x2320
callq 0x2349