LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::L2NormSquared() const
RNScalar R3Grid::
L2NormSquared(void) const
{
  // Return L2 norm of grid
  RNScalar sum = 0.0;
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    RNScalar value = *(grid_valuep++);
    sum += value * value;
  }
  return sum;
}

// Assembly:
movq 0x230(%rdi), %rax
movl 0x24c(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
xorpd %xmm0, %xmm0
cmpl %edx, %ecx
je 0x2bde8
movsd (%rax,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x2bdd2
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Cardinality() const
int R3Grid::
Cardinality(void) const
{
  // Return number of non-zero grid values
  int count = 0;
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    RNScalar value = *(grid_valuep++);
    if (value == 0.0) continue;
    count++;
  }
  return count;
}

// Assembly:
movq 0x230(%rdi), %rcx
movl 0x24c(%rdi), %edx
xorl %esi, %esi
testl %edx, %edx
cmovlel %esi, %edx
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpl %esi, %edx
je 0x2be1e
movsd (%rcx,%rsi,8), %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %rdi
subl %edi, %eax
incq %rsi
jmp 0x2be04
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::GridCentroid() const
R3Point R3Grid::
GridCentroid(void) const
{
  // Compute weighted sum
  RNScalar total_value = 0;
  R3Point centroid(0,0,0);
  RNScalar *grid_valuesp = grid_values;
  for (int k = 0; k < grid_resolution[2]; k++) {
    for (int j = 0; j < grid_resolution[1]; j++) {
      for (int i = 0; i < grid_resolution[0]; i++) {
        R3Vector position(i, j, k);
        RNScalar value = *(grid_valuesp++);
        centroid += value * position;
        total_value += value;
      }
    }
  }

  // Divide by total value
  if (total_value > 0) centroid /= total_value;

  // Return centroid
  return centroid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x37b4c
movq 0x230(%r14), %r13
xorl %eax, %eax
leaq 0x40(%rsp), %r15
leaq 0x28(%rsp), %r12
cmpl 0x240(%r14), %eax
jge 0x2c4a1
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %ecx, %ecx
movl %eax, 0x8(%rsp)
cmpl 0x23c(%r14), %ecx
jge 0x2c49a
movl %ecx, 0xc(%rsp)
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %ebp, %ebp
cmpl 0x238(%r14), %ebp
jge 0x2c48e
cvtsi2sd %ebp, %xmm0
movq %r15, %rdi
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x3830c
movsd (%r13), %xmm0
movsd %xmm0, 0x20(%rsp)
addq $0x8, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x38a02
movq %rbx, %rdi
movq %r12, %rsi
callq 0x37e9c
movsd (%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
incl %ebp
jmp 0x2c433
movl 0xc(%rsp), %ecx
incl %ecx
movl 0x8(%rsp), %eax
jmp 0x2c41a
incl %eax
jmp 0x2c3fd
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2c4bc
movapd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x38234
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Slice(int, int) const
R2Grid *R3Grid::
Slice(int dim, int grid_coordinate) const
{
  // Extract 2D grid along slice at given coordinate in given dimension

  // Compute parameters
  int dim1 = (dim+1)%3;
  int dim2 = (dim+2)%3;
  R3Box world_box = WorldBox();
  R2Box slice_box(world_box[0][dim1], world_box[0][dim2], world_box[1][dim1], world_box[1][dim2]);

  // Allocate 2D grid for slice
  R2Grid *slice = new R2Grid(grid_resolution[dim1], grid_resolution[dim2], slice_box);
  if (!slice) {
    RNFail("Unable to allocate slice\n");
    return NULL;
  }

  // Fill values
  for (int i = 0; i < grid_resolution[dim1]; i++) {
    for (int j = 0; j < grid_resolution[dim2]; j++) {
      RNScalar value = 0.0;
      if (dim == RN_X) value = GridValue(grid_coordinate, i, j);
      else if (dim == RN_Y) value = GridValue(j, grid_coordinate, i);
      else value = GridValue(i, j, grid_coordinate);
      slice->SetGridValue(i, j, value);
    }
  }

  // Return slice
  return slice;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leal 0x1(%r14), %eax
pushq $0x3
popq %rcx
cltd
idivl %ecx
movl %edx, %ebp
leal 0x2(%r14), %eax
cltd
idivl %ecx
movl %edx, %r12d
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x365d4
movslq %ebp, %rbp
movslq %r12d, %rax
movsd 0x20(%rsp,%rbp,8), %xmm0
movsd 0x38(%rsp,%rbp,8), %xmm2
movsd 0x20(%rsp,%rax,8), %xmm1
movq %rax, 0x10(%rsp)
movsd 0x38(%rsp,%rax,8), %xmm3
leaq 0x50(%rsp), %rdi
callq 0x5cb7a
movl $0xd0, %edi
callq 0xe450
movq %rax, %r12
movl 0x238(%r15,%rbp,4), %esi
movq 0x10(%rsp), %rax
movl 0x238(%r15,%rax,4), %edx
leaq 0x50(%rsp), %rcx
movq %r12, %rdi
callq 0x516fe
movl 0x238(%r15,%rbp,4), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movl %eax, 0xc(%rsp)
xorl %edx, %edx
cmpl 0xc(%rsp), %edx
je 0x2caac
movq 0x10(%rsp), %rax
movl 0x238(%r15,%rax,4), %esi
movq 0x230(%r15), %rdi
movl 0x248(%r15), %r13d
movl 0x244(%r15), %r9d
movl %r9d, %ecx
imull %ebx, %ecx
movl %r9d, %r10d
imull %edx, %r10d
movl %r13d, %r11d
imull %ebx, %r11d
addl %edx, %r11d
testl %esi, %esi
movl $0x0, %eax
cmovlel %eax, %esi
movl %r13d, %ebp
imull %edx, %ebp
addl %ecx, %ebp
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x2caa5
cmpl $0x1, %r14d
je 0x2ca6a
testl %r14d, %r14d
jne 0x2ca70
movl %r13d, %r8d
imull %ecx, %r8d
addl %ebx, %r8d
addl %r10d, %r8d
jmp 0x2ca7a
leal (%rcx,%rbp), %r8d
jmp 0x2ca7a
movl %r9d, %r8d
imull %ecx, %r8d
addl %r11d, %r8d
movslq %r8d, %r8
movsd (%rdi,%r8,8), %xmm0
movq 0xb8(%r12), %r8
movl 0xc8(%r12), %eax
imull %ecx, %eax
addl %edx, %eax
cltq
movsd %xmm0, (%r8,%rax,8)
incq %rcx
jmp 0x2ca4b
incl %edx
jmp 0x2c9f4
leaq 0x50(%rsp), %rdi
callq 0x5d2ee
leaq 0x18(%rsp), %rdi
callq 0x25832
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xd0, %esi
movq %r12, %rdi
callq 0xe460
jmp 0x2cae7
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x5d2ee
jmp 0x2caf6
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x25832
movq %rbx, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Abs()
void R3Grid::
Abs(void) 
{
  // Take the absolute value of every grid value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    *grid_valuep = fabs(*grid_valuep);
    grid_valuep++;
  }
}

// Assembly:
movq 0x230(%rdi), %rax
movl 0x24c(%rdi), %ecx
xorl %edx, %edx
movaps 0x66752(%rip), %xmm0    # 0x93270
cmpl %ecx, %edx
jge 0x2cb33
movsd (%rax,%rdx,8), %xmm1
andps %xmm0, %xmm1
movlps %xmm1, (%rax,%rdx,8)
incq %rdx
jmp 0x2cb1e
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Sqrt()
void R3Grid::
Sqrt(void) 
{
  // Take sqrt of every grid value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    *grid_valuep = sqrt(*grid_valuep);
    grid_valuep++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x230(%rdi), %r14
xorl %r15d, %r15d
xorpd %xmm1, %xmm1
cmpl 0x24c(%rbx), %r15d
jge 0x2cb79
movsd (%r14,%r15,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x2cb65
sqrtsd %xmm0, %xmm0
jmp 0x2cb6e
callq 0xe350
xorpd %xmm1, %xmm1
movsd %xmm0, (%r14,%r15,8)
incq %r15
jmp 0x2cb4a
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Square()
void R3Grid::
Square(void) 
{
  // Square every grid value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    *grid_valuep = (*grid_valuep) * (*grid_valuep);
    grid_valuep++;
  }
}

// Assembly:
movq 0x230(%rdi), %rax
movl 0x24c(%rdi), %ecx
xorl %edx, %edx
cmpl %ecx, %edx
jge 0x2cba6
movsd (%rax,%rdx,8), %xmm0
mulsd %xmm0, %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x2cb8f
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Negate()
void R3Grid::
Negate(void) 
{
  // Negate every grid value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    *grid_valuep = -(*grid_valuep);
    grid_valuep++;
  }
}

// Assembly:
movq 0x230(%rdi), %rax
movl 0x24c(%rdi), %ecx
xorl %edx, %edx
movaps 0x66472(%rip), %xmm0    # 0x93030
cmpl %ecx, %edx
jge 0x2cbd3
movsd (%rax,%rdx,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rax,%rdx,8)
incq %rdx
jmp 0x2cbbe
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Invert()
void R3Grid::
Invert(void) 
{
  // Invert every grid value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    if (RNIsNotZero(*grid_valuep, 1.0E-20)) *grid_valuep = 1.0/(*grid_valuep);
    grid_valuep++;
  }
}

// Assembly:
movq 0x230(%rdi), %rax
movl 0x24c(%rdi), %ecx
xorl %edx, %edx
movapd 0x66685(%rip), %xmm0    # 0x93270
movsd 0x6735d(%rip), %xmm1    # 0x93f50
movsd 0x6640d(%rip), %xmm2    # 0x93008
cmpl %ecx, %edx
jge 0x2cc24
movsd (%rax,%rdx,8), %xmm3
movapd %xmm3, %xmm4
andpd %xmm0, %xmm4
ucomisd %xmm1, %xmm4
jbe 0x2cc1f
movapd %xmm2, %xmm4
divsd %xmm3, %xmm4
movsd %xmm4, (%rax,%rdx,8)
incq %rdx
jmp 0x2cbfb
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Transpose()
void R3Grid::
Transpose(void)
{
  // Transpose values
  R3Grid copy(*this);
  int xres = XResolution();
  int yres = YResolution();
  int zres = ZResolution();
  for (int iz = 0; iz < zres; iz++) {
    for (int iy = 0; iy < yres; iy++) {
      for (int ix = 0; ix < xres; ix++) {
        RNScalar value = copy.GridValue(xres-1 - ix, yres-1 - iy, zres-1 - iz);
        SetGridValue(ix, iy, iz, value);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2bbaa
movl 0x238(%rbx), %eax
movl 0x23c(%rbx), %ecx
movl 0x240(%rbx), %edx
xorl %esi, %esi
testl %eax, %eax
movl $0x0, %edi
cmovgl %eax, %edi
testl %ecx, %ecx
movl $0x0, %r8d
cmovgl %ecx, %r8d
testl %edx, %edx
movl $0x0, %r9d
cmovgl %edx, %r9d
decl %eax
decl %edx
decl %ecx
cmpl %r9d, %esi
je 0x2cd0c
xorl %r10d, %r10d
movl %ecx, %r11d
cmpl %r8d, %r10d
je 0x2cd03
movq 0x238(%rsp), %r14
movq 0x230(%rbx), %r15
movl 0x250(%rsp), %ebp
imull %edx, %ebp
addl %eax, %ebp
movl 0x24c(%rsp), %r12d
imull %r11d, %r12d
addl %ebp, %r12d
movl 0x248(%rbx), %ebp
imull %esi, %ebp
movl 0x244(%rbx), %r13d
imull %r10d, %r13d
addl %ebp, %r13d
movq %rdi, %rbp
subq $0x1, %rbp
jb 0x2ccfb
movslq %r12d, %r12
movsd (%r14,%r12,8), %xmm0
movslq %r13d, %r13
movsd %xmm0, (%r15,%r13,8)
decl %r12d
incl %r13d
jmp 0x2ccdb
incl %r10d
decl %r11d
jmp 0x2cc92
incl %esi
decl %edx
jmp 0x2cc83
leaq 0x8(%rsp), %rdi
callq 0x2bc02
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Threshold(double, double, double)
void R3Grid::
Threshold(RNScalar threshold, RNScalar low, RNScalar high) 
{
  // Set grid value to low (high) if less/equal (greater) than threshold
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    if (*grid_valuep <= threshold) {
      if (low != R3_GRID_KEEP_VALUE) *grid_valuep = low;
    }
    else {
      if (high != R3_GRID_KEEP_VALUE) *grid_valuep = high;
    }
    grid_valuep++;
  }
}

// Assembly:
movq 0x230(%rdi), %rax
movl 0x24c(%rdi), %ecx
xorl %edx, %edx
movsd 0x66cf1(%rip), %xmm3    # 0x93f58
cmpl %ecx, %edx
jge 0x2d292
ucomisd (%rax,%rdx,8), %xmm0
jae 0x2d27c
ucomisd %xmm3, %xmm2
movapd %xmm2, %xmm4
jmp 0x2d284
ucomisd %xmm3, %xmm1
movapd %xmm1, %xmm4
jne 0x2d288
jnp 0x2d28d
movsd %xmm4, (%rax,%rdx,8)
incq %rdx
jmp 0x2d267
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::GradientMagnitude()
void R3Grid::
GradientMagnitude(void)
{
  // Compute magnitude of gradient
  R3Grid gx(*this); gx.Gradient(RN_X);
  R3Grid gy(*this); gy.Gradient(RN_Y);
  R3Grid gz(*this); gz.Gradient(RN_Z);
  for (int i = 0; i < grid_size; i++) {
    RNScalar x = gx.GridValue(i);
    RNScalar y = gy.GridValue(i);
    RNScalar z = gz.GridValue(i);
    grid_values[i] = sqrt(x*x + y*y + z*z);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x6f8, %rsp            # imm = 0x6F8
movq %rdi, %rbx
leaq 0x4a8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2bbaa
leaq 0x660e5(%rip), %rsi     # 0x94070
movq %r14, %rdi
callq 0x2dc3a
leaq 0x258(%rsp), %rdi
movq %rbx, %rsi
callq 0x2bbaa
leaq 0x661a6(%rip), %rsi     # 0x94150
leaq 0x258(%rsp), %rdi
callq 0x2dc3a
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2bbaa
leaq 0x66265(%rip), %rsi     # 0x94230
leaq 0x8(%rsp), %rdi
callq 0x2dc3a
movl 0x24c(%rbx), %eax
movq 0x6d8(%rsp), %rcx
movq 0x488(%rsp), %rdx
movq 0x238(%rsp), %rsi
movq 0x230(%rbx), %rdi
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
cmpq %r8, %rax
je 0x2e03d
movsd (%rcx,%r8,8), %xmm0
movsd (%rdx,%r8,8), %xmm1
movsd (%rsi,%r8,8), %xmm2
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
addsd %xmm0, %xmm2
sqrtsd %xmm2, %xmm0
movsd %xmm0, (%rdi,%r8,8)
incq %r8
jmp 0x2e003
leaq 0x8(%rsp), %rdi
callq 0x2bc02
leaq 0x258(%rsp), %rdi
callq 0x2bc02
leaq 0x4a8(%rsp), %rdi
callq 0x2bc02
addq $0x6f8, %rsp            # imm = 0x6F8
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2bc02
jmp 0x2e080
jmp 0x2e07d
movq %rax, %rbx
leaq 0x258(%rsp), %rdi
callq 0x2bc02
jmp 0x2e094
jmp 0x2e091
movq %rax, %rbx
leaq 0x4a8(%rsp), %rdi
callq 0x2bc02
movq %rbx, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::MaskNonMinima(double)
void R3Grid::
MaskNonMinima(RNLength grid_radius)
{
  // Create grid with local minima
  R3Grid copy(*this);
  copy.MinFilter(grid_radius);

  // Mask values that are not minima
  for (int i = 0; i < grid_size; i++) {
    if (grid_values[i] > copy.grid_values[i]) grid_values[i] = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2bbaa
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x36674
movl 0x24c(%rbx), %eax
movq 0x230(%rbx), %rcx
movq 0x238(%rsp), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
cmpq %rsi, %rax
je 0x2e45e
movsd (%rcx,%rsi,8), %xmm0
ucomisd (%rdx,%rsi,8), %xmm0
jbe 0x2e459
andq $0x0, (%rcx,%rsi,8)
incq %rsi
jmp 0x2e443
leaq 0x8(%rsp), %rdi
callq 0x2bc02
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2bc02
movq %rbx, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::MaskNonMaxima(double)
void R3Grid::
MaskNonMaxima(RNLength grid_radius)
{
  // Create grid with local maxima
  R3Grid copy(*this);
  copy.MaxFilter(grid_radius);

  // Mask values that are not maxima
  for (int i = 0; i < grid_size; i++) {
    if (grid_values[i] < copy.grid_values[i]) grid_values[i] = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2bbaa
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x3667c
movl 0x24c(%rbx), %eax
movq 0x230(%rbx), %rcx
movq 0x238(%rsp), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
cmpq %rsi, %rax
je 0x2e4ee
movsd (%rdx,%rsi,8), %xmm0
ucomisd (%rcx,%rsi,8), %xmm0
jbe 0x2e4e9
andq $0x0, (%rcx,%rsi,8)
incq %rsi
jmp 0x2e4d3
leaq 0x8(%rsp), %rdi
callq 0x2bc02
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2bc02
movq %rbx, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Clear(double)
void R3Grid::
Clear(RNScalar value) 
{
  // Set all grid values to value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) 
    *(grid_valuep++) = value;
}

// Assembly:
movq 0x230(%rdi), %rax
movl 0x24c(%rdi), %ecx
xorl %edx, %edx
cmpl %ecx, %edx
jge 0x2e8e1
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x2e8d3
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Substitute(double, double)
void R3Grid::
Substitute(RNScalar old_value, RNScalar new_value) 
{
  // Replace all instances of old_value with new_value
  for (int i = 0; i < grid_size; i++) {
    if (grid_values[i] == old_value) {
      grid_values[i] = new_value;
    }
  }
}

// Assembly:
movslq 0x24c(%rdi), %rax
movq 0x230(%rdi), %rcx
xorl %edx, %edx
cmpq %rax, %rdx
jge 0x2e90e
movsd (%rcx,%rdx,8), %xmm2
ucomisd %xmm0, %xmm2
jne 0x2e909
jp 0x2e909
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
jmp 0x2e8f2
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Add(double)
void R3Grid::
Add(RNScalar value) 
{
  // Add value to all grid values 
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) 
    *(grid_valuep++) += value;
}

// Assembly:
movq 0x230(%rdi), %rax
movl 0x24c(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpl %edx, %ecx
je 0x2e93b
movsd (%rax,%rdx,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
jmp 0x2e924
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Multiply(double)
void R3Grid::
Multiply(RNScalar value) 
{
  // Multiply grid values by value
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) 
    *(grid_valuep++) *= value;
}

// Assembly:
movq 0x230(%rdi), %rax
movl 0x24c(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpl %edx, %ecx
je 0x2ec8f
movsd (%rax,%rdx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
jmp 0x2ec78
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Divide(gaps::R3Grid const&)
void R3Grid::
Divide(const R3Grid& grid) 
{
  // Resolutions 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]);

  // Divide passed grid values by corresponding entries of this grid
  for (int i = 0; i < grid_size; i++) {
    RNScalar value = grid.grid_values[i];
    if (RNIsNotZero(value, 1.0E-20)) grid_values[i] /= value;
  }
}

// Assembly:
movslq 0x24c(%rdi), %rax
movq 0x230(%rsi), %rcx
movq 0x230(%rdi), %rdx
xorl %esi, %esi
movapd 0x6458f(%rip), %xmm0    # 0x93270
movsd 0x65267(%rip), %xmm1    # 0x93f50
cmpq %rax, %rsi
jge 0x2ed14
movsd (%rcx,%rsi,8), %xmm2
movapd %xmm2, %xmm3
andpd %xmm0, %xmm3
ucomisd %xmm1, %xmm3
jbe 0x2ed0f
movsd (%rdx,%rsi,8), %xmm3
divsd %xmm2, %xmm3
movsd %xmm3, (%rdx,%rsi,8)
incq %rsi
jmp 0x2ece9
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Min(gaps::R3Grid const&)
void R3Grid::
Min(const R3Grid& grid) 
{
  // Resolutions 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]);

  // Keep minimum value
  for (int i = 0; i < grid_size; i++) {
    RNScalar value0 = grid_values[i];
    RNScalar value1 = grid.grid_values[i];
    if (value1 < value0) grid_values[i] = value1;
  }
}

// Assembly:
movslq 0x24c(%rdi), %rax
movq 0x230(%rdi), %rcx
movq 0x230(%rsi), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x2ed4c
movsd (%rcx,%rsi,8), %xmm1
movsd (%rdx,%rsi,8), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x2ed47
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
jmp 0x2ed2d
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Max(gaps::R3Grid const&)
void R3Grid::
Max(const R3Grid& grid) 
{
  // Resolutions 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]);

  // Keep maximum value
  for (int i = 0; i < grid_size; i++) {
    RNScalar value0 = grid_values[i];
    RNScalar value1 = grid.grid_values[i];
    if (value1 > value0) grid_values[i] = value1;
  }
}

// Assembly:
movslq 0x24c(%rdi), %rax
movq 0x230(%rdi), %rcx
movq 0x230(%rsi), %rdx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x2ed80
movsd (%rdx,%rsi,8), %xmm0
ucomisd (%rcx,%rsi,8), %xmm0
jbe 0x2ed7b
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
jmp 0x2ed65
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Pow(double)
void R3Grid::
Pow(RNScalar exponent) 
{
  // Raise each grid value to exponent
  RNScalar *grid_valuep = grid_values;
  for (int i = 0; i < grid_size; i++) {
    RNScalar value = *grid_valuep;
    if (value < 0) value = -value;
    *(grid_valuep++) = pow(value, exponent);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movq 0x230(%rdi), %r14
xorl %r15d, %r15d
cmpl 0x24c(%rbx), %r15d
jge 0x2edd3
movsd (%r14,%r15,8), %xmm1
movapd %xmm1, %xmm0
xorpd 0x64277(%rip), %xmm0    # 0x93030
maxsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm1
callq 0xe800
movsd %xmm0, (%r14,%r15,8)
incq %r15
jmp 0x2ed9e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::SetWorldToGridTransformation(gaps::R3Affine const&)
void R3Grid::
SetWorldToGridTransformation(const R3Affine& affine)
{
  // Set transformations
  world_to_grid_transform = affine;
  grid_to_world_transform = affine.Inverse();
  world_to_grid_scale_factor = affine.ScaleFactor();
  grid_to_world_scale_factor = (world_to_grid_scale_factor != 0) ? 1 / world_to_grid_scale_factor : 1.0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
addq $0x110, %rdi            # imm = 0x110
callq 0x21db8
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x366c6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21db8
movq %rsp, %rdi
callq 0x276ee
movq (%r14), %rax
movq %r14, %rdi
callq *0xc0(%rax)
movsd %xmm0, 0x220(%rbx)
movsd 0x63a3d(%rip), %xmm1    # 0x93008
movapd %xmm1, %xmm2
divsd %xmm0, %xmm2
xorpd %xmm3, %xmm3
cmpneqsd %xmm0, %xmm3
andpd %xmm3, %xmm2
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movlpd %xmm3, 0x228(%rbx)
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x276ee
movq %rbx, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::SignedDistanceTransform()
void R3Grid::
SignedDistanceTransform(void)
{
  // Compute distance from boundary into interior (negative) and into exterior (positive)
  R3Grid copy(*this);
  SquaredDistanceTransform();
  Sqrt();
  copy.Threshold(0, 1, 0);
  copy.Substitute(R2_GRID_UNKNOWN_VALUE, 1);
  copy.SquaredDistanceTransform();
  copy.Sqrt();
  Subtract(copy);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2bbaa
movq %rbx, %rdi
callq 0x2cda0
movq %rbx, %rdi
callq 0x2cb34
leaq 0x8(%rsp), %r14
movsd 0x639c1(%rip), %xmm1    # 0x93008
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
movq %r14, %rdi
callq 0x2d250
movsd 0x6490b(%rip), %xmm0    # 0x93f68
movq %r14, %rdi
movsd 0x639a0(%rip), %xmm1    # 0x93008
callq 0x2e8e2
movq %r14, %rdi
callq 0x2cda0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2cb34
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ec32
movq %r14, %rdi
callq 0x2bc02
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2bc02
movq %rbx, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::Gauss(double, int)
void R3Grid::
Gauss(RNLength sigma, RNBoolean square)
{
  // Check sigma
  if (sigma == 0.0) return;    

  // Replace each grid value with Gaussian of what was there before
  const RNScalar sqrt_two_pi = sqrt(RN_TWO_PI);
  RNScalar a = sqrt_two_pi * sigma;
  RNScalar fac = 1.0 / (a * a * a);
  RNScalar denom = -2.0 * sigma * sigma;
  if (RNIsZero(denom, 1.0E-6)) return;
  for (int i = 0; i < grid_size; i++) {
    RNScalar value = grid_values[i];
    if (square) value *= value;
    grid_values[i] = fac * exp( value / denom );
  }
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2f6c3
jp 0x2f6c3
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movapd %xmm0, %xmm3
movq %rdi, %r14
leaq 0x6b88c(%rip), %rax     # 0x9af68
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x2f6ec
sqrtsd %xmm0, %xmm0
jmp 0x2f6fb
movsd %xmm3, (%rsp)
callq 0xe350
movsd (%rsp), %xmm3
movsd 0x63afd(%rip), %xmm2    # 0x93200
mulsd %xmm3, %xmm2
mulsd %xmm3, %xmm2
movapd 0x63b5d(%rip), %xmm1    # 0x93270
movapd %xmm2, (%rsp)
andpd %xmm2, %xmm1
movsd 0x63abc(%rip), %xmm2    # 0x931e0
ucomisd %xmm1, %xmm2
jae 0x2f792
mulsd %xmm3, %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd 0x638c6(%rip), %xmm0    # 0x93008
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
xorl %r15d, %r15d
movslq 0x24c(%r14), %rax
cmpq %rax, %r15
jge 0x2f792
movq 0x230(%r14), %rax
movsd (%rax,%r15,8), %xmm0
testl %ebx, %ebx
je 0x2f770
mulsd %xmm0, %xmm0
divsd (%rsp), %xmm0
callq 0xe820
mulsd 0x18(%rsp), %xmm0
movq 0x230(%r14), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
jmp 0x2f74f
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::RasterizeGridValue(int, int, int, double, int)
void R3Grid::
RasterizeGridValue(int ix, int iy, int iz, RNScalar value, int operation)
{
  // Check if within bounds
  if ((ix < 0) || (ix > grid_resolution[0]-1)) return;
  if ((iy < 0) || (iy > grid_resolution[1]-1)) return;
  if ((iz < 0) || (iz > grid_resolution[2]-1)) return;

  // Update grid based on operation
  if (operation == R3_GRID_ADD_OPERATION) AddGridValue(ix, iy, iz, value);
  else if (operation == R3_GRID_SUBTRACT_OPERATION) AddGridValue(ix, iy, iz, -value);
  else if (operation == R3_GRID_REPLACE_OPERATION) SetGridValue(ix, iy, iz, value);
  else RNAbort("Unrecognized grid rasterization operation\n");
}

// Assembly:
testl %esi, %esi
js 0x30266
testl %edx, %edx
js 0x30266
cmpl %esi, 0x238(%rdi)
jle 0x30266
testl %ecx, %ecx
js 0x30266
cmpl %edx, 0x23c(%rdi)
jle 0x30266
cmpl %ecx, 0x240(%rdi)
jle 0x30266
cmpl $0x2, %r8d
je 0x30267
cmpl $0x1, %r8d
je 0x3023c
testl %r8d, %r8d
jne 0x30289
movq 0x230(%rdi), %rax
imull 0x248(%rdi), %ecx
imull 0x244(%rdi), %edx
addl %esi, %ecx
addl %edx, %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
jmp 0x30283
movq 0x230(%rdi), %rax
imull 0x248(%rdi), %ecx
imull 0x244(%rdi), %edx
addl %esi, %ecx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rcx,8)
retq
movq 0x230(%rdi), %rax
imull 0x248(%rdi), %ecx
imull 0x244(%rdi), %edx
addl %esi, %ecx
addl %edx, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
retq
leaq 0x68492(%rip), %rdi     # 0x98722
xorl %eax, %eax
jmp 0x680f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Grid.cpp
// Function: gaps::R3Grid::RasterizeGridBox(gaps::R3Box const&, double, int)
void R3Grid::
RasterizeGridBox(const R3Box& box, RNScalar value, int operation)
{
  // Get corner coordinates
  int ix1 = (int) (box.XMin() + 0.5);
  int ix2 = (int) (box.XMax() + 0.5);
  int iy1 = (int) (box.YMin() + 0.5);
  int iy2 = (int) (box.YMax() + 0.5);
  int iz1 = (int) (box.ZMin() + 0.5);
  int iz2 = (int) (box.ZMax() + 0.5);

  // Check for intersection
  if (ix1 >= XResolution()) return;
  if (iy1 >= YResolution()) return;
  if (iz1 >= ZResolution()) return;
  if (ix2 < 0) return;
  if (iy2 < 0) return;
  if (iz2 < 0) return;

  // Clip coordinates
  if (ix1 < 0) ix1 = 0;
  if (iy1 < 0) iy1 = 0;
  if (iz1 < 0) iz1 = 0;
  if (ix2 >= XResolution()) ix2 = XResolution()-1;
  if (iy2 >= YResolution()) iy2 = YResolution()-1;
  if (iz2 >= ZResolution()) iz2 = ZResolution()-1;

  // Add value to grid entries
  for (int iz = iz1; iz <= iz2; iz++) {
    for (int iy = iy1; iy <= iy2; iy++) {
      for (int ix = ix1; ix <= ix2; ix++) {
        RasterizeGridValue(ix, iy, iz, value, operation);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movsd 0x619a0(%rip), %xmm1    # 0x93010
movsd 0x8(%rsi), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl 0x238(%rdi), %eax
cmpl %ecx, %eax
jle 0x316ff
movl %edx, %ebx
movq %rdi, %r14
movl %ecx, %r11d
movsd 0x10(%rsi), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movl 0x23c(%rdi), %ecx
cmpl %edx, %ecx
jle 0x316ff
movl %edx, %r15d
movupd 0x20(%rsi), %xmm0
addpd 0x6198a(%rip), %xmm0    # 0x93040
cvttpd2dq %xmm0, %xmm0
movsd 0x18(%rsi), %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %edi
addsd 0x30(%rsi), %xmm1
cvttsd2si %xmm1, %edx
movl 0x240(%r14), %esi
cmpl %edi, %esi
setle %r8b
pshufd $0x50, %xmm0, %xmm1     # xmm1 = xmm0[0,0,1,1]
movmskpd %xmm1, %r9d
orb %r9b, %r8b
shrb %r9b
testl %edx, %edx
sets %r10b
orb %r9b, %r10b
orb %r8b, %r10b
testb $0x1, %r10b
je 0x3170e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
testl %r11d, %r11d
cmovlel %ebp, %r11d
movl %r11d, 0xc(%rsp)
testl %r15d, %r15d
cmovlel %ebp, %r15d
movl %r15d, (%rsp)
testl %edi, %edi
cmovgl %edi, %ebp
movd %xmm0, %edi
leal -0x1(%rax), %r13d
cmpl %edi, %eax
cmovgl %edi, %r13d
pshufd $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movd %xmm0, %eax
leal -0x1(%rcx), %edi
cmpl %eax, %ecx
cmovgl %eax, %edi
movl %edi, 0x8(%rsp)
leal -0x1(%rsi), %eax
cmpl %edx, %esi
cmovgl %edx, %eax
movl %eax, 0x4(%rsp)
cmpl 0x4(%rsp), %ebp
jg 0x316ff
movl (%rsp), %r15d
movl 0xc(%rsp), %r12d
cmpl 0x8(%rsp), %r15d
jle 0x3178f
jmp 0x31799
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
movl %ebp, %ecx
movq 0x10(%rsp), %xmm0
movl %ebx, %r8d
callq 0x301e4
incl %r12d
cmpl %r13d, %r12d
jle 0x31773
incl %r15d
jmp 0x31765
incl %ebp
jmp 0x3175b
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x24c(%rdi), %eax
movq 0x230(%rdi), %rcx
movq 0x230(%rsi), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
xorpd %xmm0, %xmm0
cmpq %rsi, %rax
je 0x317d5
movsd (%rcx,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
jmp 0x317bd
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x24c(%rdi), %eax
movq 0x230(%rdi), %rcx
movq 0x230(%rsi), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
xorpd %xmm0, %xmm0
movapd 0x61a73(%rip), %xmm1    # 0x93270
cmpq %rsi, %rax
je 0x31819
movsd (%rcx,%rsi,8), %xmm2
subsd (%rdx,%rsi,8), %xmm2
andpd %xmm1, %xmm2
addsd %xmm2, %xmm0
incq %rsi
jmp 0x317fd
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x24c(%rdi), %eax
movq 0x230(%rdi), %rcx
movq 0x230(%rsi), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
xorpd %xmm0, %xmm0
cmpq %rsi, %rax
je 0x31855
movsd (%rcx,%rsi,8), %xmm1
subsd (%rdx,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rsi
jmp 0x31839
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
sqrtsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0xe4e0
testq %rax, %rax
je 0x31b2a
movq %rax, %r15
leaq 0x66ca0(%rip), %rsi     # 0x9874d
pushq $0x4
popq %rdx
movq %rax, %rdi
callq 0xe220
testl %eax, %eax
je 0x31b43
leaq 0x66c8b(%rip), %rsi     # 0x98752
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0xe220
testl %eax, %eax
je 0x31b53
leaq 0x66c7a(%rip), %rsi     # 0x98757
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0xe220
testl %eax, %eax
je 0x31b63
leaq 0x66c69(%rip), %rsi     # 0x9875c
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0xe220
testl %eax, %eax
je 0x31bb5
cmpb $0x2e, (%r15)
jne 0x31b73
cmpb $0x64, 0x1(%r15)
jne 0x31b73
cmpb $0x78, 0x2(%r15)
jne 0x31b73
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x329fe
leaq 0x617b1(%rip), %rdi     # 0x932e2
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 0x31be6
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x31c3a
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x321f2
leaq 0x66be7(%rip), %rsi     # 0x98761
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0xe220
testl %eax, %eax
je 0x31bc5
leaq 0x66bd6(%rip), %rsi     # 0x98766
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0xe220
testl %eax, %eax
je 0x31bd5
leaq 0x6178f(%rip), %rdi     # 0x93335
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x681ca
jmp 0x31b3b
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x32360
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x32dd0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x330f4
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x61963(%rip), %rsi     # 0x9355b
movq %rbx, %rdi
callq 0xe550
testq %rax, %rax
je 0x31c21
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x34960
movl %eax, %ebx
movq %r15, %rdi
callq 0xe440
movl %ebx, %eax
jmp 0x31c34
leaq 0x66b86(%rip), %rdi     # 0x987ae
movq %rbx, %rsi
xorl %eax, %eax
callq 0x681ca
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0xe4e0
testq %rax, %rax
je 0x33be0
movq %rax, %r15
leaq 0x64ba0(%rip), %rsi     # 0x9874d
pushq $0x4
popq %rdx
movq %rax, %rdi
callq 0xe220
testl %eax, %eax
je 0x33c3b
cmpb $0x2e, (%r15)
jne 0x33bf3
cmpb $0x64, 0x1(%r15)
jne 0x33bf3
cmpb $0x78, 0x2(%r15)
jne 0x33bf3
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x33cc6
leaq 0x5f6fb(%rip), %rdi     # 0x932e2
movq %rbx, %rsi
xorl %eax, %eax
callq 0xe070
jmp 0x33c33
leaq 0x64b6c(%rip), %rsi     # 0x98766
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0xe220
testl %eax, %eax
je 0x33c4b
leaq 0x64b63(%rip), %rsi     # 0x98773
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0xe220
testl %eax, %eax
je 0x33c62
leaq 0x64b52(%rip), %rdi     # 0x98778
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x681ca
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x33c72
leaq 0x64b19(%rip), %rdx     # 0x9876b
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x33e7e
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x347be
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5fdad(%rip), %rsi     # 0x93a31
movq %rbx, %rdi
callq 0xe550
testq %rax, %rax
je 0x33cad
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x34baa
movl %eax, %ebx
movq %r15, %rdi
callq 0xe440
movl %ebx, %eax
jmp 0x33cc0
leaq 0x64afa(%rip), %rdi     # 0x987ae
movq %rbx, %rsi
xorl %eax, %eax
callq 0x681ca
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x63f90(%rip), %rsi     # 0x98769
movq %r15, %rdi
callq 0xe550
testq %rax, %rax
je 0x3493b
movq %rax, %r14
xorl %r15d, %r15d
xorpd %xmm1, %xmm1
xorl %ebp, %ebp
cmpl 0x240(%rbx), %ebp
jge 0x3492b
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rsp)
xorl %r12d, %r12d
cmpl 0x23c(%rbx), %r12d
jge 0x34924
cvtsi2sd %r12d, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r13d, %r13d
cmpl 0x238(%rbx), %r13d
jge 0x3491c
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
ucomisd %xmm1, %xmm0
jbe 0x34914
cvtsi2sd %r13d, %xmm0
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm1
movsd (%rsp), %xmm2
callq 0x31a5e
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
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), %xmm3
subq $0x8, %rsp
movq %r14, %rdi
leaq 0x64b99(%rip), %rsi     # 0x99464
leaq 0x64bd7(%rip), %rdx     # 0x994a9
movl %r15d, %ecx
leaq 0x64bd4(%rip), %r8      # 0x994b0
pushq $0x20
popq %r9
movaps %xmm3, %xmm4
movb $0x5, %al
leaq 0x5ed1d(%rip), %r10     # 0x93609
pushq %r10
pushq $0x20
pushq %r15
leaq 0x64bbd(%rip), %r10     # 0x994b6
pushq %r10
leaq 0x64bb0(%rip), %r10     # 0x994b2
pushq %r10
callq 0xe6a0
xorpd %xmm1, %xmm1
addq $0x30, %rsp
incl %r15d
incl %r13d
jmp 0x34829
incl %r12d
jmp 0x3480e
incl %ebp
jmp 0x347f6
movq %r14, %rdi
callq 0xe440
movl 0x24c(%rbx), %ebx
jmp 0x3494e
leaq 0x5ea28(%rip), %rdi     # 0x9336a
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x681ca
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x34bca
movq 0xa53b9(%rip), %rax     # 0xd9f80
movq (%rax), %r14
leaq 0x238(%rbx), %rdi
pushq $0x4
popq %rsi
pushq $0x3
popq %rdx
movq %r14, %rcx
callq 0xe8e0
cmpq $0x3, %rax
jne 0x34c24
xorl %ebp, %ebp
leaq 0x4(%rsp), %r15
pushq $0x4
popq %r12
pushq $0x1
popq %r13
cmpl $0x10, %ebp
je 0x34c2d
cvtsd2ss 0x118(%rbx,%rbp,8), %xmm0
movss %xmm0, 0x4(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xe8e0
cmpq $0x1, %rax
jne 0x34c6d
incq %rbp
jmp 0x34bf4
leaq 0x63c43(%rip), %rdi     # 0x9886e
jmp 0x34c7d
movq 0x230(%rbx), %r15
xorl %r12d, %r12d
pushq $0x1
popq %r13
movl 0x24c(%rbx), %ebp
cmpl %ebp, %r12d
jge 0x34c86
cvtsd2ss (%r15,%r12,8), %xmm0
movss %xmm0, (%rsp)
movq %rsp, %rdi
pushq $0x4
popq %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xe8e0
cmpq $0x1, %rax
jne 0x34c76
incq %r12
jmp 0x34c3b
leaq 0x63c1d(%rip), %rdi     # 0x98891
jmp 0x34c7d
leaq 0x63c48(%rip), %rdi     # 0x988c5
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x681ca
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_O2/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
movq %rsi, %r14
xorl %ebx, %ebx
testl %edx, %edx
movl $0x0, %r12d
movl %edx, 0xc(%rsp)
cmovgl %edx, %r12d
movq %rdi, %r15
pushq $0x8
popq %r13
pushq $0x1
popq %rbp
cmpq %rbx, %r12
je 0x34cf3
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0xe6f0
cmpq $0x1, %rax
jne 0x34cf3
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%r14,%rbx,8)
incq %rbx
jmp 0x34cc4
movslq 0xc(%rsp), %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
setge %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %ebx
movl %edx, 0xc(%rsp)
cmovgl %edx, %ebx
movq %rdi, %r15
pushq $0x8
popq %r13
pushq $0x1
popq %rbp
movq %rcx, %r12
cmpq %rcx, %rbx
je 0x34d6c
movsd (%r14,%r12,8), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0xe8e0
leaq 0x1(%r12), %rcx
cmpq $0x1, %rax
je 0x34d3a
movslq 0xc(%rsp), %rcx
xorl %eax, %eax
cmpq %rcx, %r12
setge %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq