LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/Table.cpp
// Function: Table::removeRecords(std::vector<WhereStmt, std::allocator<WhereStmt>>&)
int Table::removeRecords(vector<WhereStmt> &where) {
    vector<uint> cols = findWheres(where);
    for (auto i: cols) {
        Pointer p(this, i);
        if (checkWheres(p.get(), where)) {
            removeRecord(i);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rdx
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rdx, 0x8(%rsp)
callq 0x26268
movq (%r12), %rbx
movq 0x8(%r12), %r14
cmpq %r14, %rbx
je 0x266f3
leaq 0x40(%rsp), %r12
movl (%rbx), %ebp
movq %r15, 0x28(%rsp)
movl %ebp, 0x30(%rsp)
cmpl $-0x1, %ebp
je 0x266ae
movq 0x48(%r15), %rdi
movl 0x9fa4(%r15), %esi
movl %ebp, %eax
xorl %edx, %edx
divl 0x9fac(%r15)
movl %eax, %edx
callq 0x6722
movq %rax, 0x38(%rsp)
movq %r12, %rdi
leaq 0x28(%rsp), %rsi
callq 0x1fa4c
movq %r15, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
callq 0x26030
movl %eax, %r13d
movq %r12, %rdi
callq 0xa37e
testb %r13b, %r13b
je 0x266e5
movq %r15, %rdi
movl %ebp, %esi
callq 0x21e12
addq $0x4, %rbx
cmpq %r14, %rbx
jne 0x2667c
movq 0x10(%rsp), %rbx
testq %rbx, %rbx
je 0x26708
movq 0x20(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x53a0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xa37e
jmp 0x2672b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26742
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53a0
movq %rbx, %rdi
callq 0x56e0
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/./Any.h
// Function: Any& Any::operator=<int>(int const&)
Any &operator=(const ValueType &value)
    {
        Any tmp(value);
        if (_pValue)
            delete _pValue;
        _pValue = tmp._pValue;
        tmp._pValue = nullptr;
        return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x10, %edi
callq 0x5390
movq %rax, %r14
leaq 0x2a951(%rip), %rax     # 0x52a78
movq %rax, (%r14)
movl (%r15), %eax
movl %eax, 0x8(%r14)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2813f
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Konano[P]UselessDatabase/main.cpp
// Function: main
int main() {
    // test_0();
    // test_1();
    // test_2();
    // test_3();
    // test_4();
    // test_5();
    // test_6();
    // test_7();
    // test_8();
    // test_9();
    // import_data_csv();
    import_data_tbl();
    cout << "import finish" << endl; 
    yyparse();
    return 0;
}

// Assembly:
pushq %rbx
callq 0x2a072
movq 0x25385(%rip), %rbx     # 0x52fc8
leaq 0x1380b(%rip), %rsi     # 0x41455
movl $0xd, %edx
movq %rbx, %rdi
callq 0x5440
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5370
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x52a0
callq 0x30b8f
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x200(%rdi), %r14
movq %r14, %rdi
callq 0x20c0
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x2b27
movl $0x1, %ebp
xorl %r12d, %r12d
shlq $0x5, %r12
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %r15, %rdi
callq 0x2180
movq (%rbx), %rax
movq 0x8(%rax,%r12), %rcx
testq %rcx, %rcx
je 0x2b12
addq %rax, %r12
movq (%r12), %rdx
cmpb $0xa, -0x1(%rdx,%rcx)
je 0x2b12
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq (%rbx), %rax
movl %ebp, %r12d
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
incl %ebp
cmpq %r12, %rcx
ja 0x2ab8
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2050
testb %al, %al
je 0x2bb1
movq %r15, %rdi
callq 0x21a0
movq (%r12), %rsi
movq %r15, %rdi
movl $0x10, %edx
callq 0x2040
movq %r14, %rdi
callq 0x2050
testb %al, %al
je 0x2be1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21e0
movl $0x1, %edi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcfec6(%rip), %rax     # 0xe1400
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x6f80c
leaq 0x18(%r15), %r14
movq %r14, %rdi
callq 0x6f80c
leaq 0x28(%r15), %r12
movq %r12, %rdi
callq 0x6f80c
leaq 0xf8(%r15), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r15)
movups %xmm0, 0x58(%r15)
movups %xmm0, 0x48(%r15)
movups %xmm0, 0x38(%r15)
leaq 0xd4912(%rip), %rsi     # 0xe5e98
callq 0x272d4
movq $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 0x6f876
jmp 0x115b7
movq %rax, %r15
movq %r14, %rdi
callq 0x6f876
jmp 0x115c4
movq %rax, %r15
movq %rbx, %rdi
callq 0x6f876
movq %r15, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
leaq 0x20(%rsp), %rdi
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x3c532
cmpl $0x0, 0x34(%r14)
jle 0x11b87
movq %rbx, 0x10(%rsp)
xorl %ebx, %ebx
leaq 0x50(%rsp), %r15
leaq 0x38(%rsp), %r12
leaq 0x20(%rsp), %r13
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x28(%r14), %rax
movq (%rax,%rbx,8), %rbp
testb $0x2, 0xa8(%rbp)
jne 0x11b38
movq (%r14), %rax
movq %r14, %rdi
movq %rbp, %rsi
callq *0x2c0(%rax)
movsd 0x90(%rbp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
movq %rbp, %rdx
callq 0x11c12
movq %r12, %rdi
movq %r15, %rsi
movsd 0x18(%rsp), %xmm0
callq 0x3cf76
movq %r13, %rdi
movq %r12, %rsi
callq 0x3ce6c
movsd 0x8(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
incq %rbx
movslq 0x34(%r14), %rax
cmpq %rax, %rbx
jl 0x11b12
jmp 0x11bd2
cmpl $0x0, 0x14(%r14)
jle 0x11be3
movq %rbx, 0x10(%rsp)
xorpd %xmm0, %xmm0
xorl %ebx, %ebx
leaq 0x20(%rsp), %r15
movsd %xmm0, 0x8(%rsp)
movq 0x8(%r14), %rax
movq (%rax,%rbx,8), %rsi
addq $0x18, %rsi
movq %r15, %rdi
callq 0x3ce6c
movsd 0x8(%rsp), %xmm0
addsd 0x90472(%rip), %xmm0    # 0xa2038
incq %rbx
movslq 0x14(%r14), %rax
cmpq %rax, %rbx
jl 0x11b9e
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq 0x10(%rsp), %rbx
jne 0x11bf2
jp 0x11bf2
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x3c542
jmp 0x11bff
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x3cf98
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/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 0x4d4e38(%rip), %rsi    # 0x4e6a60
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3c542
movq 0x8(%r15), %rsi
addq $0x18, %rsi
movq %r14, %rdi
callq 0x3ce6c
movq 0x10(%r15), %rsi
addq $0x18, %rsi
movq %r14, %rdi
callq 0x3ce6c
movq 0x18(%r15), %rsi
addq $0x18, %rsi
movq %r14, %rdi
callq 0x3ce6c
movsd 0x9056b(%rip), %xmm0    # 0xa21d8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3cf98
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x60, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
testq %rsi, %rsi
je 0x11d13
callq 0x3c542
jmp 0x11d1b
movq %rbx, %rsi
callq 0x11ac4
cmpl $0x0, 0x34(%rbx)
jle 0x11dc9
xorpd %xmm0, %xmm0
xorl %r13d, %r13d
leaq 0x48(%rsp), %r14
leaq 0x18(%rsp), %r15
xorpd %xmm1, %xmm1
movapd %xmm1, 0x30(%rsp)
movsd %xmm0, (%rsp)
movq 0x28(%rbx), %rax
movq (%rax,%r13,8), %r12
testb $0x2, 0xa8(%r12)
jne 0x11d67
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0x2c0(%rax)
movsd 0x90(%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rdx
callq 0x11c12
movq %r14, %rdi
movq %r15, %rsi
callq 0x49404
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
movapd 0x30(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm2, %xmm0
incq %r13
movslq 0x34(%rbx), %rax
cmpq %rax, %r13
jl 0x11d3a
divsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
cmpeqsd %xmm0, %xmm2
andnpd %xmm1, %xmm2
jmp 0x11e1a
cmpl $0x0, 0x14(%rbx)
jle 0x11e16
xorpd %xmm2, %xmm2
xorl %r15d, %r15d
leaq 0x18(%rsp), %r14
movapd %xmm2, (%rsp)
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq $0x18, %rdi
movq %r14, %rsi
callq 0x49404
movapd (%rsp), %xmm2
addsd %xmm0, %xmm2
incq %r15
movslq 0x14(%rbx), %rax
cmpq %rax, %r15
jl 0x11ddb
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm2
jmp 0x11e1a
xorpd %xmm2, %xmm2
movapd %xmm2, %xmm0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x0, 0x24(%rdi)
jle 0x11f79
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm1, %xmm1
xorl %r14d, %r14d
leaq 0xd3c90(%rip), %r15     # 0xe5b98
xorl %ebp, %ebp
movsd %xmm1, (%rsp)
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
callq 0x11f92
movsd (%r15), %xmm1
movapd %xmm0, %xmm2
cmpnlepd %xmm1, %xmm2
xorpd 0x900eb(%rip), %xmm1    # 0xa2020
cmpnlepd %xmm0, %xmm1
orpd %xmm2, %xmm1
movq %xmm1, %rax
testb $0x1, %al
jne 0x11f4e
movsd (%rsp), %xmm1
jmp 0x11f57
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
andl $0x1, %eax
addl %eax, %ebp
incq %r14
movslq 0x24(%rbx), %rax
cmpq %rax, %r14
jl 0x11f0a
testl %ebp, %ebp
je 0x11f7f
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
jmp 0x11f83
xorpd %xmm1, %xmm1
jmp 0x11f8d
xorpd %xmm1, %xmm1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movl %r8d, %r12d
movl %ecx, 0x4(%rsp)
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xcf744(%rip), %rax     # 0xe20e8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0xd364a(%rip), %rbp     # 0xe6000
leaq 0x8(%rbp), %rsi
movq %r14, %rdi
callq 0x2c2be
movl $0x88, %esi
leaq (%rbx,%rsi), %rdi
addq 0xd260e(%rip), %rsi     # 0xe4fe0
callq 0x2c2be
movq 0x108(%rbp), %rax
movq %rax, 0x108(%rbx)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x11ac4
testl %r13d, %r13d
jne 0x12a2d
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
leaq 0xa0(%rsp), %rdi
callq 0x3cfc6
leaq 0xa0(%rsp), %rsi
movq %r14, %rdi
callq 0x2d3f8
andb $-0x3, 0x108(%rbx)
testl $0xfffffffd, %r12d      # imm = 0xFFFFFFFD
je 0x12a6f
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x11cf2
leaq 0xd314e(%rip), %rax     # 0xe5b98
ucomisd (%rax), %xmm0
jbe 0x12a6f
movsd 0x8f5e0(%rip), %xmm1    # 0xa2038
divsd %xmm0, %xmm1
movq %r14, %rdi
movapd %xmm1, %xmm0
callq 0x2d5a6
andb $-0x3, 0x108(%rbx)
cmpl $0x0, 0x4(%rsp)
je 0x12adb
leaq 0x8f8a5(%rip), %rdi     # 0xa2322
xorl %eax, %eax
callq 0x718f6
leaq 0xd372d(%rip), %rsi     # 0xe61b8
leaq 0x1b0(%rsp), %rdi
callq 0x2ab46
leaq 0x20(%rsp), %rdi
leaq 0x1b0(%rsp), %rsi
callq 0x2ad48
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0x29fda
leaq 0xa0(%rsp), %rsi
movq %rbx, %rdi
callq 0x2a196
leaq 0xa0(%rsp), %rdi
callq 0x2a028
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
leaq 0x20(%rsp), %rdi
callq 0x3cfc6
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3dc00
leaq 0xa0(%rsp), %rsi
movq %r14, %rdi
callq 0x2d3f8
andb $-0x3, 0x108(%rbx)
movq %rbx, %rax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0xa0(%rsp), %rdi
callq 0x2a028
jmp 0x12b61
jmp 0x12b5e
jmp 0x12b5e
jmp 0x12b5e
jmp 0x12b5e
jmp 0x12b5e
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a6bc
jmp 0x12b69
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a028
movq %r14, %rdi
callq 0xe7e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, (%rsp)
cmpl $0x0, 0x14(%rsi)
xorpd %xmm3, %xmm3
xorpd %xmm2, %xmm2
jle 0x12f0e
movq %rsi, %rbx
leaq 0x18(%rsi), %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
movq 0x10(%rsp), %r14
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
testq %rax, %rax
je 0x12f06
movq 0x8(%rax), %rsi
movl $0x20, %ecx
cmpq %rbx, %rsi
jne 0x12e26
movq 0x10(%rax), %rsi
movl $0x18, %ecx
movq (%rax,%rcx), %rbp
testq %rbp, %rbp
je 0x12f06
cmpq %rbx, 0x8(%rbp)
je 0x12e4f
cmpq %rbx, 0x10(%rbp)
je 0x12e56
movl $0x28, %eax
cmpq %rbx, 0x18(%rbp)
je 0x12e5b
jmp 0x12f06
movl $0x30, %eax
jmp 0x12e5b
movl $0x20, %eax
movq (%rbp,%rax), %rax
testq %rax, %rax
je 0x12f06
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x20(%rsp)
movq 0x8(%rax), %r12
cmpq %rbx, %r12
jne 0x12e82
movq 0x10(%rax), %r12
addq $0x18, %rsi
addq $0x18, %r12
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x3c78e
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3c78e
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x4bc63
testb $0x2, 0xa8(%rbp)
jne 0x12edc
movq (%rsp), %rdi
movq (%rdi), %rax
movq %rbp, %rsi
movsd %xmm0, 0x8(%rsp)
callq *0x2c0(%rax)
movsd 0x8(%rsp), %xmm0
movsd 0x20(%rsp), %xmm2
addsd 0x90(%rbp), %xmm2
movsd 0x18(%rsp), %xmm3
addsd %xmm0, %xmm3
incq %r13
movslq 0x14(%rbx), %rax
cmpq %rax, %r13
jl 0x12dfe
jmp 0x12f0e
xorpd %xmm3, %xmm3
xorpd %xmm2, %xmm2
leaq 0x970d3(%rip), %rax     # 0xa9fe8
movsd (%rax), %xmm1
subsd %xmm3, %xmm1
mulsd 0x8f2b3(%rip), %xmm1    # 0xa21d8
divsd %xmm2, %xmm1
xorpd %xmm0, %xmm0
cmpltsd %xmm2, %xmm0
andpd %xmm1, %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x12cc2
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x12f68
jnp 0x12fa2
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12faa
testb $0x2, 0x78(%rbx)
jne 0x12f8b
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x2b0(%rax)
addq $0x30, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3d252
xorpd 0x8f07e(%rip), %xmm0    # 0xa2020
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x8(%rdx), %rdx
movq 0x10(%r14), %rsi
addq $0x18, %rsi
addq $0x18, %rdx
callq 0x3c78e
testb $0x2, 0x38(%r14)
jne 0x131b7
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x2b8(%rax)
movsd 0x28(%r14), %xmm0
leaq 0xd29d4(%rip), %rax     # 0xe5b98
ucomisd (%rax), %xmm0
jbe 0x131d2
movq %rbx, %rdi
callq 0x3db98
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x954ec(%rip), %rsi     # 0xa86e0
callq 0x3cfd6
movq 0x18(%r15), %r12
movq 0x20(%r15), %r15
testq %r12, %r12
je 0x1322f
testb $0x4, 0xa8(%r12)
jne 0x13220
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x2c8(%rax)
addq $0x38, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3d984
testq %r15, %r15
je 0x1325c
testb $0x4, 0xa8(%r15)
jne 0x1324d
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x2c8(%rax)
addq $0x38, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d984
movq %rbx, %rdi
callq 0x3d2dc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x8(%rdx), %rax
movq 0x10(%rdx), %rcx
movsd 0x58(%rax), %xmm0
movsd 0x60(%rax), %xmm1
addsd 0x58(%rcx), %xmm0
addsd 0x60(%rcx), %xmm1
movq 0x18(%rdx), %r15
movsd 0x68(%rax), %xmm2
addsd 0x68(%rcx), %xmm2
movq %rsp, %r14
movq %r14, %rdi
callq 0x6f680
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
addsd 0x58(%r15), %xmm0
addsd 0x60(%r15), %xmm1
movsd 0x10(%r14), %xmm2
addsd 0x68(%r15), %xmm2
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x6f680
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
movsd 0x8eddc(%rip), %xmm3    # 0xa21d8
divsd %xmm3, %xmm0
divsd %xmm3, %xmm1
movsd 0x10(%r14), %xmm2
divsd %xmm3, %xmm2
movq %rbx, %rdi
callq 0x6f680
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq 0x20(%rsi), %r12
movq 0x28(%rsi), %r15
movq 0x30(%rsi), %rbx
testb $0x2, 0x38(%r12)
jne 0x13455
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x2b8(%rax)
movsd 0x28(%r12), %xmm2
leaq 0xd2735(%rip), %r12     # 0xe5b98
movsd (%r12), %xmm0
movapd 0x8ebaf(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
ucomisd %xmm1, %xmm2
jb 0x13485
ucomisd %xmm2, %xmm0
jae 0x13509
testb $0x2, 0x38(%r15)
movsd %xmm2, 0x10(%rsp)
jne 0x134b3
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x2b8(%rax)
movsd (%r12), %xmm0
movapd 0x8eb71(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
movsd 0x28(%r15), %xmm5
ucomisd %xmm1, %xmm5
jb 0x134c5
ucomisd %xmm5, %xmm0
jae 0x13509
testb $0x2, 0x38(%rbx)
jne 0x134f8
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movsd %xmm5, 0x8(%rsp)
callq *0x2b8(%rax)
movsd 0x8(%rsp), %xmm5
movsd (%r12), %xmm0
movapd 0x8eb2c(%rip), %xmm1    # 0xa2020
xorpd %xmm0, %xmm1
movsd 0x28(%rbx), %xmm2
ucomisd %xmm1, %xmm2
jb 0x13520
ucomisd %xmm2, %xmm0
jb 0x13520
leaq 0xd2698(%rip), %rax     # 0xe5ba8
movsd (%rax), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movsd 0x10(%rsp), %xmm4
movapd %xmm4, %xmm1
addsd %xmm5, %xmm1
addsd %xmm2, %xmm1
mulsd 0x8eaf6(%rip), %xmm1    # 0xa2030
movapd %xmm4, %xmm0
mulsd %xmm5, %xmm0
mulsd %xmm2, %xmm0
movapd %xmm1, %xmm3
subsd %xmm4, %xmm3
mulsd 0x8eca2(%rip), %xmm3    # 0xa21f8
movapd %xmm1, %xmm4
subsd %xmm5, %xmm4
mulsd %xmm3, %xmm4
subsd %xmm2, %xmm1
mulsd %xmm4, %xmm1
divsd %xmm1, %xmm0
jmp 0x13514
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4d34d5(%rip), %rsi    # 0x4e6a60
callq 0x3c542
movsd (%r15), %xmm0
movq 0x8(%r14), %rsi
addq $0x18, %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x3cf76
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3ce6c
movsd 0x8(%r15), %xmm0
movq 0x10(%r14), %rsi
addq $0x18, %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x3cf76
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3ce6c
movsd 0x10(%r15), %xmm0
movq 0x18(%r14), %rsi
addq $0x18, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x3cf76
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ce6c
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c542
movq 0x10(%r14), %rsi
addq $0x18, %rsi
leaq 0x68(%rsp), %r13
movq %r13, %rdi
callq 0x3c542
movq 0x18(%r14), %rsi
addq $0x18, %rsi
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
callq 0x3c542
leaq 0x38(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x3c78e
leaq 0x20(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x3c78e
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3c78e
addq $0x38, %r14
movq %r14, %rdi
callq 0x3d14e
leal 0x1(%rax), %ecx
movslq %ecx, %rcx
imulq $0x55555556, %rcx, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
negl %ecx
addl %eax, %ecx
incl %ecx
movl %eax, %edx
addl $0x2, %edx
movslq %edx, %rdx
imulq $0x55555556, %rdx, %rdx # imm = 0x55555556
movq %rdx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rdx
addl %esi, %edx
leal (%rdx,%rdx,2), %edx
negl %edx
addl %edx, %eax
addl $0x2, %eax
cltq
movsd 0x38(%rsp,%rax,8), %xmm4
movslq %ecx, %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 0x13739
jp 0x13739
leaq 0x4d3331(%rip), %rsi    # 0x4e6a60
movq %rbx, %rdi
callq 0x3c542
jmp 0x13795
movapd 0x8e8df(%rip), %xmm5    # 0xa2020
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 0x8e8bb(%rip), %xmm0    # 0xa2038
subsd %xmm1, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
subsd %xmm2, %xmm0
movq %rbx, %rdi
callq 0x3c532
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/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), %rax
testq %rax, %rax
jle 0x1380e
movq 0x8(%rsi), %rcx
movq (%rcx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x13811
movb $0x1, %dl
movl $0x1, %esi
cmpq $0x0, 0x20(%rdi)
je 0x13807
cmpq %rax, %rsi
setb %dl
je 0x13807
movq (%rcx,%rsi,8), %rdi
incq %rsi
cmpq $0x0, 0x18(%rdi)
jne 0x137ea
movzbl %dl, %eax
andl $0x1, %eax
retq
xorl %eax, %eax
retq
movl $0x1, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c89a
andb $-0x3, 0x78(%r15)
movslq 0x14(%r15), %rax
testq %rax, %rax
jle 0x138c8
movq 0x8(%r15), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
andq $-0x3, 0x38(%rsi)
movq 0x8(%rsi), %rdi
cmpq %r15, %rdi
jne 0x1389c
movq 0x10(%rsi), %rdi
andb $-0x3, 0x78(%rdi)
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0x138b0
andb $-0xd, 0xa8(%rdi)
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x138c0
andb $-0xd, 0xa8(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0x13886
leaq 0xf8(%rbx), %rdi
movq %r14, %rsi
callq 0x27cc6
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x290(%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpq %rdx, %rsi
je 0x13914
movslq 0x14(%rsi), %rcx
testq %rcx, %rcx
jle 0x13914
movq 0x8(%rsi), %rsi
xorl %edi, %edi
movq (%rsi,%rdi,8), %rax
cmpq %rdx, 0x8(%rax)
je 0x13916
cmpq %rdx, 0x10(%rax)
je 0x13916
incq %rdi
cmpq %rdi, %rcx
jne 0x138fc
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1392d
cmpq %rsi, 0x10(%rdx)
je 0x1393d
cmpq %rsi, 0x18(%rdx)
je 0x1394e
xorl %eax, %eax
retq
xorl %eax, %eax
testl %ecx, %ecx
sete %al
shll $0x4, %eax
orq $0x20, %rax
jmp 0x1395d
xorl %eax, %eax
testl %ecx, %ecx
setne %al
leaq 0x20(,%rax,8), %rax
jmp 0x1395d
xorl %eax, %eax
testl %ecx, %ecx
setne %al
leaq 0x28(,%rax,8), %rax
movq (%rdx,%rax), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1397e
cmpq %rsi, 0x10(%rcx)
je 0x13991
cmpq %rsi, 0x18(%rcx)
jne 0x139a3
movq 0x28(%rcx), %rsi
movq 0x30(%rcx), %rax
jmp 0x13999
movq 0x20(%rcx), %rax
movq 0x30(%rcx), %rcx
cmpq %rdx, %rax
je 0x139aa
cmpq %rdx, %rcx
jne 0x139a3
retq
movq 0x20(%rcx), %rsi
movq 0x28(%rcx), %rax
cmpq %rdx, %rax
je 0x139a6
cmpq %rdx, %rsi
je 0x13990
xorl %eax, %eax
retq
movq %rsi, %rax
retq
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x139f2
movq 0x8(%rsi), %rax
movq 0x8(%rdx), %rcx
cmpq %rcx, %rax
je 0x139f1
movq 0x10(%rdx), %rdx
cmpq %rdx, %rax
je 0x139f1
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_O3/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 0x13a62
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
callq 0x13ab8
testq %rax, %rax
je 0x13a65
movl $0x1, %ecx
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 0x13a5d
movq 0x10(%r14), %rsi
cmpq %rsi, %rax
je 0x13a5d
movq 0x18(%r14), %rcx
cmpq %rcx, %rax
je 0x13a5d
movq 0x10(%rbx), %rax
cmpq %rcx, %rax
je 0x13a5d
cmpq %rdx, %rax
je 0x13a5d
cmpq %rsi, %rax
je 0x13a5d
movq 0x18(%rbx), %rax
cmpq %rdx, %rax
sete %dl
cmpq %rsi, %rax
sete %sil
orb %dl, %sil
jne 0x13a5d
xorl %edx, %edx
cmpq %rcx, %rax
cmovneq %rdx, %rax
jmp 0x13a5d
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13b04
movq 0x20(%rsi), %rax
movq 0x18(%rax), %rcx
cmpq %rsi, %rcx
jne 0x13ace
movq 0x20(%rax), %rcx
cmpq %rdx, %rcx
je 0x13b06
movq 0x28(%rsi), %rax
movq 0x18(%rax), %rcx
cmpq %rsi, %rcx
jne 0x13ae4
movq 0x20(%rax), %rcx
cmpq %rdx, %rcx
je 0x13b06
movq 0x30(%rsi), %rcx
movq 0x18(%rcx), %rdi
cmpq %rsi, %rdi
jne 0x13afa
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_O3/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, %r12
movq 0x20(%rsi), %rbx
movq 0x28(%rsi), %r14
movq 0x30(%rsi), %r15
testb $0x2, 0x38(%rbx)
jne 0x13b38
movq (%r12), %rax
movq %r12, %rdi
movq %rbx, %rsi
callq *0x2b8(%rax)
movsd 0x28(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
testb $0x2, 0x38(%r14)
jne 0x13b5a
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x2b8(%rax)
movsd 0x28(%r14), %xmm2
testb $0x2, 0x38(%r15)
jne 0x13b83
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
movsd %xmm2, 0x8(%rsp)
callq *0x2b8(%rax)
movsd 0x8(%rsp), %xmm2
movsd 0x28(%r15), %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm1, %xmm0
cmovbeq %r15, %rbx
ucomisd %xmm2, %xmm0
cmovbeq %r15, %r14
ucomisd %xmm1, %xmm2
cmovaq %rbx, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
movq 0x20(%rsi), %rbx
movq 0x28(%rsi), %r14
movq 0x30(%rsi), %r15
testb $0x2, 0x38(%rbx)
jne 0x13be6
movq (%r12), %rax
movq %r12, %rdi
movq %rbx, %rsi
callq *0x2b8(%rax)
movsd 0x28(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
testb $0x2, 0x38(%r14)
jne 0x13c08
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x2b8(%rax)
movsd 0x28(%r14), %xmm2
testb $0x2, 0x38(%r15)
jne 0x13c31
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
movsd %xmm2, 0x8(%rsp)
callq *0x2b8(%rax)
movsd 0x8(%rsp), %xmm2
movsd 0x28(%r15), %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
cmovbeq %r15, %rbx
ucomisd %xmm0, %xmm2
cmovbeq %r15, %r14
ucomisd %xmm2, %xmm1
cmovaq %rbx, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd1835(%rip)           # 0xe54b0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6f80c
movl 0xc(%r15), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x6f8a2
movl 0xd1813(%rip), %eax     # 0xe54b0
movl %eax, 0x88(%r14)
movl 0x14(%rsp), %eax
testl %eax, %eax
je 0x13d31
leaq 0x8(%rsp), %r14
movq 0x8(%rsp), %rcx
movslq %eax, %rsi
movq -0x8(%rcx,%rsi,8), %r15
decl %esi
movq %r14, %rdi
callq 0x6fa2c
movl 0xc(%rbx), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f8a2
movl 0x14(%r15), %eax
testl %eax, %eax
jle 0x13d29
xorl %r12d, %r12d
movq 0x8(%r15), %rcx
movq (%rcx,%r12,8), %rcx
movq 0x8(%rcx), %rsi
cmpq %r15, %rsi
jne 0x13cfa
movq 0x10(%rcx), %rsi
movl 0xd17b0(%rip), %ecx     # 0xe54b0
cmpl %ecx, 0x88(%rsi)
je 0x13d1e
movl %ecx, 0x88(%rsi)
movl 0x14(%rsp), %edx
movq %r14, %rdi
callq 0x6f8a2
movl 0x14(%r15), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0x13ce5
movl 0x14(%rsp), %eax
testl %eax, %eax
jne 0x13cb5
leaq 0x8(%rsp), %rdi
callq 0x6f876
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x13d4b
jmp 0x13d4b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6f876
movq %rbx, %rdi
callq 0xe7e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd173b(%rip)           # 0xe54b0
movq %rsp, %r15
movq %r15, %rdi
callq 0x6f80c
movl 0xc(%r15), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x6f8a2
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x13e54
movq %rsp, %r14
movq (%rsp), %rcx
movslq %eax, %rsi
movq -0x8(%rcx,%rsi,8), %r15
decl %esi
movq %r14, %rdi
callq 0x6fa2c
movl 0xb8(%r15), %eax
cmpl 0xd16ef(%rip), %eax     # 0xe54b0
je 0x13e48
movl 0xc(%rbx), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f8a2
movq 0x20(%r15), %rax
movq 0x18(%rax), %rsi
cmpq %r15, %rsi
jne 0x13de6
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x13df7
movl 0xc(%rsp), %edx
movq %r14, %rdi
callq 0x6f8a2
movq 0x28(%r15), %rax
movq 0x18(%rax), %rsi
cmpq %r15, %rsi
jne 0x13e08
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x13e19
movl 0xc(%rsp), %edx
movq %r14, %rdi
callq 0x6f8a2
movq 0x30(%r15), %rax
movq 0x18(%rax), %rsi
cmpq %r15, %rsi
jne 0x13e2a
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x13e3b
movl 0xc(%rsp), %edx
movq %r14, %rdi
callq 0x6f8a2
movl 0xd166f(%rip), %eax     # 0xe54b0
movl %eax, 0xb8(%r15)
movl 0xc(%rsp), %eax
testl %eax, %eax
jne 0x13d9e
movq %rsp, %rdi
callq 0x6f876
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x13e68
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6f876
movq %rbx, %rdi
callq 0xe7e0
nop