LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pedro-onate[P]eva/eva.c
// Function: es_make_args
static es_val_t es_make_args(es_ctx_t* ctx, es_args_t* parent, int arity, int rest, int argc, es_val_t* argv)
{
  gc_root(ctx, parent);
  es_args_t* env = es_alloc(ctx, ES_ARGS_TYPE, sizeof(es_args_t) + argc * sizeof(es_val_t));
  int i = 0;
  env->parent = parent;
  env->size   = argc;
  for(; i < arity; i++)
    env->args[i] = argv[i];
  if (rest && argc > arity) {
    es_val_t iter = env->args[i] = es_cons(ctx, argv[i], es_nil);
    for(int j = i + 1; j < argc; j++) {
      es_set_cdr(iter, es_cons(ctx, argv[j], es_nil));
      iter = es_cdr(iter);
    }
  } else {
    env->args[i] = es_nil;
  }
  gc_unroot(ctx, 1);
  return es_obj_to_val(env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movl 0x2040(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x2040(%rdx)
movslq %ecx, %rcx
leaq -0x10(%rbp), %rdx
movq %rdx, 0x40(%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
shlq $0x3, %rdx
addq $0x20, %rdx
movl $0x10, %esi
callq 0x1bd0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x992a
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x98fe
cmpl $0x0, -0x18(%rbp)
je 0x99c4
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0x99c4
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x3, %edx
callq 0x1e10
movq -0x30(%rbp), %rcx
movslq -0x34(%rbp), %rdx
movq %rax, 0x20(%rcx,%rdx,8)
movq %rax, -0x40(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x99c2
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x3, %edx
callq 0x1e10
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x1f70
movq -0x40(%rbp), %rdi
callq 0x1f20
movq %rax, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x9974
jmp 0x99d5
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq $0x3, 0x20(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x2040(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x2040(%rax)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aparrish[P]rwet-examples-c/ap_getline.c
// Function: ap_getline
size_t ap_getline(char** linep, FILE* fp) {
	int current_index = 0;
	int length = 80;

	*linep = (char*)malloc(length);
	if (*linep == NULL) return -1;

	while (1) {
		int ch;
		ch = getc(fp);
		if (ch == EOF) {
			break;
		}
		/* if the string would be longer than the allocated buffer */
		/* + 2: one because current_index is zero-based, one for trailing \0 */
		if (current_index + 2 > length) {
			/* eighty more chars */
			size_t new_length = length + 80;
			char *new_linep;
			new_linep = (char*)realloc(*linep, new_length);
			if (new_linep == NULL) return -1;

			*linep = new_linep;
			length = new_length;
		}
		(*linep)[current_index] = ch;
		current_index++;
		if (ch == '\n') break;
	}
	(*linep)[current_index] = '\0';
	return current_index;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x50, -0x20(%rbp)
movslq -0x20(%rbp), %rdi
callq 0x10a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2ab8
movq $-0x1, -0x8(%rbp)
jmp 0x2b5c
jmp 0x2aba
movq -0x18(%rbp), %rdi
callq 0x10e0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x2ace
jmp 0x2b45
movl -0x1c(%rbp), %eax
addl $0x2, %eax
cmpl -0x20(%rbp), %eax
jle 0x2b1c
movl -0x20(%rbp), %eax
addl $0x50, %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x10b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2b0a
movq $-0x1, -0x8(%rbp)
jmp 0x2b5c
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0xa, -0x24(%rbp)
jne 0x2b40
jmp 0x2b45
jmp 0x2aba
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movslq -0x1c(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_new
obint * obint_new(int64_t num){

  uint64_t i, ds;
  int64_t partial_num;
  obint *instance;

  /* find the number of digits in the primitive, ensuring at least one for 0
   * case */
  ds = 1;
  partial_num = num/10;
  while(partial_num){
    partial_num /= 10;
    ds++;
  }

  ds = ds ? ds : 1;

  instance = obint_create_default(ds);
  if(num < 0){
    instance->sign = -1;
    num *= -1;
  }

  for(i = 0; i < ds; i++){
    instance->digits[i] = num%10;
    num /= 10;
  }

  return instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x244d
movq -0x20(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2426
cmpq $0x0, -0x18(%rbp)
je 0x245e
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x2469
movl $0x1, %eax
movq %rax, -0x30(%rbp)
jmp 0x2469
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x24f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x2496
movq -0x28(%rbp), %rax
movb $-0x1, 0x8(%rax)
imulq $-0x1, -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x24e5
movq -0x8(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x249e
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_create_default
obint * obint_create_default(uint64_t num_digits){

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

  /* initialize base class data */
  ob_init_base((obj *)new_instance, &obint_destroy, &obint_hash,
               &obint_compare, &obint_display, classname);

  new_instance->sign = 1; /* positive by default */

  new_instance->digits = malloc(sizeof(int8_t)*num_digits);
  assert(new_instance->digits != NULL);
  memset(new_instance->digits, 0, num_digits);

  new_instance->num_digits = num_digits;

  return new_instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x1130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2513
jmp 0x2532
leaq 0x5247(%rip), %rdi      # 0x7761
leaq 0x4eec(%rip), %rsi      # 0x740d
movl $0x167, %edx            # imm = 0x167
leaq 0x5249(%rip), %rcx      # 0x7776
callq 0x10a0
movq -0x10(%rbp), %rdi
leaq 0x1803(%rip), %rsi      # 0x3d40
leaq 0x188c(%rip), %rdx      # 0x3dd0
leaq 0x19d5(%rip), %rcx      # 0x3f20
leaq 0x1b2e(%rip), %r8       # 0x4080
leaq 0x53d3(%rip), %r9       # 0x792c
callq 0x6180
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x8(%rbp), %rdi
shlq $0x0, %rdi
callq 0x1130
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x258b
jmp 0x25aa
leaq 0x520a(%rip), %rdi      # 0x779c
leaq 0x4e74(%rip), %rsi      # 0x740d
movl $0x170, %edx            # imm = 0x170
leaq 0x51d1(%rip), %rcx      # 0x7776
callq 0x10a0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x10b0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_value
int64_t obint_value(const obint *a){

  uint64_t i, most_sig;
  int64_t val;

  assert(a != NULL);

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

  return val*a->sign;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x25f5
jmp 0x2614
leaq 0x4e07(%rip), %rdi      # 0x7403
leaq 0x4e0a(%rip), %rsi      # 0x740d
movl $0x34, %edx
leaq 0x4e12(%rip), %rcx      # 0x7421
callq 0x10a0
movq -0x8(%rbp), %rdi
callq 0x2690
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x266b
imulq $0xa, -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movsbq (%rax,%rcx), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2631
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movsbq 0x8(%rcx), %rcx
imulq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_most_sig
uint64_t obint_most_sig(const obint *a){

  uint64_t i;

  i = a->num_digits - 1;
  while(!a->digits[i] && i>0) i--;
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
subq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpb $0x0, (%rcx,%rdx)
movb %al, -0x11(%rbp)
jne 0x26ca
cmpq $0x0, -0x10(%rbp)
seta %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x26d3
jmp 0x26e1
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x26a8
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_from_string
obint * obint_from_string(const obstring *numstr){

  int8_t offset, sign;

  int32_t num;
  uint32_t strlen, i;
  uint64_t digits;
  obint *instance;

  assert(numstr != NULL);

  strlen = obstring_length(numstr);
  if(obstring_char_at_index(numstr, 0) == '-'){
    sign = -1;
    digits = strlen - 1;
    offset = 1;
  }
  else{
    sign = 1;
    digits = strlen;
    offset = 0;
  }
  assert(strlen > 0);

  instance = obint_create_default(digits);
  instance->sign = sign;
  for(i=0 ; i<digits; i++){
    num = obstring_char_at_index(numstr, i+offset) - '0';
    assert(num >= 0 && num <= 9);
    instance->digits[digits-i-1] = num;
  }

  /* zero is defined to be positive */
  if(obint_is_zero(instance)) instance->sign = 1;

  return instance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2705
jmp 0x2724
leaq 0x4d38(%rip), %rdi      # 0x7444
leaq 0x4cfa(%rip), %rsi      # 0x740d
movl $0x4a, %edx
leaq 0x4d34(%rip), %rcx      # 0x7453
callq 0x10a0
movq -0x8(%rbp), %rdi
callq 0x46a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x46f0
movsbl %al, %eax
cmpl $0x2d, %eax
jne 0x275b
movb $-0x1, -0xa(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movb $0x1, -0x9(%rbp)
jmp 0x276a
movb $0x1, -0xa(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
movb $0x0, -0x9(%rbp)
cmpl $0x0, -0x14(%rbp)
jbe 0x2772
jmp 0x2791
leaq 0x4d05(%rip), %rdi      # 0x747e
leaq 0x4c8d(%rip), %rsi      # 0x740d
movl $0x57, %edx
leaq 0x4cc7(%rip), %rcx      # 0x7453
callq 0x10a0
movq -0x20(%rbp), %rdi
callq 0x24f0
movq %rax, -0x28(%rbp)
movb -0xa(%rbp), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x8(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpq -0x20(%rbp), %rax
jae 0x282d
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %eax
movsbl -0x9(%rbp), %ecx
addl %ecx, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x46f0
movsbl %al, %eax
subl $0x30, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x27e5
cmpl $0x9, -0x10(%rbp)
jg 0x27e5
jmp 0x2804
leaq 0x4c9d(%rip), %rdi      # 0x7489
leaq 0x4c1a(%rip), %rsi      # 0x740d
movl $0x5d, %edx
leaq 0x4c54(%rip), %rcx      # 0x7453
callq 0x10a0
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %esi
subq %rsi, %rcx
subq $0x1, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x27af
movq -0x28(%rbp), %rdi
callq 0x2850
cmpb $0x0, %al
je 0x2842
movq -0x28(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_is_zero
uint8_t obint_is_zero(const obint *a){

  uint64_t most_sig;

  assert(a != NULL);

  most_sig = obint_most_sig(a);
  return most_sig == 0 && a->digits[0] == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2865
jmp 0x2884
leaq 0x4b97(%rip), %rdi      # 0x7403
leaq 0x4b9a(%rip), %rsi      # 0x740d
movl $0x96, %edx
leaq 0x4c69(%rip), %rcx      # 0x74e8
callq 0x10a0
movq -0x8(%rbp), %rdi
callq 0x2690
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
jne 0x28b1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_to_string
obstring * obint_to_string(const obint *a){

  uint8_t offset = 0;
  uint64_t most_sig, i;
  char *str;
  obstring *result;

  assert(a != NULL);

  if(a->sign == -1) offset = 1;
  most_sig = obint_most_sig(a);
  str = malloc(sizeof(char)*(most_sig+2+offset));

  /* generate cstring from int */
  str[0] = '-'; /* non-negatives will overwrite value in following loop */
  for(i=most_sig; i<=most_sig; i--) str[most_sig-i+offset] = a->digits[i] + '0';
  str[most_sig+1+offset] = '\0';

  result = obstring_new(str);
  free(str);

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x28d9
jmp 0x28f8
leaq 0x4b23(%rip), %rdi      # 0x7403
leaq 0x4b26(%rip), %rsi      # 0x740d
movl $0x6f, %edx
leaq 0x4bab(%rip), %rcx      # 0x749e
callq 0x10a0
movq -0x8(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $-0x1, %eax
jne 0x2909
movb $0x1, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2690
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2, %rdi
movzbl -0x9(%rbp), %eax
addq %rax, %rdi
shlq $0x0, %rdi
callq 0x1130
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x2d, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x2984
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq -0x20(%rbp), %rcx
movzbl -0x9(%rbp), %esi
addq %rsi, %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2941
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movzbl -0x9(%rbp), %edx
addq %rdx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rdi
callq 0x4390
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_copy
obint * obint_copy(const obint *a){

  uint64_t i, most_sig;
  obint *copy;

  assert(a != NULL);

  most_sig = obint_most_sig(a);

  copy = obint_create_default(most_sig+1);
  for(i=0; i<= most_sig; i++) copy->digits[i] = a->digits[i];
  copy->sign = a->sign;

  return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x29d5
jmp 0x29f4
leaq 0x4a27(%rip), %rdi      # 0x7403
leaq 0x4a2a(%rip), %rsi      # 0x740d
movl $0x86, %edx
leaq 0x4ad8(%rip), %rcx      # 0x74c7
callq 0x10a0
movq -0x8(%rbp), %rdi
callq 0x2690
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x24f0
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x2a50
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2a1a
movq -0x8(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_add
obint * obint_add(const obint *a, const obint *b){

  int8_t cmp_result;
  obint *result;

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

  /* a and b are  of same 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 opposite sign */
  cmp_result = obint_compare_magnitudes(a,b);
  if(cmp_result == OB_LESS_THAN){
    result = obint_subtract_unsigned(b,a);
    result->sign = b->sign;
    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 opposite, result is 0 */
  return obint_new(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2ad9
jmp 0x2af8
leaq 0x4923(%rip), %rdi      # 0x7403
leaq 0x4926(%rip), %rsi      # 0x740d
movl $0xa8, %edx
leaq 0x4a43(%rip), %rcx      # 0x7536
callq 0x10a0
cmpq $0x0, -0x18(%rbp)
je 0x2b01
jmp 0x2b20
leaq 0x4a5d(%rip), %rdi      # 0x7565
leaq 0x48fe(%rip), %rsi      # 0x740d
movl $0xa9, %edx
leaq 0x4a1b(%rip), %rcx      # 0x7536
callq 0x10a0
movq -0x10(%rbp), %rdi
callq 0x2a70
movzbl %al, %eax
cmpl $0x0, %eax
je 0x2b42
movq -0x18(%rbp), %rdi
callq 0x2a70
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2b5c
movq -0x10(%rbp), %rdi
callq 0x2a70
cmpb $0x0, %al
jne 0x2b88
movq -0x18(%rbp), %rdi
callq 0x2a70
cmpb $0x0, %al
jne 0x2b88
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c20
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c0b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2e00
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $-0x1, %eax
jne 0x2bca
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ed0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c0b
movsbl -0x19(%rbp), %eax
cmpl $0x1, %eax
jne 0x2bfc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2ed0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c0b
jmp 0x2bfe
xorl %eax, %eax
movl %eax, %edi
callq 0x2400
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_compare_magnitudes
int8_t obint_compare_magnitudes(const obint *a, const obint *b){

  uint64_t i,j;

  i = obint_most_sig(a);
  j = obint_most_sig(b);

  if(i < j) return OB_LESS_THAN;
  if(i > j) return OB_GREATER_THAN;

  /* number of digits is equal, resort to digit by digit comparision */
  for( ; i<a->num_digits; i--){
    if(a->digits[i] < b->digits[i]) return OB_LESS_THAN;
    if(a->digits[i] > b->digits[i]) return OB_GREATER_THAN;
  }

  return OB_EQUAL_TO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2690
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2690
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x2e3d
movb $-0x1, -0x1(%rbp)
jmp 0x2ec5
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x2e4d
movb $0x1, -0x1(%rbp)
jmp 0x2ec5
jmp 0x2e4f
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x2ec1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x2e87
movb $-0x1, -0x1(%rbp)
jmp 0x2ec5
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jle 0x2eb1
movb $0x1, -0x1(%rbp)
jmp 0x2ec5
jmp 0x2eb3
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2e4f
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/obint.c
// Function: obint_subtract_unsigned
obint * obint_subtract_unsigned(const obint *a, const obint *b){

  uint64_t i, a_most_sig, b_most_sig;
  obint *result;

  result = obint_copy(a);

  a_most_sig = obint_most_sig(a);
  b_most_sig = obint_most_sig(b);

  for(i=0; i<=b_most_sig; i++){
    /* perform borrow operation if needed */
    if(result->digits[i] < b->digits[i]){
      result->digits[i+1]--;
      result->digits[i] += 10;
    }

    result->digits[i] -= b->digits[i];
  }

  /* propagate any final borrow */
  while(i < a_most_sig && result->digits[i] < 0){
    result->digits[i+1]--;
    result->digits[i] += 10;
    i++;
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29c0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2690
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2690
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x2fa4
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x2f6e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movb 0x1(%rax,%rcx), %dl
addb $-0x1, %dl
movb %dl, 0x1(%rax,%rcx)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edx
addl $0xa, %edx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %esi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edx
subl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2f0f
jmp 0x2fa6
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x2fce
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2fd7
jmp 0x3012
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movb 0x1(%rax,%rcx), %dl
addb $-0x1, %dl
movb %dl, 0x1(%rax,%rcx)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edx
addl $0xa, %edx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2fa6
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/obint.c
// Function: obint_add_primitive
obint * obint_add_primitive(const obint *a, int64_t b){

  obint *wrapper, *result;

  assert(a != NULL);

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

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3039
jmp 0x3058
leaq 0x43c3(%rip), %rdi      # 0x7403
leaq 0x43c6(%rip), %rsi      # 0x740d
movl $0xc9, %edx
leaq 0x451c(%rip), %rcx      # 0x756f
callq 0x10a0
movq -0x10(%rbp), %rdi
callq 0x2400
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2ac0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6480
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x30a9
jmp 0x30c8
leaq 0x4353(%rip), %rdi      # 0x7403
leaq 0x4356(%rip), %rsi      # 0x740d
movl $0xd8, %edx
leaq 0x44df(%rip), %rcx      # 0x75a2
callq 0x10a0
cmpq $0x0, -0x18(%rbp)
je 0x30d1
jmp 0x30f0
leaq 0x448d(%rip), %rdi      # 0x7565
leaq 0x432e(%rip), %rsi      # 0x740d
movl $0xd9, %edx
leaq 0x44b7(%rip), %rcx      # 0x75a2
callq 0x10a0
movq -0x10(%rbp), %rdi
callq 0x2a70
cmpb $0x0, %al
jne 0x310e
movq -0x18(%rbp), %rdi
callq 0x2a70
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x312c
movq -0x10(%rbp), %rdi
callq 0x2a70
movzbl %al, %eax
cmpl $0x0, %eax
je 0x3158
movq -0x18(%rbp), %rdi
callq 0x2a70
cmpb $0x0, %al
jne 0x3158
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2c20
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x31e1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2e00
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $-0x1, %eax
jne 0x31a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ed0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x8(%rax), %eax
imull $-0x1, %eax, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x31e1
movsbl -0x19(%rbp), %eax
cmpl $0x1, %eax
jne 0x31d2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2ed0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x31e1
jmp 0x31d4
xorl %eax, %eax
movl %eax, %edi
callq 0x2400
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3209
jmp 0x3228
leaq 0x41f3(%rip), %rdi      # 0x7403
leaq 0x41f6(%rip), %rsi      # 0x740d
movl $0xf9, %edx
leaq 0x43b3(%rip), %rcx      # 0x75d6
callq 0x10a0
movq -0x10(%rbp), %rdi
callq 0x2400
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3090
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6480
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3279
jmp 0x3298
leaq 0x4183(%rip), %rdi      # 0x7403
leaq 0x4186(%rip), %rsi      # 0x740d
movl $0x107, %edx            # imm = 0x107
leaq 0x437b(%rip), %rcx      # 0x760e
callq 0x10a0
cmpq $0x0, -0x10(%rbp)
je 0x32a1
jmp 0x32c0
leaq 0x42bd(%rip), %rdi      # 0x7565
leaq 0x415e(%rip), %rsi      # 0x740d
movl $0x108, %edx            # imm = 0x108
leaq 0x4353(%rip), %rcx      # 0x760e
callq 0x10a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3300
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
movsbl 0x8(%rcx), %ecx
imull %ecx, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x35c9
jmp 0x35e8
leaq 0x3e33(%rip), %rdi      # 0x7403
leaq 0x3e36(%rip), %rsi      # 0x740d
movl $0x115, %edx            # imm = 0x115
leaq 0x405f(%rip), %rcx      # 0x7642
callq 0x10a0
movq -0x10(%rbp), %rdi
callq 0x2400
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3260
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6480
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3639
jmp 0x3658
leaq 0x3dc3(%rip), %rdi      # 0x7403
leaq 0x3dc6(%rip), %rsi      # 0x740d
movl $0x123, %edx            # imm = 0x123
leaq 0x4027(%rip), %rcx      # 0x767a
callq 0x10a0
cmpq $0x0, -0x10(%rbp)
je 0x3661
jmp 0x3680
leaq 0x3efd(%rip), %rdi      # 0x7565
leaq 0x3d9e(%rip), %rsi      # 0x740d
movl $0x124, %edx            # imm = 0x124
leaq 0x3fff(%rip), %rcx      # 0x767a
callq 0x10a0
movq -0x10(%rbp), %rdi
callq 0x2850
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3693
jmp 0x36b2
leaq 0x4012(%rip), %rdi      # 0x76ac
leaq 0x3d6c(%rip), %rsi      # 0x740d
movl $0x125, %edx            # imm = 0x125
leaq 0x3fcd(%rip), %rcx      # 0x767a
callq 0x10a0
xorl %eax, %eax
movl %eax, %edi
callq 0x2400
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
callq 0x3710
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
movsbl 0x8(%rcx), %ecx
imull %ecx, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x6480
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3b39
jmp 0x3b58
leaq 0x38c3(%rip), %rdi      # 0x7403
leaq 0x38c6(%rip), %rsi      # 0x740d
movl $0x134, %edx            # imm = 0x134
leaq 0x3b6f(%rip), %rcx      # 0x76c2
callq 0x10a0
cmpq $0x0, -0x10(%rbp)
je 0x3b61
jmp 0x3b80
leaq 0x3b90(%rip), %rdi      # 0x76f8
leaq 0x389e(%rip), %rsi      # 0x740d
movl $0x135, %edx            # imm = 0x135
leaq 0x3b47(%rip), %rcx      # 0x76c2
callq 0x10a0
movq -0x10(%rbp), %rdi
callq 0x2400
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3620
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6480
movq -0x20(%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/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3bd9
jmp 0x3bf8
leaq 0x3823(%rip), %rdi      # 0x7403
leaq 0x3826(%rip), %rsi      # 0x740d
movl $0x143, %edx            # imm = 0x143
leaq 0x3b0c(%rip), %rcx      # 0x76ff
callq 0x10a0
cmpq $0x0, -0x10(%rbp)
je 0x3c01
jmp 0x3c20
leaq 0x395d(%rip), %rdi      # 0x7565
leaq 0x37fe(%rip), %rsi      # 0x740d
movl $0x144, %edx            # imm = 0x144
leaq 0x3ae4(%rip), %rcx      # 0x76ff
callq 0x10a0
movq -0x10(%rbp), %rdi
callq 0x2850
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3c33
jmp 0x3c52
leaq 0x3a72(%rip), %rdi      # 0x76ac
leaq 0x37cc(%rip), %rsi      # 0x740d
movl $0x145, %edx            # imm = 0x145
leaq 0x3ab2(%rip), %rcx      # 0x76ff
callq 0x10a0
xorl %eax, %eax
movl %eax, %edi
callq 0x2400
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x3710
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x6480
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3cb9
jmp 0x3cd8
leaq 0x3743(%rip), %rdi      # 0x7403
leaq 0x3746(%rip), %rsi      # 0x740d
movl $0x154, %edx            # imm = 0x154
leaq 0x3a5b(%rip), %rcx      # 0x772e
callq 0x10a0
cmpq $0x0, -0x10(%rbp)
je 0x3ce1
jmp 0x3d00
leaq 0x3a10(%rip), %rdi      # 0x76f8
leaq 0x371e(%rip), %rsi      # 0x740d
movl $0x155, %edx            # imm = 0x155
leaq 0x3a33(%rip), %rcx      # 0x772e
callq 0x10a0
movq -0x10(%rbp), %rdi
callq 0x2400
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3bc0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6480
movq -0x20(%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/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3d5d
jmp 0x3d7c
leaq 0x3b5d(%rip), %rdi      # 0x78c1
leaq 0x36a2(%rip), %rsi      # 0x740d
movl $0x1e5, %edx            # imm = 0x1E5
leaq 0x3b55(%rip), %rcx      # 0x78cc
callq 0x10a0
movq -0x8(%rbp), %rdi
leaq 0x3a5c(%rip), %rsi      # 0x77e3
callq 0x65a0
cmpb $0x0, %al
je 0x3d92
jmp 0x3db1
leaq 0x3b4d(%rip), %rdi      # 0x78e6
leaq 0x366d(%rip), %rsi      # 0x740d
movl $0x1e6, %edx            # imm = 0x1E6
leaq 0x3b20(%rip), %rcx      # 0x78cc
callq 0x10a0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3ded
jmp 0x3e0c
leaq 0x39c5(%rip), %rdi      # 0x77b9
leaq 0x3612(%rip), %rsi      # 0x740d
movl $0x182, %edx            # imm = 0x182
leaq 0x39ba(%rip), %rcx      # 0x77c1
callq 0x10a0
movq -0x8(%rbp), %rdi
leaq 0x39cc(%rip), %rsi      # 0x77e3
callq 0x65a0
cmpb $0x0, %al
je 0x3e22
jmp 0x3e41
leaq 0x39c0(%rip), %rdi      # 0x77e9
leaq 0x35dd(%rip), %rsi      # 0x740d
movl $0x183, %edx            # imm = 0x183
leaq 0x3985(%rip), %rcx      # 0x77c1
callq 0x10a0
movsbl 0x7290(%rip), %eax      # 0xb0d8
cmpl $0x0, %eax
jne 0x3e72
xorl %eax, %eax
movl %eax, %edi
callq 0x1120
movl %eax, %edi
callq 0x10d0
callq 0x1160
cltq
movq %rax, 0x7275(%rip)      # 0xb0e0
movb $0x1, 0x7266(%rip)      # 0xb0d8
movq 0x7267(%rip), %rax      # 0xb0e0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2690
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x3edf
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movsbq (%rax,%rcx), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0xa, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x6, %rax
xorq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3e8a
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
imulq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
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 0x3f49
jmp 0x3f68
leaq 0x38b8(%rip), %rdi      # 0x7808
leaq 0x34b6(%rip), %rsi      # 0x740d
movl $0x1a3, %edx            # imm = 0x1A3
leaq 0x38a7(%rip), %rcx      # 0x780a
callq 0x10a0
cmpq $0x0, -0x18(%rbp)
je 0x3f71
jmp 0x3f90
leaq 0x3196(%rip), %rdi      # 0x710e
leaq 0x348e(%rip), %rsi      # 0x740d
movl $0x1a4, %edx            # imm = 0x1A4
leaq 0x387f(%rip), %rcx      # 0x780a
callq 0x10a0
movq -0x10(%rbp), %rdi
leaq 0x3848(%rip), %rsi      # 0x77e3
callq 0x65a0
cmpb $0x0, %al
je 0x3fa6
jmp 0x3fc5
leaq 0x388c(%rip), %rdi      # 0x7839
leaq 0x3459(%rip), %rsi      # 0x740d
movl $0x1a5, %edx            # imm = 0x1A5
leaq 0x384a(%rip), %rcx      # 0x780a
callq 0x10a0
movq -0x18(%rbp), %rdi
leaq 0x3813(%rip), %rsi      # 0x77e3
callq 0x65a0
cmpb $0x0, %al
je 0x3fdb
jmp 0x3ffa
leaq 0x3870(%rip), %rdi      # 0x7852
leaq 0x3424(%rip), %rsi      # 0x740d
movl $0x1a6, %edx            # imm = 0x1A6
leaq 0x3815(%rip), %rcx      # 0x780a
callq 0x10a0
movq -0x28(%rbp), %rax
movsbl 0x8(%rax), %eax
movq -0x30(%rbp), %rcx
movsbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x4053
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2e00
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $-0x1, %eax
jne 0x404b
movsbl -0x19(%rbp), %eax
cmpl $-0x1, %eax
jne 0x403a
movb $0x1, -0x19(%rbp)
jmp 0x4049
movsbl -0x19(%rbp), %eax
cmpl $0x1, %eax
jne 0x4047
movb $-0x1, -0x19(%rbp)
jmp 0x4049
jmp 0x404b
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x406a
movq -0x28(%rbp), %rax
movsbl 0x8(%rax), %eax
cmpl $-0x1, %eax
jne 0x4066
movb $-0x1, -0x1(%rbp)
jmp 0x406a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theck01[P]offbrand_lib/src/classes/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x409d
jmp 0x40bc
leaq 0x37c7(%rip), %rdi      # 0x786b
leaq 0x3362(%rip), %rsi      # 0x740d
movl $0x1d4, %edx            # imm = 0x1D4
leaq 0x37bd(%rip), %rcx      # 0x7874
callq 0x10a0
movq -0x8(%rbp), %rdi
leaq 0x371c(%rip), %rsi      # 0x77e3
callq 0x65a0
cmpb $0x0, %al
je 0x40d2
jmp 0x40f1
leaq 0x37bb(%rip), %rdi      # 0x7894
leaq 0x332d(%rip), %rsi      # 0x740d
movl $0x1d5, %edx            # imm = 0x1D5
leaq 0x3788(%rip), %rcx      # 0x7874
callq 0x10a0
movq -0x18(%rbp), %rdi
callq 0x28c0
movq %rax, -0x10(%rbp)
movq 0x6ef3(%rip), %rax      # 0xaff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48d0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x3791(%rip), %rsi      # 0x78b4
movb $0x0, %al
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x6480
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2690
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x41a3
imulq $0xa, -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movsbq (%rax,%rcx), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4169
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x10(%rbp), %rax
ja 0x4223
movl $0x1, %edi
callq 0x24f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x24f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x1100
jmp 0x4295
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
subq -0x10(%rbp), %rdi
callq 0x24f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
addq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
subq -0x10(%rbp), %rdx
callq 0x1100
movq -0x10(%rbp), %rdi
callq 0x24f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x42bc
jmp 0x4352
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
addq -0x10(%rbp), %rdi
shlq $0x0, %rdi
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x42de
jmp 0x42fd
leaq 0x2e3b(%rip), %rdi      # 0x7120
leaq 0x3121(%rip), %rsi      # 0x740d
movl $0x2fa, %edx            # imm = 0x2FA
leaq 0x3610(%rip), %rcx      # 0x7908
callq 0x10a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x10b0
movq -0x18(%rbp), %rdi
addq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x1100
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)