LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: staticAllocate
struct object  *staticAllocate(int sz)
{
  staticPointer = WORDSDOWN(staticPointer, sz + 2);
  if(staticPointer < staticBase)
  {
    sysError("insufficient static memory", 0);
  }
  SETSIZE(staticPointer, sz);
  return (staticPointer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x423a6(%rip), %rax     # 0x48a08
movl -0x4(%rbp), %edx
addl $0x2, %edx
xorl %ecx, %ecx
subl %edx, %ecx
shll $0x3, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x4238c(%rip)     # 0x48a08
movq 0x42385(%rip), %rax     # 0x48a08
cmpq 0x4236e(%rip), %rax     # 0x489f8
jae 0x669c
leaq 0x3d47(%rip), %rdi      # 0xa3da
xorl %eax, %eax
movl %eax, %esi
callq 0x56d0
movl -0x4(%rbp), %ecx
shll $0x2, %ecx
movq 0x4235f(%rip), %rax     # 0x48a08
movl %ecx, (%rax)
movq 0x42356(%rip), %rax     # 0x48a08
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: staticIAllocate
struct object  *staticIAllocate(int sz)
{
  int             trueSize;
  struct object  *result;

  trueSize = (sz + BytesPerWord - 1) / BytesPerWord;
  result = staticAllocate(trueSize);
  SETSIZE(result, sz);
  result->size |= FLAG_BIN;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x8, %eax
subl $0x1, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x6650
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
shll $0x2, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x2, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: gcialloc
struct object  *gcialloc(int sz)
{
  int             trueSize;
  struct object  *result;

  trueSize = (sz + BytesPerWord - 1) / BytesPerWord;
  result = gcalloc(trueSize);
  SETSIZE(result, sz);
  result->size |= FLAG_BIN;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x8, %eax
subl $0x1, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
movq 0x422e2(%rip), %rax     # 0x48a18
movl -0x8(%rbp), %edx
addl $0x2, %edx
xorl %ecx, %ecx
subl %edx, %ecx
shll $0x3, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x422c8(%rip)     # 0x48a18
cmpq 0x422b9(%rip), %rax     # 0x48a10
jae 0x6767
movl -0x8(%rbp), %edi
callq 0x6050
movq %rax, -0x18(%rbp)
jmp 0x6781
movl -0x8(%rbp), %ecx
shll $0x2, %ecx
movq 0x422a4(%rip), %rax     # 0x48a18
movl %ecx, (%rax)
movq 0x4229b(%rip), %rax     # 0x48a18
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
shll $0x2, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
orl $0x2, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: addStaticRoot
void addStaticRoot(struct object **objp)
{
  LstUInt         i;

  for(i = 0; i < staticRootTop; ++i)
  {
    if(objp == staticRoots[i])
    {
      return;
    }
  }
  if(staticRootTop >= STATICROOTLIMIT)
  {
    sysError("addStaticRoot: too many static references",
             0);
  }
  staticRoots[staticRootTop++] = objp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x41cd4(%rip), %eax     # 0x48bd0
jae 0x6f23
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0x41cd2(%rip), %rcx     # 0x48be0
cmpq (%rcx,%rdx,8), %rax
jne 0x6f16
jmp 0x6f63
jmp 0x6f18
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6ef3
cmpl $0x1f4, 0x41ca3(%rip)   # imm = 0x1F4
jb 0x6f3f
leaq 0x34dc(%rip), %rdi      # 0xa412
xorl %eax, %eax
movl %eax, %esi
callq 0x56d0
movq -0x8(%rbp), %rdx
movl 0x41c87(%rip), %eax     # 0x48bd0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x41c7c(%rip)     # 0x48bd0
movl %eax, %eax
movl %eax, %ecx
leaq 0x41c81(%rip), %rax     # 0x48be0
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: exchangeObjects
void
exchangeObjects(struct object *array1, struct object *array2, LstUInt size)
{
  LstUInt         x;

  /*
   * Convert our memory spaces
   */
  walk(memoryPointer, memoryTop, array1, array2, size);
  walk(staticPointer, staticTop, array1, array2, size);

  /*
   * Fix up the root pointers, too
   */
  for(x = 0; x < rootTop; x++)
  {
    map(&rootStack[x], array1, array2, size);
  }
  for(x = 0; x < staticRootTop; x++)
  {
    map(staticRoots[x], array1, array2, size);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x41a8e(%rip), %rdi     # 0x48a18
movq 0x41a9f(%rip), %rsi     # 0x48a30
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
callq 0x7050
movq 0x41a5f(%rip), %rdi     # 0x48a08
movq 0x41a50(%rip), %rsi     # 0x48a00
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
callq 0x7050
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x419ff(%rip), %eax     # 0x489d0
jae 0x6fff
movl -0x18(%rbp), %eax
leaq 0x41a63(%rip), %rdi     # 0x48a40
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x7170
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6fc8
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x41bc1(%rip), %eax     # 0x48bd0
jae 0x703c
movl -0x18(%rbp), %eax
movl %eax, %ecx
leaq 0x41bc3(%rip), %rax     # 0x48be0
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x7170
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7006
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: walk
static void
walk(struct object *base, struct object *top,
     struct object *array1, struct object *array2, LstUInt size)
{
  struct object  *op,
                 *opnext;
  LstUInt         x,
                  sz;

  for(op = base; op < top; op = opnext)
  {
    /*
     * Re-map the class pointer, in case that's the
     * object which has been remapped.
     */
    map(&op->class, array1, array2, size);

    /*
     * Skip our argument arrays, since otherwise things
     * get rather circular.
     */
    sz = SIZE(op);
    if((op == array1) || (op == array2))
    {
      opnext = WORDSUP(op, sz + 2);
      continue;
    }

    /*
     * Don't have to worry about instance variables
     * if it's a binary format.
     */
    if(op->size & FLAG_BIN)
    {
      LstUInt         trueSize;

      /*
       * Skip size/class, and enough words to
       * contain the binary bytes.
       */
      trueSize = (sz + BytesPerWord - 1) / BytesPerWord;
      opnext = WORDSUP(op, trueSize + 2);
      continue;
    }

    /*
     * For each instance variable slot, fix up the pointer
     * if needed.
     */
    for(x = 0; x < sz; ++x)
    {
      map(&op->data[x], array1, array2, size);
    }

    /*
     * Walk past this object
     */
    opnext = WORDSUP(op, sz + 2);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x7169
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x7170
movq -0x30(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x70ba
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x70d5
movq -0x30(%rbp), %rax
movl -0x40(%rbp), %ecx
addl $0x2, %ecx
shll $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x715c
movq -0x30(%rbp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x710a
movl -0x40(%rbp), %eax
addl $0x8, %eax
subl $0x1, %eax
shrl $0x3, %eax
movl %eax, -0x44(%rbp)
movq -0x30(%rbp), %rax
movl -0x44(%rbp), %ecx
addl $0x2, %ecx
shll $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x715c
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jae 0x7146
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movl -0x3c(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x7170
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7111
movq -0x30(%rbp), %rax
movl -0x40(%rbp), %ecx
addl $0x2, %ecx
shll $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x7074
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: map
static void
map(struct object **oop, struct object *a1, struct object *a2, int size)
{
  int             x;
  struct object  *oo = *oop;

  for(x = 0; x < size; ++x)
  {
    if(a1->data[x] == oo)
    {
      *oop = a2->data[x];
      return;
    }
    if(a2->data[x] == oo)
    {
      *oop = a1->data[x];
      return;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x71fc
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
cmpq -0x28(%rbp), %rax
jne 0x71c6
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x71fc
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
cmpq -0x28(%rbp), %rax
jne 0x71ef
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x71fc
jmp 0x71f1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7195
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: lstNewString
struct object *lstNewString(const char *str)
{
  struct byteObject *stringObject;
  struct object *returnObject;
  LstUInt i;
  LstUInt l;

  l = strlen(str);

  stringObject = (struct byteObject *)gcialloc(l);
  returnObject = (struct object *)stringObject;
  returnObject->class = StringClass;

  for(i = 0; i < l; i++)
      stringObject->bytes[i] = str[i];

  return returnObject;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2100
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x6710
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x4176d(%rip), %rax     # 0x489a0
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x726d
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb %dl, 0x10(%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7245
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: lstGetString
void lstGetString(char *to, int size, struct object *from)
{
  int             i;
  int             fsize = SIZE(from);
  struct byteObject *bobj = (struct byteObject *) from;

  if(fsize > size)
  {
	  sysError("error converting text into unix string", (void *)(INT_PTR)fsize);
  }
  for(i = 0; i < fsize; i++)
  {
    to[i] = bobj->bytes[i];
  }
  to[i] = '\0';                 /* put null terminator at end */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x72bf
movslq -0x20(%rbp), %rsi
leaq 0x3182(%rip), %rdi      # 0xa43c
callq 0x56d0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x72f0
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb 0x10(%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x72c6
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: lstNewBinary
struct object *lstNewBinary(void *p, LstUInt l)
{
  struct byteObject *stringObject = (struct byteObject *) gcialloc(l);

  stringObject->class = StringClass; // TODO should use ByteArrayClass

  memcpy(stringObject->bytes, p, l);

  return (struct object *) stringObject;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x6710
movq %rax, -0x18(%rbp)
leaq 0x4166e(%rip), %rax     # 0x489a0
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x2200
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: readWord
static unsigned int readWord(FILE * fp)
{
  int             i;
  unsigned int    value;

  i = fgetc(fp);
  if(i == EOF)
  {
    sysError("unexpected end of file reading image file", 0);
  }

  value = i == 255 ? 255 + readWord(fp) : i;
  return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2170
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x738e
leaq 0x3121(%rip), %rdi      # 0xa4a6
xorl %eax, %eax
movl %eax, %esi
callq 0x56d0
cmpl $0xff, -0xc(%rbp)
jne 0x73aa
movq -0x8(%rbp), %rdi
callq 0x7360
addl $0xff, %eax
movl %eax, -0x14(%rbp)
jmp 0x73b0
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/memory.c
// Function: writeWord
static void writeWord(FILE * fp, int i)
{
  if(i < 0)
  {
	  sysError("trying to write out negative value", (void *)(INT_PTR)i);
  }
  if(i >= 255)
  {
    fputc(255, fp);
    writeWord(fp, i - 255);
  }
  else
  {
    fputc(i, fp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x73e5
movslq -0xc(%rbp), %rsi
leaq 0x310a(%rip), %rdi      # 0xa4ea
callq 0x56d0
cmpl $0xff, -0xc(%rbp)
jl 0x7410
movq -0x8(%rbp), %rsi
movl $0xff, %edi
callq 0x2190
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0xff, %esi
callq 0x73c0
jmp 0x741c
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x2190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/rss_dynload.c
// Function: rss_dlOpen
RSS_DL_Handle rss_dlOpen(const char *pathname, RSS_DL_Mode mode)
{
  int dlMode;
  RSS_DL_Handle h = (RSS_DL_Handle)malloc(sizeof(struct RSS_DL_Handle_Struct));
  if(!h)
    return 0;

  dlMode = mode == RSS_DL_LAZY ? RTLD_LAZY : RTLD_NOW;
  /*h->handle = dlopen(pathname, dlMode | RTLD_LOCAL);*/
  h->handle = dlopen(pathname, dlMode | RTLD_GLOBAL);

  if(!h->handle)
  {
    free(h);
    h = 0;
  }

  return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x8, %edi
callq 0x2230
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7e2e
movq $0x0, -0x8(%rbp)
jmp 0x7e83
movl -0x14(%rbp), %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
orl $0x100, %esi            # imm = 0x100
callq 0x21c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7e7b
movq -0x20(%rbp), %rdi
callq 0x2060
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/rss_dynload.c
// Function: rss_dlClose
int rss_dlClose(RSS_DL_Handle handle)
{
  int result = -1;

  if(!handle)
    return -1;

  if(handle->handle)
    result = dlclose(handle->handle);

  free(handle);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x10(%rbp)
jne 0x7eb3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7edb
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7ecc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2370
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2060
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/rss_queue.c
// Function: rss_queueCreate
RSS_Queue rss_queueCreate(int initialSize)
{
  RSS_Queue q;

  q = (RSS_Queue)malloc(sizeof(struct RSS_Queue_Struct));
  if(!q)
    return 0;

  q->maxSize    = 0;
  q->size       = 0;
  q->firstIndex = 0;
  q->lastIndex  = 0;
  q->queue      = 0;

  if(!rss_queueResize(q, initialSize ? initialSize : 100))
  {
    free(q);
    q = 0;
  }

  return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl $0x18, %edi
callq 0x2230
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7fcd
movq $0x0, -0x8(%rbp)
jmp 0x804e
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x801a
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x8024
movl $0x64, %eax
movl %eax, -0x24(%rbp)
jmp 0x8024
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x8060
cmpl $0x0, %eax
jne 0x8046
movq -0x18(%rbp), %rdi
callq 0x2060
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/rss_queue.c
// Function: rss_queueResize
static int rss_queueResize(RSS_Queue queue, int newSize)
{
  void **newQueue;
  int    i;

  if(!queue)
    return 0;

  newQueue = (void **)malloc(newSize * sizeof(void *));
  if(!newQueue)
    return 0;

  if(queue->queue)
  {
    for(i = 0; i < queue->size; i++)
      newQueue[i] = queue->queue[(queue->firstIndex + i) % queue->maxSize];

    free(queue->queue);
  }

  queue->queue      = newQueue;
  queue->firstIndex = 0;
  queue->lastIndex  = queue->size;
  queue->maxSize    = newSize;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8082
movl $0x0, -0x4(%rbp)
jmp 0x8145
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0x2230
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x80a6
movl $0x0, -0x4(%rbp)
jmp 0x8145
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8110
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x8103
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cltd
idivl (%rcx)
movq -0x30(%rbp), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x80b8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2060
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/rss_queue.c
// Function: rss_queueRelease
void rss_queueRelease(RSS_Queue queue)
{
  if(!queue)
    return;

  if(queue->queue)
    free(queue->queue);

  free(queue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8165
jmp 0x8186
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x817d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/rss_queue.c
// Function: rss_queueGet
void *rss_queueGet(RSS_Queue queue)
{
  void *element;

  if(!queue)
    return 0;

  if(queue->size <= 0)
    return 0;

  element = queue->queue[queue->firstIndex];
  queue->firstIndex++;
  if(queue->firstIndex >= queue->maxSize)
    queue->firstIndex -= queue->maxSize;

  queue->size--;

  return element;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x81d9
movq $0x0, -0x8(%rbp)
jmp 0x8248
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jg 0x81ed
movq $0x0, -0x8(%rbp)
jmp 0x8248
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x8233
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GregorR[P]lstg/source/rss_queue.c
// Function: rss_queuePut
int rss_queuePut(RSS_Queue queue, void *element)
{
  if(!queue)
    return 0;

  if(queue->size >= queue->maxSize)
  {
    if(!rss_queueResize(queue, queue->maxSize + (queue->maxSize / 2) + 1))
      return 0;
  }

  queue->queue[queue->lastIndex] = element;
  queue->lastIndex++;
  if(queue->lastIndex >= queue->maxSize)
    queue->lastIndex -= queue->maxSize;

  queue->size++;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8273
movl $0x0, -0x4(%rbp)
jmp 0x830e
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x82b4
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl %eax, %esi
addl $0x1, %esi
callq 0x8060
cmpl $0x0, %eax
jne 0x82b2
movl $0x0, -0x4(%rbp)
jmp 0x830e
jmp 0x82b4
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0xc(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x82fa
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/one-one/test/matrix.c
// Function: init
void init(matrix *t, int c) {
    t->mat = (int **)malloc(sizeof(int *) * t->r);
    for(int i = 0; i < t->r; i++ ) {
        t->mat[i] = (int *)malloc(sizeof(int) * t->c); 
    }
    // initialising the matrix with c
    for(int i = 0; i < t->r; i++) {
        for(int j = 0; j < t->c; j++) {
            t->mat[i][j] = c;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rdi
shlq $0x3, %rdi
callq 0x10d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1c0b
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rdi
shlq $0x2, %rdi
callq 0x10d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1bd1
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1c62
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x1c55
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c25
jmp 0x1c57
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c12
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/one-one/test/matrix.c
// Function: print_matrix
void print_matrix(matrix *t) {
    printf("\n");
    // t->mat[5][5] = 34;
    for(int i = 0; i < t->r; i++) {
        for(int j = 0; j < t->c; j++) {
            // printf("%d ", t->mat[i][j]);
            if(t->mat[i][j] != 80){
                final_check = 0;
            }
        }
        // printf("\n");
    }
    if(final_check == 1) {
        printf(GREEN "**PASSED** : MATRIX TEST with rows=%d, columns=%d\n" NONE, t->r, t->c);
    }
    else {
        printf(RED "**FAILED** : MATRIX TEST with rows=%d, columns=%d\n" NONE, t->r, t->c);

    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x133e(%rip), %rdi      # 0x3041
movb $0x0, %al
callq 0x10a0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1d6d
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x1d60
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
cmpl $0x50, (%rax,%rcx,4)
je 0x1d53
movl $0x0, 0x334d(%rip)      # 0x50a0
jmp 0x1d55
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1d24
jmp 0x1d62
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1d11
cmpl $0x1, 0x332c(%rip)      # 0x50a0
jne 0x1d94
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x12b8(%rip), %rdi      # 0x3043
movb $0x0, %al
callq 0x10a0
jmp 0x1db0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x12da(%rip), %rdi      # 0x3083
movb $0x0, %al
callq 0x10a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/one-one/test/matrix.c
// Function: partial_multiply
void* partial_multiply(void *arg) {
    int sum;
    rows *temp = (rows *)arg; 
    int start = temp->row_start;
    int end = temp->row_end + 1;
    // printf("D %d %d \n", start, end);
    for(int i = start; i < end; i++) {
        for(int j = 0; j < b.c; j++) {
            sum = 0;
            for( int k = 0; k < a.c; k++) {
                sum += a.mat[i][k] * b.mat[k][j];

            }
            res.mat[i][j] = sum;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x1ee8
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl 0x327c(%rip), %eax      # 0x50d4
jge 0x1ed8
movl $0x0, -0x14(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl 0x3273(%rip), %eax      # 0x50e4
jge 0x1eb1
movq 0x325e(%rip), %rax      # 0x50d8
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x3238(%rip), %rcx      # 0x50c8
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x30(%rbp), %rdx
imull (%rcx,%rdx,4), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1e68
movl -0x14(%rbp), %edx
movq 0x322d(%rip), %rax      # 0x50e8
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1e4f
jmp 0x1eda
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1e3c
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/client.c
// Function: version
static void
version(void)
{

	fprintf(stderr, "%s %s\n", __NAME_CLIENT__, __THIS_VERSION__);
	fprintf(stderr, "Copyright (c) 2016-2019 Tudor Ioan Roman\n");
	fprintf(stderr, "Released under the ISC License\n");

	exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3b35(%rip), %rax      # 0x5ff0
movq (%rax), %rdi
leaq 0x1ba4(%rip), %rsi      # 0x4069
leaq 0x1ba4(%rip), %rdx      # 0x4070
leaq 0x1b95(%rip), %rcx      # 0x4068
movb $0x0, %al
callq 0x2150
movq 0x3b0f(%rip), %rax      # 0x5ff0
movq (%rax), %rdi
leaq 0x1b89(%rip), %rsi      # 0x4074
movb $0x0, %al
callq 0x2150
movq 0x3af7(%rip), %rax      # 0x5ff0
movq (%rax), %rdi
leaq 0x1b9b(%rip), %rsi      # 0x409e
movb $0x0, %al
callq 0x2150
xorl %edi, %edi
callq 0x2060
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/client.c
// Function: init_xcb
static void
init_xcb(xcb_connection_t **conn)
{
	*conn = xcb_connect(NULL, NULL);
	if (xcb_connection_has_error(*conn))
		errx(EXIT_FAILURE, "unable to connect to X server");
	scr = xcb_setup_roots_iterator(xcb_get_setup(*conn)).data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x2090
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
cmpl $0x0, %eax
je 0x2566
movl $0x1, %edi
leaq 0x1b5f(%rip), %rsi      # 0x40be
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x20a0
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x400b(%rip)      # 0x6598
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/client.c
// Function: send_command
static void
send_command(struct Command *c, int argc, char **argv)
{
	xcb_client_message_event_t msg;
	xcb_client_message_data_t data;
	xcb_generic_error_t *err;
	xcb_void_cookie_t cookie;
	bool status = true;

	msg.response_type = XCB_CLIENT_MESSAGE;
	msg.type = get_atom(ATOM_COMMAND);
	msg.format = 32;
	data.data32[0] = c->command;
	if (c->handler != NULL)
		status = (c->handler)(data.data32 + 1, argc, argv);
	if (status == false)
		errx(EXIT_FAILURE, "malformed input");

	msg.data = data;

	cookie = xcb_send_event_checked(conn, false, scr->root,
			XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (char *)&msg);

	err = xcb_request_check(conn, cookie);
	if (err)
		fprintf(stderr, "oops %d\n", err->error_code);
	xcb_flush(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x5d(%rbp)
movb $0x21, -0x38(%rbp)
leaq 0x1f42(%rip), %rdi      # 0x4504
callq 0x31e0
movl %eax, -0x30(%rbp)
movb $0x20, -0x37(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2601
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
leaq -0x4c(%rbp), %rdi
addq $0x4, %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq *%rax
andb $0x1, %al
movb %al, -0x5d(%rbp)
movb -0x5d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2621
movl $0x1, %edi
leaq 0x1d61(%rip), %rsi      # 0x437b
movb $0x0, %al
callq 0x2120
movq -0x4c(%rbp), %rax
movq %rax, -0x2c(%rbp)
movq -0x44(%rbp), %rax
movq %rax, -0x24(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq 0x3f52(%rip), %rdi      # 0x6590
movq 0x3f53(%rip), %rax      # 0x6598
movl (%rax), %edx
xorl %esi, %esi
movl $0x100000, %ecx         # imm = 0x100000
leaq -0x38(%rbp), %r8
callq 0x2080
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq 0x3f29(%rip), %rdi      # 0x6590
movl -0x5c(%rbp), %esi
callq 0x2130
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x269a
movq 0x396f(%rip), %rax      # 0x5ff0
movq (%rax), %rdi
movq -0x58(%rbp), %rax
movzbl 0x1(%rax), %edx
leaq 0x1e82(%rip), %rsi      # 0x4515
movb $0x0, %al
callq 0x2150
movq 0x3eef(%rip), %rdi      # 0x6590
callq 0x20d0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/client.c
// Function: fn_offset
static bool
fn_offset(uint32_t *data, int argc, char **argv)
{
	int i = 0;
	do {
		errno = 0;
		int c = strtol(argv[i], NULL, 10);
		if (c >= 0)
			data[i] = IPC_MUL_PLUS;
		else
			data[i] = IPC_MUL_MINUS;
		data[i + 2] = abs(c);
		i++;
	} while (i < argc && errno == 0);

	if (errno != 0)
		return false;
	else
		return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
callq 0x2100
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x20e0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x2709
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x2718
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x1, (%rax,%rcx,4)
movl -0x28(%rbp), %edx
movl %edx, %eax
negl %eax
cmovnsl %eax, %edx
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x2756
callq 0x2100
cmpl $0x0, (%rax)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x26ca
callq 0x2100
cmpl $0x0, (%rax)
je 0x2771
movb $0x0, -0x1(%rbp)
jmp 0x2775
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/client.c
// Function: fn_naturals
static bool
fn_naturals(uint32_t *data, int argc, char **argv)
{
	int i = 0;
	do {
		errno = 0;
		data[i] = strtol(argv[i], NULL, 10);
		i++;
	} while (i < argc && errno == 0);

	if (errno != 0)
		return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
callq 0x2100
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x20e0
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x25(%rbp)
jge 0x27f0
callq 0x2100
cmpl $0x0, (%rax)
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x279a
callq 0x2100
cmpl $0x0, (%rax)
je 0x2807
movb $0x0, -0x1(%rbp)
jmp 0x280b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/client.c
// Function: fn_hack
static bool
fn_hack(uint32_t *data, int argc, char **argv)
{
	int i = 0, j = 0;
	unsigned long d;
	do {
		errno = 0;
		d = strtoul(argv[i], NULL, 10);
		if (i % 2 == 0) {
			data[j] = d << 16U;
		} else {
			data[j] |= d;
			j++;
		}
		i++;
	} while (i < argc && errno == 0);

	if (i % 2 == 1 || errno != 0)
		return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
callq 0x2100
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x2160
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x2891
movq -0x30(%rbp), %rax
shlq $0x10, %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x28af
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edx
orq %rsi, %rdx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x31(%rbp)
jge 0x28d3
callq 0x2100
cmpl $0x0, (%rax)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2841
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
je 0x28f8
callq 0x2100
cmpl $0x0, (%rax)
je 0x28fe
movb $0x0, -0x1(%rbp)
jmp 0x2902
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/client.c
// Function: fn_position
static bool
fn_position(uint32_t *data, int argc, char **argv)
{
	char *pos = argv[0];
	enum position snap_pos;

	if (strcasecmp(pos, "topleft") == 0)
		snap_pos = TOP_LEFT;
	else if (strcasecmp(pos, "topright") == 0)
		snap_pos = TOP_RIGHT;
	else if (strcasecmp(pos, "bottomleft") == 0)
		snap_pos = BOTTOM_LEFT;
	else if (strcasecmp(pos, "bottomright") == 0)
		snap_pos = BOTTOM_RIGHT;
	else if (strcasecmp(pos, "middle") == 0 ||
			strcasecmp(pos, "center") == 0 ||
			strcasecmp(pos, "centre") == 0)
		snap_pos = CENTER;
	else if (strcasecmp(pos, "left") == 0)
		snap_pos = LEFT;
	else if (strcasecmp(pos, "bottom") == 0)
		snap_pos = BOTTOM;
	else if (strcasecmp(pos, "top") == 0)
		snap_pos = TOP;
	else if (strcasecmp(pos, "right") == 0)
		snap_pos = RIGHT;
	else if (strcasecmp(pos, "all") == 0)
		snap_pos = ALL;
	else
		return false;

	(void)(argc);
	data[0] = snap_pos;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x19b0(%rip), %rsi      # 0x42e9
callq 0x2070
cmpl $0x0, %eax
jne 0x294f
movl $0x2, -0x2c(%rbp)
jmp 0x2aae
movq -0x28(%rbp), %rdi
leaq 0x1997(%rip), %rsi      # 0x42f1
callq 0x2070
cmpl $0x0, %eax
jne 0x2970
movl $0x3, -0x2c(%rbp)
jmp 0x2aac
movq -0x28(%rbp), %rdi
leaq 0x197f(%rip), %rsi      # 0x42fa
callq 0x2070
cmpl $0x0, %eax
jne 0x2991
movl $0x0, -0x2c(%rbp)
jmp 0x2aaa
movq -0x28(%rbp), %rdi
leaq 0x1969(%rip), %rsi      # 0x4305
callq 0x2070
cmpl $0x0, %eax
jne 0x29b2
movl $0x1, -0x2c(%rbp)
jmp 0x2aa8
movq -0x28(%rbp), %rdi
leaq 0x1954(%rip), %rsi      # 0x4311
callq 0x2070
cmpl $0x0, %eax
je 0x29f1
movq -0x28(%rbp), %rdi
leaq 0x1946(%rip), %rsi      # 0x4318
callq 0x2070
cmpl $0x0, %eax
je 0x29f1
movq -0x28(%rbp), %rdi
leaq 0x1938(%rip), %rsi      # 0x431f
callq 0x2070
cmpl $0x0, %eax
jne 0x29fd
movl $0x4, -0x2c(%rbp)
jmp 0x2aa6
movq -0x28(%rbp), %rdi
leaq 0x18f8(%rip), %rsi      # 0x4300
callq 0x2070
cmpl $0x0, %eax
jne 0x2a1e
movl $0x5, -0x2c(%rbp)
jmp 0x2aa4
movq -0x28(%rbp), %rdi
leaq 0x18fd(%rip), %rsi      # 0x4326
callq 0x2070
cmpl $0x0, %eax
jne 0x2a3c
movl $0x6, -0x2c(%rbp)
jmp 0x2aa2
movq -0x28(%rbp), %rdi
leaq 0x18e6(%rip), %rsi      # 0x432d
callq 0x2070
cmpl $0x0, %eax
jne 0x2a5a
movl $0x7, -0x2c(%rbp)
jmp 0x2aa0
movq -0x28(%rbp), %rdi
leaq 0x18a6(%rip), %rsi      # 0x430b
callq 0x2070
cmpl $0x0, %eax
jne 0x2a78
movl $0x8, -0x2c(%rbp)
jmp 0x2a9e
movq -0x28(%rbp), %rdi
leaq 0x18ae(%rip), %rsi      # 0x4331
callq 0x2070
cmpl $0x0, %eax
jne 0x2a96
movl $0x9, -0x2c(%rbp)
jmp 0x2a9c
movb $0x0, -0x1(%rbp)
jmp 0x2abb
jmp 0x2a9e
jmp 0x2aa0
jmp 0x2aa2
jmp 0x2aa4
jmp 0x2aa6
jmp 0x2aa8
jmp 0x2aaa
jmp 0x2aac
jmp 0x2aae
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/client.c
// Function: fn_direction
static bool
fn_direction(uint32_t *data, int argc, char **argv)
{
	char *pos = argv[0];
	enum direction dir_sel;

	if (strcasecmp(pos, "up") == 0 || strcasecmp(pos, "north") == 0)
		dir_sel = NORTH;
	else if (strcasecmp(pos, "down") == 0 || strcasecmp(pos, "south") == 0)
		dir_sel = SOUTH;
	else if (strcasecmp(pos, "left") == 0 || strcasecmp(pos, "west") == 0)
		dir_sel = WEST;
	else if (strcasecmp(pos, "right") == 0 || strcasecmp(pos, "east") == 0)
		dir_sel = EAST;
	else
		return false;

	(void)(argc);
	data[0] = dir_sel;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x1723(%rip), %rsi      # 0x421c
callq 0x2070
cmpl $0x0, %eax
je 0x2b18
movq -0x28(%rbp), %rdi
leaq 0x1827(%rip), %rsi      # 0x4335
callq 0x2070
cmpl $0x0, %eax
jne 0x2b24
movl $0x0, -0x2c(%rbp)
jmp 0x2bc9
movq -0x28(%rbp), %rdi
leaq 0x180c(%rip), %rsi      # 0x433b
callq 0x2070
cmpl $0x0, %eax
je 0x2b4e
movq -0x28(%rbp), %rdi
leaq 0x17fc(%rip), %rsi      # 0x4340
callq 0x2070
cmpl $0x0, %eax
jne 0x2b57
movl $0x1, -0x2c(%rbp)
jmp 0x2bc7
movq -0x28(%rbp), %rdi
leaq 0x179e(%rip), %rsi      # 0x4300
callq 0x2070
cmpl $0x0, %eax
je 0x2b81
movq -0x28(%rbp), %rdi
leaq 0x17cf(%rip), %rsi      # 0x4346
callq 0x2070
cmpl $0x0, %eax
jne 0x2b8a
movl $0x3, -0x2c(%rbp)
jmp 0x2bc5
movq -0x28(%rbp), %rdi
leaq 0x1776(%rip), %rsi      # 0x430b
callq 0x2070
cmpl $0x0, %eax
je 0x2bb4
movq -0x28(%rbp), %rdi
leaq 0x17a1(%rip), %rsi      # 0x434b
callq 0x2070
cmpl $0x0, %eax
jne 0x2bbd
movl $0x2, -0x2c(%rbp)
jmp 0x2bc3
movb $0x0, -0x1(%rbp)
jmp 0x2bd6
jmp 0x2bc5
jmp 0x2bc7
jmp 0x2bc9
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/client.c
// Function: fn_hex
static bool
fn_hex(uint32_t *data, int argc, char **argv)
{
	int i = 0;
	do {
		errno = 0;
		data[i] = strtol(argv[i], NULL, 16);
		i++;
	} while (i < argc && errno == 0);

	if (errno != 0)
		return false;
	else
		return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
callq 0x2100
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x20e0
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x25(%rbp)
jge 0x2c60
callq 0x2100
cmpl $0x0, (%rax)
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x2c0a
callq 0x2100
cmpl $0x0, (%rax)
je 0x2c77
movb $0x0, -0x1(%rbp)
jmp 0x2c7b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/client.c
// Function: fn_config
static bool
fn_config(uint32_t *data, int argc, char **argv) {
	char *key;
	bool status;
	int i;

	key = argv[0];

	i = 0;
	while (i < NR_IPC_CONFIGS && strcmp(key, configs[i].key) != 0)
		i++;

	if (i < NR_IPC_CONFIGS) {
		if (configs[i].argc != argc - 1)
			errx(EXIT_FAILURE, "too many or not enough arguments. Want: %d", configs[i].argc);
		data[0] = configs[i].config;
		status = (configs[i].handler)(data + 1, argc - 1, argv + 1);

		if (status == false)
			errx(EXIT_FAILURE, "malformed input");
	} else {
		errx(EXIT_FAILURE, "no such config key");
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x14, -0x28(%rbp)
movb %al, -0x29(%rbp)
jge 0x2ce7
movq -0x20(%rbp), %rdi
movslq -0x28(%rbp), %rcx
leaq 0x36d1(%rip), %rax      # 0x63a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x2110
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2cf0
jmp 0x2cfb
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2cb5
cmpl $0x14, -0x28(%rbp)
jge 0x2dbc
movslq -0x28(%rbp), %rcx
leaq 0x3690(%rip), %rax      # 0x63a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x2d4c
movslq -0x28(%rbp), %rcx
leaq 0x3671(%rip), %rax      # 0x63a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %edx
movl $0x1, %edi
leaq 0x160b(%rip), %rsi      # 0x4350
movb $0x0, %al
callq 0x2120
movslq -0x28(%rbp), %rcx
leaq 0x3649(%rip), %rax      # 0x63a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movslq -0x28(%rbp), %rcx
leaq 0x362e(%rip), %rax      # 0x63a0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
callq *%rax
andb $0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2dba
movl $0x1, %edi
leaq 0x15c8(%rip), %rsi      # 0x437b
movb $0x0, %al
callq 0x2120
jmp 0x2dcf
movl $0x1, %edi
leaq 0x15c3(%rip), %rsi      # 0x438b
movb $0x0, %al
callq 0x2120
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]windowchef/client.c
// Function: fn_gap
static bool
fn_gap(uint32_t *data, int argc, char **argv)
{
	(void)(argc);
	bool status = true;

	status = status && fn_position(data, 1, argv);
	status = status && fn_naturals(data + 1, 1, argv + 1);

	return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
xorl %eax, %eax
testb $0x1, -0x19(%rbp)
movb %al, -0x1a(%rbp)
je 0x2e17
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x2910
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
xorl %eax, %eax
testb $0x1, -0x19(%rbp)
movb %al, -0x1b(%rbp)
je 0x2e47
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
movl $0x1, %esi
callq 0x2780
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)