LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r13d
movq %rsi, %rbx
movl 0x24(%rdx), %ecx
movl %ecx, %r14d
subl %r13d, %r14d
jle 0x435eb0
movq %rdx, %r15
movl %ebp, %r8d
subl %r14d, %r8d
movq %rdi, 0x10(%rsp)
jle 0x435ecd
movl %r14d, %esi
addq %rbx, %rsi
movq %r15, %rdx
callq 0x435e5b
movl %eax, %r12d
movl %eax, 0xc(%rsp)
testl %eax, %eax
cmovel %r14d, %ebp
jne 0x435f4f
jmp 0x435ecd
movb $0x1, %r15b
testl %ebp, %ebp
jle 0x435ecb
movl %ebp, %eax
xorl %r14d, %r14d
cmpb $0x0, (%rbx,%r14)
jne 0x435f1f
incq %r14
cmpq %r14, %rax
jne 0x435ebc
jmp 0x435f47
movslq %r13d, %r13
movq 0x10(%r15), %rsi
addq %r13, %rsi
movslq %ebp, %rbp
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x401028
testl %eax, %eax
je 0x435f4c
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x409e0b
movl %eax, %r14d
movl %eax, %r12d
testl %eax, %eax
jne 0x435f18
addq 0x10(%r15), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x401048
movl 0xc(%rsp), %r12d
testl %r14d, %r14d
jne 0x435f4f
jmp 0x435f4c
movq 0x70(%rdi), %rdi
callq 0x409e0b
movl %eax, %r12d
testl %eax, %eax
je 0x435f34
xorl %r15d, %r15d
jmp 0x435f47
addq %r14, %rbx
movslq %ebp, %rdx
subq %r14, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4010b8
testb %r15b, %r15b
je 0x435f4f
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: 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 0x4366be
movl %ecx, %r10d
movzwl 0x2(%rbx,%r10), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r11d
movl %r11d, %r8d
subl %esi, %r8d
jns 0x4366e9
movzwl (%rbx,%r10), %edx
rolw $0x8, %dx
movzwl %dx, %r8d
addl %ecx, %r11d
movl %ecx, %edx
cmpl %r11d, %r8d
jge 0x436683
jmp 0x4366c1
movl %ecx, %r8d
testl %r8d, %r8d
je 0x43672f
leaq 0x11a1da(%rip), %rsi    # 0x5508a7
leaq 0x11a2f6(%rip), %rdx    # 0x5509ca
leaq 0x11a003(%rip), %r8     # 0x5506de
xorl %ebx, %ebx
movl $0xb, %edi
movl $0xfad8, %ecx           # imm = 0xFAD8
jmp 0x436712
addl %ecx, %r11d
cmpl %edi, %r11d
jle 0x436722
leaq 0x11a1af(%rip), %rsi    # 0x5508a7
leaq 0x11a2cb(%rip), %rdx    # 0x5509ca
leaq 0x119fd8(%rip), %r8     # 0x5506de
xorl %ebx, %ebx
movl $0xb, %edi
movl $0xfac1, %ecx           # imm = 0xFAC1
xorl %eax, %eax
callq 0x40743a
movl $0xb, (%r14)
jmp 0x436758
cmpl $0x3, %r8d
jg 0x436733
cmpb $0x39, 0x7(%rbx,%rax)
jbe 0x436742
xorl %ebx, %ebx
jmp 0x436758
movl %r8d, %eax
rolw $0x8, %ax
movw %ax, 0x2(%rbx,%r10)
jmp 0x436752
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_O1/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 0x437566
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq 0x28(%rax), %rdi
callq 0x43058c
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x437561
movq 0x10(%r14), %rcx
movq 0x28(%rcx), %rcx
movzwl 0x6(%rcx), %ecx
movw %cx, 0x10(%rax)
movb $0x0, 0x13(%rax)
jmp 0x437566
movl $0x7, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x18, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %r14
movl %ecx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movzbl (%rdx), %ebx
movzbl (%r8), %ebp
movsbl 0x1(%rdx), %eax
testl %eax, %eax
js 0x437766
movl %eax, 0x4(%rsp)
jmp 0x437774
leaq 0x1(%r15), %rdi
leaq 0x4(%rsp), %rsi
callq 0x42f5e3
addq %r15, %rbx
addq %r14, %rbp
movsbl 0x1(%r14), %eax
testl %eax, %eax
js 0x437788
movl %eax, (%rsp)
jmp 0x437794
leaq 0x1(%r14), %rdi
movq %rsp, %rsi
callq 0x42f5e3
movl 0x4(%rsp), %eax
movl (%rsp), %ecx
movl %eax, %r12d
subl %ecx, %r12d
cmovll %eax, %ecx
movl %ecx, %eax
addl $-0xd, %eax
shrl $0x1f, %eax
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 0x4377e6
movq 0x18(%rcx), %rcx
movl %r12d, %eax
negl %eax
cmpb $0x0, (%rcx)
cmovel %r12d, %eax
jmp 0x437816
xorl %eax, %eax
cmpw $0x2, 0x6(%rcx)
jb 0x437816
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
movl 0x8(%rsp), %ecx
movq %r14, %r8
movl 0xc(%rsp), %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x437873
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: 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
movq 0x18(%rdi), %rax
movzwl 0x5e(%rdi), %ebp
cmpw $0x5, %bp
movl $0x5, %r15d
cmovbl %ebp, %r15d
movzwl 0x48(%rax), %eax
movw %ax, (%r14)
cmpq $0x0, 0x48(%rdi)
je 0x43919b
addl $-0xa, %eax
movw %ax, (%r14)
cmpw $0x20, (%r14)
jg 0x4391a8
movw $0x21, (%r14)
leaq 0x2(%r14), %rdi
leal (%r15,%r15), %eax
movzwl %ax, %edx
leaq 0x113ae0(%rip), %rsi    # 0x54cc9a
callq 0x401048
movzwl 0x5e(%rbx), %eax
cmpw %ax, %r15w
jae 0x4391ec
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 0x4391d8
cmpb $0x0, 0x62(%rbx)
je 0x4391fc
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_O1/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 0x43962d
movq %r14, %rdi
callq 0x439685
movq 0x50(%rbx), %rsi
testq %rsi, %rsi
je 0x43963e
movq %r14, %rdi
callq 0x439a79
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x43964f
movq %r14, %rdi
callq 0x415dca
testb $0x10, 0x63(%rbx)
je 0x439666
movq 0x40(%rbx), %rsi
testq %rsi, %rsi
je 0x439666
movq %r14, %rdi
callq 0x415dca
testq %rbx, %rbx
je 0x43967d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x415dca
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movzwl 0x5(%rsi), %eax
testl $0x8040, %eax           # imm = 0x8040
jne 0x4396d3
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x4396b0
cmpb $-0x5a, (%rbx)
je 0x4396b0
movq %r14, %rdi
callq 0x439685
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x43970a
movq %r14, %rdi
callq 0x439685
testb $0x20, 0x5(%rbx)
jne 0x4396d3
movq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x439737
testb $0x1, 0x6(%rbx)
je 0x4396ea
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x4396ea
movq %r14, %rdi
callq 0x415dca
testb $-0x80, 0x5(%rbx)
jne 0x439702
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x415dca
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testb $0x8, 0x5(%rbx)
movq 0x20(%rbx), %rsi
jne 0x439723
testq %rsi, %rsi
je 0x4396c1
movq %r14, %rdi
callq 0x439a79
jmp 0x4396c1
testq %rsi, %rsi
je 0x4396c1
movq %r14, %rdi
movl $0x1, %edx
callq 0x4397c2
jmp 0x4396c1
// File: /workspace/github_c_makefile_star2_O1/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 0x4397c1
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %rsi
testq %rsi, %rsi
je 0x43975b
movq %r14, %rdi
callq 0x439685
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x43976c
movq %r14, %rdi
callq 0x439a79
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x43977d
movq %r14, %rdi
callq 0x439a79
movq 0x28(%rbx), %rsi
testq %rsi, %rsi
je 0x43978e
movq %r14, %rdi
callq 0x439685
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x43979f
movq %r14, %rdi
callq 0x439685
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x4397af
movq %r14, %rdi
callq 0x415dca
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x415dca
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x439a9e
movq %r14, %rdi
callq 0x439685
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x439aaf
movq %r14, %rdi
callq 0x415dca
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x439ac0
movq %r14, %rdi
callq 0x415dca
addq $0x20, %r15
decl %ebp
cmpl $0x1, %ebp
jg 0x439a8e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x415dca
// File: /workspace/github_c_makefile_star2_O1/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 0x43a6db
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 0x43a6f0
leaq 0x116ee5(%rip), %rsi    # 0x5515b7
xorl %eax, %eax
callq 0x439cf7
jmp 0x43a6f9
leaq 0x116ebe(%rip), %rsi    # 0x5515a0
xorl %eax, %eax
callq 0x439cf7
movl $0x1, %ebx
jmp 0x43a6f9
orb %r8b, %r9b
movb %r9b, (%rax,%rsi)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x43aade
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x43aade
movq %rbx, %rdi
callq 0x42017c
movq 0x8(%rbx), %rax
movl 0x30(%rax), %ebp
movl 0x34(%rax), %r14d
cmpb $0x0, 0x11(%rbx)
je 0x43aafc
decl 0x14(%rbx)
jne 0x43aafc
movq %rbx, %rdi
callq 0x420202
subl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x43bbd7
movl $0x7, %eax
cmpb $0x0, 0x61(%rdi)
jne 0x43bc46
cmpb $0x0, 0x62(%rdi)
jne 0x43bc46
movb $0x1, 0x61(%rdi)
cmpl $0x0, 0xc4(%rdi)
jle 0x43bbcf
movl $0x1, 0x158(%rdi)
incl 0x160(%rdi)
jmp 0x43bc46
movq 0x68(%rbx), %rsi
cltq
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
callq 0x415e3d
testq %rax, %rax
je 0x43bc41
movq %rax, %r14
movq (%r15), %rax
testq %rax, %rax
je 0x43bc15
cmpq %r14, 0x188(%rax)
ja 0x43bc15
cmpq %r14, 0x190(%rax)
jbe 0x43bc15
movzwl 0x164(%rax), %eax
jmp 0x43bc1e
movq %r14, %rdi
callq *0x16455a(%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 0x43bc46
movl $0x7, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x43bfe6
movq %rbp, %rdi
callq 0x401100
movq %rax, %r15
andl $0x3fffffff, %r15d      # imm = 0x3FFFFFFF
jmp 0x43bfe9
xorl %r15d, %r15d
leal 0x29(%r15), %edi
callq 0x4052d6
testq %rax, %rax
je 0x43c08c
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 0x439361
testq %rax, %rax
je 0x43c0b8
cmpb $0x0, 0x61(%rbx)
jne 0x43c07f
cmpb $0x0, 0x62(%rbx)
jne 0x43c07f
movb $0x1, 0x61(%rbx)
cmpl $0x0, 0xc4(%rbx)
jle 0x43c079
movl $0x1, 0x158(%rbx)
incl 0x160(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x415dca
jmp 0x43c0b5
cmpb $0x0, 0x61(%rbx)
jne 0x43c0b5
cmpb $0x0, 0x62(%rbx)
jne 0x43c0b5
movb $0x1, 0x61(%rbx)
cmpl $0x0, 0xc4(%rbx)
jle 0x43c0af
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_O1/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 0x440f69
movq %rcx, %rbp
movq %rdx, %r13
movswq 0x46(%rax), %r12
shlq $0x5, %r12
addq 0x8(%rax), %r12
movb 0xb5(%r14), %al
addb $0x4, %al
movb %al, 0x34(%rsp)
leaq 0x11a3e(%rip), %rax     # 0x4528db
movq %rax, 0x18(%rsp)
leaq 0x11ae6(%rip), %rax     # 0x45298f
movq %rax, 0x20(%rsp)
movl $0x0, 0x38(%rsp)
testq %rbx, %rbx
je 0x440ec8
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x452999
cmpb $0x0, 0x34(%rsp)
je 0x440f53
movq %rbp, 0x8(%rsp)
movq -0x18(%r12), %rsi
testq %rsi, %rsi
je 0x440eea
movq %r14, %rdi
callq 0x439685
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 0x459a1e
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 0x453111
movq %rax, -0x18(%r12)
movq 0x8(%rbp), %rsi
testq %rsi, %rsi
je 0x440f69
movq %r14, %rdi
callq 0x415dca
jmp 0x440f69
movq -0x20(%r12), %rdx
leaq 0x111cff(%rip), %rsi    # 0x552c5e
movq %r15, %rdi
xorl %eax, %eax
callq 0x40e237
cmpb $0x2, 0x10c(%r15)
jb 0x440fa8
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %r15, 0x10(%rsp)
leaq 0x18aff(%rip), %rax     # 0x459a90
movq %rax, 0x18(%rsp)
testq %rbx, %rbx
je 0x440fa8
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x452999
testq %rbx, %rbx
je 0x440fb8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x439685
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: 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, %rbx
cmpl $0x2c, %esi
jne 0x440fe5
cmpl $0x0, 0x30(%rbx)
je 0x441061
movq (%rbx), %rdi
movl $0x50, %esi
callq 0x415e71
movq %rax, %r14
testq %rax, %rax
je 0x44101f
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movb %bpl, (%r14)
movw $0xffff, 0x32(%r14)     # imm = 0xFFFF
movq (%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x4497bc
testq %r14, %r14
je 0x441055
movq (%rbx), %rax
movl 0x88(%rax), %edx
cmpl 0x28(%r14), %edx
jge 0x441055
leaq 0x111b86(%rip), %rsi    # 0x552bd1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x40e237
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x459545
movq %rax, %r14
jmp 0x441030
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movl %esi, %r13d
movq %rdi, %rbx
movq (%rdi), %rdi
movl %ecx, %r12d
leaq 0x51(%r12), %rsi
callq 0x415e71
movq %rax, %r15
testq %rax, %rax
je 0x441160
movb %r13b, (%r15)
xorl %r13d, %r13d
movb %r13b, 0x1(%r15)
movl $0x800000, 0x4(%r15)    # imm = 0x800000
movb %r13b, 0x36(%r15)
movabsq $-0x1000000000000, %rax # imm = 0xFFFF000000000000
movq %rax, 0x2c(%r15)
movq %r15, %rdi
addq $0x50, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %r13, 0x20(%r15)
movups %xmm0, 0x38(%r15)
movq %r13, 0x48(%r15)
movq %rdi, 0x8(%r15)
movq %r14, %rsi
movq %r12, %rdx
callq 0x401048
movb %r13b, 0x50(%r15,%r12)
movzbl 0x50(%r15), %eax
leaq 0x10b3fa(%rip), %rcx    # 0x54c500
cmpb %r13b, (%rax,%rcx)
jns 0x441121
cmpb $0x22, %al
jne 0x441118
movl $0x800040, 0x4(%r15)    # imm = 0x800040
movq 0x8(%r15), %rdi
callq 0x4599c8
movl $0x1, 0x28(%r15)
cmpb $0x2, 0x10c(%rbx)
jb 0x441160
movq (%rbx), %rdi
movl $0x20, %esi
callq 0x40c57c
testq %rax, %rax
je 0x441160
movq %r15, (%rax)
movq %r14, 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_O1/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 0x111b07(%rip), %rsi    # 0x552c8b
movq %r14, %rdi
callq 0x407729
testl %eax, %eax
je 0x4411a7
leaq 0x111af9(%rip), %rsi    # 0x552c90
movq %r14, %rdi
callq 0x407729
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x4411af
movb $-0x65, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x44506f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movslq (%rsi), %rbp
addq $0x8, %r15
decq %rbp
movq (%rdx), %r13
testq %r13, %r13
movq %rdx, 0x10(%rsp)
je 0x445000
movl %ecx, 0xc(%rsp)
movl 0x8(%rdx), %r14d
movq (%rbx), %rdi
leaq 0x1(%r14), %rsi
callq 0x415e71
movq %rax, %r12
testq %rax, %rax
je 0x444ffa
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x401048
movb $0x0, (%r12,%r14)
movl 0xc(%rsp), %ecx
jmp 0x445003
xorl %r12d, %r12d
shlq $0x5, %rbp
movq %r12, 0x8(%r15,%rbp)
testl %ecx, %ecx
je 0x445018
movq %r12, %rdi
callq 0x4599c8
cmpb $0x2, 0x10c(%rbx)
movq 0x10(%rsp), %r12
jb 0x445061
leaq (%r15,%rbp), %rax
addq $0x8, %rax
movq (%rax), %r14
movq (%rbx), %rdi
movl $0x20, %esi
callq 0x40c57c
testq %rax, %rax
je 0x445061
movq %r14, (%rax)
movups (%r12), %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_O1/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 0x4450c3
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 0x4450a6
movq %r15, %rdi
callq 0x415dca
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x459a1e
movq %rax, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4452ac
movl (%rsi), %ecx
movq %r15, %rdi
movl $0x1, %edx
callq 0x462007
movq %rax, %rbx
jmp 0x4452f4
movl $0x78, %esi
movq %r15, %rdi
callq 0x415e71
testq %rax, %rax
je 0x445306
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 0x44530a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4398aa
xorl %ebx, %ebx
jmp 0x44536a
movslq (%rbx), %rax
imulq $0x70, %rax, %rax
testq %r12, %r12
je 0x445323
movq (%r12), %rcx
testq %rcx, %rcx
cmoveq %rcx, %r12
jmp 0x445326
xorl %r12d, %r12d
leaq (%rax,%rbx), %r13
addq $-0x68, %r13
testq %r12, %r12
je 0x445353
movq %r15, %rdi
movq %r12, %rsi
callq 0x445377
movq %rax, 0x10(%r13)
movq %r15, %rdi
movq %r14, %rsi
callq 0x445377
movq %rax, 0x8(%r13)
jmp 0x44536a
movq %r15, %rdi
movq %r14, %rsi
callq 0x445377
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_O1/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
movq %rsi, (%rsp)
callq 0x44e8aa
testq %rax, %rax
je 0x449c8f
movq %rax, %rbx
testq %r14, %r14
je 0x449c47
movq %rsp, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x454ab5
movl %eax, %ebp
testl %eax, %eax
jns 0x449c49
jmp 0x449c8f
xorl %ebp, %ebp
cmpl $0x1, %ebp
je 0x449c8f
movq %rbx, %rdi
movl $0x8, %esi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x43bae0
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 0x449c8f
orl %eax, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x474aca
movq %rax, %r15
testq %rax, %rax
je 0x44d1bd
cmpb $0x2, 0x10c(%r13)
jb 0x44d186
movq %r12, 0x28(%r15)
xorl %r12d, %r12d
movq %rbx, %rax
xorl %ebx, %ebx
jmp 0x44d1b5
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x453664
movq %rax, 0x28(%r15)
testq %rbx, %rbx
je 0x44d1b3
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x453111
jmp 0x44d1b5
xorl %eax, %eax
movq %rax, 0x20(%r15)
movb %bpl, 0x1(%r15)
testq %r12, %r12
je 0x44d1cd
movq %r14, %rdi
movq %r12, %rsi
callq 0x439a79
testq %rbx, %rbx
je 0x44d1dd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x439685
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_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3ExprCodeGetColumn
SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(
  Parse *pParse,   /* Parsing and code generating context */
  Table *pTab,     /* Description of the table we are reading from */
  int iColumn,     /* Index of the table column */
  int iTable,      /* The cursor pointing to the table */
  int iReg,        /* Store results here */
  u8 p5            /* P5 value for OP_Column + FLAGS */
){
  Vdbe *v = pParse->pVdbe;
  assert( v!=0 );
  sqlite3ExprCodeGetColumnOfTable(v, pTab, iTable, iColumn, iReg);
  if( p5 ){
    sqlite3VdbeChangeP5(v, p5);
  }
  return iReg;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r9d, %ebp
movl %r8d, %ebx
movl %edx, %eax
movq 0x10(%rdi), %r14
movq %r14, %rdi
movl %ecx, %edx
movl %eax, %ecx
callq 0x452088
testl %ebp, %ebp
je 0x450267
movslq 0xb8(%r14), %rax
testq %rax, %rax
jle 0x450267
movzbl %bpl, %ecx
movq 0x68(%r14), %rdx
leaq (%rax,%rax,2), %rax
movw %cx, -0x16(%rdx,%rax,8)
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x450658
movl 0x4(%r15), %eax
btl $0xc, %eax
jae 0x450658
btl $0x12, %eax
jb 0x450648
addq $0x10, %r15
jmp 0x450650
movq 0x20(%r15), %r15
addq $0x8, %r15
movq (%r15), %r15
testq %r15, %r15
jne 0x450632
cmpb $0x0, 0x23(%r14)
je 0x4506ba
cmpb $-0x5c, (%r15)
je 0x4506ba
movq %rsp, %r12
movb $0x2, 0x24(%r12)
leaq 0x2266(%rip), %rax      # 0x4528db
movq %rax, 0x8(%r12)
leaq 0x230e(%rip), %rax      # 0x45298f
movq %rax, 0x10(%r12)
movl $0x0, 0x28(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x452999
cmpb $0x0, 0x24(%r12)
je 0x4506ba
movl $0x0, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x450809
jmp 0x450716
movb 0x1f(%r14), %al
testb %al, %al
je 0x4506d5
decb %al
movb %al, 0x1f(%r14)
movzbl %al, %eax
movl 0xc4(%r14,%rax,4), %ebp
jmp 0x4506df
movl 0x38(%r14), %ebp
incl %ebp
movl %ebp, 0x38(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x44ef27
cmpl %ebp, %eax
jne 0x4506f4
movl %ebp, %ecx
jmp 0x450714
xorl %ecx, %ecx
testl %ebp, %ebp
je 0x450714
movzbl 0x1f(%r14), %edx
cmpq $0x7, %rdx
ja 0x450714
leal 0x1(%rdx), %esi
movb %sil, 0x1f(%r14)
movl %ebp, 0xc4(%r14,%rdx,4)
movl %ecx, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ukontainer[P]sqlite-bench/sqlite3.c
// Function: 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, %r15
movq 0x58(%rdi), %r14
testl %edx, %edx
sets %al
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x450888
movq %r15, (%rsp)
movl (%r14), %ebp
testl %ebp, %ebp
setle %r13b
jle 0x450879
incl %ebp
movq %r14, %r15
addq $0x24, %r15
testb $0x4, -0x3(%r15)
je 0x450868
movq -0x1c(%r15), %rsi
xorl %edi, %edi
movq %r12, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x452c53
testl %eax, %eax
je 0x45087b
decl %ebp
addq $0x20, %r15
cmpl $0x2, %ebp
setl %r13b
jge 0x45084a
jmp 0x45087e
jmp 0x45087e
movl (%r15), %eax
testb $0x1, %r13b
movq (%rsp), %r15
je 0x4508f2
testq %r12, %r12
je 0x4508a1
movq (%r15), %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x453111
movq %rax, %rdx
jmp 0x4508a3
xorl %edx, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x444ece
testq %rax, %rax
je 0x4508ec
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 0x4508e9
movl 0x38(%r15), %ebx
incl %ebx
movl %ebx, 0x38(%r15)
movl %ebx, 0x1c(%rcx)
movq %rax, 0x58(%r15)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq