LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq 0x163fd(%rip), %rax     # 0x24a28
movq %rax, -0x20(%rbp)
movq 0x1625a(%rip), %rax     # 0x24890
movq %rax, -0x18(%rbp)
movl 0x164b0(%rip), %eax     # 0x24af0
andl $0x20, %eax
cmpl $0x0, %eax
je 0xe653
movl 0x11192(%rip), %eax     # 0x1f7e0
movl %eax, -0x24(%rbp)
jmp 0xe65c
movl 0x11183(%rip), %eax     # 0x1f7dc
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rsi
movl 0x1646a(%rip), %edx     # 0x24ae0
movl -0x4(%rbp), %eax
imull 0x16468(%rip), %eax     # 0x24ae8
addl %eax, %edx
movl 0x16454(%rip), %ecx     # 0x24adc
movl -0x8(%rbp), %eax
imull 0x16452(%rip), %eax     # 0x24ae4
addl %eax, %ecx
movl -0xc(%rbp), %r8d
subl -0x4(%rbp), %r8d
addl $0x1, %r8d
imull 0x16440(%rip), %r8d     # 0x24ae8
movl -0x10(%rbp), %r9d
subl -0x8(%rbp), %r9d
addl $0x1, %r9d
imull 0x16428(%rip), %r9d     # 0x24ae4
callq 0x6420
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x63b0
addq $0x1, %rax
shlq $0x0, %rax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
callq 0x6220
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
xorl %esi, %esi
callq 0x60c0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x6840
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x18, %edi
callq 0x6220
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe79a
movq -0x8(%rbp), %rdi
callq 0x63b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0xe6d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/x.c
// Function: lastItem
struct _spareFontInfo *
lastItem(struct _spareFontInfo *head)
{
  if (head == NULL) return NULL;

  if (head->next == NULL)
  {
#ifdef __DEBUG
    printf("lastItem(): last_item 0x%X\n", head);
#endif
    return head;
  }
  else
    return lastItem(head->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe7cd
movq $0x0, -0x8(%rbp)
jmp 0xe7f3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe7e2
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe7f3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xe7b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/x.c
// Function: unloadSpareFontInfo
void
unloadSpareFontInfo(struct _spareFontInfo *spi)
{
  if (spi == NULL) return;

  if (spi->next != NULL) {
    unloadSpareFontInfo(spi->next);
  }

#ifdef __DEBUG
  printf("unloadSpareFontInfo() freeing item 0x%X, [%s]\n", spi, spi->fontString);
#endif
  if (spi->fontString != NULL) {
    free(spi->fontString);
    spi->fontString = NULL;
  }

  free(spi);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xe815
jmp 0xe857
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe82d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xe800
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe84e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6380
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x6380
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xe895
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xe800
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x6380
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movb $0x2c, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe8e4
movq $0x0, -0x8(%rbp)
jmp 0xe9e1
movl $0x10, %edi
callq 0x6220
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0x65a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe944
jmp 0xe922
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
movsbl -0x19(%rbp), %esi
callq 0x65a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xe919
movq -0x10(%rbp), %rdi
callq 0xe6d0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xe96b
movq -0x18(%rbp), %rdi
callq 0xe860
movq $0x0, -0x8(%rbp)
jmp 0xe9e1
movq -0x30(%rbp), %rdi
leaq -0x19(%rbp), %rsi
callq 0x6780
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe9d9
movq -0x28(%rbp), %rdi
callq 0xe740
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xe9a9
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xe9c6
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xe7b0
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
xorl %eax, %eax
movl %eax, %edi
leaq -0x19(%rbp), %rsi
callq 0x6780
movq %rax, -0x28(%rbp)
jmp 0xe97c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xeded
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xedf8
movq 0x15d04(%rip), %rax     # 0x24af8
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xee17
movq 0x15ce5(%rip), %rax     # 0x24af8
movq %rax, -0x8(%rbp)
movq 0x15b6a(%rip), %rdi     # 0x24988
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
movl $0x4, %ecx
leaq -0x28(%rbp), %r8
callq 0x6480
cmpl $0x0, %eax
je 0xee3c
jmp 0xee7a
movq 0x15b45(%rip), %rdi     # 0x24988
movq 0x15b4e(%rip), %rsi     # 0x24998
leaq -0x28(%rbp), %rdx
callq 0x6430
movq 0x15b2e(%rip), %rdi     # 0x24988
movq 0x15b37(%rip), %rsi     # 0x24998
movq 0x15b60(%rip), %rcx     # 0x249c8
leaq -0x28(%rbp), %rdx
callq 0x64a0
movq -0x28(%rbp), %rdi
callq 0x60a0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq 0x15c4a(%rip), %rcx     # 0x24b40
leaq 0x15c03(%rip), %rax     # 0x24b00
movq (%rax,%rcx,8), %rdi
callq 0x6380
cmpl $0x0, -0xc(%rbp)
je 0xef7e
movslq 0x15c2d(%rip), %rcx     # 0x24b40
leaq 0x15be6(%rip), %rax     # 0x24b00
movq $0x0, (%rax,%rcx,8)
movl 0x15c18(%rip), %eax     # 0x24b40
subl $0x1, %eax
addl $0x8, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, 0x15c04(%rip)     # 0x24b40
movslq 0x15bfd(%rip), %rcx     # 0x24b40
leaq 0x15bb6(%rip), %rax     # 0x24b00
cmpq $0x0, (%rax,%rcx,8)
je 0xef69
movslq 0x15be8(%rip), %rcx     # 0x24b40
leaq 0x15ba1(%rip), %rax     # 0x24b00
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
jmp 0xef74
movq 0x15b88(%rip), %rax     # 0x24af8
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xefc8
cmpq $0x0, -0x8(%rbp)
je 0xefa5
movq -0x8(%rbp), %rdi
callq 0x6d50
movq %rax, %rdx
movslq 0x15ba8(%rip), %rcx     # 0x24b40
leaq 0x15b61(%rip), %rax     # 0x24b00
movq %rdx, (%rax,%rcx,8)
jmp 0xefc6
movslq 0x15b94(%rip), %rcx     # 0x24b40
leaq 0x15b4d(%rip), %rax     # 0x24b00
movq $0x0, (%rax,%rcx,8)
movq 0x15b36(%rip), %rax     # 0x24af8
movq %rax, -0x8(%rbp)
jmp 0xefc8
movq 0x159b9(%rip), %rdi     # 0x24988
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
movl $0x4, %ecx
leaq -0x30(%rbp), %r8
callq 0x6480
cmpl $0x0, %eax
je 0xefed
jmp 0xf02b
movq 0x15994(%rip), %rdi     # 0x24988
movq 0x1599d(%rip), %rsi     # 0x24998
leaq -0x30(%rbp), %rdx
callq 0x6430
movq 0x1597d(%rip), %rdi     # 0x24988
movq 0x15986(%rip), %rsi     # 0x24998
movq 0x159a7(%rip), %rcx     # 0x249c0
leaq -0x30(%rbp), %rdx
callq 0x64a0
movq -0x30(%rbp), %rdi
callq 0x60a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x15af2(%rip), %eax     # 0x24b40
addl $0x1, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x15a99(%rip), %rax     # 0x24b00
movq (%rax,%rcx,8), %rdi
callq 0x6380
movslq 0x15ac9(%rip), %rcx     # 0x24b40
leaq 0x15a82(%rip), %rax     # 0x24b00
cmpq $0x0, (%rax,%rcx,8)
je 0xf0a2
movslq 0x15ab4(%rip), %rcx     # 0x24b40
leaq 0x15a6d(%rip), %rax     # 0x24b00
movq (%rax,%rcx,8), %rdi
callq 0x6d50
movq %rax, -0x10(%rbp)
jmp 0xf0aa
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0xf0aa
movq -0x10(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x15a47(%rip), %rax     # 0x24b00
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
movl %eax, 0x15a7a(%rip)     # 0x24b40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpq $0x0, 0x1486a(%rip)     # 0x24a10
jne 0x101aa
jmp 0x101ff
movl 0x14930(%rip), %eax     # 0x24ae0
movl -0x4(%rbp), %ecx
imull 0x1492e(%rip), %ecx     # 0x24ae8
addl %ecx, %eax
movw %ax, 0x14855(%rip)      # 0x24a18
movl 0x14913(%rip), %eax     # 0x24adc
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
imull 0x1490e(%rip), %ecx     # 0x24ae4
addl %ecx, %eax
movw %ax, 0x1483b(%rip)      # 0x24a1a
movq 0x1482a(%rip), %rdi     # 0x24a10
movq 0x14833(%rip), %rdx     # 0x24a20
leaq 0xafa2(%rip), %rsi      # 0x1b196
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x62a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/x.c
// Function: xsetmode
void
xsetmode(int set, unsigned int flags)
{
  int mode = win.mode;
  MODBIT(win.mode, set, flags);
  if ((win.mode & MODE_REVERSE) != (mode & MODE_REVERSE))
    redraw();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x1485c(%rip), %eax     # 0x24af0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x102ae
movl -0x8(%rbp), %eax
orl 0x1484a(%rip), %eax     # 0x24af0
movl %eax, 0x14844(%rip)     # 0x24af0
jmp 0x102c0
movl -0x8(%rbp), %eax
xorl $-0x1, %eax
andl 0x14836(%rip), %eax     # 0x24af0
movl %eax, 0x14830(%rip)     # 0x24af0
movl 0x1482a(%rip), %eax     # 0x24af0
andl $0x20, %eax
movl -0xc(%rbp), %ecx
andl $0x20, %ecx
cmpl %ecx, %eax
je 0x102d8
callq 0xa080
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/x.c
// Function: xsetcursor
int
xsetcursor(int cursor)
{
  if (!BETWEEN(cursor, 0, 7))
    return 1;
  win.cursor = cursor;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jg 0x102f4
cmpl $0x7, -0x8(%rbp)
jle 0x102fd
movl $0x1, -0x4(%rbp)
jmp 0x1030d
movl -0x8(%rbp), %eax
movl %eax, 0x147ee(%rip)     # 0x24af4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl 0x147c6(%rip), %eax     # 0x24af0
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x1033c
movl $0x1, %edi
callq 0x10370
cmpl $0x0, 0x14545(%rip)     # 0x24888
je 0x10362
movq 0x1463c(%rip), %rdi     # 0x24988
movq 0x14645(%rip), %rsi     # 0x24998
movl 0x1452f(%rip), %edx     # 0x24888
xorl %eax, %eax
movl %eax, %ecx
callq 0x69a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x14606(%rip), %rdi     # 0x24988
movq 0x1460f(%rip), %rsi     # 0x24998
callq 0x6560
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x103ab
movq -0x10(%rbp), %rax
movq (%rax), %rcx
orq $0x100, %rcx            # imm = 0x100
movq %rcx, (%rax)
jmp 0x103bc
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x101, %rcx           # imm = 0xFEFF
movq %rcx, (%rax)
movq 0x145c5(%rip), %rdi     # 0x24988
movq 0x145ce(%rip), %rsi     # 0x24998
movq -0x10(%rbp), %rdx
callq 0x6a10
movq -0x10(%rbp), %rdi
callq 0x60a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x140(%rbp), %rax
movq %rax, -0x260(%rbp)
cmpq $0x0, 0x14710(%rip)     # 0x24b48
je 0x1044a
movq 0x14707(%rip), %rax     # 0x24b48
movq %rax, -0x268(%rbp)
jmp 0x1045a
leaq 0xad5d(%rip), %rax      # 0x1b1ae
movq %rax, -0x268(%rbp)
jmp 0x1045a
movq -0x260(%rbp), %rdi
movq -0x268(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0xad30(%rip), %rdx      # 0x1b1a8
movb $0x0, %al
callq 0x60d0
leaq -0x240(%rbp), %rax
movq %rax, -0x270(%rbp)
cmpq $0x0, 0x146bb(%rip)     # 0x24b50
je 0x104a7
movq 0x146b2(%rip), %rax     # 0x24b50
movq %rax, -0x278(%rbp)
jmp 0x104b7
leaq 0xad03(%rip), %rax      # 0x1b1b1
movq %rax, -0x278(%rbp)
jmp 0x104b7
movq -0x270(%rbp), %rdi
movq -0x278(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0xacd3(%rip), %rdx      # 0x1b1a8
movb $0x0, %al
callq 0x60d0
movb $0x0, -0x141(%rbp)
movb $0x0, -0x41(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x140(%rbp), %rsi
leaq -0x240(%rbp), %rdx
leaq -0x248(%rbp), %rcx
leaq -0x258(%rbp), %r8
callq 0x6900
cmpq $0x0, -0x250(%rbp)
je 0x10533
movq -0x248(%rbp), %rsi
leaq 0xac90(%rip), %rdi      # 0x1b1b4
movl $0x40, %edx
callq 0x6210
cmpl $0x0, %eax
je 0x1053c
movl $0x1, -0x4(%rbp)
jmp 0x105b3
movl -0x1c(%rbp), %eax
movl %eax, -0x27c(%rbp)
testl %eax, %eax
je 0x10565
jmp 0x1054b
movl -0x27c(%rbp), %eax
subl $0x1, %eax
je 0x10575
jmp 0x10558
movl -0x27c(%rbp), %eax
subl $0x2, %eax
je 0x10594
jmp 0x105ac
movq -0x250(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x105ac
movq -0x250(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x69c0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
jmp 0x105ac
movq -0x250(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x64d0
movq -0x40(%rbp), %rax
movss %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x65d0
movq 0x143b4(%rip), %rdi     # 0x24988
callq 0x61a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x105e6
jmp 0x1063e
movq -0x8(%rbp), %rdi
callq 0x6740
movq %rax, -0x10(%rbp)
leaq 0xfa76(%rip), %rax      # 0x20070
movq %rax, -0x18(%rbp)
leaq 0xfa6b(%rip), %rax      # 0x20070
addq $0x4c8, %rax            # imm = 0x4C8
cmpq %rax, -0x18(%rbp)
jae 0x1063e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0x103f0
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x105fe
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/x.c
// Function: reload
void
reload(int sig)
{
  /* reload xresources */
  config_init();

  /* colors, fonts */
  xloadcols();
  xunloadfonts();
  xloadfonts(usedfont, 0);

  /* pretend the window just got resized */
  cresize(win.w, win.h);

  redraw();

  /* triggers re-render if we're visible. */
  ttywrite("\033[O", 3, 0);

  signal(SIGUSR1, reload);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x105c0
callq 0xe190
callq 0x10a40
movq 0x14167(%rip), %rdi     # 0x24b58
xorps %xmm0, %xmm0
callq 0x10ad0
movl 0x140d5(%rip), %edi     # 0x24ad4
movl 0x140d3(%rip), %esi     # 0x24ad8
callq 0x10e60
callq 0xa080
leaq 0xa824(%rip), %rdi      # 0x1b23a
movl $0x3, %esi
xorl %edx, %edx
callq 0x8400
movl $0xa, %edi
leaq -0x5e(%rip), %rsi       # 0x109d0
callq 0x6070
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
jmp 0x10a46
cmpl $0x0, 0x1417b(%rip)     # 0x24bc8
jle 0x10a80
movq 0x13f32(%rip), %rdi     # 0x24988
movq 0x14173(%rip), %rax     # 0x24bd0
movl 0x14165(%rip), %ecx     # 0x24bc8
addl $-0x1, %ecx
movl %ecx, 0x1415c(%rip)     # 0x24bc8
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x60f0
jmp 0x10a46
leaq 0x13e09(%rip), %rdi     # 0x24890
addq $0x10, %rdi
callq 0x12a70
leaq 0x13df9(%rip), %rdi     # 0x24890
addq $0x48, %rdi
callq 0x12a70
leaq 0x13de9(%rip), %rdi     # 0x24890
addq $0x80, %rdi
callq 0x12a70
leaq 0x13dd6(%rip), %rdi     # 0x24890
addq $0xb8, %rdi
callq 0x12a70
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x10e7d
movl -0x4(%rbp), %eax
movl %eax, 0x13c57(%rip)     # 0x24ad4
cmpl $0x0, -0x8(%rbp)
je 0x10e8c
movl -0x8(%rbp), %eax
movl %eax, 0x13c4c(%rip)     # 0x24ad8
movl 0x13c42(%rip), %eax     # 0x24ad4
movl 0x13cf0(%rip), %ecx     # 0x24b88
shll %ecx
subl %ecx, %eax
cltd
idivl 0x13c45(%rip)           # 0x24ae8
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jge 0x10eca
movl 0x13c20(%rip), %eax     # 0x24ad4
movl 0x13cce(%rip), %ecx     # 0x24b88
shll %ecx
subl %ecx, %eax
cltd
idivl 0x13c23(%rip)           # 0x24ae8
movl %eax, -0x14(%rbp)
jmp 0x10ed4
movl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10ed4
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl 0x13bf8(%rip), %eax     # 0x24ad8
movl 0x13ca2(%rip), %ecx     # 0x24b88
shll %ecx
subl %ecx, %eax
cltd
idivl 0x13bf3(%rip)           # 0x24ae4
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jge 0x10f18
movl 0x13bd6(%rip), %eax     # 0x24ad8
movl 0x13c80(%rip), %ecx     # 0x24b88
shll %ecx
subl %ecx, %eax
cltd
idivl 0x13bd1(%rip)           # 0x24ae4
movl %eax, -0x18(%rbp)
jmp 0x10f22
movl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x10f22
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl 0x13c5a(%rip), %eax     # 0x24b88
movl %eax, 0x13bac(%rip)     # 0x24ae0
movl %eax, 0x13ba2(%rip)     # 0x24adc
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x8b30
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x12d60
movl 0x13b76(%rip), %edi     # 0x24acc
movl 0x13b74(%rip), %esi     # 0x24ad0
callq 0x88b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x11f05(%rip), %rdi     # 0x24988
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x60f0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x6060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x12ab5
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x6550
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/x.c
// Function: xresize
void
xresize(int col, int row)
{
  win.tw = col * win.cw;
  win.th = row * win.ch;

  XFreePixmap(xw.dpy, xw.buf);
  xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, xw.depth);
  XftDrawChange(xw.draw, xw.buf);
  xclear(0, 0, win.w, win.h);

  /* resize to new width */
  xw.specbuf = xrealloc(xw.specbuf, col * sizeof(GlyphFontSpec));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
imull 0x11d70(%rip), %eax     # 0x24ae8
movl %eax, 0x11d4e(%rip)     # 0x24acc
movl -0x8(%rbp), %eax
imull 0x11d5c(%rip), %eax     # 0x24ae4
movl %eax, 0x11d42(%rip)     # 0x24ad0
movq 0x11bf3(%rip), %rdi     # 0x24988
movq 0x11c04(%rip), %rsi     # 0x249a0
callq 0x68d0
movq 0x11be0(%rip), %rdi     # 0x24988
movq 0x11be9(%rip), %rsi     # 0x24998
movl 0x11d1f(%rip), %edx     # 0x24ad4
movl 0x11d1d(%rip), %ecx     # 0x24ad8
movl 0x11cee(%rip), %r8d     # 0x24ab0
callq 0x6960
movq %rax, 0x11bd2(%rip)     # 0x249a0
movq 0x11c53(%rip), %rdi     # 0x24a28
movq 0x11bc4(%rip), %rsi     # 0x249a0
callq 0x6770
movl 0x11ced(%rip), %edx     # 0x24ad4
movl 0x11ceb(%rip), %ecx     # 0x24ad8
xorl %esi, %esi
movl %esi, %edi
callq 0x129e0
movq 0x11bab(%rip), %rdi     # 0x249a8
movslq -0x4(%rbp), %rsi
shlq $0x4, %rsi
callq 0x6d00
movq %rax, 0x11b97(%rip)     # 0x249a8
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/x.c
// Function: load_icon
void
load_icon(void)
{
  // declare X11 atoms
  xw.taskbar_icon_atom = XInternAtom(xw.dpy, "_NET_WM_ICON", False);
  xw.cardinal_atom = XInternAtom(xw.dpy, "CARDINAL", False);

  unsigned int pixmap_length = 2 + (tIconBytes.width * tIconBytes.height);

  // change property
  XChangeProperty(xw.dpy, xw.win,
                  xw.taskbar_icon_atom,
                  xw.cardinal_atom, 32,
                  PropModeReplace,
                  (unsigned char *)convert_pixmap(), pixmap_length);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x11449(%rip), %rdi     # 0x24988
leaq 0x8154(%rip), %rsi      # 0x1b69a
xorl %edx, %edx
callq 0x6810
movq %rax, 0x114a4(%rip)     # 0x249f8
movq 0x1142d(%rip), %rdi     # 0x24988
leaq 0x8145(%rip), %rsi      # 0x1b6a7
xorl %edx, %edx
callq 0x6810
movq %rax, 0x11490(%rip)     # 0x24a00
movl $0x1002, -0x4(%rbp)     # imm = 0x1002
movq 0x1140a(%rip), %rax     # 0x24988
movq %rax, -0x28(%rbp)
movq 0x1140f(%rip), %rax     # 0x24998
movq %rax, -0x20(%rbp)
movq 0x11464(%rip), %rax     # 0x249f8
movq %rax, -0x18(%rbp)
movq 0x11461(%rip), %rax     # 0x24a00
movq %rax, -0x10(%rbp)
callq 0x13790
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rax, %r10
movl -0x4(%rbp), %eax
movl $0x20, %r8d
xorl %r9d, %r9d
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x68b0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq -0x24(%rbp), %rdx
callq 0x61d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13617
movl $0x1, -0x4(%rbp)
jmp 0x136a4
movq 0x1136a(%rip), %rdi     # 0x24988
movq -0x20(%rbp), %rsi
callq 0x6850
movq 0x115a2(%rip), %rcx     # 0x24bd0
movslq 0x11593(%rip), %rdx     # 0x24bc8
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x13657
movq -0x20(%rbp), %rdi
callq 0x6060
movl $0x1, -0x4(%rbp)
jmp 0x136a4
movl -0x14(%rbp), %ecx
movq 0x1156f(%rip), %rax     # 0x24bd0
movslq 0x11560(%rip), %rdx     # 0x24bc8
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq 0x11557(%rip), %rax     # 0x24bd0
movslq 0x11548(%rip), %rcx     # 0x24bc8
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0xc(%rax)
movl 0x11534(%rip), %eax     # 0x24bc8
addl $0x1, %eax
movl %eax, 0x1152b(%rip)     # 0x24bc8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/x.c
// Function: xgeommasktogravity
int
xgeommasktogravity(int mask)
{
  switch (mask & (XNegative|YNegative)) {
  case 0:
    return NorthWestGravity;
  case XNegative:
    return NorthEastGravity;
  case YNegative:
    return SouthWestGravity;
  }

  return SouthEastGravity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x30, %eax
movl %eax, -0xc(%rbp)
je 0x13768
jmp 0x13754
movl -0xc(%rbp), %eax
subl $0x10, %eax
je 0x13771
jmp 0x1375e
movl -0xc(%rbp), %eax
subl $0x20, %eax
je 0x1377a
jmp 0x13783
movl $0x1, -0x4(%rbp)
jmp 0x1378a
movl $0x3, -0x4(%rbp)
jmp 0x1378a
movl $0x7, -0x4(%rbp)
jmp 0x1378a
movl $0x9, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/x.c
// Function: convert_pixmap
unsigned long *
convert_pixmap(void)
{

  unsigned int len;
  unsigned long *converted_icon_data = NULL;

  len = (unsigned int)(tIconBytes.width*tIconBytes.height);
  converted_icon_data = (unsigned long *)malloc(sizeof(unsigned long)*(len + 2));

  bzero(converted_icon_data, (len + 2)*sizeof(unsigned long));

  converted_icon_data[0] = (unsigned long)tIconBytes.width;
  converted_icon_data[1] = (unsigned long)tIconBytes.height;

  unsigned int *pixmap_pointer = (unsigned int *)tIconBytes.pixel_data;

  printf("Loading X11 Taskbar Icon: w: %d, h: %d, bpp: %d\n", tIconBytes.width, tIconBytes.height, tIconBytes.bytes_per_pixel << 3);
  for (unsigned int offset=0; offset<len; offset++) {
    (converted_icon_data + 2)[offset] = pixmap_pointer[offset];
  }

  // return converted pixmap
  return converted_icon_data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
movl $0x1000, -0x4(%rbp)     # imm = 0x1000
movl -0x4(%rbp), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x6220
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x60c0
movq -0x10(%rbp), %rax
movq $0x40, (%rax)
movq -0x10(%rbp), %rax
movq $0x40, 0x8(%rax)
leaq 0x36f3(%rip), %rax      # 0x16ee8
addq $0xc, %rax
movq %rax, -0x18(%rbp)
leaq 0x7eac(%rip), %rdi      # 0x1b6b0
movl $0x40, %edx
movl $0x20, %ecx
movl %edx, %esi
movb $0x0, %al
callq 0x60b0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jae 0x13849
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, 0x10(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1381e
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jg 0x13c82
cmpl $0xb, -0xc(%rbp)
jg 0x13c82
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
xorl $-0x1, %eax
andl 0x10fb8(%rip), %eax     # 0x24c34
movl %eax, 0x10fb2(%rip)     # 0x24c34
movl 0x10e68(%rip), %eax     # 0x24af0
andl $0xc018, %eax           # imm = 0xC018
cmpl $0x0, %eax
je 0x13caf
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl 0xe6a1(%rip), %eax      # 0x22340
cmpl $0x0, %eax
jne 0x13caf
movq -0x8(%rbp), %rdi
callq 0x14880
jmp 0x13cd8
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x14b50
cmpl $0x0, %eax
je 0x13cc4
jmp 0x13cd8
cmpl $0x1, -0xc(%rbp)
jne 0x13cd8
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x14dd0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x13d53
jmp 0x13e31
movq -0x8(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x13dca
cmpq $0x0, 0x10cac(%rip)     # 0x24a10
je 0x13d72
movq 0x10ca3(%rip), %rdi     # 0x24a10
callq 0x66e0
movl 0x10d78(%rip), %eax     # 0x24af0
orl $0x2, %eax
movl %eax, 0x10d6f(%rip)     # 0x24af0
xorl %edi, %edi
callq 0x10370
movl 0x10d62(%rip), %eax     # 0x24af0
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x13dab
leaq 0x7d30(%rip), %rdi      # 0x1bacf
movl $0x3, %esi
xorl %edx, %edx
callq 0x8400
cmpl $0x0, 0xc7be(%rip)      # 0x20570
jne 0x13dc8
movl $0x1, 0xc7b2(%rip)      # 0x20570
callq 0xe190
callq 0xa080
jmp 0x13e31
cmpq $0x0, 0x10c3e(%rip)     # 0x24a10
je 0x13de0
movq 0x10c35(%rip), %rdi     # 0x24a10
callq 0x6410
movl 0x10d0a(%rip), %eax     # 0x24af0
andl $-0x3, %eax
movl %eax, 0x10d01(%rip)     # 0x24af0
movl 0x10cfb(%rip), %eax     # 0x24af0
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x13e12
leaq 0x7434(%rip), %rdi      # 0x1b23a
movl $0x3, %esi
xorl %edx, %edx
callq 0x8400
cmpl $0x0, 0xc757(%rip)      # 0x20570
je 0x13e2f
movl $0x0, 0xc74b(%rip)      # 0x20570
callq 0xe190
callq 0xa080
jmp 0x13e31
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x10a65(%rip), %rdi     # 0x24988
leaq 0x73e1(%rip), %rsi      # 0x1b30b
xorl %edx, %edx
callq 0x6810
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x13f69
movq -0x10(%rbp), %rax
cmpq $0x1, 0x28(%rax)
je 0x13f60
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x13f69
movq -0x8(%rbp), %rdi
callq 0x141e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x10a40
movq 0x10310(%rip), %rdi     # 0x24b58
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x10ad0
callq 0x12e20
xorl %esi, %esi
movl %esi, %edi
callq 0x10e60
callq 0xa080
callq 0x13320
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %edi
callq 0x14d10
movl %eax, %ecx
movl -0x28(%rbp), %eax
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x24(%rbp)
leaq 0xd7c7(%rip), %rax      # 0x22350
movq %rax, -0x20(%rbp)
leaq 0xd7bc(%rip), %rax      # 0x22350
addq $0xa0, %rax
cmpq %rax, -0x20(%rbp)
jae 0x14c1c
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x14c09
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x14c09
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edi
movl -0x24(%rbp), %esi
callq 0x14540
cmpl $0x0, %eax
jne 0x14bee
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edi
movl -0x24(%rbp), %esi
movl 0xd761(%rip), %eax      # 0x22340
xorl $-0x1, %eax
andl %eax, %esi
callq 0x14540
cmpl $0x0, %eax
je 0x14c09
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x14c23
jmp 0x14c0b
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x14b8d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xccd1(%rip), %rdi      # 0xe050
movb $0x0, %al
callq 0x1040
movl $0x1, -0x4(%rbp)
movl $0x20, %edi
callq 0x1130
cmpl $0x0, %eax
jge 0x13bb
callq 0x1100
movq %rax, %rsi
leaq 0xccbe(%rip), %rdi      # 0xe069
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x1424
leaq 0xccd4(%rip), %rdi      # 0xe096
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
movl $0x500, %ecx            # imm = 0x500
movl $0x2d0, %r8d            # imm = 0x2D0
movl $0x4, %r9d
movl %edx, %esi
callq 0x1050
movq %rax, 0x11dd2(%rip)     # 0x131b8
cmpq $0x0, 0x11dca(%rip)     # 0x131b8
jne 0x140f
callq 0x1100
movq %rax, %rsi
leaq 0xcca9(%rip), %rdi      # 0xe0a8
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x1422
movq 0x11da2(%rip), %rdi     # 0x131b8
callq 0x11a0
movq %rax, 0x11d9e(%rip)     # 0x131c0
jmp 0x1424
leaq 0xcca9(%rip), %rdi      # 0xe0d4
movb $0x0, %al
callq 0x1040
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1260
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x1a(%rax)
je 0x1635
movl $0x1, 0x11b7b(%rip)     # 0x131b0
movq -0x10(%rbp), %rax
cmpb $0x0, 0x16(%rax)
je 0x1649
movl $0xffffffff, 0x11b67(%rip) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
cmpb $0x0, 0x7(%rax)
je 0x165d
movl $0x1, 0x11b57(%rip)     # 0x131b4
movq -0x10(%rbp), %rax
cmpb $0x0, 0x4(%rax)
je 0x1671
movl $0xffffffff, 0x11b43(%rip) # imm = 0xFFFFFFFF
jmp 0x1673
movq -0x18(%rbp), %rdi
callq 0x10d0
cmpl $0x0, %eax
je 0x16c9
movq -0x18(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jne 0x1699
movl $0x1, 0x11b11(%rip)     # 0x131a8
jmp 0x16c7
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdi
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x1850
jmp 0x1673
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xca4b(%rip), %rsi      # 0xe13a
callq 0xcc30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x175c
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movss -0xc(%rbp), %xmm1
movss 0xc8f8(%rip), %xmm0     # 0xe00c
mulss %xmm0, %xmm1
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
callq 0x4270
movq -0x58(%rbp), %rdi
movss %xmm1, -0x30(%rbp)
movlpd %xmm0, -0x38(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movss -0x40(%rbp), %xmm1
callq 0xa650
movl 0x11a4e(%rip), %eax     # 0x131b0
movl %eax, -0x4c(%rbp)
movl 0x11a49(%rip), %eax     # 0x131b4
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x17b0
cmpl $0x0, -0x4c(%rbp)
jle 0x1795
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movss -0xc(%rbp), %xmm0
movl $0x1, %esi
callq 0x2650
jmp 0x17ae
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movss -0xc(%rbp), %xmm0
movl $0x2, %esi
callq 0x2650
jmp 0x17b0
cmpl $0x0, -0x50(%rbp)
je 0x17f2
cmpl $0x0, -0x50(%rbp)
jle 0x17d7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movss -0xc(%rbp), %xmm0
movl $0x3, %esi
callq 0x2650
jmp 0x17f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movss -0xc(%rbp), %xmm0
movl $0x4, %esi
callq 0x2650
jmp 0x17f2
movl $0x0, 0x119b4(%rip)     # 0x131b0
movl $0x0, 0x119ae(%rip)     # 0x131b4
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0xc90c(%rip), %rdi      # 0xe127
movb $0x0, %al
callq 0x1040
callq 0x1cb0
movq 0x1198a(%rip), %rdi     # 0x131b8
callq 0x1030
movq $0x0, 0x1197a(%rip) # 0x131b8
callq 0x1070
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Nealsbo[P]C-Software-Renderer/src/application.c
// Function: IH_Handle
void IH_Handle( SDL_Event e, renderer_t *renderer ) {
    switch( e.type ){
        case SDL_KEYDOWN:
            switch( e.key.keysym.sym ) {
                case SDLK_ESCAPE:
                    quit = TRUE;
                    break;
                case SDLK_q:
                    quit = TRUE;
                    break;
                case SDLK_r:
                    Renderer_SwitchRendState( renderer );
                    break;
                default:
                    break;
            }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movl (%rax), %eax
subl $0x300, %eax            # imm = 0x300
jne 0x18bb
jmp 0x186f
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1b, %eax
je 0x1894
jmp 0x1880
movl -0x14(%rbp), %eax
subl $0x71, %eax
je 0x18a0
jmp 0x188a
movl -0x14(%rbp), %eax
subl $0x72, %eax
je 0x18ac
jmp 0x18b7
movl $0x1, 0x1190a(%rip)     # 0x131a8
jmp 0x18b9
movl $0x1, 0x118fe(%rip)     # 0x131a8
jmp 0x18b9
movq -0x8(%rbp), %rdi
callq 0xbe00
jmp 0x18b9
jmp 0x18b9
jmp 0x18bb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)