// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_blob_open
SQLITE_API int sqlite3_blob_open(
  sqlite3* db,            /* The database connection */
  const char *zDb,        /* The attached database containing the blob */
  const char *zTable,     /* The table containing the blob */
  const char *zColumn,    /* The column containing the blob */
  sqlite_int64 iRow,      /* The row containing the glob */
  int flags,              /* True -> read/write access, false -> read-only */
  sqlite3_blob **ppBlob   /* Handle for accessing the blob returned here */
){
  int nAttempt = 0;
  int iCol;               /* Index of zColumn in row-record */

  /* This VDBE program seeks a btree cursor to the identified 
  ** db/table/row entry. The reason for using a vdbe program instead
  ** of writing code to use the b-tree layer directly is that the
  ** vdbe program will take advantage of the various transaction,
  ** locking and error handling infrastructure built into the vdbe.
  **
  ** After seeking the cursor, the vdbe executes an OP_ResultRow.
  ** Code external to the Vdbe then "borrows" the b-tree cursor and
  ** uses it to implement the blob_read(), blob_write() and 
  ** blob_bytes() functions.
  **
  ** The sqlite3_blob_close() function finalizes the vdbe program,
  ** which closes the b-tree cursor and (possibly) commits the 
  ** transaction.
  */
  static const VdbeOpList openBlob[] = {
    {OP_Transaction, 0, 0, 0},     /* 0: Start a transaction */
    {OP_VerifyCookie, 0, 0, 0},    /* 1: Check the schema cookie */
    {OP_TableLock, 0, 0, 0},       /* 2: Acquire a read or write lock */

    /* One of the following two instructions is replaced by an OP_Noop. */
    {OP_OpenRead, 0, 0, 0},        /* 3: Open cursor 0 for reading */
    {OP_OpenWrite, 0, 0, 0},       /* 4: Open cursor 0 for read/write */

    {OP_Variable, 1, 1, 1},        /* 5: Push the rowid to the stack */
    {OP_NotExists, 0, 10, 1},      /* 6: Seek the cursor */
    {OP_Column, 0, 0, 1},          /* 7  */
    {OP_ResultRow, 1, 0, 0},       /* 8  */
    {OP_Goto, 0, 5, 0},            /* 9  */
    {OP_Close, 0, 0, 0},           /* 10 */
    {OP_Halt, 0, 0, 0},            /* 11 */
  };

  int rc = SQLITE_OK;
  char *zErr = 0;
  Table *pTab;
  Parse *pParse = 0;
  Incrblob *pBlob = 0;

  flags = !!flags;                /* flags = (flags ? 1 : 0); */
  *ppBlob = 0;

  sqlite3_mutex_enter(db->mutex);

  pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
  if( !pBlob ) goto blob_open_out;
  pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
  if( !pParse ) goto blob_open_out;

  do {
    memset(pParse, 0, sizeof(Parse));
    pParse->db = db;
    sqlite3DbFree(db, zErr);
    zErr = 0;

    sqlite3BtreeEnterAll(db);
    pTab = sqlite3LocateTable(pParse, 0, zTable, zDb);
    if( pTab && IsVirtual(pTab) ){
      pTab = 0;
      sqlite3ErrorMsg(pParse, "cannot open virtual table: %s", zTable);
    }
#ifndef SQLITE_OMIT_VIEW
    if( pTab && pTab->pSelect ){
      pTab = 0;
      sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable);
    }
#endif
    if( !pTab ){
      if( pParse->zErrMsg ){
        sqlite3DbFree(db, zErr);
        zErr = pParse->zErrMsg;
        pParse->zErrMsg = 0;
      }
      rc = SQLITE_ERROR;
      sqlite3BtreeLeaveAll(db);
      goto blob_open_out;
    }

    /* Now search pTab for the exact column. */
    for(iCol=0; iCol<pTab->nCol; iCol++) {
      if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
        break;
      }
    }
    if( iCol==pTab->nCol ){
      sqlite3DbFree(db, zErr);
      zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn);
      rc = SQLITE_ERROR;
      sqlite3BtreeLeaveAll(db);
      goto blob_open_out;
    }

    /* If the value is being opened for writing, check that the
    ** column is not indexed, and that it is not part of a foreign key. 
    ** It is against the rules to open a column to which either of these
    ** descriptions applies for writing.  */
    if( flags ){
      const char *zFault = 0;
      Index *pIdx;
#ifndef SQLITE_OMIT_FOREIGN_KEY
      if( db->flags&SQLITE_ForeignKeys ){
        /* Check that the column is not part of an FK child key definition. It
        ** is not necessary to check if it is part of a parent key, as parent
        ** key columns must be indexed. The check below will pick up this 
        ** case.  */
        FKey *pFKey;
        for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
          int j;
          for(j=0; j<pFKey->nCol; j++){
            if( pFKey->aCol[j].iFrom==iCol ){
              zFault = "foreign key";
            }
          }
        }
      }
#endif
      for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
        int j;
        for(j=0; j<pIdx->nColumn; j++){
          if( pIdx->aiColumn[j]==iCol ){
            zFault = "indexed";
          }
        }
      }
      if( zFault ){
        sqlite3DbFree(db, zErr);
        zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
        rc = SQLITE_ERROR;
        sqlite3BtreeLeaveAll(db);
        goto blob_open_out;
      }
    }

    pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(db);
    assert( pBlob->pStmt || db->mallocFailed );
    if( pBlob->pStmt ){
      Vdbe *v = (Vdbe *)pBlob->pStmt;
      int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);

      sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);


      /* Configure the OP_Transaction */
      sqlite3VdbeChangeP1(v, 0, iDb);
      sqlite3VdbeChangeP2(v, 0, flags);

      /* Configure the OP_VerifyCookie */
      sqlite3VdbeChangeP1(v, 1, iDb);
      sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);
      sqlite3VdbeChangeP3(v, 1, pTab->pSchema->iGeneration);

      /* Make sure a mutex is held on the table to be accessed */
      sqlite3VdbeUsesBtree(v, iDb); 

      /* Configure the OP_TableLock instruction */
#ifdef SQLITE_OMIT_SHARED_CACHE
      sqlite3VdbeChangeToNoop(v, 2);
#else
      sqlite3VdbeChangeP1(v, 2, iDb);
      sqlite3VdbeChangeP2(v, 2, pTab->tnum);
      sqlite3VdbeChangeP3(v, 2, flags);
      sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
#endif

      /* Remove either the OP_OpenWrite or OpenRead. Set the P2 
      ** parameter of the other to pTab->tnum.  */
      sqlite3VdbeChangeToNoop(v, 4 - flags);
      sqlite3VdbeChangeP2(v, 3 + flags, pTab->tnum);
      sqlite3VdbeChangeP3(v, 3 + flags, iDb);

      /* Configure the number of columns. Configure the cursor to
      ** think that the table has one more column than it really
      ** does. An OP_Column to retrieve this imaginary column will
      ** always return an SQL NULL. This is useful because it means
      ** we can invoke OP_Column to fill in the vdbe cursors type 
      ** and offset cache without causing any IO.
      */
      sqlite3VdbeChangeP4(v, 3+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
      sqlite3VdbeChangeP2(v, 7, pTab->nCol);
      if( !db->mallocFailed ){
        pParse->nVar = 1;
        pParse->nMem = 1;
        pParse->nTab = 1;
        sqlite3VdbeMakeReady(v, pParse);
      }
    }
   
    pBlob->flags = flags;
    pBlob->iCol = iCol;
    pBlob->db = db;
    sqlite3BtreeLeaveAll(db);
    if( db->mallocFailed ){
      goto blob_open_out;
    }
    sqlite3_bind_int64(pBlob->pStmt, 1, iRow);
    rc = blobSeekToRow(pBlob, iRow, &zErr);
  } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );

