LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/scn2cam/scn2cam.cpp
// Function: IsDifferentCameraOrientation(Camera*, Camera*, void*)
static int
IsDifferentCameraOrientation(Camera *camera1, Camera *camera2, void *data)
{
  // Check towards angle
  R3Vector towards1 = camera1->Towards();  
  R3Vector towards2 = camera2->Towards();
  if (R3InteriorAngle(towards1, towards2) > angle_sampling) return 1;

  // Check up angle
  R3Vector up1 = camera1->Up();  
  R3Vector up2 = camera2->Up();
  if (R3InteriorAngle(up1, up2) > angle_sampling) return 1;

  // Cameras overlap
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x48(%rdi), %rsi
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x7e6c4
leaq 0x48(%rbx), %rsi
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x7e6c4
movq %r15, %rdi
movq %r12, %rsi
callq 0x561ab
movl $0x1, %eax
ucomisd 0x135c8e(%rip), %xmm0   # 0x1618b8
ja 0x2bc6c
addq $0x30, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7da9a
addq $0x30, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7da9a
movq %r15, %rdi
movq %r14, %rsi
callq 0x561ab
xorl %eax, %eax
ucomisd 0x135c4f(%rip), %xmm0   # 0x1618b8
seta %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/scn2cam/scn2cam.cpp
// Function: IsRoom(gaps::R3SceneNode*)
static RNBoolean
IsRoom(R3SceneNode *node)
{
  // Check if labeled
  if (input_categories_filename) {
    // Check if node is labeled as a room
    if (!node->Name()) return 0;
    if (strncmp(node->Name(), "Room#", 5)) return 0;
  }
  else {
    // If no "rooms", then include only root node
    if (node->Parent()) return 0;
  }

  // Passed all tests
  return 1;
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x135bdf(%rip)    # 0x161860
je 0x2bcaf
movq 0x1a0(%rdi), %rdi
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x2bcab
leaq 0xc6a54(%rip), %rsi     # 0xf26ec
movl $0x5, %edx
callq 0x223b0
testl %eax, %eax
jne 0x2bcab
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
xorl %ebx, %ebx
cmpq $0x0, 0x10(%rdi)
jne 0x2bcab
jmp 0x2bca6
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/scn2cam/../../pkgs/R3Shapes/R3Kdtree.cpp
// Function: gaps::R3Kdtree<Camera*>::FindAny(Camera*, double, double, int (*)(Camera*, Camera*, void*), void*) const
PtrType R3Kdtree<PtrType>::
FindAny(PtrType query_point, 
  RNScalar min_distance, RNScalar max_distance, 
  int (*IsCompatible)(PtrType, PtrType, void *), void *compatible_data) const
{
  // Check root
  if (!root) return NULL;

  // Use squared distances for efficiency
  if (max_distance < 0) return NULL;
  if (min_distance < 0) min_distance = 0;
  RNLength min_distance_squared = min_distance * min_distance;
  RNLength max_distance_squared = max_distance * max_distance;

  // Search nodes recursively
  return FindAny(root, bbox, 
    query_point, Position(query_point),
    min_distance_squared, max_distance_squared, 
    IsCompatible, compatible_data);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq 0x50(%rdi), %r12
testq %r12, %r12
sete %al
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
seta %cl
orb %al, %cl
je 0x2ce9a
xorl %eax, %eax
jmp 0x2cef5
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, %r13
maxsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
movsd %xmm2, 0x10(%rsp)
mulsd %xmm1, %xmm1
movsd %xmm1, 0x18(%rsp)
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2d420
movq %r14, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %rbp, %r8
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %rbx, %r9
callq 0x2cfb2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::~R3PointSet()
R3PointSet::
~R3PointSet(void)
{
  // Delete OpenGL buffers
  if (vbo_position_buffer > 0) glDeleteBuffers(1, &vbo_position_buffer);
  if (vbo_normal_buffer > 0) glDeleteBuffers(1, &vbo_normal_buffer);
  if (vbo_rgb_color_buffer > 0) glDeleteBuffers(1, &vbo_rgb_color_buffer);
  if (vbo_pick_color_buffer > 0) glDeleteBuffers(1, &vbo_pick_color_buffer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x108(%rdi)
je 0x7e9d5
leaq 0x108(%rbx), %rsi
movq 0xdd5fa(%rip), %rax     # 0x15bfc8
movl $0x1, %edi
callq *(%rax)
cmpl $0x0, 0x10c(%rbx)
je 0x7e9f3
leaq 0x10c(%rbx), %rsi
movq 0xdd5dc(%rip), %rax     # 0x15bfc8
movl $0x1, %edi
callq *(%rax)
cmpl $0x0, 0x110(%rbx)
je 0x7ea11
leaq 0x110(%rbx), %rsi
movq 0xdd5be(%rip), %rax     # 0x15bfc8
movl $0x1, %edi
callq *(%rax)
cmpl $0x0, 0x114(%rbx)
je 0x7ea2f
leaq 0x114(%rbx), %rsi
movq 0xdd5a0(%rip), %rax     # 0x15bfc8
movl $0x1, %edi
callq *(%rax)
leaq 0x118(%rbx), %rdi
callq 0x75728
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x7ea56
movq 0x100(%rbx), %rsi
subq %rdi, %rsi
callq 0x228b0
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x7ea71
movq 0xe8(%rbx), %rsi
subq %rdi, %rsi
callq 0x228b0
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x7ea8c
movq 0xd0(%rbx), %rsi
subq %rdi, %rsi
callq 0x228b0
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x7eaa7
movq 0xb8(%rbx), %rsi
subq %rdi, %rsi
callq 0x228b0
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x7eac2
movq 0xa0(%rbx), %rsi
subq %rdi, %rsi
callq 0x228b0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x7eada
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x228b0
movl $0x70, %r14d
movq -0x10(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x7eaf6
movq (%rbx,%r14), %rsi
subq %rdi, %rsi
callq 0x228b0
addq $-0x18, %r14
cmpq $0x40, %r14
jne 0x7eae0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x7eb15
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x228b0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x7eb2a
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x228b0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7eb45
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x228b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x2ccc9
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::Centroid() const
R3Point R3PointSet::
Centroid(void) const
{
  // Check if no points
  if (positions.size() == 0) return R3zero_point;

  // Return centroid of point set
  R3Point centroid = R3zero_point;
  for (unsigned int i = 0; i < positions.size(); i++) 
    centroid += positions[i];
  centroid /= positions.size();
  return centroid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq (%rsi), %r12
leaq 0xec11e(%rip), %rsi     # 0x16ac90
callq 0x7d006
cmpq %r12, %r15
je 0x7ebdb
movq (%r14), %rax
movq 0x8(%r14), %rcx
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
subq %rax, %rcx
je 0x7ebc6
movl $0x1, %ebp
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rcx
leaq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x7d930
movl %ebp, %edx
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %r15, %rcx
incl %ebp
cmpq %rdx, %rcx
ja 0x7eb99
jmp 0x7ebce
sarq $0x3, %rcx
imulq %r15, %rcx
cvtsi2sd %rcx, %xmm0
movq %rbx, %rdi
callq 0x7d9ae
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::SetPointPosition(int, gaps::R3Point const&)
void R3PointSet::
SetPointPosition(int index, const R3Point& position)
{
  // Set position for point with given index
  while (index >= (int) positions.size())
    positions.push_back(R3zero_point);
  positions[index] = position;
  bbox.Union(position);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
cmpl %esi, %ecx
jg 0x7eed7
leaq 0xebddc(%rip), %r15     # 0x16ac90
movq %r14, %rdi
movq %r15, %rsi
callq 0x6bbd2
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
cmpl %ebp, %ecx
jle 0x7eeb4
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq %rbx, %rsi
callq 0x7d35e
addq $0x118, %r14            # imm = 0x118
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x752fa
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::SetPointNormal(int, gaps::R3Vector const&)
void R3PointSet::
SetPointNormal(int index, const R3Vector& normal)
{
  // Set normal for point with given index
  while (index >= (int) normals.size())
    normals.push_back(R3zero_vector);
  normals[index] = normal;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
cmpl %esi, %ecx
jg 0x7ef5e
movq %rdi, %r14
leaq 0x18(%rdi), %r15
leaq 0x76376(%rip), %r12     # 0xf52b0
movq %r15, %rdi
movq %r12, %rsi
callq 0x80f86
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
cmpl %ebp, %ecx
jle 0x7ef3a
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7e216
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::SetPointTangent(int, gaps::R3Vector const&)
void R3PointSet::
SetPointTangent(int index, const R3Vector& tangent)
{
  // Set tangent for point with given index
  while (index >= (int) tangents.size())
    tangents.push_back(R3zero_vector);
  tangents[index] = tangent;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
cmpl %esi, %ecx
jg 0x7efd2
movq %rdi, %r14
leaq 0x30(%rdi), %r15
leaq 0x76302(%rip), %r12     # 0xf52b0
movq %r15, %rdi
movq %r12, %rsi
callq 0x80f86
movq 0x30(%r14), %rax
movq 0x38(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
cmpl %ebp, %ecx
jle 0x7efae
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7e216
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::SetPointRadius(int, int, double)
void R3PointSet::
SetPointRadius(int index, int axis, RNLength radius)
{
  // Set radius for point with given index
  while (index >= (int) radii[axis].size())
    radii[axis].push_back(0);
  radii[axis][index] = radius;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movl %esi, %ebx
movslq %edx, %rax
leaq (%rax,%rax,2), %rcx
movq 0x48(%rdi,%rcx,8), %rax
movq 0x50(%rdi,%rcx,8), %rsi
movq %rsi, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
cmpl %ebx, %edx
jg 0x7f06a
leaq (%rdi,%rcx,8), %r14
addq $0x48, %r14
leaq 0x8(%rsp), %r15
movq $0x0, 0x8(%rsp)
cmpq 0x10(%r14), %rsi
je 0x7f04a
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r14)
jmp 0x7f05c
movq %r14, %rdi
movq %r15, %rdx
callq 0x8132a
movq (%r14), %rax
movq 0x8(%r14), %rsi
movq %rsi, %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ebx, %ecx
jle 0x7f02a
movslq %ebx, %rcx
movsd (%rsp), %xmm0
movsd %xmm0, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::SetPointColor(int, gaps::RNRgb const&)
void R3PointSet::
SetPointColor(int index, const RNRgb& color)
{
  // Set color for point with given index
  while (index >= (int) colors.size())
    colors.push_back(RNblack_rgb);
  colors[index] = color;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq 0x78(%rdi), %rax
movq 0x80(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
cmpl %esi, %ecx
jg 0x7f0e0
movq %rdi, %r14
leaq 0x78(%rdi), %r15
leaq 0xec5b7(%rip), %r12     # 0x16b670
movq %r15, %rdi
movq %r12, %rsi
callq 0x80fb2
movq 0x78(%r14), %rax
movq 0x80(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
cmpl %ebp, %ecx
jle 0x7f0b9
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9eabe
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::SetPointTimestamp(int, double)
void R3PointSet::
SetPointTimestamp(int index, RNScalar timestamp)
{
  // Set timestamp for point with given index
  while (index >= (int) timestamps.size())
    timestamps.push_back(-1);
  timestamps[index] = timestamp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movl %esi, %ebx
movq 0x90(%rdi), %rax
movq 0x98(%rdi), %rsi
movq %rsi, %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ebx, %ecx
jg 0x7f18a
movq %rdi, %r14
leaq 0x90(%rdi), %r15
movabsq $-0x4010000000000000, %r13 # imm = 0xBFF0000000000000
leaq 0x8(%rsp), %r12
movq %r13, 0x8(%rsp)
cmpq 0xa0(%r14), %rsi
je 0x7f163
movq %r13, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x98(%r14)
jmp 0x7f17c
movq %r15, %rdi
movq %r12, %rdx
callq 0x8132a
movq 0x90(%r14), %rax
movq 0x98(%r14), %rsi
movq %rsi, %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ebx, %ecx
jle 0x7f145
movslq %ebx, %rcx
movsd (%rsp), %xmm0
movsd %xmm0, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::SetPointCategoryIdentifier(int, int)
void R3PointSet::
SetPointCategoryIdentifier(int index, int identifier)
{
  // Set category identifier for point with given index
  while (index >= (int) category_identifiers.size())
    category_identifiers.push_back(-1);
  category_identifiers[index] = identifier;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq 0xa8(%rdi), %rax
movq 0xb0(%rdi), %rsi
movq %rsi, %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %ebp, %ecx
jg 0x7f22c
movq %rdi, %r14
leaq 0xa8(%rdi), %r15
leaq 0xc(%rsp), %r12
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
cmpq 0xb8(%r14), %rsi
je 0x7f205
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
addq $0x4, %rsi
movq %rsi, 0xb0(%r14)
jmp 0x7f21e
movq %r15, %rdi
movq %r12, %rdx
callq 0x8165a
movq 0xa8(%r14), %rax
movq 0xb0(%r14), %rsi
movq %rsi, %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %ebp, %ecx
jle 0x7f1e1
movslq %ebp, %rcx
movl %ebx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::SetPointInstanceIdentifier(int, int)
void R3PointSet::
SetPointInstanceIdentifier(int index, int identifier)
{
  // Set instance identifier for point with given index
  while (index >= (int) instance_identifiers.size())
    instance_identifiers.push_back(-1);
  instance_identifiers[index] = identifier;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq 0xc0(%rdi), %rax
movq 0xc8(%rdi), %rsi
movq %rsi, %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %ebp, %ecx
jg 0x7f2c6
movq %rdi, %r14
leaq 0xc0(%rdi), %r15
leaq 0xc(%rsp), %r12
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
cmpq 0xd0(%r14), %rsi
je 0x7f29f
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
addq $0x4, %rsi
movq %rsi, 0xc8(%r14)
jmp 0x7f2b8
movq %r15, %rdi
movq %r12, %rdx
callq 0x8165a
movq 0xc0(%r14), %rax
movq 0xc8(%r14), %rsi
movq %rsi, %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %ebp, %ecx
jle 0x7f27b
movslq %ebp, %rcx
movl %ebx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::SetPointWeight(int, double)
void R3PointSet::
SetPointWeight(int index, RNScalar weight)
{
  // Set weight for point with given index
  while (index >= (int) weights.size())
    weights.push_back(0);
  weights[index] = weight;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movq 0xd8(%rdi), %rax
movq 0xe0(%rdi), %rsi
movq %rsi, %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ebx, %ecx
jg 0x7f365
movq %rdi, %r14
leaq 0xd8(%rdi), %r15
leaq 0x10(%rsp), %r12
movq $0x0, 0x10(%rsp)
cmpq 0xe8(%r14), %rsi
je 0x7f33e
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0xe0(%r14)
jmp 0x7f357
movq %r15, %rdi
movq %r12, %rdx
callq 0x8132a
movq 0xd8(%r14), %rax
movq 0xe0(%r14), %rsi
movq %rsi, %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ebx, %ecx
jle 0x7f318
movslq %ebx, %rcx
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax,%rcx,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::SetPointValue(int, double)
void R3PointSet::
SetPointValue(int index, RNScalar value)
{
  // Set value for point with given index
  while (index >= (int) values.size())
    values.push_back(-1);
  values[index] = value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movl %esi, %ebx
movq 0xf0(%rdi), %rax
movq 0xf8(%rdi), %rsi
movq %rsi, %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ebx, %ecx
jg 0x7f40e
movq %rdi, %r14
leaq 0xf0(%rdi), %r15
movabsq $-0x4010000000000000, %r13 # imm = 0xBFF0000000000000
leaq 0x8(%rsp), %r12
movq %r13, 0x8(%rsp)
cmpq 0x100(%r14), %rsi
je 0x7f3e7
movq %r13, (%rsi)
addq $0x8, %rsi
movq %rsi, 0xf8(%r14)
jmp 0x7f400
movq %r15, %rdi
movq %r12, %rdx
callq 0x8132a
movq 0xf0(%r14), %rax
movq 0xf8(%r14), %rsi
movq %rsi, %rcx
subq %rax, %rcx
shrq $0x3, %rcx
cmpl %ebx, %ecx
jle 0x7f3c9
movslq %ebx, %rcx
movsd (%rsp), %xmm0
movsd %xmm0, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::ReadFile(char const*)
int R3PointSet::
ReadFile(const char *filename)
{
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .mm)\n", filename);
    return 0;
  }

  // Read file of appropriate type
  if (!strcmp(extension, ".xyz")) return ReadXYZFile(filename);
  else if (!strcmp(extension, ".xyzn")) return ReadXYZNFile(filename);
  else if (!strcmp(extension, ".pset")) return ReadBinaryFile(filename);
  else if (!strcmp(extension, ".pts")) return ReadPTSFile(filename);
  else if (!strcmp(extension, ".sdf")) return ReadSDFFile(filename);
  else if (!strcmp(extension, ".vts")) return ReadVTSFile(filename);
  else return ReadMeshFile(filename);

  // Should not get here
  RNFail("Unrecognized file extension in %s\n", filename);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x2e, %esi
callq 0x22980
testq %rax, %rax
je 0x7fe3c
movq %rax, %r15
leaq 0x755fd(%rip), %rsi     # 0xf53b2
movq %rax, %rdi
callq 0x22cd0
testl %eax, %eax
je 0x7fe55
leaq 0x755eb(%rip), %rsi     # 0xf53b7
movq %r15, %rdi
callq 0x22cd0
testl %eax, %eax
je 0x7fe65
leaq 0x755da(%rip), %rsi     # 0xf53bd
movq %r15, %rdi
callq 0x22cd0
testl %eax, %eax
je 0x7fe75
leaq 0x755c9(%rip), %rsi     # 0xf53c3
movq %r15, %rdi
callq 0x22cd0
testl %eax, %eax
je 0x7fe85
leaq 0x755bb(%rip), %rsi     # 0xf53c8
movq %r15, %rdi
callq 0x22cd0
testl %eax, %eax
je 0x7fe95
leaq 0x755ad(%rip), %rsi     # 0xf53cd
movq %r15, %rdi
callq 0x22cd0
movq %r14, %rdi
movq %rbx, %rsi
testl %eax, %eax
je 0x7fea5
popq %rbx
popq %r14
popq %r15
jmp 0x805ee
leaq 0x75545(%rip), %rdi     # 0xf5388
movq %rbx, %rsi
xorl %eax, %eax
callq 0x22080
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7feb0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7ffa0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x800e6
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x802de
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x80404
popq %rbx
popq %r14
popq %r15
jmp 0x804f4
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::ReadXYZFile(char const*)
int R3PointSet::
ReadXYZFile(const char *filename)
{
  // Open file
  FILE *fp = fopen(filename, "r");
  if (!fp) {
    RNFail("Unable to open %s\n", filename);
    return 0;
  }

  // Read points
  double px, py, pz;
  while (fscanf(fp, "%lf%lf%lf", &px, &py, &pz) == (unsigned int) 3) {
    R3Point position(px,py,pz);
    InsertPoint(position);
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x79c18(%rip), %rsi     # 0xf9ae3
movq %r15, %rdi
callq 0x22a70
testq %rax, %rax
je 0x7ff7c
movq %rax, %r14
leaq 0x74a1c(%rip), %rsi     # 0xf4902
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rax, %rdi
xorl %eax, %eax
callq 0x23150
cmpl $0x3, %eax
jne 0x7ff6d
leaq 0x20(%rsp), %r15
leaq 0x18(%rsp), %r13
leaq 0x10(%rsp), %rbp
leaq 0x8(%rsp), %r12
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movq %r15, %rdi
callq 0x7cff6
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %esi # imm = 0xAAAAAAAB
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7ee86
movq %r14, %rdi
leaq 0x749aa(%rip), %rsi     # 0xf4902
movq %r13, %rdx
movq %rbp, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x23150
cmpl $0x3, %eax
je 0x7ff18
movq %r14, %rdi
callq 0x22880
movl $0x1, %ebx
jmp 0x7ff8f
leaq 0x7544f(%rip), %rdi     # 0xf53d2
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0xa172a
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::ReadXYZNFile(char const*)
int R3PointSet::
ReadXYZNFile(const char *filename)
{
  // Open file
  FILE *fp = fopen(filename, "r");
  if (!fp) {
    RNFail("Unable to open %s\n", filename);
    return 0;
  }

  // Read points
  double px, py, pz, nx, ny, nz;
  while (fscanf(fp, "%lf%lf%lf%lf%lf%lf", &px, &py, &pz, &nx, &ny, &nz) == (unsigned int) 6) {
    R3Point position(px,py,pz);
    R3Vector normal(nx,ny,nz);
    normal.Normalize();
    int index = InsertPoint(position);
    SetPointNormal(index, normal);
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x79b28(%rip), %rsi     # 0xf9ae3
movq %r15, %rdi
callq 0x22a70
testq %rax, %rax
je 0x800c2
movq %rax, %r14
leaq 0x28(%rsp), %rbp
leaq 0x30(%rsp), %r13
leaq 0x72dda(%rip), %rsi     # 0xf2dba
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %rax, %rdi
xorl %eax, %eax
pushq %rbp
pushq %r13
callq 0x23150
addq $0x10, %rsp
cmpl $0x6, %eax
jne 0x800b3
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
leaq 0x38(%rsp), %rdi
callq 0x7cff6
movsd 0x8(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x7da8a
movq %r12, %rdi
callq 0x7dda0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
movq %r14, %r15
movq %r13, %r14
movq %rbp, %r13
imull $0xaaaaaaab, %eax, %ebp # imm = 0xAAAAAAAB
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x38(%rsp), %rdx
callq 0x7ee86
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rbp
movq %r14, %r13
movq %r15, %r14
movq %r12, %rdx
callq 0x7ef06
movq %r15, %rdi
leaq 0x72d20(%rip), %rsi     # 0xf2dba
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x8(%rsp), %r9
jmp 0x7fff7
movq %r14, %rdi
callq 0x22880
movl $0x1, %ebx
jmp 0x800d5
leaq 0x75309(%rip), %rdi     # 0xf53d2
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0xa172a
movl %ebx, %eax
addq $0x68, %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/R3PointSet.cpp
// Function: gaps::R3PointSet::ReadPTSFile(char const*)
int R3PointSet::
ReadPTSFile(const char *filename)
{
  // Open file
  FILE *fp = fopen(filename, "rb");
  if (!fp) {
    RNFail("Unable to open %s\n", filename);
    return 0;
  }

  // Read points
  float buf[6];
  while (fread(buf, sizeof(float), 6, fp) == (unsigned int) 6) {
    R3Point position(buf[0], buf[1], buf[2]);
    R3Vector normal(buf[3], buf[4], buf[5]);
    normal.Normalize();
    int index = InsertPoint(position);
    SetPointNormal(index, normal);
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x73361(%rip), %rsi     # 0xf365a
movq %r15, %rdi
callq 0x22a70
testq %rax, %rax
je 0x803df
movq %rax, %r14
movq %rsp, %rdi
movl $0x4, %esi
movl $0x6, %edx
movq %rax, %rcx
callq 0x22e10
cmpq $0x6, %rax
jne 0x803d0
leaq 0x30(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %rsp, %r13
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rsp), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rsp), %xmm2
movq %r15, %rdi
callq 0x7cff6
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x10(%rsp), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x14(%rsp), %xmm2
movq %r12, %rdi
callq 0x7da8a
movq %r12, %rdi
callq 0x7dda0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %ebp # imm = 0xAAAAAAAB
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x7ee86
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x7ef06
movl $0x4, %esi
movl $0x6, %edx
movq %r13, %rdi
movq %r14, %rcx
callq 0x22e10
cmpq $0x6, %rax
je 0x80339
movq %r14, %rdi
callq 0x22880
movl $0x1, %ebx
jmp 0x803f2
leaq 0x74fec(%rip), %rdi     # 0xf53d2
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0xa172a
movl %ebx, %eax
addq $0x48, %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/R3PointSet.cpp
// Function: gaps::R3PointSet::ReadSDFFile(char const*)
int R3PointSet::
ReadSDFFile(const char *filename)
{
  // Open file
  FILE *fp = fopen(filename, "rb");
  if (!fp) {
    RNFail("Unable to open %s\n", filename);
    return 0;
  }

  // Read points
  float buf[4];
  while (fread(buf, sizeof(float), 4, fp) == (unsigned int) 4) {
    R3Point position(buf[0], buf[1], buf[2]);
    int index = InsertPoint(position);
    SetPointValue(index, buf[3]);
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7323d(%rip), %rsi     # 0xf365a
movq %r15, %rdi
callq 0x22a70
testq %rax, %rax
je 0x804d1
movq %rax, %r14
movq %rsp, %rdi
movl $0x4, %esi
movl $0x4, %edx
movq %rax, %rcx
callq 0x22e10
cmpq $0x4, %rax
jne 0x804c2
leaq 0x18(%rsp), %r15
movq %rsp, %r12
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rsp), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rsp), %xmm2
movq %r15, %rdi
callq 0x7cff6
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %ebp # imm = 0xAAAAAAAB
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x7ee86
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rsp), %xmm0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7f380
movl $0x4, %esi
movl $0x4, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x22e10
cmpq $0x4, %rax
je 0x80454
movq %r14, %rdi
callq 0x22880
movl $0x1, %ebx
jmp 0x804e4
leaq 0x74efa(%rip), %rdi     # 0xf53d2
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0xa172a
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::ReadVTSFile(char const*)
int R3PointSet::
ReadVTSFile(const char *filename)
{
  // Open file
  FILE *fp = fopen(filename, "r");
  if (!fp) {
    RNFail("Unable to open %s\n", filename);
    return 0;
  }

  // Read points
  int vertex_index;
  double px, py, pz;
  while (fscanf(fp, "%d%lf%lf%lf", &vertex_index, &px, &py, &pz) == (unsigned int) 4) {
    R3Point position(px,py,pz);
    InsertPoint(position);
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x795d4(%rip), %rsi     # 0xf9ae3
movq %r15, %rdi
callq 0x22a70
testq %rax, %rax
je 0x805ca
movq %rax, %r14
leaq 0x743d6(%rip), %rsi     # 0xf4900
leaq 0x4(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %rax, %rdi
xorl %eax, %eax
callq 0x23150
cmpl $0x4, %eax
jne 0x805bb
leaq 0x20(%rsp), %r15
leaq 0x18(%rsp), %rbp
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movq %r15, %rdi
callq 0x7cff6
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %esi # imm = 0xAAAAAAAB
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7ee86
movq %r14, %rdi
leaq 0x7435f(%rip), %rsi     # 0xf4900
leaq 0x4(%rsp), %rdx
movq %rbp, %rcx
movq %r12, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0x23150
cmpl $0x4, %eax
je 0x80561
movq %r14, %rdi
callq 0x22880
movl $0x1, %ebx
jmp 0x805dd
leaq 0x74e01(%rip), %rdi     # 0xf53d2
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0xa172a
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::ReadMeshFile(char const*)
int R3PointSet::
ReadMeshFile(const char *filename)
{
  // Read mesh file
  R3Mesh mesh;
  if (!mesh.ReadFile(filename)) {
    RNFail("Unable to read %s\n", filename);
    return 0;
  }

  // Create point for each vertex
  for (int i = 0; i < mesh.NVertices(); i++) {
    R3MeshVertex *vertex = mesh.Vertex(i);
    int index = InsertPoint(mesh.VertexPosition(vertex));
    SetPointNormal(index, mesh.VertexNormal(vertex));
    SetPointColor(index, mesh.VertexColor(vertex));
  }

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x58a90
movq %rbx, %rdi
movq %r15, %rsi
callq 0x65a84
testl %eax, %eax
je 0x806a9
movl $0x1, %ebx
cmpl $0x0, 0x14(%rsp)
jle 0x806bc
xorl %r13d, %r13d
movq %rsp, %r15
movq 0x8(%rsp), %rax
movq (%rax,%r13,8), %r12
leaq 0x18(%r12), %rdx
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %ebp # imm = 0xAAAAAAAB
movq %r14, %rdi
movl %ebp, %esi
callq 0x7ee86
testb $0x2, 0x78(%r12)
jne 0x8067a
movq (%rsp), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x2b0(%rax)
leaq 0x30(%r12), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x7ef06
addq $0x58, %r12
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x7f082
incq %r13
movslq 0x14(%rsp), %rax
cmpq %rax, %r13
jl 0x80639
jmp 0x806bc
xorl %ebx, %ebx
leaq 0x72fc9(%rip), %rdi     # 0xf367b
movq %r15, %rsi
xorl %eax, %eax
callq 0xa172a
movq %rsp, %rdi
callq 0x58fce
movl %ebx, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x806da
movq %rax, %rbx
movq %rsp, %rdi
callq 0x58fce
movq %rbx, %rdi
callq 0x23090
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::WriteFile(char const*) const
int R3PointSet::
WriteFile(const char *filename) const
{
  // Parse input filename extension
  const char *extension;
  if (!(extension = strrchr(filename, '.'))) {
    printf("Filename %s has no extension (e.g., .mm)\n", filename);
    return 0;
  }

  // Write file of appropriate type
  if (!strcmp(extension, ".xyz")) return WriteXYZFile(filename);
  else if (!strcmp(extension, ".xyzn")) return WriteXYZNFile(filename);
  else if (!strcmp(extension, ".pset")) return WriteBinaryFile(filename);
  else if (!strcmp(extension, ".pts")) return WritePTSFile(filename);
  else if (!strcmp(extension, ".sdf")) return WriteSDFFile(filename);
  else return WriteMeshFile(filename);

  // Should not get here
  RNFail("Unrecognized file extension in %s\n", filename);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x2e, %esi
callq 0x22980
testq %rax, %rax
je 0x8077d
movq %rax, %r15
leaq 0x74c9d(%rip), %rsi     # 0xf53b2
movq %rax, %rdi
callq 0x22cd0
testl %eax, %eax
je 0x80796
leaq 0x74c8f(%rip), %rsi     # 0xf53b7
movq %r15, %rdi
callq 0x22cd0
testl %eax, %eax
je 0x807a6
leaq 0x74c82(%rip), %rsi     # 0xf53bd
movq %r15, %rdi
callq 0x22cd0
testl %eax, %eax
je 0x807b6
leaq 0x74c75(%rip), %rsi     # 0xf53c3
movq %r15, %rdi
callq 0x22cd0
testl %eax, %eax
je 0x807c6
leaq 0x74c67(%rip), %rsi     # 0xf53c8
movq %r15, %rdi
callq 0x22cd0
movq %r14, %rdi
movq %rbx, %rsi
testl %eax, %eax
je 0x807d6
popq %rbx
popq %r14
popq %r15
jmp 0x80e6e
leaq 0x74c04(%rip), %rdi     # 0xf5388
movq %rbx, %rsi
xorl %eax, %eax
callq 0x22080
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x807e0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x808a0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x809a6
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x80c02
popq %rbx
popq %r14
popq %r15
jmp 0x80d3a
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::WriteXYZFile(char const*) const
int R3PointSet::
WriteXYZFile(const char *filename) const
{
 // Open file
  FILE *fp = fopen(filename, "w");
  if (!fp) {
    RNFail("Unable to open %s\n", filename);
    return 0;
  }

  // Write points
  for (int i = 0; i < NPoints(); i++) {
    const R3Point& p = PointPosition(i);
    fprintf(fp, "%g %g %g\n", p[0], p[1], p[2]);
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x754c4(%rip), %rsi     # 0xf5cba
movq %r15, %rdi
callq 0x22a70
testq %rax, %rax
je 0x80881
movq %rax, %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
testl %ecx, %ecx
jle 0x80872
movl $0x10, %r12d
xorl %r13d, %r13d
leaq 0x734d1(%rip), %r15     # 0xf3cff
movsd -0x10(%rax,%r12), %xmm0
movsd -0x8(%rax,%r12), %xmm1
movsd (%rax,%r12), %xmm2
movq %r14, %rdi
movq %r15, %rsi
movb $0x3, %al
callq 0x22d50
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
movslq %ecx, %rcx
addq $0x18, %r12
cmpq %rcx, %r13
jl 0x8082e
movq %r14, %rdi
callq 0x22880
movl $0x1, %ebx
jmp 0x80894
leaq 0x74b4a(%rip), %rdi     # 0xf53d2
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0xa172a
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::WriteXYZNFile(char const*) const
int R3PointSet::
WriteXYZNFile(const char *filename) const
{
 // Open file
  FILE *fp = fopen(filename, "w");
  if (!fp) {
    RNFail("Unable to open %s\n", filename);
    return 0;
  }

  // Write points
  for (int i = 0; i < NPoints(); i++) {
    const R3Point& p = PointPosition(i);
    const R3Vector& n = PointNormal(i);
    fprintf(fp, "%g %g %g %g %g %g\n", p[0], p[1], p[2], n[0], n[1], n[2]);
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x75402(%rip), %rsi     # 0xf5cba
movq %r15, %rdi
callq 0x22a70
testq %rax, %rax
je 0x80981
movq %rax, %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
testl %ecx, %ecx
jle 0x80972
xorl %r12d, %r12d
leaq 0x749be(%rip), %r13     # 0xf52b0
leaq 0x74aec(%rip), %r15     # 0xf53e5
xorl %ebp, %ebp
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
imull $0xaaaaaaab, %edx, %edx # imm = 0xAAAAAAAB
movslq %edx, %rdx
cmpq %rdx, %rbp
jl 0x8091d
movq %r13, %rcx
jmp 0x80920
addq %r12, %rcx
movsd (%rax,%r12), %xmm0
movsd 0x8(%rax,%r12), %xmm1
movsd 0x10(%rax,%r12), %xmm2
movsd (%rcx), %xmm3
movsd 0x8(%rcx), %xmm4
movsd 0x10(%rcx), %xmm5
movq %r14, %rdi
movq %r15, %rsi
movb $0x6, %al
callq 0x22d50
incq %rbp
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
movslq %ecx, %rcx
addq $0x18, %r12
cmpq %rcx, %rbp
jl 0x808fb
movq %r14, %rdi
callq 0x22880
movl $0x1, %ebx
jmp 0x80994
leaq 0x74a4a(%rip), %rdi     # 0xf53d2
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0xa172a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::WritePTSFile(char const*) const
int R3PointSet::
WritePTSFile(const char *filename) const
{
 // Open file
  FILE *fp = fopen(filename, "wb");
  if (!fp) {
    RNFail("Unable to open %s\n", filename);
    return 0;
  }

  // Write points
  float buf[6];
  for (int i = 0; i < NPoints(); i++) {
    const R3Point& p = PointPosition(i);
    const R3Vector& n = PointNormal(i);
    buf[0] = p[0]; buf[1] = p[1]; buf[2] = p[2];
    buf[3] = n[0]; buf[4] = n[1]; buf[5] = n[2];
    if (fwrite(buf, sizeof(float), 6, fp) != (unsigned int) 6) {
      RNFail("Unable to write point %d to %s\n", i, filename);
      return 0;
    }
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x74070(%rip), %rsi     # 0xf4c8d
movq %rbx, %rdi
callq 0x22a70
testq %rax, %rax
je 0x80cfe
movq %rax, %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
testl %ecx, %ecx
jle 0x80cef
xorl %ebp, %ebp
movq %rsp, %r13
xorl %r12d, %r12d
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
imull $0xaaaaaaab, %edx, %edx # imm = 0xAAAAAAAB
movslq %edx, %rdx
cmpq %rdx, %r12
jl 0x80c7b
leaq 0x74637(%rip), %rcx     # 0xf52b0
jmp 0x80c7e
addq %rbp, %rcx
movupd (%rax,%rbp), %xmm0
movsd 0x10(%rax,%rbp), %xmm1
movhpd (%rcx), %xmm1           # xmm1 = xmm1[0],mem[0]
cvtpd2ps %xmm1, %xmm1
cvtpd2ps %xmm0, %xmm0
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movapd %xmm0, (%rsp)
movupd 0x8(%rcx), %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, 0x10(%rsp)
movl $0x4, %esi
movl $0x6, %edx
movq %r13, %rdi
movq %r15, %rcx
callq 0x23240
cmpq $0x6, %rax
jne 0x80d13
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
movslq %ecx, %rcx
addq $0x18, %rbp
cmpq %rcx, %r12
jl 0x80c55
movq %r15, %rdi
callq 0x22880
movl $0x1, %ebp
jmp 0x80d29
leaq 0x746cd(%rip), %rdi     # 0xf53d2
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa172a
jmp 0x80d29
leaq 0x746de(%rip), %rdi     # 0xf53f8
xorl %ebp, %ebp
movl %r12d, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xa172a
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::WriteSDFFile(char const*) const
int R3PointSet::
WriteSDFFile(const char *filename) const
{
 // Open file
  FILE *fp = fopen(filename, "wb");
  if (!fp) {
    RNFail("Unable to open %s\n", filename);
    return 0;
  }

  // Write points
  float buf[4];
  for (int i = 0; i < NPoints(); i++) {
    const R3Point& p = PointPosition(i);
    buf[0] = p[0]; buf[1] = p[1]; buf[2] = p[2];
    buf[3] = PointValue(i);
    if (fwrite(buf, sizeof(float), 4, fp) != (unsigned int) 4) {
      RNFail("Unable to write point %d to %s\n", i, filename);
      return 0;
    }
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x73f38(%rip), %rsi     # 0xf4c8d
movq %rbx, %rdi
callq 0x22a70
testq %rax, %rax
je 0x80e32
movq %rax, %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
testl %ecx, %ecx
jle 0x80e23
movl $0x2, %ebp
xorl %r12d, %r12d
movq %rsp, %r13
movupd -0x10(%rax,%rbp,8), %xmm0
cvtpd2ps %xmm0, %xmm0
movlpd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsd2ss (%rax,%rbp,8), %xmm0
movss %xmm0, 0x8(%rsp)
movq 0xf0(%r14), %rax
movq 0xf8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
movss 0x73543(%rip), %xmm0    # 0xf4310
cmpq %rcx, %r12
jge 0x80ddb
xorps %xmm0, %xmm0
cvtsd2ss (%rax,%r12,8), %xmm0
movss %xmm0, 0xc(%rsp)
movl $0x4, %esi
movl $0x4, %edx
movq %r13, %rdi
movq %r15, %rcx
callq 0x23240
cmpq $0x4, %rax
jne 0x80e47
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xaaaaaaab, %ecx, %ecx # imm = 0xAAAAAAAB
movslq %ecx, %rcx
addq $0x3, %rbp
cmpq %rcx, %r12
jl 0x80d90
movq %r15, %rdi
callq 0x22880
movl $0x1, %ebp
jmp 0x80e5d
leaq 0x74599(%rip), %rdi     # 0xf53d2
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0xa172a
jmp 0x80e5d
leaq 0x745aa(%rip), %rdi     # 0xf53f8
xorl %ebp, %ebp
movl %r12d, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xa172a
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3PointSet.cpp
// Function: gaps::R3PointSet::WriteMeshFile(char const*) const
int R3PointSet::
WriteMeshFile(const char *filename) const
{
  // Create mesh
  R3Mesh mesh;
  for (int i = 0; i < NPoints(); i++) {
    mesh.CreateVertex(PointPosition(i), PointNormal(i), PointColor(i));
  }

  // Write mesh
  return mesh.WriteFile(filename);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
callq 0x58a90
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x80f40
xorl %r12d, %r12d
leaq 0x743f9(%rip), %r13     # 0xf52b0
leaq 0xea7b2(%rip), %rbp     # 0x16b670
leaq 0x10(%rsp), %r15
xorl %ebx, %ebx
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rax
subq %rdx, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %rbx
jl 0x80ee6
movq %r13, %rdx
jmp 0x80ee9
addq %r12, %rdx
movq 0x80(%r14), %rax
movq 0x78(%r14), %rcx
subq %rcx, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
cmpq %rax, %rbx
jl 0x80f0d
movq %rbp, %rcx
jmp 0x80f10
addq %r12, %rcx
addq %r12, %rsi
movq %r15, %rdi
xorl %r8d, %r8d
callq 0x5c01c
incq %rbx
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
addq $0x18, %r12
cmpq %rax, %rbx
jl 0x80ec5
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x69992
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x58fce
movl %ebx, %eax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x80f71
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x58fce
movq %rbx, %rdi
callq 0x23090
// File: /workspace/github_cpp_makefile_star2_O3/kusumi[P]procstat/container.cc
// Function: Container::Container(int, char**)
Container::Container(int argc, char *argv[])
{
	_build_window();
	for (int i = 0; i < argc; i++) {
		char *p = argv[i];
		struct stat st;
		if (stat(p, &st) == -1 || !S_ISREG(st.st_mode))
			continue;
		if (i < static_cast<int>(_v.size())) {
			_v[i]->attach_buffer(p);
			int wd = add_watch(p);
			if (wd != -1)
				_map.insert(_map_t::value_type(wd, _v[i]));
		}
	}
	_it = _v.begin();
	(*_it)->focus(true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movl %esi, %ebp
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x7ceb(%rip), %rax      # 0xc3f2
cmpb $0x0, (%rax)
movq %rdi, (%rsp)
je 0x4717
callq 0x4acc
jmp 0x471c
callq 0x49b8
testl %ebp, %ebp
jle 0x47f2
movl %ebp, %r12d
xorl %r15d, %r15d
leaq 0x18(%rsp), %rbx
movq (%r14,%r15,8), %rbp
movq %rbp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x3330
cmpl $-0x1, %eax
je 0x47e6
movl 0x50(%rsp), %eax
movl $0xf000, %ecx           # imm = 0xF000
andl %ecx, %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x47e6
movq (%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jge 0x47e6
movq (%rax,%r15,8), %r13
movq %rbx, %rdi
movq %rbp, %rsi
leaq 0x8(%rsp), %rdx
callq 0x5034
movq %r13, %rdi
movq %rbx, %rsi
callq 0x57f2
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x47b4
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3380
movq %rbp, %rdi
callq 0x703a
cmpl $-0x1, %eax
je 0x47e6
movq (%rsp), %rcx
movq (%rcx), %rcx
movl %eax, 0x8(%rsp)
movq (%rcx,%r15,8), %rax
movq %rax, 0x10(%rsp)
leaq 0x7ca4(%rip), %rdi      # 0xc480
leaq 0x8(%rsp), %rsi
callq 0x543a
incq %r15
cmpq %r15, %r12
jne 0x472f
movq (%rsp), %rcx
movq (%rcx), %rax
movq %rax, 0x18(%rcx)
movq (%rax), %rdi
movl $0x1, %esi
callq 0x5980
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4843
jmp 0x4843
jmp 0x4843
movq %rax, %r14
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x4846
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3380
jmp 0x4846
movq %rax, %r14
movq (%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4862
movq (%rsp), %rax
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x3380
movq %r14, %rdi
callq 0x3680
// File: /workspace/github_cpp_makefile_star2_O3/kusumi[P]procstat/main.cc
// Function: (anonymous namespace)::atexit_handler()
void atexit_handler(void)
{
	cleanup_screen();
	cleanup_watch();
	cleanup_log();
	cleanup_lock();
	if (_what)
		std::cerr << _what << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x6c40
callq 0x702f
callq 0x695a
movq 0x7ef8(%rip), %rbx      # 0xc420
testq %rbx, %rbx
je 0x4578
movq %rbx, %rdi
callq 0x3180
movq 0x7aac(%rip), %r14      # 0xbfe8
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x3400
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3350
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3260
addq $0x8, %rsp
popq %rbx
popq %r14
retq