LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3VdbeMemNumerify
SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
  if( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 ){
    int rc;
    assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
    assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
    rc = sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc);
    if( rc==0 ){
      MemSetTypeFlag(pMem, MEM_Int);
    }else{
      i64 i = pMem->u.i;
      sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
      if( rc==1 && sqlite3RealSameAsInt(pMem->u.r, i) ){
        pMem->u.i = i;
        MemSetTypeFlag(pMem, MEM_Int);
      }else{
        MemSetTypeFlag(pMem, MEM_Real);
      }
    }
  }
  assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 );
  pMem->flags &= ~(MEM_Str|MEM_Blob|MEM_Zero);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
testb $0xd, %al
jne 0x42ac8f
movq 0x10(%rbx), %rdi
movl 0xc(%rbx), %edx
movzbl 0xa(%rbx), %ecx
movq %rbx, %rsi
callq 0x420cca
movl %eax, %ebp
movw $0x4, %ax
testl %ebp, %ebp
je 0x42ac80
movq (%rbx), %r14
movq 0x10(%rbx), %rdi
movl 0xc(%rbx), %edx
movzbl 0xa(%rbx), %ecx
movq %rbx, %rsi
callq 0x4208d9
movw $0x8, %ax
cmpl $0x1, %ebp
jne 0x42ac80
cvtsi2sd %r14, %xmm0
movq %xmm0, %rcx
cmpq %rcx, (%rbx)
jne 0x42ac80
movq %r14, (%rbx)
movw $0x4, %ax
movzwl 0x8(%rbx), %ecx
andl $0x3e00, %ecx           # imm = 0x3E00
movzwl %ax, %eax
orl %ecx, %eax
andl $0xbfed, %eax           # imm = 0xBFED
movw %ax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: btreeMoveto
static int btreeMoveto(
  BtCursor *pCur,     /* Cursor open on the btree to be searched */
  const void *pKey,   /* Packed key if the btree is an index */
  i64 nKey,           /* Integer key for tables.  Size of pKey for indices */
  int bias,           /* Bias search to the high end */
  int *pRes           /* Write search results here */
){
  int rc;                    /* Status code */
  UnpackedRecord *pIdxKey;   /* Unpacked index key */

  if( pKey ){
    assert( nKey==(i64)(int)nKey );
    pIdxKey = sqlite3VdbeAllocUnpackedRecord(pCur->pKeyInfo);
    if( pIdxKey==0 ) return SQLITE_NOMEM_BKPT;
    sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
    if( pIdxKey->nField==0 ){
      rc = SQLITE_CORRUPT_BKPT;
      goto moveto_done;
    }
  }else{
    pIdxKey = 0;
  }
  rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
moveto_done:
  if( pIdxKey ){
    sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, %rbx
testq %rsi, %rsi
je 0x42af97
movq %rsi, %r13
movq 0x80(%rbx), %rdi
callq 0x4296c0
testq %rax, %rax
je 0x42afc9
movq %rax, %r14
movq 0x80(%rbx), %rdi
movl %r12d, %esi
movq %r13, %rdx
movq %rax, %rcx
callq 0x4296f8
cmpw $0x0, 0x10(%r14)
jne 0x42af9a
movl $0xf7e4, %edi           # imm = 0xF7E4
callq 0x418527
movl %eax, %ebp
jmp 0x42afb4
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movq %r15, %r8
callq 0x429138
movl %eax, %ebp
testq %r14, %r14
je 0x42afcc
movq 0x80(%rbx), %rax
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x412f53
jmp 0x42afcc
pushq $0x7
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: btreePrevious
static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){
  int rc;
  MemPage *pPage;

  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
  assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
  assert( pCur->info.nSize==0 );
  if( pCur->eState!=CURSOR_VALID ){
    rc = restoreCursorPosition(pCur);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    if( CURSOR_INVALID==pCur->eState ){
      return SQLITE_DONE;
    }
    if( pCur->skipNext ){
      assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_SKIPNEXT );
      pCur->eState = CURSOR_VALID;
      if( pCur->skipNext<0 ){
        pCur->skipNext = 0;
        return SQLITE_OK;
      }
      pCur->skipNext = 0;
    }
  }

  pPage = pCur->pPage;
  assert( pPage->isInit );
  if( !pPage->leaf ){
    int idx = pCur->ix;
    rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
    if( rc ) return rc;
    rc = moveToRightmost(pCur);
  }else{
    while( pCur->ix==0 ){
      if( pCur->iPage==0 ){
        pCur->eState = CURSOR_INVALID;
        return SQLITE_DONE;
      }
      moveToParent(pCur);
    }
    assert( pCur->info.nSize==0 );
    assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );

    pCur->ix--;
    pPage = pCur->pPage;
    if( pPage->intKey && !pPage->leaf ){
      rc = sqlite3BtreePrevious(pCur, 0);
    }else{
      rc = SQLITE_OK;
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %al
pushq $0x65
popq %rbp
testb %al, %al
je 0x42bbf4
cmpb $0x3, %al
jb 0x42bbd6
movq %rbx, %rdi
callq 0x42aee3
testl %eax, %eax
jne 0x42bc50
movb (%rbx), %al
cmpb $0x1, %al
je 0x42bc8f
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x42bbf4
movb $0x0, (%rbx)
andl $0x0, 0x4(%rbx)
testl %eax, %eax
js 0x42bc8d
movq 0x88(%rbx), %rax
cmpb $0x0, 0x8(%rax)
je 0x42bc1a
movzwl 0x56(%rbx), %eax
testw %ax, %ax
jne 0x42bc54
cmpb $0x0, 0x54(%rbx)
je 0x42bc7d
movq %rbx, %rdi
callq 0x42b218
jmp 0x42bc01
movzwl 0x56(%rbx), %ecx
movzwl 0x18(%rax), %edx
movq 0x60(%rax), %rsi
movzbl (%rsi,%rcx,2), %r8d
shll $0x8, %r8d
movzbl 0x1(%rsi,%rcx,2), %edi
orl %r8d, %edi
andl %edx, %edi
addq 0x50(%rax), %rdi
callq 0x415e33
movq %rbx, %rdi
movl %eax, %esi
callq 0x42b256
testl %eax, %eax
je 0x42bc82
movl %eax, %ebp
jmp 0x42bc8f
decl %eax
movw %ax, 0x56(%rbx)
movq 0x88(%rbx), %rax
xorl %ebp, %ebp
cmpb $0x0, 0x2(%rax)
je 0x42bc8f
cmpb $0x0, 0x8(%rax)
jne 0x42bc8f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x429687
movb $0x1, (%rbx)
jmp 0x42bc8f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x42bc98
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: btreeOverwriteContent
static int btreeOverwriteContent(
  MemPage *pPage,           /* MemPage on which writing will occur */
  u8 *pDest,                /* Pointer to the place to start writing */
  const BtreePayload *pX,   /* Source of data to write */
  int iOffset,              /* Offset of first byte to write */
  int iAmt                  /* Number of bytes to be written */
){
  int nData = pX->nData - iOffset;
  if( nData<=0 ){
    /* Overwritting with zeros */
    int i;
    for(i=0; i<iAmt && pDest[i]==0; i++){}
    if( i<iAmt ){
      int rc = sqlite3PagerWrite(pPage->pDbPage);
      if( rc ) return rc;
      memset(pDest + i, 0, iAmt - i);
    }
  }else{
    if( nData<iAmt ){
      /* Mixed read data and zeros at the end.  Make a recursive call
      ** to write the zeros then fall through to write the real data */
      int rc = btreeOverwriteContent(pPage, pDest+nData, pX, iOffset+nData,
                                 iAmt-nData);
      if( rc ) return rc;
      iAmt = nData;
    }
    if( memcmp(pDest, ((u8*)pX->pData) + iOffset, iAmt)!=0 ){
      int rc = sqlite3PagerWrite(pPage->pDbPage);
      if( rc ) return rc;
      memcpy(pDest, ((u8*)pX->pData) + iOffset, iAmt);
    }
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r15d
movl %ecx, %r13d
movq %rsi, %rbx
movl 0x24(%rdx), %ecx
movl %ecx, %ebp
subl %r13d, %ebp
jle 0x42ddfa
movq %rdx, %r12
movl %r15d, %r8d
subl %ebp, %r8d
jle 0x42ddb0
movl %ebp, %esi
addq %rbx, %rsi
movq %rdi, %r14
movq %r12, %rdx
callq 0x42dd6d
movq %r14, %rdi
movl %ebp, %r15d
testl %eax, %eax
jne 0x42de2a
movq %rdi, (%rsp)
movslq %r13d, %r13
movq 0x10(%r12), %rsi
addq %r13, %rsi
movslq %r15d, %rbp
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x401028
xorl %r14d, %r14d
testl %eax, %eax
je 0x42de2d
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x408cc0
testl %eax, %eax
jne 0x42de2a
addq 0x10(%r12), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x401048
jmp 0x42de2d
xorl %r14d, %r14d
testl %r15d, %r15d
movl $0x0, %eax
cmovgl %r15d, %eax
xorl %r12d, %r12d
cmpq %r12, %rax
je 0x42de2d
cmpb $0x0, (%rbx,%r12)
jne 0x42de1d
incq %r12
jmp 0x42de0c
movq 0x70(%rdi), %rdi
callq 0x408cc0
testl %eax, %eax
je 0x42de3f
movl %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %r12, %rbx
movslq %r15d, %rdx
subq %r12, %rdx
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4010b8
jmp 0x42de2d
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: pageFindSlot
static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){
  const int hdr = pPg->hdrOffset;
  u8 * const aData = pPg->aData;
  int iAddr = hdr + 1;
  int pc = get2byte(&aData[iAddr]);
  int x;
  int usableSize = pPg->pBt->usableSize;
  int size;            /* Size of the free slot */

  assert( pc>0 );
  while( pc<=usableSize-4 ){
    /* EVIDENCE-OF: R-22710-53328 The third and fourth bytes of each
    ** freeblock form a big-endian integer which is the size of the freeblock
    ** in bytes, including the 4-byte header. */
    size = get2byte(&aData[pc+2]);
    if( (x = size - nByte)>=0 ){
      testcase( x==4 );
      testcase( x==3 );
      if( size+pc > usableSize ){
        *pRc = SQLITE_CORRUPT_PAGE(pPg);
        return 0;
      }else if( x<4 ){
        /* EVIDENCE-OF: R-11498-58022 In a well-formed b-tree page, the total
        ** number of bytes in fragments may not exceed 60. */
        if( aData[hdr+7]>57 ) return 0;

        /* Remove the slot from the free-list. Update the number of
        ** fragmented bytes within the page. */
        memcpy(&aData[iAddr], &aData[pc], 2);
        aData[hdr+7] += (u8)x;
      }else{
        /* The slot remains on the free-list. Reduce its size to account
         ** for the portion used by the new allocation. */
        put2byte(&aData[pc+2], x);
      }
      return &aData[pc + x];
    }
    iAddr = pc;
    pc = get2byte(&aData[pc]);
    if( pc<iAddr+size ) break;
  }
  if( pc ){
    *pRc = SQLITE_CORRUPT_PAGE(pPg);
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movzbl 0x9(%rdi), %ecx
movq 0x48(%rdi), %rdx
movq 0x50(%rdi), %rax
movzwl 0x1(%rax,%rcx), %r8d
rolw $0x8, %r8w
leaq 0x1(%rcx), %rdi
movzwl %r8w, %r9d
movl 0x34(%rdx), %r8d
leal -0x4(%r8), %r10d
movl %r9d, %edx
cmpl %r10d, %r9d
jg 0x42e3b9
movl %edx, %r11d
movzwl 0x2(%rax,%r11), %r9d
rolw $0x8, %r9w
movzwl %r9w, %ebp
movl %ebp, %r9d
subl %esi, %r9d
jns 0x42e3c8
movzwl (%rax,%r11), %edi
rolw $0x8, %di
movzwl %di, %r9d
addl %edx, %ebp
movl %edx, %edi
cmpl %ebp, %r9d
jae 0x42e37f
jmp 0x42e3bc
movl %edx, %r9d
testl %r9d, %r9d
je 0x42e3db
movl $0xfad8, %edi           # imm = 0xFAD8
jmp 0x42e3d4
addl %edx, %ebp
cmpl %r8d, %ebp
jle 0x42e3e4
movl $0xfac1, %edi           # imm = 0xFAC1
callq 0x418527
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x3, %r9d
ja 0x42e403
cmpb $0x39, 0x7(%rax,%rcx)
ja 0x42e3db
movl %edi, %esi
movzwl (%rax,%r11), %edi
movw %di, (%rax,%rsi)
addb %r9b, 0x7(%rax,%rcx)
jmp 0x42e410
movl %r9d, %ecx
rolw $0x8, %cx
movw %cx, 0x2(%rax,%r11)
addl %edx, %r9d
addq %r9, %rax
jmp 0x42e3dd
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: vdbeSortAllocUnpacked
static int vdbeSortAllocUnpacked(SortSubtask *pTask){
  if( pTask->pUnpacked==0 ){
    pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pTask->pSorter->pKeyInfo);
    if( pTask->pUnpacked==0 ) return SQLITE_NOMEM_BKPT;
    pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nKeyField;
    pTask->pUnpacked->errCode = 0;
  }
  return SQLITE_OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpq $0x0, 0x18(%rdi)
jne 0x42ee11
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq 0x28(%rax), %rdi
callq 0x4296c0
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x42ee0e
movq 0x10(%r14), %rcx
movq 0x28(%rcx), %rcx
movzwl 0x6(%rcx), %ecx
movw %cx, 0x10(%rax)
movb $0x0, 0x13(%rax)
jmp 0x42ee11
pushq $0x7
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: vdbeSorterCompareText
static int vdbeSorterCompareText(
  SortSubtask *pTask,             /* Subtask context (for pKeyInfo) */
  int *pbKey2Cached,              /* True if pTask->pUnpacked is pKey2 */
  const void *pKey1, int nKey1,   /* Left side of comparison */
  const void *pKey2, int nKey2    /* Right side of comparison */
){
  const u8 * const p1 = (const u8 * const)pKey1;
  const u8 * const p2 = (const u8 * const)pKey2;
  const u8 * const v1 = &p1[ p1[0] ];   /* Pointer to value 1 */
  const u8 * const v2 = &p2[ p2[0] ];   /* Pointer to value 2 */

  int n1;
  int n2;
  int res;

  getVarint32(&p1[1], n1);
  getVarint32(&p2[1], n2);
  res = memcmp(v1, v2, (MIN(n1, n2) - 13)/2);
  if( res==0 ){
    res = n1 - n2;
  }

  if( res==0 ){
    if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
      res = vdbeSorterCompareTail(
          pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2
      );
    }
  }else{
    if( pTask->pSorter->pKeyInfo->aSortOrder[0] ){
      res = res * -1;
    }
  }

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x14(%rsp)
movq %r8, %r14
movl %ecx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, 0x18(%rsp)
movq %rdi, %r13
movzbl (%rdx), %ebx
movzbl (%r8), %ebp
movsbl 0x1(%rdx), %eax
testl %eax, %eax
js 0x42efe5
movl %eax, 0xc(%rsp)
jmp 0x42eff3
leaq 0x1(%r15), %rdi
leaq 0xc(%rsp), %rsi
callq 0x428a26
addq %r15, %rbx
addq %r14, %rbp
movsbl 0x1(%r14), %eax
testl %eax, %eax
jns 0x42f017
leaq 0x1(%r14), %rdi
leaq 0x24(%rsp), %r12
movq %r12, %rsi
callq 0x428a26
movl (%r12), %eax
movl 0xc(%rsp), %ecx
movl %ecx, %r12d
subl %eax, %r12d
cmovll %ecx, %eax
addl $-0xd, %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movslq %eax, %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x4010a0
testl %eax, %eax
cmovnel %eax, %r12d
movq 0x10(%r13), %rax
movq 0x28(%rax), %rcx
testl %r12d, %r12d
je 0x42f060
movq 0x18(%rcx), %rcx
movl %r12d, %eax
negl %eax
cmpb $0x0, (%rcx)
cmovel %r12d, %eax
jmp 0x42f090
xorl %eax, %eax
cmpw $0x2, 0x6(%rcx)
jb 0x42f090
movq %r13, %rdi
movq 0x18(%rsp), %rsi
movq %r15, %rdx
movl 0x10(%rsp), %ecx
movq %r14, %r8
movl 0x14(%rsp), %r9d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42f0eb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3DefaultRowEst
SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){
  /*                10,  9,  8,  7,  6 */
  LogEst aVal[] = { 33, 32, 30, 28, 26 };
  LogEst *a = pIdx->aiRowLogEst;
  int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
  int i;

  /* Indexes with default row estimates should not have stat1 data */
  assert( !pIdx->hasStat1 );

  /* Set the first entry (number of rows in the index) to the estimated 
  ** number of rows in the table, or half the number of rows in the table
  ** for a partial index.   But do not let the estimate drop below 10. */
  a[0] = pIdx->pTable->nRowLogEst;
  if( pIdx->pPartIdxWhere!=0 ) a[0] -= 10;  assert( 10==sqlite3LogEst(2) );
  if( a[0]<33 ) a[0] = 33;                  assert( 33==sqlite3LogEst(10) );

  /* Estimate that a[1] is 10, a[2] is 9, a[3] is 8, a[4] is 7, a[5] is
  ** 6 and each subsequent value (if any) is 5.  */
  memcpy(&a[1], aVal, nCopy*sizeof(LogEst));
  for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
    a[i] = 23;                    assert( 23==sqlite3LogEst(5) );
  }

  assert( 0==sqlite3LogEst(1) );
  if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movzwl 0x5e(%rdi), %ebp
cmpw $0x5, %bp
pushq $0x5
popq %r12
movl %ebp, %edx
cmovael %r12d, %edx
movq 0x18(%rdi), %rax
movl 0x48(%rax), %ecx
movw %cx, (%r15)
leal -0xa(%rcx), %eax
cmpq $0x0, 0x48(%rdi)
cmovel %ecx, %eax
jne 0x430766
cmpw $0x20, %ax
jg 0x430774
cmpw $0x22, %ax
pushq $0x21
popq %rcx
cmovgel %eax, %ecx
movw %cx, (%r15)
leaq 0x2(%r15), %r14
addl %edx, %edx
movl $0xffff, %r13d          # imm = 0xFFFF
andl %r13d, %edx
leaq 0x10a4e0(%rip), %rsi    # 0x53ac6a
movq %r14, %rdi
callq 0x401048
cmpw $0x5, %bp
cmovbl %ebp, %r12d
andl %r13d, %r12d
movzwl 0x5e(%rbx), %eax
cmpq %rax, %r12
jae 0x4307b2
movw $0x17, (%r14,%r12,2)
incq %r12
jmp 0x43079d
cmpb $0x0, 0x62(%rbx)
je 0x4307be
andw $0x0, (%r15,%rax,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3FreeIndex
SQLITE_PRIVATE void sqlite3FreeIndex(sqlite3 *db, Index *p){
#ifndef SQLITE_OMIT_ANALYZE
  sqlite3DeleteIndexSamples(db, p);
#endif
  sqlite3ExprDelete(db, p->pPartIdxWhere);
  sqlite3ExprListDelete(db, p->aColExpr);
  sqlite3DbFree(db, p->zColAff);
  if( p->isResized ) sqlite3DbFree(db, (void *)p->azColl);
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
  sqlite3_free(p->aiRowEst);
#endif
  sqlite3DbFree(db, p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %rsi
callq 0x430b70
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0x430b76
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x4043ed
testb $0x10, 0x63(%rbx)
je 0x430b5e
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x4043ed
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x412f53
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ExprDeleteNN
static SQLITE_NOINLINE void sqlite3ExprDeleteNN(sqlite3 *db, Expr *p){
  assert( p!=0 );
  /* Sanity check: Assert that the IntValue is non-negative if it exists */
  assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
#ifdef SQLITE_DEBUG
  if( ExprHasProperty(p, EP_Leaf) && !ExprHasProperty(p, EP_TokenOnly) ){
    assert( p->pLeft==0 );
    assert( p->pRight==0 );
    assert( p->x.pSelect==0 );
  }
#endif
  if( !ExprHasProperty(p, (EP_TokenOnly|EP_Leaf)) ){
    /* The Expr.x union is never used at the same time as Expr.pRight */
    assert( p->x.pList==0 || p->pRight==0 );
    if( p->pLeft && p->op!=TK_SELECT_COLUMN ) sqlite3ExprDeleteNN(db, p->pLeft);
    if( p->pRight ){
      sqlite3ExprDeleteNN(db, p->pRight);
    }else if( ExprHasProperty(p, EP_xIsSelect) ){
      sqlite3SelectDelete(db, p->x.pSelect);
    }else{
      sqlite3ExprListDelete(db, p->x.pList);
    }
    if( !ExprHasProperty(p, EP_Reduced) ){
      sqlite3WindowDelete(db, p->pWin);
    }
  }
  if( ExprHasProperty(p, EP_MemToken) ) sqlite3DbFree(db, p->u.zToken);
  if( !ExprHasProperty(p, EP_Static) ){
    sqlite3DbFreeNN(db, p);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %eax
testl $0x804000, %eax         # imm = 0x804000
jne 0x430bee
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x430baa
cmpb $-0x5a, (%rbx)
je 0x430baa
movq %r14, %rdi
callq 0x430b80
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x430bbd
movq %r14, %rdi
callq 0x430b80
jmp 0x430bd6
testb $0x8, 0x5(%rbx)
movq 0x20(%rbx), %rsi
movq %r14, %rdi
jne 0x430bd1
callq 0x430b76
jmp 0x430bd6
callq 0x430c22
movl 0x4(%rbx), %eax
btl $0xd, %eax
jb 0x430bee
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x430c2d
movl 0x4(%rbx), %eax
btl $0x10, %eax
jae 0x430c03
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4043ed
movl 0x4(%rbx), %eax
testw %ax, %ax
js 0x430c1a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x412f53
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3WindowDelete
SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3 *db, Window *p){
  if( p ){
    sqlite3ExprDelete(db, p->pFilter);
    sqlite3ExprListDelete(db, p->pPartition);
    sqlite3ExprListDelete(db, p->pOrderBy);
    sqlite3ExprDelete(db, p->pEnd);
    sqlite3ExprDelete(db, p->pStart);
    sqlite3DbFree(db, p->zName);
    sqlite3DbFree(db, p);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x430c92
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rsi
callq 0x430b70
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x430b76
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x430b76
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x430b70
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x430b70
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x4043ed
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x412f53
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: exprListDeleteNN
static SQLITE_NOINLINE void exprListDeleteNN(sqlite3 *db, ExprList *pList){
  int i = pList->nExpr;
  struct ExprList_item *pItem =  pList->a;
  assert( pList->nExpr>0 );
  do{
    sqlite3ExprDelete(db, pItem->pExpr);
    sqlite3DbFree(db, pItem->zName);
    sqlite3DbFree(db, pItem->zSpan);
    pItem++;
  }while( --i>0 );
  sqlite3DbFreeNN(db, pList);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %ebp
leaq 0x8(%rsi), %r15
incl %ebp
movq (%r15), %rsi
movq %r14, %rdi
callq 0x430b70
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x4043ed
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x4043ed
addq $0x20, %r15
decl %ebp
cmpl $0x1, %ebp
jg 0x430f0e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x412f53
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: checkRef
static int checkRef(IntegrityCk *pCheck, Pgno iPage){
  if( iPage>pCheck->nPage || iPage==0 ){
    checkAppendMsg(pCheck, "invalid page number %d", iPage);
    return 1;
  }
  if( getPageReferenced(pCheck, iPage) ){
    checkAppendMsg(pCheck, "2nd reference to page %d", iPage);
    return 1;
  }
  setPageReferenced(pCheck, iPage);
  return 0;
}

// Assembly:
pushq %rbx
movl %esi, %edx
leal -0x1(%rdx), %eax
cmpl 0x18(%rdi), %eax
jae 0x4319bf
movq 0x10(%rdi), %rax
movl %edx, %esi
shrl $0x3, %esi
movl %edx, %ecx
andb $0x7, %cl
pushq $0x1
popq %rbx
movl %ebx, %r8d
shll %cl, %r8d
movzbl (%rax,%rsi), %ecx
movl %edx, %r9d
andl $0x7, %r9d
btl %r9d, %ecx
jae 0x4319d2
leaq 0x10dc11(%rip), %rsi    # 0x53f5c7
xorl %eax, %eax
callq 0x43113d
jmp 0x4319db
leaq 0x10dbea(%rip), %rsi    # 0x53f5b0
xorl %eax, %eax
callq 0x43113d
pushq $0x1
popq %rbx
jmp 0x4319db
orb %cl, %r8b
movb %r8b, (%rax,%rsi)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: growOpArray
static int growOpArray(Vdbe *v, int nOp){
  VdbeOp *pNew;
  Parse *p = v->pParse;

  /* The SQLITE_TEST_REALLOC_STRESS compile-time option is designed to force
  ** more frequent reallocs and hence provide more opportunities for 
  ** simulated OOM faults.  SQLITE_TEST_REALLOC_STRESS is generally used
  ** during testing only.  With SQLITE_TEST_REALLOC_STRESS grow the op array
  ** by the minimum* amount required until the size reaches 512.  Normal
  ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current
  ** size of the op array or add 1KB of space, whichever is smaller. */
#ifdef SQLITE_TEST_REALLOC_STRESS
  int nNew = (p->nOpAlloc>=512 ? p->nOpAlloc*2 : p->nOpAlloc+nOp);
#else
  int nNew = (p->nOpAlloc ? p->nOpAlloc*2 : (int)(1024/sizeof(Op)));
  UNUSED_PARAMETER(nOp);
#endif

  /* Ensure that the size of a VDBE does not grow too large */
  if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){
    sqlite3OomFault(p->db);
    return SQLITE_NOMEM;
  }

  assert( nOp<=(1024/sizeof(Op)) );
  assert( nNew>=(p->nOpAlloc+nOp) );
  pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
  if( pNew ){
    p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew);
    p->nOpAlloc = p->szOpAlloc/sizeof(Op);
    v->aOp = pNew;
  }
  return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r15
movl 0x3c(%r15), %eax
leal (%rax,%rax), %ecx
testl %eax, %eax
pushq $0x2a
popq %rax
cmovnel %ecx, %eax
movq (%r15), %rdi
cmpl 0x90(%rdi), %eax
jle 0x432b02
callq 0x40a1fe
jmp 0x432b3e
movq 0x68(%rbx), %rsi
cltq
imulq $0x18, %rax, %rdx
callq 0x412fa2
testq %rax, %rax
je 0x432b3e
movq %rax, %r14
movq (%r15), %rdi
movq %rax, %rsi
callq 0x40654b
movl %eax, 0x40(%r15)
cltq
xorl %ecx, %ecx
pushq $0x18
popq %rsi
xorl %edx, %edx
divq %rsi
movl %eax, 0x3c(%r15)
movq %r14, 0x68(%rbx)
jmp 0x432b41
pushq $0x7
popq %rcx
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3DbStrNDup
SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){
  char *zNew;
  assert( db!=0 );
  if( z==0 ){
    return 0;
  }
  assert( (n&0x7fffffff)==n );
  zNew = sqlite3DbMallocRawNN(db, n+1);
  if( zNew ){
    memcpy(zNew, z, (size_t)n);
    zNew[n] = 0;
  }
  return zNew;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x432c08
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x1(%rdx), %rsi
callq 0x412fd6
testq %rax, %rax
je 0x432c08
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x401048
movb $0x0, (%r14,%rbx)
jmp 0x432c0b
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3VtabCreateModule
SQLITE_PRIVATE Module *sqlite3VtabCreateModule(
  sqlite3 *db,                    /* Database in which module is registered */
  const char *zName,              /* Name assigned to this module */
  const sqlite3_module *pModule,  /* The definition of the module */
  void *pAux,                     /* Context pointer for xCreate/xConnect */
  void (*xDestroy)(void *)        /* Module destructor function */
){
  Module *pMod;
  int nName = sqlite3Strlen30(zName);
  pMod = (Module *)sqlite3Malloc(sizeof(Module) + nName + 1);
  if( pMod==0 ){
    sqlite3OomFault(db);
  }else{
    Module *pDel;
    char *zCopy = (char *)(&pMod[1]);
    memcpy(zCopy, zName, nName+1);
    pMod->zName = zCopy;
    pMod->pModule = pModule;
    pMod->pAux = pAux;
    pMod->xDestroy = xDestroy;
    pMod->pEpoTab = 0;
    pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod);
    assert( pDel==0 || pDel==pMod );
    if( pDel ){
      sqlite3OomFault(db);
      sqlite3DbFree(db, pDel);
      pMod = 0;
    }
  }
  return pMod;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, 0x10(%rsp)
movq %rsi, %rbp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4066a8
movl %eax, %r15d
leal 0x29(%r15), %edi
callq 0x404b49
testq %rax, %rax
je 0x432efc
movq %rax, %r14
movq %r12, 0x8(%rsp)
movq %rax, %r12
addq $0x28, %r12
incl %r15d
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x401048
movq %r12, 0x8(%r14)
movq 0x10(%rsp), %rax
movq %rax, (%r14)
movq %r13, 0x10(%r14)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%r14)
andq $0x0, 0x20(%r14)
leaq 0x1c0(%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4308d9
testq %rax, %rax
je 0x432f07
movq %rax, %r15
movq %rbx, %rdi
callq 0x40a1fe
movq %rbx, %rdi
movq %r15, %rsi
callq 0x412f53
jmp 0x432f04
movq %rbx, %rdi
callq 0x40a1fe
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3AddDefaultValue
SQLITE_PRIVATE void sqlite3AddDefaultValue(
  Parse *pParse,           /* Parsing context */
  Expr *pExpr,             /* The parsed expression of the default value */
  const char *zStart,      /* Start of the default value text */
  const char *zEnd         /* First character past end of defaut value text */
){
  Table *p;
  Column *pCol;
  sqlite3 *db = pParse->db;
  p = pParse->pNewTable;
  if( p!=0 ){
    pCol = &(p->aCol[p->nCol-1]);
    if( !sqlite3ExprIsConstantOrFunction(pExpr, db->init.busy) ){
      sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
          pCol->zName);
    }else{
      /* A copy of pExpr is used instead of the original, as pExpr contains
      ** tokens that point to volatile memory.
      */
      Expr x;
      sqlite3ExprDelete(db, pCol->pDflt);
      memset(&x, 0, sizeof(x));
      x.op = TK_SPAN;
      x.u.zToken = sqlite3DbSpanDup(db, zStart, zEnd);
      x.pLeft = pExpr;
      x.flags = EP_Skip;
      pCol->pDflt = sqlite3ExprDup(db, &x, EXPRDUP_REDUCE);
      sqlite3DbFree(db, x.u.zToken);
    }
  }
  if( IN_RENAME_OBJECT ){
    sqlite3RenameExprUnmap(pParse, pExpr);
  }
  sqlite3ExprDelete(db, pExpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq 0x138(%rdi), %rax
testq %rax, %rax
je 0x439bc6
movq %rcx, %rbp
movq %rdx, %r13
movswq 0x46(%rax), %r12
shlq $0x5, %r12
addq 0x8(%rax), %r12
movzbl 0xb5(%r14), %esi
addl $0x4, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x44bab7
testl %eax, %eax
je 0x439bb0
movq -0x18(%r12), %rsi
movq %r14, %rdi
callq 0x430b70
xorps %xmm0, %xmm0
movq %rbp, %rdx
movq %rsp, %rbp
movaps %xmm0, (%rbp)
movaps %xmm0, 0x40(%rbp)
movaps %xmm0, 0x30(%rbp)
movaps %xmm0, 0x20(%rbp)
movaps %xmm0, 0x10(%rbp)
movb $-0x57, (%rbp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x451d68
movq %rax, 0x8(%rbp)
movq %rbx, 0x10(%rbp)
movl $0x1000, 0x4(%rbp)      # imm = 0x1000
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x44c0b2
movq %rax, -0x18(%r12)
movq 0x8(%rbp), %rsi
movq %r14, %rdi
callq 0x4043ed
jmp 0x439bc6
movq -0x20(%r12), %rdx
leaq 0x1070ae(%rip), %rsi    # 0x540c6a
movq %r15, %rdi
xorl %eax, %eax
callq 0x40c672
cmpb $0x2, 0x10c(%r15)
jb 0x439bf4
xorps %xmm0, %xmm0
movq %rsp, %rdi
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq %r15, (%rdi)
leaq 0x181cb(%rip), %rax     # 0x451db3
movq %rax, 0x8(%rdi)
movq %rbx, %rsi
callq 0x44bba1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x430b70
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3PExpr
SQLITE_PRIVATE Expr *sqlite3PExpr(
  Parse *pParse,          /* Parsing context */
  int op,                 /* Expression opcode */
  Expr *pLeft,            /* Left operand */
  Expr *pRight            /* Right operand */
){
  Expr *p;
  if( op==TK_AND && pParse->nErr==0 ){
    /* Take advantage of short-circuit false optimization for AND */
    p = sqlite3ExprAnd(pParse->db, pLeft, pRight);
  }else{
    p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr));
    if( p ){
      memset(p, 0, sizeof(Expr));
      p->op = op & TKFLG_MASK;
      p->iAgg = -1;
    }
    sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
  }
  if( p ) {
    sqlite3ExprCheckHeight(pParse, p->nHeight);
  }
  return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x2c, %esi
jne 0x439c2c
cmpl $0x0, 0x30(%rbx)
je 0x439c99
movq (%rbx), %rdi
pushq $0x50
popq %rsi
callq 0x412fd6
movq %rax, %r12
testq %rax, %rax
je 0x439c6a
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movups %xmm0, 0x30(%r12)
movups %xmm0, 0x40(%r12)
movups %xmm0, 0x20(%r12)
movups %xmm0, 0x10(%r12)
movb %bpl, (%r12)
orw $-0x1, 0x32(%r12)
movq (%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x445562
testq %r12, %r12
je 0x439c8d
movl 0x28(%r12), %esi
movq %rbx, %rdi
callq 0x44fa15
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x451924
movq %rax, %r12
jmp 0x439c7b
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: tokenExpr
static Expr *tokenExpr(Parse *pParse, int op, Token t){
    Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1);
    if( p ){
      /* memset(p, 0, sizeof(Expr)); */
      p->op = (u8)op;
      p->affinity = 0;
      p->flags = EP_Leaf;
      p->iAgg = -1;
      p->pLeft = p->pRight = 0;
      p->x.pList = 0;
      p->pAggInfo = 0;
      p->pTab = 0;
      p->op2 = 0;
      p->iTable = 0;
      p->iColumn = 0;
#ifndef SQLITE_OMIT_WINDOWFUNC
      p->pWin = 0;
#endif
      p->u.zToken = (char*)&p[1];
      memcpy(p->u.zToken, t.z, t.n);
      p->u.zToken[t.n] = 0;
      if( sqlite3Isquote(p->u.zToken[0]) ){
        if( p->u.zToken[0]=='"' ) p->flags |= EP_DblQuoted;
        sqlite3Dequote(p->u.zToken);
      }
#if SQLITE_MAX_EXPR_DEPTH>0
      p->nHeight = 1;
#endif  
      if( IN_RENAME_OBJECT ){
        return (Expr*)sqlite3RenameTokenMap(pParse, (void*)p, &t);
      }
    }
    return p;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
movl %ecx, 0x10(%rsp)
movq (%rdi), %rdi
movl %ecx, %r13d
leaq 0x51(%r13), %rsi
callq 0x412fd6
movq %rax, %r14
testq %rax, %rax
je 0x439d85
movq %rax, %r15
movb %bpl, (%r14)
xorl %ebp, %ebp
movb %bpl, 0x1(%r14)
movl $0x800000, 0x4(%r14)    # imm = 0x800000
movb %bpl, 0x36(%r14)
movabsq $-0x1000000000000, %rax # imm = 0xFFFF000000000000
movq %rax, 0x2c(%r14)
addq $0x50, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
andq $0x0, 0x20(%r14)
movups %xmm0, 0x38(%r14)
andq $0x0, 0x48(%r14)
movq %r15, 0x8(%r14)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x401048
movb %bpl, 0x50(%r14,%r13)
movzbl 0x50(%r14), %eax
leaq 0x100786(%rip), %rcx    # 0x53a4d0
cmpb %bpl, (%rax,%rcx)
jns 0x439d64
cmpb $0x22, %al
jne 0x439d5c
movl $0x800040, 0x4(%r14)    # imm = 0x800040
movq %r15, %rdi
callq 0x451d16
movl $0x1, 0x28(%r14)
cmpb $0x2, 0x10c(%rbx)
jb 0x439d85
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x440dfa
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ExprIdToTrueFalse
SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
  assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
  if( sqlite3StrICmp(pExpr->u.zToken, "true")==0
   || sqlite3StrICmp(pExpr->u.zToken, "false")==0
  ){
    pExpr->op = TK_TRUEFALSE;
    return 1;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x106eee(%rip), %rsi    # 0x540c97
movq %r14, %rdi
callq 0x406caf
testl %eax, %eax
je 0x439dcc
leaq 0x106ee0(%rip), %rsi    # 0x540c9c
movq %r14, %rdi
callq 0x406caf
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x439dd2
movb $-0x65, (%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ExprListSetName
SQLITE_PRIVATE void sqlite3ExprListSetName(
  Parse *pParse,          /* Parsing context */
  ExprList *pList,        /* List to which to add the span. */
  Token *pName,           /* Name to be added */
  int dequote             /* True to cause the name to be dequoted */
){
  assert( pList!=0 || pParse->db->mallocFailed!=0 );
  if( pList ){
    struct ExprList_item *pItem;
    assert( pList->nExpr>0 );
    pItem = &pList->a[pList->nExpr-1];
    assert( pItem->zName==0 );
    pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
    if( dequote ) sqlite3Dequote(pItem->zName);
    if( IN_RENAME_OBJECT ){
      sqlite3RenameTokenMap(pParse, (void*)pItem->zName, pName);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x440b3d
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq (%rsi), %r12
shlq $0x5, %r12
movq (%rdi), %rdi
movq (%rdx), %rsi
movl 0x8(%rdx), %edx
callq 0x432bd2
movq %rax, -0x10(%r12,%r15)
testl %ebp, %ebp
je 0x440b15
movq %rax, %rdi
callq 0x451d16
cmpb $0x2, 0x10c(%r14)
jb 0x440b3d
leaq (%r12,%r15), %rax
addq $-0x10, %rax
movq (%rax), %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x440dfa
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3SrcListAppend
SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(
  sqlite3 *db,        /* Connection to notify of malloc failures */
  SrcList *pList,     /* Append to this SrcList. NULL creates a new SrcList */
  Token *pTable,      /* Table to append */
  Token *pDatabase    /* Database of the table */
){
  struct SrcList_item *pItem;
  assert( pDatabase==0 || pTable!=0 );  /* Cannot have C without B */
  assert( db!=0 );
  if( pList==0 ){
    pList = sqlite3DbMallocRawNN(db, sizeof(SrcList) );
    if( pList==0 ) return 0;
    pList->nAlloc = 1;
    pList->nSrc = 1;
    memset(&pList->a[0], 0, sizeof(pList->a[0]));
    pList->a[0].iCursor = -1;
  }else{
    pList = sqlite3SrcListEnlarge(db, pList, 1, pList->nSrc);
  }
  if( db->mallocFailed ){
    sqlite3SrcListDelete(db, pList);
    return 0;
  }
  pItem = &pList->a[pList->nSrc-1];
  if( pDatabase && pDatabase->z==0 ){
    pDatabase = 0;
  }
  if( pDatabase ){
    pItem->zName = sqlite3NameFromToken(db, pDatabase);
    pItem->zDatabase = sqlite3NameFromToken(db, pTable);
  }else{
    pItem->zName = sqlite3NameFromToken(db, pTable);
    pItem->zDatabase = 0;
  }
  return pList;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x440d45
movl (%rsi), %ecx
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x4577f6
movq %rax, %rbx
jmp 0x440d88
pushq $0x78
popq %rsi
movq %r15, %rdi
callq 0x412fd6
testq %rax, %rax
je 0x440d9a
movq %rax, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
orl $-0x1, 0x48(%rbx)
cmpb $0x0, 0x61(%r15)
je 0x440d9e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x430d57
xorl %ebx, %ebx
jmp 0x440ded
movslq (%rbx), %rax
imulq $0x70, %rax, %rax
leaq (%rax,%rbx), %r13
addq $-0x68, %r13
testq %r12, %r12
je 0x440dd9
cmpq $0x0, (%r12)
je 0x440dd9
movq %r15, %rdi
movq %r12, %rsi
callq 0x440e3e
movq %rax, 0x10(%r13)
movq %r15, %rdi
movq %r14, %rsi
callq 0x440e3e
movq %rax, 0x8(%r13)
jmp 0x440ded
movq %r15, %rdi
movq %r14, %rsi
callq 0x440e3e
movq %rax, 0x10(%r13)
andq $0x0, 0x8(%r13)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3RenameTokenMap
SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse *pParse, void *pPtr, Token *pToken){
  RenameToken *pNew;
  assert( pPtr || pParse->db->mallocFailed );
  renameTokenCheckAll(pParse, pPtr);
  pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken));
  if( pNew ){
    pNew->p = pPtr;
    pNew->t = *pToken;
    pNew->pNext = pParse->pRename;
    pParse->pRename = pNew;
  }

  return pPtr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
pushq $0x20
popq %rsi
callq 0x40af46
testq %rax, %rax
je 0x440e35
movq %rbx, (%rax)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x190(%r14), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x190(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3Vacuum
SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse, Token *pNm){
  Vdbe *v = sqlite3GetVdbe(pParse);
  int iDb = 0;
  if( v==0 ) return;
  if( pNm ){
#ifndef SQLITE_BUG_COMPATIBLE_20160819
    /* Default behavior:  Report an error if the argument to VACUUM is
    ** not recognized */
    iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
    if( iDb<0 ) return;
#else
    /* When SQLITE_BUG_COMPATIBLE_20160819 is defined, unrecognized arguments
    ** to VACUUM are silently ignored.  This is a back-out of a bug fix that
    ** occurred on 2016-08-19 (https://www.sqlite.org/src/info/083f9e6270).
    ** The buggy behavior is required for binary compatibility with some
    ** legacy applications. */
    iDb = sqlite3FindDb(pParse->db, pNm);
    if( iDb<0 ) iDb = 0;
#endif
  }
  if( iDb!=1 ){
    sqlite3VdbeAddOp1(v, OP_Vacuum, iDb);
    sqlite3VdbeUsesBtree(v, iDb);
  }
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x44856b
testq %rax, %rax
je 0x4457ad
movq %rax, %rbx
testq %r14, %r14
je 0x4457b8
movq %rsp, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x44d8f3
movl %eax, %ebp
testl %eax, %eax
sets %al
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
je 0x4457ba
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
pushq $0x8
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x449fcc
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x40c950
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ExprCodeTemp
SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
  int r2;
  pExpr = sqlite3ExprSkipCollate(pExpr);
  if( ConstFactorOk(pParse)
   && pExpr->op!=TK_REGISTER
   && sqlite3ExprIsConstantNotJoin(pExpr)
  ){
    *pReg  = 0;
    r2 = sqlite3ExprCodeAtInit(pParse, pExpr, -1);
  }else{
    int r1 = sqlite3GetTempReg(pParse);
    r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
    if( r2==r1 ){
      *pReg = r1;
    }else{
      sqlite3ReleaseTempReg(pParse, r1);
      *pReg = 0;
    }
  }
  return r2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x44b988
movq %rax, %r15
cmpb $0x0, 0x23(%r14)
je 0x449ee7
cmpb $-0x5c, (%r15)
je 0x449ee7
movq %r15, %rdi
callq 0x449fd6
testl %eax, %eax
je 0x449ee7
andl $0x0, (%rbx)
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x449fe0
movq %r14, %rdi
callq 0x44b9b3
movl %eax, %ebp
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x448a28
cmpl %ebp, %eax
jne 0x449f06
movl %ebp, %ecx
jmp 0x449f26
xorl %ecx, %ecx
testl %ebp, %ebp
je 0x449f26
movzbl 0x1f(%r14), %edx
cmpq $0x7, %rdx
ja 0x449f26
leal 0x1(%rdx), %esi
movb %sil, 0x1f(%r14)
movl %ebp, 0xc4(%r14,%rdx,4)
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ExprCodeAtInit
SQLITE_PRIVATE int sqlite3ExprCodeAtInit(
  Parse *pParse,    /* Parsing context */
  Expr *pExpr,      /* The expression to code when the VDBE initializes */
  int regDest       /* Store the value in this register */
){
  ExprList *p;
  assert( ConstFactorOk(pParse) );
  p = pParse->pConstExpr;
  if( regDest<0 && p ){
    struct ExprList_item *pItem;
    int i;
    for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){
      if( pItem->reusable && sqlite3ExprCompare(0,pItem->pExpr,pExpr,-1)==0 ){
        return pItem->u.iConstExprReg;
      }
    }
  }
  pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
  p = sqlite3ExprListAppend(pParse, p, pExpr);
  if( p ){
     struct ExprList_item *pItem = &p->a[p->nExpr-1];
     pItem->reusable = regDest<0;
     if( regDest<0 ) regDest = ++pParse->nMem;
     pItem->u.iConstExprReg = regDest;
  }
  pParse->pConstExpr = p;
  return regDest;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, (%rsp)
movq 0x58(%rdi), %r15
testl %edx, %edx
sets %al
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x44a040
movl (%r15), %r14d
movq %r15, %r13
addq $0x24, %r13
pushq $-0x1
popq %rbp
testl %r14d, %r14d
jle 0x44a040
testb $0x4, -0x3(%r13)
je 0x44a037
movq -0x1c(%r13), %rsi
xorl %edi, %edi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x44bddb
testl %eax, %eax
je 0x44a0b2
decl %r14d
addq $0x20, %r13
jmp 0x44a017
movq (%rsp), %r14
movq (%r14), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x44c0b2
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x440a42
testq %rax, %rax
je 0x44a09d
movslq (%rax), %rdx
shlq $0x5, %rdx
movb 0x1(%rdx,%rax), %sil
movl %ebx, %ecx
shrl $0x1d, %ecx
andb $0x4, %cl
andb $-0x5, %sil
orb %cl, %sil
leaq (%rdx,%rax), %rcx
addq $-0x18, %rcx
movb %sil, 0x1(%rdx,%rax)
testl %ebx, %ebx
jns 0x44a09a
movl 0x38(%r14), %ebx
incl %ebx
movl %ebx, 0x38(%r14)
movl %ebx, 0x1c(%rcx)
movq %rax, 0x58(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%r13), %ebx
jmp 0x44a0a1
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ReleaseTempRange
SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
  if( nReg==1 ){
    sqlite3ReleaseTempReg(pParse, iReg);
    return;
  }
  if( nReg>pParse->nRangeReg ){
    pParse->nRangeReg = nReg;
    pParse->iRangeReg = iReg;
  }
}

// Assembly:
cmpl $0x1, %edx
jne 0x44a2a7
testl %esi, %esi
je 0x44a2b5
movzbl 0x1f(%rdi), %eax
cmpq $0x7, %rax
ja 0x44a2b5
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rdi)
leaq (%rdi,%rax,4), %rdi
addq $0xc4, %rdi
jmp 0x44a2b3
cmpl %edx, 0x28(%rdi)
jge 0x44a2b5
movl %edx, 0x28(%rdi)
addq $0x2c, %rdi
movl %esi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ExprCodeGetColumnOfTable
SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(
  Vdbe *v,        /* The VDBE under construction */
  Table *pTab,    /* The table containing the value */
  int iTabCur,    /* The table cursor.  Or the PK cursor for WITHOUT ROWID */
  int iCol,       /* Index of the column to extract */
  int regOut      /* Extract the value into this register */
){
  if( pTab==0 ){
    sqlite3VdbeAddOp3(v, OP_Column, iTabCur, iCol, regOut);
    return;
  }
  if( iCol<0 || iCol==pTab->iPKey ){
    sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
  }else{
    int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
    int x = iCol;
    if( !HasRowid(pTab) && !IsVirtual(pTab) ){
      x = sqlite3ColumnOfIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
    }
    sqlite3VdbeAddOp3(v, op, iTabCur, x, regOut);
  }
  if( iCol>=0 ){
    sqlite3ColumnDefault(v, pTab, iCol, regOut);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r12d
movq %rdi, %r14
testq %rsi, %rsi
je 0x44b3d6
movq %rsi, %r15
testl %ebp, %ebp
js 0x44b3bb
movswl 0x44(%r15), %eax
cmpl %ebp, %eax
jne 0x44b3f7
movq %r14, %rdi
movl $0x81, %esi
movl %r12d, %edx
movl %ebx, %ecx
callq 0x432a3f
testl %ebp, %ebp
jns 0x44b444
jmp 0x44b4be
pushq $0x5a
popq %rsi
movq %r14, %rdi
movl %r12d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x432a44
cmpl $0x0, 0x54(%r15)
setne %al
movl $0xa5, %ecx
pushq $0x5a
popq %r13
cmovnel %ecx, %r13d
testb $0x20, 0x40(%r15)
sete %dl
orb %al, %dl
movl %ebp, %ecx
testb $0x1, %dl
jne 0x44b433
movq %r15, %rdi
callq 0x40f0e7
movswl %bp, %esi
movq %rax, %rdi
callq 0x44b4cd
movswl %ax, %ecx
movq %r14, %rdi
movl %r13d, %esi
movl %r12d, %edx
movl %ebx, %r8d
callq 0x432a44
cmpq $0x0, 0x18(%r15)
je 0x44b450
movl %ebp, %r13d
jmp 0x44b493
movq %rsp, %r12
andq $0x0, (%r12)
movq (%r14), %rdi
movzbl 0x5e(%rdi), %edx
movq 0x8(%r15), %rax
movl %ebp, %r13d
movq %r13, %rcx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %rsi
movzbl 0x19(%rax,%rcx), %ecx
movq %r12, %r8
callq 0x44b4ec
movq (%r12), %rsi
testq %rsi, %rsi
je 0x44b493
pushq $-0xb
popq %rdx
movq %r14, %rdi
callq 0x448919
movq 0x8(%r15), %rax
shlq $0x5, %r13
cmpb $0x45, 0x19(%rax,%r13)
jne 0x44b4be
pushq $0x54
popq %rsi
movq %r14, %rdi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x449fcc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq