LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sus304[P]ForRocket/./lib/boost/numeric/odeint/stepper/runge_kutta4.hpp
// Function: boost::numeric::odeint::rk4_coefficients_b<double>::rk4_coefficients_b()
rk4_coefficients_b( void )
    {
        (*this)[0] = static_cast<Value>(1)/static_cast<Value>(6);
        (*this)[1] = static_cast<Value>(1)/static_cast<Value>(3);
        (*this)[2] = static_cast<Value>(1)/static_cast<Value>(3);
        (*this)[3] = static_cast<Value>(1)/static_cast<Value>(6);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x82850
movq -0x10(%rbp), %rdi
movsd 0x1572f(%rip), %xmm0    # 0x97668
movsd %xmm0, (%rax)
movl $0x1, %esi
callq 0x82850
movq -0x10(%rbp), %rdi
movsd 0x242bd(%rip), %xmm0    # 0xa6210
movsd %xmm0, (%rax)
movl $0x2, %esi
callq 0x82850
movq -0x10(%rbp), %rdi
movsd 0x242a3(%rip), %xmm0    # 0xa6210
movsd %xmm0, (%rax)
movl $0x3, %esi
callq 0x82850
movsd 0x156e5(%rip), %xmm0    # 0x97668
movsd %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: sus304[P]ForRocket/./lib/boost/numeric/odeint/stepper/runge_kutta4.hpp
// Function: boost::numeric::odeint::rk4_coefficients_c<double>::rk4_coefficients_c()
rk4_coefficients_c( void )
    {
        (*this)[0] = static_cast<Value>(0);
        (*this)[1] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
        (*this)[2] = static_cast< Value >( 1 ) / static_cast< Value >( 2 );
        (*this)[3] = static_cast<Value>(1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x82850
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x1, %esi
callq 0x82850
movq -0x10(%rbp), %rdi
movsd 0x13692(%rip), %xmm0    # 0x95660
movsd %xmm0, (%rax)
movl $0x2, %esi
callq 0x82850
movq -0x10(%rbp), %rdi
movsd 0x13678(%rip), %xmm0    # 0x95660
movsd %xmm0, (%rax)
movl $0x3, %esi
callq 0x82850
movsd 0x1363a(%rip), %xmm0    # 0x95638
movsd %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sus304[P]ForRocket/./lib/boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp
// Function: boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::stage_vector::stage_vector(boost::fusion::vector<boost::array<double, 1ul> const, boost::array<double, 2ul> const, boost::array<double, 3ul> const> const&, boost::array<double, 4ul> const&, boost::array<double, 4ul> const&)
stage_vector( const coef_a_type &a , const coef_b_type &b , const coef_c_type &c )
        {
            typedef boost::mpl::range_c< size_t , 0 , StageCount-1 > indices;
            boost::mpl::for_each< indices >( do_insertion( *this , a , c ) );
            boost::fusion::at_c< StageCount - 1 >( *this ).c = c[ StageCount - 1 ];
            boost::fusion::at_c< StageCount - 1 >( *this ).a = b;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x82a10
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0x82a90
leaq -0x38(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x82a30
movq -0x20(%rbp), %rdi
movl $0x3, %esi
callq 0x82ad0
movq -0x48(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
callq 0x82b40
movsd -0x50(%rbp), %xmm0
movq -0x48(%rbp), %rdi
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x82b40
movq -0x40(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x20(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sus304[P]ForRocket/./lib/boost/mpl/for_each.hpp
// Function: void boost::mpl::aux::for_each_impl<false>::execute<boost::mpl::r_iter<mpl_::integral_c<unsigned long, 0ul>>, boost::mpl::r_iter<mpl_::integral_c<unsigned long, 3ul>>, boost::mpl::identity<mpl_::na>, boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::stage_vector::do_insertion>(boost::mpl::r_iter<mpl_::integral_c<unsigned long, 0ul>>*, boost::mpl::r_iter<mpl_::integral_c<unsigned long, 3ul>>*, boost::mpl::identity<mpl_::na>*, boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::stage_vector::do_insertion)
BOOST_MPL_CFG_GPU_ENABLED
    static void execute(
          Iterator*
        , LastIterator*
        , TransformFunc* 
        , F f
        )
    {
        typedef typename deref<Iterator>::type item;
        typedef typename apply1<TransformFunc,item>::type arg;
    
        // dwa 2002/9/10 -- make sure not to invoke undefined behavior
        // when we pass arg.
        value_initialized<arg> x;
        aux::unwrap(f, 0)(boost::get(x));
        
        typedef typename mpl::next<Iterator>::type iter;
        for_each_impl<boost::is_same<iter,LastIterator>::value>
            ::execute( static_cast<iter*>(0), static_cast<LastIterator*>(0), static_cast<TransformFunc*>(0), f);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x82d90
movq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x82db0
movq %rax, -0x58(%rbp)
jmp 0x82d0b
leaq -0x19(%rbp), %rdi
callq 0x82e50
jmp 0x82d16
movq -0x58(%rbp), %rdi
callq 0x82dd0
jmp 0x82d21
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x40(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
movq -0x40(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0x50(%rbp), %xmm0
movups %xmm0, (%rax)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
movq %rdx, %rsi
callq 0x82e70
jmp 0x82d57
leaq -0x19(%rbp), %rdi
callq 0x82f30
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x82f30
movq -0x28(%rbp), %rdi
callq 0x6760
nopw (%rax,%rax)
// File: sus304[P]ForRocket/./lib/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
// Function: void boost::numeric::odeint::explicit_stepper_base<boost::numeric::odeint::explicit_generic_rk<4ul, 4ul, std::array<double, 14ul>, double, std::array<double, 14ul>, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations, boost::numeric::odeint::initially_resizer>, (unsigned short)4, std::array<double, 14ul>, double, std::array<double, 14ul>, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations, boost::numeric::odeint::initially_resizer>::do_step_v1<forrocket::Dynamics3dofParachute, std::array<double, 14ul>>(forrocket::Dynamics3dofParachute, std::array<double, 14ul>&, double, double)
void do_step_v1( System system , StateInOut &x , time_type t , time_type dt )
    {
        typename odeint::unwrap_reference< System >::type &sys = system;
        m_resizer.adjust_size( x , detail::bind( &internal_stepper_base_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );
        sys( x , m_dxdt.m_v ,t );
        this->stepper().do_step_impl( system , x , m_dxdt.m_v , t , x , dt );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
incq %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq 0x14a(%rip), %rax       # 0x839a0
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
callq 0x839d0
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq 0x6072a(%rip), %rcx     # 0xe3fa8
callq 0x83960
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x83910
movq -0x90(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rdx
movsd -0x20(%rbp), %xmm0
movq (%rdi), %rax
callq *(%rax)
movq -0x90(%rbp), %rdi
callq 0x83a00
movq -0x98(%rbp), %rsi
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x7cd60
movq -0x90(%rbp), %rcx
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x8, %rcx
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %r8
movsd -0x28(%rbp), %xmm1
leaq -0x80(%rbp), %rsi
callq 0x83a10
addq $0xb0, %rsp
popq %rbp
retq
// File: sus304[P]ForRocket/./lib/boost/numeric/odeint/stepper/explicit_generic_rk.hpp
// Function: bool boost::numeric::odeint::explicit_generic_rk<4ul, 4ul, std::array<double, 14ul>, double, std::array<double, 14ul>, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations, boost::numeric::odeint::initially_resizer>::resize_impl<std::array<double, 14ul>>(std::array<double, 14ul> const&)
bool resize_impl( const StateIn &x )
    {
        bool resized( false );
        resized |= adjust_size_by_resizeability( m_x_tmp , x , typename is_resizeable<state_type>::type() );
        for( size_t i = 0 ; i < StageCount-1 ; ++i )
        {
            resized |= adjust_size_by_resizeability( m_F[i] , x , typename is_resizeable<deriv_type>::type() );
        }
        return resized;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
addq $0xf0, %rdi
movq -0x10(%rbp), %rsi
callq 0x7e5b0
andb $0x1, %al
movzbl %al, %ecx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x3, -0x20(%rbp)
jae 0x83fe9
movq -0x30(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
imulq $0x70, -0x20(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x7e5b0
andb $0x1, %al
movzbl %al, %ecx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x83f9e
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: sus304[P]ForRocket/./lib/boost/fusion/algorithm/iteration/detail/for_each.hpp
// Function: void boost::fusion::detail::for_each_unrolled<4>::call<boost::fusion::vector_iterator<boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::stage_vector const, 0>, boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::calculate_stage<forrocket::Dynamics3dofParachute, std::array<double, 14ul>, std::array<double, 14ul>, std::array<double, 14ul>, boost::numeric::odeint::state_wrapper<std::array<double, 14ul>, void>, std::array<double, 14ul>, double>>(boost::fusion::vector_iterator<boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::stage_vector const, 0> const&, boost::numeric::odeint::detail::generic_rk_algorithm<4ul, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::calculate_stage<forrocket::Dynamics3dofParachute, std::array<double, 14ul>, std::array<double, 14ul>, std::array<double, 14ul>, boost::numeric::odeint::state_wrapper<std::array<double, 14ul>, void>, std::array<double, 14ul>, double>&)
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        static void call(I0 const& i0, F& f)
        {
            f(*i0);
            typedef typename result_of::next<I0>::type I1;
            I1 i1(fusion::next(i0));
            f(*i1);
            typedef typename result_of::next<I1>::type I2;
            I2 i2(fusion::next(i1));
            f(*i2);
            typedef typename result_of::next<I2>::type I3;
            I3 i3(fusion::next(i2));
            f(*i3);
            for_each_unrolled<N-4>::call(fusion::next(i3), f);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x84710
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x84690
movq -0x8(%rbp), %rdi
callq 0x84740
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x84840
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x84770
leaq -0x18(%rbp), %rdi
callq 0x84870
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x84980
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x848a0
leaq -0x20(%rbp), %rdi
callq 0x849b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x84ab0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x849e0
leaq -0x28(%rbp), %rdi
callq 0x84af0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x84ae0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Open_DB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
KVDS* Open_DB(string filename, int shards_num, int aggregate = 0) {
    cout << "Start OpenDB, Please wait ..." << endl;
    Options opts;
    opts.shards_num = shards_num;
    opts.aggregate_request = aggregate;
    KVTime tv_start;
    KVDS *db = KVDS::Open_KVDS(filename.c_str(), opts);
    KVTime tv_end;
    double diff_time = (tv_end - tv_start) / 1000000.0;
    cout << "Open DB use time: " << diff_time << "s" << endl;
    return db;
}

// Assembly:
subq $0x178, %rsp            # imm = 0x178
movq %rdi, 0x78(%rsp)
movq %rdi, 0x170(%rsp)
movl %esi, 0x16c(%rsp)
movl %edx, 0x168(%rsp)
movq 0x6eed7(%rip), %rdi     # 0x77fd0
leaq 0x4e075(%rip), %rsi     # 0x57175
callq 0x8520
movq %rax, %rdi
movq 0x6ee91(%rip), %rsi     # 0x77fa0
callq 0x8560
leaq 0x118(%rsp), %rdi
callq 0x3c2f0
movl 0x16c(%rsp), %eax
movl %eax, 0x130(%rsp)
movl 0x168(%rsp), %eax
testl %eax, %eax
setne 0x150(%rsp)
leaq 0x108(%rsp), %rdi
callq 0x555c0
movq 0x78(%rsp), %rdi
callq 0x8190
movq %rax, %rdi
movups 0x158(%rsp), %xmm0
movaps %xmm0, 0xf0(%rsp)
movups 0x118(%rsp), %xmm0
movups 0x128(%rsp), %xmm1
movups 0x138(%rsp), %xmm2
movups 0x148(%rsp), %xmm3
movaps %xmm3, 0xe0(%rsp)
movaps %xmm2, 0xd0(%rsp)
movaps %xmm1, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movaps 0xf0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movaps 0xb0(%rsp), %xmm0
movaps 0xc0(%rsp), %xmm1
movaps 0xd0(%rsp), %xmm2
movaps 0xe0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x31470
movq %rax, 0x80(%rsp)
jmp 0x91f7
movq 0x80(%rsp), %rax
movq %rax, 0x100(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x555c0
jmp 0x9216
leaq 0x90(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0x55770
movq %rax, 0x70(%rsp)
jmp 0x9232
movq 0x70(%rsp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x4ddc4(%rip), %xmm1    # 0x57008
divsd %xmm1, %xmm0
movsd %xmm0, 0x88(%rsp)
movq 0x6ed78(%rip), %rdi     # 0x77fd0
leaq 0x4df34(%rip), %rsi     # 0x57193
callq 0x8520
movq %rax, 0x68(%rsp)
jmp 0x926b
movq 0x68(%rsp), %rdi
movsd 0x88(%rsp), %xmm0
callq 0x8940
movq %rax, 0x60(%rsp)
jmp 0x9285
movq 0x60(%rsp), %rdi
leaq 0x4e146(%rip), %rsi     # 0x573d7
callq 0x8520
movq %rax, 0x58(%rsp)
jmp 0x929d
movq 0x58(%rsp), %rdi
movq 0x6ecf7(%rip), %rsi     # 0x77fa0
callq 0x8560
jmp 0x92b0
movq 0x100(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x557b0
leaq 0x108(%rsp), %rdi
callq 0x557b0
movq 0x50(%rsp), %rax
addq $0x178, %rsp            # imm = 0x178
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x931b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x557b0
leaq 0x108(%rsp), %rdi
callq 0x557b0
movq 0xa8(%rsp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Create_Keys(int, 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>>>>&)
void Create_Keys(int record_num, vector<string> &key_list) {
    for (int index = 0; index < record_num; index++) {
        char c_key[KEY_SIZE+1] = "kkkkkkkkkk";
        stringstream key_ss;
        key_ss << index;
        string key(key_ss.str());
        memcpy(c_key, key.c_str(), key.length());
        string key_last = c_key;
        key_list.push_back(key_last);
    }
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movl %edi, 0x224(%rsp)
movq %rsi, 0x218(%rsp)
movl $0x0, 0x214(%rsp)
movl 0x214(%rsp), %eax
cmpl 0x224(%rsp), %eax
jge 0x94d6
movabsq $0x6b6b6b6b6b6b6b6b, %rax # imm = 0x6B6B6B6B6B6B6B6B
movq %rax, 0x208(%rsp)
movl $0x6b6b6b, 0x20f(%rsp) # imm = 0x6B6B6B
leaq 0x80(%rsp), %rdi
callq 0x8380
leaq 0x90(%rsp), %rdi
movl 0x214(%rsp), %esi
callq 0x8870
jmp 0x93b5
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x8510
jmp 0x93c9
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x8190
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x8770
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x208(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8440
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x8890
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x86c0
jmp 0x9426
leaq 0x2f(%rsp), %rdi
callq 0x8580
movq 0x218(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xce00
jmp 0x9444
leaq 0x30(%rsp), %rdi
callq 0x8998
leaq 0x50(%rsp), %rdi
callq 0x8998
leaq 0x80(%rsp), %rdi
callq 0x83f0
movl 0x214(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x214(%rsp)
jmp 0x9361
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x94c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x8580
jmp 0x94bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x8998
leaq 0x50(%rsp), %rdi
callq 0x8998
leaq 0x80(%rsp), %rdi
callq 0x83f0
jmp 0x94de
addq $0x228, %rsp            # imm = 0x228
retq
movq 0x78(%rsp), %rdi
callq 0x8880
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Bench_Create_DB(benchmark_arg)
void Bench_Create_DB(benchmark_arg bm_arg) {
    string file_path = bm_arg.file_path;
    int db_size = bm_arg.db_size;
    int segment_K = bm_arg.segment_K;
    int shards_num = bm_arg.shards_num;
    int ds_type = bm_arg.ds_type;

    vector<string> key_list;
    if (Create_DB(file_path, db_size, segment_K, shards_num, ds_type) < 0) {
        cout << "Create DB Fail!!!" <<endl;
        return;
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, %rsi
movq %rsi, 0x18(%rsp)
movq %rsi, 0xa0(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x81b0
movq 0x18(%rsp), %rdi
movl 0x20(%rdi), %eax
movl %eax, 0x7c(%rsp)
movl 0x2c(%rdi), %eax
movl %eax, 0x78(%rsp)
movl 0x30(%rdi), %eax
movl %eax, 0x74(%rsp)
movl 0x34(%rdi), %eax
movl %eax, 0x70(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xd290
movq 0x20(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x81b0
jmp 0xb735
movl 0x7c(%rsp), %esi
movl 0x78(%rsp), %edx
movl 0x74(%rsp), %ecx
movl 0x70(%rsp), %r8d
leaq 0x38(%rsp), %rdi
callq 0x8dc0
movl %eax, 0x14(%rsp)
jmp 0xb756
leaq 0x38(%rsp), %rdi
callq 0x8998
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
jge 0xb7ca
movq 0x6c860(%rip), %rdi     # 0x77fd0
leaq 0x4bcd8(%rip), %rsi     # 0x5744f
callq 0x8520
movq %rax, 0x8(%rsp)
jmp 0xb783
movq 0x8(%rsp), %rdi
movq 0x6c811(%rip), %rsi     # 0x77fa0
callq 0x8560
jmp 0xb796
movl $0x1, 0x28(%rsp)
jmp 0xb7d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xb7f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x8998
jmp 0xb7f1
movl $0x0, 0x28(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xd2a0
leaq 0x80(%rsp), %rdi
callq 0x8998
addq $0xa8, %rsp
retq
leaq 0x58(%rsp), %rdi
callq 0xd2a0
leaq 0x80(%rsp), %rdi
callq 0x8998
movq 0x30(%rsp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Bench_Write(benchmark_arg)
void Bench_Write(benchmark_arg bm_arg) {
    string file_path = bm_arg.file_path;
    int record_num =bm_arg.record_num;
    int thread_num = bm_arg.thread_num;
    int shards_num = bm_arg.shards_num;
    int aggregate = bm_arg.aggregate;

    vector<string> key_list;
    Create_Keys(record_num, key_list);

    KVDS *db = Open_DB(file_path, shards_num, aggregate);

    Bench_Insert(db, record_num, key_list, thread_num);
    delete db;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, %rsi
movq %rsi, 0x10(%rsp)
movq %rsi, 0xa0(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x81b0
movq 0x10(%rsp), %rdi
movl 0x24(%rdi), %eax
movl %eax, 0x7c(%rsp)
movl 0x28(%rdi), %eax
movl %eax, 0x78(%rsp)
movl 0x30(%rdi), %eax
movl %eax, 0x74(%rsp)
movl 0x38(%rdi), %eax
movl %eax, 0x70(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd290
movq 0x18(%rsp), %rsi
movl 0x7c(%rsp), %edi
callq 0x9340
jmp 0xb884
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x81b0
jmp 0xb898
movl 0x74(%rsp), %esi
movl 0x70(%rsp), %edx
leaq 0x20(%rsp), %rdi
callq 0x90d0
movq %rax, 0x8(%rsp)
jmp 0xb8b1
leaq 0x20(%rsp), %rdi
callq 0x8998
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movl 0x7c(%rsp), %esi
movl 0x78(%rsp), %ecx
xorl %eax, %eax
movl %eax, %r8d
leaq 0x58(%rsp), %rdx
callq 0x9820
jmp 0xb8e3
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xb8fc
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x58(%rsp), %rdi
callq 0xd2a0
leaq 0x80(%rsp), %rdi
callq 0x8998
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb943
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8998
leaq 0x58(%rsp), %rdi
callq 0xd2a0
leaq 0x80(%rsp), %rdi
callq 0x8998
movq 0x50(%rsp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: Bench_Read(benchmark_arg)
void Bench_Read(benchmark_arg bm_arg)
{
    string file_path = bm_arg.file_path;
    int record_num =bm_arg.record_num;
    int thread_num = bm_arg.thread_num;
    int shards_num = bm_arg.shards_num;

    vector<string> key_list;
    Create_Keys(record_num, key_list);

    KVDS *db = Open_DB(file_path, shards_num);
    db->ClearReadCache();
    Bench_Get_Seq(db, record_num, key_list, thread_num);
    delete db;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, %rsi
movq %rsi, 0x10(%rsp)
movq %rsi, 0xa0(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x81b0
movq 0x10(%rsp), %rdi
movl 0x24(%rdi), %eax
movl %eax, 0x7c(%rsp)
movl 0x28(%rdi), %eax
movl %eax, 0x78(%rsp)
movl 0x30(%rdi), %eax
movl %eax, 0x74(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd290
movq 0x18(%rsp), %rsi
movl 0x7c(%rsp), %edi
callq 0x9340
jmp 0xc33d
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x81b0
jmp 0xc351
movl 0x74(%rsp), %esi
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
callq 0x90d0
movq %rax, 0x8(%rsp)
jmp 0xc368
leaq 0x20(%rsp), %rdi
callq 0x8998
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x32800
jmp 0xc388
movq 0x40(%rsp), %rdi
movl 0x7c(%rsp), %esi
movl 0x78(%rsp), %ecx
leaq 0x58(%rsp), %rdx
callq 0xa570
jmp 0xc3a1
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xc3ba
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x58(%rsp), %rdi
callq 0xd2a0
leaq 0x80(%rsp), %rdi
callq 0x8998
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xc401
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8998
leaq 0x58(%rsp), %rdi
callq 0xd2a0
leaq 0x80(%rsp), %rdi
callq 0x8998
movq 0x50(%rsp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: main
int main(int argc, char** argv) {

    benchmark_arg bm_arg;

    if(Parse_Option(argc, argv, bm_arg) < 0) {
        usage();
        return -1;
    }

    switch(bm_arg.bench_type) {
        case CREATE:
            Bench_Create_DB(bm_arg);
            break;
        case WRITE:
            Bench_Write(bm_arg);
            break;
        case OVERWRITE:
            Bench_Overwrite(bm_arg);
            break;
        case READ:
            Bench_Read(bm_arg);
            break;
        default:
            break;
    }
    return 0;
}

// Assembly:
subq $0x178, %rsp            # imm = 0x178
movl $0x0, 0x174(%rsp)
movl %edi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
leaq 0x128(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd300
movq 0x8(%rsp), %rdx
movl 0x170(%rsp), %edi
movq 0x168(%rsp), %rsi
callq 0xadf0
movl %eax, 0x14(%rsp)
jmp 0xc482
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
jge 0xc4c6
callq 0x8d90
jmp 0xc492
movl $0xffffffff, 0x174(%rsp) # imm = 0xFFFFFFFF
movl $0x1, 0x118(%rsp)
jmp 0xc65e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
jmp 0xc67a
movl 0x164(%rsp), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0xc646
movq (%rsp), %rax
leaq 0x4ab7a(%rip), %rcx     # 0x57060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xd8(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0xd310
jmp 0xc506
leaq 0xd8(%rsp), %rdi
callq 0xb6d0
jmp 0xc515
leaq 0xd8(%rsp), %rdi
callq 0xd360
jmp 0xc648
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0xd360
jmp 0xc67a
leaq 0x98(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0xd310
jmp 0xc564
leaq 0x98(%rsp), %rdi
callq 0xb820
jmp 0xc573
leaq 0x98(%rsp), %rdi
callq 0xd360
jmp 0xc648
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xd360
jmp 0xc67a
leaq 0x58(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0xd310
jmp 0xc5bf
leaq 0x58(%rsp), %rdi
callq 0xb970
jmp 0xc5cb
leaq 0x58(%rsp), %rdi
callq 0xd360
jmp 0xc648
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xd360
jmp 0xc67a
leaq 0x18(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0xd310
jmp 0xc60e
leaq 0x18(%rsp), %rdi
callq 0xc2e0
jmp 0xc61a
leaq 0x18(%rsp), %rdi
callq 0xd360
jmp 0xc648
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x120(%rsp)
movl %eax, 0x11c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xd360
jmp 0xc67a
jmp 0xc648
movl $0x0, 0x174(%rsp)
movl $0x1, 0x118(%rsp)
leaq 0x128(%rsp), %rdi
callq 0xd360
movl 0x174(%rsp), %eax
addq $0x178, %rsp            # imm = 0x178
retq
leaq 0x128(%rsp), %rdi
callq 0xd360
movq 0x120(%rsp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: LatMgr::GetStatistics(Lat_Stats&)
void GetStatistics(Lat_Stats &lat_stats) {
        sort(lat_vec.begin(), lat_vec.end());
        //for (vector<uint64_t>::iterator iter=lat_vec.begin(); iter!= lat_vec.end(); ++iter)
        //{
        //    cout << "sorted latency is: " << *iter << endl;
        //}
        int len = lat_vec.size();
        int med_idx = len / 2;
        int P_50_idx = (int) (len * 0.5) - 1;
        int P_75_idx = (int) (len * 0.75) - 1;
        int P_99_idx = (int) (len * 0.99) - 1;
        int P_999_idx = (int) (len * 0.999) - 1;
        int P_9999_idx = (int) (len * 0.9999) - 1;

        lat_stats.med    = lat_vec[med_idx];
        lat_stats.P_50   = lat_vec[P_50_idx];
        lat_stats.P_75   = lat_vec[P_75_idx];
        lat_stats.P_99   = lat_vec[P_99_idx];
        lat_stats.P_999  = lat_vec[P_999_idx];
        lat_stats.P_9999 = lat_vec[P_9999_idx];
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xf8f0
movq (%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0xf770
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xfda0
movq (%rsp), %rdi
callq 0xfa30
movq (%rsp), %rdi
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x20(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm0
movsd 0x4a04b(%rip), %xmm1    # 0x57038
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
subl $0x1, %eax
movl %eax, 0x1c(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm0
movsd 0x4a026(%rip), %xmm1    # 0x57030
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
subl $0x1, %eax
movl %eax, 0x18(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm0
movsd 0x4a001(%rip), %xmm1    # 0x57028
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm0
movsd 0x49fdc(%rip), %xmm1    # 0x57020
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm0
movsd 0x49fb7(%rip), %xmm1    # 0x57018
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
movslq 0x20(%rsp), %rsi
callq 0xfde0
movq (%rsp), %rdi
movq (%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movslq 0x1c(%rsp), %rsi
callq 0xfde0
movq (%rsp), %rdi
movq (%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movslq 0x18(%rsp), %rsi
callq 0xfde0
movq (%rsp), %rdi
movq (%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movslq 0x14(%rsp), %rsi
callq 0xfde0
movq (%rsp), %rdi
movq (%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x18(%rax)
movslq 0x10(%rsp), %rsi
callq 0xfde0
movq (%rsp), %rdi
movq (%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x20(%rax)
movslq 0xc(%rsp), %rsi
callq 0xfde0
movq (%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x28(%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/tools/Benchmark.cc
// Function: LatMgr::GetAvg()
uint64_t GetAvg() {
        uint64_t total_lats = 0;
        for (vector<uint64_t>::iterator iter = lat_vec.begin(); iter != lat_vec.end(); iter++) {
            total_lats += *iter;
        }
        uint64_t avg = total_lats / (uint64_t)lat_vec.size();
        //cout << "total_lats = " << total_lats << ", size = " << lat_vec.size() << endl;
        return avg;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq $0x0, 0x38(%rsp)
callq 0xf8f0
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0xf770
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xfea0
testb $0x1, %al
jne 0xd15a
jmp 0xd184
leaq 0x30(%rsp), %rdi
callq 0x10590
movq (%rax), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x112f0
movq %rax, 0x20(%rsp)
jmp 0xd136
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xfa30
movq %rax, %rcx
movq 0x8(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: grame-cncm[P]digraph/main.cpp
// Function: newtest()
void newtest()
{
    digraph<char, multidep> g;
    g.add('A', 'B', {{{"M", 2}, {"N", 0}}, 0});
    std::cout << "g = " << g << std::endl;
    dotfile(std::cout, g);
}

// Assembly:
subq $0x168, %rsp            # imm = 0x168
leaq 0x158(%rsp), %rdi
callq 0x29c0
movb $0x41, 0x157(%rsp)
movb $0x42, 0x156(%rsp)
leaq 0x88(%rsp), %rdi
movq %rdi, 0x80(%rsp)
movl $0x2, 0x7c(%rsp)
leaq 0x3ab41(%rip), %rsi     # 0x3d004
leaq 0x7c(%rsp), %rdx
callq 0x2a50
jmp 0x24cf
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x80(%rsp)
movl $0x0, 0x68(%rsp)
leaq 0x3ab18(%rip), %rsi     # 0x3d006
leaq 0x68(%rsp), %rdx
callq 0x2a50
jmp 0x24fa
leaq 0x88(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq $0x2, 0xe0(%rsp)
leaq 0x66(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x2af0
movq 0x58(%rsp), %r8
movq 0xd8(%rsp), %rsi
movq 0xe0(%rsp), %rdx
leaq 0xe8(%rsp), %rdi
leaq 0x67(%rsp), %rcx
callq 0x2b00
jmp 0x254e
movl $0x0, 0x60(%rsp)
leaq 0x118(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x2be0
jmp 0x2572
leaq 0x158(%rsp), %rdi
leaq 0x157(%rsp), %rsi
leaq 0x156(%rsp), %rdx
leaq 0x118(%rsp), %rcx
callq 0x2a00
jmp 0x2599
leaq 0x118(%rsp), %rdi
callq 0x2c20
leaq 0xe8(%rsp), %rdi
callq 0x2c30
leaq 0x66(%rsp), %rdi
callq 0x2c40
leaq 0x88(%rsp), %rax
movq %rax, 0x48(%rsp)
addq $0x50, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x40(%rsp)
callq 0x2ae0
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x50(%rsp)
jne 0x25d3
movq 0x539cf(%rip), %rdi     # 0x55fd0
leaq 0x3bd79(%rip), %rsi     # 0x3e381
callq 0x2180
movq %rax, 0x38(%rsp)
jmp 0x2614
movq 0x38(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0x2c50
movq %rax, 0x30(%rsp)
jmp 0x262d
movq 0x30(%rsp), %rdi
movq 0x5397f(%rip), %rsi     # 0x55fb8
callq 0x21b0
jmp 0x2640
movq 0x53989(%rip), %rdi     # 0x55fd0
leaq 0x158(%rsp), %rsi
xorl %edx, %edx
callq 0x2f60
jmp 0x2658
leaq 0x158(%rsp), %rdi
callq 0x3780
addq $0x168, %rsp            # imm = 0x168
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
movq 0x80(%rsp), %rax
leaq 0x88(%rsp), %rcx
cmpq %rax, %rcx
movq %rax, 0x28(%rsp)
je 0x26bf
movq 0x28(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x20(%rsp)
callq 0x2ae0
movq 0x20(%rsp), %rax
leaq 0x88(%rsp), %rcx
cmpq %rcx, %rax
movq %rax, 0x28(%rsp)
jne 0x2695
jmp 0x2763
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x270c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x26ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x118(%rsp), %rdi
callq 0x2c20
leaq 0xe8(%rsp), %rdi
callq 0x2c30
leaq 0x66(%rsp), %rdi
callq 0x2c40
leaq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x50, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $-0x28, %rdi
movq %rdi, 0x8(%rsp)
callq 0x2ae0
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x272c
jmp 0x2763
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x158(%rsp), %rdi
callq 0x3780
movq 0x70(%rsp), %rdi
callq 0x2290
nopw (%rax,%rax)
// File: grame-cncm[P]digraph/./dglib/stdprinting.hh
// Function: std::ostream& operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>(std::ostream&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>> const&)
inline std::ostream& operator<<(std::ostream& file, const std::map<N, A>& S)
{
    std::string sep = "";

    file << "std::map{";
    for (const auto& e : S) {
        file << sep << e;
        sep = ", ";
    }
    return file << "}";
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x22a0
movq 0x18(%rsp), %rdx
leaq 0x328d2(%rip), %rsi     # 0x3d081
leaq 0x58(%rsp), %rdi
callq 0x2200
jmp 0xa7bb
leaq 0x57(%rsp), %rdi
callq 0x21c0
movq 0x80(%rsp), %rdi
leaq 0x3286c(%rip), %rsi     # 0x3d040
callq 0x2180
jmp 0xa7db
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x8270
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x82c0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x82a0
testb $0x1, %al
jne 0xa81b
jmp 0xa8a9
leaq 0x30(%rsp), %rdi
callq 0xa8f0
movq %rax, 0x20(%rsp)
movq 0x80(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x2150
movq %rax, 0x10(%rsp)
jmp 0xa843
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xa910
jmp 0xa854
leaq 0x327cf(%rip), %rsi     # 0x3d02a
leaq 0x58(%rsp), %rdi
callq 0x21f0
jmp 0xa867
jmp 0xa869
leaq 0x30(%rsp), %rdi
callq 0xa970
jmp 0xa803
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x21c0
jmp 0xa8db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x20e0
jmp 0xa8db
movq 0x80(%rsp), %rdi
leaq 0x339e3(%rip), %rsi     # 0x3e29b
callq 0x2180
movq %rax, 0x8(%rsp)
jmp 0xa8c4
leaq 0x58(%rsp), %rdi
callq 0x20e0
movq 0x8(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
nop
// File: grame-cncm[P]digraph/./dglib/arrow.hh
// Function: arrow_traits<std::pair<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>, int>>::label(std::pair<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>, int> const&)
static std::string label(const multidep& M)
    {
        std::stringstream sn;
        std::string       sep = "";
        for (const auto& d : M.first) {
            sn << sep << d.first << ":" << d.second;
            sep = " ";
        }
        return sn.str();
    }

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x2110
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x22a0
movq 0x30(%rsp), %rdx
leaq 0x32695(%rip), %rsi     # 0x3d081
leaq 0x70(%rsp), %rdi
callq 0x2200
jmp 0xa9f8
leaq 0x6f(%rsp), %rdi
callq 0x21c0
movq 0x218(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x8270
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x82c0
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x82a0
testb $0x1, %al
jne 0xaa45
jmp 0xab07
leaq 0x48(%rsp), %rdi
callq 0xa8f0
movq %rax, 0x38(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2150
movq %rax, 0x18(%rsp)
jmp 0xaa6d
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x2150
movq %rax, 0x10(%rsp)
jmp 0xaa83
movq 0x10(%rsp), %rdi
leaq 0x325f3(%rip), %rsi     # 0x3d082
callq 0x2180
movq %rax, 0x8(%rsp)
jmp 0xaa9b
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x2280
jmp 0xaaaf
leaq 0x3401d(%rip), %rsi     # 0x3ead3
leaq 0x70(%rsp), %rdi
callq 0x21f0
jmp 0xaac2
jmp 0xaac4
leaq 0x48(%rsp), %rdi
callq 0xa970
jmp 0xaa2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6f(%rsp), %rdi
callq 0x21c0
jmp 0xab3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x20e0
jmp 0xab3f
movq 0x20(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x2170
jmp 0xab1b
leaq 0x70(%rsp), %rdi
callq 0x20e0
leaq 0x90(%rsp), %rdi
callq 0x2120
movq 0x28(%rsp), %rax
addq $0x228, %rsp            # imm = 0x228
retq
leaq 0x90(%rsp), %rdi
callq 0x2120
movq 0x60(%rsp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
// File: grame-cncm[P]digraph/./dglib/digraph.hh
// Function: digraph<char, std::pair<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>, int>>::internalgraph::areConnected(char const&, char const&, std::pair<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>, int>&) const
bool areConnected(const N& n1, const N& n2, A& d) const
        {
            auto c = fConnections.at(n1);
            auto q = c.find(n2);
            if (q != c.end()) {
                d = q->second;
                return true;
            } else {
                return false;
            }
        }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq 0x88(%rsp), %rdi
addq $0x30, %rdi
movq 0x80(%rsp), %rsi
callq 0xa440
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xef90
movq 0x8(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x61a0
movq %rax, 0x10(%rsp)
jmp 0xeee2
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x61f0
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x61d0
testb $0x1, %al
jne 0xef10
jmp 0xef59
leaq 0x38(%rsp), %rdi
callq 0x6220
movq %rax, %rsi
addq $0x8, %rsi
movq 0x70(%rsp), %rdi
callq 0x6800
jmp 0xef2d
movb $0x1, 0x97(%rsp)
movl $0x1, 0x1c(%rsp)
jmp 0xef69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5890
jmp 0xef84
movb $0x0, 0x97(%rsp)
movl $0x1, 0x1c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5890
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2290
nop
// File: grame-cncm[P]digraph/mtests.cpp
// Function: mcheck(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&)
bool mcheck(const std::string& testname, const std::string& testvalue, const std::string& expectedvalue)
{
    bool ok = (0 == expectedvalue.compare(testvalue));
    if (ok) {
        std::cout << testname << " SUCCESS " << std::endl;
    } else {
        std::cout << testname << " FAILED " << std::endl;
        std::cout << "We got     [[" << testvalue << "]]" << std::endl;
        std::cout << "instead of [[" << expectedvalue << "]]" << std::endl;
    }
    return ok;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2030
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0xfb9c
movq 0x20(%rsp), %rsi
movq 0x4645c(%rip), %rdi     # 0x55fd0
callq 0x2150
movq %rax, %rdi
leaq 0x2d646(%rip), %rsi     # 0x3d1c9
callq 0x2180
movq %rax, %rdi
movq 0x46426(%rip), %rsi     # 0x55fb8
callq 0x21b0
jmp 0xfc47
movq 0x20(%rsp), %rsi
movq 0x46428(%rip), %rdi     # 0x55fd0
callq 0x2150
movq %rax, %rdi
leaq 0x2d61c(%rip), %rsi     # 0x3d1d3
callq 0x2180
movq %rax, %rdi
movq 0x463f2(%rip), %rsi     # 0x55fb8
callq 0x21b0
movq 0x463fe(%rip), %rdi     # 0x55fd0
leaq 0x2d603(%rip), %rsi     # 0x3d1dc
callq 0x2180
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x2d5f5(%rip), %rsi     # 0x3d1ea
callq 0x2180
movq %rax, %rdi
movq 0x463b4(%rip), %rsi     # 0x55fb8
callq 0x21b0
movq 0x463c0(%rip), %rdi     # 0x55fd0
leaq 0x2d5d6(%rip), %rsi     # 0x3d1ed
callq 0x2180
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x2d5b7(%rip), %rsi     # 0x3d1ea
callq 0x2180
movq %rax, %rdi
movq 0x46376(%rip), %rsi     # 0x55fb8
callq 0x21b0
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: grame-cncm[P]digraph/tests.cpp
// Function: check0()
bool check0()
{
    std::stringstream ss;
    test0(ss);
    bool ok = (0 == ss.str().compare(res0()));
    if (ok) {
        std::cout << "test0 OK " << std::endl;
    } else {
        std::cout << "test0 FAIL " << std::endl;
        std::cout << "We got     " << ss.str() << std::endl;
        std::cout << "instead of " << res0() << std::endl;
    }
    return ok;
}

// Assembly:
subq $0x258, %rsp            # imm = 0x258
leaq 0xd0(%rsp), %rdi
callq 0x2110
leaq 0xe0(%rsp), %rdi
callq 0x1c700
jmp 0x1cba3
leaq 0xa0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x2170
jmp 0x1cbba
leaq 0x80(%rsp), %rdi
callq 0x1cb00
jmp 0x1cbc9
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x2030
movl %eax, 0x3c(%rsp)
jmp 0x1cbe4
movl 0x3c(%rsp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
movb %al, 0x3b(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x20e0
leaq 0xa0(%rsp), %rdi
callq 0x20e0
movb 0x3b(%rsp), %al
andb $0x1, %al
movb %al, 0xc3(%rsp)
testb $0x1, 0xc3(%rsp)
je 0x1ccbc
movq 0x393a1(%rip), %rdi     # 0x55fd0
leaq 0x21375(%rip), %rsi     # 0x3dfab
callq 0x2180
movq %rax, 0x30(%rsp)
jmp 0x1cc42
movq 0x30(%rsp), %rdi
movq 0x3936a(%rip), %rsi     # 0x55fb8
callq 0x21b0
jmp 0x1cc55
jmp 0x1cde5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x1ce0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x1ccaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x20e0
leaq 0xa0(%rsp), %rdi
callq 0x20e0
jmp 0x1ce0b
movq 0x3930d(%rip), %rdi     # 0x55fd0
leaq 0x212eb(%rip), %rsi     # 0x3dfb5
callq 0x2180
movq %rax, 0x28(%rsp)
jmp 0x1ccd6
movq 0x28(%rsp), %rdi
movq 0x392d6(%rip), %rsi     # 0x55fb8
callq 0x21b0
jmp 0x1cce9
movq 0x392e0(%rip), %rdi     # 0x55fd0
leaq 0x212ca(%rip), %rsi     # 0x3dfc1
callq 0x2180
movq %rax, 0x20(%rsp)
jmp 0x1cd03
leaq 0x60(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x2170
jmp 0x1cd17
movq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2150
movq %rax, 0x18(%rsp)
jmp 0x1cd2d
movq 0x18(%rsp), %rdi
movq 0x3927f(%rip), %rsi     # 0x55fb8
callq 0x21b0
jmp 0x1cd40
leaq 0x60(%rsp), %rdi
callq 0x20e0
movq 0x3927f(%rip), %rdi     # 0x55fd0
leaq 0x21275(%rip), %rsi     # 0x3dfcd
callq 0x2180
movq %rax, 0x10(%rsp)
jmp 0x1cd64
leaq 0x40(%rsp), %rdi
callq 0x1cb00
jmp 0x1cd70
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2150
movq %rax, 0x8(%rsp)
jmp 0x1cd86
movq 0x8(%rsp), %rdi
movq 0x39226(%rip), %rsi     # 0x55fb8
callq 0x21b0
jmp 0x1cd99
leaq 0x40(%rsp), %rdi
callq 0x20e0
jmp 0x1cde5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x20e0
jmp 0x1ce0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x20e0
jmp 0x1ce0b
movb 0xc3(%rsp), %al
movb %al, 0x7(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x2120
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x258, %rsp            # imm = 0x258
retq
leaq 0xd0(%rsp), %rdi
callq 0x2120
movq 0xc8(%rsp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)