LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/Decoder.cpp
// Function: Decoder::Create(ogg_page*)
Decoder* Decoder::Create(ogg_page* page)
{
  assert(ogg_page_bos(page));
  ogg_uint32_t serialno = ogg_page_serialno(page);
  if (page->body_len > 8 &&
      strncmp("theora", (const char*)page->body+1, 6) == 0)
  {
    return new TheoraDecoder(serialno);
  } else if (page->body_len > 8 &&
             strncmp("vorbis", (const char*)page->body+1, 6) == 0)
  {
    return new VorbisDecoder(serialno);
#ifdef HAVE_KATE
  } else if (page->body_len > 8 &&
             memcmp("kate\0\0\0", (const char*)page->body+1, 7) == 0)
  {
    return new KateDecoder(serialno);
#endif
  } else if (page->body_len > 8 &&
             strncmp("fishead", (const char*)page->body, 8) == 0)
  {
    return new SkeletonDecoder(serialno);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x4690
testl %eax, %eax
je 0x510f
movq %r14, %rdi
callq 0x42c0
cmpq $0x9, 0x18(%r14)
jl 0x50b8
movl %eax, %ebx
movq 0x10(%r14), %r14
leaq 0x1(%r14), %r15
leaq 0x965a(%rip), %rdi      # 0xe6d7
pushq $0x6
popq %rdx
movq %r15, %rsi
callq 0x4190
testl %eax, %eax
je 0x50bd
leaq 0x9788(%rip), %rdi      # 0xe81b
pushq $0x6
popq %rdx
movq %r15, %rsi
callq 0x4190
testl %eax, %eax
je 0x50d6
leaq 0x9123(%rip), %rdi      # 0xe1cc
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x4190
testl %eax, %eax
je 0x50ef
xorl %r14d, %r14d
jmp 0x5106
movl $0x290, %edi            # imm = 0x290
callq 0x4350
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x5166
jmp 0x5106
movl $0x388, %edi            # imm = 0x388
callq 0x4350
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x5232
jmp 0x5106
movl $0x228, %edi            # imm = 0x228
callq 0x4350
movq %rax, %r14
movq %rax, %rdi
movl %ebx, %esi
callq 0x49c6
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9077(%rip), %rdi      # 0xe18d
leaq 0x8ef0(%rip), %rsi      # 0xe00d
leaq 0x907c(%rip), %rcx      # 0xe1a0
movl $0x3ed, %edx            # imm = 0x3ED
callq 0x4210
movq %rax, %rbx
movl $0x228, %esi            # imm = 0x228
jmp 0x514a
movq %rax, %rbx
movl $0x388, %esi            # imm = 0x388
jmp 0x514a
movq %rax, %rbx
movl $0x290, %esi            # imm = 0x290
movq %r14, %rdi
callq 0x4370
movq %rbx, %rdi
callq 0x4680
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/Decoder.cpp
// Function: TheoraDecoder::GetFisboneInfo()
virtual FisboneInfo GetFisboneInfo() {
    FisboneInfo f;
    f.mGranNumer = mInfo.fps_numerator;
    f.mGranDenom = mInfo.fps_denominator;
    f.mPreroll = 0;
    f.mGranuleShift = mInfo.keyframe_granule_shift;
    f.mRadix = 0;
    f.mContentType = "video/theora";
    f.mRole = "video/main";
    f.mName = "video_1";
    return f;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6706
movsd 0x1d4(%r14), %xmm0
xorps %xmm1, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movups %xmm0, (%rbx)
andl $0x0, 0x10(%rbx)
movl 0x1f4(%r14), %eax
movl %eax, 0x14(%rbx)
andl $0x0, 0x18(%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x87cb(%rip), %rsi      # 0xe6d1
callq 0x46f0
leaq 0x40(%rbx), %rdi
leaq 0x87c8(%rip), %rsi      # 0xe6de
callq 0x46f0
leaq 0x60(%rbx), %rdi
leaq 0x87c3(%rip), %rsi      # 0xe6e9
callq 0x46f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6744
movq %r14, %rdi
callq 0x4680
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/Decoder.cpp
// Function: TheoraDecoder::DumpPacket(TheoraDecoder::Frame&)
void DumpPacket(Frame& f) {
    if (gOptions.GetDumpPackets() ||
        (f.is_keyframe && gOptions.GetDumpKeyPackets()))
    {
      cout << "[T] " << (f.is_keyframe ? "keyframe" : "frame")
           << " time_ms=[" << StartTime(f.granulepos) << ","
           << EndTime(f.granulepos) << "] granulepos=" << f.granulepos
           << " packetno=" << f.packetno
           << (f.e_o_s ? " eos" : "")
           << endl;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf378(%rip), %r15      # 0x15400
movq %r15, %rdi
callq 0x82d6
testb %al, %al
je 0x617b
movq 0xef31(%rip), %rdi      # 0x14fd0
leaq 0x851f(%rip), %rsi      # 0xe5c5
callq 0x4340
leaq 0x8518(%rip), %rcx      # 0xe5ca
leaq 0x8514(%rip), %rsi      # 0xe5cd
cmpb $0x0, 0x10(%rbx)
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x4340
leaq 0x86ec(%rip), %rsi      # 0xe7bc
movq %rax, %rdi
callq 0x4340
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x6012
movq %r15, %rdi
movq %rax, %rsi
callq 0x4320
leaq 0x8fe5(%rip), %rsi      # 0xf0de
movq %rax, %rdi
callq 0x4340
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x6040
movq %r15, %rdi
movq %rax, %rsi
callq 0x4320
leaq 0x84b1(%rip), %rsi      # 0xe5d3
movq %rax, %rdi
callq 0x4340
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x4320
leaq 0x84a4(%rip), %rsi      # 0xe5e1
movq %rax, %rdi
callq 0x4340
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x4320
leaq 0x8292(%rip), %rcx      # 0xe3e9
leaq 0x928c(%rip), %rsi      # 0xf3ea
cmpb $0x0, 0x11(%rbx)
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x41b0
cmpb $0x1, 0x10(%rbx)
jne 0x618c
cmpb $0x1, 0x1(%r15)
je 0x6098
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/Decoder.cpp
// Function: VorbisDecoder::GetFisboneInfo()
virtual FisboneInfo GetFisboneInfo() {
    FisboneInfo f;
    f.mGranNumer = mInfo.rate;
    f.mGranDenom = 1;
    f.mPreroll = 2;
    f.mGranuleShift = 0;
    f.mRadix = 0;
    f.mContentType = "audio/vorbis";
    f.mRole = "audio/main";
    f.mName = "audio_1";
    return f;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6706
movq 0x1e8(%r14), %rax
movq %rax, (%rbx)
movq $0x1, 0x8(%rbx)
movq $0x2, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x7a61(%rip), %rsi      # 0xe815
callq 0x46f0
leaq 0x40(%rbx), %rdi
leaq 0x7a5e(%rip), %rsi      # 0xe822
callq 0x46f0
leaq 0x60(%rbx), %rdi
leaq 0x7a59(%rip), %rsi      # 0xe82d
callq 0x46f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6744
movq %r14, %rdi
callq 0x4680
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/Options.cpp
// Function: Options::PrintHelp()
void Options::PrintHelp() {
  cout
    << "OggIndex " << VERSION << " (Skeleton " << SKELETON_VERSION_MAJOR
    << "." << SKELETON_VERSION_MINOR << ")" << endl
    << endl
    << "Indexes an Ogg file to enable faster seeking." << endl
    << endl
    << "Usage:" << endl
    << "  OggIndex [-i <interval> -v -d -k -p -m -o <out filename>] <in filename>" << endl
    << endl
    << "Options:" << endl
    << "  -i <interval>  --  minimum <interval> in ms between keyframes (default 2000)" << endl
    << "  -v             --  verify the index in the output file" << endl
    << "  -d             --  dump packet info to stdout" << endl
    << "  -k             --  dump only keyframe packet info to stdout" << endl
    << "  -p             --  dump page info to stdout" << endl
    << "  -m             --  dump stream keyframe merge info to stdout" << endl
    << "  -o <filename>  --  use <filename> as the output filename" << endl
    << endl
    << "If no output filename is specified, the indexed ogg file is written" << endl
    << "into <in filename>.indexed.ogg" << endl 
    << endl;
}

// Assembly:
pushq %rax
movq 0xccea(%rip), %rdi      # 0x14fd0
leaq 0x68c3(%rip), %rsi      # 0xebb0
callq 0x4340
leaq 0x68c1(%rip), %rsi      # 0xebba
movq %rax, %rdi
callq 0x4340
leaq 0x68bc(%rip), %rsi      # 0xebc4
movq %rax, %rdi
callq 0x4340
pushq $0x4
popq %rsi
movq %rax, %rdi
callq 0x4650
leaq 0x684b(%rip), %rsi      # 0xeb6d
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
xorl %esi, %esi
callq 0x4650
leaq 0x763b(%rip), %rsi      # 0xf976
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
callq 0x41b0
leaq 0x6876(%rip), %rsi      # 0xebd0
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
callq 0x41b0
leaq 0x6885(%rip), %rsi      # 0xebfe
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
leaq 0x6875(%rip), %rsi      # 0xec05
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
callq 0x41b0
leaq 0x68a0(%rip), %rsi      # 0xec4f
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
leaq 0x6892(%rip), %rsi      # 0xec58
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
leaq 0x68ca(%rip), %rsi      # 0xeca7
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
leaq 0x68ec(%rip), %rsi      # 0xece0
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
leaq 0x6905(%rip), %rsi      # 0xed10
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
leaq 0x692c(%rip), %rsi      # 0xed4e
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
leaq 0x6943(%rip), %rsi      # 0xed7c
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
leaq 0x696b(%rip), %rsi      # 0xedbb
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
callq 0x41b0
leaq 0x6987(%rip), %rsi      # 0xedf6
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
leaq 0x69b4(%rip), %rsi      # 0xee3a
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
popq %rax
jmp 0x41b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/Options.cpp
// Function: Options::Parse(int, char**)
bool Options::Parse(int argc, char** argv) {
  const char* error = 0;
  if (!DoParse(argc, argv, &error)) {
    PrintHelp();
    cout << error << endl;
    return false;
  }
  cout << "Writing output to '" << mOutputFilename.c_str() << "'" << endl;
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsp, %rcx
andq $0x0, (%rcx)
callq 0x850c
movl %eax, %ebx
testb %al, %al
je 0x84e4
movq 0xcb10(%rip), %rdi      # 0x14fd0
leaq 0x6992(%rip), %rsi      # 0xee59
callq 0x4340
movq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x4340
leaq 0x698c(%rip), %rsi      # 0xee6b
movq %rax, %rdi
jmp 0x84f4
callq 0x82de
movq (%rsp), %rsi
movq 0xcadc(%rip), %rdi      # 0x14fd0
callq 0x4340
movq %rax, %rdi
callq 0x41b0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/Options.cpp
// Function: IsArgument(char const*)
static bool
IsArgument(const char* s) {
  return strcmp(s, "-v") == 0 ||
         strcmp(s, "-d") == 0 ||
         strcmp(s, "-k") == 0 ||
         strcmp(s, "-p") == 0 ||
         strcmp(s, "-o") == 0 ||
         strcmp(s, "-m") == 0 ||
         strcmp(s, "-i") == 0;
}

// Assembly:
cmpb $0x2d, (%rdi)
jne 0x87fb
cmpb $0x76, 0x1(%rdi)
jne 0x87b1
cmpb $0x0, 0x2(%rdi)
je 0x87fe
cmpb $0x64, 0x1(%rdi)
jne 0x87bd
cmpb $0x0, 0x2(%rdi)
je 0x87fe
cmpb $0x6b, 0x1(%rdi)
jne 0x87c9
cmpb $0x0, 0x2(%rdi)
je 0x87fe
cmpb $0x70, 0x1(%rdi)
jne 0x87d5
cmpb $0x0, 0x2(%rdi)
je 0x87fe
cmpb $0x6f, 0x1(%rdi)
jne 0x87e1
cmpb $0x0, 0x2(%rdi)
je 0x87fe
cmpb $0x6d, 0x1(%rdi)
jne 0x87ed
cmpb $0x0, 0x2(%rdi)
je 0x87fe
cmpb $0x69, 0x1(%rdi)
jne 0x87fb
cmpb $0x0, 0x2(%rdi)
sete %al
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movups %xmm0, 0x34(%rdi)
movups %xmm0, 0x44(%rdi)
movups %xmm0, 0x54(%rdi)
andl $0x0, 0x64(%rdi)
movq %r8, 0x68(%rdi)
movq 0x18(%rsi), %r12
addq $0x8, %r14
leaq 0x8(%rsp), %r15
cmpq %r14, %r12
je 0x88b7
movq 0x28(%r12), %r13
movq %r13, 0x8(%rsp)
movq (%r13), %rax
movq %r13, %rdi
callq *0x28(%rax)
cmpl $0x1, %eax
je 0x8886
movq (%r13), %rax
movq %r13, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x8886
movq (%r13), %rax
movq %r13, %rdi
callq *0x28(%rax)
cmpl $0x3, %eax
jne 0x8891
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa012
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x4, %eax
jne 0x88aa
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rbx)
movq %r12, %rdi
callq 0x4250
movq %rax, %r12
jmp 0x884a
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x88d7
movl 0x1a0(%rax), %eax
movl %eax, 0x30(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %edi, %edi
callq 0x4310
movl %eax, %edi
callq 0x4330
callq 0x40d0
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorl %esi, %esi
movl %esi, %esi
cmpq %rsi, %rdx
jbe 0x88c6
movq (%rcx,%rsi,8), %rdi
incl %esi
cmpl %eax, 0x1a0(%rdi)
jne 0x88fa
jmp 0x88e5
movq %rax, %r14
leaq 0x50(%rbx), %rdi
leaq 0x38(%rbx), %r15
callq 0x7e44
movq %r15, %rdi
callq 0x6e66
movq %rbx, %rdi
callq 0xa3e0
movq %r14, %rdi
callq 0x4680
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
xorl %r12d, %r12d
pushq $0x30
popq %r15
movl %r12d, %r12d
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x898f
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x8982
movq %rax, %rdi
callq 0x4440
movq (%r14), %rax
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
callq 0x4370
incl %r12d
jmp 0x8950
movq %rbx, %rdi
callq 0x89c4
leaq 0x50(%rbx), %rdi
callq 0x7e44
movq %r14, %rdi
callq 0x6e66
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa3e0
movq %rax, %rdi
callq 0x515a
nop
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/SkeletonEncoder.cpp
// Function: SkeletonEncoder::AddBosPacket()
void
SkeletonEncoder::AddBosPacket()
{
  // Should not call this more than once, this should be the first packet.
  assert(mPacketCount == 0);

  // Allocate packet to return...
  ogg_packet* bos = new ogg_packet();
  memset(bos, 0, sizeof(ogg_packet));
  bos->packet = new unsigned char[SKELETON_4_0_HEADER_LENGTH];
  memset(bos->packet, 0, SKELETON_4_0_HEADER_LENGTH);
  bos->bytes = SKELETON_4_0_HEADER_LENGTH;
  bos->b_o_s = 1;
  
  if (mSkeletonDecoder) {
    // We already have a skeleton track. Use what data we can from its
    // bos packet.
    ogg_packet* original = mSkeletonDecoder->mPackets.front();
    memcpy(bos->packet, original->packet, SKELETON_3_0_HEADER_LENGTH);
  } else {
    // We need to construct the skeleton bos packet...
    memcpy(bos->packet, "fishead", 8);
    
    WriteLEUint64(bos->packet + SKELETON_PRES_TIME_DENOM_OFFSET, 1000);
    WriteLEUint64(bos->packet + SKELETON_BASE_TIME_DENOM_OFFSET, 1000);
  }
  
  // Set the version fields.
  WriteLEUint16(bos->packet + SKELETON_VERSION_MAJOR_OFFSET, SKELETON_VERSION_MAJOR);
  WriteLEUint16(bos->packet + SKELETON_VERSION_MINOR_OFFSET, SKELETON_VERSION_MINOR);
  
  WriteLEUint64(bos->packet + SKELETON_CONTENT_OFFSET, mContentOffset);

  mPacketCount++;

  mIndexPackets.push_back(bos);

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x34(%rdi)
jne 0x8b13
movq %rdi, %rbx
pushq $0x30
popq %rdi
callq 0x4350
movq %rax, %r14
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
pushq $0x50
popq %rdi
callq 0x4030
movq %rax, %rdi
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movq $0x50, 0x8(%r14)
movq $0x1, 0x10(%r14)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x8aa0
movq 0x1d0(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movups %xmm3, 0x30(%rdi)
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
jmp 0x8acf
movabsq $0x64616568736966, %rax # imm = 0x64616568736966
movq %rax, (%rdi)
addq $0x14, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0xafcd
movq (%r14), %rdi
addq $0x24, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0xafcd
movq (%r14), %rdi
addq $0x8, %rdi
pushq $0x4
popq %rsi
callq 0xb176
movq (%r14), %rdi
addq $0xa, %rdi
xorl %esi, %esi
callq 0xb176
movq (%r14), %rdi
addq $0x48, %rdi
movq 0x68(%rbx), %rsi
callq 0xafcd
incl 0x34(%rbx)
addq $0x38, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa030
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x64d6(%rip), %rdi      # 0xeff0
leaq 0x64e1(%rip), %rsi      # 0xf002
leaq 0x64f2(%rip), %rcx      # 0xf01a
pushq $0x7e
popq %rdx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x30
popq %rdi
callq 0x4350
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x1, 0x18(%rax)
movslq 0x34(%rbx), %rcx
movq %rcx, 0x28(%rax)
leal 0x1(%rcx), %eax
movl %eax, 0x34(%rbx)
addq $0x38, %rbx
movq %rbx, %rdi
callq 0xa030
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, (%rsi)
movq %rdi, %rax
xorl %ecx, %ecx
xorl %edx, %edx
movzbl (%rax), %edi
movl %edi, %r8d
andl $0x7f, %r8d
shlq %cl, %r8
orq %r8, %rdx
movq %rdx, (%rsi)
addq $0x7, %rcx
incq %rax
testb %dil, %dil
jns 0x9966
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
xorl %eax, %eax
movl %eax, %r15d
movq 0x50(%r14), %rax
movq 0x58(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jbe 0x9a1a
movq (%rax,%r15,8), %rdi
addq 0x8(%rdi), %rbx
addq 0x18(%rdi), %rbx
callq 0x46b0
leal 0x1(%r15), %eax
jmp 0x99ec
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorl %edi, %edi
movl %edi, %edi
cmpq %rdi, %rdx
jbe 0x9b20
movq (%rcx,%rdi,8), %rax
incl %edi
cmpl %esi, 0x1a0(%rax)
jne 0x9b0a
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %rdx
leaq 0x5250(%rip), %rsi      # 0xf3fd
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
callq 0xa0f8
leaq 0x5224(%rip), %rdx      # 0xf3e8
movq %rsp, %rdi
movq %r15, %rsi
callq 0xa0d9
leaq 0x5236(%rip), %rdx      # 0xf40c
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xa0d9
leaq 0x60(%r14), %rdx
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xa32b
leaq 0x51eb(%rip), %rdx      # 0xf3e8
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xa0d9
leaq 0x5200(%rip), %rdx      # 0xf413
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xa0d9
addq $0x40, %r14
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq %r14, %rdx
callq 0xa32b
leaq 0x51a0(%rip), %rdx      # 0xf3e8
leaq 0xa0(%rsp), %rsi
movq %rbx, %rdi
callq 0xa0d9
leaq 0xa0(%rsp), %rdi
callq 0x4170
leaq 0x80(%rsp), %rdi
callq 0x4170
leaq 0x60(%rsp), %rdi
callq 0x4170
leaq 0x40(%rsp), %rdi
callq 0x4170
leaq 0x20(%rsp), %rdi
callq 0x4170
movq %rsp, %rdi
callq 0x4170
leaq 0xc0(%rsp), %rdi
callq 0x4170
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x4170
jmp 0xa2ca
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x4170
jmp 0xa2dc
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x4170
jmp 0xa2eb
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4170
jmp 0xa2fa
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4170
movq %rsp, %rdi
callq 0x4170
leaq 0xc0(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4680
movq %rax, %rbx
jmp 0xa304
movq %rax, %rbx
jmp 0xa30c
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x4350
movq %rax, %rbx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq 0x8(%r14), %r13
movq 0x18(%r14), %rbp
movq %rbp, %rdi
addq %r13, %rdi
callq 0x4030
movq %rax, %r15
movq %rax, (%rbx)
movq 0x8(%rbx), %rax
movq %rax, 0x20(%rsp)
addq %r15, %rax
movq %rax, 0x10(%rbx)
movq (%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
movq %r13, 0x10(%rsp)
movq %r13, %rdx
movq %rax, %r13
callq 0x42b0
movq 0x10(%r14), %rsi
movq %r13, %rdi
movq %rsi, 0x18(%rsp)
movq %rbp, 0x8(%rsp)
movq %rbp, %rdx
callq 0x42b0
movq %r12, %rdi
movq %r15, %rsi
movq 0x20(%rsp), %r15
movq %r15, %rdx
callq 0x4380
testl %eax, %eax
jne 0xa812
movq 0x18(%rbx), %r14
movq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x4380
testl %eax, %eax
jne 0xa82b
cmpq 0x10(%rsp), %r15
jne 0xa844
cmpq 0x8(%rsp), %r14
jne 0xa85d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4c4f(%rip), %rdi      # 0xf468
leaq 0x4c79(%rip), %rsi      # 0xf499
leaq 0x4c80(%rip), %rcx      # 0xf4a7
pushq $0x39
jmp 0xa874
leaq 0x4c91(%rip), %rdi      # 0xf4c3
leaq 0x4c60(%rip), %rsi      # 0xf499
leaq 0x4c67(%rip), %rcx      # 0xf4a7
pushq $0x3a
jmp 0xa874
leaq 0x4ca3(%rip), %rdi      # 0xf4ee
leaq 0x4c47(%rip), %rsi      # 0xf499
leaq 0x4c4e(%rip), %rcx      # 0xf4a7
pushq $0x3b
jmp 0xa874
leaq 0x4ca9(%rip), %rdi      # 0xf50d
leaq 0x4c2e(%rip), %rsi      # 0xf499
leaq 0x4c35(%rip), %rcx      # 0xf4a7
pushq $0x3c
popq %rdx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x43c0
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4200
movq %rsp, %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x4470
movq %rsp, %rdi
callq 0x4660
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4090
movq %rsp, %rdi
callq 0x40c0
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0xa922
movq %rax, %rbx
movq %rsp, %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x4680
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa985
movq %rdi, %r14
pushq $0x30
popq %rdi
callq 0x4350
movq %rax, %rbx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movq 0x8(%r14), %r15
movq %r15, %rdi
callq 0x4030
movq %rax, (%rbx)
movq (%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x42b0
jmp 0xa987
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movq (%rcx), %rbp
movq %r13, %rdi
movq %r12, %rsi
callq 0x4600
movl %eax, %ebx
cmpl $0x1, %eax
je 0xaa90
movl $0x100000, %esi         # imm = 0x100000
movq %r13, %rdi
callq 0x4590
testq %rax, %rax
je 0xaaa5
movl $0x100000, %edx         # imm = 0x100000
movq %r14, %rdi
movq %rax, %rsi
callq 0x4420
movl 0x8(%r14), %ecx
movslq %ecx, %rsi
movq (%r15), %rax
addq %rsi, %rax
movq %rax, (%r15)
testq %rcx, %rcx
je 0xaa52
movq %r13, %rdi
callq 0x4410
testl %eax, %eax
je 0xa9d6
leaq 0x35ca(%rip), %rdi      # 0xe004
leaq 0x4a58(%rip), %rsi      # 0xf499
leaq 0x4ae7(%rip), %rcx      # 0xf52f
movl $0x8c, %edx
callq 0x4210
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%r14,%rcx)
je 0xaac2
cmpq %rax, %rbp
je 0xaa90
movq 0xa583(%rip), %rdi      # 0x14ff0
leaq 0x4b0f(%rip), %rsi      # 0xf583
callq 0x4340
leaq 0x4b44(%rip), %rsi      # 0xf5c4
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
cmpl $0x1, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4a7c(%rip), %rdi      # 0xf528
leaq 0x49e6(%rip), %rsi      # 0xf499
leaq 0x4a75(%rip), %rcx      # 0xf52f
pushq $0x7e
popq %rdx
callq 0x4210
leaq 0x4aad(%rip), %rdi      # 0xf576
leaq 0x49c9(%rip), %rsi      # 0xf499
leaq 0x4a58(%rip), %rcx      # 0xf52f
movl $0x84, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/Utils.cpp
// Function: PageSeek(ogg_sync_state*, ogg_page*, std::istream&, unsigned long&)
int PageSeek(ogg_sync_state* state,
             ogg_page* page,
             istream& stream,
             ogg_uint64_t& bytesRead)
{
  int retval = 0;
  ogg_int32_t bytes = 0;
  ogg_int32_t r = 0;
  ogg_uint64_t intialBytesRead = bytesRead;
  while ((r = ogg_sync_pageseek(state, page)) <= 0) {
    if (r == 0) {
      // Need to read more data to get to next page.
      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);
    } else {
      assert(r<0);
      // We skipped -r bytes reading up to next ogg page capture.
      retval += (-r);
    }
  }
  if (r == -1) {
    cout << "ERROR: sync failure in ReadPage()" << endl;
    return -1;
  }
  return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movq (%rcx), %rbp
xorl %ebx, %ebx
movq %r13, %rdi
movq %r12, %rsi
callq 0x4220
testl %eax, %eax
jg 0xaba3
jne 0xab5b
movl $0x100000, %esi         # imm = 0x100000
movq %r13, %rdi
callq 0x4590
testq %rax, %rax
je 0xabb4
movl $0x100000, %edx         # imm = 0x100000
movq %r14, %rdi
movq %rax, %rsi
callq 0x4420
movl 0x8(%r14), %ecx
movslq %ecx, %rsi
movq (%r15), %rax
addq %rsi, %rax
movq %rax, (%r15)
testq %rcx, %rcx
je 0xab5f
movq %r13, %rdi
callq 0x4410
testl %eax, %eax
je 0xaafd
jmp 0xabd3
subl %eax, %ebx
jmp 0xaafd
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%r14,%rcx)
je 0xabf2
xorl %ebx, %ebx
cmpq %rax, %rbp
je 0xaba3
movq 0xa470(%rip), %rdi      # 0x14ff0
leaq 0x49fc(%rip), %rsi      # 0xf583
callq 0x4340
leaq 0x4a31(%rip), %rsi      # 0xf5c4
movq %rax, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41b0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x496d(%rip), %rdi      # 0xf528
leaq 0x48d7(%rip), %rsi      # 0xf499
leaq 0x4a19(%rip), %rcx      # 0xf5e2
movl $0x9f, %edx
callq 0x4210
leaq 0x342a(%rip), %rdi      # 0xe004
leaq 0x48b8(%rip), %rsi      # 0xf499
leaq 0x49fa(%rip), %rcx      # 0xf5e2
movl $0xaf, %edx
callq 0x4210
leaq 0x497d(%rip), %rdi      # 0xf576
leaq 0x4899(%rip), %rsi      # 0xf499
leaq 0x49db(%rip), %rcx      # 0xf5e2
movl $0xa6, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/Utils.cpp
// Function: IsPageAtOffset(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long, ogg_page*)
bool
IsPageAtOffset(const string& filename, ogg_int64_t offset, ogg_page* page)
{
  ifstream file(filename.c_str(), ios::in | ios::binary);
  assert(file);
  file.seekg((std::streamoff)offset, ios_base::beg);
  char* buf = new char[max(page->body_len, page->header_len)];
  file.read(buf, page->header_len);
  assert(file.gcount() == page->header_len);
  if (memcmp(buf, page->header, page->header_len) != 0) {
    cerr << "Incorrect page offset calculation for page at offset "
         << offset << endl;
    delete[] buf;
    return false;
  }
  
  file.read(buf, page->body_len);
  assert(file.gcount() == page->body_len);
  if (memcmp(buf, page->body, page->body_len) != 0) {
    cerr << "Incorrect page offset calculation for page at offset "
         << offset << endl;
    delete[] buf;
    return false;
  }

  delete[] buf;
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %r15
movq %rsi, %rbx
movq (%rdi), %rsi
movq %rsp, %r14
pushq $0xc
popq %rdx
movq %r14, %rdi
callq 0x46d0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
jne 0xad13
movq %rsp, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4470
movq 0x8(%r15), %r12
movq 0x18(%r15), %rdi
cmpq %r12, %rdi
cmovleq %r12, %rdi
callq 0x4030
movq %rax, %r14
movq %rsp, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x4420
movq 0x8(%rsp), %rdx
cmpq 0x8(%r15), %rdx
jne 0xad32
movq (%r15), %rsi
movq %r14, %rdi
callq 0x4380
testl %eax, %eax
jne 0xacc6
movq 0x18(%r15), %rdx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x4420
movq 0x8(%rsp), %rdx
cmpq 0x18(%r15), %rdx
jne 0xad51
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x4380
testl %eax, %eax
je 0xad0f
movq 0xa323(%rip), %rdi      # 0x14ff0
leaq 0x49b3(%rip), %rsi      # 0xf687
callq 0x4340
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4320
movq %rax, %rdi
callq 0x41b0
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x4440
movq %rsp, %rdi
callq 0x40c0
movl %ebx, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movb $0x1, %bl
jmp 0xacee
leaq 0x4235(%rip), %rdi      # 0xef4f
leaq 0x4778(%rip), %rsi      # 0xf499
leaq 0x4900(%rip), %rcx      # 0xf628
movl $0xc1, %edx
callq 0x4210
leaq 0x492c(%rip), %rdi      # 0xf665
leaq 0x4759(%rip), %rsi      # 0xf499
leaq 0x48e1(%rip), %rcx      # 0xf628
movl $0xc5, %edx
callq 0x4210
leaq 0x4965(%rip), %rdi      # 0xf6bd
leaq 0x473a(%rip), %rsi      # 0xf499
leaq 0x48c2(%rip), %rcx      # 0xf628
movl $0xce, %edx
callq 0x4210
jmp 0xad72
movq %rax, %rbx
movq %rsp, %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x4680
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rdi,%rax)
jne 0xae51
movq (%rsi), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rsi,%rax)
jne 0xae70
movq %rdx, %rbx
movq %rsi, (%rsp)
testq %rdx, %rdx
js 0xae8f
movq %rdi, %r15
movl $0x100000, %r12d        # imm = 0x100000
cmpq %r12, %rbx
cmovbq %rbx, %r12
movq %r12, %rdi
callq 0x4030
movq %rax, %r13
xorl %r14d, %r14d
movq %rbx, %rax
subq %r14, %rax
je 0xae1c
cmpq %rax, %r12
cmovlq %r12, %rax
movslq %eax, %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4420
cmpq 0x8(%r15), %rbp
jne 0xae32
movq (%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4460
addq %rbp, %r14
jmp 0xade2
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4440
leaq 0x48f8(%rip), %rdi      # 0xf731
leaq 0x4659(%rip), %rsi      # 0xf499
leaq 0x4896(%rip), %rcx      # 0xf6dd
movl $0xe9, %edx
callq 0x4210
leaq 0x3bc8(%rip), %rdi      # 0xea20
leaq 0x463a(%rip), %rsi      # 0xf499
leaq 0x4877(%rip), %rcx      # 0xf6dd
movl $0xdd, %edx
callq 0x4210
leaq 0x489b(%rip), %rdi      # 0xf712
leaq 0x461b(%rip), %rsi      # 0xf499
leaq 0x4858(%rip), %rcx      # 0xf6dd
movl $0xde, %edx
callq 0x4210
leaq 0x488a(%rip), %rdi      # 0xf720
leaq 0x45fc(%rip), %rsi      # 0xf499
leaq 0x4839(%rip), %rcx      # 0xf6dd
movl $0xe0, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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
testq %rdi, %rdi
je 0xaec8
movq (%rdi), %rax
testq %rax, %rax
je 0xaee7
cmpq $0x19, 0x8(%rdi)
jle 0xaf06
movl 0x16(%rax), %eax
popq %rcx
retq
leaq 0x4876(%rip), %rdi      # 0xf745
leaq 0x45c3(%rip), %rsi      # 0xf499
leaq 0x4872(%rip), %rcx      # 0xf74f
movl $0xf3, %edx
callq 0x4210
leaq 0x4886(%rip), %rdi      # 0xf774
leaq 0x45a4(%rip), %rsi      # 0xf499
leaq 0x4853(%rip), %rcx      # 0xf74f
movl $0xf4, %edx
callq 0x4210
leaq 0x4879(%rip), %rdi      # 0xf786
leaq 0x4585(%rip), %rsi      # 0xf499
leaq 0x4834(%rip), %rcx      # 0xf74f
movl $0xf5, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
callq 0x4130
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
movq (%rbx), %rcx
movzbl 0x1a(%rcx), %edx
pushq $0x1b
popq %rsi
leaq -0x1a(%rsi), %rdi
cmpq %rdx, %rdi
jae 0xafcb
xorl %edi, %edi
cmpb $-0x1, (%rcx,%rsi)
setne %dil
addl %edi, %eax
incq %rsi
jmp 0xafb1
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
testq %rdi, %rdi
je 0xaff8
xorl %eax, %eax
movq %rsi, %rcx
cmpq $0x8, %rax
je 0xafea
movb %cl, (%rdi,%rax)
shrq $0x8, %rcx
incq %rax
jmp 0xafd8
cmpq %rsi, (%rdi)
jne 0xb017
addq $0x8, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x494f(%rip), %rdi      # 0xf94e
leaq 0x4493(%rip), %rsi      # 0xf499
leaq 0x478f(%rip), %rcx      # 0xf79c
movl $0x12c, %edx            # imm = 0x12C
callq 0x4210
leaq 0x47c0(%rip), %rdi      # 0xf7de
leaq 0x4474(%rip), %rsi      # 0xf499
leaq 0x4770(%rip), %rcx      # 0xf79c
movl $0x131, %edx            # imm = 0x131
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
testq %rdi, %rdi
je 0xb065
xorl %eax, %eax
movq %rsi, %rcx
cmpq $0x8, %rax
je 0xb057
movb %cl, (%rdi,%rax)
sarq $0x8, %rcx
incq %rax
jmp 0xb045
cmpq %rsi, (%rdi)
jne 0xb084
addq $0x8, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x48e2(%rip), %rdi      # 0xf94e
leaq 0x4426(%rip), %rsi      # 0xf499
leaq 0x4777(%rip), %rcx      # 0xf7f1
movl $0x13a, %edx            # imm = 0x13A
callq 0x4210
leaq 0x47a6(%rip), %rdi      # 0xf831
leaq 0x4407(%rip), %rsi      # 0xf499
leaq 0x4758(%rip), %rcx      # 0xf7f1
movl $0x13f, %edx            # imm = 0x13F
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
testq %rdi, %rdi
je 0xb0cf
xorl %eax, %eax
movl %esi, %ecx
cmpq $0x4, %rax
je 0xb0c2
movb %cl, (%rdi,%rax)
shrl $0x8, %ecx
incq %rax
jmp 0xb0b1
cmpl %esi, (%rdi)
jne 0xb0ee
addq $0x4, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x4878(%rip), %rdi      # 0xf94e
leaq 0x43bc(%rip), %rsi      # 0xf499
leaq 0x475f(%rip), %rcx      # 0xf843
movl $0x148, %edx            # imm = 0x148
callq 0x4210
leaq 0x4790(%rip), %rdi      # 0xf885
leaq 0x439d(%rip), %rsi      # 0xf499
leaq 0x4740(%rip), %rcx      # 0xf843
movl $0x14d, %edx            # imm = 0x14D
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
testq %rdi, %rdi
je 0xb135
xorl %eax, %eax
movl %esi, %ecx
cmpq $0x4, %rax
je 0xb128
movb %cl, (%rdi,%rax)
sarl $0x8, %ecx
incq %rax
jmp 0xb117
cmpl %esi, (%rdi)
jne 0xb154
addq $0x4, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x4812(%rip), %rdi      # 0xf94e
leaq 0x4356(%rip), %rsi      # 0xf499
leaq 0x474e(%rip), %rcx      # 0xf898
movl $0x156, %edx            # imm = 0x156
callq 0x4210
leaq 0x477d(%rip), %rdi      # 0xf8d8
leaq 0x4337(%rip), %rsi      # 0xf499
leaq 0x472f(%rip), %rcx      # 0xf898
movl $0x15b, %edx            # imm = 0x15B
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
testq %rdi, %rdi
je 0xb18e
movw %si, (%rdi)
movb $0x1, %al
testb %al, %al
je 0xb1ad
addq $0x2, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x47b9(%rip), %rdi      # 0xf94e
leaq 0x42fd(%rip), %rsi      # 0xf499
leaq 0x4747(%rip), %rcx      # 0xf8ea
movl $0x163, %edx            # imm = 0x163
callq 0x4210
leaq 0x4778(%rip), %rdi      # 0xf92c
leaq 0x42de(%rip), %rsi      # 0xf499
leaq 0x4728(%rip), %rcx      # 0xf8ea
movl $0x166, %edx            # imm = 0x166
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq %rdx, %rsi
xorl %edx, %edx
callq 0x4730
movq %rax, %r13
leaq 0x8(%rsp), %r12
cmpq $-0x1, %r13
je 0xb244
movq %r13, %rcx
subq %rbp, %rcx
je 0xb244
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x4390
movq %r14, %rdi
movq %r12, %rsi
callq 0xb268
movq %r12, %rdi
callq 0x4170
movq %r13, %rbp
addq 0x8(%rbx), %rbp
movq %r15, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x4730
movq %rax, %r13
jmp 0xb1fb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4680
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
addq $0x1a8, %rdi            # imm = 0x1A8
movq %rdi, %rax
movq (%rax), %rax
cmpq %rdi, %rax
je 0xc7f9
cmpq $-0x1, 0x10(%rax)
je 0xc7cd
leaq 0x36cf(%rip), %rdi      # 0xfeb2
leaq 0x3155(%rip), %rsi      # 0xf93f
leaq 0x36d5(%rip), %rcx      # 0xfec6
pushq $0x7b
popq %rdx
callq 0x4210
movb $0x1, %al
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movq 0x228(%rdi), %rdi
callq 0x40a0
imull $0x3e8, 0x1e0(%rbx), %ecx # imm = 0x3E8
imulq %rcx, %rax
movl 0x1dc(%rbx), %ecx
cqto
idivq %rcx
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1a8(%rdi), %r14
cmpq $0x0, 0x1b8(%rbx)
je 0xc885
movq (%r14), %rax
movq 0x10(%rax), %r15
cmpq $-0x1, %r15
je 0xc885
movb 0x18(%rax), %bpl
movq %r14, %rdi
callq 0xc944
testb $0x1, %bpl
je 0xc847
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc80a
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x4360
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4550
testl %eax, %eax
jne 0xccd4
cmpb $0x1, 0xc(%rbx)
jne 0xcccc
addq $0x200, %rbx            # imm = 0x200
movq %rbx, %rdi
callq 0x44f0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x3217(%rip), %rdi      # 0xfef2
leaq 0x2c5d(%rip), %rsi      # 0xf93f
leaq 0x3275(%rip), %rcx      # 0xff5e
movl $0x116, %edx            # imm = 0x116
callq 0x4210
nop