LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/./lj.hpp
// Function: LennardJones::random_sr_repulsion(double, RandomContext*)
double random_sr_repulsion (double rsq_, RandomContext *random)
    {
        double rsq = fmin (rsq_ / sq (scale), sq (rep_cutoff));

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

        // invert the LJ potential, picking the solution in repulsive region
        // FIXME look at corner cases
        double rsix = .5 + sqrt (.25 + e_evt);
        double rsq_evt = pow (rsix, -1./3);
        assert (rsq_evt <= sq (rep_cutoff));

        return rsq_evt * sq (scale) - rsq_;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm1
movsd 0x20(%rdi), %xmm2
mulsd %xmm1, %xmm1
movsd %xmm0, 0x10(%rsp)
divsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
movapd %xmm2, %xmm1
minsd %xmm0, %xmm1
cmpunordsd %xmm0, %xmm0
movapd %xmm0, %xmm3
andnpd %xmm1, %xmm3
andpd %xmm2, %xmm0
orpd %xmm3, %xmm0
movsd 0x19e556(%rip), %xmm1   # 0x5cb068
callq 0x4ee2f0
movsd (%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x42cbe7
movsd 0x19e4c7(%rip), %xmm1   # 0x5caff8
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
cmpl $0x40, 0xbc8(%r14)
jne 0x42cb61
movq %r14, %rdi
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x4417f8
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
movl 0xbc8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xbc8(%r14)
movsd 0x9c8(%r14,%rax,8), %xmm0
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
addsd 0x1a2334(%rip), %xmm1   # 0x5ceec0
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x42cb9f
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x42cba8
movapd %xmm1, %xmm0
callq 0x4ee410
addsd 0x19e400(%rip), %xmm0   # 0x5cafb0
movsd 0x1a2310(%rip), %xmm1   # 0x5ceec8
callq 0x4ee2f0
movsd 0x20(%rbx), %xmm1
mulsd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jb 0x42cc06
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm1, %xmm0
subsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x19f0e1(%rip), %rdi    # 0x5cbccf
leaq 0x19f0e5(%rip), %rsi    # 0x5cbcda
leaq 0x19f0ea(%rip), %rcx    # 0x5cbce6
movl $0x120, %edx            # imm = 0x120
callq 0x50c400
leaq 0x1a23fd(%rip), %rdi    # 0x5cf00a
leaq 0x1a2411(%rip), %rsi    # 0x5cf025
leaq 0x1a2413(%rip), %rcx    # 0x5cf02e
movl $0x73, %edx
callq 0x50c400
nop
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/./lj.hpp
// Function: LennardJones::random_sr_attraction(double, RandomContext*)
double random_sr_attraction (double rsq_, RandomContext *random)
    {
        double rsq = fmax (rsq_ / sq (scale), sq (LJ_MINIMUM));

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

        if (e_evt >= lj_at_cutoff)
            return ESCAPES_TO_INFINITY ();

        // invert the LJ potential, picking the solution in attractive region
        // FIXME look at corner cases
        double rsix = .5 - sqrt (.25 + e_evt);
        double rsq_evt = pow (rsix, -1./3);
        assert (rsq_evt <= sq (attr_cutoff) && rsq_evt >= sq (LJ_MINIMUM));

        return rsq_evt * sq (scale) - rsq_;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm1
mulsd %xmm1, %xmm1
movsd %xmm0, 0x10(%rsp)
divsd %xmm1, %xmm0
maxsd 0x1a2282(%rip), %xmm0   # 0x5ceed0
movsd 0x19e412(%rip), %xmm1   # 0x5cb068
callq 0x4ee2f0
movsd (%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x42cd4e
movsd 0x19e383(%rip), %xmm1   # 0x5caff8
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
cmpl $0x40, 0xbc8(%r14)
jne 0x42cca5
movq %r14, %rdi
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x4417f8
movsd (%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
movl 0xbc8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xbc8(%r14)
movsd 0x9c8(%r14,%rax,8), %xmm0
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
ucomisd 0x30(%rbx), %xmm1
jae 0x42ccea
addsd 0x1a21e9(%rip), %xmm1   # 0x5ceec0
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x42ccf4
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x42ccfd
movsd 0x1a21e6(%rip), %xmm0   # 0x5ceed8
jmp 0x42cd46
movapd %xmm1, %xmm0
callq 0x4ee410
movsd 0x19e2ab(%rip), %xmm2   # 0x5cafb0
subsd %xmm0, %xmm2
movsd 0x1a21b7(%rip), %xmm1   # 0x5ceec8
movapd %xmm2, %xmm0
callq 0x4ee2f0
ucomisd 0x1a21ae(%rip), %xmm0   # 0x5ceed0
jb 0x42cd6d
movsd 0x28(%rbx), %xmm1
mulsd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jb 0x42cd6d
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm1, %xmm0
subsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x19ef7a(%rip), %rdi    # 0x5cbccf
leaq 0x19ef7e(%rip), %rsi    # 0x5cbcda
leaq 0x19ef83(%rip), %rcx    # 0x5cbce6
movl $0x120, %edx            # imm = 0x120
callq 0x50c400
leaq 0x1a22fc(%rip), %rdi    # 0x5cf070
leaq 0x1a22aa(%rip), %rsi    # 0x5cf025
leaq 0x1a2328(%rip), %rcx    # 0x5cf0aa
movl $0x88, %edx
callq 0x50c400
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/./lj.hpp
// Function: double LennardJones::lr_event_rate<std::array<double, 3ul>>(std::array<double, 3ul> const&, unsigned long)
double lr_event_rate (const VECTOR &r, size_t direction)
    {
        double rsq = norm_sq (r) / sq (scale);

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movsd (%rsi), %xmm0
mulsd %xmm0, %xmm0
xorl %eax, %eax
movsd 0x8(%r15,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x2, %rax
jne 0x431c86
movsd 0x8(%rbx), %xmm2
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
divsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm2
ja 0x431d27
movsd 0x18(%rbx), %xmm2
mulsd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
ja 0x431d27
movsd 0x199393(%rip), %xmm1   # 0x5cb068
movsd %xmm0, 0x8(%rsp)
callq 0x4ee2f0
movsd 0x8(%rsp), %xmm3
movsd 0x19d1f2(%rip), %xmm2   # 0x5ceee0
mulsd %xmm0, %xmm2
addsd 0x19d1ee(%rip), %xmm2   # 0x5ceee8
mulsd (%r15,%r14,8), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm1
jae 0x431d27
mulsd (%rbx), %xmm2
mulsd %xmm2, %xmm0
movsd 0x10(%rbx), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm1, %xmm3
divsd %xmm3, %xmm0
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/ljg.cpp
// Function: LennardJonesGauss::LennardJonesGauss()
LennardJonesGauss ()
    {
        inv_temperature = 5;
        gauss_epsilon = 1.8;
        gauss_r0 = 1.52;
        gauss_sigma_sq = .02;
        set_parameter ("cutoff", 3.6);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movabsq $0x4014000000000000, %rax # imm = 0x4014000000000000
movq %rax, (%rdi)
movabsq $0x3ffccccccccccccd, %rax # imm = 0x3FFCCCCCCCCCCCCD
movq %rax, 0x8(%rdi)
movabsq $0x3ff851eb851eb852, %rax # imm = 0x3FF851EB851EB852
movq %rax, 0x10(%rdi)
movabsq $0x3f947ae147ae147b, %rax # imm = 0x3F947AE147AE147B
movq %rax, 0x18(%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19c1cc(%rip), %rsi    # 0x5ce77b
leaq 0x19c1cb(%rip), %rdx    # 0x5ce781
movq %rsp, %r14
movq %r14, %rdi
callq 0x40843e
movsd 0x19d3b7(%rip), %xmm0   # 0x5cf980
movq %rbx, %rdi
movq %r14, %rsi
callq 0x433688
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4325ea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4440d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x43260d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rdi
callq 0x4f77a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/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 0x43408e
movapd %xmm0, %xmm1
movsd 0x196054(%rip), %xmm0   # 0x5ca018
ucomisd %xmm1, %xmm0
jb 0x434004
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movq %rbx, %rsi
movsd %xmm1, 0x10(%rsp)
callq 0x434222
movsd 0x10(%rsp), %xmm3
movapd %xmm3, %xmm1
cmpunordsd %xmm3, %xmm1
movapd %xmm1, %xmm2
andpd %xmm0, %xmm2
maxsd %xmm3, %xmm0
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
subsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x43433e
movapd %xmm0, %xmm1
movsd 0x10(%r14), %xmm0
mulsd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x43407c
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movq %rbx, %rsi
movsd %xmm1, 0x10(%rsp)
callq 0x434480
movsd 0x10(%rsp), %xmm3
movapd %xmm3, %xmm1
cmpunordsd %xmm3, %xmm1
movapd %xmm1, %xmm2
andpd %xmm0, %xmm2
minsd %xmm3, %xmm0
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
subsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm1
mulsd %xmm1, %xmm1
movapd %xmm0, %xmm3
cmpunordsd %xmm0, %xmm3
movapd %xmm3, %xmm2
andpd %xmm1, %xmm2
minsd %xmm0, %xmm1
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
movapd %xmm3, (%rsp)
jb 0x4340d9
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x4340e2
movapd %xmm3, %xmm0
callq 0x4ee410
subsd 0x10(%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movsd %xmm1, 0x20(%rsp)
mulsd %xmm0, %xmm0
mulsd 0x28(%rbx), %xmm0
callq 0x4ee440
movsd (%rbx), %xmm1
ucomisd 0x196edc(%rip), %xmm1   # 0x5cafe8
jbe 0x4341e3
movapd %xmm0, %xmm2
cmpl $0x40, 0xbc8(%r14)
jne 0x434140
movq %r14, %rdi
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
callq 0x4417f8
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movl 0xbc8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xbc8(%r14)
movsd 0x9c8(%r14,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
ucomisd 0x38(%rbx), %xmm0
movapd (%rsp), %xmm1
jae 0x4341ad
movsd 0x10(%rbx), %xmm1
movaps %xmm1, (%rsp)
movsd 0x8(%rbx), %xmm1
xorpd 0x196f41(%rip), %xmm1   # 0x5cb0d0
divsd %xmm1, %xmm0
callq 0x4ee2b0
divsd 0x28(%rbx), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x4341bb
sqrtsd %xmm0, %xmm0
jmp 0x4341c4
movapd 0x196f1b(%rip), %xmm0   # 0x5cb0d0
xorpd %xmm1, %xmm0
jmp 0x4341db
callq 0x4ee410
xorpd %xmm2, %xmm2
movapd (%rsp), %xmm1
subsd %xmm0, %xmm1
ucomisd %xmm2, %xmm1
jbe 0x434202
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x197ae5(%rip), %rdi    # 0x5cbccf
leaq 0x197ae9(%rip), %rsi    # 0x5cbcda
leaq 0x197aee(%rip), %rcx    # 0x5cbce6
movl $0x120, %edx            # imm = 0x120
callq 0x50c400
leaq 0x19b8a3(%rip), %rdi    # 0x5cfaac
leaq 0x19b8a7(%rip), %rsi    # 0x5cfab7
leaq 0x19b8a8(%rip), %rcx    # 0x5cfabf
movl $0x7b, %edx
callq 0x50c400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
minsd 0x195de1(%rip), %xmm0   # 0x5ca018
movsd 0x196e29(%rip), %xmm1   # 0x5cb068
callq 0x4ee2f0
movsd (%r14), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x4342ff
movsd 0x196da1(%rip), %xmm1   # 0x5cb000
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
cmpl $0x40, 0xbc8(%rbx)
jne 0x434290
movq %rbx, %rdi
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x4417f8
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movl 0xbc8(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xbc8(%rbx)
movsd 0x9c8(%rbx,%rax,8), %xmm0
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
addsd 0x195d60(%rip), %xmm1   # 0x5ca018
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x4342cb
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x4342d4
movapd %xmm1, %xmm0
callq 0x4ee410
addsd 0x195d3c(%rip), %xmm0   # 0x5ca018
movsd 0x19abe4(%rip), %xmm1   # 0x5ceec8
callq 0x4ee2f0
movsd 0x195d27(%rip), %xmm1   # 0x5ca018
ucomisd %xmm0, %xmm1
jb 0x43431e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1979c9(%rip), %rdi    # 0x5cbccf
leaq 0x1979cd(%rip), %rsi    # 0x5cbcda
leaq 0x1979d2(%rip), %rcx    # 0x5cbce6
movl $0x120, %edx            # imm = 0x120
callq 0x50c400
leaq 0x19b7e5(%rip), %rdi    # 0x5cfb0a
leaq 0x19b78b(%rip), %rsi    # 0x5cfab7
leaq 0x19b7f2(%rip), %rcx    # 0x5cfb25
movl $0x65, %edx
callq 0x50c400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
maxsd 0x195cc5(%rip), %xmm0   # 0x5ca018
movsd 0x196d0d(%rip), %xmm1   # 0x5cb068
callq 0x4ee2f0
movsd (%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x434442
movsd 0x196c86(%rip), %xmm1   # 0x5cb000
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
cmpl $0x40, 0xbc8(%r14)
jne 0x4343ac
movq %r14, %rdi
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
callq 0x4417f8
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movl 0xbc8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xbc8(%r14)
movsd 0x9c8(%r14,%rax,8), %xmm0
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
ucomisd 0x40(%rbx), %xmm1
jae 0x4343f1
addsd 0x195c3a(%rip), %xmm1   # 0x5ca018
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x4343fb
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x434404
movsd 0x19aadf(%rip), %xmm0   # 0x5ceed8
jmp 0x43443a
movapd %xmm1, %xmm0
callq 0x4ee410
movsd 0x195c0c(%rip), %xmm2   # 0x5ca018
subsd %xmm0, %xmm2
movsd 0x19aab0(%rip), %xmm1   # 0x5ceec8
movapd %xmm2, %xmm0
callq 0x4ee2f0
ucomisd 0x195bef(%rip), %xmm0   # 0x5ca018
jb 0x434461
movsd 0x20(%rbx), %xmm1
mulsd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jb 0x434461
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x197886(%rip), %rdi    # 0x5cbccf
leaq 0x19788a(%rip), %rsi    # 0x5cbcda
leaq 0x19788f(%rip), %rcx    # 0x5cbce6
movl $0x120, %edx            # imm = 0x120
callq 0x50c400
leaq 0x19b709(%rip), %rdi    # 0x5cfb71
leaq 0x19b648(%rip), %rsi    # 0x5cfab7
leaq 0x19b730(%rip), %rcx    # 0x5cfba6
movl $0x9b, %edx
callq 0x50c400
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %r14
movapd %xmm0, %xmm1
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm2
mulsd %xmm2, %xmm2
cmpunordsd %xmm0, %xmm0
movapd %xmm0, %xmm3
andpd %xmm2, %xmm3
maxsd %xmm1, %xmm2
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4344c3
sqrtsd %xmm0, %xmm0
jmp 0x4344c8
callq 0x4ee410
subsd 0x10(%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movsd %xmm1, (%rsp)
mulsd %xmm0, %xmm0
mulsd 0x28(%rbx), %xmm0
callq 0x4ee440
movsd (%rbx), %xmm1
ucomisd 0x196af7(%rip), %xmm1   # 0x5cafe8
jbe 0x4345b5
movapd %xmm0, %xmm2
cmpl $0x40, 0xbc8(%r14)
jne 0x434525
movq %r14, %rdi
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
callq 0x4417f8
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movl 0xbc8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xbc8(%r14)
movsd 0x9c8(%r14,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd (%rsp), %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
ucomisd 0x30(%rbx), %xmm0
jae 0x43458d
movsd 0x10(%rbx), %xmm1
movsd %xmm1, (%rsp)
movsd 0x8(%rbx), %xmm1
xorpd 0x196b61(%rip), %xmm1   # 0x5cb0d0
divsd %xmm1, %xmm0
callq 0x4ee2b0
divsd 0x28(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x434597
sqrtsd %xmm0, %xmm0
jmp 0x43459c
movsd 0x19a943(%rip), %xmm0   # 0x5ceed8
jmp 0x4345ad
callq 0x4ee410
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x197713(%rip), %rdi    # 0x5cbccf
leaq 0x197717(%rip), %rsi    # 0x5cbcda
leaq 0x19771c(%rip), %rcx    # 0x5cbce6
movl $0x120, %edx            # imm = 0x120
callq 0x50c400
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x19843e(%rip), %rsi    # 0x5d0173
movq %rbx, %rdi
callq 0x4c3ef0
testl %eax, %eax
jne 0x437d5d
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x437d7c
movsd %xmm1, (%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x19343c(%rip), %rsi    # 0x5cb1a0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x407ce4
movq %r14, %rdi
callq 0x440975
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1983d6(%rip), %rsi    # 0x5d0162
leaq 0x1983e8(%rip), %rdx    # 0x5d017b
leaq 0x8(%rsp), %rdi
callq 0x40843e
leaq 0x8(%rsp), %rdi
callq 0x440975
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0x437dcc
jmp 0x437dd9
movq %rax, %rbx
jmp 0x437dd9
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x437dd9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rdi
callq 0x4f77a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/./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 0x43aa60
movq %rax, %rdi
movq %rbx, %rsi
callq 0x43aa7e
movq (%rax), %rdi
testq %rdi, %rdi
je 0x43a995
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x4c1910
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x195ce4(%rip), %rsi    # 0x5d0680
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x407ce4
movq %r14, %rdi
callq 0x440975
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43a9d2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x2104d9(%rip), %rcx    # 0x64b400
movq %rcx, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movq %rax, 0x60(%rdi)
movups %xmm0, 0x28(%rdi)
movl $0x0, 0x38(%rdi)
movl $0xf, %eax
movl $0x4, (%rbx,%rax,4)
incq %rax
cmpq $0x11, %rax
jne 0x43af45
movl $0x3, 0x3c(%rbx)
movl $0x4, 0x44(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x41305a
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
je 0x43af8d
movq (%r15), %rsi
incq %rsi
callq 0x4440d0
movq %r14, %rdi
callq 0x4f77a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
testq %rax, %rax
jne 0x43b330
xorl %eax, %eax
movsd 0x18fe24(%rip), %xmm0   # 0x5cb0a0
xorpd %xmm1, %xmm1
movsd 0x18ed90(%rip), %xmm2   # 0x5ca018
movsd (%r14,%rax,8), %xmm3
movsd %xmm3, 0x50(%rbx,%rax,8)
movsd (%r14,%rax,8), %xmm3
movapd %xmm0, %xmm4
divsd %xmm3, %xmm4
cmpeqsd %xmm1, %xmm3
andnpd %xmm4, %xmm3
movlpd %xmm3, 0x68(%rbx,%rax,8)
movapd %xmm2, %xmm4
divsd %xmm3, %xmm4
movsd (%r14,%rax,8), %xmm3
cmpeqsd %xmm1, %xmm3
andnpd %xmm4, %xmm3
movlpd %xmm3, 0x78(%rbx,%rax,8)
incq %rax
cmpq $0x2, %rax
jne 0x43b288
movsd 0x10(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x43b35b
jp 0x43b35b
movq $0x656aa0, %r14         # imm = 0x656AA0
leaq 0x1954e2(%rip), %rsi    # 0x5d07d9
movl $0x8, %edx
movq %r14, %rdi
callq 0x4b14d0
addq $0x50, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4184a2
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4b14d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x195457(%rip), %rsi    # 0x5d0797
leaq 0x195470(%rip), %rdx    # 0x5d07b7
leaq 0x8(%rsp), %rdi
callq 0x40843e
leaq 0x8(%rsp), %rdi
callq 0x440975
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x19544d(%rip), %rsi    # 0x5d07b8
leaq 0x195466(%rip), %rdx    # 0x5d07d8
leaq 0x8(%rsp), %rdi
callq 0x40843e
leaq 0x8(%rsp), %rdi
callq 0x440975
jmp 0x43b38a
jmp 0x43b3a6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x43b3a9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
jmp 0x43b3a9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4f77a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
xorpd %xmm0, %xmm0
movsd (%r15,%r14,8), %xmm1
ucomisd %xmm0, %xmm1
jb 0x43bc0c
movsd 0x50(%rbx,%r14,8), %xmm2
ucomisd %xmm1, %xmm2
jbe 0x43bc0c
incq %r14
cmpq $0x2, %r14
jne 0x43bba6
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x43bc70
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 0x41684c
incq 0x30(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq $0x656aa0, %rdi         # imm = 0x656AA0
leaq 0x194a82(%rip), %rsi    # 0x5d069c
callq 0x4b1a00
movsd (%r15,%r14,8), %xmm0
movq %rax, %rdi
callq 0x4b2970
leaq 0x194a8b(%rip), %rsi    # 0x5d06bf
movq %rax, %rdi
callq 0x4b1a00
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x43bb62
movq %r15, %rdi
callq 0x4b2970
leaq 0x194a6a(%rip), %rsi    # 0x5d06c3
movq %rax, %rdi
callq 0x4b1a00
leaq 0x219a81(%rip), %rsi    # 0x6556e9
movq %rax, %rdi
callq 0x440cc2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18faed(%rip), %xmm1   # 0x5cafd8
movsd (%rdx,%rax,8), %xmm2
ucomisd %xmm0, %xmm2
jb 0x43b547
movsd 0x50(%rdi,%rax,8), %xmm3
ucomisd %xmm2, %xmm3
jbe 0x43b566
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
cmpq $0x2, %rax
jne 0x43b4eb
movsd 0x10(%rdx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x43b585
jp 0x43b585
orb $0x1, 0x8(%rsi)
popq %rax
retq
leaq 0x195182(%rip), %rdi    # 0x5d06d0
leaq 0x18fcb4(%rip), %rsi    # 0x5cb209
leaq 0x195182(%rip), %rcx    # 0x5d06de
movl $0x13f, %edx            # imm = 0x13F
callq 0x50c400
leaq 0x1951e4(%rip), %rdi    # 0x5d0751
leaq 0x18fc95(%rip), %rsi    # 0x5cb209
leaq 0x195163(%rip), %rcx    # 0x5d06de
movl $0x140, %edx            # imm = 0x140
callq 0x50c400
leaq 0x1951d8(%rip), %rdi    # 0x5d0764
leaq 0x18fc76(%rip), %rsi    # 0x5cb209
leaq 0x195144(%rip), %rcx    # 0x5d06de
movl $0x144, %edx            # imm = 0x144
callq 0x50c400
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x48dec0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
jne 0x43c4c7
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x4982f0
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x4982f0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
jne 0x43c4a9
leaq 0x10(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x4982f0
movq %rax, %rdi
callq 0x497440
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x48(%rsp,%rax)
je 0x43c4a9
leaq 0x28(%rsp), %rdi
callq 0x48ebf0
movq %r14, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1946a9(%rip), %rsi    # 0x5d0b59
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x407ce4
leaq 0x8(%rsp), %rdi
callq 0x440975
leaq 0x194676(%rip), %rsi    # 0x5d0b44
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x407ce4
leaq 0x8(%rsp), %rdi
callq 0x440975
jmp 0x43c4e9
jmp 0x43c50b
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43c50e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
jmp 0x43c50e
jmp 0x43c50b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x48ebf0
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl $0x10, %edx
callq 0x48e030
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x43c5ed
movq $0xf, 0x28(%rsp,%rax)
xorl %r13d, %r13d
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movsd (%r14,%r13), %xmm0
movq %r15, %rdi
callq 0x4b2730
movb $0xa, (%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4b14d0
addq $0x8, %r13
cmpq $0x18, %r13
jne 0x43c56e
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x43c607
movq $0x64ec08, %rax         # imm = 0x64EC08
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x28(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x20(%rsp,%rcx)
callq 0x48cb10
leaq 0x118(%rsp), %rdi
callq 0x493a40
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x194550(%rip), %rsi    # 0x5d0b44
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x407ce4
movq %rsp, %rdi
callq 0x440975
leaq 0x194560(%rip), %rsi    # 0x5d0b6e
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x407ce4
movq %rsp, %rdi
callq 0x440975
jmp 0x43c625
jmp 0x43c647
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43c64a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4440d0
jmp 0x43c64a
jmp 0x43c647
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x48eab0
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b2730
movb $0x20, %r15b
leaq 0x2(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4b14d0
movsd 0x8(%r14), %xmm0
movq %rax, %rdi
callq 0x4b2730
leaq 0x3(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4b14d0
movsd 0x10(%r14), %xmm0
movq %rax, %rdi
callq 0x4b2730
testl %ebp, %ebp
je 0x43d720
leaq 0x4(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4b14d0
movsd 0x20(%r14), %xmm0
movq %rax, %rdi
callq 0x4b2730
leaq 0x5(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4b14d0
movsd 0x28(%r14), %xmm0
movq %rax, %rdi
callq 0x4b2730
leaq 0x6(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x4b14d0
movsd 0x30(%r14), %xmm0
movq %rax, %rdi
callq 0x4b2730
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4b14d0
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x43d74e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x4444f0
leaq 0x20df49(%rip), %rsi    # 0x64b6a8
movq %rax, %rdi
xorl %edx, %edx
callq 0x445540
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %r15, %rdi
movl $0x10, %edx
callq 0x48e030
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x43e10f
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 0x43e129
leaq 0x20(%rsp), %rdi
callq 0x48e880
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x43e143
movq $0x64ec08, %rax         # imm = 0x64EC08
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x28(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x20(%rsp,%rcx)
callq 0x48cb10
leaq 0x118(%rsp), %rdi
callq 0x493a40
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
leaq 0x192b92(%rip), %rsi    # 0x5d0ca8
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x407ce4
movq %rsp, %rdi
callq 0x440975
leaq 0x192b8b(%rip), %rsi    # 0x5d0cbb
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x407ce4
movq %rsp, %rdi
callq 0x440975
leaq 0x192b86(%rip), %rsi    # 0x5d0cd0
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x407ce4
movq %rsp, %rdi
callq 0x440975
jmp 0x43e165
jmp 0x43e187
jmp 0x43e165
jmp 0x43e187
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43e18a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4440d0
jmp 0x43e18a
jmp 0x43e187
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x48eab0
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movsd %xmm1, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %rsi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x408340
leaq 0x19d11f(%rip), %rsi    # 0x5db2fc
movq %r14, %rdi
callq 0x4c3490
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x8(%rsp), %rdi
callq 0x4c3350
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x43e21f
movq %rdx, 0x38(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x48(%rsp)
jmp 0x43e227
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x38(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x43e2e0
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x43e262
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x43e279
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
callq *0x10(%rax)
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x43e2c1
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x4440d0
jmp 0x43e2c1
jmp 0x43e2be
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x43e2d8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4440d0
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/Cell-veto[P]postlhc/paircorrel.cpp
// Function: Correlator<Monodisperse3D>::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 0x440534
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0xbf8(%rbx)
leaq 0xc08(%rbx), %rdi
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq 0xc10(%rbx), %rdx
jne 0x440039
jp 0x440039
movq %rax, %r14
leaq 0x1b3ea1(%rip), %rcx    # 0x5f3e89
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4c2930
movq (%r14), %rax
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movl $0x8, %eax
movsd (%r15), %xmm0
ucomisd 0x18(%rsp,%rax), %xmm0
jbe 0x440020
leaq (%rsp,%rax), %r15
addq $0x18, %r15
addq $0x8, %rax
cmpq $0x18, %rax
jne 0x44000b
movsd (%r15), %xmm0
mulsd 0x18af79(%rip), %xmm0   # 0x5cafb0
jmp 0x440067
leaq 0x190cdd(%rip), %rcx    # 0x5d0d1d
movl $0x6, %r8d
xorl %esi, %esi
callq 0x4c2930
movsd 0x8(%rsp), %xmm0
ucomisd 0x18af8d(%rip), %xmm0   # 0x5cafe8
jbe 0x44011c
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0xc28(%rbx)
leaq 0xc30(%rbx), %r14
movsd 0xc28(%rbx), %xmm0
divsd 0xbf8(%rbx), %xmm0
callq 0x401140
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
movsd 0x18af39(%rip), %xmm1   # 0x5cafd8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, %xmm0
punpckldq 0x18aff5(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x18affd(%rip), %xmm0   # 0x5cb0c0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
addsd 0x18af21(%rip), %xmm2   # 0x5caff8
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
movq $0x0, (%rdx)
movq %r14, %rdi
callq 0x43eed8
xorpd %xmm0, %xmm0
movupd %xmm0, 0xc48(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x190c01(%rip), %rdi    # 0x5d0d24
leaq 0x190c04(%rip), %rsi    # 0x5d0d2e
leaq 0x190d67(%rip), %rcx    # 0x5d0e98
movl $0x24, %edx
callq 0x50c400
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x88, %rsp
movq %rdx, %r14
movq %rdi, 0x8(%rsp)
movq %rsi, %rdi
callq 0x43eeb6
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x30(%rax)
movl $0x50, %ecx
movsd 0x18b50c(%rip), %xmm0   # 0x5ca018
mulsd (%r15,%rcx), %xmm0
addq $0x8, %rcx
cmpq $0x60, %rcx
jne 0x43eb0c
movq %rax, %xmm1
punpckldq 0x18c587(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x18c58f(%rip), %xmm1   # 0x5cb0c0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm0, %xmm2
movq 0x8(%rsp), %rbx
movsd %xmm2, 0xc00(%rbx)
addq %r14, 0xc48(%rbx)
callq 0x440898
subq %rax, 0xc50(%rbx)
testq %r14, %r14
je 0x43ec11
movq 0x8(%rsp), %rax
leaq 0x28(%rax), %rcx
movq %rcx, 0x10(%rsp)
leaq 0xc08(%rax), %r13
movq 0x8(%rsp), %rbx
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x40e976
movq %rax, %rbp
movq %r13, %rdi
leaq 0x1b52eb(%rip), %rsi    # 0x5f3e89
callq 0x4c3ef0
testl %eax, %eax
je 0x43ebd5
movsd 0xc28(%rbx), %xmm0
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x43f2f6
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x43f1e4
jmp 0x43ec08
movq %r15, 0x28(%rsp)
leaq 0x20c8a7(%rip), %rax    # 0x64b488
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x411b32
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x43f0d8
decq %r14
jne 0x43eb84
callq 0x440898
movq 0x8(%rsp), %rcx
addq %rax, 0xc50(%rcx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl 0x50(%rcx), %eax
movq 0x18(%rcx,%rax,8), %rcx
cmpq 0x40(%rbx,%rax,8), %rcx
je 0x43f2e7
movq %rsi, %r14
movq %rdi, %r15
leaq 0x88(%rsi), %r12
shlq $0x4, %rdx
leaq (%rsi,%rdx), %r13
addq $0x88, %r13
movq 0x8(%rbx), %rax
shlq $0x4, %rax
addq %r12, %rax
xorl %ecx, %ecx
movq (%r13,%rcx), %rdx
subq (%rax,%rcx), %rdx
xorps %xmm0, %xmm0
cvtsi2sd %rdx, %xmm0
mulsd 0x78(%r14,%rcx), %xmm0
movsd %xmm0, (%rsp,%rcx)
addq $0x8, %rcx
cmpq $0x10, %rcx
jne 0x43f230
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd 0x18bd72(%rip), %xmm0   # 0x5cafe8
jb 0x43f27e
sqrtsd %xmm0, %xmm0
jmp 0x43f283
callq 0x4ee410
divsd 0xbf8(%r15), %xmm0
callq 0x401140
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x18bd37(%rip), %xmm0   # 0x5cafd8
cvttsd2si %xmm0, %rdx
sarq $0x3f, %rcx
andl %ecx, %edx
orl %edx, %eax
movq 0xc30(%r15), %rcx
movq 0xc38(%r15), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jae 0x43f2cc
incq (%rcx,%rax,8)
movq %rbx, %rdi
callq 0x4119b8
movl 0x50(%rbx), %eax
movq 0x18(%rbx,%rax,8), %rcx
cmpq 0x40(%rbx,%rax,8), %rcx
jne 0x43f223
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
xorpd %xmm1, %xmm1
movapd %xmm0, 0x20(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x43f39f
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x411628
movapd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x43f378
incl %ebp
cmpl $0x2, %ebp
jne 0x43f31f
shlq $0x4, %r15
leaq (%r14,%r15), %rdx
addq $0x88, %rdx
movaps 0x18bd7e(%rip), %xmm1   # 0x5cb0d0
movaps 0x20(%rsp), %xmm0
xorps %xmm0, %xmm1
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movaps %xmm0, %xmm2
callq 0x411a10
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x191a35(%rip), %rsi    # 0x5d0dbd
leaq 0x191a5b(%rip), %rdx    # 0x5d0dea
movq %rsp, %rdi
callq 0x40843e
movq %rsp, %rdi
callq 0x440975
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1919fb(%rip), %rsi    # 0x5d0daa
leaq 0x191a06(%rip), %rdx    # 0x5d0dbc
movq %rsp, %rdi
callq 0x40843e
movq %rsp, %rdi
callq 0x440975
jmp 0x43f3ca
jmp 0x43f3e5
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x43f3e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4440d0
jmp 0x43f3e8
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4f77a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x214f0d(%rip), %al     # 0x6557b0
testb %al, %al
je 0x4408cf
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x577b00
movq (%rbx), %rax
subq 0x214eea(%rip), %rax    # 0x6557a8
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
addq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
callq 0x401899
jmp 0x4408a7