LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rax
movq %rdi, %rsi
xorl %r14d, %r14d
testq %rcx, %rcx
setne %r13b
je 0x25c9
movq %rcx, %rbp
decq %rax
movq %rax, 0x10(%rsp)
movl $0x1, %r12d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %eax, %eax
xorl %r11d, %r11d
movsbl (%rdx,%rax), %eax
leal -0x30(%rax), %edi
leal -0x30(%rax), %r10d
cmpb $0xa, %dil
cmovael %ebx, %r10d
leal -0x61(%rax), %r8d
leal -0x57(%rax), %edi
cmpb $0x6, %r8b
cmovael %r10d, %edi
leal -0x41(%rax), %r8d
movl %eax, %r10d
addl $-0x37, %r10d
cmpb $0x6, %r8b
cmovael %edi, %r10d
cmpl $-0x1, %r10d
je 0x257f
cmpq 0x10(%rsp), %r11
jne 0x259c
xorl %r15d, %r15d
leaq 0x2b17(%rip), %rdi      # 0x5065
xorl %eax, %eax
movq %r14, (%rsp)
movq %rsi, %r14
movq %rdx, %rbx
movq %r11, 0x8(%rsp)
callq 0x2040
movq 0x8(%rsp), %r11
movq %rbx, %rdx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rsi
movq (%rsp), %r14
movb $0x0, (%rsi,%r11)
jmp 0x25af
testl %r14d, %r14d
je 0x25a3
xorl %edi, %edi
cmpb $0x78, %al
sete %dil
subq %rdi, %r11
xorl %edi, %edi
cmpb $0x58, %al
sete %dil
subq %rdi, %r11
jmp 0x25a3
movb %al, (%rsi,%r11)
incq %r11
xorl %r14d, %r14d
cmpb $0x30, %al
sete %r14b
movb $0x1, %r15b
testb %r15b, %r15b
je 0x25cc
movl %r12d, %eax
incl %r12d
cmpq %rbp, %rax
setb %r13b
jb 0x2502
jmp 0x25cc
xorl %r11d, %r11d
movq $-0x1, %rax
testb $0x1, %r13b
jne 0x25e1
movb $0x0, (%rsi,%r11)
movq %r11, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x1c0f(%rip), %r15      # 0x544a
movq %r15, %rdx
callq 0x3882
leaq 0x4(%r14), %rsi
leaq 0x1a09(%rip), %r12      # 0x5257
movq %r12, %rdi
movq %r15, %rdx
callq 0x3882
leaq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x3882
addq $0xc, %r14
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3882
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x1bb5(%rip), %rdi      # 0x5450
xorl %eax, %eax
callq 0x2040
leaq 0x1ba3(%rip), %r15      # 0x544c
leaq 0x19a7(%rip), %r12      # 0x5257
xorl %r13d, %r13d
movzbl (%r14,%r13), %esi
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2040
incq %r13
cmpq $0x3, %r13
jne 0x38b3
movzbl 0x3(%r14), %esi
leaq 0x1786(%rip), %rdi      # 0x5060
xorl %eax, %eax
callq 0x2040
leaq 0x1b68(%rip), %rdi      # 0x5450
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2040
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movb $0x0, 0x10(%rdx)
leaq 0x11(%rdx), %rax
xorl %ecx, %ecx
movabsq $0x2800000400000000, %r8 # imm = 0x2800000400000000
movb (%rsi,%rcx), %r9b
movb %r9b, 0x1012(%rdx,%rcx)
cmpb $0x0, (%rdi,%rcx)
je 0x397d
movzbl 0x10(%rdx), %r9d
leal 0x1(%r9), %r10d
movb %r10b, 0x10(%rdx)
movb %cl, (%rdx,%r9)
movl $0x33, %r10d
xorl %r9d, %r9d
movq %rcx, %r11
shlq $0x8, %r11
addq %rax, %r11
cmpl $0x3d, %r10d
ja 0x3958
movl %r10d, %ebx
btq %rbx, %r8
jb 0x396d
movb 0x1012(%rdx,%rcx), %bl
xorb %r10b, %bl
movzbl %r9b, %r14d
incb %r9b
movb %bl, (%r14,%r11)
incl %r10d
cmpl $0x7f, %r10d
jne 0x3949
movb %r9b, 0x1011(%rdx)
incq %rcx
cmpq $0x10, %rcx
jne 0x3913
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rsp), %r15
movq 0x40(%rsp), %rax
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x1040(%rdi)
movq $0x0, 0x1050(%rdi)
vmovups (%rdx), %xmm0
vmovaps %xmm0, (%rsp)
vmovups (%rsi), %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 0x1048(%rdi), %rsi
cmpq 0x1050(%rdi), %rsi
je 0x3a33
vmovaps (%rsp), %xmm0
vmovups %xmm0, (%rsi)
addq $0x10, 0x1048(%rbx)
jmp 0x3a45
leaq 0x1040(%rbx), %r12
movq %rsp, %rdx
movq %r12, %rdi
callq 0x3c3e
leaq 0x9(%rbx), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x38fc
movzbl 0x19(%rbx), %eax
shll $0x3, %eax
movl %eax, 0x102c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r12), %rdi
testq %rdi, %rdi
je 0x3a7e
callq 0x2130
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $0x0, (%rdi)
movq 0x1040(%rdi), %r14
cmpq 0x1048(%rdi), %r14
je 0x3b94
movq %rdi, %rbx
leaq 0x9(%rdi), %rax
movq %rax, 0x1040(%rsp)
leaq 0x1058(%rdi), %rax
movq %rax, 0x1038(%rsp)
leaq 0x1068(%rdi), %rax
movq %rax, 0x1030(%rsp)
leaq 0x1088(%rdi), %rbp
leaq 0x1078(%rdi), %r15
leaq 0x8(%rdi), %r13
leaq 0x1050(%rsp), %r12
movl $0x1022, %edx           # imm = 0x1022
movq %r12, %rdi
movq 0x1040(%rsp), %rsi
callq 0x2100
movl $0x204, %ecx            # imm = 0x204
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movzwl 0x2070(%rsp), %eax
movw %ax, 0x1020(%rsp)
movq %r13, 0x1028(%rsp)
movq %r14, %rdi
movq 0x1038(%rsp), %rsi
movq 0x1030(%rsp), %rdx
movq %rbp, %rcx
movq %r15, %r8
leaq 0x1048(%rsp), %r9
callq 0x3d76
movq 0x1048(%rsp), %rax
addq %rax, (%rbx)
cmpb $0x1, 0x8(%rbx)
je 0x3b87
cmpb $0x0, 0x35c0(%rip)      # 0x7132
jne 0x3b94
addq $0x10, %r14
cmpq 0x1048(%rbx), %r14
jne 0x3af9
jmp 0x3b94
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32c0
leaq 0x48(%rsp), %rdi
movss 0x2584(%rip), %xmm0     # 0x5018
movss 0x2580(%rip), %xmm1     # 0x501c
movss 0x257c(%rip), %xmm2     # 0x5020
movq %rbx, %rsi
callq 0x3674
movabsq $0x4000000041400000, %rax # imm = 0x4000000041400000
leaq 0x48(%rsp), %rdi
movq %rax, 0x14(%rdi)
movl $0x40400000, 0x1c(%rdi) # imm = 0x40400000
movabsq $0x3f80000000000000, %rax # imm = 0x3F80000000000000
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movl $0x0, 0x8(%rsi)
callq 0x385e
xorl %eax, %eax
leaq 0x20(%rsp), %rdi
movq %rax, 0x8(%rdi)
leaq 0x41b2(%rip), %rcx      # 0x6ca8
addq $0x10, %rcx
movq %rcx, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rax, 0x20(%rdi)
callq 0x23fc
leaq 0xc(%rsp), %rdi
movl $0x64, (%rdi)
leaq 0x20(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x44fc
leaq 0x20(%rsp), %rdi
callq 0x2b6e
leaq 0x10(%rsp), %rdi
callq 0x335c
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
jmp 0x2b48
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2b6e
jmp 0x2b5c
jmp 0x2b59
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x335c
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
subq $0x20, %rsp
leaq 0x5508(%rip), %rbx      # 0x84d8
movq %rbx, %rdi
callq 0x2bde
movss 0x6884(%rip), %xmm2     # 0x9864
movss 0x6878(%rip), %xmm1     # 0x9860
subss %xmm1, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
movaps %xmm2, (%rsp)
movq %rbx, %rdi
callq 0x2bde
movss 0x685c(%rip), %xmm2     # 0x9864
movss 0x6850(%rip), %xmm1     # 0x9860
subss %xmm1, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
movaps (%rsp), %xmm3
addss %xmm3, %xmm3
addss %xmm2, %xmm2
movss 0x2078(%rip), %xmm0     # 0x50a8
addss %xmm0, %xmm3
addss %xmm0, %xmm2
movaps %xmm2, %xmm1
mulss %xmm2, %xmm1
movaps %xmm3, (%rsp)
movaps %xmm3, %xmm0
mulss %xmm3, %xmm0
addss %xmm1, %xmm0
ucomiss 0x2057(%rip), %xmm0     # 0x50ac
jb 0x305d
sqrtss %xmm0, %xmm0
jmp 0x306c
movaps %xmm2, 0x10(%rsp)
callq 0x2250
movaps 0x10(%rsp), %xmm2
ucomiss 0x1f9d(%rip), %xmm0     # 0x5010
ja 0x2fd0
movaps (%rsp), %xmm0
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
xorps %xmm1, %xmm1
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
subq $0x30, %rsp
leaq 0x5442(%rip), %rbx      # 0x84d8
movq %rbx, %rdi
callq 0x2bde
movss 0x67be(%rip), %xmm2     # 0x9864
movss 0x67b2(%rip), %xmm1     # 0x9860
subss %xmm1, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
movaps %xmm2, 0x20(%rsp)
movq %rbx, %rdi
callq 0x2bde
movss 0x6795(%rip), %xmm2     # 0x9864
movss 0x6789(%rip), %xmm1     # 0x9860
subss %xmm1, %xmm2
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
movaps %xmm2, 0x10(%rsp)
movq %rbx, %rdi
callq 0x2bde
movss 0x676c(%rip), %xmm1     # 0x9864
movss 0x6760(%rip), %xmm2     # 0x9860
subss %xmm2, %xmm1
mulss %xmm0, %xmm1
addss %xmm2, %xmm1
movaps 0x20(%rsp), %xmm2
addss %xmm2, %xmm2
movaps 0x10(%rsp), %xmm3
addss %xmm3, %xmm3
addss %xmm1, %xmm1
movss 0x1f7e(%rip), %xmm0     # 0x50a8
addss %xmm0, %xmm2
addss %xmm0, %xmm3
addss %xmm0, %xmm1
movaps %xmm3, 0x10(%rsp)
movaps %xmm3, %xmm0
mulss %xmm3, %xmm0
movaps %xmm2, 0x20(%rsp)
mulss %xmm2, %xmm2
addss %xmm0, %xmm2
movaps %xmm1, %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
ucomiss 0x1f4b(%rip), %xmm0     # 0x50ac
jb 0x3169
sqrtss %xmm0, %xmm0
jmp 0x317a
movss %xmm1, 0xc(%rsp)
callq 0x2250
movss 0xc(%rsp), %xmm1
ucomiss 0x1e8f(%rip), %xmm0     # 0x5010
ja 0x3096
movaps 0x20(%rsp), %xmm0
unpcklps 0x10(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movslq %edx, %r15
leaq (,%r15,8), %rdi
testl %r15d, %r15d
movq $-0x1, %r12
cmovsq %r12, %rdi
callq 0x2030
movq %rax, 0x8(%r14)
testl %r15d, %r15d
jle 0x334d
movslq %ebx, %rax
movl $0xc, %ecx
mulq %rcx
movq %rax, %r15
cmovoq %r12, %r15
movl %ebx, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r12
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x2030
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%rbp,8)
testl %ebx, %ebx
jle 0x3345
movq 0x8(%r14), %rax
movq (%rax,%rbp,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20c0
incq %rbp
cmpq %rbp, %r13
jne 0x331f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x4(%rdi)
jle 0x3465
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorps %xmm1, %xmm1
cmpl $0x0, (%rbx)
jle 0x344c
movl $0x8, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %r13
movss -0x8(%r13,%r15), %xmm0
ucomiss %xmm1, %xmm0
jb 0x33ec
sqrtss %xmm0, %xmm0
jmp 0x33f4
callq 0x2250
xorps %xmm1, %xmm1
movss %xmm0, -0x8(%r13,%r15)
movss -0x4(%r13,%r15), %xmm0
ucomiss %xmm1, %xmm0
jb 0x340d
sqrtss %xmm0, %xmm0
jmp 0x3415
callq 0x2250
xorps %xmm1, %xmm1
movss %xmm0, -0x4(%r13,%r15)
movss (%r13,%r15), %xmm0
ucomiss %xmm1, %xmm0
jb 0x342e
sqrtss %xmm0, %xmm0
jmp 0x3436
callq 0x2250
xorps %xmm1, %xmm1
movss %xmm0, (%r13,%r15)
incq %r12
movslq (%rbx), %rax
addq $0xc, %r15
cmpq %rax, %r12
jl 0x33d2
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x33c0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c5e(%rip), %rsi      # 0x50ec
movq %r14, %rdi
movl $0x10, %edx
callq 0x2050
leaq 0x1c54(%rip), %rsi      # 0x50f6
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x2160
movl (%rbx), %esi
leaq 0x8(%rsp), %rdi
callq 0x2210
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2160
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2210
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2160
leaq 0x1c01(%rip), %rsi      # 0x50fa
movl $0x4, %edx
movq %rax, %rdi
callq 0x2160
cmpl $0x0, 0x4(%rbx)
jle 0x360a
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %r15
cmpl $0x0, (%rbx)
jle 0x35e5
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rax
movss (%rax,%r13), %xmm0
mulss 0x1ba7(%rip), %xmm0     # 0x50e8
cvttss2si %xmm0, %esi
movq %r14, %rdi
callq 0x2210
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq 0x8(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movss 0x4(%rcx,%r13), %xmm0
mulss 0x1b6f(%rip), %xmm0     # 0x50e8
cvttss2si %xmm0, %esi
movq %rax, %rdi
callq 0x2210
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
movq 0x8(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movss 0x8(%rcx,%r13), %xmm0
mulss 0x1b37(%rip), %xmm0     # 0x50e8
cvttss2si %xmm0, %esi
movq %rax, %rdi
callq 0x2210
movb $0x20, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2160
incq %rbp
movslq (%rbx), %rax
addq $0xc, %r13
cmpq %rax, %rbp
jl 0x352b
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0x351d
leaq 0x8(%rsp), %rdi
callq 0x21a0
movq 0x39c5(%rip), %rax      # 0x6fe0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x2100
leaq 0x100(%rsp), %rdi
callq 0x2070
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x365c
jmp 0x365c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2230
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movss %xmm1, 0x4(%rsp)
movss %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2fc4
movss 0xc(%r14), %xmm1
movaps %xmm1, %xmm5
mulss %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss %xmm1, %xmm0
movss 0x20(%r14), %xmm7
movaps %xmm7, %xmm3
mulss %xmm5, %xmm3
movss 0x24(%r14), %xmm6
movaps %xmm6, %xmm8
mulss %xmm5, %xmm8
movss 0x28(%r14), %xmm9
mulss %xmm9, %xmm5
movss 0x2c(%r14), %xmm1
movaps %xmm0, %xmm2
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
movss 0x30(%r14), %xmm3
movaps %xmm0, %xmm4
mulss %xmm3, %xmm4
addss %xmm8, %xmm4
movss 0x34(%r14), %xmm10
mulss %xmm10, %xmm0
addss %xmm5, %xmm0
movq (%r14), %rax
xorps %xmm5, %xmm5
cvtsi2ssl (%rax), %xmm5
movss 0x1891(%rip), %xmm8     # 0x5014
mulss %xmm8, %xmm5
movss (%rsp), %xmm12
subss %xmm5, %xmm12
movss 0x8(%r14), %xmm11
divss %xmm11, %xmm12
xorps %xmm5, %xmm5
cvtsi2ssl 0x4(%rax), %xmm5
mulss %xmm8, %xmm5
subss 0x4(%rsp), %xmm5
divss %xmm11, %xmm5
movss 0x14(%r14), %xmm8
addss %xmm2, %xmm8
movss 0x18(%r14), %xmm11
addss %xmm4, %xmm11
unpcklps %xmm11, %xmm8           # xmm8 = xmm8[0],xmm11[0],xmm8[1],xmm11[1]
movss 0x1c(%r14), %xmm11
mulss %xmm12, %xmm7
mulss %xmm12, %xmm6
mulss %xmm9, %xmm12
mulss %xmm5, %xmm1
addss %xmm7, %xmm1
mulss %xmm5, %xmm3
addss %xmm6, %xmm3
mulss %xmm10, %xmm5
addss %xmm12, %xmm5
subss 0x38(%r14), %xmm1
subss 0x3c(%r14), %xmm3
subss 0x40(%r14), %xmm5
addss %xmm0, %xmm11
movss 0x17f2(%rip), %xmm6     # 0x5010
divss 0x10(%r14), %xmm6
mulss %xmm6, %xmm2
mulss %xmm6, %xmm4
mulss %xmm0, %xmm6
subss %xmm6, %xmm5
subss %xmm2, %xmm1
subss %xmm4, %xmm3
unpcklps %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movlps %xmm8, (%rbx)
movss %xmm11, 0x8(%rbx)
movlps %xmm1, 0xc(%rbx)
movss %xmm5, 0x14(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movss %xmm0, 0xc(%rsp)
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
cmpq %r12, %r15
je 0x3c5e
movq %rdx, %rbx
movq %rsi, %r14
xorl %ebp, %ebp
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 0x3c4d
movss (%rbx), %xmm0
movss 0x8(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3c53
movb $0x1, %bpl
movaps %xmm0, %xmm1
jmp 0x3c53
movss 0x8(%rsp), %xmm1
addq $0x8, %r15
cmpq %r12, %r15
jne 0x3c17
jmp 0x3c60
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x10(%rdi), %eax
movl %eax, 0x8(%rcx)
movq 0x8(%rdi), %rax
movq %rax, (%rcx)
movss 0x14a4(%rip), %xmm0     # 0x514c
movss 0x10(%rdx), %xmm1
mulss %xmm0, %xmm1
movss 0x14(%rdx), %xmm2
mulss %xmm0, %xmm2
mulss 0x18(%rdx), %xmm0
addss 0x4(%rdx), %xmm1
movq %r8, %r14
addss 0x8(%rdx), %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
addss 0xc(%rdx), %xmm0
movlps %xmm1, (%r8)
movss %xmm0, 0x8(%r8)
callq 0x308a
movss 0x10(%rbx), %xmm2
addss %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
addss 0x14(%rbx), %xmm0
addss 0x18(%rbx), %xmm1
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movlps %xmm2, 0xc(%r14)
movss %xmm1, 0x14(%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rdx, %rbx
movq %rdi, %r15
movl 0x10(%rdi), %eax
movl %eax, 0x8(%rcx)
movq 0x8(%rdi), %rax
movq %rax, (%rcx)
movss 0x1405(%rip), %xmm0     # 0x514c
movss 0x10(%rdx), %xmm1
mulss %xmm0, %xmm1
movss 0x14(%rdx), %xmm2
mulss %xmm0, %xmm2
mulss 0x18(%rdx), %xmm0
addss 0x4(%rdx), %xmm1
addss 0x8(%rdx), %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
addss 0xc(%rdx), %xmm0
movlps %xmm1, (%r8)
movss %xmm0, 0x8(%r8)
movss 0xc(%rsi), %xmm4
movss 0x10(%rsi), %xmm3
movss 0x10(%rdx), %xmm0
movss 0x14(%rdx), %xmm1
movaps %xmm3, %xmm2
movaps %xmm3, %xmm5
mulss %xmm1, %xmm2
movaps %xmm4, %xmm3
movaps %xmm4, %xmm6
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
movss 0x14(%rsi), %xmm7
movss 0x18(%rdx), %xmm2
movaps %xmm7, %xmm4
mulss %xmm2, %xmm4
addss %xmm3, %xmm4
mulss %xmm4, %xmm0
mulss %xmm4, %xmm1
mulss %xmm2, %xmm4
addss %xmm0, %xmm0
addss %xmm1, %xmm1
addss %xmm4, %xmm4
subss %xmm0, %xmm6
movss %xmm6, 0x8(%rsp)
subss %xmm1, %xmm5
movss %xmm5, 0xc(%rsp)
subss %xmm4, %xmm7
movss %xmm7, 0x4(%rsp)
callq 0x308a
movss 0x14(%r15), %xmm2
movaps %xmm2, %xmm3
mulss %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss %xmm2, %xmm0
mulss %xmm2, %xmm1
addss 0x4(%rsp), %xmm1
addss 0x8(%rsp), %xmm3
addss 0xc(%rsp), %xmm0
unpcklps %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
movlps %xmm3, 0xc(%r14)
movss %xmm1, 0x14(%r14)
movss 0xc(%r14), %xmm0
movss 0x10(%r14), %xmm2
mulss 0x14(%rbx), %xmm2
mulss 0x10(%rbx), %xmm0
addss %xmm2, %xmm0
mulss 0x18(%rbx), %xmm1
addss %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
seta %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rdx, %rbx
movaps %xmm0, %xmm10
movq %rsi, %r14
movss (%rdi), %xmm6
movss 0x4(%rdi), %xmm8
movss 0x8(%rdi), %xmm7
movaps %xmm8, %xmm0
mulss %xmm8, %xmm0
movaps %xmm6, %xmm1
mulss %xmm6, %xmm1
addss %xmm0, %xmm1
movaps %xmm7, %xmm0
mulss %xmm7, %xmm0
addss %xmm1, %xmm0
xorps %xmm11, %xmm11
ucomiss %xmm11, %xmm0
jb 0x4241
sqrtss %xmm0, %xmm0
jmp 0x427a
movaps %xmm6, 0x20(%rsp)
movss %xmm7, 0xc(%rsp)
movaps %xmm8, 0x10(%rsp)
movss %xmm10, 0x8(%rsp)
callq 0x2250
xorps %xmm11, %xmm11
movss 0x8(%rsp), %xmm10
movaps 0x10(%rsp), %xmm8
movss 0xc(%rsp), %xmm7
movaps 0x20(%rsp), %xmm6
movss 0xd8d(%rip), %xmm9      # 0x5010
movaps %xmm9, %xmm1
divss %xmm0, %xmm1
mulss %xmm1, %xmm6
mulss %xmm1, %xmm8
mulss %xmm1, %xmm7
movss (%r14), %xmm1
movss 0x4(%r14), %xmm0
movaps %xmm8, %xmm2
mulss %xmm0, %xmm2
movaps %xmm6, %xmm4
mulss %xmm1, %xmm4
addss %xmm2, %xmm4
movss 0x8(%r14), %xmm2
movaps %xmm7, %xmm3
mulss %xmm2, %xmm3
addss %xmm4, %xmm3
movaps %xmm3, %xmm4
mulss %xmm3, %xmm4
movaps %xmm9, %xmm5
subss %xmm4, %xmm5
movaps %xmm10, %xmm4
mulss %xmm10, %xmm4
mulss %xmm5, %xmm4
subss %xmm4, %xmm9
ucomiss %xmm11, %xmm9
jbe 0x4398
mulss %xmm3, %xmm1
mulss %xmm3, %xmm0
mulss %xmm3, %xmm2
subss %xmm1, %xmm6
subss %xmm0, %xmm8
subss %xmm2, %xmm7
mulss %xmm10, %xmm6
mulss %xmm10, %xmm8
mulss %xmm10, %xmm7
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm9
jb 0x432d
xorps %xmm0, %xmm0
sqrtss %xmm9, %xmm0
jmp 0x4366
movaps %xmm9, %xmm0
movaps %xmm6, 0x20(%rsp)
movss %xmm7, 0xc(%rsp)
movaps %xmm8, 0x10(%rsp)
movss %xmm9, 0x8(%rsp)
callq 0x2250
movss 0x8(%rsp), %xmm9
movaps 0x10(%rsp), %xmm8
movss 0xc(%rsp), %xmm7
movaps 0x20(%rsp), %xmm6
movss (%r14), %xmm1
mulss %xmm0, %xmm1
movss 0x4(%r14), %xmm2
mulss %xmm0, %xmm2
mulss 0x8(%r14), %xmm0
subss %xmm0, %xmm7
subss %xmm1, %xmm6
subss %xmm2, %xmm8
unpcklps %xmm8, %xmm6            # xmm6 = xmm6[0],xmm8[0],xmm6[1],xmm8[1]
movlps %xmm6, (%rbx)
movss %xmm7, 0x8(%rbx)
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm9
seta %al
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdbc(%rip), %xmm1      # 0x519c
xorps %xmm0, %xmm0
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x4459
leaq 0x30(%rsp), %rdx
movq 0x20(%rdx), %rdi
movq (%rdi), %rax
leaq 0xc(%rsp), %rcx
leaq 0x18(%rsp), %r8
movq %r12, %rsi
callq *0x10(%rax)
xorps %xmm0, %xmm0
cmpl $0x1d, %ebx
jg 0x44f7
testb %al, %al
xorps %xmm1, %xmm1
je 0x44eb
incl %ebx
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x43b4
movaps %xmm0, %xmm2
movss 0xc(%rsp), %xmm0
mulss %xmm2, %xmm0
shufps $0x55, %xmm2, %xmm2     # xmm2 = xmm2[1,1,1,1]
mulss 0x10(%rsp), %xmm2
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
mulss 0x14(%rsp), %xmm1
jmp 0x44eb
movss 0xc(%r12), %xmm1
movss 0x10(%r12), %xmm3
movss 0x14(%r12), %xmm0
movaps %xmm3, %xmm2
mulss %xmm3, %xmm2
mulss %xmm1, %xmm1
addss %xmm2, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
ucomiss 0xc20(%rip), %xmm0      # 0x50ac
jb 0x4494
sqrtss %xmm0, %xmm0
jmp 0x44a5
movss %xmm3, 0x8(%rsp)
callq 0x2250
movss 0x8(%rsp), %xmm3
movss 0xb63(%rip), %xmm1      # 0x5010
movaps %xmm1, %xmm2
divss %xmm0, %xmm2
mulss %xmm2, %xmm3
addss %xmm1, %xmm3
movss 0xb50(%rip), %xmm0      # 0x5014
mulss %xmm0, %xmm3
subss %xmm3, %xmm1
mulss %xmm3, %xmm0
movss 0xcc8(%rip), %xmm2      # 0x51a0
mulss %xmm3, %xmm2
addss %xmm1, %xmm0
addss %xmm1, %xmm2
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
addss %xmm3, %xmm1
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorps %xmm1, %xmm1
jmp 0x44eb
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpq $0x0, 0x8(%rdi)
je 0x2a1d
xorl %eax, %eax
movq (%rdi), %rcx
movb (%rcx,%rax), %dl
leal -0x41(%rdx), %esi
cmpb $0x19, %sil
ja 0x2a14
orb $0x20, %dl
movb %dl, (%rcx,%rax)
incq %rax
cmpq 0x8(%rdi), %rax
jb 0x29ff
retq
// File: /workspace/github_cpp_makefile_star2_O1/alibakhtiar[P]ExampleHTTPServer/example.cc
// Function: main
int main(int argc, char* argv[])
{
	Server server;

	server.ip = "0.0.0.0";
	server.port = 5000;

	if (argc >= 2) {
		server.port = std::atoi(argv[1]);
	}

	server.onRequest([](Request *req, Response *res) {
		res->header("Content-Type", "text/plain");
		res->header("Server", "ExampleHTTPServer");
		res->header("Cache-Control", "no-cache, no-store, must-revalidate");

		if (req->url == "/" || req->url == "/index.cpp") {
			res->body = "Your Request:\n";

			res->body += "method: ";
			res->body += req->method;
			res->body += "\n";

			res->body += "http version: ";
			res->body += std::to_string(req->httpMajorVersion);
			res->body += ".";
			res->body += std::to_string(req->httpMinorVersion);
			res->body += "\n";

			res->body += "url: ";
			res->body += req->url;
			res->body += "\n";

			if (req->queryString != "") {
				res->body += "query string: ";
				res->body += req->queryString;
				res->body += "\n";
			}

			res->body += "headers:\n";
			for (auto const &h : req->headers) {
				res->body += h.first;
				res->body += ": ";
				res->body += h.second;
				res->body += "\n";
			}
		}
		else {
			res->statusCode = 404;
			res->errorPage();
		}

		res->send();

		return true;
	});

	bool rc = createServer(&server);
	if (rc == false)
		return 1;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movl %edi, %ebp
leaq 0x4f4f(%rip), %r12      # 0x7d50
leaq 0x28(%rsp), %rdi
movq %r12, -0x8(%rdi)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movl $0x2e302e30, (%r15)     # imm = 0x2E302E30
movl $0x302e302e, 0x3(%r15)  # imm = 0x302E302E
leaq 0x2381(%rip), %rcx      # 0x51aa
movq $0x7, -0x8(%r15)
movb $0x0, 0x7(%r15)
movl $0x1388, 0x10(%r15)     # imm = 0x1388
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x28(%r15)
movl $0x7, %edx
movl $0x7, %r8d
xorl %esi, %esi
callq 0x2270
leaq 0x50(%rsp), %rbx
movl $0x1388, -0x8(%rbx)     # imm = 0x1388
cmpl $0x2, %ebp
jl 0x2e7b
movq 0x8(%r14), %rdi
callq 0x2280
movl %eax, 0x48(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0xbd(%rip), %rax        # 0x2f48
movq %rax, 0x18(%rsi)
leaq 0x70a(%rip), %rax       # 0x35a0
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x45a8
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2eb9
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x20(%rsp), %rdi
callq 0x2a1e
movq %r12, 0x20(%rsp)
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x2edf
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ef6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21d0
movl $0x1, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f2a
jmp 0x2f2a
jmp 0x2f32
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x2f35
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x2f35
movq %rax, %rdi
callq 0x37e9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x36ea
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4590(%rip), %rax      # 0x7cd0
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movq 0x20(%rdi), %rcx
movb %al, (%rcx)
movq %rax, 0x48(%rdi)
movq 0x40(%rdi), %rcx
movb %al, (%rcx)
movq %rax, 0x68(%rdi)
movq 0x60(%rdi), %rcx
movb %al, (%rcx)
leaq 0x88(%rdi), %r14
movq %r14, %rdi
callq 0x37f4
movq %r14, %rdi
callq 0x38a0
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x3792
movq (%rax), %rsi
incq %rsi
callq 0x21d0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x37aa
movq (%rax), %rsi
incq %rsi
callq 0x21d0
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x37c9
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/alibakhtiar[P]ExampleHTTPServer/./HttpServer.hh
// Function: SimpleHttpServer::Response::write(char const*, unsigned long)
static ssize_t sendBytes(int sock, const char *buffer, size_t length)
{
	ssize_t n = 0;
	const char *p = buffer;

	while (length > 0) {
		n = send(sock, p, length, 0);

		if (n < 1)
			break;

		p += n;
		length -= n;
	}

	return n;
}

// Assembly:
testq %rdx, %rdx
je 0x407f
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl 0x8(%rdi), %ebp
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2120
testq %rax, %rax
jle 0x407a
addq %rax, %r14
subq %rax, %rbx
jne 0x405e
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x137b
movq 0x8(%rsi), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x1160
testq %rax, %rax
jle 0x1393
movq %rax, %rbx
callq 0x139c
decq %rbx
jne 0x136f
jmp 0x1393
movq 0x5c56(%rip), %rdi      # 0x6fd8
leaq 0x2c7b(%rip), %rsi      # 0x4004
movl $0x25, %edx
callq 0x1120
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpb $0x0, (%rsi)
je 0x2b23
xorl %eax, %eax
leaq 0x1(%rax), %rsi
cmpb $0x0, 0x1(%r14,%rax)
movq %rsi, %rax
jne 0x2b12
jmp 0x2b25
xorl %esi, %esi
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
cmpq %rax, %rsi
jl 0x2b3d
addq %rsi, %rsi
movq %rbx, %rdi
callq 0x2b68
movb (%r14), %al
testb %al, %al
je 0x2b5f
incq %r14
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb %al, (%rcx)
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x2b47
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r15
movq 0x8(%rdi), %r13
subq %r15, %rax
leaq (%rax,%rsi), %r14
leaq (%rax,%rsi), %rdi
incq %rdi
callq 0x1030
movq %rax, %r12
testq %r14, %r14
je 0x2bac
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x10b0
cmpq %r13, %r15
je 0x2bc6
movq %r15, %rax
movq %r12, %rcx
movb (%rax), %dl
incq %rax
movb %dl, (%rcx)
incq %rcx
cmpq %r13, %rax
jne 0x2bb7
testq %r15, %r15
je 0x2bd3
movq %r15, %rdi
callq 0x1140
addq %r12, %r14
subq %r15, %r13
movq %r12, (%rbx)
addq %r12, %r13
movq %r13, 0x8(%rbx)
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c22
subq (%rbx), %rsi
addq %rsi, %rsi
movq %rbx, %rdi
callq 0x2b68
cmpl $0x3, %r14d
ja 0x2c6f
movb $0x20, %al
movl %r14d, %ecx
leaq 0x14e4(%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 0x2c61
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb $0x2e, (%rcx)
jmp 0x2c61
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_O1/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 0x1050
leal 0x3(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $-0x4, %ecx
subl %ecx, %eax
cmpl $0x3, %eax
je 0x2ce6
cmpl $0x2, %eax
je 0x2cb1
cmpl $0x1, %eax
jne 0x2d37
movq %rbx, %rdi
xorl %esi, %esi
jmp 0x2cdf
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2bf6
callq 0x1050
cltq
cqto
idivq 0x18(%r14)
movq (%r14), %rax
movq (%rax,%rdx,8), %rsi
movq %rbx, %rdi
callq 0x2afe
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2bf6
jmp 0x2d1b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2bf6
callq 0x1050
cltq
cqto
idivq 0x18(%r14)
movq (%r14), %rax
movq (%rax,%rdx,8), %rsi
movq %rbx, %rdi
callq 0x2afe
leaq 0x1415(%rip), %rsi      # 0x4128
movq %rbx, %rdi
callq 0x2afe
callq 0x1050
cltq
cqto
idivq 0x18(%r14)
movq (%r14), %rax
movq (%rax,%rdx,8), %rsi
movq %rbx, %rdi
callq 0x2afe
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1050
cltq
cqto
idivq 0x18(%r14)
movq (%r14), %rax
movq (%rax,%rdx,8), %rsi
movq %rbx, %rdi
callq 0x2afe
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x2c78
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2bf6
movq 0x60(%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2afe
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
callq 0x2bf6
callq 0x1050
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
andl $-0x2, %ecx
subl %ecx, %eax
cmpl $0x1, %eax
je 0x2de5
testl %eax, %eax
jne 0x2df0
callq 0x1050
cltq
cqto
idivq 0x40(%r14)
movq 0x28(%r14), %rax
movq (%rax,%rdx,8), %rsi
movq %rbx, %rdi
callq 0x2afe
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2bf6
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2afe
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jweinst1[P]Pages/src/util/AppStr.cpp
// Function: AppStr::expand()
void AppStr::expand()
{
        size_t oldLen = len();
        size_t newCap = cap() * 2;
        _begin = static_cast<char*>(std::realloc(_begin, newCap));
        _end = _begin + newCap;
        _mark = _begin + oldLen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %r14
subq %rdi, %r14
movq 0x10(%rbx), %r15
subq %rdi, %r15
leaq (%r15,%r15), %rsi
callq 0x11a0
movq %rax, (%rbx)
leaq (%rax,%r15,2), %rcx
movq %rcx, 0x10(%rbx)
addq %rax, %r14
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
cmpb $0x0, (%rax)
je 0x2fbd
movl $0x1, %ecx
leaq 0x1(%rcx), %rdi
cmpb $0x0, (%rax,%rcx)
movq %rdi, %rcx
jne 0x2fae
jmp 0x2fc2
movl $0x1, %edi
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 0x2fcf
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jweinst1[P]Pages/src/util/BlockStr.cpp
// Function: operator<(BlockStr const&, BlockStr const&)
bool operator<(const BlockStr& lhs, const BlockStr& rhs)
{
        long lhsTotal = 0;
        long rhsTotal = 0;
        const char* lhsPtr = lhs.getString();
        const char* rhsPtr = rhs.getString();
        while(*lhsPtr) lhsTotal += *lhsPtr++;
        while(*rhsPtr) rhsTotal += *rhsPtr++;
        return lhsTotal < rhsTotal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movq (%rsi), %rax
movb (%rdx), %sil
testb %sil, %sil
je 0x3012
incq %rdx
xorl %ecx, %ecx
movsbq %sil, %rsi
addq %rsi, %rcx
movb (%rdx), %sil
incq %rdx
testb %sil, %sil
jne 0x2ffe
jmp 0x3014
xorl %ecx, %ecx
movb (%rax), %sil
testb %sil, %sil
je 0x3035
incq %rax
xorl %edx, %edx
movsbq %sil, %rsi
addq %rsi, %rdx
movb (%rax), %sil
incq %rax
testb %sil, %sil
jne 0x3021
jmp 0x3037
xorl %edx, %edx
cmpq %rdx, %rcx
setl %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jweinst1[P]Pages/src/util/BlockStr.cpp
// Function: BlockStr::operator==(BlockStr const&) const
bool BlockStr::operator ==(const BlockStr& other) const
{
        const char* current = _str;
        const char* comp = other.getString();
        while(*comp && *current)
        {
                if((*comp++ != *current++)) return false;
        }
        if(*comp != '\0' || *current != '\0') return false;
        else return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq (%rsi), %rdx
xorl %ecx, %ecx
movb (%rdx,%rcx), %sil
testb %sil, %sil
je 0x3085
movb (%rax,%rcx), %dil
testb %dil, %dil
je 0x307c
incq %rcx
cmpb %dil, %sil
je 0x3060
jmp 0x3081
testb %sil, %sil
je 0x3085
xorl %eax, %eax
jmp 0x308c
cmpb $0x0, (%rax,%rcx)
sete %al
popq %rbp
retq