LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/./ipl.hpp
// Function: PowerLawInteraction::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 == "strength")
        {
            if (! (value >= 0.))
                rt_error ("Invalid strength for power law");
            gamma = value;
        }
        else if (name == "exponent")
        {
            exponent = value;
        }
        else if (name == "sr_lr_split")
        {
            if (! (value > 0.))
                rt_error ("Invalid sr_lr_split for power law");
            sr_lr_split = value;
        }
        else
        {
            rt_error ("Invalid parameter: " + name);
        }

        // for compatibility with conventional normalization
        if (exponent == 0)
            stren = gamma;
        else
            stren = gamma * fabs (exponent);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1bd0af(%rip), %rsi    # 0x5cb156
movq %r14, %rdi
callq 0x4c3ef0
testl %eax, %eax
je 0x40e0fa
leaq 0x1bd07d(%rip), %rsi    # 0x5cb137
movq %r14, %rdi
callq 0x4c3ef0
testl %eax, %eax
je 0x40e13b
leaq 0x1bc12b(%rip), %rsi    # 0x5ca1f8
movq %r14, %rdi
callq 0x4c3ef0
testl %eax, %eax
jne 0x40e187
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x40e1a6
movapd %xmm1, %xmm0
leaq 0x18(%rbx), %rax
jmp 0x40e144
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq %rbx, %rax
movapd %xmm1, %xmm0
jae 0x40e144
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bd03f(%rip), %rsi    # 0x5cb15f
leaq 0x1bd056(%rip), %rdx    # 0x5cb17d
leaq 0x8(%rsp), %rdi
callq 0x40843e
leaq 0x8(%rsp), %rdi
callq 0x440975
leaq 0x10(%rbx), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd (%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
movapd 0x1bcf87(%rip), %xmm2   # 0x5cb0e0
andpd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorpd %xmm3, %xmm3
cmpeqsd %xmm1, %xmm3
movapd %xmm3, %xmm1
andnpd %xmm2, %xmm1
andpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movlpd %xmm3, 0x8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1bd012(%rip), %rsi    # 0x5cb1a0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x407ce4
movq %rbx, %rdi
callq 0x440975
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bcfc8(%rip), %rsi    # 0x5cb17e
leaq 0x1bcfe2(%rip), %rdx    # 0x5cb19f
leaq 0x8(%rsp), %rdi
callq 0x40843e
leaq 0x8(%rsp), %rdi
callq 0x440975
jmp 0x40e1d5
jmp 0x40e1e4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0x40e1fa
jmp 0x40e207
movq %rax, %rbx
jmp 0x40e207
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40e207
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rdi
callq 0x4f77a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/jellium3.cpp
// Function: Jellium3::notify_error_bound(AbstractStorage const*, double)
void notify_error_bound (const AbstractStorage *stor,
        double err_bound)
    {
        const unsigned DIM = stor->dimension ();

        if (error_bound != err_bound || period != stor->periods ())
        {
            error_bound = err_bound;
            period = stor->periods ();

            if (DIM >= exponent + 3)
                std::cerr << "jellium3: exponent " << exponent
                    << " too small for dimension " << DIM << ABORT;

            switch (DIM)
            {
            case 2:
                for (unsigned n = 0; n != DIM; ++n)
                    calibrate <2> (n);
                return;
            case 3:
                for (unsigned n = 0; n != DIM; ++n)
                    calibrate <3> (n);
                return;
            default:
                std::cerr << "jellium3: DIM = " << DIM
                    << " not implemented" << ABORT;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
movl %eax, %ebp
movsd 0x38(%rbx), %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jne 0x40e834
jnp 0x40e83a
movapd %xmm1, %xmm0
jmp 0x40e87f
movq (%r14), %rax
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movsd 0x20(%rbx), %xmm0
ucomisd (%r15), %xmm0
jne 0x40e879
jp 0x40e879
xorl %eax, %eax
cmpq $0x10, %rax
je 0x40e8f4
movsd 0x28(%rbx,%rax), %xmm0
ucomisd 0x18(%rsp,%rax), %xmm0
leaq 0x8(%rax), %rax
jne 0x40e879
jnp 0x40e85b
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x38(%rbx)
movq (%r14), %rax
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movq 0x10(%r15), %rax
movq %rax, 0x30(%rbx)
movups (%r15), %xmm0
movups %xmm0, 0x20(%rbx)
movl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x10(%rbx), %xmm1
addsd 0x1bc754(%rip), %xmm1   # 0x5cb010
ucomisd %xmm1, %xmm0
jae 0x40e8ff
cmpl $0x2, %ebp
je 0x40e8e1
cmpl $0x3, %ebp
jne 0x40e93a
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40f412
incl %ebp
cmpl $0x3, %ebp
jne 0x40e8ce
jmp 0x40e8f4
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40f0a2
incl %ebp
cmpl $0x2, %ebp
jne 0x40e8e3
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq $0x656aa0, %rdi         # imm = 0x656AA0
leaq 0x1bcb06(%rip), %rsi    # 0x5cb413
callq 0x4b1a00
movsd 0x10(%rbx), %xmm0
movq %rax, %rdi
callq 0x4b2970
leaq 0x1bcb01(%rip), %rsi    # 0x5cb427
movq %rax, %rdi
callq 0x4b1a00
movq %rax, %rdi
movl %ebp, %esi
callq 0x4b2030
jmp 0x40e966
movq $0x656aa0, %rdi         # imm = 0x656AA0
leaq 0x1bcaf9(%rip), %rsi    # 0x5cb441
callq 0x4b1a00
movq %rax, %rdi
movl %ebp, %esi
callq 0x4b2030
leaq 0x1e53f1(%rip), %rsi    # 0x5f3d4f
movq %rax, %rdi
callq 0x4b1a00
leaq 0x246c94(%rip), %rsi    # 0x655601
movq %rax, %rdi
callq 0x440cc2
nop
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::random_particle(RandomContext*)
key_t random_particle (RandomContext *random)
    {
        assert (num_ > 0);
        key_t ret;
        do {
            ret = random->uint (num_cells_);
        } while (!data_[ret].in_use ());
        return ret;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x30(%rdi)
je 0x40e9b2
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x88(%rdi), %r15
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x4417ae
movl %eax, %eax
movq %rax, %rcx
shlq $0x4, %rcx
testb $0x1, 0x8(%r15,%rcx)
je 0x40e98f
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1bce37(%rip), %rdi    # 0x5cb7f0
leaq 0x1bc849(%rip), %rsi    # 0x5cb209
leaq 0x1bce32(%rip), %rcx    # 0x5cb7f9
movl $0x221, %edx            # imm = 0x221
callq 0x50c400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42ce49
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm2
mulsd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
ja 0x42ce40
movq %rdx, %r14
movq %rsi, %r15
movsd 0x19e27a(%rip), %xmm1   # 0x5cb068
movsd %xmm0, 0x8(%rsp)
callq 0x4ee2f0
movsd 0x8(%rsp), %xmm3
movsd 0x1a20d9(%rip), %xmm2   # 0x5ceee0
mulsd %xmm0, %xmm2
addsd 0x1a20d5(%rip), %xmm2   # 0x5ceee8
mulsd (%r15,%r14,8), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm1
jae 0x42ce40
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_O1/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 0x4115c4
movsd 0x30(%rsp), %xmm1
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incl %r12d
cmpl $0x2, %r12d
jne 0x4116d7
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x411712
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x41171b
movapd %xmm1, %xmm0
callq 0x4ee410
cmpl $0x3, %ebp
movapd 0x50(%rsp), %xmm2
jae 0x4117b4
movsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movl %ebp, %eax
ucomisd 0x50(%r14,%rax,8), %xmm0
jae 0x4117d3
movapd 0x1b998d(%rip), %xmm0   # 0x5cb0e0
andpd %xmm2, %xmm0
movapd %xmm0, 0x30(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x411628
movapd 0x30(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x4117fe
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 0x411a10
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b9fce(%rip), %rdi    # 0x5cb789
leaq 0x1b9a47(%rip), %rsi    # 0x5cb209
leaq 0x1b9fd0(%rip), %rcx    # 0x5cb799
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x50c400
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1ba115(%rip), %rsi    # 0x5cb8f8
leaq 0x1ba137(%rip), %rdx    # 0x5cb921
leaq 0x10(%rsp), %rdi
callq 0x40843e
leaq 0x10(%rsp), %rdi
callq 0x440975
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1ba114(%rip), %rsi    # 0x5cb922
leaq 0x1ba134(%rip), %rdx    # 0x5cb949
leaq 0x10(%rsp), %rdi
callq 0x40843e
leaq 0x10(%rsp), %rdi
callq 0x440975
jmp 0x41182d
jmp 0x411849
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x41184c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4440d0
jmp 0x41184c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41188e
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq %rax, %rsi
je 0x411884
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x2, %rax
jne 0x411872
retq
pushq %rax
leaq 0x1ba387(%rip), %rdi    # 0x5cbc1d
leaq 0x1ba38b(%rip), %rsi    # 0x5cbc28
leaq 0x1ba38f(%rip), %rcx    # 0x5cbc33
movl $0x16a, %edx            # imm = 0x16A
callq 0x50c400
// File: /workspace/github_cpp_makefile_star2_O1/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 0x411997
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 0x1b9669(%rip), %xmm0   # 0x5cafd8
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 0x1b9d87(%rip), %rdi    # 0x5cb726
leaq 0x1b9863(%rip), %rsi    # 0x5cb209
leaq 0x1ba050(%rip), %rcx    # 0x5cb9fd
movl $0xe5, %edx
callq 0x50c400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, 0x10(%rdi)
leaq 0x238c06(%rip), %rax    # 0x64a628
movq %rax, (%rdi)
movl %ecx, 0x50(%rdi)
leaq 0x3c(%rsi), %rax
addq $0x40, %rdi
movl %ecx, %r8d
shlq $0x2, %r8
movsd 0x1b9599(%rip), %xmm3   # 0x5cafd8
xorl %r9d, %r9d
cmpq %r9, %r8
jne 0x411a7c
movsd 0x2c(%rax,%r9,2), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm1, %xmm5
cvttsd2si %xmm5, %r10
mulsd %xmm2, %xmm4
cvttsd2si %xmm4, %rcx
movq %rcx, %r14
sarq $0x3f, %r14
subsd %xmm3, %xmm4
cvttsd2si %xmm4, %r11
andq %r14, %r11
orq %rcx, %r11
jmp 0x411aa8
movsd 0x2c(%rax,%r9,2), %xmm4
mulsd %xmm0, %xmm4
cvttsd2si %xmm4, %rcx
movq %rcx, %r10
sarq $0x3f, %r10
subsd %xmm3, %xmm4
cvttsd2si %xmm4, %r11
andq %r10, %r11
orq %rcx, %r11
movq %r11, %r10
negq %r10
addq (%rdx,%r9,2), %r10
xorl %ecx, %ecx
subb (%rax,%r9), %cl
shrq %cl, %r10
shlq %cl, %r10
movq %r10, -0x10(%rdi,%r9,2)
addq (%rdx,%r9,2), %r11
shrq %cl, %r11
incq %r11
shlq %cl, %r11
movq %r11, (%rdi,%r9,2)
cmpq %r11, %r10
je 0x411b12
movq %r10, -0x28(%rdi,%r9,2)
addq $0x4, %r9
cmpq $0x8, %r9
jne 0x411a42
movq $0x0, 0x28(%rbx)
movq %rbx, %rax
addq $0x18, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x411b92
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x411b32
leaq 0x1b9e31(%rip), %rdi    # 0x5cb94a
leaq 0x1b96e9(%rip), %rsi    # 0x5cb209
leaq 0x1b9e40(%rip), %rcx    # 0x5cb967
movl $0x2f8, %edx            # imm = 0x2F8
callq 0x50c400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x411bb7
movq (%rsi,%rdx,8), %r8
shldq %cl, %r8, %rax
incq %rdx
cmpq $0x2, %rdx
jne 0x411b96
movb 0x44(%rdi), %cl
shlq %cl, %rax
retq
pushq %rax
leaq 0x1b9f16(%rip), %rdi    # 0x5cbad5
leaq 0x1b9643(%rip), %rsi    # 0x5cb209
leaq 0x1b9f13(%rip), %rcx    # 0x5cbae0
movl $0xfd, %edx
callq 0x50c400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x411cb1
leaq 0x18(%rbx), %rsi
movq $0x0, 0x28(%rbx)
movl 0x50(%rbx), %eax
leaq -0x4(,%rax,4), %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x411c83
movb 0x40(%rdi,%rdx), %r8b
xorl %ecx, %ecx
subb %r8b, %cl
movl $0x1, %r8d
shlq %cl, %r8
addq 0x20(%rbx,%rdx,2), %r8
movq %r8, 0x20(%rbx,%rdx,2)
cmpq 0x48(%rbx,%rdx,2), %r8
jne 0x411ca8
movq 0x38(%rbx,%rdx,2), %rcx
movq %rcx, 0x20(%rbx,%rdx,2)
addq $-0x4, %rdx
cmpq $-0x8, %rdx
jne 0x411c50
movl 0x50(%rbx), %eax
cmpq $0x2, %rax
jae 0x411cb3
xorl %ecx, %ecx
subb 0x3c(%rdi,%rax,4), %cl
movl $0x1, %edx
shlq %cl, %rdx
addq %rdx, (%rsi,%rax,8)
callq 0x411b92
movq %rax, 0x8(%rbx)
popq %rbx
retq
leaq 0x1b9a6c(%rip), %rdi    # 0x5cb726
leaq 0x1b9548(%rip), %rsi    # 0x5cb209
leaq 0x1b9ef7(%rip), %rcx    # 0x5cbbbf
movl $0xd7, %edx
callq 0x50c400
// File: /workspace/github_cpp_makefile_star2_O1/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 0x415c96
leaq (%rdx,%rdx,2), %rax
shlq $0x4, %rax
testb $0x1, 0x90(%rdi,%rax)
je 0x415cb5
addq %rdi, %rax
addq $0x88, %rax
xorl %ecx, %ecx
movsd 0x1b546e(%rip), %xmm0   # 0x5cb0b0
movapd 0x1b5476(%rip), %xmm1   # 0x5cb0c0
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 0x415c4a
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 0x1b5ea4(%rip), %rdi    # 0x5cbb41
leaq 0x1b5565(%rip), %rsi    # 0x5cb209
leaq 0x1b6a7a(%rip), %rcx    # 0x5cc725
movl $0x20b, %edx            # imm = 0x20B
callq 0x50c400
leaq 0x1b5ef6(%rip), %rdi    # 0x5cbbb2
leaq 0x1b5546(%rip), %rsi    # 0x5cb209
leaq 0x1b6a5b(%rip), %rcx    # 0x5cc725
movl $0x20d, %edx            # imm = 0x20D
callq 0x50c400
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b827c(%rip), %xmm0   # 0x5ca018
movsd %xmm0, (%rsp)
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4115c4
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incl %ebp
cmpl $0x2, %ebp
jne 0x411da3
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x2, %esi
callq *0x48(%rax)
movq %rax, %xmm0
punpckldq 0x1b92d3(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1b92db(%rip), %xmm0   # 0x5cb0c0
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_O1/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 0x44173c
movq %rbx, %rdi
callq 0x4121ac
testl %eax, %eax
je 0x412158
movl %eax, %r12d
cmpl $0x3f, %eax
ja 0x412189
movl %r12d, %r13d
movsd 0x1b7f9d(%rip), %xmm1   # 0x5ca018
movsd 0x400(%rbx,%r13,8), %xmm0
addsd %xmm1, %xmm0
movsd 0x1b8fdf(%rip), %xmm1   # 0x5cb070
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x200(%rbx,%r13,8), %xmm0
decl %r12d
divsd 0x200(%rbx,%r12,8), %xmm0
callq 0x4ee2f0
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x44172c
movsd 0x1b7f4c(%rip), %xmm2   # 0x5ca018
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 0x4ee2f0
mulsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0x441996
movsd %xmm0, (%r14)
movsd %xmm1, 0x8(%r14)
movsd 0x600(%rbx,%r13,8), %xmm0
movsd %xmm0, (%rsp)
movsd 0x1b7ee4(%rip), %xmm1   # 0x5ca018
addsd 0x400(%rbx,%r13,8), %xmm1
xorpd 0x1b8f8a(%rip), %xmm1   # 0x5cb0d0
movsd 0x8(%rsp), %xmm0
callq 0x4ee2f0
mulsd (%rsp), %xmm0
jmp 0x41217b
movsd 0x200(%rbx), %xmm0
movq %r15, %rdi
callq 0x441ab2
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 $0x656aa0, %rdi         # imm = 0x656AA0
leaq 0x1b9c01(%rip), %rsi    # 0x5cbd98
callq 0x4b1a00
leaq 0x24345e(%rip), %rsi    # 0x655601
movq %rax, %rdi
callq 0x440cc2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
subq $0x18, %rsp
xorl %eax, %eax
movsd 0x50(%rdi,%rax,8), %xmm0
movsd %xmm0, 0x8(%rsp,%rax,8)
incq %rax
cmpq $0x2, %rax
jne 0x4126a2
movsd 0x60(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4126d9
jp 0x4126d9
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addq $0x18, %rsp
retq
leaq 0x1b97f6(%rip), %rdi    # 0x5cbed6
leaq 0x1b9541(%rip), %rsi    # 0x5cbc28
leaq 0x1b97ff(%rip), %rcx    # 0x5cbeed
movl $0x14b, %edx            # imm = 0x14B
callq 0x50c400
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41672a
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4167c8
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 0x1b4946(%rip), %xmm0   # 0x5cafd8
cvttsd2si %xmm0, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
addq %rsi, 0x8(%rsp,%rax,8)
cmpl $0x3, %ebp
jae 0x416749
addsd 0x20(%rsp,%rax,8), %xmm1
movsd %xmm1, 0x20(%rsp,%rax,8)
orb $0x1, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
cmpq %r15, %rbx
jne 0x4166d3
movq %r14, %rdi
callq 0x41684c
movq %rax, %rbx
jmp 0x41671c
movq %r14, %rdi
callq 0x415ad2
movq %r14, %rdi
movq %rax, %rsi
callq 0x416e7c
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 0x1b58d6(%rip), %rdi    # 0x5cc007
leaq 0x1b4ad1(%rip), %rsi    # 0x5cb209
leaq 0x1b6319(%rip), %rcx    # 0x5cca58
movl $0x233, %edx            # imm = 0x233
callq 0x50c400
leaq 0x1b63e2(%rip), %rdi    # 0x5ccb32
leaq 0x1b4ab2(%rip), %rsi    # 0x5cb209
leaq 0x1b63e8(%rip), %rcx    # 0x5ccb46
movl $0xa3, %edx
callq 0x50c400
movq %rax, %r15
cmpl $0x1, %edx
jne 0x4167b7
movq %r15, %rdi
callq 0x444650
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4167c8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x41684c
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x41684c
movq %rax, %rbx
callq 0x4446c0
jmp 0x41671c
movq %rax, %r15
callq 0x4446c0
movq %r15, %rdi
callq 0x4f77a0
movq %rax, %rdi
callq 0x407dd1
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x412f9e
shlq $0x4, %rsi
movq 0x90(%rdi,%rsi), %rdx
testb $0x1, %dl
je 0x412fbd
leaq (%rdi,%rsi), %rcx
addq $0x88, %rcx
movq (%rcx), %rax
movq $0x0, 0x8(%rcx)
popq %rcx
retq
leaq 0x1b8b9c(%rip), %rdi    # 0x5cbb41
leaq 0x1b825d(%rip), %rsi    # 0x5cb209
leaq 0x1b90cb(%rip), %rcx    # 0x5cc07e
movl $0x16e, %edx            # imm = 0x16E
callq 0x50c400
leaq 0x1b910c(%rip), %rdi    # 0x5cc0d0
leaq 0x1b823e(%rip), %rsi    # 0x5cb209
leaq 0x1b90ac(%rip), %rcx    # 0x5cc07e
movl $0x16f, %edx            # imm = 0x16F
callq 0x50c400
// File: /workspace/github_cpp_makefile_star2_O1/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 0x411b92
movq %r14, %rdi
movq %rax, %rsi
callq 0x413542
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 0x41304a
movq %r15, %rdi
callq 0x444650
movq %r14, %rdi
xorl %esi, %esi
callq 0x41305a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x412fdc
movq %rax, %r15
callq 0x4446c0
jmp 0x41300a
movq %rax, %r15
callq 0x4446c0
movq %r15, %rdi
callq 0x4f77a0
movq %rax, %rdi
callq 0x407dd1
// File: /workspace/github_cpp_makefile_star2_O1/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 0x413584
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 0x4135a0
decq %rcx
addq $0x10, %rdx
cmpq %rcx, %rax
jne 0x413573
movq (%r14), %rax
movq %r14, %rdi
movl $0x2, %esi
callq *0x48(%rax)
addq %r15, %rax
cmpq %rax, %rbx
jae 0x4135af
incl 0x48(%r14)
jmp 0x4135a6
subq %rcx, %r15
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %edi
callq 0x4444f0
leaq 0x237108(%rip), %rsi    # 0x64a6c8
movq %rax, %rdi
xorl %edx, %edx
callq 0x445540
// File: /workspace/github_cpp_makefile_star2_O1/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), %xmm1
movsd 0x8(%rsi), %xmm0
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x41372b
sqrtsd %xmm0, %xmm0
jmp 0x413730
callq 0x4ee410
leaq 0x200(%rbx), %rcx
movl $0x40, %esi
movq %rcx, %rax
movq %rsi, %rdx
shrq %rdx
ucomisd (%rax,%rdx,8), %xmm0
jbe 0x41375a
leaq (%rax,%rdx,8), %rax
addq $0x8, %rax
notq %rdx
addq %rsi, %rdx
movq %rdx, %rsi
testq %rdx, %rdx
jg 0x413742
subq %rcx, %rax
shrq $0x3, %rax
testl %eax, %eax
je 0x4137aa
cmpl $0x3f, %eax
ja 0x4137b8
andl $0x3f, %eax
movsd 0x400(%rbx,%rax,8), %xmm1
movsd 0x600(%rbx,%rax,8), %xmm2
movsd %xmm2, 0x8(%rsp)
addsd 0x1b6883(%rip), %xmm1   # 0x5ca018
xorpd 0x1b7933(%rip), %xmm1   # 0x5cb0d0
callq 0x4ee2f0
mulsd 0x8(%rsp), %xmm0
jmp 0x4137b2
movsd 0x600(%rbx), %xmm0
addq $0x10, %rsp
popq %rbx
retq
movq $0x656aa0, %rdi         # imm = 0x656AA0
leaq 0x1b8b57(%rip), %rsi    # 0x5cc31d
callq 0x4b1a00
leaq 0x241e2f(%rip), %rsi    # 0x655601
movq %rax, %rdi
callq 0x440cc2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41c026
movsd 0x40(%r14), %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
jne 0x41bfdc
jp 0x41bfdc
movq (%rbx), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movsd 0x20(%r14), %xmm0
ucomisd (%r15), %xmm0
jne 0x41bfe2
jp 0x41bfe2
movl $0x1, %ecx
cmpq $0x3, %rcx
je 0x41c01c
movq %rcx, %rax
movsd 0x20(%r14,%rcx,8), %xmm0
incq %rcx
ucomisd 0x8(%rsp,%rax,8), %xmm0
jne 0x41bfcf
jnp 0x41bfb2
cmpq $0x3, %rax
movsd (%rsp), %xmm0
jne 0x41bfe7
jmp 0x41c01c
movapd %xmm1, %xmm0
jmp 0x41bfe7
movsd (%rsp), %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 0x41c72c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq $0x656aa0, %rdi         # imm = 0x656AA0
leaq 0x1b1873(%rip), %rsi    # 0x5cd8a7
callq 0x4b1a00
leaq 0x239619(%rip), %rsi    # 0x655659
movq %rax, %rdi
callq 0x440cc2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41cbf1
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41cc74
cvtsi2sd %eax, %xmm1
movsd 0x1ad3d3(%rip), %xmm0   # 0x5ca018
divsd %xmm1, %xmm0
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp,%rax,8)
incq %rax
cmpq $0x2, %rax
jne 0x41cc4b
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addq $0x18, %rsp
retq
leaq 0x1b0cb8(%rip), %rdi    # 0x5cd933
leaq 0x1b0c41(%rip), %rsi    # 0x5cd8c3
leaq 0x1b0cb3(%rip), %rcx    # 0x5cd93c
movl $0x7e, %edx
callq 0x50c400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41cf2b
jnp 0x41cf7c
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x41cf49
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r14)
jmp 0x41cf54
movq %rsp, %rdx
movq %r14, %rdi
callq 0x4126f8
movq 0x28(%r14), %rsi
cmpq 0x30(%r14), %rsi
je 0x41cf6d
movupd (%rbx), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x28(%r14)
jmp 0x41cf7c
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x41cfbc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41cfb1
xorpd %xmm0, %xmm0
movq %rax, %rdx
addsd (%rdx), %xmm0
movsd %xmm0, 0x18(%rdi)
addq $0x8, %rdx
cmpq %rcx, %rdx
jne 0x41cf9f
cmpq %rax, %rcx
jne 0x41d0fc
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rax, %r8
testq %r8, %r8
je 0x41d696
leaq 0x6(%r8), %rax
leaq 0x8(%rcx), %rdx
cmpq %rsi, (%rcx)
movq %rdx, %rcx
jbe 0x41d656
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 0x41d6bf
movq (%rcx,%rsi,8), %rax
testq %r8, %r8
je 0x41d69d
popq %rcx
retq
movq $0x656aa0, %rdi         # imm = 0x656AA0
leaq 0x1b0449(%rip), %rsi    # 0x5cdaf4
callq 0x4b1a00
leaq 0x237fa2(%rip), %rsi    # 0x655659
movq %rax, %rdi
callq 0x440cc2
leaq 0x1aec6e(%rip), %rdi    # 0x5cc334
xorl %eax, %eax
callq 0x492130
nop
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/./pareto_prober.hpp
// Function: double ParetoProber::random_probe<2ul>(std::array<double, 2ul>*, 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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd (%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x422f9b
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
movq %rdx, %rdi
callq 0x44173c
movsd 0x28(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x422ef2
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
jmp 0x422f17
xorl %eax, %eax
cmpq $0x1, %rax
sete %bpl
je 0x422f6e
movsd 0x30(%rbx,%rax,8), %xmm1
incq %rax
ucomisd %xmm0, %xmm1
jbe 0x422ef4
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
addsd 0x20(%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
subsd (%rbx), %xmm1
movq %r15, %rdi
callq 0x44186e
addsd (%rbx), %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x441996
movsd %xmm0, (%r14)
movsd %xmm1, 0x8(%r14)
movsd (%rsp), %xmm0
subsd (%rbx), %xmm0
movsd 0x1a809e(%rip), %xmm2   # 0x5caff8
movapd %xmm2, %xmm1
subsd 0x20(%rbx), %xmm1
addsd %xmm2, %xmm1
callq 0x4ee2f0
jmp 0x422f6e
testb %bpl, %bpl
je 0x422f90
movsd 0x10(%rbx), %xmm0
movq %r15, %rdi
callq 0x441ab2
movsd %xmm0, (%r14)
movsd %xmm1, 0x8(%r14)
movsd 0x8(%rbx), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ab301(%rip), %rdi    # 0x5ce2a3
leaq 0x1ab21d(%rip), %rsi    # 0x5ce1c6
leaq 0x1ab332(%rip), %rcx    # 0x5ce2e2
movl $0x59, %edx
callq 0x50c400
// File: /workspace/github_cpp_makefile_star2_O1/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
movsd (%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4237c9
movq %rdi, %rbx
movsd (%rsi), %xmm2
movsd 0x8(%rsi), %xmm0
mulsd %xmm2, %xmm2
mulsd %xmm0, %xmm0
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x423765
sqrtsd %xmm0, %xmm0
jmp 0x42376a
callq 0x4ee410
movsd 0x10(%rbx), %xmm1
movapd %xmm1, %xmm2
cmpunordsd %xmm1, %xmm2
movapd %xmm2, %xmm3
andpd %xmm0, %xmm3
maxsd %xmm1, %xmm0
andnpd %xmm0, %xmm2
orpd %xmm3, %xmm2
subsd (%rbx), %xmm2
movsd 0x1a7860(%rip), %xmm0   # 0x5caff8
movapd %xmm0, %xmm1
subsd 0x20(%rbx), %xmm1
addsd %xmm0, %xmm1
movapd %xmm2, %xmm0
callq 0x4ee2f0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x4237e8
popq %rbx
retq
leaq 0x1aaad3(%rip), %rdi    # 0x5ce2a3
leaq 0x1aa9ef(%rip), %rsi    # 0x5ce1c6
leaq 0x1aacd7(%rip), %rcx    # 0x5ce4b5
movl $0x70, %edx
callq 0x50c400
leaq 0x1aad15(%rip), %rdi    # 0x5ce504
leaq 0x1aa9d0(%rip), %rsi    # 0x5ce1c6
leaq 0x1aacb8(%rip), %rcx    # 0x5ce4b5
movl $0x75, %edx
callq 0x50c400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a75d6(%rip), %rsi    # 0x5ce77b
movq %r14, %rdi
callq 0x4c3ef0
testl %eax, %eax
je 0x4271db
leaq 0x1a3040(%rip), %rsi    # 0x5ca1f8
movq %r14, %rdi
callq 0x4c3ef0
testl %eax, %eax
je 0x4271f7
movq %rbx, %rdi
movq %r14, %rsi
movsd (%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x40e08e
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x427223
movsd %xmm1, 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1a75c3(%rip), %rsi    # 0x5ce7ca
leaq 0x1a75eb(%rip), %rdx    # 0x5ce7f9
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x40843e
movq %rbx, %rdi
callq 0x440975
leaq 0x1a7558(%rip), %rdi    # 0x5ce782
leaq 0x1a755c(%rip), %rsi    # 0x5ce78d
leaq 0x1a755d(%rip), %rcx    # 0x5ce795
movl $0xe, %edx
callq 0x50c400
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x42725c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm0
mulsd %xmm0, %xmm0
xorl %eax, %eax
movsd 0x8(%rsi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x2, %rax
jne 0x429d98
movsd 0x18(%rbx), %xmm2
mulsd %xmm2, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
ja 0x429e09
movl %edx, %eax
movsd (%rsi,%rax,8), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rbx), %xmm1
addsd 0x1a1294(%rip), %xmm1   # 0x5cb070
mulsd 0x1a127c(%rip), %xmm1   # 0x5cb060
callq 0x4ee2f0
movapd %xmm0, %xmm1
mulsd 0x8(%rsp), %xmm1
movsd 0x8(%rbx), %xmm0
mulsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
cmpnlesd %xmm2, %xmm1
andpd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, 0x10(%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a3eda(%rip), %rsi    # 0x5ce77b
leaq 0x1a3ed9(%rip), %rdx    # 0x5ce781
movq %rsp, %r14
movq %r14, %rdi
callq 0x40843e
movsd 0x1a45e5(%rip), %xmm0   # 0x5ceea0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42bd32
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x42a8dc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4440d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x42a8ff
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rdi
callq 0x4f77a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42c1b9
jnp 0x42c24c
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 0x1a2cd3(%rip), %xmm1   # 0x5ceeb8
movq %r14, %rdi
movsd (%rsp), %xmm0
movl %eax, %esi
callq 0x422b3e
movq $0x656aa0, %rdi         # imm = 0x656AA0
leaq 0x19fb30(%rip), %rsi    # 0x5cbd32
movl $0x11, %edx
callq 0x4b14d0
movsd 0x40(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x42c254
movsd 0x38(%rbx), %xmm0
mulsd 0x58(%rbx), %xmm0
movq $0x656aa0, %rdi         # imm = 0x656AA0
callq 0x4b2730
leaq 0x1af9b2(%rip), %rsi    # 0x5dbbea
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4b14d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1a2048(%rip), %rdi    # 0x5ce2a3
leaq 0x1a1f64(%rip), %rsi    # 0x5ce1c6
leaq 0x1a204b(%rip), %rcx    # 0x5ce2b4
movl $0x51, %edx
callq 0x50c400
nop