// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
callq 0x1df9e
movq %rax, %rbx
callq 0x22c0e
xorps %xmm0, %xmm0
leaq 0x1a0(%rsp), %r14
movaps %xmm0, (%r14)
leaq 0x5b7(%rip), %rax       # 0x1a1e8
movq %rax, 0x18(%r14)
leaq 0x5c6(%rip), %rax       # 0x1a202
movq %rax, 0x10(%r14)
leaq 0x7c19f(%rip), %rcx     # 0x95de6
pushq $0x6
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23314
leaq 0x1a0(%rsp), %rdi
callq 0x21f04
callq 0x23429
leaq 0x180(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x59d(%rip), %rax       # 0x1a21a
movq %rax, 0x18(%r14)
leaq 0x59e(%rip), %rax       # 0x1a226
movq %rax, 0x10(%r14)
leaq 0x7c153(%rip), %rcx     # 0x95de6
pushq $0x6
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23b82
leaq 0x180(%rsp), %rdi
callq 0x21f04
callq 0x23c97
xorps %xmm0, %xmm0
leaq 0x160(%rsp), %r14
movaps %xmm0, (%r14)
leaq 0x575(%rip), %rax       # 0x1a23e
movq %rax, 0x18(%r14)
leaq 0x572(%rip), %rax       # 0x1a246
movq %rax, 0x10(%r14)
leaq 0x7c107(%rip), %rcx     # 0x95de6
pushq $0x6
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x242f6
leaq 0x160(%rsp), %rdi
callq 0x21f04
callq 0x2440b
leaq 0x140(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x549(%rip), %rax       # 0x1a25e
movq %rax, 0x18(%r14)
leaq 0x546(%rip), %rax       # 0x1a266
movq %rax, 0x10(%r14)
leaq 0x7c0bb(%rip), %rcx     # 0x95de6
pushq $0x6
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24a18
leaq 0x140(%rsp), %rdi
callq 0x21f04
callq 0x24b2d
xorps %xmm0, %xmm0
leaq 0x120(%rsp), %r14
movaps %xmm0, (%r14)
leaq 0x51d(%rip), %rax       # 0x1a27e
movq %rax, 0x18(%r14)
leaq 0x51c(%rip), %rax       # 0x1a288
movq %rax, 0x10(%r14)
leaq 0x7c06f(%rip), %rcx     # 0x95de6
pushq $0x6
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2518c
leaq 0x120(%rsp), %rdi
callq 0x21f04
callq 0x252a1
leaq 0x100(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x4f3(%rip), %rax       # 0x1a2a0
movq %rax, 0x18(%r14)
leaq 0x4f2(%rip), %rax       # 0x1a2aa
movq %rax, 0x10(%r14)
leaq 0x7c023(%rip), %rcx     # 0x95de6
pushq $0x6
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25900
leaq 0x100(%rsp), %rdi
callq 0x21f04
callq 0x25a15
xorps %xmm0, %xmm0
leaq 0xe0(%rsp), %r14
movaps %xmm0, (%r14)
leaq 0x4c9(%rip), %rax       # 0x1a2c2
movq %rax, 0x18(%r14)
leaq 0x4ca(%rip), %rax       # 0x1a2ce
movq %rax, 0x10(%r14)
leaq 0x7bfd7(%rip), %rcx     # 0x95de6
pushq $0x6
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26022
leaq 0xe0(%rsp), %rdi
callq 0x21f04
callq 0x26137
leaq 0xc0(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x4a1(%rip), %rax       # 0x1a2e6
movq %rax, 0x18(%r14)
leaq 0x4a2(%rip), %rax       # 0x1a2f2
movq %rax, 0x10(%r14)
leaq 0x7bf8b(%rip), %rcx     # 0x95de6
pushq $0x6
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26744
leaq 0xc0(%rsp), %rdi
callq 0x21f04
callq 0x26859
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %r14
movaps %xmm0, (%r14)
leaq 0x479(%rip), %rax       # 0x1a30a
movq %rax, 0x18(%r14)
leaq 0x476(%rip), %rax       # 0x1a312
movq %rax, 0x10(%r14)
leaq 0x7bf3f(%rip), %rcx     # 0x95de6
pushq $0x6
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26d1a
leaq 0xa0(%rsp), %rdi
callq 0x21f04
callq 0x26e2f
callq 0x272ef
leaq 0x80(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x448(%rip), %rax       # 0x1a32a
movq %rax, 0x18(%r14)
leaq 0x449(%rip), %rax       # 0x1a336
movq %rax, 0x10(%r14)
leaq 0x7beee(%rip), %rcx     # 0x95de6
pushq $0x6
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x277b0
leaq 0x80(%rsp), %rdi
callq 0x21f04
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %r14
movaps %xmm0, (%r14)
leaq 0x428(%rip), %rax       # 0x1a34e
movq %rax, 0x18(%r14)
leaq 0x517(%rip), %rax       # 0x1a448
movq %rax, 0x10(%r14)
leaq 0x7be9f(%rip), %rcx     # 0x95ddb
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x278c6
leaq 0x60(%rsp), %rdi
callq 0x21f04
callq 0x279db
callq 0x27f41
leaq 0x40(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x4ef(%rip), %rax       # 0x1a460
movq %rax, 0x18(%r14)
leaq 0x4f6(%rip), %rax       # 0x1a472
movq %rax, 0x10(%r14)
leaq 0x7be54(%rip), %rcx     # 0x95ddb
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28402
leaq 0x40(%rsp), %rdi
callq 0x21f04
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
leaq 0x4d8(%rip), %rax       # 0x1a48a
movq %rax, 0x18(%r14)
leaq 0x4d9(%rip), %rax       # 0x1a496
movq %rax, 0x10(%r14)
leaq 0x7be1e(%rip), %rcx     # 0x95de6
pushq $0x6
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28518
leaq 0x20(%rsp), %rdi
callq 0x21f04
callq 0x2862d
callq 0x28a97
callq 0x28faa
callq 0x29414
movq %rsp, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x4a9(%rip), %rax       # 0x1a4ae
movq %rax, 0x18(%r14)
leaq 0x630(%rip), %rax       # 0x1a640
movq %rax, 0x10(%r14)
leaq 0x7bdc0(%rip), %rcx     # 0x95ddb
pushq $0xa
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x296e8
movq %rsp, %rdi
callq 0x21f04
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
retq
jmp 0x1a056
jmp 0x1a056
jmp 0x1a056
jmp 0x1a056
jmp 0x1a056
jmp 0x1a056
jmp 0x1a056
jmp 0x1a056
jmp 0x1a056
jmp 0x1a056
jmp 0x1a056
jmp 0x1a056
jmp 0x1a056
movq %rax, %rbx
movq %r14, %rdi
callq 0x21f04
movq %rbx, %rdi
callq 0x11570