LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: xtermclear
void
xtermclear(int col1, int row1, int col2, int row2)
{
  XftDrawRect(xw.draw,
      &dc.col[IS_SET(MODE_REVERSE) ? defaultfg : defaultbg],
      win.dynborder_w + col1 * win.cw,
      win.dynborder_h + row1 * win.ch,
      (col2-col1+1) * win.cw,
      (row2-row1+1) * win.ch);
}

// Assembly:
movl %edi, %r9d
movq 0x14b4f(%rip), %rdi     # 0x20c68
testb $0x20, 0x14c14(%rip)    # 0x20d34
leaq 0x11489(%rip), %rax     # 0x1d5b0
leaq 0x1147e(%rip), %r8      # 0x1d5ac
cmovneq %rax, %r8
movl (%r8), %eax
shlq $0x4, %rax
addq 0x14990(%rip), %rax     # 0x20ad0
movl 0x14be5(%rip), %r10d    # 0x20d2c
subl %r9d, %edx
leal 0x1(%rdx), %r8d
imull %r10d, %r8d
movl %r10d, %edx
imull %r9d, %edx
addl 0x14bc5(%rip), %edx     # 0x20d24
movl 0x14bc2(%rip), %r10d    # 0x20d28
subl %esi, %ecx
leal 0x1(%rcx), %r9d
imull %r10d, %r9d
movl %r10d, %ecx
imull %esi, %ecx
addl 0x14ba4(%rip), %ecx     # 0x20d20
movq %rax, %rsi
jmp 0x6420
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: deepcopy
char *
deepcopy(char *src) {
  char *tmpBuf = NULL;
  int srcLen = (strlen(src) + 1) * sizeof(char);

  // deep string copy
  tmpBuf = (char *)malloc(srcLen);
  bzero(tmpBuf, srcLen);
  strncpy(tmpBuf, src, srcLen - 1);

#ifdef __DEBUG
  printf("deepcopy(): duped string 0x%X to 0x%X\n", src, tmpBuf);
  printf("deepcopy(): source string: [%s], dest string [%s]\n", src, tmpBuf);
#endif

  // return copied string
  return tmpBuf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x63b0
movq %rax, %r14
incl %eax
movslq %eax, %r15
movq %r15, %rdi
callq 0x6220
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x60c0
movslq %r14d, %rdx
movq %r12, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6830
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: allocateFontInfo
struct _spareFontInfo *
allocateFontInfo(char *content)
{
  struct _spareFontInfo *newItem = NULL;
  newItem = (struct _spareFontInfo *)malloc(sizeof(struct _spareFontInfo));

  if (newItem != NULL) {
    newItem->fontStringLen = strlen(content);
    newItem->fontString = deepcopy(content);
    newItem->next = NULL;
  }

#ifdef __DEBUG
  printf("allocateFontInfo(): newItem 0x%X, content [%s]\n", newItem, newItem->fontString);
#endif

  return newItem;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x18, %edi
callq 0x6220
movq %rax, %rbx
testq %rax, %rax
je 0xc204
movq %r14, %rdi
callq 0x63b0
movl %eax, 0x8(%rbx)
movq %r14, %rdi
callq 0xc184
movq %rax, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: unloadSpareFontList
void
unloadSpareFontList(spareFontList *spl)
{
  if (spl != NULL) {
#ifdef __DEBUG
    printf("unloadSpareFontInfo() freeing font Info 0x%X, font List 0x%X\n", spl->fonts, spl);
#endif
    unloadSpareFontInfo(spl->fonts);
    spl->fonts = NULL;
    free(spl);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xc27c
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xc224
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x6380
retq
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: loadSpareFontList
spareFontList *
loadSpareFontList(char *spec)
{
  spareFontList *tempList = NULL;
  char needle = ',';
  char *loopPtr = NULL, *stringToParse = NULL;
  struct _spareFontInfo *fontItem = NULL;

  if (!spec) return NULL;

  // allocate fontlist object
  tempList = (spareFontList *)malloc(sizeof(spareFontList));
  tempList->fonts = NULL;

  // count spare fonts defined in Xresources template
  // spec must be not NULL, assume at least one font is correctly specified
  for (tempList->fontCount=1, loopPtr = strchr(spec, needle); loopPtr != NULL; loopPtr = strchr(loopPtr+1, needle), tempList->fontCount++);

  // parse font string spec
  stringToParse = deepcopy(spec);
  if (stringToParse == NULL) {
    unloadSpareFontList(tempList);
    return NULL;
  }

  // parse font spec into a linked list
  loopPtr = strtok(stringToParse, &needle);
  while (loopPtr != NULL) {
    fontItem = (struct _spareFontInfo *)allocateFontInfo(loopPtr);
#ifdef __DEBUG
    printf("loadSpareFontList(): fontItem 0x%X, tempList->fonts 0x%X\n", fontItem, tempList->fonts);
#endif
    if (tempList->fonts == NULL) {
      tempList->fonts = fontItem;
    }
    else {
      lastItem(tempList->fonts)->next = fontItem;
    }
#ifdef __DEBUG
    printf("loadSpareFontList(): lastItem 0x%X\n", lastItem(tempList->fonts));
#endif
    loopPtr = strtok(NULL, &needle);
  }

  // return fontList
#ifdef __DEBUG
  printSpareFontInfo(tempList->fonts);
#endif
  return tempList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movb $0x2c, 0xf(%rsp)
testq %rdi, %rdi
je 0xc359
movq %rdi, %r14
movl $0x10, %edi
callq 0x6220
movq %rax, %rbx
movq $0x0, 0x8(%rax)
movl $0x1, (%rax)
movq %r14, %rdi
movl $0x2c, %esi
callq 0x6590
testq %rax, %rax
je 0xc2e4
movl (%rbx), %ebp
incl %ebp
incq %rax
movq %rax, %rdi
movl $0x2c, %esi
callq 0x6590
movl %ebp, (%rbx)
incl %ebp
testq %rax, %rax
jne 0xc2cb
movq %r14, %rdi
callq 0xc184
testq %rax, %rax
je 0xc342
leaq 0xf(%rsp), %rsi
movq %rax, %rdi
callq 0x6770
testq %rax, %rax
je 0xc35b
movq 0x8(%rbx), %r14
leaq 0xf(%rsp), %r15
movq %rax, %rdi
callq 0xc1cd
movq %rax, %r12
testq %r14, %r14
je 0xc32a
movq %r14, %rdi
callq 0xc20f
movq %r12, 0x10(%rax)
jmp 0xc32d
movq %r12, %r14
xorl %edi, %edi
movq %r15, %rsi
callq 0x6770
testq %rax, %rax
jne 0xc30c
movq %r14, 0x8(%rbx)
jmp 0xc35b
xorl %edi, %edi
callq 0xc224
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x6380
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: xseticontitle
void
xseticontitle(char *p)
{
  XTextProperty prop;
  DEFAULT(p, opt_title);

  if (p[0] == '\0')
   p = opt_title;

  if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
      &prop) != Success)
    return;
  XSetWMName(xw.dpy, xw.win, &prop);
  XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmiconname);
  XFree(prop.value);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
testq %rdi, %rdi
movq 0x14674(%rip), %rax     # 0x20d40
cmoveq %rax, %rdi
movq %rdi, (%rsi)
cmpb $0x0, (%rdi)
cmoveq %rax, %rdi
movq %rdi, (%rsi)
movq 0x144e4(%rip), %rdi     # 0x20bc8
leaq 0x10(%rsp), %r8
movl $0x1, %edx
movl $0x4, %ecx
callq 0x6480
testl %eax, %eax
jne 0xc73c
movq 0x144c5(%rip), %rdi     # 0x20bc8
movq 0x144ce(%rip), %rsi     # 0x20bd8
leaq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x6430
movq 0x144aa(%rip), %rdi     # 0x20bc8
movq 0x144b3(%rip), %rsi     # 0x20bd8
movq 0x144dc(%rip), %rcx     # 0x20c08
movq %rbx, %rdx
callq 0x64a0
movq (%rbx), %rdi
callq 0x60a0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: xsettitle
void
xsettitle(char *p, int pop)
{
  XTextProperty prop;

  free(titlestack[tstki]);
  if (pop) {
    titlestack[tstki] = NULL;
    tstki = (tstki - 1 + TITLESTACKSIZE) % TITLESTACKSIZE;
    p = titlestack[tstki] ? titlestack[tstki] : opt_title;
  } else if (p) {
    titlestack[tstki] = xstrdup(p);
  } else {
    titlestack[tstki] = NULL;
    p = opt_title;
  }

  if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
      &prop) != Success)
    return;
  XSetWMName(xw.dpy, xw.win, &prop);
  XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname);
  XFree(prop.value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, 0x8(%rsp)
movl 0x14607(%rip), %r15d    # 0x20d90
leaq 0x145c0(%rip), %r14     # 0x20d50
movq (%r14,%r15,8), %rdi
callq 0x6380
testl %ebx, %ebx
je 0xc7bd
movq $0x0, (%r14,%r15,8)
leal -0x1(%r15), %eax
andl $0x7, %eax
movl %eax, 0x145de(%rip)     # 0x20d90
movq (%r14,%rax,8), %rax
testq %rax, %rax
je 0xc7e0
jmp 0xc7e7
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc7d8
callq 0x7213
movl 0x145be(%rip), %ecx     # 0x20d90
movq %rax, (%r14,%rcx,8)
jmp 0xc7ec
movq $0x0, (%r14,%r15,8)
movq 0x14559(%rip), %rax     # 0x20d40
movq %rax, 0x8(%rsp)
movq 0x143d5(%rip), %rdi     # 0x20bc8
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %r8
movl $0x1, %edx
movl $0x4, %ecx
callq 0x6480
testl %eax, %eax
jne 0xc850
movq 0x143b1(%rip), %rdi     # 0x20bc8
movq 0x143ba(%rip), %rsi     # 0x20bd8
leaq 0x10(%rsp), %rbx
movq %rbx, %rdx
callq 0x6430
movq 0x14396(%rip), %rdi     # 0x20bc8
movq 0x1439f(%rip), %rsi     # 0x20bd8
movq 0x143c0(%rip), %rcx     # 0x20c00
movq %rbx, %rdx
callq 0x64a0
movq (%rbx), %rdi
callq 0x60a0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: xpushtitle
void
xpushtitle(void)
{
  int tstkin = (tstki + 1) % TITLESTACKSIZE;

  free(titlestack[tstkin]);
  titlestack[tstkin] = titlestack[tstki] ? xstrdup(titlestack[tstki]) : NULL;
  tstki = tstkin;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x1452a(%rip), %r15d    # 0x20d90
leal 0x1(%r15), %ebx
andl $0x7, %ebx
leaq 0x144dc(%rip), %r14     # 0x20d50
movq (%r14,%rbx,8), %rdi
callq 0x6380
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0xc88d
callq 0x7213
jmp 0xc88f
xorl %eax, %eax
movq %rax, (%r14,%rbx,8)
movl %ebx, 0x144f7(%rip)     # 0x20d90
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: xximspot
void
xximspot(int x, int y)
{
  if (xw.ime.xic == NULL)
    return;

  xw.ime.spot.x = win.dynborder_w + x * win.cw;
  xw.ime.spot.y = win.dynborder_h + (y + 1) * win.ch;

  XSetICValues(xw.ime.xic, XNPreeditAttributes, xw.ime.spotlist, NULL);
}

// Assembly:
movl %edi, %eax
movq 0x1366a(%rip), %rdi     # 0x20c50
testq %rdi, %rdi
je 0xd62c
imull 0x1373a(%rip), %eax     # 0x20d2c
addl 0x1372c(%rip), %eax     # 0x20d24
movw %ax, 0x13659(%rip)      # 0x20c58
incl %esi
imull 0x13720(%rip), %esi     # 0x20d28
addl 0x13712(%rip), %esi     # 0x20d20
movw %si, 0x13645(%rip)      # 0x20c5a
movq 0x13644(%rip), %rdx     # 0x20c60
leaq 0x9903(%rip), %rsi      # 0x16f26
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x62a0
retq
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: xbell
void
xbell(void)
{
  if (!(IS_SET(MODE_FOCUSED)))
    xseturgency(1);
  if (bellvolume)
    XkbBell(xw.dpy, xw.win, bellvolume, (Atom)NULL);
}

// Assembly:
testb $0x2, 0x13689(%rip)     # 0x20d34
jne 0xd6bc
pushq %rax
movl $0x1, %edi
callq 0xd6dc
addq $0x8, %rsp
movl 0x13406(%rip), %edx     # 0x20ac8
testl %edx, %edx
je 0xd6db
movq 0x134fb(%rip), %rdi     # 0x20bc8
movq 0x13504(%rip), %rsi     # 0x20bd8
xorl %ecx, %ecx
jmp 0x69a0
retq
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: xseturgency
void
xseturgency(int add)
{
  XWMHints *h = XGetWMHints(xw.dpy, xw.win);

  MODBIT(h->flags, add, XUrgencyHint);
  XSetWMHints(xw.dpy, xw.win, h);
  XFree(h);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
testl %edi, %edi
setne %r14b
movq 0x134d8(%rip), %rdi     # 0x20bc8
movq 0x134e1(%rip), %rsi     # 0x20bd8
callq 0x6550
movq %rax, %rbx
movq $-0x101, %rax           # imm = 0xFEFF
andq (%rbx), %rax
shll $0x8, %r14d
orq %rax, %r14
movq %r14, (%rbx)
movq 0x134ae(%rip), %rdi     # 0x20bc8
movq 0x134b7(%rip), %rsi     # 0x20bd8
movq %rbx, %rdx
callq 0x6a10
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x60a0
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: resource_load
int
resource_load(XrmDatabase db, char *name, enum resource_type rtype, void *dst)
{
  char **sdst = dst;
  int *idst = dst;
  float *fdst = dst;

  char fullname[256];
  char fullclass[256];
  char *type;
  XrmValue ret;

  snprintf(fullname, sizeof(fullname), "%s.%s", opt_name ? opt_name : "st", name);
  snprintf(fullclass, sizeof(fullclass), "%s.%s", opt_class ? opt_class : "St", name);
  fullname[sizeof(fullname) - 1] = fullclass[sizeof(fullclass) - 1] = '\0';

  XrmGetResource(db, fullname, fullclass, &type, &ret);
  if (ret.addr == NULL || strncmp("String", type, 64))
    return 1;

  switch (rtype) {
  case STRING:
    *sdst = ret.addr;
    break;
  case INTEGER:
    *idst = strtoul(ret.addr, NULL, 10);
    break;
  case FLOAT:
    *fdst = strtof(ret.addr, NULL);
    break;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rcx, 0x8(%rsp)
movl %edx, 0x14(%rsp)
movq %rsi, %r15
movq %rdi, %r14
movq 0x13639(%rip), %rax     # 0x20d98
testq %rax, %rax
leaq 0x97d5(%rip), %rcx      # 0x16f3e
cmovneq %rax, %rcx
leaq 0x97c4(%rip), %r13      # 0x16f38
xorl %ebp, %ebp
leaq 0x130(%rsp), %r12
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x60d0
movq 0x13606(%rip), %rax     # 0x20da0
testq %rax, %rax
leaq 0x979d(%rip), %rcx      # 0x16f41
cmovneq %rax, %rcx
leaq 0x30(%rsp), %rbx
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %r13, %rdx
movq %r15, %r8
xorl %eax, %eax
callq 0x60d0
movb %bpl, 0xff(%rbx)
movb %bpl, 0xff(%r12)
leaq 0x18(%rsp), %rcx
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %r8
callq 0x68f0
movq 0x8(%r15), %r15
movl $0x1, %r14d
testq %r15, %r15
je 0xd815
movq 0x18(%rsp), %rsi
leaq 0x973d(%rip), %rdi      # 0x16f44
movl $0x40, %edx
callq 0x6210
testl %eax, %eax
je 0xd82a
movl %r14d, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x14(%rsp), %eax
xorl %r14d, %r14d
cmpl $0x2, %eax
je 0xd861
cmpl $0x1, %eax
je 0xd849
testl %eax, %eax
jne 0xd815
movq 0x8(%rsp), %rax
movq %r15, (%rax)
jmp 0xd815
movq %r15, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x69c0
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
jmp 0xd815
movq %r15, %rdi
xorl %esi, %esi
callq 0x64c0
movq 0x8(%rsp), %rax
movss %xmm0, (%rax)
jmp 0xd815
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: config_init
void
config_init(void)
{
  char *resm;
  XrmDatabase db;
  ResourcePref *p;

  XrmInitialize();
  resm = XResourceManagerString(xw.dpy);
  if (!resm)
    return;

  db = XrmGetStringDatabase(resm);
  for (p = resources; p < resources + LEN(resources); p++)
    resource_load(db, p->name, p->type, p->dst);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x65c0
movq 0x13341(%rip), %rdi     # 0x20bc8
callq 0x61a0
testq %rax, %rax
je 0xd8ce
movq %rax, %rdi
callq 0x6730
movq %rax, %rbx
movq $-0x18, %r14
leaq 0x10596(%rip), %r15     # 0x1de40
movq 0x18(%r14,%r15), %rsi
movl 0x20(%r14,%r15), %edx
movq 0x28(%r14,%r15), %rcx
movq %rbx, %rdi
callq 0xd738
addq $0x18, %r14
cmpq $0x4b0, %r14            # imm = 0x4B0
jb 0xd8aa
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13050(%rip), %eax     # 0x20ab4
orl 0x13046(%rip), %eax     # 0x20ab0
je 0xdb5a
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq 0x13145(%rip), %rdi     # 0x20bc8
leaq 0x950c(%rip), %rsi      # 0x16f96
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x6800
movq %rax, 0x1318d(%rip)     # 0x20c28
movq 0x13126(%rip), %rdi     # 0x20bc8
leaq 0x9508(%rip), %rsi      # 0x16fb1
xorl %edx, %edx
callq 0x6800
movq %rax, %r14
movq %rax, 0x13176(%rip)     # 0x20c30
movq %rsp, %rbx
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x60c0
movl $0x21, (%rbx)
movq 0x130ff(%rip), %rax     # 0x20bd8
movq %rax, 0x20(%rbx)
movq 0x1313c(%rip), %rax     # 0x20c20
movq %rax, 0x28(%rbx)
movl $0x20, 0x30(%rbx)
movq $0x1, 0x38(%rbx)
cmpl $0x1, 0x12fb2(%rip)     # 0x20ab0
movl $0x0, %eax
cmoveq %r14, %rax
movq %rax, 0x40(%rbx)
cmpl $0x1, 0x12fa2(%rip)     # 0x20ab4
cmovneq %r15, %r14
movq %r14, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x130a0(%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_O1/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 0x13264(%rip), %eax     # 0x20e20
testl %eax, %eax
jle 0xdbe5
movq 0x13001(%rip), %rdi     # 0x20bc8
movq 0x1325a(%rip), %rcx     # 0x20e28
decl %eax
movl %eax, 0x1324a(%rip)     # 0x20e20
shlq $0x4, %rax
movq (%rcx,%rax), %rsi
callq 0x60f0
jmp 0xdbb6
leaq 0x12ef4(%rip), %rdi     # 0x20ae0
callq 0xf253
leaq 0x12f20(%rip), %rdi     # 0x20b18
callq 0xf253
leaq 0x12f4c(%rip), %rdi     # 0x20b50
callq 0xf253
leaq 0x12f78(%rip), %rdi     # 0x20b88
popq %rax
jmp 0xf253
// File: /workspace/github_c_makefile_star2_O1/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 0xdf57
movl %edi, 0x12dc1(%rip)     # 0x20d18
testl %esi, %esi
je 0xdf61
movl %esi, 0x12dbb(%rip)     # 0x20d1c
pushq %rbp
pushq %rbx
pushq %rax
movl 0x12dae(%rip), %eax     # 0x20d18
movl 0x12e70(%rip), %ecx     # 0x20de0
leal (%rcx,%rcx), %esi
subl %esi, %eax
cltd
idivl 0x12db0(%rip)           # 0x20d2c
movl %eax, %ebx
cmpl $0x2, %eax
movl $0x1, %ebp
cmovll %ebp, %ebx
movl 0x12d8d(%rip), %eax     # 0x20d1c
subl %esi, %eax
cltd
idivl 0x12d90(%rip)           # 0x20d28
cmpl $0x2, %eax
cmovgel %eax, %ebp
movl %ecx, 0x12d80(%rip)     # 0x20d24
movl %ecx, 0x12d76(%rip)     # 0x20d20
movl %ebx, %edi
movl %ebp, %esi
callq 0x84ec
movl 0x12d73(%rip), %eax     # 0x20d2c
imull %ebx, %eax
imull 0x12d65(%rip), %ebp     # 0x20d28
movl %eax, 0x12d47(%rip)     # 0x20d10
movl %ebp, 0x12d45(%rip)     # 0x20d14
movq 0x12bf2(%rip), %rdi     # 0x20bc8
movq 0x12c03(%rip), %rsi     # 0x20be0
callq 0x68c0
movq 0x12bdf(%rip), %rdi     # 0x20bc8
movq 0x12be8(%rip), %rsi     # 0x20bd8
movl 0x12d22(%rip), %edx     # 0x20d18
movl 0x12d20(%rip), %ecx     # 0x20d1c
movl 0x12ced(%rip), %r8d     # 0x20cf0
callq 0x6960
movq %rax, 0x12bd1(%rip)     # 0x20be0
movq 0x12c52(%rip), %rdi     # 0x20c68
movq %rax, %rsi
callq 0x6760
movl 0x12cf3(%rip), %r8d     # 0x20d18
movl 0x12cf0(%rip), %r9d     # 0x20d1c
movq 0x12c35(%rip), %rdi     # 0x20c68
testb $0x20, 0x12cfa(%rip)    # 0x20d34
leaq 0xf56f(%rip), %rax      # 0x1d5b0
leaq 0xf564(%rip), %rcx      # 0x1d5ac
cmovneq %rax, %rcx
movl (%rcx), %esi
shlq $0x4, %rsi
addq 0x12a77(%rip), %rsi     # 0x20ad0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6420
movq 0x12b7f(%rip), %rdi     # 0x20be8
shlq $0x4, %rbx
movq %rbx, %rsi
callq 0x71e9
movq %rax, 0x12b6c(%rip)     # 0x20be8
movl 0x12c8e(%rip), %edi     # 0x20d10
movl 0x12c8c(%rip), %esi     # 0x20d14
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8331
// File: /workspace/github_c_makefile_star2_O1/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 0x1196a(%rip), %rdi     # 0x20bc8
movq 0x20(%rbx), %rsi
callq 0x60f0
movq 0x30(%rbx), %rdi
callq 0x6060
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xf27f
popq %rbx
jmp 0x6540
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11563(%rip), %rax     # 0x20d98
testq %rax, %rax
leaq 0x76ff(%rip), %rcx      # 0x16f3e
cmovneq %rax, %rcx
movq %rcx, (%rsp)
movq 0x11552(%rip), %rax     # 0x20da0
testq %rax, %rax
leaq 0x76e9(%rip), %rcx      # 0x16f41
cmovneq %rax, %rcx
movq %rcx, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x1, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0x68b0
movq %rax, %rbx
movq $0x158, (%rax)          # imm = 0x158
movl 0x1147a(%rip), %eax     # 0x20d1c
movl %eax, 0x14(%rbx)
movl 0x1146d(%rip), %ecx     # 0x20d18
movl %ecx, 0x10(%rbx)
movl 0x11474(%rip), %edx     # 0x20d28
movl %edx, 0x2c(%rbx)
movl 0x1146f(%rip), %esi     # 0x20d2c
movl %esi, 0x28(%rbx)
movl 0x1145e(%rip), %edi     # 0x20d24
leal (%rdi,%rdi), %r8d
movl %r8d, 0x44(%rbx)
movl 0x1144b(%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, 0x113fb(%rip)     # 0x20cec
je 0xf906
movq $0x178, (%rbx)          # imm = 0x178
movl %ecx, 0x20(%rbx)
movl %ecx, 0x18(%rbx)
movl %eax, 0x24(%rbx)
movl %eax, 0x1c(%rbx)
movl 0x113f0(%rip), %eax     # 0x20cfc
testb $0x3, %al
je 0xf93a
orw $0x201, (%rbx)          # imm = 0x201
movl 0x113d9(%rip), %ecx     # 0x20cf4
movl %ecx, 0x8(%rbx)
movl 0x113d4(%rip), %ecx     # 0x20cf8
movl %ecx, 0xc(%rbx)
shrl $0x2, %eax
andl $0xc, %eax
leaq 0x738c(%rip), %rcx      # 0x16cc0
movl (%rax,%rcx), %eax
movl %eax, 0x48(%rbx)
movq 0x11287(%rip), %rdi     # 0x20bc8
movq 0x11290(%rip), %rsi     # 0x20bd8
subq $0x8, %rsp
leaq 0x8(%rsp), %rax
leaq 0x18(%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_O1/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 0xf9ee
movq %rax, %r14
movq 0x11220(%rip), %rdi     # 0x20bc8
movq %rax, %rsi
callq 0x6840
movq 0x11471(%rip), %rdx     # 0x20e28
movslq 0x11462(%rip), %rcx     # 0x20e20
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, (%rdx,%rsi)
testq %rax, %rax
je 0xf9e6
movl %ebx, 0x8(%rdx,%rsi)
movl $0x0, 0xc(%rdx,%rsi)
incl %ecx
movl %ecx, 0x1143e(%rip)     # 0x20e20
xorl %ebp, %ebp
jmp 0xf9ee
movq %r14, %rdi
callq 0x6060
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xfe27
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
roll %cl, %eax
andl %eax, 0x11069(%rip)     # 0x20e90
movzwl 0x10f06(%rip), %eax     # 0x20d34
testl $0xc018, %eax           # imm = 0xC018
je 0xfe4a
testb $0x1, 0x50(%rbx)
jne 0xfe4a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x104ea
movq %rbx, %rdi
movl $0x1, %esi
callq 0x106c4
cmpl $0x1, %r14d
jne 0xfe75
testl %eax, %eax
jne 0xfe75
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10779
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xfea6
popq %rbx
retq
movl (%rdi), %ebx
movq 0x10da1(%rip), %rdi     # 0x20c50
cmpl $0x9, %ebx
je 0xfef3
testq %rdi, %rdi
je 0xfebe
callq 0x6410
movl 0x10e70(%rip), %eax     # 0x20d34
movl %eax, %ecx
andl $-0x3, %ecx
movl %ecx, 0x10e65(%rip)     # 0x20d34
btl $0xd, %eax
jae 0xfee8
leaq 0x70ee(%rip), %rdi      # 0x16fca
movl $0x3, %esi
xorl %edx, %edx
callq 0x8037
cmpb $0x0, 0x10e19(%rip)     # 0x20d08
jne 0xfea4
jmp 0xff34
testq %rdi, %rdi
je 0xfefd
callq 0x66d0
orb $0x2, 0x10e30(%rip)     # 0x20d34
xorl %edi, %edi
callq 0xd6dc
testb $0x20, 0x10e23(%rip)    # 0x20d35
je 0xff27
leaq 0x7944(%rip), %rdi      # 0x1785f
movl $0x3, %esi
xorl %edx, %edx
callq 0x8037
cmpb $0x0, 0x10dda(%rip)     # 0x20d08
je 0xfea4
cmpl $0x9, %ebx
setne 0x10dca(%rip)           # 0x20d08
callq 0xbdcf
popq %rbx
jmp 0x9424
// File: /workspace/github_c_makefile_star2_O1/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 0x10c2a(%rip), %rdi     # 0x20bc8
leaq 0x70f6(%rip), %rsi      # 0x1709b
xorl %edx, %edx
callq 0x6800
cmpl $0x0, 0x38(%rbx)
jne 0xffc1
movq 0x28(%rbx), %rcx
cmpq $0x1, %rcx
je 0xffc3
cmpq %rax, %rcx
je 0xffc3
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x1015c
// File: /workspace/github_c_makefile_star2_O1/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 0xdbb5
movq 0x108e0(%rip), %rdi     # 0x20da8
cvtss2sd (%rbx), %xmm0
callq 0xdc16
callq 0xf45b
xorl %edi, %edi
xorl %esi, %esi
callq 0xdf4d
callq 0x9424
popq %rbx
jmp 0xf829
// File: /workspace/github_c_makefile_star2_O1/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), %edx
movl 0x54(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x4, %ecx
jae 0x106e0
movl %ecx, %ecx
leaq 0x65f5(%rip), %rdi      # 0x16cd0
movl (%rdi,%rcx,4), %ecx
jmp 0x106f0
xorl %ecx, %ecx
cmpl $0x5, %eax
setne %cl
negl %ecx
orl $0xffffefff, %ecx       # imm = 0xFFFFEFFF
andl %edx, %ecx
movl %ecx, %edx
andl $0xffff9fef, %edx       # imm = 0xFFFF9FEF
andl $0xffff9fee, %ecx       # imm = 0xFFFF9FEE
movq $-0x20, %rdi
leaq 0xde92(%rip), %r8       # 0x1e5a0
cmpl %esi, 0x38(%rdi,%r8)
jne 0x10737
cmpl 0x20(%rdi,%r8), %eax
jne 0x10737
movl 0x24(%rdi,%r8), %r9d
cmpl $-0x1, %r9d
je 0x10747
cmpl %r9d, %edx
je 0x10747
cmpl $-0x1, %r9d
je 0x10747
cmpl %r9d, %ecx
je 0x10747
addq $0x20, %rdi
cmpq $0x80, %rdi
jb 0x1070e
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_O1/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 0x6d47(%rip), %rdi      # 0x80cb
callq 0x11f0
movl $0x20, %edi
callq 0x1120
testl %eax, %eax
js 0x13e0
leaq 0x6cdf(%rip), %rdi      # 0x807d
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, 0xadb3(%rip)      # 0xc178
testq %rax, %rax
je 0x13ee
movq %rax, %rdi
callq 0x1190
movq %rax, 0xada7(%rip)      # 0xc180
movl $0x1, %ebx
jmp 0x1406
callq 0x10f0
leaq 0x6c64(%rip), %rdi      # 0x8050
jmp 0x13fa
callq 0x10f0
leaq 0x6c95(%rip), %rdi      # 0x808f
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x1040
leaq 0x6cd6(%rip), %rdi      # 0x80e3
callq 0x11f0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1738
movl $0x1, 0xaa38(%rip)      # 0xc170
cmpb $0x0, 0x16(%rax)
je 0x1748
movl $0xffffffff, 0xaa28(%rip) # imm = 0xFFFFFFFF
cmpb $0x0, 0x7(%rax)
je 0x1758
movl $0x1, 0xaa1c(%rip)      # 0xc174
leaq 0x20(%rsp), %r14
cmpb $0x0, 0x4(%rax)
je 0x17a9
movl $0xffffffff, 0xaa07(%rip) # imm = 0xFFFFFFFF
jmp 0x17a9
movl (%r14), %eax
cmpl $0x300, %eax            # imm = 0x300
je 0x178c
cmpl $0x100, %eax            # imm = 0x100
jne 0x17a9
movl $0x1, 0xa9de(%rip)      # 0xc168
jmp 0x17a9
movl 0x14(%r14), %eax
cmpl $0x72, %eax
je 0x17a1
cmpl $0x71, %eax
je 0x1780
cmpl $0x1b, %eax
jne 0x17a9
jmp 0x1780
movq %rbx, %rdi
callq 0x62e3
movq %r14, %rdi
callq 0x10c0
testl %eax, %eax
jne 0x176f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x68ec(%rip), %rsi      # 0x80c4
callq 0x6999
testq %rax, %rax
je 0x1806
movq %rax, %r14
movss 0x6847(%rip), %xmm1     # 0x8034
mulss 0xc(%rsp), %xmm1
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
callq 0x2a5a
movq %r14, %rdi
callq 0x590f
movl 0xa968(%rip), %ebp      # 0xc174
cmpl $0x0, 0xa95d(%rip)      # 0xc170
je 0x182e
movq (%rbx), %rax
movq (%rax), %rdi
setle %al
movzbl %al, %esi
incl %esi
movss 0xc(%rsp), %xmm0
callq 0x1c5b
testl %ebp, %ebp
movss 0xc(%rsp), %xmm0
je 0x184c
movq (%rbx), %rax
movq (%rax), %rdi
setle %al
movzbl %al, %esi
addl $0x3, %esi
callq 0x1c5b
movq $0x0, 0xa919(%rip) # 0xc170
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x68c2(%rip), %rdi      # 0x812a
callq 0x11f0
movq 0xa914(%rip), %rdi      # 0xc188
callq 0x69ef
movq 0xa910(%rip), %rdi      # 0xc190
callq 0x686e
movq 0xa8ec(%rip), %rdi      # 0xc178
callq 0x1030
movq $0x0, 0xa8dc(%rip) # 0xc178
popq %rax
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/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 $0x40, %rsp
movss %xmm7, 0xc(%rsp)
movss %xmm6, 0x1c(%rsp)
movss %xmm5, 0x18(%rsp)
movss %xmm4, 0x14(%rsp)
movss %xmm3, 0x8(%rsp)
movaps %xmm2, 0x20(%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 0x20(%rsp), %xmm2
movlps %xmm2, 0x18(%rax)
movss 0x8(%rsp), %xmm3
movss %xmm3, 0x20(%rax)
movsd 0xc(%rax), %xmm0
movss 0x14(%rax), %xmm1
callq 0x2aaf
movlps %xmm0, 0x24(%rbx)
movss %xmm1, 0x2c(%rbx)
movaps 0x20(%rsp), %xmm0
movlps %xmm0, 0x30(%rbx)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x38(%rbx)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x7c(%rbx)
movss 0x18(%rsp), %xmm1
movss %xmm1, 0x80(%rbx)
movss 0x1c(%rsp), %xmm1
movss %xmm1, 0x84(%rbx)
movss 0xc(%rsp), %xmm1
movss %xmm1, 0x88(%rbx)
movss 0x50(%rsp), %xmm1
movss %xmm1, 0x8c(%rbx)
movss 0x58(%rsp), %xmm1
movss %xmm1, 0x90(%rbx)
movss 0x60(%rsp), %xmm1
movss %xmm1, 0x94(%rbx)
callq 0x479d
callq 0x10e0
movss %xmm0, 0x8(%rsp)
movss 0x80(%rbx), %xmm0
callq 0x479d
callq 0x10e0
mulss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x80(%rbx), %xmm0
callq 0x479d
callq 0x1110
movss %xmm0, 0x20(%rsp)
movss 0x7c(%rbx), %xmm0
callq 0x479d
callq 0x1110
movss %xmm0, 0xc(%rsp)
movss 0x80(%rbx), %xmm0
callq 0x479d
callq 0x10e0
movss 0xc(%rsp), %xmm2
mulss %xmm0, %xmm2
movss 0x8(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
callq 0x2a5a
callq 0x2aff
movlps %xmm0, 0xc(%rbx)
movss %xmm1, 0x14(%rbx)
movsd 0x30(%rbx), %xmm2
movss 0x38(%rbx), %xmm3
callq 0x2aaf
callq 0x2aff
movlps %xmm0, 0x24(%rbx)
movss %xmm1, 0x2c(%rbx)
movsd 0xc(%rbx), %xmm2
movss 0x14(%rbx), %xmm3
callq 0x2aaf
callq 0x2aff
movlps %xmm0, 0x18(%rbx)
movss %xmm1, 0x20(%rbx)
leaq 0x3c(%rbx), %rdi
movss 0x8c(%rbx), %xmm0
movss 0x90(%rbx), %xmm1
movss 0x84(%rbx), %xmm2
movss 0x88(%rbx), %xmm3
callq 0x434b
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6ff4(%rip), %rdi      # 0x8ba6
xorl %eax, %eax
callq 0x1040
movsd (%rbx), %xmm0
movss 0x8(%rbx), %xmm1
callq 0x2d37
leaq 0x65a2(%rip), %rdi      # 0x8170
xorl %eax, %eax
callq 0x1040
movsd 0xc(%rbx), %xmm0
movss 0x14(%rbx), %xmm1
callq 0x2d37
leaq 0x658d(%rip), %rdi      # 0x8178
xorl %eax, %eax
callq 0x1040
movsd 0x18(%rbx), %xmm0
movss 0x20(%rbx), %xmm1
callq 0x2d37
leaq 0x6575(%rip), %rdi      # 0x817d
xorl %eax, %eax
callq 0x1040
movsd 0x24(%rbx), %xmm0
movss 0x2c(%rbx), %xmm1
callq 0x2d37
xorps %xmm0, %xmm0
cvtss2sd 0x84(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x88(%rbx), %xmm1
leaq 0x654a(%rip), %rdi      # 0x8185
movb $0x2, %al
callq 0x1040
leaq 0x6551(%rip), %rdi      # 0x819a
callq 0x11f0
addq $0x3c, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x3a4b
// File: /workspace/github_c_makefile_star2_O1/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 0x1cdb
movaps %xmm0, %xmm2
mulss 0x94(%rbx), %xmm2
leaq 0x64e8(%rip), %rax      # 0x8160
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0xc(%rbx), %rax
jmp 0x1caa
leaq 0x24(%rbx), %rax
jmp 0x1c98
leaq 0x24(%rbx), %rax
xorps 0x64b8(%rip), %xmm2     # 0x8150
movl $0x2c, %ecx
jmp 0x1caf
leaq 0xc(%rbx), %rax
xorps 0x64a6(%rip), %xmm2     # 0x8150
movl $0x14, %ecx
movsd (%rax), %xmm0
movss (%rbx,%rcx), %xmm1
callq 0x2a72
movaps %xmm0, %xmm2
movaps %xmm1, %xmm3
movsd (%rbx), %xmm0
movss 0x8(%rbx), %xmm1
callq 0x2a62
movlps %xmm0, (%rbx)
movss %xmm1, 0x8(%rbx)
popq %rbx
retq
jmp 0x1cc3
// File: /workspace/github_c_makefile_star2_O1/Nealsbo[P]C-Software-Renderer/src/data.c
// Function: List_Init
void List_Init ( List *list, void ( *Print_Data )( void *data ), void ( *Destroy_Node )( void *data ) ){
    list->size = 0;
    list->Destroy_Node = Destroy_Node;
    list->Print_Data = Print_Data;
    list->head = NULL;
    list->tail = NULL;
}

// Assembly:
movl $0x0, (%rdi)
movq %rdx, 0x10(%rdi)
movq %rsi, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d33
cmpq $0x0, 0x20(%rbx)
je 0x1d33
movq %rbx, %rdi
callq 0x1d47
cmpl $0x0, (%rbx)
jg 0x1d1f
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1d74
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
cmpl $0x1, %eax
jne 0x1d80
movq (%r14), %rdi
callq *0x10(%rbx)
movq %r14, %rdi
callq 0x1288
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
jmp 0x1d9e
leaq 0x6457(%rip), %rdi      # 0x81d2
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_O1/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 0x1de0
movq %r14, (%rax)
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x1df5
movq 0x20(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq $0x0, 0x8(%rax)
movq %rdx, 0x10(%rax)
jmp 0x1e00
leaq 0x63c6(%rip), %rdi      # 0x81ad
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_O1/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 0x1e3b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
cmpq $0x0, 0x8(%r14)
je 0x1e33
movq (%r14), %rdi
callq *0x8(%rbx)
movq 0x8(%r14), %r14
jmp 0x1e20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x63bb(%rip), %rdi      # 0x81fd
jmp 0x11f0
// File: /workspace/github_c_makefile_star2_O1/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 0x619c(%rip), %xmm2     # 0x8014
xorps %xmm1, %xmm1
callq 0x47bf
movaps 0x10(%rsp), %xmm0
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
xorps %xmm1, %xmm1
movss 0x6180(%rip), %xmm2     # 0x8014
callq 0x47bf
xorps %xmm1, %xmm1
movss 0xc(%rsp), %xmm0
movss 0x616a(%rip), %xmm2     # 0x8014
addq $0x28, %rsp
jmp 0x47bf
// File: /workspace/github_c_makefile_star2_O1/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 0x60f6(%rip), %xmm1     # 0x8014
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
xorps %xmm2, %xmm2
cvtsi2ss %r11d, %xmm2
andl %ecx, %ebx
xorps %xmm3, %xmm3
cvtsi2ss %ebx, %xmm3
shrl $0x10, %r9d
shrl $0x10, %r10d
mulss %xmm0, %xmm3
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
cvttss2si %xmm2, %esi
andl %ecx, %r9d
xorps %xmm2, %xmm2
cvtsi2ss %r9d, %xmm2
andl %ecx, %r10d
xorps %xmm3, %xmm3
cvtsi2ss %r10d, %xmm3
mulss %xmm0, %xmm3
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
cvttss2si %xmm2, %edi
shrl $0x18, %edx
xorps %xmm2, %xmm2
cvtsi2ss %edx, %xmm2
shrl $0x18, %r8d
xorps %xmm3, %xmm3
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