LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Konano[P]UselessDatabase/Database.cpp
// Function: Database::deleteTable(char const*)
int Database::deleteTable(const char* name) { // -1: doesn't exist, 0: OK
    int num = this->findTable(std::string(name));
    if (num == -1) return -1;
    delete table[num];
    for (uint i = num; i < table_num - 1; i++) {
        table[i] = table[i + 1];
        table[i]->table_id = i;
    }
    table[--table_num] = nullptr;
    fm->deleteFile(dirPath(this->name, name, "usid"));
    update();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x68a0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xc020
jmp 0x7ff3
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8150
movl %eax, -0x74(%rbp)
jmp 0x8005
leaq -0x40(%rbp), %rdi
callq 0x6340
leaq -0x41(%rbp), %rdi
callq 0x6530
movl -0x74(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x8060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8135
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8052
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6340
leaq -0x41(%rbp), %rdi
callq 0x6530
jmp 0x8141
movq -0x70(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x808e
movq -0x80(%rbp), %rdi
callq 0x48750
movq -0x80(%rbp), %rdi
movl $0x9fe8, %esi           # imm = 0x9FE8
callq 0x64b0
movl -0x1c(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x70(%rbp), %rcx
movl -0x58(%rbp), %eax
movl 0x820(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x80da
movq -0x70(%rbp), %rax
movl -0x58(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movq 0x20(%rax,%rcx,8), %rdx
movl -0x58(%rbp), %ecx
movq %rdx, 0x20(%rax,%rcx,8)
movl -0x58(%rbp), %ecx
movl -0x58(%rbp), %edx
movq 0x20(%rax,%rdx,8), %rax
movl %ecx, 0x50(%rax)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x8094
movq -0x70(%rbp), %rdi
movl 0x820(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x820(%rdi)
movl %eax, %eax
movq $0x0, 0x20(%rdi,%rax,8)
movq 0x828(%rdi), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x76921(%rip), %rdx     # 0x7ea32
callq 0x35280
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x34f10
movq -0x70(%rbp), %rdi
callq 0x7860
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6890
nopw (%rax,%rax)
// File: Konano[P]UselessDatabase/Database.cpp
// Function: Database::showTables()
void Database::showTables() {
    std::vector<std::pair<std::string, int> > v;
    v.push_back(std::pair<std::string, int>("Table", 20));
    Print::title(v);
    Anys d;
    for (uint i = 0; i < table_num; i++) {
        d.push_back(Any((char*)table[i]->name));
        Print::row(d);
        d.clear();
    }
    Print::end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc0d0
movl $0x14, -0x4c(%rbp)
leaq 0x767c6(%rip), %rsi     # 0x7ea37
leaq -0x48(%rbp), %rdi
leaq -0x4c(%rbp), %rdx
callq 0xc120
jmp 0x8280
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc0f0
jmp 0x828f
leaq -0x48(%rbp), %rdi
callq 0xc1a0
leaq -0x78(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc1c0
jmp 0x82a7
leaq -0x78(%rbp), %rdi
callq 0x45590
jmp 0x82b2
leaq -0x78(%rbp), %rdi
callq 0xc2b0
leaq -0x90(%rbp), %rdi
callq 0xc310
jmp 0x82c9
movl $0x0, -0x94(%rbp)
movq -0xc8(%rbp), %rcx
movl -0x94(%rbp), %eax
cmpl 0x820(%rcx), %eax
jae 0x8416
movq -0xc8(%rbp), %rax
movl -0x94(%rbp), %ecx
movq 0x20(%rax,%rcx,8), %rax
addq $0x18, %rax
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xc350
jmp 0x831e
leaq -0x90(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xc330
jmp 0x8333
leaq -0xa0(%rbp), %rdi
callq 0xc3c0
leaq -0xc0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xc400
jmp 0x8354
leaq -0xc0(%rbp), %rdi
callq 0x45a80
jmp 0x8362
leaq -0xc0(%rbp), %rdi
callq 0xc430
leaq -0x90(%rbp), %rdi
callq 0xc450
jmp 0x837c
jmp 0x837e
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x82d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x8447
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc1a0
jmp 0x8447
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xc2b0
jmp 0x8447
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x843b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xc3c0
jmp 0x843b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xc430
jmp 0x843b
callq 0x45cd0
jmp 0x841d
leaq -0x90(%rbp), %rdi
callq 0xc430
leaq -0x20(%rbp), %rdi
callq 0xc2b0
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x90(%rbp), %rdi
callq 0xc430
leaq -0x20(%rbp), %rdi
callq 0xc2b0
movq -0x58(%rbp), %rdi
callq 0x6890
nopl (%rax)
// File: Konano[P]UselessDatabase/Database.cpp
// Function: Database::getVarchar(unsigned long)
char* Database::getVarchar(uint64_t idx) {
    uint page = idx >> 32;
    uint offset = (idx & 0xffffffff) >> 16;
    uint size = idx & 0xffff;
    BufType buf = bpm->getPage(mem_file, page) + offset;
    char* str = new char[size + 1]; 
    char* _str = str;
    while (true) {
        if (PAGE_SIZE - offset > size) {
            memcpy(str, buf, size);
            offset += size;
            break;
        } else {
            memcpy(str, buf, (PAGE_SIZE - offset));
            str += PAGE_SIZE - offset;
            size -= PAGE_SIZE - offset;
            page += 1;
            offset = 0;
            buf = bpm->getPage(mem_file, page) + offset;
        }
    }
    
    str[size] = '\0';
    return _str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rcx
shrq $0x20, %rcx
movl %ecx, -0x14(%rbp)
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq -0x10(%rbp), %rcx
shrq $0x10, %rcx
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
movl %ecx, -0x1c(%rbp)
movq 0x830(%rax), %rdi
movl 0x838(%rax), %esi
movl -0x14(%rbp), %edx
callq 0x70b0
movl -0x18(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x6040
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x2000, %eax           # imm = 0x2000
subl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x850a
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x63f0
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x8580
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x2000, %eax           # imm = 0x2000
subl -0x18(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x63f0
movq -0x40(%rbp), %rax
movl $0x2000, %edx           # imm = 0x2000
subl -0x18(%rbp), %edx
movq -0x30(%rbp), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movl $0x2000, %edx           # imm = 0x2000
subl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
subl %edx, %ecx
movl %ecx, -0x1c(%rbp)
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq 0x830(%rax), %rdi
movl 0x838(%rax), %esi
movl -0x14(%rbp), %edx
callq 0x70b0
movl -0x18(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x84e0
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Konano[P]UselessDatabase/Database.cpp
// Function: Database::storeVarchar(char*)
uint64_t Database::storeVarchar(char* str) {
    uint size = strlen(str);
    uint64_t out = (mem << 16) + size;

    int index;
    uint page = mem >> 16;
    uint offset = mem & 0xffff;
    BufType buf = bpm->getPage(mem_file, page, index) + offset;
    while (true) {
        if (PAGE_SIZE - offset > size) {
            memcpy(buf, str, size);
            offset += size;
            break;
        } else {
            memcpy(buf, str, (PAGE_SIZE - offset));
            str += PAGE_SIZE - offset;
            size -= PAGE_SIZE - offset;
            page += 1;
            offset = 0;
            bpm->markDirty(index);
            buf = bpm->getPage(mem_file, page, index) + offset;
        }
    }
    bpm->markDirty(index);
    mem = ((uint64_t)page << 16) + offset;
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6250
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq 0x840(%rax), %rcx
shlq $0x10, %rcx
movl -0x14(%rbp), %edx
addq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movq 0x840(%rax), %rcx
shrq $0x10, %rcx
movl %ecx, -0x28(%rbp)
movq 0x840(%rax), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
movl %ecx, -0x2c(%rbp)
movq 0x830(%rax), %rdi
movl 0x838(%rax), %esi
movl -0x28(%rbp), %edx
leaq -0x24(%rbp), %rcx
callq 0x71d0
movl -0x2c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl $0x2000, %eax           # imm = 0x2000
subl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x864f
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x63f0
movl -0x14(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x86dc
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2000, %eax           # imm = 0x2000
subl -0x2c(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x63f0
movq -0x40(%rbp), %rax
movl $0x2000, %edx           # imm = 0x2000
subl -0x2c(%rbp), %edx
movq -0x10(%rbp), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, -0x10(%rbp)
movl $0x2000, %edx           # imm = 0x2000
subl -0x2c(%rbp), %edx
movl -0x14(%rbp), %ecx
subl %edx, %ecx
movl %ecx, -0x14(%rbp)
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq 0x830(%rax), %rdi
movl -0x24(%rbp), %esi
callq 0x7300
movq -0x40(%rbp), %rax
movq 0x830(%rax), %rdi
movl 0x838(%rax), %esi
movl -0x28(%rbp), %edx
leaq -0x24(%rbp), %rcx
callq 0x71d0
movl -0x2c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x8622
movq -0x40(%rbp), %rax
movq 0x830(%rax), %rdi
movl -0x24(%rbp), %esi
callq 0x7300
movq -0x40(%rbp), %rax
movl -0x28(%rbp), %ecx
shlq $0x10, %rcx
movl -0x2c(%rbp), %edx
addq %rdx, %rcx
movq %rcx, 0x840(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Konano[P]UselessDatabase/Database.cpp
// Function: cmpCol(enumOp, Anys&, Anys&)
bool cmpCol(enumOp op, Anys &a, Anys &b) {
    switch (op) {
    case OP_EQ: return a == b;
    case OP_NEQ: return a != b;
    case OP_LE: return a <= b;
    case OP_GE: return a >= b;
    case OP_LS: return a < b;
    case OP_GT: return a > b;
    default: return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0x87d0
movq -0x20(%rbp), %rax
leaq 0x758d1(%rip), %rcx     # 0x7e020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc500
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x87d4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc5a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x87d4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc5d0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x87d4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc600
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x87d4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc630
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x87d4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc710
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x87d4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator=(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>)
basic_json& operator=(basic_json other) noexcept (
        std::is_nothrow_move_constructible<value_t>::value and
        std::is_nothrow_move_assignable<value_t>::value and
        std::is_nothrow_move_constructible<json_value>::value and
        std::is_nothrow_move_assignable<json_value>::value
    )
    {
        // check that passed value is valid
        other.assert_invariant();

        using std::swap;
        swap(m_type, other.m_type);
        swap(m_value, other.m_value);

        assert_invariant();
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x17ae0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x1cb20
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x1cb50
movq -0x18(%rbp), %rdi
callq 0x17ae0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::push_back(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>&&)
void push_back(basic_json&& val)
    {
        // push_back only works for null objects or arrays
        if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
        {
            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
        }

        // transform null object into an array
        if (is_null())
        {
            m_type = value_t::array;
            m_value = value_t::array;
            assert_invariant();
        }

        // add element to array (move semantics)
        m_value.array->push_back(std::move(val));
        // invalidate object: mark it null so we do not call the destructor
        // cppcheck-suppress accessMoved
        val.m_type = value_t::null;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1b300
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x71(%rbp)
jne 0xb228
movq -0x80(%rbp), %rdi
callq 0x18420
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb23a
jmp 0xb331
movb $0x1, -0x65(%rbp)
movl $0x20, %edi
callq 0x62a0
movq -0x80(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x1b400
movq %rax, -0x90(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x68a0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0xc020
jmp 0xb288
leaq 0x74d6a(%rip), %rsi     # 0x7fff9
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x150c0
jmp 0xb29e
movq -0x98(%rbp), %rdi
movl $0x134, %esi            # imm = 0x134
leaq -0x30(%rbp), %rdx
callq 0x14ed0
jmp 0xb2b5
movq -0x98(%rbp), %rdi
movb $0x0, -0x65(%rbp)
leaq 0xa5671(%rip), %rsi     # 0xb0938
leaq 0x9f22(%rip), %rdx      # 0x151f0
callq 0x6850
jmp 0xb390
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xb312
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xb309
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6340
leaq -0x50(%rbp), %rdi
callq 0x6340
leaq -0x51(%rbp), %rdi
callq 0x6530
testb $0x1, -0x65(%rbp)
jne 0xb323
jmp 0xb32f
movq -0x98(%rbp), %rdi
callq 0x63a0
jmp 0xb387
movq -0x80(%rbp), %rdi
callq 0x1b300
testb $0x1, %al
jne 0xb340
jmp 0xb366
movq -0x80(%rbp), %rax
movb $0x2, (%rax)
leaq -0x70(%rbp), %rdi
movl $0x2, %esi
callq 0x198e0
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, 0x8(%rdi)
callq 0x17ae0
movq -0x80(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x18320
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6890
// File: Konano[P]UselessDatabase/./Anys.h
// Function: Anys::operator==(Anys const&) const
bool operator==(const Anys &b) const {
        uint sz = size();
        if (sz != b.size()) return false;
        for (uint i = 0; i < sz; i++) if (!(v[i] == b.v[i])) return false;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xcd90
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0xcd90
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
je 0xc53e
movb $0x0, -0x1(%rbp)
jmp 0xc594
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0xc590
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x108c0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x108c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x108e0
testb $0x1, %al
jne 0xc583
movb $0x0, -0x1(%rbp)
jmp 0xc594
jmp 0xc585
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc545
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Konano[P]UselessDatabase/./Anys.h
// Function: Anys::operator<(Anys const&) const
bool operator<(const Anys &b) const {
        uint sz = size(), _sz = b.size();
        if (sz != _sz) return sz < _sz;
        for (uint i = 0; i < sz; i++) if (!(v[i] == b.v[i])) return v[i] < b.v[i];
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xcd90
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0xcd90
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0xc677
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xc6fa
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0xc6f6
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x108c0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x108c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x108e0
testb $0x1, %al
jne 0xc6e9
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x108c0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x108c0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xd370
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xc6fa
jmp 0xc6eb
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc67e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Konano[P]UselessDatabase/./Any.h
// Function: Any::Any(Any const&)
Any(const Any &any) {
        if (any._pValue)
            _pValue = any._pValue->clone();
        else 
            _pValue = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xca3b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xca46
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Konano[P]UselessDatabase/Database.cpp
// Function: getch()
inline char getch() {
    struct termios tm, tm_old;
    int fd = 0, ch;
    if (tcgetattr(fd, &tm) < 0) return -1;
    tm_old = tm;
    cfmakeraw(&tm);
    if (tcsetattr(fd, TCSANOW, &tm) < 0) return -1;
    ch = getchar();
    if (tcsetattr(fd, TCSANOW, &tm_old) < 0) return -1;
    return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x80(%rbp)
movl -0x80(%rbp), %edi
leaq -0x40(%rbp), %rsi
callq 0x6580
cmpl $0x0, %eax
jge 0xd059
movb $-0x1, -0x1(%rbp)
jmp 0xd0ba
leaq -0x7c(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x3c, %edx
callq 0x63f0
leaq -0x40(%rbp), %rdi
callq 0x66d0
movl -0x80(%rbp), %edi
xorl %esi, %esi
leaq -0x40(%rbp), %rdx
callq 0x6620
cmpl $0x0, %eax
jge 0xd08d
movb $-0x1, -0x1(%rbp)
jmp 0xd0ba
callq 0x66c0
movl %eax, -0x84(%rbp)
movl -0x80(%rbp), %edi
xorl %esi, %esi
leaq -0x7c(%rbp), %rdx
callq 0x6620
cmpl $0x0, %eax
jge 0xd0b1
movb $-0x1, -0x1(%rbp)
jmp 0xd0ba
movl -0x84(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Konano[P]UselessDatabase/./Any.h
// Function: Any::operator=(Any const&)
Any& operator=(const Any& any) {
        _pValue = nullptr;
        if (any._pValue) {
            _pValue = any._pValue->clone();
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd360
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Konano[P]UselessDatabase/./Any.h
// Function: Any::operator<(Any const&) const
bool operator<(const Any &b) const
    {
        if (isNull() || b.isNull()) {
            if (isNull() && b.isNull()) return false;
            if (isNull() && !b.isNull()) return true;
            if (!isNull() && b.isNull()) return false;
        } else if (b.anyCast<char*>() != nullptr) {
            return *this < (const char*)*b.anyCast<char*>();
        } else if (b.anyCast<int>() != nullptr) {
            return *this < *b.anyCast<int>();
        } else if (b.anyCast<long double>() != nullptr) {
            return *this < *b.anyCast<long double>();
        } else if (b.anyCast<uint32_t>() != nullptr) {
            return *this < *b.anyCast<uint32_t>();
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xc920
testb $0x1, %al
jne 0xd3a0
movq -0x18(%rbp), %rdi
callq 0xc920
testb $0x1, %al
jne 0xd3a0
jmp 0xd416
movq -0x20(%rbp), %rdi
callq 0xc920
testb $0x1, %al
jne 0xd3af
jmp 0xd3c7
movq -0x18(%rbp), %rdi
callq 0xc920
testb $0x1, %al
jne 0xd3be
jmp 0xd3c7
movb $0x0, -0x1(%rbp)
jmp 0xd4d1
movq -0x20(%rbp), %rdi
callq 0xc920
testb $0x1, %al
jne 0xd3d6
jmp 0xd3ec
movq -0x18(%rbp), %rdi
callq 0xc920
testb $0x1, %al
jne 0xd3ec
movb $0x1, -0x1(%rbp)
jmp 0xd4d1
movq -0x20(%rbp), %rdi
callq 0xc920
testb $0x1, %al
jne 0xd411
movq -0x18(%rbp), %rdi
callq 0xc920
testb $0x1, %al
jne 0xd408
jmp 0xd411
movb $0x0, -0x1(%rbp)
jmp 0xd4d1
jmp 0xd4cd
movq -0x18(%rbp), %rdi
callq 0x10a50
cmpq $0x0, %rax
je 0xd444
movq -0x18(%rbp), %rdi
callq 0x10a50
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
callq 0x11450
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd4d1
movq -0x18(%rbp), %rdi
callq 0x10b40
cmpq $0x0, %rax
je 0xd46f
movq -0x18(%rbp), %rdi
callq 0x10b40
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x114c0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd4d1
movq -0x18(%rbp), %rdi
callq 0x10c30
cmpq $0x0, %rax
je 0xd49a
movq -0x18(%rbp), %rdi
callq 0x10c30
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x11530
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd4d1
movq -0x18(%rbp), %rdi
callq 0x10d20
cmpq $0x0, %rax
je 0xd4c5
movq -0x18(%rbp), %rdi
callq 0x10d20
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x115a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd4d1
jmp 0xd4c7
jmp 0xd4c9
jmp 0xd4cb
jmp 0xd4cd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Konano[P]UselessDatabase/./Any.h
// Function: Any::operator==(char const*) const
bool operator==(const char* value) const
    {
        if (isNull()) {
            return false; 
        } else if (this->anyCast<char*>() != nullptr) {
            return strcmp(*this->anyCast<char*>(), value) == 0;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xc920
testb $0x1, %al
jne 0x10af3
jmp 0x10af9
movb $0x0, -0x1(%rbp)
jmp 0x10b30
movq -0x20(%rbp), %rdi
callq 0x10a50
cmpq $0x0, %rax
je 0x10b2a
movq -0x20(%rbp), %rdi
callq 0x10a50
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x66e0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x10b30
jmp 0x10b2c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/./Any.h
// Function: bool Any::operator==<int>(int const&) const
bool operator==(const ValueType &value) const
    {
        if (isNull()) {
            return false; 
        } else if (this->anyCast<ValueType>() != nullptr) {
            return *this->anyCast<ValueType>() == value;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xc920
testb $0x1, %al
jne 0x10be3
jmp 0x10be9
movb $0x0, -0x1(%rbp)
jmp 0x10c19
movq -0x20(%rbp), %rdi
callq 0x10b40
cmpq $0x0, %rax
je 0x10c13
movq -0x20(%rbp), %rdi
callq 0x10b40
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x10c19
jmp 0x10c15
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Konano[P]UselessDatabase/./Any.h
// Function: Any::operator<(char const*) const
bool operator<(const char* value) const
    {
        if (isNull()) {
            return true; 
        } else if (this->anyCast<char*>() != nullptr) {
            return strcmp(*this->anyCast<char*>(), value) < 0;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xc920
testb $0x1, %al
jne 0x11473
jmp 0x11479
movb $0x1, -0x1(%rbp)
jmp 0x114b0
movq -0x20(%rbp), %rdi
callq 0x10a50
cmpq $0x0, %rax
je 0x114aa
movq -0x20(%rbp), %rdi
callq 0x10a50
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x66e0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x114b0
jmp 0x114ac
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/./Any.h
// Function: bool Any::operator<<int>(int const&) const
bool operator<(const ValueType &value) const
    {
        if (isNull()) {
            return true; 
        } else if (this->anyCast<ValueType>() != nullptr) {
            return *this->anyCast<ValueType>() < value;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xc920
testb $0x1, %al
jne 0x114e3
jmp 0x114e9
movb $0x1, -0x1(%rbp)
jmp 0x11519
movq -0x20(%rbp), %rdi
callq 0x10b40
cmpq $0x0, %rax
je 0x11513
movq -0x20(%rbp), %rdi
callq 0x10b40
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11519
jmp 0x11515
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Konano[P]UselessDatabase/./Any.h
// Function: Any::operator>(char const*) const
bool operator>(const char* value) const
    {
        if (isNull()) {
            return false; 
        } else if (this->anyCast<char*>() != nullptr) {
            return strcmp(*this->anyCast<char*>(), value) > 0;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xc920
testb $0x1, %al
jne 0x11633
jmp 0x11639
movb $0x0, -0x1(%rbp)
jmp 0x11670
movq -0x20(%rbp), %rdi
callq 0x10a50
cmpq $0x0, %rax
je 0x1166a
movq -0x20(%rbp), %rdi
callq 0x10a50
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x66e0
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11670
jmp 0x1166c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::dump_float(double)
void dump_float(number_float_t x)
    {
        // NaN / inf
        if (not std::isfinite(x))
        {
            o->write_characters("null", 4);
            return;
        }

        // If number_float_t is an IEEE-754 single or double precision number,
        // use the Grisu2 algorithm to produce short numbers which are
        // guaranteed to round-trip, using strtof and strtod, resp.
        //
        // NB: The test below works if <long double> == <double>.
        static constexpr bool is_ieee_single_or_double
            = (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 24 and std::numeric_limits<number_float_t>::max_exponent == 128) or
              (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 53 and std::numeric_limits<number_float_t>::max_exponent == 1024);

        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x16100
testb $0x1, %al
jne 0x14cd7
movq -0x20(%rbp), %rdi
callq 0x13880
movq %rax, %rdi
movq (%rdi), %rax
leaq 0x69fa9(%rip), %rsi     # 0x7ec76
movl $0x4, %edx
callq *0x8(%rax)
jmp 0x14ce5
movq -0x20(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x16140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::count_digits(unsigned long)
inline unsigned int count_digits(number_unsigned_t x) noexcept
    {
        unsigned int n_digits = 1;
        for (;;)
        {
            if (x < 10)
            {
                return n_digits;
            }
            if (x < 100)
            {
                return n_digits + 1;
            }
            if (x < 1000)
            {
                return n_digits + 2;
            }
            if (x < 10000)
            {
                return n_digits + 3;
            }
            x = x / 10000u;
            n_digits += 4;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
cmpq $0xa, -0x18(%rbp)
jae 0x15fb2
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1600b
cmpq $0x64, -0x18(%rbp)
jae 0x15fc4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1600b
cmpq $0x3e8, -0x18(%rbp)     # imm = 0x3E8
jae 0x15fd9
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0x1600b
cmpq $0x2710, -0x18(%rbp)    # imm = 0x2710
jae 0x15fee
movl -0x1c(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0x1600b
movq -0x18(%rbp), %rax
movl $0x2710, %ecx           # imm = 0x2710
xorl %edx, %edx
divq %rcx
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15fa3
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: Konano[P]UselessDatabase/./json.hpp
// Function: void nlohmann::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double)
JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
                  "internal error: not enough precision");

    assert(std::isfinite(value));
    assert(value > 0);

    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
    // decimal representations are not exactly "short".
    //
    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
    // and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
    // does.
    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
    // representation using the corresponding std::from_chars function recovers value exactly". That
    // indicates that single precision floating-point numbers should be recovered using
    // 'std::strtof'.
    //
    // NB: If the neighbors are computed for single-precision numbers, there is a single float
    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
    //     value is off by 1 ulp.
#if 0
    const boundaries w = compute_boundaries(static_cast<double>(value));
#else
    const boundaries w = compute_boundaries(value);
#endif

    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x16100
testb $0x1, %al
jne 0x1644c
jmp 0x1644e
jmp 0x1646d
leaq 0x68b4d(%rip), %rdi     # 0x7efa2
leaq 0x686e5(%rip), %rsi     # 0x7eb41
movl $0x34e1, %edx           # imm = 0x34E1
leaq 0x68cc6(%rip), %rcx     # 0x7f12e
callq 0x6350
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1647d
jmp 0x1649c
leaq 0x68d09(%rip), %rdi     # 0x7f18d
leaq 0x686b6(%rip), %rsi     # 0x7eb41
movl $0x34e2, %edx           # imm = 0x34E2
leaq 0x68c97(%rip), %rcx     # 0x7f12e
callq 0x6350
movsd -0x20(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
callq 0x16790
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rcx
movl -0x58(%rbp), %r8d
leaq -0x70(%rbp), %r9
leaq -0x80(%rbp), %rax
movq (%r9), %r10
movq %r10, (%rsp)
movq 0x8(%r9), %r9
movq %r9, 0x8(%rsp)
movq (%rax), %r9
movq %r9, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x16a30
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::detail::dtoa_impl::diyfp::normalize(nlohmann::detail::dtoa_impl::diyfp)
static diyfp normalize(diyfp x) noexcept
    {
        assert(x.f != 0);

        while ((x.f >> 63u) == 0)
        {
            x.f <<= 1u;
            x.e--;
        }

        return x;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movl %esi, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x16cd8
jmp 0x16cf7
leaq 0x68513(%rip), %rdi     # 0x7f1f2
leaq 0x67e5b(%rip), %rsi     # 0x7eb41
movl $0x31f7, %edx           # imm = 0x31F7
leaq 0x68509(%rip), %rcx     # 0x7f1fb
callq 0x6350
jmp 0x16cf9
movq -0x20(%rbp), %rax
shrq $0x3f, %rax
cmpq $0x0, %rax
jne 0x16d1d
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x16cf9
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::detail::dtoa_impl::diyfp::normalize_to(nlohmann::detail::dtoa_impl::diyfp const&, int)
static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
    {
        const int delta = x.e - target_exponent;

        assert(delta >= 0);
        assert(((x.f << delta) >> delta) == x.f);

        return {x.f << delta, target_exponent};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x16d64
jmp 0x16d83
leaq 0x684d2(%rip), %rdi     # 0x7f23d
leaq 0x67dcf(%rip), %rsi     # 0x7eb41
movl $0x320a, %edx           # imm = 0x320A
leaq 0x684ca(%rip), %rcx     # 0x7f248
callq 0x6350
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
shlq %cl, %rax
movl -0x20(%rbp), %ecx
shrq %cl, %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x16da1
jmp 0x16dc0
leaq 0x684f8(%rip), %rdi     # 0x7f2a0
leaq 0x67d92(%rip), %rsi     # 0x7eb41
movl $0x320b, %edx           # imm = 0x320B
leaq 0x6848d(%rip), %rcx     # 0x7f248
callq 0x6350
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movb -0x20(%rbp), %cl
shlq %cl, %rsi
movl -0x1c(%rbp), %edx
leaq -0x10(%rbp), %rdi
callq 0x16c90
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::detail::dtoa_impl::find_largest_pow10(unsigned int, unsigned int&)
inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
{
    // LCOV_EXCL_START
    if (n >= 1000000000)
    {
        pow10 = 1000000000;
        return 10;
    }
    // LCOV_EXCL_STOP
    else if (n >= 100000000)
    {
        pow10 = 100000000;
        return  9;
    }
    else if (n >= 10000000)
    {
        pow10 = 10000000;
        return  8;
    }
    else if (n >= 1000000)
    {
        pow10 = 1000000;
        return  7;
    }
    else if (n >= 100000)
    {
        pow10 = 100000;
        return  6;
    }
    else if (n >= 10000)
    {
        pow10 = 10000;
        return  5;
    }
    else if (n >= 1000)
    {
        pow10 = 1000;
        return  4;
    }
    else if (n >= 100)
    {
        pow10 = 100;
        return  3;
    }
    else if (n >= 10)
    {
        pow10 = 10;
        return  2;
    }
    else
    {
        pow10 = 1;
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3b9aca00, -0x8(%rbp) # imm = 0x3B9ACA00
jb 0x1766a
movq -0x10(%rbp), %rax
movl $0x3b9aca00, (%rax)     # imm = 0x3B9ACA00
movl $0xa, -0x4(%rbp)
jmp 0x1775e
cmpl $0x5f5e100, -0x8(%rbp)  # imm = 0x5F5E100
jb 0x17689
movq -0x10(%rbp), %rax
movl $0x5f5e100, (%rax)      # imm = 0x5F5E100
movl $0x9, -0x4(%rbp)
jmp 0x1775e
cmpl $0x989680, -0x8(%rbp)   # imm = 0x989680
jb 0x176a8
movq -0x10(%rbp), %rax
movl $0x989680, (%rax)       # imm = 0x989680
movl $0x8, -0x4(%rbp)
jmp 0x1775e
cmpl $0xf4240, -0x8(%rbp)    # imm = 0xF4240
jb 0x176c7
movq -0x10(%rbp), %rax
movl $0xf4240, (%rax)        # imm = 0xF4240
movl $0x7, -0x4(%rbp)
jmp 0x1775e
cmpl $0x186a0, -0x8(%rbp)    # imm = 0x186A0
jb 0x176e3
movq -0x10(%rbp), %rax
movl $0x186a0, (%rax)        # imm = 0x186A0
movl $0x6, -0x4(%rbp)
jmp 0x1775e
cmpl $0x2710, -0x8(%rbp)     # imm = 0x2710
jb 0x176ff
movq -0x10(%rbp), %rax
movl $0x2710, (%rax)         # imm = 0x2710
movl $0x5, -0x4(%rbp)
jmp 0x1775e
cmpl $0x3e8, -0x8(%rbp)      # imm = 0x3E8
jb 0x1771b
movq -0x10(%rbp), %rax
movl $0x3e8, (%rax)          # imm = 0x3E8
movl $0x4, -0x4(%rbp)
jmp 0x1775e
cmpl $0x64, -0x8(%rbp)
jb 0x17734
movq -0x10(%rbp), %rax
movl $0x64, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x1775e
cmpl $0xa, -0x8(%rbp)
jb 0x1774d
movq -0x10(%rbp), %rax
movl $0xa, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x1775e
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::basic_json(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>&&)
basic_json(basic_json&& other) noexcept
        : m_type(std::move(other.m_type)),
          m_value(std::move(other.m_value))
    {
        // check that passed value is valid
        other.assert_invariant();

        // invalidate payload
        other.m_type = value_t::null;
        other.m_value = {};

        assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x17ae0
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x62c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
callq 0x17ae0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::type_name() const
const noexcept
    {
        {
            switch (m_type)
            {
                case value_t::null:
                    return "null";
                case value_t::object:
                    return "object";
                case value_t::array:
                    return "array";
                case value_t::string:
                    return "string";
                case value_t::boolean:
                    return "boolean";
                case value_t::discarded:
                    return "discarded";
                default:
                    return "number";
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x8, %rax
ja 0x1b47b
movq -0x18(%rbp), %rax
leaq 0x62cc4(%rip), %rcx     # 0x7e0e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x63842(%rip), %rax     # 0x7ec76
movq %rax, -0x8(%rbp)
jmp 0x1b486
leaq 0x64989(%rip), %rax     # 0x7fdca
movq %rax, -0x8(%rbp)
jmp 0x1b486
leaq 0x64983(%rip), %rax     # 0x7fdd1
movq %rax, -0x8(%rbp)
jmp 0x1b486
leaq 0x6497c(%rip), %rax     # 0x7fdd7
movq %rax, -0x8(%rbp)
jmp 0x1b486
leaq 0x64976(%rip), %rax     # 0x7fdde
movq %rax, -0x8(%rbp)
jmp 0x1b486
leaq 0x64971(%rip), %rax     # 0x7fde6
movq %rax, -0x8(%rbp)
jmp 0x1b486
leaq 0x6496e(%rip), %rax     # 0x7fdf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::skip_bom()
bool skip_bom()
    {
        if (get() == 0xEF)
        {
            // check if we completely parse the BOM
            return get() == 0xBB and get() == 0xBF;
        }

        // the first character is not the beginning of the BOM; unget it to
        // process is later
        unget();
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x21310
cmpl $0xef, %eax
jne 0x212f6
movq -0x18(%rbp), %rdi
callq 0x21310
movl %eax, %ecx
xorl %eax, %eax
cmpl $0xbb, %ecx
movb %al, -0x19(%rbp)
jne 0x212ec
movq -0x18(%rbp), %rdi
callq 0x21310
cmpl $0xbf, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x21303
movq -0x18(%rbp), %rdi
callq 0x225b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Konano[P]UselessDatabase/./json.hpp
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::get()
std::char_traits<char>::int_type get()
    {
        ++position.chars_read_total;
        ++position.chars_read_current_line;

        if (next_unget)
        {
            // just reset the next_unget variable and work with current
            next_unget = false;
        }
        else
        {
            current = ia->get_character();
        }

        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
        {
            token_string.push_back(std::char_traits<char>::to_char_type(current));
        }

        if (current == '\n')
        {
            ++position.lines_read;
            position.chars_read_current_line = 0;
        }

        return current;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
testb $0x1, 0x14(%rax)
je 0x2134c
movq -0x18(%rbp), %rax
movb $0x0, 0x14(%rax)
jmp 0x21366
movq -0x18(%rbp), %rdi
callq 0x22800
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
callq 0x20f80
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x21389
jmp 0x213b1
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x28(%rbp)
addq $0x10, %rdi
callq 0x22850
movq -0x28(%rbp), %rdi
movb %al, -0x9(%rbp)
leaq -0x9(%rbp), %rsi
callq 0x22820
movq -0x18(%rbp), %rax
cmpl $0xa, 0x10(%rax)
jne 0x213d3
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addq $0x30, %rsp
popq %rbp
retq