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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x1a5cd9(%rip), %xmm0   # 0x5fb018
callq 0x418110
movsd -0x58(%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, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x454130
movq -0x50(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x41f030
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x1a5c6d(%rip), %xmm0   # 0x5fb018
addsd -0x30(%rbp), %xmm0
callq 0x51f030
movaps %xmm0, %xmm1
movsd 0x1a5c58(%rip), %xmm0   # 0x5fb018
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd 0x1abada(%rip), %xmm1   # 0x600eb0
callq 0x51ef10
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x1a5c26(%rip), %xmm0   # 0x5fb018
callq 0x418110
movsd -0x48(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x455404
jmp 0x455423
leaq 0x1ac94f(%rip), %rdi    # 0x601d5a
leaq 0x1ac8f5(%rip), %rsi    # 0x601d07
movl $0x65, %edx
leaq 0x1ac957(%rip), %rcx    # 0x601d75
callq 0x53d020
movsd -0x40(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::random_attractive_lift_lj(double, RandomContext*)
double random_attractive_lift_lj (double rsq, RandomContext *random)
    {
        rsq = fmax (rsq, sq (LJ_MINIMUM));

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x1a5bb9(%rip), %xmm0   # 0x5fb018
callq 0x418110
movsd -0x58(%rbp), %xmm3
movaps %xmm0, %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, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x454130
movq -0x50(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x41f030
movq -0x50(%rbp), %rax
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd 0x40(%rax), %xmm0
jb 0x4554e2
callq 0x44b1b0
movsd %xmm0, -0x8(%rbp)
jmp 0x4555a4
movsd 0x1a5b2e(%rip), %xmm0   # 0x5fb018
addsd -0x38(%rbp), %xmm0
callq 0x51f030
movaps %xmm0, %xmm1
movsd 0x1a5b19(%rip), %xmm0   # 0x5fb018
subsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd 0x1ab99b(%rip), %xmm1   # 0x600eb0
callq 0x51ef10
movq -0x50(%rbp), %rax
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd 0x20(%rax), %xmm0
callq 0x418110
movsd -0x68(%rbp), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x59(%rbp)
jb 0x455570
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd 0x1a5abf(%rip), %xmm0   # 0x5fb018
callq 0x418110
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x455579
jmp 0x45557b
jmp 0x45559a
leaq 0x1ac83f(%rip), %rdi    # 0x601dc1
leaq 0x1ac77e(%rip), %rsi    # 0x601d07
movl $0x9b, %edx
leaq 0x1ac861(%rip), %rcx    # 0x601df6
callq 0x53d020
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nop
// File: Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::random_attractive_lift_g(double, RandomContext*)
double random_attractive_lift_g (double rsq, RandomContext *random)
    {
        rsq = fmax (rsq, sq (gauss_r0));

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

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

// Assembly:
pushq %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
maxsd %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 0x30(%rax), %xmm0
jb 0x4556b0
callq 0x44b1b0
movsd %xmm0, -0x8(%rbp)
jmp 0x455716
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
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0x418110
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Cell-veto[P]postlhc/./harddisk.hpp
// Function: HardInteraction::set_parameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double)
void set_parameter (string_ref name, double value)
    {
        if (name == "diameter")
        {
            if (! (value > 0.))
                rt_error ("Invalid particle diameter");
            diameter = value;
        }
        else
        {
            rt_error ("Invalid parameter: " + name);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1a78eb(%rip), %rsi    # 0x602636
callq 0x407c80
testb $0x1, %al
jne 0x45ad56
jmp 0x45adcf
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
ja 0x45adc0
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4771f0
movq -0x80(%rbp), %rdx
leaq 0x1a78a9(%rip), %rsi    # 0x602625
leaq -0x38(%rbp), %rdi
callq 0x407bd0
jmp 0x45ad87
leaq -0x38(%rbp), %rdi
callq 0x46d330
jmp 0x45ad92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x45adb5
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 0x45ae18
movq -0x78(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x45ae0f
movq -0x10(%rbp), %rdx
leaq 0x1a1696(%rip), %rsi    # 0x5fc470
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x407fd0
movq -0x88(%rbp), %rdi
callq 0x46d330
jmp 0x45adf8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4f1e40
jmp 0x45ae18
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5283c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Cell-veto[P]postlhc/./tools.hpp
// Function: Factory<AbstractStorage>::make(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static ABSTRACT *make (string typecode)
    {
        Factory *f = registry () [typecode];
        if (!f)
            rt_error ("no factory to make product " + typecode);
        ABSTRACT *prod = f->make ();
        prod->typecode_ = typecode;
        return prod;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x45fba0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x45fc00
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x45f9a9
movq -0x50(%rbp), %rdx
leaq 0x1a34b3(%rip), %rsi    # 0x602e2d
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x407fd0
movq -0x58(%rbp), %rdi
callq 0x46d330
jmp 0x45f992
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4f1e40
jmp 0x45f9d1
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x50(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x4f1e70
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5283c0
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::Storage()
Storage ()
    {
        num_cells_ = num_ = 0;
        nextsub_ = 0;
        for (unsigned n = 0; n != DIM; ++n)
            bc_[n] = 4;
        bc_[0] = 3;
        bc_[DIM] = 4;
        subdivide (true);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x461060
movq -0x20(%rbp), %rdi
leaq 0x22c3b4(%rip), %rax    # 0x68d348
movq %rax, (%rdi)
addq $0x50, %rdi
callq 0x4610a0
jmp 0x460fa2
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq $0x0, 0x28(%rax)
movl $0x0, 0x38(%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
je 0x460ffb
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl $0x4, 0x3c(%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x460fc4
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x4618a0
jmp 0x46101f
movq -0x20(%rbp), %rdi
movl $0x3, 0x3c(%rdi)
movl $0x4, 0x44(%rdi)
movl $0x1, %esi
callq 0x422640
jmp 0x461019
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x5283c0
nopl (%rax,%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::insert(MostGeneralParticle const&)
key_t insert (const MostGeneralParticle &part)
    {
        // guard against invalid user input
        for (unsigned n = 0; n != DIM; ++n)
        {
            if (! (part.coords[n] >= 0.) || ! (part.coords[n] < period (n)))
            {
                std::cerr << "particle coordinate invalid: 0 <= "
                    << part.coords[n] << " < " << period (n) << " is violated"
                    << ABORT;
            }
        }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
je 0x461a8a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x41da30
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x461a02
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x41da30
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x14(%rbp), %esi
callq 0x41df90
movsd -0x40(%rbp), %xmm1
ucomisd %xmm1, %xmm0
ja 0x461a7a
movq $0x698ac0, %rdi         # imm = 0x698AC0
leaq 0x1a1439(%rip), %rsi    # 0x602e49
callq 0x4e1b60
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x41da30
movq -0x50(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x4e2ad0
movq %rax, %rdi
leaq 0x1a142e(%rip), %rsi    # 0x602e6c
callq 0x4e1b60
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %esi
callq 0x41df90
movq -0x48(%rbp), %rdi
callq 0x4e2ad0
movq %rax, %rdi
leaq 0x1a140a(%rip), %rsi    # 0x602e70
callq 0x4e1b60
movq %rax, %rdi
leaq 0x235c94(%rip), %rsi    # 0x697709
callq 0x46d700
jmp 0x461a7c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4619af
movq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x461af0
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
leaq -0x28(%rbp), %rdi
callq 0x461c90
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
leaq -0x28(%rbp), %rdi
callq 0x461ca0
movq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4224f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::encode_coords(unsigned long*, std::array<double, 3ul> const&) const
void encode_coords (uint64_t frac[DIM], const vector <MAX_DIM> &real) const
    {
        unsigned n = 0;
        for (; n != DIM; ++n)
        {
            assert (real[n] >= 0.);
            assert (real[n] < peri_[n]);
            frac[n] = real2frac[n] * real[n];
        }
        for (; n != MAX_DIM; ++n)
            assert (real[n] == 0.);
        // in_use flag
        frac[1] |= 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0x461c1b
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x41da30
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x461b3a
jmp 0x461b59
leaq 0x1a133c(%rip), %rdi    # 0x602e7d
leaq 0x19a99f(%rip), %rsi    # 0x5fc4e7
movl $0x13f, %edx            # imm = 0x13F
leaq 0x1a1337(%rip), %rcx    # 0x602e8b
callq 0x53d020
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x41da30
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0x50, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x41da30
movsd -0x30(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x461b93
jmp 0x461bb2
leaq 0x1a1364(%rip), %rdi    # 0x602efe
leaq 0x19a946(%rip), %rsi    # 0x5fc4e7
movl $0x140, %edx            # imm = 0x140
leaq 0x1a12de(%rip), %rcx    # 0x602e8b
callq 0x53d020
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
movsd 0x68(%rax,%rsi,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41da30
movsd -0x38(%rbp), %xmm0
movsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rdx
movq %rdx, %rcx
sarq $0x3f, %rcx
movsd 0x19a795(%rip), %xmm1   # 0x5fc388
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rcx, %rax
orq %rax, %rdx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x461b13
jmp 0x461c1d
cmpl $0x3, -0x1c(%rbp)
je 0x461c6e
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x41da30
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x461c42
jp 0x461c42
jmp 0x461c61
leaq 0x1a12c8(%rip), %rdi    # 0x602f11
leaq 0x19a897(%rip), %rsi    # 0x5fc4e7
movl $0x144, %edx            # imm = 0x144
leaq 0x1a122f(%rip), %rcx    # 0x602e8b
callq 0x53d020
jmp 0x461c63
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x461c1d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
orq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Cell-veto[P]postlhc/io.cpp
// Function: Periods::from_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Periods Periods::from_file (string_ref filename)
{
    Periods periods (MAX_DIM, 0.);
    std::ifstream ifs (filename);
    if (!ifs)
        rt_error ("error opening file: " + filename);
    ifs >> periods[0] >> periods[1];
    if (!ifs)
        goto error;
    ifs >> periods[2] >> std::ws;
    if (ifs.eof ())
        return periods;
error:
    rt_error ("error reading file: " + filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x278(%rbp)
movq %rdi, %rax
movq %rax, -0x270(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x3, %esi
xorps %xmm0, %xmm0
callq 0x417830
movq -0x8(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x4be090
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x4c2500
movb %al, -0x261(%rbp)
jmp 0x463c02
movb -0x261(%rbp), %al
testb $0x1, %al
jne 0x463c0e
jmp 0x463c6f
movq -0x8(%rbp), %rdx
leaq 0x19f6ef(%rip), %rsi    # 0x603308
leaq -0x240(%rbp), %rdi
callq 0x407fd0
jmp 0x463c27
leaq -0x240(%rbp), %rdi
callq 0x46d330
jmp 0x463c35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x463db7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x4f1e40
jmp 0x463db7
movq -0x278(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x419310
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
callq 0x4c8600
movq %rax, -0x280(%rbp)
jmp 0x463c97
movq -0x278(%rbp), %rdi
movl $0x1, %esi
callq 0x419310
movq -0x280(%rbp), %rdi
movq %rax, %rsi
callq 0x4c8600
jmp 0x463cb9
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x4c2500
movb %al, -0x281(%rbp)
jmp 0x463cd9
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x463ce5
jmp 0x463cea
jmp 0x463d72
movq -0x278(%rbp), %rdi
movl $0x2, %esi
callq 0x419310
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
callq 0x4c8600
movq %rax, -0x290(%rbp)
jmp 0x463d13
movq -0x290(%rbp), %rdi
movq $0x4c7610, %rsi         # imm = 0x4C7610
callq 0x4c54e0
jmp 0x463d28
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x4c25a0
movb %al, -0x291(%rbp)
jmp 0x463d48
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x463d54
jmp 0x463d70
leaq -0x210(%rbp), %rdi
callq 0x4bedc0
movq -0x270(%rbp), %rax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
jmp 0x463d72
movq -0x8(%rbp), %rdx
leaq 0x19f5a0(%rip), %rsi    # 0x60331d
leaq -0x260(%rbp), %rdi
callq 0x407fd0
jmp 0x463d8b
leaq -0x260(%rbp), %rdi
callq 0x46d330
jmp 0x463d99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x4f1e40
leaq -0x210(%rbp), %rdi
callq 0x4bedc0
movq -0x218(%rbp), %rdi
callq 0x5283c0
nop
// File: Cell-veto[P]postlhc/io.cpp
// Function: Periods::savetxt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Periods::savetxt (string_ref filename)
{
    std::ofstream ofs (filename);
    if (!ofs)
        rt_error ("error opening file: " + filename);
    ofs.precision (15);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x290(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x4be200
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x4c2500
movb %al, -0x281(%rbp)
jmp 0x463e23
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x463e2f
jmp 0x463e90
movq -0x10(%rbp), %rdx
leaq 0x19f4ce(%rip), %rsi    # 0x603308
leaq -0x240(%rbp), %rdi
callq 0x407fd0
jmp 0x463e48
leaq -0x240(%rbp), %rdi
callq 0x46d330
jmp 0x463e56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x463fd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x4f1e40
jmp 0x463fd4
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
movl $0xf, %esi
callq 0x4133d0
jmp 0x463eaf
movq -0x290(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x248(%rbp), %rdi
callq 0x4181d0
movq %rax, -0x250(%rbp)
movq -0x248(%rbp), %rdi
callq 0x465100
movq %rax, -0x258(%rbp)
movq -0x250(%rbp), %rax
cmpq -0x258(%rbp), %rax
je 0x463f4c
movq -0x250(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x260(%rbp)
movsd -0x260(%rbp), %xmm0
leaq -0x210(%rbp), %rdi
callq 0x4e2ad0
movq %rax, -0x298(%rbp)
jmp 0x463f23
movq -0x298(%rbp), %rdi
movl $0xa, %esi
callq 0x4e1a90
jmp 0x463f36
jmp 0x463f38
movq -0x250(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x250(%rbp)
jmp 0x463ee3
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x4c2500
movb %al, -0x299(%rbp)
jmp 0x463f6c
movb -0x299(%rbp), %al
testb $0x1, %al
jne 0x463f78
jmp 0x463fbf
movq -0x10(%rbp), %rdx
leaq 0x19f3af(%rip), %rsi    # 0x603332
leaq -0x280(%rbp), %rdi
callq 0x407fd0
jmp 0x463f91
leaq -0x280(%rbp), %rdi
callq 0x46d330
jmp 0x463f9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x4f1e40
jmp 0x463fd4
leaq -0x210(%rbp), %rdi
callq 0x4bec80
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x4bec80
movq -0x218(%rbp), %rdi
callq 0x5283c0
nopl (%rax)
// File: Cell-veto[P]postlhc/io.cpp
// Function: write_mono_particle_to_stream(std::ostream&, MostGeneralParticle const&, bool)
static
void write_mono_particle_to_stream (std::ostream &os, const MostGeneralParticle &part, bool tagged)
{
    if (MAX_DIM > 3u)
        std::cerr << "DIM>3 is not implemented" << ABORT;

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

    if (!os)
        throw IoError ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x41da30
movq -0x30(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x4e2ad0
movq %rax, %rdi
movl $0x20, %esi
callq 0x4e1a90
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x41da30
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x4e2ad0
movq %rax, %rdi
movl $0x20, %esi
callq 0x4e1a90
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x41da30
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x4e2ad0
testb $0x1, -0x11(%rbp)
je 0x4650ab
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x4e1a90
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x41da30
movq -0x48(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x4e2ad0
movq %rax, %rdi
movl $0x20, %esi
callq 0x4e1a90
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0x41da30
movq -0x40(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x4e2ad0
movq %rax, %rdi
movl $0x20, %esi
callq 0x4e1a90
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl $0x2, %esi
callq 0x41da30
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x4e2ad0
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x4e1a90
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4c2500
testb $0x1, %al
jne 0x4650cf
jmp 0x4650ec
movl $0x1, %edi
callq 0x475060
movq %rax, %rdi
leaq 0x2285c5(%rip), %rsi    # 0x68d6a8
xorl %eax, %eax
movl %eax, %edx
callq 0x4760b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Cell-veto[P]postlhc/paircorrel.cpp
// Function: AbstractCorrelator::savetxt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void AbstractCorrelator::savetxt (string_ref filename)
{
    std::ofstream ofs (filename);
    if (!ofs)
        rt_error ("cannot open file: " + filename);
    savetxt (ofs);
    if (!ofs)
        rt_error ("error writing data: " + filename);
    ofs.close ();
    if (!ofs)
        rt_error ("error writing data (2): " + filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x290(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x4be200
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x4c2500
movb %al, -0x281(%rbp)
jmp 0x468573
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x46857f
jmp 0x4685e0
movq -0x10(%rbp), %rdx
leaq 0x19aecb(%rip), %rsi    # 0x603455
leaq -0x240(%rbp), %rdi
callq 0x407fd0
jmp 0x468598
leaq -0x240(%rbp), %rdi
callq 0x46d330
jmp 0x4685a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x468705
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x4f1e40
jmp 0x468705
movq -0x290(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq -0x210(%rbp), %rsi
callq *%rax
jmp 0x4685f9
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x4c2500
movb %al, -0x291(%rbp)
jmp 0x468619
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x468625
jmp 0x46866f
movq -0x10(%rbp), %rdx
leaq 0x19ae38(%rip), %rsi    # 0x603468
leaq -0x260(%rbp), %rdi
callq 0x407fd0
jmp 0x46863e
leaq -0x260(%rbp), %rdi
callq 0x46d330
jmp 0x46864c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x4f1e40
jmp 0x468705
leaq -0x210(%rbp), %rdi
callq 0x4bea50
jmp 0x46867d
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x4c2500
movb %al, -0x292(%rbp)
jmp 0x46869d
movb -0x292(%rbp), %al
testb $0x1, %al
jne 0x4686a9
jmp 0x4686f0
movq -0x10(%rbp), %rdx
leaq 0x19adc9(%rip), %rsi    # 0x60347d
leaq -0x280(%rbp), %rdi
callq 0x407fd0
jmp 0x4686c2
leaq -0x280(%rbp), %rdi
callq 0x46d330
jmp 0x4686d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x4f1e40
jmp 0x468705
leaq -0x210(%rbp), %rdi
callq 0x4bec80
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x4bec80
movq -0x218(%rbp), %rdi
callq 0x5283c0
nopl (%rax)
// File: Cell-veto[P]postlhc/paircorrel.cpp
// Function: make_correlator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, AbstractStorage*, double, double)
AbstractCorrelator *make_correlator (string_ref attribute, AbstractStorage *stor,
    double bin_width, double rmax)
{
    AbstractCorrelator *ret = Factory <AbstractCorrelator>::make (
        attribute + "/" + stor->typecode ());
    ret->init (stor, bin_width, rmax);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x1a53d4(%rip), %rdx    # 0x60db1c
leaq -0x68(%rbp), %rdi
callq 0x408110
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x45fb90
movq %rax, -0x80(%rbp)
jmp 0x468764
movq -0x80(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x45fb40
jmp 0x468777
leaq -0x48(%rbp), %rdi
callq 0x468820
movq %rax, -0x88(%rbp)
jmp 0x468789
leaq -0x48(%rbp), %rdi
callq 0x4f1e40
leaq -0x68(%rbp), %rdi
callq 0x4f1e40
movq -0x88(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4687ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4f1e40
leaq -0x68(%rbp), %rdi
callq 0x4f1e40
movq -0x70(%rbp), %rdi
callq 0x5283c0
// File: Cell-veto[P]postlhc/paircorrel.cpp
// Function: Correlator<Monodisperse2D>::init(AbstractStorage*, double, double)
virtual void init (AbstractStorage *stor_, double bin_width, double rmax)
    {
        stor_t *stor = downcast (stor_);

        binwid_ = bin_width;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46a510
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0xbf8(%rax)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x469f10
jp 0x469f10
movq -0x50(%rbp), %rdi
addq $0xc08, %rdi            # imm = 0xC08
leaq 0x1bc7d4(%rip), %rsi    # 0x6266a9
callq 0x4f2e90
movq -0x28(%rbp), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %rdi
callq *0x28(%rax)
leaq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0x46a550
movq -0x50(%rbp), %rax
movsd 0x1923ae(%rip), %xmm1   # 0x5fc2b0
divsd %xmm1, %xmm0
movsd %xmm0, 0xc28(%rax)
jmp 0x469f67
movq -0x50(%rbp), %rdi
addq $0xc08, %rdi            # imm = 0xC08
leaq 0x1995a8(%rip), %rsi    # 0x6034ca
callq 0x4f2e90
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x469f37
jmp 0x469f56
leaq 0x199593(%rip), %rdi    # 0x6034d1
leaq 0x199596(%rip), %rsi    # 0x6034db
movl $0x24, %edx
leaq 0x199599(%rip), %rcx    # 0x6034ea
callq 0x53d020
movq -0x50(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0xc28(%rax)
movq -0x50(%rbp), %rdi
movq %rdi, %rax
addq $0xc30, %rax            # imm = 0xC30
movq %rax, -0x58(%rbp)
movsd 0xc28(%rdi), %xmm0
callq 0x46a680
movq -0x58(%rbp), %rdi
movq %rax, %xmm0
movaps 0x19240b(%rip), %xmm1   # 0x5fc3a0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x19240f(%rip), %xmm1   # 0x5fc3b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x192340(%rip), %xmm1   # 0x5fc2f8
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
movsd 0x1923b5(%rip), %xmm1   # 0x5fc388
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
andq %rcx, %rax
orq %rax, %rsi
movq $0x0, -0x48(%rbp)
leaq -0x48(%rbp), %rdx
callq 0x46a5d0
movq -0x50(%rbp), %rax
movq $0x0, 0xc48(%rax)
movq $0x0, 0xc50(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Cell-veto[P]postlhc/paircorrel.cpp
// Function: Correlator<Monodisperse2D>::sample(AbstractStorage*, unsigned long)
virtual void sample (AbstractStorage *stor_, size_t multiplier)
    {
        stor_t *stor = downcast (stor_);

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

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

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

        walltime_ += gclock ();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46a510
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x46b3c0
movq -0xb8(%rbp), %rax
movsd %xmm0, 0xc00(%rax)
movq -0x18(%rbp), %rcx
addq 0xc48(%rax), %rcx
movq %rcx, 0xc48(%rax)
callq 0x46d200
movq %rax, %rdx
movq -0xb8(%rbp), %rax
movq 0xc50(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xc50(%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x46a1ee
movq -0xb8(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x28, %rsi
callq 0x419340
movq -0xb8(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0xc08, %rdi            # imm = 0xC08
leaq 0x1bc5cd(%rip), %rsi    # 0x6266a9
callq 0x407c80
testb $0x1, %al
jne 0x46a0e7
jmp 0x46a158
movq -0x20(%rbp), %rsi
movq %rsi, -0xd0(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x46b510
movq -0xb8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq -0xc0(%rbp), %rcx
callq 0x46b430
jmp 0x46a130
leaq -0x48(%rbp), %rdi
callq 0x462020
jmp 0x46a1db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x462020
jmp 0x46a214
movq -0xb8(%rbp), %rax
movq -0x20(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
movq -0x30(%rbp), %rdx
movq %rdx, -0xe0(%rbp)
movsd 0xc28(%rax), %xmm0
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x46b620
movq -0xb8(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
movq -0xd8(%rbp), %rcx
callq 0x46b540
jmp 0x46a1b3
leaq -0xb0(%rbp), %rdi
callq 0x41e640
jmp 0x46a1db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x41e640
jmp 0x46a214
jmp 0x46a1dd
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x46a0a1
callq 0x46d200
movq %rax, %rcx
movq -0xb8(%rbp), %rax
addq 0xc50(%rax), %rcx
movq %rcx, 0xc50(%rax)
addq $0xf0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5283c0
nopl (%rax)
// File: Cell-veto[P]postlhc/paircorrel.cpp
// Function: void Correlator<Monodisperse2D>::do_sample<Storage<Monodisperse2D>::AllNewGenerator>(Storage<Monodisperse2D>*, unsigned long, Storage<Monodisperse2D>::AllNewGenerator)
void do_sample (stor_t *stor, key_t k1, GENERATOR g)
    {
        for (; g.not_done (); g.next ())
        {
            key_t k2 = g.key ();
            double r = norm (stor->distance_vector (k1, k2));
            unsigned i = bin (r);
            if (i < hist_.size ())
                ++hist_[i];
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rcx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rdi
callq 0x462070
testb $0x1, %al
jne 0x46b466
jmp 0x46b4ff
movq -0x58(%rbp), %rdi
callq 0x41e3c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x41e310
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41aa30
movq -0x50(%rbp), %rdi
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x46a680
movq -0x50(%rbp), %rdi
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq %rax, -0x60(%rbp)
addq $0xc30, %rdi            # imm = 0xC30
callq 0x423cb0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x46b4ef
movq -0x50(%rbp), %rdi
addq $0xc30, %rdi            # imm = 0xC30
movl -0x44(%rbp), %eax
movl %eax, %esi
callq 0x423c90
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x46b4f1
movq -0x58(%rbp), %rdi
callq 0x41e5e0
jmp 0x46b454
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::enumerate_box(unsigned long, double)
StripGenerator enumerate_box (key_t whence, double a)
    {
        if (! (a > 0))
            rt_error ("box width negative");
        for (unsigned n = 0; n != DIM; ++n)
            if (a > strip_max_extent (n))
                rt_error ("enumeration box too large / periods too small");
        return StripGenerator (*this, data_[whence].coord, 0, a, -a, a);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
ja 0x46b6cb
leaq -0x41(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4771f0
movq -0xa0(%rbp), %rdx
leaq 0x197f35(%rip), %rsi    # 0x6035b9
leaq -0x40(%rbp), %rdi
callq 0x407bd0
jmp 0x46b68f
leaq -0x40(%rbp), %rdi
callq 0x46d330
jmp 0x46b69a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x46b6bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4f1e40
leaq -0x41(%rbp), %rdi
callq 0x477210
jmp 0x46b7db
movl $0x0, -0x58(%rbp)
cmpl $0x2, -0x58(%rbp)
je 0x46b77b
movq -0x88(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
movl -0x58(%rbp), %esi
callq 0x41e040
movaps %xmm0, %xmm1
movsd -0xa8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x46b76b
leaq -0x79(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x4771f0
movq -0xb0(%rbp), %rdx
leaq 0x197ea5(%rip), %rsi    # 0x6035cc
leaq -0x78(%rbp), %rdi
callq 0x407bd0
jmp 0x46b732
leaq -0x78(%rbp), %rdi
callq 0x46d330
jmp 0x46b73d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x46b760
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4f1e40
leaq -0x79(%rbp), %rdi
callq 0x477210
jmp 0x46b7db
jmp 0x46b76d
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x46b6d2
movq -0x88(%rbp), %rsi
movq -0x98(%rbp), %rdi
movq %rsi, %rdx
addq $0x88, %rdx
movq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
movsd -0x20(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd -0x20(%rbp), %xmm2
xorl %ecx, %ecx
callq 0x41e660
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x5283c0
nopw %cs:(%rax,%rax)
nop
// File: Cell-veto[P]postlhc/tools.cpp
// Function: sigterm_caught()
bool sigterm_caught ()
{
    if (!sigterm_installed)
    {
        sigterm_caught_flag = false;
        sigterm_installed = true;
        signal (SIGTERM, sigterm_handler);
    }

    return sigterm_caught_flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testb $0x1, 0x22a55d(%rip)    # 0x6977d8
jne 0x46d29c
movb $0x0, 0x22a555(%rip)    # 0x6977d9
movb $0x1, 0x22a54d(%rip)    # 0x6977d8
movl $0xf, %edi
leaq 0x19(%rip), %rsi        # 0x46d2b0
callq 0x543280
movb 0x22a537(%rip), %al     # 0x6977d9
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Cell-veto[P]postlhc/tools.cpp
// Function: remove_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
bool remove_file (string_ref path, bool ignore_failure)
{
    if (::unlink (path.c_str ()) != 0 && !ignore_failure)
    {
        rt_error ("unlink failed for " + path);
        return false;
    }
    else
    {
        return true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4f3880
movq %rax, %rdi
callq 0x5afac0
cmpl $0x0, %eax
je 0x46d59a
testb $0x1, -0x9(%rbp)
jne 0x46d59a
movq -0x8(%rbp), %rdx
leaq 0x19632e(%rip), %rsi    # 0x603899
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x407fd0
movq -0x48(%rbp), %rdi
callq 0x46d330
jmp 0x46d583
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4f1e40
jmp 0x46d5a4
movb $0x1, %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5283c0
nopl (%rax)
// File: Cell-veto[P]postlhc/tools.cpp
// Function: hostname[abi:cxx11]()
string hostname ()
{
    char buf[HOST_NAME_MAX+1];
    gethostname (buf, HOST_NAME_MAX);
    buf[HOST_NAME_MAX] = 0;
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x40, %esi
callq 0x5b01b0
movb $0x0, -0x10(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4771f0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x407bd0
jmp 0x46d603
leaq -0x51(%rbp), %rdi
callq 0x477210
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x477210
movq -0x60(%rbp), %rdi
callq 0x5283c0
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/tools.cpp
// Function: string_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector <string> string_split (string_ref str)
{
    std::vector <string> ret;
    boost::algorithm::split (ret, str,
        boost::is_any_of ("\t "), boost::token_compress_on);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x46ea80
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x196239(%rip), %rsi    # 0x6038ac
leaq -0x30(%rbp), %rdi
callq 0x46eb70
jmp 0x46d67e
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rdx
xorl %ecx, %ecx
callq 0x46eaa0
jmp 0x46d693
leaq -0x30(%rbp), %rdi
callq 0x46ebc0
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x46d6d6
jmp 0x46d6cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x46d6e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x46ebc0
jmp 0x46d6e0
movq -0x58(%rbp), %rdi
callq 0x465390
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x465390
movq -0x38(%rbp), %rdi
callq 0x5283c0
nopw %cs:(%rax,%rax)
// File: Cell-veto[P]postlhc/tools.cpp
// Function: redirect_cerr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void redirect_cerr (string_ref filename, bool append)
{
    std::ios::openmode mode = std::ios::out;
    if (append)
        mode |= std::ios::app;
    cerr_logfile.open (filename, mode);
    if (!cerr_logfile)
        std::cerr << "cannot open log file " << filename << ABORT;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl $0x10, -0x10(%rbp)
testb $0x1, -0x9(%rbp)
je 0x46d7e2
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x46ec10
movq -0x8(%rbp), %rsi
movl -0x10(%rbp), %edx
leaq 0x22a168(%rip), %rdi    # 0x697958
callq 0x4bd900
movq 0x22a15c(%rip), %rax    # 0x697958
leaq 0x22a155(%rip), %rdi    # 0x697958
addq -0x18(%rax), %rdi
callq 0x4c2500
testb $0x1, %al
jne 0x46d812
jmp 0x46d840
movq $0x698ac0, %rdi         # imm = 0x698AC0
leaq 0x19608f(%rip), %rsi    # 0x6038af
callq 0x4e1b60
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x4f4680
movq %rax, %rdi
leaq 0x229f86(%rip), %rsi    # 0x6977c1
callq 0x46d700
movq $0x698ac0, %rdi         # imm = 0x698AC0
callq 0x4e0700
leaq 0x229f8d(%rip), %rsi    # 0x6977e0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4eae50
movq -0x70(%rbp), %rsi
leaq 0x22a0ed(%rip), %rdi    # 0x697958
callq 0x4f4680
jmp 0x46d872
leaq -0x30(%rbp), %rdi
callq 0x4f1e40
leaq -0x61(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4771f0
movq -0x78(%rbp), %rdx
leaq 0x1b7fdf(%rip), %rsi    # 0x625872
leaq -0x60(%rbp), %rdi
callq 0x407bd0
jmp 0x46d89e
leaq 0x229f3b(%rip), %rdi    # 0x6977e0
leaq -0x60(%rbp), %rsi
callq 0x4eaee0
jmp 0x46d8b0
leaq -0x60(%rbp), %rdi
callq 0x4f1e40
leaq -0x61(%rbp), %rdi
callq 0x477210
movq $0x698ac0, %rax         # imm = 0x698AC0
movq (%rax), %rcx
movq $0x698ac0, %rax         # imm = 0x698AC0
addq -0x18(%rcx), %rax
movq %rax, -0x80(%rbp)
leaq 0x22a076(%rip), %rdi    # 0x697958
callq 0x4ba920
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x4c2630
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4f1e40
jmp 0x46d93f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x46d936
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4f1e40
leaq -0x61(%rbp), %rdi
callq 0x477210
movq -0x38(%rbp), %rdi
callq 0x5283c0
nopl (%rax,%rax)
// File: Cell-veto[P]postlhc/tools.cpp
// Function: dont_redirect_cerr()
void dont_redirect_cerr ()
{
    // all in vain.
    std::cerr.flush ();
    original_cerr_stream << cerr_buffer.str ();
    cerr_buffer.str ("");
    // redirect cerr to the log file
    std::cerr.rdbuf (original_cerr_stream.rdbuf ());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq $0x698ac0, %rdi         # imm = 0x698AC0
callq 0x4e0700
leaq 0x229e75(%rip), %rsi    # 0x6977e0
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4eae50
movq -0x60(%rbp), %rsi
leaq 0x22a1d5(%rip), %rdi    # 0x697b58
callq 0x4f4680
jmp 0x46d98a
leaq -0x20(%rbp), %rdi
callq 0x4f1e40
leaq -0x51(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4771f0
movq -0x68(%rbp), %rdx
leaq 0x1b7ec7(%rip), %rsi    # 0x625872
leaq -0x50(%rbp), %rdi
callq 0x407bd0
jmp 0x46d9b6
leaq 0x229e23(%rip), %rdi    # 0x6977e0
leaq -0x50(%rbp), %rsi
callq 0x4eaee0
jmp 0x46d9c8
leaq -0x50(%rbp), %rdi
callq 0x4f1e40
leaq -0x51(%rbp), %rdi
callq 0x477210
movq $0x698ac0, %rax         # imm = 0x698AC0
movq (%rax), %rcx
movq $0x698ac0, %rax         # imm = 0x698AC0
addq -0x18(%rcx), %rax
movq %rax, -0x70(%rbp)
movq 0x22a15e(%rip), %rax    # 0x697b58
leaq 0x22a157(%rip), %rdi    # 0x697b58
addq -0x18(%rax), %rdi
callq 0x4c2620
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x4c2630
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4f1e40
jmp 0x46da5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x46da56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4f1e40
leaq -0x51(%rbp), %rdi
callq 0x477210
movq -0x28(%rbp), %rdi
callq 0x5283c0
nopl (%rax,%rax)