LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: parseArgs(float*, std::__cxx11::basic_istringstream<char, std::char_traits<char>, std::allocator<char>>*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void parseArgs(float args[], istringstream *iss, int numArgs, string errMessage) {
    string temp;
    int index = 0;
    while (*iss >> temp){
        args[index] = atof(temp.c_str());
        index++;
    }

    if (index != numArgs){
        cerr << errMessage << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x50(%rbp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebx, %ebx
leaq -0x48(%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x39ac
movq -0x48(%rbp), %rdi
callq 0x32a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r12,%rbx,4)
incq %rbx
jmp 0x397b
cmpl %ebx, %r14d
je 0x39f2
movq -0x50(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x1a62d(%rip), %rdi     # 0x1dff0
callq 0x3260
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3160
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3a0b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a1c
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3a38
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: parseArgs(int*, std::__cxx11::basic_istringstream<char, std::char_traits<char>, std::allocator<char>>*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void parseArgs(int args[], istringstream *iss, int numArgs, string errMessage) {
    string temp;
    int index = 0;
    while (*iss >> temp){
        args[index] = atoi(temp.c_str());
        index++;
    }

    if (index != numArgs){
        cerr << errMessage << endl;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x50(%rbp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebx, %ebx
leaq -0x48(%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3aa2
movq -0x48(%rbp), %rdi
callq 0x33b0
movl %eax, (%r12,%rbx,4)
incq %rbx
jmp 0x3a77
cmpl %ebx, %r14d
je 0x3ae8
movq -0x50(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x1a537(%rip), %rdi     # 0x1dff0
callq 0x3260
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3160
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3b01
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b12
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3b2e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Triangle::Triangle(vec3&, vec3&, vec3&, Material&, mat4, vec3&, vec3&, vec3&)
Triangle(vec3 &_v1, vec3 &_v2, vec3 &_v3, Material &_mat, mat4 _transform, 
    vec3 &_normal1, vec3 &_normal2, vec3 &_normal3)
    : Polygon(_transform, _mat) {
        vertex1 = _v1;
        vertex2 = _v2;
        vertex3 = _v3;
        edge1 = vertex3 - vertex1;
        edge2 = vertex2 - vertex1;
    	normal1 = _normal1;
    	normal2 = _normal2;
    	normal3 = _normal3;
    	needInterpolate = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rbp), %r13
movq %r9, %rsi
movq %r8, %rdx
callq 0x7462
leaq 0x170fe(%rip), %rax     # 0x1dc90
movq %rax, (%rbx)
movsd (%r12), %xmm0
movsd %xmm0, 0x1f0(%rbx)
movsd 0x8(%r12), %xmm1
movsd %xmm1, 0x1f8(%rbx)
movsd 0x10(%r12), %xmm2
movsd %xmm2, 0x200(%rbx)
movsd (%r15), %xmm3
movsd %xmm3, 0x208(%rbx)
movsd 0x8(%r15), %xmm4
movsd %xmm4, 0x210(%rbx)
movsd 0x10(%r15), %xmm5
movsd %xmm5, 0x218(%rbx)
movsd (%r14), %xmm6
movsd %xmm6, 0x220(%rbx)
movsd 0x8(%r14), %xmm7
movsd %xmm7, 0x228(%rbx)
movsd 0x10(%r14), %xmm8
movsd %xmm8, 0x230(%rbx)
subsd %xmm0, %xmm6
subsd %xmm1, %xmm7
subsd %xmm2, %xmm8
movsd %xmm6, 0x238(%rbx)
movsd %xmm7, 0x240(%rbx)
movsd %xmm8, 0x248(%rbx)
subsd %xmm0, %xmm3
subsd %xmm1, %xmm4
subsd %xmm2, %xmm5
movsd %xmm3, 0x250(%rbx)
movsd %xmm4, 0x258(%rbx)
movsd %xmm5, 0x260(%rbx)
movsd (%r13), %xmm0
movsd %xmm0, 0x268(%rbx)
movsd 0x8(%r13), %xmm0
movsd %xmm0, 0x270(%rbx)
movsd 0x10(%r13), %xmm0
movsd %xmm0, 0x278(%rbx)
movq 0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x280(%rbx)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x288(%rbx)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x290(%rbx)
movq 0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x298(%rbx)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x2a0(%rbx)
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x2a8(%rbx)
movb $0x1, 0x2b0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Triangle::Triangle(vec3&, vec3&, vec3&, Material&, mat4)
Triangle(vec3 &_v1, vec3 &_v2, vec3 &_v3, Material &_mat, mat4 _transform)
    : Polygon(_transform, _mat) {
        vertex1 = _v1;
        vertex2 = _v2;
        vertex3 = _v3;
        edge1 = vertex3 - vertex1;
        edge2 = vertex2 - vertex1;
        needInterpolate = false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %r9, %rsi
movq %r8, %rdx
callq 0x7462
leaq 0x16f75(%rip), %rax     # 0x1dc90
movq %rax, (%rbx)
movsd (%r12), %xmm0
movsd %xmm0, 0x1f0(%rbx)
movsd 0x8(%r12), %xmm1
movsd %xmm1, 0x1f8(%rbx)
movsd 0x10(%r12), %xmm2
movsd %xmm2, 0x200(%rbx)
movsd (%r15), %xmm3
movsd %xmm3, 0x208(%rbx)
movsd 0x8(%r15), %xmm4
movsd %xmm4, 0x210(%rbx)
movsd 0x10(%r15), %xmm5
movsd %xmm5, 0x218(%rbx)
movsd (%r14), %xmm6
movsd %xmm6, 0x220(%rbx)
movsd 0x8(%r14), %xmm7
movsd %xmm7, 0x228(%rbx)
movsd 0x10(%r14), %xmm8
movsd %xmm8, 0x230(%rbx)
subsd %xmm0, %xmm6
subsd %xmm1, %xmm7
subsd %xmm2, %xmm8
movsd %xmm6, 0x238(%rbx)
movsd %xmm7, 0x240(%rbx)
movsd %xmm8, 0x248(%rbx)
subsd %xmm0, %xmm3
subsd %xmm1, %xmm4
subsd %xmm2, %xmm5
movsd %xmm3, 0x250(%rbx)
movsd %xmm4, 0x258(%rbx)
movsd %xmm5, 0x260(%rbx)
movb $0x0, 0x2b0(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Film::Film(int, int)
Film(int _width, int _height) {
    	width = _width;
    	height = _height;
        for (int i = 0; i < width * height; i++) {
        	film.push_back(vec3(0, 0, 0));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
imull %esi, %edx
testl %edx, %edx
jle 0x6e58
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorl %r12d, %r12d
leaq -0x40(%rbp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa2d8
incl %r12d
movl 0x4(%rbx), %eax
imull (%rbx), %eax
cmpl %eax, %r12d
jl 0x6e30
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6e7c
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x3220
movq %r15, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Scene::Scene(Camera&, Film&, float, int, int)
Scene(Camera &_cam, Film &_film, float _eps, int _width, int _height)  {
		cam = _cam;
		film = _film;
		vec3 defaultAmbientColor = vec3(0, 0, 0);
		Light ambientLight = Light(defaultAmbientColor);
		width = _width;
		height = _height;
		maxDepth = 6; //6 or 7 ideal says GSI
		eps = _eps;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %r13d
movss %xmm0, -0x2c(%rbp)
movq %rdi, %rbx
leaq 0x88(%rdi), %r14
leaq 0xa0(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rdi)
movups %xmm0, 0xa8(%rdi)
movups %xmm0, 0x98(%rdi)
movups %xmm0, 0x88(%rdi)
movq $0x0, 0xc8(%rdi)
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rsi), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x20(%rsi), %xmm0
movsd %xmm0, 0x20(%rdi)
movsd 0x28(%rsi), %xmm0
movsd %xmm0, 0x28(%rdi)
movsd 0x30(%rsi), %xmm0
movsd %xmm0, 0x30(%rdi)
movsd 0x38(%rsi), %xmm0
movsd %xmm0, 0x38(%rdi)
movsd 0x40(%rsi), %xmm0
movsd %xmm0, 0x40(%rdi)
movsd 0x48(%rsi), %xmm0
movsd %xmm0, 0x48(%rdi)
movsd 0x50(%rsi), %xmm0
movsd %xmm0, 0x50(%rdi)
movsd 0x58(%rsi), %xmm0
movsd %xmm0, 0x58(%rdi)
movsd 0x60(%rsi), %xmm0
movsd %xmm0, 0x60(%rdi)
movsd 0x68(%rsi), %xmm0
movsd %xmm0, 0x68(%rdi)
movsd 0x70(%rsi), %xmm0
movsd %xmm0, 0x70(%rdi)
movq 0x78(%rsi), %rax
movq %rax, 0x78(%rdi)
movq (%rdx), %rax
movq %rax, 0x80(%rdi)
leaq 0x8(%rdx), %rsi
movq %r14, %rdi
callq 0x8348
movl %r13d, 0x108(%rbx)
movl %r12d, 0x10c(%rbx)
movl $0x6, 0x110(%rbx)
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0x114(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x6fdc
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3220
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x34e0
movq %r12, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/./algebra3.h
// Function: rotation3D(vec3, double)
inline mat4 rotation3D(vec3 Axis, const double angleDeg) {
    double  angleRad = angleDeg * M_PI / 180.0,
	    c = cos(angleRad),
	    s = sin(angleRad),
	    t = 1.0 - c;

    Axis.normalize();
    return mat4(vec4(t * Axis[VX] * Axis[VX] + c,
		     t * Axis[VX] * Axis[VY] - s * Axis[VZ],
		     t * Axis[VX] * Axis[VZ] + s * Axis[VY],
		     0.0),
		vec4(t * Axis[VX] * Axis[VY] + s * Axis[VZ],
		     t * Axis[VY] * Axis[VY] + c,
		     t * Axis[VY] * Axis[VZ] - s * Axis[VX],
		     0.0),
		vec4(t * Axis[VX] * Axis[VZ] - s * Axis[VY],
		     t * Axis[VY] * Axis[VZ] + s * Axis[VX],
		     t * Axis[VZ] * Axis[VZ] + c,
		     0.0),
		vec4(0.0, 0.0, 0.0, 1.0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
mulsd 0x10015(%rip), %xmm0    # 0x17020
divsd 0x10015(%rip), %xmm0    # 0x17028
movsd %xmm0, -0x18(%rbp)
callq 0x34a0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x3080
movapd %xmm0, %xmm9
movsd 0xffd6(%rip), %xmm12    # 0x17010
movapd %xmm12, %xmm10
subsd -0x20(%rbp), %xmm10
movsd (%r14), %xmm1
movsd 0x8(%r14), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%r14), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x707a
sqrtsd %xmm0, %xmm0
jmp 0x70a0
movsd %xmm10, -0x18(%rbp)
movsd %xmm9, -0x28(%rbp)
callq 0x31a0
movsd -0x28(%rbp), %xmm9
movsd 0xff76(%rip), %xmm12    # 0x17010
movsd -0x18(%rbp), %xmm10
divsd %xmm0, %xmm12
movsd (%r14), %xmm0
mulsd %xmm12, %xmm0
movsd %xmm0, (%r14)
movsd 0x8(%r14), %xmm1
mulsd %xmm12, %xmm1
movsd %xmm1, 0x8(%r14)
mulsd 0x10(%r14), %xmm12
movsd %xmm12, 0x10(%r14)
movapd %xmm10, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm2, %xmm3
mulsd %xmm0, %xmm3
movsd -0x20(%rbp), %xmm11
addsd %xmm11, %xmm3
movapd %xmm2, %xmm6
mulsd %xmm1, %xmm6
movapd %xmm9, %xmm4
mulsd %xmm12, %xmm4
movapd %xmm6, %xmm5
subsd %xmm4, %xmm5
movapd %xmm9, %xmm7
mulsd %xmm1, %xmm7
mulsd %xmm12, %xmm2
movapd %xmm2, %xmm8
addsd %xmm7, %xmm8
addsd %xmm6, %xmm4
movapd %xmm10, %xmm6
mulsd %xmm1, %xmm6
mulsd %xmm6, %xmm1
addsd %xmm11, %xmm1
mulsd %xmm12, %xmm6
mulsd %xmm9, %xmm0
movapd %xmm6, %xmm9
subsd %xmm0, %xmm9
subsd %xmm7, %xmm2
addsd %xmm6, %xmm0
mulsd %xmm12, %xmm10
mulsd %xmm12, %xmm10
addsd %xmm11, %xmm10
movsd %xmm3, (%rbx)
movsd %xmm5, 0x8(%rbx)
movsd %xmm8, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movsd %xmm4, 0x20(%rbx)
movsd %xmm1, 0x28(%rbx)
movsd %xmm9, 0x30(%rbx)
movq %rax, 0x38(%rbx)
movsd %xmm2, 0x40(%rbx)
movsd %xmm0, 0x48(%rbx)
movsd %xmm10, 0x50(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x58(%rbx)
movupd %xmm0, 0x68(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Scene::render()
void render() {
        Sampler sampler = Sampler(width, height);
        Sample sample = Sample();
        int count = 0;
        int tenthPixels = width * height / 10;
        while (sampler.generateSample(&sample)) {
            Ray testRay = cam.generateRay(sample);
            vec3 color = traceRay(testRay, maxDepth);
            film.writeToFilm(sample, color);
            if (count > tenthPixels) {
                cout << sampler.percentage() << "\% completed." << endl;
                count = 0;
            }
            count++;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl 0x108(%rdi), %edx
movl 0x10c(%rdi), %r13d
leaq -0x30(%rbp), %rax
movq $0x0, (%rax)
movl %r13d, %eax
imull %edx, %eax
cltq
imulq $0x66666667, %rax, %rsi # imm = 0x66666667
movq %rsi, %rcx
shrq $0x3f, %rcx
sarq $0x22, %rsi
addl %ecx, %esi
movq %rsi, -0x60(%rbp)
movq %rdx, -0x48(%rbp)
leal -0x1(%rdx), %ecx
movl %ecx, -0x38(%rbp)
movq %rdi, -0x50(%rbp)
leaq 0x80(%rdi), %rcx
movq %rcx, -0x58(%rbp)
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x34(%rbp)
xorl %r12d, %r12d
xorl %eax, %eax
xorl %r8d, %r8d
movl %r13d, -0x3c(%rbp)
cmpl %r13d, %eax
je 0x72dd
movl %r12d, -0x30(%rbp)
movl %eax, -0x2c(%rbp)
cmpl -0x38(%rbp), %r12d
jne 0x72da
leal 0x1(%rax), %ecx
xorl %r12d, %r12d
jmp 0x72df
incl %r12d
movl %eax, %ecx
cmpl %r13d, %eax
je 0x73bd
movl %r12d, %r13d
leaq -0xb0(%rbp), %rdi
movq -0x50(%rbp), %r12
movq %r12, %rsi
movl %ecx, %ebx
leaq -0x30(%rbp), %rdx
movl %r8d, %r15d
callq 0x8b2e
movl 0x110(%r12), %ecx
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
leaq -0xb0(%rbp), %rdx
movl %r13d, %r12d
callq 0x8c5e
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq %r14, %rdx
callq 0x923a
movl %r15d, %r8d
cmpl -0x60(%rbp), %r15d
jle 0x73af
movl %ebx, %eax
imull -0x48(%rbp), %eax
addl %r12d, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss -0x34(%rbp), %xmm0
mulss 0xfd26(%rip), %xmm0     # 0x17084
cvttss2si %xmm0, %esi
movq 0x16c67(%rip), %rdi     # 0x1dfd0
callq 0x3410
movq %rax, %r14
movl $0xc, %edx
movq %rax, %rdi
leaq 0x100bd(%rip), %rsi     # 0x1743d
callq 0x3260
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3160
xorl %r8d, %r8d
incl %r8d
movl %ebx, %eax
movl -0x3c(%rbp), %r13d
jmp 0x72c0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Camera::generateRay(Sample&)
Ray generateRay(Sample &sample) {
        float u = float(sample.x) / float(width);
        float v = float(sample.y) / float(height);
        vec3 c = (ll*(1-u) + lr*u)*(1-v) + (ul*(1-u) + ur*u)*v;
        vec3 testRayVec = c - eye;
	    return Ray(eye, testRayVec);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cvtsi2ssl (%rdx), %xmm0
cvtsi2ssl 0x78(%rsi), %xmm2
cvtsi2ssl 0x4(%rdx), %xmm1
movq %rdi, %rax
cvtsi2ssl 0x7c(%rsi), %xmm3
divss %xmm2, %xmm0
divss %xmm3, %xmm1
movss 0xe538(%rip), %xmm6     # 0x17090
movaps %xmm6, %xmm2
subss %xmm0, %xmm2
cvtss2sd %xmm2, %xmm2
movsd 0x48(%rsi), %xmm4
mulsd %xmm2, %xmm4
movsd 0x50(%rsi), %xmm5
mulsd %xmm2, %xmm5
movsd 0x58(%rsi), %xmm7
mulsd %xmm2, %xmm7
cvtss2sd %xmm0, %xmm0
movsd 0x60(%rsi), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm4, %xmm3
movsd 0x68(%rsi), %xmm4
mulsd %xmm0, %xmm4
addsd %xmm5, %xmm4
movsd 0x70(%rsi), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm7, %xmm5
subss %xmm1, %xmm6
cvtss2sd %xmm6, %xmm6
mulsd %xmm6, %xmm3
mulsd %xmm6, %xmm4
movsd 0x18(%rsi), %xmm7
mulsd %xmm2, %xmm7
movsd 0x20(%rsi), %xmm8
mulsd %xmm2, %xmm8
mulsd 0x28(%rsi), %xmm2
mulsd %xmm6, %xmm5
movsd 0x30(%rsi), %xmm6
mulsd %xmm0, %xmm6
addsd %xmm7, %xmm6
movsd 0x38(%rsi), %xmm7
mulsd %xmm0, %xmm7
mulsd 0x40(%rsi), %xmm0
addsd %xmm8, %xmm7
addsd %xmm2, %xmm0
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm6
addsd %xmm3, %xmm6
mulsd %xmm1, %xmm7
addsd %xmm4, %xmm7
mulsd %xmm1, %xmm0
addsd %xmm5, %xmm0
movsd (%rsi), %xmm1
movsd 0x8(%rsi), %xmm2
subsd %xmm1, %xmm6
subsd %xmm2, %xmm7
movsd 0x10(%rsi), %xmm3
subsd %xmm3, %xmm0
movsd %xmm1, (%rdi)
movsd %xmm2, 0x8(%rdi)
movsd %xmm3, 0x10(%rdi)
movsd %xmm6, 0x18(%rdi)
movsd %xmm7, 0x20(%rdi)
movsd %xmm0, 0x28(%rdi)
movabsq $0x7f7fffff3a83126f, %rcx # imm = 0x7F7FFFFF3A83126F
movq %rcx, 0x30(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Film::writeToFilm(Sample&, vec3&)
void writeToFilm(Sample &sample, vec3 &fColor) {
    	vec3 color = floatToByte(fColor);
    	if (color[RED] > 255) {color[RED] = 255;}
    	if (color[GREEN] > 255) {color[GREEN] = 255;}
    	if (color[BLUE] > 255) {color[BLUE] = 255;}
        film.at(sample.y * width + sample.x)[RED] = color[RED];
        film.at(sample.y * width + sample.x)[GREEN] = color[GREEN];
        film.at(sample.y * width + sample.x)[BLUE] = color[BLUE];
    }

// Assembly:
movslq 0x4(%rsi), %rax
movslq (%rdi), %rcx
imulq %rax, %rcx
movslq (%rsi), %rsi
addq %rcx, %rsi
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
subq %rcx, %rdi
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rax
cmpq %rsi, %rax
jbe 0x92d1
movsd 0xdd93(%rip), %xmm0     # 0x17008
movsd 0x10(%rdx), %xmm1
mulsd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
movapd %xmm0, %xmm2
movsd 0x8(%rdx), %xmm3
mulsd %xmm0, %xmm3
cvttpd2dq %xmm3, %xmm3
minsd %xmm1, %xmm2
cvtdq2pd %xmm3, %xmm1
movapd %xmm0, %xmm3
movsd (%rdx), %xmm4
mulsd %xmm0, %xmm4
cvttpd2dq %xmm4, %xmm4
minsd %xmm1, %xmm3
cvtdq2pd %xmm4, %xmm1
minsd %xmm1, %xmm0
leaq (%rsi,%rsi,2), %rax
movsd %xmm0, (%rcx,%rax,8)
movsd %xmm3, 0x8(%rcx,%rax,8)
movsd %xmm2, 0x10(%rcx,%rax,8)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xe16e(%rip), %rdi      # 0x1744a
movq %rax, %rdx
xorl %eax, %eax
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Polygon::transformRay(Ray&)
Ray transformRay(Ray &ray) {
        vec4 tmpPos = vec4(ray.pos, 1.0f);
        tmpPos = inverseTransform * tmpPos;
        vec3 rayPos = vec3(tmpPos);
        vec4 tmpVec = vec4(ray.vec, 0.0f);
        tmpVec = inverseTransform * tmpVec;
        vec3 rayVec = vec3(tmpVec, VW);
        return Ray(rayPos, rayVec);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movsd (%rdx), %xmm15
movsd 0x8(%rdx), %xmm14
movsd 0x10(%rdx), %xmm13
movsd 0xf0(%rsi), %xmm9
movsd 0xf8(%rsi), %xmm2
movapd %xmm14, %xmm0
mulsd %xmm2, %xmm0
movapd %xmm9, %xmm1
mulsd %xmm15, %xmm1
addsd %xmm0, %xmm1
movsd 0x100(%rsi), %xmm4
movapd %xmm4, %xmm0
mulsd %xmm13, %xmm0
addsd %xmm1, %xmm0
movsd 0x110(%rsi), %xmm8
movsd 0x118(%rsi), %xmm3
movsd %xmm3, -0x8(%rbp)
movapd %xmm14, %xmm1
mulsd %xmm3, %xmm1
movapd %xmm8, %xmm5
mulsd %xmm15, %xmm5
addsd %xmm1, %xmm5
movsd 0x120(%rsi), %xmm7
movapd %xmm7, %xmm1
mulsd %xmm13, %xmm1
addsd %xmm5, %xmm1
movsd 0x130(%rsi), %xmm5
movsd 0x138(%rsi), %xmm12
movapd %xmm14, %xmm6
mulsd %xmm12, %xmm6
movapd %xmm5, %xmm11
mulsd %xmm15, %xmm11
addsd %xmm6, %xmm11
movsd 0x140(%rsi), %xmm10
movapd %xmm10, %xmm6
mulsd %xmm13, %xmm6
addsd %xmm11, %xmm6
movsd 0x108(%rsi), %xmm11
mulsd 0x158(%rsi), %xmm14
mulsd 0x150(%rsi), %xmm15
addsd %xmm11, %xmm0
addsd %xmm14, %xmm15
movsd 0x128(%rsi), %xmm14
addsd %xmm14, %xmm1
mulsd 0x160(%rsi), %xmm13
addsd %xmm15, %xmm13
movsd 0x148(%rsi), %xmm15
addsd %xmm15, %xmm6
addsd 0x168(%rsi), %xmm13
divsd %xmm13, %xmm0
divsd %xmm13, %xmm1
divsd %xmm13, %xmm6
movsd 0x20(%rdx), %xmm13
mulsd %xmm13, %xmm2
movsd 0x18(%rdx), %xmm3
mulsd %xmm3, %xmm9
addsd %xmm2, %xmm9
movsd 0x28(%rdx), %xmm2
mulsd %xmm2, %xmm4
addsd %xmm9, %xmm4
xorpd %xmm9, %xmm9
mulsd %xmm9, %xmm11
addsd %xmm4, %xmm11
movsd -0x8(%rbp), %xmm4
mulsd %xmm13, %xmm4
mulsd %xmm3, %xmm8
addsd %xmm4, %xmm8
mulsd %xmm2, %xmm7
addsd %xmm8, %xmm7
mulsd %xmm9, %xmm14
addsd %xmm7, %xmm14
mulsd %xmm13, %xmm12
mulsd %xmm3, %xmm5
addsd %xmm12, %xmm5
mulsd %xmm2, %xmm10
addsd %xmm5, %xmm10
mulsd %xmm9, %xmm15
addsd %xmm10, %xmm15
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movsd %xmm6, 0x10(%rdi)
movsd %xmm11, 0x18(%rdi)
movsd %xmm14, 0x20(%rdi)
movsd %xmm15, 0x28(%rdi)
movabsq $0x7f7fffff3a83126f, %rcx # imm = 0x7F7FFFFF3A83126F
movq %rcx, 0x30(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Polygon::transformIntersection(vec3&)
vec3 transformIntersection(vec3 &intersection) {
    	vec4 tmpIntersection = vec4(intersection, 1.0f);
    	tmpIntersection = transform * tmpIntersection;
    	vec3 intersection3 = vec3(tmpIntersection);
        return intersection3;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd (%rdx), %xmm1
movsd 0x8(%rdx), %xmm2
movsd 0x10(%rdx), %xmm0
movsd 0x78(%rsi), %xmm3
mulsd %xmm2, %xmm3
movsd 0x70(%rsi), %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd 0x80(%rsi), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm4, %xmm3
addsd 0x88(%rsi), %xmm3
movsd 0x98(%rsi), %xmm4
mulsd %xmm2, %xmm4
movsd 0x90(%rsi), %xmm5
mulsd %xmm1, %xmm5
addsd %xmm4, %xmm5
movsd 0xa0(%rsi), %xmm4
mulsd %xmm0, %xmm4
addsd %xmm5, %xmm4
addsd 0xa8(%rsi), %xmm4
movsd 0xb8(%rsi), %xmm5
mulsd %xmm2, %xmm5
movsd 0xb0(%rsi), %xmm6
mulsd %xmm1, %xmm6
addsd %xmm5, %xmm6
movsd 0xc0(%rsi), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm6, %xmm5
addsd 0xc8(%rsi), %xmm5
mulsd 0xd8(%rsi), %xmm2
mulsd 0xd0(%rsi), %xmm1
mulsd 0xe0(%rsi), %xmm0
addsd %xmm2, %xmm1
addsd %xmm1, %xmm0
addsd 0xe8(%rsi), %xmm0
movq %rdi, %rax
divsd %xmm0, %xmm3
movsd %xmm3, (%rdi)
divsd %xmm0, %xmm4
movsd %xmm4, 0x8(%rdi)
divsd %xmm0, %xmm5
movsd %xmm5, 0x10(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Polygon::transformNormal(vec3&)
vec3 transformNormal(vec3 &normal) {

        vec4 normal4= vec4(normal, 0.0f);
        normal4 = inverseTranspose * normal4;
        vec3 normal3  = vec3(normal4, VW);
        return normal3;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movsd (%rdx), %xmm1
movsd 0x8(%rdx), %xmm2
movsd 0x10(%rdx), %xmm0
movsd 0x178(%rsi), %xmm3
mulsd %xmm2, %xmm3
movsd 0x170(%rsi), %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd 0x180(%rsi), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm4, %xmm5
xorpd %xmm3, %xmm3
movsd 0x188(%rsi), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm5, %xmm4
movsd 0x198(%rsi), %xmm5
mulsd %xmm2, %xmm5
movsd 0x190(%rsi), %xmm6
mulsd %xmm1, %xmm6
addsd %xmm5, %xmm6
movsd 0x1a0(%rsi), %xmm5
mulsd %xmm0, %xmm5
addsd %xmm6, %xmm5
movsd 0x1a8(%rsi), %xmm6
mulsd %xmm3, %xmm6
mulsd 0x1b8(%rsi), %xmm2
mulsd 0x1b0(%rsi), %xmm1
addsd %xmm5, %xmm6
addsd %xmm2, %xmm1
mulsd 0x1c0(%rsi), %xmm0
addsd %xmm1, %xmm0
mulsd 0x1c8(%rsi), %xmm3
addsd %xmm0, %xmm3
movsd %xmm4, (%rdi)
movsd %xmm6, 0x8(%rdi)
movsd %xmm3, 0x10(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Light::intensityAt(vec3&)
vec3 intensityAt(vec3 &point) {
        if (falloff == 0) {
        	return color;
        } else {
        	float d = distance(pos, point);
            return color / pow(d, falloff);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x30(%rsi)
je 0x9c21
movsd 0x18(%r14), %xmm0
movsd 0x20(%r14), %xmm1
subsd (%rdx), %xmm0
mulsd %xmm0, %xmm0
subsd 0x8(%rdx), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x28(%r14), %xmm0
subsd 0x10(%rdx), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x9c3d
sqrtsd %xmm0, %xmm0
jmp 0x9c42
movsd (%r14), %xmm0
movsd %xmm0, (%rbx)
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x10(%r14), %xmm1
jmp 0x9c86
callq 0x31a0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x30(%r14), %xmm1
callq 0x3440
movsd 0xd3b0(%rip), %xmm1     # 0x17010
divsd %xmm0, %xmm1
movsd (%r14), %xmm0
mulsd %xmm1, %xmm0
movsd 0x8(%r14), %xmm2
mulsd %xmm1, %xmm2
mulsd 0x10(%r14), %xmm1
movsd %xmm0, (%rbx)
movsd %xmm2, 0x8(%rbx)
movsd %xmm1, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/raytracer.cpp
// Function: Scene::traceShadowRay(Ray&, Polygon*)
bool traceShadowRay(Ray &ray, Polygon *source) {
        for (int i = 0; i < objects.size(); i++) {
            if (objects[i]->intersects(ray) && objects[i] != source) {
                return true;
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xa0(%rdi), %rax
cmpq %rax, 0xa8(%rdi)
setne %r12b
je 0x9e0a
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movq (%rax,%r13,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
testb %al, %al
je 0x9de9
movq 0xa0(%r15), %rax
cmpq %rbx, (%rax,%r13,8)
jne 0x9e0a
incq %r13
movq 0xa0(%r15), %rax
movq 0xa8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
seta %r12b
ja 0x9dcc
andb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_load_file(unsigned char**, unsigned long*, char const*)
unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename)
{
  FILE* file;
  long size;

  /*provide some proper output values if error will happen*/
  *out = 0;
  *outsize = 0;

  file = fopen(filename, "rb");
  if(!file) return 78;

  /*get filesize:*/
  fseek(file , 0 , SEEK_END);
  size = ftell(file);
  rewind(file);

  /*read contents of the file into the vector*/
  *outsize = 0;
  *out = (unsigned char*)lodepng_malloc((size_t)size);
  if(size && (*out)) (*outsize) = fread(*out, 1, (size_t)size, file);

  fclose(file);
  if(!(*out) && size) return 83; /*the above malloc failed*/
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, (%rdi)
movq %rax, (%rsi)
leaq 0xd35b(%rip), %rsi      # 0x17f80
movq %rdx, %rdi
callq 0x3270
testq %rax, %rax
je 0xacb0
movq %rax, %r15
xorl %r13d, %r13d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3250
movq %r15, %rdi
callq 0x3030
movq %rax, %r12
movq %r15, %rdi
callq 0x3060
movq $0x0, (%r14)
movq %r12, %rdi
callq 0x32e0
movq %rax, (%rbx)
testq %r12, %r12
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0xac92
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x3360
movq %rax, (%r14)
movq %r15, %rdi
callq 0x3200
cmpq $0x0, (%rbx)
movl $0x53, %eax
cmovnel %r13d, %eax
testq %r12, %r12
cmovel %r13d, %eax
jmp 0xacb5
movl $0x4e, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/lodepng.cpp
// Function: append_symbol_coins(Coin*, unsigned int const*, unsigned int, unsigned long)
static unsigned append_symbol_coins(Coin* coins, const unsigned* frequencies, unsigned numcodes, size_t sum)
{
  unsigned i;
  unsigned j = 0; /*index of present symbols*/
  for(i = 0; i != numcodes; ++i)
  {
    if(frequencies[i] != 0) /*only include symbols that are present*/
    {
      coins[j].weight = frequencies[i] / (float)sum;
      uivector_push_back(&coins[j].symbols, i);
      ++j;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
testl %edx, %edx
je 0xb1f0
movq %rdi, %r14
testq %rcx, %rcx
js 0xb178
cvtsi2ss %rcx, %xmm0
jmp 0xb18d
movq %rcx, %rax
shrq %rax
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movl %edx, %r12d
xorl %r13d, %r13d
xorl %ebx, %ebx
movq -0x38(%rbp), %rax
movl (%rax,%r13,4), %eax
testl %eax, %eax
je 0xb1e8
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
divss -0x2c(%rbp), %xmm0
movl %ebx, %eax
shlq $0x5, %rax
leaq (%r14,%rax), %r15
movss %xmm0, 0x18(%r14,%rax)
movq 0x8(%r14,%rax), %rsi
incq %rsi
movq %r15, %rdi
callq 0x13dd8
testl %eax, %eax
je 0xb1e6
movq (%r15), %rax
movq 0x8(%r15), %rcx
movl %r13d, -0x4(%rax,%rcx,4)
incl %ebx
incq %r13
cmpq %r13, %r12
jne 0xb19a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_crc32(unsigned char const*, unsigned long)
unsigned lodepng_crc32(const unsigned char* buf, size_t len)
{
  unsigned c = 0xffffffffL;
  size_t n;

  for(n = 0; n < len; ++n)
  {
    c = lodepng_crc32_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
  }
  return c ^ 0xffffffffL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0xd8f8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
leaq 0x9de6(%rip), %rdx      # 0x176c0
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0xd8da
notl %eax
jmp 0xd8fa
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_has_palette_alpha(LodePNGColorMode const*)
unsigned lodepng_has_palette_alpha(const LodePNGColorMode* info)
{
  size_t i;
  for(i = 0; i != info->palettesize; ++i)
  {
    if(info->palette[i * 4 + 3] < 255) return 1;
  }
  return 0;
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xde6d
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
xorl %edx, %edx
cmpb $-0x1, 0x3(%rcx,%rdx,4)
jne 0xde70
incq %rdx
cmpq %rdx, %rax
jne 0xde5a
xorl %eax, %eax
jmp 0xde75
xorl %eax, %eax
retq
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_info_init(LodePNGInfo*)
void lodepng_info_init(LodePNGInfo* info)
{
  lodepng_color_mode_init(&info->color);
  info->interlace_method = 0;
  info->compression_method = 0;
  info->filter_method = 0;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  info->background_defined = 0;
  info->background_r = info->background_g = info->background_b = 0;

  LodePNGText_init(info);
  LodePNGIText_init(info);

  info->time_defined = 0;
  info->phys_defined = 0;

  LodePNGUnknownChunks_init(info);
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movabsq $0x800000006, %rax      # imm = 0x800000006
movq %rax, 0x10(%rdi)
movups %xmm0, 0x18(%rdi)
xorl %eax, %eax
movl %eax, 0x8(%rdi)
movq $0x0, (%rdi)
movl %eax, 0xa4(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x78(%rdi)
movl %eax, 0x88(%rdi)
movups %xmm0, 0xb8(%rdi)
movups %xmm0, 0xc8(%rdi)
movups %xmm0, 0xd8(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_color_mode_equal(LodePNGColorMode const*, LodePNGColorMode const*)
static int lodepng_color_mode_equal(const LodePNGColorMode* a, const LodePNGColorMode* b)
{
  size_t i;
  if(a->colortype != b->colortype) return 0;
  if(a->bitdepth != b->bitdepth) return 0;
  if(a->key_defined != b->key_defined) return 0;
  if(a->key_defined)
  {
    if(a->key_r != b->key_r) return 0;
    if(a->key_g != b->key_g) return 0;
    if(a->key_b != b->key_b) return 0;
  }
  if(a->palettesize != b->palettesize) return 0;
  for(i = 0; i != a->palettesize * 4; ++i)
  {
    if(a->palette[i] != b->palette[i]) return 0;
  }
  return 1;
}

// Assembly:
movl (%rdi), %ecx
xorl %eax, %eax
cmpl (%rsi), %ecx
jne 0xeb40
movl 0x4(%rdi), %ecx
cmpl 0x4(%rsi), %ecx
jne 0xeb40
movl 0x18(%rdi), %ecx
cmpl 0x18(%rsi), %ecx
jne 0xeb40
testl %ecx, %ecx
je 0xeb03
movl 0x1c(%rdi), %ecx
cmpl 0x1c(%rsi), %ecx
jne 0xeb40
movl 0x20(%rdi), %ecx
cmpl 0x20(%rsi), %ecx
jne 0xeb40
movl 0x24(%rdi), %ecx
cmpl 0x24(%rsi), %ecx
jne 0xeb40
movq 0x10(%rdi), %rcx
cmpq 0x10(%rsi), %rcx
jne 0xeb40
shlq $0x2, %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0xeb40
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
xorl %edi, %edi
movb (%rdx,%rdi), %r8b
cmpb (%rsi,%rdi), %r8b
jne 0xeb3d
incq %rdi
cmpq %rdi, %rcx
jne 0xeb29
jmp 0xeb3f
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_encoder_settings_init(LodePNGEncoderSettings*)
void lodepng_encoder_settings_init(LodePNGEncoderSettings* settings)
{
  lodepng_compress_settings_init(&settings->zlibsettings);
  settings->filter_palette_zero = 1;
  settings->filter_strategy = LFS_MINSUM;
  settings->auto_convert = 1;
  settings->force_palette = 0;
  settings->predefined_filters = 0;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  settings->add_id = 0;
  settings->text_compression = 1;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movaps 0x6745(%rip), %xmm0     # 0x17520
movups %xmm0, (%rdi)
movabsq $0x100000080, %rax      # imm = 0x100000080
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
movl $0x1, %eax
movl %eax, 0x38(%rdi)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movl %eax, 0x50(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/lodepng.cpp
// Function: addChunk_tIME(ucvector*, LodePNGTime const*)
static unsigned addChunk_tIME(ucvector* out, const LodePNGTime* time)
{
  unsigned error = 0;
  unsigned char* data = (unsigned char*)lodepng_malloc(7);
  if(!data) return 83; /*alloc fail*/
  data[0] = (unsigned char)(time->year / 256);
  data[1] = (unsigned char)(time->year % 256);
  data[2] = (unsigned char)time->month;
  data[3] = (unsigned char)time->day;
  data[4] = (unsigned char)time->hour;
  data[5] = (unsigned char)time->minute;
  data[6] = (unsigned char)time->second;
  error = addChunk(out, "tIME", data, 7);
  lodepng_free(data);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x7, %edi
callq 0x32e0
testq %rax, %rax
je 0x12863
movq %rax, %r14
movzwl (%r15), %eax
rolw $0x8, %ax
movw %ax, (%r14)
movb 0x4(%r15), %al
movb %al, 0x2(%r14)
movb 0x8(%r15), %al
movb %al, 0x3(%r14)
movb 0xc(%r15), %al
movb %al, 0x4(%r14)
movb 0x10(%r15), %al
movb %al, 0x5(%r14)
movb 0x14(%r15), %al
movb %al, 0x6(%r14)
leaq 0x8(%rbx), %rsi
leaq 0x6615(%rip), %rcx      # 0x18e4a
movq %rbx, %rdi
movl $0x7, %edx
movq %r14, %r8
callq 0xdb5b
testl %eax, %eax
jne 0x12851
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3280
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng::load_file(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void load_file(std::vector<unsigned char>& buffer, const std::string& filename)
{
  std::ifstream file(filename.c_str(), std::ios::in|std::ios::binary|std::ios::ate);

  /*get filesize*/
  std::streamsize size = 0;
  if(file.seekg(0, std::ios::end).good()) size = file.tellg();
  if(file.seekg(0, std::ios::beg).good()) size -= file.tellg();

  /*read contents of the file into the vector*/
  buffer.resize(size_t(size));
  if(size > 0) file.read((char*)(&buffer[0]), size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x218(%rbp), %r14
movq %r14, %rdi
movl $0xe, %edx
callq 0x3480
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x32f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%rax,%rcx)
je 0x1350f
xorl %r14d, %r14d
jmp 0x1351e
leaq -0x218(%rbp), %rdi
callq 0x3420
movq %rax, %r14
leaq -0x218(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x32f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%rax,%rcx)
jne 0x1354b
leaq -0x218(%rbp), %rdi
callq 0x3420
subq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16c46
testq %r14, %r14
jle 0x1356d
movq (%rbx), %rsi
leaq -0x218(%rbp), %rdi
movq %r14, %rdx
callq 0x32b0
leaq -0x218(%rbp), %rdi
callq 0x30b0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x13589
jmp 0x13589
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH06_Functions/examples/mk_plural.cc
// Function: main
int main()
{
	size_t cnt = 1;
	cout << make_plural(cnt, "success", "es") << endl;

	cnt = 2;
	cout << make_plural(cnt, "failure", "s") << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xdba(%rip), %rsi       # 0x2004
leaq 0xdba(%rip), %rdx       # 0x200b
leaq -0x60(%rbp), %rdi
callq 0x1544
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xda3(%rip), %rsi       # 0x200c
leaq 0xd9e(%rip), %rdx       # 0x200e
leaq -0x80(%rbp), %rdi
callq 0x1544
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0x14aa
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x2d33(%rip), %rdi      # 0x3fd8
callq 0x10b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x12e9
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x10a0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x12fe
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x10a0
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x1313
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x10a0
leaq -0x60(%rbp), %rdi
movq %r14, (%rdi)
leaq 0xcee(%rip), %rsi       # 0x200f
leaq 0xcee(%rip), %rdx       # 0x2016
callq 0x1544
leaq -0x80(%rbp), %rdi
movq %r15, (%rdi)
leaq 0xcd2(%rip), %rsi       # 0x200d
leaq 0xccc(%rip), %rdx       # 0x200e
callq 0x1544
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x1445
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x2c71(%rip), %rdi      # 0x3fd8
callq 0x10b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x13ab
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x10a0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x13c0
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x10a0
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x13d5
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x10a0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13ea
jmp 0x13ef
jmp 0x13f4
movq %rax, %rbx
jmp 0x1413
movq %rax, %rbx
jmp 0x1428
movq %rax, %rbx
jmp 0x143d
jmp 0x13fb
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1413
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x10a0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x1428
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x10a0
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x143d
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x10a0
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O1/superblocks[P]superblocks/set-spt.cpp
// Function: Superblocks::init()
void Superblocks::init() {

	coin = "SPT"; 
	coin_name = "Spots";

	hash_length = 64;

	// normal (step 0)
	reward[0] = 49;

	// superblock (step 1)
	reward[1] = 10045; // superblock reward (step 1)
	seed_type[1] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[1] = 8;
	cutout_length[1] = 7;
	rnd_range_low[1] = 1;
	rnd_range_high[1] = 100000;
	luck_type[1] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[1] = 50000;
	luck_y[1] = 50011;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
movq 0x20(%rbx), %rdx
leaq 0x18f8(%rip), %rcx      # 0x3b00
movl $0x3, %r8d
xorl %esi, %esi
callq 0x1130
leaq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rdx
leaq 0x18e0(%rip), %rcx      # 0x3b04
movl $0x5, %r8d
xorl %esi, %esi
callq 0x1130
movl $0x40, 0x58(%rbx)
movl $0x273d, 0xd8(%rbx)     # imm = 0x273D
movl $0x2, 0x60(%rbx)
movl $0x8, 0x68(%rbx)
movl $0x7, 0x70(%rbx)
movl $0x1, 0x78(%rbx)
movl $0x186a0, 0x80(%rbx)    # imm = 0x186A0
movl $0x3, 0xc0(%rbx)
movl $0xc350, 0xc8(%rbx)     # imm = 0xC350
movabsq $0x310000c35b, %rax     # imm = 0x310000C35B
movq %rax, 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/HQarroum[P]thread-pool/examples/working-with-tokens/main.cpp
// Function: main
int main() {
 thread::pool::pool_t pool(std::thread::hardware_concurrency() + 1);
 
 // Creating a producer token.
 auto producer_token = pool.create_token_of<thread::pool::producer_token_t>();

 // Filling our array with `iterations` amount of functions,
 // bound to the number `42`.
 std::fill_n(callables, iterations, std::bind(static_void_function, 42));
 // Scheduling the execution in bulk.
 auto result = pool.schedule_bulk(producer_token, callables, iterations);
 // Log whether the insertion was successful.
 std::cout << "The insertion has " << (result ? "succeeded." : "failed.") << std::endl;
 assert(result == true);
 return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2b0, %rsp            # imm = 0x2B0
callq 0x21d0
leal 0x1(%rax), %esi
leaq 0x18(%rsp), %rdi
callq 0x25f0
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x3924
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, (%rsp)
je 0x24a9
movq %rsp, %rax
movq %rax, 0x10(%rcx)
leaq -0x94(%rip), %rax       # 0x241c
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movl $0x2a, 0x8(%rbx)
xorl %r14d, %r14d
leaq 0x6cb7(%rip), %r15      # 0x9180
leaq (%r15,%r14), %rdi
movq %rbx, %rsi
callq 0x4108
addq $0x20, %r14
cmpq $0xc80, %r14            # imm = 0xC80
jne 0x24c9
leaq 0x6c97(%rip), %rdx      # 0x9180
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
movl $0x64, %ecx
callq 0x26b8
movl %eax, %ebx
movq 0x6acc(%rip), %rdi      # 0x8fd0
leaq 0x2b09(%rip), %rsi      # 0x5014
movl $0x12, %edx
callq 0x21a0
leaq 0x2b0b(%rip), %rax      # 0x5027
leaq 0x2b0f(%rip), %rsi      # 0x5032
testb %bl, %bl
cmovneq %rax, %rsi
movzbl %bl, %eax
leaq (%rax,%rax,2), %rdx
addq $0x7, %rdx
movq 0x6a95(%rip), %r14      # 0x8fd0
movq %r14, %rdi
callq 0x21a0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq 0x6a6f(%rip), %rdi      # 0x8fd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
testb %bl, %bl
je 0x25a0
movq (%rsp), %rax
testq %rax, %rax
je 0x2587
movq $0x0, 0x10(%rax)
movb $0x1, 0x8(%rax)
leaq 0x18(%rsp), %rdi
callq 0x26f8
xorl %eax, %eax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2a93(%rip), %rdi      # 0x503a
leaq 0x2a9b(%rip), %rsi      # 0x5049
leaq 0x2a9d(%rip), %rcx      # 0x5052
movl $0x25, %edx
callq 0x2100
movq %rax, %rbx
jmp 0x25de
jmp 0x25c6
movq %rax, %rbx
movq (%rsp), %rax
testq %rax, %rax
je 0x25de
movq $0x0, 0x10(%rax)
movb $0x1, 0x8(%rax)
leaq 0x18(%rsp), %rdi
callq 0x26f8
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/ipatix[P]wav2agb/wav2agb.cpp
// Function: main.cold.2
static void usage() {
    fprintf(stderr, "wav2agb\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "Usage: wav2agb [options] <input.wav> [<output.s>]\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "Options:\n");
    fprintf(stderr, "-s, --symbol <sym>       | symbol name for wave header (default: file name)\n");
    fprintf(stderr, "-l, --lookahead <amount> | DPCM compression lookahead 1..8 (default: 3)\n");
    fprintf(stderr, "-c, --compress           | compress output with DPCM\n");
    fprintf(stderr, "--loop-start <pos>       | override loop start (integer)\n");
    fprintf(stderr, "--loop-end <pos>         | override loop end (integer)\n");
    fprintf(stderr, "--tune <cents>           | override tuning (float)\n");
    fprintf(stderr, "--key <key>              | override midi key (int)\n");
    fprintf(stderr, "--rate <rate>            | override base samplerate (int)\n");
    exit(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x6b66(%rip), %r15      # 0x8fd8
movq (%r15), %rcx
leaq 0x3f24(%rip), %rdi      # 0x63a0
pushq $0x8
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2400
movq (%r15), %rsi
pushq $0xa
popq %rbp
movl %ebp, %edi
callq 0x22a0
movq (%r15), %rcx
leaq 0x3f08(%rip), %rdi      # 0x63a9
pushq $0x32
popq %rsi
movq %rbx, %rdx
callq 0x2400
movq (%r15), %rsi
movl %ebp, %edi
callq 0x22a0
movq (%r15), %rcx
leaq 0x3f1c(%rip), %rdi      # 0x63dc
pushq $0x9
popq %rsi
movq %rbx, %rdx
callq 0x2400
movq (%r15), %rcx
leaq 0x3f11(%rip), %rdi      # 0x63e6
pushq $0x4c
popq %rsi
movq %rbx, %rdx
callq 0x2400
movq (%r15), %rcx
leaq 0x3f49(%rip), %rdi      # 0x6433
pushq $0x48
popq %rsi
movq %rbx, %rdx
callq 0x2400
movq (%r15), %rcx
leaq 0x3f7d(%rip), %rdi      # 0x647c
pushq $0x35
popq %rsi
movq %rbx, %rdx
callq 0x2400
movq (%r15), %rcx
leaq 0x3f9e(%rip), %rdi      # 0x64b2
pushq $0x39
popq %rsi
movq %rbx, %rdx
callq 0x2400
movq (%r15), %rcx
leaq 0x3fc3(%rip), %rdi      # 0x64ec
pushq $0x37
popq %rsi
movq %rbx, %rdx
callq 0x2400
movq (%r15), %rcx
leaq 0x3fe6(%rip), %rdi      # 0x6524
pushq $0x33
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2400
movq (%r15), %rcx
leaq 0x4001(%rip), %rdi      # 0x6558
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2400
movq (%r15), %rcx
leaq 0x4020(%rip), %rdi      # 0x658c
pushq $0x3a
popq %rsi
movq %rbx, %rdx
callq 0x2400
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/ipatix[P]wav2agb/converter.cpp
// Function: agb_out(std::basic_ofstream<char, std::char_traits<char>>&, char const*, ...)
static void agb_out(std::ofstream& ofs, const char *msg, ...) {
    char buf[256];
    va_list args;
    va_start(args, msg);
    vsnprintf(buf, sizeof(buf), msg, args);
    va_end(args);
    ofs << buf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %r10
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2ea2
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0x1f0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %r10, %rdx
callq 0x2160
movq %r14, %rdi
callq 0x2110
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2260
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq