LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/j-faria[P]kima/examples/default_priors/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "dummy_data.rv";

    load(datafile, "kms", 0);

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(1000);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
movq 0x32852(%rip), %rdx     # 0x53548
leaq 0x32843(%rip), %r14     # 0x53540
leaq 0x2468d(%rip), %rcx     # 0x45391
movl $0xd, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x6600
leaq 0x8(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x1e7c2(%rip), %rsi     # 0x3f4e8
movq %r14, %rdi
callq 0x20f1d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x21020
movq %r14, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x210f2
leaq 0x8(%rsp), %rdi
callq 0x212d0
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x212d0
movq %rbx, %rdi
callq 0x6710
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/char.hxx
// Function: std::enable_if<!cxon::JSON<cxon::json::format_traits>::produce_strict_javascript, bool>::type cxon::cio::chr::imp::encode_<cxon::JSON<cxon::json::format_traits>, char32_t>::value<cxon::cnt::range_container<char*>, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(cxon::cnt::range_container<char*>&, char32_t, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static auto value(O& o, char32_t c, Cx& cx) -> enable_if_t<!S::produce_strict_javascript, bool> {
                        if (c > 0x7F) {
                                char b[4]; int const n = utf32_to_utf8(b, c);
                                return poke<X>(o, b, n, cx);
                        }
                        else    return encode_<X, char>::value(o, char(c), cx);
                    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x80, %esi
jb 0x193c99
movl %esi, %ecx
andl $0xfffffc00, %ecx       # imm = 0xFFFFFC00
xorl %eax, %eax
cmpl $0xd800, %ecx           # imm = 0xD800
je 0x193c6e
movl $0x2, %eax
cmpl $0x800, %esi            # imm = 0x800
jb 0x193c18
movl $0x3, %eax
cmpl $0x10000, %esi          # imm = 0x10000
jb 0x193c18
xorl %eax, %eax
cmpl $0x110000, %esi         # imm = 0x110000
setb %al
shll $0x2, %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0x193c6e
leaq 0x58bc9(%rip), %rdx     # 0x1ec7f0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %esi, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x7(%rsp)
shrl $0x6, %esi
movl %esi, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x6(%rsp)
shrl $0x6, %esi
movl %esi, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x5(%rsp)
shrl $0x6, %esi
movl %eax, %ecx
leaq 0x5447a(%rip), %rdx     # 0x1e80e0
orl (%rdx,%rcx,8), %esi
movb %sil, 0x4(%rsp)
movl %eax, %r15d
movq 0x8(%rbx), %r12
movq 0x10(%rbx), %rdi
subq %rdi, %r12
cmpq %r15, %r12
jl 0x193cb3
testq %r15, %r15
je 0x193c93
leaq 0x4(%rsp), %rsi
movq %r15, %rdx
callq 0xe200
addq %r15, 0x10(%rbx)
jmp 0x193cc3
movsbl %sil, %esi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe2a10
callq 0x4b9ec
movl $0x1, (%r14)
movq %rax, 0x8(%r14)
cmpq %r15, %r12
setge %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/variant.hxx
// Function: bool cxon::cio::var::variant_read<cxon::JSON<cxon::json::format_traits>, boost::variant2::variant<std::nullptr_t, boost::container::map<int, int, std::less<int>, void, void>, boost::container::stable_vector<int, void>, boost::container::basic_string<char, std::char_traits<char>, void>, int, bool>, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>>(boost::variant2::variant<std::nullptr_t, boost::container::map<int, int, std::less<int>, void, void>, boost::container::stable_vector<int, void>, boost::container::basic_string<char, std::char_traits<char>, void>, int, bool>&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
inline bool variant_read(V& v, II& i, II e, Cx& cx) {
            if (!consume<X>(i, e, cx))
                return false;
            switch (peek(i, e)) {
                case X::map::beg:
                    return imp::variant_read_<X, is_map>(v, i, e, cx);
                case X::list::beg:
                    return imp::variant_read_<X, is_list>(v, i, e, cx);
                case X::string::del:
                    return imp::variant_read_<X, is_string>(v, i, e, cx);
                case '-': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case 'I': case 'N':
                    return imp::variant_read_<X, is_number>(v, i, e, cx);
                case *X::id::pos: case *X::id::neg:
                    return imp::variant_read_<X, is_bool>(v, i, e, cx);
                case *X::id::nil:
                    return imp::variant_read_<X, is_null>(v, i, e, cx);
            }
            return cx/json::read_error::unexpected;
        }

// Assembly:
pushq %rbx
movq %rcx, %rbx
movq (%rsi), %rax
cmpq %rdx, %rax
je 0xab9ff
leaq 0x13c5c7(%rip), %rcx    # 0x1e7fb0
movzbl (%rax), %r8d
testb $0x8, (%r8,%rcx)
je 0xab9ff
incq %rax
movq %rax, (%rsi)
cmpq %rdx, %rax
jne 0xab9e9
movq (%rsi), %rax
cmpq %rdx, %rax
je 0xaba0b
movb (%rax), %al
jmp 0xaba0d
movb $-0x1, %al
movzbl %al, %eax
cmpl $0x65, %eax
jg 0xaba36
addl $-0x22, %eax
cmpl $0x39, %eax
ja 0xaba87
movabsq $0x108000ffc800, %rcx   # imm = 0x108000FFC800
btq %rax, %rcx
jae 0xaba61
movq %rbx, %rcx
popq %rbx
jmp 0xac36e
cmpl $0x73, %eax
jg 0xaba4e
cmpl $0x66, %eax
je 0xaba75
cmpl $0x6e, %eax
jne 0xaba87
movq %rbx, %rcx
popq %rbx
jmp 0xac486
cmpl $0x74, %eax
je 0xaba75
cmpl $0x7b, %eax
jne 0xaba87
movq %rbx, %rcx
popq %rbx
jmp 0xaba9a
testq %rax, %rax
je 0xaba7e
cmpq $0x39, %rax
jne 0xaba87
movq %rbx, %rcx
popq %rbx
jmp 0xac0ba
movq %rbx, %rcx
popq %rbx
jmp 0xac3b8
movq %rbx, %rcx
popq %rbx
jmp 0xac292
callq 0x4ae3c
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/string.hxx
// Function: bool cxon::cio::str::imp::char_read_<cxon::JSON<cxon::test::input_iterator_traits<cxon::json::format_traits>>, cxon::cnt::range_container<char*>, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::input_iterator_traits<cxon::json::format_traits>>>, char>(cxon::cnt::range_container<char*>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::input_iterator_traits<cxon::json::format_traits>>>&)
inline bool char_read_(C& c, II& i, II e, Cx& cx) {
                II const o = i;
                    char32_t const c32 = chr::utf8_to_utf32<X>(i, e, cx);
                        if (c32 == chr::bad_utf32) return rewind(i, o), false;
                return char_append_(c, c32) || (rewind(i, o), cx/X::read_error::overflow);
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movq (%rdx), %rcx
movq (%rsi), %rdx
cmpq %rcx, %rdx
je 0xdf265
cmpb $0x5c, (%rdx)
jne 0xdf265
incq (%rax)
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdf011
jmp 0xdf276
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %rax, %rdi
movq %rbx, %rdx
callq 0xdf40c
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
je 0xdf35f
movl %ecx, %edx
andl $0xfffffc00, %edx       # imm = 0xFFFFFC00
cmpl $0xd800, %edx           # imm = 0xD800
je 0xdf320
movl $0x1, %eax
cmpl $0x80, %ecx
jb 0xdf2cc
movl $0x2, %eax
cmpl $0x800, %ecx            # imm = 0x800
jb 0xdf2cc
movl $0x3, %eax
cmpl $0x10000, %ecx          # imm = 0x10000
jb 0xdf2cc
xorl %eax, %eax
cmpl $0x110000, %ecx         # imm = 0x110000
setb %al
shll $0x2, %eax
leal -0x1(%rax), %edx
cmpl $0x3, %edx
ja 0xdf320
leaq 0x1090c5(%rip), %rsi    # 0x1e83a0
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movl %ecx, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x3(%rsp)
shrl $0x6, %ecx
movl %ecx, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x2(%rsp)
shrl $0x6, %ecx
movl %ecx, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, 0x1(%rsp)
shrl $0x6, %ecx
movl %eax, %edx
leaq 0x108dc6(%rip), %rsi    # 0x1e80e0
orl (%rsi,%rdx,8), %ecx
movb %cl, (%rsp)
movl %eax, %r15d
movq 0x8(%r14), %r12
movq 0x10(%r14), %rdi
subq %rdi, %r12
cmpq %r15, %r12
jl 0xdf34e
testq %r15, %r15
je 0xdf343
movq %rsp, %rsi
movq %r15, %rdx
callq 0xe200
addq %r15, 0x10(%r14)
movb $0x1, %al
cmpq %r15, %r12
jge 0xdf35f
callq 0x4ae3c
movl $0x8, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/json/compound.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(T*& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<Y>(i, e, cx))
                        return false;
                    if (cio::peek(i, e) == *Y::id::nil) {
                        II const o = i;
                        return  (cio::consume<Y>(Y::id::nil, i, e) && (t = nullptr, true)) ||
                                (cio::rewind(i, o), cx/json::read_error::unexpected)
                        ;
                    }
                    auto al = alc::make_context_allocator<T>(cx);
                    T *const n = al.create();
                        if (!read_value<Y>(*n, i, e, cx))
                            return al.release(n), false;
                    return t = n, true;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %r15
movq (%rsi), %rax
cmpq %rdx, %rax
je 0x1e5ed3
leaq 0x20f1(%rip), %rcx      # 0x1e7fb0
movzbl (%rax), %edx
testb $0x8, (%rdx,%rcx)
je 0x1e5ed3
incq %rax
movq %rax, (%r15)
cmpq %r12, %rax
jne 0x1e5ebf
movq (%r15), %rax
cmpq %r12, %rax
je 0x1e5f2a
cmpb $0x6e, (%rax)
jne 0x1e5f2a
cmpq %r12, %rax
je 0x1e5f81
movq %r12, %rdx
subq %rax, %rdx
leaq 0x8201(%rip), %rsi      # 0x1ee0f7
addq %rsi, %rdx
movl $0x4, %r10d
leaq 0x81f5(%rip), %rcx      # 0x1ee0fb
movq %rax, %r8
subq $0x1, %r10
jb 0x1e5f8d
movb (%rsi), %r9b
cmpb (%r8), %r9b
jne 0x1e5f8a
incq %r8
movq %r8, (%r15)
incq %rsi
cmpq %r12, %r8
jne 0x1e5f09
movq %rdx, %rcx
jmp 0x1e5f8d
movq %rdi, %r14
movl $0x20, %edi
callq 0xe260
movq %rax, %r13
leaq 0x10(%rax), %rbx
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0xe6e56
movl %eax, %ebp
testb %al, %al
je 0x1e5f69
movq %r13, (%r14)
jmp 0x1e5fb3
movq (%r13), %rdi
cmpq %rbx, %rdi
je 0x1e5f77
callq 0xe250
movq %r13, %rdi
callq 0xe250
jmp 0x1e5fb3
leaq 0x816f(%rip), %rcx      # 0x1ee0f7
jmp 0x1e5f8d
movq %rsi, %rcx
cmpb $0x0, (%rcx)
je 0x1e5fa9
movq %rax, (%r15)
callq 0x4ae3c
movl $0x1, (%rbp)
movq %rax, 0x8(%rbp)
xorl %ebp, %ebp
jmp 0x1e5fb3
movq $0x0, (%rdi)
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<cxon::test::input_iterator_traits<cxon::json::format_traits>>, char, void>::value<cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::input_iterator_traits<cxon::json::format_traits>>>>(char&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::input_iterator_traits<cxon::json::format_traits>>>&)
static bool value(T& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<X>(cio::str::delim_be_read<X, II>, i, e, cx)) return false;
                        II const o = i;
                            char32_t const c32 = cio::chr::utf8_to_utf32<X>(i, e, cx);
                                if (c32 == cio::chr::bad_utf32) return cio::rewind(i, o), false;
                                if (c32 >  0xFF)                return cio::rewind(i, o), cx/json::read_error::character_invalid;
                    return cio::consume<X>(cio::str::delim_en_read<X, II>, i, e, cx) && (t = char(c32), true);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdx), %rax
movq (%rsi), %rcx
cmpq %rax, %rcx
je 0x10e412
leaq 0xd9bb2(%rip), %rdx     # 0x1e7fb0
movzbl (%rcx), %esi
testb $0x4, (%rsi,%rdx)
je 0x10e412
incq %rcx
movq %rcx, (%r15)
cmpq %rax, %rcx
jne 0x10e3fe
movq (%r15), %rcx
cmpq %rax, %rcx
je 0x10e44e
cmpb $0x22, (%rcx)
jne 0x10e44e
movq (%r15), %rcx
incq %rcx
movq %rcx, (%r15)
movq (%r12), %rax
cmpq %rcx, %rax
je 0x10e46e
cmpb $0x5c, (%rcx)
jne 0x10e46e
incq (%r15)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x10e8b5
jmp 0x10e481
callq 0x4ae3c
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x10e4f8
cmpl $-0x1, %eax
je 0x10e45d
cmpl $0x100, %eax            # imm = 0x100
jb 0x10e49a
callq 0x4ae3c
movl $0x2, (%rbx)
jmp 0x10e459
movq (%r12), %rcx
movq (%r15), %rdx
cmpq %rcx, %rdx
je 0x10e4c1
leaq 0xd9b03(%rip), %rsi     # 0x1e7fb0
movzbl (%rdx), %edi
testb $0x4, (%rdi,%rsi)
je 0x10e4c1
incq %rdx
movq %rdx, (%r15)
cmpq %rcx, %rdx
jne 0x10e4ad
movq (%r15), %rdx
cmpq %rcx, %rdx
jne 0x10e4cd
xorl %ebp, %ebp
jmp 0x10e4d4
cmpb $0x22, (%rdx)
sete %bpl
testb %bpl, %bpl
je 0x10e4e4
incq (%r15)
movb %al, (%r14)
jmp 0x10e45f
callq 0x4ae3c
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x10e45f
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>, wchar_t, void>::value<cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>>>(wchar_t&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>>&)
static bool value(T& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<X>(cio::str::delim_be_read<X, II>, i, e, cx)) return false;
                        II const o = i;
                            char32_t const c32 = cio::chr::utf8_to_utf32<X>(i, e, cx);
                                if (c32 == cio::chr::bad_utf32) return cio::rewind(i, o), false;
                    return cio::consume<X>(cio::str::delim_en_read<X, II>, i, e, cx) && (t = T(c32), true);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdx), %rax
movq (%rsi), %rcx
cmpq %rax, %rcx
je 0x1ca768
leaq 0x1d85c(%rip), %rdx     # 0x1e7fb0
movzbl (%rcx), %esi
testb $0x4, (%rsi,%rdx)
je 0x1ca768
incq %rcx
movq %rcx, (%r15)
cmpq %rax, %rcx
jne 0x1ca754
movq (%r15), %rcx
cmpq %rax, %rcx
je 0x1ca7a4
cmpb $0x22, (%rcx)
jne 0x1ca7a4
movq (%r15), %rcx
incq %rcx
movq %rcx, (%r15)
movq (%r12), %rax
cmpq %rcx, %rax
je 0x1ca7c4
cmpb $0x5c, (%rcx)
jne 0x1ca7c4
incq (%r15)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1c9e93
jmp 0x1ca7d7
callq 0x4ae3c
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1c9ad6
cmpl $-0x1, %eax
je 0x1ca7b3
movq (%r12), %rcx
movq (%r15), %rdx
cmpq %rcx, %rdx
je 0x1ca803
leaq 0x1d7c1(%rip), %rsi     # 0x1e7fb0
movzbl (%rdx), %edi
testb $0x4, (%rdi,%rsi)
je 0x1ca803
incq %rdx
movq %rdx, (%r15)
cmpq %rcx, %rdx
jne 0x1ca7ef
movq (%r15), %rdx
cmpq %rcx, %rdx
jne 0x1ca80f
xorl %ebp, %ebp
jmp 0x1ca816
cmpb $0x22, (%rdx)
sete %bpl
testb %bpl, %bpl
je 0x1ca823
incq (%r15)
movl %eax, (%r14)
jmp 0x1ca7b5
callq 0x4ae3c
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x1ca7b5
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/json/fundamental.hxx
// Function: bool cxon::read<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>, char16_t, void>::value<cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>>>(char16_t&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, cxon::test::force_input_iterator<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, cxon::context<cxon::JSON<cxon::test::unquoted_keys_traits<cxon::test::input_iterator_traits<cxon::json::format_traits>>>>&)
static bool value(T& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<X>(cio::str::delim_be_read<X, II>, i, e, cx)) return false;
                        II const o = i;
                            char32_t const c32 = cio::chr::utf8_to_utf32<X>(i, e, cx);
                                if (c32 == cio::chr::bad_utf32) return cio::rewind(i, o), false;
                                if (c32 >  0xFFFF)              return cio::rewind(i, o), cx/json::read_error::character_invalid;
                    return cio::consume<X>(cio::str::delim_en_read<X, II>, i, e, cx) && (t = T(c32), true);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdx), %rax
movq (%rsi), %rcx
cmpq %rax, %rcx
je 0x1cae4c
leaq 0x1d178(%rip), %rdx     # 0x1e7fb0
movzbl (%rcx), %esi
testb $0x4, (%rsi,%rdx)
je 0x1cae4c
incq %rcx
movq %rcx, (%r15)
cmpq %rax, %rcx
jne 0x1cae38
movq (%r15), %rcx
cmpq %rax, %rcx
je 0x1cae88
cmpb $0x22, (%rcx)
jne 0x1cae88
movq (%r15), %rcx
incq %rcx
movq %rcx, (%r15)
movq (%r12), %rax
cmpq %rcx, %rax
je 0x1caea8
cmpb $0x5c, (%rcx)
jne 0x1caea8
incq (%r15)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1c9e93
jmp 0x1caebb
callq 0x4ae3c
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1c9ad6
cmpl $-0x1, %eax
je 0x1cae97
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x1caed4
callq 0x4ae3c
movl $0x2, (%rbx)
jmp 0x1cae93
movq (%r12), %rcx
movq (%r15), %rdx
cmpq %rcx, %rdx
je 0x1caefb
leaq 0x1d0c9(%rip), %rsi     # 0x1e7fb0
movzbl (%rdx), %edi
testb $0x4, (%rdi,%rsi)
je 0x1caefb
incq %rdx
movq %rdx, (%r15)
cmpq %rcx, %rdx
jne 0x1caee7
movq (%r15), %rdx
cmpq %rcx, %rdx
jne 0x1caf07
xorl %ebp, %ebp
jmp 0x1caf0e
cmpb $0x22, (%rdx)
sete %bpl
testb %bpl, %bpl
je 0x1caf1f
incq (%r15)
movw %ax, (%r14)
jmp 0x1cae99
callq 0x4ae3c
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x1cae99
nop
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/char.hxx
// Function: std::enable_if<cxon::JSON<cxon::test::produce_strict_javascript_traits>::produce_strict_javascript, bool>::type cxon::cio::chr::imp::encode_<cxon::JSON<cxon::test::produce_strict_javascript_traits>, char32_t>::value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::test::produce_strict_javascript_traits>>, cxon::JSON<cxon::test::produce_strict_javascript_traits>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char32_t, cxon::context<cxon::JSON<cxon::test::produce_strict_javascript_traits>>&)
static auto value(O& o, char32_t c, Cx& cx) -> enable_if_t< S::produce_strict_javascript, bool> {
                        if (c > 0x7F) {
                                if (c == 0x2028) return poke<X>(o, "\\u2028", 6, cx);
                                if (c == 0x2029) return poke<X>(o, "\\u2029", 6, cx);
                                char b[4]; int const n = utf32_to_utf8(b, c);
                                return poke<X>(o, b, n, cx);
                        }
                        else    return encode_<X, char>::value(o, char(c), cx);
                    }

// Assembly:
cmpl $0x80, %esi
jb 0x10f216
pushq %rax
cmpl $0x2029, %esi           # imm = 0x2029
je 0x10f21f
cmpl $0x2028, %esi           # imm = 0x2028
jne 0x10f230
leaq 0xdb85a(%rip), %rsi     # 0x1eaa6e
jmp 0x10f226
movsbl %sil, %esi
jmp 0x10ef84
leaq 0xdb84f(%rip), %rsi     # 0x1eaa75
movl $0x6, %edx
jmp 0x10f2c7
movl %esi, %ecx
andl $0xfffffc00, %ecx       # imm = 0xFFFFFC00
xorl %eax, %eax
cmpl $0xd800, %ecx           # imm = 0xD800
je 0x10f2c0
movl $0x2, %eax
cmpl $0x800, %esi            # imm = 0x800
jb 0x10f26a
movl $0x3, %eax
cmpl $0x10000, %esi          # imm = 0x10000
jb 0x10f26a
xorl %eax, %eax
cmpl $0x110000, %esi         # imm = 0x110000
setb %al
shll $0x2, %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
ja 0x10f2c0
leaq 0xdb2e7(%rip), %rdx     # 0x1ea560
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %esi, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x7(%rsp)
shrl $0x6, %esi
movl %esi, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x6(%rsp)
shrl $0x6, %esi
movl %esi, %ecx
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x5(%rsp)
shrl $0x6, %esi
movl %eax, %ecx
leaq 0xd8e28(%rip), %rdx     # 0x1e80e0
orl (%rdx,%rcx,8), %esi
movb %sil, 0x4(%rsp)
movl %eax, %edx
leaq 0x4(%rsp), %rsi
callq 0xe060
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/common/cio/io.hxx
// Function: cxon::cio::buffered_back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::array<char, 8ul>>::append(char const*, unsigned long)
void append(const T* t, std::size_t n) {
                if (s_ + n > b_.size()) {
                    flush();
                    if (n > b_.size())
                        return poke(c_, t, n), void();
                }
                std::copy_n(t, n, b_.data() + s_), s_ += n;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdi), %rdx
leaq (%rdx,%rbx), %rax
cmpq $0x9, %rax
jb 0x12619b
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0xe060
movq $0x0, 0x10(%r14)
cmpq $0x9, %rbx
jb 0x12619b
movq (%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xe060
testq %rbx, %rbx
je 0x1261b3
movq 0x8(%r14), %rdi
addq 0x10(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe3a0
addq %rbx, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/json/lib/std/valarray.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, std::valarray<int>, void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(std::valarray<int>&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(std::valarray<T>& t, II& i, II e, Cx& cx) { // no, it sucks
                    std::valarray<T> v(4);
                    std::size_t p = 0;
                    bool const r = cio::cnt::read_list<Y>(i, e, cx, [&] {
                        if (p >= v.size()) {
                            std::valarray<T> n(std::move(v));
                            v.resize(p + p);
                                for (std::size_t i = 0; i != p; ++i) v[i] = n[i];
                        }
                        return read_value<Y>(v[p], i, e, cx) && (++p, true);
                    });
                        if (!r) return false;
                    t.resize(p);
                        for (std::size_t j = 0; j != p; ++j) t[j] = v[j];
                    return true;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x68(%rsp), %r12
movq %rdx, (%r12)
leaq 0x30(%rsp), %r13
movq $0x4, (%r13)
movl $0x10, %edi
callq 0xe260
movq %rax, 0x8(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x28(%rsp), %rax
movq $0x0, (%rax)
movq (%r12), %rsi
movq %rax, 0x40(%rsp)
movq %r13, 0x48(%rsp)
movq %r15, 0x50(%rsp)
movq %r12, 0x58(%rsp)
movq %rbx, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x19541f
movl %eax, %ebx
testb %al, %al
je 0x1953f0
movq 0x28(%rsp), %r15
cmpq %r15, (%r14)
je 0x1953b6
movq 0x8(%r14), %rdi
callq 0xe250
movq %r15, (%r14)
leaq (,%r15,4), %rdi
callq 0xe260
movq %rax, 0x8(%r14)
movq 0x8(%r14), %r14
testq %r15, %r15
je 0x1953d0
shlq $0x2, %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xe170
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x1953f0
movq 0x38(%rsp), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
movl %esi, (%r14,%rdx,4)
incq %rdx
cmpq %rdx, %rax
jne 0x1953e1
movq 0x38(%rsp), %rdi
callq 0xe250
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
callq 0xe250
movq %rbx, %rdi
callq 0xe3e0
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/test/../src/cxon/lang/json/lib/std/valarray.hxx
// Function: bool cxon::write<cxon::JSON<cxon::json::format_traits>, std::valarray<int>, void>::value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::valarray<int> const&, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(O& o, const std::valarray<T>& t, Cx& cx) {
#                   ifdef _MSC_VER // std::begin/std::end broken for empty std::valarray
                        return (t.size() && cio::cnt::write_list<Y, std::valarray<T>>(o, std::begin(t), std::end(t), cx)) ||
                               (cio::poke<Y>(o, Y::list::beg, cx) && cio::poke<Y>(o, Y::list::end, cx))
                        ;
#                   else
                        return cio::cnt::write_list<Y, std::valarray<T>>(o, std::begin(t), std::end(t), cx);
#                   endif
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %r15
testq %rax, %rax
leaq (%r15,%rax,4), %r12
cmoveq %rax, %r15
cmoveq %rax, %r12
movl $0x5b, %esi
callq 0xe220
cmpq %r12, %r15
je 0x1956cb
movl (%r15), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4ba88
testb %al, %al
je 0x1956cb
addq $0x4, %r15
cmpq %r12, %r15
je 0x1956cb
movq %rbx, %rdi
movl $0x2c, %esi
callq 0xe220
movl (%r15), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4ba88
addq $0x4, %r15
testb %al, %al
jne 0x1956a3
movl (%r14), %ebp
testl %ebp, %ebp
jne 0x1956df
movq %rbx, %rdi
movl $0x5d, %esi
callq 0xe220
testl %ebp, %ebp
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: getSearchValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int getSearchValue(const string &line) {
    /*
    *	Given a line read from the search query file of the form:
    *	SEARCH <VALUE>
    *	this funtion returns integer(<VALUE>)
    */
    int length = line.length();
    string number = "";
    for (int i=7; i<length; ++i)
        number += line[i];
    return stoi(number);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r15
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x1299(%rip), %rdx      # 0x50f4
leaq -0x50(%rbp), %rdi
movq %rdx, %rsi
callq 0x476c
cmpl $0x8, %r15d
jl 0x3e96
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movl $0x7, %r12d
leaq -0x50(%rbp), %r14
movq (%rbx), %rax
movsbl (%rax,%r12), %esi
movq %r14, %rdi
callq 0x2180
incq %r12
cmpq %r12, %r15
jne 0x3e7e
movq -0x50(%rbp), %r15
callq 0x2050
movq %rax, %rbx
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%rbx)
leaq -0x58(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x2210
cmpq %r15, (%r12)
je 0x3f02
movq %rax, %r14
movslq %r14d, %rax
cmpq %r14, %rax
jne 0x3f0e
movl (%rbx), %eax
cmpl $0x22, %eax
je 0x3f0e
testl %eax, %eax
jne 0x3ee2
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x3ef0
callq 0x21b0
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14de(%rip), %rdi      # 0x53e7
callq 0x2120
leaq 0x14d2(%rip), %rdi      # 0x53e7
callq 0x2230
movq %rax, %r14
cmpl $0x0, (%rbx)
jne 0x3f2c
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
jmp 0x3f2c
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x3f3a
callq 0x21b0
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: updateFilePaths(int, char**)
void updateFilePaths(int argc, char **argv) {
    /* This file updates file paths using command line arguments */
    if (argc != 4) {
        //cout << "ERROR: command line arguments expected\n";
        exit(0);
    }
    input_file_path = argv[1];
    query_file_path = argv[2];
    output_file_path = argv[3];
}

// Assembly:
cmpl $0x4, %edi
jne 0x3f69
movq 0x8(%rsi), %rax
movq %rax, 0x427e(%rip)      # 0x81d0
movq 0x10(%rsi), %rax
movq %rax, 0x427b(%rip)      # 0x81d8
movq 0x18(%rsi), %rax
movq %rax, 0x4278(%rip)      # 0x81e0
retq
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: getLastPageNumber(FileHandler&, bool)
int getLastPageNumber(FileHandler &fh, bool keep_pinned=false) {
    /*
     *	When we call fh.LastPage().getPageNum(), it brings the last page
     *	into memory if not already in memory. By default it is pinned.
     *	Inputs:
     *		fh : file handler from wich to find the page number of last page
     *		keep_pinned : whether to keep the last page pinned or not
     *	Outputs: page number of the last page
     */
    PageHandler last_page_handler = fh.LastPage();
    int page_number = last_page_handler.GetPageNum();
    if (not keep_pinned)	fh.UnpinPage(page_number);
    return page_number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x28(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x37cc
movq %r14, %rdi
callq 0x36c2
movl %eax, %r14d
testl %r15d, %r15d
jne 0x3fb1
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3928
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: getLastPageHandler(FileHandler&, bool)
PageHandler getLastPageHandler(FileHandler &fh, bool keep_pinned=false) {
    /*
     *	When we call fh.LastPage().getPageNum(), it brings the last page
     *	into memory if not already in memory. By default it is pinned.
     *	Inputs:
     *		fh : file handler from wich to find the page number of last page
     *		keep_pinned : whether to keep the last page pinned or not
     *	Outputs: pagehandler of the last page
     */
    PageHandler last_page_handler = fh.LastPage();
    int page_number = last_page_handler.GetPageNum();
    if (not keep_pinned)	fh.UnpinPage(page_number);
    return last_page_handler;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x37cc
movq %rbx, %rdi
callq 0x36c2
testl %r15d, %r15d
jne 0x3fee
movq %r14, %rdi
movl %eax, %esi
callq 0x3928
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: getFirstPageHandler(FileHandler&, bool)
PageHandler getFirstPageHandler(FileHandler &fh, bool keep_pinned=false) {
    /*
     *	When we call fh.LastPage().getPageNum(), it brings the last page
     *	into memory if not already in memory. By default it is pinned.
     *	Inputs:
     *		fh : file handler from wich to find the page number of last page
     *		keep_pinned : whether to keep the last page pinned or not
     *	Outputs: pagehandler of the last page
     */
    PageHandler first_page_handler = fh.FirstPage();
    int page_number = first_page_handler.GetPageNum();
    if (not keep_pinned)	fh.UnpinPage(page_number);
    return first_page_handler;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3722
movq %rbx, %rdi
callq 0x36c2
testl %r15d, %r15d
jne 0x402b
movq %r14, %rdi
movl %eax, %esi
callq 0x3928
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Dwijesh522[P]DBMS_assignment_3/linear_search.cpp
// Function: getPageHandler(FileHandler&, int, bool)
PageHandler getPageHandler(FileHandler &fh, int page_number, bool keep_pinned=false) {
	/*
	 *	When we call fh.FirstPage().getPageNum(), it brings the last page
	 *	into memory if not already in memory. By default it is pinned.
	 *	Inputs:
	 *		fh : file handler from wich to find the page number of last page
	 *		keep_pinned : whether to keep the last page pinned or not
	 *	Outputs: pagehandler of the last page
	 */
	PageHandler page_handler = fh.PageAt(page_number);
	if (not keep_pinned)	fh.UnpinPage(page_number);
	return page_handler;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3870
testl %r12d, %r12d
jne 0x429a
movq %r15, %rdi
movl %r14d, %esi
callq 0x3928
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/main/db_mkbtree.cc
// Function: main
int main(int argc, char **argv){
	if (argc <= 1 + 1){
		printUsage(argv[0]);
		return 1;
	}

	const char *input_file	= argv[1];
	const char *output_file	= argv[2];

	if (CHECK_FILE_EXISTS && fileExists(output_file)){
		printf("File %s exists. Please remove it and try again.\n", output_file);
		return 2;
	}

	using DiskTable = hm3::DiskTable;

	hm3::DiskTable list;
	list.open(input_file);

	using BTreeIndexBuilder = hm3::btreeindex::BTreeIndexBuilder<DiskTable>;

	BTreeIndexBuilder builder;

	bool const result = builder.createFromList(output_file, list);

	return result ? 0 : 100;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x508, %rsp            # imm = 0x508
cmpl $0x2, %edi
jg 0x24fd
movq (%rsi), %rbx
leaq 0x2bd8(%rip), %rdi      # 0x5091
callq 0x2260
leaq 0x2b3f(%rip), %rdi      # 0x5004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2030
leaq 0x2bc2(%rip), %rdi      # 0x5098
callq 0x2260
leaq 0x2be5(%rip), %rdi      # 0x50c7
callq 0x2260
leaq 0x2bed(%rip), %rdi      # 0x50db
callq 0x2260
movl $0x1, %ebx
jmp 0x268a
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rbx
xorl %eax, %eax
movb %al, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movb %al, 0x20(%rsp)
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x38(%rsp)
movq $0x0, 0x48(%rsp)
movups %xmm0, 0x54(%rsp)
movl %eax, 0x64(%rsp)
movl $0x1, 0x6c(%rsp)
movups %xmm0, 0x70(%rsp)
movl %eax, 0x9c(%rsp)
movups %xmm0, 0x84(%rsp)
movl %eax, 0x94(%rsp)
movb $0x1, 0xa0(%rsp)
movups %xmm0, 0xa8(%rsp)
movups %xmm0, 0xb8(%rsp)
movups %xmm0, 0xc8(%rsp)
movups %xmm0, 0xd8(%rsp)
testq %r14, %r14
je 0x258d
movq %r14, %rdi
callq 0x20a0
jmp 0x2594
leaq 0x2ac1(%rip), %r14      # 0x5055
leaq 0xf8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, 0x8(%rsi)
leaq 0x8(%rsp), %rdi
callq 0x352c
leaq 0xf8(%rsp), %rdi
callq 0x22a0
leaq 0x2f8(%rsp), %rdi
callq 0x22a0
movq $0x0, 0x4f8(%rsp)
testq %rbx, %rbx
je 0x25e2
movq %rbx, %rdi
callq 0x20a0
jmp 0x25eb
leaq 0x2a6c(%rip), %rbx      # 0x5055
xorl %eax, %eax
leaq 0xe8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, 0x8(%rsi)
leaq 0xf8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x26d6
xorl %ecx, %ecx
testb %al, %al
movl $0x64, %ebx
cmovnel %ecx, %ebx
movq 0x59a9(%rip), %rax      # 0x7fc8
movq (%rax), %r15
movq 0x18(%rax), %r12
leaq 0x300(%rsp), %rdi
movq %r15, -0x8(%rdi)
movq -0x18(%r15), %rax
movq %r12, 0x2f8(%rsp,%rax)
callq 0x2170
leaq 0x3f0(%rsp), %r14
movq %r14, %rdi
callq 0x2080
movq %r15, -0x2f8(%r14)
movq -0x18(%r15), %rax
movq %r12, 0xf8(%rsp,%rax)
leaq 0x100(%rsp), %rdi
callq 0x2170
leaq 0x1f0(%rsp), %rdi
callq 0x2080
leaq 0x8(%rsp), %rdi
callq 0x29ce
movl %ebx, %eax
addq $0x508, %rsp            # imm = 0x508
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x2964
jmp 0x26c4
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x2240
jmp 0x26c4
jmp 0x26c1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x29ce
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/btreeindex/btreeindexbuilder_impl.h
// Function: hm3::btreeindex::BTreeIndexBuilder<hm3::DiskTable>::injectEmptyNode_(unsigned char, unsigned char)
void BTreeIndexBuilder<LIST>::injectEmptyNode_(level_type const level, level_type const this_level){
	if (this_level == level){
		// add empty node

		Node node;

		// fill gets refference to NIL
		auto const nil = Node::NIL;
		std::fill_n(node.values, VALUES, nil);

		// push the node
		file_indx_.write( (const char *) & node, sizeof node );
	}else if (this_level < level){
		// add children
		for(branch_type i = 0; i < BRANCHES; ++i)
			injectEmptyNode_( level, level_type(this_level + 1) );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, %rbx
cmpb %sil, %dl
jne 0x2c56
movq %rsp, %r14
movl $0x3f8, %edx            # imm = 0x3F8
movq %r14, %rdi
movl $0xff, %esi
callq 0x20e0
movl $0x3f8, %edx            # imm = 0x3F8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
jmp 0x2c7a
jae 0x2c7a
incb %dl
movw $0x80, %r15w
movzbl %sil, %ebp
movzbl %dl, %r14d
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x2c1a
decw %r15w
jne 0x2c67
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/btreeindex/btreeindexbuilder_impl.h
// Function: hm3::btreeindex::BTreeIndexBuilder<hm3::DiskTable>::injectValue_(hm3::DiskTable const&, unsigned long)
void BTreeIndexBuilder<LIST>::injectValue_(const LIST &list, size_type const index){
	// we need to have the pair,
	// because key "live" inside it.
	const auto &p = list.getAt(index);
	const StringRef &key = p.getKey();

	{
		NodeData nd;
		nd.keysize = htobe16(key.size());
		nd.dataid  = htobe64(index);

		// push NodeData
		file_data_.write( (const char *) &nd, sizeof nd );

		// push the key
		file_data_.write( key.data(), (std::streamsize) key.size() );
	}

	current_ += sizeof(uint16_t) + sizeof(uint64_t) + key.size();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2d24
movq %r14, %rdi
callq 0x2e04
movq %rax, %r14
movq %rdx, %r15
rolw $0x8, %ax
leaq 0xe(%rsp), %rsi
movw %ax, (%rsi)
bswapq %r12
movq %r12, 0x2(%rsi)
leaq 0x200(%rbx), %r12
movl $0xa, %edx
movq %r12, %rdi
callq 0x2200
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2200
movq 0x400(%rbx), %rax
addq %r14, %rax
addq $0xa, %rax
movq %rax, 0x400(%rbx)
movq %rsp, %rdi
callq 0x2d50
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2d50
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/olegk0[P]readAVI/player.cpp
// Function: ReadBuf(png_struct_def*, unsigned char*, unsigned long)
void ReadBuf(
    png_structp png_ptr, png_byte* raw_data, png_size_t read_length) {

    read_buf_str_t* read_buf_str = (read_buf_str_t*)png_get_io_ptr(png_ptr);
    const png_byte* src = read_buf_str->buf + read_buf_str->pos;
    memcpy(raw_data, src, read_length);
    read_buf_str->pos += read_length;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0x21f0
movq %rax, %r15
movl 0xc(%rax), %esi
addq (%rax), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x21c0
addl %ebx, 0xc(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::ReadAVI(char const*)
ReadAVI::ReadAVI(const char *filename)
{
    data_buf = NULL;
    stream_format_vid.palette = NULL;
    data_buf_size = 0;
    inFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
    inFile.open(filename, ios_base::ate | ios_base::in | ios_base::binary);
    fileSize = inFile.tellg();
    inFile.close();
    inFile.open(filename, ios_base::in | ios_base::binary);
    try {
	parse_riff();
    } catch (std::system_error& e) { //file corrupted?
	std::cerr << e.code().message() << "\n";
	if (index_entries.size() == 0) {
	    free();
	    throw;
	}
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x514a(%rip), %rax      # 0x7d58
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x2250
xorl %eax, %eax
movq %rax, 0x338(%rbx)
movq %rax, 0x2c8(%rbx)
movl $0x0, 0x340(%rbx)
movq 0x20(%rbx), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl $0x5, 0x3c(%rbx,%rax)
movl 0x40(%rbx,%rax), %esi
callq 0x23c0
movq %r14, %rdi
movq %r15, %rsi
movl $0xe, %edx
callq 0x2170
movq %r14, %rdi
callq 0x23e0
movq %rax, 0x328(%rbx)
movq %r14, %rdi
callq 0x20a0
movq %r14, %rdi
movq %r15, %rsi
movl $0xc, %edx
callq 0x2170
movq %rbx, %rdi
callq 0x2d9e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x2d75
movq %r15, %rdi
callq 0x2110
movq 0x18(%rax), %rsi
movl 0x10(%rax), %edx
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x20(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x5310(%rip), %rdi      # 0x7ff0
callq 0x2260
leaq 0x2ca1(%rip), %rsi      # 0x598d
movl $0x1, %edx
movq %rax, %rdi
callq 0x2260
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d14
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2210
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x2d28
callq 0x23b0
jmp 0x2ca2
movq %rbx, %rdi
callq 0x31d4
callq 0x2370
jmp 0x2d39
jmp 0x2d72
movq %rax, %r15
jmp 0x2d5c
movq %rax, %r15
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d5c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2210
callq 0x23b0
jmp 0x2d75
movq %rax, %rdi
callq 0x2beb
jmp 0x2d72
movq %rax, %r15
jmp 0x2d7d
movq %rax, %r15
movq %r14, %rdi
callq 0x20d0
leaq 0x8(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2d95
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x2210
movq %r15, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O1/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::free()
void ReadAVI::free()
{
    if (inFile.is_open()) {
	inFile.close();
    }

    delete[] stream_format_vid.palette;
    delete[] data_buf;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x98, %rdi
callq 0x20b0
testb %al, %al
je 0x31f1
leaq 0x20(%rbx), %rdi
callq 0x20a0
movq 0x2c8(%rbx), %rdi
testq %rdi, %rdi
je 0x3202
callq 0x22c0
movq 0x338(%rbx), %rdi
testq %rdi, %rdi
je 0x3214
popq %rbx
jmp 0x22c0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::check_data_buf(unsigned int)
void ReadAVI::check_data_buf(unsigned size)
{
    if (data_buf_size < size) {
	delete[] data_buf;
	data_buf = new unsigned char[size + 1];
	data_buf_size = size;
    }
}

// Assembly:
cmpl %esi, 0x340(%rdi)
jae 0x32a9
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x338(%rdi), %rdi
testq %rdi, %rdi
je 0x328c
callq 0x22c0
leal 0x1(%rbx), %edi
callq 0x2040
movq %rax, 0x338(%r14)
movl %ebx, 0x340(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::GetFrameFromIndex(ReadAVI::frame_entry_t*)
int ReadAVI::GetFrameFromIndex(frame_entry_t *frame_entry)
{
    if (frame_entry->pointer >= index_entries.size()){
	MSG_DBG(2, "Pointer out of range\n");
	return -5;
    }
    for (unsigned i = frame_entry->pointer; i < index_entries.size(); i++) {
	if (index_entries[i].type & frame_entry->type) {
	    check_data_buf(index_entries[i].dwChunkLength);
	    try {
		inFile.seekg(index_entries[i].dwChunkOffset, ios_base::beg);
		read_chars_bin(data_buf, index_entries[i].dwChunkLength);
	    } catch (...) {
		return -1;
	    }
	    frame_entry->buf = data_buf;
	    frame_entry->pointer = i + 1;
	    frame_entry->stream_num = index_entries[i].stream_num;
	    frame_entry->type = index_entries[i].type;
	    return index_entries[i].dwChunkLength;
	}
    }
    MSG_DBG(2, "No more frames\n");
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x10(%rsi), %r12d
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
cmpq %r12, %rcx
jbe 0x3303
seta %bpl
jbe 0x32fe
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %edx
leaq (%r12,%r12,4), %rsi
testl %edx, (%rax,%rsi,4)
jne 0x332d
incl %r12d
cmpq %r12, %rcx
seta %bpl
ja 0x32e9
jmp 0x33a2
movq 0x4ca6(%rip), %rax      # 0x7fb0
movq (%rax), %rcx
leaq 0x1e4c(%rip), %rdi      # 0x5160
movl $0x15, %esi
movl $0x1, %edx
callq 0x2410
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x33cc
leaq (,%r12,4), %rcx
leaq (%rcx,%rcx,4), %r13
movl 0x10(%rax,%r13), %esi
movq %r14, %rdi
callq 0x326a
leaq 0x20(%r14), %r15
movq 0x8(%r14), %rax
movslq 0xc(%rax,%r13), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x22f0
movq 0x338(%r14), %rsi
movq 0x8(%r14), %rax
leaq (%r12,%r12,4), %r13
movslq 0x10(%rax,%r13,4), %rdx
movq %r15, %rdi
callq 0x22b0
movq 0x338(%r14), %rax
movq %rax, 0x8(%rbx)
incl %r12d
movl %r12d, 0x10(%rbx)
movq 0x8(%r14), %rax
movl 0x4(%rax,%r13,4), %ecx
movl %ecx, 0x4(%rbx)
movl (%rax,%r13,4), %ecx
movl %ecx, (%rbx)
movl 0x10(%rax,%r13,4), %eax
testb %bpl, %bpl
jne 0x33cc
movq 0x4c02(%rip), %rax      # 0x7fb0
movq (%rax), %rcx
leaq 0x1dbe(%rip), %rdi      # 0x5176
movl $0xf, %esi
movl $0x1, %edx
callq 0x2410
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x2110
callq 0x23b0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x33a2
nop