LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: isSimpleCount
static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
  Table *pTab;
  Expr *pExpr;

  assert( !p->pGroupBy );

  if( p->pWhere || p->pEList->nExpr!=1 
   || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect
  ){
    return 0;
  }
  pTab = p->pSrc->a[0].pTab;
  pExpr = p->pEList->a[0].pExpr;
  assert( pTab && !pTab->pSelect && pExpr );

  if( IsVirtual(pTab) ) return 0;
  if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
  if( NEVER(pAggInfo->nFunc==0) ) return 0;
  if( (pAggInfo->aFunc[0].pFunc->flags&SQLITE_FUNC_COUNT)==0 ) return 0;
  if( pExpr->flags&EP_Distinct ) return 0;

  return pTab;
}

// Assembly:
cmpq $0x0, 0x30(%rdi)
je 0x557cc
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
cmpl $0x1, (%rax)
jne 0x55812
movq 0x28(%rdi), %rcx
cmpb $0x1, (%rcx)
jne 0x55812
cmpq $0x0, 0x30(%rcx)
jne 0x55812
movq 0x28(%rcx), %rcx
testb $0x10, 0x46(%rcx)
jne 0x55812
movq 0x8(%rax), %rax
movq (%rax), %rdi
cmpb $-0x67, (%rdi)
setne %al
testl %edx, %edx
sete %dl
orb %al, %dl
jne 0x55812
movq 0x8(%rsi), %rax
testb $0x10, 0x3(%rax)
jne 0x55816
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
testb $0x10, 0x2(%rdi)
cmoveq %rcx, %rax
jmp 0x55814
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: explainSimpleCount
static void explainSimpleCount(
  Parse *pParse,                  /* Parse context */
  Table *pTab,                    /* Table being queried */
  Index *pIdx                     /* Index used to optimize scan, or NULL */
){
  if( pParse->explain==2 ){
    char *zEqp = sqlite3MPrintf(pParse->db, "SCAN TABLE %s%s%s",
        pTab->zName, 
        pIdx ? " USING COVERING INDEX " : "",
        pIdx ? pIdx->zName : ""
    );
    sqlite3VdbeAddOp4(
        pParse->pVdbe, OP_Explain, pParse->iSelectId, 0, 0, zEqp, P4_DYNAMIC
    );
  }
}

// Assembly:
cmpb $0x2, 0x200(%rdi)
jne 0x558a4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rsi), %rdx
leaq 0x28b68(%rip), %r8      # 0x7e3b0
leaq 0x26431(%rip), %rcx     # 0x7bc80
testq %rax, %rax
cmoveq %r8, %rcx
je 0x5585b
movq (%rax), %r8
leaq 0x2640c(%rip), %rsi     # 0x7bc6e
xorl %eax, %eax
callq 0x11900
movq %rax, %r14
movq 0x10(%rbx), %r15
movl 0x210(%rbx), %edx
movq %r15, %rdi
movl $0x96, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45f15
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11a9f
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: minMaxQuery
static u8 minMaxQuery(AggInfo *pAggInfo, ExprList **ppMinMax){
  int eRet = WHERE_ORDERBY_NORMAL;          /* Return value */

  *ppMinMax = 0;
  if( pAggInfo->nFunc==1 ){
    Expr *pExpr = pAggInfo->aFunc[0].pExpr; /* Aggregate function */
    ExprList *pEList = pExpr->x.pList;      /* Arguments to agg function */

    assert( pExpr->op==TK_AGG_FUNCTION );
    if( pEList && pEList->nExpr==1 && pEList->a[0].pExpr->op==TK_AGG_COLUMN ){
      const char *zFunc = pExpr->u.zToken;
      if( sqlite3StrICmp(zFunc, "min")==0 ){
        eRet = WHERE_ORDERBY_MIN;
        *ppMinMax = pEList;
      }else if( sqlite3StrICmp(zFunc, "max")==0 ){
        eRet = WHERE_ORDERBY_MAX;
        *ppMinMax = pEList;
      }
    }
  }

  assert( *ppMinMax==0 || (*ppMinMax)->nExpr==1 );
  return eRet;
}

// Assembly:
movq $0x0, (%rsi)
cmpl $0x1, 0x30(%rdi)
jne 0x5596b
pushq %rbp
movq %rsp, %rbp
movq 0x28(%rdi), %rax
movq (%rax), %rax
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x55999
cmpl $0x1, (%rcx)
jne 0x55999
movq 0x8(%rcx), %rdx
movq (%rdx), %rdx
cmpb $-0x66, (%rdx)
jne 0x55999
movq 0x8(%rax), %rdx
movb (%rdx), %r8b
testb %r8b, %r8b
je 0x5596e
xorl %eax, %eax
leaq 0x2639b(%rip), %r9      # 0x7bc97
leaq 0x207ad(%rip), %rdi     # 0x760b0
movl %r8d, %r10d
movzbl %r10b, %r10d
movb (%r10,%rdi), %r10b
movzbl (%rax,%r9), %r11d
movb (%r11,%rdi), %r11b
cmpb %r11b, %r10b
jne 0x55935
movb 0x1(%rdx,%rax), %r10b
incq %rax
testb %r10b, %r10b
jne 0x55906
movzbl (%rax,%r9), %eax
movb (%rax,%rdi), %r11b
xorl %r10d, %r10d
movb $0x1, %al
cmpb %r11b, %r10b
je 0x55994
incq %rdx
leaq 0x26355(%rip), %rax     # 0x7bc9b
xorl %r9d, %r9d
movzbl %r8b, %r8d
movb (%r8,%rdi), %r10b
movzbl (%rax), %r11d
cmpb (%r11,%rdi), %r10b
jne 0x5597a
incq %rax
movb (%rdx), %r8b
incq %rdx
testb %r8b, %r8b
jne 0x55949
jmp 0x5597d
xorl %eax, %eax
retq
leaq 0x26326(%rip), %rax     # 0x7bc9b
xorl %r9d, %r9d
jmp 0x5597d
movq %r8, %r9
leaq 0x2072c(%rip), %rdx     # 0x760b0
movb (%r9,%rdx), %dil
movzbl (%rax), %r8d
movb $0x2, %al
cmpb (%r8,%rdx), %dil
jne 0x55999
movq %rcx, (%rsi)
jmp 0x5599b
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3SrcListEnlarge
SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(
  sqlite3 *db,       /* Database connection to notify of OOM errors */
  SrcList *pSrc,     /* The SrcList to be enlarged */
  int nExtra,        /* Number of new slots to add to pSrc->a[] */
  int iStart         /* Index in pSrc->a[] of first new slot */
){
  int i;

  /* Sanity checking on calling parameters */
  assert( iStart>=0 );
  assert( nExtra>=1 );
  assert( pSrc!=0 );
  assert( iStart<=pSrc->nSrc );

  /* Allocate additional space if needed */
  if( pSrc->nSrc+nExtra>pSrc->nAlloc ){
    SrcList *pNew;
    int nAlloc = pSrc->nSrc+nExtra;
    int nGot;
    pNew = sqlite3DbRealloc(db, pSrc,
               sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
    if( pNew==0 ){
      assert( db->mallocFailed );
      return pSrc;
    }
    pSrc = pNew;
    nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
    pSrc->nAlloc = (u8)nGot;
  }

  /* Move existing slots that come after the newly inserted slots
  ** out of the way */
  for(i=pSrc->nSrc-1; i>=iStart; i--){
    pSrc->a[i+nExtra] = pSrc->a[i];
  }
  pSrc->nSrc += (i8)nExtra;

  /* Zero the newly allocated slots */
  memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
  for(i=iStart; i<iStart+nExtra; i++){
    pSrc->a[i].iCursor = -1;
  }

  /* Return a pointer to the enlarged SrcList */
  return pSrc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r14d
movq %rsi, %r13
movb (%rsi), %al
movzbl %al, %ecx
leal (%rcx,%r14), %edx
movzbl 0x1(%rsi), %esi
cmpl %esi, %edx
jle 0x56113
movq %rdi, %r12
imull $0x68, %edx, %edx
addl $0x8, %edx
movq %r13, %rsi
callq 0x174d6
testq %rax, %rax
je 0x561cb
movq %rax, %r15
testq %r12, %r12
je 0x56118
cmpq %r15, 0x170(%r12)
ja 0x56118
cmpq %r15, 0x178(%r12)
jbe 0x56118
movzwl 0x150(%r12), %eax
jmp 0x56121
movq %r13, %r15
jmp 0x56143
movq %r15, %rdi
callq *0x3e317(%rip)          # 0x94438
cltq
addq $-0x70, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %rcx # imm = 0x4EC4EC4EC4EC4EC5
mulq %rcx
shrl $0x5, %edx
incb %dl
movb %dl, 0x1(%r15)
movb (%r15), %al
movzbl %al, %ecx
cmpl %ebx, %ecx
jle 0x56180
movzbl %al, %eax
movslq %r14d, %rcx
movslq %ebx, %r12
imulq $0x68, %rax, %rdx
addq $-0x60, %rdx
imulq $0x68, %rcx, %r8
addq %r15, %r8
decq %rax
leaq (%r8,%rdx), %rdi
leaq (%r15,%rdx), %rsi
movl $0xd, %ecx
rep  movsq (%rsi), %es:(%rdi)
addq $-0x68, %rdx
cmpq %r12, %rax
jg 0x5615f
movb (%r15), %al
jmp 0x56183
movl %ebx, %r12d
addl %r14d, %eax
movb %al, (%r15)
imulq $0x68, %r12, %r13
leaq (%r15,%r13), %rdi
addq $0x8, %rdi
movl %r14d, %eax
imulq $0x68, %rax, %rdx
xorl %esi, %esi
callq 0x8200
testl %r14d, %r14d
jle 0x561c8
addl %r14d, %ebx
movslq %ebx, %rax
leaq (%r15,%r13), %rcx
addq $0x44, %rcx
movl $0xffffffff, (%rcx)     # imm = 0xFFFFFFFF
incq %r12
addq $0x68, %rcx
cmpq %rax, %r12
jl 0x561b6
movq %r15, %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: substExprList
static void substExprList(
  sqlite3 *db,         /* Report malloc errors here */
  ExprList *pList,     /* List to scan and in which to make substitutes */
  int iTable,          /* Table to be substituted */
  ExprList *pEList     /* Substitute values */
){
  int i;
  if( pList==0 ) return;
  for(i=0; i<pList->nExpr; i++){
    pList->a[i].pExpr = substExpr(db, pList->a[i].pExpr, iTable, pEList);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
testq %rsi, %rsi
je 0x56240
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x56240
movq %rcx, %r14
movl %edx, %r12d
movq %rdi, %r15
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
xorl %r13d, %r13d
xorl %ebx, %ebx
movq (%rsi,%r13), %rsi
movq %r15, %rdi
movl %r12d, %edx
movq %r14, %rcx
callq 0x5624f
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq %rax, (%rsi,%r13)
incq %rbx
movslq (%rcx), %rax
addq $0x20, %r13
cmpq %rax, %rbx
jl 0x56213
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: substExpr
static Expr *substExpr(
  sqlite3 *db,        /* Report malloc errors to this connection */
  Expr *pExpr,        /* Expr in which substitution occurs */
  int iTable,         /* Table to be substituted */
  ExprList *pEList    /* Substitute expressions */
){
  if( pExpr==0 ) return 0;
  if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
    if( pExpr->iColumn<0 ){
      pExpr->op = TK_NULL;
    }else{
      Expr *pNew;
      assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
      assert( pExpr->pLeft==0 && pExpr->pRight==0 );
      pNew = sqlite3ExprDup(db, pEList->a[pExpr->iColumn].pExpr, 0);
      sqlite3ExprDelete(db, pExpr);
      pExpr = pNew;
    }
  }else{
    pExpr->pLeft = substExpr(db, pExpr->pLeft, iTable, pEList);
    pExpr->pRight = substExpr(db, pExpr->pRight, iTable, pEList);
    if( ExprHasProperty(pExpr, EP_xIsSelect) ){
      substSelect(db, pExpr->x.pSelect, iTable, pEList);
    }else{
      substExprList(db, pExpr->x.pList, iTable, pEList);
    }
  }
  return pExpr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x562f9
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
cmpb $-0x68, (%rsi)
jne 0x562b3
cmpl %r12d, 0x2c(%rbx)
jne 0x562b3
movswq 0x30(%rbx), %rax
testq %rax, %rax
js 0x5630e
movq 0x8(%r15), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4848c
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3479d
movq %r15, %rax
jmp 0x56305
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl %r12d, %edx
movq %r15, %rcx
callq 0x5624f
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rsi
movq %r14, %rdi
movl %r12d, %edx
movq %r15, %rcx
callq 0x5624f
movq %rax, 0x18(%rbx)
testb $0x8, 0x3(%rbx)
movq 0x20(%rbx), %rsi
movq %r14, %rdi
movl %r12d, %edx
movq %r15, %rcx
jne 0x562fd
callq 0x561dd
jmp 0x56302
xorl %ebx, %ebx
jmp 0x56302
callq 0x56313
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x62, (%rbx)
jmp 0x56302
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: substSelect
static void substSelect(
  sqlite3 *db,         /* Report malloc errors here */
  Select *p,           /* SELECT statement in which to make substitutions */
  int iTable,          /* Table to be replaced */
  ExprList *pEList     /* Substitute values */
){
  SrcList *pSrc;
  struct SrcList_item *pItem;
  int i;
  if( !p ) return;
  substExprList(db, p->pEList, iTable, pEList);
  substExprList(db, p->pGroupBy, iTable, pEList);
  substExprList(db, p->pOrderBy, iTable, pEList);
  p->pHaving = substExpr(db, p->pHaving, iTable, pEList);
  p->pWhere = substExpr(db, p->pWhere, iTable, pEList);
  substSelect(db, p->pPrior, iTable, pEList);
  pSrc = p->pSrc;
  assert( pSrc );  /* Even for (SELECT 1) we have: pSrc!=0 but pSrc->nSrc==0 */
  if( ALWAYS(pSrc) ){
    for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
      substSelect(db, pItem->pSelect, iTable, pEList);
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0x563ef
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %rsi
callq 0x561dd
movq 0x38(%r12), %rsi
movq %r15, %rdi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x561dd
movq 0x48(%r12), %rsi
movq %r15, %rdi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x561dd
movq 0x40(%r12), %rsi
movq %r15, %rdi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x5624f
movq %rax, 0x40(%r12)
movq 0x30(%r12), %rsi
movq %r15, %rdi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x5624f
movq %rax, 0x30(%r12)
movq 0x50(%r12), %rsi
movq %r15, %rdi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x56313
movq 0x28(%r12), %r12
testq %r12, %r12
je 0x563e1
movzbl (%r12), %r13d
testl %r13d, %r13d
je 0x563e1
incl %r13d
addq $0x30, %r12
movq (%r12), %rsi
movq %r15, %rdi
movl %r14d, %edx
movq %rbx, %rcx
callq 0x56313
decl %r13d
addq $0x68, %r12
cmpl $0x1, %r13d
ja 0x563c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: explainComposite
static void explainComposite(
  Parse *pParse,                  /* Parse context */
  int op,                         /* One of TK_UNION, TK_EXCEPT etc. */
  int iSub1,                      /* Subquery id 1 */
  int iSub2,                      /* Subquery id 2 */
  int bUseTmp                     /* True if a temp table was used */
){
  assert( op==TK_UNION || op==TK_EXCEPT || op==TK_INTERSECT || op==TK_ALL );
  if( pParse->explain==2 ){
    Vdbe *v = pParse->pVdbe;
    char *zMsg = sqlite3MPrintf(
        pParse->db, "COMPOUND SUBQUERIES %d AND %d %s(%s)", iSub1, iSub2,
        bUseTmp?"USING TEMP B-TREE ":"", selectOpName(op)
    );
    sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
  }
}

// Assembly:
cmpb $0x2, 0x200(%rdi)
jne 0x56439
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x10(%r14), %rbx
testl %r8d, %r8d
leaq 0x27f99(%rip), %rax     # 0x7e3b0
leaq 0x25669(%rip), %r8      # 0x7ba87
cmoveq %rax, %r8
addl $-0x71, %esi
cmpl $0x2, %esi
ja 0x5643a
movl %esi, %eax
leaq 0x3d4c5(%rip), %rsi     # 0x938f8
movq (%rsi,%rax,8), %r9
jmp 0x56441
retq
leaq 0x2561b(%rip), %r9      # 0x7ba5c
leaq 0x2561a(%rip), %rsi     # 0x7ba62
xorl %eax, %eax
callq 0x11900
movq %rax, %r15
movl 0x210(%r14), %edx
movq %rbx, %rdi
movl $0x96, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45f15
movq %rbx, %rdi
movl %eax, %esi
movq %r15, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11a9f
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: multiSelectCollSeq
static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
  CollSeq *pRet;
  if( p->pPrior ){
    pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
  }else{
    pRet = 0;
  }
  assert( iCol>=0 );
  if( pRet==0 && iCol<p->pEList->nExpr ){
    pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
  }
  return pRet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x50(%rsi), %rsi
testq %rsi, %rsi
je 0x564b3
movq %rbx, %rdi
movl %r14d, %edx
callq 0x56487
testq %rax, %rax
jne 0x564de
movq (%r15), %rax
cmpl %r14d, (%rax)
jle 0x564dc
movq 0x8(%rax), %rax
movslq %r14d, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4b225
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: codeOffset
static void codeOffset(
  Vdbe *v,          /* Generate code into this VM */
  Select *p,        /* The SELECT statement being coded */
  int iContinue     /* Jump here to skip the current record */
){
  if( p->iOffset && iContinue!=0 ){
    int addr;
    sqlite3VdbeAddOp2(v, OP_AddImm, p->iOffset, -1);
    addr = sqlite3VdbeAddOp1(v, OP_IfNeg, p->iOffset);
    sqlite3VdbeAddOp2(v, OP_Goto, 0, iContinue);
    VdbeComment((v, "skip OFFSET records"));
    sqlite3VdbeJumpHere(v, addr);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl 0x10(%rsi), %edx
testl %edx, %edx
sete %al
testl %r14d, %r14d
sete %cl
orb %al, %cl
jne 0x56a27
movq %rsi, %r15
movq %rdi, %rbx
movl $0x20, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
callq 0x45f15
movl 0x10(%r15), %edx
movq %rbx, %rdi
movl $0x7f, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45f15
movl %eax, %r15d
movq %rbx, %rdi
movl $0xe, %esi
xorl %edx, %edx
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x45f15
testl %r15d, %r15d
js 0x56a27
movl 0x34(%rbx), %eax
cmpl %r15d, %eax
jbe 0x56a27
movq 0x8(%rbx), %rcx
movl %r15d, %edx
leaq (%rdx,%rdx,2), %rdx
movl %eax, 0x8(%rcx,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: whereSplit
static void whereSplit(WhereClause *pWC, Expr *pExpr, u8 op){
  pWC->op = op;
  if( pExpr==0 ) return;
  if( pExpr->op!=op ){
    whereClauseInsert(pWC, pExpr, 0);
  }else{
    whereSplit(pWC, pExpr->pLeft, op);
    whereSplit(pWC, pExpr->pRight, op);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movb %r14b, 0x10(%rdi)
testq %rsi, %rsi
je 0x56a74
movq %rsi, %rbx
movq %rdi, %r15
movzbl %r14b, %r12d
cmpb %r14b, (%rbx)
jne 0x56a7d
movq 0x10(%rbx), %rsi
movq %r15, %rdi
movl %r12d, %edx
callq 0x56a32
movq 0x18(%rbx), %rbx
movb %r14b, 0x10(%r15)
testq %rbx, %rbx
jne 0x56a53
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x57b6d
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: exprListTableUsage
static Bitmask exprListTableUsage(WhereMaskSet *pMaskSet, ExprList *pList){
  int i;
  Bitmask mask = 0;
  if( pList ){
    for(i=0; i<pList->nExpr; i++){
      mask |= exprTableUsage(pMaskSet, pList->a[i].pExpr);
    }
  }
  return mask;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x5704d
movslq (%rsi), %r15
testq %r15, %r15
jle 0x5704d
movq %rdi, %rbx
movq 0x8(%rsi), %r12
shlq $0x5, %r15
xorl %r13d, %r13d
xorl %r14d, %r14d
movq (%r12,%r13), %rsi
movq %rbx, %rdi
callq 0x58edf
orq %rax, %r14
addq $0x20, %r13
cmpq %r13, %r15
jne 0x57033
jmp 0x57050
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: whereInfoFree
static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){
  if( ALWAYS(pWInfo) ){
    whereClauseClear(&pWInfo->sWC);
    while( pWInfo->pLoops ){
      WhereLoop *p = pWInfo->pLoops;
      pWInfo->pLoops = p->pNextLoop;
      whereLoopDelete(db, p);
    }
    sqlite3DbFree(db, pWInfo);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x150(%rsi), %rdi
callq 0x5b755
movq 0x20(%rbx), %r15
testq %r15, %r15
je 0x57a0f
movq 0x38(%r15), %rax
movq %rax, 0x20(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5a05c
movq %r14, %rdi
movq %r15, %rsi
callq 0x9ca4
jmp 0x579e6
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9ca4
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: evalConstExpr
static int evalConstExpr(Walker *pWalker, Expr *pExpr){
  Parse *pParse = pWalker->pParse;
  switch( pExpr->op ){
    case TK_IN:
    case TK_REGISTER: {
      return WRC_Prune;
    }
    case TK_COLLATE: {
      return WRC_Continue;
    }
    case TK_FUNCTION:
    case TK_AGG_FUNCTION:
    case TK_CONST_FUNC: {
      /* The arguments to a function have a fixed destination.
      ** Mark them this way to avoid generated unneeded OP_SCopy
      ** instructions. 
      */
      ExprList *pList = pExpr->x.pList;
      assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
      if( pList ){
        int i = pList->nExpr;
        struct ExprList_item *pItem = pList->a;
        for(; i>0; i--, pItem++){
          if( ALWAYS(pItem->pExpr) ) pItem->pExpr->flags |= EP_FixedDest;
        }
      }
      break;
    }
  }
  if( isAppropriateForFactoring(pExpr) ){
    int r1 = ++pParse->nMem;
    int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
    /* If r2!=r1, it means that register r1 is never used.  That is harmless
    ** but suboptimal, so we want to know about the situation to fix it.
    ** Hence the following assert: */
    assert( r2==r1 );
    pExpr->op2 = pExpr->op;
    pExpr->op = TK_REGISTER;
    pExpr->iTable = r2;
    return WRC_Prune;
  }
  return WRC_Continue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movzbl (%rsi), %ecx
movl $0x1, %eax
cmpl $0x96, %ecx
jg 0x57a68
cmpl $0x48, %ecx
je 0x57b62
cmpl $0x5c, %ecx
je 0x57b60
cmpl $0x84, %ecx
je 0x57b62
jmp 0x57aac
cmpl $0x97, %ecx
je 0x57a80
cmpl $0x99, %ecx
je 0x57a80
cmpl $0x9b, %ecx
jne 0x57aac
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x57aac
movl (%rcx), %eax
testl %eax, %eax
jle 0x57aac
movq 0x8(%rcx), %rcx
incl %eax
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x57aa1
orb $0x2, 0x3(%rdx)
addq $0x20, %rcx
decl %eax
cmpl $0x1, %eax
jg 0x57a95
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r15
movups %xmm0, 0x10(%r15)
movq $0x0, 0x20(%r15)
movl $0x3, 0x20(%r15)
leaq -0xbf1a(%rip), %rax     # 0x4bbb5
movq %rax, (%r15)
leaq -0xbee2(%rip), %rax     # 0x4bbf7
movq %rax, 0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x473bb
xorl %eax, %eax
cmpl $0x0, 0x20(%r15)
je 0x57b62
testb $0x2, 0x3(%rbx)
jne 0x57b1e
movl 0x58(%r14), %edx
incl %edx
movl %edx, 0x58(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d33b
movb (%rbx), %cl
movb %cl, 0x37(%rbx)
movb $-0x7c, (%rbx)
movl %eax, 0x2c(%rbx)
movl $0x1, %eax
jmp 0x57b62
movq %rbx, %rcx
movzbl (%rcx), %edx
cmpl $0x9d, %edx
jne 0x57b32
movq 0x10(%rcx), %rcx
jmp 0x57b21
addl $-0x5e, %edx
cmpl $0x3e, %edx
ja 0x57af7
movabsq $0xb800000011, %rsi     # imm = 0xB800000011
btq %rdx, %rsi
jb 0x57b62
cmpq $0x3e, %rdx
jne 0x57af7
movq 0x10(%rcx), %rcx
movb (%rcx), %cl
addb $0x7f, %cl
cmpb $0x2, %cl
jae 0x57af7
jmp 0x57b62
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: whereClauseInsert
static int whereClauseInsert(WhereClause *pWC, Expr *p, u8 wtFlags){
  WhereTerm *pTerm;
  int idx;
  testcase( wtFlags & TERM_VIRTUAL );
  if( pWC->nTerm>=pWC->nSlot ){
    WhereTerm *pOld = pWC->a;
    sqlite3 *db = pWC->pWInfo->pParse->db;
    pWC->a = sqlite3DbMallocRaw(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
    if( pWC->a==0 ){
      if( wtFlags & TERM_DYNAMIC ){
        sqlite3ExprDelete(db, p);
      }
      pWC->a = pOld;
      return 0;
    }
    memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
    if( pOld!=pWC->aStatic ){
      sqlite3DbFree(db, pOld);
    }
    pWC->nSlot = sqlite3DbMallocSize(db, pWC->a)/sizeof(pWC->a[0]);
  }
  pTerm = &pWC->a[idx = pWC->nTerm++];
  pTerm->pExpr = sqlite3ExprSkipCollate(p);
  pTerm->wtFlags = wtFlags;
  pTerm->pWC = pWC;
  pTerm->iParent = -1;
  return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl 0x14(%rdi), %eax
movl 0x18(%rdi), %ecx
cmpl %ecx, %eax
jl 0x57c30
movq (%rbx), %rax
movq 0x20(%rbx), %r13
movq (%rax), %rax
movq (%rax), %r12
imull $0x70, %ecx, %esi
movq %r12, %rdi
callq 0x11721
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x57c7e
movslq 0x14(%rbx), %rcx
imulq $0x38, %rcx, %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x82f0
leaq 0x28(%rbx), %rax
cmpq %rax, %r13
je 0x57bde
movq %r12, %rdi
movq %r13, %rsi
callq 0x9ca4
movq 0x20(%rbx), %rdi
testq %r12, %r12
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x57c11
cmpq %rdi, 0x170(%r12)
ja 0x57c11
cmpq %rdi, 0x178(%r12)
jbe 0x57c11
movzwl 0x150(%r12), %eax
jmp 0x57c17
callq *0x3c821(%rip)          # 0x94438
cltq
shrq $0x3, %rax
movabsq $0x2492492492492493, %rcx # imm = 0x2492492492492493
mulq %rcx
movl %edx, 0x18(%rbx)
movl 0x14(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
movslq %eax, %rcx
imulq $0x38, %rcx, %rcx
addq 0x20(%rbx), %rcx
testq %r14, %r14
je 0x57c5a
movzbl (%r14), %edx
cmpl $0x5c, %edx
je 0x57c54
cmpl $0x18, %edx
jne 0x57c5d
movq 0x10(%r14), %r14
jmp 0x57c41
xorl %r14d, %r14d
movq %r14, (%rcx)
movb %r15b, 0x1a(%rcx)
movq %rbx, 0x20(%rcx)
movl $0xffffffff, 0x8(%rcx)  # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, %r15b
je 0x57c8f
movq %r12, %rdi
movq %r14, %rsi
callq 0x3479d
movq %r13, 0x20(%rbx)
xorl %eax, %eax
jmp 0x57c6f
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: exprTableUsage
static Bitmask exprTableUsage(WhereMaskSet *pMaskSet, Expr *p){
  Bitmask mask = 0;
  if( p==0 ) return 0;
  if( p->op==TK_COLUMN ){
    mask = getMask(pMaskSet, p->iTable);
    return mask;
  }
  mask = exprTableUsage(pMaskSet, p->pRight);
  mask |= exprTableUsage(pMaskSet, p->pLeft);
  if( ExprHasProperty(p, EP_xIsSelect) ){
    mask |= exprSelectTableUsage(pMaskSet, p->x.pSelect);
  }else{
    mask |= exprListTableUsage(pMaskSet, p->x.pList);
  }
  return mask;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x58f1b
movq %rsi, %r15
movq %rdi, %r14
cmpb $-0x68, (%rsi)
jne 0x58f1f
movslq (%r14), %rax
testq %rax, %rax
jle 0x58f1b
movl 0x2c(%r15), %edx
xorl %ebx, %ebx
xorl %ecx, %ecx
cmpl %edx, 0x4(%r14,%rcx,4)
je 0x58f5f
incq %rcx
cmpq %rcx, %rax
jne 0x58f0a
jmp 0x58f67
xorl %ebx, %ebx
jmp 0x58f67
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x58edf
movq %rax, %r12
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x58edf
movq %rax, %rbx
orq %r12, %rbx
testb $0x8, 0x3(%r15)
movq 0x20(%r15), %rsi
movq %r14, %rdi
jne 0x58f55
callq 0x57007
jmp 0x58f5a
callq 0x58f73
orq %rax, %rbx
jmp 0x58f67
movl $0x1, %ebx
shlq %cl, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: exprSelectTableUsage
static Bitmask exprSelectTableUsage(WhereMaskSet *pMaskSet, Select *pS){
  Bitmask mask = 0;
  while( pS ){
    SrcList *pSrc = pS->pSrc;
    mask |= exprListTableUsage(pMaskSet, pS->pEList);
    mask |= exprListTableUsage(pMaskSet, pS->pGroupBy);
    mask |= exprListTableUsage(pMaskSet, pS->pOrderBy);
    mask |= exprTableUsage(pMaskSet, pS->pWhere);
    mask |= exprTableUsage(pMaskSet, pS->pHaving);
    if( ALWAYS(pSrc!=0) ){
      int i;
      for(i=0; i<pSrc->nSrc; i++){
        mask |= exprSelectTableUsage(pMaskSet, pSrc->a[i].pSelect);
        mask |= exprTableUsage(pMaskSet, pSrc->a[i].pOn);
      }
    }
    pS = pS->pPrior;
  }
  return mask;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x5906f
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
movq %rdi, -0x30(%rbp)
movq (%r14), %rsi
movq 0x28(%r14), %rbx
movq %r12, %rdi
callq 0x57007
movq %rax, -0x38(%rbp)
movq 0x38(%r14), %rsi
movq %r12, %rdi
callq 0x57007
movq %rax, -0x48(%rbp)
movq 0x48(%r14), %rsi
movq %r12, %rdi
callq 0x57007
movq %rax, %r13
movq 0x30(%r14), %rsi
movq %r12, %rdi
callq 0x58edf
movq %rax, -0x40(%rbp)
movq 0x40(%r14), %rsi
movq %r12, %rdi
callq 0x58edf
movq %rax, %r12
movq -0x38(%rbp), %rax
orq %r15, %rax
orq -0x48(%rbp), %r13
orq %rax, %r13
orq -0x40(%rbp), %r12
orq %r13, %r12
testq %rbx, %rbx
movq %r14, -0x50(%rbp)
je 0x59052
movzbl (%rbx), %eax
testq %rax, %rax
je 0x59052
imulq $0x68, %rax, %rax
movq %rax, -0x38(%rbp)
xorl %r14d, %r14d
movq -0x30(%rbp), %r13
movq 0x30(%rbx,%r14), %rsi
movq %r13, %rdi
callq 0x58f73
movq %rax, %r15
movq 0x48(%rbx,%r14), %rsi
movq %r13, %rdi
callq 0x58edf
orq %r12, %r15
orq %rax, %r15
addq $0x68, %r14
movq %r15, %r12
cmpq %r14, -0x38(%rbp)
jne 0x59020
jmp 0x59059
movq %r12, %r15
movq -0x30(%rbp), %r13
movq -0x50(%rbp), %r14
movq 0x50(%r14), %r14
testq %r14, %r14
movq %r13, %r12
jne 0x58f9a
jmp 0x59072
xorl %r15d, %r15d
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeGetBoundValue
SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff){
  assert( iVar>0 );
  if( v ){
    Mem *pMem = &v->aVar[iVar-1];
    if( 0==(pMem->flags & MEM_Null) ){
      sqlite3_value *pRet = sqlite3ValueNew(v->db);
      if( pRet ){
        sqlite3VdbeMemCopy((Mem *)pRet, pMem);
        sqlite3ValueApplyAffinity(pRet, aff, SQLITE_UTF8);
        sqlite3VdbeMemStoreType((Mem *)pRet);
      }
      return pRet;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x590f5
movq 0x78(%rdi), %r15
movslq %esi, %rax
imulq $0x38, %rax, %r12
testb $0x1, -0x14(%r15,%r12)
jne 0x590f5
movq (%rdi), %r14
movq %r14, %rdi
movl $0x38, %esi
callq 0x11721
testq %rax, %rax
je 0x590f5
movq %rax, %rbx
leaq (%r15,%r12), %rsi
addq $-0x38, %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x8(%rax)
movw $0x1, 0x24(%rax)
movb $0x5, 0x26(%rax)
movq %r14, (%rax)
movq %rax, %rdi
callq 0xf417
movq %rbx, %rdi
callq 0x110b5
jmp 0x590f7
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: findTerm
static WhereTerm *findTerm(
  WhereClause *pWC,     /* The WHERE clause to be searched */
  int iCur,             /* Cursor number of LHS */
  int iColumn,          /* Column number of LHS */
  Bitmask notReady,     /* RHS must not overlap with this mask */
  u32 op,               /* Mask of WO_xx values describing operator */
  Index *pIdx           /* Must be compatible with this index, if not NULL */
){
  WhereTerm *pResult = 0;
  WhereTerm *p;
  WhereScan scan;

  p = whereScanInit(&scan, pWC, iCur, iColumn, op, pIdx);
  while( p ){
    if( (p->prereqRight & notReady)==0 ){
      if( p->prereqRight==0 && (p->eOperator&WO_EQ)!=0 ){
        return p;
      }
      if( pResult==0 ) pResult = p;
    }
    p = whereScanNext(&scan);
  }
  return pResult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %rsi
leaq -0x98(%rbp), %rdi
callq 0x59176
xorl %r14d, %r14d
testq %rax, %rax
je 0x59160
leaq -0x98(%rbp), %r15
movq 0x28(%rax), %rcx
testq %rbx, %rcx
jne 0x59153
testq %rcx, %rcx
jne 0x5914c
testb $0x2, 0x18(%rax)
jne 0x59171
testq %r14, %r14
cmoveq %rax, %r14
movq %r15, %rdi
callq 0x59205
testq %rax, %rax
jne 0x59138
movq %r14, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x59160
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: whereScanInit
static WhereTerm *whereScanInit(
  WhereScan *pScan,       /* The WhereScan object being initialized */
  WhereClause *pWC,       /* The WHERE clause to be scanned */
  int iCur,               /* Cursor to scan for */
  int iColumn,            /* Column to scan for */
  u32 opMask,             /* Operator(s) to scan for */
  Index *pIdx             /* Must be compatible with this index */
){
  int j;

  /* memset(pScan, 0, sizeof(*pScan)); */
  pScan->pOrigWC = pWC;
  pScan->pWC = pWC;
  if( pIdx && iColumn>=0 ){
    pScan->idxaff = pIdx->pTable->aCol[iColumn].affinity;
    for(j=0; pIdx->aiColumn[j]!=iColumn; j++){
      if( NEVER(j>=pIdx->nColumn) ) return 0;
    }
    pScan->zCollName = pIdx->azColl[j];
  }else{
    pScan->idxaff = 0;
    pScan->zCollName = 0;
  }
  pScan->opMask = opMask;
  pScan->k = 0;
  pScan->aEquiv[0] = iCur;
  pScan->aEquiv[1] = iColumn;
  pScan->nEquiv = 2;
  pScan->iEquiv = 2;
  return whereScanNext(pScan);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, (%rdi)
movq %rsi, 0x8(%rdi)
testq %r9, %r9
sete %al
testl %ecx, %ecx
sets %sil
orb %al, %sil
jne 0x591b8
movq 0x18(%r9), %rax
movq 0x8(%rax), %rax
movl %ecx, %esi
leaq (%rsi,%rsi,2), %rsi
shlq $0x4, %rsi
movb 0x29(%rax,%rsi), %al
movb %al, 0x18(%rdi)
movq 0x8(%r9), %rax
cmpl %ecx, (%rax)
jne 0x591c0
xorl %r11d, %r11d
jmp 0x591db
movb $0x0, 0x18(%rdi)
xorl %eax, %eax
jmp 0x591e3
movzwl 0x54(%r9), %esi
xorl %r10d, %r10d
cmpq %r10, %rsi
je 0x59201
leaq 0x1(%r10), %r11
cmpl %ecx, 0x4(%rax,%r10,4)
movq %r11, %r10
jne 0x591c8
movq 0x40(%r9), %rax
movq (%rax,%r11,8), %rax
movq %rax, 0x10(%rdi)
movl %r8d, 0x1c(%rdi)
movl $0x0, 0x20(%rdi)
movl %edx, 0x24(%rdi)
movl %ecx, 0x28(%rdi)
movw $0x202, 0x19(%rdi)      # imm = 0x202
popq %rbp
jmp 0x59205
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: whereLoopResize
static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){
  WhereTerm **paNew;
  if( p->nLSlot>=n ) return SQLITE_OK;
  n = (n+7)&~7;
  paNew = sqlite3DbMallocRaw(db, sizeof(p->aLTerm[0])*n);
  if( paNew==0 ) return SQLITE_NOMEM;
  memcpy(paNew, p->aLTerm, sizeof(p->aLTerm[0])*p->nLSlot);
  if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFree(db, p->aLTerm);
  p->aLTerm = paNew;
  p->nLSlot = n;
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzwl 0x2e(%rsi), %eax
xorl %ebx, %ebx
cmpl %edx, %eax
jge 0x5a120
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
addl $0x7, %r14d
andl $-0x8, %r14d
leal (,%r14,8), %esi
callq 0x11721
testq %rax, %rax
je 0x5a11b
movq %rax, %r13
movq 0x30(%r15), %rsi
movzwl 0x2e(%r15), %edx
shll $0x3, %edx
movq %rax, %rdi
callq 0x82f0
movq 0x30(%r15), %rsi
leaq 0x40(%r15), %rax
cmpq %rax, %rsi
je 0x5a110
movq %r12, %rdi
callq 0x9ca4
movq %r13, 0x30(%r15)
movw %r14w, 0x2e(%r15)
jmp 0x5a120
movl $0x7, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: whereCost
static WhereCost whereCost(tRowcnt x){
  static WhereCost a[] = { 0, 2, 3, 5, 6, 7, 8, 9 };
  WhereCost y = 40;
  if( x<8 ){
    if( x<2 ) return 0;
    while( x<8 ){  y -= 10; x <<= 1; }
  }else{
    while( x>255 ){ y += 40; x >>= 4; }
    while( x>15 ){  y += 10; x >>= 1; }
  }
  return a[x&7] + y - 10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x8, %edi
jae 0x5a328
cmpl $0x2, %edi
jae 0x5a34c
xorl %eax, %eax
jmp 0x5a389
movw $0x28, %ax
cmpl $0x100, %edi            # imm = 0x100
jb 0x5a35f
movw $0x28, %ax
movl %edi, %ecx
addl $0x28, %eax
shrl $0x4, %ecx
cmpl $0xfff, %edi            # imm = 0xFFF
movl %ecx, %edi
ja 0x5a33a
jmp 0x5a361
movw $0x28, %ax
addl $-0xa, %eax
leal (%rdi,%rdi), %edx
cmpl $0x4, %edi
movl %edx, %edi
jb 0x5a350
jmp 0x5a378
movl %edi, %ecx
cmpl $0x10, %ecx
jb 0x5a376
movl %ecx, %edx
addl $0xa, %eax
shrl %edx
cmpl $0x1f, %ecx
movl %edx, %ecx
ja 0x5a368
jmp 0x5a378
movl %ecx, %edx
andl $0x7, %edx
leaq 0x1f07e(%rip), %rcx     # 0x79400
addw (%rcx,%rdx,2), %ax
addl $-0xa, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: whereOrInsert
static int whereOrInsert(
  WhereOrSet *pSet,      /* The WhereOrSet to be updated */
  Bitmask prereq,        /* Prerequisites of the new entry */
  WhereCost rRun,        /* Run-cost of the new entry */
  WhereCost nOut         /* Number of outputs for the new entry */
){
  u16 i;
  WhereOrCost *p;
  for(i=pSet->n, p=pSet->a; i>0; i--, p++){
    if( rRun<=p->rRun && (prereq & p->prereq)==prereq ){
      goto whereOrInsert_done;
    }
    if( p->rRun<=rRun && (p->prereq & prereq)==p->prereq ){
      return 0;
    }
  }
  if( pSet->n<N_OR_COST ){
    p = &pSet->a[pSet->n++];
    p->nOut = nOut;
  }else{
    p = pSet->a;
    for(i=1; i<pSet->n; i++){
      if( p->rRun>pSet->a[i].rRun ) p = pSet->a + i;
    }
    if( p->rRun<=rRun ) return 0;
  }
whereOrInsert_done:
  p->prereq = prereq;
  p->rRun = rRun;
  if( p->nOut>nOut ) p->nOut = nOut;
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movzwl (%rdi), %eax
leaq 0x8(%rdi), %r8
testq %rax, %rax
je 0x5a3d9
movq %rsi, %r10
notq %r10
movq %r8, %r9
movl %eax, %r11d
movzwl 0x8(%r9), %ebx
cmpw %dx, %bx
jb 0x5a3bf
movq (%r9), %r14
notq %r14
testq %r14, %rsi
je 0x5a3ee
cmpw %dx, %bx
ja 0x5a3c9
testq %r10, (%r9)
je 0x5a402
addq $0x10, %r9
decw %r11w
jne 0x5a3aa
cmpw $0x3, %ax
jae 0x5a407
leal 0x1(%rax), %r9d
movw %r9w, (%rdi)
shll $0x4, %eax
leaq (%r8,%rax), %r9
movw %cx, 0xa(%r8,%rax)
movq %rsi, (%r9)
movw %dx, 0x8(%r9)
cmpw %cx, 0xa(%r9)
jbe 0x5a402
movw %cx, 0xa(%r9)
popq %rbx
popq %r14
popq %rbp
retq
addq $0x18, %rdi
decq %rax
movzwl 0x8(%r8), %r10d
movq %rdi, %r9
cmpw 0x8(%rdi), %r10w
ja 0x5a420
movq %r8, %r9
addq $0x10, %rdi
movq %r9, %r8
decq %rax
jne 0x5a40e
cmpw %dx, 0x8(%r9)
ja 0x5a3ee
jmp 0x5a402
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: whereLoopClearUnion
static void whereLoopClearUnion(sqlite3 *db, WhereLoop *p){
  if( p->wsFlags & (WHERE_VIRTUALTABLE|WHERE_AUTO_INDEX) ){
    if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){
      sqlite3_free(p->u.vtab.idxStr);
      p->u.vtab.needFree = 0;
      p->u.vtab.idxStr = 0;
    }else if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 && p->u.btree.pIndex!=0 ){
      sqlite3DbFree(db, p->u.btree.pIndex->zColAff);
      sqlite3DbFree(db, p->u.btree.pIndex);
      p->u.btree.pIndex = 0;
    }
  }
}

// Assembly:
movl 0x28(%rsi), %eax
testl $0x4400, %eax           # imm = 0x4400
je 0x5a4a3
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
btl $0xa, %eax
jae 0x5a46b
cmpb $0x0, 0x1c(%rbx)
je 0x5a46b
leaq 0x20(%rbx), %r14
movq 0x20(%rbx), %rdi
callq 0xa3c7
movb $0x0, 0x1c(%rbx)
jmp 0x5a498
btl $0xe, %eax
jae 0x5a49f
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x5a49f
addq $0x20, %rbx
movq 0x20(%rax), %rsi
movq %r14, %rdi
callq 0x9ca4
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x9ca4
movq %rbx, %r14
movq $0x0, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: termCanDriveIndex
static int termCanDriveIndex(
  WhereTerm *pTerm,              /* WHERE clause term to check */
  struct SrcList_item *pSrc,     /* Table we are trying to access */
  Bitmask notReady               /* Tables in outer loops of the join */
){
  char aff;
  if( pTerm->leftCursor!=pSrc->iCursor ) return 0;
  if( (pTerm->eOperator & WO_EQ)==0 ) return 0;
  if( (pTerm->prereqRight & notReady)!=0 ) return 0;
  if( pTerm->u.leftColumn<0 ) return 0;
  aff = pSrc->pTab->aCol[pTerm->u.leftColumn].affinity;
  if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
  return 1;
}

// Assembly:
movl 0xc(%rdi), %ecx
xorl %eax, %eax
cmpl 0x3c(%rsi), %ecx
jne 0x5a4ba
testb $0x2, 0x18(%rdi)
je 0x5a4ba
testq %rdx, 0x28(%rdi)
je 0x5a4bb
retq
movslq 0x10(%rdi), %rcx
testq %rcx, %rcx
js 0x5a4ba
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x20(%rsi), %rax
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movb 0x29(%rax,%rcx), %bl
movq (%rdi), %rdi
callq 0x4f3c0
cmpb $0x62, %al
je 0x5a4fa
movzbl %al, %eax
cmpl $0x61, %eax
jne 0x5a4fe
cmpb $0x61, %bl
sete %al
jmp 0x5a504
movb $0x1, %al
jmp 0x5a504
cmpb $0x63, %bl
setge %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: whereCostAdd
static WhereCost whereCostAdd(WhereCost a, WhereCost b){
  static const unsigned char x[] = {
     10, 10,                         /* 0,1 */
      9, 9,                          /* 2,3 */
      8, 8,                          /* 4,5 */
      7, 7, 7,                       /* 6,7,8 */
      6, 6, 6,                       /* 9,10,11 */
      5, 5, 5,                       /* 12-14 */
      4, 4, 4, 4,                    /* 15-18 */
      3, 3, 3, 3, 3, 3,              /* 19-24 */
      2, 2, 2, 2, 2, 2, 2,           /* 25-31 */
  };
  if( a>=b ){
    if( a>b+49 ) return a;
    if( a>b+31 ) return a+1;
    return a+x[a-b];
  }else{
    if( b>a+49 ) return b;
    if( b>a+31 ) return b+1;
    return b+x[b-a];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
cmpw %si, %ax
jae 0x5a524
leal 0x31(%rax), %ecx
cmpl %esi, %ecx
jae 0x5a536
movl %esi, %eax
jmp 0x5a56c
leal 0x31(%rsi), %ecx
cmpl %eax, %ecx
jb 0x5a56c
leal 0x1f(%rsi), %ecx
cmpl %eax, %ecx
jae 0x5a542
incl %eax
jmp 0x5a56c
leal 0x1f(%rax), %ecx
cmpl %esi, %ecx
jae 0x5a558
leal 0x1(%rsi), %eax
jmp 0x5a56c
movl %eax, %ecx
subl %esi, %ecx
movslq %ecx, %rcx
leaq 0x22f90(%rip), %rdx     # 0x7d4e0
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
jmp 0x5a56c
movl %esi, %ecx
subl %eax, %ecx
movslq %ecx, %rax
leaq 0x22f7a(%rip), %rcx     # 0x7d4e0
movzbl (%rax,%rcx), %eax
addl %esi, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3ExprImpliesExpr
SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Expr *pE1, Expr *pE2, int iTab){
  if( sqlite3ExprCompare(pE1, pE2, iTab)==0 ){
    return 1;
  }
  if( pE2->op==TK_OR
   && (sqlite3ExprImpliesExpr(pE1, pE2->pLeft, iTab)
             || sqlite3ExprImpliesExpr(pE1, pE2->pRight, iTab) )
  ){
    return 1;
  }
  if( pE2->op==TK_NOTNULL
   && sqlite3ExprCompare(pE1->pLeft, pE2->pLeft, iTab)==0
   && (pE1->op!=TK_ISNULL && pE1->op!=TK_IS)
  ){
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
callq 0x4b798
movl $0x1, %ebx
testl %eax, %eax
je 0x5aaa3
movzbl (%r12), %eax
cmpl $0x44, %eax
jne 0x5aa75
movq 0x10(%r12), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x5aa20
testl %eax, %eax
jne 0x5aaa3
movq 0x18(%r12), %r12
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x4b798
jmp 0x5aa3e
xorl %ebx, %ebx
cmpl $0x4a, %eax
jne 0x5aaa3
movq 0x10(%r14), %rdi
movq 0x10(%r12), %rsi
movl %r15d, %edx
callq 0x4b798
testl %eax, %eax
jne 0x5aaa3
movb (%r14), %al
cmpb $0x49, %al
setne %cl
cmpb $0x46, %al
setne %al
andb %cl, %al
movzbl %al, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: explainAppendTerm
static void explainAppendTerm(
  StrAccum *pStr,             /* The text expression being built */
  int iTerm,                  /* Index of this term.  First is zero */
  const char *zColumn,        /* Name of the column */
  const char *zOp             /* Name of the operator */
){
  if( iTerm ) sqlite3StrAccumAppend(pStr, " AND ", 5);
  sqlite3StrAccumAppend(pStr, zColumn, -1);
  sqlite3StrAccumAppend(pStr, zOp, 1);
  sqlite3StrAccumAppend(pStr, "?", 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
testl %esi, %esi
je 0x5b1ae
leaq 0x20a7d(%rip), %rsi     # 0x7bc1e
movq %rbx, %rdi
movl $0x5, %edx
callq 0x172f3
movq %rbx, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x172f3
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x172f3
leaq 0x1e741(%rip), %rsi     # 0x79916
movq %rbx, %rdi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x172f3
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: disableTerm
static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
  if( pTerm
      && (pTerm->wtFlags & TERM_CODED)==0
      && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
  ){
    pTerm->wtFlags |= TERM_CODED;
    if( pTerm->iParent>=0 ){
      WhereTerm *pOther = &pTerm->pWC->a[pTerm->iParent];
      if( (--pOther->nChild)==0 ){
        disableTerm(pLevel, pOther);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x5b3fe
movb 0x1a(%rsi), %al
testb $0x4, %al
jne 0x5b3fe
cmpl $0x0, (%rdi)
je 0x5b3da
movq (%rsi), %rcx
testb $0x1, 0x2(%rcx)
je 0x5b3fe
orb $0x4, %al
movb %al, 0x1a(%rsi)
movslq 0x8(%rsi), %rax
testq %rax, %rax
js 0x5b3fe
movq 0x20(%rsi), %rcx
movq 0x20(%rcx), %rcx
imulq $0x38, %rax, %rax
leaq (%rcx,%rax), %rsi
decb 0x1b(%rcx,%rax)
je 0x5b3c0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3ExprNeedsNoAffinityChange
SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){
  u8 op;
  if( aff==SQLITE_AFF_NONE ) return 1;
  while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
  op = p->op;
  if( op==TK_REGISTER ) op = p->op2;
  switch( op ){
    case TK_INTEGER: {
      return aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC;
    }
    case TK_FLOAT: {
      return aff==SQLITE_AFF_REAL || aff==SQLITE_AFF_NUMERIC;
    }
    case TK_STRING: {
      return aff==SQLITE_AFF_TEXT;
    }
    case TK_BLOB: {
      return 1;
    }
    case TK_COLUMN: {
      assert( p->iTable>=0 );  /* p cannot be part of a CHECK constraint */
      return p->iColumn<0
          && (aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC);
    }
    default: {
      return 0;
    }
  }
}

// Assembly:
movb $0x1, %al
cmpb $0x62, %sil
je 0x5b693
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %cl
movzbl %cl, %edx
leal -0x9c(%rdx), %r8d
cmpl $0x2, %r8d
jae 0x5b61e
movq 0x10(%rdi), %rdi
jmp 0x5b606
cmpl $0x84, %edx
jne 0x5b629
movb 0x37(%rdi), %cl
movzbl %cl, %ecx
cmpl $0x81, %ecx
jle 0x5b663
cmpl $0x82, %ecx
je 0x5b67d
cmpl $0x83, %ecx
je 0x5b692
cmpl $0x98, %ecx
jne 0x5b690
cmpw $0x0, 0x30(%rdi)
sets %cl
addb $-0x63, %sil
cmpb $0x2, %sil
setb %al
andb %cl, %al
jmp 0x5b692
cmpl $0x5e, %ecx
je 0x5b687
cmpl $0x81, %ecx
jne 0x5b690
addb $-0x63, %sil
cmpb $0x2, %sil
setb %al
jmp 0x5b692
addb $-0x63, %sil
testb $-0x3, %sil
jmp 0x5b68b
cmpb $0x61, %sil
sete %al
jmp 0x5b692
xorl %eax, %eax
popq %rbp
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/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_NONE entries at the beginning
  ** and end of the affinity string.
  */
  while( n>0 && zAff[0]==SQLITE_AFF_NONE ){
    n--;
    base++;
    zAff++;
  }
  while( n>1 && zAff[n-1]==SQLITE_AFF_NONE ){
    n--;
  }

  /* Code the OP_Affinity opcode if there is anything left to do. */
  if( n>0 ){
    sqlite3VdbeAddOp2(v, OP_Affinity, base, n);
    sqlite3VdbeChangeP4(v, -1, zAff, n);
    sqlite3ExprCacheAffinityChange(pParse, base, n);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rcx, %rcx
je 0x5b746
movq %rdi, %rbx
testl %edx, %edx
jle 0x5b6d7
movl %edx, %r14d
addq %rcx, %r14
leal (%rdx,%rsi), %r15d
cmpb $0x62, (%rcx)
jne 0x5b6d7
leal -0x1(%rdx), %eax
incl %esi
incq %rcx
cmpl $0x1, %edx
movl %eax, %edx
jg 0x5b6bf
xorl %edx, %edx
jmp 0x5b6dd
movq %rcx, %r14
movl %esi, %r15d
movq 0x10(%rbx), %r13
movl %edx, %eax
movq %rax, %r12
cmpl $0x2, %r12d
jl 0x5b6fb
leaq -0x1(%r12), %rax
cmpb $0x62, -0x1(%r14,%r12)
je 0x5b6e3
jmp 0x5b701
cmpq $0x1, %r12
jne 0x5b746
movq %r13, %rdi
movl $0x2a, %esi
movl %r15d, %edx
movl %r12d, %ecx
xorl %r8d, %r8d
callq 0x45f15
movq %r13, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
movl %r12d, %ecx
callq 0x11a9f
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4e564
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq