LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_obj_at_iterator
obj * obdeque_obj_at_iterator(const obdeque *deque, const obdeque_iterator *it){

  assert(deque);
  assert(it);
  assert(it->deque == deque); /* assert that iterator belongs to provided
                                 deque */
  if(!it->node) return NULL; /* if the iterator is empty return NULL */
  return it->node->stored;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ec9
jmp 0x1ee8
leaq 0x3885(%rip), %rdi      # 0x5755
leaq 0x372a(%rip), %rsi      # 0x5601
movl $0x128, %edx            # imm = 0x128
leaq 0x3ad1(%rip), %rcx      # 0x59b4
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x1ef1
jmp 0x1f10
leaq 0x384d(%rip), %rdi      # 0x5745
leaq 0x3702(%rip), %rsi      # 0x5601
movl $0x129, %edx            # imm = 0x129
leaq 0x3aa9(%rip), %rcx      # 0x59b4
callq 0x1050
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x1f20
jmp 0x1f3f
leaq 0x3821(%rip), %rdi      # 0x5748
leaq 0x36d3(%rip), %rsi      # 0x5601
movl $0x12a, %edx            # imm = 0x12A
leaq 0x3a7a(%rip), %rcx      # 0x59b4
callq 0x1050
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1f54
movq $0x0, -0x8(%rbp)
jmp 0x1f64
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_add_at_tail
void obdeque_add_at_tail(obdeque *deque, obj *to_add){

  obdeque_node *new_node;

  assert(deque);
  assert(to_add);

  /* creating deque node with to_add ob_retains to account for the deque's
   * reference */
  new_node = obdeque_new_node(to_add);

  /* set node data */
  new_node->prev = deque->tail;

  /* update deque data */
  /* if a tail aleady exists update tail next */
  if(deque->tail) deque->tail->next = new_node;
  else deque->head = new_node; /* else set head, which should not be NULL
                                 anymore */
  deque->tail = new_node;
  deque->length++;

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1f89
jmp 0x1fa8
leaq 0x37c5(%rip), %rdi      # 0x5755
leaq 0x366a(%rip), %rsi      # 0x5601
movl $0x92, %edx
leaq 0x382c(%rip), %rcx      # 0x57cf
callq 0x1050
cmpq $0x0, -0x10(%rbp)
je 0x1fb1
jmp 0x1fd0
leaq 0x3810(%rip), %rdi      # 0x57c8
leaq 0x3642(%rip), %rsi      # 0x5601
movl $0x93, %edx
leaq 0x3804(%rip), %rcx      # 0x57cf
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x24e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x200a
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x2016
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_iterate_next
uint8_t obdeque_iterate_next(const obdeque *deque, obdeque_iterator *it){

  assert(deque);
  assert(it);
  assert(it->deque == deque);

  if(!it->node) return 0;

  /* update the iterator if the next node exists, and return 1 */
  if(it->node->next){
    ob_retain((obj *)it->node->next);
    ob_release((obj *)it->node);
    it->node = it->node->next;
    return 1;
  }

  /* else the iterator is at the end of the list, return 0 */
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2059
jmp 0x2078
leaq 0x36f5(%rip), %rdi      # 0x5755
leaq 0x359a(%rip), %rsi      # 0x5601
movl $0x4c, %edx
leaq 0x3690(%rip), %rcx      # 0x5703
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x2081
jmp 0x20a0
leaq 0x36bd(%rip), %rdi      # 0x5745
leaq 0x3572(%rip), %rsi      # 0x5601
movl $0x4d, %edx
leaq 0x3668(%rip), %rcx      # 0x5703
callq 0x1050
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x20b0
jmp 0x20cf
leaq 0x3691(%rip), %rdi      # 0x5748
leaq 0x3543(%rip), %rsi      # 0x5601
movl $0x4e, %edx
leaq 0x3639(%rip), %rcx      # 0x5703
callq 0x1050
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x20e0
movb $0x0, -0x1(%rbp)
jmp 0x212b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x2127
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x3f70
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3ef0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x212b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_new_iterator
obdeque_iterator * obdeque_new_iterator(const obdeque *deque, obdeque_node *node){

  static const char classname[] = "obdeque_iterator";
  obdeque_iterator *new_instance;

  if(!node) return NULL; /* return nothing when iterating from an empty
                            deque */

  new_instance = malloc(sizeof(obdeque_iterator));
  assert(new_instance != NULL);

  /* initialize base class data */
  ob_init_base((obj *)new_instance, &obdeque_destroy_iterator, NULL, NULL, NULL,
               classname);

  ob_retain((obj *)node);
  new_instance->node = node;
  new_instance->deque = deque;

  return new_instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2204
movq $0x0, -0x8(%rbp)
jmp 0x2285
movl $0x18, %edi
callq 0x10a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x221b
jmp 0x223a
leaq 0x38c9(%rip), %rdi      # 0x5aeb
leaq 0x33d8(%rip), %rsi      # 0x5601
movl $0x1dc, %edx            # imm = 0x1DC
leaq 0x392d(%rip), %rcx      # 0x5b62
callq 0x1050
movq -0x20(%rbp), %rdi
leaq 0x111b(%rip), %rsi      # 0x3360
xorl %eax, %eax
movl %eax, %r8d
leaq 0x3b8f(%rip), %r9       # 0x5de0
movq %r8, %rdx
movq %r8, %rcx
callq 0x3bf0
movq -0x18(%rbp), %rdi
callq 0x3f70
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_iterate_prev
uint8_t obdeque_iterate_prev(const obdeque *deque, obdeque_iterator *it){

  assert(deque);
  assert(it);
  assert(it->deque == deque);

  if(!it->node) return 0;

  /* update the iterator if the prev node exists, and return 1 */
  if(it->node->prev){
    ob_retain((obj *)it->node->prev);
    ob_release((obj *)it->node);
    it->node = it->node->prev;
    return 1;
  }

  /* else the iterator is at the end of the list, return 0 */
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2329
jmp 0x2348
leaq 0x3425(%rip), %rdi      # 0x5755
leaq 0x32ca(%rip), %rsi      # 0x5601
movl $0x61, %edx
leaq 0x3418(%rip), %rcx      # 0x575b
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x2351
jmp 0x2370
leaq 0x33ed(%rip), %rdi      # 0x5745
leaq 0x32a2(%rip), %rsi      # 0x5601
movl $0x62, %edx
leaq 0x33f0(%rip), %rcx      # 0x575b
callq 0x1050
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x2380
jmp 0x239f
leaq 0x33c1(%rip), %rdi      # 0x5748
leaq 0x3273(%rip), %rsi      # 0x5601
movl $0x63, %edx
leaq 0x33c1(%rip), %rcx      # 0x575b
callq 0x1050
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x23b0
movb $0x0, -0x1(%rbp)
jmp 0x23fb
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x23f7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x3f70
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3ef0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x23fb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_add_at_head
void obdeque_add_at_head(obdeque *deque, obj *to_add){

  obdeque_node *new_node;

  assert(deque);
  assert(to_add);

  /* creating deque node with to_add ob_retains to account for the deque's
   * reference */
  new_node = obdeque_new_node(to_add);

  /* set node data */
  new_node->next = deque->head;

  /* update deque data */
  /* if a head aleady exists update head prev */
  if(deque->head) deque->head->prev = new_node;
  else deque->tail = new_node; /* else set tail, which should not be NULL
                                 anymore*/
  deque->head = new_node;
  deque->length++;

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2429
jmp 0x2448
leaq 0x3325(%rip), %rdi      # 0x5755
leaq 0x31ca(%rip), %rsi      # 0x5601
movl $0x78, %edx
leaq 0x335a(%rip), %rcx      # 0x579d
callq 0x1050
cmpq $0x0, -0x10(%rbp)
je 0x2451
jmp 0x2470
leaq 0x3370(%rip), %rdi      # 0x57c8
leaq 0x31a2(%rip), %rsi      # 0x5601
movl $0x79, %edx
leaq 0x3332(%rip), %rcx      # 0x579d
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x24e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x24aa
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x24b6
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_new_node
obdeque_node * obdeque_new_node(obj *to_store){

  static const char classname[] = "obdeque_node";
  obdeque_node *new_instance;

  assert(to_store != NULL);

  new_instance = malloc(sizeof(obdeque_node));
  assert(new_instance != NULL);

  /* initialize base class data */
  ob_init_base((obj *)new_instance, &obdeque_destroy_node, NULL, NULL, NULL,
               classname);

  ob_retain(to_store);
  new_instance->stored = to_store;
  new_instance->next = NULL;
  new_instance->prev = NULL;

  return new_instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x24f5
jmp 0x2514
leaq 0x35b8(%rip), %rdi      # 0x5ab4
leaq 0x30fe(%rip), %rsi      # 0x5601
movl $0x1b1, %edx            # imm = 0x1B1
leaq 0x35b6(%rip), %rcx      # 0x5ac5
callq 0x1050
movl $0x20, %edi
callq 0x10a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x252b
jmp 0x254a
leaq 0x35b9(%rip), %rdi      # 0x5aeb
leaq 0x30c8(%rip), %rsi      # 0x5601
movl $0x1b4, %edx            # imm = 0x1B4
leaq 0x3580(%rip), %rcx      # 0x5ac5
callq 0x1050
movq -0x10(%rbp), %rdi
leaq 0xd7b(%rip), %rsi       # 0x32d0
xorl %eax, %eax
movl %eax, %r8d
leaq 0x386f(%rip), %r9       # 0x5dd0
movq %r8, %rdx
movq %r8, %rcx
callq 0x3bf0
movq -0x8(%rbp), %rdi
callq 0x3f70
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_add_at_iterator
void obdeque_add_at_iterator(obdeque *deque, obdeque_iterator *it, obj *to_add){

  obdeque_node *new_node;

  assert(deque);
  assert(it);
  assert(it->deque == deque);
  assert(to_add);

  if(!it->node){
    obdeque_add_at_head(deque, to_add);
    it->node = deque->head;
  }

  /* creating deque node with to_add ob_retains to account for the deque's
   * reference */
  new_node = obdeque_new_node(to_add);

  /* set node data */
  new_node->prev = it->node->prev;
  new_node->next = it->node;
  if(it->node->prev) it->node->prev->next = new_node;
  it->node->prev = new_node;

  deque->length++;

  /* update deque data if the iterator is pointing at the head (added node
   * cannot be the new tail) */
  if(it->node == deque->head) deque->head = new_node;

  /* update iterator to newly inserted node */
  assert(obdeque_iterate_prev(deque, it));

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x25cd
jmp 0x25ec
leaq 0x3181(%rip), %rdi      # 0x5755
leaq 0x3026(%rip), %rsi      # 0x5601
movl $0xac, %edx
leaq 0x3213(%rip), %rcx      # 0x57fa
callq 0x1050
cmpq $0x0, -0x10(%rbp)
je 0x25f5
jmp 0x2614
leaq 0x3149(%rip), %rdi      # 0x5745
leaq 0x2ffe(%rip), %rsi      # 0x5601
movl $0xad, %edx
leaq 0x31eb(%rip), %rcx      # 0x57fa
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x2624
jmp 0x2643
leaq 0x311d(%rip), %rdi      # 0x5748
leaq 0x2fcf(%rip), %rsi      # 0x5601
movl $0xae, %edx
leaq 0x31bc(%rip), %rcx      # 0x57fa
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x264c
jmp 0x266b
leaq 0x3175(%rip), %rdi      # 0x57c8
leaq 0x2fa7(%rip), %rsi      # 0x5601
movl $0xaf, %edx
leaq 0x3194(%rip), %rcx      # 0x57fa
callq 0x1050
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2693
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2410
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x24e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x26e7
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x2725
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2310
cmpb $0x0, %al
je 0x2738
jmp 0x2757
leaq 0x30fe(%rip), %rdi      # 0x583d
leaq 0x2ebb(%rip), %rsi      # 0x5601
movl $0xc7, %edx
leaq 0x30a8(%rip), %rcx      # 0x57fa
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_join
obdeque * obdeque_join(const obdeque *d1, const obdeque *d2){

  obdeque *joined;
  obdeque_iterator *it;
  obj *element;

  assert(d1);
  assert(d2);

  joined = obdeque_copy(d1);

  it = obdeque_head_iterator(d2);

  if(!it) return joined; /* if the list is empty, return joined list */

  /* while there are elements in the deque to copy add to the tail of the
   * deque */
  do{
    element = obdeque_obj_at_iterator(d2, it);
    obdeque_add_at_tail(joined, element);
  } while(obdeque_iterate_next(d2, it));

  ob_release((obj *)it);

  return joined;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2779
jmp 0x2798
leaq 0x30dd(%rip), %rdi      # 0x585d
leaq 0x2e7a(%rip), %rsi      # 0x5601
movl $0xd3, %edx
leaq 0x30cd(%rip), %rcx      # 0x5860
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x27a1
jmp 0x27c0
leaq 0x30f0(%rip), %rdi      # 0x5898
leaq 0x2e52(%rip), %rsi      # 0x5601
movl $0xd4, %edx
leaq 0x30a5(%rip), %rcx      # 0x5860
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1db0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x27eb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x282d
jmp 0x27ed
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1eb0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1f70
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2040
cmpb $0x0, %al
jne 0x27ed
movq -0x28(%rbp), %rdi
callq 0x3ef0
movq -0x20(%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/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_find_obj
uint8_t obdeque_find_obj(const obdeque *deque, const obj *to_find){

  obdeque_iterator *it;
  uint8_t retval = 0;

  assert(deque);
  assert(to_find);

  it = obdeque_head_iterator(deque);
  if(!it) return 0; /* obj is not in an empty list */

  do{
    if(ob_compare(obdeque_obj_at_iterator(deque, it), to_find) == OB_EQUAL_TO){
      retval = 1;
      break;
    }
  } while(obdeque_iterate_next(deque, it));

  ob_release((obj *)it);

  return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x285d
jmp 0x287c
leaq 0x2ef1(%rip), %rdi      # 0x5755
leaq 0x2d96(%rip), %rsi      # 0x5601
movl $0xed, %edx
leaq 0x3024(%rip), %rcx      # 0x589b
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x2885
jmp 0x28a4
leaq 0x3046(%rip), %rdi      # 0x58d2
leaq 0x2d6e(%rip), %rsi      # 0x5601
movl $0xee, %edx
leaq 0x2ffc(%rip), %rcx      # 0x589b
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1e60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x28be
movb $0x0, -0x1(%rbp)
jmp 0x2909
jmp 0x28c0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1eb0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3dd0
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x28e7
movb $0x1, -0x21(%rbp)
jmp 0x28fa
jmp 0x28e9
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2040
cmpb $0x0, %al
jne 0x28c0
movq -0x20(%rbp), %rdi
callq 0x3ef0
movb -0x21(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_sort_with_funct
void obdeque_sort_with_funct(obdeque *deque, int8_t order, ob_compare_fptr funct){

  obdeque sorted; /* stack variable to remove internal memory management
                     burden */

  assert(deque);
  assert(order == OB_LEAST_TO_GREATEST || order == OB_GREATEST_TO_LEAST);
  assert(funct);

  sorted = obdeque_recursive_sort(*deque, order, funct);

  /* connect head and tail of newly sorted list to deque */
  deque->head = sorted.head;
  deque->tail = sorted.tail;

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2972
jmp 0x2991
leaq 0x2ddc(%rip), %rdi      # 0x5755
leaq 0x2c81(%rip), %rsi      # 0x5601
movl $0x10a, %edx            # imm = 0x10A
leaq 0x2f4e(%rip), %rcx      # 0x58da
callq 0x1050
movsbl -0x9(%rbp), %eax
cmpl $-0x1, %eax
je 0x29a3
movsbl -0x9(%rbp), %eax
cmpl $0x1, %eax
jne 0x29a5
jmp 0x29c4
leaq 0x2f6f(%rip), %rdi      # 0x591b
leaq 0x2c4e(%rip), %rsi      # 0x5601
movl $0x10b, %edx            # imm = 0x10B
leaq 0x2f1b(%rip), %rcx      # 0x58da
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x29cd
jmp 0x29ec
leaq 0x2f86(%rip), %rdi      # 0x595a
leaq 0x2c26(%rip), %rsi      # 0x5601
movl $0x10c, %edx            # imm = 0x10C
leaq 0x2ef3(%rip), %rcx      # 0x58da
callq 0x1050
movq -0x8(%rbp), %rcx
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movq (%rcx), %rsi
movq %rsi, (%rsp)
movq 0x8(%rcx), %rsi
movq %rsi, 0x8(%rsp)
movq 0x10(%rcx), %rsi
movq %rsi, 0x10(%rsp)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movsbl %al, %esi
callq 0x2a70
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_remove_head
void obdeque_remove_head(obdeque *deque){

  obdeque_node *temp_node;

  assert(deque);

  /* return if the list is empty */
  if(!(temp_node = deque->head)) return;

  /* repair deque after removal */
  deque->head = deque->head->next;
  if(deque->head) deque->head->prev = NULL;
  else deque->tail = NULL;

  deque->length--;

  /* set temp_node next and prev to null, to separate the node completely from
   * the deque if it lives on through a reference in an iterator */
  temp_node->next = NULL;
  temp_node->prev = NULL;

  ob_release((obj *)temp_node);

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2ef5
jmp 0x2f14
leaq 0x2859(%rip), %rdi      # 0x5755
leaq 0x26fe(%rip), %rsi      # 0x5601
movl $0x135, %edx            # imm = 0x135
leaq 0x2aed(%rip), %rcx      # 0x59fc
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x2f28
jmp 0x2f96
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2f59
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x18(%rax)
jmp 0x2f65
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x3ef0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_remove_tail
void obdeque_remove_tail(obdeque *deque){

  obdeque_node *temp_node;

  assert(deque);

  /* return NULL if the list is empty */
  if(!(temp_node = deque->tail)) return;

  /* repair deque after removal */
  deque->tail = deque->tail->prev;
  if(deque->tail) deque->tail->next = NULL;
  else deque->head = NULL;

  deque->length--;

  /* set temp_node next and prev to null, to separate the node completely from
   * the deque if it lives on through a reference in an iterator */
  temp_node->next = NULL;
  temp_node->prev = NULL;

  ob_release((obj *)temp_node);

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2fb5
jmp 0x2fd4
leaq 0x2799(%rip), %rdi      # 0x5755
leaq 0x263e(%rip), %rsi      # 0x5601
movl $0x150, %edx            # imm = 0x150
leaq 0x2a51(%rip), %rcx      # 0x5a20
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x2fe8
jmp 0x3056
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3019
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x10(%rax)
jmp 0x3025
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x3ef0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_clear
void obdeque_clear(obdeque *deque){

  obdeque_node *tmp, *next;

  assert(deque);

  tmp = deque->head;

  while(tmp){

    next = tmp->next;

    /* remove references to other nodes, individual nodes may live on due to
     * references from iterators */
    tmp->next = NULL;
    tmp->prev = NULL;

    ob_release((obj *)tmp);
    tmp = next;
  }

  deque->head = NULL;
  deque->tail = NULL;
  deque->length = 0;

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3235
jmp 0x3254
leaq 0x2519(%rip), %rdi      # 0x5755
leaq 0x23be(%rip), %rsi      # 0x5601
movl $0x18e, %edx            # imm = 0x18E
leaq 0x2847(%rip), %rcx      # 0x5a96
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x329e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x3ef0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3260
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_destroy_node
void obdeque_destroy_node(obj *to_dealloc){

  /* cast generic obj to obdeque_node */
  obdeque_node *instance = (obdeque_node *)to_dealloc;

  assert(to_dealloc);
  assert(ob_has_class(to_dealloc, "obdeque_node"));

  ob_release(instance->stored);

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x32ed
jmp 0x330c
leaq 0x280c(%rip), %rdi      # 0x5b00
leaq 0x2306(%rip), %rsi      # 0x5601
movl $0x1c8, %edx            # imm = 0x1C8
leaq 0x2804(%rip), %rcx      # 0x5b0b
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x2815(%rip), %rsi      # 0x5b2c
callq 0x4010
cmpb $0x0, %al
je 0x3322
jmp 0x3341
leaq 0x2810(%rip), %rdi      # 0x5b39
leaq 0x22d1(%rip), %rsi      # 0x5601
movl $0x1c9, %edx            # imm = 0x1C9
leaq 0x27cf(%rip), %rcx      # 0x5b0b
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3ef0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_destroy_iterator
void obdeque_destroy_iterator(obj *to_dealloc){

  /* cast generic obj to obdeque_node */
  obdeque_iterator *instance = (obdeque_iterator *)to_dealloc;

  assert(to_dealloc);
  assert(ob_has_class(to_dealloc, "obdeque_iterator"));

  ob_release((obj *)instance->node);

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x337d
jmp 0x339c
leaq 0x277c(%rip), %rdi      # 0x5b00
leaq 0x2276(%rip), %rsi      # 0x5601
movl $0x1ef, %edx            # imm = 0x1EF
leaq 0x2821(%rip), %rcx      # 0x5bb8
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x2836(%rip), %rsi      # 0x5bdd
callq 0x4010
cmpb $0x0, %al
je 0x33b2
jmp 0x33d1
leaq 0x2835(%rip), %rdi      # 0x5bee
leaq 0x2241(%rip), %rsi      # 0x5601
movl $0x1f0, %edx            # imm = 0x1F0
leaq 0x27ec(%rip), %rcx      # 0x5bb8
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3ef0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_destroy
void obdeque_destroy(obj *to_dealloc){

  /* cast generic obj to obdeque */
  obdeque *instance = (obdeque *)to_dealloc;

  assert(to_dealloc);
  assert(ob_has_class(to_dealloc, "obdeque"));

  obdeque_clear(instance);

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x340d
jmp 0x342c
leaq 0x26ec(%rip), %rdi      # 0x5b00
leaq 0x21e6(%rip), %rsi      # 0x5601
movl $0x2cf, %edx            # imm = 0x2CF
leaq 0x2969(%rip), %rcx      # 0x5d90
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x2836(%rip), %rsi      # 0x5c6d
callq 0x4010
cmpb $0x0, %al
je 0x3442
jmp 0x3461
leaq 0x2963(%rip), %rdi      # 0x5dac
leaq 0x21b1(%rip), %rsi      # 0x5601
movl $0x2d0, %edx            # imm = 0x2D0
leaq 0x2934(%rip), %rcx      # 0x5d90
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x3220
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_hash
ob_hash_t obdeque_hash(const obj *to_hash){

  static int8_t init = 0;
  ob_hash_t value;
  static ob_hash_t seed = 0;
  obdeque *instance = (obdeque *)to_hash;
  obdeque_iterator *it;

  assert(to_hash);
  assert(ob_has_class(to_hash, "obdeque"));

  if(init == 0){
    srand(time(NULL));
    seed = rand();
    init = 1;
  }

  value = seed;

  it = obdeque_head_iterator(instance);
  if(!it) return value;

  do{
    value += ob_hash(obdeque_obj_at_iterator(instance, it));
    value += value << 10;
    value ^= value >> 6;
  }while(obdeque_iterate_next(instance, it));

  ob_release((obj *)it);

  value += value << 3;
  value ^= value >> 11;
  value += value << 15;

  return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x348d
jmp 0x34ac
leaq 0x27ad(%rip), %rdi      # 0x5c41
leaq 0x2166(%rip), %rsi      # 0x5601
movl $0x26b, %edx            # imm = 0x26B
leaq 0x27a2(%rip), %rcx      # 0x5c49
callq 0x1050
movq -0x10(%rbp), %rdi
leaq 0x27b6(%rip), %rsi      # 0x5c6d
callq 0x4010
cmpb $0x0, %al
je 0x34c2
jmp 0x34e1
leaq 0x27ac(%rip), %rdi      # 0x5c75
leaq 0x2131(%rip), %rsi      # 0x5601
movl $0x26c, %edx            # imm = 0x26C
leaq 0x276d(%rip), %rcx      # 0x5c49
callq 0x1050
movsbl 0x4b90(%rip), %eax      # 0x8078
cmpl $0x0, %eax
jne 0x3512
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x1060
callq 0x10b0
cltq
movq %rax, 0x4b75(%rip)      # 0x8080
movb $0x1, 0x4b66(%rip)      # 0x8078
movq 0x4b67(%rip), %rax      # 0x8080
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1e60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x353e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x35cf
jmp 0x3540
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1eb0
movq %rax, %rdi
callq 0x3d30
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0xa, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2040
cmpb $0x0, %al
jne 0x3540
movq -0x28(%rbp), %rdi
callq 0x3ef0
movq -0x18(%rbp), %rax
shlq $0x3, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0xb, %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0xf, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obdeque.c
// Function: obdeque_display
void obdeque_display(const obj *to_print){

  obdeque *d = (obdeque *)to_print;
  obdeque_iterator *it;

  assert(to_print != NULL);
  assert(ob_has_class(to_print, "obdeque"));
  fprintf(stderr, "obdeque with %llu elements\n"
                  "  [deque head]", obdeque_length(d));

  it = obdeque_head_iterator(d);

  if(!it) return;

  do{
    ob_display(obdeque_obj_at_iterator(d, it));
    fprintf(stderr, "\n");
  }while(obdeque_iterate_next(d, it));

  ob_release((obj *)it);

  fprintf(stderr, "  [deque tail]\n");

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x37dd
jmp 0x37fc
leaq 0x251d(%rip), %rdi      # 0x5d01
leaq 0x1e16(%rip), %rsi      # 0x5601
movl $0x2b4, %edx            # imm = 0x2B4
leaq 0x251b(%rip), %rcx      # 0x5d12
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x2466(%rip), %rsi      # 0x5c6d
callq 0x4010
cmpb $0x0, %al
je 0x3812
jmp 0x3831
leaq 0x251b(%rip), %rdi      # 0x5d34
leaq 0x1de1(%rip), %rsi      # 0x5601
movl $0x2b5, %edx            # imm = 0x2B5
leaq 0x24e6(%rip), %rcx      # 0x5d12
callq 0x1050
movq 0x47c0(%rip), %rax      # 0x7ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2190
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x2500(%rip), %rsi      # 0x5d56
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rdi
callq 0x1e60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3873
jmp 0x38d4
jmp 0x3875
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1eb0
movq %rax, %rdi
callq 0x3e70
movq 0x4767(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x1d5c(%rip), %rsi      # 0x55f7
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2040
cmpb $0x0, %al
jne 0x3875
movq -0x18(%rbp), %rdi
callq 0x3ef0
movq 0x4735(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x24b3(%rip), %rsi      # 0x5d80
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: sonicInit
void sonicInit(void) {
  sonicStream.speed = 1.0;
  sonicStream.volume = 1.0f;
  sonicStream.numInputSamples = 0;;
  sonicStream.numOutputSamples = 0;
  sonicStream.remainingInputToCopy = 0;
  sonicStream.prevPeriod = 0;
  sonicStream.prevMinDiff = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss 0x1d88(%rip), %xmm0     # 0x3004
movss %xmm0, 0x4398(%rip)     # 0x561c
movss 0x1d78(%rip), %xmm0     # 0x3004
movss %xmm0, 0x438c(%rip)     # 0x5620
movl $0x0, 0x4386(%rip)      # 0x5624
movl $0x0, 0x4380(%rip)      # 0x5628
movl $0x0, 0x437a(%rip)      # 0x562c
movl $0x0, 0x4374(%rip)      # 0x5630
movl $0x0, 0x436e(%rip)      # 0x5634
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: sonicFlushStream
void sonicFlushStream(void) {
  int maxRequired = 2 * SONIC_MAX_PERIOD;
  int remainingSamples = sonicStream.numInputSamples;
  float speed = sonicStream.speed;
  int expectedOutputSamples = sonicStream.numOutputSamples + (int)((remainingSamples / speed) + 0.5f);

  memset(sonicStream.inputBuffer + remainingSamples, 0,
      sizeof(short) * (SONIC_INPUT_BUFFER_SIZE - remainingSamples));
  sonicStream.numInputSamples += 2 * maxRequired;
  sonicWriteShortToStream(NULL, 0);
  /* Throw away any extra samples we generated due to the silence we added */
  if (sonicStream.numOutputSamples > expectedOutputSamples) {
    sonicStream.numOutputSamples = expectedOutputSamples;
  }
  /* Empty input buffer */
  sonicStream.numInputSamples = 0;
  sonicStream.remainingInputToCopy = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xf6, -0x4(%rbp)
movl 0x428f(%rip), %eax      # 0x5624
movl %eax, -0x8(%rbp)
movss 0x427c(%rip), %xmm0     # 0x561c
movss %xmm0, -0xc(%rbp)
movl 0x427d(%rip), %eax      # 0x5628
cvtsi2ssl -0x8(%rbp), %xmm0
divss -0xc(%rbp), %xmm0
movss 0x1c4b(%rip), %xmm1     # 0x3008
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movslq -0x8(%rbp), %rax
leaq 0x3cd7(%rip), %rdi      # 0x50ac
shlq %rax
addq %rax, %rdi
movl $0x146, %eax            # imm = 0x146
subl -0x8(%rbp), %eax
movslq %eax, %rdx
shlq %rdx
xorl %esi, %esi
callq 0x1090
movl -0x4(%rbp), %eax
shll %eax
addl 0x4229(%rip), %eax      # 0x5624
movl %eax, 0x4223(%rip)      # 0x5624
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
callq 0x1440
movl 0x4216(%rip), %eax      # 0x5628
cmpl -0x10(%rbp), %eax
jle 0x1420
movl -0x10(%rbp), %eax
movl %eax, 0x4208(%rip)      # 0x5628
movl $0x0, 0x41fa(%rip)      # 0x5624
movl $0x0, 0x41f8(%rip)      # 0x562c
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: addShortSamplesToInputBuffer
static int addShortSamplesToInputBuffer(short *samples,
                                        int numSamples) {
  if (numSamples == 0) {
    return 1;
  }
  memcpy(sonicStream.inputBuffer + sonicStream.numInputSamples,
         samples, numSamples * sizeof(short));
  sonicStream.numInputSamples += numSamples;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x149e
movl $0x1, -0x4(%rbp)
jmp 0x14d8
movslq 0x417f(%rip), %rax      # 0x5624
leaq 0x3c00(%rip), %rdi      # 0x50ac
shlq %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
shlq %rdx
callq 0x10d0
movl -0x14(%rbp), %eax
addl 0x4159(%rip), %eax      # 0x5624
movl %eax, 0x4153(%rip)      # 0x5624
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: processStreamInput
static void processStreamInput(void) {
  int originalNumOutputSamples = sonicStream.numOutputSamples;
  float speed = sonicStream.speed;

  if (speed > 1.00001) {
    changeSpeed(speed);
  } else {
    copyToOutput(sonicStream.inputBuffer, sonicStream.numInputSamples);
    sonicStream.numInputSamples = 0;
  }
  if (sonicStream.volume != 1.0f) {
    /* Adjust output volume. */
    scaleSamples( sonicStream.outputBuffer + originalNumOutputSamples,
        (sonicStream.numOutputSamples - originalNumOutputSamples), sonicStream.volume);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x412a(%rip), %eax      # 0x5628
movl %eax, -0x4(%rbp)
movss 0x4113(%rip), %xmm0     # 0x561c
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1af9(%rip), %xmm1     # 0x3018
ucomisd %xmm1, %xmm0
jbe 0x1531
movss -0x8(%rbp), %xmm0
callq 0x15a0
jmp 0x154d
movl 0x40ed(%rip), %esi      # 0x5624
leaq 0x3b6e(%rip), %rdi      # 0x50ac
callq 0x1660
movl $0x0, 0x40d7(%rip)      # 0x5624
movss 0x40cb(%rip), %xmm0     # 0x5620
movss 0x1aa7(%rip), %xmm1     # 0x3004
ucomiss %xmm1, %xmm0
jne 0x1566
jp 0x1566
jmp 0x1594
movslq -0x4(%rbp), %rax
leaq 0x3b3b(%rip), %rdi      # 0x50ac
addq $0x28c, %rdi            # imm = 0x28C
shlq %rax
addq %rax, %rdi
movl 0x40a4(%rip), %esi      # 0x5628
subl -0x4(%rbp), %esi
movss 0x4091(%rip), %xmm0     # 0x5620
callq 0x16b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: changeSpeed
static void changeSpeed(float speed) {
  short *samples;
  int numSamples = sonicStream.numInputSamples;
  int position = 0, period, newSamples;
  int maxRequired = 2 * SONIC_MAX_PERIOD;

  /* printf("Changing speed to %f\n", speed); */
  if (sonicStream.numInputSamples < maxRequired) {
    return;
  }
  do {
    if (sonicStream.remainingInputToCopy > 0) {
      newSamples = copyInputToOutput(position);
      position += newSamples;
    } else {
      samples = sonicStream.inputBuffer + position;
      period = findPitchPeriod(samples, 1);
      newSamples = skipPitchPeriod(samples, speed, period);
      position += period + newSamples;
    }
  } while (position + maxRequired <= numSamples);
  removeInputSamples(position);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x4(%rbp)
movl 0x4071(%rip), %eax      # 0x5624
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0xf6, -0x24(%rbp)
movl 0x405a(%rip), %eax      # 0x5624
cmpl -0x24(%rbp), %eax
jge 0x15d1
jmp 0x164d
jmp 0x15d3
cmpl $0x0, 0x4052(%rip)      # 0x562c
jle 0x15f2
movl -0x18(%rbp), %edi
callq 0x1760
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1638
movslq -0x18(%rbp), %rcx
leaq 0x3aaf(%rip), %rax      # 0x50ac
shlq %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x17c0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movss -0x4(%rbp), %xmm0
movl -0x1c(%rbp), %esi
callq 0x18b0
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x163a
movl -0x18(%rbp), %eax
addl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x15d3
movl -0x18(%rbp), %edi
callq 0x1990
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: scaleSamples
static void scaleSamples(short *samples, int numSamples, float volume) {
  /* This is 24-bit integer and 8-bit fraction fixed-point representation. */
  int fixedPointVolume;
  int value;

  if (volume > 127.0) {
    volume = 127.0;
  }
  fixedPointVolume = volume * 256.0f;
  while (numSamples--) {
    value = (*samples * fixedPointVolume) >> 8;
    if (value > 32767) {
      value = 32767;
    } else if (value < -32767) {
      value = -32767;
    }
    *samples++ = value;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x194f(%rip), %xmm1     # 0x3020
ucomisd %xmm1, %xmm0
jbe 0x16e4
movss 0x192d(%rip), %xmm0     # 0x300c
movss %xmm0, -0x10(%rbp)
movss 0x1924(%rip), %xmm0     # 0x3010
mulss -0x10(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x1757
movq -0x8(%rbp), %rax
movswl (%rax), %eax
imull -0x14(%rbp), %eax
sarl $0x8, %eax
movl %eax, -0x18(%rbp)
cmpl $0x7fff, -0x18(%rbp)    # imm = 0x7FFF
jle 0x172b
movl $0x7fff, -0x18(%rbp)    # imm = 0x7FFF
jmp 0x173d
cmpl $0xffff8001, -0x18(%rbp) # imm = 0xFFFF8001
jge 0x173b
movl $0xffff8001, -0x18(%rbp) # imm = 0xFFFF8001
jmp 0x173d
movl -0x18(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x8(%rbp)
movw %cx, (%rax)
jmp 0x16f8
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: copyInputToOutput
static int copyInputToOutput(int position) {
  int numSamples = sonicStream.remainingInputToCopy;

  if (numSamples > 2 * SONIC_MAX_PERIOD) {
    numSamples = 2 * SONIC_MAX_PERIOD;
  }
  copyToOutput(sonicStream.inputBuffer + position, numSamples);
  sonicStream.remainingInputToCopy -= numSamples;
  return numSamples;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x3ebb(%rip), %eax      # 0x562c
movl %eax, -0x8(%rbp)
cmpl $0xf6, -0x8(%rbp)
jle 0x1784
movl $0xf6, -0x8(%rbp)
movslq -0x4(%rbp), %rax
leaq 0x391d(%rip), %rdi      # 0x50ac
shlq %rax
addq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1660
movl -0x8(%rbp), %ecx
movl 0x3e86(%rip), %eax      # 0x562c
subl %ecx, %eax
movl %eax, 0x3e7e(%rip)      # 0x562c
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: findPitchPeriod
static int findPitchPeriod(short *samples, int preferNewPeriod) {
  int minPeriod = SONIC_MIN_PERIOD;
  int maxPeriod = SONIC_MAX_PERIOD;
  int minDiff, maxDiff, retPeriod;
  int period;

  if (SONIC_SKIP == 1) {
    period = findPitchPeriodInRange(samples, minPeriod, maxPeriod, &minDiff, &maxDiff);
  } else {
    downSampleInput(samples);
    period = findPitchPeriodInRange(sonicStream.downSampleBuffer, minPeriod / SONIC_SKIP,
                                    maxPeriod / SONIC_SKIP, &minDiff, &maxDiff);
    period *= SONIC_SKIP;
    minPeriod = period - (SONIC_SKIP << 2);
    maxPeriod = period + (SONIC_SKIP << 2);
    if (minPeriod < SONIC_MIN_PERIOD) {
      minPeriod = SONIC_MIN_PERIOD;
    }
    if (maxPeriod > SONIC_MAX_PERIOD) {
      maxPeriod = SONIC_MAX_PERIOD;
    }
    period = findPitchPeriodInRange(samples, minPeriod, maxPeriod, &minDiff, &maxDiff);
  }
  if (prevPeriodBetter(minDiff, maxDiff, preferNewPeriod)) {
    retPeriod = sonicStream.prevPeriod;
  } else {
    retPeriod = period;
  }
  sonicStream.prevMinDiff = minDiff;
  sonicStream.prevPeriod = period;
  return retPeriod;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x14, -0x10(%rbp)
movl $0x7b, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x19e0
movl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
leaq 0x38a5(%rip), %rdi      # 0x50ac
addq $0x478, %rdi            # imm = 0x478
leaq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %r8
callq 0x1a80
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x14(%rbp)
cmpl $0x14, -0x10(%rbp)
jge 0x1845
movl $0x14, -0x10(%rbp)
cmpl $0x7b, -0x14(%rbp)
jle 0x1852
movl $0x7b, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %r8
callq 0x1a80
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %edi
movl -0x1c(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x1c10
cmpl $0x0, %eax
je 0x188a
movl 0x3dab(%rip), %eax      # 0x5630
movl %eax, -0x20(%rbp)
jmp 0x1890
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, 0x3d9b(%rip)      # 0x5634
movl -0x24(%rbp), %eax
movl %eax, 0x3d8e(%rip)      # 0x5630
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: skipPitchPeriod
static int skipPitchPeriod(short *samples, float speed, int period) {
  long newSamples;

  if (speed >= 2.0f) {
    newSamples = period / (speed - 1.0f);
  } else {
    newSamples = period;
    sonicStream.remainingInputToCopy = period * (2.0f - speed) / (speed - 1.0f);
  }
  overlapAdd(newSamples, sonicStream.outputBuffer + sonicStream.numOutputSamples,
      samples, samples + period);
  sonicStream.numOutputSamples += newSamples;
  return newSamples;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movss -0xc(%rbp), %xmm0
movss 0x1743(%rip), %xmm1     # 0x3014
ucomiss %xmm1, %xmm0
jb 0x18fb
cvtsi2ssl -0x10(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
movss 0x171c(%rip), %xmm2     # 0x3004
subss %xmm2, %xmm1
divss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movq %rax, -0x18(%rbp)
jmp 0x1938
movslq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cvtsi2ssl -0x10(%rbp), %xmm0
movss 0x1704(%rip), %xmm1     # 0x3014
subss -0xc(%rbp), %xmm1
mulss %xmm1, %xmm0
movss -0xc(%rbp), %xmm1
movss 0x16de(%rip), %xmm2     # 0x3004
subss %xmm2, %xmm1
divss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x3cf4(%rip)      # 0x562c
movq -0x18(%rbp), %rax
movl %eax, %edi
movslq 0x3ce3(%rip), %rax      # 0x5628
leaq 0x3760(%rip), %rsi      # 0x50ac
addq $0x28c, %rsi            # imm = 0x28C
shlq %rax
addq %rax, %rsi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rax
shlq %rax
addq %rax, %rcx
callq 0x1c90
movq -0x18(%rbp), %rcx
movslq 0x3cad(%rip), %rax      # 0x5628
addq %rcx, %rax
movl %eax, 0x3ca4(%rip)      # 0x5628
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/waywardgeek[P]sonic/sonic_lite.c
// Function: removeInputSamples
static void removeInputSamples(int position) {
  int remainingSamples = sonicStream.numInputSamples - position;

  if (remainingSamples > 0) {
    memmove(sonicStream.inputBuffer,
            sonicStream.inputBuffer + position,
            remainingSamples * sizeof(short));
  }
  sonicStream.numInputSamples = remainingSamples;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x3c83(%rip), %eax      # 0x5624
subl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x19d1
movslq -0x4(%rbp), %rax
leaq 0x36f4(%rip), %rsi      # 0x50ac
shlq %rax
addq %rax, %rsi
movslq -0x8(%rbp), %rdx
shlq %rdx
leaq 0x36e0(%rip), %rdi      # 0x50ac
callq 0x10f0
movl -0x8(%rbp), %eax
movl %eax, 0x3c4a(%rip)      # 0x5624
addq $0x10, %rsp
popq %rbp
retq