LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::IRTokenizer::GetToken[abi:cxx11]()
std::string GosVM::IRTokenizer::GetToken() {
    std::string ret = "";
    char ch;
    bool in_string = false;
    bool is_string = false;
    while ((ch = input.get()) != EOF) {
        if (ch == '\"') {
            if (!in_string) {
                in_string = true;
                is_string = true;
            } else {
                ret += "\"";
                break;
            }
        }
        if (ch == ' ' || ch == '\n' || ch == '\r') {
            if (!in_string) {
                break;
            }
        }
        ret += ch;
    }
    last = ch;
    if (is_string) {
        return ret.substr(1, ret.size() - 2);
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x33ce1(%rip), %rsi     # 0xa97b6
leaq 0x18(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x664f4
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rdi
callq 0x113e0
movl %eax, %ebp
cmpb $0xa, %bpl
je 0x75b1a
movzbl %bpl, %eax
cmpl $0xd, %eax
je 0x75b1a
cmpl $0x20, %eax
je 0x75b1a
cmpl $0x22, %eax
je 0x75b34
cmpl $0xff, %eax
jne 0x75b20
jmp 0x75b50
testb $0x1, %r12b
je 0x75b50
movl %r13d, %ebx
movsbl %bpl, %esi
movq %r15, %rdi
callq 0x537e8
movl %ebx, %r13d
jmp 0x75aed
movb $0x1, %bl
testb $0x1, %r12b
movb $0x1, %r12b
je 0x75b23
leaq 0x33c48(%rip), %rsi     # 0xa978e
leaq 0x18(%rsp), %rdi
callq 0x21c04
movb %bpl, (%r14)
testb $0x1, %r13b
movq 0x10(%rsp), %rdi
je 0x75b75
leaq 0x18(%rsp), %rsi
movq 0x8(%rsi), %rcx
addq $-0x2, %rcx
pushq $0x1
popq %rdx
callq 0x79922
jmp 0x75bb7
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x75b98
movq %rdx, (%rdi)
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rdi)
jmp 0x75b9e
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x209be
movq 0x10(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x75bd7
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMFunction::Execute(ObjectPtr, std::vector<ObjectPtr, std::allocator<ObjectPtr>> const&)
SharedObject GosVM::VMFunction::Execute(ObjectPtr instance, const std::vector<ObjectPtr>& params) {
    RTMemory funcMem;
    RTMemory* backup = mem;
    mem = &funcMem;
    auto ret = VMExecutable::Execute(instance, params);
    mem = backup;
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq 0x28(%rsi), %r12
movq %rax, 0x28(%rsi)
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x16fc8
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x75eaa
movq %r12, 0x28(%r14)
movq %rsp, %rdi
callq 0x21312
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21312
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::RTMemory::NewVar(int, SharedObject)
void GosVM::RTMemory::NewVar(int id, SharedObject obj) {
    if (id < mem.size()) {
        mem[id] = obj;
    } else {
        while (mem.size() < id) {
            mem.push_back(SharedObject::Null);
        }
        mem.push_back(obj);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movslq %esi, %r12
movq (%rdi), %rdi
movq 0x8(%r14), %rcx
movq %rcx, %rax
subq %rdi, %rax
pushq $0x38
popq %r13
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x78789
imulq $0x38, %r12, %rax
addq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x208e6
leaq 0x8dbe8(%rip), %r15     # 0x106378
subq %rdi, %rcx
movq %rcx, %rax
cqto
idivq %r13
cmpq %r12, %rax
jae 0x787b4
movq %r14, %rdi
movq %r15, %rsi
callq 0x79960
movq (%r14), %rdi
movq 0x8(%r14), %rcx
jmp 0x78790
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x79960
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMProgram::WriteCommandDefClass(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::WriteCommandDefClass(const std::string& className, const std::vector<std::string>& inherits) {
    AddOperation(DEF_CLASS);
    AddParamString(className);
    AddParamInt(inherits.size());
    for (int i = 0; i < inherits.size(); i++) {
        AddParamString(inherits[i]);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
addq $0x20, %rdi
pushq $0x1
popq %rsi
callq 0x537e8
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2b71e
movq %r14, %rdi
movq %r15, %rsi
callq 0x75d30
movq %rsp, %rdi
callq 0x209be
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
shrq $0x5, %rsi
movq %r14, %rdi
callq 0x75cae
xorl %r12d, %r12d
leaq 0x20(%rsp), %r15
xorl %r13d, %r13d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x78863
addq %r12, %rsi
movq %r15, %rdi
callq 0x2b71e
movq %r14, %rdi
movq %r15, %rsi
callq 0x75d30
movq %r15, %rdi
callq 0x209be
incq %r13
addq $0x20, %r12
jmp 0x78829
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x78873
movq %rax, %rbx
movq %r15, %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMProgram::WriteCommandDefFunc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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&)
std::function<void(int)> GosVM::VMProgram::WriteCommandDefFunc(const std::string& name, const std::string& retType, const std::vector<std::string>& paramTypes) {
    AddOperation(DEF_MEMBER_FUNC);
    AddParamString(name);
    AddParamString(retType);
    int len = paramTypes.size();
    AddParamInt(len);
    for (int i = 0; i < len; i++) {
        AddParamString(paramTypes[i]);
    }
    int pos = content.size();
    AddParamInt(0);
    int startJump = content.size();
    return [this, pos, startJump](int jmp) {
        *(int*)&content[pos] = jmp - startJump;
    };
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %rdi
pushq $0x4
popq %rsi
callq 0x537e8
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x2b71e
movq %r14, %rdi
movq %r12, %rsi
callq 0x75d30
leaq 0x28(%rsp), %rdi
callq 0x209be
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x2b71e
movq %r14, %rdi
movq %r12, %rsi
callq 0x75d30
leaq 0x8(%rsp), %rdi
callq 0x209be
movq 0x8(%r15), %r13
subq (%r15), %r13
shrq $0x5, %r13
movq %r14, %rdi
movl %r13d, %esi
callq 0x75cae
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
shlq $0x5, %r13
leaq 0x48(%rsp), %r12
cmpq %rbp, %r13
je 0x789d9
movq (%r15), %rsi
addq %rbp, %rsi
movq %r12, %rdi
callq 0x2b71e
movq %r14, %rdi
movq %r12, %rsi
callq 0x75d30
movq %r12, %rdi
callq 0x209be
addq $0x20, %rbp
jmp 0x789ad
movl 0x28(%r14), %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x75cae
movl 0x28(%r14), %eax
movq %r14, (%rbx)
movl %ebp, 0x8(%rbx)
movl %eax, 0xc(%rbx)
leaq 0xd95(%rip), %rax       # 0x79790
movq %rax, 0x18(%rbx)
leaq 0xd9e(%rip), %rax       # 0x797a4
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x78a20
jmp 0x78a20
movq %rax, %rbx
movq %r12, %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
addq $0x20, %rdi
pushq $0xb
popq %rsi
callq 0x537e8
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2b71e
movq %r14, %rdi
movq %r12, %rsi
callq 0x75d30
movq %rsp, %rdi
callq 0x209be
movq %r14, %rdi
movl %ebp, %esi
callq 0x75cae
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
shrq $0x2, %rsi
movq %r14, %rdi
callq 0x75cae
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x78cc4
movl (%rax,%r15,4), %esi
movq %r14, %rdi
callq 0x75cae
incq %r15
jmp 0x78ca0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x20(%rdi), %r12
pushq $0xd
popq %rsi
movq %r12, %rdi
callq 0x537e8
movq %r12, %rdi
movl %r14d, %esi
callq 0x537e8
movq %r15, %rdi
movl %ebp, %esi
callq 0x75cae
movq 0x60(%r15), %rdi
movq %rbx, %rsi
callq 0x759a0
movq %r15, %rdi
movl %eax, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x75cae
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
addq $0x20, %rdi
pushq $0x12
popq %rsi
callq 0x537e8
movq %r15, %rdi
movl %r14d, %esi
callq 0x75cae
movq %r15, %rdi
movl %ebp, %esi
callq 0x75cae
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b71e
movq %r15, %rdi
movq %r14, %rsi
callq 0x75d30
leaq 0x8(%rsp), %rdi
callq 0x209be
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsi), %rdi
pushq $0x1d
popq %rsi
callq 0x537e8
movl 0x28(%rbx), %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x75cae
movl 0x28(%rbx), %eax
movq %rbx, (%r14)
movl %ebp, 0x8(%r14)
movl %eax, 0xc(%r14)
leaq 0x720(%rip), %rax       # 0x79808
movq %rax, 0x18(%r14)
leaq 0x729(%rip), %rax       # 0x7981c
movq %rax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsi), %rdi
pushq $0x1e
popq %rsi
callq 0x537e8
movq %r14, %rdi
movl %ebx, %esi
callq 0x75cae
movl 0x28(%r14), %ebx
movq %r14, %rdi
xorl %esi, %esi
callq 0x75cae
movl 0x28(%r14), %eax
movq %r14, (%r15)
movl %ebx, 0x8(%r15)
movl %eax, 0xc(%r15)
leaq 0x6fd(%rip), %rax       # 0x79844
movq %rax, 0x18(%r15)
leaq 0x706(%rip), %rax       # 0x79858
movq %rax, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
addq $0x20, %rdi
pushq $0x21
popq %rsi
callq 0x537e8
movq %r14, %rdi
movl %ebp, %esi
callq 0x75cae
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2b71e
movq %r14, %rdi
movq %r12, %rsi
callq 0x75d30
movq %rsp, %rdi
callq 0x209be
movq 0x8(%rbx), %r15
subq (%rbx), %r15
shrq $0x2, %r15
movq %r14, %rdi
movl %r15d, %esi
callq 0x75cae
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0x79247
movq (%rbx), %rax
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x75cae
incq %r12
jmp 0x7922e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
addq $0x20, %rdi
pushq $0x2
popq %rsi
callq 0x537e8
movq %rsp, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2b71e
movq %r14, %rdi
movq %r15, %rsi
callq 0x75d30
movq %rsp, %rdi
callq 0x209be
movq 0x8(%rbx), %r12
subq (%rbx), %r12
shrq $0x5, %r12
movq %r14, %rdi
movl %r12d, %esi
callq 0x75cae
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
shlq $0x5, %r12
leaq 0x20(%rsp), %r15
cmpq %r13, %r12
je 0x79300
movq (%rbx), %rsi
addq %r13, %rsi
movq %r15, %rdi
callq 0x2b71e
movq %r14, %rdi
movq %r15, %rsi
callq 0x75d30
movq %r15, %rdi
callq 0x209be
addq $0x20, %r13
jmp 0x792d4
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x79310
movq %rax, %rbx
movq %r15, %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsi), %rdi
pushq $0x7
popq %rsi
callq 0x537e8
movl 0x28(%rbx), %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x75cae
andq $0x0, 0x8(%r14)
movq %rbx, (%r14)
movl %ebp, 0x8(%r14)
leaq 0x518(%rip), %rax       # 0x79880
movq %rax, 0x18(%r14)
leaq 0x51f(%rip), %rax       # 0x79892
movq %rax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x11320
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x111f0
movl 0x4(%rsp), %ebx
leaq 0x8(%rsp), %rdi
callq 0x112c0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
jmp 0x7b402
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x112c0
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0x2c, %rax
je 0x7d5eb
cmpl $0x2b, %eax
je 0x7d59d
cmpl $0x2a, %eax
jne 0x7d61f
addq $0x18, %r14
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x7d630
movq %rsp, %rdi
callq 0x11270
leaq 0x10(%rsp), %r15
movsbq 0x8(%r14), %rax
leaq 0x2c02a(%rip), %rcx     # 0xa95e0
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %r15, %rdi
callq 0x11340
leaq 0x2c1e9(%rip), %rsi     # 0xa97b5
movq %rax, %rdi
callq 0x11340
movzbl 0x8(%r14), %eax
cmpb $0x2, %al
jg 0x7d637
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x11330
jmp 0x7d65f
addq $0x18, %r14
leaq 0x2c198(%rip), %r15     # 0xa978e
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x7e29e
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x20985
movq %rsp, %rdi
callq 0x209be
jmp 0x7d674
shlq $0x5, %rax
leaq 0x89436(%rip), %rsi     # 0x106a60
addq %rax, %rsi
movq %rbx, %rdi
callq 0x2b71e
jmp 0x7d674
cmpl $0x4, %eax
je 0x7d651
cmpl $0x3, %eax
jne 0x7d65f
movss 0x10(%r14), %xmm0
movq %r15, %rdi
callq 0x112b0
jmp 0x7d65f
movsd 0x10(%r14), %xmm0
movq %r15, %rdi
callq 0x114f0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x112a0
movq %rsp, %rdi
callq 0x112c0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x209be
jmp 0x7d69e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x112c0
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x7e0e8
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x7e3de
cmpl %ebx, (%r15)
je 0x7e221
cmpq $0x0, 0x60(%r14)
je 0x7e16e
leaq 0x50(%r14), %rdi
callq 0x7e3fa
testb %al, %al
je 0x7e221
movq 0x87e7b(%rip), %rdi     # 0x105ff0
leaq 0x2b51d(%rip), %rsi     # 0xa9699
callq 0x11340
addq $0x10, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x11320
leaq 0x19300(%rip), %rsi     # 0x97497
movq %rax, %rdi
callq 0x11340
movl 0x2c(%rsp), %esi
movq %rax, %rdi
callq 0x11540
leaq 0x2b4ef(%rip), %rsi     # 0xa96a1
movq %rax, %rdi
callq 0x11340
movl %ebx, %ecx
shlq $0x5, %rcx
leaq 0x88899(%rip), %rsi     # 0x106a60
addq %rcx, %rsi
movq %rax, %rdi
callq 0x11320
leaq 0x2b4e4(%rip), %rsi     # 0xa96bd
movq %rax, %rdi
callq 0x11340
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7d564
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11320
leaq 0x2b4be(%rip), %rsi     # 0xa96c5
movq %rax, %rdi
callq 0x11340
movq %rax, %rdi
callq 0x111b0
leaq 0x8(%rsp), %rdi
callq 0x209be
leaq 0x40(%rsp), %rdi
callq 0x209be
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7e246
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x209be
jmp 0x7e249
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movb $0x1, 0x88a4c(%rip)     # 0x1071e0
cmpl $0x0, 0x88a49(%rip)     # 0x1071e4
jne 0x7e82a
movq %rdi, %rbx
movq 0x87845(%rip), %rdi     # 0x105ff0
leaq 0x2aee7(%rip), %rsi     # 0xa9699
callq 0x11340
leaq 0x88a02(%rip), %rsi     # 0x1071c0
movq %rax, %rdi
callq 0x11320
leaq 0x18cca(%rip), %rsi     # 0x97497
movq %rax, %rdi
callq 0x11340
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x11540
leaq 0x2af93(%rip), %rsi     # 0xa977a
movq %rax, %rdi
callq 0x11340
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7d564
movq %r14, %rdi
movq %r15, %rsi
callq 0x11320
leaq 0x2af7c(%rip), %rsi     # 0xa978e
movq %rax, %rdi
callq 0x11340
movq %rax, %rdi
callq 0x111b0
movq %rsp, %rdi
callq 0x209be
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movb $0x1, 0x88986(%rip)     # 0x1071e0
cmpl $0x0, 0x88983(%rip)     # 0x1071e4
jne 0x7e92e
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8777c(%rip), %rdi     # 0x105ff0
leaq 0x2ae1e(%rip), %rsi     # 0xa9699
callq 0x11340
leaq 0x88939(%rip), %rsi     # 0x1071c0
movq %rax, %rdi
callq 0x11320
leaq 0x18c01(%rip), %rsi     # 0x97497
movq %rax, %rdi
callq 0x11340
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x11540
leaq 0x2aedf(%rip), %rsi     # 0xa9790
movq %rax, %rdi
callq 0x11340
movq %rax, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7d564
movq %r15, %rdi
movq %r12, %rsi
callq 0x11320
leaq 0x2aec7(%rip), %rsi     # 0xa97a5
movq %rax, %rdi
callq 0x11340
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x7d564
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x11320
leaq 0x2ae84(%rip), %rsi     # 0xa978e
movq %rax, %rdi
callq 0x11340
movq %rax, %rdi
callq 0x111b0
leaq 0x8(%rsp), %rdi
callq 0x209be
leaq 0x28(%rsp), %rdi
callq 0x209be
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7e93c
movq %rax, %rbx
jmp 0x7e94e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x209be
leaq 0x28(%rsp), %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x88846(%rip), %rsi     # 0x1071c0
movq %rbx, %rdi
callq 0x85088
movq 0xe8(%rbx), %rsi
movq %rsp, %rdi
callq 0x79332
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0x7e9af
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r15
jmp 0x7e999
xorl %r12d, %r12d
leaq 0x20(%rsp), %r14
xorl %r13d, %r13d
movq 0x130(%rbx), %rax
subq 0x128(%rbx), %rax
sarq $0x2, %rax
cmpq %r13, %rax
jbe 0x7ea24
movq 0xe8(%rbx), %rsi
movq %r14, %rdi
callq 0x790b0
movq 0x128(%rbx), %rax
movl (%rax,%r13,4), %esi
movq %r14, %rdi
callq 0x83e66
movq %r14, %rdi
callq 0x21f04
movq 0xe8(%rbx), %rdi
movq 0x140(%rbx), %r15
callq 0x7932e
addq %r12, %r15
movq %r15, %rdi
movl %eax, %esi
callq 0x83e66
incq %r13
addq $0x20, %r12
jmp 0x7e9ba
movl 0xe0(%rbx), %esi
movq %rsp, %rdi
callq 0x83e66
movq 0xe8(%rbx), %rdi
callq 0x79324
movq %rsp, %rdi
callq 0x21f04
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7ea6b
jmp 0x7ea6b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x21f04
jmp 0x7ea6e
jmp 0x7ea6b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21f04
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
andl $0x0, 0x8874c(%rip)     # 0x1071e4
movb $0x0, 0x88741(%rip)     # 0x1071e0
addq $0x10, %r14
pushq $0x60
popq %r15
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
callq 0x7e268
testb %al, %al
jne 0x7eae9
testb $0x1, 0x88721(%rip)     # 0x1071e0
jne 0x7eae9
movq %r15, %rdi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %rbx, %rsi
callq 0x81454
movq %r13, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x84b08
jmp 0x7eaac
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r13, %rdi
callq 0x11360
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
testl %esi, %esi
cmovgl %esi, %ebp
movq 0x8749f(%rip), %r15     # 0x105fc8
leaq 0x2ac84(%rip), %r12     # 0xa97b4
subl $0x1, %ebp
jb 0x7eb42
movq %r15, %rdi
movq %r12, %rsi
callq 0x11340
jmp 0x7eb30
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0x7eb60
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x8(%rax)
addq $0x8, %r15
jmp 0x7eb4a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x83e82
leaq 0x86037(%rip), %rax     # 0x105280
addq $0x10, %rax
movq %rax, (%rbx)
andl $0x0, 0x8(%rbx)
cmpb $0x0, 0x87f85(%rip)     # 0x1071e0
jne 0x7f2bb
movq %r14, %rdi
callq 0x7e0e8
leaq 0x28(%rbx), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x83ec4
movl (%r15), %eax
cmpq $0x27, %rax
ja 0x7f2c5
movabsq $0x803c000000, %rcx     # imm = 0x803C000000
btq %rax, %rcx
jae 0x7f2c5
movl $0x1, 0x8(%rbx)
pushq $0x60
popq %rdi
callq 0x11350
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x7f22e
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
callq 0x84b08
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x7e25c
pushq $0x60
popq %rdi
callq 0x11350
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x7ef86
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
callq 0x84b08
jmp 0x7f2bb
jmp 0x7f2fa
jmp 0x7f30c
movq %rax, %r14
pushq $0x60
popq %rsi
movq %r15, %rdi
callq 0x11360
jmp 0x7f30f
jmp 0x7f30c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7eb6a
movq %r14, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x83e82
leaq 0x85f8e(%rip), %rax     # 0x1052c8
addq $0x10, %rax
movq %rax, (%rbx)
andl $0x0, 0x8(%rbx)
cmpb $0x0, 0x87e94(%rip)     # 0x1071e0
jne 0x7f3c2
pushq $0x60
popq %rdi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x7f22e
leaq 0x10(%rbx), %r15
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x84b08
movq %r14, %rdi
callq 0x7e0e8
leaq 0x28(%rbx), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x83ec4
cmpl $0xe, (%r12)
jne 0x7f3ba
pushq $0x60
popq %rdi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x7ebf4
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x84b08
jmp 0x7f3c2
movq %r14, %rdi
callq 0x7e25c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7f3d2
jmp 0x7f3e4
movq %rax, %r14
pushq $0x60
popq %rsi
movq %r12, %rdi
callq 0x11360
jmp 0x7f3e7
jmp 0x7f3e4
movq %rax, %r14
movq %rbx, %rdi
callq 0x7eb6a
movq %r14, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x83e82
leaq 0x85ef8(%rip), %rax     # 0x105310
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rbx, (%rsp)
andl $0x0, 0x8(%rbx)
cmpb $0x0, 0x87da6(%rip)     # 0x1071e0
jne 0x7f501
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
pushq $0x60
popq %rdi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f320
movq (%rsp), %rax
leaq 0x10(%rax), %r12
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movq %r12, %rdi
callq 0x84b08
movq %r15, %rdi
callq 0x7e0e8
movq (%rsp), %rcx
leaq 0x28(%rcx), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
pushq $0x60
popq %rbp
leaq 0x10(%rsp), %rbx
movl (%r13), %eax
cmpl $0x1f, %eax
ja 0x7f4f9
movl $0xd0000000, %ecx       # imm = 0xD0000000
btl %eax, %ecx
jae 0x7f4f9
movq %rbp, %rdi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f320
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x84b08
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x7e342
movq %r15, %rdi
callq 0x7e0e8
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
jmp 0x7f49e
movq %r15, %rdi
callq 0x7e25c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r13, %rdi
jmp 0x7f528
jmp 0x7f531
jmp 0x7f531
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r14, %rdi
callq 0x11360
jmp 0x7f534
jmp 0x7f531
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x7e36e
movq (%rsp), %rdi
callq 0x7eb6a
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x83e82
leaq 0x85de8(%rip), %rax     # 0x105358
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rbx, (%rsp)
andl $0x0, 0x8(%rbx)
cmpb $0x0, 0x87c4e(%rip)     # 0x1071e0
jne 0x7f652
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
pushq $0x78
popq %rdi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f3f8
movq (%rsp), %rax
leaq 0x10(%rax), %r12
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movq %r12, %rdi
callq 0x84b08
movq %r15, %rdi
callq 0x7e0e8
movq (%rsp), %rcx
leaq 0x28(%rcx), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
pushq $0x78
popq %rbp
leaq 0x10(%rsp), %rbx
movl (%r13), %eax
andl $-0x2, %eax
cmpl $0x1a, %eax
jne 0x7f64a
movq %rbp, %rdi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f3f8
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x84b08
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x7e342
movq %r15, %rdi
callq 0x7e0e8
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
jmp 0x7f5f6
movq %r15, %rdi
callq 0x7e25c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r13, %rdi
jmp 0x7f679
jmp 0x7f682
jmp 0x7f682
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r14, %rdi
callq 0x11360
jmp 0x7f685
jmp 0x7f682
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x7e36e
movq (%rsp), %rdi
callq 0x7eb6a
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x83e82
leaq 0x85ce0(%rip), %rax     # 0x1053a0
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rbx, (%rsp)
andl $0x0, 0x8(%rbx)
cmpb $0x0, 0x87afe(%rip)     # 0x1071e0
jne 0x7f7a2
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
pushq $0x78
popq %rdi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f550
movq (%rsp), %rax
leaq 0x10(%rax), %r12
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movq %r12, %rdi
callq 0x84b08
movq %r15, %rdi
callq 0x7e0e8
movq (%rsp), %rcx
leaq 0x28(%rcx), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
pushq $0x78
popq %rbp
leaq 0x10(%rsp), %rbx
movl (%r13), %eax
addl $-0x23, %eax
cmpl $0x3, %eax
ja 0x7f79a
movq %rbp, %rdi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f550
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x84b08
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x7e342
movq %r15, %rdi
callq 0x7e0e8
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
jmp 0x7f746
movq %r15, %rdi
callq 0x7e25c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r13, %rdi
jmp 0x7f7c9
jmp 0x7f7d2
jmp 0x7f7d2
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r14, %rdi
callq 0x11360
jmp 0x7f7d5
jmp 0x7f7d2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x7e36e
movq (%rsp), %rdi
callq 0x7eb6a
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x83e82
leaq 0x85bd8(%rip), %rax     # 0x1053e8
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rbx, (%rsp)
andl $0x0, 0x8(%rbx)
cmpb $0x0, 0x879ae(%rip)     # 0x1071e0
jne 0x7f8f2
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
pushq $0x78
popq %rdi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f6a0
movq (%rsp), %rax
leaq 0x10(%rax), %r12
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movq %r12, %rdi
callq 0x84b08
movq %r15, %rdi
callq 0x7e0e8
movq (%rsp), %rcx
leaq 0x28(%rcx), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
pushq $0x78
popq %rbp
leaq 0x10(%rsp), %rbx
movl (%r13), %eax
addl $-0x21, %eax
cmpl $0x1, %eax
ja 0x7f8ea
movq %rbp, %rdi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f6a0
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x84b08
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x7e342
movq %r15, %rdi
callq 0x7e0e8
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
jmp 0x7f896
movq %r15, %rdi
callq 0x7e25c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r13, %rdi
jmp 0x7f919
jmp 0x7f922
jmp 0x7f922
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r14, %rdi
callq 0x11360
jmp 0x7f925
jmp 0x7f922
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x7e36e
movq (%rsp), %rdi
callq 0x7eb6a
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x83e82
leaq 0x85ad0(%rip), %rax     # 0x105430
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rbx, (%rsp)
andl $0x0, 0x8(%rbx)
cmpb $0x0, 0x8785e(%rip)     # 0x1071e0
jne 0x7fa3d
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
pushq $0x78
popq %rdi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f7f0
movq (%rsp), %rax
leaq 0x10(%rax), %r12
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movq %r12, %rdi
callq 0x84b08
movq %r15, %rdi
callq 0x7e0e8
movq (%rsp), %rcx
leaq 0x28(%rcx), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
pushq $0x78
popq %rbp
leaq 0x10(%rsp), %rbx
cmpl $0x28, (%r13)
jne 0x7fa35
movq %rbp, %rdi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f7f0
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x84b08
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x7e342
movq %r15, %rdi
callq 0x7e0e8
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
jmp 0x7f9e6
movq %r15, %rdi
callq 0x7e25c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r13, %rdi
jmp 0x7fa64
jmp 0x7fa6d
jmp 0x7fa6d
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r14, %rdi
callq 0x11360
jmp 0x7fa70
jmp 0x7fa6d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x7e36e
movq (%rsp), %rdi
callq 0x7eb6a
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x83e82
leaq 0x859cc(%rip), %rax     # 0x105478
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rbx, (%rsp)
andl $0x0, 0x8(%rbx)
cmpb $0x0, 0x87712(%rip)     # 0x1071e0
jne 0x7fb89
movq (%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
pushq $0x78
popq %rdi
callq 0x11350
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f940
movq (%rsp), %rax
leaq 0x10(%rax), %r12
leaq 0x10(%rsp), %rsi
movq %r13, (%rsi)
movq %r12, %rdi
callq 0x84b08
movq %r15, %rdi
callq 0x7e0e8
movq (%rsp), %rcx
leaq 0x28(%rcx), %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
pushq $0x78
popq %rbp
leaq 0x10(%rsp), %rbx
cmpl $0x29, (%r13)
jne 0x7fb81
movq %rbp, %rdi
callq 0x11350
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x7f940
movq %r14, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x84b08
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x7e342
movq %r15, %rdi
callq 0x7e0e8
movq %r13, %rdi
movq %rax, %rsi
callq 0x83ec4
jmp 0x7fb32
movq %r15, %rdi
callq 0x7e25c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r13, %rdi
jmp 0x7fbb0
jmp 0x7fbb9
jmp 0x7fbb9
movq %rax, %rbx
pushq $0x78
popq %rsi
movq %r14, %rdi
callq 0x11360
jmp 0x7fbbc
jmp 0x7fbb9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x7e36e
movq (%rsp), %rdi
callq 0x7eb6a
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Cond::Cond(Gos::GosTokenizer&)
Build(Cond) {
        Log(Cond);
        Expect(LogicOr);
        token = tokenizer.GetToken();
        if (token.type == QUESTION) {
            branch = 1;
            Expect(Exp);
            tokenizer.EatToken(COLON);
            Expect(Exp);
        } else {
            tokenizer.BackToken();
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x83e82
leaq 0x858ce(%rip), %rax     # 0x1054c0
addq $0x10, %rax
movq %rax, (%rbx)
andl $0x0, 0x8(%rbx)
cmpb $0x0, 0x875dc(%rip)     # 0x1071e0
jne 0x7fcb4
pushq $0x78
popq %rdi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x7fa8c
leaq 0x10(%rbx), %r15
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x84b08
movq %r14, %rdi
callq 0x7e0e8
leaq 0x28(%rbx), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x83ec4
cmpl $0x31, (%r12)
jne 0x7fcac
movl $0x1, 0x8(%rbx)
pushq $0x60
popq %rdi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x7fe86
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x84b08
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x7e12a
pushq $0x60
popq %rdi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x7fe86
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x84b08
jmp 0x7fcb4
movq %r14, %rdi
callq 0x7e25c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7fcc2
movq %rax, %r14
pushq $0x60
jmp 0x7fcd2
jmp 0x7fcdf
jmp 0x7fcdf
movq %rax, %r14
pushq $0x78
popq %rsi
movq %r12, %rdi
callq 0x11360
jmp 0x7fce2
jmp 0x7fcdf
movq %rax, %r14
movq %rbx, %rdi
callq 0x7eb6a
movq %r14, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosAST.cpp
// Function: Gos::AST::Assign::Assign(Gos::GosTokenizer&)
Build(Assign) {
        Log(Assign);
        Expect(Unary);
        token = tokenizer.GetToken();
        if (token.type != ASSIGN && token.type != ASSIGN_ADD &&
            token.type != ASSIGN_SUB && token.type != ASSIGN_MUL &&
            token.type != ASSIGN_DIV && token.type != ASSIGN_REM &&
            token.type != ASSIGN_XOR && token.type != ASSIGN_AND &&
            token.type != ASSIGN_OR) {
            GosASTError::UnexpectedToken(token);
            return;
        }
        Expect(Cond);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x83e82
leaq 0x857bd(%rip), %rax     # 0x105550
addq $0x10, %rax
movq %rax, (%rbx)
andl $0x0, 0x8(%rbx)
cmpb $0x0, 0x8743b(%rip)     # 0x1071e0
jne 0x7fe41
pushq $0x60
popq %rdi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x7f22e
leaq 0x10(%rbx), %r15
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x84b08
movq %r14, %rdi
callq 0x7e0e8
leaq 0x28(%rbx), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x83ec4
movl (%r12), %eax
addl $-0xf, %eax
cmpl $0x9, %eax
jae 0x7fe20
pushq $0x60
popq %rdi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x7fbd8
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movq %r15, %rdi
callq 0x84b08
jmp 0x7fe41
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x7e3de
leaq 0x10(%rsp), %rdi
callq 0x7e784
leaq 0x28(%rsp), %rdi
callq 0x209be
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x209be
jmp 0x7fe75
jmp 0x7fe60
jmp 0x7fe72
movq %rax, %r14
pushq $0x60
popq %rsi
movq %r12, %rdi
callq 0x11360
jmp 0x7fe75
jmp 0x7fe72
movq %rax, %r14
movq %rbx, %rdi
callq 0x7eb6a
movq %r14, %rdi
callq 0x11570
nop