LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: hexstr_to_bytes(unsigned char*, unsigned long, char*)
size_t hexstr_to_bytes(uint8_t *dst, size_t dst_size, char *hexstr)
{
	unsigned int len = strlen(hexstr);
	if (dst_size > (len/2))
	{
		dst_size = (len/2);
	}
	memset (dst,0,dst_size);
	for (unsigned int i=0; i < dst_size*2; i++)
	{
		unsigned int shift = 4 - 4 * (i & 1);
		unsigned int charIndex = i; //len-1-i;
		char c = hexstr[charIndex];
		uint8_t nibble = hexdigit_value (c);
		dst[i/2] |= nibble << shift;
	}
	return dst_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq %rdx, %rdi
movq %rdx, %r14
movq %rsi, %rbx
callq 0x2060
shrl %eax
movq %r15, %rdi
cmpq %rbx, %rax
cmovbq %rax, %rbx
xorl %r12d, %r12d
xorl %esi, %esi
movq %rbx, %rdx
callq 0x20a0
leal (%rbx,%rbx), %ebp
xorl %r13d, %r13d
cmpl %r13d, %ebp
jbe 0x23ce
movsbl (%r14,%r13), %edi
callq 0x232c
movl %r12d, %ecx
addl $0x4, %r12d
notb %cl
andb $0x4, %cl
shlxl %ecx, %eax, %eax
movl %r13d, %ecx
shrl %ecx
incq %r13
orb %al, (%r15,%rcx)
jmp 0x23a0
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/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: cleanup_hexstr(char*, unsigned long, char*, unsigned long)
size_t cleanup_hexstr(char *hexstr, size_t hexstr_size, char *str, size_t str_size)
{
	size_t cnt=0;
	int lastIs0=0;
	for (unsigned int j=0; j < str_size; j++)
	{
		char c = str[j];
		if (is_hexdigit (c))
		{
			if (cnt == hexstr_size-1) // need final char for null
			{
				printf ("Too many hex digits. hexstr=%s\n", hexstr);
				hexstr[cnt] = 0;
				return -1;
			}
			hexstr[cnt++] = c;
		}
		else if (lastIs0)
		{
			if ('x' == c)
			{
				cnt--;
			}
			if('X'==c)
			{
				cnt--;
			}
		}
		lastIs0 = '0' == c;
	}
	hexstr[cnt] = 0;
	return cnt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
decq %rsi
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, 0x8(%rsp)
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %rsi, 0x10(%rsp)
movl %ebp, %ebp
cmpq %r12, %rbp
jae 0x24af
movb (%r13,%rbp), %bl
movsbl %bl, %edi
callq 0x2353
testl %eax, %eax
je 0x2486
movq 0x10(%rsp), %r14
cmpq %r14, %r15
je 0x24b9
movq 0x8(%rsp), %rax
movb %bl, (%rax,%r15)
incq %r15
jmp 0x24a1
testl %r14d, %r14d
je 0x24a1
xorl %eax, %eax
cmpb $0x78, %bl
sete %al
subq %rax, %r15
xorl %eax, %eax
cmpb $0x58, %bl
sete %al
subq %rax, %r15
xorl %r14d, %r14d
cmpb $0x30, %bl
sete %r14b
incl %ebp
jmp 0x2456
movq 0x8(%rsp), %rbx
movq %r15, %r14
jmp 0x24d3
movq 0x8(%rsp), %rbx
leaq 0x1ba0(%rip), %rdi      # 0x4065
xorl %eax, %eax
movq %rbx, %rsi
callq 0x2030
pushq $-0x1
popq %r15
movb $0x0, (%rbx,%r14)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: print_128(char const*, unsigned char const*, char const*)
static
void print_128(const char m[], const uint8_t a[16], const char m2[])
{
	print_bytes_sep (m, a, 4, "_", "");
	print_bytes_sep ("", a+4 , 4, "_", "");
	print_bytes_sep ("", a+8 , 4, "_", "");
	print_bytes_sep ("", a+12, 4, m2, "");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x114a(%rip), %r15      # 0x444a
movq %rdx, %rbx
movq %rsi, %r14
movq %r15, %rdx
callq 0x33b4
leaq 0xf42(%rip), %r12       # 0x4257
leaq 0x4(%r14), %rsi
movq %r15, %rdx
movq %r12, %rdi
callq 0x33b4
leaq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x33b4
addq $0xc, %r14
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x33b4
// File: /workspace/github_cpp_makefile_star2_O2/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: print_bytes_sep(char const*, unsigned char const*, unsigned int, char const*, char const*)
static
void print_bytes_sep(const char *msg,const unsigned char *buf, unsigned int size, const char m2[], const char sep[])
{
    unsigned int i;
    printf ("%s", msg);
    for (i=0; i < size-1; i++)
	{
		printf ("%02X%s", buf[i], sep);
	}
    if (i < size)
	{
		printf ("%02X", buf[i]);
	}
    printf ("%s", m2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x1086(%rip), %rdi      # 0x4450
xorl %eax, %eax
movq %rdx, %rbx
callq 0x2030
leaq 0x1071(%rip), %r15      # 0x444c
leaq 0xe75(%rip), %r12       # 0x4257
xorl %r13d, %r13d
cmpq $0x3, %r13
je 0x3402
movzbl (%r14,%r13), %esi
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2030
incq %r13
jmp 0x33e5
movzbl 0x3(%r14), %esi
leaq 0xc52(%rip), %rdi       # 0x4060
xorl %eax, %eax
callq 0x2030
leaq 0x1034(%rip), %rdi      # 0x4450
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2030
nop
// File: /workspace/github_cpp_makefile_star2_O2/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: aes_brute_force::mask_to_offsets(unsigned char*, unsigned char*, voffset*)
static
	void mask_to_offsets(uint8_t cipher_mask[16], uint8_t next_block[16], voffset_t *v)
	{
		v->n_offsets = 0;
		for (unsigned int i=0; i < 16; i++)
		{
			v->next[i] = next_block[i];
			if (cipher_mask[i]) 
			{
				v->offsets[v->n_offsets++] = i;
				uint8_t count = 0;
				for (unsigned int j=0x33; j < 0x7f; j++)
				{
					// generate range of valid chars for each byte
					if (j != 0x3b && j != 0x3d && j != 0x22)
					{
						v->valid_chars[i][count++] = j ^ v->next[i];
					}
				}
				v->n_valid_chars = count;
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x11(%rdx), %rax
movl $0x33, %r8d
movabsq $0x2800000400000000, %r9 # imm = 0x2800000400000000
xorl %ecx, %ecx
movb $0x0, 0x10(%rdx)
cmpq $0x10, %rcx
je 0x34c0
movb (%rsi,%rcx), %r10b
movb %r10b, 0x1012(%rdx,%rcx)
cmpb $0x0, (%rdi,%rcx)
je 0x34bb
movzbl 0x10(%rdx), %r10d
movl %r8d, %ebx
leal 0x1(%r10), %r11d
movb %r11b, 0x10(%rdx)
movq %rcx, %r11
shlq $0x8, %r11
movb %cl, (%rdx,%r10)
xorl %r10d, %r10d
addq %rax, %r11
cmpl $0x3d, %ebx
ja 0x3495
movl %ebx, %r14d
btq %r14, %r9
jb 0x34b0
cmpl $0x7f, %ebx
je 0x34b4
movb 0x1012(%rdx,%rcx), %bpl
movzbl %r10b, %r14d
incb %r10b
xorb %bl, %bpl
movb %bpl, (%r14,%r11)
incl %ebx
jmp 0x3487
movb %r10b, 0x1011(%rdx)
incq %rcx
jmp 0x344e
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: aes_brute_force::aes_brute_force(unsigned char*, unsigned char*, unsigned char*, unsigned char*, unsigned char*, unsigned char*, unsigned char*)
explicit aes_brute_force(uint8_t cipher_mask[16], uint8_t cipher[16], uint8_t key[16], uint8_t iv[16], uint8_t plain_mask[16], uint8_t plain[16], uint8_t next_block[16])
	{
		aes128_block_t b;

		memcpy (&b, cipher, 16);
		memcpy (this->cipher_mask, cipher_mask, 16);
		memcpy (this->key, key, 16);
		memcpy (this->iv, iv, 16);
		memcpy (this->plain_mask, plain_mask, 16);
		memcpy (this->plain, plain, 16);
		memcpy (this->next_block, next_block, 16);

		blocks.push_back (b);
		mask_to_offsets (cipher_mask, next_block, &this->v);
		nbits = this->v.n_offsets * 8;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
vxorps %xmm0, %xmm0, %xmm0
andq $0x0, 0x1050(%rdi)
movq %rsi, %r14
movq %rsp, %rsi
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %r15
leaq 0x1040(%rdi), %r12
movq %rdi, %rbx
vmovups %xmm0, 0x1040(%rdi)
vmovups (%rdx), %xmm0
vmovaps %xmm0, (%rsi)
vmovups (%r14), %xmm0
vmovups %xmm0, 0x10a8(%rdi)
vmovups (%rcx), %xmm0
vmovups %xmm0, 0x1058(%rdi)
vmovups (%r8), %xmm0
vmovups %xmm0, 0x1068(%rdi)
vmovups (%r9), %xmm0
vmovups %xmm0, 0x1088(%rdi)
vmovups (%rax), %xmm0
vmovups %xmm0, 0x1078(%rdi)
vmovups (%r15), %xmm0
vmovups %xmm0, 0x10b8(%rdi)
movq %r12, %rdi
callq 0x37fe
leaq 0x9(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3430
movzbl 0x19(%rbx), %eax
shll $0x3, %eax
movl %eax, 0x102c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %rax, %rbx
callq 0x395e
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: aes_brute_force::compute()
void compute()
	{
		loop_cnt = 0;
		for(auto b=blocks.begin(); b != blocks.end(); ++b) 
		{
			uint64_t cnt;
			search (v, b->bytes, key, iv, plain_mask, plain, cnt, found);
			loop_cnt += cnt;
			if (found)
			{
				memcpy (valid_cipher, b->bytes, 16);
				return;
			}
			if (is_done()) // used for multithread operations
			{ 
				return;
			}
		}
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2078, %rsp           # imm = 0x2078
andq $0x0, (%rdi)
leaq 0x9(%rdi), %rax
leaq 0x1088(%rdi), %rbp
leaq 0x1078(%rdi), %r15
leaq 0x8(%rdi), %r13
leaq 0x1050(%rsp), %r12
movq %rdi, %rbx
movq 0x1040(%rdi), %r14
movq %rax, 0x1040(%rsp)
leaq 0x1058(%rdi), %rax
movq %rax, 0x1038(%rsp)
leaq 0x1068(%rdi), %rax
movq %rax, 0x1030(%rsp)
cmpq 0x1048(%rbx), %r14
je 0x3749
movq 0x1040(%rsp), %rsi
movl $0x1022, %edx           # imm = 0x1022
movq %r12, %rdi
callq 0x20e0
movl $0x1022, %ecx           # imm = 0x1022
movq %rsp, %rdi
movq %r12, %rsi
leaq 0x1048(%rsp), %r9
movq %r15, %r8
rep  movsb (%rsi), %es:(%rdi)
movq %r13, 0x1028(%rsp)
movq %r14, %rdi
movq %rbp, %rcx
movq 0x1038(%rsp), %rsi
movq 0x1030(%rsp), %rdx
callq 0x396c
movq 0x1048(%rsp), %rax
addq %rax, (%rbx)
cmpb $0x1, 0x8(%rbx)
je 0x373c
cmpb $0x0, 0x39e6(%rip)      # 0x711a
jne 0x3749
addq $0x10, %r14
jmp 0x36c3
vmovups (%r14), %xmm0
vmovups %xmm0, 0x1030(%rbx)
addq $0x2078, %rsp           # imm = 0x2078
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/main.cpp
// Function: main
int main() {
	Film film(256, 128);

	Camera camera(film, 20, 0.1f, 12);
	camera.position = Vector3(12, 2, 3);
	camera.lookAt(Vector3(0, 1, 0));

	Scene scene;
	initScene(scene);

	Renderer renderer(100);
	renderer.render(scene, camera);

	return 0;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x80, %edx
callq 0x2ff0
leaq 0x48(%rsp), %rdi
movss 0x2808(%rip), %xmm0     # 0x5014
movss 0x2804(%rip), %xmm1     # 0x5018
movss 0x2800(%rip), %xmm2     # 0x501c
movq %rbx, %rsi
callq 0x3318
movsd 0x2894(%rip), %xmm0     # 0x50c0
leaq 0x48(%rsp), %rdi
movsd %xmm0, 0x14(%rdi)
movl $0x40400000, 0x1c(%rdi) # imm = 0x40400000
movsd 0x288b(%rip), %xmm0     # 0x50d0
leaq 0x20(%rsp), %rsi
movsd %xmm0, (%rsi)
andl $0x0, 0x8(%rsi)
callq 0x3508
leaq 0x20(%rsp), %rdi
andq $0x0, 0x8(%rdi)
leaq 0x5448(%rip), %rax      # 0x7cb0
addq $0x10, %rax
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
callq 0x23ac
leaq 0xc(%rsp), %rdi
movl $0x64, (%rdi)
leaq 0x20(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x3f2a
leaq 0x20(%rsp), %rdi
callq 0x28f6
leaq 0x10(%rsp), %rdi
callq 0x308e
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
jmp 0x28bb
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x28f6
jmp 0x28cf
jmp 0x28cc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x308e
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/math.cpp
// Function: gui::Math::randomDisk()
Vector3 Math::randomDisk() {
		Vector3 v;
		do {
			v = Vector3(Math::random(), Math::random(), 0) * 2 - Vector3(1, 1, 0);
		} while(v.length() > 1);
		return v;
	}

// Assembly:
subq $0x18, %rsp
callq 0x28e2
movaps %xmm0, (%rsp)
callq 0x28e2
movaps (%rsp), %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
addps %xmm2, %xmm2
addps 0x2331(%rip), %xmm2     # 0x5110
movaps %xmm2, %xmm0
mulps %xmm2, %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm2, %xmm1
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
sqrtss %xmm1, %xmm0
ucomiss 0x2211(%rip), %xmm0     # 0x5010
ja 0x2dc0
xorps %xmm1, %xmm1
movaps %xmm2, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/math.cpp
// Function: gui::Math::randomSphere()
Vector3 Math::randomSphere() {
		Vector3 v;
		do {
			v = Vector3(Math::random(), Math::random(), Math::random()) * 2 - Vector3(1);
		} while(v.length() > 1);
		return v;
	}

// Assembly:
subq $0x28, %rsp
callq 0x28e2
movaps %xmm0, (%rsp)
callq 0x28e2
movaps %xmm0, 0x10(%rsp)
callq 0x28e2
movaps (%rsp), %xmm3
movaps %xmm0, %xmm1
addss %xmm0, %xmm1
unpcklps 0x10(%rsp), %xmm3       # xmm3 = xmm3[0],mem[0],xmm3[1],mem[1]
addps %xmm3, %xmm3
addps 0x22ce(%rip), %xmm3     # 0x5110
addss 0x22d6(%rip), %xmm1     # 0x5120
movaps %xmm3, %xmm0
mulps %xmm3, %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movaps %xmm3, %xmm2
mulss %xmm3, %xmm2
addss %xmm0, %xmm2
movaps %xmm1, %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
sqrtss %xmm0, %xmm0
ucomiss 0x219b(%rip), %xmm0     # 0x5010
ja 0x2e10
movaps %xmm3, %xmm0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/film.cpp
// Function: gui::Film::Film(int, int)
Film::Film(int width, int height) : width(width), height(height) {
		pixels = new Vector3*[height];
		for(int i = 0; i < height; ++i) {
			pixels[i] = new Vector3[width];
			for (int j = 0; j < width; ++j) {
				pixels[i][j] = Vector3(0);
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %edx, %edi
shlq $0x3, %rdi
xorl %r13d, %r13d
testl %edx, %edx
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
cmovlel %r13d, %ebx
callq 0x2030
movq %rax, %r15
movslq %ebp, %rcx
pushq $0xc
popq %rdx
movq %rcx, %rax
mulq %rdx
movq %rax, %r12
movq %r15, 0x8(%r14)
pushq $-0x1
popq %rax
cmovoq %rax, %r12
testl %ecx, %ecx
cmovlel %r13d, %ecx
imulq $0xc, %rcx, %rbp
cmpq %rbx, %r13
je 0x307e
movq %r12, %rdi
callq 0x2030
movq %rax, (%r15,%r13,8)
movq 0x8(%r14), %r15
xorl %eax, %eax
cmpq %rax, %rbp
je 0x3079
movq (%r15,%r13,8), %rcx
andq $0x0, (%rcx,%rax)
andl $0x0, 0x8(%rcx,%rax)
addq $0xc, %rax
jmp 0x3060
incq %r13
jmp 0x3049
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/film.cpp
// Function: gui::Film::gammaCorrection()
void Film::gammaCorrection() {
		for(int i = 0; i < height; ++i) {
			for(int j = 0; j < width; ++j) {
				Vector3& c = pixels[i][j];
				c.x = sqrtf(c.x);
				c.y = sqrtf(c.y);
				c.z = sqrtf(c.z);
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x8
popq %r15
xorps %xmm1, %xmm1
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jge 0x317d
movq %r15, %r12
xorl %r13d, %r13d
movslq (%rbx), %rax
cmpq %rax, %r13
jge 0x3175
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rbp
movss -0x8(%rbp,%r12), %xmm0
ucomiss %xmm1, %xmm0
jb 0x311b
sqrtss %xmm0, %xmm0
jmp 0x3123
callq 0x2250
xorps %xmm1, %xmm1
movss %xmm0, -0x8(%rbp,%r12)
movss -0x4(%rbp,%r12), %xmm0
ucomiss %xmm1, %xmm0
jb 0x313c
sqrtss %xmm0, %xmm0
jmp 0x3144
callq 0x2250
xorps %xmm1, %xmm1
movss %xmm0, -0x4(%rbp,%r12)
movss (%rbp,%r12), %xmm0
ucomiss %xmm1, %xmm0
jb 0x315d
sqrtss %xmm0, %xmm0
jmp 0x3165
callq 0x2250
xorps %xmm1, %xmm1
movss %xmm0, (%rbp,%r12)
incq %r13
addq $0xc, %r12
jmp 0x30f9
incq %r14
jmp 0x30e6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/film.cpp
// Function: gui::Film::writePPM() const
void Film::writePPM() const {
		std::ofstream file;
		file.open("image.ppm");
		file << "P3\n" << width << ' ' << height << '\n' << "255\n";
		for(int i = 0; i < height; ++i) {
			for(int j = 0; j < width; ++j) {
				file << (int) (pixels[i][j].x * 255) << ' '
					 << (int) (pixels[i][j].y * 255) << ' '
					 << (int) (pixels[i][j].z * 255) << ' ';
			}
			file << '\n';
		}
		file.close();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2200
leaq 0x1fac(%rip), %rsi      # 0x5160
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x2050
leaq 0x1fa4(%rip), %rsi      # 0x516a
leaq 0x8(%rsp), %rdi
callq 0x2130
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2210
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x2160
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2210
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x2160
leaq 0x1f6c(%rip), %rsi      # 0x516e
movq %rax, %rdi
callq 0x2130
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
pushq $0x20
popq %rbp
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0x32d9
xorl %r13d, %r13d
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x32c6
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rax
movss (%rax,%r13), %xmm0
mulss 0x1f12(%rip), %xmm0     # 0x515c
cvttss2si %xmm0, %esi
movq %r14, %rdi
callq 0x2210
movq %rax, %rdi
movl %ebp, %esi
callq 0x2160
movq 0x8(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movss 0x4(%rcx,%r13), %xmm0
mulss 0x1ee5(%rip), %xmm0     # 0x515c
cvttss2si %xmm0, %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
movl %ebp, %esi
callq 0x2160
movq 0x8(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movss 0x8(%rcx,%r13), %xmm0
mulss 0x1eb8(%rip), %xmm0     # 0x515c
cvttss2si %xmm0, %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
movl %ebp, %esi
callq 0x2160
incq %r15
addq $0xc, %r13
jmp 0x3228
movq %r14, %rdi
pushq $0xa
popq %rsi
callq 0x2160
incq %r12
jmp 0x3215
leaq 0x8(%rsp), %rdi
callq 0x21a0
leaq 0x8(%rsp), %rdi
callq 0x21c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3303
jmp 0x3303
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/camera.cpp
// Function: gui::Camera::getRay(float, float) const
Ray Camera::getRay(float px, float py) const {
		Vector3 offset = Math::randomDisk() * apeture;
		offset = x * offset.x + y * offset.y;
		float u = (px - film.width * 0.5f) / resolution;
		float v = (film.height * 0.5f - py) / resolution;
		return Ray(position + offset, x * u + y * v - z - offset / focal);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movss %xmm1, 0x30(%rsp)
movss %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2dbc
movaps %xmm0, %xmm2
movss 0xc(%r14), %xmm1
movaps %xmm1, %xmm0
mulss %xmm2, %xmm0
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
mulss %xmm1, %xmm2
movaps %xmm2, 0x20(%rsp)
leaq 0x20(%r14), %r12
movq %r12, %rdi
callq 0x359e
movaps %xmm0, 0x10(%rsp)
movss %xmm1, 0xc(%rsp)
leaq 0x2c(%r14), %r13
movq %r13, %rdi
movaps 0x20(%rsp), %xmm0
callq 0x359e
addps 0x10(%rsp), %xmm0
addss 0xc(%rsp), %xmm1
leaq 0x50(%rsp), %r15
movlps %xmm0, (%r15)
movss %xmm1, 0x8(%r15)
movq (%r14), %rax
cvtsi2ssl (%rax), %xmm0
movss 0x1d7a(%rip), %xmm1     # 0x5194
mulss %xmm1, %xmm0
movss 0x8(%rsp), %xmm2
subss %xmm0, %xmm2
movss 0x8(%r14), %xmm0
divss %xmm0, %xmm2
movss %xmm2, 0x8(%rsp)
cvtsi2ssl 0x4(%rax), %xmm2
mulss %xmm1, %xmm2
subss 0x30(%rsp), %xmm2
divss %xmm0, %xmm2
movss %xmm2, 0x20(%rsp)
leaq 0x14(%r14), %rdi
movq %r15, %rsi
callq 0x35b2
movaps %xmm0, 0x30(%rsp)
movss %xmm1, 0xc(%rsp)
movq %r12, %rdi
movss 0x8(%rsp), %xmm0
callq 0x359e
movaps %xmm0, 0x10(%rsp)
movss %xmm1, 0x8(%rsp)
movq %r13, %rdi
movss 0x20(%rsp), %xmm0
callq 0x359e
addps 0x10(%rsp), %xmm0
addss 0x8(%rsp), %xmm1
leaq 0x40(%rsp), %rdi
movlps %xmm0, (%rdi)
movss %xmm1, 0x8(%rdi)
leaq 0x38(%r14), %rsi
callq 0x35c8
movss 0x1b58(%rip), %xmm2     # 0x5010
divss 0x10(%r14), %xmm2
movss 0x8(%r15), %xmm3
mulss %xmm2, %xmm3
movsd (%r15), %xmm4
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
mulps %xmm4, %xmm2
subps %xmm2, %xmm0
subss %xmm3, %xmm1
movaps 0x30(%rsp), %xmm2
movlps %xmm2, (%rbx)
movss 0xc(%rsp), %xmm2
movss %xmm2, 0x8(%rbx)
movlps %xmm0, 0xc(%rbx)
movss %xmm1, 0x14(%rbx)
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/./vector3.h
// Function: gui::Vector3::cross(gui::Vector3 const&) const
Vector3 cross(const Vector3& v) const {
			return Vector3(
				y * v.z - z * v.y,
				z * v.x - x * v.z,
				x * v.y - y * v.x
			);
		}

// Assembly:
movss (%rsi), %xmm2
movss (%rdi), %xmm1
movsd 0x4(%rdi), %xmm3
movsd 0x4(%rsi), %xmm4
movaps %xmm1, %xmm5
shufps $0xd4, %xmm3, %xmm5     # xmm5 = xmm5[0,1],xmm3[1,3]
shufps $0x52, %xmm3, %xmm5     # xmm5 = xmm5[2,0],xmm3[1,1]
mulps %xmm4, %xmm5
movaps %xmm2, %xmm0
shufps $0xd4, %xmm4, %xmm0     # xmm0 = xmm0[0,1],xmm4[1,3]
shufps $0x52, %xmm4, %xmm0     # xmm0 = xmm0[2,0],xmm4[1,1]
mulps %xmm3, %xmm0
subps %xmm5, %xmm0
mulss %xmm3, %xmm2
mulss %xmm4, %xmm1
subss %xmm2, %xmm1
retq
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/./vector3.h
// Function: gui::Vector3::operator*=(float)
Vector3& operator*=(float k) {
			x *= k;
			y *= k;
			z *= k;
			return *this;
		}

// Assembly:
movq %rdi, %rax
movsd (%rdi), %xmm1
movaps %xmm0, %xmm2
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
mulps %xmm1, %xmm2
movlps %xmm2, (%rdi)
mulss 0x8(%rdi), %xmm0
movss %xmm0, 0x8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/scene.cpp
// Function: gui::Scene::intersect(gui::Ray const&, float, float, gui::Intersection&) const
bool Scene::intersect(
		const Ray& ray,
		float tMin,
		float tMax,
		Intersection& intersection) const {
			
		bool intersected = false;
		for(auto e : shapes) {
			if(e->intersect(ray, tMin, tMax, intersection)) {
				if(intersection.t < tMax) {
					tMax = intersection.t;
					intersected = true;
				}
			}
		}
		return intersected;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movss %xmm0, 0xc(%rsp)
movq %rsi, %r14
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
xorl %ebp, %ebp
cmpq %r12, %r15
je 0x3899
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movss 0xc(%rsp), %xmm0
movss %xmm1, 0x8(%rsp)
movq %rbx, %rdx
callq *0x10(%rax)
testb %al, %al
je 0x388d
movss (%rbx), %xmm0
movss 0x8(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3893
movb $0x1, %bpl
movaps %xmm0, %xmm1
jmp 0x3893
movss 0x8(%rsp), %xmm1
addq $0x8, %r15
jmp 0x3852
andb $0x1, %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/diffuse.cpp
// Function: gui::Diffuse::scatter(gui::Ray const&, gui::Intersection const&, gui::Vector3&, gui::Ray&) const
bool Diffuse::scatter(
		const Ray& in,
		const Intersection& intersection,
		Vector3& attenuation,
		Ray& scattered) const {

		attenuation = albedo;
		scattered.origin = intersection.position + intersection.normal * 0.001f;
		scattered.direction = intersection.normal + Math::randomSphere();
		return true;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl 0x10(%rdi), %eax
movl %eax, 0x8(%rcx)
movq 0x8(%rdi), %rax
movq %rax, (%rcx)
leaq 0x4(%rdx), %r14
leaq 0x10(%rdx), %r15
movss 0x18dd(%rip), %xmm0     # 0x51cc
movq %r15, %rdi
callq 0x359e
leaq 0x8(%rsp), %r12
movlps %xmm0, (%r12)
movss %xmm1, 0x8(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x35b2
movlps %xmm0, (%rbx)
movss %xmm1, 0x8(%rbx)
callq 0x2e0c
movlps %xmm0, (%r12)
movss %xmm1, 0x8(%r12)
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x35b2
movlps %xmm0, 0xc(%rbx)
movss %xmm1, 0x14(%rbx)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/metal.cpp
// Function: gui::Metal::scatter(gui::Ray const&, gui::Intersection const&, gui::Vector3&, gui::Ray&) const
bool Metal::scatter(
		const Ray& in,
		const Intersection& intersection,
		Vector3& attenuation, Ray& scattered) const {

		attenuation = albedo;
		scattered.origin = intersection.position + intersection.normal * 0.001f;
		scattered.direction = in.direction.reflect(intersection.normal) + Math::randomSphere() * fuzzy;
		if (scattered.direction.dot(intersection.normal) > 0) return true;
		return false;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %r8, %rbx
movq %rsi, %r12
movq %rdi, %r15
movl 0x10(%rdi), %eax
movl %eax, 0x8(%rcx)
movq 0x8(%rdi), %rax
movq %rax, (%rcx)
leaq 0x4(%rdx), %r13
leaq 0x10(%rdx), %r14
movss 0x183d(%rip), %xmm0     # 0x51cc
movq %r14, %rdi
callq 0x359e
leaq 0x20(%rsp), %rsi
movlps %xmm0, (%rsi)
movss %xmm1, 0x8(%rsi)
movq %r13, %rdi
callq 0x35b2
movlps %xmm0, (%rbx)
movss %xmm1, 0x8(%rbx)
addq $0xc, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3a1a
movaps %xmm0, 0x10(%rsp)
movss %xmm1, 0xc(%rsp)
callq 0x2e0c
movss 0x14(%r15), %xmm2
mulss %xmm2, %xmm1
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
mulps %xmm0, %xmm2
addps 0x10(%rsp), %xmm2
addss 0xc(%rsp), %xmm1
leaq 0xc(%rbx), %rdi
movlps %xmm2, 0xc(%rbx)
movss %xmm1, 0x14(%rbx)
movq %r14, %rsi
callq 0x3a58
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
seta %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/./vector3.h
// Function: gui::Vector3::refract(gui::Vector3 const&, float, gui::Vector3&) const
bool refract(const Vector3& normal, float niOverNt, Vector3& refracted) const {
			Vector3 v = Vector3(*this).identity();
			float c1 = v.dot(normal);
			float c2 = 1 - niOverNt * niOverNt * (1 - c1 * c1);
			if(c2 > 0) {
				refracted = (v - normal * c1) * niOverNt - normal * sqrt(c2);
				return true;
			}
			return false;
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movaps %xmm0, 0x10(%rsp)
movq %rsi, %r14
movl 0x8(%rdi), %ecx
leaq 0x48(%rsp), %rax
movl %ecx, 0x8(%rax)
movq (%rdi), %rcx
movq %rcx, (%rax)
movq %rax, %rdi
callq 0x35de
movaps 0x10(%rsp), %xmm3
movsd (%rax), %xmm5
movaps %xmm5, %xmm0
shufps $0x55, %xmm5, %xmm0     # xmm0 = xmm0[1,1],xmm5[1,1]
movss 0x8(%rax), %xmm4
mulss 0x4(%r14), %xmm0
movss (%r14), %xmm1
mulss %xmm5, %xmm1
addss %xmm0, %xmm1
movss 0x8(%r14), %xmm0
mulss %xmm4, %xmm0
addss %xmm1, %xmm0
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
movss 0x129c(%rip), %xmm6     # 0x5010
movaps %xmm6, %xmm2
subss %xmm1, %xmm2
movaps %xmm3, %xmm1
mulss %xmm3, %xmm1
mulss %xmm2, %xmm1
subss %xmm1, %xmm6
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm6
jbe 0x3e22
movaps %xmm5, 0x30(%rsp)
movq %r14, %rdi
movss %xmm4, 0x8(%rsp)
movss %xmm6, 0xc(%rsp)
callq 0x359e
movss 0xc(%rsp), %xmm2
movaps %xmm0, 0x20(%rsp)
movss 0x8(%rsp), %xmm0
subss %xmm1, %xmm0
mulss 0x10(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
ucomiss 0x1429(%rip), %xmm2     # 0x5200
jb 0x3ddf
sqrtss %xmm2, %xmm0
jmp 0x3de7
movaps %xmm2, %xmm0
callq 0x2250
movq %r14, %rdi
callq 0x359e
movaps 0x30(%rsp), %xmm3
subps 0x20(%rsp), %xmm3
movaps 0x10(%rsp), %xmm2
unpcklps %xmm2, %xmm2            # xmm2 = xmm2[0,0,1,1]
mulps %xmm3, %xmm2
subps %xmm0, %xmm2
movss 0x8(%rsp), %xmm0
subss %xmm1, %xmm0
movlps %xmm2, (%rbx)
movss %xmm0, 0x8(%rbx)
movss 0xc(%rsp), %xmm6
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm6
seta %al
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/renderer.cpp
// Function: gui::Renderer::radiance(gui::Ray const&, gui::Scene const&, int) const
Vector3 Renderer::radiance(const Ray& ray, const Scene& scene, int depth) const {
		Intersection intersection;
		if (scene.intersect(ray, 0, 10000, intersection)) {
			Ray scattered;
			Vector3 attenuation;
			if (intersection.material->scatter(
				ray, intersection, attenuation, scattered) && depth < 30) {
				return attenuation * radiance(scattered, scene, ++depth);
			} else {
				return Vector3(0);
			}
		} else {
			Vector3 unit = ray.direction;
			float k = (unit.identity().y + 1) * 0.5f;
			return Vector3(1) * (1 - k) + Vector3(0.5f, 0.7f, 1) * k;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x30(%rsp), %rdx
movl $0x7f7fffff, (%rdx)     # imm = 0x7F7FFFFF
movq (%r14), %rax
movss 0x13c0(%rip), %xmm1     # 0x5224
xorps %xmm0, %xmm0
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x3ec8
leaq 0x30(%rsp), %rdx
movq 0x20(%rdx), %rdi
movq (%rdi), %rax
leaq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %r8
movq %r12, %rsi
callq *0x10(%rax)
xorps %xmm0, %xmm0
cmpl $0x1d, %ebx
jg 0x3f24
testb %al, %al
xorps %xmm1, %xmm1
je 0x3f18
incl %ebx
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x3e38
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
mulps %xmm2, %xmm0
mulss 0x10(%rsp), %xmm1
jmp 0x3f18
movl 0x14(%r12), %eax
leaq 0x18(%rsp), %rdi
movl %eax, 0x8(%rdi)
movq 0xc(%r12), %rax
movq %rax, (%rdi)
callq 0x35de
movss 0x1126(%rip), %xmm0     # 0x5010
movss 0x4(%rax), %xmm1
addss %xmm0, %xmm1
mulss 0x1299(%rip), %xmm1     # 0x5194
movaps %xmm1, %xmm2
shufps $0x0, %xmm1, %xmm2      # xmm2 = xmm2[0,0],xmm1[0,0]
mulps 0x1327(%rip), %xmm2     # 0x5230
subss %xmm1, %xmm0
addss %xmm0, %xmm1
shufps $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
addps %xmm2, %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorps %xmm1, %xmm1
jmp 0x3f18
nop
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/renderer.cpp
// Function: gui::Renderer::render(gui::Scene const&, gui::Camera&) const
void Renderer::render(const Scene& scene, Camera& camera) const {
		float r = 1.0f / samples;
		for(int i = 0; i < camera.film.height; ++i) {
			printf("\rrendering %5.2f%%", 100.0f * (i + 1) / camera.film.height);
			fflush(stdout);
			for(int j = 0; j < camera.film.width; ++j) {
				for (int k = 0; k < samples; ++k) {
					Ray ray = camera.getRay(j + Math::random(), i + Math::random());
					camera.film.pixels[i][j] += radiance(ray, scene, 0);
				}
				camera.film.pixels[i][j] *= r;
			}
		}

		printf("\nstatistical data:\n");
		printf("num intersects: %lld\n", nIntersects);

		camera.film.gammaCorrection();
		camera.film.writePPM();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, 0x28(%rsp)
movq %rdi, %r15
cvtsi2ssl (%rdi), %xmm0
movss 0x10c1(%rip), %xmm1     # 0x5010
divss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
movq (%rdx), %rax
xorl %ebp, %ebp
leaq 0x40(%rsp), %r13
movslq 0x4(%rax), %rax
cmpq %rax, %rbp
jge 0x407e
leaq 0x1(%rbp), %rcx
movq %rcx, 0x18(%rsp)
cvtsi2ss %ecx, %xmm0
cvtsi2ss %eax, %xmm1
mulss 0x129f(%rip), %xmm0     # 0x5228
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x12a8(%rip), %rdi      # 0x5240
movb $0x1, %al
callq 0x2040
movq 0x402a(%rip), %rax      # 0x7fd0
movq (%rax), %rdi
callq 0x2170
cvtsi2ss %ebp, %xmm0
movss %xmm0, 0xc(%rsp)
xorl %edx, %edx
movq (%rbx), %rax
movslq (%rax), %rcx
cmpq %rcx, %rdx
jge 0x4074
cvtsi2ss %edx, %xmm0
movss %xmm0, 0x10(%rsp)
xorl %r14d, %r14d
movq %rdx, 0x20(%rsp)
imulq $0xc, %rdx, %r12
cmpl (%r15), %r14d
jge 0x404e
callq 0x28e2
addss 0x10(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
callq 0x28e2
movaps %xmm0, %xmm1
addss 0xc(%rsp), %xmm1
movq %r13, %rdi
movq %rbx, %rsi
movss 0x14(%rsp), %xmm0
callq 0x3388
movq %r15, %rdi
movq %r13, %rsi
movq 0x28(%rsp), %rdx
xorl %ecx, %ecx
callq 0x3e38
movlps %xmm0, 0x30(%rsp)
movss %xmm1, 0x38(%rsp)
movq (%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax,%rbp,8), %rdi
addq %r12, %rdi
leaq 0x30(%rsp), %rsi
callq 0x40be
incl %r14d
jmp 0x3fdf
movq (%rbx), %rax
movq 0x8(%rax), %rax
addq (%rax,%rbp,8), %r12
movq %r12, %rdi
movss 0x8(%rsp), %xmm0
callq 0x3654
movq 0x20(%rsp), %rdx
incq %rdx
jmp 0x3fba
movq 0x18(%rsp), %rbp
jmp 0x3f63
leaq 0x11e4(%rip), %rdi      # 0x5269
callq 0x21d0
movq 0x67d7(%rip), %rsi      # 0xa868
leaq 0x11bb(%rip), %rdi      # 0x5253
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rdi
callq 0x30ce
movq (%rbx), %rdi
callq 0x318c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/GUI-Graphics[P]cpuraytracing/./vector3.h
// Function: gui::Vector3::operator+=(gui::Vector3 const&)
Vector3& operator+=(const Vector3& v) {
			x += v.x;
			y += v.y;
			z += v.z;
			return *this;
		}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm0
movsd (%rdi), %xmm1
addps %xmm0, %xmm1
movlps %xmm1, (%rdi)
movss 0x8(%rsi), %xmm0
addss 0x8(%rdi), %xmm0
movss %xmm0, 0x8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/alibakhtiar[P]ExampleHTTPServer/./HttpServer.hh
// Function: SimpleHttpServer::strtolower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void strtolower(std::string &str)
{
	for (std::string::size_type i=0; i < str.size(); ++i) {
		if ((str[i] >= 'A') && (str[i] <= 'Z'))
			str[i] += 32;
	}

	return;
}

// Assembly:
xorl %eax, %eax
cmpq 0x8(%rdi), %rax
jae 0x28a0
movq (%rdi), %rcx
movb (%rcx,%rax), %dl
leal -0x41(%rdx), %esi
cmpb $0x19, %sil
ja 0x289b
orb $0x20, %dl
movb %dl, (%rcx,%rax)
incq %rax
jmp 0x2880
retq
// File: /workspace/github_cpp_makefile_star2_O2/alibakhtiar[P]ExampleHTTPServer/./HttpServer.hh
// Function: SimpleHttpServer::serverRequestHandler(SimpleHttpServer::Server*, int, sockaddr_in)
static void serverRequestHandler(Server *server, int sock, struct sockaddr_in clientAddr)
{
	bool rc;
	Request *req;
	Response *res;
	char *buffer;
	ssize_t recvLen;

	// New request
	req = new Request;
	req->sock = sock;
	req->addr = clientAddr;

	// New response
	res = new Response;
	res->sock = sock;
	res->req  = req;

	// Recv buffer
	buffer = new char[1+RECV_BUFFER_SIZE];

	while (1) {
		memset(buffer, '\0', 1+RECV_BUFFER_SIZE);

		recvLen = recv(sock, buffer, RECV_BUFFER_SIZE, 0);
		if (recvLen == 0) {
			break;
		}
		else if (recvLen < 0) {
			APPERROR(_STRERR, _FUNC, _LINE);
			break;
		}

		// Request parser
		rc = httpRequestParse(req, buffer, recvLen);
		if (rc == false)
			break;

		if (req->hasError == true) {
			res->statusCode = 400;
			res->errorPage();
			res->send();
			break;
		}

		if (server->onRequestCallback != NULL)
			server->onRequestCallback(req, res);

		break;
	}

	close(sock);

	delete[] buffer;
	buffer = NULL;

	delete req;
	req = NULL;

	delete res;
	res = NULL;

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
movl $0xb8, %edi
callq 0x2210
movq %rax, %rbx
movq %rax, %rdi
callq 0x32a4
movl %ebp, 0x8(%rbx)
movq %r15, 0xc(%rbx)
movq %r14, 0x14(%rbx)
pushq $0x70
popq %rdi
callq 0x2210
movq %rax, %r14
movq %rax, %rdi
callq 0x3362
movl %ebp, 0x8(%r14)
movq %rbx, 0x10(%r14)
movl $0x801, %edi            # imm = 0x801
callq 0x2030
movq %rax, %r15
movl $0x801, %edx            # imm = 0x801
movq %rax, %rdi
xorl %esi, %esi
callq 0x2170
movl $0x800, %edx            # imm = 0x800
movl %ebp, %edi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x20c0
testq %rax, %rax
je 0x2bcc
js 0x2bf5
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x24bc
cmpb $0x1, 0x1c(%rbx)
jne 0x2bb2
movl $0x190, 0x18(%r14)      # imm = 0x190
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
jmp 0x2bcc
cmpq $0x0, 0x40(%r12)
je 0x2bcc
addq $0x30, %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x33c8
movl %ebp, %edi
callq 0x2380
movq %r15, %rdi
callq 0x2280
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x28(%rax)
movq 0x53d4(%rip), %rax      # 0x7fd0
movq (%rax), %r12
callq 0x2050
movl (%rax), %edi
callq 0x20d0
leaq 0x241f(%rip), %rsi      # 0x5031
leaq 0x2599(%rip), %rcx      # 0x51b2
movq %r12, %rdi
movq %rax, %rdx
movl $0x1a7, %r8d            # imm = 0x1A7
xorl %eax, %eax
callq 0x22b0
jmp 0x2bcc
movq %rax, %r15
pushq $0x70
popq %rsi
movq %r14, %rdi
jmp 0x2c44
movq %rax, %r15
movl $0xb8, %esi
movq %rbx, %rdi
callq 0x2230
movq %r15, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/alibakhtiar[P]ExampleHTTPServer/./HttpServer.hh
// Function: SimpleHttpServer::Request::~Request()
virtual ~Request(void)
	{
		this->method.clear();
		this->url.clear();
		this->queryString.clear();
		this->headers.clear();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x48ca(%rip), %rax      # 0x7cd0
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
andq $0x0, 0x28(%rdi)
movq 0x20(%rdi), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x40(%rdi), %r15
andq $0x0, 0x48(%rdi)
movq 0x40(%rdi), %rax
movb %cl, (%rax)
andq $0x0, 0x68(%rdi)
leaq 0x60(%rdi), %r12
movq 0x60(%rdi), %rax
movb %cl, (%rax)
addq $0x88, %r14
movq %r14, %rdi
callq 0x3494
movq %r14, %rdi
callq 0x3528
movq %r12, %rdi
callq 0x2120
movq %r15, %rdi
callq 0x2120
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/alibakhtiar[P]ExampleHTTPServer/./HttpServer.hh
// Function: SimpleHttpServer::Response::errorPage()
virtual void errorPage(void)
	{
		this->header("Content-Type", "text/html");
		this->header("Cache-Control", "no-cache, no-store, must-revalidate");

		this->body = "<!doctype html><html lang=\"en\">";
		this->body += "<head><title>Error</title></head>";
		this->body += "<body><h1>Error ";
		this->body += std::to_string(this->statusCode);
		this->body += "</h1><hr><p>";
		this->body += httpStatusMessage(this->statusCode);
		this->body += "</p></body></html>";

		return;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x1c95(%rip), %rsi      # 0x5201
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x30ca
leaq 0x1c89(%rip), %rsi      # 0x520e
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30ca
movq (%rbx), %rax
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq *(%rax)
leaq 0x70(%rsp), %rdi
callq 0x2120
leaq 0x90(%rsp), %rdi
callq 0x2120
leaq 0x1c51(%rip), %rsi      # 0x5218
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x30ca
leaq 0x1c49(%rip), %rsi      # 0x5226
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x30ca
movq (%rbx), %rax
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq *(%rax)
leaq 0x30(%rsp), %rdi
callq 0x2120
leaq 0x50(%rsp), %rdi
callq 0x2120
leaq 0x50(%rbx), %r14
leaq 0x1c2d(%rip), %rsi      # 0x524a
movq %r14, %rdi
callq 0x2360
leaq 0x1c3e(%rip), %rsi      # 0x526a
movq %r14, %rdi
callq 0x2350
leaq 0x1c51(%rip), %rsi      # 0x528c
movq %r14, %rdi
callq 0x2350
movl 0x18(%rbx), %esi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x3a2f
movq %r14, %rdi
movq %r15, %rsi
callq 0x2370
leaq 0x10(%rsp), %rdi
callq 0x2120
leaq 0x1c2e(%rip), %rsi      # 0x529d
movq %r14, %rdi
callq 0x2350
movl 0x18(%rbx), %edi
callq 0x2c51
movq %r14, %rdi
movq %rax, %rsi
callq 0x2350
leaq 0x1c19(%rip), %rsi      # 0x52aa
movq %r14, %rdi
callq 0x2350
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x36e5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2120
jmp 0x36c2
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x36e5
jmp 0x36ec
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2120
jmp 0x36dd
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x2120
jmp 0x36ef
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/jweinst1[P]Pages/src/main/Main.cpp
// Function: main
int main(int argc, char const *argv[]) {
        if(argc == 2)
        {
                long eventCount = std::strtol(argv[1],nullptr,10);
                for(long i = 0; i<eventCount; i++) MakeStory::one();
        }
        else std::cout<< "Error: Need argument for eventcount.\n";
        return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x133b
movq 0x8(%rsi), %rdi
xorl %ebx, %ebx
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x1140
testq %rax, %rax
cmovgq %rax, %rbx
subq $0x1, %rbx
jb 0x134e
callq 0x1358
jmp 0x132e
movq 0x5c96(%rip), %rdi      # 0x6fd8
leaq 0x2cbb(%rip), %rsi      # 0x4004
callq 0x10d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jweinst1[P]Pages/src/story/StoryEvent.cpp
// Function: StoryEvent::operator<<(char const*)
StoryEvent& StoryEvent::operator<<(const char* words)
{
        long wordSize = 0;
        const char* count = words;
        while(*count++) wordSize++;
        if(wordSize >= getSpace()) expandBy(wordSize * 2);
        while(*words) *_mark++ = *words++;
        return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
xorl %eax, %eax
cmpb $0x0, (%r14,%rax)
je 0x2c45
incq %rax
addq $0x2, %rsi
jmp 0x2c35
movq 0x10(%rbx), %rcx
subq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jl 0x2c6d
movq %rbx, %rdi
callq 0x2c7c
jmp 0x2c6d
incq %r14
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb %al, (%rcx)
movb (%r14), %al
testb %al, %al
jne 0x2c5c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jweinst1[P]Pages/src/story/StoryEvent.cpp
// Function: StoryEvent::expandBy(long)
void StoryEvent::expandBy(long addSize)
{
        long newCap = getCapacity() + addSize;
        long oldLen = getLen();
        char* newStream = new char[newCap + 1];
        std::fill(newStream, newStream + newCap, 0);
        char* writer = newStream;
        char* reader = _stream;
        while(reader != _mark)
        {
                *writer++ = *reader++;
        }
        delete[] _stream;
        _stream = newStream;
        _mark = _stream + oldLen;
        _end = _stream + newCap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq (%rdi), %r14
movq 0x8(%rdi), %r12
subq %r14, %rax
leaq (%rax,%rsi), %r13
leaq (%rax,%rsi), %rdi
incq %rdi
callq 0x1030
movq %rax, %r15
leaq (%rax,%r13), %rdx
xorl %eax, %eax
cmpq %rax, %r13
je 0x2cc3
movb $0x0, (%r15,%rax)
incq %rax
jmp 0x2cb4
xorl %eax, %eax
leaq (%r14,%rax), %rcx
cmpq %r12, %rcx
je 0x2cd9
movb (%rcx), %cl
movb %cl, (%r15,%rax)
incq %rax
jmp 0x2cc5
testq %r14, %r14
je 0x2cec
movq %r14, %rdi
movq %rdx, %r13
callq 0x1120
movq %r13, %rdx
subq %r14, %r12
movq %r15, (%rbx)
addq %r12, %r15
movq %r15, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jweinst1[P]Pages/src/story/StoryEvent.cpp
// Function: StoryEvent::operator<<(StoryPart::Type)
StoryEvent& StoryEvent::operator<<(StoryPart::Type flag)
{
        if(3 >= getSpace()) expandBy(getLen() * 2);
        switch(flag)
        {
        case StoryPart::Comma:
                *_mark++ = ',';
                *_mark++ = ' ';
                break;
        case StoryPart::Period:
                *_mark++ = '.';
                *_mark++ = ' ';
                break;
        case StoryPart::Space:
                *_mark++ = ' ';
                break;
        case StoryPart::Newline:
                *_mark++ = '\n';
                break;
        }
        return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rax
subq %rsi, %rax
cmpq $0x3, %rax
jg 0x2d38
subq (%rbx), %rsi
addq %rsi, %rsi
movq %rbx, %rdi
callq 0x2c7c
cmpl $0x3, %r14d
ja 0x2d85
movb $0x20, %al
movl %r14d, %ecx
leaq 0x13ce(%rip), %rdx      # 0x4118
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb $0x2c, (%rcx)
jmp 0x2d77
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb $0x2e, (%rcx)
jmp 0x2d77
movb $0xa, %al
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb %al, (%rcx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jweinst1[P]Pages/src/story/StoryEvent.cpp
// Function: StoryEvent::operator<<(Descriptor const&)
StoryEvent& StoryEvent::operator<<(const Descriptor& desc)
{
        DescriptorPath::Type path = DescriptorPath::get();
        switch(path)
        {
        case DescriptorPath::Zero:
                break;
        case DescriptorPath::One:
                *this << StoryPart::Space << desc.get().getString();
                break;
        case DescriptorPath::Two:
                *this << StoryPart::Space
                      << desc.get().getString()
                      << StoryPart::Comma
                      << desc.get().getString();
                break;
        case DescriptorPath::Two_And:
                *this << StoryPart::Space
                      << desc.get().getString()
                      << " and "
                      << desc.get().getString();
                break;
        }

        return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2ee4
cmpl $0x3, %eax
je 0x2de0
cmpl $0x2, %eax
je 0x2db6
cmpl $0x1, %eax
jne 0x2e1f
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x2dd9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2d0c
movq %r14, %rdi
callq 0x2a86
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2c24
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2d0c
jmp 0x2e0c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2d0c
movq %r14, %rdi
callq 0x2a86
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2c24
leaq 0x1324(%rip), %rsi      # 0x4128
movq %rbx, %rdi
callq 0x2c24
movq %r14, %rdi
callq 0x2a86
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x2c24
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jweinst1[P]Pages/src/story/StoryEvent.cpp
// Function: StoryEvent::operator<<(StoryObject const&)
StoryEvent& StoryEvent::operator<<(const StoryObject& sobj)
{
        *this << sobj.getDeterminer()
              << sobj.descriptor()
              << StoryPart::Space
              << sobj.getName();
        return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2a86
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ef8
movq %rax, %r15
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x2d8e
movq %r15, %rdi
xorl %esi, %esi
callq 0x2d0c
addq $0x60, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2ef8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jweinst1[P]Pages/src/story/StoryEvent.cpp
// Function: StoryEvent::operator<<(StoryAction const&)
StoryEvent& StoryEvent::operator<<(const StoryAction& sact)
{
        *this << StoryPart::Space;
        ActionPath::Type path = ActionPath::get();
        switch(path)
        {
        case ActionPath::Adverb:
                *this << sact.getAdverb()
                      << StoryPart::Space
                      << sact.getName();
                break;
        case ActionPath::None:
                *this << sact.getName();
                break;
        }
        return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x2d0c
callq 0x2f06
movq %rbx, %r15
cmpl $0x1, %eax
je 0x2ecb
testl %eax, %eax
jne 0x2ed6
leaq 0x28(%r14), %rdi
callq 0x2a86
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ef8
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
callq 0x2d0c
movq %r15, %rdi
movq %r14, %rsi
callq 0x2ef8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jweinst1[P]Pages/src/util/BlockStr.cpp
// Function: BlockStr::operator=(BlockStr const&)
BlockStr& BlockStr::operator=(const BlockStr& other)
{
        _str = new char[BlockStr::getLen(other.getString()) + 1];
        char* writer = _str;
        const char* reader = other.getString();
        while((*writer++ = *reader++)) ;
        return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x2ffc
leaq 0x1(%rax), %rdi
callq 0x1030
movq %rax, (%rbx)
movq (%r14), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
testb %sil, %sil
jne 0x30a8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq