LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: exprIdxCover
static int exprIdxCover(Walker *pWalker, Expr *pExpr){
  if( pExpr->op==TK_COLUMN
   && pExpr->iTable==pWalker->u.pIdxCover->iCur
   && sqlite3ColumnOfIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
  ){
    pWalker->eCode = 1;
    return WRC_Abort;
  }
  return WRC_Continue;
}

// Assembly:
xorl %eax, %eax
cmpb $-0x62, (%rsi)
jne 0x46b0ec
movl 0x2c(%rsi), %edx
movq 0x28(%rdi), %rcx
cmpl 0x8(%rcx), %edx
jne 0x46b0ec
movq (%rcx), %rcx
movzwl 0x60(%rcx), %eax
testq %rax, %rax
je 0x46b0e3
movzwl 0x30(%rsi), %edx
movq 0x8(%rcx), %rsi
xorl %ecx, %ecx
cmpw %dx, (%rsi,%rcx,2)
je 0x46b0dc
incq %rcx
cmpq %rcx, %rax
jne 0x46b0cc
jmp 0x46b0e3
xorl %eax, %eax
testw %cx, %cx
jns 0x46b0ec
movb $0x1, 0x24(%rdi)
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: translateColumnToCopy
static void translateColumnToCopy(
  Parse *pParse,      /* Parsing context */
  int iStart,         /* Translate from this opcode to the end */
  int iTabCur,        /* OP_Column/OP_Rowid references to this table */
  int iRegister,      /* The first column is in this register */
  int bIncrRowid      /* If non-zero, transform OP_rowid to OP_AddImm(1) */
){
  Vdbe *v = pParse->pVdbe;
  VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
  int iEnd = sqlite3VdbeCurrentAddr(v);
  if( pParse->db->mallocFailed ) return;
  for(; iStart<iEnd; iStart++, pOp++){
    if( pOp->p1!=iTabCur ) continue;
    if( pOp->opcode==OP_Column ){
      pOp->opcode = OP_Copy;
      pOp->p1 = pOp->p2 + iRegister;
      pOp->p2 = pOp->p3;
      pOp->p3 = 0;
    }else if( pOp->opcode==OP_Rowid ){
      if( bIncrRowid ){
        /* Increment the value stored in the P2 operand of the OP_Rowid. */
        pOp->opcode = OP_AddImm;
        pOp->p1 = pOp->p2;
        pOp->p2 = 1;
      }else{
        pOp->opcode = OP_Null;
        pOp->p1 = 0;
        pOp->p3 = 0;
      }
    }
  }
}

// Assembly:
movq 0x10(%rdi), %r9
movl %esi, %eax
testl %esi, %esi
jns 0x46baf7
movl 0xb8(%r9), %eax
decl %eax
movq (%r9), %r10
cmpb $0x0, 0x61(%r10)
je 0x46bb0a
leaq 0x139300(%rip), %rax    # 0x5a4e08
jmp 0x46bb18
cltq
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x68(%r9), %rax
movl 0xb8(%r9), %r9d
movq (%rdi), %rdi
cmpb $0x0, 0x61(%rdi)
sete %dil
subl %esi, %r9d
setg %sil
andb %dil, %sil
cmpb $0x1, %sil
jne 0x46bb99
addq $0xc, %rax
xorl %esi, %esi
cmpl %edx, -0x8(%rax)
jne 0x46bb90
movzbl -0xc(%rax), %edi
cmpl $0x81, %edi
je 0x46bb6f
cmpl $0x5a, %edi
jne 0x46bb90
movb $0x4e, -0xc(%rax)
movl -0x4(%rax), %edi
addl %ecx, %edi
movl %edi, -0x8(%rax)
movl (%rax), %edi
movl %edi, -0x4(%rax)
movl $0x0, (%rax)
jmp 0x46bb90
testl %r8d, %r8d
je 0x46bb87
movb $0x53, -0xc(%rax)
movl -0x4(%rax), %edi
movl %edi, -0x8(%rax)
movl $0x1, -0x4(%rax)
jmp 0x46bb90
movb $0x49, -0xc(%rax)
movl %esi, -0x8(%rax)
movl %esi, (%rax)
addq $0x18, %rax
decl %r9d
jne 0x46bb40
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: codeApplyAffinity
static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
  Vdbe *v = pParse->pVdbe;
  if( zAff==0 ){
    assert( pParse->db->mallocFailed );
    return;
  }
  assert( v!=0 );

  /* Adjust base and n to skip over SQLITE_AFF_BLOB entries at the beginning
  ** and end of the affinity string.
  */
  while( n>0 && zAff[0]==SQLITE_AFF_BLOB ){
    n--;
    base++;
    zAff++;
  }
  while( n>1 && zAff[n-1]==SQLITE_AFF_BLOB ){
    n--;
  }

  /* Code the OP_Affinity opcode if there is anything left to do. */
  if( n>0 ){
    sqlite3VdbeAddOp4(v, OP_Affinity, base, n, 0, zAff, n);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rcx, %rcx
je 0x46c61f
movl %edx, %ebx
testl %edx, %edx
jle 0x46c5c7
movl %ebx, %r14d
addq %rcx, %r14
leal (%rbx,%rsi), %edx
cmpb $0x41, (%rcx)
jne 0x46c5c7
leal -0x1(%rbx), %eax
incl %esi
incq %rcx
cmpl $0x1, %ebx
movl %eax, %ebx
jg 0x46c5af
xorl %ebx, %ebx
jmp 0x46c5cc
movq %rcx, %r14
movl %esi, %edx
movq 0x10(%rdi), %r15
movl %ebx, %ecx
testl %ebx, %ebx
movl $0x1, %eax
cmovlel %ebx, %eax
incl %ebx
cmpl $0x2, %ecx
jl 0x46c5f3
decl %ebx
cmpb $0x41, -0x1(%r14,%rcx)
leaq -0x1(%rcx), %rcx
je 0x46c5de
jmp 0x46c5f5
movl %eax, %ebx
testl %ebx, %ebx
jle 0x46c61f
movq %r15, %rdi
movl $0x5b, %esi
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x43bae0
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
movl %ebx, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x40e507
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: codeDeferredSeek
static void codeDeferredSeek(
  WhereInfo *pWInfo,              /* Where clause context */
  Index *pIdx,                    /* Index scan is using */
  int iCur,                       /* Cursor for IPK b-tree */
  int iIdxCur                     /* Index cursor */
){
  Parse *pParse = pWInfo->pParse; /* Parse context */
  Vdbe *v = pParse->pVdbe;        /* Vdbe to generate code within */

  assert( iIdxCur>0 );
  assert( pIdx->aiColumn[pIdx->nColumn-1]==-1 );
  
  sqlite3VdbeAddOp3(v, OP_DeferredSeek, iIdxCur, 0, iCur);
  if( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)
   && DbMaskAllZero(sqlite3ParseToplevel(pParse)->writeMask)
  ){
    int i;
    Table *pTab = pIdx->pTable;
    int *ai = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*(pTab->nCol+1));
    if( ai ){
      ai[0] = pTab->nCol;
      for(i=0; i<pIdx->nColumn-1; i++){
        assert( pIdx->aiColumn[i]<pTab->nCol );
        if( pIdx->aiColumn[i]>=0 ) ai[pIdx->aiColumn[i]+1] = i+1;
      }
      sqlite3VdbeChangeP4(v, -1, (char*)ai, P4_INTARRAY);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r8d
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %r12
movq 0x10(%r12), %rbx
movq %rbx, %rdi
movl $0x87, %esi
movl %ecx, %edx
xorl %ecx, %ecx
callq 0x43bae0
testb $0x20, 0x40(%r15)
je 0x46c66b
movq 0xa0(%r12), %rax
testq %rax, %rax
cmoveq %r12, %rax
cmpl $0x0, 0x70(%rax)
je 0x46c677
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r14), %r15
movq (%r12), %rdi
movswq 0x46(%r15), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x40c57c
testq %rax, %rax
je 0x46c66b
movswl 0x46(%r15), %ecx
movl %ecx, (%rax)
movzwl 0x60(%r14), %ecx
cmpq $0x2, %rcx
jb 0x46c6ca
decl %ecx
movq 0x8(%r14), %rdx
xorl %esi, %esi
movzwl (%rdx,%rsi,2), %edi
testw %di, %di
js 0x46c6c2
leal 0x1(%rsi), %r8d
movl %r8d, 0x4(%rax,%rdi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x46c6b0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rax, %rdx
movl $0xfffffff1, %ecx       # imm = 0xFFFFFFF1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40e507
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: whereIndexExprTrans
static void whereIndexExprTrans(
  Index *pIdx,      /* The Index */
  int iTabCur,      /* Cursor of the table that is being indexed */
  int iIdxCur,      /* Cursor of the index itself */
  WhereInfo *pWInfo /* Transform expressions in this WHERE clause */
){
  int iIdxCol;               /* Column number of the index */
  ExprList *aColExpr;        /* Expressions that are indexed */
  Walker w;
  IdxExprTrans x;
  aColExpr = pIdx->aColExpr;
  if( aColExpr==0 ) return;  /* Not an index on expressions */
  memset(&w, 0, sizeof(w));
  w.xExprCallback = whereIndexExprTransNode;
  w.u.pIdxTrans = &x;
  x.iTabCur = iTabCur;
  x.iIdxCur = iIdxCur;
  for(iIdxCol=0; iIdxCol<aColExpr->nExpr; iIdxCol++){
    if( pIdx->aiColumn[iIdxCol]!=XN_EXPR ) continue;
    assert( aColExpr->a[iIdxCol].pExpr!=0 );
    x.iIdxCol = iIdxCol;
    x.pIdxExpr = aColExpr->a[iIdxCol].pExpr;
    sqlite3WalkExpr(&w, pWInfo->pWhere);
    sqlite3WalkExprList(&w, pWInfo->pOrderBy);
    sqlite3WalkExprList(&w, pWInfo->pResultSet);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x50(%rdi), %r12
testq %r12, %r12
je 0x46c79a
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x128(%rip), %rax       # 0x46c845
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movl %esi, 0x8(%rax)
movl %edx, 0xc(%rax)
cmpl $0x0, (%r12)
jle 0x46c79a
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x8(%r12), %r13
xorl %ebp, %ebp
movq %rsp, %r15
movq 0x8(%r14), %rax
cmpw $-0x2, (%rax,%rbp,2)
jne 0x46c78a
movl %ebp, 0x40(%rsp)
movq (%r13), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x46c772
movq %r15, %rdi
callq 0x452999
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x452c00
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x452c00
incq %rbp
movslq (%r12), %rax
addq $0x20, %r13
cmpq %rax, %rbp
jl 0x46c749
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: whereIndexExprTransNode
static int whereIndexExprTransNode(Walker *p, Expr *pExpr){
  IdxExprTrans *pX = p->u.pIdxTrans;
  if( sqlite3ExprCompare(0, pExpr, pX->pIdxExpr, pX->iTabCur)==0 ){
    pExpr->op = TK_COLUMN;
    pExpr->iTable = pX->iIdxCur;
    pExpr->iColumn = pX->iIdxCol;
    pExpr->pTab = 0;
    return WRC_Prune;
  }else{
    return WRC_Continue;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x28(%rdi), %r15
movq (%r15), %rdx
movl 0x8(%r15), %ecx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x452c53
testl %eax, %eax
jne 0x46c887
movb $-0x62, (%rbx)
movl 0xc(%r15), %eax
movl %eax, 0x2c(%rbx)
movzwl 0x10(%r15), %eax
movw %ax, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: windowCheckIntValue
static void windowCheckIntValue(Parse *pParse, int reg, int eCond){
  static const char *azErr[] = {
    "frame starting offset must be a non-negative integer",
    "frame ending offset must be a non-negative integer",
    "second argument to nth_value must be a positive integer"
  };
  static int aOp[] = { OP_Ge, OP_Ge, OP_Gt };
  Vdbe *v = sqlite3GetVdbe(pParse);
  int regZero = sqlite3GetTempReg(pParse);
  assert( eCond==0 || eCond==1 || eCond==2 );
  sqlite3VdbeAddOp2(v, OP_Integer, 0, regZero);
  sqlite3VdbeAddOp2(v, OP_MustBeInt, reg, sqlite3VdbeCurrentAddr(v)+2);
  VdbeCoverageIf(v, eCond==0);
  VdbeCoverageIf(v, eCond==1);
  VdbeCoverageIf(v, eCond==2);
  sqlite3VdbeAddOp3(v, aOp[eCond], regZero, sqlite3VdbeCurrentAddr(v)+2, reg);
  VdbeCoverageNeverNullIf(v, eCond==0);
  VdbeCoverageNeverNullIf(v, eCond==1);
  VdbeCoverageNeverNullIf(v, eCond==2);
  sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_ERROR, OE_Abort);
  sqlite3VdbeAppendP4(v, (void*)azErr[eCond], P4_STATIC);
  sqlite3ReleaseTempReg(pParse, regZero);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x44e8aa
movq %rax, %r14
movb 0x1f(%rbx), %al
testb %al, %al
je 0x46cb3a
decb %al
movb %al, 0x1f(%rbx)
movzbl %al, %eax
movl 0xc4(%rbx,%rax,4), %ebp
jmp 0x46cb42
movl 0x38(%rbx), %ebp
incl %ebp
movl %ebp, 0x38(%rbx)
movq %r14, %rdi
movl $0x46, %esi
xorl %edx, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x43bae0
movl 0xb8(%r14), %ecx
addl $0x2, %ecx
movq %r14, %rdi
movl $0xf, %esi
movl %r15d, %edx
xorl %r8d, %r8d
callq 0x43bae0
movl %r12d, %r12d
leaq 0xe3407(%rip), %rax     # 0x54ff84
movl (%rax,%r12,4), %esi
movl 0xb8(%r14), %ecx
addl $0x2, %ecx
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %r8d
callq 0x43bae0
movq %r14, %rdi
movl $0x45, %esi
movl $0x1, %edx
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x43bae0
movq (%r14), %rax
cmpb $0x0, 0x61(%rax)
jne 0x46cbe2
leaq 0xe33b6(%rip), %rax     # 0x54ff78
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
movq 0x68(%r14), %rax
movslq 0xb8(%r14), %rdx
leaq (%rdx,%rdx,2), %rdx
movb $-0x1, -0x17(%rax,%rdx,8)
movq %rcx, -0x8(%rax,%rdx,8)
testl %ebp, %ebp
je 0x46cbfd
movzbl 0x1f(%rbx), %eax
cmpq $0x7, %rax
ja 0x46cbfd
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rbx)
movl %ebp, 0xc4(%rbx,%rax,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: windowInitAccum
static int windowInitAccum(Parse *pParse, Window *pMWin){
  Vdbe *v = sqlite3GetVdbe(pParse);
  int regArg;
  int nArg = 0;
  Window *pWin;
  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
    FuncDef *pFunc = pWin->pFunc;
    sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
    nArg = MAX(nArg, windowArgCount(pWin));
    if( pFunc->zName==nth_valueName
     || pFunc->zName==first_valueName
    ){
      sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp);
      sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
    }

    if( (pFunc->funcFlags & SQLITE_FUNC_MINMAX) && pWin->csrApp ){
      assert( pWin->eStart!=TK_UNBOUNDED );
      sqlite3VdbeAddOp1(v, OP_ResetSorter, pWin->csrApp);
      sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
    }
  }
  regArg = pParse->nMem+1;
  pParse->nMem += nArg;
  return regArg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, (%rsp)
callq 0x44e8aa
testq %r14, %r14
je 0x46cd0b
movq %rax, %r15
xorl %ebp, %ebp
leaq 0xe3320(%rip), %r12     # 0x54ff52
leaq 0xe3323(%rip), %r13     # 0x54ff5c
movq 0x40(%r14), %rbx
movl 0x4c(%r14), %ecx
movq %r15, %rdi
movl $0x49, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x43bae0
movq 0x60(%r14), %rax
movq 0x20(%rax), %rax
movl $0x0, %ecx
testq %rax, %rax
je 0x46cc67
movl (%rax), %ecx
cmpl %ecx, %ebp
movl $0x0, %edx
cmovgl %ebp, %edx
testq %rax, %rax
je 0x46cc80
cmpl %ecx, %ebp
movl %edx, %ebp
jg 0x46cc82
movl (%rax), %ebp
jmp 0x46cc82
movl %edx, %ebp
movq 0x38(%rbx), %rax
cmpq %r12, %rax
setne %cl
cmpq %r13, %rax
setne %al
testb %al, %cl
jne 0x46ccc4
movl 0x58(%r14), %ecx
movq %r15, %rdi
movl $0x46, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x43bae0
movl 0x58(%r14), %ecx
incl %ecx
movq %r15, %rdi
movl $0x46, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x43bae0
testb $0x10, 0x5(%rbx)
je 0x46ccfc
movl 0x54(%r14), %edx
testl %edx, %edx
je 0x46ccfc
movq %r15, %rdi
movl $0x8b, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x43bae0
movl 0x58(%r14), %ecx
incl %ecx
movq %r15, %rdi
movl $0x46, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x43bae0
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x46cc39
jmp 0x46cd0d
xorl %ebp, %ebp
movq (%rsp), %rdx
movl 0x38(%rdx), %ecx
leal 0x1(%rcx), %eax
addl %ecx, %ebp
movl %ebp, 0x38(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: windowReturnRows
static void windowReturnRows(
  Parse *pParse,
  Window *pMWin,                  /* List of window functions */
  int regCtr,                     /* Register containing number of rows */
  int regGosub,                   /* Register for Gosub addrGosub */
  int addrGosub,                  /* Address of sub-routine for ReturnOneRow */
  int regInvArg,                  /* Array of registers for xInverse args */
  int regInvSize                  /* Register containing size of partition */
){
  int addr;
  Vdbe *v = sqlite3GetVdbe(pParse);
  windowAggFinal(pParse, pMWin, 0);
  addr = sqlite3VdbeAddOp3(v, OP_IfPos, regCtr, sqlite3VdbeCurrentAddr(v)+2 ,1);
  VdbeCoverage(v);
  sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
  windowReturnOneRow(pParse, pMWin, regGosub, addrGosub);
  if( regInvArg ){
    windowAggStep(pParse, pMWin, pMWin->iEphCsr, 1, regInvArg, regInvSize);
  }
  sqlite3VdbeAddOp2(v, OP_Next, pMWin->iEphCsr, addr);
  VdbeCoverage(v);
  sqlite3VdbeJumpHere(v, addr+1);   /* The OP_Goto */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, 0x4(%rsp)
movl %ecx, %r13d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %r12
callq 0x44e8aa
movq %rax, %rbx
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x46d17b
movl 0xb8(%rbx), %ecx
addl $0x2, %ecx
movq %rbx, %rdi
movl $0x2f, %esi
movl %r15d, %edx
movl $0x1, %r8d
callq 0x43bae0
movl %eax, %r15d
movq %rbx, %rdi
movl $0xb, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x43bae0
movq %r12, %rdi
movq %r14, %rsi
movl %r13d, %edx
movl 0x4(%rsp), %ecx
callq 0x46d353
testl %ebp, %ebp
je 0x46d7ae
movl 0x40(%rsp), %r9d
movl 0x48(%r14), %edx
movq %r12, %rdi
movq %r14, %rsi
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x46cd2b
movl 0x48(%r14), %edx
movq %rbx, %rdi
movl $0x5, %esi
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x43bae0
movl 0xb8(%rbx), %eax
movq (%rbx), %rcx
cmpb $0x0, 0x61(%rcx)
je 0x46d7dd
leaq 0x13762d(%rip), %rcx    # 0x5a4e08
jmp 0x46d7fa
leal 0x1(%r15), %ecx
leal -0x1(%rax), %edx
cmpl $-0x1, %r15d
cmovgel %ecx, %edx
movslq %edx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x68(%rbx), %rcx
movl %eax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: havingToWhereExprCb
static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
  if( pExpr->op!=TK_AND ){
    Select *pS = pWalker->u.pSelect;
    if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy) ){
      sqlite3 *db = pWalker->pParse->db;
      Expr *pNew = sqlite3ExprAlloc(db, TK_INTEGER, &sqlite3IntTokens[1], 0);
      if( pNew ){
        Expr *pWhere = pS->pWhere;
        SWAP(Expr, *pNew, *pExpr);
        pNew = sqlite3ExprAnd(db, pWhere, pNew);
        pS->pWhere = pNew;
        pWalker->eCode = 1;
      }
    }
    return WRC_Prune;
  }
  return WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
xorl %ebp, %ebp
cmpb $0x2c, (%rsi)
je 0x46dede
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x28(%rdi), %r12
movq 0x38(%r12), %rcx
movq %rsp, %r15
movb $0x1, 0x24(%r15)
leaq 0xa0(%rip), %rdx        # 0x46deed
movq %rdx, 0x8(%r15)
movq $0x0, 0x10(%r15)
movq %rcx, 0x28(%r15)
movq %rax, (%r15)
movq %r15, %rdi
callq 0x452999
cmpb $0x0, 0x24(%r15)
movl $0x1, %ebp
je 0x46dede
movq (%rbx), %rax
movq (%rax), %r15
leaq 0x13051f(%rip), %rdx    # 0x59e3a0
movq %r15, %rdi
movl $0x8f, %esi
xorl %ecx, %ecx
callq 0x445107
testq %rax, %rax
je 0x46dede
movq 0x30(%r12), %rdx
movq %rsp, %r8
movl $0xa, %ecx
movq %r8, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0xa, %ecx
movq %rax, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0xa, %ecx
movq %r14, %rdi
movq %r8, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x459545
movq %rax, 0x30(%r12)
movb $0x1, 0x24(%rbx)
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: targetSrcList
static SrcList *targetSrcList(
  Parse *pParse,       /* The parsing context */
  TriggerStep *pStep   /* The trigger containing the target token */
){
  sqlite3 *db = pParse->db;
  int iDb;             /* Index of the database to use */
  SrcList *pSrc;       /* SrcList to be returned */

  pSrc = sqlite3SrcListAppend(db, 0, 0, 0);
  if( pSrc ){
    assert( pSrc->nSrc>0 );
    pSrc->a[pSrc->nSrc-1].zName = sqlite3DbStrDup(db, pStep->zTarget);
    iDb = sqlite3SchemaToIndex(db, pStep->pTrig->pSchema);
    if( iDb==0 || iDb>=2 ){
      const char *zDb;
      assert( iDb<db->nDb );
      zDb = db->aDb[iDb].zDbSName;
      pSrc->a[pSrc->nSrc-1].zDatabase =  sqlite3DbStrDup(db, zDb);
    }
  }
  return pSrc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq (%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x445281
movq %rax, %r14
testq %rax, %rax
je 0x470699
movq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x40c378
movslq (%r14), %rcx
imulq $0x70, %rcx, %rcx
movq %rax, -0x58(%rcx,%r14)
movq 0x8(%r15), %rax
movq 0x28(%rax), %rcx
testq %rcx, %rcx
je 0x47065c
movq 0x20(%rbx), %rdx
addq $0x18, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
leaq 0x20(%rdx), %rsi
cmpq %rcx, (%rdx)
movq %rsi, %rdx
jne 0x47064c
jmp 0x470661
movl $0xfff0bdc0, %eax       # imm = 0xFFF0BDC0
testl %eax, %eax
setne %cl
cmpl $0x2, %eax
setl %dl
testb %dl, %cl
jne 0x470699
movq %r14, %r15
addq $0x8, %r15
movq 0x20(%rbx), %rcx
movl %eax, %eax
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq %rbx, %rdi
callq 0x40c378
movslq (%r14), %rcx
imulq $0x70, %rcx, %rcx
movq %rax, -0x68(%rcx,%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3BtreeSecureDelete
SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree *p, int newFlag){
  int b;
  if( p==0 ) return 0;
  sqlite3BtreeEnter(p);
  assert( BTS_OVERWRITE==BTS_SECURE_DELETE*2 );
  assert( BTS_FAST_SECURE==(BTS_OVERWRITE|BTS_SECURE_DELETE) );
  if( newFlag>=0 ){
    p->pBt->btsFlags &= ~BTS_FAST_SECURE;
    p->pBt->btsFlags |= BTS_SECURE_DELETE*newFlag;
  }
  b = (p->pBt->btsFlags & BTS_FAST_SECURE)/BTS_SECURE_DELETE;
  sqlite3BtreeLeave(p);
  return b;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x474331
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x11(%rdi)
je 0x4742f6
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x4742f6
movq %rbx, %rdi
callq 0x42017c
testl %ebp, %ebp
js 0x47430e
movq 0x8(%rbx), %rax
movzwl 0x26(%rax), %ecx
andl $-0xd, %ecx
shll $0x2, %ebp
orl %ecx, %ebp
movw %bp, 0x26(%rax)
movq 0x8(%rbx), %rax
movzwl 0x26(%rax), %ebp
shrl $0x2, %ebp
andl $0x3, %ebp
cmpb $0x0, 0x11(%rbx)
je 0x474333
decl 0x14(%rbx)
jne 0x474333
movq %rbx, %rdi
callq 0x420202
jmp 0x474333
xorl %ebp, %ebp
movzwl %bp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: detachFunc
static void detachFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  const char *zName = (const char *)sqlite3_value_text(argv[0]);
  sqlite3 *db = sqlite3_context_db_handle(context);
  int i;
  Db *pDb = 0;
  char zErr[128];

  UNUSED_PARAMETER(NotUsed);

  if( zName==0 ) zName = "";
  for(i=0; i<db->nDb; i++){
    pDb = &db->aDb[i];
    if( pDb->pBt==0 ) continue;
    if( sqlite3StrICmp(pDb->zDbSName, zName)==0 ) break;
  }

  if( i>=db->nDb ){
    sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
    goto detach_error;
  }
  if( i<2 ){
    sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
    goto detach_error;
  }
  if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
    sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
    goto detach_error;
  }

  sqlite3BtreeClose(pDb->pBt);
  pDb->pBt = 0;
  pDb->pSchema = 0;
  sqlite3CollapseDatabaseArray(db);
  return;

detach_error:
  sqlite3_result_error(context, zErr, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
movl $0x1, %esi
callq 0x40ad95
movq (%rbx), %rcx
testq %rax, %rax
leaq 0xfc8b4(%rip), %r14     # 0x57226d
cmovneq %rax, %r14
movq 0x28(%rcx), %rax
movl 0x28(%rax), %r15d
testl %r15d, %r15d
setg %bpl
movq %rax, 0x8(%rsp)
jle 0x475a14
movq 0x20(%rax), %rax
xorl %r13d, %r13d
movq %rax, %r12
cmpq $0x0, 0x8(%rax)
je 0x4759f4
movq (%r12), %rdi
movq %r14, %rsi
callq 0x407729
testl %eax, %eax
je 0x475a0b
incq %r13
cmpq %r15, %r13
setb %bpl
leaq 0x20(%r12), %rax
cmpq %r13, %r15
jne 0x4759da
movl %r15d, %r13d
cmpl $0x2, %r13d
setb %al
jmp 0x475a19
xorl %r12d, %r12d
movb $0x1, %al
leaq 0xde3c6(%rip), %rcx     # 0x553de6
leaq 0xde3aa(%rip), %rdx     # 0x553dd1
testb $0x1, %bpl
cmovneq %rcx, %rdx
je 0x475a4d
testb %al, %al
jne 0x475a4d
movq 0x8(%r12), %rdi
leaq 0xde3bf(%rip), %rdx     # 0x553e00
cmpb $0x0, 0x10(%rdi)
jne 0x475a4d
cmpl $0x0, 0x18(%rdi)
je 0x475a99
leaq 0x10(%rsp), %r15
movl $0x80, %edi
movq %r15, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x407373
movl $0x1, 0x24(%rbx)
movq (%rbx), %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
movq $-0x1, %r8
callq 0x40b018
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4245db
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %rax, 0x18(%r12)
movq 0x8(%rsp), %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43c729
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameTestSchema
static void renameTestSchema(Parse *pParse, const char *zDb, int bTemp){
  sqlite3NestedParse(pParse, 
      "SELECT 1 "
      "FROM \"%w\".%s "
      "WHERE name NOT LIKE 'sqlite_%%'"
      " AND sql NOT LIKE 'create virtual%%'"
      " AND sqlite_rename_test(%Q, sql, type, name, %d)=NULL ",
      zDb, MASTER_NAME, 
      zDb, bTemp
  );

  if( bTemp==0 ){
    sqlite3NestedParse(pParse, 
        "SELECT 1 "
        "FROM temp.%s "
        "WHERE name NOT LIKE 'sqlite_%%'"
        " AND sql NOT LIKE 'create virtual%%'"
        " AND sqlite_rename_test(%Q, sql, type, name, 1)=NULL ",
        MASTER_NAME, zDb 
    );
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xdd72a(%rip), %rsi     # 0x554213
leaq 0xda71c(%rip), %rcx     # 0x55120c
movq %rbx, %rdx
movq %rbx, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x45516d
testl %ebp, %ebp
je 0x476b09
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xdd793(%rip), %rsi     # 0x5542a3
leaq 0xda6f5(%rip), %rdx     # 0x55120c
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x45516d
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3InsertBuiltinFuncs
SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs(
  FuncDef *aDef,      /* List of global functions to be inserted */
  int nDef            /* Length of the apDef[] list */
){
  int i;
  for(i=0; i<nDef; i++){
    FuncDef *pOther;
    const char *zName = aDef[i].zName;
    int nName = sqlite3Strlen30(zName);
    int h = (zName[0] + nName) % SQLITE_FUNC_HASH_SZ;
    assert( zName[0]>='a' && zName[0]<='z' );
    pOther = functionSearch(h, zName);
    if( pOther ){
      assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] );
      aDef[i].pNext = pOther->pNext;
      pOther->pNext = &aDef[i];
    }else{
      aDef[i].pNext = 0;
      aDef[i].u.pHash = sqlite3BuiltinFunctions.a[h];
      sqlite3BuiltinFunctions.a[h] = &aDef[i];
    }
  }
}

// Assembly:
testl %esi, %esi
jle 0x478b1b
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl %esi, %r12d
leaq 0x12bff6(%rip), %r13    # 0x5a4a70
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x478a92
movq %r14, %rdi
callq 0x401100
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jmp 0x478a94
xorl %eax, %eax
movsbl (%r14), %ecx
addl %eax, %ecx
movslq %ecx, %rax
imulq $-0x4de9bd37, %rax, %r15 # imm = 0xB21642C9
shrq $0x20, %r15
addl %eax, %r15d
movl %r15d, %ecx
shrl $0x1f, %ecx
sarl $0x4, %r15d
addl %ecx, %r15d
leal (%r15,%r15,2), %ecx
shll $0x3, %ecx
subl %ecx, %r15d
addl %eax, %r15d
movl %r15d, %edi
movq %r14, %rsi
callq 0x47c61b
testq %rax, %rax
je 0x478ae0
addq $0x10, %rax
movl $0x10, %ecx
jmp 0x478afb
movq $0x0, 0x10(%rbx)
movslq %r15d, %rax
leaq (,%rax,8), %rax
addq %r13, %rax
movl $0x40, %ecx
movq (%rax), %rdx
movq %rdx, (%rbx,%rcx)
movq %rbx, (%rax)
addq $0x48, %rbx
decq %r12
jne 0x478a7a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameParseSql
static int renameParseSql(
  Parse *p,                       /* Memory to use for Parse object */
  const char *zDb,                /* Name of schema SQL belongs to */
  int bTable,                     /* 1 -> RENAME TABLE, 0 -> RENAME COLUMN */
  sqlite3 *db,                    /* Database handle */
  const char *zSql,               /* SQL to parse */
  int bTemp                       /* True if SQL is from temp schema */
){
  int rc;
  char *zErr = 0;

  db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb);

  /* Parse the SQL statement passed as the first argument. If no error
  ** occurs and the parse does not result in a new table, index or
  ** trigger object, the database must be corrupt. */
  memset(p, 0, sizeof(Parse));
  p->eParseMode = (bTable ? PARSE_MODE_RENAME_TABLE : PARSE_MODE_RENAME_COLUMN);
  p->db = db;
  p->nQueryLoop = 1;
  rc = sqlite3RunParser(p, zSql, &zErr);
  assert( p->zErrMsg==0 );
  assert( rc!=SQLITE_OK || zErr==0 );
  assert( (0!=p->pNewTable) + (0!=p->pNewIndex) + (0!=p->pNewTrigger)<2 );
  p->zErrMsg = zErr;
  if( db->mallocFailed ) rc = SQLITE_NOMEM;
  if( rc==SQLITE_OK 
   && p->pNewTable==0 && p->pNewIndex==0 && p->pNewTrigger==0 
  ){
    rc = SQLITE_CORRUPT_BKPT;
  }

#ifdef SQLITE_DEBUG
  /* Ensure that all mappings in the Parse.pRename list really do map to
  ** a part of the input string.  */
  if( rc==SQLITE_OK ){
    int nSql = sqlite3Strlen30(zSql);
    RenameToken *pToken;
    for(pToken=p->pRename; pToken; pToken=pToken->pNext){
      assert( pToken->t.z>=zSql && &pToken->t.z[pToken->t.n]<=&zSql[nSql] );
    }
  }
#endif

  db->init.iDb = 0;
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
movb $0x1, %al
testl %r9d, %r9d
jne 0x479b6b
movq %rbx, %rdi
callq 0x413b87
movb %al, 0xb4(%rbx)
movl $0x198, %edx            # imm = 0x198
movq %r14, %rdi
xorl %esi, %esi
callq 0x4010b8
testl %ebp, %ebp
sete %al
xorb $0x3, %al
movb %al, 0x10c(%r14)
movq %rbx, (%r14)
movl $0x1, 0xb4(%r14)
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x410e60
movq (%r12), %rcx
movq %rcx, 0x8(%r14)
cmpb $0x0, 0x61(%rbx)
movl $0x7, %ebp
cmovel %eax, %ebp
testl %ebp, %ebp
jne 0x479bdd
cmpq $0x0, 0x138(%r14)
jne 0x479bdb
cmpq $0x0, 0x140(%r14)
je 0x479bf3
xorl %ebp, %ebp
movb $0x0, 0xb4(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x148(%r14)
movl $0x0, %ebp
jne 0x479bdd
leaq 0xd6c9e(%rip), %rsi     # 0x5508a7
leaq 0xd6dba(%rip), %rdx     # 0x5509ca
leaq 0xd6ac7(%rip), %r8      # 0x5506de
movl $0xb, %ebp
movl $0xb, %edi
movl $0x18ebb, %ecx          # imm = 0x18EBB
xorl %eax, %eax
callq 0x40743a
jmp 0x479bdd
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameColumnElistNames
static void renameColumnElistNames(
  Parse *pParse, 
  RenameCtx *pCtx, 
  ExprList *pEList, 
  const char *zOld
){
  if( pEList ){
    int i;
    for(i=0; i<pEList->nExpr; i++){
      char *zName = pEList->a[i].zName;
      if( 0==sqlite3_stricmp(zName, zOld) ){
        renameTokenFind(pParse, pCtx, (void*)zName);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
testq %rdx, %rdx
je 0x47a023
movq %rdx, %r14
movslq (%rdx), %rbp
testq %rbp, %rbp
jle 0x47a023
movq %rcx, %rbx
addq $0x8, %r14
xorl %r15d, %r15d
movq %rcx, %rax
negq %rax
movl $0x0, %r12d
sbbl %r12d, %r12d
addq $0x190, 0x8(%rsp)       # imm = 0x190
testq %rbx, %rbx
sete %cl
movq %r15, %rax
shlq $0x5, %rax
movq 0x8(%r14,%rax), %r13
testq %r13, %r13
sete %dl
movl $0x1, %eax
cmovel %r12d, %eax
orb %cl, %dl
jne 0x479fce
movq %r13, %rdi
movq %rbx, %rsi
callq 0x407729
testl %eax, %eax
jne 0x47a017
movq 0x8(%rsp), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x47a017
movq 0x8(%rsp), %rcx
cmpq %r13, (%rax)
je 0x479ffe
movq %rax, %rcx
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x47a017
cmpq %r13, (%rax)
jne 0x479fe9
addq $0x18, %rcx
movq 0x18(%rax), %rdx
movq %rdx, (%rcx)
movq 0x10(%rsp), %rdx
movq (%rdx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, (%rdx)
incl 0x8(%rdx)
incq %r15
cmpq %rbp, %r15
jne 0x479f9e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameParseCleanup
static void renameParseCleanup(Parse *pParse){
  sqlite3 *db = pParse->db;
  if( pParse->pVdbe ){
    sqlite3VdbeFinalize(pParse->pVdbe);
  }
  sqlite3DeleteTable(db, pParse->pNewTable);
  if( pParse->pNewIndex ) sqlite3FreeIndex(db, pParse->pNewIndex);
  sqlite3DeleteTrigger(db, pParse->pNewTrigger);
  sqlite3DbFree(db, pParse->zErrMsg);
  renameTokenFree(db, pParse->pRename);
  sqlite3ParserReset(pParse);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x47a4af
callq 0x40aa03
movq 0x138(%rbx), %rsi
movq %r14, %rdi
callq 0x404aa4
movq 0x140(%rbx), %rsi
testq %rsi, %rsi
je 0x47a4d2
movq %r14, %rdi
callq 0x439612
movq 0x148(%rbx), %rsi
movq %r14, %rdi
callq 0x404a3b
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x47a4f2
movq %r14, %rdi
callq 0x415dca
movq 0x190(%rbx), %rsi
testq %rsi, %rsi
je 0x47a512
movq 0x18(%rsi), %r15
movq %r14, %rdi
callq 0x415dca
movq %r15, %rsi
testq %r15, %r15
jne 0x47a4fe
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40e9ed
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameTableExprCb
static int renameTableExprCb(Walker *pWalker, Expr *pExpr){
  RenameCtx *p = pWalker->u.pRename;
  if( pExpr->op==TK_COLUMN && p->pTab==pExpr->pTab ){
    renameTokenFind(pWalker->pParse, p, (void*)&pExpr->pTab);
  }
  return WRC_Continue;
}

// Assembly:
cmpb $-0x62, (%rsi)
jne 0x47a57c
movq 0x28(%rdi), %rax
movq 0x10(%rax), %rcx
cmpq 0x40(%rsi), %rcx
jne 0x47a57c
movq (%rdi), %rdx
movq 0x190(%rdx), %rcx
testq %rcx, %rcx
je 0x47a57c
addq $0x40, %rsi
cmpq %rsi, (%rcx)
je 0x47a561
movq %rcx, %rdx
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
je 0x47a57c
cmpq %rsi, (%rcx)
jne 0x47a54a
addq $0x18, %rdx
jmp 0x47a568
addq $0x190, %rdx            # imm = 0x190
movq 0x18(%rcx), %rsi
movq %rsi, (%rdx)
movq (%rax), %rdx
movq %rdx, 0x18(%rcx)
movq %rcx, (%rax)
incl 0x8(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: renameTableSelectCb
static int renameTableSelectCb(Walker *pWalker, Select *pSelect){
  int i;
  RenameCtx *p = pWalker->u.pRename;
  SrcList *pSrc = pSelect->pSrc;
  for(i=0; i<pSrc->nSrc; i++){
    struct SrcList_item *pItem = &pSrc->a[i];
    if( pItem->pTab==p->pTab ){
      renameTokenFind(pWalker->pParse, p, pItem->zName);
    }
  }

  return WRC_Continue;
}

// Assembly:
movq 0x28(%rsi), %rax
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x47a5f9
movq 0x28(%rdi), %rdx
addq $0x8, %rax
xorl %esi, %esi
imulq $0x70, %rsi, %r10
movq 0x20(%rax,%r10), %r8
cmpq 0x10(%rdx), %r8
jne 0x47a5f1
movq (%rdi), %r9
movq 0x190(%r9), %r8
testq %r8, %r8
je 0x47a5f1
addq %rax, %r10
movq 0x10(%r10), %r10
cmpq %r10, (%r8)
je 0x47a5d6
movq %r8, %r9
movq 0x18(%r8), %r8
testq %r8, %r8
je 0x47a5f1
cmpq %r10, (%r8)
jne 0x47a5bf
addq $0x18, %r9
jmp 0x47a5dd
addq $0x190, %r9             # imm = 0x190
movq 0x18(%r8), %r10
movq %r10, (%r9)
movq (%rdx), %r9
movq %r9, 0x18(%r8)
movq %r8, (%rdx)
incl 0x8(%rdx)
incq %rsi
cmpq %rcx, %rsi
jne 0x47a595
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: percent_rankStepFunc
static void percent_rankStepFunc(
  sqlite3_context *pCtx, 
  int nArg,
  sqlite3_value **apArg
){
  struct CallCount *p;
  UNUSED_PARAMETER(nArg); assert( nArg==1 );

  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nTotal==0 ){
      p->nTotal = sqlite3_value_int64(apArg[0]);
    }
    p->nStep++;
    if( p->nValue==0 ){
      p->nValue = p->nStep;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x47a795
movl $0x18, %esi
callq 0x40c406
movq %rax, %rbx
jmp 0x47a799
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0x47a7c5
cmpq $0x0, 0x10(%rbx)
jne 0x47a7b1
movq (%r14), %rdi
callq 0x40ad24
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rax
incq %rax
movq %rax, 0x8(%rbx)
cmpq $0x0, (%rbx)
jne 0x47a7c5
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: percent_rankValueFunc
static void percent_rankValueFunc(sqlite3_context *pCtx){
  struct CallCount *p;
  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nTotal>1 ){
      double r = (double)(p->nValue-1) / (double)(p->nTotal-1);
      sqlite3_result_double(pCtx, r);
    }else{
      sqlite3_result_double(pCtx, 0.0);
    }
    p->nValue = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x47a7f0
movq %rbx, %rdi
movl $0x18, %esi
callq 0x40c406
movq %rax, %r14
jmp 0x47a7f4
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x47a830
movq 0x10(%r14), %rax
xorpd %xmm0, %xmm0
cmpq $0x2, %rax
jl 0x47a821
movq (%r14), %rcx
decq %rcx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
decq %rax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movq (%rbx), %rdi
callq 0x40afa4
movq $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: cume_distStepFunc
static void cume_distStepFunc(
  sqlite3_context *pCtx, 
  int nArg,
  sqlite3_value **apArg
){
  struct CallCount *p;
  assert( nArg==1 ); UNUSED_PARAMETER(nArg);

  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nTotal==0 ){
      p->nTotal = sqlite3_value_int64(apArg[0]);
    }
    p->nStep++;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x47a858
movl $0x18, %esi
callq 0x40c406
movq %rax, %r14
jmp 0x47a85c
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x47a878
cmpq $0x0, 0x10(%r14)
jne 0x47a874
movq (%rbx), %rdi
callq 0x40ad24
movq %rax, 0x10(%r14)
incq 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: cume_distValueFunc
static void cume_distValueFunc(sqlite3_context *pCtx){
  struct CallCount *p;
  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p && p->nTotal ){
    double r = (double)(p->nStep) / (double)(p->nTotal);
    sqlite3_result_double(pCtx, r);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x47a89d
movq %rbx, %rdi
movl $0x18, %esi
callq 0x40c406
jmp 0x47a8a1
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x47a8c7
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x47a8c7
cvtsi2sdq 0x8(%rax), %xmm0
cvtsi2sd %rcx, %xmm1
divsd %xmm1, %xmm0
movq (%rbx), %rdi
popq %rbx
jmp 0x40afa4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: ntileStepFunc
static void ntileStepFunc(
  sqlite3_context *pCtx, 
  int nArg,
  sqlite3_value **apArg
){
  struct NtileCtx *p;
  assert( nArg==2 ); UNUSED_PARAMETER(nArg);
  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nTotal==0 ){
      p->nParam = sqlite3_value_int64(apArg[0]);
      p->nTotal = sqlite3_value_int64(apArg[1]);
      if( p->nParam<=0 ){
        sqlite3_result_error(
            pCtx, "argument of ntile must be a positive integer", -1
        );
      }
    }
    p->iRow++;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x47a8f0
movq %rbx, %rdi
movl $0x18, %esi
callq 0x40c406
movq %rax, %r14
jmp 0x47a8f4
movq 0x10(%rax), %r14
testq %r14, %r14
je 0x47a949
cmpq $0x0, (%r14)
jne 0x47a945
movq (%r15), %rdi
callq 0x40ad24
movq %rax, 0x8(%r14)
movq 0x8(%r15), %rdi
callq 0x40ad24
movq %rax, (%r14)
cmpq $0x0, 0x8(%r14)
jg 0x47a945
movl $0x1, 0x24(%rbx)
movq (%rbx), %rdi
leaq 0xd9fd0(%rip), %rsi     # 0x5548ff
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
movq $-0x1, %r8
callq 0x40b018
incq 0x10(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: last_valueValueFunc
static void last_valueValueFunc(sqlite3_context *pCtx){
  struct LastValueCtx *p;
  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p && p->pVal ){
    sqlite3_result_value(pCtx, p->pVal);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x47aacf
movq %rbx, %rdi
movl $0x10, %esi
callq 0x40c406
jmp 0x47aad3
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x47aae9
movq (%rax), %rsi
testq %rsi, %rsi
je 0x47aae9
movq (%rbx), %rdi
popq %rbx
jmp 0x40b406
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/util.c
// Function: trim_space
char* trim_space(const char* s) {
  size_t start = 0;
  while (start < strlen(s) && isspace(s[start])) {
    start++;
  }
  size_t limit = strlen(s);
  while (limit > start && isspace(s[limit - 1])) {
    limit--;
  }

  char* res = calloc(sizeof(char), limit - start + 1);
  for (size_t i = 0; i < limit - start; i++)
    res[i] = s[start + i];
  res[limit - start] = '\0';

  return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x401100
movq %rax, %r14
testq %rax, %rax
je 0x47d2bb
callq 0x480070
movq (%rax), %rax
xorl %r12d, %r12d
movsbq (%rbx,%r12), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x47d2be
incq %r12
cmpq %r12, %r14
jne 0x47d2a2
movq %r14, %r12
jmp 0x47d2be
xorl %r12d, %r12d
cmpq %r12, %r14
jbe 0x47d2e3
callq 0x480070
movq (%rax), %rax
movsbq -0x1(%rbx,%r14), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x47d2e3
decq %r14
cmpq %r12, %r14
ja 0x47d2cb
movq %r12, %r14
movq %r14, %rax
subq %r12, %rax
leaq 0x1(%rax), %rsi
movl $0x1, %edi
callq 0x4a9160
movq %rax, %r15
subq %r12, %r14
je 0x47d310
addq %r12, %rbx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x401048
movb $0x0, (%r15,%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O1/veltzer[P]xmeltdown/src/grid.c
// Function: Initialize
void Initialize(int argc, char** argv)
{
	XSizeHints size_hints;
	if (!(dpy=XOpenDisplay(""))) {
		printf ("Error: Can't open display.");
		exit(-1);
	}
	screen=DefaultScreen(dpy);

	size_hints.width=400;
	size_hints.height=400;
	size_hints.flags=PSize;

	win=XCreateSimpleWindow(dpy,
		DefaultRootWindow(dpy),
		0, 0,
		size_hints.width,
		size_hints.height,
		4,
		BlackPixel(dpy, screen),
		WhitePixel(dpy, screen));

	XSetStandardProperties (dpy, win, "GC demo",
		"stickman",
		None, argv, argc, &size_hints);

	XMapWindow(dpy, win);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movl %edi, %ebx
leaq 0xe2d(%rip), %rdi       # 0x201e
callq 0x1060
movq %rax, 0x2e93(%rip)      # 0x4090
testq %rax, %rax
je 0x12af
movslq 0xe0(%rax), %r10
movabsq $0x19000000190, %rcx    # imm = 0x19000000190
movq %rsp, %r15
movq %rcx, 0x10(%r15)
movq $0x8, (%r15)
movq 0xe8(%rax), %r11
shlq $0x7, %r10
movq 0x10(%r11,%r10), %rsi
subq $0x8, %rsp
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x190, %r8d            # imm = 0x190
movl $0x190, %r9d            # imm = 0x190
pushq 0x58(%r11,%r10)
pushq 0x60(%r11,%r10)
pushq $0x4
callq 0x1050
addq $0x20, %rsp
movq %rax, 0x2e30(%rip)      # 0x4098
movq 0x2e21(%rip), %rdi      # 0x4090
leaq 0xda9(%rip), %rdx       # 0x201f
leaq 0xdaa(%rip), %rcx       # 0x2027
movq %rax, %rsi
xorl %r8d, %r8d
movq %r14, %r9
pushq %r15
pushq %rbx
callq 0x10d0
addq $0x10, %rsp
movq 0x2df7(%rip), %rdi      # 0x4090
movq 0x2df8(%rip), %rsi      # 0x4098
callq 0x10a0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xd4e(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1040
// File: /workspace/github_c_makefile_star2_O1/veltzer[P]xmeltdown/src/grid.c
// Function: DrawGrid
void DrawGrid(void) {
	int fromx, fromy, tox, toy;
	int counter;
	for (counter=0; counter < 16; counter++) {
		fromx=counter*10;
		fromy=0;
		tox=counter*10;
		toy=400;
		XDrawLine(dpy, win,
			gc_list[counter],
			fromx, fromy, tox, toy);

		fromx=0;
		fromy=counter*10;
		tox=400;
		toy=counter*10;
		XDrawLine(dpy, win,
			gc_list[counter],
			fromx, fromy, tox, toy);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2dce(%rip), %r14      # 0x40a0
xorl %ebx, %ebx
movq 0x2db5(%rip), %rdi      # 0x4090
movq 0x2db6(%rip), %rsi      # 0x4098
movq (%r14), %rdx
movl $0x190, (%rsp)          # imm = 0x190
movl %ebx, %ecx
xorl %r8d, %r8d
movl %ebx, %r9d
callq 0x1070
movq 0x2d90(%rip), %rdi      # 0x4090
movq 0x2d91(%rip), %rsi      # 0x4098
movq (%r14), %rdx
movl %ebx, (%rsp)
xorl %ecx, %ecx
movl %ebx, %r8d
movl $0x190, %r9d            # imm = 0x190
callq 0x1070
addq $0xa, %rbx
addq $0x8, %r14
cmpq $0xa0, %rbx
jne 0x12d4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/veltzer[P]xmeltdown/src/grid.c
// Function: main
int main(int argc, char** argv) {
	XGCValues my_gcvalues;
	XEvent my_event;
	int counter;

	Initialize(argc, argv);

	XSelectInput(dpy, win,
		ExposureMask|ButtonPressMask|ButtonReleaseMask|
		ButtonMotionMask|KeyPressMask);

	my_gcvalues.line_width=5;
	my_gcvalues.line_style=LineSolid;
	for (counter=0; counter < 16; counter++) {
		my_gcvalues.function=counter;

		gc_list[counter]=XCreateGC(dpy, win,
			GCFunction|GCLineWidth|GCLineStyle,
			&my_gcvalues);
	}
	while (1) {
		XNextEvent (dpy, &my_event);
		if (my_event.type == Expose)
			DrawGrid();
		if (my_event.type == ButtonPress)
			DrawGrid();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
callq 0x11dc
movq 0x2d26(%rip), %rdi      # 0x4090
movq 0x2d27(%rip), %rsi      # 0x4098
movl $0xa00d, %edx           # imm = 0xA00D
callq 0x10c0
leaq 0xc0(%rsp), %rbx
movq $0x5, 0x20(%rbx)
leaq 0x2d0e(%rip), %r14      # 0x40a0
xorl %r15d, %r15d
movl %r15d, 0xc0(%rsp)
movq 0x2cec(%rip), %rdi      # 0x4090
movq 0x2ced(%rip), %rsi      # 0x4098
movl $0x31, %edx
movq %rbx, %rcx
callq 0x10b0
movq %rax, (%r14)
incq %r15
addq $0x8, %r14
cmpq $0x10, %r15
jne 0x1395
movq %rsp, %rbx
movq 0x2cbe(%rip), %rdi      # 0x4090
movq %rbx, %rsi
callq 0x1090
cmpl $0xc, (%rsp)
jne 0x13e5
callq 0x12c7
cmpl $0x4, (%rsp)
jne 0x13cb
callq 0x12c7
jmp 0x13cb
// File: /workspace/github_c_makefile_star2_O1/fabiovila[P]fs2ch/fs2ch.cpp
// Function: listfolder(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void listfolder(const std::string& path)
{
	
    if (!path.empty())
    {
        namespace fs = boost::filesystem;

        fs::path apk_path(path);
        fs::recursive_directory_iterator end;

        for (fs::recursive_directory_iterator i(apk_path); i != end; ++i)
        {
            const fs::path cp = (*i);
            List.push_back(cp.string());
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x4d27
leaq -0x68(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rdi), %rsi
addq %rsi, %rdx
leaq -0x78(%rbp), %rbx
movq %rbx, %rdi
callq 0xba20
movq $0x0, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x8ce6
leaq -0x48(%rbp), %r13
leaq -0x30(%rbp), %rbx
leaq -0x58(%rbp), %r14
leaq 0xe53d(%rip), %r15      # 0x131c8
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq %rax, %rcx
je 0x4d00
testq %rcx, %rcx
je 0x4ca7
movq 0x8(%rcx), %rdx
cmpq 0x10(%rcx), %rdx
jne 0x4cb6
testq %rax, %rax
je 0x4d00
movq 0x8(%rax), %rcx
cmpq 0x10(%rax), %rcx
je 0x4d00
movq %rbx, %rdi
callq 0xbef6
movq %r13, -0x58(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xba20
movq %r15, %rdi
movq %r14, %rsi
callq 0x8d18
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x4cf4
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2120
jmp 0x4c8b
leaq -0x30(%rbp), %rdi
callq 0xb8f0
leaq -0x38(%rbp), %rdi
callq 0xb8f0
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x4d27
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x21d0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4d63
jmp 0x4d57
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x4d5a
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21d0
jmp 0x4d5a
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xb8f0
leaq -0x38(%rbp), %rdi
callq 0xb8f0
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x4d81
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22e0