// File: /workspace/github_cpp_makefile_star2_O3/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 0x227b2
movq %rax, %rbx
callq 0x28082
xorps %xmm0, %xmm0
leaq 0x1a0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x91e(%rip), %rax       # 0x1d058
movq %rax, 0x18(%rsi)
leaq 0x92d(%rip), %rax       # 0x1d072
movq %rax, 0x10(%rsi)
leaq 0x9f66f(%rip), %rcx     # 0xbbdbf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x28c1e
movq 0x1b0(%rsp), %rax
testq %rax, %rax
je 0x1c77c
leaq 0x1a0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x28e55
xorps %xmm0, %xmm0
leaq 0x180(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8f4(%rip), %rax       # 0x1d08a
movq %rax, 0x18(%rsi)
leaq 0x929(%rip), %rax       # 0x1d0ca
movq %rax, 0x10(%rsi)
leaq 0x9f613(%rip), %rcx     # 0xbbdbf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x29a7c
movq 0x190(%rsp), %rax
testq %rax, %rax
je 0x1c7d8
leaq 0x180(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x29cb3
xorps %xmm0, %xmm0
leaq 0x160(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8f0(%rip), %rax       # 0x1d0e2
movq %rax, 0x18(%rsi)
leaq 0x8ed(%rip), %rax       # 0x1d0ea
movq %rax, 0x10(%rsi)
leaq 0x9f5b7(%rip), %rcx     # 0xbbdbf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2a736
movq 0x170(%rsp), %rax
testq %rax, %rax
je 0x1c834
leaq 0x160(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2a96d
xorps %xmm0, %xmm0
leaq 0x140(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x8b4(%rip), %rax       # 0x1d102
movq %rax, 0x18(%rsi)
leaq 0x8b1(%rip), %rax       # 0x1d10a
movq %rax, 0x10(%rsi)
leaq 0x9f55b(%rip), %rcx     # 0xbbdbf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2b364
movq 0x150(%rsp), %rax
testq %rax, %rax
je 0x1c890
leaq 0x140(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2b59b
xorps %xmm0, %xmm0
leaq 0x120(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x878(%rip), %rax       # 0x1d122
movq %rax, 0x18(%rsi)
leaq 0x877(%rip), %rax       # 0x1d12c
movq %rax, 0x10(%rsi)
leaq 0x9f4ff(%rip), %rcx     # 0xbbdbf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2c01e
movq 0x130(%rsp), %rax
testq %rax, %rax
je 0x1c8ec
leaq 0x120(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2c255
xorps %xmm0, %xmm0
leaq 0x100(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x83e(%rip), %rax       # 0x1d144
movq %rax, 0x18(%rsi)
leaq 0x83d(%rip), %rax       # 0x1d14e
movq %rax, 0x10(%rsi)
leaq 0x9f4a3(%rip), %rcx     # 0xbbdbf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2ccd8
movq 0x110(%rsp), %rax
testq %rax, %rax
je 0x1c948
leaq 0x100(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2cf0f
xorps %xmm0, %xmm0
leaq 0xe0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x804(%rip), %rax       # 0x1d166
movq %rax, 0x18(%rsi)
leaq 0x805(%rip), %rax       # 0x1d172
movq %rax, 0x10(%rsi)
leaq 0x9f447(%rip), %rcx     # 0xbbdbf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2d906
movq 0xf0(%rsp), %rax
testq %rax, %rax
je 0x1c9a4
leaq 0xe0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2db3d
xorps %xmm0, %xmm0
leaq 0xc0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x7cc(%rip), %rax       # 0x1d18a
movq %rax, 0x18(%rsi)
leaq 0x7cd(%rip), %rax       # 0x1d196
movq %rax, 0x10(%rsi)
leaq 0x9f3eb(%rip), %rcx     # 0xbbdbf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2e534
movq 0xd0(%rsp), %rax
testq %rax, %rax
je 0x1ca00
leaq 0xc0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2e76b
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x794(%rip), %rax       # 0x1d1ae
movq %rax, 0x18(%rsi)
leaq 0x791(%rip), %rax       # 0x1d1b6
movq %rax, 0x10(%rsi)
leaq 0x9f38f(%rip), %rcx     # 0xbbdbf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2ef32
movq 0xb0(%rsp), %rax
testq %rax, %rax
je 0x1ca5c
leaq 0xa0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x2f169
callq 0x2f930
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x753(%rip), %rax       # 0x1d1ce
movq %rax, 0x18(%rsi)
leaq 0x754(%rip), %rax       # 0x1d1da
movq %rax, 0x10(%rsi)
leaq 0x9f32e(%rip), %rcx     # 0xbbdbf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x300f8
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0x1cabd
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       # 0x1d1f2
movq %rax, 0x18(%rsi)
leaq 0x874(%rip), %rax       # 0x1d34e
movq %rax, 0x10(%rsi)
leaq 0x9f2cf(%rip), %rcx     # 0xbbdb4
movl $0xa, %edx
movq %rbx, %rdi
callq 0x30330
movq 0x70(%rsp), %rax
testq %rax, %rax
je 0x1cb0b
leaq 0x60(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x30567
callq 0x30e46
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x83f(%rip), %rax       # 0x1d366
movq %rax, 0x18(%rsi)
leaq 0x856(%rip), %rax       # 0x1d388
movq %rax, 0x10(%rsi)
leaq 0x9f277(%rip), %rcx     # 0xbbdb4
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3160e
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x1cb63
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       # 0x1d3a0
movq %rax, 0x18(%rsi)
leaq 0x82c(%rip), %rax       # 0x1d3ac
movq %rax, 0x10(%rsi)
leaq 0x9f234(%rip), %rcx     # 0xbbdbf
movl $0x6, %edx
movq %rbx, %rdi
callq 0x31846
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1cbb1
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
callq 0x31a7d
callq 0x321b8
callq 0x32a0b
callq 0x33146
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x7ef(%rip), %rax       # 0x1d3c4
movq %rax, 0x18(%rsi)
leaq 0xa22(%rip), %rax       # 0x1d602
movq %rax, 0x10(%rsi)
leaq 0x9f1c9(%rip), %rcx     # 0xbbdb4
movl $0xa, %edx
movq %rbx, %rdi
callq 0x335c6
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1cc0f
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
retq
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
jmp 0x1cec4
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1cebc
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0x40(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0x70(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0x60(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0x90(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0x80(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0xb0(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0xa0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0xd0(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0xc0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0xf0(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0xe0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0x110(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0x100(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0x130(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0x120(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0x150(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0x140(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0x170(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0x160(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0x190(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0x180(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1cebc
jmp 0x1cec4
movq %rax, %rbx
movq 0x1b0(%rsp), %rax
testq %rax, %rax
je 0x1cebc
leaq 0x1a0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x11580
movq %rax, %rdi
callq 0x26e38