LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_subtract
obint * obint_subtract(const obint *a, const obint *b){

  int8_t cmp_result;
  obint *result;

  assert(a != NULL);
  assert(b != NULL);

  /* a and b are  of opposite sign */
  if((!obint_is_negative(a) && obint_is_negative(b)) ||
     (obint_is_negative(a) && !obint_is_negative(b))){
    result = obint_add_unsigned(a,b);
    result->sign = a->sign;
    return result;
  }

  /* a and b are of same sign */
  cmp_result = obint_compare_magnitudes(a,b);
  if(cmp_result == OB_LESS_THAN){
    result = obint_subtract_unsigned(b,a);
    result->sign = b->sign * -1;
    return result;
  }
  else if(cmp_result == OB_GREATER_THAN){
    result = obint_subtract_unsigned(a,b);
    result->sign = a->sign;
    return result;
  }

  /* a and b are equal and same, result is 0 */
  return obint_new(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2a6b
movq %rsi, %r14
testq %rsi, %rsi
je 0x2a8a
movq %rdi, %rbx
cmpb $-0x1, 0x8(%rdi)
sete %al
cmpb $-0x1, 0x8(%r14)
sete %cl
cmpb %cl, %al
je 0x2a18
movq %r14, %rsi
callq 0x27a5
jmp 0x2a4f
movq %r14, %rsi
callq 0x289f
cmpb $0x1, %al
je 0x2a44
movzbl %al, %eax
cmpl $0xff, %eax
jne 0x2a5d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28f8
xorl %ecx, %ecx
subb 0x8(%r14), %cl
movb %cl, 0x8(%rax)
jmp 0x2a55
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28f8
movb 0x8(%rbx), %cl
movb %cl, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22e0
leaq 0x2990(%rip), %rdi      # 0x5402
leaq 0x2993(%rip), %rsi      # 0x540c
leaq 0x2b21(%rip), %rcx      # 0x55a1
movl $0xd8, %edx
callq 0x10a0
leaq 0x2ad3(%rip), %rdi      # 0x5564
leaq 0x2974(%rip), %rsi      # 0x540c
leaq 0x2b02(%rip), %rcx      # 0x55a1
movl $0xd9, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_subtract_primitive
obint * obint_subtract_primitive(const obint *a, int64_t b){

  obint *wrapper, *result;

  assert(a != NULL);

  wrapper = obint_new(b);
  result = obint_subtract(a, wrapper);
  ob_release((obj *)wrapper);

  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2ae1
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x22e0
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x29e3
movq %rax, %rbx
movq %r14, %rdi
callq 0x4c7e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x291a(%rip), %rdi      # 0x5402
leaq 0x291d(%rip), %rsi      # 0x540c
leaq 0x2adf(%rip), %rcx      # 0x55d5
movl $0xf9, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_multiply
obint * obint_multiply(const obint *a, const obint *b){

  obint *result;

  assert(a != NULL);
  assert(b != NULL);

  result = obint_multiply_unsigned(a,b);
  result->sign = a->sign * b->sign;

  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2b34
movq %rsi, %r14
testq %rsi, %rsi
je 0x2b53
movq %rdi, %rbx
movq %r14, %rsi
callq 0x2b72
movq %rax, %rcx
movb 0x8(%r14), %al
mulb 0x8(%rbx)
movb %al, 0x8(%rcx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x28c7(%rip), %rdi      # 0x5402
leaq 0x28ca(%rip), %rsi      # 0x540c
leaq 0x2ac4(%rip), %rcx      # 0x560d
movl $0x107, %edx            # imm = 0x107
callq 0x10a0
leaq 0x2a0a(%rip), %rdi      # 0x5564
leaq 0x28ab(%rip), %rsi      # 0x540c
leaq 0x2aa5(%rip), %rcx      # 0x560d
movl $0x108, %edx            # imm = 0x108
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_multiply_primitive
obint * obint_multiply_primitive(const obint *a, int64_t b){

  obint *wrapper, *result;

  assert(a != NULL);

  wrapper = obint_new(b);
  result = obint_multiply(a, wrapper);
  ob_release((obj *)wrapper);

  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2da4
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x22e0
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2b00
movq %rax, %rbx
movq %r14, %rdi
callq 0x4c7e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2657(%rip), %rdi      # 0x5402
leaq 0x265a(%rip), %rsi      # 0x540c
leaq 0x2888(%rip), %rcx      # 0x5641
movl $0x115, %edx            # imm = 0x115
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_divide
obint * obint_divide(const obint *a, const obint *b){

  obint *result, *seed;

  assert(a != NULL);
  assert(b != NULL);
  assert(obint_is_zero(b) == 0);

  seed = obint_new(0);
  result = obint_reduce(a, b, seed, 1);
  result->sign = a->sign * b->sign;
  ob_release((obj *)seed);

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2e28
movq %rsi, %r14
testq %rsi, %rsi
je 0x2e47
movq %rdi, %rbx
movq %r14, %rdi
callq 0x256b
testb %al, %al
jne 0x2e66
xorl %edi, %edi
callq 0x22e0
movq %rax, %r15
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2e85
movq %rax, %r12
movb 0x8(%r14), %al
mulb 0x8(%rbx)
movb %al, 0x8(%r12)
movq %r15, %rdi
callq 0x4c7e
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x25d3(%rip), %rdi      # 0x5402
leaq 0x25d6(%rip), %rsi      # 0x540c
leaq 0x283c(%rip), %rcx      # 0x5679
movl $0x123, %edx            # imm = 0x123
callq 0x10a0
leaq 0x2716(%rip), %rdi      # 0x5564
leaq 0x25b7(%rip), %rsi      # 0x540c
leaq 0x281d(%rip), %rcx      # 0x5679
movl $0x124, %edx            # imm = 0x124
callq 0x10a0
leaq 0x283e(%rip), %rdi      # 0x56ab
leaq 0x2598(%rip), %rsi      # 0x540c
leaq 0x27fe(%rip), %rcx      # 0x5679
movl $0x125, %edx            # imm = 0x125
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_divide_primitive
obint * obint_divide_primitive(const obint *a, int64_t b){

  obint *wrapper, *result;

  assert(a != NULL);
  assert(b != 0);

  wrapper = obint_new(b);
  result = obint_divide(a, wrapper);
  ob_release((obj *)wrapper);

  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x314c
testq %rsi, %rsi
je 0x316b
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x22e0
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2dc3
movq %rax, %rbx
movq %r14, %rdi
callq 0x4c7e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x22af(%rip), %rdi      # 0x5402
leaq 0x22b2(%rip), %rsi      # 0x540c
leaq 0x2560(%rip), %rcx      # 0x56c1
movl $0x134, %edx            # imm = 0x134
callq 0x10a0
leaq 0x2585(%rip), %rdi      # 0x56f7
leaq 0x2293(%rip), %rsi      # 0x540c
leaq 0x2541(%rip), %rcx      # 0x56c1
movl $0x135, %edx            # imm = 0x135
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_mod
obint * obint_mod(const obint *a, const obint *b){

  obint *result, *seed;

  assert(a != NULL);
  assert(b != NULL);
  assert(obint_is_zero(b) == 0);

  seed = obint_new(0);
  result = obint_reduce(a, b, seed, 0);
  result->sign = a->sign;
  ob_release((obj *)seed);

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x31e0
movq %rsi, %r14
testq %rsi, %rsi
je 0x31ff
movq %rdi, %rbx
movq %r14, %rdi
callq 0x256b
testb %al, %al
jne 0x321e
xorl %edi, %edi
callq 0x22e0
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x2e85
movq %rax, %r14
movb 0x8(%rbx), %al
movb %al, 0x8(%r14)
movq %r15, %rdi
callq 0x4c7e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x221b(%rip), %rdi      # 0x5402
leaq 0x221e(%rip), %rsi      # 0x540c
leaq 0x2509(%rip), %rcx      # 0x56fe
movl $0x143, %edx            # imm = 0x143
callq 0x10a0
leaq 0x235e(%rip), %rdi      # 0x5564
leaq 0x21ff(%rip), %rsi      # 0x540c
leaq 0x24ea(%rip), %rcx      # 0x56fe
movl $0x144, %edx            # imm = 0x144
callq 0x10a0
leaq 0x2486(%rip), %rdi      # 0x56ab
leaq 0x21e0(%rip), %rsi      # 0x540c
leaq 0x24cb(%rip), %rcx      # 0x56fe
movl $0x145, %edx            # imm = 0x145
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_mod_primitive
obint * obint_mod_primitive(const obint *a, int64_t b){

  obint *wrapper, *result;

  assert(a != NULL);
  assert(b != 0);

  wrapper = obint_new(b);
  result = obint_mod(a, wrapper);
  ob_release((obj *)wrapper);

  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x327a
testq %rsi, %rsi
je 0x3299
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x22e0
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x318a
movq %rax, %rbx
movq %r14, %rdi
callq 0x4c7e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2181(%rip), %rdi      # 0x5402
leaq 0x2184(%rip), %rsi      # 0x540c
leaq 0x249e(%rip), %rcx      # 0x572d
movl $0x154, %edx            # imm = 0x154
callq 0x10a0
leaq 0x2457(%rip), %rdi      # 0x56f7
leaq 0x2165(%rip), %rsi      # 0x540c
leaq 0x247f(%rip), %rcx      # 0x572d
movl $0x155, %edx            # imm = 0x155
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_destroy
void obint_destroy(obj *to_dealloc){

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

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

  free(instance->digits);

  return;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x32db
movq %rdi, %rbx
leaq 0x265d(%rip), %rsi      # 0x5925
callq 0x4cf6
testb %al, %al
je 0x32fa
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x1030
leaq 0x25d8(%rip), %rdi      # 0x58ba
leaq 0x2123(%rip), %rsi      # 0x540c
leaq 0x25d5(%rip), %rcx      # 0x58c5
movl $0x1e5, %edx            # imm = 0x1E5
callq 0x10a0
leaq 0x25de(%rip), %rdi      # 0x58df
leaq 0x2104(%rip), %rsi      # 0x540c
leaq 0x25b6(%rip), %rcx      # 0x58c5
movl $0x1e6, %edx            # imm = 0x1E6
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_hash
ob_hash_t obint_hash(const obj *to_hash){

  static int8_t init = 0;
  static ob_hash_t seed = 0;

  uint64_t i;
  ob_hash_t value;
  obint *instance = (obint *)to_hash;

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

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

  value = seed;

  i = obint_most_sig(instance);

  /* A version of Jenkin's one at a time hash function */
  for( ; i<instance->num_digits; i--){
    value += instance->digits[i];
    value += value << 10;
    value ^= value >> 6;
  }

  value += value << 3;
  value ^= value >> 11;
  value *= value << 15;
  return value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x33c4
movq %rdi, %rbx
leaq 0x25f5(%rip), %rsi      # 0x5925
callq 0x4cf6
testb %al, %al
je 0x33e3
cmpb $0x1, 0x5dac(%rip)      # 0x90f0
jne 0x334f
movq 0x5dab(%rip), %r14      # 0x90f8
jmp 0x3373
xorl %edi, %edi
callq 0x1140
movl %eax, %edi
callq 0x10e0
callq 0x1190
movslq %eax, %r14
movq %r14, 0x5d8c(%rip)      # 0x90f8
movb $0x1, 0x5d7d(%rip)      # 0x90f0
movq %rbx, %rdi
callq 0x2455
movq 0x18(%rbx), %rcx
cmpq %rcx, %rax
jae 0x33a6
movq 0x10(%rbx), %rdx
movsbq (%rdx,%rax), %rdx
addq %rdx, %r14
imulq $0x401, %r14, %rdx      # imm = 0x401
movq %rdx, %r14
shrq $0x6, %r14
xorq %rdx, %r14
decq %rax
jmp 0x337f
leaq (%r14,%r14,8), %rcx
movq %rcx, %rax
shrq $0xb, %rax
xorq %rcx, %rax
imulq %rax, %rax
shlq $0xf, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x23ed(%rip), %rdi      # 0x57b8
leaq 0x203a(%rip), %rsi      # 0x540c
leaq 0x23e7(%rip), %rcx      # 0x57c0
movl $0x182, %edx            # imm = 0x182
callq 0x10a0
leaq 0x23f8(%rip), %rdi      # 0x57e2
leaq 0x201b(%rip), %rsi      # 0x540c
leaq 0x23c8(%rip), %rcx      # 0x57c0
movl $0x183, %edx            # imm = 0x183
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_compare
int8_t obint_compare(const obj *a, const obj *b){

  int8_t magnitude_comp;
  const obint *comp_a = (obint *)a;
  const obint *comp_b = (obint *)b;

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

  /* if signs are equal magnitude comparision is required */
  if(comp_a->sign == comp_b->sign){

    magnitude_comp = obint_compare_magnitudes(comp_a, comp_b);

    /* reverse magnitude comparision if both are negative */
    if(comp_a->sign == -1){
      if(magnitude_comp == OB_LESS_THAN) magnitude_comp = OB_GREATER_THAN;
      else if(magnitude_comp == OB_GREATER_THAN) magnitude_comp = OB_LESS_THAN;
    }

    return magnitude_comp;
  }

  if(comp_a->sign == -1) return OB_LESS_THAN;
  return OB_GREATER_THAN;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3487
movq %rsi, %rbx
testq %rsi, %rsi
je 0x34a6
movq %rdi, %r14
leaq 0x2504(%rip), %rsi      # 0x5925
callq 0x4cf6
testb %al, %al
je 0x34c5
leaq 0x24f0(%rip), %rsi      # 0x5925
movq %rbx, %rdi
callq 0x4cf6
testb %al, %al
je 0x34e4
movb 0x8(%r14), %bpl
cmpb 0x8(%rbx), %bpl
jne 0x3473
movq %r14, %rdi
movq %rbx, %rsi
callq 0x289f
cmpb $-0x1, %bpl
jne 0x347e
cmpb $-0x1, %al
je 0x3483
cmpb $0x1, %al
movzbl %al, %ecx
movl $0xff, %eax
cmovnel %ecx, %eax
jmp 0x347e
cmpb $-0x1, %bpl
sete %al
negb %al
orb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x347e
leaq 0x2373(%rip), %rdi      # 0x5801
leaq 0x1f77(%rip), %rsi      # 0x540c
leaq 0x2367(%rip), %rcx      # 0x5803
movl $0x1a3, %edx            # imm = 0x1A3
callq 0x10a0
leaq 0x1c61(%rip), %rdi      # 0x510e
leaq 0x1f58(%rip), %rsi      # 0x540c
leaq 0x2348(%rip), %rcx      # 0x5803
movl $0x1a4, %edx            # imm = 0x1A4
callq 0x10a0
leaq 0x2366(%rip), %rdi      # 0x5832
leaq 0x1f39(%rip), %rsi      # 0x540c
leaq 0x2329(%rip), %rcx      # 0x5803
movl $0x1a5, %edx            # imm = 0x1A5
callq 0x10a0
leaq 0x2360(%rip), %rdi      # 0x584b
leaq 0x1f1a(%rip), %rsi      # 0x540c
leaq 0x230a(%rip), %rcx      # 0x5803
movl $0x1a6, %edx            # imm = 0x1A6
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_display
void obint_display(const obj *to_print){

  obstring *str;
  const obint *instance = (obint *)to_print;

  assert(to_print);
  assert(ob_has_class(to_print, "obint"));

  str = obint_to_string(instance);
  fprintf(stderr, "Value:\n  %s\n", obstring_cstring(str));

  ob_release((obj *)str);

  return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x355f
movq %rdi, %rbx
leaq 0x240f(%rip), %rsi      # 0x5925
callq 0x4cf6
testb %al, %al
je 0x357e
movq %rbx, %rdi
callq 0x25ad
movq %rax, %rbx
movq 0x5ac7(%rip), %rax      # 0x8ff8
movq (%rax), %r14
movq %rbx, %rdi
callq 0x3a19
leaq 0x236a(%rip), %rsi      # 0x58ad
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1110
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4c7e
leaq 0x22fe(%rip), %rdi      # 0x5864
leaq 0x1e9f(%rip), %rsi      # 0x540c
leaq 0x22f9(%rip), %rcx      # 0x586d
movl $0x1d4, %edx            # imm = 0x1D4
callq 0x10a0
leaq 0x2308(%rip), %rdi      # 0x588d
leaq 0x1e80(%rip), %rsi      # 0x540c
leaq 0x22da(%rip), %rcx      # 0x586d
movl $0x1d5, %edx            # imm = 0x1D5
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_magnitude
int64_t obint_magnitude(const obint *a){

  uint64_t i, most_sig;
  int64_t val;

  most_sig = obint_most_sig(a);
  val = 0;

  for(i=most_sig ; i <= most_sig; i--){
    val *= 10;
    val += a->digits[i];
  }

  return val;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2455
movq 0x10(%rbx), %rdx
xorl %ecx, %ecx
movq %rax, %rsi
cmpq %rax, %rsi
ja 0x35c5
imulq $0xa, %rcx, %rdi
movsbq (%rdx,%rsi), %rcx
addq %rdi, %rcx
decq %rsi
jmp 0x35af
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_split
void obint_split(const obint *a, uint64_t i, obint **b1, obint **b0){

  if(a->num_digits <= i){
    *b1 = obint_create_default(1);
    *b0 = obint_create_default(a->num_digits);
    memcpy((*b0)->digits, a->digits, a->num_digits);
  }
  else{
    *b1 = obint_create_default(a->num_digits - i);
    memcpy((*b1)->digits, (a->digits + i), a->num_digits-i);
    *b0 = obint_create_default(i);
    memcpy((*b0)->digits, (a->digits), i);
  }

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
subq %rsi, %rdi
jbe 0x361f
movq %rsi, %r15
callq 0x2355
movq %rax, (%r12)
movq 0x10(%rax), %rdi
movq 0x10(%rbx), %rsi
addq %r15, %rsi
movq 0x18(%rbx), %rdx
subq %r15, %rdx
callq 0x1120
movq %r15, %rdi
callq 0x2355
movq %rax, (%r14)
movq 0x10(%rax), %rdi
movq 0x10(%rbx), %rsi
movq %r15, %rdx
jmp 0x3643
pushq $0x1
popq %rdi
callq 0x2355
movq %rax, (%r12)
movq 0x18(%rbx), %rdi
callq 0x2355
movq %rax, (%r14)
movq 0x10(%rax), %rdi
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1120
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_shift
void obint_shift(obint *a, uint64_t m){

  int8_t *digits;

  /* if shifting by zero do nothing */
  if(m == 0) return;

  digits = malloc(sizeof(int8_t)*(a->num_digits + m));
  assert(digits);

  memset(digits, 0, m);
  memcpy(digits+m, a->digits, a->num_digits);

  free(a->digits);
  a->digits = digits;
  a->num_digits += m;

  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x36ae
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r12
leaq (%r12,%rsi), %rdi
callq 0x1150
testq %rax, %rax
je 0x36b8
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x10b0
movq %r15, %rdi
addq %rbx, %rdi
movq 0x10(%r14), %r13
movq %r13, %rsi
movq %r12, %rdx
callq 0x1120
movq %r13, %rdi
callq 0x1030
movq %r15, 0x10(%r14)
addq %rbx, 0x18(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1a61(%rip), %rdi      # 0x5120
leaq 0x1d46(%rip), %rsi      # 0x540c
leaq 0x2234(%rip), %rcx      # 0x5901
movl $0x2fa, %edx            # imm = 0x2FA
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obstring.c
// Function: obstring_new
obstring *obstring_new(const char *str){

  obstring *instance;

  assert(str);

  instance = obstring_create_default();

  instance->length = strlen(str);
  instance->str = realloc(instance->str, (instance->length+1)*sizeof(char));
  assert(instance->str);

  strcpy(instance->str, str);

  return instance;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3733
movq %rdi, %rbx
callq 0x3769
movq %rax, %r14
movq %rbx, %rdi
callq 0x1090
movl %eax, 0x10(%r14)
movq 0x8(%r14), %rdi
leal 0x1(%rax), %esi
callq 0x1170
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x374c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1060
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2325(%rip), %rdi      # 0x5a5f
leaq 0x21ea(%rip), %rsi      # 0x592b
leaq 0x21fa(%rip), %rcx      # 0x5942
pushq $0x13
jmp 0x3763
leaq 0x2494(%rip), %rdi      # 0x5be7
leaq 0x21d1(%rip), %rsi      # 0x592b
leaq 0x21e1(%rip), %rcx      # 0x5942
pushq $0x19
popq %rdx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obstring.c
// Function: obstring_create_default
obstring * obstring_create_default(void){

  static const char classname[] = "obstring";
  obstring *new_instance = malloc(sizeof(obstring));
  assert(new_instance != NULL);

  /* initialize base class data */
  ob_init_base((obj *)new_instance, &obstring_destroy, &obstring_hash,
               &obstring_compare, &obstring_display, classname);

  new_instance->str = malloc(sizeof(char));
  assert(new_instance->str);
  new_instance->str[0] = '\0';
  new_instance->length = 0;

  return new_instance;
}

// Assembly:
pushq %rbx
pushq $0x18
popq %rdi
callq 0x1150
testq %rax, %rax
je 0x37c2
movq %rax, %rbx
leaq 0x5c2(%rip), %rsi       # 0x3d43
leaq 0x61c(%rip), %rdx       # 0x3da4
leaq 0x6e6(%rip), %rcx       # 0x3e75
leaq 0x7ed(%rip), %r8        # 0x3f83
leaq 0x25aa(%rip), %r9       # 0x5d47
movq %rax, %rdi
callq 0x4aac
pushq $0x1
popq %rdi
callq 0x1150
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x37e1
movb $0x0, (%rax)
andl $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x1f97(%rip), %rdi      # 0x5760
leaq 0x215b(%rip), %rsi      # 0x592b
leaq 0x23e4(%rip), %rcx      # 0x5bbb
movl $0xd4, %edx
callq 0x10a0
leaq 0x23fb(%rip), %rdi      # 0x5be3
leaq 0x213c(%rip), %rsi      # 0x592b
leaq 0x23c5(%rip), %rcx      # 0x5bbb
movl $0xdb, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obstring.c
// Function: obstring_copy_substring
obstring * obstring_copy_substring(const obstring *s, int64_t start, uint32_t length){

  obstring *instance;

  assert(s);

  instance = obstring_create_default();

  /* account for negative indexing */
  if(start < 0) start += s->length;

  /* if negative indexing beyond start of string then modify range */
  if(start < 0){
    length += start; /* shrink length to not copy out of range space */
    start = 0;
  }

  /* if indexing beyond end of string then shrink lenght to not copy out of
   * range space */
  if(start+length > s->length) length = s->length - start;

  /* if specified range contains no characters return an "empty" string */
  if(start > s->length || start+length < 0 || s->length == 0 || length <= 0)
    return instance;

  instance->length = length;
  instance->str = realloc(instance->str, (length+1)*sizeof(char));
  assert(instance->str);

  strncpy(instance->str, s->str+start, length);
  instance->str[length] = '\0';

  return instance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x38b0
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3769
movl 0x10(%rbx), %ecx
movq %r14, %rdx
sarq $0x3f, %rdx
andl %ecx, %edx
addq %r14, %rdx
xorl %esi, %esi
testq %rdx, %rdx
movl $0x0, %r15d
cmovgq %rdx, %r15
movq %rax, %r14
cmovsq %rdx, %rsi
addl %ebp, %esi
leaq (%rsi,%r15), %rax
movl %ecx, %r13d
subl %r15d, %r13d
cmpq %rcx, %rax
cmovbel %esi, %r13d
cmpq %rcx, %rdx
jg 0x389e
testl %ecx, %ecx
je 0x389e
testl %r13d, %r13d
je 0x389e
movl %r13d, 0x10(%r14)
movq 0x8(%r14), %rdi
leal 0x1(%r13), %esi
callq 0x1170
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x38cd
movq %rax, %r12
movl %r13d, %r13d
addq 0x8(%rbx), %r15
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x1040
movb $0x0, (%r12,%r13)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x186e(%rip), %rdi      # 0x5125
leaq 0x206d(%rip), %rsi      # 0x592b
leaq 0x20a2(%rip), %rcx      # 0x5967
pushq $0x25
popq %rdx
callq 0x10a0
leaq 0x2313(%rip), %rdi      # 0x5be7
leaq 0x2050(%rip), %rsi      # 0x592b
leaq 0x2085(%rip), %rcx      # 0x5967
pushq $0x3c
jmp 0x38c7
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obstring.c
// Function: obstring_char_at_index
char obstring_char_at_index(const obstring *s, int64_t i){

  assert(s);

  if(i < 0) i += s->length; /* account for negative indexing */
  if(i >= s->length || i < 0) return '\0';
  return s->str[i];
}

// Assembly:
testq %rdi, %rdi
je 0x3931
movl 0x10(%rdi), %ecx
movq %rsi, %rax
sarq $0x3f, %rax
andl %ecx, %eax
addq %rsi, %rax
cmpq %rcx, %rax
jae 0x392e
movq 0x8(%rdi), %rcx
movb (%rcx,%rax), %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x17ec(%rip), %rdi      # 0x5125
leaq 0x1feb(%rip), %rsi      # 0x592b
leaq 0x2092(%rip), %rcx      # 0x59d9
pushq $0x4d
popq %rdx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obstring.c
// Function: obstring_concat
obstring * obstring_concat(const obstring *s1, const obstring *s2){

  obstring *concatted;

  assert(s1);
  assert(s2);

  concatted = obstring_create_default();
  concatted->length = s1->length + s2->length;

  if(concatted->length == 0) return concatted;

  concatted->str = realloc(concatted->str, (concatted->length+1)*sizeof(char));
  assert(concatted->str);

  if(s1->length > 0) strcpy(concatted->str, s1->str);
  if(s2->length > 0) strcpy(concatted->str+s1->length, s2->str);

  return concatted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x39ca
movq %rsi, %rbx
testq %rsi, %rsi
je 0x39e3
movq %rdi, %r15
callq 0x3769
movq %rax, %r14
movl 0x10(%rbx), %esi
addl 0x10(%r15), %esi
movl %esi, 0x10(%rax)
je 0x39bd
movq 0x8(%r14), %rdi
incl %esi
callq 0x1170
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x39fc
movq %rax, %r12
movl 0x10(%r15), %r13d
testq %r13, %r13
je 0x39a8
movq 0x8(%r15), %rsi
movq %r12, %rdi
callq 0x1060
cmpl $0x0, 0x10(%rbx)
je 0x39bd
addq %r13, %r12
movq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0x1060
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x203f(%rip), %rdi      # 0x5a10
leaq 0x1f53(%rip), %rsi      # 0x592b
leaq 0x2034(%rip), %rcx      # 0x5a13
pushq $0x59
jmp 0x3a13
leaq 0x2067(%rip), %rdi      # 0x5a51
leaq 0x1f3a(%rip), %rsi      # 0x592b
leaq 0x201b(%rip), %rcx      # 0x5a13
pushq $0x5a
jmp 0x3a13
leaq 0x2051(%rip), %rdi      # 0x5a54
leaq 0x1f21(%rip), %rsi      # 0x592b
leaq 0x2002(%rip), %rcx      # 0x5a13
pushq $0x62
popq %rdx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obstring.c
// Function: obstring_split
obvector * obstring_split(const obstring *s, const char *delim){

  obvector *tokens;
  obstring *copy, *substring;
  char *marker;
  uint32_t i, delim_len, substrs;


  assert(s);
  assert(delim);

  tokens = obvector_new(1);
  copy = obstring_copy_substring(s, 0, s->length);
  delim_len = strlen(delim);
  marker = copy->str;

  /* overwrite all instance of delimeter with NUL character(s) */
  while(marker <= copy->str+(copy->length - delim_len)){
    if(strncmp(marker, delim, delim_len) == 0)
      for(i=0; i<delim_len; i++) *(marker++) = '\0';
    else
      marker++;
  }

  marker = copy->str;

  /* copy all found substrings into new obstrings for Vector */
  substrs=0;
  while(marker < copy->str+copy->length){
    substring = obstring_new(marker);
    marker += substring->length;
    obvector_store_at_index(tokens, (obj *)substring, substrs++);
    ob_release((obj *)substring); /* only tokens vector needs a reference */
    while(*marker == '\0' && marker < copy->str + copy->length) marker++;
  }

  ob_release((obj *)copy);
  return tokens;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x3b62
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3b7b
movq %rdi, %r14
pushq $0x1
popq %rdi
callq 0x3ff8
movq %rax, (%rsp)
movl 0x10(%r14), %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3800
movq %rax, %r14
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
callq 0x1090
movq %rax, %rbx
movq 0x8(%r14), %r12
movl %ebx, %eax
movq %rax, 0x8(%rsp)
movq %r12, %rbp
movl 0x10(%r14), %r13d
movl %r13d, %r15d
subl %ebx, %r15d
addq %r12, %r15
cmpq %r15, %rbp
ja 0x3ae8
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1050
testl %eax, %eax
je 0x3acf
incq %rbp
jmp 0x3aaf
xorl %eax, %eax
cmpl %eax, %ebx
je 0x3adf
movb $0x0, (%rbp,%rax)
incq %rax
jmp 0x3ad1
movq 0x8(%r14), %r12
addq %rax, %rbp
jmp 0x3aa2
xorl %ebp, %ebp
movq %r12, %rbx
movl %r13d, %eax
addq %r12, %rax
cmpq %rax, %rbx
jae 0x3b47
movq %rbx, %rdi
callq 0x36e8
movq %rax, %r12
movl 0x10(%rax), %r15d
addq %rbx, %r15
movl %ebp, %edx
incl %ebp
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x416d
movq %r12, %rdi
callq 0x4c7e
movq 0x8(%r14), %r12
movl 0x10(%r14), %r13d
movq %r13, %rax
addq %r12, %rax
leaq 0x1(%r15), %rbx
cmpb $0x0, (%r15)
jne 0x3b42
cmpq %rax, %r15
movq %rbx, %r15
jb 0x3b30
decq %rbx
jmp 0x3aed
movq %r14, %rdi
callq 0x4c7e
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15bc(%rip), %rdi      # 0x5125
leaq 0x1dbb(%rip), %rsi      # 0x592b
leaq 0x1f1b(%rip), %rcx      # 0x5a92
pushq $0x79
jmp 0x3b92
leaq 0x1f49(%rip), %rdi      # 0x5acb
leaq 0x1da2(%rip), %rsi      # 0x592b
leaq 0x1f02(%rip), %rcx      # 0x5a92
pushq $0x7a
popq %rdx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obstring.c
// Function: obstring_find_substring
uint8_t obstring_find_substring(const obstring *s, const char *substring){

  uint32_t sublen;
  char *marker;

  assert(s);
  assert(substring);

  sublen = strlen(substring);

  for(marker = s->str; marker <= s->str +(s->length - sublen); marker++)
    if(strncmp(marker, substring, sublen) == 0) return 1;

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3bf7
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3c16
movq %rdi, %r12
movq %rbx, %rdi
callq 0x1090
movq 0x8(%r12), %r14
movl %eax, %r15d
movl 0x10(%r12), %r12d
subl %eax, %r12d
addq %r14, %r12
cmpq %r12, %r14
ja 0x3be9
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1050
incq %r14
testl %eax, %eax
jne 0x3bcb
movb $0x1, %al
jmp 0x3beb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1527(%rip), %rdi      # 0x5125
leaq 0x1d26(%rip), %rsi      # 0x592b
leaq 0x1ec5(%rip), %rcx      # 0x5ad1
movl $0x9f, %edx
callq 0x10a0
leaq 0x1ef4(%rip), %rdi      # 0x5b11
leaq 0x1d07(%rip), %rsi      # 0x592b
leaq 0x1ea6(%rip), %rcx      # 0x5ad1
movl $0xa0, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obstring.c
// Function: obstring_match_regex
obstring * obstring_match_regex(const obstring *s, const char *regex){

  regex_t comp_regex;
  regmatch_t match;
  int errcode;
  char errbuf[REGEX_ERROR_BUFFER_SIZE];

  assert(s);
  assert(regex);

  /* compile regex */
  if((errcode = regcomp(&comp_regex, regex, REG_EXTENDED))){
    regerror(errcode, &comp_regex, errbuf, REGEX_ERROR_BUFFER_SIZE);
    fprintf(stderr, "obstring::obstring_match_regex recieved improper regex\n"
                    "Regex supplied: %s\nError string:%s\n", regex, errbuf);

    regfree(&comp_regex);
    return obstring_new("");
  }

  /* match regex, returning empty string if no match was found */
  if(regexec(&comp_regex, s->str, 1, &match, 0)){
    regfree(&comp_regex);
    return obstring_new("");
  }

  regfree(&comp_regex);

  /* return a new string containing the matching range */
  return obstring_copy_substring(s, match.rm_so, match.rm_eo - match.rm_so);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
testq %rdi, %rdi
je 0x3d05
movq %rsi, %r14
testq %rsi, %rsi
je 0x3d24
movq %rdi, %rbx
movq %rsp, %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x10c0
testl %eax, %eax
jne 0x3cc3
movq 0x8(%rbx), %rsi
movq %rsp, %r14
pushq $0x1
popq %rdx
leaq 0x40(%rsp), %rcx
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x1160
movl %eax, %ebp
movq %r14, %rdi
callq 0x1080
testl %ebp, %ebp
je 0x3ca2
leaq 0x2553(%rip), %rdi      # 0x61ee
callq 0x36e8
jmp 0x3cb5
movslq 0x40(%rsp), %rsi
movl 0x44(%rsp), %edx
subl %esi, %edx
movq %rbx, %rdi
callq 0x3800
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsp, %rbx
leaq 0x40(%rsp), %r15
movl $0x100, %ecx            # imm = 0x100
movl %eax, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1130
movq 0x5314(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x1e72(%rip), %rsi      # 0x5b60
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1110
movq %rbx, %rdi
callq 0x1080
jmp 0x3c94
leaq 0x1419(%rip), %rdi      # 0x5125
leaq 0x1c18(%rip), %rsi      # 0x592b
leaq 0x1e01(%rip), %rcx      # 0x5b1b
movl $0xb2, %edx
callq 0x10a0
leaq 0x1e2f(%rip), %rdi      # 0x5b5a
leaq 0x1bf9(%rip), %rsi      # 0x592b
leaq 0x1de2(%rip), %rcx      # 0x5b1b
movl $0xb3, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obstring.c
// Function: obstring_destroy
void obstring_destroy(obj *to_dealloc){

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

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

  if(instance->str) free(instance->str);

  return;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3d66
movq %rdi, %rbx
leaq 0x1ff4(%rip), %rsi      # 0x5d47
callq 0x4cf6
testb %al, %al
je 0x3d85
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x1030
leaq 0x1b4d(%rip), %rdi      # 0x58ba
leaq 0x1bb7(%rip), %rsi      # 0x592b
leaq 0x1f8a(%rip), %rcx      # 0x5d05
movl $0x12a, %edx            # imm = 0x12A
callq 0x10a0
leaq 0x1f96(%rip), %rdi      # 0x5d22
leaq 0x1b98(%rip), %rsi      # 0x592b
leaq 0x1f6b(%rip), %rcx      # 0x5d05
movl $0x12b, %edx            # imm = 0x12B
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obstring.c
// Function: obstring_hash
ob_hash_t obstring_hash(const obj *to_hash){

  static int8_t init = 0;
  static ob_hash_t seed;

  obstring *instance = (obstring *)to_hash;
  ob_hash_t value;
  char *pos;

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

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

  value = seed;

  /* A version of Jenkin's one at a time hash function */
  pos = instance->str;
  while(*pos != '\0'){
    value += *(pos++);
    value += value << 10;
    value ^= value >> 6;
  }

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

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3e37
movq %rdi, %rbx
leaq 0x1f8f(%rip), %rsi      # 0x5d47
callq 0x4cf6
testb %al, %al
je 0x3e56
cmpb $0x1, 0x5334(%rip)      # 0x9100
jne 0x3dd7
movq 0x5333(%rip), %rax      # 0x9108
jmp 0x3dfa
xorl %edi, %edi
callq 0x1140
movl %eax, %edi
callq 0x10e0
callq 0x1190
cltq
movq %rax, 0x5315(%rip)      # 0x9108
movb $0x1, 0x5306(%rip)      # 0x9100
movq 0x8(%rbx), %rcx
movsbq (%rcx), %rdx
testq %rdx, %rdx
je 0x3e20
incq %rcx
addq %rdx, %rax
imulq $0x401, %rax, %rdx      # imm = 0x401
movq %rdx, %rax
shrq $0x6, %rax
xorq %rdx, %rax
jmp 0x3dfe
leaq (%rax,%rax,8), %rax
movq %rax, %rcx
shrq $0xb, %rcx
xorq %rax, %rcx
imulq $0x8001, %rcx, %rax     # imm = 0x8001
popq %rbx
retq
leaq 0x197a(%rip), %rdi      # 0x57b8
leaq 0x1ae6(%rip), %rsi      # 0x592b
leaq 0x1da9(%rip), %rcx      # 0x5bf5
movl $0xec, %edx
callq 0x10a0
leaq 0x1dbd(%rip), %rdi      # 0x5c1a
leaq 0x1ac7(%rip), %rsi      # 0x592b
leaq 0x1d8a(%rip), %rcx      # 0x5bf5
movl $0xed, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/theck01[P]offbrand_lib/src/classes/obstring.c
// Function: obstring_compare
int8_t obstring_compare(const obj *a, const obj *b){

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

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

  /* compare string contents where both have characters */
  for(i=0; i<comp_a->length && i<comp_b->length; i++){
    if(comp_a->str[i] < comp_b->str[i]) return OB_LESS_THAN;
    else if(comp_b->str[i] < comp_a->str[i]) return OB_GREATER_THAN;
  }

  /* if characters matched check lengths for final equality */
  if(comp_a->length < comp_b->length) return OB_LESS_THAN;
  else if(comp_b->length < comp_a->length) return OB_GREATER_THAN;
  return OB_EQUAL_TO;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3f07
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3f26
movq %rdi, %r14
leaq 0x1eaf(%rip), %rsi      # 0x5d47
callq 0x4cf6
testb %al, %al
je 0x3f45
leaq 0x1e9b(%rip), %rsi      # 0x5d47
movq %rbx, %rdi
callq 0x4cf6
testb %al, %al
je 0x3f64
movl 0x10(%r14), %ecx
movl 0x10(%rbx), %edx
xorl %eax, %eax
cmpq %rax, %rcx
je 0x3ef0
cmpq %rdx, %rax
jae 0x3ef0
movq 0x8(%r14), %rsi
movb (%rsi,%rax), %sil
movq 0x8(%rbx), %rdi
movb (%rdi,%rax), %dil
cmpb %dil, %sil
jl 0x3efd
incq %rax
cmpb %sil, %dil
jge 0x3ec5
movb $0x1, %al
jmp 0x3eff
movb $-0x1, %al
cmpl %edx, %ecx
jb 0x3eff
cmpl %ecx, %edx
setb %al
jmp 0x3eff
movb $-0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18f3(%rip), %rdi      # 0x5801
leaq 0x1a16(%rip), %rsi      # 0x592b
leaq 0x1d20(%rip), %rcx      # 0x5c3c
movl $0x10c, %edx            # imm = 0x10C
callq 0x10a0
leaq 0x11e1(%rip), %rdi      # 0x510e
leaq 0x19f7(%rip), %rsi      # 0x592b
leaq 0x1d01(%rip), %rcx      # 0x5c3c
movl $0x10d, %edx            # imm = 0x10D
callq 0x10a0
leaq 0x1d22(%rip), %rdi      # 0x5c6e
leaq 0x19d8(%rip), %rsi      # 0x592b
leaq 0x1ce2(%rip), %rcx      # 0x5c3c
movl $0x10e, %edx            # imm = 0x10E
callq 0x10a0
leaq 0x1d1f(%rip), %rdi      # 0x5c8a
leaq 0x19b9(%rip), %rsi      # 0x592b
leaq 0x1cc3(%rip), %rcx      # 0x5c3c
movl $0x10f, %edx            # imm = 0x10F
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/src/crypto.c
// Function: ff_derived_key_alloc
struct ff_derived_key *ff_derived_key_alloc(uint16_t length)
{
    struct ff_derived_key *key = malloc(sizeof(struct ff_derived_key));
    key->key = calloc(1, length);
    key->length = length;

    return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
pushq $0x10
popq %rdi
callq 0x23c0
movq %rax, %r14
movl %ebx, %esi
pushq $0x1
popq %rdi
callq 0x21f0
movq %rax, (%r14)
movw %bx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/src/crypto.c
// Function: ff_derived_key_free
void ff_derived_key_free(struct ff_derived_key *key)
{
    if (key == NULL)
    {
        return;
    }

    if (key->key != NULL)
    {
        FREE(key->key);
    }

    FREE(key);
}

// Assembly:
testq %rdi, %rdi
je 0x2f21
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2340
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2340
retq
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/src/crypto.c
// Function: ff_derive_key_pbkdf2
bool ff_derive_key_pbkdf2(
    struct ff_encryption_config *config,
    uint8_t *salt,
    uint16_t salt_length,
    struct ff_derived_key *out_key)

{
    int res = PKCS5_PBKDF2_HMAC(
        (char *)config->key,
        strlen((char *)config->key),
        salt, salt_length,
        config->pbkdf2_iterations,
        EVP_sha256(),
        out_key->length,
        out_key->key);

    bool success = res == 1;

    if (!success)
    {
        ff_log(FF_ERROR, ERR_error_string(ERR_get_error(), NULL));
        ff_log(FF_ERROR, "Failed to derive key using PBKDF2 algorithm");
    }

    return success;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, -0x2c(%rbp)
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %r13
movq %r13, %rdi
callq 0x2130
movq %rax, %r14
movl 0x8(%r12), %r12d
callq 0x2470
movzwl 0x8(%rbx), %r10d
movq %r13, %rdi
movl %r14d, %esi
movq %r15, %rdx
movl -0x2c(%rbp), %ecx
movl %r12d, %r8d
movq %rax, %r9
pushq (%rbx)
pushq %r10
callq 0x2460
popq %rcx
popq %rdx
movl %eax, %ebx
cmpl $0x1, %eax
je 0x2fae
callq 0x23b0
movq %rax, %rdi
xorl %esi, %esi
callq 0x20b0
pushq $0x4
popq %r14
movl %r14d, %edi
movq %rax, %rsi
xorl %eax, %eax
callq 0x3db4
leaq 0x2738(%rip), %rsi      # 0x56dc
movl %r14d, %edi
xorl %eax, %eax
callq 0x3db4
cmpl $0x1, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/src/hash_table.c
// Function: ff_hash_table_init
struct ff_hash_table *ff_hash_table_init(uint8_t prefix_bit_length)
{
    assert(prefix_bit_length > 0);

    struct ff_hash_table *hash_table = malloc(sizeof(struct ff_hash_table));

    hash_table->length = 0;
    *(uint8_t *)&hash_table->prefix_bit_length = prefix_bit_length;
    *(uint8_t *)&hash_table->bucket_levels = (int)ceil(hash_table->prefix_bit_length / FF_BUCKET_POOL_BITS);

    hash_table->buckets = ff_hash_table_init_bucket();
    hash_table->linked_list = NULL;
    hash_table->linked_list_last = NULL;

    return hash_table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %edi, %edi
je 0x3025
movl %edi, %ebx
pushq $0x20
popq %rdi
callq 0x23c0
movq %rax, %r14
andl $0x0, 0x4(%rax)
movb %bl, (%rax)
shrb $0x3, %bl
movb %bl, 0x1(%rax)
callq 0x3042
movq %rax, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x26dc(%rip), %rdi      # 0x5708
leaq 0x26eb(%rip), %rsi      # 0x571e
leaq 0x26f5(%rip), %rcx      # 0x572f
pushq $0x14
popq %rdx
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/src/hash_table.c
// Function: ff_hash_table_get_or_create_bucket
union ff_hash_table_bucket *ff_hash_table_get_or_create_bucket(
    struct ff_hash_table *hash_table,
    uint64_t item_id,
    bool should_create,
    union ff_hash_table_bucket **buckets_list)
{
    union ff_hash_table_bucket *buckets = hash_table->buckets;
    uint8_t hash;

    for (uint8_t level = 0; level < hash_table->bucket_levels - 1; level++)
    {
        hash = FF_HASH_GET_FOR_LEVEL(item_id, level);

        if (buckets[hash].buckets == NULL)
        {
            if (!should_create)
            {
                return NULL;
            }

            // Init new layer
            buckets[hash].buckets = ff_hash_table_init_bucket();
        }

        buckets = buckets[hash].buckets;

        if (buckets_list != NULL)
        {
            buckets_list[level] = buckets;
        }
    }

    hash = FF_HASH_GET_FOR_LEVEL(item_id, hash_table->bucket_levels - 1);
    buckets = &buckets[hash];

    return buckets;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movl %edx, -0x2c(%rbp)
movq %rdi, %r15
movq 0x8(%rdi), %r9
xorl %r12d, %r12d
movq %rsi, -0x38(%rbp)
movzbl %r12b, %ebx
movzbl 0x1(%r15), %eax
leal -0x1(%rax), %ecx
cmpl %ebx, %ecx
jle 0x30e7
leal (,%rbx,8), %eax
movb $0x38, %cl
subb %al, %cl
movq %rsi, %rdx
shlq %cl, %rdx
shrq %cl, %rdx
movl %eax, %ecx
shrq %cl, %rdx
movzbl %dl, %r13d
movl %r13d, %eax
movq (%r9,%rax,8), %rax
testq %rax, %rax
jne 0x30d4
cmpb $0x0, -0x2c(%rbp)
je 0x3105
movq %r9, -0x40(%rbp)
callq 0x3042
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rcx
movq %rax, (%rcx,%r13,8)
testq %r14, %r14
je 0x30df
movl %ebx, %ecx
movq %rax, (%r14,%rcx,8)
incb %r12b
movq %rax, %r9
jmp 0x3080
shll $0x3, %eax
movl %eax, %ecx
negb %cl
shlq %cl, %rsi
shrq %cl, %rsi
addb $-0x8, %al
movl %eax, %ecx
shrq %cl, %rsi
movzbl %sil, %eax
leaq (%r9,%rax,8), %rax
jmp 0x3107
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/src/hash_table.c
// Function: ff_hash_table_get_item
void *ff_hash_table_get_item(struct ff_hash_table *hash_table, uint64_t item_id)
{
    pthread_mutex_lock(&ff_hash_table_data_mutex);

    union ff_hash_table_bucket *buckets = ff_hash_table_get_or_create_bucket(hash_table, item_id, false, NULL);
    void *ret = NULL;

    if (buckets == NULL || buckets->nodes == NULL)
    {
        ret = NULL;
        goto cleanup;
    }

    struct ff_hash_table_node *node = buckets->nodes;

    do
    {
        if (node->item_id == item_id && node->value != NULL)
        {
            ret = node->value;
            goto cleanup;
        }
    } while ((node = node->next) != NULL);

cleanup:
    pthread_mutex_unlock(&ff_hash_table_data_mutex);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x61bb(%rip), %rdi      # 0x92e8
callq 0x2400
xorl %r14d, %r14d
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x305b
testq %rax, %rax
je 0x3168
movq (%rax), %rax
testq %rax, %rax
je 0x3165
cmpq %rbx, (%rax)
jne 0x315f
movq 0x8(%rax), %r14
testq %r14, %r14
jne 0x3168
movq 0x10(%rax), %rax
jmp 0x314c
xorl %r14d, %r14d
leaq 0x6179(%rip), %rdi      # 0x92e8
callq 0x2230
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/src/hash_table.c
// Function: ff_hash_table_put_item
void ff_hash_table_put_item(struct ff_hash_table *hash_table, uint64_t item_id, void *item)
{
    pthread_mutex_lock(&ff_hash_table_data_mutex);

    union ff_hash_table_bucket *buckets = ff_hash_table_get_or_create_bucket(hash_table, item_id, true, NULL);

    // Find last node or matching in chain
    struct ff_hash_table_node *node = buckets->nodes;
    struct ff_hash_table_node *last_node = node;

    while (node != NULL)
    {
        // Item already exists, update in hash table
        if (node->item_id == item_id)
        {
            node->value = item;
            goto cleanup;
        }

        last_node = node;
        node = node->next;
    }

    // Store new item in hash table
    struct ff_hash_table_node *new_node = calloc(1, sizeof(struct ff_hash_table_node));
    new_node->item_id = item_id;
    new_node->value = item;

    if (last_node == NULL)
    {
        buckets->nodes = new_node;
    }
    else
    {
        last_node->next = new_node;
    }

    // Store new item in global linked list
    if (hash_table->linked_list == NULL)
    {
        hash_table->linked_list = new_node;
        hash_table->linked_list_last = new_node;
    }
    else
    {
        new_node->prev_in_list = hash_table->linked_list_last;
        hash_table->linked_list_last->next_in_list = new_node;
        hash_table->linked_list_last = new_node;
    }

    hash_table->length++;

cleanup:
    pthread_mutex_unlock(&ff_hash_table_data_mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x6148(%rip), %rdi      # 0x92e8
callq 0x2400
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x305b
movq %rax, %r12
movq (%rax), %r13
movq %r13, %rax
testq %rax, %rax
je 0x31d1
cmpq %r15, (%rax)
je 0x3206
movq %rax, %r13
movq 0x10(%rax), %rax
jmp 0x31be
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x21f0
movq %r15, (%rax)
leaq 0x10(%r13), %rcx
testq %r13, %r13
cmoveq %r12, %rcx
movq %r14, 0x8(%rax)
movq %rax, (%rcx)
cmpq $0x0, 0x10(%rbx)
je 0x320c
movq 0x18(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x20(%rcx)
jmp 0x3210
movq %r14, 0x8(%rax)
jmp 0x3217
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
incl 0x4(%rbx)
leaq 0x60ca(%rip), %rdi      # 0x92e8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2230
// File: /workspace/github_c_makefile_star2_O2/TimeToogo[P]ff-proxy/src/hash_table.c
// Function: ff_hash_table_free_bucket_level
void ff_hash_table_free_bucket_level(uint8_t bucket_levels, union ff_hash_table_bucket *bucket)
{
    assert(bucket_levels > 0);

    if (bucket_levels > 1)
    {
        for (int i = 0; i < FF_BUCKET_POOL_LENGTH; i++)
        {
            if (bucket[i].buckets != NULL)
            {
                ff_hash_table_free_bucket_level(bucket_levels - 1, bucket[i].buckets);
            }
        }

        FREE(bucket);
    }
    else if (bucket_levels == 1)
    {
        for (int i = 0; i < FF_BUCKET_POOL_LENGTH; i++)
        {
            if (bucket[i].nodes != NULL)
            {
                struct ff_hash_table_node *node = bucket[i].nodes;
                struct ff_hash_table_node *tmp_node = NULL;

                while (node != NULL)
                {
                    tmp_node = node;
                    node = node->next;
                    FREE(tmp_node);
                }
            }
        }

        FREE(bucket);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x1, %edi
je 0x33d7
testl %edi, %edi
je 0x3416
decb %dil
xorl %r15d, %r15d
movzbl %dil, %r14d
cmpq $0x100, %r15            # imm = 0x100
je 0x3404
movq (%rbx,%r15,8), %rsi
testq %rsi, %rsi
je 0x33d2
movl %r14d, %edi
callq 0x3398
incq %r15
jmp 0x33b8
xorl %r14d, %r14d
cmpq $0x100, %r14            # imm = 0x100
je 0x3404
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
jne 0x33fa
jmp 0x33ff
movq 0x10(%rdi), %r15
callq 0x2340
movq %r15, %rdi
testq %rdi, %rdi
jne 0x33ee
incq %r14
jmp 0x33da
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2340
leaq 0x2344(%rip), %rdi      # 0x5761
leaq 0x22fa(%rip), %rsi      # 0x571e
leaq 0x2348(%rip), %rcx      # 0x5773
movl $0x134, %edx            # imm = 0x134
callq 0x21e0