LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Unary::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Unary) {
    START();
    if (branch == 1) {
        if (token.type == ADD) {
            return SUB(0);
        } else if (token.type == SUB) {
            int tmp = code.GetTmpVar();
            vm.WriteCommandCall(SUB(0), "__unm", {});
            vm.WriteCommandRef(tmp, 0);
            return tmp;
        } else if (token.type == NOT) {
            int tmp = code.GetTmpVar();
            vm.WriteCommandClone(tmp, SUB(0));
            vm.WriteCommandNot(tmp);
            return tmp;
        } else if (token.type == MUL) {
            // unbox
            int tmp = code.GetTmpVar();
            vm.WriteCommandUnbox(tmp, SUB(0));
            return tmp;
        } else if (token.type == ADDR) {
            // box
            int tmp = code.GetTmpVar();
            vm.WriteCommandBox(tmp, SUB(0));
            return tmp;
        }
    }
    return SUB(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl 0x2c(%rdi), %eax
movl %eax, 0x819d9(%rip)     # 0x107278
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x8595d
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, 0x8(%rdi)
jne 0x859af
movl 0x28(%r14), %edx
leal -0x1a(%rdx), %ecx
cmpl $0x3, %ecx
ja 0x8596e
leaq 0x24f40(%rip), %rdx     # 0xaa814
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %rbx, %rdi
callq 0x85044
movl %eax, %ebp
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movl %eax, %r14d
leaq 0x104bf(%rip), %rsi     # 0x95dc6
leaq 0x30(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0x664f4
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
movq %r15, %rdi
movl %r14d, %esi
movq %r12, %rdx
callq 0x791c0
leaq 0x10(%rsp), %rdi
callq 0x89956
leaq 0x30(%rsp), %rdi
callq 0x209be
movq 0xe8(%rbx), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x78dd8
jmp 0x8595f
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x27, %edx
jne 0x859af
movq %rbx, %rdi
callq 0x85044
movl %eax, %ebp
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x78e08
movq 0xe8(%rbx), %rdi
movl %ebp, %esi
callq 0x79064
jmp 0x8595f
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rbx, %rdi
callq 0x85044
movl %eax, %ebp
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x79190
jmp 0x8595f
movq %rbx, %rdi
callq 0x85044
movl %eax, %ebp
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x79160
jmp 0x8595f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x89956
leaq 0x30(%rsp), %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Cast::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Cast) {
    START();
    if (token.type == AS) {
        int tmp = code.GetTmpVar();
        vm.WriteCommandNew(nodes[1]->token.str, tmp, {});
        vm.WriteCommandMov(tmp, SUB(0));
        return tmp;
    }
    return SUB(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl 0x2c(%rdi), %eax
movl %eax, 0x8181b(%rip)     # 0x107278
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x85ad1
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xe, 0x28(%rdi)
jne 0x85ae0
movq %rbx, %rdi
callq 0x85044
movl %eax, %ebp
movq 0xe8(%rbx), %rdi
movq 0x10(%r14), %rax
movq 0x8(%rax), %rsi
addq $0x40, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
movl %ebp, %edx
callq 0x78c3c
movq %rsp, %rdi
callq 0x89956
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x78da8
jmp 0x85ad3
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rax, %rbx
movq %rsp, %rdi
callq 0x89956
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Mul::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Mul) {
    START();
    if (tokenList.size() == 0) {
        return SUB(0);
    }
    int tmp = code.GetTmpVar();
    vm.WriteCommandClone(tmp, SUB(0));
    for (int i = 0; i < tokenList.size(); i++) {
        if (tokenList[i].type == MUL) {
            vm.WriteCommandMul(tmp, SUB(i + 1));
        } else if (tokenList[i].type == DIV) {
            vm.WriteCommandDiv(tmp, SUB(i + 1));
        } else if (tokenList[i].type == REM) {
            vm.WriteCommandRem(tmp, SUB(i + 1));
        }
    }
    return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2c(%rdi), %eax
movl %eax, 0x81758(%rip)     # 0x107278
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x85c1f
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rcx
cmpq 0x60(%rdi), %rcx
je 0x85c32
movq %rbx, %rdi
callq 0x85044
movl %eax, %ebp
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x78e08
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x60(%r14), %rcx
movq 0x68(%r14), %rax
subq %rcx, %rax
cqto
pushq $0x38
popq %rsi
idivq %rsi
cmpq %r13, %rax
jbe 0x85c21
movl (%rcx,%r12), %eax
cmpl $0x1f, %eax
je 0x85bef
cmpl $0x1e, %eax
je 0x85bc9
cmpl $0x1c, %eax
jne 0x85c13
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq 0x8(%rax,%r13,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x78f44
jmp 0x85c13
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq 0x8(%rax,%r13,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x78f74
jmp 0x85c13
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq 0x8(%rax,%r13,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x78fa4
incq %r13
addq $0x38, %r12
jmp 0x85b74
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Add::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Add) {
    START();
    if (tokenList.size() == 0) {
        return SUB(0);
    }
    int tmp = code.GetTmpVar();
    vm.WriteCommandClone(tmp, SUB(0));
    for (int i = 0; i < tokenList.size(); i++) {
        if (tokenList[i].type == ADD) {
            vm.WriteCommandAdd(tmp, SUB(i + 1));
        } else if (tokenList[i].type == SUB) {
            vm.WriteCommandSub(tmp, SUB(i + 1));
        }
    }
    return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2c(%rdi), %eax
movl %eax, 0x81616(%rip)     # 0x107278
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x85d2f
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rcx
cmpq 0x60(%rdi), %rcx
je 0x85d42
movq %rbx, %rdi
callq 0x85044
movl %eax, %ebp
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x78e08
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x60(%r14), %rcx
movq 0x68(%r14), %rax
subq %rcx, %rax
cqto
pushq $0x38
popq %rsi
idivq %rsi
cmpq %r13, %rax
jbe 0x85d31
movl (%rcx,%r12), %eax
cmpl $0x1b, %eax
je 0x85d02
cmpl $0x1a, %eax
jne 0x85d26
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq 0x8(%rax,%r13,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x78ee4
jmp 0x85d26
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq 0x8(%rax,%r13,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x78f14
incq %r13
addq $0x38, %r12
jmp 0x85cb6
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::LogicAnd::CompileAST(Gos::Compiler::VMCompiler&)
Compile(LogicAnd) {
    START();
    if (tokenList.size() == 0) {
        return SUB(0);
    }
    int tmp = code.GetTmpVar();
    vm.WriteCommandClone(tmp, SUB(0));
    for (int i = 0; i < tokenList.size(); i++) {
        vm.WriteCommandAnd(tmp, SUB(i + 1));
    }
    return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2c(%rdi), %eax
movl %eax, 0x81026(%rip)     # 0x107278
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x862e2
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rcx
cmpq 0x60(%rdi), %rcx
je 0x862f5
movq %rbx, %rdi
callq 0x85044
movl %eax, %ebp
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x78e08
xorl %r12d, %r12d
pushq $0x38
popq %r13
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x862e4
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq 0x8(%rax,%r12,8), %rdi
incq %r12
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x79004
jmp 0x862a7
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::LogicOr::CompileAST(Gos::Compiler::VMCompiler&)
Compile(LogicOr) {
    START();
    if (tokenList.size() == 0) {
        return SUB(0);
    }
    int tmp = code.GetTmpVar();
    vm.WriteCommandClone(tmp, SUB(0));
    for (int i = 0; i < tokenList.size(); i++) {
        vm.WriteCommandOr(tmp, SUB(i + 1));
    }
    return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2c(%rdi), %eax
movl %eax, 0x80f52(%rip)     # 0x107278
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x863b6
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rcx
cmpq 0x60(%rdi), %rcx
je 0x863c9
movq %rbx, %rdi
callq 0x85044
movl %eax, %ebp
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x78e08
xorl %r12d, %r12d
pushq $0x38
popq %r13
movq 0x68(%r14), %rax
subq 0x60(%r14), %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x863b8
movq 0xe8(%rbx), %r15
movq 0x10(%r14), %rax
movq 0x8(%rax,%r12,8), %rdi
incq %r12
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movq %r15, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x79034
jmp 0x8637b
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Cond::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Cond) {
    START();
    if (branch == 1) {
        int tmp = code.GetTmpVar();
        int val = SUB(0);
        auto ifJmp = vm.WriteCommandIf(val);
        vm.WriteCommandClone(tmp, SUB(2));
        auto outJmp = vm.WriteCommandJmp();
        ifJmp(vm.GetProgress());
        vm.WriteCommandClone(tmp, SUB(1));
        outJmp(vm.GetProgress());
        return tmp;
    }
    return SUB(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x2c(%rdi), %eax
movl %eax, 0x80e7e(%rip)     # 0x107278
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x864e1
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x1, 0x8(%rdi)
jne 0x864f1
movq %r14, %rdi
callq 0x85044
movl %eax, %ebx
movq 0x10(%r15), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
movq 0xe8(%r14), %rsi
leaq 0x28(%rsp), %rdi
movl %eax, %edx
callq 0x79100
movq 0xe8(%r14), %r12
movq 0x10(%r15), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
movq %r12, %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x78e08
movq 0xe8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x790b0
movq 0xe8(%r14), %rdi
callq 0x7932e
leaq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x83e66
movq 0xe8(%r14), %r12
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
movq %r12, %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x78e08
movq 0xe8(%r14), %rdi
callq 0x7932e
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x83e66
leaq 0x8(%rsp), %rdi
callq 0x21f04
leaq 0x28(%rsp), %rdi
callq 0x21f04
jmp 0x864e3
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%rax), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movq %r14, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
jmp 0x8650c
movq %rax, %rbx
jmp 0x8651e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21f04
leaq 0x28(%rsp), %rdi
callq 0x21f04
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Assign::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Assign) {
    START();
    int dest = SUB(0);
    int src = SUB(1);
    switch (token.type) {
        case ASSIGN:     vm.WriteCommandMov(dest, src); break;
        case ASSIGN_ADD: vm.WriteCommandAdd(dest, src); break;
        case ASSIGN_SUB: vm.WriteCommandSub(dest, src); break;
        case ASSIGN_MUL: vm.WriteCommandMul(dest, src); break;
        case ASSIGN_DIV: vm.WriteCommandDiv(dest, src); break;
        case ASSIGN_REM: vm.WriteCommandRem(dest, src); break;
        case ASSIGN_XOR: vm.WriteCommandXor(dest, src); break;
        case ASSIGN_AND: vm.WriteCommandAnd(dest, src); break;
        case ASSIGN_OR:  vm.WriteCommandOr(dest, src);  break;
        default: return dest;
    }
    return dest;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x2c(%rdi), %eax
movl %eax, 0x80d18(%rip)     # 0x107278
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x865b8
movq %rsi, %r14
movq %rdi, %r15
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebx
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
movl 0x28(%r15), %ecx
addl $-0xf, %ecx
cmpl $0x8, %ecx
ja 0x865ba
leaq 0x24287(%rip), %rdx     # 0xaa824
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x78da8
jmp 0x865ba
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x78f74
jmp 0x865ba
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x78f14
jmp 0x865ba
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x78f44
jmp 0x865ba
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x79004
jmp 0x865ba
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x78ee4
jmp 0x865ba
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x78fa4
jmp 0x865ba
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x78fd4
jmp 0x865ba
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0x79034
jmp 0x865ba
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::DefVar::CompileAST(Gos::Compiler::VMCompiler&)
Compile(DefVar) {
    START();
    std::string symbol = nodes[0]->token.str;
    std::string type = "unknown";
    int assign;
    int id = pc++;
    code.currentScope->varID[symbol] = id;
    if (branch == 1) {
        type = nodes[1]->token.str;
    } else if (branch == 2) {
        assign = SUB(1);
    } else if (branch == 3) {
        type = nodes[1]->token.str;
        assign = SUB(2);
    }
    code.currentScope->varType[symbol] = type;
    if (branch <= 1) {
        vm.WriteCommandNew(type, id, {});
    } else if (branch == 2) {
        vm.WriteCommandRef(id, assign);
    } else if (branch == 3) {
        vm.WriteCommandNew(type, id, {});
        vm.WriteCommandMov(id, assign);
    }
    return id;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl 0x2c(%rdi), %eax
movl %eax, 0x80beb(%rip)     # 0x107278
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x86715
movq %rsi, %r14
movq %rdi, %r15
movq (%rax), %rsi
addq $0x40, %rsi
leaq 0x38(%rsp), %rdi
callq 0x2b71e
leaq 0x24470(%rip), %rsi     # 0xaab25
leaq 0x18(%rsp), %rdi
movq %rsp, %rdx
callq 0x664f4
movl 0xe0(%r14), %ebx
leal 0x1(%rbx), %eax
movl %eax, 0xe0(%r14)
movq 0xd0(%r14), %rdi
addq $0x28, %rdi
leaq 0x38(%rsp), %rsi
callq 0x7a76e
movl %ebx, (%rax)
movl 0x8(%r15), %eax
cmpl $0x3, %eax
je 0x86720
cmpl $0x2, %eax
je 0x8671c
cmpl $0x1, %eax
jne 0x8674b
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
addq $0x40, %rsi
leaq 0x18(%rsp), %rdi
callq 0x2de0e
jmp 0x8674b
xorl %ebx, %ebx
jmp 0x8680a
pushq $0x8
jmp 0x86738
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
addq $0x40, %rsi
leaq 0x18(%rsp), %rdi
callq 0x2de0e
pushq $0x10
popq %rax
movq 0x10(%r15), %rcx
movq (%rcx,%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
movl %eax, %ebp
movq 0xd0(%r14), %rdi
addq $0x60, %rdi
leaq 0x38(%rsp), %rsi
callq 0x89230
leaq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x2de0e
movl 0x8(%r15), %eax
cmpl $0x1, %eax
jg 0x867a1
movq 0xe8(%r14), %rdi
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
leaq 0x18(%rsp), %rsi
movl %ebx, %edx
callq 0x78c3c
movq %rsp, %rdi
callq 0x89956
jmp 0x867f6
cmpl $0x3, %eax
je 0x867bd
cmpl $0x2, %eax
jne 0x867f6
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x78dd8
jmp 0x867f6
movq 0xe8(%r14), %rdi
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
leaq 0x18(%rsp), %rsi
movl %ebx, %edx
callq 0x78c3c
movq %rsp, %rdi
callq 0x89956
movq 0xe8(%r14), %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x78da8
leaq 0x18(%rsp), %rdi
callq 0x209be
leaq 0x38(%rsp), %rdi
callq 0x209be
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x86819
movq %rax, %rbx
movq %rsp, %rdi
callq 0x89956
jmp 0x8682e
movq %rax, %rbx
jmp 0x86838
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x209be
leaq 0x38(%rsp), %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::StatBlock::CompileAST(Gos::Compiler::VMCompiler&)
Compile(StatBlock) {
    compilingLine = token.line;
    blockDepth++;
    for (auto* ast : nodes) {
        ast->CompileAST(code);
    }
    blockDepth--;
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x2c(%rdi), %eax
incl 0x7ff72(%rip)           # 0x107330
movq %rsi, %rbx
movl %eax, 0x7feb1(%rip)     # 0x107278
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x873e5
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r14
jmp 0x873cf
decl 0x7ff45(%rip)           # 0x107330
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::SingleAttr::CompileAST(Gos::Compiler::VMCompiler&)
Compile(SingleAttr) {
    START();
    std::string attr = nodes[0]->token.str;
    std::vector<std::string> attrs;
    if (nodes.size() > 1) {
        for (int i = 0; i < nodes[1]->nodes.size(); i++) {
            attrs.push_back(nodes[1]->nodes[i]->token.str);
        }
    }
    vm.WriteCommandAttributes(attr, attrs);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl 0x2c(%rdi), %eax
movl %eax, 0x7ef54(%rip)     # 0x107278
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0x883c4
movq %rsi, %rbx
movq %rdi, %r14
movq (%rax), %rsi
addq $0x40, %rsi
leaq 0x18(%rsp), %rdi
callq 0x2b71e
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
cmpq $0x9, %rcx
jb 0x8839e
xorl %r12d, %r12d
movq %rsp, %r15
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x8839e
movq (%rax,%r12,8), %rsi
addq $0x40, %rsi
movq %r15, %rdi
callq 0x79a38
incq %r12
movq 0x10(%r14), %rax
jmp 0x8836d
movq 0xe8(%rbx), %rdi
leaq 0x18(%rsp), %rsi
movq %rsp, %rdx
callq 0x79268
movq %rsp, %rdi
callq 0x2b668
leaq 0x18(%rsp), %rdi
callq 0x209be
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x883d4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2b668
leaq 0x18(%rsp), %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Attribute::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Attribute) {
    START();
    for (int i = 0; i < nodes.size(); i++) {
        SUB(i);
    }
    return 0;
}

// Assembly:
movl 0x2c(%rdi), %eax
movl %eax, 0x7ee7d(%rip)     # 0x107278
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
cmpq %rax, %rcx
je 0x88440
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x8843b
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
incq %r15
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
jmp 0x88416
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosScript::SetScriptName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Gos::GosScript::SetScriptName(const std::string& name) {
    GosASTError::SetFileName(name);
    scriptName = name;
    int pos = name.length() - 1;
    while (name[pos] != '.' && pos > 0) {
        pos--;
    }
    if (pos == 0) {
        pos = name.length();
    }
    scriptNameClass = TypeID::getRaw(std::string_view(scriptName).substr(0, pos));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7e774
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2de0e
movl 0x8(%r14), %eax
movq (%r14), %rdx
movl %eax, %ecx
decl %ecx
testl %ecx, %ecx
jle 0x8a980
movslq %ecx, %rsi
cmpb $0x2e, (%rdx,%rsi)
jne 0x8a971
testl %ecx, %ecx
cmovnel %ecx, %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movq %rsp, %rdi
movq %rdx, (%rdi)
movq %rcx, 0x8(%rdi)
movslq %eax, %rdx
xorl %esi, %esi
callq 0x2156c
movq %rax, %r14
movq %rdx, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x215c2
movq %rax, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movq %r15, 0x30(%rbx)
andw $0x0, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosScript::GetClassInfo() const
const GosVM::GosClass& Gos::GosScript::GetClassInfo() const {
    auto& info = GosVM::GosClass::classInfo;
    if (info.find(scriptNameClass) == info.end()) {
        std::cerr << "Error: no such class defined in script " << scriptName << ": " << scriptNameClass.getName() << std::endl;
        return info[TypeID::get<void>()];
    }
    return info[scriptNameClass];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
leaq 0x7bb69(%rip), %rdi     # 0x106590
movq %rbx, %rsi
callq 0x7bb48
testq %rax, %rax
je 0x8aa4a
leaq 0x7bb55(%rip), %rdi     # 0x106590
movq %rbx, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x7bc1e
movq 0x7b59f(%rip), %rdi     # 0x105ff0
leaq 0x2017b(%rip), %rsi     # 0xaabd3
callq 0x11340
movq %rax, %rdi
movq %r14, %rsi
callq 0x11320
leaq 0xca28(%rip), %rsi      # 0x97497
movq %rax, %rdi
callq 0x11340
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b9ce
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x113b0
movq %rax, %rdi
callq 0x111b0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x20c9a
leaq 0x7bae4(%rip), %rdi     # 0x106590
movq %rbx, %rsi
callq 0x8bb0c
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosScript::Read(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Gos::GosScript::Read(std::istream& fin, std::string inputFileName) {
    GosTokenizer tokenizer(fin, inputFileName);
    SetScriptName(inputFileName);
    Compiler::VMCompiler compiler(vm);
    GosAST ast;
    ast.Build(tokenizer);
    ast.CompileAST(compiler);
    // ast.PrintAST();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rdi
callq 0x7d6a6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a946
addq $0x40, %rbx
leaq 0xd0(%rsp), %rdi
movq %rbx, %rsi
callq 0x85094
movq %rsp, %rdi
callq 0x83e82
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
callq 0x7ea7e
movq %rsp, %rdi
leaq 0xd0(%rsp), %rsi
callq 0x7e960
movq %rsp, %rdi
callq 0x7eb6a
leaq 0xd0(%rsp), %rdi
callq 0x8b4e6
leaq 0x60(%rsp), %rdi
callq 0x8b518
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x8abc5
jmp 0x8abb5
movq %rax, %rbx
jmp 0x8abd2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7eb6a
leaq 0xd0(%rsp), %rdi
callq 0x8b4e6
leaq 0x60(%rsp), %rdi
callq 0x8b518
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosProject::ExecuteFiles(std::queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::deque<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void Gos::GosProject::ExecuteFiles(std::queue<std::string>& files) {
    std::unordered_set<std::string> vis;
    while (!files.empty()) {
        std::string scriptPath = files.front();
        if (vis.contains(scriptPath)) {
            continue;
        }
        vis.insert(scriptPath);
        std::cout << "Gos: Import " << scriptPath << std::endl;
        files.pop();
        auto fin = FileSystem::Read(scriptPath);
        GosScript& script = scripts[scriptPath];
        script.Read(fin, scriptPath);
        script.Execute();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq 0x88(%rsp), %r15
leaq 0x30(%rsp), %r13
leaq 0x68(%rsp), %r14
movq 0x10(%rbx), %rsi
cmpq %rsi, 0x30(%rbx)
je 0x8b166
movq %r15, %rdi
callq 0x2b71e
movq %r13, %rdi
movq %r15, %rsi
callq 0x8b6ce
testb %al, %al
jne 0x8b159
movq %r13, %rdi
movq %r15, %rsi
callq 0x8c286
movq 0x7af55(%rip), %rdi     # 0x105fc8
leaq 0x1fb8a(%rip), %rsi     # 0xaac04
callq 0x11340
movq %rax, %rdi
movq %r15, %rsi
callq 0x11320
movq %rax, %rdi
callq 0x111b0
movq %rbx, %rdi
callq 0x8c5d2
leaq 0xd0(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
pushq $0x2
popq %rdx
callq 0x8b53c
leaq 0x130(%rsp), %rdi
movq %rbp, %rsi
callq 0x8dc1e
movq %rbp, %rdi
callq 0x8b62c
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x8c63c
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b71e
movq %r12, %rdi
leaq 0x130(%rsp), %rsi
movq %r14, %rdx
callq 0x8ab26
movq %r14, %rdi
callq 0x209be
leaq 0xa8(%rsp), %rdi
callq 0x16fb8
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0xf8(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
leaq 0xa8(%rsp), %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rcx
callq 0x8a9cc
movq %rbp, %rdi
callq 0x19b6c
movq %r12, %rdi
callq 0x225a0
leaq 0x130(%rsp), %rdi
callq 0x112c0
movq %r15, %rdi
callq 0x209be
jmp 0x8b038
leaq 0x30(%rsp), %rdi
callq 0x8b922
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x8b62c
jmp 0x8b1ce
jmp 0x8b1cb
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x209be
jmp 0x8b1bc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x225a0
jmp 0x8b1bc
movq %rax, %rbx
jmp 0x8b1db
movq %rax, %rbx
leaq 0x130(%rsp), %rdi
callq 0x112c0
jmp 0x8b1ce
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x209be
leaq 0x30(%rsp), %rdi
callq 0x8b922
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosProject::ScanDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>)
void Gos::GosProject::ScanDirectory(std::string directory, std::function<bool(std::string)> filter) {
    std::queue<std::string> imports;
    FileSystem::Iterate(".", std::function([&filter, &imports, this](Path path) {
        if (filter(path.string())) {
            PreprocessFile(path.string(), imports);
        }
    }));
    ExecuteFiles(imports);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x8b6dc
leaq 0xbfed(%rip), %rsi      # 0x97201
leaq 0x28(%rsp), %rdi
pushq $0x2
popq %rdx
callq 0x8b5a4
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $0x18
popq %rdi
callq 0x11350
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x101(%rip), %rax       # 0x8b34e
movq %rax, 0x18(%rsi)
leaq 0x1b2(%rip), %rax       # 0x8b40a
movq %rax, 0x10(%rsi)
leaq 0x28(%rsp), %rdi
callq 0x8d736
movq %rsp, %rdi
callq 0x21f04
leaq 0x28(%rsp), %rdi
callq 0x8b62c
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x8afea
leaq 0x50(%rsp), %rdi
callq 0x8b9e0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8b29e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21f04
leaq 0x28(%rsp), %rdi
callq 0x8b62c
jmp 0x8b2b8
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x8b9e0
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosFileSystem.cpp
// Function: Gos::FileSystem::Read(std::filesystem::__cxx11::path)
std::stringstream Gos::FileSystem::Read(Path path) {
    std::stringstream ss;
    File& file = instance.files[FileSystem::GetFile(path, false)];
    if (file.packID == -1) {
        std::ifstream fin;
        fin.open(path, std::ios::binary);
        ss << fin.rdbuf();
        fin.close();
    } else {
        std::ifstream fin;
        char* buffer = new char[file.fileSize];
        fin.open(instance.dataPacks[file.packID], std::ios::binary);
        fin.seekg(file.packPos);
        fin.read(buffer, file.fileSize);
        fin.close();
        ss.write(buffer, file.fileSize);
        delete[] buffer;
    }
    return ss;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
callq 0x11270
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x8b67e
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x8cde6
movslq %eax, %r12
movq 0x797a6(%rip), %r15     # 0x107400
shlq $0x4, %r12
leaq 0x8(%rsp), %rdi
callq 0x8b62c
cmpl $-0x1, (%r15,%r12)
je 0x8dce8
leaq 0x30(%rsp), %rdi
callq 0x113a0
addq %r12, %r15
movslq 0x8(%r15), %rdi
callq 0x11030
movq %rax, %r14
movslq (%r15), %rsi
shlq $0x5, %rsi
addq 0x79752(%rip), %rsi     # 0x1073e8
leaq 0x30(%rsp), %rdi
pushq $0x4
popq %rdx
callq 0x11300
movslq 0x4(%r15), %rsi
leaq 0x30(%rsp), %rdi
xorl %edx, %edx
callq 0x11400
movslq 0x8(%r15), %rdx
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x113f0
leaq 0x30(%rsp), %rdi
callq 0x110a0
leaq 0x10(%rbx), %rdi
movslq 0x8(%r15), %rdx
movq %r14, %rsi
callq 0x11430
movq %r14, %rdi
callq 0x11420
jmp 0x8dd1a
leaq 0x30(%rsp), %rdi
callq 0x113a0
leaq 0x30(%rsp), %rdi
pushq $0x4
popq %rdx
movq %r14, %rsi
callq 0x8dfd2
leaq 0x10(%rbx), %rdi
leaq 0x40(%rsp), %rsi
callq 0x110b0
leaq 0x30(%rsp), %rdi
callq 0x110a0
leaq 0x30(%rsp), %rdi
callq 0x110e0
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8dd49
jmp 0x8dd49
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8b62c
jmp 0x8dd5d
movq %rax, %r14
jmp 0x8dd5d
jmp 0x8dd50
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x110e0
movq %rbx, %rdi
callq 0x112c0
movq %r14, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/main.cpp
// Function: vmTest(int, char**)
int vmTest(int argc, char* argv[]) {
    reflIO();
    GosVM::RTConst constArea;
    GosVM::VMProgram program(&constArea);
    std::ifstream fin;
    if (argc > 1) {
        fin.open(argv[1]);
    } else {
        fin.open("1.in");
    }
    program.Read(fin, true);
    fin.close();
    // program.Write(std::cout, true);
    auto ret = program.Execute();
    /*
    auto v = refl.New("Virtual");
    v.Invoke("print", {});
    v.GetField("x").As<int>() = 2333;
    v.Invoke("print", {});
    std::cout << v.GetField("x") << std::endl;
    */
    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x388, %rsp            # imm = 0x388
movq %rsi, %rbx
movl %edi, %ebp
callq 0x8f21c
xorps %xmm0, %xmm0
leaq 0x128(%rsp), %rax
movaps %xmm0, -0x48(%rax)
andq $0x0, -0x38(%rax)
movq %rax, -0x30(%rax)
pushq $0x1
popq %rcx
movq %rcx, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, %edx       # imm = 0x3F800000
movl %edx, -0x10(%rax)
leaq 0x178(%rsp), %rax
movaps %xmm0, -0x58(%rax)
movaps %xmm0, -0x48(%rax)
andq $0x0, -0x38(%rax)
movq %rax, -0x30(%rax)
movq %rcx, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl %edx, -0x10(%rax)
movaps %xmm0, -0x8(%rax)
leaq 0x40(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x75c10
leaq 0x180(%rsp), %rdi
callq 0x113a0
cmpl $0x2, %ebp
jl 0x8f631
movq 0x8(%rbx), %rsi
leaq 0x180(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x11200
jmp 0x8f648
leaq 0x1b6d0(%rip), %rsi     # 0xaad08
leaq 0x180(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x11200
leaq 0x40(%rsp), %rdi
leaq 0x180(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x776c2
leaq 0x180(%rsp), %rdi
callq 0x110a0
leaq 0x18(%rsp), %rdi
callq 0x16fb8
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
leaq 0xa8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x75eaa
movq %rsp, %rdi
callq 0x225a0
leaq 0xa8(%rsp), %rdi
callq 0x19b6c
leaq 0x180(%rsp), %rdi
callq 0x110e0
leaq 0x40(%rsp), %rdi
callq 0x8cb12
leaq 0xe0(%rsp), %rdi
callq 0x8b4be
xorl %eax, %eax
addq $0x388, %rsp            # imm = 0x388
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x225a0
jmp 0x8f6fa
jmp 0x8f6f7
movq %rax, %rbx
jmp 0x8f707
movq %rax, %rbx
jmp 0x8f711
movq %rax, %rbx
leaq 0x180(%rsp), %rdi
callq 0x110e0
leaq 0x40(%rsp), %rdi
callq 0x8cb12
leaq 0xe0(%rsp), %rdi
callq 0x8b4be
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/dmarto[P]crrs-xlib/main.cpp
// Function: Shadow(std::vector<Sphere*, std::allocator<Sphere*>> const&, Vec3 const&, Vec3 const&, Vec3&, Sphere const&)
void Shadow(const std::vector<Sphere *> &objects, const Vec3 &pointOfIntersection, const Vec3 &normal, Vec3 &pixclr,
			const Sphere &light)
{
	Colors color;

	double shadowIntensity = 2.3;

	for (auto &sphereB : objects)
	{
		const Ray ray2(pointOfIntersection, light.GetNormal(sphereB->center) * -3);
		double t2;
		if (sphereB->Intersects(ray2, t2))
		{
			const Vec3 pointOfIntersection2 = ray2.origin + ray2.destination * t2;
			const Vec3 len2 = pointOfIntersection - pointOfIntersection2;
			const Vec3 normal2 = sphereB->GetNormal(pointOfIntersection2);
			const double dotP2 = dot(len2.Normalize(), normal2.Normalize());

			Vec3 shadow = color.black + 1 * shadowIntensity;
			Vec3 pixclrBounce = pixclr * dotP2 * shadow;
			ColorBoundary(pixclrBounce);

			pixclr = pixclr - pixclrBounce;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %rbp
movq %rcx, 0x38(%rsp)
movq %rsi, %r15
movq (%rdi), %r13
movq 0x8(%rdi), %r12
cmpq %r12, %r13
je 0x173d
movq (%r13), %rdx
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
callq 0x215e
movsd 0x30(%rsp), %xmm0
mulsd 0x1a80(%rip), %xmm0     # 0x3038
movups (%r15), %xmm1
movaps %xmm1, 0x50(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x60(%rsp)
movapd 0x20(%rsp), %xmm1
mulpd 0x1af8(%rip), %xmm1     # 0x30d0
movupd %xmm1, 0x68(%rsp)
movsd %xmm0, 0x78(%rsp)
movq (%r13), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x20a0
testb %al, %al
je 0x1734
movsd 0x48(%rsp), %xmm0
movsd 0x78(%rsp), %xmm1
mulsd %xmm0, %xmm1
addsd 0x60(%rsp), %xmm1
movupd 0x68(%rsp), %xmm2
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm2, %xmm0
addpd 0x50(%rsp), %xmm0
movapd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x30(%rsp)
movsd 0x10(%r15), %xmm2
subsd %xmm1, %xmm2
movupd (%r15), %xmm1
subpd %xmm0, %xmm1
movapd %xmm1, 0x90(%rsp)
movsd %xmm2, 0xa0(%rsp)
movq (%r13), %rsi
movq %r12, %r14
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
leaq 0x20(%rsp), %rdx
callq 0x215e
movq %rsp, %rbx
movq %rbx, %rdi
leaq 0x90(%rsp), %rsi
callq 0x219a
leaq 0xa8(%rsp), %rdi
movq %r12, %rsi
movq %r14, %r12
callq 0x219a
movsd 0xa8(%rsp), %xmm0
mulsd (%rsp), %xmm0
movupd 0x8(%rsp), %xmm1
movupd 0xb0(%rsp), %xmm2
mulpd %xmm1, %xmm2
addsd %xmm2, %xmm0
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm0, %xmm2
movq 0x38(%rsp), %r14
movsd 0x10(%r14), %xmm1
movsd %xmm1, 0x40(%rsp)
addsd %xmm2, %xmm2
movapd %xmm2, %xmm0
mulsd %xmm1, %xmm0
movupd (%r14), %xmm1
movapd %xmm1, 0x80(%rsp)
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm1, %xmm2
movapd %xmm2, (%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x130c
movsd 0x40(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
movapd 0x80(%rsp), %xmm1
subpd (%rsp), %xmm1
movupd %xmm1, (%r14)
movsd %xmm0, 0x10(%r14)
addq $0x8, %r13
jmp 0x1590
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dmarto[P]crrs-xlib/main.cpp
// Function: Trace(Ray const&, Sphere const&, std::vector<Sphere*, std::allocator<Sphere*>> const&)
Vec3 Trace(const Ray &ray, const Sphere &light, const std::vector<Sphere *> &objects)
{
	Colors color;
	Vec3 pixclr = color.black;

	for (auto &sphere : objects)
	{
		double t;
		double lightIntensity = 0.62;

		if (sphere->Intersects(ray, t))
		{
			const Vec3 pointOfIntersection = ray.origin + ray.destination * t;
			const Vec3 len = light.center - pointOfIntersection;
			const Vec3 normal = sphere->GetNormal(pointOfIntersection);
			const double dotProduct = dot(len.Normalize(), normal.Normalize());

			pixclr = (sphere->clr + light.clr / 2 * dotProduct) * lightIntensity;

			if (sphere->name != "world")
				Reflection(objects, pointOfIntersection, normal, pixclr);
			Shadow(objects, pointOfIntersection, normal, pixclr, light);

			ColorBoundary(pixclr);
		}
	}

	return pixclr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rdi)
movupd 0x68(%rsp), %xmm0
movupd %xmm0, (%rdi)
movq (%rcx), %rbp
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %r13
leaq 0x40(%rsp), %rbx
movq %r13, 0x10(%rsp)
cmpq %r13, %rbp
je 0x1932
movq (%rbp), %rdi
movq %r12, %rsi
leaq 0x18(%rsp), %rdx
callq 0x20a0
testb %al, %al
je 0x1929
movsd 0x18(%rsp), %xmm0
movsd 0x28(%r12), %xmm1
mulsd %xmm0, %xmm1
addsd 0x10(%r12), %xmm1
movupd (%r12), %xmm2
movupd 0x18(%r12), %xmm3
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
movapd %xmm0, 0x40(%rsp)
movsd %xmm1, 0x50(%rsp)
movsd 0x10(%r14), %xmm2
subsd %xmm1, %xmm2
movupd (%r14), %xmm1
subpd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
movsd %xmm2, 0x30(%rsp)
movq (%rbp), %rsi
movq %rbx, %r13
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rdx
callq 0x215e
leaq 0x98(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x219a
leaq 0x80(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rbx
callq 0x219a
movsd 0x80(%rsp), %xmm0
mulsd 0x98(%rsp), %xmm0
movupd 0xa0(%rsp), %xmm1
movupd 0x88(%rsp), %xmm2
mulpd %xmm1, %xmm2
addsd %xmm2, %xmm0
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm0, %xmm2
movq (%rbp), %rdi
mulsd 0x17a4(%rip), %xmm2     # 0x3040
movsd 0x30(%r14), %xmm0
mulsd %xmm2, %xmm0
addsd 0x30(%rdi), %xmm0
mulsd 0x1795(%rip), %xmm0     # 0x3048
movupd 0x20(%r14), %xmm1
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm1, %xmm2
movupd 0x20(%rdi), %xmm1
addpd %xmm2, %xmm1
mulpd 0x180e(%rip), %xmm1     # 0x30e0
movupd %xmm1, (%r15)
movsd %xmm0, 0x10(%r15)
addq $0x38, %rdi
leaq 0x1948(%rip), %rsi      # 0x3230
callq 0x21f9
testb %al, %al
je 0x1909
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
leaq 0xb0(%rsp), %rdx
movq %r15, %rcx
callq 0x1375
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0x156d
movq %r15, %rdi
callq 0x130c
movq 0x10(%rsp), %r13
addq $0x8, %rbp
jmp 0x179f
movq %r15, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dmarto[P]crrs-xlib/main.cpp
// Function: HandleEvents(_XEvent&, Sphere&, Sphere&)
void HandleEvents(XEvent &event, Sphere &light, Sphere &world)
{
	if (event.type == MotionNotify)
	{
		light.center.x = event.xmotion.x;
		light.center.y = event.xmotion.y;
	}

	if (event.type == ButtonPress && event.xbutton.button == 4 && world.center.z > 580)
	{
		world.center.z -= 5;
		world.center.y -= 5;

		light.center.z -= 30;
	}

	if (event.type == ButtonPress && event.xbutton.button == 5 && world.center.z < 600)
	{
		world.center.z += 5;
		world.center.y += 5;

		light.center.z += 30;
	}
}

// Assembly:
movl (%rdi), %eax
cmpl $0x6, %eax
jne 0x19c4
cvtsi2sdl 0x40(%rdi), %xmm0
movsd %xmm0, (%rsi)
cvtsi2sdl 0x44(%rdi), %xmm0
movsd %xmm0, 0x8(%rsi)
movl (%rdi), %eax
movl %eax, %r8d
xorl $0x4, %r8d
movl 0x54(%rdi), %ecx
movl %ecx, %r9d
xorl $0x4, %r9d
orl %r8d, %r9d
jne 0x1a1a
movsd 0x10(%rdx), %xmm0
movsd 0x1669(%rip), %xmm1     # 0x3050
ucomisd %xmm0, %xmm1
jae 0x1a5f
movupd 0x8(%rdx), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd 0x16f2(%rip), %xmm1     # 0x30f0
movupd %xmm1, 0x8(%rdx)
movsd 0x10(%rsi), %xmm0
addsd 0x1648(%rip), %xmm0     # 0x3058
movsd %xmm0, 0x10(%rsi)
movl (%rdi), %eax
movl 0x54(%rdi), %ecx
cmpl $0x4, %eax
jne 0x1a5f
cmpl $0x5, %ecx
jne 0x1a5f
movsd 0x10(%rdx), %xmm0
movsd 0x162f(%rip), %xmm1     # 0x3060
ucomisd %xmm0, %xmm1
jbe 0x1a5f
movupd 0x8(%rdx), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd 0x16b8(%rip), %xmm1     # 0x3100
movupd %xmm1, 0x8(%rdx)
movsd 0x10(%rsi), %xmm0
addsd 0x160e(%rip), %xmm0     # 0x3068
movsd %xmm0, 0x10(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/dmarto[P]crrs-xlib/main.cpp
// Function: Sphere::Intersects(Ray const&, double&) const
bool Intersects(const Ray &ray, double &t) const
	{
		const Vec3 origin = ray.origin;
		const Vec3 dest = ray.destination;
		const Vec3 orgCtr = origin - this->center;
		const double b = 2 * dot(orgCtr, dest);
		const double center = dot(orgCtr, orgCtr) - radius * radius;
		double discrim = b * b - 4 * center;

		if (discrim < 1e-4)
			return false;

		discrim = sqrt(discrim);
		const double t0 = -b - discrim;
		const double t1 = -b + discrim;

		t = (t0 < t1) ? t0 : t1;

		return true;
	}

// Assembly:
movsd (%rsi), %xmm0
subsd (%rdi), %xmm0
movsd 0x18(%rsi), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm0
movupd 0x8(%rsi), %xmm2
movupd 0x8(%rdi), %xmm3
subpd %xmm3, %xmm2
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
unpcklpd %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0]
movapd %xmm2, %xmm0
movlpd 0x20(%rsi), %xmm0       # xmm0 = mem[0],xmm0[1]
mulpd %xmm2, %xmm0
addpd %xmm1, %xmm0
movsd 0x18(%rdi), %xmm1
shufpd $0x1, %xmm1, %xmm2      # xmm2 = xmm2[1],xmm1[0]
movsd 0x28(%rsi), %xmm3
unpcklpd %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0]
mulpd %xmm2, %xmm3
movapd %xmm0, %xmm1
addpd %xmm3, %xmm1
subpd %xmm3, %xmm0
movsd %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1]
mulpd 0xf9d(%rip), %xmm0      # 0x30b0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
subsd %xmm2, %xmm1
ucomisd 0xef9(%rip), %xmm1      # 0x3028
jb 0x2151
sqrtsd %xmm1, %xmm2
movapd %xmm2, %xmm3
addsd %xmm0, %xmm3
xorpd 0xf7b(%rip), %xmm3      # 0x30c0
subsd %xmm0, %xmm2
minsd %xmm3, %xmm2
movsd %xmm2, (%rdx)
ucomisd 0xecf(%rip), %xmm1      # 0x3028
setae %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::Matrix(int, int)
Matrix::Matrix(int rows, int cols)
{
  mData = new double* [rows];
  mShape[0] = rows;
  mShape[1] = cols;
	for (int i=0; i<rows;  i++){
		mData[i] = new double[cols];
		for (int j=0; j<cols; j++){
			mData[i][j] = 0.0;
  	}
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r12d
movq %rdi, %r14
movl %esi, %edi
shlq $0x3, %rdi
xorl %r13d, %r13d
testl %esi, %esi
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
movl $0x0, %ebp
cmovgl %esi, %ebp
callq 0x2030
movq %rax, %r15
movq %rax, (%r14)
movl %r12d, 0x8(%r14)
movl %ebx, 0xc(%r14)
movl %ebx, %r12d
shlq $0x3, %r12
testl %ebx, %ebx
pushq $-0x1
popq %rax
cmovsq %rax, %r12
cmovlel %r13d, %ebx
cmpq %rbp, %r13
je 0x2dda
movq %r12, %rdi
callq 0x2030
movq %rax, (%r15,%r13,8)
movq (%r14), %r15
xorl %eax, %eax
cmpq %rax, %rbx
je 0x2dd5
movq (%r15,%r13,8), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x2dc2
incq %r13
jmp 0x2dac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::operator()(int, int)
double& Matrix::operator()(int i, int j)
{

  if (i < 1 || j< 1)
    {
      throw Exception("out of range",
		  "accessing vector through () - index too small");
    }
  else if (i > mShape[0] || j >mShape[1] )
    {
      throw Exception("length mismatch",
		  "accessing vector through () - index too high");
    }
  return mData[i-1][j-1];
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
testl %esi, %esi
jle 0x2e65
testl %edx, %edx
jle 0x2e65
cmpl %esi, 0x8(%rdi)
jl 0x2ecb
cmpl %edx, 0xc(%rdi)
jl 0x2ecb
movq (%rdi), %rax
movl %esi, %ecx
movq -0x8(%rax,%rcx,8), %rax
movl %edx, %ecx
leaq (%rax,%rcx,8), %rax
addq $-0x8, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x2090
movq %rax, %rbx
leaq 0x6229(%rip), %rsi      # 0x90a0
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2060
leaq 0x6220(%rip), %rsi      # 0x90ad
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x2060
movb $0x1, %bpl
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a40
xorl %ebp, %ebp
leaq 0x9ee6(%rip), %rsi      # 0xcda0
leaq 0x5191(%rip), %rdx      # 0x8052
movq %rbx, %rdi
callq 0x21a0
jmp 0x2f2f
pushq $0x40
popq %rdi
callq 0x2090
movq %rax, %rbx
leaq 0x61fe(%rip), %rsi      # 0x90db
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2060
leaq 0x61f8(%rip), %rsi      # 0x90eb
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x2060
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x8a40
xorl %ebp, %ebp
leaq 0x9e80(%rip), %rsi      # 0xcda0
leaq 0x512b(%rip), %rdx      # 0x8052
movq %rbx, %rdi
callq 0x21a0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2070
jmp 0x2f44
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
jmp 0x2f65
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x2070
jmp 0x2f60
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rdi
callq 0x2070
testb %bpl, %bpl
jne 0x2f76
jmp 0x2f7e
jmp 0x2f73
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21d0