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: sqlite3ValueText
SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
  if( !pVal ) return 0;
  assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
  assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
  assert( !sqlite3VdbeMemIsRowSet(pVal) );
  if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
    assert( sqlite3VdbeMemValidStrRep(pVal) );
    return pVal->z;
  }
  if( pVal->flags&MEM_Null ){
    return 0;
  }
  return valueToText(pVal, enc);
}

// Assembly:
testq %rdi, %rdi
je 0x281cc2
movl 0x8(%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x202, %ecx            # imm = 0x202
jne 0x281cb5
cmpb %sil, 0xa(%rdi)
jne 0x281cb5
movq 0x10(%rdi), %rax
retq
testb $0x1, %al
jne 0x281cc2
movzbl %sil, %esi
jmp 0x29b6f4
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_value_dup
SQLITE_API sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig){
  sqlite3_value *pNew;
  if( pOrig==0 ) return 0;
  pNew = sqlite3_malloc( sizeof(*pNew) );
  if( pNew==0 ) return 0;
  memset(pNew, 0, sizeof(*pNew));
  memcpy(pNew, pOrig, MEMCELLSIZE);
  pNew->flags &= ~MEM_Dyn;
  pNew->db = 0;
  if( pNew->flags&(MEM_Str|MEM_Blob) ){
    pNew->flags &= ~(MEM_Static|MEM_Dyn);
    pNew->flags |= MEM_Ephem;
    if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){
      sqlite3ValueFree(pNew);
      pNew = 0;
    }
  }
  return pNew;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x281d90
movq %rdi, %r14
callq 0x27bed9
testl %eax, %eax
je 0x281d21
xorl %ebx, %ebx
jmp 0x281d2e
movl $0x38, %edi
callq 0x27c381
movq %rax, %rbx
testq %rbx, %rbx
je 0x281d90
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
xorl %ecx, %ecx
movq %rcx, 0x30(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movzwl 0x8(%rbx), %eax
movl %eax, %edx
andl $0xfbff, %edx           # imm = 0xFBFF
movw %dx, 0x8(%rbx)
movq %rcx, 0x28(%rbx)
testb $0x12, %al
je 0x281d92
andl $0xffffe3ff, %eax       # imm = 0xFFFFE3FF
orl $0x1000, %eax           # imm = 0x1000
movw %ax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x281d9d
testl %eax, %eax
je 0x281d92
movq %rbx, %rdi
callq 0x281de6
xorl %ebx, %ebx
movq %rbx, %rax
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: sqlite3VdbeMemMakeWriteable
SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){
    if( ExpandBlob(pMem) ) return SQLITE_NOMEM;
    if( pMem->szMalloc==0 || pMem->z!=pMem->zMalloc ){
      int rc = vdbeMemAddTerminator(pMem);
      if( rc ) return rc;
    }
  }
  pMem->flags &= ~MEM_Ephem;
#ifdef SQLITE_DEBUG
  pMem->pScopyFrom = 0;
#endif

  return SQLITE_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
