// File: /workspace/github_cpp_makefile_star2_O3/FreeSlave[P]def2fgd/src/main.cpp
// Function: main
int main(int argc, char** argv)
{
    const char* format = "";
    const char* inputFileName = 0;
    const char* outputFileName = 0;
    FGDWriteOptions options;

    const char* package = "def2fgd";
    const char* localeDir = LOCALEDIR;

    generateLocale(package, localeDir);

    std::vector<const char*> positionalArgs;
    const char* programName = argv[0];
    for(int i=1; i<argc; ++i) {
        const char* arg = argv[i];
        if (strcmp(arg, "-format") == 0) {
            if (format[0]) {
                fputs(translate("-format option repetition\n").c_str(), stderr);
                return EXIT_FAILURE;
            }

            i++;
            if (i < argc) {
                format = argv[i];
            } else {
                fputs(translate("-format requires argument\n").c_str(), stderr);
                return EXIT_FAILURE;
            }
        } else if (strcmp(arg, "-bob") == 0) {
            if (options.bob) {
                printBobparms(options);
                return EXIT_FAILURE;
            }

            options.bobparms[0] = 180;
            options.bobparms[1] = 8;
            options.bobparms[2] = 0;
            options.bob = true;
        } else if (strcmp(arg, "-bobparms") == 0) {
            if (options.bob) {
                printBobparms(options);
                return EXIT_FAILURE;
            }

            i++;
            if (i < argc) {
                char* current = argv[i];
                options.bobparms[0] = static_cast<int>(strtol(current, &current, 10));
                options.bobparms[1] = static_cast<int>(strtol(current, &current, 10));
                options.bobparms[2] = static_cast<int>(strtol(current, NULL, 10));
                options.bob = true;
            } else {
                fputs(translate("-bobparms requires argument\n").c_str(), stderr);
                return EXIT_FAILURE;
            }
        } else if (strcmp(arg, "-offset-glob") == 0) {
            i++;
            if (i < argc) {
                options.offsetPatterns.push_back(argv[i]);
            } else {
                fputs(translate("-offset-glob requires argument\n").c_str(), stderr);
                return EXIT_FAILURE;
            }
        } else if (strcmp(arg, "-bob-glob") == 0) {
            i++;
            if (i < argc) {
                options.bobPatterns.push_back(argv[i]);
            } else {
                fputs(translate("-bob-glob requires argument\n").c_str(), stderr);
                return EXIT_FAILURE;
            }

        } else if (strcmp(arg, "-noauto-bob-glob") == 0) {
            options.useDefaultBobPatterns = false;
        } else if (strcmp(arg, "-noauto-offset-glob") == 0) {
            options.useDefaultOffsetPatterns = false;
        } else if (strcmp(arg, "-help") == 0 || strcmp(arg, "--help") == 0 || strcmp(arg, "-h") == 0) {
            printHelp(programName);
            return EXIT_SUCCESS;
        } else if (strcmp(arg, "-version") == 0 || strcmp(arg, "--version") == 0) {
            printVersion();
            return EXIT_SUCCESS;
        } else if (strcmp(arg, "--") == 0) {
            for (; ++i<argc;) {
                positionalArgs.push_back(argv[i]);
            }
        } else if (arg[0] == '-' && arg[1] != '\0') {
            fprintf(stderr, translate("Unknown parameter: %s\n").c_str(), arg);
            printHint(argv[0]);
            return EXIT_FAILURE;
        } else {
            positionalArgs.push_back(arg);
        }
    }

    if (positionalArgs.size() > 0) {
        inputFileName = positionalArgs[0];
        if (positionalArgs.size() > 1) {
            outputFileName = positionalArgs[1];
        }
    }

    if (inputFileName && strcmp(inputFileName, "-") == 0) {
        inputFileName = 0;
    }

    if (outputFileName && strcmp(outputFileName, "-") == 0) {
        outputFileName = 0;
    }

    if (format[0] == '\0') {
        if (inputFileName) {
            const char* extension = strrchr(inputFileName, '.');
            if (extension && strcmp(extension, ".ent") == 0){
                format = "ent";
            } else if (extension && strcmp(extension, ".def") == 0) {
                format = "def";
            } else {
                fputs(translate("Could not detect input format. Use -format option to explicitly set it.\n").c_str(), stderr);
                return EXIT_FAILURE;
            }
        } else {
            fputs(translate("No input file name nor format given.\n").c_str(), stderr);
            printHint(argv[0]);
            return EXIT_FAILURE;
        }
    }

    std::istream* inStream = &std::cin;
    std::ostream* outStream = &std::cout;

    std::ifstream inFile;
    std::ofstream outFile;

    if (inputFileName != 0) {
        inFile.open(inputFileName);
        if (!inFile) {
            fprintf(stderr, translate("Could not open file %s for reading: %s\n").c_str(), inputFileName, strerror(errno));
            return EXIT_FAILURE;
        }
        inStream = &inFile;
    }

    try
    {
        std::vector<Entity> entities;
        if (strcmp(format, "def") == 0) {
            entities = readDefFile(*inStream);
        } else if (strcmp(format, "ent") == 0) {
            entities = readEntFile(*inStream);
        } else {
            fprintf(stderr, translate("Unknown format '%s'\n").c_str(), format);
            return EXIT_FAILURE;
        }

        if (outputFileName) {
            outFile.open(outputFileName);
            if (!outFile) {
                fprintf(stderr, translate("Could not open file %s for writing: %s\n").c_str(), outputFileName, strerror(errno));
                return EXIT_FAILURE;
            }
            outStream = &outFile;
        }

        writefgd(*outStream, entities, options);
        outStream->flush();
    }
    catch(DefReadError& e)
    {
        if (inputFileName) {
            fprintf(stderr, translate("%s:%d:%d: error: %s\n").c_str(), inputFileName, e.line(), e.column(), e.what());
        } else {
            fprintf(stderr, translate("%d:%d: error: %s\n").c_str(), e.line(), e.column(), e.what());
        }

        return EXIT_FAILURE;
    }
    catch(std::exception& e)
    {
        fprintf(stderr, translate("Error: %s\n").c_str(), e.what());
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4c8, %rsp            # imm = 0x4C8
movq %rsi, %r14
movl %edi, %r12d
movw $0x100, 0x64(%rsp)      # imm = 0x100
movb $0x1, 0x66(%rsp)
movl $0x0, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rsp)
movups %xmm0, 0x78(%rsp)
movups %xmm0, 0x88(%rsp)
leaq 0x6a45(%rip), %rdi      # 0xb5f8
leaq 0x6a46(%rip), %rsi      # 0xb600
leaq 0x662d(%rip), %r13      # 0xb1ee
movq %r13, %rdx
callq 0xaed8
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
cmpl $0x2, %r12d
jl 0x4f4e
leaq 0x68(%rsp), %rbx
movq (%r14), %rax
movq %rax, 0x98(%rsp)
movl $0x1, %ebp
leaq 0x65ee(%rip), %r13      # 0xb1ee
movslq %ebp, %rax
movq (%r14,%rax,8), %r15
movq %r15, 0x2c8(%rsp)
movq %r15, %rdi
leaq 0x69ee(%rip), %rsi      # 0xb607
callq 0x3310
testl %eax, %eax
je 0x4d6b
movq %r15, %rdi
leaq 0x6a15(%rip), %rsi      # 0xb645
callq 0x3310
testl %eax, %eax
je 0x4d8d
movq %r15, %rdi
leaq 0x6a03(%rip), %rsi      # 0xb64a
callq 0x3310
testl %eax, %eax
je 0x4db1
movq %r15, %rdi
leaq 0x6a68(%rip), %rsi      # 0xb6c6
callq 0x3310
testl %eax, %eax
je 0x4e35
movq %r15, %rdi
leaq 0x6a40(%rip), %rsi      # 0xb6b5
callq 0x3310
testl %eax, %eax
je 0x4e61
movq %r15, %rdi
leaq 0x6a22(%rip), %rsi      # 0xb6ae
callq 0x3310
testl %eax, %eax
je 0x4e96
movq %r15, %rdi
leaq 0x6a1c(%rip), %rsi      # 0xb6bf
callq 0x3310
testl %eax, %eax
je 0x4eaa
movq %r15, %rdi
leaq 0x6a1a(%rip), %rsi      # 0xb6d4
callq 0x3310
testl %eax, %eax
je 0x52d1
movq %r15, %rdi
leaq 0x6a02(%rip), %rsi      # 0xb6d3
callq 0x3310
testl %eax, %eax
je 0x52d1
movb (%r15), %bl
cmpb $0x2d, %bl
jne 0x4cf8
cmpb $0x68, 0x1(%r15)
jne 0x4cf8
cmpb $0x0, 0x2(%r15)
je 0x52d1
movq %r15, %rdi
leaq 0x69d9(%rip), %rsi      # 0xb6db
callq 0x3310
testl %eax, %eax
je 0x52f1
movq %r15, %rdi
leaq 0x69c1(%rip), %rsi      # 0xb6da
callq 0x3310
testl %eax, %eax
je 0x52f1
cmpb $0x2d, %bl
leaq 0x68(%rsp), %rbx
jne 0x4d4d
cmpb $0x2d, 0x1(%r15)
jne 0x4d42
cmpb $0x0, 0x2(%r15)
je 0x4edd
cmpb $0x0, 0x1(%r15)
jne 0x53ed
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x4ec6
movq %r15, (%rsi)
addq $0x8, 0x28(%rsp)
jmp 0x4e25
cmpb $0x0, (%r13)
jne 0x530d
incl %ebp
cmpl %r12d, %ebp
jge 0x5333
movslq %ebp, %rax
movq (%r14,%rax,8), %r13
jmp 0x4e25
cmpb $0x0, 0x64(%rsp)
jne 0x51b4
movabsq $0x8000000b4, %rax      # imm = 0x8000000B4
movq %rax, 0x58(%rsp)
movl $0x0, 0x60(%rsp)
jmp 0x4e20
cmpb $0x1, 0x64(%rsp)
je 0x51b4
incl %ebp
cmpl %r12d, %ebp
jge 0x537c
movslq %ebp, %rax
movq (%r14,%rax,8), %rdi
movq %rdi, 0xc0(%rsp)
leaq 0xc0(%rsp), %r15
movq %r15, %rsi
movl $0xa, %edx
callq 0x3320
movl %eax, 0x58(%rsp)
movq 0xc0(%rsp), %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x3320
movl %eax, 0x5c(%rsp)
movq 0xc0(%rsp), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x3320
movl %eax, 0x60(%rsp)
movb $0x1, 0x64(%rsp)
incl %ebp
cmpl %r12d, %ebp
jl 0x4c00
jmp 0x4f29
incl %ebp
cmpl %r12d, %ebp
jge 0x539f
movslq %ebp, %rax
leaq (%r14,%rax,8), %rdx
movq 0x70(%rsp), %rsi
cmpq 0x78(%rsp), %rsi
je 0x4e9d
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x70(%rsp)
jmp 0x4e25
incl %ebp
cmpl %r12d, %ebp
jge 0x53c2
movslq %ebp, %rax
leaq (%r14,%rax,8), %rdx
movq 0x88(%rsp), %rsi
cmpq 0x90(%rsp), %rsi
je 0x4eb4
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x88(%rsp)
jmp 0x4e25
movb $0x0, 0x65(%rsp)
jmp 0x4e25
movq %rbx, %rdi
callq 0x605c
jmp 0x4e25
movb $0x0, 0x66(%rsp)
jmp 0x4e25
leaq 0x80(%rsp), %rdi
callq 0x605c
jmp 0x4e25
leaq 0x20(%rsp), %rdi
leaq 0x2c8(%rsp), %rdx
callq 0x605c
jmp 0x4e25
incl %ebp
cmpl %r12d, %ebp
jge 0x4e25
movslq %ebp, %rax
leaq (%r14,%rax,8), %r15
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x4f09
movq (%r15), %rax
movq %rax, (%rsi)
addq $0x8, 0x28(%rsp)
jmp 0x4f16
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x605c
addq $0x8, %r15
incl %ebp
cmpl %ebp, %r12d
jne 0x4eef
movl %r12d, %ebp
jmp 0x4e25
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rax, %rcx
je 0x4f4e
movq (%rax), %r15
cmpq $0x9, %rcx
jb 0x51c5
movq 0x8(%rax), %r12
jmp 0x51c8
cmpb $0x0, (%r13)
je 0x5263
xorl %r12d, %r12d
xorl %r15d, %r15d
leaq 0xc0(%rsp), %rdi
callq 0x32b0
leaq 0x2c8(%rsp), %rdi
callq 0x33e0
testq %r15, %r15
je 0x4fd8
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x3180
movq 0xc0(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0xe0(%rsp,%rax)
je 0x4fdf
movq 0xb00d(%rip), %rax      # 0xffc0
movq (%rax), %rbx
leaq 0x67b7(%rip), %rsi      # 0xb774
movq %rsp, %rdi
callq 0xaed9
movq %rsp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x374a
jmp 0x52c7
movq 0xaff1(%rip), %r14      # 0xffd0
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x670a(%rip), %rsi      # 0xb701
movq %r13, %rdi
callq 0x3310
testl %eax, %eax
je 0x502c
leaq 0x66f2(%rip), %rsi      # 0xb6fc
movq %r13, %rdi
callq 0x3310
testl %eax, %eax
jne 0x5296
leaq 0xa0(%rsp), %rdi
movq %r14, %rsi
callq 0x88fb
jmp 0x503c
leaq 0xa0(%rsp), %rdi
movq %r14, %rsi
callq 0x61cf
movq 0x50(%rsp), %rax
leaq 0xa0(%rsp), %rbx
movaps (%rbx), %xmm0
movq 0x10(%rbx), %rcx
movq %rcx, 0x50(%rsp)
movaps 0x40(%rsp), %xmm1
movaps %xmm0, 0x40(%rsp)
movq %rsp, %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
callq 0x5956
movq %rbx, %rdi
callq 0x5956
testq %r12, %r12
je 0x50e3
leaq 0x2c8(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x10, %edx
callq 0x3070
movq 0x2c8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x2e8(%rsp,%rax)
je 0x50ea
movq 0xaf02(%rip), %rax      # 0xffc0
movq (%rax), %rbx
leaq 0x66e9(%rip), %rsi      # 0xb7b1
movq %rsp, %rdi
callq 0xaed9
movq %rsp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x37cd
jmp 0x52bd
movq 0xaece(%rip), %rbx      # 0xffb8
leaq 0x40(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x3be4
movq %rbx, %rdi
callq 0x31b0
leaq 0x40(%rsp), %rdi
callq 0x5956
xorl %ebx, %ebx
movq 0xae81(%rip), %rax      # 0xff98
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x2d0(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x2c8(%rsp,%rcx)
callq 0x3210
leaq 0x3c0(%rsp), %rdi
callq 0x30e0
leaq 0xc0(%rsp), %rdi
callq 0x3090
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x516c
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3250
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x5189
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x3250
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x51a0
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x3250
movl %ebx, %eax
addq $0x4c8, %rsp            # imm = 0x4C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ebx
leaq 0x58(%rsp), %rdi
callq 0x34ec
jmp 0x5155
xorl %r12d, %r12d
testq %r15, %r15
je 0x51e0
cmpb $0x2d, (%r15)
jne 0x51e3
xorl %eax, %eax
cmpb $0x0, 0x1(%r15)
cmoveq %rax, %r15
jmp 0x51e3
xorl %r15d, %r15d
testq %r12, %r12
je 0x51fd
cmpb $0x2d, (%r12)
jne 0x5200
xorl %eax, %eax
cmpb $0x0, 0x1(%r12)
cmoveq %rax, %r12
jmp 0x5200
xorl %r12d, %r12d
cmpb $0x0, (%r13)
jne 0x4f5f
testq %r15, %r15
je 0x5263
movq %r15, %rdi
movl $0x2e, %esi
callq 0x3290
testq %rax, %rax
je 0x5359
movq %rax, %rbx
leaq 0x64cb(%rip), %rsi      # 0xb6fb
movq %rax, %rdi
callq 0x3310
testl %eax, %eax
je 0x52e5
leaq 0x64b9(%rip), %rsi      # 0xb700
movq %rbx, %rdi
callq 0x3310
testl %eax, %eax
jne 0x5359
leaq 0x64a3(%rip), %r13      # 0xb701
jmp 0x4f5f
leaq 0x64e4(%rip), %rsi      # 0xb74e
leaq 0xc0(%rsp), %rdi
callq 0xaed9
leaq 0xc0(%rsp), %rdi
callq 0x3867
movq (%r14), %rdi
movl $0x1, %ebx
callq 0x3490
jmp 0x5155
movq 0xad23(%rip), %rax      # 0xffc0
movq (%rax), %r14
leaq 0x64f5(%rip), %rsi      # 0xb79c
movq %rsp, %rdi
callq 0xaed9
movq %rsp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x37a0
leaq 0x40(%rsp), %rdi
callq 0x5956
movl $0x1, %ebx
jmp 0x5110
xorl %ebx, %ebx
movq 0x98(%rsp), %rdi
callq 0x4b01
jmp 0x5155
leaq 0x6410(%rip), %r13      # 0xb6fc
jmp 0x4f5f
leaq 0x6292(%rip), %rdi      # 0xb58a
leaq 0x5d39(%rip), %rsi      # 0xb038
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x3060
jmp 0x5155
leaq 0x62fb(%rip), %rsi      # 0xb60f
leaq 0xc0(%rsp), %rdi
callq 0xaed9
leaq 0xc0(%rsp), %rdi
callq 0x36bd
jmp 0x53e3
leaq 0x62f0(%rip), %rsi      # 0xb62a
leaq 0xc0(%rsp), %rdi
callq 0xaed9
leaq 0xc0(%rsp), %rdi
callq 0x36ec
jmp 0x53e3
leaq 0x63a5(%rip), %rsi      # 0xb705
leaq 0xc0(%rsp), %rdi
callq 0xaed9
leaq 0xc0(%rsp), %rdi
callq 0x371b
jmp 0x53e3
leaq 0x62d1(%rip), %rsi      # 0xb654
leaq 0xc0(%rsp), %rdi
callq 0xaed9
leaq 0xc0(%rsp), %rdi
callq 0x368e
jmp 0x53e3
leaq 0x62cb(%rip), %rsi      # 0xb671
leaq 0xc0(%rsp), %rdi
callq 0xaed9
leaq 0xc0(%rsp), %rdi
callq 0x365f
jmp 0x53e3
leaq 0x62c8(%rip), %rsi      # 0xb691
leaq 0xc0(%rsp), %rdi
callq 0xaed9
leaq 0xc0(%rsp), %rdi
callq 0x3630
movl $0x1, %ebx
jmp 0x5155
movq 0xabcc(%rip), %rax      # 0xffc0
movq (%rax), %rbx
leaq 0x62e6(%rip), %rsi      # 0xb6e4
leaq 0xc0(%rsp), %rdi
callq 0xaed9
leaq 0xc0(%rsp), %rdi
leaq 0x2c8(%rsp), %rsi
movq %rbx, %rdx
callq 0x35fd
movq (%r14), %rdi
movl $0x1, %ebx
callq 0x3490
jmp 0x5155
jmp 0x547b
jmp 0x547b
jmp 0x547b
jmp 0x547b
jmp 0x547b
jmp 0x547b
jmp 0x547b
jmp 0x547b
jmp 0x547b
jmp 0x547b
jmp 0x54ac
jmp 0x54ac
jmp 0x54ac
jmp 0x54ac
jmp 0x5453
movq %rax, %rbx
leaq 0x2c8(%rsp), %rdi
callq 0x3370
jmp 0x546c
jmp 0x547b
jmp 0x547b
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x3090
jmp 0x547e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x549a
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3250
jmp 0x549a
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x59ac
movq %rbx, %rdi
callq 0x3420
movq %rdx, %r14
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5956
cmpl $0x2, %r14d
jne 0x552d
movq %rbx, %rdi
callq 0x3110
movq %rax, %r14
movq 0xaaec(%rip), %rax      # 0xffc0
movq (%rax), %rbx
testq %r15, %r15
jne 0x5578
leaq 0x6300(%rip), %rsi      # 0xb7e7
movq %rsp, %rdi
callq 0xaed9
movq (%rsp), %r15
movq %r14, %rdi
callq 0x61c4
movq %rax, %r12
movq %r14, %rdi
callq 0x61ca
movq %rax, %r13
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x3340
jmp 0x55c3
cmpl $0x1, %r14d
jne 0x5456
movq %rbx, %rdi
callq 0x3110
movq %rax, %rbx
movq 0xaa77(%rip), %rax      # 0xffc0
movq (%rax), %r14
leaq 0x6286(%rip), %rsi      # 0xb7d9
movq %rsp, %rdi
callq 0xaed9
movq %rsp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3823
movl $0x1, %ebx
callq 0x33c0
jmp 0x5110
leaq 0x6265(%rip), %rsi      # 0xb7e4
movq %rsp, %rdi
callq 0xaed9
movq (%rsp), %r12
movq %r14, %rdi
callq 0x61c4
movq %rax, %r13
movq %r14, %rdi
callq 0x61ca
movq %rax, %rbp
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %rbp, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x3340
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55de
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3250
movl $0x1, %ebx
callq 0x33c0
jmp 0x5110
jmp 0x5453
jmp 0x5453
jmp 0x55f9
movq %rax, %rbx
jmp 0x562b
jmp 0x560d
movq %rax, %rbx
callq 0x33c0
jmp 0x5456
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x562b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3250
callq 0x33c0
jmp 0x5456
movq %rax, %rdi
callq 0x59a0
nop