LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_clipboard
static int f_clipboard(lua_State *L) {
  if (lua_gettop(L) > 0) {
    const char *text = luaL_checkstring(L, 1);
    if (SDL_SetClipboardText(text)) luaL_error(L, "SDL_SetClipboardText() failed: %s", SDL_GetError());
    lua_pushstring(L, text);
    return 1;
  }
  else {
    lua_pushstring(L, SDL_GetClipboardText());
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6d60
cmpl $0x0, %eax
jle 0x514e6
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf060
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x67d0
cmpl $0x0, %eax
je 0x514d0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x6390
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x6b85(%rip), %rsi      # 0x5804e
movb $0x0, %al
callq 0xe880
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9100
movl $0x1, -0x4(%rbp)
jmp 0x51506
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x6210
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x9100
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_randomseed
static int f_randomseed(lua_State *L) {
  if (lua_gettop(L) > 0) {
    Uint32 x = (Uint32)luaL_checkinteger(L, 1);
    px_randomseed(x);
  }
  lua_pushinteger(L, (lua_Integer)seed);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d60
cmpl $0x0, %eax
jle 0x51543
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x51ff0
movq -0x8(%rbp), %rdi
movl 0x11360b(%rip), %eax    # 0x164b58
movl %eax, %esi
callq 0x8e00
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_random
static int f_random(lua_State *L) {
  lua_Integer low, up;
  double r = (double)(px_rand() % 100000) / 100000.0;
  switch (lua_gettop(L)) {
  case 0: lua_pushnumber(L, (lua_Number)r); return 1;
  case 1: low = 1; up = luaL_checkinteger(L, 1); break;
  case 2: low = luaL_checkinteger(L, 1); up = luaL_checkinteger(L, 2); break;
  default: return luaL_error(L, "wrong number of arguments");
  }
  luaL_argcheck(L, low <= up, 1, "interval is empty");
  luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1, "interval too large");
  r *= (double)(up - low) + 1.0;
  lua_pushinteger(L, (lua_Integer)r + low);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x52050
movl %eax, %ecx
shrl $0x5, %ecx
imulq $0xa7c5ac5, %rcx, %rcx  # imm = 0xA7C5AC5
shrq $0x27, %rcx
imull $0x186a0, %ecx, %ecx    # imm = 0x186A0
subl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd 0x611b(%rip), %xmm1     # 0x576b0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6d60
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
testl %eax, %eax
je 0x515c6
jmp 0x515b2
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x515e0
jmp 0x515bc
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x515fc
jmp 0x51622
movq -0x10(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x8db0
movl $0x1, -0x4(%rbp)
jmp 0x516f2
movq $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movq %rax, -0x20(%rbp)
jmp 0x5163c
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xf220
movq %rax, -0x20(%rbp)
jmp 0x5163c
movq -0x10(%rbp), %rdi
leaq 0x536e(%rip), %rsi      # 0x5699b
movb $0x0, %al
callq 0xe880
movl %eax, -0x4(%rbp)
jmp 0x516f2
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpq -0x20(%rbp), %rcx
movb %al, -0x2d(%rbp)
jle 0x51669
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x535a(%rip), %rdx      # 0x569b5
callq 0xe740
cmpl $0x0, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x2e(%rbp)
jge 0x516b2
movq -0x20(%rbp), %rcx
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
addq -0x18(%rbp), %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x2e(%rbp)
jle 0x516b2
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x5323(%rip), %rdx      # 0x569c7
callq 0xe740
cmpl $0x0, %eax
setne %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
movq -0x20(%rbp), %rax
subq -0x18(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x3fc6(%rip), %xmm1     # 0x55690
addsd %xmm1, %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
cvttsd2si -0x28(%rbp), %rsi
addq -0x18(%rbp), %rsi
callq 0x8e00
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_resolution
static int f_resolution(lua_State *L) {
  int width = (int)luaL_checkinteger(L, 1);
  int height = (int)luaL_checkinteger(L, 2);
  luaL_argcheck(L, width > 0 && width < PX_SCREEN_MAX_WIDTH, 1, "invalid width value");
  luaL_argcheck(L, height > 0 && height < PX_SCREEN_MAX_HEIGHT, 2, "invalid height value");
  px_create_texture(L, width, height);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf220
movl %eax, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x517e2
movb $0x1, %al
cmpl $0x400, -0xc(%rbp)      # imm = 0x400
movb %al, -0x11(%rbp)
jl 0x51800
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x687e(%rip), %rdx      # 0x58070
callq 0xe740
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
cmpl $0x0, -0x10(%rbp)
jle 0x51817
movb $0x1, %al
cmpl $0x400, -0x10(%rbp)     # imm = 0x400
movb %al, -0x12(%rbp)
jl 0x51835
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x685d(%rip), %rdx      # 0x58084
callq 0xe740
cmpl $0x0, %eax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x520a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_compress
static int f_compress(lua_State *L) {
  size_t source_size;
  luaL_Buffer buffer;
  const char *source = luaL_checklstring(L, 1, &source_size);
  int dest_size = LZ4_compressBound((int)source_size);
  char *dest = luaL_buffinitsize(L, &buffer, dest_size);
  dest_size = LZ4_compress_default(source, dest, (int)source_size, dest_size);
  if (!dest_size) luaL_error(L, "compression failed");
  luaL_pushresultsize(&buffer, dest_size);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0xf060
movq %rax, -0x2038(%rbp)
movq -0x10(%rbp), %rax
movl %eax, %edi
callq 0x36ef0
movl %eax, -0x203c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x203c(%rbp), %rdx
leaq -0x2030(%rbp), %rsi
callq 0xf7c0
movq %rax, -0x2048(%rbp)
movq -0x2038(%rbp), %rdi
movq -0x2048(%rbp), %rsi
movq -0x10(%rbp), %rax
movl %eax, %edx
movl -0x203c(%rbp), %ecx
callq 0x3b0f0
movl %eax, -0x203c(%rbp)
cmpl $0x0, -0x203c(%rbp)
jne 0x518e7
movq -0x8(%rbp), %rdi
leaq 0x6827(%rip), %rsi      # 0x58107
movb $0x0, %al
callq 0xe880
movslq -0x203c(%rbp), %rsi
leaq -0x2030(%rbp), %rdi
callq 0xf690
movl $0x1, %eax
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_decompress
static int f_decompress(lua_State *L) {
  size_t source_size;
  luaL_Buffer buffer;
  const char *source = luaL_checklstring(L, 1, &source_size);
  int dest_size = (int)luaL_optinteger(L, 2, 64 * 1024);
  char *dest = luaL_buffinitsize(L, &buffer, dest_size);
  dest_size = LZ4_decompress_safe(source, dest, (int)source_size, dest_size);
  if (!dest_size) luaL_error(L, "decompression failed");
  luaL_pushresultsize(&buffer, dest_size);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0xf060
movq %rax, -0x2038(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0xf2b0
movl %eax, -0x203c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x203c(%rbp), %rdx
leaq -0x2030(%rbp), %rsi
callq 0xf7c0
movq %rax, -0x2048(%rbp)
movq -0x2038(%rbp), %rdi
movq -0x2048(%rbp), %rsi
movq -0x10(%rbp), %rax
movl %eax, %edx
movl -0x203c(%rbp), %ecx
callq 0x42a40
movl %eax, -0x203c(%rbp)
cmpl $0x0, -0x203c(%rbp)
jne 0x519af
movq -0x8(%rbp), %rdi
leaq 0x675d(%rip), %rsi      # 0x58105
movb $0x0, %al
callq 0xe880
movslq -0x203c(%rbp), %rsi
leaq -0x2030(%rbp), %rdi
callq 0xf690
movl $0x1, %eax
addq $0x2050, %rsp           # imm = 0x2050
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_bind
static int f_bind(lua_State *L) {
  struct sockaddr_in sin;
  Uint16 port = (Uint16)luaL_checkinteger(L, 1);
  // prepare addr
  SDL_zero(sin);
  sin.sin_family = AF_INET;
  sin.sin_port = htons(port);
  sin.sin_addr.s_addr = htonl(INADDR_ANY);
  // bind socket
  net_create_socket(L);
  if (bind(socket_fd, (struct sockaddr*)&sin, sizeof(sin))) luaL_error(L, "Cannot bind on port %d", port);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xf220
movw %ax, -0x1a(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x6240
movw $0x2, -0x18(%rbp)
movzwl -0x1a(%rbp), %edi
callq 0x6080
movw %ax, -0x16(%rbp)
xorl %edi, %edi
callq 0x63a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x52220
movl 0x113132(%rip), %edi    # 0x164b5c
leaq -0x18(%rbp), %rsi
movl $0x10, %edx
callq 0x60f0
cmpl $0x0, %eax
je 0x51a53
movq -0x8(%rbp), %rdi
movzwl -0x1a(%rbp), %edx
leaq 0x66ce(%rip), %rsi      # 0x5811a
movb $0x0, %al
callq 0xe880
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_unbind
static int f_unbind(lua_State *L) {
  (void)L;
  if (socket_fd != INVALID_SOCKET) {
    closesocket(socket_fd);
    socket_fd = INVALID_SOCKET;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $-0x1, 0x1130e9(%rip)   # 0x164b5c
je 0x51a8a
movl 0x1130e1(%rip), %edi    # 0x164b5c
callq 0x68a0
movl $0xffffffff, 0x1130d2(%rip) # imm = 0xFFFFFFFF
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_send
static int f_send(lua_State *L) {
  struct sockaddr_in sin;
  size_t datalen;
  int sent;
  const char *data = luaL_checklstring(L, 1, &datalen);
  Uint32 host = (Uint32)luaL_checkinteger(L, 2);
  Uint16 port = (Uint16)luaL_checkinteger(L, 3);
  // prepare addr
  SDL_zero(sin);
  sin.sin_family = AF_INET;
  sin.sin_port = htons(port);
  sin.sin_addr.s_addr = htonl(host);
  // sned
  net_create_socket(L);
  sent = sendto(socket_fd, data, (int)datalen, 0, (struct sockaddr*)&sin, sizeof(sin));
  lua_pushboolean(L, sent == (int)datalen);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x20(%rbp), %rdx
callq 0xf060
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0xf220
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xf220
movw %ax, -0x36(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x6240
movw $0x2, -0x18(%rbp)
movzwl -0x36(%rbp), %edi
callq 0x6080
movw %ax, -0x16(%rbp)
movl -0x34(%rbp), %edi
callq 0x63a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x52220
movl 0x112e0a(%rip), %edi    # 0x164b5c
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq %eax, %rdx
xorl %ecx, %ecx
leaq -0x18(%rbp), %r8
movl $0x10, %r9d
callq 0x60a0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x9b40
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: f_resolve
static int f_resolve(lua_State *L) {
  struct addrinfo hints, *result;
  const char *hostname = luaL_checkstring(L, 1);
  SDL_zero(hints);
  hints.ai_family = AF_INET;
  if (getaddrinfo(hostname, NULL, &hints, &result) == 0) {
    if (result) {
      lua_pushinteger(L, ntohl(((struct sockaddr_in*)(result->ai_addr))->sin_addr.s_addr));
      freeaddrinfo(result);
      return 1;
    }
  }
  lua_pushnil(L);
  lua_pushfstring(L, "cannot resolve " LUA_QS, hostname);
  return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xf060
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x6240
movl $0x2, -0x3c(%rbp)
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x65f0
cmpl $0x0, %eax
jne 0x51e33
cmpq $0x0, -0x48(%rbp)
je 0x51e31
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x4(%rax), %edi
callq 0x6600
movq -0x58(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x8e00
movq -0x48(%rbp), %rdi
callq 0x6620
movl $0x1, -0x4(%rbp)
jmp 0x51e59
jmp 0x51e33
movq -0x10(%rbp), %rdi
callq 0x8d80
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x62ff(%rip), %rsi      # 0x5814a
movb $0x0, %al
callq 0x9840
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: mml_reset_channel
static void mml_reset_channel(AudioChannel *channel) {
  if (channel->source) SDL_free((void*)channel->source);
  SDL_zerop(channel);
  channel->tempo = 140;
  channel->octave = 3;
  channel->waveform = PX_WAVEFORM_PULSE_50;
  channel->default_length = 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x51f02
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6290
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x6240
movq -0x8(%rbp), %rax
movl $0x8c, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: px_rand
static Uint32 px_rand() {
  seed ^= seed << 13;
  seed ^= seed >> 17;
  seed ^= seed << 5;
  return seed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x112afe(%rip), %eax    # 0x164b58
shll $0xd, %eax
xorl 0x112af5(%rip), %eax    # 0x164b58
movl %eax, 0x112aef(%rip)    # 0x164b58
movl 0x112ae9(%rip), %eax    # 0x164b58
shrl $0x11, %eax
xorl 0x112ae0(%rip), %eax    # 0x164b58
movl %eax, 0x112ada(%rip)    # 0x164b58
movl 0x112ad4(%rip), %eax    # 0x164b58
shll $0x5, %eax
xorl 0x112acb(%rip), %eax    # 0x164b58
movl %eax, 0x112ac5(%rip)    # 0x164b58
movl 0x112abf(%rip), %eax    # 0x164b58
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: px_open_controllers
static void px_open_controllers(lua_State *L) {
  int i;
  SDL_GameController *controller;
  for (i = 0; i < SDL_NumJoysticks(); ++i) {
    if (SDL_IsGameController(i)) {
      controller = SDL_GameControllerOpen(i);
      if (!controller) luaL_error(L, "SDL_GameControllerOpen() failed: %s", SDL_GetError());
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x6340
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x526d8
movl -0xc(%rbp), %edi
callq 0x6800
cmpl $0x0, %eax
je 0x526cb
movl -0xc(%rbp), %edi
callq 0x6470
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x526c9
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x6390
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x5bc6(%rip), %rsi      # 0x58288
movb $0x0, %al
callq 0xe880
jmp 0x526cb
jmp 0x526cd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x52673
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: mml_parse_number
static int mml_parse_number(AudioChannel *channel) {
  int value = 0;
  mml_skip_spaces(channel);
  while (SDL_isdigit(*channel->in)) {
    value *= 10;
    value += *channel->in++ - '0';
  }
  return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x52ad0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %edi
callq 0x61b0
cmpl $0x0, %eax
je 0x52b69
imull $0xa, -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movsbl (%rax), %eax
subl $0x30, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x52b2c
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: mml_parse_duration
static void mml_parse_duration(AudioChannel *channel) {
  float duration = (float)mml_parse_number(channel);
  if (duration == 0.0f) duration = (float)channel->default_length;
  duration = mixing_frequency / ((float)channel->tempo * 0.25f / 60.0f) * (1.0f / duration);
  if (mml_is_next(channel, '.')) duration *= 1.5f;
  channel->duration = (int)duration;
  if (mml_is_next(channel, '&')) channel->silence = 0;
  else channel->silence = (int)(duration * (1.0f / 8.0f));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x52b10
cvtsi2ss %eax, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x52bbb
jp 0x52bbb
movq -0x8(%rbp), %rax
cvtsi2ssl 0x30(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movss 0x111f1d(%rip), %xmm0   # 0x164ae0
movq -0x8(%rbp), %rax
cvtsi2ssl 0x28(%rax), %xmm1
movss 0x4b04(%rip), %xmm2     # 0x576d8
mulss %xmm2, %xmm1
movss 0x4b14(%rip), %xmm2     # 0x576f4
divss %xmm2, %xmm1
divss %xmm1, %xmm0
movss 0x4ae0(%rip), %xmm1     # 0x576d0
divss -0xc(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x52d50
cmpl $0x0, %eax
je 0x52c23
movss 0x4adf(%rip), %xmm0     # 0x576f8
mulss -0xc(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
cvttss2si -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movl $0x26, %esi
callq 0x52d50
cmpl $0x0, %eax
je 0x52c4f
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
jmp 0x52c67
movss 0x4a99(%rip), %xmm0     # 0x576f0
mulss -0xc(%rbp), %xmm0
cvttss2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: mml_parse_note
static void mml_parse_note(AudioChannel *channel, int key) {
  if (mml_is_next(channel, '#')) ++key;
  else if (mml_is_next(channel, '+')) ++key;
  else if (mml_is_next(channel, '-')) --key;
  key += (channel->octave - 1) * 12;
  channel->frequency = (float)SDL_pow(2.0, ((double)key - 49.0) / 12.0) * 440.0f;
  channel->t = 0.0f;
  mml_parse_duration(channel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x23, %esi
callq 0x52d50
cmpl $0x0, %eax
je 0x52c9d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x52cdb
movq -0x8(%rbp), %rdi
movl $0x2b, %esi
callq 0x52d50
cmpl $0x0, %eax
je 0x52cbb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x52cd9
movq -0x8(%rbp), %rdi
movl $0x2d, %esi
callq 0x52d50
cmpl $0x0, %eax
je 0x52cd7
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x52cd9
jmp 0x52cdb
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
subl $0x1, %eax
imull $0xc, %eax, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm1
movsd 0x49cd(%rip), %xmm0     # 0x576c8
subsd %xmm0, %xmm1
movsd 0x49b9(%rip), %xmm0     # 0x576c0
divsd %xmm0, %xmm1
movsd 0x29c5(%rip), %xmm0     # 0x556d8
callq 0x6550
cvtsd2ss %xmm0, %xmm0
movss 0x49d8(%rip), %xmm1     # 0x576fc
mulss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rdi
callq 0x52b80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: px_handle_mouse
static void px_handle_mouse(const SDL_Event *ev) {
  int button;
  switch (ev->button.button) {
  case SDL_BUTTON_LEFT: button = PX_BUTTON_A; break;
  case SDL_BUTTON_RIGHT: button = PX_BUTTON_B; break;
  default: return;
  }
  px_set_button(0, button, ev->type == SDL_MOUSEBUTTONDOWN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x52f78
jmp 0x52f6e
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x52f81
jmp 0x52f8a
movl $0x0, -0xc(%rbp)
jmp 0x52f8c
movl $0x1, -0xc(%rbp)
jmp 0x52f8c
jmp 0x52fa8
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
cmpl $0x401, (%rax)          # imm = 0x401
sete %al
andb $0x1, %al
movzbl %al, %edx
xorl %edi, %edi
callq 0x532f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: px_handle_controller
static void px_handle_controller(const SDL_Event *ev) {
  int button;
  switch (ev->cbutton.button) {
  case SDL_CONTROLLER_BUTTON_A: button = PX_BUTTON_A; break;
  case SDL_CONTROLLER_BUTTON_B: button = PX_BUTTON_B; break;
  case SDL_CONTROLLER_BUTTON_X: button = PX_BUTTON_X; break;
  case SDL_CONTROLLER_BUTTON_Y: button = PX_BUTTON_Y; break;
  case SDL_CONTROLLER_BUTTON_START: button = PX_BUTTON_START; break;
  case SDL_CONTROLLER_BUTTON_DPAD_UP: button = PX_BUTTON_UP; break;
  case SDL_CONTROLLER_BUTTON_DPAD_DOWN: button = PX_BUTTON_DOWN; break;
  case SDL_CONTROLLER_BUTTON_DPAD_LEFT: button = PX_BUTTON_LEFT; break;
  case SDL_CONTROLLER_BUTTON_DPAD_RIGHT: button = PX_BUTTON_RIGHT; break;
  default: return;
  }
  px_set_button(ev->cbutton.which, button, ev->type == SDL_CONTROLLERBUTTONDOWN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0xc(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0xe, %rax
ja 0x53033
movq -0x18(%rbp), %rax
leaq 0x4a2f(%rip), %rcx      # 0x57a08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0xc(%rbp)
jmp 0x53035
movl $0x1, -0xc(%rbp)
jmp 0x53035
movl $0x2, -0xc(%rbp)
jmp 0x53035
movl $0x3, -0xc(%rbp)
jmp 0x53035
movl $0x8, -0xc(%rbp)
jmp 0x53035
movl $0x6, -0xc(%rbp)
jmp 0x53035
movl $0x7, -0xc(%rbp)
jmp 0x53035
movl $0x4, -0xc(%rbp)
jmp 0x53035
movl $0x5, -0xc(%rbp)
jmp 0x53035
jmp 0x53056
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
cmpl $0x651, (%rax)          # imm = 0x651
sete %al
andb $0x1, %al
movzbl %al, %edx
callq 0x532f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: px_set_button
static void px_set_button(int player, int button, int down) {
  if (player >= 0 && player < PX_NUM_CONTROLLERS) {
    button = 1 << button;
    if (down) {
      inputs[player].down |= button;
      inputs[player].pressed |= button;
    }
    else {
      inputs[player].down &= ~button;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x5337c
cmpl $0x8, -0x4(%rbp)
jge 0x5337c
movl -0x8(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x5335a
movl -0x8(%rbp), %edx
movslq -0x4(%rbp), %rcx
leaq 0x1117c6(%rip), %rax    # 0x164af0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movzwl (%rax), %ecx
orl %edx, %ecx
movw %cx, (%rax)
movl -0x8(%rbp), %edx
movslq -0x4(%rbp), %rcx
leaq 0x1117a9(%rip), %rax    # 0x164af0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movzwl 0x2(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x2(%rax)
jmp 0x5337a
movl -0x8(%rbp), %edx
xorl $-0x1, %edx
movslq -0x4(%rbp), %rcx
leaq 0x111785(%rip), %rax    # 0x164af0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movzwl (%rax), %ecx
andl %edx, %ecx
movw %cx, (%rax)
jmp 0x5337c
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/pixl.c
// Function: px_shutdown
static void px_shutdown() {
  if (audio_device) SDL_CloseAudioDevice(audio_device);
  if (texture) SDL_DestroyTexture(texture);
  if (renderer) SDL_DestroyRenderer(renderer);
  if (window) SDL_DestroyWindow(window);
  SDL_Quit();
  net_shutdown();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x1116d(%rip)     # 0x644f8
je 0x53398
movl 0x11165(%rip), %edi     # 0x644f8
callq 0x6230
cmpq $0x0, 0x11150(%rip)     # 0x644f0
je 0x533ae
movq 0x11147(%rip), %rdi     # 0x644f0
callq 0x6380
cmpq $0x0, 0x11132(%rip)     # 0x644e8
je 0x533c4
movq 0x11129(%rip), %rdi     # 0x644e8
callq 0x6220
cmpq $0x0, 0x11114(%rip)     # 0x644e0
je 0x533da
movq 0x1110b(%rip), %rdi     # 0x644e0
callq 0x6030
callq 0x60c0
callq 0x533f0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]pre-pe/pre-dip-c.c
// Function: lt_opt_init
static void lt_opt_init(lt_opt_t *opt)
{
	memset(opt, 0, sizeof(lt_opt_t));
	opt->n_threads = 2;
	opt->chunk_size = 10000000;
	opt->max_qual = 50;
	opt->min_seq_len = 40;
	opt->max_ovlp_pen = 2;
	opt->min_ovlp_len = 8;
	opt->max_adap_pen = 1;
	opt->min_adap_len = 3;
	opt->max_olig_pen = 2;
	opt->min_olig_len = 10; // total length = 19
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x2c, %edx
callq 0x2110
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rax
movl $0x989680, 0x4(%rax)    # imm = 0x989680
movq -0x8(%rbp), %rax
movl $0x32, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x28, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0xa, 0x24(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/tests/test_verify_tables.c
// Function: diff_array
static inline int diff_array(
        unsigned long s1Len,
        unsigned long s2Len,
        int *a,
        int *b)
{
    unsigned long i = 0;
    unsigned long size = s1Len * s2Len;
    for (i=0; i<size; ++i) {
        if (a[i] != b[i]) return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x14db5c
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x14db4c
movl $0x1, -0x4(%rbp)
jmp 0x14db63
jmp 0x14db4e
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x14db21
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O1/codeniko[P]CS214-Malloc-Free/mymalloc.c
// Function: myfree
void myfree(void *p, char *file, int line)
{
	struct MemEntry *ptr;
	struct MemEntry *prev;
	struct MemEntry *next;

	if (p == NULL) {
		fprintf(stderr, "Pointer is NULL in file, free failed in FILE: '%s' on LINE: '%d'\n", file, line);
		return;
	}

	ptr = (struct MemEntry*)((char*)p - sizeof(struct MemEntry));
	
	//check if valid memEntry ptr
	int i;
	int valid = 0;
	for (i = 0; i < entriesSize; i++) {
		if (ptr == memEntries[i] && !ptr->isfree) {
			valid = 1; //memEntry is valid
			break;
		}
	}
	if (!valid) {
		fprintf(stderr, "Attempting to free memory that was not malloced in FILE: '%s' on LINE: '%d'\n", file, line);
		return;
	}

	if((prev = ptr->prev) != 0 && prev->isfree)
	{
		// the previous chunk is free, so
		// merge this chunk with the previous chunk
		prev->size += sizeof(struct MemEntry) + ptr->size;
		memEntries[i] = 0; //merged with previous, so removing free memEntry
	}
	else
	{ //not setting memEntry to null b/c not necessarily removing it, just isfree=1
		ptr->isfree = 1;
		prev = ptr;	// used for the step below
	}
	if((next = ptr->next) != 0 && next->isfree)
	{
		// the next chunk is free, merge with it
		prev->size += sizeof(struct MemEntry) + next->size;
		prev->next = next->next;
		//prev->isfree = 1;
		for (i = 0; i < entriesSize; i++) {
			if (next == memEntries[i]) {
				memEntries[i] = 0; //merged with next, so removing free memEntry
				break;
			}
		}
	}
}

// Assembly:
movl %edx, %ecx
movq %rsi, %rdx
testq %rdi, %rdi
je 0x1380
leaq -0x18(%rdi), %rsi
xorl %r8d, %r8d
leaq 0x8f24(%rip), %rax      # 0xa200
cmpq (%r8,%rax), %rsi
jne 0x12e8
cmpl $0x0, -0x8(%rdi)
je 0x130b
addq $0x8, %r8
cmpq $0x2090, %r8            # imm = 0x2090
jne 0x12dc
movq 0x2cfc(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdcc(%rip), %rsi       # 0x20d2
jmp 0x1391
movq -0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x1335
cmpl $0x0, 0x10(%rcx)
je 0x1335
movl -0x4(%rdi), %edx
movl 0x14(%rcx), %esi
addl %esi, %edx
addl $0x18, %edx
movl %edx, 0x14(%rcx)
movq $0x0, (%r8,%rax)
movq %rcx, %rsi
jmp 0x133c
movl $0x1, -0x8(%rdi)
movq -0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x1376
cmpl $0x0, 0x10(%rcx)
je 0x1376
movl 0x14(%rcx), %edx
movl 0x14(%rsi), %edi
addl %edi, %edx
addl $0x18, %edx
movl %edx, 0x14(%rsi)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsi)
xorl %edx, %edx
cmpq (%rdx,%rax), %rcx
je 0x1377
addq $0x8, %rdx
cmpq $0x2090, %rdx           # imm = 0x2090
jne 0x1363
retq
movq $0x0, (%rdx,%rax)
retq
movq 0x2c71(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xcff(%rip), %rsi       # 0x2090
xorl %eax, %eax
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_bmp
STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_bmp_core(&s, x, y, comp, data);
      stbi__end_write_file(&s);
      return r;
   } else
      return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r13d
leaq 0xd87e(%rip), %rsi      # 0xec65
callq 0x11c0
movq %rax, %r12
leaq 0x9034(%rip), %rax      # 0xa42a
movq %rax, -0x38(%rbp)
movq %r12, -0x30(%rbp)
testq %r12, %r12
je 0x1424
leaq -0x38(%rbp), %rdi
movl %r13d, %esi
movl %r15d, %edx
movl %r14d, %ecx
movq %rbx, %r8
callq 0x1353
movl %eax, %ebx
movq %r12, %rdi
callq 0x1080
jmp 0x1426
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_tga
STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_tga_core(&s, x, y, comp, (void *) data);
      stbi__end_write_file(&s);
      return r;
   } else
      return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r13d
leaq 0xd3ef(%rip), %rsi      # 0xec65
callq 0x11c0
movq %rax, %r12
leaq 0x8ba5(%rip), %rax      # 0xa42a
movq %rax, -0x38(%rbp)
movq %r12, -0x30(%rbp)
testq %r12, %r12
je 0x18b3
leaq -0x38(%rbp), %rdi
movl %r13d, %esi
movl %r15d, %edx
movl %r14d, %ecx
movq %rbx, %r8
callq 0x1462
movl %eax, %ebx
movq %r12, %rdi
callq 0x1080
jmp 0x18b5
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_hdr
STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data);
      stbi__end_write_file(&s);
      return r;
   } else
      return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r13d
leaq 0xcee7(%rip), %rsi      # 0xec65
callq 0x11c0
movq %rax, %r12
leaq 0x869d(%rip), %rax      # 0xa42a
movq %rax, -0x38(%rbp)
movq %r12, -0x30(%rbp)
testq %r12, %r12
je 0x1dbb
leaq -0x38(%rbp), %rdi
movl %r13d, %esi
movl %r15d, %edx
movl %r14d, %ecx
movq %rbx, %r8
callq 0x18f1
movl %eax, %ebx
movq %r12, %rdi
callq 0x1080
jmp 0x1dbd
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__sbgrowf
static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
{
   int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
   void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
   STBIW_ASSERT(p);
   if (p) {
      if (!*arr) ((int *) p)[1] = 0;
      *arr = (void *) ((int *) p + 2);
      stbiw__sbm(*arr) = m;
   }
   return *arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x262a
movl -0x8(%rax), %ecx
leal 0x1(,%rcx,2), %r14d
jmp 0x2630
movl $0x2, %r14d
leaq -0x8(%rax), %rdi
testq %rax, %rax
cmoveq %rax, %rdi
imull %r14d, %esi
movslq %esi, %rsi
addq $0x8, %rsi
callq 0x11a0
testq %rax, %rax
je 0x266f
cmpq $0x0, (%rbx)
jne 0x265d
movl $0x0, 0x4(%rax)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, (%rbx)
movl %r14d, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xd00e(%rip), %rdi      # 0xf684
leaq 0xc525(%rip), %rsi      # 0xeba2
leaq 0xc906(%rip), %rcx      # 0xef8a
movl $0x319, %edx            # imm = 0x319
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__zlib_flushf
static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
{
   while (*bitcount >= 8) {
      stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer));
      *bitbuffer >>= 8;
      *bitcount -= 8;
   }
   return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, -0x20(%rbp)
cmpl $0x8, (%rdx)
jl 0x26ef
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x20(%rbp), %r15
movq -0x20(%rbp), %rax
testq %rax, %rax
je 0x26be
movl -0x4(%rax), %ecx
incl %ecx
cmpl -0x8(%rax), %ecx
jl 0x26cb
movq %r15, %rdi
movl $0x1, %esi
callq 0x260b
movb (%r14), %al
movq -0x20(%rbp), %rcx
movslq -0x4(%rcx), %rdx
leal 0x1(%rdx), %esi
movl %esi, -0x4(%rcx)
movb %al, (%rcx,%rdx)
shrl $0x8, (%r14)
movl (%rbx), %eax
leal -0x8(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0xf, %eax
jg 0x26ab
movq -0x20(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_png
STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
   FILE *f;
   int len;
   unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (png == NULL) return 0;

   f = stbiw__fopen(filename, "wb");
   if (!f) { STBIW_FREE(png); return 0; }
   fwrite(png, 1, len, f);
   fclose(f);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %r9d, %r10d
movl %ecx, %eax
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %r14
leaq -0x14(%rbp), %r9
movq %r8, %rdi
movl %r10d, %esi
movl %eax, %r8d
callq 0x26fe
testq %rax, %rax
je 0x2dfd
movq %rax, %rbx
leaq 0xbe9c(%rip), %rsi      # 0xec65
movq %r14, %rdi
callq 0x11c0
testq %rax, %rax
je 0x2e02
movq %rax, %r14
movslq -0x14(%rbp), %rdx
movl $0x1, %esi
movq %rbx, %rdi
movq %rax, %rcx
callq 0x1200
movq %r14, %rdi
callq 0x1080
movl $0x1, %r14d
jmp 0x2e05
xorl %r14d, %r14d
jmp 0x2e0d
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1030
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_png_to_func
STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
{
   int len;
   unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (png == NULL) return 0;
   func(context, png, len);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rbp), %esi
leaq -0x1c(%rbp), %r9
movq %rax, %rdi
callq 0x26fe
testq %rax, %rax
je 0x2e5d
movq %rax, %r15
movl -0x1c(%rbp), %edx
movq %r14, %rdi
movq %rax, %rsi
callq *%rbx
movq %r15, %rdi
callq 0x1030
movl $0x1, %eax
jmp 0x2e5f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_jpg
STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);
      stbi__end_write_file(&s);
      return r;
   } else
      return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, %r14
movl %ecx, %r15d
movl %edx, %r12d
movl %esi, %ebx
leaq 0xb6dc(%rip), %rsi      # 0xec65
callq 0x11c0
movq %rax, %r13
leaq 0x6e92(%rip), %rax      # 0xa42a
movq %rax, -0x40(%rbp)
movq %r13, -0x38(%rbp)
testq %r13, %r13
je 0x35c9
leaq -0x40(%rbp), %rdi
movl %ebx, %esi
movl %r12d, %edx
movl %r15d, %ecx
movq %r14, %r8
movl -0x2c(%rbp), %r9d
callq 0x2e9c
movl %eax, %ebx
movq %r13, %rdi
callq 0x1080
jmp 0x35cb
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetGlyphBox
STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
{
   if (info->cff.size) {
      stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1);
   } else {
      int g = stbtt__GetGlyfOffset(info, glyph_index);
      if (g < 0) return 0;

      if (x0) *x0 = ttSHORT(info->data + g + 2);
      if (y0) *y0 = ttSHORT(info->data + g + 4);
      if (x1) *x1 = ttSHORT(info->data + g + 6);
      if (y1) *y1 = ttSHORT(info->data + g + 8);
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
cmpl $0x0, 0x4c(%rdi)
je 0x431f
movq %r15, %rdi
movq %r13, %rdx
movq %r12, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x43b7
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x4446
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
js 0x4310
movl %ecx, %edx
testq %r13, %r13
je 0x4350
movq 0x8(%r15), %rsi
movzbl 0x2(%rsi,%rdx), %edi
shll $0x8, %edi
movzbl 0x3(%rsi,%rdx), %esi
movswl %di, %edi
orl %esi, %edi
movl %edi, (%r13)
testq %r12, %r12
je 0x436f
movq 0x8(%r15), %rsi
movzbl 0x4(%rsi,%rdx), %edi
shll $0x8, %edi
movzbl 0x5(%rsi,%rdx), %esi
movswl %di, %edi
orl %esi, %edi
movl %edi, (%r12)
testq %r14, %r14
je 0x438d
movq 0x8(%r15), %rsi
movzbl 0x6(%rsi,%rdx), %edi
shll $0x8, %edi
movzbl 0x7(%rsi,%rdx), %esi
movswl %di, %edi
orl %esi, %edi
movl %edi, (%r14)
testq %rbx, %rbx
je 0x43aa
movq 0x8(%r15), %rsi
movzbl 0x8(%rsi,%rdx), %edi
shll $0x8, %edi
movzbl 0x9(%rsi,%rdx), %edx
movswl %di, %esi
orl %edx, %esi
movl %esi, (%rbx)
testl %ecx, %ecx
jns 0x430b
jmp 0x4310
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__GetGlyphInfoT2
static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
{
   stbtt__csctx c = STBTT__CSCTX_INIT(1);
   int r = stbtt__run_charstring(info, glyph_index, &c);
   if (x0)  *x0 = r ? c.min_x : 0;
   if (y0)  *y0 = r ? c.min_y : 0;
   if (x1)  *x1 = r ? c.max_x : 0;
   if (y1)  *y1 = r ? c.max_y : 0;
   return r ? c.num_vertices : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x20(%rdx)
movaps %xmm0, 0x10(%rdx)
movq $0x0, 0x30(%rdx)
movl $0x1, (%rdx)
callq 0xaa76
testq %r12, %r12
je 0x4409
movl %eax, %ecx
testl %eax, %eax
je 0x4405
movl -0x48(%rbp), %ecx
movl %ecx, (%r12)
testq %r15, %r15
je 0x441a
movl %eax, %ecx
testl %eax, %eax
je 0x4417
movl -0x40(%rbp), %ecx
movl %ecx, (%r15)
testq %r14, %r14
je 0x442b
movl %eax, %ecx
testl %eax, %eax
je 0x4428
movl -0x44(%rbp), %ecx
movl %ecx, (%r14)
testq %rbx, %rbx
je 0x4439
testl %eax, %eax
je 0x4437
movl -0x3c(%rbp), %eax
movl %eax, (%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__GetGlyfOffset
static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index)
{
   int g1,g2;

   STBTT_assert(!info->cff.size);

   if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range
   if (info->indexToLocFormat >= 2)    return -1; // unknown index->glyph map format

   if (info->indexToLocFormat == 0) {
      g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2;
      g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2;
   } else {
      g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4);
      g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4);
   }

   return g1==g2 ? -1 : g1; // if length is 0, return -1
}

// Assembly:
cmpl $0x0, 0x4c(%rdi)
jne 0x44ac
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, 0x14(%rdi)
jle 0x44ab
movl 0x38(%rdi), %r8d
cmpl $0x1, %r8d
jg 0x44ab
movslq 0x18(%rdi), %rdx
addq 0x8(%rdi), %rdx
movl 0x20(%rdi), %ecx
movslq %esi, %rsi
testl %r8d, %r8d
je 0x4480
movl (%rdx,%rsi,4), %eax
movl 0x4(%rdx,%rsi,4), %edx
bswapl %eax
bswapl %edx
jmp 0x449f
movzbl (%rdx,%rsi,2), %eax
movzbl 0x1(%rdx,%rsi,2), %edi
shll $0x9, %eax
leal (%rax,%rdi,2), %eax
movzbl 0x2(%rdx,%rsi,2), %edi
movzbl 0x3(%rdx,%rsi,2), %edx
shll $0x9, %edi
leal (%rdi,%rdx,2), %edx
addl %eax, %ecx
cmpl %edx, %eax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %ecx, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xaafb(%rip), %rdi      # 0xefb2
leaq 0xa7aa(%rip), %rsi      # 0xec68
leaq 0xaafd(%rip), %rcx      # 0xefc2
movl $0x613, %edx            # imm = 0x613
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_IsGlyphEmpty
STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_index)
{
   stbtt_int16 numberOfContours;
   int g;
   if (info->cff.size)
      return stbtt__GetGlyphInfoT2(info, glyph_index, NULL, NULL, NULL, NULL) == 0;
   g = stbtt__GetGlyfOffset(info, glyph_index);
   if (g < 0) return 1;
   numberOfContours = ttSHORT(info->data + g);
   return numberOfContours == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x4c(%rdi)
je 0x4569
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movq $0x0, 0x30(%r14)
movl $0x1, (%r14)
movq %rbx, %rdi
movq %r14, %rdx
callq 0xaa76
testl %eax, %eax
sete %cl
cmpl $0x0, 0x30(%r14)
sete %al
orb %cl, %al
jmp 0x4589
movq %rbx, %rdi
callq 0x4446
testl %eax, %eax
js 0x4587
movq 0x8(%rbx), %rcx
movl %eax, %eax
movb 0x1(%rcx,%rax), %dl
orb (%rcx,%rax), %dl
sete %al
jmp 0x4589
movb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetGlyphHMetrics
STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing)
{
   stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34);
   if (glyph_index < numOfLongHorMetrics) {
      if (advanceWidth)     *advanceWidth    = ttSHORT(info->data + info->hmtx + 4*glyph_index);
      if (leftSideBearing)  *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2);
   } else {
      if (advanceWidth)     *advanceWidth    = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1));
      if (leftSideBearing)  *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics));
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movslq 0x24(%rdi), %r8
movzwl 0x22(%rax,%r8), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r9d
movl %esi, %r8d
subl %r9d, %r8d
jge 0x4603
testq %rdx, %rdx
je 0x45e0
movslq 0x28(%rdi), %r8
addq %rax, %r8
movslq %esi, %r9
movzbl (%r8,%r9,4), %r10d
shll $0x8, %r10d
movzbl 0x1(%r8,%r9,4), %r8d
movswl %r10w, %r9d
orl %r8d, %r9d
movl %r9d, (%rdx)
testq %rcx, %rcx
je 0x465c
movslq 0x28(%rdi), %rdx
addq %rdx, %rax
shll $0x2, %esi
movslq %esi, %rsi
leaq (%rsi,%rax), %rdx
addq $0x2, %rdx
addq %rsi, %rax
addq $0x3, %rax
jmp 0x464c
movl %r9d, %esi
testq %rdx, %rdx
je 0x462c
movslq 0x28(%rdi), %r9
addq %rax, %r9
movzbl -0x4(%r9,%rsi,4), %r10d
shll $0x8, %r10d
movzbl -0x3(%r9,%rsi,4), %r9d
movswl %r10w, %r10d
orl %r9d, %r10d
movl %r10d, (%rdx)
testq %rcx, %rcx
je 0x465c
movslq 0x28(%rdi), %rdx
addq %rdx, %rax
leaq (%rax,%rsi,4), %rax
addl %r8d, %r8d
movslq %r8d, %rsi
leaq (%rax,%rsi), %rdx
addq %rsi, %rax
incq %rax
movzbl (%rdx), %edx
shll $0x8, %edx
movzbl (%rax), %eax
movswl %dx, %edx
orl %eax, %edx
movl %edx, (%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetFontVMetricsOS2
STBTT_DEF int  stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int *typoAscent, int *typoDescent, int *typoLineGap)
{
   int tab = stbtt__find_table(info->data, info->fontstart, "OS/2");
   if (!tab)
      return 0;
   if (typoAscent ) *typoAscent  = ttSHORT(info->data+tab + 68);
   if (typoDescent) *typoDescent = ttSHORT(info->data+tab + 70);
   if (typoLineGap) *typoLineGap = ttSHORT(info->data+tab + 72);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq 0x8(%rdi), %r14
movl 0x10(%rdi), %esi
leaq 0x9fa0(%rip), %rdx      # 0xece7
movq %r14, %rdi
callq 0x4db8
testl %eax, %eax
je 0x4dad
movslq %eax, %rcx
testq %r12, %r12
je 0x4d71
movzbl 0x44(%r14,%rcx), %eax
shll $0x8, %eax
movzbl 0x45(%r14,%rcx), %edx
cwtl
orl %edx, %eax
movl %eax, (%r12)
testq %r15, %r15
je 0x4d8b
movzbl 0x46(%r14,%rcx), %eax
shll $0x8, %eax
movzbl 0x47(%r14,%rcx), %edx
cwtl
orl %edx, %eax
movl %eax, (%r15)
movl $0x1, %eax
testq %rbx, %rbx
je 0x4daf
movzbl 0x48(%r14,%rcx), %edx
shll $0x8, %edx
movzbl 0x49(%r14,%rcx), %ecx
movswl %dx, %edx
orl %ecx, %edx
movl %edx, (%rbx)
jmp 0x4daf
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq