LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: skip_taskbar_and_pager
void
skip_taskbar_and_pager(void)
{
  /*
    window  = the respective client window
    message_type = _NET_WM_STATE
    format = 32
    data.l[0] = the action, as listed below
    data.l[1] = first property to alter
    data.l[2] = second property to alter
    data.l[3] = source indication
    other data.l[] elements = 0

    _NET_WM_STATE_REMOVE 0
    _NET_WM_STATE_ADD 1
    _NET_WM_STATE_TOGGLE 2
  */

  if ((skiptaskbar == FALSE) && (skippager == FALSE))
    return;

  // should we skip the taskbar?
  xw.skip_taskbar = XInternAtom(xw.dpy, "_NET_WM_STATE_SKIP_TASKBAR", False);
  xw.skip_pager = XInternAtom(xw.dpy, "_NET_WM_STATE_SKIP_PAGER", False);

  // See Xlib.h, line 36
  XEvent xevent;
  bzero(&xevent, sizeof(xevent));
  // prepare client message
  // we are interested in the 'xclient' field of the Xevent union
  xevent.type = ClientMessage;
  xevent.xclient.window = xw.win;
  xevent.xclient.message_type = xw.window_state;
  xevent.xclient.format = 32;
  xevent.xclient.data.l[0] = _NET_WM_STATE_ADD;
  xevent.xclient.data.l[1] = (skiptaskbar == TRUE) ? xw.skip_pager : 0;
  xevent.xclient.data.l[2] = (skippager == TRUE) ? xw.skip_pager : 0;
  xevent.xclient.data.l[3] = 0;
  xevent.xclient.data.l[4] = 0;
  // Send Message to root win, see https://specifications.freedesktop.org/wm-spec/wm-spec-1.3.html#idm140130317705584 for XCB,
  // for Xlib, as used in this program, the equivalent Root window flags are named:
  // X.h:#define SubstructureNotifyMask              (1L<<19)
  // X.h:#define SubstructureRedirectMask    (1L<<20)
  XSendEvent(xw.dpy, DefaultRootWindow(xw.dpy), False, SubstructureNotifyMask|SubstructureRedirectMask, &xevent);
}

// Assembly:
movl 0x12a68(%rip), %eax     # 0x20ab4
orl 0x12a5e(%rip), %eax     # 0x20ab0
je 0xe142
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq 0x12b5d(%rip), %rdi     # 0x20bc8
leaq 0x8f44(%rip), %rsi      # 0x16fb6
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x6800
movq %rax, 0x12ba5(%rip)     # 0x20c28
movq 0x12b3e(%rip), %rdi     # 0x20bc8
leaq 0x8f40(%rip), %rsi      # 0x16fd1
xorl %edx, %edx
callq 0x6800
movq %rax, %r14
movq %rax, 0x12b8e(%rip)     # 0x20c30
movq %rsp, %rbx
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x60c0
movl $0x21, (%rbx)
movq 0x12b17(%rip), %rax     # 0x20bd8
movq %rax, 0x20(%rbx)
movq 0x12b54(%rip), %rax     # 0x20c20
movq %rax, 0x28(%rbx)
movl $0x20, 0x30(%rbx)
movq $0x1, 0x38(%rbx)
cmpl $0x1, 0x129ca(%rip)     # 0x20ab0
movl $0x0, %eax
cmoveq %r14, %rax
movq %rax, 0x40(%rbx)
cmpl $0x1, 0x129ba(%rip)     # 0x20ab4
cmovneq %r15, %r14
movq %r14, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x12ab8(%rip), %rdi     # 0x20bc8
movq 0xe8(%rdi), %rax
movslq 0xe0(%rdi), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rsi
movl $0x180000, %ecx         # imm = 0x180000
xorl %edx, %edx
movq %rbx, %r8
callq 0x66c0
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: xunloadfonts
void
xunloadfonts(void)
{
  /* Free the loaded fonts in the font cache.  */
  while (frclen > 0)
    XftFontClose(xw.dpy, frc[--frclen].font);

  xunloadfont(&dc.font);
  xunloadfont(&dc.bfont);
  xunloadfont(&dc.ifont);
  xunloadfont(&dc.ibfont);

//  if (frc) free(frc);
}

// Assembly:
pushq %rax
movl 0x12c7c(%rip), %eax     # 0x20e20
testl %eax, %eax
jle 0xe1cd
movq 0x12a19(%rip), %rdi     # 0x20bc8
movq 0x12c72(%rip), %rcx     # 0x20e28
decl %eax
movl %eax, 0x12c62(%rip)     # 0x20e20
shlq $0x4, %rax
movq (%rcx,%rax), %rsi
callq 0x60f0
jmp 0xe19e
leaq 0x1290c(%rip), %rdi     # 0x20ae0
callq 0xf861
leaq 0x12938(%rip), %rdi     # 0x20b18
callq 0xf861
leaq 0x12964(%rip), %rdi     # 0x20b50
callq 0xf861
leaq 0x12990(%rip), %rdi     # 0x20b88
popq %rax
jmp 0xf861
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: cresize
void
cresize(int width, int height)
{
  int col, row;

  if (width != 0)
    win.w = width;
  if (height != 0)
    win.h = height;

  col = MAX(1, (win.w - 2 * borderpx)/win.cw);
  row = MAX(1, (win.h - 2 * borderpx)/win.ch);
  win.dynborder_h = win.dynborder_w = borderpx;

  tresize(col, row);
  xresize(col, row);
  ttyresize(win.tw, win.th);
}

// Assembly:
testl %edi, %edi
je 0xe53f
movl %edi, 0x127d9(%rip)     # 0x20d18
testl %esi, %esi
je 0xe54b
movl %esi, 0x127d3(%rip)     # 0x20d1c
jmp 0xe551
movl 0x127cb(%rip), %esi     # 0x20d1c
pushq %rbp
pushq %rbx
pushq %rax
movl 0x127be(%rip), %eax     # 0x20d18
movl 0x12880(%rip), %ecx     # 0x20de0
leal (%rcx,%rcx), %edi
subl %edi, %eax
cltd
idivl 0x127c0(%rip)           # 0x20d2c
movl %eax, %ebx
cmpl $0x2, %eax
movl $0x1, %ebp
cmovll %ebp, %ebx
subl %edi, %esi
movl %esi, %eax
cltd
idivl 0x127a4(%rip)           # 0x20d28
cmpl $0x2, %eax
cmovgel %eax, %ebp
movl %ecx, 0x12794(%rip)     # 0x20d24
movl %ecx, 0x1278a(%rip)     # 0x20d20
movl %ebx, %edi
movl %ebp, %esi
callq 0x8705
movl 0x12787(%rip), %eax     # 0x20d2c
imull %ebx, %eax
imull 0x12779(%rip), %ebp     # 0x20d28
movl %eax, 0x1275b(%rip)     # 0x20d10
movl %ebp, 0x12759(%rip)     # 0x20d14
movq 0x12606(%rip), %rdi     # 0x20bc8
movq 0x12617(%rip), %rsi     # 0x20be0
callq 0x68c0
movq 0x125f3(%rip), %rdi     # 0x20bc8
movq 0x125fc(%rip), %rsi     # 0x20bd8
movl 0x12736(%rip), %edx     # 0x20d18
movl 0x12734(%rip), %ecx     # 0x20d1c
movl 0x12701(%rip), %r8d     # 0x20cf0
callq 0x6960
movq %rax, 0x125e5(%rip)     # 0x20be0
movq 0x12666(%rip), %rdi     # 0x20c68
movq %rax, %rsi
callq 0x6750
movl 0x12707(%rip), %r8d     # 0x20d18
movl 0x12704(%rip), %r9d     # 0x20d1c
movq 0x12649(%rip), %rdi     # 0x20c68
testb $0x20, 0x1270e(%rip)    # 0x20d34
leaq 0xef83(%rip), %rax      # 0x1d5b0
leaq 0xef78(%rip), %rcx      # 0x1d5ac
cmovneq %rax, %rcx
movl (%rcx), %esi
shlq $0x4, %rsi
addq 0x1248b(%rip), %rsi     # 0x20ad0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6420
movq 0x12593(%rip), %rdi     # 0x20be8
shlq $0x4, %rbx
movq %rbx, %rsi
callq 0x71e9
movq %rax, 0x12580(%rip)     # 0x20be8
movl 0x126a2(%rip), %edi     # 0x20d10
movl 0x126a0(%rip), %esi     # 0x20d14
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8541
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: xunloadfont
void
xunloadfont(Font *f)
{
  XftFontClose(xw.dpy, f->match);
  FcPatternDestroy(f->pattern);
  if (f->set)
    FcFontSetDestroy(f->set);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1135c(%rip), %rdi     # 0x20bc8
movq 0x20(%rbx), %rsi
callq 0x60f0
movq 0x30(%rbx), %rdi
callq 0x6060
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xf88d
popq %rbx
jmp 0x6540
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: xhints
void
xhints(void)
{
  XClassHint class = {opt_name ? opt_name : "st",
                      opt_class ? opt_class : "St"};
  XWMHints wm = {.flags = InputHint, .input = 1};
  XSizeHints *sizeh;

  sizeh = XAllocSizeHints();

  sizeh->flags = PSize | PResizeInc | PBaseSize | PMinSize;
  sizeh->height = win.h;
  sizeh->width = win.w;
  sizeh->height_inc = win.ch;
  sizeh->width_inc = win.cw;
  sizeh->base_height = 2 * win.dynborder_w;
  sizeh->base_width = 2 * win.dynborder_h;
  sizeh->min_height = win.ch + 2 * win.dynborder_h;
  sizeh->min_width = win.cw + 2 * win.dynborder_w;
  if (xw.isfixed) {
    sizeh->flags |= PMaxSize;
    sizeh->min_width = sizeh->max_width = win.w;
    sizeh->min_height = sizeh->max_height = win.h;
  }
  if (xw.gm & (XValue|YValue)) {
    sizeh->flags |= USPosition | PWinGravity;
    sizeh->x = xw.l;
    sizeh->y = xw.t;
    sizeh->win_gravity = xgeommasktogravity(xw.gm);
  }

  XSetWMProperties(xw.dpy, xw.win, NULL, NULL, NULL, 0, sizeh, &wm,
      &class);
  XFree(sizeh);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq 0x10f53(%rip), %rax     # 0x20d98
testq %rax, %rax
leaq 0x710f(%rip), %rcx      # 0x16f5e
cmovneq %rax, %rcx
movq 0x10f46(%rip), %rax     # 0x20da0
testq %rax, %rax
leaq 0x70fd(%rip), %rdx      # 0x16f61
cmovneq %rax, %rdx
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movq $0x1, 0x18(%rsp)
movl $0x1, 0x20(%rsp)
callq 0x68b0
movq %rax, %rbx
movq $0x158, (%rax)          # imm = 0x158
movl 0x10e72(%rip), %eax     # 0x20d1c
movl %eax, 0x14(%rbx)
movl 0x10e65(%rip), %ecx     # 0x20d18
movl %ecx, 0x10(%rbx)
movl 0x10e6c(%rip), %edx     # 0x20d28
movl %edx, 0x2c(%rbx)
movl 0x10e67(%rip), %esi     # 0x20d2c
movl %esi, 0x28(%rbx)
movl 0x10e56(%rip), %edi     # 0x20d24
leal (%rdi,%rdi), %r8d
movl %r8d, 0x44(%rbx)
movl 0x10e43(%rip), %r8d     # 0x20d20
leal (%r8,%r8), %r9d
movl %r9d, 0x40(%rbx)
leal (%rdx,%r8,2), %edx
movl %edx, 0x1c(%rbx)
leal (%rsi,%rdi,2), %edx
movl %edx, 0x18(%rbx)
cmpl $0x0, 0x10df3(%rip)     # 0x20cec
je 0xff15
movq $0x178, (%rbx)          # imm = 0x178
movl %ecx, 0x20(%rbx)
movl %ecx, 0x18(%rbx)
movl %eax, 0x24(%rbx)
movl %eax, 0x1c(%rbx)
movl $0x379, %ecx            # imm = 0x379
jmp 0xff1a
movl $0x359, %ecx            # imm = 0x359
movl 0x10ddc(%rip), %eax     # 0x20cfc
testb $0x3, %al
je 0xff45
movq %rcx, (%rbx)
movq 0x10dc6(%rip), %rcx     # 0x20cf4
movq %rcx, 0x8(%rbx)
shrl $0x2, %eax
andl $0xc, %eax
leaq 0x6da1(%rip), %rcx      # 0x16ce0
movl (%rax,%rcx), %eax
movl %eax, 0x48(%rbx)
movq 0x10c7c(%rip), %rdi     # 0x20bc8
movq 0x10c85(%rip), %rsi     # 0x20bd8
subq $0x8, %rsp
leaq 0x10(%rsp), %rax
leaq 0x20(%rsp), %r10
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %rbx
callq 0x6360
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x60a0
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mcaimi[P]st/x.c
// Function: xloadsparefont
int
xloadsparefont(FcPattern *pattern, int flags)
{
  FcPattern *match;
  FcResult result;

  match = FcFontMatch(NULL, pattern, &result);
  if (!match) {
    return 1;
  }

  if (!(frc[frclen].font = XftFontOpenPattern(xw.dpy, match))) {
    FcPatternDestroy(match);
    return 1;
  }

  frc[frclen].flags = flags;
  /* Believe U+0000 glyph will present in each default font */
  frc[frclen].unicodep = 0;
  frclen++;

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0xc(%rsp), %rdx
xorl %edi, %edi
callq 0x61d0
movl $0x1, %ebp
testq %rax, %rax
je 0xfff9
movq %rax, %r14
movq 0x10c15(%rip), %rdi     # 0x20bc8
movq %rax, %rsi
callq 0x6840
movq 0x10e66(%rip), %rdx     # 0x20e28
movslq 0x10e57(%rip), %rcx     # 0x20e20
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, (%rdx,%rsi)
testq %rax, %rax
je 0xfff1
movl %ebx, 0x8(%rdx,%rsi)
movl $0x0, 0xc(%rdx,%rsi)
incl %ecx
movl %ecx, 0x10e33(%rip)     # 0x20e20
xorl %ebp, %ebp
jmp 0xfff9
movq %r14, %rdi
callq 0x6060
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10418
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
roll %cl, %eax
andl %eax, 0x10a78(%rip)     # 0x20e90
movzwl 0x10915(%rip), %eax     # 0x20d34
testl $0xc018, %eax           # imm = 0xC018
setne %al
movl 0x50(%rbx), %edi
testb $0x1, %dil
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x10447
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10ae1
movl %r14d, %esi
movl $0x1, %edx
callq 0x10cdf
cmpl $0x1, %r14d
jne 0x10472
testl %eax, %eax
jne 0x10472
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10d86
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x104a3
popq %rbx
retq
movl (%rdi), %ebx
movq 0x107a4(%rip), %rdi     # 0x20c50
cmpl $0x9, %ebx
je 0x104f0
testq %rdi, %rdi
je 0x104bb
callq 0x6410
movl 0x10873(%rip), %eax     # 0x20d34
movl %eax, %ecx
andl $-0x3, %ecx
movl %ecx, 0x10868(%rip)     # 0x20d34
btl $0xd, %eax
jae 0x104e5
leaq 0x6b11(%rip), %rdi      # 0x16fea
movl $0x3, %esi
xorl %edx, %edx
callq 0x8138
cmpb $0x0, 0x1081c(%rip)     # 0x20d08
jne 0x104a1
jmp 0x10531
testq %rdi, %rdi
je 0x104fa
callq 0x66d0
orb $0x2, 0x10833(%rip)     # 0x20d34
xorl %edi, %edi
callq 0xdcbd
testb $0x20, 0x10826(%rip)    # 0x20d35
je 0x10524
leaq 0x7367(%rip), %rdi      # 0x1787f
movl $0x3, %esi
xorl %edx, %edx
callq 0x8138
cmpb $0x0, 0x107dd(%rip)     # 0x20d08
je 0x104a1
cmpl $0x9, %ebx
setne 0x107cd(%rip)           # 0x20d08
callq 0xc403
popq %rbx
jmp 0x97d8
// File: /workspace/github_c_makefile_star2_O3/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 0x1062d(%rip), %rdi     # 0x20bc8
leaq 0x6b19(%rip), %rsi      # 0x170bb
xorl %edx, %edx
callq 0x6800
cmpl $0x0, 0x38(%rbx)
jne 0x105be
movq 0x28(%rbx), %rcx
cmpq $0x1, %rcx
je 0x105c0
cmpq %rax, %rcx
je 0x105c0
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x10750
// File: /workspace/github_c_makefile_star2_O3/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 0xe19d
movq 0x102e9(%rip), %rdi     # 0x20da8
cvtss2sd (%rbx), %xmm0
callq 0xe1fe
callq 0xfa69
xorl %edi, %edi
xorl %esi, %esi
callq 0xe535
callq 0x97d8
popq %rbx
jmp 0xfe39
// File: /workspace/github_c_makefile_star2_O3/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:
leal -0x1(%rsi), %eax
cmpl $0x4, %eax
jae 0x10cf5
movl %eax, %eax
leaq 0x6000(%rip), %rcx      # 0x16cf0
movl (%rcx,%rax,4), %eax
jmp 0x10d04
xorl %eax, %eax
cmpl $0x5, %esi
setne %al
negl %eax
orl $0xffffefff, %eax       # imm = 0xFFFFEFFF
andl %edi, %eax
movl %eax, %ecx
andl $0xffff9fef, %ecx       # imm = 0xFFFF9FEF
andl $0xffff9fee, %eax       # imm = 0xFFFF9FEE
movq $-0x20, %rdi
leaq 0xd87f(%rip), %r8       # 0x1e5a0
cmpl %edx, 0x38(%rdi,%r8)
jne 0x10d44
cmpl %esi, 0x20(%rdi,%r8)
jne 0x10d44
movl 0x24(%rdi,%r8), %r9d
cmpl $-0x1, %r9d
je 0x10d54
cmpl %r9d, %ecx
je 0x10d54
cmpl %r9d, %eax
je 0x10d54
addq $0x20, %rdi
cmpq $0x80, %rdi
jb 0x10d21
xorl %eax, %eax
retq
pushq %rax
addq %r8, %rdi
addq $0x30, %rdi
callq *-0x8(%rdi)
movl $0x1, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5d47(%rip), %rdi      # 0x70cb
callq 0x11f0
movl $0x20, %edi
callq 0x1120
testl %eax, %eax
js 0x13e0
leaq 0x5cdf(%rip), %rdi      # 0x707d
movl $0x1fff0000, %esi       # imm = 0x1FFF0000
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
movl $0x500, %ecx            # imm = 0x500
movl $0x2d0, %r8d            # imm = 0x2D0
movl $0x4, %r9d
callq 0x1050
movq %rax, 0x9db3(%rip)      # 0xb178
testq %rax, %rax
je 0x13ee
movq %rax, %rdi
callq 0x1190
movq %rax, 0x9da7(%rip)      # 0xb180
movl $0x1, %ebx
jmp 0x1406
callq 0x10f0
leaq 0x5c64(%rip), %rdi      # 0x7050
jmp 0x13fa
callq 0x10f0
leaq 0x5c95(%rip), %rdi      # 0x708f
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x1040
leaq 0x5cd6(%rip), %rdi      # 0x70e3
callq 0x11f0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1270
cmpb $0x0, 0x1a(%rax)
je 0x173f
movl $0x1, 0x9a31(%rip)      # 0xb170
cmpb $0x0, 0x16(%rax)
je 0x174f
movl $0xffffffff, 0x9a21(%rip) # imm = 0xFFFFFFFF
cmpb $0x0, 0x7(%rax)
je 0x175f
movl $0x1, 0x9a15(%rip)      # 0xb174
leaq 0x20(%rsp), %r14
cmpb $0x0, 0x4(%rax)
je 0x17b0
movl $0xffffffff, 0x9a00(%rip) # imm = 0xFFFFFFFF
jmp 0x17b0
movl (%r14), %eax
cmpl $0x300, %eax            # imm = 0x300
je 0x1793
cmpl $0x100, %eax            # imm = 0x100
jne 0x17b0
movl $0x1, 0x99d7(%rip)      # 0xb168
jmp 0x17b0
movl 0x14(%r14), %eax
cmpl $0x72, %eax
je 0x17a8
cmpl $0x71, %eax
je 0x1787
cmpl $0x1b, %eax
jne 0x17b0
jmp 0x1787
movq %rbx, %rdi
callq 0x5f8b
movq %r14, %rdi
callq 0x10c0
testl %eax, %eax
jne 0x1776
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x58e5(%rip), %rsi      # 0x70c4
callq 0x664b
testq %rax, %rax
je 0x180d
movq %rax, %r14
movss 0x5840(%rip), %xmm1     # 0x7034
mulss 0xc(%rsp), %xmm1
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
callq 0x2a24
movq %r14, %rdi
callq 0x55d8
movl 0x9961(%rip), %ebp      # 0xb174
cmpl $0x0, 0x9956(%rip)      # 0xb170
je 0x1835
movq (%rbx), %rax
movq (%rax), %rdi
setle %al
movzbl %al, %esi
incl %esi
movss 0xc(%rsp), %xmm0
callq 0x1c4a
testl %ebp, %ebp
movss 0xc(%rsp), %xmm0
je 0x1853
movq (%rbx), %rax
movq (%rax), %rdi
setle %al
movzbl %al, %esi
addl $0x3, %esi
callq 0x1c4a
movq $0x0, 0x9912(%rip) # 0xb170
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x58bb(%rip), %rdi      # 0x712a
callq 0x11f0
movq 0x990d(%rip), %rdi      # 0xb188
callq 0x66a1
movq 0x9909(%rip), %rdi      # 0xb190
callq 0x6520
movq 0x98e5(%rip), %rdi      # 0xb178
callq 0x1030
movq $0x0, 0x98d5(%rip) # 0xb178
popq %rax
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/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 0x11a0
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 0x2a6b
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 0x44a3
callq 0x10e0
movss %xmm0, 0x10(%rsp)
movss 0x20(%rsp), %xmm0
callq 0x44a3
callq 0x10e0
mulss 0x10(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x20(%rsp), %xmm0
callq 0x44a3
callq 0x1110
movss %xmm0, 0x30(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x44a3
callq 0x1110
movss %xmm0, 0xc(%rsp)
movss 0x20(%rsp), %xmm0
callq 0x44a3
callq 0x10e0
movss 0xc(%rsp), %xmm2
mulss %xmm0, %xmm2
movss 0x10(%rsp), %xmm0
movss 0x30(%rsp), %xmm1
callq 0x2a24
callq 0x2abd
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 0x2a6b
callq 0x2abd
movlps %xmm0, 0x24(%rbx)
movss %xmm1, 0x2c(%rbx)
movaps 0x20(%rsp), %xmm2
movss 0xc(%rsp), %xmm3
callq 0x2a6b
callq 0x2abd
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 0x4139
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6025(%rip), %rdi      # 0x7bc6
xorl %eax, %eax
callq 0x1040
movsd (%rbx), %xmm0
movss 0x8(%rbx), %xmm1
callq 0x2c64
leaq 0x55b3(%rip), %rdi      # 0x7170
xorl %eax, %eax
callq 0x1040
movsd 0xc(%rbx), %xmm0
movss 0x14(%rbx), %xmm1
callq 0x2c64
leaq 0x559e(%rip), %rdi      # 0x7178
xorl %eax, %eax
callq 0x1040
movsd 0x18(%rbx), %xmm0
movss 0x20(%rbx), %xmm1
callq 0x2c64
leaq 0x5586(%rip), %rdi      # 0x717d
xorl %eax, %eax
callq 0x1040
movsd 0x24(%rbx), %xmm0
movss 0x2c(%rbx), %xmm1
callq 0x2c64
xorps %xmm0, %xmm0
cvtss2sd 0x84(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x88(%rbx), %xmm1
leaq 0x555b(%rip), %rdi      # 0x7185
movb $0x2, %al
callq 0x1040
leaq 0x5562(%rip), %rdi      # 0x719a
callq 0x11f0
addq $0x3c, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x3893
// File: /workspace/github_c_makefile_star2_O3/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 0x1cca
movaps %xmm0, %xmm2
mulss 0x94(%rbx), %xmm2
leaq 0x54f9(%rip), %rax      # 0x7160
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0xc(%rbx), %rax
jmp 0x1c99
leaq 0x24(%rbx), %rax
jmp 0x1c87
leaq 0x24(%rbx), %rax
xorps 0x54c9(%rip), %xmm2     # 0x7150
movl $0x2c, %ecx
jmp 0x1c9e
leaq 0xc(%rbx), %rax
xorps 0x54b7(%rip), %xmm2     # 0x7150
movl $0x14, %ecx
movsd (%rax), %xmm0
movss (%rbx,%rcx), %xmm1
callq 0x2a3c
movaps %xmm0, %xmm2
movaps %xmm1, %xmm3
movsd (%rbx), %xmm0
movss 0x8(%rbx), %xmm1
callq 0x2a2c
movlps %xmm0, (%rbx)
movss %xmm1, 0x8(%rbx)
popq %rbx
retq
jmp 0x1cb2
// File: /workspace/github_c_makefile_star2_O3/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, (%rdi)
jle 0x1d23
cmpq $0x0, 0x20(%rbx)
je 0x1d23
movq %rbx, %rdi
callq 0x1d37
cmpl $0x0, (%rbx)
jg 0x1d0f
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1d64
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
cmpl $0x1, %eax
jne 0x1d70
movq (%r14), %rdi
callq *0x10(%rbx)
movq %r14, %rdi
callq 0x1288
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
jmp 0x1d8e
leaq 0x5467(%rip), %rdi      # 0x71d2
jmp 0x11f0
movq 0x10(%r14), %rax
movq %rax, 0x20(%rbx)
movq $0x0, 0x8(%rax)
movq (%r14), %rdi
callq *0x10(%rbx)
movq %r14, %rdi
callq 0x1288
decl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x18, %edi
callq 0x11a0
testq %rax, %rax
je 0x1dd0
movq %r14, (%rax)
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x1de5
movq 0x20(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq $0x0, 0x8(%rax)
movq %rdx, 0x10(%rax)
jmp 0x1df0
leaq 0x53d6(%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_O3/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 0x1e2b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
cmpq $0x0, 0x8(%r14)
je 0x1e23
movq (%r14), %rdi
callq *0x8(%rbx)
movq 0x8(%r14), %r14
jmp 0x1e10
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x53cb(%rip), %rdi      # 0x71fd
jmp 0x11f0
// File: /workspace/github_c_makefile_star2_O3/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 0x51ac(%rip), %xmm2     # 0x7014
xorps %xmm1, %xmm1
callq 0x44c5
movaps 0x10(%rsp), %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
xorps %xmm1, %xmm1
movss 0x5190(%rip), %xmm2     # 0x7014
callq 0x44c5
xorps %xmm1, %xmm1
movss 0xc(%rsp), %xmm0
movss 0x517a(%rip), %xmm2     # 0x7014
addq $0x28, %rsp
jmp 0x44c5
// File: /workspace/github_c_makefile_star2_O3/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 0x1fdf
movl $0xff00, %ecx           # imm = 0xFF00
movl $0xff0000, %edx         # imm = 0xFF0000
movl $0xff000000, %eax       # imm = 0xFF000000
movl $0xff000000, %esi       # imm = 0xFF000000
jmp 0x204c
movl %edi, %eax
movl %edi, %edx
shrl $0x8, %edx
movl %edi, %ecx
shrl $0x10, %ecx
movl %edi, %esi
andl $0xff000000, %esi       # imm = 0xFF000000
ucomiss 0x501a(%rip), %xmm0     # 0x7014
ja 0x204c
movl $0xff, %edi
andl %edi, %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %eax
andl %edi, %edx
xorps %xmm1, %xmm1
cvtsi2ss %edx, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %edx
andl %edi, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
andl %edi, %ecx
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_O3/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 0x4f7a(%rip), %xmm2     # 0x7014
xorps %xmm1, %xmm1
callq 0x44c5
movss %xmm0, 0x8(%rsp)
movaps 0x10(%rsp), %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
xorps %xmm1, %xmm1
movss 0x4f58(%rip), %xmm2     # 0x7014
callq 0x44c5
movss %xmm0, 0x10(%rsp)
xorps %xmm1, %xmm1
movss 0xc(%rsp), %xmm0
movss 0x4f3c(%rip), %xmm2     # 0x7014
callq 0x44c5
movl $0xff, %ecx
andl %ecx, %ebx
xorps %xmm1, %xmm1
cvtsi2ss %ebx, %xmm1
mulss 0x8(%rsp), %xmm1
cvttss2si %xmm1, %eax
andl %ecx, %r15d
xorps %xmm1, %xmm1
cvtsi2ss %r15d, %xmm1
mulss 0x10(%rsp), %xmm1
cvttss2si %xmm1, %edx
andl %ecx, %r14d
xorps %xmm1, %xmm1
cvtsi2ss %r14d, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %esi
andl %ecx, %esi
shll $0x10, %esi
orl %ebp, %esi
andl %ecx, %edx
shll $0x8, %edx
orl %esi, %edx
andl %ecx, %eax
orl %edx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x4(%rdi), %edx
testl %edx, %edx
je 0x2237
movl (%rdi), %ecx
xorl %eax, %eax
movl $0x0, %r8d
testl %ecx, %ecx
je 0x222e
xorl %edx, %edx
movq 0x8(%rdi), %r8
imull %eax, %ecx
addl %edx, %ecx
movl %esi, (%r8,%rcx,4)
incl %edx
movl (%rdi), %ecx
cmpl %ecx, %edx
jb 0x2213
movl 0x4(%rdi), %edx
movl %ecx, %r8d
incl %eax
movl %r8d, %ecx
cmpl %edx, %eax
jb 0x2207
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2421
leaq 0x4e4c(%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_O3/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 0x4e1b(%rip), %rdi      # 0x72b7
leaq 0x4e1e(%rip), %rsi      # 0x72c1
callq 0x1180
movq %rax, %rbx
testq %rax, %rax
je 0x2524
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq 0x4e05(%rip), %rsi      # 0x72c3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11c0
movl 0x4(%r14), %ecx
testl %ecx, %ecx
je 0x2530
movl (%r14), %eax
leaq 0x4f6c(%rip), %r15      # 0x7446
xorl %ebp, %ebp
testl %eax, %eax
je 0x251a
xorl %r12d, %r12d
movq 0x8(%r14), %rsi
imull %ebp, %eax
addl %r12d, %eax
movzbl (%rsi,%rax,4), %edx
movzbl 0x1(%rsi,%rax,4), %ecx
movzbl 0x2(%rsi,%rax,4), %r8d
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x11c0
incl %r12d
movl (%r14), %eax
cmpl %eax, %r12d
jb 0x24e3
movl 0x4(%r14), %ecx
jmp 0x251c
xorl %eax, %eax
incl %ebp
cmpl %ecx, %ebp
jb 0x24dc
jmp 0x2530
leaq 0x4e0f(%rip), %rdi      # 0x733a
callq 0x11f0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O3/Nealsbo[P]C-Software-Renderer/src/image.c
// Function: Bitmap_SavePPM6
void Bitmap_SavePPM6( bitmap_t *i ) {
    FILE *output;
    if ( ( output = fopen( "image1.ppm","wb" ) ) == NULL )
        printf( "ERROR: Can not create or open file!\n" );
    else{
        fprintf( output, "P6\n%d %d\n255\n", i->width, i->height );
        unsigned int w, h;
        color_t c;
        for( h = 0; h < i->height; h++ ) {
            for( w = 0; w < i->width; w++ ) {
                c = i->bitmap[ h * i->width + w ];
                unsigned char wcolor[3];
                wcolor[0] = c.r;
                wcolor[1] = c.g;
                wcolor[2] = c.b;
                fwrite(wcolor, 1, 3, output);
            }
        }
    }
    fclose(output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x4cc5(%rip), %rdi      # 0x72d1
leaq 0x4cc9(%rip), %rsi      # 0x72dc
callq 0x1180
movq %rax, %rbx
testq %rax, %rax
je 0x269c
movl (%r14), %edx
movl 0x4(%r14), %ecx
leaq 0x4cb1(%rip), %rsi      # 0x72df
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11c0
movl 0x4(%r14), %ecx
testl %ecx, %ecx
je 0x26a8
movl (%r14), %eax
leaq 0xd(%rsp), %r15
testl %eax, %eax
je 0x2692
xorl %r12d, %r12d
movq 0x8(%r14), %rcx
imull %ebp, %eax
addl %r12d, %eax
movzwl (%rcx,%rax,4), %edx
movb 0x2(%rcx,%rax,4), %al
movw %dx, 0xd(%rsp)
movb %al, 0xf(%rsp)
movl $0x1, %esi
movl $0x3, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1260
incl %r12d
movl (%r14), %eax
cmpl %eax, %r12d
jb 0x2651
movl 0x4(%r14), %ecx
jmp 0x2694
xorl %eax, %eax
incl %ebp
cmpl %ecx, %ebp
jb 0x264a
jmp 0x26a8
leaq 0x4c97(%rip), %rdi      # 0x733a
callq 0x11f0
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x4(%rdi), %ecx
testl %ecx, %ecx
je 0x2749
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
leaq 0x4c2a(%rip), %r14      # 0x7313
xorl %ebp, %ebp
movl $0x0, %edx
testl %eax, %eax
je 0x2737
xorl %r15d, %r15d
imull %ebp, %eax
addl %r15d, %eax
movq 0x8(%rbx), %rdx
movzbl (%rdx,%rax,4), %ecx
movzbl 0x1(%rdx,%rax,4), %r8d
movzbl 0x2(%rdx,%rax,4), %r9d
movzbl 0x3(%rdx,%rax,4), %eax
movl %eax, (%rsp)
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1040
incl %r15d
movl (%rbx), %eax
cmpl %eax, %r15d
jb 0x26f7
movl 0x4(%rbx), %ecx
movl %eax, %edx
incl %ebp
movl %edx, %eax
cmpl %ecx, %ebp
jb 0x26eb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
leaq 0x4c0e(%rip), %rdi      # 0x735e
jmp 0x11f0
// File: /workspace/github_c_makefile_star2_O3/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: vec3i_arrayToVec3ip
vec3i *vec3i_arrayToVec3ip(int size, int *ar){
    int i;
    vec3i *v = malloc(sizeof(vec3i) * (size / 3));
    for(i = 0; i < size / 3; i++)
        v[i] = (vec3i){ar[i*3], ar[i*3+1], ar[i*3+2]};
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movslq %edi, %r15
imulq $0x55555556, %r15, %r14 # imm = 0x55555556
movq %r14, %rax
shrq $0x3f, %rax
shrq $0x20, %r14
addl %eax, %r14d
movslq %r14d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
callq 0x11a0
cmpl $0x3, %r15d
jl 0x295f
movl %r14d, %ecx
shlq $0x2, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
movl 0x8(%rbx,%rdx), %esi
movq (%rbx,%rdx), %rdi
movq %rdi, (%rax,%rdx)
movl %esi, 0x8(%rax,%rdx)
addq $0xc, %rdx
cmpq %rdx, %rcx
jne 0x2946
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Nealsbo[P]C-Software-Renderer/src/libmath.c
// Function: mat4_mlt
void mat4_mlt( mat4 m1, mat4 m2, mat4 dest ){
    int i, j, k;
    for (i = 0; i < 4; i++)
        for (j = 0; j < 4; j++)
            for(k = 0; k < 4; k++)
                dest[i * 4 + j] += m1[i * 4 + k] * m2[4 * k + j];
}

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

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
movss (%rdi,%rcx,4), %xmm0
movss %xmm0, (%rsi,%rcx)
addq $0x4, %rcx
cmpq $0x10, %rcx
jne 0x2f96
incq %rax
addq $0x10, %rsi
addq $0x4, %rdi
cmpq $0x4, %rax
jne 0x2f94
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3c04(%rip), %r14      # 0x74a9
xorps %xmm0, %xmm0
cvtss2sd (%rbx,%r15), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rbx,%r15), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rbx,%r15), %xmm2
xorps %xmm3, %xmm3
cvtss2sd 0xc(%rbx,%r15), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x1040
addq $0x10, %r15
cmpq $0x40, %r15
jne 0x38a5
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O3/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 0x3bc6(%rip), %rdi      # 0x74c4
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x1040
leaq 0x3b9a(%rip), %r14      # 0x74a9
xorps %xmm0, %xmm0
cvtss2sd (%rbx,%r15), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rbx,%r15), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x8(%rbx,%r15), %xmm2
xorps %xmm3, %xmm3
cvtss2sd 0xc(%rbx,%r15), %xmm3
movq %r14, %rdi
movb $0x4, %al
callq 0x1040
addq $0x10, %r15
cmpq $0x40, %r15
jne 0x390f
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O3/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 0x3a9f(%rip), %xmm3     # 0x7520
movups %xmm3, (%rdi)
movaps 0x3aa5(%rip), %xmm3     # 0x7530
movups %xmm3, 0x10(%rdi)
movaps 0x3aaa(%rip), %xmm3     # 0x7540
movups %xmm3, 0x20(%rdi)
movaps 0x3aaf(%rip), %xmm3     # 0x7550
movups %xmm3, 0x30(%rdi)
movss %xmm0, 0xc(%rdi)
movss %xmm1, 0x1c(%rdi)
movss %xmm2, 0x2c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3497(%rip), %xmm1     # 0x7014
subss %xmm0, %xmm1
movaps 0x20(%rsp), %xmm11
movaps %xmm11, %xmm3
movaps 0x40(%rsp), %xmm6
mulss %xmm6, %xmm3
movaps 0x35b4(%rip), %xmm9     # 0x7150
movaps %xmm3, %xmm8
xorps %xmm9, %xmm8
movaps %xmm2, %xmm4
movaps %xmm2, %xmm7
unpcklps %xmm12, %xmm4           # xmm4 = xmm4[0],xmm12[0],xmm4[1],xmm12[1]
movaps %xmm6, %xmm2
movaps %xmm6, %xmm10
shufps $0x0, %xmm6, %xmm2      # xmm2 = xmm2[0,0],xmm6[0,0]
mulps %xmm4, %xmm2
movaps %xmm11, %xmm4
mulss %xmm12, %xmm4
movaps %xmm2, %xmm6
mulss %xmm1, %xmm6
addss %xmm4, %xmm6
mulss %xmm12, %xmm12
mulss %xmm7, %xmm11
movaps %xmm2, %xmm7
shufps $0x55, %xmm2, %xmm7     # xmm7 = xmm7[1,1],xmm2[1,1]
mulss %xmm1, %xmm7
subss %xmm11, %xmm7
xorps %xmm9, %xmm4
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 %xmm8, %xmm0            # xmm0 = xmm0[0],xmm8[0],xmm0[1],xmm8[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 %xmm6, 0x8(%rbx)
xorl %eax, %eax
movl %eax, 0xc(%rbx)
movaps %xmm12, %xmm0
mulps %xmm1, %xmm0
addps %xmm3, %xmm0
movlps %xmm0, 0x10(%rbx)
movss %xmm7, 0x18(%rbx)
movl %eax, 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