LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: detachFunc
static void detachFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  const char *zName = (const char *)sqlite3_value_text(argv[0]);
  sqlite3 *db = sqlite3_context_db_handle(context);
  int i;
  Db *pDb = 0;
  HashElem *pEntry;
  char zErr[128];

  UNUSED_PARAMETER(NotUsed);

  if( zName==0 ) zName = "";
  for(i=0; i<db->nDb; i++){
    pDb = &db->aDb[i];
    if( pDb->pBt==0 ) continue;
    if( sqlite3DbIsNamed(db, i, zName) ) break;
  }

  if( i>=db->nDb ){
    sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
    goto detach_error;
  }
  if( i<2 ){
    sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
    goto detach_error;
  }
  if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
    sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
    goto detach_error;
  }

  /* If any TEMP triggers reference the schema being detached, move those
  ** triggers to reference the TEMP schema itself. */
  assert( db->aDb[1].pSchema );
  pEntry = sqliteHashFirst(&db->aDb[1].pSchema->trigHash);
  while( pEntry ){
    Trigger *pTrig = (Trigger*)sqliteHashData(pEntry);
    if( pTrig->pTabSchema==pDb->pSchema ){
      pTrig->pTabSchema = pTrig->pSchema;
    }
    pEntry = sqliteHashNext(pEntry);
  }

  sqlite3BtreeClose(pDb->pBt);
  pDb->pBt = 0;
  pDb->pSchema = 0;
  sqlite3CollapseDatabaseArray(db);
  return;

