LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_vprintf_data
size_t mg_vprintf_data(struct mg_connection *c, const char *fmt, va_list ap) {
  struct connection *conn = MG_CONN_2_CONN(c);
  int len;
  char mem[IOBUF_SIZE], *buf = mem;

  terminate_headers(c);

  len = ns_avprintf(&buf, sizeof(mem), fmt, ap);

  if (len >= 0) {
    write_chunk((struct connection *) conn, buf, len);
  }
  if (buf != mem && buf != NULL) {
    NS_FREE(buf);
  }
  return conn->ns_conn->send_iobuf.len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x20(%rbp)
leaq -0x2030(%rbp), %rax
movq %rax, -0x2038(%rbp)
movq -0x8(%rbp), %rdi
callq 0xb1af0
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x2038(%rbp), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0xaee40
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xb1d0f
movq -0x20(%rbp), %rdi
movq -0x2038(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0xb1b70
movq -0x2038(%rbp), %rax
leaq -0x2030(%rbp), %rcx
cmpq %rcx, %rax
je 0xb1d38
cmpq $0x0, -0x2038(%rbp)
je 0xb1d38
movq -0x2038(%rbp), %rdi
callq 0xd2c0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x60(%rax), %rax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_websocket_printf
size_t mg_websocket_printf(struct mg_connection *conn, int opcode,
                           const char *fmt, ...) {
  char mem[4192], *buf = mem;
  va_list ap;
  int len;

  va_start(ap, fmt);
  if ((len = ns_avprintf(&buf, sizeof(mem), fmt, ap)) > 0) {
    mg_websocket_write(conn, opcode, buf, len);
  }
  va_end(ap);

  if (buf != mem && buf != NULL) {
    NS_FREE(buf);
  }

  return MG_CONN_2_CONN(conn)->ns_conn->send_iobuf.len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1160, %rsp           # imm = 0x1160
testb %al, %al
je 0xb1fc7
movaps %xmm0, -0x1130(%rbp)
movaps %xmm1, -0x1120(%rbp)
movaps %xmm2, -0x1110(%rbp)
movaps %xmm3, -0x1100(%rbp)
movaps %xmm4, -0x10f0(%rbp)
movaps %xmm5, -0x10e0(%rbp)
movaps %xmm6, -0x10d0(%rbp)
movaps %xmm7, -0x10c0(%rbp)
movq %r9, -0x1138(%rbp)
movq %r8, -0x1140(%rbp)
movq %rcx, -0x1148(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1080(%rbp), %rax
movq %rax, -0x1088(%rbp)
leaq -0x10a0(%rbp), %rax
leaq -0x1160(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x18(%rbp), %rdx
leaq -0x10a0(%rbp), %rcx
leaq -0x1088(%rbp), %rdi
movl $0x1060, %esi           # imm = 0x1060
callq 0xaee40
movl %eax, -0x10a4(%rbp)
cmpl $0x0, %eax
jle 0xb205d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x1088(%rbp), %rdx
movslq -0x10a4(%rbp), %rcx
callq 0xb1d50
leaq -0x10a0(%rbp), %rax
movq -0x1088(%rbp), %rax
leaq -0x1080(%rbp), %rcx
cmpq %rcx, %rax
je 0xb208d
cmpq $0x0, -0x1088(%rbp)
je 0xb208d
movq -0x1088(%rbp), %rdi
callq 0xd2c0
movq -0x8(%rbp), %rax
movq -0x8(%rax), %rax
movq 0x60(%rax), %rax
addq $0x1160, %rsp           # imm = 0x1160
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_get_mime_type
const char *mg_get_mime_type(const char *path, const char *default_mime_type) {
  const char *ext;
  size_t i, path_len;

  path_len = strlen(path);

  for (i = 0; static_builtin_mime_types[i].extension != NULL; i++) {
    ext = path + (path_len - static_builtin_mime_types[i].ext_len);
    if (path_len > static_builtin_mime_types[i].ext_len &&
        mg_strcasecmp(ext, static_builtin_mime_types[i].extension) == 0) {
      return static_builtin_mime_types[i].mime_type;
    }
  }

  return default_mime_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd550
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
leaq 0x3b804(%rip), %rax     # 0xed8e0
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xb2175
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
leaq 0x3b7e3(%rip), %rdx     # 0xed8e0
imulq $0x18, -0x28(%rbp), %rsi
addq %rsi, %rdx
subq 0x8(%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
leaq 0x3b7c5(%rip), %rcx     # 0xed8e0
imulq $0x18, -0x28(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jbe 0xb2162
movq -0x20(%rbp), %rdi
leaq 0x3b7ac(%rip), %rax     # 0xed8e0
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0xb1070
cmpl $0x0, %eax
jne 0xb2162
leaq 0x3b790(%rip), %rax     # 0xed8e0
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xb217d
jmp 0xb2164
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb20d5
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_send_file_data
void mg_send_file_data(struct mg_connection *c, int fd) {
  struct connection *conn = MG_CONN_2_CONN(c);
  conn->endpoint_type = EP_FILE;
  conn->endpoint.fd = fd;
  ns_set_close_on_exec(conn->endpoint.fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, 0x2b8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2b0(%rax)
movq -0x18(%rbp), %rax
movl 0x2b0(%rax), %edi
callq 0xaf170
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_url_encode
size_t mg_url_encode(const char *src, size_t s_len, char *dst, size_t dst_len) {
  static const char *dont_escape = "._-$,;~()";
  static const char *hex = "0123456789abcdef";
  size_t i = 0, j = 0;

  for (i = j = 0; dst_len > 0 && i < s_len && j + 2 < dst_len - 1; i++, j++) {
    if (isalnum(* (const unsigned char *) (src + i)) ||
        strchr(dont_escape, * (const unsigned char *) (src + i)) != NULL) {
      dst[j] = src[i];
    } else if (j + 3 < dst_len) {
      dst[j] = '%';
      dst[j + 1] = hex[(* (const unsigned char *) (src + i)) >> 4];
      dst[j + 2] = hex[(* (const unsigned char *) (src + i)) & 0xf];
      j += 2;
    }
  }

  dst[j] = '\0';
  return j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x31(%rbp)
jbe 0xb224c
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0xb224c
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xb2258
jmp 0xb2348
callq 0xd1f0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xb2299
movq 0x3ca3e(%rip), %rdi     # 0xeecc0
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0xd710
cmpq $0x0, %rax
je 0xb22b1
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xb2329
movq -0x30(%rbp), %rax
addq $0x3, %rax
cmpq -0x20(%rbp), %rax
jae 0xb2327
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x25, (%rax,%rcx)
movq 0x3c9f6(%rip), %rax     # 0xeecc8
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
sarl $0x4, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, 0x1(%rax,%rcx)
movq 0x3c9ce(%rip), %rax     # 0xeecc8
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, 0x2(%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
jmp 0xb2329
jmp 0xb232b
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xb2218
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_send_digest_auth_request
void mg_send_digest_auth_request(struct mg_connection *c) {
  struct connection *conn = MG_CONN_2_CONN(c);
  c->status_code = 401;
  mg_printf(c,
            "HTTP/1.1 401 Unauthorized\r\n"
            "Content-Length: 0\r\n"
            "WWW-Authenticate: Digest qop=\"auth\", "
            "realm=\"%s\", nonce=\"%lu\"\r\n\r\n",
            conn->server->config_options[AUTH_DOMAIN],
            (unsigned long) time(NULL));
  close_local_endpoint(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x191, 0x27c(%rax)     # imm = 0x191
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x2a8(%rax), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0xd980
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq %rax, %rcx
leaq 0x14849(%rip), %rsi     # 0xc6c05
movb $0x0, %al
callq 0xb0cb0
movq -0x10(%rbp), %rdi
callq 0xb23e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_md5
char *mg_md5(char buf[33], ...) {
  unsigned char hash[16];
  const char *p;
  va_list ap;
  MD5_CTX ctx;

  MD5Init(&ctx);

  va_start(ap, buf);
  while ((p = va_arg(ap, const char *)) != NULL) {
    MD5Update(&ctx, (const unsigned char *) p, (unsigned) strlen(p));
  }
  va_end(ap);

  MD5Final(hash, &ctx);
  bin2str(buf, hash, sizeof(hash));
  return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
testb %al, %al
je 0xb26c7
movaps %xmm0, -0x120(%rbp)
movaps %xmm1, -0x110(%rbp)
movaps %xmm2, -0x100(%rbp)
movaps %xmm3, -0xf0(%rbp)
movaps %xmm4, -0xe0(%rbp)
movaps %xmm5, -0xd0(%rbp)
movaps %xmm6, -0xc0(%rbp)
movaps %xmm7, -0xb0(%rbp)
movq %r9, -0x128(%rbp)
movq %r8, -0x130(%rbp)
movq %rcx, -0x138(%rbp)
movq %rdx, -0x140(%rbp)
movq %rsi, -0x148(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xb2800
leaq -0x40(%rbp), %rax
leaq -0x150(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x160(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x154(%rbp)
cmpl $0x28, %eax
ja 0xb2759
movq -0x160(%rbp), %rcx
movl -0x154(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x168(%rbp)
jmp 0xb2776
movq -0x160(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x168(%rbp)
movq -0x168(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xb27b8
movq -0x28(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0x28(%rbp), %rdi
callq 0xd550
movq -0x170(%rbp), %rsi
movl %eax, %edx
leaq -0x98(%rbp), %rdi
callq 0xb2850
jmp 0xb271e
leaq -0x20(%rbp), %rdi
movq %rdi, -0x178(%rbp)
leaq -0x98(%rbp), %rsi
callq 0xb29c0
movq -0x178(%rbp), %rsi
movq -0x8(%rbp), %rdi
movl $0x10, %edx
callq 0xb2b00
movq -0x8(%rbp), %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: MD5Update
static void MD5Update(MD5_CTX *ctx, unsigned char const *buf, unsigned len) {
  uint32_t t;

  t = ctx->bits[0];
  if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t)
    ctx->bits[1]++;
  ctx->bits[1] += len >> 29;

  t = (t >> 3) & 0x3f;

  if (t) {
    unsigned char *p = (unsigned char *) ctx->in + t;

    t = 64 - t;
    if (len < t) {
      memcpy(p, buf, len);
      return;
    }
    memcpy(p, buf, t);
    byteReverse(ctx->in, 16);
    MD5Transform(ctx->buf, (uint32_t *) ctx->in);
    buf += t;
    len -= t;
  }

  while (len >= 64) {
    memcpy(ctx->in, buf, 64);
    byteReverse(ctx->in, 16);
    MD5Transform(ctx->buf, (uint32_t *) ctx->in);
    buf += 64;
    len -= 64;
  }

  memcpy(ctx->in, buf, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl %eax, 0x10(%rcx)
cmpl -0x18(%rbp), %eax
jae 0xb2891
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movl -0x14(%rbp), %ecx
shrl $0x1d, %ecx
movq -0x8(%rbp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movl -0x18(%rbp), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xb2943
movq -0x8(%rbp), %rax
addq $0x18, %rax
movl -0x18(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x40, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0xb28f3
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0xd100
jmp 0xb29b1
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
movl %eax, %edx
callq 0xd100
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl $0x10, %esi
callq 0xb62d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
callq 0xb6350
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0xb2945
cmpl $0x40, -0x14(%rbp)
jb 0xb299b
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0xd100
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl $0x10, %esi
callq 0xb62d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
callq 0xb6350
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
subl $0x40, %eax
movl %eax, -0x14(%rbp)
jmp 0xb2945
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0xd100
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: MD5Final
static void MD5Final(unsigned char digest[16], MD5_CTX *ctx) {
  unsigned count;
  unsigned char *p;
  uint32_t *a;

  count = (ctx->bits[0] >> 3) & 0x3F;

  p = ctx->in + count;
  *p++ = 0x80;
  count = 64 - 1 - count;
  if (count < 8) {
    memset(p, 0, count);
    byteReverse(ctx->in, 16);
    MD5Transform(ctx->buf, (uint32_t *) ctx->in);
    memset(ctx->in, 0, 56);
  } else {
    memset(p, 0, count - 8);
  }
  byteReverse(ctx->in, 14);

  a = (uint32_t *)ctx->in;
  a[14] = ctx->bits[0];
  a[15] = ctx->bits[1];

  MD5Transform(ctx->buf, (uint32_t *) ctx->in);
  byteReverse((unsigned char *) ctx->buf, 4);
  memcpy(digest, ctx->buf, 16);
  memset((char *) ctx, 0, sizeof(*ctx));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $-0x80, (%rax)
movl $0x3f, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jae 0xb2a5e
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0xd430
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movl $0x10, %esi
callq 0xb62d0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0xb6350
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0xd430
jmp 0xb2a73
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x8, %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0xd430
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movl $0xe, %esi
callq 0xb62d0
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0xb6350
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0xb62d0
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0xd430
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_strncasecmp
static int mg_strncasecmp(const char *s1, const char *s2, size_t len) {
  int diff = 0;

  if (len > 0)
    do {
      diff = lowercase(s1++) - lowercase(s2++);
    } while (diff == 0 && s1[-1] != '\0' && --len > 0);

  return diff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0xb2ed5
jmp 0xb2e64
movq -0x8(%rbp), %rdi
movq %rdi, %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
callq 0xb1360
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
callq 0xb1360
movl %eax, %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x21(%rbp)
jne 0xb2ecc
movq -0x8(%rbp), %rax
movsbl -0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0xb2ecc
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xb2e64
jmp 0xb2ed5
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: check_password
static int check_password(const char *method, const char *ha1, const char *uri,
                          const char *nonce, const char *nc, const char *cnonce,
                          const char *qop, const char *response) {
  char ha2[32 + 1], expected_response[32 + 1];

#if 0
  // Check for authentication timeout
  if ((unsigned long) time(NULL) - (unsigned long) to64(nonce) > 3600 * 2) {
    return 0;
  }
#endif

  mg_md5(ha2, method, ":", uri, NULL);
  mg_md5(expected_response, ha1, ":", nonce, ":", nc,
      ":", cnonce, ":", qop, ":", ha2, NULL);

  return mg_strcasecmp(response, expected_response) == 0 ? MG_TRUE : MG_FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xc8, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0xccb8(%rip), %rdx      # 0xbfc37
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xb2680
leaq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rbx
movq 0x10(%rbp), %r11
leaq -0x60(%rbp), %rax
leaq 0xcc86(%rip), %r10      # 0xbfc37
xorl %edx, %edx
movq %r10, %rdx
movq %r10, %r8
movq %r10, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movb $0x0, %al
callq 0xb2680
movq 0x18(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xb1070
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_forward
int mg_forward(struct mg_connection *c, const char *addr) {
  static const char ok[] = "HTTP/1.1 200 OK\r\n\r\n";
  struct connection *conn = MG_CONN_2_CONN(c);
  struct ns_connection *pc;

  if ((pc = ns_connect(&conn->server->ns_mgr, addr,
      mg_ev_handler, conn)) == NULL) {
    conn->ns_conn->flags |= NSF_CLOSE_IMMEDIATELY;
    return 0;
  }

  // Interlink two connections
  pc->flags |= MG_PROXY_CONN;
  conn->endpoint_type = EP_PROXY;
  conn->endpoint.nc = pc;
  DBG(("%p [%s] [%s] -> %p %p", conn, c->uri, addr, pc, conn->ns_conn->ssl));

  if (strcmp(c->request_method, "CONNECT") == 0) {
    // For CONNECT request, reply with 200 OK. Tunnel is established.
    // TODO(lsm): check for send() failure
    (void) send(conn->ns_conn->sock, ok, sizeof(ok) - 1, 0);
  } else {
    // Strip "http://host:port" part from the URI
    if (memcmp(c->uri, "http://", 7) == 0) c->uri += 7;
    while (*c->uri != '\0' && *c->uri != '/') c->uri++;
    proxy_request(pc, c);
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x2a8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x13a(%rip), %rdx       # 0xb3410
callq 0xb07c0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xb3307
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0xa0(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0xa0(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xb33fc
movq -0x28(%rbp), %rax
movl 0xa0(%rax), %ecx
orl $0x800000, %ecx         # imm = 0x800000
movl %ecx, 0xa0(%rax)
movq -0x20(%rbp), %rax
movl $0x6, 0x2b8(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x1395e(%rip), %rsi     # 0xc6ca6
callq 0xdab0
cmpl $0x0, %eax
jne 0xb3374
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %edi
leaq 0x1367d(%rip), %rsi     # 0xc69e0
movl $0x13, %edx
xorl %ecx, %ecx
callq 0xd4a0
jmp 0xb33f5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1392b(%rip), %rsi     # 0xc6cae
movl $0x7, %edx
callq 0xddb0
cmpl $0x0, %eax
jne 0xb33a2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x7, %rcx
movq %rcx, 0x8(%rax)
jmp 0xb33a4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0xb33cd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xb33d6
jmp 0xb33e8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0xb33a4
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb37a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_snprintf
static int mg_snprintf(char *buf, size_t buflen, const char *fmt, ...) {
  va_list ap;
  int n;
  va_start(ap, fmt);
  n = mg_vsnprintf(buf, buflen, fmt, ap);
  va_end(ap);
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0xb3c8b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0xb7270
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: must_hide_file
static int must_hide_file(struct connection *conn, const char *path) {
  const char *pw_pattern = "**" PASSWORDS_FILE_NAME "$";
  const char *pattern = conn->server->config_options[HIDE_FILES_PATTERN];
  return mg_match_prefix(pw_pattern, strlen(pw_pattern), path) > 0 ||
    (pattern != NULL && mg_match_prefix(pattern, strlen(pattern), path) > 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x137d5(%rip), %rax     # 0xc74ec
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x2a8(%rax), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd550
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0xb10f0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jg 0xb3d9a
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x31(%rbp)
je 0xb3d94
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd550
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0xb10f0
cmpl $0x0, %eax
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: send_directory_listing
static void send_directory_listing(struct connection *conn, const char *dir) {
  struct dir_entry *arr = NULL;
  int i, num_entries, sort_direction = conn->mg_conn.query_string != NULL &&
    conn->mg_conn.query_string[1] == 'd' ? 'a' : 'd';

  mg_send_header(&conn->mg_conn, "Transfer-Encoding", "chunked");
  mg_send_header(&conn->mg_conn, "Content-Type", "text/html; charset=utf-8");

  mg_printf_data(&conn->mg_conn,
              "<html><head><title>Index of %s</title>"
              "<style>th {text-align: left;}</style></head>"
              "<body><h1>Index of %s</h1><pre><table cellpadding=\"0\">"
              "<tr><th><a href=\"?n%c\">Name</a></th>"
              "<th><a href=\"?d%c\">Modified</a></th>"
              "<th><a href=\"?s%c\">Size</a></th></tr>"
              "<tr><td colspan=\"3\"><hr></td></tr>",
              conn->mg_conn.uri, conn->mg_conn.uri,
              sort_direction, sort_direction, sort_direction);

  num_entries = scan_directory(conn, dir, &arr);
  if (arr) {
      qsort(arr, num_entries, sizeof(arr[0]), compare_dir_entries);
      for (i = 0; i < num_entries; i++) {
        print_dir_entry(&arr[i]);
        NS_FREE(arr[i].file_name);
      }
      NS_FREE(arr);
  }

  write_terminating_chunk(conn);
  close_local_endpoint(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, -0x25(%rbp)
je 0xb42ed
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x64, %eax
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %dl
movl $0x64, %eax
movl $0x61, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x12e7a(%rip), %rsi     # 0xc718c
leaq 0x12e85(%rip), %rdx     # 0xc719e
callq 0xb1a50
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0xb5c3(%rip), %rsi      # 0xbf8f0
leaq 0x13257(%rip), %rdx     # 0xc758b
callq 0xb1a50
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movl -0x24(%rbp), %r8d
movl -0x24(%rbp), %r9d
movl -0x24(%rbp), %eax
leaq 0x13241(%rip), %rsi     # 0xc75a4
movl %eax, (%rsp)
movb $0x0, %al
callq 0xb1bf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xb7370
movl %eax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb43f6
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
movl $0xa0, %edx
leaq 0x3224(%rip), %rcx      # 0xb75c0
callq 0xd950
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xb43ed
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0xa0, %rax, %rax
addq %rax, %rdi
callq 0xb7780
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0xa0, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0xd2c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb43a8
movq -0x18(%rbp), %rdi
callq 0xd2c0
movq -0x8(%rbp), %rdi
callq 0xb79c0
movq -0x8(%rbp), %rdi
callq 0xb23e0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: handle_ssi_request
static void handle_ssi_request(struct connection *conn, const char *path) {
  FILE *fp;
  struct vec mime_vec;

  if ((fp = fopen(path, "rb")) == NULL) {
    send_http_error(conn, 500, "fopen(%s): %s", path, strerror(errno));
  } else {
    ns_set_close_on_exec(fileno(fp));
    get_mime_type(conn->server, path, &mime_vec);
    conn->mg_conn.status_code = 200;
    mg_printf(&conn->mg_conn,
              "HTTP/1.1 %d OK\r\n"
              "Content-Type: %.*s\r\n"
              "Connection: close\r\n\r\n",
              conn->mg_conn.status_code, (int) mime_vec.len, mime_vec.ptr);
    send_ssi_file(&conn->mg_conn, path, fp, 0);
    fclose(fp);
    close_local_endpoint(conn);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xae3e(%rip), %rsi      # 0xbf4d9
callq 0xdd20
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xb46e9
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xdcc0
movl (%rax), %edi
callq 0xda00
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq %rax, %r8
movl $0x1f4, %esi            # imm = 0x1F4
leaq 0x134da(%rip), %rdx     # 0xc7bb7
movb $0x0, %al
callq 0xb3db0
jmp 0xb4772
movq -0x18(%rbp), %rdi
callq 0xde90
movl %eax, %edi
callq 0xaf170
movq -0x8(%rbp), %rax
movq 0x2a8(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xb83a0
movq -0x8(%rbp), %rax
movl $0xc8, 0x284(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rax
movl 0x284(%rax), %edx
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %r8
leaq 0x13306(%rip), %rsi     # 0xc7a48
movb $0x0, %al
callq 0xb0cb0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0xb8470
movq -0x18(%rbp), %rdi
callq 0xd5b0
movq -0x8(%rbp), %rdi
callq 0xb23e0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: is_not_modified
static int is_not_modified(const struct connection *conn,
                           const file_stat_t *stp) {
  char etag[64];
  const char *ims = mg_get_header(&conn->mg_conn, "If-Modified-Since");
  const char *inm = mg_get_header(&conn->mg_conn, "If-None-Match");
  construct_etag(etag, sizeof(etag), stp);
  return (inm != NULL && !mg_strcasecmp(etag, inm)) ||
    (ims != NULL && stp->st_mtime <= parse_date_string(ims));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0xacbc(%rip), %rsi      # 0xbf45b
callq 0xb0fe0
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x1343d(%rip), %rsi     # 0xc7bf4
callq 0xb0fe0
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x40, %esi
callq 0xb8c00
cmpq $0x0, -0x60(%rbp)
je 0xb47f2
leaq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xb1070
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x61(%rbp)
je 0xb4829
xorl %eax, %eax
cmpq $0x0, -0x58(%rbp)
movb %al, -0x62(%rbp)
je 0xb4823
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x58(%rbp), %rdi
callq 0xb8c40
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
setle %al
movb %al, -0x62(%rbp)
movb -0x62(%rbp), %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_connect
struct mg_connection *mg_connect(struct mg_server *server, const char *addr) {
  struct ns_connection *nsconn;
  struct connection *conn;

  nsconn = ns_connect(&server->ns_mgr, addr, mg_ev_handler, NULL);
  if (nsconn == NULL) return 0;

  if ((conn = (struct connection *) NS_CALLOC(1, sizeof(*conn))) == NULL) {
    nsconn->flags |= NSF_CLOSE_IMMEDIATELY;
    return 0;
  }

  // Interlink two structs
  conn->ns_conn = nsconn;
  nsconn->user_data = conn;

  conn->server = server;
  conn->endpoint_type = EP_CLIENT;
  //conn->handler = handler;
  conn->mg_conn.server_param = server->ns_mgr.user_data;
  conn->ns_conn->flags = NSF_CONNECTING;

  return &conn->mg_conn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x18ff(%rip), %rdx     # 0xb3410
xorl %eax, %eax
movl %eax, %ecx
callq 0xb07c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb4d30
movq $0x0, -0x8(%rbp)
jmp 0xb4dcd
movl $0x1, %edi
movl $0x2e8, %esi            # imm = 0x2E8
callq 0xdaf0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xb4d66
movq -0x20(%rbp), %rax
movl 0xa0(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0xa0(%rax)
movq $0x0, -0x8(%rbp)
jmp 0xb4dcd
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x2a8(%rax)
movq -0x28(%rbp), %rax
movl $0x5, 0x2b8(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x290(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl $0x8, 0xa0(%rax)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_destroy_server
void mg_destroy_server(struct mg_server **server) {
  if (server != NULL && *server != NULL) {
    struct mg_server *s = *server;
    int i;

    ns_mgr_free(&s->ns_mgr);
    for (i = 0; i < (int) ARRAY_SIZE(s->config_options); i++) {
      NS_FREE(s->config_options[i]);  // It is OK to free(NULL)
    }
    NS_FREE(s);
    *server = NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb4e7f
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb4e7f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb0b70
movl $0x0, -0x14(%rbp)
cmpl $0x13, -0x14(%rbp)
jge 0xb4e6b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x38(%rax,%rcx,8), %rdi
callq 0xd2c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb4e48
movq -0x10(%rbp), %rdi
callq 0xd2c0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_next
struct mg_connection *mg_next(struct mg_server *s, struct mg_connection *c) {
  struct ns_connection *nc = ns_next(&s->ns_mgr, c == NULL ? NULL :
                                     MG_CONN_2_CONN(c)->ns_conn);
  if (nc != NULL && nc->user_data != NULL) {
    return & ((struct connection *) nc->user_data)->mg_conn;
  } else {
    return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb4eb7
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0xb4ec3
movq -0x18(%rbp), %rax
movq -0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xb03d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xb4efe
movq -0x20(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0xb4efe
movq -0x20(%rbp), %rax
movq 0x80(%rax), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0xb4f06
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_get_var_n
int mg_get_var_n(const struct mg_connection *conn, const char *name,
               char *dst, size_t dst_len, int n) {
  int len = get_var(conn->query_string, conn->query_string == NULL ? 0 :
                    strlen(conn->query_string), name, dst, dst_len, n);
  if (len == -1) {
    len = get_var(conn->content, conn->content_len, name, dst, dst_len, n);
  }
  return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xb4f4b
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xb4f5c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xd550
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
callq 0xb4fc0
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
jne 0xb4fb0
movq -0x8(%rbp), %rax
movq 0x268(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x270(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
callq 0xb4fc0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: get_request_len
static int get_request_len(const char *s, size_t buf_len) {
  const unsigned char *buf = (unsigned char *) s;
  size_t i;

  for (i = 0; i < buf_len; i++) {
    // Control characters are not allowed but >=128 are.
    // Abort scan as soon as one malformed character is found.
    if (!isprint(buf[i]) && buf[i] != '\r' && buf[i] != '\n' && buf[i] < 128) {
      return -1;
    } else if (buf[i] == '\n' && i + 1 < buf_len && buf[i + 1] == '\n') {
      return i + 2;
    } else if (buf[i] == '\n' && i + 2 < buf_len && buf[i + 1] == '\r' &&
               buf[i + 2] == '\n') {
      return i + 3;
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xb5519
callq 0xd1f0
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0xb5474
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xd, %eax
je 0xb5474
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0xb5474
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x80, %eax
jge 0xb5474
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb5520
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xb54b2
movq -0x28(%rbp), %rax
addq $0x1, %rax
cmpq -0x18(%rbp), %rax
jae 0xb54b2
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xb54b2
movq -0x28(%rbp), %rax
addq $0x2, %rax
movl %eax, -0x4(%rbp)
jmp 0xb5520
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xb5502
movq -0x28(%rbp), %rax
addq $0x2, %rax
cmpq -0x18(%rbp), %rax
jae 0xb5502
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0xb5502
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl 0x2(%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0xb5502
movq -0x28(%rbp), %rax
addq $0x3, %rax
movl %eax, -0x4(%rbp)
jmp 0xb5520
jmp 0xb5504
jmp 0xb5506
jmp 0xb5508
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xb5400
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_copy_listeners
void mg_copy_listeners(struct mg_server *s, struct mg_server *to) {
  struct ns_connection *c;
  for (c = ns_next(&s->ns_mgr, NULL); c != NULL; c = ns_next(&s->ns_mgr, c)) {
    struct ns_connection *tmp;
    if ((c->flags & NSF_LISTENING) &&
        (tmp = (struct ns_connection *) NS_MALLOC(sizeof(*tmp))) != NULL) {
      memcpy(tmp, c, sizeof(*tmp));

#if defined(NS_ENABLE_SSL) && defined(HEADER_SSL_H)
      /* OpenSSL only. See https://github.com/cesanta/mongoose/issues/441 */
      if (tmp->ssl_ctx != NULL) {
        tmp->ssl_ctx->references++;
      }
#endif

      tmp->mgr = &to->ns_mgr;
      ns_add_conn(tmp->mgr, tmp);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb03d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb5654
movq -0x18(%rbp), %rax
movl 0xa0(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xb563f
movl $0xa8, %edi
callq 0xdb70
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xb563f
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xa8, %edx
callq 0xd100
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xb09e0
jmp 0xb5641
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb03d0
movq %rax, -0x18(%rbp)
jmp 0xb55e1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: get_option_index
static int get_option_index(const char *name) {
  int i;

  for (i = 0; static_config_options[i * 2] != NULL; i++) {
    if (strcmp(static_config_options[i * 2], name) == 0) {
      return i;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll %eax
movslq %eax, %rcx
leaq 0x3929e(%rip), %rax     # 0xeecd0
cmpq $0x0, (%rax,%rcx,8)
je 0xb5a6f
movl -0x14(%rbp), %eax
shll %eax
movslq %eax, %rcx
leaq 0x39288(%rip), %rax     # 0xeecd0
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0xdab0
cmpl $0x0, %eax
jne 0xb5a62
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb5a76
jmp 0xb5a64
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb5a23
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_strdup
static char *mg_strdup(const char *str) {
  char *copy = (char *) NS_MALLOC(strlen(str) + 1);
  if (copy != NULL) {
    strcpy(copy, str);
  }
  return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd550
movq %rax, %rdi
addq $0x1, %rdi
callq 0xdb70
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb5ab9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xd580
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: next_option
static const char *next_option(const char *list, struct vec *val,
                               struct vec *eq_val) {
  if (list == NULL || *list == '\0') {
    // End of the list
    list = NULL;
  } else {
    val->ptr = list;
    if ((list = strchr(val->ptr, ',')) != NULL) {
      // Comma found. Store length and shift the list ptr
      val->len = list - val->ptr;
      list++;
    } else {
      // This value is the last one
      list = val->ptr + strlen(val->ptr);
      val->len = list - val->ptr;
    }

    if (eq_val != NULL) {
      // Value has form "x=y", adjust pointers and lengths
      // so that val points to "x", and eq_val points to "y".
      eq_val->len = 0;
      eq_val->ptr = (const char *) memchr(val->ptr, '=', val->len);
      if (eq_val->ptr != NULL) {
        eq_val->ptr++;  // Skip over '=' character
        eq_val->len = val->ptr + val->len - eq_val->ptr;
        val->len = (eq_val->ptr - val->ptr) - 1;
      }
    }
  }

  return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb5af7
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xb5b04
movq $0x0, -0x8(%rbp)
jmp 0xb5c1d
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x2c, %esi
callq 0xd710
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0xb5b4e
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xb5b89
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xd550
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xb5c1b
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x3d, %esi
callq 0xd5c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb5c19
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xb5c1b
jmp 0xb5c1d
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./lib/mongoose/mongoose.c
// Function: mg_wakeup_server_ex
void mg_wakeup_server_ex(struct mg_server *server, mg_handler_t cb,
                         const char *fmt, ...) {
  va_list ap;
  char buf[8 * 1024];
  int len;

  // Encode callback (cb) into a buffer
  len = snprintf(buf, sizeof(buf), "%p ", cb);
  va_start(ap, fmt);
  len += vsnprintf(buf + len, sizeof(buf) - len, fmt, ap);
  va_end(ap);

  // "len + 1" is to include terminating \0 in the message
  ns_broadcast(&server->ns_mgr, iter2, buf, len + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2100, %rsp           # imm = 0x2100
testb %al, %al
je 0xb5c77
movaps %xmm0, -0x20c0(%rbp)
movaps %xmm1, -0x20b0(%rbp)
movaps %xmm2, -0x20a0(%rbp)
movaps %xmm3, -0x2090(%rbp)
movaps %xmm4, -0x2080(%rbp)
movaps %xmm5, -0x2070(%rbp)
movaps %xmm6, -0x2060(%rbp)
movaps %xmm7, -0x2050(%rbp)
movq %r9, -0x20c8(%rbp)
movq %r8, -0x20d0(%rbp)
movq %rcx, -0x20d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
leaq 0x110ab(%rip), %rdx     # 0xc6d4e
xorl %eax, %eax
leaq -0x2030(%rbp), %rdi
movq %rdi, -0x20f8(%rbp)
movl $0x2000, %esi           # imm = 0x2000
movq %rsi, -0x2100(%rbp)
callq 0xd6e0
movq -0x2100(%rbp), %rsi
movl %eax, -0x2034(%rbp)
leaq -0x20f0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movslq -0x2034(%rbp), %rax
leaq -0x2030(%rbp,%rax), %rdi
subq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0xdf48
movq -0x20f8(%rbp), %rdx
movl %eax, %ecx
movl -0x2034(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x2034(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2034(%rbp), %eax
incl %eax
movslq %eax, %rcx
leaq 0x12(%rip), %rsi        # 0xb5d50
callq 0xb0a30
addq $0x2100, %rsp           # imm = 0x2100
popq %rbp
retq
nopl (%rax)