LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: MethodInfo::sameDeclareTo(MethodInfo const&) const
bool MethodInfo::sameDeclareTo(const MethodInfo& other) const {
    if (returnType != other.returnType || argsList.size() != other.argsList.size()) {
        return false;
    }
    for (int i = 0; i < argsList.size(); i++) {
        if (argsList[i] != other.argsList[i]) {
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x98, %esi
addq %rsi, %rdi
addq %rbx, %rsi
callq 0x1ba2a
testb %al, %al
jne 0x1e204
movq 0xc0(%r14), %rax
subq 0xb8(%r14), %rax
movq 0xc0(%rbx), %rcx
subq 0xb8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x1e204
pushq $-0x1
popq %r15
xorl %esi, %esi
movq 0xb8(%r14), %rdi
movq 0xc0(%r14), %rax
subq %rdi, %rax
sarq $0x5, %rax
incq %r15
cmpq %r15, %rax
setbe %bpl
jbe 0x1e206
leaq 0x20(%rsi), %r12
addq %rsi, %rdi
addq 0xb8(%rbx), %rsi
callq 0x1ba2a
movq %r12, %rsi
testb %al, %al
je 0x1e1c7
jmp 0x1e206
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::SafeGetFieldWithInherit(std::function<void* (void*)>*, TypeID, std::basic_string_view<char, std::char_traits<char>>, bool)
const FieldInfo* ReflMgr::SafeGetFieldWithInherit(std::function<void*(void*)>* conv, TypeID id, std::string_view name, bool showError) {
    auto ret = WalkThroughInherits(conv, id, std::function([&](TypeID type) { return SafeGet(fieldInfo, type, name); }));
    if (ret == nullptr && showError) {
        ERROR << "Error: no matching field found: " << id.getName() << "::" << name << std::endl;
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %r8d, %ebp
movq %rdi, %r14
leaq 0x28(%rsp), %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
leaq 0x38(%rsp), %rdx
movq %rdi, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0x1b2b(%rip), %rax      # 0x1ff90
movq %rax, 0x18(%rdx)
leaq 0x1b56(%rip), %rax      # 0x1ffc6
movq %rax, 0x10(%rdx)
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x6f71a
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x21f04
testq %rbx, %rbx
setne %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0x1e516
leaq 0x80(%rsp), %r15
movq 0xe7b33(%rip), %rdi     # 0x105ff0
movq %r14, %rsi
callq 0x11320
leaq 0x79012(%rip), %rsi     # 0x974de
movq %rax, %rdi
callq 0x11340
movq %rax, %r14
movq %r15, %rdi
callq 0x1b9ce
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x113b0
leaq 0x77808(%rip), %rsi     # 0x95cfc
movq %rax, %rdi
callq 0x11340
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x113b0
movq %rax, %rdi
callq 0x111b0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x21f04
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::New(TypeID, std::vector<ObjectPtr, std::allocator<ObjectPtr>> const&)
SharedObject ReflMgr::New(TypeID type, const std::vector<ObjectPtr>& args) {
    auto& func = classInfo[TypeID::getRaw(removeNameRefAndConst(type.getName()))].newObject;
    if (func == 0) {
        ERROR << "Error: unable to init an unregistered class: " << type.getName() << std::endl;
        return SharedObject::Null;
    }
    return func(args);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x90(%rsi), %r13
callq 0x1b9ce
movq %rax, %rbp
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
xorl %r14d, %r14d
movq %rax, %rcx
movl $0x0, %eax
cmpq $0x7, %rbp
jb 0x1e7c4
leaq 0x18(%rsp), %r15
pushq $0x6
popq %rbx
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x2156c
leaq 0x78dec(%rip), %rcx     # 0x9758e
movq %rax, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x6661e
testb %al, %al
pushq $0x6
popq %rax
movl $0x0, %ecx
cmovel %ecx, %eax
movq (%r15), %rcx
movq 0x8(%r15), %rdx
xorl %edi, %edi
cmpb $0x26, -0x1(%rdx,%rcx)
sete %dil
movl %eax, %esi
subl %eax, %ebp
subl %edi, %ebp
testl %ebp, %ebp
cmovgl %ebp, %r14d
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2156c
movq %rax, %r14
movq %rdx, %r15
movq %rax, %rdi
movq %rdx, %rsi
callq 0x215c2
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
movq %r15, 0x10(%rbx)
andw $0x0, 0x18(%rbx)
leaq 0x18(%rsp), %rsi
movq %r13, %rdi
callq 0x737ca
cmpq $0x0, 0x98(%rax)
je 0x1e840
addq $0x88, %rax
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rdx
callq 0x70072
jmp 0x1e895
movq 0xe77a9(%rip), %rdi     # 0x105ff0
movq %r12, %rsi
callq 0x11320
leaq 0x78ccb(%rip), %rsi     # 0x97521
movq %rax, %rdi
callq 0x11340
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x1b9ce
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x113b0
movq %rax, %rdi
callq 0x111b0
leaq 0xe7af0(%rip), %rsi     # 0x106378
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x171ac
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %r8, %r9
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x175d(%rip), %rdx      # 0x20084
movq %rdx, 0x18(%rsi)
leaq 0x1756(%rip), %rdx      # 0x20088
movq %rdx, 0x10(%rsi)
movaps 0x60(%rsp), %xmm0
movaps 0x70(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %r8
movq %rax, %rdi
movq %rcx, %rdx
movq %r9, %rcx
callq 0x1e436
movq %rax, %r15
testq %rax, %rax
je 0x1e984
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x21c42
addq $0x78, %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7008a
jmp 0x1e993
leaq 0xe7a25(%rip), %rsi     # 0x1063b0
movq %rbx, %rdi
callq 0x16fc8
leaq 0x20(%rsp), %rdi
callq 0x21f04
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x21f04
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x16bf(%rip), %rdi      # 0x200a0
movq %rdi, 0x18(%rsi)
leaq 0x16b8(%rip), %rdi      # 0x200a4
movq %rdi, 0x10(%rsi)
movaps 0x90(%rsp), %xmm0
movaps 0xa0(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %r9
movq %rax, %rdi
callq 0x1e53a
movq %rax, %r15
testq %rax, %rax
je 0x1ea30
leaq 0x8ad92(%rip), %rsi     # 0xa97b6
movq %r15, %rdi
callq 0x21c5b
testb %al, %al
je 0x1ea3f
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x1eacc
leaq 0x50(%rsp), %r14
movq %r15, -0x8(%r14)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x6f9d6
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
pushq $0x28
popq %rdi
callq 0x11350
movq 0x48(%rsp), %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
movq 0x68(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x60(%rsp), %rcx
testq %rcx, %rcx
je 0x1eaab
movq %rax, %rdx
addq $0x8, %rdx
leaq 0x60(%rsp), %rsi
movups (%r14), %xmm0
movups %xmm0, (%rdx)
movq %rcx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq %rax, (%rbx)
leaq 0x1607(%rip), %rax      # 0x200bc
movq %rax, 0x18(%rbx)
leaq 0x166c(%rip), %rax      # 0x2012c
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x21f04
leaq 0x20(%rsp), %rdi
callq 0x21f04
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %rbx, %rdi
callq 0x21f04
movq %r14, %rdi
callq 0x21f04
jmp 0x1eafd
jmp 0x1eafa
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x21f04
movq %r15, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %r9, %r10
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x1689(%rip), %rdx      # 0x201c0
movq %rdx, 0x18(%rsi)
leaq 0x1682(%rip), %rdx      # 0x201c4
movq %rdx, 0x10(%rsi)
movaps 0x60(%rsp), %xmm0
movaps 0x70(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %r9
movq %rax, %rdi
movq %rcx, %rdx
movq %r8, %rcx
movq %r10, %r8
callq 0x1e53a
movq %rax, %r15
testq %rax, %rax
je 0x1eb89
leaq 0x8ac39(%rip), %rsi     # 0xa97b6
movq %r15, %rdi
callq 0x21c5b
testb %al, %al
je 0x1eb9a
leaq 0xe77e8(%rip), %rsi     # 0x106378
movq %rbx, %rdi
callq 0x171ac
jmp 0x1ebcd
leaq 0x78(%r15), %rsi
movq %rbx, %rdi
callq 0x21c68
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x21c42
movq 0x80(%rsp), %rdx
addq $0x58, %r15
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x21c80
leaq 0x20(%rsp), %rdi
callq 0x21f04
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x19b6c
jmp 0x1ebf4
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x21f04
movq %r14, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
addq $0x90, %r13
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x215c2
movq %rsp, %rbp
movq %rax, (%rbp)
movq %r12, 0x8(%rbp)
movq %r15, 0x10(%rbp)
andw $0x0, 0x18(%rbp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x737ca
movq %rax, %r15
leaq 0x20(%rax), %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x215c2
movq %rax, (%rbp)
movq %r14, 0x8(%rbp)
movq %rbx, 0x10(%rbp)
andw $0x0, 0x18(%rbp)
movq %rsp, %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x21f20
addq $0x38, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
leaq 0x1446(%rip), %rax      # 0x201dc
movq %rax, 0x18(%rbx)
leaq 0x143f(%rip), %rax      # 0x201e0
movq %rax, 0x10(%rbx)
movq %rsp, %rsi
movq %r15, %rdi
callq 0x73902
movq %rsp, %rdi
callq 0x21f04
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21f04
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r15
movq %rsi, (%r15)
movq %rdx, 0x8(%r15)
addq $0x58, %rdi
leaq 0x70(%rsp), %rsi
callq 0x71c2c
movq %rax, %r12
leaq 0x10(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x209a4
movq %r12, %rdi
movq %r13, %rsi
callq 0x72416
movq %rax, %r13
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x209be
andq $0x0, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq (%r13), %r12
movq 0x8(%r13), %r13
cmpq %r13, %r12
je 0x1ef7c
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x6f0ae
addq $0xd0, %r12
jmp 0x1ef5a
xorl %ecx, %ecx
leaq 0xe7593(%rip), %rax     # 0x106518
cmpq $0x3, %rcx
je 0x1ef9f
movq 0x10(%rsp,%rcx,8), %rdx
incq %rcx
testq %rdx, %rdx
je 0x1ef85
addq $0x20, %rdx
movq %rdx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209be
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::RawAddField(TypeID, TypeID, std::basic_string_view<char, std::char_traits<char>>, std::function<ObjectPtr (ObjectPtr)>)
void ReflMgr::RawAddField(TypeID cls, TypeID varType, std::string_view name, std::function<ObjectPtr(ObjectPtr)> func) {
    FieldInfo info{ std::string{name} };
    auto& field = fieldInfo[cls][std::string{name}];
    field = info.withRegister([func, cls](void* ptr) { return func(ObjectPtr{cls, ptr}); });
    field.varType = varType;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x140(%rsp), %r14
leaq 0x70(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x80(%rsp), %r12
leaq 0x30(%rsp), %rdx
movq %r12, %rdi
movq %rax, %rsi
callq 0x209a4
andq $0x0, 0x40(%r12)
leaq 0xd0(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, -0x8(%rax)
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
addq $0x20, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72020
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x209a4
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x72880
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x209be
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x70108
movups (%r14), %xmm0
movups 0xa(%r14), %xmm1
movups %xmm1, 0x5a(%rsp)
movups %xmm0, 0x50(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
pushq $0x40
popq %rdi
callq 0x11350
leaq 0xf8(%rsp), %rdi
leaq 0x50(%rsp), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq -0x8(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq -0x10(%rcx), %rdx
testq %rdx, %rdx
je 0x1f0f3
leaq 0x40(%rsp), %rsi
movups -0x10(%rsi), %xmm0
movups %xmm0, (%rax)
movq %rdx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x30(%rax)
movups %xmm0, 0x20(%rax)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10e7(%rip), %rax      # 0x201f8
movq %rax, 0x18(%rsi)
leaq 0x112a(%rip), %rax      # 0x20246
movq %rax, 0x10(%rsi)
callq 0x6ed18
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x7014e
leaq 0x160(%rsp), %r14
leaq 0x10(%rsp), %rdi
callq 0x21f04
leaq 0x30(%rsp), %rdi
callq 0x21f04
movups (%r14), %xmm0
movups 0xa(%r14), %xmm1
movups %xmm1, 0x62(%rbx)
movups %xmm0, 0x58(%rbx)
leaq 0x80(%rsp), %rdi
callq 0x70198
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1f198
jmp 0x1f193
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x209be
jmp 0x1f1af
jmp 0x1f193
movq %rax, %rbx
jmp 0x1f1af
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x21f04
leaq 0x30(%rsp), %rdi
callq 0x21f04
leaq 0x80(%rsp), %rdi
callq 0x70198
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::RawAddStaticField(TypeID, TypeID, std::basic_string_view<char, std::char_traits<char>>, std::function<ObjectPtr ()>)
void ReflMgr::RawAddStaticField(TypeID cls, TypeID varType, std::string_view name, std::function<ObjectPtr()> func) {
    FieldInfo info{ std::string{name} };
    auto& field = fieldInfo[cls][std::string{name}];
    field = info.withRegister([func](void* ptr) { return func(); });
    field.varType = varType;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x68(%rsp), %r15
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x209a4
andq $0x0, 0x40(%r15)
leaq 0xb8(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, -0x8(%rax)
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
addq $0x20, %rbx
leaq 0x120(%rsp), %rsi
movq %rbx, %rdi
callq 0x72020
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x209a4
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x72880
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209be
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x701b8
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
pushq $0x20
popq %rdi
callq 0x11350
leaq 0xe0(%rsp), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
testq %rcx, %rcx
je 0x1f2d6
leaq 0x20(%rsp), %rdx
movups -0x10(%rdx), %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xffd(%rip), %rax       # 0x202e2
movq %rax, 0x18(%rsi)
leaq 0x1004(%rip), %rax      # 0x202f4
movq %rax, 0x10(%rsi)
callq 0x6ed18
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x7014e
leaq 0x140(%rsp), %r14
leaq 0x30(%rsp), %rdi
callq 0x21f04
leaq 0x10(%rsp), %rdi
callq 0x21f04
movups (%r14), %xmm0
movups 0xa(%r14), %xmm1
movups %xmm1, 0x62(%rbx)
movups %xmm0, 0x58(%rbx)
leaq 0x68(%rsp), %rdi
callq 0x70198
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1f364
jmp 0x1f35f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209be
jmp 0x1f37b
jmp 0x1f35f
movq %rax, %rbx
jmp 0x1f37b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x21f04
leaq 0x10(%rsp), %rdi
callq 0x21f04
leaq 0x68(%rsp), %rdi
callq 0x70198
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %r8, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, 0x48(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, 0x40(%rsp)
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rbp
movaps %xmm0, (%rbp)
andq $0x0, 0x10(%rbp)
leaq 0x50(%rsp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq (%r9), %r15
movq 0x8(%r9), %r13
leaq 0x100(%rsp), %r12
leaq 0xe0(%rsp), %rbx
cmpq %r13, %r15
je 0x1f795
movq %r12, %rdi
movq %r15, %rsi
callq 0x16fc8
movq %r12, %rdi
callq 0x1703c
movq %rax, 0xe0(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22160
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17024
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x21f20
addq $0x28, %r15
jmp 0x1f74e
leaq 0xc0(%rsp), %rdi
movq 0x48(%rsp), %rbx
movq %rbx, %rsi
callq 0x17024
movq %rbx, %rdi
callq 0x1703c
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2c4a2
leaq 0xa8(%rsp), %r14
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x70244
movups 0xc0(%rsp), %xmm0
movups 0xd0(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, 0x20(%rsp)
leaq 0x90(%rsp), %r9
movq 0x40(%rsp), %r14
movq %r14, %rdi
movq 0x28(%rsp), %rsi
movq %rbx, %rdx
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
callq 0x1eb10
leaq 0xa8(%rsp), %rdi
callq 0x224ee
leaq 0x90(%rsp), %rdi
callq 0x22566
leaq 0x50(%rsp), %rdi
callq 0x224ee
leaq 0x70(%rsp), %rdi
callq 0x22566
movq %r14, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x224ee
jmp 0x1f879
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x22566
jmp 0x1f891
jmp 0x1f88e
jmp 0x1f88e
jmp 0x1f88e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x224ee
leaq 0x70(%rsp), %rdi
callq 0x22566
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::SelfExport()
void ReflMgr::SelfExport() {
    auto& mgr = Instance();
    mgr.AddStaticMethod(TypeID::get<ReflMgr>(), &ReflMgr::Instance, "Instance");
    mgr.AddMethod(&ReflMgr::RawAddField, "AddField");
    mgr.AddMethod(&ReflMgr::RawAddStaticField, "AddStaticField");
    mgr.AddMethod(MethodType<ObjectPtr, ReflMgr, ObjectPtr, std::string_view>::Type(&ReflMgr::RawGetField), "GetField");
    mgr.AddMethod(&ReflMgr::RawAddMethod, "AddMethod");
    mgr.AddMethod(MethodType<SharedObject, ReflMgr, ObjectPtr, std::string_view, const std::vector<ObjectPtr>&>::Type(&ReflMgr::RawInvoke), "Invoke");
    mgr.AddMethod(&ReflMgr::RawAddStaticMethod, "AddStaticMethod");
    mgr.AddMethod(&ReflMgr::RawInvokeStatic, "InvokeStatic");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
callq 0x1df9e
leaq -0x1c19(%rip), %r15     # 0x1df9e
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x7065c
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0xe686d(%rip), %rbx     # 0x106448
leaq 0x8af66(%rip), %rcx     # 0xaab48
pushq $0x8
popq %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x70546
leaq -0xc39(%rip), %rsi      # 0x1efc2
leaq 0x7794d(%rip), %r8      # 0x9754f
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x70698
leaq -0xa52(%rip), %rsi      # 0x1f1c4
leaq 0x7793b(%rip), %r8      # 0x97558
pushq $0xe
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7078c
leaq -0x8a3(%rip), %rsi      # 0x1f38e
leaq 0x763c4(%rip), %r8      # 0x95ffc
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %rcx
callq 0x70880
leaq -0x852(%rip), %rsi      # 0x1f3fa
leaq 0x77914(%rip), %r8      # 0x97567
pushq $0x9
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x70974
leaq -0x579(%rip), %rsi      # 0x1f6ee
leaq 0x76387(%rip), %r8      # 0x95ff5
pushq $0x6
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x70a68
leaq -0x3d4(%rip), %rsi      # 0x1f8ae
leaq 0x778e8(%rip), %r8      # 0x97571
pushq $0xf
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x70b5c
leaq -0x129(%rip), %rsi      # 0x1fb74
leaq 0x778dd(%rip), %r8      # 0x97581
pushq $0xc
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x70c50
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xa0(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
leaq 0xa3f(%rip), %rax       # 0x20724
movq %rax, 0x58(%rsp)
leaq 0xa37(%rip), %rax       # 0x20728
movq %rax, 0x50(%rsp)
movq %r14, %rdi
callq 0x1b9ce
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x1dffc
movups 0x60(%rsp), %xmm0
movups 0x6a(%rsp), %xmm1
movups %xmm1, 0xa(%r14)
movups %xmm0, (%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
pushq $0x18
popq %rdi
callq 0x11350
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x9f3(%rip), %rax       # 0x20740
movq %rax, 0x18(%rdx)
leaq 0xa40(%rip), %rax       # 0x20798
movq %rax, 0x10(%rdx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f71a
leaq 0x20(%rsp), %rdi
callq 0x21f04
leaq 0x40(%rsp), %rdi
callq 0x21f04
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1fd9e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x21f04
jmp 0x1fdb0
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x21f04
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::IterateMethod(TypeID, std::function<void (MethodInfo const&)>)
void ReflMgr::IterateMethod(TypeID cls, std::function<void(const MethodInfo&)> callback) {
    std::function<void*(void*)> conv = [](void* orig) { return orig; };
    cls = GetType(cls.getName());
    WalkThroughInherits(&conv, cls, std::function([&](TypeID type) -> MethodInfo* {
        auto* lst = SafeGetList(methodInfo, cls);
        if (lst == nullptr) {
            return nullptr;
        }
        for (auto& method : *lst) {
            for (auto& overloads : method.second) {
                callback(overloads);
            }
        }
        return nullptr;
    }));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xa0(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
leaq 0xa0d(%rip), %rax       # 0x207f8
movq %rax, 0x58(%rsp)
leaq 0xa05(%rip), %rax       # 0x207fc
movq %rax, 0x50(%rsp)
movq %r14, %rdi
callq 0x1b9ce
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x1dffc
movups 0x60(%rsp), %xmm0
movups 0x6a(%rsp), %xmm1
movups %xmm1, 0xa(%r14)
movups %xmm0, (%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
pushq $0x18
popq %rdi
callq 0x11350
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x9c1(%rip), %rax       # 0x20814
movq %rax, 0x18(%rdx)
leaq 0xa28(%rip), %rax       # 0x20886
movq %rax, 0x10(%rdx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x6fb1c
leaq 0x20(%rsp), %rdi
callq 0x21f04
leaq 0x40(%rsp), %rdi
callq 0x21f04
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1fea4
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x21f04
jmp 0x1feb6
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x21f04
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::IsBaseClass(TypeID, TypeID)
bool ReflMgr::IsBaseClass(TypeID query, TypeID base) {
    std::queue<TypeID> q;
    q.push(query);
    while (!q.empty()) {
        if (q.front() == base) {
            return true;
        }
        auto& info = classInfo[q.front()];
        q.pop();
        for (auto& id : info.parents) {
            q.push(id);
        }
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x70d44
leaq 0x80(%rsp), %rsi
movq %r14, %rdi
callq 0x7557a
leaq 0xa0(%rsp), %r14
addq $0x90, %rbx
movq %rsp, %r15
movq 0x10(%rsp), %r12
movq 0x30(%rsp), %r13
cmpq %r12, %r13
je 0x1ff59
movq %r12, %rdi
movq %r14, %rsi
callq 0x1ba12
testb %al, %al
jne 0x1ff59
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2aae8
movq %rax, %r13
movq %r15, %rdi
callq 0x757c0
movq 0x20(%r13), %r12
movq 0x28(%r13), %r13
cmpq %r13, %r12
je 0x1ff05
movq %r15, %rdi
movq %r12, %rsi
callq 0x7557a
addq $0x20, %r12
jmp 0x1ff43
cmpq %r12, %r13
setne %bl
movq %rsp, %rdi
callq 0x71a92
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1ff7d
jmp 0x1ff7d
jmp 0x1ff7d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x71a92
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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:
movabsq $-0x340d631b7bdddcdb, %rax # imm = 0xCBF29CE484222325
xorl %ecx, %ecx
movabsq $0x100000001b3, %rdx    # imm = 0x100000001B3
cmpq %rcx, %rdi
je 0x215ee
movsbq (%rsi,%rcx), %r8
xorq %r8, %rax
imulq %rdx, %rax
incq %rcx
jmp 0x215d8
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Reflection/./ReflMgr.h
// Function: void ReflMgr::AddClass<ObjectPtr>(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>)
void AddClass(TagList tagList = {}) {
            auto type = TypeID::get<T>();
            classInfo[type].newObject = [](const std::vector<ObjectPtr>& args) -> SharedObject {
                auto obj = SharedObject{TypeID::get<T>(), std::make_shared<T>(), false};
                obj.ctor(args);
                return obj;
            };
            classInfo[type].tags = tagList;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x2aa52
addq $0x90, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2aae8
leaq 0x88(%rax), %rdi
leaq 0xf(%rsp), %rsi
callq 0x2aa8e
movq %r14, %rdi
movq %r15, %rsi
callq 0x2aae8
leaq 0x50(%rax), %rdi
movq %rbx, %rsi
callq 0x2b298
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Reflection/./ReflMgr.h
// Function: void ReflMgr::AddMethod<ObjectPtr, SharedObject, ObjectPtr const&>(std::function<SharedObject (ObjectPtr*, ObjectPtr const&)>, MethodInfo)
void AddMethod(std::function<Ret(Type*, Args...)> func, MethodInfo info) {
            info.returnType = TypeID::get<Ret>();
            info.argsList = ArgsTypeList{TypeID::get<Args>()...};
            info.newRet = GetNewRet(func);
            AddMethodInfo(TypeID::get<Type>(), info.name, info.withRegister(GetLambdaRegisterFunc(func)));
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0x2bca0
movups (%r12), %xmm0
movups 0xa(%r12), %xmm1
movups %xmm1, 0xa2(%rbx)
movups %xmm0, 0x98(%rbx)
movups 0xd59e0(%rip), %xmm0    # 0x1013d0
movaps %xmm0, 0x10(%r12)
movups 0xd59c3(%rip), %xmm0    # 0x1013c0
movaps %xmm0, (%r12)
leaq 0xb0(%rsp), %r12
leaq 0x30(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x2f(%rsp), %rcx
movq %r12, %rdi
callq 0x2bde8
leaq 0xb8(%rbx), %rdi
movq %r12, %rsi
callq 0x2bea6
movq %r12, %rdi
callq 0x22566
leaq 0xc8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2bb66
leaq 0x78(%rbx), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2bcdc
movq %r12, %rdi
callq 0x21f04
leaq 0x90(%rsp), %rdi
callq 0x2aa52
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2bb66
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2bd20
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2bd8a
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x1df8c
leaq 0xe8(%rsp), %rdi
movq %rax, %rsi
callq 0x2bbac
movups 0x90(%rsp), %xmm0
movups 0xa0(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0xe8(%rsp), %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e212
leaq 0xe8(%rsp), %rdi
callq 0x2bc6c
leaq 0x50(%rsp), %rdi
callq 0x21f04
leaq 0x30(%rsp), %rdi
callq 0x21f04
leaq 0x70(%rsp), %rdi
callq 0x21f04
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0x2bc6c
jmp 0x2bb40
movq %rax, %rbx
jmp 0x2bb4a
movq %rax, %rbx
jmp 0x2bb54
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x21f04
leaq 0x30(%rsp), %rdi
callq 0x21f04
leaq 0x70(%rsp), %rdi
callq 0x21f04
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x2e0b0
movq (%r14), %rax
movq (%rax), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2e334
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x171e2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x208e6
movq %r14, %rdi
callq 0x19b6c
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/Reflection/JSON.cpp
// Function: float ConvertTo<float, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
T ConvertTo(U orig) {
    std::stringstream ss;
    ss << orig;
    T ret;
    ss >> ret;
    return ret;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11270
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x11320
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x115c0
movss 0x4(%rsp), %xmm0
movss %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x112c0
movss (%rsp), %xmm0
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
jmp 0x661b5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x112c0
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x6eec2
testq %rax, %rax
je 0x6efc1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x27(%rsp), %rdx
callq 0x209a4
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x72346
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x209be
testq %r14, %r14
je 0x6efc1
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x27(%rsp), %rdx
callq 0x209a4
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x72416
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x209be
jmp 0x6efc3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
jmp 0x6efd2
jmp 0x6efe1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x209be
jmp 0x6efe4
movq %rax, %rbx
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x158, %rsp            # imm = 0x158
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x73dd8
movups (%r12), %xmm0
movups 0xa(%r12), %xmm1
movups %xmm1, 0xa2(%rbx)
movups %xmm0, 0x98(%rbx)
leaq 0xb8(%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
leaq 0x40(%rsp), %r12
movq %r12, %rsi
callq 0x2bea6
movq %r12, %rdi
callq 0x22566
leaq 0x78(%rbx), %rdi
leaq 0x40(%rsp), %rsi
callq 0x73e16
movaps 0x180(%rsp), %xmm0
movaps 0x190(%rsp), %xmm1
leaq 0x68(%rsp), %rsi
andq $0x0, 0x8(%rsi)
movaps %xmm0, 0x20(%rsp)
movaps %xmm1, 0x30(%rsp)
movq %r15, (%rsi)
leaq 0x15d(%rip), %rax       # 0x73e96
movq %rax, 0x18(%rsi)
leaq 0x158(%rip), %rax       # 0x73e9c
movq %rax, 0x10(%rsi)
leaq 0x58(%rbx), %rdi
callq 0x6ed66
leaq 0x88(%rsp), %rdi
movq %rbx, %rsi
callq 0x2bbac
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x88(%rsp), %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e212
leaq 0x88(%rsp), %rdi
callq 0x2bc6c
leaq 0x68(%rsp), %rdi
callq 0x21f04
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x2bc6c
jmp 0x73dc5
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x21f04
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x73dd8
callq *(%r14)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x171e2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x208e6
movq %r14, %rdi
callq 0x19b6c
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7a3e8
testq %rax, %rax
je 0x75857
movq %r15, %rdi
movq %r14, %rsi
callq 0x7a76e
movl (%rax), %eax
jmp 0x758a5
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x798ba
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7a572
leaq 0x10(%rsp), %rdi
callq 0x21624
movq 0x8(%rbx), %r12
subq (%rbx), %r12
shrq $0x4, %r12
decl %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x7a76e
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
leaq 0x10(%rsp), %rdi
callq 0x21624
movq %rbx, %rdi
callq 0x11570
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdi
callq 0x798ba
movslq %ebx, %rbp
movq (%r15), %rdi
movq 0x8(%r15), %rax
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
cmpq %rbp, %rcx
jbe 0x7590e
shlq $0x4, %rbp
addq %rbp, %rdi
movq %rsp, %rsi
callq 0x79f38
jmp 0x75953
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
subq %rdi, %rax
sarq $0x4, %rax
cmpq %rbp, %rax
jae 0x75948
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x7a572
movq %r12, %rdi
callq 0x21624
movq (%r15), %rdi
movq 0x8(%r15), %rax
jmp 0x75918
movq %rsp, %rsi
movq %r15, %rdi
callq 0x798d8
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7a76e
movl %ebx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x21624
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7598d
movq %rax, %rbx
movq %r12, %rdi
callq 0x21624
leaq 0x8(%rsp), %rdi
callq 0x21624
movq %rbx, %rdi
callq 0x11570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
leaq 0x68(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x7ac08
testq %rax, %rax
je 0x759d4
movq %rsp, %rsi
movq %r14, %rdi
callq 0x7ade8
movl (%rax), %eax
jmp 0x75a0e
leaq 0x50(%rbx), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x79904
movq 0x58(%rbx), %r12
subq 0x50(%rbx), %r12
shrq $0x3, %r12
decl %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x7ade8
movl %r12d, (%rax)
movq 0x58(%rbx), %rax
subq 0x50(%rbx), %rax
shrq $0x3, %rax
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Heptagon196[P]Gos/GosVM.cpp
// Function: GosVM::RTConst::setNumID(GosVM::RTConstNum, int)
void GosVM::RTConst::setNumID(RTConstNum s, int id) {
    if (id < nums.size()) {
        nums[id] = s;
    } else {
        while (id > nums.size()) {
            nums.push_back({});
        }
        nums.push_back(s);
    }
    numMap[s] = id;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
movq %rsi, (%rsp)
movslq %edx, %r13
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r13, %rdx
jbe 0x75a50
movq %rsi, (%rax,%r13,8)
jmp 0x75a8a
leaq 0x50(%r14), %r15
leaq 0x8(%rsp), %r12
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
jae 0x75a7f
movb $0x0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x7b0ee
movq 0x50(%r14), %rax
movq 0x58(%r14), %rcx
jmp 0x75a59
movq %rsp, %rsi
movq %r15, %rdi
callq 0x79904
addq $0x68, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x7ade8
movl %ebx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop