LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: SkeletonEncoder::SkeletonEncoder(std::map<unsigned int, Decoder*, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, Decoder*>>>&, long, long, unsigned long)
SkeletonEncoder::SkeletonEncoder(DecoderMap& decoders,
                                 ogg_int64_t fileLength,
                                 ogg_int64_t oldSkeletonLength,
                                 ogg_uint64_t contentOffset)
  : mSkeletonDecoder(0),
    mFileLength(fileLength),
    mOldSkeletonLength(oldSkeletonLength),
    mPacketCount(0),
    mContentOffset(contentOffset)
{
  DecoderMap::iterator itr = decoders.begin();
  while (itr != decoders.end()) {
    Decoder* d = itr->second;
    if (IsIndexable(d)) {
      mDecoders.push_back(d);
    }
    if (d->Type() == TYPE_SKELETON) {
      mSkeletonDecoder = (SkeletonDecoder*)d;
    }
    itr++;
  }
  mSerial = mSkeletonDecoder ? mSkeletonDecoder->GetSerial()
                             : GetUniqueSerialNo(mDecoders);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x13f00
movq 0x28(%rsp), %rdi
movq $0x0, 0x18(%rdi)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rdi)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rdi)
movl $0x0, 0x34(%rdi)
addq $0x38, %rdi
movq %rdi, 0x18(%rsp)
callq 0x6960
movq 0x28(%rsp), %rdi
addq $0x50, %rdi
movq %rdi, 0x20(%rsp)
callq 0xea20
movq 0x28(%rsp), %rax
movq 0x60(%rsp), %rcx
movq %rcx, 0x68(%rax)
movq 0x78(%rsp), %rdi
callq 0xeb20
movq %rax, 0x58(%rsp)
movq 0x78(%rsp), %rdi
callq 0xeb70
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xeb50
testb $0x1, %al
jne 0x11390
jmp 0x11442
leaq 0x58(%rsp), %rdi
callq 0xeba0
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x114b0
movb %al, 0x17(%rsp)
jmp 0x113b3
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x113bd
jmp 0x11401
movq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x13f10
jmp 0x113ce
jmp 0x11401
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0xecc0
movq 0x18(%rsp), %rdi
callq 0x69d0
movq 0x28(%rsp), %rdi
callq 0x13fa0
jmp 0x1149a
movq 0x48(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movl %eax, 0x10(%rsp)
jmp 0x11415
movl 0x10(%rsp), %eax
cmpl $0x4, %eax
jne 0x1142c
movq 0x28(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x18(%rax)
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0xebc0
movq %rax, 0x30(%rsp)
jmp 0x11369
movq 0x28(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1146c
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x13f80
movl %eax, 0xc(%rsp)
jmp 0x11462
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x11486
movq 0x28(%rsp), %rdi
callq 0x11510
movl %eax, 0x4(%rsp)
jmp 0x1147c
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x11486
movq 0x28(%rsp), %rax
movl 0x8(%rsp), %ecx
movl %ecx, 0x30(%rax)
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x57d0
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: GetUniqueSerialNo(std::vector<Decoder*, std::allocator<Decoder*>>&)
static ogg_uint32_t
GetUniqueSerialNo(vector<Decoder*>& decoders)
{
  ogg_uint32_t serialno;
  srand((unsigned)time(0));
  do {
    serialno = rand();
  } while (!IsUniqueSerialno(serialno, decoders));
  return serialno;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x53b0
movl %eax, %edi
callq 0x53c0
callq 0x50f0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x13e40
xorb $-0x1, %al
testb $0x1, %al
jne 0x11529
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: SkeletonEncoder::~SkeletonEncoder()
SkeletonEncoder::~SkeletonEncoder() {
  for (ogg_uint32_t i=0; i<mIndexPackets.size(); i++) {
    delete[] mIndexPackets[i]->packet;
    delete mIndexPackets[i];
  }
  ClearIndexPages();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
movq %rax, 0x18(%rsp)
addq $0x38, %rdi
callq 0x6980
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x11601
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x69a0
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x115be
movq 0x10(%rsp), %rdi
callq 0x5540
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x69a0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x115ef
movq 0x8(%rsp), %rdi
movl $0x30, %esi
callq 0x5400
jmp 0x115f1
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1156b
movq 0x20(%rsp), %rdi
callq 0x11640
jmp 0x1160d
movq 0x20(%rsp), %rdi
addq $0x50, %rdi
callq 0xecc0
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
callq 0x69d0
movq 0x20(%rsp), %rdi
callq 0x13fa0
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x6940
// File: cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: SkeletonEncoder::AddEosPacket()
void
SkeletonEncoder::AddEosPacket() {
  ogg_packet* eos = new ogg_packet();
  memset(eos, 0, sizeof(ogg_packet));
  eos->e_o_s = 1;
  eos->packetno = mPacketCount;
  mPacketCount++;
  mIndexPackets.push_back(eos);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x30, %edi
callq 0x53e0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x5230
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x5230
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq $0x1, 0x18(%rax)
movslq 0x34(%rdi), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
movl 0x34(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x34(%rdi)
addq $0x38, %rdi
leaq 0x18(%rsp), %rsi
callq 0x14030
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: ReadVariableLength(unsigned char*, long*)
unsigned char*
ReadVariableLength(unsigned char* p, ogg_int64_t* num) {
  *num = 0;
  int shift = 0;
  ogg_int64_t byte = 0;
  do {
    byte = (ogg_int64_t)(*p);
    *num |= ((byte & 0x7f) << shift);
    shift += 7;
    p++;
  } while ((byte & 0x80) != 0x80);
  return p;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq $0x0, (%rax)
movl $0x0, -0x14(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
andq $0x7f, %rax
movl -0x14(%rsp), %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x10(%rsp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movl -0x14(%rsp), %eax
addl $0x7, %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
movq -0x20(%rsp), %rax
andq $0x80, %rax
cmpq $0x80, %rax
jne 0x12ed7
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: compressed_length(std::vector<KeyFrameInfo, std::allocator<KeyFrameInfo>> const&)
static ogg_int64_t compressed_length(const vector<KeyFrameInfo>& K) {
  ogg_int64_t length = 0;
  if (K.size() == 0) {
    return 0;
  }
  length = bytes_required(K[0].mOffset) + bytes_required(K[0].mTime);
  for (unsigned i=1; i<K.size(); i++) {
    ogg_int64_t off_diff = K[i].mOffset - K[i-1].mOffset;
    ogg_int64_t time_diff = K[i].mTime - K[i-1].mTime;
    length += bytes_required(off_diff) + bytes_required(time_diff);
  }
  return length;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0xa590
cmpq $0x0, %rax
jne 0x12f70
movq $0x0, 0x50(%rsp)
jmp 0x1309c
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x14120
movq (%rax), %rdi
callq 0x130b0
movl %eax, 0x24(%rsp)
movq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x14120
movq 0x8(%rax), %rdi
callq 0x130b0
movl %eax, %ecx
movl 0x24(%rsp), %eax
addl %ecx, %eax
cltq
movq %rax, 0x40(%rsp)
movl $0x1, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0xa590
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x13092
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x14120
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x14120
movq %rax, %rcx
movq (%rsp), %rax
subq (%rcx), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x14120
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl 0x3c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x14120
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq 0x8(%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x130b0
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0x130b0
movl %eax, %ecx
movl 0x14(%rsp), %eax
addl %ecx, %eax
cltq
addq 0x40(%rsp), %rax
movq %rax, 0x40(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x12fb8
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: SkeletonEncoder::GetTrackLength()
ogg_int64_t
SkeletonEncoder::GetTrackLength()
{
  ogg_int64_t length = 0;
  int packets = 0;
  for (ogg_uint32_t i=0; i<mIndexPages.size(); i++) {
    length += mIndexPages[i]->header_len + mIndexPages[i]->body_len;
    packets += ogg_page_packets(mIndexPages[i]);
  }
  return length;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x50, %rdi
callq 0xec30
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x13235
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0xec50
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
addq $0x50, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0xec50
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
addq 0x18(%rcx), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x50, %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0xec50
movq (%rax), %rdi
callq 0x5820
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1318c
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: SkeletonEncoder::FindTrack(unsigned int)
Decoder*
SkeletonEncoder::FindTrack(ogg_uint32_t serialno) {
  for (unsigned i=0; i<mDecoders.size(); i++) {
    if (mDecoders[i]->GetSerial() == serialno) {
      return mDecoders[i];
    }
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %eax
movq %rax, (%rsp)
callq 0x140a0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x13474
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x140c0
movq (%rax), %rdi
callq 0x13f80
cmpl 0x14(%rsp), %eax
jne 0x13465
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x140c0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x1347d
jmp 0x13467
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1340f
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: IsUniqueSerialno(unsigned int, std::vector<Decoder*, std::allocator<Decoder*>>&)
static bool
IsUniqueSerialno(ogg_uint32_t serialno, vector<Decoder*>& decoders)
{
  for (unsigned i=0; i<decoders.size(); i++) {
    if (decoders[i]->GetSerial() == serialno) {
      return false;
    }
  }
  return true;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x140a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x13ea9
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x140c0
movq (%rax), %rdi
callq 0x13f80
cmpl 0x20(%rsp), %eax
jne 0x13e9a
movb $0x0, 0x27(%rsp)
jmp 0x13eae
jmp 0x13e9c
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x13e55
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: bits_required(long)
static int bits_required(ogg_int64_t n) {
  int count = 0;
  while (n) {
    n = n >> 1;
    count++;
  }
  return count;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x13eef
movq -0x8(%rsp), %rax
sarq %rax
movq %rax, -0x8(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x13ecd
movl -0xc(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nop
// File: cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: unsigned char* WriteVariableLength<long>(unsigned char*, unsigned char const*, long)
unsigned char*
WriteVariableLength(unsigned char* p, const unsigned char* limit, const T n)
{
  #if _DEBUG
  unsigned char* before_p = p;
  #endif
  T k = n;
  do {
    unsigned char b = (unsigned char)(k & 0x7f);
    k >>= 7;
    if (k == 0) {
      // Last byte, add terminating bit.
      b |= 0x80;
    }
    *p = b;
    p++;
  } while (k && p < limit);

#if _DEBUG
  ogg_int64_t t;
  ReadVariableLength(before_p, &t);
  assert(t == n);
#endif
  return p;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
andq $0x7f, %rax
movb %al, -0x21(%rsp)
movq -0x20(%rsp), %rax
sarq $0x7, %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
jne 0x1418a
movzbl -0x21(%rsp), %eax
orl $0x80, %eax
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %cl
movq -0x8(%rsp), %rax
movb %cl, (%rax)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rsp)
movb %al, -0x22(%rsp)
je 0x141c2
movq -0x8(%rsp), %rax
cmpq -0x10(%rsp), %rax
setb %al
movb %al, -0x22(%rsp)
movb -0x22(%rsp), %al
testb $0x1, %al
jne 0x14159
movq -0x8(%rsp), %rax
retq
// File: cpearce[P]OggIndex/src/Decoder.hpp
// Function: FisboneInfo::MessageHeaders[abi:cxx11]()
string MessageHeaders() {
    return
      "Content-Type: " + mContentType + "\r\n" +
      "Name: " + mName + "\r\n" +
      "Role: " + mRole + "\r\n";
  }

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq 0x118(%rsp), %rdx
movq %rdx, 0x18(%rsp)
addq $0x20, %rdx
leaq 0x9e53(%rip), %rsi      # 0x1e3df
leaq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x143c0
movq 0x20(%rsp), %rsi
leaq 0x9e23(%rip), %rdx      # 0x1e3ca
leaq 0x58(%rsp), %rdi
callq 0x14370
jmp 0x145b3
leaq 0x9e34(%rip), %rdx      # 0x1e3ee
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x14370
jmp 0x145cb
movq 0x18(%rsp), %rdx
addq $0x60, %rdx
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x148b0
jmp 0x145e8
leaq 0x9ddb(%rip), %rdx      # 0x1e3ca
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x14370
jmp 0x14606
leaq 0x9de8(%rip), %rdx      # 0x1e3f5
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x14370
jmp 0x14624
movq 0x18(%rsp), %rdx
addq $0x40, %rdx
leaq 0xf8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x148b0
jmp 0x14644
movq 0x8(%rsp), %rdi
leaq 0x9d7a(%rip), %rdx      # 0x1e3ca
leaq 0xf8(%rsp), %rsi
callq 0x14370
jmp 0x1465f
leaq 0xf8(%rsp), %rdi
callq 0x5260
leaq 0xd8(%rsp), %rdi
callq 0x5260
leaq 0xb8(%rsp), %rdi
callq 0x5260
leaq 0x98(%rsp), %rdi
callq 0x5260
leaq 0x78(%rsp), %rdi
callq 0x5260
leaq 0x58(%rsp), %rdi
callq 0x5260
leaq 0x38(%rsp), %rdi
callq 0x5260
movq 0x10(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1477a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x14770
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x14766
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x14759
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1474c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1473f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0x5260
leaq 0xd8(%rsp), %rdi
callq 0x5260
leaq 0xb8(%rsp), %rdi
callq 0x5260
leaq 0x98(%rsp), %rdi
callq 0x5260
leaq 0x78(%rsp), %rdi
callq 0x5260
leaq 0x58(%rsp), %rdi
callq 0x5260
leaq 0x38(%rsp), %rdi
callq 0x5260
movq 0x30(%rsp), %rdi
callq 0x57d0
nop
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: Clone(ogg_page*)
ogg_page*
Clone(ogg_page* p)
{
  ogg_page* q = new ogg_page();
  memcpy(q, p, sizeof(ogg_page));
  q->header = new unsigned char[p->header_len + p->body_len];
  q->body = q->header + q->header_len;
  memcpy(q->header, p->header, p->header_len);
  memcpy(q->body, p->body, p->body_len);
  assert(memcmp(p->header, q->header, q->header_len) == 0);
  assert(memcmp(p->body, q->body, q->body_len) == 0);
  assert(q->header_len == p->header_len);
  assert(q->body_len == p->body_len);
  return q;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x20, %edi
callq 0x53e0
movq %rax, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x5230
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
addq 0x18(%rax), %rdi
callq 0x5030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
addq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x5340
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x5340
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x51c0
cmpl $0x0, %eax
jne 0x15bc6
jmp 0x15be5
leaq 0x887d(%rip), %rdi      # 0x1e44a
leaq 0x88a7(%rip), %rsi      # 0x1e47b
movl $0x39, %edx
leaq 0x88a9(%rip), %rcx      # 0x1e489
callq 0x5280
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x51c0
cmpl $0x0, %eax
jne 0x15c0c
jmp 0x15c2b
leaq 0x8892(%rip), %rdi      # 0x1e4a5
leaq 0x8861(%rip), %rsi      # 0x1e47b
movl $0x3a, %edx
leaq 0x8863(%rip), %rcx      # 0x1e489
callq 0x5280
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x15c41
jmp 0x15c60
leaq 0x8888(%rip), %rdi      # 0x1e4d0
leaq 0x882c(%rip), %rsi      # 0x1e47b
movl $0x3b, %edx
leaq 0x882e(%rip), %rcx      # 0x1e489
callq 0x5280
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x15c76
jmp 0x15c95
leaq 0x8872(%rip), %rdi      # 0x1e4ef
leaq 0x87f7(%rip), %rsi      # 0x1e47b
movl $0x3c, %edx
leaq 0x87f9(%rip), %rcx      # 0x1e489
callq 0x5280
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: FileLength(char const*)
ogg_int64_t
FileLength(const char* aFileName)
{
  ifstream is;
  is.open (aFileName, ios::binary);
  is.seekg (0, ios::end);
  streampos length = is.tellg();
  is.close();
  return (ogg_int64_t)length;
}

// Assembly:
subq $0x258, %rsp            # imm = 0x258
movq %rdi, 0x250(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x54a0
movq 0x20(%rsp), %rdi
movq 0x250(%rsp), %rsi
movl $0x4, %edx
callq 0x5270
jmp 0x15d77
xorl %eax, %eax
movl %eax, %esi
leaq 0x48(%rsp), %rdi
movl $0x2, %edx
callq 0x5570
jmp 0x15d8c
leaq 0x48(%rsp), %rdi
callq 0x57b0
movq %rdx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
jmp 0x15da2
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x50a0
jmp 0x15dc2
leaq 0x28(%rsp), %rdi
callq 0xec80
movq %rax, 0x8(%rsp)
jmp 0x15dd3
leaq 0x48(%rsp), %rdi
callq 0x50e0
movq 0x8(%rsp), %rax
addq $0x258, %rsp            # imm = 0x258
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x50e0
movq 0x40(%rsp), %rdi
callq 0x57d0
nopl (%rax)
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: Clone(ogg_packet*)
ogg_packet*
Clone(ogg_packet* p)
{
  if (!p)
    return 0;
  ogg_packet* q = new ogg_packet();
  memcpy(q, p, sizeof(ogg_packet));
  q->packet = new unsigned char[p->bytes];
  memcpy(q->packet, p->packet, p->bytes);
  return q;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x15e2c
movq $0x0, 0x20(%rsp)
jmp 0x15ea9
movl $0x30, %edi
callq 0x53e0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x5230
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x30, %edx
callq 0x5340
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x5030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x5340
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: ReadPage(ogg_sync_state*, ogg_page*, std::istream&, unsigned long&)
bool ReadPage(ogg_sync_state* state,
              ogg_page* page,
              istream& stream,
              ogg_uint64_t& bytesRead)
{
  ogg_int32_t bytes = 0;
  ogg_int32_t r = 0;
  ogg_uint64_t intialBytesRead = bytesRead;
  while ((r = ogg_sync_pageout(state, page)) != 1) {
    char* buffer = ogg_sync_buffer(state, FILE_BUFFER_SIZE);
    assert(buffer);
    stream.read(buffer, FILE_BUFFER_SIZE);
    bytes = stream.gcount();
    bytesRead += bytes;
    if (bytes == 0) {
      // End of file
      assert(stream.eof());
      if (intialBytesRead != bytesRead) {
        cerr << "WARNING: Reached end of file, when expecting to find more data! "
             << "Page header may be incorrect!" << endl;
      }
      return false;
    }
    ogg_int32_t ret = ogg_sync_wrote(state, bytes);
    assert(ret == 0);
  }
  return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x5720
movl %eax, 0x18(%rsp)
cmpl $0x1, %eax
je 0x160a6
movq 0x38(%rsp), %rdi
movl $0x100000, %esi         # imm = 0x100000
callq 0x56c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x15f8f
jmp 0x15fae
leaq 0x8574(%rip), %rdi      # 0x1e50a
leaq 0x84de(%rip), %rsi      # 0x1e47b
movl $0x7e, %edx
leaq 0x8568(%rip), %rcx      # 0x1e511
callq 0x5280
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x5520
movq 0x28(%rsp), %rdi
callq 0x58d0
movl %eax, 0x1c(%rsp)
movslq 0x1c(%rsp), %rcx
movq 0x20(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
cmpl $0x0, 0x1c(%rsp)
jne 0x16066
movq 0x28(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x5850
testb $0x1, %al
jne 0x15ffe
jmp 0x16000
jmp 0x1601f
leaq 0x8551(%rip), %rdi      # 0x1e558
leaq 0x846d(%rip), %rsi      # 0x1e47b
movl $0x84, %edx
leaq 0x84f7(%rip), %rcx      # 0x1e511
callq 0x5280
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
je 0x1605f
movq 0x11fbb(%rip), %rdi     # 0x27ff0
leaq 0x8529(%rip), %rsi      # 0x1e565
callq 0x53d0
movq %rax, %rdi
leaq 0x855b(%rip), %rsi      # 0x1e5a6
callq 0x53d0
movq %rax, %rdi
movq 0x11f66(%rip), %rsi     # 0x27fc0
callq 0x5430
movb $0x0, 0x47(%rsp)
jmp 0x160ab
movq 0x38(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x5500
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x16082
jmp 0x160a1
leaq 0x6f7b(%rip), %rdi      # 0x1d004
leaq 0x83eb(%rip), %rsi      # 0x1e47b
movl $0x8c, %edx
leaq 0x8475(%rip), %rcx      # 0x1e511
callq 0x5280
jmp 0x15f55
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: CopyFileData(std::istream&, std::ostream&, long)
void
CopyFileData(istream& input, ostream& output, ogg_int64_t bytesToCopy)
{
  assert(input.good());
  assert(output.good());
  // Copy data in chunks at most 1mb in size.
  assert(bytesToCopy >= 0);
  assert((ogg_int64_t)FILE_BUFFER_SIZE < (ogg_int64_t)INT_MAX);
  ogg_int32_t len = (ogg_int32_t)min(bytesToCopy, (ogg_int64_t)FILE_BUFFER_SIZE);
  char* buf = new char[len];
  ogg_int64_t bytesCopied = 0;
  while (bytesCopied != bytesToCopy) {
    ogg_int64_t remaining = bytesToCopy - bytesCopied;
    ogg_int32_t x = (ogg_int32_t)min(remaining, (ogg_int64_t)len);
    input.read(buf, x);
    assert(x == input.gcount());
    output.write(buf, x);
    bytesCopied += x;
  }
  delete[] buf;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x5780
testb $0x1, %al
jne 0x1667a
jmp 0x1667c
jmp 0x1669b
leaq 0x737d(%rip), %rdi      # 0x1da00
leaq 0x7df1(%rip), %rsi      # 0x1e47b
movl $0xdd, %edx
leaq 0x804f(%rip), %rcx      # 0x1e6e5
callq 0x5280
movq 0x58(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x5780
testb $0x1, %al
jne 0x166b2
jmp 0x166b4
jmp 0x166d3
leaq 0x805f(%rip), %rdi      # 0x1e71a
leaq 0x7db9(%rip), %rsi      # 0x1e47b
movl $0xde, %edx
leaq 0x8017(%rip), %rcx      # 0x1e6e5
callq 0x5280
cmpq $0x0, 0x50(%rsp)
jl 0x166dd
jmp 0x166fc
leaq 0x8044(%rip), %rdi      # 0x1e728
leaq 0x7d90(%rip), %rsi      # 0x1e47b
movl $0xe0, %edx
leaq 0x7fee(%rip), %rcx      # 0x1e6e5
callq 0x5280
movq $0x100000, 0x40(%rsp)   # imm = 0x100000
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x9090
movq (%rax), %rax
movl %eax, 0x4c(%rsp)
movslq 0x4c(%rsp), %rdi
callq 0x5030
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x167f0
movq 0x50(%rsp), %rax
subq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movslq 0x4c(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x9090
movq (%rax), %rax
movl %eax, 0x24(%rsp)
movq 0x60(%rsp), %rdi
movq 0x38(%rsp), %rsi
movslq 0x24(%rsp), %rdx
callq 0x5520
movslq 0x24(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
callq 0x58d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x167a9
jmp 0x167c8
leaq 0x7f89(%rip), %rdi      # 0x1e739
leaq 0x7cc4(%rip), %rsi      # 0x1e47b
movl $0xe9, %edx
leaq 0x7f22(%rip), %rcx      # 0x1e6e5
callq 0x5280
movq 0x58(%rsp), %rdi
movq 0x38(%rsp), %rsi
movslq 0x24(%rsp), %rdx
callq 0x5550
movslq 0x24(%rsp), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x16733
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1680a
movq 0x8(%rsp), %rdi
callq 0x5540
addq $0x68, %rsp
retq
nop
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: GetChecksum(ogg_page*)
ogg_uint32_t
GetChecksum(ogg_page* page)
{
  assert(page != 0);
  assert(page->header != 0);
  assert(page->header_len > 25);
  return LEUint32(page->header + 22);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x1681e
jmp 0x1683d
leaq 0x7f28(%rip), %rdi      # 0x1e74d
leaq 0x7c4f(%rip), %rsi      # 0x1e47b
movl $0xf3, %edx
leaq 0x7f1f(%rip), %rcx      # 0x1e757
callq 0x5280
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x16849
jmp 0x16868
leaq 0x7f2c(%rip), %rdi      # 0x1e77c
leaq 0x7c24(%rip), %rsi      # 0x1e47b
movl $0xf4, %edx
leaq 0x7ef4(%rip), %rcx      # 0x1e757
callq 0x5280
movq (%rsp), %rax
cmpq $0x19, 0x8(%rax)
jle 0x16875
jmp 0x16894
leaq 0x7f12(%rip), %rdi      # 0x1e78e
leaq 0x7bf8(%rip), %rsi      # 0x1e47b
movl $0xf5, %edx
leaq 0x7ec8(%rip), %rcx      # 0x1e757
callq 0x5280
movq (%rsp), %rax
movq (%rax), %rdi
addq $0x16, %rdi
callq 0x168b0
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: LEUint32(unsigned char const*)
ogg_uint32_t
LEUint32(unsigned const char* p) {
  ogg_uint32_t i =  p[0] +
                   (p[1] << 8) + 
                   (p[2] << 16) +
                   (p[3] << 24);
  return i;  
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
movq -0x8(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x8(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movq -0x8(%rsp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x18, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: TheoraVersion(th_info*, unsigned char, unsigned char, unsigned char)
int TheoraVersion(th_info* info,
                  unsigned char maj,
                  unsigned char min,
                  unsigned char sub)
{
  ogg_uint32_t ver = (maj << 16) + (min << 8) + sub;
  ogg_uint32_t th_ver = (info->version_major << 16) +
                        (info->version_minor << 8) +
                        info->version_subminor;
  return (th_ver >= ver) ? 1 : 0;
}

// Assembly:
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rsp)
movb %dl, -0x9(%rsp)
movb %cl, -0xa(%rsp)
movb %al, -0xb(%rsp)
movzbl -0x9(%rsp), %eax
shll $0x10, %eax
movzbl -0xa(%rsp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movzbl -0xb(%rsp), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
shll $0x10, %eax
movq -0x8(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x8(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %edx
movl -0x10(%rsp), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovael %ecx, %eax
retq
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: CountPacketStarts(ogg_page*)
int
CountPacketStarts(ogg_page* page)
{
  int i;
  // If we're not continuing a packet, we're at a packet start.
  int packets_start = (ogg_page_continued(page) == 0) ? 1 : 0;
  int num_lacing_vals = page->header[26];
  unsigned char* lacing_vals = &page->header[27];
  for (i=1; i<num_lacing_vals; i++) {
    if (lacing_vals[i-1] < 0xff) {
      packets_start++;
    }
  }
  return packets_start;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5160
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movzbl 0x1a(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
addq $0x1b, %rax
movq %rax, 0x8(%rsp)
movl $0x1, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x16abd
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xff, %eax
jge 0x16aae
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x16ab0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x16a7f
movl 0x18(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: WriteLEUint64(unsigned char*, unsigned long)
unsigned char*
WriteLEUint64(unsigned char* p, const ogg_uint64_t num)
{
  ogg_int32_t i;
  ogg_uint64_t n = num;
  assert(p);
  for (i=0; i<8; i++) {
    p[i] = (unsigned char)(n & 0xff);
    n >>= 8;
  }
  assert(LEUint64(p) == num);
  return p + 8;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x16af2
jmp 0x16b11
leaq 0x738f(%rip), %rdi      # 0x1de88
leaq 0x797b(%rip), %rsi      # 0x1e47b
movl $0x12c, %edx            # imm = 0x12C
leaq 0x7c98(%rip), %rcx      # 0x1e7a4
callq 0x5280
movl $0x0, 0x14(%rsp)
cmpl $0x8, 0x14(%rsp)
jge 0x16b55
movq 0x8(%rsp), %rax
andq $0xff, %rax
movb %al, %dl
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
shrq $0x8, %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x16b19
movq 0x20(%rsp), %rdi
callq 0x16ba0
cmpq 0x18(%rsp), %rax
jne 0x16b68
jmp 0x16b87
leaq 0x7c77(%rip), %rdi      # 0x1e7e6
leaq 0x7905(%rip), %rsi      # 0x1e47b
movl $0x131, %edx            # imm = 0x131
leaq 0x7c22(%rip), %rcx      # 0x1e7a4
callq 0x5280
movq 0x20(%rsp), %rax
addq $0x8, %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: WriteLEInt64(unsigned char*, long)
unsigned char*
WriteLEInt64(unsigned char* p, const ogg_int64_t num)
{
  ogg_int64_t n = num;
  ogg_int32_t i;
  assert(p);
  for (i=0; i<8; i++) {
    p[i] = (unsigned char)(n & 0xff);
    n >>= 8;
  }
  assert(LEInt64(p) == num);
  return p + 8;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x16c12
jmp 0x16c31
leaq 0x726f(%rip), %rdi      # 0x1de88
leaq 0x785b(%rip), %rsi      # 0x1e47b
movl $0x13a, %edx            # imm = 0x13A
leaq 0x7bcd(%rip), %rcx      # 0x1e7f9
callq 0x5280
movl $0x0, 0xc(%rsp)
cmpl $0x8, 0xc(%rsp)
jge 0x16c75
movq 0x10(%rsp), %rax
andq $0xff, %rax
movb %al, %dl
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
sarq $0x8, %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x16c39
movq 0x20(%rsp), %rdi
callq 0x16cc0
cmpq 0x18(%rsp), %rax
jne 0x16c88
jmp 0x16ca7
leaq 0x7baa(%rip), %rdi      # 0x1e839
leaq 0x77e5(%rip), %rsi      # 0x1e47b
movl $0x13f, %edx            # imm = 0x13F
leaq 0x7b57(%rip), %rcx      # 0x1e7f9
callq 0x5280
movq 0x20(%rsp), %rax
addq $0x8, %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: WriteLEUint32(unsigned char*, unsigned int)
unsigned char*
WriteLEUint32(unsigned char* p, const ogg_uint32_t num)
{
  ogg_uint32_t n = num;
  ogg_int32_t i;
  assert(p);
  for (i=0; i<4; i++) {
    p[i] = (unsigned char)(n & 0xff);
    n >>= 8;
  }
  assert(LEUint32(p) == num);
  return p + 4;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x16d2f
jmp 0x16d4e
leaq 0x7152(%rip), %rdi      # 0x1de88
leaq 0x773e(%rip), %rsi      # 0x1e47b
movl $0x148, %edx            # imm = 0x148
leaq 0x7b02(%rip), %rcx      # 0x1e84b
callq 0x5280
movl $0x0, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jge 0x16d8d
movl 0x8(%rsp), %eax
andl $0xff, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x8(%rsp), %eax
shrl $0x8, %eax
movl %eax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x16d56
movq 0x10(%rsp), %rdi
callq 0x168b0
cmpl 0xc(%rsp), %eax
jne 0x16d9f
jmp 0x16dbe
leaq 0x7ae7(%rip), %rdi      # 0x1e88d
leaq 0x76ce(%rip), %rsi      # 0x1e47b
movl $0x14d, %edx            # imm = 0x14D
leaq 0x7a92(%rip), %rcx      # 0x1e84b
callq 0x5280
movq 0x10(%rsp), %rax
addq $0x4, %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: WriteLEInt32(unsigned char*, int)
unsigned char*
WriteLEInt32(unsigned char* p, const ogg_int32_t num)
{
  ogg_int32_t n = num;
  ogg_int32_t i;
  assert(p);
  for (i=0; i<4; i++) {
    p[i] = (unsigned char)(n & 0xff);
    n >>= 8;
  }
  assert(LEInt32(p) == num);
  return p + 4;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x16def
jmp 0x16e0e
leaq 0x7092(%rip), %rdi      # 0x1de88
leaq 0x767e(%rip), %rsi      # 0x1e47b
movl $0x156, %edx            # imm = 0x156
leaq 0x7a97(%rip), %rcx      # 0x1e8a0
callq 0x5280
movl $0x0, 0x4(%rsp)
cmpl $0x4, 0x4(%rsp)
jge 0x16e4d
movl 0x8(%rsp), %eax
andl $0xff, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x8(%rsp), %eax
sarl $0x8, %eax
movl %eax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x16e16
movq 0x10(%rsp), %rdi
callq 0x16e90
cmpl 0xc(%rsp), %eax
jne 0x16e5f
jmp 0x16e7e
leaq 0x7a7a(%rip), %rdi      # 0x1e8e0
leaq 0x760e(%rip), %rsi      # 0x1e47b
movl $0x15b, %edx            # imm = 0x15B
leaq 0x7a27(%rip), %rcx      # 0x1e8a0
callq 0x5280
movq 0x10(%rsp), %rax
addq $0x4, %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: WriteLEUint16(unsigned char*, unsigned short)
unsigned char*
WriteLEUint16(unsigned char* p, const ogg_uint16_t num)
{
  ogg_uint16_t n = num;
  assert(p);
  p[0] = (unsigned char)(n & 0xff);
  p[1] = (unsigned char)((n >> 8) & 0xff);
  assert(LEUint16(p) == num);
  return p + 2;
}

// Assembly:
subq $0x18, %rsp
movw %si, %ax
movq %rdi, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movw 0xe(%rsp), %ax
movw %ax, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x16ef5
jmp 0x16f14
leaq 0x6f8c(%rip), %rdi      # 0x1de88
leaq 0x7578(%rip), %rsi      # 0x1e47b
movl $0x163, %edx            # imm = 0x163
leaq 0x79e3(%rip), %rcx      # 0x1e8f2
callq 0x5280
movzwl 0xc(%rsp), %eax
andl $0xff, %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
movzwl 0xc(%rsp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x10(%rsp), %rdi
callq 0x16f90
movzwl %ax, %eax
movzwl 0xe(%rsp), %ecx
cmpl %ecx, %eax
jne 0x16f56
jmp 0x16f75
leaq 0x79d7(%rip), %rdi      # 0x1e934
leaq 0x7517(%rip), %rsi      # 0x1e47b
movl $0x166, %edx            # imm = 0x166
leaq 0x7982(%rip), %rcx      # 0x1e8f2
callq 0x5280
movq 0x10(%rsp), %rax
addq $0x2, %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/Utils.cpp
// Function: Tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Tokenize(const string& str,
              vector<string>& tokens,
              const string& delimiter)
{
  string::size_type matchStart = 0;
  string::size_type matchEnd = str.find(delimiter, matchStart);
  while (matchEnd != string::npos && matchStart != matchEnd)
  {
    // Found a token, add it to the vector.
    tokens.push_back(str.substr(matchStart, matchEnd - matchStart));
    matchStart = matchEnd + delimiter.size();
    matchEnd = str.find(delimiter, matchStart);
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x58e0
movq %rax, 0x50(%rsp)
xorl %eax, %eax
cmpq $-0x1, 0x50(%rsp)
movb %al, 0x23(%rsp)
je 0x17014
movq 0x58(%rsp), %rax
cmpq 0x50(%rsp), %rax
setne %al
movb %al, 0x23(%rsp)
movb 0x23(%rsp), %al
testb $0x1, %al
jne 0x17021
jmp 0x170c3
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
subq %rdx, %rcx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5410
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x17120
jmp 0x1705d
leaq 0x30(%rsp), %rdi
callq 0x5260
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x52d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x58e0
movq %rax, 0x50(%rsp)
jmp 0x16ff5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5260
jmp 0x170c8
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x57d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cpearce[P]OggIndex/src/Validate.cpp
// Function: ReadAllHeaders(Theora*, Vorbis*, void*, Skeleton*)
static bool ReadAllHeaders(Theora* theora, Vorbis* vorbis, Kate* kate, Skeleton* skeleton)
{
  return (theora || vorbis || kate || skeleton) &&
         (!theora || theora->mReadHeaders) &&
         (!vorbis || vorbis->mReadHeaders) &&
#ifdef HAVE_KATE
         (!kate || kate->mReadHeaders) &&
#endif
         (!skeleton || skeleton->mReadHeaders);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
cmpq $0x0, -0x8(%rsp)
jne 0x1909a
cmpq $0x0, -0x10(%rsp)
jne 0x1909a
cmpq $0x0, -0x18(%rsp)
jne 0x1909a
xorl %eax, %eax
cmpq $0x0, -0x20(%rsp)
movb %al, -0x21(%rsp)
je 0x190ee
cmpq $0x0, -0x8(%rsp)
je 0x190b3
movq -0x8(%rsp), %rcx
xorl %eax, %eax
testb $0x1, 0xc(%rcx)
movb %al, -0x21(%rsp)
je 0x190ee
cmpq $0x0, -0x10(%rsp)
je 0x190cc
movq -0x10(%rsp), %rcx
xorl %eax, %eax
testb $0x1, 0xc(%rcx)
movb %al, -0x21(%rsp)
je 0x190ee
movb $0x1, %al
cmpq $0x0, -0x20(%rsp)
movb %al, -0x22(%rsp)
je 0x190e6
movq -0x20(%rsp), %rax
movb 0xc(%rax), %al
movb %al, -0x22(%rsp)
movb -0x22(%rsp), %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nop
// File: cpearce[P]OggIndex/src/Validate.cpp
// Function: Theora::AllBufferedGranuleposInvalid()
bool AllBufferedGranuleposInvalid() {
    list<PacketInfo>::iterator itr = mBuffer.begin();
    while (itr != mBuffer.end()) {
      PacketInfo* p = &(*itr);
      assert(p->granulepos == -1);
      itr++;      
    }
    return true;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x1a5d0
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x1a620
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1a600
testb $0x1, %al
jne 0x1a23f
jmp 0x1a28d
leaq 0x28(%rsp), %rdi
callq 0x1a650
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $-0x1, (%rax)
jne 0x1a25b
jmp 0x1a27a
leaq 0x4c58(%rip), %rdi      # 0x1eeba
leaq 0x46de(%rip), %rsi      # 0x1e947
movl $0x7b, %edx
leaq 0x4c59(%rip), %rcx      # 0x1eece
callq 0x5280
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1a670
movq %rax, 0x10(%rsp)
jmp 0x1a214
movb $0x1, %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/Validate.cpp
// Function: Theora::Time(long)
ogg_int64_t Time(ogg_int64_t granulepos) {
    ogg_int64_t frame_index = th_granule_frame(mCtx, granulepos);
    ogg_int64_t start_time = (1000 * mInfo.fps_denominator * frame_index) /
                              mInfo.fps_numerator;
    return start_time;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x228(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x50b0
movq (%rsp), %rcx
movq %rax, 0x10(%rsp)
imull $0x3e8, 0x1e0(%rcx), %eax # imm = 0x3E8
movl %eax, %eax
imulq 0x10(%rsp), %rax
movl 0x1dc(%rcx), %ecx
cqto
idivq %rcx
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: cpearce[P]OggIndex/src/Validate.cpp
// Function: Theora::NextKeyframeTime()
ogg_int64_t NextKeyframeTime() {
    while (mBuffer.size() > 0 && mBuffer.front().granulepos != -1) {
      PacketInfo p = mBuffer.front();
      mBuffer.pop_front();
      if (p.isKeyFrame) {
        assert(p.granulepos != -1);
        return Time(p.granulepos);
      }
    }
    return -1;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x1a4b0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, 0xf(%rsp)
jbe 0x1a52f
movq 0x10(%rsp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x1a480
cmpq $-0x1, (%rax)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1a539
jmp 0x1a5b7
movq 0x10(%rsp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x1a480
movq 0x10(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x1aab0
testb $0x1, 0x20(%rsp)
je 0x1a5b2
cmpq $-0x1, 0x18(%rsp)
je 0x1a57d
jmp 0x1a59c
leaq 0x4976(%rip), %rdi      # 0x1eefa
leaq 0x43bc(%rip), %rsi      # 0x1e947
movl $0x70, %edx
leaq 0x4976(%rip), %rcx      # 0x1ef0d
callq 0x5280
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1a420
movq %rax, 0x30(%rsp)
jmp 0x1a5c0
jmp 0x1a4f3
movq $-0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: cpearce[P]OggIndex/src/Validate.cpp
// Function: Vorbis::Reset()
virtual void Reset() {
    ogg_stream_reset(&mStreamState);  
    ogg_packet op;
    assert(ogg_stream_packetout(&mStreamState, &op) == 0);
    if (mReadHeaders) {
      vorbis_synthesis_restart(&mDsp);
    }
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
callq 0x53f0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x10(%rsp), %rsi
callq 0x5680
cmpl $0x0, %eax
jne 0x1b026
jmp 0x1b045
leaq 0x3f07(%rip), %rdi      # 0x1ef34
leaq 0x3913(%rip), %rsi      # 0x1e947
movl $0x116, %edx            # imm = 0x116
leaq 0x3f60(%rip), %rcx      # 0x1efa0
callq 0x5280
movq 0x8(%rsp), %rax
testb $0x1, 0xc(%rax)
je 0x1b061
movq 0x8(%rsp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0x5610
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: todo314[P]pruned-monte-carlo/src/pmc.cpp
// Function: PrunedEstimater::update(std::vector<long long, std::allocator<long long>>&)
void PrunedEstimater::update(vector<long long> &sums) {
	for (int i = 0; i < (int) up.size(); i++) {
		int v = up[i];
		if (!flag) {
			sums[v] -= sigmas[comp[v]];
		}
	}
	for (int i = 0; i < (int) up.size(); i++) {
		int v = up[i];
		sums[v] += sigma1(v);
	}
	flag = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x80, %rdi
callq 0x71f0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x5505
movq -0x28(%rbp), %rdi
addq $0x80, %rdi
movslq -0x14(%rbp), %rsi
callq 0x29c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x18(%rbp)
testb $0x1, 0x1c8(%rax)
jne 0x54f5
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x40(%rbp)
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x29c0
movq -0x40(%rbp), %rdi
movslq (%rax), %rsi
callq 0x29c0
movslq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x7c30
movq -0x38(%rbp), %rdx
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x54f7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x545f
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x80, %rdi
callq 0x71f0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x5579
movq -0x28(%rbp), %rdi
addq $0x80, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x29c0
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x4cd0
cltq
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x7c30
movq -0x50(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x550c
movq -0x28(%rbp), %rax
movb $0x0, 0x1c8(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)