LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x43178c
movq 0x10(%rbx), %rdi
movl 0xc(%rbx), %edx
movzbl 0xa(%rbx), %ecx
movq %rbx, %rsi
callq 0x425e39
movl %eax, %ebp
movw $0x4, %ax
testl %ebp, %ebp
je 0x43177d
movq (%rbx), %r14
movq 0x10(%rbx), %rdi
movl 0xc(%rbx), %edx
movzbl 0xa(%rbx), %ecx
movq %rbx, %rsi
callq 0x425909
movw $0x8, %ax
cmpl $0x1, %ebp
jne 0x43177d
cvtsi2sd %r14, %xmm0
movq %xmm0, %rcx
cmpq %rcx, (%rbx)
jne 0x43177d
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_O3/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 0x431ace
movq %rsi, %r13
movq 0x80(%rbx), %rdi
callq 0x42fcc7
testq %rax, %rax
je 0x431aee
movq %rax, %r14
movq 0x80(%rbx), %rdi
movl %r12d, %esi
movq %r13, %rdx
movq %rax, %rcx
callq 0x42fd0b
cmpw $0x0, 0x10(%r14)
je 0x431af5
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movq %r15, %r8
callq 0x42f6e0
movl %eax, %ebp
jmp 0x431b20
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movl %ebp, %ecx
movq %r15, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42f6e0
movl $0x7, %ebp
jmp 0x431b33
leaq 0x11ee33(%rip), %rsi    # 0x55092f
leaq 0x11ef4f(%rip), %rdx    # 0x550a52
leaq 0x11ec5c(%rip), %r8     # 0x550766
movl $0xb, %ebp
movl $0xb, %edi
movl $0xf7e4, %ecx           # imm = 0xF7E4
xorl %eax, %eax
callq 0x40765d
movq 0x80(%rbx), %rax
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x415f0a
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_O3/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 %rbx
movq %rdi, %rbx
movb (%rdi), %cl
testb %cl, %cl
je 0x43295e
cmpb $0x3, %cl
jb 0x432939
movq %rbx, %rdi
callq 0x431a0e
testl %eax, %eax
jne 0x4329f3
movb (%rbx), %cl
movl $0x65, %eax
cmpb $0x1, %cl
je 0x4329f3
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x43295e
movb $0x0, (%rbx)
movl $0x0, 0x4(%rbx)
js 0x4329f1
movq 0x88(%rbx), %rcx
cmpb $0x0, 0x8(%rcx)
movzwl 0x56(%rbx), %eax
je 0x432997
testw %ax, %ax
jne 0x4329d4
jmp 0x432987
movq %rbx, %rdi
callq 0x431e05
movzwl 0x56(%rbx), %eax
testw %ax, %ax
jne 0x4329cd
cmpb $0x0, 0x54(%rbx)
jne 0x432976
movb $0x1, (%rbx)
movl $0x65, %eax
jmp 0x4329f3
movzwl %ax, %eax
movzwl 0x18(%rcx), %edx
movq 0x50(%rcx), %rsi
movq 0x60(%rcx), %rcx
movzbl (%rcx,%rax,2), %edi
shll $0x8, %edi
movzbl 0x1(%rcx,%rax,2), %eax
orl %edi, %eax
andl %edx, %eax
movl (%rsi,%rax), %esi
bswapl %esi
movq %rbx, %rdi
callq 0x431e45
testl %eax, %eax
jne 0x4329f3
movq %rbx, %rdi
popq %rbx
jmp 0x4329f5
movq 0x88(%rbx), %rcx
decl %eax
movw %ax, 0x56(%rbx)
xorl %eax, %eax
cmpb $0x0, 0x2(%rcx)
je 0x4329f3
cmpb $0x0, 0x8(%rcx)
jne 0x4329f3
movq %rbx, %rdi
popq %rbx
jmp 0x42fc8d
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14d
movl %ecx, %r13d
movq %rsi, %rbx
movl 0x24(%rdx), %ecx
movl %ecx, %r12d
subl %r13d, %r12d
jle 0x434be8
movq %rdx, %r15
movl %r14d, %r8d
subl %r12d, %r8d
jle 0x434ba1
movl %r12d, %esi
addq %rbx, %rsi
movq %rdi, %r14
movq %r15, %rdx
callq 0x434b5c
movq %r14, %rdi
movl %r12d, %r14d
testl %eax, %eax
jne 0x434c13
movq %rdi, (%rsp)
movslq %r13d, %r13
movq 0x10(%r15), %rsi
addq %r13, %rsi
movslq %r14d, %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x401028
xorl %ebp, %ebp
testl %eax, %eax
je 0x434c15
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x409fdc
testl %eax, %eax
jne 0x434c13
addq 0x10(%r15), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x401048
jmp 0x434c15
testl %r14d, %r14d
jle 0x434c02
movl %r14d, %eax
xorl %r15d, %r15d
cmpb $0x0, (%rbx,%r15)
jne 0x434c06
incq %r15
cmpq %r15, %rax
jne 0x434bf3
xorl %ebp, %ebp
jmp 0x434c15
movq 0x70(%rdi), %rdi
callq 0x409fdc
testl %eax, %eax
je 0x434c26
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %r15, %rbx
movslq %r14d, %rdx
subq %r15, %rdx
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4010b8
jmp 0x434c15
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movzbl 0x9(%rdi), %eax
movq 0x48(%rdi), %rcx
movq 0x50(%rdi), %rbx
movzwl 0x1(%rbx,%rax), %edi
rolw $0x8, %di
leaq 0x1(%rax), %rdx
movzwl %di, %r8d
movl 0x34(%rcx), %edi
leal -0x4(%rdi), %r9d
movl %r8d, %ecx
cmpl %r9d, %r8d
jg 0x43531a
movl %ecx, %r10d
movzwl 0x2(%rbx,%r10), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r11d
movl %r11d, %r8d
subl %esi, %r8d
jns 0x435345
movzwl (%rbx,%r10), %edx
rolw $0x8, %dx
movzwl %dx, %r8d
addl %ecx, %r11d
movl %ecx, %edx
cmpl %r11d, %r8d
jae 0x4352df
jmp 0x43531d
movl %ecx, %r8d
testl %r8d, %r8d
je 0x43538b
leaq 0x11b606(%rip), %rsi    # 0x55092f
leaq 0x11b722(%rip), %rdx    # 0x550a52
leaq 0x11b42f(%rip), %r8     # 0x550766
xorl %ebx, %ebx
movl $0xb, %edi
movl $0xfad8, %ecx           # imm = 0xFAD8
jmp 0x43536e
addl %ecx, %r11d
cmpl %edi, %r11d
jle 0x43537e
leaq 0x11b5db(%rip), %rsi    # 0x55092f
leaq 0x11b6f7(%rip), %rdx    # 0x550a52
leaq 0x11b404(%rip), %r8     # 0x550766
xorl %ebx, %ebx
movl $0xb, %edi
movl $0xfac1, %ecx           # imm = 0xFAC1
xorl %eax, %eax
callq 0x40765d
movl $0xb, (%r14)
jmp 0x4353b4
cmpl $0x3, %r8d
ja 0x43538f
cmpb $0x39, 0x7(%rbx,%rax)
jbe 0x43539e
xorl %ebx, %ebx
jmp 0x4353b4
movl %r8d, %eax
rolw $0x8, %ax
movw %ax, 0x2(%rbx,%r10)
jmp 0x4353ae
movl %edx, %edx
movzwl (%rbx,%r10), %esi
movw %si, (%rbx,%rdx)
addb %r8b, 0x7(%rbx,%rax)
addl %ecx, %r8d
addq %r8, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x43613c
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq 0x28(%rax), %rdi
callq 0x42fcc7
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x436137
movq 0x10(%r14), %rcx
movq 0x28(%rcx), %rcx
movzwl 0x6(%rcx), %ecx
movw %cx, 0x10(%rax)
movb $0x0, 0x13(%rax)
jmp 0x43613c
movl $0x7, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x436336
movl %eax, 0xc(%rsp)
jmp 0x436344
leaq 0x1(%r15), %rdi
leaq 0xc(%rsp), %rsi
callq 0x42ee0c
addq %r15, %rbx
addq %r14, %rbp
movsbl 0x1(%r14), %eax
testl %eax, %eax
jns 0x436368
leaq 0x1(%r14), %rdi
leaq 0x24(%rsp), %r12
movq %r12, %rsi
callq 0x42ee0c
movl (%r12), %eax
movl 0xc(%rsp), %ecx
movl %ecx, %r12d
subl %eax, %r12d
cmovll %ecx, %eax
movl %eax, %ecx
addl $-0xd, %ecx
shrl $0x1f, %ecx
addl %ecx, %eax
addl $-0xd, %eax
sarl %eax
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 0x4363b7
movq 0x18(%rcx), %rcx
movl %r12d, %eax
negl %eax
cmpb $0x0, (%rcx)
cmovel %r12d, %eax
jmp 0x4363e7
xorl %eax, %eax
cmpw $0x2, 0x6(%rcx)
jb 0x4363e7
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 0x436444
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movzwl 0x5e(%rdi), %ebp
cmpw $0x5, %bp
movl $0x5, %r15d
cmovbl %ebp, %r15d
movq 0x18(%rdi), %rax
movl 0x48(%rax), %ecx
movw %cx, (%r14)
leal -0xa(%rcx), %eax
cmpq $0x0, 0x48(%rdi)
cmovel %ecx, %eax
jne 0x437d0b
cmpw $0x20, %ax
jg 0x437d1b
cmpw $0x22, %ax
movl $0x21, %ecx
cmovgel %eax, %ecx
movw %cx, (%r14)
leaq 0x2(%r14), %rdi
leal (%r15,%r15), %eax
movzwl %ax, %edx
leaq 0x114f3d(%rip), %rsi    # 0x54cc6a
callq 0x401048
movzwl 0x5e(%rbx), %eax
cmpw %ax, %r15w
jae 0x437d5f
cmpw $0x5, %bp
movl $0x5, %eax
cmovbl %ebp, %eax
movzwl %ax, %ecx
movw $0x17, 0x2(%r14,%rcx,2)
incq %rcx
movzwl 0x5e(%rbx), %eax
cmpq %rax, %rcx
jb 0x437d4b
cmpb $0x0, 0x62(%rbx)
je 0x437d6f
movzwl %ax, %eax
movw $0x0, (%r14,%rax,2)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x4381a0
movq %r14, %rdi
callq 0x4381eb
movq 0x50(%rbx), %rsi
testq %rsi, %rsi
je 0x4381b1
movq %r14, %rdi
callq 0x4385eb
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x4381c2
movq %r14, %rdi
callq 0x415f0a
testb $0x10, 0x63(%rbx)
je 0x4381d9
movq 0x40(%rbx), %rsi
testq %rsi, %rsi
je 0x4381d9
movq %r14, %rdi
callq 0x415f0a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x415f0a
// File: /workspace/github_c_makefile_star2_O3/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 0x43823e
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x438215
cmpb $-0x5a, (%rbx)
je 0x438215
movq %r14, %rdi
callq 0x4381eb
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x438277
movq %r14, %rdi
callq 0x4381eb
movl 0x4(%rbx), %eax
btl $0xd, %eax
jb 0x43823e
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x4382a4
movl 0x4(%rbx), %eax
btl $0x10, %eax
jae 0x438258
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x438258
movq %r14, %rdi
callq 0x415f0a
movl 0x4(%rbx), %eax
testw %ax, %ax
js 0x43826f
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x415f0a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb $0x8, 0x5(%rbx)
movq 0x20(%rbx), %rsi
jne 0x438290
testq %rsi, %rsi
je 0x438226
movq %r14, %rdi
callq 0x4385eb
jmp 0x438226
testq %rsi, %rsi
je 0x438226
movq %r14, %rdi
movl $0x1, %edx
callq 0x43832f
jmp 0x438226
// File: /workspace/github_c_makefile_star2_O3/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 0x43832e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rsi
testq %rsi, %rsi
je 0x4382c8
movq %r14, %rdi
callq 0x4381eb
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x4382d9
movq %r14, %rdi
callq 0x4385eb
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x4382ea
movq %r14, %rdi
callq 0x4385eb
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x4382fb
movq %r14, %rdi
callq 0x4381eb
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x43830c
movq %r14, %rdi
callq 0x4381eb
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x43831c
movq %r14, %rdi
callq 0x415f0a
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x415f0a
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x438610
movq %r14, %rdi
callq 0x4381eb
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x438621
movq %r14, %rdi
callq 0x415f0a
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x438632
movq %r14, %rdi
callq 0x415f0a
addq $0x20, %r15
decl %ebp
cmpl $0x1, %ebp
jg 0x438600
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x415f0a
// File: /workspace/github_c_makefile_star2_O3/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 0x439262
movq 0x10(%rdi), %rax
movl %edx, %esi
shrl $0x3, %esi
movzbl (%rax,%rsi), %r8d
movl %edx, %ecx
andb $0x7, %cl
movl $0x1, %r9d
shll %cl, %r9d
movl $0x1, %ebx
movl %edx, %ecx
andl $0x7, %ecx
btl %ecx, %r8d
jae 0x439277
leaq 0x1183e6(%rip), %rsi    # 0x55163f
xorl %eax, %eax
callq 0x43886d
jmp 0x439280
leaq 0x1183bf(%rip), %rsi    # 0x551628
xorl %eax, %eax
callq 0x43886d
movl $0x1, %ebx
jmp 0x439280
orb %r8b, %r9b
movb %r9b, (%rax,%rsi)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3BtreeGetOptimalReserve
SQLITE_PRIVATE int sqlite3BtreeGetOptimalReserve(Btree *p){
  int n;
  sqlite3BtreeEnter(p);
  n = sqlite3BtreeGetReserveNoMutex(p);
#ifdef SQLITE_HAS_CODEC
  if( n<p->pBt->optimalReserve ) n = p->pBt->optimalReserve;
#endif
  sqlite3BtreeLeave(p);
  return n;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x11(%rdi)
je 0x43966a
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
je 0x439677
movq 0x8(%rbx), %rax
movl 0x30(%rax), %ebp
movl 0x34(%rax), %r14d
jmp 0x439690
movq 0x8(%rbx), %rax
movl 0x30(%rax), %ebp
movl 0x34(%rax), %r14d
jmp 0x43969d
movq %rbx, %rdi
callq 0x420275
cmpb $0x0, 0x11(%rbx)
movq 0x8(%rbx), %rax
movl 0x30(%rax), %ebp
movl 0x34(%rax), %r14d
je 0x43969d
decl 0x14(%rbx)
jne 0x43969d
movq %rbx, %rdi
callq 0x4202fb
subl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x2a, %eax
cmovnel %ecx, %eax
movq (%r15), %rdi
cmpl 0x90(%rdi), %eax
jle 0x43a756
movl $0x7, %eax
cmpb $0x0, 0x61(%rdi)
jne 0x43a7c5
cmpb $0x0, 0x62(%rdi)
jne 0x43a7c5
movb $0x1, 0x61(%rdi)
cmpl $0x0, 0xc4(%rdi)
jle 0x43a74e
movl $0x1, 0x158(%rdi)
incl 0x160(%rdi)
jmp 0x43a7c5
movq 0x68(%rbx), %rsi
cltq
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
callq 0x415f7d
testq %rax, %rax
je 0x43a7c0
movq %rax, %r14
movq (%r15), %rax
testq %rax, %rax
je 0x43a794
cmpq %r14, 0x188(%rax)
ja 0x43a794
cmpq %r14, 0x190(%rax)
jbe 0x43a794
movzwl 0x164(%rax), %eax
jmp 0x43a79d
movq %r14, %rdi
callq *0x1659db(%rip)         # 0x5a0178
movl %eax, 0x40(%r15)
cltq
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x4, %rdx
movl %edx, 0x3c(%r15)
movq %r14, 0x68(%rbx)
xorl %eax, %eax
jmp 0x43a7c5
movl $0x7, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x43ab44
movq %rbp, %rdi
callq 0x401100
movq %rax, %r15
andl $0x3fffffff, %r15d      # imm = 0x3FFFFFFF
jmp 0x43ab47
xorl %r15d, %r15d
leal 0x29(%r15), %edi
callq 0x4053ac
testq %rax, %rax
je 0x43abea
movq %rax, %r14
movq %rbx, 0x8(%rsp)
movq %r12, %rbx
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 %rbx, 0x18(%r14)
movq 0x8(%rsp), %rbx
movq $0x0, 0x20(%r14)
leaq 0x1c0(%rbx), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x437ed9
testq %rax, %rax
je 0x43ac16
cmpb $0x0, 0x61(%rbx)
jne 0x43abdd
cmpb $0x0, 0x62(%rbx)
jne 0x43abdd
movb $0x1, 0x61(%rbx)
cmpl $0x0, 0xc4(%rbx)
jle 0x43abd7
movl $0x1, 0x158(%rbx)
incl 0x160(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x415f0a
jmp 0x43ac13
cmpb $0x0, 0x61(%rbx)
jne 0x43ac13
cmpb $0x0, 0x62(%rbx)
jne 0x43ac13
movb $0x1, 0x61(%rbx)
cmpl $0x0, 0xc4(%rbx)
jle 0x43ac0d
movl $0x1, 0x158(%rbx)
incl 0x160(%rbx)
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_O3/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 $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq 0x138(%rdi), %rax
testq %rax, %rax
je 0x43fb5b
movq %rdx, %r13
movq %rcx, 0x8(%rsp)
movswq 0x46(%rax), %r12
shlq $0x5, %r12
addq 0x8(%rax), %r12
movb 0xb5(%r14), %al
addb $0x4, %al
movb %al, 0x34(%rsp)
leaq 0x120df(%rip), %rcx     # 0x451b74
movq %rcx, 0x18(%rsp)
leaq 0x1218d(%rip), %rcx     # 0x451c2e
movq %rcx, 0x20(%rsp)
movl $0x0, 0x38(%rsp)
testq %rbx, %rbx
je 0x43fac6
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x451c38
movb 0x24(%rbp), %al
testb %al, %al
je 0x43fb45
movq -0x18(%r12), %rsi
testq %rsi, %rsi
je 0x43fadc
movq %r14, %rdi
callq 0x4381eb
xorps %xmm0, %xmm0
leaq 0x10(%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
movq 0x8(%rsp), %rdx
callq 0x458bc9
movq %rax, 0x8(%rbp)
movq %rbx, 0x10(%rbp)
movl $0x1000, 0x4(%rbp)      # imm = 0x1000
movq %r14, %rdi
movq %rbp, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x452376
movq %rax, -0x18(%r12)
movq 0x8(%rbp), %rsi
testq %rsi, %rsi
je 0x43fb5b
movq %r14, %rdi
callq 0x415f0a
jmp 0x43fb5b
movq -0x20(%r12), %rdx
leaq 0x113191(%rip), %rsi    # 0x552ce2
movq %r15, %rdi
xorl %eax, %eax
callq 0x40e48a
cmpb $0x2, 0x10c(%r15)
jb 0x43fb95
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movq %r15, 0x10(%rsp)
leaq 0x190bd(%rip), %rax     # 0x458c3b
movq %rax, 0x18(%rsp)
testq %rbx, %rbx
je 0x43fb95
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x451c38
testq %rbx, %rbx
je 0x43fba5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4381eb
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x2c, %esi
jne 0x43fbd7
cmpl $0x0, 0x30(%r14)
je 0x43fc5b
movq (%r14), %rdi
movl $0x50, %esi
callq 0x415fb1
testq %rax, %rax
je 0x43fc3d
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movb %bpl, (%rax)
movw $0xffff, 0x32(%rax)     # imm = 0xFFFF
movq (%r14), %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x448a8a
movq (%r14), %rax
movl 0x88(%rax), %edx
cmpl 0x28(%rbx), %edx
jge 0x43fc4f
leaq 0x113024(%rip), %rsi    # 0x552c55
movq %r14, %rdi
xorl %eax, %eax
callq 0x40e48a
jmp 0x43fc4f
movq (%r14), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x448a8a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x458727
movq %rax, %rbx
testq %rax, %rax
jne 0x43fc1c
xorl %ebx, %ebx
jmp 0x43fc4f
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movl %ecx, %ebp
movq %rdx, (%rsp)
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rdi
movl %ecx, %r13d
leaq 0x51(%r13), %rsi
callq 0x415fb1
movq %rax, %r15
testq %rax, %rax
je 0x43fd68
movq %rax, %r12
movb %r14b, (%r15)
xorl %r14d, %r14d
movb %r14b, 0x1(%r15)
movl $0x800000, 0x4(%r15)    # imm = 0x800000
movb %r14b, 0x36(%r15)
movabsq $-0x1000000000000, %rax # imm = 0xFFFF000000000000
movq %rax, 0x2c(%r15)
addq $0x50, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %r14, 0x20(%r15)
movups %xmm0, 0x38(%r15)
movq %r14, 0x48(%r15)
movq %r12, 0x8(%r15)
movq %r12, %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0x401048
movb %r14b, 0x50(%r15,%r13)
movzbl 0x50(%r15), %eax
leaq 0x10c7c5(%rip), %rcx    # 0x54c4d0
cmpb %r14b, (%rax,%rcx)
jns 0x43fd25
cmpb $0x22, %al
jne 0x43fd1d
movl $0x800040, 0x4(%r15)    # imm = 0x800040
movq %r12, %rdi
callq 0x458b73
movl $0x1, 0x28(%r15)
cmpb $0x2, 0x10c(%rbx)
jb 0x43fd68
movq (%rbx), %rdi
movl $0x20, %esi
callq 0x40c786
testq %rax, %rax
je 0x43fd68
movq %r15, (%rax)
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq 0x190(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x190(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x112f83(%rip), %rsi    # 0x552d0f
movq %r14, %rdi
callq 0x4079b2
testl %eax, %eax
je 0x43fdaf
leaq 0x112f75(%rip), %rsi    # 0x552d14
movq %r14, %rdi
callq 0x4079b2
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x43fdb7
movb $-0x65, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rsi, %rsi
je 0x444326
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %rbx
movslq (%rsi), %r14
addq $0x8, %r15
decq %r14
movq (%rdx), %r13
testq %r13, %r13
je 0x4442af
movl %ecx, 0xc(%rsp)
movq %rbp, 0x10(%rsp)
movl 0x8(%rbp), %ebp
movq (%rbx), %rdi
leaq 0x1(%rbp), %rsi
callq 0x415fb1
testq %rax, %rax
je 0x4442b4
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x401048
movb $0x0, (%r12,%rbp)
jmp 0x4442b7
xorl %r12d, %r12d
jmp 0x4442c0
xorl %r12d, %r12d
movq 0x10(%rsp), %rbp
movl 0xc(%rsp), %ecx
shlq $0x5, %r14
movq %r12, 0x8(%r15,%r14)
testl %ecx, %ecx
je 0x4442d5
movq %r12, %rdi
callq 0x458b73
cmpb $0x2, 0x10c(%rbx)
jb 0x444318
leaq (%r15,%r14), %rax
addq $0x8, %rax
movq (%rax), %r14
movq (%rbx), %rdi
movl $0x20, %esi
callq 0x40c786
testq %rax, %rax
je 0x444318
movq %r14, (%rax)
movups (%rbp), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x190(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x190(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ExprListSetSpan
SQLITE_PRIVATE void sqlite3ExprListSetSpan(
  Parse *pParse,          /* Parsing context */
  ExprList *pList,        /* List to which to add the span. */
  const char *zStart,     /* Start of the span */
  const char *zEnd        /* End of the span */
){
  sqlite3 *db = pParse->db;
  assert( pList!=0 || db->mallocFailed!=0 );
  if( pList ){
    struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
    assert( pList->nExpr>0 );
    sqlite3DbFree(db, pItem->zSpan);
    pItem->zSpan = sqlite3DbSpanDup(db, zStart, zEnd);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x44437a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq (%rdi), %r15
movslq (%rsi), %rax
shlq $0x5, %rax
leaq (%rax,%rsi), %r12
addq $-0x8, %r12
movq (%r12), %rsi
testq %rsi, %rsi
je 0x44435d
movq %r15, %rdi
callq 0x415f0a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x458bc9
movq %rax, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x444567
movl (%rsi), %ecx
movq %r15, %rdi
movl $0x1, %edx
callq 0x461331
movq %rax, %rbx
jmp 0x4445af
movl $0x78, %esi
movq %r15, %rdi
callq 0x415fb1
testq %rax, %rax
je 0x4445c1
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)
movl $0xffffffff, 0x48(%rbx) # imm = 0xFFFFFFFF
cmpb $0x0, 0x61(%r15)
je 0x4445c5
movq %r15, %rdi
movq %rbx, %rsi
callq 0x438417
xorl %ebx, %ebx
jmp 0x444617
movslq (%rbx), %rax
imulq $0x70, %rax, %rax
leaq (%rax,%rbx), %r13
addq $-0x68, %r13
testq %r12, %r12
je 0x444600
cmpq $0x0, (%r12)
je 0x444600
movq %r15, %rdi
movq %r12, %rsi
callq 0x444624
movq %rax, 0x10(%r13)
movq %r15, %rdi
movq %r14, %rsi
callq 0x444624
movq %rax, 0x8(%r13)
jmp 0x444617
movq %r15, %rdi
movq %r14, %rsi
callq 0x444624
movq %rax, 0x10(%r13)
movq $0x0, 0x8(%r13)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x44dbe5
testq %rax, %rax
je 0x448fbb
movq %rax, %rbx
testq %r14, %r14
je 0x448f78
movq %rsp, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x453da3
movl %eax, %ebp
testl %eax, %eax
sets %al
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
je 0x448f7a
jmp 0x448fbb
xorl %ebp, %ebp
movq %rbx, %rdi
movl $0x8, %esi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x43a65f
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
orl %eax, 0xc4(%rbx)
movq (%rbx), %rcx
movq 0x20(%rcx), %rcx
movl %ebp, %edx
shlq $0x5, %rdx
movq 0x8(%rcx,%rdx), %rcx
cmpb $0x0, 0x11(%rcx)
je 0x448fbb
orl %eax, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3TriggerUpdateStep
SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(
  Parse *pParse,          /* Parser */
  Token *pTableName,   /* Name of the table to be updated */
  ExprList *pEList,    /* The SET clause: list of column and new values */
  Expr *pWhere,        /* The WHERE clause */
  u8 orconf,           /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */
  const char *zStart,  /* Start of SQL text */
  const char *zEnd     /* End of SQL text */
){
  sqlite3 *db = pParse->db;
  TriggerStep *pTriggerStep;

  pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd);
  if( pTriggerStep ){
    if( IN_RENAME_OBJECT ){
      pTriggerStep->pExprList = pEList;
      pTriggerStep->pWhere = pWhere;
      pEList = 0;
      pWhere = 0;
    }else{
      pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
      pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
    }
    pTriggerStep->orconf = orconf;
  }
  sqlite3ExprListDelete(db, pEList);
  sqlite3ExprDelete(db, pWhere);
  return pTriggerStep;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %rdx
movq %rdi, %r13
movq 0x40(%rsp), %r8
movq (%rdi), %r14
movl $0x76, %esi
movq %r9, %rcx
callq 0x474360
movq %rax, %r15
testq %rax, %rax
je 0x44c53b
cmpb $0x2, 0x10c(%r13)
jb 0x44c504
movq %r12, 0x28(%r15)
xorl %r12d, %r12d
movq %rbx, %rax
xorl %ebx, %ebx
jmp 0x44c533
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x4528d0
movq %rax, 0x28(%r15)
testq %rbx, %rbx
je 0x44c531
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x452376
jmp 0x44c533
xorl %eax, %eax
movq %rax, 0x20(%r15)
movb %bpl, 0x1(%r15)
testq %r12, %r12
je 0x44c54b
movq %r14, %rdi
movq %r12, %rsi
callq 0x4385eb
testq %rbx, %rbx
je 0x44c55b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4381eb
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq