LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/encoder.cpp
// Function: generateCodes(HuffmanTable&)
void generateCodes(HuffmanTable& hTable) {
    uint code = 0;
    for (uint i = 0; i < 16; ++i) {
        for (uint j = hTable.offsets[i]; j < hTable.offsets[i + 1]; ++j) {
            hTable.codes[j] = code;
            code += 1;
        }
        code <<= 1;
    }
}

// Assembly:
movb (%rdi), %sil
xorl %eax, %eax
xorl %ecx, %ecx
movb 0x1(%rdi,%rax), %dl
incq %rax
cmpb %dl, %sil
jae 0x30f2
movzbl %sil, %esi
movl %ecx, 0xc4(%rdi,%rsi,4)
incl %ecx
incq %rsi
movzbl (%rdi,%rax), %edx
cmpq %rdx, %rsi
jb 0x30dd
addl %ecx, %ecx
movl %edx, %esi
cmpq $0x10, %rax
jne 0x30cd
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/encoder.cpp
// Function: bitLength(int)
uint bitLength(int v) {
    uint length = 0;
    while (v > 0) {
        v >>= 1;
        length += 1;
    }
    return length;
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
jle 0x3110
movl %edi, %ecx
shrl %ecx
incl %eax
cmpl $0x1, %edi
movl %ecx, %edi
ja 0x3105
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/encoder.cpp
// Function: getCode(HuffmanTable const&, unsigned char, unsigned int&, unsigned int&)
bool getCode(const HuffmanTable& hTable, byte symbol, uint& code, uint& codeLength) {
    for (uint i = 0; i < 16; ++i) {
        for (uint j = hTable.offsets[i]; j < hTable.offsets[i + 1]; ++j) {
            if (symbol == hTable.symbols[j]) {
                code = hTable.codes[j];
                codeLength = i + 1;
                return true;
            }
        }
    }
    return false;
}

// Assembly:
pushq %rbx
movb (%rdi), %r9b
movb $0x1, %al
xorl %r8d, %r8d
movq %r8, %r10
movl %r9d, %r11d
incq %r8
movb 0x1(%rdi,%r10), %r9b
cmpb %r9b, %r11b
jae 0x3144
movzbl %r9b, %ebx
movzbl %r11b, %r11d
cmpb %sil, 0x11(%rdi,%r11)
je 0x3155
incq %r11
cmpq %r11, %rbx
jne 0x3135
cmpq $0xf, %r10
setb %al
cmpq $0x10, %r8
jne 0x311a
xorl %eax, %eax
jmp 0x3162
movl 0xc4(%rdi,%r11,4), %esi
movl %esi, (%rdx)
movl %r8d, (%rcx)
andb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/encoder.cpp
// Function: writeQuantizationTable(std::basic_ofstream<char, std::char_traits<char>>&, unsigned char, QuantizationTable const&)
void writeQuantizationTable(std::ofstream& outFile, byte tableID, const QuantizationTable& qTable) {
    outFile.put(0xFF);
    outFile.put(DQT);
    putShort(outFile, 67);
    outFile.put(tableID);
    for (uint i = 0; i < 64; ++i) {
        outFile.put(qTable.table[zigZagMap[i]]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2030
movq %r14, %rdi
movl $0xffffffdb, %esi       # imm = 0xFFFFFFDB
callq 0x2030
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
callq 0x2030
movq %r14, %rdi
movl $0x43, %esi
callq 0x2030
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x2030
leaq 0x1b37(%rip), %r12      # 0x52e0
movzbl (%r15,%r12), %eax
movsbl (%rbx,%rax,4), %esi
movq %r14, %rdi
callq 0x2030
incq %r15
cmpq $0x40, %r15
jne 0x37a9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/encoder.cpp
// Function: writeHuffmanTable(std::basic_ofstream<char, std::char_traits<char>>&, unsigned char, unsigned char, HuffmanTable const&)
void writeHuffmanTable(std::ofstream& outFile, byte acdc, byte tableID, const HuffmanTable& hTable) {
    outFile.put(0xFF);
    outFile.put(DHT);
    putShort(outFile, 19 + hTable.offsets[16]);
    outFile.put(acdc << 4 | tableID);
    for (uint i = 0; i < 16; ++i) {
        outFile.put(hTable.offsets[i + 1] - hTable.offsets[i]);
    }
    for (uint i = 0; i < 16; ++i) {
        for (uint j = hTable.offsets[i]; j < hTable.offsets[i + 1]; ++j) {
            outFile.put(hTable.symbols[j]);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2030
movq %r14, %rdi
movl $0xffffffc4, %esi       # imm = 0xFFFFFFC4
callq 0x2030
movzbl 0x10(%rbx), %r12d
addl $0x13, %r12d
movl %r12d, %esi
shrl $0x8, %esi
movq %r14, %rdi
callq 0x2030
movsbl %r12b, %esi
movq %r14, %rdi
callq 0x2030
shlb $0x4, %bpl
orb %r15b, %bpl
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x2030
xorl %eax, %eax
leaq 0x1(%rax), %r15
movb 0x1(%rbx,%rax), %cl
subb (%rbx,%rax), %cl
movsbl %cl, %esi
movq %r14, %rdi
callq 0x2030
movq %r15, %rax
cmpq $0x10, %r15
jne 0x38fd
movb (%rbx), %al
xorl %r15d, %r15d
movb 0x1(%rbx,%r15), %cl
incq %r15
cmpb %cl, %al
jae 0x394c
movzbl %al, %r12d
movsbl 0x11(%rbx,%r12), %esi
movq %r14, %rdi
callq 0x2030
incq %r12
movzbl (%rbx,%r15), %ecx
cmpq %rcx, %r12
jb 0x3931
movl %ecx, %eax
cmpq $0x10, %r15
jne 0x3921
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannye[P]jed/src/encoder.cpp
// Function: BitWriter::writeBit(unsigned int)
void writeBit(uint bit) {
        if (nextBit == 0) {
            data.push_back(0);
        }
        data.back() |= (bit & 1) << (7 - nextBit);
        nextBit = (nextBit + 1) % 8;
        if (nextBit == 0 && data.back() == 0xFF) {
            data.push_back(0);
        }
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
jne 0x3f9e
movq 0x8(%rbx), %rdi
movb $0x0, 0x7(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x3f92
movb $0x0, (%rsi)
incq 0x8(%rdi)
jmp 0x3f9c
leaq 0x7(%rsp), %rdx
callq 0x3ff0
movb (%rbx), %al
andl $0x1, %ebp
movb $0x7, %cl
subb %al, %cl
shll %cl, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
orb %bpl, -0x1(%rax)
movb (%rbx), %al
incb %al
andb $0x7, %al
movb %al, (%rbx)
jne 0x3fe9
movq 0x8(%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpb $-0x1, -0x1(%rsi)
jne 0x3fe9
movb $0x0, 0x6(%rsp)
cmpq 0x10(%rdi), %rsi
je 0x3fdf
movb $0x0, (%rsi)
incq 0x8(%rdi)
jmp 0x3fe9
leaq 0x6(%rsp), %rdx
callq 0x3ff0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/sflview/sflview.cpp
// Function: GLUTStop()
void GLUTStop(void)
{
  // Terminate viewer
  if (viewer) viewer->Terminate();

  // Close scene
  if (scene) CloseScene(scene);

  // Destroy window 
  // glutDestroyWindow(GLUTwindow);

  // Exit
  exit(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x1962d4(%rip), %rdi    # 0x1c1980
testq %rdi, %rdi
je 0x2b6b7
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x1962ca(%rip), %rbx    # 0x1c1988
testq %rbx, %rbx
je 0x2b84c
movq %rsp, %r15
movq %r15, %rdi
callq 0xe50e8
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x28020
cmpb $0x1, 0x1962e2(%rip)    # 0x1c19c8
jne 0x2b831
leaq 0x10cc1c(%rip), %rdi    # 0x13830f
callq 0x27f10
movq %rsp, %rdi
callq 0xe514a
leaq 0x10c9c6(%rip), %rdi    # 0x1380cd
movb $0x1, %al
callq 0x27080
movl 0x1c(%rbx), %esi
leaq 0x10c9cc(%rip), %rdi    # 0x1380e4
xorl %eax, %eax
callq 0x27080
movl 0x2c(%rbx), %esi
leaq 0x10c9cd(%rip), %rdi    # 0x1380f6
xorl %eax, %eax
callq 0x27080
movl 0x7c(%rbx), %esi
leaq 0x10c9cd(%rip), %rdi    # 0x138107
xorl %eax, %eax
callq 0x27080
movl 0xac(%rbx), %esi
leaq 0x10c9cf(%rip), %rdi    # 0x13811d
xorl %eax, %eax
callq 0x27080
movl 0x8c(%rbx), %esi
leaq 0x10c9ce(%rip), %rdi    # 0x138130
xorl %eax, %eax
callq 0x27080
movl 0x9c(%rbx), %esi
leaq 0x10c9ca(%rip), %rdi    # 0x138140
xorl %eax, %eax
callq 0x27080
movq 0x8(%rbx), %rax
movl 0x24(%rax), %esi
leaq 0x10c9c6(%rip), %rdi    # 0x138151
xorl %eax, %eax
callq 0x27080
movq 0x8(%rbx), %rcx
movslq 0x24(%rcx), %rax
testq %rax, %rax
jle 0x2b7b8
movq 0x18(%rcx), %rcx
xorl %edx, %edx
xorl %r14d, %r14d
movq (%rcx,%rdx,8), %rsi
addl 0x4c(%rsi), %r14d
incq %rdx
cmpq %rdx, %rax
jne 0x2b7a8
leaq 0x10c9a2(%rip), %rdi    # 0x138161
xorl %r15d, %r15d
movl %r14d, %esi
xorl %eax, %eax
callq 0x27080
movq 0x8(%rbx), %rcx
movslq 0x24(%rcx), %rax
testq %rax, %rax
jle 0x2b811
movq 0x18(%rcx), %rcx
xorl %edx, %edx
xorl %r15d, %r15d
movq (%rcx,%rdx,8), %rdi
movslq 0x4c(%rdi), %rsi
testq %rsi, %rsi
jle 0x2b809
movq 0x40(%rdi), %rdi
xorl %r8d, %r8d
movq (%rdi,%r8,8), %r9
movslq 0x8(%r9), %r9
addq %r9, %r15
incq %r8
cmpq %r8, %rsi
jne 0x2b7f6
incq %rdx
cmpq %rax, %rdx
jne 0x2b7e2
leaq 0x10c95a(%rip), %rdi    # 0x138172
movq %r15, %rsi
xorl %eax, %eax
callq 0x27080
movq 0x190677(%rip), %rax    # 0x1bbea0
movq (%rax), %rdi
callq 0x27af0
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0xf8(%rax)
testl %eax, %eax
jne 0x2b84c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %edi, %edi
callq 0x27b50
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/sflview/sflview.cpp
// Function: GLUTRedraw()
void GLUTRedraw(void)
{
  // Redraw with viewer
  if (viewer->Redraw()) {
    glutPostRedisplay();
  }

  // Draw stuff
  DrawModel();

  // Swap buffers 
  glutSwapBuffers();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x196118(%rip), %rdi    # 0x1c1980
movq (%rdi), %rax
callq *0x20(%rax)
testl %eax, %eax
je 0x2b877
callq 0x12b6fc
cmpq $0x0, 0x196131(%rip)    # 0x1c19b0
je 0x2ba11
cmpl $0x0, 0x19115c(%rip)    # 0x1bc9e8
je 0x2b8c8
movl $0xb50, %edi            # imm = 0xB50
callq 0x27860
movsd 0x10c768(%rip), %xmm0   # 0x138008
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
callq 0x27ed0
movq 0x1960fc(%rip), %rdi    # 0x1c19b0
movl $0x772, %esi            # imm = 0x772
callq 0x63836
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
cmpl $0x0, 0x1960c1(%rip)    # 0x1c1990
je 0x2ba11
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movss 0x10c759(%rip), %xmm0   # 0x138040
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
callq 0x28350
movq 0x1960b5(%rip), %rax    # 0x1c19b0
cmpl $0x0, 0x14(%rax)
jle 0x2ba11
xorl %r14d, %r14d
leaq 0x30(%rsp), %rbx
leaq 0x18(%rsp), %r15
movq %rsp, %r12
leaq 0x59a494(%rip), %r13    # 0x5c5db0
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rbp
cmpq $0x0, 0x1a0(%rbp)
je 0x2b9fa
cmpl $0x0, 0x2c(%rbp)
jne 0x2b9fa
movq %rbp, %rdi
callq 0x76928
movsd 0x8(%rax), %xmm0
ucomisd 0x20(%rax), %xmm0
ja 0x2b9fa
movsd 0x10(%rax), %xmm0
ucomisd 0x28(%rax), %xmm0
ja 0x2b9fa
movsd 0x18(%rax), %xmm0
ucomisd 0x30(%rax), %xmm0
ja 0x2b9fa
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x76ae6
movq %rbp, %rdi
callq 0x76928
movsd 0x30(%rax), %xmm0
subsd 0x18(%rax), %xmm0
mulsd 0x10c677(%rip), %xmm0   # 0x138010
mulsd 0x10c677(%rip), %xmm0   # 0x138018
movq %r15, %rdi
leaq 0x11693d(%rip), %rsi    # 0x1422e8
callq 0xc5162
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xc4077
movq 0x1a0(%rbp), %rbp
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x272c0
movb (%rbp), %al
testb %al, %al
je 0x2b9fa
incq %rbp
movsbl %al, %esi
movq %r13, %rdi
callq 0x12b82c
movb (%rbp), %al
incq %rbp
testb %al, %al
jne 0x2b9e5
incq %r14
movq 0x195fac(%rip), %rax    # 0x1c19b0
movslq 0x14(%rax), %rcx
cmpq %rcx, %r14
jl 0x2b91c
callq 0x12b74e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/sflview/sflview.cpp
// Function: GLUTResize(int, int)
void GLUTResize(int w, int h)
{
  // Remember window dimensions
  GLUTwindow_width = w;
  GLUTwindow_height = h;

  // Resize viewer
  if (viewer->Resize(w, h)) {
    glutPostRedisplay();
  }
}

// Assembly:
pushq %rax
movl %esi, %edx
movl %edi, %esi
movl %edi, 0x190fb0(%rip)    # 0x1bc9e0
movl %edx, 0x190fae(%rip)    # 0x1bc9e4
movq 0x195f43(%rip), %rdi    # 0x1c1980
movq (%rdi), %rax
callq *0x28(%rax)
testl %eax, %eax
je 0x2ba4d
popq %rax
jmp 0x12b6fc
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/sflview/sflview.cpp
// Function: GLUTMouseButton(int, int, int, int)
void GLUTMouseButton(int button, int state, int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;
  
  // Determine button
  int b = button;
  if (button == GLUT_LEFT_BUTTON) b = 0;
  else if (button == GLUT_MIDDLE_BUTTON) b = 1;
  else if (button == GLUT_RIGHT_BUTTON) b = 2;

  // Determinte state
  int s = (state == GLUT_DOWN) ? 1 : 0;

  // Determine modifiers
  int modifiers = glutGetModifiers();
  int shift = (modifiers & GLUT_ACTIVE_SHIFT);
  int ctrl = (modifiers & GLUT_ACTIVE_CTRL);
  int alt = (modifiers & GLUT_ACTIVE_ALT);

  // Send mouse event to viewer
  if (viewer->MouseButton(x, y, b, s, shift, ctrl, alt)) {
    glutPostRedisplay();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %edi, %ebp
movl 0x190f5d(%rip), %r14d   # 0x1bc9e4
subl %ecx, %r14d
xorl %r15d, %r15d
testl %esi, %esi
sete %r15b
callq 0x1305b5
movl %eax, %r9d
andl $0x1, %r9d
movl %eax, %r10d
andl $0x2, %r10d
andl $0x4, %eax
movq 0x195ed0(%rip), %rdi    # 0x1c1980
movq (%rdi), %r11
subq $0x8, %rsp
movl %ebx, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %r15d, %r8d
pushq $0x1
pushq %rax
pushq %r10
callq *0x38(%r11)
addq $0x20, %rsp
addq $0x8, %rsp
testl %eax, %eax
je 0x2bae1
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12b6fc
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/sflview/sflview.cpp
// Function: GLUTInit(int*, char**)
void GLUTInit(int *argc, char **argv)
{
  // Open window
  glutInit(argc, argv);
  glutInitWindowPosition(100, 100);
  glutInitWindowSize(GLUTwindow_width, GLUTwindow_height);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_ALPHA);
  GLUTwindow = glutCreateWindow("Surfel Viewer");

  // Initialize grfx (after create context because calls glewInit)
  RNInitGrfx();

  // Initialize GLUT callback functions
  glutDisplayFunc(GLUTRedraw);
  glutReshapeFunc(GLUTResize);
  glutKeyboardFunc(GLUTKeyboard);
  glutSpecialFunc(GLUTSpecial);
  glutMouseFunc(GLUTMouseButton);
  glutMotionFunc(GLUTMouseMotion);
  atexit(GLUTStop);

  // Initialize viewer
  viewer->Initialize();
}

// Assembly:
pushq %rax
callq 0x12c371
movl $0x64, %edi
movl $0x64, %esi
callq 0x12c8c1
movl 0x190bc7(%rip), %edi    # 0x1bc9e0
movl 0x190bc5(%rip), %esi    # 0x1bc9e4
callq 0x12c8d7
movl $0x1a, %edi
callq 0x12c8f6
leaq 0x10c28a(%rip), %rdi    # 0x1380bf
callq 0x1318a6
callq 0xe51d0
leaq -0x5f3(%rip), %rdi      # 0x2b853
callq 0x12adf8
leaq -0x42d(%rip), %rdi      # 0x2ba25
callq 0x12ae4d
leaq -0x235(%rip), %rdi      # 0x2bc29
callq 0x12ae8f
leaq -0x382(%rip), %rdi      # 0x2bae8
callq 0x12aed7
leaq -0x401(%rip), %rdi      # 0x2ba75
callq 0x12b220
leaq -0x433(%rip), %rdi      # 0x2ba4f
callq 0x12b2b0
leaq -0x7f2(%rip), %rdi      # 0x2b69c
callq 0x137f20
movq 0x195ae6(%rip), %rdi    # 0x1c1980
movq (%rdi), %rax
popq %rcx
jmpq *0x10(%rax)
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/apps/sflview/sflview.cpp
// Function: GLUTMainLoop()
void GLUTMainLoop(void)
{
  // Set background color
  viewer->SetBackgroundColor(background_color);

  // Set camera 
  if (initial_camera) {
    R3Camera camera(initial_camera_eye, initial_camera_towards, initial_camera_up, 0.4, 0.4, 0.01, 100000.0);
    viewer->SetCamera(camera);
  }

  // Set world origin
  if (initial_world_origin != R3Point(-1, -1, -1)) {
    viewer->SetCenterPoint(initial_world_origin);
  }

  // Run main loop -- never returns
  glutMainLoop();
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq 0x195ad0(%rip), %rdi    # 0x1c1980
movq (%rdi), %rax
leaq 0x195a4e(%rip), %rsi    # 0x1c1908
callq *0x168(%rax)
cmpb $0x1, 0x195acd(%rip)    # 0x1c1994
jne 0x2bf14
leaq 0x195a50(%rip), %rsi    # 0x1c1920
leaq 0x195a61(%rip), %rdx    # 0x1c1938
leaq 0x195a72(%rip), %rcx    # 0x1c1950
movq %rsp, %rbx
movsd 0x10c137(%rip), %xmm0   # 0x138020
movsd 0x10c137(%rip), %xmm2   # 0x138028
movsd 0x10c137(%rip), %xmm3   # 0x138030
movq %rbx, %rdi
movaps %xmm0, %xmm1
callq 0x79f14
movq 0x195a75(%rip), %rdi    # 0x1c1980
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x58(%rax)
movq %rsp, %rbx
movsd 0x10c119(%rip), %xmm0   # 0x138038
movq %rbx, %rdi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0xc3d32
leaq 0x195a34(%rip), %rdi    # 0x1c1968
movq %rbx, %rsi
callq 0xc3e28
testl %eax, %eax
je 0x2bf57
movq 0x195a39(%rip), %rdi    # 0x1c1980
movq (%rdi), %rax
leaq 0x195a17(%rip), %rsi    # 0x1c1968
callq *0x80(%rax)
callq 0x12e9b7
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::~R3SurfelViewer()
R3SurfelViewer::
~R3SurfelViewer(void)
{
  // Delete selected image texture
  if (selected_image_texture_id > 0) glDeleteTextures(1, &selected_image_texture_id);

#if (R3_SURFEL_VIEWER_DRAW_METHOD == R3_SURFEL_VIEWER_DRAW_WITH_VBO)
  // Delete VBO buffers
  if (vbo_position_buffer > 0) glDeleteBuffers(1, &vbo_position_buffer);
  if (vbo_normal_buffer > 0) glDeleteBuffers(1, &vbo_normal_buffer);
  if (vbo_color_buffer > 0) glDeleteBuffers(1, &vbo_color_buffer);
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x186e03(%rip), %rax    # 0x1b3ae0
movq %rax, (%rdi)
cmpl $0x0, 0x5e8(%rdi)
je 0x2ccfa
leaq 0x5e8(%rbx), %rsi
movl $0x1, %edi
callq 0x27cf0
cmpl $0x0, 0x5f8(%rbx)
je 0x2cd18
leaq 0x5f8(%rbx), %rsi
movq 0x18f297(%rip), %rax    # 0x1bbfa8
movl $0x1, %edi
callq *(%rax)
cmpl $0x0, 0x5fc(%rbx)
je 0x2cd36
leaq 0x5fc(%rbx), %rsi
movq 0x18f279(%rip), %rax    # 0x1bbfa8
movl $0x1, %edi
callq *(%rax)
cmpl $0x0, 0x600(%rbx)
je 0x2cd54
leaq 0x600(%rbx), %rsi
movq 0x18f25b(%rip), %rax    # 0x1bbfa8
movl $0x1, %edi
callq *(%rax)
leaq 0x5c8(%rbx), %rdi
callq 0xdeff4
leaq 0x4f8(%rbx), %rdi
callq 0xcd2d8
movq 0x340(%rbx), %rdi
testq %rdi, %rdi
je 0x2cd87
movq 0x350(%rbx), %rsi
subq %rdi, %rsi
callq 0x27930
leaq 0x168(%rbx), %rdi
callq 0xae0e4
leaq 0x120(%rbx), %rdi
callq 0xae0e4
leaq 0x78(%rbx), %rdi
callq 0x785f8
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x412c0
movq %rax, %rdi
callq 0x344f1
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::ObjectVisibility(gaps::R3SurfelObject*) const
int R3SurfelViewer::
ObjectVisibility(R3SurfelObject *object) const
{
  // Check if any part is visible
  for (int i = 0; i < object->NParts(); i++) {
    R3SurfelObject *part = object->Part(i);
    if (ObjectVisibility(part)) return 1;
  }

  // Check if any node is visible
  for (int i = 0; i < object->NNodes(); i++) {
    R3SurfelNode *node = object->Node(i);
    if (NodeVisibility(node)) return 1;
  }

  // Not visible
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x2c(%rsi)
jle 0x2ce2e
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x2cdfa
testl %eax, %eax
jne 0x2ce5b
incq %r15
movslq 0x2c(%rbx), %rax
cmpq %rax, %r15
jl 0x2ce0e
cmpl $0x0, 0x6c(%rbx)
jle 0x2ce57
xorl %r15d, %r15d
movq 0x60(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x2ce66
testl %eax, %eax
jne 0x2ce5b
incq %r15
movslq 0x6c(%rbx), %rax
cmpq %rax, %r15
jl 0x2ce37
xorl %eax, %eax
jmp 0x2ce60
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::LabelVisibility(int) const
int R3SurfelViewer::
LabelVisibility(int label_index) const
{
  // Check label index
  if (label_index < 0) return FALSE;
  if (label_index >= scene->NLabels()) return FALSE;

  // Label is visible if not in list
  if (label_visibilities.size() <= (unsigned int) label_index) 
    return TRUE;

  // Return whether label is visible
  return label_visibilities[label_index];
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
js 0x2d093
movq 0x8(%rdi), %rcx
cmpl %esi, 0x2c(%rcx)
jle 0x2d093
movq 0x340(%rdi), %rcx
movq 0x348(%rdi), %rdi
subq %rcx, %rdi
sarq $0x2, %rdi
movl %esi, %edx
movl $0x1, %eax
cmpq %rdx, %rdi
jbe 0x2d093
movl (%rcx,%rdx,4), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::SetLabelVisibility(int, int)
void R3SurfelViewer::
SetLabelVisibility(int label_index, int visibility)
{
  // Check label index
  if (label_index == -1) {
    if (visibility == 1) {
      // Turn all visibilities on
      label_visibilities.clear();
    }
    else {
      // Set all visibilities
      for (int i = 0; i < scene->NLabels(); i++) {
        SetLabelVisibility(i, visibility);
      }
    }
  }
  else {
    // Check label index
    if (label_index < 0) return;
    if (label_index >= scene->NLabels()) return;

    // Add label visibilities
    while (label_visibilities.size() <= (unsigned int) label_index) {
      label_visibilities.push_back(1);
    }

    // Set visibility
    if (visibility == -1) label_visibilities[label_index] = 1 - label_visibilities[label_index];
    else if (visibility == 0) label_visibilities[label_index] = 0;
    else label_visibilities[label_index] = 1;
  }

  // Invalidate VBO buffers
  InvalidateVBO();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
cmpl $-0x1, %esi
je 0x2d153
testl %esi, %esi
js 0x2d1bc
movq 0x8(%rbx), %rax
cmpl %esi, 0x2c(%rax)
jle 0x2d1bc
movl %esi, %r12d
movq 0x340(%rbx), %rax
movq 0x348(%rbx), %rsi
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x2d13b
leaq 0x340(%rbx), %r14
leaq 0xc(%rsp), %r15
movl $0x1, 0xc(%rsp)
cmpq 0x350(%rbx), %rsi
je 0x2d113
movl $0x1, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x348(%rbx)
jmp 0x2d12c
movq %r14, %rdi
movq %r15, %rdx
callq 0x34ab8
movq 0x340(%rbx), %rax
movq 0x348(%rbx), %rsi
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x2d0ef
testl %ebp, %ebp
je 0x2d19e
cmpl $-0x1, %ebp
jne 0x2d1a8
movl $0x1, %ecx
subl (%rax,%r12,4), %ecx
movl %ecx, (%rax,%r12,4)
jmp 0x2d1b0
cmpl $0x1, %ebp
jne 0x2d171
movq 0x340(%rbx), %rax
cmpq %rax, 0x348(%rbx)
je 0x2d1b0
movq %rax, 0x348(%rbx)
jmp 0x2d1b0
movq 0x8(%rbx), %rax
cmpl $0x0, 0x2c(%rax)
jle 0x2d1b0
xorl %r14d, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq *0x148(%rax)
incl %r14d
movq 0x8(%rbx), %rax
cmpl 0x2c(%rax), %r14d
jl 0x2d17e
jmp 0x2d1b0
movl $0x0, (%rax,%r12,4)
jmp 0x2d1b0
movl $0x1, (%rax,%r12,4)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x378(%rax)
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/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::SetAttributeVisibility(gaps::RNFlags, int)
void R3SurfelViewer::
SetAttributeVisibility(RNFlags attribute_flags, int visibility)
{
  // Check if changing all flags
  if (attribute_flags == 0) attribute_flags = 0xFFFFFFFF;

  // Update attribute visibility flags
  if (visibility == -1) attribute_visibility_flags.XOR(attribute_flags);
  else if (!visibility) attribute_visibility_flags.Remove(attribute_flags);
  else attribute_visibility_flags.Add(attribute_flags);

  // Invalidate VBO buffers
  InvalidateVBO();
}

// Assembly:
testq %rsi, %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovneq %rsi, %rax
testl %edx, %edx
je 0x2d1e8
cmpl $-0x1, %edx
jne 0x2d1f4
xorq 0x358(%rdi), %rax
jmp 0x2d1fb
notq %rax
andq 0x358(%rdi), %rax
jmp 0x2d1fb
orq 0x358(%rdi), %rax
movq %rax, 0x358(%rdi)
movq (%rdi), %rax
jmpq *0x378(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::CreateColor(unsigned char*, double) const
void R3SurfelViewer::
CreateColor(unsigned char *color, double value) const
{
  // Compute rgb based on blue-green-red heatmap
  if (value <= 0) {
    color[0] = 0;
    color[1] = 0;
    color[2] = 255;
  }
  else if (value < 0.1) {
    value *= 10 * 255;
    color[0] = 0;
    color[1] = value;
    color[2] = 255;
  }
  else if (value < 0.5) {
    value = (value - 0.1) * 2.5 * 255;
    color[0] = 0;
    color[1] = 255;
    color[2] = 255 - value;
  }
  else if (value < 0.9) {
    value = (value - 0.5) * 2.5 * 255;
    color[0] = value;
    color[1] = 255;
    color[2] = 0;
  }
  else if (value < 1) {
    value = (value - 0.9) * 10 * 255;
    color[0] = 255;
    color[1] = 255 - value;
    color[2] = 0;
  }
  else {
    color[0] = 255;
    color[1] = 0;
    color[2] = 0;
  }
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x2d270
movsd 0x10b0fa(%rip), %xmm1   # 0x138350
ucomisd %xmm0, %xmm1
jbe 0x2d27b
mulsd 0x10b134(%rip), %xmm0   # 0x138398
movb $0x0, (%rsi)
cvttsd2si %xmm0, %eax
movb %al, 0x1(%rsi)
jmp 0x2d275
movw $0x0, (%rsi)
movb $-0x1, %al
movb %al, 0x2(%rsi)
retq
movsd 0x10ad8d(%rip), %xmm1   # 0x138010
ucomisd %xmm0, %xmm1
jbe 0x2d2b4
addsd 0x10b0f7(%rip), %xmm0   # 0x138388
mulsd 0x10b0f7(%rip), %xmm0   # 0x138390
movsd 0x10b0cf(%rip), %xmm1   # 0x138370
mulsd %xmm1, %xmm0
movw $0xff00, (%rsi)         # imm = 0xFF00
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
jmp 0x2d277
movsd 0x10b09c(%rip), %xmm1   # 0x138358
ucomisd %xmm0, %xmm1
jbe 0x2d2e6
addsd 0x10b0ae(%rip), %xmm0   # 0x138378
mulsd 0x10b0ae(%rip), %xmm0   # 0x138380
mulsd 0x10b096(%rip), %xmm0   # 0x138370
cvttsd2si %xmm0, %eax
movb %al, (%rsi)
movb $-0x1, 0x1(%rsi)
jmp 0x2d325
movsd 0x10ad1a(%rip), %xmm1   # 0x138008
ucomisd %xmm0, %xmm1
jbe 0x2d320
addsd 0x10b064(%rip), %xmm0   # 0x138360
mulsd 0x10b064(%rip), %xmm0   # 0x138368
movsd 0x10b064(%rip), %xmm1   # 0x138370
mulsd %xmm1, %xmm0
movb $-0x1, (%rsi)
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, 0x1(%rsi)
jmp 0x2d325
movw $0xff, (%rsi)
xorl %eax, %eax
jmp 0x2d277
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawViewingExtent() const
void R3SurfelViewer::
DrawViewingExtent(void) const
{
  // Check extent visibility
  if (!viewing_extent_visibility) return;
  
  // Check extent
  const R3Box& bbox = scene->BBox();  
  const R3Box& extent = ViewingExtent();
  if (extent.IsEmpty() || R3Contains(extent, bbox)) return;

  // Draw extent
  glDisable(GL_LIGHTING);
  RNLoadRgb(0.5, 0.5, 0.5);
  extent.Outline();
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x338(%rdi)
je 0x2d7bb
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2d768
callq 0x4003c
jmp 0x2d76f
leaq 0x196de9(%rip), %rax    # 0x1c4558
movsd 0x128(%rbx), %xmm0
ucomisd 0x140(%rbx), %xmm0
ja 0x2d7bb
movsd 0x130(%rbx), %xmm0
ucomisd 0x148(%rbx), %xmm0
ja 0x2d7bb
movsd 0x138(%rbx), %xmm0
ucomisd 0x150(%rbx), %xmm0
ja 0x2d7bb
addq $0x120, %rbx            # imm = 0x120
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8a96a
testl %eax, %eax
je 0x2d7bd
popq %rbx
retq
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x10a841(%rip), %xmm0   # 0x138010
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x27ed0
movq (%rbx), %rax
movq 0xb0(%rax), %rax
movl $0x1, %esi
movq %rbx, %rdi
popq %rbx
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::EnableViewingExtent() const
void R3SurfelViewer::
EnableViewingExtent(void) const
{
  // Check clip planes extent
  const R3Box& bbox = scene->BBox();  
  const R3Box& extent = ViewingExtent();
  if (extent.IsEmpty() || R3Contains(extent, bbox)) {
    DisableViewingExtent();
    return;
  }

  // Load lo clip planes
  for (int dim = RN_X; dim <= RN_Z; dim++) {
    if (extent[RN_LO][dim] > bbox[RN_LO][dim]) {
      GLdouble plane_equation[4] = { 0, 0, 0, 0 };
      plane_equation[dim] = 1.0;
      plane_equation[3] = -extent[RN_LO][dim];
      glClipPlane(GL_CLIP_PLANE0 + dim, plane_equation);
      glEnable(GL_CLIP_PLANE0 + dim);
    }
  }

  // Load hi clip planes
  for (int dim = RN_X; dim <= RN_Z; dim++) {
    if (extent[RN_HI][dim] < bbox[RN_HI][dim]) {
      GLdouble plane_equation[4] = { 0, 0, 0, 0 };
      plane_equation[dim] = -1.0;
      plane_equation[3] = extent[RN_HI][dim];
      glClipPlane(GL_CLIP_PLANE0 + 3 + dim, plane_equation);
      glEnable(GL_CLIP_PLANE0 + 3 + dim);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2d81f
callq 0x4003c
movq %rax, %r14
jmp 0x2d826
leaq 0x196d32(%rip), %r14    # 0x1c4558
movsd 0x128(%rbx), %xmm0
ucomisd 0x140(%rbx), %xmm0
ja 0x2d86f
movsd 0x130(%rbx), %xmm0
ucomisd 0x148(%rbx), %xmm0
ja 0x2d86f
movsd 0x138(%rbx), %xmm0
ucomisd 0x150(%rbx), %xmm0
ja 0x2d86f
leaq 0x120(%rbx), %rdi
movq %r14, %rsi
callq 0x8a96a
testl %eax, %eax
je 0x2d889
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x238(%rax)
xorl %r12d, %r12d
movabsq $0x3ff0000000000000, %r13 # imm = 0x3FF0000000000000
movq %rsp, %r15
movsd 0x128(%rbx,%r12,8), %xmm0
ucomisd 0x8(%r14,%r12,8), %xmm0
jbe 0x2d8e7
xorpd %xmm1, %xmm1
movapd %xmm1, 0x10(%rsp)
movapd %xmm1, (%rsp)
movq %r13, (%rsp,%r12,8)
xorpd 0x10abc9(%rip), %xmm0   # 0x138490
movlpd %xmm0, 0x18(%rsp)
movl %r12d, %ebp
orl $0x3000, %ebp           # imm = 0x3000
movl %ebp, %edi
movq %r15, %rsi
callq 0x27390
movl %ebp, %edi
callq 0x27860
incq %r12
cmpq $0x3, %r12
jne 0x2d899
xorl %r12d, %r12d
movabsq $-0x4010000000000000, %r13 # imm = 0xBFF0000000000000
movq %rsp, %r15
movsd 0x140(%rbx,%r12,8), %xmm0
movsd 0x20(%r14,%r12,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2d949
xorpd %xmm1, %xmm1
movapd %xmm1, 0x10(%rsp)
movapd %xmm1, (%rsp)
movq %r13, (%rsp,%r12,8)
movsd %xmm0, 0x18(%rsp)
leal 0x3003(%r12), %ebp
movl %ebp, %edi
movq %r15, %rsi
callq 0x27390
movl %ebp, %edi
callq 0x27860
incq %r12
cmpq $0x3, %r12
jne 0x2d900
addq $0x28, %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/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::UpdateViewingFrustum()
void R3SurfelViewer::
UpdateViewingFrustum(void)
{
  // Update viewing frustum
  const R3Camera& camera = viewer.Camera();
  viewing_frustum = R3Frustum(camera.Origin(), camera.Towards(), camera.Up(),
    camera.XFOV(), camera.YFOV(), camera.Near(), camera.Far());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq %rdi, %rbx
leaq 0x80(%rdi), %r15
leaq 0xc8(%rdi), %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0xc5400
leaq 0xb0(%rbx), %rcx
movsd 0xe0(%rbx), %xmm0
movsd 0xe8(%rbx), %xmm1
movsd 0xf0(%rbx), %xmm2
movsd 0xf8(%rbx), %xmm3
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xa9e44
leaq 0x170(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc409a
leaq 0x188(%rbx), %rdi
leaq 0x38(%rsp), %rsi
callq 0xc4f52
leaq 0x50(%rsp), %rsi
leaq 0x1a0(%rbx), %rdi
callq 0xc4f52
leaq 0x68(%rsp), %rsi
leaq 0x1b8(%rbx), %rdi
callq 0xc4f52
xorl %r15d, %r15d
movq %rbx, %r12
xorl %r13d, %r13d
leaq (%r12,%r13), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
leaq (%r14,%r13), %rsi
addq $0x68, %rsi
callq 0xc4f52
movsd 0x80(%r14,%r13), %xmm0
movsd %xmm0, 0x1e8(%r12,%r13)
addq $0x20, %r13
cmpq $0x60, %r13
jne 0x2da2f
incq %r15
addq $0x60, %r14
addq $0x60, %r12
cmpq $0x2, %r15
jne 0x2da2c
leaq 0x18(%rsp), %rdi
movups 0x128(%rdi), %xmm0
movups 0x138(%rdi), %xmm1
movups %xmm1, 0x2a0(%rbx)
movups %xmm0, 0x290(%rbx)
callq 0xae0e4
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2daaf
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xae0e4
movq %rbx, %rdi
callq 0x28120
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::UpdateSelectedImageColorPixels()
void R3SurfelViewer::
UpdateSelectedImageColorPixels(void)
{
  // Check stuff
  if (!selected_image) return;
  if (selected_image == previous_color_image) return;

  // Get color image
  selected_image_color_pixels = selected_image->ColorChannels();
  if ((selected_image_color_pixels.Width() <= 0) ||
      (selected_image_color_pixels.Height() <= 0) ||
      (selected_image_color_pixels.Depth() != 3)) {
    selected_image_color_pixels = R2Image();
  }

  // Remember last selected image
  previous_color_image = selected_image;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x2d0(%rdi), %rsi
testq %rsi, %rsi
je 0x2dfa5
movq %rdi, %rbx
cmpq 0x5e0(%rdi), %rsi
je 0x2dfa5
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4410c
leaq 0x5c8(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xdf092
leaq 0x8(%rsp), %rdi
callq 0xdeff4
cmpl $0x0, 0x5c8(%rbx)
jle 0x2df75
cmpl $0x0, 0x5cc(%rbx)
jle 0x2df75
cmpl $0x3, 0x5d0(%rbx)
je 0x2df97
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xdea78
movq %r14, %rdi
movq %r15, %rsi
callq 0xdf092
leaq 0x8(%rsp), %rdi
callq 0xdeff4
movq 0x2d0(%rbx), %rax
movq %rax, 0x5e0(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2dfb1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdeff4
movq %rbx, %rdi
callq 0x28120
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::AdaptWorkingSet()
void R3SurfelViewer::
AdaptWorkingSet(void)
{
  // Check if adapting automatically
  if (!adapt_working_set_automatically) return;

  // Adjust target resolution based on frame time
  if (frame_time > 0.05) {
    SetTargetResolution(0.9 * TargetResolution());
  }
  else if (frame_time < 0.025) {
    SetTargetResolution(1.1 * TargetResolution());
  }

  // Make gross estimate of visible radius
  RNLength camera_height = viewer.Camera().Origin().Z();
  RNLength visible_radius = camera_height;

  // Adjust focus radius 
  SetFocusRadius(visible_radius);

  // Adjust surfel size based on visible radius
  if ((TargetResolution() > 0) && (visible_radius > 0)) {
    RNLength window_width = viewer.Viewport().Width();
    RNLength npixels = window_width / (visible_radius * TargetResolution());
    SetSurfelSize(npixels);
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpl $0x0, 0x460(%rdi)
je 0x2e1b6
movq %rdi, %rbx
movsd 0x4e8(%rdi), %xmm0
ucomisd 0x10a29f(%rip), %xmm0   # 0x1383c0
jbe 0x2e12d
movsd 0x10a22d(%rip), %xmm0   # 0x138358
jmp 0x2e143
movsd 0x10a29b(%rip), %xmm1   # 0x1383d0
ucomisd %xmm0, %xmm1
jbe 0x2e157
movsd 0x10a285(%rip), %xmm0   # 0x1383c8
mulsd 0x468(%rbx), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x1c8(%rax)
movsd 0x90(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x1d0(%rax)
movsd 0x8(%rsp), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x2e1b6
movsd 0x468(%rbx), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2e1b6
xorps %xmm0, %xmm0
cvtsi2sdl 0x118(%rbx), %xmm0
mulsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movq (%rbx), %rax
movq 0x98(%rax), %rax
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmpq *%rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawSurfels(gaps::R3SurfelNode*, gaps::RNFlags) const
void R3SurfelViewer::
DrawSurfels(R3SurfelNode *node, RNFlags color_draw_flags) const
{
  // Check node
  if (!NodeVisibility(node)) return;

  // Draw all blocks
  for (int i = 0; i < node->NBlocks(); i++) {
    R3SurfelBlock *block = node->Block(i);
    block->Draw(shape_draw_flags | color_draw_flags, subsampling_factor);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2ce66
testl %eax, %eax
je 0x2e20a
cmpl $0x0, 0x4c(%r14)
jle 0x2e20a
xorl %r12d, %r12d
movq 0x40(%r14), %rax
movq (%rax,%r12,8), %rdi
movq 0x458(%r15), %rsi
orq %rbx, %rsi
movl 0x48c(%r15), %edx
callq 0x37b40
incq %r12
movslq 0x4c(%r14), %rax
cmpq %rax, %r12
jl 0x2e1e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawObjectProperties(int) const
void R3SurfelViewer::
DrawObjectProperties(int property_type) const
{
  // Check stuff
  if (!scene) return;
  
  // Draw object properties
  for (int i = 0; i < scene->NObjectProperties(); i++) {
    R3SurfelObjectProperty *property = scene->ObjectProperty(i);
    if (property->Type() != property_type) continue;
    R3SurfelObject *object = property->Object();
    if (!object->Parent()) continue;
    if (object->Parent() != scene->RootObject()) continue;
    if (!ObjectVisibility(object)) continue;
    if (!object->HasSurfels(TRUE)) continue;
    if ((surfel_color_scheme == R3_SURFEL_VIEWER_COLOR_BY_OBJECT) ||
        (surfel_color_scheme == R3_SURFEL_VIEWER_COLOR_BY_CURRENT_LABEL) ||
        (surfel_color_scheme == R3_SURFEL_VIEWER_COLOR_BY_OBJECT_ATTRIBUTES)) {
      unsigned char color[3];
      CreateColor(color, surfel_color_scheme, NULL, NULL, NULL, object, NULL);
      color[0] += 0.5 * (255 - color[0]);
      color[1] += 0.5 * (255 - color[1]);
      color[2] += 0.5 * (255 - color[2]);
      RNLoadRgb(color);
    }
    property->Draw(0);
  }
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2ed8d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x3c(%rax)
jle 0x2ed7f
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x5(%rsp), %r15
movq 0x30(%rax), %rcx
movq (%rcx,%rbp,8), %r12
cmpl %ebx, 0x2c(%r12)
jne 0x2ec74
movq 0x18(%r12), %r13
movq 0x18(%r13), %rcx
testq %rcx, %rcx
je 0x2ec74
movq 0x10(%rax), %rax
cmpq (%rax), %rcx
je 0x2ec89
incq %rbp
movq 0x8(%r14), %rax
movslq 0x3c(%rax), %rcx
cmpq %rcx, %rbp
jl 0x2ec4e
jmp 0x2ed7f
movq %r14, %rdi
movq %r13, %rsi
callq 0x2cdfa
testl %eax, %eax
je 0x2ec74
movq %r13, %rdi
movl $0x1, %esi
callq 0x46e54
testl %eax, %eax
je 0x2ec74
movl 0x360(%r14), %edx
cmpl $0xd, %edx
ja 0x2ed6e
movl $0x2120, %eax           # imm = 0x2120
btl %edx, %eax
jae 0x2ed6e
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
pushq %r13
callq *0x210(%rax)
addq $0x10, %rsp
movzbl 0x5(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
notb %al
movzbl %al, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd 0x10930a(%rip), %xmm2   # 0x138010
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movb %al, 0x5(%rsp)
movzbl 0x6(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
notb %al
movzbl %al, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movb %al, 0x6(%rsp)
movzbl 0x7(%rsp), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
notb %al
movzbl %al, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movb %al, 0x7(%rsp)
movq %r15, %rdi
callq 0x27c00
movq (%r12), %rax
movq %r12, %rdi
xorl %esi, %esi
callq *0x10(%rax)
jmp 0x2ec74
addq $0x8, %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/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawObjectPrincipalAxes() const
void R3SurfelViewer::
DrawObjectPrincipalAxes(void) const
{
  // Check stuff
  if (!object_principal_axes_visibility) return;
  
  // Draw object principal axes
  glDisable(GL_LIGHTING);
  RNLoadRgb(object_principal_axes_color);
  DrawObjectProperties(R3_SURFEL_OBJECT_PCA_PROPERTY);
}

// Assembly:
cmpl $0x0, 0x308(%rdi)
je 0x2edd7
pushq %rbx
movq %rdi, %rbx
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x398(%rbx), %xmm0
movsd 0x3a0(%rbx), %xmm1
movsd 0x3a8(%rbx), %xmm2
callq 0x27ed0
movq (%rbx), %rax
movq 0x368(%rax), %rax
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmpq *%rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawObjectOrientedBBoxes() const
void R3SurfelViewer::
DrawObjectOrientedBBoxes(void) const
{
  // Check stuff
  if (!object_oriented_bbox_visibility) return;

  // Draw object oriented boxes
  glLineWidth(2);
  glDisable(GL_LIGHTING);
  RNLoadRgb(object_oriented_bbox_color);
  DrawObjectProperties(R3_SURFEL_OBJECT_AMODAL_OBB_PROPERTY);
  glLineWidth(1);
}

// Assembly:
cmpl $0x0, 0x30c(%rdi)
je 0x2ee38
pushq %rbx
movq %rdi, %rbx
movss 0x109757(%rip), %xmm0   # 0x138544
callq 0x281a0
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x3b0(%rbx), %xmm0
movsd 0x3b8(%rbx), %xmm1
movsd 0x3c0(%rbx), %xmm2
callq 0x27ed0
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x2, %esi
callq *0x368(%rax)
movss 0x10920e(%rip), %xmm0   # 0x138040
popq %rbx
jmp 0x281a0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawObjectRelationships() const
void R3SurfelViewer::
DrawObjectRelationships(void) const
{
  // Check stuff
  if (!scene) return;
  if (!object_relationship_visibility) return;
  
  // Draw object relationships
  glDisable(GL_LIGHTING);
  RNLoadRgb(1.0, 1.0, 1.0);
  for (int i = 0; i < scene->NObjectRelationships(); i++) {
    R3SurfelObjectRelationship *relationship = scene->ObjectRelationship(i);
    relationship->Draw();
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2eea5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x310(%rdi)
je 0x2ee9e
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x1091a5(%rip), %xmm0   # 0x138008
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x27ed0
movq 0x8(%rbx), %rax
cmpl $0x0, 0x5c(%rax)
jle 0x2ee9e
xorl %r14d, %r14d
movq 0x50(%rax), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x10(%rax)
incq %r14
movq 0x8(%rbx), %rax
movslq 0x5c(%rax), %rcx
cmpq %rcx, %r14
jl 0x2ee7b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawObjectBBoxes() const
void R3SurfelViewer::
DrawObjectBBoxes(void) const
{
  // Check stuff
  if (!scene) return;
  if (!object_bbox_visibility) return;
  
  // Draw node bounding boxes
  glDisable(GL_LIGHTING);
  RNLoadRgb(object_bbox_color);
  for (int i = 0; i < scene->NObjects(); i++) {
    R3SurfelObject *object = scene->Object(i);
    if (!object->Parent()) continue;
    if (object->Parent() != scene->RootObject()) continue;
    if ((object->NParts() == 0) && (object->NNodes() == 0)) continue;    
    object->BBox().Outline();
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2ef44
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x314(%rdi)
je 0x2ef3d
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x3c8(%rbx), %xmm0
movsd 0x3d0(%rbx), %xmm1
movsd 0x3d8(%rbx), %xmm2
callq 0x27ed0
movq 0x8(%rbx), %rax
cmpl $0x0, 0x1c(%rax)
jle 0x2ef3d
xorl %r14d, %r14d
movq 0x10(%rax), %rcx
movq (%rcx,%r14,8), %rdi
movq 0x18(%rdi), %rdx
testq %rdx, %rdx
je 0x2ef31
cmpq (%rcx), %rdx
jne 0x2ef31
cmpl $0x0, 0x2c(%rdi)
jne 0x2ef17
cmpl $0x0, 0x6c(%rdi)
je 0x2ef31
callq 0x46944
movq (%rax), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq *0xb0(%rcx)
movq 0x8(%rbx), %rax
incq %r14
movslq 0x1c(%rax), %rcx
cmpq %rcx, %r14
jl 0x2eef5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawNodeBBoxes() const
void R3SurfelViewer::
DrawNodeBBoxes(void) const
{
  // Check stuff
  if (!scene) return;
  if (!node_bbox_visibility) return;
  
  // Draw node bounding boxes
  glDisable(GL_LIGHTING);
  RNLoadRgb(node_bbox_color);
  for (int i = 0; i < resident_nodes.NNodes(); i++) {
    R3SurfelNode *node = resident_nodes.Node(i);
    if (node->NParts() > 0) RNLoadRgb(0, 1, 0);
    else RNLoadRgb(1, 0, 0);
    node->BBox().Outline();
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2eff2
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x318(%rdi)
je 0x2efed
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x3e0(%rbx), %xmm0
movsd 0x3e8(%rbx), %xmm1
movsd 0x3f0(%rbx), %xmm2
callq 0x27ed0
cmpl $0x0, 0x24(%rbx)
jle 0x2efed
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %r14
cmpl $0x0, 0x3c(%r14)
jle 0x2efb5
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
movss 0x10908d(%rip), %xmm1   # 0x138040
jmp 0x2efc3
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movss 0x10907d(%rip), %xmm0   # 0x138040
callq 0x28350
movq %r14, %rdi
callq 0x4003c
movq (%rax), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq *0xb0(%rcx)
incq %r15
movslq 0x24(%rbx), %rax
cmpq %rax, %r15
jl 0x2ef96
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawBlockBBoxes() const
void R3SurfelViewer::
DrawBlockBBoxes(void) const
{
  // Check stuff
  if (!scene) return;
  if (!block_bbox_visibility) return;

  // Draw block bounding boxes
  glDisable(GL_LIGHTING);
  RNLoadRgb(block_bbox_color);
  for (int i = 0; i < resident_nodes.NNodes(); i++) {
    R3SurfelNode *node = resident_nodes.Node(i);
    for (int j = 0; j < node->NBlocks(); j++) {
      R3SurfelBlock *block = node->Block(j);
      block->BBox().Outline();
    }
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x2f099
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x31c(%rdi)
je 0x2f08e
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movsd 0x3f8(%rbx), %xmm0
movsd 0x400(%rbx), %xmm1
movsd 0x408(%rbx), %xmm2
callq 0x27ed0
movl 0x24(%rbx), %eax
testl %eax, %eax
jle 0x2f08e
xorl %r14d, %r14d
movq 0x18(%rbx), %rcx
movq (%rcx,%r14,8), %r15
cmpl $0x0, 0x4c(%r15)
jle 0x2f083
xorl %r12d, %r12d
movq 0x40(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x3650a
movq (%rax), %rcx
movl $0x1, %esi
movq %rax, %rdi
callq *0xb0(%rcx)
incq %r12
movslq 0x4c(%r15), %rax
cmpq %rax, %r12
jl 0x2f056
movl 0x24(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x2f044
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawCenterPoint() const
void R3SurfelViewer::
DrawCenterPoint(void) const
{
  // Check stuff
  if (!center_point_visibility) return;
  
  // Draw center point
  glEnable(GL_LIGHTING);
  RNLoadRgb(center_point_color);
  R3Sphere(center_point, 0.1).Draw();
  glDisable(GL_LIGHTING);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x334(%rdi)
je 0x2f110
movq %rdi, %rbx
movl $0xb50, %edi            # imm = 0xB50
callq 0x27860
movsd 0x440(%rbx), %xmm0
movsd 0x448(%rbx), %xmm1
movsd 0x450(%rbx), %xmm2
callq 0x27ed0
addq $0x2b0, %rbx            # imm = 0x2B0
movq %rsp, %r14
movsd 0x10926a(%rip), %xmm0   # 0x138350
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaad4e
movl $0x772, %esi            # imm = 0x772
movq %r14, %rdi
callq 0x80f66
movq %rsp, %rdi
callq 0xae0e4
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xae0e4
movq %rbx, %rdi
callq 0x28120
nop
// File: /workspace/github_cpp_makefile_star2_O3/tomfunkhouser[P]gaps/pkgs/R3Utils/R3SurfelViewer.cpp
// Function: gaps::R3SurfelViewer::DrawSelectedPoint() const
void R3SurfelViewer::
DrawSelectedPoint(void) const
{
  // Check stuff
  if (!selected_point) return;
  // if (!selected_point_visibility) return;

  // Draw selected point
  glEnable(GL_LIGHTING);
  RNLoadRgb(RNred_rgb);
  R3Sphere(selected_point->Position(), 0.05).Draw();
  glDisable(GL_LIGHTING);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x2c8(%rdi)
je 0x2f1e2
movq %rdi, %rbx
movl $0xb50, %edi            # imm = 0xB50
callq 0x27860
leaq 0x18df83(%rip), %rax    # 0x1bd0d8
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm2
callq 0x27ed0
movq 0x2c8(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax), %xmm0
addsd 0x10(%rcx), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rax), %xmm1
addsd 0x18(%rcx), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rax), %xmm2
addsd 0x20(%rcx), %xmm2
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0xc3d32
leaq 0x8(%rsp), %r14
movsd 0x10920a(%rip), %xmm0   # 0x1383c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaad4e
movl $0x772, %esi            # imm = 0x772
movq %r14, %rdi
callq 0x80f66
leaq 0x8(%rsp), %rdi
callq 0xae0e4
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xae0e4
movq %rbx, %rdi
callq 0x28120
nop