LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x1b44b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq -0x8(%rbp), %rcx
movslq 0x2208(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x2208(%rax), %eax
addl $0x2, %eax
movslq %eax, %rcx
movl $0x2000, %eax           # imm = 0x2000
subq %rcx, %rax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x1b54c
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x3110
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rax
cmpl $0x0, -0x14(%rbp)
jle 0x1b54a
movl -0x14(%rbp), %eax
addl $0x1, %eax
cmpl -0x18(%rbp), %eax
jge 0x1b54a
movq -0x8(%rbp), %rax
cmpl $0x3e, 0x220c(%rax)
jge 0x1b54a
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movl 0x220c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x220c(%rsi)
movslq %ecx, %rcx
movq %rdx, 0x2008(%rax,%rcx,8)
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
addl 0x2208(%rax), %ecx
movl %ecx, 0x2208(%rax)
jmp 0x1b54c
movq -0x20(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_scan_directory
static void mg_scan_directory(struct mg_connection *nc, const char *dir,
                              const struct mg_serve_http_opts *opts,
                              void (*func)(struct mg_connection *, const char *,
                                           cs_stat_t *)) {
  char path[MG_MAX_PATH];
  cs_stat_t st;
  struct dirent *dp;
  DIR *dirp;

  LOG(LL_DEBUG, ("%p [%s]", nc, dir));
  if ((dirp = (opendir(dir))) != NULL) {
    while ((dp = readdir(dirp)) != NULL) {
      /* Do not show current dir and hidden files */
      if (mg_is_file_hidden((const char *) dp->d_name, opts, 1)) {
        continue;
      }
      snprintf(path, sizeof(path), "%s/%s", dir, dp->d_name);
      if (mg_stat(path, &st) == 0) {
        func(nc, (const char *) dp->d_name, &st);
      }
    }
    closedir(dirp);
  } else {
    LOG(LL_DEBUG, ("%p opendir(%s) -> %d", nc, dir, mg_get_errno()));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10d0, %rsp           # imm = 0x10D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x3, %edi
leaq 0x5a29(%rip), %rsi      # 0x21000
leaq 0x3f6c(%rip), %rdx      # 0x1f54a
callq 0x4650
cmpl $0x0, %eax
je 0x1b5fe
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x51c3(%rip), %rdi      # 0x207ba
movb $0x0, %al
callq 0x47a0
jmp 0x1b600
movq -0x10(%rbp), %rdi
callq 0x3170
movq %rax, -0x10c0(%rbp)
cmpq $0x0, %rax
je 0x1b6c9
jmp 0x1b61c
movq -0x10c0(%rbp), %rdi
callq 0x3550
movq %rax, -0x10b8(%rbp)
cmpq $0x0, %rax
je 0x1b6bb
movq -0x10b8(%rbp), %rdi
addq $0x13, %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x1a530
cmpl $0x0, %eax
je 0x1b659
jmp 0x1b61c
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x10b8(%rbp), %r8
addq $0x13, %r8
movl $0x1000, %esi           # imm = 0x1000
leaq 0x519e(%rip), %rdx      # 0x20819
movb $0x0, %al
callq 0x31f0
leaq -0x1020(%rbp), %rdi
leaq -0x10b0(%rbp), %rsi
callq 0x12330
cmpl $0x0, %eax
jne 0x1b6b6
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10b8(%rbp), %rsi
addq $0x13, %rsi
leaq -0x10b0(%rbp), %rdx
callq *%rax
jmp 0x1b61c
movq -0x10c0(%rbp), %rdi
callq 0x32b0
jmp 0x1b725
jmp 0x1b6cb
movl $0x3, %edi
leaq 0x5929(%rip), %rsi      # 0x21000
leaq 0x3e6c(%rip), %rdx      # 0x1f54a
callq 0x4650
cmpl $0x0, %eax
je 0x1b721
movq -0x8(%rbp), %rax
movq %rax, -0x10d0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10c8(%rbp)
callq 0xd6a0
movq -0x10d0(%rbp), %rsi
movq -0x10c8(%rbp), %rdx
movl %eax, %ecx
leaq 0x58f8(%rip), %rdi      # 0x21012
movb $0x0, %al
callq 0x47a0
jmp 0x1b723
jmp 0x1b725
addq $0x10d0, %rsp           # imm = 0x10D0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_escape
static void mg_escape(const char *src, char *dst, size_t dst_len) {
  size_t n = 0;
  while (*src != '\0' && n + 5 < dst_len) {
    unsigned char ch = *(unsigned char *) src++;
    if (ch == '<') {
      n += snprintf(dst + n, dst_len - n, "%s", "&lt;");
    } else {
      dst[n++] = ch;
    }
  }
  dst[n] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
je 0x1ba5f
movq -0x20(%rbp), %rax
addq $0x5, %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x1ba68
jmp 0x1bad4
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x3c, %eax
jne 0x1bab6
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq -0x20(%rbp), %rsi
leaq 0x44f6(%rip), %rdx      # 0x1ff92
leaq 0x4236(%rip), %rcx      # 0x1fcd9
movb $0x0, %al
callq 0x31f0
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1bacf
movb -0x21(%rbp), %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x1ba3c
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_get_month_index
static int mg_get_month_index(const char *s) {
  static const char *month_names[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
                                      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  size_t i;

  for (i = 0; i < ARRAY_SIZE(month_names); i++)
    if (!strcmp(s, month_names[i])) return (int) i;

  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0xc, -0x18(%rbp)
jae 0x1bce1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0xb736(%rip), %rax      # 0x273f0
movq (%rax,%rcx,8), %rsi
callq 0x3340
cmpl $0x0, %eax
jne 0x1bcd1
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x1bce8
jmp 0x1bcd3
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1bca4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_handle_ssi_request
MG_INTERNAL void mg_handle_ssi_request(struct mg_connection *nc,
                                       struct http_message *hm,
                                       const char *path,
                                       const struct mg_serve_http_opts *opts) {
  FILE *fp;
  struct mg_str mime_type;
  DBG(("%p %s", nc, path));

  if ((fp = mg_fopen(path, "rb")) == NULL) {
    mg_http_send_error(nc, 404, NULL);
  } else {
    mg_set_close_on_exec((sock_t) fileno(fp));

    mime_type = mg_get_mime_type(path, "text/plain", opts);
    mg_send_response_line(nc, 200, opts->extra_headers);
    mg_printf(nc,
              "Content-Type: %.*s\r\n"
              "Connection: close\r\n\r\n",
              (int) mime_type.len, mime_type.p);
    mg_send_ssi_file(nc, hm, path, fp, 0, opts);
    fclose(fp);
    nc->flags |= MG_F_SEND_AND_CLOSE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x4, %edi
leaq 0x53d4(%rip), %rsi      # 0x21138
leaq 0x37df(%rip), %rdx      # 0x1f54a
callq 0x4650
cmpl $0x0, %eax
je 0x1bd8b
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x53ca(%rip), %rdi      # 0x2114e
movb $0x0, %al
callq 0x47a0
jmp 0x1bd8d
movq -0x18(%rbp), %rdi
leaq 0x3e55(%rip), %rsi      # 0x1fbed
callq 0x12360
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1bdbe
movq -0x8(%rbp), %rdi
movl $0x194, %esi            # imm = 0x194
xorl %eax, %eax
movl %eax, %edx
callq 0x11e30
jmp 0x1be6a
movq -0x28(%rbp), %rdi
callq 0x33f0
movl %eax, %edi
callq 0xe240
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x5350(%rip), %rsi      # 0x2112d
callq 0x1be70
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rdx
movl $0xc8, %esi
callq 0x11c20
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %edx
movq -0x38(%rbp), %rcx
leaq 0x532f(%rip), %rsi      # 0x21154
movb $0x0, %al
callq 0xb2f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r9
xorl %r8d, %r8d
callq 0x1c010
movq -0x28(%rbp), %rdi
callq 0x3160
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rcx
orq $0x400, %rcx            # imm = 0x400
movq %rcx, 0xc8(%rax)
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x2010(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x169d0
movq %rax, -0x2018(%rbp)
cmpq $0x0, %rax
jbe 0x1c775
movq -0x8(%rbp), %rdi
leaq -0x2010(%rbp), %rsi
movq -0x2018(%rbp), %rax
movl %eax, %edx
callq 0xb260
jmp 0x1c733
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_handle_incoming_websocket_frame
static void mg_handle_incoming_websocket_frame(struct mg_connection *nc,
                                               struct websocket_message *wsm) {
  if (wsm->flags & 0x8) {
    mg_call(nc, nc->handler, nc->user_data, MG_EV_WEBSOCKET_CONTROL_FRAME, wsm);
  } else {
    mg_call(nc, nc->handler, nc->user_data, MG_EV_WEBSOCKET_FRAME, wsm);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x1ccca
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdx
movq -0x10(%rbp), %r8
movl $0x72, %ecx
callq 0xa8e0
jmp 0x1ccf2
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdx
movq -0x10(%rbp), %r8
movl $0x71, %ecx
callq 0xa8e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_tun_close_all
static void mg_tun_close_all(struct mg_tun_client *client) {
  struct mg_connection *nc;
  for (nc = client->mgr->active_connections; nc != NULL; nc = nc->next) {
    if (nc->iface == client->iface && !(nc->flags & MG_F_LISTENING)) {
      LOG(LL_DEBUG, ("Closing tunneled connection %p", nc));
      nc->flags |= MG_F_CLOSE_IMMEDIATELY;
      /* mg_close_conn(nc); */
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1d71d
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1d70b
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x1d70b
jmp 0x1d6c1
movl $0x3, %edi
leaq 0x424a(%rip), %rsi      # 0x21917
leaq 0x1e76(%rip), %rdx      # 0x1f54a
callq 0x4650
cmpl $0x0, %eax
je 0x1d6f0
movq -0x10(%rbp), %rsi
leaq 0x423f(%rip), %rdi      # 0x21928
movb $0x0, %al
callq 0x47a0
jmp 0x1d6f2
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rcx
orq $0x800, %rcx            # imm = 0x800
movq %rcx, 0xc8(%rax)
jmp 0x1d70d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1d68a
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sfeakes[P]unifi-motion/mongoose.c
// Function: mg_tun_init_client
static void mg_tun_init_client(struct mg_tun_client *client, struct mg_mgr *mgr,
                               struct mg_iface *iface, const char *dispatcher,
                               struct mg_tun_ssl_opts ssl) {
  client->mgr = mgr;
  client->iface = iface;
  client->disp_url = dispatcher;
  client->last_stream_id = 0;
  client->ssl = ssl;

  client->disp = NULL;      /* will be set by mg_tun_reconnect */
  client->listener = NULL;  /* will be set by mg_do_bind */
  client->reconnect = NULL; /* will be set by mg_tun_reconnect */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %r8d, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x28, 0x1d8(%rax)
jle 0x1d7da
movb $0x0, -0x1(%rbp)
jmp 0x1d924
movl $0x8c, %edi
callq 0x3420
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x1d8(%rcx), %rcx
movq %rdx, 0x98(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x1d8(%rcx), %rcx
movq 0x98(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movl $0x28, %edx
callq 0x30a0
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x1d8(%rcx), %rcx
movq 0x98(%rax,%rcx,8), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
movl $0x64, %edx
callq 0x30a0
movq -0x18(%rbp), %rdi
callq 0x3180
cmpq $0x27, %rax
jb 0x1d8a9
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x1d8(%rcx), %rcx
movq 0x98(%rax,%rcx,8), %rax
movb $0x0, 0x27(%rax)
movq 0x9773(%rip), %rax      # 0x26ff0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x1d8(%rcx), %rcx
movq 0x98(%rax,%rcx,8), %rcx
leaq 0x4105(%rip), %rsi      # 0x219a7
movb $0x0, %al
callq 0x3370
movq -0x20(%rbp), %rdi
callq 0x3180
cmpq $0x63, %rax
jb 0x1d90d
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x1d8(%rcx), %rcx
movq 0x98(%rax,%rcx,8), %rax
movb $0x0, 0x8b(%rax)
movq 0x9713(%rip), %rax      # 0x26ff0
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x1d8(%rcx), %rcx
movq 0x98(%rax,%rcx,8), %rcx
addq $0x28, %rcx
leaq 0x40e4(%rip), %rsi      # 0x219ea
movb $0x0, %al
callq 0x3370
movq -0x10(%rbp), %rax
movl 0x1d8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1d8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x36a0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x1d96a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1d93c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1d980
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d9fd
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3180
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x21(%rbp)
jbe 0x1d9d6
callq 0x36a0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1d9df
jmp 0x1d9ed
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1d9a3
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sfeakes[P]unifi-motion/config.c
// Function: cleanalloc
char *cleanalloc(char*str)
{
  char *result;
  str = cleanwhitespace(str);
  
  result = (char*)malloc(strlen(str)+1);
  strcpy ( result, str );
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d930
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3180
movq %rax, %rdi
addq $0x1, %rdi
callq 0x3420
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x30d0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sfeakes[P]unifi-motion/config.c
// Function: print_config
void print_config(umConfig *config)
{
  int i;

  fprintf(stderr, "CFG mqtt address '%s'\n", config->mqtt_address );
  fprintf(stderr, "CFG mqtt user '%s'\n", config->mqtt_user );
  fprintf(stderr, "CFG mqtt passwd '%s'\n", config->mqtt_passwd );
  fprintf(stderr, "CFG mqtt topic '%s'\n", config->mqtt_pub_topic );
  fprintf(stderr, "CFG log regexp '%s'\n", config->regexString );
  fprintf(stderr, "CFG log to monitor '%s'\n", config->log_file_to_monitor );
  fprintf(stderr, "CFG watch filename '%s'\n", config->watchFile );
  fprintf(stderr, "CFG watch directory '%s'\n", config->watchDir );

  for (i = 0; i < config->numMotions; i++) {
    fprintf(stderr, "CFG Motion '%s'='%s'\n", config->motions[i]->name, config->motions[i]->action);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x914d(%rip), %rax      # 0x26ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x3be2(%rip), %rsi      # 0x21a96
movb $0x0, %al
callq 0x3370
movq 0x912e(%rip), %rax      # 0x26ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x3bd9(%rip), %rsi      # 0x21aad
movb $0x0, %al
callq 0x3370
movq 0x910e(%rip), %rax      # 0x26ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x3bcd(%rip), %rsi      # 0x21ac1
movb $0x0, %al
callq 0x3370
movq 0x90ee(%rip), %rax      # 0x26ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x3bc3(%rip), %rsi      # 0x21ad7
movb $0x0, %al
callq 0x3370
movq 0x90ce(%rip), %rax      # 0x26ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdx
leaq 0x3bb8(%rip), %rsi      # 0x21aec
movb $0x0, %al
callq 0x3370
movq 0x90ae(%rip), %rax      # 0x26ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x3bad(%rip), %rsi      # 0x21b01
movb $0x0, %al
callq 0x3370
movq 0x908e(%rip), %rax      # 0x26ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdx
leaq 0x3ba6(%rip), %rsi      # 0x21b1a
movb $0x0, %al
callq 0x3370
movq 0x906e(%rip), %rax      # 0x26ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdx
leaq 0x3b9f(%rip), %rsi      # 0x21b33
movb $0x0, %al
callq 0x3370
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1d8(%rcx), %eax
jge 0x1dff8
movq 0x9038(%rip), %rax      # 0x26ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x98(%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x98(%rax,%rcx,8), %rcx
addq $0x28, %rcx
leaq 0x3b67(%rip), %rsi      # 0x21b4d
movb $0x0, %al
callq 0x3370
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1dfa2
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1d8(%rcx), %eax
jge 0x1e042
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x98(%rax,%rcx,8), %rdi
callq 0x3050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1e013
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3050
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/erik[P]gamut/rotate.c
// Function: sampleat
pixel_t sampleat(pixel_t *image, int x, int y, int width, int height)
{
    // clamp to edges
    int clamp = 1;
    if (x < 0) x = 0, clamp = 0;
    else if (x >= width) x = width - 1, clamp = 0;
    if (y < 0) y = 0, clamp = 0;
    else if (y >= height) y = height - 1, clamp = 0;

    pixel_t pixel = PIXEL(image, x, y);
    pixel.a *= clamp;
    return pixel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1262
movl $0x0, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x127c
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x127a
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x127c
cmpl $0x0, -0x18(%rbp)
jge 0x1292
movl $0x0, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x12ac
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x12aa
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x12ac
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
imull -0x1c(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %ecx
movzwl -0x2(%rbp), %eax
imull %ecx, %eax
movw %ax, -0x2(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/erik[P]gamut/rotate.c
// Function: interpolate
pixel_t interpolate(pixel_t a, pixel_t b, double t)
{
    double s = 1.0 - t;
    return (pixel_t){
        a.r * s + b.r * t,
        a.g * s + b.g * t,
        a.b * s + b.b * t,
        a.a * s + b.a * t
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd 0x1d0a(%rip), %xmm0     # 0x3008
subsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movzwl -0x10(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd -0x28(%rbp), %xmm2
movzwl -0x18(%rbp), %eax
cvtsi2sd %eax, %xmm1
movsd -0x20(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, -0x8(%rbp)
movzwl -0xe(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd -0x28(%rbp), %xmm2
movzwl -0x16(%rbp), %eax
cvtsi2sd %eax, %xmm1
movsd -0x20(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, -0x6(%rbp)
movzwl -0xc(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd -0x28(%rbp), %xmm2
movzwl -0x14(%rbp), %eax
cvtsi2sd %eax, %xmm1
movsd -0x20(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, -0x4(%rbp)
movzwl -0xa(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd -0x28(%rbp), %xmm2
movzwl -0x12(%rbp), %eax
cvtsi2sd %eax, %xmm1
movsd -0x20(%rbp), %xmm3
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, -0x2(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erik[P]gamut/./farbfeld.h
// Function: read_header
static void read_header(uint32_t* width, uint32_t* height)
{
    uint8_t hdr[16] = {0};

    if (fread(hdr, 1, strlen(FF_HEADER), stdin) != strlen(FF_HEADER)) {
        fprintf(stderr, "incomplete header\n");
        exit(1);
    }

    if (memcmp("farbfeld", hdr, strlen("farbfeld"))) {
        fprintf(stderr, "invalid magic value\n");
        exit(1);
    }

    *width = ntohl(*((uint32_t *)(hdr + 8)));
    *height = ntohl(*((uint32_t *)(hdr + 12)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10a0
leaq -0x20(%rbp), %rdi
movq 0x331d(%rip), %rax      # 0x4fd8
movq (%rax), %rcx
movl $0x1, %esi
movl $0x10, %edx
callq 0x1040
cmpq $0x10, %rax
je 0x1cf5
movq 0x331e(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1386(%rip), %rsi      # 0x306a
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1100
leaq -0x20(%rbp), %rax
movq (%rax), %rax
movabsq $0x646c656662726166, %rcx # imm = 0x646C656662726166
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x1d36
movq 0x32dd(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1361(%rip), %rsi      # 0x3086
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1100
movl -0x18(%rbp), %edi
callq 0x1120
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %edi
callq 0x1120
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/erik[P]gamut/./farbfeld.h
// Function: read_image
static inline void read_image(pixel_t* pixels, uint32_t width, uint32_t height)
{
    uint32_t size = width * height;

    if (fread(pixels, sizeof(uint16_t) * 4, size, stdin) != size) {
        fprintf(stderr, "unexpected EOF\n");
        exit(1);
    }

    for (uint32_t i = 0; i < height; i++) {
        for (uint32_t j = 0; j < width; j++) {
            hton_pixel(&pixels[i * width + j], &pixels[i * width + j]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %edx
movq 0x324c(%rip), %rax      # 0x4fd8
movq (%rax), %rcx
movl $0x8, %esi
callq 0x1040
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
je 0x1dc3
movq 0x3250(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x12e9(%rip), %rsi      # 0x309b
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1100
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x1e2c
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x1e1f
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
imull -0xc(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movl -0x18(%rbp), %eax
imull -0xc(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1fc0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1dd9
jmp 0x1e21
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1dca
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erik[P]gamut/./farbfeld.h
// Function: write_header
static void write_header(uint32_t width, uint32_t height)
{
    uint32_t tmp;

    fputs("farbfeld", stdout);

    tmp = htonl(width);
    if (fwrite(&tmp, sizeof(uint32_t), 1, stdout) != 1)
        exit(1);

    tmp = htonl(height);
    if (fwrite(&tmp, sizeof(uint32_t), 1, stdout) != 1)
        exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0x317b(%rip), %rax      # 0x4fd0
movq (%rax), %rsi
leaq 0x121e(%rip), %rdi      # 0x307d
callq 0x1080
movl -0x4(%rbp), %edi
callq 0x1090
movl %eax, -0xc(%rbp)
movq 0x315a(%rip), %rax      # 0x4fd0
movq (%rax), %rcx
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1110
cmpq $0x1, %rax
je 0x1e9c
movl $0x1, %edi
callq 0x1100
movl -0x8(%rbp), %edi
callq 0x1090
movl %eax, -0xc(%rbp)
movq 0x3122(%rip), %rax      # 0x4fd0
movq (%rax), %rcx
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1110
cmpq $0x1, %rax
je 0x1ed4
movl $0x1, %edi
callq 0x1100
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erik[P]gamut/./farbfeld.h
// Function: write_pixel
static inline void write_pixel(pixel_t* rgba)
{
    pixel_t copy;

    hton_pixel(&copy, rgba);

    if (fwrite(&copy, sizeof(uint16_t), 4, stdout) != 4) {
        fprintf(stderr, "write error\n");
        exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x1fc0
movq 0x30d0(%rip), %rax      # 0x4fd0
movq (%rax), %rcx
leaq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x1110
cmpq $0x4, %rax
je 0x1f3e
movq 0x30d5(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x117e(%rip), %rsi      # 0x30ab
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x1f94
movq 0x3085(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x10d5(%rip), %rsi      # 0x3059
movb $0x0, %al
callq 0x10d0
movl $0x1, -0x4(%rbp)
jmp 0x1fb3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1050
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x13d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/erik[P]gamut/./farbfeld.h
// Function: hton_pixel
static void hton_pixel(pixel_t* dst, pixel_t* src)
{
    dst->r = htons(src->r);
    dst->g = htons(src->g);
    dst->b = htons(src->b);
    dst->a = htons(src->a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %edi
callq 0x1060
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x1060
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %edi
callq 0x1060
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x1060
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/seakeyakv2/generic32lc/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    SeaKeyak_Instance instance;

    SeaKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 0, 0 );
    SeaKeyak_Wrap( &instance, m, c, (size_t)mlen, ad, (size_t)adlen, c+mlen, 0, 0 );
    *clen = mlen + 16;
    return 0;
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq 0x210(%rsp), %rax
movq 0x208(%rsp), %rax
movq 0x200(%rsp), %rax
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
movq %rcx, 0x1d8(%rsp)
movq %r8, 0x1d0(%rsp)
movq %r9, 0x1c8(%rsp)
movq 0x210(%rsp), %rsi
movq 0x208(%rsp), %rcx
leaq 0x20(%rsp), %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x53a0
movq 0x1e0(%rsp), %rsi
movq 0x1f0(%rsp), %rdx
movq 0x1d8(%rsp), %rcx
movq 0x1d0(%rsp), %r8
movq 0x1c8(%rsp), %r9
movq 0x1f0(%rsp), %rax
addq 0x1d8(%rsp), %rax
leaq 0x20(%rsp), %rdi
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5660
movq 0x1d8(%rsp), %rcx
addq $0x10, %rcx
movq 0x1e8(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/seakeyakv2/generic32lc/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    SeaKeyak_Instance instance;
    unsigned long long mlen_;

    if (clen < 16)
        return -1;
    SeaKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 1, 0 );
    mlen_ = clen - 16;
    *mlen = mlen_;
    if ( SeaKeyak_Wrap( &instance, c, m, (size_t)mlen_, ad, (size_t)adlen, (unsigned char*)c+mlen_, 1, 0 ) == 1 )
        return 0;
    return -1;
}

// Assembly:
subq $0x208, %rsp            # imm = 0x208
movq 0x220(%rsp), %rax
movq 0x218(%rsp), %rax
movq 0x210(%rsp), %rax
movq %rdi, 0x1f8(%rsp)
movq %rsi, 0x1f0(%rsp)
movq %rdx, 0x1e8(%rsp)
movq %rcx, 0x1e0(%rsp)
movq %r8, 0x1d8(%rsp)
movq %r9, 0x1d0(%rsp)
cmpq $0x10, 0x1d8(%rsp)
jae 0x1b8ba
movl $0xffffffff, 0x204(%rsp) # imm = 0xFFFFFFFF
jmp 0x1b98d
movq 0x220(%rsp), %rsi
movq 0x218(%rsp), %rcx
leaq 0x28(%rsp), %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x53a0
movq 0x1d8(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x1f0(%rsp), %rax
movq %rcx, (%rax)
movq 0x1e0(%rsp), %rsi
movq 0x1f8(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x1d0(%rsp), %r8
movq 0x210(%rsp), %r9
movq 0x1e0(%rsp), %rax
addq 0x20(%rsp), %rax
leaq 0x28(%rsp), %rdi
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5660
cmpl $0x1, %eax
jne 0x1b982
movl $0x0, 0x204(%rsp)
jmp 0x1b98d
movl $0xffffffff, 0x204(%rsp) # imm = 0xFFFFFFFF
movl 0x204(%rsp), %eax
addq $0x208, %rsp            # imm = 0x208
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/main.c
// Function: main
int main(int argc, char **argv)
{
    int returnValue = 0;
    char buffer[256];
    ficlVm *vm;
	ficlSystem *system;

    system = ficlSystemCreate(NULL);
    ficlSystemCompileExtras(system);
    vm = ficlSystemCreateVm(system);

    returnValue = ficlVmEvaluate(vm, ".ver .( " __DATE__ " ) cr quit");

    /*
    ** load files specified on command-line
    */
    if (argc  > 1)
    {
        sprintf(buffer, ".( loading %s ) cr load %s\n cr", argv[1], argv[1]);
        returnValue = ficlVmEvaluate(vm, buffer);
    }

    while (returnValue != FICL_VM_STATUS_USER_EXIT)
    {
        fputs(FICL_PROMPT, stdout);
        if (fgets(buffer, sizeof(buffer), stdin) == NULL) break;
        returnValue = ficlVmEvaluate(vm, buffer);
    }

    ficlSystemDestroy(system);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3540
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rdi
callq 0x10880
movq -0x130(%rbp), %rdi
callq 0x3a30
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rdi
leaq 0x11b87(%rip), %rsi     # 0x15004
callq 0x96b0
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x34c6
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x11b79(%rip), %rsi     # 0x15022
movb $0x0, %al
callq 0x32d0
movq -0x128(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x96b0
movl %eax, -0x14(%rbp)
jmp 0x34c8
cmpl $0xfffffefd, -0x14(%rbp) # imm = 0xFFFFFEFD
je 0x3522
movq 0x18b00(%rip), %rax     # 0x1bfd8
movq (%rax), %rsi
leaq 0x11b5f(%rip), %rdi     # 0x15041
callq 0x3110
leaq -0x120(%rbp), %rdi
movq 0x18aeb(%rip), %rax     # 0x1bfe0
movq (%rax), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x3150
cmpq $0x0, %rax
jne 0x350a
jmp 0x3522
movq -0x128(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x96b0
movl %eax, -0x14(%rbp)
jmp 0x34c8
movq -0x130(%rbp), %rdi
callq 0x3b60
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/system.c
// Function: ficlSystemSetVersion
static void ficlSystemSetVersion(ficlSystem *system)
{
    int major = 0;
    int minor = 0;
	ficl2Integer combined;
	ficlDictionary *environment = ficlSystemGetEnvironment(system);
    sscanf(FICL_VERSION, "%d.%d", &major, &minor);
	FICL_2INTEGER_SET(major, minor, combined);
    ficlDictionarySet2Constant(environment, "ficl-version", combined);
    ficlDictionarySetConstant(environment, "ficl-robust",  FICL_ROBUST);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3ce0
movq %rax, -0x28(%rbp)
leaq 0x1185c(%rip), %rdi     # 0x151ba
leaq 0x1185b(%rip), %rsi     # 0x151c0
leaq -0xc(%rbp), %rdx
leaq -0x10(%rbp), %rcx
movb $0x0, %al
callq 0x3230
movslq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x1181f(%rip), %rsi     # 0x151c6
callq 0x11640
movq -0x28(%rbp), %rdi
leaq 0x1181c(%rip), %rsi     # 0x151d3
xorl %eax, %eax
movl %eax, %edx
callq 0x11540
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x6421(%rip), %rdx      # 0x9e20
xorl %ecx, %ecx
callq 0x11780
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11010
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3c20
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/system.c
// Function: ficlSystemCreateVm
ficlVm *ficlSystemCreateVm(ficlSystem *system)
{
    ficlVm *vm = ficlVmCreate(NULL, system->stackSize, system->stackSize);
    vm->link = system->vmList;

	memcpy(&(vm->callback), &(system->callback), sizeof(system->callback));
	vm->callback.vm = vm;
	vm->callback.system = system;

    system->vmList = vm;
    return vm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rax
movl %eax, %esi
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rax
movl %eax, %edx
xorl %eax, %eax
movl %eax, %edi
callq 0x64b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x28, %edx
callq 0x31e0
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/system.c
// Function: ficlSystemDestroyVm
void ficlSystemDestroyVm(ficlVm *vm)
{
    ficlSystem *system = vm->callback.system;
    ficlVm *pList = system->vmList;

    FICL_VM_ASSERT(vm, vm != NULL);

    if (system->vmList == vm)
    {
        system->vmList = system->vmList->link;
    }
    else for (; pList != NULL; pList = pList->link)
    {
        if (pList->link == vm)
        {
            pList->link = vm->link;
            break;
        }
    }

    if (pList)
        ficlVmDestroy(vm);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x3b08
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x3b43
jmp 0x3b0a
cmpq $0x0, -0x18(%rbp)
je 0x3b41
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x3b31
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x3b41
jmp 0x3b33
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3b0a
jmp 0x3b43
cmpq $0x0, -0x18(%rbp)
je 0x3b53
movq -0x8(%rbp), %rdi
callq 0x65f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/system.c
// Function: ficlSystemDestroy
void ficlSystemDestroy(ficlSystem *system)
{
    if (system->dictionary)
        ficlDictionaryDestroy(system->dictionary);
    system->dictionary = NULL;

    if (system->environment)
        ficlDictionaryDestroy(system->environment);
    system->environment = NULL;

#if FICL_WANT_LOCALS
    if (system->locals)
        ficlDictionaryDestroy(system->locals);
    system->locals = NULL;
#endif

    while (system->vmList != NULL)
    {
        ficlVm *vm = system->vmList;
        system->vmList = system->vmList->link;
        ficlVmDestroy(vm);
    }

    ficlFree(system);
    system = NULL;

	if (ficlSystemGlobal == system)
		ficlSystemGlobal = NULL;

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x3b84
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x11ae0
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x3ba8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x11ae0
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3bea
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0x65f0
jmp 0x3bb4
movq -0x8(%rbp), %rdi
callq 0xf980
movq $0x0, -0x8(%rbp)
movq 0x1b8b6(%rip), %rax     # 0x1f4b8
cmpq -0x8(%rbp), %rax
jne 0x3c13
movq $0x0, 0x1b8a5(%rip) # 0x1f4b8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/system.c
// Function: ficlSystemAddParseStep
int ficlSystemAddParseStep(ficlSystem *system, ficlWord *word)
{
    int i;
    for (i = 0; i < FICL_MAX_PARSE_STEPS; i++)
    {
        if (system->parseList[i] == NULL)
        {
            system->parseList[i] = word;
            return 0;
        }
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x3c70
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, 0x60(%rax,%rcx,8)
jne 0x3c63
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, 0x60(%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
jmp 0x3c77
jmp 0x3c65
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3c33
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/float.c
// Function: ficlVmDisplayFloatStack
void ficlVmDisplayFloatStack(ficlVm *vm)
{
    struct stackContext context;
	context.vm = vm;
	context.count = 0;
    ficlStackDisplay(vm->floatStack, ficlFloatStackDisplayCallback, &context);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
leaq 0x16(%rip), %rsi        # 0x3e80
leaq -0x18(%rbp), %rdx
callq 0x5130
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/float.c
// Function: ficlFloatStackDisplayCallback
static ficlInteger ficlFloatStackDisplayCallback(void *c, ficlCell *cell)
{
    struct stackContext *context = (struct stackContext *)c;
    char buffer[64];
    sprintf(buffer, "[0x%08x %3d] %16f (0x%08x)\n", cell, context->count++, (double)(cell->f), cell->i);
    ficlVmTextOut(context->vm, buffer);
	return FICL_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rax)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x10(%rbp), %rax
movq (%rax), %r8
leaq 0x113a7(%rip), %rsi     # 0x15270
movb $0x1, %al
callq 0x32d0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq -0x60(%rbp), %rsi
callq 0x95e0
movq $-0x1, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)