LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x6ac3
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
cvtss2sd %xmm2, %xmm2
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm3
cvtss2sd %xmm3, %xmm3
leaq 0x79c0(%rip), %rdi      # 0xe471
movb $0x4, %al
callq 0x1040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6a43
leaq 0x777f(%rip), %rdi      # 0xe249
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x7991(%rip), %rdi      # 0xe48c
movb $0x0, %al
callq 0x1040
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x6b89
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
cvtss2sd %xmm2, %xmm2
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm3
cvtss2sd %xmm3, %xmm3
leaq 0x78fa(%rip), %rdi      # 0xe471
movb $0x4, %al
callq 0x1040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6b09
leaq 0x76b9(%rip), %rdi      # 0xe249
movb $0x0, %al
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_setColVec3
void mat4_setColVec3( mat4 m, vec3 v, int i ) {
	if( i >= 0 || i <= 3 ) {
        m[    i] = v.x;
        m[4 + i] = v.y;
        m[8 + i] = v.z;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x1c(%rbp)
movss %xmm1, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x6c7f
cmpl $0x3, -0x2c(%rbp)
jg 0x6cbf
movss -0xc(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x8(%rbp), %xmm0
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x4(%rbp), %xmm0
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x6cf1
cmpl $0x3, -0x1c(%rbp)
jg 0x6d48
movss -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0xc, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_setRowVec3
void mat4_setRowVec3( mat4 m, vec3 v, int i ) {
	if( i >= 0 || i <= 3 ) {
        m[i    ] = v.x;
        m[i + 1] = v.y;
        m[i + 2] = v.z;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x1c(%rbp)
movss %xmm1, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x6dcf
cmpl $0x3, -0x2c(%rbp)
jg 0x6e0f
movss -0xc(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x8(%rbp), %xmm0
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x4(%rbp), %xmm0
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_setRowVec4
void mat4_setRowVec4( mat4 m, vec4 v, int i ) {
	if( i >= 0 || i <= 3 ) {
        m[i    ] = v.x;
        m[i + 1] = v.y;
        m[i + 2] = v.z;
        m[i + 3] = v.w;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x6e41
cmpl $0x3, -0x1c(%rbp)
jg 0x6e98
movss -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xc05a(%rip), %rdi      # 0x13160
callq 0x7140
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x2c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xc05a(%rip), %rdi      # 0x131f0
callq 0x7140
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
movss 0x6e34(%rip), %xmm0     # 0xe004
movss %xmm0, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq 0xbff4(%rip), %rdi      # 0x131f0
callq 0x7140
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
movss 0x6dce(%rip), %xmm0     # 0xe004
movss %xmm0, 0x3c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_rotation
void mat4_rotation( mat4 dest, float x, float y, float z ){
    mat4 mx, my, mz, tmp;
    mat4_create(tmp);
    mat4_create(dest);
    mat4_rotx(mx, x);
    mat4_roty(my, y);
    mat4_rotz(mz, z);
    mat4_mlt( my, mx, tmp );
    mat4_mlt( mz, tmp, dest );
    //mat4_print(mx);
    //mat4_print(my);
    //mat4_print(mz);
    //mat4_print(tmp);
    //mat4_print(dest);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x6ba0
movq -0x8(%rbp), %rdi
callq 0x6ba0
leaq -0x60(%rbp), %rdi
movss -0xc(%rbp), %xmm0
callq 0x7540
leaq -0xa0(%rbp), %rdi
movss -0x10(%rbp), %xmm0
callq 0x7650
leaq -0xe0(%rbp), %rdi
movss -0x14(%rbp), %xmm0
callq 0x7760
leaq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x58a0
leaq -0xe0(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x58a0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss 0x6aab(%rip), %xmm0     # 0xe004
movss %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x4c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1240
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1080
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1080
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x1240
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x69db(%rip), %xmm0     # 0xe004
movss %xmm0, -0x14(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x7140
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movss 0x679c(%rip), %xmm0     # 0xe034
mulss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x6ae7(%rip), %xmm1     # 0xe390
mulsd %xmm1, %xmm0
movsd 0x6ad3(%rip), %xmm1     # 0xe388
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x11d0
movaps %xmm0, %xmm1
movss 0x6737(%rip), %xmm0     # 0xe004
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0xc(%rbp), %xmm0
subss -0x10(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x1c(%rbp), %xmm0
divss -0x18(%rbp), %xmm0
movss %xmm0, -0x60(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x5c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x58(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x54(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x50(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0xc(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
subss -0x10(%rbp), %xmm0
divss -0x20(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movss 0x66b5(%rip), %xmm0     # 0xe01c
mulss -0xc(%rbp), %xmm0
mulss -0x10(%rbp), %xmm0
divss -0x20(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss 0x69e9(%rip), %xmm0     # 0xe37c
movss %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x7140
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_screen
void mat4_screen( mat4 dest, float halfW, float halfH ){
    mat4 m = {
            halfW,   0.0f,  0.0f, halfW,
             0.0f,  halfH,  0.0f, halfH,
             0.0f,   0.0f,  1.0f,  0.0f,
             0.0f,   0.0f,  0.0f,  1.0f };
    mat4_copy(m, dest);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x4c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x3c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss 0x65ce(%rip), %xmm0     # 0xe004
movss %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x65a1(%rip), %xmm0     # 0xe004
movss %xmm0, -0x14(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x7140
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movss 0x5fe0(%rip), %xmm0     # 0xe004
movss %xmm0, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x804f
movss -0x4(%rbp), %xmm0
mulss -0x10(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x802f
movss -0x10(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, %al
callq 0x1370
cltq
cmpq $0x0, %rax
je 0x81ac
movb $0x0, %al
callq 0x1440
movb $0x0, %al
callq 0x1810
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movlpd %xmm2, -0x20(%rbp)
movlpd %xmm3, -0x18(%rbp)
movlpd %xmm4, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rdi)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rdi)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm4
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
movsd (%rax), %xmm2
movsd 0x8(%rax), %xmm3
callq 0x54c0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movlpd %xmm0, -0x14(%rbp)
movlpd %xmm1, -0xc(%rbp)
movups -0x14(%rbp), %xmm0
movups %xmm0, (%rdi)
movss -0x4(%rbp), %xmm4
movsd 0x10(%rdi), %xmm0
movsd 0x18(%rdi), %xmm1
movsd 0x10(%rax), %xmm2
movsd 0x18(%rax), %xmm3
callq 0x54c0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movlpd %xmm0, -0x24(%rbp)
movlpd %xmm1, -0x1c(%rbp)
movups -0x24(%rbp), %xmm0
movups %xmm0, 0x10(%rdi)
movss -0x4(%rbp), %xmm2
movsd 0x20(%rdi), %xmm0
movsd 0x20(%rax), %xmm1
callq 0x3e00
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movlpd %xmm0, -0x2c(%rbp)
movq -0x2c(%rbp), %rcx
movq %rcx, 0x20(%rdi)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x838f
movq -0x10(%rbp), %rax
leaq 0x6159(%rip), %rcx      # 0xe4a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x8397
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x8397
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x8397
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x8397
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/objloader.c
// Function: Face_Create
obj_face_t Face_Create(int n, vec3i *v){
    int i;
    obj_face_t f;
    f.vcount = n;
    f.indexes = v;
    for(i = 0; i < n; i++)
        f.indexes[i] = v[i];
    return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x841d
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x83e0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
leaq 0x654a(%rip), %rdi      # 0xe990
movb $0x0, %al
callq 0x1040
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x84aa
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
leaq 0x64fe(%rip), %rdi      # 0xe996
movb $0x0, %al
callq 0x1040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8454
leaq 0x5d98(%rip), %rdi      # 0xe249
movb $0x0, %al
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x64b5(%rip), %rdi      # 0xe990
movb $0x0, %al
callq 0x1040
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x854e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
leaq 0x645a(%rip), %rdi      # 0xe996
movb $0x0, %al
callq 0x1040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x84e9
leaq 0x5cf4(%rip), %rdi      # 0xe249
movb $0x0, %al
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8d6e
leaq 0x5e0b(%rip), %rdi      # 0xeb6d
movb $0x0, %al
callq 0x1040
jmp 0x8ef3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x100(%rax)
jne 0x8d8c
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rdi
callq 0x1278
movq -0x10(%rbp), %rax
cmpq $0x0, 0x110(%rax)
jne 0x8daa
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rdi
callq 0x1278
movq -0x10(%rbp), %rax
cmpq $0x0, 0x118(%rax)
jne 0x8dc8
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rdi
callq 0x1278
movq -0x10(%rbp), %rax
cmpq $0x0, 0x108(%rax)
jne 0x8e26
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x12c(%rcx), %eax
jge 0x8e16
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x1278
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8ddd
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdi
callq 0x1278
movq -0x10(%rbp), %rax
cmpq $0x0, 0x158(%rax)
jne 0x8e57
movq -0x10(%rbp), %rax
movq 0x158(%rax), %rax
movq (%rax), %rdi
callq 0x39a0
movq -0x10(%rbp), %rax
movq 0x158(%rax), %rdi
callq 0x1278
movq -0x10(%rbp), %rax
cmpq $0x0, 0x160(%rax)
jne 0x8e88
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rax
movq (%rax), %rdi
callq 0x39a0
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rdi
callq 0x1278
movq -0x10(%rbp), %rax
movq $0x0, 0x100(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x110(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x118(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x108(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x158(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x160(%rax)
movq -0x10(%rbp), %rdi
callq 0x1278
movq $0x0, -0x10(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x30, %edi
callq 0x11b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
movl $0x384000, %edi         # imm = 0x384000
callq 0x11b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x20(%rax)
movq -0x18(%rbp), %rax
leaq 0x13(%rip), %rcx        # 0xbd00
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/render.c
// Function: Renderer_Putpixel
void Renderer_Putpixel( SDL_Surface *surface, int x, int y, uint32_t pixel ) {
    if ( x > surface->w || x < 0 || y > surface->h || y < 0 )
        return;
    int bpp = surface->format->BytesPerPixel;
    uint8_t *p = (uint8_t *)surface->pixels + y * surface->pitch + x * bpp;
    switch(bpp) {
    case 1:
        *p = pixel;
        break;
    case 2:
        *(uint16_t *)p = pixel;
        break;
    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
            p[0] = (pixel >> 16) & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = pixel & 0xff;
        } else {
            p[0] = pixel & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = (pixel >> 16) & 0xff;
        }
        break;
    case 4:
        *(uint32_t *)p = pixel;
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jg 0xbd35
cmpl $0x0, -0xc(%rbp)
jl 0xbd35
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jg 0xbd35
cmpl $0x0, -0x10(%rbp)
jge 0xbd3a
jmp 0xbdf6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movzbl 0x11(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rax
movl -0x10(%rbp), %ecx
movl 0x18(%rdx), %edx
imull %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl -0xc(%rbp), %ecx
movl -0x18(%rbp), %edx
imull %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0xbdf6
movq -0x28(%rbp), %rax
leaq 0x2e42(%rip), %rcx      # 0xebd0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
jmp 0xbdf6
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
jmp 0xbdf6
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
jmp 0xbdf6
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/render.c
// Function: Renderer_SwitchRendState
void Renderer_SwitchRendState( renderer_t *renderer ) {
    if( renderer->flagState == RENDER_STATE_WIREFRAME ) {
        renderer->flagState = RENDER_STATE_LIT;
    } else if( renderer->flagState == RENDER_STATE_LIT ) {
        renderer->flagState = RENDER_STATE_UNLIT;
    } else if( renderer->flagState == RENDER_STATE_UNLIT ) {
        renderer->flagState = RENDER_STATE_Z_BUFFER;
    } else if( renderer->flagState == RENDER_STATE_Z_BUFFER ) {
        renderer->flagState = RENDER_STATE_WIREFRAME;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xbe1f
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0xbe68
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xbe36
movq -0x8(%rbp), %rax
movl $0x2, 0x8(%rax)
jmp 0xbe66
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0xbe4d
movq -0x8(%rbp), %rax
movl $0x3, 0x8(%rax)
jmp 0xbe64
movq -0x8(%rbp), %rax
cmpl $0x3, 0x8(%rax)
jne 0xbe62
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0xbe64
jmp 0xbe66
jmp 0xbe68
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/render.c
// Function: Renderer_ClipTriangle
int Renderer_ClipTriangle( vec4 *v ) {
	int i, res = 0;
	for( i = 0; i < 3; i++ ) {
		if( ( v[i].x < -1.0f && v[i].x > 1.0 ) &&
		    ( v[i].y < -1.0f && v[i].y > 1.0 ) &&
		    ( v[i].z <  0.0f && v[i].z > 1.0 ) )
		    res++;
	}
	return res == 3 ? 1 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0xbfb3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0x2495(%rip), %xmm0     # 0xe37c
ucomiss (%rax), %xmm0
jbe 0xbfa3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2471(%rip), %xmm1     # 0xe380
ucomisd %xmm1, %xmm0
jbe 0xbfa3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0x244c(%rip), %xmm0     # 0xe37c
ucomiss 0x4(%rax), %xmm0
jbe 0xbfa3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x242a(%rip), %xmm1     # 0xe380
ucomisd %xmm1, %xmm0
jbe 0xbfa3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
ucomiss 0x8(%rax), %xmm0
jbe 0xbfa3
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x23ec(%rip), %xmm1     # 0xe380
ucomisd %xmm1, %xmm0
jbe 0xbfa3
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbfa5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbec6
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x3, %edx
cmovel %ecx, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/render.c
// Function: Renderer_DrawWorld
void Renderer_DrawWorld( renderer_t *renderer, SDL_Surface *Surface ) {
	scene_t *scene = renderer->scene;
    SDL_FillRect( Surface, NULL, SDL_MapRGB( Surface->format, 0x00, 0x00, 0x00 ) );
    Renderer_ClearZBuffer( renderer );
    node_t *objList_node = List_Head( Scene_GetObjectList( scene ) );

    while( objList_node != NULL ) {
        Renderer_DrawObject( scene, renderer, List_Data(objList_node), Surface );
        objList_node = objList_node->next;
    }
    renderer->frameCount++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x10b0
movq -0x28(%rbp), %rdi
movl %eax, %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0xbe70
movq -0x18(%rbp), %rdi
callq 0xcb40
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc91c
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
callq 0xbfd0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc8ef
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/render.c
// Function: Renderer_Destroy
void Renderer_Destroy( renderer_t *renderer ) {
    if( renderer != NULL ) {
        free( renderer->z_Buffer );
        renderer->z_Buffer = NULL;
        printf( "\nRendered frames: %d\n", renderer->frameCount );
        free( renderer );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc97a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1278
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %esi
leaq 0x228a(%rip), %rdi      # 0xebf4
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1278
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/scene.c
// Function: Scene_Init
scene_t *Scene_Init( camera_t *camera ) {
    scene_t *scene = (scene_t *)malloc(sizeof(scene_t));
    if(scene == NULL) {
        printf( "Error: Cannot create scene!\n" );
        return NULL;
    }

    scene->objectList = (List *)malloc(sizeof(List));
    List_Init( scene->objectList, &Model_Test, &Model_Free );

    scene->mainCamera   = camera;
    scene->directLight = vec3_create( 0.0f, 5.0f, 5.0f );
	scene->directLightColor = vec3_create( 1.0f, 1.0f, 1.0f );
	scene->ambientLightColor = vec3_create( 1.0f, 1.0f, 1.0f );
    scene->currentState = SCENE_STATE_UPDATABLE;
    return scene;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl $0x40, %edi
callq 0x11b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc9bf
leaq 0x225f(%rip), %rdi      # 0xec0a
movb $0x0, %al
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0xcaf0
movl $0x28, %edi
callq 0x11b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x2263(%rip), %rsi     # 0xa780
leaq -0x3caa(%rip), %rdx     # 0x8d40
callq 0x2950
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
xorps %xmm0, %xmm0
movss 0x1620(%rip), %xmm2     # 0xe030
movaps %xmm2, %xmm1
callq 0x4270
movq -0x98(%rbp), %rax
movss %xmm1, -0x30(%rbp)
movlpd %xmm0, -0x38(%rbp)
movl -0x30(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl -0x20(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movss 0x15ac(%rip), %xmm2     # 0xe004
movss %xmm2, -0x84(%rbp)
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x4270
movq -0x90(%rbp), %rax
movss -0x84(%rbp), %xmm2
movss %xmm1, -0x50(%rbp)
movlpd %xmm0, -0x58(%rbp)
movl -0x50(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movl -0x40(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x14(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x4270
movq -0x80(%rbp), %rax
movss %xmm1, -0x70(%rbp)
movlpd %xmm0, -0x78(%rbp)
movq -0x78(%rbp), %rcx
movq %rcx, -0x64(%rbp)
movl -0x70(%rbp), %ecx
movl %ecx, -0x5c(%rbp)
movq -0x64(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl -0x5c(%rbp), %ecx
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/scene.c
// Function: Scene_FindObjectByName
obj_model_t *Scene_FindObjectByName( scene_t *scene, char *name ) {
	List        *objList = Scene_GetObjectList( scene );
	node_t      *curr    = List_Head( objList );
	obj_model_t *obj     = NULL;
	
	int isFound = FALSE;
	
	while( curr != NULL ) {
		if( strstr( Model_GetName(List_Data(curr)), name ) ) {
			isFound = TRUE;
			break;
		}
        curr = curr->next;
    }
    if(isFound){
		obj = List_Data(curr);
	} else {
		printf( "SceneWarn: Object \"%s\" not found!\n", name );
	}
	return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcb40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xcca4
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xa770
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1090
cmpq $0x0, %rax
je 0xcc96
movl $0x1, -0x2c(%rbp)
jmp 0xcca4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xcc68
cmpl $0x0, -0x2c(%rbp)
je 0xccb7
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xccc9
movq -0x10(%rbp), %rsi
leaq 0x1f65(%rip), %rdi      # 0xec27
movb $0x0, %al
callq 0x1040
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/shader.c
// Function: Shader_Vertex
vec4 Shader_Vertex( shader_t *shader, vertex_t *vert, int index ) {
	//mat4_setColVec2( &shader->var_uv, vert->uv, index );
	//mat4_setColVec4( &shader->var_nrm, vec4_byMat4( vert->normal, shader->m_it ), index );
	//mat4_setColVec4( &shader->var_pos, vec4_byMat4( vert->position, shader->m ), index );
	shader->pos[index]     = vec4_byMat4( vert->position, shader->m );
	shader->normals[index] = vec4_byMat4( vert->normal, shader->m_it );
	shader->uvs[index]     = vert->uv;
	return vec4_byMat4( vert->position, shader->mvp );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
callq 0x55d0
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %rax
movlpd %xmm0, -0x34(%rbp)
movlpd %xmm1, -0x2c(%rbp)
movups -0x34(%rbp), %xmm0
movups %xmm0, 0x100(%rax,%rcx)
movq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
subq $-0x80, %rdi
movsd 0x10(%rax), %xmm0
movsd 0x18(%rax), %xmm1
callq 0x55d0
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %rax
movlpd %xmm0, -0x44(%rbp)
movlpd %xmm1, -0x3c(%rbp)
movups -0x44(%rbp), %xmm0
movups %xmm0, 0x130(%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq 0x20(%rdx), %rdx
movq %rdx, 0x1cc(%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
addq $0xc0, %rdi
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
callq 0x55d0
movlpd %xmm0, -0x10(%rbp)
movlpd %xmm1, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/shader.c
// Function: Shader_SetMatrices
void Shader_SetMatrices( shader_t *shader, mat4 model, mat4 view, mat4 mvp ) {
	mat4 tmp;
	mat4_copy( model, shader->m );
	mat4_copy( view, shader->v );
	
	mat4_inv( shader->m, tmp );
	mat4_tsp( tmp, shader->m_it );
	
	mat4_copy( mvp, shader->mvp );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x7140
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x40, %rsi
callq 0x7140
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x59d0
leaq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x80, %rsi
callq 0x5960
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xc0, %rsi
callq 0x7140
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/phrases/phrases.c
// Function: readTimings
static void
readTimings(char *take)
    {
    double seconds;
    FILE *fp;
    char buffer[512];

    snprintf(buffer,sizeof(buffer),"%stimings",take);
    printf("looking for timing information in %s\n",buffer);

    TimingCount = 0;
    if ((fp = fopen(buffer,"r")) == 0) return;
    fscanf(fp,"%lf",&seconds);
    while (!feof(fp))
        {
        Timings[TimingCount] = seconds;
        fscanf(fp,"%lf",&seconds);
        ++TimingCount;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
leaq -0x220(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x200, %esi            # imm = 0x200
leaq 0x154b(%rip), %rdx      # 0x3351
movb $0x0, %al
callq 0x1090
leaq -0x220(%rbp), %rsi
leaq 0x1540(%rip), %rdi      # 0x335b
movb $0x0, %al
callq 0x1080
movl $0x0, 0x6b14(%rip)      # 0x8940
leaq -0x220(%rbp), %rdi
leaq 0x1547(%rip), %rsi      # 0x3381
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1e4b
jmp 0x1eb7
movq -0x18(%rbp), %rdi
leaq 0x18ff(%rip), %rsi      # 0x3755
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x10d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1e78
jmp 0x1eb7
movsd -0x10(%rbp), %xmm0
movslq 0x6abc(%rip), %rcx      # 0x8940
leaq 0x6ac5(%rip), %rax      # 0x8950
movsd %xmm0, (%rax,%rcx,8)
movq -0x18(%rbp), %rdi
leaq 0x18ba(%rip), %rsi      # 0x3755
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x1040
movl 0x6a94(%rip), %eax      # 0x8940
addl $0x1, %eax
movl %eax, 0x6a8b(%rip)      # 0x8940
jmp 0x1e61
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/phrases/phrases.c
// Function: middle
static void
middle(FILE *out)
    {
    int i;

    for (i = 0; i < PHRASE_CAPACITY; ++i)
        {
        if (comments[i] == 0) continue;
            
        if (strlen(comments[i]) > 1)
            fprintf(out,"    //%s\n",comments[i]);
        if (i < TimingCount)
            fprintf(out,"    moveTo(0,%f+TimingOffset);\n",Timings[i]);
        else
            fprintf(out,"    moveTo(0,SSS);\n");

        fprintf(out,"    nplay(0,take%d,%d);\n",takes[i],notes[i]);
        fprintf(out,"\n");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x200, -0xc(%rbp)      # imm = 0x200
jge 0x1fc1
movslq -0xc(%rbp), %rcx
leaq 0x4a55(%rip), %rax      # 0x6940
cmpq $0x0, (%rax,%rcx,8)
jne 0x1ef7
jmp 0x1fb3
movslq -0xc(%rbp), %rcx
leaq 0x4a3e(%rip), %rax      # 0x6940
movq (%rax,%rcx,8), %rdi
callq 0x1060
cmpq $0x1, %rax
jbe 0x1f32
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x4a20(%rip), %rax      # 0x6940
movq (%rax,%rcx,8), %rdx
leaq 0x1620(%rip), %rsi      # 0x354b
movb $0x0, %al
callq 0x10c0
movl -0xc(%rbp), %eax
cmpl 0x6a05(%rip), %eax      # 0x8940
jge 0x1f61
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x6a04(%rip), %rax      # 0x8950
movsd (%rax,%rcx,8), %xmm0
leaq 0x15fd(%rip), %rsi      # 0x3555
movb $0x1, %al
callq 0x10c0
jmp 0x1f73
movq -0x8(%rbp), %rdi
leaq 0x1609(%rip), %rsi      # 0x3575
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x59be(%rip), %rax      # 0x7940
movl (%rax,%rcx,4), %edx
movslq -0xc(%rbp), %rcx
leaq 0x61b0(%rip), %rax      # 0x8140
movl (%rax,%rcx,4), %ecx
leaq 0x15ef(%rip), %rsi      # 0x3589
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
leaq 0x1472(%rip), %rsi      # 0x341e
movb $0x0, %al
callq 0x10c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ed3
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/phrases/phrases.c
// Function: coda
static void
coda(FILE *out)
    {
    fprintf(out,"    closeOutput();\n");
    fprintf(out,"\n");
    fprintf(out,"    return 0;\n");
    fprintf(out,"    }\n");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x15bb(%rip), %rsi      # 0x35a2
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
leaq 0x1425(%rip), %rsi      # 0x341e
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
leaq 0x15ab(%rip), %rsi      # 0x35b6
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
leaq 0x15a8(%rip), %rsi      # 0x35c5
movb $0x0, %al
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/phrases/scanner.c
// Function: readInt
int
readInt(FILE *fp)
    {
    int x,result;
    result = fscanf(fp,"%d",&x);
    if (result == EOF)
        {
        return 0;
        }
    if (result == 0)
        {
        fprintf(stderr,"SCAN ERROR: attempt to read an integer failed\n");
        fprintf(stderr,"offending character was <%c>\n",fgetc(fp));
        exit(1);
        }
    return x;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x16bd(%rip), %rsi      # 0x3704
leaq -0x14(%rbp), %rdx
movb $0x0, %al
callq 0x1040
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x2064
movl $0x0, -0x4(%rbp)
jmp 0x20bd
cmpl $0x0, -0x18(%rbp)
jne 0x20b7
movq 0x3f87(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x168c(%rip), %rsi      # 0x3707
movb $0x0, %al
callq 0x10c0
movq 0x3f6f(%rip), %rax      # 0x5ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq -0x20(%rbp), %rdi
movl %eax, %edx
leaq 0x1690(%rip), %rsi      # 0x3736
movb $0x0, %al
callq 0x10c0
movl $0x1, %edi
callq 0x1170
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)