LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::StripGenerator::clip(unsigned long, double)
void clip (key_t active, double end)
        {
            uint64_t whence = stor_->data_[active].coord[direction_];
            uint64_t end_frac = stor_->real2frac[direction_] * end;
            uint64_t new_hi_bound = stor_->cell_ceil (whence + end_frac, direction_);
#ifdef DEBUG
            // check we're not jumping over the end marker.
            for (uint64_t t = new_hi_bound; t != hi_bound_[direction_];
                    t += stor_->cell_stride (direction_))
                assert (t != position_[direction_]);
            assert (lo_bound_[direction_] != new_hi_bound);
#endif
            hi_bound_[direction_] = new_hi_bound;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
shlq $0x4, %rsi
movl 0x50(%rbx), %edx
leaq (%rdi,%rdx,8), %rcx
mulsd 0x68(%rdi,%rdx,8), %xmm0
cvttsd2si %xmm0, %r8
movq %r8, %r9
sarq $0x3f, %r9
subsd 0x1b0b6b(%rip), %xmm0   # 0x5bf1e0
cvttsd2si %xmm0, %rax
andq %r9, %rax
orq %r8, %rax
addq 0x88(%rsi,%rcx), %rax
movq %rax, %rsi
callq 0x40e854
movl 0x50(%rbx), %ecx
movq %rax, 0x40(%rbx,%rcx,8)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::StripGenerator::StripGenerator(Storage<Monodisperse2D> const&, unsigned long*, unsigned int, double, double, double)
StripGenerator (const this_t &stor, uint64_t base[DIM],
            unsigned direction,
            double strip_width, double begin, double end)
            : GeneratorBase (stor)
        {
            direction_ = direction;
            for (unsigned n = 0; n != DIM; ++n)
            {
                uint64_t b, e;
                if (n == direction)
                {
                    b = int64_t (stor_->real2frac[n] * begin);
                    e = stor_->real2frac[n] * end;
                }
                else
                {
                    uint64_t rep_frac = stor_->real2frac[n] * strip_width;
                    b = 0ull - rep_frac;
                    e = rep_frac;
                }

                lo_bound_[n] = stor_->cell_floor (base[n] + b, n);
                hi_bound_[n] = stor_->cell_ceil (base[n] + e, n);
                assert (lo_bound_[n] != hi_bound_[n]);
                position_[n] = lo_bound_[n];
            }

            position_[DIM] = 0;

            GeneratorBase::init (stor_->make_base_key (position_));
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm2, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, 0x10(%rdi)
leaq 0x233ffb(%rip), %rax    # 0x6426f0
movq %rax, (%rdi)
movl %ecx, 0x50(%rdi)
leaq 0x40(%rdi), %rbp
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rsp)
movl %ecx, %r15d
xorl %r12d, %r12d
cmpq $0x2, %r12
je 0x40e7d0
movq 0x10(%rbx), %rdi
cmpq %r12, %r15
jne 0x40e75e
movsd 0x68(%rdi,%r15,8), %xmm0
movapd %xmm0, %xmm1
mulsd 0x18(%rsp), %xmm1
cvttsd2si %xmm1, %rsi
mulsd 0x20(%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1b0a8f(%rip), %xmm0   # 0x5bf1e0
cvttsd2si %xmm0, %r13
andq %rcx, %r13
orq %rax, %r13
jmp 0x40e790
movsd 0x68(%rdi,%r12,8), %xmm0
mulsd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1b0a61(%rip), %xmm0   # 0x5bf1e0
cvttsd2si %xmm0, %r13
andq %rcx, %r13
orq %rax, %r13
movq %r13, %rsi
negq %rsi
addq (%r14,%r12,8), %rsi
movl %r12d, %edx
callq 0x40e81c
movq %rax, 0x30(%rbx,%r12,8)
movq 0x10(%rbx), %rdi
addq (%r14,%r12,8), %r13
movq %r13, %rsi
movl %r12d, %edx
callq 0x40e854
movq %rax, 0x40(%rbx,%r12,8)
movq 0x30(%rbx,%r12,8), %rcx
cmpq %rax, %rcx
je 0x40e7fc
movq %rcx, -0x28(%rbp,%r12,8)
incq %r12
jmp 0x40e70e
andq $0x0, 0x28(%rbx)
movq 0x10(%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0x40e8be
movq %rbx, %rdi
movq %rax, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40e88e
leaq 0x1b12af(%rip), %rdi    # 0x5bfab2
leaq 0x1b0b05(%rip), %rsi    # 0x5bf30f
leaq 0x1b12be(%rip), %rcx    # 0x5bfacf
movl $0x2f8, %edx            # imm = 0x2F8
callq 0x4ffe80
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::cell_floor(unsigned long, unsigned int) const
uint64_t cell_floor (uint64_t frac, unsigned n) const
    {
        assert (n < DIM);
        frac >>= 64 - bc_[n];
        frac <<= 64 - bc_[n];
        return frac;
    }

// Assembly:
cmpl $0x2, %edx
jae 0x40e833
movl %edx, %eax
xorl %ecx, %ecx
subb 0x3c(%rdi,%rax,4), %cl
shrq %cl, %rsi
shlq %cl, %rsi
movq %rsi, %rax
retq
pushq %rax
leaq 0x1b1018(%rip), %rdi    # 0x5bf853
leaq 0x1b0acd(%rip), %rsi    # 0x5bf30f
leaq 0x1b131c(%rip), %rcx    # 0x5bfb65
movl $0xdd, %edx
callq 0x4ffe80
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::make_base_key(unsigned long const*) const
key_t make_base_key (const uint64_t frac[DIM]) const
    {
        uint64_t ret = 0;
        for (unsigned n = 0; n != DIM; ++n)
        {
            assert (bc_[n] > 0);
            ret <<= bc_[n];
            ret |= frac[n] >> (64-bc_[n]);
        }
        return ret << bc_[DIM];
    }

// Assembly:
xorl %edx, %edx
xorl %eax, %eax
cmpq $0x2, %rdx
je 0x40e8de
movl 0x3c(%rdi,%rdx,4), %ecx
testq %rcx, %rcx
je 0x40e8e5
movq (%rsi,%rdx,8), %r8
shldq %cl, %r8, %rax
incq %rdx
jmp 0x40e8c2
movb 0x44(%rdi), %cl
shlq %cl, %rax
retq
pushq %rax
leaq 0x1b13b7(%rip), %rdi    # 0x5bfca4
leaq 0x1b0a1b(%rip), %rsi    # 0x5bf30f
leaq 0x1b13b4(%rip), %rcx    # 0x5bfcaf
movl $0xfd, %edx
callq 0x4ffe80
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::StripGenerator::next_cell()
void next_cell () final
        {
            ++k_;
            if (++position_[DIM] < stor_->planes_in_use_)
                return;
            position_[DIM] = 0;

            unsigned n;
            for (n = DIM-1; n+1u != 0u; --n)
            {
                if (n == direction_)
                    continue;
                position_[n] += stor_->cell_stride (n);
                if (position_[n] != hi_bound_[n])
                    goto recompute;
                position_[n] = lo_bound_[n];
            }

            n = direction_;
            position_[n] += stor_->cell_stride (n);

        recompute:
            k_ = stor_->make_base_key (position_);
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
incq 0x8(%rdi)
movq 0x10(%rdi), %rax
movq 0x28(%rdi), %rcx
incq %rcx
movq %rcx, 0x28(%rdi)
movl 0x48(%rax), %eax
cmpq %rax, %rcx
jb 0x40e9d0
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
andq $0x0, 0x28(%rdi)
pushq $0x1
popq %rbp
movl 0x50(%rbx), %r15d
cmpl $-0x1, %ebp
je 0x40e9af
cmpl %r15d, %ebp
je 0x40e9ab
movq 0x10(%rbx), %rdi
movl %ebp, %esi
callq 0x40eaf0
movl %ebp, %ecx
addq 0x18(%rbx,%rcx,8), %rax
movq %rax, 0x18(%rbx,%rcx,8)
cmpq 0x40(%rbx,%rcx,8), %rax
jne 0x40e9c0
movq 0x30(%rbx,%rcx,8), %rax
movq %rax, 0x18(%rbx,%rcx,8)
decl %ebp
jmp 0x40e975
movq 0x10(%rbx), %rdi
movl %r15d, %esi
callq 0x40eaf0
addq %rax, 0x18(%rbx,%r15,8)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x40e8be
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::get(MostGeneralParticle*, unsigned long) const
void get (MostGeneralParticle *ret, key_t k) const
    {
        assert (k < num_cells_);
        const CellData &cd = data_[k];
        assert (cd.in_use ());
        decode_coords (&ret->coords, cd.coord);
        ret->tag = cd.tag ();
        ret->disp = cd.disp ();
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpq %rdx, 0x28(%rdi)
jbe 0x40ea6c
shlq $0x4, %rdx
testb $0x1, 0x90(%rdi,%rdx)
je 0x40ea8b
movq %rsi, %rbx
addq %rdi, %rdx
addq $0x88, %rdx
callq 0x40eaaa
andl $0x0, 0x18(%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x40dc39
movq 0x10(%r14), %rax
movq %rax, 0x30(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x20(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1b129d(%rip), %rdi    # 0x5bfd10
leaq 0x1b0895(%rip), %rsi    # 0x5bf30f
leaq 0x1b129e(%rip), %rcx    # 0x5bfd1f
movl $0x20b, %edx            # imm = 0x20B
callq 0x4ffe80
leaq 0x1b12ef(%rip), %rdi    # 0x5bfd81
leaq 0x1b0876(%rip), %rsi    # 0x5bf30f
leaq 0x1b127f(%rip), %rcx    # 0x5bfd1f
movl $0x20d, %edx            # imm = 0x20D
callq 0x4ffe80
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::decode_coords(std::array<double, 3ul>*, unsigned long const*) const
void decode_coords (vector <MAX_DIM> *real, const uint64_t frac[DIM]) const
    {
        unsigned n = 0;
        for (; n != DIM; ++n)
            (*real)[n] = frac2real[n] * frac[n];
        for (; n != MAX_DIM; ++n)
            (*real)[n] = 0.;
    }

// Assembly:
xorl %eax, %eax
movsd 0x1b058c(%rip), %xmm0   # 0x5bf040
movapd 0x1b0594(%rip), %xmm1   # 0x5bf050
cmpq $0x2, %rax
je 0x40eaea
movsd (%rdx,%rax,8), %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
subpd %xmm1, %xmm2
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
mulsd 0x78(%rdi,%rax,8), %xmm3
movsd %xmm3, (%rsi,%rax,8)
incq %rax
jmp 0x40eabc
andq $0x0, 0x10(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./tools.hpp
// Function: RandomContext::exponential(double)
inline
double RandomContext::exponential (double scale)
{
    assert (scale > 0.);
#if RANDOM_EXPONENTIAL_BUFFER_SIZE != 0
    if (num_exp_used_ == RANDOM_EXPONENTIAL_BUFFER_SIZE)
        refill_exp_buffer_ ();
    return exp_buffer_[num_exp_used_++] / scale;
#else
    return exponential () / scale;
#endif
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x40eb7d
movq %rdi, %rbx
movl 0xbc8(%rdi), %eax
cmpl $0x40, %eax
jne 0x40eb5f
movq %rbx, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0x43568a
movsd 0x8(%rsp), %xmm1
movl 0xbc8(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xbc8(%rbx)
movl %eax, %eax
movsd 0x9c8(%rbx,%rax,8), %xmm0
divsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1b131a(%rip), %rdi    # 0x5bfe9e
leaq 0x1b131e(%rip), %rsi    # 0x5bfea9
leaq 0x1b1323(%rip), %rcx    # 0x5bfeb5
movl $0x120, %edx            # imm = 0x120
callq 0x4ffe80
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::cell_max_density() const
double cell_max_density () const
    {
        double md = 1.;
        for (unsigned n = 0; n != DIM; ++n)
            md /= cell_width (n);
        return md * cell_count (DIM);
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movsd 0x1af46c(%rip), %xmm0   # 0x5be018
movsd %xmm0, (%rsp)
cmpl $0x2, %ebp
je 0x40ebd2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40e316
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incl %ebp
jmp 0x40ebb1
movq (%rbx), %rax
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq *0x48(%rax)
movq %rax, %xmm0
punpckldq 0x1b0455(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1b045d(%rip), %xmm0   # 0x5bf050
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./adap_prober.hpp
// Function: double AdaptiveProber::random_probe<2ul>(std::array<double, 2ul>*, RandomContext*)
double random_probe (vector <DIM> *ret, RandomContext *random)
    {
        double x = random->real (total_probe_rate ());
        unsigned i = bin_from_quantile (x);

        if (i == 0)
        {
            *ret = random->fromball <DIM> (binrad_[0]);

            // return probe rate
            return binrate_[0];
        }
        else if (i < N_)
        {
            // sample radial distance
            double iexpon = DIM - (1.+binexp_[i]);
            double w_min = pow (binrad_[i]/binrad_[i-1], iexpon);
            double w = 1 - random->real () * (1-w_min);
            double r = binrad_[i-1] * pow (w, 1. / iexpon);

            // add direction
            *ret = random->fromsphere <DIM> (r);

            // return probe rate
            return binrate_[i] * pow (r, -(1.+binexp_[i]));
        }

        std::cerr << "random_probe: impossible" << ABORT;
        return 0.;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x1f8(%rdi), %xmm0
movq %rdx, %rdi
callq 0x4355f4
movq %rbx, %rdi
callq 0x40efc0
testl %eax, %eax
je 0x40ef6c
movl %eax, %r12d
cmpl $0x3f, %eax
ja 0x40ef9d
movl %r12d, %r13d
movsd 0x1af189(%rip), %xmm1   # 0x5be018
movsd 0x400(%rbx,%r13,8), %xmm0
addsd %xmm1, %xmm0
movsd 0x1b0303(%rip), %xmm1   # 0x5bf1a8
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x200(%rbx,%r13,8), %xmm0
decl %r12d
divsd 0x200(%rbx,%r12,8), %xmm0
callq 0x4e1d70
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x4355d2
movsd 0x1af138(%rip), %xmm2   # 0x5be018
movapd %xmm2, %xmm1
subsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
movsd 0x200(%rbx,%r12,8), %xmm1
movsd %xmm1, (%rsp)
movapd %xmm2, %xmm1
divsd 0x8(%rsp), %xmm1
callq 0x4e1d70
mulsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0x435844
movsd %xmm0, (%r14)
movsd %xmm1, 0x8(%r14)
movsd 0x600(%rbx,%r13,8), %xmm0
movsd %xmm0, (%rsp)
movsd 0x1af0d0(%rip), %xmm1   # 0x5be018
addsd 0x400(%rbx,%r13,8), %xmm1
xorpd 0x1b0106(%rip), %xmm1   # 0x5bf060
movsd 0x8(%rsp), %xmm0
callq 0x4e1d70
mulsd (%rsp), %xmm0
jmp 0x40ef8f
movsd 0x200(%rbx), %xmm0
movq %r15, %rdi
callq 0x43595e
movsd %xmm0, (%r14)
movsd %xmm1, 0x8(%r14)
movsd 0x600(%rbx), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1b0fbc(%rip), %rsi    # 0x5bff67
callq 0x4a4910
leaq 0x23e64a(%rip), %rsi    # 0x64d601
movq %rax, %rdi
callq 0x434f95
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse2D>::trunc_periods(Storage<Monodisperse2D>*)
static
    vector_t trunc_periods (stor_t *stor)
    {
        vector_t ret;
        for (size_t n = 0; n != DIM; ++n)
            ret[n] = stor->period (n);
        for (size_t n = DIM; n != MAX_DIM; ++n)
            assert (stor->period (n) == 0.);
        return ret;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x2, %r14
je 0x40f37e
movq %rbx, %rdi
movl %r14d, %esi
callq 0x40e38a
movsd %xmm0, 0x8(%rsp,%r14,8)
incq %r14
jmp 0x40f361
movsd 0x60(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x40f3a3
jp 0x40f3a3
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1b0cfb(%rip), %rdi    # 0x5c00a5
leaq 0x1b0a46(%rip), %rsi    # 0x5bfdf7
leaq 0x1b0d04(%rip), %rcx    # 0x5c00bc
movl $0x14b, %edx            # imm = 0x14B
callq 0x4ffe80
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./tools.hpp
// Function: double fproduct<double const*>(double const*, double const* const&)
double fproduct (ITERATOR begin, const ITERATOR &end)
{
    double prod = 1.;
    while (begin != end)
        prod *= *begin++;
    return prod;
}

// Assembly:
movq (%rsi), %rax
movsd 0x1ae618(%rip), %xmm0   # 0x5be018
cmpq %rax, %rdi
je 0x40fa0f
mulsd (%rdi), %xmm0
addq $0x8, %rdi
jmp 0x40fa00
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Tagged<Monodisperse2D>>::displace(unsigned long, unsigned int, double, unsigned long)
key_t displace (key_t whom, unsigned direction, double distance,
        key_t preserve)
    {
        assert (distance >= 0.);
        CellData moving = pull_encoded (whom);

        moving.coord[direction] += uint64_t (real2frac[direction] * distance);
        moving.add_displacement (direction, distance);
        
        // maintain in_use flag
        moving.coord[1] |= 1;

        if (preserve == whom)
            return put_encoded_possibly_subdivide (moving);

        try
        {
            put_encoded (moving);
            return preserve;
        }
        catch (StorageFull)
        {
            // damage control - we need to resize the cell array,
            // but our caller also needs a valid reference to
            // inext.  pull it out.
            CellData next = pull_encoded (preserve);
            put_encoded_possibly_subdivide (moving);
            return put_encoded_possibly_subdivide (next);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
xorpd %xmm1, %xmm1
movsd %xmm0, 0x8(%rsp)
ucomisd %xmm1, %xmm0
jb 0x412cbd
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x412d38
movl %ebp, %eax
movsd 0x68(%r14,%rax,8), %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
subsd 0x1ac57b(%rip), %xmm1   # 0x5bf1e0
sarq $0x3f, %rdx
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
addq %rsi, 0x10(%rsp,%rax,8)
movq %r12, %rdi
movl %ebp, %esi
callq 0x412db4
orb $0x1, 0x8(%r12)
cmpq %r15, %rbx
jne 0x412ca0
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x412de8
movq %rax, %rbx
jmp 0x412cad
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x412e4c
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ad512(%rip), %rdi    # 0x5c01d6
leaq 0x1ac644(%rip), %rsi    # 0x5bf30f
leaq 0x1adfcc(%rip), %rcx    # 0x5c0c9e
movl $0x233, %edx            # imm = 0x233
callq 0x4ffe80
movq %rax, %r15
cmpl $0x1, %edx
jne 0x412d28
movq %r15, %rdi
callq 0x437fd0
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x412d38
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x412de8
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
callq 0x412de8
movq %rax, %rbx
callq 0x438040
jmp 0x412cad
movq %rax, %r15
callq 0x438040
movq %r15, %rdi
callq 0x4eb220
movq %rax, %rdi
callq 0x4062f8
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::pull_encoded(unsigned long)
CellData pull_encoded (key_t k)
    {
        assert (k < num_cells_);
        assert (data_[k].in_use ());
        CellData cd = data_[k];
        data_[k].clear ();
        return cd;
    }

// Assembly:
pushq %rax
cmpq %rsi, 0x28(%rdi)
jbe 0x40fd2d
shlq $0x4, %rsi
movq 0x90(%rdi,%rsi), %rdx
testb $0x1, %dl
je 0x40fd4c
leaq (%rdi,%rsi), %rcx
addq $0x88, %rcx
movq (%rcx), %rax
andq $0x0, 0x8(%rcx)
popq %rcx
retq
leaq 0x1affdc(%rip), %rdi    # 0x5bfd10
leaq 0x1af5d4(%rip), %rsi    # 0x5bf30f
leaq 0x1b050b(%rip), %rcx    # 0x5c024d
movl $0x16e, %edx            # imm = 0x16E
callq 0x4ffe80
leaq 0x1b054c(%rip), %rdi    # 0x5c029f
leaq 0x1af5b5(%rip), %rsi    # 0x5bf30f
leaq 0x1b04ec(%rip), %rcx    # 0x5c024d
movl $0x16f, %edx            # imm = 0x16F
callq 0x4ffe80
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::put_encoded(Monodisperse2D const&)
key_t put_encoded (const CellData &cd)
    {
        key_t k = make_base_key (cd.coord);
        k = find_spot (k);
        data_[k] = cd;
        return k;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x40e8be
movq %r14, %rdi
movq %rax, %rsi
callq 0x4102da
movq %rax, %rcx
shlq $0x4, %rcx
movups (%rbx), %xmm0
movups %xmm0, 0x88(%r14,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: std::array<double, 2ul> Storage<Monodisperse2D>::to_vector<std::array<double, 2ul>, double (Storage<Monodisperse2D>::*)(unsigned int) const>(double (Storage<Monodisperse2D>::*)(unsigned int) const) const
VECTOR to_vector (PTR_TO_MEMBERFUNC func) const
    {
        VECTOR ret;
        for (unsigned n = 0; n != ret.size (); ++n)
            ret[n] = (this->*func) (n);
        return ret;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq %rdx, %r14
xorl %r15d, %r15d
cmpq $0x2, %r15
je 0x4102a6
movq %rbx, %rax
testb $0x1, %bl
je 0x410293
movq (%r14), %rax
movq -0x1(%rax,%rbx), %rax
movq %r14, %rdi
movl %r15d, %esi
callq *%rax
movsd %xmm0, (%rsp,%r15,8)
incq %r15
jmp 0x41027d
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::find_spot(unsigned long)
key_t find_spot (key_t base_key)
    {
        key_t k = base_key;
        key_t k_end = base_key + planes_in_use_;
        for (; k != k_end; ++k)
            if (!data_[k].in_use ())
                return k;
        if (k < base_key + cell_count (DIM))
        {
            ++planes_in_use_;
            return k;
        }
        throw StorageFull ();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x48(%rdi), %eax
leaq (%rax,%rsi), %rbx
movq %rsi, %rcx
shlq $0x4, %rcx
addq %rdi, %rcx
addq $0x90, %rcx
negq %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x410315
testb $0x1, (%rcx)
je 0x41032f
decq %rdx
addq $0x10, %rcx
jmp 0x410302
movq (%r14), %rax
pushq $0x2
popq %rsi
movq %r14, %rdi
callq *0x48(%rax)
addq %r15, %rax
cmpq %rax, %rbx
jae 0x41033e
incl 0x48(%r14)
jmp 0x410335
subq %rdx, %r15
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rdi
callq 0x437e70
leaq 0x23240b(%rip), %rsi    # 0x642758
movq %rax, %rdi
xorl %edx, %edx
callq 0x438ec0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./tools.hpp
// Function: Histogram::add(double)
void add (double value)
    {
        size_t i = (value-low_) / bin_wid_;
        if (i < size ())
            ++data_[i];
        ++num_sampl_;
    }

// Assembly:
subsd 0x20(%rdi), %xmm0
divsd 0x18(%rdi), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
subsd 0x1aede4(%rip), %xmm0   # 0x5bf1e0
cvttsd2si %xmm0, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x410422
incq (%rcx,%rax,8)
incq 0x28(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./adap_prober.hpp
// Function: double AdaptiveProber::probe_rate<2ul>(std::array<double, 2ul> const&)
double probe_rate (const vector <DIM> &r_)
    {
        double r = norm (r_);
        unsigned i = bin_from_radius (r);
        if (i == 0)
            return binrate_[0];
        else if (i < N_)
            return binrate_[i] * pow (r, -(1.+binexp_[i]));

        std::cerr << "probe_rate: impossible" << ABORT;
        return 0.;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x40d4b6
testl %eax, %eax
je 0x410532
cmpl $0x3f, %eax
ja 0x410540
movl %eax, %eax
movsd 0x400(%rbx,%rax,8), %xmm1
movsd 0x600(%rbx,%rax,8), %xmm0
movsd %xmm0, (%rsp)
addsd 0x1adb00(%rip), %xmm1   # 0x5be018
xorpd 0x1aeb40(%rip), %xmm1   # 0x5bf060
movsd 0x8(%rsp), %xmm0
callq 0x4e1d70
mulsd (%rsp), %xmm0
jmp 0x41053a
movsd 0x600(%rbx), %xmm0
addq $0x10, %rsp
popq %rbx
retq
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1aff9e(%rip), %rsi    # 0x5c04ec
callq 0x4a4910
leaq 0x23d0a7(%rip), %rsi    # 0x64d601
movq %rax, %rdi
callq 0x434f95
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse3D>::reset_statistics()
virtual
    void reset_statistics ()
    {
        walltime = 0;
        all_events.fill (0);
        longrange_events.fill (0);
        chainend_events.fill (0);
        longrange_predicts = shortrange_predicts = 0;
        cumulative_disp.fill (0.);
        cumulative_xdisp.fill (0.);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x24b8(%rdi)
addq $0x24f0, %rdi           # imm = 0x24F0
movq %rsp, %r14
andq $0x0, (%r14)
movq %r14, %rsi
callq 0x414400
leaq 0x2508(%rbx), %rdi
andq $0x0, (%r14)
movq %rsp, %r14
movq %r14, %rsi
callq 0x414400
leaq 0x2520(%rbx), %rdi
andq $0x0, (%r14)
movq %rsp, %r14
movq %r14, %rsi
callq 0x414400
leaq 0x24c0(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x2538(%rbx)
andq $0x0, (%r14)
movq %rsp, %r14
movq %r14, %rsi
callq 0x40b7e4
addq $0x24d8, %rbx           # imm = 0x24D8
andq $0x0, (%r14)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x40b7e4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/jellium4.cpp
// Function: Jellium4<2u, Monodisperse2D>::notify_error_bound(AbstractStorage const*, double)
void notify_error_bound (const AbstractStorage *stor,
        double err_bound)
    {
        if (stor->dimension () != DIM)
            std::cerr << "Wrong dimension in Jellium4" << ABORT;
        if (error_bound == err_bound && periods == stor->periods ())
            return;

        error_bound = err_bound;
        periods = stor->periods ();

        setup_probe_distr (stor);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
cmpl $0x2, %eax
jne 0x417b16
movsd 0x40(%r14), %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jne 0x417ad1
jp 0x417ad1
leaq 0x20(%r14), %r15
movq (%rbx), %rax
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x418168
movsd 0x8(%rsp), %xmm0
testb %al, %al
je 0x417ad5
jmp 0x417b0a
movapd %xmm1, %xmm0
movsd %xmm0, 0x40(%r14)
movq (%rbx), %rax
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movq 0x10(%r15), %rax
movq %rax, 0x30(%r14)
movupd (%r15), %xmm0
movupd %xmm0, 0x20(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x41818e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1aa033(%rip), %rsi    # 0x5c1b57
callq 0x4a4910
leaq 0x235b29(%rip), %rsi    # 0x64d659
movq %rax, %rdi
callq 0x434f95
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./vector.hpp
// Function: bool vector_math_for_std_array::operator==<double, 3ul, Periods>(std::array<double, 3ul> const&, Periods const&)
bool operator== (const std::array <TYPE, DIM> &lhs, const VEC2 &rhs)
    {
        using detail::vector_dimension;
        assert (DIM == vector_dimension (rhs));
        for (size_t n = 0; n != DIM; ++n)
        {
            if (! (lhs[n] == rhs[n]))
                return false;
        }

        return true;
    }

// Assembly:
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x3, %rcx
je 0x418185
movsd (%rdi,%rax,8), %xmm0
leaq 0x1(%rax), %rcx
ucomisd (%rsi,%rax,8), %xmm0
jne 0x418185
jnp 0x41816a
cmpq $0x3, %rax
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/jellium4.cpp
// Function: GridIndices<2> Jellium4<2u, Monodisperse2D>::get_cell_grid<Storage<Monodisperse2D>>(Storage<Monodisperse2D> const&)
static
    GridIndices <DIM> get_cell_grid (const STORAGE &stor)
    {
        std::array <int, DIM> low, high;
        for (size_t n = 0; n != DIM; ++n)
        {
            int c = stor.cell_count (n);
            low[n] = 0 - c/2;
            high[n] = c - c/2;
        }
        return GridIndices <DIM> (low, high);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x2
popq %rbp
cmpq $0x2, %r14
je 0x41857b
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x48(%rax)
movq %rax, %rcx
cltd
idivl %ebp
subl %eax, %ecx
negl %eax
movl %eax, 0x8(%rsp,%r14,4)
movl %ecx, (%rsp,%r14,4)
incq %r14
jmp 0x418551
movq 0x8(%rsp), %rax
movq (%rsp), %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/jellium4.cpp
// Function: GridIndices<2>::begin() const
iterator begin () const
    {
        iterator ret (*this);
        for (size_t n = 0; n != DIM; ++n)
            ret.pos_[n] = low_[n];
        return ret;
    }

// Assembly:
movq %rdi, %rax
movups (%rsi), %xmm0
movups %xmm0, 0x8(%rdi)
xorl %ecx, %ecx
cmpq $0x2, %rcx
je 0x4185c7
movl (%rsi,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x4185b6
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./vector.hpp
// Function: std::array<std::common_type<double, int>::type, 2ul> vector_math_for_std_array::operator/<double, 2ul, int>(std::array<double, 2ul> const&, int const&)
auto operator/ (const std::array <TYPE, DIM> &lhs, const TYPE2 &rhs)
        -> detail::return_array <TYPE, TYPE2, DIM>
    {
        using ret_t = detail::return_array <TYPE, TYPE2, DIM>;
        assert (rhs != 0);
        const typename ret_t::value_type scale = 1./rhs;
        ret_t ret;
        for (size_t n = 0; n != DIM; ++n)
            ret[n] = lhs[n] * scale;
        return ret;
    }

// Assembly:
subq $0x18, %rsp
movl (%rsi), %eax
testl %eax, %eax
je 0x418639
cvtsi2sd %eax, %xmm1
movsd 0x1a5a10(%rip), %xmm0   # 0x5be018
divsd %xmm1, %xmm0
xorl %eax, %eax
cmpq $0x2, %rax
je 0x418628
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp,%rax,8)
incq %rax
jmp 0x41860e
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addq $0x18, %rsp
retq
leaq 0x1a95a3(%rip), %rdi    # 0x5c1be3
leaq 0x1a952c(%rip), %rsi    # 0x5c1b73
leaq 0x1a959e(%rip), %rcx    # 0x5c1bec
pushq $0x7e
popq %rdx
callq 0x4ffe80
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./marsaglia.hpp
// Function: MtwDiscreteSampler<std::array<double, 2ul>>::finish()
void finish ()
    {
        // normalize weights
        weights_total = 0.;
        for (double w : weights)
            weights_total += w;
        if (weights.size () == 0)
            return;

        init_table ();
    }

// Assembly:
andq $0x0, 0x18(%rdi)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm0, %xmm0
movq %rax, %rdx
cmpq %rcx, %rdx
je 0x4188f9
addsd (%rdx), %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x8, %rdx
jmp 0x4188e5
cmpq %rax, %rcx
jne 0x418ac6
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./marsaglia.hpp
// Function: MtwDiscreteSampler<std::array<double, 2ul>>::sample(unsigned long) const
index_t sample (index_t u) const
    {
        for (unsigned n = 0; n != NUM_LEVELS; ++n)
        {
            if (u < tbase[n+1])
            {
                u -= tbase[n];
                u >>= 6 * (NUM_LEVELS-1-n);
                return table[n].at (u);
            }
        }

        std::cerr << "Broken lookup table in MtwDiscreteSampler" << ABORT;
        return 0; // squelch warning
    }

// Assembly:
pushq %rax
leaq 0xb8(%rdi), %rax
addq $0x20, %rdi
pushq $0x1e
popq %rcx
testq %rcx, %rcx
je 0x418fb2
addq $-0x6, %rcx
leaq 0x8(%rax), %rdx
addq $0x18, %rdi
cmpq %rsi, (%rax)
movq %rdx, %rax
jbe 0x418f85
subq -0x10(%rdx), %rsi
andb $-0x2, %cl
shrq %cl, %rsi
callq 0x410562
movq (%rax), %rax
popq %rcx
retq
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1a8de4(%rip), %rsi    # 0x5c1da4
callq 0x4a4910
leaq 0x23468d(%rip), %rsi    # 0x64d659
movq %rax, %rdi
callq 0x434f95
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./vector.hpp
// Function: double LennardJones::lr_event_rate<std::array<double, 2ul>>(std::array<double, 2ul> const&, unsigned long)
auto inner_product (const VEC1 &lhs, const VEC2 &rhs) -> decltype (lhs[0]*rhs[0])
    {
        using type = decltype (lhs[0]*rhs[0]);
        using detail::vector_dimension;
        const size_t size = vector_dimension (lhs);
        assert (size == vector_dimension (rhs));
        if (size == 0)
            return type ();
        type ret = lhs[0]*rhs[0];
        for (size_t i = 1; i != size; ++i)
            ret += lhs[i]*rhs[i];
        return ret;
    }

// Assembly:
movsd (%rsi), %xmm1
movsd 0x8(%rsi), %xmm0
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x8(%rdi), %xmm2
movsd 0x10(%rdi), %xmm1
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
ja 0x424ec1
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm2
mulsd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
ja 0x424eb8
movq %rdx, %r14
movq %rsi, %r15
movsd 0x19a33a(%rip), %xmm1   # 0x5bf1a0
movsd %xmm0, 0x8(%rsp)
callq 0x4e1d70
movsd 0x8(%rsp), %xmm3
movsd 0x19e541(%rip), %xmm2   # 0x5c33c0
mulsd %xmm0, %xmm2
addsd 0x19e53d(%rip), %xmm2   # 0x5c33c8
mulsd (%r15,%r14,8), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm1
jae 0x424eb8
mulsd (%rbx), %xmm2
mulsd %xmm2, %xmm0
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm1, %xmm3
divsd %xmm3, %xmm0
movapd %xmm0, %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./pareto_prober.hpp
// Function: double ParetoProber::random_probe<3ul>(std::array<double, 3ul>*, RandomContext*)
double random_probe (vector <DIM> *ret, RandomContext *random)
    {
        assert (error_bound > 0.);
        double tow = random->real (total_pr);

        // the long-range part is split up into DIM pareto's since we need
        // to expand the (r+error_bound)^(DIM-1) in the numerator.
        // tower sample: which exponent to use
        for (unsigned n = 0; n != DIM; ++n)
            if (tow < towerp[n])
            {
                double r = random->pareto (paralpha0+n,
                    zeroshell_radius-error_bound) + error_bound;
                *ret = random->fromsphere <DIM> (r);
                return pow (r-error_bound, -paralpha0-(DIM-1)-1);
            }

        // zeroshell event
        *ret = random->fromball <DIM> (zeroshell_radius);
        return marginal_rate;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd (%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x422b63
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
movq %rdx, %rdi
callq 0x4355f4
xorl %eax, %eax
cmpq $0x3, %rax
je 0x422abc
movsd 0x28(%rbx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x422aea
incq %rax
jmp 0x422aa5
movsd 0x10(%rbx), %xmm0
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4359c0
movq 0x10(%r12), %rax
movq %rax, 0x10(%r14)
movups (%r12), %xmm0
movups %xmm0, (%r14)
movsd 0x8(%rbx), %xmm0
jmp 0x422b57
movl %eax, %eax
cvtsi2sd %rax, %xmm0
addsd 0x20(%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
subsd (%rbx), %xmm1
movq %r15, %rdi
callq 0x4356fa
addsd (%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x435890
movq 0x10(%r12), %rax
movq %rax, 0x10(%r14)
movups (%r12), %xmm0
movups %xmm0, (%r14)
movsd 0x8(%rsp), %xmm0
subsd (%rbx), %xmm0
movsd 0x19c5f3(%rip), %xmm1   # 0x5bf138
subsd 0x20(%rbx), %xmm1
addsd 0x19c5de(%rip), %xmm1   # 0x5bf130
callq 0x4e1d70
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x19fb81(%rip), %rdi    # 0x5c26eb
leaq 0x19fa9d(%rip), %rsi    # 0x5c260e
leaq 0x1a03d5(%rip), %rcx    # 0x5c2f4d
pushq $0x59
popq %rdx
callq 0x4ffe80
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./pareto_prober.hpp
// Function: double ParetoProber::probe_rate<2ul>(std::array<double, 2ul> const&, unsigned int)
double probe_rate (const vector <DIM> &dist, unsigned direction)
    {
        assert (error_bound > 0.);
        (void)direction;  // not used, we sample azimuth uniformly
        double r = norm (dist);
        double s = fmax (zeroshell_radius, r);
        double ret = pow (s - error_bound, -paralpha0-(DIM-1)-1);
        assert (std::isfinite (ret) || ret == 0);
        return ret;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd (%rdi), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, 0x8(%rsp)
ucomisd %xmm0, %xmm1
jbe 0x41dd40
movq %rdi, %rbx
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm1
movsd 0x10(%rdi), %xmm0
callq 0x4e1c90
subsd 0x8(%rsp), %xmm0
movsd 0x1a1421(%rip), %xmm2   # 0x5bf130
movapd %xmm2, %xmm1
subsd 0x20(%rbx), %xmm1
addsd %xmm2, %xmm1
callq 0x4e1d70
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x41dd59
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1a49a4(%rip), %rdi    # 0x5c26eb
leaq 0x1a48c0(%rip), %rsi    # 0x5c260e
leaq 0x1a4ba8(%rip), %rcx    # 0x5c28fd
pushq $0x70
jmp 0x41dd70
leaq 0x1a4bec(%rip), %rdi    # 0x5c294c
leaq 0x1a48a7(%rip), %rsi    # 0x5c260e
leaq 0x1a4b8f(%rip), %rcx    # 0x5c28fd
pushq $0x75
popq %rdx
callq 0x4ffe80
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/ipl.cpp
// Function: TruncatedIPL::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 == "cutoff")
        {
            assert (value > 0.);
            sr_lr_split = value;
        }
        else if (name == "sr_lr_split")
        {
            rt_error ("Invalid parameter sr_lr_split for truncated IPL");
        }
        else
        {
            PowerLawInteraction::set_parameter (name, value);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1a2433(%rip), %rsi    # 0x5c2bc3
movq %r14, %rdi
callq 0x406081
testb %al, %al
je 0x4207b9
xorpd %xmm0, %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4207e4
movsd %xmm1, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x19da38(%rip), %rsi    # 0x5be1f8
movq %r14, %rdi
callq 0x406081
testb %al, %al
jne 0x420801
movq %rbx, %rdi
movq %r14, %rsi
movsd 0x10(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
jmp 0x40b46e
leaq 0x1a23df(%rip), %rdi    # 0x5c2bca
leaq 0x1a23e3(%rip), %rsi    # 0x5c2bd5
leaq 0x1a23e4(%rip), %rcx    # 0x5c2bdd
pushq $0xe
popq %rdx
callq 0x4ffe80
leaq 0x1a240a(%rip), %rsi    # 0x5c2c12
leaq 0x18(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x406046
movq %rbx, %rdi
callq 0x434d5b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/ipl.cpp
// Function: double IPL::lr_event_rate<std::array<double, 3ul>>(std::array<double, 3ul> const&, unsigned int)
double lr_event_rate (const VECTOR &dist, unsigned direction)
    {
        double rsq = norm_sq (dist);
        if (rsq < sq (sr_lr_split))
            return 0.;
        double rate = unit_directional_derivative (dist[direction], rsq);
        if (rate <= 0.)
            return 0.;
        else
            return stren * rate;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x40e17c
movapd %xmm0, %xmm2
movsd 0x18(%rbx), %xmm1
mulsd %xmm1, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm1
ja 0x422a67
movl %ebp, %eax
movsd (%r14,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rbx), %xmm1
addsd 0x19c76e(%rip), %xmm1   # 0x5bf1a8
mulsd 0x19c756(%rip), %xmm1   # 0x5bf198
movapd %xmm2, %xmm0
callq 0x4e1d70
mulsd 0x8(%rsp), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
cmpnlesd %xmm2, %xmm0
andpd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./lj.hpp
// Function: LennardJones::LennardJones()
LennardJones ()
    {
        strength = 1.;
        sr_lr_split = 1.;
        scale = 2.;
        set_parameter ("cutoff", INFINITY);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x40(%rdi)
movaps 0x19bd6f(%rip), %xmm0   # 0x5bf030
movups %xmm0, (%rdi)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, 0x10(%rdi)
leaq 0x19f8ea(%rip), %rsi    # 0x5c2bc3
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x406046
movsd 0x1a008d(%rip), %xmm0   # 0x5c3380
movq %rbx, %rdi
movq %r14, %rsi
callq 0x424144
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./lj.hpp
// Function: LennardJones::notify_error_bound(AbstractStorage const*, double)
void notify_error_bound (const AbstractStorage *stor, double err_bound)
    {
        if (prober.error_bound != err_bound)
        {
            prober.error_bound = err_bound;
            prober.setup (sr_lr_split * scale, 6., stor->dimension ());
            std::cerr << "total_probe_rate " << total_probe_rate (0) << "\n";
        }
    }

// Assembly:
movsd 0x40(%rdi), %xmm1
ucomisd %xmm0, %xmm1
jne 0x4244bf
jnp 0x42453c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
movsd %xmm0, 0x40(%rdi)
movsd 0x8(%rdi), %xmm0
mulsd 0x10(%rdi), %xmm0
movsd %xmm0, (%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
movsd 0x19eea9(%rip), %xmm1   # 0x5c3398
movq %r14, %rdi
movsd (%rsp), %xmm0
movl %eax, %esi
callq 0x41d250
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x19b9f5(%rip), %rsi    # 0x5bff01
callq 0x4a4910
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x424ba8
movq %r14, %rdi
callq 0x4a5640
leaq 0x1abedd(%rip), %rsi    # 0x5d040a
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4a4910
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./lj.hpp
// Function: LennardJones::random_sr_repulsion(double, RandomContext*)
double random_sr_repulsion (double rsq_, RandomContext *random)
    {
        double rsq = fmin (rsq_ / sq (scale), sq (rep_cutoff));

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

        // invert the LJ potential, picking the solution in repulsive region
        // FIXME look at corner cases
        double rsix = .5 + sqrt (.25 + e_evt);
        double rsq_evt = pow (rsix, -1./3);
        assert (rsq_evt <= sq (rep_cutoff));

        return rsq_evt * sq (scale) - rsq_;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm2
movsd 0x20(%rdi), %xmm1
mulsd %xmm2, %xmm2
movsd %xmm0, 0x8(%rsp)
divsd %xmm2, %xmm0
mulsd %xmm1, %xmm1
callq 0x4e1ce0
movsd 0x19a55c(%rip), %xmm1   # 0x5bf1a0
callq 0x4e1d70
movsd 0x19a4df(%rip), %xmm1   # 0x5bf130
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd (%rbx), %xmm0
movq %r14, %rdi
callq 0x40eb24
addsd 0x10(%rsp), %xmm0
addsd 0x19e727(%rip), %xmm0   # 0x5c33a0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x424c89
sqrtsd %xmm0, %xmm0
jmp 0x424c8e
callq 0x4e1e90
addsd 0x19a462(%rip), %xmm0   # 0x5bf0f8
movsd 0x19e70a(%rip), %xmm1   # 0x5c33a8
callq 0x4e1d70
movsd 0x20(%rbx), %xmm1
mulsd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jb 0x424ccd
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm1, %xmm0
subsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x19e7db(%rip), %rdi    # 0x5c34af
leaq 0x19e7ef(%rip), %rsi    # 0x5c34ca
leaq 0x19e7f1(%rip), %rcx    # 0x5c34d3
pushq $0x73
popq %rdx
callq 0x4ffe80
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./lj.hpp
// Function: LennardJones::random_sr_attraction(double, RandomContext*)
double random_sr_attraction (double rsq_, RandomContext *random)
    {
        double rsq = fmax (rsq_ / sq (scale), sq (LJ_MINIMUM));

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

        if (e_evt >= lj_at_cutoff)
            return ESCAPES_TO_INFINITY ();

        // invert the LJ potential, picking the solution in attractive region
        // FIXME look at corner cases
        double rsix = .5 - sqrt (.25 + e_evt);
        double rsq_evt = pow (rsix, -1./3);
        assert (rsq_evt <= sq (attr_cutoff) && rsq_evt >= sq (LJ_MINIMUM));

        return rsq_evt * sq (scale) - rsq_;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm1
mulsd %xmm1, %xmm1
movsd %xmm0, 0x8(%rsp)
divsd %xmm1, %xmm0
maxsd 0x19e69e(%rip), %xmm0   # 0x5c33b0
movsd 0x19a486(%rip), %xmm1   # 0x5bf1a0
callq 0x4e1d70
movsd 0x19a409(%rip), %xmm1   # 0x5bf130
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd (%rbx), %xmm0
movq %r14, %rdi
callq 0x40eb24
addsd 0x10(%rsp), %xmm0
ucomisd 0x30(%rbx), %xmm0
jae 0x424d66
addsd 0x19e64a(%rip), %xmm0   # 0x5c33a0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x424d70
sqrtsd %xmm0, %xmm0
jmp 0x424d75
movsd 0x19e64a(%rip), %xmm0   # 0x5c33b8
jmp 0x424dbe
callq 0x4e1e90
movsd 0x19a37b(%rip), %xmm2   # 0x5bf0f8
subsd %xmm0, %xmm2
movsd 0x19e61f(%rip), %xmm1   # 0x5c33a8
movapd %xmm2, %xmm0
callq 0x4e1d70
ucomisd 0x19e616(%rip), %xmm0   # 0x5c33b0
jb 0x424dc6
movsd 0x28(%rbx), %xmm1
mulsd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jb 0x424dc6
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm1, %xmm0
subsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x19e748(%rip), %rdi    # 0x5c3515
leaq 0x19e6f6(%rip), %rsi    # 0x5c34ca
leaq 0x19e774(%rip), %rcx    # 0x5c354f
movl $0x88, %edx
callq 0x4ffe80
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./lj.hpp
// Function: double LennardJones::lr_event_rate<std::array<double, 3ul>>(std::array<double, 3ul> const&, unsigned long)
double lr_event_rate (const VECTOR &r, size_t direction)
    {
        double rsq = norm_sq (r) / sq (scale);

        if (rsq < sq (sr_lr_split) || rsq > sq (cutoff))
            return 0.;

        double rsix = pow (rsq, -3.);
        double rate = (12.*rsix - 6.) * r[direction];

        if (rate <= 0.)
            return 0.;
        else
            return rate * strength * rsix / (scale * scale * rsq);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x40e17c
movsd 0x8(%rbx), %xmm2
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
ja 0x4289d9
movsd 0x18(%rbx), %xmm2
mulsd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
ja 0x4289d9
movsd 0x196819(%rip), %xmm1   # 0x5bf1a0
movsd %xmm0, 0x8(%rsp)
callq 0x4e1d70
movsd 0x8(%rsp), %xmm3
movsd 0x19aa20(%rip), %xmm2   # 0x5c33c0
mulsd %xmm0, %xmm2
addsd 0x19aa1c(%rip), %xmm2   # 0x5c33c8
mulsd (%r15,%r14,8), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm1
jae 0x4289d9
mulsd (%rbx), %xmm2
mulsd %xmm2, %xmm0
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm1, %xmm3
divsd %xmm3, %xmm0
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::LennardJonesGauss()
LennardJonesGauss ()
    {
        inv_temperature = 5;
        gauss_epsilon = 1.8;
        gauss_r0 = 1.52;
        gauss_sigma_sq = .02;
        set_parameter ("cutoff", 3.6);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movaps 0x19adb7(%rip), %xmm0   # 0x5c3e20
movups %xmm0, (%rdi)
movaps 0x19adbd(%rip), %xmm0   # 0x5c3e30
movups %xmm0, 0x10(%rdi)
leaq 0x199b45(%rip), %rsi    # 0x5c2bc3
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x406046
movsd 0x19ada8(%rip), %xmm0   # 0x5c3e40
movq %rbx, %rdi
movq %r14, %rsi
callq 0x429d8c
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220