LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/src/OutputFile.cpp
// Function: OutputFile::setUp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void OutputFile::setUp(const string &file_name)
{
	this->setUp();

	this->out_file.open(file_name.c_str());
	
	if (!this->out_file.is_open())
	{
		exit(1);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2712
movq (%rbx), %rsi
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x2030
addq $0x70, %r14
movq %r14, %rdi
callq 0x2040
testb %al, %al
je 0x278f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x1
popq %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/src/OutputFile.cpp
// Function: OutputFile::writeHeaders(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void OutputFile::writeHeaders(const vector<string> &headers)
{
	sem_wait(&(this->lock));
	for (uint32_t i = 0; i < headers.size(); i++)
	{
		this->out_file << headers[i];
		if ( (headers[i].size() > 0) && (headers[i].at(headers[i].size() - 1) != '\n') )
		{
			this->out_file << endl;
		}
	}
	sem_post(&(this->lock));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x200(%rdi), %r14
movq %r14, %rdi
callq 0x20c0
xorl %r12d, %r12d
movl %r12d, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x2935
movq %r12, %r13
shlq $0x5, %r13
addq %r13, %rsi
movq %r15, %rdi
callq 0x2140
movq (%rbx), %rdi
movq 0x8(%rdi,%r13), %rsi
testq %rsi, %rsi
je 0x2930
addq %r13, %rdi
decq %rsi
callq 0x2170
cmpb $0xa, (%rax)
je 0x2930
movq %r15, %rdi
callq 0x20a0
incl %r12d
jmp 0x28e3
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/src/OutputFile.cpp
// Function: OutputFile::changeFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void OutputFile::changeFile(const string &file_name)
{
	sem_wait(&(this->lock));
	if (this->out_file.is_open())
	{
		this->out_file.close();
	}
	this->out_file.open(file_name.c_str());
	if (!this->out_file.is_open())
	{
		exit(1);
	}
	sem_post(&(this->lock));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
leaq 0x200(%rdi), %rbx
movq %rbx, %rdi
callq 0x20c0
leaq 0x70(%r15), %r14
movq %r14, %rdi
callq 0x2040
testb %al, %al
je 0x2995
movq %r15, %rdi
callq 0x21a0
movq (%r12), %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2040
testb %al, %al
je 0x29c3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21e0
pushq $0x1
popq %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/msh2grd/../../pkgs/R3Shapes/R3Grid.h
// Function: gaps::R3Grid::RasterizeGridTriangle(gaps::R3Point const&, gaps::R3Point const&, gaps::R3Point const&, double, int)
inline void R3Grid::
RasterizeGridTriangle(const R3Point& p1, const R3Point& p2, const R3Point& p3, RNScalar value, int operation)
{
  // Splat value everywhere inside grid triangle
  int i1[3] = { (int) (p1[0] + 0.5), (int) (p1[1] + 0.5), (int) (p1[2] + 0.5) };
  int i2[3] = { (int) (p2[0] + 0.5), (int) (p2[1] + 0.5), (int) (p2[2] + 0.5) };
  int i3[3] = { (int) (p3[0] + 0.5), (int) (p3[1] + 0.5), (int) (p3[2] + 0.5) };
  RasterizeGridTriangle(i1, i2, i3, value, operation);
}

// Assembly:
subq $0x38, %rsp
movq %rsi, %rax
movupd (%rsi), %xmm1
movapd 0x8230f(%rip), %xmm2    # 0x93040
addpd %xmm2, %xmm1
cvttpd2dq %xmm1, %xmm1
leaq 0x28(%rsp), %rsi
movlpd %xmm1, (%rsi)
movsd 0x822c6(%rip), %xmm1    # 0x93010
movsd 0x10(%rax), %xmm3
addsd %xmm1, %xmm3
cvttsd2si %xmm3, %eax
movl %eax, 0x8(%rsi)
movupd (%rdx), %xmm3
addpd %xmm2, %xmm3
cvttpd2dq %xmm3, %xmm3
leaq 0x18(%rsp), %rax
movlpd %xmm3, (%rax)
movsd 0x10(%rdx), %xmm3
addsd %xmm1, %xmm3
cvttsd2si %xmm3, %edx
movl %edx, 0x8(%rax)
movupd (%rcx), %xmm3
addpd %xmm2, %xmm3
cvttpd2dq %xmm3, %xmm2
leaq 0x8(%rsp), %r9
movlpd %xmm2, (%r9)
addsd 0x10(%rcx), %xmm1
cvttsd2si %xmm1, %ecx
movl %ecx, 0x8(%r9)
movq %rax, %rdx
movq %r9, %rcx
callq 0x30ac6
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::R3Mesh()
R3Mesh::
R3Mesh(void) 
  : vertex_block(NULL),
    edge_block(NULL),
    face_block(NULL),
    vbo_face_position_buffer(0),
    vbo_face_normal_buffer(0),
    vbo_face_texcoord_buffer(0),
    vbo_face_rgb_color_buffer(0),
    vbo_face_pick_color_buffer(0),
    vbo_vertex_position_buffer(0),
    vbo_vertex_normal_buffer(0),
    vbo_vertex_texcoord_buffer(0),
    vbo_vertex_rgb_color_buffer(0),
    vbo_vertex_pick_color_buffer(0),
    bbox(R3null_box),
    data(NULL)
{
  // Initialize name
  name[0] = '\0';

  // Just checking
  assert(IsValid());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0xc560a(%rip), %rax     # 0xd6410
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x6630a
leaq 0x18(%r15), %r14
movq %r14, %rdi
callq 0x6630a
leaq 0x28(%r15), %r12
movq %r12, %rdi
callq 0x6630a
leaq 0xf8(%r15), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r15)
movups %xmm0, 0x58(%r15)
movups %xmm0, 0x48(%r15)
movups %xmm0, 0x38(%r15)
leaq 0xca056(%rip), %rsi     # 0xdaea8
callq 0x24b3e
andq $0x0, 0x130(%r15)
movb $0x0, 0x78(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x66378
jmp 0x10e80
movq %rax, %r15
movq %r14, %rdi
callq 0x66378
jmp 0x10e8d
movq %rax, %r15
movq %rbx, %rdi
callq 0x66378
movq %r15, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::Centroid() const
R3Point R3Mesh::
Centroid(void) const
{
  // Return centroid of mesh
  RNArea area = 0;
  R3Point centroid(0,0,0);
  if (NFaces() > 0) {
    for (int i = 0; i < NFaces(); i++) {
      R3MeshFace *face = Face(i);
      RNArea face_area = FaceArea(face);
      R3Point face_centroid = FaceCentroid(face);
      centroid += face_area * face_centroid;
      area += face_area;
    }
  }
  else {
    for (int i = 0; i < NVertices(); i++) {
      R3MeshVertex *vertex = Vertex(i);
      centroid += VertexPosition(vertex);
      area += 1.0;
    }
  }

  // Return centroid
  if (area == 0) return centroid;
  else return centroid / area;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x20(%rsp), %rdi
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x37b4c
movl 0x34(%r14), %eax
testl %eax, %eax
jle 0x113f2
movq %r12, 0x18(%rsp)
xorpd %xmm0, %xmm0
xorl %ebx, %ebx
leaq 0x50(%rsp), %r15
leaq 0x38(%rsp), %r12
leaq 0x20(%rsp), %r13
cltq
cmpq %rax, %rbx
jge 0x113eb
movq 0x28(%r14), %rax
movq (%rax,%rbx,8), %rbp
movq %r14, %rdi
movq %rbp, %rsi
movsd %xmm0, 0x8(%rsp)
callq 0x2125e
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movq %rbp, %rdx
callq 0x11472
movq %r12, %rdi
movq %r15, %rsi
movsd 0x10(%rsp), %xmm0
callq 0x382c0
movq %r13, %rdi
movq %r12, %rsi
callq 0x381b6
movsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
incq %rbx
movl 0x34(%r14), %eax
jmp 0x11389
movq 0x18(%rsp), %r12
jmp 0x1143f
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %ebx, %ebx
leaq 0x20(%rsp), %r15
movslq 0x14(%r14), %rax
cmpq %rax, %rbx
jge 0x11439
movq 0x8(%r14), %rax
movq (%rax,%rbx,8), %rsi
addq $0x18, %rsi
movq %r15, %rdi
callq 0x381b6
movsd 0x8(%rsp), %xmm0
addsd 0x81bda(%rip), %xmm0    # 0x93008
movsd %xmm0, 0x8(%rsp)
incq %rbx
jmp 0x11403
movsd 0x8(%rsp), %xmm0
xorpd %xmm1, %xmm1
leaq 0x20(%rsp), %rsi
movq %r12, %rdi
ucomisd %xmm1, %xmm0
jne 0x1145a
jp 0x1145a
callq 0x37b5c
jmp 0x1145f
callq 0x382e2
movq %r12, %rax
addq $0x68, %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/R3Mesh.cpp
// Function: gaps::R3Mesh::FaceCentroid(gaps::R3MeshFace const*) const
R3Point R3Mesh::
FaceCentroid(const R3MeshFace *f) const
{
  // Return face centroid
  R3Point centroid = R3zero_point;
  centroid += f->vertex[0]->position;
  centroid += f->vertex[1]->position;
  centroid += f->vertex[2]->position;
  return centroid / 3.0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x4ca5e8(%rip), %rsi    # 0x4dba70
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x37b5c
movq 0x8(%r15), %rsi
addq $0x18, %rsi
movq %r14, %rdi
callq 0x381b6
movq 0x10(%r15), %rsi
addq $0x18, %rsi
movq %r14, %rdi
callq 0x381b6
movq 0x18(%r15), %rsi
addq $0x18, %rsi
movq %r14, %rdi
callq 0x381b6
movsd 0x81d0b(%rip), %xmm0    # 0x931d8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x382e2
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::Area() const
RNArea R3Mesh::
Area(void) const
{
  // Return area of mesh
  RNArea area = 0;
  for (int i = 0; i < NFaces(); i++) {
    R3MeshFace *face = Face(i);
    RNArea face_area = FaceArea(face);
    area += face_area;
  }

  // Return total area
  return area;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
movslq 0x34(%rbx), %rax
cmpq %rax, %r14
jge 0x1152a
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq 0x2125e
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r14
jmp 0x114f4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::AverageRadius(gaps::R3Point const*) const
RNLength R3Mesh::
AverageRadius(const R3Point *center) const
{
  // Get centroid
  R3Point centroid = (center) ? *center : Centroid();

  // Check if mesh has faces
  if (NFaces() > 0) {
    // Compute average distance between a position on the surface and a center point
    RNArea area = 0;
    RNLength distance = 0;
    for (int i = 0; i < NFaces(); i++) {
      R3MeshFace *face = Face(i);
      RNArea face_area = FaceArea(face);
      R3Point face_centroid = FaceCentroid(face);
      distance += face_area * R3Distance(face_centroid, centroid);
      area += face_area;
    }

    // Return weighted average
    if (area == 0) return 0;
    else return distance / area;
  }
  else if (NVertices() > 0) {
    // Sum distances between vertices and center point
    RNLength sum = 0;
    for (int i = 0; i < NVertices(); i++) {
      R3MeshVertex *vertex = Vertex(i);
      const R3Point& position = VertexPosition(vertex);
      sum += R3Distance(position, centroid);
    }

    // Return average
    return sum / NVertices();
  }

  // Should not get here unless mesh is empty
  return 0.0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
testq %rsi, %rsi
je 0x11553
callq 0x37b5c
jmp 0x1155b
movq %rbx, %rsi
callq 0x1133a
movl 0x34(%rbx), %eax
testl %eax, %eax
jle 0x115fe
xorpd %xmm0, %xmm0
xorl %r13d, %r13d
leaq 0x38(%rsp), %r14
leaq 0x20(%rsp), %r15
xorpd %xmm2, %xmm2
cltq
cmpq %rax, %r13
jge 0x115eb
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %r12
movq %rbx, %rdi
movq %r12, %rsi
movapd %xmm0, (%rsp)
movsd %xmm2, 0x18(%rsp)
callq 0x2125e
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rdx
callq 0x11472
movq %r14, %rdi
movq %r15, %rsi
callq 0x4321a
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
mulsd %xmm3, %xmm0
movapd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movapd (%rsp), %xmm0
addsd %xmm3, %xmm2
incq %r13
movl 0x34(%rbx), %eax
jmp 0x1157b
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
cmpeqsd %xmm2, %xmm1
andnpd %xmm0, %xmm1
jmp 0x1164b
movl 0x14(%rbx), %eax
xorpd %xmm1, %xmm1
testl %eax, %eax
jle 0x1164b
xorl %r15d, %r15d
leaq 0x20(%rsp), %r14
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0x11643
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq $0x18, %rdi
movq %r14, %rsi
movapd %xmm1, (%rsp)
callq 0x4321a
movapd (%rsp), %xmm1
addsd %xmm0, %xmm1
incq %r15
movl 0x14(%rbx), %eax
jmp 0x11611
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::AverageEdgeInteriorAngle() const
RNAngle R3Mesh::
AverageEdgeInteriorAngle(void) const
{
  // Sum dihedral angles
  int count = 0;
  RNAngle sum = 0.0;
  for (int i = 0; i < NEdges(); i++) {
    R3MeshEdge *edge = Edge(i);
    RNAngle angle = EdgeInteriorAngle(edge);
    if (RNIsZero(angle)) continue;
    sum += angle;
    count++;
  }

  // Return average
  return (count > 0) ? sum / count : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
leaq 0xc948f(%rip), %r15     # 0xdaba8
xorl %ebp, %ebp
movslq 0x24(%rbx), %rax
cmpq %rax, %r14
jge 0x11771
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
callq 0x11796
movsd (%r15), %xmm1
movapd %xmm0, %xmm2
cmpnlepd %xmm1, %xmm2
xorpd 0x818e6(%rip), %xmm1    # 0x93030
cmpnlepd %xmm0, %xmm1
orpd %xmm2, %xmm1
movq %xmm1, %rax
testb $0x1, %al
je 0x1176a
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
subl %eax, %ebp
incq %r14
jmp 0x1171b
xorpd %xmm0, %xmm0
testl %ebp, %ebp
je 0x1178a
cvtsi2sd %ebp, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::EGINormalizationTransformation(int, int, int) const
R3Affine R3Mesh::
EGINormalizationTransformation(RNBoolean translate, RNBoolean rotate, int scale) const
{
  // Initialize transformation
  R3Affine affine(R3identity_affine);

  // Compute center of mass
  R3Point centroid = Centroid();

  // Translate center of mass back to original (if not translating)
  if (!translate) {
    affine.Translate(centroid.Vector());
  }

  // Scale by inverse of radius
  if ((scale != 0) && (scale != 2)) {
    RNScalar radius = AverageRadius(&centroid);
    if (RNIsPositive(radius)) affine.Scale(1.0 / radius);
  }

  // Rotate to align EGI axes with XYZ
  if (rotate) {
    R3Triad triad = EGIAxes();
    affine.Transform(R3Affine(triad.InverseMatrix()));
  }

  // Translate center of mass to origin
  affine.Translate(-(centroid.Vector()));
  
  // Return transformation
  return affine;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f0, %rsp            # imm = 0x1F0
movl %r8d, %r15d
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc8f8c(%rip), %rsi     # 0xdb010
callq 0x21282
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1133a
testl %r12d, %r12d
jne 0x120b9
leaq 0x98(%rsp), %rdi
movq %rsp, %rsi
callq 0x212f8
leaq 0x98(%rsp), %rsi
movq %rbx, %rdi
callq 0x212e2
testl $0xfffffffd, %r15d      # imm = 0xFFFFFFFD
je 0x120f2
movq %rsp, %rsi
movq %r14, %rdi
callq 0x11532
leaq 0xc8ad4(%rip), %rax     # 0xdaba8
ucomisd (%rax), %xmm0
jbe 0x120f2
movsd 0x80f26(%rip), %xmm1    # 0x93008
divsd %xmm0, %xmm1
movq %rbx, %rdi
movapd %xmm1, %xmm0
callq 0x21314
testl %ebp, %ebp
je 0x12146
leaq 0x1a8(%rsp), %rdi
callq 0x11e00
leaq 0x18(%rsp), %rdi
leaq 0x1a8(%rsp), %rsi
callq 0x28386
leaq 0x98(%rsp), %rdi
leaq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x276a0
leaq 0x98(%rsp), %rsi
movq %rbx, %rdi
callq 0x2785a
leaq 0x98(%rsp), %rdi
callq 0x276ee
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x212f8
leaq 0x98(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x38c72
leaq 0x98(%rsp), %rsi
movq %rbx, %rdi
callq 0x212e2
movq %rbx, %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x98(%rsp), %rdi
callq 0x276ee
jmp 0x121a7
jmp 0x121a4
jmp 0x121a4
jmp 0x121a4
jmp 0x121a4
jmp 0x121a4
movq %rax, %r14
movq %rbx, %rdi
callq 0x276ee
movq %r14, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::VertexArea(gaps::R3MeshVertex const*) const
RNArea R3Mesh::
VertexArea(const R3MeshVertex *v) const
{
  // Return 1/3 the sum of areas of attached faces
  RNLength sum = 0;
  for (int i = 0; i < VertexValence(v); i++) {
    R3MeshEdge *e = EdgeOnVertex(v, i);
    R3MeshFace *f = FaceOnEdge(e, v, RN_CCW);
    if (!f) continue;
    sum += FaceArea(f);
  }
  return sum / 3;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movslq 0x14(%rbx), %rax
cmpq %rax, %r15
jge 0x1236d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
xorl %ecx, %ecx
cmpq %rbx, 0x8(%rax)
setne %cl
movq 0x18(%rax,%rcx,8), %rsi
testq %rsi, %rsi
je 0x12368
movq %r14, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x2125e
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r15
jmp 0x12320
divsd 0x80e63(%rip), %xmm0    # 0x931d8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::VertexGaussCurvature(gaps::R3MeshVertex const*) const
RNScalar R3Mesh::
VertexGaussCurvature(const R3MeshVertex *v) const
{
  // Sum areas and interior angles of adjacent faces
  RNArea area = 0;
  RNAngle angle = 0;
  const R3Point& p = VertexPosition(v);
  for (int i = 0; i < VertexValence(v); i++) {
    R3MeshEdge *e1 = EdgeOnVertex(v, i);
    if (!e1) { angle = 0; area = 0; break; }
    R3MeshVertex *v1 = VertexAcrossEdge(e1, v);
    R3MeshEdge *e2 = EdgeOnVertex(v, e1, RN_CCW);
    if (!e2) { angle = 0; area = 0; break; }
    R3MeshVertex *v2 = VertexAcrossEdge(e2, v);
    R3MeshFace *f = FaceOnVertex(v, e1, RN_CCW);
    if (!f) { angle = 0; area = 0; break; }
    const R3Point& p1 = VertexPosition(v1);
    const R3Point& p2 = VertexPosition(v2);
    angle += R3InteriorAngle(p1 - p, p2 - p);
    area += FaceArea(f);
  }

  // Compute curvature using Gauss-Bonet
  RNScalar curvature = (area > 0) ? 3  * (RN_TWO_PI - angle) / area : 0;

  // Return Gauss curvature
  return curvature;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsi), %rax
movq %rax, 0x18(%rsp)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
xorpd %xmm1, %xmm1
movq %rsi, 0x10(%rsp)
movslq 0x14(%rbx), %rax
cmpq %rax, %r15
jge 0x1251d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %r12
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
testq %r12, %r12
je 0x12517
movsd %xmm1, 0x20(%rsp)
movq 0x8(%r12), %rbp
cmpq %rbx, %rbp
jne 0x12459
movq 0x10(%r12), %rbp
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x2134a
testq %rax, %rax
je 0x12517
movq 0x8(%rax), %r13
cmpq %rbx, %r13
jne 0x1247f
movq 0x10(%rax), %r13
xorl %eax, %eax
cmpq %rbx, 0x8(%r12)
setne %al
movq 0x18(%r12,%rax,8), %r12
xorpd %xmm1, %xmm1
testq %r12, %r12
je 0x12528
addq $0x18, %rbp
addq $0x18, %r13
movq %r15, %rbx
movq %r14, %r15
leaq 0x28(%rsp), %rdi
movq %rbp, %rsi
movq 0x18(%rsp), %rbp
movq %rbp, %rdx
callq 0x37d29
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x37d29
leaq 0x28(%rsp), %rdi
movq %r15, %r13
movq %rbx, %r15
movq 0x10(%rsp), %rbx
movq %r14, %rsi
callq 0x4555f
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r13, %r14
movq %r13, %rdi
movq %r12, %rsi
callq 0x2125e
movsd 0x20(%rsp), %xmm1
addsd %xmm0, %xmm1
incq %r15
jmp 0x1241c
xorpd %xmm1, %xmm1
jmp 0x12528
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x88a39(%rip), %rax     # 0x9af68
movsd (%rax), %xmm2
subsd 0x8(%rsp), %xmm2
mulsd 0x80c97(%rip), %xmm2    # 0x931d8
divsd %xmm1, %xmm2
xorpd %xmm0, %xmm0
cmpltsd %xmm1, %xmm0
andpd %xmm2, %xmm0
addq $0x58, %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/R3Mesh.cpp
// Function: gaps::R3Mesh::VertexMeanCurvature(gaps::R3MeshVertex const*) const
RNScalar R3Mesh::
VertexMeanCurvature(const R3MeshVertex *v) const
{
  // Compute signed length of laplacian vector projected onto normal
  RNArea area = VertexArea(v);
  if (area == 0) return 0;
  R3Vector laplacian = VertexLaplacianVector(v);
  RNScalar curvature = -1 * laplacian.Dot(VertexNormal(v));
  return curvature;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1230a
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x12586
jnp 0x125b7
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x125c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21234
movq %r15, %rdi
movq %rax, %rsi
callq 0x38586
xorpd 0x80a79(%rip), %xmm0    # 0x93030
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::EdgeDirection(gaps::R3MeshEdge const*) const
R3Vector R3Mesh:: 
EdgeDirection(const R3MeshEdge *e) const
{
  // Returns the normalized vector pointing in direction of the edge
  R3Vector vector = EdgeVector(e);
  RNLength d = EdgeLength(e);
  if (RNIsPositive(d)) vector /= d;
  return vector;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x213a6
movq %r15, %rdi
movq %r14, %rsi
callq 0x10db2
leaq 0xc8423(%rip), %rax     # 0xdaba8
ucomisd (%rax), %xmm0
jbe 0x12793
movq %rbx, %rdi
callq 0x38c0a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::EdgeNormal(gaps::R3MeshEdge const*) const
R3Vector R3Mesh::
EdgeNormal(const R3MeshEdge *e) const
{
  // Return the normal to the surface at the edge
  R3Vector normal = R3zero_vector;
  R3MeshFace *f0 = FaceOnEdge(e, 0);
  R3MeshFace *f1 = FaceOnEdge(e, 1);
  if (f0) normal += FaceNormal(f0);
  if (f1) normal += FaceNormal(f1);
  normal.Normalize();
  return normal;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x86edf(%rip), %rsi     # 0x99690
callq 0x3831c
movq 0x18(%r15), %rsi
movq 0x20(%r15), %r15
testq %rsi, %rsi
je 0x127d6
movq %r14, %rdi
callq 0x10dd0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38a24
testq %r15, %r15
je 0x127f1
movq %r14, %rdi
movq %r15, %rsi
callq 0x10dd0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38a24
movq %rbx, %rdi
callq 0x3860e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::FaceColor(gaps::R3MeshFace const*) const
RNRgb R3Mesh:: 
FaceColor(const R3MeshFace *f) const
{
  R3MeshVertex *v0 = VertexOnFace(f, 0);
  R3MeshVertex *v1 = VertexOnFace(f, 1);
  R3MeshVertex *v2 = VertexOnFace(f, 2);
  const RNRgb& c0 = VertexColor(v0);
  const RNRgb& c1 = VertexColor(v1);
  const RNRgb& c2 = VertexColor(v2);
  return (c0 + c1 + c2) / 3.0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
movq 0x10(%rdx), %rax
movq 0x18(%rdx), %r14
addq $0x58, %rsi
addq $0x58, %rax
addq $0x58, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq 0x213f3
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x213f3
movsd 0x808e1(%rip), %xmm0    # 0x931d8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x213c7
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::FaceAspect(gaps::R3MeshFace const*) const
RNScalar R3Mesh:: 
FaceAspect(const R3MeshFace *f) const
{
  R3MeshEdge *e0 = EdgeOnFace(f, 0);
  R3MeshEdge *e1 = EdgeOnFace(f, 1);
  R3MeshEdge *e2 = EdgeOnFace(f, 2);
  RNLength a = EdgeLength(e0);
  if (RNIsZero(a)) return RN_INFINITY;
  RNLength b = EdgeLength(e1);
  if (RNIsZero(b)) return RN_INFINITY;
  RNLength c = EdgeLength(e2);
  if (RNIsZero(c)) return RN_INFINITY;
  RNScalar s = (a + b + c) / 2.0;
  return (a * b * c) / (8.0 * (s - a) * (s - b) * (s - c));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %r15
movq 0x30(%rsi), %r14
movq %rax, %rsi
callq 0x10db2
leaq 0xc826d(%rip), %r12     # 0xdaba8
movsd (%r12), %xmm2
movapd 0x806e7(%rip), %xmm1    # 0x93030
xorpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x12959
ucomisd %xmm0, %xmm2
jae 0x129b7
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10db2
movsd (%r12), %xmm2
movapd 0x806b8(%rip), %xmm1    # 0x93030
xorpd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x12988
ucomisd %xmm0, %xmm2
jae 0x129b7
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10db2
movsd (%r12), %xmm1
movapd 0x80689(%rip), %xmm2    # 0x93030
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x129d2
ucomisd %xmm0, %xmm1
jb 0x129d2
leaq 0xc81fa(%rip), %rax     # 0xdabb8
movsd (%rax), %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movsd 0x10(%rsp), %xmm4
movapd %xmm4, %xmm2
movsd 0x8(%rsp), %xmm5
addsd %xmm5, %xmm2
addsd %xmm0, %xmm2
mulsd 0x8061e(%rip), %xmm2    # 0x93010
movapd %xmm4, %xmm1
mulsd %xmm5, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm2, %xmm3
subsd %xmm4, %xmm3
mulsd 0x807ea(%rip), %xmm3    # 0x931f8
movapd %xmm2, %xmm4
subsd %xmm5, %xmm4
mulsd %xmm3, %xmm4
subsd %xmm0, %xmm2
mulsd %xmm4, %xmm2
divsd %xmm2, %xmm1
jmp 0x129c2
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::FacePoint(gaps::R3MeshFace const*, double*) const
R3Point R3Mesh::
FacePoint(const R3MeshFace *f, RNMagnitude barycentrics[3]) const
{
  // Return point on the face with the given barycentric coordinates
  R3Point point = R3zero_point;
  point += barycentrics[0] * f->vertex[0]->position;
  point += barycentrics[1] * f->vertex[1]->position;
  point += barycentrics[2] * f->vertex[2]->position;
  return point;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x4c902d(%rip), %rsi    # 0x4dba70
callq 0x37b5c
movsd (%r15), %xmm0
movq 0x8(%r14), %rsi
addq $0x18, %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x382c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x381b6
movsd 0x8(%r15), %xmm0
movq 0x10(%r14), %rsi
addq $0x18, %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x382c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x381b6
movsd 0x10(%r15), %xmm0
movq 0x18(%r14), %rsi
addq $0x18, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x382c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x381b6
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::FaceBarycentric(gaps::R3MeshFace const*, gaps::R3Point const&) const
R3Point R3Mesh::
FaceBarycentric(const R3MeshFace *f, const R3Point &point) const
{
  // From http://www.devmaster.net/wiki/Ray-triangle_intersection
  R3Point p0 = f->vertex[0]->position;
  R3Point p1 = f->vertex[1]->position;
  R3Point p2 = f->vertex[2]->position;
  R3Vector b = p1 - p0;
  R3Vector c = p2 - p0;
  R3Vector p = point - p0;
  RNDimension dim = f->plane.Normal().MaxDimension();
  RNDimension dim0 = (dim+1)%3;
  RNDimension dim1 = (dim+2)%3;
  RNScalar denom = b[dim1]*c[dim0] - b[dim0]*c[dim1];
  if (denom == 0) return R3zero_point;
  RNScalar b1 = (p[dim1]*c[dim0] - p[dim0]*c[dim1]) / denom;
  RNScalar b2 = (p[dim1]*b[dim0] - p[dim0]*b[dim1]) / -denom;
  RNScalar b0 = 1 - b1 - b2;
  return R3Point(b0, b1, b2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
addq $0x18, %rsi
leaq 0x80(%rsp), %r12
movq %r12, %rdi
callq 0x37b5c
movq 0x10(%r14), %rsi
addq $0x18, %rsi
leaq 0x68(%rsp), %r13
movq %r13, %rdi
callq 0x37b5c
movq 0x18(%r14), %rsi
addq $0x18, %rsi
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
callq 0x37b5c
leaq 0x38(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x37d29
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x37d29
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x37d29
addq $0x38, %r14
movq %r14, %rdi
callq 0x38490
movl %eax, %ecx
leal 0x1(%rcx), %eax
pushq $0x3
popq %rdi
cltd
idivl %edi
movl %edx, %esi
addl $0x2, %ecx
movl %ecx, %eax
cltd
idivl %edi
movslq %edx, %rax
movsd 0x38(%rsp,%rax,8), %xmm4
movslq %esi, %rcx
movsd 0x20(%rsp,%rcx,8), %xmm1
movsd 0x38(%rsp,%rcx,8), %xmm2
movsd 0x20(%rsp,%rax,8), %xmm3
movapd %xmm3, %xmm5
mulsd %xmm2, %xmm5
movapd %xmm4, %xmm0
mulsd %xmm1, %xmm0
subsd %xmm5, %xmm0
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm0
jne 0x12bbe
jp 0x12bbe
leaq 0x4c8ebc(%rip), %rsi    # 0x4dba70
movq %rbx, %rdi
callq 0x37b5c
jmp 0x12c1a
movapd 0x8046a(%rip), %xmm5    # 0x93030
xorpd %xmm0, %xmm5
unpcklpd %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0]
movsd 0x8(%rsp,%rcx,8), %xmm4
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
mulpd %xmm3, %xmm4
movsd 0x8(%rsp,%rax,8), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
unpcklpd %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0]
mulpd %xmm3, %xmm1
subpd %xmm4, %xmm1
unpcklpd %xmm5, %xmm0            # xmm0 = xmm0[0],xmm5[0]
divpd %xmm0, %xmm1
movsd 0x80406(%rip), %xmm0    # 0x93008
subsd %xmm1, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
subsd %xmm2, %xmm0
movq %rbx, %rdi
callq 0x37b4c
movq %rbx, %rax
addq $0x98, %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/R3Mesh.cpp
// Function: gaps::R3Mesh::IsVertexOnBoundary(gaps::R3MeshVertex const*) const
RNBoolean R3Mesh::
IsVertexOnBoundary(const R3MeshVertex *v) const
{
  // Return whether vertex lies on boundary
  for (int i = 0; i < VertexValence(v); i++) {
    R3MeshEdge *e = EdgeOnVertex(v, i);
    if (IsEdgeOnBoundary(e)) return TRUE;
  }

  // No adjacent edge is on boundary
  return FALSE;
}

// Assembly:
movslq 0x14(%rsi), %rcx
xorl %edi, %edi
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
movq %rdi, %rdx
cmpq %rdi, %rax
je 0x12c84
movq 0x8(%rsi), %rdi
movq (%rdi,%rdx,8), %r8
cmpq $0x0, 0x18(%r8)
je 0x12c84
leaq 0x1(%rdx), %rdi
cmpq $0x0, 0x20(%r8)
jne 0x12c62
xorl %eax, %eax
cmpq %rcx, %rdx
setl %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::SetVertexPosition(gaps::R3MeshVertex*, gaps::R3Point const&)
void R3Mesh::
SetVertexPosition(R3MeshVertex *v, const R3Point& position)
{
  // Set vertex position
  v->position = position;

  // Mark vertex in need of update to normal 
  v->flags.Remove(R3_MESH_VERTEX_NORMAL_UPTODATE);

  // Mark edges/faces in need of update
  for (int i = 0; i < v->edges.NEntries(); i++) {
    R3MeshEdge *e = v->edges[i];
    e->flags.Remove(R3_MESH_EDGE_LENGTH_UPTODATE);
    R3MeshVertex *neighbor = VertexAcrossEdge(e, v);
    neighbor->flags.Remove(R3_MESH_VERTEX_NORMAL_UPTODATE);
    R3MeshFace *f0 = e->face[0];
    if (f0) f0->flags.Remove(R3_MESH_FACE_PLANE_UPTODATE | R3_MESH_FACE_BBOX_UPTODATE);
    R3MeshFace *f1 = e->face[1];
    if (f1) f1->flags.Remove(R3_MESH_FACE_PLANE_UPTODATE | R3_MESH_FACE_BBOX_UPTODATE);
  }

  // Update bounding box
  bbox.Union(position);

  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
movq %rdx, %rsi
callq 0x37e36
andb $-0x3, 0x78(%r15)
movslq 0x14(%r15), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x12d39
movq 0x8(%r15), %rdx
movq (%rdx,%rcx,8), %rdx
andq $-0x3, 0x38(%rdx)
movq 0x8(%rdx), %rsi
cmpq %r15, %rsi
jne 0x12d10
movq 0x10(%rdx), %rsi
andb $-0x3, 0x78(%rsi)
movq 0x18(%rdx), %rsi
testq %rsi, %rsi
je 0x12d24
andb $-0xd, 0xa8(%rsi)
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
je 0x12d34
andb $-0xd, 0xa8(%rdx)
incq %rcx
jmp 0x12cf1
leaq 0xf8(%rbx), %rdi
movq %r14, %rsi
callq 0x254a4
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x290(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::EdgeBetweenVertices(gaps::R3MeshVertex const*, gaps::R3MeshVertex const*) const
R3MeshEdge *R3Mesh::
EdgeBetweenVertices(const R3MeshVertex *v1, const R3MeshVertex *v2) const
{
  // Check if vertices are same
  if (v1 == v2) return NULL;

  // Search for edge in v1's list
  for (int i = 0; i < v1->edges.NEntries(); i++) {
    R3MeshEdge *e = v1->edges[i];
    if (IsVertexOnEdge(v2, e)) return e;
  }

  // Not found
  return NULL;
}

// Assembly:
xorl %eax, %eax
cmpq %rdx, %rsi
je 0x12d88
movl 0x14(%rsi), %ecx
testl %ecx, %ecx
cmovlel %eax, %ecx
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x12d88
movq 0x8(%rsi), %rax
movq (%rax,%rdi,8), %rax
cmpq %rdx, 0x8(%rax)
je 0x12d87
incq %rdi
cmpq %rdx, 0x10(%rax)
jne 0x12d6b
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::EdgeOnVertex(gaps::R3MeshVertex const*, gaps::R3MeshFace const*, int) const
R3MeshEdge *R3Mesh::
EdgeOnVertex(const R3MeshVertex *v, const R3MeshFace *f, RNDirection dir) const
{
  // Return edge on v in dir with respect to f
  if (f->vertex[0] == v) {
    if (dir == RN_CCW) return f->edge[2];
    else return f->edge[0];
  }
  else if (f->vertex[1] == v) {
    if (dir == RN_CCW) return f->edge[0];
    else return f->edge[1];
  }
  else if (f->vertex[2] == v) {
    if (dir == RN_CCW) return f->edge[1];
    else return f->edge[2];
  }
  else {
    // Vertex is not on face
    return NULL;
  }
}

// Assembly:
cmpq %rsi, 0x8(%rdx)
je 0x12da1
cmpq %rsi, 0x10(%rdx)
je 0x12db1
cmpq %rsi, 0x18(%rdx)
je 0x12dc2
xorl %eax, %eax
retq
xorl %eax, %eax
testl %ecx, %ecx
sete %al
shll $0x4, %eax
orq $0x20, %rax
jmp 0x12dd1
xorl %eax, %eax
testl %ecx, %ecx
setne %al
leaq 0x20(,%rax,8), %rax
jmp 0x12dd1
xorl %eax, %eax
testl %ecx, %ecx
setne %al
leaq 0x28(,%rax,8), %rax
movq (%rdx,%rax), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::EdgeAcrossVertex(gaps::R3MeshVertex const*, gaps::R3MeshEdge const*, gaps::R3MeshFace const*) const
R3MeshEdge *R3Mesh:: 
EdgeAcrossVertex(const R3MeshVertex *v, const R3MeshEdge *e, const R3MeshFace *f) const
{
  // Returns edge on the other side of a vertex from an edge on the same face 
  if (v == f->vertex[0]) {
    if (e == f->edge[0]) return f->edge[2];
    else if (e == f->edge[2]) return f->edge[0];
  }
  else if (v == f->vertex[1]) {
    if (e == f->edge[1]) return f->edge[0];
    else if (e == f->edge[0]) return f->edge[1];
  }
  else if (v == f->vertex[2]) {
    if (e == f->edge[2]) return f->edge[1];
    else if (e == f->edge[1]) return f->edge[2];
  }
  return NULL;
}

// Assembly:
cmpq %rsi, 0x8(%rcx)
je 0x12df2
cmpq %rsi, 0x10(%rcx)
je 0x12e05
cmpq %rsi, 0x18(%rcx)
jne 0x12e17
movq 0x28(%rcx), %rsi
movq 0x30(%rcx), %rax
jmp 0x12e0d
movq 0x20(%rcx), %rax
movq 0x30(%rcx), %rcx
cmpq %rdx, %rax
je 0x12e1e
cmpq %rdx, %rcx
jne 0x12e17
retq
movq 0x20(%rcx), %rsi
movq 0x28(%rcx), %rax
cmpq %rdx, %rax
je 0x12e1a
cmpq %rdx, %rsi
je 0x12e04
xorl %eax, %eax
retq
movq %rsi, %rax
retq
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::VertexBetweenEdges(gaps::R3MeshEdge const*, gaps::R3MeshEdge const*) const
R3MeshVertex *R3Mesh::
VertexBetweenEdges(const R3MeshEdge *e1, const R3MeshEdge *e2) const
{
  // Return vertex shared by edges
  if (e1 == e2) return NULL;
  if ((e1->vertex[0] == e2->vertex[0]) || (e1->vertex[0] == e2->vertex[1])) return e1->vertex[0];
  else if ((e1->vertex[1] == e2->vertex[0]) || (e1->vertex[1] == e2->vertex[1])) return e1->vertex[1];
  else return NULL;
}

// Assembly:
cmpq %rdx, %rsi
je 0x12e66
movq 0x8(%rsi), %rax
movq 0x8(%rdx), %rcx
cmpq %rcx, %rax
je 0x12e65
movq 0x10(%rdx), %rdx
cmpq %rdx, %rax
je 0x12e65
movq 0x10(%rsi), %rsi
xorl %eax, %eax
cmpq %rdx, %rsi
cmoveq %rsi, %rax
cmpq %rcx, %rsi
cmoveq %rsi, %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::VertexBetweenFaces(gaps::R3MeshFace const*, gaps::R3MeshFace const*, int) const
R3MeshVertex *R3Mesh::
VertexBetweenFaces(const R3MeshFace *f1, const R3MeshFace *f2, RNDirection dir) const
{
  // Check if faces are same
  if (f1 == f2) return NULL;

  // Return vertex connected to both f1 and f2
  R3MeshEdge *e = EdgeBetweenFaces(f1, f2);
  if (e) {
    // Faces lie on same edge, return vertex in dir with respect to f1
    return VertexOnFace(f1, e, dir);
  }
  else {
    // Faces do not lie on the same edge, check if they share a vertex
    if (f1->vertex[0] == f2->vertex[0]) return f1->vertex[0];
    if (f1->vertex[0] == f2->vertex[1]) return f1->vertex[0];
    if (f1->vertex[0] == f2->vertex[2]) return f1->vertex[0];
    if (f1->vertex[1] == f2->vertex[0]) return f1->vertex[1];
    if (f1->vertex[1] == f2->vertex[1]) return f1->vertex[1];
    if (f1->vertex[1] == f2->vertex[2]) return f1->vertex[1];
    if (f1->vertex[2] == f2->vertex[0]) return f1->vertex[2];
    if (f1->vertex[2] == f2->vertex[1]) return f1->vertex[2];
    if (f1->vertex[2] == f2->vertex[2]) return f1->vertex[2];
    return NULL;
  }
}

// Assembly:
cmpq %rdx, %rsi
je 0x12ed4
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
callq 0x12f2a
testq %rax, %rax
je 0x12ed7
pushq $0x1
popq %rcx
subl %ebp, %ecx
cmpq %rbx, 0x18(%rax)
movslq %ecx, %rcx
movslq %ebp, %rdx
cmoveq %rcx, %rdx
movq 0x8(%rax,%rdx,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
movq 0x8(%rbx), %rax
movq 0x8(%r14), %rdx
cmpq %rdx, %rax
je 0x12ecf
movq 0x10(%r14), %rsi
cmpq %rsi, %rax
je 0x12ecf
movq 0x18(%r14), %rcx
cmpq %rcx, %rax
je 0x12ecf
movq 0x10(%rbx), %rax
cmpq %rcx, %rax
je 0x12ecf
cmpq %rdx, %rax
je 0x12ecf
cmpq %rsi, %rax
je 0x12ecf
movq 0x18(%rbx), %rax
cmpq %rdx, %rax
sete %dl
cmpq %rsi, %rax
sete %sil
orb %dl, %sil
jne 0x12ecf
xorl %edx, %edx
cmpq %rcx, %rax
cmovneq %rdx, %rax
jmp 0x12ecf
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::EdgeBetweenFaces(gaps::R3MeshFace const*, gaps::R3MeshFace const*) const
R3MeshEdge *R3Mesh::
EdgeBetweenFaces(const R3MeshFace *f1, const R3MeshFace *f2) const
{
  if (f1 == f2) return NULL;
  if (FaceAcrossEdge(f1->edge[0], f1) == f2) return f1->edge[0];
  if (FaceAcrossEdge(f1->edge[1], f1) == f2) return f1->edge[1];
  if (FaceAcrossEdge(f1->edge[2], f1) == f2) return f1->edge[2];
  return NULL;
}

// Assembly:
cmpq %rdx, %rsi
je 0x12f76
movq 0x20(%rsi), %rax
movq 0x18(%rax), %rcx
cmpq %rsi, %rcx
jne 0x12f40
movq 0x20(%rax), %rcx
cmpq %rdx, %rcx
je 0x12f78
movq 0x28(%rsi), %rax
movq 0x18(%rax), %rcx
cmpq %rsi, %rcx
jne 0x12f56
movq 0x20(%rax), %rcx
cmpq %rdx, %rcx
je 0x12f78
movq 0x30(%rsi), %rcx
movq 0x18(%rcx), %rdi
cmpq %rsi, %rdi
jne 0x12f6c
movq 0x20(%rcx), %rdi
xorl %eax, %eax
cmpq %rdx, %rdi
cmoveq %rcx, %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::ShortestEdgeOnFace(gaps::R3MeshFace const*) const
R3MeshEdge *R3Mesh::
ShortestEdgeOnFace(const R3MeshFace *f) const
{
  // Return shortest of three edges on face
  R3MeshEdge *e0 = EdgeOnFace(f, 0);
  R3MeshEdge *e1 = EdgeOnFace(f, 1);
  R3MeshEdge *e2 = EdgeOnFace(f, 2);
  RNLength d0 = EdgeLength(e0);
  RNLength d1 = EdgeLength(e1);
  RNLength d2 = EdgeLength(e2);
  if (d0 < d1) {
    if (d0 < d2) return e0;
    else return e2;
  }
  else {
    if (d1 < d2) return e1;
    else return e2;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %r14
movq 0x28(%rsi), %r15
movq 0x30(%rsi), %r12
movq %r14, %rsi
callq 0x10db2
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10db2
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10db2
movsd 0x10(%rsp), %xmm1
ucomisd %xmm1, %xmm0
cmovbeq %r12, %r14
movsd 0x8(%rsp), %xmm2
ucomisd %xmm2, %xmm0
cmovaq %r15, %r12
ucomisd %xmm1, %xmm2
cmovaq %r14, %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::LongestEdgeOnFace(gaps::R3MeshFace const*) const
R3MeshEdge *R3Mesh::
LongestEdgeOnFace(const R3MeshFace *f) const
{
  // Return longest of three edges on face
  R3MeshEdge *e0 = EdgeOnFace(f, 0);
  R3MeshEdge *e1 = EdgeOnFace(f, 1);
  R3MeshEdge *e2 = EdgeOnFace(f, 2);
  RNLength d0 = EdgeLength(e0);
  RNLength d1 = EdgeLength(e1);
  RNLength d2 = EdgeLength(e2);
  if (d0 > d1) {
    if (d0 > d2) return e0;
    else return e2;
  }
  else {
    if (d1 > d2) return e1;
    else return e2;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %r14
movq 0x28(%rsi), %r15
movq 0x30(%rsi), %r12
movq %r14, %rsi
callq 0x10db2
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10db2
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10db2
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
cmovbeq %r12, %r14
movsd 0x8(%rsp), %xmm2
ucomisd %xmm0, %xmm2
cmovaq %r15, %r12
ucomisd %xmm2, %xmm1
cmovaq %r14, %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::FindConnectedVertices(gaps::R3MeshVertex*, gaps::RNArray<gaps::R3MeshVertex*>&)
void R3Mesh::
FindConnectedVertices(R3MeshVertex *seed, RNArray<R3MeshVertex *>& vertices)
{
  // Fill array with vertices in same connected component as seed
  R3mesh_mark++;
  RNArray<R3MeshVertex *> stack;
  stack.Insert(seed);
  SetVertexMark(seed, R3mesh_mark);
  while (!stack.IsEmpty()) {
    R3MeshVertex *vertex = stack.Tail();
    stack.RemoveTail();
    vertices.Insert(vertex);
    for (int i = 0; i < VertexValence(vertex); i++) {
      R3MeshEdge *edge = EdgeOnVertex(vertex, i);
      R3MeshVertex *neighbor = VertexAcrossEdge(edge, vertex);
      if (VertexMark(neighbor) != R3mesh_mark) {
        SetVertexMark(neighbor, R3mesh_mark);
        stack.Insert(neighbor);
      }
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
incl 0xc743f(%rip)           # 0xda4c0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6630a
movq %r15, %rdi
movq %r14, %rsi
callq 0x22bfc
movl 0xc7421(%rip), %eax     # 0xda4c0
movl %eax, 0x88(%r14)
leaq 0x8(%rsp), %r14
movslq 0x14(%rsp), %rax
testq %rax, %rax
je 0x13114
movq 0x8(%rsp), %rcx
movq -0x8(%rcx,%rax,8), %r15
movq %r14, %rdi
callq 0x21340
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22bfc
xorl %r12d, %r12d
movslq 0x14(%r15), %rax
cmpq %rax, %r12
jge 0x130ab
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %rsi
cmpq %r15, %rsi
jne 0x130f3
movq 0x10(%rax), %rsi
movl 0xc73c7(%rip), %eax     # 0xda4c0
cmpl %eax, 0x88(%rsi)
je 0x1310f
movl %eax, 0x88(%rsi)
movq %r14, %rdi
callq 0x22bfc
incq %r12
jmp 0x130d5
leaq 0x8(%rsp), %rdi
callq 0x66378
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1312e
jmp 0x1312e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x66378
movq %rbx, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::FindConnectedFaces(gaps::R3MeshFace*, gaps::RNArray<gaps::R3MeshFace*>&)
void R3Mesh::
FindConnectedFaces(R3MeshFace *seed, RNArray<R3MeshFace *>& faces)
{
  // Fill array with faces in same connected component as seed
  R3mesh_mark++;
  RNArray<R3MeshFace *> stack;
  stack.Insert(seed);
  while (!stack.IsEmpty()) {
    R3MeshFace *face = stack.Tail();
    stack.RemoveTail();
    if (FaceMark(face) != R3mesh_mark) {
      faces.Insert(face);
      if (FaceOnFace(face, 0)) stack.Insert(FaceOnFace(face, 0));
      if (FaceOnFace(face, 1)) stack.Insert(FaceOnFace(face, 1));
      if (FaceOnFace(face, 2)) stack.Insert(FaceOnFace(face, 2));
      SetFaceMark(face, R3mesh_mark);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
incl 0xc7367(%rip)           # 0xda4c0
movq %rsp, %r15
movq %r15, %rdi
callq 0x6630a
movq %r15, %rdi
movq %r14, %rsi
callq 0x22bfc
movq %rsp, %r14
movslq 0xc(%rsp), %rax
testq %rax, %rax
je 0x13217
movq (%rsp), %rcx
movq -0x8(%rcx,%rax,8), %r15
movq %r14, %rdi
callq 0x21340
movl 0xb8(%r15), %eax
cmpl 0xc7322(%rip), %eax     # 0xda4c0
je 0x13172
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22bfc
movq 0x20(%r15), %rax
movq 0x18(%rax), %rsi
cmpq %r15, %rsi
jne 0x131bc
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x131c9
movq %r14, %rdi
callq 0x22bfc
movq 0x28(%r15), %rax
movq 0x18(%rax), %rsi
cmpq %r15, %rsi
jne 0x131da
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x131e7
movq %r14, %rdi
callq 0x22bfc
movq 0x30(%r15), %rax
movq 0x18(%rax), %rsi
cmpq %r15, %rsi
jne 0x131f8
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x13205
movq %r14, %rdi
callq 0x22bfc
movl 0xc72b5(%rip), %eax     # 0xda4c0
movl %eax, 0xb8(%r15)
jmp 0x13172
movq %rsp, %rdi
callq 0x66378
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1322b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x66378
movq %rbx, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::Empty()
void R3Mesh::
Empty(void)
{
  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();

  // Delete all faces, edges, vertices
  while (NFaces() > 0) DeleteFace(Face(0));
  while (NEdges() > 0) DeleteEdge(Edge(0));
  while (NVertices() > 0) DeleteVertex(Vertex(0));

  // Delete the blocks of data
  if (vertex_block) { delete [] vertex_block; vertex_block = NULL; }
  if (edge_block) { delete [] edge_block; edge_block = NULL; }
  if (face_block) { delete [] face_block; face_block = NULL; }

  // Reset bounding box
  bbox = R3null_box;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x290(%rax)
cmpl $0x0, 0x34(%rbx)
jle 0x1327b
movq (%rbx), %rax
movq 0x28(%rbx), %rcx
movq (%rcx), %rsi
movq %rbx, %rdi
callq *0x70(%rax)
jmp 0x13253
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movq (%rcx), %rsi
movq %rbx, %rdi
callq *0x68(%rax)
cmpl $0x0, 0x24(%rbx)
jg 0x1326b
jmp 0x13293
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq (%rcx), %rsi
movq %rbx, %rdi
callq *0x60(%rax)
cmpl $0x0, 0x14(%rbx)
jg 0x13283
movq 0x38(%rbx), %r15
testq %r15, %r15
je 0x132e7
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x132cf
addq $-0x98, %r15
imulq $0x98, %r12, %r13
leaq (%r15,%r13), %rdi
callq 0x21124
addq $-0x98, %r13
jne 0x132bd
imulq $0x98, %r12, %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0xe8f0
andq $0x0, 0x38(%rbx)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x13307
imulq $0x58, -0x8(%rdi), %rsi
addq $-0x8, %rdi
addq $0x8, %rsi
callq 0xe8f0
andq $0x0, 0x40(%rbx)
movq 0x48(%rbx), %r15
testq %r15, %r15
je 0x13355
leaq -0x8(%r15), %r14
movq -0x8(%r15), %r12
testq %r12, %r12
je 0x1333d
addq $-0xc8, %r15
imulq $0xc8, %r12, %r13
leaq (%r15,%r13), %rdi
callq 0x21208
addq $-0xc8, %r13
jne 0x1332b
imulq $0xc8, %r12, %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0xe8f0
andq $0x0, 0x48(%rbx)
addq $0xf8, %rbx
leaq 0xc7b45(%rip), %rsi     # 0xdaea8
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2141e