LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::random_sr_repulsion(double, RandomContext*)
double random_sr_repulsion (double rsq, RandomContext *random)
    {
        double rsq_evt = random_repulsive_lift_g  (rsq, random);
        if (rsq_evt <= sq (LJ_MINIMUM))
            update_max (&rsq_evt, random_repulsive_lift_lj (rsq, random));
        return rsq_evt - rsq;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
callq 0x42a5c6
movapd %xmm0, %xmm1
movsd 0x193afc(%rip), %xmm0   # 0x5be018
ucomisd %xmm1, %xmm0
jb 0x42a54b
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movq %rbx, %rsi
movsd %xmm1, 0x10(%rsp)
callq 0x42a694
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
callq 0x4e1c90
movapd %xmm0, %xmm1
subsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::random_sr_attraction(double, RandomContext*)
double random_sr_attraction (double rsq, RandomContext *random)
    {
        double rsq_evt = random_attractive_lift_lj (rsq, random);
        if (rsq_evt >= sq (gauss_r0))
            update_min (&rsq_evt, random_attractive_lift_g  (rsq, random));
        return rsq_evt - rsq;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
callq 0x42a744
movapd %xmm0, %xmm1
movsd 0x10(%r14), %xmm0
mulsd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x42a5b3
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movq %rbx, %rsi
movsd %xmm1, 0x10(%rsp)
callq 0x42a814
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
callq 0x4e1ce0
movapd %xmm0, %xmm1
subsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm1
mulsd %xmm1, %xmm1
callq 0x4e1ce0
movq %rbx, %rdi
movaps %xmm0, (%rsp)
callq 0x429fa8
movsd %xmm0, 0x10(%rsp)
movsd (%rbx), %xmm0
movq %r14, %rdi
callq 0x40eb24
addsd 0x10(%rsp), %xmm0
ucomisd 0x38(%rbx), %xmm0
jae 0x42a640
movsd 0x10(%rbx), %xmm1
movaps %xmm1, (%rsp)
movsd 0x8(%rbx), %xmm1
xorpd 0x194a3e(%rip), %xmm1   # 0x5bf060
divsd %xmm1, %xmm0
callq 0x4e1d30
divsd 0x28(%rbx), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x42a64f
sqrtsd %xmm0, %xmm0
jmp 0x42a658
movapd (%rsp), %xmm0
xorpd 0x194a13(%rip), %xmm0   # 0x5bf060
jmp 0x42a66f
callq 0x4e1e90
xorpd %xmm2, %xmm2
movapd (%rsp), %xmm1
subsd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
jbe 0x42a677
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1998ee(%rip), %rdi    # 0x5c3f6c
leaq 0x1998f2(%rip), %rsi    # 0x5c3f77
leaq 0x1998f3(%rip), %rcx    # 0x5c3f7f
pushq $0x7b
popq %rdx
callq 0x4ffe80
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
minsd 0x193972(%rip), %xmm0   # 0x5be018
movsd 0x194af2(%rip), %xmm1   # 0x5bf1a0
callq 0x4e1d70
movsd 0x194a7d(%rip), %xmm1   # 0x5bf138
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x40eb24
addsd (%rsp), %xmm0
addsd 0x193936(%rip), %xmm0   # 0x5be018
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x42a6f2
sqrtsd %xmm0, %xmm0
jmp 0x42a6f7
callq 0x4e1e90
movsd 0x193919(%rip), %xmm1   # 0x5be018
addsd %xmm1, %xmm0
movsd 0x198c9d(%rip), %xmm1   # 0x5c33a8
callq 0x4e1d70
movsd 0x193900(%rip), %xmm1   # 0x5be018
ucomisd %xmm0, %xmm1
jb 0x42a726
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x19989d(%rip), %rdi    # 0x5c3fca
leaq 0x199843(%rip), %rsi    # 0x5c3f77
leaq 0x1998aa(%rip), %rcx    # 0x5c3fe5
pushq $0x65
popq %rdx
callq 0x4ffe80
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
maxsd 0x1938c2(%rip), %xmm0   # 0x5be018
movsd 0x194a42(%rip), %xmm1   # 0x5bf1a0
callq 0x4e1d70
movsd 0x1949cd(%rip), %xmm1   # 0x5bf138
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rbx), %xmm0
movq %r14, %rdi
callq 0x40eb24
addsd (%rsp), %xmm0
ucomisd 0x40(%rbx), %xmm0
jae 0x42a7a8
addsd 0x193880(%rip), %xmm0   # 0x5be018
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x42a7b2
sqrtsd %xmm0, %xmm0
jmp 0x42a7b7
movsd 0x198c08(%rip), %xmm0   # 0x5c33b8
jmp 0x42a7ed
callq 0x4e1e90
movsd 0x193859(%rip), %xmm2   # 0x5be018
subsd %xmm0, %xmm2
movsd 0x198bdd(%rip), %xmm1   # 0x5c33a8
movapd %xmm2, %xmm0
callq 0x4e1d70
ucomisd 0x19383c(%rip), %xmm0   # 0x5be018
jb 0x42a7f5
movsd 0x20(%rbx), %xmm1
mulsd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jb 0x42a7f5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x199835(%rip), %rdi    # 0x5c4031
leaq 0x199774(%rip), %rsi    # 0x5c3f77
leaq 0x19985c(%rip), %rcx    # 0x5c4066
movl $0x9b, %edx
callq 0x4ffe80
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm1
mulsd %xmm1, %xmm1
callq 0x4e1c90
movq %rbx, %rdi
callq 0x429fa8
movsd %xmm0, (%rsp)
movsd (%rbx), %xmm0
movq %r14, %rdi
callq 0x40eb24
addsd (%rsp), %xmm0
ucomisd 0x30(%rbx), %xmm0
jae 0x42a886
movsd 0x10(%rbx), %xmm1
movsd %xmm1, (%rsp)
movsd 0x8(%rbx), %xmm1
xorpd 0x1947f8(%rip), %xmm1   # 0x5bf060
divsd %xmm1, %xmm0
callq 0x4e1d30
divsd 0x28(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x42a890
sqrtsd %xmm0, %xmm0
jmp 0x42a895
movsd 0x198b2a(%rip), %xmm0   # 0x5c33b8
jmp 0x42a8a6
callq 0x4e1e90
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1973f5(%rip), %rsi    # 0x5c4793
movq %rbx, %rdi
callq 0x406081
testb %al, %al
je 0x42d3c7
xorpd %xmm0, %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x42d3e6
movsd %xmm1, (%r14)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x191eca(%rip), %rsi    # 0x5bf298
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4061da
movq %r14, %rdi
callq 0x434d5b
leaq 0x197395(%rip), %rsi    # 0x5c4782
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x406046
leaq 0x18(%rsp), %rdi
callq 0x434d5b
jmp 0x42d40d
movq %rax, %rbx
jmp 0x42d41a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x42f84e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x42f8ca
movq (%rax), %rdi
testq %rdi, %rdi
je 0x42f743
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x4b4820
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x1956e6(%rip), %rsi    # 0x5c4e30
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4061da
movq %r14, %rdi
callq 0x434d5b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse3D>::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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x212abf(%rip), %rax    # 0x643600
movq %rax, (%rdi)
addq $0x50, %rdi
callq 0x42fe2c
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
andl $0x0, 0x38(%r14)
pushq $0xf
popq %rax
cmpq $0x12, %rax
je 0x430b70
movl $0x4, (%r14,%rax,4)
incq %rax
jmp 0x430b5d
movl $0x3, 0x3c(%r14)
movl $0x4, 0x48(%r14)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x416184
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4b4bf0
movq %r14, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::set_periods(Periods const&)
void set_periods (const Periods &periods) override
    {
        if (num_particles () != 0)
            rt_error ("don't set_periods with particles");

        double MAX = 1. + UINT64_MAX;
        unsigned n = 0;
        for (; n != DIM; ++n)
        {
            peri_[n] = periods[n];
            real2frac[n] = periods[n]==0. ? 0. : MAX/periods[n];
            frac2real[n] = periods[n]==0. ? 0. : 1./real2frac[n];
        }
        for (; n != MAX_DIM; ++n)
        {
            if (periods[n] != 0.)
                rt_error ("periods invalid for this Storage");
        }

        // emit updated parameters to logfile
        std::cerr << "periods " << peri_ << '\n';
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x30(%rax)
testq %rax, %rax
jne 0x43015a
leaq 0x50(%r15), %rbx
xorl %eax, %eax
movsd 0x18f12c(%rip), %xmm0   # 0x5bf1e8
xorpd %xmm1, %xmm1
movsd 0x18df50(%rip), %xmm2   # 0x5be018
cmpq $0x2, %rax
je 0x430116
movsd (%r14,%rax,8), %xmm3
movsd %xmm3, 0x50(%r15,%rax,8)
movapd %xmm0, %xmm4
divsd %xmm3, %xmm4
cmpeqsd %xmm1, %xmm3
andnpd %xmm4, %xmm3
movlpd %xmm3, 0x68(%r15,%rax,8)
movapd %xmm2, %xmm4
divsd %xmm3, %xmm4
movsd (%r14,%rax,8), %xmm3
cmpeqsd %xmm1, %xmm3
andnpd %xmm4, %xmm3
movlpd %xmm3, 0x78(%r15,%rax,8)
incq %rax
jmp 0x4300c8
movsd 0x10(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x43017a
jp 0x43017a
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x194e53(%rip), %rsi    # 0x5c4f89
callq 0x4a4910
movq %rax, %rdi
movq %rbx, %rsi
callq 0x414416
pushq $0xa
popq %rsi
movq %rax, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x4a4840
leaq 0x194de6(%rip), %rsi    # 0x5c4f47
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x406046
leaq 0x10(%rsp), %rdi
callq 0x434d5b
leaq 0x194de7(%rip), %rsi    # 0x5c4f68
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x406046
leaq 0x10(%rsp), %rdi
callq 0x434d5b
jmp 0x43019e
jmp 0x4301ad
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4b4bf0
jmp 0x4301b0
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Tagged<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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x2, %r14
je 0x43093e
movsd (%r15,%r14,8), %xmm0
movsd %xmm0, 0x8(%rsp)
ucomisd 0x18e7fc(%rip), %xmm0   # 0x5bf120
jb 0x430984
movq %rbx, %rdi
movl %r14d, %esi
callq 0x411d08
ucomisd 0x8(%rsp), %xmm0
jbe 0x430984
incq %r14
jmp 0x43090a
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4309e8
movl 0x18(%r15), %eax
movl %eax, 0x10(%r14)
movups 0x20(%r15), %xmm0
movups %xmm0, 0x18(%r14)
movq 0x30(%r15), %rax
movq %rax, 0x28(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x412de8
incq 0x30(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1944ba(%rip), %rsi    # 0x5c4e4c
callq 0x4a4910
movsd (%r15,%r14,8), %xmm0
movq %rax, %rdi
callq 0x4a5880
leaq 0x1944c3(%rip), %rsi    # 0x5c4e6f
movq %rax, %rdi
callq 0x4a4910
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x411d08
movq %r15, %rdi
callq 0x4a5880
leaq 0x1944a2(%rip), %rsi    # 0x5c4e73
movq %rax, %rdi
callq 0x4a4910
leaq 0x21cd09(%rip), %rsi    # 0x64d6e9
movq %rax, %rdi
callq 0x434f95
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
xorl %eax, %eax
xorpd %xmm0, %xmm0
movsd 0x18ef11(%rip), %xmm1   # 0x5bf1e0
cmpq $0x2, %rax
je 0x430316
movsd (%rdx,%rax,8), %xmm2
ucomisd %xmm0, %xmm2
jb 0x43032d
movsd 0x50(%rdi,%rax,8), %xmm3
ucomisd %xmm2, %xmm3
jbe 0x43034c
mulsd 0x68(%rdi,%rax,8), %xmm2
cvttsd2si %xmm2, %rcx
movq %rcx, %r8
sarq $0x3f, %r8
subsd %xmm1, %xmm2
cvttsd2si %xmm2, %r9
andq %r8, %r9
orq %rcx, %r9
movq %r9, (%rsi,%rax,8)
incq %rax
jmp 0x4302cf
movsd 0x10(%rdx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x43036b
jp 0x43036b
orb $0x1, 0x8(%rsi)
popq %rax
retq
leaq 0x194b4c(%rip), %rdi    # 0x5c4e80
leaq 0x18efd4(%rip), %rsi    # 0x5bf30f
leaq 0x194b4c(%rip), %rcx    # 0x5c4e8e
movl $0x13f, %edx            # imm = 0x13F
callq 0x4ffe80
leaq 0x194bae(%rip), %rdi    # 0x5c4f01
leaq 0x18efb5(%rip), %rsi    # 0x5bf30f
leaq 0x194b2d(%rip), %rcx    # 0x5c4e8e
movl $0x140, %edx            # imm = 0x140
callq 0x4ffe80
leaq 0x194ba2(%rip), %rdi    # 0x5c4f14
leaq 0x18ef96(%rip), %rsi    # 0x5bf30f
leaq 0x194b0e(%rip), %rcx    # 0x5c4e8e
movl $0x144, %edx            # imm = 0x144
callq 0x4ffe80
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x3
popq %rsi
xorps %xmm0, %xmm0
callq 0x40b2d4
leaq 0x28(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x480e40
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
jne 0x43118d
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x48b270
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x48b270
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
jne 0x43116f
leaq 0x10(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x48b270
movq %rax, %rdi
callq 0x48a3c0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x48(%rsp,%rax)
je 0x43116f
leaq 0x28(%rsp), %rdi
callq 0x481b70
movq %r14, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1941af(%rip), %rsi    # 0x5c5325
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x4061da
leaq 0x8(%rsp), %rdi
callq 0x434d5b
leaq 0x19417c(%rip), %rsi    # 0x5c5310
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x4061da
leaq 0x8(%rsp), %rdi
callq 0x434d5b
jmp 0x4311af
jmp 0x4311c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
jmp 0x4311c3
jmp 0x4311c0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x481b70
movq %rbx, %rdi
callq 0x4eb220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x480fb0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x43126b
movq $0xf, 0x28(%rsp,%rax)
xorl %r12d, %r12d
leaq 0x20(%rsp), %r15
pushq $0xa
popq %rbp
cmpq $0x18, %r12
je 0x431241
movsd (%r14,%r12), %xmm0
movq %r15, %rdi
callq 0x4a5640
movq %rax, %rdi
movl %ebp, %esi
callq 0x4a4840
addq $0x8, %r12
jmp 0x43121d
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x431285
leaq 0x20(%rsp), %rdi
callq 0x481a30
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19409e(%rip), %rsi    # 0x5c5310
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4061da
movq %rsp, %rdi
callq 0x434d5b
leaq 0x1940ae(%rip), %rsi    # 0x5c533a
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4061da
movq %rsp, %rdi
callq 0x434d5b
jmp 0x4312a3
jmp 0x4312b2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4b4bf0
jmp 0x4312b5
jmp 0x4312b2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x481a30
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movsd (%rsi), %xmm0
callq 0x4a5640
pushq $0x20
popq %r15
movq %rax, %rdi
movl %r15d, %esi
callq 0x4a4840
movsd 0x8(%r14), %xmm0
movq %rax, %rdi
callq 0x4a5640
movq %rax, %rdi
movl %r15d, %esi
callq 0x4a4840
movsd 0x10(%r14), %xmm0
movq %rax, %rdi
callq 0x4a5640
testl %ebp, %ebp
je 0x431bb7
pushq $0x20
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4a4840
movsd 0x20(%r14), %xmm0
movq %rax, %rdi
callq 0x4a5640
movq %rax, %rdi
movl %ebp, %esi
callq 0x4a4840
movsd 0x28(%r14), %xmm0
movq %rax, %rdi
callq 0x4a5640
movq %rax, %rdi
movl %ebp, %esi
callq 0x4a4840
movsd 0x30(%r14), %xmm0
movq %rax, %rdi
callq 0x4a5640
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x4a4840
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x431bdb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x437e70
leaq 0x211ab6(%rip), %rsi    # 0x6436a0
movq %rax, %rdi
xorl %edx, %edx
callq 0x438ec0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x480fb0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x4329db
movq (%r14), %rax
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq *0x20(%rax)
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x4329f5
leaq 0x20(%rsp), %rdi
callq 0x481800
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x432a0f
leaq 0x20(%rsp), %rdi
callq 0x481a30
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
leaq 0x192a7b(%rip), %rsi    # 0x5c545d
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4061da
movq %rsp, %rdi
callq 0x434d5b
leaq 0x192a74(%rip), %rsi    # 0x5c5470
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4061da
movq %rsp, %rdi
callq 0x434d5b
leaq 0x192a6f(%rip), %rsi    # 0x5c5485
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x4061da
movq %rsp, %rdi
callq 0x434d5b
jmp 0x432a31
jmp 0x432a40
jmp 0x432a31
jmp 0x432a40
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4b4bf0
jmp 0x432a43
jmp 0x432a40
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x481a30
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x19d0a7(%rip), %rdx    # 0x5cfb1c
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x406250
leaq 0x8(%rbx), %rdx
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x42f82f
leaq 0x18(%rsp), %rdi
callq 0x432afc
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x4b4bf0
leaq 0x38(%rsp), %rdi
callq 0x4b4bf0
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq *0x10(%rax)
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4b4bf0
jmp 0x432ae9
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x433682
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd %xmm1, 0xbf8(%rbx)
leaq 0xc08(%rbx), %rdi
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x433254
jp 0x433254
movq %rax, %r14
leaq 0x1b5480(%rip), %rsi    # 0x5e86a9
callq 0x4b5ba0
movq (%r14), %rax
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x4336a4
mulsd 0x18bea6(%rip), %xmm0   # 0x5bf0f8
jmp 0x433274
leaq 0x192277(%rip), %rsi    # 0x5c54d2
callq 0x4b5ba0
movsd 0x8(%rsp), %xmm0
ucomisd 0x18beb2(%rip), %xmm0   # 0x5bf120
jbe 0x43331e
movsd %xmm0, 0xc28(%rbx)
leaq 0xc30(%rbx), %r14
divsd 0xbf8(%rbx), %xmm0
callq 0x401140
cvttsd2si %xmm0, %rax
movq %rax, %rcx
movsd 0x18bf40(%rip), %xmm1   # 0x5bf1e0
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, %xmm0
punpckldq 0x18bd80(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x18bd88(%rip), %xmm0   # 0x5bf050
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
addsd 0x18be54(%rip), %xmm2   # 0x5bf130
cvttsd2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd %xmm1, %xmm2
cvttsd2si %xmm2, %rsi
andq %rcx, %rsi
orq %rax, %rsi
leaq 0x18(%rsp), %rdx
andq $0x0, (%rdx)
movq %r14, %rdi
callq 0x4336d8
xorpd %xmm0, %xmm0
movupd %xmm0, 0xc48(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1921b4(%rip), %rdi    # 0x5c54d9
leaq 0x1921b7(%rip), %rsi    # 0x5c54e3
leaq 0x1921bf(%rip), %rcx    # 0x5c54f2
pushq $0x24
popq %rdx
callq 0x4ffe80
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x433682
movq %rax, %r15
movq %rax, %rdi
callq 0x43390a
movsd %xmm0, 0xc00(%rbx)
addq %r14, 0xc48(%rbx)
callq 0x434c6c
subq %rax, 0xc50(%rbx)
leaq 0x28(%rbx), %r12
movq %rbx, (%rsp)
leaq 0xc08(%rbx), %r13
subq $0x1, %r14
jb 0x43341c
movq %r15, %rdi
movq %r12, %rsi
callq 0x40be5c
movq %rax, %rbp
movq %r13, %rdi
leaq 0x1b52fa(%rip), %rsi    # 0x5e86a9
callq 0x406081
testb %al, %al
je 0x4333e8
movq %r13, %rbx
movq %r12, %r13
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x43045a
movq (%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r13, %r12
movq %rbx, %r13
callq 0x433960
jmp 0x43338d
movq (%rsp), %rbx
movsd 0xc28(%rbx), %xmm0
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x433aa8
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
leaq 0x20(%rsp), %rcx
callq 0x433a00
jmp 0x43338d
callq 0x434c6c
movq (%rsp), %rcx
addq %rax, 0xc50(%rcx)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/paircorrel.cpp
// Function: void Correlator<Monodisperse2D>::do_sample<Storage<Monodisperse2D>::StripGenerator>(Storage<Monodisperse2D>*, unsigned long, Storage<Monodisperse2D>::StripGenerator)
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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x50(%rbx), %eax
movq 0x18(%rbx,%rax,8), %rcx
cmpq 0x40(%rbx,%rax,8), %rcx
je 0x433a9b
movq 0x8(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x40e556
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm0
divsd 0xbf8(%r12), %xmm0
callq 0x401140
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x18b77f(%rip), %xmm0   # 0x5bf1e0
cvttsd2si %xmm0, %rdx
sarq $0x3f, %rcx
andl %ecx, %edx
orl %edx, %eax
movq 0xc30(%r12), %rcx
movq 0xc38(%r12), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x433a8e
incq (%rcx,%rax,8)
movq %rbx, %rdi
callq 0x40e69a
jmp 0x433a14
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
xorpd %xmm1, %xmm1
movapd %xmm0, 0x10(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x433b4a
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl $0x2, %ebp
je 0x433b0e
movq %r14, %rdi
movl %ebp, %esi
callq 0x40e3b8
incl %ebp
movapd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x433ad1
leaq 0x191adf(%rip), %rsi    # 0x5c55d4
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x406046
leaq 0x28(%rsp), %rdi
callq 0x434d5b
shlq $0x4, %r15
leaq (%r14,%r15), %rdx
addq $0x88, %rdx
movaps 0x18b53c(%rip), %xmm1   # 0x5bf060
movaps 0x10(%rsp), %xmm0
xorps %xmm0, %xmm1
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movaps %xmm0, %xmm2
callq 0x40e6c4
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x191a70(%rip), %rsi    # 0x5c55c1
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x406046
leaq 0x28(%rsp), %rdi
callq 0x434d5b
jmp 0x433b6e
jmp 0x433b7d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4b4bf0
jmp 0x433b80
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/tools.cpp
// Function: gclock()
uint64_t gclock ()
{
    static uint64_t base = time (0);
    struct timeval tv;
    gettimeofday(&tv, 0);
    return (tv.tv_sec-base) * 1000000ull + tv.tv_usec;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movb 0x218b39(%rip), %al     # 0x64d7b0
testb %al, %al
je 0x434ca3
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x56b580
movq (%rbx), %rax
subq 0x218b16(%rip), %rax    # 0x64d7a8
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
addq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x218b06(%rip), %rdi    # 0x64d7b0
callq 0x438f80
testl %eax, %eax
je 0x434c7b
xorl %edi, %edi
callq 0x56b520
movq %rax, 0x218ae7(%rip)    # 0x64d7a8
leaq 0x218ae8(%rip), %rdi    # 0x64d7b0
callq 0x439090
jmp 0x434c7b
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x0, 0x218ae2(%rip)    # 0x64d7b8
jne 0x434cfa
pushq %rax
movb $0x0, 0x218ad9(%rip)    # 0x64d7b9
movb $0x1, 0x218ad1(%rip)    # 0x64d7b8
leaq 0x13(%rip), %rsi        # 0x434d01
pushq $0xf
popq %rdi
callq 0x5060e0
addq $0x8, %rsp
movb 0x218ab9(%rip), %al     # 0x64d7b9
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x572940
testl %eax, %eax
sete %al
orb %bpl, %al
je 0x434ec1
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1909d1(%rip), %rsi    # 0x5c5899
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4061da
movq %r14, %rdi
callq 0x434d5b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x190962(%rip), %rsi    # 0x5c58ac
movq %rsp, %rdi
callq 0x435be7
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x435b63
movq %rsp, %rdi
callq 0x435c12
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x435c12
jmp 0x434f85
movq %rax, %r14
movq %rbx, %rdi
callq 0x431c54
movq %r14, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/tools.cpp
// Function: buffer_cerr()
void buffer_cerr ()
{
    // save the original stream buffer in case we need to restore it
    original_cerr_stream.rdbuf (std::cerr.rdbuf ());
    // redirect cerr to cerr_buffer
    std::cerr.rdbuf (cerr_buffer.rdbuf ());
}

// Assembly:
pushq %rbx
movq 0x218b90(%rip), %rax    # 0x64db38
leaq 0x218b89(%rip), %rdi    # 0x64db38
addq -0x18(%rax), %rdi
movq $0x64eaa0, %rbx         # imm = 0x64EAA0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rbx,%rax), %rsi
callq 0x4853e0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
leaq 0x2187ec(%rip), %rsi    # 0x64d7c8
movq %rbx, %rdi
popq %rbx
jmp 0x4853e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leal 0x10(%rsi), %edx
leaq 0x21893f(%rip), %r14    # 0x64d938
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4806b0
movq 0x21892d(%rip), %rax    # 0x64d938
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rax,%r14)
jne 0x4350a6
movq $0x64eaa0, %rbx         # imm = 0x64EAA0
movq %rbx, %rdi
callq 0x4a34b0
leaq 0x218797(%rip), %rsi    # 0x64d7c8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4aa900
leaq 0x2188f3(%rip), %rdi    # 0x64d938
movq %r14, %rsi
callq 0x4b7440
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
leaq 0x1b2814(%rip), %rsi    # 0x5e7872
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x406046
leaq 0x218754(%rip), %rdi    # 0x64d7c8
leaq 0x8(%rsp), %rsi
callq 0x4aad70
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
leaq 0x2188aa(%rip), %rsi    # 0x64d940
movq %rbx, %rdi
callq 0x4853e0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1907fb(%rip), %rsi    # 0x5c58af
callq 0x4a4910
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4b7440
movq %rax, %rdi
callq 0x434f95
jmp 0x4350d3
movq %rax, %rbx
jmp 0x4350e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq $0x64eaa0, %rbx         # imm = 0x64EAA0
movq %rbx, %rdi
callq 0x4a34b0
leaq 0x2186c1(%rip), %rsi    # 0x64d7c8
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x4aa900
leaq 0x218a1d(%rip), %r14    # 0x64db38
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b7440
leaq 0x10(%rsp), %rdi
callq 0x4b4bf0
leaq 0x1b273b(%rip), %rsi    # 0x5e7872
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x406046
leaq 0x21867b(%rip), %rdi    # 0x64d7c8
leaq 0x10(%rsp), %rsi
callq 0x4aad70
leaq 0x10(%rsp), %rdi
callq 0x4b4bf0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq 0x2189c9(%rip), %rax    # 0x64db38
movq -0x18(%rax), %rax
movq 0xe8(%rax,%r14), %rsi
movq %rbx, %rdi
callq 0x4853e0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x435194
movq %rax, %rbx
jmp 0x4351a1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/tools.cpp
// Function: int_pop_arg[abi:cxx11](char const**)
static
std::pair <string, string> int_pop_arg (const char **argv)
{
    assert (*argv);
    string kw = *argv++;
    if (!*argv)
        rt_error ("missing argument for kw " + kw);
    return std::make_pair (kw, string (*argv));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x4352a1
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x406046
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x4352c0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x406046
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x435e0a
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
leaq 0x28(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0x190762(%rip), %rdi    # 0x5c5a0a
leaq 0x190645(%rip), %rsi    # 0x5c58f4
leaq 0x19075a(%rip), %rcx    # 0x5c5a10
movl $0x9a, %edx
callq 0x4ffe80
leaq 0x19077e(%rip), %rsi    # 0x5c5a45
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x4061da
leaq 0x8(%rsp), %rdi
callq 0x434d5b
jmp 0x4352e4
jmp 0x4352f3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
jmp 0x4352f6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/tools.cpp
// Function: unsigned long read_arg<unsigned long>(char const**)
unsigned long read_arg (const char **argv)
{
    string kw, value;
    std::tie (kw, value) = int_pop_arg (argv);
    try
    {
        return std::stoul (value);
    }
    catch (...)
    {
        rt_error ("cannot convert value " + value + " for keyword " + kw);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rsi
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x88(%rsp), %rdi
callq 0x435234
leaq 0x8(%rsp), %rbx
leaq 0x48(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x28(%rsp), %rax
movq %rax, 0x8(%rdi)
leaq 0x88(%rsp), %r14
movq %r14, %rsi
callq 0x435c26
movq %r14, %rdi
callq 0x435c54
pushq $0xa
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x435c6a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
leaq 0x28(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x437fd0
leaq 0x190512(%rip), %rsi    # 0x5c58c5
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x4061da
leaq 0x190512(%rip), %rdx    # 0x5c58db
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4067fc
leaq 0x88(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x42f82f
leaq 0x88(%rsp), %rdi
callq 0x434d5b
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x4b4bf0
jmp 0x435411
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4b4bf0
jmp 0x435420
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4b4bf0
jmp 0x43542f
movq %rax, %rbx
callq 0x438040
jmp 0x435441
movq %rax, %rdi
callq 0x4062f8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
leaq 0x28(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/tools.cpp
// Function: double read_arg<double>(char const**)
double read_arg (const char **argv)
{
    string kw, value;
    std::tie (kw, value) = int_pop_arg (argv);
    try
    {
        return std::stod (value);
    }
    catch (...)
    {
        rt_error ("cannot convert value " + value + " for keyword " + kw);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rsi
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x88(%rsp), %rdi
callq 0x435234
leaq 0x8(%rsp), %rbx
leaq 0x48(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x28(%rsp), %rax
movq %rax, 0x8(%rdi)
leaq 0x88(%rsp), %r14
movq %r14, %rsi
callq 0x435c26
movq %r14, %rdi
callq 0x435c54
movq %rbx, %rdi
xorl %esi, %esi
callq 0x431c3a
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
leaq 0x28(%rsp), %rdi
callq 0x4b4bf0
movsd (%rsp), %xmm0
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x437fd0
leaq 0x1903bc(%rip), %rsi    # 0x5c58c5
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x4061da
leaq 0x1903bc(%rip), %rdx    # 0x5c58db
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4067fc
leaq 0x88(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x42f82f
leaq 0x88(%rsp), %rdi
callq 0x434d5b
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x4b4bf0
jmp 0x435567
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4b4bf0
jmp 0x435576
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4b4bf0
jmp 0x435585
movq %rax, %rbx
callq 0x438040
jmp 0x435597
movq %rax, %rdi
callq 0x4062f8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4b4bf0
leaq 0x28(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/tools.cpp
// Function: RandomContext::refill_exp_buffer_()
void RandomContext::refill_exp_buffer_ ()
{
    for (int i = 0; i != RANDOM_EXPONENTIAL_BUFFER_SIZE; ++i)
        exp_buffer_[i] = real ();
    for (int i = 0; i != RANDOM_EXPONENTIAL_BUFFER_SIZE; ++i)
        exp_buffer_[i] = -std::log (1-exp_buffer_[i]);
    num_exp_used_ = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x139, %r14d           # imm = 0x139
cmpq $0x179, %r14            # imm = 0x179
je 0x4356b3
movq %rbx, %rdi
callq 0x4355d2
movsd %xmm0, (%rbx,%r14,8)
incq %r14
jmp 0x435697
xorl %r14d, %r14d
cmpq $0x40, %r14
je 0x4356ea
movsd 0x188954(%rip), %xmm0   # 0x5be018
subsd 0x9c8(%rbx,%r14,8), %xmm0
callq 0x4e1d30
xorpd 0x189985(%rip), %xmm0   # 0x5bf060
movlpd %xmm0, 0x9c8(%rbx,%r14,8)
incq %r14
jmp 0x4356b6
andl $0x0, 0xbc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/tools.cpp
// Function: RandomContext::pareto(double, double)
double RandomContext::pareto (double paralpha, double minimum)
{
    assert (paralpha > 0.);
    assert (minimum > 0.);
    double u = 1 - real ();
    return pow (u, -1/paralpha) * minimum;
}

// Assembly:
subq $0x18, %rsp
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x43574d
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
ucomisd %xmm2, %xmm1
jbe 0x43576c
callq 0x4355d2
movsd 0x1888f1(%rip), %xmm2   # 0x5be018
subsd %xmm0, %xmm2
movsd 0x1899fd(%rip), %xmm1   # 0x5bf130
divsd 0x8(%rsp), %xmm1
movapd %xmm2, %xmm0
callq 0x4e1d70
mulsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
leaq 0x1901d5(%rip), %rdi    # 0x5c5929
leaq 0x190199(%rip), %rsi    # 0x5c58f4
leaq 0x1901d5(%rip), %rcx    # 0x5c5937
movl $0x103, %edx            # imm = 0x103
callq 0x4ffe80
leaq 0x1901f1(%rip), %rdi    # 0x5c5964
leaq 0x19017a(%rip), %rsi    # 0x5c58f4
leaq 0x1901b6(%rip), %rcx    # 0x5c5937
movl $0x104, %edx            # imm = 0x104
callq 0x4ffe80
nop