LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::Compiler::Scope::GetVarType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Gos::Compiler::Scope::GetVarType(const std::string& name) {
    if (varType.find(name) != varType.end()) {
        return varType[name];
    }
    if (fa != nullptr) {
        return fa->GetVarType(name);
    }
    std::cerr << "Error: " << compilingFileName << ": " << compilingLine << ": unknown variable type of " << name << std::endl;
    return "unknown";
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x60, %rdi
movq 0x50(%rsp), %rsi
callq 0x1dcf10
movq 0x20(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x60, %rdi
callq 0x1dcf40
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1dcef0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1d4fd7
jmp 0x1d4ffc
movq 0x20(%rsp), %rdi
addq $0x60, %rdi
movq 0x50(%rsp), %rsi
callq 0x1dcf70
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x6f070
jmp 0x1d50da
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1d5023
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x50(%rsp), %rdx
callq 0x1d4f70
jmp 0x1d50da
movq 0x12bfc6(%rip), %rdi    # 0x300ff0
leaq 0x4bb8b(%rip), %rsi     # 0x220bbc
callq 0x13380
movq %rax, %rdi
leaq 0x12d230(%rip), %rsi    # 0x302270
callq 0x131a0
movq %rax, %rdi
leaq 0x37da8(%rip), %rsi     # 0x20cdf7
callq 0x13380
movq %rax, %rdi
movl 0x12d29b(%rip), %esi    # 0x3022f8
callq 0x131d0
movq %rax, %rdi
leaq 0x4cfa0(%rip), %rsi     # 0x22200c
callq 0x13380
movq %rax, %rdi
movq 0x50(%rsp), %rsi
callq 0x131a0
movq %rax, %rdi
movq 0x12bf58(%rip), %rsi    # 0x300fe0
callq 0x135d0
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x13570
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x4cf7b(%rip), %rsi     # 0x222028
callq 0x165520
jmp 0x1d50b4
leaq 0x3f(%rsp), %rdi
callq 0x136a0
jmp 0x1d50da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x136a0
jmp 0x1d50e4
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x133f0
nop
// File: Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::Compiler::VMCompiler::MoveToNew()
void Gos::Compiler::VMCompiler::MoveToNew() {
    currentScope->subScopes.push_back(Scope());
    Scope* newScope = &currentScope->subScopes.back();
    newScope->pos = currentScope->pos;
    newScope->fa = currentScope;
    currentScope = newScope;
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xd0(%rax), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x110(%rsp)
movaps %xmm0, 0x100(%rsp)
movaps %xmm0, 0xf0(%rsp)
movaps %xmm0, 0xe0(%rsp)
movaps %xmm0, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x1dcfd0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1dcfa0
jmp 0x1d51a3
leaq 0x50(%rsp), %rdi
callq 0x1dd020
movq 0x8(%rsp), %rax
movq 0xd0(%rax), %rdi
addq $0x8, %rdi
callq 0x1dd070
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq 0xd0(%rax), %rcx
movq 0x20(%rcx), %rdx
movq 0x38(%rsp), %rcx
movq %rdx, 0x20(%rcx)
movq 0xd0(%rax), %rdx
movq 0x38(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x38(%rsp), %rcx
movq %rcx, 0xd0(%rax)
addq $0x128, %rsp            # imm = 0x128
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1dd020
movq 0x48(%rsp), %rdi
callq 0x133f0
nopl (%rax,%rax)
// File: Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::Compiler::VMCompiler::GetTmpVar()
int Gos::Compiler::VMCompiler::GetTmpVar() {
    for (auto& [i, b] : tmpVars) {
        if (!b) {
            b = true;
            return i;
        }
    }
    return pos++;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
addq $0xf0, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1dd0b0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1dd0e0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1dd110
xorb $-0x1, %al
testb $0x1, %al
jne 0x1d52a2
jmp 0x1d52fc
leaq 0x28(%rsp), %rdi
callq 0x1dd130
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1dd150
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1dd160
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
jne 0x1d52ee
movq 0x8(%rsp), %rax
movb $0x1, (%rax)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x44(%rsp)
jmp 0x1d5315
jmp 0x1d52f0
leaq 0x28(%rsp), %rdi
callq 0x1dd170
jmp 0x1d528b
movq (%rsp), %rcx
movl 0xe0(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0xe0(%rcx)
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::Compiler::VMCompiler::VMCompiler(GosVM::VMProgram&)
Gos::Compiler::VMCompiler::VMCompiler(GosVM::VMProgram& program) : pos(1), vm(program) {
    mainScope.fa = nullptr;
    mainScope.pos = &pos;
    currentScope = &mainScope;
    usings.clear();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x1dcfd0
movq (%rsp), %rdi
movl $0x1, 0xe0(%rdi)
movq 0x8(%rsp), %rax
movq %rax, 0xe8(%rdi)
addq $0xf0, %rdi
callq 0x1dd1a0
movq (%rsp), %rdi
addq $0x128, %rdi            # imm = 0x128
callq 0x1dd1b0
movq (%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x1dd1c0
movq (%rsp), %rax
movq $0x0, (%rax)
movq %rax, %rcx
addq $0xe0, %rcx
movq %rcx, 0x20(%rax)
movq %rax, 0xd0(%rax)
leaq 0x12ce87(%rip), %rdi    # 0x3022e0
callq 0x1dd1d0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: GetFieldCache(Gos::Compiler::Scope*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static inline int& GetFieldCache(Gos::Compiler::Scope* scope, const std::string& name) {
    for (auto* p = scope; p != nullptr; p = p->fa) {
        auto& info = p->compilingClassVarID;
        if (info.find(name) != info.end()) {
            return info[name];
        }
    }
    auto& info = scope->compilingClassVarID;
    info[name] = -1;
    return info[name];
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x1d5a11
movq 0x28(%rsp), %rax
addq $0x98, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1b4750
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1b4780
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b4730
xorb $-0x1, %al
testb $0x1, %al
jne 0x1d59ea
jmp 0x1d5a00
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1b4880
movq %rax, 0x40(%rsp)
jmp 0x1d5a4a
jmp 0x1d5a02
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x1d5998
movq 0x38(%rsp), %rax
addq $0x98, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1b4880
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1b4880
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Number::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Number) {
    compilingLine = token.line;
    int id = pc++;
    vm.WriteCommandNewNum(token.numType, id, token.num);
    return id;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movl 0x2c(%rcx), %eax
movl %eax, 0x12c87c(%rip)    # 0x3022f8
movq 0x18(%rsp), %rdx
movl 0xe0(%rdx), %eax
movl %eax, %esi
addl $0x1, %esi
movl %esi, 0xe0(%rdx)
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0xe8(%rax), %rdi
movb 0x30(%rcx), %al
movl 0x14(%rsp), %edx
movq 0x38(%rcx), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movsbl %al, %esi
callq 0x1b10d0
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::String::CompileAST(Gos::Compiler::VMCompiler&)
Compile(String) {
    compilingLine = token.line;
    int id = pc++;
    vm.WriteCommandNewStr(id, token.str);
    return id;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdx
movl 0x2c(%rdx), %eax
movl %eax, 0x12c80c(%rip)    # 0x3022f8
movq 0x8(%rsp), %rcx
movl 0xe0(%rcx), %eax
movl %eax, %esi
addl $0x1, %esi
movl %esi, 0xe0(%rcx)
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq 0xe8(%rax), %rdi
movl 0x4(%rsp), %esi
addq $0x28, %rdx
addq $0x18, %rdx
callq 0x1b1040
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Primary::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Primary) {
    START();
    if (branch & 1) {
        std::vector<int> params;
        if (branch & 2) {
            GosAST* argsList = nodes[1];
            for (auto* expr : argsList->nodes) {
                params.push_back(expr->CompileAST(code));
            }
        }
        int id = code.GetTmpVar();
        vm.WriteCommandNew(nodes[0]->token.str, id, params);
        return id;
    }
    return SUB(0);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl 0x2c(%rdi), %eax
movl %eax, 0x12c7a4(%rip)    # 0x3022f8
addq $0x10, %rdi
callq 0x1d1e80
cmpq $0x0, %rax
jne 0x1d5b73
movl $0x0, 0x84(%rsp)
jmp 0x1d5cfb
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1d5cd5
leaq 0x58(%rsp), %rdi
callq 0x1dd1b0
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1d5c73
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0x1d1e60
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1d1b70
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1d1ba0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1d1bd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1d5c03
jmp 0x1d5c71
leaq 0x40(%rsp), %rdi
callq 0x1d1c10
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, 0xc(%rsp)
jmp 0x1d5c2d
movl 0xc(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x1dd2e0
jmp 0x1d5c46
jmp 0x1d5c48
leaq 0x40(%rsp), %rdi
callq 0x1d1c20
jmp 0x1d5bec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1dd280
jmp 0x1d5d0a
jmp 0x1d5c73
movq 0x70(%rsp), %rdi
callq 0x1d5250
movq 0x10(%rsp), %rdi
movl %eax, 0x18(%rsp)
movq 0x70(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, (%rsp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rsp), %rdi
movq (%rax), %rsi
addq $0x40, %rsi
movl 0x18(%rsp), %edx
leaq 0x58(%rsp), %rcx
callq 0x1b0f40
jmp 0x1d5cbe
movl 0x18(%rsp), %eax
movl %eax, 0x84(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1dd280
jmp 0x1d5cfb
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x70(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movl 0x2c(%rdi), %eax
movl %eax, 0x12b734(%rip)    # 0x3022f8
addq $0x10, %rdi
callq 0x1d1e80
cmpq $0x0, %rax
jne 0x1d6be3
movl $0x0, 0x84(%rsp)
jmp 0x1d6d11
movq 0x38(%rsp), %rax
cmpl $0xe, 0x28(%rax)
jne 0x1d6ceb
movq 0x70(%rsp), %rdi
callq 0x1d5250
movq 0x38(%rsp), %rdi
movl %eax, 0x6c(%rsp)
movq 0x70(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x18(%rsp)
addq $0x10, %rdi
movl $0x1, %esi
callq 0x1d1e60
movq (%rax), %rax
addq $0x40, %rax
movq %rax, 0x20(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x2c(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x1dd1b0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x2c(%rsp), %edx
movq 0x30(%rsp), %rcx
callq 0x1b0f40
jmp 0x1d6c72
leaq 0x50(%rsp), %rdi
callq 0x1dd280
movq 0x38(%rsp), %rdi
movq 0x70(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x70(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %eax, %edx
callq 0x1b1150
movl 0x6c(%rsp), %eax
movl %eax, 0x84(%rsp)
jmp 0x1d6d11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1dd280
jmp 0x1d6d20
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x70(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x133f0
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movl 0x2c(%rdi), %eax
movl %eax, 0x12b347(%rip)    # 0x3022f8
addq $0x10, %rdi
callq 0x1d1e80
cmpq $0x0, %rax
jne 0x1d6fcd
movl $0x0, 0x64(%rsp)
jmp 0x1d717a
movq 0x40(%rsp), %rdi
addq $0x60, %rdi
callq 0x1c58d0
cmpq $0x0, %rax
jne 0x1d7009
movq 0x40(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x50(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movl %eax, 0x64(%rsp)
jmp 0x1d717a
movq 0x50(%rsp), %rdi
callq 0x1d5250
movq 0x40(%rsp), %rdi
movl %eax, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x30(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x3c(%rsp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x50(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x30(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl %eax, %edx
callq 0x1b11f0
movl $0x0, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x60, %rdi
callq 0x1c58d0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x1d7172
movq 0x40(%rsp), %rdi
addq $0x60, %rdi
movslq 0x48(%rsp), %rsi
callq 0x1c58f0
cmpl $0x1a, (%rax)
jne 0x1d70f8
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x24(%rsp)
addq $0x10, %rdi
movl 0x48(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x50(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %eax, %edx
callq 0x1b1330
jmp 0x1d7160
movq 0x40(%rsp), %rdi
addq $0x60, %rdi
movslq 0x48(%rsp), %rsi
callq 0x1c58f0
cmpl $0x1b, (%rax)
jne 0x1d715e
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x10, %rdi
movl 0x48(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x50(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %eax, %edx
callq 0x1b1380
jmp 0x1d7160
jmp 0x1d7162
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x1d7067
movl 0x4c(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl 0x2c(%rdi), %eax
movl %eax, 0x12a687(%rip)    # 0x3022f8
addq $0x10, %rdi
callq 0x1d1e80
cmpq $0x0, %rax
jne 0x1d7c8d
movl $0x0, 0x54(%rsp)
jmp 0x1d7daf
movq 0x30(%rsp), %rdi
addq $0x60, %rdi
callq 0x1c58d0
cmpq $0x0, %rax
jne 0x1d7cc9
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movl %eax, 0x54(%rsp)
jmp 0x1d7daf
movq 0x40(%rsp), %rdi
callq 0x1d5250
movq 0x30(%rsp), %rdi
movl %eax, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x20(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x2c(%rsp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl %eax, %edx
callq 0x1b11f0
movl $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x60, %rdi
callq 0x1c58d0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x1d7da7
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x10, %rdi
movl 0x38(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %eax, %edx
callq 0x1b1510
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x1d7d27
movl 0x3c(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl 0x2c(%rdi), %eax
movl %eax, 0x12a517(%rip)    # 0x3022f8
addq $0x10, %rdi
callq 0x1d1e80
cmpq $0x0, %rax
jne 0x1d7dfd
movl $0x0, 0x54(%rsp)
jmp 0x1d7f1f
movq 0x30(%rsp), %rdi
addq $0x60, %rdi
callq 0x1c58d0
cmpq $0x0, %rax
jne 0x1d7e39
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movl %eax, 0x54(%rsp)
jmp 0x1d7f1f
movq 0x40(%rsp), %rdi
callq 0x1d5250
movq 0x30(%rsp), %rdi
movl %eax, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x20(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x2c(%rsp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl %eax, %edx
callq 0x1b11f0
movl $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x60, %rdi
callq 0x1c58d0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x1d7f17
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x10, %rdi
movl 0x38(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl %eax, %edx
callq 0x1b1560
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x1d7e97
movl 0x3c(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movl 0x2c(%rdi), %eax
movl %eax, 0x12a39b(%rip)    # 0x3022f8
addq $0x10, %rdi
callq 0x1d1e80
cmpq $0x0, %rax
jne 0x1d7f7c
movl $0x0, 0xb4(%rsp)
jmp 0x1d819a
movq 0x40(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x1d8171
movq 0xa0(%rsp), %rdi
callq 0x1d5250
movq 0x40(%rsp), %rdi
movl %eax, 0x9c(%rsp)
addq $0x10, %rdi
movq %rdi, 0x28(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0xa0(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq 0xe8(%rax), %rsi
movl 0x98(%rsp), %edx
leaq 0x78(%rsp), %rdi
callq 0x1b1760
movq 0x28(%rsp), %rdi
movq 0xa0(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x30(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x38(%rsp)
movl $0x2, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0xa0(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, 0x3c(%rsp)
jmp 0x1d8037
movl 0x3c(%rsp), %edx
movl 0x38(%rsp), %esi
movq 0x30(%rsp), %rdi
callq 0x1b11f0
jmp 0x1d804b
movq 0xa0(%rsp), %rax
movq 0xe8(%rax), %rsi
leaq 0x48(%rsp), %rdi
callq 0x1b1630
jmp 0x1d8066
movq 0xa0(%rsp), %rax
movq 0xe8(%rax), %rdi
callq 0x1b1b80
movl %eax, 0x24(%rsp)
jmp 0x1d8080
movl 0x24(%rsp), %esi
leaq 0x78(%rsp), %rdi
callq 0x1d1c40
jmp 0x1d8090
movq 0x40(%rsp), %rdi
movq 0xa0(%rsp), %rax
movq 0xe8(%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x1c(%rsp)
addq $0x10, %rdi
movl $0x1, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0xa0(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, 0x20(%rsp)
jmp 0x1d80db
movl 0x20(%rsp), %edx
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdi
callq 0x1b11f0
jmp 0x1d80ef
movq 0xa0(%rsp), %rax
movq 0xe8(%rax), %rdi
callq 0x1b1b80
movl %eax, 0xc(%rsp)
jmp 0x1d8109
movl 0xc(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0x1d1c40
jmp 0x1d8119
movl 0x9c(%rsp), %eax
movl %eax, 0xb4(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1d1c80
leaq 0x78(%rsp), %rdi
callq 0x1d1c80
jmp 0x1d819a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x1d8165
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1d1c80
leaq 0x78(%rsp), %rdi
callq 0x1d1c80
jmp 0x1d81a9
movq 0x40(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0xa0(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movl %eax, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl 0x2c(%rdi), %eax
movl %eax, 0x12a0a7(%rip)    # 0x3022f8
addq $0x10, %rdi
callq 0x1d1e80
cmpq $0x0, %rax
jne 0x1d826d
movl $0x0, 0x34(%rsp)
jmp 0x1d83fc
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq %rdi, (%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq (%rsp), %rdi
movl %eax, 0x1c(%rsp)
movl $0x1, %esi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rsp)
movl 0x28(%rax), %eax
addl $-0xf, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x8, %eax
ja 0x1d83ea
movq 0x8(%rsp), %rax
leaq 0x49a42(%rip), %rcx     # 0x221d24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rax
movq 0xe8(%rax), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x1b1150
jmp 0x1d83f4
movq 0x20(%rsp), %rax
movq 0xe8(%rax), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x1b1330
jmp 0x1d83f4
movq 0x20(%rsp), %rax
movq 0xe8(%rax), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x1b1380
jmp 0x1d83f4
movq 0x20(%rsp), %rax
movq 0xe8(%rax), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x1b13d0
jmp 0x1d83f4
movq 0x20(%rsp), %rax
movq 0xe8(%rax), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x1b1420
jmp 0x1d83f4
movq 0x20(%rsp), %rax
movq 0xe8(%rax), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x1b1470
jmp 0x1d83f4
movq 0x20(%rsp), %rax
movq 0xe8(%rax), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x1b14c0
jmp 0x1d83f4
movq 0x20(%rsp), %rax
movq 0xe8(%rax), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x1b1510
jmp 0x1d83f4
movq 0x20(%rsp), %rax
movq 0xe8(%rax), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x1b1560
jmp 0x1d83f4
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x1d83fc
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl 0x2c(%rax), %ecx
movl %ecx, 0x12816c(%rip)    # 0x3022f8
movl 0x12821e(%rip), %ecx    # 0x3023b0
addl $0x1, %ecx
movl %ecx, 0x128215(%rip)    # 0x3023b0
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1d1b70
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1d1ba0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1d1bd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1da1d9
jmp 0x1da206
leaq 0x18(%rsp), %rdi
callq 0x1d1c10
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
leaq 0x18(%rsp), %rdi
callq 0x1d1c20
jmp 0x1da1c2
movl 0x1281a4(%rip), %eax    # 0x3023b0
addl $-0x1, %eax
movl %eax, 0x12819b(%rip)    # 0x3023b0
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x2c(%rdi), %eax
movl %eax, 0x126217(%rip)    # 0x3022f8
addq $0x10, %rdi
callq 0x1d1e80
cmpq $0x0, %rax
jne 0x1dc0fd
movl $0x0, 0x74(%rsp)
jmp 0x1dc227
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d1e60
movq (%rax), %rsi
addq $0x28, %rsi
addq $0x18, %rsi
leaq 0x40(%rsp), %rdi
callq 0x6f070
leaq 0x28(%rsp), %rdi
callq 0x1b4f70
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x1d1e80
cmpq $0x1, %rax
jbe 0x1dc1ee
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, (%rsp)
addq $0x10, %rdi
movl $0x1, %esi
callq 0x1d1e60
movq (%rax), %rdi
addq $0x10, %rdi
callq 0x1d1e80
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x1dc1ec
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0x1d1e60
movq (%rax), %rdi
addq $0x10, %rdi
movslq 0x24(%rsp), %rsi
callq 0x1d1e60
movq (%rax), %rsi
addq $0x40, %rsi
leaq 0x28(%rsp), %rdi
callq 0x1b4f80
jmp 0x1dc1b9
jmp 0x1dc1bb
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1dc14e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6ed80
leaq 0x40(%rsp), %rdi
callq 0x52f50
jmp 0x1dc230
jmp 0x1dc1ee
movq 0x60(%rsp), %rax
movq 0xe8(%rax), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x1b1a30
jmp 0x1dc20b
movl $0x0, 0x74(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6ed80
leaq 0x40(%rsp), %rdi
callq 0x52f50
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x133f0
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl 0x2c(%rdi), %eax
movl %eax, 0x126097(%rip)    # 0x3022f8
addq $0x10, %rdi
callq 0x1d1e80
cmpq $0x0, %rax
jne 0x1dc27a
movl $0x0, 0x34(%rsp)
jmp 0x1dc2dc
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
callq 0x1d1e80
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1dc2d4
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x1d1e60
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1dc282
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x1c68a0
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x1187a0
movq 0x58(%rsp), %rdi
callq 0x55b20
subq $0x1, %rax
movl %eax, 0x54(%rsp)
movq 0x58(%rsp), %rdi
movslq 0x54(%rsp), %rsi
callq 0x1e6dc0
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, 0x7(%rsp)
je 0x1e574c
cmpl $0x0, 0x54(%rsp)
setg %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1e5756
jmp 0x1e5763
movl 0x54(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x1e5723
cmpl $0x0, 0x54(%rsp)
jne 0x1e5778
movq 0x58(%rsp), %rdi
callq 0x55b20
movl %eax, 0x54(%rsp)
movq 0x8(%rsp), %rdi
callq 0x52f00
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movslq 0x54(%rsp), %rdx
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x54a50
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x18fed0
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x30(%rax)
movw 0x48(%rsp), %cx
movw %cx, 0x38(%rax)
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rsi
movq %rsi, 0x8(%rsp)
leaq 0x11bd96(%rip), %rax    # 0x301610
movq %rax, 0x50(%rsp)
addq $0x20, %rsi
leaq 0x11bd86(%rip), %rdi    # 0x301610
callq 0x1b5300
movq %rax, 0x48(%rsp)
leaq 0x11bd75(%rip), %rdi    # 0x301610
callq 0x1b5330
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1b52e0
testb $0x1, %al
jne 0x1e58bd
jmp 0x1e594c
movq 0x11b72c(%rip), %rdi    # 0x300ff0
leaq 0x3c808(%rip), %rsi     # 0x2220d3
callq 0x13380
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x131a0
movq %rax, %rdi
leaq 0x27510(%rip), %rsi     # 0x20cdf7
callq 0x13380
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
addq $0x20, %rdi
callq 0x2b420
movq (%rsp), %rdi
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x133c10
movq %rax, %rdi
movq 0x11b6bb(%rip), %rsi    # 0x300fe0
callq 0x135d0
leaq 0x10(%rsp), %rdi
callq 0x534e0
leaq 0x11bcd5(%rip), %rdi    # 0x301610
leaq 0x10(%rsp), %rsi
callq 0x1e6df0
movq %rax, 0x60(%rsp)
jmp 0x1e5966
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
leaq 0x11bcb4(%rip), %rdi    # 0x301610
callq 0x1b5360
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
// File: 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:
subq $0x268, %rsp            # imm = 0x268
movq %rdx, 0x10(%rsp)
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq 0x260(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x258(%rsp), %rsi
leaq 0x1e0(%rsp), %rdi
callq 0x1c3c40
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1e56e0
jmp 0x1e5ab7
movq 0x8(%rsp), %rsi
addq $0x40, %rsi
leaq 0x78(%rsp), %rdi
callq 0x1d53d0
jmp 0x1e5acc
leaq 0x18(%rsp), %rdi
callq 0x1d1d40
jmp 0x1e5ad8
leaq 0x18(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
callq 0x1c6d80
jmp 0x1e5aec
leaq 0x18(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x1c6b50
jmp 0x1e5afd
leaq 0x18(%rsp), %rdi
callq 0x1c6f10
leaq 0x78(%rsp), %rdi
callq 0x1e6e20
leaq 0x1e0(%rsp), %rdi
callq 0x1e6e70
addq $0x268, %rsp            # imm = 0x268
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1d8(%rsp)
movl %eax, 0x1d4(%rsp)
jmp 0x1e5b7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1d8(%rsp)
movl %eax, 0x1d4(%rsp)
jmp 0x1e5b70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1d8(%rsp)
movl %eax, 0x1d4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1c6f10
leaq 0x78(%rsp), %rdi
callq 0x1e6e20
leaq 0x1e0(%rsp), %rdi
callq 0x1e6e70
movq 0x1d8(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xe8, %rsp
movq %rdx, (%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x1e7500
leaq 0x2652d(%rip), %rsi     # 0x20cb61
leaq 0x58(%rsp), %rdi
movl $0x2, %edx
callq 0x1e6fb0
jmp 0x1e6645
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x80(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1e6720
jmp 0x1e6676
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1ee1b0
jmp 0x1e6687
leaq 0x28(%rsp), %rdi
callq 0x1e7530
leaq 0x58(%rsp), %rdi
callq 0x1e7130
movq 0x8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x1e6250
jmp 0x1e66af
leaq 0x80(%rsp), %rdi
callq 0x1e7540
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1e6706
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1e66fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1e7530
leaq 0x58(%rsp), %rdi
callq 0x1e7130
leaq 0x80(%rsp), %rdi
callq 0x1e7540
movq 0x50(%rsp), %rdi
callq 0x133f0
nopl (%rax)
// File: 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:
subq $0x3b8, %rsp            # imm = 0x3B8
movl %edi, 0x3b4(%rsp)
movq %rsi, 0x3a8(%rsp)
callq 0x1f4fd0
leaq 0x308(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1e6d20
movq 0x8(%rsp), %rsi
leaq 0x2a0(%rsp), %rdi
callq 0x1a9600
jmp 0x1f59c1
leaq 0x88(%rsp), %rdi
callq 0x131f0
jmp 0x1f59d0
cmpl $0x1, 0x3b4(%rsp)
jle 0x1f5a47
movq 0x3a8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x88(%rsp), %rdi
movl $0x8, %edx
callq 0x13430
jmp 0x1f59fa
jmp 0x1f5a64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
jmp 0x1f5b54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
jmp 0x1f5b47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
jmp 0x1f5b3a
leaq 0x2c9de(%rip), %rsi     # 0x22242c
leaq 0x88(%rsp), %rdi
movl $0x8, %edx
callq 0x13430
jmp 0x1f5a62
jmp 0x1f5a64
leaq 0x2a0(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movl $0x1, %edx
callq 0x1ad190
jmp 0x1f5a80
leaq 0x88(%rsp), %rdi
callq 0x133d0
jmp 0x1f5a8f
leaq 0x28(%rsp), %rdi
callq 0x1e0e0
jmp 0x1f5a9b
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x53b40
movq (%rsp), %rcx
leaq 0x50(%rsp), %rdi
leaq 0x2a0(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x1a9c50
jmp 0x1f5ad7
leaq 0x10(%rsp), %rdi
callq 0x53b50
leaq 0x50(%rsp), %rdi
callq 0x23b00
leaq 0x88(%rsp), %rdi
callq 0x13040
leaq 0x2a0(%rsp), %rdi
callq 0x1ec900
leaq 0x308(%rsp), %rdi
callq 0x1e6d70
xorl %eax, %eax
addq $0x3b8, %rsp            # imm = 0x3B8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x53b50
leaq 0x88(%rsp), %rdi
callq 0x13040
leaq 0x2a0(%rsp), %rdi
callq 0x1ec900
leaq 0x308(%rsp), %rdi
callq 0x1e6d70
movq 0x298(%rsp), %rdi
callq 0x133f0
nop
// File: dmarto[P]crrs-xlib/main.cpp
// Function: RenderPixel(ScreenData const&)
Vec3 RenderPixel(const ScreenData &sd)
{
	Vec3 pixclr = sd.color.black;
	//~ Vec3 pixclrBounce = sd.color.black;

	const Ray ray(Vec3(sd.x, sd.y, -3), Vec3(0, 0, 1));
	pixclr = Trace(ray, sd.light, sd.objList);

	return pixclr;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rcx
movq %rcx, (%rdi)
movq 0x38(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x40(%rax), %rax
movq %rax, 0x10(%rdi)
movq 0x90(%rsp), %rax
cvtsi2sdl 0x8(%rax), %xmm0
movq 0x90(%rsp), %rax
cvtsi2sdl 0xc(%rax), %xmm1
leaq 0x48(%rsp), %rdi
movsd 0x318b(%rip), %xmm2     # 0x6050
callq 0x4330
leaq 0x30(%rsp), %rdi
xorps %xmm1, %xmm1
movsd 0x317e(%rip), %xmm2     # 0x6058
movaps %xmm1, %xmm0
callq 0x4330
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x3da0
movq 0x90(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x90(%rsp), %rax
movq 0x18(%rax), %rcx
leaq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2b50
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rdi)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rdi)
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rdi)
addq $0x98, %rsp
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
cmpl $0x6, (%rax)
jne 0x2f90
movq -0x8(%rsp), %rax
cvtsi2sdl 0x40(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
cvtsi2sdl 0x44(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rsp), %rax
cmpl $0x4, (%rax)
jne 0x300e
movq -0x8(%rsp), %rax
cmpl $0x4, 0x54(%rax)
jne 0x300e
movq -0x18(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x30b1(%rip), %xmm1     # 0x6068
ucomisd %xmm1, %xmm0
jbe 0x300e
movq -0x18(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x30a9(%rip), %xmm1     # 0x6078
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x308e(%rip), %xmm1     # 0x6078
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd 0x306b(%rip), %xmm1     # 0x6070
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x8(%rsp), %rax
cmpl $0x4, (%rax)
jne 0x307c
movq -0x8(%rsp), %rax
cmpl $0x5, 0x54(%rax)
jne 0x307c
movq -0x18(%rsp), %rax
movsd 0x3050(%rip), %xmm0     # 0x6080
ucomisd 0x10(%rax), %xmm0
jbe 0x307c
movq -0x18(%rsp), %rax
movsd 0x3034(%rip), %xmm0     # 0x6078
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x18(%rsp), %rax
movsd 0x301d(%rip), %xmm0     # 0x6078
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movsd 0x2ffe(%rip), %xmm0     # 0x6070
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
retq
nopl (%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x98(%rsp), %rdx
movq %rdx, 0x10(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x70(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x78(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x58(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x60(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0x68(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x4020
leaq 0x40(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x40e0
movaps %xmm0, %xmm1
movsd 0x21b3(%rip), %xmm0     # 0x6040
mulsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
leaq 0x40(%rsp), %rsi
movq %rsi, %rdi
callq 0x40e0
movq 0x10(%rsp), %rax
movsd 0x18(%rax), %xmm1
mulsd 0x18(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x38(%rsp), %xmm0
mulsd 0x38(%rsp), %xmm0
movsd 0x2167(%rip), %xmm1     # 0x6038
mulsd 0x30(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x2147(%rip), %xmm0     # 0x6030
ucomisd 0x28(%rsp), %xmm0
jbe 0x3efe
movb $0x0, 0xa7(%rsp)
jmp 0x3fa6
movsd 0x28(%rsp), %xmm0
sqrtsd %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x38(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
subsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3f80
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x3f8c
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x88(%rsp), %rax
movsd %xmm0, (%rax)
movb $0x1, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x1c(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x18(%rsp), %ecx
movl %ecx, 0xc(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x3659
movslq 0x18(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0x3647
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x3612
jmp 0x3649
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x35c2
addq $0x28, %rsp
retq
nop
// File: yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::T() const
Matrix Matrix::T() const
{
	Matrix C(mShape[1],mShape[0]);
	for (int i=0; i<mShape[1];  i++){
		for (int j=0; j<mShape[0]; j++){
			C.mData[i][j] = mData[j][i];
		}
	}
	return C;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x27(%rsp)
movl 0xc(%rax), %esi
movl 0x8(%rax), %edx
callq 0x3560
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3aa1
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3a92
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movslq 0x1c(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x20(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x1c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3a42
jmp 0x3a94
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x3a2c
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x3ab6
movq (%rsp), %rdi
callq 0x3660
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq