LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdx), %rcx
movq (%rsi), %rax
cmpq %rcx, %rax
je 0x111729
movzbl (%rax), %esi
leaq 0xd391b(%rip), %rdx     # 0x1e5020
testb $0x4, (%rsi,%rdx)
je 0x111729
incq %rax
movq %rax, %rsi
movq %rsi, %rax
movq %rsi, (%r15)
cmpq %rcx, %rsi
je 0x111729
movzbl (%rax), %edi
leaq 0x1(%rax), %rsi
testb $0x4, (%rdi,%rdx)
jne 0x111711
cmpq %rax, %rcx
je 0x1117e7
cmpb $0x22, (%rax)
jne 0x1117e7
leaq 0x1(%rax), %rdx
movq %rdx, (%r15)
movq (%r12), %rcx
cmpq %rdx, %rcx
je 0x11176a
cmpb $0x5c, (%rdx)
jne 0x11176a
addq $0x2, %rax
movq %rax, (%r15)
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x111bd1
jmp 0x11177b
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x111804
cmpl $-0x1, %eax
je 0x1117f6
cmpl $0x100, %eax            # imm = 0x100
jb 0x111794
callq 0x4a9e4
movl $0x2, (%rbx)
jmp 0x1117f2
movq (%r12), %rdx
movq (%r15), %rcx
cmpq %rdx, %rcx
je 0x1117d0
movzbl (%rcx), %edi
leaq 0xd3876(%rip), %rsi     # 0x1e5020
testb $0x4, (%rdi,%rsi)
je 0x1117d0
incq %rcx
movq %rcx, %rdi
movq %rdi, %rcx
movq %rdi, (%r15)
cmpq %rdx, %rdi
je 0x1117d0
movzbl (%rcx), %r8d
leaq 0x1(%rcx), %rdi
testb $0x4, (%r8,%rsi)
jne 0x1117b6
cmpq %rcx, %rdx
je 0x1117e7
cmpb $0x22, (%rcx)
jne 0x1117e7
incq %rcx
movq %rcx, (%r15)
movb %al, (%r14)
movb $0x1, %al
jmp 0x1117f8
callq 0x4a9e4
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdx), %rcx
movq (%rsi), %rax
cmpq %rcx, %rax
je 0x1c807d
movzbl (%rax), %esi
leaq 0x1cfc7(%rip), %rdx     # 0x1e5020
testb $0x4, (%rsi,%rdx)
je 0x1c807d
incq %rax
movq %rax, %rsi
movq %rsi, %rax
movq %rsi, (%r15)
cmpq %rcx, %rsi
je 0x1c807d
movzbl (%rax), %edi
leaq 0x1(%rax), %rsi
testb $0x4, (%rdi,%rdx)
jne 0x1c8065
cmpq %rax, %rcx
je 0x1c8127
cmpb $0x22, (%rax)
jne 0x1c8127
leaq 0x1(%rax), %rdx
movq %rdx, (%r15)
movq (%r12), %rcx
cmpq %rdx, %rcx
je 0x1c80be
cmpb $0x5c, (%rdx)
jne 0x1c80be
addq $0x2, %rax
movq %rax, (%r15)
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1c77d9
jmp 0x1c80cf
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1c740c
cmpl $-0x1, %eax
je 0x1c8136
movq (%r12), %rdx
movq (%r15), %rcx
cmpq %rdx, %rcx
je 0x1c8110
movzbl (%rcx), %edi
leaq 0x1cf36(%rip), %rsi     # 0x1e5020
testb $0x4, (%rdi,%rsi)
je 0x1c8110
incq %rcx
movq %rcx, %rdi
movq %rdi, %rcx
movq %rdi, (%r15)
cmpq %rdx, %rdi
je 0x1c8110
movzbl (%rcx), %r8d
leaq 0x1(%rcx), %rdi
testb $0x4, (%r8,%rsi)
jne 0x1c80f6
cmpq %rcx, %rdx
je 0x1c8127
cmpb $0x22, (%rcx)
jne 0x1c8127
incq %rcx
movq %rcx, (%r15)
movl %eax, (%r14)
movb $0x1, %al
jmp 0x1c8138
callq 0x4a9e4
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdx), %rcx
movq (%rsi), %rax
cmpq %rcx, %rax
je 0x1c8765
movzbl (%rax), %esi
leaq 0x1c8df(%rip), %rdx     # 0x1e5020
testb $0x4, (%rsi,%rdx)
je 0x1c8765
incq %rax
movq %rax, %rsi
movq %rsi, %rax
movq %rsi, (%r15)
cmpq %rcx, %rsi
je 0x1c8765
movzbl (%rax), %edi
leaq 0x1(%rax), %rsi
testb $0x4, (%rdi,%rdx)
jne 0x1c874d
cmpq %rax, %rcx
je 0x1c8824
cmpb $0x22, (%rax)
jne 0x1c8824
leaq 0x1(%rax), %rdx
movq %rdx, (%r15)
movq (%r12), %rcx
cmpq %rdx, %rcx
je 0x1c87a6
cmpb $0x5c, (%rdx)
jne 0x1c87a6
addq $0x2, %rax
movq %rax, (%r15)
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1c77d9
jmp 0x1c87b7
movq %rsp, %rsi
movq %rcx, (%rsi)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1c740c
cmpl $-0x1, %eax
je 0x1c8833
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x1c87d0
callq 0x4a9e4
movl $0x2, (%rbx)
jmp 0x1c882f
movq (%r12), %rdx
movq (%r15), %rcx
cmpq %rdx, %rcx
je 0x1c880c
movzbl (%rcx), %edi
leaq 0x1c83a(%rip), %rsi     # 0x1e5020
testb $0x4, (%rdi,%rsi)
je 0x1c880c
incq %rcx
movq %rcx, %rdi
movq %rdi, %rcx
movq %rdi, (%r15)
cmpq %rdx, %rdi
je 0x1c880c
movzbl (%rcx), %r8d
leaq 0x1(%rcx), %rdi
testb $0x4, (%r8,%rsi)
jne 0x1c87f2
cmpq %rcx, %rdx
je 0x1c8824
cmpb $0x22, (%rcx)
jne 0x1c8824
incq %rcx
movq %rcx, (%r15)
movw %ax, (%r14)
movb $0x1, %al
jmp 0x1c8835
callq 0x4a9e4
movl $0x1, (%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_O3/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 0x11247a
pushq %rax
cmpl $0x2029, %esi           # imm = 0x2029
je 0x112483
cmpl $0x2028, %esi           # imm = 0x2028
jne 0x112491
leaq 0xd5546(%rip), %rsi     # 0x1e79be
jmp 0x11248a
movsbl %sil, %esi
jmp 0x1121e6
leaq 0xd553b(%rip), %rsi     # 0x1e79c5
movl $0x6, %edx
jmp 0x112505
movl %esi, %eax
andl $0xfffffc00, %eax       # imm = 0xFFFFFC00
cmpl $0xd800, %eax           # imm = 0xD800
jne 0x1124a3
xorl %edx, %edx
jmp 0x112500
movl $0x2, %edx
cmpl $0x800, %esi            # imm = 0x800
jb 0x1124e4
movl $0x3, %edx
cmpl $0x10000, %esi          # imm = 0x10000
jb 0x1124d7
cmpl $0x10ffff, %esi         # imm = 0x10FFFF
ja 0x11249f
movl %esi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x7(%rsp)
shrl $0x6, %esi
movl $0x4, %edx
movl %esi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x6(%rsp)
shrl $0x6, %esi
movl %esi, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x5(%rsp)
shrl $0x6, %esi
leaq 0xd2c58(%rip), %rax     # 0x1e5150
orl (%rax,%rdx,8), %esi
movb %sil, 0x4(%rsp)
leaq 0x4(%rsp), %rsi
callq 0xe060
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x129715
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0xe060
movq $0x0, 0x10(%r14)
cmpq $0x9, %rbx
jb 0x129713
movq (%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xe060
xorl %edx, %edx
testq %rbx, %rbx
je 0x129730
addq 0x8(%r14), %rdx
movq %rdx, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe3a0
movq 0x10(%r14), %rdx
addq %rbx, %rdx
movq %rdx, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x70(%rsp), %r13
movq %rdx, (%r13)
leaq 0x38(%rsp), %rbp
movq $0x4, (%rbp)
movl $0x10, %edi
callq 0xe260
movq %rax, 0x8(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
leaq 0x30(%rsp), %rax
movq $0x0, (%rax)
movq %rax, 0x48(%rsp)
movq %rbp, 0x50(%rsp)
movq %r12, 0x58(%rsp)
movq %r13, 0x60(%rsp)
movq %rbx, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x48(%rsp), %xmm0
movups 0x58(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x194ddf
movl %eax, %ebx
testb %al, %al
je 0x194daf
movq 0x30(%rsp), %r12
movq 0x8(%r14), %r15
cmpq %r12, (%r14)
je 0x194d77
movq %r15, %rdi
callq 0xe250
movq %r12, (%r14)
leaq (,%r12,4), %rdi
callq 0xe260
movq %rax, %r15
movq %rax, 0x8(%r14)
testq %r12, %r12
je 0x194d8d
shlq $0x2, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xe170
movq 0x30(%rsp), %rax
movq 0x40(%rsp), %rdi
testq %rax, %rax
je 0x194db4
xorl %ecx, %ecx
movl (%rdi,%rcx,4), %edx
movl %edx, (%r15,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x194d9e
jmp 0x194db4
movq 0x40(%rsp), %rdi
callq 0xe250
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
callq 0xe250
movq %rbx, %rdi
callq 0xe3e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %r15
testq %rax, %rax
movq %r15, %r13
cmoveq %rax, %r13
movq %rdi, %r14
leaq (%r15,%rax,4), %r12
cmoveq %rax, %r12
movl $0x5b, %esi
callq 0xe220
cmpq %r12, %r13
je 0x195080
movl (%r13), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4b6bc
testb %al, %al
je 0x195080
addq $0x4, %r15
cmpq %r12, %r15
je 0x195080
movq %r14, %rdi
movl $0x2c, %esi
callq 0xe220
movl (%r15), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4b6bc
addq $0x4, %r15
testb %al, %al
jne 0x195058
movl (%rbx), %ebx
testl %ebx, %ebx
jne 0x195093
movq %r14, %rdi
movl $0x5d, %esi
callq 0xe220
testl %ebx, %ebx
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12ed(%rip), %rdx      # 0x50f4
leaq -0x50(%rbp), %rdi
movq %rdx, %rsi
callq 0x4718
cmpl $0x8, %r15d
jl 0x3e42
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 0x3e2a
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 0x3eae
movq %rax, %r14
movslq %r14d, %rax
cmpq %r14, %rax
jne 0x3eba
movl (%rbx), %eax
cmpl $0x22, %eax
je 0x3eba
testl %eax, %eax
jne 0x3e8e
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x3e9c
callq 0x21b0
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1532(%rip), %rdi      # 0x53e7
callq 0x2120
leaq 0x1526(%rip), %rdi      # 0x53e7
callq 0x2230
movq %rax, %r14
cmpl $0x0, (%rbx)
jne 0x3ed8
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
jmp 0x3ed8
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x3ee6
callq 0x21b0
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f15
movq 0x8(%rsi), %rax
movq %rax, 0x42d2(%rip)      # 0x81d0
movq 0x10(%rsi), %rax
movq %rax, 0x42cf(%rip)      # 0x81d8
movq 0x18(%rsi), %rax
movq %rax, 0x42cc(%rip)      # 0x81e0
retq
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3798
movq %r14, %rdi
callq 0x368e
movl %eax, %r14d
testl %r15d, %r15d
jne 0x3f5d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38f4
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3798
movq %rbx, %rdi
callq 0x368e
testl %r15d, %r15d
jne 0x3f9a
movq %r14, %rdi
movl %eax, %esi
callq 0x38f4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x36ee
movq %rbx, %rdi
callq 0x368e
testl %r15d, %r15d
jne 0x3fd7
movq %r14, %rdi
movl %eax, %esi
callq 0x38f4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x383c
testl %r12d, %r12d
jne 0x4246
movq %r15, %rdi
movl %r14d, %esi
callq 0x38f4
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c68
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 0x2c8c
jae 0x2c8c
incb %dl
movw $0x80, %r15w
movzbl %sil, %ebp
movzbl %dl, %r14d
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x2c2c
decw %r15w
jne 0x2c79
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d36
movq %r14, %rdi
callq 0x2e14
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 0x2d60
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2d60
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rsi, %rbx
movl 0x10(%rsi), %ecx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rsi
subq %rax, %rsi
sarq $0x2, %rsi
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rsi, %rdx
cmpq %rcx, %rdx
jbe 0x331f
movq %rdi, %r14
movl (%rbx), %esi
leal 0x1(%rcx), %ebp
leaq (%rcx,%rcx,4), %r12
testl %esi, (%rax,%r12,4)
jne 0x3346
movl %ebp, %ecx
incl %ebp
cmpq %rcx, %rdx
ja 0x32e2
movq 0x4cb4(%rip), %rax      # 0x7fb0
movq (%rax), %rcx
leaq 0x1e70(%rip), %rdi      # 0x5176
movl $0xf, %esi
movl $0x1, %edx
callq 0x2410
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x33a2
movq 0x4c8a(%rip), %rax      # 0x7fb0
movq (%rax), %rcx
leaq 0x1e30(%rip), %rdi      # 0x5160
movl $0x15, %esi
movl $0x1, %edx
callq 0x2410
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x33a2
leaq (%rax,%r12,4), %rax
movl 0x10(%rax), %esi
movq %r14, %rdi
callq 0x326a
leaq 0x20(%r14), %r15
movq 0x8(%r14), %rax
movslq 0xc(%rax,%r12,4), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x22f0
movq 0x338(%r14), %rsi
movq 0x8(%r14), %rax
movslq 0x10(%rax,%r12,4), %rdx
movq %r15, %rdi
callq 0x22b0
movq 0x338(%r14), %rax
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
movq 0x8(%r14), %rax
movq (%rax,%r12,4), %rcx
movq %rcx, (%rbx)
movl 0x10(%rax,%r12,4), %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x2110
callq 0x23b0
jmp 0x3315
nop
// File: /workspace/github_cpp_makefile_star2_O3/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::hex_dump_chunk(int)
int ReadAVI::hex_dump_chunk(int chunk_len)
{
    char chars[17];
    unsigned char c;
    int ch, n;

    chars[16] = 0;

    for (n = 0; n < chunk_len; n++) {
	if ((n % 16) == 0) {
	    if (n != 0)
		MSG_DBG(2, "%s\n", chars);
	    MSG_DBG(2, "      ");
	    memset(chars, ' ', 16);
	}
	read_chars_bin(&c, 1);
	ch = c;
	if (ch == EOF)
	    break;
	MSG_DBG(2, "%02x ", ch);
	if (ch >= ' ' && ch <= 126) {
	    chars[n % 16] = ch;
	} else {
	    chars[n % 16] = '.';
	}
    }

    if ((n % 16) != 0) {
	for (ch = n % 16; ch < 16; ch++) {
	    MSG_DBG(2, "   ");
	}
    }
    MSG_DBG(2, "%s\n", chars);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movb $0x0, 0x20(%rsp)
testl %esi, %esi
jle 0x34b4
movl %esi, %ebx
movq %rdi, %r14
addq $0x20, %r14
movq 0x4bbb(%rip), %r15      # 0x7fb0
xorl %r12d, %r12d
movl %r12d, %ebp
andl $0xf, %ebp
jne 0x3440
testl %r12d, %r12d
je 0x341b
movq (%r15), %rdi
leaq 0x206e(%rip), %rsi      # 0x547d
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x2340
movq (%r15), %rcx
movl $0x6, %esi
movl $0x1, %edx
leaq 0x1d57(%rip), %rdi      # 0x5186
callq 0x2410
movaps 0x1d15(%rip), %xmm0     # 0x5150
movaps %xmm0, 0x10(%rsp)
movl $0x1, %edx
movq %r14, %rdi
leaq 0xf(%rsp), %rsi
callq 0x22b0
movzbl 0xf(%rsp), %r13d
movq (%r15), %rdi
leaq 0x1d2b(%rip), %rsi      # 0x518d
movl %r13d, %edx
xorl %eax, %eax
callq 0x2340
leal -0x20(%r13), %eax
cmpb $0x5f, %al
movl $0x2e, %eax
cmovael %eax, %r13d
movb %r13b, 0x10(%rsp,%rbp)
incl %r12d
cmpl %r12d, %ebx
jne 0x33f8
andl $0xf, %ebx
je 0x34b4
orl $-0x10, %ebx
leaq 0x1cee(%rip), %r14      # 0x5189
movq (%r15), %rcx
movl $0x3, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x2410
incl %ebx
jne 0x349b
movq 0x4af5(%rip), %rax      # 0x7fb0
movq (%rax), %rdi
leaq 0x1fb8(%rip), %rsi      # 0x547d
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x2340
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::decodeCkid(char*, ReadAVI::chunk_type_t*)
int ReadAVI::decodeCkid(char *ckid, chunk_type_t *chunk_type)
{
    int stream = (ckid[0] - '0') * 10 + (ckid[1] - '0');
    for (int i = 0; i < ChunkTypesCnt; i++) {
	if (chunk_types[i].type_id[0] == ckid[2] && chunk_types[i].type_id[1] == ckid[3]) {
	    *chunk_type = chunk_types[i].type;
	    return stream;
	}
    }
    return -1;
}

// Assembly:
movsbl (%rsi), %ecx
movsbl 0x1(%rsi), %eax
movb 0x2(%rsi), %dil
xorl %r9d, %r9d
leaq 0x4d39(%rip), %r8       # 0x8230
xorl %r10d, %r10d
cmpb %dil, (%r8,%r9,8)
jne 0x350b
movb 0x1(%r8,%r9,8), %r11b
cmpb 0x3(%rsi), %r11b
je 0x3522
cmpq $0x3, %r9
leaq 0x1(%r9), %r11
setae %r10b
movq %r11, %r9
cmpq $0x4, %r11
jne 0x34fa
jmp 0x352f
movl 0x4(%r8,%r9,8), %esi
movl %esi, (%rdx)
testb $0x1, %r10b
je 0x3535
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
leal (%rcx,%rcx,4), %ecx
leal (%rax,%rcx,2), %eax
addl $0xfffffdf0, %eax       # imm = 0xFFFFFDF0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::parse_movi(int)
int ReadAVI::parse_movi(int size)
{
    char chunk_id[5];
    long end_of_chunk;
    index_entry_t index_entry;
    int blk_size;

    do {
	long offset = inFile.tellg();
	/*
	 if (fileSize - offset < 8)
	 break;
	 */
	read_chars(chunk_id, 4);
	index_entry.stream_num = decodeCkid(chunk_id, &index_entry.type);

	if (index_entry.stream_num < 0) {
	    inFile.seekg(offset - 4, ios_base::beg);
	    break;
	}

	index_entry.dwChunkLength = read_int();

	if (!(avi_header.Flags & AVIF_HASINDEX)) {
	    index_entry.dwChunkOffset = offset + 8;
	    index_entries.push_back(index_entry);
	}

	MSG_DBG(3, "      AVI Movi Chunk ( id=%s(%d-%d) chunk_size=%d offset=0x%lx)\n", chunk_id, index_entry.type,
		index_entry.stream_num, index_entry.dwChunkLength, offset);
	MSG_DBG(3, "      {\n");

	end_of_chunk = index_entry.dwChunkLength + inFile.tellg();
	end_of_chunk = (end_of_chunk + 1) & ~1;
	/*    if ((end_of_chunk % 4) != 0) {
	 end_of_chunk = end_of_chunk + (4 - (end_of_chunk % 4));
	 }
	 */
//    MSG_DBG(2, "end_of_chunk:%d  %X\n", end_of_chunk, end_of_chunk);
	inFile.seekg(end_of_chunk, ios_base::beg);
	MSG_DBG(3, "      }\n");

	blk_size = end_of_chunk - offset;
	size -= blk_size;
	MSG_DBG(3, "size:%d \n", size);

    } while (size > 7);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
leaq 0x8(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x3(%rsp), %r15
leaq 0x3bf0(%rip), %r12      # 0x8230
movq %rbx, %rdi
callq 0x23e0
movq %rax, %r13
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22b0
movb $0x0, 0x7(%rsp)
movsbl 0x3(%rsp), %ecx
movsbl 0x4(%rsp), %eax
movb 0x5(%rsp), %dl
movb 0x6(%rsp), %sil
xorl %edi, %edi
xorl %r8d, %r8d
cmpb %dl, (%r12,%rdi,8)
jne 0x4685
cmpb %sil, 0x1(%r12,%rdi,8)
je 0x469f
cmpq $0x3, %rdi
leaq 0x1(%rdi), %r9
setae %r8b
movq %r9, %rdi
cmpq $0x4, %r9
jne 0x4678
jmp 0x475c
movl 0x4(%r12,%rdi,8), %edx
movl %edx, 0xc(%rsp)
testb $0x1, %r8b
jne 0x475c
leal (%rcx,%rcx,4), %ecx
leal (%rax,%rcx,2), %eax
addl $0xfffffdf0, %eax       # imm = 0xFFFFFDF0
movl %eax, 0x10(%rsp)
js 0x4764
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x22b0
movl 0x8(%rsp), %eax
movl %eax, 0x1c(%rsp)
testb $0x10, 0x234(%r14)
jne 0x4722
leal 0x8(%r13), %eax
movl %eax, 0x18(%rsp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x4713
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsi)
movups 0xc(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x14, 0x10(%r14)
jmp 0x4722
movq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x4878
movslq 0x1c(%rsp), %r15
movq %rbx, %rdi
callq 0x23e0
addq %rax, %r15
incq %r15
andq $-0x2, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x22f0
subl %r15d, %r13d
addl %r13d, %ebp
cmpl $0x7, %ebp
leaq 0x3(%rsp), %r15
jg 0x4640
jmp 0x4775
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
addq $-0x4, %r13
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x22f0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/olegk0[P]readAVI/ReadAVI.cpp
// Function: ReadAVI::parse_hdrl(unsigned int)
int ReadAVI::parse_hdrl(unsigned int size)
{
    char chunk_id[5];
    int chunk_size;
    int end_of_chunk;
    long offset = inFile.tellg();

    read_chars(chunk_id, 4);
    chunk_size = read_int();

    MSG_DBG(2, "      AVI Header Chunk (id=%s size=%d offset=0x%lx)\n", chunk_id, chunk_size, offset);
    MSG_DBG(2, "      {\n");

    end_of_chunk = chunk_size + inFile.tellg();
    if ((end_of_chunk % 4) != 0) {
	end_of_chunk = end_of_chunk + (4 - (end_of_chunk % 4));
    }

    read_avi_header();
    MSG_DBG(2, "      }\n");

    while (inFile.tellg() < offset + size - 4) {
	//MSG_DBG(2, "Should end at 0x%lx  0x%lx\n",offset+size,inFile.tellg());
	parse_hdrl_list();
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x23e0
movq %rax, %r15
leaq 0x13(%rsp), %r12
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x22b0
movb $0x0, 0x4(%r12)
leaq 0xc(%rsp), %r13
movl $0x4, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x22b0
movl (%r13), %ecx
movq 0x37cd(%rip), %r13      # 0x7fb0
movq (%r13), %rdi
leaq 0x10a0(%rip), %rsi      # 0x588e
movq %r12, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x2340
movq (%r13), %rcx
leaq 0x101e(%rip), %rdi      # 0x5824
movl $0x8, %esi
movl $0x1, %edx
callq 0x2410
movq %r14, %rdi
callq 0x23e0
movq %rbx, %rdi
callq 0x378c
movq (%r13), %rcx
leaq 0x1055(%rip), %rdi      # 0x5885
movl $0x8, %esi
movl $0x1, %edx
callq 0x2410
movq %r14, %rdi
callq 0x23e0
movl %ebp, %ecx
addq %rcx, %r15
addq $-0x4, %r15
cmpq %r15, %rax
jge 0x4867
movq %rbx, %rdi
callq 0x42a4
movq %r14, %rdi
callq 0x23e0
jmp 0x4850
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/reactor_client_test.cc
// Function: main
int main(int argc, char **argv)
{
    if (argc < 3) {
        fprintf(stderr, "usage: %s ip port\n", argv[0]);
        return EXIT_FAILURE;
    }

    TimeClient client;
    if (!client.ConnectServer(argv[1], atoi(argv[2]))) {
        fprintf(stderr, "connect remote server failed\n");
        return EXIT_FAILURE;
    }

    g_reactor.RegisterHandler(&client, reactor::kWriteEvent);
    while (1) {
        g_reactor.HandleEvents();
        sleep(1);
    }
    g_reactor.RemoveHandler(&client);
    return EXIT_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x2, %edi
jg 0x24fd
movq %rbx, %rdi
callq 0x22eb
jmp 0x255b
movq %rsp, %r14
movq %r14, %rdi
callq 0x25f8
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %rdi
callq 0x2240
movzwl %ax, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2640
testb %al, %al
jne 0x256a
movq 0x4aaa(%rip), %rax      # 0x6fd8
movq (%rax), %rcx
leaq 0x1aed(%rip), %rdi      # 0x4025
movl $0x1d, %esi
movl $0x1, %edx
callq 0x2280
leaq 0x47b2(%rip), %rax      # 0x6d00
movq %rax, (%rsp)
movl 0x8(%rsp), %edi
callq 0x2290
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x269c
movq (%rax), %rdi
movq %rsp, %rsi
movl $0x2, %edx
callq 0x305e
leaq 0x541a(%rip), %rbx      # 0x79a0
movq (%rbx), %r14
testq %r14, %r14
jne 0x25a6
movl $0x8, %edi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
callq 0x352c
movq %r14, (%rbx)
movq (%r14), %rdi
callq 0x3150
movl $0x1, %edi
callq 0x2130
jmp 0x2586
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x21a0
jmp 0x25d3
jmp 0x25ef
jmp 0x25d0
movq %rax, %rbx
leaq 0x4726(%rip), %rax      # 0x6d00
movq %rax, (%rsp)
movl 0x8(%rsp), %edi
callq 0x2290
movq %rbx, %rdi
callq 0x2260
movq %rax, %rdi
callq 0x2898
nop
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/./eventhandler/timeclient.hpp
// Function: TimeClient::HandleRead()
virtual void HandleRead()
    {
        memset(g_read_buffer, 0, BUFFERSIZE);
        int len = recv(m_handle, g_read_buffer, BUFFERSIZE, 0);
        if (len > 0) {
            fprintf(stderr, "%s", g_read_buffer);
            g_reactor.RegisterHandler(this, reactor::kWriteEvent);
        } else {
            ReportSocketError("recv");
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4a5d(%rip), %r14      # 0x7190
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x20f0
movl 0x8(%rbx), %edi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x2080
testl %eax, %eax
jle 0x27aa
movq 0x4879(%rip), %rax      # 0x6fd8
movq (%rax), %rsi
leaq 0x4a27(%rip), %rdi      # 0x7190
callq 0x21c0
leaq 0x522b(%rip), %r15      # 0x79a0
movq (%r15), %r14
testq %r14, %r14
jne 0x2795
movl $0x8, %edi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
callq 0x352c
movq %r14, (%r15)
movq (%r14), %rdi
movq %rbx, %rsi
movl $0x2, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x305e
leaq 0x18e1(%rip), %rdi      # 0x4092
popq %rbx
popq %r14
popq %r15
jmp 0x22b0
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/xuchanglong[P]SimpleReactorImplemention-comments/./eventhandler/timeclient.hpp
// Function: TimeClient::HandleWrite()
virtual void HandleWrite()
    {
        memset(g_write_buffer, 0, BUFFERSIZE);
        int len = sprintf(g_write_buffer, "time\r\n");
        len = send(m_handle, g_write_buffer, len, 0);
        if (len > 0) {
            fprintf(stderr, "%s", g_write_buffer);
            g_reactor.RegisterHandler(this, reactor::kReadEvent);
        } else {
            ReportSocketError("send");
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4db4(%rip), %rdi      # 0x7597
movl $0x3f9, %edx            # imm = 0x3F9
xorl %esi, %esi
callq 0x20f0
leaq 0x4d9a(%rip), %rsi      # 0x7590
movl $0x656d6974, 0x4d90(%rip) # imm = 0x656D6974
movl $0xa0d65, 0x4d89(%rip)  # imm = 0xA0D65
movl 0x8(%rbx), %edi
movl $0x6, %edx
xorl %ecx, %ecx
callq 0x20d0
testl %eax, %eax
jle 0x286f
movq 0x47b4(%rip), %rax      # 0x6fd8
movq (%rax), %rsi
leaq 0x4d62(%rip), %rdi      # 0x7590
callq 0x21c0
leaq 0x5166(%rip), %r15      # 0x79a0
movq (%r15), %r14
testq %r14, %r14
jne 0x285a
movl $0x8, %edi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
callq 0x352c
movq %r14, (%r15)
movq (%r14), %rdi
movq %rbx, %rsi
movl $0x1, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x305e
leaq 0x1828(%rip), %rdi      # 0x409e
popq %rbx
popq %r14
popq %r15
jmp 0x22b0
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/test/test_binarysearch.cc
// Function: void test<char>(char const*, char)
void test(const char *name, const T key){
	VVector<T, MAX> v;

	size_t result;

	bool const found = binarySearch(v, v.size(), key, BinarySearchCompStdandard{}, result);

	bool const ok = found && v[result] == key;

	printf("%10s %s\n", name, ok ? "OK" : "Error");
}

// Assembly:
movq %rdi, %rax
movzbl %sil, %ecx
movl $0x2710, %edi           # imm = 0x2710
xorl %r8d, %r8d
movq %rdi, %rdx
subq %r8, %rdx
shrq %rdx
addq %r8, %rdx
cmpb %sil, %dl
jge 0x12d3
incq %rdx
movq %rdx, %r8
jmp 0x12d8
movq %rdx, %rdi
jle 0x130a
leaq 0x5(%r8), %rdx
cmpq %rdi, %rdx
jb 0x12ba
leaq 0xd49(%rip), %rdx       # 0x2031
cmpq %rdi, %r8
jae 0x131f
decq %rdi
cmpb %r8b, %cl
je 0x1308
cmpb %sil, %r8b
jg 0x131f
leaq 0x1(%r8), %r9
cmpq %r8, %rdi
movq %r9, %r8
jne 0x12f0
jmp 0x131f
movl %ecx, %edx
cmpb %sil, %dl
leaq 0xd1a(%rip), %rcx       # 0x202e
leaq 0xd16(%rip), %rdx       # 0x2031
cmoveq %rcx, %rdx
leaq 0xcff(%rip), %rdi       # 0x2025
movq %rax, %rsi
xorl %eax, %eax
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/allocSP.cc
// Function: use_factory(int)
shared_ptr<Foo> use_factory(T arg)
{
	shared_ptr<Foo> p = factory(arg);
	print(cout, *p);
	cout << endl;
	// use p
	return p;  // reference count is incremented when we return p
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r12d
movq %rdi, %rbx
movl $0x18, %edi
callq 0x1080
movq %rax, %r14
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x2a93(%rip), %rax      # 0x3d40
movq %rax, (%r14)
leaq 0x10(%r14), %rax
movl %r12d, 0x10(%r14)
movq %r14, 0x8(%rbx)
movq %rax, (%rbx)
movq 0x2d0a(%rip), %r15      # 0x3fd0
movq %r15, %rdi
movl %r12d, %esi
callq 0x10c0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq 0x2ce1(%rip), %rdi      # 0x3fd0
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x1394
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O3/liskin[P]hybrid-screenclone/screenclone.cc
// Function: usage(char const*)
void usage( const char *name )
{
	std::cerr
		<< "Usage: " << name << " <options>" << std::endl
		<< "Options:" << std::endl
		<< " -s <display name> (default :0)" << std::endl
		<< " -d <display name> (default :1)" << std::endl
		<< " -x <xinerama screen number> (default 0)" << std::endl;
	exit( 0 );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x52cc(%rip), %rdi      # 0x8fe8
leaq 0x234a(%rip), %rsi      # 0x606d
callq 0x2200
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2200
leaq 0x233b(%rip), %rsi      # 0x6075
movq %rax, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x20b0
leaq 0x232f(%rip), %rsi      # 0x6080
movq %rax, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x20b0
leaq 0x2321(%rip), %rsi      # 0x6089
movq %rax, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x20b0
leaq 0x232a(%rip), %rsi      # 0x60a9
movq %rax, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x20b0
leaq 0x2333(%rip), %rsi      # 0x60c9
movq %rax, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x20b0
xorl %edi, %edi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/liskin[P]hybrid-screenclone/screenclone.cc
// Function: mouse_replayer::cursor_changed()
void cursor_changed() {
		std::lock_guard< std::recursive_mutex > guard( cursor_mutex );

		if ( !on )
			return;

		XFixesCursorImage *cur;
		XcursorImage image;
		Cursor cursor;

		cur = TC( XFixesGetCursorImage( src.dpy ) );
		if ( !cur )
			return;

		memset( &image, 0, sizeof( image ) );
		image.width  = cur->width;
		image.height = cur->height;
		image.size	 = std::max( image.width, image.height );
		image.xhot	 = cur->xhot;
		image.yhot	 = cur->yhot;

		if ( 0 && sizeof( * image.pixels ) == sizeof( * cur->pixels ) ) {
			// 32-bit machines where int is long
			image.pixels = (unsigned int *) cur->pixels;
		} else {
			image.pixels = (unsigned int *) alloca(
				image.width * image.height * sizeof( unsigned int ) );
			for ( unsigned i = 0; i < image.width * image.height; ++i )
				image.pixels[ i ] = cur->pixels[ i ];
		}

		cursor = TC( XcursorImageLoadCursor( dst.dpy, &image ) );
		XFree( cur );

		TC( XDefineCursor( dst.dpy, dst_window.win, cursor ) );
		XFreeCursor( dst.dpy, cursor );

		TC( XFlush( dst.dpy ) );

		DBG( std::cout << "cursor changed" << std::endl );
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x70(%rdi), %rbx
movq %rbx, %rdi
callq 0x2300
testl %eax, %eax
jne 0x5480
movb 0x68(%r14), %al
cmpb $0x1, %al
jne 0x546b
movq (%r14), %rdi
callq 0x2250
movq %rax, %r15
testq %rax, %rax
je 0x546b
pxor %xmm0, %xmm0
movdqa %xmm0, -0x40(%rbp)
movdqa %xmm0, -0x50(%rbp)
movzwl 0x4(%r15), %ecx
movl %ecx, -0x48(%rbp)
movzwl 0x6(%r15), %eax
cmpw %ax, %cx
movl %eax, %edx
cmoval %ecx, %edx
movl %eax, -0x44(%rbp)
movl %edx, -0x4c(%rbp)
movq 0x8(%r15), %xmm1
punpcklwd %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3]
movq %xmm1, -0x40(%rbp)
imull %ecx, %eax
leaq 0xf(,%rax,4), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, %rsp
movq %rcx, -0x30(%rbp)
testl %eax, %eax
je 0x542e
movq 0x18(%r15), %rdx
xorl %esi, %esi
movl (%rdx,%rsi,8), %edi
movl %edi, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x5420
movq 0x18(%r14), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2050
movq %rax, %r12
movq %r15, %rdi
callq 0x22c0
movq 0x18(%r14), %rdi
movq 0x50(%r14), %rsi
movq %r12, %rdx
callq 0x23c0
movq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0x2260
movq 0x18(%r14), %rdi
callq 0x2340
movq %rbx, %rdi
callq 0x2140
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x2100
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x23e0