LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x2098, %rsp           # imm = 0x2098
movq %rdi, 0x2090(%rsp)
movq 0x2090(%rsp), %rdi
movq %rdi, 0x1048(%rsp)
movq $0x0, (%rdi)
addq $0x1040, %rdi           # imm = 0x1040
callq 0x5b70
movq %rax, 0x2088(%rsp)
movq 0x1048(%rsp), %rdi
addq $0x1040, %rdi           # imm = 0x1040
callq 0x59e0
movq %rax, 0x2080(%rsp)
leaq 0x2088(%rsp), %rdi
leaq 0x2080(%rsp), %rsi
callq 0x6110
testb $0x1, %al
jne 0x5244
jmp 0x5378
movq 0x1048(%rsp), %rsi
addq $0x9, %rsi
leaq 0x1050(%rsp), %rdi
movl $0x1022, %edx           # imm = 0x1022
callq 0x2100
leaq 0x2088(%rsp), %rdi
callq 0x6430
movq 0x1048(%rsp), %r9
movq %rax, 0x1038(%rsp)
movq %r9, %rax
addq $0x1058, %rax           # imm = 0x1058
movq %rax, 0x1030(%rsp)
movq %r9, %rdx
addq $0x1068, %rdx           # imm = 0x1068
movq %r9, %rax
addq $0x1088, %rax           # imm = 0x1088
movq %rax, 0x1040(%rsp)
movq %r9, %r8
addq $0x1078, %r8            # imm = 0x1078
addq $0x8, %r9
movq %rsp, %rax
movl $0x204, %ecx            # imm = 0x204
leaq 0x1050(%rsp), %rsi
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq 0x1030(%rsp), %rsi
movq 0x1038(%rsp), %rdi
movq 0x1040(%rsp), %rcx
movw 0x2070(%rsp), %r10w
movw %r10w, 0x1020(%rax)
movq %r9, 0x1028(%rax)
leaq 0x2078(%rsp), %r9
callq 0x6150
movq 0x1048(%rsp), %rax
movq 0x2078(%rsp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
testb $0x1, 0x8(%rax)
je 0x5357
leaq 0x2088(%rsp), %rdi
callq 0x6430
movq %rax, %rcx
movq 0x1048(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, 0x1030(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x1038(%rax)
jmp 0x5378
callq 0x6440
testb $0x1, %al
jne 0x5362
jmp 0x5364
jmp 0x5378
jmp 0x5366
leaq 0x2088(%rsp), %rdi
callq 0x6450
jmp 0x520a
addq $0x2098, %rsp           # imm = 0x2098
retq
// File: cgvwzq[P]aes_bf/src/aes-brute-force.cpp
// Function: aes_brute_force::is_valid_plaintext_padding(unsigned char*, unsigned char*, unsigned char*, unsigned char*)
static
	bool is_valid_plaintext_padding(uint8_t candidate[16], uint8_t plain_mask[16], uint8_t plain[16], uint8_t iv[16])
	{
		for (unsigned int i=0; i < 16; i++)
		{
			uint8_t c = candidate[i] ^ iv[i];
			// only ascii printable
			if (i < 15) // set to 15 for padding
			{
				// if ((c & plain_mask[i]) ^ plain[i])
				if (c <= 0x1f || c >= 0x7f)
				{
					return false;	
				}
				// avoid problematic chars for cookie
				if (c == 0x3b || c == 0x3d || c == 0x22)
				{
					return false;
				}
			}
			else if (c != 0x01)
			{
				return false;
			}
		}
		return true;
	}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
cmpl $0x10, -0x2c(%rsp)
jae 0x6555
movq -0x10(%rsp), %rax
movl -0x2c(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x28(%rsp), %rcx
movl -0x2c(%rsp), %edx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, -0x2d(%rsp)
cmpl $0xf, -0x2c(%rsp)
jae 0x6530
movzbl -0x2d(%rsp), %eax
cmpl $0x1f, %eax
jle 0x6502
movzbl -0x2d(%rsp), %eax
cmpl $0x7f, %eax
jl 0x6509
movb $0x0, -0x1(%rsp)
jmp 0x655a
movzbl -0x2d(%rsp), %eax
cmpl $0x3b, %eax
je 0x6527
movzbl -0x2d(%rsp), %eax
cmpl $0x3d, %eax
je 0x6527
movzbl -0x2d(%rsp), %eax
cmpl $0x22, %eax
jne 0x652e
movb $0x0, -0x1(%rsp)
jmp 0x655a
jmp 0x6543
movzbl -0x2d(%rsp), %eax
cmpl $0x1, %eax
je 0x6541
movb $0x0, -0x1(%rsp)
jmp 0x655a
jmp 0x6543
jmp 0x6545
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x64bc
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movl $0x100, %esi            # imm = 0x100
movl $0x80, %edx
callq 0x4e10
movq -0xc0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movss 0x52d1(%rip), %xmm0     # 0x8040
movss 0x52a1(%rip), %xmm1     # 0x8018
movss 0x52c5(%rip), %xmm2     # 0x8044
callq 0x53b0
jmp 0x2d86
leaq -0x78(%rbp), %rdi
movss 0x52b2(%rip), %xmm0     # 0x8044
movss 0x52ae(%rip), %xmm1     # 0x8048
movss 0x52aa(%rip), %xmm2     # 0x804c
callq 0x2eb0
jmp 0x2da9
movl -0x70(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x4c(%rbp)
leaq -0x84(%rbp), %rdi
movss 0x523e(%rip), %xmm1     # 0x8004
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
callq 0x2eb0
jmp 0x2dd3
leaq -0x60(%rbp), %rdi
leaq -0x84(%rbp), %rsi
callq 0x5840
jmp 0x2de5
leaq -0xb0(%rbp), %rdi
callq 0x30a0
jmp 0x2df3
leaq -0xb0(%rbp), %rdi
callq 0x24d0
jmp 0x2e01
leaq -0xb4(%rbp), %rdi
movl $0x64, %esi
callq 0x30e0
jmp 0x2e14
leaq -0xb4(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x7010
jmp 0x2e2d
movl $0x0, -0x4(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3100
leaq -0x18(%rbp), %rdi
callq 0x4f90
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2e7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3100
leaq -0x18(%rbp), %rdi
callq 0x4f90
movq -0x68(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0xc(%rbp), %rdi
callq 0x47c0
callq 0x2e90
movss %xmm0, -0x94(%rbp)
callq 0x2e90
movaps %xmm0, %xmm1
movss -0x94(%rbp), %xmm0
leaq -0x34(%rbp), %rdi
movq %rdi, -0x90(%rbp)
xorps %xmm2, %xmm2
movss %xmm2, -0x84(%rbp)
callq 0x2eb0
movq -0x90(%rbp), %rdi
movss 0x3b9d(%rip), %xmm0     # 0x8048
callq 0x47d0
movss -0x84(%rbp), %xmm2
movss %xmm1, -0x40(%rbp)
movlpd %xmm0, -0x48(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x54(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movss 0x3b24(%rip), %xmm1     # 0x8004
movaps %xmm1, %xmm0
callq 0x2eb0
movq -0x80(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4830
movss %xmm1, -0x60(%rbp)
movlpd %xmm0, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x48a0
movss 0x3ad8(%rip), %xmm1     # 0x8004
ucomiss %xmm1, %xmm0
ja 0x4464
movl -0x4(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x78(%rbp)
movsd -0x78(%rbp), %xmm0
movss -0x70(%rbp), %xmm1
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0xc(%rbp), %rdi
callq 0x47c0
callq 0x2e90
movss %xmm0, -0x8c(%rbp)
callq 0x2e90
movss %xmm0, -0x90(%rbp)
callq 0x2e90
movss -0x90(%rbp), %xmm1
movaps %xmm0, %xmm2
movss -0x8c(%rbp), %xmm0
leaq -0x34(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2eb0
movq -0x88(%rbp), %rdi
movss 0x3a83(%rip), %xmm0     # 0x8048
callq 0x47d0
movss %xmm1, -0x40(%rbp)
movlpd %xmm0, -0x48(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x54(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movss 0x3a12(%rip), %xmm0     # 0x8004
callq 0x3070
movq -0x80(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4830
movss %xmm1, -0x60(%rbp)
movlpd %xmm0, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x48a0
movss 0x39c9(%rip), %xmm1     # 0x8004
ucomiss %xmm1, %xmm0
ja 0x4574
movl -0x4(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x78(%rbp)
movsd -0x78(%rbp), %xmm0
movss -0x70(%rbp), %xmm1
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movslq -0x10(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4f81
movslq -0xc(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0xc, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x58(%rbp)
callq 0x2030
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x48(%rbp)
cmpq $0x0, %rax
je 0x4ef4
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
imulq $0xc, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x47c0
jmp 0x4edf
movq -0x68(%rbp), %rcx
movq -0x70(%rbp), %rax
addq $0xc, %rax
cmpq %rcx, %rax
movq %rax, -0x60(%rbp)
jne 0x4ed0
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4f71
leaq -0x34(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x3070
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq -0x34(%rbp), %rcx
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4f0f
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2310
jmp 0x4f87
jmp 0x4f73
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4e6c
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22d0
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x50ca
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jge 0x50ba
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
callq 0x2300
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
callq 0x2300
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
callq 0x2300
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5042
jmp 0x50bc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x502b
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movss (%rcx), %xmm2
movss 0x4(%rcx), %xmm3
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm7
movss 0x8(%rcx), %xmm1
movss (%rax), %xmm5
movss 0x4(%rax), %xmm4
movaps %xmm1, %xmm6
mulss %xmm4, %xmm6
movaps %xmm3, %xmm0
mulss %xmm7, %xmm0
subss %xmm6, %xmm0
movaps %xmm2, %xmm6
mulss %xmm7, %xmm6
mulss %xmm5, %xmm1
subss %xmm6, %xmm1
mulss %xmm5, %xmm3
mulss %xmm4, %xmm2
subss %xmm3, %xmm2
leaq -0xc(%rbp), %rdi
callq 0x2eb0
movl -0x4(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movss -0x28(%rbp), %xmm1
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, -0x21(%rbp)
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6170
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x61a0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x61d0
testb $0x1, %al
jne 0x60fb
jmp 0x615f
leaq -0x38(%rbp), %rdi
callq 0x6210
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x612d
jmp 0x6152
movq -0x20(%rbp), %rax
movss (%rax), %xmm1
movss -0x18(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x6150
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movb $0x1, -0x21(%rbp)
jmp 0x6152
jmp 0x6154
leaq -0x38(%rbp), %rdi
callq 0x6230
jmp 0x60e8
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x10(%rcx), %edx
movl %edx, 0x8(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x4, %rax
movq %rax, -0xb0(%rbp)
addq $0x10, %rdi
movss 0x1e06(%rip), %xmm0     # 0x8108
callq 0x47d0
movq -0xb0(%rbp), %rdi
movss %xmm1, -0x50(%rbp)
movlpd %xmm0, -0x58(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x5970
movss %xmm1, -0x60(%rbp)
movlpd %xmm0, -0x68(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xa8(%rbp)
callq 0x4560
movq -0xa8(%rbp), %rdi
movss %xmm1, -0x88(%rbp)
movlpd %xmm0, -0x90(%rbp)
movl -0x88(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x5970
movss %xmm1, -0x98(%rbp)
movlpd %xmm0, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x74(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x28(%rbp), %rax
movq -0x74(%rbp), %rcx
movq %rcx, 0xc(%rax)
movl -0x6c(%rbp), %ecx
movl %ecx, 0x14(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0xf0(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rcx), %edx
movl %edx, 0x8(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x4, %rax
movq %rax, -0xf8(%rbp)
addq $0x10, %rdi
movss 0x1c6f(%rip), %xmm0     # 0x8108
callq 0x47d0
movq -0xf8(%rbp), %rdi
movss %xmm1, -0x58(%rbp)
movlpd %xmm0, -0x60(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x5970
movss %xmm1, -0x68(%rbp)
movlpd %xmm0, -0x70(%rbp)
movl -0x68(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
addq $0xc, %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x6620
movss %xmm1, -0x90(%rbp)
movlpd %xmm0, -0x98(%rbp)
movl -0x90(%rbp), %eax
movl %eax, -0x80(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x4560
movq -0xf0(%rbp), %rax
movss %xmm1, -0xc0(%rbp)
movlpd %xmm0, -0xc8(%rbp)
movl -0xc0(%rbp), %ecx
movl %ecx, -0xb0(%rbp)
movq -0xc8(%rbp), %rcx
movq %rcx, -0xb8(%rbp)
movss 0x14(%rax), %xmm0
leaq -0xb8(%rbp), %rdi
callq 0x47d0
movss %xmm1, -0xd0(%rbp)
movlpd %xmm0, -0xd8(%rbp)
movl -0xd0(%rbp), %eax
movl %eax, -0xa0(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x5970
movss %xmm1, -0xe0(%rbp)
movlpd %xmm0, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0x7c(%rbp)
movl -0xe0(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x30(%rbp), %rax
movq -0x7c(%rbp), %rcx
movq %rcx, 0xc(%rax)
movl -0x74(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq -0x30(%rbp), %rdi
addq $0xc, %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x6000
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x6608
movb $0x1, -0x1(%rbp)
jmp 0x660c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5aa0
movq (%rax), %rcx
movq %rcx, -0x34(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x34(%rbp), %rdi
callq 0x6000
movss %xmm0, -0x44(%rbp)
movss -0x1c(%rbp), %xmm0
mulss -0x1c(%rbp), %xmm0
movss -0x44(%rbp), %xmm1
movss -0x44(%rbp), %xmm2
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm1
movss 0x1482(%rip), %xmm2     # 0x8004
addss %xmm2, %xmm1
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm1, %xmm0
movss 0x1465(%rip), %xmm1     # 0x8004
addss %xmm1, %xmm0
movss %xmm0, -0x48(%rbp)
movss -0x48(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x6cec
movq -0x18(%rbp), %rdi
movss -0x44(%rbp), %xmm0
callq 0x47d0
movss %xmm1, -0x88(%rbp)
movlpd %xmm0, -0x90(%rbp)
movl -0x88(%rbp), %eax
movl %eax, -0x78(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4830
movss %xmm1, -0x98(%rbp)
movlpd %xmm0, -0xa0(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x70(%rbp)
movss -0x1c(%rbp), %xmm0
leaq -0x70(%rbp), %rdi
callq 0x47d0
movss %xmm1, -0xa8(%rbp)
movlpd %xmm0, -0xb0(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xe8(%rbp)
movss -0x48(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2110
movq -0xe8(%rbp), %rdi
cvtsd2ss %xmm0, %xmm0
callq 0x47d0
movss %xmm1, -0xc8(%rbp)
movlpd %xmm0, -0xd0(%rbp)
movl -0xc8(%rbp), %eax
movl %eax, -0xb8(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x4830
movss %xmm1, -0xd8(%rbp)
movlpd %xmm0, -0xe0(%rbp)
movq -0xe0(%rbp), %rax
movq %rax, -0x54(%rbp)
movl -0xd8(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rax
movq -0x54(%rbp), %rcx
movq %rcx, (%rax)
movl -0x4c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x6cf0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x3bd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x34a0
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x3bc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x34a0
movsbl (%rax), %eax
cmpl $0x5a, %eax
jg 0x3bc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x34a0
movsbl (%rax), %ecx
addl $0x20, %ecx
movb %cl, (%rax)
jmp 0x3bc2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3b64
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5080
leaq -0x58(%rbp), %rdi
leaq 0x4f8d(%rip), %rsi      # 0x91ba
callq 0x33a0
jmp 0x4234
movl $0x1388, -0x38(%rbp)    # imm = 0x1388
cmpl $0x2, -0x8(%rbp)
jl 0x4264
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3400
movl %eax, -0x38(%rbp)
jmp 0x4264
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x431e
leaq -0x90(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x91(%rbp), %rsi
callq 0x4330
movq -0xa0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x5110
jmp 0x4290
leaq -0x90(%rbp), %rdi
callq 0x5140
leaq -0x60(%rbp), %rdi
callq 0x3be0
movb %al, -0xa1(%rbp)
jmp 0x42ad
movb -0xa1(%rbp), %al
andb $0x1, %al
movb %al, -0x92(%rbp)
movb -0x92(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x42f8
movl $0x1, -0x4(%rbp)
movl $0x1, -0x98(%rbp)
jmp 0x4309
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x5140
jmp 0x431e
movl $0x0, -0x4(%rbp)
movl $0x1, -0x98(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5160
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x5160
movq -0x68(%rbp), %rdi
callq 0x3440
// File: alibakhtiar[P]ExampleHTTPServer/./HttpServer.hh
// Function: SimpleHttpServer::sendBytes(int, 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x4426
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x3180
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x4409
jmp 0x4426
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x43e3
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x8865(%rip), %rax      # 0xdcb0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x3390
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x3390
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x3390
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x5610
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x5630
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x31b0
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x31b0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x31b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jne 0x137d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1140
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x137b
callq 0x13a0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x135e
jmp 0x1390
movq 0xbc54(%rip), %rdi      # 0xcfd8
leaq 0x6c79(%rip), %rsi      # 0x8004
callq 0x10d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpb $0x0, (%rax)
je 0x644a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6428
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x6940
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jl 0x6477
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
shlq %rsi
callq 0x64c0
jmp 0x6479
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x64aa
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq 0x8(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movb %cl, (%rax)
jmp 0x6479
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x6ad0
movq -0x48(%rbp), %rdi
addq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x6960
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x1030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq -0x18(%rbp), %rsi
movl $0x0, -0x2c(%rbp)
leaq -0x2c(%rbp), %rdx
callq 0x6910
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq 0x8(%rcx), %rax
je 0x6564
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb (%rax), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
jmp 0x6532
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x657e
movq -0x50(%rbp), %rdi
callq 0x1120
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
addq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
addq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x6940
movq %rax, %rcx
movl $0x3, %eax
cmpq %rcx, %rax
jl 0x65f1
movq -0x18(%rbp), %rdi
callq 0x6960
movq -0x18(%rbp), %rdi
movq %rax, %rsi
shlq %rsi
callq 0x64c0
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x6698
movq -0x20(%rbp), %rax
leaq 0x1b0b(%rip), %rcx      # 0x8118
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movb $0x2c, (%rax)
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movb $0x20, (%rax)
jmp 0x6698
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movb $0x2e, (%rax)
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movb $0x20, (%rax)
jmp 0x6698
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movb $0x20, (%rax)
jmp 0x6698
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movb $0xa, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x6980
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x67e3
movq -0x20(%rbp), %rax
leaq 0x1a3c(%rip), %rcx      # 0x8128
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x67e3
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x65b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69a0
movq %rax, %rdi
callq 0x69c0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x6400
jmp 0x67e3
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x65b0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69a0
movq %rax, %rdi
callq 0x69c0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x6400
movq %rax, %rdi
movl $0x1, %esi
callq 0x65b0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69a0
movq %rax, %rdi
callq 0x69c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x6400
jmp 0x67e3
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x65b0
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69a0
movq %rax, %rdi
callq 0x69c0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x6400
movq %rax, %rdi
leaq 0x197b(%rip), %rsi      # 0x8138
callq 0x6400
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69a0
movq %rax, %rdi
callq 0x69c0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x6400
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a20
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x69e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a40
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x66b0
movq %rax, %rdi
xorl %esi, %esi
callq 0x65b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a60
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x69e0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
callq 0x65b0
callq 0x6a80
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x68ad
jmp 0x68a3
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x68e7
jmp 0x68fc
movq -0x10(%rbp), %rdi
callq 0x6aa0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x69e0
movq %rax, %rdi
xorl %esi, %esi
callq 0x65b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6ac0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x69e0
jmp 0x68fc
movq -0x10(%rbp), %rdi
callq 0x6ac0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x69e0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6d10
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x6d30
movq %rax, %rcx
movq -0x20(%rbp), %rax
shlq %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1180
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rcx
addq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq (%rax), %rcx
addq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69c0
movq %rax, %rdi
callq 0x6d50
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %al, (%rcx)
cmpb $0x0, %al
je 0x6f0b
jmp 0x6ee3
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x69c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69c0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6f80
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbq (%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6f5a
jmp 0x6f82
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6fa8
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movsbq (%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x6f82
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setl %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x69c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x29(%rbp)
je 0x7033
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x703c
jmp 0x706c
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %eax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x706a
movb $0x0, -0x1(%rbp)
jmp 0x708e
jmp 0x7018
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x7084
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x708a
movb $0x0, -0x1(%rbp)
jmp 0x708e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: Thilotilo[P]DoaERando/Rom.cpp
// Function: DoaERando::ROM::ReadRom(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ROM::ReadRom(std::string file)
{
    ifstream fin(file, ios::binary);
    if (fin.fail()) throw 0;
    myContents = vector<BYTE>(
        (istreambuf_iterator<char>(fin)),
        (istreambuf_iterator<char>())
        );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x270(%rbp)
leaq -0x218(%rbp), %rdi
movl $0x4, %edx
callq 0x464570
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x468a90
movb %al, -0x262(%rbp)
jmp 0x40471f
movb -0x262(%rbp), %al
testb $0x1, %al
jne 0x40472b
jmp 0x40476a
movl $0x4, %edi
callq 0x41e900
movq %rax, %rdi
movl $0x0, (%rdi)
movq $0x6096e8, %rsi         # imm = 0x6096E8
xorl %eax, %eax
movl %eax, %edx
callq 0x41f950
jmp 0x404842
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x40482a
leaq -0x250(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x404de0
leaq -0x260(%rbp), %rdi
callq 0x404e40
leaq -0x261(%rbp), %rdi
movq %rdi, -0x278(%rbp)
callq 0x404e70
movq -0x278(%rbp), %r9
movq -0x250(%rbp), %rsi
movl -0x248(%rbp), %edx
movq -0x260(%rbp), %rcx
movl -0x258(%rbp), %r8d
leaq -0x240(%rbp), %rdi
callq 0x404e90
jmp 0x4047cc
movq -0x270(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x404f20
leaq -0x240(%rbp), %rdi
callq 0x404f50
leaq -0x261(%rbp), %rdi
callq 0x404fb0
leaq -0x218(%rbp), %rdi
callq 0x4652a0
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x261(%rbp), %rdi
callq 0x404fb0
leaq -0x218(%rbp), %rdi
callq 0x4652a0
movq -0x220(%rbp), %rdi
callq 0x4c9ba0
nopw %cs:(%rax,%rax)
// File: Thilotilo[P]DoaERando/Rom.cpp
// Function: DoaERando::ROM::SwapBytesAtBank(int, int, int)
void ROM::SwapBytesAtBank(int bank, int address1, int address2)
{
    int baseOffset1 = address1 - 0x8000;
    int baseOffset2 = address2 - 0x8000;
    SwapBytes(0x10 + (bank * 0x4000) + baseOffset1,
              0x10 + (bank * 0x4000) + baseOffset2);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x8000, %eax           # imm = 0x8000
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %esi
shll $0xe, %esi
addl $0x10, %esi
addl -0x18(%rbp), %esi
movl -0xc(%rbp), %edx
shll $0xe, %edx
addl $0x10, %edx
addl -0x1c(%rbp), %edx
callq 0x404cb0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Thilotilo[P]DoaERando/Randomizer.cpp
// Function: DoaERando::Randomizer::GetGeneralLocation(unsigned char)
int Randomizer::GetGeneralLocation(BYTE id)
{
    const int BANK_OFFSET = 0x30010 - 0x8000;
    const int GENERAL_ADDRESSES_LSB_START = 0x32610;
    const int GENERAL_ADDRESSES_MSB_START = 0x32710;
    int msb = myRom->ReadByte(GENERAL_ADDRESSES_MSB_START + id);
    int lsb = myRom->ReadByte(GENERAL_ADDRESSES_LSB_START + id);
    int address = (msb << 8) + lsb + BANK_OFFSET;
    return address;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x28010, -0x10(%rbp)   # imm = 0x28010
movl $0x32610, -0x14(%rbp)   # imm = 0x32610
movl $0x32710, -0x18(%rbp)   # imm = 0x32710
movq (%rax), %rdi
movzbl -0x9(%rbp), %esi
addl $0x32710, %esi          # imm = 0x32710
callq 0x404bb0
movb %al, %cl
movq -0x30(%rbp), %rax
movzbl %cl, %ecx
movl %ecx, -0x1c(%rbp)
movq (%rax), %rdi
movzbl -0x9(%rbp), %esi
addl $0x32610, %esi          # imm = 0x32610
callq 0x404bb0
movzbl %al, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
shll $0x8, %eax
addl -0x20(%rbp), %eax
addl $0x28010, %eax          # imm = 0x28010
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop