LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawSurfels(int, int)
static void
DrawSurfels(int color_scheme = RGBD_PHOTO_COLOR_SCHEME, int skip = 1)
{
  // Draw pixels of all images as surfels in world space
  for (int i = 0; i < configuration.NImages(); i++) {
    RGBDImage *image = configuration.Image(i);
    if (!image->DepthChannel()) continue;
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index)) image->DrawSurfels(RGBD_HIGHLIGHT_COLOR_SCHEME, skip);
    else image->DrawSurfels(color_scheme, skip);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r14d, %r14d
pushq $0x4
popq %r15
pushq $0x1
popq %rbp
movslq 0x133457(%rip), %rax    # 0x15a8e4
cmpq %rax, %r14
jge 0x274d3
movq 0x13343f(%rip), %rax    # 0x15a8d8
movq (%rax,%r14,8), %rdi
cmpl $0x4, 0x24(%rdi)
jl 0x274ce
movq 0x18(%rdi), %rax
cmpq $0x0, 0x18(%rax)
je 0x274ce
movl 0x12e554(%rip), %eax    # 0x155a08
cmpq %rax, %r14
movl %ebx, %esi
cmovel %r15d, %esi
cmpl $0x3, %ebx
movq (%rdi), %rax
cmovel %ebx, %esi
movl %ebp, %edx
callq *0xe0(%rax)
incq %r14
jmp 0x27486
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawQuads(int, int)
static void
DrawQuads(int color_scheme = RGBD_PHOTO_COLOR_SCHEME, int skip = 1)
{
  // Draw pixels of all images as quads in world space
  for (int i = 0; i < configuration.NImages(); i++) {
    RGBDImage *image = configuration.Image(i);
    if (!image->DepthChannel()) continue;
    if ((color_scheme != RGBD_INDEX_COLOR_SCHEME) && (i == selected_image_index)) image->DrawQuads(RGBD_HIGHLIGHT_COLOR_SCHEME, skip);
    else image->DrawQuads(color_scheme, skip);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r14d, %r14d
pushq $0x4
popq %r15
pushq $0x1
popq %rbp
movslq 0x1333ec(%rip), %rax    # 0x15a8e4
cmpq %rax, %r14
jge 0x2753e
movq 0x1333d4(%rip), %rax    # 0x15a8d8
movq (%rax,%r14,8), %rdi
cmpl $0x4, 0x24(%rdi)
jl 0x27539
movq 0x18(%rdi), %rax
cmpq $0x0, 0x18(%rax)
je 0x27539
movl 0x12e4e9(%rip), %eax    # 0x155a08
cmpq %rax, %r14
movl %ebx, %esi
cmovel %r15d, %esi
cmpl $0x3, %ebx
movq (%rdi), %rax
cmovel %ebx, %esi
movl %ebp, %edx
callq *0xe8(%rax)
incq %r14
jmp 0x274f1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: GLUTMotion(int, int)
void GLUTMotion(int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;

  // Compute mouse movement
  int dx = x - GLUTmouse[0];
  int dy = y - GLUTmouse[1];
  
  // Update mouse drag
  GLUTmouse_drag += dx*dx + dy*dy;

  // Check if control key is down
  if (GLUTmodifiers & GLUT_ACTIVE_CTRL) {
    // Update rubber box
    if (rubber_box_active) {
      DrawRubberBox();
      rubber_box_corners[1] = R2Point(x, y);
      DrawRubberBox();
    }
    else {
      rubber_box_active = TRUE;
      rubber_box_corners[0] = R2Point(x, y);
      rubber_box_corners[1] = R2Point(x, y);
      DrawRubberBox();
    }
  }
  else {
    // World in hand navigation 
    if (GLUTbutton[0]) viewer.RotateWorld(1.0, center, x, y, dx, dy);
    else if (GLUTbutton[1]) viewer.ScaleWorld(1.0, center, x, y, dx, dy);
    else if (GLUTbutton[2]) viewer.TranslateWorld(1.0, center, x, y, dx, dy);
    if (GLUTbutton[0] || GLUTbutton[1] || GLUTbutton[2]) glutPostRedisplay();
  }

  // Remember mouse position 
  GLUTmouse[0] = x;
  GLUTmouse[1] = y;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edi, %ebp
movl 0x12e467(%rip), %ebx    # 0x155a00
subl %esi, %ebx
movl %edi, %r8d
subl 0x13351f(%rip), %r8d    # 0x15aac4
movl %ebx, %r9d
subl 0x133519(%rip), %r9d    # 0x15aac8
movl %r8d, %eax
imull %r8d, %eax
movl %r9d, %ecx
imull %r9d, %ecx
addl 0x133509(%rip), %eax    # 0x15aacc
addl %ecx, %eax
movl %eax, 0x133501(%rip)    # 0x15aacc
testb $0x2, 0x1334fe(%rip)    # 0x15aad0
jne 0x27605
cmpl $0x0, 0x1334fd(%rip)    # 0x15aad8
je 0x27679
leaq 0x1333e8(%rip), %rdi    # 0x15a9d0
leaq 0x1333c9(%rip), %rsi    # 0x15a9b8
movsd 0xbaa19(%rip), %xmm0    # 0xe2010
movl %ebp, %edx
movl %ebx, %ecx
callq 0x37124
jmp 0x276cb
cvtsi2sd %ebp, %xmm0
cvtsi2sd %ebx, %xmm1
cmpb $0x1, 0x1334c0(%rip)    # 0x15aad4
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
jne 0x27628
callq 0x27700
jmp 0x2764b
movb $0x1, 0x1334a5(%rip)    # 0x15aad4
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x93cb8
leaq 0x13333d(%rip), %rdi    # 0x15a980
movq %r14, %rsi
callq 0x93df0
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x93cb8
leaq 0x133326(%rip), %rdi    # 0x15a990
movq %r14, %rsi
callq 0x93df0
callq 0x27700
jmp 0x276eb
cmpl $0x0, 0x13345c(%rip)    # 0x15aadc
je 0x276a3
leaq 0x133347(%rip), %rdi    # 0x15a9d0
leaq 0x133328(%rip), %rsi    # 0x15a9b8
movsd 0xba978(%rip), %xmm0    # 0xe2010
movl %ebp, %edx
movl %ebx, %ecx
callq 0x370c8
jmp 0x276cb
cmpl $0x0, 0x133436(%rip)    # 0x15aae0
je 0x276cb
leaq 0x13331d(%rip), %rdi    # 0x15a9d0
leaq 0x1332fe(%rip), %rsi    # 0x15a9b8
movsd 0xba94e(%rip), %xmm0    # 0xe2010
movl %ebp, %edx
movl %ebx, %ecx
callq 0x36ff6
cmpl $0x0, 0x133406(%rip)    # 0x15aad8
jne 0x276e6
cmpl $0x0, 0x133401(%rip)    # 0x15aadc
jne 0x276e6
cmpl $0x0, 0x1333fc(%rip)    # 0x15aae0
je 0x276eb
callq 0xd562c
movl %ebp, 0x1333d3(%rip)    # 0x15aac4
movl %ebx, 0x1333d1(%rip)    # 0x15aac8
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: DrawRubberBox()
static void 
DrawRubberBox(void)
{
  // Set rendering modes
  glDrawBuffer(GL_FRONT);
  glDisable(GL_DEPTH_TEST);
  glDepthMask(0);
  glLineStipple(1, 0xFF00);
  glEnable(GL_LINE_STIPPLE);
  glLogicOp(GL_XOR);
  glEnable(GL_COLOR_LOGIC_OP);

  // Set projection matrix
  glMatrixMode(GL_PROJECTION);  
  glPushMatrix();
  glLoadIdentity();
  gluOrtho2D(0, GLUTwindow_width, 0, GLUTwindow_height);

  // Set model view matrix
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();

  // Draw box
  RNGrfxBegin(RN_GRFX_LINE_LOOP);
  RNLoadRgb(1.0, 1.0, 1.0);
  R2LoadPoint(rubber_box_corners[0][0], rubber_box_corners[0][1]);
  R2LoadPoint(rubber_box_corners[0][0], rubber_box_corners[1][1]);
  R2LoadPoint(rubber_box_corners[1][0], rubber_box_corners[1][1]);
  R2LoadPoint(rubber_box_corners[1][0], rubber_box_corners[0][1]);
  RNGrfxEnd();

  // Reset projection matrix
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();

  // Reset model view matrix
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();

  // Reset rendering modes
  glDisable(GL_COLOR_LOGIC_OP);
  glDisable(GL_LINE_STIPPLE);
  glEnable(GL_DEPTH_TEST);
  glDepthMask(1);
  glDrawBuffer(GL_BACK);
  glFlush();
}

// Assembly:
pushq %rbx
movl $0x404, %edi            # imm = 0x404
callq 0x23de0
movl $0xb71, %edi            # imm = 0xB71
callq 0x23210
xorl %edi, %edi
callq 0x23510
pushq $0x1
popq %rbx
movl %ebx, %edi
movl $0xff00, %esi           # imm = 0xFF00
callq 0x23b10
movl $0xb24, %edi            # imm = 0xB24
callq 0x23840
movl $0x1506, %edi           # imm = 0x1506
callq 0x24360
movl $0xbf2, %edi            # imm = 0xBF2
callq 0x23840
movl $0x1701, %edi           # imm = 0x1701
callq 0x23cf0
callq 0x23fb0
callq 0x23c80
cvtsi2sdl 0x12e297(%rip), %xmm1 # 0x1559fc
cvtsi2sdl 0x12e293(%rip), %xmm3 # 0x155a00
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
callq 0x23570
movl $0x1700, %edi           # imm = 0x1700
callq 0x23cf0
callq 0x23fb0
callq 0x23c80
pushq $0x2
popq %rdi
callq 0x23190
movsd 0xba874(%rip), %xmm0    # 0xe2010
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x23ec0
movsd 0x1331d1(%rip), %xmm0   # 0x15a980
movsd 0x1331d1(%rip), %xmm1   # 0x15a988
callq 0x23640
movsd 0x1331bc(%rip), %xmm0   # 0x15a980
movsd 0x1331cc(%rip), %xmm1   # 0x15a998
callq 0x23640
movsd 0x1331b7(%rip), %xmm0   # 0x15a990
movsd 0x1331b7(%rip), %xmm1   # 0x15a998
callq 0x23640
movsd 0x1331a2(%rip), %xmm0   # 0x15a990
movsd 0x133192(%rip), %xmm1   # 0x15a988
callq 0x23640
callq 0x23c90
movl $0x1701, %edi           # imm = 0x1701
callq 0x23cf0
callq 0x24210
movl $0x1700, %edi           # imm = 0x1700
callq 0x23cf0
callq 0x24210
movl $0xbf2, %edi            # imm = 0xBF2
callq 0x23210
movl $0xb24, %edi            # imm = 0xB24
callq 0x23210
movl $0xb71, %edi            # imm = 0xB71
callq 0x23840
movl %ebx, %edi
callq 0x23510
movl $0x405, %edi            # imm = 0x405
callq 0x23de0
popq %rbx
jmp 0x23df0
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: ResetViewer()
static void
ResetViewer(void)
{
  // Get bounding box
  R3Box bbox = configuration.WorldBBox();

  // Restrict bounding box only to surfaces, if there are any
  if (configuration.NSurfaces() > 0) {
    bbox = R3null_box;
    for (int i = 0; i < configuration.NSurfaces(); i++) {
      RGBDSurface *surface = configuration.Surface(i);
      bbox.Union(surface->WorldBBox());
    }
  }

  // Initialize viewing center
  center = bbox.Centroid();

  // Initialize viewer
  RNLength r = bbox.DiagonalRadius();
  if (r < 10) r = 10;
  R3Point eye = center - R3negz_vector * (2.5 * r);
  R3Camera camera(eye, R3negz_vector, R3posy_vector, 0.4, 0.4, 0.01 * r, 100.0 * r);
  R2Viewport viewport(0, 0, GLUTwindow_width, GLUTwindow_height);
  viewer.SetViewport(viewport);
  viewer.SetCamera(camera);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
leaq 0x132228(%rip), %rsi    # 0x15a8d0
leaq 0x10(%rsp), %rdi
callq 0x29f5a
cmpl $0x0, 0x13223b(%rip)    # 0x15a8f4
jle 0x28710
leaq 0x134fe6(%rip), %rsi    # 0x15d6a8
leaq 0x10(%rsp), %rdi
callq 0x29f96
xorl %r15d, %r15d
leaq 0x70(%rsp), %rbx
leaq 0x10(%rsp), %r14
movslq 0x132214(%rip), %rax    # 0x15a8f4
cmpq %rax, %r15
jge 0x28710
movq 0x1321fc(%rip), %rax    # 0x15a8e8
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x29fc8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7573a
movq %rbx, %rdi
callq 0x759da
incq %r15
jmp 0x286d9
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x754fe
leaq 0x132292(%rip), %rdi    # 0x15a9b8
leaq 0x70(%rsp), %rsi
callq 0x7cb9e
leaq 0x10(%rsp), %rdi
callq 0x2a012
movsd 0xb9906(%rip), %xmm1    # 0xe2048
maxsd %xmm0, %xmm1
movsd 0xb9922(%rip), %xmm0    # 0xe2070
movsd %xmm1, 0x8(%rsp)
mulsd %xmm1, %xmm0
leaq 0xbd499(%rip), %rsi     # 0xe5bf8
leaq 0x70(%rsp), %rdi
callq 0x7d76a
leaq 0x132248(%rip), %rsi    # 0x15a9b8
leaq 0x58(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x7d005
movsd 0xb98f1(%rip), %xmm2    # 0xe2078
movsd 0x8(%rsp), %xmm3
mulsd %xmm3, %xmm2
mulsd 0xb98e7(%rip), %xmm3    # 0xe2080
leaq 0xbd458(%rip), %rdx     # 0xe5bf8
leaq 0xbd3f1(%rip), %rcx     # 0xe5b98
leaq 0x70(%rsp), %rdi
leaq 0x58(%rsp), %rsi
movsd 0xb9887(%rip), %xmm0    # 0xe2040
movapd %xmm0, %xmm1
callq 0x3859e
movl 0x12d234(%rip), %ecx    # 0x1559fc
movl 0x12d231(%rip), %r8d    # 0x155a00
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x39238
leaq 0x1321ec(%rip), %rdi    # 0x15a9d0
leaq 0x48(%rsp), %rsi
callq 0x36dac
leaq 0x1321db(%rip), %rdi    # 0x15a9d0
leaq 0x70(%rsp), %rsi
callq 0x36d52
leaq 0x10(%rsp), %rdi
callq 0x759da
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
jmp 0x28831
jmp 0x28831
jmp 0x28831
jmp 0x28831
jmp 0x28831
jmp 0x28831
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x759da
jmp 0x28834
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x759da
movq %rbx, %rdi
callq 0x24110
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: GLUTInterface()
void GLUTInterface(void)
{
  // Open window
  int argc = 0;
  char *argv[1];
  argv[argc++] = RNStrdup("conf2texture");
  glutInit(&argc, argv);
  glutInitWindowPosition(100, 100);
  glutInitWindowSize(GLUTwindow_width, GLUTwindow_height);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  GLUTwindow = glutCreateWindow("Configuration Viewer");
  
  // Initialize grfx (after create context because calls glewInit)
  RNInitGrfx();

  // Initialize graphics modes  
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);

  // Initialize lighting
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  static GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
  glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
  glEnable(GL_NORMALIZE);

  // Define headlight
  static GLfloat light0_diffuse[] = { 0.5, 0.5, 0.5, 1.0 };
  static GLfloat light0_position[] = { 0.0, 0.0, 1.0, 0.0 };
  glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
  glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
  glEnable(GL_LIGHT0);

  // Initialize GLUT callback functions 
  glutDisplayFunc(GLUTRedraw);
  glutReshapeFunc(GLUTResize);
  glutKeyboardFunc(GLUTKeyboard);
  glutSpecialFunc(GLUTSpecial);
  glutMouseFunc(GLUTMouse);
  glutMotionFunc(GLUTMotion);

  // Reset viewer
  ResetViewer();

  // Run main loop -- never returns 
  glutMainLoop();
}

// Assembly:
subq $0x18, %rsp
leaq 0xb94a4(%rip), %rdi     # 0xe227a
callq 0x9b569
leaq 0xc(%rsp), %rdi
movl $0x1, (%rdi)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
callq 0xd620d
pushq $0x64
popq %rdi
movl %edi, %esi
callq 0xd6708
movl 0x12cbf9(%rip), %edi    # 0x1559fc
movl 0x12cbf7(%rip), %esi    # 0x155a00
callq 0xd671e
pushq $0x12
popq %rdi
callq 0xd673d
leaq 0xb946a(%rip), %rdi     # 0xe2287
callq 0xdb264
movl %eax, 0x131c58(%rip)    # 0x15aa80
callq 0x98bf8
movl $0xb71, %edi            # imm = 0xB71
callq 0x23840
movl $0xb44, %edi            # imm = 0xB44
callq 0x23840
movl $0x1700, %edi           # imm = 0x1700
callq 0x23cf0
callq 0x23c80
leaq 0x12cbc9(%rip), %rsi    # 0x155a20
movl $0xb53, %edi            # imm = 0xB53
callq 0x24250
pushq $0x1
popq %rsi
movl $0xb51, %edi            # imm = 0xB51
callq 0x23150
movl $0xba1, %edi            # imm = 0xBA1
callq 0x23840
leaq 0x12cbb1(%rip), %rdx    # 0x155a30
movl $0x4000, %edi           # imm = 0x4000
movl $0x1201, %esi           # imm = 0x1201
callq 0x240f0
leaq 0x12cbab(%rip), %rdx    # 0x155a40
movl $0x4000, %edi           # imm = 0x4000
movl $0x1203, %esi           # imm = 0x1203
callq 0x240f0
movl $0x4000, %edi           # imm = 0x4000
callq 0x23840
leaq -0x23c3(%rip), %rdi     # 0x26af2
callq 0xd4d2c
leaq -0x1978(%rip), %rdi     # 0x27549
callq 0xd4d81
leaq -0x687(%rip), %rdi      # 0x28846
callq 0xd4dc3
leaq -0xbc4(%rip), %rdi      # 0x28315
callq 0xd4e0b
leaq -0x1692(%rip), %rdi     # 0x27853
callq 0xd5152
leaq -0x1968(%rip), %rdi     # 0x27589
callq 0xd51e2
callq 0x28695
callq 0xd861f
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/confview/confview.cpp
// Function: CheckVisibility(gaps::RGBDImage*, gaps::R3Point const&)
static int
CheckVisibility(RGBDImage *image, const R3Point& world_position)
{
  // Check world position
  if (world_position == R3unknown_point) return 1;

  // Get/check point depth
  R3Vector vector = world_position - image->WorldViewpoint();
  RNScalar point_depth = vector.Dot(image->WorldTowards());
  if (RNIsNegativeOrZero(point_depth)) return 0;

  // Get/check projection into image
  R2Point image_position;
  if (!image->TransformWorldToImage(world_position, image_position)) return 0;

  // Get/check image depth channel
  R2Grid *depth_channel = image->DepthChannel();
  if (depth_channel) {
    // Get/check image depth
    int image_ix = image_position.X() + 0.5;
    int image_iy = image_position.Y() + 0.5;
    if ((image_ix < 0) || (image_ix > image->NPixels(RN_X))) return 0;
    if ((image_iy < 0) || (image_iy > image->NPixels(RN_Y))) return 0;
    RNScalar image_depth = image->PixelDepth(image_ix, image_iy);
    if ((image_depth == R2_GRID_UNKNOWN_VALUE) || (image_depth == 0)) return 1;

    // If depth is not within 10% of image depth, then probably not 
    if (image_depth < 0.9 * point_depth) return 0;
    if (image_depth > 1.1 * point_depth) return 0;
  }

  // Passed all tests
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x130c81(%rip), %rdi    # 0x15a968
leaq 0x134322(%rip), %rsi    # 0x15e010
callq 0x7c97a
testl %eax, %eax
je 0x29cff
pushq $0x1
popq %rax
jmp 0x29dd8
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29e3e
leaq 0x130c52(%rip), %rsi    # 0x15a968
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x7ca91
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29e58
movq %r15, %rdi
movq %r14, %rsi
callq 0x7d2ee
leaq 0x12c400(%rip), %rax    # 0x156148
movsd (%rax), %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
jae 0x29dd8
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x93cb6
movq (%rbx), %rax
leaq 0x130bf3(%rip), %rsi    # 0x15a968
movq %rbx, %rdi
movq %r14, %rdx
callq *0xb0(%rax)
testl %eax, %eax
je 0x29dd6
cmpl $0x4, 0x24(%rbx)
jl 0x29cf7
movq 0x18(%rbx), %rax
cmpq $0x0, 0x18(%rax)
je 0x29cf7
movsd 0xb8272(%rip), %xmm0    # 0xe2018
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
testl %esi, %esi
js 0x29dd6
addsd 0x18(%rsp), %xmm0
cvttsd2si %xmm0, %edx
cmpl %esi, 0x28(%rbx)
setl %al
testl %edx, %edx
sets %cl
orb %al, %cl
jne 0x29dd6
cmpl %edx, 0x2c(%rbx)
jge 0x29de2
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x29e8c
ucomisd 0xb82a6(%rip), %xmm0    # 0xe2098
pushq $0x1
popq %rax
jne 0x29df9
jnp 0x29dd8
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x29e05
jnp 0x29dd8
movsd 0xb8243(%rip), %xmm1    # 0xe2050
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm1
ucomisd %xmm0, %xmm1
ja 0x29dd6
mulsd 0xb8233(%rip), %xmm2    # 0xe2058
ucomisd %xmm2, %xmm0
movl $0x0, %eax
jbe 0x29cf7
jmp 0x29dd8
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0xf(%rsp), %r15
cmpq %r14, %r12
jae 0x2675
movb $0x0, 0xf(%rsp)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x28b9
cmpq %r14, %rax
je 0x2683
movq %rax, %r13
movq %rax, %rdx
subq %r12, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x20b0
incq %r13
movq %r13, %r12
jmp 0x2634
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2966(%rip), %rdi      # 0x4ff0
leaq 0xa4e(%rip), %rsi       # 0x30df
callq 0x2140
leaq 0xa71(%rip), %rsi       # 0x310e
movq %rax, %rdi
callq 0x2140
pushq $0x1
popq %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse2D>::optimize_sr_lr_split(AbstractStorage*)
virtual
    void optimize_sr_lr_split (AbstractStorage *stor_)
    {
        stor_t *stor = downcast (stor_);

        const int num_samples = 1000;
        double try_splits[] = {  2.1,  1.6,  1.7,  2.3,  2.9,  1.8,  1.5,  3.6,
            0.8,  3.9,  3.5, 0.9,  3.4,  2. ,  1.2,  1.4,  1.9,  3.1,  3.7,  3.,
            3.3,  2.4, 2.2,  2.5,  2.8,  2.7,  1. ,  0.6,  0.7,  3.2,  1.3,  3.8,
            2.6, 1.1 };

        uint64_t smallest_time_so_far = time_for_collisions (stor, try_splits[0], num_samples);
        int best_split_so_far = 0;

        const int num_splits = sizeof(try_splits) / sizeof (try_splits[0]);

        for (int i = 1; i != num_splits; ++i)
        {
            uint64_t time_now = time_for_collisions (stor, try_splits[i], num_samples);
            if (time_now < smallest_time_so_far)
            {
                smallest_time_so_far = time_now;
                best_split_so_far = i;
            }
        }

        std::cerr << "info best sr_lr_split " << try_splits[best_split_so_far] <<"\n";
        set_parameter ("sr_lr_split", try_splits[best_split_so_far]);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x40bb20
movq %rax, %r14
movsd 0x1b462c(%rip), %xmm0   # 0x5bf0f0
movq %rbx, %rdi
movq %rax, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x40bb42
movq %rax, %r15
xorl %ebp, %ebp
pushq $0x1
popq %r13
leaq 0x1b6e9c(%rip), %r12    # 0x5c1980
cmpq $0x22, %r13
je 0x40ab10
movsd (%r12,%r13,8), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x40bb42
cmpq %r15, %rax
cmovbl %r13d, %ebp
cmovbq %rax, %r15
incq %r13
jmp 0x40aae4
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1b49e7(%rip), %rsi    # 0x5bf505
callq 0x4a4910
movslq %ebp, %rcx
movsd (%r12,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rax, %rdi
callq 0x4a5640
leaq 0x1c58c9(%rip), %rsi    # 0x5d040a
movq %rax, %rdi
callq 0x4a4910
leaq 0x1b36a8(%rip), %rsi    # 0x5be1f8
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x406046
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movsd 0x10(%rsp), %xmm0
callq *0x18(%rax)
leaq 0x18(%rsp), %rdi
callq 0x4b4bf0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse3D>::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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4145ac
movq %rax, %r14
pushq $0x64
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x415a00
movsd %xmm0, (%rsp)
movq (%r14), %rax
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movq %r15, %rdi
callq 0x40f2ea
divsd (%rsp), %xmm0
mulsd 0x1ab3fe(%rip), %xmm0   # 0x5bf0f8
movsd %xmm0, 0x28(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movq %rax, %xmm0
punpckldq 0x1ab32b(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1ab333(%rip), %xmm0   # 0x5bf050
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x415d3a
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movaps (%rsp), %xmm0
movq %r15, %rsi
callq 0x415cd3
movq 0x10(%r12), %rax
movq %rax, 0x2498(%rbx)
movups (%r12), %xmm0
movups %xmm0, 0x2488(%rbx)
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x415d3a
movq 0x10(%r15), %rax
movq %rax, 0x24b0(%rbx)
movups (%r15), %xmm0
movups %xmm0, 0x24a0(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x434c6c
subq %rax, 0x24a0(%rbx)
movq %r14, %rdi
callq 0x40bb20
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x30(%rax)
movq %rax, %xmm0
punpckldq 0x1b4388(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1b4390(%rip), %xmm0   # 0x5bf050
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd (%rsp), %xmm1
movsd 0x28(%rbx), %xmm0
divsd %xmm0, %xmm1
addsd 0x1b3336(%rip), %xmm1   # 0x5be018
cvttsd2si %xmm1, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40fa10
callq 0x434c6c
addq %rax, 0x24a0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./ipl.hpp
// Function: PowerLawInteraction::PowerLawInteraction()
PowerLawInteraction ()
    {
        // we set beta = 1.  scale density accordingly!
        gamma = 1.;
        // sr_lr_split = cutoff for a truncated IPL.  otherwise, it's the
        // handshake distance between probing events and direct enumeration.
        sr_lr_split = 5.8;

        // built-in self-test, will leave exponent at 32 at the end
        double rsq_list[] = { 1e-6, 1e-2, 1., 1e2, 1e6 };
        double ex_list[] = { 1024., 6., 0., .5, /*-.5,*/ 1., 32. };
        for (double rsq : rsq_list)
        for (double ex : ex_list)
        {
            set_parameter ("exponent", ex);
            double delta = repulsive_lift (rsq, 1e-2);
            if (! (delta <= 0.))
            {
                std::cerr << "ipl: self-test error\n" << ABORT;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdi)
movabsq $0x4017333333333333, %rax # imm = 0x4017333333333333
movq %rax, 0x18(%rdi)
movaps 0x1b3d3a(%rip), %xmm0   # 0x5bf080
movaps %xmm0, 0x50(%rsp)
movaps 0x1b3d3e(%rip), %xmm0   # 0x5bf090
movaps %xmm0, 0x60(%rsp)
movabsq $0x412e848000000000, %rax # imm = 0x412E848000000000
movq %rax, 0x70(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps 0x1b3d2b(%rip), %xmm0   # 0x5bf0a0
movaps %xmm0, 0x20(%rsp)
movapd 0x1b3d2e(%rip), %xmm0   # 0x5bf0b0
movupd %xmm0, 0x38(%rsp)
movabsq $0x4040000000000000, %rax # imm = 0x4040000000000000
movq %rax, 0x48(%rsp)
xorl %r13d, %r13d
leaq 0x1b3e8e(%rip), %r14    # 0x5bf22f
leaq 0x78(%rsp), %r15
leaq 0xf(%rsp), %r12
cmpq $0x28, %r13
je 0x40b425
movsd 0x50(%rsp,%r13), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %ebp, %ebp
cmpq $0x30, %rbp
je 0x40b41f
movsd 0x20(%rsp,%rbp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x406046
movq %rbx, %rdi
movq %r15, %rsi
movsd 0x18(%rsp), %xmm0
callq 0x40b46e
movq %r15, %rdi
callq 0x4b4bf0
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x1b2c06(%rip), %xmm1   # 0x5be010
callq 0x40b5b8
addq $0x8, %rbp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x40b3c0
jmp 0x40b437
addq $0x8, %r13
jmp 0x40b3ab
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1b3df3(%rip), %rsi    # 0x5bf238
callq 0x4a4910
leaq 0x2421b0(%rip), %rsi    # 0x64d601
movq %rax, %rdi
callq 0x434f95
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./ipl.hpp
// Function: PowerLawInteraction::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 == "strength")
        {
            if (! (value >= 0.))
                rt_error ("Invalid strength for power law");
            gamma = value;
        }
        else if (name == "exponent")
        {
            exponent = value;
        }
        else if (name == "sr_lr_split")
        {
            if (! (value > 0.))
                rt_error ("Invalid sr_lr_split for power law");
            sr_lr_split = value;
        }
        else
        {
            rt_error ("Invalid parameter: " + name);
        }

        // for compatibility with conventional normalization
        if (exponent == 0)
            stren = gamma;
        else
            stren = gamma * fabs (exponent);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1b3dc6(%rip), %rsi    # 0x5bf24e
movq %r14, %rdi
callq 0x406081
testb %al, %al
je 0x40b4cb
xorpd %xmm0, %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq %rbx, %rax
movapd %xmm1, %xmm0
jae 0x40b515
leaq 0x1b3da5(%rip), %rsi    # 0x5bf257
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x406046
leaq 0x18(%rsp), %rdi
callq 0x434d5b
leaq 0x1b3d5d(%rip), %rsi    # 0x5bf22f
movq %r14, %rdi
callq 0x406081
testb %al, %al
je 0x40b4ea
leaq 0x10(%rbx), %rax
movsd 0x10(%rsp), %xmm0
jmp 0x40b515
leaq 0x1b2d07(%rip), %rsi    # 0x5be1f8
movq %r14, %rdi
callq 0x406081
testb %al, %al
je 0x40b558
xorpd %xmm0, %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x40b577
movapd %xmm1, %xmm0
leaq 0x18(%rbx), %rax
movsd %xmm0, (%rax)
movsd (%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
movapd 0x1b3b46(%rip), %xmm2   # 0x5bf070
andpd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorpd %xmm3, %xmm3
cmpeqsd %xmm1, %xmm3
movapd %xmm3, %xmm1
andnpd %xmm2, %xmm1
andpd %xmm0, %xmm3
orpd %xmm1, %xmm3
movlpd %xmm3, 0x8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x1b3d39(%rip), %rsi    # 0x5bf298
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4061da
movq %rbx, %rdi
callq 0x434d5b
leaq 0x1b3cf8(%rip), %rsi    # 0x5bf276
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x406046
leaq 0x18(%rsp), %rdi
callq 0x434d5b
jmp 0x40b59d
jmp 0x40b5ac
jmp 0x40b59d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4b4bf0
jmp 0x40b5af
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4eb220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
movsd 0x1b36ed(%rip), %xmm0   # 0x5bf040
movapd 0x1b36f5(%rip), %xmm1   # 0x5bf050
cmpq $0x2, %rax
je 0x40b98d
movsd (%rdi,%rax,8), %xmm2
movsd (%rsi,%rax,8), %xmm3
unpcklps %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
subpd %xmm1, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
divsd %xmm4, %xmm2
movsd %xmm2, -0x10(%rsp,%rax,8)
incq %rax
jmp 0x40b95b
movsd -0x10(%rsp), %xmm0
movsd -0x8(%rsp), %xmm1
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
movsd 0x1b35eb(%rip), %xmm0   # 0x5bf040
movapd 0x1b35f3(%rip), %xmm1   # 0x5bf050
cmpq $0x2, %rax
je 0x40ba8b
movsd (%rdi,%rax,8), %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
subpd %xmm1, %xmm2
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
mulsd (%rsi,%rax,8), %xmm3
movsd %xmm3, -0x10(%rsp,%rax,8)
incq %rax
jmp 0x40ba5d
movsd -0x10(%rsp), %xmm0
movsd -0x8(%rsp), %xmm1
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
cmpq $0x2, %rax
je 0x40bab5
movsd (%rdi,%rax,8), %xmm0
addsd (%rsi,%rax,8), %xmm0
movsd %xmm0, -0x10(%rsp,%rax,8)
incq %rax
jmp 0x40ba9a
movsd -0x10(%rsp), %xmm0
movsd -0x8(%rsp), %xmm1
retq
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./ecmc.hpp
// Function: ChainRunner<Jellium3, Monodisperse2D>::time_for_collisions(Storage<Monodisperse2D>*, double, int)
uint64_t time_for_collisions (stor_t *stor, double sr_lr_split, int num_samples)
    {
        set_parameter ("sr_lr_split", sr_lr_split);
        inter.notify_random_context (&random);
        inter.notify_error_bound (stor, stor->cell_diagonal ());

        uint64_t start_time = gclock ();

        direction = 0;
        disp_left = stor->periods ()[0];

        for (int n = 0; n != num_samples; ++n)
        {
            planned_next = active = stor->random_particle (&random);
            planned_disp = disp_left;
            planned_xdisp = 0.;

            find_sr_events (stor);
            find_lr_events (stor);
        }

        uint64_t end_time = gclock ();
        std::cerr << "info optimizing sr_lr_split " << sr_lr_split << " " << (end_time-start_time) << " usec\n";
        return end_time - start_time;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movsd %xmm0, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1b2693(%rip), %rsi    # 0x5be1f8
leaq 0x18(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0x406046
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
movsd 0x10(%rsp), %xmm0
callq *0x18(%rax)
leaq 0x18(%rsp), %rdi
callq 0x4b4bf0
leaq 0x30(%r15), %r12
leaq 0x1870(%r15), %r13
movq %r14, %rdi
callq 0x40be06
movq %r12, %rdi
movq %r14, %rsi
callq 0x40bcac
callq 0x434c6c
movq %rax, %r12
andl $0x0, 0x2448(%r15)
movq (%r14), %rax
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movsd (%rbp), %xmm0
movsd %xmm0, 0x2450(%r15)
subl $0x1, %ebx
jb 0x40bc30
movq %r14, %rdi
movq %r13, %rsi
callq 0x40be5c
movq %rax, 0x2440(%r15)
movq %rax, 0x2458(%r15)
movsd 0x2450(%r15), %xmm0
movsd %xmm0, 0x2460(%r15)
andq $0x0, 0x2468(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x40beb8
movq %r15, %rdi
movq %r14, %rsi
callq 0x40c1d6
jmp 0x40bbe0
callq 0x434c6c
movq %rax, %rbx
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1b38d6(%rip), %rsi    # 0x5bf51c
callq 0x4a4910
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x4a5640
leaq 0x1b9c4d(%rip), %rsi    # 0x5c58ad
movq %rax, %rdi
callq 0x4a4910
subq %r12, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4a4ce0
leaq 0x1b38bc(%rip), %rsi    # 0x5bf539
movq %rax, %rdi
callq 0x4a4910
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4b4bf0
movq %rbx, %rdi
callq 0x4eb220
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/jellium3.cpp
// Function: Jellium3::notify_error_bound(AbstractStorage const*, double)
void notify_error_bound (const AbstractStorage *stor,
        double err_bound)
    {
        const unsigned DIM = stor->dimension ();

        if (error_bound != err_bound || period != stor->periods ())
        {
            error_bound = err_bound;
            period = stor->periods ();

            if (DIM >= exponent + 3)
                std::cerr << "jellium3: exponent " << exponent
                    << " too small for dimension " << DIM << ABORT;

            switch (DIM)
            {
            case 2:
                for (unsigned n = 0; n != DIM; ++n)
                    calibrate <2> (n);
                return;
            case 3:
                for (unsigned n = 0; n != DIM; ++n)
                    calibrate <3> (n);
                return;
            default:
                std::cerr << "jellium3: DIM = " << DIM
                    << " not implemented" << ABORT;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
movl %eax, %ebp
movsd 0x38(%rbx), %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
jne 0x40bce0
jnp 0x40bce6
movapd %xmm1, %xmm0
jmp 0x40bd0f
leaq 0x20(%rbx), %r15
movq (%r14), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x40c4f3
movsd (%rsp), %xmm0
testb %al, %al
je 0x40bd83
movsd %xmm0, 0x38(%rbx)
movq (%r14), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
movq 0x10(%r15), %rax
movq %rax, 0x30(%rbx)
movups (%r15), %xmm0
movups %xmm0, 0x20(%rbx)
movl %ebp, %eax
cvtsi2sd %rax, %xmm0
movsd 0x10(%rbx), %xmm1
addsd 0x1b33ff(%rip), %xmm1   # 0x5bf148
ucomisd %xmm1, %xmm0
jae 0x40bd90
cmpl $0x2, %ebp
je 0x40bd6e
cmpl $0x3, %ebp
jne 0x40bdcb
xorl %ebp, %ebp
cmpl $0x3, %ebp
je 0x40bd83
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40c7d2
incl %ebp
jmp 0x40bd5b
xorl %ebp, %ebp
cmpl $0x2, %ebp
je 0x40bd83
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40c4fe
incl %ebp
jmp 0x40bd70
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1b37a2(%rip), %rsi    # 0x5bf540
callq 0x4a4910
movsd 0x10(%rbx), %xmm0
movq %rax, %rdi
callq 0x4a5880
leaq 0x1b379d(%rip), %rsi    # 0x5bf554
movq %rax, %rdi
callq 0x4a4910
movq %rax, %rdi
movl %ebp, %esi
callq 0x4a4f40
jmp 0x40bdf7
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1b3795(%rip), %rsi    # 0x5bf56e
callq 0x4a4910
movq %rax, %rdi
movl %ebp, %esi
callq 0x4a4f40
leaq 0x1dc780(%rip), %rsi    # 0x5e856f
movq %rax, %rdi
callq 0x4a4910
leaq 0x241803(%rip), %rsi    # 0x64d601
movq %rax, %rdi
callq 0x434f95
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
xorpd %xmm1, %xmm1
cmpl $0x2, %ebp
je 0x40be37
movq %rbx, %rdi
movl %ebp, %esi
movsd %xmm1, (%rsp)
callq 0x40e316
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incl %ebp
jmp 0x40be12
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x40be4c
sqrtsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4e1e90
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x30(%rdi)
je 0x40be98
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x88(%rdi), %r15
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x43564a
movl %eax, %eax
movq %rax, %rcx
shlq $0x4, %rcx
testb $0x1, 0x8(%r15,%rcx)
je 0x40be75
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1b3a7e(%rip), %rdi    # 0x5bf91d
leaq 0x1b3469(%rip), %rsi    # 0x5bf30f
leaq 0x1b3a79(%rip), %rcx    # 0x5bf926
movl $0x221, %edx            # imm = 0x221
callq 0x4ffe80
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movsd (%rsi), %xmm0
xorl %eax, %eax
cmpq $0x2, %rax
je 0x40d5a6
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x10(%rsp,%rax,8)
incq %rax
jmp 0x40d58c
movsd -0x10(%rsp), %xmm0
movsd -0x8(%rsp), %xmm1
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./adap_prober.hpp
// Function: AdaptiveProber::calib_add(double, double, double)
void calib_add (double r, double rate, double rtol = 0.)
    {
        if (rate == 0.) return;

        if (! (r >= 0.))
            std::cerr << "calib_add: negative distance" << ABORT;

        if (!std::isfinite (rate))
            std::cerr << "calib_add: nonfinite lifting rate" << ABORT;

        // range of bins affected (including imax)
        unsigned i =    bin_from_radius (r-rtol);
        unsigned imax = bin_from_radius (r+rtol);
        assert (imax < N_);

        // zero bin (const probe rate)
        if (i == 0)
        {
            binrate_[i] = fmax (binrate_[i], rate);
            ++i;
        }

        // outer bins (correct for appropriate exponent)
        for (; i <= imax; ++i)
        {
            double ir = fmin (binrad_[i], r+rtol); // FIXME??
            double irate = rate / pow (ir, -(1.+binexp_[i]));
            binrate_[i] = fmax (binrate_[i], irate);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movapd %xmm2, %xmm3
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
movsd %xmm1, 0x8(%rsp)
ucomisd %xmm0, %xmm1
jne 0x40d5e3
jp 0x40d5e3
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
ucomisd %xmm0, %xmm2
jb 0x40d6eb
movq 0x8(%rsp), %xmm0
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x40d6fb
movq %rdi, %rbx
movsd %xmm2, (%rsp)
subsd %xmm3, %xmm2
movapd %xmm2, %xmm0
movsd %xmm3, 0x10(%rsp)
callq 0x40d4b6
movl %eax, %r14d
movsd (%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x40d4b6
cmpl $0x40, %eax
jae 0x40d71d
movl %eax, %ebp
testl %r14d, %r14d
jne 0x40d671
movsd 0x600(%rbx), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x4e1c90
movsd %xmm0, 0x600(%rbx)
cmpl $0x1, %r14d
adcl $0x0, %r14d
movl %ebp, %r15d
cmpq %r15, %r14
ja 0x40d5d8
movsd 0x200(%rbx,%r14,8), %xmm0
movsd 0x400(%rbx,%r14,8), %xmm1
movaps %xmm1, 0x10(%rsp)
movsd (%rsp), %xmm1
callq 0x4e1ce0
movapd 0x10(%rsp), %xmm1
addsd 0x1b0962(%rip), %xmm1   # 0x5be018
xorpd 0x1b19a2(%rip), %xmm1   # 0x5bf060
callq 0x4e1d70
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x600(%rbx,%r14,8), %xmm0
callq 0x4e1c90
movsd %xmm0, 0x600(%rbx,%r14,8)
incq %r14
jmp 0x40d67c
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1b1fb8(%rip), %rsi    # 0x5bf6b1
jmp 0x40d709
movq $0x64eaa0, %rdi         # imm = 0x64EAA0
leaq 0x1b1fc5(%rip), %rsi    # 0x5bf6ce
callq 0x4a4910
leaq 0x23feec(%rip), %rsi    # 0x64d601
movq %rax, %rdi
callq 0x434f95
leaq 0x1b1fcc(%rip), %rdi    # 0x5bf6f0
leaq 0x1b1ed0(%rip), %rsi    # 0x5bf5fb
leaq 0x1b1fc8(%rip), %rcx    # 0x5bf6fa
pushq $0x45
popq %rdx
callq 0x4ffe80
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpl $0x2, %edi
je 0x40d9e5
cmpl $0x3, %edi
jne 0x40d9ee
movsd 0x1b17ec(%rip), %xmm0   # 0x5bf1d0
retq
movsd 0x1b17eb(%rip), %xmm0   # 0x5bf1d8
retq
pushq %rax
callq 0x40385d
// File: /workspace/github_cpp_makefile_star2_O2/Cell-veto[P]postlhc/./tools.hpp
// Function: std::array<double, 3ul> zero_vector<3ul>()
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:
movq %rdi, %rax
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x40dc4e
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x40dc3e
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movaps %xmm2, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x40be06
movsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x40e38a
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jae 0x40e4e5
movapd 0x1b0be8(%rip), %xmm0   # 0x5bf070
andpd 0x30(%rsp), %xmm0
movapd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movl %ebp, %esi
callq 0x40e3b8
movapd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x40e505
shlq $0x4, %r15
leaq (%r14,%r15), %rdx
addq $0x88, %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movsd 0x8(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movaps 0x30(%rsp), %xmm2
callq 0x40e6c4
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b1574(%rip), %rsi    # 0x5bfa60
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x406046
leaq 0x48(%rsp), %rdi
callq 0x434d5b
leaq 0x1b157e(%rip), %rsi    # 0x5bfa8a
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x406046
leaq 0x48(%rsp), %rdi
callq 0x434d5b
jmp 0x40e529
jmp 0x40e538
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4b4bf0
jmp 0x40e53b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4eb220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
shlq $0x4, %rsi
leaq (%rdi,%rsi), %rax
addq $0x88, %rax
shlq $0x4, %rdx
leaq (%rdi,%rdx), %rcx
addq $0x88, %rcx
xorl %edx, %edx
cmpq $0x10, %rdx
je 0x40e59a
movq (%rax,%rdx), %rsi
subq (%rcx,%rdx), %rsi
cvtsi2sd %rsi, %xmm0
mulsd 0x78(%rdi,%rdx), %xmm0
movsd %xmm0, -0x10(%rsp,%rdx)
addq $0x8, %rdx
jmp 0x40e575
movsd -0x10(%rsp), %xmm0
movsd -0x8(%rsp), %xmm1
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x1, %rsi
ja 0x40e5d2
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x2, %rax
je 0x40e5d1
cmpq %rax, %rsi
je 0x40e5cc
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x40e5b4
retq
pushq %rax
leaq 0x1b1812(%rip), %rdi    # 0x5bfdec
leaq 0x1b1816(%rip), %rsi    # 0x5bfdf7
leaq 0x1b181a(%rip), %rcx    # 0x5bfe02
movl $0x16a, %edx            # imm = 0x16A
callq 0x4ffe80