LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseIfExpr()
ASTNode *Parser::parseIfExpr() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseIfExpr"<<std::endl;
    #endif
    getNextToken(); // eat "if"
    ASTNode *cond = this->parseParenExpr();
    ASTNode *ifblock = this->parseBlock();
    ASTNode *elseblock = nullptr;
    if (curToken.second == "else") {
        getNextToken(); // eat "else"
        if (curToken.second == "if") {  // "else if"
            elseblock = this->parseIfExpr();
        } else {
            elseblock = this->parseBlock();   // "else {}"
        }
    }
    ASTNode *ifExpr = new IfExprAST(cond, ifblock, elseblock);
    return ifExpr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movslq 0x80(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%rdi)
movq (%rdi), %rcx
leaq (%rax,%rax,4), %rax
leaq 0x8(%rcx,%rax,8), %rsi
movl -0x8(%rsi), %eax
movl %eax, 0x58(%rdi)
leaq 0x60(%rdi), %r12
movq %r12, %rdi
callq 0x3130
movq %r15, %rdi
callq 0xa212
movq %rax, %rbx
movq %r15, %rdi
callq 0xa4c4
movq %rax, %r14
leaq 0x57d4(%rip), %rsi      # 0xf10b
movq %r12, %rdi
callq 0x30a0
testl %eax, %eax
je 0x9948
xorl %r15d, %r15d
jmp 0x9999
movslq 0x80(%r15), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%r15)
movq (%r15), %rcx
leaq (%rax,%rax,4), %rax
leaq 0x8(%rcx,%rax,8), %rsi
movl -0x8(%rsi), %eax
movl %eax, 0x58(%r15)
movq %r12, %rdi
callq 0x3130
leaq 0x578d(%rip), %rsi      # 0xf108
movq %r12, %rdi
callq 0x30a0
movq %r15, %rdi
testl %eax, %eax
je 0x9991
callq 0xa4c4
jmp 0x9996
callq 0x98de
movq %rax, %r15
movl $0x28, %edi
callq 0x31e0
movl $0x0, 0x8(%rax)
leaq 0xa27f(%rip), %rcx      # 0x13c30
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %r15, 0x20(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseWhileExpr()
ASTNode *Parser::parseWhileExpr() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseWhileExpr"<<std::endl;
    #endif
    getNextToken(); // eat "while"
    ASTNode *cond = this->parseParenExpr();
    ASTNode *block = this->parseBlock();
    ASTNode *whileExpr = new WhileExprAST(cond, block);
    return whileExpr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x80(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%rdi)
movq (%rdi), %rcx
leaq (%rax,%rax,4), %rax
leaq 0x8(%rcx,%rax,8), %rsi
movl -0x8(%rsi), %eax
movl %eax, 0x58(%rdi)
addq $0x60, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0xa212
movq %rax, %r14
movq %rbx, %rdi
callq 0xa4c4
movq %rax, %rbx
movl $0x20, %edi
callq 0x31e0
movl $0x0, 0x8(%rax)
leaq 0xa247(%rip), %rcx      # 0x13c78
addq $0x10, %rcx
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseFuncReturn()
ASTNode *Parser::parseFuncReturn() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseFuncReturn"<<std::endl;
    #endif
    getNextToken(); // eat "return"
    ASTNode *retExpr = this->parseExpression();
    if (!retExpr) {
        retExpr = new NumberAST("0");
    }
    return new ReturnAST(retExpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0x80(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%rdi)
movq (%rdi), %rcx
leaq (%rax,%rax,4), %rax
leaq 0x8(%rcx,%rax,8), %rsi
movl -0x8(%rsi), %eax
movl %eax, 0x58(%rdi)
addq $0x60, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x9b7a
movq %rax, %rbx
testq %rax, %rax
jne 0x9b25
movl $0x30, %edi
callq 0x31e0
movq %rax, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x580b(%rip), %rsi      # 0xf2de
leaq 0x5805(%rip), %rdx      # 0xf2df
leaq -0x38(%rbp), %rdi
callq 0x47f6
movl $0x0, 0x8(%rbx)
leaq 0x9fd7(%rip), %rax      # 0x13ac8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
movq %rbx, %rax
addq $0x20, %rax
movq %rax, 0x10(%rbx)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
callq 0x42ce
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x9b25
callq 0x31c0
movl $0x18, %edi
callq 0x31e0
movl $0x0, 0x8(%rax)
leaq 0xa1cb(%rip), %rcx      # 0x13d08
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x9b69
callq 0x31c0
jmp 0x9b69
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O1/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseNumber()
ASTNode *Parser::parseNumber() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseNumber"<<std::endl;
    #endif
    // ASTNode *result = new NumberAST(strtod(curToken.second.c_str(), nullptr));
    ASTNode *result = new NumberAST(curToken.second);
    getNextToken();
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x30, %edi
callq 0x31e0
movq %rax, %rbx
movl $0x0, 0x8(%rax)
leaq 0x9925(%rip), %rax      # 0x13ac8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
addq %rsi, %rdx
callq 0x42ce
leaq 0x60(%r14), %rdi
movslq 0x80(%r14), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%r14)
movq (%r14), %rcx
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %rsi
addq $0x8, %rsi
movl -0x8(%rsi), %eax
movl %eax, 0x58(%r14)
callq 0x3130
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O1/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseParenExpr()
ASTNode *Parser::parseParenExpr() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseParenExpr"<<std::endl;
    #endif
    getNextToken();  // eat '('
    ASTNode *expr = this->parseExpression();
    if (curToken.first != static_cast<Token>(')')) {
        std::cout<<"expected \')\'"<<std::endl;
    }
    getNextToken();  // eat ')'
    return expr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x80(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%rdi)
movq (%rdi), %rcx
leaq (%rax,%rax,4), %rax
leaq 0x8(%rcx,%rax,8), %rsi
movl -0x8(%rsi), %eax
movl %eax, 0x58(%rdi)
leaq 0x60(%rdi), %r14
movq %r14, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x9b7a
movq %rax, %r15
cmpl $0x29, 0x58(%rbx)
je 0xa2a2
movq 0x9d6a(%rip), %r12      # 0x13fd0
leaq 0x5064(%rip), %rsi      # 0xf2d1
movl $0xc, %edx
movq %r12, %rdi
callq 0x3230
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3150
movslq 0x80(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%rbx)
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
leaq 0x8(%rcx,%rax,8), %rsi
movl -0x8(%rsi), %eax
movl %eax, 0x58(%rbx)
movq %r14, %rdi
callq 0x3130
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/KJTang[P]SimpleCompiler/Parser.cpp
// Function: Parser::parseBlock()
ASTNode *Parser::parseBlock() {
    #ifdef DEBUG
    std::cout<<curToken.second<<"\tparseBlock"<<std::endl;
    #endif
    getNextToken(); // eat '{'
    std::vector<ASTNode*> stats;
    while (curToken.first != static_cast<Token>('}')) {
        ASTNode *newStat = this->parseStatement();
        if (newStat) {
            stats.push_back(newStat);
        }
    }
    ASTNode *block = new BlockAST(stats);
    getNextToken(); // eat '}'
    return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movslq 0x80(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%rdi)
movq (%rdi), %rcx
leaq (%rax,%rax,4), %rax
leaq 0x8(%rcx,%rax,8), %rsi
movl -0x8(%rsi), %eax
movl %eax, 0x58(%rdi)
leaq 0x60(%rdi), %r14
movq %r14, %rdi
callq 0x3130
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
cmpl $0x7d, 0x58(%rbx)
je 0xa557
leaq -0x40(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %rbx, %rdi
callq 0x98a0
movq %rax, -0x48(%rbp)
testq %rax, %rax
je 0xa551
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0xa546
movq %rax, (%rsi)
addq $0x8, -0x38(%rbp)
jmp 0xa551
movq %r15, %rdi
movq %r12, %rdx
callq 0xb060
cmpl $0x7d, 0x58(%rbx)
jne 0xa521
movl $0x28, %edi
callq 0x31e0
movq %rax, %r15
movl $0x0, 0x8(%rax)
leaq 0x9676(%rip), %rax      # 0x13be8
addq $0x10, %rax
movq %rax, (%r15)
movq %r15, %rdi
addq $0x10, %rdi
leaq -0x40(%rbp), %rsi
callq 0xae2a
movslq 0x80(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x80(%rbx)
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rax
leaq 0x8(%rcx,%rax,8), %rsi
movl -0x8(%rsi), %eax
movl %eax, 0x58(%rbx)
movq %r14, %rdi
callq 0x3130
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xa5c1
callq 0x31c0
movq %r15, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x31c0
jmp 0xa5e3
jmp 0xa5e0
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0xa5f1
callq 0x31c0
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O1/KJTang[P]SimpleCompiler/Assembler.cpp
// Function: Assembler::assemble()
bool Assembler::assemble() {
    this->init();
    this->redirect();
    this->interpret();
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xb984
movq %rbx, %rdi
callq 0xbfa0
movq %rbx, %rdi
callq 0xc358
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/KJTang[P]SimpleCompiler/Assembler.cpp
// Function: Assembler::interpret()
bool Assembler::interpret() {
    std::ostringstream oss;
    for (auto it = this->instructions.begin(); it != this->instructions.end(); ++it) {
        oss<<static_cast<int>(it->op)<<" ";
        for (int i = 0; i != it->args.size(); ++i) {
            oss<<it->args[i]<<" ";
        }
    }
    this->binCode = oss.str();
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x3280
movq 0x70(%rbx), %r12
movq %rbx, -0x30(%rbp)
cmpq 0x78(%rbx), %r12
je 0xc418
leaq -0x1c8(%rbp), %r14
leaq 0x2ec0(%rip), %r15      # 0xf25b
movl 0x20(%r12), %esi
movq %r14, %rdi
callq 0x3320
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3230
movq 0x28(%r12), %rax
cmpq %rax, 0x30(%r12)
je 0xc40a
movl $0x8, %r13d
xorl %ebx, %ebx
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r14, %rdi
callq 0x3230
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3230
incq %rbx
movq 0x28(%r12), %rax
movq 0x30(%r12), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %rcx, %rbx
jne 0xc3cc
addq $0x40, %r12
movq -0x30(%rbp), %rax
cmpq 0x78(%rax), %r12
jne 0xc39b
leaq -0x1c0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x32d0
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
leaq -0x50(%rbp), %r14
movq %r14, %rsi
callq 0x3250
movq (%r14), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xc44d
callq 0x31c0
movq 0x7b74(%rip), %rsi      # 0x13fc8
leaq -0x1c8(%rbp), %rdi
callq 0x3120
leaq -0x158(%rbp), %rdi
callq 0x30c0
movb $0x1, %al
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc484
jmp 0xc484
movq %rax, %rbx
movq 0x7b3a(%rip), %rsi      # 0x13fc8
leaq -0x1c8(%rbp), %rdi
callq 0x3120
leaq -0x158(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O1/KJTang[P]SimpleCompiler/VirtualMachine.cpp
// Function: VirtualMachine::printStack()
void VirtualMachine::printStack() {
    if (!this->stack.empty()) {
        std::cout<<"stack top: "<<this->stack.top()<<std::endl;
    } else {
        std::cout<<"stack top: none"<<std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x48(%rdi), %rax
cmpq 0x28(%rdi), %rax
je 0xd40e
movq %rdi, %rbx
movq 0x6bfe(%rip), %rdi      # 0x13fd0
leaq 0x204b(%rip), %rsi      # 0xf424
movl $0xb, %edx
callq 0x3230
movq 0x48(%rbx), %rax
cmpq 0x50(%rbx), %rax
jne 0xd3fa
movq 0x60(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movl -0x4(%rax), %esi
movq 0x6bcc(%rip), %rdi      # 0x13fd0
callq 0x3320
movq %rax, %rbx
jmp 0xd429
movq 0x6bbb(%rip), %rbx      # 0x13fd0
leaq 0x2014(%rip), %rsi      # 0xf430
movl $0xf, %edx
movq %rbx, %rdi
callq 0x3230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3150
// File: /workspace/github_cpp_makefile_star2_O1/KJTang[P]SimpleCompiler/VirtualMachine.cpp
// Function: VirtualMachine::printData()
void VirtualMachine::printData() {
    for (int i = 0; i != eipStack.size()+1; ++i) {
        std::cout<<"data stack "<<i<<": ";
        for (int j = 0; j != 10; ++j) {
            std::cout<<data[i][j]<<" ";
        }
        std::cout<<std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x6b5f(%rip), %r15      # 0x13fd0
leaq 0x1de3(%rip), %r12      # 0xf25b
movq 0xe8(%rbx), %rax
movq %rax, %rcx
subq 0xc8(%rbx), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x7, %rcx
movq 0xd0(%rbx), %rax
subq 0xd8(%rbx), %rax
movq 0xc0(%rbx), %rdx
sarq $0x2, %rax
subq 0xb0(%rbx), %rdx
sarq $0x2, %rdx
addq %rcx, %rax
addq %rdx, %rax
incq %rax
cmpq %r14, %rax
je 0xd561
movl $0xb, %edx
movq %r15, %rdi
leaq 0x1f62(%rip), %rsi      # 0xf440
callq 0x3230
movq %r15, %rdi
movl %r14d, %esi
callq 0x3320
movl $0x2, %edx
movq %rax, %rdi
leaq 0x1d42(%rip), %rsi      # 0xf23f
callq 0x3230
xorl %r13d, %r13d
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rax
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x3320
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3230
incq %r13
cmpq $0xa, %r13
jne 0xd505
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3150
incq %r14
jmp 0xd478
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/thunlp[P]KB2E/CTransR/Train_CTransR.cpp
// Function: Train::add(int, int, int)
void add(int x,int y,int z)
    {
        fb_h.push_back(x);
        fb_r.push_back(z);
        fb_l.push_back(y);
        ok[make_pair(x,z)][y]=1;
        ok_fb[make_pair(x,cluster2fb[z])][y]=1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %eax
movq %rdi, %rbx
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x98(%rdi), %rsi
cmpq 0xa0(%rdi), %rsi
je 0x3db2
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x98(%rbx)
jmp 0x3dc3
leaq 0x90(%rbx), %rdi
leaq 0x14(%rsp), %rdx
callq 0x47d6
movq 0xc8(%rbx), %rsi
cmpq 0xd0(%rbx), %rsi
je 0x3de6
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xc8(%rbx)
jmp 0x3df7
leaq 0xc0(%rbx), %rdi
leaq 0xc(%rsp), %rdx
callq 0x47d6
movq 0xb0(%rbx), %rsi
cmpq 0xb8(%rbx), %rsi
je 0x3e1a
movl 0x10(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xb0(%rbx)
jmp 0x3e2b
leaq 0xa8(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x47d6
movl 0x14(%rsp), %eax
leaq 0xc(%rsp), %r12
movl (%r12), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x18(%rsp), %r15
movq %rcx, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4748
leaq 0x10(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3cc8
movl $0x1, %ebp
movl %ebp, (%rax)
addq $0x30, %rbx
leaq 0x390dc(%rip), %rdi     # 0x3cf50
movq %r12, %rsi
callq 0x3cc8
movl 0x14(%rsp), %ecx
movl (%rax), %eax
shlq $0x20, %rax
orq %rcx, %rax
movq %rax, (%r15)
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x4748
movq %rax, %rdi
movq %r14, %rsi
callq 0x3cc8
movl %ebp, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: get2RegName[abi:cxx11](int)
string get2RegName(int i) {
    switch (i) {
    case 0: return "%al";
    case 1: return "%bl";
    case 2: return "%cl";
    case 3: return "%dl";
    case 4: return "%sil";
    case 5: return "%dil";
    case 6: return "%r8b";
    case 7: return "%r9b";
    case 8: return "%r10b";
    case 9: return "%r11b";
    case 10: return "%r12b";
    case 11: return "%r13b";
    case 12: return "%r14b";
    case 13: return "%r15b";
    }
    return "unknown4reg";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0xd, %esi
ja 0x3854
movl %esi, %eax
leaq 0x98b7(%rip), %rcx      # 0xd010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x9a3b(%rip), %rsi      # 0xd1a4
leaq 0x9a37(%rip), %rdx      # 0xd1a7
jmp 0x3862
leaq 0x9a5e(%rip), %rsi      # 0xd1da
leaq 0x9a5c(%rip), %rdx      # 0xd1df
jmp 0x3862
leaq 0x9a25(%rip), %rsi      # 0xd1b4
leaq 0x9a22(%rip), %rdx      # 0xd1b8
jmp 0x3862
leaq 0x9a3e(%rip), %rsi      # 0xd1e0
leaq 0x9a3c(%rip), %rdx      # 0xd1e5
jmp 0x3862
leaq 0x9a19(%rip), %rsi      # 0xd1ce
leaq 0x9a17(%rip), %rdx      # 0xd1d3
jmp 0x3862
leaq 0x99e4(%rip), %rsi      # 0xd1ac
leaq 0x99e0(%rip), %rdx      # 0xd1af
jmp 0x3862
leaq 0x99d5(%rip), %rsi      # 0xd1b0
leaq 0x99d1(%rip), %rdx      # 0xd1b3
jmp 0x3862
leaq 0x99d8(%rip), %rsi      # 0xd1c3
leaq 0x99d5(%rip), %rdx      # 0xd1c7
jmp 0x3862
leaq 0x99ad(%rip), %rsi      # 0xd1a8
leaq 0x99a9(%rip), %rdx      # 0xd1ab
jmp 0x3862
leaq 0x99ae(%rip), %rsi      # 0xd1b9
leaq 0x99ab(%rip), %rdx      # 0xd1bd
jmp 0x3862
leaq 0x99cb(%rip), %rsi      # 0xd1e6
leaq 0x99c9(%rip), %rdx      # 0xd1eb
jmp 0x3862
leaq 0x9993(%rip), %rsi      # 0xd1be
leaq 0x9990(%rip), %rdx      # 0xd1c2
jmp 0x3862
leaq 0x9999(%rip), %rsi      # 0xd1d4
leaq 0x9997(%rip), %rdx      # 0xd1d9
jmp 0x3862
leaq 0x997d(%rip), %rsi      # 0xd1c8
leaq 0x997b(%rip), %rdx      # 0xd1cd
jmp 0x3862
leaq 0x9991(%rip), %rsi      # 0xd1ec
leaq 0x9995(%rip), %rdx      # 0xd1f7
movq %rbx, %rdi
callq 0x7948
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: get4RegName[abi:cxx11](int)
string get4RegName(int i) {
    switch (i) {
    case 0: return "%eax";
    case 1: return "%ebx";
    case 2: return "%ecx";
    case 3: return "%edx";
    case 4: return "%esi";
    case 5: return "%edi";
    case 6: return "%r8d";
    case 7: return "%r9d";
    case 8: return "%r10d";
    case 9: return "%r11d";
    case 10: return "%r12d";
    case 11: return "%r13d";
    case 12: return "%r14d";
    case 13: return "%r15d";
    }
    return "unknown4reg";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0xd, %esi
ja 0x3987
movl %esi, %eax
leaq 0x97bc(%rip), %rcx      # 0xd048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x995c(%rip), %rsi      # 0xd1f8
leaq 0x9959(%rip), %rdx      # 0xd1fc
jmp 0x3995
leaq 0x9983(%rip), %rsi      # 0xd232
leaq 0x9981(%rip), %rdx      # 0xd237
jmp 0x3995
leaq 0x994a(%rip), %rsi      # 0xd20c
leaq 0x9947(%rip), %rdx      # 0xd210
jmp 0x3995
leaq 0x9963(%rip), %rsi      # 0xd238
leaq 0x9961(%rip), %rdx      # 0xd23d
jmp 0x3995
leaq 0x993e(%rip), %rsi      # 0xd226
leaq 0x993c(%rip), %rdx      # 0xd22b
jmp 0x3995
leaq 0x9907(%rip), %rsi      # 0xd202
leaq 0x9904(%rip), %rdx      # 0xd206
jmp 0x3995
leaq 0x98f9(%rip), %rsi      # 0xd207
leaq 0x98f6(%rip), %rdx      # 0xd20b
jmp 0x3995
leaq 0x98fd(%rip), %rsi      # 0xd21b
leaq 0x98fa(%rip), %rdx      # 0xd21f
jmp 0x3995
leaq 0x98cf(%rip), %rsi      # 0xd1fd
leaq 0x98cc(%rip), %rdx      # 0xd201
jmp 0x3995
leaq 0x98d3(%rip), %rsi      # 0xd211
leaq 0x98d0(%rip), %rdx      # 0xd215
jmp 0x3995
leaq 0x98f0(%rip), %rsi      # 0xd23e
leaq 0x98ee(%rip), %rdx      # 0xd243
jmp 0x3995
leaq 0x98b8(%rip), %rsi      # 0xd216
leaq 0x98b5(%rip), %rdx      # 0xd21a
jmp 0x3995
leaq 0x98be(%rip), %rsi      # 0xd22c
leaq 0x98bc(%rip), %rdx      # 0xd231
jmp 0x3995
leaq 0x98a2(%rip), %rsi      # 0xd220
leaq 0x98a0(%rip), %rdx      # 0xd225
jmp 0x3995
leaq 0x985e(%rip), %rsi      # 0xd1ec
leaq 0x9862(%rip), %rdx      # 0xd1f7
movq %rbx, %rdi
callq 0x7948
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: get8RegName[abi:cxx11](int)
string get8RegName(int i) {
    switch (i) {
    case 0: return "%rax";
    case 1: return "%rbx";
    case 2: return "%rcx";
    case 3: return "%rdx";
    case 4: return "%rsi";
    case 5: return "%rdi";
    case 6: return "%r8";
    case 7: return "%r9";
    case 8: return "%r10";
    case 9: return "%r11";
    case 10: return "%r12";
    case 11: return "%r13";
    case 12: return "%r14";
    case 13: return "%r15";
    }
    return "unknown8reg";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0xd, %esi
ja 0x3aba
movl %esi, %eax
leaq 0x96c1(%rip), %rcx      # 0xd080
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x9875(%rip), %rsi      # 0xd244
leaq 0x9872(%rip), %rdx      # 0xd248
jmp 0x3ac8
leaq 0x9897(%rip), %rsi      # 0xd279
leaq 0x9894(%rip), %rdx      # 0xd27d
jmp 0x3ac8
leaq 0x9863(%rip), %rsi      # 0xd258
leaq 0x9860(%rip), %rdx      # 0xd25c
jmp 0x3ac8
leaq 0x9876(%rip), %rsi      # 0xd27e
leaq 0x9873(%rip), %rdx      # 0xd282
jmp 0x3ac8
leaq 0x9854(%rip), %rsi      # 0xd26f
leaq 0x9851(%rip), %rdx      # 0xd273
jmp 0x3ac8
leaq 0x9820(%rip), %rsi      # 0xd24e
leaq 0x981d(%rip), %rdx      # 0xd252
jmp 0x3ac8
leaq 0x9812(%rip), %rsi      # 0xd253
leaq 0x980f(%rip), %rdx      # 0xd257
jmp 0x3ac8
leaq 0x9815(%rip), %rsi      # 0xd266
leaq 0x9811(%rip), %rdx      # 0xd269
jmp 0x3ac8
leaq 0x97e8(%rip), %rsi      # 0xd249
leaq 0x97e5(%rip), %rdx      # 0xd24d
jmp 0x3ac8
leaq 0x97ec(%rip), %rsi      # 0xd25d
leaq 0x97e9(%rip), %rdx      # 0xd261
jmp 0x3ac8
leaq 0x9802(%rip), %rsi      # 0xd283
leaq 0x97ff(%rip), %rdx      # 0xd287
jmp 0x3ac8
leaq 0x97d1(%rip), %rsi      # 0xd262
leaq 0x97cd(%rip), %rdx      # 0xd265
jmp 0x3ac8
leaq 0x97d3(%rip), %rsi      # 0xd274
leaq 0x97d0(%rip), %rdx      # 0xd278
jmp 0x3ac8
leaq 0x97b9(%rip), %rsi      # 0xd26a
leaq 0x97b6(%rip), %rdx      # 0xd26e
jmp 0x3ac8
leaq 0x97c7(%rip), %rsi      # 0xd288
leaq 0x97cb(%rip), %rdx      # 0xd293
movq %rbx, %rdi
callq 0x7948
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: getTmpReg[abi:cxx11](int)
string getTmpReg(int size) {
    for (int i = 0; i < 14; i++) {
        if (!regUsed[i])
            return size == 2 ? get2RegName(i) : (size == 4 ? get4RegName(i) : get8RegName(i));
    }
    cerr << "no enough regs" << endl;
    throw 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
cmpb $0x1, 0xf98c(%rip)      # 0x13470
movl $0x0, %ebp
jne 0x3b14
xorl %ecx, %ecx
leaq 0xf97c(%rip), %rdx      # 0x13470
cmpq $0xd, %rcx
je 0x3b49
leaq 0x1(%rcx), %rax
cmpb $0x0, 0x1(%rcx,%rdx)
movq %rax, %rcx
jne 0x3af4
leaq -0x1(%rax), %rcx
cmpq $0xd, %rcx
setae %bpl
movq %rbx, %rdi
cmpl $0x4, %esi
je 0x3b2a
cmpl $0x2, %esi
jne 0x3b33
movl %eax, %esi
callq 0x373c
jmp 0x3b3a
movl %eax, %esi
callq 0x386f
jmp 0x3b3a
movl %eax, %esi
callq 0x39a2
testb %bpl, %bpl
jne 0x3b49
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xf4a0(%rip), %rdi      # 0x12ff0
leaq 0x973d(%rip), %rsi      # 0xd294
callq 0x31e0
movq %rax, %rdi
callq 0x3100
movl $0x4, %edi
callq 0x3110
movl $0x0, (%rax)
movq 0xf41d(%rip), %rsi      # 0x12f98
movq %rax, %rdi
xorl %edx, %edx
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: getSymbolMemory[abi:cxx11](Symbol*)
string getSymbolMemory(Symbol* sym) {
    if (varDeclare[sym].size() == 0) {
        cerr << "++++++++ trying getting empty symbol " << sym << endl;
        throw 0;
    }
    return varDeclare[sym] + string("(%rip)");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0xf327(%rip), %rdi      # 0x13240
movq %rax, %rsi
callq 0x7706
cmpq $0x0, 0x8(%rax)
je 0x3fdb
leaq 0xf30d(%rip), %rdi      # 0x13240
movq %rsp, %rsi
callq 0x7706
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x9386(%rip), %rsi      # 0xd2d5
leaq 0x9385(%rip), %rdx      # 0xd2db
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x7948
movq (%r14), %rcx
movq 0x8(%r14), %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3250
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x3f98
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x3f9e
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3fcc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xf00e(%rip), %rdi      # 0x12ff0
leaq 0x92c6(%rip), %rsi      # 0xd2af
callq 0x31e0
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x3100
movl $0x4, %edi
callq 0x3110
movl $0x0, (%rax)
movq 0xef7f(%rip), %rsi      # 0x12f98
movq %rax, %rdi
xorl %edx, %edx
callq 0x3390
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x403d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: handleCodeBlock(TreeNode*)
void handleCodeBlock(TreeNode* node) {
    if (node->nodeType == TreeNode::NODE_STATMENT
            && static_cast<StatementNode*>(node)->type == StatementNode::ST_SCOPE) {
        node = node->child;
    }
    while (node) {
        generateCode(node);
        node = node -> sibling;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, 0x10(%rdi)
jne 0x480b
cmpl $0x2, 0x30(%rbx)
jne 0x480b
movq 0x18(%rbx), %rbx
jmp 0x480b
movq %rbx, %rdi
callq 0x4812
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
jne 0x47ff
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: handleFunctionNode(TreeNode*)
void handleFunctionNode(TreeNode* node) {
    Symbol* ownSymbol = static_cast<TreeNode*>(node)->symbol;
    of << "\t.globl\t" << ownSymbol->value << "\n";
    of << "\t.type\t" << ownSymbol->value << ", @function\n";
    of << ownSymbol->value << ":\n";
    of << "\tpushq\t%rbp\n";
    of << "\tmovq\t%rsp, %rbp\n";

    auto children = node -> child;

    handleCodeBlock(children);

    while (true) {
        if (children->sibling != nullptr)
            children = children->sibling;
        else break;
    }

    if (children->nodeType == TreeNode::NODE_STATMENT
            && static_cast<StatementNode*>(children)->type == StatementNode::ST_RET) {

    } else {
        if (ownSymbol->value == "main") {
            of << "\tmovl $0, %eax\n";
        }
        of << "\tleave\n";
        of << "\tret\n";
    }
    of << "\t.size\t"<< ownSymbol->value <<", .-"<< ownSymbol->value <<"\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x28(%rdi), %r12
leaq 0xca1f(%rip), %r15      # 0x13270
leaq 0x6bc3(%rip), %rsi      # 0xd41b
movl $0x8, %edx
movq %r15, %rdi
callq 0x3260
leaq 0x8(%r12), %rbx
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r15, %rdi
callq 0x3260
leaq 0x6c9d(%rip), %rsi      # 0xd520
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
leaq 0x6b8d(%rip), %rsi      # 0xd424
movl $0x7, %edx
movq %r15, %rdi
callq 0x3260
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r15, %rdi
callq 0x3260
leaq 0x6b6f(%rip), %rsi      # 0xd42c
movl $0xc, %edx
movq %rax, %rdi
callq 0x3260
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %r15, %rdi
callq 0x3260
leaq 0x6ae5(%rip), %rsi      # 0xd3c8
movl $0x2, %edx
movq %rax, %rdi
callq 0x3260
leaq 0x6b42(%rip), %rsi      # 0xd439
movl $0xc, %edx
movq %r15, %rdi
callq 0x3260
leaq 0x6b3b(%rip), %rsi      # 0xd446
movl $0x11, %edx
movq %r15, %rdi
callq 0x3260
movq 0x18(%r14), %r14
movq %r14, %rdi
callq 0x47e9
movq %r14, %rax
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x6924
cmpl $0x1, 0x10(%rax)
jne 0x693c
cmpl $0x3, 0x30(%rax)
je 0x6996
leaq 0x6b15(%rip), %rsi      # 0xd458
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
jne 0x6967
leaq 0xc91a(%rip), %rdi      # 0x13270
leaq 0x6b00(%rip), %rsi      # 0xd45d
movl $0xf, %edx
callq 0x3260
leaq 0xc902(%rip), %rbx      # 0x13270
leaq 0x6af8(%rip), %rsi      # 0xd46d
movl $0x7, %edx
movq %rbx, %rdi
callq 0x3260
leaq 0x6aec(%rip), %rsi      # 0xd475
movl $0x5, %edx
movq %rbx, %rdi
callq 0x3260
leaq 0xc8d3(%rip), %rbx      # 0x13270
leaq 0x6ad7(%rip), %rsi      # 0xd47b
movl $0x7, %edx
movq %rbx, %rdi
callq 0x3260
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rbx, %rdi
callq 0x3260
movq %rax, %rbx
leaq 0x6ab6(%rip), %rsi      # 0xd483
movl $0x4, %edx
movq %rax, %rdi
callq 0x3260
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rbx, %rdi
callq 0x3260
leaq 0x6b2d(%rip), %rsi      # 0xd520
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3260
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/asm.cpp
// Function: handleWhile(StatementNode*)
void handleWhile(StatementNode* node) {
    string LCondition = getNextLabel();

    of << "\tjmp\t" << LCondition << "\n";

    string LBlock = getNextLabel();

    of << LBlock << ":\n";

    handleCodeBlock(node->child->sibling);

    of << LCondition << ":\n";
    string reg = handleExprNode(node->child);
    of << "\ttestl\t" << reg << ", " << reg << "\n";
    of << "\tje\t" << LBlock << "\n";
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4045
leaq 0xc84c(%rip), %rdi      # 0x13270
leaq 0x6997(%rip), %rsi      # 0xd3c2
movl $0x5, %edx
callq 0x3260
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0xc82a(%rip), %rdi      # 0x13270
callq 0x3260
leaq 0x6ace(%rip), %rsi      # 0xd520
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
leaq 0x20(%rsp), %rdi
callq 0x4045
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0xc7f6(%rip), %rdi      # 0x13270
callq 0x3260
leaq 0x6942(%rip), %rsi      # 0xd3c8
movl $0x2, %edx
movq %rax, %rdi
callq 0x3260
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x47e9
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0xc7bf(%rip), %rdi      # 0x13270
callq 0x3260
leaq 0x690b(%rip), %rsi      # 0xd3c8
movl $0x2, %edx
movq %rax, %rdi
callq 0x3260
movq 0x18(%rbx), %rsi
movq %rsp, %rdi
callq 0x5226
leaq 0xc793(%rip), %rdi      # 0x13270
leaq 0x68af(%rip), %rsi      # 0xd393
movl $0x7, %edx
callq 0x3260
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0xc772(%rip), %rdi      # 0x13270
callq 0x3260
movq %rax, %rbx
leaq 0x68c6(%rip), %rsi      # 0xd3d3
movl $0x2, %edx
movq %rax, %rdi
callq 0x3260
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3260
leaq 0x69ee(%rip), %rsi      # 0xd520
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
leaq 0xc72a(%rip), %rdi      # 0x13270
leaq 0x6865(%rip), %rsi      # 0xd3b2
movl $0x4, %edx
callq 0x3260
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0xc708(%rip), %rdi      # 0x13270
callq 0x3260
leaq 0x69ac(%rip), %rsi      # 0xd520
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b9c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bb7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bd2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3200
addq $0x60, %rsp
popq %rbx
retq
jmp 0x6be1
jmp 0x6bdc
movq %rax, %rbx
jmp 0x6c1f
movq %rax, %rbx
jmp 0x6c04
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c04
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c1f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c3a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    if (argc == 2) {
        FILE* fin = fopen(argv[1], "r");
        if (fin != nullptr) {
            yyin = fin;
        } else {
            cerr << "failed to open file: " << argv[1] << endl;
        }
    } else {
#if YYDEBUG != 0
        extern int yydebug;
        yydebug = 1;
#endif
    }

    scope = new Scope();

    yyparse();

    TreeNode* temp = root;

    while (temp) {
        showTree(temp);
        temp = temp -> sibling;
    }

    extern void generateASM();
    generateASM();

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x8617
movq %rsi, %r14
movq 0x8(%rsi), %rdi
leaq 0x6ea8(%rip), %rsi      # 0xf42b
callq 0x3280
testq %rax, %rax
je 0x8599
leaq 0xaf04(%rip), %rcx      # 0x13498
movq %rax, (%rcx)
jmp 0x8617
movq 0xaa50(%rip), %rbx      # 0x12ff0
leaq 0x51b9(%rip), %rsi      # 0xd760
movl $0x15, %edx
movq %rbx, %rdi
callq 0x3260
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x85d9
movq %r14, %rdi
callq 0x30f0
movq 0xaa24(%rip), %rdi      # 0x12ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x3260
jmp 0x85f0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x3370
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3150
movl $0x18, %edi
callq 0x31f0
movq %rax, %rbx
movq %rax, %rdi
callq 0xb788
leaq 0xaefd(%rip), %rax      # 0x13530
movq %rbx, (%rax)
callq 0xa0c0
leaq 0xaee6(%rip), %rax      # 0x13528
movq (%rax), %rbx
testq %rbx, %rbx
je 0x8658
movq %rbx, %rdi
callq 0x8000
movq 0x20(%rbx), %rbx
jmp 0x8645
callq 0x725d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x3200
movq %r14, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/scope.cpp
// Function: Scope::findSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Symbol *Scope::findSymbol(const string &name)
{
    for (const auto& l: scopeStack) {
        for (const auto& n: l) {
            if(n.name == name)
                return n.symbol;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r14
movq 0x8(%rsi), %r12
movq %rdi, (%rsp)
movq %rdi, %r13
movq (%r13), %r13
cmpq (%rsp), %r13
je 0xb8e5
leaq 0x10(%r13), %rbx
movq %rbx, %rbp
movq (%rbp), %rbp
cmpq %rbx, %rbp
je 0xb8de
movq 0x20(%rbp), %rdx
cmpq %r12, %rdx
jne 0xb8ce
testq %rdx, %rdx
je 0xb8d2
movq 0x18(%rbp), %rdi
movq %r14, %rsi
callq 0x3210
testl %eax, %eax
sete %al
jmp 0xb8d4
xorl %eax, %eax
jmp 0xb8d4
movb $0x1, %al
testb %al, %al
je 0xb8dc
movq 0x38(%rbp), %r15
je 0xb8a4
cmpq %rbx, %rbp
je 0xb893
jmp 0xb8e8
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/scope.cpp
// Function: Scope::insertSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, Symbol*)
bool Scope::insertSymbol(const string &name, int lineno, Symbol *symbol)
{
    auto& current = scopeStack.front();
    for (const auto& n: current) {
        if(n.name == name)
            return false;
    }
    current.push_back(ScopeNode(lineno, name, symbol));
    if (currFunc) {
        funcTable[currFunc].push_back(symbol);
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x40(%rsp)
movl %edx, 0x4(%rsp)
movq %rsi, %r12
movq (%rdi), %rax
leaq 0x10(%rax), %r15
movq %rax, 0x38(%rsp)
movq 0x10(%rax), %rbp
cmpq %r15, %rbp
sete %bl
je 0xb967
movq (%r12), %r13
movq 0x8(%r12), %r14
movq 0x20(%rbp), %rdx
cmpq %r14, %rdx
jne 0xb95b
testq %rdx, %rdx
je 0xba63
movq 0x18(%rbp), %rdi
movq %r13, %rsi
callq 0x3210
testl %eax, %eax
je 0xba63
movq (%rbp), %rbp
cmpq %r15, %rbp
sete %bl
jne 0xb935
leaq 0x10(%rsp), %rdi
movl 0x4(%rsp), %eax
movl %eax, -0x8(%rdi)
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x78b8
movq 0x40(%rsp), %r14
movq %r14, 0x10(%r13)
movl $0x40, %edi
callq 0x31f0
movl 0x8(%rsp), %ecx
movl %ecx, 0x10(%rax)
movq %rax, %rcx
addq $0x28, %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rdx
cmpq %r13, %rdx
je 0xb9cb
movq %rdx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x28(%rax)
jmp 0xb9d3
movups (%r13), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq %r13, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3060
movq 0x38(%rsp), %rax
incq 0x20(%rax)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xba23
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x7b0e(%rip), %rax      # 0x13538
cmpq $0x0, (%rax)
je 0xba63
leaq 0x7b11(%rip), %rdi      # 0x13548
leaq 0x7afa(%rip), %rsi      # 0x13538
callq 0xbabe
movq %rax, %r15
movl $0x18, %edi
callq 0x31f0
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3060
incq 0x10(%r15)
andb $0x1, %bl
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xba91
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/symbol.cpp
// Function: Symbol::getSymbolName[abi:cxx11](Symbol*)
string Symbol::getSymbolName(Symbol *s)
{
    switch (s->type) {
    case Symbol::VALUE_CHAR:
        return "char";
    case Symbol::VALUE_DOUBLE:
        return "double";
    case Symbol::VALUE_INT:
        return "int";
    case Symbol::VALUE_NONE:
        return "none";
    case Symbol::VALUE_ERROR:
        return "error";
    case Symbol::VALUE_STRING:
        return "string";
    case Symbol::VALUE_VOID:
        return "void";
    }
    return "--";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rsi), %eax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
cmpq $0x6, %rax
ja 0xbe8f
leaq 0x35c6(%rip), %rcx      # 0xf40c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x35e2(%rip), %rsi      # 0xf438
leaq 0x35df(%rip), %rdx      # 0xf43c
jmp 0xbecd
leaq 0x35d7(%rip), %rsi      # 0xf43d
leaq 0x35d6(%rip), %rdx      # 0xf443
jmp 0xbecd
leaq 0x35be(%rip), %rsi      # 0xf434
leaq 0x35ba(%rip), %rdx      # 0xf437
jmp 0xbecd
leaq 0x35a7(%rip), %rsi      # 0xf42d
leaq 0x35a6(%rip), %rdx      # 0xf433
jmp 0xbecd
leaq 0x35b3(%rip), %rsi      # 0xf449
leaq 0x35ae(%rip), %rdx      # 0xf44b
jmp 0xbecd
leaq 0x359e(%rip), %rsi      # 0xf444
leaq 0x359b(%rip), %rdx      # 0xf448
jmp 0xbecd
leaq 0x3572(%rip), %rsi      # 0xf428
leaq 0x356f(%rip), %rdx      # 0xf42c
jmp 0xbecd
leaq 0x34e5(%rip), %rsi      # 0xf3ab
leaq 0x34e3(%rip), %rdx      # 0xf3b0
movq %rbx, %rdi
callq 0x7948
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/tree.cpp
// Function: TreeNode::addChild(TreeNode*)
void TreeNode::addChild(TreeNode *node)
{
    if (node == nullptr
            || (node->nodeType == NODE_STATMENT
                && static_cast<StatementNode*>(node)->type == StatementNode::StatementNode::ST_EMPTY)) return;
    if (child == nullptr) {
        child = node;
        return;
    }
    if (child->sibling == nullptr) {
        child->sibling = node;
        return;
    }
    auto cur = child->sibling;
    while (cur->sibling != nullptr) {
        cur = cur->sibling;
    }
    cur->sibling = node;
}

// Assembly:
testq %rsi, %rsi
je 0xc1db
cmpl $0x1, 0x10(%rsi)
jne 0xc1a7
cmpl $0x1, 0x30(%rsi)
je 0xc1db
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0xc1cb
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0xc1d1
movq %rax, %rdi
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0xc1b9
addq $0x20, %rdi
jmp 0xc1d8
addq $0x18, %rdi
jmp 0xc1d8
addq $0x20, %rcx
movq %rcx, %rdi
movq %rsi, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/SunriseFox[P]very-simple-c-compiler/./src/tree.cpp
// Function: ExprNode::ExprNode(int, Symbol::ValueType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
ExprNode::ExprNode(int lineno, Symbol::ValueType type, string value, bool isConstant)
    : TreeNode(lineno, NODE_EXPRESSION)
{
    if (isConstant)
        this->symbol = new Constant(type, value);
    else
        this->symbol = new Variable(type, value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %r8d, %r12d
movq %rcx, %r15
movl %edx, %ebp
movq %rdi, %r14
leaq 0x68b2(%rip), %rax      # 0x12be0
movq %rax, (%rdi)
movl %esi, 0xc(%rdi)
movl $0x3, 0x10(%rdi)
movl 0x6ee3(%rip), %eax      # 0x13224
leal 0x1(%rax), %ecx
movl %ecx, 0x6eda(%rip)      # 0x13224
movl %eax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x6905(%rip), %rax      # 0x12c60
movq %rax, (%rdi)
movl $0x30, %edi
callq 0x31f0
movq %rax, %rbx
testl %r12d, %r12d
je 0xc3a8
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x78b8
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xbf0c
movq %rbx, 0x28(%r14)
movq 0x20(%rsp), %rdi
jmp 0xc3d9
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x78b8
movq %rsp, %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xbfa4
movq %rbx, 0x28(%r14)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xc3ea
movq (%r12), %rsi
incq %rsi
callq 0x3200
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xc42b
movq 0x10(%rsp), %rsi
jmp 0xc41c
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xc42b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0xc42b
jmp 0xc428
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x3200
movq %r14, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O1/sykeben[P]overos/cmd/hello.cpp
// Function: main
int main(int argc, char** argv) {
	cout << "Hello, World! I'm gonna test arguments now!" << _TERM;
	cout << "Arguments used with \"" << argv[0] << "\":" << _TERM;
  for (int n = 1; n < argc; n++)
    cout << setw(2) << n << ": " << argv[n] << _TERM;
  return 0;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %r15d
movq 0x2dee(%rip), %r14      # 0x3fd8
leaq 0xe13(%rip), %rsi       # 0x2004
movl $0x2b, %edx
movq %r14, %rdi
callq 0x1050
leaq -0x2a(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x1050
leaq 0xe17(%rip), %rsi       # 0x2030
movl $0x15, %edx
movq %r14, %rdi
callq 0x1050
movq %rbx, -0x38(%rbp)
movq (%rbx), %r12
testq %r12, %r12
je 0x124e
movq %r12, %rdi
callq 0x1030
movq 0x2d97(%rip), %rdi      # 0x3fd8
movq %r12, %rsi
movq %rax, %rdx
callq 0x1050
jmp 0x1266
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x1070
movq 0x2d6b(%rip), %r14      # 0x3fd8
leaq 0xdd2(%rip), %rsi       # 0x2046
movl $0x2, %edx
movq %r14, %rdi
callq 0x1050
leaq -0x2b(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %r12d
movl $0x1, %edx
movq %r14, %rdi
callq 0x1050
cmpl $0x2, %r15d
jl 0x133a
movl %r15d, %ebx
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r14,%rax)
movq %r14, %rdi
movl %r12d, %esi
callq 0x1080
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
leaq 0xd74(%rip), %rsi       # 0x2049
callq 0x1050
movq -0x38(%rbp), %rax
movq (%rax,%r12,8), %r13
testq %r13, %r13
je 0x12ff
movq %r13, %rdi
callq 0x1030
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1050
jmp 0x1319
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x1070
movb $0xa, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
leaq -0x29(%rbp), %rsi
callq 0x1050
incq %r12
cmpq %r12, %rbx
jne 0x12a8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: intern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string* intern(string s)
{
  map<string, string*>::iterator it = interned.find(s);
  if (it == interned.end())
    {
      interned[s] = new string(s);
      chromAsInt[interned[s]] = static_cast<int>(interned.size());
      return interned[s];
    }
  return it->second;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xaa1b(%rip), %rdi      # 0xd228
movq %rbx, %rsi
callq 0x7306
leaq 0xaa14(%rip), %rcx      # 0xd230
cmpq %rcx, %rax
je 0x2827
addq $0x40, %rax
jmp 0x288f
movl $0x20, %edi
callq 0x2220
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x7276
leaq 0xa9d4(%rip), %r15      # 0xd228
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6ac2
movq %r14, (%rax)
movl 0xa9e8(%rip), %ebp      # 0xd250
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6ac2
leaq 0xa9de(%rip), %rdi      # 0xd258
movq %rax, %rsi
callq 0x6b3e
movl %ebp, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6ac2
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: idxFromChrom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
int idxFromChrom(string* ptr)
{
  map<string*, int>::const_iterator it = chromAsInt.find(ptr);
  if (chromAsInt.end() == it)
    {
      cerr << "Coding error:  Line " << __LINE__ << ", failed to find \""
	   << *ptr << "\" in the lookup table." << endl << endl;
      exit(2);
    }
  return it->second;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xa9a8(%rip), %rdx      # 0xd268
leaq 0xa999(%rip), %rax      # 0xd260
movq %rax, %rcx
testq %rdx, %rdx
je 0x28ee
leaq 0xa98a(%rip), %rcx      # 0xd260
xorl %esi, %esi
cmpq %rbx, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x28d6
movq %rax, %rdx
cmpq %rax, %rcx
je 0x2905
cmpq %rbx, 0x20(%rcx)
leaq 0xa95f(%rip), %rdx      # 0xd260
cmovbeq %rcx, %rdx
cmpq %rax, %rdx
je 0x290f
movl 0x28(%rdx), %eax
popq %rbx
retq
movq 0xa6da(%rip), %rdi      # 0xcff0
leaq 0x6777(%rip), %rsi      # 0x9094
callq 0x2210
movq %rax, %rdi
movl $0x34, %esi
callq 0x2390
leaq 0x6773(%rip), %rsi      # 0x90a9
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21e0
leaq 0x676c(%rip), %rsi      # 0x90bc
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
movl $0x2, %edi
callq 0x22c0