LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/assert.hpp
// Function: void cpp::assertion::detail::assertion_failed_msg<char>(char const*, char const*, char const*, char const*, unsigned long)
void assertion_failed_msg(const CharT* expr, const char* msg, const char* function, const char* file, size_t line) {
    std::cerr
        << "***** Internal Program Error - assertion (" << expr << ") failed in "
        << function << ":\n"
        << file << '(' << line << "): " << msg << std::endl;
    std::abort();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq 0x101765(%rip), %rdi    # 0x12bfe8
leaq 0xb6115(%rip), %rsi     # 0xe099f
callq 0xa4e0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0xa4e0
movq %rax, %rdi
leaq 0xb6124(%rip), %rsi     # 0xe09ca
callq 0xa4e0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0xa4e0
movq %rax, %rdi
leaq 0xbd151(%rip), %rsi     # 0xe7a13
callq 0xa4e0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0xa4e0
movq %rax, %rdi
movl $0x28, %esi
callq 0xa5d0
movq %rax, %rdi
movq (%rsp), %rsi
callq 0xa110
movq %rax, %rdi
leaq 0xb60e0(%rip), %rsi     # 0xe09d7
callq 0xa4e0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0xa4e0
movq %rax, %rdi
movq 0x10161d(%rip), %rsi    # 0x12bf30
callq 0xa530
callq 0x29ff0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/data.hpp
// Function: double cpp::stddev<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, double)
double stddev(Iterator first, Iterator last, double mean) {
    double std = 0.0;
    for (auto it = first; it != last; ++it) {
        std += (*it - mean) * (*it - mean);
    }
    return std::sqrt(std / std::distance(first, last));
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
vmovsd %xmm0, 0x30(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovsd %xmm0, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1edd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x3135f
jmp 0x313b0
leaq 0x20(%rsp), %rdi
callq 0x1ee50
vcvtsi2sdl (%rax), %xmm0, %xmm0
vsubsd 0x30(%rsp), %xmm0, %xmm0
vmovsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1ee50
vmovsd 0x8(%rsp), %xmm1
vcvtsi2sdl (%rax), %xmm0, %xmm0
vsubsd 0x30(%rsp), %xmm0, %xmm0
vmovsd 0x28(%rsp), %xmm2
vfmadd213sd %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
vmovsd %xmm0, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1f180
jmp 0x31348
vmovsd 0x28(%rsp), %xmm0
vmovsd %xmm0, (%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x30000
vmovsd (%rsp), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
callq 0xa3d0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/data.hpp
// Function: void cpp::normalize<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>&)
void normalize(Container& container) {
    //normalize to zero-mean
    auto m = cpp::mean(container);
    for (auto& v : container) {
        v -= m;
    }

    //normalize to unit variance
    if (auto s = cpp::stddev(container, 0.0); s != 0.0) {
        for (auto& v : container) {
            v /= s;
        }
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x30160
vmovsd %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x303a0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x303d0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x31140
xorb $-0x1, %al
testb $0x1, %al
jne 0x31748
jmp 0x3177a
leaq 0x38(%rsp), %rdi
callq 0x31180
movq %rax, 0x28(%rsp)
vmovsd 0x48(%rsp), %xmm1
movq 0x28(%rsp), %rax
vmovsd (%rax), %xmm0
vsubsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, (%rax)
leaq 0x38(%rsp), %rdi
callq 0x31190
jmp 0x31731
movq 0x50(%rsp), %rdi
vpxor %xmm0, %xmm0, %xmm0
callq 0x314e0
vmovsd %xmm0, 0x20(%rsp)
vmovsd 0x20(%rsp), %xmm0
vpxor %xmm1, %xmm1, %xmm1
vucomisd %xmm1, %xmm0
jne 0x317a2
jp 0x317a2
jmp 0x31813
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x303a0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x303d0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x31140
xorb $-0x1, %al
testb $0x1, %al
jne 0x317e1
jmp 0x31811
leaq 0x10(%rsp), %rdi
callq 0x31180
movq %rax, (%rsp)
vmovsd 0x20(%rsp), %xmm1
movq (%rsp), %rax
vmovsd (%rax), %xmm0
vdivsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x31190
jmp 0x317ca
jmp 0x31813
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: wichtounet[P]cpp_utils_test/doctest/doctest/doctest.h
// Function: doctest::detail::Expression_lhs<bool&>::operator doctest::detail::Result()
DOCTEST_NOINLINE operator Result() {
// this is needed only for MSVC 2015
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4800) // 'int': forcing value to bool
            bool res = static_cast<bool>(lhs);
DOCTEST_MSVC_SUPPRESS_WARNING_POP
            if(m_at & assertType::is_false) { //!OCLINT bitwise operator in conditional
                res = !res;
            }

            if(!res || getContextOptions()->success) {
                return { res, (DOCTEST_STRINGIFY(lhs)) };
            }
            return { res };
        }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movq (%rax), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, 0x87(%rsp)
movl 0x8(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x3830f
movb 0x87(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x87(%rsp)
testb $0x1, 0x87(%rsp)
je 0x38324
callq 0x9a3e0
testb $0x1, 0x6c(%rax)
je 0x3838b
movq 0x38(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %esi
movzbl 0x87(%rsp), %eax
movl %eax, 0x1c(%rsp)
andl $0x1, %esi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x9a5d0
movl 0x1c(%rsp), %esi
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
andl $0x1, %esi
callq 0x9bcb0
jmp 0x38365
leaq 0x68(%rsp), %rdi
callq 0x98c40
jmp 0x383e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x98c40
jmp 0x383f1
movzbl 0x87(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x98c20
movl 0xc(%rsp), %esi
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
andl $0x1, %esi
callq 0x9bcb0
jmp 0x383be
leaq 0x40(%rsp), %rdi
callq 0x98c40
jmp 0x383e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x98c40
jmp 0x383f1
movq 0x30(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0xa890
nopl (%rax,%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/thread_pool.hpp
// Function: void cpp::default_thread_pool<std::deque>::do_task<DOCTEST_ANON_FUNC_2()::$_0, int>(DOCTEST_ANON_FUNC_2()::$_0, int)::'lambda'()::operator()()
void do_task(Functor fun, Args... args) {
        with_lock(main_lock, [fun, args..., this] () mutable {
            if (stop_flag) {
#ifndef CPP_UTILS_NO_EXCEPT
                throw std::runtime_error("cpp_utils: enqueue on stopped ThreadPool");
#else
                std::cerr << "cpp_utils: enqueue on stopped ThreadPool (exceptions disabled)" << std::endl;
                std::abort();
#endif
            }

            //Execute the task
            tasks.emplace_back([fun, args...] () mutable {
                fun(args...);
            });
        });

        condition.notify_one();
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movb 0x108(%rax), %al
testb $0x1, %al
je 0x43e2b
movl $0x10, %edi
callq 0xa240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x9e1c8(%rip), %rsi     # 0xe1fba
callq 0xa1d0
jmp 0x43df9
movq 0x8(%rsp), %rdi
movq 0xe81eb(%rip), %rsi     # 0x12bff0
movq 0xe8164(%rip), %rdx     # 0x12bf70
callq 0xa820
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xa360
jmp 0x43e57
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x43e70
addq $0x48, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xa890
nopw %cs:(%rax,%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/parallel.hpp
// Function: void cpp::parallel_foreach_n<cpp::thread_pool<true>, DOCTEST_ANON_FUNC_16()::$_0>(cpp::thread_pool<true>&, unsigned long, unsigned long, DOCTEST_ANON_FUNC_16()::$_0)
void parallel_foreach_n(TP& thread_pool, std::size_t first, std::size_t last, Functor fun) {
    const auto n    = last - first;
    const auto part = n / thread_pool.size();

    if (part < 2) {
        for (std::size_t i = first; i < last; ++i) {
            thread_pool.do_task(fun, i);
        }
    } else {
        auto batch_functor = [fun](std::size_t first, std::size_t last) {
            for (std::size_t i = first; i < last; ++i) {
                fun(i);
            }
        };

        // Distribute evenly the batches

        for (std::size_t t = 0; t < thread_pool.size(); ++t) {
            thread_pool.do_task(batch_functor, t * part, (t + 1) * part);
        }

        // Compute the remainders
        if (auto rem = n % thread_pool.size(); rem > 0) {
            for (std::size_t i = last - rem; i < last; ++i) {
                fun(i);
            }
        }
    }

    thread_pool.wait();
}

// Assembly:
subq $0x88, %rsp
movq %rcx, 0x80(%rsp)
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x68(%rsp), %rax
subq 0x70(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rdi
callq 0x50e20
movq %rax, %rcx
movq 0x18(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0x58(%rsp)
cmpq $0x2, 0x58(%rsp)
jae 0x4b307
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x68(%rsp), %rax
jae 0x4b302
movq 0x78(%rsp), %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rsi
callq 0x4b410
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x4b2c5
jmp 0x4b3f0
movq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdi
callq 0x50e20
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x4b381
movq 0x78(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdx
imulq 0x58(%rsp), %rdx
movq 0x38(%rsp), %rcx
addq $0x1, %rcx
imulq 0x58(%rsp), %rcx
movq 0x30(%rsp), %rsi
callq 0x4b490
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x4b31d
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rdi
callq 0x50e20
movq %rax, %rcx
movq 0x8(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jbe 0x4b3ee
movq 0x68(%rsp), %rax
subq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x68(%rsp), %rax
jae 0x4b3ec
movq 0x20(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x4b530
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x4b3be
jmp 0x4b3ee
jmp 0x4b3f0
movq 0x78(%rsp), %rdi
callq 0x50f40
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/thread_pool.hpp
// Function: cpp::default_thread_pool<std::deque>::wait()
void wait() {
        while (true) {
            std::unique_lock<std::mutex> ulock(main_lock);

            if (tasks.empty() && std::find(status.begin(), status.end(), thread_status::WORKING) == status.end()) {
                return;
            }

            //At this point, there are still some threads working, we wait for
            //one of them to notify a change of status
            wait_condition.wait(ulock, [this] {
                return tasks.empty();
            });
        }
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
addq $0x80, %rsi
leaq 0x70(%rsp), %rdi
callq 0x4dcd0
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
callq 0x4ff80
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x50f8f
jmp 0x51009
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x8(%rsp)
callq 0x51920
movq 0x8(%rsp), %rdi
movq %rax, 0x60(%rsp)
callq 0x51950
movq %rax, 0x58(%rsp)
movl $0x1, 0x54(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
leaq 0x54(%rsp), %rdx
callq 0x518c0
movq %rax, 0x10(%rsp)
jmp 0x50fd9
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x68(%rsp)
addq $0x18, %rdi
callq 0x51950
movq %rax, 0x38(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x51880
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x51013
jmp 0x51037
movl $0x1, 0x34(%rsp)
jmp 0x51064
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4dd90
jmp 0x51087
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0xd8, %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdx
leaq 0x70(%rsp), %rsi
callq 0x51980
jmp 0x5105c
movl $0x0, 0x34(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4dd90
movl 0x34(%rsp), %eax
testl %eax, %eax
je 0x5107a
jmp 0x51078
jmp 0x5107f
jmp 0x50f5c
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xa890
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/thread_pool.hpp
// Function: cpp::default_thread_pool<std::deque>::~default_thread_pool()
~default_thread_pool() {
        with_lock(main_lock, [this] { stop_flag = true; });

        condition.notify_all();

        for (auto& thread : threads) {
            thread.join();
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %rdi
subq $-0x80, %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0x51eb0
jmp 0x51dda
movq (%rsp), %rdi
addq $0xa8, %rdi
callq 0xa810
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x50870
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4f910
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x51f10
xorb $-0x1, %al
testb $0x1, %al
jne 0x51e28
jmp 0x51e51
leaq 0x18(%rsp), %rdi
callq 0x509d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xa9b0
jmp 0x51e43
jmp 0x51e45
leaq 0x18(%rsp), %rdi
callq 0x51f50
jmp 0x51e11
movq (%rsp), %rdi
addq $0xd8, %rdi
callq 0xa8d0
movq (%rsp), %rdi
addq $0xa8, %rdi
callq 0xa8d0
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x4ddd0
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x4de40
movq (%rsp), %rdi
callq 0x4dea0
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x1e4c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/parallel.hpp
// Function: void cpp::parallel_foreach_n<DOCTEST_ANON_FUNC_2()::$_0>(unsigned long, unsigned long, DOCTEST_ANON_FUNC_2()::$_0)
void parallel_foreach_n(std::size_t first, std::size_t last, Functor fun) {
    std::vector<std::future<void>> futures;
    futures.reserve(last - first);

    for (std::size_t i = first; i != last; ++i) {
        futures.push_back(std::move(std::async(std::launch::async, fun, i)));
    }

    //No need to wait for the futures, the destructor will do it for us
}

// Assembly:
subq $0x68, %rsp
movq %rdx, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x877f0
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rax
subq %rax, %rsi
callq 0x87800
jmp 0x64ecb
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x64f51
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x60(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x64f80
jmp 0x64efc
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x87910
jmp 0x64f0d
leaq 0x10(%rsp), %rdi
callq 0x87940
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x64ed5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x64f60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x87940
jmp 0x64f60
leaq 0x38(%rsp), %rdi
callq 0x87950
addq $0x68, %rsp
retq
leaq 0x38(%rsp), %rdi
callq 0x87950
movq 0x30(%rsp), %rdi
callq 0xa890
nopw %cs:(%rax,%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/parallel.hpp
// Function: void cpp::parallel_foreach<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, DOCTEST_ANON_FUNC_6()::$_0>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, DOCTEST_ANON_FUNC_6()::$_0)
void parallel_foreach(Iterator first, Iterator last, Functor fun) {
    std::vector<std::future<void>> futures;
    futures.reserve(std::distance(first, last));

    for (; first != last; ++first) {
        futures.push_back(std::move(std::async(std::launch::async, fun, *first)));
    }

    //No need to wait for the futures, the destructor will do it for us
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x877f0
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x30000
movq %rax, (%rsp)
jmp 0x6a146
movq (%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x87800
jmp 0x6a156
jmp 0x6a158
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1edd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x6a16f
jmp 0x6a1e3
leaq 0x60(%rsp), %rdi
callq 0x1ee50
movq %rax, %rcx
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x50(%rsp), %rdx
callq 0x6a210
jmp 0x6a192
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x87910
jmp 0x6a1a3
leaq 0x8(%rsp), %rdi
callq 0x87940
leaq 0x60(%rsp), %rdi
callq 0x1f180
jmp 0x6a158
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x6a1f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x87940
jmp 0x6a1f2
leaq 0x38(%rsp), %rdi
callq 0x87950
addq $0x68, %rsp
retq
leaq 0x38(%rsp), %rdi
callq 0x87950
movq 0x20(%rsp), %rdi
callq 0xa890
nopw %cs:(%rax,%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/parallel.hpp
// Function: void cpp::parallel_foreach<std::vector<int, std::allocator<int>>, DOCTEST_ANON_FUNC_8()::$_0>(std::vector<int, std::allocator<int>>&, DOCTEST_ANON_FUNC_8()::$_0)
void parallel_foreach(Container& container, Functor fun) {
    std::vector<std::future<void>> futures;
    futures.reserve(container.size());

    for (std::size_t i = 0; i < container.size(); ++i) {
        futures.push_back(std::move(std::async(std::launch::async, fun, container[i])));
    }

    //No need to wait for the futures, the destructor will do it for us
}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x877f0
movq 0x58(%rsp), %rdi
callq 0x8b350
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x87800
jmp 0x6ca66
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x8b350
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x6cb0d
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1f160
movq %rax, %rcx
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x60(%rsp), %rdx
callq 0x6cb30
jmp 0x6cab8
leaq 0x40(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x87910
jmp 0x6cac9
leaq 0x18(%rsp), %rdi
callq 0x87940
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x6ca6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x6cb1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x87940
jmp 0x6cb1c
leaq 0x40(%rsp), %rdi
callq 0x87950
addq $0x68, %rsp
retq
leaq 0x40(%rsp), %rdi
callq 0x87950
movq 0x38(%rsp), %rdi
callq 0xa890
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/parallel.hpp
// Function: void cpp::parallel_foreach_i<std::vector<int, std::allocator<int>>, DOCTEST_ANON_FUNC_14()::$_0>(std::vector<int, std::allocator<int>>&, DOCTEST_ANON_FUNC_14()::$_0)
void parallel_foreach_i(Container& container, Functor fun) {
    std::vector<std::future<void>> futures;
    futures.reserve(container.size());

    for (std::size_t i = 0; i < container.size(); ++i) {
        futures.push_back(std::move(std::async(std::launch::async, fun, container[i], i)));
    }

    //No need to wait for the futures, the destructor will do it for us
}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x877f0
movq 0x58(%rsp), %rdi
callq 0x8b350
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x87800
jmp 0x74726
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x8b350
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x747d6
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1f160
movq %rax, %rcx
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x60(%rsp), %rdx
leaq 0x28(%rsp), %r8
callq 0x74800
jmp 0x74781
leaq 0x40(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x87910
jmp 0x74792
leaq 0x18(%rsp), %rdi
callq 0x87940
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x7472f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x747e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x87940
jmp 0x747e5
leaq 0x40(%rsp), %rdi
callq 0x87950
addq $0x68, %rsp
retq
leaq 0x40(%rsp), %rdi
callq 0x87950
movq 0x38(%rsp), %rdi
callq 0xa890
nopl (%rax)
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/parallel.hpp
// Function: void cpp::parallel_foreach_i_only<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, DOCTEST_ANON_FUNC_16()::$_0>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, DOCTEST_ANON_FUNC_16()::$_0)
void parallel_foreach_i_only(Iterator first, Iterator last, Functor fun) {
    std::vector<std::future<void>> futures;
    futures.reserve(std::distance(first, last));

    for (; first != last; ++first) {
        futures.push_back(std::move(std::async(std::launch::async, fun, futures.size())));
    }

    //No need to wait for the futures, the destructor will do it for us
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x877f0
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x30000
movq %rax, 0x8(%rsp)
jmp 0x77187
movq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x87800
jmp 0x77198
jmp 0x7719a
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1edd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x771b1
jmp 0x7722c
leaq 0x48(%rsp), %rdi
callq 0x87a80
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x60(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x77250
jmp 0x771db
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x87910
jmp 0x771ec
leaq 0x18(%rsp), %rdi
callq 0x87940
leaq 0x70(%rsp), %rdi
callq 0x1f180
jmp 0x7719a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x7723b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x87940
jmp 0x7723b
leaq 0x48(%rsp), %rdi
callq 0x87950
addq $0x78, %rsp
retq
leaq 0x48(%rsp), %rdi
callq 0x87950
movq 0x30(%rsp), %rdi
callq 0xa890
nop
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/streams.hpp
// Function: std::ostream& cpp::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::ostream&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
std::ostream& operator<<(std::ostream& os, const std::vector<T, A>& vec) {
    os << "[";
    std::string comma;
    for (auto& v : vec) {
        os << comma << v;
        comma = ", ";
    }
    os << "]";
    return os;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x5407d(%rip), %rsi     # 0xe53e7
callq 0xa4e0
leaq 0x48(%rsp), %rdi
callq 0x92160
movq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x921d0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x92200
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x92230
xorb $-0x1, %al
testb $0x1, %al
jne 0x913b8
jmp 0x91429
leaq 0x38(%rsp), %rdi
callq 0x92270
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xa430
movq %rax, 0x10(%rsp)
jmp 0x913dd
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xa430
jmp 0x913ee
leaq 0x55387(%rip), %rsi     # 0xe677c
leaq 0x48(%rsp), %rdi
callq 0x92280
jmp 0x91401
jmp 0x91403
leaq 0x38(%rsp), %rdi
callq 0x922b0
jmp 0x913a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2a820
jmp 0x9145a
movq 0x70(%rsp), %rdi
leaq 0x53ff4(%rip), %rsi     # 0xe5429
callq 0xa4e0
jmp 0x9143c
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2a820
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xa890
nopw %cs:(%rax,%rax)
nop
// File: wichtounet[P]cpp_utils_test/include/cpp_utils/string.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>& cpp::rtrim<char, std::char_traits<char>, std::allocator<char>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::basic_string<CharT, Traits, Allocator>& rtrim(std::basic_string<CharT, Traits, Allocator>& s) {
    s.erase(std::find_if(s.rbegin(), s.rend(),
						 [](CharT c) {
							 return !std::isspace(c);
						 }).base(), s.end());
    return s;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x981a0
movq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x981f0
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x98130
leaq 0x38(%rsp), %rdi
callq 0x98240
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x971d0
movq 0x50(%rsp), %rdi
callq 0x97260
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x971d0
movq (%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x970d0
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wichtounet[P]cpp_utils_test/doctest/doctest/doctest.h
// Function: doctest::skipPathFromFilename(char const*)
const char* skipPathFromFilename(const char* file) {
#ifndef DOCTEST_CONFIG_DISABLE
    if(getContextOptions()->no_path_in_filenames) {
        auto back    = std::strrchr(file, '\\');
        auto forward = std::strrchr(file, '/');
        if(back || forward) {
            if(back > forward)
                forward = back;
            return forward + 1;
        }
    }
#endif // DOCTEST_CONFIG_DISABLE
    return file;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
callq 0x9a3e0
testb $0x1, 0x7c(%rax)
je 0x9a3c4
movq 0x18(%rsp), %rdi
movl $0x5c, %esi
callq 0xa580
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2f, %esi
callq 0xa580
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x9a39c
cmpq $0x0, 0x8(%rsp)
je 0x9a3c2
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x9a3b2
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x9a3ce
jmp 0x9a3c4
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: wichtounet[P]cpp_utils_test/doctest/doctest/doctest.h
// Function: doctest::SubcaseSignature::operator<(doctest::SubcaseSignature const&) const
bool SubcaseSignature::operator<(const SubcaseSignature& other) const {
    if(m_line != other.m_line)
        return m_line < other.m_line;
    if(std::strcmp(m_file, other.m_file) != 0)
        return std::strcmp(m_file, other.m_file) < 0;
    return m_name.compare(other.m_name) < 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x20(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
je 0x9a4a0
movq 0x8(%rsp), %rax
movl 0x20(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x9a4fe
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xa6c0
cmpl $0x0, %eax
je 0x9a4e1
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xa6c0
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x9a4fe
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x99610
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: wichtounet[P]cpp_utils_test/doctest/doctest/doctest.h
// Function: doctest::Approx::operator()(double) const
Approx Approx::operator()(double value) const {
    Approx approx(value);
    approx.epsilon(m_epsilon);
    approx.scale(m_scale);
    return approx;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
vmovsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
vmovsd 0x18(%rsp), %xmm0
callq 0x9a8c0
movq 0x8(%rsp), %rax
movq (%rsp), %rdi
vmovsd (%rax), %xmm0
callq 0x9a980
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
vmovsd 0x8(%rax), %xmm0
callq 0x9a9a0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: SeanChao[P]KV-Store/persistence.cc
// Function: usage(char const*, char const*, char const*)
void usage(const char *prog, const char *verb, const char *mode)
{
	std::cout << "Usage: " << prog  << " [-t] [-v]" << std::endl;
	std::cout << "  -t: test mode for persistence test,"
		" if -t is not given, the program only prepares data for test."
		" [currently " << mode << "]" << std::endl;
	std::cout << "  -v: print extra info for failed tests [currently ";
	std::cout << verb << "]" << std::endl;
	std::cout << std::endl;
	std::cout << " NOTE: A normal usage is as follows:" << std::endl;
	std::cout << "    1. invoke `" << prog << "`;" << std::endl;
	std::cout << "    2. terminate (kill) the program when data is ready;";
	std::cout << std::endl;
	std::cout << "    3. invoke `" << prog << "-t ` to test." << std::endl;
	std::cout << std::endl;
	std::cout.flush();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x1a7e5(%rip), %rdi     # 0x1efd0
leaq 0x11832(%rip), %rsi     # 0x16024
callq 0x42f0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x42f0
movq %rax, %rdi
leaq 0x1181f(%rip), %rsi     # 0x1602c
callq 0x42f0
movq %rax, %rdi
movq 0x1a794(%rip), %rsi     # 0x1efb0
callq 0x4320
movq 0x1a7a8(%rip), %rdi     # 0x1efd0
leaq 0x11808(%rip), %rsi     # 0x16037
callq 0x42f0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x42f0
movq %rax, %rdi
leaq 0x11a22(%rip), %rsi     # 0x1626c
callq 0x42f0
movq %rax, %rdi
movq 0x1a757(%rip), %rsi     # 0x1efb0
callq 0x4320
movq 0x1a76b(%rip), %rdi     # 0x1efd0
leaq 0x1183a(%rip), %rsi     # 0x160a6
callq 0x42f0
movq -0x10(%rbp), %rsi
movq 0x1a754(%rip), %rdi     # 0x1efd0
callq 0x42f0
movq %rax, %rdi
leaq 0x119e1(%rip), %rsi     # 0x1626c
callq 0x42f0
movq %rax, %rdi
movq 0x1a716(%rip), %rsi     # 0x1efb0
callq 0x4320
movq 0x1a72a(%rip), %rdi     # 0x1efd0
movq 0x1a703(%rip), %rsi     # 0x1efb0
callq 0x4320
movq 0x1a717(%rip), %rdi     # 0x1efd0
leaq 0x1181a(%rip), %rsi     # 0x160da
callq 0x42f0
movq %rax, %rdi
movq 0x1a6e1(%rip), %rsi     # 0x1efb0
callq 0x4320
movq 0x1a6f5(%rip), %rdi     # 0x1efd0
leaq 0x1181d(%rip), %rsi     # 0x160ff
callq 0x42f0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x42f0
movq %rax, %rdi
leaq 0x11812(%rip), %rsi     # 0x1610f
callq 0x42f0
movq %rax, %rdi
movq 0x1a6a4(%rip), %rsi     # 0x1efb0
callq 0x4320
movq 0x1a6b8(%rip), %rdi     # 0x1efd0
leaq 0x117f3(%rip), %rsi     # 0x16112
callq 0x42f0
movq 0x1a6a5(%rip), %rdi     # 0x1efd0
movq 0x1a67e(%rip), %rsi     # 0x1efb0
callq 0x4320
movq 0x1a692(%rip), %rdi     # 0x1efd0
leaq 0x11805(%rip), %rsi     # 0x1614a
callq 0x42f0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x42f0
movq %rax, %rdi
leaq 0x117fa(%rip), %rsi     # 0x1615a
callq 0x42f0
movq %rax, %rdi
movq 0x1a641(%rip), %rsi     # 0x1efb0
callq 0x4320
movq 0x1a655(%rip), %rdi     # 0x1efd0
movq 0x1a62e(%rip), %rsi     # 0x1efb0
callq 0x4320
movq 0x1a642(%rip), %rdi     # 0x1efd0
callq 0x4210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: SeanChao[P]KV-Store/persistence.cc
// Function: PersistenceTest::start_test(void*)
void start_test(void *args = NULL) override
	{
		bool testmode = (args && *static_cast<bool *>(args));

		std::cout << "KVStore Persistence Test" << std::endl;

		if (testmode) {
			std::cout << "<<Test Mode>>" << std::endl;
			test(TEST_MAX);
		} else {
			std::cout << "<<Preparation Mode>>" << std::endl;
			prepare(TEST_MAX);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x12(%rbp)
je 0x518d
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq 0x19e34(%rip), %rdi     # 0x1efd0
leaq 0x11020(%rip), %rsi     # 0x161c3
callq 0x42f0
movq %rax, %rdi
movq 0x19dfe(%rip), %rsi     # 0x1efb0
callq 0x4320
testb $0x1, -0x11(%rbp)
je 0x51f1
movq 0x19e0c(%rip), %rdi     # 0x1efd0
leaq 0x11011(%rip), %rsi     # 0x161dc
callq 0x42f0
movq %rax, %rdi
movq 0x19dd6(%rip), %rsi     # 0x1efb0
callq 0x4320
movq -0x20(%rbp), %rdi
movq 0xa8(%rdi), %rsi
callq 0x5300
jmp 0x5223
movq 0x19dd8(%rip), %rdi     # 0x1efd0
leaq 0x10feb(%rip), %rsi     # 0x161ea
callq 0x42f0
movq %rax, %rdi
movq 0x19da2(%rip), %rsi     # 0x1efb0
callq 0x4320
movq -0x20(%rbp), %rdi
movq 0xa8(%rdi), %rsi
callq 0x58d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: SeanChao[P]KV-Store/./test.h
// Function: Test::Test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
Test(const std::string &dir, bool v=true): store(dir), verbose(v)
	{
		nr_tests = 0;
		nr_passed_tests = 0;
		nr_phases = 0;
		nr_passed_phases = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x1997a(%rip), %rax     # 0x1ebf0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x7000
movq -0x20(%rbp), %rax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0xa0(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: SeanChao[P]KV-Store/./test.h
// Function: void Test::expect<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void expect(const T &exp, const T &got,
		    const std::string &file, int line)
	{
		++nr_tests;
		if (exp == got) {
			++nr_passed_tests;
			return;
		}
		if (verbose) {
			std::cerr << "TEST Error @" << file << ":" << line;
			std::cerr << ", expected " << exp;
			std::cerr << ", got " << got << std::endl;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6b10
testb $0x1, %al
jne 0x6823
jmp 0x6838
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x68cf
movq -0x30(%rbp), %rax
testb $0x1, 0xa0(%rax)
je 0x68cf
movq 0x187a0(%rip), %rdi     # 0x1eff0
leaq 0xf9de(%rip), %rsi      # 0x16235
callq 0x42f0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x42c0
movq %rax, %rdi
leaq 0xf88b(%rip), %rsi      # 0x160fd
callq 0x42f0
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0x4510
movq 0x18767(%rip), %rdi     # 0x1eff0
leaq 0xf9b2(%rip), %rsi      # 0x16242
callq 0x42f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x42c0
movq 0x18748(%rip), %rdi     # 0x1eff0
leaq 0xf99f(%rip), %rsi      # 0x1624e
callq 0x42f0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x42c0
movq %rax, %rdi
movq 0x186e6(%rip), %rsi     # 0x1efb0
callq 0x4320
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: SeanChao[P]KV-Store/./test.h
// Function: Test::phase()
void phase(void)
	{
		// Report
		std::cout << "  Phase " << (nr_phases+1) << ": ";
		std::cout << nr_passed_tests << "/" << nr_tests << " ";

		// Count
		++nr_phases;
		if (nr_tests == nr_passed_tests) {
			++nr_passed_phases;
			std::cout << "[PASS]" << std::endl;
		} else
			std::cout << "[FAIL]" << std::endl;

		std::cout.flush();

		// Reset
		nr_tests = 0;
		nr_passed_tests = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x18665(%rip), %rdi     # 0x1efd0
leaq 0xf8e3(%rip), %rsi      # 0x16255
callq 0x42f0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0x1, %rsi
callq 0x4090
movq %rax, %rdi
leaq 0xf694(%rip), %rsi      # 0x16029
callq 0x42f0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18627(%rip), %rdi     # 0x1efd0
callq 0x4090
movq %rax, %rdi
leaq 0xf8a6(%rip), %rsi      # 0x1625e
callq 0x42f0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4090
movq %rax, %rdi
leaq 0xf950(%rip), %rsi      # 0x16327
callq 0x42f0
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x18(%rcx)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
jne 0x6a2a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq 0x185c3(%rip), %rdi     # 0x1efd0
leaq 0xf84c(%rip), %rsi      # 0x16260
callq 0x42f0
movq %rax, %rdi
movq 0x1858d(%rip), %rsi     # 0x1efb0
callq 0x4320
jmp 0x6a4c
movq 0x1859f(%rip), %rdi     # 0x1efd0
leaq 0xf82f(%rip), %rsi      # 0x16267
callq 0x42f0
movq %rax, %rdi
movq 0x18569(%rip), %rsi     # 0x1efb0
callq 0x4320
movq 0x1857d(%rip), %rdi     # 0x1efd0
callq 0x4210
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: SeanChao[P]KV-Store/./test.h
// Function: Test::report()
void report(void)
	{
		std::cout << nr_passed_phases << "/" << nr_phases << " passed.";
		std::cout << std::endl;
		std::cout.flush();

		nr_phases = 0;
		nr_passed_phases = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x20(%rax), %rsi
movq 0x18531(%rip), %rdi     # 0x1efd0
callq 0x4090
movq %rax, %rdi
leaq 0xf7b0(%rip), %rsi      # 0x1625e
callq 0x42f0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x4090
movq %rax, %rdi
leaq 0xf7a1(%rip), %rsi      # 0x1626e
callq 0x42f0
movq 0x184f7(%rip), %rdi     # 0x1efd0
movq 0x184d0(%rip), %rsi     # 0x1efb0
callq 0x4320
movq 0x184e4(%rip), %rdi     # 0x1efd0
callq 0x4210
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::KVStore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
KVStore::KVStore(const std::string &dir)
    : KVStoreAPI(dir), dir(dir), verbose(false), memTableSize(0), level(0) {
    memTable = std::unique_ptr<SkipList<uint64_t, std::string>>(
        new SkipList<uint64_t, std::string>());
    // this->dir = dir;
    // root = std::filesystem::path(dir);
    fileNum.push_back(0);
    loadSsTable();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0xb460
movq -0x40(%rbp), %rdi
leaq 0x17bec(%rip), %rax     # 0x1ec18
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4170
movq -0x40(%rbp), %rdi
movb $0x0, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
addq $0x38, %rdi
movq %rdi, -0x50(%rbp)
callq 0xb480
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x48(%rbp)
callq 0xb4b0
movq -0x40(%rbp), %rdi
movl $0x0, 0x58(%rdi)
addq $0x60, %rdi
movq %rdi, -0x38(%rbp)
callq 0xb4d0
movl $0x28, %edi
callq 0x4300
movq %rax, -0x30(%rbp)
jmp 0x7096
movq -0x30(%rbp), %rdi
callq 0xb4f0
jmp 0x70a1
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb670
movq -0x60(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
callq 0xb6a0
movq -0x60(%rbp), %rdi
callq 0xb6d0
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
movl $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xb720
jmp 0x70e6
movq -0x40(%rbp), %rdi
callq 0x7150
jmp 0x70f1
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x711f
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x28, %esi
callq 0x4310
movq -0x38(%rbp), %rdi
callq 0xb750
movq -0x48(%rbp), %rdi
callq 0xb7b0
movq -0x50(%rbp), %rdi
callq 0xb6d0
movq -0x58(%rbp), %rdi
callq 0x45d8
movq -0x20(%rbp), %rdi
callq 0x4530
nopl (%rax)
// File: SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::put(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void KVStore::put(uint64_t key, const std::string &s) {
    std::clog << "+ " << key << " " << std::string(s, 0, 50) << std::endl;
    memTable->put(key, s);
    memTableSize += getDataSize(s.length());
    if (verbose) {
        // std::clog << "put " << key << '\t' << s << "  done.\n";
        // std::clog << *memTable << '\n';
    }
    // if the size memTable reaches the threshold, then calls buildSsTable and
    // resets memTable
    if (this->memTableSize >= MEM_TABLE_SIZE_MAX) {
        convertMemTable();
        resetMemTable();
        // std::clog << *memTable << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq 0x17b17(%rip), %rdi     # 0x1efa0
leaq 0xee96(%rip), %rsi      # 0x16326
callq 0x42f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4090
movq %rax, %rdi
leaq 0xee7c(%rip), %rsi      # 0x16327
callq 0x42f0
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x32, %ecx
callq 0x4450
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x42c0
movq %rax, -0x70(%rbp)
jmp 0x74e1
movq -0x70(%rbp), %rdi
movq 0x17ac4(%rip), %rsi     # 0x1efb0
callq 0x4320
jmp 0x74f3
leaq -0x38(%rbp), %rdi
callq 0x45d8
movq -0x88(%rbp), %rdi
addq $0x38, %rdi
callq 0xb830
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4170
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
callq 0xb850
jmp 0x754e
leaq -0x68(%rbp), %rdi
callq 0x45d8
movq -0x18(%rbp), %rdi
callq 0x4490
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0xbfd0
movq %rax, %rcx
movq -0x88(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
testb $0x1, 0x28(%rax)
je 0x75b7
jmp 0x75b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x45d8
jmp 0x75e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x45d8
jmp 0x75e9
movq -0x88(%rbp), %rax
cmpq $0x200000, 0x30(%rax)   # imm = 0x200000
jb 0x75e0
movq -0x88(%rbp), %rdi
callq 0x7600
movq -0x88(%rbp), %rdi
callq 0x7c10
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4530
nopw %cs:(%rax,%rax)
// File: SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::resetMemTable()
void KVStore::resetMemTable() {
    // resets memTable
    memTable.release();
    memTable = std::unique_ptr<SkipList<uint64_t, std::string>>(
        new SkipList<uint64_t, std::string>());
    // reset state
    memTableSize = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x38, %rdi
callq 0xb810
movl $0x28, %edi
callq 0x4300
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0xb4f0
jmp 0x7c48
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0xb670
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
leaq -0x10(%rbp), %rsi
callq 0xb6a0
leaq -0x10(%rbp), %rdi
callq 0xb6d0
movq -0x30(%rbp), %rax
movq $0x0, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x4310
movq -0x18(%rbp), %rdi
callq 0x4530
nopw %cs:(%rax,%rax)
// File: SeanChao[P]KV-Store/kvstore.cc
// Function: KVStore::findIndexedKey(unsigned long, unsigned long*) const
int KVStore::findIndexedKey(uint64_t key, uint64_t *offsetDst) const {
    int count = 0;
    bool found = false;
    uint64_t offset = 0;
    for (auto table : indexTableList) {
        if (found) break;
        // binary searches in an index table
        int l = 0;
        int r = table.size() - 1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (table[mid].key == key) {
                offset = table[mid].offset;
                found = true;
                break;
            }
            if (table[mid].key < key) {
                l = mid + 1;
            } else
                r = mid - 1;
        }
        if (!found) count++;
    }
    if (found && offsetDst != nullptr) *offsetDst = offset;
    return found ? count : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movq $0x0, -0x28(%rbp)
addq $0x40, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xcf90
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xcfc0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xcff0
testb $0x1, %al
jne 0x8003
jmp 0x80f1
leaq -0x38(%rbp), %rdi
callq 0xd030
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0xd050
testb $0x1, -0x1d(%rbp)
je 0x802a
movl $0x2, -0x5c(%rbp)
jmp 0x80cd
movl $0x0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xd140
subq $0x1, %rax
movl %eax, -0x64(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x64(%rbp), %eax
jg 0x80b7
movl -0x60(%rbp), %eax
addl -0x64(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x68(%rbp)
movslq -0x68(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xd160
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x808b
movslq -0x68(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xd160
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movb $0x1, -0x1d(%rbp)
jmp 0x80b7
movslq -0x68(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xd160
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0x80ac
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x80b5
movl -0x68(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x8041
testb $0x1, -0x1d(%rbp)
jne 0x80c6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x5c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xcd20
movl -0x5c(%rbp), %eax
testl %eax, %eax
je 0x80e1
jmp 0x80df
jmp 0x80f1
jmp 0x80e3
leaq -0x38(%rbp), %rdi
callq 0xd180
jmp 0x7fed
testb $0x1, -0x1d(%rbp)
je 0x8109
cmpq $0x0, -0x18(%rbp)
je 0x8109
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
testb $0x1, -0x1d(%rbp)
je 0x8117
movl -0x1c(%rbp), %eax
movl %eax, -0x6c(%rbp)
jmp 0x8121
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x6c(%rbp)
jmp 0x8121
movl -0x6c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)