LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::AddRandomNoise(double)
void R3Mesh::
AddRandomNoise(RNScalar factor)
{
  // Change every vertex position
  bbox = R3null_box;
  for (int i = 0; i < NVertices(); i++) {
    R3MeshVertex *vertex = Vertex(i);
    RNLength max_distance = factor * VertexAverageEdgeLength(vertex);
    R3Vector random_vector(RNRandomScalar(), RNRandomScalar(), RNRandomScalar());
    vertex->position += max_distance * random_vector;
    vertex->flags.Remove(R3_MESH_VERTEX_NORMAL_UPTODATE);
    bbox.Union(vertex->position);
  }

  // Mark every edge out of date
  for (int i = 0; i < NEdges(); i++) {
    R3MeshEdge *edge = Edge(i);
    edge->flags.Remove(R3_MESH_EDGE_LENGTH_UPTODATE);
  }

  // Mark every face out of date
  for (int i = 0; i < NFaces(); i++) {
    R3MeshFace *face = Face(i);
    face->flags.Remove(R3_MESH_FACE_PLANE_UPTODATE | R3_MESH_FACE_BBOX_UPTODATE);
  }

  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
addq $0xf8, %rdi
leaq 0xc76d1(%rip), %rsi     # 0xdaea8
movq %rdi, (%rsp)
callq 0x2141e
xorl %r14d, %r14d
leaq 0x40(%rsp), %r15
leaq 0x28(%rsp), %r12
movslq 0x14(%rbx), %rax
cmpq %rax, %r14
jge 0x13885
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12380
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
callq 0x67e16
movsd %xmm0, 0x18(%rsp)
callq 0x67e16
movsd %xmm0, 0x10(%rsp)
callq 0x67e16
movapd %xmm0, %xmm2
movq %r15, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x3830c
movq %r12, %rdi
movq %r15, %rsi
movsd 0x20(%rsp), %xmm0
callq 0x38a02
leaq 0x18(%r13), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x37e9c
andb $-0x3, 0x78(%r13)
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x254a4
incq %r14
jmp 0x137ed
movl 0x24(%rbx), %eax
movq 0x18(%rbx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x138a6
movq (%rcx,%rdx,8), %rsi
andq $-0x3, 0x38(%rsi)
incq %rdx
jmp 0x13893
movl 0x34(%rbx), %eax
movq 0x28(%rbx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x138ca
movq (%rcx,%rdx,8), %rsi
andq $-0xd, 0xa8(%rsi)
incq %rdx
jmp 0x138b4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x290(%rax)
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::Inflate(double)
void R3Mesh::
Inflate(RNScalar factor)
{
  // Change every vertex position
  bbox = R3null_box;
  for (int i = 0; i < NVertices(); i++) {
    R3MeshVertex *vertex = Vertex(i);
    RNLength distance = factor * VertexAverageEdgeLength(vertex);
    R3Vector normal_vector = VertexNormal(vertex);
    vertex->position += distance * normal_vector;
    vertex->flags.Remove(R3_MESH_VERTEX_NORMAL_UPTODATE);
    bbox.Union(vertex->position);
  }

  // Mark every edge out of date
  for (int i = 0; i < NEdges(); i++) {
    R3MeshEdge *edge = Edge(i);
    edge->flags.Remove(R3_MESH_EDGE_LENGTH_UPTODATE);
  }

  // Mark every face out of date
  for (int i = 0; i < NFaces(); i++) {
    R3MeshFace *face = Face(i);
    face->flags.Remove(R3_MESH_FACE_PLANE_UPTODATE | R3_MESH_FACE_BBOX_UPTODATE);
  }

  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
addq $0xf8, %rdi
leaq 0xc759d(%rip), %rsi     # 0xdaea8
movq %rdi, (%rsp)
callq 0x2141e
xorl %r14d, %r14d
leaq 0x30(%rsp), %r15
leaq 0x18(%rsp), %r12
movslq 0x14(%rbx), %rax
cmpq %rax, %r14
jge 0x13995
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12380
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21234
movq %r15, %rdi
movq %rax, %rsi
callq 0x3831c
movq %r12, %rdi
movq %r15, %rsi
movsd 0x10(%rsp), %xmm0
callq 0x38a02
leaq 0x18(%r13), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x37e9c
andb $-0x3, 0x78(%r13)
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x254a4
incq %r14
jmp 0x13921
movl 0x24(%rbx), %eax
movq 0x18(%rbx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x139b6
movq (%rcx,%rdx,8), %rsi
andq $-0x3, 0x38(%rsi)
incq %rdx
jmp 0x139a3
movl 0x34(%rbx), %eax
movq 0x28(%rbx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x139da
movq (%rcx,%rdx,8), %rsi
andq $-0xd, 0xa8(%rsi)
incq %rdx
jmp 0x139c4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x290(%rax)
addq $0x48, %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::Transform(gaps::R3Transformation const&)
void R3Mesh::
Transform(const R3Transformation& transformation)
{
  // Transform every vertex position
  bbox = R3null_box;
  for (int i = 0; i < NVertices(); i++) {
    R3MeshVertex *vertex = Vertex(i);
    vertex->position.Transform(transformation);
    vertex->flags.Remove(R3_MESH_VERTEX_NORMAL_UPTODATE);
    bbox.Union(vertex->position);
  }

  // Mark every edge out of date
  for (int i = 0; i < NEdges(); i++) {
    R3MeshEdge *edge = Edge(i);
    edge->flags.Remove(R3_MESH_EDGE_LENGTH_UPTODATE);
  }

  // Mark every face out of date
  for (int i = 0; i < NFaces(); i++) {
    R3MeshFace *face = Face(i);
    face->flags.Remove(R3_MESH_FACE_PLANE_UPTODATE | R3_MESH_FACE_BBOX_UPTODATE);
  }

  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf8(%rdi), %r15
leaq 0xc7493(%rip), %rsi     # 0xdaea8
movq %r15, %rdi
callq 0x2141e
xorl %r13d, %r13d
movslq 0x14(%rbx), %rax
cmpq %rax, %r13
jge 0x13a54
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rbp
leaq 0x18(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x38192
andb $-0x3, 0x78(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x254a4
incq %r13
jmp 0x13a20
movl 0x24(%rbx), %eax
movq 0x18(%rbx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x13a75
movq (%rcx,%rdx,8), %rsi
andq $-0x3, 0x38(%rsi)
incq %rdx
jmp 0x13a62
movl 0x34(%rbx), %eax
movq 0x28(%rbx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x13a99
movq (%rcx,%rdx,8), %rsi
andq $-0xd, 0xa8(%rsi)
incq %rdx
jmp 0x13a83
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x290(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::CreateVertex(gaps::R3MeshVertex const&, gaps::R3MeshVertex*)
R3MeshVertex *R3Mesh::
CreateVertex(const R3MeshVertex& source_vertex, R3MeshVertex *v)
{
  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();

  // Create vertex
  if (!v) {
    v = new R3MeshVertex();
    v->flags.Add(R3_MESH_VERTEX_ALLOCATED);
  }

  // Set position/normal of new vertex
  SetVertexPosition(v, source_vertex.position);
  if (!source_vertex.normal.IsZero()) SetVertexNormal(v, source_vertex.normal);
  SetVertexColor(v, source_vertex.color);
  SetVertexTextureCoords(v, source_vertex.texcoords);

  // Set ID of new vertex
  v->id = vertices.NEntries();

  // Insert vertex into array
  vertices.Insert(v);

  // Return vertex
  return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
callq *0x290(%rax)
testq %rbx, %rbx
jne 0x13aec
movl $0x98, %edi
callq 0xe450
movq %rax, %rbx
movq %rax, %rdi
callq 0x2108c
orb $0x1, 0x78(%rbx)
leaq 0x18(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12ccc
leaq 0x30(%r15), %r12
movq %r12, %rdi
callq 0x21450
testl %eax, %eax
jne 0x13b19
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x21486
leaq 0x58(%r15), %rsi
leaq 0x58(%rbx), %rdi
callq 0x66212
addq $0x48, %r15
leaq 0x48(%rbx), %rdi
movq %r15, %rsi
callq 0x5f6c4
movl 0x14(%r14), %eax
addq $0x8, %r14
movl %eax, 0x70(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22bfc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x98, %esi
movq %rbx, %rdi
callq 0xe460
movq %r14, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::CreateVertex(gaps::R3Point const&, gaps::R3MeshVertex*)
R3MeshVertex *R3Mesh::
CreateVertex(const R3Point& position, R3MeshVertex *v)
{
  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();

  // Create vertex
  if (!v) {
    v = new R3MeshVertex();
    v->flags.Add(R3_MESH_VERTEX_ALLOCATED);
  }

  // Set position of new vertex
  SetVertexPosition(v, position);

  // Set ID of new vertex
  v->id = vertices.NEntries();

  // Insert vertex into array
  vertices.Insert(v);

  // Return vertex
  return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
callq *0x290(%rax)
testq %rbx, %rbx
jne 0x13ba9
movl $0x98, %edi
callq 0xe450
movq %rax, %rbx
movq %rax, %rdi
callq 0x2108c
orb $0x1, 0x78(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x12ccc
movl 0x14(%r14), %eax
addq $0x8, %r14
movl %eax, 0x70(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22bfc
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x98, %esi
movq %rbx, %rdi
callq 0xe460
movq %r14, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::CreateVertex(gaps::R3Point const&, gaps::R3Vector const&, gaps::R3MeshVertex*)
R3MeshVertex *R3Mesh::
CreateVertex(const R3Point& position, const R3Vector& normal, R3MeshVertex *v)
{
  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();

  // Create vertex
  if (!v) {
    v = new R3MeshVertex();
    v->flags.Add(R3_MESH_VERTEX_ALLOCATED);
  }

  // Set position/normal of new vertex
  SetVertexPosition(v, position);
  if (!normal.IsZero()) SetVertexNormal(v, normal);

  // Set ID of new vertex
  v->id = vertices.NEntries();

  // Insert vertex into array
  vertices.Insert(v);

  // Return vertex
  return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
callq *0x290(%rax)
testq %rbx, %rbx
jne 0x13c29
movl $0x98, %edi
callq 0xe450
movq %rax, %rbx
movq %rax, %rdi
callq 0x2108c
orb $0x1, 0x78(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x12ccc
movq %r15, %rdi
callq 0x21450
testl %eax, %eax
jne 0x13c51
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x21486
movl 0x14(%r14), %eax
addq $0x8, %r14
movl %eax, 0x70(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22bfc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x98, %esi
movq %rbx, %rdi
callq 0xe460
movq %r14, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::CreateVertex(gaps::R3Point const&, gaps::R3Vector const&, gaps::RNRgb const&, gaps::R3MeshVertex*)
R3MeshVertex *R3Mesh::
CreateVertex(const R3Point& position, const R3Vector& normal, const RNRgb& color, R3MeshVertex *v)
{
  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();

  // Create vertex
  if (!v) {
    v = new R3MeshVertex();
    v->flags.Add(R3_MESH_VERTEX_ALLOCATED);
  }

  // Set position/normal of new vertex
  SetVertexPosition(v, position);
  if (!normal.IsZero()) SetVertexNormal(v, normal);
  SetVertexColor(v, color);

  // Set ID of new vertex
  v->id = vertices.NEntries();

  // Insert vertex into array
  vertices.Insert(v);

  // Return vertex
  return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq (%rdi), %rax
callq *0x290(%rax)
testq %rbx, %rbx
jne 0x13ccd
movl $0x98, %edi
callq 0xe450
movq %rax, %rbx
movq %rax, %rdi
callq 0x2108c
orb $0x1, 0x78(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x12ccc
movq %r12, %rdi
callq 0x21450
testl %eax, %eax
jne 0x13cf5
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x21486
leaq 0x58(%rbx), %rdi
movq %r15, %rsi
callq 0x66212
movl 0x14(%r14), %eax
addq $0x8, %r14
movl %eax, 0x70(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22bfc
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x98, %esi
movq %rbx, %rdi
callq 0xe460
movq %r14, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::CreateEdge(gaps::R3MeshVertex*, gaps::R3MeshVertex*, gaps::R3MeshEdge*)
R3MeshEdge *R3Mesh::
CreateEdge(R3MeshVertex *v1, R3MeshVertex *v2, R3MeshEdge *e)
{
  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();

  // Create edge
  if (!e) {
    e = new R3MeshEdge();
    e->flags.Add(R3_MESH_EDGE_ALLOCATED);
  }

  // Update edge-vertex relations
  e->vertex[0] = v1;
  e->vertex[1] = v2;

  // Set ID of new edge
  e->id = edges.NEntries();

  // Insert edge into vertex lists
  v1->edges.Insert(e);
  v2->edges.Insert(e);

  // Insert edge into array
  edges.Insert(e);

  // Return edge
  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
callq *0x290(%rax)
testq %rbx, %rbx
jne 0x13e61
pushq $0x58
popq %rdi
callq 0xe450
movq %rax, %rbx
leaq 0xc28fc(%rip), %rax     # 0xd6730
movq %rax, (%rbx)
andq $0x0, 0x28(%rbx)
orl $-0x1, 0x30(%rbx)
andq $0x0, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
andq $0x0, 0x40(%rbx)
andl $0x0, 0x48(%rbx)
movq $0x1, 0x38(%rbx)
movq %r12, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movl 0x24(%r14), %eax
addq $0x18, %r14
movl %eax, 0x30(%rbx)
addq $0x8, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x22bfc
addq $0x8, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22bfc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22bfc
movq %rbx, %rax
addq $0x8, %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::CreateFace(gaps::R3MeshVertex*, gaps::R3MeshVertex*, gaps::R3MeshVertex*, gaps::R3MeshFace*)
R3MeshFace *R3Mesh::
CreateFace(R3MeshVertex *v1, R3MeshVertex *v2, R3MeshVertex *v3, R3MeshFace *f)
{
  // Get/create edges
  R3MeshEdge *e1 = EdgeBetweenVertices(v1, v2);
  if (!e1) e1 = CreateEdge(v1, v2);
  R3MeshEdge *e2 = EdgeBetweenVertices(v2, v3);
  if (!e2) e2 = CreateEdge(v2, v3);
  R3MeshEdge *e3 = EdgeBetweenVertices(v3, v1);
  if (!e3) e3 = CreateEdge(v3, v1);
  assert(e1 && e2 && e3);

  // Create face
  return CreateFace(v1, v2, v3, e1, e2, e3, f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x12d5a
movq %rax, %rbp
testq %rax, %rax
jne 0x13ee9
movq (%r13), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq *0x40(%rax)
movq %rax, %rbp
movq %r15, %rsi
movq %r14, %rdx
callq 0x12d5a
movq %rax, %rbx
testq %rax, %rax
jne 0x13f11
movq (%r13), %rax
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq *0x40(%rax)
movq %rax, %rbx
movq %r14, %rsi
movq %r12, %rdx
callq 0x12d5a
testq %rax, %rax
jne 0x13f33
movq (%r13), %rax
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq *0x40(%rax)
movq (%r13), %r10
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbp, %r8
movq %rbx, %r9
pushq (%rsp)
pushq %rax
callq *0x58(%r10)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::CreateFace(gaps::R3MeshEdge*, gaps::R3MeshEdge*, gaps::R3MeshEdge*, gaps::R3MeshFace*)
R3MeshFace *R3Mesh::
CreateFace(R3MeshEdge *e1, R3MeshEdge *e2, R3MeshEdge *e3, R3MeshFace *f)
{
  // Get vertices
  R3MeshVertex *v1 = VertexBetweenEdges(e3, e1);
  R3MeshVertex *v2 = VertexBetweenEdges(e1, e2);
  R3MeshVertex *v3 = VertexBetweenEdges(e2, e3);
  assert(v1 && v2 && v3);

  // Create face
  return CreateFace(v1, v2, v3, e1, e2, e3, f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rcx, %rsi
movq %r12, %rdx
callq 0x12e36
movq %rax, %rbp
movq %r12, %rsi
movq %r15, %rdx
callq 0x12e36
movq %rax, %r14
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12e36
movq (%r13), %r10
movq %r13, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %r12, %r8
movq %r15, %r9
pushq (%rsp)
pushq %rbx
callq *0x58(%r10)
addq $0x18, %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::DeallocateVertex(gaps::R3MeshVertex*)
void R3Mesh::
DeallocateVertex(R3MeshVertex *v)
{
  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();

  // Remove vertex from mesh array by moving last vertex
  assert(!vertices.IsEmpty());
  R3MeshVertex *tail = vertices.Tail();
  int index = v->id;
  RNArrayEntry *entry = vertices.KthEntry(index);
  assert(vertices.EntryContents(entry) == v);
  vertices.EntryContents(entry) = tail;
  tail->id = index;
  vertices.RemoveTail();

  // Reset ID to ease debugging
  v->id = -1;

  // Deallocate vertex
  if (v->flags[R3_MESH_VERTEX_ALLOCATED]) delete v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x290(%rax)
leaq 0x8(%r14), %rdi
movslq 0x14(%r14), %rax
movq 0x8(%r14), %rcx
movq -0x8(%rcx,%rax,8), %rax
movslq 0x70(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movl %edx, 0x70(%rax)
callq 0x21340
orl $-0x1, 0x70(%rbx)
testq %rbx, %rbx
je 0x14176
movq 0x78(%rbx), %rax
andl $0x1, %eax
je 0x14176
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x8(%rax)
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::DeallocateEdge(gaps::R3MeshEdge*)
void R3Mesh::
DeallocateEdge(R3MeshEdge *e)
{
  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();

  // Remove edge from mesh array by moving last edge
  assert(!edges.IsEmpty());
  R3MeshEdge *tail = edges.Tail();
  int index = e->id;
  RNArrayEntry *entry = edges.KthEntry(index);
  assert(edges.EntryContents(entry) == e);
  edges.EntryContents(entry) = tail;
  tail->id = index;
  edges.RemoveTail();

  // Reset ID to ease debugging
  e->id = -1;

  // Deallocate edge
  if (e->flags[R3_MESH_EDGE_ALLOCATED]) delete e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x290(%rax)
leaq 0x18(%r14), %rdi
movslq 0x24(%r14), %rax
movq 0x18(%r14), %rcx
movq -0x8(%rcx,%rax,8), %rax
movslq 0x30(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movl %edx, 0x30(%rax)
callq 0x21340
orl $-0x1, 0x30(%rbx)
testq %rbx, %rbx
je 0x141d4
movq 0x38(%rbx), %rax
andl $0x1, %eax
je 0x141d4
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x8(%rax)
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::DeallocateFace(gaps::R3MeshFace*)
void R3Mesh::
DeallocateFace(R3MeshFace *f)
{
  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();

  // Remove face from mesh array by moving last face
  assert(!faces.IsEmpty());
  R3MeshFace *tail = faces.Tail();
  int index = f->id;
  RNArrayEntry *entry = faces.KthEntry(index);
  assert(faces.EntryContents(entry) == f);
  faces.EntryContents(entry) = tail;
  tail->id = index;
  faces.RemoveTail();

  // Reset ID to ease debugging
  f->id = -1;

  // Deallocate face
  if (f->flags[R3_MESH_FACE_ALLOCATED]) delete f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x290(%rax)
leaq 0x28(%r14), %rdi
movslq 0x34(%r14), %rax
movq 0x28(%r14), %rcx
movq -0x8(%rcx,%rax,8), %rax
movslq 0xa4(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movl %edx, 0xa4(%rax)
callq 0x21340
orl $-0x1, 0xa4(%rbx)
testq %rbx, %rbx
je 0x1423e
movq 0xa8(%rbx), %rax
andl $0x1, %eax
je 0x1423e
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x8(%rax)
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::DeleteVertex(gaps::R3MeshVertex*)
void R3Mesh::
DeleteVertex(R3MeshVertex *v)
{
  // Delete edges attached to vertex
  RNArray<R3MeshEdge *> vertex_edges = v->edges;
  for (int i = 0; i < vertex_edges.NEntries(); i++) 
    DeleteEdge(vertex_edges.Kth(i));

  // Deallocate vertex
  DeallocateVertex(v);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rsi
movq %rsp, %rdi
callq 0x66312
xorl %r15d, %r15d
movslq 0xc(%rsp), %rax
cmpq %rax, %r15
jge 0x14284
movq (%rsp), %rax
movq (%rax,%r15,8), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x68(%rax)
incq %r15
jmp 0x14264
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x298(%rax)
movq %rsp, %rdi
callq 0x66378
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x142a7
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::DeleteEdge(gaps::R3MeshEdge*)
void R3Mesh::
DeleteEdge(R3MeshEdge *e)
{
  // Delete faces attached to edge
  if (e->face[0]) DeleteFace(e->face[0]);
  if (e->face[1]) DeleteFace(e->face[1]);

  // Remove edge from vertex arrays
  e->vertex[0]->edges.Remove(e);
  e->vertex[1]->edges.Remove(e);

  // Deallocate edge
  DeallocateEdge(e);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
je 0x142d6
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x142e8
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
movq 0x8(%rbx), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x22c04
movq 0x10(%rbx), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x22c04
movq (%r14), %rax
movq 0x2a0(%rax), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::DeleteFace(gaps::R3MeshFace*)
void R3Mesh::
DeleteFace(R3MeshFace *f)
{
  // Update edge-face relations
  if (f->edge[0]->face[0] == f) f->edge[0]->face[0] = NULL;
  if (f->edge[0]->face[1] == f) f->edge[0]->face[1] = NULL;
  if (f->edge[1]->face[0] == f) f->edge[1]->face[0] = NULL;
  if (f->edge[1]->face[1] == f) f->edge[1]->face[1] = NULL;
  if (f->edge[2]->face[0] == f) f->edge[2]->face[0] = NULL;
  if (f->edge[2]->face[1] == f) f->edge[2]->face[1] = NULL;

  // Deallocate face
  DeallocateFace(f);
}

// Assembly:
movq 0x20(%rsi), %rax
cmpq %rsi, 0x18(%rax)
jne 0x14335
andq $0x0, 0x18(%rax)
movq 0x20(%rsi), %rax
cmpq %rsi, 0x20(%rax)
jne 0x14340
andq $0x0, 0x20(%rax)
movq 0x28(%rsi), %rax
cmpq %rsi, 0x18(%rax)
jne 0x14353
andq $0x0, 0x18(%rax)
movq 0x28(%rsi), %rax
cmpq %rsi, 0x20(%rax)
jne 0x1435e
andq $0x0, 0x20(%rax)
movq 0x30(%rsi), %rax
cmpq %rsi, 0x18(%rax)
jne 0x14371
andq $0x0, 0x18(%rax)
movq 0x30(%rsi), %rax
cmpq %rsi, 0x20(%rax)
jne 0x1437c
andq $0x0, 0x20(%rax)
movq (%rdi), %rax
movq 0x2a8(%rax), %rax
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::DeleteUnusedVertices()
void R3Mesh::
DeleteUnusedVertices(void)
{
  // Find unused vertices
  RNArray<R3MeshVertex *> unused_vertices;
  for (int i = 0; i < NVertices(); i++) {
    R3MeshVertex *vertex = Vertex(i);
    if (VertexValence(vertex) == 0) unused_vertices.Insert(vertex);
  }

  // Delete unused vertices
  for (int i = 0; i < unused_vertices.NEntries(); i++) {
    R3MeshVertex *vertex = unused_vertices.Kth(i);
    DeleteVertex(vertex);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x6630a
xorl %r15d, %r15d
movslq 0x14(%rbx), %rax
cmpq %rax, %r15
jge 0x143c6
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
cmpl $0x0, 0x14(%rsi)
jne 0x143c1
movq %r14, %rdi
callq 0x22bfc
incq %r15
jmp 0x143a2
xorl %r14d, %r14d
movslq 0xc(%rsp), %rax
cmpq %rax, %r14
jge 0x143e9
movq (%rsp), %rax
movq (%rax,%r14,8), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
incq %r14
jmp 0x143c9
movq %rsp, %rdi
callq 0x66378
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x143fd
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::DeleteUnusedEdges()
void R3Mesh::
DeleteUnusedEdges(void)
{
  // Find unused edges
  RNArray<R3MeshEdge *> unused_edges;
  for (int i = 0; i < NEdges(); i++) {
    R3MeshEdge *edge = Edge(i);
    if (!FaceOnEdge(edge, 0) && !FaceOnEdge(edge, 1)) unused_edges.Insert(edge);
  }

  // Delete unused edges
  for (int i = 0; i < unused_edges.NEntries(); i++) {
    R3MeshEdge *edge = unused_edges.Kth(i);
    DeleteEdge(edge);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x6630a
xorl %r15d, %r15d
movslq 0x24(%rbx), %rax
cmpq %rax, %r15
jge 0x14456
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rsi
cmpq $0x0, 0x18(%rsi)
jne 0x14451
cmpq $0x0, 0x20(%rsi)
jne 0x14451
movq %r14, %rdi
callq 0x22bfc
incq %r15
jmp 0x1442a
xorl %r14d, %r14d
movslq 0xc(%rsp), %rax
cmpq %rax, %r14
jge 0x14479
movq (%rsp), %rax
movq (%rax,%r14,8), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
incq %r14
jmp 0x14459
movq %rsp, %rdi
callq 0x66378
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1448d
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::CollapseFace(gaps::R3MeshFace*, gaps::R3Point const&)
R3MeshVertex *R3Mesh::
CollapseFace(R3MeshFace *f, const R3Point& point)
{
  // Collapse face into single point
  R3MeshVertex *v0 = VertexOnFace(f, 0);
  R3MeshVertex *v1 = VertexOnFace(f, 1);
  R3MeshVertex *v2 = VertexOnFace(f, 2);
  R3MeshEdge *e01 = EdgeBetweenVertices(v0, v1);
  R3MeshVertex *v01 = CollapseEdge(e01, point);
  if (!v01) return NULL;
  R3MeshEdge *e012 = EdgeBetweenVertices(v01, v2);
  assert(e012);
  R3MeshVertex *v012 = CollapseEdge(e012, point);
  return v012;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %r15
movq %rax, %rsi
callq 0x12d5a
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq *0x98(%rcx)
testq %rax, %rax
je 0x14dc1
movq %rax, %rsi
movq %r15, %rdx
callq 0x12d5a
movq (%r14), %rcx
movq 0x98(%rcx), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
xorl %eax, %eax
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::SplitEdge(gaps::R3MeshEdge*, gaps::R3Plane const&)
R3MeshVertex *R3Mesh::
SplitEdge(R3MeshEdge *e, const R3Plane& plane)
{
  // Compute intersection point with plane
  RNScalar t;
  R3Point point;
  R3Span edge_span = EdgeSpan(e);
  if (!R3Intersects(edge_span, plane, &point, &t)) return NULL;
  if ((RNIsEqual(t, 0.0)) || (RNIsEqual(t, edge_span.Length()))) return NULL;

  // Split edge
  return SplitEdge(e, point);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x37b4a
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x214e0
movq %rsp, %rcx
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3f506
testl %eax, %eax
je 0x15335
movsd (%rsp), %xmm0
leaq 0xc58a1(%rip), %rax     # 0xdaba8
movsd (%rax), %xmm1
movapd 0x7dd1d(%rip), %xmm2    # 0x93030
xorpd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x15323
ucomisd %xmm0, %xmm1
jae 0x15335
subsd 0x68(%rsp), %xmm0
ucomisd %xmm2, %xmm0
jb 0x15345
ucomisd %xmm0, %xmm1
jb 0x15345
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r14), %rax
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq *0xb8(%rax)
jmp 0x15337
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::FlipFace(gaps::R3MeshFace*)
void R3Mesh::
FlipFace(R3MeshFace *f)
{
  // Reverse orientation of plane
  f->plane.Flip();

  // Reverse order of vertices
  R3MeshVertex *vswap = f->vertex[0];
  f->vertex[0] = f->vertex[2];
  f->vertex[2] = vswap;

  // Reverse order of edges
  R3MeshEdge *eswap = f->edge[0];
  f->edge[0] = f->edge[1];
  f->edge[1] = eswap;

  // Invalidate GL buffer objects
  InvalidateGLBufferObjects();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rsi), %rdi
callq 0x21548
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movdqu 0x20(%rbx), %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movdqu %xmm0, 0x20(%rbx)
movq (%r14), %rax
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x290(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::FlipFaces()
void R3Mesh::
FlipFaces(void)
{
  // Reverse orientation of all faces
  for (int i = 0; i < NFaces(); i++) {
    R3MeshFace *f = Face(i);
    FlipFace(f);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x34(%rbx), %rax
cmpq %rax, %r14
jge 0x15bc4
movq (%rbx), %rax
movq 0x28(%rbx), %rcx
movq (%rcx,%r14,8), %rsi
movq %rbx, %rdi
callq *0xe0(%rax)
incq %r14
jmp 0x15ba2
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::FillHoles(double, double)
void R3Mesh::
FillHoles(RNLength max_perimeter, RNLength max_planar_deviation)
{
  // Set edge marks
  // Cleared in FillHole
  // Used to avoid trying to fill hole multiple times
  RNMark edge_mark = ++R3mesh_mark;
  for (int i = 0; i < NEdges(); i++) {
    R3MeshEdge *edge = Edge(i);
    SetEdgeMark(edge, edge_mark);
  }
  
  // Iteratively find boundary edge and fill hole
  for (int i = 0; i < NEdges(); i++) {
    R3MeshEdge *edge = Edge(i);
    if (!IsEdgeOnBoundary(edge)) continue;
    if (EdgeMark(edge) != edge_mark) continue;
    FillHole(edge, max_perimeter, max_planar_deviation);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
movl 0xc35c0(%rip), %ebp     # 0xda4c0
incl %ebp
movl %ebp, 0xc35b8(%rip)     # 0xda4c0
movl 0x24(%rdi), %eax
movq 0x18(%rdi), %rcx
movslq %eax, %rdx
xorl %esi, %esi
cmpq %rdx, %rsi
jge 0x16f25
movq (%rcx,%rsi,8), %rdi
movl %ebp, 0x48(%rdi)
incq %rsi
jmp 0x16f14
xorl %r14d, %r14d
movslq %eax, %rcx
cmpq %rcx, %r14
jge 0x16f66
movq 0x18(%rbx), %rcx
movq (%rcx,%r14,8), %rsi
cmpq $0x0, 0x18(%rsi)
je 0x16f46
cmpq $0x0, 0x20(%rsi)
jne 0x16f61
cmpl %ebp, 0x48(%rsi)
jne 0x16f61
movq %rbx, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x166f6
movl 0x24(%rbx), %eax
incq %r14
jmp 0x16f28
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::GLFacePositionBufferObject() const
unsigned int R3Mesh::
GLFacePositionBufferObject(void) const
{
  // Check if nothing to be done
  if (NFaces() == 0) return 0;
  
  // Update position buffer
  if (vbo_face_position_buffer == 0) {
    glGenBuffers(1, (GLuint *) &vbo_face_position_buffer);
    if (vbo_face_position_buffer > 0) {
      std::vector<GLfloat> positions;
      for (int i = 0; i < NFaces(); i++) {
        R3MeshFace *face = Face(i);
        for (int j = 0; j < 3; j++){
          R3MeshVertex *vertex = VertexOnFace(face, j);
          const R3Point& position = VertexPosition(vertex);
          positions.push_back(position.X());
          positions.push_back(position.Y());
          positions.push_back(position.Z());
        }
      }
      glBindBuffer(GL_ARRAY_BUFFER, vbo_face_position_buffer);
      glBufferData(GL_ARRAY_BUFFER, positions.size() * sizeof(GLfloat), &positions[0], GL_STATIC_DRAW);
      glBindBuffer(GL_ARRAY_BUFFER, 0);
    }
  }

  // Return position buffer identifier
  return vbo_face_position_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorl %eax, %eax
cmpl $0x0, 0x34(%rdi)
je 0x17422
movq %rdi, %r14
movl 0x50(%rdi), %eax
testl %eax, %eax
jne 0x17422
leaq 0x50(%r14), %rbx
movq 0xc2c6d(%rip), %rax     # 0xd9f98
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq *(%rax)
cmpl $0x0, (%rbx)
movl $0x0, %eax
je 0x17422
movq %rbx, 0x10(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movq %r14, 0x18(%rsp)
movslq 0x34(%r14), %rax
cmpq %rax, %r13
jge 0x173d6
movq 0x28(%r14), %rax
movq (%rax,%r13,8), %rbx
pushq $0x1
popq %rbp
cmpq $0x4, %rbp
je 0x173cc
movq (%rbx,%rbp,8), %r14
cvtsd2ss 0x18(%r14), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
cvtsd2ss 0x20(%r14), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
cvtsd2ss 0x28(%r14), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
incq %rbp
jmp 0x17378
incq %r13
movq 0x18(%rsp), %r14
jmp 0x17364
movq 0xc2bd3(%rip), %rbx     # 0xd9fb0
movq 0x10(%rsp), %r14
movl (%r14), %esi
movl $0x8892, %edi           # imm = 0x8892
callq *(%rbx)
movq 0xc2bd5(%rip), %rax     # 0xd9fc8
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
subq %rdx, %rsi
movl $0x8892, %edi           # imm = 0x8892
movl $0x88e4, %ecx           # imm = 0x88E4
callq *(%rax)
movl $0x8892, %edi           # imm = 0x8892
xorl %esi, %esi
callq *(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x23192
movl (%r14), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17437
jmp 0x17437
jmp 0x17437
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x23192
movq %rbx, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::GLFaceNormalBufferObject() const
unsigned int R3Mesh::
GLFaceNormalBufferObject(void) const
{
  // Check if nothing to be done
  if (NFaces() == 0) return 0;
  
  // Update normal buffer
  if (vbo_face_normal_buffer == 0) {
    glGenBuffers(1, (GLuint *) &vbo_face_normal_buffer);
    if (vbo_face_normal_buffer > 0) {
      std::vector<GLfloat> normals;
      for (int i = 0; i < NFaces(); i++) {
        R3MeshFace *face = Face(i);
        for (int j = 0; j < 3; j++){
          R3MeshVertex *vertex = VertexOnFace(face, j);
          const R3Vector& normal = VertexNormal(vertex);
          normals.push_back(normal.X());
          normals.push_back(normal.Y());
          normals.push_back(normal.Z());
        }
      }
      glBindBuffer(GL_ARRAY_BUFFER, vbo_face_normal_buffer);
      glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(GLfloat), &normals[0], GL_STATIC_DRAW);
      glBindBuffer(GL_ARRAY_BUFFER, 0);
    }
  }

  // Return normal buffer identifier
  return vbo_face_normal_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorl %eax, %eax
cmpl $0x0, 0x34(%rdi)
je 0x1757e
movq %rdi, %r14
movl 0x54(%rdi), %eax
testl %eax, %eax
jne 0x1757e
leaq 0x54(%r14), %rbx
movq 0xc2b19(%rip), %rax     # 0xd9f98
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq *(%rax)
cmpl $0x0, (%rbx)
movl $0x0, %eax
je 0x1757e
movq %rbx, 0x10(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
xorl %ecx, %ecx
leaq 0xc(%rsp), %r12
movslq 0x34(%r14), %rax
cmpq %rax, %rcx
jge 0x17532
movq 0x28(%r14), %rax
movq %rcx, 0x18(%rsp)
movq (%rax,%rcx,8), %rbx
pushq $0x1
popq %rbp
cmpq $0x4, %rbp
je 0x17528
movq (%rbx,%rbp,8), %rsi
movq %r14, %rdi
callq 0x21234
movq %rax, %r13
cvtsd2ss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
cvtsd2ss 0x8(%r13), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
cvtsd2ss 0x10(%r13), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
incq %rbp
jmp 0x174cb
movq 0x18(%rsp), %rcx
incq %rcx
jmp 0x174b2
movq 0xc2a77(%rip), %rbx     # 0xd9fb0
movq 0x10(%rsp), %r14
movl (%r14), %esi
movl $0x8892, %edi           # imm = 0x8892
callq *(%rbx)
movq 0xc2a79(%rip), %rax     # 0xd9fc8
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
subq %rdx, %rsi
movl $0x8892, %edi           # imm = 0x8892
movl $0x88e4, %ecx           # imm = 0x88E4
callq *(%rax)
movl $0x8892, %edi           # imm = 0x8892
xorl %esi, %esi
callq *(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x23192
movl (%r14), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17595
jmp 0x17595
jmp 0x17595
jmp 0x17595
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x23192
movq %rbx, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::GLFaceTextureCoordBufferObject() const
unsigned int R3Mesh::
GLFaceTextureCoordBufferObject(void) const
{
  // Check if nothing to be done
  if (NFaces() == 0) return 0;

  // Update texcoord buffer
  if (vbo_face_texcoord_buffer == 0) {
    glGenBuffers(1, (GLuint *) &vbo_face_texcoord_buffer);
    if (vbo_face_texcoord_buffer > 0) {
      std::vector<GLfloat> texcoords;
      for (int i = 0; i < NFaces(); i++) {
        R3MeshFace *face = Face(i);
        for (int j = 0; j < 3; j++){
          R3MeshVertex *vertex = VertexOnFace(face, j);
          const R2Point& texcoord = VertexTextureCoords(vertex);
          texcoords.push_back(texcoord.X());
          texcoords.push_back(texcoord.Y());
        }
      }
      glBindBuffer(GL_ARRAY_BUFFER, vbo_face_texcoord_buffer);
      glBufferData(GL_ARRAY_BUFFER, texcoords.size() * sizeof(GLfloat), &texcoords[0], GL_STATIC_DRAW);
      glBindBuffer(GL_ARRAY_BUFFER, 0);
    }
  }

  // Return texcoord buffer identifier
  return vbo_face_texcoord_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorl %eax, %eax
cmpl $0x0, 0x34(%rdi)
je 0x176bd
movq %rdi, %r14
movl 0x58(%rdi), %eax
testl %eax, %eax
jne 0x176bd
leaq 0x58(%r14), %rbx
movq 0xc29bb(%rip), %rax     # 0xd9f98
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq *(%rax)
cmpl $0x0, (%rbx)
movl $0x0, %eax
je 0x176bd
movq %rbx, 0x10(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movq %r14, 0x18(%rsp)
movslq 0x34(%r14), %rax
cmpq %rax, %r13
jge 0x17671
movq 0x28(%r14), %rax
movq (%rax,%r13,8), %rbx
pushq $0x1
popq %rbp
cmpq $0x4, %rbp
je 0x17667
movq (%rbx,%rbp,8), %r14
cvtsd2ss 0x48(%r14), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
cvtsd2ss 0x50(%r14), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
incq %rbp
jmp 0x1762a
incq %r13
movq 0x18(%rsp), %r14
jmp 0x17616
movq 0xc2938(%rip), %rbx     # 0xd9fb0
movq 0x10(%rsp), %r14
movl (%r14), %esi
movl $0x8892, %edi           # imm = 0x8892
callq *(%rbx)
movq 0xc293a(%rip), %rax     # 0xd9fc8
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
subq %rdx, %rsi
movl $0x8892, %edi           # imm = 0x8892
movl $0x88e4, %ecx           # imm = 0x88E4
callq *(%rax)
movl $0x8892, %edi           # imm = 0x8892
xorl %esi, %esi
callq *(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x23192
movl (%r14), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x176d0
jmp 0x176d0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x23192
movq %rbx, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::GLFacePickColorBufferObject() const
unsigned int R3Mesh::
GLFacePickColorBufferObject(void) const
{
  // Check if nothing to be done
  if (NFaces() == 0) return 0;

  // Update pick color buffer
  if (vbo_face_pick_color_buffer == 0) {
    glGenBuffers(1, (GLuint *) &vbo_face_pick_color_buffer);
    if (vbo_face_pick_color_buffer > 0) {
      std::vector<GLubyte> pick_colors;
      for (int i = 0; i < NFaces(); i++) {
        for (int j = 0; j < 3; j++){
          unsigned char pick_color[4];
          EncodePickColor(i, 255, pick_color);
          pick_colors.push_back(pick_color[0]);
          pick_colors.push_back(pick_color[1]);
          pick_colors.push_back(pick_color[2]);
          pick_colors.push_back(pick_color[3]);
        }
      }
      glBindBuffer(GL_ARRAY_BUFFER, vbo_face_pick_color_buffer);
      glBufferData(GL_ARRAY_BUFFER, pick_colors.size() * sizeof(GLubyte), &pick_colors[0], GL_STATIC_DRAW);
      glBindBuffer(GL_ARRAY_BUFFER, 0);
    }
  }

  // Return pick color buffer identifier
  return vbo_face_pick_color_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorl %eax, %eax
cmpl $0x0, 0x34(%rdi)
je 0x1799e
movq %rdi, %r14
movl 0x60(%rdi), %eax
testl %eax, %eax
jne 0x1799e
leaq 0x60(%r14), %rbx
movq 0xc26df(%rip), %rax     # 0xd9f98
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq *(%rax)
cmpl $0x0, (%rbx)
movl $0x0, %eax
je 0x1799e
movq %r14, 0x18(%rsp)
movq %rbx, 0x10(%rsp)
leaq 0x20(%rsp), %r15
andq $0x0, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
leaq 0xe(%rsp), %r13
xorl %ebp, %ebp
leaq 0xf(%rsp), %rbx
leaq 0xc(%rsp), %r14
movq 0x18(%rsp), %rax
cmpl 0x34(%rax), %ebp
jge 0x17952
pushq $0x3
popq %r12
subl $0x1, %r12d
jb 0x1794e
movl %ebp, %edi
movl $0xff, %esi
movq %r14, %rdx
callq 0x65eb6
movq %r15, %rdi
movq %r14, %rsi
callq 0x21c1e
movq %r15, %rdi
leaq 0xd(%rsp), %rsi
callq 0x21c1e
movq %r15, %rdi
movq %r13, %rsi
callq 0x21c1e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x21c1e
jmp 0x17909
incl %ebp
jmp 0x178fb
movq 0xc2657(%rip), %rbx     # 0xd9fb0
movq 0x10(%rsp), %r14
movl (%r14), %esi
movl $0x8892, %edi           # imm = 0x8892
callq *(%rbx)
movq 0xc2659(%rip), %rax     # 0xd9fc8
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
subq %rdx, %rsi
movl $0x8892, %edi           # imm = 0x8892
movl $0x88e4, %ecx           # imm = 0x88E4
callq *(%rax)
movl $0x8892, %edi           # imm = 0x8892
xorl %esi, %esi
callq *(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x23344
movl (%r14), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x179af
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x23344
movq %rbx, %rdi
callq 0xe810
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::GLVertexPositionBufferObject() const
unsigned int R3Mesh::
GLVertexPositionBufferObject(void) const
{
  // Check if nothing to be done
  if (NVertices() == 0) return 0;
  
  // Update position buffer
  if (vbo_vertex_position_buffer == 0) {
    glGenBuffers(1, (GLuint *) &vbo_vertex_position_buffer);
    if (vbo_vertex_position_buffer > 0) {
      std::vector<GLfloat> positions;
      for (int i = 0; i < NVertices(); i++) {
        R3MeshVertex *vertex = Vertex(i);
        const R3Point& position = VertexPosition(vertex);
        positions.push_back(position.X());
        positions.push_back(position.Y());
        positions.push_back(position.Z());
      }
      glBindBuffer(GL_ARRAY_BUFFER, vbo_vertex_position_buffer);
      glBufferData(GL_ARRAY_BUFFER, positions.size() * sizeof(GLfloat), &positions[0], GL_STATIC_DRAW);
      glBindBuffer(GL_ARRAY_BUFFER, 0);
    }
  }

  // Return position buffer identifier
  return vbo_vertex_position_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
cmpl $0x0, 0x14(%rdi)
je 0x17ac5
movq %rdi, %r14
movl 0x64(%rdi), %eax
testl %eax, %eax
jne 0x17ac5
leaq 0x64(%r14), %rbx
movq 0xc25a1(%rip), %rax     # 0xd9f98
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq *(%rax)
cmpl $0x0, (%rbx)
movl $0x0, %eax
je 0x17ac5
leaq 0x10(%rsp), %r15
andq $0x0, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movslq 0x14(%r14), %rax
cmpq %rax, %r13
jge 0x17a7e
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rbp
cvtsd2ss 0x18(%rbp), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
cvtsd2ss 0x20(%rbp), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
cvtsd2ss 0x28(%rbp), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
incq %r13
jmp 0x17a26
movq 0xc252b(%rip), %r14     # 0xd9fb0
movl (%rbx), %esi
movl $0x8892, %edi           # imm = 0x8892
callq *(%r14)
movq 0xc2532(%rip), %rax     # 0xd9fc8
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
subq %rdx, %rsi
movl $0x8892, %edi           # imm = 0x8892
movl $0x88e4, %ecx           # imm = 0x88E4
callq *(%rax)
movl $0x8892, %edi           # imm = 0x8892
xorl %esi, %esi
callq *(%r14)
leaq 0x10(%rsp), %rdi
callq 0x23192
movl (%rbx), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17ada
jmp 0x17ada
jmp 0x17ada
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x23192
movq %rbx, %rdi
callq 0xe810
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Mesh.cpp
// Function: gaps::R3Mesh::GLVertexNormalBufferObject() const
unsigned int R3Mesh::
GLVertexNormalBufferObject(void) const
{
  // Check if nothing to be done
  if (NVertices() == 0) return 0;
  
  // Update normal buffer
  if (vbo_vertex_normal_buffer == 0) {
    glGenBuffers(1, (GLuint *) &vbo_vertex_normal_buffer);
    if (vbo_vertex_normal_buffer > 0) {
      std::vector<GLfloat> normals;
      for (int i = 0; i < NVertices(); i++) {
        R3MeshVertex *vertex = Vertex(i);
        const R3Vector& normal = VertexNormal(vertex);
        normals.push_back(normal.X());
        normals.push_back(normal.Y());
        normals.push_back(normal.Z());
      }
      glBindBuffer(GL_ARRAY_BUFFER, vbo_vertex_normal_buffer);
      glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(GLfloat), &normals[0], GL_STATIC_DRAW);
      glBindBuffer(GL_ARRAY_BUFFER, 0);
    }
  }

  // Return normal buffer identifier
  return vbo_vertex_normal_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
cmpl $0x0, 0x14(%rdi)
je 0x17bfc
movq %rdi, %r14
movl 0x68(%rdi), %eax
testl %eax, %eax
jne 0x17bfc
leaq 0x68(%r14), %rbx
movq 0xc2475(%rip), %rax     # 0xd9f98
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq *(%rax)
cmpl $0x0, (%rbx)
movl $0x0, %eax
je 0x17bfc
leaq 0x10(%rsp), %r15
andq $0x0, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
xorl %ebp, %ebp
leaq 0xc(%rsp), %r12
movslq 0x14(%r14), %rax
cmpq %rax, %rbp
jge 0x17bb5
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %rsi
movq %r14, %rdi
callq 0x21234
movq %rax, %r13
cvtsd2ss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
cvtsd2ss 0x8(%r13), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
cvtsd2ss 0x10(%r13), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x231c6
incq %rbp
jmp 0x17b51
movq 0xc23f4(%rip), %r14     # 0xd9fb0
movl (%rbx), %esi
movl $0x8892, %edi           # imm = 0x8892
callq *(%r14)
movq 0xc23fb(%rip), %rax     # 0xd9fc8
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
subq %rdx, %rsi
movl $0x8892, %edi           # imm = 0x8892
movl $0x88e4, %ecx           # imm = 0x88E4
callq *(%rax)
movl $0x8892, %edi           # imm = 0x8892
xorl %esi, %esi
callq *(%r14)
leaq 0x10(%rsp), %rdi
callq 0x23192
movl (%rbx), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17c13
jmp 0x17c13
jmp 0x17c13
jmp 0x17c13
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x23192
movq %rbx, %rdi
callq 0xe810