LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc993
movq (%rsi), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rsi,%rax)
jne 0xc9b2
movq %rdx, %rbx
movq %rsi, (%rsp)
testq %rdx, %rdx
js 0xc9d1
movq %rdi, %r15
movl $0x100000, %r12d        # imm = 0x100000
cmpq %r12, %rbx
cmovlq %rbx, %r12
movq %r12, %rdi
callq 0x4030
movq %rax, %r13
testq %rbx, %rbx
je 0xc95e
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 0xc974
movq (%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x44a0
addq %rbp, %r14
cmpq %rbx, %r14
jne 0xc923
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4490
leaq 0x4dcc(%rip), %rdi      # 0x11747
leaq 0x4b2d(%rip), %rsi      # 0x114af
leaq 0x4d6a(%rip), %rcx      # 0x116f3
movl $0xe9, %edx
callq 0x4210
leaq 0x4086(%rip), %rdi      # 0x10a20
leaq 0x4b0e(%rip), %rsi      # 0x114af
leaq 0x4d4b(%rip), %rcx      # 0x116f3
movl $0xdd, %edx
callq 0x4210
leaq 0x4d6f(%rip), %rdi      # 0x11728
leaq 0x4aef(%rip), %rsi      # 0x114af
leaq 0x4d2c(%rip), %rcx      # 0x116f3
movl $0xde, %edx
callq 0x4210
leaq 0x4d5e(%rip), %rdi      # 0x11736
leaq 0x4ad0(%rip), %rsi      # 0x114af
leaq 0x4d0d(%rip), %rcx      # 0x116f3
movl $0xe0, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O1/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 0xca0a
movq (%rdi), %rax
testq %rax, %rax
je 0xca29
cmpq $0x19, 0x8(%rdi)
jle 0xca48
movl 0x16(%rax), %eax
popq %rcx
retq
leaq 0x4d4a(%rip), %rdi      # 0x1175b
leaq 0x4a97(%rip), %rsi      # 0x114af
leaq 0x4d46(%rip), %rcx      # 0x11765
movl $0xf3, %edx
callq 0x4210
leaq 0x4d5a(%rip), %rdi      # 0x1178a
leaq 0x4a78(%rip), %rsi      # 0x114af
leaq 0x4d27(%rip), %rcx      # 0x11765
movl $0xf4, %edx
callq 0x4210
leaq 0x4d4d(%rip), %rdi      # 0x1179c
leaq 0x4a59(%rip), %rsi      # 0x114af
leaq 0x4d08(%rip), %rcx      # 0x11765
movl $0xf5, %edx
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O1/cpearce[P]OggIndex/src/Utils.cpp
// Function: TheoraVersion(th_info*, unsigned char, unsigned char, unsigned char)
int TheoraVersion(th_info* info,
                  unsigned char maj,
                  unsigned char min,
                  unsigned char sub)
{
  ogg_uint32_t ver = (maj << 16) + (min << 8) + sub;
  ogg_uint32_t th_ver = (info->version_major << 16) +
                        (info->version_minor << 8) +
                        info->version_subminor;
  return (th_ver >= ver) ? 1 : 0;
}

// Assembly:
shll $0x10, %esi
shll $0x8, %edx
orl %esi, %edx
orl %ecx, %edx
movzbl (%rdi), %eax
shll $0x10, %eax
movzbl 0x1(%rdi), %ecx
shll $0x8, %ecx
orl %eax, %ecx
movzbl 0x2(%rdi), %esi
orl %ecx, %esi
xorl %eax, %eax
cmpl %edx, %esi
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcb10
decq %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpb $-0x1, 0x1b(%rcx,%rsi)
setne %dil
addl %edi, %eax
incq %rsi
cmpq %rsi, %rdx
jne 0xcafb
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xcb52
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rsi, %rcx
movb %cl, (%rbx,%rax)
shrq $0x8, %rcx
incq %rax
cmpq $0x8, %rax
jne 0xcb26
movq %rbx, %rdi
callq 0xcb90
cmpq %r14, %rax
jne 0xcb71
addq $0x8, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x434f(%rip), %rdi      # 0x10ea8
leaq 0x494f(%rip), %rsi      # 0x114af
leaq 0x4c4b(%rip), %rcx      # 0x117b2
movl $0x12c, %edx            # imm = 0x12C
callq 0x4210
leaq 0x4c7c(%rip), %rdi      # 0x117f4
leaq 0x4930(%rip), %rsi      # 0x114af
leaq 0x4c2c(%rip), %rcx      # 0x117b2
movl $0x131, %edx            # imm = 0x131
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xcbd4
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rsi, %rcx
movb %cl, (%rbx,%rax)
sarq $0x8, %rcx
incq %rax
cmpq $0x8, %rax
jne 0xcba8
movq %rbx, %rdi
callq 0xcc12
cmpq %r14, %rax
jne 0xcbf3
addq $0x8, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x42cd(%rip), %rdi      # 0x10ea8
leaq 0x48cd(%rip), %rsi      # 0x114af
leaq 0x4c1e(%rip), %rcx      # 0x11807
movl $0x13a, %edx            # imm = 0x13A
callq 0x4210
leaq 0x4c4d(%rip), %rdi      # 0x11847
leaq 0x48ae(%rip), %rsi      # 0x114af
leaq 0x4bff(%rip), %rcx      # 0x11807
movl $0x13f, %edx            # imm = 0x13F
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcc3c
xorl %eax, %eax
movl %esi, %ecx
movb %cl, (%rdi,%rax)
shrl $0x8, %ecx
incq %rax
cmpq $0x4, %rax
jne 0xcc20
cmpl %esi, (%rdi)
jne 0xcc5b
addq $0x4, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x4265(%rip), %rdi      # 0x10ea8
leaq 0x4865(%rip), %rsi      # 0x114af
leaq 0x4c08(%rip), %rcx      # 0x11859
movl $0x148, %edx            # imm = 0x148
callq 0x4210
leaq 0x4c39(%rip), %rdi      # 0x1189b
leaq 0x4846(%rip), %rsi      # 0x114af
leaq 0x4be9(%rip), %rcx      # 0x11859
movl $0x14d, %edx            # imm = 0x14D
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O1/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 0xcca0
xorl %eax, %eax
movl %esi, %ecx
movb %cl, (%rdi,%rax)
sarl $0x8, %ecx
incq %rax
cmpq $0x4, %rax
jne 0xcc84
cmpl %esi, (%rdi)
jne 0xccbf
addq $0x4, %rdi
movq %rdi, %rax
popq %rcx
retq
leaq 0x4201(%rip), %rdi      # 0x10ea8
leaq 0x4801(%rip), %rsi      # 0x114af
leaq 0x4bf9(%rip), %rcx      # 0x118ae
movl $0x156, %edx            # imm = 0x156
callq 0x4210
leaq 0x4c28(%rip), %rdi      # 0x118ee
leaq 0x47e2(%rip), %rsi      # 0x114af
leaq 0x4bda(%rip), %rcx      # 0x118ae
movl $0x15b, %edx            # imm = 0x15B
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xccf1
movw %si, (%rdi)
addq $0x2, %rdi
movq %rdi, %rax
retq
pushq %rax
leaq 0x41af(%rip), %rdi      # 0x10ea8
leaq 0x47af(%rip), %rsi      # 0x114af
leaq 0x4bf9(%rip), %rcx      # 0x11900
movl $0x163, %edx            # imm = 0x163
callq 0x4210
// File: /workspace/github_cpp_makefile_star2_O1/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 0x46c0
movq %rax, %r12
decq %rax
cmpq $-0x3, %rax
ja 0xcdab
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 0xcddc
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0xcd85
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 0x46c0
cmpq $-0x1, %rax
je 0xcdab
movq %r12, %rdx
cmpq %rax, %r12
movq %rax, %r12
jne 0xcd52
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 0xcdd4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x43a0
movq %rbx, %rdi
callq 0x46e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1b8(%rbx), %rcx
movq $-0x1, %rax
testq %rcx, %rcx
je 0xea4e
movq 0x1a8(%rbx), %r12
movq 0x10(%r12), %r15
cmpq $-0x1, %r15
je 0xea4e
movb 0x18(%r12), %bpl
decq %rcx
movq %rcx, 0x1b8(%rbx)
movq %r12, %rdi
callq 0x4640
movl $0x20, %esi
movq %r12, %rdi
callq 0x43a0
testb $0x1, %bpl
je 0xea41
movq 0x228(%rbx), %rdi
movq %r15, %rsi
callq 0x40b0
imull $0x3e8, 0x1e0(%rbx), %ecx # imm = 0x3E8
imulq %rcx, %rax
movl 0x1dc(%rbx), %ecx
cqto
idivq %rcx
movq %rax, %r14
movq %r14, %rax
testb $0x1, %bpl
je 0xe9c7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45a0
testl %eax, %eax
jne 0xee22
cmpb $0x1, 0xc(%rbx)
jne 0xee1a
addq $0x200, %rbx            # imm = 0x200
movq %rbx, %rdi
callq 0x4540
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x30cc(%rip), %rdi      # 0x11ef5
leaq 0x2b12(%rip), %rsi      # 0x11942
leaq 0x312a(%rip), %rcx      # 0x11f61
movl $0x116, %edx            # imm = 0x116
callq 0x4210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rdi), %rax
movq 0x88(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
jle 0x38f9
movb 0x1c8(%rbx), %dl
movq 0x20(%rbx), %rsi
movq 0x38(%rbx), %rdi
movq (%r14), %r8
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
testb %dl, %dl
jne 0x38f1
movslq (%rax,%r9,4), %r10
movslq (%rsi,%r10,4), %r11
movslq (%rdi,%r11,4), %r11
subq %r11, (%r8,%r10,8)
incq %r9
cmpq %r9, %rcx
jne 0x38dd
movq 0x80(%rbx), %rax
movq 0x88(%rbx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
jle 0x3952
xorl %r15d, %r15d
movslq (%rax,%r15,4), %r12
movq 0x20(%rbx), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x333c
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 0x3915
movb $0x0, 0x1c8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c21
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 0x2484(%rip), %r14      # 0x5fd0
leaq 0x7cf(%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 0x2452(%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 0x3bf5
movq 0x241a(%rip), %rbx      # 0x5fd0
leaq 0x76e(%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 0x23e8(%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 0x23a5(%rip), %rdi      # 0x5fd0
callq 0x2160
leaq 0x6ce(%rip), %rsi       # 0x4305
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
jmp 0x3c82
jmp 0x3c82
jmp 0x3c82
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 0x3c82
jmp 0x3c82
movq %rax, %rdi
callq 0x378f
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45ff
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3100
movq %rax, %rdi
movq %r15, %rsi
callq 0x4509
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 0x47d4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x48be
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_O1/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 0x45ff
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x3100
movq %rax, %rdi
movq %r15, %rsi
callq 0x4509
movq %rax, %rdi
movq %r12, %rsi
callq 0x4509
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 0x4916
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4a52
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_O1/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 0x45ff
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3100
movq %rax, %rdi
movq %r15, %rsi
callq 0x4509
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 0x4aaa
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4b72
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_O1/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 0x45ff
movq %rax, %rdi
movq %r15, %rsi
callq 0x4509
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 0x5c1a
movsd %xmm0, 0x20(%r12,%r14,8)
incq %r14
cmpq $0x3, %r14
jne 0x37a5
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4bca
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_O1/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 0x45ff
movq %rax, %rdi
movq %r14, %rsi
callq 0x4509
movq %rax, %rdi
movq %r15, %rsi
callq 0x4509
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 0x38df
movl $0x58, %edi
callq 0x31c0
movq %rax, %r14
movb $0x1, %r15b
leaq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x4c76
leaq -0xb0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4cf0
movss -0x1c(%rbp), %xmm0
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
movq %r14, %rdi
callq 0x4da4
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e8e
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x57ba(%rip), %rdi      # 0x90a0
leaq 0x57fb(%rip), %rsi      # 0x90e8
leaq 0x5802(%rip), %rcx      # 0x90f6
movl $0x8b, %edx
callq 0x30f0
movq %rax, %rbx
testb %r15b, %r15b
je 0x3913
movl $0x58, %esi
movq %r14, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/driver.cc
// Function: readAreaLight(std::istream&)
sp_arealightd readAreaLight(istream &is) {
	rgbcolord color;
	vector3d center, normal, upDir;
	double hspace, vspace, width, height;
	cin >> color >> center >> normal >> upDir >> hspace >> vspace >> width
		>> height;
	sp_arealightd x(new arealightd(
			color, center, normal, upDir, hspace, vspace, width, height));
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, -0x30(%rbp)
xorl %eax, %eax
leaq -0xd0(%rbp), %rcx
movq %rax, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movq %rcx, %rsi
leaq -0xb0(%rbp), %rbx
movq %rax, 0x10(%rbx)
movaps %xmm0, (%rbx)
leaq -0x90(%rbp), %r14
movq %rax, 0x10(%r14)
movaps %xmm0, (%r14)
leaq -0x70(%rbp), %r15
movq %rax, 0x10(%r15)
movaps %xmm0, (%r15)
movq 0xa65f(%rip), %rdi      # 0xdfd8
callq 0x45ff
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4509
movq %rax, %rdi
movq %r14, %rsi
callq 0x4509
movq %rax, %rdi
movq %r15, %rsi
callq 0x4509
leaq -0x50(%rbp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3100
leaq -0x48(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3100
leaq -0x40(%rbp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x3100
leaq -0x38(%rbp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x3100
movl $0xb8, %edi
callq 0x31c0
movq %rax, %r14
movsd (%rbx), %xmm0
movsd (%r15), %xmm1
movsd (%r12), %xmm2
movsd (%r13), %xmm3
movq %rax, %rdi
leaq -0xd0(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
leaq -0x90(%rbp), %rcx
leaq -0x70(%rbp), %r8
callq 0x4ee6
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x509c
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xb8, %esi
movq %r14, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/driver.cc
// Function: readCamera(std::istream&)
sp_camerad readCamera(istream &is) {
	vector3d vec1;
	vector3d vec2;
	vector3d vec3;
	cin >> vec1 >> vec2 >> vec3;
	sp_camerad x(new camerad(vec1, vec2, vec3));
	return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq -0x80(%rbp), %r14
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq -0x60(%rbp), %r15
movq %rax, 0x10(%r15)
movaps %xmm0, (%r15)
leaq -0x40(%rbp), %r12
movq %rax, 0x10(%r12)
movaps %xmm0, (%r12)
movq 0xa538(%rip), %rdi      # 0xdfd8
movq %r14, %rsi
callq 0x4509
movq %rax, %rdi
movq %r15, %rsi
callq 0x4509
movq %rax, %rdi
movq %r12, %rsi
callq 0x4509
movl $0x70, %edi
callq 0x31c0
movq %rax, %r13
movsd 0x5545(%rip), %xmm0     # 0x9018
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x50f4
movq %rbx, %rdi
movq %r13, %rsi
callq 0x52ce
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x70, %esi
movq %r13, %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/driver.cc
// Function: usage(char*)
void usage(char *progname) {
	cout << "---> Usage: " << progname
			<< ": <width in pixels> <height in pixels> -s" << endl;
	cout << "---> -s is for shadows and must be the last argument." << endl;
	cout << "---> It's intended for scene descriptions to be sent in with"
			<< " redirection like: " << endl
			<< "       " << progname << " 640 480 < inputfile.dat" << endl;
	cout << "---> See example.dat for the scene description format."
			<< endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xa49b(%rip), %rbx      # 0xdfc8
leaq 0x55e9(%rip), %rsi      # 0x911d
movl $0xc, %edx
movq %rbx, %rdi
callq 0x31f0
testq %r14, %r14
je 0x3b62
movq %r14, %rdi
callq 0x30b0
movq 0xa473(%rip), %rdi      # 0xdfc8
movq %r14, %rsi
movq %rax, %rdx
callq 0x31f0
jmp 0x3b79
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x3280
leaq 0x55aa(%rip), %rsi      # 0x912a
movl $0x29, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
leaq 0x5599(%rip), %rsi      # 0x9154
movl $0x35, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
leaq 0x5594(%rip), %rsi      # 0x918a
movl $0x3c, %edx
movq %rbx, %rdi
callq 0x31f0
leaq 0x55bd(%rip), %rsi      # 0x91c7
movl $0x13, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
movq %rax, %r15
leaq 0x5593(%rip), %rsi      # 0x91db
movl $0x7, %edx
movq %rax, %rdi
callq 0x31f0
testq %r14, %r14
je 0x3c72
movq %r14, %rdi
callq 0x30b0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x31f0
jmp 0x3c8c
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x3280
leaq 0x5550(%rip), %rsi      # 0x91e3
movl $0x18, %edx
movq %r15, %rdi
callq 0x31f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3110
leaq 0x552e(%rip), %rsi      # 0x91fc
movl $0x36, %edx
movq %rbx, %rdi
callq 0x31f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3110
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/mvector.hh
// Function: std::istream& operator>><double, 3>(std::istream&, mvector<double, 3>&)
std::istream & operator>>(std::istream& is, mvector<T, size> &v) {

	if(!is) { // If not ready...
		return is; // ...already failed, just return.
	}

	// Configure istream to throw an exception if the failbit gets set below.
	is.exceptions(std::ios_base::failbit);

	// Otherwise get the first char.
	char c;
	is >> c;
	if (c == '<') { // If it's the start of a vector, then...

		assert(size > 0);
		int i = 0;
		do {
			is >> v[i] >> c;
			if (c != ',') { // If wasn't a comma after coordinate, bad format.
				is.clear(std::ios_base::failbit);
			}
			i++;
		} while (i < size - 1);

		// When we reach here we have one coordinate left to read.
		assert(i == size - 1);
		is >> v[size - 1] >> c;
		if (c != '>') { // If no closing bracket, then bad format.
			is.clear(std::ios_base::failbit);
		}

	}
	else { // If first char wasn't <, put it back into the stream and return.
		is.putback(c);
		return is;
	}

	return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rdi
movl 0x20(%rbx,%rdi), %esi
testb $0x5, %sil
jne 0x45ef
addq %rbx, %rdi
movl $0x4, 0x1c(%rdi)
callq 0x3280
leaq -0x21(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3210
movb (%r15), %al
cmpb $0x3c, %al
jne 0x45e4
xorl %esi, %esi
movb $0x1, %r12b
movq %r14, %rdi
callq 0x4c22
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3100
movq %rax, %rdi
movq %r15, %rsi
callq 0x3210
cmpb $0x2c, -0x21(%rbp)
je 0x4599
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0x4, %esi
callq 0x3280
movl $0x1, %esi
testb $0x1, %r12b
movl $0x0, %r12d
jne 0x4561
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3100
leaq -0x21(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3210
cmpb $0x3e, (%r14)
je 0x45ef
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0x4, %esi
callq 0x3280
jmp 0x45ef
movsbl %al, %esi
movq %rbx, %rdi
callq 0x32d0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3>::operator-(mvector<double, 3> const&) const
const mvector<T, size> operator-(const mvector<T, size> &rhs) const {
		mvector tmp = *this;
		for (int i = 0; i < size; i++)
			tmp[i] -= rhs[i];
		return tmp;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x5c1a
movsd %xmm0, (%r14,%r12,8)
incq %r12
cmpq $0x3, %r12
jne 0x4c91
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5c1a
movsd %xmm0, -0x28(%rbp)
movq %r14, %rdi
movl %r15d, %esi
callq 0x4c22
movsd (%rax), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rax)
incl %r15d
cmpl $0x3, %r15d
jne 0x4cae
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3>::norm() const
mvector<T, size> norm() const {
    	mvector vec(*this);
    	T magnitude = mag();
    	for (int i = 0; i < size; i++)
    		vec[i] /= magnitude;
    	return vec;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5c1a
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq $0x3, %r15
jne 0x4d03
xorpd %xmm1, %xmm1
xorl %r15d, %r15d
movsd %xmm1, -0x20(%rbp)
movq %r14, %rdi
movl %r15d, %esi
callq 0x5c1a
movsd -0x20(%rbp), %xmm1
mulsd (%r14,%r15,8), %xmm0
addsd %xmm0, %xmm1
incq %r15
cmpq $0x3, %r15
jne 0x4d24
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x4d5f
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x4d68
movapd %xmm1, %xmm0
callq 0x3170
xorl %r14d, %r14d
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4c22
movsd -0x20(%rbp), %xmm0
movsd (%rax), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax)
incl %r14d
cmpl $0x3, %r14d
jne 0x4d70
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/arealight.hh
// Function: arealight<double, double, double, 3>::arealight(rgbcolor<double> const&, mvector<double, 3> const&, mvector<double, 3> const&, mvector<double, 3> const&, double, double, double, double)
arealight(const rgbcolor<color_T> &color, const mvector<vec_T, dim> &center,
			const mvector<vec_T, dim> &surfaceNormal,
			const mvector<vec_T, dim> &upDirection,
			vec_T horizontalSpacing, vec_T verticalSpacing,
			vec_T width, vec_T height) :
				light<vec_T, color_T, time_T, dim>(color, center),
				norm(surfaceNormal.norm()),
				horizontalSpacing(horizontalSpacing),
				verticalSpacing(verticalSpacing),
				width(width), height(height) {

		// After the initializer list ends we still need to deal with
		// vhat, uhat, and the lights collection.
		assert(dim > 0);
		assert(horizontalSpacing > 0);
		assert(verticalSpacing > 0);
		assert(horizontalSpacing < width);
		assert(verticalSpacing < height);

		constructorHelper(upDirection);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm3, -0x48(%rbp)
movsd %xmm2, -0x38(%rbp)
movsd %xmm1, -0x40(%rbp)
movsd %xmm0, -0x30(%rbp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq %rax, -0x50(%rbp)
movups (%rsi), %xmm0
movaps %xmm0, -0x60(%rbp)
leaq 0x89d3(%rip), %rax      # 0xd900
movq %rax, (%rdi)
movapd -0x60(%rbp), %xmm0
movupd %xmm0, 0x8(%rdi)
movq -0x50(%rbp), %rax
movq %rax, 0x18(%rdi)
leaq 0x8c0f(%rip), %rax      # 0xdb58
movq %rax, (%rdi)
xorl %r13d, %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0x5c1a
movsd %xmm0, 0x20(%rbx,%r13,8)
incq %r13
cmpq $0x3, %r13
jne 0x4f4f
leaq 0x8d37(%rip), %rax      # 0xdca8
movq %rax, (%rbx)
leaq 0x38(%rbx), %rdi
movq %r15, %rsi
callq 0x4cf0
movsd -0x30(%rbp), %xmm5
movsd %xmm5, 0x50(%rbx)
movsd -0x40(%rbp), %xmm3
movsd %xmm3, 0x58(%rbx)
movsd -0x38(%rbp), %xmm4
movsd %xmm4, 0x60(%rbx)
movsd -0x48(%rbp), %xmm2
movsd %xmm2, 0x68(%rbx)
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm5
xorps %xmm1, %xmm1
movups %xmm1, 0x70(%rbx)
movups %xmm1, 0x80(%rbx)
movups %xmm1, 0x90(%rbx)
movups %xmm1, 0xa0(%rbx)
movq $0x0, 0xb0(%rbx)
jbe 0x5005
ucomisd %xmm0, %xmm3
jbe 0x5024
ucomisd %xmm5, %xmm4
jbe 0x5043
ucomisd %xmm3, %xmm2
jbe 0x5062
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6bea
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x493f(%rip), %rdi      # 0x994b
leaq 0x494e(%rip), %rsi      # 0x9961
leaq 0x4958(%rip), %rcx      # 0x9972
movl $0xb5, %edx
callq 0x30f0
leaq 0x4a42(%rip), %rdi      # 0x9a6d
leaq 0x492f(%rip), %rsi      # 0x9961
leaq 0x4939(%rip), %rcx      # 0x9972
movl $0xb6, %edx
callq 0x30f0
leaq 0x4a37(%rip), %rdi      # 0x9a81
leaq 0x4910(%rip), %rsi      # 0x9961
leaq 0x491a(%rip), %rcx      # 0x9972
movl $0xb7, %edx
callq 0x30f0
leaq 0x4a32(%rip), %rdi      # 0x9a9b
leaq 0x48f1(%rip), %rsi      # 0x9961
leaq 0x48fb(%rip), %rcx      # 0x9972
movl $0xb8, %edx
callq 0x30f0
movq %rax, %r14
addq $0xa0, %rbx
movq %rbx, %rdi
callq 0x599a
movq %r14, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/camera.hh
// Function: camera<double, double, 3>::camera(mvector<double, 3> const&, mvector<double, 3> const&, mvector<double, 3> const&, double)
camera(const mvector<vec_T, dim> &position,
			const mvector<vec_T, dim> &lookAt,
			const mvector<vec_T, dim> &upDir,
			vec_T fieldOfView = M_PI / 3) : pos(position), fov(fieldOfView) {
		dir = (lookAt - pos).norm();
		right = (dir % upDir).norm();
		up = (right % dir).norm();
		dist = 0.5 / tan((double)fov / 2);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm0, -0x30(%rbp)
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
xorl %r13d, %r13d
movq %r15, %rdi
movl %r13d, %esi
callq 0x5c1a
movsd %xmm0, (%rbx,%r13,8)
incq %r13
cmpq $0x3, %r13
jne 0x5119
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
xorl %r13d, %r13d
movq %r13, 0x28(%rbx)
movsd -0x30(%rbp), %xmm1
movsd %xmm1, 0x30(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x4c76
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4cf0
movq 0x10(%r12), %rax
movq %rax, 0x28(%rbx)
movups (%r12), %xmm0
movups %xmm0, 0x18(%rbx)
movq %r13, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movsd 0x20(%rbx), %xmm2
movsd 0x28(%rbx), %xmm3
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm2, %xmm5
mulsd %xmm1, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, (%r15)
movsd 0x18(%rbx), %xmm4
movsd (%r14), %xmm5
mulsd %xmm5, %xmm3
mulsd %xmm4, %xmm1
subsd %xmm1, %xmm3
movsd %xmm3, 0x8(%r15)
mulsd %xmm2, %xmm5
mulsd %xmm0, %xmm4
subsd %xmm5, %xmm4
movsd %xmm4, 0x10(%r15)
leaq -0x68(%rbp), %r15
leaq -0x50(%rbp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x4cf0
movq 0x10(%r15), %rax
movq %rax, 0x60(%rbx)
movups (%r15), %xmm0
movups %xmm0, 0x50(%rbx)
movq %r13, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movsd 0x58(%rbx), %xmm0
movsd 0x20(%rbx), %xmm1
movsd 0x28(%rbx), %xmm2
movsd 0x60(%rbx), %xmm3
movapd %xmm1, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm0, %xmm5
mulsd %xmm2, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, (%r14)
movsd 0x18(%rbx), %xmm4
movsd 0x50(%rbx), %xmm5
mulsd %xmm4, %xmm3
mulsd %xmm5, %xmm2
subsd %xmm2, %xmm3
movsd %xmm3, 0x8(%r14)
mulsd %xmm0, %xmm4
mulsd %xmm1, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, 0x10(%r14)
leaq -0x68(%rbp), %r14
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x4cf0
movq 0x10(%r14), %rax
movq %rax, 0x48(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x38(%rbx)
movsd 0x30(%rbx), %xmm0
mulsd 0x3d78(%rip), %xmm0     # 0x9020
callq 0x30e0
movsd 0x3d6b(%rip), %xmm1     # 0x9020
divsd %xmm0, %xmm1
movsd %xmm1, 0x68(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/scene.hh
// Function: scene<double, double, double, 3>::addAreaLight(boost::shared_ptr<arealight<double, double, double, 3>>)
void addAreaLight(sp_arealight theLight) {
		assert(theLight != 0);
		typename std::vector<boost::shared_ptr<
			light<vec_T, color_T, time_T, dim> > >::const_iterator iter;
		for(iter = theLight->getLights().begin();
				iter < theLight->getLights().end(); iter++) {
			addPointLight(*iter);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x556b
movq %rsi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x553d
movq %rdi, %r14
movq 0xa0(%rcx), %r13
leaq -0x30(%rbp), %r15
leaq -0x38(%rbp), %r12
cmpq 0xa8(%rax), %r13
jae 0x555c
movq (%r13), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%r13), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x551e
lock
incl 0x8(%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x5462
movq %r15, %rdi
callq 0x581c
addq $0x10, %r13
movq (%rbx), %rax
testq %rax, %rax
jne 0x54fc
leaq 0x463f(%rip), %rdi      # 0x9b83
leaq 0x4640(%rip), %rsi      # 0x9b8b
leaq 0x4942(%rip), %rcx      # 0x9e94
movl $0x2d8, %edx            # imm = 0x2D8
callq 0x30f0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x479a(%rip), %rdi      # 0x9d0c
leaq 0x470f(%rip), %rsi      # 0x9c88
leaq 0x4895(%rip), %rcx      # 0x9e15
movl $0x9f, %edx
callq 0x30f0
movq %rax, %rbx
movq %r15, %rdi
callq 0x581c
movq %rbx, %rdi
callq 0x32a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3>::print(std::ostream&) const
void print(std::ostream &os) const {
    	int i = 0;
    	os << "<";
    	do {
    		os << v[i];
    		if (i + 1 != size)
    			os << ", ";
    	} while (++i < size);
    	os << ">";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3922(%rip), %rsi      # 0x95a8
movl $0x1, %edx
movq %rbx, %rdi
callq 0x31f0
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x3260
xorl %r12d, %r12d
leaq 0x3860(%rip), %r15      # 0x950a
movl $0x2, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31f0
movsd 0x8(%r14,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x3260
incq %r12
cmpq $0x2, %r12
jne 0x5caa
leaq 0x38d1(%rip), %rsi      # 0x95aa
movl $0x1, %edx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3> const operator*<double, 3>(mvector<double, 3> const&, double)
const mvector<T, size> operator*(const mvector<T, size> &lhs, T scalar) {
	mvector<T, size> tmp = lhs;
	for (int i = 0; i < lhs.dim(); i++)
		tmp[i] *= scalar;
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, -0x20(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x5c1a
movsd %xmm0, (%rbx,%r15,8)
incq %r15
cmpq $0x3, %r15
jne 0x667b
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4c22
movsd (%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
incl %r14d
cmpl $0x3, %r14d
jne 0x6698
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/infplane.hh
// Function: infplane<double, double, double, 3>::intersection(ray<double, double, 3> const&) const
time_T intersection(const ray<vec_T, time_T, dim> &r) const {
		vec_T denom = r.getDir() * surfNorm;
		if (denom == 0)
			return RAY_MISS;
		time_T t= (time_T) (-(r.getOrig() * surfNorm + dist) / denom);
		if (t < 0)
			return RAY_MISS;
		return t;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
movsd %xmm0, -0x28(%rbp)
movq %r15, %rdi
movl %r12d, %esi
callq 0x5c1a
mulsd 0x18(%r14,%r12,8), %xmm0
movsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
incq %r12
cmpq $0x3, %r12
jne 0x681e
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x6867
jp 0x6867
movsd 0x27db(%rip), %xmm0     # 0x9040
jmp 0x68c5
xorl %r12d, %r12d
movapd %xmm2, -0x40(%rbp)
movq %r15, %rdi
movl %r12d, %esi
callq 0x5c1a
movapd -0x40(%rbp), %xmm2
mulsd (%r14,%r12,8), %xmm0
addsd %xmm0, %xmm2
incq %r12
cmpq $0x3, %r12
jne 0x686a
addsd 0x28(%rbx), %xmm2
xorpd 0x27f1(%rip), %xmm2     # 0x9090
divsd -0x28(%rbp), %xmm2
xorpd %xmm0, %xmm0
movapd %xmm2, %xmm1
cmpltsd %xmm0, %xmm1
movsd 0x2787(%rip), %xmm0     # 0x9040
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hamikm[P]Raytracer/src/camera.hh
// Function: camera<double, double, 3>::getRayForPixel(int, int, int, int) const
ray<vec_T, time_T, dim> getRayForPixel(int x, int y,
			int width, int height) const {
		assert(x >= 0);
		assert(y >= 0);
		assert(width > 0);
		assert(height > 0);
		vec_T centerx = ((vec_T) width) / height / 2;
	    mvector<vec_T, dim> pixelDir = dist * dir +
	    		(0.5 - (vec_T) y / (vec_T) (height - 1)) * up +
				((vec_T) x / (vec_T) (height - 1) - centerx) * right;

	    ray<vec_T, time_T, dim> pixelRay(pos, pixelDir);
	    return pixelRay;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
testl %edx, %edx
js 0x7fed
movl %ecx, %r13d
testl %ecx, %ecx
js 0x800c
testl %r8d, %r8d
jle 0x802b
movl %r9d, %r12d
testl %r9d, %r9d
jle 0x804a
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cvtsi2sd %r8d, %xmm1
cvtsi2sd %r12d, %xmm0
divsd %xmm0, %xmm1
mulsd 0x10ff(%rip), %xmm1     # 0x9020
movsd %xmm1, -0x38(%rbp)
movsd 0x68(%rsi), %xmm0
addq $0x18, %rsi
leaq -0x50(%rbp), %rdi
callq 0x88f9
cvtsi2sd %r13d, %xmm2
decl %r12d
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movsd %xmm0, -0x30(%rbp)
divsd %xmm0, %xmm2
movsd 0x10c7(%rip), %xmm0     # 0x9020
subsd %xmm2, %xmm0
leaq 0x38(%r14), %rsi
leaq -0x80(%rbp), %r12
movq %r12, %rdi
callq 0x88f9
leaq -0x98(%rbp), %r13
movq %r13, %rdi
leaq -0x50(%rbp), %rsi
movq %r12, %rdx
callq 0x65ea
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
divsd -0x30(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
leaq 0x50(%r14), %rsi
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x88f9
leaq -0xb0(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x65ea
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rdi
addq $0x18, %rdi
movq %r12, %rsi
callq 0x4cf0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x153a(%rip), %rdi      # 0x952e
leaq 0x1f46(%rip), %rsi      # 0x9f41
leaq 0x1f4d(%rip), %rcx      # 0x9f4f
movl $0x6a, %edx
callq 0x30f0
leaq 0x1fc3(%rip), %rdi      # 0x9fd6
leaq 0x1f27(%rip), %rsi      # 0x9f41
leaq 0x1f2e(%rip), %rcx      # 0x9f4f
movl $0x6b, %edx
callq 0x30f0
leaq 0x1fab(%rip), %rdi      # 0x9fdd
leaq 0x1f08(%rip), %rsi      # 0x9f41
leaq 0x1f0f(%rip), %rcx      # 0x9f4f
movl $0x6c, %edx
callq 0x30f0
leaq 0x155b(%rip), %rdi      # 0x95ac
leaq 0x1ee9(%rip), %rsi      # 0x9f41
leaq 0x1ef0(%rip), %rcx      # 0x9f4f
movl $0x6d, %edx
callq 0x30f0
nop