LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rachit31[P]CubeSatADCS/threadManager.cpp
// Function: ThreadManager::create(void* (*)(void*))
const char* ThreadManager::create(void *(*function)(void *))
{
  // Look for lowest available thread id
  unsigned int id = 0;
  bool found = true;
  while(found)
  {
    if (m_threadMap.count(id))
    {
      id++;
    }
    else
    {
      found = false;
    }
  }

  std::string error = threadCreate(function,id);
  if (!error.empty())
  {
    return error.c_str();
  }

  std::stringstream idStream;
  idStream << id;

  return idStream.str().c_str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x208(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
je 0x5eda
movq -0x208(%rbp), %rdi
addq $0x8, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x6d70
cmpq $0x0, %rax
je 0x5ed4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5ed8
movb $0x0, -0x1d(%rbp)
jmp 0x5ea9
movq -0x208(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x6020
movq %rax, -0x218(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x3430
movq -0x218(%rbp), %rsi
movq -0x210(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x6dd0
jmp 0x5f1d
leaq -0x41(%rbp), %rdi
callq 0x32d0
leaq -0x40(%rbp), %rdi
callq 0x33e0
testb $0x1, %al
jne 0x5f66
leaq -0x40(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x5ff3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x32d0
jmp 0x6012
leaq -0x1e0(%rbp), %rdi
callq 0x3190
jmp 0x5f74
leaq -0x1d0(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3320
jmp 0x5f85
leaq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x3260
jmp 0x5f9a
leaq -0x200(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x3160
movl $0x1, -0x58(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x31d0
jmp 0x5ff3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6009
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x31d0
jmp 0x6009
leaq -0x40(%rbp), %rdi
callq 0x3160
movq -0x8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x3160
movq -0x50(%rbp), %rdi
callq 0x3420
nopl (%rax,%rax)
// File: rachit31[P]CubeSatADCS/threadManager.cpp
// Function: ThreadManager::threadCreate(void* (*)(void*), unsigned int)
const char* ThreadManager::threadCreate(void *(*function)(void *), const unsigned int id)
{
  std::stringstream error;

  Thread* pThread;

  try
  {
    pThread = new Thread(function, this, id);
  }
  catch (const char* e)
  {
    error << "Thread(): " << e;
    return error.str().c_str();
  }

  m_threadMap[id] = pThread;

  return error.str().c_str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x3190
movl $0x20, %edi
callq 0x3280
movq %rax, -0x218(%rbp)
jmp 0x6060
movq -0x220(%rbp), %rdx
movq -0x218(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %ecx
callq 0x97e0
jmp 0x607c
movq -0x218(%rbp), %rax
movq %rax, -0x1b0(%rbp)
jmp 0x617e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x60c6
movq -0x218(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
movl $0x20, %esi
callq 0x3290
movl -0x1bc(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6224
movq -0x1b8(%rbp), %rdi
callq 0x30f0
movq %rax, -0x1c8(%rbp)
leaq -0x198(%rbp), %rdi
leaq 0x71f9(%rip), %rsi      # 0xd2f3
callq 0x3270
movq %rax, -0x228(%rbp)
jmp 0x6108
movq -0x228(%rbp), %rdi
movq -0x1c8(%rbp), %rsi
callq 0x3270
jmp 0x611d
leaq -0x1e8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x3260
jmp 0x6132
leaq -0x1e8(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1ec(%rbp)
callq 0x33d0
jmp 0x620b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
callq 0x33d0
jmp 0x6224
movq -0x220(%rbp), %rdi
movq -0x1b0(%rbp), %rax
movq %rax, -0x238(%rbp)
addq $0x8, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x6e80
movq %rax, -0x230(%rbp)
jmp 0x61a9
movq -0x230(%rbp), %rax
movq -0x238(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x210(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x3260
jmp 0x61cf
leaq -0x210(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1ec(%rbp)
jmp 0x620b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x6224
leaq -0x1a8(%rbp), %rdi
callq 0x31d0
movq -0x8(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
leaq -0x1a8(%rbp), %rdi
callq 0x31d0
movq -0x1b8(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: rachit31[P]CubeSatADCS/threadManager.cpp
// Function: ThreadManager::create(void* (*)(void*), unsigned int)
const char* ThreadManager::create(void *(*function)(void *), const unsigned int id)
{
  std::stringstream error;

  // Look for existing id
  if (m_threadMap.count(id))
  {
    error << "thread " << id << " already exists";
    return error.str().c_str();
  }

  return threadCreate(function,id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x3190
movq -0x1f0(%rbp), %rdi
addq $0x8, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x6d70
movq %rax, -0x1e8(%rbp)
jmp 0x628a
movq -0x1e8(%rbp), %rax
cmpq $0x0, %rax
je 0x6341
leaq -0x198(%rbp), %rdi
leaq 0x7032(%rip), %rsi      # 0xd2db
callq 0x3270
movq %rax, -0x1f8(%rbp)
jmp 0x62b7
movq -0x1f8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3320
movq %rax, -0x200(%rbp)
jmp 0x62cf
movq -0x200(%rbp), %rdi
leaq 0x7006(%rip), %rsi      # 0xd2e3
callq 0x3270
jmp 0x62e4
leaq -0x1d8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x3260
jmp 0x62f9
leaq -0x1d8(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1dc(%rbp)
jmp 0x6372
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x31d0
jmp 0x638b
movq -0x1f0(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x6020
movq %rax, -0x208(%rbp)
jmp 0x635d
movq -0x208(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x1dc(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x31d0
movq -0x8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: 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
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x3190
movq -0x230(%rbp), %rdi
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x6d70
movq %rax, -0x228(%rbp)
jmp 0x6a56
movq -0x228(%rbp), %rax
cmpq $0x0, %rax
jne 0x6b13
leaq -0x190(%rbp), %rdi
leaq 0x68f2(%rip), %rsi      # 0xd367
callq 0x3270
movq %rax, -0x238(%rbp)
jmp 0x6a83
movq -0x238(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3320
movq %rax, -0x240(%rbp)
jmp 0x6a9b
movq -0x240(%rbp), %rdi
leaq 0x68c9(%rip), %rsi      # 0xd372
callq 0x3270
jmp 0x6ab0
leaq -0x1d8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x3260
jmp 0x6ac5
leaq -0x1d8(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1dc(%rbp)
jmp 0x6c21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
jmp 0x6c3a
movq -0x230(%rbp), %rdi
addq $0x8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x6e80
movq %rax, -0x248(%rbp)
jmp 0x6b30
movq -0x248(%rbp), %rax
movq (%rax), %rdi
callq 0x9990
movq %rax, -0x250(%rbp)
jmp 0x6b48
movq -0x250(%rbp), %rdi
callq 0x3350
movl %eax, -0x254(%rbp)
jmp 0x6b5c
movl -0x254(%rbp), %eax
movl %eax, -0x1a4(%rbp)
cmpl $0x0, -0x1a4(%rbp)
je 0x6be6
leaq -0x190(%rbp), %rdi
leaq 0x6803(%rip), %rsi      # 0xd382
callq 0x3270
movq %rax, -0x260(%rbp)
jmp 0x6b8d
movl -0x1a4(%rbp), %edi
callq 0x30d0
movq -0x260(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
jmp 0x6ba9
leaq -0x200(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x3260
jmp 0x6bbe
leaq -0x200(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1dc(%rbp)
jmp 0x6c21
leaq -0x220(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x3260
jmp 0x6bfb
leaq -0x220(%rbp), %rdi
callq 0x3100
movq %rax, -0x8(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x3160
movl $0x1, -0x1dc(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
movq -0x8(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl %eax, (%rcx)
movb $0x1, 0x10(%rcx)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rcx)
movq %rcx, %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x3450
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x993d
leaq -0x1a8(%rbp), %rdi
callq 0x3190
leaq -0x198(%rbp), %rdi
leaq 0x3b90(%rip), %rsi      # 0xd3da
callq 0x3270
movq %rax, -0x1e8(%rbp)
jmp 0x9858
movl -0x20(%rbp), %edi
callq 0x30d0
movq -0x1e8(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
jmp 0x9871
movb $0x1, -0x1d9(%rbp)
movl $0x8, %edi
callq 0x3120
movq %rax, -0x1f0(%rbp)
leaq -0x1d8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x3260
jmp 0x989e
leaq -0x1d8(%rbp), %rdi
callq 0x3100
movq -0x1f0(%rbp), %rdi
movq %rax, (%rdi)
movb $0x0, -0x1d9(%rbp)
movq 0x8706(%rip), %rsi      # 0x11fc8
xorl %eax, %eax
movl %eax, %edx
callq 0x33f0
jmp 0x9952
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x992f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x9916
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x3160
testb $0x1, -0x1d9(%rbp)
jne 0x9921
jmp 0x992d
movq -0x1f0(%rbp), %rdi
callq 0x31b0
jmp 0x992f
leaq -0x1a8(%rbp), %rdi
callq 0x31d0
jmp 0x9946
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x18(%rax), %rdi
callq 0x69f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49e0
movq -0x18(%rbp), %rax
movb $0x0, 0x10(%rax)
movq 0x18(%rax), %rdi
callq 0x69d0
movq -0x10(%rbp), %rdi
callq 0x4b30
movq -0x10(%rbp), %rdi
callq 0x4e90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rax)
popq %rbp
retq
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0xb40a
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0xb3fa
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0xb3ea
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb384
jmp 0xb3ec
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb358
jmp 0xb3fc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb347
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x6, -0x1c(%rbp)
jge 0xb5ea
movl $0x0, -0x20(%rbp)
cmpl $0x6, -0x20(%rbp)
jge 0xb5da
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x24(%rbp)
cmpl $0x6, -0x24(%rbp)
jge 0xb5ca
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb564
jmp 0xb5cc
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb538
jmp 0xb5dc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb527
popq %rbp
retq
nopl (%rax)
// File: 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 %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x11e5
movl -0x4(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11c8
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x1258
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %esi
subl -0x14(%rbp), %esi
subl $0x1, %esi
movl $0x100, %edi            # imm = 0x100
callq 0x11b0
movl %eax, %ecx
movl -0x18(%rbp), %eax
imull %ecx, %eax
movl $0x65, %ecx
cltd
idivl %ecx
addl -0x10(%rbp), %edx
movl %edx, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x120d
movl -0x10(%rbp), %eax
movl $0x65, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x13f3
leaq 0xc24(%rip), %rdi       # 0x2007
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x145a
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x12d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x142c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xbfa(%rip), %rdi       # 0x201f
movb $0x0, %al
callq 0x1060
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x11f0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
leaq 0xbe7(%rip), %rdi       # 0x2033
movb $0x0, %al
callq 0x1060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2180
shll $0x0, %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2180
movl %eax, %ecx
movl 0x4(%rsp), %eax
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2180
movl %eax, %ecx
movl 0x8(%rsp), %eax
shll $0x10, %ecx
addl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2180
movl %eax, %ecx
movl 0xc(%rsp), %eax
shll $0x18, %ecx
addl %ecx, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x3ead
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x3e9b
movl $0x0, 0x4(%rsp)
cmpl $0x3, 0x4(%rsp)
jae 0x3e8c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
imull 0x14(%rcx), %eax
addl 0x8(%rsp), %eax
movl %eax, %eax
imulq $0x300, %rax, %rax      # imm = 0x300
addq %rax, %rdi
movl 0x4(%rsp), %esi
callq 0x52f0
movq %rax, %rdi
callq 0x3110
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3e41
jmp 0x3e8e
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3e2b
jmp 0x3e9d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3e11
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x3fef
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x3fdd
movl $0x0, 0x14(%rsp)
cmpl $0x3, 0x14(%rsp)
jae 0x3fcb
movl 0x14(%rsp), %eax
movl %eax, %ecx
leaq 0x5dd7(%rip), %rax      # 0x9d50
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
imull 0x14(%rcx), %eax
addl 0x18(%rsp), %eax
movl %eax, %eax
imulq $0x300, %rax, %rax      # imm = 0x300
addq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x52f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x3ec0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3f65
jmp 0x3fcd
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x3f4b
jmp 0x3fdf
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x3f31
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
cmpl $0x10, -0x10(%rsp)
jae 0x408a
movq -0x8(%rsp), %rax
movl -0x10(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
movl -0x10(%rsp), %edx
addl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jae 0x4073
movl -0xc(%rsp), %edx
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movl %edx, 0xc4(%rax,%rcx,4)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x402d
movl -0xc(%rsp), %eax
shll %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x4015
retq
nopl (%rax,%rax)
// File: 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:
movl %edi, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
cmpl $0x0, -0x4(%rsp)
jle 0x40ba
movl -0x4(%rsp), %eax
sarl %eax
movl %eax, -0x4(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x409c
movl -0x8(%rsp), %eax
retq
nop
// File: 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:
movb %sil, %al
movq %rdi, -0x10(%rsp)
movb %al, -0x11(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
cmpl $0x10, -0x2c(%rsp)
jae 0x4178
movq -0x10(%rsp), %rax
movl -0x2c(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x30(%rsp)
movl -0x30(%rsp), %eax
movq -0x10(%rsp), %rcx
movl -0x2c(%rsp), %edx
addl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jae 0x4166
movzbl -0x11(%rsp), %eax
movq -0x10(%rsp), %rcx
movl -0x30(%rsp), %edx
movzbl 0x11(%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x4157
movq -0x10(%rsp), %rax
movl -0x30(%rsp), %ecx
movl 0xc4(%rax,%rcx,4), %ecx
movq -0x20(%rsp), %rax
movl %ecx, (%rax)
movl -0x2c(%rsp), %ecx
addl $0x1, %ecx
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rsp)
jmp 0x417d
jmp 0x4159
movl -0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rsp)
jmp 0x40fa
jmp 0x4168
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x40de
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2030
movq 0x20(%rsp), %rdi
movl $0xffffffdb, %esi       # imm = 0xFFFFFFDB
callq 0x2030
movq 0x20(%rsp), %rdi
movl $0x43, %esi
callq 0x4740
movq 0x20(%rsp), %rdi
movsbl 0x1f(%rsp), %esi
callq 0x2030
movl $0x0, 0xc(%rsp)
cmpl $0x40, 0xc(%rsp)
jae 0x4823
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, %edx
leaq 0x2a79(%rip), %rcx      # 0x7280
movzbl (%rcx,%rdx), %ecx
movl (%rax,%rcx,4), %eax
movsbl %al, %esi
callq 0x2030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x47e9
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2030
movq 0x10(%rsp), %rdi
movl $0xffffffc0, %esi       # imm = 0xFFFFFFC0
callq 0x2030
movq 0x10(%rsp), %rdi
movl $0x11, %esi
callq 0x4740
movq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x2030
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %esi
callq 0x4740
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x4740
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x2030
movl $0x1, 0x4(%rsp)
cmpl $0x3, 0x4(%rsp)
ja 0x4906
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %eax
movsbl %al, %esi
callq 0x2030
movq 0x10(%rsp), %rdi
movl $0x11, %esi
callq 0x2030
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movsbl %al, %esi
callq 0x2030
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x48b4
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movb %dl, %al
movb %sil, %dl
movq %rdi, 0x20(%rsp)
movb %dl, 0x1f(%rsp)
movb %al, 0x1e(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2030
movq 0x20(%rsp), %rdi
movl $0xffffffc4, %esi       # imm = 0xFFFFFFC4
callq 0x2030
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl 0x10(%rax), %esi
addl $0x13, %esi
callq 0x4740
movq 0x20(%rsp), %rdi
movzbl 0x1f(%rsp), %eax
shll $0x4, %eax
movzbl 0x1e(%rsp), %ecx
orl %ecx, %eax
movsbl %al, %esi
callq 0x2030
movl $0x0, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
jae 0x49c5
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movsbl %al, %esi
callq 0x2030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4983
movl $0x0, 0x8(%rsp)
cmpl $0x10, 0x8(%rsp)
jae 0x4a33
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
movl 0x8(%rsp), %edx
addl $0x1, %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jae 0x4a24
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movsbl 0x11(%rax,%rcx), %esi
callq 0x2030
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x49e5
jmp 0x4a26
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x49cd
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2030
movq 0x10(%rsp), %rdi
movl $0xffffffda, %esi       # imm = 0xFFFFFFDA
callq 0x2030
movq 0x10(%rsp), %rdi
movl $0xc, %esi
callq 0x4740
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x2030
movl $0x1, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
ja 0x4ad0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movsbl %al, %esi
callq 0x2030
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0x11, %eax
xorl %ecx, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movsbl %al, %esi
callq 0x2030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4a8d
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x2030
movq 0x10(%rsp), %rdi
movl $0x3f, %esi
callq 0x2030
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x2030
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x2030
movq (%rsp), %rdi
movl $0xffffffe0, %esi       # imm = 0xFFFFFFE0
callq 0x2030
movq (%rsp), %rdi
movl $0x10, %esi
callq 0x4740
movq (%rsp), %rdi
movl $0x4a, %esi
callq 0x2030
movq (%rsp), %rdi
movl $0x46, %esi
callq 0x2030
movq (%rsp), %rdi
movl $0x49, %esi
callq 0x2030
movq (%rsp), %rdi
movl $0x46, %esi
callq 0x2030
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x2030
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x2030
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x2030
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x2030
movq (%rsp), %rdi
movl $0x64, %esi
callq 0x4740
movq (%rsp), %rdi
movl $0x64, %esi
callq 0x4740
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x2030
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x2030
popq %rax
retq
nopl (%rax)
// File: dannye[P]jed/src/jpg.h
// Function: Block::operator[](unsigned int)
int* operator[](uint i) {
        switch (i) {
            case 0:
                return y;
            case 1:
                return cb;
            case 2:
                return cr;
            default:
                return nullptr;
        }
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x18(%rsp)
testl %eax, %eax
je 0x5327
jmp 0x5311
movl -0x18(%rsp), %eax
subl $0x1, %eax
je 0x5333
jmp 0x531c
movl -0x18(%rsp), %eax
subl $0x2, %eax
je 0x5345
jmp 0x5357
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x5360
movq -0x20(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x8(%rsp)
jmp 0x5360
movq -0x20(%rsp), %rax
addq $0x200, %rax            # imm = 0x200
movq %rax, -0x8(%rsp)
jmp 0x5360
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x55e7
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movb $0x0, 0x1b(%rsp)
leaq 0x1b(%rsp), %rsi
callq 0x5680
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %edx
andl $0x1, %edx
movzbl (%rax), %esi
movl $0x7, %ecx
subl %esi, %ecx
shll %cl, %edx
movl %edx, 0xc(%rsp)
movq 0x8(%rax), %rdi
callq 0x56b0
movl 0xc(%rsp), %esi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movzbl (%rcx), %edx
orl %esi, %edx
movb %dl, (%rcx)
movzbl (%rax), %eax
addl $0x1, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movq 0x10(%rsp), %rax
movb %dl, %cl
movb %cl, (%rax)
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x566e
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x56b0
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x566e
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movb $0x0, 0x1a(%rsp)
leaq 0x1a(%rsp), %rsi
callq 0x5680
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rax
movq 0x2a5178(%rip), %rdi    # 0x2d24b0
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0x0, %eax
je 0x2d348
callq 0x22cf90
callq 0x2d360
callq 0x22cff0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/sflview/sflview.cpp
// Function: DrawModel()
static void
DrawModel(void)
{
  // Check model
  if (!model) return;

  // Draw model faces
  if (show_model) {
    glEnable(GL_LIGHTING);
    RNLoadRgb(1.0, 1.0, 1.0);
    model->Draw(R3_DEFAULT_DRAW_FLAGS);
    glDisable(GL_LIGHTING);
  }

  // Draw model node names
  if (show_model_names) {
    glDisable(GL_LIGHTING);
    RNLoadRgb(1, 1, 1);
    for (int i = 0; i < model->NNodes(); i++) {
      R3SceneNode *node = model->Node(i);
      if (node->Name() == NULL) continue;
      if (node->NChildren() != 0) continue;
      if (node->BBox().IsEmpty()) continue;
      R3Point p = node->Centroid() + 1.5 * node->BBox().ZRadius() * R3posz_vector;
      R3DrawText(p, node->Name());
    }
  }
}

// Assembly:
subq $0x78, %rsp
cmpq $0x0, 0x2a517c(%rip)    # 0x2d24e8
jne 0x2d373
jmp 0x2d4f5
cmpl $0x0, 0x29676e(%rip)    # 0x2c3ae8
je 0x2d3cd
movl $0xb50, %edi            # imm = 0xB50
callq 0x28960
movsd 0x213c82(%rip), %xmm2   # 0x241010
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x2f2e0
movq 0x2a5148(%rip), %rax    # 0x2d24e8
movq %rax, 0x10(%rsp)
leaq 0x70(%rsp), %rdi
movl $0x772, %esi            # imm = 0x772
callq 0x2f310
movq 0x10(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xa1bf0
movl $0xb50, %edi            # imm = 0xB50
callq 0x28240
cmpl $0x0, 0x2a50ec(%rip)    # 0x2d24c0
je 0x2d4f5
movl $0xb50, %edi            # imm = 0xB50
callq 0x28240
movl $0x1, %edx
movl %edx, %edi
movl %edx, %esi
callq 0x2f330
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x2a50df(%rip), %rdi    # 0x2d24e8
callq 0x2f360
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2d4f3
movq 0x2a50c5(%rip), %rdi    # 0x2d24e8
movl 0x6c(%rsp), %esi
callq 0x2f380
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x2f3b0
cmpq $0x0, %rax
jne 0x2d446
jmp 0x2d4e3
movq 0x60(%rsp), %rdi
callq 0x2f3d0
cmpl $0x0, %eax
je 0x2d45a
jmp 0x2d4e3
movq 0x60(%rsp), %rdi
callq 0xc9fa0
movq %rax, %rdi
callq 0x2f3f0
cmpl $0x0, %eax
je 0x2d473
jmp 0x2d4e3
movq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0xca340
movq 0x60(%rsp), %rdi
callq 0xc9fa0
movq %rax, %rdi
callq 0x2f4f0
movaps %xmm0, %xmm1
movsd 0x213b79(%rip), %xmm0   # 0x241018
mulsd %xmm1, %xmm0
leaq 0x18(%rsp), %rdi
leaq 0x6a8af1(%rip), %rsi    # 0x6d5fa0
callq 0x2f4b0
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x162880
movq 0x60(%rsp), %rdi
callq 0x2f3b0
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x2f510
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x2d3fa
jmp 0x2d4f5
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: 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 %edi, 0x4(%rsp)
movl %esi, (%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x2965ce(%rip)    # 0x2c3ae0
movl (%rsp), %eax
movl %eax, 0x2965c9(%rip)    # 0x2c3ae4
movq 0x2a4f8e(%rip), %rdi    # 0x2d24b0
movl 0x4(%rsp), %esi
movl (%rsp), %edx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x0, %eax
je 0x2d539
callq 0x22cf90
popq %rax
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
movl 0x29654a(%rip), %eax    # 0x2c3ae4
subl 0x38(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x44(%rsp)
jne 0x2d5bb
movl $0x0, 0x34(%rsp)
jmp 0x2d5df
cmpl $0x1, 0x44(%rsp)
jne 0x2d5cc
movl $0x1, 0x34(%rsp)
jmp 0x2d5dd
cmpl $0x2, 0x44(%rsp)
jne 0x2d5db
movl $0x2, 0x34(%rsp)
jmp 0x2d5dd
jmp 0x2d5df
movl 0x40(%rsp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, 0x30(%rsp)
callq 0x2351c0
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
andl $0x1, %eax
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
andl $0x2, %eax
movl %eax, 0x24(%rsp)
movl 0x2c(%rsp), %eax
andl $0x4, %eax
movl %eax, 0x20(%rsp)
movq 0x2a4e8b(%rip), %rdi    # 0x2d24b0
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
movl 0x34(%rsp), %ecx
movl 0x30(%rsp), %r8d
movl 0x28(%rsp), %r9d
movl 0x24(%rsp), %r11d
movl 0x20(%rsp), %r10d
movq (%rdi), %rax
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
callq *0x38(%rax)
cmpl $0x0, %eax
je 0x2d666
callq 0x22cf90
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x22e200
movl $0x64, %esi
movl %esi, %edi
callq 0x22e980
movl 0x295f81(%rip), %edi    # 0x2c3ae0
movl 0x295f7f(%rip), %esi    # 0x2c3ae4
callq 0x22e9c0
movl $0x1a, %edi
callq 0x22ea00
leaq 0x21369c(%rip), %rdi    # 0x241217
callq 0x237220
movl %eax, 0x2a493e(%rip)    # 0x2d24c4
callq 0x1a2240
leaq -0x862(%rip), %rdi      # 0x2d330
callq 0x22c1a0
leaq -0x69e(%rip), %rdi      # 0x2d500
callq 0x22c220
leaq -0x39a(%rip), %rdi      # 0x2d810
callq 0x22c290
leaq -0x546(%rip), %rdi      # 0x2d670
callq 0x22c300
leaq -0x642(%rip), %rdi      # 0x2d580
callq 0x22c830
leaq -0x68e(%rip), %rdi      # 0x2d540
callq 0x22c910
leaq -0xa9a(%rip), %rdi      # 0x2d140
callq 0x240830
movq 0x2a48ca(%rip), %rdi    # 0x2d24b0
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq 0x2a48a2(%rip), %rdi    # 0x2d24b0
movq (%rdi), %rax
leaq 0x2a4820(%rip), %rsi    # 0x2d2438
callq *0x168(%rax)
cmpl $0x0, 0x2a48a3(%rip)    # 0x2d24c8
je 0x2dc73
leaq 0x18(%rsp), %rdi
leaq 0x2a481d(%rip), %rsi    # 0x2d2450
leaq 0x2a482e(%rip), %rdx    # 0x2d2468
leaq 0x2a483f(%rip), %rcx    # 0x2d2480
movsd 0x2133d7(%rip), %xmm1   # 0x241020
movsd 0x2133d7(%rip), %xmm2   # 0x241028
movsd 0x2133d7(%rip), %xmm3   # 0x241030
movaps %xmm1, %xmm0
callq 0xd09a0
movq 0x2a4848(%rip), %rdi    # 0x2d24b0
movq (%rdi), %rax
leaq 0x18(%rsp), %rsi
callq *0x58(%rax)
movq %rsp, %rdi
movsd 0x21338a(%rip), %xmm2   # 0x241008
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x1622c0
leaq 0x2a4808(%rip), %rdi    # 0x2d2498
movq %rsp, %rsi
callq 0x1624d0
cmpl $0x0, %eax
je 0x2dcb4
movq 0x2a480c(%rip), %rdi    # 0x2d24b0
movq (%rdi), %rax
leaq 0x2a47ea(%rip), %rsi    # 0x2d2498
callq *0x80(%rax)
callq 0x232000
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/sflview/sflview.cpp
// Function: main
int main(int argc, char **argv)
{
  // Initialize packages
  if (!R3InitGraphics()) exit(-1);
  if (!R3InitSurfels()) exit(-1);

  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Open scene
  scene = OpenScene(scene_name, database_name);
  if (!scene) exit(-1);

  // Read model
  if (model_name) {
    model = ReadModel(model_name);
    if (!model) exit(-1);
  }

  // Read images
  if (pixel_database) {
    if (!ReadImagesFromPixelDatabase(scene, pixel_database)) exit(-1);
  }
  else if (image_directory) {
    if (!ReadImagesFromDirectory(scene, image_directory)) exit(-1);
  }
  
  // Create viewer
  viewer = new R3SurfelViewer(scene);
  if (!viewer) exit(-1);

  // Initialize GLUT
  GLUTInit(&argc, argv);

  // Run GLUT interface
  GLUTMainLoop();

  // Return success 
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
callq 0x9f8d0
cmpl $0x0, %eax
jne 0x2dcf9
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x28cb0
callq 0x428e0
cmpl $0x0, %eax
jne 0x2dd0d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x28cb0
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x2de70
cmpl $0x0, %eax
jne 0x2dd2a
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x28cb0
movq 0x2a479f(%rip), %rdi    # 0x2d24d0
movq 0x2a47a0(%rip), %rsi    # 0x2d24d8
callq 0x2e730
movq %rax, 0x2a4774(%rip)    # 0x2d24b8
cmpq $0x0, 0x2a476c(%rip)    # 0x2d24b8
jne 0x2dd58
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x28cb0
cmpq $0x0, 0x2a4780(%rip)    # 0x2d24e0
je 0x2dd8b
movq 0x2a4777(%rip), %rdi    # 0x2d24e0
callq 0x2e9f0
movq %rax, 0x2a4773(%rip)    # 0x2d24e8
cmpq $0x0, 0x2a476b(%rip)    # 0x2d24e8
jne 0x2dd89
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x28cb0
jmp 0x2dd8b
cmpq $0x0, 0x2a475d(%rip)    # 0x2d24f0
je 0x2ddb9
movq 0x2a471c(%rip), %rdi    # 0x2d24b8
movq 0x2a474d(%rip), %rsi    # 0x2d24f0
callq 0x2eb50
cmpl $0x0, %eax
jne 0x2ddb7
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x28cb0
jmp 0x2dde9
cmpq $0x0, 0x2a4737(%rip)    # 0x2d24f8
je 0x2dde7
movq 0x2a46ee(%rip), %rdi    # 0x2d24b8
movq 0x2a4727(%rip), %rsi    # 0x2d24f8
callq 0x2ecc0
cmpl $0x0, %eax
jne 0x2dde5
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x28cb0
jmp 0x2dde7
jmp 0x2dde9
movl $0x618, %edi            # imm = 0x618
callq 0x28a30
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x2a46b4(%rip), %rsi    # 0x2d24b8
callq 0x2f970
jmp 0x2de0b
movq (%rsp), %rax
movq %rax, 0x2a469a(%rip)    # 0x2d24b0
cmpq $0x0, 0x2a4692(%rip)    # 0x2d24b0
jne 0x2de48
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x28cb0
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x618, %esi            # imm = 0x618
callq 0x28a50
jmp 0x2de63
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2db30
callq 0x2dc00
xorl %eax, %eax
addq $0x28, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x292e0
nopl (%rax)