// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Reflection/ReflMgrInit.cpp
// Function: ReflMgrTool::InitBaseTypes()
void InitBaseTypes() {
        auto& mgr = ReflMgr::Instance();
#define DEFTYPE(type)                                           \
        ReflMgrTool::AutoRegister<type>();                      \
        DEFCTOR(type)                                           \

#define DEFSINGLE_BASE(type, op, meta) DEFSINGLE(type, { return op; }, meta)

#define DEFCTOR(type) DEFDOUBLE(type, { *self = other; return; }, ctor)

#define DEFDOUBLE(type, func, meta)                                                     \
        mgr.AddMethod<type>(                                                            \
            std::function([](type* self, const type& other) -> decltype(auto) func),    \
            MetaMethods::operator_ ## meta                                              \
        );

#define DEFSINGLE(type, func, meta)                                                     \
        mgr.AddMethod<type>(                                                            \
            std::function([](type* self) -> decltype(auto) func),                       \
            MetaMethods::operator_ ## meta                                              \
        );                                                                              \

        DEFTYPE(ObjectPtr);
        DEFTYPE(SharedObject);

#define DEFINT(num)                                                                     \
        DEFTYPE(num);                                                                   \

        DEFINT(int);
        DEFINT(char);
        DEFINT(size_t);
        DEFINT(int64_t);
        DEFTYPE(float);
        DEFTYPE(double);
        DEFTYPE(bool);

#define DEFVEC(type) DEFVEC_BASE(std::vector<type>, type)
#define DEFVEC_BASE(type, elem)                                         \
        ReflMgrTool::AutoRegister<type>();                              \
        AutoRegister<type::iterator>();                                 \
        DEFCTOR(type);                                                  \
        DEFSINGLE(type, {                                               \
            std::stringstream ss;                                       \
            printVec(ss, *self);                                        \
            return (std::string)(ss.str());                             \
        }, tostring)                                                    \

        /*
        DEFVEC(ObjectPtr);
        DEFVEC(SharedObject);
        DEFVEC(int);
        DEFVEC(float);
        DEFVEC(std::string);
        */
        DEFVEC(ReflMgr::Any);
        AutoRegister<std::string>();
        AutoRegister<std::string::iterator>();
        DEFSINGLE(std::string, {
            return std::string(*self);
        }, tostring);
        DEFCTOR(std::string);

        ReflMgrTool::AutoRegister<std::string_view>();
        ReflMgrTool::AutoRegister<std::string_view::iterator>();

#define DEFMAP(key, value)                                                      \
        do {                                                                    \
            using type = std::map<key, value>;                                  \
            AutoRegister<type>();                                               \
            AutoRegister<type::iterator>();                                     \
            DEFSINGLE(type, {                                                   \
                std::stringstream ss;                                           \
                printMap(ss, *self);                                            \
                return (std::string)(ss.str());                                 \
            }, tostring)                                                        \
        } while (0)

        DEFMAP(ReflMgr::Any, ReflMgr::Any);
        /*
#define DEFHASHMAP(key, value)                                                  \
        do {                                                                    \
            using type = std::unordered_map<key, value>;                        \
            AutoRegister<type>();                                               \
            AutoRegister<type::iterator>();                                     \
            DEFSINGLE(type, {                                                   \
                std::stringstream ss;                                           \
                printMap(ss, *self);                                            \
                return (std::string)(ss.str());                                 \
            }, tostring)                                                        \
        } while (0)

#define DEFMAP_FOR(type)                                \
        DEFMAP(type, int);                              \
        DEFMAP(type, float);                            \
        DEFMAP(type, std::string);                      \
        DEFMAP(type, SharedObject);                     \
        DEFMAP(type, ObjectPtr);                        \
        DEFMAP(type, ReflMgr::Any)

#define DEFHASHMAP_FOR(type)                            \
        DEFHASHMAP(type, int);                          \
        DEFHASHMAP(type, float);                        \
        DEFHASHMAP(type, std::string);                  \
        DEFHASHMAP(type, SharedObject);                 \
        DEFHASHMAP(type, ObjectPtr);                    \
        DEFHASHMAP(type, ReflMgr::Any)

        DEFMAP_FOR(int);
        DEFMAP_FOR(float);
        DEFMAP_FOR(std::string);
        DEFMAP_FOR(SharedObject);
        DEFMAP_FOR(ObjectPtr);

        DEFHASHMAP_FOR(int);
        DEFHASHMAP_FOR(float);
        DEFHASHMAP_FOR(std::string);
        */

#undef DEFMAP_FOR
#undef DEFMAP
#undef DEFINT
#undef DEFVEC_BASE
#undef DEFVEC
#undef DEFOBJ
#undef DEFSINGLE
#undef DEFDOUBLE
#undef DEFSINGLE_BASE
#undef DEFTYPE
#undef DEFCTOR
    }

// Assembly:
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
callq 0x23132
movq %rax, %rbx
callq 0x28ad8
xorps %xmm0, %xmm0
leaq 0x1a0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x91e(%rip), %rax       # 0x1da18
movq %rax, 0x18(%rsi)
leaq 0x92d(%rip), %rax       # 0x1da32
movq %rax, 0x10(%rsi)
leaq 0x9fcdf(%rip), %rcx     # 0xbcdef
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2967a
movq 0x1b0(%rsp), %rax
testq %rax, %rax
je 0x1d13c
leaq 0x1a0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x298bb
xorps %xmm0, %xmm0
leaq 0x180(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8f4(%rip), %rax       # 0x1da4a
movq %rax, 0x18(%rsi)
leaq 0x929(%rip), %rax       # 0x1da8a
movq %rax, 0x10(%rsi)
leaq 0x9fc83(%rip), %rcx     # 0xbcdef
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2a4ea
movq 0x190(%rsp), %rax
testq %rax, %rax
je 0x1d198
leaq 0x180(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2a72b
xorps %xmm0, %xmm0
leaq 0x160(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8f0(%rip), %rax       # 0x1daa2
movq %rax, 0x18(%rsi)
leaq 0x8ed(%rip), %rax       # 0x1daaa
movq %rax, 0x10(%rsi)
leaq 0x9fc27(%rip), %rcx     # 0xbcdef
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2b1b6
movq 0x170(%rsp), %rax
testq %rax, %rax
je 0x1d1f4
leaq 0x160(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2b3f7
xorps %xmm0, %xmm0
leaq 0x140(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8b4(%rip), %rax       # 0x1dac2
movq %rax, 0x18(%rsi)
leaq 0x8b1(%rip), %rax       # 0x1daca
movq %rax, 0x10(%rsi)
leaq 0x9fbcb(%rip), %rcx     # 0xbcdef
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2bdf6
movq 0x150(%rsp), %rax
testq %rax, %rax
je 0x1d250
leaq 0x140(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2c037
xorps %xmm0, %xmm0
leaq 0x120(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x878(%rip), %rax       # 0x1dae2
movq %rax, 0x18(%rsi)
leaq 0x877(%rip), %rax       # 0x1daec
movq %rax, 0x10(%rsi)
leaq 0x9fb6f(%rip), %rcx     # 0xbcdef
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2cac2
movq 0x130(%rsp), %rax
testq %rax, %rax
je 0x1d2ac
leaq 0x120(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2cd03
xorps %xmm0, %xmm0
leaq 0x100(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x83e(%rip), %rax       # 0x1db04
movq %rax, 0x18(%rsi)
leaq 0x83d(%rip), %rax       # 0x1db0e
movq %rax, 0x10(%rsi)
leaq 0x9fb13(%rip), %rcx     # 0xbcdef
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2d78e
movq 0x110(%rsp), %rax
testq %rax, %rax
je 0x1d308
leaq 0x100(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2d9cf
xorps %xmm0, %xmm0
leaq 0xe0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x804(%rip), %rax       # 0x1db26
movq %rax, 0x18(%rsi)
leaq 0x805(%rip), %rax       # 0x1db32
movq %rax, 0x10(%rsi)
leaq 0x9fab7(%rip), %rcx     # 0xbcdef
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2e3ce
movq 0xf0(%rsp), %rax
testq %rax, %rax
je 0x1d364
leaq 0xe0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2e60f
xorps %xmm0, %xmm0
leaq 0xc0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x7cc(%rip), %rax       # 0x1db4a
movq %rax, 0x18(%rsi)
leaq 0x7cd(%rip), %rax       # 0x1db56
movq %rax, 0x10(%rsi)
leaq 0x9fa5b(%rip), %rcx     # 0xbcdef
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2f00e
movq 0xd0(%rsp), %rax
testq %rax, %rax
je 0x1d3c0
leaq 0xc0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2f24f
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x794(%rip), %rax       # 0x1db6e
movq %rax, 0x18(%rsi)
leaq 0x791(%rip), %rax       # 0x1db76
movq %rax, 0x10(%rsi)
leaq 0x9f9ff(%rip), %rcx     # 0xbcdef
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2fa1e
movq 0xb0(%rsp), %rax
testq %rax, %rax
je 0x1d41c
leaq 0xa0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2fc5f
callq 0x3042d
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x753(%rip), %rax       # 0x1db8e
movq %rax, 0x18(%rsi)
leaq 0x754(%rip), %rax       # 0x1db9a
movq %rax, 0x10(%rsi)
leaq 0x9f99e(%rip), %rcx     # 0xbcdef
movl $0x6, %edx
movq %rbx, %rdi
callq 0x30bfc
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0x1d47d
leaq 0x80(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x723(%rip), %rax       # 0x1dbb2
movq %rax, 0x18(%rsi)
leaq 0x874(%rip), %rax       # 0x1dd0e
movq %rax, 0x10(%rsi)
leaq 0x9f93f(%rip), %rcx     # 0xbcde4
movl $0xa, %edx
movq %rbx, %rdi
callq 0x30e3e
movq 0x70(%rsp), %rax
testq %rax, %rax
je 0x1d4cb
leaq 0x60(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x3107f
callq 0x31965
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x83f(%rip), %rax       # 0x1dd26
movq %rax, 0x18(%rsi)
leaq 0x856(%rip), %rax       # 0x1dd48
movq %rax, 0x10(%rsi)
leaq 0x9f8e7(%rip), %rcx     # 0xbcde4
movl $0xa, %edx
movq %rbx, %rdi
callq 0x32134
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x1d523
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x82b(%rip), %rax       # 0x1dd60
movq %rax, 0x18(%rsi)
leaq 0x82c(%rip), %rax       # 0x1dd6c
movq %rax, 0x10(%rsi)
leaq 0x9f8a4(%rip), %rcx     # 0xbcdef
movl $0x6, %edx
movq %rbx, %rdi
callq 0x32376
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1d571
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x325b7
callq 0x32cf9
callq 0x33553
callq 0x33c95
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x7ef(%rip), %rax       # 0x1dd84
movq %rax, 0x18(%rsi)
leaq 0xa08(%rip), %rax       # 0x1dfa8
movq %rax, 0x10(%rsi)
leaq 0x9f839(%rip), %rcx     # 0xbcde4
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3411c
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1d5cf
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
retq
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
jmp 0x1d884
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1d87c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0x70(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0x60(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0x80(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0xb0(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0xa0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0xd0(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0xc0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0xf0(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0xe0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0x110(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0x100(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0x130(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0x120(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0x150(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0x140(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0x170(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0x160(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0x190(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0x180(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1d87c
jmp 0x1d884
movq %rax, %rbx
movq 0x1b0(%rsp), %rax
testq %rax, %rax
je 0x1d87c
leaq 0x1a0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x2789a