LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ResetAllSchemasOfConnection
SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
  int i;
  sqlite3BtreeEnterAll(db);
  for(i=0; i<db->nDb; i++){
    Db *pDb = &db->aDb[i];
    if( pDb->pSchema ){
      if( db->nSchemaLock==0 ){
        sqlite3SchemaClear(pDb->pSchema);
      }else{
        DbSetProperty(db, i, DB_ResetWanted);
      }
    }
  }
  db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
  sqlite3VtabUnlockList(db);
  sqlite3BtreeLeaveAll(db);
  if( db->nSchemaLock==0 ){
    sqlite3CollapseDatabaseArray(db);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x28(%rdi), %rax
testq %rax, %rax
jle 0x2773ea
movq 0x20(%rbx), %rcx
movq %rax, %rdx
shlq $0x5, %rdx
xorl %esi, %esi
movq 0x8(%rcx,%rsi), %rdi
testq %rdi, %rdi
je 0x2773a4
movq (%rdi), %r8
movq 0x8(%rdi), %rdi
movq %r8, 0x8(%rdi)
addq $0x20, %rsi
cmpq %rsi, %rdx
jne 0x27738f
testl %eax, %eax
jle 0x2773ea
movl $0x18, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rcx
movq (%rcx,%r14), %rdi
testq %rdi, %rdi
je 0x2773db
cmpl $0x0, 0x48(%rbx)
je 0x2773d3
orb $0x8, 0x72(%rdi)
jmp 0x2773db
callq 0x29d6d4
movl 0x28(%rbx), %eax
incq %r15
movslq %eax, %rcx
addq $0x20, %r14
cmpq %rcx, %r15
jl 0x2773ba
andb $-0x12, 0x2c(%rbx)
movq %rbx, %rdi
callq 0x2a5baa
cmpl $0x0, 0x48(%rbx)
je 0x277402
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2a90a7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3PagerWrite
SQLITE_PRIVATE int sqlite3PagerWrite(PgHdr *pPg){
  Pager *pPager = pPg->pPager;
  assert( (pPg->flags & PGHDR_MMAP)==0 );
  assert( pPager->eState>=PAGER_WRITER_LOCKED );
  assert( assert_pager_state(pPager) );
  if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
    if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
    return SQLITE_OK;
  }else if( pPager->errCode ){
    return pPager->errCode;
  }else if( pPager->sectorSize > (u32)pPager->pageSize ){
    assert( pPager->tempFile==0 );
    return pagerWriteLargeSector(pPg);
  }else{
    return pager_write(pPg);
  }
}

// Assembly:
movq 0x28(%rdi), %rcx
testb $0x4, 0x34(%rdi)
je 0x2774b3
movl 0x1c(%rcx), %eax
cmpl 0x30(%rdi), %eax
jae 0x2774d2
movl 0x2c(%rcx), %eax
testl %eax, %eax
je 0x2774bb
retq
movl 0xb8(%rcx), %eax
cmpl 0xbc(%rcx), %eax
ja 0x28d4c1
jmp 0x28d655
cmpl $0x0, 0x80(%rcx)
jne 0x285e77
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3PagerSync
SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zSuper){
  int rc = SQLITE_OK;
  void *pArg = (void*)zSuper;
  rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
  if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
  if( rc==SQLITE_OK && !pPager->noSync ){
    assert( !MEMDB );
    rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
  }
  return rc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x2776d1
movq %rsi, %rdx
movl $0x15, %esi
callq *0x50(%rax)
cmpl $0xc, %eax
je 0x2776d1
testl %eax, %eax
jne 0x2776d9
xorl %eax, %eax
cmpb $0x0, 0xb(%rbx)
je 0x2776db
popq %rbx
retq
movzbl 0xe(%rbx), %esi
testl %esi, %esi
je 0x2776d9
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BtreeRollback
SQLITE_PRIVATE int sqlite3BtreeRollback(Btree *p, int tripCode, int writeOnly){
  int rc;
  BtShared *pBt = p->pBt;
  MemPage *pPage1;

  assert( writeOnly==1 || writeOnly==0 );
  assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK );
  sqlite3BtreeEnter(p);
  if( tripCode==SQLITE_OK ){
    rc = tripCode = saveAllCursors(pBt, 0, 0);
    if( rc ) writeOnly = 0;
  }else{
    rc = SQLITE_OK;
  }
  if( tripCode ){
    int rc2 = sqlite3BtreeTripAllCursors(p, tripCode, writeOnly);
    assert( rc==SQLITE_OK || (writeOnly==0 && rc2==SQLITE_OK) );
    if( rc2!=SQLITE_OK ) rc = rc2;
  }
  btreeIntegrity(p);

  if( p->inTrans==TRANS_WRITE ){
    int rc2;

    assert( TRANS_WRITE==pBt->inTransaction );
    rc2 = sqlite3PagerRollback(pBt->pPager);
    if( rc2!=SQLITE_OK ){
      rc = rc2;
    }

    /* The rollback may have destroyed the pPage1->aData value.  So
    ** call btreeGetPage() on page 1 again to make
    ** sure pPage1->aData is set correctly. */
    if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
      btreeSetNPage(pBt, pPage1);
      releasePageOne(pPage1);
    }
    assert( countValidCursors(pBt, 1)==0 );
    pBt->inTransaction = TRANS_READ;
    btreeClearHasContent(pBt);
  }

  btreeEndTransaction(p);
  sqlite3BtreeLeave(p);
  return rc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq (%rdi), %rax
movq %rax, 0x8(%r14)
testl %esi, %esi
je 0x277b78
movq %rbx, %rdi
movl %r15d, %edx
callq 0x28f9af
cmpb $0x2, 0x10(%rbx)
jne 0x277b67
movq (%r14), %rdi
callq 0x28942f
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x28ced9
testl %eax, %eax
jne 0x277b51
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rcx
movl 0x1c(%rcx), %ecx
bswapl %ecx
testl %ecx, %ecx
jne 0x277b44
movq (%r14), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, 0x40(%r14)
movq 0x70(%rax), %rdi
callq 0x28cfb5
movb $0x1, 0x24(%r14)
movq 0x60(%r14), %rdi
callq 0x28a41d
movq $0x0, 0x60(%r14)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x28db58
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x277b06
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
callq 0x28e021
movl %eax, %esi
testl %eax, %eax
jne 0x277afb
jmp 0x277b06
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: invokeProfileCallback
static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){
  sqlite3_int64 iNow;
  sqlite3_int64 iElapse;
  assert( p->startTime>0 );
  assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 );
  assert( db->init.busy==0 );
  assert( p->zSql!=0 );
  sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
  iElapse = (iNow - p->startTime)*1000000;
#ifndef SQLITE_OMIT_DEPRECATED
  if( db->xProfile ){
    db->xProfile(db->pProfileArg, p->zSql, iElapse);
  }
#endif
  if( db->mTrace & SQLITE_TRACE_PROFILE ){
    db->trace.xV2(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse);
  }
  p->startTime = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x28fcb4
movq (%r15), %rax
subq 0xb8(%rbx), %rax
imulq $0xf4240, %rax, %rdx    # imm = 0xF4240
movq %rdx, (%rsp)
movq 0xf0(%r14), %rax
testq %rax, %rax
je 0x277f40
movq 0xf8(%r14), %rdi
movq 0xf0(%rbx), %rsi
callq *%rax
testb $0x2, 0x68(%r14)
je 0x277f60
movq 0xe8(%r14), %rsi
movq %rsp, %rcx
movl $0x2, %edi
movq %rbx, %rdx
callq *0xe0(%r14)
movq $0x0, 0xb8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_reset
SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt){
  int rc;
  if( pStmt==0 ){
    rc = SQLITE_OK;
  }else{
    Vdbe *v = (Vdbe*)pStmt;
    sqlite3 *db = v->db;
    sqlite3_mutex_enter(db->mutex);
    checkProfileCallback(db, v);
    rc = sqlite3VdbeReset(v);
    sqlite3VdbeRewind(v);
    assert( (rc & (db->errMask))==rc );
    rc = sqlite3ApiExit(db, rc);
    sqlite3_mutex_leave(db->mutex);
  }
  return rc;
}

// Assembly:
testq %rdi, %rdi
je 0x278019
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
cmpq $0x0, 0xb8(%rdi)
jle 0x277fcd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x277ef0
movq %r14, %rdi
callq 0x278031
movl $0x2df20da3, 0x24(%r14) # imm = 0x2DF20DA3
movl $0x0, 0x38(%r14)
movw $0xff02, 0xc2(%r14)     # imm = 0xFF02
xorl %ecx, %ecx
movq %rcx, 0x3c(%r14)
movabsq $-0xffffffff, %rdx      # imm = 0xFFFFFFFF00000001
movq %rdx, 0x30(%r14)
movq %rcx, 0x50(%r14)
cmpl $0xc0a, %eax            # imm = 0xC0A
je 0x27801c
cmpb $0x0, 0x61(%rbx)
jne 0x27801c
andl 0x54(%rbx), %eax
jmp 0x278029
xorl %eax, %eax
retq
movq %rbx, %rdi
callq 0x28fd56
movl $0x7, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_clear_bindings
SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
  int i;
  int rc = SQLITE_OK;
  Vdbe *p = (Vdbe*)pStmt;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
#endif
  sqlite3_mutex_enter(mutex);
  for(i=0; i<p->nVar; i++){
    sqlite3VdbeMemRelease(&p->aVar[i]);
    p->aVar[i].flags = MEM_Null;
  }
  assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );
  if( p->expmask ){
    p->expired = 1;
  }
  sqlite3_mutex_leave(mutex);
  return rc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl 0x20(%rdi), %eax
testw %ax, %ax
jle 0x278153
movq 0x80(%rbx), %rdi
xorl %r14d, %r14d
xorl %r15d, %r15d
testb $0x24, 0x9(%rdi,%r14)
jne 0x278128
cmpl $0x0, 0x20(%rdi,%r14)
je 0x27813b
addq %r14, %rdi
callq 0x291775
movq 0x80(%rbx), %rdi
movzwl 0x20(%rbx), %eax
movw $0x1, 0x8(%rdi,%r14)
incq %r15
movswq %ax, %rcx
addq $0x38, %r14
cmpq %rcx, %r15
jl 0x278118
cmpl $0x0, 0x114(%rbx)
je 0x27816f
movzwl 0xc6(%rbx), %eax
andl $-0x4, %eax
incl %eax
movw %ax, 0xc6(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_value_blob
SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){
  Mem *p = (Mem*)pVal;
  if( p->flags & (MEM_Blob|MEM_Str) ){
    if( ExpandBlob(p)!=SQLITE_OK ){
      assert( p->flags==MEM_Null && p->z==0 );
      return 0;
    }
    p->flags |= MEM_Blob;
    return p->n ? p->z : 0;
  }else{
    return sqlite3_value_text(pVal);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
movzwl %ax, %ecx
testb $0x12, %cl
je 0x2781b0
btl $0xe, %ecx
jae 0x27819d
movq %rbx, %rdi
callq 0x2781c2
testl %eax, %eax
jne 0x2781be
movzwl 0x8(%rbx), %eax
orl $0x10, %eax
movw %ax, 0x8(%rbx)
cmpl $0x0, 0xc(%rbx)
je 0x2781be
movq 0x10(%rbx), %rax
jmp 0x2781c0
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x278305
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemExpandBlob
SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
  int nByte;
  assert( pMem->flags & MEM_Zero );
  assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) );
  testcase( sqlite3_value_nochange(pMem) );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );

  /* Set nByte to the number of bytes required to store the expanded blob. */
  nByte = pMem->n + pMem->u.nZero;
  if( nByte<=0 ){
    if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK;
    nByte = 1;
  }
  if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
    return SQLITE_NOMEM_BKPT;
  }

  memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
  pMem->n += pMem->u.nZero;
  pMem->flags &= ~(MEM_Zero|MEM_Term);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %esi
addl 0xc(%rdi), %esi
jg 0x2781dc
movl $0x1, %esi
xorl %ebp, %ebp
testb $0x10, 0x8(%rbx)
je 0x27820f
movq %rbx, %rdi
movl $0x1, %edx
callq 0x291865
movl $0x7, %ebp
testl %eax, %eax
jne 0x27820f
movslq 0xc(%rbx), %rdi
addq 0x10(%rbx), %rdi
movslq (%rbx), %rdx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x173a0
movl (%rbx), %eax
addl %eax, 0xc(%rbx)
andb $-0x43, 0x9(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ValueBytes
SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
  Mem *p = (Mem*)pVal;
  assert( (p->flags & MEM_Null)==0 || (p->flags & (MEM_Str|MEM_Blob))==0 );
  if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){
    return p->n;
  }
  if( (p->flags & MEM_Blob)!=0 ){
    if( p->flags & MEM_Zero ){
      return p->n + p->u.nZero;
    }else{
      return p->n;
    }
  }
  if( p->flags & MEM_Null ) return 0;
  return valueBytes(pVal, enc);
}

// Assembly:
movzwl 0x8(%rdi), %ecx
testb $0x2, %cl
je 0x27823c
cmpb %sil, 0xa(%rdi)
jne 0x27823c
movl 0xc(%rdi), %eax
retq
testb $0x10, %cl
jne 0x278251
xorl %eax, %eax
testb $0x1, %cl
jne 0x27825a
movzbl %sil, %esi
jmp 0x291a09
btl $0xe, %ecx
movl 0xc(%rdi), %eax
jb 0x27825b
retq
addl (%rdi), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeIntValue
SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
  int flags;
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
  flags = pMem->flags;
  if( flags & (MEM_Int|MEM_IntReal) ){
    testcase( flags & MEM_IntReal );
    return pMem->u.i;
  }else if( flags & MEM_Real ){
    return doubleToInt64(pMem->u.r);
  }else if( (flags & (MEM_Str|MEM_Blob))!=0 && pMem->z!=0 ){
    return memIntValue(pMem);
  }else{
    return 0;
  }
}

