LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: setChildPtrmaps
static int setChildPtrmaps(MemPage *pPage){
  int i;                             /* Counter variable */
  int nCell;                         /* Number of cells in page pPage */
  int rc;                            /* Return code */
  BtShared *pBt = pPage->pBt;
  Pgno pgno = pPage->pgno;

  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  rc = pPage->isInit ? SQLITE_OK : btreeInitPage(pPage);
  if( rc!=SQLITE_OK ) return rc;
  nCell = pPage->nCell;

  for(i=0; i<nCell; i++){
    u8 *pCell = findCell(pPage, i);

    ptrmapPutOvflPtr(pPage, pPage, pCell, &rc);

    if( !pPage->leaf ){
      Pgno childPgno = get4byte(pCell);
      ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
    }
  }

  if( !pPage->leaf ){
    Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
    ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
  }

  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x48(%rdi), %r14
movl 0x4(%rdi), %eax
movl %eax, 0x4(%rsp)
xorl %eax, %eax
cmpb $0x0, (%rdi)
jne 0x299111
movq %r15, %rdi
callq 0x294e54
movl %eax, (%rsp)
testl %eax, %eax
jne 0x2991b2
movzwl 0x18(%r15), %ebp
testq %rbp, %rbp
je 0x299185
xorl %ebx, %ebx
movq %rsp, %r12
movzwl 0x1a(%r15), %eax
movq 0x60(%r15), %rcx
movzbl (%rcx,%rbx,2), %edx
shll $0x8, %edx
movzbl 0x1(%rcx,%rbx,2), %r13d
orl %edx, %r13d
andl %eax, %r13d
addq 0x50(%r15), %r13
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x2996f1
cmpb $0x0, 0x8(%r15)
jne 0x29917d
movl (%r13), %esi
bswapl %esi
movq %r14, %rdi
movl $0x5, %edx
movl 0x4(%rsp), %ecx
movq %r12, %r8
callq 0x2991c1
incq %rbx
cmpq %rbx, %rbp
jne 0x29912b
cmpb $0x0, 0x8(%r15)
jne 0x2991af
movq 0x50(%r15), %rax
movzbl 0x9(%r15), %ecx
movl 0x8(%rax,%rcx), %esi
bswapl %esi
movq %rsp, %r8
movq %r14, %rdi
movl $0x5, %edx
movl 0x4(%rsp), %ecx
callq 0x2991c1
movl (%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3PcacheMove
SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
  PCache *pCache = p->pCache;
  assert( p->nRef>0 );
  assert( newPgno>0 );
  assert( sqlite3PcachePageSanity(p) );
  pcacheTrace(("%p.MOVE %d -> %d\n",pCache,p->pgno,newPgno));
  sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno);
  p->pgno = newPgno;
  if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){
    pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT);
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x18(%rdi), %rax
movq 0x40(%rax), %rdi
movl 0x30(%rbx), %edx
movl %ebp, %ecx
callq *0x22d173(%rip)         # 0x4c6750
movl %ebp, 0x30(%rbx)
movl 0x34(%rbx), %eax
notl %eax
testb $0xa, %al
jne 0x2995fc
movq %rbx, %rdi
movl $0x3, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x292ab5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: ptrmapPutOvflPtr
static void ptrmapPutOvflPtr(MemPage *pPage, MemPage *pSrc, u8 *pCell,int *pRC){
  CellInfo info;
  if( *pRC ) return;
  assert( pCell!=0 );
  pPage->xParseCell(pPage, pCell, &info);
  if( info.nLocal<info.nPayload ){
    Pgno ovfl;
    if( SQLITE_WITHIN(pSrc->aDataEnd, pCell, pCell+info.nLocal) ){
      testcase( pSrc!=pPage );
      *pRC = SQLITE_CORRUPT_BKPT;
      return;
    }
    ovfl = get4byte(&pCell[info.nSize-4]);
    ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
  }
}

// Assembly:
cmpl $0x0, (%rcx)
je 0x2996f7
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x8(%rsp), %r13
movq %rdx, %rsi
movq %r13, %rdx
callq *0x80(%rdi)
movzwl 0x14(%r13), %eax
cmpl %eax, 0x10(%r13)
jbe 0x29978d
movq 0x58(%r12), %rcx
cmpq %r15, %rcx
jb 0x29976c
addq %r15, %rax
cmpq %rax, %rcx
jae 0x29976c
leaq 0x145bda(%rip), %rsi    # 0x3df31f
leaq 0x145ce4(%rip), %rdx    # 0x3df430
leaq 0x145a32(%rip), %r8     # 0x3df185
movl $0xb, %edi
movl $0x1014d, %ecx          # imm = 0x1014D
xorl %eax, %eax
callq 0x27e637
movl $0xb, (%rbx)
jmp 0x29978d
movzwl 0x1e(%rsp), %eax
movl -0x4(%r15,%rax), %esi
bswapl %esi
movq 0x48(%r14), %rdi
movl 0x4(%r14), %ecx
movl $0x3, %edx
movq %rbx, %r8
callq 0x2991c1
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BtreeTripAllCursors
SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode, int writeOnly){
  BtCursor *p;
  int rc = SQLITE_OK;

  assert( (writeOnly==0 || writeOnly==1) && BTCF_WriteFlag==1 );
  if( pBtree ){
    sqlite3BtreeEnter(pBtree);
    for(p=pBtree->pBt->pCursor; p; p=p->pNext){
      if( writeOnly && (p->curFlags & BTCF_WriteFlag)==0 ){
        if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
          rc = saveCursorPosition(p);
          if( rc!=SQLITE_OK ){
            (void)sqlite3BtreeTripAllCursors(pBtree, rc, 0);
            break;
          }
        }
      }else{
        sqlite3BtreeClearCursor(p);
        p->eState = CURSOR_FAULT;
        p->skipNext = errCode;
      }
      btreeReleaseAllCursorPages(p);
    }
    sqlite3BtreeLeave(pBtree);
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x299824
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rcx), %r15
testq %r15, %r15
je 0x299824
testl %ebp, %ebp
je 0x2997eb
testb $0x1, 0x1(%r15)
jne 0x2997eb
movzbl (%r15), %eax
testb $-0x3, %al
jne 0x299804
movq %r15, %rdi
callq 0x297cd2
testl %eax, %eax
je 0x299804
jmp 0x299812
movq 0x18(%r15), %rdi
callq 0x27c490
movq $0x0, 0x18(%r15)
movb $0x4, (%r15)
movl %r14d, 0x4(%r15)
movq %r15, %rdi
callq 0x297d1a
movq 0x28(%r15), %r15
jmp 0x2997c5
testb $0x1, %r13b
cmovel %eax, %r12d
movb $0x1, %r13b
xorl %ebp, %ebp
movl %eax, %r14d
jmp 0x2997b1
xorl %eax, %eax
testb $0x1, %r13b
cmovnel %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: releaseMemArray
static void releaseMemArray(Mem *p, int N){
  if( p && N ){
    Mem *pEnd = &p[N];
    sqlite3 *db = p->db;
    if( db->pnBytesFreed ){
      do{
        if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
      }while( (++p)<pEnd );
      return;
    }
    do{
      assert( (&p[1])==pEnd || p[0].db==p[1].db );
      assert( sqlite3VdbeCheckMemInvariants(p) );

      /* This block is really an inlined version of sqlite3VdbeMemRelease()
      ** that takes advantage of the fact that the memory cell value is
      ** being set to NULL after releasing any dynamic resources.
      **
      ** The justification for duplicating code is that according to
      ** callgrind, this causes a certain test case to hit the CPU 4.7
      ** percent less (x86 linux, gcc version 4.1.2, -O6) than if
      ** sqlite3MemRelease() were called from here. With -O2, this jumps
      ** to 6.6 percent. The test case is inserting 1000 rows into a table
      ** with no indexes using a single prepared INSERT statement, bind()
      ** and reset(). Inserts are grouped into a transaction.
      */
      testcase( p->flags & MEM_Agg );
      testcase( p->flags & MEM_Dyn );
      testcase( p->xDel==sqlite3VdbeFrameMemDel );
      if( p->flags&(MEM_Agg|MEM_Dyn) ){
        sqlite3VdbeMemRelease(p);
      }else if( p->szMalloc ){
        sqlite3DbFreeNN(db, p->zMalloc);
        p->szMalloc = 0;
      }

      p->flags = MEM_Undefined;
    }while( (++p)<pEnd );
  }
}

// Assembly:
testq %rdi, %rdi
sete %al
testl %esi, %esi
sete %cl
orb %al, %cl
jne 0x2998cb
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %esi, %rax
imulq $0x38, %rax, %r15
addq %rdi, %r15
movq 0x28(%rdi), %r14
cmpq $0x0, 0x2d0(%r14)
je 0x29988e
cmpl $0x0, 0x20(%rbx)
je 0x299883
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x299883
movq %r14, %rdi
callq 0x28c3e7
addq $0x38, %rbx
cmpq %r15, %rbx
jb 0x29986c
jmp 0x2998c6
testb $0x24, 0x9(%rbx)
je 0x29989e
movq %rbx, %rdi
callq 0x29b45b
jmp 0x2998b7
cmpl $0x0, 0x20(%rbx)
je 0x2998b7
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x28c3e7
movl $0x0, 0x20(%rbx)
movw $0x80, 0x8(%rbx)
addq $0x38, %rbx
cmpq %r15, %rbx
jb 0x29988e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeFreeOpArray
static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
  if( aOp ){
    Op *pOp;
    for(pOp=&aOp[nOp-1]; pOp>=aOp; pOp--){
      if( pOp->p4type <= P4_FREE_IF_LE ) freeP4(db, pOp->p4type, pOp->p4.p);
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
      sqlite3DbFree(db, pOp->zComment);
#endif
    }
    sqlite3DbFreeNN(db, aOp);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x29991c
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %rax
leaq (%rax,%rax,2), %rax
leaq (%rsi,%rax,8), %r15
addq $-0x18, %r15
cmpq %rbx, %r15
jb 0x29990c
movsbl 0x1(%r15), %esi
cmpl $-0x7, %esi
jg 0x299906
movq 0x10(%r15), %rdx
movq %r14, %rdi
callq 0x29991d
addq $-0x18, %r15
jmp 0x2998eb
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x28c3e7
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VtabModuleUnref
SQLITE_PRIVATE void sqlite3VtabModuleUnref(sqlite3 *db, Module *pMod){
  assert( pMod->nRefModule>0 );
  pMod->nRefModule--;
  if( pMod->nRefModule==0 ){
    if( pMod->xDestroy ){
      pMod->xDestroy(pMod->pAux);
    }
    assert( pMod->pEpoTab==0 );
    sqlite3DbFree(db, pMod);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
decl 0x10(%rsi)
je 0x299a48
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x299a5d
movq 0x18(%rbx), %rdi
callq *%rax
testq %rbx, %rbx
je 0x299a40
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3e7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeDelete
SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){
  sqlite3 *db;

  assert( p!=0 );
  db = p->db;
  assert( sqlite3_mutex_held(db->mutex) );
  sqlite3VdbeClearObject(db, p);
  if( p->pPrev ){
    p->pPrev->pNext = p->pNext;
  }else{
    assert( db->pVdbe==p );
    db->pVdbe = p->pNext;
  }
  if( p->pNext ){
    p->pNext->pPrev = p->pPrev;
  }
  p->magic = VDBE_MAGIC_DEAD;
  p->db = 0;
  sqlite3DbFreeNN(db, p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27bd96
movq 0x8(%rbx), %rax
leaq 0x8(%r14), %rcx
leaq 0x10(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq 0x10(%rbx), %rcx
movq %rcx, (%rdx)
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x299afa
movq %rax, 0x8(%rcx)
movl $0x5606c3c8, 0x24(%rbx) # imm = 0x5606C3C8
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28c3e7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: apiOomError
SQLITE_PRIVATE void sqlite3OomClear(sqlite3 *db){
  if( db->mallocFailed && db->nVdbeExec==0 ){
    db->mallocFailed = 0;
    AtomicStore(&db->u1.isInterrupted, 0);
    assert( db->lookaside.bDisable>0 );
    EnableLookaside;
  }
}

// Assembly:
cmpb $0x0, 0x61(%rdi)
je 0x299b51
cmpl $0x0, 0xcc(%rdi)
jne 0x299b51
movb $0x0, 0x61(%rdi)
movl $0x0, 0x168(%rdi)
decl 0x170(%rdi)
je 0x299b43
xorl %eax, %eax
jmp 0x299b4a
movzwl 0x176(%rdi), %eax
movw %ax, 0x174(%rdi)
movl $0x7, 0x50(%rdi)
movl $0x7, %esi
jmp 0x28e696
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeTransferError
SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){
  sqlite3 *db = p->db;
  int rc = p->rc;
  if( p->zErrMsg ){
    db->bBenignMalloc++;
    sqlite3BeginBenignMalloc();
    if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
    sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
    sqlite3EndBenignMalloc();
    db->bBenignMalloc--;
  }else if( db->pErr ){
    sqlite3ValueSetNull(db->pErr);
  }
  db->errCode = rc;
  return rc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movl 0x38(%rdi), %ebp
cmpq $0x0, 0xa8(%rdi)
je 0x29a061
movq %rdi, %r14
incb 0x62(%rbx)
movq 0x22fe5f(%rip), %rax    # 0x4c9e48
testq %rax, %rax
je 0x299ff0
callq *%rax
cmpq $0x0, 0x160(%rbx)
jne 0x29a01d
movl $0x38, %esi
movq %rbx, %rdi
callq 0x283569
testq %rax, %rax
je 0x29a016
movw $0x1, 0x8(%rax)
movq %rbx, 0x28(%rax)
movq %rax, 0x160(%rbx)
movq 0x160(%rbx), %rdi
testq %rdi, %rdi
je 0x29a046
movq 0xa8(%r14), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
movq $-0x1, %r8
callq 0x281f27
movq 0x22fe03(%rip), %rax    # 0x4c9e50
testq %rax, %rax
je 0x29a054
callq *%rax
decb 0x62(%rbx)
movl %ebp, 0x50(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x160(%rbx), %rdi
testq %rdi, %rdi
je 0x29a057
testb $0x24, 0x9(%rdi)
je 0x29a07a
callq 0x29b491
jmp 0x29a057
movw $0x1, 0x8(%rdi)
jmp 0x29a057
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeEnter
SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe *p){
  int i;
  sqlite3 *db;
  Db *aDb;
  int nDb;
  if( DbMaskAllZero(p->lockMask) ) return;  /* The common case */
  db = p->db;
  aDb = db->aDb;
  nDb = db->nDb;
  for(i=0; i<nDb; i++){
    if( i!=1 && DbMaskTest(p->lockMask,i) && ALWAYS(aDb[i].pBt!=0) ){
      sqlite3BtreeEnter(aDb[i].pBt);
    }
  }
}

// Assembly:
movl 0xcc(%rdi), %eax
testl %eax, %eax
je 0x29a0cc
movq (%rdi), %rdx
movslq 0x28(%rdx), %rcx
testq %rcx, %rcx
jle 0x29a0cc
movq 0x20(%rdx), %rdx
addq $0x8, %rdx
xorl %esi, %esi
cmpq $0x1, %rsi
je 0x29a0c0
btl %esi, %eax
jae 0x29a0c0
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x29a0c0
movq (%rdi), %r8
movq 0x8(%rdi), %rdi
movq %r8, 0x8(%rdi)
incq %rsi
addq $0x20, %rdx
cmpq %rsi, %rcx
jne 0x29a0a2
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeFrameRestore
SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *pFrame){
  Vdbe *v = pFrame->v;
  closeCursorsInFrame(v);
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
  v->anExec = pFrame->anExec;
#endif
  v->aOp = pFrame->aOp;
  v->nOp = pFrame->nOp;
  v->aMem = pFrame->aMem;
  v->nMem = pFrame->nMem;
  v->apCsr = pFrame->apCsr;
  v->nCursor = pFrame->nCursor;
  v->db->lastRowid = pFrame->lastRowid;
  v->nChange = pFrame->nChange;
  v->db->nChange = pFrame->nDbChange;
  sqlite3VdbeDeleteAuxData(v->db, &v->pAuxData, -1, 0);
  v->pAuxData = pFrame->pAuxData;
  pFrame->pAuxData = 0;
  return pFrame->pc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
callq 0x29aadb
movq 0x10(%rbx), %rax
movq %rax, 0x88(%r14)
movl 0x58(%rbx), %eax
movl %eax, 0x90(%r14)
movq 0x20(%rbx), %rax
movq %rax, 0x68(%r14)
movl 0x5c(%rbx), %eax
movl %eax, 0x28(%r14)
movq 0x28(%rbx), %rax
movq %rax, 0x78(%r14)
movl 0x50(%rbx), %eax
movl %eax, 0x2c(%r14)
movq 0x40(%rbx), %rax
movq (%r14), %rdi
movq %rax, 0x38(%rdi)
movl 0x68(%rbx), %eax
movl %eax, 0x3c(%r14)
movl 0x6c(%rbx), %eax
movl %eax, 0x74(%rdi)
leaq 0x120(%r14), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x29ab27
movq 0x48(%rbx), %rax
movq %rax, 0x120(%r14)
movq $0x0, 0x48(%rbx)
movl 0x54(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: closeCursorsInFrame
static void closeCursorsInFrame(Vdbe *p){
  if( p->apCsr ){
    int i;
    for(i=0; i<p->nCursor; i++){
      VdbeCursor *pC = p->apCsr[i];
      if( pC ){
        sqlite3VdbeFreeCursor(p, pC);
        p->apCsr[i] = 0;
      }
    }
  }
}

// Assembly:
cmpq $0x0, 0x78(%rdi)
je 0x29ab26
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x2c(%rdi)
jle 0x29ab1f
xorl %r14d, %r14d
movq 0x78(%rbx), %rax
movq (%rax,%r14,8), %rsi
testq %rsi, %rsi
je 0x29ab13
movq %rbx, %rdi
callq 0x29ab9c
movq 0x78(%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
movslq 0x2c(%rbx), %rax
cmpq %rax, %r14
jl 0x29aaf2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeDeleteAuxData
SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(sqlite3 *db, AuxData **pp, int iOp, int mask){
  while( *pp ){
    AuxData *pAux = *pp;
    if( (iOp<0)
     || (pAux->iAuxOp==iOp
          && pAux->iAuxArg>=0
          && (pAux->iAuxArg>31 || !(mask & MASKBIT32(pAux->iAuxArg))))
    ){
      testcase( pAux->iAuxArg==31 );
      if( pAux->xDeleteAux ){
        pAux->xDeleteAux(pAux->pAux);
      }
      *pp = pAux->pNextAux;
      sqlite3DbFree(db, pAux);
    }else{
      pp= &pAux->pNextAux;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x29ab93
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
testl %ebp, %ebp
js 0x29ab67
cmpl %ebp, (%r12)
jne 0x29ab5e
movl 0x4(%r12), %eax
testl %eax, %eax
js 0x29ab5e
cmpl $0x1f, %eax
jg 0x29ab67
btl %eax, %ebx
jae 0x29ab67
addq $0x18, %r12
movq %r12, %r15
jmp 0x29ab8b
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x29ab78
movq 0x8(%r12), %rdi
callq *%rax
movq 0x18(%r12), %rax
movq %rax, (%r15)
movq %r14, %rdi
movq %r12, %rsi
callq 0x28c3e7
movq (%r15), %r12
testq %r12, %r12
jne 0x29ab41
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeFreeCursor
SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
  if( pCx==0 ){
    return;
  }
  assert( pCx->pBtx==0 || pCx->eCurType==CURTYPE_BTREE );
  switch( pCx->eCurType ){
    case CURTYPE_SORTER: {
      sqlite3VdbeSorterClose(p->db, pCx);
      break;
    }
    case CURTYPE_BTREE: {
      if( pCx->isEphemeral ){
        if( pCx->pBtx ) sqlite3BtreeClose(pCx->pBtx);
        /* The pCx->pCursor will be close automatically, if it exists, by
        ** the call above. */
      }else{
        assert( pCx->uc.pCursor!=0 );
        sqlite3BtreeCloseCursor(pCx->uc.pCursor);
      }
      break;
    }
#ifndef SQLITE_OMIT_VIRTUALTABLE
    case CURTYPE_VTAB: {
      sqlite3_vtab_cursor *pVCur = pCx->uc.pVCur;
      const sqlite3_module *pModule = pVCur->pVtab->pModule;
      assert( pVCur->pVtab->nRef>0 );
      pVCur->pVtab->nRef--;
      pModule->xClose(pVCur);
      break;
    }
#endif
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x29ac2c
movq %rsi, %rbx
movzbl (%rsi), %eax
testl %eax, %eax
je 0x29ac08
cmpl $0x2, %eax
je 0x29abf3
cmpl $0x1, %eax
jne 0x29ac2c
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x29ac2c
movq (%rdi), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x29addf
movq 0x40(%r14), %rdi
callq 0x27c490
movq %r15, %rdi
movq %r14, %rsi
callq 0x28c3e7
movq $0x0, 0x30(%rbx)
jmp 0x29ac2c
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %rcx
decl 0x8(%rax)
popq %rbx
popq %r14
popq %r15
jmpq *0x38(%rcx)
testb $0x1, 0x5(%rbx)
jne 0x29ac1c
movq 0x30(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x29ad48
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x29ac2c
popq %rbx
popq %r14
popq %r15
jmp 0x29ac32
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BtreeCloseCursor
SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
  Btree *pBtree = pCur->pBtree;
  if( pBtree ){
    BtShared *pBt = pCur->pBt;
    sqlite3BtreeEnter(pBtree);
    assert( pBt->pCursor!=0 );
    if( pBt->pCursor==pCur ){
      pBt->pCursor = pCur->pNext;
    }else{
      BtCursor *pPrev = pBt->pCursor;
      do{
        if( pPrev->pNext==pCur ){
          pPrev->pNext = pCur->pNext;
          break;
        }
        pPrev = pPrev->pNext;
      }while( ALWAYS(pPrev) );
    }
    btreeReleaseAllCursorPages(pCur);
    unlockBtreeIfUnused(pBt);
    sqlite3_free(pCur->aOverflow);
    sqlite3_free(pCur->pKey);
    sqlite3BtreeLeave(pBtree);
    pCur->pBtree = 0;
  }
  return SQLITE_OK;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x29adde
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%r14), %rax
cmpq %rdi, %rax
je 0x29ad87
movq 0x28(%rax), %rcx
cmpq %rbx, %rcx
je 0x29ad8d
movq %rcx, %rax
testq %rcx, %rcx
jne 0x29ad74
jmp 0x29ad98
leaq 0x10(%r14), %rax
jmp 0x29ad91
addq $0x28, %rax
movq 0x28(%rbx), %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
callq 0x297d1a
cmpb $0x0, 0x24(%r14)
jne 0x29adbd
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x29adbd
movq $0x0, 0x18(%r14)
callq 0x296c8e
movq 0x10(%rbx), %rdi
callq 0x27c490
movq 0x18(%rbx), %rdi
callq 0x27c490
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeSorterReset
SQLITE_PRIVATE void sqlite3VdbeSorterReset(sqlite3 *db, VdbeSorter *pSorter){
  int i;
  (void)vdbeSorterJoinAll(pSorter, SQLITE_OK);
  assert( pSorter->bUseThreads || pSorter->pReader==0 );
#if SQLITE_MAX_WORKER_THREADS>0
  if( pSorter->pReader ){
    vdbePmaReaderClear(pSorter->pReader);
    sqlite3DbFree(db, pSorter->pReader);
    pSorter->pReader = 0;
  }
#endif
  vdbeMergeEngineFree(pSorter->pMerger);
  pSorter->pMerger = 0;
  for(i=0; i<pSorter->nTask; i++){
    SortSubtask *pTask = &pSorter->aTask[i];
    vdbeSortSubtaskCleanup(db, pTask);
    pTask->pSorter = pSorter;
  }
  if( pSorter->list.aMemory==0 ){
    vdbeSorterRecordFree(0, pSorter->list.pList);
  }
  pSorter->list.pList = 0;
  pSorter->list.szPMA = 0;
  pSorter->bUsePMA = 0;
  pSorter->iMemory = 0;
  pSorter->mxKeysize = 0;
  sqlite3DbFree(db, pSorter->pUnpacked);
  pSorter->pUnpacked = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rdi
callq 0x29af28
movq $0x0, 0x18(%rbx)
cmpb $0x0, 0x5b(%rbx)
je 0x29aec8
leaq 0x60(%rbx), %r12
xorl %r13d, %r13d
imulq $0x68, %r13, %rbp
movq 0x18(%r12,%rbp), %rsi
testq %rsi, %rsi
je 0x29ae28
movq %r14, %rdi
callq 0x28c3e7
addq %r12, %rbp
movq 0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x29ae45
movq 0x8(%rdi), %r15
callq 0x27c490
movq %r15, %rdi
testq %r15, %r15
jne 0x29ae34
movq 0x48(%rbp), %r15
testq %r15, %r15
je 0x29ae6b
movq (%r15), %rax
testq %rax, %rax
je 0x29ae63
movq %r15, %rdi
callq *0x8(%rax)
movq $0x0, (%r15)
movq %r15, %rdi
callq 0x27c490
movq 0x58(%rbp), %r15
testq %r15, %r15
je 0x29ae91
movq (%r15), %rax
testq %rax, %rax
je 0x29ae89
movq %r15, %rdi
callq *0x8(%rax)
movq $0x0, (%r15)
movq %r15, %rdi
callq 0x27c490
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbp)
movups %xmm0, 0x50(%rbp)
movups %xmm0, 0x40(%rbp)
movups %xmm0, 0x30(%rbp)
movups %xmm0, 0x20(%rbp)
movups %xmm0, (%rbp)
movq $0x0, 0x60(%rbp)
movq %rbx, 0x10(%rbp)
incq %r13
movzbl 0x5b(%rbx), %eax
cmpq %rax, %r13
jb 0x29ae12
cmpq $0x0, 0x40(%rbx)
jne 0x29aee9
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x29aee9
movq 0x8(%rdi), %r15
callq 0x27c490
movq %r15, %rdi
testq %r15, %r15
jne 0x29aed8
movq $0x0, 0x38(%rbx)
xorl %eax, %eax
movl %eax, 0x48(%rbx)
movb $0x0, 0x58(%rbx)
movl %eax, 0x50(%rbx)
movl %eax, 0x8(%rbx)
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x29af11
movq %r14, %rdi
callq 0x28c3e7
movq $0x0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeMergeEngineFree
static void vdbeMergeEngineFree(MergeEngine *pMerger){
  int i;
  if( pMerger ){
    for(i=0; i<pMerger->nTree; i++){
      vdbePmaReaderClear(&pMerger->aReadr[i]);
    }
  }
  sqlite3_free(pMerger);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x29af5b
cmpl $0x0, (%rbx)
jle 0x29af5b
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rdi
addq %r14, %rdi
callq 0x29af68
incq %r15
movslq (%rbx), %rax
addq $0x50, %r14
cmpq %rax, %r15
jl 0x29af40
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x27c490
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbePmaReaderClear
static void vdbePmaReaderClear(PmaReader *pReadr){
  sqlite3_free(pReadr->aAlloc);
  sqlite3_free(pReadr->aBuffer);
  if( pReadr->aMap ) sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap);
  vdbeIncrFree(pReadr->pIncr);
  memset(pReadr, 0, sizeof(PmaReader));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x27c490
movq 0x30(%rbx), %rdi
callq 0x27c490
movq 0x40(%rbx), %rdx
testq %rdx, %rdx
je 0x29af96
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x90(%rax)
movq 0x48(%rbx), %rdi
callq 0x29afb7
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: callFinaliser
static void callFinaliser(sqlite3 *db, int offset){
  int i;
  if( db->aVTrans ){
    VTable **aVTrans = db->aVTrans;
    db->aVTrans = 0;
    for(i=0; i<db->nVTrans; i++){
      VTable *pVTab = aVTrans[i];
      sqlite3_vtab *p = pVTab->pVtab;
      if( p ){
        int (*x)(sqlite3_vtab *);
        x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset);
        if( x ) x(p);
      }
      pVTab->iSavepoint = 0;
      sqlite3VtabUnlock(pVTab);
    }
    sqlite3DbFree(db, aVTrans);
    db->nVTrans = 0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x210(%rdi), %r14
testq %r14, %r14
je 0x29b054
movq %rdi, %rbx
movq $0x0, 0x210(%rdi)
cmpl $0x0, 0x1ec(%rdi)
jle 0x29b03f
movl %esi, %r12d
xorl %r13d, %r13d
movq (%r14,%r13,8), %r15
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x29b020
movq (%rdi), %rax
movq (%rax,%r12), %rax
testq %rax, %rax
je 0x29b020
callq *%rax
movl $0x0, 0x20(%r15)
movq %r15, %rdi
callq 0x2999f3
incq %r13
movslq 0x1ec(%rbx), %rax
cmpq %rax, %r13
jl 0x29b005
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28c3e7
movl $0x0, 0x1ec(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeError
SQLITE_PRIVATE void sqlite3VdbeError(Vdbe *p, const char *zFormat, ...){
  va_list ap;
  sqlite3DbFree(p->db, p->zErrMsg);
  va_start(ap, zFormat);
  p->zErrMsg = sqlite3VMPrintf(p->db, zFormat, ap);
  va_end(ap);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x29b0bd
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0xa8(%rdi), %rsi
testq %rsi, %rsi
je 0x29b0d1
movq (%rbx), %rdi
callq 0x28c3e7
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x28e62e
movq %rax, 0xa8(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3OsOpenMalloc
SQLITE_PRIVATE int sqlite3OsOpenMalloc(
  sqlite3_vfs *pVfs,
  const char *zFile,
  sqlite3_file **ppFile,
  int flags,
  int *pOutFlags
){
  int rc;
  sqlite3_file *pFile;
  pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile);
  if( pFile ){
    rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
    if( rc!=SQLITE_OK ){
      sqlite3_free(pFile);
    }else{
      *ppFile = pFile;
    }
  }else{
    rc = SQLITE_NOMEM_BKPT;
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movl %ecx, %r12d
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r13
movslq 0x4(%rdi), %r15
movq %r15, %rdi
callq 0x27c381
testq %rax, %rax
je 0x29b188
movq %rax, %r14
movq %rbp, 0x8(%rsp)
xorl %ebp, %ebp
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x173a0
andl $0x1087f7f, %r12d       # imm = 0x1087F7F
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %ecx
movq 0x10(%rsp), %r8
callq *0x28(%r13)
testl %eax, %eax
je 0x29b18f
movl %eax, %ebx
movq %r14, %rdi
callq 0x27c490
movl %ebx, %ebp
jmp 0x29b197
movl $0x7, %ebp
jmp 0x29b197
movq 0x8(%rsp), %rax
movq %r14, (%rax)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VtabImportErrmsg
SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){
  if( pVtab->zErrMsg ){
    sqlite3 *db = p->db;
    sqlite3DbFree(db, p->zErrMsg);
    p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
    sqlite3_free(pVtab->zErrMsg);
    pVtab->zErrMsg = 0;
  }
}

// Assembly:
cmpq $0x0, 0x10(%rsi)
je 0x29b1fa
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0xa8(%rdi), %rsi
testq %rsi, %rsi
je 0x29b1d1
movq %r15, %rdi
callq 0x28c3e7
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x283365
movq %rax, 0xa8(%r14)
movq 0x10(%rbx), %rdi
callq 0x27c490
movq $0x0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeCloseStatement
static SQLITE_NOINLINE int vdbeCloseStatement(Vdbe *p, int eOp){
  sqlite3 *const db = p->db;
  int rc = SQLITE_OK;
  int i;
  const int iSavepoint = p->iStatement-1;

  assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE);
  assert( db->nStatement>0 );
  assert( p->iStatement==(db->nStatement+db->nSavepoint) );

  for(i=0; i<db->nDb; i++){
    int rc2 = SQLITE_OK;
    Btree *pBt = db->aDb[i].pBt;
    if( pBt ){
      if( eOp==SAVEPOINT_ROLLBACK ){
        rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint);
      }
      if( rc2==SQLITE_OK ){
        rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint);
      }
      if( rc==SQLITE_OK ){
        rc = rc2;
      }
    }
  }
  db->nStatement--;
  p->iStatement = 0;

  if( rc==SQLITE_OK ){
    if( eOp==SAVEPOINT_ROLLBACK ){
      rc = sqlite3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint);
    }
    if( rc==SQLITE_OK ){
      rc = sqlite3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint);
    }
  }

  /* If the statement transaction is being rolled back, also restore the
  ** database handles deferred constraint counter to the value it had when
  ** the statement transaction was opened.  */
  if( eOp==SAVEPOINT_ROLLBACK ){
    db->nDeferredCons = p->nStmtDefCons;
    db->nDeferredImmCons = p->nStmtDefImmCons;
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0xc(%rsp)
movq (%rdi), %rbx
movq %rdi, 0x10(%rsp)
movl 0x40(%rdi), %r15d
decl %r15d
cmpl $0x0, 0x28(%rbx)
jle 0x29b280
xorl %r14d, %r14d
movl $0x8, %ebp
xorl %r12d, %r12d
movq 0x20(%rbx), %rax
movq (%rax,%rbp), %r13
testq %r13, %r13
je 0x29b26e
xorl %eax, %eax
cmpl $0x2, 0xc(%rsp)
jne 0x29b253
movq %r13, %rdi
movl $0x2, %esi
movl %r15d, %edx
callq 0x29b2ff
testl %eax, %eax
jne 0x29b267
movq %r13, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x29b2ff
testl %r12d, %r12d
cmovel %eax, %r12d
incq %r14
movslq 0x28(%rbx), %rax
addq $0x20, %rbp
cmpq %rax, %r14
jl 0x29b22d
jmp 0x29b283
xorl %r12d, %r12d
decl 0x2bc(%rbx)
movq 0x10(%rsp), %r14
movl $0x0, 0x40(%r14)
testl %r12d, %r12d
jne 0x29b2d0
xorl %r12d, %r12d
cmpl $0x2, 0xc(%rsp)
jne 0x29b2b8
movq %rbx, %rdi
movl $0x2, %esi
movl %r15d, %edx
callq 0x29b386
movl %eax, %r12d
testl %r12d, %r12d
jne 0x29b2d0
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x29b386
movl %eax, %r12d
cmpl $0x2, 0xc(%rsp)
jne 0x29b2ed
movq 0x58(%r14), %rax
movq %rax, 0x2c0(%rbx)
movq 0x60(%r14), %rax
movq %rax, 0x2c8(%rbx)
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/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BtreeSavepoint
SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){
  int rc = SQLITE_OK;
  if( p && p->inTrans==TRANS_WRITE ){
    BtShared *pBt = p->pBt;
    assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
    assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
    sqlite3BtreeEnter(p);
    if( op==SAVEPOINT_ROLLBACK ){
      rc = saveAllCursors(pBt, 0, 0);
    }
    if( rc==SQLITE_OK ){
      rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
    }
    if( rc==SQLITE_OK ){
      if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){
        pBt->nPage = 0;
      }
      rc = newDatabase(pBt);
      btreeSetNPage(pBt, pBt->pPage1);

      /* pBt->nPage might be zero if the database was corrupt when
      ** the transaction was started. Otherwise, it must be at least 1.  */
      assert( CORRUPT_DB || pBt->nPage>0 );
    }
    sqlite3BtreeLeave(p);
  }
  return rc;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x29b385
cmpb $0x2, 0x10(%rdi)
jne 0x29b385
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq (%rdi), %rax
movq 0x8(%rdi), %rbx
movq %rax, 0x8(%rbx)
xorl %eax, %eax
cmpl $0x2, %esi
jne 0x29b339
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x29b339
xorl %esi, %esi
xorl %edx, %edx
callq 0x297c7e
testl %eax, %eax
jne 0x29b34a
movq (%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x2937c5
testl %eax, %eax
jne 0x29b381
testl %ebp, %ebp
jns 0x29b35f
testb $0x10, 0x28(%rbx)
je 0x29b35f
movl $0x0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x2965eb
movq 0x18(%rbx), %rcx
movq 0x50(%rcx), %rcx
movl 0x1c(%rcx), %ecx
bswapl %ecx
testl %ecx, %ecx
jne 0x29b37e
movq (%rbx), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, 0x40(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeMemClear
static SQLITE_NOINLINE void vdbeMemClear(Mem *p){
  if( VdbeMemDynamic(p) ){
    vdbeMemClearExternAndSetNull(p);
  }
  if( p->szMalloc ){
    sqlite3DbFreeNN(p->db, p->zMalloc);
    p->szMalloc = 0;
  }
  p->z = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x24, 0x9(%rdi)
je 0x29b46d
movq %rbx, %rdi
callq 0x29b491
cmpl $0x0, 0x20(%rbx)
je 0x29b487
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rdi
callq 0x28c3e7
movl $0x0, 0x20(%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeMemClearExternAndSetNull
static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem *p){
  assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
  assert( VdbeMemDynamic(p) );
  if( p->flags&MEM_Agg ){
    sqlite3VdbeMemFinalize(p, p->u.pDef);
    assert( (p->flags & MEM_Agg)==0 );
    testcase( p->flags & MEM_Dyn );
  }
  if( p->flags&MEM_Dyn ){
    assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 );
    p->xDel((void *)p->z);
  }
  p->flags = MEM_Null;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x20, 0x9(%rdi)
je 0x29b4a6
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x29b4bb
testb $0x4, 0x9(%rbx)
je 0x29b4b3
movq 0x10(%rbx), %rdi
callq *0x30(%rbx)
movw $0x1, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemFinalize
SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
  sqlite3_context ctx;
  Mem t;
  assert( pFunc!=0 );
  assert( pFunc->xFinalize!=0 );
  assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  memset(&ctx, 0, sizeof(ctx));
  memset(&t, 0, sizeof(t));
  t.flags = MEM_Null;
  t.db = pMem->db;
  ctx.pOut = &t;
  ctx.pMem = pMem;
  ctx.pFunc = pFunc;
  pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */
  assert( (pMem->flags & MEM_Dyn)==0 );
  if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
  memcpy(pMem, &t, sizeof(t));
  return ctx.isError;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
xorl %eax, %eax
movq %rax, 0x30(%rdi)
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, 0x20(%rcx)
movq %rax, 0x30(%rcx)
movw $0x1, 0x8(%rcx)
movq 0x28(%rbx), %rax
movq %rax, 0x28(%rcx)
movq %rcx, (%rdi)
movq %rbx, 0x10(%rdi)
movq %rsi, 0x8(%rdi)
callq *0x20(%rsi)
cmpl $0x0, 0x20(%rbx)
jle 0x29b520
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rdi
callq 0x28c3e7
movq 0x30(%rsp), %rax
movq %rax, 0x30(%rbx)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movl 0x64(%rsp), %eax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DbReallocOrFree
SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, u64 n){
  void *pNew;
  pNew = sqlite3DbRealloc(db, p, n);
  if( !pNew ){
    sqlite3DbFree(db, p);
  }
  return pNew;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x28c4c8
movq %rax, %r15
testq %rax, %rax
setne %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x29b6d4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28c3e7
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: valueToText
static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
  assert( pVal!=0 );
  assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
  assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
  assert( !sqlite3VdbeMemIsRowSet(pVal) );
  assert( (pVal->flags & (MEM_Null))==0 );
  if( pVal->flags & (MEM_Blob|MEM_Str) ){
    if( ExpandBlob(pVal) ) return 0;
    pVal->flags |= MEM_Str;
    if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
      sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
    }
    if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
      assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
      if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
        return 0;
      }
    }
    sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
  }else{
    sqlite3VdbeMemStringify(pVal, enc, 0);
    assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
  }
  assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
              || pVal->db->mallocFailed );
  if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
    assert( sqlite3VdbeMemValidStrRep(pVal) );
    return pVal->z;
  }else{
    return 0;
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
testb $0x12, %al
je 0x29b762
btl $0xe, %eax
jae 0x29b716
movq %rbx, %rdi
callq 0x281b53
testl %eax, %eax
jne 0x29b780
orb $0x2, 0x8(%rbx)
movzbl 0xa(%rbx), %eax
movzbl %bpl, %esi
andl $-0x9, %esi
cmpl %eax, %esi
je 0x29b731
movq %rbx, %rdi
callq 0x29b888
testb $0x8, %bpl
je 0x29b749
testb $0x1, 0x10(%rbx)
je 0x29b749
movq %rbx, %rdi
callq 0x281d9d
testl %eax, %eax
jne 0x29b780
movzwl 0x8(%rbx), %eax
andl $0x202, %eax            # imm = 0x202
cmpw $0x2, %ax
jne 0x29b770
movq %rbx, %rdi
callq 0x29be39
jmp 0x29b770
movzbl %bpl, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x29b789
andb $-0x9, %bpl
cmpb %bpl, 0xa(%rbx)
jne 0x29b780
movq 0x10(%rbx), %rax
jmp 0x29b782
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemStringify
SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
  const int nByte = 32;

  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( !(pMem->flags&MEM_Zero) );
  assert( !(pMem->flags&(MEM_Str|MEM_Blob)) );
  assert( pMem->flags&(MEM_Int|MEM_Real|MEM_IntReal) );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );


  if( sqlite3VdbeMemClearAndResize(pMem, nByte) ){
    pMem->enc = 0;
    return SQLITE_NOMEM_BKPT;
  }

  vdbeMemRenderNum(nByte, pMem->z, pMem);
  assert( pMem->z!=0 );
  pMem->n = sqlite3Strlen30NN(pMem->z);
  pMem->enc = SQLITE_UTF8;
  pMem->flags |= MEM_Str|MEM_Term;
  if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
  sqlite3VdbeChangeEncoding(pMem, enc);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x1f, 0x20(%rdi)
jg 0x29b7c5
movq %rbx, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x29b54f
testl %eax, %eax
je 0x29b7d2
movb $0x0, 0xa(%rbx)
movl $0x7, %r14d
jmp 0x29b878
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
andw $0x2d, 0x8(%rbx)
movq 0x10(%rbx), %r15
movzwl 0x8(%rbx), %eax
testb $0x4, %al
jne 0x29b807
movq %r15, 0x8(%rsp)
xorl %ecx, %ecx
movq %rcx, (%rsp)
movl $0x20, 0x10(%rsp)
movq %rcx, 0x14(%rsp)
movw $0x0, 0x1c(%rsp)
testb $0x20, %al
jne 0x29b814
movsd (%rbx), %xmm0
jmp 0x29b819
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x29be9f
jmp 0x29b837
cvtsi2sdq (%rbx), %xmm0
leaq 0x143cfd(%rip), %rsi    # 0x3df51d
movq %rsp, %r12
movq %r12, %rdi
movb $0x1, %al
callq 0x27e729
movl 0x18(%r12), %eax
movb $0x0, (%r15,%rax)
movq 0x10(%rbx), %rdi
callq 0x172f0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, 0xc(%rbx)
movb $0x1, 0xa(%rbx)
movl $0x202, %eax            # imm = 0x202
orl 0x8(%rbx), %eax
movl %eax, %ecx
andl $-0x2d, %ecx
testb %r14b, %r14b
cmovel %eax, %ecx
movw %cx, 0x8(%rbx)
xorl %r14d, %r14d
cmpb $0x1, %bpl
je 0x29b878
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x29b888
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeMemAddTerminator
static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){
  if( sqlite3VdbeMemGrow(pMem, pMem->n+3, 1) ){
    return SQLITE_NOMEM_BKPT;
  }
  pMem->z[pMem->n] = 0;
  pMem->z[pMem->n+1] = 0;
  pMem->z[pMem->n+2] = 0;
  pMem->flags |= MEM_Term;
  return SQLITE_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0xc(%rdi), %esi
addl $0x3, %esi
movl $0x1, %edx
callq 0x29b54f
movl %eax, %ecx
movl $0x7, %eax
testl %ecx, %ecx
jne 0x29be81
movq 0x10(%rbx), %rcx
movslq 0xc(%rbx), %rdx
xorl %eax, %eax
movb %al, (%rcx,%rdx)
movq 0x10(%rbx), %rcx
movslq 0xc(%rbx), %rdx
movb %al, 0x1(%rcx,%rdx)
movq 0x10(%rbx), %rcx
movslq 0xc(%rbx), %rdx
movb %al, 0x2(%rcx,%rdx)
orb $0x2, 0x9(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3Int64ToText
SQLITE_PRIVATE void sqlite3Int64ToText(i64 v, char *zOut){
  int i;
  u64 x;
  char zTemp[22];
  if( v<0 ){
    x = (v==SMALLEST_INT64) ? ((u64)1)<<63 : (u64)-v;
  }else{
    x = v;
  }
  i = sizeof(zTemp)-2;
  zTemp[sizeof(zTemp)-1] = 0;
  do{
    zTemp[i--] = (x%10) + '0';
    x = x/10;
  }while( x );
  if( v<0 ) zTemp[i--] = '-';
  memcpy(zOut, &zTemp[i+1], sizeof(zTemp)-1-i);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r8
movq %rdi, %rcx
negq %rcx
cmovsq %rdi, %rcx
movb $0x0, 0x15(%rsp)
movl $0x14, %r9d
movl $0x13, %esi
movabsq $0x1400000000, %r10     # imm = 0x1400000000
movabsq $-0x3333333333333333, %r11 # imm = 0xCCCCCCCCCCCCCCCD
movabsq $-0x100000000, %rbx     # imm = 0xFFFFFFFF00000000
addq %rbx, %r10
movq %rcx, %rax
mulq %r11
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %ebp
subl %eax, %ebp
orb $0x30, %bpl
movb %bpl, (%rsp,%r9)
decq %r9
decl %esi
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x29bee0
testq %rdi, %rdi
js 0x29bf17
movl %r9d, %esi
jmp 0x29bf20
sarq $0x20, %r10
movb $0x2d, (%rsp,%r10)
movslq %esi, %rax
movq %rsp, %rcx
leaq (%rax,%rcx), %rsi
incq %rsi
movl $0x15, %edx
subq %rax, %rdx
movq %r8, %rdi
callq 0x17660
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: memRealValue
static SQLITE_NOINLINE double memRealValue(Mem *pMem){
  /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
  double val = (double)0;
  sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
  return val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq 0x10(%rdi), %rax
movl 0xc(%rdi), %edx
movzbl 0xa(%rdi), %ecx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x29bf75
movsd (%rbx), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemShallowCopy
SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
  assert( !sqlite3VdbeMemIsRowSet(pFrom) );
  assert( pTo->db==pFrom->db );
  if( VdbeMemDynamic(pTo) ){ vdbeClrCopy(pTo,pFrom,srcType); return; }
  memcpy(pTo, pFrom, MEMCELLSIZE);
  if( (pFrom->flags&MEM_Static)==0 ){
    pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
    assert( srcType==MEM_Ephem || srcType==MEM_Static );
    pTo->flags |= srcType;
  }
}

// Assembly:
testb $0x24, 0x9(%rdi)
jne 0x2a83ff
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
testb $0x8, 0x9(%rsi)
jne 0x2a4359
movl $0xffffe3ff, %eax       # imm = 0xFFFFE3FF
andl 0x8(%rdi), %eax
orl %edx, %eax
movw %ax, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SubInt64
SQLITE_PRIVATE int sqlite3SubInt64(i64 *pA, i64 iB){
#if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
  return __builtin_sub_overflow(*pA, iB, pA);
#else
  testcase( iB==SMALLEST_INT64+1 );
  if( iB==SMALLEST_INT64 ){
    testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
    if( (*pA)>=0 ) return 1;
    *pA -= iB;
    return 0;
  }else{
    return sqlite3AddInt64(pA, -iB);
  }
#endif
}

// Assembly:
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%rdx), %rax
movq (%rdi), %rcx
cmpq %rax, %rsi
jne 0x2a437b
movl $0x1, %eax
testq %rcx, %rcx
js 0x2a43a1
retq
testq %rsi, %rsi
jle 0x2a43a6
testq %rcx, %rcx
jns 0x2a43be
subq %rcx, %rdx
addq $0x2, %rdx
movl $0x1, %r8d
subq %rsi, %r8
movl $0x1, %eax
cmpq %r8, %rdx
jg 0x2a437a
jmp 0x2a43be
andq %rdx, %rcx
jmp 0x2a43c1
testq %rcx, %rcx
jle 0x2a43be
movq %rsi, %r8
negq %r8
subq %rcx, %rdx
movl $0x1, %eax
cmpq %r8, %rdx
jl 0x2a437a
subq %rsi, %rcx
movq %rcx, (%rdi)
xorl %eax, %eax
retq