LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/macfergus[P]baduk/cppsrc/baduk/board.cpp
// Function: baduk::Board::validate() const
void Board::validate() const {
    for (const auto& go_string_idx : grid_) {
        if (go_string_idx == EMPTY) {
            continue;
        }
        const GoString& go_string = strings_[go_string_idx];
        for (const auto point : go_string.stones()) {
            assert(!isEmpty(point));
            assert(at(point) == go_string.color());
        }
        for (const auto point : go_string.liberties()) {
            assert(isEmpty(point));
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x5c8(%rdi), %r13
movl $0x20, %ebp
leaq 0x10(%rsp), %r15
movq %rsp, %r12
movslq (%rbx,%rbp), %rax
cmpq $-0x1, %rax
je 0x10a02
imulq $0x78, %rax, %rax
leaq (%rax,%r13), %r14
movq 0x38(%r13,%rax), %rcx
movq %rcx, 0x50(%rsp)
movups 0x8(%r13,%rax), %xmm0
movups 0x18(%r13,%rax), %xmm1
movups 0x28(%r13,%rax), %xmm2
movaps %xmm2, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4f10
movq %rax, 0x10(%rsp)
movl %edx, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4f56
movq %rax, (%rsp)
movl %edx, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4d56
testb %al, %al
je 0x10981
movq %r15, %rdi
callq 0x4d2a
movl 0xc(%rbx), %ecx
imull %eax, %ecx
shrq $0x20, %rax
addl %eax, %ecx
movslq 0x20(%rbx,%rcx,4), %rax
cmpq $-0x1, %rax
je 0x10a41
imulq $0x78, %rax, %rax
movl (%r13,%rax), %eax
cmpl (%r14), %eax
jne 0x10a60
movq %r15, %rdi
callq 0x4cda
jmp 0x10933
movq 0x70(%r14), %rax
movq %rax, 0x50(%rsp)
movups 0x40(%r14), %xmm0
movups 0x50(%r14), %xmm1
movups 0x60(%r14), %xmm2
movaps %xmm2, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x4f10
movq %rax, 0x10(%rsp)
movl %edx, 0x18(%rsp)
movq %r14, %rdi
callq 0x4f56
movq %rax, (%rsp)
movl %edx, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4d56
testb %al, %al
je 0x10a02
movq %r15, %rdi
callq 0x4d2a
movl 0xc(%rbx), %ecx
imull %eax, %ecx
shrq $0x20, %rax
addl %eax, %ecx
cmpl $-0x1, 0x20(%rbx,%rcx,4)
jne 0x10a22
movq %r15, %rdi
callq 0x4cda
jmp 0x109ce
addq $0x4, %rbp
cmpq $0x5c4, %rbp            # imm = 0x5C4
jne 0x108cd
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b1d(%rip), %rdi      # 0x14546
leaq 0x3ad7(%rip), %rsi      # 0x14507
leaq 0x3b1e(%rip), %rcx      # 0x14555
movl $0xb4, %edx
callq 0x3110
leaq 0x3afd(%rip), %rdi      # 0x14545
leaq 0x3ab8(%rip), %rsi      # 0x14507
leaq 0x3aff(%rip), %rcx      # 0x14555
movl $0xb0, %edx
callq 0x3110
leaq 0x3b12(%rip), %rdi      # 0x14579
leaq 0x3a99(%rip), %rsi      # 0x14507
leaq 0x3ae0(%rip), %rcx      # 0x14555
movl $0xb1, %edx
callq 0x3110
nop
// File: /workspace/github_cpp_makefile_star2_O1/macfergus[P]baduk/cppsrc/baduk/board.cpp
// Function: baduk::Board::operator==(baduk::Board const&) const
bool Board::operator==(Board const& b) const {
    if (num_rows_ != b.num_rows_ || num_cols_ != b.num_cols_) {
        return false;
    }
    for (unsigned int r = 0; r < num_rows_; ++r) {
        for (unsigned int c = 0; c < num_cols_; ++c) {
            Point p(r, c);
            if (isEmpty(p) != b.isEmpty(p)) {
                return false;
            }
            if (!isEmpty(p)) {
                if (at(p) != b.at(p)) {
                    return false;
                }
            }
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x8(%rdi), %eax
movl %eax, -0xc(%rsp)
cmpl 0x8(%rsi), %eax
jne 0x10b8d
movl 0xc(%rdi), %edx
movl 0xc(%rsi), %eax
movq %rax, -0x8(%rsp)
cmpl %eax, %edx
jne 0x10b8d
cmpl $0x0, -0xc(%rsp)
sete %al
je 0x10b8f
testq %rdx, %rdx
setne -0xd(%rsp)
movl $0x5c8, %r10d           # imm = 0x5C8
leaq (%rdi,%r10), %r11
addq %rsi, %r10
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x10b74
movl %ebp, %ecx
imull %edx, %ecx
movq -0x8(%rsp), %r15
imull %ebp, %r15d
movl 0x20(%rdi,%rcx,4), %r13d
cmpl $-0x1, %r13d
sete %r9b
movl 0x20(%rsi,%r15,4), %ecx
cmpl $-0x1, %ecx
sete %r15b
xorb %r9b, %r15b
movb -0xd(%rsp), %r12b
jne 0x10b6e
movl $0x1, %r15d
movb -0xd(%rsp), %r12b
testb $0x1, %r9b
jne 0x10b3a
movslq %r13d, %r8
imulq $0x78, %r8, %r8
movl (%r11,%r8), %r8d
movslq %ecx, %rcx
imulq $0x78, %rcx, %rcx
cmpl (%r10,%rcx), %r8d
jne 0x10b6e
cmpq %r15, %rdx
je 0x10b74
seta %r12b
leal (%rbx,%r15), %ecx
movl 0x20(%rdi,%rcx,4), %r13d
cmpl $-0x1, %r13d
sete %r9b
leal (%r14,%r15), %ecx
movl 0x20(%rsi,%rcx,4), %ecx
cmpl $-0x1, %ecx
sete %r8b
xorb %r9b, %r8b
incq %r15
testb %r8b, %r8b
je 0x10b1c
testb $0x1, %r12b
jne 0x10b8f
incl %ebp
addq -0x8(%rsp), %r14
addq %rdx, %rbx
cmpl -0xc(%rsp), %ebp
setae %al
jne 0x10ad7
jmp 0x10b8f
xorl %eax, %eax
andb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/macfergus[P]baduk/cppsrc/baduk/board.cpp
// Function: baduk::operator<<(std::ostream&, baduk::Board const&)
std::ostream& operator<<(std::ostream& out, Board const& board) {
    for (int r = board.numRows() - 1; r >= 0; --r) {
        if (r + 1 < 10) {
            out << " ";
        }
        out << r + 1 << " ";
        for (unsigned int c = 0; c < board.numCols(); ++c) {
            baduk::Point p(static_cast<unsigned int>(r), c);
            if (board.isEmpty(p)) {
                out << ".";
            } else {
                const auto stone = board.at(p);
                out << (stone == baduk::Stone::black ? "x" : "o");
            }
        }
        out << "\n";
    }
    out << "   ";
    for (unsigned int c = 0; c < board.numCols(); ++c) {
        out << COLS.at(c);
    }
    out << "\n";

    return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %ebp
movl %ebp, %eax
decl %eax
js 0x10ed8
leaq 0x5c8(%r14), %r13
leaq 0x376d(%rip), %r12      # 0x14598
movl %eax, %r15d
cmpl $0x9, %ebp
jg 0x10e47
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x3760(%rip), %rsi      # 0x145a2
callq 0x31d0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3280
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3742(%rip), %rsi      # 0x145a2
callq 0x31d0
movl 0xc(%r14), %eax
testl %eax, %eax
je 0x10eb4
xorl %ebp, %ebp
imull %r15d, %eax
addl %ebp, %eax
movslq 0x20(%r14,%rax,4), %rax
movq %r12, %rsi
cmpq $-0x1, %rax
je 0x10e9d
imulq $0x78, %rax, %rax
cmpl $0x0, (%r13,%rax)
leaq 0x3706(%rip), %rsi      # 0x1459a
je 0x10e9d
leaq 0x36ff(%rip), %rsi      # 0x1459c
movl $0x1, %edx
movq %rbx, %rdi
callq 0x31d0
incl %ebp
movl 0xc(%r14), %eax
cmpl %eax, %ebp
jb 0x10e6f
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x36db(%rip), %rsi      # 0x1459e
callq 0x31d0
leal -0x1(%r15), %eax
movl %r15d, %ebp
testl %r15d, %r15d
jg 0x10e2b
leaq 0x36c1(%rip), %rsi      # 0x145a0
movl $0x3, %edx
movq %rbx, %rdi
callq 0x31d0
cmpl $0x0, 0xc(%r14)
je 0x10f2f
xorl %r15d, %r15d
leaq 0x7(%rsp), %r12
movq 0x8306(%rip), %rdx      # 0x19208
cmpq %r15, %rdx
jbe 0x10f55
movq 0x82f2(%rip), %rax      # 0x19200
movb (%rax,%r15), %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x31d0
incq %r15
cmpl 0xc(%r14), %r15d
jb 0x10efb
leaq 0x3668(%rip), %rsi      # 0x1459e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x31d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3648(%rip), %rdi      # 0x145a4
movq %r15, %rsi
xorl %eax, %eax
callq 0x3230
// File: /workspace/github_cpp_makefile_star2_O1/macfergus[P]baduk/cppsrc/baduk/board.cpp
// Function: baduk::Board::stringsBegin() const
StringIter Board::stringsBegin() const {
    // Find the first used string.
    unsigned int first = 0;
    for (; first < strings_.size(); ++first) {
        if (used_[first]) {
            break;
        }
    }
    return StringIter(this, first);
}

// Assembly:
movq %rdi, %rax
xorl %edx, %edx
movq %rdx, %rcx
shrq $0x6, %rcx
movq 0x5b18(%rax,%rcx,8), %rcx
btq %rdx, %rcx
jb 0x10f91
incq %rdx
cmpq $0xb6, %rdx
jne 0x10f6b
movl $0xb6, %edx
retq
// File: /workspace/github_cpp_makefile_star2_O1/macfergus[P]baduk/cppsrc/baduk/board.cpp
// Function: baduk::StringIter::operator++()
StringIter& StringIter::operator++() {
    ++i_;
    while (i_ < board_->strings_.size() && !board_->used_[i_]) {
        ++i_;
    }
    return *this;
}

// Assembly:
movq %rdi, %rax
movl 0x8(%rdi), %ecx
movq (%rdi), %rdx
leal 0x1(%rcx), %edi
cmpl $0xb7, %edi
movl $0xb6, %esi
cmovael %edi, %esi
incl %ecx
cmpl $0xb5, %ecx
ja 0x10fdd
movl %ecx, %edi
shrl $0x6, %edi
movq 0x5b18(%rdx,%rdi,8), %rdi
btq %rcx, %rdi
jae 0x10fbe
jmp 0x10fdf
movl %esi, %ecx
movl %ecx, 0x8(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/superblocks[P]superblocks/set-grw.cpp
// Function: Superblocks::init()
void Superblocks::init() {

  coin = "GRW"; 
	coin_name = "Growthcoin";

	hash_length = 64;

	// normal (step 0)
	reward[0] = 100;

	// superblocks

	seed_type[1] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[1] = 7;
	cutout_length[1] = 7;
	rnd_range_low[1] = 1;
	rnd_range_high[1] = 8000;
	luck_type[1] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[1] = 5000;
	luck_y[1] = 5101;
		secondary_rand[1] = 1;
		secondary_rand_type[1] = SECONDARY_REWARD_PLUS_RAND_MINUS_X;
		secondary_cutout_start[1] = 10;
		secondary_cutout_length[1] = 7; 
		secondary_rand_low[1] = 1;
		secondary_rand_high[1] = 501;
		secondary_rand_x[1] = 0;
	reward[1] = 499;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
movq 0x20(%rbx), %rdx
leaq 0x1334(%rip), %rcx      # 0x3e80
movl $0x3, %r8d
xorl %esi, %esi
callq 0x1120
leaq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rdx
leaq 0x131c(%rip), %rcx      # 0x3e84
movl $0xa, %r8d
xorl %esi, %esi
callq 0x1120
movl $0x40, 0x58(%rbx)
movl $0x2, 0x60(%rbx)
movl $0x7, %eax
movl %eax, 0x68(%rbx)
movl %eax, 0x70(%rbx)
movl $0x1, %ecx
movl %ecx, 0x78(%rbx)
movl $0x1f40, 0x80(%rbx)     # imm = 0x1F40
movl $0x3, 0xc0(%rbx)
movl $0x1388, 0xc8(%rbx)     # imm = 0x1388
movabsq $0x64000013ed, %rdx     # imm = 0x64000013ED
movq %rdx, 0xd0(%rbx)
movl %ecx, 0x88(%rbx)
movl %ecx, 0x90(%rbx)
movl $0xa, 0xb0(%rbx)
movl %eax, 0xb8(%rbx)
movl %ecx, 0x98(%rbx)
movl $0x1f5, 0xa0(%rbx)      # imm = 0x1F5
movl $0x0, 0xa8(%rbx)
movl $0x1f3, 0xd8(%rbx)      # imm = 0x1F3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/miguelmartin75[P]StringUtils/tests/../include/util/string_utils.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::center_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, char)
Str center_string(const Str& str, int amountOfCharactersInLine, char fillChar= ' ')
    {
        std::size_t halfStringSize = str.length() / 2;
        std::size_t amountOfFillCharactersRequired = (amountOfCharactersInLine / 2) - halfStringSize;

        Str fillCharacter(amountOfFillCharactersRequired, fillChar);

        return fillCharacter + str + fillCharacter;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
shrq %rax
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
movslq %esi, %rsi
subq %rax, %rsi
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movl %ecx, %edx
callq 0x21d0
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x61de
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x2070
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x5d6b
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x5d71
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)
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d9a
callq 0x2180
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x5da8
callq 0x2180
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5dd2
callq 0x2180
jmp 0x5dd2
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x5de0
callq 0x2180
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/miguelmartin75[P]StringUtils/tests/../include/util/string_utils.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> util::get_extension<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Str get_extension(const Str& str)
    {
        Str extension; // Holds the extension

        size_t sizeOfStringUntilExtension = 0;
        size_t sizeOfExtension = 0; // How many characters are in the extension

        for(size_t i = 0; i < str.size(); ++i)
        {
            if(str[i] == '.')
            {
                sizeOfStringUntilExtension = i + 1;
            }
        }

        sizeOfExtension = static_cast<int>(str.size() - sizeOfStringUntilExtension);

        extension = str.substr(str.size() - sizeOfExtension);
        return extension;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x68f1
movq (%rsi), %rcx
movq %rdx, %rdi
negq %rdi
movl $0x1, %r8d
xorl %eax, %eax
cmpb $0x2e, -0x1(%rcx,%r8)
cmoveq %r8, %rax
leaq (%rdi,%r8), %r9
incq %r9
incq %r8
cmpq $0x1, %r9
jne 0x68d5
jmp 0x68f3
xorl %eax, %eax
movl %edx, %ecx
subl %eax, %ecx
movslq %ecx, %rax
subq %rax, %rdx
leaq -0x38(%rbp), %rdi
movq $-0x1, %rcx
callq 0x21a0
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
movq (%r14), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x692d
callq 0x2180
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x694b
callq 0x2180
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: boost::intrusive_ptr<DummyInt> memorypool::boost_intrusive_pool<DummyInt>::allocate_through_init<unsigned int&>(unsigned int&)
item_ptr allocate_through_init(Args&&... args)
    {
        assert(m_pool); // pool must be initialized
        Item* recycled_item = m_pool->allocate_safe_get_recycled_item();
        if (!recycled_item)
            return nullptr;

        // Construct the object in the obtained storage
        // using the init() method of the item itself:
        recycled_item->init(std::forward<Args>(args)...);

        // AFTER the init() call, run the check() function
        item_ptr ret_ptr(recycled_item);
#if BOOST_INTRUSIVE_POOL_DEBUG_CHECKS
        ret_ptr->check();
#endif
        return ret_ptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x39d1a
movq %rdx, %r14
callq 0x561e2
testq %rax, %rax
je 0x39d0b
movl (%r14), %ecx
movl %ecx, 0x20(%rax)
movq %rax, (%rbx)
movq 0x8(%rax), %rcx
cmpq $0x3ff, %rcx            # imm = 0x3FF
jae 0x39d39
incq %rcx
movq %rcx, 0x8(%rax)
movq %rax, %rdi
callq 0x55c14
jmp 0x39d12
movq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x26eea(%rip), %rdi     # 0x60c0b
leaq 0x266bb(%rip), %rsi     # 0x603e3
leaq 0x26ee3(%rip), %rcx     # 0x60c12
movl $0x1a0, %edx            # imm = 0x1A0
callq 0xf2f0
leaq 0x2704c(%rip), %rdi     # 0x60d8c
leaq 0x2669c(%rip), %rsi     # 0x603e3
leaq 0x2708f(%rip), %rcx     # 0x60ddd
movl $0xdc, %edx
callq 0xf2f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x39dfe
movq %r14, %rdi
callq 0xf880
nop
// File: /workspace/github_cpp_makefile_star2_O1/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyInt>::clear()
void clear()
    {
        if (!m_pool)
            return; // nothing to do

        // VERY IMPORTANT: this function is very tricky: to do this correctly we cannot
        // simply call m_pool->clear(): that would remove all arenas that are the memory
        // support of memory pool items.
        // At this point we don't know yet if there are boost::intrusive_ptr<> out there
        // still alive... so we must play safe:
        size_t init_size = m_pool->m_enlarge_step;
        size_t enlarge_size = m_pool->m_enlarge_step;
        size_t max_size = m_pool->m_max_size;
        recycle_method_e method = m_pool->m_recycle_method;
        recycle_function recycle = m_pool->m_recycle_fn;
        m_pool->trigger_self_destruction();
        m_pool = nullptr; // release old pool
        m_pool = boost::intrusive_ptr<impl>(new impl(enlarge_size, max_size, method, recycle));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x39f2b
movq %rdi, %rbx
movq 0x30(%rsi), %r14
movq 0x38(%rsi), %r15
movl 0xc(%rsi), %r12d
addq $0x10, %rsi
leaq -0x68(%rbp), %rdi
callq 0x555f6
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x39f3a
callq 0x55f12
movq 0x8(%rbx), %rdi
movq $0x0, 0x8(%rbx)
testq %rdi, %rdi
je 0x39eb2
decl 0x8(%rdi)
jne 0x39eb2
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x88, %edi
callq 0xf4e0
movq %rax, %r13
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x555f6
leaq -0x48(%rbp), %r8
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x55678
incl 0x8(%r13)
movq 0x8(%rbx), %rdi
movq %r13, 0x8(%rbx)
testq %rdi, %rdi
je 0x39efd
decl 0x8(%rdi)
jne 0x39efd
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0x39f14
leaq -0x48(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x39f2b
leaq -0x68(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2229c(%rip), %rdi     # 0x5c1dd
leaq 0x268a5(%rip), %rsi     # 0x607ed
leaq 0x2694e(%rip), %rcx     # 0x6089d
movl $0xc7, %edx
callq 0xf2f0
jmp 0x39fac
jmp 0x39fac
movq %rax, %rbx
movq -0x38(%rbp), %rax
testq %rax, %rax
je 0x39f7e
leaq -0x48(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x39f7e
jmp 0x39fac
movq %rax, %rbx
movq %r13, %rdi
callq 0xf480
jmp 0x39f8d
jmp 0x39f8a
movq %rax, %rbx
movq -0x58(%rbp), %rax
testq %rax, %rax
je 0x39fa4
leaq -0x68(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xf880
movq %rax, %rdi
callq 0x3347e
// File: /workspace/github_cpp_makefile_star2_O1/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool_arena<DummyInt>::~boost_intrusive_pool_arena()
~boost_intrusive_pool_arena()
    {
        // m_storage is automatically cleaned up
        if (m_storage) {
            delete[] m_storage;
            m_storage = nullptr;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x55c04
movq %rdi, %rbx
leaq -0x8(%r15), %r14
movq -0x8(%r15), %rax
testq %rax, %rax
je 0x55bf4
shlq $0x3, %rax
leaq (%rax,%rax,4), %r12
leaq 0x2b358(%rip), %r13     # 0x80f28
addq $0x10, %r13
movq %r13, -0x28(%r15,%r12)
movq -0x10(%r15,%r12), %rdi
testq %rdi, %rdi
je 0x55bee
decl 0x8(%rdi)
jne 0x55bee
movq (%rdi), %rax
callq *0x8(%rax)
addq $-0x28, %r12
jne 0x55bd4
movq %r14, %rdi
callq 0xf650
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/string_helper.h
// Function: Boss::Private::StringTypeFromTypeId<1u>::Type Boss::StringHelper::GetString<1u>() const
typename Private::StringTypeFromTypeId<Type>::Type GetString() const
    {
      void const *Data = 0;
      UInt Size = 0;
      RefObjPtr<IBuffer> Buf;
      if (Str->GetString(Type, Buf.GetPPtr()) != Status::Ok ||
          Buf->GetSize(&Size)  != Status::Ok ||
          Buf->GetData(&Data)  != Status::Ok)
      {
        throw StringHelperException("Failed to get string.");
      }
      typedef typename Private::StringTypeFromTypeId<Type>::Type StrType;
      typedef typename StrType::value_type CharType;
      return std::move(StrType(reinterpret_cast<CharType const *>(Data),
                               Size / sizeof(CharType)));
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq (%rsi), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x38(%rax)
testl %eax, %eax
jne 0x186f0
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x4(%rsp), %rsi
callq *0x30(%rax)
testl %eax, %eax
jne 0x186f0
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
callq *0x28(%rax)
testl %eax, %eax
jne 0x186f0
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %edx
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x19dae
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x18(%rsp), %rcx
cmpq %r14, %rcx
je 0x186c5
movq %rcx, (%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x186cc
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x186e5
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1af10
movq %rax, %r14
leaq 0xa5a03(%rip), %rsi     # 0xbe107
movq %rax, %rdi
callq 0x2e450
leaq 0xdbbb5(%rip), %rax     # 0xf42c8
movq %rax, (%r14)
leaq 0xdbb83(%rip), %rsi     # 0xf42a0
leaq 0xc3ac(%rip), %rdx      # 0x24ad0
movq %r14, %rdi
callq 0x1bf60
jmp 0x18758
jmp 0x1873d
movq %rax, %rbx
movq %r14, %rdi
callq 0x1af70
jmp 0x18740
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18750
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xbb570
movq %rax, %rdi
callq 0x188b5
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/examples/string_enum/main.cpp
// Function: MyNs::SimpleObject::SimpleObject()
SimpleObject()
    {
      auto StringEnum = Boss::Base<Boss::Enum>::Create();
      
      StringEnum->AddItem(Boss::Base<Boss::String>::Create("String 1"));
      StringEnum->AddItem(Boss::Base<Boss::String>::Create("String 2"));
      StringEnum->AddItem(Boss::Base<Boss::String>::Create("String 3"));
      
      Strings = std::move(StringEnum);
      
      std::cout << "SimpleObject" << std::endl;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
leaq 0xdbbd1(%rip), %rax     # 0xf44b8
movq %rax, (%rdi)
leaq 0xdbc0f(%rip), %rax     # 0xf4500
movq %rax, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x18, %rbx
leaq 0x8(%rsp), %rdi
callq 0x18cd8
movq 0x8(%rsp), %r14
leaq 0xa5723(%rip), %rsi     # 0xbe03a
leaq 0x20(%rsp), %rdi
callq 0x18e44
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x18dac
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1893e
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x20(%rsp)
movq 0x8(%rsp), %r14
leaq 0xa56f0(%rip), %rsi     # 0xbe043
leaq 0x18(%rsp), %rdi
callq 0x18e44
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x18dac
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1897a
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %r14
leaq 0xa56bd(%rip), %rsi     # 0xbe04c
leaq 0x10(%rsp), %rdi
callq 0x18e44
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x18dac
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x189b6
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x10(%rsp)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x189cd
movq (%rdi), %rax
callq *0x18(%rax)
xorl %eax, %eax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rcx, %rdx
movq %rdx, (%rbx)
movq %rax, 0x8(%rsp)
leaq 0xe3a6f(%rip), %r14     # 0xfc460
leaq 0xa56b9(%rip), %rsi     # 0xbe0b1
movl $0xc, %edx
movq %r14, %rdi
callq 0x86890
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x679e0
movsbl %al, %esi
leaq 0xe3a3d(%rip), %rdi     # 0xfc460
callq 0x86390
movq %rax, %rdi
callq 0x85960
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18a40
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x18aed
jmp 0x18aed
jmp 0x18aed
jmp 0x18aed
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x18a6f
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x18ac4
jmp 0x18aed
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x18a8f
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x18(%rsp)
jmp 0x18ac4
jmp 0x18aed
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x18aaf
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x20(%rsp)
jmp 0x18ac4
jmp 0x18aed
movq %rax, %r14
jmp 0x18add
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18ad4
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x18892
movq %r14, %rdi
callq 0xbb570
movq %rax, %rdi
callq 0x188b5
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::GetLength(unsigned int*) const
virtual RetCode BOSS_CALL GetLength(UInt *length) const
    {
      if (!length)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        *length = Length;
        return Status::Ok;
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x19544
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x155d0
testl %eax, %eax
jne 0x1954f
movl 0x44(%r14), %eax
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x15630
xorl %eax, %eax
jmp 0x19549
movl $0x5, %eax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x1718b
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x1956f
callq 0x1b070
callq 0x1b0e0
movl $0x2, %eax
jmp 0x19549
callq 0xbb570
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::GetType(unsigned int*) const
virtual RetCode BOSS_CALL GetType(UInt *type) const
    {
      if (!type)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        *type = Type;
        return Status::Ok;
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x195a6
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x155d0
testl %eax, %eax
jne 0x195b1
movl 0x40(%r14), %eax
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x15630
xorl %eax, %eax
jmp 0x195ab
movl $0x5, %eax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x1718b
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x195d1
callq 0x1b070
callq 0x1b0e0
movl $0x2, %eax
jmp 0x195ab
callq 0xbb570
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::GetString(unsigned int, Boss::IBuffer**) const
virtual RetCode BOSS_CALL GetString(UInt type, IBuffer **str) const
    {
      if (!str || *str)
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        if (Type == UnknownStringType)
          return Status::False;
        RetCode Code = const_cast<String *>(this)->ConvertInternal(type);
        return Code == Status::Ok ? Data.QueryInterface(str) : Code;
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x5, %ebp
testq %rdx, %rdx
je 0x19648
movq %rdx, %r14
cmpq $0x0, (%rdx)
jne 0x19648
movl %esi, %r12d
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x155d0
testl %eax, %eax
jne 0x1965a
cmpl $0x0, 0x40(%r15)
je 0x1963b
movq (%r15), %rax
movq %r15, %rdi
movl %r12d, %esi
callq *0x68(%rax)
movl %eax, %ebp
testl %eax, %eax
jne 0x19640
movq 0x48(%r15), %rdi
testq %rdi, %rdi
je 0x19653
movq (%rdi), %rax
movl $0xaaa58dc, %esi        # imm = 0xAAA58DC
movq %r14, %rdx
callq *0x20(%rax)
movl %eax, %ebp
jmp 0x19640
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x15630
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x2, %ebp
jmp 0x19640
movl %eax, %edi
callq 0x1718b
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x15630
jmp 0x19677
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x19691
callq 0x1b070
callq 0x1b0e0
movl $0x2, %ebp
jmp 0x19648
callq 0xbb570
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::SetString(unsigned int, Boss::IBuffer*)
virtual RetCode BOSS_CALL SetString(UInt type, IBuffer *str)
    {
      if (!str || (type != AnsiString && type != Utf8String && type != UnicodeString))
        return Status::InvalidArgument;
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        void const *Buf = 0;
        UInt Len = 0;
        if (str->GetSize(&Len) != Status::Ok || str->GetData(&Buf) != Status::Ok)
          return Status::Fail;
        if (Type == UnicodeString && Len % sizeof(std::wstring::value_type))
          return Status::InvalidArgument;
        Data = std::move(Base<RawBuffer>::Create(Buf, Len));
        Type = type;
        Length = Len;
        if (Type == UnicodeString)
          Length /= sizeof(std::wstring::value_type);
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %r15d
testq %rdx, %rdx
sete %al
leal -0x4(%r15), %ecx
cmpl $-0x3, %ecx
setb %cl
orb %al, %cl
movl $0x5, %ebp
jne 0x19929
movq %rdx, %r12
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x155d0
testl %eax, %eax
jne 0x199ac
movq $0x0, 0x18(%rsp)
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
movq (%r12), %rax
movq %r12, %rdi
callq *0x30(%rax)
movl $0x2, %ebp
testl %eax, %eax
jne 0x19914
movq (%r12), %rax
leaq 0x18(%rsp), %rsi
movq %r12, %rdi
callq *0x28(%rax)
testl %eax, %eax
je 0x19938
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x15630
testb %r14b, %r14b
je 0x19929
movl $0x2, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x3, 0x40(%r14)
jne 0x1994d
testb $0x3, 0xc(%rsp)
je 0x1994d
movl $0x5, %ebp
jmp 0x19914
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x1a350
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x19970
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x48(%r14)
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x48(%r14)
movl %r15d, 0x40(%r14)
movl 0xc(%rsp), %eax
movl %eax, %ecx
shrl $0x2, %ecx
cmpl $0x3, %r15d
cmovnel %eax, %ecx
movl %ecx, 0x44(%r14)
movb $0x1, %r14b
jmp 0x19917
movl %eax, %edi
callq 0x1718b
movq %rdx, %r15
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x199c9
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x199ec
movq %rax, %rdi
callq 0x188b5
jmp 0x199e6
movq %rdx, %r15
movq %rax, %r14
jmp 0x199f4
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x15630
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x19a0c
callq 0x1b070
callq 0x1b0e0
jmp 0x19924
callq 0xbb570
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::Convert(unsigned int)
virtual RetCode BOSS_CALL Convert(UInt type)
    {
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        return ConvertInternal(type);
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x155d0
testl %eax, %eax
jne 0x19a50
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
callq *0x68(%rax)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x15630
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x1718b
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x15630
jmp 0x19a6d
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x19a87
callq 0x1b070
callq 0x1b0e0
movl $0x2, %ebp
jmp 0x19a43
callq 0xbb570
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::Clear()
virtual RetCode BOSS_CALL Clear()
    {
      try
      {
        std::lock_guard<std::recursive_mutex> Lock(Mtx);
        Data.Release();
        Type = UnknownStringType;
        Length = 0;
        return Status::Ok;
      }
      catch (std::exception const &)
      {
      }
      return Status::Fail;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x155d0
testl %eax, %eax
jne 0x19acb
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x19ab3
movq (%rdi), %rax
callq *0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r14)
movq %rbx, %rdi
callq 0x15630
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x1718b
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x15630
jmp 0x19ae8
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x19b02
callq 0x1b070
callq 0x1b0e0
movl $0x2, %eax
jmp 0x19ac5
callq 0xbb570
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/string.h
// Function: Boss::String::ConvertInternal(unsigned int)
virtual RetCode ConvertInternal(UInt type)
    {
      if (Type == UnknownStringType && type != UnknownStringType)
        return Status::InvalidArgument;
      if (Type == type)
        return Status::Ok;
      if (Type == AnsiString || type == AnsiString)
        return Status::NotImplemented;
      if (Type == Utf8String && type == UnicodeString)
      {
        void const *Buf = 0;
        if (Data->GetData(&Buf) != Status::Ok)
          return Status::Fail;
        SetStringInternal(FromUtf8(std::string(reinterpret_cast<std::string::value_type const *>(Buf), Length).c_str()));
        return Status::Ok;
      }
      if (Type == UnicodeString && type == Utf8String)
      {
        void const *Buf = 0;
        if (Data->GetData(&Buf) != Status::Ok)
          return Status::Fail;
        SetStringInternal(ToUtf8(std::wstring(reinterpret_cast<std::wstring::value_type const *>(Buf), Length).c_str()), true);
        return Status::Ok;
      }
      return Status::Fail;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x40(%rdi), %ecx
testl %ecx, %ecx
sete %dl
testl %esi, %esi
setne %dil
movl $0x5, %eax
testb %dl, %dil
jne 0x19c52
xorl %eax, %eax
cmpl %esi, %ecx
je 0x19c52
cmpl $0x1, %ecx
sete %al
cmpl $0x1, %esi
sete %dl
orb %al, %dl
movl $0x6, %eax
jne 0x19c52
movl %ecx, %eax
xorl $0x2, %eax
movl %esi, %edx
xorl $0x3, %edx
orl %eax, %edx
jne 0x19bbd
movq %rsp, %rsi
movq $0x0, (%rsi)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x19c52
movq (%rsp), %rsi
movl 0x44(%rbx), %edx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x19dae
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1a5c6
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a3f6
jmp 0x19c2e
xorl $0x3, %ecx
xorl $0x2, %esi
movl $0x2, %eax
orl %ecx, %esi
jne 0x19c52
movq %rsp, %rsi
movq $0x0, (%rsi)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x19c52
movq (%rsp), %rsi
movl 0x44(%rbx), %eax
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq (%rsi,%rax,4), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1a74c
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1a680
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x1a488
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19c41
callq 0x1ac20
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x19c50
callq 0x1ac20
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x19c60
jmp 0x19c78
jmp 0x19c8c
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19c7b
callq 0x1ac20
jmp 0x19c7b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x19c8f
callq 0x1ac20
jmp 0x19c8f
movq %rax, %rbx
movq %rbx, %rdi
callq 0xbb570
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/../other/utf8_converter.h
// Function: Boss::Private::Utf8Converter::FromUtf8[abi:cxx11](char const*)
static std::wstring FromUtf8(char const *src)
      {
        std::wstring Ret;
        int len = strlen(src);
        for(int i = 0 ; i < len ; )
        {
          unsigned short ch = 0;
          if((src[i] & MASK3BYTES) == MASK3BYTES)
          {
            ch = ((src[i] & 0x0F) << 12) | ((src[i+1] & MASKBITS) << 6) | (src[i+2] & MASKBITS);
            i += 3;
          }
          else
          if((src[i] & MASK2BYTES) == MASK2BYTES)
          {
            ch = ((src[i] & 0x1F) << 6) | (src[i+1] & MASKBITS);
            i += 2;
          }
          else
          if(src[i] < static_cast<char>(MASKBYTE))
          {
            ch = src[i];
            i += 1;
          }
          Ret += ch;
        }
        return Ret;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x152c0
movq %rax, %r15
xorl %ebp, %ebp
cmpl %r15d, %ebp
jge 0x1a65b
movslq %ebp, %rax
leaq (%r14,%rax), %rcx
movsbl (%r14,%rax), %eax
movl %eax, %edx
notl %edx
testb $-0x20, %dl
jne 0x1a62f
shll $0xc, %eax
movzbl 0x1(%rcx), %edx
andl $0x3f, %edx
shll $0x6, %edx
movzwl %ax, %eax
orl %edx, %eax
movl $0x3, %edx
movl $0x2, %esi
jmp 0x1a646
xorl %esi, %esi
testb $-0x40, %dl
jne 0x1a651
andl $0x1f, %eax
shll $0x6, %eax
movl $0x2, %edx
movl $0x1, %esi
movzbl (%rcx,%rsi), %esi
andl $0x3f, %esi
orl %eax, %esi
addl %edx, %ebp
movq %rbx, %rdi
callq 0xa5480
jmp 0x1a5f7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1a677
callq 0x1ac20
movq %r14, %rdi
callq 0xbb570
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/../other/utf8_converter.h
// Function: Boss::Private::Utf8Converter::ToUtf8[abi:cxx11](wchar_t const*)
static std::string ToUtf8(wchar_t const *src)
      {
        std::string Ret;
        int len = wcslen(src);
        for(int i = 0 ; i < len ; ++i)
        {
          if(src[i] < 0x80)
            Ret += static_cast<char>(src[i]);
          else
          if(src[i] < 0x800)
          {
            Ret += static_cast<char>(MASK2BYTES | src[i] >> 6);
            Ret += static_cast<char>(MASKBYTE | (src[i] & MASKBITS));
          }
          else
          if(src[i] < 0x10000)
          {
            Ret += static_cast<char>(MASK3BYTES | src[i] >> 12);
            Ret+= static_cast<char>(MASKBYTE | ((src[i] >> 6) & MASKBITS));
            Ret += static_cast<char>(MASKBYTE | (src[i] & MASKBITS));
          }
        }
        return Ret;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x150f0
movq %rax, %r15
testl %r15d, %r15d
jle 0x1a726
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movl (%r14,%r13,4), %eax
cmpl $0x7f, %eax
jle 0x1a713
cmpl $0x7ff, %eax            # imm = 0x7FF
jg 0x1a6de
shrl $0x6, %eax
orb $-0x40, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8dc00
jmp 0x1a70b
cmpl $0xffff, %eax           # imm = 0xFFFF
jg 0x1a71e
shrl $0xc, %eax
orb $-0x20, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8dc00
movl (%r14,%r13,4), %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8dc00
movb (%r14,%r13,4), %al
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8dc00
incq %r13
cmpq %r13, %r15
jne 0x1a6bc
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1a743
callq 0x1ac20
movq %r14, %rdi
callq 0xbb570
nop
// File: /workspace/github_cpp_makefile_star2_O1/Laakeri[P]Triangulator/src/./graph.hpp
// Function: std::vector<long, std::allocator<long>> Graph::mapTableInto<long>(std::vector<long, std::allocator<long>> const&) const
std::vector<T> mapTableInto(const std::vector<T>& table) const {
		std::vector<T> res;
		for (int x : vMap) {
			assert(x >= 0 && x < (int)table.size());
			res.push_back(table[x]);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x6953
movq %rdx, %r14
movslq (%r15), %rax
testq %rax, %rax
js 0x6962
movq (%r14), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
cmpl %edx, %eax
jge 0x6962
leaq (%rcx,%rax,8), %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6942
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x694a
movq %rbx, %rdi
callq 0x8ad8
addq $0x4, %r15
cmpq %r12, %r15
jne 0x690a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x23d17(%rip), %rdi     # 0x2a680
leaq 0x23d30(%rip), %rsi     # 0x2a6a0
leaq 0x23d35(%rip), %rcx     # 0x2a6ac
movl $0x32, %edx
callq 0x2140
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6998
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2210
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/Laakeri[P]Triangulator/src/bayes.cpp
// Function: Bayes::BayesIO::printFill(std::ostream&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>)
void printFill(ostream& out, vector<pair<int, int> > es) {
		vector<string> mp(variables.size());
		for (auto v : variables) {
			assert(v.S>=0&&v.S<(int)variables.size());
			mp[v.S] = v.F;
		}
		for (auto e : es) {
			out<<mp[e.F]<<" "<<mp[e.S]<<endl;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, (%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movq 0x58(%rdi), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x864c
movq 0x48(%r15), %r12
leaq 0x38(%r15), %r14
cmpq %r14, %r12
je 0x7cfc
leaq 0x30(%rsp), %rbp
leaq 0x20(%rsp), %r13
movq %rbp, 0x20(%rsp)
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x83f0
movslq 0x40(%r12), %rdi
movl %edi, 0x40(%rsp)
testq %rdi, %rdi
js 0x7db7
cmpl 0x58(%r15), %edi
jge 0x7db7
shlq $0x5, %rdi
addq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x2100
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7cec
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2210
movq %r12, %rdi
callq 0x2170
movq %rax, %r12
cmpq %r14, %rax
jne 0x7c8e
movq (%rsp), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x7d9e
leaq 0x24006(%rip), %r14     # 0x2bd1d
movslq (%r12), %rax
movslq 0x4(%r12), %rbp
movq 0x8(%rsp), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq %rbx, %rdi
callq 0x2250
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2250
movq 0x8(%rsp), %rax
shlq $0x5, %rbp
movq (%rax,%rbp), %rsi
movq 0x8(%rax,%rbp), %rdx
movq %r15, %rdi
callq 0x2250
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2160
addq $0x8, %r12
cmpq %r13, %r12
jne 0x7d17
leaq 0x8(%rsp), %rdi
callq 0x4406
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2285e(%rip), %rdi     # 0x2a61c
leaq 0x224d3(%rip), %rsi     # 0x2a298
leaq 0x22872(%rip), %rcx     # 0x2a63e
movl $0x128, %edx            # imm = 0x128
callq 0x2140
jmp 0x7df4
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7df7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2210
jmp 0x7df7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4406
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::Graph(int, int)
Graph::Graph(int n_, int m_) {
	n = n_;
	m = 0;
	g.resize(n);
	DENSE = denseG(n, m_);
	if (DENSE) initMatrix();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x38(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq $0x0, 0x48(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movl %esi, 0x50(%rdi)
movl $0x0, 0x54(%rdi)
movslq %esi, %rsi
movq %r15, %rdi
callq 0xa67e
movslq 0x50(%rbx), %rax
movq %rax, %rcx
imulq %rax, %rcx
imulq %rax, %rcx
movslq %ebp, %rax
imulq %rax, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rax
cmpq %rax, %rcx
setle 0x30(%rbx)
jg 0x91df
movq %rbx, %rdi
callq 0x9100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x41fe
movq %r14, %rdi
callq 0x43b8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x920f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2210
movq %r12, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::Graph(int, bool)
Graph::Graph(int n_, bool dense) {
	n = n_;
	m = 0;
	g.resize(n);
	DENSE = dense;
	if (DENSE) initMatrix();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x38(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movq $0x0, 0x48(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movl %esi, 0x50(%rdi)
movl $0x0, 0x54(%rdi)
movslq %esi, %rsi
movq %r15, %rdi
callq 0xa67e
movb %bpl, 0x30(%rbx)
testb %bpl, %bpl
je 0x926d
movq %rbx, %rdi
callq 0x9100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x41fe
movq %r14, %rdi
callq 0x43b8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x929d
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2210
movq %r12, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::addEdge(int, int)
void Graph::addEdge(int a, int b) {
	if (DENSE) {
		mat[a][b] = 1;
		mat[b][a] = 1;
	}
	g[a].push_back(b);
	g[b].push_back(a);
	m++;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
cmpb $0x1, 0x30(%rdi)
jne 0x9558
movslq %esi, %rax
movq 0x18(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movslq %edx, %rdx
movq (%rcx,%rax,8), %rax
movb $0x1, %cl
movb %cl, (%rax,%rdx)
movslq 0x8(%rsp), %rax
movq 0x18(%rbx), %rdx
leaq (%rax,%rax,2), %rax
movslq 0xc(%rsp), %rsi
movq (%rdx,%rax,8), %rax
movb %cl, (%rax,%rsi)
movslq 0xc(%rsp), %rax
movq 0x38(%rbx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x9583
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x958d
leaq 0x8(%rsp), %rdx
callq 0x8fde
movslq 0x8(%rsp), %rax
movq 0x38(%rbx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x95b8
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x95c2
leaq 0xc(%rsp), %rdx
callq 0x8fde
incl 0x54(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Laakeri[P]Triangulator/src/graph.cpp
// Function: Graph::popEdge(int, int)
void Graph::popEdge(int a, int b) {
	if (DENSE) {
		mat[a][b] = 0;
		mat[b][a] = 0;
	}
	g[a].pop_back();
	g[b].pop_back();
	m--;
}

// Assembly:
cmpb $0x1, 0x30(%rdi)
movslq %esi, %rcx
movslq %edx, %rax
jne 0x9864
movq 0x18(%rdi), %rdx
leaq (%rcx,%rcx,2), %rsi
movq (%rdx,%rsi,8), %rdx
xorl %esi, %esi
movb %sil, (%rdx,%rax)
movq 0x18(%rdi), %rdx
leaq (%rax,%rax,2), %r8
movq (%rdx,%r8,8), %rdx
movb %sil, (%rdx,%rcx)
movq 0x38(%rdi), %rdx
leaq (%rcx,%rcx,2), %rcx
addq $-0x4, 0x8(%rdx,%rcx,8)
leaq (%rax,%rax,2), %rax
addq $-0x4, 0x8(%rdx,%rax,8)
decl 0x54(%rdi)
retq