LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: eschwabe[P]interview-practice/src/zeromatrix.cpp
// Function: main
int main()
{
    // allocate matrix
    const int ROWS = 10;
    const int COLS = 7;
    int* matrix[ROWS];
    for(int r = 0; r < ROWS; r++) {
        matrix[r] = new int[COLS];
    }

    // initialize matrix
    for(int r = 0; r < ROWS; r++) {
        for(int c = 0; c < COLS; c++) {
            matrix[r][c] = r+c;
        }
    }
    matrix[ROWS/2][COLS/2+2] = 0;

    // print and set zeros
    PrintMatrix(matrix, ROWS, COLS);
    PropogateZeros(matrix, ROWS, COLS);
    PrintMatrix(matrix, ROWS, COLS);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl $0xa, -0x8(%rbp)
movl $0x7, -0xc(%rbp)
movl $0x0, -0x64(%rbp)
cmpl $0xa, -0x64(%rbp)
jge 0x143b
movl $0x1c, %edi
callq 0x1030
movq %rax, %rcx
movslq -0x64(%rbp), %rax
movq %rcx, -0x60(%rbp,%rax,8)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x1414
movl $0x0, -0x68(%rbp)
cmpl $0xa, -0x68(%rbp)
jge 0x1483
movl $0x0, -0x6c(%rbp)
cmpl $0x7, -0x6c(%rbp)
jge 0x1476
movl -0x68(%rbp), %edx
addl -0x6c(%rbp), %edx
movslq -0x68(%rbp), %rax
movq -0x60(%rbp,%rax,8), %rax
movslq -0x6c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x144f
jmp 0x1478
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x1442
movq -0x38(%rbp), %rax
movl $0x0, 0x14(%rax)
leaq -0x60(%rbp), %rdi
movl $0xa, %esi
movl $0x7, %edx
callq 0x1340
leaq -0x60(%rbp), %rdi
movl $0xa, %esi
movl $0x7, %edx
callq 0x11e0
leaq -0x60(%rbp), %rdi
movl $0xa, %esi
movl $0x7, %edx
callq 0x1340
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: zheng-ji[P]lruCache/example.cpp
// Function: Process(int, int&)
int Process(int32_t iKey, int32_t & iValue) 
{
    static LRUCache<int32_t, int32_t> tCache(100000, 3600);
    if (tCache.GetCache(iKey, iValue) > 0)
        return 1;
    iValue = random(); // δ����cache�����в�ѯ�������õ���������cache
    tCache.UpdateCache(iKey, iValue);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpb $0x0, 0x7e42(%rip)      # 0xa1c8
jne 0x23d7
leaq 0x7e39(%rip), %rdi      # 0xa1c8
callq 0x2210
cmpl $0x0, %eax
je 0x23d7
leaq 0x7da0(%rip), %rdi      # 0xa140
movl $0x186a0, %esi          # imm = 0x186A0
movl $0xe10, %edx            # imm = 0xE10
callq 0x28a0
jmp 0x23b1
leaq 0x548(%rip), %rdi       # 0x2900
leaq 0x7d81(%rip), %rsi      # 0xa140
leaq 0x7d5a(%rip), %rdx      # 0xa120
callq 0x20f0
leaq 0x7df6(%rip), %rdi      # 0xa1c8
callq 0x20b0
movq -0x10(%rbp), %rdx
leaq 0x7d5e(%rip), %rdi      # 0xa140
leaq -0x8(%rbp), %rsi
movl $0x1, %ecx
callq 0x2930
cmpl $0x0, %eax
jle 0x2418
movl $0x1, -0x4(%rbp)
jmp 0x2440
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq 0x7db7(%rip), %rdi      # 0xa1c8
callq 0x20a0
jmp 0x2449
callq 0x2080
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdx
leaq 0x7d10(%rip), %rdi      # 0xa140
leaq -0x8(%rbp), %rsi
callq 0x2b60
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: zheng-ji[P]lruCache/example.cpp
// Function: TestCacheUpdateThread()
void TestCacheUpdateThread() 
{
    int iCnt = 10000;
    int iHit = 0;
    for (auto i = 0; i < iCnt; i++) 
    {
        int32_t iKey = random() % 200000;
        int32_t iValue = 0;
        if (Process(iKey, iValue) > 0) 
        {
            iHit++;
        }
    }
    std::cout << "Process cnt:" << iCnt << " hitcache:" << iHit << std::endl;;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x2710, -0x4(%rbp)     # imm = 0x2710
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x24c7
callq 0x2080
movl $0x30d40, %ecx          # imm = 0x30D40
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %edi
leaq -0x14(%rbp), %rsi
callq 0x2370
cmpl $0x0, %eax
jle 0x24ba
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x24bc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x247d
movq 0x7b0a(%rip), %rdi      # 0x9fd8
leaq 0x3b33(%rip), %rsi      # 0x6008
callq 0x2140
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x21f0
movq %rax, %rdi
leaq 0x3b26(%rip), %rsi      # 0x6015
callq 0x2140
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x21f0
movq %rax, %rdi
movq 0x7ab7(%rip), %rsi      # 0x9fc0
callq 0x2160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: transformNormal(vec3&, Polygon*)
vec3 transformNormal(vec3 &normal, Polygon *poly) {
	vec4 tmpNormal = vec4(normal, 1.0f);
	tmpNormal = tmpNormal * poly->inverseTranspose;
	vec3 retNormal = vec3(tmpNormal);
	return retNormal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movsd 0x214f1(%rip), %xmm0    # 0x25010
callq 0x68a0
movq -0x18(%rbp), %rdx
addq $0x170, %rdx            # imm = 0x170
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x68f0
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6950
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x69a0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: 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
subq $0x80, %rsp
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x33b0
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3360
movq %rax, -0x68(%rbp)
jmp 0x3ba1
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3340
movb %al, -0x69(%rbp)
jmp 0x3bb9
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x3bc2
jmp 0x3c06
leaq -0x40(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
callq 0x3330
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x3b8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3160
jmp 0x3c4a
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x3c38
movq -0x60(%rbp), %rsi
movq 0x2c3d7(%rip), %rdi     # 0x2fff0
callq 0x3210
movq %rax, -0x78(%rbp)
jmp 0x3c24
movq -0x78(%rbp), %rdi
movq 0x2c389(%rip), %rsi     # 0x2ffb8
callq 0x3270
jmp 0x3c36
jmp 0x3c38
leaq -0x40(%rbp), %rdi
callq 0x3160
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x33b0
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3360
movq %rax, -0x68(%rbp)
jmp 0x3ca1
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3340
movb %al, -0x69(%rbp)
jmp 0x3cb9
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x3cc2
jmp 0x3d02
leaq -0x40(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
callq 0x3440
movl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x3c8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3160
jmp 0x3d46
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x3d34
movq -0x60(%rbp), %rsi
movq 0x2c2db(%rip), %rdi     # 0x2fff0
callq 0x3210
movq %rax, -0x78(%rbp)
jmp 0x3d20
movq -0x78(%rbp), %rdi
movq 0x2c28d(%rip), %rsi     # 0x2ffb8
callq 0x3270
jmp 0x3d32
jmp 0x3d34
leaq -0x40(%rbp), %rdi
callq 0x3160
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x34f0
nop
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: reduceTransforms(std::vector<mat4, std::allocator<mat4>>*)
mat4 reduceTransforms(vector<mat4> *transforms) {
    mat4 tMatrix = identity3D();
    for (int i = 0; i < transforms->size(); i++) {
        tMatrix = tMatrix * transforms->at(i);
    }
    return tMatrix;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x6a00
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6ac0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x3e14
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x7bc0
movq -0xa8(%rbp), %rsi
movq %rax, %rdx
leaq -0x98(%rbp), %rdi
callq 0x6ae0
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x7c00
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3db0
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: logicx24[P]RayTracer/./algebra3.h
// Function: identity3D()
inline mat4 identity3D()
{   return mat4(vec4(1.0, 0.0, 0.0, 0.0),
		vec4(0.0, 1.0, 0.0, 0.0),
		vec4(0.0, 0.0, 1.0, 0.0),
		vec4(0.0, 0.0, 0.0, 1.0)); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
movsd 0x1e5e4(%rip), %xmm0    # 0x25010
xorps %xmm3, %xmm3
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x9b70
leaq -0x48(%rbp), %rdi
xorps %xmm3, %xmm3
movsd 0x1e5c7(%rip), %xmm1    # 0x25010
movaps %xmm3, %xmm0
movaps %xmm3, %xmm2
callq 0x9b70
leaq -0x68(%rbp), %rdi
xorps %xmm3, %xmm3
movsd 0x1e5ad(%rip), %xmm2    # 0x25010
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
callq 0x9b70
leaq -0x88(%rbp), %rdi
xorps %xmm2, %xmm2
movsd 0x1e590(%rip), %xmm3    # 0x25010
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x9b70
movq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x68(%rbp), %rcx
leaq -0x88(%rbp), %r8
callq 0x9c30
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %r9, -0x70(%rbp)
movq %rsi, %rax
movq -0x70(%rbp), %rsi
movq 0x20(%rbp), %r9
movq 0x18(%rbp), %r9
movq 0x10(%rbp), %r9
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x28(%rbp), %rdx
callq 0x9f30
movq -0x68(%rbp), %rdi
leaq 0x27d0d(%rip), %rax     # 0x2fc80
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1f0, %rdi            # imm = 0x1F0
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x280, %rdi            # imm = 0x280
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x298, %rdi            # imm = 0x298
callq 0x8300
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1f0, %rdi            # imm = 0x1F0
callq 0x8590
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x208, %rdi            # imm = 0x208
callq 0x8590
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x220, %rdi            # imm = 0x220
callq 0x8590
movq -0x68(%rbp), %rdx
movq %rdx, %rsi
addq $0x220, %rsi            # imm = 0x220
addq $0x1f0, %rdx            # imm = 0x1F0
leaq -0x48(%rbp), %rdi
callq 0xa040
movq -0x68(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
leaq -0x48(%rbp), %rsi
callq 0x8590
movq -0x68(%rbp), %rdx
movq %rdx, %rsi
addq $0x208, %rsi            # imm = 0x208
addq $0x1f0, %rdx            # imm = 0x1F0
leaq -0x60(%rbp), %rdi
callq 0xa040
movq -0x68(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
leaq -0x60(%rbp), %rsi
callq 0x8590
movq -0x68(%rbp), %rdi
movq 0x10(%rbp), %rsi
addq $0x268, %rdi            # imm = 0x268
callq 0x8590
movq -0x68(%rbp), %rdi
movq 0x18(%rbp), %rsi
addq $0x280, %rdi            # imm = 0x280
callq 0x8590
movq -0x68(%rbp), %rdi
movq 0x20(%rbp), %rsi
addq $0x298, %rdi            # imm = 0x298
callq 0x8590
movq -0x68(%rbp), %rax
movb $0x1, 0x2b0(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %r9, -0x70(%rbp)
movq %rsi, %rax
movq -0x70(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x28(%rbp), %rdx
callq 0x9f30
movq -0x68(%rbp), %rdi
leaq 0x27b49(%rip), %rax     # 0x2fc80
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1f0, %rdi            # imm = 0x1F0
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x280, %rdi            # imm = 0x280
callq 0x8300
movq -0x68(%rbp), %rdi
addq $0x298, %rdi            # imm = 0x298
callq 0x8300
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1f0, %rdi            # imm = 0x1F0
callq 0x8590
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x208, %rdi            # imm = 0x208
callq 0x8590
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x220, %rdi            # imm = 0x220
callq 0x8590
movq -0x68(%rbp), %rdx
movq %rdx, %rsi
addq $0x220, %rsi            # imm = 0x220
addq $0x1f0, %rdx            # imm = 0x1F0
leaq -0x48(%rbp), %rdi
callq 0xa040
movq -0x68(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
leaq -0x48(%rbp), %rsi
callq 0x8590
movq -0x68(%rbp), %rdx
movq %rdx, %rsi
addq $0x208, %rsi            # imm = 0x208
addq $0x1f0, %rdx            # imm = 0x1F0
leaq -0x60(%rbp), %rdi
callq 0xa040
movq -0x68(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
leaq -0x60(%rbp), %rsi
callq 0x8590
movq -0x68(%rbp), %rax
movb $0x0, 0x2b0(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
movq %rdi, -0x50(%rbp)
callq 0x7c70
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl $0x0, -0x14(%rbp)
movq -0x48(%rbp), %rdx
movl -0x14(%rbp), %eax
movl (%rdx), %ecx
imull 0x4(%rdx), %ecx
cmpl %ecx, %eax
jge 0x83b1
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x6860
jmp 0x837e
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7c90
jmp 0x838d
jmp 0x838f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x834d
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x82a0
jmp 0x83b7
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34f0
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: Material::Material()
Material() {
    	ka = vec3(0, 0, 0);
    	kd = vec3(0, 0, 0);
    	ks = vec3(0, 0, 0);
    	kr = 0.0f;
    	sp = 0.0f;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x8300
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0x8300
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
callq 0x8300
movq -0x70(%rbp), %rdi
addq $0x48, %rdi
callq 0x8300
leaq -0x20(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x6860
movq -0x70(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8590
leaq -0x38(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x6860
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
leaq -0x38(%rbp), %rsi
callq 0x8590
leaq -0x50(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x6860
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
leaq -0x50(%rbp), %rsi
callq 0x8590
leaq -0x68(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0xb170
movq -0x70(%rbp), %rdi
addq $0x48, %rdi
leaq -0x68(%rbp), %rsi
callq 0x8590
movq -0x70(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x60(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: Camera::Camera(vec3&, vec3&, vec3&, vec3&, vec3&, int, int)
Camera(vec3 &_eye, vec3 &_ul, vec3 &_ur, vec3 &_ll, vec3 &_lr,
	       int _width, int _height) {
	    eye = _eye;
		ul = _ul;
		ur = _ur;
		ll = _ll;
		lr = _lr;
		width = _width;
		height = _height;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x8300
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x8300
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x8300
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
callq 0x8300
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
callq 0x8300
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8590
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rdi
callq 0x8590
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x30, %rdi
callq 0x8590
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x48, %rdi
callq 0x8590
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x60, %rdi
callq 0x8590
movq -0x38(%rbp), %rax
movl 0x10(%rbp), %ecx
movl %ecx, 0x78(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x7c(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x83c0
movq -0x90(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0xa8(%rbp)
callq 0xb3b0
movq -0x90(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x8500
movq -0x90(%rbp), %rdi
addq $0xb8, %rdi
movq %rdi, -0x98(%rbp)
callq 0x8520
movq -0x90(%rbp), %rdi
addq $0xd0, %rdi
callq 0xb3d0
jmp 0x87c3
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb400
jmp 0x87d5
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq $-0x80, %rdi
callq 0xb490
jmp 0x87eb
leaq -0x50(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x6860
jmp 0x87ff
leaq -0x88(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8af0
jmp 0x8811
movq -0x90(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, 0x108(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x10c(%rax)
movl $0x6, 0x110(%rax)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x114(%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x94d0
movq -0xa0(%rbp), %rdi
callq 0x9530
movq -0xa8(%rbp), %rdi
callq 0x9590
movq -0x30(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: Material::Material(vec3&, vec3&, vec3&, vec3&, float)
Material(vec3 &_ka, vec3 &_kd, vec3 &_ks, vec3 &_kr, float _sp) {
    	ka = _ka;
    	kd = _kd;
    	ks = _ks;
    	kr = _kr;
    	sp = _sp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movss %xmm0, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x8300
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0x8300
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x8300
movq -0x38(%rbp), %rdi
addq $0x48, %rdi
callq 0x8300
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8590
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rdi
callq 0x8590
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x30, %rdi
callq 0x8590
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x48, %rdi
callq 0x8590
movq -0x38(%rbp), %rax
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0x60(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: Light::Light(vec3&, vec3&, int, bool)
Light(vec3 &_color, vec3 &_pos, int _falloff, bool _pointLight) {
    	color = _color;
    	pos = _pos;
    	falloff = _falloff;
    	pointLight = _pointLight;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x8300
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x8300
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8590
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rdi
callq 0x8590
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, 0x30(%rax)
movb -0x1d(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x34(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: Light::Light(vec3&)
Light(vec3 &ambientColor) {
    	color = ambientColor;
    	pos = vec3(0, 0, 0);
    	falloff = 0;
    	pointLight = false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x8300
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x8300
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8590
leaq -0x28(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x6860
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
leaq -0x28(%rbp), %rsi
callq 0x8590
movq -0x30(%rbp), %rax
movl $0x0, 0x30(%rax)
movb $0x0, 0x34(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: logicx24[P]RayTracer/./algebra3.h
// Function: scaling3D(vec3 const&)
inline mat4 scaling3D(const vec3& scaleVector)
{   return mat4(
		vec4(scaleVector[VX], 0.0, 0.0, 0.0),
		vec4(0.0, scaleVector[VY], 0.0, 0.0),
		vec4(0.0, 0.0, scaleVector[VZ], 0.0),
		vec4(0.0, 0.0, 0.0, 1.0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xc880
leaq -0x30(%rbp), %rdi
xorps %xmm3, %xmm3
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x9b70
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xc880
movaps %xmm0, %xmm1
leaq -0x50(%rbp), %rdi
xorps %xmm3, %xmm3
movaps %xmm3, %xmm0
movaps %xmm3, %xmm2
callq 0x9b70
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xc880
movaps %xmm0, %xmm2
leaq -0x70(%rbp), %rdi
xorps %xmm3, %xmm3
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
callq 0x9b70
leaq -0x90(%rbp), %rdi
xorps %xmm2, %xmm2
movsd 0x1c3e7(%rip), %xmm3    # 0x25010
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x9b70
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
leaq -0x90(%rbp), %r8
callq 0x9c30
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: logicx24[P]RayTracer/./algebra3.h
// Function: translation3D(vec3 const&)
inline mat4 translation3D(const vec3& v)
{   return mat4(vec4(1.0, 0.0, 0.0, v[VX]),
		vec4(0.0, 1.0, 0.0, v[VY]),
		vec4(0.0, 0.0, 1.0, v[VZ]),
		vec4(0.0, 0.0, 0.0, 1.0)); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xc880
movaps %xmm0, %xmm3
leaq -0x30(%rbp), %rdi
movsd 0x1c362(%rip), %xmm0    # 0x25010
xorps %xmm2, %xmm2
movaps %xmm2, %xmm1
callq 0x9b70
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xc880
movaps %xmm0, %xmm3
leaq -0x50(%rbp), %rdi
xorps %xmm2, %xmm2
movsd 0x1c337(%rip), %xmm1    # 0x25010
movaps %xmm2, %xmm0
callq 0x9b70
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xc880
movaps %xmm0, %xmm3
leaq -0x70(%rbp), %rdi
xorps %xmm1, %xmm1
movsd 0x1c30f(%rip), %xmm2    # 0x25010
movaps %xmm1, %xmm0
callq 0x9b70
leaq -0x90(%rbp), %rdi
xorps %xmm2, %xmm2
movsd 0x1c2f5(%rip), %xmm3    # 0x25010
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x9b70
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
leaq -0x90(%rbp), %r8
callq 0x9c30
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x108(%rax), %esi
movl 0x10c(%rax), %edx
leaq -0x18(%rbp), %rdi
callq 0xd8e0
leaq -0x20(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xd910
movq -0x80(%rbp), %rcx
movl $0x0, -0x24(%rbp)
movl 0x108(%rcx), %eax
imull 0x10c(%rcx), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd930
testb $0x1, %al
jne 0x9622
jmp 0x96b4
movq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0xd9b0
movq -0x80(%rbp), %rsi
movl 0x110(%rsi), %ecx
leaq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0xdb60
movq -0x80(%rbp), %rdi
addq $0x80, %rdi
leaq -0x20(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0xdf60
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x96a6
leaq -0x18(%rbp), %rdi
callq 0xe130
movl %eax, %esi
movq 0x2694c(%rip), %rdi     # 0x2ffc8
callq 0x34c0
movq %rax, %rdi
leaq 0x1be18(%rip), %rsi     # 0x254a3
callq 0x3220
movq %rax, %rdi
movq 0x2691e(%rip), %rsi     # 0x2ffb8
callq 0x3270
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x960c
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: logicx24[P]RayTracer/./algebra3.h
// Function: mat4::transpose() const
inline mat4 mat4::transpose() const{
    return mat4(vec4(v[0][0], v[1][0], v[2][0], v[3][0]),
		vec4(v[0][1], v[1][1], v[2][1], v[3][1]),
		vec4(v[0][2], v[1][2], v[2][2], v[3][2]),
		vec4(v[0][3], v[1][3], v[2][3], v[3][3]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
xorl %esi, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xf8(%rbp)
addq $0x20, %rdi
xorl %esi, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0x108(%rbp)
addq $0x40, %rdi
xorl %esi, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0x100(%rbp)
addq $0x60, %rdi
xorl %esi, %esi
callq 0x9bc0
movsd -0x108(%rbp), %xmm1
movsd -0x100(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xf8(%rbp), %xmm0
leaq -0x30(%rbp), %rdi
callq 0x9b70
movq -0xc0(%rbp), %rdi
movl $0x1, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xe0(%rbp)
addq $0x20, %rdi
movl $0x1, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xf0(%rbp)
addq $0x40, %rdi
movl $0x1, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xe8(%rbp)
addq $0x60, %rdi
movl $0x1, %esi
callq 0x9bc0
movsd -0xf0(%rbp), %xmm1
movsd -0xe8(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xe0(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
callq 0x9b70
movq -0xc0(%rbp), %rdi
movl $0x2, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xc8(%rbp)
addq $0x20, %rdi
movl $0x2, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xd8(%rbp)
addq $0x40, %rdi
movl $0x2, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xd0(%rbp)
addq $0x60, %rdi
movl $0x2, %esi
callq 0x9bc0
movsd -0xd8(%rbp), %xmm1
movsd -0xd0(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xc8(%rbp), %xmm0
leaq -0x70(%rbp), %rdi
callq 0x9b70
movq -0xc0(%rbp), %rdi
movl $0x3, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xa8(%rbp)
addq $0x20, %rdi
movl $0x3, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xb8(%rbp)
addq $0x40, %rdi
movl $0x3, %esi
callq 0x9bc0
movq -0xc0(%rbp), %rdi
movsd %xmm0, -0xb0(%rbp)
addq $0x60, %rdi
movl $0x3, %esi
callq 0x9bc0
movsd -0xb8(%rbp), %xmm1
movsd -0xb0(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0xa8(%rbp), %xmm0
leaq -0x90(%rbp), %rdi
callq 0x9b70
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x70(%rbp), %rcx
leaq -0x90(%rbp), %r8
callq 0x9c30
movq -0x98(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nop
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: Polygon::Polygon(mat4&, Material&)
Polygon(mat4 &_transform, Material &_mat) {
    	mat = _mat;
    	transform= _transform;
    	inverseTransform = transform.inverse();
    	inverseTranspose = inverseTransform.transpose();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
leaq 0x25d77(%rip), %rax     # 0x2fcd0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x8420
movq -0x120(%rbp), %rdi
addq $0x70, %rdi
callq 0xa790
movq -0x120(%rbp), %rdi
addq $0xf0, %rdi
callq 0xa790
movq -0x120(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0xa790
movq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rdi
callq 0xa7e0
movq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x70, %rdi
callq 0x7c00
movq -0x120(%rbp), %rsi
addq $0x70, %rsi
leaq -0x98(%rbp), %rdi
callq 0xa860
movq -0x120(%rbp), %rdi
addq $0xf0, %rdi
leaq -0x98(%rbp), %rsi
callq 0x7c00
movq -0x120(%rbp), %rsi
addq $0xf0, %rsi
leaq -0x118(%rbp), %rdi
callq 0x98f0
movq -0x120(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
leaq -0x118(%rbp), %rsi
callq 0x7c00
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: Sampler::Sampler(int, int)
Sampler(int _width, int _height) {
    	width = _width;
    	height = _height;
        x = 0;
        y = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
popq %rbp
retq
nopl (%rax)
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: Sampler::generateSample(Sample*)
bool generateSample(Sample *sample) {
        if (y == height) {
        	return false;
        }
    	sample->x = x;
    	sample->y = y;
        if (x == width - 1) {
        	x = 0;
            y++;
        } else {
        	x++;
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0xc(%rcx), %eax
cmpl 0x4(%rcx), %eax
jne 0xd952
movb $0x0, -0x1(%rbp)
jmp 0xd99c
movq -0x20(%rbp), %rcx
movl 0x8(%rcx), %edx
movq -0x18(%rbp), %rax
movl %edx, (%rax)
movl 0xc(%rcx), %edx
movq -0x18(%rbp), %rax
movl %edx, 0x4(%rax)
movl 0x8(%rcx), %eax
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xd98b
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0xd998
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x128(%rbp)
movq %rdi, %rax
movq %rax, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x120(%rbp)
movq -0x18(%rbp), %rax
cvtsi2ssl (%rax), %xmm0
cvtsi2ssl 0x78(%rsi), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cvtsi2ssl 0x4(%rax), %xmm0
cvtsi2ssl 0x7c(%rsi), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
addq $0x48, %rsi
movss 0x1761c(%rip), %xmm0    # 0x25038
subss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq -0x80(%rbp), %rdi
callq 0xb110
movq -0x120(%rbp), %rsi
addq $0x60, %rsi
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq -0x98(%rbp), %rdi
callq 0xb110
leaq -0x68(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0xb070
movss 0x175ce(%rip), %xmm0    # 0x25038
subss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb110
movq -0x120(%rbp), %rsi
addq $0x18, %rsi
movss 0x175a5(%rip), %xmm0    # 0x25038
subss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq -0xe0(%rbp), %rdi
callq 0xb110
movq -0x120(%rbp), %rsi
addq $0x30, %rsi
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq -0xf8(%rbp), %rdi
callq 0xb110
leaq -0xc8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
leaq -0xf8(%rbp), %rdx
callq 0xb070
movss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq -0xb0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xb110
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0xb070
movq -0x120(%rbp), %rdx
leaq -0x110(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa040
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rsi
leaq -0x110(%rbp), %rdx
callq 0xe170
movq -0x118(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3a40
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x67c0
movsd (%rax), %xmm0
movsd 0x17068(%rip), %xmm1    # 0x25008
ucomisd %xmm1, %xmm0
jbe 0xdfbd
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x67c0
movsd 0x1704f(%rip), %xmm0    # 0x25008
movsd %xmm0, (%rax)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x67c0
movsd (%rax), %xmm0
movsd 0x17031(%rip), %xmm1    # 0x25008
ucomisd %xmm1, %xmm0
jbe 0xdff7
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x67c0
movsd 0x17015(%rip), %xmm0    # 0x25008
movsd %xmm0, (%rax)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x67c0
movsd (%rax), %xmm0
movsd 0x16ff7(%rip), %xmm1    # 0x25008
ucomisd %xmm1, %xmm0
jbe 0xe031
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x67c0
movsd 0x16fdb(%rip), %xmm0    # 0x25008
movsd %xmm0, (%rax)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x67c0
movq -0x38(%rbp), %rcx
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq %rcx, %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
imull (%rcx), %eax
movq -0x10(%rbp), %rcx
addl (%rcx), %eax
movslq %eax, %rsi
callq 0xecb0
movq %rax, %rdi
xorl %esi, %esi
callq 0x67c0
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x67c0
movq -0x38(%rbp), %rcx
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movq %rcx, %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
imull (%rcx), %eax
movq -0x10(%rbp), %rcx
addl (%rcx), %eax
movslq %eax, %rsi
callq 0xecb0
movq %rax, %rdi
movl $0x1, %esi
callq 0x67c0
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x67c0
movq -0x38(%rbp), %rcx
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq %rcx, %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
imull (%rcx), %eax
movq -0x10(%rbp), %rcx
addl (%rcx), %eax
movslq %eax, %rsi
callq 0xecb0
movq %rax, %rdi
movl $0x2, %esi
callq 0x67c0
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: Ray::Ray(vec3&, vec3&)
Ray(vec3 &p, vec3 &v) {
		pos = p;
		vec = v;
		t_min = 0.001f;
		t_max = MAXFLOAT;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x8300
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x8300
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8590
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rdi
callq 0x8590
movq -0x20(%rbp), %rax
movss 0x16e78(%rip), %xmm0    # 0x25040
movss %xmm0, 0x30(%rax)
movss 0x16e5b(%rip), %xmm0    # 0x25030
movss %xmm0, 0x34(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0xe0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movsd 0x16d7d(%rip), %xmm0    # 0x25010
callq 0x68a0
movq -0xe0(%rbp), %rsi
addq $0xf0, %rsi
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x9740
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6950
leaq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x69a0
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x90(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x68a0
movq -0xe0(%rbp), %rsi
addq $0xf0, %rsi
leaq -0xb0(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x9740
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x6950
leaq -0xc8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movl $0x3, %edx
callq 0xe880
movq -0xd8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0xe170
movq -0xd0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movsd 0x16c29(%rip), %xmm0    # 0x25010
callq 0x68a0
movq -0x70(%rbp), %rsi
addq $0x70, %rsi
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x9740
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6950
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x69a0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x68a0
movq -0x70(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x9740
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6950
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x3, %edx
callq 0xe880
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: logicx24[P]RayTracer/./algebra3.h
// Function: vec3::vec3(vec4 const&, int)
inline vec3::vec3(const vec4& v, int dropAxis) {
    switch (dropAxis) {
	case VX: n[VX] = v.n[VY]; n[VY] = v.n[VZ]; n[VZ] = v.n[VW]; break;
	case VY: n[VX] = v.n[VX]; n[VY] = v.n[VZ]; n[VZ] = v.n[VW]; break;
	case VZ: n[VX] = v.n[VX]; n[VY] = v.n[VY]; n[VZ] = v.n[VW]; break;
	default: n[VX] = v.n[VX]; n[VY] = v.n[VY]; n[VZ] = v.n[VZ]; break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0xe8ba
jmp 0xe8a3
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0xe8ec
jmp 0xe8ad
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0xe91a
jmp 0xe948
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0xe974
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0xe974
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x18(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0xe974
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x30(%rax)
jne 0xea5c
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x7e40
jmp 0xea90
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x37a0
movq -0x28(%rbp), %rax
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movl 0x30(%rax), %edi
callq 0xc750
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xec40
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0xa0, %rdi
callq 0x9390
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xeb9d
movq -0x30(%rbp), %rdi
addq $0xa0, %rdi
movslq -0x24(%rbp), %rsi
callq 0x93e0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %al
jne 0xeb6d
jmp 0xeb90
movq -0x30(%rbp), %rdi
addq $0xa0, %rdi
movslq -0x24(%rbp), %rsi
callq 0x93e0
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
je 0xeb90
movb $0x1, -0x1(%rbp)
jmp 0xeba1
jmp 0xeb92
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xeb23
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: logicx24[P]RayTracer/raytracer.cpp
// Function: Light::lightVec(vec3&)
vec3 lightVec(vec3 &point) {
        if (pointLight) {
        	return (pos - point);
        } else {
        	return -pos;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x34(%rax)
je 0xebf4
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rdx
callq 0xa040
jmp 0xec05
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x18, %rsi
callq 0xc780
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop