LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawAxes()
static void
DrawAxes(void)
{
  // Draw axes 
  RNScalar d = 1;
  glLineWidth(3);
  R3BeginLine();
  RNLoadRgb(1, 0, 0);
  R3LoadPoint(R3zero_point + 0.5 * d * R3negx_vector);
  R3LoadPoint(R3zero_point + d * R3posx_vector);
  R3EndLine();
  R3BeginLine();
  RNLoadRgb(0, 1, 0);
  R3LoadPoint(R3zero_point + 0.5 * d * R3negy_vector);
  R3LoadPoint(R3zero_point + d * R3posy_vector);
  R3EndLine();
  R3BeginLine();
  RNLoadRgb(0, 0, 1);
  R3LoadPoint(R3zero_point + 0.5 * d * R3negz_vector);
  R3LoadPoint(R3zero_point + d * R3posz_vector);
  R3EndLine();
  glLineWidth(1);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movsd 0x19ce81(%rip), %xmm0   # 0x1c7010
movsd %xmm0, 0x120(%rsp)
movss 0x19cefc(%rip), %xmm0   # 0x1c709c
callq 0x25340
callq 0x2f240
movl $0x1, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x2efd0
movsd 0x19ce70(%rip), %xmm0   # 0x1c7030
mulsd 0x120(%rsp), %xmm0
leaq 0xf0(%rsp), %rdi
leaq 0x2152d0(%rip), %rsi    # 0x23f4a8
callq 0x2ebc0
leaq 0x108(%rsp), %rdi
leaq 0x215154(%rip), %rsi    # 0x23f340
leaq 0xf0(%rsp), %rdx
callq 0xed770
leaq 0x108(%rsp), %rdi
callq 0x2f170
movsd 0x120(%rsp), %xmm0
leaq 0xc0(%rsp), %rdi
leaq 0x215242(%rip), %rsi    # 0x23f460
callq 0x2ebc0
leaq 0xd8(%rsp), %rdi
leaq 0x21510e(%rip), %rsi    # 0x23f340
leaq 0xc0(%rsp), %rdx
callq 0xed770
leaq 0xd8(%rsp), %rdi
callq 0x2f170
callq 0x2f250
callq 0x2f240
xorl %edx, %edx
movl $0x1, %esi
movl %edx, %edi
callq 0x2efd0
movsd 0x19cdc4(%rip), %xmm0   # 0x1c7030
mulsd 0x120(%rsp), %xmm0
leaq 0x90(%rsp), %rdi
leaq 0x21523c(%rip), %rsi    # 0x23f4c0
callq 0x2ebc0
leaq 0xa8(%rsp), %rdi
leaq 0x2150a8(%rip), %rsi    # 0x23f340
leaq 0x90(%rsp), %rdx
callq 0xed770
leaq 0xa8(%rsp), %rdi
callq 0x2f170
movsd 0x120(%rsp), %xmm0
leaq 0x60(%rsp), %rdi
leaq 0x2151b1(%rip), %rsi    # 0x23f478
callq 0x2ebc0
leaq 0x78(%rsp), %rdi
leaq 0x215068(%rip), %rsi    # 0x23f340
leaq 0x60(%rsp), %rdx
callq 0xed770
leaq 0x78(%rsp), %rdi
callq 0x2f170
callq 0x2f250
callq 0x2f240
xorl %esi, %esi
movl $0x1, %edx
movl %esi, %edi
callq 0x2efd0
movsd 0x19cd24(%rip), %xmm0   # 0x1c7030
mulsd 0x120(%rsp), %xmm0
leaq 0x30(%rsp), %rdi
leaq 0x2151b7(%rip), %rsi    # 0x23f4d8
callq 0x2ebc0
leaq 0x48(%rsp), %rdi
leaq 0x21500e(%rip), %rsi    # 0x23f340
leaq 0x30(%rsp), %rdx
callq 0xed770
leaq 0x48(%rsp), %rdi
callq 0x2f170
movsd 0x120(%rsp), %xmm0
movq %rsp, %rdi
leaq 0x215137(%rip), %rsi    # 0x23f490
callq 0x2ebc0
leaq 0x18(%rsp), %rdi
leaq 0x214fd6(%rip), %rsi    # 0x23f340
movq %rsp, %rdx
callq 0xed770
leaq 0x18(%rsp), %rdi
callq 0x2f170
callq 0x2f250
movss 0x19cd0f(%rip), %xmm0   # 0x1c7098
callq 0x25340
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DeleteSelectedSurface()
static int
DeleteSelectedSurface(void)
{
  // Print message
  if (selected_surface_index >= 0) {
    printf("Deleted surface %d\n", selected_surface_index);
    fflush(stdout);
  }
  else {
    printf("Select a surface first, and then type ctrl-d if you want to delete it\n");
    fflush(stdout);
    return 0;
  }

  // Delete selected surface
  RGBDSurface *selected_surface = configuration.Surface(selected_surface_index);
  delete selected_surface;

  // Reset selected surface index
  selected_surface_index = -1;

  // Return success
  return 1;
}

// Assembly:
subq $0x18, %rsp
cmpl $0x0, 0x2090c9(%rip)    # 0x235ae4
jl 0x2ca42
movl 0x2090c1(%rip), %esi    # 0x235ae4
leaq 0x19aa8e(%rip), %rdi    # 0x1c74b8
movb $0x0, %al
callq 0x24090
movq 0x208558(%rip), %rax    # 0x234f90
movq (%rax), %rdi
callq 0x24c20
jmp 0x2ca69
leaq 0x19aa83(%rip), %rdi    # 0x1c74cc
movb $0x0, %al
callq 0x24090
movq 0x208539(%rip), %rax    # 0x234f90
movq (%rax), %rdi
callq 0x24c20
movl $0x0, 0x14(%rsp)
jmp 0x2caab
movl 0x209075(%rip), %esi    # 0x235ae4
leaq 0x20f16a(%rip), %rdi    # 0x23bbe0
callq 0x2f050
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2ca99
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0xffffffff, 0x209041(%rip) # imm = 0xFFFFFFFF
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: main
int
main(int argc, char **argv)
{
  // Initialize packages
  if (!R3InitGraphics()) exit(-1);

  // Check number of arguments
  if (!ParseArgs(argc, argv)) exit(1);

  // Read configuration
  if (!ReadConfigurationFile(configuration, input_configuration_filename)) exit(-1);

  // Read mesh
  if (input_mesh_filename) {
    if (!ReadMeshFile(configuration, input_mesh_filename)) exit(-1);
  }

  // Read segmentation
  if (input_segmentation_filename) {
    if (!ReadSegmentationFile(configuration, input_segmentation_filename)) exit(-1);
  }

  // Read obbs
  if (input_obbs_filename) {
    if (!ReadOrientedBoxFile(configuration, input_obbs_filename)) exit(-1);
  }

  // Read image-image overlaps
  if (input_overlap_matrix) {
    if (!ReadOverlapMatrix(configuration, input_overlap_matrix)) exit(-1);
  }

  // Read vertex-image overlaps
  if (input_overlap_filename) {
    if (!ReadOverlapFile(configuration, input_overlap_filename)) exit(-1);
  }

  // Begin viewing interface -- never returns
  GLUTInterface();

  // Return success 
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0x4aa80
cmpl $0x0, %eax
jne 0x2cc49
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c90
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x2cd80
cmpl $0x0, %eax
jne 0x2cc66
movl $0x1, %edi
callq 0x24c90
movq 0x20f1e3(%rip), %rsi    # 0x23be50
leaq 0x20ef6c(%rip), %rdi    # 0x23bbe0
callq 0x2d270
cmpl $0x0, %eax
jne 0x2cc88
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c90
cmpq $0x0, 0x20f1c8(%rip)    # 0x23be58
je 0x2ccb6
movq 0x20f1bf(%rip), %rsi    # 0x23be58
leaq 0x20ef40(%rip), %rdi    # 0x23bbe0
callq 0x2d470
cmpl $0x0, %eax
jne 0x2ccb4
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c90
jmp 0x2ccb6
cmpq $0x0, 0x20f1a2(%rip)    # 0x23be60
je 0x2cce4
movq 0x20f199(%rip), %rsi    # 0x23be60
leaq 0x20ef12(%rip), %rdi    # 0x23bbe0
callq 0x2d680
cmpl $0x0, %eax
jne 0x2cce2
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c90
jmp 0x2cce4
cmpq $0x0, 0x20f17c(%rip)    # 0x23be68
je 0x2cd12
movq 0x20f173(%rip), %rsi    # 0x23be68
leaq 0x20eee4(%rip), %rdi    # 0x23bbe0
callq 0x2d750
cmpl $0x0, %eax
jne 0x2cd10
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c90
jmp 0x2cd12
cmpq $0x0, 0x20f156(%rip)    # 0x23be70
je 0x2cd40
movq 0x20f14d(%rip), %rsi    # 0x23be70
leaq 0x20eeb6(%rip), %rdi    # 0x23bbe0
callq 0x2d820
cmpl $0x0, %eax
jne 0x2cd3e
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c90
jmp 0x2cd40
cmpq $0x0, 0x20f130(%rip)    # 0x23be78
je 0x2cd6e
movq 0x20f127(%rip), %rsi    # 0x23be78
leaq 0x20ee88(%rip), %rdi    # 0x23bbe0
callq 0x2d9c0
cmpl $0x0, %eax
jne 0x2cd6c
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c90
jmp 0x2cd6e
callq 0x2cac0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: ReadOverlapMatrix(gaps::RGBDConfiguration&, char const*)
static int
ReadOverlapMatrix(RGBDConfiguration& configuration, const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate matrix
  image_image_overlaps = new R2Grid();
  if (!image_image_overlaps) {
    RNFail("Unable to allocate overlap matrix for %s\n", filename);
    return 0;
  }

  // Read matrix from file
  if (!image_image_overlaps->ReadFile(filename)) {
    RNFail("Unable to read overlap matrix from %s\n", filename);
    return 0;
  }

  // Apply scale factor if png
  if (strstr(filename, ".png")) image_image_overlaps->Multiply(0.001);

  // Print statistics
  if (print_verbose) {
    printf("Read overlaps from %s ...\n", filename);
    printf("  # Images = %d\n", image_image_overlaps->XResolution());
    printf("  # Overlaps = %d\n", image_image_overlaps->Cardinality());
    printf("  Mean = %g\n", image_image_overlaps->Mean());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x127730
movq (%rsp), %rdi
callq 0x2e970
movl $0xd0, %edi
callq 0x24a00
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0xff7e0
jmp 0x2d865
movq 0x8(%rsp), %rax
movq %rax, 0x20e627(%rip)    # 0x23be98
cmpq $0x0, 0x20e61f(%rip)    # 0x23be98
jne 0x2d8bd
movq 0x30(%rsp), %rsi
leaq 0x199ecf(%rip), %rdi    # 0x1c7756
movb $0x0, %al
callq 0x12c6b0
movl $0x0, 0x44(%rsp)
jmp 0x2d9a3
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0xd0, %esi
callq 0x24a20
jmp 0x2d9ac
movq 0x20e5d4(%rip), %rdi    # 0x23be98
movq 0x30(%rsp), %rsi
callq 0x10f370
cmpl $0x0, %eax
jne 0x2d8f3
movq 0x30(%rsp), %rsi
leaq 0x199ea1(%rip), %rdi    # 0x1c7780
movb $0x0, %al
callq 0x12c6b0
movl $0x0, 0x44(%rsp)
jmp 0x2d9a3
movq 0x30(%rsp), %rdi
leaq 0x19c1f0(%rip), %rsi    # 0x1c9aef
callq 0x241a0
cmpq $0x0, %rax
je 0x2d91e
movq 0x20e587(%rip), %rdi    # 0x23be98
movsd 0x19976f(%rip), %xmm0   # 0x1c7088
callq 0x107d80
cmpl $0x0, 0x20e4ab(%rip)    # 0x23bdd0
je 0x2d99b
movq 0x30(%rsp), %rsi
leaq 0x199e74(%rip), %rdi    # 0x1c77a7
movb $0x0, %al
callq 0x24090
movq 0x20e557(%rip), %rdi    # 0x23be98
callq 0x2f7f0
movl %eax, %esi
leaq 0x199a55(%rip), %rdi    # 0x1c73a4
movb $0x0, %al
callq 0x24090
movq 0x20e53b(%rip), %rdi    # 0x23be98
callq 0x1010e0
movl %eax, %esi
leaq 0x199e57(%rip), %rdi    # 0x1c77c2
movb $0x0, %al
callq 0x24090
movq 0x20e51f(%rip), %rdi    # 0x23be98
callq 0x101180
leaq 0x199e50(%rip), %rdi    # 0x1c77d5
movb $0x1, %al
callq 0x24090
movq 0x2075fd(%rip), %rax    # 0x234f90
movq (%rax), %rdi
callq 0x24c20
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x252b0
nopw %cs:(%rax,%rax)
// File: SoftwearDevelopment[P]xattr_syscall_wrapper/listxattr.cc
// Function: void print_with_newline<char*, std::ostream>(char*, char*, std::ostream&)
void print_with_newline(Itr s, Itr end, Os &out) {
  while (s < end) {
    char *next = std::find(s, end, '\0');
    size_t slen = next - s;

    if (next == end) {
      std::cerr << "error: Found string that is not \\0 terminated "
                << "at the end of the xattr list. Exiting confused.";
      exit(1);
    }

    out.write(s, slen);
    out << std::endl;

    s += slen + 1;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2b86
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb $0x0, -0x21(%rbp)
leaq -0x21(%rbp), %rdx
callq 0x39f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x2b50
movq 0x44c5(%rip), %rdi      # 0x6ff0
leaq 0x15bd(%rip), %rsi      # 0x40ef
callq 0x2170
movq %rax, %rdi
leaq 0x15dd(%rip), %rsi      # 0x411e
callq 0x2170
movl $0x1, %edi
callq 0x21f0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2210
movq -0x18(%rbp), %rdi
movq 0x4454(%rip), %rsi      # 0x6fc0
callq 0x21a0
movq -0x30(%rbp), %rax
addq $0x1, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2ae4
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Cell-veto[P]postlhc/jellium3.cpp
// Function: void for_all_angles<2ul, void Jellium3::calibrate<2u>(unsigned int)::'lambda'(std::array<double, 2ul> const&)>(unsigned int, void Jellium3::calibrate<2u>(unsigned int)::'lambda'(std::array<double, 2ul> const&) const&)
static
void for_all_angles (unsigned discretization, const CALLABLE &yield)
{
    // FIXME explicit 3D missing (strictly speaking, we might underestimate
    // the LR if the box is very different from cubic.  ecmc.hpp would
    // violently complain, however, and this would not go undetected)
    double incr = 2*M_PI / discretization;
    vector <DIM> d = zero_vector <DIM> ();
    for (unsigned i = 0; i != discretization; ++i)
    {
        d[0] = cos (incr*i);
        d[1] = sin (incr*i);
        yield (d);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
cvtsi2sd %rax, %xmm1
movsd 0x1e8169(%rip), %xmm0   # 0x5fc348
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x41a980
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
je 0x414284
movsd -0x18(%rbp), %xmm0
movl -0x2c(%rbp), %eax
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
callq 0x4010e8
movsd %xmm0, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x418e10
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movl -0x2c(%rbp), %eax
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
callq 0x401090
movsd %xmm0, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x418e10
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41bbe0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4141fe
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse2D>::reset_statistics()
virtual
    void reset_statistics ()
    {
        walltime = 0;
        all_events.fill (0);
        longrange_events.fill (0);
        chainend_events.fill (0);
        longrange_predicts = shortrange_predicts = 0;
        cumulative_disp.fill (0.);
        cumulative_xdisp.fill (0.);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, 0x24a0(%rdi)
addq $0x24c8, %rdi           # imm = 0x24C8
movq $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x4183a0
movq -0x38(%rbp), %rdi
addq $0x24d8, %rdi           # imm = 0x24D8
movq $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x4183a0
movq -0x38(%rbp), %rdi
addq $0x24e8, %rdi           # imm = 0x24E8
movq $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x4183a0
movq -0x38(%rbp), %rdi
movq $0x0, 0x2500(%rdi)
movq $0x0, 0x24f8(%rdi)
addq $0x24a8, %rdi           # imm = 0x24A8
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x415e30
movq -0x38(%rbp), %rdi
addq $0x24b8, %rdi           # imm = 0x24B8
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x415e30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse2D>::calibrate(AbstractStorage*)
virtual
    void calibrate (AbstractStorage *stor_)
    {
        stor_t *stor = downcast (stor_);
        double chexp = measure_chain_expansion (stor, 0);
        double Lmax = stor->periods ().max ();
        calib_constant = Lmax / chexp / 2;

        target_epc = factor_quantity (stor->num_particles (), trunc_periods (stor));
        target_tdisppc = trunc_periods (stor);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x418e40
movq -0x78(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
xorl %edx, %edx
movl $0x64, %ecx
callq 0x41f930
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq *%rax
movq -0x88(%rbp), %rdi
callq 0x41fe20
movq -0x78(%rbp), %rax
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0x1e57cc(%rip), %xmm1   # 0x5fc2a0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, %xmm0
movaps 0x1e58aa(%rip), %xmm1   # 0x5fc3a0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x1e58ae(%rip), %xmm1   # 0x5fc3b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41fef0
movaps %xmm0, %xmm2
movsd -0x80(%rbp), %xmm0
movsd %xmm2, -0x60(%rbp)
movsd %xmm1, -0x58(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x41fe60
movq -0x78(%rbp), %rax
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, 0x2480(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x2488(%rax)
movq -0x18(%rbp), %rdi
callq 0x41fef0
movq -0x78(%rbp), %rax
movsd %xmm0, -0x70(%rbp)
movsd %xmm1, -0x68(%rbp)
movq -0x70(%rbp), %rcx
movq %rcx, 0x2490(%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x2498(%rax)
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse2D>::collide(AbstractStorage*, double)
virtual
    void collide (AbstractStorage *stor_, double disp_per_particle)
    {
        walltime -= gclock ();
        stor_t *stor = downcast (stor_);
        unsigned num_chains = 1 + stor->num_particles () * disp_per_particle / calib_constant;
        this->run (stor, num_chains, calib_constant);
        walltime += gclock ();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x46d200
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq 0x24a0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x24a0(%rax)
movq -0x10(%rbp), %rdi
callq 0x418e40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq -0x30(%rbp), %rdi
movq %rax, %xmm0
movaps 0x1e579c(%rip), %xmm1   # 0x5fc3a0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x1e57a0(%rip), %xmm1   # 0x5fc3b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x28(%rdi), %xmm1
divsd %xmm1, %xmm0
movsd 0x1e43df(%rip), %xmm1   # 0x5fb018
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movsd 0x28(%rdi), %xmm0
callq 0x421f30
callq 0x46d200
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq 0x24a0(%rax), %rcx
movq %rcx, 0x24a0(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse2D>::sum_uivector(std::array<unsigned long, 2ul> const&)
static
    uint64_t sum_uivector (const uivector_t &v)
    {
        uint64_t ret = v[0];
        for (size_t i = 1; i != v.size (); ++i)
            ret += v[i];
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x418ca0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x418460
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x4185eb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x418ca0
movq (%rax), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4185a8
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Cell-veto[P]postlhc/./tools.hpp
// Function: std::array<double, 2ul> elementwise_fdivide<double, 2ul, std::array<unsigned long, 2ul>>(std::array<double, 2ul> const&, std::array<unsigned long, 2ul> const&)
auto elementwise_fdivide (const std::array <TYPE, DIM> &lhs, const VEC2 &rhs)
    -> std::array <double, DIM>
{
    std::array <double, DIM> ret;
    for (size_t n = 0; n != DIM; ++n)
        ret[n] = double (lhs[n]) / double (rhs[n]);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x2, -0x28(%rbp)
je 0x41891d
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x418dc0
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x418ca0
movsd -0x38(%rbp), %xmm0
movq (%rax), %xmm1
movaps 0x1e3ace(%rip), %xmm2   # 0x5fc3a0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x1e3ad2(%rip), %xmm2   # 0x5fc3b0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x418e10
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x418898
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Cell-veto[P]postlhc/./vector.hpp
// Function: std::array<decltype(fp[0] * fp0[0]), 2ul> vector_math_for_std_array::elementwise_product<unsigned long, 2ul, std::array<double, 2ul>>(std::array<unsigned long, 2ul> const&, std::array<double, 2ul> const&)
auto elementwise_product (const std::array <TYPE, DIM> &lhs, const TYPE2 &rhs)
        -> std::array <decltype (lhs[0]*rhs[0]), DIM>
    {
        std::array <decltype (lhs[0]*rhs[0]), DIM> ret;
        for (size_t n = 0; n != DIM; ++n)
            ret[n] = lhs[n]*rhs[n];
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x2, -0x28(%rbp)
je 0x418b56
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x418ca0
movq (%rax), %xmm0
movaps 0x1e38a9(%rip), %xmm1   # 0x5fc3a0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x1e38ad(%rip), %xmm1   # 0x5fc3b0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x418dc0
movsd -0x38(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x418e10
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x418ad8
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Cell-veto[P]postlhc/./vector.hpp
// Function: std::array<double, 2ul> vector_math_for_std_array::operator+<double, 2ul>(std::array<double, 2ul> const&, std::array<double, 2ul> const&)
std::array <TYPE, DIM> operator+ (const std::array <TYPE, DIM> &lhs, const std::array <TYPE, DIM> &rhs)
    {
        std::array <TYPE, DIM> ret;
        for (size_t n = 0; n != DIM; ++n)
            ret[n] = lhs[n] + rhs[n];
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x2, -0x28(%rbp)
je 0x418be4
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x418dc0
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x418dc0
movsd -0x38(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x418e10
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x418b88
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::cell_diagonal() const
double cell_diagonal () const
    {
        double nsq = 0.;
        for (unsigned n = 0; n != DIM; ++n)
            nsq += sq (cell_width (n));
        return sqrt (nsq);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
je 0x4192ff
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x41def0
callq 0x418110
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4192d3
movsd -0x10(%rbp), %xmm0
callq 0x51f030
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::random_particle(RandomContext*)
key_t random_particle (RandomContext *random)
    {
        assert (num_ > 0);
        key_t ret;
        do {
            ret = random->uint (num_cells_);
        } while (!data_[ret].in_use ());
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x30(%rax)
jbe 0x419361
jmp 0x419380
leaq 0x1e3900(%rip), %rdi    # 0x5fcc68
leaq 0x1e3178(%rip), %rsi    # 0x5fc4e7
movl $0x221, %edx            # imm = 0x221
leaq 0x1e38f6(%rip), %rcx    # 0x5fcc71
callq 0x53d020
jmp 0x419382
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rax
movl %eax, %esi
callq 0x46e270
movl %eax, %eax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
movq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x41dff0
xorb $-0x1, %al
testb $0x1, %al
jne 0x419382
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Cell-veto[P]postlhc/./tools.hpp
// Function: std::array<double, 2ul> zero_vector<2ul>()
std::array <double, DIM> zero_vector ()
{
    std::array <double, DIM> ret;
    for (size_t n = 0; n != DIM; ++n)
        ret[n] = 0.;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
je 0x41a9b9
movq -0x18(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x418e10
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x41a990
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Cell-veto[P]postlhc/./vector.hpp
// Function: std::array<std::common_type<double, double>::type, 2ul> vector_math_for_std_array::operator*<double, 2ul, double>(std::array<double, 2ul> const&, double const&)
auto operator* (const std::array <TYPE, DIM> &lhs, const TYPE2 &rhs)
        -> detail::return_array <TYPE, TYPE2, DIM>
    {
        detail::return_array <TYPE, TYPE2, DIM> ret;
        for (size_t n = 0; n != DIM; ++n)
            ret[n] = lhs[n] * rhs;
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x2, -0x28(%rbp)
je 0x41bd11
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x418dc0
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x418e10
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x41bcc8
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Cell-veto[P]postlhc/./vector.hpp
// Function: decltype(fp[0] * fp0[0]) vector_math_for_std_array::inner_product<std::array<double, 2ul>, std::array<double, 2ul>>(std::array<double, 2ul> const&, std::array<double, 2ul> const&)
auto inner_product (const VEC1 &lhs, const VEC2 &rhs) -> decltype (lhs[0]*rhs[0])
    {
        using type = decltype (lhs[0]*rhs[0]);
        using detail::vector_dimension;
        const size_t size = vector_dimension (lhs);
        assert (size == vector_dimension (rhs));
        if (size == 0)
            return type ();
        type ret = lhs[0]*rhs[0];
        for (size_t i = 1; i != size; ++i)
            ret += lhs[i]*rhs[i];
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41c140
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41c140
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x41c05c
jmp 0x41c07b
leaq 0x1e08c7(%rip), %rdi    # 0x5fc92a
leaq 0x1e08df(%rip), %rsi    # 0x5fc949
movl $0x8c, %edx
leaq 0x1e08e0(%rip), %rcx    # 0x5fc956
callq 0x53d020
cmpq $0x0, -0x20(%rbp)
jne 0x41c08f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x41c128
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x418dc0
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x418dc0
movsd -0x40(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x41c11e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x418dc0
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x418dc0
movsd -0x48(%rbp), %xmm0
movsd (%rax), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x41c0c8
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Cell-veto[P]postlhc/./tools.hpp
// Function: sphere_surface(unsigned int)
inline constexpr
double sphere_surface (unsigned DIM)
{
    return
        DIM==3 ? 4*M_PI :
        DIM==2 ? 2*M_PI :
        (std::abort (), NAN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x3, -0x4(%rbp)
jne 0x41c690
movsd 0x1dfcf7(%rip), %xmm0   # 0x5fc380
movsd %xmm0, -0x10(%rbp)
jmp 0x41c6ac
cmpl $0x2, -0x4(%rbp)
jne 0x41c698
jmp 0x41c69d
callq 0x40385d
movsd 0x1dfca3(%rip), %xmm0   # 0x5fc348
movsd %xmm0, -0x10(%rbp)
jmp 0x41c6ac
movsd -0x10(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::enumerate_strip(unsigned long, unsigned int, double, double, double)
StripGenerator enumerate_strip (key_t whence, unsigned direction,
        double strip_width, double begin, double end)
    {
        if (2*cell_diagonal () + 2*strip_width >= period (direction))
            rt_error ("sr_lr_split too large / periods too small");
        if (fabs (end) > strip_max_extent (direction))
            rt_error ("strip too long (this should not happen)");

        return StripGenerator (*this, data_[whence].coord, direction,
            strip_width, begin, end);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movsd %xmm2, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4192b0
movq -0xa8(%rbp), %rdi
movsd 0x1de167(%rip), %xmm1   # 0x5fc2b0
mulsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0xa0(%rbp)
movl -0x1c(%rbp), %esi
callq 0x41df90
movaps %xmm0, %xmm1
movsd -0xa0(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x41e1dc
leaq -0x59(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x4771f0
movq -0xc0(%rbp), %rdx
leaq 0x1dec16(%rip), %rsi    # 0x5fcdab
leaq -0x58(%rbp), %rdi
callq 0x407bd0
jmp 0x41e1a0
leaq -0x58(%rbp), %rdi
callq 0x46d330
jmp 0x41e1ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x41e1ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4f1e40
leaq -0x59(%rbp), %rdi
callq 0x477210
jmp 0x41e2cf
movq -0xa8(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
movaps 0x1de1d1(%rip), %xmm1   # 0x5fc3c0
pand %xmm1, %xmm0
movsd %xmm0, -0xc8(%rbp)
movl -0x1c(%rbp), %esi
callq 0x41e040
movaps %xmm0, %xmm1
movsd -0xc8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x41e285
leaq -0x91(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x4771f0
movq -0xd0(%rbp), %rdx
leaq 0x1deba0(%rip), %rsi    # 0x5fcdd5
leaq -0x90(%rbp), %rdi
callq 0x407bd0
jmp 0x41e243
leaq -0x90(%rbp), %rdi
callq 0x46d330
jmp 0x41e251
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x41e277
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4f1e40
leaq -0x91(%rbp), %rdi
callq 0x477210
jmp 0x41e2cf
movq -0xa8(%rbp), %rsi
movq -0xb8(%rbp), %rdi
movq %rsi, %rdx
addq $0x88, %rdx
movq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
movl -0x1c(%rbp), %ecx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
callq 0x41e660
movq -0xb0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x5283c0
nopl (%rax,%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::distance_vector(unsigned long, unsigned long)
vector_t distance_vector (key_t j, key_t i)
    {
        vector_t r;
        for (unsigned n = 0; n != DIM; ++n)
            r[n] = frac2real[n] *
                int64_t (data_[j].coord[n] - data_[i].coord[n]);
        return r;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x2, -0x2c(%rbp)
je 0x41e3aa
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
movsd 0x78(%rcx,%rax,8), %xmm0
movq %rcx, %rax
addq $0x88, %rax
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl -0x2c(%rbp), %edx
movq (%rax,%rdx,8), %rax
addq $0x88, %rcx
movq -0x28(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl -0x2c(%rbp), %edx
subq (%rcx,%rdx,8), %rax
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %esi
leaq -0x10(%rbp), %rdi
callq 0x418e10
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x41e333
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/./ecmc.hpp
// Function: double ChainRunner<Jellium3, Monodisperse2D>::norm_ortho_sq<2ul>(std::array<double, 2ul> const&, unsigned long)
static
    double norm_ortho_sq (const vector <DIM> &v, size_t skip)
    {
        assert (skip < DIM);
        double ret = 0.;
        for (size_t i = 0; i != DIM; ++i)
        {
            if (i != skip)
                ret += v[i]*v[i];
        }
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x2, -0x10(%rbp)
jae 0x41e3f9
jmp 0x41e418
leaq 0x1ded37(%rip), %rdi    # 0x5fd137
leaq 0x1ded3b(%rip), %rsi    # 0x5fd142
movl $0x16a, %edx            # imm = 0x16A
leaq 0x1ded3a(%rip), %rcx    # 0x5fd14d
callq 0x53d020
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x2, -0x20(%rbp)
je 0x41e487
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x41e477
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x418dc0
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x418dc0
movsd -0x28(%rbp), %xmm0
movsd (%rax), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x41e479
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x41e428
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::StripGenerator::clip(unsigned long, double)
void clip (key_t active, double end)
        {
            uint64_t whence = stor_->data_[active].coord[direction_];
            uint64_t end_frac = stor_->real2frac[direction_] * end;
            uint64_t new_hi_bound = stor_->cell_ceil (whence + end_frac, direction_);
#ifdef DEBUG
            // check we're not jumping over the end marker.
            for (uint64_t t = new_hi_bound; t != hi_bound_[direction_];
                    t += stor_->cell_stride (direction_))
                assert (t != position_[direction_]);
            assert (lo_bound_[direction_] != new_hi_bound);
#endif
            hi_bound_[direction_] = new_hi_bound;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl 0x50(%rax), %edx
movq 0x88(%rcx,%rdx,8), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rcx
movl 0x50(%rax), %edx
movsd 0x68(%rcx,%rdx,8), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movsd 0x1dddf0(%rip), %xmm1   # 0x5fc388
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
addq -0x28(%rbp), %rsi
movl 0x50(%rax), %edx
callq 0x41e980
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movl 0x50(%rax), %ecx
movq %rdx, 0x40(%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::cell_floor(unsigned long, unsigned int) const
uint64_t cell_floor (uint64_t frac, unsigned n) const
    {
        assert (n < DIM);
        frac >>= 64 - bc_[n];
        frac <<= 64 - bc_[n];
        return frac;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x2, -0x14(%rbp)
jae 0x41e913
jmp 0x41e932
leaq 0x1de284(%rip), %rdi    # 0x5fcb9e
leaq 0x1ddbc6(%rip), %rsi    # 0x5fc4e7
movl $0xdd, %edx
leaq 0x1de583(%rip), %rcx    # 0x5fceb0
callq 0x53d020
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
movl $0x40, %ecx
subl 0x3c(%rax,%rdx,4), %ecx
movq -0x10(%rbp), %rdx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, -0x10(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, %edx
movl $0x40, %ecx
subl 0x3c(%rax,%rdx,4), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::make_base_key(unsigned long const*) const
key_t make_base_key (const uint64_t frac[DIM]) const
    {
        uint64_t ret = 0;
        for (unsigned n = 0; n != DIM; ++n)
        {
            assert (bc_[n] > 0);
            ret <<= bc_[n];
            ret |= frac[n] >> (64-bc_[n]);
        }
        return ret << bc_[DIM];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0x41eb35
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpl $0x0, 0x3c(%rax,%rcx,4)
jbe 0x41eacd
jmp 0x41eaec
leaq 0x1de51b(%rip), %rdi    # 0x5fcfef
leaq 0x1dda0c(%rip), %rsi    # 0x5fc4e7
movl $0xfd, %edx
leaq 0x1de513(%rip), %rcx    # 0x5fcffa
callq 0x53d020
movq -0x28(%rbp), %rdx
movl -0x1c(%rbp), %eax
movl 0x3c(%rdx,%rax,4), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
movl $0x40, %ecx
subl 0x3c(%rdx,%rsi,4), %ecx
movl %ecx, %ecx
shrq %cl, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x41eab7
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x44(%rcx), %ecx
shlq %cl, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::GeneratorBase::get(MostGeneralParticle*)
bool get (MostGeneralParticle *dst) final
        {
            if (not_done ())
            {
                stor_->get (dst, k_);
                next ();
                return true;
            }

            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0x41eba4
jmp 0x41ebc8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq 0x8(%rax), %rdx
callq 0x41edd0
movq -0x20(%rbp), %rdi
callq 0x41e5e0
movb $0x1, -0x1(%rbp)
jmp 0x41ebcc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::StripGenerator::next_cell()
void next_cell () final
        {
            ++k_;
            if (++position_[DIM] < stor_->planes_in_use_)
                return;
            position_[DIM] = 0;

            unsigned n;
            for (n = DIM-1; n+1u != 0u; --n)
            {
                if (n == direction_)
                    continue;
                position_[n] += stor_->cell_stride (n);
                if (position_[n] != hi_bound_[n])
                    goto recompute;
                position_[n] = lo_bound_[n];
            }

            n = direction_;
            position_[n] += stor_->cell_stride (n);

        recompute:
            k_ = stor_->make_base_key (position_);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x8(%rcx)
movq 0x28(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x28(%rcx)
movq 0x10(%rcx), %rcx
movl 0x48(%rcx), %ecx
cmpq %rcx, %rax
jae 0x41ec1d
jmp 0x41ece6
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
cmpl $0x0, %eax
je 0x41eca0
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x50(%rcx), %eax
jne 0x41ec49
jmp 0x41ec95
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x41efc0
movq -0x18(%rbp), %rcx
movq %rax, %rdx
movl -0xc(%rbp), %eax
addq 0x18(%rcx,%rax,8), %rdx
movq %rdx, 0x18(%rcx,%rax,8)
movl -0xc(%rbp), %eax
movq 0x18(%rcx,%rax,8), %rax
movl -0xc(%rbp), %edx
cmpq 0x40(%rcx,%rdx,8), %rax
je 0x41ec81
jmp 0x41ecca
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movq 0x30(%rax,%rcx,8), %rdx
movl -0xc(%rbp), %ecx
movq %rdx, 0x18(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x41ec30
movq -0x18(%rbp), %rax
movl 0x50(%rax), %ecx
movl %ecx, -0xc(%rbp)
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x41efc0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
addq 0x18(%rax,%rcx,8), %rdx
movq %rdx, 0x18(%rax,%rcx,8)
movq -0x18(%rbp), %rsi
movq 0x10(%rsi), %rdi
addq $0x18, %rsi
callq 0x41ea90
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::get(MostGeneralParticle*, unsigned long) const
void get (MostGeneralParticle *ret, key_t k) const
    {
        assert (k < num_cells_);
        const CellData &cd = data_[k];
        assert (cd.in_use ());
        decode_coords (&ret->coords, cd.coord);
        ret->tag = cd.tag ();
        ret->disp = cd.disp ();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x41edf8
jmp 0x41ee17
leaq 0x1de25c(%rip), %rdi    # 0x5fd05b
leaq 0x1dd6e1(%rip), %rsi    # 0x5fc4e7
movl $0x20b, %edx            # imm = 0x20B
leaq 0x1de258(%rip), %rcx    # 0x5fd06a
callq 0x53d020
movq -0x40(%rbp), %rax
addq $0x88, %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x41dff0
testb $0x1, %al
jne 0x41ee3f
jmp 0x41ee41
jmp 0x41ee60
leaq 0x1de284(%rip), %rdi    # 0x5fd0cc
leaq 0x1dd698(%rip), %rsi    # 0x5fc4e7
movl $0x20d, %edx            # imm = 0x20D
leaq 0x1de20f(%rip), %rcx    # 0x5fd06a
callq 0x53d020
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x41eec0
movq -0x20(%rbp), %rdi
callq 0x41ef80
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x41ef90
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::decode_coords(std::array<double, 3ul>*, unsigned long const*) const
void decode_coords (vector <MAX_DIM> *real, const uint64_t frac[DIM]) const
    {
        unsigned n = 0;
        for (; n != DIM; ++n)
            (*real)[n] = frac2real[n] * frac[n];
        for (; n != MAX_DIM; ++n)
            (*real)[n] = 0.;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
je 0x41ef4c
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsd 0x78(%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movq (%rax,%rcx,8), %xmm1
movaps 0x1dd49a(%rip), %xmm2   # 0x5fc3a0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x1dd49e(%rip), %xmm2   # 0x5fc3b0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x419310
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x41eee3
jmp 0x41ef4e
cmpl $0x3, -0x1c(%rbp)
je 0x41ef74
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x419310
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x41ef4e
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Cell-veto[P]postlhc/./tools.hpp
// Function: RandomContext::exponential(double)
inline
double RandomContext::exponential (double scale)
{
    assert (scale > 0.);
#if RANDOM_EXPONENTIAL_BUFFER_SIZE != 0
    if (num_exp_used_ == RANDOM_EXPONENTIAL_BUFFER_SIZE)
        refill_exp_buffer_ ();
    return exp_buffer_[num_exp_used_++] / scale;
#else
    return exponential () / scale;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x41f059
jmp 0x41f078
leaq 0x1de189(%rip), %rdi    # 0x5fd1e9
leaq 0x1de18d(%rip), %rsi    # 0x5fd1f4
movl $0x120, %edx            # imm = 0x120
leaq 0x1de18d(%rip), %rcx    # 0x5fd200
callq 0x53d020
movq -0x18(%rbp), %rax
cmpl $0x40, 0xbc8(%rax)
jne 0x41f08e
movq -0x18(%rbp), %rdi
callq 0x46e300
movq -0x18(%rbp), %rax
movl 0xbc8(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0xbc8(%rax)
movl %ecx, %ecx
movsd 0x9c8(%rax,%rcx,8), %xmm0
divsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Cell-veto[P]postlhc/./storage.hpp
// Function: Storage<Monodisperse2D>::cell_max_density() const
double cell_max_density () const
    {
        double md = 1.;
        for (unsigned n = 0; n != DIM; ++n)
            md /= cell_width (n);
        return md * cell_count (DIM);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd 0x1dbf0c(%rip), %xmm0   # 0x5fb018
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
je 0x41f146
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x41def0
movaps %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x41f118
movq -0x20(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq (%rdi), %rax
movq 0x48(%rax), %rax
movl $0x2, %esi
callq *%rax
movsd -0x28(%rbp), %xmm0
movq %rax, %xmm1
movaps 0x1dd22d(%rip), %xmm2   # 0x5fc3a0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x1dd231(%rip), %xmm2   # 0x5fc3b0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)