LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::enumerate_strip(unsigned long, unsigned int, double, double, double)
StripGenerator enumerate_strip (key_t whence, unsigned direction,
        double strip_width, double begin, double end)
    {
        if (2*cell_diagonal () + 2*strip_width >= period (direction))
            rt_error ("sr_lr_split too large / periods too small");
        if (fabs (end) > strip_max_extent (direction))
            rt_error ("strip too long (this should not happen)");

        return StripGenerator (*this, data_[whence].coord, direction,
            strip_width, begin, end);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movaps %xmm2, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm1, %xmm1
xorl %r12d, %r12d
movsd %xmm1, 0x30(%rsp)
movq %r14, %rdi
movl %r12d, %esi
callq 0x4114cc
movsd 0x30(%rsp), %xmm1
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incl %r12d
cmpl $0x2, %r12d
jne 0x4115df
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x41161a
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x411623
movapd %xmm1, %xmm0
callq 0x4ed060
cmpl $0x3, %ebp
movapd 0x50(%rsp), %xmm2
jae 0x4116bc
movsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movl %ebp, %eax
ucomisd 0x50(%r14,%rax,8), %xmm0
jae 0x4116db
movapd 0x1b8a05(%rip), %xmm0   # 0x5ca060
andpd %xmm2, %xmm0
movapd %xmm0, 0x30(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x411530
movapd 0x30(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x411706
shlq $0x4, %r15
leaq (%r14,%r15), %rdx
addq $0x88, %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movsd 0x8(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movaps 0x50(%rsp), %xmm2
callq 0x41191c
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b91b6(%rip), %rdi    # 0x5ca879
leaq 0x1b8c2f(%rip), %rsi    # 0x5ca2f9
leaq 0x1b91b8(%rip), %rcx    # 0x5ca889
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x50b050
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b92fd(%rip), %rsi    # 0x5ca9e8
leaq 0x1b931f(%rip), %rdx    # 0x5caa11
leaq 0x10(%rsp), %rdi
callq 0x4083fe
leaq 0x10(%rsp), %rdi
callq 0x43f581
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1b92fc(%rip), %rsi    # 0x5caa12
leaq 0x1b931c(%rip), %rdx    # 0x5caa39
leaq 0x10(%rsp), %rdi
callq 0x4083fe
leaq 0x10(%rsp), %rdi
callq 0x43f581
jmp 0x411735
jmp 0x411751
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x411754
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x442d20
jmp 0x411754
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./ecmc.hpp
// Function: double ChainRunner<Jellium3, Monodisperse2D>::norm_ortho_sq<2ul>(std::array<double, 2ul> const&, unsigned long)
static
    double norm_ortho_sq (const vector <DIM> &v, size_t skip)
    {
        assert (skip < DIM);
        double ret = 0.;
        for (size_t i = 0; i != DIM; ++i)
        {
            if (i != skip)
                ret += v[i]*v[i];
        }
        return ret;
    }

// Assembly:
cmpq $0x1, %rsi
ja 0x411796
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq %rax, %rsi
je 0x41178c
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x2, %rax
jne 0x41177a
retq
pushq %rax
leaq 0x1b956f(%rip), %rdi    # 0x5cad0d
leaq 0x1b9573(%rip), %rsi    # 0x5cad18
leaq 0x1b9577(%rip), %rcx    # 0x5cad23
movl $0x16a, %edx            # imm = 0x16A
callq 0x50b050
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl 0x50(%rdi), %eax
cmpq $0x2, %rax
jae 0x4118a3
movq 0x10(%rdi), %rdx
shlq $0x4, %rsi
leaq (%rdx,%rax,8), %rcx
mulsd 0x68(%rdx,%rax,8), %xmm0
cvttsd2si %xmm0, %r8
movq %r8, %r9
sarq $0x3f, %r9
subsd 0x1b889d(%rip), %xmm0   # 0x5ca118
cvttsd2si %xmm0, %r10
andq %r9, %r10
orq %r8, %r10
addq 0x88(%rsi,%rcx), %r10
xorl %ecx, %ecx
subb 0x3c(%rdx,%rax,4), %cl
shrq %cl, %r10
incq %r10
shlq %cl, %r10
movq %r10, 0x40(%rdi,%rax,8)
retq
pushq %rax
leaq 0x1b8f6b(%rip), %rdi    # 0x5ca816
leaq 0x1b8a47(%rip), %rsi    # 0x5ca2f9
leaq 0x1b9234(%rip), %rcx    # 0x5caaed
movl $0xe5, %edx
callq 0x50b050
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, 0x10(%rdi)
leaq 0x237dce(%rip), %rax    # 0x649700
movq %rax, (%rdi)
movl %ecx, 0x50(%rdi)
leaq 0x3c(%rsi), %rdi
leaq 0x40(%rbx), %r8
leaq 0x18(%rbx), %rax
movl %ecx, %r9d
leaq (,%r9,4), %r10
movsd 0x1b87c1(%rip), %xmm3   # 0x5ca118
xorl %r11d, %r11d
cmpq %r11, %r10
jne 0x411994
movsd 0x68(%rsi,%r9,8), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm1, %xmm5
cvttsd2si %xmm5, %r14
mulsd %xmm2, %xmm4
cvttsd2si %xmm4, %rcx
movq %rcx, %r12
sarq $0x3f, %r12
subsd %xmm3, %xmm4
cvttsd2si %xmm4, %r15
andq %r12, %r15
orq %rcx, %r15
jmp 0x4119c0
movsd 0x2c(%rdi,%r11,2), %xmm4
mulsd %xmm0, %xmm4
cvttsd2si %xmm4, %rcx
movq %rcx, %r14
sarq $0x3f, %r14
subsd %xmm3, %xmm4
cvttsd2si %xmm4, %r15
andq %r14, %r15
orq %rcx, %r15
movq %r15, %r14
negq %r14
addq (%rdx,%r11,2), %r14
xorl %ecx, %ecx
subb (%rdi,%r11), %cl
shrq %cl, %r14
shlq %cl, %r14
movq %r14, -0x10(%r8,%r11,2)
addq (%rdx,%r11,2), %r15
shrq %cl, %r15
incq %r15
shlq %cl, %r15
movq %r15, (%r8,%r11,2)
cmpq %r15, %r14
je 0x411a27
movq %r14, -0x28(%r8,%r11,2)
addq $0x4, %r11
cmpq $0x8, %r11
jne 0x41195a
movq $0x0, 0x28(%rbx)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x411aa6
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x411a46
leaq 0x1b900c(%rip), %rdi    # 0x5caa3a
leaq 0x1b88c4(%rip), %rsi    # 0x5ca2f9
leaq 0x1b901b(%rip), %rcx    # 0x5caa57
movl $0x2f8, %edx            # imm = 0x2F8
callq 0x50b050
// File: /workspace/github_cpp_makefile_star2_O3/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
movl 0x3c(%rdi,%rdx,4), %ecx
testq %rcx, %rcx
je 0x411acb
movq (%rsi,%rdx,8), %r8
shldq %cl, %r8, %rax
incq %rdx
cmpq $0x2, %rdx
jne 0x411aaa
movb 0x44(%rdi), %cl
shlq %cl, %rax
retq
pushq %rax
leaq 0x1b90f2(%rip), %rdi    # 0x5cabc5
leaq 0x1b881f(%rip), %rsi    # 0x5ca2f9
leaq 0x1b90ef(%rip), %rcx    # 0x5cabd0
movl $0xfd, %edx
callq 0x50b050
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
incq 0x8(%rdi)
movq 0x10(%rdi), %rdi
movq 0x28(%rbx), %rax
incq %rax
movq %rax, 0x28(%rbx)
movl 0x48(%rdi), %ecx
cmpq %rcx, %rax
jb 0x411bc2
leaq 0x18(%rbx), %rsi
movq $0x0, 0x28(%rbx)
movl 0x50(%rbx), %eax
leaq -0x4(,%rax,4), %rdx
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x411b98
movb 0x40(%rdi,%r8), %r9b
xorl %ecx, %ecx
subb %r9b, %cl
movl $0x1, %r9d
shlq %cl, %r9
addq 0x20(%rbx,%r8,2), %r9
movq %r9, 0x20(%rbx,%r8,2)
cmpq 0x48(%rbx,%r8,2), %r9
jne 0x411bb9
movq 0x38(%rbx,%r8,2), %rcx
movq %rcx, 0x20(%rbx,%r8,2)
addq $-0x4, %r8
cmpq $-0x8, %r8
jne 0x411b65
cmpl $0x2, %eax
jae 0x411bc4
xorl %ecx, %ecx
subb 0x3c(%rdi,%rax,4), %cl
movl $0x1, %edx
shlq %cl, %rdx
addq %rdx, (%rsi,%rax,8)
callq 0x411aa6
movq %rax, 0x8(%rbx)
popq %rbx
retq
leaq 0x1b8c4b(%rip), %rdi    # 0x5ca816
leaq 0x1b8727(%rip), %rsi    # 0x5ca2f9
leaq 0x1b90d6(%rip), %rcx    # 0x5cacaf
movl $0xd7, %edx
callq 0x50b050
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Tagged<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 %rax
cmpq %rdx, 0x28(%rdi)
jbe 0x4159b2
leaq (%rdx,%rdx,2), %rax
shlq $0x4, %rax
testb $0x1, 0x90(%rdi,%rax)
je 0x4159d1
addq %rdi, %rax
addq $0x88, %rax
xorl %ecx, %ecx
movsd 0x1b4682(%rip), %xmm0   # 0x5c9fe0
movapd 0x1b468a(%rip), %xmm1   # 0x5c9ff0
movsd (%rax,%rcx,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,%rcx,8), %xmm3
movsd %xmm3, (%rsi,%rcx,8)
incq %rcx
cmpq $0x2, %rcx
jne 0x415966
movq $0x0, 0x10(%rsi)
movl 0x10(%rax), %ecx
movl %ecx, 0x18(%rsi)
movups 0x18(%rax), %xmm0
movups %xmm0, 0x20(%rsi)
movq 0x28(%rax), %rax
movq %rax, 0x30(%rsi)
popq %rax
retq
leaq 0x1b5278(%rip), %rdi    # 0x5cac31
leaq 0x1b4939(%rip), %rsi    # 0x5ca2f9
leaq 0x1b5e4e(%rip), %rcx    # 0x5cb815
movl $0x20b, %edx            # imm = 0x20B
callq 0x50b050
leaq 0x1b52ca(%rip), %rdi    # 0x5caca2
leaq 0x1b491a(%rip), %rsi    # 0x5ca2f9
leaq 0x1b5e2f(%rip), %rcx    # 0x5cb815
movl $0x20d, %edx            # imm = 0x20D
callq 0x50b050
// File: /workspace/github_cpp_makefile_star2_O3/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
movsd 0x1b736a(%rip), %xmm0   # 0x5c9018
movsd %xmm0, (%rsp)
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4114cc
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incl %ebp
cmpl $0x2, %ebp
jne 0x411cb5
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x2, %esi
callq *0x48(%rax)
movq %rax, %xmm0
punpckldq 0x1b82f1(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1b82f9(%rip), %xmm0   # 0x5c9ff0
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_O3/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 0x440344
movq %rbx, %rdi
callq 0x4120be
testl %eax, %eax
je 0x41206a
movl %eax, %r12d
cmpl $0x3f, %eax
ja 0x41209b
movl %r12d, %r13d
movsd 0x1b708b(%rip), %xmm1   # 0x5c9018
movsd 0x400(%rbx,%r13,8), %xmm0
addsd %xmm1, %xmm0
movsd 0x1b820d(%rip), %xmm1   # 0x5ca1b0
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x200(%rbx,%r13,8), %xmm0
decl %r12d
divsd 0x200(%rbx,%r12,8), %xmm0
callq 0x4ecf40
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x440334
movsd 0x1b703a(%rip), %xmm2   # 0x5c9018
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 0x4ecf40
mulsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0x4405a2
movsd %xmm0, (%r14)
movsd %xmm1, 0x8(%r14)
movsd 0x600(%rbx,%r13,8), %xmm0
movsd %xmm0, (%rsp)
movsd 0x1b6fd2(%rip), %xmm1   # 0x5c9018
addsd 0x400(%rbx,%r13,8), %xmm1
xorpd 0x1b7fe8(%rip), %xmm1   # 0x5ca040
movsd 0x8(%rsp), %xmm0
callq 0x4ecf40
mulsd (%rsp), %xmm0
jmp 0x41208d
movsd 0x200(%rbx), %xmm0
movq %r15, %rdi
callq 0x4406b8
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 $0x655aa0, %rdi         # imm = 0x655AA0
leaq 0x1b8ddf(%rip), %rsi    # 0x5cae88
callq 0x4b0650
leaq 0x24254c(%rip), %rsi    # 0x654601
movq %rax, %rdi
callq 0x43f8ce
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x68, %rsp
xorpd %xmm1, %xmm1
movsd %xmm0, (%rsp)
ucomisd %xmm1, %xmm0
jb 0x41642a
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4164c8
movl %ebp, %eax
movsd 0x68(%r14,%rax,8), %xmm0
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x1b3d86(%rip), %xmm0   # 0x5ca118
cvttsd2si %xmm0, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
addq %rsi, 0x8(%rsp,%rax,8)
cmpl $0x3, %ebp
jae 0x416449
addsd 0x20(%rsp,%rax,8), %xmm1
movsd %xmm1, 0x20(%rsp,%rax,8)
orb $0x1, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
cmpq %r15, %rbx
jne 0x4163d3
movq %r14, %rdi
callq 0x41654c
movq %rax, %rbx
jmp 0x41641c
movq %r14, %rdi
callq 0x4157f0
movq %r14, %rdi
movq %rax, %rsi
callq 0x416b7c
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movupd 0x8(%rsp), %xmm0
movupd 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0xa8(%r14,%rax)
movupd %xmm1, 0x98(%r14,%rax)
movupd %xmm0, 0x88(%r14,%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b4cc6(%rip), %rdi    # 0x5cb0f7
leaq 0x1b3ec1(%rip), %rsi    # 0x5ca2f9
leaq 0x1b5709(%rip), %rcx    # 0x5cbb48
movl $0x233, %edx            # imm = 0x233
callq 0x50b050
leaq 0x1b57d2(%rip), %rdi    # 0x5cbc22
leaq 0x1b3ea2(%rip), %rsi    # 0x5ca2f9
leaq 0x1b57d8(%rip), %rcx    # 0x5cbc36
movl $0xa3, %edx
callq 0x50b050
movq %rax, %r15
cmpl $0x1, %edx
jne 0x4164b7
movq %r15, %rdi
callq 0x4432a0
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4164c8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x41654c
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x41654c
movq %rax, %rbx
callq 0x443310
jmp 0x41641c
movq %rax, %r15
callq 0x443310
movq %r15, %rdi
callq 0x4f63f0
movq %rax, %rdi
callq 0x407d31
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x412e14
shlq $0x4, %rsi
movq 0x90(%rdi,%rsi), %rdx
testb $0x1, %dl
je 0x412e33
leaq (%rdi,%rsi), %rcx
addq $0x88, %rcx
movq (%rcx), %rax
movq $0x0, 0x8(%rcx)
popq %rcx
retq
leaq 0x1b7e16(%rip), %rdi    # 0x5cac31
leaq 0x1b74d7(%rip), %rsi    # 0x5ca2f9
leaq 0x1b8345(%rip), %rcx    # 0x5cb16e
movl $0x16e, %edx            # imm = 0x16E
callq 0x50b050
leaq 0x1b8386(%rip), %rdi    # 0x5cb1c0
leaq 0x1b74b8(%rip), %rsi    # 0x5ca2f9
leaq 0x1b8326(%rip), %rcx    # 0x5cb16e
movl $0x16f, %edx            # imm = 0x16F
callq 0x50b050
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::put_encoded_possibly_subdivide(Monodisperse2D const&)
key_t put_encoded_possibly_subdivide (const CellData &cd)
    {
        try
        {
            return put_encoded (cd);
        }
        catch (StorageFull)
        {
            subdivide ();
            return put_encoded_possibly_subdivide (cd);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x411aa6
movq %r14, %rdi
movq %rax, %rsi
callq 0x4133c0
movq %rax, %r15
shlq $0x4, %rax
movups (%rbx), %xmm0
movups %xmm0, 0x88(%r14,%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
cmpl $0x1, %edx
jne 0x412ec0
movq %r15, %rdi
callq 0x4432a0
movq %r14, %rdi
xorl %esi, %esi
callq 0x412ed0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x412e52
movq %rax, %r15
callq 0x443310
jmp 0x412e80
movq %rax, %r15
callq 0x443310
movq %r15, %rdi
callq 0x4f63f0
movq %rax, %rdi
callq 0x407d31
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rsi, %rbx
testq %rax, %rax
je 0x413402
leaq (%rax,%r15), %rbx
negq %rax
movq %r15, %rcx
shlq $0x4, %rcx
leaq (%rcx,%r14), %rdx
addq $0x90, %rdx
xorl %ecx, %ecx
testb $0x1, (%rdx)
je 0x41341e
decq %rcx
addq $0x10, %rdx
cmpq %rcx, %rax
jne 0x4133f1
movq (%r14), %rax
movq %r14, %rdi
movl $0x2, %esi
callq *0x48(%rax)
addq %r15, %rax
cmpq %rax, %rbx
jae 0x41342d
incl 0x48(%r14)
jmp 0x413424
subq %rcx, %r15
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %edi
callq 0x443140
leaq 0x23632a(%rip), %rsi    # 0x649768
movq %rax, %rdi
xorl %edx, %edx
callq 0x444190
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
leaq 0x200(%rdi), %rcx
movl $0x40, %esi
movq %rcx, %rax
movq %rsi, %rdx
shrq %rdx
ucomisd (%rax,%rdx,8), %xmm0
jbe 0x4135af
leaq (%rax,%rdx,8), %rax
addq $0x8, %rax
notq %rdx
addq %rsi, %rdx
movq %rdx, %rsi
testq %rdx, %rdx
jg 0x413597
subq %rcx, %rax
shrq $0x3, %rax
testl %eax, %eax
je 0x4135fd
cmpl $0x3f, %eax
ja 0x413607
andl $0x3f, %eax
movsd 0x400(%rdi,%rax,8), %xmm1
movsd 0x600(%rdi,%rax,8), %xmm2
movsd %xmm2, (%rsp)
addsd 0x1b5a2f(%rip), %xmm1   # 0x5c9018
xorpd 0x1b6a4f(%rip), %xmm1   # 0x5ca040
callq 0x4ecf40
mulsd (%rsp), %xmm0
jmp 0x413605
movsd 0x600(%rdi), %xmm0
popq %rax
retq
movq $0x655aa0, %rdi         # imm = 0x655AA0
leaq 0x1b7df8(%rip), %rsi    # 0x5cb40d
callq 0x4b0650
leaq 0x240fe0(%rip), %rsi    # 0x654601
movq %rax, %rdi
callq 0x43f8ce
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
cmpl $0x2, %eax
jne 0x41bc09
movsd 0x40(%r14), %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
jne 0x41bbc6
jp 0x41bbc6
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x28(%rax)
xorl %eax, %eax
movsd 0x20(%r14,%rax,8), %xmm0
movsd 0x8(%rsp,%rax,8), %xmm1
ucomisd %xmm1, %xmm0
jne 0x41bbb7
jp 0x41bbb7
leaq 0x1(%rax), %rcx
cmpq $0x2, %rax
movq %rcx, %rax
jne 0x41bb95
ucomisd %xmm1, %xmm0
movsd (%rsp), %xmm0
jne 0x41bbca
jnp 0x41bbff
jmp 0x41bbca
movapd %xmm1, %xmm0
movsd %xmm0, 0x40(%r14)
movq (%rbx), %rax
leaq 0x8(%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 0x41c2ce
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq $0x655aa0, %rdi         # imm = 0x655AA0
leaq 0x1b0d80(%rip), %rsi    # 0x5cc997
callq 0x4b0650
leaq 0x238a36(%rip), %rsi    # 0x654659
movq %rax, %rdi
callq 0x43f8ce
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x48(%rax)
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
subl %ecx, %eax
negl %ecx
movl %ecx, 0x10(%rsp,%r14,4)
movl %eax, 0x8(%rsp,%r14,4)
incq %r14
cmpq $0x2, %r14
jne 0x41c6d3
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl (%rsi), %eax
testl %eax, %eax
je 0x41c73c
cvtsi2sd %eax, %xmm0
movsd 0x1ac8f5(%rip), %xmm1   # 0x5c9018
divsd %xmm0, %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movupd (%rdi), %xmm0
mulpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
retq
pushq %rax
leaq 0x1b02df(%rip), %rdi    # 0x5cca23
leaq 0x1b0268(%rip), %rsi    # 0x5cc9b3
leaq 0x1b02da(%rip), %rcx    # 0x5cca2c
movl $0x7e, %edx
callq 0x50b050
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/./marsaglia.hpp
// Function: MtwDiscreteSampler<std::array<double, 2ul>>::add(double, std::array<double, 2ul> const&)
void add (double weight, const value_t &value)
    {
        if (weight == 0)
            return;
        weights.push_back (weight);
        values.push_back (value);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x41ca05
jnp 0x41ca56
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x41ca23
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r14)
jmp 0x41ca2e
movq %rsp, %rdx
movq %r14, %rdi
callq 0x41258c
movq 0x28(%r14), %rsi
cmpq 0x30(%r14), %rsi
je 0x41ca47
movupd (%rbx), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x28(%r14)
jmp 0x41ca56
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x41ca96
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq $0x0, 0x18(%rdi)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
je 0x41ca94
xorpd %xmm0, %xmm0
movq %rax, %rdx
addsd (%rdx), %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x8, %rdx
cmpq %rcx, %rdx
jne 0x41ca79
cmpq %rcx, %rax
jne 0x41cbd6
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
addq $0xb8, %rdi
movq $-0x1e, %rax
movq %rdi, %rcx
testq %rax, %rax
je 0x41d175
addq $0x6, %rax
leaq 0x8(%rcx), %rdx
cmpq %rsi, (%rcx)
movq %rdx, %rcx
jbe 0x41d136
subq -0x10(%rdx), %rsi
movl %eax, %ecx
negb %cl
andb $-0x2, %cl
shrq %cl, %rsi
movq -0x20(%rdi,%rax,4), %rcx
movq -0x18(%rdi,%rax,4), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rsi, %rdx
jbe 0x41d197
movq (%rcx,%rsi,8), %rax
popq %rcx
retq
movq $0x655aa0, %rdi         # imm = 0x655AA0
leaq 0x1afa61(%rip), %rsi    # 0x5ccbe4
callq 0x4b0650
leaq 0x2374ca(%rip), %rsi    # 0x654659
movq %rax, %rdi
callq 0x43f8ce
leaq 0x1ae286(%rip), %rdi    # 0x5cb424
xorl %eax, %eax
callq 0x490d80
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x429166
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
movq %rdx, %rdi
callq 0x440344
xorl %eax, %eax
movsd 0x28(%rbx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x4290ea
incq %rax
cmpq $0x3, %rax
jne 0x4290a7
movsd 0x10(%rbx), %xmm0
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x440770
movq 0x10(%r12), %rax
movq %rax, 0x10(%r14)
movups (%r12), %xmm0
movups %xmm0, (%r14)
movsd 0x8(%rbx), %xmm0
jmp 0x42915a
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
addsd 0x20(%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
subsd (%rbx), %xmm1
movq %r15, %rdi
callq 0x440476
addsd (%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4405f6
movq 0x10(%r12), %rax
movq %rax, 0x10(%r14)
movups (%r12), %xmm0
movups %xmm0, (%r14)
movsd 0x8(%rsp), %xmm0
subsd (%rbx), %xmm0
movsd 0x1a0ff8(%rip), %xmm1   # 0x5ca140
subsd 0x20(%rbx), %xmm1
addsd 0x1a0fe3(%rip), %xmm1   # 0x5ca138
callq 0x4ecf40
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1a4226(%rip), %rdi    # 0x5cd393
leaq 0x1a4142(%rip), %rsi    # 0x5cd2b6
leaq 0x1a49d9(%rip), %rcx    # 0x5cdb54
movl $0x59, %edx
callq 0x50b050
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movsd (%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jbe 0x422d03
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm2
mulsd %xmm0, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
sqrtsd %xmm2, %xmm2
movsd 0x10(%rdi), %xmm3
movapd %xmm3, %xmm0
cmpunordsd %xmm3, %xmm0
movapd %xmm0, %xmm4
andpd %xmm2, %xmm4
maxsd %xmm3, %xmm2
andnpd %xmm2, %xmm0
orpd %xmm4, %xmm0
subsd %xmm1, %xmm0
movsd 0x1a7462(%rip), %xmm2   # 0x5ca138
movapd %xmm2, %xmm1
subsd 0x20(%rdi), %xmm1
addsd %xmm2, %xmm1
callq 0x4ecf40
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x422d22
popq %rax
retq
leaq 0x1aa689(%rip), %rdi    # 0x5cd393
leaq 0x1aa5a5(%rip), %rsi    # 0x5cd2b6
leaq 0x1aa88d(%rip), %rcx    # 0x5cd5a5
movl $0x70, %edx
callq 0x50b050
leaq 0x1aa8cb(%rip), %rdi    # 0x5cd5f4
leaq 0x1aa586(%rip), %rsi    # 0x5cd2b6
leaq 0x1aa86e(%rip), %rcx    # 0x5cd5a5
movl $0x75, %edx
callq 0x50b050
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1a7430(%rip), %rsi    # 0x5cd86b
movq %r14, %rdi
callq 0x4c2b40
testl %eax, %eax
je 0x426471
leaq 0x1a2daa(%rip), %rsi    # 0x5c91f8
movq %r14, %rdi
callq 0x4c2b40
testl %eax, %eax
je 0x42648d
movq %rbx, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x40e0c2
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4264b9
movsd %xmm1, 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1a741d(%rip), %rsi    # 0x5cd8ba
leaq 0x1a7445(%rip), %rdx    # 0x5cd8e9
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4083fe
movq %rbx, %rdi
callq 0x43f581
leaq 0x1a73b2(%rip), %rdi    # 0x5cd872
leaq 0x1a73b6(%rip), %rsi    # 0x5cd87d
leaq 0x1a73b7(%rip), %rcx    # 0x5cd885
movl $0xe, %edx
callq 0x50b050
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4264f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x42bee1
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm2
mulsd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
ja 0x42bed8
movq %rdx, %r14
movq %rsi, %r15
movsd 0x19e322(%rip), %xmm1   # 0x5ca1a8
movsd %xmm0, 0x8(%rsp)
callq 0x4ecf40
movsd 0x8(%rsp), %xmm3
movsd 0x1a2131(%rip), %xmm2   # 0x5cdfd0
mulsd %xmm0, %xmm2
addsd 0x1a212d(%rip), %xmm2   # 0x5cdfd8
mulsd (%r15,%r14,8), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm1
jae 0x42bed8
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_O3/Cell-veto[P]postlhc/./lj.hpp
// Function: LennardJones::LennardJones()
LennardJones ()
    {
        strength = 1.;
        sr_lr_split = 1.;
        scale = 2.;
        set_parameter ("cutoff", INFINITY);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x40(%rdi)
movaps 0x1a0535(%rip), %xmm0   # 0x5c9fa0
movups %xmm0, (%rdi)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, 0x10(%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a3ddf(%rip), %rsi    # 0x5cd86b
leaq 0x1a3dde(%rip), %rdx    # 0x5cd871
movq %rsp, %r14
movq %r14, %rdi
callq 0x4083fe
movsd 0x1a44ea(%rip), %xmm0   # 0x5cdf90
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42ae18
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x429ac7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x429aea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movsd 0x40(%rdi), %xmm1
ucomisd %xmm0, %xmm1
jne 0x42b29f
jnp 0x42b332
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 0x1a2cdd(%rip), %xmm1   # 0x5cdfa8
movq %r14, %rdi
movsd (%rsp), %xmm0
movl %eax, %esi
callq 0x4220f6
movq $0x655aa0, %rdi         # imm = 0x655AA0
leaq 0x19fb3a(%rip), %rsi    # 0x5cae22
movl $0x11, %edx
callq 0x4b0120
movsd 0x40(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x42b33a
movsd 0x38(%rbx), %xmm0
mulsd 0x58(%rbx), %xmm0
movq $0x655aa0, %rdi         # imm = 0x655AA0
callq 0x4b1380
leaq 0x1afa4c(%rip), %rsi    # 0x5dad6a
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4b0120
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1a2052(%rip), %rdi    # 0x5cd393
leaq 0x1a1f6e(%rip), %rsi    # 0x5cd2b6
leaq 0x1a2055(%rip), %rcx    # 0x5cd3a4
movl $0x51, %edx
callq 0x50b050
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %xmm1
movsd 0x20(%rdi), %xmm2
mulsd %xmm1, %xmm1
movsd %xmm0, 0x10(%rsp)
divsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
movapd %xmm2, %xmm1
minsd %xmm0, %xmm1
cmpunordsd %xmm0, %xmm0
movapd %xmm0, %xmm3
andnpd %xmm1, %xmm3
andpd %xmm2, %xmm0
orpd %xmm3, %xmm0
movsd 0x19e606(%rip), %xmm1   # 0x5ca1a8
callq 0x4ecf40
movsd (%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x42bc7b
movsd 0x19e577(%rip), %xmm1   # 0x5ca138
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movl 0xbc8(%r14), %eax
cmpl $0x40, %eax
jne 0x42bbfa
movq %r14, %rdi
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x440400
movsd (%rsp), %xmm2
movsd 0x8(%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
addsd 0x1a2390(%rip), %xmm1   # 0x5cdfb0
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x42bc33
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x42bc3c
movapd %xmm1, %xmm0
callq 0x4ed060
addsd 0x19e4ac(%rip), %xmm0   # 0x5ca0f0
movsd 0x1a236c(%rip), %xmm1   # 0x5cdfb8
callq 0x4ecf40
movsd 0x20(%rbx), %xmm1
mulsd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jb 0x42bc9a
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm1, %xmm0
subsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x19f13d(%rip), %rdi    # 0x5cadbf
leaq 0x19f141(%rip), %rsi    # 0x5cadca
leaq 0x19f146(%rip), %rcx    # 0x5cadd6
movl $0x120, %edx            # imm = 0x120
callq 0x50b050
leaq 0x1a2459(%rip), %rdi    # 0x5ce0fa
leaq 0x1a246d(%rip), %rsi    # 0x5ce115
leaq 0x1a246f(%rip), %rcx    # 0x5ce11e
movl $0x73, %edx
callq 0x50b050
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x10(%rsp)
divsd %xmm1, %xmm0
maxsd 0x1a22de(%rip), %xmm0   # 0x5cdfc0
movsd 0x19e4be(%rip), %xmm1   # 0x5ca1a8
callq 0x4ecf40
movsd (%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x42bde6
movsd 0x19e42f(%rip), %xmm1   # 0x5ca138
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movl 0xbc8(%r14), %eax
cmpl $0x40, %eax
jne 0x42bd42
movq %r14, %rdi
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x440400
movsd (%rsp), %xmm2
movsd 0x8(%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 0x30(%rbx), %xmm1
jae 0x42bd82
addsd 0x1a2241(%rip), %xmm1   # 0x5cdfb0
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x42bd8c
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x42bd95
movsd 0x1a223e(%rip), %xmm0   # 0x5cdfc8
jmp 0x42bdde
movapd %xmm1, %xmm0
callq 0x4ed060
movsd 0x19e353(%rip), %xmm2   # 0x5ca0f0
subsd %xmm0, %xmm2
movsd 0x1a220f(%rip), %xmm1   # 0x5cdfb8
movapd %xmm2, %xmm0
callq 0x4ecf40
ucomisd 0x1a2206(%rip), %xmm0   # 0x5cdfc0
jb 0x42be05
movsd 0x28(%rbx), %xmm1
mulsd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jb 0x42be05
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm1, %xmm0
subsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x19efd2(%rip), %rdi    # 0x5cadbf
leaq 0x19efd6(%rip), %rsi    # 0x5cadca
leaq 0x19efdb(%rip), %rcx    # 0x5cadd6
movl $0x120, %edx            # imm = 0x120
callq 0x50b050
leaq 0x1a2354(%rip), %rdi    # 0x5ce160
leaq 0x1a2302(%rip), %rsi    # 0x5ce115
leaq 0x1a2380(%rip), %rcx    # 0x5ce19a
movl $0x88, %edx
callq 0x50b050
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movaps 0x19d651(%rip), %xmm0   # 0x5cea70
movups %xmm0, (%rdi)
movaps 0x19d657(%rip), %xmm0   # 0x5cea80
movups %xmm0, 0x10(%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19c42e(%rip), %rsi    # 0x5cd86b
leaq 0x19c42d(%rip), %rdx    # 0x5cd871
movq %rsp, %r14
movq %r14, %rdi
callq 0x4083fe
movsd 0x19d639(%rip), %xmm0   # 0x5cea90
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43243a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x431478
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x43149b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x442d20
movq %rbx, %rdi
callq 0x4f63f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::random_sr_repulsion(double, RandomContext*)
double random_sr_repulsion (double rsq, RandomContext *random)
    {
        double rsq_evt = random_repulsive_lift_g  (rsq, random);
        if (rsq_evt <= sq (LJ_MINIMUM))
            update_max (&rsq_evt, random_repulsive_lift_lj (rsq, random));
        return rsq_evt - rsq;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
callq 0x432df6
movapd %xmm0, %xmm1
movsd 0x1962ec(%rip), %xmm0   # 0x5c9018
ucomisd %xmm1, %xmm0
jb 0x432d6c
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movq %rbx, %rsi
movsd %xmm1, 0x10(%rsp)
callq 0x432f8e
movsd 0x10(%rsp), %xmm3
movapd %xmm3, %xmm1
cmpunordsd %xmm3, %xmm1
movapd %xmm1, %xmm2
andpd %xmm0, %xmm2
maxsd %xmm3, %xmm0
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
subsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::random_sr_attraction(double, RandomContext*)
double random_sr_attraction (double rsq, RandomContext *random)
    {
        double rsq_evt = random_attractive_lift_lj (rsq, random);
        if (rsq_evt >= sq (gauss_r0))
            update_min (&rsq_evt, random_attractive_lift_g  (rsq, random));
        return rsq_evt - rsq;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
callq 0x4330ae
movapd %xmm0, %xmm1
movsd 0x10(%r14), %xmm0
mulsd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x432de4
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movq %rbx, %rsi
movsd %xmm1, 0x10(%rsp)
callq 0x4331f4
movsd 0x10(%rsp), %xmm3
movapd %xmm3, %xmm1
cmpunordsd %xmm3, %xmm1
movapd %xmm1, %xmm2
andpd %xmm0, %xmm2
minsd %xmm3, %xmm0
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
subsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq