LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x88(%rdi), %rcx
movq 0x80(%rdi), %rax
movq %rcx, %r9
subq %rax, %r9
movb 0x1c8(%rdi), %dl
movq 0x20(%rdi), %rsi
movq 0x38(%rdi), %rdi
movq (%r14), %r8
shrq $0x2, %r9
movslq %r9d, %r9
xorl %r10d, %r10d
cmpq %r9, %r10
jge 0x31d8
testb $0x1, %dl
jne 0x31d3
movslq (%rax,%r10,4), %r11
movslq (%rsi,%r11,4), %r15
movslq (%rdi,%r15,4), %r15
subq %r15, (%r8,%r11,8)
incq %r10
jmp 0x31b9
xorl %r12d, %r12d
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jge 0x3215
movslq (%rax,%r12,4), %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2eba
cltq
movq (%r14), %rcx
addq %rax, (%rcx,%r15,8)
incq %r12
movq 0x80(%rbx), %rax
movq 0x88(%rbx), %rcx
jmp 0x31db
movb $0x0, 0x1c8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq %esi, %r13
movq 0x118(%rdi), %rax
movslq (%rax,%r13,4), %r15
leaq 0xc0(%rdi), %rcx
movq %rcx, (%rsp)
pushq $-0x1
popq %rbx
xorl %ebp, %ebp
movslq 0x4(%rax,%r13,4), %rax
cmpq %rax, %r15
jge 0x40f3
movq 0xe8(%r14), %rax
movslq (%rax,%r15,4), %r12
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x4052
xorl %ecx, %ecx
testq %rdx, (%rax)
cmovel %r12d, %ebx
sete %cl
addl %ecx, %ebp
incq %r15
movq 0x118(%r14), %rax
jmp 0x40b8
testl %ebp, %ebp
je 0x4100
cmpl $0x1, %ebp
je 0x4103
pushq $-0x2
jmp 0x4102
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl (%rdi), %ecx
movl %ecx, %eax
shll $0xb, %eax
xorl %ecx, %eax
movq 0x4(%rdi), %rcx
movq %rcx, (%rdi)
movl 0xc(%rdi), %ecx
movl %ecx, 0x8(%rdi)
movl %ecx, %edx
shrl $0x13, %edx
xorl %eax, %edx
shrl $0x8, %eax
xorl %edx, %eax
xorl %ecx, %eax
movl %eax, 0xc(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
cmpl $0x3, %edi
jle 0x36c9
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %r14
movq 0x18(%rsi), %rbx
leaq 0xb8(%rsp), %rdi
callq 0x3234
leaq 0x60(%rsp), %rdi
callq 0x3234
leaq 0x8(%rsp), %rdi
callq 0x3234
leaq 0xb8(%rsp), %rdi
movq %r15, %rsi
callq 0x2802
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x2802
movq 0x298e(%rip), %rdi      # 0x5fd0
leaq 0xcd9(%rip), %rsi       # 0x4322
callq 0x2100
movq %rax, %rdi
callq 0x20a0
leaq 0xb8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x2e93
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x264e
testl %eax, %eax
jne 0x3699
movq 0x294b(%rip), %rdi      # 0x5fd0
leaq 0xc9f(%rip), %rsi       # 0x432b
callq 0x2100
movq %rax, %rdi
callq 0x20a0
leaq 0x8(%rsp), %rdi
callq 0x3276
leaq 0x60(%rsp), %rdi
callq 0x3276
leaq 0xb8(%rsp), %rdi
callq 0x3276
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
movq (%rsi), %rsi
movq 0x28fd(%rip), %rdi      # 0x5fd0
callq 0x2100
leaq 0xc26(%rip), %rsi       # 0x4305
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x20a0
xorl %edi, %edi
callq 0x2140
movq %rax, %rbx
jmp 0x370d
movq %rax, %rbx
jmp 0x3717
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3276
leaq 0x60(%rsp), %rdi
callq 0x3276
leaq 0xb8(%rsp), %rdi
callq 0x3276
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/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
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x416e
movq 0xbb15(%rip), %rdi      # 0xefd8
movq %r14, %rsi
callq 0x4274
leaq -0x38(%rbp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x3110
movq %rax, %rdi
movq %r15, %rsi
callq 0x4186
leaq -0x2c(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3300
pushq $0x48
popq %rdi
callq 0x31e0
movq %rax, %r12
movsd (%r13), %xmm0
movss (%r15), %xmm1
movq %rax, %rdi
movq %r14, %rsi
leaq -0x50(%rbp), %rdx
callq 0x439c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4424
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x48
popq %rsi
movq %r12, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq -0x70(%rbp), %r15
movq %r15, %rdi
callq 0x416e
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x416e
movq 0xba46(%rip), %rdi      # 0xefd8
movq %r14, %rsi
callq 0x4274
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
movq %r15, %rsi
callq 0x4186
movq %rax, %rdi
movq %r12, %rsi
callq 0x4186
leaq -0x40(%rbp), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x3110
leaq -0x34(%rbp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x3300
pushq $0x68
popq %rdi
callq 0x31e0
movq %rax, %r15
leaq -0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd (%r12), %xmm1
movss (%r13), %xmm2
movq %r15, %rdi
movq %r14, %rsi
leaq -0x70(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x4458
movq %rbx, %rdi
movq %r15, %rsi
callq 0x451e
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r15, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x416e
movq 0xb8a4(%rip), %rdi      # 0xefd8
movq %r14, %rsi
callq 0x4274
movq %rax, %rdi
movq %r12, %rsi
callq 0x4186
pushq $0x38
popq %rdi
callq 0x31e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x460e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4640
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x416e
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x416e
movq 0xb801(%rip), %rdi      # 0xefd8
movq %r12, %rsi
callq 0x4274
movq %rax, %rdi
movq %r14, %rsi
callq 0x4186
movq %rax, %rdi
movq %r15, %rsi
callq 0x4186
leaq -0x24(%rbp), %rsi
movq %rax, %rdi
callq 0x3300
movsd (%r14), %xmm0
ucomisd (%r15), %xmm0
jne 0x3828
jp 0x3828
movsd -0x38(%rbp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x3828
movsd -0x48(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jne 0x3828
jnp 0x3894
pushq $0x58
popq %rdi
callq 0x31e0
movq %rax, %r14
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x46c8
leaq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x4722
movss -0x24(%rbp), %xmm0
leaq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
movq %r14, %rdi
callq 0x4778
movq %rbx, %rdi
movq %r14, %rsi
callq 0x47f4
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x57f9(%rip), %rdi      # 0x9094
leaq 0x583a(%rip), %rsi      # 0x90dc
leaq 0x5841(%rip), %rcx      # 0x90ea
movl $0x8b, %edx
callq 0x3100
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r14, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x98, %rsp
movq %rdi, -0x30(%rbp)
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rbx
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq -0xb8(%rbp), %r14
movq %r14, %rdi
callq 0x416e
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
callq 0x416e
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x416e
movq 0xb6b4(%rip), %rdi      # 0xefd8
movq %rbx, %rsi
callq 0x4274
movq %rax, %rdi
movq %r14, %rsi
callq 0x4186
movq %rax, %rdi
movq %r15, %rsi
callq 0x4186
movq %rax, %rdi
movq %r12, %rsi
callq 0x4186
leaq -0x50(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3110
leaq -0x48(%rbp), %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x3110
leaq -0x40(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3110
leaq -0x38(%rbp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3110
movl $0xb8, %edi
callq 0x31e0
movq %rax, %r12
movsd (%r15), %xmm0
movsd (%r13), %xmm1
movsd (%r14), %xmm2
movsd (%rbx), %xmm3
movq %rax, %rdi
leaq -0x70(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
leaq -0x88(%rbp), %r8
callq 0x4828
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x49a0
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xb8, %esi
movq %r12, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rdi, %rbx
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x416e
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x416e
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x416e
movq 0xb592(%rip), %rdi      # 0xefd8
movq %r14, %rsi
callq 0x4186
movq %rax, %rdi
movq %r15, %rsi
callq 0x4186
movq %rax, %rdi
movq %r12, %rsi
callq 0x4186
pushq $0x70
popq %rdi
callq 0x31e0
movq %rax, %r13
movsd 0x5599(%rip), %xmm0     # 0x9010
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x49d4
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4ae0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x70
popq %rsi
movq %r13, %rdi
callq 0x31f0
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %r14
movq 0xb4fc(%rip), %rbx      # 0xefc8
leaq 0x563e(%rip), %rsi      # 0x9111
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
leaq 0x5631(%rip), %rsi      # 0x911e
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30d0
leaq 0x5644(%rip), %rsi      # 0x9148
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30d0
leaq 0x5663(%rip), %rsi      # 0x917e
movq %rbx, %rdi
callq 0x31d0
leaq 0x5691(%rip), %rsi      # 0x91bb
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30d0
leaq 0x568e(%rip), %rsi      # 0x91cf
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
leaq 0x567c(%rip), %rsi      # 0x91d7
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30d0
leaq 0x567e(%rip), %rsi      # 0x91f0
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rdi
testb $0x5, 0x20(%rbx,%rdi)
jne 0x4262
movq %rsi, %r14
addq %rbx, %rdi
pushq $0x4
popq %rsi
callq 0x3080
leaq -0x29(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3230
movb (%r15), %al
cmpb $0x3c, %al
jne 0x4257
xorl %esi, %esi
movb $0x1, %r13b
pushq $0x1
popq %r12
movq %r14, %rdi
callq 0x4674
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3110
movq %rax, %rdi
movq %r15, %rsi
callq 0x3230
cmpb $0x2c, -0x29(%rbp)
je 0x4210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
pushq $0x4
popq %rsi
callq 0x32b0
movl %r12d, %esi
testb $0x1, %r13b
movl $0x0, %r13d
jne 0x41da
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3110
leaq -0x29(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3230
cmpb $0x3e, (%r14)
je 0x4262
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
pushq $0x4
popq %rsi
callq 0x32b0
jmp 0x4262
movsbl %al, %esi
movq %rbx, %rdi
callq 0x32f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rdi
testb $0x5, 0x20(%rbx,%rdi)
jne 0x438d
movq %rsi, %r14
addq %rbx, %rdi
pushq $0x4
popq %rsi
callq 0x3080
leaq -0x19(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3230
movb (%r15), %al
cmpb $0x28, %al
jne 0x4382
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x3110
movq %rax, %rdi
movq %r15, %rsi
callq 0x3230
cmpb $0x2c, (%r15)
je 0x42ed
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
pushq $0x4
popq %rsi
callq 0x32b0
leaq -0x28(%rbp), %r15
movsd (%r15), %xmm0
movq %r14, %rdi
callq 0x531a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3110
leaq -0x19(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3230
cmpb $0x2c, (%r15)
je 0x4330
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
pushq $0x4
popq %rsi
callq 0x32b0
leaq -0x28(%rbp), %r15
movsd (%r15), %xmm0
movq %r14, %rdi
callq 0x5358
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3110
leaq -0x19(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x3230
cmpb $0x29, (%r15)
je 0x4373
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
pushq $0x4
popq %rsi
callq 0x32b0
movsd -0x28(%rbp), %xmm0
movq %r14, %rdi
callq 0x5398
jmp 0x438d
movsbl %al, %esi
movq %rbx, %rdi
callq 0x32f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x5430
xorl %r15d, %r15d
cmpl $0x3, %r15d
je 0x4713
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5652
movsd %xmm0, -0x20(%rbp)
movq %r14, %rdi
movl %r15d, %esi
callq 0x4674
movsd (%rax), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
incl %r15d
jmp 0x46e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5430
movq %r14, %rdi
callq 0x6332
movsd %xmm0, -0x18(%rbp)
xorl %r14d, %r14d
cmpl $0x3, %r14d
je 0x476b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4674
movsd (%rax), %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
incl %r14d
jmp 0x4748
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movsd %xmm3, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
movq %r8, %rbx
movq %rcx, %r15
movq %rdi, %r14
callq 0x460e
leaq 0xa452(%rip), %rax      # 0xecb0
movq %rax, (%r14)
leaq 0x38(%r14), %rdi
movq %r15, %rsi
callq 0x4722
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x50(%r14)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x58(%r14)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x60(%r14)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x68(%r14)
leaq 0x70(%r14), %rdi
callq 0x416e
leaq 0x88(%r14), %rdi
callq 0x416e
movsd -0x38(%rbp), %xmm2
xorpd %xmm0, %xmm0
andq $0x0, 0xb0(%r14)
movupd %xmm0, 0xa0(%r14)
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jbe 0x4910
movsd -0x30(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x492f
movsd -0x28(%rbp), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x494e
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x496d
leaq 0xa0(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x64b6
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5028(%rip), %rdi      # 0x993f
leaq 0x5037(%rip), %rsi      # 0x9955
leaq 0x5041(%rip), %rcx      # 0x9966
movl $0xb5, %edx
callq 0x3100
leaq 0x512b(%rip), %rdi      # 0x9a61
leaq 0x5018(%rip), %rsi      # 0x9955
leaq 0x5022(%rip), %rcx      # 0x9966
movl $0xb6, %edx
callq 0x3100
leaq 0x5120(%rip), %rdi      # 0x9a75
leaq 0x4ff9(%rip), %rsi      # 0x9955
leaq 0x5003(%rip), %rcx      # 0x9966
movl $0xb7, %edx
callq 0x3100
leaq 0x511b(%rip), %rdi      # 0x9a8f
leaq 0x4fda(%rip), %rsi      # 0x9955
leaq 0x4fe4(%rip), %rcx      # 0x9966
movl $0xb8, %edx
callq 0x3100
movq %rax, %rbx
movq %r15, %rdi
callq 0x51c2
movq %rbx, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x38(%rbp)
movq %rdx, %r13
movq %rdi, %rbx
callq 0x5430
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x416e
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x30(%rbx)
leaq 0x38(%rbx), %rdi
callq 0x416e
leaq 0x50(%rbx), %r12
movq %r12, %rdi
callq 0x416e
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x46c8
leaq -0x68(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x4722
movq 0x10(%r13), %rax
movq %rax, 0x28(%rbx)
movups (%r13), %xmm0
movups %xmm0, 0x18(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq -0x38(%rbp), %rdx
callq 0x68ba
movq %r13, %rdi
movq %r15, %rsi
callq 0x4722
movq 0x10(%r13), %rax
movq %rax, 0x60(%rbx)
movups (%r13), %xmm0
movups %xmm0, 0x50(%rbx)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x68ba
leaq -0x68(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x4722
movq 0x10(%r14), %rax
movq %rax, 0x48(%rbx)
movups (%r14), %xmm0
movups %xmm0, 0x38(%rbx)
movsd 0x30(%rbx), %xmm0
mulsd 0x455d(%rip), %xmm0     # 0x9018
callq 0x30f0
movsd 0x4550(%rip), %xmm1     # 0x9018
divsd %xmm0, %xmm1
movsd %xmm1, 0x68(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x0, (%rsi)
je 0x4e3c
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x785e
movq 0xa0(%rax), %r13
leaq -0x30(%rbp), %r15
leaq -0x38(%rbp), %r12
movq %rbx, %rdi
callq 0x785e
cmpq 0xa8(%rax), %r13
jae 0x4e2d
movq (%r13), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%r13), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x4e14
lock
incl 0x8(%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x4ce2
movq %r15, %rdi
callq 0x5092
addq $0x10, %r13
jmp 0x4dea
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4ef7(%rip), %rdi      # 0x9d3a
leaq 0x4e6c(%rip), %rsi      # 0x9cb6
leaq 0x4ff2(%rip), %rcx      # 0x9e43
movl $0x9f, %edx
callq 0x3100
movq %rax, %rbx
movq %r15, %rdi
callq 0x5092
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %r12d
movl %edx, %ebx
movq %rsi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
leaq 0x509e(%rip), %rsi      # 0x9f6b
movq %r8, -0x68(%rbp)
movq %r8, %rdi
callq 0x31d0
movq %rax, %rdi
movl %ebx, %esi
callq 0x32c0
leaq 0x42eb(%rip), %r14      # 0x91d5
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
movq %rax, %rdi
movl %r12d, %esi
callq 0x32c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x31d0
movq %rax, %rdi
movl $0xff, %esi
callq 0x32c0
movq %rax, %rdi
callq 0x30d0
xorl %r14d, %r14d
testl %ebx, %ebx
movl $0x0, %r15d
movl %ebx, -0x34(%rbp)
cmovgl %ebx, %r15d
testl %r12d, %r12d
movl $0x0, %eax
movl %r12d, -0x30(%rbp)
cmovgl %r12d, %eax
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %r12
cmpl -0x2c(%rbp), %r14d
je 0x502c
xorl %r13d, %r13d
cmpl %r13d, %r15d
je 0x5024
leaq -0x98(%rbp), %rbx
movq %rbx, %rdi
movq -0x60(%rbp), %rsi
movl %r13d, %edx
movl %r14d, %ecx
movl -0x34(%rbp), %r8d
movl -0x30(%rbp), %r9d
callq 0x788a
movq %r12, %rdi
movq -0x58(%rbp), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x7a10
movsd -0x50(%rbp), %xmm0
movsd 0x4082(%rip), %xmm1     # 0x9020
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
xorpd %xmm0, %xmm0
movq %r12, %rdi
callq 0x7f98
cvttsd2si -0x50(%rbp), %esi
movq -0x68(%rbp), %rdi
callq 0x32c0
movq %rax, %rdi
leaq 0x41ee(%rip), %rbx      # 0x91d5
movq %rbx, %rsi
callq 0x31d0
cvttsd2si -0x48(%rbp), %esi
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x31d0
cvttsd2si -0x40(%rbp), %esi
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x30d0
incl %r13d
jmp 0x4f56
incl %r14d
jmp 0x4f49
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x545f
movq %rbx, %rdi
movl %r15d, %esi
callq 0x5652
movsd %xmm0, (%r14,%r15,8)
incq %r15
jmp 0x5443
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3ede(%rip), %rsi      # 0x959c
xorl %r15d, %r15d
leaq 0x3e36(%rip), %r12      # 0x94fe
movq %rbx, %rdi
callq 0x31d0
movsd (%r14,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x3290
incq %r15
movq %r12, %rsi
cmpq $0x3, %r15
jne 0x56c8
leaq 0x3ead(%rip), %rsi      # 0x959e
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x590f
movq %rbx, %rdi
movl %r15d, %esi
movsd %xmm0, -0x20(%rbp)
callq 0x5652
mulsd (%r14,%r15,8), %xmm0
movsd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
incq %r15
jmp 0x58db
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
callq 0x5430
xorl %r14d, %r14d
cmpl $0x3, %r14d
je 0x5ee7
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4674
movsd (%rax), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
incl %r14d
jmp 0x5ec4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdi
leaq 0x30(%rbx), %r15
movq %r15, %rsi
callq 0x58c4
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6096
jp 0x6096
movsd 0x2fac(%rip), %xmm0     # 0x9040
jmp 0x60dd
movq %r14, %rdi
movq %r15, %rsi
movsd %xmm0, -0x20(%rbp)
callq 0x58c4
movapd %xmm0, %xmm1
addsd 0x28(%rbx), %xmm1
xorpd 0x2fc9(%rip), %xmm1     # 0x9080
divsd -0x20(%rbp), %xmm1
movapd %xmm1, %xmm2
cmpltsd 0x2f7f(%rip), %xmm2     # 0x9048
movsd 0x2f6f(%rip), %xmm0     # 0x9040
andpd %xmm2, %xmm0
andnpd %xmm1, %xmm2
orpd %xmm2, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6202
leaq 0x33e8(%rip), %rsi      # 0x9b4c
movq %rbx, %rdi
callq 0x31d0
movsd 0x68(%r14), %xmm0
movq %rax, %rdi
callq 0x3290
leaq 0x33e7(%rip), %rsi      # 0x9b68
movq %rax, %rdi
callq 0x31d0
movsd 0x50(%r14), %xmm0
movq %rax, %rdi
callq 0x3290
leaq 0x300d(%rip), %rsi      # 0x97ab
movq %rax, %rdi
callq 0x31d0
movq %rax, %r15
leaq 0x38(%r14), %rdi
movq %rax, %rsi
callq 0x56a6
leaq 0x33c3(%rip), %rsi      # 0x9b7f
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
leaq 0x88(%r14), %rdi
movq %rax, %rsi
callq 0x56a6
leaq 0x33ab(%rip), %rsi      # 0x9b88
movq %r15, %rdi
callq 0x31d0
movq %rax, %r15
leaq 0x70(%r14), %rdi
movq %rax, %rsi
callq 0x56a6
leaq 0x3396(%rip), %rsi      # 0x9b91
movq %r15, %rdi
callq 0x31d0
movsd 0x60(%r14), %xmm0
movq %rax, %rdi
callq 0x3290
leaq 0x3383(%rip), %rsi      # 0x9b9b
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30d0
leaq 0x3376(%rip), %rsi      # 0x9ba5
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30d0
movq 0xa0(%r14), %r15
leaq 0x2985(%rip), %r12      # 0x91d2
cmpq 0xa8(%r14), %r15
jae 0x6886
movq %rbx, %rdi
movq %r12, %rsi
callq 0x31d0
movq %rax, %r13
movq %r15, %rdi
callq 0x6bfe
movq (%rax), %rcx
movq %rax, %rdi
movq %r13, %rsi
callq *0x18(%rcx)
movq %r13, %rdi
callq 0x30d0
addq $0x10, %r15
jmp 0x684d
leaq 0x331e(%rip), %rsi      # 0x9bab
movq %rbx, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30d0
leaq 0x2f6f(%rip), %rsi      # 0x9813
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x416e
movsd 0x8(%r14), %xmm0
movsd 0x10(%r14), %xmm1
movsd 0x8(%r15), %xmm2
movsd 0x10(%r15), %xmm3
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm2, %xmm5
mulsd %xmm1, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, (%rbx)
movsd (%r15), %xmm4
movsd (%r14), %xmm5
mulsd %xmm5, %xmm3
mulsd %xmm4, %xmm1
subsd %xmm1, %xmm3
movsd %xmm3, 0x8(%rbx)
mulsd %xmm2, %xmm5
mulsd %xmm0, %xmm4
subsd %xmm5, %xmm4
movsd %xmm4, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x69ea
jnp 0x6a16
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm2
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
divsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rdi)
movsd 0x10(%rdi), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdi)
movq %rdi, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x3087(%rip), %rdi      # 0x9aa8
leaq 0x287f(%rip), %rsi      # 0x92a7
leaq 0x30c9(%rip), %rcx      # 0x9af8
movl $0xce, %edx
callq 0x3100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x98, %rsp
testl %edx, %edx
js 0x79a8
movl %ecx, %r13d
testl %ecx, %ecx
js 0x79c1
testl %r8d, %r8d
jle 0x79da
movl %r9d, %r12d
movq %rdi, -0x40(%rbp)
testl %r9d, %r9d
jle 0x79f3
movl %edx, %r15d
movq %rsi, %r14
cvtsi2sd %r8d, %xmm1
cvtsi2sd %r12d, %xmm0
divsd %xmm0, %xmm1
mulsd 0x1732(%rip), %xmm1     # 0x9018
movsd %xmm1, -0x38(%rbp)
movsd 0x68(%rsi), %xmm0
addq $0x18, %rsi
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
callq 0x801c
cvtsi2sd %r13d, %xmm2
decl %r12d
cvtsi2sd %r12d, %xmm0
movsd %xmm0, -0x30(%rbp)
divsd %xmm0, %xmm2
movsd 0x16f7(%rip), %xmm0     # 0x9018
subsd %xmm2, %xmm0
leaq 0x38(%r14), %rsi
leaq -0x70(%rbp), %r12
movq %r12, %rdi
callq 0x801c
leaq -0xa0(%rbp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x5e50
cvtsi2sd %r15d, %xmm0
divsd -0x30(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
leaq 0x50(%r14), %rsi
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
callq 0x801c
leaq -0xb8(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x5e50
pushq $0x1
popq %rcx
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5dd8
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b73(%rip), %rdi      # 0x9522
leaq 0x25b9(%rip), %rsi      # 0x9f6f
leaq 0x25c0(%rip), %rcx      # 0x9f7d
pushq $0x6a
jmp 0x7a0a
leaq 0x263c(%rip), %rdi      # 0xa004
leaq 0x25a0(%rip), %rsi      # 0x9f6f
leaq 0x25a7(%rip), %rcx      # 0x9f7d
pushq $0x6b
jmp 0x7a0a
leaq 0x262a(%rip), %rdi      # 0xa00b
leaq 0x2587(%rip), %rsi      # 0x9f6f
leaq 0x258e(%rip), %rcx      # 0x9f7d
pushq $0x6c
jmp 0x7a0a
leaq 0x1ba6(%rip), %rdi      # 0x95a0
leaq 0x256e(%rip), %rsi      # 0x9f6f
leaq 0x2575(%rip), %rcx      # 0x9f7d
pushq $0x6d
popq %rdx
callq 0x3100
// File: /workspace/github_cpp_makefile_star2_O2/hamikm[P]Raytracer/src/rgbcolor.hh
// Function: rgbcolor<double>::clamp(double, double)
void clamp(T minv, T maxv) {
		assert(maxv > minv);
		if(r < minv) {
			r = minv;
		}
		if(g < minv) {
			g = minv;
		}
		if(b < minv) {
			b = minv;
		}
		if(r > maxv) {
			r = maxv;
		}
		if(g > maxv) {
			g = maxv;
		}
		if(b > maxv) {
			b = maxv;
		}
	}

// Assembly:
ucomisd %xmm0, %xmm1
jbe 0x7ff9
movsd (%rdi), %xmm2
ucomisd %xmm2, %xmm0
jbe 0x7fb0
movsd %xmm0, (%rdi)
movapd %xmm0, %xmm2
movsd 0x8(%rdi), %xmm3
ucomisd %xmm3, %xmm0
jbe 0x7fc4
movsd %xmm0, 0x8(%rdi)
movapd %xmm0, %xmm3
movsd 0x10(%rdi), %xmm4
ucomisd %xmm4, %xmm0
jbe 0x7fd8
movsd %xmm0, 0x10(%rdi)
movapd %xmm0, %xmm4
ucomisd %xmm1, %xmm2
jbe 0x7fe2
movsd %xmm1, (%rdi)
ucomisd %xmm1, %xmm3
jbe 0x7fed
movsd %xmm1, 0x8(%rdi)
ucomisd %xmm1, %xmm4
jbe 0x7ff8
movsd %xmm1, 0x10(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x227f(%rip), %rdi      # 0xa283
leaq 0x129c(%rip), %rsi      # 0x92a7
leaq 0x227d(%rip), %rcx      # 0xa28f
movl $0xf9, %edx
callq 0x3100
// File: /workspace/github_cpp_makefile_star2_O2/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3> const operator*<double, 3>(double, mvector<double, 3> const&)
const mvector<T, size> operator*(T scalar, const mvector<T, size> &rhs) {
	mvector<T, size> tmp = rhs;
	for (int i = 0; i < rhs.dim(); i++)
		tmp[i] *= scalar;
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
movq %rdi, %rbx
callq 0x5430
xorl %r14d, %r14d
cmpl $0x3, %r14d
je 0x805a
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4674
movsd (%rax), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
incl %r14d
jmp 0x8037
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hamikm[P]Raytracer/src/scene.hh
// Function: scene<double, double, double, 3>::findClosestShape(ray<double, double, 3> const&, double&) const
sp_shape findClosestShape(
			const ray<vec_T, time_T, dim> &r, time_T &tIntersect) const {
		time_T t = RAY_MISS;
		tIntersect = RAY_MISS;
		sp_shape intersectedObjPtr, tmpPtr;
		typename std::vector<sp_shape>::const_iterator iter;
		for (iter = shapes.begin(); iter < shapes.end(); iter++) {
			tmpPtr = *iter;
			t = tmpPtr->intersection(r);
			if (t != RAY_MISS && t > 0) {
				if (tIntersect == RAY_MISS) { // tIntersect starts at RAY_MISS
					tIntersect = t;
					intersectedObjPtr = tmpPtr;
				}
				else if (t < tIntersect) {
					intersectedObjPtr = tmpPtr;
					tIntersect = t;
				}
			}
		}
		return intersectedObjPtr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, (%rcx)
xorpd %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movupd %xmm0, (%rdi)
leaq -0x50(%rbp), %r13
movapd %xmm0, (%r13)
movq 0x30(%rsi), %rbx
cmpq 0x38(%r12), %rbx
jae 0x8135
movq %r13, %rdi
movq %rbx, %rsi
callq 0x8388
movq %r13, %rdi
callq 0x81d8
movq (%rax), %rcx
movq %rax, %rdi
movq %r15, %rsi
callq *0x20(%rcx)
ucomisd 0xf67(%rip), %xmm0      # 0x9040
jne 0x80dd
jnp 0x812c
ucomisd 0xf63(%rip), %xmm0      # 0x9048
jbe 0x812c
movsd (%r14), %xmm1
ucomisd 0xf4c(%rip), %xmm1      # 0x9040
jne 0x810b
jp 0x810b
movsd %xmm0, (%r14)
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x8388
jmp 0x812c
ucomisd %xmm0, %xmm1
jbe 0x812c
movq -0x30(%rbp), %rdi
movq %r13, %rsi
movsd %xmm0, -0x38(%rbp)
callq 0x8388
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%r14)
addq $0x10, %rbx
jmp 0x80a7
leaq -0x48(%rbp), %rdi
callq 0x5092
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x5092
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x5092
movq %rbx, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/hamikm[P]Raytracer/src/rgbcolor.hh
// Function: rgbcolor<double>::operator+=(rgbcolor<double> const&)
rgbcolor & operator+=(const rgbcolor &rhs) {
		r += rhs.getR();
		g += rhs.getG();
		b += rhs.getB();
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movsd (%rsi), %xmm0
addsd (%rdi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
addsd 0x8(%rdi), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
addsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hamikm[P]Raytracer/src/mvector.hh
// Function: mvector<double, 3>::operator-() const
const mvector<T, size> operator-() const {
		mvector tmp = *this;
		for (int i = 0; i < size; i++)
			tmp[i] *= -1;
		return tmp;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5430
xorl %r14d, %r14d
cmpl $0x3, %r14d
je 0x82c6
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4674
movsd (%rax), %xmm0
xorps 0xdc2(%rip), %xmm0      # 0x9080
movlps %xmm0, (%rax)
incl %r14d
jmp 0x82a2
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lagoproject[P]arti/analysis/cherenkov.cc
// Function: Usage(char*, int)
void Usage(char *prog, int verbose=0) {
  cout << endl << "analysis.cc, from ARTI     version " << VERSION << endl<< endl;
  cout << "  Read ascii files containing Corsika Cherenkov outputs (CER) and produce a histogram" << endl; 
  cout << "  of photon density as a function of distance to core." << endl; 
  cout << "  Usage: " << prog << " [flags] raw_file" << endl;
  cout << "    If 'raw_file' does not exits, switch to STDIN and use raw_file as" << endl;
  cout << "    basename for output file." << endl;
  cout << "    flags:"<<endl;
  cout << "      -c <CERARY input line> : CERARY line (expects complete line!) from input file" << endl;
  cout << "      -v: enable verbose outputs"<<endl; 
  cout << "      -h: prints help and exits"<<endl << endl;
//  cout << "    * STILL NOT IMPLEMENTED"<<endl;
  if (verbose) {
    // verbose help
  }
  exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x2c2b(%rip), %rbx      # 0x3fc8
movq %rbx, %rdi
callq 0x1060
leaq 0xce4(%rip), %rsi       # 0x2090
movq %rax, %rdi
callq 0x1090
leaq 0xcf9(%rip), %rsi       # 0x20b4
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1060
leaq 0xcdf(%rip), %rsi       # 0x20b9
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xd1e(%rip), %rsi       # 0x210f
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xd3e(%rip), %rsi       # 0x2146
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
movq %r14, %rsi
callq 0x1090
leaq 0xd2e(%rip), %rsi       # 0x2150
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xd29(%rip), %rsi       # 0x2162
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xd58(%rip), %rsi       # 0x21a8
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xd5f(%rip), %rsi       # 0x21c6
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xd53(%rip), %rsi       # 0x21d1
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xd90(%rip), %rsi       # 0x2225
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
leaq 0xd9a(%rip), %rsi       # 0x2246
movq %rbx, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1060
pushq $0x1
popq %rdi
callq 0x10d0