LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Dot(gaps::R3Grid const&) const
RNScalar R3Grid::
Dot(const R3Grid& grid) const
{
  // Resolutions and transforms must be the same (for now)
  assert(grid_resolution[0] == grid.grid_resolution[0]);
  assert(grid_resolution[1] == grid.grid_resolution[1]);
  assert(grid_resolution[2] == grid.grid_resolution[2]);

  // Compute dot product between this and grid
  RNScalar dot = 0.0;
  for (int i = 0; i < grid_size; i++) 
    dot += grid_values[i] * grid.grid_values[i];
  return dot;
}

// Assembly:
movslq 0x24c(%rdi), %rax
testq %rax, %rax
jle 0x358d5
movq 0x230(%rdi), %rcx
movq 0x230(%rsi), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x358be
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::L1Distance(gaps::R3Grid const&) const
RNScalar R3Grid::
L1Distance(const R3Grid& grid) const
{
  // Compute distance between this and grid
  RNScalar distance = 0.0;
  for (int i = 0; i < grid_size; i++) 
    distance += fabs(grid_values[i] - grid.grid_values[i]);
  return distance;
}

// Assembly:
movslq 0x24c(%rdi), %rax
testq %rax, %rax
jle 0x3591d
movq 0x230(%rdi), %rcx
movq 0x230(%rsi), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movapd 0x6c96e(%rip), %xmm1    # 0xa2270
movsd (%rcx,%rsi,8), %xmm2
subsd (%rdx,%rsi,8), %xmm2
andpd %xmm1, %xmm2
addsd %xmm2, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x35902
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::L2DistanceSquared(gaps::R3Grid const&) const
RNScalar R3Grid::
L2DistanceSquared(const R3Grid& grid) const
{
  // Compute distance between this and grid
  RNScalar distance_squared = 0.0;
  for (int i = 0; i < grid_size; i++) {
    RNScalar delta = (grid_values[i] - grid.grid_values[i]);
    distance_squared += delta * delta;
  }

  // Return result
  return distance_squared;
}

// Assembly:
movslq 0x24c(%rdi), %rax
testq %rax, %rax
jle 0x3595d
movq 0x230(%rdi), %rcx
movq 0x230(%rsi), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
subsd (%rdx,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x35942
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::WorldSpacing(int) const
RNScalar R3Grid::
WorldSpacing(RNDimension dim) const
{
  // Return distance between grid samples in dimension
  assert((0 <= dim) && (dim <= 2));
  RNScalar m0 = grid_to_world_transform.Matrix()[0][dim];
  RNScalar m1 = grid_to_world_transform.Matrix()[1][dim];
  RNScalar m2 = grid_to_world_transform.Matrix()[2][dim];
  RNScalar spacing_squared = m0*m0 + m1*m1 + m2*m2;
  return sqrt(spacing_squared);
}

// Assembly:
movslq %esi, %rax
movsd 0x8(%rdi,%rax,8), %xmm0
movsd 0x28(%rdi,%rax,8), %xmm1
movsd 0x48(%rdi,%rax,8), %xmm2
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::ReadFile(char const*)
int R3Grid::
ReadFile(const char *filename)
{
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .ply)\n", filename);
    return 0;
  }

  // Read file of appropriate type
  int status = 0;
  if (!strncmp(extension, ".grd", 4)) 
    status = ReadGridFile(filename);
  else if (!strncmp(extension, ".phi", 4)) 
    status = ReadDelphiFile(filename);
  else if (!strncmp(extension, ".vox", 4)) 
    status = ReadVoxelFile(filename);
  else if (!strncmp(extension, ".ins", 4)) 
    status = ReadInsightFile(filename);
  else if (!strncmp(extension, ".dx", 3)) 
    status = ReadDXFile(filename);
  else if (!strncmp(extension, ".map", 4)) 
    status = ReadCCP4File(filename);
  else if (!strncmp(extension, ".raw", 4)) 
    status = ReadRawFile(filename);
  else {
    RNFail("Unable to read file %s (unrecognized extension: %s)\n", filename, extension);
    return 0;
  }

  // Return status
  return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x2e, %esi
callq 0xe4c0
testq %rax, %rax
je 0x35cae
movq %rax, %r15
leaq 0x71b78(%rip), %rsi     # 0xa779d
movl $0x4, %edx
movq %rax, %rdi
callq 0xe210
testl %eax, %eax
je 0x35cc7
leaq 0x71b61(%rip), %rsi     # 0xa77a2
movl $0x4, %edx
movq %r15, %rdi
callq 0xe210
testl %eax, %eax
je 0x35cd7
leaq 0x71b4a(%rip), %rsi     # 0xa77a7
movl $0x4, %edx
movq %r15, %rdi
callq 0xe210
testl %eax, %eax
je 0x35ce7
leaq 0x71b37(%rip), %rsi     # 0xa77ac
movl $0x4, %edx
movq %r15, %rdi
callq 0xe210
testl %eax, %eax
je 0x35d3d
cmpb $0x2e, (%r15)
jne 0x35cf7
cmpb $0x64, 0x1(%r15)
jne 0x35cf7
cmpb $0x78, 0x2(%r15)
jne 0x35cf7
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x36bec
leaq 0x6c67d(%rip), %rdi     # 0xa2332
movq %rbx, %rsi
xorl %eax, %eax
callq 0xe070
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x35d6e
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x35dc2
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x363b0
leaq 0x71ab3(%rip), %rsi     # 0xa77b1
movl $0x4, %edx
movq %r15, %rdi
callq 0xe210
testl %eax, %eax
je 0x35d4d
leaq 0x71aa0(%rip), %rsi     # 0xa77b6
movl $0x4, %edx
movq %r15, %rdi
callq 0xe210
testl %eax, %eax
je 0x35d5d
leaq 0x6c657(%rip), %rdi     # 0xa2385
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x719d2
jmp 0x35cbf
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x36526
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x36fb8
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x372da
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::ReadGridFile(char const*)
int R3Grid::
ReadGridFile(const char *filename)
{
  // Open file
  FILE *fp = fopen(filename, "rb");
  if (!fp) {
    RNFail("Unable to open voxel file %s", filename);
    return 0;
  }

  // Read 
  int status = ReadGrid(fp);

  // Close file
  fclose(fp);

  // Return status
  return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6c82b(%rip), %rsi     # 0xa25ab
movq %rbx, %rdi
callq 0xe530
testq %rax, %rax
je 0x35da9
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x38740
movl %eax, %ebx
movq %r15, %rdi
callq 0xe430
movl %ebx, %eax
jmp 0x35dbc
leaq 0x71a4e(%rip), %rdi     # 0xa77fe
movq %rbx, %rsi
xorl %eax, %eax
callq 0x719d2
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::WriteFile(char const*) const
int R3Grid::
WriteFile(const char *filename) const
{
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .ply)\n", filename);
    return 0;
  }

  // Write file of appropriate type
  int status = 0;
  if (!strncmp(extension, ".grd", 4)) 
    status = WriteGridFile(filename);
  else if (!strncmp(extension, ".dx", 3)) 
    status = WriteDXFile(filename);
  else if (!strncmp(extension, ".raw", 4)) 
    status = WriteRawFile(filename);
  else if (!strncmp(extension, ".pdb", 4)) 
    status = WritePDBFile(filename);
  else {
    RNFail("Unable to write file %s (unrecognized extension: %s)\n", filename, extension);
    return 0;
  }

  // Return status
  return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x2e, %esi
callq 0xe4c0
testq %rax, %rax
je 0x37b70
movq %rax, %r15
leaq 0x6fc66(%rip), %rsi     # 0xa779d
movl $0x4, %edx
movq %rax, %rdi
callq 0xe210
testl %eax, %eax
je 0x37bcf
cmpb $0x2e, (%r15)
jne 0x37b83
cmpb $0x64, 0x1(%r15)
jne 0x37b83
cmpb $0x78, 0x2(%r15)
jne 0x37b83
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x37c5a
leaq 0x6a7bb(%rip), %rdi     # 0xa2332
movq %rbx, %rsi
xorl %eax, %eax
callq 0xe070
jmp 0x37bc7
leaq 0x6fc2c(%rip), %rsi     # 0xa77b6
movl $0x4, %edx
movq %r15, %rdi
callq 0xe210
testl %eax, %eax
je 0x37bdf
leaq 0x6fc21(%rip), %rsi     # 0xa77c3
movl $0x4, %edx
movq %r15, %rdi
callq 0xe210
testl %eax, %eax
je 0x37bf6
leaq 0x6fc0e(%rip), %rdi     # 0xa77c8
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x719d2
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x37c06
leaq 0x6fbd5(%rip), %rdx     # 0xa77bb
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x37ee2
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x38560
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::WriteGridFile(char const*) const
int R3Grid::
WriteGridFile(const char *filename) const
{
  // Open file
  FILE *fp = fopen(filename, "wb");
  if (!fp) {
    RNFail("Unable to open voxel file %s", filename);
    return 0;
  }

  // Write
  int status = WriteGrid(fp);

  // Close file
  fclose(fp);

  // Return status
  return status;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6ae69(%rip), %rsi     # 0xa2a81
movq %rbx, %rdi
callq 0xe530
testq %rax, %rax
je 0x37c41
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x389ce
movl %eax, %ebx
movq %r15, %rdi
callq 0xe430
movl %ebx, %eax
jmp 0x37c54
leaq 0x6fbb6(%rip), %rdi     # 0xa77fe
movq %rbx, %rsi
xorl %eax, %eax
callq 0x719d2
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::WritePDBFile(char const*) const
int R3Grid::
WritePDBFile(const char *filename) const
{
  // Open file
  FILE *fp = fopen(filename, "w");
  if (!fp) {
    RNFail("Unable to open file %s", filename);
    return 0;
  }

  // Print values
  int n = 0;
  for (int k = 0; k < ZResolution(); k++) {
    for (int j = 0; j < YResolution(); j++) {
      for (int i = 0; i < XResolution(); i++) {
	if (GridValue(i,j, k) > 0){
	  R3Point world_position = WorldPosition(i, j, k);	  
	  fprintf(fp, "%-6s%5d %-4s%c%3s %1s%4d%c   %8.3f%8.3f%8.3f%6.2f%6.2f          %2s\n", "HETATM", n, "H", ' ', "POC", "1", n, ' ', world_position.X(), world_position.Y(), world_position.Z(), GridValue(i, j, k), GridValue(i, j, k), "");
	  n++;
	}
      }
    }
  }

  // Close file
  fclose(fp);

  // Return OK status
  return grid_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x6f23e(%rip), %rsi     # 0xa77b9
movq %r15, %rdi
callq 0xe530
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x3871c
movl 0x240(%rbx), %ecx
testl %ecx, %ecx
jle 0x3870a
movl 0x23c(%rbx), %eax
xorl %r13d, %r13d
xorpd %xmm1, %xmm1
leaq 0x20(%rsp), %r15
xorl %r12d, %r12d
testl %eax, %eax
jle 0x386fe
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0x238(%rbx), %ecx
xorl %ebp, %ebp
testl %ecx, %ecx
jle 0x386ee
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %r14d, %r14d
movq 0x230(%rbx), %rax
movl 0x248(%rbx), %edx
imull %r13d, %edx
movl 0x244(%rbx), %esi
imull %ebp, %esi
addl %edx, %esi
addl %r14d, %esi
movslq %esi, %rdx
movsd (%rax,%rdx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x386dc
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movq %r15, %rdi
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x3c532
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3ce48
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
movq 0x230(%rbx), %rax
movl 0x248(%rbx), %ecx
imull %r13d, %ecx
movl 0x244(%rbx), %edx
imull %ebp, %edx
addl %ecx, %edx
addl %r14d, %edx
movslq %edx, %rcx
movsd (%rax,%rcx,8), %xmm3
subq $0x8, %rsp
movq 0x10(%rsp), %rdi
leaq 0x6fe29(%rip), %rsi     # 0xa84b4
leaq 0x6fe67(%rip), %rdx     # 0xa84f9
movl %r12d, %ecx
leaq 0x6fe64(%rip), %r8      # 0xa8500
movl $0x20, %r9d
movaps %xmm3, %xmm4
movb $0x5, %al
leaq 0x69fab(%rip), %r10     # 0xa2659
pushq %r10
pushq $0x20
pushq %r12
leaq 0x6fe4b(%rip), %r10     # 0xa8506
pushq %r10
leaq 0x6fe3e(%rip), %r10     # 0xa8502
pushq %r10
callq 0xe670
xorpd %xmm1, %xmm1
addq $0x30, %rsp
incl %r12d
movl 0x238(%rbx), %ecx
incl %r14d
cmpl %ecx, %r14d
jl 0x385ea
movl 0x23c(%rbx), %eax
incl %ebp
cmpl %eax, %ebp
jl 0x385d2
movl 0x240(%rbx), %ecx
incl %r13d
cmpl %ecx, %r13d
jl 0x385b4
movq 0x8(%rsp), %rdi
callq 0xe430
movl 0x24c(%rbx), %ebx
jmp 0x3872f
leaq 0x69c97(%rip), %rdi     # 0xa23ba
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x719d2
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::WriteGrid(_IO_FILE*) const
int R3Grid::
WriteGrid(FILE *fp) const
{
  // Check file
  if (!fp) fp = stdout;

  // Write grid resolution to file
  if (fwrite(&grid_resolution, sizeof(int), 3, fp) != 3) {
    RNFail("Unable to write resolution to file");
    return 0;
  }

  // Write world_to_grid transformation to file
  const RNScalar *m = &(world_to_grid_transform.Matrix()[0][0]);
  for (int i = 0; i < 16; i++) {
    float value = (float) *(m++);
    if (fwrite(&value, sizeof(float), 1, fp) != 1) {
      RNFail("Unable to write transformation matrix value to file");
      return 0;
    }
  }

  // Write grid values to file
  const RNScalar *grid_valuesp = grid_values;
  for (int i = 0; i < grid_size; i++) {
    float value = (float) *(grid_valuesp++);
    if (fwrite(&value, sizeof(float), 1, fp) != 1) {
      RNFail("Unable to write grid value to file");
      return 0;
    }
  }

  // Return number of grid values written
  return grid_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x389ee
movq 0xac585(%rip), %rax     # 0xe4f70
movq (%rax), %r14
leaq 0x238(%rbx), %rdi
movl $0x4, %esi
movl $0x3, %edx
movq %r14, %rcx
callq 0xe8b0
cmpq $0x3, %rax
jne 0x38aa0
xorl %r12d, %r12d
leaq 0x4(%rsp), %r15
xorps %xmm0, %xmm0
cvtsd2ss 0x118(%rbx,%r12,8), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0xe8b0
cmpq $0x1, %rax
jne 0x38aa9
incq %r12
cmpl $0x10, %r12d
jne 0x38a19
movl 0x24c(%rbx), %ebp
testl %ebp, %ebp
jle 0x38ac2
movq 0x230(%rbx), %r12
xorl %r13d, %r13d
movq %rsp, %r15
xorps %xmm0, %xmm0
cvtsd2ss (%r12,%r13,8), %xmm0
movss %xmm0, (%rsp)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0xe8b0
cmpq $0x1, %rax
jne 0x38ab2
movl 0x24c(%rbx), %ebp
incq %r13
cmpl %ebp, %r13d
jl 0x38a67
jmp 0x38ac2
leaq 0x6ee17(%rip), %rdi     # 0xa78be
jmp 0x38ab9
leaq 0x6ee31(%rip), %rdi     # 0xa78e1
jmp 0x38ab9
leaq 0x6ee5c(%rip), %rdi     # 0xa7915
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x719d2
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: int gaps::ReadRawValues<double>(_IO_FILE*, double*, int)
static int
ReadRawValues(FILE *fp, RNScalar *values, int nvalues)
{
  // Read values of type T into array of RNScalar
  for (int i = 0; i < nvalues; i++) {
    T value;
    if (fread(&value, sizeof(T), 1, fp) != 1) return 0;
    values[i] = (RNScalar) value;
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x1, %ebx
testl %edx, %edx
jle 0x38b5e
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0xe6c0
xorl %ecx, %ecx
cmpq $0x1, %rax
jne 0x38b5c
movl %ebp, %eax
movq %rax, 0x10(%rsp)
leaq -0x1(%rax), %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r14,%rbp,8)
cmpq %rbp, %r13
je 0x38b5e
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0xe6c0
incq %rbp
cmpq $0x1, %rax
je 0x38b23
xorl %ecx, %ecx
cmpq 0x10(%rsp), %rbp
setae %cl
movl %ecx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: int gaps::WriteRawValues<double>(_IO_FILE*, double*, int)
static int
WriteRawValues(FILE *fp, RNScalar *values, int nvalues)
{
  // Write values of type T from array of RNScalar
  for (int i = 0; i < nvalues; i++) {
    T value = (T) values[i];
    if (fwrite(&value, sizeof(T), 1, fp) != 1) return 0;
  }
  return 1;
}

// Assembly:
testl %edx, %edx
jle 0x391c9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movsd (%rsi), %xmm0
movq %rsp, %rdi
movsd %xmm0, (%rdi)
movl $0x1, %r13d
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0xe8b0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
jne 0x391ba
movl %ebp, %r12d
movq %rsp, %r15
movq %r13, %rbp
cmpq %r13, %r12
je 0x391b2
movsd (%rbx,%rbp,8), %xmm0
movsd %xmm0, (%rsp)
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0xe8b0
leaq 0x1(%rbp), %r13
cmpq $0x1, %rax
je 0x39181
xorl %eax, %eax
cmpq %r12, %rbp
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::WriteASCIIFile(char const*) const
int R3Grid::
WriteASCIIFile(const char *filename) const
{
  // Open file
  FILE *fp = fopen(filename, "w");
  if (!fp) {
    RNFail("Unable to open file %s", filename);
    return 0;
  }

  // Print resolutions
  fprintf(fp, "%d %d %d\n", XResolution(), YResolution(), ZResolution());

  // Print world to grid transformation
  const R4Matrix& m = world_to_grid_transform.Matrix();
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      fprintf(fp, "%lf ", m[i][j]);
    }
    fprintf(fp, "\n");
  }

  // Print values
  for (int i = 0; i < XResolution(); i++) {
    for (int j = 0; j < YResolution(); j++) {
      for (int k = 0; k < ZResolution(); k++) {
	fprintf(fp, "%lf\n", GridValue(i, j, k));
      }
    }
  }

  // Close file
  fclose(fp);

  // Return OK status
  return grid_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x6de3d(%rip), %rsi     # 0xa77b9
movq %r15, %rdi
callq 0xe530
testq %rax, %rax
je 0x39a97
movq %rax, %r14
movl 0x238(%rbx), %edx
movl 0x23c(%rbx), %ecx
movl 0x240(%rbx), %r8d
leaq 0x6908a(%rip), %rsi     # 0xa2a34
xorl %r12d, %r12d
movq %rax, %rdi
xorl %eax, %eax
callq 0xe670
leaq 0x118(%rbx), %r13
leaq 0x6eb79(%rip), %r15     # 0xa853e
xorl %ebp, %ebp
movsd (%r13,%rbp,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0xe670
incq %rbp
cmpq $0x4, %rbp
jne 0x399c7
movl $0xa, %edi
movq %r14, %rsi
callq 0xe5a0
incq %r12
addq $0x20, %r13
cmpq $0x4, %r12
jne 0x399c5
movl 0x238(%rbx), %ecx
testl %ecx, %ecx
jle 0x39a87
movl 0x23c(%rbx), %eax
xorl %ebp, %ebp
leaq 0x6ea21(%rip), %r15     # 0xa8438
testl %eax, %eax
jle 0x39a81
movl 0x240(%rbx), %ecx
xorl %r12d, %r12d
testl %ecx, %ecx
jle 0x39a73
xorl %r13d, %r13d
movq 0x230(%rbx), %rax
movl 0x248(%rbx), %ecx
imull %r13d, %ecx
movl 0x244(%rbx), %edx
imull %r12d, %edx
addl %ebp, %ecx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0xe670
incl %r13d
movl 0x240(%rbx), %ecx
cmpl %ecx, %r13d
jl 0x39a2b
movl 0x23c(%rbx), %eax
incl %r12d
cmpl %eax, %r12d
jl 0x39a24
movl 0x238(%rbx), %ecx
incl %ebp
cmpl %ecx, %ebp
jl 0x39a17
movq %r14, %rdi
callq 0xe430
movl 0x24c(%rbx), %ebx
jmp 0x39aaa
leaq 0x6891c(%rip), %rdi     # 0xa23ba
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x719d2
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Print(_IO_FILE*) const
int R3Grid::
Print(FILE *fp) const
{
  // Check file
  if (!fp) fp = stdout;

  // Print resolutions
  fprintf(fp, "%d %d %d\n", XResolution(), YResolution(), ZResolution());

  // Print values
  for (int k = 0; k < ZResolution(); k++) {
    for (int j = 0; j < YResolution(); j++) {
      for (int i = 0; i < XResolution(); i++) {
        fprintf(fp, "%g ", GridValue(i, j, k));
      }
      fprintf(fp, "\n");
    }
    fprintf(fp, "\n");
  }

  // Return number of grid values written
  return grid_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x39adc
movq 0xab497(%rip), %rax     # 0xe4f70
movq (%rax), %r14
movl 0x238(%rbx), %edx
movl 0x23c(%rbx), %ecx
movl 0x240(%rbx), %r8d
leaq 0x68f3e(%rip), %rsi     # 0xa2a34
xorl %ebp, %ebp
movq %r14, %rdi
xorl %eax, %eax
callq 0xe670
cmpl $0x0, 0x240(%rbx)
jle 0x39ba2
leaq 0x6ea2d(%rip), %r15     # 0xa8543
cmpl $0x0, 0x23c(%rbx)
jle 0x39b87
xorl %r12d, %r12d
cmpl $0x0, 0x238(%rbx)
jle 0x39b6e
xorl %r13d, %r13d
movq 0x230(%rbx), %rax
movl 0x248(%rbx), %ecx
imull %ebp, %ecx
movl 0x244(%rbx), %edx
imull %r12d, %edx
addl %ecx, %edx
addl %r13d, %edx
movslq %edx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0xe670
incl %r13d
cmpl 0x238(%rbx), %r13d
jl 0x39b2e
movl $0xa, %edi
movq %r14, %rsi
callq 0xe5a0
incl %r12d
cmpl 0x23c(%rbx), %r12d
jl 0x39b22
movl $0xa, %edi
movq %r14, %rsi
callq 0xe5a0
incl %ebp
cmpl 0x240(%rbx), %ebp
jl 0x39b16
movl 0x24c(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::DrawIsoSurface(double) const
void R3Grid::
DrawIsoSurface(RNScalar isolevel) const
{
  // Allocate storage for isosurface
  static const R3Grid *isosurface_grid = NULL;
  static RNScalar isosurface_level = -12345679;
  static const int isosurface_max_points = 8*1024*1024;
  static R3Point *isosurface_points = NULL;
  static int isosurface_npoints = 0;

  // Allocate points for isosurface
  if (!isosurface_points) { 
    isosurface_points = new R3Point [isosurface_max_points];
    assert(isosurface_points);
  }

  // Generate isosurface
  if ((this != isosurface_grid) || (isosurface_level != isolevel)) {
    isosurface_npoints = GenerateIsoSurface(isolevel, isosurface_points, isosurface_max_points);
    isosurface_grid = this;
    isosurface_level = isolevel;
  }

  // Draw isosurface
  R3Point *pointsp = isosurface_points;
  RNGrfxBegin(RN_GRFX_TRIANGLES);
  for (int i = 0; i < isosurface_npoints; i += 3) {
    R3Point p0 = *(pointsp++);
    R3Point p1 = *(pointsp++);
    R3Point p2 = *(pointsp++);
    R3Plane plane(p0, p1, p2);
    R3LoadNormal(plane.Normal());
    R3LoadPoint(p0);
    R3LoadPoint(p1);
    R3LoadPoint(p2);
  }
  RNGrfxEnd();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
movq 0xabc8e(%rip), %rbx     # 0xe6650
testq %rbx, %rbx
jne 0x3aa00
movsd %xmm0, 0x8(%rsp)
movl $0xc000000, %edi        # imm = 0xC000000
callq 0xe030
movq %rax, %rbx
xorl %r15d, %r15d
leaq (%rbx,%r15), %rdi
callq 0x3c530
addq $0x18, %r15
cmpq $0xc000000, %r15        # imm = 0xC000000
jne 0x3a9dd
movq %rbx, 0xabc56(%rip)     # 0xe6650
movsd 0x8(%rsp), %xmm0
cmpq %r14, 0xabc41(%rip)     # 0xe6648
jne 0x3aa19
movsd 0xaafef(%rip), %xmm1    # 0xe5a00
ucomisd %xmm0, %xmm1
jne 0x3aa19
jnp 0x3aa51
movq %r14, %rdi
movq %rbx, %rsi
movl $0x800000, %edx         # imm = 0x800000
movsd %xmm0, 0x8(%rsp)
callq 0x3a6b2
movl %eax, 0xabc23(%rip)     # 0xe6658
movq %r14, 0xabc0c(%rip)     # 0xe6648
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0xaafb6(%rip)    # 0xe5a00
movq 0xabbff(%rip), %rbx     # 0xe6650
movl $0x4, %edi
callq 0xe110
cmpl $0x0, 0xabbf6(%rip)     # 0xe6658
jle 0x3aae3
xorl %r13d, %r13d
leaq 0x40(%rsp), %r14
leaq 0x28(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x18(%rbx), %rbp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c542
movq %r15, %rdi
movq %rbp, %rsi
callq 0x3c542
leaq 0x30(%rbx), %rsi
movq %r12, %rdi
callq 0x3c542
leaq 0x58(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x3b21e
movq %rbp, %rdi
callq 0xe6b0
movq %r14, %rdi
callq 0xe130
movq %r15, %rdi
callq 0xe130
movq %r12, %rdi
callq 0xe130
addl $0x3, %r13d
addq $0x48, %rbx
cmpl 0xabb77(%rip), %r13d    # 0xe6658
jl 0x3aa76
callq 0xe5d0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0xc000000, %esi        # imm = 0xC000000
movq %rbx, %rdi
callq 0xe8c0
movq %r14, %rdi
callq 0xe7e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::R3Plane(gaps::R3Point const&, gaps::R3Line const&)
R3Plane::
R3Plane(const R3Point& point, const R3Line& line)
{
    // Construct plane through point and line
    v = point - line.Point();
    v.Cross(line.Vector());
    v.Normalize();
    d = -(v[0]*point[0] + v[1]*point[1] + v[2]*point[2]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3cfc4
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3c78e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3d752
addq $0x18, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d352
movq %rbx, %rdi
callq 0x3d2dc
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x8(%r14), %xmm1
mulsd (%r14), %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rbx), %xmm1
mulsd 0x10(%r14), %xmm1
addsd %xmm0, %xmm1
xorpd 0x66e99(%rip), %xmm1    # 0xa2020
movlpd %xmm1, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::R3Plane(gaps::R3Point const&, gaps::R3Vector const&, gaps::R3Vector const&)
R3Plane::
R3Plane(const R3Point& point, const R3Vector& vector1, const R3Vector& vector2)
{
    // Construct plane through point and two vectors
    v = vector1 % vector2;
    v.Normalize();
    d = -(v[0]*point[0] + v[1]*point[1] + v[2]*point[2]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3cfc4
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3d8fa
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3d752
movq %rbx, %rdi
callq 0x3d2dc
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x8(%r14), %xmm1
mulsd (%r14), %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rbx), %xmm1
mulsd 0x10(%r14), %xmm1
addsd %xmm0, %xmm1
xorpd 0x66e15(%rip), %xmm1    # 0xa2020
movlpd %xmm1, 0x18(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::R3Plane(gaps::R3Point const&, gaps::R3Point const&, gaps::R3Point const&)
R3Plane::
R3Plane(const R3Point& point1, const R3Point& point2, const R3Point& point3)
{
    // Construct plane through three points
    v = point2 - point1;
    R3Vector v3 = point3 - point1;
    v.Cross(v3);
    v.Normalize();
    d = -(v[0]*point1[0] + v[1]*point1[1] + v[2]*point1[2]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3cfc4
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3c78e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3d752
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3c78e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3d352
movq %rbx, %rdi
callq 0x3d2dc
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x8(%r14), %xmm1
mulsd (%r14), %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rbx), %xmm1
mulsd 0x10(%r14), %xmm1
addsd %xmm0, %xmm1
xorpd 0x66d71(%rip), %xmm1    # 0xa2020
movlpd %xmm1, 0x18(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::R3Plane(gaps::RNArray<gaps::R3Point*> const&, int)
R3Plane::
R3Plane(const RNArray<R3Point *>& points, RNBoolean polygon_vertices)
{
    // Initialize plane
    v = R3null_vector;
    d = 0;

    // Check number of points
    int npoints = points.NEntries();
    if (npoints < 3) {
      *this = R3null_plane;
      return;
    }

    // Compute centroid
    R3Point c = R3Centroid(points);

    // Check if points form (counter-clockwise) boundary of polygon
    if (polygon_vertices) {
        // Compute best normal for counter-clockwise array of points using newell's method 
        const R3Point *p1 = points[npoints-1];
        for (int i = 0; i < npoints; i++) {
            const R3Point *p2 = points[i];
            v[0] += (p1->Y() - p2->Y()) * (p1->Z() + p2->Z());
            v[1] += (p1->Z() - p2->Z()) * (p1->X() + p2->X());
            v[2] += (p1->X() - p2->X()) * (p1->Y() + p2->Y());
            p1 = p2;
        }

        // Normalize 
        v.Normalize();
    }
    else {
        // Compute principle axes
        R3Triad triad = R3PrincipleAxes(c, points);

        // Select direction of least variation
        v = triad[2];
    }

    // Compute d from centroid and normal
    d = -(v[0]*c[0] + v[1]*c[1] + v[2]*c[2]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3cfc4
leaq 0x6d400(%rip), %rsi     # 0xa86e0
movq %rbx, %rdi
callq 0x3d752
movq $0x0, 0x18(%rbx)
movslq 0xc(%r14), %r15
cmpq $0x2, %r15
jg 0x3b31b
leaq 0x4ab38f(%rip), %rsi    # 0x4e6690
movq %rbx, %rdi
callq 0x3d752
movsd 0x4ab397(%rip), %xmm0   # 0x4e66a8
movsd %xmm0, 0x18(%rbx)
jmp 0x3b41a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4c1ec
testl %ebp, %ebp
je 0x3b3c1
movq (%r14), %rax
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movq -0x8(%rax,%r15,8), %rdx
movsd 0x10(%rbx), %xmm2
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rsi
movsd 0x8(%rdx), %xmm3
subsd 0x8(%rsi), %xmm3
movsd 0x10(%rdx), %xmm4
addsd 0x10(%rsi), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm0
movsd %xmm0, (%rbx)
movsd (%rdx), %xmm3
movsd 0x10(%rdx), %xmm4
subsd 0x10(%rsi), %xmm4
addsd (%rsi), %xmm3
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm1
movsd %xmm1, 0x8(%rbx)
movsd (%rdx), %xmm3
movsd 0x8(%rdx), %xmm4
subsd (%rsi), %xmm3
addsd 0x8(%rsi), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm2
movsd %xmm2, 0x10(%rbx)
incq %rcx
movq %rsi, %rdx
cmpq %rcx, %r15
jne 0x3b34a
movq %rbx, %rdi
callq 0x3d2dc
jmp 0x3b3e5
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4c299
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x3d752
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rbx), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
xorpd 0x66c0b(%rip), %xmm1    # 0xa2020
movlpd %xmm1, 0x18(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::R3Plane(gaps::R3Point const*, int, int)
R3Plane::
R3Plane(const R3Point *points, int npoints, RNBoolean polygon_vertices)
{
    // Initialize plane
    v = R3null_vector;
    d = 0;

    // Check number of points
    if (npoints < 3) {
      *this = R3null_plane;
      return;
    }

    // Compute centroid
    R3Point c = R3Centroid(npoints, points);

    // Check if points form (counter-clockwise) boundary of polygon
    if (polygon_vertices) {
        // Compute best normal for counter-clockwise array of points using newell's method 
        const R3Point *p1 = &points[npoints-1];
        for (int i = 0; i < npoints; i++) {
            const R3Point *p2 = &points[i];
            v[0] += (p1->Y() - p2->Y()) * (p1->Z() + p2->Z());
            v[1] += (p1->Z() - p2->Z()) * (p1->X() + p2->X());
            v[2] += (p1->X() - p2->X()) * (p1->Y() + p2->Y());
            p1 = p2;
        }

        // Normalize 
        v.Normalize();
    }
    else {
        // Compute principle axes
        R3Triad triad = R3PrincipleAxes(c, npoints, points);

        // Select direction of least variation
        v = triad[2];
    }

    // Compute d from centroid and normal
    d = -(v[0]*c[0] + v[1]*c[1] + v[2]*c[2]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3cfc4
leaq 0x6d299(%rip), %rsi     # 0xa86e0
movq %rbx, %rdi
callq 0x3d752
movq $0x0, 0x18(%rbx)
cmpl $0x2, %ebp
jg 0x3b47d
leaq 0x4ab22d(%rip), %rsi    # 0x4e6690
movq %rbx, %rdi
callq 0x3d752
movsd 0x4ab235(%rip), %xmm0   # 0x4e66a8
movsd %xmm0, 0x18(%rbx)
jmp 0x3b589
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x4dab1
testl %r15d, %r15d
je 0x3b52d
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
movl %ebp, %eax
leaq (%rax,%rax,2), %rcx
leaq (%r14,%rcx,8), %rcx
addq $-0x18, %rcx
movsd 0x10(%rbx), %xmm2
movsd 0x8(%rcx), %xmm3
subsd 0x8(%r14), %xmm3
movsd 0x10(%rcx), %xmm4
addsd 0x10(%r14), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm0
movsd %xmm0, (%rbx)
movsd (%rcx), %xmm3
movsd 0x10(%rcx), %xmm4
subsd 0x10(%r14), %xmm4
addsd (%r14), %xmm3
mulsd %xmm4, %xmm3
addsd %xmm3, %xmm1
movsd %xmm1, 0x8(%rbx)
movsd (%rcx), %xmm3
movsd 0x8(%rcx), %xmm4
subsd (%r14), %xmm3
addsd 0x8(%r14), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm4, %xmm2
movsd %xmm2, 0x10(%rbx)
movq %r14, %rcx
addq $0x18, %r14
decq %rax
jne 0x3b4b3
movq %rbx, %rdi
callq 0x3d2dc
jmp 0x3b554
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl %ebp, %edx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4db3b
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x3d752
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rbx), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
xorpd 0x66a9c(%rip), %xmm1    # 0xa2020
movlpd %xmm1, 0x18(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::Mirror(gaps::R3Plane const&)
void R3Plane::
Mirror(const R3Plane& plane)
{
    // Mirror plane ???
    R3Point p = Point();
    p.Mirror(plane);
    v.Mirror(plane);
    Reposition(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
xorps 0x66a31(%rip), %xmm0    # 0xa2020
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3d962
leaq 0x4ab45a(%rip), %rsi    # 0x4e6a60
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x3c877
movq %r12, %rdi
movq %r14, %rsi
callq 0x3c942
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3dae6
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x8(%r12), %xmm1
mulsd (%r12), %xmm0
movsd 0x10(%rbx), %xmm2
mulsd 0x10(%r12), %xmm2
addsd %xmm1, %xmm0
addsd %xmm0, %xmm2
xorpd 0x669c2(%rip), %xmm2    # 0xa2020
movlpd %xmm2, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::Transform(gaps::R3Transformation const&)
void R3Plane::
Transform (const R3Transformation& transformation)
{
    // Transform plane ???
    R3Point p = Point();
    p.Transform(transformation);
    transformation.ApplyInverseTranspose(v);
    v.Normalize();
    Reposition(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
xorps 0x668c9(%rip), %xmm0    # 0xa2020
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3d962
leaq 0x4ab2f2(%rip), %rsi    # 0x4e6a60
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rdx
callq 0x3c877
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ce48
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x78(%rax)
movq %rbx, %rdi
callq 0x3d2dc
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x8(%r14), %xmm1
mulsd (%r14), %xmm0
movsd 0x10(%rbx), %xmm2
mulsd 0x10(%r14), %xmm2
addsd %xmm1, %xmm0
addsd %xmm0, %xmm2
xorpd 0x66854(%rip), %xmm2    # 0xa2020
movlpd %xmm2, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Plane.cpp
// Function: gaps::R3Plane::InverseTransform(gaps::R3Transformation const&)
void R3Plane::
InverseTransform (const R3Transformation& transformation)
{
    // Transform plane ???
    R3Point p = Point();
    p.InverseTransform(transformation);
    transformation.ApplyTranspose(v);
    v.Normalize();
    Reposition(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
xorps 0x66825(%rip), %xmm0    # 0xa2020
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3d962
leaq 0x4ab24e(%rip), %rsi    # 0x4e6a60
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rdx
callq 0x3c877
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ce5a
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x80(%rax)
movq %rbx, %rdi
callq 0x3d2dc
movsd (%rbx), %xmm0
movsd 0x8(%rbx), %xmm1
mulsd 0x8(%r14), %xmm1
mulsd (%r14), %xmm0
movsd 0x10(%rbx), %xmm2
mulsd 0x10(%r14), %xmm2
addsd %xmm1, %xmm0
addsd %xmm0, %xmm2
xorpd 0x667ad(%rip), %xmm2    # 0xa2020
movlpd %xmm2, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::R3Span(gaps::R3Point const&, gaps::R3Vector const&)
R3Span::
R3Span(const R3Point& point, const R3Vector& vector)
    : end(point + vector)
{
    R3Vector v(vector);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(point, v, TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3c114
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3c877
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3cfd6
movq %r12, %rdi
callq 0x3d0cc
movsd %xmm0, 0x48(%rbx)
leaq 0xaa228(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x3b988
xorpd 0x6669e(%rip), %xmm1    # 0xa2020
ucomisd %xmm0, %xmm1
jbe 0x3b990
movq %rsp, %rdi
callq 0x3db98
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c89a
addq $0x18, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3d752
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::R3Span(gaps::R3Point const&, gaps::R3Point const&)
R3Span::
R3Span(const R3Point& point1, const R3Point& point2)
    : end(point2)
{
    R3Vector v(point2 - point1);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(point1, v, TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3c114
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x3c542
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3c78e
movq %r12, %rdi
callq 0x3d0cc
movsd %xmm0, 0x48(%rbx)
leaq 0xaa198(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x3ba18
xorpd 0x6660e(%rip), %xmm1    # 0xa2020
ucomisd %xmm0, %xmm1
jbe 0x3ba20
movq %rsp, %rdi
callq 0x3db98
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c89a
addq $0x18, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3d752
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::R3Span(double, double, double, double, double, double)
R3Span::
R3Span(RNCoord x1, RNCoord y1, RNCoord z1, RNCoord x2, RNCoord y2, RNCoord z2)
    : end(x2, y2, z2)
{
    R3Point p1(x1, y1, z1);
    R3Point p2(x2, y2, z2);
    R3Vector v(p2 - p1);
    length = v.Length();
    if (RNIsNotZero(length)) v /= length;
    ray.Reset(p1, v, TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movsd %xmm5, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm3, (%rsp)
movsd %xmm2, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rdi, %rbx
callq 0x3c114
leaq 0x30(%rbx), %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x3c532
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
callq 0x3c532
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x3c532
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3c78e
movq %r12, %rdi
callq 0x3d0cc
movsd %xmm0, 0x48(%rbx)
leaq 0xaa09e(%rip), %rax     # 0xe5b98
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm0
ja 0x3bb12
xorpd 0x66514(%rip), %xmm1    # 0xa2020
ucomisd %xmm0, %xmm1
jbe 0x3bb1c
leaq 0x30(%rsp), %rdi
callq 0x3db98
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x3c89a
addq $0x18, %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x3d752
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::T(gaps::R3Point const&) const
const RNScalar R3Span::
T(const R3Point& point) const
{
    // Return parametric value of closest point on span
    if (length == 0.0) return 0.0;
    R3Vector topoint = point - Start();
    return Vector().Dot(topoint);
}

// Assembly:
movsd 0x48(%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x3bc6e
jp 0x3bc6e
retq
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3c78e
addq $0x18, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d252
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::Reposition(int, gaps::R3Point const&)
void R3Span::
Reposition(int k, const R3Point& point)
{
    // Set one endpoint of span
    if (k == 0) ray = R3Ray(point, end);
    else { end = point; ray.Align(end - ray.Start()); }
    length = R3Distance(Start(), End());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
testl %esi, %esi
je 0x3bcff
leaq 0x30(%rbx), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x3c89a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3c78e
movq %r14, %rdi
movq %r12, %rsi
callq 0x3d752
movq %r14, %rdi
callq 0x3d2dc
jmp 0x3bd2e
leaq 0x30(%rbx), %rax
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3c126
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c89a
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x3d752
leaq 0x30(%rbx), %rsi
movq %rbx, %rdi
callq 0x49404
movsd %xmm0, 0x48(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::Flip()
void R3Span::
Flip(void)
{
    // Flip direction of span
    R3Point swap = Start();
    ray.Reposition(end);
    end = swap;
    ray.Flip();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3c542
leaq 0x30(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c89a
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c89a
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x3d334
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Span.cpp
// Function: gaps::R3Span::Reset(gaps::R3Point const&, gaps::R3Point const&)
void R3Span::
Reset(const R3Point& point1, const R3Point& point2)
{
    // Reset span
    ray = R3Ray(point1, point2);
    end = point2;
    length = R3Distance(point1, point2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3c126
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3c89a
leaq 0x18(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3d752
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x3c89a
movq %r15, %rdi
movq %r14, %rsi
callq 0x49404
movsd %xmm0, 0x48(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Ray.cpp
// Function: gaps::R3Ray::T(gaps::R3Point const&) const
const RNScalar R3Ray::
T(const R3Point& point) const
{
    // Return parametric value of closest point on ray
    if (IsZero()) return 0.0;
    RNScalar denom = Vector().Dot(Vector());
    assert(RNIsNotZero(denom));
    R3Vector topoint = point - Start();
    return (Vector().Dot(topoint) / denom);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x3c1ae
jp 0x3c1ae
movsd 0x20(%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x3c1ae
jp 0x3c1ae
movsd 0x28(%rbx), %xmm2
ucomisd %xmm1, %xmm2
jne 0x3c1ae
jnp 0x3c1e7
leaq 0x18(%rbx), %r15
movq %r15, %rdi
movq %r15, %rsi
callq 0x3d252
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3c78e
movq %r15, %rdi
movq %r12, %rsi
callq 0x3d252
divsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Line.cpp
// Function: gaps::R3Line::R3Line(gaps::RNArray<gaps::R3Point*> const&)
R3Line::
R3Line(const RNArray<R3Point *>& points)
    : point(0, 0, 0),
      vector(0, 0, 0)
{
    // Check number of points
    if (points.NEntries() < 2) return;

    // Compute centroid
    point = R3Centroid(points);

    // Compute principle axes
    R3Triad triad = R3PrincipleAxes(point, points);

    // Select direction of most variation
    vector = triad[0];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x3c532
leaq 0x18(%r14), %r15
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x3cfc6
cmpl $0x2, 0xc(%rbx)
jl 0x3c392
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4c1ec
movq %r14, %rdi
movq %r12, %rsi
callq 0x3c89a
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4c299
movq %r15, %rdi
movq %r12, %rsi
callq 0x3d752
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Line.cpp
// Function: gaps::R3Line::R3Line(gaps::R3Point*, int)
R3Line::
R3Line(R3Point *points, int npoints)
    : point(0, 0, 0),
      vector(0, 0, 0)
{
    // Check number of points
    if (npoints < 2) return;

    // Compute centroid
    point = R3Centroid(npoints, points);

    // Compute principle axes
    R3Triad triad = R3PrincipleAxes(point, npoints, points);

    // Select direction of most variation
    vector = triad[0];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x3c532
leaq 0x18(%r14), %r15
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x3cfc6
cmpl $0x2, %ebp
jl 0x3c41f
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x4dab1
movq %r14, %rdi
movq %r12, %rsi
callq 0x3c89a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4db3b
movq %r15, %rdi
movq %r12, %rsi
callq 0x3d752
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq