LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Color_Intensity
color_t Color_Intensity( color_t c, float a ) {
    if( a < 0.0f )
        return Color_Init( 0, 0, 0, 255 );
    if( a > 1.0f )
        return c;
    color_t res = Color_Init( (unsigned char)(c.r * a), (unsigned char)(c.g * a), (unsigned char)(c.b * a), c.a );
    return res;
}

// Assembly:
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1ff0
movl $0xff00, %ecx           # imm = 0xFF00
movl $0xff0000, %edx         # imm = 0xFF0000
movl $0xff000000, %eax       # imm = 0xFF000000
movl $0xff000000, %esi       # imm = 0xFF000000
jmp 0x205d
movl %edi, %eax
movl %edi, %edx
shrl $0x8, %edx
movl %edi, %ecx
shrl $0x10, %ecx
movl %edi, %esi
andl $0xff000000, %esi       # imm = 0xFF000000
ucomiss 0x6009(%rip), %xmm0     # 0x8014
ja 0x205d
movl $0xff, %edi
andl %edi, %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
andl %edi, %edx
xorps %xmm1, %xmm1
cvtsi2ss %edx, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %edx
andl %edi, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
andl %edi, %ecx
movl %ecx, %r8d
shll $0x10, %r8d
andl %edi, %edx
shll $0x8, %edx
orl %r8d, %edx
andl %edi, %eax
orl %edx, %eax
shrl $0x8, %edx
movl $0xff, %edi
andl %edi, %ecx
shll $0x10, %ecx
shll $0x8, %edx
movzwl %dx, %edx
andl %edi, %eax
orl %esi, %eax
orl %edx, %eax
orl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Color_IntensityVec3
color_t Color_IntensityVec3( color_t c, vec3 v ) {
	float x, y, z;
    x = clamp( v.x, 0.0f, 1.0f );
    y = clamp( v.y, 0.0f, 1.0f );
    z = clamp( v.z, 0.0f, 1.0f );
    color_t res = Color_Init( (unsigned char)(c.r * x), (unsigned char)(c.g * y), (unsigned char)(c.b * z), c.a );
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movss %xmm1, 0xc(%rsp)
movaps %xmm0, 0x10(%rsp)
movl %edi, %ebx
movl %edi, %r15d
shrl $0x8, %r15d
movl %edi, %r14d
shrl $0x10, %r14d
movl %edi, %ebp
andl $0xff000000, %ebp       # imm = 0xFF000000
movss 0x5f69(%rip), %xmm2     # 0x8014
xorps %xmm1, %xmm1
callq 0x47bf
movss %xmm0, 0x8(%rsp)
movaps 0x10(%rsp), %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
xorps %xmm1, %xmm1
movss 0x5f47(%rip), %xmm2     # 0x8014
callq 0x47bf
movss %xmm0, 0x10(%rsp)
xorps %xmm1, %xmm1
movss 0xc(%rsp), %xmm0
movss 0x5f2b(%rip), %xmm2     # 0x8014
callq 0x47bf
movl $0xff, %ecx
andl %ecx, %ebx
xorps %xmm1, %xmm1
cvtsi2ss %ebx, %xmm1
mulss 0x8(%rsp), %xmm1
cvttss2si %xmm1, %eax
andl %ecx, %r15d
xorps %xmm1, %xmm1
cvtsi2ss %r15d, %xmm1
mulss 0x10(%rsp), %xmm1
cvttss2si %xmm1, %edx
andl %ecx, %r14d
xorps %xmm1, %xmm1
cvtsi2ss %r14d, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %esi
andl %ecx, %esi
shll $0x10, %esi
orl %ebp, %esi
andl %ecx, %edx
shll $0x8, %edx
orl %esi, %edx
andl %ecx, %eax
orl %edx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Bitmap_CreateMap
bitmap_t *Bitmap_CreateMap( unsigned int w, unsigned int h ) {
    bitmap_t * new_image;
    new_image = (bitmap_t*)malloc( sizeof(bitmap_t) );
    color_t c = { 0, 0, 0, 0 };

    new_image->width = w;
    new_image->height = h;
    new_image->bitmap = malloc( w * h * sizeof(color_t) );

    Bitmap_FillColor( new_image, c );

    return new_image;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movl $0x10, %edi
callq 0x11a0
movq %rax, %r14
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
imull %ebp, %ebx
shlq $0x2, %rbx
movq %rbx, %rdi
callq 0x11a0
movq %rax, 0x8(%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0x220d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Bitmap_FillColor
void Bitmap_FillColor( bitmap_t *i, color_t c ) {
    unsigned int w, h;
    for( h = 0; h < i->height; h++ ) {
        for( w = 0; w < i->width; w++ ) {
            i->bitmap[ h * i->width + w ] = c;
        }
    }
}

// Assembly:
cmpl $0x0, 0x4(%rdi)
je 0x2239
xorl %eax, %eax
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x2232
xorl %edx, %edx
movq 0x8(%rdi), %r8
imull %eax, %ecx
addl %edx, %ecx
movl %esi, (%r8,%rcx,4)
incl %edx
movl (%rdi), %ecx
cmpl %ecx, %edx
jb 0x221d
incl %eax
cmpl 0x4(%rdi), %eax
jb 0x2215
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Bitmap_SetPixel
void Bitmap_SetPixel( bitmap_t *i, unsigned int x, unsigned int y, color_t c ) {
    if ( x > i->width || x < 0 || y > i->height || y < 0 )
        printf( "Warning: Try to put pixel out of image size! Bitmap size:(%d, %d), Point:(%d, %d)\n", i->width, i->height, x, y );
    else {
        int tmp = y * i->width + x ;
        i->bitmap[ tmp ] = c;
    }
}

// Assembly:
movl %edx, %r8d
movl %esi, %eax
movl (%rdi), %esi
cmpl %eax, %esi
jb 0x2404
cmpl %r8d, 0x4(%rdi)
jae 0x2417
movl 0x4(%rdi), %edx
leaq 0x5e56(%rip), %rdi      # 0x8264
movl %eax, %ecx
xorl %eax, %eax
jmp 0x1040
imull %r8d, %esi
addl %eax, %esi
movq 0x8(%rdi), %rax
movslq %esi, %rdx
movl %ecx, (%rax,%rdx,4)
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Bitmap_GetPixelUV
color_t Bitmap_GetPixelUV( bitmap_t *i, vec2 uv ) {
    //unsigned int x = i->width * (uv.x - (int)uv.x);
    //unsigned int y = i->height * (uv.y - (int)uv.y);
    //uint32_t x = (uint32_t)(i->width * uv.x) % i->width;
    //uint32_t y = (uint32_t)(i->height * uv.y) % i->height;
    uint32_t x = (uint32_t)((i->width - 1) * uv.x);
    uint32_t y = (uint32_t)((i->height -1) * uv.y);

    return i->bitmap[ (y % i->height) * i->width + x % i->width ];
}

// Assembly:
movl (%rdi), %r8d
movl 0x4(%rdi), %esi
leal -0x1(%r8), %eax
cvtsi2ss %rax, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %rcx
leal -0x1(%rsi), %eax
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movq 0x8(%rdi), %rdi
xorl %edx, %edx
divl %esi
movl %edx, %esi
imull %r8d, %esi
movl %ecx, %eax
xorl %edx, %edx
divl %r8d
addl %esi, %edx
movl (%rdi,%rdx,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Bitmap_Save
void Bitmap_Save( bitmap_t *i ) {
    FILE *output;
    if ( ( output = fopen( "image.ppm","w" ) ) == NULL )
        printf( "ERROR: Can not create or open file!\n" );
    else{
        fprintf( output, "P3\n%d %d\n255\n", i->width, i->height );
        unsigned int w, h;
        color_t c;
        for( h = 0; h < i->height; h++ ) {
            for( w = 0; w < i->width; w++ ) {
                c = i->bitmap[ h * i->width + w ];
                fprintf( output, "%d %d %d\n", c.r, c.g, c.b );
            }
        }
    }
    fclose(output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x5e25(%rip), %rdi      # 0x82b7
leaq 0x5e28(%rip), %rsi      # 0x82c1
callq 0x1180
movq %rax, %rbx
testq %rax, %rax
je 0x2513
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq 0x5e0f(%rip), %rsi      # 0x82c3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11c0
cmpl $0x0, 0x4(%r14)
je 0x251f
leaq 0x5f7a(%rip), %r15      # 0x8446
xorl %ebp, %ebp
movl (%r14), %eax
testl %eax, %eax
je 0x2509
xorl %r12d, %r12d
movq 0x8(%r14), %rsi
imull %ebp, %eax
addl %r12d, %eax
movzbl (%rsi,%rax,4), %edx
movzbl 0x1(%rsi,%rax,4), %ecx
movzbl 0x2(%rsi,%rax,4), %r8d
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x11c0
incl %r12d
movl (%r14), %eax
cmpl %eax, %r12d
jb 0x24d8
incl %ebp
cmpl 0x4(%r14), %ebp
jb 0x24ce
jmp 0x251f
leaq 0x5e20(%rip), %rdi      # 0x833a
callq 0x11f0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Bitmap_SavePPM6
void Bitmap_SavePPM6( bitmap_t *i ) {
    FILE *output;
    if ( ( output = fopen( "image1.ppm","wb" ) ) == NULL )
        printf( "ERROR: Can not create or open file!\n" );
    else{
        fprintf( output, "P6\n%d %d\n255\n", i->width, i->height );
        unsigned int w, h;
        color_t c;
        for( h = 0; h < i->height; h++ ) {
            for( w = 0; w < i->width; w++ ) {
                c = i->bitmap[ h * i->width + w ];
                unsigned char wcolor[3];
                wcolor[0] = c.r;
                wcolor[1] = c.g;
                wcolor[2] = c.b;
                fwrite(wcolor, 1, 3, output);
            }
        }
    }
    fclose(output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x5cdd(%rip), %rdi      # 0x82d1
leaq 0x5ce1(%rip), %rsi      # 0x82dc
callq 0x1180
movq %rax, %rbx
testq %rax, %rax
je 0x267d
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq 0x5cc9(%rip), %rsi      # 0x82df
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11c0
cmpl $0x0, 0x4(%r14)
je 0x2689
leaq 0xd(%rsp), %r15
movl (%r14), %eax
testl %eax, %eax
je 0x2673
xorl %r12d, %r12d
movq 0x8(%r14), %rcx
imull %ebp, %eax
addl %r12d, %eax
movzwl (%rcx,%rax,4), %edx
movb 0x2(%rcx,%rax,4), %al
movw %dx, 0xd(%rsp)
movb %al, 0xf(%rsp)
movl $0x1, %esi
movl $0x3, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1260
incl %r12d
movl (%r14), %eax
cmpl %eax, %r12d
jb 0x2638
incl %ebp
cmpl 0x4(%r14), %ebp
jb 0x262e
jmp 0x2689
leaq 0x5cb6(%rip), %rdi      # 0x833a
callq 0x11f0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Bitmap_Print
void Bitmap_Print( bitmap_t *i ) {
    unsigned int w, h, index;
    for( h = 0; h < i->height; h++ ) {
        for( w = 0; w < i->width; w++ ) {
            index = h * i->width + w;
            printf( "Pos:(%d, %d); r:%d, g:%d, b:%d, a:%d \n", w, h, i->bitmap[index].r, i->bitmap[index].g, i->bitmap[index].b, i->bitmap[index].a  );
        }
    }
    printf( " === \n" );
}

// Assembly:
cmpl $0x0, 0x4(%rdi)
je 0x271e
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5c4c(%rip), %r14      # 0x8313
xorl %ebp, %ebp
movl (%rbx), %eax
testl %eax, %eax
je 0x270d
xorl %r15d, %r15d
imull %ebp, %eax
addl %r15d, %eax
movq 0x8(%rbx), %rdx
movzbl (%rdx,%rax,4), %ecx
movzbl 0x1(%rdx,%rax,4), %r8d
movzbl 0x2(%rdx,%rax,4), %r9d
movzbl 0x3(%rdx,%rax,4), %eax
movl %eax, (%rsp)
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1040
incl %r15d
movl (%rbx), %eax
cmpl %eax, %r15d
jb 0x26d2
incl %ebp
cmpl 0x4(%rbx), %ebp
jb 0x26c9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
leaq 0x5c39(%rip), %rdi      # 0x835e
jmp 0x11f0
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec2i_neg
vec2i vec2i_neg(vec2i v1){
    vec2i v2;
    v2.x = -v1.x;
    v2.y = -v1.y;
    return v2;
}

// Assembly:
movq %rdi, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
andq %rdi, %rcx
negl %eax
subq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec2_nrm
vec2 vec2_nrm(vec2 v1){
    vec2 v2;
    float len = vec2_lng(v1);
    v2.x = v1.x / len;
    v2.y = v1.y / len;
    return v2;
}

// Assembly:
movaps %xmm0, %xmm2
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movaps %xmm3, %xmm1
mulss %xmm3, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2862
sqrtss %xmm0, %xmm0
jmp 0x2881
subq $0x28, %rsp
movaps %xmm2, 0x10(%rsp)
movaps %xmm3, (%rsp)
callq 0x1230
movaps (%rsp), %xmm3
movaps 0x10(%rsp), %xmm2
addq $0x28, %rsp
divss %xmm0, %xmm2
divss %xmm0, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
movaps %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec3i_arrayToVec3ip
vec3i *vec3i_arrayToVec3ip(int size, int *ar){
    int i;
    vec3i *v = malloc(sizeof(vec3i) * (size / 3));
    for(i = 0; i < size / 3; i++)
        v[i] = (vec3i){ar[i*3], ar[i*3+1], ar[i*3+2]};
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movslq %edi, %r15
imulq $0x55555556, %r15, %r14 # imm = 0x55555556
movq %r14, %rax
shrq $0x3f, %rax
shrq $0x20, %r14
addl %eax, %r14d
movslq %r14d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
callq 0x11a0
cmpl $0x3, %r15d
jl 0x2995
movl %r14d, %ecx
shlq $0x2, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movq (%rbx,%rdx), %rsi
movl 0x8(%rbx,%rdx), %edi
movq %rsi, (%rax,%rdx)
movl %edi, 0x8(%rax,%rdx)
addq $0xc, %rdx
cmpq %rdx, %rcx
jne 0x297c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec3i_add
vec3i vec3i_add(vec3i v1, vec3i v2){
    vec3i v3;
    v3.x = v1.x + v2.x;
    v3.y = v1.y + v2.y;
    v3.z = v1.z + v2.z;
    return v3;
}

// Assembly:
movabsq $-0x100000000, %r8      # imm = 0xFFFFFFFF00000000
leal (%rdi,%rdx), %eax
andq %r8, %rdi
addl %esi, %ecx
addq %rdx, %rdi
andq %r8, %rdi
orq %rdi, %rax
movl %ecx, %edx
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec3i_mlt
vec3i vec3i_mlt(vec3i v1,  float f){
    vec3i v3;
    v3.x = v1.x * f;
    v3.y = v1.y * f;
    v3.z = v1.z * f;
    return v3;
}

// Assembly:
cvtsi2ss %edi, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
shrq $0x20, %rdi
xorps %xmm1, %xmm1
cvtsi2ss %edi, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %esi, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %edx
shlq $0x20, %rcx
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec3i_neg
vec3i vec3i_neg(vec3i v1){
    vec3i v2;
    v2.x = -v1.x;
    v2.y = -v1.y;
    v2.z = -v1.z;
    return v2;
}

// Assembly:
movl %esi, %edx
movq %rdi, %rax
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
andq %rdi, %rcx
negl %eax
negl %edx
subq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec3_nrm
vec3 vec3_nrm(vec3 v1){
    vec3 v2;
    float len = vec3_lng(v1);
    v2.x = v1.x / len;
    v2.y = v1.y / len;
    v2.z = v1.z / len;
    return v2;
}

// Assembly:
movaps %xmm0, %xmm3
movaps %xmm0, %xmm4
shufps $0x55, %xmm0, %xmm4     # xmm4 = xmm4[1,1],xmm0[1,1]
movaps %xmm4, %xmm0
mulss %xmm4, %xmm0
movaps %xmm3, %xmm2
mulss %xmm3, %xmm2
addss %xmm0, %xmm2
movaps %xmm1, %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jb 0x2b34
sqrtss %xmm0, %xmm0
jmp 0x2b61
subq $0x38, %rsp
movss %xmm1, 0xc(%rsp)
movaps %xmm3, 0x20(%rsp)
movaps %xmm4, 0x10(%rsp)
callq 0x1230
movaps 0x10(%rsp), %xmm4
movaps 0x20(%rsp), %xmm3
movss 0xc(%rsp), %xmm1
addq $0x38, %rsp
divss %xmm0, %xmm3
divss %xmm0, %xmm4
unpcklps %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1]
divss %xmm0, %xmm1
movaps %xmm3, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec3_byMat4
vec3 vec3_byMat4(vec3 v, mat4 m){
    vec4 v2 = {m[ 0] * v.x + m[ 1] * v.y + m[ 2] * v.z + m[ 3],
               m[ 4] * v.x + m[ 5] * v.y + m[ 6] * v.z + m[ 7],
               m[ 8] * v.x + m[ 9] * v.y + m[10] * v.z + m[11],
               m[12] * v.x + m[13] * v.y + m[14] * v.z + m[15],};
    /*
    vec3 v2 = {m[ 0] * v.x + m[ 1] * v.y + m[ 2] * v.z,
               m[ 4] * v.x + m[ 5] * v.y + m[ 6] * v.z,
               m[ 8] * v.x + m[ 9] * v.y + m[10] * v.z};
    */
    return vec4_toVec3( vec4_pdiv( v2 ) );
}

// Assembly:
movss (%rdi), %xmm2
mulss %xmm0, %xmm2
movss 0x10(%rdi), %xmm3
mulss %xmm0, %xmm3
movss 0x20(%rdi), %xmm4
mulss %xmm0, %xmm4
movss 0x30(%rdi), %xmm5
mulss %xmm0, %xmm5
movaps %xmm0, %xmm6
shufps $0x55, %xmm0, %xmm6     # xmm6 = xmm6[1,1],xmm0[1,1]
movss 0x4(%rdi), %xmm0
mulss %xmm6, %xmm0
addss %xmm0, %xmm2
movss 0x8(%rdi), %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
addss 0xc(%rdi), %xmm0
movss 0x14(%rdi), %xmm2
mulss %xmm6, %xmm2
addss %xmm2, %xmm3
movss 0x18(%rdi), %xmm7
mulss %xmm1, %xmm7
addss %xmm3, %xmm7
addss 0x1c(%rdi), %xmm7
movss 0x24(%rdi), %xmm2
mulss %xmm6, %xmm2
addss %xmm2, %xmm4
movss 0x28(%rdi), %xmm2
mulss %xmm1, %xmm2
addss %xmm4, %xmm2
addss 0x2c(%rdi), %xmm2
mulss 0x34(%rdi), %xmm6
addss %xmm6, %xmm5
mulss 0x38(%rdi), %xmm1
addss %xmm5, %xmm1
addss 0x3c(%rdi), %xmm1
divss %xmm1, %xmm0
divss %xmm1, %xmm7
unpcklps %xmm7, %xmm0            # xmm0 = xmm0[0],xmm7[0],xmm0[1],xmm7[1]
divss %xmm1, %xmm2
movaps %xmm2, %xmm1
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec4_mlt
vec4 vec4_mlt(vec4 v1, float f){
    vec4 v3;
    v3.x = v1.x * f;
    v3.y = v1.y * f;
    v3.z = v1.z * f;
    v3.w = v1.w * f;
    return v3;
}

// Assembly:
movaps %xmm0, %xmm3
mulss %xmm2, %xmm3
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss %xmm2, %xmm0
unpcklps %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
movaps %xmm1, %xmm4
mulss %xmm2, %xmm4
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
mulss %xmm2, %xmm1
unpcklps %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
movaps %xmm3, %xmm0
movaps %xmm4, %xmm1
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec4_crs
vec4 vec4_crs(vec4 v1, vec4 v2){
    vec4 v3;
    v3.x = v1.y * v2.z - v1.z * v2.y;
    v3.y = v1.z * v2.x - v1.x * v2.z;
    v3.z = v1.x * v2.y - v1.y * v2.x;
    v3.w = 1;
    return v3;
}

// Assembly:
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5     # xmm5 = xmm5[1,1],xmm0[1,1]
movaps %xmm2, %xmm6
shufps $0x55, %xmm2, %xmm6     # xmm6 = xmm6[1,1],xmm2[1,1]
movaps %xmm6, %xmm7
mulss %xmm1, %xmm7
movaps %xmm5, %xmm4
mulss %xmm3, %xmm4
subss %xmm7, %xmm4
mulss %xmm0, %xmm3
mulss %xmm2, %xmm1
subss %xmm3, %xmm1
unpcklps %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
mulss %xmm2, %xmm5
mulss %xmm0, %xmm6
subss %xmm5, %xmm6
movaps 0x5545(%rip), %xmm1     # 0x8370
movss %xmm6, %xmm1            # xmm1 = xmm6[0],xmm1[1,2,3]
movaps %xmm4, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec4_byMat4
vec4 vec4_byMat4(vec4 v, mat4 m){
    vec4 v2 = {m[ 0] * v.x + m[ 1] * v.y + m[ 2] * v.z + m[ 3] * v.w,
               m[ 4] * v.x + m[ 5] * v.y + m[ 6] * v.z + m[ 7] * v.w,
               m[ 8] * v.x + m[ 9] * v.y + m[10] * v.z + m[11] * v.w,
               m[12] * v.x + m[13] * v.y + m[14] * v.z + m[15] * v.w};
    return v2;
}

// Assembly:
movss (%rdi), %xmm2
mulss %xmm0, %xmm2
movss 0x10(%rdi), %xmm3
mulss %xmm0, %xmm3
movss 0x20(%rdi), %xmm4
mulss %xmm0, %xmm4
movss 0x30(%rdi), %xmm5
mulss %xmm0, %xmm5
movaps %xmm0, %xmm6
shufps $0x55, %xmm0, %xmm6     # xmm6 = xmm6[1,1],xmm0[1,1]
movss 0x4(%rdi), %xmm0
mulss %xmm6, %xmm0
addss %xmm0, %xmm2
movss 0x8(%rdi), %xmm7
mulss %xmm1, %xmm7
addss %xmm2, %xmm7
movss 0x18(%rdi), %xmm2
mulss %xmm1, %xmm2
movss 0x28(%rdi), %xmm8
mulss %xmm1, %xmm8
movss 0x38(%rdi), %xmm9
mulss %xmm1, %xmm9
movaps %xmm1, %xmm10
shufps $0x55, %xmm1, %xmm10    # xmm10 = xmm10[1,1],xmm1[1,1]
movss 0xc(%rdi), %xmm0
mulss %xmm10, %xmm0
addss %xmm7, %xmm0
movss 0x14(%rdi), %xmm1
mulss %xmm6, %xmm1
addss %xmm1, %xmm3
addss %xmm3, %xmm2
movss 0x1c(%rdi), %xmm1
mulss %xmm10, %xmm1
addss %xmm2, %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movss 0x24(%rdi), %xmm1
mulss %xmm6, %xmm1
addss %xmm1, %xmm4
addss %xmm4, %xmm8
movss 0x2c(%rdi), %xmm1
mulss %xmm10, %xmm1
addss %xmm8, %xmm1
mulss 0x34(%rdi), %xmm6
addss %xmm6, %xmm5
addss %xmm5, %xmm9
mulss 0x3c(%rdi), %xmm10
addss %xmm9, %xmm10
unpcklps %xmm10, %xmm1           # xmm1 = xmm1[0],xmm10[0],xmm1[1],xmm10[1]
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_mlt
void mat4_mlt( mat4 m1, mat4 m2, mat4 dest ){
    int i, j, k;
    for (i = 0; i < 4; i++)
        for (j = 0; j < 4; j++)
            for(k = 0; k < 4; k++)
                dest[i * 4 + j] += m1[i * 4 + k] * m2[4 * k + j];
}

// Assembly:
xorl %eax, %eax
leaq (,%rax,4), %rcx
movq %rsi, %r8
xorl %r9d, %r9d
movq %r9, %r10
orq %rcx, %r10
movss (%rdx,%r10,4), %xmm0
xorl %r11d, %r11d
movss (%rdi,%r11), %xmm1
mulss (%r8,%r11,4), %xmm1
addss %xmm1, %xmm0
movss %xmm0, (%rdx,%r10,4)
addq $0x4, %r11
cmpq $0x10, %r11
jne 0x3111
incq %r9
addq $0x4, %r8
cmpq $0x4, %r9
jne 0x3102
incq %rax
addq $0x10, %rdi
cmpq $0x4, %rax
jne 0x30f4
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_tsp
void mat4_tsp( mat4 m1, mat4 dest ){
    int i, j;
    for (i = 0; i < 4; i++)
        for (j = 0; j < 4; j++)
            dest[i * 4 + j] = m1[i + j * 4];
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm0
movss %xmm0, (%rsi,%rcx)
addq $0x4, %rcx
cmpq $0x10, %rcx
jne 0x3150
incq %rax
addq $0x10, %rsi
addq $0x4, %rdi
cmpq $0x4, %rax
jne 0x314e
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_print
void mat4_print( mat4 m1 ){
    int i;
    for( i = 0; i < 4; i++ )
        printf( "Matrix:{ %f, %f, %f, %f )\n", m1[4*i], m1[4*i + 1], m1[4*i + 2], m1[4*i + 3] );
    printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x4a4c(%rip), %r14      # 0x84a9
xorps %xmm0, %xmm0
cvtss2sd (%rbx,%r15), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rbx,%r15), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rbx,%r15), %xmm2
xorps %xmm3, %xmm3
cvtss2sd 0xc(%rbx,%r15), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x1040
addq $0x10, %r15
cmpq $0x40, %r15
jne 0x3a5d
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_print_named
void mat4_print_named( mat4 m1 , char *name ){
    int i;
    printf("Matrix name: %s\n", name);

    for( i = 0; i < 4; i++ )
        printf( "Matrix:{ %f, %f, %f, %f )\n", m1[4*i], m1[4*i + 1], m1[4*i + 2], m1[4*i + 3] );
    printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4a0e(%rip), %rdi      # 0x84c4
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x1040
leaq 0x49e2(%rip), %r14      # 0x84a9
xorps %xmm0, %xmm0
cvtss2sd (%rbx,%r15), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rbx,%r15), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rbx,%r15), %xmm2
xorps %xmm3, %xmm3
cvtss2sd 0xc(%rbx,%r15), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x1040
addq $0x10, %r15
cmpq $0x40, %r15
jne 0x3ac7
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_setColVec4
void mat4_setColVec4( mat4 m, vec4 v, int i ) {
	if( i >= 0 || i <= 3 ) {
        m[     i] = v.x;
        m[ 4 + i] = v.y;
        m[ 8 + i] = v.z;
        m[12 + i] = v.w;
	}
}

// Assembly:
movslq %esi, %rax
movss %xmm0, (%rdi,%rax,4)
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x10(%rdi,%rax,4)
movss %xmm1, 0x20(%rdi,%rax,4)
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movss %xmm1, 0x30(%rdi,%rax,4)
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_translate
void mat4_translate( mat4 dest, float x, float y, float z){
    mat4_copy( identity_mat, dest );
    dest[3] = x;
    dest[7] = y;
    dest[11] = z;
}

// Assembly:
movaps 0x48d1(%rip), %xmm3     # 0x8520
movups %xmm3, (%rdi)
movaps 0x48d7(%rip), %xmm3     # 0x8530
movups %xmm3, 0x10(%rdi)
movaps 0x48dc(%rip), %xmm3     # 0x8540
movups %xmm3, 0x20(%rdi)
movaps 0x48e1(%rip), %xmm3     # 0x8550
movups %xmm3, 0x30(%rdi)
movss %xmm0, 0xc(%rdi)
movss %xmm1, 0x1c(%rdi)
movss %xmm2, 0x2c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_scale
void mat4_scale( mat4 dest, float x, float y, float z ){
    mat4_copy( zero_mat, dest );
    dest[0] = x;
    dest[5] = y;
    dest[10] = z;
    dest[15] = 1.0f;
}

// Assembly:
xorps %xmm3, %xmm3
movups %xmm3, (%rdi)
movups %xmm3, 0x10(%rdi)
movups %xmm3, 0x20(%rdi)
movups %xmm3, 0x30(%rdi)
movss %xmm0, (%rdi)
movss %xmm1, 0x14(%rdi)
movss %xmm2, 0x28(%rdi)
movl $0x3f800000, 0x3c(%rdi) # imm = 0x3F800000
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_uscale
void mat4_uscale( mat4 dest, float s ){
    mat4_copy( zero_mat, dest );
    dest[0] = s;
    dest[5] = s;
    dest[10] = s;
    dest[15] = 1.0f;
}

// Assembly:
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x30(%rdi)
movss %xmm0, (%rdi)
movss %xmm0, 0x14(%rdi)
movss %xmm0, 0x28(%rdi)
movl $0x3f800000, 0x3c(%rdi) # imm = 0x3F800000
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_rotationA
void mat4_rotationA( mat4 dest, float x, float y, float z, float angle ){
    float sin = sinf(angle);
    float cos = cosf(angle);

    mat4 m = {
              cos+x*x*(1-cos), x*y*(1-cos)-z*sin, x*z*(1-cos)+y*sin, 0,
            y*x*(1-cos)+z*sin,   cos+y*y*(1-cos), y*z*(1-cos)-x*sin, 0,
            z*x*(1-cos)-y*sin, z*y*(1-cos)+x*sin,   cos+z*z*(1-cos), 0,
                            0,                 0,                 0, 1 };
    mat4_copy(m, dest);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movss %xmm3, 0xc(%rsp)
movss %xmm2, 0x1c(%rsp)
movss %xmm1, 0x18(%rsp)
movss %xmm0, 0x10(%rsp)
movq %rdi, %rbx
movaps %xmm3, %xmm0
callq 0x1110
movss %xmm0, 0x14(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x10e0
movss 0x10(%rsp), %xmm7
movaps %xmm7, %xmm1
mulss %xmm7, %xmm1
movss 0x42d4(%rip), %xmm3     # 0x8014
subss %xmm0, %xmm3
mulss %xmm3, %xmm1
addss %xmm0, %xmm1
movaps %xmm7, %xmm2
movss 0x18(%rsp), %xmm10
mulss %xmm10, %xmm2
movss 0x14(%rsp), %xmm8
movaps %xmm8, %xmm6
movss 0x1c(%rsp), %xmm11
mulss %xmm11, %xmm6
mulss %xmm3, %xmm2
movaps %xmm2, %xmm5
subss %xmm6, %xmm5
movaps %xmm7, %xmm4
movaps %xmm7, %xmm9
mulss %xmm11, %xmm4
movaps %xmm8, %xmm7
movaps %xmm8, %xmm12
mulss %xmm10, %xmm7
mulss %xmm3, %xmm4
movaps %xmm4, %xmm8
addss %xmm7, %xmm8
addss %xmm6, %xmm2
movaps %xmm10, %xmm6
mulss %xmm10, %xmm6
mulss %xmm3, %xmm6
addss %xmm0, %xmm6
mulss %xmm11, %xmm10
mulss %xmm9, %xmm12
mulss %xmm3, %xmm10
movaps %xmm10, %xmm9
subss %xmm12, %xmm9
subss %xmm7, %xmm4
addss %xmm12, %xmm10
movaps %xmm11, %xmm7
mulss %xmm11, %xmm7
mulss %xmm3, %xmm7
addss %xmm0, %xmm7
movss %xmm1, (%rbx)
movss %xmm5, 0x4(%rbx)
movss %xmm8, 0x8(%rbx)
xorl %eax, %eax
movl %eax, 0xc(%rbx)
movss %xmm2, 0x10(%rbx)
movss %xmm6, 0x14(%rbx)
movss %xmm9, 0x18(%rbx)
movl %eax, 0x1c(%rbx)
movss %xmm4, 0x20(%rbx)
movss %xmm10, 0x24(%rbx)
movss %xmm7, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rbx)
movl $0x3f800000, 0x3c(%rbx) # imm = 0x3F800000
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_rotx
void mat4_rotx( mat4 dest, float r ){
    mat4 m = {
        1.0f,    0.0f,   0.0f, 0.0f,
        0.0f,  cos(r), sin(r), 0.0f,
        0.0f, -sin(r), cos(r), 0.0f,
        0.0f,    0.0f,   0.0f, 1.0f };
    mat4_copy(m, dest);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
callq 0x1250
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movsd (%rsp), %xmm0
callq 0x1080
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x1080
cvtsd2ss %xmm0, %xmm0
xorps 0x3fae(%rip), %xmm0     # 0x8150
movaps %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x1250
cvtsd2ss %xmm0, %xmm0
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, (%rbx)
xorps %xmm1, %xmm1
movups %xmm1, 0x4(%rbx)
movss 0xc(%rsp), %xmm2
movss %xmm2, 0x14(%rbx)
movss 0x8(%rsp), %xmm2
movss %xmm2, 0x18(%rbx)
movq $0x0, 0x1c(%rbx)
movaps 0x10(%rsp), %xmm2
movss %xmm2, 0x24(%rbx)
movss %xmm0, 0x28(%rbx)
movups %xmm1, 0x2c(%rbx)
movl %eax, 0x3c(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_roty
void mat4_roty( mat4 dest, float r ){
    mat4 m = {
        cos(r), 0.0f, -sin(r), 0.0f,
          0.0f, 1.0f,    0.0f, 0.0f,
        sin(r), 0.0f,  cos(r), 0.0f,
          0.0f, 0.0f,    0.0f, 1.0f };
    mat4_copy(m, dest);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
callq 0x1250
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movsd (%rsp), %xmm0
callq 0x1080
cvtsd2ss %xmm0, %xmm0
xorps 0x3f1e(%rip), %xmm0     # 0x8150
movaps %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x1080
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x1250
cvtsd2ss %xmm0, %xmm0
movss 0xc(%rsp), %xmm1
movss %xmm1, (%rbx)
xorl %eax, %eax
movl %eax, 0x4(%rbx)
movaps 0x10(%rsp), %xmm1
movss %xmm1, 0x8(%rbx)
movaps 0x4107(%rip), %xmm1     # 0x8380
movups %xmm1, 0xc(%rbx)
movl %eax, 0x1c(%rbx)
movss 0x8(%rsp), %xmm1
movss %xmm1, 0x20(%rbx)
movl %eax, 0x24(%rbx)
movss %xmm0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rbx)
movl $0x3f800000, 0x3c(%rbx) # imm = 0x3F800000
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_rotz
void mat4_rotz( mat4 dest, float r ){
    mat4 m = {
         cos(r), sin(r), 0.0f, 0.0f,
        -sin(r), cos(r), 0.0f, 0.0f,
           0.0f,   0.0f, 1.0f, 0.0f,
           0.0f,   0.0f, 0.0f, 1.0f };

    mat4_copy(m, dest);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
callq 0x1250
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movsd (%rsp), %xmm0
callq 0x1080
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x1080
cvtsd2ss %xmm0, %xmm0
xorps 0x3e60(%rip), %xmm0     # 0x8150
movaps %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x1250
cvtsd2ss %xmm0, %xmm0
movss 0xc(%rsp), %xmm1
movss %xmm1, (%rbx)
movss 0x8(%rsp), %xmm1
movss %xmm1, 0x4(%rbx)
movq $0x0, 0x8(%rbx)
movaps 0x10(%rsp), %xmm1
movss %xmm1, 0x10(%rbx)
movss %xmm0, 0x14(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, 0x28(%rbx)
movups %xmm0, 0x2c(%rbx)
movl %eax, 0x3c(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_projection
void mat4_projection( mat4 dest, float n, float f, float fov, float aspect ){
    float s = 1.0f/tanf(fov * 0.5f * M_PI / 180.0f);
    float zr = n - f;
    
    mat4 m = {
            s/aspect, 0.0f,      0.0f,        0.0f,
                0.0f,    s,      0.0f,        0.0f,
                0.0f, 0.0f, (-n-f)/zr, 2.0f*n*f/zr,
                0.0f, 0.0f,     -1.0f,        0.0f };
    mat4_copy(m, dest);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movss %xmm3, 0xc(%rsp)
movss %xmm1, 0x8(%rsp)
movaps %xmm0, 0x10(%rsp)
mulss 0x3cc3(%rip), %xmm2     # 0x802c
movq %rdi, %rbx
xorps %xmm0, %xmm0
cvtss2sd %xmm2, %xmm0
mulsd 0x4045(%rip), %xmm0     # 0x83c0
divsd 0x4045(%rip), %xmm0     # 0x83c8
cvtsd2ss %xmm0, %xmm0
callq 0x11d0
movss 0x3c80(%rip), %xmm1     # 0x8014
divss %xmm0, %xmm1
movaps 0x10(%rsp), %xmm4
movaps %xmm4, %xmm0
movss 0x8(%rsp), %xmm5
subss %xmm5, %xmm0
movaps %xmm1, %xmm2
divss 0xc(%rsp), %xmm2
movaps 0x3d96(%rip), %xmm3     # 0x8150
xorps %xmm4, %xmm3
subss %xmm5, %xmm3
divss %xmm0, %xmm3
addss %xmm4, %xmm4
mulss %xmm5, %xmm4
divss %xmm0, %xmm4
movss %xmm2, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rbx)
movss %xmm1, 0x14(%rbx)
movups %xmm0, 0x18(%rbx)
movss %xmm3, 0x28(%rbx)
movss %xmm4, 0x2c(%rbx)
movaps 0x3faa(%rip), %xmm0     # 0x83a0
movups %xmm0, 0x30(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_lookAt
void mat4_lookAt( mat4 dest, vec3 eye, vec3 center, vec3 up ){    
    vec3 f = vec3_nrm(vec3_sub(center, eye));
    vec3 r = vec3_crs(up, f);
    vec3 u = vec3_crs(f, r);

    mat4 m = {
             r.x,  u.x,  f.x, eye.x,
             r.y,  u.y,  f.y, eye.y,
             r.z,  u.z,  f.z, eye.z,
            0.0f, 0.0f, 0.0f,  1.0f };
    
    mat4_copy(m, dest);
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
movaps %xmm0, %xmm9
movq %rdi, %rbx
subps %xmm0, %xmm2
movaps %xmm0, %xmm10
shufps $0x55, %xmm0, %xmm10    # xmm10 = xmm10[1,1],xmm0[1,1]
movaps %xmm2, %xmm11
shufps $0x55, %xmm2, %xmm11    # xmm11 = xmm11[1,1],xmm2[1,1]
subss %xmm1, %xmm3
movaps %xmm11, %xmm0
mulss %xmm11, %xmm0
movaps %xmm2, %xmm6
mulss %xmm2, %xmm6
addss %xmm0, %xmm6
movaps %xmm3, %xmm0
mulss %xmm3, %xmm0
addss %xmm6, %xmm0
xorps %xmm6, %xmm6
ucomiss %xmm6, %xmm0
jb 0x4488
sqrtss %xmm0, %xmm0
jmp 0x44e9
movss %xmm3, 0xc(%rsp)
movss %xmm1, 0x8(%rsp)
movaps %xmm4, 0x50(%rsp)
movss %xmm5, 0x4(%rsp)
movaps %xmm2, 0x40(%rsp)
movaps %xmm9, 0x30(%rsp)
movaps %xmm10, 0x20(%rsp)
movaps %xmm11, 0x10(%rsp)
callq 0x1230
movaps 0x10(%rsp), %xmm11
movaps 0x20(%rsp), %xmm10
movaps 0x30(%rsp), %xmm9
movaps 0x40(%rsp), %xmm2
movss 0x4(%rsp), %xmm5
movaps 0x50(%rsp), %xmm4
movss 0x8(%rsp), %xmm1
movss 0xc(%rsp), %xmm3
divss %xmm0, %xmm2
divss %xmm0, %xmm11
divss %xmm0, %xmm3
movaps %xmm4, %xmm0
shufps $0x55, %xmm4, %xmm0     # xmm0 = xmm0[1,1],xmm4[1,1]
movaps %xmm11, %xmm6
mulss %xmm5, %xmm6
movaps %xmm2, %xmm7
mulss %xmm0, %xmm7
mulss %xmm3, %xmm0
subss %xmm6, %xmm0
movaps %xmm3, %xmm6
mulss %xmm4, %xmm6
mulss %xmm2, %xmm5
subss %xmm6, %xmm5
mulss %xmm11, %xmm4
subss %xmm7, %xmm4
movaps %xmm3, %xmm6
mulss %xmm5, %xmm6
movaps %xmm11, %xmm8
mulss %xmm4, %xmm8
subss %xmm6, %xmm8
movaps %xmm4, %xmm7
mulss %xmm2, %xmm7
movaps %xmm3, %xmm6
mulss %xmm0, %xmm6
subss %xmm7, %xmm6
movss %xmm0, (%rbx)
mulss %xmm11, %xmm0
movaps %xmm2, %xmm7
mulss %xmm5, %xmm7
subss %xmm0, %xmm7
movss %xmm8, 0x4(%rbx)
movss %xmm2, 0x8(%rbx)
movss %xmm9, 0xc(%rbx)
movss %xmm5, 0x10(%rbx)
movss %xmm6, 0x14(%rbx)
movss %xmm11, 0x18(%rbx)
movss %xmm10, 0x1c(%rbx)
movss %xmm4, 0x20(%rbx)
movss %xmm7, 0x24(%rbx)
movss %xmm3, 0x28(%rbx)
movss %xmm1, 0x2c(%rbx)
movaps 0x3e07(%rip), %xmm0     # 0x83b0
movups %xmm0, 0x30(%rbx)
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: power_f_i
float power_f_i( float x, int y ) {
    int i;
    float s = 1;
    for( i = y; i != 0; --i )
		s *= x;
    return s;
}

// Assembly:
testl %edi, %edi
je 0x4741
movaps %xmm0, %xmm1
movss 0x38dc(%rip), %xmm0     # 0x8014
mulss %xmm1, %xmm0
decl %edi
jne 0x4738
retq
movss 0x38cb(%rip), %xmm0     # 0x8014
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/main.c
// Function: main
int main(int argc, char* args[]) {
    if( Application_Init() != NULL )
		Application_Run();
	
	Application_Close();

    return 0;
}

// Assembly:
pushq %rax
xorl %eax, %eax
callq 0x137c
testl %eax, %eax
je 0x47ef
xorl %eax, %eax
callq 0x1416
xorl %eax, %eax
callq 0x1860
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/objloader.c
// Function: Vertex_Init
vertex_t Vertex_Init(vec4 pos, vec4 norm, vec2 uv){
    vertex_t vert;
    vert.position = pos;
    vert.normal   = norm;
    vert.uv       = uv;
    return vert;
}

// Assembly:
movq %rdi, %rax
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, (%rdi)
movlhps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
movups %xmm2, 0x10(%rdi)
movlps %xmm4, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/objloader.c
// Function: Vertex_Lerp
vertex_t Vertex_Lerp( vertex_t v, float value ){
    vertex_t vert;
    vert.position = vec4_lerp( vert.position, v.position, value );
    vert.normal   = vec4_lerp( vert.normal, v.normal, value );
    vert.uv       = vec2_lerp( vert.uv, v.uv, value );
    return vert;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movaps %xmm0, %xmm4
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd 0x20(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
callq 0x2f31
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, (%rbx)
movsd 0x10(%rbx), %xmm0
movsd 0x18(%rbx), %xmm1
movsd 0x30(%rsp), %xmm2
movsd 0x38(%rsp), %xmm3
movss 0xc(%rsp), %xmm4
callq 0x2f31
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x10(%rbx)
movsd 0x20(%rbx), %xmm0
movsd 0x40(%rsp), %xmm1
movss 0xc(%rsp), %xmm2
callq 0x28d0
movlps %xmm0, 0x20(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/objloader.c
// Function: Vertex_GetPositionElement
float Vertex_GetPositionElement( vertex_t v, int index ){
    switch( index ){
    case 0:
        return v.position.x;
    case 1:
        return v.position.y;
    case 2:
        return v.position.z;
    case 3:
        return v.position.w;
    default:
        return 0;
    }
}

// Assembly:
cmpl $0x3, %edi
ja 0x48dc
leaq 0x8(%rsp), %rax
movl %edi, %ecx
leaq 0x3ca4(%rip), %rdx      # 0x8560
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movss (%rax), %xmm0
retq
movss 0x8(%rax), %xmm0
retq
movss 0xc(%rax), %xmm0
retq
movss 0x4(%rax), %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/objloader.c
// Function: Face_Print
void Face_Print(obj_face_t f){
    int i;
    printf("Face:");
    for(i = 0; i <f.vcount; i++)
        printf(" %d/%d/%d", f.indexes[i].x, f.indexes[i].y, f.indexes[i].z );
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x414c(%rip), %rdi      # 0x8a50
xorl %eax, %eax
callq 0x1040
testl %ebp, %ebp
jle 0x4944
movl %ebp, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %r15
leaq 0x4136(%rip), %r14      # 0x8a56
xorl %r12d, %r12d
movl (%rbx,%r12), %esi
movl 0x4(%rbx,%r12), %edx
movl 0x8(%rbx,%r12), %ecx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
addq $0xc, %r12
cmpq %r12, %r15
jne 0x4923
movl $0xa, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/objloader.c
// Function: Face_Printp
void Face_Printp(void *_f){
    obj_face_t *f = (obj_face_t *)_f;
    int i;
    printf("Face:");
    for(i = 0; i <f->vcount; i++)
        printf(" %d/%d/%d", f->indexes[i].x, f->indexes[i].y, f->indexes[i].z );
    printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40e8(%rip), %rdi      # 0x8a50
xorl %eax, %eax
callq 0x1040
cmpl $0x0, (%rbx)
jle 0x49af
movl $0x8, %r15d
leaq 0x40d5(%rip), %r14      # 0x8a56
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movl -0x8(%rax,%r15), %esi
movl -0x4(%rax,%r15), %edx
movl (%rax,%r15), %ecx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
incq %r12
movslq (%rbx), %rax
addq $0xc, %r15
cmpq %rax, %r12
jl 0x4984
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/objloader.c
// Function: Model_Create
obj_model_t *Model_Create( const char *model_name){
    obj_model_t *model = (obj_model_t *)malloc(sizeof(obj_model_t));
    if(model == NULL){
        printf("Error: Cannot create model object '%s'\n", model_name);
        return NULL;
    }

    memcpy(model->name, model_name, MAX_NAME_LENGTH);

    model->vertCount   = 0;                                             //Allocation prepared data for model, box in that case
    model->trisCount   = 0;
    model->position    = vec3_create(0.1, 2.3, 4.5);
    model->rotation    = vec3_create(6.7, 8.9, 0.1);
    model->scale       = vec3_create(1.3, 1.6, 1.9);
    model->baseColor   = Color_Init(63, 127, 191, 255);
    model->diffmap     = NULL;
    model->normalmap   = NULL;
    model->vertices    = NULL;
    model->faces       = NULL;
    model->normals     = NULL;
    model->textcoords  = NULL;

    return model;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x170, %edi            # imm = 0x170
callq 0x11a0
testq %rax, %rax
je 0x4abc
movq %rax, %rbx
movl $0x100, %edx            # imm = 0x100
movq %rax, %rdi
movq %r14, %rsi
callq 0x1100
xorl %eax, %eax
movl %eax, 0x120(%rbx)
movl %eax, 0x12c(%rbx)
movss 0x4029(%rip), %xmm0     # 0x8a30
movss 0x4025(%rip), %xmm1     # 0x8a34
movss 0x4021(%rip), %xmm2     # 0x8a38
callq 0x2a5a
movlps %xmm0, 0x130(%rbx)
movss %xmm1, 0x138(%rbx)
movss 0x4009(%rip), %xmm0     # 0x8a3c
movss 0x4005(%rip), %xmm1     # 0x8a40
movss 0x3fed(%rip), %xmm2     # 0x8a30
callq 0x2a5a
movlps %xmm0, 0x13c(%rbx)
movss %xmm1, 0x144(%rbx)
movss 0x3fe5(%rip), %xmm0     # 0x8a44
movss 0x3fe1(%rip), %xmm1     # 0x8a48
movss 0x3fdd(%rip), %xmm2     # 0x8a4c
callq 0x2a5a
movlps %xmm0, 0x148(%rbx)
movss %xmm1, 0x150(%rbx)
movl $0x3f, %edi
movl $0x7f, %esi
movl $0xbf, %edx
movl $0xff, %ecx
callq 0x1e50
movl %eax, 0x154(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%rbx)
movups %xmm0, 0x110(%rbx)
movups %xmm0, 0x158(%rbx)
jmp 0x4acf
leaq 0x3f9d(%rip), %rdi      # 0x8a60
xorl %ebx, %ebx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/objloader.c
// Function: Model_Free
void Model_Free(void *_model){
    obj_model_t *model = (obj_model_t *)_model;
    if(model == NULL){
        printf("Warning: Free request for NULL model pointer!");
        return;
    }

    if( !model->vertices )
        free(model->vertices);
    if( !model->normals )
        free(model->normals);
    if( !model->textcoords )
        free(model->textcoords);
    if( !model->faces ){
        int i;
        for(i = 0; i < model->trisCount; i++)
            free(model->faces[i].indexes);
        free(model->faces);
    }

    if( !model->diffmap ){
        Bitmap_Free(model->diffmap->bitmap);
        free(model->diffmap);
    }
    
    if( !model->normalmap ){
        Bitmap_Free(model->normalmap->bitmap);
        free(model->normalmap);
    }

    model->vertices   = NULL;
    model->normals    = NULL;
    model->textcoords = NULL;
    model->faces      = NULL;
    model->diffmap    = NULL;
    model->normalmap  = NULL;

    free(model);
    model = NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x4e4f
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x108(%rdi)
jne 0x4df2
cmpl $0x0, 0x12c(%rbx)
jle 0x4de6
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x108(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x1288
incq %r15
movslq 0x12c(%rbx), %rax
addq $0x10, %r14
cmpq %rax, %r15
jl 0x4dc3
movq 0x108(%rbx), %rdi
callq 0x1288
leaq 0x158(%rbx), %r14
cmpq $0x0, 0x158(%rbx)
jne 0x4e10
callq 0x272a
movq (%r14), %rdi
callq 0x1288
leaq 0x100(%rbx), %r15
cmpq $0x0, 0x160(%rbx)
jne 0x4e32
callq 0x272a
movq 0x160(%rbx), %rdi
callq 0x1288
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
movups %xmm0, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1288
leaq 0x3d70(%rip), %rdi      # 0x8bc6
xorl %eax, %eax
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/raster.c
// Function: Raster_DrawLine
void Raster_DrawLine(vec4 v0, vec4 v1, SDL_Surface *image, color_t color) {
    mat4 sst;
	mat4_screen ( sst, WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2 );
    
    vec2i p0 = vec4_toVec2i( vec4_pdiv( vec4_byMat4( v0, sst ) ) );
    vec2i p1 = vec4_toVec2i( vec4_pdiv( vec4_byMat4( v1, sst ) ) );

    int x0 = p0.x;
    int y0 = p0.y;
    int x1 = p1.x;
    int y1 = p1.y;

    int deltax = abs( x1 - x0 );
    int deltay = abs( y1 - y0 );
    int signx = x0 < x1 ? 1 : -1;
    int signy = y0 < y1 ? 1 : -1;
    int error2, error = ( deltax > deltay ? deltax : -deltay ) / 2;

    while(1) {
        if( x0 >= 0 && y0 >= 0 && x0 < image->w && y0 < image->h )
            renderer_->PutPixel( image, x0, y0, Color_ToUInt32( color ) );
        if( x0 == x1 && y0 == y1 )
            break;

        error2 = error;
        if ( error2 >- deltax ){
            error -= deltay;
            x0    += signx;
        }
        if ( error2 <  deltay ){
            error += deltax;
            y0    += signy;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %rbx
movaps %xmm3, 0x40(%rsp)
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x50(%rsp), %r13
movss 0x30bb(%rip), %xmm0     # 0x8c80
movss 0x30b7(%rip), %xmm1     # 0x8c84
movq %r13, %rdi
callq 0x4400
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movq %r13, %rdi
callq 0x2f94
callq 0x2d16
callq 0x2f7f
movq %rax, %r15
movq %rax, %r12
shrq $0x20, %r12
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movq %r13, %rdi
callq 0x2f94
callq 0x2d16
callq 0x2f7f
movq %rbx, %r13
movq %rax, %r8
shrq $0x20, %r8
xorl %edi, %edi
movl %r8d, %ecx
subl %r12d, %ecx
setg %dil
xorl %edx, %edx
movl %eax, %esi
subl %r15d, %esi
setg %dl
movl %esi, %r9d
negl %r9d
cmovsl %esi, %r9d
movl %ecx, %r14d
negl %r14d
cmovsl %ecx, %r14d
leal -0x1(,%rdx,2), %esi
movl %r14d, %ecx
negl %ecx
cmpl %r14d, %r9d
cmoval %r9d, %ecx
leal -0x1(,%rdi,2), %edi
movl %ecx, %ebp
shrl $0x1f, %ebp
addl %ecx, %ebp
sarl %ebp
movl %r9d, %ebx
negl %ebx
movq %rax, 0x30(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x10(%rsp)
movl %esi, 0x8(%rsp)
movl %edi, 0x4(%rsp)
testl %r15d, %r15d
js 0x5ce2
testl %r12d, %r12d
js 0x5ce2
cmpl 0x10(%r13), %r15d
jge 0x5ce2
cmpl 0x14(%r13), %r12d
jge 0x5ce2
leaq 0x6501(%rip), %rcx      # 0xc1a8
movq (%rcx), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x40(%rsp)
movl 0xc(%rsp), %edi
callq 0x214b
movq %r13, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %eax, %ecx
callq *0x40(%rsp)
movl 0x4(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x10(%rsp), %r9d
movq 0x20(%rsp), %r8
movq 0x30(%rsp), %rax
cmpl %eax, %r15d
jne 0x5cec
cmpl %r8d, %r12d
je 0x5d24
cmpl %ebx, %ebp
movl $0x0, %edx
cmovgl %esi, %edx
movl $0x0, %ecx
cmovgl %r14d, %ecx
addl %edx, %r15d
movl %ebp, %edx
subl %ecx, %edx
cmpl %r14d, %ebp
movl $0x0, %ecx
cmovll %edi, %ecx
movl $0x0, %ebp
cmovll %r9d, %ebp
addl %ecx, %r12d
addl %edx, %ebp
jmp 0x5c8a
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/render.c
// Function: Renderer_Init
renderer_t *Renderer_Init( scene_t *scene, uint32_t rs_flag, uint32_t rt_flag ) {
    renderer_t *renderer = malloc( sizeof(renderer_t) );
    renderer->scene      = scene;
    renderer->flagState  = rs_flag;
    renderer->renderType = rt_flag;
    renderer->fog        = 0;
    renderer->fogIntence = 0.0;
    renderer->z_Buffer   = (float *)malloc(sizeof(float) * WINDOW_WIDTH * WINDOW_HEIGHT);
    renderer->frameCount = 0;
    renderer->frameTime  = 0.0;
    renderer->PutPixel   = Renderer_Putpixel;
    return renderer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl $0x30, %edi
callq 0x11a0
movq %rax, %r15
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
movl %ebx, 0xc(%rax)
xorl %ebx, %ebx
movq %rbx, 0x10(%rax)
movl $0x384000, %edi         # imm = 0x384000
callq 0x11a0
movq %rax, 0x18(%r15)
movq %rbx, 0x20(%r15)
leaq 0x12(%rip), %rax        # 0x627d
movq %rax, 0x28(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq