LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/QZzcoder[P]LiveChat/SocketManager.cpp
// Function: splitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
vector<string> splitString(string s,char flag){
    vector<string> ret;

    for(int i = 0;i<s.size();i++){
        if(s[i] == flag){
            ret.push_back(s.substr(0,i));
            ret.push_back(s.substr(i+1,s.size()-i-1));
            return ret;
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2f8d
movq %rsi, %r14
movq (%rsi), %rcx
negq %rax
movl $0x1, %r15d
cmpb %dl, -0x1(%rcx,%r15)
je 0x2f2c
leaq (%rax,%r15), %rsi
incq %rsi
incq %r15
cmpq $0x1, %rsi
jne 0x2f13
jmp 0x2f8d
leaq -0x1(%r15), %rcx
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2200
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3030
leaq -0x30(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x2f5d
callq 0x21a0
movl %r15d, %edx
movq 0x8(%r14), %rcx
subq %r15, %rcx
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x2200
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3030
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2f8d
callq 0x21a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
jne 0x2fbd
jmp 0x2fc7
jmp 0x2fc4
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fc7
callq 0x21a0
jmp 0x2fc7
movq %rax, %r14
movq %rbx, %rdi
callq 0x2fd8
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Reflection/Object.cpp
// Function: operator<<(std::ostream&, ObjectPtr const&)
std::ostream& operator << (std::ostream& out, const ObjectPtr& ptr) {
    auto obj = ptr.Invoke(MetaMethods::operator_tostring, {});
    if (obj.GetType() != TypeID::get<std::string>()) {
        return out;
    }
    out << obj.Get<std::string>();
    return out;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
callq 0x227b2
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
leaq 0x70(%rsp), %rdx
movaps %xmm1, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq 0x20(%r14), %rcx
movq %rcx, 0x20(%rdx)
movl $0x1, (%rsp)
leaq 0x9f930(%rip), %r8      # 0xbbdb4
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %r9
movl $0xa, %ecx
movq %rax, %rsi
callq 0x263cc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c4b2
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
leaq 0x70(%rsp), %rdi
movaps %xmm1, 0x10(%rdi)
movaps %xmm0, (%rdi)
movabsq $-0x22bfd0b2172c96aa, %rax # imm = 0xDD402F4DE8D36956
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq $0x17, 0x8(%rsi)
leaq 0x9f949(%rip), %rax     # 0xbbe32
movq %rax, 0x10(%rsi)
movw $0x0, 0x18(%rsi)
callq 0x1f66c
testb %al, %al
jne 0x1c51a
movq 0x68(%rsp), %rax
testq %rax, %rax
jne 0x1c50b
movq 0x58(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x113c0
leaq 0x38(%rsp), %rdi
callq 0x1c65c
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
jmp 0x1c534
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1c65c
jmp 0x1c55d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c55d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Reflection/ReflMgrInit.cpp
// Function: ReflMgrTool::InitModules()
void InitModules() {
        auto& mgr = ReflMgr::Instance();
        mgr.SelfExport();
        // ObjectPtr SharedObject
#define DEFOBJ(Obj)                                                  \
        mgr.AddMethod(&Obj::Invoke, "Invoke");                       \
        mgr.AddMethod(&Obj::GetField, "GetField");                   \
        mgr.AddMethod(&Obj::GetType, "GetType");                     \
        mgr.AddMethod(&Obj::tostring, "tostring");                   \
        mgr.AddMethod(&Obj::ctor, "ctor");                           \
        mgr.AddMethod(&Obj::dtor, "dtor");                           \

        DEFOBJ(ObjectPtr);
        DEFOBJ(SharedObject);
#undef DEFOBJ
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x227b2
movq %rax, %rbx
movq %rax, %rdi
callq 0x24e8e
leaq -0x42d2(%rip), %rsi     # 0x18c1c
leaq 0x9f0d9(%rip), %r8      # 0xbbfce
movl $0x6, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x337fe
leaq -0x4341(%rip), %rsi     # 0x18bca
leaq 0x9f0c3(%rip), %r15     # 0xbbfd5
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %r8
callq 0x339e6
leaq -0x43a1(%rip), %rsi     # 0x18b8a
leaq 0x9f0ac(%rip), %r12     # 0xbbfde
movl $0x7, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %r8
callq 0x33bce
leaq -0x1327(%rip), %rsi     # 0x1bc24
leaq 0x9ee64(%rip), %r13     # 0xbbdb6
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r13, %r8
callq 0x33db6
leaq -0x12a1(%rip), %rsi     # 0x1bcca
leaq 0x9ee4f(%rip), %rbp     # 0xbbdc1
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %rbp, %r8
callq 0x33f9e
leaq -0x125b(%rip), %rsi     # 0x1bd30
leaq 0x9ee36(%rip), %r14     # 0xbbdc8
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %r8
callq 0x34186
leaq -0x3f5f(%rip), %rsi     # 0x1904c
movl $0x6, %ecx
movq %rbx, %rdi
xorl %edx, %edx
leaq 0x9f012(%rip), %r8      # 0xbbfce
callq 0x3436e
leaq -0x4044(%rip), %rsi     # 0x18f84
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %r8
callq 0x34556
leaq -0x40a5(%rip), %rsi     # 0x18f3c
movl $0x7, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %r8
callq 0x3473e
leaq -0x2b04(%rip), %rsi     # 0x1a4f6
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r13, %r8
callq 0x34926
leaq -0x418f(%rip), %rsi     # 0x18e84
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %rbp, %r8
callq 0x34b0e
leaq -0x2a4e(%rip), %rsi     # 0x1a5de
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34cf6
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Reflection/JSON.cpp
// Function: JSON::Init()
void JSON::Init() {
    ReflMgr::Instance().AddMethod<JSON>(std::function([](JSON* self) -> std::string {
        return self->obj.tostring().As<std::string>();
    }), MetaMethods::operator_tostring);
    ReflMgr::Instance().AddMethod<std::vector<JSON>>(std::function([](std::vector<JSON>* self) -> std::string {
        std::stringstream ss;
        printVec(ss, *self);
        return ss.str();
    }), MetaMethods::operator_tostring);
    ReflMgr::Instance().AddMethod<std::unordered_map<std::string, JSON>>(std::function([](std::unordered_map<std::string, JSON>* self) -> std::string {
        std::stringstream ss;
        printMap(ss, *self);
        return ss.str();
    }), MetaMethods::operator_tostring);
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
callq 0x227b2
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x171c(%rip), %rcx      # 0x1ee74
movq %rcx, 0x18(%rsi)
leaq 0x1771(%rip), %rcx      # 0x1eed4
movq %rcx, 0x10(%rsi)
leaq 0x9e646(%rip), %rcx     # 0xbbdb4
movl $0xa, %edx
movq %rax, %rdi
callq 0x86cd4
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x1d794
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x227b2
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x1741(%rip), %rcx      # 0x1eeec
movq %rcx, 0x18(%rsi)
leaq 0x1888(%rip), %rcx      # 0x1f03e
movq %rcx, 0x10(%rsi)
leaq 0x9e5f3(%rip), %rcx     # 0xbbdb4
movl $0xa, %edx
movq %rax, %rdi
callq 0x86f0c
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1d7e7
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x227b2
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x1ab6(%rip), %rcx      # 0x1f2b2
movq %rcx, 0x18(%rsi)
leaq 0x1cc5(%rip), %rcx      # 0x1f4cc
movq %rcx, 0x10(%rsi)
leaq 0x9e5a2(%rip), %rcx     # 0xbbdb4
movl $0xa, %edx
movq %rax, %rdi
callq 0x87144
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1d836
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x60, %rsp
popq %rbx
retq
jmp 0x1d8a4
jmp 0x1d8a4
jmp 0x1d8a4
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1d89c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d89c
jmp 0x1d8a4
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1d89c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d89c
jmp 0x1d8a4
movq %rax, %rbx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x1d89c
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x26e38
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Reflection/JSON.cpp
// Function: JSON::JSON(std::basic_string_view<char, std::char_traits<char>>)
JSON::JSON(std::string_view content) {
    std::stringstream ss;
    ss << content;
    Tokenizer tk(ss);
    obj = parse(tk);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x18cf8
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x11280
leaq 0xa0(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x113c0
leaq 0x48(%rsp), %r15
movq %r12, -0x40(%r15)
xorl %eax, %eax
movb %al, -0x38(%r15)
movabsq $0x3173c900e37ae1df, %rcx # imm = 0x3173C900E37AE1DF
movq %rcx, -0x30(%r15)
movq $0x4, -0x28(%r15)
leaq 0x9d49c(%rip), %rcx     # 0xbbd57
movq %rcx, -0x20(%r15)
movw $0x0, -0x18(%r15)
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb %al, (%r15)
leaq 0x58(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1da3e
leaq 0x80(%rsp), %r14
movups -0x28(%r14), %xmm0
movups -0x1e(%r14), %xmm1
movups %xmm1, 0xa(%rbx)
movups %xmm0, (%rbx)
movq -0x8(%r14), %rax
movq %rax, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x26e44
movq 0x8(%r14), %rax
movq %rax, 0x30(%rbx)
leaq 0x58(%rsp), %rdi
callq 0x1c65c
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x1e93a
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0xfe657(%rip), %rsi     # 0x11cf98
leaq 0x90(%rsp), %rdi
callq 0x112c0
leaq 0x110(%rsp), %rdi
callq 0x11120
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x1e989
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x1e989
movq %rax, %r14
movq 0xfe608(%rip), %rsi     # 0x11cf98
leaq 0x90(%rsp), %rdi
callq 0x112c0
leaq 0x110(%rsp), %rdi
callq 0x11120
jmp 0x1e9af
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c65c
movq %r14, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Reflection/JSON.cpp
// Function: void print<SharedObject>(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, SharedObject const&)
static void print(std::stringstream& out, const T& val) {
    if constexpr (std::same_as<T, std::string> || std::same_as<T, std::string_view>) {
        out << '"' << val << '"';
    } else {
        if constexpr (std::same_as<T, SharedObject> || std::same_as<T, ObjectPtr>) {
            if (val.GetType() == TypeID::get<std::string>()) {
                out << '"' << codeString(val.template Get<std::string>()) << '"';
            } else if (val.GetType() == TypeID::get<std::string_view>()) {
                out << '"' << codeString(val.template Get<std::string_view>()) << '"';
            } else {
                out << val;
            }
        } else {
            out << val;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x18f3c
movabsq $-0x22bfd0b2172c96aa, %rax # imm = 0xDD402F4DE8D36956
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq $0x17, 0x8(%rsi)
leaq 0x9cda1(%rip), %rax     # 0xbbe32
movq %rax, 0x10(%rsi)
movw $0x0, 0x18(%rsi)
movq %r15, %rdi
callq 0x1f654
testb %al, %al
je 0x1f104
addq $0x10, %r14
movq %rsp, %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x113c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x18b7c
movq (%rax), %rdx
movq 0x8(%rax), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1f1fb
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x113c0
leaq 0x20(%rsp), %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x113c0
jmp 0x1f1a1
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x18f3c
movabsq $-0x5958df06e1f63252, %rax # imm = 0xA6A720F91E09CDAE
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq $0x1c, 0x8(%rsi)
leaq 0x9da96(%rip), %rax     # 0xbcbc9
movq %rax, 0x10(%rsi)
movw $0x0, 0x18(%rsi)
movq %r15, %rdi
callq 0x1f654
addq $0x10, %r14
testb %al, %al
je 0x1f1be
movq %rsp, %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x113c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x18b7c
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1f1fb
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x113c0
leaq 0x20(%rsp), %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x113c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f1c9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x1f1c9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c565
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1f1d5
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f1f3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Reflection/JSON.cpp
// Function: codeString[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>)
static std::string codeString(std::string_view s) {
    std::string ret = "";
    for (auto ch : s) {
        if (ch == '\n') {
            ret += "\\n";
        } else if (ch == '\r') {
            ret += "\\r";
        } else if (ch == '\t') {
            ret += "\\t";
        } else {
            ret += ch;
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0xb0355(%rip), %rdx     # 0xcf576
movq %rdx, %rsi
callq 0x27370
testq %r15, %r15
je 0x1f27f
xorl %r13d, %r13d
leaq 0x9e02e(%rip), %rbp     # 0xbd266
leaq 0x9e024(%rip), %r12     # 0xbd263
movzbl (%r14,%r13), %eax
cmpl $0x9, %eax
je 0x1f25b
movq %rbp, %rsi
cmpl $0xd, %eax
je 0x1f262
cmpl $0xa, %eax
jne 0x1f26c
movq %r12, %rsi
jmp 0x1f262
leaq 0x9e007(%rip), %rsi     # 0xbd269
movq %rbx, %rdi
callq 0x27406
jmp 0x1f277
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6e3f2
incq %r13
cmpq %r13, %r15
jne 0x1f23f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x1f2a9
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x11360
movq %r14, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::GetType(std::basic_string_view<char, std::char_traits<char>>)
TypeID ReflMgr::GetType(std::string_view clsName) {
    auto& instance = ReflMgr::Instance();
    TypeID target = TypeID::getRaw(clsName);
    if (!instance.HasClassInfo(target)) {
        return target;
    }
    while (!instance.classInfo[target].aliasTo.isNull()) {
        target = instance.classInfo[target].aliasTo;
    }
    return target;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movabsq $-0x340d631b7bdddcdb, %r12 # imm = 0xCBF29CE484222325
callq 0x227b2
testq %r15, %r15
je 0x22823
xorl %eax, %eax
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
movsbq (%r14,%rax), %rdx
xorq %r12, %rdx
imulq %rcx, %rdx
incq %rax
movq %rdx, %r12
cmpq %rax, %r15
jne 0x2280a
jmp 0x22826
movq %r12, %rdx
movq %rdx, (%rbx)
movq %r15, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movw $0x0, 0x18(%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
movzwl 0x18(%rbx), %edi
movl 0x1a(%rbx), %r8d
movzwl 0x1e(%rbx), %r9d
movq %rsp, %rsi
movq %rdx, 0x10(%rsi)
movw %di, 0x18(%rsi)
movl %r8d, 0x1a(%rsi)
movw %r9w, 0x1e(%rsi)
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
leaq 0xfac77(%rip), %rdi     # 0x11d4e8
callq 0x8f652
testq %rax, %rax
je 0x228cd
leaq 0xfac66(%rip), %rdi     # 0x11d4e8
movq %rbx, %rsi
callq 0x35d16
movq %rax, %rdi
callq 0x1f5d6
testb %al, %al
jne 0x228cd
leaq 0xfac4b(%rip), %r14     # 0x11d4e8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x35d16
movups (%rax), %xmm0
movups 0xa(%rax), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0xa(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x35d16
movq %rax, %rdi
callq 0x1f5d6
testb %al, %al
je 0x2289d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::SafeGet(TypeID, std::basic_string_view<char, std::char_traits<char>>, ArgsTypeList const&)
const MethodInfo* ReflMgr::SafeGet(TypeID id, std::string_view name, const ArgsTypeList& args) {
    auto* lst = SafeGet(methodInfo, id, name);
    if (lst == nullptr) {
        return nullptr;
    }
    const MethodInfo* rec[3] = { nullptr, nullptr, nullptr };
    for (const auto& info : *lst) {
        CheckParams(info, args, rec);
    }
    for (int i = 0; i < 3; i++) {
        if (rec[i] != nullptr) {
            return rec[i];
        }
    }
    for (const auto& info : *lst) {
        CheckParams(info, args, rec, true);
    }
    return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x58(%rdi), %rsi
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x8b8c0
testq %rax, %rax
je 0x229cb
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq (%rax), %r12
movq 0x8(%rax), %rbp
cmpq %rbp, %r12
je 0x2297d
leaq 0x20(%rsp), %r13
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0x8be8e
addq $0xd0, %r12
cmpq %rbp, %r12
jne 0x2295d
xorl %eax, %eax
movq 0x20(%rsp,%rax,8), %r12
testq %r12, %r12
jne 0x229ce
incq %rax
cmpq $0x3, %rax
jne 0x2297f
movq (%r15), %r13
movq 0x8(%r15), %rbp
cmpq %rbp, %r13
je 0x229cb
leaq 0x20(%rsp), %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movl $0x1, %r8d
callq 0x8be8e
addq $0xd0, %r13
cmpq %rbp, %r13
jne 0x229a6
jmp 0x229ce
xorl %r12d, %r12d
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x98, %esi
addq %rsi, %rdi
addq %rbx, %rsi
callq 0x1f66c
testb %al, %al
jne 0x22a6f
movq 0xb8(%r14), %rdi
movq 0xc0(%r14), %rax
movq %rax, %rcx
subq %rdi, %rcx
movq 0xc0(%rbx), %rdx
subq 0xb8(%rbx), %rdx
cmpq %rdx, %rcx
jne 0x22a6f
cmpq %rdi, %rax
je 0x22a7d
xorl %r15d, %r15d
xorl %r12d, %r12d
addq %r15, %rdi
movq 0xb8(%rbx), %rsi
addq %r15, %rsi
callq 0x1f66c
testb %al, %al
jne 0x22a6b
incq %r12
movq 0xb8(%r14), %rdi
movq 0xc0(%r14), %rcx
subq %rdi, %rcx
sarq $0x5, %rcx
addq $0x20, %r15
cmpq %r12, %rcx
ja 0x22a34
xorb $0x1, %al
jmp 0x22a71
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x22a71
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2629(%rip), %rax      # 0x2541a
movq %rax, 0x18(%rdx)
leaq 0x2654(%rip), %rax      # 0x25450
movq %rax, 0x10(%rdx)
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x8c28c
movq %rax, %rbx
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0x22e3a
leaq 0x38(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
testq %rbx, %rbx
setne %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0x22ee8
leaq 0x80(%rsp), %r15
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0xfa18d(%rip), %rdi     # 0x11cff0
callq 0x113c0
movq %rax, %r14
leaq 0x9a45e(%rip), %rsi     # 0xbd2d0
movl $0x20, %edx
movq %rax, %rdi
callq 0x113c0
movq %r15, %rdi
callq 0x1f5e2
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x113c0
movq %rax, %r14
leaq 0x98e81(%rip), %rsi     # 0xbbd20
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x113c0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq %r14, %rdi
callq 0x11040
movq %rax, %rdi
callq 0x11260
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x22f1c
movq %rax, %rbx
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0x22f14
leaq 0x38(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x26e38
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x1f5e2
xorl %ecx, %ecx
cmpq $0x7, %rax
jb 0x231f4
movl $0x736e6f63, %ecx       # imm = 0x736E6F63
xorl (%rdx), %ecx
movzwl 0x4(%rdx), %esi
xorl $0x2074, %esi           # imm = 0x2074
xorl %edi, %edi
orl %ecx, %esi
movl $0x6, %ecx
cmovnel %edi, %ecx
movl %ecx, %ecx
movq %rax, %r9
subq %rcx, %r9
jb 0x2332c
leaq 0x90(%r12), %rdi
movabsq $-0x340d631b7bdddcdb, %rsi # imm = 0xCBF29CE484222325
xorl %r8d, %r8d
cmpb $0x26, -0x1(%rdx,%rax)
sete %r8b
subl %ecx, %eax
subl %r8d, %eax
xorl %r8d, %r8d
testl %eax, %eax
cmovgl %eax, %r8d
cmpq %r8, %r9
cmovbq %r9, %r8
addq %rcx, %rdx
testq %r8, %r8
je 0x23262
xorl %eax, %eax
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
movsbq (%rdx,%rax), %r9
xorq %rsi, %r9
imulq %rcx, %r9
incq %rax
movq %r9, %rsi
cmpq %rax, %r8
jne 0x23249
jmp 0x23265
movq %rsi, %r9
leaq 0x8(%rsp), %rsi
movq %r9, (%rsi)
movq %r8, 0x8(%rsi)
movq %rdx, 0x10(%rsi)
movw $0x0, 0x18(%rsi)
callq 0x9148e
cmpq $0x0, 0x98(%rax)
je 0x232a2
movq %rax, %rsi
addq $0x88, %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq *0xa0(%rax)
jmp 0x2331d
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq 0xf9d3e(%rip), %rdi     # 0x11cff0
callq 0x113c0
movq %rax, %r15
leaq 0x9a052(%rip), %rsi     # 0xbd313
movl $0x2d, %edx
movq %rax, %rdi
callq 0x113c0
movq %r14, %rdi
callq 0x1f5e2
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x113c0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq %r14, %rdi
callq 0x11040
movq %rax, %rdi
callq 0x11260
leaq 0xfa073(%rip), %rsi     # 0x11d388
movq %rbx, %rdi
callq 0x18d30
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x9a067(%rip), %rdi     # 0xbd39a
leaq 0x9a046(%rip), %rsi     # 0xbd380
movq %rcx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x114c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x50, %rsp
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x214e(%rip), %rdx      # 0x25512
movq %rdx, 0x18(%rsi)
leaq 0x2147(%rip), %rdx      # 0x25516
movq %rdx, 0x10(%rsi)
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rax, %rdi
movq %rcx, %rdx
movq %r8, %rcx
movl $0x1, %r8d
callq 0x22dc2
movq %rax, %r14
testq %rax, %rax
je 0x23446
movq %r15, 0x28(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x2347b
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq *0x18(%rdi)
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x88(%r14)
je 0x2347b
movq %r14, %rsi
addq $0x78, %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq *0x90(%r14)
jmp 0x23455
leaq 0xf9f73(%rip), %rsi     # 0x11d3c0
movq %rbx, %rdi
callq 0x18b2e
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x2346e
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x11150
jmp 0x234a6
movq %rax, %rbx
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x2349e
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x26e38
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/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 0x205f(%rip), %rdi      # 0x2552e
movq %rdi, 0x18(%rsi)
leaq 0x2058(%rip), %rdi      # 0x25532
movq %rdi, 0x10(%rsi)
movaps 0x90(%rsp), %xmm0
movaps 0xa0(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rax, %rdi
movl $0x1, %r9d
callq 0x22f24
movq %rax, %r15
testq %rax, %rax
je 0x235a9
leaq 0xac05e(%rip), %rsi     # 0xcf576
movq %r15, %rdi
callq 0x27854
testl %eax, %eax
je 0x235a9
leaq 0x50(%rsp), %r14
movq %r15, -0x8(%r14)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x8c680
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movl $0x28, %edi
callq 0x11350
movq 0x48(%rsp), %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movq 0x68(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x60(%rsp), %rcx
testq %rcx, %rcx
je 0x2358e
movq %rax, %rdx
addq $0x8, %rdx
movups (%r14), %xmm0
movups %xmm0, (%rdx)
movq %rcx, 0x18(%rax)
movq %rax, (%rbx)
leaq 0x1fb2(%rip), %rax      # 0x2554a
movq %rax, 0x18(%rbx)
leaq 0x2059(%rip), %rax      # 0x255fc
movq %rax, 0x10(%rbx)
jmp 0x235b3
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x235cc
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x235fe
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x235fe
jmp 0x2361f
jmp 0x235fb
jmp 0x2361f
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x23617
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x26e38
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x50, %rsp
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x2060(%rip), %rdx      # 0x256ac
movq %rdx, 0x18(%rsi)
leaq 0x2059(%rip), %rdx      # 0x256b0
movq %rdx, 0x10(%rsi)
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rax, %rdi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
movl $0x1, %r9d
callq 0x22f24
movq %rax, %r14
testq %rax, %rax
je 0x23702
leaq 0xabedf(%rip), %rsi     # 0xcf576
movq %r14, %rdi
callq 0x27854
testl %eax, %eax
je 0x23702
cmpq $0x0, 0x88(%r14)
je 0x2373c
leaq 0x78(%r14), %rsi
movq %rbx, %rdi
callq *0x90(%r14)
movq %r15, 0x28(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x23737
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq *0x18(%rdi)
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x68(%r14)
je 0x23737
movq 0x90(%rsp), %rdx
movq %r14, %rdi
addq $0x58, %rdi
leaq 0x28(%rsp), %rsi
movq %rbx, %rcx
callq *0x70(%r14)
jmp 0x23711
leaq 0xf9c7f(%rip), %rsi     # 0x11d388
movq %rbx, %rdi
callq 0x18d30
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x2372a
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x11150
callq 0x11150
jmp 0x23774
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c65c
jmp 0x23753
movq %rax, %r14
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x2376c
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x26e38
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movq %rcx, %r14
movabsq $-0x340d631b7bdddcdb, %r13 # imm = 0xCBF29CE484222325
movabsq $0x100000001b3, %r12    # imm = 0x100000001B3
addq $0x90, %rdi
movq %r13, %rcx
testq %rsi, %rsi
je 0x2392c
xorl %eax, %eax
movq %r13, %r8
movsbq (%rdx,%rax), %rcx
xorq %r8, %rcx
imulq %r12, %rcx
incq %rax
movq %rcx, %r8
cmpq %rax, %rsi
jne 0x23915
movq %rsp, %rax
movq %rcx, (%rax)
movq %rsi, 0x8(%rax)
movq %rdx, 0x10(%rax)
movw $0x0, 0x18(%rax)
movq %rax, %rsi
callq 0x9148e
movq %rax, %r15
testq %r14, %r14
je 0x2396b
xorl %eax, %eax
movsbq (%rbx,%rax), %rcx
xorq %r13, %rcx
imulq %r12, %rcx
incq %rax
movq %rcx, %r13
cmpq %rax, %r14
jne 0x23952
jmp 0x2396e
movq %r13, %rcx
movq %rcx, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movw $0x0, 0x18(%rsp)
movq 0x28(%r15), %rsi
cmpq 0x30(%r15), %rsi
je 0x239a4
movups (%rsp), %xmm0
movups 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x28(%r15)
jmp 0x239b0
leaq 0x20(%r15), %rdi
movq %rsp, %rdx
callq 0x276da
addq $0x38, %r15
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x1d04(%rip), %rax      # 0x256c8
movq %rax, 0x18(%rsi)
leaq 0x1cfd(%rip), %rax      # 0x256cc
movq %rax, 0x10(%rsi)
movq %r15, %rdi
callq 0x915b0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x239f2
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x23a24
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x23a1c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x26e38
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
addq $0x58, %rdi
leaq 0x60(%rsp), %rsi
callq 0x8f75a
movq %rax, %r13
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
addq %r15, %r12
movq %rsp, %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x27370
movq %r13, %rdi
movq %rbp, %rsi
callq 0x8fef4
movq %rax, %r12
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x23bed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%r12), %r15
movq 0x8(%r12), %r13
cmpq %r13, %r15
je 0x23c2e
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x8bac0
addq $0xd0, %r15
cmpq %r13, %r15
jne 0x23c0e
xorl %ecx, %ecx
leaq 0xf98f1(%rip), %rax     # 0x11d528
movq (%rsp,%rcx,8), %rdx
testq %rdx, %rdx
jne 0x23c4b
incq %rcx
cmpq $0x3, %rcx
jne 0x23c37
jmp 0x23c52
addq $0x20, %rdx
movq %rdx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x23c7f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x40, %rsp
callq 0x227b2
leaq -0x26ed(%rip), %rsi     # 0x227b2
movabsq $-0x499506eb9c827484, %rax # imm = 0xB66AF914637D8B7C
movq %rax, 0x20(%rsp)
movq $0x7, 0x28(%rsp)
leaq 0x98548(%rip), %rax     # 0xbd406
movq %rax, 0x30(%rsp)
movw $0x0, 0x38(%rsp)
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0xf8574(%rip), %rbx     # 0x11d458
leaq 0xab219(%rip), %rcx     # 0xd0104
movl $0x8, %edx
movq %rbx, %rdi
callq 0x8d6f6
leaq -0x1277(%rip), %rsi     # 0x23c88
leaq 0x9843b(%rip), %r8      # 0xbd341
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8d90e
leaq -0xfba(%rip), %rsi      # 0x23f62
leaq 0x98427(%rip), %r8      # 0xbd34a
movl $0xe, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8daf6
leaq -0xd2d(%rip), %rsi      # 0x2420c
leaq 0x97095(%rip), %r8      # 0xbbfd5
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8dcde
leaq -0xcde(%rip), %rsi      # 0x24278
leaq 0x983fc(%rip), %r8      # 0xbd359
movl $0x9, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8dec6
leaq -0x829(%rip), %rsi      # 0x2474a
leaq 0x97054(%rip), %r8      # 0xbbfce
movl $0x6, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8e0ae
leaq -0x5ce(%rip), %rsi      # 0x249c2
leaq 0x983cc(%rip), %r8      # 0xbd363
movl $0xf, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8e296
leaq -0x14f(%rip), %rsi      # 0x24e5e
leaq 0x983bf(%rip), %r8      # 0xbd373
movl $0xc, %ecx
movq %rbx, %rdi
xorl %edx, %edx
addq $0x40, %rsp
popq %rbx
jmp 0x8e47e
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x20(%rsp)
leaq 0xd89(%rip), %rax       # 0x25d7a
movq %rax, 0x38(%rsp)
leaq 0xd81(%rip), %rax       # 0x25d7e
movq %rax, 0x30(%rsp)
movq %r14, %rdi
callq 0x1f5e2
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x227d6
movups 0x60(%rsp), %xmm0
movups 0x6a(%rsp), %xmm1
movups %xmm1, 0xa(%r14)
movups %xmm0, (%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movl $0x18, %edi
callq 0x11350
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
leaq 0x40(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xd3b(%rip), %rax       # 0x25d96
movq %rax, 0x18(%rdx)
leaq 0xdaa(%rip), %rax       # 0x25e10
movq %rax, 0x10(%rdx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8c28c
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x250a2
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x250bb
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x25112
jmp 0x25112
movq %rax, %rbx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x250f1
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x250f1
jmp 0x25112
jmp 0x250ee
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2510a
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x26e38
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::IterateMethod(TypeID, std::function<void (MethodInfo const&)>)
void ReflMgr::IterateMethod(TypeID cls, std::function<void(const MethodInfo&)> callback) {
    std::function<void*(void*)> conv = [](void* orig) { return orig; };
    cls = GetType(cls.getName());
    WalkThroughInherits(&conv, cls, std::function([&](TypeID type) -> MethodInfo* {
        auto* lst = SafeGetList(methodInfo, cls);
        if (lst == nullptr) {
            return nullptr;
        }
        for (auto& method : *lst) {
            for (auto& overloads : method.second) {
                callback(overloads);
            }
        }
        return nullptr;
    }));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xa0(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
leaq 0xd31(%rip), %rax       # 0x25e74
movq %rax, 0x38(%rsp)
leaq 0xd29(%rip), %rax       # 0x25e78
movq %rax, 0x30(%rsp)
movq %r14, %rdi
callq 0x1f5e2
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x227d6
movups 0x60(%rsp), %xmm0
movups 0x6a(%rsp), %xmm1
movups %xmm1, 0xa(%r14)
movups %xmm0, (%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movl $0x18, %edi
callq 0x11350
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
leaq 0x40(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xce3(%rip), %rax       # 0x25e90
movq %rax, 0x18(%rdx)
leaq 0xd70(%rip), %rax       # 0x25f28
movq %rax, 0x10(%rdx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8c892
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x251f4
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2520d
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x25264
jmp 0x25264
movq %rax, %rbx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x25243
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x25243
jmp 0x25264
jmp 0x25240
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2525c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x26e38
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::IsBaseClass(TypeID, TypeID)
bool ReflMgr::IsBaseClass(TypeID query, TypeID base) {
    std::queue<TypeID> q;
    q.push(query);
    while (!q.empty()) {
        if (q.front() == base) {
            return true;
        }
        auto& info = classInfo[q.front()];
        q.pop();
        for (auto& id : info.parents) {
            q.push(id);
        }
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x90(%rsp), %r14
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x40(%r15)
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r15, %rdi
xorl %esi, %esi
callq 0x939de
movq 0x30(%r15), %rax
movq 0x40(%r15), %rcx
addq $-0x20, %rcx
cmpq %rcx, %rax
je 0x252de
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq 0x30(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x30(%rsp)
jmp 0x252ee
movq %rsp, %rdi
movq %r14, %rsi
callq 0x93b56
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rdi
cmpq %rdi, %rax
je 0x253e0
leaq 0xb0(%rsp), %r14
addq $0x90, %rbx
movq %rsp, %r15
movq %r14, %rsi
callq 0x1f654
movl %eax, %ebp
testb %al, %al
jne 0x253e4
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x35d16
movq %rax, %r13
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
addq $-0x20, %rax
cmpq %rax, %rdi
je 0x25349
addq $0x20, %rdi
jmp 0x2537b
movq 0x18(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x11360
movq 0x28(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x200(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x20(%r13), %r12
movq 0x28(%r13), %r13
cmpq %r13, %r12
je 0x253d3
movq 0x30(%rsp), %rax
movq 0x40(%rsp), %rcx
addq $-0x20, %rcx
cmpq %rcx, %rax
je 0x253ba
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x20, 0x30(%rsp)
jmp 0x253c5
movq %r15, %rdi
movq %r12, %rsi
callq 0x93b56
addq $0x20, %r12
cmpq %r13, %r12
jne 0x2538d
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x30(%rsp)
jne 0x2530e
jmp 0x253e7
xorl %ebp, %ebp
jmp 0x253e7
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x8f59c
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25406
jmp 0x25406
jmp 0x25406
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8f59c
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O3/Heptagon196[P]Gos/Reflection/./ReflMgr.h
// Function: void ReflMgr::AddClass<ObjectPtr>(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>)
void AddClass(TagList tagList = {}) {
            auto type = TypeID::get<T>();
            classInfo[type].newObject = [](const std::vector<ObjectPtr>& args) -> SharedObject {
                auto obj = SharedObject{TypeID::get<T>(), std::make_shared<T>(), false};
                obj.ctor(args);
                return obj;
            };
            classInfo[type].tags = tagList;
        }

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

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11280
leaq 0x18(%rsp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x113c0
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x111f0
movl 0x4(%rsp), %ebx
movq 0x95248(%rip), %rsi     # 0x11cf98
leaq 0x8(%rsp), %rdi
callq 0x112c0
leaq 0x88(%rsp), %rdi
callq 0x11120
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
jmp 0x87d74
movq %rax, %rbx
movq 0x9521a(%rip), %rsi     # 0x11cf98
leaq 0x8(%rsp), %rdi
callq 0x112c0
leaq 0x88(%rsp), %rdi
callq 0x11120
movq %rbx, %rdi
callq 0x11580
nop