LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse2D>::trunc_periods(Storage<Monodisperse2D>*)
static
    vector_t trunc_periods (stor_t *stor)
    {
        vector_t ret;
        for (size_t n = 0; n != DIM; ++n)
            ret[n] = stor->period (n);
        for (size_t n = DIM; n != MAX_DIM; ++n)
            assert (stor->period (n) == 0.);
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x2, -0x20(%rbp)
je 0x41ff43
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x41df90
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x418e10
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x41ff04
movq $0x2, -0x28(%rbp)
cmpq $0x3, -0x28(%rbp)
je 0x41ff9d
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
callq 0x41df90
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x41ff6e
jp 0x41ff6e
jmp 0x41ff8d
leaq 0x1dd47b(%rip), %rdi    # 0x5fd3f0
leaq 0x1dd1c6(%rip), %rsi    # 0x5fd142
movl $0x14b, %edx            # imm = 0x14B
leaq 0x1dd47f(%rip), %rcx    # 0x5fd407
callq 0x53d020
jmp 0x41ff8f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x41ff4b
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Cell-veto[P]postlhc/./tools.hpp
// Function: double fproduct<double const*>(double const*, double const* const&)
double fproduct (ITERATOR begin, const ITERATOR &end)
{
    double prod = 1.;
    while (begin != end)
        prod *= *begin++;
    return prod;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd 0x1d9164(%rip), %xmm0   # 0x5fb018
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0x421ee5
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x8(%rbp)
movsd (%rax), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x421eb9
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x422434
jmp 0x422453
leaq 0x1dac20(%rip), %rdi    # 0x5fd05b
leaq 0x1da0a5(%rip), %rsi    # 0x5fc4e7
movl $0x16e, %edx            # imm = 0x16E
leaq 0x1db14a(%rip), %rcx    # 0x5fd598
callq 0x53d020
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
movq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x41dff0
testb $0x1, %al
jne 0x422474
jmp 0x422476
jmp 0x422495
leaq 0x1db16d(%rip), %rdi    # 0x5fd5ea
leaq 0x1da063(%rip), %rsi    # 0x5fc4e7
movl $0x16f, %edx            # imm = 0x16F
leaq 0x1db108(%rip), %rcx    # 0x5fd598
callq 0x53d020
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
movups 0x88(%rax,%rcx), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
leaq 0x88(%rax,%rcx), %rdi
callq 0x422620
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4225b0
movq %rax, -0x30(%rbp)
jmp 0x422517
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x422586
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x422590
movq -0x20(%rbp), %rdi
callq 0x4751c0
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x422640
jmp 0x42254f
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4224f0
movq %rax, -0x40(%rbp)
jmp 0x422562
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
callq 0x475230
jmp 0x422586
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x475230
jmp 0x422584
jmp 0x422590
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5283c0
movq %rax, %rdi
callq 0x4082e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::put_encoded(Monodisperse2D const&)
key_t put_encoded (const CellData &cd)
    {
        key_t k = make_base_key (cd.coord);
        k = find_spot (k);
        data_[k] = cd;
        return k;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x41ea90
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4236f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
addq $0x88, %rax
movq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: std::array<double, 3ul> Storage<Monodisperse3D>::to_vector<std::array<double, 3ul>, double (Storage<Monodisperse3D>::*)(unsigned int) const>(double (Storage<Monodisperse3D>::*)(unsigned int) const) const
VECTOR to_vector (PTR_TO_MEMBERFUNC func) const
    {
        VECTOR ret;
        for (unsigned n = 0; n != ret.size (); ++n)
            ret[n] = (this->*func) (n);
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x48(%rbp), %rdi
movl -0x2c(%rbp), %eax
movq %rax, -0x50(%rbp)
callq 0x4181f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
je 0x42fbf0
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0x42fbb1
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x68(%rbp)
jmp 0x42fbb9
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rax
movl -0x2c(%rbp), %esi
callq *%rax
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x70(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x419310
movsd -0x70(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x42fb5b
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x48(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x423761
movq -0x30(%rbp), %rdi
addq $0x88, %rdi
movq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x41dff0
testb $0x1, %al
jne 0x423751
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4237c7
jmp 0x423753
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x42371e
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rdi), %rax
movl $0x2, %esi
callq *0x48(%rax)
movq -0x40(%rbp), %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x4237aa
movq -0x30(%rbp), %rax
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4237c7
movl $0x1, %edi
callq 0x475060
movq %rax, %rdi
leaq 0x268e52(%rip), %rsi    # 0x68c610
xorl %eax, %eax
movl %eax, %edx
callq 0x4760b0
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Cell-veto[P]postlhc/./tools.hpp
// Function: Histogram::add(double)
void add (double value)
    {
        size_t i = (value-low_) / bin_wid_;
        if (i < size ())
            ++data_[i];
        ++num_sampl_;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x18(%rdi), %xmm1
movsd 0x20(%rdi), %xmm2
subsd %xmm2, %xmm0
divsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x1d8a31(%rip), %xmm1   # 0x5fc388
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x4239b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x42399a
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x423c90
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41aa30
movq -0x30(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x41b860
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x423bcf
movq -0x30(%rbp), %rdi
addq $0x600, %rdi            # imm = 0x600
xorl %eax, %eax
movl %eax, %esi
callq 0x41b830
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x423c76
cmpl $0x40, -0x24(%rbp)
jae 0x423c52
movq -0x30(%rbp), %rdi
addq $0x600, %rdi            # imm = 0x600
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x41b830
movq -0x30(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x400, %rdi            # imm = 0x400
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x41b830
movsd -0x40(%rbp), %xmm0
movsd 0x1d73f9(%rip), %xmm1   # 0x5fb018
addsd (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
callq 0x51ef10
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x423c76
jmp 0x423c54
movq $0x698ac0, %rdi         # imm = 0x698AC0
leaq 0x1d9bd5(%rip), %rsi    # 0x5fd837
callq 0x4e1b60
movq %rax, %rdi
leaq 0x2739b0(%rip), %rsi    # 0x697621
callq 0x46d700
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0x2, %eax
je 0x43269e
movq $0x698ac0, %rdi         # imm = 0x698AC0
leaq 0x1ccaa5(%rip), %rsi    # 0x5ff12f
callq 0x4e1b60
movq %rax, %rdi
leaq 0x264fe0(%rip), %rsi    # 0x697679
callq 0x46d700
movq -0x50(%rbp), %rax
movsd 0x40(%rax), %xmm0
xorl %eax, %eax
ucomisd -0x18(%rbp), %xmm0
movb %al, -0x51(%rbp)
jne 0x4326df
jp 0x4326df
movq -0x50(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x28(%rax)
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4331e0
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x4326e8
jmp 0x4326ea
jmp 0x43272b
movq -0x50(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x40(%rax)
movq -0x10(%rbp), %rsi
movq (%rsi), %rax
leaq -0x48(%rbp), %rdi
callq *0x28(%rax)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, 0x20(%rdi)
movq -0x40(%rbp), %rax
movq %rax, 0x28(%rdi)
movq -0x38(%rbp), %rax
movq %rax, 0x30(%rdi)
movq -0x10(%rbp), %rsi
callq 0x433290
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Cell-veto[P]postlhc/./vector.hpp
// Function: bool vector_math_for_std_array::operator==<double, 3ul, Periods>(std::array<double, 3ul> const&, Periods const&)
bool operator== (const std::array <TYPE, DIM> &lhs, const VEC2 &rhs)
    {
        using detail::vector_dimension;
        assert (DIM == vector_dimension (rhs));
        for (size_t n = 0; n != DIM; ++n)
        {
            if (! (lhs[n] == rhs[n]))
                return false;
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x433650
movq %rax, %rcx
movl $0x3, %eax
cmpq %rcx, %rax
jne 0x433208
jmp 0x433227
leaq 0x1cbf3c(%rip), %rdi    # 0x5ff14b
leaq 0x1c9733(%rip), %rsi    # 0x5fc949
movl $0xaf, %edx
leaq 0x1cbf47(%rip), %rcx    # 0x5ff169
callq 0x53d020
movq $0x0, -0x20(%rbp)
cmpq $0x3, -0x20(%rbp)
je 0x43327e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x41da30
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x41da30
movsd -0x28(%rbp), %xmm0
ucomisd (%rax), %xmm0
jne 0x433268
jp 0x433268
jmp 0x43326e
movb $0x0, -0x1(%rbp)
jmp 0x433282
jmp 0x433270
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x43322f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Cell-veto[P]postlhc/jellium4.cpp
// Function: GridIndices<2> Jellium4<2u, Monodisperse2D>::get_cell_grid<Storage<Monodisperse2D>>(Storage<Monodisperse2D> const&)
static
    GridIndices <DIM> get_cell_grid (const STORAGE &stor)
    {
        std::array <int, DIM> low, high;
        for (size_t n = 0; n != DIM; ++n)
        {
            int c = stor.cell_count (n);
            low[n] = 0 - c/2;
            high[n] = c - c/2;
        }
        return GridIndices <DIM> (low, high);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x2, -0x30(%rbp)
je 0x43376f
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %esi
movq (%rdi), %rax
callq *0x48(%rax)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x434060
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x34(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x434060
movl -0x38(%rbp), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4336f4
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x434090
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Cell-veto[P]postlhc/jellium4.cpp
// Function: GridIndices<2>::begin() const
iterator begin () const
    {
        iterator ret (*this);
        for (size_t n = 0; n != DIM; ++n)
            ret.pos_[n] = low_[n];
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
callq 0x434220
movq $0x0, -0x10(%rbp)
cmpq $0x2, -0x10(%rbp)
je 0x433825
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x434250
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rsi
callq 0x434060
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4337ec
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Cell-veto[P]postlhc/jellium4.cpp
// Function: GridIndices<2>::end() const
iterator end () const
    {
        iterator ret (*this);
        ret.pos_[0] = high_[0];
        for (size_t n = 1; n != DIM; ++n)
            ret.pos_[n] = low_[n];
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
callq 0x434220
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x434250
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x434060
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movq $0x1, -0x10(%rbp)
cmpq $0x2, -0x10(%rbp)
je 0x4338bd
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x434250
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rsi
callq 0x434060
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x433884
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4339fb
jmp 0x433a1a
leaq 0x1cb84d(%rip), %rdi    # 0x5ff24f
leaq 0x1c8f40(%rip), %rsi    # 0x5fc949
movl $0x7e, %edx
leaq 0x1cb843(%rip), %rcx    # 0x5ff258
callq 0x53d020
movq -0x20(%rbp), %rax
cvtsi2sdl (%rax), %xmm1
movsd 0x1c75ee(%rip), %xmm0   # 0x5fb018
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x2, -0x30(%rbp)
je 0x433a81
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x418dc0
movsd (%rax), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x418e10
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x433a3b
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Cell-veto[P]postlhc/jellium4.cpp
// Function: GridIndices<2>::iterator::operator++()
iterator &operator++ ()
        {
            for (size_t n = DIM-1; n != 0; --n)
            {
                if (++pos_[n] == high_[n])
                    pos_[n] = low_[n];
                else
                    return *this;
            }
            ++pos_[0];
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x433f29
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x434060
movq -0x20(%rbp), %rdi
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movl %ecx, (%rax)
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x434250
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl (%rcx), %eax
jne 0x433f0f
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x434250
movq -0x20(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
callq 0x434060
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x433f19
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x433f48
jmp 0x433f1b
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x433eac
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x434060
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %edx
addl $0x1, %edx
movl %edx, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x433f8f
jp 0x433f8f
jmp 0x433fad
movq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x41ffd0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x4346a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x420080
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4200b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4209d0
testb $0x1, %al
jne 0x43400d
jmp 0x434040
leaq -0x18(%rbp), %rdi
callq 0x421040
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
leaq -0x18(%rbp), %rdi
callq 0x420fe0
jmp 0x433ffa
movq -0x30(%rbp), %rdi
callq 0x420670
cmpq $0x0, %rax
jne 0x434051
jmp 0x43405a
movq -0x30(%rbp), %rdi
callq 0x434dd0
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
je 0x435d5e
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %edx
addl $0x1, %edx
movl %edx, %edx
cmpq 0xb0(%rcx,%rdx,8), %rax
jae 0x435d51
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq 0xb0(%rdi,%rax,8), %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x4, %eax
subl -0x14(%rbp), %eax
imull $0x6, %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x10(%rbp)
addq $0x38, %rdi
movl -0x14(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x423cd0
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x435d53
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x435cdf
movq $0x698ac0, %rdi         # imm = 0x698AC0
leaq 0x1c96a4(%rip), %rsi    # 0x5ff410
callq 0x4e1b60
movq %rax, %rdi
leaq 0x2618fe(%rip), %rsi    # 0x697679
callq 0x46d700
// File: Cell-veto[P]postlhc/ipl.cpp
// Function: double IPL::lr_event_rate<std::array<double, 2ul>>(std::array<double, 2ul> const&, unsigned int)
double lr_event_rate (const VECTOR &dist, unsigned direction)
    {
        double rsq = norm_sq (dist);
        if (rsq < sq (sr_lr_split))
            return 0.;
        double rate = unit_directional_derivative (dist[direction], rsq);
        if (rate <= 0.)
            return 0.;
        else
            return stren * rate;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41c000
movq -0x40(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x18(%rax), %xmm0
callq 0x418110
movsd -0x38(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x43d616
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x43d662
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x418dc0
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x41c270
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jb 0x43d64f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x43d662
movq -0x40(%rbp), %rax
movsd 0x8(%rax), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x43d6fb
jmp 0x43d71a
leaq 0x1c2758(%rip), %rdi    # 0x5ffe5a
leaq 0x1c2674(%rip), %rsi    # 0x5ffd7d
movl $0x59, %edx
leaq 0x1c2784(%rip), %rcx    # 0x5ffe99
callq 0x53d020
movq -0x60(%rbp), %rax
movq -0x20(%rbp), %rdi
movsd 0x18(%rax), %xmm0
callq 0x46e1b0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpq $0x2, %rax
je 0x43d81d
movq -0x60(%rbp), %rax
movsd -0x28(%rbp), %xmm1
movl -0x2c(%rbp), %ecx
movsd 0x28(%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x43d80d
movq -0x60(%rbp), %rax
movq -0x20(%rbp), %rdi
movsd 0x20(%rax), %xmm0
movl -0x2c(%rbp), %ecx
cvtsi2sd %rcx, %xmm1
addsd %xmm1, %xmm0
movsd 0x10(%rax), %xmm1
subsd (%rax), %xmm1
callq 0x46e3c0
movq -0x60(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
callq 0x46e580
movq -0x60(%rbp), %rax
movsd %xmm0, -0x48(%rbp)
movsd %xmm1, -0x40(%rbp)
movq -0x18(%rbp), %rcx
movq -0x48(%rbp), %rdx
movq %rdx, (%rcx)
movq -0x40(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movsd -0x38(%rbp), %xmm0
subsd (%rax), %xmm0
movsd 0x20(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0x1bd827(%rip), %xmm2   # 0x5fb018
subsd %xmm2, %xmm1
movsd 0x1bd81b(%rip), %xmm2   # 0x5fb018
subsd %xmm2, %xmm1
callq 0x51ef10
movsd %xmm0, -0x8(%rbp)
jmp 0x43d85a
jmp 0x43d80f
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x43d738
movq -0x60(%rbp), %rax
movq -0x20(%rbp), %rdi
movsd 0x10(%rax), %xmm0
callq 0x46e710
movq -0x60(%rbp), %rax
movsd %xmm0, -0x58(%rbp)
movsd %xmm1, -0x50(%rbp)
movq -0x18(%rbp), %rcx
movq -0x58(%rbp), %rdx
movq %rdx, (%rcx)
movq -0x50(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x43e24a
jmp 0x43e269
leaq 0x1c1c09(%rip), %rdi    # 0x5ffe5a
leaq 0x1c1b25(%rip), %rsi    # 0x5ffd7d
movl $0x70, %edx
leaq 0x1c1e08(%rip), %rcx    # 0x60006c
callq 0x53d020
movq -0x10(%rbp), %rdi
callq 0x41aa30
movq -0x38(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movsd 0x10(%rax), %xmm3
movsd -0x20(%rbp), %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
maxsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
subsd (%rax), %xmm0
movsd 0x20(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0x1bcd43(%rip), %xmm2   # 0x5fb018
subsd %xmm2, %xmm1
movsd 0x1bcd37(%rip), %xmm2   # 0x5fb018
subsd %xmm2, %xmm1
callq 0x51ef10
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x41bfc0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0x43e31c
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x43e325
jmp 0x43e327
jmp 0x43e346
leaq 0x1c1d8d(%rip), %rdi    # 0x6000bb
leaq 0x1c1a48(%rip), %rsi    # 0x5ffd7d
movl $0x75, %edx
leaq 0x1c1d2b(%rip), %rcx    # 0x60006c
callq 0x53d020
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1bd38a(%rip), %rsi    # 0x600332
callq 0x407c80
testb $0x1, %al
jne 0x442fb3
jmp 0x442ff5
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x442fc3
jmp 0x442fe2
leaq 0x1bd36f(%rip), %rdi    # 0x600339
leaq 0x1bd373(%rip), %rsi    # 0x600344
movl $0xe, %edx
leaq 0x1bd36f(%rip), %rcx    # 0x60034c
callq 0x53d020
movq -0x58(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
jmp 0x44307b
movq -0x10(%rbp), %rdi
leaq 0x1b83e0(%rip), %rsi    # 0x5fb3e0
callq 0x407c80
testb $0x1, %al
jne 0x44300b
jmp 0x443067
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4771f0
movq -0x60(%rbp), %rdx
leaq 0x1bd35e(%rip), %rsi    # 0x600381
leaq -0x38(%rbp), %rdi
callq 0x407bd0
jmp 0x44302e
leaq -0x38(%rbp), %rdi
callq 0x46d330
jmp 0x443039
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x44305c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4f1e40
leaq -0x39(%rbp), %rdi
callq 0x477210
jmp 0x443081
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x417b70
jmp 0x44307b
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5283c0
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/./lj.hpp
// Function: LennardJones::LennardJones()
LennardJones ()
    {
        strength = 1.;
        sr_lr_split = 1.;
        scale = 2.;
        set_parameter ("cutoff", INFINITY);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x40, %rdi
callq 0x43c260
movq -0x50(%rbp), %rax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
movq %rcx, 0x8(%rax)
movabsq $0x4000000000000000, %rcx # imm = 0x4000000000000000
movq %rcx, 0x10(%rax)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4771f0
movq -0x48(%rbp), %rdx
leaq 0x1b82aa(%rip), %rsi    # 0x600332
leaq -0x28(%rbp), %rdi
callq 0x407bd0
jmp 0x448093
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movsd 0x1b427d(%rip), %xmm0   # 0x5fc320
callq 0x449a50
jmp 0x4480aa
leaq -0x28(%rbp), %rdi
callq 0x4f1e40
leaq -0x29(%rbp), %rdi
callq 0x477210
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4480e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4f1e40
leaq -0x29(%rbp), %rdi
callq 0x477210
movq -0x38(%rbp), %rdi
callq 0x5283c0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd 0x40(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
jne 0x44a1a0
jp 0x44a1a0
jmp 0x44a224
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x40(%rax)
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x38(%rbp)
movsd 0x8(%rax), %xmm0
mulsd 0x10(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x38(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movl %eax, %esi
movsd 0x1b20f3(%rip), %xmm1   # 0x5fc2d8
callq 0x43d110
movq $0x698ac0, %rdi         # imm = 0x698AC0
leaq 0x1b3054(%rip), %rsi    # 0x5fd24c
callq 0x4e1b60
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
xorl %esi, %esi
callq 0x44acd0
movq -0x28(%rbp), %rdi
callq 0x4e2ad0
movq %rax, %rdi
leaq 0x1c41eb(%rip), %rsi    # 0x60e40a
callq 0x4e1b60
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd 0x10(%rax), %xmm0
callq 0x418110
movq -0x58(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd 0x20(%rax), %xmm0
callq 0x418110
movsd -0x60(%rbp), %xmm3
movaps %xmm0, %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
minsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x449da0
movq -0x58(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x41f030
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x1b5fc1(%rip), %xmm0   # 0x600eb8
addsd -0x38(%rbp), %xmm0
callq 0x51f030
movaps %xmm0, %xmm1
movsd 0x1b1394(%rip), %xmm0   # 0x5fc2a0
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd 0x1b5f8e(%rip), %xmm1   # 0x600eb0
callq 0x51ef10
movq -0x58(%rbp), %rax
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x20(%rax), %xmm0
callq 0x418110
movsd -0x50(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x44af51
jmp 0x44af70
leaq 0x1b605f(%rip), %rdi    # 0x600fb7
leaq 0x1b6073(%rip), %rsi    # 0x600fd2
movl $0x73, %edx
leaq 0x1b6070(%rip), %rcx    # 0x600fdb
callq 0x53d020
movq -0x58(%rbp), %rax
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd 0x10(%rax), %xmm0
callq 0x418110
movaps %xmm0, %xmm2
movsd -0x70(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/./lj.hpp
// Function: double LennardJones::lr_event_rate<std::array<double, 2ul>>(std::array<double, 2ul> const&, unsigned long)
double lr_event_rate (const VECTOR &r, size_t direction)
    {
        double rsq = norm_sq (r) / sq (scale);

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41c000
movq -0x50(%rbp), %rax
movsd %xmm0, -0x48(%rbp)
movsd 0x10(%rax), %xmm0
callq 0x418110
movq -0x50(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x8(%rax), %xmm0
callq 0x418110
movsd -0x40(%rbp), %xmm1
ucomisd %xmm1, %xmm0
ja 0x44b2a2
movq -0x50(%rbp), %rax
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x18(%rax), %xmm0
callq 0x418110
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x44b2af
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x44b341
movsd -0x28(%rbp), %xmm0
movsd 0x1b10ac(%rip), %xmm1   # 0x5fc368
callq 0x51ef10
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x1b5bf5(%rip), %xmm1   # 0x600ec8
mulsd %xmm1, %xmm0
movsd 0x1b5bf1(%rip), %xmm1   # 0x600ed0
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x418dc0
movsd -0x60(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x38(%rbp), %xmm0
jb 0x44b317
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x44b341
movq -0x50(%rbp), %rax
movsd -0x38(%rbp), %xmm0
mulsd (%rax), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd 0x10(%rax), %xmm1
mulsd 0x10(%rax), %xmm1
mulsd -0x28(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movabsq $0x4014000000000000, %rcx # imm = 0x4014000000000000
movq %rcx, (%rax)
movabsq $0x3ffccccccccccccd, %rcx # imm = 0x3FFCCCCCCCCCCCCD
movq %rcx, 0x8(%rax)
movabsq $0x3ff851eb851eb852, %rcx # imm = 0x3FF851EB851EB852
movq %rcx, 0x10(%rax)
movabsq $0x3f947ae147ae147b, %rcx # imm = 0x3F947AE147AE147B
movq %rcx, 0x18(%rax)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4771f0
movq -0x48(%rbp), %rdx
leaq 0x1ade7f(%rip), %rsi    # 0x600332
leaq -0x28(%rbp), %rdi
callq 0x407bd0
jmp 0x4524be
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movsd 0x1af702(%rip), %xmm0   # 0x601bd0
callq 0x453e50
jmp 0x4524d5
leaq -0x28(%rbp), %rdi
callq 0x4f1e40
leaq -0x29(%rbp), %rdi
callq 0x477210
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x452510
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4f1e40
leaq -0x29(%rbp), %rdi
callq 0x477210
movq -0x38(%rbp), %rdi
callq 0x5283c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rsi
callq 0x4551a0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x1a5f46(%rip), %xmm0   # 0x5fb018
callq 0x418110
movsd -0x28(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x4550fd
movq -0x30(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rsi
callq 0x455310
leaq -0x20(%rbp), %rdi
callq 0x433e40
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rsi
callq 0x455430
movq -0x30(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x10(%rax), %xmm0
callq 0x418110
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x455181
movq -0x30(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rsi
callq 0x455600
leaq -0x20(%rbp), %rdi
callq 0x4555b0
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::random_repulsive_lift_g(double, RandomContext*)
double random_repulsive_lift_g (double rsq, RandomContext *random)
    {
        rsq = fmin (rsq, sq (gauss_r0));

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x10(%rax), %xmm0
callq 0x418110
movsd -0x50(%rbp), %xmm3
movq -0x48(%rbp), %rdi
movaps %xmm0, %xmm2
movaps %xmm2, %xmm4
movaps %xmm3, %xmm0
cmpunordsd %xmm0, %xmm0
movaps %xmm0, %xmm1
pand %xmm4, %xmm1
minsd %xmm3, %xmm2
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x454180
movq -0x48(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x41f030
movq -0x48(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd 0x38(%rax), %xmm0
jb 0x45526a
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4552ff
movq -0x48(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm0
movsd 0x8(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
divsd %xmm1, %xmm0
callq 0x51eed0
movq -0x48(%rbp), %rax
divsd 0x28(%rax), %xmm0
callq 0x51f030
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4552d1
jmp 0x4552f0
leaq 0x1aca24(%rip), %rdi    # 0x601cfc
leaq 0x1aca28(%rip), %rsi    # 0x601d07
movl $0x7b, %edx
leaq 0x1aca24(%rip), %rcx    # 0x601d0f
callq 0x53d020
movsd -0x40(%rbp), %xmm0
callq 0x418110
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)