LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::RawGetField(TypeID, void*, std::basic_string_view<char, std::char_traits<char>>)
ObjectPtr ReflMgr::RawGetField(TypeID type, void* instance, std::string_view member) {
    std::function<void*(void*)> conv = [](void* orig) { return orig; };
    auto* p = SafeGetFieldWithInherit(&conv, type, member);
    if (p == nullptr) {
        return ObjectPtr::Null;
    }
    return p->getRegister(conv(instance));
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rcx, 0xe0(%rsp)
movq %r8, 0xe8(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
leaq 0xaf(%rsp), %rsi
callq 0x4b6f0
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movups 0xe0(%rsp), %xmm0
movaps %xmm0, 0x70(%rsp)
movq 0x70(%rsp), %rdx
movq 0x78(%rsp), %rcx
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movq %rsp, %rax
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %r8d
callq 0x4ab60
movq %rax, 0x58(%rsp)
jmp 0x4b629
movq 0x58(%rsp), %rax
movq %rax, 0xa0(%rsp)
cmpq $0x0, 0xa0(%rsp)
jne 0x4b67b
movq 0x30(%rsp), %rdi
leaq 0x2b5de3(%rip), %rsi    # 0x301430
callq 0x1e110
jmp 0x4b654
movl $0x1, 0x60(%rsp)
jmp 0x4b6c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x56a00
jmp 0x4b6e0
movq 0xa0(%rsp), %rax
addq $0x78, %rax
movq %rax, 0x20(%rsp)
movq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
callq 0x563f0
movq %rax, 0x28(%rsp)
jmp 0x4b6a8
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x192870
jmp 0x4b6be
movl $0x1, 0x60(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x56a00
movq 0x38(%rsp), %rax
addq $0xf8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x133f0
nopw (%rax,%rax)
// File: Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::GetInvokeFunc(TypeID, std::basic_string_view<char, std::char_traits<char>>, ArgsTypeList)
std::function<void(void*, std::vector<void*>, SharedObject& ret)> ReflMgr::GetInvokeFunc(TypeID type, std::string_view member, ArgsTypeList list) {
    std::function<void*(void*)> conv = [](void* orig) { return orig; };
    auto* info = SafeGetMethodWithInherit(&conv, type, member, list);
    if (info == nullptr || info->name == "") {
        return nullptr;
    }
    return [info, conv](void* instance, std::vector<void*> params, SharedObject& ret) {
        info->getRegister(conv(instance), params, ret);
    };
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %r8, 0x58(%rsp)
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
leaq 0x130(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x120(%rsp)
movq %rdx, 0x110(%rsp)
movq %rcx, 0x118(%rsp)
movq %rsi, 0x108(%rsp)
movq %r8, 0x100(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
leaq 0xdf(%rsp), %rsi
callq 0x4b980
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %r8
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movups 0x110(%rsp), %xmm0
movaps %xmm0, 0xa0(%rsp)
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rcx
movaps 0xb0(%rsp), %xmm0
movaps 0xc0(%rsp), %xmm1
movq %rsp, %rax
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %r9d
callq 0x4adf0
movq %rax, 0x60(%rsp)
jmp 0x4b86c
movq 0x60(%rsp), %rax
movq %rax, 0xd0(%rsp)
cmpq $0x0, 0xd0(%rsp)
je 0x4b8a8
movq 0xd0(%rsp), %rdi
leaq 0x1d5433(%rip), %rsi    # 0x220cc6
callq 0x56430
movb %al, 0x2f(%rsp)
jmp 0x4b89e
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x4b8a8
jmp 0x4b8df
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1928d0
movl $0x1, 0x90(%rsp)
jmp 0x4b948
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x4b962
movq 0xd0(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x191b10
jmp 0x4b900
movq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4ba10
jmp 0x4b911
leaq 0x68(%rsp), %rdi
callq 0x4bac0
movl $0x1, 0x90(%rsp)
jmp 0x4b948
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x4bac0
jmp 0x4b962
leaq 0xe0(%rsp), %rdi
callq 0x56a00
movq 0x38(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
leaq 0xe0(%rsp), %rdi
callq 0x56a00
movq 0x98(%rsp), %rdi
callq 0x133f0
nopl (%rax)
// File: Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::RawInvoke(TypeID, void*, std::basic_string_view<char, std::char_traits<char>>, ArgsTypeList, std::vector<void*, std::allocator<void*>>)
SharedObject ReflMgr::RawInvoke(TypeID type, void* instance, std::string_view member, ArgsTypeList list, std::vector<void*> params) {
    std::function<void*(void*)> conv = [](void* orig) { return orig; };
    auto* info = SafeGetMethodWithInherit(&conv, type, member, list);
    if (info == nullptr || info->name == "") {
        return SharedObject::Null;
    }
    auto ret = info->newRet();
    info->getRegister(conv(instance), params, ret);
    return ret;
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %r9, 0x68(%rsp)
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x130(%rsp), %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x120(%rsp)
movq %rcx, 0x110(%rsp)
movq %r8, 0x118(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq %r9, 0xf8(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0xd8(%rsp), %rdi
movq %rdi, 0x60(%rsp)
leaq 0xd7(%rsp), %rsi
callq 0x4bd40
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %r8
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movups 0x110(%rsp), %xmm0
movaps %xmm0, 0x90(%rsp)
movq 0x90(%rsp), %rdx
movq 0x98(%rsp), %rcx
movaps 0xa0(%rsp), %xmm0
movaps 0xb0(%rsp), %xmm1
movq %rsp, %rax
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl $0x1, %r9d
callq 0x4adf0
movq %rax, 0x70(%rsp)
jmp 0x4bbe1
movq 0x70(%rsp), %rax
movq %rax, 0xc8(%rsp)
cmpq $0x0, 0xc8(%rsp)
je 0x4bc1d
movq 0xc8(%rsp), %rdi
leaq 0x1d50be(%rip), %rsi    # 0x220cc6
callq 0x56430
movb %al, 0x37(%rsp)
jmp 0x4bc13
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0x4bc1d
jmp 0x4bc59
movq 0x38(%rsp), %rdi
leaq 0x2b57cf(%rip), %rsi    # 0x3013f8
callq 0x1e520
jmp 0x4bc30
movl $0x1, 0x80(%rsp)
jmp 0x4bd03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x4bd1d
movq 0x38(%rsp), %rdi
movb $0x0, 0x7f(%rsp)
movq 0xc8(%rsp), %rsi
addq $0x78, %rsi
callq 0x56470
jmp 0x4bc76
movq 0xc8(%rsp), %rax
addq $0x58, %rax
movq %rax, 0x20(%rsp)
movq 0x100(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
callq 0x563f0
movq %rax, 0x28(%rsp)
jmp 0x4bca3
movq 0x38(%rsp), %rcx
movq 0x48(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x564c0
jmp 0x4bcbe
movb $0x1, 0x7f(%rsp)
movl $0x1, 0x80(%rsp)
testb $0x1, 0x7f(%rsp)
jne 0x4bd01
jmp 0x4bcf7
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
callq 0x23b00
jmp 0x4bd1d
movq 0x38(%rsp), %rdi
callq 0x23b00
jmp 0x4bd03
leaq 0xd8(%rsp), %rdi
callq 0x56a00
movq 0x40(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
leaq 0xd8(%rsp), %rdi
callq 0x56a00
movq 0x88(%rsp), %rdi
callq 0x133f0
nopw (%rax,%rax)
// File: Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::AddVirtualInheritance(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>)
void ReflMgr::AddVirtualInheritance(std::string_view cls, std::string_view inherit) {
    ClassInfo& info = classInfo[TypeID::getRaw(cls)];
    info.parents.push_back(TypeID::getRaw(inherit));
    info.cast.push_back([](void* derived) -> void* {
        return derived;
    });
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rsi, 0xf8(%rsp)
movq %rdx, 0x100(%rsp)
movq %rcx, 0xe8(%rsp)
movq %r8, 0xf0(%rsp)
movq %rdi, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
addq $0x90, %rax
movq %rax, 0x8(%rsp)
movups 0xf8(%rsp), %xmm0
movaps %xmm0, 0xa0(%rsp)
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x18fed0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1927b0
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
movups 0xe8(%rsp), %xmm0
movaps %xmm0, 0x70(%rsp)
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
leaq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x18fed0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x56310
movq 0xd8(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
leaq 0x4f(%rsp), %rsi
callq 0x4c0a0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x192960
jmp 0x4c06a
leaq 0x50(%rsp), %rdi
callq 0x56a00
addq $0x108, %rsp            # imm = 0x108
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x56a00
movq 0x40(%rsp), %rdi
callq 0x133f0
nop
// File: Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::GetMethodInfo[abi:cxx11](TypeID, std::basic_string_view<char, std::char_traits<char>>, ArgsTypeList const&)
TagList& ReflMgr::GetMethodInfo(TypeID cls, std::string_view name, const ArgsTypeList& args) {
    auto& infos = methodInfo[cls][std::string{name}];
    MethodInfo* rec[3] = { nullptr, nullptr, nullptr };
    for (auto& info : infos) {
        CheckParams(info, args, rec);
    }
    for (int i = 0; i < 3; i++) {
        if (rec[i] != nullptr) {
            return rec[i]->tags;
        }
    }
    return nullTag;
}

// Assembly:
subq $0xd8, %rsp
movq %rsi, %rax
leaq 0xe0(%rsp), %rsi
movq %rax, 0xc0(%rsp)
movq %rdx, 0xc8(%rsp)
movq %rdi, 0xb8(%rsp)
movq %rcx, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x58, %rdi
callq 0x190140
movq %rax, 0x18(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x13570
movq 0x20(%rsp), %rdx
leaq 0x88(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x52e80
jmp 0x4c38b
movq 0x18(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1905c0
movq %rax, 0x8(%rsp)
jmp 0x4c3a4
leaq 0x88(%rsp), %rdi
callq 0x52f50
leaq 0x87(%rsp), %rdi
callq 0x136a0
movq 0x8(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x131c0
movq 0xa8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x191340
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x191370
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1913a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x4c41e
jmp 0x4c492
leaq 0x40(%rsp), %rdi
callq 0x1913e0
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movq 0xb0(%rsp), %rdx
leaq 0x50(%rsp), %rcx
xorl %r8d, %r8d
callq 0x190940
leaq 0x40(%rsp), %rdi
callq 0x1913f0
jmp 0x4c407
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x4c483
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x52f50
leaq 0x87(%rsp), %rdi
callq 0x136a0
jmp 0x4c4f4
movl $0x0, 0x2c(%rsp)
cmpl $0x3, 0x2c(%rsp)
jge 0x4c4d5
movslq 0x2c(%rsp), %rax
cmpq $0x0, 0x50(%rsp,%rax,8)
je 0x4c4c6
movslq 0x2c(%rsp), %rax
movq 0x50(%rsp,%rax,8), %rax
addq $0x20, %rax
movq %rax, 0xd0(%rsp)
jmp 0x4c4e4
jmp 0x4c4c8
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x4c49a
leaq 0x2b50bc(%rip), %rax    # 0x301598
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
addq $0xd8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x133f0
nop
// File: Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::RawInvoke(ObjectPtr, std::basic_string_view<char, std::char_traits<char>>, std::vector<ObjectPtr, std::allocator<ObjectPtr>> const&)
SharedObject ReflMgr::RawInvoke(ObjectPtr instance, std::string_view name, const std::vector<ObjectPtr>& params) {
    ArgsTypeList list;
    std::vector<void*> args;
    for (auto param : params) {
        args.push_back(param.GetRawPtr());
        list.push_back(param.GetType());
    }
    return RawInvoke(instance.GetType(), instance.GetRawPtr(), name, list, args);
}

// Assembly:
subq $0x198, %rsp            # imm = 0x198
movq %rdx, 0x40(%rsp)
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x190(%rsp)
movq %rcx, 0x180(%rsp)
movq %r8, 0x188(%rsp)
movq %rsi, 0x178(%rsp)
movq %rdx, 0x170(%rsp)
movq %r9, 0x168(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x150(%rsp), %rdi
callq 0x56250
leaq 0x138(%rsp), %rdi
callq 0x57a30
movq 0x168(%rsp), %rax
movq %rax, 0x130(%rsp)
movq 0x130(%rsp), %rdi
callq 0x56260
movq %rax, 0x128(%rsp)
movq 0x130(%rsp), %rdi
callq 0x56290
movq %rax, 0x120(%rsp)
leaq 0x128(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x562c0
xorb $-0x1, %al
testb $0x1, %al
jne 0x4d38a
jmp 0x4d43c
leaq 0x128(%rsp), %rdi
callq 0x56300
movq %rax, %rsi
leaq 0xf8(%rsp), %rdi
callq 0x1e110
jmp 0x4d3a9
leaq 0xf8(%rsp), %rdi
callq 0x1e280
movq %rax, 0x38(%rsp)
jmp 0x4d3bd
movq 0x38(%rsp), %rax
movq %rax, 0xe0(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x57a60
jmp 0x4d3e1
leaq 0xc0(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x1e240
jmp 0x4d3f8
leaq 0x150(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x56310
jmp 0x4d40f
jmp 0x4d411
leaq 0x128(%rsp), %rdi
callq 0x56340
jmp 0x4d36a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0x4d560
movq 0x40(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x1e240
jmp 0x4d450
movq 0x40(%rsp), %rdi
callq 0x1e280
movq %rax, 0x30(%rsp)
jmp 0x4d461
movups 0x180(%rsp), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x725b0
jmp 0x4d485
leaq 0x60(%rsp), %rdi
leaq 0x138(%rsp), %rsi
callq 0x192d10
jmp 0x4d499
movq 0x30(%rsp), %rdx
movq 0x58(%rsp), %rsi
movq 0x48(%rsp), %rdi
movq 0x90(%rsp), %rcx
movq 0x98(%rsp), %r8
movups 0xa0(%rsp), %xmm0
movups 0xb0(%rsp), %xmm1
movq %rsp, %rax
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x60(%rsp), %r9
movq %r9, 0x20(%rax)
leaq 0x78(%rsp), %r9
callq 0x4bae0
jmp 0x4d4e7
leaq 0x60(%rsp), %rdi
callq 0x568a0
leaq 0x78(%rsp), %rdi
callq 0x56a10
leaq 0x138(%rsp), %rdi
callq 0x568a0
leaq 0x150(%rsp), %rdi
callq 0x56a10
movq 0x50(%rsp), %rax
addq $0x198, %rsp            # imm = 0x198
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0x4d556
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x568a0
leaq 0x78(%rsp), %rdi
callq 0x56a10
leaq 0x138(%rsp), %rdi
callq 0x568a0
leaq 0x150(%rsp), %rdi
callq 0x56a10
movq 0xf0(%rsp), %rdi
callq 0x133f0
nopw (%rax,%rax)
// File: Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::IterateField(TypeID, std::function<void (FieldInfo const&)>)
void ReflMgr::IterateField(TypeID cls, std::function<void(const FieldInfo&)> callback) {
    std::function<void*(void*)> conv = [](void* orig) { return orig; };
    cls = GetType(cls.getName());
    WalkThroughInherits(&conv, cls, std::function([&](TypeID type) -> FieldInfo* {
        auto* lst = SafeGetList(fieldInfo, cls);
        if (lst == nullptr) {
            return nullptr;
        }
        for (auto& field : *lst) {
            callback(field.second);
        }
        return nullptr;
    }));
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rsi, 0x20(%rsp)
leaq 0x120(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0xe7(%rsp), %rsi
callq 0x4e030
movq 0x30(%rsp), %rdi
callq 0x2b420
movq %rdx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
jmp 0x4def1
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, 0xb0(%rsp)
movq %rax, 0xb8(%rsp)
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
leaq 0xc0(%rsp), %rdi
callq 0x4a300
jmp 0x4df2a
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rdx
movups 0xc0(%rsp), %xmm0
movups 0xca(%rsp), %xmm1
movups %xmm1, 0xa(%rcx)
movups %xmm0, (%rcx)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movaps %xmm1, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x4e0c0
jmp 0x4df87
movq 0x28(%rsp), %rdi
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movq %rsp, %rax
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0xe8(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x191590
jmp 0x4dfba
leaq 0x60(%rsp), %rdi
callq 0x192330
leaq 0xe8(%rsp), %rdi
callq 0x56a00
addq $0x118, %rsp            # imm = 0x118
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x4e00d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x192330
leaq 0xe8(%rsp), %rdi
callq 0x56a00
movq 0xa8(%rsp), %rdi
callq 0x133f0
nopw (%rax,%rax)
// File: 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:
subq $0x118, %rsp            # imm = 0x118
movq %rsi, 0x20(%rsp)
leaq 0x120(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0xe7(%rsp), %rsi
callq 0x4e310
movq 0x30(%rsp), %rdi
callq 0x2b420
movq %rdx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
jmp 0x4e1d1
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rcx, 0xb0(%rsp)
movq %rax, 0xb8(%rsp)
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
leaq 0xc0(%rsp), %rdi
callq 0x4a300
jmp 0x4e20a
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rdx
movups 0xc0(%rsp), %xmm0
movups 0xca(%rsp), %xmm1
movups %xmm1, 0xa(%rcx)
movups %xmm0, (%rcx)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movaps %xmm1, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x4e3a0
jmp 0x4e267
movq 0x28(%rsp), %rdi
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movq %rsp, %rax
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0xe8(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x191df0
jmp 0x4e29a
leaq 0x60(%rsp), %rdi
callq 0x194700
leaq 0xe8(%rsp), %rdi
callq 0x56a00
addq $0x118, %rsp            # imm = 0x118
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x4e2ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x194700
leaq 0xe8(%rsp), %rdi
callq 0x56a00
movq 0xa8(%rsp), %rdi
callq 0x133f0
nopw (%rax,%rax)
// File: 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:
subq $0xe8, %rsp
leaq 0x110(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x88(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x194710
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x194740
jmp 0x4e4a9
jmp 0x4e4ab
leaq 0x88(%rsp), %rdi
callq 0x194770
movb %al, 0x2f(%rsp)
jmp 0x4e4be
movb 0x2f(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4e4cd
jmp 0x4e602
leaq 0x88(%rsp), %rdi
callq 0x194790
movq %rax, 0x20(%rsp)
jmp 0x4e4e1
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x2b4b0
movb %al, 0x1f(%rsp)
jmp 0x4e4f6
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x4e500
jmp 0x4e538
movb $0x1, 0xe7(%rsp)
movl $0x1, 0x78(%rsp)
jmp 0x4e612
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x194810
jmp 0x4e630
movq 0x38(%rsp), %rax
addq $0x90, %rax
movq %rax, 0x8(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x194790
movq %rax, 0x10(%rsp)
jmp 0x4e55c
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x6b980
movq %rax, (%rsp)
jmp 0x4e571
movq (%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1947a0
jmp 0x4e589
movq 0x70(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x56f40
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x56d60
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1947b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x4e5cc
jmp 0x4e5fd
leaq 0x60(%rsp), %rdi
callq 0x57490
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x194740
jmp 0x4e5ef
jmp 0x4e5f1
leaq 0x60(%rsp), %rdi
callq 0x1947f0
jmp 0x4e5b5
jmp 0x4e4ab
movb $0x0, 0xe7(%rsp)
movl $0x1, 0x78(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x194810
movb 0xe7(%rsp), %al
andb $0x1, %al
addq $0xe8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x133f0
nopl (%rax)
// File: Heptagon196[P]Gos/Reflection/./TypeID.h
// Function: TypeID::calculateHash(std::basic_string_view<char, std::char_traits<char>>)
static constexpr size_t calculateHash(std::string_view s) {
            size_t hash = sizeof(size_t) == 8 ? 0xcbf29ce484222325 : 0x811c9dc5;
            const size_t prime = sizeof(size_t) == 8 ? 0x00000100000001b3 : 0x01000193;
            for (char ch : s) {
                hash ^= (size_t)ch;
                hash *= prime;
            }
            return hash;
        }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x40(%rsp)
movabsq $-0x340d631b7bdddcdb, %rax # imm = 0xCBF29CE484222325
movq %rax, 0x30(%rsp)
movabsq $0x100000001b3, %rax    # imm = 0x100000001B3
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x54c80
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x54c90
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x54c70
movq 0x18(%rsp), %rax
movb (%rax), %al
movb %al, 0xf(%rsp)
movsbq 0xf(%rsp), %rax
xorq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movabsq $0x100000001b3, %rax    # imm = 0x100000001B3
imulq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x54c24
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x6b8f0
movq (%rsp), %rdi
addq $0x90, %rdi
leaq 0x18(%rsp), %rsi
callq 0x6b980
movq %rax, %rdi
addq $0x88, %rdi
leaq 0x17(%rsp), %rsi
callq 0x6b9b0
movq (%rsp), %rdi
addq $0x90, %rdi
leaq 0x18(%rsp), %rsi
callq 0x6b980
movq 0x8(%rsp), %rsi
movq %rax, %rdi
addq $0x50, %rdi
callq 0x6ba00
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: Heptagon196[P]Gos/Reflection/./ReflMgr.h
// Function: auto ReflMgr::GetLambdaRegisterFunc<ObjectPtr, ObjectPtr, ObjectPtr const&, 0ul>(std::function<ObjectPtr& (ObjectPtr*, ObjectPtr const&)>, std::integer_sequence<unsigned long, 0ul>)::'lambda'(void*, std::vector<void*, std::allocator<void*>> const&, SharedObject&)::operator()(void*, std::vector<void*, std::allocator<void*>> const&, SharedObject&) const
auto GetLambdaRegisterFunc(std::function<Ret&(Type*, Args...)> func, std::index_sequence<N...> is) {
            return [func](void* instance, const std::vector<void*>& params, SharedObject& ret) {
                ret = SharedObject{ TypeID::get<Ret&>(),
                    (void*)(
                        &(func((Type*)instance, *(reinterpret_cast<typename std::remove_reference<Args>::type*>(params[N]))...))
                    )
                };
            };
        }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7c070
movq 0x98(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x90(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x72220
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rax), %rdx
callq 0x7cac0
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x1e590
movq 0x88(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x52cd0
leaq 0x50(%rsp), %rdi
callq 0x23b00
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x10(%rsp)
movq %rdi, 0x1b0(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x131b0
movq 0x10(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x131a0
jmp 0x164a0f
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x13680
jmp 0x164a20
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x13240
movl 0xc(%rsp), %eax
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x13240
movq 0x20(%rsp), %rdi
callq 0x133f0
// File: Heptagon196[P]Gos/Reflection/JSON.cpp
// Function: Tokenizer::getChar()
char getChar() {
        char ret;
        if (ch != 0) {
            ret = ch;
            ch = 0;
            return ret;
        }
        ret = in.get();
        return ret;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movsbl 0x8(%rax), %eax
cmpl $0x0, %eax
je 0x165346
movq 0x8(%rsp), %rax
movb 0x8(%rax), %cl
movb %cl, 0x17(%rsp)
movb $0x0, 0x8(%rax)
movb 0x17(%rsp), %al
movb %al, 0x27(%rsp)
jmp 0x16535f
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x13560
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdx, 0x40(%rsp)
leaq 0x1f0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x1b0(%rsp), %rdi
callq 0x1a1640
movq 0x40(%rsp), %rdx
movups 0x1b0(%rsp), %xmm0
movups 0x1ba(%rsp), %xmm1
movups %xmm1, 0xa2(%rdx)
movups %xmm0, 0x98(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x190(%rsp)
movq $0x0, 0x1a0(%rsp)
leaq 0x190(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x56250
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0xb8, %rdi
callq 0x70660
movq 0x20(%rsp), %rdi
callq 0x56a10
movq 0x28(%rsp), %rdi
movq 0x1d8(%rsp), %rsi
callq 0x1a16d0
movq 0x40(%rsp), %rdi
addq $0x78, %rdi
leaq 0x18f(%rsp), %rsi
callq 0x1a16e0
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rdx
movq 0x30(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movaps %xmm1, 0x170(%rsp)
movaps %xmm0, 0x160(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x1d8(%rsp), %rsi
callq 0x1a1730
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x48(%rsp)
leaq 0x68(%rsp), %rsi
callq 0x1a1760
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x4a210
movq %rax, 0x50(%rsp)
jmp 0x1a1596
movq 0x50(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x703f0
jmp 0x1a15aa
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdi
movaps 0x160(%rsp), %xmm0
movaps 0x170(%rsp), %xmm1
movq %rsp, %rax
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x90(%rsp), %rdx
movl $0x1, %ecx
callq 0x4a7f0
jmp 0x1a15e2
leaq 0x90(%rsp), %rdi
callq 0x70530
leaq 0x70(%rsp), %rdi
callq 0x70000
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1a162c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x70530
leaq 0x70(%rsp), %rdi
callq 0x70000
movq 0x60(%rsp), %rdi
callq 0x133f0
// File: Heptagon196[P]Gos/Reflection/./ReflMgr.h
// Function: auto ReflMgr::GetStaticMethodRegisterFunc<ReflMgr>(ReflMgr& (*)(), std::integer_sequence<unsigned long, ...>)::'lambda'(void*, std::vector<void*, std::allocator<void*>> const&, SharedObject&)::operator()(void*, std::vector<void*, std::allocator<void*>> const&, SharedObject&) const
auto GetStaticMethodRegisterFunc(Ret& (*func)(Args...), std::index_sequence<N...> is) {
            return [func](void*, const std::vector<void*>& params, SharedObject& ret) {
                ret = SharedObject{ TypeID::get<Ret&>(),
                    (void*)(
                        &(func(*(reinterpret_cast<typename std::remove_reference<Args>::type*>(params[N]))...))
                    )
                };
            };
        }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1a1640
movq 0x28(%rsp), %rax
callq *(%rax)
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x1e590
movq 0x88(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x52cd0
leaq 0x50(%rsp), %rdi
callq 0x23b00
addq $0xa8, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x18, %rdi
movq 0x50(%rsp), %rsi
callq 0x1b4750
movq 0x18(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x18, %rdi
callq 0x1b4780
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1b4730
testb $0x1, %al
jne 0x1a8fe6
jmp 0x1a906e
movq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1b47e0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1b47b0
jmp 0x1a900b
leaq 0x30(%rsp), %rdi
callq 0x7a5f0
movq 0x18(%rsp), %rdi
callq 0x1b4860
movq 0x18(%rsp), %rdi
subq $0x1, %rax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
movq 0x50(%rsp), %rsi
callq 0x1b4880
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rdi
movl %ecx, (%rax)
callq 0x1b4860
subq $0x1, %rax
movl %eax, 0x64(%rsp)
jmp 0x1a9087
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7a5f0
jmp 0x1a9090
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movq 0x50(%rsp), %rsi
callq 0x1b4880
movl (%rax), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x133f0
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x1b47e0
movq 0x20(%rsp), %rdi
movslq 0x64(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x1b4860
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x1a910d
movq 0x20(%rsp), %rdi
movslq 0x64(%rsp), %rsi
callq 0x1b48b0
movq %rax, %rdi
leaq 0x50(%rsp), %rsi
callq 0x1b48d0
jmp 0x1a919d
jmp 0x1a910f
movq 0x20(%rsp), %rdi
movslq 0x64(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x1b4860
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jbe 0x1a917a
xorl %eax, %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1b4900
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1b47b0
jmp 0x1a9154
leaq 0x40(%rsp), %rdi
callq 0x7a5f0
jmp 0x1a910f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x7a5f0
jmp 0x1a91d9
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1b4920
jmp 0x1a918b
jmp 0x1a919d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x1a91d9
movq 0x20(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x18, %rdi
movq 0x68(%rsp), %rsi
callq 0x1b4880
movq %rax, 0x8(%rsp)
jmp 0x1a91bf
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x50(%rsp), %rdi
callq 0x7a5f0
addq $0x78, %rsp
retq
leaq 0x50(%rsp), %rdi
callq 0x7a5f0
movq 0x38(%rsp), %rdi
callq 0x133f0
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x68, %rdi
leaq 0x28(%rsp), %rsi
callq 0x1b49b0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x68, %rdi
callq 0x1b49e0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b4990
testb $0x1, %al
jne 0x1a9243
jmp 0x1a929d
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
leaq 0x28(%rsp), %rsi
callq 0x1b4a10
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x1b4a80
movq 0x8(%rsp), %rdi
subq $0x1, %rax
movl %eax, 0x4(%rsp)
addq $0x68, %rdi
leaq 0x28(%rsp), %rsi
callq 0x1b4aa0
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, (%rax)
addq $0x50, %rdi
callq 0x1b4a80
subq $0x1, %rax
movl %eax, 0x34(%rsp)
jmp 0x1a92b6
movq 0x8(%rsp), %rdi
addq $0x68, %rdi
leaq 0x28(%rsp), %rsi
callq 0x1b4aa0
movl (%rax), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movslq 0x34(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x50, %rdi
callq 0x1b4a80
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x1a9319
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
movslq 0x34(%rsp), %rsi
callq 0x1b4ad0
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x1a936d
jmp 0x1a931b
movq 0x18(%rsp), %rdi
movslq 0x34(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x50, %rdi
callq 0x1b4a80
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jbe 0x1a935a
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
movb $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x1b4af0
jmp 0x1a931b
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
leaq 0x40(%rsp), %rsi
callq 0x1b4a10
movq 0x18(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x68, %rdi
leaq 0x40(%rsp), %rsi
callq 0x1b4aa0
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x13570
movq 0x30(%rsp), %rdx
leaq 0x778a0(%rip), %rsi     # 0x220cc6
leaq 0x58(%rsp), %rdi
callq 0x165520
jmp 0x1a9432
leaq 0x57(%rsp), %rdi
callq 0x136a0
movb $0x0, 0x42(%rsp)
movb $0x0, 0x41(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x13560
movl %eax, 0x14(%rsp)
jmp 0x1a945a
movl 0x14(%rsp), %eax
movb %al, 0x43(%rsp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x1a951b
movsbl 0x43(%rsp), %eax
cmpl $0x22, %eax
jne 0x1a94dc
testb $0x1, 0x42(%rsp)
jne 0x1a94c5
movb $0x1, 0x42(%rsp)
movb $0x1, 0x41(%rsp)
jmp 0x1a94da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x136a0
jmp 0x1a9591
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x52f50
jmp 0x1a9591
leaq 0x777d2(%rip), %rsi     # 0x220c9e
leaq 0x58(%rsp), %rdi
callq 0x168410
jmp 0x1a94d8
jmp 0x1a951b
jmp 0x1a94dc
movsbl 0x43(%rsp), %eax
cmpl $0x20, %eax
je 0x1a94fa
movsbl 0x43(%rsp), %eax
cmpl $0xa, %eax
je 0x1a94fa
movsbl 0x43(%rsp), %eax
cmpl $0xd, %eax
jne 0x1a9505
testb $0x1, 0x42(%rsp)
jne 0x1a9503
jmp 0x1a951b
jmp 0x1a9505
movsbl 0x43(%rsp), %esi
leaq 0x58(%rsp), %rdi
callq 0x168440
jmp 0x1a9516
jmp 0x1a9446
movq 0x28(%rsp), %rax
movb 0x43(%rsp), %cl
movb %cl, (%rax)
testb $0x1, 0x41(%rsp)
je 0x1a9563
leaq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x55060
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rcx
addq $-0x2, %rcx
movl $0x1, %edx
callq 0x1b4b20
jmp 0x1a9559
movl $0x1, 0x3c(%rsp)
jmp 0x1a957a
movq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x55130
movl $0x1, 0x3c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x52f50
movq 0x20(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x133f0
nopl (%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1b4ba0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rsi
movq 0x28(%rax), %rdx
movq %rdx, 0x68(%rsp)
movq %rcx, 0x28(%rax)
movb $0x0, 0x67(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1e110
jmp 0x1a9bd1
movq 0x18(%rsp), %rsi
movq (%rsp), %rdi
movq 0x88(%rsp), %rcx
leaq 0x38(%rsp), %rdx
callq 0x1a9c50
jmp 0x1a9bee
movq 0x18(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, 0x28(%rax)
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x1a9c2d
jmp 0x1a9c24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1b4c20
jmp 0x1a9c44
movq (%rsp), %rdi
callq 0x23b00
leaq 0x70(%rsp), %rdi
callq 0x1b4c20
movq 0x8(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x133f0
nop
// File: 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:
subq $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movslq 0x2c(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x1b4f30
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x1b02cb
movq 0x10(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x1b4f50
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x52cd0
jmp 0x1b0303
jmp 0x1b02cd
movq 0x10(%rsp), %rdi
callq 0x1b4f30
movslq 0x2c(%rsp), %rcx
cmpq %rcx, %rax
jae 0x1b02f4
movq 0x10(%rsp), %rdi
leaq 0x15110b(%rip), %rsi    # 0x3013f8
callq 0x1b4bb0
jmp 0x1b02cd
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x1b4bb0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x1, %esi
callq 0x1a96f0
movq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6f070
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1a98d0
jmp 0x1b06c5
leaq 0x50(%rsp), %rdi
callq 0x52f50
movq 0x70(%rsp), %rdi
callq 0x6f4b0
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x1a9780
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
callq 0x6f4b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1b0789
movq 0x70(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0x1b5c10
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6f070
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1a98d0
jmp 0x1b073e
leaq 0x20(%rsp), %rdi
callq 0x52f50
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x1b06ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x52f50
jmp 0x1b0791
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x52f50
jmp 0x1b0791
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x133f0
nopl (%rax,%rax)
// File: Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::VMProgram::WriteCommandDefFunc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
std::function<void(int)> GosVM::VMProgram::WriteCommandDefFunc(const std::string& name, const std::string& retType, const std::vector<std::string>& paramTypes) {
    AddOperation(DEF_MEMBER_FUNC);
    AddParamString(name);
    AddParamString(retType);
    int len = paramTypes.size();
    AddParamInt(len);
    for (int i = 0; i < len; i++) {
        AddParamString(paramTypes[i]);
    }
    int pos = content.size();
    AddParamInt(0);
    int startJump = content.size();
    return [this, pos, startJump](int jmp) {
        *(int*)&content[pos] = jmp - startJump;
    };
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %r8, 0xc0(%rsp)
movq 0xd8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x4, %esi
callq 0x1a96f0
movq 0xd0(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x6f070
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1a98d0
jmp 0x1b08fe
leaq 0xa0(%rsp), %rdi
callq 0x52f50
movq 0xc8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6f070
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1a98d0
jmp 0x1b0933
leaq 0x70(%rsp), %rdi
callq 0x52f50
movq 0xc0(%rsp), %rdi
callq 0x6f4b0
movq 0x20(%rsp), %rdi
movl %eax, 0x6c(%rsp)
movl 0x6c(%rsp), %esi
callq 0x1a9780
movl $0x0, 0x68(%rsp)
movl 0x68(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jge 0x1b0a25
movq 0xc0(%rsp), %rdi
movslq 0x68(%rsp), %rsi
callq 0x1b5c10
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6f070
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1a98d0
jmp 0x1b09a5
leaq 0x48(%rsp), %rdi
callq 0x52f50
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x1b0964
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x52f50
jmp 0x1b0a8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x52f50
jmp 0x1b0a8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x52f50
jmp 0x1b0a8e
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x55060
movq 0x20(%rsp), %rdi
movl %eax, 0x44(%rsp)
xorl %esi, %esi
callq 0x1a9780
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x55060
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movq 0x20(%rsp), %rax
movl %ecx, 0x40(%rsp)
movq %rax, 0x30(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x3c(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x1b0aa0
movq 0x18(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0x98(%rsp), %rdi
callq 0x133f0
nopl (%rax,%rax)