LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: accept_new_connection
static void accept_new_connection(const struct socket *listener,
                                  struct mg_context *ctx) {
  struct socket accepted;
  int allowed;

  accepted.rsa.len = sizeof(accepted.rsa.u.sin);
  accepted.lsa = listener->lsa;
  accepted.sock = accept(listener->sock, &accepted.rsa.u.sa, &accepted.rsa.len);
  if (accepted.sock != INVALID_SOCKET) {
    allowed = check_acl(ctx, &accepted.rsa);
    if (allowed) {
      // Put accepted socket structure into the queue
      DEBUG_TRACE(("accepted socket %d", accepted.sock));
      accepted.is_ssl = listener->is_ssl;
      accepted.is_proxy = listener->is_proxy;
      produce_socket(ctx, &accepted);
    } else {
      cry(fc(ctx), "%s: %s is not allowed to connect",
          __func__, inet_ntoa(accepted.rsa.u.sin.sin_addr));
      (void) closesocket(accepted.sock);
    }
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl $0x10, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq 0xc(%rax), %rcx
movq %rcx, 0x24(%rsp)
movq 0x14(%rax), %rcx
movq %rcx, 0x2c(%rsp)
movl 0x1c(%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x60(%rsp), %rax
movl 0x8(%rax), %edi
leaq 0x18(%rsp), %rsi
addq $0x20, %rsi
addq $0x4, %rsi
leaq 0x18(%rsp), %rdx
addq $0x20, %rdx
callq 0x5170
movl %eax, 0x20(%rsp)
cmpl $-0x1, 0x20(%rsp)
je 0x1b2dd
movq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rsi
addq $0x20, %rsi
callq 0x1aea0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x1b29d
movq 0x60(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x4c(%rsp)
movq 0x60(%rsp), %rax
movl 0x38(%rax), %eax
movl %eax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1b2f0
jmp 0x1b2db
movq 0x58(%rsp), %rdi
callq 0x18750
movq %rax, 0x8(%rsp)
movl 0x40(%rsp), %edi
callq 0x5240
movq 0x8(%rsp), %rdi
movq %rax, %rcx
leaq 0x7b39(%rip), %rsi      # 0x22dfd
leaq 0x7b53(%rip), %rdx      # 0x22e1e
movb $0x0, %al
callq 0x184e0
movl 0x20(%rsp), %edi
callq 0x5b70
jmp 0x1b2dd
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: produce_socket
static void produce_socket(struct mg_context *ctx, const struct socket *sp) {
  (void) pthread_mutex_lock(&ctx->mutex);

  // If the queue is full, wait
  while (ctx->sq_head - ctx->sq_tail >= (int) ARRAY_SIZE(ctx->queue)) {
    (void) pthread_cond_wait(&ctx->sq_empty, &ctx->mutex);
  }
  assert(ctx->sq_head - ctx->sq_tail < (int) ARRAY_SIZE(ctx->queue));

  // Copy socket to the queue and increment head
  ctx->queue[ctx->sq_head % ARRAY_SIZE(ctx->queue)] = *sp;
  ctx->sq_head++;
  DEBUG_TRACE(("queued socket %d", sp->sock));

  (void) pthread_cond_signal(&ctx->sq_full);
  (void) pthread_mutex_unlock(&ctx->mutex);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0xe0, %rdi
callq 0x58a0
movq 0x10(%rsp), %rax
movl 0x638(%rax), %eax
movq 0x10(%rsp), %rcx
movl 0x63c(%rcx), %ecx
subl %ecx, %eax
cmpl $0x14, %eax
jl 0x1b34b
movq 0x10(%rsp), %rdi
addq $0x670, %rdi            # imm = 0x670
movq 0x10(%rsp), %rsi
addq $0xe0, %rsi
callq 0x5910
jmp 0x1b30f
movq 0x10(%rsp), %rdi
addq $0x138, %rdi            # imm = 0x138
movq 0x10(%rsp), %rax
movl 0x638(%rax), %eax
cltq
movl $0x14, %ecx
xorl %edx, %edx
divq %rcx
shlq $0x6, %rdx
addq %rdx, %rdi
movq 0x8(%rsp), %rsi
movl $0x40, %edx
callq 0x5450
movq 0x10(%rsp), %rax
movl 0x638(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x638(%rax)
movq 0x10(%rsp), %rdi
addq $0x640, %rdi            # imm = 0x640
callq 0x5030
movq 0x10(%rsp), %rdi
addq $0xe0, %rdi
callq 0x53e0
addq $0x18, %rsp
retq
nop
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: consume_socket
static int consume_socket(struct mg_context *ctx, struct socket *sp) {
  (void) pthread_mutex_lock(&ctx->mutex);
  DEBUG_TRACE(("going idle"));

  // If the queue is empty, wait. We're idle at this point.
  while (ctx->sq_head == ctx->sq_tail && ctx->stop_flag == 0) {
    pthread_cond_wait(&ctx->sq_full, &ctx->mutex);
  }
  // Master thread could wake us up without putting a socket.
  // If this happens, it is time to exit.
  if (ctx->stop_flag) {
    (void) pthread_mutex_unlock(&ctx->mutex);
    return 0;
  }
  assert(ctx->sq_head > ctx->sq_tail);

  // Copy socket from the queue and increment tail
  *sp = ctx->queue[ctx->sq_tail % ARRAY_SIZE(ctx->queue)];
  ctx->sq_tail++;
  DEBUG_TRACE(("grabbed socket %d, going busy", sp->sock));

  // Wrap pointers if needed
  while (ctx->sq_tail > (int) ARRAY_SIZE(ctx->queue)) {
    ctx->sq_tail -= ARRAY_SIZE(ctx->queue);
    ctx->sq_head -= ARRAY_SIZE(ctx->queue);
  }

  (void) pthread_cond_signal(&ctx->sq_empty);
  (void) pthread_mutex_unlock(&ctx->mutex);

  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
addq $0xe0, %rdi
callq 0x58a0
movq 0x18(%rsp), %rax
movl 0x638(%rax), %ecx
movq 0x18(%rsp), %rax
movl 0x63c(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, 0xf(%rsp)
jne 0x1b410
movq 0x18(%rsp), %rax
movl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1b41a
jmp 0x1b439
movq 0x18(%rsp), %rdi
addq $0x640, %rdi            # imm = 0x640
movq 0x18(%rsp), %rsi
addq $0xe0, %rsi
callq 0x5910
jmp 0x1b3df
movq 0x18(%rsp), %rax
movl (%rax), %eax
cmpl $0x0, %eax
je 0x1b463
movq 0x18(%rsp), %rdi
addq $0xe0, %rdi
callq 0x53e0
movl $0x0, 0x24(%rsp)
jmp 0x1b51c
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x138, %rsi            # imm = 0x138
movq 0x18(%rsp), %rax
movl 0x63c(%rax), %eax
cltq
movl $0x14, %ecx
xorl %edx, %edx
divq %rcx
shlq $0x6, %rdx
addq %rdx, %rsi
movl $0x40, %edx
callq 0x5450
movq 0x18(%rsp), %rax
movl 0x63c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x63c(%rax)
movq 0x18(%rsp), %rax
movl 0x63c(%rax), %eax
cmpl $0x14, %eax
jle 0x1b4f2
movq 0x18(%rsp), %rax
movl 0x63c(%rax), %ecx
movslq %ecx, %rcx
subq $0x14, %rcx
movl %ecx, 0x63c(%rax)
movq 0x18(%rsp), %rax
movl 0x638(%rax), %ecx
movslq %ecx, %rcx
subq $0x14, %rcx
movl %ecx, 0x638(%rax)
jmp 0x1b4b0
movq 0x18(%rsp), %rdi
addq $0x670, %rdi            # imm = 0x670
callq 0x5030
movq 0x18(%rsp), %rdi
addq $0xe0, %rdi
callq 0x53e0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: close_connection
static void close_connection(struct mg_connection *conn) {
  if (conn->ssl) {
    SSL_free(conn->ssl);
    conn->ssl = NULL;
  }

  if (conn->client.sock != INVALID_SOCKET) {
    close_socket_gracefully(conn->client.sock);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x460(%rax)
je 0x1b926
movq 0xffce(%rip), %rax      # 0x2b8d8
movq (%rsp), %rcx
movq 0x460(%rcx), %rdi
callq *%rax
movq (%rsp), %rax
movq $0x0, 0x460(%rax)
movq (%rsp), %rax
cmpl $-0x1, 0x470(%rax)
je 0x1b942
movq (%rsp), %rax
movl 0x470(%rax), %edi
callq 0x21590
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: reset_per_request_attributes
static void reset_per_request_attributes(struct mg_connection *conn) {
  struct mg_request_info *ri = &conn->request_info;

  // Reset request info attributes. DO NOT TOUCH is_ssl, remote_ip, remote_port
  if (ri->remote_user != NULL) {
    free((void *) ri->remote_user);
  }
  ri->remote_user = ri->request_method = ri->uri = ri->http_version = NULL;
  ri->num_headers = 0;
  ri->status_code = -1;

  conn->num_bytes_sent = conn->consumed_content = 0;
  conn->content_len = -1;
  conn->request_len = conn->data_len = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1b981
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x56c0
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x4c(%rax)
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x44(%rax) # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rax
movq $0x0, 0x4c0(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x4b0(%rax)
movq 0x10(%rsp), %rax
movq $-0x1, 0x4b8(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x4d8(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x4d4(%rax)
addq $0x18, %rsp
retq
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: get_request_len
static int get_request_len(const char *buf, int buflen) {
  const char *s, *e;
  int len = 0;

  DEBUG_TRACE(("buf: %p, len: %d", buf, buflen));
  for (s = buf, e = s + buflen - 1; len <= 0 && s < e; s++)
    // Control characters are not allowed but >=128 is.
    if (!isprint(* (const unsigned char *) s) && *s != '\r' &&
        *s != '\n' && * (const unsigned char *) s < 128) {
      len = -1;
    } else if (s[0] == '\n' && s[1] == '\n') {
      len = (int) (s - buf) + 2;
    } else if (s[0] == '\n' && &s[1] < e &&
        s[1] == '\r' && s[2] == '\n') {
      len = (int) (s - buf) + 3;
    }

  return len;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x4(%rsp)
movb %al, 0x3(%rsp)
jg 0x1ba73
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
setb %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x1ba80
jmp 0x1bb6e
callq 0x5610
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0x1bad7
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x1bad7
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x1bad7
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0x1bad7
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x1bb59
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1bb08
movq 0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0xa, %eax
jne 0x1bb08
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rcx, %rax
addl $0x2, %eax
movl %eax, 0x4(%rsp)
jmp 0x1bb57
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1bb55
movq 0x10(%rsp), %rax
addq $0x1, %rax
cmpq 0x8(%rsp), %rax
jae 0x1bb55
movq 0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0xd, %eax
jne 0x1bb55
movq 0x10(%rsp), %rax
movsbl 0x2(%rax), %eax
cmpl $0xa, %eax
jne 0x1bb55
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rcx, %rax
addl $0x3, %eax
movl %eax, 0x4(%rsp)
jmp 0x1bb57
jmp 0x1bb59
jmp 0x1bb5b
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1ba55
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: read_request
static int read_request(FILE *fp, SOCKET sock, SSL *ssl, char *buf, int bufsiz,
                        int *nread) {
  int n, request_len;

  request_len = 0;
  while (*nread < bufsiz && request_len == 0) {
    n = pull(fp, sock, ssl, buf + *nread, bufsiz - *nread);
    if (n <= 0) {
      break;
    } else {
      *nread += n;
      request_len = get_request_len(buf, *nread);
    }
  }

  return request_len;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq %r9, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
xorl %eax, %eax
cmpl 0x24(%rsp), %ecx
movb %al, 0xf(%rsp)
jge 0x1bbc8
cmpl $0x0, 0x10(%rsp)
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1bbd2
jmp 0x1bc36
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rax
movslq (%rax), %rax
addq %rax, %rcx
movl 0x24(%rsp), %r8d
movq 0x18(%rsp), %rax
subl (%rax), %r8d
callq 0x16e30
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jg 0x1bc0f
jmp 0x1bc36
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
callq 0x1ba20
movl %eax, 0x10(%rsp)
jmp 0x1bba9
movl 0x10(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: parse_http_request
static int parse_http_request(char *buf, struct mg_request_info *ri) {
  int status = 0;

  // RFC says that all initial whitespaces should be ingored
  while (*buf != '\0' && isspace(* (unsigned char *) buf)) {
    buf++;
  }

  ri->request_method = skip(&buf, " ");
  ri->uri = skip(&buf, " ");
  ri->http_version = skip(&buf, "\r\n");

  if (is_valid_http_method(ri->request_method) &&
      strncmp(ri->http_version, "HTTP/", 5) == 0) {
    ri->http_version += 5;   /* Skip "HTTP/" */
    parse_http_headers(&buf, ri);
    status = 1;
  }

  return status;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x3(%rsp)
je 0x1bf0f
callq 0x5610
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x1bf19
jmp 0x1bf29
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1bed6
leaq 0x10(%rsp), %rdi
leaq 0x6377(%rip), %rsi      # 0x222ac
callq 0x1cda0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
leaq 0x10(%rsp), %rdi
leaq 0x635a(%rip), %rsi      # 0x222ac
callq 0x1cda0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
leaq 0x10(%rsp), %rdi
leaq 0x72d9(%rip), %rsi      # 0x23248
callq 0x1cda0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1cdd0
cmpl $0x0, %eax
je 0x1bfda
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x6f6e(%rip), %rsi      # 0x22f11
movl $0x5, %edx
callq 0x5270
cmpl $0x0, %eax
jne 0x1bfda
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x5, %rcx
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x1cea0
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: discard_current_request_from_buffer
static void discard_current_request_from_buffer(struct mg_connection *conn) {
  char *buffered;
  int buffered_len, body_len;

  buffered = conn->buf + conn->request_len;
  buffered_len = conn->data_len - conn->request_len;
  assert(buffered_len >= 0);

  if (conn->content_len == -1) {
    body_len = 0;
  } else if (conn->content_len < (int64_t) buffered_len) {
    body_len = (int) conn->content_len;
  } else {
    body_len = buffered_len;
  }

  conn->data_len -= conn->request_len + body_len;
  memmove(conn->buf, conn->buf + conn->request_len + body_len,
          (size_t) conn->data_len);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x4c8(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x4d4(%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x4d8(%rax), %eax
movq 0x10(%rsp), %rcx
subl 0x4d4(%rcx), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
cmpq $-0x1, 0x4b8(%rax)
jne 0x1cb5b
movl $0x0, (%rsp)
jmp 0x1cb8b
movq 0x10(%rsp), %rax
movq 0x4b8(%rax), %rax
movslq 0x4(%rsp), %rcx
cmpq %rcx, %rax
jge 0x1cb82
movq 0x10(%rsp), %rax
movq 0x4b8(%rax), %rax
movl %eax, (%rsp)
jmp 0x1cb89
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
jmp 0x1cb8b
movq 0x10(%rsp), %rax
movl 0x4d4(%rax), %edx
addl (%rsp), %edx
movq 0x10(%rsp), %rax
movl 0x4d8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4d8(%rax)
movq 0x10(%rsp), %rax
movq 0x4c8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x4c8(%rax), %rsi
movq 0x10(%rsp), %rax
movslq 0x4d4(%rax), %rax
addq %rax, %rsi
movslq (%rsp), %rax
addq %rax, %rsi
movq 0x10(%rsp), %rax
movslq 0x4d8(%rax), %rdx
callq 0x59c0
addq $0x18, %rsp
retq
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: should_keep_alive
static int should_keep_alive(const struct mg_connection *conn) {
  const char *http_version = conn->request_info.http_version;
  const char *header = mg_get_header(conn, "Connection");
  return (header == NULL && http_version && !strcmp(http_version, "1.1")) ||
      (header != NULL && !mg_strcasecmp(header, "keep-alive"));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x7152(%rip), %rsi      # 0x23d65
callq 0x16b70
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1cc4b
cmpq $0x0, 0x18(%rsp)
je 0x1cc4b
movq 0x18(%rsp), %rdi
leaq 0x69d2(%rip), %rsi      # 0x2360b
callq 0x5810
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x1cc7e
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xe(%rsp)
je 0x1cc76
movq 0x10(%rsp), %rdi
leaq 0x629b(%rip), %rsi      # 0x22f00
callq 0x19510
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: mg_snprintf
static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
                       const char *fmt, ...) {
  va_list ap;
  int n;

  va_start(ap, fmt);
  n = mg_vsnprintf(conn, buf, buflen, fmt, ap);
  va_end(ap);

  return n;
}

// Assembly:
subq $0xf8, %rsp
testb %al, %al
je 0x1cccc
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rcx, 0xd8(%rsp)
movq %rsp, %rax
movq %rax, 0xd0(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x20, 0xc0(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
movq 0xe0(%rsp), %rdx
movq 0xd8(%rsp), %rcx
leaq 0xc0(%rsp), %r8
callq 0x17120
movl %eax, 0xbc(%rsp)
movl 0xbc(%rsp), %eax
addq $0xf8, %rsp
retq
nopw (%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: parse_http_headers
static void parse_http_headers(char **buf, struct mg_request_info *ri) {
  int i;

  for (i = 0; i < (int) ARRAY_SIZE(ri->http_headers); i++) {
    ri->http_headers[i].name = skip_quoted(buf, ":", " ", 0);
    ri->http_headers[i].value = skip(buf, "\r\n");
    if (ri->http_headers[i].name[0] == '\0')
      break;
    ri->num_headers = i + 1;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x40, 0x4(%rsp)
jge 0x1cf64
movq 0x10(%rsp), %rdi
leaq 0x53ed(%rip), %rsi      # 0x222ba
leaq 0x53d8(%rip), %rdx      # 0x222ac
xorl %ecx, %ecx
callq 0x1cf70
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq $0x50, %rax
movslq 0x4(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
leaq 0x6346(%rip), %rsi      # 0x23248
callq 0x1cda0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq $0x50, %rax
movslq 0x4(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x50, %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1cf45
jmp 0x1cf64
movl 0x4(%rsp), %ecx
addl $0x1, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4c(%rax)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1ceb6
addq $0x18, %rsp
retq
nopl (%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: skip_quoted
static char *skip_quoted(char **buf, const char *delimiters, const char *whitespace, char quotechar) {
  char *p, *begin_word, *end_word, *end_whitespace;

  begin_word = *buf;
  end_word = begin_word + strcspn(begin_word, delimiters);

  /* Check for quotechar */
  if (end_word > begin_word) {
    p = end_word - 1;
    while (*p == quotechar) {
      /* If there is anything beyond end_word, copy it */
      if (*end_word == '\0') {
        *p = '\0';
        break;
      } else {
        size_t end_off = strcspn(end_word + 1, delimiters);
        memmove (p, end_word, end_off + 1);
        p += end_off; /* p must correspond to end_word - 1 */
        end_word += end_off + 1;
      }
    }
    for (p++; p < end_word; p++) {
      *p = '\0';
    }
  }

  if (*end_word == '\0') {
    *buf = end_word;
  } else {
    end_whitespace = end_word + 1 + strspn(end_word + 1, whitespace);

    for (p = end_word; p < end_whitespace; p++) {
      *p = '\0';
    }

    *buf = end_whitespace;
  }

  return begin_word;
}

// Assembly:
subq $0x58, %rsp
movb %cl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movb %al, 0x3f(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x50a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jbe 0x1d08d
movq 0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movsbl (%rax), %eax
movsbl 0x3f(%rsp), %ecx
cmpl %ecx, %eax
jne 0x1d059
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1d005
movq 0x30(%rsp), %rax
movb $0x0, (%rax)
jmp 0x1d059
movq 0x20(%rsp), %rdi
addq $0x1, %rdi
movq 0x48(%rsp), %rsi
callq 0x50a0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq $0x1, %rdx
callq 0x59c0
movq 0x10(%rsp), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1cfdd
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x1d08b
movq 0x30(%rsp), %rax
movb $0x0, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1d067
jmp 0x1d08d
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1d0a9
movq 0x20(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1d113
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
addq $0x1, %rdi
movq 0x40(%rsp), %rsi
callq 0x5210
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x1d106
movq 0x30(%rsp), %rax
movb $0x0, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1d0e2
movq 0x18(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: log_header
static void log_header(const struct mg_connection *conn, const char *header,
                       FILE *fp) {
  const char *header_value;

  if ((header_value = mg_get_header(conn, header)) == NULL) {
    (void) fprintf(fp, "%s", " -");
  } else {
    (void) fprintf(fp, " \"%s\"", header_value);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x16b70
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x1d169
movq 0x10(%rsp), %rdi
leaq 0x661f(%rip), %rsi      # 0x23778
leaq 0x5e24(%rip), %rdx      # 0x22f84
movb $0x0, %al
callq 0x5850
jmp 0x1d181
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x66fe(%rip), %rsi      # 0x23878
movb $0x0, %al
callq 0x5850
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: parse_url
static int parse_url(const char *url, char *host, int *port) {
  int len;

  if (sscanf(url, "%*[htps]://%1024[^:]:%d%n", host, port, &len) == 2 ||
      sscanf(url, "%1024[^:]:%d%n", host, port, &len) == 2) {
  } else if (sscanf(url, "%*[htps]://%1024[^/]%n", host, &len) == 1) {
    *port = 80;
  } else {
    sscanf(url, "%1024[^/]%n", host, &len);
    *port = 80;
  }
  DEBUG_TRACE(("Host:%s, port:%d", host, *port));

  return len;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x5de7(%rip), %rsi      # 0x22fa0
leaq 0xc(%rsp), %r8
movb $0x0, %al
callq 0x5540
cmpl $0x2, %eax
je 0x1d1f1
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x5dcb(%rip), %rsi      # 0x22fab
leaq 0xc(%rsp), %r8
movb $0x0, %al
callq 0x5540
cmpl $0x2, %eax
jne 0x1d1f3
jmp 0x1d24c
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x5db6(%rip), %rsi      # 0x22fba
leaq 0xc(%rsp), %rcx
movb $0x0, %al
callq 0x5540
cmpl $0x1, %eax
jne 0x1d222
movq 0x10(%rsp), %rax
movl $0x50, (%rax)
jmp 0x1d24a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x5d92(%rip), %rsi      # 0x22fc5
leaq 0xc(%rsp), %rcx
movb $0x0, %al
callq 0x5540
movq 0x10(%rsp), %rax
movl $0x50, (%rax)
jmp 0x1d24c
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: remove_double_dots_and_double_slashes
static void remove_double_dots_and_double_slashes(char *s) {
  char *p = s;

  while (*s != '\0') {
    *p++ = *s++;
    if (s[-1] == '/' || s[-1] == '\\') {
      // Skip all following slashes and backslashes
      while (*s == '/' || *s == '\\') {
        s++;
      }

      // Skip all double-dots
      while (*s == '.' && s[1] == '.') {
        s += 2;
      }
    }
  }
  *p = '\0';
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1d8d0
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rsp)
movb (%rax), %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
movq -0x8(%rsp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x1d846
movq -0x8(%rsp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x5c, %eax
jne 0x1d8cb
jmp 0x1d848
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2f, %ecx
movb %al, -0x11(%rsp)
je 0x1d86d
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
sete %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
testb $0x1, %al
jne 0x1d877
jmp 0x1d887
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x1d848
jmp 0x1d889
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x12(%rsp)
jne 0x1d8af
movq -0x8(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2e, %eax
sete %al
movb %al, -0x12(%rsp)
movb -0x12(%rsp), %al
testb $0x1, %al
jne 0x1d8b9
jmp 0x1d8c9
movq -0x8(%rsp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rsp)
jmp 0x1d889
jmp 0x1d8cb
jmp 0x1d7ef
movq -0x10(%rsp), %rax
movb $0x0, (%rax)
retq
nopl (%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: check_authorization
static int check_authorization(struct mg_connection *conn, const char *path) {
  FILE *fp;
  char fname[PATH_MAX];
  struct vec uri_vec, filename_vec;
  const char *list;
  int authorized;

  fp = NULL;
  authorized = 1;

  list = conn->ctx->config[PROTECT_URI];
  while ((list = next_option(list, &uri_vec, &filename_vec)) != NULL) {
    if (!memcmp(conn->request_info.uri, uri_vec.ptr, uri_vec.len)) {
      (void) mg_snprintf(conn, fname, sizeof(fname), "%.*s",
          filename_vec.len, filename_vec.ptr);
      if ((fp = mg_fopen(fname, "r")) == NULL) {
        cry(conn, "%s: cannot open %s: %s", __func__, fname, strerror(errno));
      }
      break;
    }
  }

  if (fp == NULL) {
    fp = open_auth_file(conn, path);
  }

  if (fp != NULL) {
    authorized = authorize(conn, fp);
    (void) fclose(fp);
  }

  return authorized;
}

// Assembly:
subq $0x1058, %rsp           # imm = 0x1058
movq %rdi, 0x1050(%rsp)
movq %rsi, 0x1048(%rsp)
movq $0x0, 0x1040(%rsp)
movl $0x1, 0x14(%rsp)
movq 0x1050(%rsp), %rax
movq 0x458(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1ab00
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1da6d
movq 0x1050(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x5250
cmpl $0x0, %eax
jne 0x1da68
movq 0x1050(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r9
movl $0x1000, %edx           # imm = 0x1000
leaq 0x5be0(%rip), %rcx      # 0x235dd
movb $0x0, %al
callq 0x1cc90
leaq 0x40(%rsp), %rdi
leaq 0x5f7e(%rip), %rsi      # 0x2398e
callq 0x56b0
movq %rax, 0x1040(%rsp)
cmpq $0x0, %rax
jne 0x1da66
movq 0x1050(%rsp), %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x5060
movl (%rax), %edi
callq 0x5190
movq (%rsp), %rdi
movq 0x8(%rsp), %rcx
movq %rax, %r8
leaq 0x511f(%rip), %rsi      # 0x22b77
leaq 0x5725(%rip), %rdx      # 0x23184
movb $0x0, %al
callq 0x184e0
jmp 0x1da6d
jmp 0x1d993
cmpq $0x0, 0x1040(%rsp)
jne 0x1da95
movq 0x1050(%rsp), %rdi
movq 0x1048(%rsp), %rsi
callq 0x1f070
movq %rax, 0x1040(%rsp)
cmpq $0x0, 0x1040(%rsp)
je 0x1dac6
movq 0x1050(%rsp), %rdi
movq 0x1040(%rsp), %rsi
callq 0x1f270
movl %eax, 0x14(%rsp)
movq 0x1040(%rsp), %rdi
callq 0x5560
movl 0x14(%rsp), %eax
addq $0x1058, %rsp           # imm = 0x1058
retq
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: send_authorization_request
static void send_authorization_request(struct mg_connection *conn) {
  conn->request_info.status_code = 401;
  (void) mg_printf(conn,
      "HTTP/1.1 401 Unauthorized\r\n"
      "WWW-Authenticate: Digest qop=\"auth\", "
      "realm=\"%s\", nonce=\"%lu\"\r\n\r\n",
      conn->ctx->config[AUTHENTICATION_DOMAIN],
      (unsigned long) time(NULL));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x191, 0x4c(%rax)      # imm = 0x191
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x458(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x54f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x56c0(%rip), %rsi      # 0x231ef
movb $0x0, %al
callq 0x17030
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: is_authorized_for_put
static int is_authorized_for_put(struct mg_connection *conn) {
  FILE *fp;
  int ret = 0;

  fp = conn->ctx->config[PUT_DELETE_PASSWORDS_FILE] == NULL ? NULL :
    mg_fopen(conn->ctx->config[PUT_DELETE_PASSWORDS_FILE], "r");

  if (fp != NULL) {
    ret = authorize(conn, fp);
    (void) fclose(fp);
  }

  return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x458(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1db6d
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x1db8e
movq 0x20(%rsp), %rax
movq 0x458(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x5e0a(%rip), %rsi      # 0x2398e
callq 0x56b0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1dbbd
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1f270
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x5560
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: substitute_index_file
static int substitute_index_file(struct mg_connection *conn, char *path,
                                 size_t path_len, struct mgstat *stp) {
  const char *list = conn->ctx->config[INDEX_FILES];
  struct mgstat st;
  struct vec filename_vec;
  size_t n = strlen(path);
  int found = 0;

  // The 'path' given to us points to the directory. Remove all trailing
  // directory separator characters from the end of the path, and
  // then append single directory separator character.
  while (n > 0 && IS_DIRSEP_CHAR(path[n - 1])) {
    n--;
  }
  path[n] = DIRSEP;

  // Traverse index files list. For each entry, append it to the given
  // path and see if the file exists. If it exists, break the loop
  while ((list = next_option(list, &filename_vec, NULL)) != NULL) {

    // Ignore too long entries that may overflow path buffer
    if (filename_vec.len > path_len - n)
      continue;

    // Prepare full path to the index file
    (void) mg_strlcpy(path + n + 1, filename_vec.ptr, filename_vec.len + 1);

    // Does it exist?
    if (mg_stat(path, &st) == 0) {
      // Yes it does, break the loop
      *stp = st;
      found = 1;
      break;
    }
  }

  // If no index file exists, restore directory path
  if (!found) {
    path[n] = '\0';
  }

  return found;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq 0x458(%rax), %rax
movq 0x70(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
callq 0x5230
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xb(%rsp)
jbe 0x1de6e
movq 0x58(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
sete %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x1de78
jmp 0x1de88
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1de44
movq 0x58(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x2f, (%rax,%rcx)
movq 0x40(%rsp), %rdi
leaq 0x18(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1ab00
movq %rax, 0x40(%rsp)
cmpq $0x0, %rax
je 0x1df2d
movq 0x20(%rsp), %rax
movq 0x50(%rsp), %rcx
subq 0x10(%rsp), %rcx
cmpq %rcx, %rax
jbe 0x1deca
jmp 0x1de96
movq 0x58(%rsp), %rdi
addq 0x10(%rsp), %rdi
addq $0x1, %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x1, %rdx
callq 0x17840
movq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1a8a0
cmpl $0x0, %eax
jne 0x1df28
movq 0x48(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, 0xc(%rsp)
jmp 0x1df2d
jmp 0x1de96
cmpl $0x0, 0xc(%rsp)
jne 0x1df42
movq 0x58(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0xc(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: match_extension
static int match_extension(const char *path, const char *ext_list) {
  struct vec ext_vec;
  size_t path_len;

  path_len = strlen(path);

  while ((ext_list = next_option(ext_list, &ext_vec, NULL)) != NULL)
    if (ext_vec.len < path_len &&
        mg_strncasecmp(path + path_len - ext_vec.len,
          ext_vec.ptr, ext_vec.len) == 0)
      return 1;

  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x5230
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1ab00
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x1e43b
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x1e439
movq 0x28(%rsp), %rdi
addq 0x8(%rsp), %rdi
xorl %eax, %eax
subq 0x18(%rsp), %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x17390
cmpl $0x0, %eax
jne 0x1e439
movl $0x1, 0x34(%rsp)
jmp 0x1e443
jmp 0x1e3dd
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: handle_ssi_file_request
static void handle_ssi_file_request(struct mg_connection *conn,
                                    const char *path) {
  FILE *fp;

  if ((fp = mg_fopen(path, "rb")) == NULL) {
    send_http_error(conn, 500, http_500_error, "fopen(%s): %s", path,
                    strerror(ERRNO));
  } else {
    set_close_on_exec(fileno(fp));
    mg_printf(conn, "HTTP/1.1 200 OK\r\n"
              "Content-Type: text/html\r\nConnection: %s\r\n\r\n",
              suggest_connection_header(conn));
    send_ssi_file(conn, path, fp, 0);
    (void) fclose(fp);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x4b53(%rip), %rsi      # 0x2356d
callq 0x56b0
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
jne 0x1ea7d
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xd025(%rip), %rax      # 0x2ba60
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x5060
movl (%rax), %edi
callq 0x5190
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %r8
movq %rax, %r9
movl $0x1f4, %esi            # imm = 0x1F4
leaq 0x4e82(%rip), %rcx      # 0x238f6
movb $0x0, %al
callq 0x1bc40
jmp 0x1ead6
movq 0x20(%rsp), %rdi
callq 0x55c0
movl %eax, %edi
callq 0x1ae20
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x1cd70
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x4d3d(%rip), %rsi      # 0x237ec
movb $0x0, %al
callq 0x17030
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
xorl %ecx, %ecx
callq 0x20a60
movq 0x20(%rsp), %rdi
callq 0x5560
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: get_document_root
static int get_document_root(const struct mg_connection *conn,
                             struct vec *document_root) {
  const char *root, *uri;
  int len_of_matched_uri;
  struct vec uri_vec, path_vec;

  uri = conn->request_info.uri;
  len_of_matched_uri = 0;
  root = next_option(conn->ctx->config[DOCUMENT_ROOT], document_root, NULL);

  while ((root = next_option(root, &uri_vec, &path_vec)) != NULL) {
    if (memcmp(uri, uri_vec.ptr, uri_vec.len) == 0) {
      *document_root = path_vec;
      len_of_matched_uri = uri_vec.len;
      break;
    }
  }

  return len_of_matched_uri;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x40(%rsp), %rax
movq 0x458(%rax), %rax
movq 0xa0(%rax), %rdi
movq 0x38(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1ab00
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
callq 0x1ab00
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x1f062
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x5250
cmpl $0x0, %eax
jne 0x1f060
movq 0x38(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl %eax, 0x24(%rsp)
jmp 0x1f062
jmp 0x1f00a
movl 0x24(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: authorize
static int authorize(struct mg_connection *conn, FILE *fp) {
  struct ah ah;
  char line[256], f_user[256], ha1[256], f_domain[256], buf[BUFSIZ];

  if (!parse_auth_header(conn, buf, sizeof(buf), &ah)) {
    return 0;
  }

  // Loop over passwords file
  while (fgets(line, sizeof(line), fp) != NULL) {
    if (sscanf(line, "%[^:]:%[^:]:%s", f_user, f_domain, ha1) != 3) {
      continue;
    }

    if (!strcmp(ah.user, f_user) &&
        !strcmp(conn->ctx->config[AUTHENTICATION_DOMAIN], f_domain))
      return check_password(
            conn->request_info.request_method,
            ha1, ah.uri, ah.nonce, ah.nc, ah.cnonce, ah.qop,
            ah.response);
  }

  return 0;
}

// Assembly:
subq $0x2468, %rsp           # imm = 0x2468
movq %rdi, 0x2458(%rsp)
movq %rsi, 0x2450(%rsp)
movq 0x2458(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x2000, %edx           # imm = 0x2000
leaq 0x2418(%rsp), %rcx
callq 0x1f3e0
cmpl $0x0, %eax
jne 0x1f2bb
movl $0x0, 0x2464(%rsp)
jmp 0x1f3c4
jmp 0x1f2bd
leaq 0x2310(%rsp), %rdi
movq 0x2450(%rsp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x5980
cmpq $0x0, %rax
je 0x1f3b9
leaq 0x2310(%rsp), %rdi
leaq 0x2210(%rsp), %rdx
leaq 0x2010(%rsp), %rcx
leaq 0x2110(%rsp), %r8
leaq 0x3ea0(%rip), %rsi      # 0x231a8
movb $0x0, %al
callq 0x5540
cmpl $0x3, %eax
je 0x1f316
jmp 0x1f2bd
movq 0x2418(%rsp), %rdi
leaq 0x2210(%rsp), %rsi
callq 0x5810
cmpl $0x0, %eax
jne 0x1f3b4
movq 0x2458(%rsp), %rax
movq 0x458(%rax), %rax
movq 0x38(%rax), %rdi
leaq 0x2010(%rsp), %rsi
callq 0x5810
cmpl $0x0, %eax
jne 0x1f3b4
movq 0x2458(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2110(%rsp), %rsi
movq 0x2420(%rsp), %rdx
movq 0x2448(%rsp), %rcx
movq 0x2440(%rsp), %r8
movq 0x2428(%rsp), %r9
movq 0x2438(%rsp), %r10
movq 0x2430(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1f6b0
movl %eax, 0x2464(%rsp)
jmp 0x1f3c4
jmp 0x1f2bd
movl $0x0, 0x2464(%rsp)
movl 0x2464(%rsp), %eax
addq $0x2468, %rsp           # imm = 0x2468
retq
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/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];

  // Some of the parameters may be NULL
  if (method == NULL || nonce == NULL || nc == NULL || cnonce == NULL ||
      qop == NULL || response == NULL) {
    return 0;
  }

  // NOTE(lsm): due to a bug in MSIE, we do not compare the URI
  // TODO(lsm): check for authentication timeout
  if (// strcmp(dig->uri, c->ouri) != 0 ||
      strlen(response) != 32
      // || now - strtoul(dig->nonce, NULL, 10) > 3600
      ) {
    return 0;
  }

  mg_md5(ha2, method, ":", uri, NULL);
  mg_md5(expected_response, ha1, ":", nonce, ":", nc,
      ":", cnonce, ":", qop, ":", ha2, NULL);

  return mg_strcasecmp(response, expected_response) == 0;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq 0xe8(%rsp), %rax
movq 0xe0(%rsp), %rax
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq %r8, 0xa0(%rsp)
movq %r9, 0x98(%rsp)
cmpq $0x0, 0xc0(%rsp)
je 0x1f73a
cmpq $0x0, 0xa8(%rsp)
je 0x1f73a
cmpq $0x0, 0xa0(%rsp)
je 0x1f73a
cmpq $0x0, 0x98(%rsp)
je 0x1f73a
cmpq $0x0, 0xe0(%rsp)
je 0x1f73a
cmpq $0x0, 0xe8(%rsp)
jne 0x1f74a
movl $0x0, 0xcc(%rsp)
jmp 0x1f827
movq 0xe8(%rsp), %rdi
callq 0x5230
cmpq $0x20, %rax
je 0x1f76d
movl $0x0, 0xcc(%rsp)
jmp 0x1f827
leaq 0x70(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xb0(%rsp), %rcx
leaq 0x2b31(%rip), %rdx      # 0x222ba
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x178c0
leaq 0x40(%rsp), %rdi
movq 0xb8(%rsp), %rsi
movq 0xa8(%rsp), %rcx
movq 0xa0(%rsp), %r9
movq 0x98(%rsp), %rbx
movq 0xe0(%rsp), %r11
leaq 0x70(%rsp), %rax
leaq 0x2aec(%rip), %r10      # 0x222ba
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 0x178c0
movq 0xe8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x19510
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xcc(%rsp)
movl 0xcc(%rsp), %eax
addq $0xd0, %rsp
popq %rbx
retq
nopw (%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: put_dir
static int put_dir(const char *path) {
  char buf[PATH_MAX];
  const char *s, *p;
  struct mgstat st;
  size_t len;

  for (s = p = path + 2; (p = strchr(s, '/')) != NULL; s = ++p) {
    len = p - path;
    assert(len < sizeof(buf));
    (void) memcpy(buf, path, len);
    buf[len] = '\0';

    // Try to create intermediate directory
    if (mg_stat(buf, &st) == -1 && mg_mkdir(buf, 0755) != 0) {
      return -1;
    }

    // Is path itself a directory?
    if (p[1] == '\0') {
      return 0;
    }
  }

  return 1;
}

// Assembly:
subq $0x1048, %rsp           # imm = 0x1048
movq %rdi, 0x1038(%rsp)
movq 0x1038(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2f, %esi
callq 0x51d0
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x1f920
movq 0x20(%rsp), %rax
movq 0x1038(%rsp), %rcx
subq %rcx, %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
movq 0x1038(%rsp), %rsi
movq (%rsp), %rdx
callq 0x5450
movq (%rsp), %rax
movb $0x0, 0x30(%rsp,%rax)
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1a8a0
cmpl $-0x1, %eax
jne 0x1f8eb
leaq 0x30(%rsp), %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x5260
cmpl $0x0, %eax
je 0x1f8eb
movl $0xffffffff, 0x1044(%rsp) # imm = 0xFFFFFFFF
jmp 0x1f92b
movq 0x20(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x1f906
movl $0x0, 0x1044(%rsp)
jmp 0x1f92b
jmp 0x1f908
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
jmp 0x1f865
movl $0x1, 0x1044(%rsp)
movl 0x1044(%rsp), %eax
addq $0x1048, %rsp           # imm = 0x1048
retq
nopw (%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: url_encode
static void url_encode(const char *src, char *dst, size_t dst_len) {
  static const char *dont_escape = "._-$,;~()";
  static const char *hex = "0123456789abcdef";
  const char *end = dst + dst_len - 1;

  for (; *src != '\0' && dst < end; src++, dst++) {
    if (isalnum(*(const unsigned char *) src) ||
        strchr(dont_escape, * (const unsigned char *) src) != NULL) {
      *dst = *src;
    } else if (dst + 2 < end) {
      dst[0] = '%';
      dst[1] = hex[(* (const unsigned char *) src) >> 4];
      dst[2] = hex[(* (const unsigned char *) src) & 0xf];
      dst += 2;
    }
  }

  *dst = '\0';
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x1fe1a
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
setb %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1fe27
jmp 0x1fefb
callq 0x5610
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x1fe60
movq 0xbc1b(%rip), %rdi      # 0x2ba68
movq 0x20(%rsp), %rax
movzbl (%rax), %esi
callq 0x51d0
cmpq $0x0, %rax
je 0x1fe70
movq 0x20(%rsp), %rax
movb (%rax), %cl
movq 0x18(%rsp), %rax
movb %cl, (%rax)
jmp 0x1fed8
movq 0x18(%rsp), %rax
addq $0x2, %rax
cmpq 0x8(%rsp), %rax
jae 0x1fed6
movq 0x18(%rsp), %rax
movb $0x25, (%rax)
movq 0xbbe1(%rip), %rax      # 0x2ba70
movq 0x20(%rsp), %rcx
movzbl (%rcx), %ecx
sarl $0x4, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0xbbc1(%rip), %rax      # 0x2ba70
movq 0x20(%rsp), %rcx
movzbl (%rcx), %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movq 0x18(%rsp), %rax
movb %cl, 0x2(%rax)
movq 0x18(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x18(%rsp)
jmp 0x1fed8
jmp 0x1feda
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1fdf6
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: nilnilnil[P]autocomplete/deps/mongoose/mongoose.c
// Function: send_file_data
static void send_file_data(struct mg_connection *conn, FILE *fp, int64_t len) {
  char buf[BUFSIZ];
  int to_read, num_read, num_written;

  while (len > 0) {
    // Calculate how much to read from the file in the buffer
    to_read = sizeof(buf);
    if ((int64_t) to_read > len)
      to_read = (int) len;

    // Read from file, exit the loop on error
    if ((num_read = fread(buf, 1, (size_t)to_read, fp)) == 0)
      break;

    // Send read bytes to the client, exit the loop on error
    if ((num_written = mg_write(conn, buf, (size_t)num_read)) != num_read)
      break;

    // Both read and were successful, adjust counters
    conn->num_bytes_sent += num_written;
    len -= num_written;
  }
}

// Assembly:
subq $0x2028, %rsp           # imm = 0x2028
movq %rdi, 0x2020(%rsp)
movq %rsi, 0x2018(%rsp)
movq %rdx, 0x2010(%rsp)
cmpq $0x0, 0x2010(%rsp)
jle 0x20893
movl $0x2000, 0xc(%rsp)      # imm = 0x2000
movslq 0xc(%rsp), %rax
cmpq 0x2010(%rsp), %rax
jle 0x20811
movq 0x2010(%rsp), %rax
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rdx
movq 0x2018(%rsp), %rcx
movl $0x1, %esi
callq 0x58e0
movl %eax, 0x8(%rsp)
cmpl $0x0, %eax
jne 0x20838
jmp 0x20893
movq 0x2020(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movslq 0x8(%rsp), %rdx
callq 0x16ed0
movl %eax, 0x4(%rsp)
cmpl 0x8(%rsp), %eax
je 0x2085b
jmp 0x20893
movslq 0x4(%rsp), %rcx
movq 0x2020(%rsp), %rax
addq 0x4b0(%rax), %rcx
movq %rcx, 0x4b0(%rax)
movslq 0x4(%rsp), %rcx
movq 0x2010(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x2010(%rsp)
jmp 0x207df
addq $0x2028, %rsp           # imm = 0x2028
retq
nopl (%rax,%rax)