LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::random_repulsive_lift_g(double, RandomContext*)
double random_repulsive_lift_g (double rsq, RandomContext *random)
    {
        rsq = fmin (rsq, sq (gauss_r0));

        // add thermal energy increase on current interaction energy
        double e_now = evaluate_g (rsq);
        double e_star = random->exponential (inv_temperature);
        double e_evt = e_now + e_star;

        if (e_evt >= g_at_origin)
        {
            // no event (thermal energy large enough)
            return -rsq;
        }
        else
        {
            // invert the Gauss, picking the solution in repulsive region
            double r_evt = gauss_r0 - sqrt (log (e_evt / (-gauss_epsilon)) / pref_g);
            assert (r_evt > 0.);
            return sq (r_evt);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm1
mulsd %xmm1, %xmm1
movapd %xmm0, %xmm3
cmpunordsd %xmm0, %xmm3
movapd %xmm3, %xmm2
andpd %xmm1, %xmm2
minsd %xmm0, %xmm1
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
movapd %xmm3, (%rsp)
jb 0x432e41
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x432e4a
movapd %xmm3, %xmm0
callq 0x4ed060
subsd 0x10(%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movsd %xmm1, 0x20(%rsp)
mulsd %xmm0, %xmm0
mulsd 0x28(%rbx), %xmm0
callq 0x4ed090
movsd (%rbx), %xmm1
ucomisd 0x1972b4(%rip), %xmm1   # 0x5ca128
jbe 0x432f4f
movapd %xmm0, %xmm2
movl 0xbc8(%r14), %eax
cmpl $0x40, %eax
jne 0x432eb1
movq %r14, %rdi
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
callq 0x440400
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movl 0xbc8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xbc8(%r14)
movl %eax, %eax
movsd 0x9c8(%r14,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
ucomisd 0x38(%rbx), %xmm0
movapd (%rsp), %xmm1
jae 0x432f19
movsd 0x10(%rbx), %xmm1
movaps %xmm1, (%rsp)
movsd 0x8(%rbx), %xmm1
xorpd 0x197145(%rip), %xmm1   # 0x5ca040
divsd %xmm1, %xmm0
callq 0x4ecf00
divsd 0x28(%rbx), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x432f27
sqrtsd %xmm0, %xmm0
jmp 0x432f30
movapd 0x19711f(%rip), %xmm0   # 0x5ca040
xorpd %xmm1, %xmm0
jmp 0x432f47
callq 0x4ed060
xorpd %xmm2, %xmm2
movapd (%rsp), %xmm1
subsd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
jbe 0x432f6e
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x197e69(%rip), %rdi    # 0x5cadbf
leaq 0x197e6d(%rip), %rsi    # 0x5cadca
leaq 0x197e72(%rip), %rcx    # 0x5cadd6
movl $0x120, %edx            # imm = 0x120
callq 0x50b050
leaq 0x19bc47(%rip), %rdi    # 0x5cebbc
leaq 0x19bc4b(%rip), %rsi    # 0x5cebc7
leaq 0x19bc4c(%rip), %rcx    # 0x5cebcf
movl $0x7b, %edx
callq 0x50b050
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::random_repulsive_lift_lj(double, RandomContext*)
double random_repulsive_lift_lj (double rsq, RandomContext *random)
    {
        rsq = fmin (rsq, sq (LJ_MINIMUM));

        // add thermal energy increase on current interaction energy
        double e_now = evaluate_lj (rsq);
        double e_star = random->exponential (inv_temperature);
        double e_evt = e_now + e_star;

        // invert the LJ potential, picking the solution in repulsive region
        // FIXME this is naive and not sufficient for very small rsq.
        double rsix = 1. + sqrt (1. + e_evt);
        double rsq_evt = pow (rsix, -1./3);

        assert (rsq_evt <= sq (LJ_MINIMUM));
        return rsq_evt;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
minsd 0x196075(%rip), %xmm0   # 0x5c9018
movsd 0x1971fd(%rip), %xmm1   # 0x5ca1a8
callq 0x4ecf40
movsd (%r14), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x43306f
movsd 0x197175(%rip), %xmm1   # 0x5ca140
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movl 0xbc8(%rbx), %eax
cmpl $0x40, %eax
jne 0x433004
movq %rbx, %rdi
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x440400
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movl 0xbc8(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xbc8(%rbx)
movl %eax, %eax
movsd 0x9c8(%rbx,%rax,8), %xmm0
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
addsd 0x195ff0(%rip), %xmm1   # 0x5c9018
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x43303b
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x433044
movapd %xmm1, %xmm0
callq 0x4ed060
addsd 0x195fcc(%rip), %xmm0   # 0x5c9018
movsd 0x19af64(%rip), %xmm1   # 0x5cdfb8
callq 0x4ecf40
movsd 0x195fb7(%rip), %xmm1   # 0x5c9018
ucomisd %xmm0, %xmm1
jb 0x43308e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x197d49(%rip), %rdi    # 0x5cadbf
leaq 0x197d4d(%rip), %rsi    # 0x5cadca
leaq 0x197d52(%rip), %rcx    # 0x5cadd6
movl $0x120, %edx            # imm = 0x120
callq 0x50b050
leaq 0x19bb85(%rip), %rdi    # 0x5cec1a
leaq 0x19bb2b(%rip), %rsi    # 0x5cebc7
leaq 0x19bb92(%rip), %rcx    # 0x5cec35
movl $0x65, %edx
callq 0x50b050
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::random_attractive_lift_lj(double, RandomContext*)
double random_attractive_lift_lj (double rsq, RandomContext *random)
    {
        rsq = fmax (rsq, sq (LJ_MINIMUM));

        // add thermal energy increase on current interaction energy
        double e_now = evaluate_lj (rsq);
        double e_star = random->exponential (inv_temperature);
        double e_evt = e_now + e_star;

        if (e_evt >= lj_at_cutoff)
        {
            // thermal energy too large, particle escapes to infinity
            return ESCAPES_TO_INFINITY ();
        }
        else
        {
            // invert the LJ potential, picking the solution in attractive region
            double rsix = 1. - sqrt (1. + e_evt);
            double rsq_evt = pow (rsix, -1./3);
            assert (rsq_evt <= sq (cutoff) && rsq_evt >= sq (LJ_MINIMUM));
            return rsq_evt;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
maxsd 0x195f55(%rip), %xmm0   # 0x5c9018
movsd 0x1970dd(%rip), %xmm1   # 0x5ca1a8
callq 0x4ecf40
movsd (%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x4331b6
movsd 0x197056(%rip), %xmm1   # 0x5ca140
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movl 0xbc8(%r14), %eax
cmpl $0x40, %eax
jne 0x433125
movq %r14, %rdi
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x440400
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movl 0xbc8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xbc8(%r14)
movl %eax, %eax
movsd 0x9c8(%r14,%rax,8), %xmm0
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
ucomisd 0x40(%rbx), %xmm1
jae 0x433165
addsd 0x195ec6(%rip), %xmm1   # 0x5c9018
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x43316f
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x433178
movsd 0x19ae5b(%rip), %xmm0   # 0x5cdfc8
jmp 0x4331ae
movapd %xmm1, %xmm0
callq 0x4ed060
movsd 0x195e98(%rip), %xmm2   # 0x5c9018
subsd %xmm0, %xmm2
movsd 0x19ae2c(%rip), %xmm1   # 0x5cdfb8
movapd %xmm2, %xmm0
callq 0x4ecf40
ucomisd 0x195e7b(%rip), %xmm0   # 0x5c9018
jb 0x4331d5
movsd 0x20(%rbx), %xmm1
mulsd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jb 0x4331d5
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x197c02(%rip), %rdi    # 0x5cadbf
leaq 0x197c06(%rip), %rsi    # 0x5cadca
leaq 0x197c0b(%rip), %rcx    # 0x5cadd6
movl $0x120, %edx            # imm = 0x120
callq 0x50b050
leaq 0x19baa5(%rip), %rdi    # 0x5cec81
leaq 0x19b9e4(%rip), %rsi    # 0x5cebc7
leaq 0x19bacc(%rip), %rcx    # 0x5cecb6
movl $0x9b, %edx
callq 0x50b050
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::random_attractive_lift_g(double, RandomContext*)
double random_attractive_lift_g (double rsq, RandomContext *random)
    {
        rsq = fmax (rsq, sq (gauss_r0));

        // add thermal energy increase on current interaction energy
        double e_now = evaluate_g (rsq);
        double e_star = random->exponential (inv_temperature);
        double e_evt = e_now + e_star;

        if (e_evt >= g_at_cutoff)
        {
            // thermal energy too large, particle escapes to infinity
            return ESCAPES_TO_INFINITY ();
        }
        else
        {
            // invert the Gauss, picking the solution in attractive region
            double r_evt = gauss_r0 + sqrt (log (e_evt / (-gauss_epsilon)) / pref_g);
            return sq (r_evt);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movapd %xmm0, %xmm1
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm2
mulsd %xmm2, %xmm2
cmpunordsd %xmm0, %xmm0
movapd %xmm0, %xmm3
andpd %xmm2, %xmm3
maxsd %xmm1, %xmm2
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x433237
sqrtsd %xmm0, %xmm0
jmp 0x43323c
callq 0x4ed060
subsd 0x10(%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movsd %xmm1, (%rsp)
mulsd %xmm0, %xmm0
mulsd 0x28(%rbx), %xmm0
callq 0x4ed090
movsd (%rbx), %xmm1
ucomisd 0x196ec3(%rip), %xmm1   # 0x5ca128
jbe 0x43332d
movapd %xmm0, %xmm2
movl 0xbc8(%r14), %eax
cmpl $0x40, %eax
jne 0x4332a2
movq %r14, %rdi
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x440400
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movl 0xbc8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xbc8(%r14)
movl %eax, %eax
movsd 0x9c8(%r14,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd (%rsp), %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
ucomisd 0x30(%rbx), %xmm0
jae 0x433305
movsd 0x10(%rbx), %xmm1
movsd %xmm1, (%rsp)
movsd 0x8(%rbx), %xmm1
xorpd 0x196d59(%rip), %xmm1   # 0x5ca040
divsd %xmm1, %xmm0
callq 0x4ecf00
divsd 0x28(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x43330f
sqrtsd %xmm0, %xmm0
jmp 0x433314
movsd 0x19acbb(%rip), %xmm0   # 0x5cdfc8
jmp 0x433325
callq 0x4ed060
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x197a8b(%rip), %rdi    # 0x5cadbf
leaq 0x197a8f(%rip), %rsi    # 0x5cadca
leaq 0x197a94(%rip), %rcx    # 0x5cadd6
movl $0x120, %edx            # imm = 0x120
callq 0x50b050
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./harddisk.hpp
// Function: HardInteraction::set_parameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
void set_parameter (string_ref name, double value)
    {
        if (name == "diameter")
        {
            if (! (value > 0.))
                rt_error ("Invalid particle diameter");
            diameter = value;
        }
        else
        {
            rt_error ("Invalid parameter: " + name);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x198aa8(%rip), %rsi    # 0x5cf283
movq %rbx, %rdi
callq 0x4c2b40
testl %eax, %eax
jne 0x436803
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x436822
movsd %xmm1, (%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x193a86(%rip), %rsi    # 0x5ca290
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x407c44
movq %r14, %rdi
callq 0x43f581
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x198a40(%rip), %rsi    # 0x5cf272
leaq 0x198a52(%rip), %rdx    # 0x5cf28b
leaq 0x8(%rsp), %rdi
callq 0x4083fe
leaq 0x8(%rsp), %rdi
callq 0x43f581
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0x436872
jmp 0x43687f
movq %rax, %rbx
jmp 0x43687f
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43687f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./tools.hpp
// Function: Factory<AbstractStorage>::make(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static ABSTRACT *make (string typecode)
    {
        Factory *f = registry () [typecode];
        if (!f)
            rt_error ("no factory to make product " + typecode);
        ABSTRACT *prod = f->make ();
        prod->typecode_ = typecode;
        return prod;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x4394b4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4394d2
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4393e9
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x4c0560
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1963b0(%rip), %rsi    # 0x5cf7a0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x407c44
movq %r14, %rdi
callq 0x43f581
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x439426
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::Storage()
Storage ()
    {
        num_cells_ = num_ = 0;
        nextsub_ = 0;
        for (unsigned n = 0; n != DIM; ++n)
            bc_[n] = 4;
        bc_[0] = 3;
        bc_[DIM] = 4;
        subdivide (true);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x210ab5(%rip), %rcx    # 0x64a430
movq %rcx, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movq %rax, 0x60(%rdi)
movups %xmm0, 0x28(%rdi)
movl $0x0, 0x38(%rdi)
movabsq $0x400000003, %rax      # imm = 0x400000003
movq %rax, 0x3c(%rdi)
movl $0x4, 0x44(%rdi)
movl $0x1, %esi
callq 0x412ed0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
je 0x4399d0
movq (%r15), %rsi
incq %rsi
callq 0x442d20
movq %r14, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::set_periods(Periods const&)
void set_periods (const Periods &periods) override
    {
        if (num_particles () != 0)
            rt_error ("don't set_periods with particles");

        double MAX = 1. + UINT64_MAX;
        unsigned n = 0;
        for (; n != DIM; ++n)
        {
            peri_[n] = periods[n];
            real2frac[n] = periods[n]==0. ? 0. : MAX/periods[n];
            frac2real[n] = periods[n]==0. ? 0. : 1./real2frac[n];
        }
        for (; n != MAX_DIM; ++n)
        {
            if (periods[n] != 0.)
                rt_error ("periods invalid for this Storage");
        }

        // emit updated parameters to logfile
        std::cerr << "periods " << peri_ << '\n';
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x30(%rax)
testq %rax, %rax
jne 0x439d69
leaq 0x50(%r15), %rbx
xorl %eax, %eax
movsd 0x190524(%rip), %xmm0   # 0x5ca1e0
xorpd %xmm1, %xmm1
movsd 0x18f350(%rip), %xmm2   # 0x5c9018
movsd (%r14,%rax,8), %xmm3
movsd %xmm3, 0x50(%r15,%rax,8)
movapd %xmm0, %xmm4
divsd %xmm3, %xmm4
cmpeqsd %xmm1, %xmm3
andnpd %xmm4, %xmm3
movlpd %xmm3, 0x68(%r15,%rax,8)
movapd %xmm2, %xmm4
divsd %xmm3, %xmm4
movsd (%r14,%rax,8), %xmm3
cmpeqsd %xmm1, %xmm3
andnpd %xmm4, %xmm3
movlpd %xmm3, 0x78(%r15,%rax,8)
incq %rax
cmpq $0x2, %rax
jne 0x439cc8
movsd 0x10(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x439d90
jp 0x439d90
movq $0x655aa0, %r14         # imm = 0x655AA0
leaq 0x195bc5(%rip), %rsi    # 0x5cf8f9
movl $0x8, %edx
movq %r14, %rdi
callq 0x4b0120
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4181dd
movq %rsp, %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4b0120
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x195b3e(%rip), %rsi    # 0x5cf8b7
leaq 0x195b57(%rip), %rdx    # 0x5cf8d7
movq %rsp, %rdi
callq 0x4083fe
movq %rsp, %rdi
callq 0x43f581
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x195b38(%rip), %rsi    # 0x5cf8d8
leaq 0x195b51(%rip), %rdx    # 0x5cf8f8
movq %rsp, %rdi
callq 0x4083fe
movq %rsp, %rdi
callq 0x43f581
jmp 0x439dbb
jmp 0x439dd6
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x439dd9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
jmp 0x439dd9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4f63f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Tagged<Monodisperse2D>>::insert(MostGeneralParticle const&)
key_t insert (const MostGeneralParticle &part)
    {
        // guard against invalid user input
        for (unsigned n = 0; n != DIM; ++n)
        {
            if (! (part.coords[n] >= 0.) || ! (part.coords[n] < period (n)))
            {
                std::cerr << "particle coordinate invalid: 0 <= "
                    << part.coords[n] << " < " << period (n) << " is violated"
                    << ABORT;
            }
        }

        CellData cd;
        encode_coords (cd.coord, part.coords);
        cd.set_tag (part.tag);
        cd.set_disp (part.disp);
        key_t ret = put_encoded_possibly_subdivide (cd);
        ++num_;
        return ret;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
xorpd %xmm0, %xmm0
movsd (%r15,%r14,8), %xmm1
ucomisd %xmm0, %xmm1
jb 0x43a6b8
movsd 0x50(%rbx,%r14,8), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x43a6b8
incq %r14
cmpq $0x2, %r14
jne 0x43a652
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x43a71c
movl 0x18(%r15), %eax
movl %eax, 0x10(%r14)
movups 0x20(%r15), %xmm0
movups %xmm0, 0x18(%r14)
movq 0x30(%r15), %rax
movq %rax, 0x28(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41654c
incq 0x30(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq $0x655aa0, %rdi         # imm = 0x655AA0
leaq 0x1950f6(%rip), %rsi    # 0x5cf7bc
callq 0x4b0650
movsd (%r15,%r14,8), %xmm0
movq %rax, %rdi
callq 0x4b15c0
leaq 0x1950ff(%rip), %rsi    # 0x5cf7df
movq %rax, %rdi
callq 0x4b0650
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x43a60e
movq %r15, %rdi
callq 0x4b15c0
leaq 0x1950de(%rip), %rsi    # 0x5cf7e3
movq %rax, %rdi
callq 0x4b0650
leaq 0x219fd5(%rip), %rsi    # 0x6546e9
movq %rax, %rdi
callq 0x43f8ce
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::encode_coords(unsigned long*, std::array<double, 3ul> const&) const
void encode_coords (uint64_t frac[DIM], const vector <MAX_DIM> &real) const
    {
        unsigned n = 0;
        for (; n != DIM; ++n)
        {
            assert (real[n] >= 0.);
            assert (real[n] < peri_[n]);
            frac[n] = real2frac[n] * real[n];
        }
        for (; n != MAX_DIM; ++n)
            assert (real[n] == 0.);
        // in_use flag
        frac[1] |= 1;
    }

// Assembly:
pushq %rax
xorl %eax, %eax
xorpd %xmm0, %xmm0
movsd 0x1901ff(%rip), %xmm1   # 0x5ca118
movsd (%rdx,%rax,8), %xmm2
ucomisd %xmm0, %xmm2
jb 0x439f75
movsd 0x50(%rdi,%rax,8), %xmm3
ucomisd %xmm2, %xmm3
jbe 0x439f94
mulsd 0x68(%rdi,%rax,8), %xmm2
cvttsd2si %xmm2, %rcx
movq %rcx, %r8
sarq $0x3f, %r8
subsd %xmm1, %xmm2
cvttsd2si %xmm2, %r9
andq %r8, %r9
orq %rcx, %r9
movq %r9, (%rsi,%rax,8)
incq %rax
cmpq $0x2, %rax
jne 0x439f19
movsd 0x10(%rdx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x439fb3
jp 0x439fb3
orb $0x1, 0x8(%rsi)
popq %rax
retq
leaq 0x195874(%rip), %rdi    # 0x5cf7f0
leaq 0x190376(%rip), %rsi    # 0x5ca2f9
leaq 0x195874(%rip), %rcx    # 0x5cf7fe
movl $0x13f, %edx            # imm = 0x13F
callq 0x50b050
leaq 0x1958d6(%rip), %rdi    # 0x5cf871
leaq 0x190357(%rip), %rsi    # 0x5ca2f9
leaq 0x195855(%rip), %rcx    # 0x5cf7fe
movl $0x140, %edx            # imm = 0x140
callq 0x50b050
leaq 0x1958ca(%rip), %rdi    # 0x5cf884
leaq 0x190338(%rip), %rsi    # 0x5ca2f9
leaq 0x195836(%rip), %rcx    # 0x5cf7fe
movl $0x144, %edx            # imm = 0x144
callq 0x50b050
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/io.cpp
// Function: Periods::from_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Periods Periods::from_file (string_ref filename)
{
    Periods periods (MAX_DIM, 0.);
    std::ifstream ifs (filename);
    if (!ifs)
        rt_error ("error opening file: " + filename);
    ifs >> periods[0] >> periods[1];
    if (!ifs)
        goto error;
    ifs >> periods[2] >> std::ws;
    if (ifs.eof ())
        return periods;
error:
    rt_error ("error reading file: " + filename);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x48cb10
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
jne 0x43af47
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x496f40
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x496f40
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
jne 0x43af29
leaq 0x10(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x496f40
movq %rax, %rdi
callq 0x496090
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x48(%rsp,%rax)
je 0x43af29
leaq 0x28(%rsp), %rdi
callq 0x48d840
movq %r14, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
leaq 0x194d65(%rip), %rsi    # 0x5cfc95
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x407c44
leaq 0x8(%rsp), %rdi
callq 0x43f581
leaq 0x194d32(%rip), %rsi    # 0x5cfc80
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x407c44
leaq 0x8(%rsp), %rdi
callq 0x43f581
jmp 0x43af69
jmp 0x43af8b
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43af8e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
jmp 0x43af8e
jmp 0x43af8b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x48d840
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/io.cpp
// Function: Periods::savetxt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Periods::savetxt (string_ref filename)
{
    std::ofstream ofs (filename);
    if (!ofs)
        rt_error ("error opening file: " + filename);
    ofs.precision (15);

    for (double l : *this)
    {
        ofs << l << '\n';
    }

    if (!ofs)
        rt_error ("error writing file: " + filename);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl $0x10, %edx
callq 0x48cc80
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x43b06d
movq $0xf, 0x28(%rsp,%rax)
xorl %r13d, %r13d
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movsd (%r14,%r13), %xmm0
movq %r15, %rdi
callq 0x4b1380
movb $0xa, (%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4b0120
addq $0x8, %r13
cmpq $0x18, %r13
jne 0x43afee
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x43b087
movq $0x64dc08, %rax         # imm = 0x64DC08
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x28(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x20(%rsp,%rcx)
callq 0x48b760
leaq 0x118(%rsp), %rdi
callq 0x492690
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x194c0c(%rip), %rsi    # 0x5cfc80
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x407c44
movq %rsp, %rdi
callq 0x43f581
leaq 0x194c1c(%rip), %rsi    # 0x5cfcaa
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x407c44
movq %rsp, %rdi
callq 0x43f581
jmp 0x43b0a5
jmp 0x43b0c7
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43b0ca
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
jmp 0x43b0ca
jmp 0x43b0c7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x48d700
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/io.cpp
// Function: write_mono_particle_to_stream(std::ostream&, MostGeneralParticle const&, bool)
static
void write_mono_particle_to_stream (std::ostream &os, const MostGeneralParticle &part, bool tagged)
{
    if (MAX_DIM > 3u)
        std::cerr << "DIM>3 is not implemented" << ABORT;

    os << part.coords[0] << ' ' << part.coords[1] << ' ' << part.coords[2];
    
    if (tagged)
        os << ' ' << part.disp[0] << ' ' << part.disp[1] << ' ' << part.disp[2];
        
    os << '\n';

    if (!os)
        throw IoError ();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rsi), %xmm0
callq 0x4b1380
movb $0x20, %r15b
leaq 0x2(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4b0120
movsd 0x8(%r14), %xmm0
movq %rax, %rdi
callq 0x4b1380
leaq 0x3(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4b0120
movsd 0x10(%r14), %xmm0
movq %rax, %rdi
callq 0x4b1380
testl %ebp, %ebp
je 0x43c1a9
leaq 0x4(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4b0120
movsd 0x20(%r14), %xmm0
movq %rax, %rdi
callq 0x4b1380
leaq 0x5(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4b0120
movsd 0x28(%r14), %xmm0
movq %rax, %rdi
callq 0x4b1380
leaq 0x6(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4b0120
movsd 0x30(%r14), %xmm0
movq %rax, %rdi
callq 0x4b1380
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4b0120
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x43c1d7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x443140
leaq 0x20e4c8(%rip), %rsi    # 0x64a6b0
movq %rax, %rdi
xorl %edx, %edx
callq 0x444190
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/paircorrel.cpp
// Function: AbstractCorrelator::savetxt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void AbstractCorrelator::savetxt (string_ref filename)
{
    std::ofstream ofs (filename);
    if (!ofs)
        rt_error ("cannot open file: " + filename);
    savetxt (ofs);
    if (!ofs)
        rt_error ("error writing data: " + filename);
    ofs.close ();
    if (!ofs)
        rt_error ("error writing data (2): " + filename);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl $0x10, %edx
callq 0x48cc80
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x43cb7f
movq (%r14), %rax
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq *0x20(%rax)
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x43cb99
leaq 0x20(%rsp), %rdi
callq 0x48d4d0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x43cbb3
movq $0x64dc08, %rax         # imm = 0x64DC08
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x28(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x20(%rsp,%rcx)
callq 0x48b760
leaq 0x118(%rsp), %rdi
callq 0x492690
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
leaq 0x19325a(%rip), %rsi    # 0x5cfde0
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x407c44
movq %rsp, %rdi
callq 0x43f581
leaq 0x193253(%rip), %rsi    # 0x5cfdf3
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x407c44
movq %rsp, %rdi
callq 0x43f581
leaq 0x19324e(%rip), %rsi    # 0x5cfe08
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x407c44
movq %rsp, %rdi
callq 0x43f581
jmp 0x43cbd5
jmp 0x43cbf7
jmp 0x43cbd5
jmp 0x43cbf7
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43cbfa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
jmp 0x43cbfa
jmp 0x43cbf7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x48d700
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/paircorrel.cpp
// Function: make_correlator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, AbstractStorage*, double, double)
AbstractCorrelator *make_correlator (string_ref attribute, AbstractStorage *stor,
    double bin_width, double rmax)
{
    AbstractCorrelator *ret = Factory <AbstractCorrelator>::make (
        attribute + "/" + stor->typecode ());
    ret->init (stor, bin_width, rmax);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movsd %xmm1, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %rsi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4082fc
leaq 0x19d82f(%rip), %rsi    # 0x5da47c
movq %r14, %rdi
callq 0x4c20e0
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x8(%rsp), %rdi
callq 0x4c1fa0
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x43cc8f
movq %rdx, 0x38(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x48(%rsp)
jmp 0x43cc97
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x38(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x43cd50
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x43ccd2
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x442d20
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x43cce9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
callq *0x10(%rax)
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x43cd31
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x442d20
jmp 0x43cd31
jmp 0x43cd2e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x43cd48
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/paircorrel.cpp
// Function: Correlator<Monodisperse3D>::init(AbstractStorage*, double, double)
virtual void init (AbstractStorage *stor_, double bin_width, double rmax)
    {
        stor_t *stor = downcast (stor_);

        binwid_ = bin_width;

        if (rmax == 0.)
        {
            method_ = "full";
            rmax_ = stor->periods ().min (DIM) / 2;
        }
        else
        {
            method_ = "window";
            assert (rmax > 0.);
            rmax_ = rmax;
        }

        hist_.resize (bin (rmax_) - 1., 0);
        ndata_ = 0;
        walltime_ = 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x43f164
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd %xmm1, 0xbf8(%rbx)
leaq 0xc08(%rbx), %rdi
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq 0xc10(%rbx), %rdx
jne 0x43ec84
jp 0x43ec84
movq %rax, %r14
leaq 0x1b43dd(%rip), %rcx    # 0x5f3009
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4c1580
movq (%r14), %rax
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
seta %al
minsd %xmm0, %xmm1
shll $0x3, %eax
ucomisd 0x10(%r15), %xmm1
movl $0x10, %ecx
cmovbeq %rax, %rcx
movsd 0x18(%rsp,%rcx), %xmm0
mulsd 0x18b46e(%rip), %xmm0   # 0x5ca0f0
jmp 0x43ecac
leaq 0x1911ca(%rip), %rcx    # 0x5cfe55
movl $0x6, %r8d
xorl %esi, %esi
callq 0x4c1580
movsd 0x8(%rsp), %xmm0
ucomisd 0x18b482(%rip), %xmm0   # 0x5ca128
jbe 0x43ed59
movsd %xmm0, 0xc28(%rbx)
leaq 0xc30(%rbx), %r14
divsd 0xbf8(%rbx), %xmm0
callq 0x401140
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
movsd 0x18b43c(%rip), %xmm1   # 0x5ca118
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, %xmm0
punpckldq 0x18b2e8(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x18b2f0(%rip), %xmm0   # 0x5c9ff0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
addsd 0x18b424(%rip), %xmm2   # 0x5ca138
cvttsd2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd %xmm1, %xmm2
cvttsd2si %xmm2, %rsi
andq %rcx, %rsi
orq %rax, %rsi
leaq 0x18(%rsp), %rdx
movq $0x0, (%rdx)
movq %r14, %rdi
callq 0x43d924
xorpd %xmm0, %xmm0
movupd %xmm0, 0xc48(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1910fc(%rip), %rdi    # 0x5cfe5c
leaq 0x1910ff(%rip), %rsi    # 0x5cfe66
leaq 0x191262(%rip), %rcx    # 0x5cffd0
movl $0x24, %edx
callq 0x50b050
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/paircorrel.cpp
// Function: Correlator<Monodisperse2D>::sample(AbstractStorage*, unsigned long)
virtual void sample (AbstractStorage *stor_, size_t multiplier)
    {
        stor_t *stor = downcast (stor_);

        // initialized late since stor might be empty at ctor time
        rho_ = stor->particle_density ();
        ndata_ += multiplier;
        walltime_ -= gclock ();

        for (size_t n1 = 0; n1 != multiplier; ++n1)
        {
            key_t k1 = stor->random_particle (&random);

            if (method_ == "full")
                do_sample (stor, k1, stor->enumerate_all ());
            else // window
                do_sample (stor, k1, stor->enumerate_box (k1, rmax_));
        }

        walltime_ += gclock ();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x43d902
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x30(%rax)
movsd 0x50(%r15), %xmm0
mulsd 0x58(%r15), %xmm0
movq %rax, %xmm1
punpckldq 0x18ca68(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x18ca70(%rip), %xmm1   # 0x5c9ff0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0xc00(%rbx)
addq %r14, 0xc48(%rbx)
callq 0x43f4a4
movq %rbx, 0x8(%rsp)
subq %rax, 0xc50(%rbx)
testq %r14, %r14
je 0x43d660
movq 0x8(%rsp), %rax
leaq 0x28(%rax), %rcx
movq %rcx, 0x10(%rsp)
leaq 0xc08(%rax), %r13
movq 0x8(%rsp), %rbx
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x40e9b8
movq %rax, %rbp
movq %r13, %rdi
leaq 0x1b5a1c(%rip), %rsi    # 0x5f3009
callq 0x4c2b40
testl %eax, %eax
je 0x43d624
movsd 0xc28(%rbx), %xmm0
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x43df76
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x43de70
jmp 0x43d657
movq %r15, 0x28(%rsp)
leaq 0x20ce60(%rip), %rax    # 0x64a490
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x411a46
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x43dd70
decq %r14
jne 0x43d5d3
callq 0x43f4a4
movq 0x8(%rsp), %rcx
addq %rax, 0xc50(%rcx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/paircorrel.cpp
// Function: void Correlator<Monodisperse3D>::do_sample<Storage<Monodisperse3D>::StripGenerator>(Storage<Monodisperse3D>*, unsigned long, Storage<Monodisperse3D>::StripGenerator)
void do_sample (stor_t *stor, key_t k1, GENERATOR g)
    {
        for (; g.not_done (); g.next ())
        {
            key_t k2 = g.key ();
            double r = norm (stor->distance_vector (k1, k2));
            unsigned i = bin (r);
            if (i < hist_.size ())
                ++hist_[i];
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movl 0x68(%rcx), %eax
movq 0x18(%rcx,%rax,8), %rcx
cmpq 0x50(%rbx,%rax,8), %rcx
je 0x43f39a
movq %rsi, %r14
movq %rdi, %r15
leaq 0x98(%rsi), %r12
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax,8), %r13
addq $0x98, %r13
movq 0x8(%rbx), %rax
leaq (%rax,%rax,2), %rax
leaq (%r12,%rax,8), %rax
xorl %ecx, %ecx
movq (%r13,%rcx), %rdx
subq (%rax,%rcx), %rdx
xorps %xmm0, %xmm0
cvtsi2sd %rdx, %xmm0
mulsd 0x80(%r14,%rcx), %xmm0
movsd %xmm0, 0x8(%rsp,%rcx)
addq $0x8, %rcx
cmpq $0x18, %rcx
jne 0x43f2e1
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
divsd 0xbf8(%r15), %xmm0
callq 0x401140
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x18adc4(%rip), %xmm0   # 0x5ca118
cvttsd2si %xmm0, %rdx
sarq $0x3f, %rcx
andl %ecx, %edx
orl %edx, %eax
movq 0xc30(%r15), %rcx
movq 0xc38(%r15), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x43f37f
incq (%rcx,%rax,8)
movq %rbx, %rdi
callq 0x418e86
movl 0x68(%rbx), %eax
movq 0x18(%rbx,%rax,8), %rcx
cmpq 0x50(%rbx,%rax,8), %rcx
jne 0x43f2d3
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::enumerate_box(unsigned long, double)
StripGenerator enumerate_box (key_t whence, double a)
    {
        if (! (a > 0))
            rt_error ("box width negative");
        for (unsigned n = 0; n != DIM; ++n)
            if (a > strip_max_extent (n))
                rt_error ("enumeration box too large / periods too small");
        return StripGenerator (*this, data_[whence].coord, 0, a, -a, a);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
xorpd %xmm1, %xmm1
movapd %xmm0, 0x20(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x43e01f
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x411530
movapd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x43dff8
incl %ebp
cmpl $0x2, %ebp
jne 0x43df9f
shlq $0x4, %r15
leaq (%r14,%r15), %rdx
addq $0x88, %rdx
movaps 0x18c06e(%rip), %xmm1   # 0x5ca040
movaps 0x20(%rsp), %xmm0
xorps %xmm0, %xmm1
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movaps %xmm0, %xmm2
callq 0x41191c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x191eed(%rip), %rsi    # 0x5cfef5
leaq 0x191f13(%rip), %rdx    # 0x5cff22
movq %rsp, %rdi
callq 0x4083fe
movq %rsp, %rdi
callq 0x43f581
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x191eb3(%rip), %rsi    # 0x5cfee2
leaq 0x191ebe(%rip), %rdx    # 0x5cfef4
movq %rsp, %rdi
callq 0x4083fe
movq %rsp, %rdi
callq 0x43f581
jmp 0x43e04a
jmp 0x43e065
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x43e068
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
jmp 0x43e068
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/tools.cpp
// Function: gclock()
uint64_t gclock ()
{
    static uint64_t base = time (0);
    struct timeval tv;
    gettimeofday(&tv, 0);
    return (tv.tv_sec-base) * 1000000ull + tv.tv_usec;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movb 0x215301(%rip), %al     # 0x6547b0
testb %al, %al
je 0x43f4db
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x576740
movq (%rbx), %rax
subq 0x2152de(%rip), %rax    # 0x6547a8
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
addq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
callq 0x40188d
jmp 0x43f4b3
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/tools.cpp
// Function: sigterm_caught()
bool sigterm_caught ()
{
    if (!sigterm_installed)
    {
        sigterm_caught_flag = false;
        sigterm_installed = true;
        signal (SIGTERM, sigterm_handler);
    }

    return sigterm_caught_flag;
}

// Assembly:
cmpb $0x0, 0x2152cf(%rip)    # 0x6547b8
jne 0x43f50f
pushq %rax
movb $0x0, 0x2152c6(%rip)    # 0x6547b9
movb $0x1, 0x2152be(%rip)    # 0x6547b8
leaq 0x15(%rip), %rsi        # 0x43f516
movl $0xf, %edi
callq 0x5112b0
addq $0x8, %rsp
movb 0x2152a4(%rip), %al     # 0x6547b9
retq
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/tools.cpp
// Function: remove_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
bool remove_file (string_ref path, bool ignore_failure)
{
    if (::unlink (path.c_str ()) != 0 && !ignore_failure)
    {
        rt_error ("unlink failed for " + path);
        return false;
    }
    else
    {
        return true;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x57db00
testl %eax, %eax
sete %al
orb %bpl, %al
je 0x43f7a7
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x190a57(%rip), %rsi    # 0x5d0205
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x407c44
movq %r14, %rdi
callq 0x43f581
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43f7e2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/tools.cpp
// Function: hostname[abi:cxx11]()
string hostname ()
{
    char buf[HOST_NAME_MAX+1];
    gethostname (buf, HOST_NAME_MAX);
    buf[HOST_NAME_MAX] = 0;
    return buf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0x40, %esi
movq %r14, %rdi
callq 0x57e1f0
movb $0x0, 0x40(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x401130
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4083fe
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/tools.cpp
// Function: buffer_cerr()
void buffer_cerr ()
{
    // save the original stream buffer in case we need to restore it
    original_cerr_stream.rdbuf (std::cerr.rdbuf ());
    // redirect cerr to cerr_buffer
    std::cerr.rdbuf (cerr_buffer.rdbuf ());
}

// Assembly:
pushq %rbx
movq 0x215257(%rip), %rax    # 0x654b38
leaq 0x215250(%rip), %rdi    # 0x654b38
addq -0x18(%rax), %rdi
movq $0x655aa0, %rbx         # imm = 0x655AA0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rbx,%rax), %rsi
callq 0x4910b0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
leaq 0x214eb3(%rip), %rsi    # 0x6547c8
movq %rbx, %rdi
popq %rbx
jmp 0x4910b0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/tools.cpp
// Function: redirect_cerr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void redirect_cerr (string_ref filename, bool append)
{
    std::ios::openmode mode = std::ios::out;
    if (append)
        mode |= std::ios::app;
    cerr_logfile.open (filename, mode);
    if (!cerr_logfile)
        std::cerr << "cannot open log file " << filename << ABORT;

    // OK, assume the log is open. flush the buffer to the log
    std::cerr.flush ();
    cerr_logfile << cerr_buffer.str ();
    cerr_buffer.str ("");
    // redirect cerr to the log file
    std::cerr.rdbuf (cerr_logfile.rdbuf ());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leal 0x10(%rsi), %edx
leaq 0x215006(%rip), %r14    # 0x654938
movq %r14, %rdi
movq %rbx, %rsi
callq 0x48c380
movq 0x214ff4(%rip), %rax    # 0x654938
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rax,%r14)
jne 0x43fa02
movq $0x655aa0, %rbx         # imm = 0x655AA0
movq %rbx, %rdi
callq 0x4af1f0
leaq 0x214e5e(%rip), %rsi    # 0x6547c8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4b6640
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x214fb3(%rip), %rdi    # 0x654938
callq 0x4b0120
leaq 0x18(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x43f9a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x1b281e(%rip), %rdx    # 0x5f21d2
movq %rdx, %rsi
callq 0x4083fe
leaq 0x214e05(%rip), %rdi    # 0x6547c8
leaq 0x8(%rsp), %rsi
callq 0x4b6ab0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x43f9e4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
movq (%rbx), %rax
addq -0x18(%rax), %rbx
leaq 0x214f4e(%rip), %rsi    # 0x654940
movq %rbx, %rdi
callq 0x4910b0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq $0x655aa0, %rdi         # imm = 0x655AA0
leaq 0x19080b(%rip), %rsi    # 0x5d021b
callq 0x4b0650
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4c30b0
movq %rax, %rdi
callq 0x43f8ce
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0x43fa4d
jmp 0x43fa5a
movq %rax, %rbx
jmp 0x43fa5a
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43fa5a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/tools.cpp
// Function: dont_redirect_cerr()
void dont_redirect_cerr ()
{
    // all in vain.
    std::cerr.flush ();
    original_cerr_stream << cerr_buffer.str ();
    cerr_buffer.str ("");
    // redirect cerr to the log file
    std::cerr.rdbuf (original_cerr_stream.rdbuf ());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq $0x655aa0, %rbx         # imm = 0x655AA0
movq %rbx, %rdi
callq 0x4af1f0
leaq 0x214d47(%rip), %rsi    # 0x6547c8
movq %rsp, %r14
movq %r14, %rdi
callq 0x4b6640
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x21509e(%rip), %r14    # 0x654b38
movq %r14, %rdi
callq 0x4b0120
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x43fabd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rsp, %rdi
movq %r15, (%rdi)
leaq 0x1b2708(%rip), %rdx    # 0x5f21d2
movq %rdx, %rsi
callq 0x4083fe
leaq 0x214cef(%rip), %rdi    # 0x6547c8
movq %rsp, %rsi
callq 0x4b6ab0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x43faf7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq 0x215033(%rip), %rax    # 0x654b38
movq -0x18(%rax), %rax
movq 0xe8(%rax,%r14), %rsi
movq %rbx, %rdi
callq 0x4910b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x43fb47
jmp 0x43fb54
movq %rax, %rbx
jmp 0x43fb54
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43fb54
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/tools.cpp
// Function: int_pop_arg[abi:cxx11](char const**)
static
std::pair <string, string> int_pop_arg (const char **argv)
{
    assert (*argv);
    string kw = *argv++;
    if (!*argv)
        rt_error ("missing argument for kw " + kw);
    return std::make_pair (kw, string (*argv));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x43fcf0
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x4079ce
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x43fd0f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x4079ce
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4082fc
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
leaq 0x18(%rsp), %rcx
movq -0x10(%rcx), %rdx
cmpq %rcx, %rdx
je 0x43fcbe
movq %rdx, 0x20(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rbx)
jmp 0x43fcc4
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rbx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43fce8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x442d20
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x19067f(%rip), %rdi    # 0x5d0376
leaq 0x190562(%rip), %rsi    # 0x5d0260
leaq 0x190677(%rip), %rcx    # 0x5d037c
movl $0x9a, %edx
callq 0x50b050
leaq 0x19069b(%rip), %rsi    # 0x5d03b1
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x407c44
leaq 0x8(%rsp), %rdi
callq 0x43f581
jmp 0x43fd33
jmp 0x43fd53
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43fd56
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
jmp 0x43fd56
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43fd71
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/tools.cpp
// Function: RandomContext::refill_exp_buffer_()
void RandomContext::refill_exp_buffer_ ()
{
    for (int i = 0; i != RANDOM_EXPONENTIAL_BUFFER_SIZE; ++i)
        exp_buffer_[i] = real ();
    for (int i = 0; i != RANDOM_EXPONENTIAL_BUFFER_SIZE; ++i)
        exp_buffer_[i] = -std::log (1-exp_buffer_[i]);
    num_exp_used_ = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x139, %r14d           # imm = 0x139
movq %rbx, %rdi
callq 0x442772
addsd 0x189d0b(%rip), %xmm0   # 0x5ca128
movsd %xmm0, (%rbx,%r14,8)
incq %r14
cmpq $0x179, %r14            # imm = 0x179
jne 0x44040d
xorl %r14d, %r14d
movsd 0x188bde(%rip), %xmm0   # 0x5c9018
subsd 0x9c8(%rbx,%r14,8), %xmm0
callq 0x4ecf00
xorpd 0x189bef(%rip), %xmm0   # 0x5ca040
movlpd %xmm0, 0x9c8(%rbx,%r14,8)
incq %r14
cmpq $0x40, %r14
jne 0x440432
movl $0x0, 0xbc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq