LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: convertFuncDef(Statement*, BBlock*)
void convertFuncDef(Statement* in, BBlock *current){
	std::string name = in->expressions.at(0)->name;
    //std::cout << "Defining function " << name << std::endl;
	Statement* args = in->children.at(0);
	Statement* body = in->children.at(1);
	BBlock* bodyBlock = new BBlock();
    BBlock* currblock = bodyBlock;
    // TODO: Fix support for multiple arguments
    if (args->expressions.size() > 0){
        Expression* exp1 = args->expressions.at(0);
        ThreeAd ta (name, 'a', exp1->name, exp1->name);
        bodyBlock->instructions.push_back(ta);
    }
	convertStatement(body, &currblock);

    funcdefs.insert(std::make_pair(name, bodyBlock));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
xorl %esi, %esi
callq 0x6bb4
movq (%rax), %rsi
addq $0x30, %rsi
leaq -0x40(%rbp), %rdi
callq 0x32f0
addq $0x18, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6bd6
movq (%rax), %r15
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x6bd6
movq (%rax), %r14
pushq $0x48
popq %rdi
callq 0x3200
movq %rax, %rbx
movq %rax, 0x8(%rax)
movq %rax, (%rax)
addq $0x38, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movq %rax, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
movb $0x0, 0x38(%rbx)
movq %rbx, -0x20(%rbp)
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0x62e2
movq %r15, %rdi
xorl %esi, %esi
callq 0x6bb4
movq (%rax), %r15
leaq -0xa0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x32f0
addq $0x30, %r15
leaq -0x80(%rbp), %rdi
movq %r15, %rsi
callq 0x32f0
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x32f0
leaq -0x108(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
pushq $0x61
popq %rdx
leaq -0x80(%rbp), %rcx
leaq -0x60(%rbp), %r8
callq 0x4818
leaq -0x60(%rbp), %rdi
callq 0x3448
leaq -0x80(%rbp), %rdi
callq 0x3448
leaq -0xa0(%rbp), %rdi
callq 0x3448
leaq -0x108(%rbp), %rsi
movq %rbx, %rdi
callq 0x6ba4
leaq -0x108(%rbp), %rdi
callq 0x6970
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x6164
leaq -0x108(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x32f0
leaq -0x108(%rbp), %rsi
movq %rbx, 0x20(%rsi)
leaq 0x15fe0(%rip), %rdi     # 0x1c2f0
callq 0x7d1a
leaq -0x108(%rbp), %rdi
callq 0x3448
leaq -0x40(%rbp), %rdi
callq 0x3448
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x6970
jmp 0x6391
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3448
jmp 0x635a
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3448
jmp 0x6368
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
jmp 0x637f
jmp 0x638e
jmp 0x638e
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x3448
jmp 0x6391
jmp 0x638e
jmp 0x638e
jmp 0x638e
jmp 0x638e
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
xorl %esi, %esi
callq 0x6bd6
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x6bb4
movq (%rax), %rax
movq %rax, -0x30(%rbp)
pushq $0x48
popq %r14
movq %r14, %rdi
callq 0x3200
movq %rax, %r12
movq %rax, 0x8(%rax)
movq %rax, (%rax)
addq $0x38, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
andq $0x0, 0x20(%r12)
movq %rax, 0x28(%r12)
andq $0x0, 0x30(%r12)
xorl %r15d, %r15d
movb %r15b, 0x38(%r12)
movq %r14, %rdi
callq 0x3200
movq %rax, %r13
movq %rax, 0x8(%rax)
movq %rax, (%rax)
addq $0x38, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
andq $0x0, 0x20(%r13)
movq %rax, 0x28(%r13)
andq $0x0, 0x30(%r13)
movb %r15b, 0x38(%r13)
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x3200
movq %rax, %r14
movq %rax, 0x8(%rax)
movq %rax, (%rax)
addq $0x38, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
andq $0x0, 0x20(%r14)
movq %rax, 0x28(%r14)
andq $0x0, 0x30(%r14)
movb %r15b, 0x38(%r14)
movq (%rbx), %rax
movq %r12, 0x18(%rax)
movq %r12, (%rbx)
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x6164
movq %r13, 0x18(%r12)
movq %r13, (%rbx)
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x5ed3
movq %r12, 0x18(%r13)
movq %r14, 0x20(%r13)
movq %r14, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: convertLoop(Statement*, BBlock**)
void convertLoop(Statement *in, BBlock **current){
    Statement* pre = in->children.at(0);
    convertStatement(pre, current);
    Expression* check = in->expressions.at(0);
    Statement* body = in->children.at(1);
    Statement* post = in->children.at(2);

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

    (*current)->trueExit = loopBlock;
    // Set loop block
    (*current) = loopBlock;
    Expression* comparitor = in->expressions.back();
    convertComparitor(comparitor, *current);
    (*current)->falseExit = bodyBlock;
    (*current)->trueExit = nextBlock;

    // Set body block
    (*current) = bodyBlock;
    convertStatement(body, current);
    convertStatement(post, current);
    (*current)->trueExit = loopBlock;

    // Set next block
    (*current) = nextBlock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x6bd6
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x6164
movq %r14, %rdi
xorl %esi, %esi
callq 0x6bb4
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x6bd6
movq (%rax), %rax
movq %rax, -0x38(%rbp)
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x6bd6
movq (%rax), %rax
movq %rax, -0x30(%rbp)
pushq $0x48
popq %r15
movq %r15, %rdi
callq 0x3200
movq %rax, %r13
movq %rax, 0x8(%rax)
movq %rax, (%rax)
addq $0x38, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
andq $0x0, 0x20(%r13)
movq %rax, 0x28(%r13)
andq $0x0, 0x30(%r13)
xorl %r12d, %r12d
movb %r12b, 0x38(%r13)
movq %r15, %rdi
callq 0x3200
movq %rax, %r15
movq %rax, 0x8(%rax)
movq %rax, (%rax)
addq $0x38, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
andq $0x0, 0x20(%r15)
movq %rax, 0x28(%r15)
andq $0x0, 0x30(%r15)
movb %r12b, 0x38(%r15)
pushq $0x48
popq %rdi
callq 0x3200
movq %rax, %r12
movq %rax, 0x8(%rax)
movq %rax, (%rax)
addq $0x38, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
andq $0x0, 0x20(%r12)
movq %rax, 0x28(%r12)
andq $0x0, 0x30(%r12)
xorl %eax, %eax
movb %al, 0x38(%r12)
movq (%rbx), %rax
movq %r13, 0x18(%rax)
movq %r13, (%rbx)
movq 0x8(%r14), %rax
movq -0x8(%rax), %rdi
movq %r13, %rsi
callq 0x5ed3
movq (%rbx), %rax
movq %r15, 0x20(%rax)
movq (%rbx), %rax
movq %r12, 0x18(%rax)
movq %r15, (%rbx)
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x6164
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x6164
movq (%rbx), %rax
movq %r13, 0x18(%rax)
movq %r12, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
xorl %esi, %esi
callq 0x6bb4
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
movq %rbx, %rdx
callq 0x5cf2
leaq 0xe02e(%rip), %rsi      # 0x146f2
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x30d0
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x32f0
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x32f0
leaq -0xf8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
pushq $0x72
popq %rdx
leaq -0x70(%rbp), %rcx
leaq -0x50(%rbp), %r8
callq 0x4818
leaq -0x50(%rbp), %rdi
callq 0x3448
leaq -0x70(%rbp), %rdi
callq 0x3448
leaq -0x90(%rbp), %rdi
callq 0x3448
leaq -0xf8(%rbp), %rsi
movq %rbx, %rdi
callq 0x6ba4
leaq -0xf8(%rbp), %rdi
callq 0x6970
leaq -0x30(%rbp), %rdi
callq 0x3448
addq $0xf8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0xf8(%rbp), %rdi
callq 0x6970
jmp 0x6799
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3448
jmp 0x677a
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x3448
jmp 0x6788
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x3448
jmp 0x6799
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/johan-bjareholt[P]lua-compiler/src/ir.cc
// Function: dumpCFG(std::ostream&, BBlock*)
void dumpCFG(std::ostream& ss, BBlock *start)
{
    set<BBlock*> done, todo;
    todo.insert(start);
    while(todo.size()>0)
    {
        // Pop an arbitrary element from todo set
        auto first = todo.begin();
        BBlock *next = *first;
        todo.erase(first);

        next->dump(ss);

        done.insert(next);
        if(next->trueExit!=NULL && done.find(next->trueExit)==done.end())
            todo.insert(next->trueExit);
        if(next->falseExit!=NULL && done.find(next->falseExit)==done.end())
            todo.insert(next->falseExit);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq -0x68(%rbp), %rax
movq %rsi, (%rax)
leaq -0x90(%rbp), %r13
andl $0x0, (%r13)
andq $0x0, 0x8(%r13)
movq %r13, 0x10(%r13)
movq %r13, 0x18(%r13)
andq $0x0, 0x20(%r13)
leaq -0x58(%rbp), %rcx
andl $0x0, (%rcx)
andq $0x0, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x7f3a
leaq -0x60(%rbp), %r14
leaq -0x98(%rbp), %r15
leaq -0x30(%rbp), %r12
cmpq $0x0, -0x38(%rbp)
je 0x68aa
movq -0x48(%rbp), %rsi
movq 0x20(%rsi), %rax
movq %rax, -0x30(%rbp)
movq %r14, %rdi
callq 0x8010
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x492e
movq %r15, %rdi
movq %r12, %rsi
callq 0x7f3a
movq -0x30(%rbp), %rsi
cmpq $0x0, 0x18(%rsi)
je 0x687d
addq $0x18, %rsi
movq %r15, %rdi
callq 0x7054
movq -0x30(%rbp), %rsi
cmpq %r13, %rax
jne 0x687d
addq $0x18, %rsi
movq %r14, %rdi
callq 0x7f3a
movq -0x30(%rbp), %rsi
cmpq $0x0, 0x20(%rsi)
je 0x6817
addq $0x20, %rsi
movq %r15, %rdi
callq 0x7054
cmpq %r13, %rax
jne 0x6817
movq -0x30(%rbp), %rsi
addq $0x20, %rsi
movq %r14, %rdi
callq 0x7f3a
jmp 0x6817
leaq -0x60(%rbp), %rdi
callq 0x6c7e
leaq -0x98(%rbp), %rdi
callq 0x6c7e
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x68d4
jmp 0x68d4
jmp 0x68d4
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x6c7e
leaq -0x98(%rbp), %rdi
callq 0x6c7e
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, %rbx
leaq -0x1f8(%rbp), %rdi
callq 0x3180
leaq -0x1e8(%rbp), %rdi
leaq 0xa27c(%rip), %rsi      # 0x12317
callq 0x31f0
movq %rax, %r14
movl 0x14327(%rip), %esi     # 0x1c3d0
leaq -0x30(%rbp), %rdi
callq 0x6af1
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x31d0
leaq -0x30(%rbp), %rdi
callq 0x3448
leaq -0x1e0(%rbp), %rsi
movq %rbx, %rdi
callq 0x3380
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq 0x32f0
leaq 0xa22d(%rip), %rsi      # 0x12316
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x30d0
leaq -0x70(%rbp), %rdi
pushq $0x4
popq %rsi
leaq -0x50(%rbp), %rdx
callq 0x8184
leaq -0x50(%rbp), %rdi
callq 0x3448
leaq -0x70(%rbp), %rdi
callq 0x3448
incl 0x142b2(%rip)           # 0x1c3d0
leaq -0x1f8(%rbp), %rdi
callq 0x3190
movq %rbx, %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x3448
jmp 0x814a
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x3448
jmp 0x8158
movq %rax, %r14
movq %rbx, %rdi
jmp 0x8164
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x3448
jmp 0x8170
jmp 0x816d
movq %rax, %r14
leaq -0x1f8(%rbp), %rdi
callq 0x3190
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x32f0
movq %r12, %rdi
callq 0xa2ed
movq %rax, %r12
leaq -0x60(%rbp), %rdi
callq 0x3448
testq %r12, %r12
je 0x8234
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x32f0
movq %r12, %rdi
callq 0xa2ed
movl (%rax), %r12d
leaq -0x40(%rbp), %rdi
callq 0x3448
cmpl $0x5, %r12d
je 0x8225
movq 0x13dd1(%rip), %rdi     # 0x1bfc8
leaq 0xa4e6(%rip), %rsi      # 0x126e4
callq 0x31f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31d0
leaq 0xbaf5(%rip), %rsi      # 0x13d0a
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
callq 0x3100
leaq 0x14174(%rip), %rdi     # 0x1c3a0
movq %rbx, %rsi
callq 0xa492
leaq -0xc8(%rbp), %r12
movl %r15d, -0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0x32f0
leaq -0xa8(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
movq %rbx, %rsi
callq 0xa43c
leaq 0x14138(%rip), %rdi     # 0x1c3a0
leaq -0xa8(%rbp), %rsi
callq 0xa6ce
leaq -0xa8(%rbp), %rdi
callq 0xa472
movq %r12, %rdi
callq 0x3448
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x82c1
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0xa472
jmp 0x82b5
movq %rax, %rbx
movq %r12, %rdi
jmp 0x82c1
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3448
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rsi
leaq 0x120a5(%rip), %rdi     # 0x1c3a0
callq 0xaa58
leaq 0x120a1(%rip), %rdx     # 0x1c3a8
leaq 0x40(%rax), %rsi
xorl %ecx, %ecx
cmpq %rdx, %rax
cmovneq %rsi, %rcx
movq %rcx, %rax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x800000004, %rax      # imm = 0x800000004
movq %rax, (%rdi)
pushq $0x4
popq %rdi
callq 0x3030
movq %rax, 0x8(%rbx)
pushq $0x8
popq %rdi
callq 0x3030
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movaps 0x1fc0(%rip), %xmm0     # 0x11020
movups %xmm0, (%rdi)
movaps 0x1fc6(%rip), %xmm0     # 0x11030
movups %xmm0, 0x10(%rdi)
movq $0x2, 0x20(%rdi)
movq $0x4, 0x28(%rdi)
pushq $0x2
popq %r14
movq %r14, %rdi
callq 0x3030
movq %rax, 0x30(%rbx)
movq %r14, %rdi
callq 0x3030
movq %rax, 0x38(%rbx)
movq %r14, %rdi
callq 0x3030
movq %rax, 0x40(%rbx)
pushq $0x1
popq %rdi
callq 0x3030
movq %rax, 0x48(%rbx)
pushq $0x3
popq %rdi
callq 0x3030
movq %rax, 0x50(%rbx)
pushq $0x4
popq %r15
movq %r15, %rdi
callq 0x3030
movq %rax, 0x58(%rbx)
movq %r15, %rdi
callq 0x3030
movq %rax, 0x60(%rbx)
movq %r15, %rdi
callq 0x3030
movq %rax, 0x68(%rbx)
movq %r14, %rdi
callq 0x3030
movq %rax, 0x70(%rbx)
pushq $0x5
popq %rdi
callq 0x3030
movq %rax, 0x78(%rbx)
pushq $0x7
popq %rdi
callq 0x3030
movq %rax, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xf12f
callq 0x31c0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xf13d
callq 0x31c0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xf14b
callq 0x31c0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xf159
callq 0x31c0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xf167
callq 0x31c0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xf175
callq 0x31c0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xf183
callq 0x31c0
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0xf191
callq 0x31c0
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0xf19f
callq 0x31c0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0xf1ad
callq 0x31c0
movq 0x80(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0xf1c4
popq %rbx
popq %rbp
jmp 0x31c0
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2de0(%rip), %rbx      # 0x3fe0
leaq -0x38(%rbp), %r14
movq 0x2dc5(%rip), %r15      # 0x3fd0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1239
movq %r15, %rdi
movq %r14, %rsi
callq 0x1070
movq %rax, %rdi
callq 0x1050
jmp 0x120b
leaq -0x38(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movsd %xmm0, 0x10(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
leaq 0x19ca6(%rip), %rdi     # 0x1cce8
callq 0x9b20
movl %ebx, 0xc(%rsp)
movl %ebx, %ecx
xorb $0x1, %cl
movl %eax, %edx
orb %cl, %dl
pushq $0x1
popq %rbp
cmpb $0x1, %dl
jne 0x309b
xorb $0x1, %al
movzbl %al, %ebp
movq (%r13), %r12
movq 0x8(%r13), %r13
movzbl %cl, %ebx
cmpq %r13, %r12
je 0x309b
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movsd 0x10(%rsp), %xmm0
callq 0x30ac
testb %al, %al
je 0x3092
cmpb $0x0, 0xc(%rsp)
jne 0x3098
addl %ebx, %ebp
addq $0x78, %r12
jmp 0x306c
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/FakePsyho[P]halite2/MyBot.cpp
// Function: getSpawningTimes(hlt::Planet&, int)
VI getSpawningTimes(Planet &p, int max_turns = 20) {
	VI docked;
	for (EntityId& eid : p.docked_ships) {
		const Ship& ship = m.get_ship(p.owner_id, eid);
		if (ship.docking_status == ShipDockingStatus::Docked) {
			docked.PB(0);
		} else if (ship.docking_status == ShipDockingStatus::Docking) {
			docked.PB(ship.docking_progress - 1);
		}
	}
	
	if (docked.empty()) return VI();
		
	VI rv;
	int v = p.current_production;
	FOR(t, 1, max_turns+1) {
		REP(i, docked.S) {
			if (docked[i]) {
				docked[i]--;
			} else {
				v += BASE_PRODUCTIVITY;
			}
		}
		if (v >= 72) {
			rv.PB(t);
			v -= 72;
		}
	}
	return rv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq 0x88(%rsi), %rbx
movq 0x90(%rsi), %rbp
leaq 0x19a27(%rip), %r12     # 0x1cce8
leaq 0x8(%rsp), %r13
cmpq %rbp, %rbx
je 0x3315
movl 0x4(%r14), %esi
movl (%rbx), %edx
movq %r12, %rdi
callq 0x9b58
movl 0x7c(%rax), %ecx
cmpl $0x1, %ecx
je 0x32f8
cmpl $0x2, %ecx
jne 0x330f
andl $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0xd9d6
jmp 0x330f
movl 0x80(%rax), %eax
decl %eax
movl %eax, 0x8(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0xd9d6
addq $0x4, %rbx
jmp 0x32c6
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rbx
andq $0x0, 0x10(%rbx)
movq 0x18(%rsp), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
cmpq %rcx, %rax
je 0x339b
movl 0x80(%r14), %r15d
pushq $0x1
popq %rax
leaq 0x8(%rsp), %r14
movl 0xc(%rsp), %ebp
movl %eax, 0x8(%rsp)
cmpl %ebp, %eax
jg 0x339b
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x337e
movl (%rax,%rdx,4), %esi
testl %esi, %esi
je 0x3375
decl %esi
movl %esi, (%rax,%rdx,4)
jmp 0x3379
addl $0x6, %r15d
incq %rdx
jmp 0x3362
cmpl $0x47, %r15d
jle 0x3393
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9bb0
addl $-0x48, %r15d
movl 0x8(%rsp), %eax
incl %eax
jmp 0x3347
leaq 0x10(%rsp), %rdi
callq 0xd9a2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xd9a2
jmp 0x33cb
jmp 0x33c8
jmp 0x33c8
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xd9a2
movq %r14, %rdi
callq 0x23f0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movl 0x184c3(%rip), %eax     # 0x1cce8
decl %eax
testl %edx, %edx
pushq $0x1
popq %rcx
cmovel %ecx, %eax
cvtsi2sd %eax, %xmm0
movq %rdi, %r15
movl 0x184b0(%rip), %eax     # 0x1ccec
decl %eax
testl %ebx, %ebx
cmovel %ecx, %eax
cvtsi2sd %eax, %xmm1
movsd 0x8(%rsi), %xmm2
subsd %xmm0, %xmm2
movsd 0x10(%rsi), %xmm0
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
sqrtsd %xmm2, %xmm0
movsd %xmm0, (%rsp)
callq 0x9c7c
movl (%r14), %eax
movl %eax, 0x60(%r15)
movl %ebp, 0x6c(%r15)
movl %ebx, 0x70(%r15)
movl $0x7, (%r15)
movsd 0xd8bf(%rip), %xmm0     # 0x12150
subsd (%rsp), %xmm0
movsd %xmm0, 0x8(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
movl 0x1841b(%rip), %esi     # 0x1ccdc
movl 0x60(%rdi), %edx
leaq 0x1841d(%rip), %rdi     # 0x1cce8
callq 0x9b58
movq %rax, %r14
movl (%rbx), %eax
leal -0x3(%rax), %ecx
cmpl $0x4, %ecx
jae 0x492f
movl 0x68(%rbx), %eax
leaq 0x90(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x1882f(%rip), %rdi     # 0x1d120
callq 0x9e20
movq (%rax), %rsi
leaq 0x8(%rsp), %r15
movl $0x88, %edx
movq %r15, %rdi
callq 0x21e0
movl 0x68(%rbx), %ecx
leaq 0x90(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4689
pushq $0x74
popq %rcx
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x497d
cmpl $0x7, %eax
je 0x495e
cmpl $0x2, %eax
jne 0x498e
movl 0x64(%rbx), %eax
imulq $0xa0, %rax, %rdx
addq 0x1841e(%rip), %rdx     # 0x1cd68
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x44a6
jmp 0x4974
movl 0x6c(%rbx), %edx
movl 0x70(%rbx), %ecx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4811
pushq $0x74
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
rep  movsb (%rsi), %es:(%rdi)
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xd938(%rip), %rdi      # 0x122cd
leaq 0xd937(%rip), %rsi      # 0x122d3
leaq 0xd93a(%rip), %rcx      # 0x122dd
movl $0x28a, %edx            # imm = 0x28A
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/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:
andl $0x0, (%rdi)
movabsq $-0x3e32329b00000000, %rax # imm = 0xC1CDCD6500000000
movq %rax, 0x8(%rdi)
andq $0x0, -0xd(%rsp)
xorl %eax, %eax
movb %al, -0x5(%rsp)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x1c(%rdi)
movdqu %xmm0, 0x10(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq -0x10(%rsp), %rcx
movq %rcx, 0x39(%rdi)
movl -0x8(%rsp), %ecx
movl %ecx, 0x41(%rdi)
movb %al, 0x58(%rdi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x60(%rdi)
orl $-0x1, 0x70(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x48(%rdi)
jne 0xa15e
movsd 0x38(%rbx), %xmm0
movsd 0x40(%rbx), %xmm1
jmp 0xa1cd
movsd 0x8(%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
xorps %xmm0, %xmm0
jne 0xa172
jnp 0xa1bf
movsd 0x10(%rbx), %xmm0
divsd 0x7eb9(%rip), %xmm0     # 0x12038
mulsd 0x7eb9(%rip), %xmm0     # 0x12040
movsd %xmm0, 0x18(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x2410
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x2070
movapd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm1
movsd %xmm0, 0x38(%rbx)
movsd %xmm1, 0x40(%rbx)
movb $0x1, 0x48(%rbx)
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/sailing/./sailing.h
// Function: problem_t::next(state_t const&, int, std::vector<std::pair<state_t, float>, std::allocator<std::pair<state_t, float>>>&) const
virtual void next(const state_t &s, Problem::action_t a, std::vector<std::pair<state_t,float> > &outcomes) const {
        ++expansions_;
        outcomes.clear();
        //outcomes.reserve(8);
        state_t next_s = s.apply(a);
        assert(next_s.in_lake(rows_, cols_));
#if 0
        for( int nwind = 0; nwind < 8; ++nwind ) {
            float p = wind_transition_[s.wind_ * 8 + nwind];
            if( p > 0 ) {
                next_s.wind_ = nwind;
                outcomes.push_back(std::make_pair(next_s, p));
            }
        }
#endif
        const std::vector<std::pair<int, float> > &sparse_transition = sparse_wind_transition_[s.wind_];
        outcomes.reserve(sparse_transition.size());
        for( int i = 0; i < int(sparse_transition.size()); ++i ) {
            const std::pair<int, float> &p = sparse_transition[i];
            next_s.wind_ = p.first;
            outcomes.push_back(std::make_pair(next_s, p.second));
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdi, %r14
incq 0x10(%rdi)
movq %rsi, %r15
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x791b
movq %rax, 0x8(%rbx)
leaq 0x4(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x7e14
movzwl (%r12), %eax
testw %ax, %ax
js 0x79e4
cmpw 0x18(%r14), %ax
jge 0x79e4
movzwl 0x6(%rsp), %eax
testw %ax, %ax
js 0x79e4
cmpw 0x1c(%r14), %ax
jge 0x79e4
movswq 0x4(%r15), %rax
movq 0x140(%r14), %rcx
imulq $0x18, %rax, %rax
leaq (%rcx,%rax), %r15
movq 0x8(%rcx,%rax), %rsi
subq (%rcx,%rax), %rsi
sarq $0x3, %rsi
movq %rbx, %rdi
callq 0x7e6c
xorl %r12d, %r12d
leaq 0xc(%rsp), %r14
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jge 0x79d8
movzwl (%rax,%r12,8), %ecx
movw %cx, 0x8(%rsp)
movl 0x4(%rsp), %edx
movl %edx, 0xc(%rsp)
movw %cx, 0x10(%rsp)
movss 0x4(%rax,%r12,8), %xmm0
movss %xmm0, 0x14(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7fc4
incq %r12
jmp 0x798e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x149cb(%rip), %rdi     # 0x1c3b6
leaq 0x149e1(%rip), %rsi     # 0x1c3d3
leaq 0x149e6(%rip), %rcx     # 0x1c3df
movl $0x9d, %edx
callq 0x5150
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/kavl/test.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	aux_t *root = 0, *p, *q;
	p = (aux_t*)malloc(sizeof(aux_t));
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		p->key = get_key(n, x), p->cnt = 0;
		q = kavl_insert(32, &root, p, 0);
		if (p == q) p = (aux_t*)malloc(sizeof(aux_t));
		z += ++q->cnt;
	}
	free(p);
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", kavl_size(head, root), z);
	x = kavl_size(head, root);
	kavl_free(aux_t, head, root, free);
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movl %edi, %r14d
movq %rsp, %rax
andq $0x0, (%rax)
pushq $0x20
popq %rdi
callq 0x1060
movq %rax, %r13
xorl %ebx, %ebx
movl %r14d, %ebp
subl $0x1, %ebp
jb 0x14d9
movl %r15d, %edi
callq 0x11ec
movl %eax, %r15d
movl %r14d, %edi
movl %eax, %esi
callq 0x1217
movl %eax, (%r13)
andl $0x0, 0x4(%r13)
movq %rsp, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x15b5
movq %rax, %r12
cmpq %rax, %r13
jne 0x14c6
pushq $0x20
popq %rdi
callq 0x1060
movq %rax, %r13
movl 0x4(%r12), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%r12)
addl %eax, %ebx
incl %ebx
jmp 0x1483
movq %r13, %rdi
callq 0x1030
movq 0x2b10(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rsp), %r14
testq %r14, %r14
jne 0x150a
leaq 0xb7a(%rip), %rsi       # 0x2075
xorl %ebp, %ebp
xorl %edx, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1050
jmp 0x154d
movl 0x1c(%r14), %edx
leaq 0xb60(%rip), %rsi       # 0x2075
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1050
movl 0x1c(%r14), %ebp
jmp 0x154d
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x153e
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%r14)
movq %r14, 0x10(%rax)
movq %rax, %r14
jmp 0x154d
movq 0x10(%r14), %rbx
movq %r14, %rdi
callq 0x1030
movq %rbx, %r14
testq %r14, %r14
jne 0x1524
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/shuimu[P]logistic-regression/lr.cpp
// Function: command_line_parse(int, char**)
int command_line_parse(int argc, char * argv[]) {
    int i = 0;
    while (i < argc) {
        char * arg = argv[i];
        if (strcmp(arg,"-n") == 0) { MAX_ITERS = atoi(argv[++i]); }
        else if (strcmp(arg, "-t") == 0) { train_file = argv[++i]; }
        else if (strcmp(arg, "-p") == 0) { predict_file = argv[++i]; }
        else if (strcmp(arg, "-o") == 0) { output_file= argv[++i]; }
        else if (strcmp(arg, "-a") == 0) { ALPHA = atof(argv[++i]); }
        else if (strcmp(arg, "-k") == 0) { ALGO  = atoi(argv[++i]); } 
        i++;
    }
    if (predict_file == NULL || train_file == NULL || output_file == NULL) {
        fprintf(stderr, "ERROR: command line not well formatted!");
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
xorl %r15d, %r15d
cmpl %r14d, %r15d
jge 0x1521
movslq %r15d, %rax
movq (%rbx,%rax,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x1519
cmpb $0x6e, 0x1(%rcx)
jne 0x146b
cmpb $0x0, 0x2(%rcx)
je 0x14bc
cmpb $0x74, 0x1(%rcx)
jne 0x1477
cmpb $0x0, 0x2(%rcx)
je 0x14d1
cmpb $0x70, 0x1(%rcx)
jne 0x1483
cmpb $0x0, 0x2(%rcx)
je 0x14e2
cmpb $0x6f, 0x1(%rcx)
jne 0x148f
cmpb $0x0, 0x2(%rcx)
je 0x14f3
cmpb $0x61, 0x1(%rcx)
jne 0x149b
cmpb $0x0, 0x2(%rcx)
je 0x1504
cmpb $0x6b, 0x1(%rcx)
jne 0x1519
cmpb $0x0, 0x2(%rcx)
jne 0x1519
incl %r15d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1150
movl %eax, 0x3c4a(%rip)      # 0x5104
jmp 0x1519
incl %r15d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1150
movl %eax, 0x3c31(%rip)      # 0x5100
jmp 0x1519
incl %r15d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x3c40(%rip)      # 0x5120
jmp 0x1519
incl %r15d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x3c37(%rip)      # 0x5128
jmp 0x1519
incl %r15d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x3c2e(%rip)      # 0x5130
jmp 0x1519
incl %r15d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1100
movsd %xmm0, 0x3bd7(%rip)     # 0x50f0
incl %r15d
jmp 0x1446
cmpq $0x0, 0x3bff(%rip)      # 0x5128
je 0x154c
cmpq $0x0, 0x3bed(%rip)      # 0x5120
je 0x154c
xorl %eax, %eax
cmpq $0x0, 0x3bf1(%rip)      # 0x5130
je 0x154c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3a85(%rip), %rax      # 0x4fd8
movq (%rax), %rcx
leaq 0x1ae3(%rip), %rdi      # 0x3040
pushq $0x27
popq %rsi
pushq $0x1
popq %rdx
callq 0x11b0
pushq $-0x1
popq %rax
jmp 0x1541
// File: /workspace/github_cpp_makefile_star2_O2/shuimu[P]logistic-regression/lr.cpp
// Function: print_help()
void print_help() {
    fprintf(stderr, "\n\n     Linear Regression Command Usage:    \n");
    fprintf(stderr, "\n     ./lr -n <int> -a <double> -k <int> -t <string> -i <string> -o <string>\n");
    fprintf(stderr, "\n     -n maximum iterators                ");
    fprintf(stderr, "\n     -a alpha parameter                  ");
    fprintf(stderr, "\n     -k [1,2] bgd or sgd algorithm       ");
    fprintf(stderr, "\n     -t train file                       ");
    fprintf(stderr, "\n     -p predict file                     ");
    fprintf(stderr, "\n     -o output file                      \n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x3a59(%rip), %r12      # 0x4fd8
movq (%r12), %rcx
leaq 0x1ade(%rip), %rdi      # 0x3068
pushq $0x2c
popq %rbx
pushq $0x1
popq %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x11b0
movq (%r12), %rcx
leaq 0x1aee(%rip), %rdi      # 0x3095
pushq $0x4d
popq %rsi
movq %r14, %rdx
callq 0x11b0
movq (%r12), %rcx
leaq 0x1b26(%rip), %rdi      # 0x30e3
pushq $0x2a
popq %r15
movq %r15, %rsi
movq %r14, %rdx
callq 0x11b0
movq (%r12), %rcx
leaq 0x1b37(%rip), %rdi      # 0x310e
movq %r15, %rsi
movq %r14, %rdx
callq 0x11b0
movq (%r12), %rcx
leaq 0x1b4c(%rip), %rdi      # 0x3139
movq %r15, %rsi
movq %r14, %rdx
callq 0x11b0
movq (%r12), %rcx
leaq 0x1b61(%rip), %rdi      # 0x3164
movq %r15, %rsi
movq %r14, %rdx
callq 0x11b0
movq (%r12), %rcx
leaq 0x1b76(%rip), %rdi      # 0x318f
movq %r15, %rsi
movq %r14, %rdx
callq 0x11b0
movq (%r12), %rcx
leaq 0x1b8b(%rip), %rdi      # 0x31ba
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11b0
// File: /workspace/github_cpp_makefile_star2_O2/shuimu[P]logistic-regression/lr.cpp
// Function: bdg()
void bdg() {
    for(int j = 0; j < D; j++) {
        J_sita_dev[j] = 0;
        for(int i = 0; i < M; i++) {
            J_sita_dev[j] += func(i)*train_features[i][j];
        }
    }
    J_sita_0_dev = 0;
    for(int i = 0; i < M; i++) J_sita_0_dev += func(i); 
    
    for(int j = 0; j < D; j++) J_sita_dev[j] /= M;
    J_sita_0_dev /= M;
    
    for(int j = 0; j < D; j++) J_sita[j] -= ALPHA*J_sita_dev[j];
    J_sita_0 -= ALPHA*J_sita_0_dev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
movslq 0x3a3f(%rip), %rax      # 0x50fc
cmpq %rax, %r14
jge 0x1718
movq 0x3aff(%rip), %rax      # 0x51c8
andq $0x0, (%rax,%r14,8)
xorl %r15d, %r15d
xorl %ebx, %ebx
movslq 0x3a1e(%rip), %rax      # 0x50f8
cmpq %rax, %rbx
jge 0x1713
movl %ebx, %edi
callq 0x1642
movq 0x3a4b(%rip), %rax      # 0x5138
movq (%rax,%r15), %rax
movq 0x3ad0(%rip), %rcx      # 0x51c8
mulsd (%rax,%r14,8), %xmm0
addsd (%rcx,%r14,8), %xmm0
movsd %xmm0, (%rcx,%r14,8)
incq %rbx
addq $0x18, %r15
jmp 0x16d3
incq %r14
jmp 0x16b6
andq $0x0, 0x3ac8(%rip)      # 0x51e8
xorl %ebx, %ebx
movl 0x39d0(%rip), %ecx      # 0x50f8
cmpl %ecx, %ebx
jge 0x1747
movl %ebx, %edi
callq 0x1642
addsd 0x3aad(%rip), %xmm0     # 0x51e8
movsd %xmm0, 0x3aa5(%rip)     # 0x51e8
incl %ebx
jmp 0x1722
movl 0x39af(%rip), %eax      # 0x50fc
cvtsi2sd %ecx, %xmm0
movq 0x3a70(%rip), %rcx      # 0x51c8
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x1777
movsd (%rcx,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
jmp 0x175f
movsd 0x3a69(%rip), %xmm1     # 0x51e8
divsd %xmm0, %xmm1
movsd %xmm1, 0x3a5d(%rip)     # 0x51e8
movq 0x3a36(%rip), %rcx      # 0x51c8
movq 0x3a17(%rip), %rdx      # 0x51b0
xorl %esi, %esi
movsd 0x394d(%rip), %xmm0     # 0x50f0
cmpq %rsi, %rax
je 0x17c0
mulsd (%rcx,%rsi,8), %xmm0
movsd (%rdx,%rsi,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
jmp 0x179b
movsd 0x3a18(%rip), %xmm1     # 0x51e0
mulsd 0x3a18(%rip), %xmm0     # 0x51e8
subsd %xmm0, %xmm1
movsd %xmm1, 0x3a04(%rip)     # 0x51e0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/shuimu[P]logistic-regression/lr.cpp
// Function: sgd(int)
void sgd(int k) {
    for(int j = 0; j < D; j++) {
        J_sita_dev[j] = func(k)*train_features[k][j];
    }
    J_sita_0_dev = func(k);

    for(int j = 0; j < D; j++) J_sita[j] -= ALPHA*J_sita_dev[j];
    J_sita_0 -= ALPHA*J_sita_0_dev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movslq %edi, %rax
xorl %r14d, %r14d
imulq $0x18, %rax, %r15
movslq 0x38f7(%rip), %r12      # 0x50fc
movl %ebx, %edi
callq 0x1642
cmpq %r12, %r14
jge 0x1834
movq 0x3920(%rip), %rax      # 0x5138
movq (%rax,%r15), %rax
mulsd (%rax,%r14,8), %xmm0
movq 0x399f(%rip), %rax      # 0x51c8
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x17fe
movsd %xmm0, 0x39ac(%rip)     # 0x51e8
movslq 0x38b9(%rip), %rax      # 0x50fc
movq 0x397e(%rip), %rcx      # 0x51c8
movq 0x395f(%rip), %rdx      # 0x51b0
xorl %esi, %esi
movsd 0x3895(%rip), %xmm0     # 0x50f0
cmpq %rax, %rsi
jge 0x1878
mulsd (%rcx,%rsi,8), %xmm0
movsd (%rdx,%rsi,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
jmp 0x1853
movsd 0x3960(%rip), %xmm1     # 0x51e0
mulsd 0x3960(%rip), %xmm0     # 0x51e8
subsd %xmm0, %xmm1
movsd %xmm1, 0x394c(%rip)     # 0x51e0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/shuimu[P]logistic-regression/lr.cpp
// Function: split(char const*, char, int*)
char ** split(const char * string, char delim, int * count) {
    if( !string )
        return 0;
    int i, j, c;
    i = 0; j = c = 1;
    int length = strlen(string);
    char * copy_str = (char *) malloc(length+1);
    memmove(copy_str, string, length);
    copy_str[length] = '\0';
    for(; i < length; i++) {
        if(copy_str[i] == delim) {
            c += 1;
        }
    }
    (*count) = c;
    char** str_array = (char**)malloc(sizeof(char*) * c);
    str_array[0] = copy_str;
    for(i = 0; i < length; i++) {
        if(copy_str[i] == delim) {
            copy_str[i] = '\0';
            str_array[j++] = copy_str + i + 1;
        }
    }
    return str_array;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x1946
movl %esi, %ebx
movq %rdi, %r13
movq %rdx, -0x30(%rbp)
callq 0x1060
movq %rax, %r12
incl %eax
movslq %eax, %rdi
callq 0x1110
movq %rax, %r15
movslq %r12d, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1090
movq -0x30(%rbp), %rdx
movb $0x0, (%r15,%r12)
testl %r12d, %r12d
cmovlel %r14d, %r12d
pushq $0x1
popq %rax
cmpq %r14, %r12
je 0x190e
xorl %ecx, %ecx
cmpb %bl, (%r15,%r14)
sete %cl
addl %ecx, %eax
incq %r14
jmp 0x18f9
movl %eax, (%rdx)
movl %eax, %edi
shlq $0x3, %rdi
callq 0x1110
movq %rax, %r14
movq %r15, (%rax)
incq %r15
pushq $0x1
popq %rax
subq $0x1, %r12
jb 0x1946
cmpb %bl, -0x1(%r15)
jne 0x1941
movb $0x0, -0x1(%r15)
movslq %eax, %rcx
incl %eax
movq %r15, (%r14,%rcx,8)
incq %r15
jmp 0x1927
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/shuimu[P]logistic-regression/lr.cpp
// Function: pfunc(int)
double pfunc(int k) {
    double ret = 0.0;
    for(int i = 0; i < D; i++) {
        ret += J_sita[i]*predict_features[k][i];
    }
    return logistic_func(ret+J_sita_0) > 0.5 ? 1.0 : 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x3496(%rip), %eax      # 0x50fc
movq 0x3543(%rip), %rcx      # 0x51b0
movslq %edi, %rdx
imulq $0x18, %rdx, %rdx
addq 0x34d5(%rip), %rdx      # 0x5150
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
xorpd %xmm0, %xmm0
cmpq %rsi, %rax
je 0x1ca1
movsd (%rcx,%rsi,8), %xmm1
movq (%rdx), %rdi
mulsd (%rdi,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
jmp 0x1c86
addsd 0x3537(%rip), %xmm0     # 0x51e0
callq 0x140c
movsd 0x1382(%rip), %xmm1     # 0x3038
cmpltsd %xmm0, %xmm1
movsd 0x136d(%rip), %xmm0     # 0x3030
andpd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/shuimu[P]logistic-regression/lr.cpp
// Function: predict()
void predict() {
    FILE * ofp;
    if((ofp = fopen(output_file, "w")) == NULL) {
        fprintf(stderr, "ERROR: Can't open output file");
    }
    for(int i = 0; i < predict_features.size(); i++) {
        fprintf(ofp, "%s", predict_instances[i]);
        for(int j = 0; j < D; j++) {
            fprintf(ofp, "\t%.3f", predict_features[i][j]);
        }
        fprintf(ofp, "\t%.3f\n", pfunc(i));
    }
    fclose(ofp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x3452(%rip), %rdi      # 0x5130
leaq 0x1536(%rip), %rsi      # 0x321b
callq 0x10f0
movq %rax, %rbx
testq %rax, %rax
je 0x1d9b
xorl %r14d, %r14d
leaq 0x153b(%rip), %r15      # 0x323b
movq 0x3451(%rip), %rax      # 0x5158
subq 0x3442(%rip), %rax      # 0x5150
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %r14, %rax
jbe 0x1d85
movq 0x3476(%rip), %rax      # 0x5198
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
callq 0x10e0
imulq $0x18, %r14, %r13
xorl %r12d, %r12d
movslq 0x33c0(%rip), %rax      # 0x50fc
cmpq %rax, %r12
jge 0x1d64
movq 0x3408(%rip), %rax      # 0x5150
movq (%rax,%r13), %rax
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x1120
incq %r12
jmp 0x1d35
movl %r14d, %edi
callq 0x1c5c
movq %rbx, %rdi
leaq 0x14cb(%rip), %rsi      # 0x3241
movb $0x1, %al
callq 0x1120
incq %r14
jmp 0x1d00
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
movq 0x3236(%rip), %rax      # 0x4fd8
movq (%rax), %rcx
leaq 0x1471(%rip), %rdi      # 0x321d
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x11b0
jmp 0x1cf6
// File: /workspace/github_cpp_makefile_star2_O2/shuimu[P]logistic-regression/lr.cpp
// Function: main
int main(int argc, char * argv[]) {
    if (command_line_parse(argc, argv) != 0) { print_help(); return -1; }
    if (load_data() != 0) { print_help(); return -1; }
    init_alldata();
    if(ALGO == 1) bgd_train_model();
    else sgd_train_model();
    predict();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1433
testl %eax, %eax
jne 0x1dd2
callq 0x1958
testl %eax, %eax
je 0x1ddc
callq 0x156d
pushq $-0x1
popq %rax
popq %rbp
retq
callq 0x1baa
cmpl $0x1, 0x331c(%rip)      # 0x5104
jne 0x1df1
callq 0x1c3c
jmp 0x1df6
callq 0x1c11
callq 0x1cc9
xorl %eax, %eax
jmp 0x1dda
nop
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/corerc.c
// Function: truncfilename
void truncfilename(char* path)
{
	char* i = getfilename(path);
	memmove(path,i,strlen(i)+1);
	i = strrchr(path,'.');
	if (i) *i=0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1243
movq %rax, %r14
movq %rax, %rdi
callq 0x1050
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10e0
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x1070
testq %rax, %rax
je 0x1298
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]asyncore_cpp/net/worker/keyvalueworker_impl.h
// Function: net::WorkerStatus net::worker::KeyValueWorker<net::protocol::RedisProtocol>::operator()<net::ClientBuffer<1024ul>>(net::ClientBuffer<1024ul>&)
WorkerStatus KeyValueWorker<PROTOCOL>::operator()(CONNECTION &buffer){
	if (buffer.size() == 0)
		return WorkerStatus::PASS;

	using ProtocolStatus = net::protocol::ProtocolStatus;

	auto status = protocol_( StringRef{ buffer.data(), buffer.size() } );

	switch(status){
		case ProtocolStatus::BUFFER_NOT_READ :
			return WorkerStatus::PASS;

		case ProtocolStatus::OK : {
			protocol_.print();

			return process_request_(buffer);
		}

		case ProtocolStatus::ERROR : {
			buffer.clear();
			buffer.push( PROTOCOL::RESPONSE_ERROR );
			return WorkerStatus::WRITE;
		}
	}

	return WorkerStatus::WRITE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movzwl 0x2(%rsi), %eax
movzwl (%rsi), %ecx
xorl %r15d, %r15d
cmpw %cx, %ax
je 0x338a
movq %rsi, %rbx
movq %rdi, %r14
subq %rcx, %rax
addq %rsi, %rcx
addq $0x4, %rcx
leaq -0x28(%rbp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
callq 0x3ab6
cmpl $0x2, %eax
je 0x3374
cmpl $0x1, %eax
je 0x338a
testl %eax, %eax
jne 0x3386
movq %r14, %rdi
callq 0x3a74
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3398
movl %eax, %r15d
jmp 0x338a
andl $0x0, (%rbx)
leaq 0x4e0a(%rip), %rsi      # 0x8188
movq %rbx, %rdi
callq 0x33d4
pushq $0x2
popq %r15
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq