LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: Repeat(Expression*, Statement*)
Statement *Repeat(Expression* expression, Statement* body){
    Statement* repeat = new Statement('R');
    repeat->children.push_back(repeat);
    repeat->expressions.push_back(expression);
	return repeat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x38, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl $0x52, %esi
callq 0x75a0
jmp 0x7f00
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
leaq -0x18(%rbp), %rsi
callq 0xa420
movq -0x18(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0xa3b0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3230
movq -0x20(%rbp), %rdi
callq 0x34b0
nop
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: FunctionDef(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<Expression*, std::allocator<Expression*>>, Statement*)
Statement *FunctionDef(std::string& name, std::vector<Expression*> args, Statement* body){
	Statement* result = new Statement('F');
	Expression* nameExp = String(name);
	result->expressions.push_back(nameExp);
	// TODO: Add proper args support
    Statement* argscontainer = new Statement('E');
    argscontainer->expressions = args;
	result->children.push_back(argscontainer);
	result->children.push_back(body);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x38, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movl $0x46, %esi
callq 0x75a0
jmp 0x7f8b
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3100
movq -0x80(%rbp), %rdi
callq 0x7410
movq %rax, -0x78(%rbp)
jmp 0x7fb3
leaq -0x58(%rbp), %rdi
callq 0x3528
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa3b0
movl $0x38, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movl $0x45, %esi
callq 0x75a0
jmp 0x7ff4
movq -0x70(%rbp), %rsi
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0xa520
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
leaq -0x60(%rbp), %rsi
callq 0xa420
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
leaq -0x18(%rbp), %rsi
callq 0xa420
movq -0x20(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3230
jmp 0x8081
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3528
jmp 0x8081
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3230
movq -0x28(%rbp), %rdi
callq 0x34b0
nopw (%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: Return(std::__cxx11::list<Expression*, std::allocator<Expression*>>)
Statement *Return(std::list<Expression*> retvals){
    Statement *result = new Statement('r');
    for (Expression* exp : retvals){
        result->expressions.push_back(exp);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movl $0x72, %esi
callq 0x75a0
jmp 0x80c0
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa040
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa070
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa0a0
testb $0x1, %al
jne 0x80fd
jmp 0x813c
leaq -0x30(%rbp), %rdi
callq 0xa0d0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xa3b0
leaq -0x30(%rbp), %rdi
callq 0xa100
jmp 0x80ea
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3230
jmp 0x8146
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34b0
nop
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: convert[abi:cxx11](Expression*, BBlock*)
string convert(Expression *in, BBlock *out)
{
    map<Expression*,string> naming;
    namePass(in, naming);
    emitPass(in, naming, out);
    return naming[in];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xaab0
movq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x82f0
jmp 0x898e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rsi
callq 0x8530
jmp 0x89a1
leaq -0x48(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xa960
movq %rax, -0x78(%rbp)
jmp 0x89b4
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x3100
jmp 0x89c3
leaq -0x48(%rbp), %rdi
callq 0xaad0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xaad0
movq -0x50(%rbp), %rdi
callq 0x34b0
nopw (%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: convertAssign(Statement*, BBlock*)
void convertAssign(Statement *in, BBlock *out)
{
    std::string name = in->expressions.at(0)->name;
    std::string val = convert(in->expressions.at(1), out);
    ThreeAd ta = ThreeAd(name,'c',name,val);
    out->instructions.push_back(ta);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xaaf0
movq (%rax), %rsi
addq $0x30, %rsi
leaq -0x30(%rbp), %rdi
callq 0x3100
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xaaf0
movq %rax, -0x130(%rbp)
jmp 0x8a47
movq -0x130(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x8950
jmp 0x8a60
leaq -0xe8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3100
jmp 0x8a72
leaq -0x108(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3100
jmp 0x8a84
leaq -0x128(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3100
jmp 0x8a96
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
movl $0x63, %edx
leaq -0x108(%rbp), %rcx
leaq -0x128(%rbp), %r8
callq 0x6550
jmp 0x8abe
leaq -0x128(%rbp), %rdi
callq 0x3528
leaq -0x108(%rbp), %rdi
callq 0x3528
leaq -0xe8(%rbp), %rdi
callq 0x3528
movq -0x10(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xaa40
jmp 0x8af4
leaq -0xc8(%rbp), %rdi
callq 0x9db0
leaq -0x50(%rbp), %rdi
callq 0x3528
leaq -0x30(%rbp), %rdi
callq 0x3528
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8ba6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8b9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8b77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8b6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x3528
leaq -0x108(%rbp), %rdi
callq 0x3528
leaq -0xe8(%rbp), %rdi
callq 0x3528
jmp 0x8b9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x9db0
leaq -0x50(%rbp), %rdi
callq 0x3528
leaq -0x30(%rbp), %rdi
callq 0x3528
movq -0x58(%rbp), %rdi
callq 0x34b0
nopl (%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: convertComparitor(Expression*, BBlock*)
void convertComparitor(Expression *in, BBlock *out)
{
    std::string l = convert(in->left, out);
    std::string r = convert(in->right, out);
    std::string name = newName();
    ThreeAd ta = ThreeAd(name,in->op,l,r);
    out->instructions.push_back(ta);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x8950
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x8950
jmp 0x8bfe
leaq -0x80(%rbp), %rdi
callq 0x8150
jmp 0x8c09
leaq -0x108(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3100
jmp 0x8c1b
movq -0x8(%rbp), %rax
movb 0x29(%rax), %al
movb %al, -0x149(%rbp)
leaq -0x128(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3100
jmp 0x8c3a
leaq -0x148(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3100
jmp 0x8c4c
movb -0x149(%rbp), %al
movsbl %al, %edx
leaq -0xe8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
leaq -0x128(%rbp), %rcx
leaq -0x148(%rbp), %r8
callq 0x6550
jmp 0x8c78
leaq -0x148(%rbp), %rdi
callq 0x3528
leaq -0x128(%rbp), %rdi
callq 0x3528
leaq -0x108(%rbp), %rdi
callq 0x3528
movq -0x10(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0xaa40
jmp 0x8cae
leaq -0xe8(%rbp), %rdi
callq 0x9db0
leaq -0x80(%rbp), %rdi
callq 0x3528
leaq -0x50(%rbp), %rdi
callq 0x3528
leaq -0x30(%rbp), %rdi
callq 0x3528
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8d83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8d7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8d71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8d4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8d3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x3528
leaq -0x128(%rbp), %rdi
callq 0x3528
leaq -0x108(%rbp), %rdi
callq 0x3528
jmp 0x8d71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x9db0
leaq -0x80(%rbp), %rdi
callq 0x3528
leaq -0x50(%rbp), %rdi
callq 0x3528
leaq -0x30(%rbp), %rdi
callq 0x3528
movq -0x58(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: convertIf(Statement*, BBlock**)
void convertIf(Statement *in, BBlock **current)
{
    // Translate comparitor
    Expression* comparitor = in->expressions.back();
    convertComparitor(comparitor, *current);

    // Create true and false block
    BBlock* trueBlock = new BBlock();
    BBlock* trueBlockPtr = trueBlock;
    convertStatement(in->children.at(0), &trueBlockPtr);
    (*current)->trueExit = trueBlock;

    BBlock* falseBlock = new BBlock();
    BBlock* falseBlockPtr = falseBlock;
    convertStatement(in->children.at(1), &falseBlockPtr);
    (*current)->falseExit = falseBlock;

    // Create next block
    BBlock* nextBlock = new BBlock();
    trueBlock->trueExit = nextBlock;
    falseBlock->trueExit = nextBlock;

    *current = nextBlock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xab30
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x8bc0
movl $0x48, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x66a0
jmp 0x8deb
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xab70
movq (%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8f20
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movl $0x48, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x66a0
jmp 0x8e42
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl $0x1, %esi
callq 0xab70
movq (%rax), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8f20
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movl $0x48, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x66a0
jmp 0x8e9a
movq -0x68(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x50(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3230
jmp 0x8f0e
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3230
jmp 0x8f0e
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3230
movq -0x28(%rbp), %rdi
callq 0x34b0
nopw (%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: convertStatement(Statement*, BBlock**)
void convertStatement(Statement *in, BBlock **current)
{
    switch(in->kind)
    {
        case 'A':
            convertAssign(in,*current);   // Does not update current
            break;
        case 'F':
            convertFuncDef(in,*current);	// Does not update current
            break;
        case 'E':
            convertExpressions(in, *current); // Does not update current
            break;
        case 'r':
            convertReturn(in,*current); // Does not update current
            break;
        case 'L':
            convertLoop(in,current);
            break;
        case 'R':
            convertRepeat(in,current);
            break;
        case 'I':
            convertIf(in,current);
            break;
        case 'S':
            convertSeq(in,current);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x30(%rax), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x31, %eax
ja 0x8fe0
movq -0x18(%rbp), %rax
leaq 0x22183(%rip), %rcx     # 0x2b0d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x8a00
jmp 0x8fe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x8ff0
jmp 0x8fe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x96b0
jmp 0x8fe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x9730
jmp 0x8fe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x94d0
jmp 0x8fe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9360
jmp 0x8fe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8da0
jmp 0x8fe0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x92e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: convertRepeat(Statement*, BBlock**)
void convertRepeat(Statement *in, BBlock **current){
    Statement*  body = in->children.at(0);
    Expression* check = in->expressions.at(0);

    BBlock* bodyBlock = new BBlock();
    BBlock* checkBlock = new BBlock();
    BBlock* nextBlock = new BBlock();

    (*current)->trueExit = bodyBlock;

    (*current) = bodyBlock;
    convertStatement(body, current);
    bodyBlock->trueExit = checkBlock;
    
    (*current) = checkBlock;
    convertComparitor(check, *current);
    checkBlock->trueExit = bodyBlock;
    checkBlock->falseExit = nextBlock;

    (*current) = nextBlock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x58(%rbp)
callq 0xab70
movq -0x58(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xaaf0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x48, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x66a0
jmp 0x93bb
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x48, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x66a0
jmp 0x93de
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x48, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x66a0
jmp 0x9401
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8f20
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x8bc0
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x3230
jmp 0x94c3
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x3230
jmp 0x94c3
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x3230
movq -0x30(%rbp), %rdi
callq 0x34b0
nopl (%rax)
// File: johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: convertReturn(Statement*, BBlock*)
void convertReturn(Statement *in, BBlock *current){
    // TODO: Support for multiple return values
    Expression* retexp = in->expressions.at(0);
    std::string retval = convert(retexp, current);
    ThreeAd ta = ThreeAd("_r",'r',retval, retval);
    current->instructions.push_back(ta);
    
    /*for(Expression* exp: in->expressions){
        convert(exp, current);
    }*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xaaf0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x8950
leaq -0xc1(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x34c0
movq -0x120(%rbp), %rdx
leaq 0x24239(%rip), %rsi     # 0x2d9c2
leaq -0xc0(%rbp), %rdi
callq 0x3390
jmp 0x9797
leaq -0xf8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3100
jmp 0x97a9
leaq -0x118(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3100
jmp 0x97bb
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
movl $0x72, %edx
leaq -0xf8(%rbp), %rcx
leaq -0x118(%rbp), %r8
callq 0x6550
jmp 0x97e3
leaq -0x118(%rbp), %rdi
callq 0x3528
leaq -0xf8(%rbp), %rdi
callq 0x3528
leaq -0xc0(%rbp), %rdi
callq 0x3528
leaq -0xc1(%rbp), %rdi
callq 0x32c0
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xaa40
jmp 0x9825
leaq -0xa0(%rbp), %rdi
callq 0x9db0
leaq -0x38(%rbp), %rdi
callq 0x3528
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x98b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x98a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x989d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x3528
leaq -0xf8(%rbp), %rdi
callq 0x3528
leaq -0xc0(%rbp), %rdi
callq 0x3528
leaq -0xc1(%rbp), %rdi
callq 0x32c0
jmp 0x98e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x9db0
leaq -0x38(%rbp), %rdi
callq 0x3528
movq -0xd0(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/convert.cc
// Function: newLabel[abi:cxx11]()
std::string newLabel(){
	std::stringstream ss;
	ss << "label" << to_string(labelcount);
    std::string varname = ss.str();
    addVar(varname, VT_LABEL, "");
	labelcount++;
	return varname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x228(%rbp)
movq %rdi, %rax
movq %rax, -0x220(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x31d0
leaq -0x180(%rbp), %rdi
leaq 0x19e01(%rip), %rsi     # 0x2b51b
callq 0x3260
movq %rax, -0x218(%rbp)
jmp 0x11728
movl 0x2cd12(%rip), %esi     # 0x3e440
leaq -0x1c0(%rbp), %rdi
callq 0xa7a0
jmp 0x1173c
movq -0x218(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x3220
jmp 0x11751
leaq -0x1c0(%rbp), %rdi
callq 0x3528
movq -0x228(%rbp), %rdi
movb $0x0, -0x1c1(%rbp)
leaq -0x190(%rbp), %rsi
callq 0x3250
jmp 0x11779
movq -0x228(%rbp), %rsi
leaq -0x1e8(%rbp), %rdi
callq 0x3100
jmp 0x1178e
leaq -0x209(%rbp), %rdi
movq %rdi, -0x230(%rbp)
callq 0x34c0
movq -0x230(%rbp), %rdx
leaq 0x19d6b(%rip), %rsi     # 0x2b51a
leaq -0x208(%rbp), %rdi
callq 0x3390
jmp 0x117bd
leaq -0x1e8(%rbp), %rdi
movl $0x4, %esi
leaq -0x208(%rbp), %rdx
callq 0x11910
jmp 0x117d7
leaq -0x208(%rbp), %rdi
callq 0x3528
leaq -0x209(%rbp), %rdi
callq 0x32c0
leaq -0x1e8(%rbp), %rdi
callq 0x3528
movl 0x2cc3f(%rip), %eax     # 0x3e440
addl $0x1, %eax
movl %eax, 0x2cc36(%rip)     # 0x3e440
movb $0x1, -0x1c1(%rbp)
testb $0x1, -0x1c1(%rbp)
jne 0x118c9
jmp 0x118bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x118f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3528
jmp 0x118f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x118e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x118a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x3528
leaq -0x209(%rbp), %rdi
callq 0x32c0
leaq -0x1e8(%rbp), %rdi
callq 0x3528
jmp 0x118e5
movq -0x228(%rbp), %rdi
callq 0x3528
leaq -0x190(%rbp), %rdi
callq 0x31e0
movq -0x220(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x3528
leaq -0x190(%rbp), %rdi
callq 0x31e0
movq -0x198(%rbp), %rdi
callq 0x34b0
nopl (%rax)
// File: johan-bjareholt[P]lua-compiler/src/convert.cc
// Function: addVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static void addVar(std::string name, int type, std::string value){
    if (getVar(name) != nullptr){
        if (getVar(name)->first != VT_UNKNOWN)
            std::cout << "overriding value of " << name << "!" << std::endl;
        vars2.erase(name);
    }
    std::pair<int, std::string> var(type, value);
    std::pair<std::string, std::pair<int, std::string>> entry(name, var);
    vars2.insert(entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl %esi, %eax
movq %rdi, %rsi
movq %rsi, -0x108(%rbp)
movq %rdx, -0x100(%rbp)
movq %rsi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x3100
movq -0xf8(%rbp), %rdi
callq 0x15770
movq %rax, -0xf0(%rbp)
jmp 0x1195e
leaq -0x38(%rbp), %rdi
callq 0x3528
movq -0xf0(%rbp), %rax
cmpq $0x0, %rax
je 0x11a50
movq -0x108(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x3100
movq -0x118(%rbp), %rdi
callq 0x15770
movq %rax, -0x110(%rbp)
jmp 0x119a4
movq -0x110(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x11c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3528
movl -0x11c(%rbp), %eax
cmpl $0x5, %eax
je 0x11a3d
movq 0x2c5fa(%rip), %rdi     # 0x3dfc8
leaq 0x19f13(%rip), %rsi     # 0x2b8e8
callq 0x3260
movq -0x108(%rbp), %rsi
movq %rax, %rdi
callq 0x3220
movq %rax, %rdi
leaq 0x1b598(%rip), %rsi     # 0x2cf8b
callq 0x3260
movq %rax, %rdi
movq 0x2c59e(%rip), %rsi     # 0x3dfa0
callq 0x32a0
jmp 0x11a3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3528
jmp 0x11b19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3528
jmp 0x11b19
movq -0x108(%rbp), %rsi
leaq 0x2c9c5(%rip), %rdi     # 0x3e410
callq 0x16220
movq -0x100(%rbp), %rdx
leaq -0x90(%rbp), %rdi
movq %rdi, -0x128(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x16250
movq -0x108(%rbp), %rsi
movq -0x128(%rbp), %rdx
leaq -0xd8(%rbp), %rdi
callq 0x16290
jmp 0x11a8a
leaq 0x2c97f(%rip), %rdi     # 0x3e410
leaq -0xd8(%rbp), %rsi
callq 0x162f0
movb %dl, -0x131(%rbp)
movq %rax, -0x130(%rbp)
jmp 0x11aac
movb -0x131(%rbp), %al
movq -0x130(%rbp), %rcx
movq %rcx, -0xe8(%rbp)
movb %al, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x16330
leaq -0x90(%rbp), %rdi
callq 0x16360
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x11b0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x16330
leaq -0x90(%rbp), %rdi
callq 0x16360
movq -0x40(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/convert.cc
// Function: newString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static std::string newString(std::string str){
    std::stringstream tempss;
    tempss << "_s" << stringc;
    std::string varname = tempss.str();
    addVar(varname, VT_STRING, str);
    stringc++;
    return varname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rsi, -0x208(%rbp)
movq %rdi, -0x200(%rbp)
movq %rdi, %rax
movq %rax, -0x1f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31d0
leaq -0x188(%rbp), %rdi
leaq 0x15dae(%rip), %rsi     # 0x2b273
callq 0x3260
movq %rax, -0x1f0(%rbp)
jmp 0x154d3
movq -0x1f0(%rbp), %rdi
movl 0x28f98(%rip), %esi     # 0x3e478
callq 0x3490
jmp 0x154e7
movq -0x200(%rbp), %rdi
movb $0x0, -0x1a5(%rbp)
leaq -0x198(%rbp), %rsi
callq 0x3250
jmp 0x15503
movq -0x200(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x3100
jmp 0x15518
movq -0x208(%rbp), %rsi
leaq -0x1e8(%rbp), %rdi
callq 0x3100
jmp 0x1552d
leaq -0x1c8(%rbp), %rdi
xorl %esi, %esi
leaq -0x1e8(%rbp), %rdx
callq 0x11910
jmp 0x15544
leaq -0x1e8(%rbp), %rdi
callq 0x3528
leaq -0x1c8(%rbp), %rdi
callq 0x3528
movl 0x28f16(%rip), %eax     # 0x3e478
addl $0x1, %eax
movl %eax, 0x28f0d(%rip)     # 0x3e478
movb $0x1, -0x1a5(%rbp)
testb $0x1, -0x1a5(%rbp)
jne 0x155f4
jmp 0x155e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x1561c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x15610
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x155da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x3528
leaq -0x1c8(%rbp), %rdi
callq 0x3528
jmp 0x15610
movq -0x200(%rbp), %rdi
callq 0x3528
leaq -0x198(%rbp), %rdi
callq 0x31e0
movq -0x1f8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x200(%rbp), %rdi
callq 0x3528
leaq -0x198(%rbp), %rdi
callq 0x31e0
movq -0x1a0(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: johan-bjareholt[P]lua-compiler/src/convert.cc
// Function: getVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static std::pair<int, std::string>* getVar(std::string name){
    auto result = vars2.find(name);
    if (result == vars2.end())
        return nullptr;
    else
        return &(*result).second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsi, -0x10(%rbp)
leaq 0x28c8a(%rip), %rdi     # 0x3e410
callq 0x15e10
movq %rax, -0x18(%rbp)
leaq 0x28c7a(%rip), %rdi     # 0x3e410
callq 0x15870
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x16380
testb $0x1, %al
jne 0x157b2
jmp 0x157bc
movq $0x0, -0x8(%rbp)
jmp 0x157cd
leaq -0x18(%rbp), %rdi
callq 0x158d0
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: aisthesis[P]realnumber/tst/array_arithmetic_test.cpp
// Function: ArraySize::ArraySize()
ArraySize() {
		small = 4;
		large = 8;
		small_array = new unsigned char[small];
		large_array = new unsigned char[large];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x4, (%rax)
movl $0x8, 0x4(%rax)
movslq (%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq 0x4(%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: aisthesis[P]realnumber/tst/array_arithmetic_test.cpp
// Function: MathTestCases::MathTestCases()
MathTestCases() {
		one = 1;
		two = 2;
		three = 3;
		x1 = 128;
		x2 = 256;
		one_billion = 1000000000;
		two_billion = 2000000000;
		three_billion = 3000000000;
		small_arr_len = 2;
		bigger_arr_len = 4;
		small_arr1 = new unsigned char[small_arr_len];
		small_arr2 = new unsigned char[small_arr_len];
		small_arr3 = new unsigned char[small_arr_len];
		smaller_arr = new unsigned char[small_arr_len - 1];
		small_result_arr = new unsigned char[small_arr_len + 1];
		bigger_arr1 = new unsigned char[bigger_arr_len];
		bigger_arr2 = new unsigned char[bigger_arr_len];
		bigger_arr3 = new unsigned char[bigger_arr_len];
		big_arr = new unsigned char[bigger_arr_len - 2];
		big_sum_arr = new unsigned char[bigger_arr_len + 1];
		big_product_arr = new unsigned char[2 * bigger_arr_len - 1];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, (%rax)
movl $0x2, 0x4(%rax)
movl $0x3, 0x8(%rax)
movl $0x80, 0xc(%rax)
movl $0x100, 0x10(%rax)      # imm = 0x100
movl $0x3b9aca00, 0x14(%rax) # imm = 0x3B9ACA00
movl $0x77359400, 0x18(%rax) # imm = 0x77359400
movl $0xb2d05e00, 0x1c(%rax) # imm = 0xB2D05E00
movq $0x2, 0x20(%rax)
movq $0x4, 0x28(%rax)
movq 0x20(%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x20(%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq 0x20(%rax), %rdi
subq $0x1, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq 0x20(%rax), %rdi
addq $0x1, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq 0x28(%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq 0x28(%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq 0x28(%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq 0x28(%rax), %rdi
subq $0x2, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movq 0x28(%rax), %rdi
addq $0x1, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x78(%rax)
movq 0x28(%rax), %rdi
shlq %rdi
subq $0x1, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: aisthesis[P]realnumber/tst/array_arithmetic_test.cpp
// Function: MathTestCases::~MathTestCases()
~MathTestCases() {
		delete[] small_arr1;
		delete[] small_arr2;
		delete[] small_arr3;
		delete[] smaller_arr;
		delete[] small_result_arr;
		delete[] bigger_arr1;
		delete[] bigger_arr2;
		delete[] bigger_arr3;
		delete[] big_arr;
		delete[] big_sum_arr;
		delete[] big_product_arr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1903b
movq -0x10(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x19056
movq -0x20(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x19071
movq -0x28(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1908c
movq -0x30(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x190a7
movq -0x38(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x190c2
movq -0x40(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x190dd
movq -0x48(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x190f8
movq -0x50(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x19113
movq -0x58(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x1912e
movq -0x60(%rbp), %rdi
callq 0x3280
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x1914c
movq -0x68(%rbp), %rdi
callq 0x3280
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: suyash[P]chan/examples/tylertreat_chan/close.cc
// Function: main
int main() {
	chan::buffered_chan<int> jobs(5);
	chan::unbuffered_chan<int> done;

	std::thread worker([&](){
		// Process jobs until channel is closed.
		int job;
		while (jobs.read(job)) {
			printf("received job: %d\n", job);
		}

		// Notify that all jobs were received.
		printf("received all jobs\n");
		done << 1;
	});

	// Send 3 jobs over the jobs channel then close it.
	for (int i = 1; i <= 3; i++) {
		jobs << i;
		printf("sent job: %d\n", i);
	}
	jobs.close();

	// Wait for all jobs to be received.
	int _;
	done >> _;

	worker.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movl $0x0, -0x4(%rbp)
leaq -0xd0(%rbp), %rdi
movl $0x5, %esi
callq 0x2a60
leaq -0x1d0(%rbp), %rdi
callq 0x2b30
jmp 0x2391
leaq -0xd0(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x1d0(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x1e8(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0x24f0
jmp 0x23c2
movl $0x1, -0x1fc(%rbp)
cmpl $0x3, -0x1fc(%rbp)
jg 0x2465
leaq -0xc8(%rbp), %rdi
leaq -0x1fc(%rbp), %rsi
callq 0x2ba0
jmp 0x23ee
movl -0x1fc(%rbp), %esi
leaq 0x1c09(%rip), %rdi      # 0x4004
xorl %eax, %eax
callq 0x2040
jmp 0x2404
jmp 0x2406
movl -0x1fc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1fc(%rbp)
jmp 0x23cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
jmp 0x24d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
jmp 0x24c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x2cc0
jmp 0x24c6
leaq -0xd0(%rbp), %rdi
callq 0x2bd0
jmp 0x2473
leaq -0x1d0(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0x2c90
jmp 0x2488
leaq -0x1e8(%rbp), %rdi
callq 0x2160
jmp 0x2496
leaq -0x1e8(%rbp), %rdi
callq 0x2cc0
leaq -0x1d0(%rbp), %rdi
callq 0x2cf0
leaq -0xd0(%rbp), %rdi
callq 0x2d10
movl -0x4(%rbp), %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x1d0(%rbp), %rdi
callq 0x2cf0
leaq -0xd0(%rbp), %rdi
callq 0x2d10
movq -0x1d8(%rbp), %rdi
callq 0x2180
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/getline.cc
// Function: main
int main() 
{
	string line;

	// read input a line at a time until end-of-file
	while (getline(cin, line))
		cout << line << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1090
movq 0x2dc1(%rip), %rdi      # 0x3fe0
leaq -0x28(%rbp), %rsi
callq 0x1030
movq %rax, -0x40(%rbp)
jmp 0x122e
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x1080
movb %al, -0x41(%rbp)
jmp 0x1246
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x124f
jmp 0x1290
movq 0x2d7a(%rip), %rdi      # 0x3fd0
leaq -0x28(%rbp), %rsi
callq 0x1060
movq %rax, -0x50(%rbp)
jmp 0x1265
movq -0x50(%rbp), %rdi
movq 0x2d50(%rip), %rsi      # 0x3fc0
callq 0x1070
jmp 0x1277
jmp 0x1218
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
jmp 0x12a9
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1040
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10b0
// File: FakePsyho[P]halite2/MyBot.cpp
// Function: detectCollisions(hlt::Location const&, hlt::Location const&, std::vector<hlt::Entity, std::allocator<hlt::Entity>>&, double, bool)
int detectCollisions(const Location& start, const Location& end, VC<Entity>& entities, double radius = 0.5001, bool earlyExit = true) {
	int rv = m.in_bounds(end) ? 0 : 1;
	if (rv && earlyExit) return 1;
	for (auto& e : entities) 
		if (segment_circle_intersect(start, end, e, radius)) {
			if (earlyExit) return 1;
			rv++;
		}
	return rv;
}

// Assembly:
subq $0x58, %rsp
movb %cl, %al
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x4d68b(%rip), %rdi     # 0x51d28
callq 0x12e40
movb %al, %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x28(%rsp)
cmpl $0x0, 0x28(%rsp)
je 0x46d0
testb $0x1, 0x2f(%rsp)
je 0x46d0
movl $0x1, 0x54(%rsp)
jmp 0x476e
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x12ed0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x12f00
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x12f30
testb $0x1, %al
jne 0x470d
jmp 0x4766
leaq 0x18(%rsp), %rdi
callq 0x12f70
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x8(%rsp), %rdx
movsd 0x30(%rsp), %xmm0
callq 0x4780
testb $0x1, %al
jne 0x473c
jmp 0x4758
testb $0x1, 0x2f(%rsp)
je 0x474d
movl $0x1, 0x54(%rsp)
jmp 0x476e
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x475a
leaq 0x18(%rsp), %rdi
callq 0x12f80
jmp 0x46f8
movl 0x28(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: FakePsyho[P]halite2/MyBot.cpp
// Function: hideOrder(hlt::Ship const&, int, int)
Order hideOrder(const Ship& ship, int cx, int cy) {
	Location loc(cx == 0 ? 1 : m.map_width - 1, cy == 0 ? 1 : m.map_height - 1);
	double dist = ship.location.get_distance_to(loc);
	
	Order o;
	o.ship = ship.entity_id;
	o.cornerx = cx;
	o.cornery = cy;
	o.type = OrderType::Hide;
	o.value = 5000 - dist;
	return o;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movl %ecx, 0x48(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x6f2d
movl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x6f3a
movl 0x4adf5(%rip), %eax     # 0x51d28
subl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
cmpl $0x0, 0x48(%rsp)
jne 0x6f5a
movl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x6f67
movl 0x4adcc(%rip), %eax     # 0x51d2c
subl $0x1, %eax
movl %eax, 0xc(%rsp)
movsd 0x10(%rsp), %xmm0
movl 0xc(%rsp), %eax
cvtsi2sd %eax, %xmm1
leaq 0x38(%rsp), %rdi
callq 0x13380
movq 0x50(%rsp), %rdi
addq $0x8, %rdi
leaq 0x38(%rsp), %rsi
callq 0x13dd0
movq 0x20(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
callq 0x139c0
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq 0x50(%rsp), %rdx
movl (%rdx), %edx
movl %edx, 0x60(%rcx)
movl 0x4c(%rsp), %edx
movl %edx, 0x6c(%rcx)
movl 0x48(%rsp), %edx
movl %edx, 0x70(%rcx)
movl $0x7, (%rcx)
movsd 0x3414e(%rip), %xmm0    # 0x3b120
subsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rcx)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FakePsyho[P]halite2/MyBot.cpp
// Function: recalcOrder(Order&)
void recalcOrder(Order& o) {
	const Ship& ship = m.get_ship(player_id, o.ship);
	if (o.type == OrderType::Colonize) {
		o = colonizeOrder(ship, m.planets[o.planet]);
	} else if (o.type == OrderType::AttackShip || o.type == OrderType::AttackMiner || o.type == OrderType::DefendMiner || o.type == OrderType::HitAndRun) {
		Ship eship = *enemyShips[o.target];
		o = attackOrder(ship, eship, o.target);
	} else if (o.type == OrderType::Hide) {
		o = hideOrder(ship, o.cornerx, o.cornery);
	} else {
		assert(false);
	}
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x210(%rsp)
movl 0x4ad17(%rip), %esi     # 0x51d1c
movq 0x210(%rsp), %rax
movl 0x60(%rax), %edx
leaq 0x4ad11(%rip), %rdi     # 0x51d28
callq 0x13160
movq %rax, 0x208(%rsp)
movq 0x210(%rsp), %rax
cmpl $0x2, (%rax)
jne 0x7094
movq 0x208(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x210(%rsp), %rax
movl 0x64(%rax), %eax
movl %eax, %esi
leaq 0x4acd6(%rip), %rdi     # 0x51d28
addq $0x80, %rdi
callq 0x13e40
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x190(%rsp), %rdi
xorl %ecx, %ecx
callq 0x6a90
movq 0x210(%rsp), %rdi
leaq 0x190(%rsp), %rsi
movl $0x74, %edx
callq 0x3220
jmp 0x71b8
movq 0x210(%rsp), %rax
cmpl $0x3, (%rax)
je 0x70c8
movq 0x210(%rsp), %rax
cmpl $0x4, (%rax)
je 0x70c8
movq 0x210(%rsp), %rax
cmpl $0x5, (%rax)
je 0x70c8
movq 0x210(%rsp), %rax
cmpl $0x6, (%rax)
jne 0x7147
movq 0x210(%rsp), %rax
movl 0x68(%rax), %eax
movl %eax, 0x104(%rsp)
leaq 0x4b07f(%rip), %rdi     # 0x52160
leaq 0x104(%rsp), %rsi
callq 0x13e60
movq (%rax), %rsi
leaq 0x108(%rsp), %rdi
movl $0x88, %edx
callq 0x3220
movq 0x208(%rsp), %rsi
movq 0x210(%rsp), %rax
movl 0x68(%rax), %ecx
leaq 0x88(%rsp), %rdi
leaq 0x108(%rsp), %rdx
callq 0x6d10
movq 0x210(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movl $0x74, %edx
callq 0x3220
jmp 0x71b6
movq 0x210(%rsp), %rax
cmpl $0x7, (%rax)
jne 0x7195
movq 0x208(%rsp), %rsi
movq 0x210(%rsp), %rax
movl 0x6c(%rax), %edx
movq 0x210(%rsp), %rax
movl 0x70(%rax), %ecx
leaq 0x10(%rsp), %rdi
callq 0x6f00
movq 0x210(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x74, %edx
callq 0x3220
jmp 0x71b4
leaq 0x340a4(%rip), %rdi     # 0x3b240
leaq 0x340a3(%rip), %rsi     # 0x3b246
movl $0x28a, %edx            # imm = 0x28A
leaq 0x340a1(%rip), %rcx     # 0x3b250
callq 0x31a0
jmp 0x71b6
jmp 0x71b8
addq $0x218, %rsp            # imm = 0x218
retq
// File: FakePsyho[P]halite2/MyBot.cpp
// Function: Order::Order()
Order() {
		type = OrderType::Unknown;
		value = -INF;
		move = Move::noop();
		ship = -1;
		target = -1;
		planet = -1;
		cornerx = -1;
		cornery = -1;
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
callq 0x1b300
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movsd 0x27631(%rip), %xmm0    # 0x3b020
movsd %xmm0, 0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x1b250
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x10(%rsp), %rsi
movl $0x49, %edx
callq 0x3220
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x60(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x68(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x64(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x6c(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x70(%rax) # imm = 0xFFFFFFFF
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: FakePsyho[P]halite2/./hlt/move.hpp
// Function: hlt::Move::get_velocity()
Location get_velocity() {
			if (velocity_cached) return velocity;
			velocity = Move::get_velocity(move_angle_deg / 180.0 * M_PI, move_thrust);
			velocity_cached = true;
			return velocity;
		}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x48(%rax)
je 0x14e32
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x40(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x14e97
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x261ec(%rip), %xmm1    # 0x3b030
divsd %xmm1, %xmm0
movsd 0x261d8(%rip), %xmm1    # 0x3b028
mulsd %xmm1, %xmm0
movsd 0x8(%rax), %xmm1
callq 0x12ff0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x40(%rax)
movb $0x1, 0x48(%rax)
movq 0x38(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x40(%rax), %rax
movq %rax, 0x30(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: FakePsyho[P]halite2/./hlt/move.hpp
// Function: hlt::Move::Move(hlt::MoveType, unsigned int, double, double, unsigned int)
Move(MoveType _type, EntityId _ship_id, double _move_thrust, double _move_angle_deg, EntityId _dock_to) {
			type = _type;
			ship_id = _ship_id;
			move_thrust = _move_thrust;
			move_angle_deg = _move_angle_deg;
			dock_to = _dock_to;
		}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movl $0x0, 0x2c(%rdi)
movl $0x0, 0x30(%rdi)
movb $0x0, 0x34(%rdi)
addq $0x38, %rdi
callq 0x13430
movq 0x8(%rsp), %rax
movb $0x0, 0x48(%rax)
movl 0x2c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x28(%rsp), %ecx
movl %ecx, 0x4(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x18(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: FakePsyho[P]halite2/hlt/hlt_in.cpp
// Function: hlt::in::get_map()
const Map get_map() {
            if (g_turn == 1) {
                out::send_string(g_bot_name);
            }

            const std::string input = get_string();

            if (!std::cin.good()) {
                // This is needed on Windows to detect that game engine is done.
                std::exit(0);
            }

            if (g_turn == 0) {
                Log::log("--- PRE-GAME ---");
            } else {
                Log::log("--- TURN " + std::to_string(g_turn) + " ---");
            }
            ++g_turn;

            return parse_map(input, g_map_width, g_map_height);
        }

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xe0(%rsp)
cmpl $0x1, 0x24a05(%rip)     # 0x5d818
jne 0x38e21
leaq 0x249d4(%rip), %rdi     # 0x5d7f0
callq 0x39060
leaq 0xc0(%rsp), %rdi
callq 0x390b0
movq 0x181ab(%rip), %rdi     # 0x50fe0
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3410
movb %al, 0x17(%rsp)
jmp 0x38e4a
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x38e74
jmp 0x38e54
xorl %edi, %edi
callq 0x32f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x3903b
cmpl $0x0, 0x2499d(%rip)     # 0x5d818
jne 0x38f25
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3450
movq 0x8(%rsp), %rdx
leaq 0x26da(%rip), %rsi      # 0x3b579
leaq 0x90(%rsp), %rdi
callq 0x3340
jmp 0x38eae
leaq 0x90(%rsp), %rdi
callq 0x12620
jmp 0x38ebd
leaq 0x90(%rsp), %rdi
callq 0x34c8
leaq 0x8f(%rsp), %rdi
callq 0x32c0
jmp 0x38ff3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x38f13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x34c8
leaq 0x8f(%rsp), %rdi
callq 0x32c0
jmp 0x3903b
movl 0x248ed(%rip), %esi     # 0x5d818
leaq 0x28(%rsp), %rdi
callq 0x1b430
jmp 0x38f37
leaq 0x264c(%rip), %rsi      # 0x3b58a
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x152e0
jmp 0x38f4f
leaq 0x262f(%rip), %rdx      # 0x3b585
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1b390
jmp 0x38f67
leaq 0x68(%rsp), %rdi
callq 0x12620
jmp 0x38f73
leaq 0x68(%rsp), %rdi
callq 0x34c8
leaq 0x48(%rsp), %rdi
callq 0x34c8
leaq 0x28(%rsp), %rdi
callq 0x34c8
jmp 0x38ff3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x38fe7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x38fdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x34c8
leaq 0x48(%rsp), %rdi
callq 0x34c8
leaq 0x28(%rsp), %rdi
callq 0x34c8
jmp 0x3903b
movq 0x18(%rsp), %rdi
movl 0x2481a(%rip), %eax     # 0x5d818
incl %eax
movl %eax, 0x24812(%rip)     # 0x5d818
movl 0x24804(%rip), %edx     # 0x5d810
movl 0x24802(%rip), %ecx     # 0x5d814
leaq 0xc0(%rsp), %rsi
callq 0x39130
jmp 0x39021
leaq 0xc0(%rsp), %rdi
callq 0x34c8
movq 0x20(%rsp), %rax
addq $0xe8, %rsp
retq
leaq 0xc0(%rsp), %rdi
callq 0x34c8
movq 0xb8(%rsp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)