testb $0x12, %al
je 0x281dde
btl $0xe, %eax
jae 0x281dc2
movq %rbx, %rdi
callq 0x281b53
movl %eax, %ecx
movl $0x7, %eax
testl %ecx, %ecx
jne 0x281de4
cmpl $0x0, 0x20(%rbx)
je 0x281dd2
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
je 0x281dde
movq %rbx, %rdi
callq 0x29be39
testl %eax, %eax
jne 0x281de4
andb $-0x11, 0x9(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: invokeValueDestructor
static int invokeValueDestructor(
  const void *p,             /* Value to destroy */
  void (*xDel)(void*),       /* The destructor */
  sqlite3_context *pCtx      /* Set a SQLITE_TOOBIG error if no NULL */
){
  assert( xDel!=SQLITE_DYNAMIC );
  if( xDel==0 ){
    /* noop */
  }else if( xDel==SQLITE_TRANSIENT ){
    /* noop */
  }else{
    xDel((void*)p);
  }
  if( pCtx ) sqlite3_result_error_toobig(pCtx);
  return SQLITE_TOOBIG;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
leaq 0x1(%rsi), %rax
cmpq $0x2, %rax
jb 0x281e82
callq *%rsi
testq %rbx, %rbx
je 0x281ea8
movl $0x12, 0x24(%rbx)
movq (%rbx), %rdi
leaq 0x15d1b6(%rip), %rsi    # 0x3df04e
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
popq %rbx
jmp 0x281f27
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemSetDouble
SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
  sqlite3VdbeMemSetNull(pMem);
  if( !sqlite3IsNaN(val) ){
    pMem->u.r = val;
    pMem->flags = MEM_Real;
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testb $0x24, 0x9(%rdi)
je 0x281ed3
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x29b491
movq 0x8(%rsp), %xmm0
jmp 0x281ed9
movw $0x1, 0x8(%rbx)
movq %xmm0, %rax
movq %rax, %rcx
notq %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
testq %rdx, %rcx
sete %cl
shlq $0xc, %rax
setne %al
testb %al, %cl
jne 0x281f09
movq %xmm0, (%rbx)
movw $0x8, 0x8(%rbx)
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: sqlite3_result_pointer
SQLITE_API void sqlite3_result_pointer(
  sqlite3_context *pCtx,
  void *pPtr,
  const char *zPType,
  void (*xDestructor)(void*)
){
  Mem *pOut = pCtx->pOut;
  assert( sqlite3_mutex_held(pOut->db->mutex) );
  sqlite3VdbeMemRelease(pOut);
  pOut->flags = MEM_Null;
  sqlite3VdbeMemSetPointer(pOut, pPtr, zPType, xDestructor);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq (%rdi), %r14
testb $0x24, 0x9(%r14)
jne 0x28225c
cmpl $0x0, 0x20(%r14)
je 0x282264
movq %r14, %rdi
callq 0x29b45b
testq %r12, %r12
leaq 0x151622(%rip), %rax    # 0x3d3890
cmovneq %r12, %rax
movq %rax, (%r14)
movq %r15, 0x10(%r14)
movw $0x8601, 0x8(%r14)      # imm = 0x8601
movb $0x70, 0xb(%r14)
testq %rbx, %rbx
leaq 0x1a4a8(%rip), %rax     # 0x29c737
cmovneq %rbx, %rax
movq %rax, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_result_text64
SQLITE_API void sqlite3_result_text64(
  sqlite3_context *pCtx,
  const char *z,
  sqlite3_uint64 n,
  void (*xDel)(void *),
  unsigned char enc
){
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  assert( xDel!=SQLITE_DYNAMIC );
  if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
  if( n>0x7fffffff ){
    (void)invokeValueDestructor(z, xDel, pCtx);
  }else{
    setResultStrOrError(pCtx, z, (int)n, enc, xDel);
  }
}

// Assembly:
movq %rcx, %r9
movq %rdi, %rax
movq %rdx, %rcx
shrq $0x1f, %rcx
je 0x2822d9
movq %rsi, %rdi
movq %r9, %rsi
movq %rax, %rdx
jmp 0x281e72
cmpb $0x4, %r8b
movzbl %r8b, %ecx
movl $0x2, %edi
cmovnel %ecx, %edi
movzbl %dil, %ecx
movq %rax, %rdi
movq %r9, %r8
jmp 0x281e1a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemCopy
SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
  int rc = SQLITE_OK;

  assert( !sqlite3VdbeMemIsRowSet(pFrom) );
  if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo);
  memcpy(pTo, pFrom, MEMCELLSIZE);
  pTo->flags &= ~MEM_Dyn;
  if( pTo->flags&(MEM_Str|MEM_Blob) ){
    if( 0==(pFrom->flags&MEM_Static) ){
      pTo->flags |= MEM_Ephem;
      rc = sqlite3VdbeMemMakeWriteable(pTo);
    }
  }

  return rc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testb $0x24, 0x9(%rdi)
je 0x28233c
movq %rbx, %rdi
callq 0x29b491
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movzwl 0x8(%rbx), %ecx
movl %ecx, %eax
andl $0xfbff, %eax           # imm = 0xFBFF
movw %ax, 0x8(%rbx)
testb $0x12, %cl
je 0x28237e
testb $0x8, 0x9(%r14)
jne 0x28237e
orl $0x1000, %eax           # imm = 0x1000
movw %ax, 0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x281d9d
xorl %eax, %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: sqlite3VdbeMemSetZeroBlob
SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
  sqlite3VdbeMemRelease(pMem);
  pMem->flags = MEM_Blob|MEM_Zero;
  pMem->n = 0;
  if( n<0 ) n = 0;
  pMem->u.nZero = n;
  pMem->enc = SQLITE_UTF8;
  pMem->z = 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testb $0x24, 0x9(%rdi)
jne 0x2823a1
cmpl $0x0, 0x20(%rbx)
je 0x2823a9
movq %rbx, %rdi
callq 0x29b45b
movw $0x4010, 0x8(%rbx)      # imm = 0x4010
xorl %eax, %eax
movl %eax, 0xc(%rbx)
testl %ebp, %ebp
cmovgl %ebp, %eax
movl %eax, (%rbx)
movb $0x1, 0xa(%rbx)
movq $0x0, 0x10(%rbx)
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: sqlite3_result_error_code
SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
  pCtx->isError = errCode ? errCode : -1;
#ifdef SQLITE_DEBUG
  if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
#endif
  if( pCtx->pOut->flags & MEM_Null ){
    sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1,
                         SQLITE_UTF8, SQLITE_STATIC);
  }
}

// Assembly:
xorl %eax, %eax
cmpl $0x1, %esi
sbbl %eax, %eax
orl %esi, %eax
movl %eax, 0x24(%rdi)
movq (%rdi), %rdi
testb $0x1, 0x8(%rdi)
jne 0x282406
retq
cmpl $0x204, %esi            # imm = 0x204
je 0x28242a
cmpl $0x65, %esi
je 0x282421
cmpl $0x64, %esi
jne 0x282433
leaq 0x161813(%rip), %rsi    # 0x3e3c32
jmp 0x28245b
leaq 0x161820(%rip), %rsi    # 0x3e3c48
jmp 0x28245b
leaq 0x1617eb(%rip), %rsi    # 0x3e3c1c
jmp 0x28245b
movzbl %sil, %eax
leaq 0x1617d0(%rip), %rsi    # 0x3e3c0e
cmpl $0x1c, %eax
ja 0x28245b
movl $0x1410004, %ecx        # imm = 0x1410004
btq %rax, %rcx
jb 0x28245b
movl %eax, %eax
leaq 0x240d99(%rip), %rcx    # 0x4c31f0
movq (%rcx,%rax,8), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
jmp 0x281f27
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_result_error_nomem
SQLITE_API void sqlite3_result_error_nomem(sqlite3_context *pCtx){
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  sqlite3VdbeMemSetNull(pCtx->pOut);
  pCtx->isError = SQLITE_NOMEM_BKPT;
  sqlite3OomFault(pCtx->pOut->db);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testb $0x24, 0x9(%rdi)
je 0x2824a4
callq 0x29b491
jmp 0x2824aa
movw $0x1, 0x8(%rdi)
movl $0x7, 0x24(%rbx)
movq (%rbx), %rax
movq 0x28(%rax), %rdi
popq %rbx
jmp 0x2824bb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3OomFault
SQLITE_PRIVATE void sqlite3OomFault(sqlite3 *db){
  if( db->mallocFailed==0 && db->bBenignMalloc==0 ){
    db->mallocFailed = 1;
    if( db->nVdbeExec>0 ){
      AtomicStore(&db->u1.isInterrupted, 1);
    }
    DisableLookaside;
    if( db->pParse ){
      db->pParse->rc = SQLITE_NOMEM_BKPT;
    }
  }
}

// Assembly:
cmpb $0x0, 0x61(%rdi)
je 0x2824c2
retq
cmpb $0x0, 0x62(%rdi)
jne 0x2824c1
movb $0x1, 0x61(%rdi)
cmpl $0x0, 0xcc(%rdi)
jle 0x2824df
movl $0x1, 0x168(%rdi)
incl 0x170(%rdi)
movw $0x0, 0x174(%rdi)
movq 0x130(%rdi), %rax
testq %rax, %rax
je 0x2824c1
movl $0x7, 0x18(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DbStrDup
SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3 *db, const char *z){
  char *zNew;
  size_t n;
  if( z==0 ){
    return 0;
  }
  n = strlen(z) + 1;
  zNew = sqlite3DbMallocRaw(db, n);
  if( zNew ){
    memcpy(zNew, z, n);
  }
  return zNew;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x283395
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x172f0
movq %rax, %r14
incq %r14
testq %r15, %r15
je 0x283399
movq %r15, %rdi
movq %r14, %rsi
callq 0x28c518
jmp 0x2833a1
xorl %eax, %eax
jmp 0x2833b9
movq %r14, %rdi
callq 0x27c381
testq %rax, %rax
je 0x2833b9
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x17660
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: createAggContext
static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){
  Mem *pMem = p->pMem;
  assert( (pMem->flags & MEM_Agg)==0 );
  if( nByte<=0 ){
    sqlite3VdbeMemSetNull(pMem);
    pMem->z = 0;
  }else{
    sqlite3VdbeMemClearAndResize(pMem, nByte);
    pMem->flags = MEM_Agg;
    pMem->u.pDef = p->pFunc;
    if( pMem->z ){
      memset(pMem->z, 0, nByte);
    }
  }
  return (void*)pMem->z;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rbx
testl %esi, %esi
jle 0x283417
movl %esi, %ebp
movq %rdi, %r14
cmpl %esi, 0x20(%rbx)
jge 0x283427
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x29b54f
jmp 0x283434
testb $0x24, 0x9(%rbx)
je 0x283455
movq %rbx, %rdi
callq 0x29b491
jmp 0x28345b
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
andw $0x2d, 0x8(%rbx)
movw $0x2000, 0x8(%rbx)      # imm = 0x2000
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x283463
movl %ebp, %edx
xorl %esi, %esi
callq 0x173a0
jmp 0x283463
movw $0x1, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq 0x10(%rbx), %rax
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: sqlite3_get_auxdata
SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
  AuxData *pAuxData;

  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
#if SQLITE_ENABLE_STAT4
  if( pCtx->pVdbe==0 ) return 0;
#else
  assert( pCtx->pVdbe!=0 );
#endif
  for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){
    if(  pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
      return pAuxData->pAux;
    }
  }
  return 0;
}

// Assembly:
movq 0x18(%rdi), %rax
movq 0x120(%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x283498
cmpl %esi, 0x4(%rcx)
jne 0x28348e
testl %esi, %esi
js 0x283494
movl 0x20(%rdi), %edx
cmpl %edx, (%rcx)
je 0x283494
movq 0x18(%rcx), %rcx
jmp 0x283479
movq 0x8(%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_set_auxdata
SQLITE_API void sqlite3_set_auxdata(
  sqlite3_context *pCtx,
  int iArg,
  void *pAux,
  void (*xDelete)(void*)
){
  AuxData *pAuxData;
  Vdbe *pVdbe = pCtx->pVdbe;

  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
#ifdef SQLITE_ENABLE_STAT4
  if( pVdbe==0 ) goto failed;
#else
  assert( pVdbe!=0 );
#endif

  for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){
    if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
      break;
    }
  }
  if( pAuxData==0 ){
    pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData));
    if( !pAuxData ) goto failed;
    pAuxData->iAuxOp = pCtx->iOp;
    pAuxData->iAuxArg = iArg;
    pAuxData->pNextAux = pVdbe->pAuxData;
    pVdbe->pAuxData = pAuxData;
    if( pCtx->isError==0 ) pCtx->isError = -1;
  }else if( pAuxData->xDeleteAux ){
    pAuxData->xDeleteAux(pAuxData->pAux);
  }

  pAuxData->pAux = pAux;
  pAuxData->xDeleteAux = xDelete;
  return;

