LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8f68c
testq %rax, %rax
je 0x8b983
movq %rsp, %rsi
movq %r15, %rdi
callq 0x8f75a
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
addq %r14, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27370
movq %rsp, %rsi
movq %r15, %rdi
callq 0x8fdf8
movq %rax, %r12
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8b947
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
testq %r12, %r12
je 0x8b983
movq %rsp, %rdi
movq %r13, (%rdi)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27370
movq %rsp, %rsi
movq %r15, %rdi
callq 0x8fef4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8b985
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x8b985
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x8b99a
jmp 0x8b9b5
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x8b9b8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x8b9b8
movq %rax, %rbx
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x170(%rsp), %r12
movabsq $-0x499506eb9c827484, %rax # imm = 0xB66AF914637D8B7C
movq %rax, 0x98(%rdx)
movq $0x9, 0xa0(%rdx)
leaq 0x2ba4f(%rip), %rax     # 0xbd473
movq %rax, 0xa8(%rdx)
movw $0x1, 0xb0(%rdx)
movq 0xb8(%rdx), %rdi
movq 0xc8(%rdx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rdx)
movq $0x0, 0xc8(%rdx)
testq %rdi, %rdi
je 0x91a64
subq %rdi, %rsi
callq 0x11360
leaq 0x78(%rbx), %rdi
leaq 0x2f(%rsp), %rsi
callq 0x91be0
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
leaq 0x30(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %r15, (%rsi)
leaq 0x1c8(%rip), %rax       # 0x91c66
movq %rax, 0x18(%rsi)
leaq 0x1c3(%rip), %rax       # 0x91c6c
movq %rax, 0x10(%rsi)
leaq 0x58(%rbx), %rdi
callq 0x8b704
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
callq 0x36ef4
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x78(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq 0x22a82
movq 0x130(%rsp), %rdi
testq %rdi, %rdi
je 0x91b08
movq 0x140(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
movq 0x100(%rsp), %rax
testq %rax, %rax
je 0x91b27
leaq 0xf0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xe0(%rsp), %rax
testq %rax, %rax
je 0x91b46
leaq 0xd0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0x36ac6
movq -0x20(%rbx), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x91b77
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x91b90
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x91bd8
jmp 0x91bd8
jmp 0x91bd8
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x37032
jmp 0x91bb7
movq %rax, %rbx
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x91bd0
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x26e38
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9b13a
testq %rax, %rax
je 0x93db3
movq %r15, %rdi
movq %r14, %rsi
callq 0x9b46a
movl (%rax), %eax
jmp 0x93e18
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
movq %r14, %rcx
callq 0x9b236
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9b2b4
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x93def
callq 0x26e8e
movq 0x8(%rbx), %r12
subq (%rbx), %r12
shrq $0x4, %r12
decl %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x9b46a
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 0x93e36
callq 0x26e8e
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9b236
movslq %ebx, %r13
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r13, %rcx
jbe 0x93ea8
shlq $0x4, %r13
movq (%rsp), %rcx
leaq (%rax,%r13), %rdi
addq $0x8, %rdi
movq %rcx, -0x8(%rdi)
movq %r12, %rsi
callq 0x26e44
jmp 0x93eec
jae 0x93ee1
leaq 0x10(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x9b2b4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x93ed1
callq 0x26e8e
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x4, %rax
cmpq %r13, %rax
jb 0x93eaf
movq %rsp, %rsi
movq %r15, %rdi
callq 0x9a5a8
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x9b46a
movl %ebx, (%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x93f0c
callq 0x26e8e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x93f31
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x93f31
callq 0x26e8e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x93f40
callq 0x26e8e
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9b8ee
testq %rax, %rax
je 0x93f96
cmpq $0x0, (%rax)
je 0x93f96
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x9ba80
movl (%rax), %eax
jmp 0x93ff1
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
je 0x93fb6
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
movq 0x58(%rbx), %r15
addq $0x8, %r15
movq %r15, 0x58(%rbx)
jmp 0x93fc8
leaq 0x50(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x9b944
movq 0x58(%rbx), %r15
subq 0x50(%rbx), %r15
shrq $0x3, %r15
decl %r15d
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x9ba80
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %rax
movq %rdi, %r14
movq %rsi, (%rsp)
movslq %edx, %r13
leaq 0x50(%rdi), %r15
movq 0x50(%rdi), %rcx
movq 0x58(%rdi), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %r13, %rdx
jbe 0x94039
movq %rax, (%rcx,%r13,8)
jmp 0x94083
jae 0x94064
leaq 0x8(%rsp), %r12
movb $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x9bcf8
movq 0x58(%r14), %rsi
movq %rsi, %rax
subq 0x50(%r14), %rax
sarq $0x3, %rax
cmpq %r13, %rax
jb 0x94040
cmpq 0x60(%r14), %rsi
je 0x94078
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x58(%r14)
jmp 0x94083
movq %rsp, %rdx
movq %r15, %rdi
callq 0x9b944
addq $0x68, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x9ba80
movl %ebx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, (%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x3b4a1(%rip), %rdx     # 0xcf576
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x27370
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
callq 0x113e0
movl %eax, %ebp
movzbl %bpl, %eax
cmpl $0x1f, %eax
jle 0x94116
cmpl $0x20, %eax
je 0x94120
cmpl $0x22, %eax
jne 0x9413a
movb $0x1, %bl
testb $0x1, %r13b
movb $0x1, %r13b
je 0x94129
jmp 0x94143
cmpl $0xa, %eax
je 0x94120
cmpl $0xd, %eax
jne 0x94126
testb $0x1, %r13b
je 0x94154
movl %r12d, %ebx
movsbl %bpl, %esi
movq %r15, %rdi
callq 0x6e3f2
movl %ebx, %r12d
jmp 0x940eb
cmpl $0xff, %eax
jne 0x94126
jmp 0x94154
leaq 0x3b404(%rip), %rsi     # 0xcf54e
leaq 0x8(%rsp), %rdi
callq 0x27406
movb %bpl, (%r14)
testb $0x1, %r12b
je 0x9419a
leaq 0x8(%rsp), %rsi
movq 0x8(%rsi), %rcx
addq $-0x2, %rcx
movl $0x1, %edx
movq (%rsp), %rdi
callq 0x9a5ee
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
movq (%rsp), %rbx
je 0x941d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x941d1
movq (%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rdx
cmpq %rdx, %rcx
je 0x941c2
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x941c8
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x941e5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x94204
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18b2e
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x9459e
movq %r12, 0x28(%r14)
movq %rsp, %rdi
callq 0x26cee
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x26cee
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x98ad1
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 0x26e44
movq 0x30(%rbx), %rax
movq %rax, 0x8(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdi, %r14
jae 0x98afc
leaq 0x848ab(%rip), %r15     # 0x11d388
movq %r14, %rdi
movq %r15, %rsi
callq 0x9a61e
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %r12, %rax
jb 0x98add
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9a61e
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e3f2
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 0x36954
movq %r14, %rdi
movq %r12, %rsi
callq 0x943fa
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x98b7c
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 0x6e3f2
cmpl $0x18, %ebp
jb 0x98b8c
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x98c16
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 0x36954
movq %r14, %rdi
movq %r15, %rsi
callq 0x943fa
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x98bfc
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 0x98bc1
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x98c37
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x98c48
movq (%r13), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e3f2
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 0x36954
movq %r12, %rdi
movq %r15, %rsi
callq 0x943fa
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x992b4
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 0x6e3f2
cmpl $0x18, %r15d
jb 0x992ba
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 0x6e3f2
cmpl $0x18, %ebp
jb 0x992e6
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x99345
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 0x6e3f2
cmpl $0x18, %ebp
jb 0x99315
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
ja 0x9930c
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 0x9936e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e3f2
movq %rbx, %rdi
movl %r12d, %esi
callq 0x6e3f2
movl $0xfffffff8, %r12d      # imm = 0xFFFFFFF8
addl $0x8, %r12d
movl %ebp, %eax
movl %r12d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6e3f2
cmpl $0x18, %r12d
jb 0x9945f
movq 0x60(%r15), %rdi
movq %r14, %rsi
callq 0x93f48
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 0x6e3f2
cmpl $0x18, %r14d
jb 0x9948f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e3f2
movl $0xfffffff8, %r13d      # imm = 0xFFFFFFF8
addl $0x8, %r13d
movl %r12d, %eax
movl %r13d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0x6e3f2
cmpl $0x18, %r13d
jb 0x9968c
movl $0xfffffff8, %r12d      # imm = 0xFFFFFFF8
addl $0x8, %r12d
movl %ebp, %eax
movl %r12d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0x6e3f2
cmpl $0x18, %r12d
jb 0x996af
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 0x36954
movq %rbx, %rdi
movq %r14, %rsi
callq 0x943fa
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9970d
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 0x99736
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e3f2
movq 0x28(%r14), %r12
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
movq %r15, %rdi
xorl %esi, %esi
callq 0x6e3f2
addl $0x8, %ebp
cmpl $0x18, %ebp
jb 0x99b32
movl 0x28(%r14), %eax
movq %r14, (%rbx)
movl %r12d, 0x8(%rbx)
movl %eax, 0xc(%rbx)
leaq 0x99d(%rip), %rax       # 0x9a4f6
movq %rax, 0x18(%rbx)
leaq 0x9a6(%rip), %rax       # 0x9a50a
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e3f2
movl $0xfffffff8, %r12d      # imm = 0xFFFFFFF8
addl $0x8, %r12d
movl %ebp, %eax
movl %r12d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0x6e3f2
cmpl $0x18, %r12d
jb 0x99b9b
movq 0x28(%r14), %r12
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
movq %r15, %rdi
xorl %esi, %esi
callq 0x6e3f2
addl $0x8, %ebp
cmpl $0x18, %ebp
jb 0x99bc0
movl 0x28(%r14), %eax
movq %r14, (%rbx)
movl %r12d, 0x8(%rbx)
movl %eax, 0xc(%rbx)
leaq 0x94b(%rip), %rax       # 0x9a532
movq %rax, 0x18(%rbx)
leaq 0x954(%rip), %rax       # 0x9a546
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e3f2
movl $0xfffffff8, %r13d      # imm = 0xFFFFFFF8
addl $0x8, %r13d
movl %ebp, %eax
movl %r13d, %ecx
sarl %cl, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x6e3f2
cmpl $0x18, %r13d
jb 0x99d06
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 0x36954
movq %r15, %rdi
movq %r12, %rsi
callq 0x943fa
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x99d66
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 0x6e3f2
cmpl $0x18, %ebp
jb 0x99d76
testl %r15d, %r15d
jle 0x99dcd
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 0x6e3f2
cmpl $0x18, %ebp
jb 0x99dab
incq %r12
cmpq %r15, %r12
jne 0x99d9f
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 0x99df6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e3f2
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 0x36954
movq %r14, %rdi
movq %r12, %rsi
callq 0x943fa
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x99e6a
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 0x6e3f2
cmpl $0x18, %ebp
jb 0x99e7a
testl %r12d, %r12d
jle 0x99ef6
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 0x36954
movq %r14, %rdi
movq %r15, %rsi
callq 0x943fa
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x99eed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x20, %rbp
decq %r12
jne 0x99eaf
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x99f17
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x99f28
movq (%r13), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e3f2
movq 0x28(%r14), %r12
movl $0xfffffff8, %ebp       # imm = 0xFFFFFFF8
movq %r15, %rdi
xorl %esi, %esi
callq 0x6e3f2
addl $0x8, %ebp
cmpl $0x18, %ebp
jb 0x99f66
movq $0x0, 0x8(%rbx)
movq %r14, (%rbx)
movl %r12d, 0x8(%rbx)
leaq 0x5e0(%rip), %rax       # 0x9a56e
movq %rax, 0x18(%rbx)
leaq 0x5e7(%rip), %rax       # 0x9a580
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_O3/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 0x80f3e(%rip), %rsi     # 0x11cf98
leaq 0x8(%rsp), %rdi
callq 0x112c0
leaq 0x88(%rsp), %rdi
callq 0x11120
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
jmp 0x9c07e
movq %rax, %rbx
movq 0x80f10(%rip), %rsi     # 0x11cf98
leaq 0x8(%rsp), %rdi
callq 0x112c0
leaq 0x88(%rsp), %rdi
callq 0x11120
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9e169
cmpl $0x2b, %eax
je 0x9e104
cmpl $0x2a, %eax
jne 0x9e1b2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
jmp 0x9e1cd
movq %rsp, %rdi
callq 0x11280
leaq 0x10(%rsp), %r15
movsbq 0x8(%r14), %rax
leaq 0x7df13(%rip), %rcx     # 0x11c030
movq (%rcx,%rax,8), %r12
movq %r12, %rdi
callq 0x11190
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x113c0
leaq 0x31437(%rip), %rsi     # 0xcf575
movl $0x1, %edx
movq %r15, %rdi
callq 0x113c0
movzbl 0x8(%r14), %eax
cmpb $0x2, %al
jg 0x9e1dd
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x11330
jmp 0x9e237
addq $0x18, %r14
leaq 0x313da(%rip), %r15     # 0xcf54e
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x9f216
movq %r12, %rdi
movq %r15, %rsi
callq 0x27406
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x9e1ef
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x9e1f5
shlq $0x5, %rax
leaq 0x7f8b3(%rip), %rcx     # 0x11da70
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x36954
jmp 0x9e260
cmpl $0x4, %eax
je 0x9e229
cmpl $0x3, %eax
jne 0x9e237
cvtss2sd 0x10(%r14), %xmm0
jmp 0x9e22f
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 0x9e260
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x9e260
movsd 0x10(%r14), %xmm0
movq %r15, %rdi
callq 0x114f0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x112b0
movq 0x7ed4d(%rip), %rsi     # 0x11cf98
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 0x9e2b1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x9e2b1
movq %rax, %rbx
movq 0x7ecfc(%rip), %rsi     # 0x11cf98
movq %rsp, %rdi
callq 0x112c0
leaq 0x80(%rsp), %rdi
callq 0x11120
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9f002
leal 0x1(%rcx), %edx
movl %edx, 0x30(%r14)
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
jmp 0x9f009
leaq 0x7f187(%rip), %rax     # 0x11e190
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 0x36954
cmpl %ebx, -0x28(%r15)
je 0x9f169
cmpq $0x0, 0x60(%r14)
je 0x9f057
leaq 0x50(%r14), %rdi
callq *0x68(%r14)
testb %al, %al
je 0x9f169
movq 0x7df92(%rip), %rdi     # 0x11cff0
leaq 0x303f5(%rip), %rsi     # 0xcf45a
movl $0x7, %edx
callq 0x113c0
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq 0x7df72(%rip), %rdi     # 0x11cff0
callq 0x113c0
movq %rax, %r14
leaq 0x1e1fc(%rip), %rsi     # 0xbd289
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movl 0x24(%rsp), %esi
movq %r14, %rdi
callq 0x11550
movq %rax, %r14
leaq 0x303b2(%rip), %rsi     # 0xcf462
movl $0x1b, %edx
movq %rax, %rdi
callq 0x113c0
movl %ebx, %eax
shlq $0x5, %rax
leaq 0x7e9a6(%rip), %rcx     # 0x11da70
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %r14, %rdi
callq 0x113c0
movq %rax, %rbx
leaq 0x30399(%rip), %rsi     # 0xcf47e
movl $0x7, %edx
movq %rax, %rdi
callq 0x113c0
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x9e0c2
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x113c0
movq %rax, %rbx
leaq 0x3036c(%rip), %rsi     # 0xcf486
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 0x9f169
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x9f180
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x9f1ac
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9f1af
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x9f1af
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x9f1c6
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x7ea94(%rip)     # 0x11e1f0
cmpl $0x0, 0x7ea91(%rip)     # 0x11e1f4
jne 0x9f84c
movq %rdi, %rbx
movq 0x7d87d(%rip), %r14     # 0x11cff0
leaq 0x2fce0(%rip), %rsi     # 0xcf45a
movl $0x7, %edx
movq %r14, %rdi
callq 0x113c0
movq 0x7ea42(%rip), %rsi     # 0x11e1d0
movq 0x7ea43(%rip), %rdx     # 0x11e1d8
movq %r14, %rdi
callq 0x113c0
movq %rax, %r14
leaq 0x1dae2(%rip), %rsi     # 0xbd289
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movl 0x4(%rbx), %esi
movq %r14, %rdi
callq 0x11550
movq %rax, %r14
leaq 0x2fd71(%rip), %rsi     # 0xcf53a
movl $0x15, %edx
movq %rax, %rdi
callq 0x113c0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9e0c2
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x113c0
movq %rax, %rbx
leaq 0x2fd51(%rip), %rsi     # 0xcf54e
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 0x9f84c
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 0x9f874
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x7e962(%rip)     # 0x11e1f0
cmpl $0x0, 0x7e95f(%rip)     # 0x11e1f4
jne 0x9f9d7
movq %rsi, %rbx
movq %rdi, %r14
movq 0x7d748(%rip), %r15     # 0x11cff0
leaq 0x2fbab(%rip), %rsi     # 0xcf45a
movl $0x7, %edx
movq %r15, %rdi
callq 0x113c0
movq 0x7e90d(%rip), %rsi     # 0x11e1d0
movq 0x7e90e(%rip), %rdx     # 0x11e1d8
movq %r15, %rdi
callq 0x113c0
movq %rax, %r15
leaq 0x1d9ad(%rip), %rsi     # 0xbd289
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x11550
movq %rax, %r15
leaq 0x2fc51(%rip), %rsi     # 0xcf550
movl $0x14, %edx
movq %rax, %rdi
callq 0x113c0
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x9e0c2
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x113c0
movq %rax, %r14
leaq 0x2fc2e(%rip), %rsi     # 0xcf565
movl $0xe, %edx
movq %rax, %rdi
callq 0x113c0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x9e0c2
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x113c0
movq %rax, %rbx
leaq 0x2fbe1(%rip), %rsi     # 0xcf54e
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 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9f9bc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9f9d7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x9f9e5
movq %rax, %rbx
jmp 0x9fa08
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fa08
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11360
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fa23
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7e789(%rip), %rsi     # 0x11e1d0
movq %rbx, %rdi
callq 0xa70f2
movq 0xe8(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x99f3e
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0x9fa7e
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r15
jmp 0x9fa68
movq 0x130(%rbx), %rax
cmpq 0x128(%rbx), %rax
je 0x9fb3e
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
xorl %r13d, %r13d
movq 0xe8(%rbx), %rsi
movq %r14, %rdi
callq 0x99b0a
movq 0x128(%rbx), %rax
movl (%rax,%r13,4), %eax
movl %eax, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x9fb93
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%rsp)
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x9faed
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0xe8(%rbx), %rdi
movq 0x140(%rbx), %rbp
callq 0x99f3a
movl %eax, 0x8(%rsp)
cmpq $0x0, 0x10(%rbp,%r12)
je 0x9fb98
leaq (%r12,%rbp), %rdi
movq %r14, %rsi
callq *0x18(%rbp,%r12)
movq 0x130(%rbx), %rax
subq 0x128(%rbx), %rax
incq %r13
sarq $0x2, %rax
addq $0x20, %r12
cmpq %r13, %rax
ja 0x9faa2
movl 0xe0(%rbx), %eax
movl %eax, 0x8(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x9fb9d
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq *0x18(%rdi)
movq 0xe8(%rbx), %rdi
callq 0x99f30
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x9fb82
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x11150
callq 0x11150
callq 0x11150
jmp 0x9fbf4
jmp 0x9fbd0
jmp 0x9fbf4
jmp 0x9fbd0
jmp 0x9fbae
jmp 0x9fbd0
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x9fbd3
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x9fbd3
jmp 0x9fbf4
jmp 0x9fbd0
movq %rax, %rbx
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x9fbec
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x26e38
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0x7e5e0(%rip)     # 0x11e1f4
movb $0x0, 0x7e5d5(%rip)     # 0x11e1f0
movq %rsi, %rdi
callq 0x9f1da
testb %al, %al
jne 0x9fc73
testb $0x1, 0x7e5c2(%rip)     # 0x11e1f0
jne 0x9fc73
addq $0x10, %r14
movq %rsp, %r15
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa329c
movq %r12, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa6aac
movq %rbx, %rdi
callq 0x9f1da
testb %al, %al
jne 0x9fc73
testb $0x1, 0x7e57f(%rip)     # 0x11e1f0
je 0x9fc37
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x60, %esi
movq %r12, %rdi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %esi, %esi
jle 0x9fccd
movq 0x7d318(%rip), %r15     # 0x11cfc8
leaq 0x2f8bd(%rip), %r12     # 0xcf574
movl %ebx, %ebp
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x113c0
decl %ebp
jne 0x9fcb9
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0x9fceb
movq (%r15), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x8(%rax)
addq $0x8, %r15
jmp 0x9fcd5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7ba1b(%rip), %rax     # 0x11c068
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
leaq 0x28(%rdi), %r12
movq %r12, %rdi
callq 0x9e04c
leaq 0x7bbf2(%rip), %rax     # 0x11c268
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
cmpb $0x0, 0x7db65(%rip)     # 0x11e1f0
jne 0xa06f4
movq %r15, %rdi
callq 0x9ef78
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movups (%rax), %xmm0
movups %xmm0, (%r12)
leaq 0x40(%rbx), %rdi
addq $0x18, %rax
movq %rax, %rsi
callq 0x39678
movl (%r12), %eax
leal -0x1a(%rax), %ecx
cmpl $0x4, %ecx
jb 0xa06c7
cmpl $0x27, %eax
jne 0xa0700
movl $0x1, 0x8(%rbx)
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xa0638
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xa6aac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x9f1ce
movl $0x60, %edi
callq 0x11350
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0xa0314
movq %rsp, %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xa6aac
jmp 0xa06f4
jmp 0xa0734
jmp 0xa0761
movq %rax, %r15
movl $0x60, %esi
movq %r12, %rdi
callq 0x11360
jmp 0xa0764
jmp 0xa0761
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa076c
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xa076c
movq %rax, %r15
movq %rbx, %rdi
callq 0x9fcf4
movq %r15, %rdi
callq 0x11580