detach_error:
  sqlite3_result_error(context, zErr, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x2243e3
movq %rbx, 0x8(%rsp)
movq (%rbx), %rcx
testq %rax, %rax
leaq 0xe5fea(%rip), %rdx     # 0x36a570
cmovneq %rax, %rdx
movq %rdx, (%rsp)
movq 0x28(%rcx), %r14
movl 0x28(%r14), %r15d
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
pushq $0x18
popq %rbx
cmpq %rbp, %r15
je 0x2845d0
movq 0x20(%r14), %r12
movq -0x10(%r12,%rbx), %r13
testq %r13, %r13
je 0x2845c7
movq %r14, %rdi
movl %ebp, %esi
movq (%rsp), %rdx
callq 0x24b1aa
testl %eax, %eax
jne 0x2845d9
incq %rbp
addq $0x20, %rbx
jmp 0x2845a2
leaq 0xf5367(%rip), %rdx     # 0x37993e
jmp 0x2845fd
cmpq $0x2, %rbp
jae 0x2845e8
leaq 0xf536d(%rip), %rdx     # 0x379953
jmp 0x2845fd
leaq 0xf537e(%rip), %rdx     # 0x37996d
cmpb $0x0, 0x10(%r13)
jne 0x2845fd
cmpl $0x0, 0x18(%r13)
je 0x284637
leaq 0x10(%rsp), %r14
movl $0x80, %edi
movq %r14, %rsi
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x221418
pushq $-0x1
popq %rdx
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2246d3
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%r12), %rax
addq $0x40, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x284660
movq 0x10(%rax), %rcx
movq 0x30(%rcx), %rdx
cmpq (%r12,%rbx), %rdx
jne 0x284640
movq 0x28(%rcx), %rdx
movq %rdx, 0x30(%rcx)
jmp 0x284640
movq %r13, %rdi
callq 0x239820
andq $0x0, -0x10(%r12,%rbx)
andq $0x0, (%r12,%rbx)
movq %r14, %rdi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24e082
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: isAlterableTable
static int isAlterableTable(Parse *pParse, Table *pTab){
  if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
#ifndef SQLITE_OMIT_VIRTUALTABLE
   || ( (pTab->tabFlags & TF_Shadow)!=0
        && sqlite3ReadOnlyShadowTables(pParse->db)
   )
#endif
  ){
    sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rbx
leaq 0xf27ad(%rip), %rsi     # 0x377bf3
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x2217ad
testl %eax, %eax
je 0x28546a
xorl %ebp, %ebp
testb $0x10, 0x41(%r15)
je 0x285481
movq (%r14), %rdi
callq 0x26a894
testl %eax, %eax
je 0x285481
leaq 0xf4920(%rip), %rsi     # 0x379d91
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x226dce
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameReloadSchema
static void renameReloadSchema(Parse *pParse, int iDb){
  Vdbe *v = pParse->pVdbe;
  if( v ){
    sqlite3ChangeCookie(pParse, iDb);
    sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0);
    if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0);
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
je 0x2854b4
movl %esi, %ebp
movq %rdi, %rbx
callq 0x26add3
movq 0x10(%rbx), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x26adfe
cmpl $0x1, %ebp
jne 0x2854bb
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x10(%rbx), %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x26adfe
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameTestSchema
static void renameTestSchema(Parse *pParse, const char *zDb, int bTemp){
  sqlite3NestedParse(pParse,
      "SELECT 1 "
      "FROM \"%w\"." DFLT_SCHEMA_TABLE " "
      "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
      " AND sql NOT LIKE 'create virtual%%'"
      " AND sqlite_rename_test(%Q, sql, type, name, %d)=NULL ",
      zDb,
      zDb, bTemp
  );

  if( bTemp==0 ){
    sqlite3NestedParse(pParse,
        "SELECT 1 "
        "FROM temp." DFLT_SCHEMA_TABLE " "
        "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
        " AND sql NOT LIKE 'create virtual%%'"
        " AND sqlite_rename_test(%Q, sql, type, name, 1)=NULL ",
        zDb
    );
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf48cb(%rip), %rsi     # 0x379dad
movq %rbx, %rdx
movq %rbx, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x26ac90
testl %ebp, %ebp
je 0x2854fb
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xf4952(%rip), %rsi     # 0x379e54
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x26ac90
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: addArgumentToVtab
static void addArgumentToVtab(Parse *pParse){
  if( pParse->sArg.z && pParse->pNewTable ){
    const char *z = (const char*)pParse->sArg.z;
    int n = pParse->sArg.n;
    sqlite3 *db = pParse->db;
    addModuleArgument(pParse, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x168(%rdi), %rsi
testq %rsi, %rsi
je 0x285570
movq %rdi, %rbx
movq 0x148(%rdi), %r14
testq %r14, %r14
je 0x285570
movslq 0x170(%rbx), %rdx
movq (%rbx), %rdi
callq 0x24b168
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24dff8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3WindowOffsetExpr
static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
  if( 0==sqlite3ExprIsConstant(pExpr) ){
    if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
    sqlite3ExprDelete(pParse->db, pExpr);
    pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
  }
  return pExpr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x261298
testl %eax, %eax
je 0x285599
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpb $0x2, 0x11c(%rbx)
jb 0x2855ad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26f5fb
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x24b639
movq (%rbx), %rdi
pushq $0x77
popq %rsi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x25bdcc
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: loadExt
static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
  const char *zFile = (const char *)sqlite3_value_text(argv[0]);
  const char *zProc;
  sqlite3 *db = sqlite3_context_db_handle(context);
  char *zErrMsg = 0;

  /* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc
  ** flag is set.  See the sqlite3_enable_load_extension() API.
  */
  if( (db->flags & SQLITE_LoadExtFunc)==0 ){
    sqlite3_result_error(context, "not authorized", -1);
    return;
  }

  if( argc==2 ){
    zProc = (const char *)sqlite3_value_text(argv[1]);
  }else{
    zProc = 0;
  }
  if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
    sqlite3_result_error(context, zErrMsg, -1);
    sqlite3_free(zErrMsg);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x2243e3
movq (%rbx), %rcx
movq 0x28(%rcx), %r14
andq $0x0, 0x8(%rsp)
testb $0x2, 0x32(%r14)
jne 0x28562d
leaq 0xf20f2(%rip), %rsi     # 0x377708
pushq $-0x1
popq %rdx
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2246d3
movq %rax, %r15
cmpl $0x2, %ebp
jne 0x285644
movq 0x8(%r12), %rdi
callq 0x2243e3
movq %rax, %rdx
jmp 0x285646
xorl %edx, %edx
testq %r15, %r15
je 0x285679
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x228119
testl %eax, %eax
je 0x285679
movq 0x8(%rsp), %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x2246d3
movq 0x8(%rsp), %rdi
callq 0x21f7f9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: lengthFunc
static void lengthFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  switch( sqlite3_value_type(argv[0]) ){
    case SQLITE_BLOB:
    case SQLITE_INTEGER:
    case SQLITE_FLOAT: {
      sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
      break;
    }
    case SQLITE_TEXT: {
      const unsigned char *z = sqlite3_value_text(argv[0]);
      const unsigned char *z0;
      unsigned char c;
      if( z==0 ) return;
      z0 = z;
      while( (c = *z)!=0 ){
        z++;
        if( c>=0xc0 ){
          while( (*z & 0xc0)==0x80 ){ z++; z0++; }
        }
      }
      sqlite3_result_int(context, (int)(z-z0));
      break;
    }
    default: {
      sqlite3_result_null(context);
      break;
    }
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rdi
movzwl 0x8(%rdi), %eax
andl $0x3f, %eax
leaq 0xebcf8(%rip), %rcx     # 0x3717f0
movzbl (%rax,%rcx), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x285b0e
cmpl $0x3, %eax
je 0x285b1e
cmpl $0x4, %eax
jne 0x285b52
callq 0x2243eb
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
jmp 0x224920
callq 0x2243e3
testq %rax, %rax
je 0x285b60
movq %rax, %rcx
movl %ecx, %esi
subl %eax, %esi
movb (%rcx), %dl
testb %dl, %dl
je 0x285b5b
incq %rcx
incl %esi
cmpb $-0x40, %dl
jb 0x285b2f
jmp 0x285b47
incq %rcx
incq %rax
movb (%rcx), %dl
andb $-0x40, %dl
negb %dl
jo 0x285b41
jmp 0x285b2b
movq %rbx, %rdi
popq %rbx
jmp 0x224941
movq %rbx, %rdi
jmp 0x285b18
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: printfFunc
static void printfFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  PrintfArguments x;
  StrAccum str;
  const char *zFormat;
  int n;
  sqlite3 *db = sqlite3_context_db_handle(context);

  if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){
    x.nArg = argc-1;
    x.nUsed = 0;
    x.apArg = argv+1;
    sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
    str.printfFlags = SQLITE_PRINTF_SQLFUNC;
    sqlite3_str_appendf(&str, zFormat, &x);
    n = str.nChar;
    sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n,
                        SQLITE_DYNAMIC);
  }
}

// Assembly:
testl %esi, %esi
jle 0x285e3b
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x28(%rax), %r15
movq (%rdx), %rdi
callq 0x2243e3
testq %rax, %rax
je 0x285e31
decl %ebp
leaq 0x8(%rsp), %rdx
movl %ebp, (%rdx)
andl $0x0, 0x4(%rdx)
addq $0x8, %r14
movq %r14, 0x8(%rdx)
movl 0x7c(%r15), %ecx
leaq 0x18(%rsp), %r14
andq $0x0, 0x8(%r14)
movq %r15, (%r14)
andl $0x0, 0x10(%r14)
movl %ecx, 0x14(%r14)
andl $0x0, 0x18(%r14)
movw $0x200, 0x1c(%r14)      # imm = 0x200
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x221594
movl 0x18(%r14), %ebp
movq %r14, %rdi
callq 0x221200
leaq -0x61273(%rip), %rcx    # 0x224bb1
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x2249c3
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: charFunc
static void charFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  unsigned char *z, *zOut;
  int i;
  zOut = z = sqlite3_malloc64( argc*4+1 );
  if( z==0 ){
    sqlite3_result_error_nomem(context);
    return;
  }
  for(i=0; i<argc; i++){
    sqlite3_int64 x;
    unsigned c;
    x = sqlite3_value_int64(argv[i]);
    if( x<0 || x>0x10ffff ) x = 0xfffd;
    c = (unsigned)(x & 0x1fffff);
    if( c<0x00080 ){
      *zOut++ = (u8)(c&0xFF);
    }else if( c<0x00800 ){
      *zOut++ = 0xC0 + (u8)((c>>6)&0x1F);
      *zOut++ = 0x80 + (u8)(c & 0x3F);
    }else if( c<0x10000 ){
      *zOut++ = 0xE0 + (u8)((c>>12)&0x0F);
      *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
      *zOut++ = 0x80 + (u8)(c & 0x3F);
    }else{
      *zOut++ = 0xF0 + (u8)((c>>18) & 0x07);
      *zOut++ = 0x80 + (u8)((c>>12) & 0x3F);
      *zOut++ = 0x80 + (u8)((c>>6) & 0x3F);
      *zOut++ = 0x80 + (u8)(c & 0x3F);
    }                                                    \
  }
  sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
leal 0x1(,%r15,4), %eax
movslq %eax, %rdi
callq 0x21f7df
testq %rax, %rax
je 0x285fa8
movq %rax, %r12
movq %rbx, (%rsp)
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
movl $0xfffd, %ebx           # imm = 0xFFFD
movq %rax, %r13
cmpq %rbp, %r15
je 0x285f7d
movq (%r14,%rbp,8), %rdi
callq 0x224451
movl %eax, %ecx
andl $0x1fffff, %ecx         # imm = 0x1FFFFF
cmpq $0x110000, %rax         # imm = 0x110000
cmovael %ebx, %ecx
cmpl $0x7f, %ecx
ja 0x285ef3
movb %cl, (%r13)
incq %r13
jmp 0x285f75
movl %ecx, %eax
cmpl $0x7ff, %ecx            # imm = 0x7FF
ja 0x285f16
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%r13)
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x1(%r13)
addq $0x2, %r13
jmp 0x285f75
cmpl $0xffff, %ecx           # imm = 0xFFFF
ja 0x285f44
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%r13)
movl %ecx, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%r13)
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x2(%r13)
addq $0x3, %r13
jmp 0x285f75
shrl $0x12, %eax
orb $-0x10, %al
movb %al, (%r13)
movl %ecx, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%r13)
movl %ecx, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%r13)
andb $0x3f, %cl
orb $-0x80, %cl
movb %cl, 0x3(%r13)
addq $0x4, %r13
incq %rbp
jmp 0x285ebf
subq %r12, %r13
leaq -0x6678e(%rip), %rcx    # 0x21f7f9
pushq $0x1
popq %r8
movq (%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2249ce
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x224b94
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: absFunc
static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  switch( sqlite3_value_type(argv[0]) ){
    case SQLITE_INTEGER: {
      i64 iVal = sqlite3_value_int64(argv[0]);
      if( iVal<0 ){
        if( iVal==SMALLEST_INT64 ){
          /* IMP: R-31676-45509 If X is the integer -9223372036854775808
          ** then abs(X) throws an integer overflow error since there is no
          ** equivalent positive 64-bit two complement value. */
          sqlite3_result_error(context, "integer overflow", -1);
          return;
        }
        iVal = -iVal;
      }
      sqlite3_result_int64(context, iVal);
      break;
    }
    case SQLITE_NULL: {
      /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
      sqlite3_result_null(context);
      break;
    }
    default: {
      /* Because sqlite3_value_double() returns 0.0 if the argument is not
      ** something that can be converted into a number, we have:
      ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob
      ** that cannot be converted to a numeric value.
      */
      double rVal = sqlite3_value_double(argv[0]);
      if( rVal<0 ) rVal = -rVal;
      sqlite3_result_double(context, rVal);
      break;
    }
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rdi
movzwl 0x8(%rdi), %eax
andl $0x3f, %eax
leaq 0xeb81d(%rip), %rcx     # 0x3717f0
movzbl (%rax,%rcx), %eax
cmpl $0x5, %eax
je 0x286003
cmpl $0x1, %eax
jne 0x28600c
callq 0x224451
testq %rax, %rax
jns 0x28602e
negq %rax
jno 0x28602e
leaq 0xf44c5(%rip), %rsi     # 0x37a4bc
pushq $-0x1
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x2246d3
movq %rbx, %rdi
popq %rbx
jmp 0x224941
callq 0x22442c
movapd 0x69a37(%rip), %xmm1    # 0x2efa50
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
movq %rbx, %rdi
movapd %xmm1, %xmm0
popq %rbx
jmp 0x22467f
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x22493c
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: roundFunc
static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
  int n = 0;
  double r;
  char *zBuf;
  assert( argc==1 || argc==2 );
  if( argc==2 ){
    if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
    n = sqlite3_value_int(argv[1]);
    if( n>30 ) n = 30;
    if( n<0 ) n = 0;
  }
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  r = sqlite3_value_double(argv[0]);
  /* If Y==0 and X will fit in a 64-bit int,
  ** handle the rounding directly,
  ** otherwise use printf.
  */
  if( r<-4503599627370496.0 || r>+4503599627370496.0 ){
    /* The value has no fractional part so there is nothing to round */
  }else if( n==0 ){
    r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5)));
  }else{
    zBuf = sqlite3_mprintf("%.*f",n,r);
    if( zBuf==0 ){
      sqlite3_result_error_nomem(context);
      return;
    }
    sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8);
    sqlite3_free(zBuf);
  }
  sqlite3_result_double(context, r);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movabsq $-0x5555555555555556, %r15 # imm = 0xAAAAAAAAAAAAAAAA
xorl %ebp, %ebp
cmpl $0x2, %esi
jne 0x28607e
movq 0x8(%r14), %rdi
movl 0x8(%rdi), %eax
btq %rax, %r15
jb 0x2860f0
callq 0x224451
cmpl $0x1e, %eax
pushq $0x1e
popq %rcx
cmovll %eax, %ecx
xorl %ebp, %ebp
testl %ecx, %ecx
cmovgl %ecx, %ebp
movq (%r14), %rdi
movl 0x8(%rdi), %eax
btq %rax, %r15
jb 0x2860f0
callq 0x22442c
movsd %xmm0, (%rsp)
movapd 0x85cb4(%rip), %xmm1    # 0x30bd50
andpd %xmm0, %xmm1
ucomisd 0xefb70(%rip), %xmm1    # 0x375c18
ja 0x28611e
testl %ebp, %ebp
je 0x2860fb
leaq 0x8bb7f(%rip), %rdi     # 0x311c34
movl %ebp, %esi
movb $0x1, %al
callq 0x22132b
testq %rax, %rax
je 0x286130
movq %rax, %r14
movq %rax, %rdi
callq 0x2211ac
movq %rsp, %r15
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x23a955
movq %r14, %rdi
callq 0x21f7f9
movsd (%r15), %xmm0
jmp 0x28611e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
leaq 0xefa71(%rip), %rcx     # 0x375b80
addsd (%rcx,%rax,8), %xmm0
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22467f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x224b94
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: randomFunc
static void randomFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **NotUsed2
){
  sqlite_int64 r;
  UNUSED_PARAMETER2(NotUsed, NotUsed2);
  sqlite3_randomness(sizeof(r), &r);
  if( r<0 ){
    /* We need to prevent a random number of 0x8000000000000000
    ** (or -9223372036854775808) since when you do abs() of that
    ** number of you get the same value back again.  To do this
    ** in a way that is testable, mask the sign bit off of negative
    ** values, resulting in a positive value.  Then take the
    ** 2s complement of that positive value.  The end result can
    ** therefore be no less than -9223372036854775807.
    */
    r = -(r & LARGEST_INT64);
  }
  sqlite3_result_int64(context, r);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x8
popq %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x221618
movq (%r14), %rsi
testq %rsi, %rsi
jns 0x28632d
btrq $0x3f, %rsi
negq %rsi
movq %rsi, (%rsp)
movq %rbx, %rdi
callq 0x22493c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: randomBlob
static void randomBlob(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  sqlite3_int64 n;
  unsigned char *p;
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  n = sqlite3_value_int64(argv[0]);
  if( n<1 ){
    n = 1;
  }
  p = contextMalloc(context, n);
  if( p ){
    sqlite3_randomness(n, p);
    sqlite3_result_blob(context, (char*)p, n, sqlite3_free);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x224451
cmpq $0x2, %rax
pushq $0x1
popq %r14
cmovgeq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28703d
testq %rax, %rax
je 0x286391
movq %rax, %r15
movl %r14d, %edi
movq %rax, %rsi
callq 0x221618
leaq -0x66b85(%rip), %rcx    # 0x21f7f9
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x22461b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: zeroblobFunc
static void zeroblobFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  i64 n;
  int rc;
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  n = sqlite3_value_int64(argv[0]);
  if( n<0 ) n = 0;
  rc = sqlite3_result_zeroblob64(context, n); /* IMP: R-00293-64994 */
  if( rc ){
    sqlite3_result_error_code(context, rc);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x224451
xorl %esi, %esi
testq %rax, %rax
cmovgq %rax, %rsi
movq %rbx, %rdi
callq 0x224acd
testl %eax, %eax
je 0x28693f
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
jmp 0x224aee
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sumInverse
static void sumInverse(sqlite3_context *context, int argc, sqlite3_value**argv){
  SumCtx *p;
  int type;
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  p = sqlite3_aggregate_context(context, sizeof(*p));
  type = sqlite3_value_numeric_type(argv[0]);
  /* p is always non-NULL because sumStep() will have been called first
  ** to initialize it */
  if( ALWAYS(p) && type!=SQLITE_NULL ){
    assert( p->cnt>0 );
    p->cnt--;
    assert( type==SQLITE_INTEGER || p->approx );
    if( type==SQLITE_INTEGER && p->approx==0 ){
      i64 v = sqlite3_value_int64(argv[0]);
      p->rSum -= v;
      p->iSum -= v;
    }else{
      p->rSum -= sqlite3_value_double(argv[0]);
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
pushq $0x20
popq %rsi
callq 0x225797
movq %rax, %rbx
movq (%r14), %rdi
callq 0x22656f
testq %rbx, %rbx
setne %cl
cmpl $0x5, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x286c92
decq 0x10(%rbx)
cmpl $0x1, %eax
jne 0x286c7e
cmpb $0x0, 0x19(%rbx)
je 0x286c9a
movq (%r14), %rdi
callq 0x22442c
movsd (%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
callq 0x224451
cvtsi2sd %rax, %xmm0
movsd (%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
subq %rax, 0x8(%rbx)
jmp 0x286c92
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: countInverse
static void countInverse(sqlite3_context *ctx, int argc, sqlite3_value **argv){
  CountCtx *p;
  p = sqlite3_aggregate_context(ctx, sizeof(*p));
  /* p is always non-NULL since countStep() will have been called first */
  if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && ALWAYS(p) ){
    p->n--;
#ifdef SQLITE_DEBUG
    p->bInverse = 1;
#endif
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
pushq $0x8
popq %rsi
callq 0x225797
testl %ebp, %ebp
je 0x286dbc
movq (%rbx), %rcx
movl 0x8(%rcx), %ecx
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
btq %rcx, %rdx
setb %cl
testq %rax, %rax
setne %dl
testb %dl, %cl
je 0x286db5
decq (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
testq %rax, %rax
jne 0x286db2
jmp 0x286db5
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: groupConcatStep
static void groupConcatStep(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  const char *zVal;
  StrAccum *pAccum;
  const char *zSep;
  int nVal, nSep;
  assert( argc==1 || argc==2 );
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));

  if( pAccum ){
    sqlite3 *db = sqlite3_context_db_handle(context);
    int firstTerm = pAccum->mxAlloc==0;
    pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
    if( !firstTerm ){
      if( argc==2 ){
        zSep = (char*)sqlite3_value_text(argv[1]);
        nSep = sqlite3_value_bytes(argv[1]);
      }else{
        zSep = ",";
        nSep = 1;
      }
      if( zSep ) sqlite3_str_append(pAccum, zSep, nSep);
    }
    zVal = (char*)sqlite3_value_text(argv[0]);
    nVal = sqlite3_value_bytes(argv[0]);
    if( zVal ) sqlite3_str_append(pAccum, zVal, nVal);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdx), %rax
movl 0x8(%rax), %eax
movabsq $-0x5555555555555556, %rcx # imm = 0xAAAAAAAAAAAAAAAA
btq %rax, %rcx
jb 0x286e78
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
pushq $0x20
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x286e78
movq %rax, %r14
movq (%r15), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x14(%r14)
movl 0x7c(%rax), %eax
movl %eax, 0x14(%r14)
je 0x286e49
cmpl $0x2, %ebp
jne 0x286e34
movq 0x8(%rbx), %rdi
callq 0x2243e3
movq %rax, %r15
movq 0x8(%rbx), %rdi
callq 0x2243eb
testq %r15, %r15
je 0x286e49
movl %eax, %edx
jmp 0x286e3e
pushq $0x1
popq %rdx
leaq 0xba5ed(%rip), %r15     # 0x34142b
movq %r14, %rdi
movq %r15, %rsi
callq 0x220f53
movq (%rbx), %rdi
callq 0x2243e3
movq %rax, %r15
movq (%rbx), %rdi
callq 0x2243eb
testq %r15, %r15
je 0x286e78
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x220f53
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: groupConcatFinalize
static void groupConcatFinalize(sqlite3_context *context){
  StrAccum *pAccum;
  pAccum = sqlite3_aggregate_context(context, 0);
  if( pAccum ){
    if( pAccum->accError==SQLITE_TOOBIG ){
      sqlite3_result_error_toobig(context);
    }else if( pAccum->accError==SQLITE_NOMEM ){
      sqlite3_result_error_nomem(context);
    }else{
      sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1,
                          sqlite3_free);
    }
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x225797
testq %rax, %rax
je 0x286eaa
movzbl 0x1c(%rax), %ecx
cmpl $0x7, %ecx
je 0x286eac
cmpl $0x12, %ecx
jne 0x286eb5
movq %rbx, %rdi
popq %rbx
jmp 0x224b75
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x224b94
movq %rax, %rdi
callq 0x221200
leaq -0x676cb(%rip), %rcx    # 0x21f7f9
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x2249c3
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: groupConcatValue
static void groupConcatValue(sqlite3_context *context){
  sqlite3_str *pAccum;
  pAccum = (sqlite3_str*)sqlite3_aggregate_context(context, 0);
  if( pAccum ){
    if( pAccum->accError==SQLITE_TOOBIG ){
      sqlite3_result_error_toobig(context);
    }else if( pAccum->accError==SQLITE_NOMEM ){
      sqlite3_result_error_nomem(context);
    }else{
      const char *zText = sqlite3_str_value(pAccum);
      sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);
    }
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x225797
testq %rax, %rax
je 0x286efa
movzbl 0x1c(%rax), %ecx
cmpl $0x7, %ecx
je 0x286efc
cmpl $0x12, %ecx
jne 0x286f05
movq %rbx, %rdi
popq %rbx
jmp 0x224b75
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x224b94
movl 0x18(%rax), %ecx
testq %rcx, %rcx
je 0x286f1b
movq 0x8(%rax), %rdx
movb $0x0, (%rdx,%rcx)
movq 0x8(%rax), %rsi
jmp 0x286f1d
xorl %esi, %esi
pushq $-0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rdi
popq %rbx
jmp 0x2249c3
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: groupConcatInverse
static void groupConcatInverse(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  int n;
  StrAccum *pAccum;
  assert( argc==1 || argc==2 );
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));
  /* pAccum is always non-NULL since groupConcatStep() will have always
  ** run frist to initialize it */
  if( ALWAYS(pAccum) ){
    n = sqlite3_value_bytes(argv[0]);
    if( argc==2 ){
      n += sqlite3_value_bytes(argv[1]);
    }else{
      n++;
    }
    if( n>=(int)pAccum->nChar ){
      pAccum->nChar = 0;
    }else{
      pAccum->nChar -= n;
      memmove(pAccum->zText, &pAccum->zText[n], pAccum->nChar);
    }
    if( pAccum->nChar==0 ) pAccum->mxAlloc = 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdx), %rax
movl 0x8(%rax), %eax
movabsq $-0x5555555555555556, %rcx # imm = 0xAAAAAAAAAAAAAAAA
btq %rax, %rcx
jb 0x286fa8
movq %rdx, %r14
movl %esi, %ebp
pushq $0x20
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x286fa8
movq %rax, %rbx
movq (%r14), %rdi
callq 0x2243eb
movl %eax, %r15d
cmpl $0x2, %ebp
jne 0x286f79
movq 0x8(%r14), %rdi
callq 0x2243eb
jmp 0x286f7c
pushq $0x1
popq %rax
addl %r15d, %eax
movl 0x18(%rbx), %edx
subl %eax, %edx
jle 0x286fa0
movl %edx, 0x18(%rbx)
movq 0x8(%rbx), %rdi
movslq %eax, %rsi
addq %rdi, %rsi
callq 0x17c50
cmpl $0x0, 0x18(%rbx)
jne 0x286fa8
jmp 0x286fa4
andl $0x0, 0x18(%rbx)
andl $0x0, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3InsertBuiltinFuncs
SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs(
  FuncDef *aDef,      /* List of global functions to be inserted */
  int nDef            /* Length of the apDef[] list */
){
  int i;
  for(i=0; i<nDef; i++){
    FuncDef *pOther;
    const char *zName = aDef[i].zName;
    int nName = sqlite3Strlen30(zName);
    int h = SQLITE_FUNC_HASH(zName[0], nName);
    assert( zName[0]>='a' && zName[0]<='z' );
    pOther = sqlite3FunctionSearch(h, zName);
    if( pOther ){
      assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] );
      aDef[i].pNext = pOther->pNext;
      pOther->pNext = &aDef[i];
    }else{
      aDef[i].pNext = 0;
      aDef[i].u.pHash = sqlite3BuiltinFunctions.a[h];
      sqlite3BuiltinFunctions.a[h] = &aDef[i];
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
testl %esi, %esi
cmovgl %esi, %r15d
pushq $0x17
popq %r12
pushq $0x10
popq %r13
subq $0x1, %r15
jb 0x28702e
movq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x2211ac
movsbl (%r14), %ecx
addl %ecx, %eax
cltd
idivl %r12d
movl %edx, %ebp
movl %edx, %edi
movq %r14, %rsi
callq 0x289f26
testq %rax, %rax
je 0x287008
addq $0x10, %rax
movq %r13, %rcx
jmp 0x28701e
andq $0x0, 0x10(%rbx)
movslq %ebp, %rax
leaq 0x1b6c81(%rip), %rcx    # 0x43dc98
leaq (%rcx,%rax,8), %rax
pushq $0x40
popq %rcx
movq (%rax), %rdx
movq %rdx, (%rbx,%rcx)
movq %rbx, (%rax)
addq $0x48, %rbx
jmp 0x286fd2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: contextMalloc
static void *contextMalloc(sqlite3_context *context, i64 nByte){
  char *z;
  sqlite3 *db = sqlite3_context_db_handle(context);
  assert( nByte>0 );
  testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
  testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
  if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
    sqlite3_result_error_toobig(context);
    z = 0;
  }else{
    z = sqlite3Malloc(nByte);
    if( !z ){
      sqlite3_result_error_nomem(context);
    }
  }
  return z;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x28(%rax), %rax
movslq 0x7c(%rax), %rax
cmpq %rsi, %rax
jge 0x28705b
movq %rbx, %rdi
callq 0x224b75
jmp 0x287070
movq %rsi, %rdi
callq 0x21f6df
testq %rax, %rax
jne 0x287072
movq %rbx, %rdi
callq 0x224b94
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: minMaxValueFinalize
static void minMaxValueFinalize(sqlite3_context *context, int bValue){
  sqlite3_value *pRes;
  pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
  if( pRes ){
    if( pRes->flags ){
      sqlite3_result_value(context, pRes);
    }
    if( bValue==0 ) sqlite3VdbeMemRelease(pRes);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
xorl %esi, %esi
callq 0x225797
testq %rax, %rax
je 0x2870a3
movq %rax, %r14
cmpw $0x0, 0x8(%rax)
je 0x28709f
movq %r15, %rdi
movq %r14, %rsi
callq 0x224a29
testl %ebx, %ebx
je 0x2870a9
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x224336
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameParseSql
static int renameParseSql(
  Parse *p,                       /* Memory to use for Parse object */
  const char *zDb,                /* Name of schema SQL belongs to */
  sqlite3 *db,                    /* Database handle */
  const char *zSql,               /* SQL to parse */
  int bTemp                       /* True if SQL is from temp schema */
){
  int rc;
  char *zErr = 0;

  db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb);

  /* Parse the SQL statement passed as the first argument. If no error
  ** occurs and the parse does not result in a new table, index or
  ** trigger object, the database must be corrupt. */
  memset(p, 0, sizeof(Parse));
  p->eParseMode = PARSE_MODE_RENAME;
  p->db = db;
  p->nQueryLoop = 1;
  rc = sqlite3RunParser(p, zSql, &zErr);
  assert( p->zErrMsg==0 );
  assert( rc!=SQLITE_OK || zErr==0 );
  p->zErrMsg = zErr;
  if( db->mallocFailed ) rc = SQLITE_NOMEM;
  if( rc==SQLITE_OK
   && p->pNewTable==0 && p->pNewIndex==0 && p->pNewTrigger==0
  ){
    rc = SQLITE_CORRUPT_BKPT;
  }

#ifdef SQLITE_DEBUG
  /* Ensure that all mappings in the Parse.pRename list really do map to
  ** a part of the input string.  */
  if( rc==SQLITE_OK ){
    int nSql = sqlite3Strlen30(zSql);
    RenameToken *pToken;
    for(pToken=p->pRename; pToken; pToken=pToken->pNext){
      assert( pToken->t.z>=zSql && &pToken->t.z[pToken->t.n]<=&zSql[nSql] );
    }
  }
#endif

  db->init.iDb = 0;
  return rc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
andq $0x0, (%rsp)
movq %rdi, %r14
movb $0x1, %al
testl %r8d, %r8d
jne 0x287bc5
movq %rbx, %rdi
callq 0x22b0a8
movb %al, 0xb4(%rbx)
leaq 0x8(%r14), %rdi
movl $0x1a0, %edx            # imm = 0x1A0
xorl %esi, %esi
callq 0x17380
movb $0x2, 0x11c(%r14)
movq %rbx, (%r14)
movl $0x1, 0xc4(%r14)
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x228e55
movl %eax, %ecx
movq (%r12), %rax
movq %rax, 0x8(%r14)
cmpb $0x0, 0x61(%rbx)
pushq $0x7
popq %rax
cmovel %ecx, %eax
testl %eax, %eax
jne 0x287c30
cmpq $0x0, 0x148(%r14)
jne 0x287c2e
cmpq $0x0, 0x150(%r14)
je 0x287c43
xorl %eax, %eax
movb $0x0, 0xb4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpq $0x0, 0x158(%r14)
movl $0x0, %eax
jne 0x287c30
movl $0x1a164, %edi          # imm = 0x1A164
callq 0x232547
jmp 0x287c30
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameColumnExprCb
static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){
  RenameCtx *p = pWalker->u.pRename;
  if( pExpr->op==TK_TRIGGER
   && pExpr->iColumn==p->iCol
   && pWalker->pParse->pTriggerTab==p->pTab
  ){
    renameTokenFind(pWalker->pParse, p, (void*)pExpr);
  }else if( pExpr->op==TK_COLUMN
   && pExpr->iColumn==p->iCol
   && p->pTab==pExpr->y.pTab
  ){
    renameTokenFind(pWalker->pParse, p, (void*)pExpr);
  }
  return WRC_Continue;
}

// Assembly:
pushq %rax
movq %rsi, %rdx
movq 0x28(%rdi), %rsi
movzbl (%rdx), %eax
cmpl $0xa4, %eax
je 0x287c90
cmpl $0x4d, %eax
jne 0x287cab
movswl 0x30(%rdx), %eax
cmpl %eax, 0xc(%rsi)
jne 0x287cab
movq (%rdi), %rdi
movq 0xa8(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x287cab
jmp 0x287ca6
movswl 0x30(%rdx), %eax
cmpl %eax, 0xc(%rsi)
jne 0x287cab
movq 0x10(%rsi), %rax
cmpq 0x40(%rdx), %rax
jne 0x287cab
movq (%rdi), %rdi
callq 0x287cc6
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameTokenFind
static void renameTokenFind(Parse *pParse, struct RenameCtx *pCtx, void *pPtr){
  RenameToken **pp;
  assert( pPtr!=0 );
  for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){
    if( (*pp)->p==pPtr ){
      RenameToken *pToken = *pp;
      *pp = pToken->pNext;
      pToken->pNext = pCtx->pList;
      pCtx->pList = pToken;
      pCtx->nList++;
      break;
    }
  }
}

// Assembly:
addq $0x1a0, %rdi            # imm = 0x1A0
movq (%rdi), %rax
testq %rax, %rax
je 0x287cf5
movq %rdi, %rcx
leaq 0x18(%rax), %rdi
cmpq %rdx, (%rax)
jne 0x287ccd
movq 0x18(%rax), %rdx
movq %rdx, (%rcx)
movq (%rsi), %rcx
movq %rcx, 0x18(%rax)
movq %rax, (%rsi)
incl 0x8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameColumnElistNames
static void renameColumnElistNames(
  Parse *pParse,
  RenameCtx *pCtx,
  ExprList *pEList,
  const char *zOld
){
  if( pEList ){
    int i;
    for(i=0; i<pEList->nExpr; i++){
      char *zName = pEList->a[i].zEName;
      if( ALWAYS(pEList->a[i].eEName==ENAME_NAME)
       && ALWAYS(zName!=0)
       && 0==sqlite3_stricmp(zName, zOld)
      ){
        renameTokenFind(pParse, pCtx, (void*)zName);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rdx, %rdx
je 0x287f9d
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r12
leaq 0x10(%rdx), %rbp
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r15
jge 0x287f9d
movq (%rbp), %r13
testb $0x3, 0x9(%rbp)
sete %al
testq %r13, %r13
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x287f94
movq %r13, %rdi
movq %rbx, %rsi
callq 0x221763
testl %eax, %eax
jne 0x287f94
movq %r12, %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0x287cc6
incq %r15
addq $0x18, %rbp
jmp 0x287f56
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameColumnIdlistNames
static void renameColumnIdlistNames(
  Parse *pParse,
  RenameCtx *pCtx,
  IdList *pIdList,
  const char *zOld
){
  if( pIdList ){
    int i;
    for(i=0; i<pIdList->nId; i++){
      char *zName = pIdList->a[i].zName;
      if( 0==sqlite3_stricmp(zName, zOld) ){
        renameTokenFind(pParse, pCtx, (void*)zName);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rdx, %rdx
je 0x288005
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r12
xorl %ebp, %ebp
xorl %r15d, %r15d
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jge 0x288005
movq (%r14), %rax
movq (%rax,%rbp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x221763
testl %eax, %eax
jne 0x287ffc
movq %r12, %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0x287cc6
incq %r15
addq $0x10, %rbp
jmp 0x287fce
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameWalkTrigger
static void renameWalkTrigger(Walker *pWalker, Trigger *pTrigger){
  TriggerStep *pStep;

  /* Find tokens to edit in WHEN clause */
  sqlite3WalkExpr(pWalker, pTrigger->pWhen);

  /* Find tokens to edit in trigger steps */
  for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){
    sqlite3WalkSelect(pWalker, pStep->pSelect);
    sqlite3WalkExpr(pWalker, pStep->pWhere);
    sqlite3WalkExprList(pWalker, pStep->pExprList);
    if( pStep->pUpsert ){
      Upsert *pUpsert = pStep->pUpsert;
      sqlite3WalkExprList(pWalker, pUpsert->pUpsertTarget);
      sqlite3WalkExprList(pWalker, pUpsert->pUpsertSet);
      sqlite3WalkExpr(pWalker, pUpsert->pUpsertWhere);
      sqlite3WalkExpr(pWalker, pUpsert->pUpsertTargetWhere);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
callq 0x267f87
addq $0x38, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x288096
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x268025
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x267f87
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x268181
movq 0x40(%rbx), %r15
testq %r15, %r15
je 0x288090
movq (%r15), %rsi
movq %r14, %rdi
callq 0x268181
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x268181
movq 0x18(%r15), %rsi
movq %r14, %rdi
callq 0x267f87
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x267f87
addq $0x50, %rbx
jmp 0x28802c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameColumnParseError
static void renameColumnParseError(
  sqlite3_context *pCtx,
  int bPost,
  sqlite3_value *pType,
  sqlite3_value *pObject,
  Parse *pParse
){
  const char *zT = (const char*)sqlite3_value_text(pType);
  const char *zN = (const char*)sqlite3_value_text(pObject);
  char *zErr;

  zErr = sqlite3_mprintf("error in %s %s%s: %s",
      zT, zN, (bPost ? " after rename" : ""),
      pParse->zErrMsg
  );
  sqlite3_result_error(pCtx, zErr, -1);
  sqlite3_free(zErr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x2243e3
movq %rax, %r12
movq %r15, %rdi
callq 0x2243e3
testl %ebp, %ebp
leaq 0xe229e(%rip), %rdx     # 0x36a570
leaq 0xf224c(%rip), %rcx     # 0x37a525
cmoveq %rdx, %rcx
movq 0x8(%r14), %r8
leaq 0xf2228(%rip), %rdi     # 0x37a510
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x22132b
movq %rax, %r14
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2246d3
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21f7f9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameParseCleanup
static void renameParseCleanup(Parse *pParse){
  sqlite3 *db = pParse->db;
  Index *pIdx;
  if( pParse->pVdbe ){
    sqlite3VdbeFinalize(pParse->pVdbe);
  }
  sqlite3DeleteTable(db, pParse->pNewTable);
  while( (pIdx = pParse->pNewIndex)!=0 ){
    pParse->pNewIndex = pIdx->pNext;
    sqlite3FreeIndex(db, pIdx);
  }
  sqlite3DeleteTrigger(db, pParse->pNewTrigger);
  sqlite3DbFree(db, pParse->zErrMsg);
  renameTokenFree(db, pParse->pRename);
  sqlite3ParserReset(pParse);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x28832e
callq 0x224149
movq 0x148(%rbx), %rsi
movq %r14, %rdi
callq 0x21f182
movq 0x150(%rbx), %rsi
testq %rsi, %rsi
je 0x28835e
movq 0x28(%rsi), %rax
movq %rax, 0x150(%rbx)
movq %r14, %rdi
callq 0x24b5ea
jmp 0x28833d
movq 0x158(%rbx), %rsi
movq %r14, %rdi
callq 0x21f128
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x21f26b
movq 0x1a0(%rbx), %rsi
movq %r14, %rdi
callq 0x288397
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22767e
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameTokenFree
static void renameTokenFree(sqlite3 *db, RenameToken *pToken){
  RenameToken *pNext;
  RenameToken *p;
  for(p=pToken; p; p=pNext){
    pNext = p->pNext;
    sqlite3DbFree(db, p);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2883b4
movq 0x18(%rsi), %r14
movq %rbx, %rdi
callq 0x22d0fc
movq %r14, %rsi
jmp 0x28839e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameTableExprCb
static int renameTableExprCb(Walker *pWalker, Expr *pExpr){
  RenameCtx *p = pWalker->u.pRename;
  if( pExpr->op==TK_COLUMN && p->pTab==pExpr->y.pTab ){
    renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
  }
  return WRC_Continue;
}

// Assembly:
cmpb $-0x5c, (%rsi)
jne 0x2883e3
movq %rsi, %rdx
movq 0x28(%rdi), %rsi
movq 0x10(%rsi), %rax
cmpq 0x40(%rdx), %rax
jne 0x2883e3
pushq %rax
addq $0x40, %rdx
movq (%rdi), %rdi
callq 0x287cc6
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameTableSelectCb
static int renameTableSelectCb(Walker *pWalker, Select *pSelect){
  int i;
  RenameCtx *p = pWalker->u.pRename;
  SrcList *pSrc = pSelect->pSrc;
  if( pSelect->selFlags & SF_View ) return WRC_Prune;
  if( pSrc==0 ){
    assert( pWalker->pParse->db->mallocFailed );
    return WRC_Abort;
  }
  for(i=0; i<pSrc->nSrc; i++){
    struct SrcList_item *pItem = &pSrc->a[i];
    if( pItem->pTab==p->pTab ){
      renameTokenFind(pWalker->pParse, p, pItem->zName);
    }
  }
  renameWalkWith(pWalker, pSelect);

  return WRC_Continue;
}

// Assembly:
testb $0x20, 0x6(%rsi)
jne 0x28843c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rsi), %r12
testq %r12, %r12
je 0x28844f
movq %rdi, %r14
movq 0x28(%rdi), %r15
leaq 0x28(%r12), %r13
xorl %ebp, %ebp
movslq (%r12), %rax
cmpq %rax, %rbp
jge 0x288440
movq (%r13), %rax
cmpq 0x10(%r15), %rax
jne 0x288433
movq (%r14), %rdi
movq -0x10(%r13), %rdx
movq %r15, %rsi
callq 0x287cc6
incq %rbp
addq $0x70, %r13
jmp 0x288411
pushq $0x1
popq %rax
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26f788
xorl %eax, %eax
jmp 0x288452
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: dense_rankValueFunc
static void dense_rankValueFunc(sqlite3_context *pCtx){
  struct CallCount *p;
  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
  if( p ){
    if( p->nStep ){
      p->nValue++;
      p->nStep = 0;
    }
    sqlite3_result_int64(pCtx, p->nValue);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0x225797
testq %rax, %rax
je 0x2884dc
cmpq $0x0, 0x8(%rax)
movq (%rax), %rsi
je 0x2884d3
incq %rsi
movq %rsi, (%rax)
andq $0x0, 0x8(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x22493c
popq %rbx
retq