LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::IterateMethod(TypeID, std::function<void (MethodInfo const&)>)
void ReflMgr::IterateMethod(TypeID cls, std::function<void(const MethodInfo&)> callback) {
    std::function<void*(void*)> conv = [](void* orig) { return orig; };
    cls = GetType(cls.getName());
    WalkThroughInherits(&conv, cls, std::function([&](TypeID type) -> MethodInfo* {
        auto* lst = SafeGetList(methodInfo, cls);
        if (lst == nullptr) {
            return nullptr;
        }
        for (auto& method : *lst) {
            for (auto& overloads : method.second) {
                callback(overloads);
            }
        }
        return nullptr;
    }));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xa0(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0xd4d(%rip), %rax       # 0x268ce
movq %rax, 0x38(%rsp)
leaq 0xd45(%rip), %rax       # 0x268d2
movq %rax, 0x30(%rsp)
movq %r14, %rdi
callq 0x1ff7e
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x23156
movups 0x60(%rsp), %xmm0
movups 0x6a(%rsp), %xmm1
movups %xmm1, 0xa(%r14)
movups %xmm0, (%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movl $0x18, %edi
callq 0x11350
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
leaq 0x40(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xcff(%rip), %rax       # 0x268ea
movq %rax, 0x18(%rdx)
leaq 0xd94(%rip), %rax       # 0x2698a
movq %rax, 0x10(%rdx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8d3b0
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x25c32
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x25c4b
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x25ca2
jmp 0x25ca2
movq %rax, %rbx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x25c81
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x25c81
jmp 0x25ca2
jmp 0x25c7e
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x25c9a
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x2789a
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::IsBaseClass(TypeID, TypeID)
bool ReflMgr::IsBaseClass(TypeID query, TypeID base) {
    std::queue<TypeID> q;
    q.push(query);
    while (!q.empty()) {
        if (q.front() == base) {
            return true;
        }
        auto& info = classInfo[q.front()];
        q.pop();
        for (auto& id : info.parents) {
            q.push(id);
        }
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x90(%rsp), %r14
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x40(%r15)
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r15, %rdi
xorl %esi, %esi
callq 0x944e8
movq 0x30(%r15), %rax
movq 0x40(%r15), %rcx
addq $-0x20, %rcx
cmpq %rcx, %rax
je 0x25d14
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x20, 0x30(%rsp)
jmp 0x25d1f
movq %rsp, %rdi
movq %r14, %rsi
callq 0x94660
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x30(%rsp)
setne %bpl
je 0x25e14
leaq 0xb0(%rsp), %r14
addq $0x90, %rbx
movq %rsp, %r15
movq %r14, %rsi
callq 0x1fff6
testb %al, %al
jne 0x25e14
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x36950
movq %rax, %r13
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $-0x20, %rcx
cmpq %rcx, %rax
je 0x25d7e
addq $0x20, %rax
jmp 0x25db0
movq 0x18(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x11360
movq 0x28(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movq 0x20(%r13), %r12
movq 0x28(%r13), %r13
cmpq %r13, %r12
je 0x25e00
movq 0x30(%rsp), %rax
movq 0x40(%rsp), %rcx
addq $-0x20, %rcx
cmpq %rcx, %rax
je 0x25def
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x20, 0x30(%rsp)
jmp 0x25dfa
movq %r15, %rdi
movq %r12, %rsi
callq 0x94660
addq $0x20, %r12
jmp 0x25dbd
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x30(%rsp)
setne %bpl
jne 0x25d45
movq %rsp, %rdi
callq 0x90110
andb $0x1, %bpl
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25e37
jmp 0x25e37
jmp 0x25e37
movq %rax, %rbx
movq %rsp, %rdi
callq 0x90110
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Reflection/./ReflMgr.h
// Function: void ReflMgr::AddClass<ObjectPtr>(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<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>>>>>>>)
void AddClass(TagList tagList = {}) {
            auto type = TypeID::get<T>();
            classInfo[type].newObject = [](const std::vector<ObjectPtr>& args) -> SharedObject {
                auto obj = SharedObject{TypeID::get<T>(), std::make_shared<T>(), false};
                obj.ctor(args);
                return obj;
            };
            classInfo[type].tags = tagList;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movabsq $0x57dfe2a8f2175be4, %rax # imm = 0x57DFE2A8F2175BE4
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
movq $0x9, 0x8(%r15)
leaq 0x8754c(%rip), %rax     # 0xbd04a
movq %rax, 0x10(%r15)
movw $0x0, 0x18(%r15)
addq $0x90, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x36950
leaq 0x88(%rax), %rdi
leaq 0xf(%rsp), %rsi
callq 0x368e2
movq %r14, %rdi
movq %r15, %rsi
callq 0x36950
addq $0x50, %rax
cmpq %rbx, %rax
je 0x35b4b
movq %rax, %rdi
movq %rbx, %rsi
callq 0x36fda
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Reflection/JSON.cpp
// Function: int ConvertTo<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
T ConvertTo(U orig) {
    std::stringstream ss;
    ss << orig;
    T ret;
    ss >> ret;
    return ret;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11280
leaq 0x18(%rsp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x113c0
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x111f0
movl 0x4(%rsp), %ebx
movq 0x957d6(%rip), %rsi     # 0x11df98
leaq 0x8(%rsp), %rdi
callq 0x112c0
leaq 0x88(%rsp), %rdi
callq 0x11120
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
jmp 0x887e6
movq %rax, %rbx
movq 0x957a8(%rip), %rsi     # 0x11df98
leaq 0x8(%rsp), %rdi
callq 0x112c0
leaq 0x88(%rsp), %rdi
callq 0x11120
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: std::vector<MethodInfo, std::allocator<MethodInfo>>* ReflMgr::SafeGet<std::vector<MethodInfo, std::allocator<MethodInfo>>>(std::unordered_map<TypeID, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<MethodInfo, std::allocator<MethodInfo>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<MethodInfo, std::allocator<MethodInfo>>>>>, std::hash<TypeID>, TypeIDHashEqual, std::allocator<std::pair<TypeID const, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<MethodInfo, std::allocator<MethodInfo>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<MethodInfo, std::allocator<MethodInfo>>>>>>>>&, TypeID, std::basic_string_view<char, std::char_traits<char>>)
T* ReflMgr::SafeGet(TypeIDMap<std::unordered_map<std::string, T>>& info, TypeID id, std::string_view name) {
    auto* lst = SafeGetList(info, id);
    if (lst == nullptr) {
        return nullptr;
    }
    if (lst->find(std::string{name}) == lst->end()) {
        return nullptr;
    }
    return &(*lst)[std::string{name}];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movq %rsp, %rsi
movaps %xmm1, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %r15, %rdi
callq 0x901f8
testq %rax, %rax
je 0x8c445
movq %rsp, %rsi
movq %r15, %rdi
callq 0x902c0
movq %rax, %r15
jmp 0x8c448
xorl %r15d, %r15d
testq %r15, %r15
je 0x8c4c7
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
addq %r14, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27dc8
movq %rsp, %rsi
movq %r15, %rdi
callq 0x90980
movq %rax, %r12
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8c48b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
testq %r12, %r12
je 0x8c4c7
movq %rsp, %rdi
movq %r13, (%rdi)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27dc8
movq %rsp, %rsi
movq %r15, %rdi
callq 0x90a7c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8c4c9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x8c4c9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x8c4de
jmp 0x8c4f9
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8c4fc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x8c4fc
movq %rax, %rbx
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Reflection/./ReflMgr.h
// Function: void ReflMgr::AddStaticMethod<ReflMgr&>(TypeID, ReflMgr& (*)(), MethodInfo)
void AddStaticMethod(TypeID type, Ret (*func)(Args...), MethodInfo info) {
            info.returnType = TypeID::get<Ret>();
            info.argsList = ArgsTypeList{TypeID::get<Args>()...};
            info.newRet = GetNewRet(func);
            AddMethodInfo(type, info.name, info.withRegister(GetStaticMethodRegisterFunc(std::forward<decltype(func)>(func))));
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x180(%rsp), %r13
movabsq $-0x499506eb9c827484, %rax # imm = 0xB66AF914637D8B7C
movq %rax, 0x98(%rdx)
movq $0x9, 0xa0(%rdx)
leaq 0x2bedb(%rip), %rax     # 0xbe4a3
movq %rax, 0xa8(%rdx)
movw $0x1, 0xb0(%rdx)
leaq 0xb8(%rdx), %rdi
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq %r12, %rsi
callq 0x37e72
movq (%r12), %rdi
testq %rdi, %rdi
je 0x92613
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
leaq 0x78(%rbx), %rdi
leaq 0x60(%rsp), %rsi
callq 0x9279c
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
leaq 0x20(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %r15, (%rsi)
leaq 0x1e2(%rip), %rax       # 0x92830
movq %rax, 0x18(%rsi)
leaq 0x1dd(%rip), %rax       # 0x92836
movq %rax, 0x10(%rsi)
leaq 0x58(%rbx), %rdi
callq 0x8c242
leaq 0x80(%rsp), %rdi
movq %rbx, %rsi
callq 0x37ae8
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x80(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq 0x2343c
movq 0x138(%rsp), %rdi
testq %rdi, %rdi
je 0x926be
movq 0x148(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
movq 0x108(%rsp), %rax
testq %rax, %rax
je 0x926dd
leaq 0xf8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xe8(%rsp), %rax
testq %rax, %rax
je 0x926fc
leaq 0xd8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
callq 0x376f2
movq -0x20(%rbx), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x9272d
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x92746
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x92793
jmp 0x92793
jmp 0x92793
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x37c26
jmp 0x92772
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x9278b
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x2789a
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::RTConst::getStrID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int GosVM::RTConst::getStrID(const std::string& s) {
    if (strMap.find(s) == strMap.end()) {
        strs.push_back(std::make_shared<std::string>(s));
        strMap[s] = strs.size() - 1;
        return strs.size() - 1;
    }
    return strMap[s];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x9bd66
testq %rax, %rax
je 0x948bf
movq %r15, %rdi
movq %r14, %rsi
callq 0x9c09a
movl (%rax), %eax
jmp 0x94924
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
movq %r14, %rcx
callq 0x9be62
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9bee0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x948fb
callq 0x278ec
movq 0x8(%rbx), %r12
subq (%rbx), %r12
shrq $0x4, %r12
decl %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x9c09a
movl %r12d, (%rax)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x4, %rax
decl %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x94942
callq 0x278ec
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::RTConst::setStrID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void GosVM::RTConst::setStrID(const std::string& s, int id) {
    auto cont = std::make_shared<std::string>(s);
    if (id < strs.size()) {
        strs[id] = cont;
    } else {
        while (id > strs.size()) {
            strs.push_back(nullptr);
        }
        strs.push_back(cont);
    }
    strMap[s] = id;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq $0x0, -0x8(%r12)
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movq %r14, %rcx
callq 0x9be62
movslq %ebx, %r13
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r13, %rcx
jbe 0x949b4
shlq $0x4, %r13
movq (%rsp), %rcx
leaq (%rax,%r13), %rdi
addq $0x8, %rdi
movq %rcx, -0x8(%rdi)
movq %r12, %rsi
callq 0x278a6
jmp 0x94a06
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x4, %rax
cmpq %r13, %rax
jae 0x949fb
leaq 0x10(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x9bee0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x949eb
callq 0x278ec
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x4, %rax
cmpq %r13, %rax
jb 0x949c9
movq %rsp, %rsi
movq %r15, %rdi
callq 0x9b1f8
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x9c09a
movl %ebx, (%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x94a26
callq 0x278ec
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x94a4b
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x94a4b
callq 0x278ec
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x94a5a
callq 0x278ec
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::RTConst::getNumID(GosVM::RTConstNum)
int GosVM::RTConst::getNumID(RTConstNum s) {
    if (numMap.find(s) == numMap.end()) {
        nums.push_back(s);
        numMap[s] = nums.size() - 1;
        return nums.size() - 1;
    }
    return numMap[s];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x8(%rsp), %r8
movq %rsi, (%r8)
leaq 0x68(%rdi), %r14
movq %rsi, %rax
xorl %edx, %edx
divq 0x70(%rdi)
movq %r14, %rdi
movq %rdx, %rsi
movq %r8, %rdx
callq 0x9c530
testq %rax, %rax
je 0x94ab0
cmpq $0x0, (%rax)
je 0x94ab0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x9c6c0
movl (%rax), %eax
jmp 0x94b04
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
je 0x94ac9
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x58(%rbx)
jmp 0x94ad7
leaq 0x50(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x9c584
movq 0x58(%rbx), %r15
subq 0x50(%rbx), %r15
shrq $0x3, %r15
decl %r15d
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x9c6c0
movl %r15d, (%rax)
movq 0x58(%rbx), %rax
subq 0x50(%rbx), %rax
shrq $0x3, %rax
decl %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::RTConst::setNumID(GosVM::RTConstNum, int)
void GosVM::RTConst::setNumID(RTConstNum s, int id) {
    if (id < nums.size()) {
        nums[id] = s;
    } else {
        while (id > nums.size()) {
            nums.push_back({});
        }
        nums.push_back(s);
    }
    numMap[s] = id;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
movq %rsi, (%rsp)
movslq %edx, %r13
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jbe 0x94b41
movq %rsi, (%rax,%r13,8)
jmp 0x94ba1
leaq 0x50(%r14), %r15
movq 0x58(%r14), %rsi
movq %rsi, %rax
subq 0x50(%r14), %rax
sarq $0x3, %rax
cmpq %r13, %rax
jae 0x94b82
leaq 0x8(%rsp), %r12
movb $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x9c948
movq 0x58(%r14), %rsi
movq %rsi, %rax
subq 0x50(%r14), %rax
sarq $0x3, %rax
cmpq %r13, %rax
jb 0x94b5e
cmpq 0x60(%r14), %rsi
je 0x94b96
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x58(%r14)
jmp 0x94ba1
movq %rsp, %rdx
movq %r15, %rdi
callq 0x9c584
addq $0x68, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x9c6c0
movl %ebx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x3b9b2(%rip), %rdx     # 0xd05a6
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x27dc8
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
callq 0x113e0
movl %eax, %r13d
shll $0x18, %eax
cmpl $0x22000000, %eax       # imm = 0x22000000
je 0x94c29
movl %r12d, %ebx
cmpl $0xff000000, %eax       # imm = 0xFF000000
jne 0x94c34
jmp 0x94c74
movb $0x1, %bl
testb $0x1, %bpl
movb $0x1, %bpl
jne 0x94c65
cmpl $0xa000000, %eax        # imm = 0xA000000
je 0x94c49
cmpl $0x20000000, %eax       # imm = 0x20000000
je 0x94c49
cmpl $0xd000000, %eax        # imm = 0xD000000
jne 0x94c4f
testb $0x1, %bpl
je 0x94c60
movsbl %r13b, %esi
movq %r15, %rdi
callq 0x6ed94
movl %ebx, %r12d
jmp 0x94c07
movl %ebx, %r12d
jmp 0x94c74
leaq 0x3b912(%rip), %rsi     # 0xd057e
movq %rsp, %rdi
callq 0x27e58
movb %r13b, (%r14)
testb $0x1, %r12b
je 0x94c99
movq %rsp, %rsi
movq 0x8(%rsi), %rcx
addq $-0x2, %rcx
movl $0x1, %edx
movq 0x20(%rsp), %rdi
callq 0x9b238
jmp 0x94ce2
movq 0x20(%rsp), %rdx
leaq 0x10(%rdx), %rax
movq %rax, (%rdx)
movq (%rsp), %rcx
leaq 0x10(%rsp), %rsi
cmpq %rsi, %rcx
je 0x94cc1
movq %rcx, (%rdx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rdx)
jmp 0x94cc7
movups (%rsi), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %rsi, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x94cfd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0x20(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x94d13
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x94d31
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x28(%rsi), %r12
movq %rax, 0x28(%rsi)
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x194ee
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x950cc
movq %r12, 0x28(%r14)
movq %rsp, %rdi
callq 0x27756
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x27756
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movslq %esi, %r12
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $0x6db6db6db6db6db7, %r13 # imm = 0x6DB6DB6DB6DB6DB7
imulq %r13, %rcx
cmpq %r12, %rcx
jbe 0x996e5
imulq $0x38, %r12, %rcx
movups (%rbx), %xmm0
movups 0xa(%rbx), %xmm1
leaq (%rax,%rcx), %r14
addq $0x28, %r14
movups %xmm1, -0x1e(%r14)
movups %xmm0, -0x28(%r14)
movq 0x20(%rbx), %rax
movq %rax, -0x8(%r14)
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x278a6
movq 0x30(%rbx), %rax
movq %rax, 0x8(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %r12, %rax
jae 0x99722
leaq 0x84c85(%rip), %r15     # 0x11e388
movq %r14, %rdi
movq %r15, %rsi
callq 0x9b268
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %r12, %rax
jb 0x99703
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9b268
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x20(%rdi), %r15
movq %r15, %rdi
movl $0x1, %esi
callq 0x6ed94
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x37586
movq %r14, %rdi
movq %r12, %rsi
callq 0x94f28
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x997a2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0x8(%rbx), %r12
subq (%rbx), %r12
shrq $0x5, %r12
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
addl $0x8, %ebp
movl %r12d, %eax
movl %ebp, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0x6ed94
cmpl $0x18, %ebp
jb 0x997b2
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x9983c
movl $0x8, %r12d
leaq 0x18(%rsp), %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq %r13, 0x8(%rsp)
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x37586
movq %r14, %rdi
movq %r15, %rsi
callq 0x94f28
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x99822
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
incq %rbp
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r12
cmpq %rbp, %rcx
ja 0x997e7
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x9985d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9986e
movq (%r13), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x20(%rdi), %r14
movq %r14, %rdi
movl $0xb, %esi
callq 0x6ed94
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x37586
movq %r12, %rdi
movq %r15, %rsi
callq 0x94f28
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x99eee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
movl $0xfffffff8, %r15d      # imm = 0xFFFFFFF8
addl $0x8, %r15d
movl %ebp, %eax
movl %r15d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x6ed94
cmpl $0x18, %r15d
jb 0x99ef4
movq 0x8(%rbx), %r15
subq (%rbx), %r15
shrq $0x2, %r15
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
addl $0x8, %ebp
movl %r15d, %eax
movl %ebp, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x6ed94
cmpl $0x18, %ebp
jb 0x99f20
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x99f7f
xorl %r15d, %r15d
movl (%rax,%r15,4), %r12d
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
addl $0x8, %ebp
movl %r12d, %eax
movl %ebp, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x6ed94
cmpl $0x18, %ebp
jb 0x99f4f
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
ja 0x99f46
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x99fa8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r15
leaq 0x20(%rdi), %rbx
movq %rbx, %rdi
movl $0xd, %esi
callq 0x6ed94
movq %rbx, %rdi
movl %r12d, %esi
callq 0x6ed94
movl $0xfffffff8, %r12d      # imm = 0xFFFFFFF8
addl $0x8, %r12d
movl %ebp, %eax
movl %r12d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6ed94
cmpl $0x18, %r12d
jb 0x9a099
movq 0x60(%r15), %rdi
movq %r14, %rsi
callq 0x94a62
movl %eax, %ebp
movl $0xfffffff8, %r14d      # imm = 0xFFFFFFF8
addl $0x8, %r14d
movl %ebp, %eax
movl %r14d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6ed94
cmpl $0x18, %r14d
jb 0x9a0c9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
movq %r15, %rdi
movl $0x12, %esi
callq 0x6ed94
movl $0xfffffff8, %r13d      # imm = 0xFFFFFFF8
addl $0x8, %r13d
movl %r12d, %eax
movl %r13d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0x6ed94
cmpl $0x18, %r13d
jb 0x9a2c6
movl $0xfffffff8, %r12d      # imm = 0xFFFFFFF8
addl $0x8, %r12d
movl %ebp, %eax
movl %r12d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0x6ed94
cmpl $0x18, %r12d
jb 0x9a2e9
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x37586
movq %rbx, %rdi
movq %r14, %rsi
callq 0x94f28
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9a347
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9a370
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %r15
movq %r15, %rdi
movl $0x1d, %esi
callq 0x6ed94
movq 0x28(%r14), %r12
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
movq %r15, %rdi
xorl %esi, %esi
callq 0x6ed94
addl $0x8, %ebp
cmpl $0x18, %ebp
jb 0x9a76c
movl 0x28(%r14), %eax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movq %r14, (%rbx)
movl %r12d, 0x8(%rbx)
movl %eax, 0xc(%rbx)
leaq 0x9a9(%rip), %rax       # 0x9b146
movq %rax, 0x18(%rbx)
leaq 0x9b2(%rip), %rax       # 0x9b15a
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %r15
movq %r15, %rdi
movl $0x1e, %esi
callq 0x6ed94
movl $0xfffffff8, %r12d      # imm = 0xFFFFFFF8
addl $0x8, %r12d
movl %ebp, %eax
movl %r12d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0x6ed94
cmpl $0x18, %r12d
jb 0x9a7df
movq 0x28(%r14), %r12
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
movq %r15, %rdi
xorl %esi, %esi
callq 0x6ed94
addl $0x8, %ebp
cmpl $0x18, %ebp
jb 0x9a804
movl 0x28(%r14), %eax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movq %r14, (%rbx)
movl %r12d, 0x8(%rbx)
movl %eax, 0xc(%rbx)
leaq 0x94d(%rip), %rax       # 0x9b182
movq %rax, 0x18(%rbx)
leaq 0x956(%rip), %rax       # 0x9b196
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r15
leaq 0x20(%rdi), %r14
movq %r14, %rdi
movl $0x21, %esi
callq 0x6ed94
movl $0xfffffff8, %r13d      # imm = 0xFFFFFFF8
addl $0x8, %r13d
movl %ebp, %eax
movl %r13d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x6ed94
cmpl $0x18, %r13d
jb 0x9a954
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x37586
movq %r15, %rdi
movq %r12, %rsi
callq 0x94f28
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9a9b4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0x8(%rbx), %r15
subq (%rbx), %r15
shrq $0x2, %r15
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
addl $0x8, %ebp
movl %r15d, %eax
movl %ebp, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x6ed94
cmpl $0x18, %ebp
jb 0x9a9c4
testl %r15d, %r15d
jle 0x9aa1b
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq (%rbx), %rax
movl (%rax,%r12,4), %r13d
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
addl $0x8, %ebp
movl %r13d, %eax
movl %ebp, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x6ed94
cmpl $0x18, %ebp
jb 0x9a9f9
incq %r12
cmpq %r15, %r12
jne 0x9a9ed
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9aa44
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x20(%rdi), %r15
movq %r15, %rdi
movl $0x2, %esi
callq 0x6ed94
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x37586
movq %r14, %rdi
movq %r12, %rsi
callq 0x94f28
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x9aab8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0x8(%rbx), %r12
subq (%rbx), %r12
shrq $0x5, %r12
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
addl $0x8, %ebp
movl %r12d, %eax
movl %ebp, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0x6ed94
cmpl $0x18, %ebp
jb 0x9aac8
testl %r12d, %r12d
jle 0x9ab44
leaq 0x18(%rsp), %r13
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movl $0x8, %ebp
leaq 0x8(%rsp), %r15
movq (%rbx), %rax
movq %r13, 0x8(%rsp)
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x37586
movq %r14, %rdi
movq %r15, %rsi
callq 0x94f28
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9ab3b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x20, %rbp
decq %r12
jne 0x9aafd
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x9ab65
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9ab76
movq (%r13), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %r15
movq %r15, %rdi
movl $0x7, %esi
callq 0x6ed94
movq 0x28(%r14), %r12
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
movq %r15, %rdi
xorl %esi, %esi
callq 0x6ed94
addl $0x8, %ebp
cmpl $0x18, %ebp
jb 0x9abb4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movq %r14, (%rbx)
movl %r12d, 0x8(%rbx)
leaq 0x5e0(%rip), %rax       # 0x9b1be
movq %rax, 0x18(%rbx)
leaq 0x5e7(%rip), %rax       # 0x9b1d0
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11280
leaq 0x18(%rsp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x113c0
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x111f0
movl 0x4(%rsp), %ebx
movq 0x81308(%rip), %rsi     # 0x11df98
leaq 0x8(%rsp), %rdi
callq 0x112c0
leaq 0x88(%rsp), %rdi
callq 0x11120
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
jmp 0x9ccb4
movq %rax, %rbx
movq 0x812da(%rip), %rsi     # 0x11df98
leaq 0x8(%rsp), %rdi
callq 0x112c0
leaq 0x88(%rsp), %rdi
callq 0x11120
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9edfd
cmpl $0x2b, %eax
je 0x9ed98
cmpl $0x2a, %eax
jne 0x9ee46
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
jmp 0x9ee61
movq %rsp, %rdi
callq 0x11280
leaq 0x10(%rsp), %r15
movsbq 0x8(%r14), %rax
leaq 0x7e27f(%rip), %rcx     # 0x11d030
movq (%rcx,%rax,8), %r12
movq %r12, %rdi
callq 0x11190
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x113c0
leaq 0x317d3(%rip), %rsi     # 0xd05a5
movl $0x1, %edx
movq %r15, %rdi
callq 0x113c0
movzbl 0x8(%r14), %eax
cmpb $0x2, %al
jg 0x9ee71
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x11330
jmp 0x9eecb
addq $0x18, %r14
leaq 0x31776(%rip), %r15     # 0xd057e
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x9fe8c
movq %r12, %rdi
movq %r15, %rsi
callq 0x27e58
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x9ee83
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x9ee89
shlq $0x5, %rax
leaq 0x7fc1f(%rip), %rcx     # 0x11ea70
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x37586
jmp 0x9eef4
cmpl $0x4, %eax
je 0x9eebd
cmpl $0x3, %eax
jne 0x9eecb
cvtss2sd 0x10(%r14), %xmm0
jmp 0x9eec3
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9eef4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x9eef4
movsd 0x10(%r14), %xmm0
movq %r15, %rdi
callq 0x114f0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x112b0
movq 0x7f0b9(%rip), %rsi     # 0x11df98
movq %rsp, %rdi
callq 0x112c0
leaq 0x80(%rsp), %rdi
callq 0x11120
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9ef45
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x9ef45
movq %rax, %rbx
movq 0x7f068(%rip), %rsi     # 0x11df98
movq %rsp, %rdi
callq 0x112c0
leaq 0x80(%rsp), %rdi
callq 0x11120
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movslq 0x30(%rdi), %rcx
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rsi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdx, %rsi
cmpq %rcx, %rsi
jbe 0x9fc78
leal 0x1(%rcx), %edx
movl %edx, 0x30(%r14)
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
jmp 0x9fc7f
leaq 0x7f511(%rip), %rax     # 0x11f190
movq 0x10(%rax), %rcx
leaq 0x38(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movups (%rax), %xmm0
movaps %xmm0, -0x18(%rdi)
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdx
addq %rsi, %rdx
callq 0x37586
cmpl %ebx, -0x28(%r15)
je 0x9fddf
cmpq $0x0, 0x60(%r14)
je 0x9fccd
leaq 0x50(%r14), %rdi
callq *0x68(%r14)
testb %al, %al
je 0x9fddf
movq 0x7e31c(%rip), %rdi     # 0x11dff0
leaq 0x307af(%rip), %rsi     # 0xd048a
movl $0x7, %edx
callq 0x113c0
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq 0x7e2fc(%rip), %rdi     # 0x11dff0
callq 0x113c0
movq %rax, %r14
leaq 0x1e5b6(%rip), %rsi     # 0xbe2b9
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movl 0x24(%rsp), %esi
movq %r14, %rdi
callq 0x11550
movq %rax, %r14
leaq 0x3076c(%rip), %rsi     # 0xd0492
movl $0x1b, %edx
movq %rax, %rdi
callq 0x113c0
movl %ebx, %eax
shlq $0x5, %rax
leaq 0x7ed30(%rip), %rcx     # 0x11ea70
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %r14, %rdi
callq 0x113c0
movq %rax, %rbx
leaq 0x30753(%rip), %rsi     # 0xd04ae
movl $0x7, %edx
movq %rax, %rdi
callq 0x113c0
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x9ed56
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x113c0
movq %rax, %rbx
leaq 0x30726(%rip), %rsi     # 0xd04b6
movl $0x7, %edx
movq %rax, %rdi
callq 0x113c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq %rbx, %rdi
callq 0x11040
movq %rax, %rdi
callq 0x11260
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fddf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x9fdf6
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x9fe22
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fe25
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x9fe25
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x9fe3c
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x7edf4(%rip)     # 0x11f1f0
cmpl $0x0, 0x7edf1(%rip)     # 0x11f1f4
jne 0xa04ec
movq %rdi, %rbx
movq 0x7dbdd(%rip), %r14     # 0x11dff0
leaq 0x30070(%rip), %rsi     # 0xd048a
movl $0x7, %edx
movq %r14, %rdi
callq 0x113c0
movq 0x7eda2(%rip), %rsi     # 0x11f1d0
movq 0x7eda3(%rip), %rdx     # 0x11f1d8
movq %r14, %rdi
callq 0x113c0
movq %rax, %r14
leaq 0x1de72(%rip), %rsi     # 0xbe2b9
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x11550
movq %rax, %r14
leaq 0x30101(%rip), %rsi     # 0xd056a
movl $0x15, %edx
movq %rax, %rdi
callq 0x113c0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9ed56
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x113c0
movq %rax, %rbx
leaq 0x300e1(%rip), %rsi     # 0xd057e
movl $0x1, %edx
movq %rax, %rdi
callq 0x113c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq %rbx, %rdi
callq 0x11040
movq %rax, %rdi
callq 0x11260
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa04ec
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0514
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580