blob_open_out:
  if( rc==SQLITE_OK && db->mallocFailed==0 ){
    *ppBlob = (sqlite3_blob *)pBlob;
  }else{
    if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
    sqlite3DbFree(db, pBlob);
  }
  sqlite3Error(db, rc, (zErr ? "%s" : 0), zErr);
  sqlite3DbFree(db, zErr);
  sqlite3StackFree(db, pParse);
  rc = sqlite3ApiExit(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, -0xa8(%rbp)
movq %rcx, %r14
movq %rdx, -0x78(%rbp)
movq %rsi, -0xb0(%rbp)
movq %rdi, %r15
movq 0x10(%rbp), %rcx
xorl %eax, %eax
movq %rax, -0x40(%rbp)
xorl %r13d, %r13d
movl %r9d, -0x50(%rbp)
testl %r9d, %r9d
setne %bl
movq %rcx, -0x98(%rbp)
movq %rax, (%rcx)
movl $0x28, %esi
callq 0x11721
movq %rax, %r12
movl $0x0, %eax
movq %rax, -0x48(%rbp)
testq %r12, %r12
je 0x115e6
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movups %xmm0, (%r12)
movq $0x0, 0x20(%r12)
movq %r15, %rdi
movl $0x298, %esi            # imm = 0x298
callq 0x11721
testq %rax, %rax
je 0x115de
movq $0x0, -0x70(%rbp)
movq %r14, -0x90(%rbp)
movq %r12, -0x30(%rbp)
movb %bl, %r13b
movl %r13d, -0x34(%rbp)
xorl %edx, %edx
cmpl $0x0, -0x50(%rbp)
setne %dl
movl $0x4, %ecx
subl %edx, %ecx
movl %ecx, -0x64(%rbp)
addl $0x3, %edx
movq %rdx, -0x88(%rbp)
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0xa0(%rbp)
leaq 0x64ee0(%rip), %r12     # 0x760b0
leaq 0x6a2b3(%rip), %rbx     # 0x7b48a
xorl %ecx, %ecx
movq %rax, %r13
movq %rax, -0x48(%rbp)
movl %ecx, -0x4c(%rbp)
movl $0x290, %edx            # imm = 0x290
movq -0xa0(%rbp), %rdi
xorl %esi, %esi
callq 0x8200
movq %r15, (%r13)
movq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x9ca4
movq $0x0, -0x40(%rbp)
movslq 0x28(%r15), %rax
testq %rax, %rax
jle 0x1123f
movq 0x20(%r15), %rcx
shlq $0x5, %rax
xorl %edx, %edx
movq 0x8(%rcx,%rdx), %rsi
testq %rsi, %rsi
je 0x11236
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
movq %rdi, 0x8(%rsi)
addq $0x20, %rdx
cmpq %rdx, %rax
jne 0x11221
movq %r13, %rdi
xorl %esi, %esi
movq -0x78(%rbp), %rdx
movq -0xb0(%rbp), %rcx
callq 0x117b5
testq %rax, %rax
je 0x116b0
testb $0x10, 0x46(%rax)
movq -0x90(%rbp), %r14
jne 0x11692
cmpq $0x0, 0x18(%rax)
jne 0x1169b
movswl 0x42(%rax), %r11d
testl %r11d, %r11d
jle 0x112f0
movq 0x8(%rax), %rcx
movl %r11d, %edx
xorl %r13d, %r13d
leaq (,%r13,2), %rsi
addq %r13, %rsi
shlq $0x4, %rsi
movq (%rcx,%rsi), %rdi
movb (%rdi), %r8b
testb %r8b, %r8b
je 0x112d0
incq %rdi
movq %r14, %rsi
movzbl %r8b, %r8d
movb (%r8,%r12), %r9b
movzbl (%rsi), %r10d
cmpb (%r10,%r12), %r9b
jne 0x112d6
incq %rsi
movb (%rdi), %r8b
incq %rdi
testb %r8b, %r8b
jne 0x112ae
jmp 0x112d3
movq %r14, %rsi
xorl %r8d, %r8d
movb (%r8,%r12), %dil
movzbl (%rsi), %esi
cmpb (%rsi,%r12), %dil
je 0x112f3
incq %r13
cmpq %rdx, %r13
jne 0x1128d
jmp 0x115b1
xorl %r13d, %r13d
cmpl %r11d, %r13d
je 0x115b1
cmpl $0x0, -0x50(%rbp)
je 0x11386
testb $0x8, 0x2e(%r15)
je 0x1134c
movq 0x20(%rax), %rdi
testq %rdi, %rdi
leaq 0x681ba(%rip), %rsi     # 0x794d5
je 0x1134c
xorl %r14d, %r14d
movslq 0x28(%rdi), %rcx
testq %rcx, %rcx
jle 0x11341
shlq $0x4, %rcx
xorl %edx, %edx
cmpl %r13d, 0x40(%rdi,%rdx)
cmoveq %rsi, %r14
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x1132f
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x11320
jmp 0x1134f
xorl %r14d, %r14d
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x1137d
movzwl 0x54(%rdi), %ecx
testq %rcx, %rcx
je 0x11377
movq 0x8(%rdi), %rdx
xorl %esi, %esi
cmpl %r13d, (%rdx,%rsi,4)
cmoveq %rbx, %r14
incq %rsi
cmpq %rsi, %rcx
jne 0x11367
movq 0x28(%rdi), %rdi
jmp 0x11353
testq %r14, %r14
jne 0x116df
movq %rax, -0x58(%rbp)
movq %r15, %rdi
callq 0x11977
movq %rax, %r14
movq -0x30(%rbp), %rax
movq %r14, 0x18(%rax)
testq %r14, %r14
je 0x114e1
movq -0x58(%rbp), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
movq %r15, -0x80(%rbp)
je 0x113e0
movl 0x28(%r15), %ecx
testl %ecx, %ecx
jle 0x113e8
movq 0x20(%r15), %rdx
addq $0x18, %rdx
xorl %r15d, %r15d
cmpq %rax, (%rdx)
je 0x113eb
incq %r15
addq $0x20, %rdx
cmpq %r15, %rcx
jne 0x113ca
movl %ecx, %r15d
jmp 0x113eb
movl $0xfff0bdc0, %r15d      # imm = 0xFFF0BDC0
jmp 0x113eb
xorl %r15d, %r15d
movq %r14, %rdi
movl $0xc, %esi
leaq 0x64db6(%rip), %rdx     # 0x761b0
callq 0x119d6
movl 0x34(%r14), %edx
testl %edx, %edx
je 0x1141e
movq 0x8(%r14), %rax
movl %r15d, 0x4(%rax)
movl -0x34(%rbp), %ecx
movl %ecx, 0x8(%rax)
cmpl $0x1, %edx
jne 0x11560
movl $0x1, %eax
movl %r15d, %ecx
shll %cl, %eax
orl %eax, 0xa0(%r14)
movq -0x58(%rbp), %rdi
movq %rdi, %rax
addq $0x3c, %rax
movq %rax, -0x60(%rbp)
movq (%rdi), %rdx
movq %r14, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x11a9f
movq %r14, %rdi
movl -0x64(%rbp), %esi
callq 0x11c3f
movq -0x88(%rbp), %rsi
cmpl %esi, 0x34(%r14)
jbe 0x1147f
movq -0x60(%rbp), %rax
movl (%rax), %eax
movq 0x8(%r14), %rcx
leaq (%rsi,%rsi,2), %rdx
movl %eax, 0x8(%rcx,%rdx,8)
movl %r15d, 0xc(%rcx,%rdx,8)
movq -0x58(%rbp), %r15
movswq 0x42(%r15), %rdx
incq %rdx
movq %r14, %rdi
movl $0xfffffff2, %ecx       # imm = 0xFFFFFFF2
callq 0x11a9f
cmpl $0x8, 0x34(%r14)
jb 0x114ae
movswl 0x42(%r15), %eax
movq 0x8(%r14), %rcx
movl %eax, 0xb0(%rcx)
movq -0x80(%rbp), %r15
cmpb $0x0, 0x50(%r15)
jne 0x116f5
movq -0x48(%rbp), %rsi
movl $0x1, 0x1f8(%rsi)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x54(%rsi)
movq %r14, %rdi
callq 0x11c84
cmpb $0x0, 0x50(%r15)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movl %r13d, 0xc(%rax)
movq %r15, 0x20(%rax)
movl -0x4c(%rbp), %r14d
jne 0x1170f
movq %r15, %r13
movq -0x30(%rbp), %r14
movq 0x18(%r14), %rdi
movl $0x1, %esi
movq -0xa8(%rbp), %r15
movq %r15, %rdx
callq 0x10c21
movq %r14, %rdi
movq %r15, %rsi
leaq -0x40(%rbp), %rdx
callq 0x1209b
movl %eax, %r14d
movq -0x70(%rbp), %rax
cmpl $0x30, %eax
ja 0x1170c
incl %eax
movq %rax, -0x70(%rbp)
movl $0x11, %ecx
cmpl $0x11, %r14d
movq %r13, %r15
movq -0x48(%rbp), %r13
je 0x111e0
jmp 0x1170f
movl %r15d, 0x1c(%rax)
movq -0x58(%rbp), %rdi
movq 0x68(%rdi), %rcx
movl (%rcx), %esi
movl %esi, 0x20(%rax)
movl 0x4(%rcx), %ecx
movl %ecx, 0x24(%rax)
movl $0x1, %esi
movl %r15d, %ecx
shll %cl, %esi
orl %esi, 0xa0(%r14)
cmpl $0x2, %edx
jbe 0x11433
movl %r15d, 0x34(%rax)
movq %rdi, %rcx
addq $0x3c, %rcx
movq %rcx, -0x60(%rbp)
movl 0x3c(%rdi), %ecx
movl %ecx, 0x38(%rax)
movl -0x34(%rbp), %ecx
movl %ecx, 0x3c(%rax)
jmp 0x1143e
movq %r15, %rdi
xorl %esi, %esi
callq 0x9ca4
leaq 0x67efe(%rip), %rsi     # 0x794c0
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x11900
movq %rax, -0x40(%rbp)
movl $0x1, %ebx
movq -0x30(%rbp), %r12
jmp 0x115ef
movq $0x0, -0x48(%rbp)
cmpb $0x0, 0x50(%r15)
je 0x1162e
xorl %ebx, %ebx
movl %ebx, %r14d
testq %r12, %r12
je 0x11606
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x11606
callq 0xeac6
movq %r15, %rdi
movq %r12, %rsi
callq 0x9ca4
movq %r15, %rbx
movq -0x40(%rbp), %r15
testq %r15, %r15
leaq 0x680b7(%rip), %rdx     # 0x796d9
cmoveq %r15, %rdx
movq %rbx, %rdi
movl %r14d, %esi
jmp 0x11655
movq -0x98(%rbp), %rax
movq %r12, (%rax)
movq %r15, %rbx
movq -0x40(%rbp), %r15
testq %r15, %r15
leaq 0x68090(%rip), %rdx     # 0x796d9
cmoveq %r15, %rdx
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
xorl %eax, %eax
callq 0xca2d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9ca4
movq %rbx, %rdi
movq -0x48(%rbp), %rsi
callq 0x9ca4
movq %rbx, %rdi
movl %r14d, %esi
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeaff
leaq 0x67df4(%rip), %rsi     # 0x7948d
jmp 0x116a2
leaq 0x67e09(%rip), %rsi     # 0x794ab
movq %r13, %rdi
movq -0x78(%rbp), %rdx
xorl %eax, %eax
callq 0x11842
movl $0x1, %ebx
cmpq $0x0, 0x8(%r13)
je 0x115d8
movq %r15, %rdi
xorl %esi, %esi
callq 0x9ca4
movq 0x8(%r13), %rax
movq %rax, -0x40(%rbp)
movq $0x0, 0x8(%r13)
jmp 0x115d8
movq %r15, %rdi
xorl %esi, %esi
callq 0x9ca4
leaq 0x67df1(%rip), %rsi     # 0x794e1
jmp 0x115c2
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movl %r13d, 0xc(%rax)
movq %r15, 0x20(%rax)
movl -0x4c(%rbp), %r14d
jmp 0x1170f
movq %r13, %r15
testl %r14d, %r14d
movq -0x30(%rbp), %r12
jne 0x115f7
jmp 0x115e6