LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMProgram::WriteCommandNew(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::vector<int, std::allocator<int>> const&)
void GosVM::VMProgram::WriteCommandNew(const std::string& type, int varID, const std::vector<int>& params) {
    AddOperation(NEW);
    AddParamString(type);
    AddParamInt(varID);
    AddParamInt(params.size());
    for (int i = 0; i < params.size(); i++) {
        AddParamInt(params[i]);
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0xb, %esi
callq 0x1a96f0
movq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x6f070
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1a98d0
jmp 0x1b0f90
leaq 0x28(%rsp), %rdi
callq 0x52f50
movq 0x8(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x1a9780
movq 0x48(%rsp), %rdi
callq 0x1b5c30
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x1a9780
movl $0x0, 0x18(%rsp)
movslq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq 0x1b5c30
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x1b1027
movq 0x48(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0x1b5c50
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x1a9780
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1b0fc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x52f50
jmp 0x1b102c
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMProgram::WriteCommandNewNum(signed char, int, GosVM::RTConstNum)
void GosVM::VMProgram::WriteCommandNewNum(int8_t type, int varID, RTConstNum num) {
    AddOperation(NEW_NUM);
    AddParamByte(type);
    AddParamInt(varID);
    // std::cout << (int)num.data.i64 << " ID: " << cst->getNumID(num) << std::endl;
    AddParamInt(cst->getNumID(num));
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rcx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movl $0xd, %esi
callq 0x1a96f0
movq (%rsp), %rdi
movsbl 0x17(%rsp), %esi
callq 0x1a9750
movq (%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x1a9780
movq (%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x1a91f0
movq (%rsp), %rdi
movl %eax, %esi
callq 0x1a9780
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMProgram::WriteCommandGetField(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void GosVM::VMProgram::WriteCommandGetField(int varID, int sourceVarID, const std::string& fieldName) {
    AddOperation(GET_FIELD);
    AddParamInt(varID);
    AddParamInt(sourceVarID);
    AddParamString(fieldName);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x12, %esi
callq 0x1a96f0
movq (%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x1a9780
movq (%rsp), %rdi
movl 0x48(%rsp), %esi
callq 0x1a9780
movq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6f070
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1a98d0
jmp 0x1b12f7
leaq 0x20(%rsp), %rdi
callq 0x52f50
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x52f50
movq 0x18(%rsp), %rdi
callq 0x133f0
nopl (%rax,%rax)
// File: Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMProgram::WriteCommandJmp()
std::function<void(int)> GosVM::VMProgram::WriteCommandJmp() {
    AddOperation(JMP);
    int pos = content.size();
    AddParamInt(0);
    int startJump = content.size();
    return [this, pos, startJump](int jmp) {
        *(int*)&content[pos] = jmp - startJump;
    };
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x1d, %esi
callq 0x1a96f0
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x55060
movq 0x10(%rsp), %rdi
movl %eax, 0x34(%rsp)
xorl %esi, %esi
callq 0x1a9780
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x55060
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl %ecx, 0x30(%rsp)
movq %rax, 0x20(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x2c(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x1b16d0
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMProgram::WriteCommandIf(int)
std::function<void(int)> GosVM::VMProgram::WriteCommandIf(int varID) {
    AddOperation(IF);
    AddParamInt(varID);
    int pos = content.size();
    AddParamInt(0);
    int startJump = content.size();
    return [this, pos, startJump](int jmp) {
        *(int*)&content[pos] = jmp - startJump;
    };
}

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1e, %esi
callq 0x1a96f0
movq 0x8(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x1a9780
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x55060
movq 0x8(%rsp), %rdi
movl %eax, 0x30(%rsp)
xorl %esi, %esi
callq 0x1a9780
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x55060
movq (%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl %ecx, 0x2c(%rsp)
movq %rax, 0x18(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x24(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x1b1810
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMProgram::WriteCommandCall(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>)
void GosVM::VMProgram::WriteCommandCall(int varID, const std::string& func, std::vector<int> paramsID) {
    AddOperation(CALL);
    AddParamInt(varID);
    AddParamString(func);
    int cnt = paramsID.size();
    AddParamInt(cnt);
    for (int i = 0; i < cnt; i++) {
        AddParamInt(paramsID[i]);
    }
}

// Assembly:
subq $0x78, %rsp
movq %rcx, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x21, %esi
callq 0x1a96f0
movq 0x10(%rsp), %rdi
movl 0x6c(%rsp), %esi
callq 0x1a9780
movq 0x60(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6f070
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1a98d0
jmp 0x1b19a3
leaq 0x38(%rsp), %rdi
callq 0x52f50
movq 0x8(%rsp), %rdi
callq 0x1b5c30
movq 0x10(%rsp), %rdi
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %esi
callq 0x1a9780
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x1b1a1d
movq 0x8(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x1b5c70
movq 0x10(%rsp), %rdi
movl (%rax), %esi
callq 0x1a9780
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1b19d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x52f50
jmp 0x1b1a22
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x133f0
nopl (%rax)
// File: Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMProgram::WriteCommandAttributes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<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>>>> const&)
void GosVM::VMProgram::WriteCommandAttributes(const std::string& attr, const std::vector<std::string>& params) {
    AddOperation(ATTR);
    AddParamString(attr);
    int len = params.size();
    AddParamInt(len);
    for (int i = 0; i < len; i++) {
        AddParamString(params[i]);
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x2, %esi
callq 0x1a96f0
movq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x6f070
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1a98d0
jmp 0x1b1a85
leaq 0x50(%rsp), %rdi
callq 0x52f50
movq 0x70(%rsp), %rdi
callq 0x6f4b0
movq 0x8(%rsp), %rdi
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %esi
callq 0x1a9780
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x40(%rsp), %eax
jge 0x1b1b38
movq 0x70(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0x1b5c10
movq %rax, %rsi
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6f070
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1a98d0
jmp 0x1b1aed
leaq 0x18(%rsp), %rdi
callq 0x52f50
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x1b1ab3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x52f50
jmp 0x1b1b40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x52f50
jmp 0x1b1b40
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x133f0
nopw (%rax,%rax)
// File: Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMProgram::WriteAlloc()
std::function<void(int)> GosVM::VMProgram::WriteAlloc() {
    AddOperation(ALLOC);
    int pos = content.size();
    AddParamInt(0);
    return [this, pos](int memSize) {
        *(int*)&content[pos] = memSize;
    };
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x7, %esi
callq 0x1a96f0
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x55060
movq 0x8(%rsp), %rdi
movl %eax, 0x34(%rsp)
xorl %esi, %esi
callq 0x1a9780
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x28(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x1b1c20
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: Heptagon196[P]Gos/GosVM.cpp
// Function: int GosVM::IRTokenizer::TokenTo<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
T GosVM::IRTokenizer::TokenTo(std::string token) {
    std::stringstream ss;
    ss << token;
    T i;
    ss >> i;
    return i;
}

// Assembly:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x10(%rsp)
movq %rdi, 0x1b0(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x131b0
movq 0x10(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x131a0
jmp 0x1bc0ef
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x13680
jmp 0x1bc100
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x13240
movl 0xc(%rsp), %eax
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x13240
movq 0x20(%rsp), %rdi
callq 0x133f0
// File: Heptagon196[P]Gos/GosTokenizer.cpp
// Function: Gos::GosToken::ToString[abi:cxx11]() const
std::string Gos::GosToken::ToString() const {
    if (type == SYMBOL) {
        return str;
    } else if (type == NUMBER) {
        std::stringstream ss;
        const char* names[] = { "i8", "i32", "i64", "float", "double" };
        ss << names[numType] << " ";
        if (numType < 3) {
            ss << num.data.i64;
        } else if (numType == 3) {
            ss << num.data.f;
        } else if (numType == 4) {
            ss << num.data.d;
        }
        return ss.str();
    } else if (type == STRING) {
        return "\"" + str + "\"";
    }
    return TokenName[type];
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movq 0x218(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x2a, (%rax)
jne 0x1c3a5e
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x18, %rsi
callq 0x6f070
jmp 0x1c3c25
movq 0x28(%rsp), %rax
cmpl $0x2b, (%rax)
jne 0x1c3b9a
leaq 0x90(%rsp), %rdi
callq 0x131b0
movq 0x28(%rsp), %rax
movq 0x13c57b(%rip), %rcx    # 0x300000
movq %rcx, 0x80(%rsp)
movaps 0x13c55c(%rip), %xmm0   # 0x2ffff0
movaps %xmm0, 0x70(%rsp)
movaps 0x13c540(%rip), %xmm0   # 0x2fffe0
movaps %xmm0, 0x60(%rsp)
leaq 0xa0(%rsp), %rdi
movsbq 0x8(%rax), %rax
movq 0x60(%rsp,%rax,8), %rsi
callq 0x13380
movq %rax, 0x10(%rsp)
jmp 0x1c3ac3
movq 0x10(%rsp), %rdi
leaq 0x5d1f6(%rip), %rsi     # 0x220cc5
callq 0x13380
jmp 0x1c3ad6
movq 0x28(%rsp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x3, %eax
jge 0x1c3b1e
movq 0x28(%rsp), %rax
leaq 0xa0(%rsp), %rdi
movq 0x10(%rax), %rsi
callq 0x13230
jmp 0x1c3afc
jmp 0x1c3b74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x13240
jmp 0x1c3c32
movq 0x28(%rsp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x3, %eax
jne 0x1c3b47
movq 0x28(%rsp), %rax
leaq 0xa0(%rsp), %rdi
movss 0x10(%rax), %xmm0
callq 0x135f0
jmp 0x1c3b45
jmp 0x1c3b72
movq 0x28(%rsp), %rax
movsbl 0x8(%rax), %eax
cmpl $0x4, %eax
jne 0x1c3b70
movq 0x28(%rsp), %rax
leaq 0xa0(%rsp), %rdi
movsd 0x10(%rax), %xmm0
callq 0x13490
jmp 0x1c3b6e
jmp 0x1c3b70
jmp 0x1c3b72
jmp 0x1c3b74
movq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x13340
jmp 0x1c3b88
leaq 0x90(%rsp), %rdi
callq 0x13240
jmp 0x1c3c25
movq 0x28(%rsp), %rax
cmpl $0x2c, (%rax)
jne 0x1c3c02
movq 0x28(%rsp), %rdx
addq $0x18, %rdx
leaq 0x5d0ea(%rip), %rsi     # 0x220c9e
movq %rsi, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x1c5600
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x52e30
jmp 0x1c3bdc
leaq 0x30(%rsp), %rdi
callq 0x52f50
jmp 0x1c3c25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x52f50
jmp 0x1c3c32
jmp 0x1c3c04
jmp 0x1c3c06
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movl (%rax), %eax
leaq 0x13dec7(%rip), %rsi    # 0x301ae0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x6f070
movq 0x20(%rsp), %rax
addq $0x228, %rsp            # imm = 0x228
retq
movq 0x58(%rsp), %rdi
callq 0x133f0
nopl (%rax)
// File: Heptagon196[P]Gos/GosTokenizer.cpp
// Function: Gos::GosTokenizer::EatToken(Gos::TokenType)
void Gos::GosTokenizer::EatToken(Gos::TokenType type) {
    auto recv = GetToken();
    if (recv.type != type) {
        if (errorCallback != 0) {
            if (!errorCallback()) {
                return;
            }
        }
        std::cerr << "Error: " << inputName << ": " << recv.line << ": invalid token: expected \"" << GosToken::TokenName[type] << "\" but \"" << recv.ToString() << "\" found" << std::endl;
    }
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movl %esi, 0xcc(%rsp)
movq 0xd0(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x1c5260
movq %rax, %rsi
leaq 0x90(%rsp), %rdi
callq 0x1c5960
movl 0x90(%rsp), %eax
cmpl 0xcc(%rsp), %eax
je 0x1c54ea
movq 0x58(%rsp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1c59b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1c5366
jmp 0x1c53af
movq 0x58(%rsp), %rdi
addq $0x50, %rdi
callq 0x1c59e0
movb %al, 0x57(%rsp)
jmp 0x1c537a
movb 0x57(%rsp), %al
testb $0x1, %al
jne 0x1c53ad
jmp 0x1c5384
movl $0x1, 0x80(%rsp)
jmp 0x1c54f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x1c550a
jmp 0x1c53af
movq 0x13bc3a(%rip), %rdi    # 0x300ff0
leaq 0x5b7ff(%rip), %rsi     # 0x220bbc
callq 0x13380
movq %rax, 0x48(%rsp)
jmp 0x1c53c9
movq 0x48(%rsp), %rdi
movq 0x58(%rsp), %rsi
addq $0x10, %rsi
callq 0x131a0
movq %rax, 0x40(%rsp)
jmp 0x1c53e3
movq 0x40(%rsp), %rdi
leaq 0x47a08(%rip), %rsi     # 0x20cdf7
callq 0x13380
movq %rax, 0x38(%rsp)
jmp 0x1c53fb
movq 0x38(%rsp), %rdi
movl 0x94(%rsp), %esi
callq 0x131d0
movq %rax, 0x30(%rsp)
jmp 0x1c5413
movq 0x30(%rsp), %rdi
leaq 0x5b7a5(%rip), %rsi     # 0x220bc4
callq 0x13380
movq %rax, 0x28(%rsp)
jmp 0x1c542b
movq 0x28(%rsp), %rdi
movl 0xcc(%rsp), %eax
shlq $0x5, %rax
leaq 0x13c69e(%rip), %rsi    # 0x301ae0
addq %rax, %rsi
callq 0x131a0
movq %rax, 0x20(%rsp)
jmp 0x1c5451
movq 0x20(%rsp), %rdi
leaq 0x5b783(%rip), %rsi     # 0x220be0
callq 0x13380
movq %rax, 0x18(%rsp)
jmp 0x1c5469
leaq 0x60(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1c3a10
jmp 0x1c547d
movq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x131a0
movq %rax, 0x10(%rsp)
jmp 0x1c5493
movq 0x10(%rsp), %rdi
leaq 0x5b749(%rip), %rsi     # 0x220be8
callq 0x13380
movq %rax, 0x8(%rsp)
jmp 0x1c54ab
movq 0x8(%rsp), %rdi
movq 0x13bb29(%rip), %rsi    # 0x300fe0
callq 0x135d0
jmp 0x1c54be
leaq 0x60(%rsp), %rdi
callq 0x52f50
jmp 0x1c54ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x52f50
jmp 0x1c550a
movl $0x0, 0x80(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x1c57d0
addq $0xd8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0x1c57d0
movq 0x88(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::GosASTError::UnexpectedToken(Gos::GosToken)
void GosASTError::UnexpectedToken(GosToken token) {
        gosASTHasError = true;
        if (!gosASTOffError) {
            std::cerr << "Error: " << gosASTFileName << ": " << token.line << ": unexpected token: \"" << token.ToString() << "\"" << std::endl;
        }/* else {
            std::cerr << "offerror: ";
            std::cerr << "Error: " << gosASTFileName << ": " << token.line << ": unexpected token: \"" << token.ToString() << "\"" << std::endl;
        }*/
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, 0x60(%rsp)
movb $0x1, 0x13b98b(%rip)    # 0x302260
cmpl $0x0, 0x13b988(%rip)    # 0x302264
jne 0x1c69b2
movq 0x13a707(%rip), %rdi    # 0x300ff0
leaq 0x5a2cc(%rip), %rsi     # 0x220bbc
callq 0x13380
movq %rax, %rdi
leaq 0x13b941(%rip), %rsi    # 0x302240
callq 0x131a0
movq %rax, %rdi
leaq 0x464e9(%rip), %rsi     # 0x20cdf7
callq 0x13380
movq %rax, %rdi
movq 0x28(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x131d0
movq %rax, %rdi
leaq 0x5a35d(%rip), %rsi     # 0x220c8a
callq 0x13380
movq 0x28(%rsp), %rsi
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1c3a10
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x131a0
movq %rax, 0x20(%rsp)
jmp 0x1c6961
movq 0x20(%rsp), %rdi
leaq 0x5a331(%rip), %rsi     # 0x220c9e
callq 0x13380
movq %rax, 0x8(%rsp)
jmp 0x1c6979
movq 0x8(%rsp), %rdi
movq 0x13a65b(%rip), %rsi    # 0x300fe0
callq 0x135d0
jmp 0x1c698c
leaq 0x40(%rsp), %rdi
callq 0x52f50
jmp 0x1c69b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x52f50
jmp 0x1c69b7
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::GosASTError::ErrorToken(Gos::GosToken, Gos::GosToken)
void GosASTError::ErrorToken(GosToken token, GosToken correct) {
        gosASTHasError = true;
        if (!gosASTOffError) {
            std::cerr << "Error: " << gosASTFileName << ": " << token.line << ": unexpected token \"" << token.ToString() << "\" instead of \"" << correct.ToString() << "\"" << std::endl;
        }/* else {
            std::cerr << "offerror: ";
            std::cerr << "Error: " << gosASTFileName << ": " << token.line << ": unexpected token \"" << token.ToString() << "\" instead of \"" << correct.ToString() << "\"" << std::endl;
        }*/
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movb $0x1, 0x13b868(%rip)    # 0x302260
cmpl $0x0, 0x13b865(%rip)    # 0x302264
jne 0x1c6b38
movq 0x13a5e4(%rip), %rdi    # 0x300ff0
leaq 0x5a1a9(%rip), %rsi     # 0x220bbc
callq 0x13380
movq %rax, %rdi
leaq 0x13b81e(%rip), %rsi    # 0x302240
callq 0x131a0
movq %rax, %rdi
leaq 0x463c6(%rip), %rsi     # 0x20cdf7
callq 0x13380
movq %rax, %rdi
movq 0x38(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x131d0
movq %rax, %rdi
leaq 0x5a250(%rip), %rsi     # 0x220ca0
callq 0x13380
movq 0x38(%rsp), %rsi
movq %rax, 0x20(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1c3a10
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x131a0
movq %rax, 0x30(%rsp)
jmp 0x1c6a84
movq 0x30(%rsp), %rdi
leaq 0x5a225(%rip), %rsi     # 0x220cb5
callq 0x13380
movq %rax, 0x18(%rsp)
jmp 0x1c6a9c
movq 0x40(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x1c3a10
jmp 0x1c6aad
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x131a0
movq %rax, 0x10(%rsp)
jmp 0x1c6ac3
movq 0x10(%rsp), %rdi
leaq 0x5a1cf(%rip), %rsi     # 0x220c9e
callq 0x13380
movq %rax, 0x8(%rsp)
jmp 0x1c6adb
movq 0x8(%rsp), %rdi
movq 0x13a4f9(%rip), %rsi    # 0x300fe0
callq 0x135d0
jmp 0x1c6aee
leaq 0x48(%rsp), %rdi
callq 0x52f50
leaq 0x78(%rsp), %rdi
callq 0x52f50
jmp 0x1c6b38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x1c6b2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x52f50
leaq 0x78(%rsp), %rdi
callq 0x52f50
jmp 0x1c6b40
addq $0xa8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x133f0
nopw (%rax,%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::GosAST::CompileAST(Gos::Compiler::VMCompiler&)
int Gos::GosAST::CompileAST(Compiler::VMCompiler& code) {
    code.SetProgramFileName(gosASTFileName);
    auto setMemsize = code.vm.WriteAlloc();
    for (auto* ast : nodes) {
        ast->CompileAST(code);
    }
    for (int i = 0; i < code.lambdaDefStartPos.size(); i++) {
        code.vm.WriteCommandJmp()(code.lambdaDefStartPos[i]);
        code.lambdaDefJumpout[i](code.vm.GetProgress());
    }
    setMemsize(code.pos);
    code.vm.WriteFinish();
    return 0;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rdi
leaq 0x13b6bd(%rip), %rsi    # 0x302240
callq 0x1d53a0
movq 0x98(%rsp), %rax
movq 0xe8(%rax), %rsi
leaq 0x78(%rsp), %rdi
callq 0x1b1ba0
movq 0x20(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1d1b70
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1d1ba0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x1d1bd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x1c6be4
jmp 0x1c6c2e
leaq 0x68(%rsp), %rdi
callq 0x1d1c10
movq (%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x1c6c0d
jmp 0x1c6c0f
leaq 0x68(%rsp), %rdi
callq 0x1d1c20
jmp 0x1c6bcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1c6d69
movl $0x0, 0x48(%rsp)
movslq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x98(%rsp), %rdi
addq $0x128, %rdi            # imm = 0x128
callq 0x1b5c30
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x1c6d25
movq 0x98(%rsp), %rax
movq 0xe8(%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1b1630
jmp 0x1c6c80
movq 0x98(%rsp), %rdi
addq $0x128, %rdi            # imm = 0x128
movslq 0x48(%rsp), %rsi
callq 0x1b5c70
movl (%rax), %esi
leaq 0x28(%rsp), %rdi
callq 0x1d1c40
jmp 0x1c6ca7
leaq 0x28(%rsp), %rdi
callq 0x1d1c80
movq 0x98(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
movslq 0x48(%rsp), %rsi
callq 0x1d1c90
movq %rax, 0x8(%rsp)
movq 0x98(%rsp), %rax
movq 0xe8(%rax), %rdi
callq 0x1b1b80
movl %eax, 0x14(%rsp)
jmp 0x1c6ce9
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdi
callq 0x1d1c40
jmp 0x1c6cf9
jmp 0x1c6cfb
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x1c6c36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1d1c80
jmp 0x1c6d69
movq 0x98(%rsp), %rax
movl 0xe0(%rax), %esi
leaq 0x78(%rsp), %rdi
callq 0x1d1c40
jmp 0x1c6d3f
movq 0x98(%rsp), %rax
movq 0xe8(%rax), %rdi
callq 0x1b1b50
jmp 0x1c6d55
leaq 0x78(%rsp), %rdi
callq 0x1d1c80
xorl %eax, %eax
addq $0xa8, %rsp
retq
leaq 0x78(%rsp), %rdi
callq 0x1d1c80
movq 0x50(%rsp), %rdi
callq 0x133f0
nopl (%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::GosAST::Build(Gos::GosTokenizer&)
void Gos::GosAST::Build(Gos::GosTokenizer& tokenizer) {
    gosASTOffError = 0;
    gosASTHasError = false;
    while (!tokenizer.IsEOF() && !gosASTHasError) {
        nodes.push_back(new AST::Preprocess(tokenizer));
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x13b4c2(%rip)    # 0x302264
movb $0x0, 0x13b4b7(%rip)    # 0x302260
movq 0x38(%rsp), %rdi
callq 0x1c5580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x1c6dcc
movb 0x13b49a(%rip), %al     # 0x302260
xorb $-0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x1c6dd6
jmp 0x1c6e3d
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movl $0x60, %edi
callq 0x13110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0x1cc310
jmp 0x1c6e04
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c6da9
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x60, %esi
callq 0x130c0
jmp 0x1c6e42
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x133f0
nopl (%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::GosAST::PrintAST(int)
void Gos::GosAST::PrintAST(int indent) {
    for (int i = 0; i < indent; i++) {
        std::cout << "  ";
    }
    for (auto* ast : nodes) {
        ast->PrintAST(indent);
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x1c6e98
movq 0x13a141(%rip), %rdi    # 0x300fc0
leaq 0x59e3e(%rip), %rsi     # 0x220cc4
callq 0x13380
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x1c6e6e
movq (%rsp), %rax
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 0x1c6eda
jmp 0x1c6f07
leaq 0x18(%rsp), %rdi
callq 0x1d1c10
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
callq 0x1d1c20
jmp 0x1c6ec3
addq $0x38, %rsp
retq
nopl (%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Unary::Unary(Gos::GosTokenizer&)
Build(Unary) {
        Log(Unary);
        token = tokenizer.GetToken();
        if (token.type == ADD || token.type == SUB || token.type == NOT || token.type == MUL || token.type == ADDR) {
            branch = 1;
            Expect(Unary);
        } else {
            tokenizer.BackToken();
            Expect(PostFix);
        }
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x1d1d40
movq 0x30(%rsp), %rax
leaq 0x13840f(%rip), %rcx    # 0x300218
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
testb $0x1, 0x13a442(%rip)    # 0x302260
je 0x1c7e25
jmp 0x1c7f87
movq 0x58(%rsp), %rdi
callq 0x1c5260
movq %rax, 0x28(%rsp)
jmp 0x1c7e36
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c7e4b
movq 0x30(%rsp), %rax
cmpl $0x1a, 0x28(%rax)
je 0x1c7e86
movq 0x30(%rsp), %rax
cmpl $0x1b, 0x28(%rax)
je 0x1c7e86
movq 0x30(%rsp), %rax
cmpl $0x27, 0x28(%rax)
je 0x1c7e86
movq 0x30(%rsp), %rax
cmpl $0x1c, 0x28(%rax)
je 0x1c7e86
movq 0x30(%rsp), %rax
cmpl $0x1d, 0x28(%rax)
jne 0x1c7f0f
movq 0x30(%rsp), %rax
movl $0x1, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movl $0x60, %edi
callq 0x13110
movq %rax, 0x20(%rsp)
jmp 0x1c7eac
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x1c7de0
jmp 0x1c7ebd
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c7ed8
jmp 0x1c7f87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1c7f8c
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movl $0x60, %esi
callq 0x130c0
jmp 0x1c7f8c
movq 0x58(%rsp), %rdi
callq 0x1c5530
jmp 0x1c7f1b
movq 0x30(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movl $0x60, %edi
callq 0x13110
movq %rax, 0x10(%rsp)
jmp 0x1c7f3a
movq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x1c77f0
jmp 0x1c7f4b
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c7f66
jmp 0x1c7f87
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movl $0x60, %esi
callq 0x130c0
jmp 0x1c7f8c
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x1c6f10
movq 0x50(%rsp), %rdi
callq 0x133f0
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Cast::Cast(Gos::GosTokenizer&)
Build(Cast) {
        Log(Cast);
        Expect(Unary);
        token = tokenizer.GetToken();
        if (token.type == AS) {
            Expect(Symbol);
        } else {
            tokenizer.BackToken();
        }
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x1d1d40
movq 0x30(%rsp), %rax
leaq 0x138297(%rip), %rcx    # 0x300260
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
testb $0x1, 0x13a282(%rip)    # 0x302260
je 0x1c7fe5
jmp 0x1c810e
movq 0x30(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movl $0x60, %edi
callq 0x13110
movq %rax, 0x28(%rsp)
jmp 0x1c8004
movq 0x28(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x1c7de0
jmp 0x1c8015
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c8030
movq 0x58(%rsp), %rdi
callq 0x1c5260
movq %rax, 0x18(%rsp)
jmp 0x1c8041
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c8056
movq 0x30(%rsp), %rax
cmpl $0xe, 0x28(%rax)
jne 0x1c8100
movq 0x30(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movl $0x60, %edi
callq 0x13110
movq %rax, 0x10(%rsp)
jmp 0x1c8084
movq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x1c7030
jmp 0x1c8095
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c80b0
jmp 0x1c810e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1c8113
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x60, %esi
callq 0x130c0
jmp 0x1c8113
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x60, %esi
callq 0x130c0
jmp 0x1c8113
movq 0x58(%rsp), %rdi
callq 0x1c5530
jmp 0x1c810c
jmp 0x1c810e
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x1c6f10
movq 0x48(%rsp), %rdi
callq 0x133f0
nopw (%rax,%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Mul::Mul(Gos::GosTokenizer&)
Build(Mul) {
        Log(Mul);
        Expect(Cast);
        token = tokenizer.GetToken();
        while (token.type == MUL || token.type == DIV || token.type == REM) {
            Expect(Cast);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x1d1d40
movq 0x40(%rsp), %rdi
leaq 0x13814f(%rip), %rax    # 0x3002a8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x60, %rdi
movq %rdi, 0x38(%rsp)
callq 0x1c5730
movq 0x40(%rsp), %rax
movl $0x0, 0x8(%rax)
testb $0x1, 0x13a0df(%rip)    # 0x302260
je 0x1c8188
jmp 0x1c831f
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movl $0x60, %edi
callq 0x13110
movq %rax, 0x30(%rsp)
jmp 0x1c81a7
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c7fa0
jmp 0x1c81b8
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c81d3
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, 0x20(%rsp)
jmp 0x1c81e4
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c81f9
jmp 0x1c81fb
movq 0x40(%rsp), %rcx
movb $0x1, %al
cmpl $0x1c, 0x28(%rcx)
movb %al, 0x1f(%rsp)
je 0x1c822d
movq 0x40(%rsp), %rcx
movb $0x1, %al
cmpl $0x1e, 0x28(%rcx)
movb %al, 0x1f(%rsp)
je 0x1c822d
movq 0x40(%rsp), %rax
cmpl $0x1f, 0x28(%rax)
sete %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x1c823a
jmp 0x1c8313
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movl $0x60, %edi
callq 0x13110
movq %rax, 0x10(%rsp)
jmp 0x1c8259
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c7fa0
jmp 0x1c826a
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c8285
movq 0x40(%rsp), %rsi
movq %rsi, %rdi
addq $0x60, %rdi
addq $0x28, %rsi
callq 0x1c57f0
jmp 0x1c829c
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, (%rsp)
jmp 0x1c82ac
movq (%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c82c0
jmp 0x1c81fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1c8324
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x60, %esi
callq 0x130c0
jmp 0x1c8324
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x60, %esi
callq 0x130c0
jmp 0x1c8324
movq 0x68(%rsp), %rdi
callq 0x1c5530
jmp 0x1c831f
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x1c5870
movq 0x40(%rsp), %rdi
callq 0x1c6f10
movq 0x58(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Add::Add(Gos::GosTokenizer&)
Build(Add) {
        Log(Add);
        Expect(Mul);
        token = tokenizer.GetToken();
        while (token.type == ADD || token.type == SUB) {
            Expect(Mul);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x1d1d40
movq 0x40(%rsp), %rdi
leaq 0x137f77(%rip), %rax    # 0x3002f0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x60, %rdi
movq %rdi, 0x38(%rsp)
callq 0x1c5730
movq 0x40(%rsp), %rax
movl $0x0, 0x8(%rax)
testb $0x1, 0x139ebf(%rip)    # 0x302260
je 0x1c83a8
jmp 0x1c852e
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movl $0x78, %edi
callq 0x13110
movq %rax, 0x30(%rsp)
jmp 0x1c83c7
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c8130
jmp 0x1c83d8
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c83f3
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, 0x20(%rsp)
jmp 0x1c8404
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c8419
jmp 0x1c841b
movq 0x40(%rsp), %rcx
movb $0x1, %al
cmpl $0x1a, 0x28(%rcx)
movb %al, 0x1f(%rsp)
je 0x1c843c
movq 0x40(%rsp), %rax
cmpl $0x1b, 0x28(%rax)
sete %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x1c8449
jmp 0x1c8522
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movl $0x78, %edi
callq 0x13110
movq %rax, 0x10(%rsp)
jmp 0x1c8468
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c8130
jmp 0x1c8479
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c8494
movq 0x40(%rsp), %rsi
movq %rsi, %rdi
addq $0x60, %rdi
addq $0x28, %rsi
callq 0x1c57f0
jmp 0x1c84ab
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, (%rsp)
jmp 0x1c84bb
movq (%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c84cf
jmp 0x1c841b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1c8533
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x78, %esi
callq 0x130c0
jmp 0x1c8533
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x78, %esi
callq 0x130c0
jmp 0x1c8533
movq 0x68(%rsp), %rdi
callq 0x1c5530
jmp 0x1c852e
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x1c5870
movq 0x40(%rsp), %rdi
callq 0x1c6f10
movq 0x58(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Relation::Relation(Gos::GosTokenizer&)
Build(Relation) {
        Log(Relation);
        Expect(Add);
        token = tokenizer.GetToken();
        while (token.type == L || token.type == LE || token.type == G || token.type == GE) {
            Expect(Add);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x1d1d40
movq 0x40(%rsp), %rdi
leaq 0x137daf(%rip), %rax    # 0x300338
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x60, %rdi
movq %rdi, 0x38(%rsp)
callq 0x1c5730
movq 0x40(%rsp), %rax
movl $0x0, 0x8(%rax)
testb $0x1, 0x139caf(%rip)    # 0x302260
je 0x1c85b8
jmp 0x1c8760
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movl $0x78, %edi
callq 0x13110
movq %rax, 0x30(%rsp)
jmp 0x1c85d7
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c8350
jmp 0x1c85e8
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c8603
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, 0x20(%rsp)
jmp 0x1c8614
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c8629
jmp 0x1c862b
movq 0x40(%rsp), %rcx
movb $0x1, %al
cmpl $0x23, 0x28(%rcx)
movb %al, 0x1f(%rsp)
je 0x1c866e
movq 0x40(%rsp), %rcx
movb $0x1, %al
cmpl $0x25, 0x28(%rcx)
movb %al, 0x1f(%rsp)
je 0x1c866e
movq 0x40(%rsp), %rcx
movb $0x1, %al
cmpl $0x24, 0x28(%rcx)
movb %al, 0x1f(%rsp)
je 0x1c866e
movq 0x40(%rsp), %rax
cmpl $0x26, 0x28(%rax)
sete %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x1c867b
jmp 0x1c8754
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movl $0x78, %edi
callq 0x13110
movq %rax, 0x10(%rsp)
jmp 0x1c869a
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c8350
jmp 0x1c86ab
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c86c6
movq 0x40(%rsp), %rsi
movq %rsi, %rdi
addq $0x60, %rdi
addq $0x28, %rsi
callq 0x1c57f0
jmp 0x1c86dd
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, (%rsp)
jmp 0x1c86ed
movq (%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c8701
jmp 0x1c862b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1c8765
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x78, %esi
callq 0x130c0
jmp 0x1c8765
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x78, %esi
callq 0x130c0
jmp 0x1c8765
movq 0x68(%rsp), %rdi
callq 0x1c5530
jmp 0x1c8760
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x1c5870
movq 0x40(%rsp), %rdi
callq 0x1c6f10
movq 0x58(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Equality::Equality(Gos::GosTokenizer&)
Build(Equality) {
        Log(Equality);
        Expect(Relation);
        token = tokenizer.GetToken();
        while (token.type == E || token.type == NE) {
            Expect(Relation);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x1d1d40
movq 0x40(%rsp), %rdi
leaq 0x137bc7(%rip), %rax    # 0x300380
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x60, %rdi
movq %rdi, 0x38(%rsp)
callq 0x1c5730
movq 0x40(%rsp), %rax
movl $0x0, 0x8(%rax)
testb $0x1, 0x139a7f(%rip)    # 0x302260
je 0x1c87e8
jmp 0x1c896e
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movl $0x78, %edi
callq 0x13110
movq %rax, 0x30(%rsp)
jmp 0x1c8807
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c8560
jmp 0x1c8818
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c8833
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, 0x20(%rsp)
jmp 0x1c8844
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c8859
jmp 0x1c885b
movq 0x40(%rsp), %rcx
movb $0x1, %al
cmpl $0x21, 0x28(%rcx)
movb %al, 0x1f(%rsp)
je 0x1c887c
movq 0x40(%rsp), %rax
cmpl $0x22, 0x28(%rax)
sete %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x1c8889
jmp 0x1c8962
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movl $0x78, %edi
callq 0x13110
movq %rax, 0x10(%rsp)
jmp 0x1c88a8
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c8560
jmp 0x1c88b9
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c88d4
movq 0x40(%rsp), %rsi
movq %rsi, %rdi
addq $0x60, %rdi
addq $0x28, %rsi
callq 0x1c57f0
jmp 0x1c88eb
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, (%rsp)
jmp 0x1c88fb
movq (%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c890f
jmp 0x1c885b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1c8973
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x78, %esi
callq 0x130c0
jmp 0x1c8973
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x78, %esi
callq 0x130c0
jmp 0x1c8973
movq 0x68(%rsp), %rdi
callq 0x1c5530
jmp 0x1c896e
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x1c5870
movq 0x40(%rsp), %rdi
callq 0x1c6f10
movq 0x58(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::LogicAnd::LogicAnd(Gos::GosTokenizer&)
Build(LogicAnd) {
        Log(LogicAnd);
        Expect(Equality);
        token = tokenizer.GetToken();
        while (token.type == AND) {
            Expect(Equality);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x1d1d40
movq 0x40(%rsp), %rdi
leaq 0x1379ff(%rip), %rax    # 0x3003c8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x60, %rdi
movq %rdi, 0x38(%rsp)
callq 0x1c5730
movq 0x40(%rsp), %rax
movl $0x0, 0x8(%rax)
testb $0x1, 0x13986f(%rip)    # 0x302260
je 0x1c89f8
jmp 0x1c8b61
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movl $0x78, %edi
callq 0x13110
movq %rax, 0x30(%rsp)
jmp 0x1c8a17
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c8790
jmp 0x1c8a28
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c8a43
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, 0x20(%rsp)
jmp 0x1c8a54
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c8a69
jmp 0x1c8a6b
movq 0x40(%rsp), %rax
cmpl $0x28, 0x28(%rax)
jne 0x1c8b55
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movl $0x78, %edi
callq 0x13110
movq %rax, 0x18(%rsp)
jmp 0x1c8a99
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c8790
jmp 0x1c8aaa
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c8ac5
movq 0x40(%rsp), %rsi
movq %rsi, %rdi
addq $0x60, %rdi
addq $0x28, %rsi
callq 0x1c57f0
jmp 0x1c8adc
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, 0x8(%rsp)
jmp 0x1c8aed
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c8b02
jmp 0x1c8a6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1c8b66
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x78, %esi
callq 0x130c0
jmp 0x1c8b66
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x78, %esi
callq 0x130c0
jmp 0x1c8b66
movq 0x68(%rsp), %rdi
callq 0x1c5530
jmp 0x1c8b61
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x1c5870
movq 0x40(%rsp), %rdi
callq 0x1c6f10
movq 0x58(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)
// File: Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::LogicOr::LogicOr(Gos::GosTokenizer&)
Build(LogicOr) {
        Log(LogicOr);
        Expect(LogicAnd);
        token = tokenizer.GetToken();
        while (token.type == OR) {
            Expect(LogicAnd);
            tokenList.push_back(token);
            token = tokenizer.GetToken();
        }
        tokenizer.BackToken();
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x1d1d40
movq 0x40(%rsp), %rdi
leaq 0x137857(%rip), %rax    # 0x300410
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x60, %rdi
movq %rdi, 0x38(%rsp)
callq 0x1c5730
movq 0x40(%rsp), %rax
movl $0x0, 0x8(%rax)
testb $0x1, 0x13967f(%rip)    # 0x302260
je 0x1c8be8
jmp 0x1c8d51
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x28(%rsp)
movl $0x78, %edi
callq 0x13110
movq %rax, 0x30(%rsp)
jmp 0x1c8c07
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c89a0
jmp 0x1c8c18
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c8c33
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, 0x20(%rsp)
jmp 0x1c8c44
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c8c59
jmp 0x1c8c5b
movq 0x40(%rsp), %rax
cmpl $0x29, 0x28(%rax)
jne 0x1c8d45
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movl $0x78, %edi
callq 0x13110
movq %rax, 0x18(%rsp)
jmp 0x1c8c89
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x1c89a0
jmp 0x1c8c9a
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x1d1cb0
jmp 0x1c8cb5
movq 0x40(%rsp), %rsi
movq %rsi, %rdi
addq $0x60, %rdi
addq $0x28, %rsi
callq 0x1c57f0
jmp 0x1c8ccc
movq 0x68(%rsp), %rdi
callq 0x1c5260
movq %rax, 0x8(%rsp)
jmp 0x1c8cdd
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x1d1da0
jmp 0x1c8cf2
jmp 0x1c8c5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1c8d56
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x78, %esi
callq 0x130c0
jmp 0x1c8d56
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x78, %esi
callq 0x130c0
jmp 0x1c8d56
movq 0x68(%rsp), %rdi
callq 0x1c5530
jmp 0x1c8d51
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x1c5870
movq 0x40(%rsp), %rdi
callq 0x1c6f10
movq 0x58(%rsp), %rdi
callq 0x133f0
nopw %cs:(%rax,%rax)