failed:
  if( xDelete ){
    xDelete(pAux);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movq 0x18(%rdi), %r12
movq 0x120(%r12), %r14
testq %r14, %r14
je 0x2834d6
cmpl %ebp, 0x4(%r14)
jne 0x2834d0
testl %ebp, %ebp
js 0x28353d
movl 0x20(%r15), %eax
cmpl %eax, (%r14)
je 0x28353d
movq 0x18(%r14), %r14
jmp 0x2834b8
movq %rcx, %r13
movq (%r12), %rdi
movl $0x20, %esi
callq 0x283569
testq %rax, %rax
je 0x283522
movq %rax, %r14
movl 0x20(%r15), %eax
movl %eax, (%r14)
movl %ebp, 0x4(%r14)
movq 0x120(%r12), %rax
movq %rax, 0x18(%r14)
movq %r14, 0x120(%r12)
cmpl $0x0, 0x24(%r15)
movq %r13, %rcx
jne 0x283552
movl $0xffffffff, 0x24(%r15) # imm = 0xFFFFFFFF
jmp 0x283552
testq %r13, %r13
je 0x28355a
movq %r13, %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x283552
movq 0x8(%r14), %rdi
movq %rcx, %r15
callq *%rax
movq %r15, %rcx
movq %rbx, 0x8(%r14)
movq %rcx, 0x10(%r14)
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: sqlite3DbMallocZero
SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, u64 n){
  void *p;
  testcase( db==0 );
  p = sqlite3DbMallocRaw(db, n);
  if( p ) memset(p, 0, (size_t)n);
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x28357f
movq %rbx, %rsi
callq 0x28c518
jmp 0x283587
movq %rbx, %rdi
callq 0x27c381
movq %rax, %r14
testq %rax, %rax
je 0x28359c
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x173a0
movq %r14, %rax
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: columnMem
static Mem *columnMem(sqlite3_stmt *pStmt, int i){
  Vdbe *pVm;
  Mem *pOut;

  pVm = (Vdbe *)pStmt;
  if( pVm==0 ) return (Mem*)columnNullValue();
  assert( pVm->db );
  sqlite3_mutex_enter(pVm->db->mutex);
  if( pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
    pOut = &pVm->pResultSet[i];
  }else{
    sqlite3Error(pVm->db, SQLITE_RANGE);
    pOut = (Mem*)columnNullValue();
  }
  return pOut;
}

// Assembly:
pushq %rbx
leaq 0x158086(%rip), %rbx    # 0x3db690
testq %rdi, %rdi
je 0x283648
movq 0xa0(%rdi), %rax
testq %rax, %rax
je 0x283634
movzwl 0xc0(%rdi), %ecx
cmpl %esi, %ecx
jbe 0x283634
movl %esi, %ecx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, %rbx
jmp 0x283648
movq (%rdi), %rdi
movl $0x19, 0x50(%rdi)
movl $0x19, %esi
callq 0x28e696
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: columnMallocFailure
static void columnMallocFailure(sqlite3_stmt *pStmt)
{
  /* If malloc() failed during an encoding conversion within an
  ** sqlite3_column_XXX API, then set the return code of the statement to
  ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
  ** and _finalize() will return NOMEM.
  */
  Vdbe *p = (Vdbe *)pStmt;
  if( p ){
    assert( p->db!=0 );
    assert( sqlite3_mutex_held(p->db->mutex) );
    p->rc = sqlite3ApiExit(p->db, p->rc);
    sqlite3_mutex_leave(p->db->mutex);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x28367c
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x38(%rbx), %eax
cmpl $0xc0a, %eax            # imm = 0xC0A
je 0x28366e
cmpb $0x0, 0x61(%rdi)
jne 0x28366e
andl 0x54(%rdi), %eax
jmp 0x283678
callq 0x299b1a
movl $0x7, %eax
movl %eax, 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_bind_blob64
SQLITE_API int sqlite3_bind_blob64(
  sqlite3_stmt *pStmt,
  int i,
  const void *zData,
  sqlite3_uint64 nData,
  void (*xDel)(void*)
){
  assert( xDel!=SQLITE_DYNAMIC );
  if( nData>0x7fffffff ){
    return invokeValueDestructor(zData, xDel, 0);
  }else{
    return bindText(pStmt, i, zData, (int)nData, xDel, 0);
  }
}

// Assembly:
movq %rcx, %rax
shrq $0x1f, %rax
je 0x2839e9
leaq 0x1(%r8), %rax
cmpq $0x2, %rax
jb 0x2839e3
pushq %rax
movq %rdx, %rdi
callq *%r8
addq $0x8, %rsp
movl $0x12, %eax
retq
xorl %r9d, %r9d
jmp 0x2838bb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_bind_pointer
SQLITE_API int sqlite3_bind_pointer(
  sqlite3_stmt *pStmt,
  int i,
  void *pPtr,
  const char *zPTtype,
  void (*xDestructor)(void*)
){
  int rc;
  Vdbe *p = (Vdbe*)pStmt;
  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    sqlite3VdbeMemSetPointer(&p->aVar[i-1], pPtr, zPTtype, xDestructor);
    sqlite3_mutex_leave(p->db->mutex);
  }else if( xDestructor ){
    xDestructor(pPtr);
  }
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r13
callq 0x283a3b
movl %eax, %ebp
testl %eax, %eax
je 0x283c2c
testq %rbx, %rbx
je 0x283c71
movq %r14, %rdi
callq *%rbx
jmp 0x283c71
movq 0x80(%r13), %rax
movslq %r12d, %rcx
imulq $0x38, %rcx, %rcx
testq %r15, %r15
leaq 0x14fc4c(%rip), %rdx    # 0x3d3890
cmovneq %r15, %rdx
movq %rdx, -0x38(%rax,%rcx)
movq %r14, -0x28(%rax,%rcx)
movw $0x8601, -0x30(%rax,%rcx) # imm = 0x8601
movb $0x70, -0x2d(%rax,%rcx)
testq %rbx, %rbx
leaq 0x18acf(%rip), %rdx     # 0x29c737
cmovneq %rbx, %rdx
movq %rdx, -0x8(%rax,%rcx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_bind_text64
SQLITE_API int sqlite3_bind_text64(
  sqlite3_stmt *pStmt,
  int i,
  const char *zData,
  sqlite3_uint64 nData,
  void (*xDel)(void*),
  unsigned char enc
){
  assert( xDel!=SQLITE_DYNAMIC );
  if( nData>0x7fffffff ){
    return invokeValueDestructor(zData, xDel, 0);
  }else{
    if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
    return bindText(pStmt, i, zData, (int)nData, xDel, enc);
  }
}

// Assembly:
movq %rcx, %rax
shrq $0x1f, %rax
je 0x283cb1
leaq 0x1(%r8), %rax
cmpq $0x2, %rax
jb 0x283cab
pushq %rax
movq %rdx, %rdi
callq *%r8
addq $0x8, %rsp
movl $0x12, %eax
retq
cmpb $0x4, %r9b
movzbl %r9b, %eax
movl $0x2, %r9d
cmovnel %eax, %r9d
movzbl %r9b, %r9d
jmp 0x2838bb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_bind_value
SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
  int rc;
  switch( sqlite3_value_type((sqlite3_value*)pValue) ){
    case SQLITE_INTEGER: {
      rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
      break;
    }
    case SQLITE_FLOAT: {
      rc = sqlite3_bind_double(pStmt, i, pValue->u.r);
      break;
    }
    case SQLITE_BLOB: {
      if( pValue->flags & MEM_Zero ){
        rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
      }else{
        rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
      }
      break;
    }
    case SQLITE_TEXT: {
      rc = bindText(pStmt,i,  pValue->z, pValue->n, SQLITE_TRANSIENT,
                              pValue->enc);
      break;
    }
    default: {
      rc = sqlite3_bind_null(pStmt, i);
      break;
    }
  }
  return rc;
}

// Assembly:
movzwl 0x8(%rdx), %eax
movl %eax, %ecx
andl $0x3f, %ecx
leaq 0x156e79(%rip), %r8     # 0x3dab60
movzbl (%rcx,%r8), %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0x283a3b
leaq 0x155b62(%rip), %r8     # 0x3d9860
movslq (%r8,%rcx,4), %rcx
addq %r8, %rcx
jmpq *%rcx
movq (%rdx), %rdx
jmp 0x283b9a
movq 0x10(%rdx), %rax
movl 0xc(%rdx), %ecx
movzbl 0xa(%rdx), %r9d
movq %rax, %rdx
movq $-0x1, %r8
jmp 0x2838bb
btl $0xe, %eax
jb 0x283d52
movq 0x10(%rdx), %rax
movl 0xc(%rdx), %ecx
movq %rax, %rdx
movq $-0x1, %r8
xorl %r9d, %r9d
jmp 0x2838bb
movsd (%rdx), %xmm0
jmp 0x2839f1
movl (%rdx), %edx
jmp 0x283d59
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_bind_zeroblob64
SQLITE_API int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  sqlite3_mutex_enter(p->db->mutex);
  if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){
    rc = SQLITE_TOOBIG;
  }else{
    assert( (n & 0x7FFFFFFF)==n );
    rc = sqlite3_bind_zeroblob(pStmt, i, n);
  }
  rc = sqlite3ApiExit(p->db, rc);
  sqlite3_mutex_leave(p->db->mutex);
  return rc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0x7c(%rax), %rcx
movl $0x12, %eax
cmpq %rdx, %rcx
jb 0x283dba
movq %rbx, %rdi
callq 0x283d59
movq (%rbx), %rdi
cmpb $0x0, 0x61(%rdi)
je 0x283dcf
callq 0x299b1a
movl $0x7, %eax
jmp 0x283dd2
andl 0x54(%rdi), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_transfer_bindings
SQLITE_API int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
  Vdbe *pFrom = (Vdbe*)pFromStmt;
  Vdbe *pTo = (Vdbe*)pToStmt;
  if( pFrom->nVar!=pTo->nVar ){
    return SQLITE_ERROR;
  }
  assert( (pTo->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pTo->expmask==0 );
  if( pTo->expmask ){
    pTo->expired = 1;
  }
  assert( (pFrom->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pFrom->expmask==0 );
  if( pFrom->expmask ){
    pFrom->expired = 1;
  }
  return sqlite3TransferBindings(pFromStmt, pToStmt);
}

// Assembly:
movzwl 0x20(%rdi), %ecx
movl $0x1, %eax
cmpw 0x20(%rsi), %cx
jne 0x283eb9
cmpl $0x0, 0x114(%rsi)
je 0x283e91
movzwl 0xc6(%rsi), %eax
andl $-0x4, %eax
incl %eax
movw %ax, 0xc6(%rsi)
cmpl $0x0, 0x114(%rdi)
je 0x283ead
movzwl 0xc6(%rdi), %eax
andl $-0x4, %eax
incl %eax
movw %ax, 0xc6(%rdi)
pushq %rax
callq 0x283eba
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_stmt_status
SQLITE_API int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
  Vdbe *pVdbe = (Vdbe*)pStmt;
  u32 v;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !pStmt
   || (op!=SQLITE_STMTSTATUS_MEMUSED && (op<0||op>=ArraySize(pVdbe->aCounter)))
  ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  if( op==SQLITE_STMTSTATUS_MEMUSED ){
    sqlite3 *db = pVdbe->db;
    sqlite3_mutex_enter(db->mutex);
    v = 0;
    db->pnBytesFreed = (int*)&v;
    sqlite3VdbeClearObject(db, pVdbe);
    sqlite3DbFree(db, pVdbe);
    db->pnBytesFreed = 0;
    sqlite3_mutex_leave(db->mutex);
  }else{
    v = pVdbe->aCounter[op];
    if( resetFlag ) pVdbe->aCounter[op] = 0;
  }
  return (int)v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x63, %esi
jne 0x284007
movq (%rbx), %r14
leaq 0x4(%rsp), %rax
movl $0x0, (%rax)
movq %rax, 0x2d0(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27bd96
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28c3e7
movq $0x0, 0x2d0(%r14)
jmp 0x284024
movslq %esi, %rax
movl 0xd0(%rbx,%rax,4), %ecx
movl %ecx, 0x4(%rsp)
testl %edx, %edx
je 0x284024
movl $0x0, 0xd0(%rbx,%rax,4)
movl 0x4(%rsp), %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: sqlite3_value_numeric_type
SQLITE_API int sqlite3_value_numeric_type(sqlite3_value *pVal){
  int eType = sqlite3_value_type(pVal);
  if( eType==SQLITE_TEXT ){
    Mem *pMem = (Mem*)pVal;
    applyNumericAffinity(pMem, 0);
    eType = sqlite3_value_type(pVal);
  }
  return eType;
}

// Assembly:
movzwl 0x8(%rdi), %eax
andl $0x3f, %eax
movabsq $0x4000400040004, %rcx  # imm = 0x4000400040004
btq %rax, %rcx
jae 0x2844ff
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x28450b
movzwl 0x8(%rbx), %eax
andl $0x3f, %eax
popq %rbx
leaq 0x15665a(%rip), %rcx    # 0x3dab60
movzbl (%rax,%rcx), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: applyNumericAffinity
static void applyNumericAffinity(Mem *pRec, int bTryForInt){
  double rValue;
  u8 enc = pRec->enc;
  int rc;
  assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str );
  rc = sqlite3AtoF(pRec->z, &rValue, pRec->n, enc);
  if( rc<=0 ) return;
  if( rc==1 && alsoAnInt(pRec, rValue, &pRec->u.i) ){
    pRec->flags |= MEM_Int;
  }else{
    pRec->u.r = rValue;
    pRec->flags |= MEM_Real;
    if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec);
  }
  /* TEXT->NUMERIC is many->one.  Hence, it is important to invalidate the
  ** string representation after computing a numeric equivalent, because the
  ** string representation might not be the canonical representation for the
  ** numeric value.  Ticket [343634942dd54ab57b7024] 2018-01-31. */
  pRec->flags &= ~MEM_Str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movl 0xc(%rdi), %r14d
movzbl 0xa(%rdi), %r12d
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x29bf75
testl %eax, %eax
jle 0x2845cc
cmpl $0x1, %eax
jne 0x2845ae
movsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %rax
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x284560
jnp 0x284590
movabsq $-0x8000000000000, %rcx # imm = 0xFFF8000000000000
addq %rax, %rcx
shrq $0x34, %rcx
cmpl $0xfff, %ecx            # imm = 0xFFF
jb 0x284599
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movq %xmm0, %rcx
movq %xmm1, %rdx
cmpq %rdx, %rcx
jne 0x284599
movq %rax, (%rbx)
orb $0x4, 0x8(%rbx)
jmp 0x2845c8
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x29c4f4
testl %eax, %eax
je 0x284593
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
orb $0x8, 0x8(%rbx)
testl %ebp, %ebp
je 0x2845c8
movq %rbx, %rdi
callq 0x2a849e
andb $-0x3, 0x8(%rbx)
addq $0x10, %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: sqlite3VdbeCreate
SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse *pParse){
  sqlite3 *db = pParse->db;
  Vdbe *p;
  p = sqlite3DbMallocRawNN(db, sizeof(Vdbe) );
  if( p==0 ) return 0;
  memset(&p->aOp, 0, sizeof(Vdbe)-offsetof(Vdbe,aOp));
  p->db = db;
  if( db->pVdbe ){
    db->pVdbe->pPrev = p;
  }
  p->pNext = db->pVdbe;
  p->pPrev = 0;
  db->pVdbe = p;
  p->magic = VDBE_MAGIC_INIT;
  p->pParse = pParse;
  pParse->pVdbe = p;
  assert( pParse->aLabel==0 );
  assert( pParse->nLabel==0 );
  assert( p->nOpAlloc==0 );
  assert( pParse->szOpAlloc==0 );
  sqlite3VdbeAddOp2(p, OP_Init, 0, 1);
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %r15
movl $0x128, %esi            # imm = 0x128
movq %r15, %rdi
callq 0x28c518
testq %rax, %rax
je 0x285097
movq %rax, %rbx
movq %rax, %rdi
addq $0x88, %rdi
movl $0xa0, %edx
xorl %esi, %esi
callq 0x173a0
movq %r15, (%rbx)
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x28505f
movq %rbx, 0x8(%rax)
movq %rax, 0x10(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, 0x8(%r15)
movl $0x16bceaa5, 0x24(%rbx) # imm = 0x16BCEAA5
movq %r14, 0x18(%rbx)
movq %rbx, 0x10(%r14)
movq %rbx, %rdi
movl $0x3e, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x2b200c
jmp 0x285099
xorl %ebx, %ebx
movq %rbx, %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: sqlite3VdbeAddOpList
SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList(
  Vdbe *p,                     /* Add opcodes to the prepared statement */
  int nOp,                     /* Number of opcodes to add */
  VdbeOpList const *aOp,       /* The opcodes to be added */
  int iLineno                  /* Source-file line number of first opcode */
){
  int i;
  VdbeOp *pOut, *pFirst;
  assert( nOp>0 );
  assert( p->magic==VDBE_MAGIC_INIT );
  if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){
    return 0;
  }
  pFirst = pOut = &p->aOp[p->nOp];
  for(i=0; i<nOp; i++, aOp++, pOut++){
    pOut->opcode = aOp->opcode;
    pOut->p1 = aOp->p1;
    pOut->p2 = aOp->p2;
    assert( aOp->p2>=0 );
    if( (sqlite3OpcodeProperty[aOp->opcode] & OPFLG_JUMP)!=0 && aOp->p2>0 ){
      pOut->p2 += p->nOp;
    }
    pOut->p3 = aOp->p3;
    pOut->p4type = P4_NOTUSED;
    pOut->p4.p = 0;
    pOut->p5 = 0;
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
    pOut->zComment = 0;
#endif
#ifdef SQLITE_VDBE_COVERAGE
    pOut->iSrcLine = iLineno+i;
#else
    (void)iLineno;
#endif
#ifdef SQLITE_DEBUG
    if( p->db->flags & SQLITE_VdbeAddopTrace ){
      sqlite3VdbePrintOp(0, i+p->nOp, &p->aOp[i+p->nOp]);
    }
#endif
  }
  p->nOp += nOp;
  return pFirst;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
movl 0x90(%rdi), %eax
addl %esi, %eax
cmpl 0x94(%rdi), %eax
jle 0x2850d2
movq %r15, %rdi
callq 0x2b20a4
testl %eax, %eax
je 0x2850d2
xorl %eax, %eax
jmp 0x28515e
movslq 0x90(%r15), %rax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x88(%r15), %rax
testl %ebx, %ebx
jle 0x285157
movl %ebx, %ecx
xorl %edx, %edx
leaq 0x156899(%rip), %rsi    # 0x3db990
movq %rax, %rdi
movzbl (%r14,%rdx,4), %r10d
movb %r10b, (%rdi)
movsbl 0x1(%r14,%rdx,4), %r8d
movl %r8d, 0x4(%rdi)
movb 0x2(%r14,%rdx,4), %r9b
movsbl %r9b, %r8d
movl %r8d, 0x8(%rdi)
testb $0x1, (%r10,%rsi)
je 0x285130
testb %r9b, %r9b
jle 0x285130
addl 0x90(%r15), %r8d
movl %r8d, 0x8(%rdi)
movsbl 0x3(%r14,%rdx,4), %r8d
movl %r8d, 0xc(%rdi)
movb $0x0, 0x1(%rdi)
movq $0x0, 0x10(%rdi)
movw $0x0, 0x2(%rdi)
addq $0x18, %rdi
incq %rdx
cmpl %edx, %ecx
jne 0x2850fa
addl %ebx, 0x90(%r15)
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: sqlite3VdbeUsesBtree
SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe *p, int i){
  assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
  assert( i<(int)sizeof(p->btreeMask)*8 );
  DbMaskSet(p->btreeMask, i);
  if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
    DbMaskSet(p->lockMask, i);
  }
}

// Assembly:
movl %esi, %ecx
movl $0x1, %eax
shll %cl, %eax
orl %eax, 0xc8(%rdi)
cmpl $0x1, %esi
je 0x285197
movq (%rdi), %rdx
movq 0x20(%rdx), %rdx
movslq %ecx, %rcx
shlq $0x5, %rcx
movq 0x8(%rdx,%rcx), %rcx
cmpb $0x0, 0x11(%rcx)
je 0x285197
orl %eax, 0xcc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeChangeP4
SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
  Op *pOp;
  sqlite3 *db;
  assert( p!=0 );
  db = p->db;
  assert( p->magic==VDBE_MAGIC_INIT );
  assert( p->aOp!=0 || db->mallocFailed );
  if( db->mallocFailed ){
    if( n!=P4_VTAB ) freeP4(db, n, (void*)*(char**)&zP4);
    return;
  }
  assert( p->nOp>0 );
  assert( addr<p->nOp );
  if( addr<0 ){
    addr = p->nOp - 1;
  }
  pOp = &p->aOp[addr];
  if( n>=0 || pOp->p4type ){
    vdbeChangeP4Full(p, pOp, zP4, n);
    return;
  }
  if( n==P4_INT32 ){
    /* Note: this cast is safe, because the origin data point was an int
    ** that was cast to a (const char *). */
    pOp->p4.i = SQLITE_PTR_TO_INT(zP4);
    pOp->p4type = P4_INT32;
  }else if( zP4!=0 ){
    assert( n<0 );
    pOp->p4.p = (void*)zP4;
    pOp->p4type = (signed char)n;
    if( n==P4_VTAB ) sqlite3VtabLock((VTable*)zP4);
  }
}

// Assembly:
movq (%rdi), %rax
cmpb $0x0, 0x61(%rax)
je 0x2851a7
cmpl $-0xc, %ecx
jne 0x2851e4
retq
testl %esi, %esi
jns 0x2851b3
movl 0x90(%rdi), %esi
decl %esi
movslq %esi, %rax
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0x88(%rdi), %rsi
testl %ecx, %ecx
jns 0x2b2166
cmpb $0x0, 0x1(%rsi)
jne 0x2b2166
cmpl $-0x3, %ecx
jne 0x2851ee
movl %edx, 0x10(%rsi)
movb $-0x3, 0x1(%rsi)
retq
movq %rax, %rdi
movl %ecx, %esi
jmp 0x29991d
testq %rdx, %rdx
je 0x2851a6
movq %rdx, 0x10(%rsi)
movb %cl, 0x1(%rsi)
cmpl $-0xc, %ecx
jne 0x2851a6
incl 0x18(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ParserReset
SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){
  sqlite3 *db = pParse->db;
  AggInfo *pThis = pParse->pAggList;
  while( pThis ){
    AggInfo *pNext = pThis->pNext;
    agginfoFree(db, pThis);
    pThis = pNext;
  }
  sqlite3DbFree(db, pParse->aLabel);
  sqlite3ExprListDelete(db, pParse->pConstExpr);
  if( db ){
    assert( db->lookaside.bDisable >= pParse->disableLookaside );
    db->lookaside.bDisable -= pParse->disableLookaside;
    db->lookaside.sz = db->lookaside.bDisable ? 0 : db->lookaside.szTrue;
  }
  pParse->disableLookaside = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0xb8(%rdi), %r15
testq %r15, %r15
je 0x2857c8
movq 0x20(%r15), %rsi
movq 0x40(%r15), %r12
testq %rsi, %rsi
je 0x2857a4
movq %r14, %rdi
callq 0x28c3e7
movq 0x30(%r15), %rsi
testq %rsi, %rsi
je 0x2857b5
movq %r14, %rdi
callq 0x28c3e7
movq %r14, %rdi
movq %r15, %rsi
callq 0x28c3e7
movq %r12, %r15
testq %r12, %r12
jne 0x28578f
movq 0x50(%rbx), %rsi
testq %rsi, %rsi
je 0x2857d9
movq %r14, %rdi
callq 0x28c3e7
movq 0x58(%rbx), %rsi
testq %rsi, %rsi
je 0x2857ea
movq %r14, %rdi
callq 0x2b0183
testq %r14, %r14
je 0x285810
movzbl 0x24(%rbx), %eax
subl %eax, 0x170(%r14)
jne 0x285806
movzwl 0x176(%r14), %eax
jmp 0x285808
xorl %eax, %eax
movw %ax, 0x174(%r14)
movb $0x0, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BtreePutData
SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
  int rc;
  assert( cursorOwnsBtShared(pCsr) );
  assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
  assert( pCsr->curFlags & BTCF_Incrblob );

  rc = restoreCursorPosition(pCsr);
  if( rc!=SQLITE_OK ){
    return rc;
  }
  assert( pCsr->eState!=CURSOR_REQUIRESEEK );
  if( pCsr->eState!=CURSOR_VALID ){
    return SQLITE_ABORT;
  }

  /* Save the positions of all other cursors open on this table. This is
  ** required in case any of them are holding references to an xFetch
  ** version of the b-tree page modified by the accessPayload call below.
  **
  ** Note that pCsr must be open on a INTKEY table and saveCursorPosition()
  ** and hence saveAllCursors() cannot fail on a BTREE_INTKEY table, hence
  ** saveAllCursors can only return SQLITE_OK.
  */
  VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr);
  assert( rc==SQLITE_OK );

  /* Check some assumptions:
  **   (a) the cursor is open for writing,
  **   (b) there is a read/write transaction open,
  **   (c) the connection holds a write-lock on the table (if required),
  **   (d) there are no conflicting read-locks, and
  **   (e) the cursor points at a valid row of an intKey table.
  */
  if( (pCsr->curFlags & BTCF_WriteFlag)==0 ){
    return SQLITE_READONLY;
  }
  assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
              && pCsr->pBt->inTransaction==TRANS_WRITE );
  assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
  assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
  assert( pCsr->pPage->intKey );

  return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
