LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_tun_log_frame
void mg_tun_log_frame(struct mg_tun_frame *frame) {
  LOG(LL_DEBUG, ("Got TUN frame: type=0x%x, flags=0x%x stream_id=0x%x, "
                 "len=%d",
                 frame->type, frame->flags, (unsigned int) frame->stream_id,
                 (int) frame->body.len));
#if MG_ENABLE_HEXDUMP
  {
    char hex[512];
    mg_hexdump(frame->body.p, frame->body.len, hex, sizeof(hex) - 1);
    hex[sizeof(hex) - 1] = '\0';
    LOG(LL_DEBUG, ("body:\n%s", hex));
  }
#else
  LOG(LL_DEBUG, ("body: '%.*s'", (int) frame->body.len, frame->body.p));
#endif
}

// Assembly:
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq 0x336f(%rip), %rsi      # 0x16182
leaq 0x27b4(%rip), %rdx      # 0x155ce
movl $0x3, %edi
callq 0x4447
testl %eax, %eax
je 0x12e44
movzbl (%rbx), %esi
movzbl 0x1(%rbx), %edx
movl 0x4(%rbx), %ecx
movl 0x10(%rbx), %r8d
leaq 0x3356(%rip), %rdi      # 0x16193
xorl %eax, %eax
callq 0x4539
movq 0x8(%rbx), %rdi
movl 0x10(%rbx), %esi
movq %rsp, %rbx
movq %rbx, %rdx
movl $0x1ff, %ecx            # imm = 0x1FF
xorl %r8d, %r8d
callq 0x10c3a
movb $0x0, 0x1ff(%rbx)
leaq 0x3316(%rip), %rsi      # 0x16182
leaq 0x275b(%rip), %rdx      # 0x155ce
movl $0x3, %edi
callq 0x4447
testl %eax, %eax
je 0x12e92
leaq 0x3347(%rip), %rdi      # 0x161cf
movq %rsp, %rsi
xorl %eax, %eax
callq 0x4539
addq $0x200, %rsp            # imm = 0x200
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_tun_reconnect_ev_handler
void mg_tun_reconnect_ev_handler(struct mg_connection *nc, int ev,
                                 void *ev_data MG_UD_ARG(void *user_data)) {
#if !MG_ENABLE_CALLBACK_USERDATA
  void *user_data = nc->user_data;
#else
  (void) nc;
#endif
  struct mg_tun_client *client = (struct mg_tun_client *) user_data;
  (void) ev_data;

  switch (ev) {
    case MG_EV_TIMER:
      if (!(client->listener->flags & MG_F_TUN_DO_NOT_RECONNECT)) {
        mg_tun_do_reconnect(client);
      } else {
        /* Reconnecting is suppressed, we'll check again at the next poll */
        mg_tun_reconnect(client, 0);
      }
      break;
  }
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
cmpl $0x6, %esi
jne 0x12f56
movq 0xa0(%rdi), %rbx
movq 0x28(%rbx), %rax
testb $-0x80, 0xc9(%rax)
jne 0x12f1f
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x50(%rsp)
movq (%rbx), %rdi
movq 0x10(%rbx), %rdx
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movaps 0x30(%rsp), %xmm0
movaps 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x15cc(%rip), %rsi      # 0x144ca
leaq 0x486d(%rip), %rcx      # 0x17772
xorl %r8d, %r8d
callq 0x10a6f
testq %rax, %rax
je 0x12f2b
movq %rax, 0x20(%rbx)
movq %rbx, 0xa0(%rax)
jmp 0x12f56
movq %rbx, %rdi
xorl %esi, %esi
addq $0x60, %rsp
popq %rbx
jmp 0x12f5c
leaq 0x4847(%rip), %rsi      # 0x17779
leaq 0x2695(%rip), %rdx      # 0x155ce
xorl %edi, %edi
callq 0x4447
testl %eax, %eax
je 0x12f56
movq 0x10(%rbx), %rsi
leaq 0x483e(%rip), %rdi      # 0x1778d
xorl %eax, %eax
callq 0x4539
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_tun_reconnect
static void mg_tun_reconnect(struct mg_tun_client *client, int timeout) {
  if (client->reconnect == NULL) {
    client->reconnect = mg_add_sock(client->mgr, INVALID_SOCKET,
                                    MG_CB(mg_tun_reconnect_ev_handler, client));
#if !MG_ENABLE_CALLBACK_USERDATA
    client->reconnect->user_data = client;
#endif
  }
  client->reconnect->ev_timer_time = mg_time() + timeout;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x30(%rdi)
jne 0x12fc0
movq (%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movapd 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
leaq -0x101(%rip), %rsi      # 0x12e9b
callq 0x87a5
movq %rax, %r14
testq %rax, %rax
je 0x12fb5
movq 0x18(%r14), %rdi
movq %r14, %rsi
callq 0x81bd
movq %r14, 0x30(%rbx)
movq %rbx, 0xa0(%r14)
callq 0x4aab
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
addsd %xmm0, %xmm1
movq 0x30(%rbx), %rax
movsd %xmm1, 0x78(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_tun_create_client
static struct mg_tun_client *mg_tun_create_client(struct mg_mgr *mgr,
                                                  const char *dispatcher,
                                                  struct mg_tun_ssl_opts ssl) {
  struct mg_tun_client *client = NULL;
  struct mg_iface *iface = mg_find_iface(mgr, &mg_tun_iface_vtable, NULL);
  if (iface == NULL) {
    LOG(LL_ERROR, ("The tun feature requires the manager to have a tun "
                   "interface enabled"));
    return NULL;
  }

  client = (struct mg_tun_client *) MG_MALLOC(sizeof(*client));
  mg_tun_init_client(client, mgr, iface, dispatcher, ssl);
  iface->data = client;

  /*
   * We need to give application a chance to set MG_F_TUN_DO_NOT_RECONNECT on a
   * listening connection right after mg_tun_bind_opt() returned it, so we
   * should use mg_tun_reconnect() here, instead of mg_tun_do_reconnect()
   */
  mg_tun_reconnect(client, 0);
  return client;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq 0x20(%rdi), %rax
testq %rax, %rax
jle 0x13019
movq %rsi, %r14
movq %rdi, %r15
movq 0x28(%rdi), %rcx
xorl %edx, %edx
leaq 0xa83a(%rip), %rsi      # 0x1d840
movq (%rcx,%rdx,8), %r12
cmpq %rsi, 0x10(%r12)
je 0x13046
incq %rdx
cmpq %rdx, %rax
jne 0x13006
leaq 0x495d(%rip), %rsi      # 0x1797d
leaq 0x25a7(%rip), %rdx      # 0x155ce
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x4447
testl %eax, %eax
je 0x13078
leaq 0x4957(%rip), %rdi      # 0x17992
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4539
jmp 0x13078
movl $0x38, %edi
callq 0x33e0
movq %rax, %rbx
movq %r15, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movq %rax, 0x8(%r12)
movq %rax, %rdi
xorl %esi, %esi
callq 0x12f5c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: cs_base64_emit_code
static void cs_base64_emit_code(struct cs_base64_ctx *ctx, int v) {
  if (v < NUM_UPPERCASES) {
    ctx->b64_putc(v + 'A', ctx->user_data);
  } else if (v < (NUM_LETTERS)) {
    ctx->b64_putc(v - NUM_UPPERCASES + 'a', ctx->user_data);
  } else if (v < (NUM_LETTERS + NUM_DIGITS)) {
    ctx->b64_putc(v - NUM_LETTERS + '0', ctx->user_data);
  } else {
    ctx->b64_putc(v - NUM_LETTERS - NUM_DIGITS == 0 ? '+' : '/',
                  ctx->user_data);
  }
}

// Assembly:
cmpl $0x19, %esi
jg 0x130c2
addb $0x41, %sil
jmp 0x130cb
cmpl $0x33, %esi
ja 0x130db
addb $0x47, %sil
movq (%rdi), %rcx
movq 0x10(%rdi), %rax
movsbl %sil, %edi
movq %rax, %rsi
jmpq *%rcx
movq (%rdi), %rcx
movq 0x10(%rdi), %rax
cmpl $0x3d, %esi
ja 0x130ed
addb $-0x4, %sil
jmp 0x130d2
xorl %edx, %edx
cmpl $0x3e, %esi
setne %dl
leal 0x2b(,%rdx,4), %edi
jmp 0x130d6
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_http_conn_destructor
static void mg_http_conn_destructor(void *proto_data) {
  struct mg_http_proto_data *pd = (struct mg_http_proto_data *) proto_data;
#if MG_ENABLE_FILESYSTEM
  mg_http_free_proto_data_file(&pd->file);
#endif
#if MG_ENABLE_HTTP_CGI
  mg_http_free_proto_data_cgi(&pd->cgi);
#endif
#if MG_ENABLE_HTTP_STREAMING_MULTIPART
  mg_http_free_proto_data_mp_stream(&pd->mp_stream);
#endif
  mg_http_free_proto_data_endpoints(&pd->endpoints);
  mg_http_free_reverse_proxy_data(&pd->reverse_proxy_data);
  MG_FREE(proto_data);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x13122
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x13118
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x1313d
orb $0x8, 0xc9(%rax)
movq $0x0, 0xa0(%rax)
movq $0x0, 0x20(%rbx)
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x1317c
movq (%r14), %r15
movq 0x8(%r14), %rdi
callq 0x3060
movq 0x18(%r14), %rdi
callq 0x3060
movq 0x20(%r14), %rdi
callq 0x3060
movq %r14, %rdi
callq 0x3060
movq %r15, %r14
testq %r15, %r15
jne 0x1314e
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x131cd
movq 0x88(%r14), %rax
testq %rax, %rax
jne 0x131b5
movl $0x1, %edi
movl $0x58, %esi
callq 0x3300
movq %rax, 0x88(%r14)
leaq -0xb0(%rip), %rcx       # 0x130fe
movq %rcx, 0x90(%r14)
movq 0x48(%rax), %rcx
testq %rcx, %rcx
je 0x131cd
orb $0x4, 0xc9(%rcx)
movq $0x0, 0x48(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3060
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_http_is_authorized
static int mg_http_is_authorized(struct http_message *hm, struct mg_str path,
                                 int is_directory, const char *domain,
                                 const char *passwords_file,
                                 int is_global_pass_file) {
  char buf[MG_MAX_PATH];
  const char *p;
  FILE *fp;
  int authorized = 1;

  if (domain != NULL && passwords_file != NULL) {
    if (is_global_pass_file) {
      fp = mg_fopen(passwords_file, "r");
    } else if (is_directory) {
      snprintf(buf, sizeof(buf), "%.*s%c%s", (int) path.len, path.p, DIRSEP,
               passwords_file);
      fp = mg_fopen(buf, "r");
    } else {
      p = strrchr(path.p, DIRSEP);
      if (p == NULL) p = path.p;
      snprintf(buf, sizeof(buf), "%.*s%c%s", (int) (p - path.p), path.p, DIRSEP,
               passwords_file);
      fp = mg_fopen(buf, "r");
    }

    if (fp != NULL) {
      authorized = mg_http_check_digest_auth(hm, domain, fp);
      fclose(fp);
    }
  }

  LOG(LL_DEBUG,
      ("%.*s %s %d %d", (int) path.len, path.p,
       passwords_file ? passwords_file : "", is_global_pass_file, authorized));
  return authorized;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %r9, %r15
movq %r8, %r13
movq %rdx, %r8
movq %rsi, %rbx
movl 0x1060(%rsp), %r14d
testq %r13, %r13
sete %al
testq %r9, %r9
sete %dl
movl $0x1, %r12d
orb %al, %dl
movq %r8, 0x18(%rsp)
jne 0x132c6
testl %r14d, %r14d
movq %rdi, 0x10(%rsp)
je 0x13234
leaq 0x3f0e(%rip), %rsi      # 0x1713d
movq %r15, %rdi
jmp 0x1329e
testl %ecx, %ecx
je 0x13255
movq %r15, (%rsp)
leaq 0x350f(%rip), %rdx      # 0x16752
leaq 0x20(%rsp), %rbp
movl $0x1000, %esi           # imm = 0x1000
movq %rbp, %rdi
movl %r8d, %ecx
jmp 0x13284
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x31f0
testq %rax, %rax
cmovel %ebx, %eax
subl %ebx, %eax
movq %r15, (%rsp)
leaq 0x34dd(%rip), %rdx      # 0x16752
leaq 0x20(%rsp), %rbp
movl $0x1000, %esi           # imm = 0x1000
movq %rbp, %rdi
movl %eax, %ecx
movq %rbx, %r8
movl $0x2f, %r9d
xorl %eax, %eax
callq 0x31e0
leaq 0x3ea2(%rip), %rsi      # 0x1713d
movq %rbp, %rdi
callq 0x3370
movq %rax, %rbp
testq %rax, %rax
je 0x132c6
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xdcae
movl %eax, %r12d
movq %rbp, %rdi
callq 0x3160
leaq 0x348e(%rip), %rsi      # 0x1675b
leaq 0x22fa(%rip), %rdx      # 0x155ce
movl $0x3, %edi
callq 0x4447
testl %eax, %eax
je 0x1330c
testq %r15, %r15
leaq 0x3501(%rip), %rcx      # 0x167ed
cmovneq %r15, %rcx
leaq 0x347a(%rip), %rdi      # 0x16771
movq 0x18(%rsp), %rsi
movq %rbx, %rdx
movl %r14d, %r8d
movl %r12d, %r9d
xorl %eax, %eax
callq 0x4539
movl %r12d, %eax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_is_file_hidden
static int mg_is_file_hidden(const char *path,
                             const struct mg_serve_http_opts *opts,
                             int exclude_specials) {
  const char *p1 = opts->per_directory_auth_file;
  const char *p2 = opts->hidden_file_pattern;

  /* Strip directory path from the file name */
  const char *pdir = strrchr(path, DIRSEP);
  if (pdir != NULL) {
    path = pdir + 1;
  }

  return (exclude_specials && (!strcmp(path, ".") || !strcmp(path, ".."))) ||
         (p1 != NULL &&
          mg_match_prefix(p1, strlen(p1), path) == (int) strlen(p1)) ||
         (p2 != NULL && mg_match_prefix(p2, strlen(p2), path) > 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movl $0x2f, %esi
callq 0x31f0
leaq 0x1(%rax), %r14
testq %rax, %rax
cmoveq %r12, %r14
testl %ebp, %ebp
je 0x1336d
cmpb $0x2e, (%r14)
jne 0x1336d
movl $0x1, %eax
cmpb $0x0, 0x1(%r14)
je 0x133c4
cmpb $0x2e, 0x1(%r14)
jne 0x1336d
cmpb $0x0, 0x2(%r14)
je 0x133c4
testq %r15, %r15
je 0x1339d
movq %r15, %rdi
callq 0x3180
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x44fc
movl %eax, %ebp
movq %r15, %rdi
callq 0x3180
movq %rax, %rcx
movl $0x1, %eax
cmpl %ecx, %ebp
je 0x133c4
testq %rbx, %rbx
je 0x133c2
movq %rbx, %rdi
callq 0x3180
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x44fc
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setg %al
jmp 0x133c4
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_http_serve_file2
static void mg_http_serve_file2(struct mg_connection *nc, const char *path,
                                struct http_message *hm,
                                struct mg_serve_http_opts *opts) {
#if MG_ENABLE_HTTP_SSI
  if (mg_match_prefix(opts->ssi_pattern, strlen(opts->ssi_pattern), path) > 0) {
    mg_handle_ssi_request(nc, hm, path, opts);
    return;
  }
#endif
  mg_http_serve_file(nc, hm, path, mg_get_mime_type(path, "text/plain", opts),
                     mg_mk_str(opts->extra_headers));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rcx), %r13
movq %r13, %rdi
callq 0x3180
movq %r13, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x44fc
testl %eax, %eax
jle 0x13b27
leaq 0x371c(%rip), %rsi      # 0x1716e
leaq 0x1b75(%rip), %rdx      # 0x155ce
movl $0x4, %edi
callq 0x4447
testl %eax, %eax
je 0x13a7b
leaq 0x3716(%rip), %rdi      # 0x17184
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4539
leaq 0x21ec(%rip), %rsi      # 0x15c6e
movq %r14, %rdi
callq 0x3370
testq %rax, %rax
je 0x13b7a
movq %rax, %r13
movq %rax, %rdi
callq 0x33c0
movl %eax, %edi
movl $0x2, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x34f0
movq 0x70(%r12), %rsi
movq %r14, %rdi
callq 0x13ea0
movq %rbp, 0x10(%rsp)
movq %rax, %rbp
movq %rdx, %r15
movq 0x78(%r12), %rdi
callq 0x6b26
movq %rdx, %rcx
movq %rbx, %rdi
movl $0xc8, %esi
movq %rax, %rdx
callq 0xc8f6
leaq 0x369d(%rip), %rsi      # 0x1718a
movq %rbx, %rdi
movl %r15d, %edx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x7ff5
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x13f86
movq %r13, %rdi
callq 0x3160
orb $0x4, 0xc9(%rbx)
jmp 0x13b6b
movq 0x70(%r12), %rsi
movq %r14, %rdi
callq 0x13ea0
movq %rax, %r15
movq %rdx, %r13
movq 0x78(%r12), %rdi
callq 0x6b26
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r13, %r8
callq 0xcbf4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x194, %esi            # imm = 0x194
xorl %edx, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcb3c
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_addenv
static char *mg_addenv(struct mg_cgi_env_block *block, const char *fmt, ...) {
  int n, space;
  char *added = block->buf + block->len;
  va_list ap;

  /* Calculate how much space is left in the buffer */
  space = sizeof(block->buf) - (block->len + 2);
  if (space > 0) {
    /* Copy VARIABLE=VALUE\0 string into the free space */
    va_start(ap, fmt);
    n = vsnprintf(added, (size_t) space, fmt, ap);
    va_end(ap);

    /* Make sure we do not overflow buffer and the envp array */
    if (n > 0 && n + 1 < space &&
        block->nvars < (int) ARRAY_SIZE(block->vars) - 2) {
      /* Append a pointer to the added string into the envp array */
      block->vars[block->nvars++] = added;
      /* Bump up used length counter. Include \0 terminator */
      block->len += n + 1;
    }
  }

  return added;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x13dd4
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movslq 0x2208(%rdi), %rax
leaq (%rdi,%rax), %r14
addq $0x8, %r14
movl $0x1ffe, %ebp           # imm = 0x1FFE
subl %eax, %ebp
testl %ebp, %ebp
jle 0x13e54
movq %rsi, %r10
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
movl %ebp, %esi
movq %r14, %rdi
movq %r10, %rdx
callq 0x3110
testl %eax, %eax
jle 0x13e54
incl %eax
cmpl %ebp, %eax
jae 0x13e54
movslq 0x220c(%rbx), %rcx
cmpq $0x3d, %rcx
jg 0x13e54
leal 0x1(%rcx), %edx
movl %edx, 0x220c(%rbx)
movq %r14, 0x2008(%rbx,%rcx,8)
addl %eax, 0x2208(%rbx)
movq %r14, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_get_mime_type
static struct mg_str mg_get_mime_type(const char *path, const char *dflt,
                                      const struct mg_serve_http_opts *opts) {
  const char *ext, *overrides;
  size_t i, path_len;
  struct mg_str r, k, v;

  path_len = strlen(path);

  overrides = opts->custom_mime_types;
  while ((overrides = mg_next_comma_list_entry(overrides, &k, &v)) != NULL) {
    ext = path + (path_len - k.len);
    if (path_len > k.len && mg_vcasecmp(&k, ext) == 0) {
      return v;
    }
  }

  for (i = 0; mg_static_builtin_mime_types[i].extension != NULL; i++) {
    ext = path + (path_len - mg_static_builtin_mime_types[i].ext_len);
    if (path_len > mg_static_builtin_mime_types[i].ext_len && ext[-1] == '.' &&
        mg_casecmp(ext, mg_static_builtin_mime_types[i].extension) == 0) {
      r.p = mg_static_builtin_mime_types[i].mime_type;
      r.len = strlen(r.p);
      return r;
    }
  }

  r.p = dflt;
  r.len = strlen(r.p);
  return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3180
movq %rax, %r14
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
movq %r15, %rdi
callq 0x76d5
testq %rax, %rax
je 0x13f0a
movq %rax, %r15
leaq 0x10(%rsp), %r12
movq %rsp, %r13
movq %r14, %rsi
subq 0x18(%rsp), %rsi
jbe 0x13ef4
addq %rbx, %rsi
movq %r12, %rdi
callq 0x6b88
testl %eax, %eax
je 0x13f5a
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x76d5
movq %rax, %r15
testq %rax, %rax
jne 0x13edb
leaq 0x3367(%rip), %rsi      # 0x17278
movl $0x18, %r12d
leaq 0x9a22(%rip), %r13      # 0x1d940
leaq 0x323e(%rip), %r15      # 0x17163
movq %r14, %rax
subq -0x10(%r12,%r13), %rax
jbe 0x13f42
leaq (%rbx,%rax), %rdi
cmpb $0x2e, -0x1(%rdi)
jne 0x13f42
callq 0x754b
testl %eax, %eax
je 0x13f65
movq (%r12,%r13), %rsi
addq $0x18, %r12
cmpq $0x498, %r12            # imm = 0x498
jne 0x13f25
movl $0xa, %edx
jmp 0x13f75
movq (%rsp), %r15
movq 0x8(%rsp), %rdx
jmp 0x13f75
movq -0x8(%r12,%r13), %r15
movq %r15, %rdi
callq 0x3180
movq %rax, %rdx
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_send_file_data
static void mg_send_file_data(struct mg_connection *nc, FILE *fp) {
  char buf[BUFSIZ];
  size_t n;
  while ((n = mg_fread(buf, 1, sizeof(buf), fp)) > 0) {
    mg_send(nc, buf, n);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %rbx, %rcx
callq 0x3100
testq %rax, %rax
je 0x144bb
movq %rax, %r12
movq %rsp, %r15
callq 0x4aab
cvttsd2si %xmm0, %rax
movq %rax, 0x70(%r14)
movl 0xc8(%r14), %eax
andl $0x2, %eax
movq 0xc0(%r14), %rcx
movq 0x10(%rcx), %rcx
movslq %r12d, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq *0x48(%rcx,%rax,4)
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r15, %rdi
movq %rbx, %rcx
callq 0x3100
movq %rax, %r12
testq %rax, %rax
jne 0x1446e
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/config.c
// Function: addMotion
bool addMotion(umConfig *config, char *name, char *action) {

  if (config->numMotions > MAX_CAMERAS*2)
    return false;

  config->motions[config->numMotions] = (umotion *)malloc(sizeof(umotion));

  strncpy(config->motions[config->numMotions]->name, name, LABEL_LEN);
  strncpy(config->motions[config->numMotions]->action, action, JSON_MQTT_MSG_SIZE);

  if (strlen(name) >= LABEL_LEN-1) {
    config->motions[config->numMotions]->name[LABEL_LEN-1] = 0;
    fprintf(stderr, "ERROR motion label '%s' is too long for buffer, truncated to '%s'\n", name, config->motions[config->numMotions]->name);
  }

  if (strlen(action) >= JSON_MQTT_MSG_SIZE-1) {
    config->motions[config->numMotions]->action[JSON_MQTT_MSG_SIZE-1] = 0;
    fprintf(stderr, "ERROR motion action '%s' is too long for buffer, truncated to '%s'\n", action, config->motions[config->numMotions]->action);
  }
  config->numMotions++;

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x1d8(%rdi), %r13
cmpq $0x28, %r13
jg 0x1486b
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x8c, %edi
callq 0x33e0
movq %rax, %r12
movq %rax, 0x98(%rbx,%r13,8)
movl $0x28, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x30b0
leaq 0x28(%r12), %rdi
movl $0x64, %edx
movq %r14, %rsi
callq 0x30b0
movq %r15, %rdi
callq 0x3180
movl %r13d, %ebp
cmpq $0x27, %rax
jae 0x14881
movq %r14, %rdi
callq 0x3180
cmpq $0x63, %rax
jae 0x148ad
incl %ebp
movl %ebp, 0x1d8(%rbx)
cmpl $0x29, %r13d
setl %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, 0x27(%r12)
movq 0x9762(%rip), %rax      # 0x1dff0
movq (%rax), %rdi
leaq 0x3145(%rip), %rsi      # 0x179dd
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3340
movl 0x1d8(%rbx), %ebp
jmp 0x14855
movslq %ebp, %rax
movq 0x98(%rbx,%rax,8), %rax
movb $0x0, 0x8b(%rax)
movq 0x972a(%rip), %rax      # 0x1dff0
movq (%rax), %rdi
movslq 0x1d8(%rbx), %rax
movq 0x98(%rbx,%rax,8), %rcx
addq $0x28, %rcx
leaq 0x313d(%rip), %rsi      # 0x17a20
movq %r14, %rdx
xorl %eax, %eax
callq 0x3340
movl 0x1d8(%rbx), %ebp
jmp 0x14863
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/config.c
// Function: cleanwhitespace
char *cleanwhitespace(char *str)
{
  char *end;
  // Trim leading space
  while(isspace(*str)) str++;

  if(*str == 0)  // All spaces?
    return str;

  // Trim trailing space
  end = str + strlen(str) - 1;
  while(end > str && isspace(*end)) end--;

  // Write new null terminator
  *(end+1) = 0;

  return str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3660
movq (%rax), %r14
decq %rbx
movsbq 0x1(%rbx), %rax
incq %rbx
testb $0x20, 0x1(%r14,%rax,2)
jne 0x1490a
testb %al, %al
je 0x14949
movq %rbx, %rdi
callq 0x3180
leaq (%rbx,%rax), %rcx
decq %rcx
movq %rcx, %rax
cmpq %rbx, %rcx
jbe 0x14945
movsbq (%rax), %rdx
leaq -0x1(%rax), %rcx
testb $0x20, 0x1(%r14,%rdx,2)
jne 0x1492d
movb $0x0, 0x1(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sfeakes[P]unifi-motion/config.c
// Function: free_config
void free_config(umConfig *config)
{
  int i;

  for (i=0; i<config->numMotions; i++){
    free(config->motions[i]);
  }

  free(config->mqtt_address);
  free(config->mqtt_user);
  free(config->mqtt_passwd);
  free(config->mqtt_pub_topic);
  free(config->log_file_to_monitor);
  free(config->regexString);
  free(config->watchDir);
  free(config->watchFile);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x1d8(%rdi)
jle 0x14c30
xorl %r14d, %r14d
movq 0x98(%rbx,%r14,8), %rdi
callq 0x3060
incq %r14
movslq 0x1d8(%rbx), %rax
cmpq %rax, %r14
jl 0x14c14
movq (%rbx), %rdi
callq 0x3060
movq 0x8(%rbx), %rdi
callq 0x3060
movq 0x10(%rbx), %rdi
callq 0x3060
movq 0x18(%rbx), %rdi
callq 0x3060
movq 0x20(%rbx), %rdi
callq 0x3060
movq 0x28(%rbx), %rdi
callq 0x3060
movq 0x48(%rbx), %rdi
callq 0x3060
movq 0x50(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3060
// File: /workspace/github_c_makefile_star2_O3/erik[P]gamut/rotate.c
// Function: main
int main(int argc, char** argv)
{
    if (argc != 2) {
        fprintf(stderr, "usage: %s ANGLE\n", argv[0]);
        return 1;
    }

    double angle = atof(argv[1]);

    return rotate(angle);
}

// Assembly:
pushq %rax
cmpl $0x2, %edi
jne 0x1afd
movq 0x8(%rsi), %rdi
callq 0x1050
popq %rax
jmp 0x13e2
movq %rsi, %rdi
callq 0x1194
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/system.c
// Function: ficlSystemAddPrimitiveParseStep
void ficlSystemAddPrimitiveParseStep(ficlSystem *system, char *name, ficlParseStep pStep)
{
    ficlDictionary *dictionary = system->dictionary;
    ficlWord *word = ficlDictionaryAppendPrimitive(dictionary, name, ficlPrimitiveParseStepParen, FICL_WORD_DEFAULT);
    ficlDictionaryAppendCell(dictionary, FICL_LVALUE_TO_CELL(pStep));
    ficlSystemAddParseStep(system, word);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
movq 0x38(%rdi), %r12
leaq 0x376c(%rip), %rdx      # 0x7034
xorl %r13d, %r13d
movq %r12, %rdi
xorl %ecx, %ecx
callq 0xc38e
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
callq 0xbf11
cmpq $0x0, 0x60(%rbx,%r13,8)
je 0x38f6
incq %r13
cmpq $0x8, %r13
jne 0x38e3
jmp 0x38fb
movq %r14, 0x60(%rbx,%r13,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/float.c
// Function: ficlPrimitiveFLiteralImmediate
static void ficlPrimitiveFLiteralImmediate(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlCell cell;


    FICL_STACK_CHECK(vm->floatStack, 1, 0);


	cell = ficlStackPop(vm->floatStack);
	if (cell.f == 1.0f)
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionF1);
	}
	else if (cell.f == 0.0f)
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionF0);
	}
	else if (cell.f == -1.0f)
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionFNeg1);
	}
	else
	{
		ficlDictionaryAppendUnsigned(dictionary, ficlInstructionFLiteralParen);
		ficlDictionaryAppendCell(dictionary, cell);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x68f3
movq %rax, %rbx
movq 0x70(%r14), %rdi
callq 0x428d
movq %rax, %r14
movd %r14d, %xmm0
ucomiss 0xa490(%rip), %xmm0     # 0xe1e8
jne 0x3d63
jp 0x3d63
movl $0x23, %esi
jmp 0x3d84
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3d74
jp 0x3d74
movl $0x22, %esi
jmp 0x3d84
ucomiss 0xa471(%rip), %xmm0     # 0xe1ec
jne 0x3d93
jp 0x3d93
movl $0x24, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbf2c
movl $0x88, %esi
movq %rbx, %rdi
callq 0xbf2c
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbf11
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/float.c
// Function: ficlPrimitiveFConstant
static void ficlPrimitiveFConstant(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);

    FICL_STACK_CHECK(vm->floatStack, 1, 0);

    ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)ficlInstructionFConstantParen, FICL_WORD_DEFAULT);
    ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->floatStack));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x68f3
movq %rax, %r14
movq %rbx, %rdi
callq 0x69c5
movl $0x89, %ecx
movq %r14, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0xbfcc
movq 0x70(%rbx), %rdi
callq 0x428d
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbf11
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/float.c
// Function: ficlPrimitiveF2Constant
static void ficlPrimitiveF2Constant(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);

    FICL_STACK_CHECK(vm->floatStack, 2, 0);

    ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)ficlInstructionF2ConstantParen, FICL_WORD_DEFAULT);
    ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->floatStack));
    ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->floatStack));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x68f3
movq %rax, %rbx
movq %r14, %rdi
callq 0x69c5
movl $0x8a, %ecx
movq %rbx, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0xbfcc
movq 0x70(%r14), %rdi
callq 0x428d
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbf11
movq 0x70(%r14), %rdi
callq 0x428d
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbf11
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/prefix.c
// Function: ficlVmParsePrefix
int ficlVmParsePrefix(ficlVm *vm, ficlString s)
{
    int i;
    ficlHash *hash;
    ficlWord *word = ficlSystemLookup(vm->callback.system, list_name);

    /* 
    ** Make sure we found the prefix dictionary - otherwise silently fail
    ** If forth-wordlist is not in the search order, we won't find the prefixes.
    */
    if (!word)
        return 0; /* false */

    hash = (ficlHash *)(word->param[0].p);
    /*
    ** Walk the list looking for a match with the beginning of the incoming token
    */
    for (i = 0; i < (int)hash->size; i++)
    {
        word = hash->table[i];
        while (word != NULL)
        {
            int n;
            n = word->length;
            /*
            ** If we find a match, adjust the TIB to give back the non-prefix characters
            ** and execute the prefix word.
            */
            if (!ficlStrincmp(FICL_STRING_GET_POINTER(s), word->name, (ficlUnsigned)n))
            {
                /* (sadler) fixed off-by-one error when the token has no trailing space in the TIB */
                ficlVmSetTibIndex(vm, s.text + n - vm->tib.text);
                ficlVmExecuteWord(vm, word);

                return 1; /* true */
            }
            word = word->link;
        }
    }

    return 0; /* false */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x11184(%rip), %rsi     # 0x151c0
callq 0x39e6
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x40bb
movq 0x28(%rcx), %r13
cmpl $0x0, 0x10(%r13)
jle 0x40bb
leaq 0x18(%r13), %rcx
xorl %ebp, %ebp
movq %rcx, (%rsp)
leaq (%rcx,%rbp,8), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x4086
movzbl 0xb(%r15), %r12d
movq 0x10(%r15), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0xb60f
testl %eax, %eax
jne 0x4064
jmp 0x409a
incq %rbp
movslq 0x10(%r13), %rcx
xorl %eax, %eax
cmpq %rcx, %rbp
movq (%rsp), %rcx
jl 0x4060
jmp 0x40bb
addq %r12, %r14
subq 0x90(%rbx), %r14
movq %r14, 0x80(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5351
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/prefix.c
// Function: ficlPrimitiveTempBase
static void ficlPrimitiveTempBase(ficlVm *vm)
{
    int oldbase = vm->base;
    ficlString number = ficlVmGetWord0(vm);
    int base = ficlStackPopInteger(vm->dataStack);

    vm->base = base;
    if (!ficlVmParseNumber(vm, number)) 
        ficlVmThrowError(vm, "%.*s not recognized", FICL_STRING_GET_LENGTH(number), FICL_STRING_GET_POINTER(number));

    vm->base = oldbase;
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %r12
callq 0x69e8
movq %rax, %r14
movq %rdx, %r15
movq 0x60(%rbx), %rdi
callq 0x42bd
cltq
movq %rax, 0x58(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6e5d
testl %eax, %eax
jne 0x415d
leaq 0xa164(%rip), %rsi      # 0xe2b1
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x67d2
movslq %r12d, %rax
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/softcore.c
// Function: ficlSystemCompileSoftCore
void ficlSystemCompileSoftCore(ficlSystem *system)
{
    ficlVm *vm = system->vmList;
    int returnValue;
    ficlCell oldSourceID = vm->sourceId;
    ficlString s;
#if FICL_WANT_LZ_SOFTCORE
    char *ficlSoftcoreUncompressed = NULL;
    size_t gotUncompressedSize = 0;
    returnValue = ficlLzUncompress(ficlSoftcoreCompressed, (unsigned char **)&ficlSoftcoreUncompressed, &gotUncompressedSize);
    FICL_VM_ASSERT(vm, returnValue == 0);
    FICL_VM_ASSERT(vm, gotUncompressedSize == ficlSoftcoreUncompressedSize);
#endif /* FICL_WANT_LZ_SOFTCORE */
    vm->sourceId.i = -1;
    FICL_STRING_SET_POINTER(s, (char *)(ficlSoftcoreUncompressed));
    FICL_STRING_SET_LENGTH(s, ficlSoftcoreUncompressedSize);
    returnValue = ficlVmExecuteString(vm, s);
    vm->sourceId = oldSourceID;
#if FICL_WANT_LZ_SOFTCORE
    free(ficlSoftcoreUncompressed);
#endif /* FICL_WANT_LZ_SOFTCORE */
    FICL_VM_ASSERT(vm, returnValue != FICL_VM_STATUS_ERROR_EXIT);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x30(%rdi), %rbx
movq 0x78(%rbx), %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x11038(%rip), %rdi     # 0x151d0
movq %r14, %rsi
callq 0xb13f
movq $-0x1, 0x78(%rbx)
movq (%r14), %rdx
movl $0x6457, %esi           # imm = 0x6457
movq %rbx, %rdi
callq 0x6c0b
movq %r15, 0x78(%rbx)
movq (%r14), %rdi
callq 0x3030
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/stack.c
// Function: ficlStackCreate
ficlStack *ficlStackCreate(ficlVm *vm, char *name, unsigned size)
{
    size_t totalSize = sizeof (ficlStack) + (size * sizeof (ficlCell));
    ficlStack *stack = ficlMalloc(totalSize);

    FICL_VM_ASSERT(vm, size != 0);
    FICL_VM_ASSERT(vm, stack != NULL);

    stack->size = size;
    stack->frame = NULL;

	stack->vm = vm;
	stack->name = name;

	ficlStackReset(stack);
    return stack;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
leaq 0x30(,%r15,8), %rdi
callq 0xb2eb
movq %r15, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x18(%rax)
leaq 0x20(%rax), %rcx
movq %rbx, 0x20(%rax)
movq %rcx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/stack.c
// Function: ficlStackWalk
void ficlStackWalk(ficlStack *stack, ficlStackWalkFunction callback, void *context, ficlInteger bottomToTop)
{
    int i;
    int depth;
	ficlCell *cell;
    FICL_STACK_CHECK(stack, 0, 0);

	depth = ficlStackDepth(stack);
	cell = bottomToTop ? stack->base : stack->top;
    for (i = 0; i < depth; i++)
    {
        if (callback(context, cell) == FICL_FALSE)
			break;
        cell += bottomToTop ? 1 : -1;
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x10(%rdi), %rax
addq $0x28, %r15
movq %rax, %r12
subq %r15, %r12
shrq $0x3, %r12
cmpl $0x7ffffffe, %r12d      # imm = 0x7FFFFFFE
ja 0x444f
movq %rdx, %rbx
movq %rsi, %r14
incl %r12d
xorl %r13d, %r13d
testq %rcx, %rcx
cmoveq %rax, %r15
setne %r13b
shll $0x4, %r13d
addq $-0x8, %r13
movl $0x1, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq *%r14
testq %rax, %rax
je 0x444f
addq %r13, %r15
leal 0x1(%rbp), %eax
cmpl %r12d, %ebp
movl %eax, %ebp
jl 0x4434
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveHashSummary
void ficlPrimitiveHashSummary(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlHash *pFHash;
    ficlWord **hash;
    unsigned size;
    ficlWord *word;
    unsigned i;
    int nMax = 0;
    int nWords = 0;
    int nFilled;
    double avg = 0.0;
    double best;
    int nAvg, nRem, nDepth;

    FICL_VM_DICTIONARY_CHECK(vm, dictionary, 0);

    pFHash = dictionary->wordlists[dictionary->wordlistCount - 1];
    hash  = pFHash->table;
    size   = pFHash->size;
    nFilled = size;

    for (i = 0; i < size; i++)
    {
        int n = 0;
        word = hash[i];

        while (word)
        {
            ++n;
            ++nWords;
            word = word->link;
        }

        avg += (double)(n * (n+1)) / 2.0;

        if (n > nMax)
            nMax = n;
        if (n == 0)
            --nFilled;
    }

    /* Calc actual avg search depth for this hash */
    avg = avg / nWords;

    /* Calc best possible performance with this size hash */
    nAvg = nWords / size;
    nRem = nWords % size;
    nDepth = size * (nAvg * (nAvg+1))/2 + (nAvg+1)*nRem;
    best = (double)nDepth/nWords;

    sprintf(vm->pad, 
        "%d bins, %2.0f%% filled, Depth: Max=%d, Avg=%2.1f, Best=%2.1f, Score: %2.0f%%\n", 
        size,
        (double)nFilled * 100.0 / size, nMax,
        avg, 
        best,
        100.0 * best / avg);

    ficlVmTextOut(vm, vm->pad);

    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x68f3
movslq 0xa8(%rax), %rcx
movq 0x20(%rax,%rcx,8), %rdx
movl 0x10(%rdx), %r8d
testq %r8, %r8
je 0x44f1
xorpd %xmm1, %xmm1
xorl %esi, %esi
movsd 0x9e38(%rip), %xmm0     # 0xe2c8
xorl %ecx, %ecx
xorl %eax, %eax
movl %r8d, %edi
movq 0x18(%rdx,%rsi,8), %r10
xorl %r9d, %r9d
testq %r10, %r10
je 0x44b2
incl %r9d
movq (%r10), %r10
testq %r10, %r10
jne 0x44a4
addl %r9d, %eax
leal 0x1(%r9), %r10d
imull %r9d, %r10d
xorps %xmm2, %xmm2
cvtsi2sd %r10d, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm2, %xmm1
cmpl %ecx, %r9d
cmovgl %r9d, %ecx
cmpl $0x1, %r9d
sbbl $0x0, %edi
incq %rsi
cmpq %r8, %rsi
jne 0x4497
xorps %xmm0, %xmm0
cvtsi2sd %edi, %xmm0
mulsd 0x9de1(%rip), %xmm0     # 0xe2d0
jmp 0x44fd
xorl %eax, %eax
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
cvtsi2sd %eax, %xmm3
xorl %edx, %edx
divl %r8d
leal 0x1(%rax), %esi
imull %r8d, %eax
imull %esi, %eax
shrl %eax
imull %esi, %edx
addl %eax, %edx
xorps %xmm2, %xmm2
cvtsi2sd %edx, %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
divpd %xmm3, %xmm2
leaq 0x118(%rbx), %r14
movl %r8d, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd 0x9d88(%rip), %xmm3     # 0xe2d0
mulsd %xmm2, %xmm3
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
divsd %xmm1, %xmm3
leaq 0x9dbd(%rip), %rsi      # 0xe31c
movq %r14, %rdi
movl %r8d, %edx
movb $0x4, %al
callq 0x32f0
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b89
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/tools.c
// Function: ficlStackDisplay
void ficlStackDisplay(ficlStack *stack, ficlStackWalkFunction callback, void *context)
{
	ficlVm *vm = stack->vm;
	char buffer[128];
	struct stackContext myContext;

    FICL_STACK_CHECK(stack, 0, 0);

	sprintf(buffer, "[%s stack has %d entries, top at 0x%08x]\n", stack->name, ficlStackDepth(stack), stack->top);
	ficlVmTextOut(vm, buffer);

    if (callback == NULL)
    {
        myContext.vm = vm;
	    myContext.count = 0;
		context = &myContext;
		callback = ficlStackDisplayCallback;
    }
	ficlStackWalk(stack, callback, context, FICL_FALSE);

	sprintf(buffer, "[%s stack base at 0x%08x]\n", stack->name, stack->base);
	ficlVmTextOut(vm, buffer);

    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq 0x20(%rdi), %r13
callq 0x4220
movq 0x10(%r14), %r8
leaq 0x9dbb(%rip), %rsi      # 0xe36b
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x32f0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x6b89
testq %r12, %r12
jne 0x45eb
leaq 0x8(%rsp), %r15
movq %rbx, (%r15)
movl $0x0, 0x10(%r15)
leaq 0x4e(%rip), %r12        # 0x4639
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x43e7
movq 0x20(%r14), %rdx
addq $0x28, %r14
leaq 0x9d8b(%rip), %rsi      # 0xe395
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x32f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6b89
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/tools.c
// Function: ficlVmDisplayDataStackSimple
void ficlVmDisplayDataStackSimple(ficlVm *vm)
{
    ficlStack *stack = vm->dataStack;
    char buffer[32];
    struct stackContext context;

    FICL_STACK_CHECK(stack, 0, 0);

    sprintf(buffer, "[%d] ", ficlStackDepth(stack));
    ficlVmTextOut(vm, buffer);

    context.vm = vm;
    context.count = 0;
    ficlStackWalk(stack, ficlStackDisplaySimpleCallback, &context, FICL_TRUE);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq %r14, %rdi
callq 0x4220
leaq 0x9d01(%rip), %rsi      # 0xe3b0
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x32f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6b89
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
movl $0x0, 0x10(%rdx)
leaq 0x19(%rip), %rsi        # 0x46fa
movq %r14, %rdi
movq $-0x1, %rcx
callq 0x43e7
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/tools.c
// Function: ficlStackDisplaySimpleCallback
static ficlInteger ficlStackDisplaySimpleCallback(void *c, ficlCell *cell)
{
    struct stackContext *context = (struct stackContext *)c;
    char buffer[32];
    sprintf(buffer, "%s%d", context->count ? " " : "", cell->i);
    context->count++;
    ficlVmTextOut(context->vm, buffer);
	return FICL_TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
leaq 0x9c5b(%rip), %rax      # 0xe36a
leaq 0xaf5d(%rip), %rdx      # 0xf673
cmoveq %rax, %rdx
movq (%rsi), %rcx
leaq 0x9d50(%rip), %rsi      # 0xe474
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x32f0
incl 0x10(%rbx)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x6b89
movq $-0x1, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/tools.c
// Function: ficlVmDisplayReturnStack
void ficlVmDisplayReturnStack(ficlVm *vm)
{
    struct stackContext context;
	context.vm = vm;
	context.count = 0;
	context.dictionary = ficlVmGetDictionary(vm);
    ficlStackDisplay(vm->returnStack, ficlReturnStackDisplayCallback, &context);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, (%r14)
movl $0x0, 0x10(%r14)
callq 0x68f3
movq %rax, 0x8(%r14)
movq 0x68(%rbx), %rdi
leaq 0x10(%rip), %rsi        # 0x478a
movq %r14, %rdx
callq 0x457e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/tools.c
// Function: ficlReturnStackDisplayCallback
static ficlInteger ficlReturnStackDisplayCallback(void *c, ficlCell *cell)
{
    struct stackContext *context = (struct stackContext *)c;
    char buffer[128];

    sprintf(buffer, "[0x%08x %3d] %12d (0x%08x)", cell, context->count++, cell->i, cell->i);

    /*
    ** Attempt to find the word that contains the return
    ** stack address (as if it is part of a colon definition).
    ** If this works, also print the name of the word.
    */
    if (ficlDictionaryIncludes(context->dictionary, cell->p))
    {
        ficlWord *word = ficlDictionaryFindEnclosingWord(context->dictionary, cell->p);
        if (word)
        {
            int offset = (ficlCell *)cell->p - &word->param[0];
            sprintf(buffer + strlen(buffer), ", %s + %d ", word->name, offset);
        }
    }
	strcat(buffer, "\n");
    ficlVmTextOut(context->vm, buffer);
	return FICL_TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x10(%rdi)
movq (%rsi), %r8
leaq 0x9cca(%rip), %rsi      # 0xe479
movq %rsp, %rdi
movq %r14, %rdx
movq %r8, %r9
xorl %eax, %eax
callq 0x32f0
movq 0x8(%rbx), %rdi
movq (%r14), %rsi
callq 0xc6a3
testl %eax, %eax
je 0x4812
movq 0x8(%rbx), %rdi
movq (%r14), %rsi
callq 0xc6c4
testq %rax, %rax
je 0x4812
movq %rax, %r15
movq (%r14), %r14
subq %rax, %r14
addq $-0x28, %r14
shrq $0x3, %r14
movq %rsp, %rdi
callq 0x30e0
leaq (%rsp,%rax), %rdi
movq 0x10(%r15), %rdx
leaq 0x9c8c(%rip), %rsi      # 0xe494
movl %r14d, %ecx
xorl %eax, %eax
callq 0x32f0
movq %rsp, %r14
movq %r14, %rdi
callq 0x30e0
movw $0xa, (%rsp,%rax)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x6b89
movq $-0x1, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveParseStepList
void ficlPrimitiveParseStepList(ficlVm *vm)
{
    int i;
    ficlSystem *system = vm->callback.system;
    FICL_VM_ASSERT(vm, system);

    ficlVmTextOut(vm, "Parse steps:\n");
    ficlVmTextOut(vm, "lookup\n");

    for (i = 0; i < FICL_MAX_PARSE_STEPS; i++)
    {
        if (system->parseList[i] != NULL)
        {
            ficlVmTextOut(vm, system->parseList[i]->name);
            ficlVmTextOut(vm, "\n");
        }
        else break;
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r15
leaq 0x9b5e(%rip), %rsi      # 0xe3b6
callq 0x6b89
leaq 0x9b60(%rip), %rsi      # 0xe3c4
movq %rbx, %rdi
callq 0x6b89
xorl %r12d, %r12d
leaq 0x9af3(%rip), %r14      # 0xe369
movq 0x60(%r15,%r12,8), %rax
testq %rax, %rax
je 0x48a0
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x6b89
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6b89
incq %r12
cmpq $0x8, %r12
jne 0x4876
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/tools.c
// Function: ficlPrimitiveForget
static void ficlPrimitiveForget(ficlVm *vm)
{
    void *where;
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlHash *hash = dictionary->compilationWordlist;

    ficlPrimitiveTick(vm);
    where = ((ficlWord *)ficlStackPopPointer(vm->dataStack))->name;
    ficlHashForget(hash, where);
    dictionary->here = FICL_POINTER_TO_CELL(where);

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x68f3
movq %rax, %r14
movq 0x20(%rax), %r15
movq %rbx, %rdi
callq 0x70d7
movq 0x60(%rbx), %rdi
callq 0x429d
movq 0x10(%rax), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb740
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq