LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/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;
  u8 isInitOrig = pPage->isInit;
  Pgno pgno = pPage->pgno;

  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  rc = btreeInitPage(pPage);
  if( rc!=SQLITE_OK ){
    goto set_child_ptrmaps_out;
  }
  nCell = pPage->nCell;

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

    ptrmapPutOvflPtr(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);
  }

set_child_ptrmaps_out:
  pPage->isInit = isInitOrig;
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq %rax, -0x40(%rbp)
movb (%rdi), %r14b
movl 0x70(%rdi), %eax
movl %eax, -0x34(%rbp)
callq 0x1a4b5
movl %eax, -0x30(%rbp)
testl %eax, %eax
jne 0x1f7ec
movb %r14b, -0x29(%rbp)
movzwl 0x10(%rbx), %r14d
xorl %r15d, %r15d
leaq -0x30(%rbp), %r12
cmpq %r15, %r14
je 0x1f7b8
movzwl 0x12(%rbx), %eax
movq 0x60(%rbx), %rcx
movzbl (%rcx,%r15,2), %edx
shll $0x8, %edx
movzbl 0x1(%rcx,%r15,2), %r13d
orl %edx, %r13d
andl %eax, %r13d
addq 0x50(%rbx), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1fa21
cmpb $0x0, 0x3(%rbx)
jne 0x1f7b3
movq %r13, %rdi
callq 0x180a3
movq -0x40(%rbp), %rdi
movl %eax, %esi
pushq $0x5
popq %rdx
movl -0x34(%rbp), %ecx
movq %r12, %r8
callq 0x1f801
incq %r15
jmp 0x1f75e
cmpb $0x0, 0x3(%rbx)
movb -0x29(%rbp), %r14b
jne 0x1f7ec
movq 0x50(%rbx), %rax
movzbl 0x5(%rbx), %ecx
leaq (%rax,%rcx), %rdi
addq $0x8, %rdi
callq 0x180a3
pushq $0x5
popq %rdx
leaq -0x30(%rbp), %r8
movq -0x40(%rbp), %rdi
movl %eax, %esi
movl -0x34(%rbp), %ecx
callq 0x1f801
movb %r14b, (%rbx)
movl -0x30(%rbp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: ptrmapPut
static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
  DbPage *pDbPage;  /* The pointer map page */
  u8 *pPtrmap;      /* The pointer map data */
  Pgno iPtrmap;     /* The pointer map page number */
  int offset;       /* Offset in pointer map page */
  int rc;           /* Return code from subfunctions */

  if( *pRC ) return;

  assert( sqlite3_mutex_held(pBt->mutex) );
  /* The master-journal page number must never be used as a pointer map page */
  assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );

  assert( pBt->autoVacuum );
  if( key==0 ){
    *pRC = SQLITE_CORRUPT_BKPT;
    return;
  }
  iPtrmap = PTRMAP_PAGENO(pBt, key);
  rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
  if( rc!=SQLITE_OK ){
    *pRC = rc;
    return;
  }
  offset = PTRMAP_PTROFFSET(iPtrmap, key);
  if( offset<0 ){
    *pRC = SQLITE_CORRUPT_BKPT;
    goto ptrmap_exit;
  }
  assert( offset <= (int)pBt->usableSize-5 );
  pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);

  if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){
    TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent));
    *pRC= rc = sqlite3PagerWrite(pDbPage);
    if( rc==SQLITE_OK ){
      pPtrmap[offset] = eType;
      put4byte(&pPtrmap[offset+1], parent);
    }
  }

ptrmap_exit:
  sqlite3PagerUnref(pDbPage);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, (%r8)
je 0x1f827
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %r14
movl %esi, %r12d
testl %esi, %esi
je 0x1f85e
movl %edx, %r15d
movq %rdi, %rbx
movl %ecx, -0x2c(%rbp)
movl %r12d, %esi
callq 0x1dfda
movl %eax, %r13d
movq (%rbx), %rdi
leaq -0x38(%rbp), %rdx
movl %eax, %esi
xorl %ecx, %ecx
callq 0xca7d
testl %eax, %eax
je 0x1f871
movl %eax, (%r14)
jmp 0x1f818
movl $0xc4d8, %edi           # imm = 0xC4D8
callq 0x1a1fc
movl $0xb, (%r14)
jmp 0x1f818
notl %r13d
addl %r12d, %r13d
leal (%r13,%r13,4), %eax
testl %eax, %eax
js 0x1f8d0
movq -0x38(%rbp), %r12
movq 0x8(%r12), %rcx
movl %eax, %eax
leaq (%rcx,%rax), %rbx
cmpb %r15b, (%rcx,%rax)
jne 0x1f8a3
leaq 0x1(%rbx), %rdi
callq 0x180a3
cmpl -0x2c(%rbp), %eax
je 0x1f8e5
movq %r12, %rdi
callq 0xd10b
movl %eax, (%r14)
testl %eax, %eax
jne 0x1f8e5
movb %r15b, (%rbx)
movl -0x2c(%rbp), %ecx
movl %ecx, %eax
shrl $0x18, %eax
movb %al, 0x1(%rbx)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0x2(%rbx)
movb %ch, 0x3(%rbx)
movb %cl, 0x4(%rbx)
jmp 0x1f8e5
movl $0xc4e3, %edi           # imm = 0xC4E3
callq 0x1a1fc
movl $0xb, (%r14)
movq -0x38(%rbp), %r12
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcf6e
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3PcacheMove
SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
  PCache *pCache = p->pCache;
  assert( p->nRef>0 );
  assert( newPgno>0 );
  sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno);
  p->pgno = newPgno;
  if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){
    pcacheRemoveFromDirtyList(p);
    pcacheAddToDirtyList(p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x40(%rax), %rdi
movq (%rbx), %rsi
movl 0x28(%rbx), %edx
movl %r14d, %ecx
callq *0x67bd1(%rip)          # 0x874f0
movl %r14d, 0x28(%rbx)
movl 0x2c(%rbx), %eax
notl %eax
testb $0x6, %al
jne 0x1f940
movq %rbx, %rdi
callq 0x1a42f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1ce86
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BitvecClear
SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){
  if( p==0 ) return;
  assert( i>0 );
  i--;
  while( p->iDivisor ){
    u32 bin = i/p->iDivisor;
    i = i%p->iDivisor;
    p = p->u.apSub[bin];
    if (!p) {
      return;
    }
  }
  if( p->iSize<=BITVEC_NBIT ){
    p->u.aBitmap[i/BITVEC_SZELEM] &= ~(1 << (i&(BITVEC_SZELEM-1)));
  }else{
    unsigned int j;
    u32 *aiValues = pBuf;
    memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
    memset(p->u.aHash, 0, sizeof(p->u.aHash));
    p->nSet = 0;
    for(j=0; j<BITVEC_NINT; j++){
      if( aiValues[j] && aiValues[j]!=(i+1) ){
        u32 h = BITVEC_HASH(aiValues[j]-1);
        p->nSet++;
        while( p->u.aHash[h] ){
          h++;
          if( h>=BITVEC_NINT ) h = 0;
        }
        p->u.aHash[h] = aiValues[j];
      }
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1f9ad
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
decl %r14d
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
je 0x1f981
movl %r14d, %eax
xorl %edx, %edx
divl %ecx
movq 0x10(%rbx,%rax,8), %rbx
movl %edx, %r14d
testq %rbx, %rbx
jne 0x1f964
jmp 0x1f99f
cmpl $0xf80, (%rbx)          # imm = 0xF80
ja 0x1f9ae
movl %r14d, %ecx
andb $0x7, %cl
pushq $0x1
popq %rax
shll %cl, %eax
shrl $0x3, %r14d
notb %al
andb %al, 0x10(%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rbx), %r12
movl $0x1f0, %edx            # imm = 0x1F0
movq %r15, %rdi
movq %r12, %rsi
callq 0x82c0
xorl %r13d, %r13d
movl $0x1f0, %edx            # imm = 0x1F0
movq %r12, %rdi
xorl %esi, %esi
callq 0x81e0
andl $0x0, 0x4(%rbx)
incl %r14d
pushq $0x7c
popq %rcx
xorl %esi, %esi
xorl %edi, %edi
cmpq $0x7c, %rdi
je 0x1f99f
movl (%r15,%rdi,4), %eax
testl %eax, %eax
je 0x1fa1c
cmpl %r14d, %eax
je 0x1fa1c
decl %eax
xorl %edx, %edx
divl %ecx
incl %esi
movl %esi, 0x4(%rbx)
movl %edx, %edx
cmpl $0x0, (%r12,%rdx,4)
je 0x1fa14
incl %edx
cmpl $0x7c, %edx
cmovael %r13d, %edx
jmp 0x1fa00
movl (%r15,%rdi,4), %eax
movl %eax, (%r12,%rdx,4)
incq %rdi
jmp 0x1f9e2
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: ptrmapPutOvflPtr
static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
  CellInfo info;
  if( *pRC ) return;
  assert( pCell!=0 );
  btreeParseCellPtr(pPage, pCell, &info);
  assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
  if( info.iOverflow ){
    Pgno ovfl = get4byte(&pCell[info.iOverflow]);
    ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, (%rdx)
je 0x1fa42
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq -0x40(%rbp), %r12
movq %r12, %rdx
callq 0x1e436
movzwl 0x1c(%r12), %eax
testq %rax, %rax
je 0x1fa35
addq %rax, %r15
movq %r15, %rdi
callq 0x180a3
movq 0x48(%r14), %rdi
movl 0x70(%r14), %ecx
pushq $0x3
popq %rdx
movl %eax, %esi
movq %rbx, %r8
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1f801
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeTripAllCursors
SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode){
  BtCursor *p;
  if( pBtree==0 ) return;
  sqlite3BtreeEnter(pBtree);
  for(p=pBtree->pBt->pCursor; p; p=p->pNext){
    int i;
    sqlite3BtreeClearCursor(p);
    p->eState = CURSOR_FAULT;
    p->skipNext = errCode;
    for(i=0; i<=p->iPage; i++){
      releasePage(p->apPage[i]);
      p->apPage[i] = 0;
    }
  }
  sqlite3BtreeLeave(pBtree);
}

// Assembly:
testq %rdi, %rdi
je 0x1faf6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq (%rdi), %rax
movq 0x8(%rdi), %r14
movq %rax, 0x8(%r14)
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x1faec
movq %r14, %rdi
callq 0x1faf7
movb $0x4, 0x77(%r14)
movl %ebx, 0x70(%r14)
xorl %r15d, %r15d
movswq 0x7a(%r14), %rax
cmpq %rax, %r15
jg 0x1faaa
movq 0xa8(%r14,%r15,8), %rdi
callq 0x1d90e
andq $0x0, 0xa8(%r14,%r15,8)
incq %r15
jmp 0x1fac7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeClearCursor
SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
  assert( cursorHoldsMutex(pCur) );
  sqlite3_free(pCur->pKey);
  pCur->pKey = 0;
  pCur->eState = CURSOR_INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x9c7b
andq $0x0, 0x68(%rbx)
movb $0x0, 0x77(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: releaseMemArray
static void releaseMemArray(Mem *p, int N){
  if( p && N ){
    Mem *pEnd;
    sqlite3 *db = p->db;
    u8 malloc_failed = db->mallocFailed;
    if( db->pnBytesFreed ){
      for(pEnd=&p[N]; p<pEnd; p++){
        sqlite3DbFree(db, p->zMalloc);
      }
      return;
    }
    for(pEnd=&p[N]; p<pEnd; p++){
      assert( (&p[1])==pEnd || p[0].db==p[1].db );

      /* 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.
      */
      if( p->flags&(MEM_Agg|MEM_Dyn|MEM_Frame|MEM_RowSet) ){
        sqlite3VdbeMemRelease(p);
      }else if( p->zMalloc ){
        sqlite3DbFree(db, p->zMalloc);
        p->zMalloc = 0;
      }

      p->flags = MEM_Invalid;
    }
    db->mallocFailed = malloc_failed;
  }
}

// Assembly:
testq %rdi, %rdi
sete %al
testl %esi, %esi
sete %cl
orb %al, %cl
jne 0x1fbb3
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movslq %esi, %rax
imulq $0x38, %rax, %r15
addq %rdi, %r15
cmpq $0x0, 0x328(%r14)
je 0x1fb68
cmpq %r15, %rbx
jae 0x1fbab
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x968b
addq $0x38, %rbx
jmp 0x1fb51
movb 0x50(%r14), %r12b
cmpq %r15, %rbx
jae 0x1fba7
movzwl 0x24(%rbx), %eax
testw $0x2460, %ax            # imm = 0x2460
je 0x1fb85
movq %rbx, %rdi
callq 0xde44
jmp 0x1fb9b
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x1fb9b
movq %r14, %rdi
callq 0x968b
andq $0x0, 0x30(%rbx)
movw $0x80, 0x24(%rbx)
addq $0x38, %rbx
jmp 0x1fb6c
movb %r12b, 0x50(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: vdbeFreeOpArray
static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
  if( aOp ){
    Op *pOp;
    for(pOp=aOp; pOp<&aOp[nOp]; pOp++){
      freeP4(db, pOp->p4type, pOp->p4.p);
#ifdef SQLITE_DEBUG
      sqlite3DbFree(db, pOp->zComment);
#endif     
    }
  }
  sqlite3DbFree(db, aOp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x1fbf5
movslq %edx, %rax
imulq $0x18, %rax, %r15
addq %rbx, %r15
movq %rbx, %r12
cmpq %r15, %r12
jae 0x1fbf5
movsbl 0x1(%r12), %esi
movq 0x10(%r12), %rdx
movq %r14, %rdi
callq 0x1fc08
addq $0x18, %r12
jmp 0x1fbd7
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x968b
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: freeP4
static void freeP4(sqlite3 *db, int p4type, void *p4){
  if( p4 ){
    assert( db );
    switch( p4type ){
      case P4_REAL:
      case P4_INT64:
      case P4_DYNAMIC:
      case P4_KEYINFO:
      case P4_INTARRAY:
      case P4_KEYINFO_HANDOFF: {
        sqlite3DbFree(db, p4);
        break;
      }
      case P4_MPRINTF: {
        if( db->pnBytesFreed==0 ) sqlite3_free(p4);
        break;
      }
      case P4_FUNCDEF: {
        freeEphemeralFunction(db, (FuncDef*)p4);
        break;
      }
      case P4_MEM: {
        if( db->pnBytesFreed==0 ){
          sqlite3ValueFree((sqlite3_value*)p4);
        }else{
          Mem *p = (Mem*)p4;
          sqlite3DbFree(db, p->zMalloc);
          sqlite3DbFree(db, p);
        }
        break;
      }
      case P4_VTAB : {
        if( db->pnBytesFreed==0 ) sqlite3VtabUnlock((VTable *)p4);
        break;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0x1fc70
addl $0x10, %esi
cmpl $0xf, %esi
ja 0x1fc70
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x4756f(%rip), %rax     # 0x67198
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x968b
cmpq $0x0, 0x328(%r14)
jne 0x1fc70
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9c7b
cmpq $0x0, 0x328(%r14)
jne 0x1fc70
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1fc99
testb $0x4, 0x3(%rbx)
jne 0x1fc32
popq %rbx
popq %r14
popq %rbp
retq
cmpq $0x0, 0x328(%r14)
je 0x1fc8d
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x968b
jmp 0x1fc32
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x12a43
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VtabUnlock
SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){
  sqlite3 *db = pVTab->db;

  assert( db );
  assert( pVTab->nRef>0 );
  assert( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ZOMBIE );

  pVTab->nRef--;
  if( pVTab->nRef==0 ){
    sqlite3_vtab *p = pVTab->pVtab;
    if( p ){
      p->pModule->xDisconnect(p);
    }
    sqlite3DbFree(db, pVTab);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r14
decl 0x18(%rdi)
je 0x1fcad
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1fcbf
movq (%rdi), %rax
callq *0x20(%rax)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x968b
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeDelete
SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){
  sqlite3 *db;

  if( NEVER(p==0) ) return;
  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;
  sqlite3DbFree(db, p);
}

// Assembly:
testq %rdi, %rdi
je 0x1fd28
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x95b7
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
leaq 0x8(%r14), %rdx
leaq 0x68(%rax), %rsi
testq %rax, %rax
cmoveq %rdx, %rsi
movq %rcx, (%rsi)
testq %rcx, %rcx
je 0x1fd0e
movq %rax, 0x60(%rcx)
movl $0xb606c3c8, 0x50(%rbx) # imm = 0xB606C3C8
andq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x968b
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeTransferError
SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){
  sqlite3 *db = p->db;
  int rc = p->rc;
  if( p->zErrMsg ){
    u8 mallocFailed = db->mallocFailed;
    sqlite3BeginBenignMalloc();
    sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
    sqlite3EndBenignMalloc();
    db->mallocFailed = mallocFailed;
    db->errCode = rc;
  }else{
    sqlite3Error(db, rc, 0);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r14
movq 0x58(%rdi), %rdx
movl 0x94(%rdi), %ebx
testq %rdx, %rdx
je 0x20664
movb 0x50(%r14), %r12b
movq 0x68938(%rip), %rax     # 0x88f60
testq %rax, %rax
je 0x20636
movq %rdi, %r15
callq *%rax
movq 0x58(%r15), %rdx
movq 0x130(%r14), %rdi
pushq $-0x1
popq %rsi
pushq $0x1
popq %rcx
pushq $-0x1
popq %r8
callq 0x12a28
movq 0x68915(%rip), %rax     # 0x88f68
testq %rax, %rax
je 0x2065a
callq *%rax
movb %r12b, 0x50(%r14)
movl %ebx, 0x44(%r14)
jmp 0x20672
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xbdb1
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3RollbackAll
SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db, int tripCode){
  int i;
  int inTrans = 0;
  assert( sqlite3_mutex_held(db->mutex) );
  sqlite3BeginBenignMalloc();

  /* Obtain all b-tree mutexes before making any calls to BtreeRollback(). 
  ** This is important in case the transaction being rolled back has
  ** modified the database schema. If the b-tree mutexes are not taken
  ** here, then another shared-cache connection might sneak in between
  ** the database rollback and schema reset, which can cause false
  ** corruption reports in some cases.  */
  sqlite3BtreeEnterAll(db);

  for(i=0; i<db->nDb; i++){
    Btree *p = db->aDb[i].pBt;
    if( p ){
      if( sqlite3BtreeIsInTrans(p) ){
        inTrans = 1;
      }
      sqlite3BtreeRollback(p, tripCode);
    }
  }
  sqlite3VtabRollback(db);
  sqlite3EndBenignMalloc();

  if( (db->flags&SQLITE_InternChanges)!=0 && db->init.busy==0 ){
    sqlite3ExpirePreparedStatements(db);
    sqlite3ResetAllSchemasOfConnection(db);
  }
  sqlite3BtreeLeaveAll(db);

  /* Any deferred constraint violations have now been resolved. */
  db->nDeferredCons = 0;
  db->nDeferredImmCons = 0;
  db->flags &= ~SQLITE_DeferFKs;

  /* If one has been configured, invoke the rollback-hook callback */
  if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
    db->xRollbackCallback(db->pRollbackArg);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x688c8(%rip), %rax     # 0x88f60
testq %rax, %rax
je 0x2069f
callq *%rax
movq %rbx, %rdi
callq 0x933b
xorl %r12d, %r12d
pushq $0x8
popq %r13
xorl %r15d, %r15d
movslq 0x28(%rbx), %rax
cmpq %rax, %r12
jge 0x206e3
movq 0x20(%rbx), %rax
movq (%rax,%r13), %rdi
testq %rdi, %rdi
je 0x206da
cmpb $0x2, 0x10(%rdi)
pushq $0x1
popq %rax
cmovel %eax, %r15d
movl %r14d, %esi
callq 0xd8df
incq %r12
addq $0x20, %r13
jmp 0x206b1
movq %rbx, %rdi
callq 0x20cd5
movq 0x68876(%rip), %rax     # 0x88f68
testq %rax, %rax
je 0x206f9
callq *%rax
movl 0x2c(%rbx), %eax
testb $0x2, %al
je 0x2071c
cmpb $0x0, 0x99(%rbx)
jne 0x2071c
movq %rbx, %rdi
callq 0x1108b
movq %rbx, %rdi
callq 0xd023
movl 0x2c(%rbx), %eax
andl $0xfeffffff, %eax       # imm = 0xFEFFFFFF
xorps %xmm0, %xmm0
movups %xmm0, 0x318(%rbx)
movl %eax, 0x2c(%rbx)
movq 0xf0(%rbx), %rax
testq %rax, %rax
je 0x2075c
testl %r15d, %r15d
je 0x20756
movq 0xe8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
cmpb $0x0, 0x4e(%rbx)
je 0x2073f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3CloseSavepoints
SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *db){
  while( db->pSavepoint ){
    Savepoint *pTmp = db->pSavepoint;
    db->pSavepoint = pTmp->pNext;
    sqlite3DbFree(db, pTmp);
  }
  db->nSavepoint = 0;
  db->nStatement = 0;
  db->isTransactionSavepoint = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x300(%rbx), %rsi
testq %rsi, %rsi
je 0x20795
movq 0x18(%rsi), %rax
movq %rax, 0x300(%rbx)
movq %rbx, %rdi
callq 0x968b
jmp 0x20774
andq $0x0, 0x30c(%rbx)
movb $0x0, 0x55(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeCheckFk
SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){
  sqlite3 *db = p->db;
  if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0) 
   || (!deferred && p->nFkConstraint>0) 
  ){
    p->rc = SQLITE_CONSTRAINT_FOREIGNKEY;
    p->errorAction = OE_Abort;
    sqlite3SetString(&p->zErrMsg, db, "foreign key constraint failed");
    return SQLITE_ERROR;
  }
  return SQLITE_OK;
}

// Assembly:
movl %esi, %eax
movq (%rdi), %rsi
testl %eax, %eax
je 0x207ed
movq 0x320(%rsi), %rax
addq 0x318(%rsi), %rax
jle 0x207f7
pushq %rbp
movq %rsp, %rbp
movl $0x313, 0x94(%rdi)      # imm = 0x313
movb $0x2, 0x98(%rdi)
addq $0x58, %rdi
leaq 0x4b0c9(%rip), %rdx     # 0x6b8aa
xorl %eax, %eax
callq 0x20d5f
pushq $0x1
popq %rax
popq %rbp
retq
cmpq $0x0, 0xc8(%rdi)
jg 0x207c1
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeFreeCursor
SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
  if( pCx==0 ){
    return;
  }
  sqlite3VdbeSorterClose(p->db, pCx);
  if( pCx->pBt ){
    sqlite3BtreeClose(pCx->pBt);
    /* The pCx->pCursor will be close automatically, if it exists, by
    ** the call above. */
  }else if( pCx->pCursor ){
    sqlite3BtreeCloseCursor(pCx->pCursor);
  }
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( pCx->pVtabCursor ){
    sqlite3_vtab_cursor *pVtabCursor = pCx->pVtabCursor;
    const sqlite3_module *pModule = pCx->pModule;
    p->inVtabMethod = 1;
    pModule->xClose(pVtabCursor);
    p->inVtabMethod = 0;
  }
#endif
}

// Assembly:
testq %rsi, %rsi
je 0x20a66
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x58(%rsi), %r15
testq %r15, %r15
je 0x20a10
movq (%rbx), %r12
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x209da
movq %rbx, -0x30(%rbp)
xorl %r13d, %r13d
xorl %ebx, %ebx
movslq 0x14(%r15), %rax
cmpq %rax, %rbx
jge 0x209ce
addq %r13, %rsi
movq %r12, %rdi
callq 0x20c4e
incq %rbx
movq 0x28(%r15), %rsi
addq $0x40, %r13
jmp 0x209ad
movq %r12, %rdi
callq 0x968b
movq -0x30(%rbp), %rbx
movq 0x38(%r15), %rdi
testq %rdi, %rdi
je 0x209e8
callq 0x20c87
movq 0x40(%r15), %rsi
movq %r12, %rdi
callq 0x20cb0
movq 0x48(%r15), %rsi
movq %r12, %rdi
callq 0x968b
movq %r12, %rdi
movq %r15, %rsi
callq 0x968b
andq $0x0, 0x58(%r14)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x20a20
callq 0x20ae6
jmp 0x20a2d
movq (%r14), %rdi
testq %rdi, %rdi
je 0x20a2d
callq 0x20bcc
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x20a58
movq 0x38(%r14), %rax
movzwl 0x9a(%rbx), %ecx
andl $-0xd, %ecx
orl $0x4, %ecx
movw %cx, 0x9a(%rbx)
callq *0x38(%rax)
andb $-0xd, 0x9a(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeDeleteAuxData
SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(Vdbe *pVdbe, int iOp, int mask){
  AuxData **pp = &pVdbe->pAuxData;
  while( *pp ){
    AuxData *pAux = *pp;
    if( (iOp<0)
     || (pAux->iOp==iOp && (pAux->iArg>31 || !(mask & ((u32)1<<pAux->iArg))))
    ){
      if( pAux->xDelete ){
        pAux->xDelete(pAux->pAux);
      }
      *pp = pAux->pNext;
      sqlite3DbFree(pVdbe->db, pAux);
    }else{
      pp= &pAux->pNext;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x120(%rdi), %r13
movq (%r13), %r12
testq %r12, %r12
je 0x20ad7
testl %r14d, %r14d
js 0x20aa7
cmpl %r14d, (%r12)
jne 0x20ace
movl 0x4(%r12), %eax
cmpl $0x1f, %eax
jg 0x20aa7
btl %eax, %ebx
jb 0x20ace
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x20ab8
movq 0x8(%r12), %rdi
callq *%rax
movq 0x18(%r12), %rax
movq %rax, (%r13)
movq (%r15), %rdi
movq %r12, %rsi
callq 0x968b
jmp 0x20a84
addq $0x18, %r12
movq %r12, %r13
jmp 0x20a84
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeClose
SQLITE_PRIVATE int sqlite3BtreeClose(Btree *p){
  BtShared *pBt = p->pBt;
  BtCursor *pCur;

  /* Close all cursors opened via this handle.  */
  assert( sqlite3_mutex_held(p->db->mutex) );
  sqlite3BtreeEnter(p);
  pCur = pBt->pCursor;
  while( pCur ){
    BtCursor *pTmp = pCur;
    pCur = pCur->pNext;
    if( pTmp->pBtree==p ){
      sqlite3BtreeCloseCursor(pTmp);
    }
  }

  /* Rollback any active transaction and free the handle structure.
  ** The call to sqlite3BtreeRollback() drops any table-locks held by
  ** this handle.
  */
  sqlite3BtreeRollback(p, SQLITE_OK);
  sqlite3BtreeLeave(p);

  /* If there are still other outstanding references to the shared-btree
  ** structure, return now. The remainder of this procedure cleans 
  ** up the shared-btree.
  */
  assert( p->wantToLock==0 && p->locked==0 );
  if( !p->sharable || removeFromSharingList(pBt) ){
    /* The pBt is no longer on the sharing list, so we can access
    ** it without having to hold the mutex.
    **
    ** Clean out and delete the BtShared object.
    */
    assert( !pBt->pCursor );
    sqlite3PagerClose(pBt->pPager);
    if( pBt->xFreeSchema && pBt->pSchema ){
      pBt->xFreeSchema(pBt->pSchema);
    }
    sqlite3DbFree(0, pBt->pSchema);
    freeTempSpace(pBt);
    sqlite3_free(pBt);
  }

#ifndef SQLITE_OMIT_SHARED_CACHE
  assert( p->wantToLock==0 );
  assert( p->locked==0 );
  if( p->pPrev ) p->pPrev->pNext = p->pNext;
  if( p->pNext ) p->pNext->pPrev = p->pPrev;
#endif

  sqlite3_free(p);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %r14
movq %rax, 0x8(%r14)
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x20b1a
movq %r15, %rdi
movq 0x10(%r15), %r15
cmpq %rbx, (%rdi)
jne 0x20b02
callq 0x20bcc
jmp 0x20b02
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd8df
cmpb $0x0, 0x11(%rbx)
je 0x20b6b
movl 0x60(%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x60(%r14)
cmpl $0x1, %eax
jg 0x20ba0
movq 0x68417(%rip), %rcx     # 0x88f58
cmpq %r14, %rcx
je 0x20b5d
testq %rcx, %rcx
je 0x20b6b
movq %rcx, %rax
movq 0x68(%rcx), %rcx
cmpq %r14, %rcx
jne 0x20b46
addq $0x68, %rax
jmp 0x20b64
leaq 0x683f4(%rip), %rax     # 0x88f58
movq 0x68(%r14), %rcx
movq %rcx, (%rax)
movq (%r14), %rdi
callq 0x181e5
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x20b87
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x20b87
callq *%rax
movq 0x40(%r14), %rdi
callq 0x9c7b
movq %r14, %rdi
callq 0x1d923
movq %r14, %rdi
callq 0x9c7b
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0x20bb1
movq %rax, 0x20(%rcx)
testq %rax, %rax
je 0x20bba
movq %rcx, 0x28(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9c7b
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeCloseCursor
SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
  Btree *pBtree = pCur->pBtree;
  if( pBtree ){
    int i;
    BtShared *pBt = pCur->pBt;
    sqlite3BtreeEnter(pBtree);
    sqlite3BtreeClearCursor(pCur);
    if( pCur->pPrev ){
      pCur->pPrev->pNext = pCur->pNext;
    }else{
      pBt->pCursor = pCur->pNext;
    }
    if( pCur->pNext ){
      pCur->pNext->pPrev = pCur->pPrev;
    }
    for(i=0; i<=pCur->iPage; i++){
      releasePage(pCur->apPage[i]);
    }
    unlockBtreeIfUnused(pBt);
    invalidateOverflowCache(pCur);
    /* sqlite3_free(pCur); */
    sqlite3BtreeLeave(pBtree);
  }
  return SQLITE_OK;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x20c4d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
callq 0x1faf7
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
movq %rcx, %rdx
cmoveq %r14, %rdx
movq %rax, 0x10(%rdx)
testq %rax, %rax
je 0x20c14
movq %rcx, 0x18(%rax)
xorl %r15d, %r15d
movswq 0x7a(%rbx), %rax
cmpq %rax, %r15
jg 0x20c33
movq 0xa8(%rbx,%r15,8), %rdi
callq 0x1d90e
incq %r15
jmp 0x20c17
movq %r14, %rdi
callq 0x1d20c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1e351
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3OsCloseFree
SQLITE_PRIVATE int sqlite3OsCloseFree(sqlite3_file *pFile){
  int rc = SQLITE_OK;
  assert( pFile );
  rc = sqlite3OsClose(pFile);
  sqlite3_free(pFile);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x20ca2
movq %rbx, %rdi
callq *0x8(%rax)
andq $0x0, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9c7b
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: vdbeSorterRecordFree
static void vdbeSorterRecordFree(sqlite3 *db, SorterRecord *pRecord){
  SorterRecord *p;
  SorterRecord *pNext;
  for(p=pRecord; p; p=pNext){
    pNext = p->pNext;
    sqlite3DbFree(db, p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x20cd0
movq 0x10(%rsi), %r14
movq %rbx, %rdi
callq 0x968b
movq %r14, %rsi
jmp 0x20cba
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: callFinaliser
static void callFinaliser(sqlite3 *db, int offset){
  int i;
  if( db->aVTrans ){
    for(i=0; i<db->nVTrans; i++){
      VTable *pVTab = db->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, db->aVTrans);
    db->nVTrans = 0;
    db->aVTrans = 0;
  }
}

// Assembly:
cmpq $0x0, 0x1c8(%rdi)
je 0x20d5e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl %esi, %r15d
xorl %r12d, %r12d
movslq 0x1a4(%rbx), %rax
movq 0x1c8(%rbx), %rsi
cmpq %rax, %r12
jge 0x20d3f
movq (%rsi,%r12,8), %r14
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x20d2d
movq (%rdi), %rax
movq (%rax,%r15), %rax
testq %rax, %rax
je 0x20d2d
callq *%rax
andl $0x0, 0x20(%r14)
movq %r14, %rdi
callq 0x1fc99
incq %r12
jmp 0x20cff
movq %rbx, %rdi
callq 0x968b
andl $0x0, 0x1a4(%rbx)
andq $0x0, 0x1c8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3SetString
SQLITE_PRIVATE void sqlite3SetString(char **pz, sqlite3 *db, const char *zFormat, ...){
  va_list ap;
  char *z;

  va_start(ap, zFormat);
  z = sqlite3VMPrintf(db, zFormat, ap);
  va_end(ap);
  sqlite3DbFree(db, *pz);
  *pz = z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xe0(%rbp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x20db5
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %rax
movq %rsi, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000018, %rcx     # imm = 0x3000000018
movq %rcx, (%rax)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x174b9
movq %rax, %r15
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x968b
movq %r15, (%r14)
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3OsOpenMalloc
SQLITE_PRIVATE int sqlite3OsOpenMalloc(
  sqlite3_vfs *pVfs, 
  const char *zFile, 
  sqlite3_file **ppFile, 
  int flags,
  int *pOutFlags
){
  int rc = SQLITE_NOMEM;
  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;
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %r12d
movq %rdx, -0x30(%rbp)
movq %rsi, %rbx
movq %rdi, %r13
movl 0x4(%rdi), %edi
callq 0xbeb2
testq %rax, %rax
je 0x20e67
movq %rax, %r14
andl $0x87f7f, %r12d         # imm = 0x87F7F
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl %r12d, %ecx
movq %r15, %r8
callq *0x28(%r13)
testl %eax, %eax
je 0x20e6d
movl %eax, %r15d
movq %r14, %rdi
callq 0x9c7b
jmp 0x20e77
pushq $0x7
popq %r15
jmp 0x20e77
movq -0x30(%rbp), %rax
movq %r14, (%rax)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VtabImportErrmsg
SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){
  sqlite3 *db = p->db;
  sqlite3DbFree(db, p->zErrMsg);
  p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
  sqlite3_free(pVtab->zErrMsg);
  pVtab->zErrMsg = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x58(%rdi), %rsi
movq %r15, %rdi
callq 0x968b
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0xf173
movq %rax, 0x58(%r14)
movq 0x10(%rbx), %rdi
callq 0x9c7b
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/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);
    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);
      pBt->nPage = get4byte(28 + pBt->pPage1->aData);

      /* The database size was written into the offset 28 of the header
      ** when the transaction started, so we know that the value at offset
      ** 28 is nonzero. */
      assert( pBt->nPage>0 );
    }
    sqlite3BtreeLeave(p);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %eax, %eax
testq %rdi, %rdi
je 0x20f30
cmpb $0x2, 0x10(%rdi)
jne 0x20f30
movl %edx, %r14d
movq (%rdi), %rax
movq 0x8(%rdi), %rbx
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
callq 0x1b942
testl %eax, %eax
jne 0x20f30
testl %r14d, %r14d
jns 0x20f0e
testb $0x8, 0x26(%rbx)
je 0x20f0e
andl $0x0, 0x3c(%rbx)
movq %rbx, %rdi
callq 0x1d141
movl %eax, %r14d
movq 0x18(%rbx), %rax
movq 0x50(%rax), %rdi
addq $0x1c, %rdi
callq 0x180a3
movl %eax, 0x3c(%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VtabSavepoint
SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){
  int rc = SQLITE_OK;

  assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );
  assert( iSavepoint>=0 );
  if( db->aVTrans ){
    int i;
    for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
      VTable *pVTab = db->aVTrans[i];
      const sqlite3_module *pMod = pVTab->pMod->pModule;
      if( pVTab->pVtab && pMod->iVersion>=2 ){
        int (*xMethod)(sqlite3_vtab *, int);
        switch( op ){
          case SAVEPOINT_BEGIN:
            xMethod = pMod->xSavepoint;
            pVTab->iSavepoint = iSavepoint+1;
            break;
          case SAVEPOINT_ROLLBACK:
            xMethod = pMod->xRollbackTo;
            break;
          default:
            xMethod = pMod->xRelease;
            break;
        }
        if( xMethod && pVTab->iSavepoint>iSavepoint ){
          rc = xMethod(pVTab->pVtab, iSavepoint);
        }
      }
    }
  }
  return rc;
}

// Assembly:
cmpq $0x0, 0x1c8(%rdi)
je 0x20fcf
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
leal 0x1(%rbx), %r12d
xorl %r13d, %r13d
xorl %eax, %eax
testl %eax, %eax
jne 0x20fd4
movslq 0x1a4(%r15), %rax
cmpq %rax, %r13
jge 0x20fd2
movq 0x1c8(%r15), %rax
movq (%rax,%r13,8), %rcx
movq 0x10(%rcx), %rdi
xorl %eax, %eax
testq %rdi, %rdi
je 0x20fca
movq 0x8(%rcx), %rdx
movq (%rdx), %rdx
cmpl $0x2, (%rdx)
jl 0x20fca
cmpl $0x2, %r14d
je 0x20fac
testl %r14d, %r14d
jne 0x20fb5
movq 0xa0(%rdx), %rdx
movl %r12d, 0x20(%rcx)
jmp 0x20fbc
movq 0xb0(%rdx), %rdx
jmp 0x20fbc
movq 0xa8(%rdx), %rdx
testq %rdx, %rdx
je 0x20fca
cmpl %ebx, 0x20(%rcx)
jle 0x20fca
movl %ebx, %esi
callq *%rdx
incq %r13
jmp 0x20f62
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemMakeWriteable
SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
  int f;
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( (pMem->flags&MEM_RowSet)==0 );
  ExpandBlob(pMem);
  f = pMem->flags;
  if( (f&(MEM_Str|MEM_Blob)) && pMem->z!=pMem->zMalloc ){
    if( sqlite3VdbeMemGrow(pMem, pMem->n + 2, 1) ){
      return SQLITE_NOMEM;
    }
    pMem->z[pMem->n] = 0;
    pMem->z[pMem->n+1] = 0;
    pMem->flags |= MEM_Term;
#ifdef SQLITE_DEBUG
    pMem->pScopyFrom = 0;
#endif
  }

  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x24(%rdi), %ecx
btl $0xe, %ecx
jae 0x219bd
movq %rbx, %rdi
callq 0xdec5
movzwl 0x24(%rbx), %ecx
xorl %eax, %eax
testb $0x12, %cl
je 0x21a05
movq 0x8(%rbx), %rcx
cmpq 0x30(%rbx), %rcx
je 0x21a05
movl 0x20(%rbx), %esi
addl $0x2, %esi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0xf2c6
testl %eax, %eax
je 0x219e8
pushq $0x7
popq %rax
jmp 0x21a05
movq 0x8(%rbx), %rcx
movslq 0x20(%rbx), %rdx
xorl %eax, %eax
movb %al, (%rcx,%rdx)
movq 0x8(%rbx), %rcx
movslq 0x20(%rbx), %rdx
movb %al, 0x1(%rcx,%rdx)
orb $0x2, 0x25(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemNulTerminate
SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  if( (pMem->flags & MEM_Term)!=0 || (pMem->flags & MEM_Str)==0 ){
    return SQLITE_OK;   /* Nothing to do */
  }
  if( sqlite3VdbeMemGrow(pMem, pMem->n+2, 1) ){
    return SQLITE_NOMEM;
  }
  pMem->z[pMem->n] = 0;
  pMem->z[pMem->n+1] = 0;
  pMem->flags |= MEM_Term;
  return SQLITE_OK;
}

// Assembly:
movzwl 0x24(%rdi), %eax
andl $0x202, %eax            # imm = 0x202
cmpw $0x2, %ax
jne 0x21a59
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rdi), %esi
addl $0x2, %esi
pushq $0x1
popq %rdx
callq 0xf2c6
testl %eax, %eax
jne 0x21a53
movq 0x8(%rbx), %rax
movslq 0x20(%rbx), %rcx
xorl %edx, %edx
movb %dl, (%rax,%rcx)
movq 0x8(%rbx), %rax
movslq 0x20(%rbx), %rcx
movb %dl, 0x1(%rax,%rcx)
orb $0x2, 0x25(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemStringify
SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, int enc){
  int rc = SQLITE_OK;
  int fg = pMem->flags;
  const int nByte = 32;

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


  if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){
    return SQLITE_NOMEM;
  }

  /* For a Real or Integer, use sqlite3_mprintf() to produce the UTF-8
  ** string representation of the value. Then, if the required encoding
  ** is UTF-16le or UTF-16be do a translation.
  ** 
  ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
  */
  if( fg & MEM_Int ){
    sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
  }else{
    assert( fg & MEM_Real );
    sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->r);
  }
  pMem->n = sqlite3Strlen30(pMem->z);
  pMem->enc = SQLITE_UTF8;
  pMem->flags |= MEM_Str|MEM_Term;
  sqlite3VdbeChangeEncoding(pMem, enc);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movzwl 0x24(%rdi), %r15d
pushq $0x20
popq %rsi
xorl %edx, %edx
callq 0xf2c6
testl %eax, %eax
je 0x21a81
pushq $0x7
popq %rax
jmp 0x21ade
movq 0x8(%r14), %rsi
testb $0x4, %r15b
jne 0x21aa4
movsd 0x10(%r14), %xmm0
leaq 0x49e6a(%rip), %rdx     # 0x6b902
pushq $0x20
popq %rdi
movb $0x1, %al
callq 0xaf26
jmp 0x21ab9
movq 0x18(%r14), %rcx
leaq 0x4af5b(%rip), %rdx     # 0x6ca0a
pushq $0x20
popq %rdi
xorl %eax, %eax
callq 0xaf26
movq 0x8(%r14), %rdi
callq 0x8f8e
movl %eax, 0x20(%r14)
movb $0x1, 0x27(%r14)
orw $0x202, 0x24(%r14)      # imm = 0x202
movq %r14, %rdi
movl %ebx, %esi
callq 0x2144b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3RowSetClear
SQLITE_PRIVATE void sqlite3RowSetClear(RowSet *p){
  struct RowSetChunk *pChunk, *pNextChunk;
  for(pChunk=p->pChunk; pChunk; pChunk = pNextChunk){
    pNextChunk = pChunk->pNextChunk;
    sqlite3DbFree(p->db, pChunk);
  }
  p->pChunk = 0;
  p->nFresh = 0;
  p->pEntry = 0;
  p->pLast = 0;
  p->pForest = 0;
  p->rsFlags = ROWSET_SORTED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x21b0c
movq (%rsi), %r14
movq 0x8(%rbx), %rdi
callq 0x968b
movq %r14, %rsi
jmp 0x21af6
andq $0x0, (%rbx)
andw $0x0, 0x30(%rbx)
andq $0x0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movb $0x1, 0x32(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3OsCurrentTimeInt64
SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){
  int rc;
  /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64()
  ** method to get the current date and time if that method is available
  ** (if iVersion is 2 or greater and the function pointer is not NULL) and
  ** will fall back to xCurrentTime() if xCurrentTimeInt64() is
  ** unavailable.
  */
  if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
    rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut);
  }else{
    double r;
    rc = pVfs->xCurrentTime(pVfs, &r);
    *pTimeOut = (sqlite3_int64)(r*86400000.0);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpl $0x2, (%rdi)
jl 0x21b56
movq 0x88(%rdi), %rax
testq %rax, %rax
je 0x21b56
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
leaq -0x18(%rbp), %r14
movq %r14, %rsi
callq *0x78(%rdi)
movsd (%r14), %xmm0
mulsd 0x49743(%rip), %xmm0    # 0x6b2b0
cvttsd2si %xmm0, %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemTooBig
SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem *p){
  assert( p->db!=0 );
  if( p->flags & (MEM_Str|MEM_Blob) ){
    int n = p->n;
    if( p->flags & MEM_Zero ){
      n += p->u.nZero;
    }
    return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
  }
  return 0; 
}

// Assembly:
movzwl 0x24(%rdi), %eax
testb $0x12, %al
je 0x298e3
movl 0x20(%rdi), %ecx
btl $0xe, %eax
jae 0x298d2
addl 0x18(%rdi), %ecx
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
xorl %eax, %eax
cmpl 0x68(%rdx), %ecx
setg %al
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemShallowCopy
SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
  assert( (pFrom->flags & MEM_RowSet)==0 );
  VdbeMemRelease(pTo);
  memcpy(pTo, pFrom, MEMCELLSIZE);
  pTo->xDel = 0;
  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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movzwl 0x24(%rdi), %eax
testw $0x2460, %ax            # imm = 0x2460
je 0x2990b
movq %rbx, %rdi
callq 0xf251
movq 0x20(%r15), %rax
movq %rax, 0x20(%rbx)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
andq $0x0, 0x28(%rbx)
testb $0x8, 0x25(%r15)
jne 0x2993e
movl $0xffffe3ff, %eax       # imm = 0xFFFFE3FF
andl 0x24(%rbx), %eax
orl %r14d, %eax
movw %ax, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemMove
SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
  assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
  assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
  assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );

  sqlite3VdbeMemRelease(pTo);
  memcpy(pTo, pFrom, sizeof(Mem));
  pFrom->flags = MEM_Null;
  pFrom->xDel = 0;
  pFrom->zMalloc = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xde44
movq 0x30(%rbx), %rax
movq %rax, 0x30(%r14)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x20(%r14)
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
movw $0x1, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq