LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_copy
obvector * obvector_copy(const obvector *to_copy){

  uint32_t i;
  obvector *new_vec;

  /* if there is nothing to copy, do nothing */
  assert(to_copy);

  new_vec = obvector_create_default(to_copy->capacity);
  new_vec->length = to_copy->length;

  for(i=0; i<to_copy->capacity; i++){
    ob_retain(to_copy->array[i]);
    new_vec->array[i] = to_copy->array[i];
  }

  return new_vec;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1f01
movq %rdi, %rbx
movl 0x14(%rdi), %edi
callq 0x1df4
movq %rax, %r14
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r14)
cmpl $0x0, 0x14(%rbx)
je 0x1ef8
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2b3f
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movl 0x14(%rbx), %eax
cmpq %rax, %r15
jb 0x1ed0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1928(%rip), %rdi      # 0x3830
leaq 0x1929(%rip), %rsi      # 0x3838
leaq 0x1939(%rip), %rcx      # 0x384f
movl $0x21, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_store_at_index
void obvector_store_at_index(obvector *v, obj *to_store, int64_t index){

  assert(v != NULL);

  /* if negatively indexing, index from the end of the array backwards */
  if(index < 0) index += v->length;

  assert(index < UINT32_MAX); /* assert not indexing beyond capacity */
  assert(index >= 0); /* assert not negative indexing after offset */

  /* ensure vector can store element at index */
  obvector_resize(v, (uint32_t)index);

  ob_retain(to_store);
  ob_release(v->array[index]);
  v->array[index] = to_store;

  /* find vector length if modifying beyond known length */
  if(index+1 >= v->length)
    v->length = obvector_find_valid_precursor(v->array, index) + 1;

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1ff0
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
js 0x1f8e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
jb 0x1f97
leaq 0x1971(%rip), %rdi      # 0x38e7
leaq 0x18bb(%rip), %rsi      # 0x3838
leaq 0x192a(%rip), %rcx      # 0x38ae
movl $0x3c, %edx
callq 0x1060
movl 0x10(%r14), %eax
addq %rax, %rbx
js 0x200f
movq %r14, %rdi
movl %ebx, %esi
callq 0x202e
movq %r15, %rdi
callq 0x2b3f
movq 0x8(%r14), %rax
movq (%rax,%rbx,8), %rdi
callq 0x2b0a
movq 0x8(%r14), %rax
movq %r15, (%rax,%rbx,8)
movq %rbx, %rax
incq %rax
movl 0x10(%r14), %ecx
cmpq %rcx, %rax
jb 0x1fea
movq 0x8(%r14), %rax
movl %ebx, %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1fe4
addl $-0x1, %ebx
jb 0x1fd1
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
incl %ebx
movl %ebx, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1882(%rip), %rdi      # 0x3879
leaq 0x183a(%rip), %rsi      # 0x3838
leaq 0x18a9(%rip), %rcx      # 0x38ae
movl $0x37, %edx
callq 0x1060
leaq 0x18e4(%rip), %rdi      # 0x38fa
leaq 0x181b(%rip), %rsi      # 0x3838
leaq 0x188a(%rip), %rcx      # 0x38ae
movl $0x3d, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_resize
void obvector_resize(obvector *v, uint32_t index){

  uint32_t i;
  uint64_t new_cap;
  obj **array;

  assert(index < UINT32_MAX);

  if(index < v->capacity) return;

  /* find the next power of two capacity that can store the index */
  new_cap = v->capacity;
  while(index+1 > new_cap) new_cap *= 2;
  if(new_cap > UINT32_MAX) new_cap = UINT32_MAX;

  array = malloc(new_cap*sizeof(obj *));

  assert(array != NULL);
  for(i=0; i<v->capacity; i++) array[i] = v->array[i];
  for(i=v->capacity; i<new_cap; i++) array[i] = NULL;

  free(v->array);
  v->array = array;
  v->capacity = new_cap;

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $-0x1, %esi
je 0x2165
movq %rdi, %rbx
movl 0x14(%rdi), %r12d
cmpl %esi, %r12d
ja 0x2159
incl %esi
movq %r12, %rcx
movq %rcx, %rax
addq %rcx, %rcx
cmpq %rsi, %rax
jb 0x2054
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpq %r15, %rax
cmovbq %rax, %r15
leaq (,%r15,8), %rdi
callq 0x10c0
testq %rax, %rax
je 0x2184
movq %rax, %r14
testq %r12, %r12
je 0x20a0
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq %rdx, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %r12
jne 0x2090
movq %r15, %rcx
subq %r12, %rcx
jbe 0x2148
leaq 0x1(%rcx), %rax
andq $-0x2, %rax
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq (%r14,%r12,8), %rcx
addq $0x8, %rcx
xorl %edx, %edx
movdqa 0x173d(%rip), %xmm1     # 0x3810
movdqa 0x1745(%rip), %xmm2     # 0x3820
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6     # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4     # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x2128
movq $0x0, -0x8(%rcx,%rdx,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x213f
movq $0x0, (%rcx,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rax
jne 0x20e3
movq 0x8(%rbx), %rdi
callq 0x1030
movq %r14, 0x8(%rbx)
movl %r15d, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x177b(%rip), %rdi      # 0x38e7
leaq 0x16c5(%rip), %rsi      # 0x3838
leaq 0x1994(%rip), %rcx      # 0x3b0e
movl $0xd1, %edx
callq 0x1060
leaq 0x1975(%rip), %rdi      # 0x3b00
leaq 0x16a6(%rip), %rsi      # 0x3838
leaq 0x1975(%rip), %rcx      # 0x3b0e
movl $0xdc, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_obj_at_index
obj * obvector_obj_at_index(const obvector *v, int64_t index){

  assert(v != NULL);

  /* if negatively indexing, index from the end of the array backwards */
  if(index < 0) index += v->length;
  assert(index < UINT32_MAX); /* assert not indexing beyond capacity */
  assert(index >= 0); /* assert not negative indexing beyond 0 index */

  if(index < v->length) return v->array[index];
  return NULL;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x21f4
testq %rsi, %rsi
js 0x21d9
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpq %rax, %rsi
ja 0x2213
movl 0x10(%rdi), %eax
jmp 0x21e1
movl 0x10(%rdi), %eax
addq %rax, %rsi
js 0x2232
cmpq %rax, %rsi
jae 0x21f0
movq 0x8(%rdi), %rax
movq (%rax,%rsi,8), %rax
jmp 0x21f2
xorl %eax, %eax
popq %rcx
retq
leaq 0x167e(%rip), %rdi      # 0x3879
leaq 0x1636(%rip), %rsi      # 0x3838
leaq 0x16fc(%rip), %rcx      # 0x3905
movl $0x50, %edx
callq 0x1060
leaq 0x16cd(%rip), %rdi      # 0x38e7
leaq 0x1617(%rip), %rsi      # 0x3838
leaq 0x16dd(%rip), %rcx      # 0x3905
movl $0x54, %edx
callq 0x1060
leaq 0x16c1(%rip), %rdi      # 0x38fa
leaq 0x15f8(%rip), %rsi      # 0x3838
leaq 0x16be(%rip), %rcx      # 0x3905
movl $0x55, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_concat
void obvector_concat(obvector *destination, obvector *to_append){

  uint64_t i;

  assert(destination != NULL);
  assert(to_append != NULL);
  /* make sure that the two vectors will not overflow when concatenated */
  assert(destination->length + to_append->length >= destination->length);

  /* ensure vector can store all elements in to_append */
  obvector_resize(destination, destination->length + to_append->length - 1);

  /* copy contents of to_append */
  for(i=0; i<to_append->length; i++){
    ob_retain((obj *)to_append->array[i]);
    destination->array[i+destination->length] = to_append->array[i];
  }

  destination->length += to_append->length;

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x22d1
movq %rsi, %r14
testq %rsi, %rsi
je 0x22f0
movq %rdi, %rbx
movl 0x10(%r14), %esi
addl 0x10(%rdi), %esi
jb 0x230f
decl %esi
movq %rbx, %rdi
callq 0x202e
cmpl $0x0, 0x10(%r14)
je 0x22c1
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x2b3f
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rcx
movl 0x10(%rbx), %eax
leaq (,%rax,8), %rdx
addq 0x8(%rbx), %rdx
movq %rcx, (%rdx,%r15,8)
incq %r15
movl 0x10(%r14), %ecx
cmpq %rcx, %r15
jb 0x228b
jmp 0x22c6
movl 0x10(%rbx), %eax
xorl %ecx, %ecx
addl %ecx, %eax
movl %eax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1663(%rip), %rdi      # 0x393b
leaq 0x1559(%rip), %rsi      # 0x3838
leaq 0x1669(%rip), %rcx      # 0x394f
movl $0x60, %edx
callq 0x1060
leaq 0x1685(%rip), %rdi      # 0x397c
leaq 0x153a(%rip), %rsi      # 0x3838
leaq 0x164a(%rip), %rcx      # 0x394f
movl $0x61, %edx
callq 0x1060
leaq 0x1678(%rip), %rdi      # 0x398e
leaq 0x151b(%rip), %rsi      # 0x3838
leaq 0x162b(%rip), %rcx      # 0x394f
movl $0x63, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_find_obj
uint8_t obvector_find_obj(const obvector *v, const obj *to_find){

  uint32_t i;

  assert(v != NULL);
  assert(to_find != NULL);

  for(i=0; i<v->length; i++){
    /* if the object exists in the vector */
    if(ob_compare(to_find, v->array[i]) == OB_EQUAL_TO){
      return 1;
    }
  }

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2378
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2397
movq %rdi, %r14
cmpl $0x0, 0x10(%rdi)
je 0x236c
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x2a87
testb %al, %al
je 0x2370
incq %r15
movl 0x10(%r14), %eax
cmpq %rax, %r15
jb 0x234c
xorl %eax, %eax
jmp 0x2372
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
leaq 0x14fa(%rip), %rdi      # 0x3879
leaq 0x14b2(%rip), %rsi      # 0x3838
leaq 0x1640(%rip), %rcx      # 0x39cd
movl $0x78, %edx
callq 0x1060
leaq 0x1668(%rip), %rdi      # 0x3a06
leaq 0x1493(%rip), %rsi      # 0x3838
leaq 0x1621(%rip), %rcx      # 0x39cd
movl $0x79, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_sort_with_funct
void obvector_sort_with_funct(obvector *v, int8_t order, ob_compare_fptr funct){

  obj **sorted;

  assert(v != NULL);
  assert(funct != NULL);
  assert(order == OB_LEAST_TO_GREATEST || order == OB_GREATEST_TO_LEAST);

  sorted = obvector_recursive_sort(v->array, v->capacity, order, funct);

  free(v->array);
  v->array = sorted;
  v->length = obvector_find_valid_precursor(v->array, v->length-1) + 1;

  return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x242a
movq %rdx, %rcx
testq %rdx, %rdx
je 0x2449
movq %rdi, %rbx
movsbl %sil, %edx
cmpl $-0x1, %edx
je 0x23e8
cmpl $0x1, %edx
jne 0x2468
movq 0x8(%rbx), %rdi
movl 0x14(%rbx), %esi
callq 0x2487
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x1030
movq %r14, 0x8(%rbx)
movl 0x10(%rbx), %ecx
xorl %eax, %eax
testq %rcx, %rcx
je 0x241f
cmpq $0x0, -0x8(%r14,%rcx,8)
jne 0x241d
decq %rcx
jne 0x240e
jmp 0x241f
movl %ecx, %eax
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1448(%rip), %rdi      # 0x3879
leaq 0x1400(%rip), %rsi      # 0x3838
leaq 0x15d7(%rip), %rcx      # 0x3a16
movl $0x8f, %edx
callq 0x1060
leaq 0x1609(%rip), %rdi      # 0x3a59
leaq 0x13e1(%rip), %rsi      # 0x3838
leaq 0x15b8(%rip), %rcx      # 0x3a16
movl $0x90, %edx
callq 0x1060
leaq 0x15f8(%rip), %rdi      # 0x3a67
leaq 0x13c2(%rip), %rsi      # 0x3838
leaq 0x1599(%rip), %rcx      # 0x3a16
movl $0x91, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_clear
void obvector_clear(obvector *v){

  uint32_t i;

  assert(v != NULL);

  for(i=0; i<v->capacity; i++){
    ob_release(v->array[i]);
  }

  v->length = 0;

  return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2676
movq %rdi, %rbx
cmpl $0x0, 0x14(%rdi)
je 0x2667
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2b0a
incq %r14
movl 0x14(%rbx), %eax
cmpq %rax, %r14
jb 0x264f
movl $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x11fc(%rip), %rdi      # 0x3879
leaq 0x11b4(%rip), %rsi      # 0x3838
leaq 0x141b(%rip), %rcx      # 0x3aa6
movl $0xa1, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_destroy
void obvector_destroy(obj *to_dealloc){

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

  assert(instance != NULL);
  assert(ob_has_class(to_dealloc, "obvector"));

  obvector_clear(instance); /* ob_release all objs contained in vector */
  free(instance->array);

  return;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x26c0
movq %rdi, %rbx
leaq 0x1670(%rip), %rsi      # 0x3d15
callq 0x2b84
testb %al, %al
je 0x26df
movq %rbx, %rdi
callq 0x263a
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x1030
leaq 0xfb1(%rip), %rdi       # 0x3678
leaq 0x116a(%rip), %rsi      # 0x3838
leaq 0x15fe(%rip), %rcx      # 0x3cd3
movl $0x17b, %edx            # imm = 0x17B
callq 0x1060
leaq 0x160a(%rip), %rdi      # 0x3cf0
leaq 0x114b(%rip), %rsi      # 0x3838
leaq 0x15df(%rip), %rcx      # 0x3cd3
movl $0x17c, %edx            # imm = 0x17C
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_hash
ob_hash_t obvector_hash(const obj *to_hash){

  static int8_t init = 0;
  static ob_hash_t seed;

  uint32_t i;
  ob_hash_t value;
  obvector *instance = (obvector *)to_hash;

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

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

  value = seed;
  for(i=0; i<instance->length; i++){
    value += ob_hash(instance->array[i]);
    value += value << 10;
    value ^= value >> 6;
  }

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

  return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x27af
movq %rdi, %rbx
leaq 0x15ff(%rip), %rsi      # 0x3d15
callq 0x2b84
testb %al, %al
je 0x27ce
cmpb $0x1, 0x396e(%rip)      # 0x6098
jne 0x2735
movq 0x396d(%rip), %r14      # 0x60a0
jmp 0x2759
xorl %edi, %edi
callq 0x10b0
movl %eax, %edi
callq 0x1080
callq 0x10f0
movslq %eax, %r14
movq %r14, 0x394e(%rip)      # 0x60a0
movb $0x1, 0x393f(%rip)      # 0x6098
cmpl $0x0, 0x10(%rbx)
je 0x2791
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2a48
addq %r14, %rax
movq %rax, %rcx
shlq $0xa, %rcx
addq %rax, %rcx
movq %rcx, %r14
shrq $0x6, %r14
xorq %rcx, %r14
incq %r15
movl 0x10(%rbx), %eax
cmpq %rax, %r15
jb 0x2762
leaq (%r14,%r14,8), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
movq %rcx, %rax
shlq $0xf, %rax
addq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xf2c(%rip), %rdi       # 0x36e2
leaq 0x107b(%rip), %rsi      # 0x3838
leaq 0x13cd(%rip), %rcx      # 0x3b91
movl $0x135, %edx            # imm = 0x135
callq 0x1060
leaq 0x13e1(%rip), %rdi      # 0x3bb6
leaq 0x105c(%rip), %rsi      # 0x3838
leaq 0x13ae(%rip), %rcx      # 0x3b91
movl $0x136, %edx            # imm = 0x136
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_compare
int8_t obvector_compare(const obj *a, const obj *b){

  uint32_t i;
  const obvector *comp_a = (obvector *)a;
  const obvector *comp_b = (obvector *)b;

  assert(a);
  assert(b);
  assert(ob_has_class(a, "obvector"));
  assert(ob_has_class(b, "obvector"));

  if(comp_a->length != comp_b->length) return OB_NOT_EQUAL;

  for(i=0; i<comp_a->length; i++)
    if(ob_compare(comp_a->array[i], comp_b->array[i]) != OB_EQUAL_TO)
      return OB_NOT_EQUAL;

  return OB_EQUAL_TO;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x287e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x289d
movq %rdi, %r14
leaq 0x1502(%rip), %rsi      # 0x3d15
callq 0x2b84
testb %al, %al
je 0x28bc
leaq 0x14ee(%rip), %rsi      # 0x3d15
movq %rbx, %rdi
callq 0x2b84
testb %al, %al
je 0x28db
movl 0x10(%r14), %eax
movb $0x2, %bpl
cmpl 0x10(%rbx), %eax
jne 0x2871
testl %eax, %eax
je 0x286f
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
callq 0x2a87
testb %al, %al
jne 0x2871
incq %r15
movl 0x10(%r14), %eax
cmpq %rax, %r15
jb 0x284a
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1353(%rip), %rdi      # 0x3bd8
leaq 0xfac(%rip), %rsi       # 0x3838
leaq 0x1347(%rip), %rcx      # 0x3bda
movl $0x153, %edx            # imm = 0x153
callq 0x1060
leaq 0x1368(%rip), %rdi      # 0x3c0c
leaq 0xf8d(%rip), %rsi       # 0x3838
leaq 0x1328(%rip), %rcx      # 0x3bda
movl $0x154, %edx            # imm = 0x154
callq 0x1060
leaq 0x134b(%rip), %rdi      # 0x3c0e
leaq 0xf6e(%rip), %rsi       # 0x3838
leaq 0x1309(%rip), %rcx      # 0x3bda
movl $0x155, %edx            # imm = 0x155
callq 0x1060
leaq 0x1348(%rip), %rdi      # 0x3c2a
leaq 0xf4f(%rip), %rsi       # 0x3838
leaq 0x12ea(%rip), %rcx      # 0x3bda
movl $0x156, %edx            # imm = 0x156
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_display
void obvector_display(const obj *to_print){

  uint32_t i;
  obvector *v = (obvector *)to_print;

  assert(to_print != NULL);
  assert(ob_has_class(to_print, "obvector"));
  fprintf(stderr, "obvector with %u elements\n", v->length);

  for(i=0; i<v->length; i++){
    fprintf(stderr, "[index: %u]\n", i);
    ob_display(v->array[i]);
    fprintf(stderr, "\n");
  }

  fprintf(stderr, "[vector end]\n");
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x291d
movq %rdi, %rbx
leaq 0x140b(%rip), %rsi      # 0x3d15
callq 0x2b84
testb %al, %al
je 0x293c
movq %rbx, %rdi
callq 0x144c
popq %rbx
retq
leaq 0x1322(%rip), %rdi      # 0x3c46
leaq 0xf0d(%rip), %rsi       # 0x3838
leaq 0x1325(%rip), %rcx      # 0x3c57
movl $0x167, %edx            # imm = 0x167
callq 0x1060
leaq 0x1337(%rip), %rdi      # 0x3c7a
leaq 0xeee(%rip), %rsi       # 0x3838
leaq 0x1306(%rip), %rcx      # 0x3c57
movl $0x168, %edx            # imm = 0x168
callq 0x1060
nop
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/offbrand_stdlib.c
// Function: ob_init_base
void ob_init_base(obj *instance, ob_dealloc_fptr dealloc_funct,
                  ob_hash_fptr hash_funct, ob_compare_fptr compare_funct,
                  ob_display_fptr display_funct, const char *classname){

  assert(classname != NULL);

  *instance = malloc(sizeof(struct obj_struct));

  assert((*instance) != NULL);

  (*instance)->references = 1;

  (*instance)->dealloc = dealloc_funct;

  if(hash_funct != &ob_hash) (*instance)->hash = hash_funct;
  else (*instance)->hash = NULL;

  if(compare_funct != &ob_compare) (*instance)->compare = compare_funct;
  else (*instance)->compare = NULL;

  if(display_funct != &ob_display) (*instance)->display = display_funct;
  else (*instance)->display = NULL;

  (*instance)->classname = classname;

  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %r9, %r9
je 0x2a0a
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbp
movl $0x30, %edi
callq 0x10c0
movq %rax, (%rbp)
testq %rax, %rax
je 0x2a29
movl $0x1, (%rax)
movq %r13, 0x8(%rax)
movq %r12, %xmm0
movq %r15, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
leaq 0xcf(%rip), %rcx        # 0x2a87
movq %rcx, %xmm0
leaq 0x84(%rip), %rcx        # 0x2a48
movq %rcx, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pcmpeqd %xmm1, %xmm2
pshufd $0xb1, %xmm2, %xmm0     # xmm0 = xmm2[1,0,3,2]
pand %xmm2, %xmm0
pandn %xmm1, %xmm0
movdqu %xmm0, 0x10(%rax)
leaq 0xff(%rip), %rcx        # 0x2ae9
xorl %edx, %edx
cmpq %rcx, %r14
cmovneq %r14, %rdx
movq %rdx, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x130d(%rip), %rdi      # 0x3d1e
leaq 0x1318(%rip), %rsi      # 0x3d30
leaq 0x1327(%rip), %rcx      # 0x3d46
movl $0xe, %edx
callq 0x1060
leaq 0x137e(%rip), %rdi      # 0x3dae
leaq 0x12f9(%rip), %rsi      # 0x3d30
leaq 0x1308(%rip), %rcx      # 0x3d46
movl $0x12, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/offbrand_stdlib.c
// Function: ob_hash
ob_hash_t ob_hash(const obj *to_hash){

  ob_hash_t retval;

  if(!to_hash) return 0;

  if((*to_hash)->hash) retval = (*to_hash)->hash(to_hash);
  else{
    retval = (ob_hash_t)to_hash;
    retval += (retval << 6);
    retval ^= (retval >> 10);
    retval += (retval >> 7);
    retval ^= (retval << 12);
  }

  return retval;
}

// Assembly:
testq %rdi, %rdi
je 0x2a5b
movq (%rdi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2a5e
jmpq *%rax
xorl %eax, %eax
retq
movq %rdi, %rax
shlq $0x6, %rax
addq %rdi, %rax
movq %rax, %rcx
shrq $0xa, %rcx
xorq %rax, %rcx
movq %rcx, %rdx
shrq $0x7, %rdx
addq %rcx, %rdx
movq %rdx, %rax
shlq $0xc, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/offbrand_stdlib.c
// Function: ob_compare
int8_t ob_compare(const obj *a, const obj *b){

  int8_t retval;

  if(a == NULL && b == NULL) return OB_EQUAL_TO;
  else if(a == NULL || b == NULL) return OB_NOT_EQUAL;


  if(ob_has_same_class(a, b) && (*a)->compare != NULL)
    retval = (*a)->compare(a, b);
  else if(a == b) retval = OB_EQUAL_TO;
  else retval = OB_NOT_EQUAL;

  return retval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rax
orq %rsi, %rax
jne 0x2a97
xorl %eax, %eax
jmp 0x2ae1
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
movb $0x2, %al
jne 0x2ae1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2bac
testb %al, %al
je 0x2ad9
movq (%r14), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x2ad9
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
cmpq %rbx, %r14
setne %al
addb %al, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/offbrand_stdlib.c
// Function: ob_display
void ob_display(const obj *to_print){
  if(!to_print){
    fprintf(stderr, "NULL value\n");
    return;
  }

  fprintf(stderr, "Instance of class %s, at address 0x%p\n",
                  (*to_print)->classname, to_print);
  if((*to_print)->display) (*to_print)->display(to_print);
}

// Assembly:
pushq %rax
movq 0x3507(%rip), %rax      # 0x5ff8
movq (%rax), %rsi
testq %rdi, %rdi
jne 0x2b03
movq %rsi, %rdi
callq 0x150e
jmp 0x2b08
callq 0x14d8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/offbrand_stdlib.c
// Function: ob_release
obj * ob_release(obj *instance){

  if(!instance) return NULL;

  /* if no other part of the program references the instance, destroy it */
  if(--((*instance)->references) <= 0){

    /* call class specific memory cleanup, if it exists */
    if((*instance)->dealloc)
      (*instance)->dealloc(instance);

    free((struct obj_struct *)*instance); /* free reference counted base */
    free(instance); /* free the entire object */

    return NULL;
  }

  return instance;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2b38
movq %rdi, %rbx
movq (%rdi), %rdi
decl (%rdi)
jne 0x2b3a
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2b2b
movq %rbx, %rdi
callq *%rax
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/offbrand_stdlib.c
// Function: ob_retain
obj * ob_retain(obj *instance){

  if(!instance) return instance;

  assert((*instance)->references < UINT32_MAX); /* reference count > UINT32_MAX
                                                   cannot be handled by lib */
  ++((*instance)->references);

  return instance;
}

// Assembly:
testq %rdi, %rdi
je 0x2b52
movq (%rdi), %rax
movl (%rax), %ecx
cmpl $-0x1, %ecx
je 0x2b56
incl %ecx
movl %ecx, (%rax)
movq %rdi, %rax
retq
pushq %rax
leaq 0x1264(%rip), %rdi      # 0x3dc2
leaq 0x11cb(%rip), %rsi      # 0x3d30
leaq 0x127b(%rip), %rcx      # 0x3de7
movl $0x40, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/offbrand_stdlib.c
// Function: ob_has_class
uint8_t ob_has_class(const obj *a, const char *classname){

  if(!a){
    if(strcmp(classname, "NULL") == 0) return 1;
    return 0;
  }
  if(strcmp((*a)->classname, classname) == 0) return 1;
  else return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2b93
movq (%rdi), %rax
movq 0x28(%rax), %rdi
jmp 0x2ba0
leaq 0x1223(%rip), %rax      # 0x3dbd
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1090
testl %eax, %eax
sete %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/theck01[P]offbrand_lib/src/offbrand_stdlib.c
// Function: ob_has_same_class
uint8_t ob_has_same_class(const obj *a, const obj *b){
  /* if both NULL, both are of the "NULL" class */
  if(!a && !b) return 1;
  else if(!a || !b) return 0;
  return ob_has_class(a, (*b)->classname);
}

// Assembly:
movb $0x1, %al
movq %rdi, %rcx
orq %rsi, %rcx
je 0x2be3
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x2be4
pushq %rax
movq (%rsi), %rax
movq 0x28(%rax), %rsi
movq (%rdi), %rax
movq 0x28(%rax), %rdi
callq 0x1090
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: siguiente_turno()
unsigned int siguiente_turno(){
  int candidato_a_ser_reactivo_en_turno;
  if(cantidad_de_reactivos_usados==NUMDREAC){
    modificado=false;
    return 0;
  }
  if((NUMDREAC-cantidad_de_reactivos_usados)==1){
unsigned int usar_NUMDREAC_buckets();
    if((reactivo_en_turno=usar_NUMDREAC_buckets())>0){
//printf("candidato_a_ser_reactivo_en_turno=%u\n",candidato_a_ser_reactivo_en_turno);
      goto actualizacion;
    }
  }
  if(cantidad_de_reactivos_usados<NUMDREAC){
    srand(time(NULL));
    candidato_a_ser_reactivo_en_turno=1+rand()%NUMDREAC;
bool asignado(unsigned int);
    while(asignado(candidato_a_ser_reactivo_en_turno)){
      candidato_a_ser_reactivo_en_turno=1+rand()%NUMDREAC;
    }
    reactivo_en_turno=candidato_a_ser_reactivo_en_turno;
    assert(reactivo_en_turno<=NUMDREAC);
void actualizar_reactivos_usados(unsigned int);
actualizacion:
    actualizar_reactivos_usados(reactivo_en_turno);
  }
  return reactivo_en_turno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x450b(%rip), %rbx      # 0x6970
movl (%rbx), %eax
cmpl $0x2, %eax
je 0x2482
cmpl $0x3, %eax
jne 0x249c
leaq 0x4508(%rip), %rax      # 0x6980
movb $0x0, (%rax)
xorl %eax, %eax
jmp 0x254d
callq 0x2571
movl %eax, %edi
leaq 0x44f4(%rip), %rax      # 0x6984
movl %edi, (%rax)
testl %edi, %edi
jne 0x253f
jmp 0x24a2
jae 0x2544
xorl %edi, %edi
callq 0x2120
movl %eax, %edi
callq 0x2130
callq 0x2080
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
negl %ecx
leal (%rax,%rcx), %edi
incl %edi
movl (%rbx), %eax
testl %eax, %eax
je 0x2531
leaq 0x4496(%rip), %r14      # 0x6978
movq (%r14), %rcx
cmpl %edi, (%rcx)
je 0x2506
movl %eax, %eax
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x2501
leaq 0x1(%rdx), %rsi
cmpl %edi, (%rcx,%rdx,4)
jne 0x24f0
cmpq %rax, %rdx
jae 0x2531
callq 0x2080
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
negl %ecx
leal (%rax,%rcx), %edi
incl %edi
movl (%rbx), %eax
testl %eax, %eax
jne 0x24e2
leaq 0x444c(%rip), %rax      # 0x6984
movl %edi, (%rax)
cmpl $0x4, %edi
jae 0x2552
callq 0x2602
leaq 0x4439(%rip), %rax      # 0x6984
movl (%rax), %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xab9(%rip), %rdi       # 0x3012
leaq 0xace(%rip), %rsi       # 0x302e
leaq 0xad6(%rip), %rcx       # 0x303d
movl $0x43, %edx
callq 0x20b0
// File: /workspace/github_c_makefile_star2_O3/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: usar_NUMDREAC_buckets()
unsigned int usar_NUMDREAC_buckets()
{
  char bucket[NUMDREAC+1]={0};        /* buckets o cubetas a utilizar */
  int i;
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    bucket[reactivos_usados[i]]=1;
  }
  for(i=1;i<NUMDREAC;i++){
    if(bucket[i]==0){
      return i;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
leaq 0x43ed(%rip), %rax      # 0x6970
movl (%rax), %ecx
movl $0x1, %eax
testq %rcx, %rcx
je 0x25bc
leaq 0x43e2(%rip), %rdx      # 0x6978
movq (%rdx), %rdx
xorl %esi, %esi
movl (%rdx,%rsi,4), %edi
movb $0x1, -0x4(%rbp,%rdi)
incq %rsi
cmpq %rsi, %rcx
jne 0x259b
cmpb $0x0, -0x3(%rbp)
je 0x25bc
xorl %eax, %eax
cmpb $0x0, -0x2(%rbp)
sete %al
addl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: asignado(unsigned int)
bool asignado(unsigned int candidato)
{
  unsigned int i;
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    if(*(reactivos_usados+i)==candidato){
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x43a7(%rip), %rax      # 0x6970
movl (%rax), %ecx
testq %rcx, %rcx
je 0x25fe
leaq 0x43a1(%rip), %rax      # 0x6978
movq (%rax), %rdx
movb $0x1, %al
cmpl %edi, (%rdx)
je 0x2600
movl $0x1, %esi
movq %rsi, %rax
cmpq %rsi, %rcx
je 0x25f6
leaq 0x1(%rax), %rsi
cmpl %edi, (%rdx,%rax,4)
jne 0x25e5
cmpq %rcx, %rax
setb %al
jmp 0x2600
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: actualizar_reactivos_usados(unsigned int)
void actualizar_reactivos_usados(unsigned int reactivo_en_uso)
{
  unsigned int i,*tmp=(unsigned int *)malloc(cantidad_de_reactivos_usados*sizeof(unsigned int));
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    *(tmp+i)=reactivos_usados[i];
  }
  reactivos_usados=(unsigned int *)malloc(
                   (cantidad_de_reactivos_usados+1)*sizeof(unsigned int));
  for(i=0;i<cantidad_de_reactivos_usados;i++){
    reactivos_usados[i]=*(tmp+i);
  }
  reactivos_usados[cantidad_de_reactivos_usados]=reactivo_en_uso;
  cantidad_de_reactivos_usados++;
  modificado=true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, -0x2c(%rbp)
leaq 0x4356(%rip), %rax      # 0x6970
movl (%rax), %r13d
leaq (,%r13,4), %r14
movq %r14, %rdi
callq 0x21c0
movq %rax, %r15
testq %r13, %r13
je 0x264a
leaq 0x433c(%rip), %rax      # 0x6978
movq (%rax), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x20f0
leal 0x1(%r13), %ebx
leaq (,%rbx,4), %rdi
callq 0x21c0
movq %rax, %r12
leaq 0x4313(%rip), %rax      # 0x6978
movq %r12, (%rax)
testq %r13, %r13
je 0x267b
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x20f0
movl -0x2c(%rbp), %eax
movl %eax, (%r12,%r13,4)
leaq 0x42e7(%rip), %rax      # 0x6970
movl %ebx, (%rax)
leaq 0x42ee(%rip), %rax      # 0x6980
movb $0x1, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/test_EvalContinua.c
// Function: main
int main(int argc,char *argv[])
{
  unsigned int indice_de_reactivo,reactivo_index,ret;
  if(argc<2){
    printf("FORMA DE USO:%s <file_index_reactivos_intro>\n",
            argv[0]);
    exit(1);
  }
void run_ctor(char *);
  run_ctor(argv[1]);
unsigned int init_REACTIVO();
   if((ret=init_REACTIVO())==NUMDREAC){
unsigned int siguiente_turno();
     if((reactivo_index=siguiente_turno())>0){
#ifndef NDEBUG
       printf("reactivo_index=%u\n",reactivo_index);
#endif
       indice_de_reactivo=reactivo_index-1;
int show_reactivo(unsigned int);
       show_reactivo(indice_de_reactivo);
void save_reactivos_asignados(unsigned int);
       if(modificado){
         save_reactivos_asignados(reactivo_index);
       }
     }else{ 
       printf("Reactivos YA asignados ...\n");
       return 0;
     }
   }else{
#ifndef NDEBUG
     printf("ret=%u\n",ret);
#endif
     return -1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jle 0x29da
movq 0x8(%rsi), %rdi
callq 0x29f8
callq 0x2c1c
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x3, %eax
jne 0x29d3
callq 0x2457
testl %eax, %eax
je 0x29c5
movl %eax, %r14d
leal -0x1(%r14), %edi
callq 0x23fc
leaq 0x3fcc(%rip), %rax      # 0x6980
xorl %ebx, %ebx
cmpb $0x1, (%rax)
jne 0x29d3
movl %r14d, %edi
callq 0x26a4
jmp 0x29d3
leaq 0x755(%rip), %rdi       # 0x3121
callq 0x2210
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rsi), %rsi
leaq 0x70f(%rip), %rdi       # 0x30f3
xorl %eax, %eax
callq 0x2040
movl $0x1, %edi
callq 0x21a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/ctors.c
// Function: init_REACTIVO()
unsigned int init_REACTIVO()
{
  unsigned int i,j=0;
  FILE *fent;
  int car,res=0;
  char nombre_de_archivo[1024];
  
  for(i=0;i<NUMDREAC;i++){
    sprintf(nombre_de_archivo,"./reactivos/reactivo%d.txt",i+1);
#ifndef NDEBUG
    printf("Abriendo %s\n",nombre_de_archivo);
#endif
    /**Apertura del i-esimo archivo de entrada*/
    fent=fopen(nombre_de_archivo,"r");
    if(fent==NULL){
      fprintf(stderr,"Error abriendo %s\n",nombre_de_archivo);
      return i;
    }
    while((car=fgetc(fent))!=EOF){
      REACTIVO[i][j++]=car;
    }
    j=0;
    /**Cierre del i-esimo archivo*/ 
    fclose(fent);
#ifndef NDEBUG
    printf("%s\n",REACTIVO[i]);
#endif
  }/*end for()*/
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
leaq 0x2539(%rip), %r12      # 0x5170
xorl %ebx, %ebx
leaq 0x1(%rbx), %r13
leaq -0x430(%rbp), %r14
movq %r14, %rdi
leaq 0x4f0(%rip), %rsi       # 0x313e
movl %r13d, %edx
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
leaq 0x4f7(%rip), %rsi       # 0x3159
callq 0x2190
testq %rax, %rax
je 0x2cc7
movq %rax, %r14
movq %rax, %rdi
callq 0x2240
cmpl $-0x1, %eax
je 0x2c9d
xorl %r15d, %r15d
shlq $0xb, %rbx
movl %r15d, %ecx
incl %r15d
leaq (%rbx,%r12), %rdx
movb %al, (%rcx,%rdx)
movq %r14, %rdi
callq 0x2240
cmpl $-0x1, %eax
jne 0x2c83
movq %r14, %rdi
callq 0x2150
movq %r13, %rbx
cmpq $0x3, %r13
jne 0x2c39
movl $0x3, %ebx
movl %ebx, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x230a(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
leaq 0x483(%rip), %rsi       # 0x315b
leaq -0x430(%rbp), %rdx
xorl %eax, %eax
callq 0x21e0
jmp 0x2cb3
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: screen_update
static void screen_update(void)
{
  int i, j;

  erase();

  /* Main cave. */
  for (i = 0; i < CAVE_WIDTH; i++) {
    for (j = 0; j < cave[i].top; j++) {
      mvaddch(j, i, GRAPHICS_CAVE);
    }
    for (j = cave[i].bottom; j < CAVE_HEIGHT; j++) {
      mvaddch(j, i, GRAPHICS_CAVE);
    }
  }

  /* HUD. */
  mvprintw(0, 0, "Score: %5d Ammo: %3d ", score, ammo);

  objects_draw();

  /* Position cursor on player. */
  mvaddch(player_y, player_x, GRAPHICS_PLAYER);
  move(player_y, player_x);

  refresh();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x29c7(%rip), %r14      # 0x3fe0
movq (%r14), %rdi
callq 0x1030
xorl %ebx, %ebx
leaq 0x2ad6(%rip), %r15      # 0x4100
cmpl $0x0, (%r15,%rbx,8)
jle 0x1659
xorl %ebp, %ebp
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x1651
movq (%r14), %rdi
movl $0x23, %esi
callq 0x1150
incl %ebp
cmpl (%r15,%rbx,8), %ebp
jl 0x1633
movl 0x4(%r15,%rbx,8), %ebp
cmpl $0x17, %ebp
jg 0x1688
movq (%r14), %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x1681
movq (%r14), %rdi
movl $0x23, %esi
callq 0x1150
incl %ebp
cmpl $0x18, %ebp
jne 0x1663
incq %rbx
cmpq $0x50, %rbx
jne 0x162a
movl 0x2a65(%rip), %ecx      # 0x40fc
movl 0x2a56(%rip), %r8d      # 0x40f4
leaq 0x999(%rip), %rdx       # 0x203e
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10d0
movq 0x2cc9(%rip), %rbx      # 0x4380
testq %rbx, %rbx
je 0x16e6
cmpl $0x0, 0xc(%rbx)
jne 0x16e0
movq (%r14), %rdi
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %esi
callq 0x1130
cmpl $-0x1, %eax
je 0x16e0
movq (%r14), %rdi
movzbl (%rbx), %esi
callq 0x1150
movq 0x10(%rbx), %rbx
jmp 0x16b7
movq (%r14), %rdi
movl 0x2a01(%rip), %esi      # 0x40f0
movzbl 0x2a02(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %edx
callq 0x1130
cmpl $-0x1, %eax
je 0x1710
movq (%r14), %rdi
movl $0x3e, %esi
callq 0x1150
movq (%r14), %rdi
movl 0x29d7(%rip), %esi      # 0x40f0
movzbl 0x29d8(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %edx
callq 0x1130
movq (%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: object_spawn
static void object_spawn(unsigned char type)
{
  object_t *new, *curr;

  new = (object_t *)malloc(sizeof(object_t));

  if (objects == NULL) {
    objects = new;
  } else {
    for (curr = objects; curr->next != NULL; curr = curr->next)
      ;
    curr->next = new;
  }

  new->type = type;
  new->next = NULL;
  new->removed = 0;

  switch (type) {
  case GRAPHICS_MONEY:
  case GRAPHICS_AMMO:
  case GRAPHICS_ENEMY:
    new->x = CAVE_WIDTH - 1;
    new->y = cave[CAVE_WIDTH - 1].top + 
      (random() % (cave[CAVE_WIDTH - 1].bottom - cave[CAVE_WIDTH - 1].top));
    break;
  case GRAPHICS_SHOT:
    new->x = player_x + 1;
    new->y = player_y;
    break;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x18, %edi
callq 0x1120
movq %rax, %rbx
movq 0x2c2d(%rip), %rcx      # 0x4380
testq %rcx, %rcx
je 0x176a
movq %rcx, %rax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x1758
addq $0x10, %rax
jmp 0x1771
leaq 0x2c0f(%rip), %rax      # 0x4380
movq %rbx, (%rax)
movb %bpl, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0x0, 0xc(%rbx)
movzbl %bpl, %eax
cmpl $0x2c, %eax
jg 0x179b
cmpl $0x24, %eax
je 0x17a5
cmpl $0x2b, %eax
je 0x17a5
jmp 0x17e9
cmpl $0x2d, %eax
je 0x17d1
cmpl $0x40, %eax
jne 0x17e9
movl $0x4f, 0x4(%rbx)
movl 0x2bc6(%rip), %ebp      # 0x4378
callq 0x1100
movslq 0x2bbe(%rip), %rcx      # 0x437c
movslq 0x2bb3(%rip), %rdx      # 0x4378
subq %rdx, %rcx
cqto
idivq %rcx
addl %ebp, %edx
jmp 0x17e6
movzbl 0x2920(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %eax
incl %eax
movl %eax, 0x4(%rbx)
movl 0x290a(%rip), %edx      # 0x40f0
movl %edx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: generate_cave
static void generate_cave(void)
{
  int i;

  /* Shift entire cave. */
  for (i = 0; i < (CAVE_WIDTH - 1); i++) {
    cave[i].top    = cave[i + 1].top;
    cave[i].bottom = cave[i + 1].bottom;
  }

  objects_shift();

  /* Next top. */
  switch (random() % 5) {
  case 0:
    cave[CAVE_WIDTH - 1].top--;
    if (cave[CAVE_WIDTH - 1].top < CAVE_PADDING_TOP) {
      cave[CAVE_WIDTH - 1].top++;
    }
    break;
  case 1:
    cave[CAVE_WIDTH - 1].top++;
    if (cave[CAVE_WIDTH - 1].top >
      cave[CAVE_WIDTH - 1].bottom - CAVE_OPENING_MIN) {
      cave[CAVE_WIDTH - 1].top--;
    }
    break;
  }

  /* Next bottom. */
  switch (random() % 5) {
  case 0:
    cave[CAVE_WIDTH - 1].bottom++;
    if (cave[CAVE_WIDTH - 1].bottom > CAVE_HEIGHT - CAVE_PADDING_BOTTOM) {
      cave[CAVE_WIDTH - 1].bottom--;
    }
    break;
  case 1:
    cave[CAVE_WIDTH - 1].bottom--;
    if (cave[CAVE_WIDTH - 1].bottom <=
      cave[CAVE_WIDTH - 1].top + CAVE_OPENING_MIN) {
      cave[CAVE_WIDTH - 1].bottom++;
    }
    break;
  }

  /* Possible item. */
  switch (random() % 20) {
  case 0:
    object_spawn(GRAPHICS_MONEY);
    break;
  case 1:
    object_spawn(GRAPHICS_AMMO);
    break;
  case 2:
    object_spawn(GRAPHICS_ENEMY);
    break;
  default:
    break;
  }
}

// Assembly:
movl $0x1, %eax
leaq 0x2904(%rip), %rcx      # 0x4100
movq (%rcx,%rax,8), %rdx
movq %rdx, -0x8(%rcx,%rax,8)
incq %rax
cmpq $0x50, %rax
jne 0x17fc
pushq %rbx
movq 0x2b6a(%rip), %rax      # 0x4380
testq %rax, %rax
je 0x1824
decl 0x4(%rax)
movq 0x10(%rax), %rax
jmp 0x1816
callq 0x1100
movq %rax, %rcx
movabsq $0x6666666666666667, %rbx # imm = 0x6666666666666667
imulq %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq %rdx
addq %rax, %rdx
leaq (%rdx,%rdx,4), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
je 0x186a
testq %rcx, %rcx
jne 0x1888
movl 0x2b1a(%rip), %eax      # 0x4378
xorl %ecx, %ecx
cmpl $0x3, %eax
setge %cl
subl %ecx, %eax
jmp 0x1882
movl 0x2b08(%rip), %ecx      # 0x4378
movl 0x2b06(%rip), %edx      # 0x437c
addl $-0x3, %edx
xorl %eax, %eax
cmpl %edx, %ecx
setl %al
addl %ecx, %eax
movl %eax, 0x2af0(%rip)      # 0x4378
callq 0x1100
movq %rax, %rcx
imulq %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq %rdx
addq %rax, %rdx
leaq (%rdx,%rdx,4), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
je 0x18c4
testq %rcx, %rcx
jne 0x18e1
movl 0x2ac4(%rip), %ecx      # 0x437c
xorl %eax, %eax
cmpl $0x16, %ecx
setl %al
addl %ecx, %eax
jmp 0x18db
movl 0x2ab2(%rip), %eax      # 0x437c
leal -0x1(%rax), %ecx
movl 0x2aa5(%rip), %edx      # 0x4378
addl $0x3, %edx
cmpl %edx, %ecx
cmovgl %ecx, %eax
movl %eax, 0x2a9b(%rip)      # 0x437c
callq 0x1100
movq %rax, %rcx
imulq %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x3, %rdx
addq %rax, %rdx
shlq $0x2, %rdx
leaq (%rdx,%rdx,4), %rax
subq %rax, %rcx
cmpq $0x2, %rcx
popq %rbx
ja 0x191e
shll $0x3, %ecx
movl $0x402b24, %eax         # imm = 0x402B24
shrl %cl, %eax
movzbl %al, %edi
jmp 0x173a
retq
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/cavescroll/cavescroll.c
// Function: objects_col_detect
static void objects_col_detect(void)
{
  object_t *curr_a, *curr_b;

  if (objects == NULL)
    return;

  for (curr_a = objects; curr_a != NULL; curr_a = curr_a->next) {
    if (curr_a->removed)
      continue;

    switch (curr_a->type) {
    case GRAPHICS_SHOT:
      if (mvinch(curr_a->y, curr_a->x) == GRAPHICS_CAVE) {
        curr_a->removed = 1;
      }
      for (curr_b = objects; curr_b != NULL; curr_b = curr_b->next) {
        if (curr_b->removed)
          continue;
        if (curr_a == curr_b)
          continue;
        if (curr_a->x == curr_b->x && curr_a->y == curr_b->y) {
          flash();
          if (curr_b->type == GRAPHICS_ENEMY)
            score += 5;
          curr_a->removed = 1;
          curr_b->removed = 1;
        }
      }
      break;

    case GRAPHICS_MONEY:
      if ((curr_a->x == player_x) && (curr_a->y == player_y)) {
        score++;
        curr_a->removed = 1;
      }
      break;

    case GRAPHICS_AMMO:
      if ((curr_a->x == player_x) && (curr_a->y == player_y)) {
        ammo++;
        curr_a->removed = 1;
      }
      break;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x2a14(%rip), %rbx      # 0x4380
testq %rbx, %rbx
je 0x1a7a
leaq 0x2780(%rip), %r14      # 0x40fc
leaq 0x2771(%rip), %r15      # 0x40f4
movq 0x2656(%rip), %r12      # 0x3fe0
movl $0x1, %ebp
cmpl $0x0, 0xc(%rbx)
je 0x19a3
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x198f
jmp 0x1a7a
movzbl (%rbx), %eax
cmpl $0x24, %eax
je 0x1a47
cmpl $0x2b, %eax
je 0x1a2c
cmpl $0x2d, %eax
jne 0x1995
movq (%r12), %rdi
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %esi
callq 0x1130
cmpl $-0x1, %eax
je 0x19e2
movq (%r12), %rdi
callq 0x1110
cmpl $0x23, %eax
jne 0x19e2
movl $0x1, 0xc(%rbx)
movq 0x2997(%rip), %r13      # 0x4380
testq %r13, %r13
je 0x1995
cmpq %r13, %rbx
je 0x1a26
cmpl $0x0, 0xc(%r13)
jne 0x1a26
movl 0x4(%rbx), %eax
cmpl 0x4(%r13), %eax
jne 0x1a26
movl 0x8(%rbx), %eax
cmpl 0x8(%r13), %eax
jne 0x1a26
callq 0x10c0
cmpb $0x40, (%r13)
jne 0x1a1f
addl $0x5, 0x26dd(%rip)      # 0x40fc
movl %ebp, 0xc(%rbx)
movl %ebp, 0xc(%r13)
movq 0x10(%r13), %r13
jmp 0x19e9
movzbl 0x26c5(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %eax
cmpl %eax, 0x4(%rbx)
jne 0x1995
movl 0x8(%rbx), %ecx
movq %r15, %rax
jmp 0x1a60
movzbl 0x26aa(%rip), %eax      # 0x40f8
leal (%rax,%rax,2), %eax
cmpl %eax, 0x4(%rbx)
jne 0x1995
movl 0x8(%rbx), %ecx
movq %r14, %rax
cmpl 0x268a(%rip), %ecx      # 0x40f0
jne 0x1995
incl (%rax)
movl $0x1, 0xc(%rbx)
jmp 0x1995
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/src/api.c
// Function: yaml_queue_extend
YAML_DECLARE(int)
yaml_queue_extend(void **start, void **head, void **tail, void **end)
{
    /* Check if we need to resize the queue. */

    if (*start == *head && *tail == *end) {
        void *new_start = yaml_realloc(*start,
                ((char *)*end - (char *)*start)*2);

        if (!new_start) return 0;

        *head = (char *)new_start + ((char *)*head - (char *)*start);
        *tail = (char *)new_start + ((char *)*tail - (char *)*start);
        *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
        *start = new_start;
    }

    /* Check if we need to move the queue at the beginning of the buffer. */

    if (*tail == *end) {
        if (*head != *tail) {
            memmove(*start, *head, (char *)*tail - (char *)*head);
        }
        *tail = (char *)*tail - (char *)*head + (char *)*start;
        *head = *start;
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
movq (%rsi), %rax
xorq %rdi, %rax
movq (%rdx), %rsi
movq (%rcx), %rdx
movq %rsi, %rcx
xorq %rdx, %rcx
orq %rax, %rcx
jne 0x2509
subq %rdi, %rsi
addq %rsi, %rsi
callq 0x2130
testq %rax, %rax
je 0x252e
movq %rax, %rdi
movq (%rbx), %rax
subq (%r15), %rax
addq %rdi, %rax
movq %rax, (%rbx)
movq (%r14), %rax
subq (%r15), %rax
addq %rdi, %rax
movq %rax, (%r14)
movq (%r12), %rax
subq (%r15), %rax
leaq (%rdi,%rax,2), %rax
movq %rax, (%r12)
movq %rdi, (%r15)
movq (%r14), %rsi
movq (%r12), %rdx
movl $0x1, %ebp
cmpq %rdx, %rsi
jne 0x2544
movq (%rbx), %rsi
cmpq %rdx, %rsi
je 0x2532
subq %rsi, %rdx
callq 0x21d0
movq (%r14), %rax
movq (%rbx), %rdx
movq (%r15), %rdi
jmp 0x2535
xorl %ebp, %ebp
jmp 0x2544
movq %rdx, %rax
subq %rdx, %rax
addq %rdi, %rax
movq %rax, (%r14)
movq (%r15), %rax
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq