LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/avx2/MinalpherMode.cpp
// Function: create_l(long long vector[4]&, unsigned char const*, unsigned char const*)
static inline void create_l(__m256i& ymmL, const unsigned char *_K, const unsigned char *_N){
  MIE_ALIGN(128) unsigned char tmp[32] = { 0 };
  memcpy(tmp, _K, 16);
  tmp[16] = 0x40;
  memcpy(tmp + 19, _N, 13);

  ymmL = _mm256_load_si256((const __m256i*)(tmp));
  minalpher_core_single_block(ymmL);
  ymmL = _mm256_xor_si256(ymmL, _mm256_load_si256((const __m256i*)(tmp)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x80, %rsp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2030
movq 0x80(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movb $0x40, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x13(%rsp)
movl 0x8(%rax), %ecx
movl %ecx, 0x1b(%rsp)
movb 0xc(%rax), %al
movb %al, 0x1f(%rsp)
movq %rsp, %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
vmovdqa (%rax), %ymm0
movq 0x88(%rsp), %rax
vmovdqa %ymm0, (%rax)
movq 0x88(%rsp), %rdi
vzeroupper
callq 0x2040
movq 0x88(%rsp), %rax
vmovdqa (%rax), %ymm1
movq %rsp, %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
vmovdqa (%rax), %ymm0
vmovdqa %ymm1, 0xc0(%rsp)
vmovdqa %ymm0, 0xa0(%rsp)
vmovdqa 0xc0(%rsp), %ymm0
vpxor 0xa0(%rsp), %ymm0, %ymm0
movq 0x88(%rsp), %rax
vmovdqa %ymm0, (%rax)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/avx2/encrypt.cpp
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
  unsigned char       *c,
  unsigned long long  *clen,
  const unsigned char *m,
  unsigned long long  mlen,
  const unsigned char *ad,
  unsigned long long  adlen,
  const unsigned char *nsec,
  const unsigned char *npub,
  const unsigned char *k
  )
{
  unsigned long long cr;

  cr = mlen + adlen;
  if( (cr<mlen) && (cr<adlen) ) return -1;
  
  //minalpher mode
  minalpher_mode_encrypt(k, npub, ad, adlen, m, mlen, c, clen);
  
  
  return 0;
}

// Assembly:
subq $0x58, %rsp
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x30(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x410c2
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x410c2
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x41100
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
movq 0x48(%rsp), %r10
movq 0x40(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x21a0
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/minalpherv11/avx2/encrypt.cpp
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
  unsigned char       *m,
  unsigned long long  *mlen,
  unsigned char       *nsec,
  const unsigned char *c,
  unsigned long long  clen,
  const unsigned char *ad,
  unsigned long long  adlen,
  const unsigned char *npub,
  const unsigned char *k
  )
{
  unsigned long long cr;
  int d, ret=0;
  MIE_ALIGN(128) unsigned char tag[32] = { 0 };

  cr = clen + adlen;
  if( (cr<clen) && (cr<adlen) ) return -1;

  clen -= TAGBYTES;
  if( clen % BLOCK_SIZE ) return -1;
  if( clen < BLOCK_SIZE ) return -1;

  //minalpher tag verification
  if (minalpher_mode_tag_generation(k, npub, ad, adlen, c, clen, tag) < 0){
    return -1;
  }
  for( d=0; d<TAGBYTES; d++ ){
    if( tag[d] != c[d+clen] ) ret |= 1;
  }
  if( ret != 0 )  return -1;

  //minalpher decryption
  if (minalpher_mode_decryption(k, npub, c, clen, m, mlen) < 0){
    return -1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x80, %rsp
subq $0x100, %rsp            # imm = 0x100
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %r8, 0xc0(%rsp)
movq %r9, 0xb8(%rsp)
movl $0x0, 0xa8(%rsp)
leaq 0x80(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2030
movq 0xc0(%rsp), %rax
addq 0x10(%rbp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
cmpq 0xc0(%rsp), %rax
jae 0x411be
movq 0xb0(%rsp), %rax
cmpq 0x10(%rbp), %rax
jae 0x411be
movl $0xffffffff, 0xec(%rsp) # imm = 0xFFFFFFFF
jmp 0x41325
movq 0xc0(%rsp), %rax
subq $0x10, %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
andq $0x1f, %rax
cmpq $0x0, %rax
je 0x411f4
movl $0xffffffff, 0xec(%rsp) # imm = 0xFFFFFFFF
jmp 0x41325
cmpq $0x20, 0xc0(%rsp)
jae 0x4120f
movl $0xffffffff, 0xec(%rsp) # imm = 0xFFFFFFFF
jmp 0x41325
movq 0x20(%rbp), %rdi
movq 0x18(%rbp), %rsi
movq 0xb8(%rsp), %rdx
movq 0x10(%rbp), %rcx
movq 0xc8(%rsp), %r8
movq 0xc0(%rsp), %r9
leaq 0x80(%rsp), %rax
movq %rax, (%rsp)
callq 0x20d0
cmpl $0x0, %eax
jge 0x41259
movl $0xffffffff, 0xec(%rsp) # imm = 0xFFFFFFFF
jmp 0x41325
movl $0x0, 0xac(%rsp)
cmpl $0x10, 0xac(%rsp)
jge 0x412c4
movslq 0xac(%rsp), %rax
movzbl 0x80(%rsp,%rax), %eax
movq 0xc8(%rsp), %rcx
movslq 0xac(%rsp), %rdx
addq 0xc0(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x412af
movl 0xa8(%rsp), %eax
orl $0x1, %eax
movl %eax, 0xa8(%rsp)
jmp 0x412b1
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0x41264
cmpl $0x0, 0xa8(%rsp)
je 0x412db
movl $0xffffffff, 0xec(%rsp) # imm = 0xFFFFFFFF
jmp 0x41325
movq 0x20(%rbp), %rdi
movq 0x18(%rbp), %rsi
movq 0xc8(%rsp), %rdx
movq 0xc0(%rsp), %rcx
movq 0xe0(%rsp), %r8
movq 0xd8(%rsp), %r9
callq 0x2150
cmpl $0x0, %eax
jge 0x4131a
movl $0xffffffff, 0xec(%rsp) # imm = 0xFFFFFFFF
jmp 0x41325
movl $0x0, 0xec(%rsp)
movl 0xec(%rsp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obtest.c
// Function: obtest_new
obtest * obtest_new(uint32_t id){

  static const char classname[] = "obtest";

  obtest *new_instance = malloc(sizeof(obtest));
  assert(new_instance != NULL);

  /*initialize reference counting base data*/
  ob_init_base((obj *)new_instance, &obtest_destroy, &obtest_hash,
               &obtest_compare, &obtest_display, classname);

  new_instance->id = id;
  return new_instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x10a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1af2
jmp 0x1b11
leaq 0x2b8a(%rip), %rdi      # 0x4683
leaq 0x2b98(%rip), %rsi      # 0x4698
movl $0x11, %edx
leaq 0x2ba1(%rip), %rcx      # 0x46ad
callq 0x1050
movq -0x10(%rbp), %rdi
leaq 0x44(%rip), %rsi        # 0x1b60
leaq 0x7d(%rip), %rdx        # 0x1ba0
leaq 0xc6(%rip), %rcx        # 0x1bf0
leaq 0x1cf(%rip), %r8        # 0x1d00
leaq 0x2b44(%rip), %r9       # 0x467c
callq 0x2e20
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%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/obtest.c
// Function: obtest_compare
int8_t obtest_compare(const obj *a, const obj *b){

  assert(a != NULL);
  assert(b != NULL);
  assert(ob_has_class(a, "obtest"));
  assert(ob_has_class(b, "obtest"));

  if(((obtest *)a)->id >((obtest *)b)->id) return OB_GREATER_THAN;
  if(((obtest *)a)->id == ((obtest *)b)->id) return OB_EQUAL_TO;
  return OB_LESS_THAN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1c09
jmp 0x1c28
leaq 0x2aba(%rip), %rdi      # 0x46ca
leaq 0x2a81(%rip), %rsi      # 0x4698
movl $0x2a, %edx
leaq 0x2af9(%rip), %rcx      # 0x471c
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x1c31
jmp 0x1c50
leaq 0x2b14(%rip), %rdi      # 0x474c
leaq 0x2a59(%rip), %rsi      # 0x4698
movl $0x2b, %edx
leaq 0x2ad1(%rip), %rcx      # 0x471c
callq 0x1050
movq -0x10(%rbp), %rdi
leaq 0x2afb(%rip), %rsi      # 0x4756
callq 0x3240
cmpb $0x0, %al
je 0x1c66
jmp 0x1c85
leaq 0x2af0(%rip), %rdi      # 0x475d
leaq 0x2a24(%rip), %rsi      # 0x4698
movl $0x2c, %edx
leaq 0x2a9c(%rip), %rcx      # 0x471c
callq 0x1050
movq -0x18(%rbp), %rdi
leaq 0x2ac6(%rip), %rsi      # 0x4756
callq 0x3240
cmpb $0x0, %al
je 0x1c9b
jmp 0x1cba
leaq 0x2ad5(%rip), %rdi      # 0x4777
leaq 0x29ef(%rip), %rsi      # 0x4698
movl $0x2d, %edx
leaq 0x2a67(%rip), %rcx      # 0x471c
callq 0x1050
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jbe 0x1cd0
movb $0x1, -0x1(%rbp)
jmp 0x1cea
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x1ce6
movb $0x0, -0x1(%rbp)
jmp 0x1cea
movb $-0x1, -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/obvector.c
// Function: obvector_new
obvector * obvector_new(uint32_t initial_capacity){

  uint32_t i, new_cap;

  new_cap = 1;
  while(initial_capacity > new_cap) new_cap *= 2;
  if(new_cap > UINT32_MAX) new_cap = UINT32_MAX;

  obvector *new_instance = obvector_create_default(new_cap);
  for(i=0; i<new_cap; i++) new_instance->array[i] = NULL;

  return new_instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, -0xc(%rbp)
movl -0x4(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0x1e04
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
jmp 0x1df2
cmpl $-0x1, -0xc(%rbp)
jbe 0x1e11
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %edi
callq 0x1e60
movq %rax, -0x18(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x1e4a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x8(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1e24
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obvector.c
// Function: obvector_create_default
obvector * obvector_create_default(uint32_t initial_capacity){

  static const char classname[] = "obvector";

  obvector *new_instance = malloc(sizeof(obvector));
  assert(new_instance != NULL);

  /* initialize reference counting base data */
  ob_init_base((obj *)new_instance, &obvector_destroy, &obvector_hash, &obvector_compare,
           &obvector_display, classname);

  /* a vector with zero capacity cannot be created, create one with a capacity
   * of one */
  if(initial_capacity == 0){
    initial_capacity = 1;
  }

  new_instance->array = malloc(initial_capacity*sizeof(obj *));
  assert(new_instance->array != NULL);

  new_instance->capacity = initial_capacity;
  new_instance->length = 0;

  return new_instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x10a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1e82
jmp 0x1ea1
leaq 0x27fa(%rip), %rdi      # 0x4683
leaq 0x298f(%rip), %rsi      # 0x481f
movl $0xb5, %edx
leaq 0x2c11(%rip), %rcx      # 0x4aad
callq 0x1050
movq -0x10(%rbp), %rdi
leaq 0xb24(%rip), %rsi       # 0x29d0
leaq 0xbad(%rip), %rdx       # 0x2a60
leaq 0xcf6(%rip), %rcx       # 0x2bb0
leaq 0xe3f(%rip), %r8        # 0x2d00
leaq 0x2e3d(%rip), %r9       # 0x4d05
callq 0x2e20
cmpl $0x0, -0x4(%rbp)
jne 0x1eda
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x10a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1f00
jmp 0x1f1f
leaq 0x2bd2(%rip), %rdi      # 0x4ad9
leaq 0x2911(%rip), %rsi      # 0x481f
movl $0xc2, %edx
leaq 0x2b93(%rip), %rcx      # 0x4aad
callq 0x1050
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1f55
jmp 0x1f74
leaq 0x28bb(%rip), %rdi      # 0x4817
leaq 0x28bc(%rip), %rsi      # 0x481f
movl $0x21, %edx
leaq 0x28c7(%rip), %rcx      # 0x4836
callq 0x1050
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x1e60
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x1fe2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x31a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f99
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x205d
jmp 0x207c
leaq 0x27fc(%rip), %rdi      # 0x4860
leaq 0x27b4(%rip), %rsi      # 0x481f
movl $0x37, %edx
leaq 0x281e(%rip), %rcx      # 0x4895
callq 0x1050
cmpq $0x0, -0x18(%rbp)
jge 0x2092
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
jge 0x209f
jmp 0x20be
leaq 0x2828(%rip), %rdi      # 0x48ce
leaq 0x2772(%rip), %rsi      # 0x481f
movl $0x3c, %edx
leaq 0x27dc(%rip), %rcx      # 0x4895
callq 0x1050
cmpq $0x0, -0x18(%rbp)
jl 0x20c7
jmp 0x20e6
leaq 0x2813(%rip), %rdi      # 0x48e1
leaq 0x274a(%rip), %rsi      # 0x481f
movl $0x3d, %edx
leaq 0x27b4(%rip), %rcx      # 0x4895
callq 0x1050
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x2160
movq -0x10(%rbp), %rdi
callq 0x31a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3120
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rax
jl 0x215a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x22b0
movl %eax, %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jae 0x2177
jmp 0x2196
leaq 0x2750(%rip), %rdi      # 0x48ce
leaq 0x269a(%rip), %rsi      # 0x481f
movl $0xd1, %edx
leaq 0x2964(%rip), %rcx      # 0x4af5
callq 0x1050
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x21a7
jmp 0x22a5
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
cmpq -0x18(%rbp), %rax
jbe 0x21cd
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
jmp 0x21b2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
jbe 0x21e1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x10a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x21fb
jmp 0x221a
leaq 0x28e5(%rip), %rdi      # 0x4ae7
leaq 0x2616(%rip), %rsi      # 0x481f
movl $0xdc, %edx
leaq 0x28e0(%rip), %rcx      # 0x4af5
callq 0x1050
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x2252
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2221
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0x227f
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x225c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2319
jmp 0x2338
leaq 0x2540(%rip), %rdi      # 0x4860
leaq 0x24f8(%rip), %rsi      # 0x481f
movl $0x50, %edx
leaq 0x25b9(%rip), %rcx      # 0x48ec
callq 0x1050
cmpq $0x0, -0x18(%rbp)
jge 0x234e
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
jge 0x235b
jmp 0x237a
leaq 0x256c(%rip), %rdi      # 0x48ce
leaq 0x24b6(%rip), %rsi      # 0x481f
movl $0x54, %edx
leaq 0x2577(%rip), %rcx      # 0x48ec
callq 0x1050
cmpq $0x0, -0x18(%rbp)
jl 0x2383
jmp 0x23a2
leaq 0x2557(%rip), %rdi      # 0x48e1
leaq 0x248e(%rip), %rsi      # 0x481f
movl $0x55, %edx
leaq 0x254f(%rip), %rcx      # 0x48ec
callq 0x1050
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rax
jge 0x23c8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x23d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x23f9
jmp 0x2418
leaq 0x2522(%rip), %rdi      # 0x4922
leaq 0x2418(%rip), %rsi      # 0x481f
movl $0x60, %edx
leaq 0x2523(%rip), %rcx      # 0x4936
callq 0x1050
cmpq $0x0, -0x10(%rbp)
je 0x2421
jmp 0x2440
leaq 0x253b(%rip), %rdi      # 0x4963
leaq 0x23f0(%rip), %rsi      # 0x481f
movl $0x61, %edx
leaq 0x24fb(%rip), %rcx      # 0x4936
callq 0x1050
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jb 0x2459
jmp 0x2478
leaq 0x2515(%rip), %rdi      # 0x4975
leaq 0x23b8(%rip), %rsi      # 0x481f
movl $0x63, %edx
leaq 0x24c3(%rip), %rcx      # 0x4936
callq 0x1050
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
addl 0x10(%rax), %esi
subl $0x1, %esi
callq 0x2160
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rax
jae 0x24f7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x31a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rsi
movl 0x10(%rsi), %esi
addq %rsi, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x249a
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2529
jmp 0x2548
leaq 0x2330(%rip), %rdi      # 0x4860
leaq 0x22e8(%rip), %rsi      # 0x481f
movl $0x78, %edx
leaq 0x2471(%rip), %rcx      # 0x49b4
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x2551
jmp 0x2570
leaq 0x2495(%rip), %rdi      # 0x49ed
leaq 0x22c0(%rip), %rsi      # 0x481f
movl $0x79, %edx
leaq 0x2449(%rip), %rcx      # 0x49b4
callq 0x1050
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x25b6
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x3000
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x25a9
movb $0x1, -0x1(%rbp)
jmp 0x25ba
jmp 0x25ab
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2577
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/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x261f
jmp 0x263e
leaq 0x223a(%rip), %rdi      # 0x4860
leaq 0x21f2(%rip), %rsi      # 0x481f
movl $0x8f, %edx
leaq 0x23c4(%rip), %rcx      # 0x49fd
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x2647
jmp 0x2666
leaq 0x23f2(%rip), %rdi      # 0x4a40
leaq 0x21ca(%rip), %rsi      # 0x481f
movl $0x90, %edx
leaq 0x239c(%rip), %rcx      # 0x49fd
callq 0x1050
movsbl -0x9(%rbp), %eax
cmpl $-0x1, %eax
je 0x2678
movsbl -0x9(%rbp), %eax
cmpl $0x1, %eax
jne 0x267a
jmp 0x2699
leaq 0x23cd(%rip), %rdi      # 0x4a4e
leaq 0x2197(%rip), %rsi      # 0x481f
movl $0x91, %edx
leaq 0x2369(%rip), %rcx      # 0x49fd
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rcx
movsbl %al, %edx
callq 0x2700
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
subl $0x1, %esi
callq 0x22b0
movl %eax, %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2965
jmp 0x2984
leaq 0x1ef4(%rip), %rdi      # 0x4860
leaq 0x1eac(%rip), %rsi      # 0x481f
movl $0xa1, %edx
leaq 0x210e(%rip), %rcx      # 0x4a8d
callq 0x1050
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x29b6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x3120
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x298b
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29ed
jmp 0x2a0c
leaq 0x1c93(%rip), %rdi      # 0x4687
leaq 0x1e24(%rip), %rsi      # 0x481f
movl $0x17b, %edx            # imm = 0x17B
leaq 0x22bc(%rip), %rcx      # 0x4cc3
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x2186(%rip), %rsi      # 0x4b9d
callq 0x3240
cmpb $0x0, %al
je 0x2a22
jmp 0x2a41
leaq 0x22b7(%rip), %rdi      # 0x4ce0
leaq 0x1def(%rip), %rsi      # 0x481f
movl $0x17c, %edx            # imm = 0x17C
leaq 0x2287(%rip), %rcx      # 0x4cc3
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x2950
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2a7d
jmp 0x2a9c
leaq 0x1c6d(%rip), %rdi      # 0x46f1
leaq 0x1d94(%rip), %rsi      # 0x481f
movl $0x135, %edx            # imm = 0x135
leaq 0x20e1(%rip), %rcx      # 0x4b78
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x20f6(%rip), %rsi      # 0x4b9d
callq 0x3240
cmpb $0x0, %al
je 0x2ab2
jmp 0x2ad1
leaq 0x20ed(%rip), %rdi      # 0x4ba6
leaq 0x1d5f(%rip), %rsi      # 0x481f
movl $0x136, %edx            # imm = 0x136
leaq 0x20ac(%rip), %rcx      # 0x4b78
callq 0x1050
movsbl 0x45a8(%rip), %eax      # 0x7080
cmpl $0x0, %eax
jne 0x2b02
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %edi
callq 0x1060
callq 0x10c0
cltq
movq %rax, 0x458d(%rip)      # 0x7088
movb $0x1, 0x457e(%rip)      # 0x7080
movq 0x457f(%rip), %rax      # 0x7088
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x2b67
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x2f60
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)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2b14
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
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2bd9
jmp 0x2bf8
leaq 0x1fe8(%rip), %rdi      # 0x4bc8
leaq 0x1c38(%rip), %rsi      # 0x481f
movl $0x153, %edx            # imm = 0x153
leaq 0x1fd7(%rip), %rcx      # 0x4bca
callq 0x1050
cmpq $0x0, -0x18(%rbp)
je 0x2c01
jmp 0x2c20
leaq 0x1ff4(%rip), %rdi      # 0x4bfc
leaq 0x1c10(%rip), %rsi      # 0x481f
movl $0x154, %edx            # imm = 0x154
leaq 0x1faf(%rip), %rcx      # 0x4bca
callq 0x1050
movq -0x10(%rbp), %rdi
leaq 0x1f72(%rip), %rsi      # 0x4b9d
callq 0x3240
cmpb $0x0, %al
je 0x2c36
jmp 0x2c55
leaq 0x1fc1(%rip), %rdi      # 0x4bfe
leaq 0x1bdb(%rip), %rsi      # 0x481f
movl $0x155, %edx            # imm = 0x155
leaq 0x1f7a(%rip), %rcx      # 0x4bca
callq 0x1050
movq -0x18(%rbp), %rdi
leaq 0x1f3d(%rip), %rsi      # 0x4b9d
callq 0x3240
cmpb $0x0, %al
je 0x2c6b
jmp 0x2c8a
leaq 0x1fa8(%rip), %rdi      # 0x4c1a
leaq 0x1ba6(%rip), %rsi      # 0x481f
movl $0x156, %edx            # imm = 0x156
leaq 0x1f45(%rip), %rcx      # 0x4bca
callq 0x1050
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x10(%rcx), %eax
je 0x2ca0
movb $0x2, -0x1(%rbp)
jmp 0x2cf5
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x2cf1
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x3000
movsbl %al, %eax
cmpl $0x0, %eax
je 0x2ce4
movb $0x2, -0x1(%rbp)
jmp 0x2cf5
jmp 0x2ce6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2ca7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2d1d
jmp 0x2d3c
leaq 0x1f12(%rip), %rdi      # 0x4c36
leaq 0x1af4(%rip), %rsi      # 0x481f
movl $0x167, %edx            # imm = 0x167
leaq 0x1f10(%rip), %rcx      # 0x4c47
callq 0x1050
movq -0x8(%rbp), %rdi
leaq 0x1e56(%rip), %rsi      # 0x4b9d
callq 0x3240
cmpb $0x0, %al
je 0x2d52
jmp 0x2d71
leaq 0x1f11(%rip), %rdi      # 0x4c6a
leaq 0x1abf(%rip), %rsi      # 0x481f
movl $0x168, %edx            # imm = 0x168
leaq 0x1edb(%rip), %rcx      # 0x4c47
callq 0x1050
movq 0x4280(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x1f04(%rip), %rsi      # 0x4c8d
movb $0x0, %al
callq 0x1080
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x2df5
movq 0x424e(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x1ef1(%rip), %rsi      # 0x4ca8
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x30a0
movq 0x421f(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x14ae(%rip), %rsi      # 0x4291
movb $0x0, %al
callq 0x1080
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d97
movq 0x41fc(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1eaf(%rip), %rsi      # 0x4cb5
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x2e49
jmp 0x2e68
leaq 0x1ebe(%rip), %rdi      # 0x4d0e
leaq 0x1ec9(%rip), %rsi      # 0x4d20
movl $0xe, %edx
leaq 0x1ed3(%rip), %rcx      # 0x4d36
callq 0x1050
movl $0x30, %edi
callq 0x10a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2e88
jmp 0x2ea7
leaq 0x1f0f(%rip), %rdi      # 0x4d9e
leaq 0x1e8a(%rip), %rsi      # 0x4d20
movl $0x12, %edx
leaq 0x1e94(%rip), %rcx      # 0x4d36
callq 0x1050
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
leaq 0x96(%rip), %rax        # 0x2f60
cmpq %rax, -0x18(%rbp)
je 0x2ee1
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x2ef0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
leaq 0x109(%rip), %rax       # 0x3000
cmpq %rax, -0x20(%rbp)
je 0x2f0e
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x2f1d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x18(%rax)
leaq 0x17c(%rip), %rax       # 0x30a0
cmpq %rax, -0x28(%rbp)
je 0x2f3b
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
jmp 0x2f4a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2f7d
movq $0x0, -0x8(%rbp)
jmp 0x2ff2
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x2fa2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
jmp 0x2fea
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x6, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0xa, %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x7, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0xc, %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3024
cmpq $0x0, -0x18(%rbp)
jne 0x3024
movb $0x0, -0x1(%rbp)
jmp 0x3093
cmpq $0x0, -0x10(%rbp)
je 0x3032
cmpq $0x0, -0x18(%rbp)
jne 0x3038
movb $0x2, -0x1(%rbp)
jmp 0x3093
jmp 0x303a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x32b0
movzbl %al, %eax
cmpl $0x0, %eax
je 0x3077
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x3077
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movb %al, -0x19(%rbp)
jmp 0x308d
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x3087
movb $0x0, -0x19(%rbp)
jmp 0x308b
movb $0x2, -0x19(%rbp)
jmp 0x308d
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x30cd
movq 0x3f3e(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1d29(%rip), %rsi      # 0x4ded
movb $0x0, %al
callq 0x1080
jmp 0x3113
movq 0x3f24(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rdx
movq -0x8(%rbp), %rcx
leaq 0x1d0c(%rip), %rsi      # 0x4df9
movb $0x0, %al
callq 0x1080
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x3113
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x313d
movq $0x0, -0x8(%rbp)
jmp 0x3196
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
ja 0x318e
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x316f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x3196
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x31bd
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3200
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $-0x1, (%rax)
jae 0x31cb
jmp 0x31ea
leaq 0x1be0(%rip), %rdi      # 0x4db2
leaq 0x1b47(%rip), %rsi      # 0x4d20
movl $0x40, %edx
leaq 0x1bf2(%rip), %rcx      # 0x4dd7
callq 0x1050
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3278
movq -0x18(%rbp), %rdi
leaq 0x1b4b(%rip), %rsi      # 0x4dad
callq 0x1070
cmpl $0x0, %eax
jne 0x3272
movb $0x1, -0x1(%rbp)
jmp 0x329b
movb $0x0, -0x1(%rbp)
jmp 0x329b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1070
cmpl $0x0, %eax
jne 0x3297
movb $0x1, -0x1(%rbp)
jmp 0x329b
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/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x32d4
cmpq $0x0, -0x18(%rbp)
jne 0x32d4
movb $0x1, -0x1(%rbp)
jmp 0x3301
cmpq $0x0, -0x10(%rbp)
je 0x32e2
cmpq $0x0, -0x18(%rbp)
jne 0x32e8
movb $0x0, -0x1(%rbp)
jmp 0x3301
jmp 0x32ea
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rsi
callq 0x3240
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190925_1MM1_INTRO/EvalContinua.c
// Function: show_reactivo(unsigned int)
int show_reactivo(unsigned int index)
{
  printf("\n/************************************************/\n");
  if((index>=0)&&(index<NUMDREAC)){
    printf("REACTIVO %u:\n",index+1);
    printf("%s\n",REACTIVO[index]);
    printf("\n/************************************************/\n");
  }else{
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq 0x1b02(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x2030
cmpl $0x0, -0x8(%rbp)
jb 0x2558
cmpl $0x3, -0x8(%rbp)
jae 0x2558
movl -0x8(%rbp), %esi
addl $0x1, %esi
leaq 0x1b17(%rip), %rdi      # 0x4039
movb $0x0, %al
callq 0x2030
movl -0x8(%rbp), %eax
leaq 0x3cad(%rip), %rsi      # 0x61e0
shlq $0xb, %rax
addq %rax, %rsi
leaq 0x1c2b(%rip), %rdi      # 0x416c
movb $0x0, %al
callq 0x2030
leaq 0x1ab5(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x2030
jmp 0x2561
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2568
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
leaq 0x5451(%rip), %rax      # 0x79e0
cmpl $0x3, (%rax)
jne 0x25aa
leaq 0x5455(%rip), %rax      # 0x79f0
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2682
movl $0x3, %eax
leaq 0x542a(%rip), %rcx      # 0x79e0
subl (%rcx), %eax
cmpl $0x1, %eax
jne 0x25d7
callq 0x2690
leaq 0x542b(%rip), %rcx      # 0x79f4
movl %eax, (%rcx)
cmpl $0x0, %eax
jbe 0x25d5
jmp 0x2668
jmp 0x25d7
leaq 0x5402(%rip), %rax      # 0x79e0
cmpl $0x3, (%rax)
jae 0x2676
xorl %eax, %eax
movl %eax, %edi
callq 0x2170
movl %eax, %edi
callq 0x2180
callq 0x2090
movl $0x3, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x2720
testb $0x1, %al
jne 0x2618
jmp 0x262d
callq 0x2090
movl $0x3, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0x8(%rbp)
jmp 0x260a
movl -0x8(%rbp), %ecx
leaq 0x53bd(%rip), %rax      # 0x79f4
movl %ecx, (%rax)
leaq 0x53b4(%rip), %rax      # 0x79f4
cmpl $0x3, (%rax)
ja 0x2647
jmp 0x2666
leaq 0x19f9(%rip), %rdi      # 0x4047
leaq 0x1a0e(%rip), %rsi      # 0x4063
movl $0x43, %edx
leaq 0x1a11(%rip), %rcx      # 0x4072
callq 0x20f0
jmp 0x2668
leaq 0x5385(%rip), %rax      # 0x79f4
movl (%rax), %edi
callq 0x2770
leaq 0x5377(%rip), %rax      # 0x79f4
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)