LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10eb6(%rip), %r15     # 0x17410
movq %r15, %rdi
callq 0x8b3a
testb %al, %al
je 0x66e9
movq 0x10a5f(%rip), %r15     # 0x16fd0
leaq 0xa04d(%rip), %rsi      # 0x105c5
movl $0x4, %edx
movq %r15, %rdi
callq 0x4410
movzbl 0x10(%rbx), %eax
leaq 0xa03a(%rip), %rcx      # 0x105ca
leaq 0xa036(%rip), %rsi      # 0x105cd
testq %rax, %rax
cmovneq %rcx, %rsi
leaq (%rax,%rax,2), %rdx
addq $0x5, %rdx
movq %r15, %rdi
callq 0x4410
leaq 0xa207(%rip), %rsi      # 0x107bc
movl $0xa, %edx
movq %r15, %rdi
callq 0x4410
movq 0x8(%rbx), %rsi
movq 0x220(%r14), %rdi
callq 0x40b0
movl 0x1d4(%r14), %ecx
movl 0x1d8(%r14), %edx
imulq %rax, %rdx
imulq $0x3e8, %rdx, %rax      # imm = 0x3E8
cqto
idivq %rcx
movq %r15, %rdi
movq %rax, %rsi
callq 0x4340
movq %rax, %r15
leaq 0xab09(%rip), %rsi      # 0x1110e
movl $0x1, %edx
movq %rax, %rdi
callq 0x4410
movq 0x8(%rbx), %rsi
movq 0x220(%r14), %rdi
callq 0x40b0
imulq $0x3e8, %rax, %rcx      # imm = 0x3E8
addq $0x3e8, %rcx            # imm = 0x3E8
movl 0x1d4(%r14), %esi
movl 0x1d8(%r14), %eax
imulq %rcx, %rax
cqto
idivq %rsi
movq %r15, %rdi
movq %rax, %rsi
callq 0x4340
movq %rax, %r14
leaq 0x9f77(%rip), %rsi      # 0x105d3
movl $0xd, %edx
movq %rax, %rdi
callq 0x4410
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4340
movq %rax, %r14
leaq 0x9f62(%rip), %rsi      # 0x105e1
movl $0xa, %edx
movq %rax, %rdi
callq 0x4410
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x4340
movq %rax, %r14
movzbl 0x11(%rbx), %edx
leaq 0x9d44(%rip), %rax      # 0x103e9
leaq 0xad6e(%rip), %rsi      # 0x1141a
testl %edx, %edx
cmovneq %rax, %rsi
shll $0x2, %edx
movq %r14, %rdi
callq 0x4410
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4250
cmpb $0x1, 0x10(%rbx)
jne 0x66fa
cmpb $0x1, 0x1(%r15)
je 0x656a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
addq $0x20, %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movb %al, 0x30(%rbx)
leaq 0x50(%rbx), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movb %al, 0x50(%rbx)
leaq 0x70(%rbx), %rcx
movq %rcx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movb %al, 0x70(%rbx)
movq 0x1e8(%rsi), %rax
movq %rax, (%rbx)
movq $0x1, 0x8(%rbx)
movq $0x2, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
leaq 0x93c9(%rip), %rcx      # 0x10815
movl $0xc, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x45b0
leaq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rdx
leaq 0x93b8(%rip), %rcx      # 0x10822
movl $0xa, %r8d
xorl %esi, %esi
callq 0x45b0
leaq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rdx
leaq 0x93a7(%rip), %rcx      # 0x1082d
movl $0x7, %r8d
xorl %esi, %esi
callq 0x45b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6c34
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
callq 0x9104
movl %eax, %ebx
testb %al, %al
je 0x904f
movq 0xdfba(%rip), %r15      # 0x16fd0
leaq 0x7e3c(%rip), %rsi      # 0x10e59
movl $0x13, %edx
movq %r15, %rdi
callq 0x4410
movq 0x28(%r14), %r14
testq %r14, %r14
je 0x9079
movq %r14, %rdi
callq 0x4170
movq 0xdf8e(%rip), %rdi      # 0x16fd0
movq %r14, %rsi
movq %rax, %rdx
callq 0x4410
jmp 0x9091
callq 0x8b42
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x90e3
movq %r14, %rdi
callq 0x4170
movq 0xdf5f(%rip), %rdi      # 0x16fd0
movq %r14, %rsi
movq %rax, %rdx
jmp 0x90a4
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x4680
movq 0xdf38(%rip), %rdi      # 0x16fd0
leaq 0x7dcc(%rip), %rsi      # 0x10e6b
movl $0x1, %edx
callq 0x4410
movq 0xdf20(%rip), %r14      # 0x16fd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4250
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0xdee6(%rip), %rax      # 0x16fd0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x4680
jmp 0x90a9
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x948c
cmpb $0x76, 0x1(%rdi)
jne 0x9442
cmpb $0x0, 0x2(%rdi)
je 0x948f
cmpb $0x64, 0x1(%rdi)
jne 0x944e
cmpb $0x0, 0x2(%rdi)
je 0x948f
cmpb $0x6b, 0x1(%rdi)
jne 0x945a
cmpb $0x0, 0x2(%rdi)
je 0x948f
cmpb $0x70, 0x1(%rdi)
jne 0x9466
cmpb $0x0, 0x2(%rdi)
je 0x948f
cmpb $0x6f, 0x1(%rdi)
jne 0x9472
cmpb $0x0, 0x2(%rdi)
je 0x948f
cmpb $0x6d, 0x1(%rdi)
jne 0x947e
cmpb $0x0, 0x2(%rdi)
je 0x948f
cmpb $0x69, 0x1(%rdi)
jne 0x948c
cmpb $0x0, 0x2(%rdi)
sete %al
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
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)
movl $0x0, 0x64(%rdi)
movq %r8, 0x68(%rdi)
movq 0x18(%rsi), %r13
addq $0x8, %r12
cmpq %r12, %r13
je 0x9619
leaq 0x38(%rbx), %r15
leaq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rbp
movq 0x28(%r13), %r14
movq %r14, 0x8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x1, %eax
je 0x95bb
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x95bb
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x3, %eax
jne 0x95df
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x95d4
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x95df
movq %rbx, %rdi
movq %rbp, %rdx
callq 0xbbf6
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x4, %eax
jne 0x95f8
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rbx)
movq %r13, %rdi
callq 0x4260
movq %rax, %r13
cmpq %r12, %rax
jne 0x9588
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x9619
movl 0x1a0(%rax), %eax
jmp 0x9658
xorl %edi, %edi
callq 0x4330
movl %eax, %edi
callq 0x4350
callq 0x40d0
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
je 0x9658
sarq $0x3, %rdx
movl $0x1, %esi
xorl %edi, %edi
movq (%rcx,%rdi,8), %rdi
cmpl %eax, 0x1a0(%rdi)
je 0x9627
movl %esi, %edi
incl %esi
cmpq %rdi, %rdx
ja 0x9643
movl %eax, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x9682
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x43a0
movq %r15, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
callq 0x4815
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
cmpq %rax, 0x40(%rdi)
je 0x96f2
movl $0x1, %ebp
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x96cf
movq %rax, %rdi
callq 0x4490
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
movl $0x30, %esi
callq 0x43a0
movl %ebp, %r14d
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebp
cmpq %r14, %rcx
ja 0x96b3
movq %rbx, %rdi
callq 0x974a
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x970f
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x43a0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x9724
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x43a0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x973c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x43a0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x53ae
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x98bd
movq %rdi, %rbx
movl $0x30, %edi
callq 0x4380
movq %rax, %r14
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movl $0x50, %edi
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 0x9834
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 0x9863
movabsq $0x64616568736966, %rax # imm = 0x64616568736966
movq %rax, (%rdi)
addq $0x14, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0xc888
movq (%r14), %rdi
addq $0x24, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0xc888
movq (%r14), %rdi
addq $0x8, %rdi
movl $0x4, %esi
callq 0xca29
movq (%r14), %rdi
addq $0xa, %rdi
xorl %esi, %esi
callq 0xca29
movq (%r14), %rdi
addq $0x48, %rdi
movq 0x68(%rbx), %rsi
callq 0xc888
incl 0x34(%rbx)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x98a6
movq %r14, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0x98b5
addq $0x38, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xbd32
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x775c(%rip), %rdi      # 0x11020
leaq 0x7767(%rip), %rsi      # 0x11032
leaq 0x7778(%rip), %rcx      # 0x1104a
movl $0x7e, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x30, %edi
callq 0x4380
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
movq $0x1, 0x18(%rax)
movslq 0x34(%rbx), %rcx
movq %rcx, 0x28(%rax)
incl %ecx
movl %ecx, 0x34(%rbx)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0xa4d0
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0xa4e1
addq $0x38, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xbd32
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
je 0xaed6
sarq $0x3, %rdx
movl $0x1, %edi
xorl %eax, %eax
movq (%rcx,%rax,8), %rax
cmpl %esi, 0x1a0(%rax)
je 0xaed8
movl %edi, %eax
incl %edi
cmpq %rax, %rdx
ja 0xaec1
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x20, %edi
callq 0x4380
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 0x42c0
movq 0x10(%r14), %rsi
movq %r13, %rdi
movq %rsi, 0x18(%rsp)
movq %rbp, 0x8(%rsp)
movq %rbp, %rdx
callq 0x42c0
movq %r12, %rdi
movq %r15, %rsi
movq 0x20(%rsp), %r15
movq %r15, %rdx
callq 0x43b0
testl %eax, %eax
jne 0xbfc4
movq 0x18(%rbx), %r14
movq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x43b0
testl %eax, %eax
jne 0xbfe3
cmpq 0x10(%rsp), %r15
jne 0xc002
cmpq 0x8(%rsp), %r14
jne 0xc021
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x54a3(%rip), %rdi      # 0x1146e
leaq 0x54cd(%rip), %rsi      # 0x1149f
leaq 0x54d4(%rip), %rcx      # 0x114ad
movl $0x39, %edx
callq 0x4210
leaq 0x54df(%rip), %rdi      # 0x114c9
leaq 0x54ae(%rip), %rsi      # 0x1149f
leaq 0x54b5(%rip), %rcx      # 0x114ad
movl $0x3a, %edx
callq 0x4210
leaq 0x54eb(%rip), %rdi      # 0x114f4
leaq 0x548f(%rip), %rsi      # 0x1149f
leaq 0x5496(%rip), %rcx      # 0x114ad
movl $0x3b, %edx
callq 0x4210
leaq 0x54eb(%rip), %rdi      # 0x11513
leaq 0x5470(%rip), %rsi      # 0x1149f
leaq 0x5477(%rip), %rcx      # 0x114ad
movl $0x3c, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4400
movq %r14, %rdi
movq %rbx, %rsi
movl $0x4, %edx
callq 0x4200
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x44b0
movq %rsp, %rdi
callq 0x46a0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x40a0
movq %rsp, %rdi
callq 0x40c0
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0xc0ee
movq %rax, %rbx
movq %rsp, %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc153
movq %rdi, %r14
movl $0x30, %edi
callq 0x4380
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 0x42c0
jmp 0xc155
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4650
movl %eax, %ebx
cmpl $0x1, %eax
je 0xc288
movl $0x100000, %esi         # imm = 0x100000
movq %r13, %rdi
callq 0x45e0
testq %rax, %rax
je 0xc29d
movl $0x100000, %edx         # imm = 0x100000
movq %r14, %rdi
movq %rax, %rsi
callq 0x4470
movl 0x8(%r14), %ecx
movslq %ecx, %rsi
movq (%r15), %rax
addq %rsi, %rax
movq %rax, (%r15)
testq %rcx, %rcx
je 0xc21a
movq %r13, %rdi
callq 0x4460
testl %eax, %eax
je 0xc19e
leaq 0x3e02(%rip), %rdi      # 0x10004
leaq 0x5296(%rip), %rsi      # 0x1149f
leaq 0x5325(%rip), %rcx      # 0x11535
movl $0x8c, %edx
callq 0x4210
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%r14,%rcx)
je 0xc2bc
cmpq %rax, %rbp
je 0xc288
movq 0xadb7(%rip), %r14      # 0x16ff0
leaq 0x5349(%rip), %rsi      # 0x11589
movl $0x40, %edx
movq %r14, %rdi
callq 0x4410
leaq 0x5376(%rip), %rsi      # 0x115ca
movl $0x1d, %edx
movq %r14, %rdi
callq 0x4410
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4250
cmpl $0x1, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x528a(%rip), %rdi      # 0x1152e
leaq 0x51f4(%rip), %rsi      # 0x1149f
leaq 0x5283(%rip), %rcx      # 0x11535
movl $0x7e, %edx
callq 0x4210
leaq 0x52b9(%rip), %rdi      # 0x1157c
leaq 0x51d5(%rip), %rsi      # 0x1149f
leaq 0x5264(%rip), %rcx      # 0x11535
movl $0x84, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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
callq 0x4220
xorl %ebx, %ebx
testl %eax, %eax
jg 0xc364
xorl %ebx, %ebx
testl %eax, %eax
je 0xc30a
subl %eax, %ebx
jmp 0xc355
movl $0x100000, %esi         # imm = 0x100000
movq %r13, %rdi
callq 0x45e0
testq %rax, %rax
je 0xc3ea
movl $0x100000, %edx         # imm = 0x100000
movq %r14, %rdi
movq %rax, %rsi
callq 0x4470
movl 0x8(%r14), %ecx
movslq %ecx, %rsi
movq (%r15), %rax
addq %rsi, %rax
movq %rax, (%r15)
testq %rcx, %rcx
je 0xc375
movq %r13, %rdi
callq 0x4460
testl %eax, %eax
jne 0xc409
movq %r13, %rdi
movq %r12, %rsi
callq 0x4220
testl %eax, %eax
jle 0xc302
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%r14,%rcx)
je 0xc428
xorl %ebx, %ebx
cmpq %rax, %rbp
je 0xc364
movq 0xac5a(%rip), %r14      # 0x16ff0
leaq 0x51ec(%rip), %rsi      # 0x11589
movl $0x40, %edx
movq %r14, %rdi
callq 0x4410
leaq 0x5219(%rip), %rsi      # 0x115ca
movl $0x1d, %edx
movq %r14, %rdi
callq 0x4410
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4250
jmp 0xc364
leaq 0x513d(%rip), %rdi      # 0x1152e
leaq 0x50a7(%rip), %rsi      # 0x1149f
leaq 0x51e9(%rip), %rcx      # 0x115e8
movl $0x9f, %edx
callq 0x4210
leaq 0x3bf4(%rip), %rdi      # 0x10004
leaq 0x5088(%rip), %rsi      # 0x1149f
leaq 0x51ca(%rip), %rcx      # 0x115e8
movl $0xaf, %edx
callq 0x4210
leaq 0x514d(%rip), %rdi      # 0x1157c
leaq 0x5069(%rip), %rsi      # 0x1149f
leaq 0x51ab(%rip), %rcx      # 0x115e8
movl $0xa6, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc709
movq (%rsi), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rsi,%rax)
jne 0xc728
movq %rdx, %rbx
movq %rsi, (%rsp)
testq %rdx, %rdx
js 0xc747
movq %rdi, %r15
movl $0x100000, %r12d        # imm = 0x100000
cmpq %r12, %rbx
cmovbq %rbx, %r12
movq %r12, %rdi
callq 0x4030
movq %rax, %r13
testq %rbx, %rbx
je 0xc6d4
xorl %r14d, %r14d
movq %rbx, %rax
subq %r14, %rax
cmpq %rax, %r12
cmovlq %r12, %rax
movslq %eax, %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4470
cmpq 0x8(%r15), %rbp
jne 0xc6ea
movq (%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x44a0
addq %rbp, %r14
cmpq %rbx, %r14
jne 0xc699
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4490
leaq 0x5046(%rip), %rdi      # 0x11737
leaq 0x4da7(%rip), %rsi      # 0x1149f
leaq 0x4fe4(%rip), %rcx      # 0x116e3
movl $0xe9, %edx
callq 0x4210
leaq 0x4310(%rip), %rdi      # 0x10a20
leaq 0x4d88(%rip), %rsi      # 0x1149f
leaq 0x4fc5(%rip), %rcx      # 0x116e3
movl $0xdd, %edx
callq 0x4210
leaq 0x4fe9(%rip), %rdi      # 0x11718
leaq 0x4d69(%rip), %rsi      # 0x1149f
leaq 0x4fa6(%rip), %rcx      # 0x116e3
movl $0xde, %edx
callq 0x4210
leaq 0x4fd8(%rip), %rdi      # 0x11726
leaq 0x4d4a(%rip), %rsi      # 0x1149f
leaq 0x4f87(%rip), %rcx      # 0x116e3
movl $0xe0, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc780
movq (%rdi), %rax
testq %rax, %rax
je 0xc79f
cmpq $0x19, 0x8(%rdi)
jle 0xc7be
movl 0x16(%rax), %eax
popq %rcx
retq
leaq 0x4fc4(%rip), %rdi      # 0x1174b
leaq 0x4d11(%rip), %rsi      # 0x1149f
leaq 0x4fc0(%rip), %rcx      # 0x11755
movl $0xf3, %edx
callq 0x4210
leaq 0x4fd4(%rip), %rdi      # 0x1177a
leaq 0x4cf2(%rip), %rsi      # 0x1149f
leaq 0x4fa1(%rip), %rcx      # 0x11755
movl $0xf4, %edx
callq 0x4210
leaq 0x4fc7(%rip), %rdi      # 0x1178c
leaq 0x4cd3(%rip), %rsi      # 0x1149f
leaq 0x4f82(%rip), %rcx      # 0x11755
movl $0xf5, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4150
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
movq (%rbx), %rcx
movzbl 0x1a(%rcx), %edx
cmpq $0x2, %rdx
jb 0xc886
decq %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpb $-0x1, 0x1b(%rcx,%rsi)
setne %dil
addl %edi, %eax
incq %rsi
cmpq %rsi, %rdx
jne 0xc871
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc8b1
xorl %eax, %eax
movq %rsi, %rcx
movb %cl, (%rdi,%rax)
shrq $0x8, %rcx
incq %rax
cmpq $0x8, %rax
jne 0xc893
cmpq %rsi, (%rdi)
jne 0xc8d0
addq $0x8, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x509c(%rip), %rdi      # 0x11954
leaq 0x4be0(%rip), %rsi      # 0x1149f
leaq 0x4edc(%rip), %rcx      # 0x117a2
movl $0x12c, %edx            # imm = 0x12C
callq 0x4210
leaq 0x4f0d(%rip), %rdi      # 0x117e4
leaq 0x4bc1(%rip), %rsi      # 0x1149f
leaq 0x4ebd(%rip), %rcx      # 0x117a2
movl $0x131, %edx            # imm = 0x131
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc91c
xorl %eax, %eax
movq %rsi, %rcx
movb %cl, (%rdi,%rax)
sarq $0x8, %rcx
incq %rax
cmpq $0x8, %rax
jne 0xc8fe
cmpq %rsi, (%rdi)
jne 0xc93b
addq $0x8, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x5031(%rip), %rdi      # 0x11954
leaq 0x4b75(%rip), %rsi      # 0x1149f
leaq 0x4ec6(%rip), %rcx      # 0x117f7
movl $0x13a, %edx            # imm = 0x13A
callq 0x4210
leaq 0x4ef5(%rip), %rdi      # 0x11837
leaq 0x4b56(%rip), %rsi      # 0x1149f
leaq 0x4ea7(%rip), %rcx      # 0x117f7
movl $0x13f, %edx            # imm = 0x13F
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc984
xorl %eax, %eax
movl %esi, %ecx
movb %cl, (%rdi,%rax)
shrl $0x8, %ecx
incq %rax
cmpq $0x4, %rax
jne 0xc968
cmpl %esi, (%rdi)
jne 0xc9a3
addq $0x4, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x4fc9(%rip), %rdi      # 0x11954
leaq 0x4b0d(%rip), %rsi      # 0x1149f
leaq 0x4eb0(%rip), %rcx      # 0x11849
movl $0x148, %edx            # imm = 0x148
callq 0x4210
leaq 0x4ee1(%rip), %rdi      # 0x1188b
leaq 0x4aee(%rip), %rsi      # 0x1149f
leaq 0x4e91(%rip), %rcx      # 0x11849
movl $0x14d, %edx            # imm = 0x14D
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc9e8
xorl %eax, %eax
movl %esi, %ecx
movb %cl, (%rdi,%rax)
sarl $0x8, %ecx
incq %rax
cmpq $0x4, %rax
jne 0xc9cc
cmpl %esi, (%rdi)
jne 0xca07
addq $0x4, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x4f65(%rip), %rdi      # 0x11954
leaq 0x4aa9(%rip), %rsi      # 0x1149f
leaq 0x4ea1(%rip), %rcx      # 0x1189e
movl $0x156, %edx            # imm = 0x156
callq 0x4210
leaq 0x4ed0(%rip), %rdi      # 0x118de
leaq 0x4a8a(%rip), %rsi      # 0x1149f
leaq 0x4e82(%rip), %rcx      # 0x1189e
movl $0x15b, %edx            # imm = 0x15B
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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 0xca41
movw %si, (%rdi)
movb $0x1, %al
testb %al, %al
je 0xca60
addq $0x2, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x4f0c(%rip), %rdi      # 0x11954
leaq 0x4a50(%rip), %rsi      # 0x1149f
leaq 0x4e9a(%rip), %rcx      # 0x118f0
movl $0x163, %edx            # imm = 0x163
callq 0x4210
leaq 0x4ecb(%rip), %rdi      # 0x11932
leaq 0x4a31(%rip), %rsi      # 0x1149f
leaq 0x4e7b(%rip), %rcx      # 0x118f0
movl $0x166, %edx            # imm = 0x166
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O3/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
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %edx, %edx
callq 0x46b0
movq %rax, %r12
decq %rax
cmpq $-0x3, %rax
ja 0xcb19
leaq 0x18(%rsp), %rbp
xorl %edx, %edx
leaq 0x8(%rsp), %r13
movq %r12, %rcx
subq %rdx, %rcx
movq %r13, %rdi
movq %r15, %rsi
callq 0x43c0
movq %r14, %rdi
movq %r13, %rsi
callq 0xcb4a
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xcaf3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x43a0
movq (%rbx), %rsi
movq 0x8(%rbx), %rcx
addq %rcx, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x46b0
cmpq $-0x1, %rax
je 0xcb19
movq %r12, %rdx
cmpq %rax, %r12
movq %rax, %r12
jne 0xcac0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xcb42
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x43a0
movq %rbx, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x1b8(%rbx), %rcx
movq $-0x1, %rax
testq %rcx, %rcx
je 0xe725
movq 0x1a8(%rbx), %r15
movq 0x10(%r15), %r14
cmpq $-0x1, %r14
je 0xe725
decq %rcx
movb 0x18(%r15), %bpl
movq %rcx, 0x1b8(%rbx)
movq %r15, %rdi
callq 0x4630
movl $0x20, %esi
movq %r15, %rdi
callq 0x43a0
testb $0x1, %bpl
je 0xe6b0
movq 0x228(%rbx), %rdi
movq %r14, %rsi
callq 0x40b0
imull $0x3e8, 0x1e0(%rbx), %ecx # imm = 0x3E8
imulq %rcx, %rax
movl 0x1dc(%rbx), %ecx
cqto
idivq %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4390
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4590
testl %eax, %eax
jne 0xeafe
cmpb $0x1, 0xc(%rbx)
jne 0xeaf6
addq $0x200, %rbx            # imm = 0x200
movq %rbx, %rdi
callq 0x4530
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x33f3(%rip), %rdi      # 0x11ef8
leaq 0x2e39(%rip), %rsi      # 0x11945
leaq 0x3451(%rip), %rcx      # 0x11f64
movl $0x116, %edx            # imm = 0x116
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x80(%rdi), %rax
movq 0x88(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
jle 0x38e7
movq %rsi, %r14
movb 0x1c8(%rbx), %dl
movq 0x20(%rbx), %rsi
movq 0x38(%rbx), %rdi
movq (%r14), %r8
movl %ecx, %r9d
andl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
xorl %r10d, %r10d
testb %dl, %dl
jne 0x389b
movslq (%rax,%r10,4), %r11
movslq (%rsi,%r11,4), %r15
movslq (%rdi,%r15,4), %r15
subq %r15, (%r8,%r11,8)
incq %r10
cmpq %r10, %r9
jne 0x3887
testl %ecx, %ecx
jle 0x38e7
xorl %r15d, %r15d
movslq (%rax,%r15,4), %r12
movq 0x20(%rbx), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x3342
cltq
movq (%r14), %rcx
addq %rax, (%rcx,%r12,8)
incq %r15
movq 0x80(%rbx), %rax
movq 0x88(%rbx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jl 0x38aa
movb $0x0, 0x1c8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/jp-myk[P]WAVUtil/src/wav_combine.cpp
// Function: main
int main(int argc, char *argv[]){
  if(argc<4){
    std::cout << argv[0] << " WAVFILE1 WAVFILE2 OUTPUTWAV" << std::endl;
    exit(0);
  }
  const char* wavFName1=argv[1];
  const char* wavFName2=argv[2];
  const char* output_wavFName=argv[3];
  WAV wav1,wav2,wav3;
  int res=0;
  res=wav1.Read(wavFName1);
  res=wav2.Read(wavFName2);
  std::cout << "combine!" << std::endl;
  res=SimpleWAV::combine_wav(wav1, wav2, wav3);
  res=wav3.Write(output_wavFName);
  if(res==0) std::cout << "success" << std::endl;
  
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rax
cmpl $0x3, %edi
jle 0x3c35
movq 0x8(%rax), %rsi
movq 0x10(%rax), %r14
movq 0x18(%rax), %rbx
xorl %eax, %eax
leaq 0xb0(%rsp), %rdi
movl %eax, 0x4(%rdi)
movabsq $0x2000100000010, %rcx  # imm = 0x2000100000010
movq %rcx, 0x10(%rdi)
movabsq $0x7d000000ac44, %rdx   # imm = 0x7D000000AC44
movq %rdx, 0x18(%rdi)
movl $0x100002, %r8d         # imm = 0x100002
movl %r8d, 0x20(%rdi)
movl %eax, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rax, 0x50(%rdi)
movl %eax, 0x5c(%rsp)
movq %rcx, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movl %r8d, 0x78(%rsp)
movl %eax, 0x80(%rsp)
movups %xmm0, 0x88(%rsp)
movups %xmm0, 0x98(%rsp)
movq %rax, 0xa8(%rsp)
movl %eax, 0x4(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movl %r8d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movups %xmm0, 0x30(%rsp)
movups %xmm0, 0x40(%rsp)
movq %rax, 0x50(%rsp)
callq 0x2a80
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x2a80
movq 0x2470(%rip), %r14      # 0x5fd0
leaq 0x7bb(%rip), %rsi       # 0x4322
movl $0x8, %edx
movq %r14, %rdi
callq 0x2190
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq 0x243e(%rip), %rdi      # 0x5fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0xb0(%rsp), %rdi
leaq 0x58(%rsp), %rsi
movq %rsp, %rdx
callq 0x3353
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x27d8
testl %eax, %eax
jne 0x3c09
movq 0x2406(%rip), %rbx      # 0x5fd0
leaq 0x75a(%rip), %rsi       # 0x432b
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq 0x23d4(%rip), %rdi      # 0x5fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rsp, %rdi
callq 0x272e
leaq 0x58(%rsp), %rdi
callq 0x272e
leaq 0xb0(%rsp), %rdi
callq 0x272e
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
movq (%rax), %rsi
movq 0x2391(%rip), %rdi      # 0x5fd0
callq 0x2160
leaq 0x6ba(%rip), %rsi       # 0x4305
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
jmp 0x3c96
jmp 0x3c96
jmp 0x3c96
movq %rax, %rbx
movq %rsp, %rdi
callq 0x272e
leaq 0x58(%rsp), %rdi
callq 0x272e
leaq 0xb0(%rsp), %rdi
callq 0x272e
movq %rbx, %rdi
callq 0x2270
jmp 0x3c96
jmp 0x3c96
movq %rax, %rdi
callq 0x378f
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/driver.cc
// Function: readSphere(std::istream&)
sp_shape3d readSphere(istream &is) {
	rgbcolord color;
	float reflectivity;
	double rad;
	vector3d vec;
	cin >> color >> rad >> vec >> reflectivity;
	sp_shape3d x(new sphere3d(color, rad, vec, reflectivity));
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq -0x70(%rbp), %r14
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq -0x50(%rbp), %r15
movq %rax, 0x10(%r15)
movaps %xmm0, (%r15)
movq 0xaaf4(%rip), %rdi      # 0xdfd8
movq %r14, %rsi
callq 0x45f7
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3100
movq %rax, %rdi
movq %r15, %rsi
callq 0x4501
leaq -0x34(%rbp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x32e0
movl $0x48, %edi
callq 0x31c0
movq %rax, %r12
leaq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movss (%r13), %xmm1
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x47cc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x489a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x48, %esi
movq %r12, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/driver.cc
// Function: readCylinder(std::istream&)
sp_shape3d readCylinder(istream &is) {
	rgbcolord color;
	float reflectivity;
	double radius, height;
	vector3d vec1, vec2;
	cin >> color >> radius >> vec1 >> vec2 >> height >> reflectivity;
	sp_shape3d x(
			new cylinderd(color, radius, vec1, height, vec2, reflectivity));
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x30(%rbp)
xorl %eax, %eax
leaq -0x60(%rbp), %rcx
movq %rax, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movq %rcx, %rsi
leaq -0xa0(%rbp), %r15
movq %rax, 0x10(%r15)
movaps %xmm0, (%r15)
leaq -0x80(%rbp), %r12
movq %rax, 0x10(%r12)
movaps %xmm0, (%r12)
movq 0xaa1c(%rip), %rdi      # 0xdfd8
callq 0x45f7
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x3100
movq %rax, %rdi
movq %r15, %rsi
callq 0x4501
movq %rax, %rdi
movq %r12, %rsi
callq 0x4501
leaq -0x48(%rbp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3100
leaq -0x3c(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x32e0
movl $0x68, %edi
callq 0x31c0
movq %rax, %r13
leaq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd (%rbx), %xmm1
movss (%r14), %xmm2
movq %r13, %rdi
leaq -0x60(%rbp), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x48f2
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4a14
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r13, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/driver.cc
// Function: readPlane(std::istream&)
sp_shape3d readPlane(istream &is) {
	rgbcolord color;
	float reflectivity;
	double dist;
	vector3d vec;
	cin >> color >> dist >> vec >> reflectivity;
	sp_shape3d x(new infplaned(color, dist, vec, reflectivity));
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq -0x70(%rbp), %r14
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq -0x50(%rbp), %r15
movq %rax, 0x10(%r15)
movaps %xmm0, (%r15)
movq 0xa936(%rip), %rdi      # 0xdfd8
movq %r14, %rsi
callq 0x45f7
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3100
movq %rax, %rdi
movq %r15, %rsi
callq 0x4501
leaq -0x34(%rbp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x32e0
movl $0x48, %edi
callq 0x31c0
movq %rax, %r12
leaq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movss (%r13), %xmm1
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4a6c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4b1a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x48, %esi
movq %r12, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/driver.cc
// Function: readLight(std::istream&)
sp_lightd readLight(istream &is) {
	rgbcolord color;
	vector3d vec;
	cin >> color >> vec;
	sp_lightd x(new lightd(color, vec));
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq -0x60(%rbp), %r13
movq %r14, 0x10(%r13)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
leaq -0x40(%rbp), %r15
movq %r14, 0x10(%r15)
movaps %xmm0, (%r15)
movq 0xa870(%rip), %rdi      # 0xdfd8
movq %r13, %rsi
callq 0x45f7
movq %rax, %rdi
movq %r15, %rsi
callq 0x4501
movl $0x38, %edi
callq 0x31c0
movq %rax, %r12
movaps (%r13), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x10(%r13), %rax
movq %rax, 0x18(%r12)
leaq 0xa3b7(%rip), %rax      # 0xdb58
movq %rax, (%r12)
movq %r15, %rdi
movl %r14d, %esi
callq 0x5b6e
movsd %xmm0, 0x20(%r12,%r14,8)
incq %r14
cmpq $0x3, %r14
jne 0x37a5
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4b72
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hamikm[P]Raytracer/src/driver.cc
// Function: readSpotLight(std::istream&)
sp_spotlightd readSpotLight(istream &is) {
	rgbcolord color;
	vector3d pos, lookat;
	float angle;
	cin >> color >> pos >> lookat >> angle;
	assert(!(pos[0] == lookat[0] &&
			lookat[1] == lookat[1] && pos[2] == lookat[2]));
	sp_spotlightd x(new spotlightd(color, pos, (lookat - pos).norm(), angle));
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq -0x80(%rbp), %rsi
movq %rax, 0x10(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
leaq -0x60(%rbp), %r14
movq %rax, 0x10(%r14)
movaps %xmm0, (%r14)
leaq -0x40(%rbp), %r15
movq %rax, 0x10(%r15)
movaps %xmm0, (%r15)
movq 0xa7b9(%rip), %rdi      # 0xdfd8
callq 0x45f7
movq %rax, %rdi
movq %r14, %rsi
callq 0x4501
movq %rax, %rdi
movq %r15, %rsi
callq 0x4501
leaq -0x1c(%rbp), %rsi
movq %rax, %rdi
callq 0x32e0
movsd (%r14), %xmm0
ucomisd (%r15), %xmm0
jne 0x386d
jp 0x386d
movsd -0x38(%rbp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x386d
movsd -0x50(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jne 0x386d
jnp 0x38d9
movl $0x58, %edi
callq 0x31c0
movq %rax, %r14
leaq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x4c1e
leaq -0xb0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4c98
movss -0x1c(%rbp), %xmm0
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
movq %r14, %rdi
callq 0x4d4c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e1c
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x57c0(%rip), %rdi      # 0x90a0
leaq 0x5801(%rip), %rsi      # 0x90e8
leaq 0x5808(%rip), %rcx      # 0x90f6
movl $0x8b, %edx
callq 0x30f0
movq %rax, %rbx
movl $0x58, %esi
movq %r14, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x32a0