LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: todo314[P]pruned-monte-carlo/src/pmc.cpp
// Function: PrunedEstimater::unique_child(int)
inline int PrunedEstimater::unique_child(const int v) {
	int outdeg = 0, child = -1;
	for (int i = at_e[v]; i < at_e[v + 1]; i++) {
		const int u = es[i];
		if (!removed[u]) {
			outdeg++;
			child = u;
		}
	}
	if (outdeg == 0) {
		return -1;
	} else if (outdeg == 1) {
		return child;
	} else {
		return -2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x0, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
addq $0x118, %rdi            # imm = 0x118
movslq -0x14(%rbp), %rsi
callq 0x29c0
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x118, %rdi            # imm = 0x118
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x29c0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl (%rcx), %eax
jge 0x7ad8
movq -0x40(%rbp), %rdi
addq $0xe8, %rdi
movslq -0x20(%rbp), %rsi
callq 0x29c0
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x24(%rbp)
addq $0xc0, %rdi
movslq -0x24(%rbp), %rsi
callq 0x7930
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7990
xorb $-0x1, %al
testb $0x1, %al
jne 0x7ab9
jmp 0x7ac8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x7aca
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7a4a
cmpl $0x0, -0x18(%rbp)
jne 0x7ae7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7afc
cmpl $0x1, -0x18(%rbp)
jne 0x7af5
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7afc
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: todo314[P]pruned-monte-carlo/src/pmc.hpp
// Function: Xorshift::Xorshift(int)
Xorshift(int seed) {
		x = _(seed, 0);
		y = _(x, 1);
		z = _(y, 2);
		w = _(z, 3);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x87d0
movq -0x18(%rbp), %rdi
movl %eax, (%rdi)
movl (%rdi), %esi
movl $0x1, %edx
callq 0x87d0
movq -0x18(%rbp), %rdi
movl %eax, 0x4(%rdi)
movl 0x4(%rdi), %esi
movl $0x2, %edx
callq 0x87d0
movq -0x18(%rbp), %rdi
movl %eax, 0x8(%rdi)
movl 0x8(%rdi), %esi
movl $0x3, %edx
callq 0x87d0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: todo314[P]pruned-monte-carlo/src/pmc.hpp
// Function: Xorshift::gen_int()
inline int gen_int() {
		unsigned int t = x ^ (x << 11);
		x = y;
		y = z;
		z = w;
		return w = w ^ (w >> 19) ^ t ^ (t >> 8);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl (%rcx), %eax
movl (%rcx), %edx
shll $0xb, %edx
xorl %edx, %eax
movl %eax, -0xc(%rbp)
movl 0x4(%rcx), %eax
movl %eax, (%rcx)
movl 0x8(%rcx), %eax
movl %eax, 0x4(%rcx)
movl 0xc(%rcx), %eax
movl %eax, 0x8(%rcx)
movl 0xc(%rcx), %eax
movl 0xc(%rcx), %edx
shrl $0x13, %edx
xorl %edx, %eax
xorl -0xc(%rbp), %eax
movl -0xc(%rbp), %edx
shrl $0x8, %edx
xorl %edx, %eax
movl %eax, 0xc(%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
jge 0x5317
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq 0x3ce3(%rip), %rdi      # 0x8fd0
callq 0x2100
movq %rax, %rdi
leaq 0x101d(%rip), %rsi      # 0x6319
callq 0x2100
movq %rax, %rdi
movq 0x3cb5(%rip), %rsi      # 0x8fc0
callq 0x2130
xorl %edi, %edi
callq 0x2150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x4410
leaq -0xd8(%rbp), %rdi
callq 0x4410
jmp 0x5352
leaq -0x140(%rbp), %rdi
callq 0x4410
jmp 0x5360
movl $0x0, -0x144(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x2e70
movl %eax, -0x148(%rbp)
jmp 0x537f
movl -0x148(%rbp), %eax
movl %eax, -0x144(%rbp)
movq -0x20(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x2e70
movl %eax, -0x14c(%rbp)
jmp 0x53a3
movl -0x14c(%rbp), %eax
movl %eax, -0x144(%rbp)
movq 0x3c1a(%rip), %rdi      # 0x8fd0
leaq 0xf79(%rip), %rsi       # 0x6336
callq 0x2100
movq %rax, -0x158(%rbp)
jmp 0x53cb
movq -0x158(%rbp), %rdi
movq 0x3be7(%rip), %rsi      # 0x8fc0
callq 0x2130
jmp 0x53e0
leaq -0x80(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq -0x140(%rbp), %rdx
callq 0x3d80
movl %eax, -0x15c(%rbp)
jmp 0x53ff
movl -0x15c(%rbp), %eax
movl %eax, -0x144(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x140(%rbp), %rdi
callq 0x2a10
movl %eax, -0x160(%rbp)
jmp 0x5423
movl -0x160(%rbp), %eax
movl %eax, -0x144(%rbp)
cmpl $0x0, -0x144(%rbp)
jne 0x54b3
movq 0x3b91(%rip), %rdi      # 0x8fd0
leaq 0xef9(%rip), %rsi       # 0x633f
callq 0x2100
movq %rax, -0x168(%rbp)
jmp 0x5454
movq -0x168(%rbp), %rdi
movq 0x3b5e(%rip), %rsi      # 0x8fc0
callq 0x2130
jmp 0x5469
jmp 0x54b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x54f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x54e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x44d0
jmp 0x54e7
movl $0x0, -0x4(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x44d0
leaq -0xd8(%rbp), %rdi
callq 0x44d0
leaq -0x80(%rbp), %rdi
callq 0x44d0
movl -0x4(%rbp), %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
leaq -0xd8(%rbp), %rdi
callq 0x44d0
leaq -0x80(%rbp), %rdi
callq 0x44d0
movq -0xe0(%rbp), %rdi
callq 0x2210
// File: 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
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4a70
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4aa0
movq -0x80(%rbp), %rsi
movq 0x15a3f(%rip), %rdi     # 0x18fd8
callq 0x4c40
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x31e0
movq -0x78(%rbp), %rsi
movq %rax, %rdi
callq 0x4ae0
movq %rax, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3070
movb $0x0, -0x51(%rbp)
movl $0x48, %edi
callq 0x3250
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movsd -0x38(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
callq 0x4da0
jmp 0x35f3
movq -0x70(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x4e80
movb $0x1, -0x51(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x3637
jmp 0x362b
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
movl $0x48, %esi
callq 0x3260
jmp 0x3647
movq -0x90(%rbp), %rdi
callq 0x4ef0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3380
// File: 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
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4a70
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4aa0
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x4aa0
movq -0xa8(%rbp), %rsi
movq 0x15926(%rip), %rdi     # 0x18fd8
callq 0x4c40
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x31e0
movq -0xa0(%rbp), %rsi
movq %rax, %rdi
callq 0x4ae0
movq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0x4ae0
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
callq 0x31e0
movq %rax, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3070
movb $0x0, -0x71(%rbp)
movl $0x68, %edi
callq 0x3250
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0x98(%rbp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
callq 0x4f10
jmp 0x373f
movq -0x90(%rbp), %rsi
movq -0xb8(%rbp), %rdi
callq 0x5040
movb $0x1, -0x71(%rbp)
testb $0x1, -0x71(%rbp)
jne 0x378c
jmp 0x3780
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
movl $0x68, %esi
callq 0x3260
jmp 0x379c
movq -0xb8(%rbp), %rdi
callq 0x4ef0
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4a70
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4aa0
movq -0x80(%rbp), %rsi
movq 0x157df(%rip), %rdi     # 0x18fd8
callq 0x4c40
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x31e0
movq -0x78(%rbp), %rsi
movq %rax, %rdi
callq 0x4ae0
movq %rax, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3070
movb $0x0, -0x51(%rbp)
movl $0x48, %edi
callq 0x3250
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movsd -0x38(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
callq 0x50b0
jmp 0x3853
movq -0x70(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x5190
movb $0x1, -0x51(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x3897
jmp 0x388b
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
movl $0x48, %esi
callq 0x3260
jmp 0x38a7
movq -0x90(%rbp), %rdi
callq 0x4ef0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3380
// File: 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
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4a70
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4aa0
movq -0x70(%rbp), %rsi
movq 0x156e5(%rip), %rdi     # 0x18fd8
callq 0x4c40
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x4ae0
movb $0x0, -0x41(%rbp)
movl $0x38, %edi
callq 0x3250
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x5200
jmp 0x392b
movq -0x60(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x5290
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x3969
jmp 0x3960
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x38, %esi
callq 0x3260
jmp 0x3976
movq -0x80(%rbp), %rdi
callq 0x5300
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3380
nop
// File: 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
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4a70
leaq -0x40(%rbp), %rdi
callq 0x4aa0
leaq -0x58(%rbp), %rdi
callq 0x4aa0
movq 0x15612(%rip), %rdi     # 0x18fd8
leaq -0x28(%rbp), %rsi
callq 0x4c40
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
callq 0x4ae0
movq %rax, %rdi
leaq -0x58(%rbp), %rsi
callq 0x4ae0
movq %rax, %rdi
leaq -0x5c(%rbp), %rsi
callq 0x3070
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x5320
movsd (%rax), %xmm0
movsd %xmm0, -0xa8(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x5320
movsd -0xa8(%rbp), %xmm0
movq %rax, %rcx
xorl %eax, %eax
ucomisd (%rcx), %xmm0
movb %al, -0x9d(%rbp)
jne 0x3abd
jp 0x3abd
leaq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0x5320
movsd (%rax), %xmm0
movsd %xmm0, -0xc0(%rbp)
leaq -0x58(%rbp), %rdi
movl $0x1, %esi
callq 0x5320
movsd -0xc0(%rbp), %xmm0
movq %rax, %rcx
xorl %eax, %eax
ucomisd (%rcx), %xmm0
movb %al, -0x9d(%rbp)
jne 0x3abd
jp 0x3abd
leaq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0x5320
movsd (%rax), %xmm0
movsd %xmm0, -0xc8(%rbp)
leaq -0x58(%rbp), %rdi
movl $0x2, %esi
callq 0x5320
movsd -0xc8(%rbp), %xmm0
ucomisd (%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x9d(%rbp)
movb -0x9d(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3acb
jmp 0x3acd
jmp 0x3aec
leaq 0xc588(%rip), %rdi      # 0x1005c
leaq 0xc5c9(%rip), %rsi      # 0x100a4
movl $0x8b, %edx
leaq 0xc5cb(%rip), %rcx      # 0x100b2
callq 0x3140
movb $0x0, -0x5d(%rbp)
movl $0x58, %edi
callq 0x3250
movq %rax, -0xd0(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x53a0
jmp 0x3b17
leaq -0x78(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x5420
jmp 0x3b29
movq -0xd0(%rbp), %rdi
movss -0x5c(%rbp), %xmm0
leaq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x78(%rbp), %rcx
callq 0x54a0
jmp 0x3b48
movq -0xd0(%rbp), %rsi
movq -0xb8(%rbp), %rdi
callq 0x5580
movb $0x1, -0x5d(%rbp)
testb $0x1, -0x5d(%rbp)
jne 0x3b98
jmp 0x3b8c
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
movl $0x58, %esi
callq 0x3260
jmp 0x3ba8
movq -0xb8(%rbp), %rdi
callq 0x55f0
movq -0xb0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x4a70
leaq -0x40(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x4aa0
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x4aa0
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4aa0
movq -0xd0(%rbp), %rsi
movq 0x153a6(%rip), %rdi     # 0x18fd8
callq 0x4c40
movq -0xc8(%rbp), %rsi
movq %rax, %rdi
callq 0x4ae0
movq -0xc0(%rbp), %rsi
movq %rax, %rdi
callq 0x4ae0
movq -0xb8(%rbp), %rsi
movq %rax, %rdi
callq 0x4ae0
movq %rax, %rdi
leaq -0x78(%rbp), %rsi
callq 0x31e0
movq %rax, %rdi
leaq -0x80(%rbp), %rsi
callq 0x31e0
movq %rax, %rdi
leaq -0x88(%rbp), %rsi
callq 0x31e0
movq %rax, %rdi
leaq -0x90(%rbp), %rsi
callq 0x31e0
movb $0x0, -0x91(%rbp)
movl $0xb8, %edi
callq 0x3250
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq -0xc0(%rbp), %rcx
movq -0xb8(%rbp), %r8
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movsd -0x78(%rbp), %xmm0
movsd -0x80(%rbp), %xmm1
movsd -0x88(%rbp), %xmm2
movsd -0x90(%rbp), %xmm3
callq 0x5610
jmp 0x3cf5
movq -0xb0(%rbp), %rsi
movq -0xe0(%rbp), %rdi
callq 0x57e0
movb $0x1, -0x91(%rbp)
testb $0x1, -0x91(%rbp)
jne 0x3d4b
jmp 0x3d3f
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
movl $0xb8, %esi
callq 0x3260
jmp 0x3d5b
movq -0xe0(%rbp), %rdi
callq 0x5850
movq -0xd8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x3380
nopw (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4aa0
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4aa0
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4aa0
movq -0x90(%rbp), %rsi
movq 0x15209(%rip), %rdi     # 0x18fd8
callq 0x4ae0
movq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0x4ae0
movq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x4ae0
movb $0x0, -0x59(%rbp)
movl $0x70, %edi
callq 0x3250
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movsd 0xc1ef(%rip), %xmm0     # 0x10010
callq 0x5870
jmp 0x3e28
movq -0x78(%rbp), %rsi
movq -0xa0(%rbp), %rdi
callq 0x59f0
movb $0x1, -0x59(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x3e6c
jmp 0x3e60
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x70, %esi
callq 0x3260
jmp 0x3e7c
movq -0xa0(%rbp), %rdi
callq 0x5a60
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x15125(%rip), %rdi     # 0x18fc8
leaq 0xc22f(%rip), %rsi      # 0x100d9
callq 0x3240
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3240
movq %rax, %rdi
leaq 0xc221(%rip), %rsi      # 0x100e6
callq 0x3240
movq %rax, %rdi
movq 0x150e4(%rip), %rsi     # 0x18fb8
callq 0x3280
movq 0x150e8(%rip), %rdi     # 0x18fc8
leaq 0xc229(%rip), %rsi      # 0x10110
callq 0x3240
movq %rax, %rdi
movq 0x150c2(%rip), %rsi     # 0x18fb8
callq 0x3280
movq 0x150c6(%rip), %rdi     # 0x18fc8
leaq 0xc23d(%rip), %rsi      # 0x10146
callq 0x3240
movq %rax, %rdi
leaq 0xc26b(%rip), %rsi      # 0x10183
callq 0x3240
movq %rax, %rdi
movq 0x15091(%rip), %rsi     # 0x18fb8
callq 0x3280
movq %rax, %rdi
leaq 0xc261(%rip), %rsi      # 0x10197
callq 0x3240
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3240
movq %rax, %rdi
leaq 0xc24e(%rip), %rsi      # 0x1019f
callq 0x3240
movq %rax, %rdi
movq 0x15058(%rip), %rsi     # 0x18fb8
callq 0x3280
movq 0x1505c(%rip), %rdi     # 0x18fc8
leaq 0xc245(%rip), %rsi      # 0x101b8
callq 0x3240
movq %rax, %rdi
movq 0x15036(%rip), %rsi     # 0x18fb8
callq 0x3280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x30f0
testb $0x1, %al
jne 0x4b06
jmp 0x4b13
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4c36
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x30a0
movq -0x10(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x3300
movsbl -0x19(%rbp), %eax
cmpl $0x3c, %eax
jne 0x4c17
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x5320
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x31e0
movq %rax, %rdi
leaq -0x19(%rbp), %rsi
callq 0x3300
movsbl -0x19(%rbp), %eax
cmpl $0x2c, %eax
je 0x4b93
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x3360
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x2, -0x20(%rbp)
jl 0x4b49
cmpl $0x2, -0x20(%rbp)
jne 0x4baa
jmp 0x4bc9
leaq 0xb774(%rip), %rdi      # 0x10325
leaq 0xb77b(%rip), %rsi      # 0x10333
movl $0x1c4, %edx            # imm = 0x1C4
leaq 0xb77e(%rip), %rcx      # 0x10342
callq 0x3140
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x5320
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x31e0
movq %rax, %rdi
leaq -0x19(%rbp), %rsi
callq 0x3300
movsbl -0x19(%rbp), %eax
cmpl $0x3e, %eax
je 0x4c15
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x3360
jmp 0x4c2e
movq -0x10(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x33b0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4c36
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: hamikm[P]Raytracer/src/rgbcolor.hh
// Function: std::istream& operator>><double>(std::istream&, rgbcolor<double>&)
std::istream & operator>>(std::istream& is, rgbcolor<T> &col) {

	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 color, then...

		// Set red component.
		T tmpcol;
		is >> tmpcol >> c;
		if (c != ',') { // If wasn't a comma after color, bad format.
			is.clear(std::ios_base::failbit);
		}
		col.setR(tmpcol);

		// Set green component.
		is >> tmpcol >> c;
		if (c != ',') { // If wasn't a comma after color, bad format.
			is.clear(std::ios_base::failbit);
		}
		col.setG(tmpcol);

		// Set red component.
		is >> tmpcol >> c;
		if (c != ')') { // If wasn't a comma after color, bad format.
			is.clear(std::ios_base::failbit);
		}
		col.setB(tmpcol);
	}
	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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x30f0
testb $0x1, %al
jne 0x4c66
jmp 0x4c73
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4d92
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x30a0
movq -0x10(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x3300
movsbl -0x19(%rbp), %eax
cmpl $0x28, %eax
jne 0x4d73
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x31e0
movq %rax, %rdi
leaq -0x19(%rbp), %rsi
callq 0x3300
movsbl -0x19(%rbp), %eax
cmpl $0x2c, %eax
je 0x4cd9
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x3360
movq -0x18(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x7320
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x31e0
movq %rax, %rdi
leaq -0x19(%rbp), %rsi
callq 0x3300
movsbl -0x19(%rbp), %eax
cmpl $0x2c, %eax
je 0x4d1e
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x3360
movq -0x18(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x73a0
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x31e0
movq %rax, %rdi
leaq -0x19(%rbp), %rsi
callq 0x3300
movsbl -0x19(%rbp), %eax
cmpl $0x29, %eax
je 0x4d63
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x4, %esi
callq 0x3360
movq -0x18(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x7420
jmp 0x4d8a
movq -0x10(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x33b0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4d92
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x7570
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x540e
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x79c0
movq -0x30(%rbp), %rdi
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %esi
callq 0x5320
movsd -0x38(%rbp), %xmm1
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x53cf
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
callq 0x7570
movq -0x28(%rbp), %rdi
callq 0x9320
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x5495
movq -0x38(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x1c(%rbp), %esi
callq 0x5320
movsd -0x40(%rbp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x545d
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x7570
movq -0xc0(%rbp), %rdi
addq $0x18, %rdi
callq 0x4aa0
movq -0xc0(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x30(%rdi)
addq $0x38, %rdi
callq 0x4aa0
movq -0xc0(%rbp), %rdi
addq $0x50, %rdi
callq 0x4aa0
movq -0xc0(%rbp), %rdx
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x53a0
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5420
movq -0xc0(%rbp), %rsi
movq -0x40(%rbp), %rax
movq %rax, 0x18(%rsi)
movq -0x38(%rbp), %rax
movq %rax, 0x20(%rsi)
movq -0x30(%rbp), %rax
movq %rax, 0x28(%rsi)
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x9cf0
leaq -0x70(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5420
movq -0xc0(%rbp), %rdx
movq -0x70(%rbp), %rax
movq %rax, 0x50(%rdx)
movq -0x68(%rbp), %rax
movq %rax, 0x58(%rdx)
movq -0x60(%rbp), %rax
movq %rax, 0x60(%rdx)
movq %rdx, %rsi
addq $0x50, %rsi
addq $0x18, %rdx
leaq -0xb8(%rbp), %rdi
callq 0x9cf0
leaq -0xa0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x5420
movq -0xc0(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x98(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x90(%rbp), %rcx
movq %rcx, 0x48(%rax)
movsd 0x30(%rax), %xmm0
movsd 0xa660(%rip), %xmm1     # 0x10020
divsd %xmm1, %xmm0
callq 0x3110
movq -0xc0(%rbp), %rax
movaps %xmm0, %xmm1
movsd 0xa63d(%rip), %xmm0     # 0x10018
divsd %xmm1, %xmm0
movsd %xmm0, 0x68(%rax)
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xddc0
testb $0x1, %al
jne 0x62b6
jmp 0x62b8
jmp 0x62d7
leaq 0xab81(%rip), %rdi      # 0x10e40
leaq 0xaaf6(%rip), %rsi      # 0x10dbc
movl $0x9f, %edx
leaq 0xac77(%rip), %rcx      # 0x10f49
callq 0x3140
leaq -0x18(%rbp), %rdi
callq 0xa990
movq -0x60(%rbp), %rdi
callq 0xddf0
movq %rax, %rdi
callq 0xde40
movq %rax, %rdi
callq 0xa9b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x60(%rbp), %rdi
callq 0xddf0
movq %rax, %rdi
callq 0xde40
movq %rax, %rdi
callq 0xaa20
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa9e0
testb $0x1, %al
jne 0x6335
jmp 0x638e
leaq -0x18(%rbp), %rdi
callq 0xaa80
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x6090
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x6020
jmp 0x635d
leaq -0x38(%rbp), %rdi
callq 0x5300
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xaaf0
movq %rax, -0x50(%rbp)
jmp 0x6305
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5300
jmp 0x6394
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3380
nopl (%rax)
// File: hamikm[P]Raytracer/src/scene.hh
// Function: scene<double, double, double, 3>::renderPPM(camera<double, double, 3> const&, int, int, std::ostream&) const
void renderPPM(const camera<vec_T, time_T, dim> &cam,
			int width, int height,
			std::ostream &os) const {
		os << "P3 " << width << " " << height << " "
				<< COLORMAX << std::endl;
		for (int y = 0; y < height; y++) {
			for (int x = 0; x < width; x++) {
				ray<vec_T, time_T, dim> pixelRay = cam.getRayForPixel(
						x, y, width, height);
				rgbcolor<color_T> c = traceRay(pixelRay);
				c *= COLORMAX;
				c.clamp(0, COLORMAX);
				os << (int)c.getR() << " " << (int)c.getG() << " " <<
						(int)c.getB() << std::endl;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xac11(%rip), %rsi      # 0x11071
callq 0x3240
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x3370
movq %rax, %rdi
leaq 0x9d23(%rip), %rsi      # 0x1019d
callq 0x3240
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x3370
movq %rax, %rdi
leaq 0x9d09(%rip), %rsi      # 0x1019d
callq 0x3240
movq %rax, %rdi
movl $0xff, %esi
callq 0x3370
movq %rax, %rdi
movq 0x12b08(%rip), %rsi     # 0x18fb8
callq 0x3280
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x65d7
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x65c7
movq -0x10(%rbp), %rsi
movl -0x28(%rbp), %edx
movl -0x24(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
leaq -0x58(%rbp), %rdi
callq 0xdf60
movq -0x78(%rbp), %rsi
leaq -0x70(%rbp), %rdi
leaq -0x58(%rbp), %rdx
xorl %ecx, %ecx
callq 0xe130
leaq -0x70(%rbp), %rdi
movsd 0x9b13(%rip), %xmm0     # 0x10028
callq 0xe910
leaq -0x70(%rbp), %rdi
xorps %xmm0, %xmm0
movsd 0x9aff(%rip), %xmm1     # 0x10028
callq 0xe950
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xea60
movq -0x90(%rbp), %rdi
cvttsd2si %xmm0, %esi
callq 0x3370
movq %rax, %rdi
leaq 0x9c41(%rip), %rsi      # 0x1019d
callq 0x3240
movq %rax, -0x88(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xea80
movq -0x88(%rbp), %rdi
cvttsd2si %xmm0, %esi
callq 0x3370
movq %rax, %rdi
leaq 0x9c12(%rip), %rsi      # 0x1019d
callq 0x3240
movq %rax, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xeaa0
movq -0x80(%rbp), %rdi
cvttsd2si %xmm0, %esi
callq 0x3370
movq %rax, %rdi
movq 0x12a04(%rip), %rsi     # 0x18fb8
callq 0x3280
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x64cf
jmp 0x65c9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x64bc
addq $0x90, %rsp
popq %rbp
retq
// File: hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3>::mvector(mvector<double, 3> const&)
mvector (const mvector<T, size> &other) {
		assert (size > 0);
		assert (other.dim() == size);
		for (int i = 0; i < size; i++)
			v[i] = other[i];
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x79b0
cmpl $0x3, %eax
jne 0x7598
jmp 0x75b7
leaq 0x8fa9(%rip), %rdi      # 0x10548
leaq 0x8d8d(%rip), %rsi      # 0x10333
movl $0x79, %edx
leaq 0x8faa(%rip), %rcx      # 0x1055c
callq 0x3140
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x75e8
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x79c0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x75be
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8b8d(%rip), %rsi      # 0x10627
callq 0x3240
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x33c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
cmpl $0x3, %eax
je 0x7ad0
movq -0x10(%rbp), %rdi
leaq 0x8a5d(%rip), %rsi      # 0x10528
callq 0x3240
jmp 0x7ad2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x3, %eax
jl 0x7a9f
movq -0x10(%rbp), %rdi
leaq 0x8b3e(%rip), %rsi      # 0x10629
callq 0x3240
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3>::operator*(mvector<double, 3> const&) const
T operator*(const mvector<T, size> &rhs) const {
		T result = 0;
		for (int i = 0; i < size; i++)
			result += rhs[i] * v[i];
		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x7f03
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x79c0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7ec7
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x7570
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x79b0
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x8a06
movq -0x30(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x1c(%rbp), %esi
callq 0x5320
movsd -0x40(%rbp), %xmm0
mulsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x89c0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7e80
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x30, %rsi
callq 0x7ea0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x8d75
jp 0x8d75
movsd 0x72d2(%rip), %xmm0     # 0x10040
movsd %xmm0, -0x8(%rbp)
jmp 0x8ddb
movq -0x18(%rbp), %rdi
callq 0x7f10
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x30, %rsi
callq 0x7ea0
movq -0x30(%rbp), %rax
addsd 0x28(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x8dd1
movsd 0x7276(%rip), %xmm0     # 0x10040
movsd %xmm0, -0x8(%rbp)
jmp 0x8ddb
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hamikm[P]Raytracer/src/arealight.hh
// Function: arealight<double, double, double, 3>::printHelper(std::ostream&) const
void printHelper(std::ostream& os) const {
		light<vec_T, color_T, time_T, dim>::printHelper(os);
		os << " ---> [area light. height: " << height <<
				", horizontal spacing: " << horizontalSpacing <<
				", surface normal: " << norm <<
				", uhat: " << uhat <<
				", vhat: " << vhat <<
				", width: " << width <<
				", lights:" << std::endl;
		os << "    {" << std::endl;
		typename std::vector<boost::shared_ptr<
			light<vec_T, color_T, time_T, dim> > >::const_iterator iter;
		for(iter = lights.begin(); iter < lights.end(); iter++) {
			os << "    " << **iter << std::endl;
		}
		os << "    }" << std::endl << "]";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x90a0
movq -0x10(%rbp), %rdi
leaq 0x71d6(%rip), %rsi      # 0x10c52
callq 0x3240
movq %rax, %rdi
movq -0x38(%rbp), %rax
movsd 0x68(%rax), %xmm0
callq 0x33c0
movq %rax, %rdi
leaq 0x71d2(%rip), %rsi      # 0x10c6e
callq 0x3240
movq %rax, %rdi
movq -0x38(%rbp), %rax
movsd 0x50(%rax), %xmm0
callq 0x33c0
movq %rax, %rdi
leaq 0x6d7a(%rip), %rsi      # 0x10836
callq 0x3240
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x38, %rsi
callq 0x7a40
movq %rax, %rdi
leaq 0x71aa(%rip), %rsi      # 0x10c85
callq 0x3240
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x88, %rsi
callq 0x7a40
movq %rax, %rdi
leaq 0x7191(%rip), %rsi      # 0x10c8e
callq 0x3240
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x70, %rsi
callq 0x7a40
movq %rax, %rdi
leaq 0x717b(%rip), %rsi      # 0x10c97
callq 0x3240
movq %rax, %rdi
movq -0x38(%rbp), %rax
movsd 0x60(%rax), %xmm0
callq 0x33c0
movq %rax, %rdi
leaq 0x7165(%rip), %rsi      # 0x10ca1
callq 0x3240
movq %rax, %rdi
movq 0xf46d(%rip), %rsi      # 0x18fb8
callq 0x3280
movq -0x10(%rbp), %rdi
leaq 0x7150(%rip), %rsi      # 0x10cab
callq 0x3240
movq %rax, %rdi
movq 0xf44e(%rip), %rsi      # 0x18fb8
callq 0x3280
leaq -0x18(%rbp), %rdi
callq 0xa990
movq -0x38(%rbp), %rdi
addq $0xa0, %rdi
callq 0xa9b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0xa0, %rdi
callq 0xaa20
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa9e0
testb $0x1, %al
jne 0x9bbb
jmp 0x9c0c
movq -0x10(%rbp), %rdi
leaq 0x65d4(%rip), %rsi      # 0x1019a
callq 0x3240
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xaa80
movq %rax, %rdi
callq 0xaaa0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xaa50
movq %rax, %rdi
movq 0xf3c2(%rip), %rsi      # 0x18fb8
callq 0x3280
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xaaf0
movq %rax, -0x30(%rbp)
jmp 0x9b94
movq -0x10(%rbp), %rdi
leaq 0x709a(%rip), %rsi      # 0x10cb1
callq 0x3240
movq %rax, %rdi
movq 0xf392(%rip), %rsi      # 0x18fb8
callq 0x3280
movq %rax, %rdi
leaq 0x675f(%rip), %rsi      # 0x10394
callq 0x3240
addq $0x40, %rsp
popq %rbp
retq
// File: 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 {
		assert(size == 3);
		assert(rhs.dim() == 3);
		mvector tmp;
		tmp[0] = v[1] * rhs[2] - v[2] * rhs[1];
		tmp[1] = -v[0] * rhs[2] + v[2] * rhs[0];
		tmp[2] = v[0] * rhs[1] - v[1] * rhs[0];
		return tmp;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x79b0
cmpl $0x3, %eax
jne 0x9d2a
jmp 0x9d49
leaq 0x6e02(%rip), %rdi      # 0x10b33
leaq 0x65fb(%rip), %rsi      # 0x10333
movl $0x107, %edx            # imm = 0x107
leaq 0x6dfe(%rip), %rcx      # 0x10b42
callq 0x3140
movq -0x30(%rbp), %rdi
callq 0x4aa0
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x79c0
movq -0x20(%rbp), %rax
movsd %xmm0, -0x88(%rbp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x90(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x79c0
movsd -0x90(%rbp), %xmm1
movsd -0x88(%rbp), %xmm2
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm3
movsd -0x80(%rbp), %xmm0
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x78(%rbp)
xorl %esi, %esi
callq 0x5320
movsd -0x78(%rbp), %xmm0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movsd %xmm0, (%rcx)
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x79c0
movq -0x20(%rbp), %rax
movsd %xmm0, -0x68(%rbp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x79c0
movsd -0x70(%rbp), %xmm1
movsd -0x68(%rbp), %xmm2
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm3
movsd -0x60(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movl $0x1, %esi
callq 0x5320
movsd -0x58(%rbp), %xmm0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movsd %xmm0, (%rcx)
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x79c0
movq -0x20(%rbp), %rax
movsd %xmm0, -0x48(%rbp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x79c0
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm3
movsd -0x40(%rbp), %xmm0
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x2, %esi
callq 0x5320
movsd -0x38(%rbp), %xmm0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movsd %xmm0, (%rcx)
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: hamikm[P]Raytracer/src/rgbcolor.hh
// Function: rgbcolor<double>::operator/=(double)
rgbcolor & operator/=(T scalar) {
		assert(scalar != 0);
		r /= scalar;
		g /= scalar;
		b /= scalar;
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa08b
jp 0xa08b
jmp 0xa08d
jmp 0xa0ac
leaq 0x6b1a(%rip), %rdi      # 0x10bae
leaq 0x61d4(%rip), %rsi      # 0x1026f
movl $0xce, %edx
leaq 0x6b57(%rip), %rcx      # 0x10bfe
callq 0x3140
movq -0x18(%rbp), %rax
movsd -0x10(%rbp), %xmm1
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm1
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rbp), %xmm1
movsd 0x10(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)