LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Chrom3D[P]Chrom3D/src/tclap-1.2.1/include/tclap/UnlabeledValueArg.h
// Function: TCLAP::UnlabeledValueArg<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::longID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string UnlabeledValueArg<T>::longID(const std::string& val) const
{
	static_cast<void>(val); // Ignore input, don't warn

	// Ideally we would like to be able to use RTTI to return the name
	// of the type required for this argument.  However, g++ at least, 
	// doesn't appear to return terribly useful "names" of the types.  
	return std::string("<") + _typeDesc + ">";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3efe(%rip), %rsi      # 0x2be6c
leaq 0x3ef8(%rip), %rdx      # 0x2be6d
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xe03a
movq 0xe8(%r14), %rsi
movq 0xf0(%r14), %rdx
movq %r15, %rdi
callq 0x6110
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x27fbf
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x27fc6
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x27f0(%rip), %rsi      # 0x2a7d9
callq 0x6630
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x28010
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x28016
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x28044
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x2805b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x28089
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
jmp 0x28089
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x280a0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O1/QZzcoder[P]LiveChat/SocketManager.cpp
// Function: getTime[abi:cxx11]()
string getTime(){
    time_t timep;
    time(&timep);
    char tmp[64];
    memset(tmp,0,sizeof(tmp));
    strftime(tmp,sizeof(tmp),"%Y-%m-%d %H:%M:%S ",localtime(&timep));
    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0x2190
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %r14
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq %r15, %rdi
callq 0x2130
leaq 0x13fc(%rip), %rdx      # 0x40a6
movl $0x40, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0x2150
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x20c0
leaq (%rax,%rbp), %rdx
addq $-0x60, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29ca
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/QZzcoder[P]LiveChat/SocketManager.cpp
// Function: getSocket(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
int getSocket(int port,std::string ip,bool isServer){
    int socket_fd = socket(AF_INET, SOCK_STREAM,0);
    if(socket_fd == -1)
    {
        cout<<"socket 创建失败："<<endl;
        exit(-1);
    }
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet_addr(ip.c_str());
    bool nOptval = true;
    setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,(const void*)&nOptval,sizeof(bool));
    int res;
    if(!isServer){
        res = connect(socket_fd,(struct sockaddr*)&addr,sizeof(addr));
    }else{
        res = bind(socket_fd,(struct sockaddr*)&addr,sizeof(addr));
        listen(socket_fd,30);
    }
    if(res == -1){
        cout<<"bind 链接失败："<<endl;
        exit(-1);
    }
    return socket_fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %r15
movl %edi, %r12d
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2070
cmpl $-0x1, %eax
je 0x2d96
movl %eax, %ebx
movw $0x2, -0x34(%rbp)
rolw $0x8, %r12w
movw %r12w, -0x32(%rbp)
movq (%r15), %rdi
callq 0x21f0
movl %eax, -0x30(%rbp)
leaq -0x21(%rbp), %rcx
movb $0x1, (%rcx)
movl %ebx, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x1, %r8d
callq 0x22d0
leaq -0x34(%rbp), %rsi
movl %ebx, %edi
movl $0x10, %edx
testb %r14b, %r14b
je 0x2d79
callq 0x2050
movl %eax, %r14d
movl %ebx, %edi
movl $0x1e, %esi
callq 0x2220
jmp 0x2d81
callq 0x2170
movl %eax, %r14d
cmpl $-0x1, %r14d
je 0x2da6
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3233(%rip), %rdi      # 0x5fd0
leaq 0x1315(%rip), %rsi      # 0x40b9
jmp 0x2db4
movq 0x3223(%rip), %rdi      # 0x5fd0
leaq 0x131c(%rip), %rsi      # 0x40d0
callq 0x21d0
movq %rax, %rdi
callq 0x20d0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/QZzcoder[P]LiveChat/SocketManager.cpp
// Function: mySelect(fd_set&, std::set<int, std::less<int>, std::allocator<int>>, int)
int mySelect(fd_set& fds,set<int> fd,int usec){
    timeval timeout = {0};
    timeout.tv_usec = usec;
    FD_ZERO(&fds);
    int maxfd = 0;
    for(int i:fd){
        maxfd = maxfd>i?maxfd:i;
        FD_SET(i,&fds);
    }
    switch(select(maxfd+1,&fds,NULL,NULL,&timeout)){
        case -1:{
            cout<<"select error";
            exit(1);
        }case 0:break;
        default:{
            for(int i:fd){
                if(FD_ISSET(i,&fds)){
                    return i;
                }
            }
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movslq %edx, %rax
movq %rax, -0x28(%rbp)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x18(%rsi), %rax
leaq 0x8(%rsi), %r12
cmpq %r12, %rax
je 0x2e5a
xorl %r15d, %r15d
movl 0x20(%rax), %ecx
cmpl %ecx, %r15d
cmovlel %ecx, %r15d
leal 0x3f(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
movl %edx, %esi
andl $-0x40, %esi
subl %esi, %ecx
movl $0x1, %esi
shlq %cl, %rsi
sarl $0x6, %edx
movslq %edx, %rcx
orq %rsi, (%rbx,%rcx,8)
movq %rax, %rdi
callq 0x2240
cmpq %r12, %rax
jne 0x2e1d
incl %r15d
jmp 0x2e60
movl $0x1, %r15d
leaq -0x30(%rbp), %r8
movl %r15d, %edi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x21b0
testl %eax, %eax
je 0x2ec9
cmpl $-0x1, %eax
je 0x2edf
movq 0x18(%r14), %rax
cmpq %r12, %rax
sete %dl
je 0x2ec4
movl 0x20(%rax), %esi
leal 0x3f(%rsi), %edi
testl %esi, %esi
cmovnsl %esi, %edi
movl %edi, %ecx
sarl $0x6, %ecx
movslq %ecx, %r8
andl $-0x40, %edi
movl %esi, %ecx
subl %edi, %ecx
movl $0x1, %edi
shlq %cl, %rdi
testq %rdi, (%rbx,%r8,8)
cmovnel %esi, %r14d
jne 0x2ec4
movq %rax, %rdi
callq 0x2240
cmpq %r12, %rax
sete %dl
jne 0x2e88
testb $0x1, %dl
je 0x2ecf
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x30ea(%rip), %rdi      # 0x5fd0
leaq 0x11f8(%rip), %rsi      # 0x40e5
callq 0x21d0
movl $0x1, %edi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fb2
movq %rsi, %r14
movq (%rsi), %rcx
negq %rax
movl $0x1, %r15d
cmpb %dl, -0x1(%rcx,%r15)
je 0x2f51
leaq (%rax,%r15), %rsi
incq %rsi
incq %r15
cmpq $0x1, %rsi
jne 0x2f38
jmp 0x2fb2
leaq -0x1(%r15), %rcx
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2200
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x304a
leaq -0x30(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x2f82
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 0x304a
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2fb2
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 0x2fe2
jmp 0x2fec
jmp 0x2fe9
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fec
callq 0x21a0
jmp 0x2fec
movq %rax, %r14
movq %rbx, %rdi
callq 0x2ffc
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23132
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 0x9ffa2(%rip), %r8      # 0xbcde4
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %r9
movl $0xa, %ecx
movq %rax, %rsi
callq 0x26e34
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ce70
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 0x9ffbb(%rip), %rax     # 0xbce62
movq %rax, 0x10(%rsi)
movw $0x0, 0x18(%rsi)
callq 0x2000e
testb %al, %al
jne 0x1ced8
movq 0x68(%rsp), %rax
testq %rax, %rax
jne 0x1cec9
movq 0x58(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x113c0
leaq 0x38(%rsp), %rdi
callq 0x1d01a
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
jmp 0x1cef2
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1d01a
jmp 0x1cf1b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cf1b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23132
movq %rax, %rbx
movq %rax, %rdi
callq 0x258cc
leaq -0x42d2(%rip), %rsi     # 0x195dc
leaq 0x9f749(%rip), %r8      # 0xbcffe
movl $0x6, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3435e
leaq -0x4341(%rip), %rsi     # 0x1958a
leaq 0x9f733(%rip), %r15     # 0xbd005
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %r8
callq 0x34552
leaq -0x43a1(%rip), %rsi     # 0x1954a
leaq 0x9f71c(%rip), %r12     # 0xbd00e
movl $0x7, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %r8
callq 0x34746
leaq -0x1329(%rip), %rsi     # 0x1c5e2
leaq 0x9f4d4(%rip), %r13     # 0xbcde6
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r13, %r8
callq 0x3493a
leaq -0x12a3(%rip), %rsi     # 0x1c688
leaq 0x9f4bf(%rip), %rbp     # 0xbcdf1
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %rbp, %r8
callq 0x34b2e
leaq -0x125d(%rip), %rsi     # 0x1c6ee
leaq 0x9f4a6(%rip), %r14     # 0xbcdf8
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r14, %r8
callq 0x34d22
leaq -0x3f61(%rip), %rsi     # 0x19a0a
movl $0x6, %ecx
movq %rbx, %rdi
xorl %edx, %edx
leaq 0x9f682(%rip), %r8      # 0xbcffe
callq 0x34f16
leaq -0x4044(%rip), %rsi     # 0x19944
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %r8
callq 0x3510a
leaq -0x40a5(%rip), %rsi     # 0x198fc
movl $0x7, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r12, %r8
callq 0x352fe
leaq -0x2b06(%rip), %rsi     # 0x1aeb4
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %r13, %r8
callq 0x354f2
leaq -0x418f(%rip), %rsi     # 0x19844
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movq %rbp, %r8
callq 0x356e6
leaq -0x2a50(%rip), %rsi     # 0x1af9c
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 0x358da
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23132
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x1724(%rip), %rcx      # 0x1f820
movq %rcx, 0x18(%rsi)
leaq 0x1779(%rip), %rcx      # 0x1f880
movq %rcx, 0x10(%rsi)
leaq 0x9ecd2(%rip), %rcx     # 0xbcde4
movl $0xa, %edx
movq %rax, %rdi
callq 0x87736
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x1e138
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x23132
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x1749(%rip), %rcx      # 0x1f898
movq %rcx, 0x18(%rsi)
leaq 0x1890(%rip), %rcx      # 0x1f9ea
movq %rcx, 0x10(%rsi)
leaq 0x9ec7f(%rip), %rcx     # 0xbcde4
movl $0xa, %edx
movq %rax, %rdi
callq 0x87978
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1e18b
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x23132
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x1ac0(%rip), %rcx      # 0x1fc60
movq %rcx, 0x18(%rsi)
leaq 0x1cbd(%rip), %rcx      # 0x1fe68
movq %rcx, 0x10(%rsi)
leaq 0x9ec2e(%rip), %rcx     # 0xbcde4
movl $0xa, %edx
movq %rax, %rdi
callq 0x87bba
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1e1da
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x60, %rsp
popq %rbx
retq
jmp 0x1e248
jmp 0x1e248
jmp 0x1e248
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1e240
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1e240
jmp 0x1e248
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1e240
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1e240
jmp 0x1e248
movq %rax, %rbx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x1e240
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x2789a
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Reflection/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 0x196b8
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 0x9db20(%rip), %rcx     # 0xbcd87
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 0x1e3e2
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 0x278a6
movq 0x8(%r14), %rax
movq %rax, 0x30(%rbx)
leaq 0x58(%rsp), %rdi
callq 0x1d01a
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x1f2e6
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x11360
movq 0xfecab(%rip), %rsi     # 0x11df98
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 0x1f335
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x1f335
movq %rax, %r14
movq 0xfec5c(%rip), %rsi     # 0x11df98
leaq 0x90(%rsp), %rdi
callq 0x112c0
leaq 0x110(%rsp), %rdi
callq 0x11120
jmp 0x1f35b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d01a
movq %r14, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/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 0x198fc
movabsq $-0x22bfd0b2172c96aa, %rax # imm = 0xDD402F4DE8D36956
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq $0x17, 0x8(%rsi)
leaq 0x9d425(%rip), %rax     # 0xbce62
movq %rax, 0x10(%rsi)
movw $0x0, 0x18(%rsi)
movq %r15, %rdi
callq 0x1fff6
testb %al, %al
je 0x1fab0
addq $0x10, %r14
movq %rsp, %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x113c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1953c
movq (%rax), %rdx
movq 0x8(%rax), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1fba7
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 0x1fb4d
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x198fc
movabsq $-0x5958df06e1f63252, %rax # imm = 0xA6A720F91E09CDAE
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq $0x1c, 0x8(%rsi)
leaq 0x9e11a(%rip), %rax     # 0xbdbf9
movq %rax, 0x10(%rsi)
movw $0x0, 0x18(%rsi)
movq %r15, %rdi
callq 0x1fff6
addq $0x10, %r14
testb %al, %al
je 0x1fb6a
movq %rsp, %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x113c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1953c
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1fba7
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 0x1fb75
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
jmp 0x1fb75
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1cf23
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1fb81
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fb9f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb09d9(%rip), %rdx     # 0xd05a6
movq %rdx, %rsi
callq 0x27dc8
testq %r15, %r15
je 0x1fc2b
xorl %r13d, %r13d
leaq 0x9e6b2(%rip), %rbp     # 0xbe296
leaq 0x9e6a8(%rip), %r12     # 0xbe293
movzbl (%r14,%r13), %eax
cmpl $0x9, %eax
je 0x1fc07
movq %rbp, %rsi
cmpl $0xd, %eax
je 0x1fc0e
cmpl $0xa, %eax
jne 0x1fc18
movq %r12, %rsi
jmp 0x1fc0e
leaq 0x9e68b(%rip), %rsi     # 0xbe299
movq %rbx, %rdi
callq 0x27e58
jmp 0x1fc23
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6ed94
incq %r13
cmpq %r13, %r15
jne 0x1fbeb
movq %rbx, %rax
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 0x1fc58
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x11360
movq %r14, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23132
testq %r15, %r15
je 0x231a3
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 0x2318a
jmp 0x231a6
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 0xfb2f7(%rip), %rdi     # 0x11e4e8
callq 0x901be
testq %rax, %rax
je 0x2324d
leaq 0xfb2e6(%rip), %rdi     # 0x11e4e8
movq %rbx, %rsi
callq 0x36950
movq %rax, %rdi
callq 0x1ff72
testb %al, %al
jne 0x2324d
leaq 0xfb2cb(%rip), %r14     # 0x11e4e8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36950
movups (%rax), %xmm0
movups 0xa(%rax), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0xa(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36950
movq %rax, %rdi
callq 0x1ff72
testb %al, %al
je 0x2321d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8c3fe
testq %rax, %rax
je 0x23368
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 0x232fd
leaq 0x20(%rsp), %r13
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0x8c9c2
addq $0xd0, %r12
cmpq %rbp, %r12
jne 0x232dd
movq 0x20(%rsp), %r12
testq %r12, %r12
je 0x2330b
xorl %eax, %eax
jmp 0x2332b
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x2, %rcx
je 0x23324
movq 0x28(%rsp,%rax,8), %r12
leaq 0x1(%rax), %rcx
testq %r12, %r12
je 0x2330d
cmpq $0x2, %rax
setae %al
testb %al, %al
je 0x2336b
movq (%r15), %r13
movq 0x8(%r15), %rbp
cmpq %rbp, %r13
je 0x23368
leaq 0x20(%rsp), %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movl $0x1, %r8d
callq 0x8c9c2
addq $0xd0, %r13
cmpq %rbp, %r13
jne 0x23343
jmp 0x2336b
xorl %r12d, %r12d
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2000e
testb %al, %al
jne 0x2342e
movq 0xc0(%r14), %rax
subq 0xb8(%r14), %rax
movq 0xc0(%rbx), %rcx
subq 0xb8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x2342e
movq 0xb8(%r14), %rdi
cmpq %rdi, 0xc0(%r14)
sete %bpl
je 0x23430
movq 0xb8(%rbx), %rsi
callq 0x2000e
testb %al, %al
jne 0x23430
movl $0x20, %esi
xorl %r15d, %r15d
incq %r15
movq 0xb8(%r14), %rdi
movq 0xc0(%r14), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r15, %rax
setbe %bpl
jbe 0x23430
leaq 0x20(%rsi), %r12
addq %rsi, %rdi
addq 0xb8(%rbx), %rsi
callq 0x2000e
movq %r12, %rsi
testb %al, %al
je 0x233f1
jmp 0x23430
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20(%rsp), %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rdi, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0x269b(%rip), %rax      # 0x25e4a
movq %rax, 0x18(%rdx)
leaq 0x26c6(%rip), %rax      # 0x25e80
movq %rax, 0x10(%rdx)
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x8cdaa
movq %rax, %rbx
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x237f8
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
testq %rbx, %rbx
setne %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0x238a6
leaq 0x80(%rsp), %r15
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0xfa7cf(%rip), %rdi     # 0x11dff0
callq 0x113c0
movq %rax, %r14
leaq 0x9aad0(%rip), %rsi     # 0xbe300
movl $0x20, %edx
movq %rax, %rdi
callq 0x113c0
movq %r15, %rdi
callq 0x1ff7e
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x113c0
movq %rax, %r14
leaq 0x994f3(%rip), %rsi     # 0xbcd50
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movq 0x20(%rsp), %rdx
movq 0x28(%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 0x238da
movq %rax, %rbx
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x238d2
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x2789a
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::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 0x1ff7e
xorl %ecx, %ecx
cmpq $0x7, %rax
jb 0x23bb8
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 0x23cf0
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 0x23c26
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 0x23c0d
jmp 0x23c29
movq %rsi, %r9
leaq 0x8(%rsp), %rsi
movq %r9, (%rsi)
movq %r8, 0x8(%rsi)
movq %rdx, 0x10(%rsi)
movw $0x0, 0x18(%rsi)
callq 0x9202e
cmpq $0x0, 0x98(%rax)
je 0x23c66
movq %rax, %rsi
addq $0x88, %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq *0xa0(%rax)
jmp 0x23ce1
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq 0xfa37a(%rip), %rdi     # 0x11dff0
callq 0x113c0
movq %rax, %r15
leaq 0x9a6be(%rip), %rsi     # 0xbe343
movl $0x2d, %edx
movq %rax, %rdi
callq 0x113c0
movq %r14, %rdi
callq 0x1ff7e
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 0xfa6af(%rip), %rsi     # 0x11e388
movq %rbx, %rdi
callq 0x196f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x9a6d3(%rip), %rdi     # 0xbe3ca
leaq 0x9a6b2(%rip), %rsi     # 0xbe3b0
movq %rcx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x114c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21c0(%rip), %rdx      # 0x25f48
movq %rdx, 0x18(%rsi)
leaq 0x21b9(%rip), %rdx      # 0x25f4c
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 0x23776
movq %rax, %r14
testq %rax, %rax
je 0x23e0a
movq %r15, 0x28(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x23e3f
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq *0x18(%rdi)
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x88(%r14)
je 0x23e3f
movq %r14, %rsi
addq $0x78, %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq *0x90(%r14)
jmp 0x23e19
leaq 0xfa5af(%rip), %rsi     # 0x11e3c0
movq %rbx, %rdi
callq 0x194ee
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x23e32
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 0x23e6a
movq %rax, %rbx
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x23e62
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x2789a
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::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 0x20d1(%rip), %rdi      # 0x25f64
movq %rdi, 0x18(%rsi)
leaq 0x20ca(%rip), %rdi      # 0x25f68
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 0x238e2
movq %rax, %r15
testq %rax, %rax
je 0x23f8f
leaq 0xac6ca(%rip), %rsi     # 0xd05a6
movq %r15, %rdi
callq 0x282a0
testl %eax, %eax
je 0x23f8f
leaq 0x50(%rsp), %r14
movq %r15, -0x8(%r14)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x8d19e
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 0x23f5d
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 0x2019(%rip), %rax      # 0x25f80
movq %rax, 0x18(%rbx)
leaq 0x20c0(%rip), %rax      # 0x26032
movq %rax, 0x10(%rbx)
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x23f99
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x23f99
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x23fb2
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
jmp 0x24007
movq %rax, %rbx
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x23fe6
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x23fe6
jmp 0x24007
jmp 0x23fe3
jmp 0x24007
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x23fff
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x2789a
nop
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/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 0x20ae(%rip), %rdx      # 0x260e2
movq %rdx, 0x18(%rsi)
leaq 0x20a7(%rip), %rdx      # 0x260e6
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 0x238e2
movq %rax, %r14
testq %rax, %rax
je 0x240ea
leaq 0xac527(%rip), %rsi     # 0xd05a6
movq %r14, %rdi
callq 0x282a0
testl %eax, %eax
je 0x240ea
cmpq $0x0, 0x88(%r14)
je 0x24124
leaq 0x78(%r14), %rsi
movq %rbx, %rdi
callq *0x90(%r14)
movq %r15, 0x28(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x2411f
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq *0x18(%rdi)
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x68(%r14)
je 0x2411f
movq 0x90(%rsp), %rdx
movq %r14, %rdi
addq $0x58, %rdi
leaq 0x28(%rsp), %rsi
movq %rbx, %rcx
callq *0x70(%r14)
jmp 0x240f9
leaq 0xfa297(%rip), %rsi     # 0x11e388
movq %rbx, %rdi
callq 0x196f0
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x24112
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 0x2415c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d01a
jmp 0x2413b
movq %rax, %r14
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x24154
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x2789a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24314
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 0x242fd
movq %rsp, %rax
movq %rcx, (%rax)
movq %rsi, 0x8(%rax)
movq %rdx, 0x10(%rax)
movw $0x0, 0x18(%rax)
movq %rax, %rsi
callq 0x9202e
movq %rax, %r15
testq %r14, %r14
je 0x24353
xorl %eax, %eax
movsbq (%rbx,%rax), %rcx
xorq %r13, %rcx
imulq %r12, %rcx
incq %rax
movq %rcx, %r13
cmpq %rax, %r14
jne 0x2433a
jmp 0x24356
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 0x2438c
movups (%rsp), %xmm0
movups 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x28(%r15)
jmp 0x24398
leaq 0x20(%r15), %rdi
movq %rsp, %rdx
callq 0x28126
addq $0x38, %r15
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x1d52(%rip), %rax      # 0x260fe
movq %rax, 0x18(%rsi)
leaq 0x1d4b(%rip), %rax      # 0x26102
movq %rax, 0x10(%rsi)
movq %r15, %rdi
callq 0x92152
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x243da
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 0x2440c
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x24404
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x2789a
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Reflection/ReflMgr.cpp
// Function: ReflMgr::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 0x902c0
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 0x27dc8
movq %r13, %rdi
movq %rbp, %rsi
callq 0x90a7c
movq %rax, %r12
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x245d5
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 0x24616
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x8c60a
addq $0xd0, %r15
cmpq %r13, %r15
jne 0x245f6
xorl %ecx, %ecx
leaq 0xf9f09(%rip), %rax     # 0x11e528
movq (%rsp,%rcx,8), %rdx
testq %rdx, %rdx
jne 0x24633
incq %rcx
cmpq $0x3, %rcx
jne 0x2461f
jmp 0x2463a
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 0x24667
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23132
leaq -0x27ab(%rip), %rsi     # 0x23132
movabsq $-0x499506eb9c827484, %rax # imm = 0xB66AF914637D8B7C
movq %rax, 0x20(%rsp)
movq $0x7, 0x28(%rsp)
leaq 0x98b3a(%rip), %rax     # 0xbe436
movq %rax, 0x30(%rsp)
movw $0x0, 0x38(%rsp)
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0xf8b36(%rip), %rbx     # 0x11e458
leaq 0xab80b(%rip), %rcx     # 0xd1134
movl $0x8, %edx
movq %rbx, %rdi
callq 0x8e214
leaq -0x12cd(%rip), %rsi     # 0x24670
leaq 0x98a2d(%rip), %r8      # 0xbe371
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8e436
leaq -0x1008(%rip), %rsi     # 0x24952
leaq 0x98a19(%rip), %r8      # 0xbe37a
movl $0xe, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8e62a
leaq -0xd71(%rip), %rsi      # 0x24c06
leaq 0x97687(%rip), %r8      # 0xbd005
movl $0x8, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8e81e
leaq -0xd22(%rip), %rsi      # 0x24c72
leaq 0x989ee(%rip), %r8      # 0xbe389
movl $0x9, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8ea12
leaq -0x84b(%rip), %rsi      # 0x25166
leaq 0x97646(%rip), %r8      # 0xbcffe
movl $0x6, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8ec06
leaq -0x5f0(%rip), %rsi      # 0x253de
leaq 0x989be(%rip), %r8      # 0xbe393
movl $0xf, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8edfa
leaq -0x14f(%rip), %rsi      # 0x2589c
leaq 0x989b1(%rip), %r8      # 0xbe3a3
movl $0xc, %ecx
movq %rbx, %rdi
xorl %edx, %edx
addq $0x40, %rsp
popq %rbx
jmp 0x8efee
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd95(%rip), %rax       # 0x267c4
movq %rax, 0x38(%rsp)
leaq 0xd8d(%rip), %rax       # 0x267c8
movq %rax, 0x30(%rsp)
movq %r14, %rdi
callq 0x1ff7e
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x23156
movups 0x60(%rsp), %xmm0
movups 0x6a(%rsp), %xmm1
movups %xmm1, 0xa(%r14)
movups %xmm0, (%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movl $0x18, %edi
callq 0x11350
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
leaq 0x40(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xd47(%rip), %rax       # 0x267e0
movq %rax, 0x18(%rdx)
leaq 0xdc0(%rip), %rax       # 0x26864
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 0x8cdaa
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x25ae0
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x25af9
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x25b50
jmp 0x25b50
movq %rax, %rbx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x25b2f
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x25b2f
jmp 0x25b50
jmp 0x25b2c
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x25b48
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x2789a