LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/apps/msh2df/msh2df.cpp
// Function: ExtractIsosurface(gaps::R3Grid*)
static R3Mesh *
ExtractIsosurface(R3Grid *grid)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate isosurface mesh
  R3Mesh *isosurface_mesh = new R3Mesh();
  if (!isosurface_mesh) {
    RNFail("Unable to allocate isosurface mesh\n");
    return NULL;
  }

  // Extract isosurface
  // One grid_spacing outside, to account for razor-thin surfaces
  RNLength grid_spacing = grid->GridToWorldScaleFactor();
  grid->GenerateIsoSurface(grid_spacing, isosurface_mesh);

  // Print statistics
  if (print_verbose) {
    printf("Extracted isosurface ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", isosurface_mesh->NFaces());
    printf("  # Edges = %d\n", isosurface_mesh->NEdges());
    printf("  # Vertices = %d\n", isosurface_mesh->NVertices());
    printf("  Manifold = %s\n", (IsManifold(isosurface_mesh)) ? "yes" : "no");
    fflush(stdout);
  }

  // Return isosurface mesh
  return isosurface_mesh;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xddf30
movq 0x8(%rsp), %rdi
callq 0x17860
movl $0x138, %edi            # imm = 0x138
callq 0xf4c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x36610
jmp 0x15ece
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x15f1e
leaq 0x12a66d(%rip), %rdi    # 0x140554
movb $0x0, %al
callq 0xe2150
movq $0x0, 0x50(%rsp)
jmp 0x1600c
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x138, %esi            # imm = 0x138
callq 0xf4d0
jmp 0x16016
movq 0x48(%rsp), %rdi
callq 0x17b20
movsd %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
movq 0x30(%rsp), %rsi
callq 0x8da00
cmpl $0x0, 0x1706ae(%rip)    # 0x1865f8
je 0x16002
leaq 0x12a621(%rip), %rdi    # 0x140578
movb $0x0, %al
callq 0xf070
leaq 0x38(%rsp), %rdi
callq 0xddff0
leaq 0x12a2b4(%rip), %rdi    # 0x140223
movb $0x1, %al
callq 0xf070
movq 0x30(%rsp), %rdi
callq 0x17880
movl %eax, %esi
leaq 0x12a2b1(%rip), %rdi    # 0x14023a
movb $0x0, %al
callq 0xf070
movq 0x30(%rsp), %rdi
callq 0x178a0
movl %eax, %esi
leaq 0x12a2a7(%rip), %rdi    # 0x14024a
movb $0x0, %al
callq 0xf070
movq 0x30(%rsp), %rdi
callq 0x178c0
movl %eax, %esi
leaq 0x12a29d(%rip), %rdi    # 0x14025a
movb $0x0, %al
callq 0xf070
movq 0x30(%rsp), %rdi
callq 0x13450
movl %eax, %ecx
leaq 0x12a5d0(%rip), %rsi    # 0x1405a7
leaq 0x12a5c5(%rip), %rax    # 0x1405a3
cmpl $0x0, %ecx
cmovneq %rax, %rsi
leaq 0x12a5a6(%rip), %rdi    # 0x140592
movb $0x0, %al
callq 0xf070
movq 0x166f96(%rip), %rax    # 0x17cf90
movq (%rax), %rdi
callq 0xf5d0
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xf890
// File: tomfunkhouser[P]gaps/apps/msh2df/msh2df.cpp
// Function: WriteMesh(gaps::R3Mesh*, char const*)
static int
WriteMesh(R3Mesh *mesh, const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Write mesh
  if (!mesh->WriteFile(filename)) return 0;

  // Print statistics
  if (print_verbose) {
    printf("Wrote mesh to %s ...\n", filename);
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsp, %rdi
callq 0xddf30
movq %rsp, %rdi
callq 0x17860
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x1d0(%rax)
cmpl $0x0, %eax
jne 0x16063
movl $0x0, 0x24(%rsp)
jmp 0x160fe
cmpl $0x0, 0x17058e(%rip)    # 0x1865f8
je 0x160f6
movq 0x10(%rsp), %rsi
leaq 0x12a52e(%rip), %rdi    # 0x1405aa
movb $0x0, %al
callq 0xf070
movq %rsp, %rdi
callq 0xddff0
leaq 0x12a191(%rip), %rdi    # 0x140223
movb $0x1, %al
callq 0xf070
movq 0x18(%rsp), %rdi
callq 0x17880
movl %eax, %esi
leaq 0x12a18e(%rip), %rdi    # 0x14023a
movb $0x0, %al
callq 0xf070
movq 0x18(%rsp), %rdi
callq 0x178a0
movl %eax, %esi
leaq 0x12a184(%rip), %rdi    # 0x14024a
movb $0x0, %al
callq 0xf070
movq 0x18(%rsp), %rdi
callq 0x178c0
movl %eax, %esi
leaq 0x12a17a(%rip), %rdi    # 0x14025a
movb $0x0, %al
callq 0xf070
movq 0x166ea2(%rip), %rax    # 0x17cf90
movq (%rax), %rdi
callq 0xf5d0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2df/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3Kdtree<Point*>::FindClosest(gaps::R3Point const&, double, double, int, gaps::RNArray<Point*>&, double*) const
int R3Kdtree<PtrType>::
FindClosest(const R3Point& query_position, RNScalar min_distance, RNScalar max_distance, int max_points, 
  RNArray<PtrType>& points, RNLength *distances) const
{
  // Check root
  if (!root) return 0;

  // Use squared distances for efficiency
  if (max_distance < 0) return 0;
  if (min_distance < 0) min_distance = 0;
  RNLength min_distance_squared = min_distance * min_distance;
  RNLength max_distance_squared = max_distance * max_distance;

  // Allocate temporary array of squared distances to max_points closest points
  RNLength *distances_squared = new RNLength [ max_points ];

  // Search nodes recursively
  FindClosest(root, bbox, 
    NULL, query_position, 
    min_distance_squared, max_distance_squared, max_points, 
    NULL, NULL, 
    points, distances_squared);

  // Update return distances
  if (distances) {
    for (int i = 0; i < points.NEntries(); i++) {
      distances[i] = sqrt(distances_squared[i]);
    }
  }

  // Delete temporary array of squared distances
  delete [] distances_squared;

  // Return number of points
  return points.NEntries();
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movsd %xmm0, 0x78(%rsp)
movsd %xmm1, 0x70(%rsp)
movl %edx, 0x6c(%rsp)
movq %rcx, 0x60(%rsp)
movq %r8, 0x58(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x50(%rax)
jne 0x188d5
movl $0x0, 0x94(%rsp)
jmp 0x18a2d
xorps %xmm0, %xmm0
ucomisd 0x70(%rsp), %xmm0
jbe 0x188f0
movl $0x0, 0x94(%rsp)
jmp 0x18a2d
xorps %xmm0, %xmm0
ucomisd 0x78(%rsp), %xmm0
jbe 0x18904
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rsp)
movsd 0x78(%rsp), %xmm0
mulsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x70(%rsp), %xmm0
mulsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movslq 0x6c(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xf030
movq 0x30(%rsp), %rdx
movq %rax, 0x40(%rsp)
movq 0x50(%rdx), %rsi
movq 0x80(%rsp), %r8
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movl 0x6c(%rsp), %r9d
movq 0x60(%rsp), %r10
movq 0x40(%rsp), %rax
xorl %ecx, %ecx
movq %rdx, %rdi
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x19510
cmpq $0x0, 0x58(%rsp)
je 0x18a02
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x60(%rsp), %rdi
callq 0x178e0
movl %eax, %ecx
movl 0x2c(%rsp), %eax
cmpl %ecx, %eax
jge 0x18a00
movq 0x40(%rsp), %rax
movslq 0x3c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0xf390
movq 0x58(%rsp), %rax
movslq 0x3c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x189b4
jmp 0x18a02
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x18a1c
movq 0x20(%rsp), %rdi
callq 0xf670
movq 0x60(%rsp), %rdi
callq 0x178e0
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/msh2df/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3Kdtree<Point*>::~R3Kdtree()
R3Kdtree<PtrType>::
~R3Kdtree(void)
{
  // Check root
  if (!root) return;

  // Traverse tree deleting nodes
  RNArray<R3KdtreeNode<PtrType> *> stack;
  stack.InsertTail(root);
  while (!stack.IsEmpty()) {
    R3KdtreeNode<PtrType> *node = stack.Tail();
    stack.RemoveTail();
    if (node->children[0]) stack.Insert(node->children[0]);
    if (node->children[1]) stack.Insert(node->children[1]);
    delete node;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x50(%rax)
jne 0x18a67
movl $0x1, 0x3c(%rsp)
jmp 0x18b50
leaq 0x28(%rsp), %rdi
callq 0x1a1d0
jmp 0x18a73
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1a1f0
jmp 0x18a88
jmp 0x18a8a
leaq 0x28(%rsp), %rdi
callq 0x177d0
movl %eax, 0x14(%rsp)
jmp 0x18a9a
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x18aaf
jmp 0x18b3e
leaq 0x28(%rsp), %rdi
callq 0x1a220
movq %rax, 0x8(%rsp)
jmp 0x18ac0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x18290
jmp 0x18ad6
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x18af9
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1a230
jmp 0x18af7
jmp 0x18af9
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x18b1c
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1a230
jmp 0x18b1a
jmp 0x18b1c
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x18b39
movq (%rsp), %rdi
movl $0x130, %esi            # imm = 0x130
callq 0xf4d0
jmp 0x18a8a
leaq 0x28(%rsp), %rdi
callq 0x1a260
movl $0x0, 0x3c(%rsp)
movq 0x18(%rsp), %rdi
callq 0x17670
addq $0x48, %rsp
retq
movq %rax, %rdi
callq 0x1a1e0
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2df/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3KdtreeNode<Point*>::R3KdtreeNode(gaps::R3KdtreeNode<Point*>*)
R3KdtreeNode<PtrType>::
R3KdtreeNode(R3KdtreeNode<PtrType> *parent)
  : parent(parent),
    npoints(0)
{
  // Initialize everything
  children[0] = NULL;
  children[1] = NULL;
  split_coordinate = 0;
  split_dimension = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x128(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movl $0x0, 0x20(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2df/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3Kdtree<Point*>::FindClosest(gaps::R3Point const&, double, double, double*) const
PtrType R3Kdtree<PtrType>::
FindClosest(const R3Point& query_position, 
  RNScalar min_distance, RNScalar max_distance, 
  RNScalar *closest_distance) const
{
  // Check root
  if (!root) return NULL;

  // Use squared distances for efficiency
  if (max_distance < 0) return NULL;
  if (min_distance < 0) min_distance = 0;
  RNLength min_distance_squared = min_distance * min_distance;
  RNLength max_distance_squared = max_distance * max_distance;

  // Initialize nearest point 
  PtrType nearest_point = NULL;
  RNLength nearest_distance_squared = max_distance_squared;

  // Search nodes recursively
  FindClosest(root, bbox, 
    NULL, query_position, 
    min_distance_squared, max_distance_squared, 
    NULL, NULL, 
    nearest_point, nearest_distance_squared);

  // Return closest distance
  if (closest_distance) *closest_distance = sqrt(nearest_distance_squared);

  // Return closest point
  return nearest_point;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movsd %xmm1, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x50(%rax)
jne 0x1a39e
movq $0x0, 0x70(%rsp)
jmp 0x1a470
xorps %xmm0, %xmm0
ucomisd 0x50(%rsp), %xmm0
jbe 0x1a3b7
movq $0x0, 0x70(%rsp)
jmp 0x1a470
xorps %xmm0, %xmm0
ucomisd 0x58(%rsp), %xmm0
jbe 0x1a3cb
xorps %xmm0, %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0x20(%rsp), %rdx
movsd 0x58(%rsp), %xmm0
mulsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x50(%rsp), %xmm0
mulsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x50(%rdx), %rsi
movq 0x60(%rsp), %r8
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
xorl %eax, %eax
movl %eax, %r9d
leaq 0x30(%rsp), %r10
leaq 0x28(%rsp), %rax
movq %rdx, %rdi
movq %r9, %rcx
movq $0x0, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x1a510
cmpq $0x0, 0x48(%rsp)
je 0x1a466
movsd 0x28(%rsp), %xmm0
callq 0xf390
movq 0x48(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshSearchTree.cpp
// Function: gaps::R3MeshSearchTree::R3MeshSearchTree(gaps::R3Mesh*)
R3MeshSearchTree::
R3MeshSearchTree(R3Mesh *mesh)
  : mesh(mesh),
    nnodes(1),
    mark(1)
{
  // Create root 
  root = new R3MeshSearchTreeNode(NULL);
  assert(root);

  // Insert faces into tree
  for (int i = 0; i < mesh->NFaces(); i++) {
    R3MeshFace *face = mesh->Face(i);
    InsertFace(face);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movl $0x1, 0x10(%rax)
movl $0x1, 0x14(%rax)
movl $0x48, %edi
callq 0xf4c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x21680
jmp 0x1b16e
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
callq 0x17880
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x1b1ee
movq 0x38(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x17a10
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x1b200
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x1b184
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x48, %esi
callq 0xf4d0
jmp 0x1b1f3
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xf890
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshSearchTree.cpp
// Function: gaps::R3MeshSearchTree::InsertFace(gaps::R3MeshFace*)
void R3MeshSearchTree::
InsertFace(R3MeshFace *face)
{
  // Check if face intersects box
  if (!R3Intersects(mesh, face, BBox())) return;

  // Create container
  R3MeshSearchTreeFace *face_container = new R3MeshSearchTreeFace(mesh, face);
  assert(face_container);

  // Insert face into root
  InsertFace(face_container, root, BBox(), 0);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq (%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x21710
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rax, %rdx
callq 0x1b330
cmpl $0x0, %eax
jne 0x1b248
jmp 0x1b2b0
movl $0x18, %edi
callq 0xf4c0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rsi
movq 0x48(%rsp), %rdx
callq 0x21730
jmp 0x1b271
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
callq 0x21710
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
xorl %r8d, %r8d
callq 0x1ba70
addq $0x58, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x18, %esi
callq 0xf4d0
movq 0x38(%rsp), %rdi
callq 0xf890
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshSearchTree.cpp
// Function: gaps::R3MeshSearchTree::DistanceSquared(gaps::R3Point const&, gaps::R3Point const&) const
RNScalar R3MeshSearchTree::
DistanceSquared(const R3Point& query_position, const R3Point& point) const
{
  // Compute squared distance from query to point
  RNScalar dx = query_position[0] - point[0];
  RNScalar dy = query_position[1] - point[1];
  RNScalar dz = query_position[2] - point[2];
  return dx*dx + dy*dy + dz*dz;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x17e60
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x17e60
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x17e60
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
callq 0x17e60
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x17e60
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x17e60
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
movsd 0x20(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshSearchTree.cpp
// Function: gaps::R3MeshSearchTree::FindAll(gaps::R3Point const&, gaps::R3Vector const&, gaps::RNArray<gaps::R3MeshIntersection*>&, double, double, int (*)(gaps::R3Point const&, gaps::R3Vector const&, gaps::R3Mesh*, gaps::R3MeshFace*, void*), void*)
void R3MeshSearchTree::
FindAll(const R3Point& query_position, const R3Vector& query_normal, RNArray<R3MeshIntersection *>& hits, 
  RNScalar min_distance, RNScalar max_distance, 
  int (*IsCompatible)(const R3Point&, const R3Vector&, R3Mesh *, R3MeshFace *, void *), void *compatible_data)
{
  // Check root
  if (!root) return;

  // Update mark (used to avoid checking same face twice)
  mark++;

  // Use squared distances for efficiency
  RNScalar min_distance_squared = min_distance * min_distance;
  RNScalar max_distance_squared = max_distance * max_distance;

  // Search nodes recursively
  FindAll(query_position, query_normal, hits,
    min_distance_squared, max_distance_squared, 
    IsCompatible, compatible_data, 
    root, BBox());
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movsd %xmm0, 0x80(%rsp)
movsd %xmm1, 0x78(%rsp)
movq %r8, 0x70(%rsp)
movq %r9, 0x68(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x8(%rax)
jne 0x1ff69
jmp 0x2003f
movq 0x50(%rsp), %rdi
movl 0x14(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x14(%rdi)
movsd 0x80(%rsp), %xmm0
mulsd 0x80(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x78(%rsp), %xmm0
mulsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x48(%rsp)
callq 0x21710
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movq 0x38(%rsp), %r8
movq 0x40(%rsp), %r9
movq 0x48(%rsp), %r10
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1f7a0
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshSearchTree.cpp
// Function: gaps::R3MeshSearchTree::FindIntersection(gaps::R3Ray const&, gaps::R3MeshIntersection&, double, double, int (*)(gaps::R3Point const&, gaps::R3Vector const&, gaps::R3Mesh*, gaps::R3MeshFace*, void*), void*)
void R3MeshSearchTree::
FindIntersection(const R3Ray& ray, R3MeshIntersection& closest,
  RNScalar min_t, RNScalar max_t, 
  int (*IsCompatible)(const R3Point&, const R3Vector&, R3Mesh *, R3MeshFace *, void *), void *compatible_data)
{
  // Initialize result
  closest.type = R3_MESH_NULL_TYPE;
  closest.vertex = NULL;
  closest.edge = NULL;
  closest.face = NULL;
  closest.point = R3zero_point;
  closest.t = 0;

  // Check root
  if (!root) return;

  // Update mark (used to avoid checking same face twice)
  mark++;

  // Search nodes recursively
  FindIntersection(ray, closest,
    min_t, max_t,
    IsCompatible, compatible_data, 
    root, BBox());
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movsd %xmm1, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x70(%rsp), %rax
movl $0x0, (%rax)
movq 0x70(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x70(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x70(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x70(%rsp), %rdi
addq $0x20, %rdi
leaq 0x5665e2(%rip), %rsi    # 0x5877c0
callq 0x935a0
movq 0x48(%rsp), %rax
movq 0x70(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rcx)
cmpq $0x0, 0x8(%rax)
jne 0x21201
jmp 0x21288
movq 0x48(%rsp), %rdi
movl 0x14(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x14(%rdi)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x40(%rsp)
callq 0x21710
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movsd 0x28(%rsp), %xmm0
movq 0x30(%rsp), %r8
movq 0x38(%rsp), %r9
movq 0x40(%rsp), %r10
leaq 0x60(%rsp), %rcx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x20950
addq $0x88, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshSearchTree.cpp
// Function: gaps::R3MeshSearchTree::Outline(gaps::R3MeshSearchTreeNode*, gaps::R3Box const&) const
void R3MeshSearchTree::
Outline(R3MeshSearchTreeNode *node, const R3Box& node_box) const
{
  // Draw kdtree nodes recursively
  if (node->children[0]) {
    assert(node->children[1]);
    assert(node->split_coordinate >= node_box[RN_LO][node->split_dimension]);
    assert(node->split_coordinate <= node_box[RN_HI][node->split_dimension]);
    R3Box child0_box(node_box);
    R3Box child1_box(node_box);
    child0_box[RN_HI][node->split_dimension] = node->split_coordinate;
    child1_box[RN_LO][node->split_dimension] = node->split_coordinate;
    Outline(node->children[0], child0_box);
    Outline(node->children[1], child1_box);
  }
  else {
    node_box.Outline();
  }
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0xd8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2142d
movq 0xd0(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x67100
movq 0xd0(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x67100
jmp 0x212f8
movq 0xd8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x98(%rsp), %rdi
movl $0x1, %esi
callq 0x17820
movq %rax, 0x38(%rsp)
jmp 0x21324
movq 0x38(%rsp), %rdi
movq 0xd8(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x17800
movq %rax, 0x28(%rsp)
jmp 0x21340
movq 0x28(%rsp), %rax
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0xd8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x17820
movq %rax, 0x20(%rsp)
jmp 0x21375
movq 0x20(%rsp), %rdi
movq 0xd8(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x17800
movq %rax, 0x10(%rsp)
jmp 0x21391
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rax
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0xd8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x98(%rsp), %rdx
callq 0x21290
jmp 0x213c0
movq 0x40(%rsp), %rdi
movq 0xd8(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x60(%rsp), %rdx
callq 0x21290
jmp 0x213dd
leaq 0x60(%rsp), %rdi
callq 0x17670
leaq 0x98(%rsp), %rdi
callq 0x17670
jmp 0x2145c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x2141e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x17670
leaq 0x98(%rsp), %rdi
callq 0x17670
jmp 0x21464
movq 0xd0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0x18120
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq (%rdi), %rax
callq *0xb0(%rax)
addq $0xe8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0xf890
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshSearchTree.cpp
// Function: gaps::R3MeshSearchTree::Print(gaps::R3MeshSearchTreeNode*, int) const
int R3MeshSearchTree::
Print(R3MeshSearchTreeNode *node, int depth) const
{
  // Check node
  if (!node) return 0;

  // Initialize number of decendents
  int ndecendents0 = 0;
  int ndecendents1 = 0;

  // Process interior node
  if (node->children[0] && node->children[1]) {
    // Print balance of children
    ndecendents0 = Print(node->children[0], depth+1);
    ndecendents1 = Print(node->children[1], depth+1);

    // Print balance of this node
    printf("%d", depth);
    for (int i = 0; i <= depth; i++) printf("  ");
    printf("I %d : %d %d %g\n", node->big_faces.NEntries(), ndecendents0, ndecendents1, (double) ndecendents0 / (double) ndecendents1);
  }
  else {
    printf("%d", depth);
    for (int i = 0; i <= depth; i++) printf("  ");
    printf("L %d \n", node->small_faces.NEntries());
  }

  // Return number of nodes rooted in this subtree
  return 1 + ndecendents0 + ndecendents1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x214f0
movl $0x0, 0x34(%rsp)
jmp 0x2163d
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x215d1
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x215d1
movq (%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movl 0x1c(%rsp), %edx
addl $0x1, %edx
callq 0x214c0
movq (%rsp), %rdi
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x1c(%rsp), %edx
addl $0x1, %edx
callq 0x214c0
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %esi
leaq 0x124125(%rip), %rdi    # 0x14568a
movb $0x0, %al
callq 0xf070
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jg 0x21599
leaq 0x122466(%rip), %rdi    # 0x1439eb
movb $0x0, %al
callq 0xf070
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x21574
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
callq 0x178e0
movl %eax, %esi
movl 0x18(%rsp), %edx
movl 0x14(%rsp), %ecx
cvtsi2sdl 0x18(%rsp), %xmm0
cvtsi2sdl 0x14(%rsp), %xmm1
divsd %xmm1, %xmm0
leaq 0x11f000(%rip), %rdi    # 0x1405c8
movb $0x1, %al
callq 0xf070
jmp 0x2162e
movl 0x1c(%rsp), %esi
leaq 0x1240ae(%rip), %rdi    # 0x14568a
movb $0x0, %al
callq 0xf070
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jg 0x21610
leaq 0x1223ef(%rip), %rdi    # 0x1439eb
movb $0x0, %al
callq 0xf070
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x215eb
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
callq 0x178e0
movl %eax, %esi
leaq 0x11efb2(%rip), %rdi    # 0x1405d9
movb $0x0, %al
callq 0xf070
movl 0x18(%rsp), %eax
addl $0x1, %eax
addl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/./R3Mesh.h
// Function: gaps::R3Mesh::FaceOnVertex(gaps::R3MeshVertex const*) const
inline R3MeshFace *R3Mesh:: 
FaceOnVertex(const R3MeshVertex *v) const
{
  // Returns any face connected to vertex
  for (int i = 0; i < VertexValence(v); i++) {
    R3MeshEdge *e = EdgeOnVertex(v, i);
    R3MeshFace *f = FaceOnEdge(e);
    if (f) return f;
  }

  // No face found
  return NULL;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rsi
callq 0x21b80
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x21960
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0x21bb0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x219a0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x21951
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x21969
jmp 0x21953
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x218f0
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: skaringa[P]DistanceCalculation/Sample.cpp
// Function: compareDistanceCalculators(Point&, Point&, std::__cxx11::list<DistanceCalculator*, std::allocator<DistanceCalculator*>>&)
static void compareDistanceCalculators(Point & p1, Point & p2, list<DistanceCalculator*> & calcs) 
{
	cout << "Distance " << p1.name() << " - " << p2.name() << ": " << endl;

	list<DistanceCalculator*>::const_iterator ical;
	for (ical = calcs.begin(); ical != calcs.end(); ++ical) {
		DistanceCalculator::use(*ical);
		cout << setw(12) << (*ical)->name() << ": ";
		cout << setw(8) << setprecision(6) << fixed << p1.distance(p2) << " km" << endl;
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x4c62(%rip), %rdi      # 0x8fd0
leaq 0x1e5c(%rip), %rsi      # 0x61d1
callq 0x3200
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x31c0
movq %rax, %rdi
leaq 0x1e3d(%rip), %rsi      # 0x61db
callq 0x3200
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x31c0
movq %rax, %rdi
leaq 0x1e18(%rip), %rsi      # 0x61df
callq 0x3200
movq %rax, %rdi
movq 0x4bea(%rip), %rsi      # 0x8fc0
callq 0x3230
leaq -0x20(%rbp), %rdi
callq 0x4dc0
movq -0x18(%rbp), %rdi
callq 0x4de0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4e10
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4e60
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4e10
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4e30
testb $0x1, %al
jne 0x4436
jmp 0x4523
leaq -0x20(%rbp), %rdi
callq 0x4e90
movq (%rax), %rdi
callq 0x3550
movl $0xc, %edi
callq 0x4ec0
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %esi
movq 0x4b72(%rip), %rdi      # 0x8fd0
callq 0x3280
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4e90
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x3200
movq %rax, %rdi
leaq 0x1d50(%rip), %rsi      # 0x61df
callq 0x3200
movl $0x8, %edi
callq 0x4ec0
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %esi
movq 0x4b25(%rip), %rdi      # 0x8fd0
callq 0x3280
movq %rax, -0x70(%rbp)
movl $0x6, %edi
callq 0x4ee0
movq -0x70(%rbp), %rdi
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %esi
callq 0x3320
movq %rax, %rdi
leaq 0xa29(%rip), %rsi       # 0x4f00
callq 0x30a0
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x68(%rbp), %rdi
callq 0x3390
movq %rax, %rdi
leaq 0x1ce1(%rip), %rsi      # 0x61e2
callq 0x3200
movq %rax, %rdi
movq 0x4ab0(%rip), %rsi      # 0x8fc0
callq 0x3230
leaq -0x20(%rbp), %rdi
callq 0x4f30
jmp 0x4406
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: skaringa[P]DistanceCalculation/./SimpleDistanceCalculator.h
// Function: SimpleDistanceCalculator::distance(Point const&, Point const&) const
virtual double distance(const Point & from, const Point & to) const {
		double lat1 = (from.lat() + to.lat()) / 2 * DEG_TO_RAD;
		double dx = 111.3 * cos(lat1) * (from.lon() - to.lon());
		double dy = 111.3 * (from.lat() - to.lat());
		return sqrt(dx * dx + dy * dy);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd 0x1717(%rip), %xmm1     # 0x6108
divsd %xmm1, %xmm0
movsd 0x1703(%rip), %xmm1     # 0x6100
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x3380
movaps %xmm0, %xmm1
movsd 0x16d5(%rip), %xmm0     # 0x60f0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd -0x48(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd -0x38(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd 0x166f(%rip), %xmm0     # 0x60f0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x3170
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: skaringa[P]DistanceCalculation/./SphereDistanceCalculator.h
// Function: SphereDistanceCalculator::distance(Point const&, Point const&) const
virtual double distance(const Point & from, const Point & to) const {
		double lat1 = from.lat() * DEG_TO_RAD;
		double lon1 = from.lon() * DEG_TO_RAD;
		double lat2 = to.lat() * DEG_TO_RAD;
		double lon2 = to.lon() * DEG_TO_RAD;
		return 6378.388 * acos(sin(lat1) * sin(lat2) 
			+ cos(lat1) * cos(lat2) * cos(lon2 - lon1));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd 0x15fa(%rip), %xmm1     # 0x6100
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x15df(%rip), %xmm1     # 0x6100
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd 0x15c4(%rip), %xmm1     # 0x6100
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x15a9(%rip), %xmm1     # 0x6100
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x3060
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x3060
movsd %xmm0, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x3380
movsd %xmm0, -0x58(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x3380
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
callq 0x3380
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x40(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x31e0
movaps %xmm0, %xmm1
movsd 0x152b(%rip), %xmm0     # 0x6110
mulsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: skaringa[P]DistanceCalculation/./SphereDistanceHaversineCalculator.h
// Function: SphereDistanceHaversineCalculator::distance(Point const&, Point const&) const
virtual double distance(const Point & from, const Point & to) const {

		double lat1 = from.lat() * DEG_TO_RAD;
		double lon1 = from.lon() * DEG_TO_RAD;
		double lat2 = to.lat() * DEG_TO_RAD;
		double lon2 = to.lon() * DEG_TO_RAD;
        double dLat = lat2-lat1;
        double dLon = lon2-lon1;
        double a = pow(sin(dLat/2.0), 2) +
            pow(sin(dLon/2.0), 2) * cos(lat1) * cos(lat2); 
        double c = 2.0 * atan2(sqrt(a),sqrt(1.0-a));
        
		return 6378.388 * c;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd 0x14c7(%rip), %xmm1     # 0x6100
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x14ac(%rip), %xmm1     # 0x6100
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movsd 0x1491(%rip), %xmm1     # 0x6100
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x1476(%rip), %xmm1     # 0x6100
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
movsd 0x144a(%rip), %xmm1     # 0x6108
divsd %xmm1, %xmm0
callq 0x3060
movsd 0x1439(%rip), %xmm1     # 0x6108
callq 0x3340
movsd %xmm0, -0x70(%rbp)
movsd -0x48(%rbp), %xmm0
movsd 0x1422(%rip), %xmm1     # 0x6108
divsd %xmm1, %xmm0
callq 0x3060
movsd 0x1411(%rip), %xmm1     # 0x6108
callq 0x3340
movsd %xmm0, -0x78(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x3380
movaps %xmm0, %xmm1
movsd -0x78(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x3380
movsd -0x70(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x68(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
callq 0x3170
movsd %xmm0, -0x60(%rbp)
movsd 0x13c1(%rip), %xmm0     # 0x6118
subsd -0x50(%rbp), %xmm0
callq 0x3170
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
callq 0x3040
movaps %xmm0, %xmm1
movsd 0x138f(%rip), %xmm0     # 0x6108
mulsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x1386(%rip), %xmm0     # 0x6110
mulsd -0x58(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: chahk0129[P]hash_bench/./bench/benchmark.h
// Function: benchmark_t<char [32]>::benchmark_t(bool)
benchmark_t(bool enable_pcm){
	    if(enable_pcm){
		pcm = PCM::getInstance();
		auto status = pcm->program();
		if(status != PCM::Success){
		    std::cout << "Error opening PCM: " << status << std::endl;
		    exit(0);
		}
	    }
	    else
		pcm = nullptr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1afa0
testb $0x1, -0x9(%rbp)
je 0x14cbd
callq 0x30290
movq %rax, -0x30(%rbp)
jmp 0x14c36
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rdi
xorl %esi, %esi
movl %esi, %edx
callq 0x34640
movl %eax, -0x34(%rbp)
jmp 0x14c54
movl -0x34(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x14cbb
movq 0x45351(%rip), %rdi     # 0x59fb8
leaq 0x2d57b(%rip), %rsi     # 0x421e9
callq 0x6400
movq %rax, -0x40(%rbp)
jmp 0x14c79
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x6740
movq %rax, -0x48(%rbp)
jmp 0x14c8b
movq -0x48(%rbp), %rdi
movq 0x4530a(%rip), %rsi     # 0x59fa0
callq 0x6460
jmp 0x14c9d
xorl %edi, %edi
callq 0x6500
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1afd0
jmp 0x14ccf
jmp 0x14cc9
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6780
nopl (%rax,%rax)
// File: chahk0129[P]hash_bench/./util/config.h
// Function: Hash<char [32]>* getInstance<char [32]>(int)
Hash<Key_t>* getInstance(const int index_type){
    const size_t initialTableSize = 1024*16;
    if(index_type == TYPE_EXTENDIBLE_HASH)
	return new ExtendibleHash<Key_t>(initialTableSize/Segment<Key_t>::kNumSlot);
    else if(index_type == TYPE_LINEAR_HASH)
	return new LinearProbingHash<Key_t>(initialTableSize);
    else if(index_type == TYPE_CUCKOO_HASH)
	return new CuckooHash<Key_t>(initialTableSize);
    else
	fprintf(stderr, "unkown index type %d\n", index_type);
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq $0x4000, -0x18(%rbp)    # imm = 0x4000
cmpl $0x0, -0xc(%rbp)
jne 0x1b318
movl $0x10, %edi
movq %rdi, -0x38(%rbp)
callq 0x6420
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x1b580
jmp 0x1b2ec
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b3da
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x6430
jmp 0x1b3e4
cmpl $0x1, -0xc(%rbp)
jne 0x1b367
movl $0x50, %edi
callq 0x6420
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl $0x4000, %esi           # imm = 0x4000
callq 0x1b6f0
jmp 0x1b33e
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b3da
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x50, %esi
callq 0x6430
jmp 0x1b3e4
cmpl $0x2, -0xc(%rbp)
jne 0x1b3b3
movl $0xe0, %edi
callq 0x6420
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movl $0x4000, %esi           # imm = 0x4000
callq 0x1b8d0
jmp 0x1b38d
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b3da
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0xe0, %esi
callq 0x6430
jmp 0x1b3e4
movq 0x3ec06(%rip), %rax     # 0x59fc0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x26f9f(%rip), %rsi     # 0x42366
movb $0x0, %al
callq 0x65c0
jmp 0x1b3d0
jmp 0x1b3d2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6780
nopl (%rax)
// File: chahk0129[P]hash_bench/./util/pair.h
// Function: void gen_input<char [32]>(Pair<char [32]>*, int)
void gen_input(Pair<Key_t>* arr, int num){
    if constexpr(sizeof(Key_t) > 8){
	char s[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
	for(int i=0; i<num; i++){
	    int j;
	    for(j=0; j<sizeof(Key_t)-1; j++)
		arr[i].key[j] = s[rand() % sizeof(s)-1];
	    arr[i].key[j] = 0;
	    arr[i].value = i+1;
	}
    }
    else{
	for(int i=0; i<num; i++){
	    arr[i].key = i+1;
	    arr[i].value = i+1;
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x270f6(%rip), %rsi     # 0x42500
movl $0x35, %edx
callq 0x6350
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1b4b3
movl $0x0, -0x58(%rbp)
movslq -0x58(%rbp), %rax
cmpq $0x1f, %rax
jae 0x1b472
callq 0x60c0
cltq
movl $0x35, %ecx
xorl %edx, %edx
divq %rcx
subq $0x1, %rdx
movb -0x50(%rbp,%rdx), %dl
movq -0x8(%rbp), %rax
movslq -0x54(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x58(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x1b42e
movq -0x8(%rbp), %rax
movslq -0x54(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x58(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movslq -0x54(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x1b41b
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: chahk0129[P]hash_bench/./index/linear_probing.h
// Function: LinearProbingHash<char [32]>::LinearProbingHash(unsigned long)
LinearProbingHash(size_t _capacity): capacity{_capacity}, dict{new Pair<Key_t>[capacity]} {
	locksize = 256;
	nlocks = capacity / locksize + 1;
	mutex = new shared_mutex[nlocks];
	invalid_initialize<Key_t>();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1bb40
movq -0x48(%rbp), %rax
leaq 0x3e265(%rip), %rcx     # 0x59980
addq $0x10, %rcx
movq %rcx, (%rax)
movss 0x2692a(%rip), %xmm0    # 0x42054
movss %xmm0, 0x8(%rax)
movss 0x26919(%rip), %xmm0    # 0x42050
movss %xmm0, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x40(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x28, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0x6030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1b7cb
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
imulq $0x28, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x14ce0
jmp 0x1b7b6
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
addq $0x28, %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x1b7a7
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rdx
movq %rdx, (%rax)
movq $0x0, 0x30(%rcx)
movl $0x0, 0x38(%rcx)
movl $0x100, 0x4c(%rcx)      # imm = 0x100
movq 0x10(%rcx), %rax
movslq 0x4c(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq $0x1, %rcx
movl %ecx, 0x48(%rax)
movslq 0x48(%rax), %rax
movq %rax, -0x70(%rbp)
movl $0x38, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6030
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x68(%rbp)
cmpq $0x0, %rax
je 0x1b887
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
imulq $0x38, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x80(%rbp)
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1cb90
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
addq $0x38, %rax
cmpq %rcx, %rax
movq %rax, -0x78(%rbp)
jne 0x1b85f
movq -0x48(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x40(%rax)
callq 0x1d430
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6830
movq -0x18(%rbp), %rdi
callq 0x6780
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chahk0129[P]hash_bench/./index/cuckoo_hash.h
// Function: CuckooHash<char [32]>::CuckooHash(unsigned long)
CuckooHash(size_t _capacity): capacity{_capacity}, table{new Pair<Key_t>[capacity]} {
        memset(&pushed, 0, sizeof(Pair<Key_t>)*2);
        locksize = 256;
        nlocks = capacity / locksize + 1;
        mutex = new std::shared_mutex[nlocks];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1bb40
movq -0x48(%rbp), %rax
leaq 0x3e0e5(%rip), %rcx     # 0x599e0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0xc70f6907, %ecx       # imm = 0xC70F6907
movq %rcx, 0x8(%rax)
movq $0x200, 0x10(%rax)      # imm = 0x200
movq $0x2, 0x18(%rax)
movss 0x26735(%rip), %xmm0    # 0x42058
movss %xmm0, 0x20(%rax)
movq $0x80, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq %rax, %rcx
addq $0x38, %rcx
movq %rcx, -0x40(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x28, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0x6030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1b9bf
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
imulq $0x28, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x14ce0
jmp 0x1b9aa
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
addq $0x28, %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x1b99b
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, (%rcx)
addq $0x40, %rax
movq %rax, %rcx
addq $0x50, %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x14ce0
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
addq $0x28, %rax
cmpq %rcx, %rax
movq %rax, -0x68(%rbp)
jne 0x1b9e1
movq -0x48(%rbp), %rdi
addq $0x90, %rdi
callq 0x14ce0
movq -0x48(%rbp), %rdi
movl $0x0, 0xc8(%rdi)
addq $0x40, %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x61f0
movq -0x48(%rbp), %rcx
movl $0x100, 0xdc(%rcx)      # imm = 0x100
movq 0x30(%rcx), %rax
movslq 0xdc(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq $0x1, %rcx
movl %ecx, 0xd8(%rax)
movslq 0xd8(%rax), %rax
movq %rax, -0x88(%rbp)
movl $0x38, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6030
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, -0x80(%rbp)
cmpq $0x0, %rax
je 0x1baf7
movq -0x80(%rbp), %rax
movq -0x88(%rbp), %rcx
imulq $0x38, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1cb90
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
addq $0x38, %rax
cmpq %rcx, %rax
movq %rax, -0x90(%rbp)
jne 0x1bac6
movq -0x48(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, 0xd0(%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6830
movq -0x18(%rbp), %rdi
callq 0x6780
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)