LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/rachit31[P]CubeSatADCS/threadManager.cpp
// Function: ThreadManager::cancel(unsigned int)
const char* ThreadManager::cancel(const unsigned int id)
{
  std::stringstream error;
  int retVal;

  if (!m_threadMap.count(id))
  {
    error << "thread id " << id << " does not exist";
    return error.str().c_str();
  }

  // Cancel the thread (TLPI pg 671)
  retVal = pthread_cancel(m_threadMap[id]->getThread());
  if (retVal != 0)
  {
    error << "pthread_cancel(): " << std::strerror(retVal);
    return error.str().c_str();
  }

  return error.str().c_str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
movl %esi, -0x14(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x2180
movq 0x18(%rbx), %rdx
leaq 0x10(%rbx), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x51cb
movl -0x14(%rbp), %esi
movq %rax, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x51b4
movq %rax, %rdx
cmpq %rax, %rcx
je 0x51e0
movl -0x14(%rbp), %edx
cmpl 0x20(%rcx), %edx
cmovbq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x5253
addq $0x8, %rbx
leaq -0x14(%rbp), %rsi
movq %rbx, %rdi
callq 0x539a
movq (%rax), %rdi
callq 0x5aa8
movq %rax, %rdi
callq 0x22b0
movl %eax, %r14d
testl %eax, %eax
je 0x529f
leaq -0x1b0(%rbp), %rbx
leaq 0x3169(%rip), %rsi      # 0x8387
movl $0x12, %edx
movq %rbx, %rdi
callq 0x2290
movl %r14d, %edi
callq 0x20d0
testq %rax, %rax
je 0x52b1
movq %rax, %r14
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2290
jmp 0x52d1
leaq -0x1b0(%rbp), %rbx
leaq 0x310b(%rip), %rsi      # 0x836c
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2290
movl -0x14(%rbp), %esi
movq %rbx, %rdi
callq 0x2150
leaq 0x30f7(%rip), %rsi      # 0x8377
movl $0xf, %edx
movq %rax, %rdi
callq 0x2290
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2330
jmp 0x52e1
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2330
jmp 0x52e1
movq -0x1b0(%rbp), %rax
movq -0x18(%rax), %rax
addq %rax, %rbx
movl -0x190(%rbp,%rax), %esi
orl $0x1, %esi
movq %rbx, %rdi
callq 0x2370
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2330
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rbx
cmpq %rax, %rbx
je 0x52fd
movq -0x28(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x2270
movq 0x5cb4(%rip), %rsi      # 0xafb8
leaq -0x1c0(%rbp), %rdi
callq 0x21c0
leaq -0x140(%rbp), %rdi
callq 0x20c0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x5331
jmp 0x5331
jmp 0x5331
movq %rax, %rbx
movq 0x5c7d(%rip), %rsi      # 0xafb8
leaq -0x1c0(%rbp), %rdi
callq 0x21c0
leaq -0x140(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/rachit31[P]CubeSatADCS/thread.cpp
// Function: Thread::Thread(void* (*)(void*), ThreadManager*, unsigned int)
Thread::Thread(void *(*function)(void *),
               ThreadManager* pManager,
               const unsigned int id) :
m_alive(true), m_pManager(pManager), m_id(id)
{
  int retVal;

  // Create pthread (TLPI pg 622)
  retVal = pthread_create(&m_pthread, NULL, function, this);
  if (retVal != 0)
  {
    std::stringstream error;
    error << "pthread_create(): " << std::strerror(retVal);
    throw error.str().c_str();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %rax
movq %rdi, %r8
movl %ecx, (%rdi)
movb $0x1, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
addq $0x8, %rdi
xorl %esi, %esi
movq %rax, %rdx
movq %r8, %rcx
callq 0x23d0
testl %eax, %eax
jne 0x59cb
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %ebx
leaq -0x1b8(%rbp), %rdi
callq 0x2180
leaq -0x1a8(%rbp), %r14
leaq 0x29f8(%rip), %rsi      # 0x83df
movl $0x12, %edx
movq %r14, %rdi
callq 0x2290
movl %ebx, %edi
callq 0x20d0
movq %r14, %rdi
movq %rax, %rsi
callq 0x2250
movl $0x8, %edi
callq 0x2110
movq %rax, %rbx
leaq -0x1a0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2330
movq -0x30(%rbp), %rax
movq %rax, (%rbx)
movq 0x5597(%rip), %rsi      # 0xafc8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2380
movq %rax, %r14
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a57
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2270
xorl %eax, %eax
jmp 0x5a60
movq %rax, %r14
movb $0x1, %al
testb %al, %al
je 0x5a71
movq %rbx, %rdi
callq 0x21a0
jmp 0x5a71
movq %rax, %r14
movq 0x5540(%rip), %rsi      # 0xafb8
leaq -0x1b8(%rbp), %rdi
callq 0x21c0
leaq -0x138(%rbp), %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/rachit31[P]CubeSatADCS/thread.cpp
// Function: Thread::threadCleanup()
void Thread::threadCleanup()
{
  // Get the mutex from the threadManager
  Mutex* pMutex = m_pManager->getMutex();

  // Lock the mutex
  pMutex->lock();

  // Mark this thread as dead
  m_alive = false;

  // Increment the managers join variable
  m_pManager->incrementJoin();

  // Unlock the mutex
  pMutex->unlock();

  // Signal the thread conditional variable
  pMutex->signal();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x5174
movq %rax, %r14
movq %rax, %rdi
callq 0x3722
movb $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
callq 0x516c
movq %r14, %rdi
callq 0x3850
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3b40
nop
// File: /workspace/github_cpp_makefile_star2_O1/rachit31[P]CubeSatADCS/propagateANDupdate.cpp
// Function: X(double const (&) [3], double (&) [3][3])
void X(const double (&v)[3], double (&vX)[3][3])
{
  vX[0][0] = 0;
  vX[0][1] = -v[2];
  vX[0][2] = v[1];
  vX[1][0] = v[2];
  vX[1][1] = 0;
  vX[1][2] = -v[0];
  vX[2][0] = -v[1];
  vX[2][1] = v[0];
  vX[2][2] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rax, (%rsi)
movsd 0x10(%rdi), %xmm0
movaps 0x10c7(%rip), %xmm1     # 0x8450
xorps %xmm1, %xmm0
movlps %xmm0, 0x8(%rsi)
movsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x10(%rsi)
movsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x18(%rsi)
movq %rax, 0x20(%rsi)
movsd (%rdi), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, 0x28(%rsi)
movsd 0x8(%rdi), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, 0x30(%rsi)
movsd (%rdi), %xmm0
movsd %xmm0, 0x38(%rsi)
movq %rax, 0x40(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rachit31[P]CubeSatADCS/propagateANDupdate.cpp
// Function: mult3x3(double const (&) [3][3], double const (&) [3][3], double (&) [3][3])
void mult3x3(const double (&A)[3][3], const double (&B)[3][3], double (&C)[3][3])
{
  for (int i = 0; i < 3; i++)
  {
    for (int j = 0; j < 3; j++)
    {
      C[i][j] = 0;

      for (int k = 0; k < 3; k++)
      {
        C[i][j] += A[i][k]*B[k][j];
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
xorl %eax, %eax
leaq (%rax,%rax,2), %rcx
leaq (%rdx,%rcx,8), %rcx
movq %rsi, %r8
xorl %r9d, %r9d
leaq (%rcx,%r9,8), %r10
movq $0x0, (%r10)
xorpd %xmm0, %xmm0
movq %r8, %r11
xorl %ebx, %ebx
movsd (%rdi,%rbx,8), %xmm1
mulsd (%r11), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%r10)
incq %rbx
addq $0x18, %r11
cmpq $0x3, %rbx
jne 0x7429
incq %r9
addq $0x8, %r8
cmpq $0x3, %r9
jne 0x7415
incq %rax
addq $0x18, %rdi
cmpq $0x3, %rax
jne 0x7407
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rachit31[P]CubeSatADCS/propagateANDupdate.cpp
// Function: mult6x6(double const (&) [6][6], double const (&) [6][6], double (&) [6][6])
void mult6x6(const double (&A)[6][6], const double (&B)[6][6], double (&C)[6][6])
{
  for (int i = 0; i < 6; i++)
  {
    for (int j = 0; j < 6; j++)
    {
      C[i][j] = 0;

      for (int k = 0; k < 6; k++)
      {
        C[i][j] += A[i][k]*B[k][j];
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
xorl %eax, %eax
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
addq %rdx, %rcx
movq %rsi, %r8
xorl %r9d, %r9d
leaq (%rcx,%r9,8), %r10
movq $0x0, (%r10)
xorpd %xmm0, %xmm0
movq %r8, %r11
xorl %ebx, %ebx
movsd (%rdi,%rbx,8), %xmm1
mulsd (%r11), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%r10)
incq %rbx
addq $0x30, %r11
cmpq $0x6, %rbx
jne 0x74fd
incq %r9
addq $0x8, %r8
cmpq $0x6, %r9
jne 0x74e9
incq %rax
addq $0x30, %rdi
cmpq $0x6, %rax
jne 0x74d8
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rachit31[P]CubeSatADCS/propagateANDupdate.cpp
// Function: q2A(double const (&) [4], double (&) [3][3])
void q2A(const double (&q)[4], double (&A)[3][3])
{
  A[0][0] = q[0]*q[0] - q[2]*q[2] - q[3]*q[3] + q[1]*q[1];
  A[0][1] = 2.0*q[0]*q[3] + 2.0*q[1]*q[2];
  A[0][2] = 2.0*q[1]*q[3] - 2.0*q[0]*q[2];
  A[1][0] = 2.0*q[1]*q[2] - 2.0*q[0]*q[3];
  A[1][1] = q[0]*q[0] + q[2]*q[2] - q[3]*q[3] - q[1]*q[1];
  A[1][2] = 2.0*q[0]*q[1] + 2.0*q[2]*q[3];
  A[2][0] = 2.0*q[0]*q[2] + 2.0*q[1]*q[3];
  A[2][1] = 2.0*q[2]*q[3] - 2.0*q[0]*q[1];
  A[2][2] = q[0]*q[0] - q[2]*q[2] + q[3]*q[3] - q[1]*q[1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd 0x10(%rdi), %xmm0
mulsd %xmm0, %xmm0
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm2
mulsd %xmm1, %xmm1
subsd %xmm0, %xmm1
movsd 0x18(%rdi), %xmm0
mulsd %xmm0, %xmm0
subsd %xmm0, %xmm1
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rsi)
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
addsd %xmm1, %xmm1
mulsd 0x10(%rdi), %xmm1
addsd %xmm0, %xmm0
mulsd 0x18(%rdi), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsi)
movsd 0x8(%rdi), %xmm1
addsd %xmm1, %xmm1
movsd 0xe31(%rip), %xmm0      # 0x8440
movsd (%rdi), %xmm2
mulsd %xmm0, %xmm2
mulsd 0x10(%rdi), %xmm2
mulsd 0x18(%rdi), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x10(%rsi)
movsd 0x8(%rdi), %xmm1
addsd %xmm1, %xmm1
movsd (%rdi), %xmm2
mulsd %xmm0, %xmm2
mulsd 0x18(%rdi), %xmm2
mulsd 0x10(%rdi), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x18(%rsi)
movsd 0x10(%rdi), %xmm1
mulsd %xmm1, %xmm1
movsd (%rdi), %xmm2
movsd 0x8(%rdi), %xmm3
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
movsd 0x18(%rdi), %xmm1
mulsd %xmm1, %xmm1
subsd %xmm1, %xmm2
mulsd %xmm3, %xmm3
subsd %xmm3, %xmm2
movsd %xmm2, 0x20(%rsi)
movsd (%rdi), %xmm1
movsd 0x10(%rdi), %xmm2
addsd %xmm1, %xmm1
addsd %xmm2, %xmm2
mulsd 0x18(%rdi), %xmm2
mulsd 0x8(%rdi), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x28(%rsi)
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm2
addsd %xmm1, %xmm1
addsd %xmm2, %xmm2
mulsd 0x18(%rdi), %xmm2
mulsd 0x10(%rdi), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x30(%rsi)
movsd 0x10(%rdi), %xmm1
addsd %xmm1, %xmm1
mulsd (%rdi), %xmm0
mulsd 0x8(%rdi), %xmm0
mulsd 0x18(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x38(%rsi)
movsd 0x10(%rdi), %xmm0
mulsd %xmm0, %xmm0
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm2
mulsd %xmm1, %xmm1
subsd %xmm0, %xmm1
movsd 0x18(%rdi), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, 0x40(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rachit31[P]CubeSatADCS/propagateANDupdate.cpp
// Function: inv3x3(double const (&) [3][3], double (&) [3][3])
void inv3x3(const double (&A)[3][3], double (&B)[3][3])
{
  const double det = A[0][0]*A[1][1]*A[2][2] - A[0][0]*A[1][2]*A[2][1] - A[0][1]*A[1][0]*A[2][2] +
                     A[0][1]*A[1][2]*A[2][0] + A[0][2]*A[1][0]*A[2][1] - A[0][2]*A[1][1]*A[2][0];

  B[0][0] = (A[1][1]*A[2][2] - A[1][2]*A[2][1])/det;
  B[0][1] = -(A[0][1]*A[2][2] - A[0][2]*A[2][1])/det;
  B[0][2] = (A[0][1]*A[1][2] - A[0][2]*A[1][1])/det;
  B[1][0] = -(A[1][0]*A[2][2] - A[1][2]*A[2][0])/det;
  B[1][1] = (A[0][0]*A[2][2] - A[0][2]*A[2][0])/det;
  B[1][2] = -(A[0][0]*A[1][2] - A[0][2]*A[1][0])/det;
  B[2][0] = (A[1][0]*A[2][1] - A[1][1]*A[2][0])/det;
  B[2][1] = -(A[0][0]*A[2][1] - A[0][1]*A[2][0])/det;
  B[2][2] = (A[0][0]*A[1][1] - A[0][1]*A[1][0])/det;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd 0x20(%rdi), %xmm1
movsd (%rdi), %xmm6
movsd 0x8(%rdi), %xmm5
movsd 0x40(%rdi), %xmm2
movsd 0x28(%rdi), %xmm4
movsd 0x38(%rdi), %xmm3
movapd %xmm4, %xmm0
mulsd %xmm6, %xmm0
mulsd %xmm1, %xmm6
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm6
subsd %xmm0, %xmm6
movsd 0x18(%rdi), %xmm0
movapd %xmm0, %xmm7
mulsd %xmm5, %xmm7
mulsd %xmm2, %xmm7
subsd %xmm7, %xmm6
mulsd %xmm4, %xmm5
movsd 0x30(%rdi), %xmm7
mulsd %xmm7, %xmm5
addsd %xmm6, %xmm5
movsd 0x10(%rdi), %xmm6
mulsd %xmm6, %xmm0
mulsd %xmm3, %xmm0
addsd %xmm5, %xmm0
mulsd %xmm1, %xmm6
mulsd %xmm7, %xmm6
subsd %xmm6, %xmm0
mulsd %xmm4, %xmm3
mulsd %xmm2, %xmm1
subsd %xmm3, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi)
movsd 0x8(%rdi), %xmm2
movsd 0x38(%rdi), %xmm1
mulsd 0x10(%rdi), %xmm1
mulsd 0x40(%rdi), %xmm2
subsd %xmm1, %xmm2
movapd 0xbca(%rip), %xmm1      # 0x8450
xorpd %xmm1, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsi)
movsd 0x8(%rdi), %xmm2
movsd 0x20(%rdi), %xmm3
mulsd 0x10(%rdi), %xmm3
mulsd 0x28(%rdi), %xmm2
subsd %xmm3, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsi)
movsd 0x18(%rdi), %xmm2
movsd 0x30(%rdi), %xmm3
mulsd 0x28(%rdi), %xmm3
mulsd 0x40(%rdi), %xmm2
subsd %xmm3, %xmm2
xorpd %xmm1, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x18(%rsi)
movsd (%rdi), %xmm2
movsd 0x30(%rdi), %xmm3
mulsd 0x10(%rdi), %xmm3
mulsd 0x40(%rdi), %xmm2
subsd %xmm3, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x20(%rsi)
movsd (%rdi), %xmm2
movsd 0x18(%rdi), %xmm3
mulsd 0x10(%rdi), %xmm3
mulsd 0x28(%rdi), %xmm2
subsd %xmm3, %xmm2
xorpd %xmm1, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x28(%rsi)
movsd 0x18(%rdi), %xmm2
movsd 0x30(%rdi), %xmm3
mulsd 0x20(%rdi), %xmm3
mulsd 0x38(%rdi), %xmm2
subsd %xmm3, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x30(%rsi)
movsd (%rdi), %xmm2
movsd 0x30(%rdi), %xmm3
mulsd 0x8(%rdi), %xmm3
mulsd 0x38(%rdi), %xmm2
subsd %xmm3, %xmm2
xorpd %xmm1, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x38(%rsi)
movsd (%rdi), %xmm1
movsd 0x18(%rdi), %xmm2
mulsd 0x8(%rdi), %xmm2
mulsd 0x20(%rdi), %xmm1
subsd %xmm2, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/rabinkarp.c
// Function: mpow
int mpow(int base, int n)
{
	int result = 1;
	for(int i = 0; i < n; i++)
	{
		result *= base;
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
testl %esi, %esi
jle 0x11d0
imull %edi, %eax
decl %esi
jne 0x11c9
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/rabinkarp.c
// Function: rk_hash
unsigned int rk_hash(unsigned char *data, unsigned int length)
{
	unsigned int hash = 0;
	for(int i = 0; i < length; i++)
	{
		hash += ((int)(data[i] * mpow(BASE_RK, length - i - 1))) % MOD_RK;
	}

	return hash % MOD_RK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
je 0x1264
movl %esi, %ecx
leal -0x1(%rsi), %edx
xorl %r8d, %r8d
xorl %eax, %eax
movl %r8d, %r9d
notl %r9d
addl %esi, %r9d
testl %r9d, %r9d
jle 0x120a
movl $0x1, %r9d
movl %edx, %r10d
shll $0x8, %r9d
decl %r10d
jne 0x11ff
jmp 0x1210
movl $0x1, %r9d
movzbl (%rdi,%r8), %r10d
imull %r9d, %r10d
movslq %r10d, %r9
imulq $0x288df0cb, %r9, %r10  # imm = 0x288DF0CB
movq %r10, %r11
shrq $0x3f, %r11
sarq $0x24, %r10
addl %r11d, %r10d
imull $0x65, %r10d, %r10d
subl %r10d, %r9d
addl %r9d, %eax
incq %r8
decl %edx
cmpq %rcx, %r8
jne 0x11e8
movl %eax, %ecx
imulq $0x446f8657, %rcx, %rcx # imm = 0x446F8657
shrq $0x20, %rcx
movl %eax, %edx
subl %ecx, %edx
shrl %edx
addl %ecx, %edx
shrl $0x6, %edx
imull $0x65, %edx, %ecx
subl %ecx, %eax
jmp 0x1266
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/rabinkarp.c
// Function: main
int main(int argc, char** argv)
{
	if (argc < 2)
	{
		printf("Usage: rabinkarp file\r\n");
		return -1;
	}

	unsigned int length = 0;
	char *data = get_file(argv[1], &length);
	if (data == NULL)
	{
		printf("Unable to open %s\r\n", argv[1]);
	}
	
	unsigned int hash = 0;
	hash = rk_hash((unsigned char *)data, length);
	printf("%08X\r\n", hash);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %edi
jg 0x1381
leaq 0xcad(%rip), %rdi       # 0x2022
callq 0x1040
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x13ce
movq %rsi, %rbx
leaq -0x14(%rbp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rbx), %rdi
callq 0x12ac
movq %rax, %r14
testq %rax, %rax
jne 0x13b1
movq 0x8(%rbx), %rsi
leaq 0xc5d(%rip), %rdi       # 0x2007
xorl %eax, %eax
callq 0x1070
movl -0x14(%rbp), %esi
movq %r14, %rdi
callq 0x11d2
leaq 0xc58(%rip), %rdi       # 0x201b
xorl %ebx, %ebx
movl %eax, %esi
xorl %eax, %eax
callq 0x1070
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannye[P]jed/src/encoder.cpp
// Function: getInt(std::basic_ifstream<char, std::char_traits<char>>&)
uint getInt(std::ifstream& inFile) {
    return (inFile.get() <<  0)
         + (inFile.get() <<  8)
         + (inFile.get() << 16)
         + (inFile.get() << 24);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2130
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2130
movl %eax, %r14d
shll $0x8, %r14d
addl %ebp, %r14d
movq %rbx, %rdi
callq 0x2130
movl %eax, %ebp
shll $0x10, %ebp
movq %rbx, %rdi
callq 0x2130
shll $0x18, %eax
addl %ebp, %eax
addl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannye[P]jed/src/encoder.cpp
// Function: forwardDCT(BMPImage const&)
void forwardDCT(const BMPImage& image) {
    for (uint y = 0; y < image.blockHeight; ++y) {
        for (uint x = 0; x < image.blockWidth; ++x) {
            for (uint i = 0; i < 3; ++i) {
                forwardDCTBlockComponent(image.blocks[y * image.blockWidth + x][i]);
            }
        }
    }
}

// Assembly:
cmpl $0x0, 0x10(%rdi)
je 0x30ca
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpl $0x0, 0x14(%rbx)
je 0x30b7
xorl %ebp, %ebp
xorl %r15d, %r15d
movl 0x14(%rbx), %eax
imull %r14d, %eax
addl %ebp, %eax
leaq (%rax,%rax,2), %rdi
shlq $0x8, %rdi
addq 0x8(%rbx), %rdi
testl %r15d, %r15d
je 0x30a2
cmpl $0x2, %r15d
je 0x3097
cmpl $0x1, %r15d
jne 0x30a0
addq $0x100, %rdi            # imm = 0x100
jmp 0x30a2
addq $0x200, %rdi            # imm = 0x200
jmp 0x30a2
xorl %edi, %edi
callq 0x2aab
incl %r15d
cmpl $0x3, %r15d
jne 0x3068
incl %ebp
cmpl 0x14(%rbx), %ebp
jb 0x3065
incl %r14d
cmpl 0x10(%rbx), %r14d
jb 0x305d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannye[P]jed/src/encoder.cpp
// Function: quantize(BMPImage const&)
void quantize(const BMPImage& image) {
    for (uint y = 0; y < image.blockHeight; ++y) {
        for (uint x = 0; x < image.blockWidth; ++x) {
            for (uint i = 0; i < 3; ++i) {
                quantizeBlockComponent(*qTables100[i], image.blocks[y * image.blockWidth + x][i]);
            }
        }
    }
}

// Assembly:
cmpl $0x0, 0x10(%rdi)
je 0x3182
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rcx
xorl %esi, %esi
leaq 0x21e3(%rip), %r8       # 0x52e0
cmpl $0x0, 0x14(%rdi)
je 0x3176
xorl %r9d, %r9d
xorl %r10d, %r10d
movl 0x14(%rdi), %eax
imull %esi, %eax
addl %r9d, %eax
leaq (%rax,%rax,2), %r11
shlq $0x8, %r11
addq %rcx, %r11
testl %r10d, %r10d
je 0x3143
cmpl $0x2, %r10d
je 0x3137
cmpl $0x1, %r10d
jne 0x3140
addq $0x100, %r11            # imm = 0x100
jmp 0x3143
addq $0x200, %r11            # imm = 0x200
jmp 0x3143
xorl %r11d, %r11d
movslq (%r8,%r10,4), %rbx
xorl %r14d, %r14d
leaq (%rbx,%r14,4), %r15
movl (%r11,%r14,4), %eax
cltd
idivl (%r8,%r15)
movl %eax, (%r11,%r14,4)
incq %r14
cmpq $0x40, %r14
jne 0x314a
incq %r10
cmpq $0x3, %r10
jne 0x3109
incl %r9d
cmpl 0x14(%rdi), %r9d
jb 0x3106
incl %esi
cmpl 0x10(%rdi), %esi
jb 0x30fd
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %ecx, %ecx
xorl %eax, %eax
movq %rcx, %rsi
movzbl (%rdi,%rcx), %edx
incq %rcx
cmpb 0x1(%rdi,%rsi), %dl
jae 0x31ac
movl %eax, 0xc4(%rdi,%rdx,4)
incl %eax
incq %rdx
movzbl (%rdi,%rcx), %esi
cmpq %rsi, %rdx
jb 0x3197
addl %eax, %eax
cmpq $0x10, %rcx
jne 0x3187
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31c8
movl %edi, %ecx
shrl %ecx
incl %eax
cmpl $0x1, %edi
movl %ecx, %edi
ja 0x31bd
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movb $0x1, %al
xorl %r8d, %r8d
movq %r8, %r9
movzbl (%rdi,%r8), %r10d
incq %r8
movzbl 0x1(%rdi,%r9), %r11d
cmpb %r11b, %r10b
setb %bl
jae 0x3225
cmpb %sil, 0x11(%rdi,%r10)
jne 0x31f6
movq %r10, %r14
jmp 0x3213
leaq -0x1(%r11), %rbx
cmpq %r10, %rbx
je 0x3225
leaq 0x1(%r10), %r14
cmpb %sil, 0x12(%rdi,%r10)
movq %r14, %r10
jne 0x31fa
cmpq %r11, %r14
setb %bl
movl 0xc4(%rdi,%r14,4), %r10d
movl %r10d, (%rdx)
movl %r8d, (%rcx)
testb %bl, %bl
jne 0x3232
cmpq $0xf, %r9
setb %al
cmpq $0x10, %r8
jne 0x31d1
andb $0x1, %al
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18c4(%rip), %r12      # 0x52f0
movzbl (%r15,%r12), %eax
movsbl (%rbx,%rax,4), %esi
movq %r14, %rdi
callq 0x2030
incq %r15
cmpq $0x40, %r15
jne 0x3a2c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannye[P]jed/src/encoder.cpp
// Function: writeStartOfFrame(std::basic_ofstream<char, std::char_traits<char>>&, BMPImage const&)
void writeStartOfFrame(std::ofstream& outFile, const BMPImage& image) {
    outFile.put(0xFF);
    outFile.put(SOF0);
    putShort(outFile, 17);
    outFile.put(8);
    putShort(outFile, image.height);
    putShort(outFile, image.width);
    outFile.put(3);
    for (uint i = 1; i <= 3; ++i) {
        outFile.put(i);
        outFile.put(0x11);
        outFile.put(i == 1 ? 0 : 1);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2030
movq %rbx, %rdi
movl $0xffffffc0, %esi       # imm = 0xFFFFFFC0
callq 0x2030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x11, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x8, %esi
callq 0x2030
movl (%r14), %ebp
movl %ebp, %eax
shrl $0x8, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x2030
movl 0x4(%r14), %ebp
movl %ebp, %eax
shrl $0x8, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x2030
movq %rbx, %rdi
movl $0x3, %esi
callq 0x2030
movl $0xfffffffd, %r14d      # imm = 0xFFFFFFFD
leal 0x4(%r14), %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rbx, %rdi
movl $0x11, %esi
callq 0x2030
xorl %esi, %esi
cmpl $-0x3, %r14d
setne %sil
movq %rbx, %rdi
callq 0x2030
incl %r14d
jne 0x3ae6
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3b80
xorl %r15d, %r15d
movq %r15, %rax
movzbl (%rbx,%r15), %r12d
incq %r15
cmpb 0x1(%rbx,%rax), %r12b
jae 0x3bcf
movsbl 0x11(%rbx,%r12), %esi
movq %r14, %rdi
callq 0x2030
incq %r12
movzbl (%rbx,%r15), %eax
cmpq %rax, %r12
jb 0x3bb4
cmpq $0x10, %r15
jne 0x3ba2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dannye[P]jed/src/encoder.cpp
// Function: writeStartOfScan(std::basic_ofstream<char, std::char_traits<char>>&)
void writeStartOfScan(std::ofstream& outFile) {
    outFile.put(0xFF);
    outFile.put(SOS);
    putShort(outFile, 12);
    outFile.put(3);
    for (uint i = 1; i <= 3; ++i) {
        outFile.put(i);
        outFile.put(i == 1 ? 0x00 : 0x11);
    }
    outFile.put(0);
    outFile.put(63);
    outFile.put(0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2030
movq %rbx, %rdi
movl $0xffffffda, %esi       # imm = 0xFFFFFFDA
callq 0x2030
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
movq %rbx, %rdi
movl $0xc, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x3, %esi
callq 0x2030
movl $0xfffffffd, %r14d      # imm = 0xFFFFFFFD
leal 0x4(%r14), %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
cmpl $-0x3, %r14d
movl $0x11, %esi
cmovel %ebp, %esi
movq %rbx, %rdi
callq 0x2030
incl %r14d
jne 0x3c28
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x3f, %esi
callq 0x2030
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O1/dannye[P]jed/src/encoder.cpp
// Function: writeAPP0(std::basic_ofstream<char, std::char_traits<char>>&)
void writeAPP0(std::ofstream& outFile) {
    outFile.put(0xFF);
    outFile.put(APP0);
    putShort(outFile, 16);
    outFile.put('J');
    outFile.put('F');
    outFile.put('I');
    outFile.put('F');
    outFile.put(0);
    outFile.put(1);
    outFile.put(2);
    outFile.put(0);
    putShort(outFile, 100);
    putShort(outFile, 100);
    outFile.put(0);
    outFile.put(0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2030
movq %rbx, %rdi
movl $0xffffffe0, %esi       # imm = 0xFFFFFFE0
callq 0x2030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x10, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x4a, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x46, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x49, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x46, %esi
callq 0x2030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x2, %esi
callq 0x2030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x64, %esi
callq 0x2030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
movq %rbx, %rdi
movl $0x64, %esi
callq 0x2030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2030
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpb $0x0, (%rdi)
jne 0x4211
movq 0x8(%rbx), %rdi
movb $0x0, 0x7(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4207
movb $0x0, (%rsi)
incq 0x8(%rdi)
jmp 0x4211
leaq 0x7(%rsp), %rdx
callq 0x4264
andl $0x1, %ebp
movb $0x7, %cl
subb (%rbx), %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 0x425c
movq 0x8(%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpb $-0x1, -0x1(%rsi)
jne 0x425c
movb $0x0, 0x6(%rsp)
cmpq 0x10(%rdi), %rsi
je 0x4252
movb $0x0, (%rsi)
incq 0x8(%rdi)
jmp 0x425c
leaq 0x6(%rsp), %rdx
callq 0x4264
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x199294(%rip), %rdi    # 0x1c4980
testq %rdi, %rdi
je 0x2b6f7
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x19928a(%rip), %rbx    # 0x1c4988
testq %rbx, %rbx
je 0x2b88e
movq %rsp, %r15
movq %r15, %rdi
callq 0xe692c
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x28030
cmpb $0x1, 0x1992a2(%rip)    # 0x1c49c8
jne 0x2b873
leaq 0x10fbdf(%rip), %rdi    # 0x13b312
callq 0x27f20
movq %rsp, %rdi
callq 0xe698e
leaq 0x10f986(%rip), %rdi    # 0x13b0cd
movb $0x1, %al
callq 0x27080
movl 0x1c(%rbx), %esi
leaq 0x10f98c(%rip), %rdi    # 0x13b0e4
xorl %eax, %eax
callq 0x27080
movl 0x2c(%rbx), %esi
leaq 0x10f98d(%rip), %rdi    # 0x13b0f6
xorl %eax, %eax
callq 0x27080
movl 0x7c(%rbx), %esi
leaq 0x10f98d(%rip), %rdi    # 0x13b107
xorl %eax, %eax
callq 0x27080
movl 0xac(%rbx), %esi
leaq 0x10f98f(%rip), %rdi    # 0x13b11d
xorl %eax, %eax
callq 0x27080
movl 0x8c(%rbx), %esi
leaq 0x10f98e(%rip), %rdi    # 0x13b130
xorl %eax, %eax
callq 0x27080
movl 0x9c(%rbx), %esi
leaq 0x10f98a(%rip), %rdi    # 0x13b140
xorl %eax, %eax
callq 0x27080
movq 0x8(%rbx), %rax
movl 0x24(%rax), %esi
leaq 0x10f986(%rip), %rdi    # 0x13b151
xorl %eax, %eax
callq 0x27080
movq 0x8(%rbx), %rcx
movslq 0x24(%rcx), %rax
testq %rax, %rax
jle 0x2b7fa
movq 0x18(%rcx), %rcx
xorl %edx, %edx
xorl %r14d, %r14d
movq (%rcx,%rdx,8), %rsi
movl 0x4c(%rsi), %esi
addq %rsi, %r14
incq %rdx
cmpq %rdx, %rax
jne 0x2b7e8
leaq 0x10f960(%rip), %rdi    # 0x13b161
xorl %r15d, %r15d
movl %r14d, %esi
xorl %eax, %eax
callq 0x27080
movq 0x8(%rbx), %rcx
movslq 0x24(%rcx), %rax
testq %rax, %rax
jle 0x2b853
movq 0x18(%rcx), %rcx
xorl %edx, %edx
xorl %r15d, %r15d
movq (%rcx,%rdx,8), %rdi
movslq 0x4c(%rdi), %rsi
testq %rsi, %rsi
jle 0x2b84b
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 0x2b838
incq %rdx
cmpq %rax, %rdx
jne 0x2b824
leaq 0x10f918(%rip), %rdi    # 0x13b172
movq %r15, %rsi
xorl %eax, %eax
callq 0x27080
movq 0x193635(%rip), %rax    # 0x1beea0
movq (%rax), %rdi
callq 0x27b00
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0xf8(%rax)
testl %eax, %eax
jne 0x2b88e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %edi, %edi
callq 0x27b60
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1990d6(%rip), %rdi    # 0x1c4980
movq (%rdi), %rax
callq *0x20(%rax)
testl %eax, %eax
je 0x2b8b9
callq 0x12dc98
cmpq $0x0, 0x1990ef(%rip)    # 0x1c49b0
je 0x2ba53
cmpl $0x0, 0x19411a(%rip)    # 0x1bf9e8
je 0x2b90a
movl $0xb50, %edi            # imm = 0xB50
callq 0x27860
movsd 0x10f726(%rip), %xmm0   # 0x13b008
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
callq 0x27ee0
movq 0x1990ba(%rip), %rdi    # 0x1c49b0
movl $0x772, %esi            # imm = 0x772
callq 0x63c58
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
cmpl $0x0, 0x19907f(%rip)    # 0x1c4990
je 0x2ba53
movl $0xb50, %edi            # imm = 0xB50
callq 0x27200
movss 0x10f717(%rip), %xmm0   # 0x13b040
movapd %xmm0, %xmm1
movapd %xmm0, %xmm2
callq 0x28360
movq 0x199073(%rip), %rax    # 0x1c49b0
cmpl $0x0, 0x14(%rax)
jle 0x2ba53
xorl %r14d, %r14d
leaq 0x30(%rsp), %rbx
leaq 0x18(%rsp), %r15
movq %rsp, %r12
leaq 0x59d452(%rip), %r13    # 0x5c8db0
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rbp
cmpq $0x0, 0x1a0(%rbp)
je 0x2ba3c
cmpl $0x0, 0x2c(%rbp)
jne 0x2ba3c
movq %rbp, %rdi
callq 0x7718c
movsd 0x8(%rax), %xmm0
ucomisd 0x20(%rax), %xmm0
ja 0x2ba3c
movsd 0x10(%rax), %xmm0
ucomisd 0x28(%rax), %xmm0
ja 0x2ba3c
movsd 0x18(%rax), %xmm0
ucomisd 0x30(%rax), %xmm0
ja 0x2ba3c
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x7734a
movq %rbp, %rdi
callq 0x7718c
movsd 0x30(%rax), %xmm0
subsd 0x18(%rax), %xmm0
mulsd 0x10f635(%rip), %xmm0   # 0x13b010
mulsd 0x10f635(%rip), %xmm0   # 0x13b018
movq %r15, %rdi
leaq 0x1198d3(%rip), %rsi    # 0x1452c0
callq 0xc6786
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xc5669
movq 0x1a0(%rbp), %rbp
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x272c0
movb (%rbp), %al
testb %al, %al
je 0x2ba3c
incq %rbp
movsbl %al, %esi
movq %r13, %rdi
callq 0x12ddc8
movb (%rbp), %al
incq %rbp
testb %al, %al
jne 0x2ba27
incq %r14
movq 0x198f6a(%rip), %rax    # 0x1c49b0
movslq 0x14(%rax), %rcx
cmpq %rcx, %r14
jl 0x2b95e
callq 0x12dce8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x193f6e(%rip)    # 0x1bf9e0
movl %edx, 0x193f6c(%rip)    # 0x1bf9e4
movq 0x198f01(%rip), %rdi    # 0x1c4980
movq (%rdi), %rax
callq *0x28(%rax)
testl %eax, %eax
je 0x2ba8f
popq %rax
jmp 0x12dc98
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x193f1b(%rip), %r14d   # 0x1bf9e4
subl %ecx, %r14d
xorl %r15d, %r15d
testl %esi, %esi
sete %r15b
callq 0x132be0
movl %eax, %r9d
andl $0x1, %r9d
movl %eax, %r10d
andl $0x2, %r10d
andl $0x4, %eax
movq 0x198e8e(%rip), %rdi    # 0x1c4980
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 0x2bb23
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12dc98
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12e93f
movl $0x64, %edi
movl $0x64, %esi
callq 0x12ee8c
movl 0x193b85(%rip), %edi    # 0x1bf9e0
movl 0x193b83(%rip), %esi    # 0x1bf9e4
callq 0x12eea2
movl $0x1a, %edi
callq 0x12eec1
leaq 0x10f248(%rip), %rdi    # 0x13b0bf
callq 0x133e8c
callq 0xe6a14
leaq -0x5f3(%rip), %rdi      # 0x2b895
callq 0x12d394
leaq -0x42d(%rip), %rdi      # 0x2ba67
callq 0x12d3e9
leaq -0x235(%rip), %rdi      # 0x2bc6b
callq 0x12d42b
leaq -0x382(%rip), %rdi      # 0x2bb2a
callq 0x12d473
leaq -0x401(%rip), %rdi      # 0x2bab7
callq 0x12d7bc
leaq -0x433(%rip), %rdi      # 0x2ba91
callq 0x12d84c
leaq -0x7f4(%rip), %rdi      # 0x2b6dc
callq 0x13a650
movq 0x198aa4(%rip), %rdi    # 0x1c4980
movq (%rdi), %rax
popq %rcx
jmpq *0x10(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x198a8e(%rip), %rdi    # 0x1c4980
movq (%rdi), %rax
leaq 0x198a0c(%rip), %rsi    # 0x1c4908
callq *0x168(%rax)
cmpb $0x1, 0x198a8b(%rip)    # 0x1c4994
jne 0x2bf56
leaq 0x198a0e(%rip), %rsi    # 0x1c4920
leaq 0x198a1f(%rip), %rdx    # 0x1c4938
leaq 0x198a30(%rip), %rcx    # 0x1c4950
movq %rsp, %rbx
movsd 0x10f0f5(%rip), %xmm0   # 0x13b020
movsd 0x10f0f5(%rip), %xmm2   # 0x13b028
movsd 0x10f0f5(%rip), %xmm3   # 0x13b030
movq %rbx, %rdi
movaps %xmm0, %xmm1
callq 0x7a6e4
movq 0x198a33(%rip), %rdi    # 0x1c4980
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x58(%rax)
movq %rsp, %rbx
movsd 0x10f0d7(%rip), %xmm0   # 0x13b038
movq %rbx, %rdi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0xc531e
leaq 0x1989f2(%rip), %rdi    # 0x1c4968
movq %rbx, %rsi
callq 0xc5414
testl %eax, %eax
je 0x2bf99
movq 0x1989f7(%rip), %rdi    # 0x1c4980
movq (%rdi), %rax
leaq 0x1989d5(%rip), %rsi    # 0x1c4968
callq *0x80(%rax)
callq 0x130f57
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x189d2f(%rip), %rax    # 0x1b6ae0
movq %rax, (%rdi)
cmpl $0x0, 0x5e8(%rdi)
je 0x2cdce
leaq 0x5e8(%rbx), %rsi
movl $0x1, %edi
callq 0x27d00
cmpl $0x0, 0x5f8(%rbx)
je 0x2cdec
leaq 0x5f8(%rbx), %rsi
movq 0x1921c3(%rip), %rax    # 0x1befa8
movl $0x1, %edi
callq *(%rax)
cmpl $0x0, 0x5fc(%rbx)
je 0x2ce0a
leaq 0x5fc(%rbx), %rsi
movq 0x1921a5(%rip), %rax    # 0x1befa8
movl $0x1, %edi
callq *(%rax)
cmpl $0x0, 0x600(%rbx)
je 0x2ce28
leaq 0x600(%rbx), %rsi
movq 0x192187(%rip), %rax    # 0x1befa8
movl $0x1, %edi
callq *(%rax)
leaq 0x5c8(%rbx), %rdi
callq 0xe0852
leaq 0x4f8(%rbx), %rdi
callq 0xce9e8
movq 0x340(%rbx), %rdi
testq %rdi, %rdi
je 0x2ce5b
movq 0x350(%rbx), %rsi
subq %rdi, %rsi
callq 0x27930
leaq 0x168(%rbx), %rdi
callq 0xaf380
leaq 0x120(%rbx), %rdi
callq 0xaf380
leaq 0x78(%rbx), %rdi
callq 0x78e0c
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x41224
movq %rax, %rdi
callq 0x34551
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x2c(%rsi)
setg %bpl
jle 0x2cf2c
movq 0x20(%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x2cece
testl %eax, %eax
jne 0x2cf22
movl $0x1, %r15d
movslq 0x2c(%rbx), %rax
cmpq %rax, %r15
setl %bpl
jge 0x2cf2c
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x2cece
incq %r15
testl %eax, %eax
je 0x2cefe
movl $0x1, %eax
testb %bpl, %bpl
jne 0x2cf77
cmpl $0x0, 0x6c(%rbx)
setg %bpl
jle 0x2cf73
movq 0x60(%rbx), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x2cf82
testl %eax, %eax
jne 0x2cf73
movl $0x1, %r15d
movslq 0x6c(%rbx), %rax
cmpq %rax, %r15
setl %bpl
jge 0x2cf73
movq 0x60(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x2cf82
incq %r15
testl %eax, %eax
je 0x2cf4f
movzbl %bpl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d1c9
movq 0x8(%rdi), %rcx
cmpl %esi, 0x2c(%rcx)
jle 0x2d1c9
movq 0x340(%rdi), %rcx
movq 0x348(%rdi), %rdi
subq %rcx, %rdi
sarq $0x2, %rdi
movl %esi, %edx
movl $0x1, %eax
cmpq %rdx, %rdi
jbe 0x2d1c9
movl (%rcx,%rdx,4), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d289
testl %esi, %esi
js 0x2d2f2
movq 0x8(%rbx), %rax
cmpl %esi, 0x2c(%rax)
jle 0x2d2f2
movl %esi, %r12d
movq 0x340(%rbx), %rax
movq 0x348(%rbx), %rsi
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x2d271
leaq 0x340(%rbx), %r14
leaq 0xc(%rsp), %r15
movl $0x1, 0xc(%rsp)
cmpq 0x350(%rbx), %rsi
je 0x2d249
movl $0x1, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x348(%rbx)
jmp 0x2d254
movq %r14, %rdi
movq %r15, %rdx
callq 0x34b18
movq 0x340(%rbx), %rax
movq 0x348(%rbx), %rsi
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x2d225
testl %ebp, %ebp
je 0x2d2d4
cmpl $-0x1, %ebp
jne 0x2d2de
movl $0x1, %ecx
subl (%rax,%r12,4), %ecx
movl %ecx, (%rax,%r12,4)
jmp 0x2d2e6
cmpl $0x1, %ebp
jne 0x2d2a7
movq 0x340(%rbx), %rax
cmpq %rax, 0x348(%rbx)
je 0x2d2e6
movq %rax, 0x348(%rbx)
jmp 0x2d2e6
movq 0x8(%rbx), %rax
cmpl $0x0, 0x2c(%rax)
jle 0x2d2e6
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 0x2d2b4
jmp 0x2d2e6
movl $0x0, (%rax,%r12,4)
jmp 0x2d2e6
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_O1/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 0x2d31e
cmpl $-0x1, %edx
jne 0x2d32a
xorq 0x358(%rdi), %rax
jmp 0x2d331
notq %rax
andq 0x358(%rdi), %rax
jmp 0x2d331
orq 0x358(%rdi), %rax
movq %rax, 0x358(%rdi)
movq (%rdi), %rax
jmpq *0x378(%rax)
nop