LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/ref.c
// Function: saveCurrentLine
void saveCurrentLine()
{
  REFERENCE *refPtr;
  
  refPtr = (REFERENCE *)my_malloc(sizeof(REFERENCE) + (long)strlen(srcLine) + 1UL );

  strcpy(refPtr->src,srcLine);
  refPtr->line = Current.Line-1;
  refPtr->file = Current.File;
  refPtr->macroline = Current.Macro.Line;
  refPtr->macrofile = Current.Macro.File;
  refPtr->macroinvoked = Current.Macro.invoked;
  refPtr->macro = Current.Macro.Processing;
  //  refPtr->var = Current.var;
  refPtr->pc = Global.OldPC;
  refPtr->codePtr = code.OldPtr;
  refPtr->up =
  refPtr->down = (REFERENCE *)0;
  refPtr->unknown = unknownLabel;
  refPtr->mode = sourceMode;

  if ( refFirst ){
    refPtr->down = refLast;
    refLast->up = refPtr;
  } else {
    refFirst = refPtr;
  }
  refLast = refPtr;

//->   printf("ref.c: %s (%s) = %p\n",unknownLabel->name,srcLine,refLast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x13e21(%rip), %rdi     # 0x20e10
callq 0x30a0
movq %rax, %rdi
addq $0x50, %rdi
addq $0x1, %rdi
callq 0x32e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
leaq 0x13df9(%rip), %rsi     # 0x20e10
callq 0x3060
leaq 0xb5d5(%rip), %rax      # 0x185f8
movl (%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
leaq 0xb5c2(%rip), %rax      # 0x185f8
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
leaq 0xb5b1(%rip), %rax      # 0x185f8
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
leaq 0xb5a0(%rip), %rax      # 0x185f8
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
leaq 0xb58f(%rip), %rax      # 0x185f8
movl 0x24(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
leaq 0xb57e(%rip), %rax      # 0x185f8
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
leaq 0xb315(%rip), %rax      # 0x183a0
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
leaq 0xb524(%rip), %rax      # 0x185c0
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
leaq 0x13c1a(%rip), %rax     # 0x20ce0
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
leaq 0xb508(%rip), %rax      # 0x185e0
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
cmpq $0x0, 0x19ca7(%rip)     # 0x26d90
je 0xd10a
movq 0x19ca6(%rip), %rcx     # 0x26d98
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq 0x19c93(%rip), %rax     # 0x26d98
movq %rcx, (%rax)
jmp 0xd115
movq -0x8(%rbp), %rax
movq %rax, 0x19c7b(%rip)     # 0x26d90
movq -0x8(%rbp), %rax
movq %rax, 0x19c78(%rip)     # 0x26d98
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/error.c
// Function: Warning
void Warning(const char *s)
{
  cntWarning++;
  if (warning && Current.File >= 0){
    if ( Current.Macro.Line ){
      fprintf(my_stderr,"WARNING: %s;%d:Macro-Line %5d:<%s>: '%s'\n",
	      file_list[Current.File].name,Current.Line,
	      Current.Macro.Line,file_list[Current.Macro.File].name,
              srcLine);
    } else {
      fprintf(my_stderr,"WARNING: %s:%5d: '%s'\n",
              file_list[Current.File].name,Current.Line, srcLine);
    }
    printf("%s\n",s);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xaa61(%rip), %rax      # 0x18384
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xaa55(%rip), %rax      # 0x18384
movl %ecx, (%rax)
leaq 0xaa30(%rip), %rax      # 0x18368
cmpl $0x0, (%rax)
je 0xda32
leaq 0xacb0(%rip), %rax      # 0x185f8
cmpl $0x0, 0x4(%rax)
jl 0xda32
leaq 0xac9f(%rip), %rax      # 0x185f8
cmpl $0x0, 0x10(%rax)
je 0xd9d8
leaq 0xac82(%rip), %rax      # 0x185e8
movq (%rax), %rdi
leaq 0xac88(%rip), %rax      # 0x185f8
movslq 0x4(%rax), %rax
leaq 0xae55(%rip), %rdx      # 0x187d0
imulq $0x204, %rax, %rax      # imm = 0x204
addq %rax, %rdx
addq $0x4, %rdx
leaq 0xac68(%rip), %rax      # 0x185f8
movl (%rax), %ecx
leaq 0xac5f(%rip), %rax      # 0x185f8
movl 0x10(%rax), %r8d
leaq 0xac54(%rip), %rax      # 0x185f8
movslq 0x14(%rax), %rax
leaq 0xae21(%rip), %r9       # 0x187d0
imulq $0x204, %rax, %rax      # imm = 0x204
addq %rax, %r9
addq $0x4, %r9
leaq 0x426d(%rip), %rsi      # 0x11c31
leaq 0x13445(%rip), %rax     # 0x20e10
movq %rax, (%rsp)
movb $0x0, %al
callq 0x3120
jmp 0xda20
leaq 0xac09(%rip), %rax      # 0x185e8
movq (%rax), %rdi
leaq 0xac0f(%rip), %rax      # 0x185f8
movslq 0x4(%rax), %rax
leaq 0xaddc(%rip), %rdx      # 0x187d0
imulq $0x204, %rax, %rax      # imm = 0x204
addq %rax, %rdx
addq $0x4, %rdx
leaq 0xabef(%rip), %rax      # 0x185f8
movl (%rax), %ecx
leaq 0x4249(%rip), %rsi      # 0x11c5b
leaq 0x133f7(%rip), %r8      # 0x20e10
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rsi
leaq 0x4165(%rip), %rdi      # 0x11b90
movb $0x0, %al
callq 0x30b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/jaguar.c
// Function: one_reg
int one_reg(int op)
{
  int reg;

  if ( GetRegister( &reg) ) return 1;

  // handle UNPACK specially
  if ( op == 64 ){
    op = ( 63 << 10 ) | 32 | reg;
  } else {
    op = (op << 10) | reg;
  }
  writeOp( op );

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0xde90
cmpl $0x0, %eax
je 0xe262
movl $0x1, -0x4(%rbp)
jmp 0xe293
cmpl $0x40, -0x8(%rbp)
jne 0xe275
movl -0xc(%rbp), %eax
orl $0xfc20, %eax           # imm = 0xFC20
movl %eax, -0x8(%rbp)
jmp 0xe281
movl -0x8(%rbp), %eax
shll $0xa, %eax
orl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movswl %ax, %edi
callq 0xda40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/jaguar.c
// Function: two_reg
int two_reg(int op)
{
  int reg1,reg2;
  if ( GetRegisterOrPC( &reg1 )) return 1;
  if ( !TestAtom(',') )return Error(SYNTAX_ERR,"");
  if ( GetRegister( &reg2 )) return 1;

  if ( reg1 == 64 && op == 34){ // special case: mov pc,rn
    op = 51;
    reg1 = 0;
  }

  if ( reg1 > 31 ) return Error(REG_ERR,"");

  op = ( op << 10 ) | ( reg1 << 5 ) | reg2;

  writeOp( op );
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0xda80
cmpl $0x0, %eax
je 0xe2c5
movl $0x1, -0x4(%rbp)
jmp 0xe35d
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xe2ea
movl $0x12, %edi
leaq 0x2d7d(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xe35d
leaq -0x10(%rbp), %rdi
callq 0xde90
cmpl $0x0, %eax
je 0xe301
movl $0x1, -0x4(%rbp)
jmp 0xe35d
cmpl $0x40, -0xc(%rbp)
jne 0xe31b
cmpl $0x22, -0x8(%rbp)
jne 0xe31b
movl $0x33, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1f, -0xc(%rbp)
jle 0xe337
movl $0x2c, %edi
leaq 0x2d30(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xe35d
movl -0x8(%rbp), %eax
shll $0xa, %eax
movl -0xc(%rbp), %ecx
shll $0x5, %ecx
orl %ecx, %eax
orl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movswl %ax, %edi
callq 0xda40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/jaguar.c
// Function: imm_reg
int imm_reg(int op)
{
  int32_t imm;
  int reg;
  int err;

  if ( !TestAtom('#') ) return Error(SYNTAX_ERR,"");

  if ( (err = Expression( &imm )) == EXPR_ERR ) return 1;

  if ( err == EXPR_UNSOLVED ) {
    saveCurrentLine();
    imm = 1;
  }

  if ( imm < 1 || imm > 32 ) Error(IMM_ERR,"1<=x<=32");

  if ( op == 24 ) imm = 32-imm; // shlq

  if ( imm == 32 ) imm = 0;

  if ( !TestAtom(',') ) return Error(SYNTAX_ERR,"");

  if ( GetRegister( &reg ) ) return 1;

  op = ( op << 10 ) | ( imm << 5) | reg;

  writeOp( op );

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x23, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xe3a3
movl $0x12, %edi
leaq 0x2cc7(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xe471
leaq -0xc(%rbp), %rdi
callq 0xc920
movl %eax, -0x14(%rbp)
cmpl $0x11, %eax
jne 0xe3c0
movl $0x1, -0x4(%rbp)
jmp 0xe471
cmpl $0x2, -0x14(%rbp)
jne 0xe3d4
movb $0x0, %al
callq 0xcfe0
movl $0x1, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0xe3e0
cmpl $0x20, -0xc(%rbp)
jle 0xe3f1
movl $0x2b, %edi
leaq 0x3886(%rip), %rsi      # 0x11c72
callq 0xd130
cmpl $0x18, -0x8(%rbp)
jne 0xe402
movl $0x20, %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jne 0xe40f
movl $0x0, -0xc(%rbp)
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xe434
movl $0x12, %edi
leaq 0x2c33(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xe471
leaq -0x10(%rbp), %rdi
callq 0xde90
cmpl $0x0, %eax
je 0xe44b
movl $0x1, -0x4(%rbp)
jmp 0xe471
movl -0x8(%rbp), %eax
shll $0xa, %eax
movl -0xc(%rbp), %ecx
shll $0x5, %ecx
orl %ecx, %eax
orl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movswl %ax, %edi
callq 0xda40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/jaguar.c
// Function: imm2_reg
int imm2_reg(int op)
{
  int32_t imm;
  int reg;
  int err;

  if ( !TestAtom('#') ) return Error(SYNTAX_ERR,"");

  if ( (err = Expression( &imm )) == EXPR_ERR ) return 1;

  if ( err == EXPR_UNSOLVED ) saveCurrentLine();

  if ( imm < 0 || imm > 31 ) Error(IMM_ERR,"0<=n<=31");

  if ( !TestAtom(',') ) return Error(SYNTAX_ERR,"");

  if ( GetRegister( &reg ) ) return 1;

  op = ( op << 10 ) | ( imm << 5) | reg;

  writeOp( op );

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x23, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xe4b3
movl $0x12, %edi
leaq 0x2bb7(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xe55c
leaq -0xc(%rbp), %rdi
callq 0xc920
movl %eax, -0x14(%rbp)
cmpl $0x11, %eax
jne 0xe4d0
movl $0x1, -0x4(%rbp)
jmp 0xe55c
cmpl $0x2, -0x14(%rbp)
jne 0xe4dd
movb $0x0, %al
callq 0xcfe0
cmpl $0x0, -0xc(%rbp)
jl 0xe4e9
cmpl $0x1f, -0xc(%rbp)
jle 0xe4fa
movl $0x2b, %edi
leaq 0x3786(%rip), %rsi      # 0x11c7b
callq 0xd130
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xe51f
movl $0x12, %edi
leaq 0x2b48(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xe55c
leaq -0x10(%rbp), %rdi
callq 0xde90
cmpl $0x0, %eax
je 0xe536
movl $0x1, -0x4(%rbp)
jmp 0xe55c
movl -0x8(%rbp), %eax
shll $0xa, %eax
movl -0xc(%rbp), %ecx
shll $0x5, %ecx
orl %ecx, %eax
orl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movswl %ax, %edi
callq 0xda40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/jaguar.c
// Function: imm3_reg
int imm3_reg(int op)
{
  int32_t imm;
  int reg;
  int err;

  if ( !TestAtom('#') ) return Error(SYNTAX_ERR,"");

  if ( (err = Expression( &imm )) == EXPR_ERR ) return 1;

  if ( err == EXPR_UNSOLVED ) saveCurrentLine();

  if ( imm < -16 || imm > 15 ) Error(IMM_ERR,"-16<=n<=15");

  imm &= 31;

  if ( !TestAtom(',') ) return Error(SYNTAX_ERR,"");

  if ( GetRegister( &reg ) ) return 1;

  op = ( op << 10 ) | ( imm << 5) | reg;

  writeOp( op );

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x23, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xe5a3
movl $0x12, %edi
leaq 0x2ac7(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xe655
leaq -0xc(%rbp), %rdi
callq 0xc920
movl %eax, -0x14(%rbp)
cmpl $0x11, %eax
jne 0xe5c0
movl $0x1, -0x4(%rbp)
jmp 0xe655
cmpl $0x2, -0x14(%rbp)
jne 0xe5cd
movb $0x0, %al
callq 0xcfe0
cmpl $-0x10, -0xc(%rbp)
jl 0xe5d9
cmpl $0xf, -0xc(%rbp)
jle 0xe5ea
movl $0x2b, %edi
leaq 0x369f(%rip), %rsi      # 0x11c84
callq 0xd130
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0xc(%rbp)
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xe618
movl $0x12, %edi
leaq 0x2a4f(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xe655
leaq -0x10(%rbp), %rdi
callq 0xde90
cmpl $0x0, %eax
je 0xe62f
movl $0x1, -0x4(%rbp)
jmp 0xe655
movl -0x8(%rbp), %eax
shll $0xa, %eax
movl -0xc(%rbp), %ecx
shll $0x5, %ecx
orl %ecx, %eax
orl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movswl %ax, %edi
callq 0xda40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/jaguar.c
// Function: imm4_reg
int imm4_reg(int op)
{
  int32_t imm;
  int reg;
  int err;

  if ( !TestAtom('#') ) return Error(SYNTAX_ERR,"");

  if ( (err = Expression( &imm )) == EXPR_ERR ) return 1;

  if ( !TestAtom(',') ) return Error(SYNTAX_ERR,"");

  if ( GetRegister( &reg ) ) return 1;

  if ( err == EXPR_UNSOLVED ) saveCurrentLine();

  if ( (last_op == 52 || last_op == 53) && last_pc == (Global.pc-2) ){
    Warning("MOVEI after JR/JUMP is unpredictable!");
  }

  op = ( op << 10 ) | reg;

  writeOp( op );
  writeWordBig( imm & 0xffff);
  writeWordBig( imm >> 16 );

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x23, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xe693
movl $0x12, %edi
leaq 0x29d7(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xe76c
leaq -0xc(%rbp), %rdi
callq 0xc920
movl %eax, -0x14(%rbp)
cmpl $0x11, %eax
jne 0xe6b0
movl $0x1, -0x4(%rbp)
jmp 0xe76c
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xe6d8
movl $0x12, %edi
leaq 0x2992(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xe76c
leaq -0x10(%rbp), %rdi
callq 0xde90
cmpl $0x0, %eax
je 0xe6ef
movl $0x1, -0x4(%rbp)
jmp 0xe76c
cmpl $0x2, -0x14(%rbp)
jne 0xe6fc
movb $0x0, %al
callq 0xcfe0
cmpl $0x34, 0x9a0d(%rip)     # 0x18110
je 0xe70e
cmpl $0x35, 0x9a04(%rip)     # 0x18110
jne 0xe730
movl 0x9a00(%rip), %eax      # 0x18114
leaq 0x9c85(%rip), %rcx      # 0x183a0
movl (%rcx), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jne 0xe730
leaq 0x3564(%rip), %rdi      # 0x11c8f
callq 0xd910
movl -0x8(%rbp), %eax
shll $0xa, %eax
orl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movswl %ax, %edi
callq 0xda40
movl -0xc(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movswl %ax, %edi
callq 0x3730
movl -0xc(%rbp), %eax
sarl $0x10, %eax
movswl %ax, %edi
callq 0x3730
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/jaguar.c
// Function: GetCondition
int GetCondition(int *cond)
{
  label_t condition;
  label_t *l;
  int32_t solved;
  int i;
  char *save_srcLinePtr = srcLinePtr-1;

  *cond = 0;
  if ( GetLabel(&condition) ) return 0;

  if ( condition.type != (UNSURE|NORMAL) ){
    srcLinePtr = save_srcLinePtr;
    atom = *srcLinePtr++;
    return 0;
  }

//->  printf("Cond:%s\n",condition.name);

  if ( atom != ',' || (l = FindLabel(&condition, &solved) ) != NULL ){
    srcLinePtr = save_srcLinePtr;
    atom = *srcLinePtr++;
    return 0;
  }

  if ( condition.len > 5 )  return Error(SYNTAX_ERR,"");

  for( i = 0 ; conditions[i].cond ; ++i ){
    if ( !strcasecmp(conditions[i].ascCond,condition.name) ){
      *cond = conditions[i].cond;
      return 0;
    }
  }

  *cond = 0;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1277a(%rip), %rax     # 0x20f10
movq (%rax), %rax
addq $-0x1, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
leaq -0x70(%rbp), %rdi
callq 0x5de0
cmpl $0x0, %eax
je 0xe7c8
movl $0x0, -0x4(%rbp)
jmp 0xe91d
cmpl $0x21, -0x6c(%rbp)
je 0xe812
movq -0x88(%rbp), %rcx
leaq 0x12734(%rip), %rax     # 0x20f10
movq %rcx, (%rax)
leaq 0x1272a(%rip), %rax     # 0x20f10
movq (%rax), %rax
movq %rax, %rdx
addq $0x1, %rdx
leaq 0x12719(%rip), %rcx     # 0x20f10
movq %rdx, (%rcx)
movsbl (%rax), %ecx
leaq 0x1271c(%rip), %rax     # 0x20f20
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xe91d
leaq 0x12707(%rip), %rax     # 0x20f20
cmpl $0x2c, (%rax)
jne 0xe835
leaq -0x70(%rbp), %rdi
leaq -0x7c(%rbp), %rsi
callq 0x6f20
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0xe879
movq -0x88(%rbp), %rcx
leaq 0x126cd(%rip), %rax     # 0x20f10
movq %rcx, (%rax)
leaq 0x126c3(%rip), %rax     # 0x20f10
movq (%rax), %rax
movq %rax, %rdx
addq $0x1, %rdx
leaq 0x126b2(%rip), %rcx     # 0x20f10
movq %rdx, (%rcx)
movsbl (%rax), %ecx
leaq 0x126b5(%rip), %rax     # 0x20f20
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xe91d
cmpl $0x5, -0x70(%rbp)
jle 0xe898
movl $0x12, %edi
leaq 0x27d2(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xe91d
movl $0x0, -0x80(%rbp)
movslq -0x80(%rbp), %rcx
leaq 0x9876(%rip), %rax      # 0x18120
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0xe90c
movslq -0x80(%rbp), %rax
leaq 0x985e(%rip), %rdi      # 0x18120
imulq $0xc, %rax, %rax
addq %rax, %rdi
leaq -0x70(%rbp), %rsi
addq $0x38, %rsi
callq 0x3050
cmpl $0x0, %eax
jne 0xe8ff
movslq -0x80(%rbp), %rcx
leaq 0x983a(%rip), %rax      # 0x18120
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xe91d
jmp 0xe901
movl -0x80(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x80(%rbp)
jmp 0xe89f
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/jaguar.c
// Function: cond_rel
int cond_rel(int op )
{
  int cond;
  int32_t dest;
  int err;

  if ( GetCondition( & cond ) ) return 1;

  if ( cond && !TestAtom(',') ) return Error(SYNTAX_ERR,"");

  if ( (err = Expression(&dest)) == EXPR_ERR) return 1;

  op = ( op << 10 ) | cond;

  if ( (Global.pc < 0xf03000) && (Global.pc & 3) ){
    Warning("JR not long-aligned ! NOP inserted !");
    writeOp(0xe400); /* NOP */
  }

  if ( err == EXPR_UNSOLVED ){
    saveCurrentLine();
  } else {
    int32_t dist = (int32_t)dest - (Global.pc + 2);
    if ( dist < -32 || dist > 30 ) {
      return Error(DISTANCE_ERR,"");
    }
    dist >>= 1;
    op  |= (dist & 31) << 5;
  }

  writeOp( op );
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0xe780
cmpl $0x0, %eax
je 0xe955
movl $0x1, -0x4(%rbp)
jmp 0xea50
cmpl $0x0, -0xc(%rbp)
je 0xe983
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xe983
movl $0x12, %edi
leaq 0x26e7(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xea50
leaq -0x10(%rbp), %rdi
callq 0xc920
movl %eax, -0x14(%rbp)
cmpl $0x11, %eax
jne 0xe9a0
movl $0x1, -0x4(%rbp)
jmp 0xea50
movl -0x8(%rbp), %eax
shll $0xa, %eax
orl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
leaq 0x99ed(%rip), %rax      # 0x183a0
cmpl $0xf03000, (%rax)       # imm = 0xF03000
jae 0xe9e2
leaq 0x99de(%rip), %rax      # 0x183a0
movl (%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xe9e2
leaq 0x32e2(%rip), %rdi      # 0x11cb5
callq 0xd910
movl $0xffffe400, %edi       # imm = 0xFFFFE400
callq 0xda40
cmpl $0x2, -0x14(%rbp)
jne 0xe9f1
movb $0x0, %al
callq 0xcfe0
jmp 0xea3e
movl -0x10(%rbp), %eax
leaq 0x99a5(%rip), %rcx      # 0x183a0
movl (%rcx), %ecx
addl $0x2, %ecx
subl %ecx, %eax
movl %eax, -0x18(%rbp)
cmpl $-0x20, -0x18(%rbp)
jl 0xea11
cmpl $0x1e, -0x18(%rbp)
jle 0xea27
movl $0x16, %edi
leaq 0x2640(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xea50
movl -0x18(%rbp), %eax
sarl %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x1f, %eax
shll $0x5, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movswl %ax, %edi
callq 0xda40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/jaguar.c
// Function: cond_abs
int cond_abs(int op )
{
  int cond;
  int reg;

  if ( GetCondition( &cond ) ) return 1;

  if ( cond && !TestAtom(',') ) return Error(SYNTAX_ERR,"");

  op = ( op << 10 ) | cond;

  if ( !TestAtom('(') ) return Error(SYNTAX_ERR,"");

  if ( GetRegister( &reg ) ) return 1;

  if ( !TestAtom(')') ) return Error(SYNTAX_ERR,"");

  op |= reg << 5;

  if ( (Global.pc < 0xf03000) && (Global.pc & 3) ){
    Warning("JUMP not long-aligned ! NOP inserted !");
    writeOp((short)0xe400);
  }

  writeOp( op );
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0xe780
cmpl $0x0, %eax
je 0xea85
movl $0x1, -0x4(%rbp)
jmp 0xeb77
cmpl $0x0, -0xc(%rbp)
je 0xeab3
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xeab3
movl $0x12, %edi
leaq 0x25b7(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xeb77
movl -0x8(%rbp), %eax
shll $0xa, %eax
orl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl $0x28, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xeae7
movl $0x12, %edi
leaq 0x2583(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xeb77
leaq -0x10(%rbp), %rdi
callq 0xde90
cmpl $0x0, %eax
je 0xeafe
movl $0x1, -0x4(%rbp)
jmp 0xeb77
movl $0x29, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xeb23
movl $0x12, %edi
leaq 0x2544(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xeb77
movl -0x10(%rbp), %eax
shll $0x5, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
leaq 0x986a(%rip), %rax      # 0x183a0
cmpl $0xf03000, (%rax)       # imm = 0xF03000
jae 0xeb65
leaq 0x985b(%rip), %rax      # 0x183a0
movl (%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xeb65
leaq 0x3184(%rip), %rdi      # 0x11cda
callq 0xd910
movl $0xffffe400, %edi       # imm = 0xFFFFE400
callq 0xda40
movl -0x8(%rbp), %eax
movswl %ax, %edi
callq 0xda40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/42Bastian[P]lyxass/jaguar.c
// Function: load2_reg
int load2_reg(int op )
{
  int reg1,reg2;

  if ( !TestAtom('(') ) return Error(SYNTAX_ERR,"");

  if ( GetRegister(&reg1) ) return 1;

  if ( !TestAtom(')') || !TestAtom(',') ) return Error(SYNTAX_ERR,"");

  if ( GetRegister( &reg2 ) ) return 1;

  op = ( op << 10 ) | ( reg1 << 5 ) | reg2;

  writeOp( op );

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x28, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xee23
movl $0x12, %edi
leaq 0x2247(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xeeab
leaq -0xc(%rbp), %rdi
callq 0xde90
cmpl $0x0, %eax
je 0xee3a
movl $0x1, -0x4(%rbp)
jmp 0xeeab
movl $0x29, %edi
callq 0x5a90
cmpl $0x0, %eax
je 0xee58
movl $0x2c, %edi
callq 0x5a90
cmpl $0x0, %eax
jne 0xee6e
movl $0x12, %edi
leaq 0x21f9(%rip), %rsi      # 0x1105d
callq 0xd130
movl %eax, -0x4(%rbp)
jmp 0xeeab
leaq -0x10(%rbp), %rdi
callq 0xde90
cmpl $0x0, %eax
je 0xee85
movl $0x1, -0x4(%rbp)
jmp 0xeeab
movl -0x8(%rbp), %eax
shll $0xa, %eax
movl -0xc(%rbp), %ecx
shll $0x5, %ecx
orl %ecx, %eax
orl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movswl %ax, %edi
callq 0xda40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_04/itoa.c
// Function: main
int main(void)
{
  int n = 785;
  char number_str[MAXLEN];

  int_to_array(n, number_str);
  printf("%s\n", number_str);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp            # imm = 0x3F0
movl $0x0, -0x4(%rbp)
movl $0x311, -0x8(%rbp)      # imm = 0x311
movl -0x8(%rbp), %edi
leaq -0x3f0(%rbp), %rsi
callq 0x11a0
leaq -0x3f0(%rbp), %rsi
leaq 0xe7e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_04/itoa.c
// Function: int_to_array
void int_to_array(int n, char s[])
{
  int i, sign;

  sign = n;

  i = 0;
  do
  {
    s[i++] = abs(n % 10) + '0';
  } while (n /= 10);

  if (sign < 0)
  {
    s[i++] = '-';
  }

  s[i] = '\0';

  int s_len = strlen(s);
  str_reverse(s, 0, s_len - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x0, %eax
jne 0x11bc
cmpl $0x0, -0x18(%rbp)
jge 0x1219
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x1030
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x1250
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_aerospike.c
// Function: as_aerospike_init
as_aerospike * as_aerospike_init(as_aerospike * a, void * s, const as_aerospike_hooks * h)
{
	a->is_rcalloc = false;
	a->source = s;
	a->hooks = h;
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_aerospike.c
// Function: as_aerospike_new
as_aerospike * as_aerospike_new(void * s, const as_aerospike_hooks * h)
{
	as_aerospike * a = (as_aerospike *) cf_rc_alloc(sizeof(as_aerospike));
	a->is_rcalloc = true;
	a->source = s;
	a->hooks = h;
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x88d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_init
as_arraylist*
as_arraylist_init(as_arraylist* list, uint32_t capacity, uint32_t block_size)
{
	if (!list) return list;

	as_list_cons((as_list *) list, false, &as_arraylist_list_hooks);
	list->block_size = block_size;
	list->capacity = capacity;
	list->size = 0;
	if (list->capacity > 0) {
		list->free = true;
		list->elements = (as_val**) cf_calloc(capacity, sizeof(as_val*));
	}
	else {
		list->free = false;
		list->elements = NULL;
	}
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8e83
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8efe
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movq 0x27130(%rip), %rdx     # 0x2ffc0
callq 0x8c30
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jbe 0x8ee2
movq -0x10(%rbp), %rax
movb $0x1, 0x30(%rax)
movl -0x14(%rbp), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x8a00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x8ef6
movq -0x10(%rbp), %rax
movb $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_new
as_arraylist*
as_arraylist_new(uint32_t capacity, uint32_t block_size)
{
	as_arraylist* list = (as_arraylist*) cf_malloc(sizeof(as_arraylist));
	if (!list) return list;

	as_list_cons((as_list *) list, true, &as_arraylist_list_hooks);
	list->block_size = block_size;
	list->capacity = capacity;
	list->size = 0;
	if (list->capacity > 0) {
		list->free = true;
		list->elements = (as_val**) cf_calloc(capacity, sizeof(as_val*));
	}
	else {
		list->free = false;
		list->elements = NULL;
	}
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl $0x38, %edi
callq 0x8090
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8f3d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8fbb
movq -0x18(%rbp), %rdi
movl $0x1, %esi
movq 0x27073(%rip), %rdx     # 0x2ffc0
callq 0x8c30
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jbe 0x8f9f
movq -0x18(%rbp), %rax
movb $0x1, 0x30(%rax)
movl -0xc(%rbp), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x8a00
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x8fb3
movq -0x18(%rbp), %rax
movb $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_release
bool
as_arraylist_release(as_arraylist* list)
{
	if (list->elements) {
		for (uint32_t i = 0; i < list->size; i++) {
			if (list->elements[i]) {
				as_val_destroy(list->elements[i]);
			}
			list->elements[i] = NULL;
		}

		if (list->free) {
			cf_free(list->elements);
		}
	}
	
	list->elements = NULL;
	list->size = 0;
	list->capacity = 0;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x9057
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x903e
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x9020
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x8550
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8fee
movq -0x8(%rbp), %rax
testb $0x1, 0x30(%rax)
je 0x9055
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x8aa0
jmp 0x9057
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_set
int
as_arraylist_set(as_arraylist* list, uint32_t index, as_val* value)
{
	int rc = AS_ARRAYLIST_OK;

	if (index >= list->capacity) {
		rc = as_arraylist_ensure(list, (index + 1) - list->size);

		if (rc != AS_ARRAYLIST_OK) {
			return rc;
		}
	}

	// Make sure that, before we free (destroy) something, it is within the
	// legal bounds of the object.
	if (index < list->size) {
		as_val_destroy(list->elements[index]);
	}

	list->elements[index] = value ? value : (as_val*)&as_nil;

	if (index == list->size) {
		list->size++;
	}
	else if (index > list->size) {
		for (uint32_t i = list->size; i < index; i++) {
			list->elements[i] = (as_val*)&as_nil;
		}

		list->size = index + 1;
	}

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0x93a2
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movq -0x10(%rbp), %rax
subl 0x20(%rax), %esi
callq 0x9470
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x93a0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9462
jmp 0x93a2
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x93c2
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x8550
cmpq $0x0, -0x20(%rbp)
je 0x93d3
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x93e0
movq 0x26c0e(%rip), %rax     # 0x2ffe8
movq %rax, -0x30(%rbp)
jmp 0x93e0
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x940e
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0x945c
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jbe 0x945a
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x944d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x28(%rbp), %ecx
movq 0x26baa(%rip), %rdx     # 0x2ffe8
movq %rdx, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x9424
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
jmp 0x945c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_ensure
static int
as_arraylist_ensure(as_arraylist* list, uint32_t delta)
{
	// Check for capacity (in terms of elements, NOT size in bytes), and if we
	// need to allocate more, do a realloc.
	if ((list->size + delta) > list->capacity) {
		// by convention - we allocate more space ONLY when the unit of
		// (new) allocation is > 0.
		if (list->block_size == 0) {
			return AS_ARRAYLIST_ERR_MAX;
		}
		// Compute how much room we're missing for the new stuff
		int new_room = (list->size + delta) - list->capacity;
		// Compute new capacity in terms of multiples of block_size
		// This will get us (conservatively) at least one block
		int new_blocks = (new_room + list->block_size) / list->block_size;
		int new_capacity = list->capacity + (new_blocks * list->block_size);
		size_t new_bytes = sizeof(as_val*) * new_capacity;
		as_val** elements = (as_val**) cf_realloc(list->elements, new_bytes);
		if (! elements) {
			return AS_ARRAYLIST_ERR_ALLOC;
		}
		// Zero everything beyond the old pointers.
		size_t old_bytes = sizeof(as_val*) * list->capacity;
		memset((uint8_t *)elements + old_bytes, 0, new_bytes - old_bytes);
		// Set the new array pointer and capacity.
		list->elements = elements;
		list->capacity = new_capacity;
		list->free = true;
	}

	return AS_ARRAYLIST_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
addl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jbe 0x9562
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x94ac
movl $0x2, -0x4(%rbp)
jmp 0x9569
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
addl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0x1c(%rcx), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x18(%rcx), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x18(%rcx)
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull 0x18(%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movslq -0x20(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x85b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x951e
movl $0x1, -0x4(%rbp)
jmp 0x9569
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
shlq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
addq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rdx
subq -0x38(%rbp), %rdx
xorl %esi, %esi
callq 0x8480
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x30(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_insert
int
as_arraylist_insert(as_arraylist* list, uint32_t index, as_val* value)
{
	uint32_t delta = 1;

	if (index > list->size) {
		delta = index + 1 - list->size;
	}

	int rc = as_arraylist_ensure(list, delta);

	if (rc != AS_ARRAYLIST_OK) {
		return rc;
	}

	for (uint32_t i = list->size; i > index; i--) {
		list->elements[i] = list->elements[i - 1];
	}

	list->elements[index] = value ? value : (as_val*)&as_nil;

	if (index <= list->size) {
		list->size++;
	}
	else {
		for (uint32_t i = list->size; i < index; i++) {
			list->elements[i] = (as_val*)&as_nil;
		}

		list->size = index + 1;
	}

	return AS_ARRAYLIST_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jbe 0x9686
movl -0x14(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
subl 0x20(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x9470
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x96a6
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9779
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x96e6
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x2c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x96b0
cmpq $0x0, -0x20(%rbp)
je 0x96f7
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x9704
movq 0x268ea(%rip), %rax     # 0x2ffe8
movq %rax, -0x38(%rbp)
jmp 0x9704
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
ja 0x9732
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
jmp 0x9772
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x9765
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x30(%rbp), %ecx
movq 0x26892(%rip), %rdx     # 0x2ffe8
movq %rdx, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x973c
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_remove
int
as_arraylist_remove(as_arraylist* list, uint32_t index)
{
	if (index >= list->size) {
		return AS_ARRAYLIST_ERR_INDEX;
	}

	if (list->elements[index]) {
		as_val_destroy(list->elements[index]);
	}

	for (uint32_t i = index + 1; i < list->size; i++) {
		list->elements[i - 1] = list->elements[i];
	}

	list->size--;
	list->elements[list->size] = NULL; // clean vacated pointer slot

	return AS_ARRAYLIST_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jb 0x9a67
movl $0x3, -0x4(%rbp)
jmp 0x9afb
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x9a8d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x8550
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x9ad0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9a96
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movq $0x0, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_concat
int
as_arraylist_concat(as_arraylist* list, const as_arraylist* list2)
{
	int rc = as_arraylist_ensure(list, list2->size);

	if (rc != AS_ARRAYLIST_OK) {
		return rc;
	}

	for (uint32_t i = 0; i < list2->size; i++) {
		if (list2->elements[i]) {
			as_val_reserve(list2->elements[i]);
		}

		list->elements[list->size++] = list2->elements[i];
	}

	return AS_ARRAYLIST_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x9470
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9b41
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9bb8
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x9bb1
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x20(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x9b7a
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rsi
movl 0x20(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x20(%rsi)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9b48
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_trim
int
as_arraylist_trim(as_arraylist* list, uint32_t index)
{
	if (index >= list->size) {
		return AS_ARRAYLIST_ERR_INDEX;
	}

	for (uint32_t i = index; i < list->size; i++) {
		if (list->elements[i]) {
			as_val_destroy(list->elements[i]);
			list->elements[i] = NULL;
		}
	}

	list->size = index;

	return AS_ARRAYLIST_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jb 0x9bf4
movl $0x3, -0x4(%rbp)
jmp 0x9c5d
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x9c4c
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x18(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x9c3f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x18(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x8550
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x18(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
jmp 0x9c41
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9bfa
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_tail
as_arraylist*
as_arraylist_tail(const as_arraylist* list)
{
	if (list->size == 0) return NULL;

	as_arraylist* list2 = as_arraylist_new(list->size-1, list->block_size);

	for(uint32_t i = 1, j = 0; i < list->size; i++, j++) {
		if (list->elements[i]) {
			as_val_reserve(list->elements[i]);
			list2->elements[j] = list2->elements[i];
		}
		else {
			list2->elements[j] = 0;
		}
	}

	return list2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x9cb3
movq $0x0, -0x8(%rbp)
jmp 0x9d5e
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
subl $0x1, %edi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x85d0
movq %rax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x9d56
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x1c(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x9d2d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x20(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x9d40
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x20(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
jmp 0x9d42
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9cdb
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_drop
as_arraylist*
as_arraylist_drop(const as_arraylist* list, uint32_t n)
{
	uint32_t		sz		= list->size;
	uint32_t		c		= n < sz ? n : sz;
	as_arraylist*	list2	= as_arraylist_new(sz-c, list->block_size);
	
	list2->size = sz-c;
	for(uint32_t i = c, j = 0; j < list2->size; i++, j++) {
		if (list->elements[i]) {
			as_val_reserve(list->elements[i]);
			list2->elements[j] = list->elements[i];
		}
		else {
			list2->elements[j] = 0;
		}
	}

	return list2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x9d99
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x9d9f
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %edi
subl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x85d0
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %ecx
subl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x9e50
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x24(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x9e27
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x28(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x9e3a
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x28(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
jmp 0x9e3c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x9dd5
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)