LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: tdefl_record_literal
static __forceinline void tdefl_record_literal(tdefl_compressor *d, mz_uint8 lit)
{
  d->m_total_lz_bytes++;
  *d->m_pLZ_code_buf++ = lit;
  *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1); if (--d->m_num_flags_left == 0) { d->m_num_flags_left = 8; d->m_pLZ_flags = d->m_pLZ_code_buf++; }
  d->m_huff_count[0][lit]++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rdx
movq 0x38(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x38(%rdx)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movzbl (%rax), %eax
sarl %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rcx
movl 0x58(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x58(%rcx)
cmpl $0x0, %eax
jne 0x95c4
movq -0x8(%rbp), %rax
movl $0x8, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movw 0x81d2(%rax,%rcx,2), %dx
addw $0x1, %dx
movw %dx, 0x81d2(%rax,%rcx,2)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: tdefl_huffman_enforce_max_code_size
static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)
{
  int i; mz_uint32 total = 0; if (code_list_len <= 1) return;
  for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) pNum_codes[max_code_size] += pNum_codes[i];
  for (i = max_code_size; i > 0; i--) total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i));
  while (total != (1UL << max_code_size))
  {
    pNum_codes[max_code_size]--;
    for (i = max_code_size - 1; i > 0; i--) if (pNum_codes[i]) { pNum_codes[i]--; pNum_codes[i + 1] += 2; break; }
    total--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jg 0xb910
jmp 0xb9fd
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jg 0xb943
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb919
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0xb973
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x10(%rbp), %ecx
subl -0x14(%rbp), %ecx
shll %cl, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb949
jmp 0xb975
movl -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
je 0xb9fd
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0xb9ef
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0xb9e2
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x2, %edx
movl %edx, (%rax,%rcx,4)
jmp 0xb9ef
jmp 0xb9e4
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb9a5
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb975
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/stack_lock-synchronized/code05.cpp
// Function: consume()
void consume()
{
	while (!stack.empty()){
		std::lock_guard < std::mutex > lock(mtx);
		if(!stack.empty()){
			sum += stack.top();
			stack.pop();
		}
	}
}

// Assembly:
subq $0x28, %rsp
leaq 0x5d65(%rip), %rdi      # 0x70f0
callq 0x16a0
xorb $-0x1, %al
testb $0x1, %al
jne 0x139b
jmp 0x1429
leaq 0x5da6(%rip), %rsi      # 0x7148
leaq 0x20(%rsp), %rdi
callq 0x1620
leaq 0x5d3d(%rip), %rdi      # 0x70f0
callq 0x16a0
movb %al, 0x13(%rsp)
jmp 0x13be
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x141a
jmp 0x13c8
leaq 0x5d21(%rip), %rdi      # 0x70f0
callq 0x16c0
movq %rax, 0x8(%rsp)
jmp 0x13db
movq 0x8(%rsp), %rax
movl (%rax), %ecx
movl 0x5d58(%rip), %eax      # 0x7140
addl %ecx, %eax
movl %eax, 0x5d50(%rip)      # 0x7140
leaq 0x5cf9(%rip), %rdi      # 0x70f0
callq 0x16d0
jmp 0x13fe
jmp 0x141a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1680
jmp 0x142e
leaq 0x20(%rsp), %rdi
callq 0x1680
jmp 0x1384
addq $0x28, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x1180
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/stack_lock-synchronized/code05.cpp
// Function: main
int main()
{
	std::thread t1{ produce };
	std::thread t2{ consume };
	std::thread t3{ consume };
	t1.join();
	t2.join();
	t3.join();
	consume();
	std::cout << sum << '\n';
}

// Assembly:
subq $0x38, %rsp
leaq -0x14b(%rip), %rsi      # 0x1300
leaq 0x30(%rsp), %rdi
callq 0x16e0
leaq -0xdc(%rip), %rsi       # 0x1380
leaq 0x28(%rsp), %rdi
callq 0x16e0
jmp 0x1468
leaq -0xef(%rip), %rsi       # 0x1380
leaq 0x10(%rsp), %rdi
callq 0x16e0
jmp 0x147b
leaq 0x30(%rsp), %rdi
callq 0x1160
jmp 0x1487
leaq 0x28(%rsp), %rdi
callq 0x1160
jmp 0x1493
leaq 0x10(%rsp), %rdi
callq 0x1160
jmp 0x149f
callq 0x1380
jmp 0x14a6
movl 0x5c94(%rip), %esi      # 0x7140
movq 0x5b25(%rip), %rdi      # 0x6fd8
callq 0x1170
movq %rax, 0x8(%rsp)
jmp 0x14bf
movq 0x8(%rsp), %rdi
movl $0xa, %esi
callq 0x1100
jmp 0x14d0
leaq 0x10(%rsp), %rdi
callq 0x17a0
leaq 0x28(%rsp), %rdi
callq 0x17a0
leaq 0x30(%rsp), %rdi
callq 0x17a0
xorl %eax, %eax
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1537
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x152d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x17a0
leaq 0x28(%rsp), %rdi
callq 0x17a0
leaq 0x30(%rsp), %rdi
callq 0x17a0
movq 0x20(%rsp), %rdi
callq 0x1180
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/strcpy.c
// Function: main
int main(int argc, char *argv[]) {
  char buf[16] = "";
  char *in = argv[1], *out = buf;

  if (argc > 1) {
    strcpy(out, in);
  }
  (void)printf(buf);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x11ad
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1030
leaq -0x20(%rbp), %rdi
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/bmfparse.c
// Function: print_variables
static void print_variables(FILE *fout, struct mof_variable *variables, uint32_t count) {
  uint32_t i;
  for (i = 0; i < count; ++i) {
    fprintf(fout, "  Variable %u:\n", i);
    print_variable(fout, &variables[i], 2);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x6f6e
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x1cc3(%rip), %rsi      # 0x8c03
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movl $0x2, %edx
callq 0x72b0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6f2a
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/bmfparse.c
// Function: print_parameters
static void print_parameters(FILE *fout, struct mof_method *method) {
  uint32_t i;
  for (i = 0; i < method->parameters_count; ++i) {
    fprintf(fout, "    Parameter %u:\n", i);
    fprintf(fout, "      Direction=");
    switch (method->parameters_direction[i]) {
    case MOF_PARAMETER_IN:
      fprintf(fout, "in");
      break;
    case MOF_PARAMETER_OUT:
      fprintf(fout, "out");
      break;
    case MOF_PARAMETER_IN_OUT:
      fprintf(fout, "in+out");
      break;
    default:
      fprintf(fout, "unknown");
      break;
    }
    fprintf(fout, "\n");
    print_variable(fout, &method->parameters[i], 4);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x729c
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x1a72(%rip), %rsi      # 0x8c37
xorl %eax, %eax
movb %al, -0x19(%rbp)
callq 0x10e0
movb -0x19(%rbp), %al
movq -0x8(%rbp), %rdi
leaq 0x1a6d(%rip), %rsi      # 0x8c4a
callq 0x10e0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x720e
jmp 0x71fa
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x7222
jmp 0x7204
movl -0x18(%rbp), %eax
subl $0x3, %eax
je 0x7236
jmp 0x724a
movq -0x8(%rbp), %rdi
leaq 0x1824(%rip), %rsi      # 0x8a3d
movb $0x0, %al
callq 0x10e0
jmp 0x725c
movq -0x8(%rbp), %rdi
leaq 0x1a31(%rip), %rsi      # 0x8c5e
movb $0x0, %al
callq 0x10e0
jmp 0x725c
movq -0x8(%rbp), %rdi
leaq 0x1a1a(%rip), %rsi      # 0x8c5b
movb $0x0, %al
callq 0x10e0
jmp 0x725c
movq -0x8(%rbp), %rdi
leaq 0x12ff(%rip), %rsi      # 0x8554
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
leaq 0x1435(%rip), %rsi      # 0x869c
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movl -0x14(%rbp), %eax
imulq $0x30, %rax, %rax
addq %rax, %rsi
movl $0x4, %edx
callq 0x72b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x71a7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/bmfparse.c
// Function: print_variable
static void print_variable(FILE *fout, struct mof_variable *variable, int indent) {
  fprintf(fout, "%*.s  Name=%s\n", indent, "", variable->name);
  fprintf(fout, "%*.s  Type=", indent, "");
  print_variable_type(fout, variable);
  fprintf(fout, "\n");
  print_qualifiers(fout, variable->qualifiers, variable->qualifiers_count, indent+2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %r8
leaq 0x1833(%rip), %rsi      # 0x8b0c
leaq 0x13bd(%rip), %rcx      # 0x869d
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x191e(%rip), %rsi      # 0x8c13
leaq 0x13a1(%rip), %rcx      # 0x869d
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6f80
movq -0x8(%rbp), %rdi
leaq 0x1381(%rip), %rsi      # 0x869c
movb $0x0, %al
callq 0x10e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
callq 0x6c10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear.h
// Function: nk_input_key
NK_API void
nk_input_key(struct nk_context *ctx, enum nk_keys key, int down)
{
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    if (in->keyboard.keys[key].down != down)
        in->keyboard.keys[key].clicked++;
    in->keyboard.keys[key].down = down;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xba5b
jmp 0xba7a
leaq 0x3a745(%rip), %rdi     # 0x461a7
leaq 0x3779a(%rip), %rsi     # 0x43203
movl $0x365c, %edx           # imm = 0x365C
leaq 0x3881a(%rip), %rcx     # 0x4428f
callq 0x3100
cmpq $0x0, -0x8(%rbp)
jne 0xba83
jmp 0xbab9
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,8), %eax
cmpl -0x10(%rbp), %eax
je 0xbaac
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl 0x4(%rax,%rcx,8), %edx
addl $0x1, %edx
movl %edx, 0x4(%rax,%rcx,8)
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_image_free
void
nk_xsurf_image_free(struct nk_image* image)
{
    XSurface *surf = xlib.surf;
    XImageWithAlpha *aimage = image->handle.ptr;
    if (!aimage) return;
    XDestroyImage(aimage->ximage);
    XFreePixmap(surf->dpy, aimage->clipMask);
    XFreeGC(surf->dpy, aimage->clipMaskGC);
    free(aimage);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2887d(%rip), %rax     # 0x58700
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2fe9b
jmp 0x2fee2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3500
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x32c0
movq -0x18(%rbp), %rdi
callq 0x31f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xfont_del
NK_API void
nk_xfont_del(Display *dpy, XFont *font)
{
    if(!font) return;
    if(font->set)
        XFreeFontSet(dpy, font->set);
    else
        XFreeFont(dpy, font->xfont);
    free(font);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x300f9
jmp 0x30131
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x30117
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x31d0
jmp 0x30128
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3110
movq -0x10(%rbp), %rdi
callq 0x31f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xfont_get_text_width
NK_INTERN float
nk_xfont_get_text_width(nk_handle handle, float height, const char *text, int len)
{
    XFont *font = (XFont*)handle.ptr;
    XRectangle r;
    if(!font || !text)
        return 0;

    if(font->set) {
        XmbTextExtents(font->set, (const char*)text, len, NULL, &r);
        return (float)r.width;
    } else{
        int w = XTextWidth(font->xfont, (const char*)text, len);
        return (float)w;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3036e
cmpq $0x0, -0x20(%rbp)
jne 0x30378
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x303cf
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x303ae
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x38(%rbp), %r8
callq 0x3490
movzwl -0x34(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x303cf
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x3390
movl %eax, -0x3c(%rbp)
cvtsi2ssl -0x3c(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_create
NK_INTERN XSurface*
nk_xsurf_create(int screen, unsigned int w, unsigned int h)
{
    XSurface *surface = (XSurface*)calloc(1, sizeof(XSurface));
    surface->w = w;
    surface->h = h;
    surface->dpy = xlib.dpy;
    surface->screen = screen;
    surface->root = xlib.root;
    surface->gc = XCreateGC(xlib.dpy, xlib.root, 0, NULL);
    XSetLineAttributes(xlib.dpy, surface->gc, 1, LineSolid, CapButt, JoinMiter);
    surface->drawable = XCreatePixmap(xlib.dpy, xlib.root, w, h,
        (unsigned int)DefaultDepth(xlib.dpy, screen));
    return surface;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x3460
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq 0x282f1(%rip), %rcx     # 0x58710
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq 0x282e0(%rip), %rcx     # 0x58718
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x282c9(%rip), %rdi     # 0x58710
movq 0x282ca(%rip), %rsi     # 0x58718
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x3370
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq 0x282a5(%rip), %rdi     # 0x58710
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r8d, %edx
movl %r9d, %ecx
callq 0x3310
movq 0x28283(%rip), %rdi     # 0x58710
movq 0x28284(%rip), %rsi     # 0x58718
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
movq 0x2826f(%rip), %rax     # 0x58710
movq 0xe8(%rax), %rax
movslq -0x4(%rbp), %r8
shlq $0x7, %r8
addq %r8, %rax
movl 0x38(%rax), %r8d
callq 0x3540
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xlib_set_font
NK_API void
nk_xlib_set_font(XFont *xfont)
{
    struct nk_user_font *font = &xfont->handle;
    font->userdata = nk_handle_ptr(xfont);
    font->height = (float)xfont->height;
    font->width = nk_xfont_get_text_width;
    nk_style_set_font(&xlib.ctx, font);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cvtsi2ssl 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq -0x1f8(%rip), %rcx      # 0x30340
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rsi
leaq 0x24181(%rip), %rdi     # 0x546c8
addq $0x38, %rdi
callq 0x10060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xlib_push_font
NK_API void
nk_xlib_push_font(XFont *xfont)
{
    struct nk_user_font *font = &xfont->handle;
    font->userdata = nk_handle_ptr(xfont);
    font->height = (float)xfont->height;
    font->width = nk_xfont_get_text_width;
    nk_style_push_font(&xlib.ctx, font);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cvtsi2ssl 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
leaq -0x278(%rip), %rcx      # 0x30340
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rsi
leaq 0x24101(%rip), %rdi     # 0x546c8
addq $0x38, %rdi
callq 0x10240
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xlib_copy
NK_API void
nk_xlib_copy(nk_handle handle, const char* str, int len)
{
    NK_UNUSED(handle);
    free(xlib.clipboard_data);
    xlib.clipboard_len = 0;
    xlib.clipboard_data = malloc((size_t)len);
    if (xlib.clipboard_data) {
        memcpy(xlib.clipboard_data, str, (size_t)len);
        xlib.clipboard_len = len;
        XSetSelectionOwner(xlib.dpy, XA_PRIMARY, xlib.root, CurrentTime);
        XSetSelectionOwner(xlib.dpy, xlib.xa_clipboard, xlib.root, CurrentTime);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x2403e(%rip), %rdi     # 0x546c8
callq 0x31f0
movl $0x0, 0x24037(%rip)     # 0x546d0
movslq -0x14(%rbp), %rdi
callq 0x3160
movq %rax, 0x2401f(%rip)     # 0x546c8
cmpq $0x0, 0x24017(%rip)     # 0x546c8
je 0x3070a
movq 0x2400e(%rip), %rdi     # 0x546c8
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x3570
movl -0x14(%rbp), %eax
movl %eax, 0x24000(%rip)     # 0x546d0
movq 0x28039(%rip), %rdi     # 0x58710
movq 0x2803a(%rip), %rdx     # 0x58718
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x33a0
movq 0x2801d(%rip), %rdi     # 0x58710
movq 0x23fe6(%rip), %rsi     # 0x546e0
movq 0x28017(%rip), %rdx     # 0x58718
xorl %eax, %eax
movl %eax, %ecx
callq 0x33a0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_resize
NK_INTERN void
nk_xsurf_resize(XSurface *surf, unsigned int w, unsigned int h)
{
    if(!surf) return;
    if (surf->w == w && surf->h == h) return;
    surf->w = w; surf->h = h;
    if(surf->drawable) XFreePixmap(surf->dpy, surf->drawable);
    surf->drawable = XCreatePixmap(surf->dpy, surf->root, w, h,
        (unsigned int)DefaultDepth(surf->dpy, surf->screen));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x313ce
jmp 0x31464
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x313e8
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x313e8
jmp 0x31464
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3141c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x3500
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0xe8(%rax), %rax
movq -0x8(%rbp), %r8
movslq 0x10(%r8), %r8
shlq $0x7, %r8
addq %r8, %rax
movl 0x38(%rax), %r8d
callq 0x3540
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xlib_shutdown
NK_API void
nk_xlib_shutdown(void)
{
    nk_xsurf_del(xlib.surf);
    nk_free(&xlib.ctx);
    XFreeCursor(xlib.dpy, xlib.cursor);
    nk_memset(&xlib, 0, sizeof(xlib));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x27285(%rip), %rdi     # 0x58700
callq 0x314c0
leaq 0x23241(%rip), %rdi     # 0x546c8
addq $0x38, %rdi
callq 0x11420
movq 0x27279(%rip), %rdi     # 0x58710
movq 0x2726a(%rip), %rsi     # 0x58708
callq 0x3060
leaq 0x2321e(%rip), %rdi     # 0x546c8
xorl %esi, %esi
movl $0x4060, %edx           # imm = 0x4060
callq 0x118e0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_scissor
NK_INTERN void
nk_xsurf_scissor(XSurface *surf, float x, float y, float w, float h)
{
    XRectangle clip_rect;
    clip_rect.x = (short)(x-1);
    clip_rect.y = (short)(y-1);
    clip_rect.width = (unsigned short)(w+2);
    clip_rect.height = (unsigned short)(h+2);
    XSetClipRectangles(surf->dpy, surf->gc, 0, 0, &clip_rect, 1, Unsorted);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
movss 0x1033b(%rip), %xmm1    # 0x42008
subss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movw %ax, -0x20(%rbp)
movss -0x10(%rbp), %xmm0
subss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movw %ax, -0x1e(%rbp)
movss -0x14(%rbp), %xmm0
movss 0x1030d(%rip), %xmm1    # 0x42004
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movw %ax, -0x1c(%rbp)
movss -0x18(%rbp), %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
xorl %ecx, %ecx
leaq -0x20(%rbp), %r8
movl $0x1, %r9d
movl %ecx, %edx
movl $0x0, (%rsp)
callq 0x34d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_stroke_line
NK_INTERN void
nk_xsurf_stroke_line(XSurface *surf, short x0, short y0, short x1,
    short y1, unsigned int line_thickness, struct nk_color col)
{
    unsigned long c = nk_color_from_byte(&col.r);
    XSetForeground(surf->dpy, surf->gc, c);
    XSetLineAttributes(surf->dpy, surf->gc, line_thickness, LineSolid, CapButt, JoinMiter);
    XDrawLine(surf->dpy, surf->drawable, surf->gc, (int)x0, (int)y0, (int)x1, (int)y1);
    XSetLineAttributes(surf->dpy, surf->gc, 1, LineSolid, CapButt, JoinMiter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %r8w, %ax
movl 0x10(%rbp), %r8d
movq %rdi, -0x8(%rbp)
movw %si, -0xa(%rbp)
movw %dx, -0xc(%rbp)
movw %cx, -0xe(%rbp)
movw %ax, -0x10(%rbp)
movl %r9d, -0x14(%rbp)
leaq 0x10(%rbp), %rdi
callq 0x31c40
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3260
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %edx
xorl %r9d, %r9d
movl $0x1, %r8d
movl %r9d, %ecx
callq 0x3310
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movswl -0xa(%rbp), %ecx
movswl -0xc(%rbp), %r8d
movswl -0xe(%rbp), %r9d
movswl -0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x3220
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r8d, %edx
movl %r9d, %ecx
callq 0x3310
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_stroke_circle
NK_INTERN void
nk_xsurf_stroke_circle(XSurface *surf, short x, short y, unsigned short w,
    unsigned short h, unsigned short line_thickness, struct nk_color col)
{
    unsigned long c = nk_color_from_byte(&col.r);
    XSetLineAttributes(surf->dpy, surf->gc, line_thickness, LineSolid, CapButt, JoinMiter);
    XSetForeground(surf->dpy, surf->gc, c);
    XDrawArc(surf->dpy, surf->drawable, surf->gc, (int)x, (int)y,
        (unsigned)w, (unsigned)h, 0, 360 * 64);
    XSetLineAttributes(surf->dpy, surf->gc, 1, LineSolid, CapButt, JoinMiter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %r8d, -0x30(%rbp)
movl %ecx, %eax
movl -0x30(%rbp), %ecx
movl %eax, -0x2c(%rbp)
movl %edx, %eax
movl -0x2c(%rbp), %edx
movl %eax, -0x28(%rbp)
movl %esi, %eax
movl -0x28(%rbp), %esi
movl %eax, -0x24(%rbp)
movq %rdi, %r8
movl -0x24(%rbp), %edi
movw %r9w, %ax
movl 0x10(%rbp), %r9d
movq %r8, -0x8(%rbp)
movw %di, -0xa(%rbp)
movw %si, -0xc(%rbp)
movw %dx, -0xe(%rbp)
movw %cx, -0x10(%rbp)
movw %ax, -0x12(%rbp)
leaq 0x10(%rbp), %rdi
callq 0x31c40
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movzwl -0x12(%rbp), %edx
xorl %r9d, %r9d
movl $0x1, %r8d
movl %r9d, %ecx
callq 0x3310
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3260
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movswl -0xa(%rbp), %ecx
movswl -0xc(%rbp), %r8d
movzwl -0xe(%rbp), %r9d
movzwl -0x10(%rbp), %eax
xorl %r10d, %r10d
movl %eax, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x5a00, 0x10(%rsp)     # imm = 0x5A00
callq 0x3470
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r8d, %edx
movl %r9d, %ecx
callq 0x3310
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_fill_circle
NK_INTERN void
nk_xsurf_fill_circle(XSurface *surf, short x, short y, unsigned short w,
    unsigned short h, struct nk_color col)
{
    unsigned long c = nk_color_from_byte(&col.r);
    XSetForeground(surf->dpy, surf->gc, c);
    XFillArc(surf->dpy, surf->drawable, surf->gc, (int)x, (int)y,
        (unsigned)w, (unsigned)h, 0, 360 * 64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %r8w, %ax
movl %r9d, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movw %si, -0x12(%rbp)
movw %dx, -0x14(%rbp)
movw %cx, -0x16(%rbp)
movw %ax, -0x18(%rbp)
leaq -0x4(%rbp), %rdi
callq 0x31c40
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3260
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movswl -0x12(%rbp), %ecx
movswl -0x14(%rbp), %r8d
movzwl -0x16(%rbp), %r9d
movzwl -0x18(%rbp), %eax
xorl %r10d, %r10d
movl %eax, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x5a00, 0x10(%rsp)     # imm = 0x5A00
callq 0x3250
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_stroke_triangle
NK_INTERN void
nk_xsurf_stroke_triangle(XSurface *surf, short x0, short y0, short x1,
    short y1, short x2, short y2, unsigned short line_thickness, struct nk_color col)
{
    unsigned long c = nk_color_from_byte(&col.r);
    XSetForeground(surf->dpy, surf->gc, c);
    XSetLineAttributes(surf->dpy, surf->gc, line_thickness, LineSolid, CapButt, JoinMiter);
    XDrawLine(surf->dpy, surf->drawable, surf->gc, x0, y0, x1, y1);
    XDrawLine(surf->dpy, surf->drawable, surf->gc, x1, y1, x2, y2);
    XDrawLine(surf->dpy, surf->drawable, surf->gc, x2, y2, x0, y0);
    XSetLineAttributes(surf->dpy, surf->gc, 1, LineSolid, CapButt, JoinMiter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %r8d, -0x30(%rbp)
movl %ecx, %eax
movl -0x30(%rbp), %ecx
movl %eax, -0x2c(%rbp)
movl %edx, %eax
movl -0x2c(%rbp), %edx
movl %eax, -0x28(%rbp)
movl %esi, %eax
movl -0x28(%rbp), %esi
movl %eax, -0x24(%rbp)
movq %rdi, %r8
movl -0x24(%rbp), %edi
movw %r9w, %ax
movl 0x20(%rbp), %r9d
movw 0x18(%rbp), %r9w
movw 0x10(%rbp), %r9w
movq %r8, -0x8(%rbp)
movw %di, -0xa(%rbp)
movw %si, -0xc(%rbp)
movw %dx, -0xe(%rbp)
movw %cx, -0x10(%rbp)
movw %ax, -0x12(%rbp)
leaq 0x20(%rbp), %rdi
callq 0x31c40
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x3260
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movzwl 0x18(%rbp), %edx
xorl %r9d, %r9d
movl $0x1, %r8d
movl %r9d, %ecx
callq 0x3310
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movswl -0xa(%rbp), %ecx
movswl -0xc(%rbp), %r8d
movswl -0xe(%rbp), %r9d
movswl -0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x3220
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movswl -0xe(%rbp), %ecx
movswl -0x10(%rbp), %r8d
movswl -0x12(%rbp), %r9d
movswl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x3220
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movswl -0x12(%rbp), %ecx
movswl 0x10(%rbp), %r8d
movswl -0xa(%rbp), %r9d
movswl -0xc(%rbp), %eax
movl %eax, (%rsp)
callq 0x3220
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r8d, %edx
movl %r9d, %ecx
callq 0x3310
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_fill_triangle
NK_INTERN void
nk_xsurf_fill_triangle(XSurface *surf, short x0, short y0, short x1,
    short y1, short x2, short y2, struct nk_color col)
{
    XPoint pnts[3];
    unsigned long c = nk_color_from_byte(&col.r);
    pnts[0].x = (short)x0;
    pnts[0].y = (short)y0;
    pnts[1].x = (short)x1;
    pnts[1].y = (short)y1;
    pnts[2].x = (short)x2;
    pnts[2].y = (short)y2;
    XSetForeground(surf->dpy, surf->gc, c);
    XFillPolygon(surf->dpy, surf->drawable, surf->gc, pnts, 3, Convex, CoordModeOrigin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %r8d, -0x38(%rbp)
movl %ecx, %eax
movl -0x38(%rbp), %ecx
movl %eax, -0x34(%rbp)
movl %edx, %eax
movl -0x34(%rbp), %edx
movl %eax, -0x30(%rbp)
movl %esi, %eax
movl -0x30(%rbp), %esi
movl %eax, -0x2c(%rbp)
movq %rdi, %r8
movl -0x2c(%rbp), %edi
movw %r9w, %ax
movl 0x18(%rbp), %r9d
movw 0x10(%rbp), %r9w
movq %r8, -0x8(%rbp)
movw %di, -0xa(%rbp)
movw %si, -0xc(%rbp)
movw %dx, -0xe(%rbp)
movw %cx, -0x10(%rbp)
movw %ax, -0x12(%rbp)
leaq 0x18(%rbp), %rdi
callq 0x31c40
movq %rax, -0x28(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0x1e(%rbp)
movw -0xc(%rbp), %ax
movw %ax, -0x1c(%rbp)
movw -0xe(%rbp), %ax
movw %ax, -0x1a(%rbp)
movw -0x10(%rbp), %ax
movw %ax, -0x18(%rbp)
movw -0x12(%rbp), %ax
movw %ax, -0x16(%rbp)
movw 0x10(%rbp), %ax
movw %ax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x3260
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq -0x1e(%rbp), %rcx
movl $0x3, %r8d
movl $0x2, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x33e0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_stroke_polygon
NK_INTERN void
nk_xsurf_stroke_polygon(XSurface *surf, const struct nk_vec2i *pnts, int count,
    unsigned short line_thickness, struct nk_color col)
{
    int i = 0;
    unsigned long c = nk_color_from_byte(&col.r);
    XSetForeground(surf->dpy, surf->gc, c);
    XSetLineAttributes(surf->dpy, surf->gc, line_thickness, LineSolid, CapButt, JoinMiter);
    for (i = 1; i < count; ++i)
        XDrawLine(surf->dpy, surf->drawable, surf->gc, pnts[i-1].x, pnts[i-1].y, pnts[i].x, pnts[i].y);
    XDrawLine(surf->dpy, surf->drawable, surf->gc, pnts[count-1].x, pnts[count-1].y, pnts[0].x, pnts[0].y);
    XSetLineAttributes(surf->dpy, surf->gc, 1, LineSolid, CapButt, JoinMiter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %cx, %ax
movl %r8d, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movw %ax, -0x1e(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x4(%rbp), %rdi
callq 0x31c40
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x3260
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movzwl -0x1e(%rbp), %edx
xorl %r9d, %r9d
movl $0x1, %r8d
movl %r9d, %ecx
callq 0x3310
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x32a08
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movswl (%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %r8d
subl $0x1, %r8d
movslq %r8d, %r8
movswl 0x2(%rax,%r8,4), %r8d
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %r9
movswl (%rax,%r9,4), %r9d
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %r10
movswl 0x2(%rax,%r10,4), %eax
movl %eax, (%rsp)
callq 0x3220
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x32995
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movswl (%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %r8d
subl $0x1, %r8d
movslq %r8d, %r8
movswl 0x2(%rax,%r8,4), %r8d
movq -0x18(%rbp), %rax
movswl (%rax), %r9d
movq -0x18(%rbp), %rax
movswl 0x2(%rax), %eax
movl %eax, (%rsp)
callq 0x3220
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r8d, %edx
movl %r9d, %ecx
callq 0x3310
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_fill_polygon
NK_INTERN void
nk_xsurf_fill_polygon(XSurface *surf,  const struct nk_vec2i *pnts, int count,
    struct nk_color col)
{
    int i = 0;
    #define MAX_POINTS 128
    XPoint xpnts[MAX_POINTS];
    unsigned long c = nk_color_from_byte(&col.r);
    XSetForeground(surf->dpy, surf->gc, c);
    for (i = 0; i < count && i < MAX_POINTS; ++i) {
        xpnts[i].x = pnts[i].x;
        xpnts[i].y = pnts[i].y;
    }
    XFillPolygon(surf->dpy, surf->drawable, surf->gc, xpnts, count, Convex, CoordModeOrigin);
    #undef MAX_POINTS
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movl %ecx, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x4(%rbp), %rdi
callq 0x31c40
movq %rax, -0x228(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x228(%rbp), %rdx
callq 0x3260
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x229(%rbp)
jge 0x32b02
cmpl $0x80, -0x20(%rbp)
setl %al
movb %al, -0x229(%rbp)
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x32b0e
jmp 0x32b4a
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movw (%rax,%rcx,4), %cx
movslq -0x20(%rbp), %rax
movw %cx, -0x220(%rbp,%rax,4)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movw 0x2(%rax,%rcx,4), %cx
movslq -0x20(%rbp), %rax
movw %cx, -0x21e(%rbp,%rax,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x32ae2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq -0x220(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl $0x2, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x33e0
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_stroke_polyline
NK_INTERN void
nk_xsurf_stroke_polyline(XSurface *surf, const struct nk_vec2i *pnts,
    int count, unsigned short line_thickness, struct nk_color col)
{
    int i = 0;
    unsigned long c = nk_color_from_byte(&col.r);
    XSetLineAttributes(surf->dpy, surf->gc, line_thickness, LineSolid, CapButt, JoinMiter);
    XSetForeground(surf->dpy, surf->gc, c);
    for (i = 0; i < count-1; ++i)
        XDrawLine(surf->dpy, surf->drawable, surf->gc, pnts[i].x, pnts[i].y, pnts[i+1].x, pnts[i+1].y);
    XSetLineAttributes(surf->dpy, surf->gc, 1, LineSolid, CapButt, JoinMiter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %cx, %ax
movl %r8d, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movw %ax, -0x1e(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x4(%rbp), %rdi
callq 0x31c40
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movzwl -0x1e(%rbp), %edx
xorl %r9d, %r9d
movl $0x1, %r8d
movl %r9d, %ecx
callq 0x3310
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x3260
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x32c7f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movswl (%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %r8
movswl 0x2(%rax,%r8,4), %r8d
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %r9d
addl $0x1, %r9d
movslq %r9d, %r9
movswl (%rax,%r9,4), %r9d
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %r10d
addl $0x1, %r10d
movslq %r10d, %r10
movswl 0x2(%rax,%r10,4), %eax
movl %eax, (%rsp)
callq 0x3220
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x32c05
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r8d, %edx
movl %r9d, %ecx
callq 0x3310
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_draw_text
NK_INTERN void
nk_xsurf_draw_text(XSurface *surf, short x, short y, unsigned short w, unsigned short h,
    const char *text, int len, XFont *font, struct nk_color cbg, struct nk_color cfg)
{
    int tx, ty;
    unsigned long bg = nk_color_from_byte(&cbg.r);
    unsigned long fg = nk_color_from_byte(&cfg.r);

    XSetForeground(surf->dpy, surf->gc, bg);
    XFillRectangle(surf->dpy, surf->drawable, surf->gc, (int)x, (int)y, (unsigned)w, (unsigned)h);
    if(!text || !font || !len) return;

    tx = (int)x;
    ty = (int)y + font->ascent;
    XSetForeground(surf->dpy, surf->gc, fg);
    if(font->set)
        XmbDrawString(surf->dpy,surf->drawable,font->set,surf->gc,tx,ty,(const char*)text,(int)len);
    else XDrawString(surf->dpy, surf->drawable, surf->gc, tx, ty, (const char*)text, (int)len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %r8w, %ax
movl 0x28(%rbp), %r8d
movl 0x20(%rbp), %r8d
movq 0x18(%rbp), %r8
movl 0x10(%rbp), %r8d
movq %rdi, -0x8(%rbp)
movw %si, -0xa(%rbp)
movw %dx, -0xc(%rbp)
movw %cx, -0xe(%rbp)
movw %ax, -0x10(%rbp)
movq %r9, -0x18(%rbp)
leaq 0x20(%rbp), %rdi
callq 0x31c40
movq %rax, -0x28(%rbp)
leaq 0x28(%rbp), %rdi
callq 0x31c40
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x3260
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movswl -0xa(%rbp), %ecx
movswl -0xc(%rbp), %r8d
movzwl -0xe(%rbp), %r9d
movzwl -0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x3270
cmpq $0x0, -0x18(%rbp)
je 0x32d5b
cmpq $0x0, 0x18(%rbp)
je 0x32d5b
cmpl $0x0, 0x10(%rbp)
jne 0x32d60
jmp 0x32e01
movswl -0xa(%rbp), %eax
movl %eax, -0x1c(%rbp)
movswl -0xc(%rbp), %eax
movq 0x18(%rbp), %rcx
addl (%rcx), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x3260
movq 0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x32dd4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movl -0x1c(%rbp), %r8d
movl -0x20(%rbp), %r9d
movq -0x18(%rbp), %r10
movl 0x10(%rbp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x3440
jmp 0x32e01
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movq -0x18(%rbp), %r9
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x3030
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/./nuklear_xlib.h
// Function: nk_xsurf_draw_image
NK_INTERN void
nk_xsurf_draw_image(XSurface *surf, short x, short y, unsigned short w, unsigned short h,
    struct nk_image img, struct nk_color col)
{
    XImageWithAlpha *aimage = img.handle.ptr;
    if (aimage){
        if (aimage->clipMask){
            XSetClipMask(surf->dpy, surf->gc, aimage->clipMask);
            XSetClipOrigin(surf->dpy, surf->gc, x, y); 
        }
        XPutImage(surf->dpy, surf->drawable, surf->gc, aimage->ximage, 0, 0, x, y, w, h);
        XSetClipMask(surf->dpy, surf->gc, None);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movl %r8d, -0x34(%rbp)
movl %ecx, %eax
movl -0x34(%rbp), %ecx
movl %eax, -0x30(%rbp)
movl %edx, %eax
movl -0x30(%rbp), %edx
movl %eax, -0x2c(%rbp)
movl %esi, %eax
movl -0x2c(%rbp), %esi
movq %rdi, %r8
movw %ax, %di
leaq 0x10(%rbp), %rax
movl %r9d, -0xc(%rbp)
movq %r8, -0x18(%rbp)
movw %di, -0x1a(%rbp)
movw %si, -0x1c(%rbp)
movw %dx, -0x1e(%rbp)
movw %cx, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3316d
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x33109
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x3120
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movswl -0x1a(%rbp), %edx
movswl -0x1c(%rbp), %ecx
callq 0x3560
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movswl -0x1a(%rbp), %ebx
movswl -0x1c(%rbp), %r11d
movzwl -0x1e(%rbp), %r10d
movzwl -0x20(%rbp), %eax
xorl %r9d, %r9d
movl %r9d, %r8d
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x33d0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3120
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/0x0203[P]schack_poc/main.c
// Function: die
static void
die(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);
    fputs("\n", stderr);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x35805
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x1e799(%rip), %rax     # 0x53ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x31b0
leaq -0x20(%rbp), %rax
movq 0x1e77e(%rip), %rax     # 0x53ff0
movq (%rax), %rsi
leaq 0x15b22(%rip), %rdi     # 0x4b39e
callq 0x3320
movl $0x1, %edi
callq 0x30f0
nopl (%rax,%rax)