xorl %eax, %eax
cmpb $0x3, (%rdi)
jb 0x285982
movq %r15, %rdi
callq 0x2a87bf
testl %eax, %eax
jne 0x2859ad
movl $0x4, %eax
cmpb $0x0, (%r15)
jne 0x2859ad
movq 0x20(%r15), %rdi
movl 0x50(%r15), %esi
movq %r15, %rdx
callq 0x2979a1
movl $0x8, %eax
testb $0x1, 0x1(%r15)
jne 0x2859b8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
movl $0x1, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x297e3f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_set_authorizer
SQLITE_API int sqlite3_set_authorizer(
  sqlite3 *db,
  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
  void *pArg
){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  db->xAuth = (sqlite3_xauth)xAuth;
  db->pAuthArg = pArg;
  if( db->xAuth ) sqlite3ExpirePreparedStatements(db, 1);
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
movq %rsi, 0x1c8(%rdi)
movq %rdx, 0x1d0(%rdi)
testq %rsi, %rsi
je 0x285adc
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x285adc
movzwl 0xc6(%rax), %ecx
andl $-0x4, %ecx
orl $0x2, %ecx
movw %cx, 0xc6(%rax)
movq 0x10(%rax), %rax
jmp 0x285abd
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_errmsg
SQLITE_API const char *sqlite3_errmsg(sqlite3 *db){
  const char *z;
  if( !db ){
    return sqlite3ErrStr(SQLITE_NOMEM_BKPT);
  }
  if( !sqlite3SafetyCheckSickOrOk(db) ){
    return sqlite3ErrStr(SQLITE_MISUSE_BKPT);
  }
  sqlite3_mutex_enter(db->mutex);
  if( db->mallocFailed ){
    z = sqlite3ErrStr(SQLITE_NOMEM_BKPT);
  }else{
    testcase( db->pErr==0 );
    z = db->errCode ? (char*)sqlite3_value_text(db->pErr) : 0;
    assert( !db->mallocFailed );
    if( z==0 ){
      z = sqlite3ErrStr(db->errCode);
    }
  }
  sqlite3_mutex_leave(db->mutex);
  return z;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xf7145(%rip), %rbx     # 0x37d5a1
testq %rdi, %rdi
je 0x2864c7
movq %rdi, %r14
callq 0x289ec4
testl %eax, %eax
je 0x286491
cmpb $0x0, 0x61(%r14)
jne 0x2864c7
cmpl $0x0, 0x50(%r14)
je 0x2864c0
movq 0x160(%r14), %rdi
movl $0x1, %esi
callq 0x281c96
movq %rax, %rbx
jmp 0x2864c2
leaq 0x158e87(%rip), %rsi    # 0x3df31f
leaq 0x15d6fd(%rip), %rdx    # 0x3e3b9c
leaq 0x158cdf(%rip), %r8     # 0x3df185
movl $0x15, %edi
movl $0x27ea7, %ecx          # imm = 0x27EA7
xorl %eax, %eax
callq 0x27e637
leaq 0x15d6c3(%rip), %rbx    # 0x3e3b81
jmp 0x2864c7
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x2864d2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x50(%r14), %eax
cmpq $0x204, %rax            # imm = 0x204
je 0x2864fa
cmpl $0x65, %eax
je 0x2864f1
cmpl $0x64, %eax
jne 0x286503
leaq 0x15d743(%rip), %rbx    # 0x3e3c32
jmp 0x2864c7
leaq 0x15d750(%rip), %rbx    # 0x3e3c48
jmp 0x2864c7
leaq 0x15d71b(%rip), %rbx    # 0x3e3c1c
jmp 0x2864c7
movzbl %al, %eax
leaq 0x15d701(%rip), %rbx    # 0x3e3c0e
cmpl $0x1c, %eax
ja 0x2864c7
movl $0x1410004, %ecx        # imm = 0x1410004
btq %rax, %rcx
jb 0x2864c7
leaq 0x23cccc(%rip), %rcx    # 0x4c31f0
movq (%rcx,%rax,8), %rbx
jmp 0x2864c7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_auto_extension
SQLITE_API int sqlite3_auto_extension(
  void (*xInit)(void)
){
  int rc = SQLITE_OK;
#ifndef SQLITE_OMIT_AUTOINIT
  rc = sqlite3_initialize();
  if( rc ){
    return rc;
  }else
#endif
  {
    u32 i;
#if SQLITE_THREADSAFE
    sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
    wsdAutoextInit;
    sqlite3_mutex_enter(mutex);
    for(i=0; i<wsdAutoext.nExt; i++){
      if( wsdAutoext.aExt[i]==xInit ) break;
    }
    if( i==wsdAutoext.nExt ){
      u64 nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
      void (**aNew)(void);
      aNew = sqlite3_realloc64(wsdAutoext.aExt, nByte);
      if( aNew==0 ){
        rc = SQLITE_NOMEM_BKPT;
      }else{
        wsdAutoext.aExt = aNew;
        wsdAutoext.aExt[wsdAutoext.nExt] = xInit;
        wsdAutoext.nExt++;
      }
    }
    sqlite3_mutex_leave(mutex);
    assert( (rc&0xff)==rc );
    return rc;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x27bed9
testl %eax, %eax
jne 0x286a74
movl 0x2432cd(%rip), %r14d   # 0x4c9cc8
xorl %eax, %eax
movl $0x0, %ecx
testq %r14, %r14
je 0x286a21
movq 0x2432c2(%rip), %rdx    # 0x4c9cd0
xorl %ecx, %ecx
cmpq %rbx, (%rdx,%rcx,8)
je 0x286a21
incq %rcx
cmpl %ecx, %r14d
jne 0x286a10
movl %r14d, %ecx
cmpl %r14d, %ecx
jne 0x286a74
movq 0x2432a3(%rip), %r15    # 0x4c9cd0
callq 0x27bed9
testl %eax, %eax
je 0x286a3a
xorl %eax, %eax
jmp 0x286a4c
incl %r14d
shlq $0x3, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x27c4f3
testq %rax, %rax
je 0x286a6f
movq %rax, 0x243278(%rip)    # 0x4c9cd0
movl 0x24326a(%rip), %ecx    # 0x4c9cc8
movq %rbx, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x24325d(%rip)    # 0x4c9cc8
xorl %eax, %eax
jmp 0x286a74
movl $0x7, %eax
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: sqlite3_free_table
SQLITE_API void sqlite3_free_table(
  char **azResult            /* Result returned from sqlite3_get_table() */
){
  if( azResult ){
    int i, n;
    azResult--;
    assert( azResult!=0 );
    n = SQLITE_PTR_TO_INT(azResult[0]);
    for(i=1; i<n; i++){ if( azResult[i] ) sqlite3_free(azResult[i]); }
    sqlite3_free(azResult);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x28719f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x8(%rdi), %r14
movq -0x8(%rdi), %r15
cmpl $0x2, %r15d
jl 0x28718c
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
decq %r15
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
testq %rdi, %rdi
je 0x287184
callq 0x27c490
incq %r12
cmpq %r12, %r15
jne 0x287176
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x27c490
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: createModule
static int createModule(
  sqlite3 *db,                    /* Database in which module is registered */
  const char *zName,              /* Name assigned to this module */
  const sqlite3_module *pModule,  /* The definition of the module */
  void *pAux,                     /* Context pointer for xCreate/xConnect */
  void (*xDestroy)(void *)        /* Module destructor function */
){
  int rc = SQLITE_OK;

  sqlite3_mutex_enter(db->mutex);
  (void)sqlite3VtabCreateModule(db, zName, pModule, pAux, xDestroy);
  rc = sqlite3ApiExit(db, rc);
  if( rc!=SQLITE_OK && xDestroy ) xDestroy(pAux);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
callq 0x2b2587
movb 0x61(%r15), %r12b
testb %r12b, %r12b
je 0x2871d3
movq %r15, %rdi
callq 0x299b1a
movl $0x7, %ebp
jmp 0x2871d5
xorl %ebp, %ebp
testb %r12b, %r12b
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x2871ea
movq %r14, %rdi
callq *%rbx
movl %ebp, %eax
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: sqlite3_drop_modules
SQLITE_API int sqlite3_drop_modules(sqlite3 *db, const char** azNames){
  HashElem *pThis, *pNext;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  for(pThis=sqliteHashFirst(&db->aModule); pThis; pThis=pNext){
    Module *pMod = (Module*)sqliteHashData(pThis);
    pNext = sqliteHashNext(pThis);
    if( azNames ){
      int ii;
      for(ii=0; azNames[ii]!=0 && strcmp(azNames[ii],pMod->zName)!=0; ii++){}
      if( azNames[ii]!=0 ) continue;
    }
    createModule(db, pMod->zName, 0, 0, 0);
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x1f8(%rdi), %r12
testq %r12, %r12
je 0x28728c
movq %rsi, %rbx
leaq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%r12), %rbp
movq (%r12), %r12
testq %rbx, %rbx
je 0x287272
movq (%rbx), %rdi
testq %rdi, %rdi
sete %r13b
je 0x287272
movq 0x8(%rbp), %r15
movq %r15, %rsi
callq 0x17a40
testl %eax, %eax
je 0x28726d
movq 0x8(%rsp), %r14
movq (%r14), %rdi
testq %rdi, %rdi
sete %r13b
je 0x287272
movq %r15, %rsi
callq 0x17a40
addq $0x8, %r14
testl %eax, %eax
jne 0x287251
testb %r13b, %r13b
je 0x287287
movq 0x8(%rbp), %rsi
movq 0x10(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2871a5
testq %r12, %r12
jne 0x287222
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq