LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/x.c
// Function: bpress
void
bpress(XEvent *e)
{
  int btn = e->xbutton.button;
  struct timespec now;
  MouseShortcut *ms;
  MouseKey *mk;
  int snap;

  if (1 <= btn && btn <= 11)
    buttons |= 1 << (btn-1);

  if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
    mousereport(e);
    return;
  }

  for (mk = mkeys; mk < mkeys + LEN(mkeys); mk++) {
    if (e->xbutton.button == mk->b
        && match(mk->mask, e->xbutton.state)) {
      mk->func(&mk->arg);
      return;
    }
  }

  if (mouseaction(e, 0))
    return;

  if (btn == Button1) {
    /*
     * If the user clicks below predefined timeouts specific
     * snapping behaviour is exposed.
     */
    clock_gettime(CLOCK_MONOTONIC, &now);
    if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout) {
      snap = SNAP_LINE;
    } else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout) {
      snap = SNAP_WORD;
    } else {
      snap = 0;
    }
    xsel.tclick2 = xsel.tclick1;
    xsel.tclick1 = now;

    selstart(evcol(e), evrow(e), snap);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x54(%rdi), %r14d
leal -0x1(%r14), %ecx
cmpl $0xa, %ecx
ja 0xf0c5
pushq $0x1
popq %rax
shll %cl, %eax
orl %eax, 0x11dcb(%rip)     # 0x20e90
movzwl 0x11c68(%rip), %eax     # 0x20d34
testw $0xc018, %ax            # imm = 0xC018
je 0xf0e8
testb $0x1, 0x50(%rbx)
jne 0xf0e8
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xf8f7
xorl %eax, %eax
leaq 0xf21f(%rip), %rcx      # 0x1e310
movl $0xffff9fef, %edx       # imm = 0xFFFF9FEF
cmpq $0x2f, %rax
ja 0xf122
cmpl (%rax,%rcx), %r14d
jne 0xf11c
movl 0x4(%rax,%rcx), %esi
cmpl $-0x1, %esi
je 0xf1d1
movl 0x50(%rbx), %edi
andl %edx, %edi
cmpl %esi, %edi
je 0xf1d1
addq $0x18, %rax
jmp 0xf0f6
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfab0
cmpl $0x1, %r14d
jne 0xf220
testl %eax, %eax
jne 0xf220
pushq $0x1
popq %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x6150
movq (%r14), %rax
movq %rax, %rcx
subq 0x11cb7(%rip), %rcx     # 0x20e10
imulq $0x3e8, %rcx, %rcx      # imm = 0x3E8
cvtsi2sd %rcx, %xmm0
movq 0x8(%r14), %rcx
movq %rcx, %rdx
subq 0x11ca5(%rip), %rdx     # 0x20e18
cvtsi2sd %rdx, %xmm1
divsd 0x1e88(%rip), %xmm1     # 0x11008
addsd %xmm0, %xmm1
movsd 0x6ae4(%rip), %xmm0     # 0x15c70
ucomisd %xmm1, %xmm0
jae 0xf1e5
subq 0x11c67(%rip), %rax     # 0x20e00
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
cvtsi2sd %rax, %xmm0
subq 0x11c5c(%rip), %rcx     # 0x20e08
cvtsi2sd %rcx, %xmm1
divsd 0x1e4f(%rip), %xmm1     # 0x11008
addsd %xmm0, %xmm1
movsd 0x6ab3(%rip), %xmm0     # 0x15c78
xorl %ebp, %ebp
ucomisd %xmm1, %xmm0
setae %bpl
jmp 0xf1e8
leaq (%rax,%rcx), %rdi
addq $0x10, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmpq *0x8(%rax,%rcx)
pushq $0x2
popq %rbp
movups 0x11c11(%rip), %xmm0    # 0x20e00
movups %xmm0, 0x11c1a(%rip)    # 0x20e10
movups (%rsp), %xmm0
movups %xmm0, 0x11bff(%rip)    # 0x20e00
movq %rbx, %rdi
callq 0xfb3d
movl %eax, %r14d
movq %rbx, %rdi
callq 0xfb61
movl %r14d, %edi
movl %eax, %esi
movl %ebp, %edx
callq 0x6dca
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/x.c
// Function: brelease
void
brelease(XEvent *e)
{
  int btn = e->xbutton.button;

  if (1 <= btn && btn <= 11)
    buttons &= ~(1 << (btn-1));

  if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
    mousereport(e);
    return;
  }

  if (mouseaction(e, 1))
    return;
  if (btn == Button1)
    mousesel(e, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x54(%rdi), %r14d
leal -0x1(%r14), %ecx
cmpl $0xa, %ecx
ja 0xf248
pushq $-0x2
popq %rax
roll %cl, %eax
andl %eax, 0x11c48(%rip)     # 0x20e90
movzwl 0x11ae5(%rip), %eax     # 0x20d34
testw $0xc018, %ax            # imm = 0xC018
je 0xf26a
testb $0x1, 0x50(%rbx)
jne 0xf26a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf8f7
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xfab0
cmpl $0x1, %r14d
jne 0xf291
testl %eax, %eax
jne 0xf291
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfba0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/x.c
// Function: focus
void
focus(XEvent *ev)
{
  XFocusChangeEvent *e = &ev->xfocus;

  if (e->mode == NotifyGrab)
    return;

  if (ev->type == FocusIn) {
    if (xw.ime.xic)
      XSetICFocus(xw.ime.xic);
    win.mode |= MODE_FOCUSED;
    xseturgency(0);
    if (IS_SET(MODE_FOCUS))
      ttywrite("\033[I", 3, 0);
    if (!is_focused) {
        is_focused = 1;
        xloadcols();
        redraw();
    }
  } else {
    if (xw.ime.xic)
      XUnsetICFocus(xw.ime.xic);
    win.mode &= ~MODE_FOCUSED;
    if (IS_SET(MODE_FOCUS))
      ttywrite("\033[O", 3, 0);
    if (is_focused) {
      is_focused = 0;
      xloadcols();
      redraw();
    }
  }
}

// Assembly:
pushq %rbx
cmpl $0x1, 0x28(%rdi)
jne 0xf2c1
popq %rbx
retq
movl (%rdi), %ebx
movq 0x11986(%rip), %rdi     # 0x20c50
cmpl $0x9, %ebx
je 0xf30c
testq %rdi, %rdi
je 0xf2d9
callq 0x6410
movl 0x11a55(%rip), %eax     # 0x20d34
movl %eax, %ecx
andl $-0x3, %ecx
movl %ecx, 0x11a4a(%rip)     # 0x20d34
btl $0xd, %eax
jae 0xf301
leaq 0x6cc3(%rip), %rdi      # 0x15fba
pushq $0x3
popq %rsi
xorl %edx, %edx
callq 0x7a9b
cmpb $0x0, 0x11a00(%rip)     # 0x20d08
jne 0xf2bf
jmp 0xf34b
testq %rdi, %rdi
je 0xf316
callq 0x66d0
orb $0x2, 0x11a17(%rip)     # 0x20d34
xorl %edi, %edi
callq 0xcc0b
testb $0x20, 0x11a0a(%rip)    # 0x20d35
je 0xf33e
leaq 0x751b(%rip), %rdi      # 0x1684f
pushq $0x3
popq %rsi
xorl %edx, %edx
callq 0x7a9b
cmpb $0x0, 0x119c3(%rip)     # 0x20d08
je 0xf2bf
cmpl $0x9, %ebx
setne 0x119b3(%rip)           # 0x20d08
callq 0xb4d8
popq %rbx
jmp 0x8ca7
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/x.c
// Function: propnotify
void
propnotify(XEvent *e)
{
  XPropertyEvent *xpev;
  Atom clipboard = XInternAtom(xw.dpy, "CLIPBOARD", 0);

  xpev = &e->xproperty;
  if (xpev->state == PropertyNewValue &&
      (xpev->atom == XA_PRIMARY ||
       xpev->atom == clipboard)) {
    selnotify(e);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x11813(%rip), %rdi     # 0x20bc8
leaq 0x6ccf(%rip), %rsi      # 0x1608b
xorl %edx, %edx
callq 0x6800
cmpl $0x0, 0x38(%rbx)
jne 0xf3d8
movq 0x28(%rbx), %rcx
cmpq $0x1, %rcx
je 0xf3da
cmpq %rax, %rcx
je 0xf3da
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0xf576
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/x.c
// Function: zoomabs
void
zoomabs(const Arg *arg)
{
  xunloadfonts();
  xloadfonts(usedfont, arg->f);
  xloadsparefonts();
  cresize(0, 0);
  redraw();
  xhints();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xd0bc
movq 0x114d3(%rip), %rdi     # 0x20da8
cvtss2sd (%rbx), %xmm0
callq 0xd11d
callq 0xe8e4
xorl %edi, %edi
xorl %esi, %esi
callq 0xd449
callq 0x8ca7
popq %rbx
jmp 0xecbd
// File: /workspace/github_c_makefile_star2_O2/mcaimi[P]st/x.c
// Function: mouseaction
static int
mouseaction(XEvent *e, uint release)
{
  MouseShortcut *ms;

  /* ignore Button<N>mask for Button<N> - it's set on release */
  uint state = e->xbutton.state & ~buttonmask(e->xbutton.button);

  for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) {
    if (ms->release == release && e->xbutton.button == ms->button && 
        (match(ms->mask, state) ||  /* exact or forced */
         match(ms->mask, state & ~forcemousemod))) {
      ms->func(&(ms->arg));
      return 1;
    }
  }

  return 0;
}

// Assembly:
movl 0x50(%rdi), %eax
movl 0x54(%rdi), %ecx
leal -0x1(%rcx), %edx
cmpl $0x4, %edx
jae 0xfacc
movl %edx, %edx
leaq 0x61f9(%rip), %rdi      # 0x15cc0
movl (%rdi,%rdx,4), %edx
jmp 0xfadc
xorl %edx, %edx
cmpl $0x5, %ecx
setne %dl
negl %edx
orl $0xffffefff, %edx       # imm = 0xFFFFEFFF
andl %eax, %edx
movl %edx, %edi
andl $0xffff9fef, %edi       # imm = 0xFFFF9FEF
andl $0xffff9fee, %edx       # imm = 0xFFFF9FEE
xorl %eax, %eax
leaq 0xeaab(%rip), %r8       # 0x1e5a0
xorl %r9d, %r9d
cmpq $0x9f, %r9
ja 0xfb3c
cmpl %esi, 0x18(%r9,%r8)
jne 0xfb23
cmpl (%r9,%r8), %ecx
jne 0xfb23
movl 0x4(%r9,%r8), %r10d
cmpl $-0x1, %r10d
je 0xfb29
cmpl %r10d, %edi
je 0xfb29
cmpl %r10d, %edx
je 0xfb29
addq $0x20, %r9
jmp 0xfaf8
pushq %rax
leaq (%r9,%r8), %rdi
addq $0x10, %rdi
callq *-0x8(%rdi)
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/application.c
// Function: Application_Init
int Application_Init() {	
	printf( "Application Init: Start\n");
	int success = TRUE;

    if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
        printf( "SDL could not be initialized! SDL_Error: %s\n", SDL_GetError() );
        success = FALSE;
    } else {
        gWindow = SDL_CreateWindow( "Software Renderer", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_SHOWN );
        if( gWindow == NULL ) {
            printf( "Window could not be created! SDL_Error: %s\n", SDL_GetError() );
            success = FALSE;
        } else {
            gScreenSurface = SDL_GetWindowSurface( gWindow );
        }
    }
	printf( "Application Init: Success\n");
	return success;
}

// Assembly:
pushq %rbx
leaq 0x5d37(%rip), %rdi      # 0x70cb
callq 0x1200
pushq $0x20
popq %rdi
callq 0x1120
testl %eax, %eax
js 0x13ea
leaq 0x5cd1(%rip), %rdi      # 0x707d
pushq $0x4
popq %r9
movl $0x1fff0000, %esi       # imm = 0x1FFF0000
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
movl $0x500, %ecx            # imm = 0x500
movl $0x2d0, %r8d            # imm = 0x2D0
callq 0x1050
movq %rax, 0xadaf(%rip)      # 0xc180
testq %rax, %rax
je 0x13f8
movq %rax, %rdi
callq 0x11a0
movq %rax, 0xada3(%rip)      # 0xc188
pushq $0x1
popq %rbx
jmp 0x1410
callq 0x10f0
leaq 0x5c5a(%rip), %rdi      # 0x7050
jmp 0x1404
callq 0x10f0
leaq 0x5c8b(%rip), %rdi      # 0x708f
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x1040
leaq 0x5ccc(%rip), %rdi      # 0x70e3
callq 0x1200
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/application.c
// Function: IH_ProcessInput
void IH_ProcessInput( SDL_Event e, renderer_t *renderer ) {
	uint8_t *keystate = SDL_GetKeyboardState(NULL);
	if( keystate[SDL_SCANCODE_W] ) {
		moveDirection[0] = 1;
	}
    if( keystate[SDL_SCANCODE_S] ) {
		moveDirection[0] = -1;
	}
	if( keystate[SDL_SCANCODE_D] ) {
		moveDirection[1] = 1;
	}
    if( keystate[SDL_SCANCODE_A] ) {
		moveDirection[1] = -1;
	}
	
	while( SDL_PollEvent( &e ) != 0 ) {
        if( e.type == SDL_QUIT ) {
            quit = TRUE;
        } else {
            IH_Handle(e, renderer);
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x1280
cmpb $0x0, 0x1a(%rax)
je 0x173e
movl $0x1, 0xaa3a(%rip)      # 0xc178
cmpb $0x0, 0x16(%rax)
je 0x174b
orl $-0x1, 0xaa2d(%rip)     # 0xc178
cmpb $0x0, 0x7(%rax)
je 0x175b
movl $0x1, 0xaa21(%rip)      # 0xc17c
cmpb $0x0, 0x4(%rax)
je 0x1768
orl $-0x1, 0xaa14(%rip)     # 0xc17c
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x10c0
testl %eax, %eax
je 0x17b5
movl (%r14), %eax
cmpl $0x300, %eax            # imm = 0x300
je 0x1796
cmpl $0x100, %eax            # imm = 0x100
jne 0x176d
movl $0x1, 0xa9dc(%rip)      # 0xc170
jmp 0x176d
movl 0x14(%r14), %eax
cmpl $0x72, %eax
je 0x17ab
cmpl $0x71, %eax
je 0x178a
cmpl $0x1b, %eax
jne 0x176d
jmp 0x178a
movq %rbx, %rdi
callq 0x5b1d
jmp 0x176d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/application.c
// Function: UpdateScene
void UpdateScene( renderer_t *renderer, float delta ) {
	//vec3 light_new_pos = vec3_create( 5.0f * cosf(elapsed_time * 2.0f), renderer->scene->directLight.y, renderer->scene->directLight.z );
	//vec3 light_new_pos = vec3_byMat4( renderer->scene->directLight, mat4_roty(delta * 1.0f) );
	//renderer->scene->directLight = light_new_pos;
	
	obj_model_t *model = Scene_FindObjectByName( renderer->scene, "monkey" );
	if( model != NULL )
		Model_AddRotation( model, vec3_create( 0.0f, 0.25f * delta, 0.0f ) );
	
	
	int f = moveDirection[0]; // 1 - Forward; -1 - Backward;
	int r = moveDirection[1]; // 1 - Right;   -1 - Left;
	
	if(f){
		if(f > 0)
			Camera_ProcMovement( renderer->scene->mainCamera, 1, delta );
		else
			Camera_ProcMovement( renderer->scene->mainCamera, 2, delta );
	}
	if(r){
		if(r > 0)
			Camera_ProcMovement( renderer->scene->mainCamera, 3, delta );
		else
			Camera_ProcMovement( renderer->scene->mainCamera, 4, delta );
	}
	moveDirection[0] = 0;
	moveDirection[1] = 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x58ec(%rip), %rsi      # 0x70c4
callq 0x61d3
testq %rax, %rax
je 0x1806
movq %rax, %r14
movss 0x5847(%rip), %xmm1     # 0x7034
mulss 0xc(%rsp), %xmm1
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
callq 0x2911
movq %r14, %rdi
callq 0x51b9
movl 0xa970(%rip), %ebp      # 0xc17c
cmpl $0x0, 0xa965(%rip)      # 0xc178
je 0x182e
movq (%rbx), %rax
movq (%rax), %rdi
setle %al
movzbl %al, %esi
incl %esi
movss 0xc(%rsp), %xmm0
callq 0x1c34
testl %ebp, %ebp
movss 0xc(%rsp), %xmm0
je 0x184c
movq (%rbx), %rax
movq (%rax), %rdi
setle %al
movzbl %al, %esi
addl $0x3, %esi
callq 0x1c34
andq $0x0, 0xa924(%rip)      # 0xc178
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/application.c
// Function: Application_Close
void Application_Close() {
	printf( "Application Close\n");
	SceneCleanUp();
	
	SDL_DestroyWindow( gWindow );
	gWindow = NULL;
	
	SDL_Quit();
}

// Assembly:
pushq %rax
leaq 0x58c5(%rip), %rdi      # 0x712a
callq 0x1200
movq 0xa91f(%rip), %rdi      # 0xc190
callq 0x622c
movq 0xa91b(%rip), %rdi      # 0xc198
callq 0x60b0
movq 0xa8f7(%rip), %rdi      # 0xc180
callq 0x1030
andq $0x0, 0xa8ea(%rip)      # 0xc180
popq %rax
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/camera.c
// Function: Camera_Init
camera_t *Camera_Init( vec3 pos, vec3 up, float yaw, float pitch, float fov, float aspect, float near, float far, float speed ) {
    camera_t *cam   = ( camera_t * )malloc( sizeof(camera_t) );
    cam->position   = pos;
    cam->up         = up;
    cam->right      = vec3_crs( cam->front, cam->up );
    cam->worldUp    = up;
    cam->yaw        = yaw;
    cam->pitch      = pitch;
    cam->fov        = fov;
    cam->aspect     = aspect;
    cam->near       = near;
    cam->far        = far;
    cam->speed      = speed;
    Camera_UpdateVectors( cam );
    mat4_projection( cam->projection, cam->near, cam->far, cam->fov, cam->aspect );
    return cam;
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movss %xmm7, 0x1c(%rsp)
movss %xmm6, 0x18(%rsp)
movss %xmm5, 0x20(%rsp)
movss %xmm4, 0xc(%rsp)
movss %xmm3, 0x14(%rsp)
movaps %xmm2, 0x40(%rsp)
movss %xmm1, 0x10(%rsp)
movaps %xmm0, 0x30(%rsp)
movl $0x98, %edi
callq 0x11b0
movq %rax, %rbx
movaps 0x30(%rsp), %xmm0
movlps %xmm0, (%rax)
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x8(%rax)
movaps 0x40(%rsp), %xmm2
movss 0x14(%rsp), %xmm3
callq 0x2958
movaps 0x40(%rsp), %xmm0
movlps %xmm0, 0x30(%rbx)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x38(%rbx)
movss 0xc(%rsp), %xmm1
movss %xmm1, 0x7c(%rbx)
movss 0x20(%rsp), %xmm0
movss %xmm0, 0x80(%rbx)
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x84(%rbx)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x88(%rbx)
movss 0x60(%rsp), %xmm0
movss %xmm0, 0x8c(%rbx)
movss 0x68(%rsp), %xmm0
movss %xmm0, 0x90(%rbx)
movss 0x70(%rsp), %xmm0
movss %xmm0, 0x94(%rbx)
movaps %xmm1, %xmm0
callq 0x40f6
callq 0x10e0
movss %xmm0, 0x10(%rsp)
movss 0x20(%rsp), %xmm0
callq 0x40f6
callq 0x10e0
mulss 0x10(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x20(%rsp), %xmm0
callq 0x40f6
callq 0x1110
movss %xmm0, 0x30(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x40f6
callq 0x1110
movss %xmm0, 0xc(%rsp)
movss 0x20(%rsp), %xmm0
callq 0x40f6
callq 0x10e0
movss 0xc(%rsp), %xmm2
mulss %xmm0, %xmm2
movss 0x10(%rsp), %xmm0
movss 0x30(%rsp), %xmm1
callq 0x2911
callq 0x29aa
movss %xmm1, 0xc(%rsp)
movaps %xmm0, 0x20(%rsp)
movlps %xmm0, 0xc(%rbx)
movss %xmm1, 0x14(%rbx)
movaps 0x40(%rsp), %xmm2
movss 0x14(%rsp), %xmm3
callq 0x2958
callq 0x29aa
movlps %xmm0, 0x24(%rbx)
movss %xmm1, 0x2c(%rbx)
movaps 0x20(%rsp), %xmm2
movss 0xc(%rsp), %xmm3
callq 0x2958
callq 0x29aa
movlps %xmm0, 0x18(%rbx)
movss %xmm1, 0x20(%rbx)
leaq 0x3c(%rbx), %rdi
movss 0x60(%rsp), %xmm0
movss 0x68(%rsp), %xmm1
movss 0x18(%rsp), %xmm2
movss 0x1c(%rsp), %xmm3
callq 0x3dee
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/camera.c
// Function: Camera_PrintInfo
void Camera_PrintInfo ( camera_t *cam ) {
    printf("Position: "); vec3_print(cam->position);
    printf("Front: ");    vec3_print(cam->front);
    printf("Up: ");       vec3_print(cam->up);
    printf("Right: ");    vec3_print(cam->right);
    
    printf("Fov: %f; Aspect: %f\n", cam->fov, cam->aspect);
    printf("Projection Matrix:\n"); mat4_print(cam->projection);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6035(%rip), %rdi      # 0x7bc6
xorl %eax, %eax
callq 0x1040
movsd (%rbx), %xmm0
movss 0x8(%rbx), %xmm1
callq 0x2b47
leaq 0x55c3(%rip), %rdi      # 0x7170
xorl %eax, %eax
callq 0x1040
movsd 0xc(%rbx), %xmm0
movss 0x14(%rbx), %xmm1
callq 0x2b47
leaq 0x55ae(%rip), %rdi      # 0x7178
xorl %eax, %eax
callq 0x1040
movsd 0x18(%rbx), %xmm0
movss 0x20(%rbx), %xmm1
callq 0x2b47
leaq 0x5596(%rip), %rdi      # 0x717d
xorl %eax, %eax
callq 0x1040
movsd 0x24(%rbx), %xmm0
movss 0x2c(%rbx), %xmm1
callq 0x2b47
cvtss2sd 0x84(%rbx), %xmm0
cvtss2sd 0x88(%rbx), %xmm1
leaq 0x5571(%rip), %rdi      # 0x7185
movb $0x2, %al
callq 0x1040
leaq 0x5578(%rip), %rdi      # 0x719a
callq 0x1200
addq $0x3c, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x37af
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/camera.c
// Function: Camera_ProcMovement
void Camera_ProcMovement ( camera_t *cam, int m_type, float delta ) {
    vec3  move, front, right;
    float speed_value = cam->speed * delta;
    switch( m_type ){
    case 1:
        move = vec3_mlt( cam->front, speed_value );
        break;

    case 2:
        move = vec3_mlt( cam->front, -speed_value );
        break;

    case 3:
        move = vec3_mlt( cam->right, speed_value );
        break;

    case 4:
        move = vec3_mlt( cam->right, -speed_value );
        break;
    }
    Camera_AddPosition( cam, move );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
decl %esi
cmpl $0x3, %esi
ja 0x1c9a
movaps %xmm0, %xmm2
mulss 0x94(%rbx), %xmm2
leaq 0x550f(%rip), %rax      # 0x7160
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0xc(%rbx), %rax
jmp 0x1c80
leaq 0x24(%rbx), %rax
jmp 0x1c71
leaq 0x24(%rbx), %rax
xorps 0x54df(%rip), %xmm2     # 0x7150
pushq $0x2c
jmp 0x1c82
leaq 0xc(%rbx), %rax
xorps 0x54d0(%rip), %xmm2     # 0x7150
pushq $0x14
popq %rcx
movsd (%rax), %xmm0
movss (%rbx,%rcx), %xmm1
callq 0x2929
movq %rbx, %rdi
popq %rbx
jmp 0x1c9c
jmp 0x1c91
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/data.c
// Function: List_Destroy
void List_Destroy ( List *list ){
    while(list->size > 0){
        if(list->tail == NULL || List_Size(list) == 0)
            break;

        List_Pop(list);
    }

    memset(list, 0, sizeof(List));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rbx)
jle 0x1ced
cmpq $0x0, 0x20(%rbx)
je 0x1ced
movq %rbx, %rdi
callq 0x1cfe
jmp 0x1cd7
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
andq $0x0, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/data.c
// Function: List_Pop
void List_Pop ( List *list ){
    if(list->size == 0){
        printf("Warning: List is empty, nothing to remove!\n");
        return;
    } else {
        node_t *curr = list->tail;
        if (list->size == 1){
            list->Destroy_Node(curr->data);
            free(curr);
            list->head = list->tail = NULL;
        } else {
            list->tail = curr->prev;
            list->tail->next = NULL;
            list->Destroy_Node(curr->data);
            free(curr);
        }
        list->size--;
    }
}

// Assembly:
movl (%rdi), %eax
testl %eax, %eax
je 0x1d2b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
cmpl $0x1, %eax
jne 0x1d37
movq (%r14), %rdi
callq *0x10(%rbx)
movq %r14, %rdi
callq 0x1298
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
jmp 0x1d52
leaq 0x54a0(%rip), %rdi      # 0x71d2
jmp 0x1200
movq 0x10(%r14), %rax
movq %rax, 0x20(%rbx)
andq $0x0, 0x8(%rax)
movq (%r14), %rdi
callq *0x10(%rbx)
movq %r14, %rdi
callq 0x1298
decl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/data.c
// Function: List_Push
void List_Push ( List *list, void *data ){
    node_t *new_node;

    if( (new_node = (node_t*)malloc(sizeof(node_t))) == NULL ){
        printf("Error: Can not create new list node!");
        return;
    }
    new_node->data = data;

    if(list->size == 0){
        list->head = new_node;
        list->head->prev = NULL;
        list->head->next = NULL;
        list->tail = new_node;
    } else {
        list->tail->next = new_node;
        new_node->next = NULL;
        new_node->prev = list->tail;
        list->tail = new_node;
    }
    //list->Print_Data(data);
    list->size++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x11b0
testq %rax, %rax
je 0x1d8f
movq %r14, (%rax)
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x1da4
movq 0x20(%rbx), %rdx
movq %rax, 0x8(%rdx)
andq $0x0, 0x8(%rax)
movq %rdx, 0x10(%rax)
jmp 0x1daf
leaq 0x5417(%rip), %rdi      # 0x71ad
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
movq %rax, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x20(%rbx)
incl %ecx
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/data.c
// Function: List_Print
void List_Print ( List *list ){
    if(list->size == 0){
        printf("List is empty!\n");
        return;
    }
    node_t *curr = list->head;

    while( curr->next != NULL ){
        list->Print_Data(curr->data);
        curr = curr->next;
    }
}

// Assembly:
cmpl $0x0, (%rdi)
je 0x1ded
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq (%r14), %r14
cmpq $0x0, 0x8(%r14)
je 0x1de5
movq (%r14), %rdi
addq $0x8, %r14
callq *0x8(%rbx)
jmp 0x1dcf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5409(%rip), %rdi      # 0x71fd
jmp 0x1200
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Color_InitVec3
color_t Color_InitVec3( vec3 v ) {
	color_t c = Color_Init( (unsigned char)( clamp( v.x, 0.0f, 1.0f ) * 255.0f ),
                            (unsigned char)( clamp( v.y, 0.0f, 1.0f ) * 255.0f ),
                            (unsigned char)( clamp( v.z, 0.0f, 1.0f ) * 255.0f ),
                            255 );
}

// Assembly:
subq $0x28, %rsp
movss %xmm1, 0xc(%rsp)
movaps %xmm0, 0x10(%rsp)
movss 0x51e8(%rip), %xmm2     # 0x7014
xorps %xmm1, %xmm1
callq 0x4118
movaps 0x10(%rsp), %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
xorps %xmm1, %xmm1
movss 0x51cc(%rip), %xmm2     # 0x7014
callq 0x4118
xorps %xmm1, %xmm1
movss 0xc(%rsp), %xmm0
movss 0x51b6(%rip), %xmm2     # 0x7014
addq $0x28, %rsp
jmp 0x4118
// File: /workspace/github_c_makefile_star2_O2/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Color_Lerp
color_t Color_Lerp( color_t src1, color_t src2, float a ) {
	color_t res;
    res.r = (1 - a) * src1.r + a * src2.r;
    res.g = (1 - a) * src1.g + a * src2.g;
    res.b = (1 - a) * src1.b + a * src2.b;
    res.a = (1 - a) * src1.a + a * src2.a;
    return res;
}

// Assembly:
pushq %rbx
movl %edi, %r11d
shrl $0x8, %r11d
movl %edi, %r9d
movl %edi, %edx
movl %esi, %ebx
shrl $0x8, %ebx
movl %esi, %r10d
movl %esi, %r8d
movss 0x5145(%rip), %xmm1     # 0x7014
subss %xmm0, %xmm1
movl $0xff, %ecx
andl %ecx, %edi
cvtsi2ss %edi, %xmm2
andl %ecx, %esi
cvtsi2ss %esi, %xmm3
mulss %xmm0, %xmm3
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
cvttss2si %xmm2, %eax
andl %ecx, %r11d
cvtsi2ss %r11d, %xmm2
andl %ecx, %ebx
cvtsi2ss %ebx, %xmm3
shrl $0x10, %r9d
shrl $0x10, %r10d
mulss %xmm0, %xmm3
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
cvttss2si %xmm2, %esi
andl %ecx, %r9d
cvtsi2ss %r9d, %xmm2
andl %ecx, %r10d
cvtsi2ss %r10d, %xmm3
mulss %xmm0, %xmm3
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
cvttss2si %xmm2, %edi
shrl $0x18, %edx
cvtsi2ss %edx, %xmm2
shrl $0x18, %r8d
cvtsi2ss %r8d, %xmm3
mulss %xmm0, %xmm3
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
cvttss2si %xmm2, %edx
shll $0x18, %edx
andl %ecx, %edi
shll $0x10, %edi
orl %edx, %edi
andl %ecx, %esi
shll $0x8, %esi
orl %edi, %esi
andl %ecx, %eax
orl %esi, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1f8f
movl $0xff00, %ecx           # imm = 0xFF00
movl $0xff0000, %edx         # imm = 0xFF0000
movl $0xff000000, %eax       # imm = 0xFF000000
movl $0xff000000, %esi       # imm = 0xFF000000
jmp 0x1ff3
movl %edi, %eax
movl %edi, %edx
shrl $0x8, %edx
movl %edi, %ecx
shrl $0x10, %ecx
movl %edi, %esi
andl $0xff000000, %esi       # imm = 0xFF000000
ucomiss 0x506a(%rip), %xmm0     # 0x7014
ja 0x1ff3
movl $0xff, %edi
andl %edi, %eax
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
andl %edi, %edx
cvtsi2ss %edx, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %edx
andl %edi, %ecx
cvtsi2ss %ecx, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
andl %edi, %ecx
shll $0x10, %ecx
orl %esi, %ecx
andl %edi, %edx
shll $0x8, %edx
orl %ecx, %edx
andl %edi, %eax
orl %edx, %eax
shrl $0x8, %edx
shrl $0x10, %ecx
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_O2/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 0x4fd3(%rip), %xmm2     # 0x7014
xorps %xmm1, %xmm1
callq 0x4118
movss %xmm0, 0x8(%rsp)
movaps 0x10(%rsp), %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
xorps %xmm1, %xmm1
movss 0x4fb1(%rip), %xmm2     # 0x7014
callq 0x4118
movss %xmm0, 0x10(%rsp)
xorps %xmm1, %xmm1
movss 0xc(%rsp), %xmm0
movss 0x4f95(%rip), %xmm2     # 0x7014
callq 0x4118
movl $0xff, %ecx
andl %ecx, %ebx
cvtsi2ss %ebx, %xmm1
mulss 0x8(%rsp), %xmm1
cvttss2si %xmm1, %eax
andl %ecx, %r15d
cvtsi2ss %r15d, %xmm1
mulss 0x10(%rsp), %xmm1
cvttss2si %xmm1, %edx
andl %ecx, %r14d
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_O2/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
pushq $0x10
popq %rdi
callq 0x11b0
movq %rax, %r14
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
imull %ebp, %ebx
shlq $0x2, %rbx
movq %rbx, %rdi
callq 0x11b0
movq %rax, 0x8(%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0x2198
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpl 0x4(%rdi), %eax
jae 0x21bc
xorl %ecx, %ecx
movl (%rdi), %edx
cmpl %edx, %ecx
jae 0x21b8
movq 0x8(%rdi), %r8
imull %eax, %edx
addl %ecx, %edx
movl %esi, (%r8,%rdx,4)
incl %ecx
jmp 0x21a1
incl %eax
jmp 0x219a
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x4(%rdi), %edx
cmpl %eax, %esi
setb %r9b
cmpl %r8d, %edx
setb %r10b
orb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x237f
leaq 0x4eee(%rip), %rdi      # 0x7264
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_O2/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 0x4ec0(%rip), %rdi      # 0x72b7
leaq 0x4ec3(%rip), %rsi      # 0x72c1
callq 0x1190
movq %rax, %rbx
testq %rax, %rax
je 0x246c
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq 0x4eaa(%rip), %rsi      # 0x72c3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11d0
leaq 0x500c(%rip), %r15      # 0x7436
xorl %ebp, %ebp
cmpl 0x4(%r14), %ebp
jae 0x2478
xorl %r12d, %r12d
movl (%r14), %eax
cmpl %eax, %r12d
jae 0x2468
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 0x11d0
incl %r12d
jmp 0x2435
incl %ebp
jmp 0x242c
leaq 0x4ec7(%rip), %rdi      # 0x733a
callq 0x1200
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x4d91(%rip), %rdi      # 0x72d1
leaq 0x4d95(%rip), %rsi      # 0x72dc
callq 0x1190
movq %rax, %rbx
testq %rax, %rax
je 0x25be
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq 0x4d7d(%rip), %rsi      # 0x72df
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11d0
pushq $0x1
popq %r12
pushq $0x3
popq %r13
cmpl 0x4(%r14), %ebp
jae 0x25ca
xorl %r15d, %r15d
movl (%r14), %eax
cmpl %eax, %r15d
jae 0x25ba
movq 0x8(%r14), %rcx
imull %ebp, %eax
addl %r15d, %eax
movzwl (%rcx,%rax,4), %edx
movb 0x2(%rcx,%rax,4), %al
movw %dx, 0x5(%rsp)
movb %al, 0x7(%rsp)
leaq 0x5(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x1270
incl %r15d
jmp 0x257f
incl %ebp
jmp 0x2576
leaq 0x4d75(%rip), %rdi      # 0x733a
callq 0x1200
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4d0f(%rip), %r14      # 0x7313
xorl %ebp, %ebp
cmpl 0x4(%rbx), %ebp
jae 0x264f
xorl %r15d, %r15d
movl (%rbx), %eax
cmpl %eax, %r15d
jae 0x264b
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
jmp 0x260e
incl %ebp
jmp 0x2606
leaq 0x4d08(%rip), %rdi      # 0x735e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1200
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %eax
pushq $0x3
popq %rcx
cltd
idivl %ecx
movslq %eax, %r14
imulq $0xc, %r14, %rdi
callq 0x11b0
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
imulq $0xc, %r14, %rdx
cmpq %rcx, %rdx
je 0x2850
movl 0x8(%rbx,%rcx), %esi
movq (%rbx,%rcx), %rdi
movq %rdi, (%rax,%rcx)
movl %esi, 0x8(%rax,%rcx)
addq $0xc, %rcx
jmp 0x2835
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
cvtsi2ss %edi, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
cvtsi2ss %esi, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %edx
shlq $0x20, %rcx
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rax
movaps %xmm0, %xmm2
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
movss 0x14(%rdi), %xmm0
movss (%rdi), %xmm4
movss 0x4(%rdi), %xmm5
unpcklps %xmm0, %xmm5            # xmm5 = xmm5[0],xmm0[0],xmm5[1],xmm0[1]
movss 0x8(%rdi), %xmm6
movss 0xc(%rdi), %xmm0
mulps %xmm3, %xmm5
movss 0x10(%rdi), %xmm7
unpcklps %xmm7, %xmm4            # xmm4 = xmm4[0],xmm7[0],xmm4[1],xmm7[1]
shufps $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
mulps %xmm2, %xmm4
addps %xmm5, %xmm4
movss 0x18(%rdi), %xmm5
unpcklps %xmm5, %xmm6            # xmm6 = xmm6[0],xmm5[0],xmm6[1],xmm5[1]
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
mulps %xmm1, %xmm6
addps %xmm4, %xmm6
movss 0x1c(%rdi), %xmm4
unpcklps %xmm4, %xmm0            # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
addps %xmm6, %xmm0
movss 0x34(%rdi), %xmm4
movss 0x24(%rdi), %xmm5
unpcklps %xmm4, %xmm5            # xmm5 = xmm5[0],xmm4[0],xmm5[1],xmm4[1]
mulps %xmm3, %xmm5
movss 0x30(%rdi), %xmm3
movss 0x20(%rdi), %xmm4
unpcklps %xmm3, %xmm4            # xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1]
mulps %xmm2, %xmm4
addps %xmm5, %xmm4
movss 0x38(%rdi), %xmm2
movss 0x28(%rdi), %xmm3
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
mulps %xmm3, %xmm1
addps %xmm4, %xmm1
movss 0x3c(%rdi), %xmm2
movss 0x2c(%rdi), %xmm3
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
addps %xmm3, %xmm1
callq 0x2b22
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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, %xmm4
shufps $0x55, %xmm0, %xmm4     # xmm4 = xmm4[1,1],xmm0[1,1]
movaps %xmm2, %xmm5
shufps $0x55, %xmm2, %xmm5     # xmm5 = xmm5[1,1],xmm2[1,1]
mulss %xmm1, %xmm5
mulss %xmm3, %xmm4
subss %xmm5, %xmm4
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
mulps %xmm0, %xmm3
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
mulps %xmm2, %xmm1
subps %xmm3, %xmm1
movaps %xmm1, %xmm2
shufps $0x11, 0x475c(%rip), %xmm2 # xmm2 = xmm2[1,0],mem[1,0]
unpcklps %xmm1, %xmm4            # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1]
shufps $0xe8, %xmm1, %xmm2     # xmm2 = xmm2[0,2],xmm1[2,3]
movaps %xmm4, %xmm0
movaps %xmm2, %xmm1
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x4, %rax
je 0x2ea9
leaq (,%rax,4), %rcx
movq %rsi, %r8
xorl %r9d, %r9d
cmpq $0x4, %r9
je 0x2ea0
movq %r9, %r10
orq %rcx, %r10
movss (%rdx,%r10,4), %xmm0
xorl %r11d, %r11d
cmpq $0x10, %r11
je 0x2e97
movss (%rdi,%r11), %xmm1
mulss (%r8,%r11,4), %xmm1
addss %xmm1, %xmm0
movss %xmm0, (%rdx,%r10,4)
addq $0x4, %r11
jmp 0x2e75
incq %r9
addq $0x4, %r8
jmp 0x2e60
incq %rax
addq $0x10, %rdi
jmp 0x2e4c
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x4, %rax
je 0x2ed7
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x2eca
movss (%rdi,%rcx,4), %xmm0
movss %xmm0, (%rsi,%rcx)
addq $0x4, %rcx
jmp 0x2eb4
incq %rax
addq $0x10, %rsi
addq $0x4, %rdi
jmp 0x2eac
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3cd8(%rip), %r14      # 0x7499
cmpq $0x40, %r15
je 0x37f2
cvtss2sd (%rbx,%r15), %xmm0
cvtss2sd 0x4(%rbx,%r15), %xmm1
cvtss2sd 0x8(%rbx,%r15), %xmm2
cvtss2sd 0xc(%rbx,%r15), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x1040
addq $0x10, %r15
jmp 0x37c1
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11c0
// File: /workspace/github_c_makefile_star2_O2/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 0x3ca6(%rip), %rdi      # 0x74b4
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x1040
leaq 0x3c7a(%rip), %r14      # 0x7499
cmpq $0x40, %r15
je 0x3850
cvtss2sd (%rbx,%r15), %xmm0
cvtss2sd 0x4(%rbx,%r15), %xmm1
cvtss2sd 0x8(%rbx,%r15), %xmm2
cvtss2sd 0xc(%rbx,%r15), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x1040
addq $0x10, %r15
jmp 0x381f
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11c0
// File: /workspace/github_c_makefile_star2_O2/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 0x3b8b(%rip), %xmm3     # 0x7510
movups %xmm3, (%rdi)
movaps 0x3b91(%rip), %xmm3     # 0x7520
movups %xmm3, 0x10(%rdi)
movaps 0x3b96(%rip), %xmm3     # 0x7530
movups %xmm3, 0x20(%rdi)
movaps 0x3b9b(%rip), %xmm3     # 0x7540
movups %xmm3, 0x30(%rdi)
movss %xmm0, 0xc(%rdi)
movss %xmm1, 0x1c(%rdi)
movss %xmm2, 0x2c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x2c(%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_O2/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, 0x2c(%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_O2/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 $0x50, %rsp
movss %xmm3, 0xc(%rsp)
movaps %xmm2, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rdi, %rbx
movaps %xmm3, %xmm0
callq 0x1110
movaps %xmm0, 0x20(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x10e0
movaps 0x10(%rsp), %xmm2
movaps %xmm2, %xmm1
shufps $0x0, %xmm2, %xmm1      # xmm1 = xmm1[0,0],xmm2[0,0]
movaps %xmm1, %xmm5
movaps 0x30(%rsp), %xmm12
unpcklps %xmm12, %xmm5           # xmm5 = xmm5[0],xmm12[0],xmm5[1],xmm12[1]
mulps %xmm1, %xmm5
movss 0x3593(%rip), %xmm1     # 0x7014
subss %xmm0, %xmm1
movaps 0x20(%rsp), %xmm11
movaps %xmm11, %xmm3
movaps 0x40(%rsp), %xmm7
mulss %xmm7, %xmm3
movaps 0x36b1(%rip), %xmm6     # 0x7150
movaps %xmm3, %xmm9
xorps %xmm6, %xmm9
movaps %xmm2, %xmm4
movaps %xmm2, %xmm8
unpcklps %xmm12, %xmm4           # xmm4 = xmm4[0],xmm12[0],xmm4[1],xmm12[1]
movaps %xmm7, %xmm2
movaps %xmm7, %xmm10
shufps $0x0, %xmm7, %xmm2      # xmm2 = xmm2[0,0],xmm7[0,0]
mulps %xmm4, %xmm2
movaps %xmm11, %xmm4
mulss %xmm12, %xmm4
movaps %xmm2, %xmm7
mulss %xmm1, %xmm7
addss %xmm4, %xmm7
mulss %xmm12, %xmm12
mulss %xmm8, %xmm11
movaps %xmm2, %xmm8
shufps $0x55, %xmm2, %xmm8     # xmm8 = xmm8[1,1],xmm2[1,1]
mulss %xmm1, %xmm8
subss %xmm11, %xmm8
mulss %xmm10, %xmm10
mulss %xmm1, %xmm10
addss %xmm0, %xmm10
shufps $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
unpcklps %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
unpcklps %xmm9, %xmm0            # xmm0 = xmm0[0],xmm9[0],xmm0[1],xmm9[1]
shufps $0xd4, %xmm5, %xmm12    # xmm12 = xmm12[0,1],xmm5[1,3]
shufps $0x52, %xmm5, %xmm12    # xmm12 = xmm12[2,0],xmm5[1,1]
mulps %xmm1, %xmm5
addps %xmm0, %xmm5
movlps %xmm5, (%rbx)
movss %xmm7, 0x8(%rbx)
andl $0x0, 0xc(%rbx)
xorps %xmm6, %xmm4
movaps %xmm12, %xmm0
mulps %xmm1, %xmm0
addps %xmm3, %xmm0
movlps %xmm0, 0x10(%rbx)
movss %xmm8, 0x18(%rbx)
andl $0x0, 0x1c(%rbx)
unpcklps %xmm11, %xmm4           # xmm4 = xmm4[0],xmm11[0],xmm4[1],xmm11[1]
mulps %xmm2, %xmm1
addps %xmm4, %xmm1
movlps %xmm1, 0x20(%rbx)
movss %xmm10, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x2c(%rbx)
movl $0x3f800000, 0x3c(%rbx) # imm = 0x3F800000
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movss %xmm2, 0xc(%rsp)
movss %xmm1, 0x8(%rsp)
movq %rdi, %rbx
xorps %xmm1, %xmm1
leaq 0x10(%rsp), %r14
movaps %xmm1, 0x30(%r14)
movaps %xmm1, 0x20(%r14)
movaps %xmm1, 0x10(%r14)
movaps %xmm1, (%r14)
movups %xmm1, 0x30(%rdi)
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
leaq 0xd0(%rsp), %r15
movq %r15, %rdi
callq 0x3c19
leaq 0x90(%rsp), %r12
movq %r12, %rdi
movss 0x8(%rsp), %xmm0
callq 0x3cae
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movss 0xc(%rsp), %xmm0
callq 0x3d59
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2e4a
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2e4a
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x40, %rsp
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x1260
movaps %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x1080
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x1080
cvtsd2ss %xmm0, %xmm0
xorps 0x34f5(%rip), %xmm0     # 0x7150
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x1260
cvtsd2ss %xmm0, %xmm0
movl $0x3f800000, %eax       # imm = 0x3F800000
movl %eax, (%rbx)
xorps %xmm1, %xmm1
movups %xmm1, 0x4(%rbx)
movapd 0x30(%rsp), %xmm2
unpcklpd 0x20(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
cvtpd2ps %xmm2, %xmm2
movupd %xmm2, 0x14(%rbx)
movaps 0x10(%rsp), %xmm2
movss %xmm2, 0x24(%rbx)
movss %xmm0, 0x28(%rbx)
movups %xmm1, 0x2c(%rbx)
movl %eax, 0x3c(%rbx)
addq $0x40, %rsp
popq %rbx
retq