LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x3d924
movq -0x58(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
je 0x3d92d
movb $0x0, -0x1(%rbp)
jmp 0x3da2c
movl $0x0, -0x1c(%rbp)
movq -0x58(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x3da28
movl $0x0, -0x20(%rbp)
movq -0x58(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0xc(%rcx), %eax
jae 0x3da18
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
leaq -0x28(%rbp), %rdi
callq 0x9dc0
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x3c650
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x5c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x3c650
movb %al, %cl
movl -0x5c(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x3d9b1
movb $0x0, -0x1(%rbp)
jmp 0x3da2c
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x3c650
testb $0x1, %al
jne 0x3da08
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
callq 0x3d4c0
movl %eax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
callq 0x3d4c0
movl %eax, %ecx
movl -0x60(%rbp), %eax
cmpl %ecx, %eax
je 0x3da06
movb $0x0, -0x1(%rbp)
jmp 0x3da2c
jmp 0x3da08
jmp 0x3da0a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3d94b
jmp 0x3da1a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3d934
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb6a0
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x3de2c
movl -0x14(%rbp), %eax
addl $0x1, %eax
cmpl $0xa, %eax
jge 0x3dd34
movq -0x8(%rbp), %rdi
leaq 0x58e0(%rip), %rsi      # 0x4360f
callq 0x31e0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x3350
movq %rax, %rdi
leaq 0x58c2(%rip), %rsi      # 0x4360f
callq 0x31e0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb6c0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jae 0x3de0e
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq -0x20(%rbp), %rdi
callq 0x9dc0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x3c650
testb $0x1, %al
jne 0x3dd9f
jmp 0x3ddb1
movq -0x8(%rbp), %rdi
leaq 0x585b(%rip), %rsi      # 0x43605
callq 0x31e0
jmp 0x3ddfe
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x34(%rbp)
movq -0x34(%rbp), %rsi
callq 0x3d4c0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x3dde4
leaq 0x5829(%rip), %rax      # 0x43607
movq %rax, -0x50(%rbp)
jmp 0x3ddf1
leaq 0x581e(%rip), %rax      # 0x43609
movq %rax, -0x50(%rbp)
jmp 0x3ddf1
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x31e0
jmp 0x3de00
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3dd59
movq -0x8(%rbp), %rdi
leaq 0x57f2(%rip), %rsi      # 0x4360b
callq 0x31e0
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3dd0f
movq -0x8(%rbp), %rdi
leaq 0x57d6(%rip), %rsi      # 0x4360d
callq 0x31e0
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb6c0
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jae 0x3de8b
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x38(%rbp), %eax
movl %eax, %esi
leaq 0x15421(%rip), %rdi     # 0x53290
callq 0x32a0
movq -0x60(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3290
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x3de43
movq -0x8(%rbp), %rdi
leaq 0x5775(%rip), %rsi      # 0x4360b
callq 0x31e0
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
addq $0x5c8, %rdi            # imm = 0x5C8
callq 0x3e6f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x3df18
movq -0x28(%rbp), %rdi
addq $0x5b18, %rdi           # imm = 0x5B18
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x3e880
testb $0x1, %al
jne 0x3df09
jmp 0x3df0b
jmp 0x3df18
jmp 0x3df0d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3decb
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x10(%rbp), %rdi
callq 0x3df80
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
addq $0x5c8, %rdi            # imm = 0x5C8
callq 0x3e6f0
movq -0x20(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x11(%rbp)
jae 0x3e015
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x5b18, %rdi           # imm = 0x5B18
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x3e880
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x3e01e
jmp 0x3e02d
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x3dfcd
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
leaq 0x1811(%rip), %rsi      # 0x5e80
callq 0x21a0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
leaq 0x1801(%rip), %rsi      # 0x5e84
callq 0x21a0
movq -0x10(%rbp), %rax
movl $0x40, 0x58(%rax)
movl $0x64, 0xd4(%rax)
movl $0x2, 0x60(%rax)
movl $0x7, 0x68(%rax)
movl $0x7, 0x70(%rax)
movl $0x1, 0x78(%rax)
movl $0x1f40, 0x80(%rax)     # imm = 0x1F40
movl $0x3, 0xc0(%rax)
movl $0x1388, 0xc8(%rax)     # imm = 0x1388
movl $0x13ed, 0xd0(%rax)     # imm = 0x13ED
movl $0x1, 0x88(%rax)
movl $0x1, 0x90(%rax)
movl $0xa, 0xb0(%rax)
movl $0x7, 0xb8(%rax)
movl $0x1, 0x98(%rax)
movl $0x1f5, 0xa0(%rax)      # imm = 0x1F5
movl $0x0, 0xa8(%rax)
movl $0x1f3, 0xd8(%rax)      # imm = 0x1F3
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32b0
shrq %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %ecx, %eax
sarl %eax
cltq
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
movsbl -0x15(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3340
movq -0x98(%rbp), %rsi
movl -0x8c(%rbp), %edx
movq -0x88(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x3150
jmp 0x92a9
leaq -0x49(%rbp), %rdi
callq 0x3210
movq -0x10(%rbp), %rdx
leaq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9810
jmp 0x92c5
movq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x97c0
jmp 0x92db
leaq -0x80(%rbp), %rdi
callq 0x3398
leaq -0x48(%rbp), %rdi
callq 0x3398
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x3210
jmp 0x9340
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x9337
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3398
leaq -0x48(%rbp), %rdi
callq 0x3398
movq -0x58(%rbp), %rdi
callq 0x3330
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3290
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3160
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0xa31d
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3220
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xa30d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa30f
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xa2cf
movq -0x10(%rbp), %rdi
callq 0x3160
movl -0x20(%rbp), %ecx
subl %ecx, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3160
movq -0x80(%rbp), %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
leaq -0x50(%rbp), %rdi
movq $-0x1, %rcx
callq 0x31f0
jmp 0xa35e
movq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3250
leaq -0x50(%rbp), %rdi
callq 0x3398
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa3a0
jmp 0xa397
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x3398
jmp 0xa3ad
movq -0x70(%rbp), %rdi
callq 0x3398
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3330
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
callq 0xbb110
testb $0x1, %al
jne 0x5d836
jmp 0x5d838
jmp 0x5d857
leaq 0x6c63d(%rip), %rdi     # 0xc9e7c
leaq 0x6be0e(%rip), %rsi     # 0xc9654
movl $0x1a0, %edx            # imm = 0x1A0
leaq 0x6c631(%rip), %rcx     # 0xc9e83
callq 0x103d0
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0xb9f80
movq %rax, %rdi
callq 0xbb4d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5d88b
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xbb770
jmp 0x5d8f1
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0xbb7c0
movq -0x50(%rbp), %rdi
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0xbb770
movq -0x50(%rbp), %rdi
callq 0xbb7e0
movq %rax, %rdi
callq 0xbaa20
jmp 0x5d8c3
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x5d8ef
jmp 0x5d8e6
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x5dc30
jmp 0x5d8fb
movq -0x50(%rbp), %rdi
callq 0x5dc30
jmp 0x5d8f1
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10aa0
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x8, %rdi
callq 0xbb280
testb $0x1, %al
jne 0x5e119
jmp 0x5e11e
jmp 0x5e27a
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x98(%rbp)
callq 0xb9f80
movq -0x98(%rbp), %rdi
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
callq 0xb9f80
movq -0x98(%rbp), %rdi
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0xb9f80
movq -0x98(%rbp), %rdi
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
callq 0xb9f80
movq -0x98(%rbp), %rdi
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
callq 0xb9f80
movq %rax, %rsi
addq $0x10, %rsi
leaq -0x48(%rbp), %rdi
callq 0xb9c70
movq -0x98(%rbp), %rdi
callq 0xb9f80
movq %rax, %rdi
callq 0xbb130
jmp 0x5e1a9
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbd3a0
jmp 0x5e1bf
movl $0x88, %edi
callq 0x10630
movq %rax, -0xa0(%rbp)
jmp 0x5e1d2
movb $0x1, -0x81(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0xa4(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb9c70
jmp 0x5e207
movl -0xa4(%rbp), %ecx
movq -0xb0(%rbp), %rdx
movq -0xb8(%rbp), %rsi
movq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %r8
callq 0xb9dd0
jmp 0x5e22d
movq -0xa0(%rbp), %rsi
movb $0x0, -0x81(%rbp)
leaq -0x60(%rbp), %rdi
movl $0x1, %edx
callq 0xb9ec0
jmp 0x5e24b
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
callq 0xb9f30
leaq -0x60(%rbp), %rdi
callq 0xb9d20
leaq -0x80(%rbp), %rdi
callq 0x5d6c0
leaq -0x48(%rbp), %rdi
callq 0x5d6c0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5e2cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5e2b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5d6c0
testb $0x1, -0x81(%rbp)
jne 0x5e2bf
jmp 0x5e2cb
movq -0xa0(%rbp), %rdi
callq 0x105b0
jmp 0x5e2cd
leaq -0x48(%rbp), %rdi
callq 0x5d6c0
movq -0x50(%rbp), %rdi
callq 0x10aa0
nop
// File: f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<DummyInt>::impl::enlarge_steps_done() const
size_t enlarge_steps_done() const
        {
            size_t num_arenas_allocated = 0;

            const boost_intrusive_pool_arena<Item>* pcurr = m_first_arena;
            while (pcurr) {
                pcurr = pcurr->get_next_arena();
                num_arenas_allocated++;
            }

            return num_arenas_allocated;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, -0x10(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbd372
movq -0x18(%rbp), %rdi
callq 0xbd380
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xbd350
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x48(%rsp)
movq $0x0, 0xa0(%rsp)
movl $0x0, 0x9c(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0x90(%rsp), %rdi
callq 0x1f490
movq 0x48(%rsp), %rdi
callq 0x20c10
movq %rax, 0x50(%rsp)
jmp 0x18eba
leaq 0x90(%rsp), %rdi
callq 0x1f4d0
movq 0x50(%rsp), %rdi
movq %rax, %rdx
movq (%rdi), %rax
movq 0x38(%rax), %rax
movl $0x1, %esi
callq *%rax
movl %eax, 0x34(%rsp)
jmp 0x18ee3
movl 0x34(%rsp), %eax
cmpl $0x0, %eax
jne 0x18f4c
leaq 0x90(%rsp), %rdi
callq 0x1f4e0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
leaq 0x9c(%rsp), %rsi
callq *%rax
movl %eax, 0x30(%rsp)
jmp 0x18f13
movl 0x30(%rsp), %eax
cmpl $0x0, %eax
jne 0x18f4c
leaq 0x90(%rsp), %rdi
callq 0x1f4e0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq 0xa0(%rsp), %rsi
callq *%rax
movl %eax, 0x2c(%rsp)
jmp 0x18f43
movl 0x2c(%rsp), %eax
cmpl $0x0, %eax
je 0x18fc8
movl $0x10, %edi
callq 0x211d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0xac28d(%rip), %rsi     # 0xc51f5
callq 0x20c20
jmp 0x18f6f
movq 0x20(%rsp), %rdi
leaq 0xe4285(%rip), %rsi     # 0xfd200
leaq 0x39e(%rip), %rdx       # 0x19320
callq 0x22220
jmp 0x19080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x19066
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
callq 0x21230
jmp 0x19066
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x9c(%rsp), %eax
movq %rax, 0x10(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x23190
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x60(%rsp), %rdi
callq 0x96270
jmp 0x1900b
movq 0x38(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x937e0
leaq 0x60(%rsp), %rdi
callq 0x93890
leaq 0x5f(%rsp), %rdi
callq 0x231b0
leaq 0x90(%rsp), %rdi
callq 0x1f080
movq 0x40(%rsp), %rax
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0x231b0
leaq 0x90(%rsp), %rdi
callq 0x1f080
movq 0x88(%rsp), %rdi
callq 0xc24c0
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x19cc0
movq 0x20(%rsp), %rdi
leaq 0xe3e54(%rip), %rax     # 0xfd418
movq %rax, (%rdi)
leaq 0xe3e92(%rip), %rax     # 0xfd460
movq %rax, 0x8(%rdi)
addq $0x18, %rdi
movq %rdi, 0x28(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x18b30
jmp 0x195e6
leaq 0x48(%rsp), %rdi
callq 0x19d20
jmp 0x195f2
leaq 0x48(%rsp), %rdi
callq 0x19e10
movq %rax, 0x18(%rsp)
jmp 0x19603
leaq 0xabb48(%rip), %rsi     # 0xc5152
leaq 0x40(%rsp), %rdi
callq 0x19ec0
jmp 0x19616
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x19e20
jmp 0x19627
leaq 0x40(%rsp), %rdi
callq 0x19fc0
leaq 0x48(%rsp), %rdi
callq 0x19e10
movq %rax, 0x10(%rsp)
jmp 0x19642
leaq 0xabb12(%rip), %rsi     # 0xc515b
leaq 0x38(%rsp), %rdi
callq 0x19ec0
jmp 0x19655
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x19e20
jmp 0x19666
leaq 0x38(%rsp), %rdi
callq 0x19fc0
leaq 0x48(%rsp), %rdi
callq 0x19e10
movq %rax, 0x8(%rsp)
jmp 0x19681
leaq 0xabadc(%rip), %rsi     # 0xc5164
leaq 0x30(%rsp), %rdi
callq 0x19ec0
jmp 0x19694
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x19e20
jmp 0x196a5
leaq 0x30(%rsp), %rdi
callq 0x19fc0
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
leaq 0x48(%rsp), %rsi
callq 0x19fe0
jmp 0x196c4
leaq 0xebd95(%rip), %rdi     # 0x105460
leaq 0xabacd(%rip), %rsi     # 0xc519f
callq 0x8d0e0
movq %rax, (%rsp)
jmp 0x196dd
movq (%rsp), %rdi
leaq 0x732d8(%rip), %rsi     # 0x8c9c0
callq 0x8bbd0
jmp 0x196ef
leaq 0x48(%rsp), %rdi
callq 0x1a050
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x19791
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x19787
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x1977d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x19fc0
jmp 0x1977d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x19fc0
jmp 0x1977d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x19fc0
leaq 0x48(%rsp), %rdi
callq 0x1a050
movq 0x28(%rsp), %rdi
callq 0x19290
movq 0x20(%rsp), %rdi
callq 0x1a1a0
movq 0x58(%rsp), %rdi
callq 0xc24c0
nopw %cs:(%rax,%rax)
nop
// File: tdv[P]boss/boss/include/core/ref_obj_ptr.h
// Function: Boss::RefObjPtr<Boss::IEnum>& Boss::RefObjPtr<Boss::IEnum>::operator=<Boss::Enum>(Boss::RefObjPtr<Boss::Enum>&&)
RefObjPtr& operator = (RefObjPtr<Other> &&ptr)
    {
      Release();
      Ptr = ptr.Ptr;
      ptr.Ptr = 0;
      return *this;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x193d0
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x10(%rsp)
je 0x1a024
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq $0x0, (%rcx)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x1c1ea
movl $0x5, 0x44(%rsp)
jmp 0x1c259
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
leaq 0x28(%rsp), %rdi
callq 0x1b5b0
jmp 0x1c1ff
movq 0x8(%rsp), %rax
movl 0x44(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x44(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1b6d0
jmp 0x1c259
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1c262
movq 0x20(%rsp), %rdi
callq 0x21330
movq %rax, 0x10(%rsp)
callq 0x213a0
movl $0x2, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xc24c0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x1c29a
movl $0x5, 0x44(%rsp)
jmp 0x1c309
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
leaq 0x28(%rsp), %rdi
callq 0x1b5b0
jmp 0x1c2af
movq 0x8(%rsp), %rax
movl 0x40(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x44(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1b6d0
jmp 0x1c309
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1c312
movq 0x20(%rsp), %rdi
callq 0x21330
movq %rax, 0x10(%rsp)
callq 0x213a0
movl $0x2, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xc24c0
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x1c34f
movq 0x48(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1c35c
movl $0x5, 0x64(%rsp)
jmp 0x1c452
movq 0x18(%rsp), %rsi
addq $0x18, %rsi
leaq 0x40(%rsp), %rdi
callq 0x1b5b0
jmp 0x1c371
movq 0x18(%rsp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x1c3a1
movl $0x1, 0x64(%rsp)
movl $0x1, 0x30(%rsp)
jmp 0x1c448
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x1c41d
movq 0x18(%rsp), %rdi
movl 0x54(%rsp), %esi
movq (%rdi), %rax
movq 0x68(%rax), %rax
callq *%rax
movl %eax, 0x14(%rsp)
jmp 0x1c3b9
movl 0x14(%rsp), %eax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x1c3eb
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
movq 0x48(%rsp), %rsi
callq 0x1f440
movl %eax, 0x10(%rsp)
jmp 0x1c3e1
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x1c3f3
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x64(%rsp)
movl $0x1, 0x30(%rsp)
jmp 0x1c448
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1b6d0
movl 0x34(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1c45b
movq 0x38(%rsp), %rdi
callq 0x21330
movq %rax, 0x20(%rsp)
callq 0x213a0
movl $0x2, 0x64(%rsp)
jmp 0x1c452
leaq 0x40(%rsp), %rdi
callq 0x1b6d0
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xc24c0
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x1c929
cmpl $0x1, 0x54(%rsp)
je 0x1c936
cmpl $0x2, 0x54(%rsp)
je 0x1c936
cmpl $0x3, 0x54(%rsp)
je 0x1c936
movl $0x5, 0x64(%rsp)
jmp 0x1cad3
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
leaq 0x40(%rsp), %rdi
callq 0x1b5b0
jmp 0x1c94b
movq $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x48(%rsp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
leaq 0x24(%rsp), %rsi
callq *%rax
movl %eax, 0x4(%rsp)
jmp 0x1c975
movl 0x4(%rsp), %eax
cmpl $0x0, %eax
jne 0x1c99e
movq 0x48(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq 0x28(%rsp), %rsi
callq *%rax
movl %eax, (%rsp)
jmp 0x1c996
movl (%rsp), %eax
cmpl $0x0, %eax
je 0x1c9d9
movl $0x2, 0x64(%rsp)
movl $0x1, 0x20(%rsp)
jmp 0x1ca88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x1caaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x1caa0
movq 0x8(%rsp), %rax
cmpl $0x3, 0x40(%rax)
jne 0x1ca07
movl 0x24(%rsp), %eax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x1ca07
movl $0x5, 0x64(%rsp)
movl $0x1, 0x20(%rsp)
jmp 0x1ca88
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x24(%rsp), %rdx
callq 0x1f4f0
jmp 0x1ca1d
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
leaq 0x18(%rsp), %rsi
callq 0x1f5f0
jmp 0x1ca32
leaq 0x18(%rsp), %rdi
callq 0x1d430
movq 0x8(%rsp), %rax
movl 0x54(%rsp), %ecx
movl %ecx, 0x40(%rax)
movl 0x24(%rsp), %ecx
movl %ecx, 0x44(%rax)
cmpl $0x3, 0x40(%rax)
jne 0x1ca80
movq 0x8(%rsp), %rax
movl 0x44(%rax), %ecx
shrq $0x2, %rcx
movl %ecx, 0x44(%rax)
jmp 0x1ca80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1d430
jmp 0x1caa0
movl $0x0, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1b6d0
movl 0x20(%rsp), %eax
testl %eax, %eax
je 0x1ca9e
jmp 0x1ca9c
jmp 0x1cad3
jmp 0x1cacb
leaq 0x40(%rsp), %rdi
callq 0x1b6d0
movl 0x34(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1cadc
movq 0x38(%rsp), %rdi
callq 0x21330
movq %rax, 0x10(%rsp)
callq 0x213a0
movl $0x2, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xc24c0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x18, %rsi
leaq 0x28(%rsp), %rdi
callq 0x1b5b0
jmp 0x1cb17
movq 0x8(%rsp), %rdi
movl 0x34(%rsp), %esi
movq (%rdi), %rax
movq 0x68(%rax), %rax
callq *%rax
movl %eax, 0x4(%rsp)
jmp 0x1cb2f
movl 0x4(%rsp), %eax
movl %eax, 0x44(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1b6d0
jmp 0x1cb94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1cb6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1b6d0
movl 0x1c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1cb9d
movq 0x20(%rsp), %rdi
callq 0x21330
movq %rax, 0x10(%rsp)
callq 0x213a0
movl $0x2, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xc24c0
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rsi
movq %rsi, (%rsp)
addq $0x18, %rsi
leaq 0x20(%rsp), %rdi
callq 0x1b5b0
jmp 0x1cbd2
movq (%rsp), %rdi
addq $0x48, %rdi
callq 0x1f0a0
jmp 0x1cbe1
movq (%rsp), %rax
movl $0x0, 0x40(%rax)
movl $0x0, 0x44(%rax)
movl $0x0, 0x34(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1b6d0
jmp 0x1cc58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x1cc2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1b6d0
movl 0x14(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1cc61
movq 0x18(%rsp), %rdi
callq 0x21330
movq %rax, 0x8(%rsp)
callq 0x213a0
movl $0x2, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xc24c0
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
callq 0xab1d0
movq 0x38(%rsp), %rdi
callq 0x152c0
movl %eax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x1fc33
movw $0x0, 0x2a(%rsp)
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
andl $0xe0, %eax
cmpl $0xe0, %eax
jne 0x1fb76
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
andl $0xf, %eax
shll $0xc, %eax
movq 0x38(%rsp), %rcx
movl 0x2c(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
andl $0x3f, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movq 0x38(%rsp), %rcx
movl 0x2c(%rsp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movw %ax, 0x2a(%rsp)
movl 0x2c(%rsp), %eax
addl $0x3, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1fc03
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
andl $0xc0, %eax
cmpl $0xc0, %eax
jne 0x1fbce
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1f, %eax
shll $0x6, %eax
movq 0x38(%rsp), %rcx
movl 0x2c(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movw %ax, 0x2a(%rsp)
movl 0x2c(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1fc01
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $-0x80, %eax
jge 0x1fbff
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movw %ax, 0x2a(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1fc01
jmp 0x1fc03
movq 0x8(%rsp), %rdi
movzwl 0x2a(%rsp), %esi
callq 0xab880
jmp 0x1fc14
jmp 0x1faeb
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xab310
jmp 0x1fc53
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x1fc49
movq 0x8(%rsp), %rdi
callq 0xab310
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xc24c0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x93780
movq 0x38(%rsp), %rdi
callq 0x150f0
movl %eax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x1fdf2
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
cmpl $0x80, (%rax,%rcx,4)
jge 0x1fcf8
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movsbl (%rax,%rcx,4), %esi
callq 0x93ea0
jmp 0x1fcd6
jmp 0x1fde0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x93890
jmp 0x1fe12
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
cmpl $0x800, (%rax,%rcx,4)   # imm = 0x800
jge 0x1fd58
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x6, %eax
orl $0xc0, %eax
movsbl %al, %esi
callq 0x93ea0
jmp 0x1fd2f
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x3f, %eax
orl $0x80, %eax
movsbl %al, %esi
callq 0x93ea0
jmp 0x1fd53
jmp 0x1fdde
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
cmpl $0x10000, (%rax,%rcx,4) # imm = 0x10000
jge 0x1fddc
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0xc, %eax
orl $0xe0, %eax
movsbl %al, %esi
callq 0x93ea0
jmp 0x1fd8f
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movsbl %al, %esi
callq 0x93ea0
jmp 0x1fdb6
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x3f, %eax
orl $0x80, %eax
movsbl %al, %esi
callq 0x93ea0
jmp 0x1fdda
jmp 0x1fddc
jmp 0x1fdde
jmp 0x1fde0
jmp 0x1fde2
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1fc9b
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x1fe08
movq 0x8(%rsp), %rdi
callq 0x93890
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xc24c0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xf420
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6680
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0xbe68
jmp 0xbf0a
leaq -0x30(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x3c(%rbp)
movb %al, -0x69(%rbp)
jl 0xbe9e
movl -0x3c(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbb80
movq %rax, %rcx
movl -0x70(%rbp), %eax
cmpl %ecx, %eax
setl %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xbea7
jmp 0xbea9
jmp 0xbec8
leaq 0x4d7b4(%rip), %rdi     # 0x59664
leaq 0x4d7cd(%rip), %rsi     # 0x59684
movl $0x32, %edx
leaq 0x4d7cd(%rip), %rcx     # 0x59690
callq 0x31a0
movq -0x18(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x12de0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x12d70
jmp 0xbee3
jmp 0xbee5
leaq -0x30(%rbp), %rdi
callq 0xbc80
jmp 0xbe52
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xbae0
jmp 0xbf27
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xbf1d
movq -0x68(%rbp), %rdi
callq 0xbae0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3480
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0xdf40
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x17610
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x28(%rbp)
callq 0x17630
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl %ecx, 0x50(%rax)
movl $0x0, 0x54(%rax)
movslq 0x50(%rax), %rsi
callq 0x17650
jmp 0x152f8
movq -0x40(%rbp), %rdi
movl 0x50(%rdi), %esi
movl -0x10(%rbp), %edx
callq 0x15250
movb %al, %cl
movq -0x40(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x30(%rax)
testb $0x1, 0x30(%rax)
je 0x1534f
movq -0x40(%rbp), %rdi
callq 0x151e0
jmp 0x15324
jmp 0x1534f
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5e20
movq -0x38(%rbp), %rdi
callq 0x6ef0
movq -0x30(%rbp), %rdi
callq 0x6d30
jmp 0x15355
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3480
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0xdf40
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x17610
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x28(%rbp)
callq 0x17630
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl %ecx, 0x50(%rax)
movl $0x0, 0x54(%rax)
movslq 0x50(%rax), %rsi
callq 0x17650
jmp 0x153cc
movq -0x40(%rbp), %rax
movb -0xd(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
testb $0x1, 0x30(%rax)
je 0x15415
movq -0x40(%rbp), %rdi
callq 0x151e0
jmp 0x153ea
jmp 0x15415
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5e20
movq -0x38(%rbp), %rdi
callq 0x6ef0
movq -0x30(%rbp), %rdi
callq 0x6d30
jmp 0x1541b
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x30(%rax)
je 0x15890
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x17560
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x17880
movq -0x18(%rbp), %rdi
movb $0x1, (%rax)
addq $0x18, %rdi
movslq -0x10(%rbp), %rsi
callq 0x17560
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x17880
movb $0x1, (%rax)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xdff0
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0x178a0
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0xdff0
movq -0x18(%rbp), %rax
movl 0x54(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x54(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)