// Assembly:
movzwl 0x8(%rdi), %eax
testb $0x24, %al
je 0x278298
movq (%rdi), %rax
retq
testb $0x8, %al
jne 0x2782ac
testb $0x12, %al
je 0x2782b5
cmpq $0x0, 0x10(%rdi)
je 0x2782b5
jmp 0x2927b4
movsd (%rdi), %xmm0
jmp 0x292788
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_value_pointer
SQLITE_API void *sqlite3_value_pointer(sqlite3_value *pVal, const char *zPType){
  Mem *p = (Mem*)pVal;
  if( (p->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) ==
                 (MEM_Null|MEM_Term|MEM_Subtype)
   && zPType!=0
   && p->eSubtype=='p'
   && strcmp(p->u.zPType, zPType)==0
  ){
    return (void*)p->z;
  }else{
    return 0;
  }
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0x2782fe
pushq %rbx
movq %rdi, %rbx
movzwl 0x8(%rdi), %ecx
andl $0xc3bf, %ecx           # imm = 0xC3BF
movzwl %cx, %ecx
cmpl $0x8201, %ecx           # imm = 0x8201
jne 0x2782fd
cmpb $0x70, 0xb(%rbx)
jne 0x2782fb
movq (%rbx), %rdi
callq 0x17a40
testl %eax, %eax
je 0x2782ff
xorl %eax, %eax
popq %rbx
retq
movq 0x10(%rbx), %rax
jmp 0x2782fd
// File: /workspace/github_c_makefile_star2_O3/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 0x278331
movl 0x8(%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x202, %ecx            # imm = 0x202
jne 0x278324
cmpb %sil, 0xa(%rdi)
jne 0x278324
movq 0x10(%rdi), %rax
retq
testb $0x1, %al
jne 0x278331
movzbl %sil, %esi
jmp 0x291a20
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x27838c
movq %rdi, %r14
callq 0x2725a7
testl %eax, %eax
je 0x278399
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x38, %edi
callq 0x272ae6
testq %rax, %rax
je 0x27838c
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x30(%rax)
movups (%r14), %xmm0
movups %xmm0, (%rax)
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 0x27838e
andl $0xffffe3ff, %eax       # imm = 0xFFFFE3FF
orl $0x1000, %eax           # imm = 0x1000
movw %ax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x27840a
testl %eax, %eax
je 0x27838e
movq %rbx, %rdi
callq 0x278453
jmp 0x27838c
// File: /workspace/github_c_makefile_star2_O3/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 0x27844b
btl $0xe, %eax
jae 0x27842f
movq %rbx, %rdi
callq 0x2781c2
movl %eax, %ecx
movl $0x7, %eax
testl %ecx, %ecx
jne 0x278451
cmpl $0x0, 0x20(%rbx)
je 0x27843f
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
je 0x27844b
movq %rbx, %rdi
callq 0x29214c
testl %eax, %eax
jne 0x278451
andb $-0x11, 0x9(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2784ef
callq *%rsi
testq %rbx, %rbx
je 0x278515
movl $0x12, 0x24(%rbx)
movq (%rbx), %rdi
leaq 0x15d3f5(%rip), %rsi    # 0x3d58fa
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
popq %rbx
jmp 0x278594
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x278540
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x2917ab
movq 0x8(%rsp), %xmm0
jmp 0x278546
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 0x278576
movq %xmm0, (%rbx)
movw $0x8, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2788bd
cmpl $0x0, 0x20(%r14)
je 0x2788c5
movq %r14, %rdi
callq 0x291775
testq %r12, %r12
leaq 0x1518a1(%rip), %rax    # 0x3ca170
cmovneq %r12, %rax
movq %rax, (%r14)
movq %r15, 0x10(%r14)
movw $0x8601, 0x8(%r14)      # imm = 0x8601
movb $0x70, 0xb(%r14)
testq %rbx, %rbx
leaq 0x1a127(%rip), %rax     # 0x292a17
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_O3/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 0x27893a
movq %rsi, %rdi
movq %r9, %rsi
movq %rax, %rdx
jmp 0x2784df
cmpb $0x4, %r8b
movzbl %r8b, %ecx
movl $0x2, %edi
cmovnel %ecx, %edi
movzbl %dil, %ecx
movq %rax, %rdi
movq %r9, %r8
jmp 0x278487
// File: /workspace/github_c_makefile_star2_O3/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 0x27899d
movq %rbx, %rdi
callq 0x2917ab
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 0x2789df
testb $0x8, 0x9(%r14)
jne 0x2789df
orl $0x1000, %eax           # imm = 0x1000
movw %ax, 0x8(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x27840a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x278a02
cmpl $0x0, 0x20(%rbx)
je 0x278a0a
movq %rbx, %rdi
callq 0x291775
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_O3/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 0x278a67
retq
cmpl $0x204, %esi            # imm = 0x204
je 0x278a8b
cmpl $0x65, %esi
je 0x278a82
cmpl $0x64, %esi
jne 0x278a94
leaq 0x161a5d(%rip), %rsi    # 0x3da4dd
jmp 0x278abc
leaq 0x161a6a(%rip), %rsi    # 0x3da4f3
jmp 0x278abc
leaq 0x161a35(%rip), %rsi    # 0x3da4c7
jmp 0x278abc
movzbl %sil, %eax
leaq 0x161a1a(%rip), %rsi    # 0x3da4b9
cmpl $0x1c, %eax
ja 0x278abc
movl $0x1410004, %ecx        # imm = 0x1410004
btq %rax, %rcx
jb 0x278abc
movl %eax, %eax
leaq 0x23f728(%rip), %rcx    # 0x4b81e0
movq (%rcx,%rax,8), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
jmp 0x278594
// File: /workspace/github_c_makefile_star2_O3/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 0x278b08
callq 0x2917ab
movq (%rbx), %rdi
jmp 0x278b0e
movw $0x1, 0x8(%rdi)
movl $0x7, 0x24(%rbx)
movq 0x28(%rdi), %rdi
popq %rbx
jmp 0x278b1c
// File: /workspace/github_c_makefile_star2_O3/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 0x278b23
retq
cmpb $0x0, 0x62(%rdi)
jne 0x278b22
movb $0x1, 0x61(%rdi)
cmpl $0x0, 0xcc(%rdi)
jle 0x278b40
movl $0x1, 0x168(%rdi)
incl 0x170(%rdi)
movw $0x0, 0x174(%rdi)
movq 0x130(%rdi), %rax
testq %rax, %rax
je 0x278b22
movl $0x7, 0x18(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x279978
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x172f0
movq %rax, %r14
incq %r14
testq %r15, %r15
je 0x279958
movq %r15, %rdi
movq %r14, %rsi
callq 0x282a35
jmp 0x279960
movq %r14, %rdi
callq 0x272ae6
testq %rax, %rax
je 0x279978
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x17660
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2799dc
movl %esi, %ebp
movq %rdi, %r14
cmpl %esi, 0x20(%rbx)
jge 0x2799ec
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x291865
movq 0x10(%rbx), %rdi
jmp 0x2799f4
testb $0x24, 0x9(%rbx)
je 0x279a15
movq %rbx, %rdi
callq 0x2917ab
jmp 0x279a1b
movq 0x18(%rbx), %rdi
movq %rdi, 0x10(%rbx)
movw $0x2000, 0x8(%rbx)      # imm = 0x2000
movq 0x8(%r14), %rax
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x279a23
movl %ebp, %edx
xorl %esi, %esi
callq 0x173a0
movq 0x10(%rbx), %rax
jmp 0x279a25
movw $0x1, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x279a56
cmpl %esi, 0x4(%rcx)
jne 0x279a4c
testl %esi, %esi
js 0x279a52
movl 0x20(%rdi), %edx
cmpl %edx, (%rcx)
je 0x279a52
movq 0x18(%rcx), %rcx
jmp 0x279a37
movq 0x8(%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x279a94
cmpl %ebp, 0x4(%r14)
jne 0x279a8e
testl %ebp, %ebp
js 0x279afb
movl 0x20(%r15), %eax
cmpl %eax, (%r14)
je 0x279afb
movq 0x18(%r14), %r14
jmp 0x279a76
movq %rcx, %r13
movq (%r12), %rdi
movl $0x20, %esi
callq 0x279b27
testq %rax, %rax
je 0x279ae0
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 0x279b10
movl $0xffffffff, 0x24(%r15) # imm = 0xFFFFFFFF
jmp 0x279b10
testq %r13, %r13
je 0x279b18
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 0x279b10
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_O3/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 0x279b3d
movq %rbx, %rsi
callq 0x282a35
jmp 0x279b45
movq %rbx, %rdi
callq 0x272ae6
movq %rax, %r14
testq %rax, %rax
je 0x279b5a
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_O3/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 0x158348(%rip), %rbx    # 0x3d1f10
testq %rdi, %rdi
je 0x279c06
movq 0xa0(%rdi), %rax
testq %rax, %rax
je 0x279bf2
movzwl 0xc0(%rdi), %ecx
cmpl %esi, %ecx
jbe 0x279bf2
movl %esi, %ecx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, %rbx
jmp 0x279c06
movq (%rdi), %rdi
movl $0x19, 0x50(%rdi)
movl $0x19, %esi
callq 0x284b1f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x279c3a
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x38(%rbx), %eax
cmpl $0xc0a, %eax            # imm = 0xC0A
je 0x279c2c
cmpb $0x0, 0x61(%rdi)
jne 0x279c2c
andl 0x54(%rdi), %eax
jmp 0x279c36
callq 0x28fd56
movl $0x7, %eax
movl %eax, 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x279fa5
leaq 0x1(%r8), %rax
cmpq $0x2, %rax
jb 0x279f9f
pushq %rax
movq %rdx, %rdi
callq *%r8
addq $0x8, %rsp
movl $0x12, %eax
retq
xorl %r9d, %r9d
jmp 0x279e79
// File: /workspace/github_c_makefile_star2_O3/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 0x279ff7
movl %eax, %ebp
testl %eax, %eax
je 0x27a20a
testq %rbx, %rbx
je 0x27a24f
movq %r14, %rdi
callq *%rbx
jmp 0x27a24f
movq 0x80(%r13), %rax
movslq %r12d, %rcx
imulq $0x38, %rcx, %rcx
testq %r15, %r15
leaq 0x14ff4e(%rip), %rdx    # 0x3ca170
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 0x187d1(%rip), %rdx     # 0x292a17
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_O3/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 0x27a28f
leaq 0x1(%r8), %rax
cmpq $0x2, %rax
jb 0x27a289
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 0x279e79
// File: /workspace/github_c_makefile_star2_O3/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 0x15711b(%rip), %r8     # 0x3d13e0
movzbl (%rcx,%r8), %ecx
decl %ecx
cmpl $0x3, %ecx
ja 0x279ff7
leaq 0x155e34(%rip), %r8     # 0x3d0110
movslq (%r8,%rcx,4), %rcx
addq %r8, %rcx
jmpq *%rcx
movq (%rdx), %rdx
jmp 0x27a178
movq 0x10(%rdx), %rax
movl 0xc(%rdx), %ecx
movzbl 0xa(%rdx), %r9d
movq %rax, %rdx
movq $-0x1, %r8
jmp 0x279e79
btl $0xe, %eax
jb 0x27a330
movq 0x10(%rdx), %rax
movl 0xc(%rdx), %ecx
movq %rax, %rdx
movq $-0x1, %r8
xorl %r9d, %r9d
jmp 0x279e79
movsd (%rdx), %xmm0
jmp 0x279fad
movl (%rdx), %edx
jmp 0x27a337
// File: /workspace/github_c_makefile_star2_O3/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), %rdi
movslq 0x7c(%rdi), %rcx
movl $0x12, %eax
cmpq %rdx, %rcx
jb 0x27a39b
movq %rbx, %rdi
callq 0x27a337
movq (%rbx), %rdi
cmpb $0x0, 0x61(%rdi)
je 0x27a3ad
callq 0x28fd56
movl $0x7, %eax
jmp 0x27a3b0
andl 0x54(%rdi), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x27a487
cmpl $0x0, 0x114(%rsi)
je 0x27a45f
movzwl 0xc6(%rsi), %eax
andl $-0x4, %eax
incl %eax
movw %ax, 0xc6(%rsi)
cmpl $0x0, 0x114(%rdi)
je 0x27a47b
movzwl 0xc6(%rdi), %eax
andl $-0x4, %eax
incl %eax
movw %ax, 0xc6(%rdi)
pushq %rax
callq 0x27a488
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x63, %esi
jne 0x27a5de
movq (%rbx), %r14
leaq 0xc(%rsp), %r15
movl $0x0, (%r15)
movq %r15, 0x2d0(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x272469
movq %r14, %rdi
movq %rbx, %rsi
callq 0x282904
movq $0x0, 0x2d0(%r14)
movl (%r15), %eax
jmp 0x27a5f7
movslq %esi, %rcx
movl 0xd0(%rbx,%rcx,4), %eax
testl %edx, %edx
je 0x27a5f7
movl $0x0, 0xd0(%rbx,%rcx,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x27aaec
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x27aaf8
movzwl 0x8(%rbx), %eax
andl $0x3f, %eax
popq %rbx
leaq 0x1568ed(%rip), %rcx    # 0x3d13e0
movzbl (%rax,%rcx), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x292288
testl %eax, %eax
jle 0x27abce
movsd 0x8(%rsp), %xmm1
cmpl $0x1, %eax
jne 0x27aba7
cvttsd2si %xmm1, %rax
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x27ab4d
jnp 0x27ab7d
movabsq $-0x8000000000000, %rcx # imm = 0xFFF8000000000000
addq %rax, %rcx
shrq $0x34, %rcx
cmpl $0xfff, %ecx            # imm = 0xFFF
jb 0x27ab88
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq %xmm1, %rcx
movq %xmm0, %rdx
cmpq %rdx, %rcx
jne 0x27ab88
movq %rax, (%rbx)
movl 0x8(%rbx), %eax
orl $0x4, %eax
jmp 0x27abc5
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %r12d, %ecx
movsd %xmm1, (%rsp)
callq 0x2927e4
movsd (%rsp), %xmm1
testl %eax, %eax
je 0x27ab80
movsd %xmm1, (%rbx)
movl 0x8(%rbx), %eax
orl $0x8, %eax
movw %ax, 0x8(%rbx)
testl %ebp, %ebp
je 0x27abc5
movq %rbx, %rdi
callq 0x29ec6b
movzwl 0x8(%rbx), %eax
andl $0xfffd, %eax           # imm = 0xFFFD
movw %ax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x282a35
movq %rax, %rbx
testq %rax, %rax
je 0x27b66a
movq %rbx, %rdi
addq $0x88, %rdi
movl $0xa0, %edx
xorl %esi, %esi
callq 0x173a0
movq %r15, (%rbx)
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x27b634
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 0x2a83e1
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movl %esi, %r14d
movq %rdi, %rbx
movl 0x90(%rdi), %ecx
leal (%rcx,%r14), %eax
cmpl 0x94(%rdi), %eax
jle 0x27b6ac
movq %rbx, %rdi
callq 0x2a8479
testl %eax, %eax
je 0x27b6a6
xorl %eax, %eax
jmp 0x27b73e
movl 0x90(%rbx), %ecx
movslq %ecx, %rax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x88(%rbx), %rax
testl %r14d, %r14d
jle 0x27b735
movl %r14d, %ecx
xorl %edx, %edx
leaq 0x156b41(%rip), %rsi    # 0x3d2210
movq %rax, %rdi
movzbl (%r15,%rdx,4), %r10d
movb %r10b, (%rdi)
movsbl 0x1(%r15,%rdx,4), %r8d
movl %r8d, 0x4(%rdi)
movb 0x2(%r15,%rdx,4), %r9b
movsbl %r9b, %r8d
movl %r8d, 0x8(%rdi)
testb $0x1, (%r10,%rsi)
je 0x27b708
testb %r9b, %r9b
jle 0x27b708
addl 0x90(%rbx), %r8d
movl %r8d, 0x8(%rdi)
movsbl 0x3(%r15,%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 0x27b6d2
movl 0x90(%rbx), %ecx
addl %r14d, %ecx
movl %ecx, 0x90(%rbx)
popq %rbx
popq %r14
popq %r15
retq