LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMultiLoad
SQLITE_PRIVATE void sqlite3VdbeMultiLoad(Vdbe *p, int iDest, const char *zTypes, ...){
  va_list ap;
  int i;
  char c;
  va_start(ap, zTypes);
  for(i=0; (c = zTypes[i])!=0; i++){
    if( c=='s' ){
      const char *z = va_arg(ap, const char*);
      sqlite3VdbeAddOp4(p, z==0 ? OP_Null : OP_String8, 0, iDest+i, 0, z, 0);
    }else if( c=='i' ){
      sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest+i);
    }else{
      goto skip_op_resultrow;
    }
  }
  sqlite3VdbeAddOp2(p, OP_ResultRow, iDest, i);
skip_op_resultrow:
  va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
testb %al, %al
je 0x46279b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movl $0x0, -0x34(%rbp)
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x35(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x462953
movsbl -0x35(%rbp), %eax
cmpl $0x73, %eax
jne 0x4628ad
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x462848
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x462865
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rcx
movl $0x73, %esi
movl $0x48, %eax
cmpq $0x0, %rcx
cmovel %eax, %esi
movl -0xc(%rbp), %ecx
addl -0x34(%rbp), %ecx
movq -0x40(%rbp), %r9
xorl %r8d, %r8d
movl %r8d, %edx
movl $0x0, (%rsp)
callq 0x429aa0
jmp 0x462943
movsbl -0x35(%rbp), %eax
cmpl $0x69, %eax
jne 0x46293f
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x118(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x10c(%rbp)
cmpl $0x28, %eax
ja 0x462900
movq -0x118(%rbp), %rcx
movl -0x10c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x128(%rbp)
jmp 0x46291d
movq -0x118(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x128(%rbp)
movq -0x120(%rbp), %rdi
movq -0x128(%rbp), %rax
movl (%rax), %edx
movl -0xc(%rbp), %ecx
addl -0x34(%rbp), %ecx
movl $0x45, %esi
callq 0x410100
jmp 0x462941
jmp 0x462967
jmp 0x462943
jmp 0x462945
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4627e6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x34(%rbp), %ecx
movl $0x50, %esi
callq 0x410100
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: pragmaFunclistLine
static void pragmaFunclistLine(
  Vdbe *v,               /* The prepared statement being created */
  FuncDef *p,            /* A particular function definition */
  int isBuiltin,         /* True if this is a built-in function */
  int showInternFuncs    /* True if showing internal functions */
){
  for(; p; p=p->pNext){
    const char *zType;
    static const u32 mask =
        SQLITE_DETERMINISTIC |
        SQLITE_DIRECTONLY |
        SQLITE_SUBTYPE |
        SQLITE_INNOCUOUS |
        SQLITE_FUNC_INTERNAL
    ;
    static const char *azEnc[] = { 0, "utf8", "utf16le", "utf16be" };

    assert( SQLITE_FUNC_ENCMASK==0x3 );
    assert( strcmp(azEnc[SQLITE_UTF8],"utf8")==0 );
    assert( strcmp(azEnc[SQLITE_UTF16LE],"utf16le")==0 );
    assert( strcmp(azEnc[SQLITE_UTF16BE],"utf16be")==0 );

    if( p->xSFunc==0 ) continue;
    if( (p->funcFlags & SQLITE_FUNC_INTERNAL)!=0
     && showInternFuncs==0
    ){
      continue;
    }
    if( p->xValue!=0 ){
      zType = "w";
    }else if( p->xFinalize!=0 ){
      zType = "a";
    }else{
      zType = "s";
    }
    sqlite3VdbeMultiLoad(v, 1, "sissii",
       p->zName, isBuiltin,
       zType, azEnc[p->funcFlags&SQLITE_FUNC_ENCMASK],
       p->nArg,
       (p->funcFlags & mask) ^ SQLITE_INNOCUOUS
    );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x462a71
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x4629a1
jmp 0x462a60
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x40000, %eax          # imm = 0x40000
cmpl $0x0, %eax
je 0x4629bd
cmpl $0x0, -0x18(%rbp)
jne 0x4629bd
jmp 0x462a60
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4629d5
leaq 0x1034f6(%rip), %rax    # 0x565ec5
movq %rax, -0x20(%rbp)
jmp 0x4629fa
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4629ed
leaq 0xd1077(%rip), %rax     # 0x533a5e
movq %rax, -0x20(%rbp)
jmp 0x4629f8
leaq 0xc9eb8(%rip), %rax     # 0x52c8ac
movq %rax, -0x20(%rbp)
jmp 0x4629fa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movl -0x14(%rbp), %r8d
movq -0x20(%rbp), %r9
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x3, %eax
movl %eax, %eax
movl %eax, %edx
leaq 0x1dd5fd(%rip), %rax    # 0x640020
movq (%rax,%rdx,8), %r11
movq -0x10(%rbp), %rax
movsbl (%rax), %r10d
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x3c0800, %eax         # imm = 0x3C0800
xorl $0x200000, %eax         # imm = 0x200000
movl $0x1, %esi
leaq 0x14bc64(%rip), %rdx    # 0x5ae6b0
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x462760
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x462986
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RegisterLikeFunctions
SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
  struct compareInfo *pInfo;
  int flags;
  if( caseSensitive ){
    pInfo = (struct compareInfo*)&likeInfoAlt;
    flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE;
  }else{
    pInfo = (struct compareInfo*)&likeInfoNorm;
    flags = SQLITE_FUNC_LIKE;
  }
  sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0);
  sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0);
  sqlite3FindFunction(db, "like", 2, SQLITE_UTF8, 0)->funcFlags |= flags;
  sqlite3FindFunction(db, "like", 3, SQLITE_UTF8, 0)->funcFlags |= flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x462b29
leaq 0x147dcc(%rip), %rax    # 0x5aa8e8
movq %rax, -0x18(%rbp)
movl $0xc, -0x1c(%rbp)
jmp 0x462b3b
leaq 0x14409c(%rip), %rax    # 0x5a6bcc
movq %rax, -0x18(%rbp)
movl $0x4, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %r8
leaq 0x14980f(%rip), %rsi    # 0x5ac359
movl $0x2, %edx
movl $0x1, %ecx
leaq 0x265(%rip), %r9        # 0x462dc0
xorl %eax, %eax
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
callq 0x3d18e0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %r8
leaq 0x1497bc(%rip), %rsi    # 0x5ac359
movl $0x3, %edx
movl $0x1, %ecx
leaq 0x212(%rip), %r9        # 0x462dc0
xorl %eax, %eax
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
callq 0x3d18e0
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x149767(%rip), %rsi    # 0x5ac359
movl $0x2, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x3d1cd0
movl -0x24(%rbp), %ecx
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x14973b(%rip), %rsi    # 0x5ac359
movl $0x3, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x3d1cd0
movl -0x20(%rbp), %ecx
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: integrityCheckResultRow
static int integrityCheckResultRow(Vdbe *v){
  int addr;
  sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);
  addr = sqlite3VdbeAddOp3(v, OP_IfPos, 1, sqlite3VdbeCurrentAddr(v)+2, 1);
  VdbeCoverage(v);
  sqlite3VdbeAddOp0(v, OP_Halt);
  return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x50, %esi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x410100
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x430ae0
movq -0x18(%rbp), %rdi
movl %eax, %ecx
addl $0x2, %ecx
movl $0x30, %esi
movl $0x1, %r8d
movl %r8d, %edx
callq 0x410130
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x44, %esi
callq 0x429a40
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3FixTriggerStep
SQLITE_PRIVATE int sqlite3FixTriggerStep(
  DbFixer *pFix,     /* Context of the fixation */
  TriggerStep *pStep /* The trigger step be fixed to one database */
){
  while( pStep ){
    if( sqlite3FixSelect(pFix, pStep->pSelect) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pStep->pWhere) ){
      return 1;
    }
    if( sqlite3FixExprList(pFix, pStep->pExprList) ){
      return 1;
    }
    if( pStep->pFrom && sqlite3FixSrcList(pFix, pStep->pFrom) ){
      return 1;
    }
#ifndef SQLITE_OMIT_UPSERT
    if( pStep->pUpsert ){
      Upsert *pUp = pStep->pUpsert;
      if( sqlite3FixExprList(pFix, pUp->pUpsertTarget)
       || sqlite3FixExpr(pFix, pUp->pUpsertTargetWhere)
       || sqlite3FixExprList(pFix, pUp->pUpsertSet)
       || sqlite3FixExpr(pFix, pUp->pUpsertWhere)
      ){
        return 1;
      }
    }
#endif
    pStep = pStep->pNext;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x463098
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x43d600
cmpl $0x0, %eax
je 0x462f9d
movl $0x1, -0x4(%rbp)
jmp 0x46309f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x43d790
cmpl $0x0, %eax
je 0x462fbf
movl $0x1, -0x4(%rbp)
jmp 0x46309f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x43d8d0
cmpl $0x0, %eax
je 0x462fe1
movl $0x1, -0x4(%rbp)
jmp 0x46309f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x46300e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x43cf30
cmpl $0x0, %eax
je 0x46300e
movl $0x1, -0x4(%rbp)
jmp 0x46309f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x463087
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x43d8d0
cmpl $0x0, %eax
jne 0x46307c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x43d790
cmpl $0x0, %eax
jne 0x46307c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x43d8d0
cmpl $0x0, %eax
jne 0x46307c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x43d790
cmpl $0x0, %eax
je 0x463085
movl $0x1, -0x4(%rbp)
jmp 0x46309f
jmp 0x463087
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x462f70
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: triggerStepAllocate
static TriggerStep *triggerStepAllocate(
  Parse *pParse,              /* Parser context */
  u8 op,                      /* Trigger opcode */
  Token *pName,               /* The target name */
  const char *zStart,         /* Start of SQL text */
  const char *zEnd            /* End of SQL text */
){
  sqlite3 *db = pParse->db;
  TriggerStep *pTriggerStep;

  pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1);
  if( pTriggerStep ){
    char *z = (char*)&pTriggerStep[1];
    memcpy(z, pName->z, pName->n);
    sqlite3Dequote(z);
    pTriggerStep->zTarget = z;
    pTriggerStep->op = op;
    pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd);
    if( IN_RENAME_OBJECT ){
      sqlite3RenameTokenMap(pParse, pTriggerStep->zTarget, pName);
    }
  }
  return pTriggerStep;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
addq $0x60, %rsi
addq $0x1, %rsi
callq 0x3c9520
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x463188
movq -0x38(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x19610
movq -0x40(%rbp), %rdi
callq 0x43c5e0
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movb -0x9(%rbp), %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4631a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movzbl 0x11c(%rax), %eax
cmpl $0x2, %eax
jl 0x463186
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x41dae0
jmp 0x463188
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: triggerSpanDup
static char *triggerSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){
  char *z = sqlite3DbSpanDup(db, zStart, zEnd);
  int i;
  if( z ) for(i=0; z[i]; i++) if( sqlite3Isspace(z[i]) ) z[i] = ' ';
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x43c700
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x463221
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x46321f
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x1439d6(%rip), %rax    # 0x5a6bd0
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x463212
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x20, (%rax,%rcx)
jmp 0x463214
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4631d7
jmp 0x463221
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SchemaGet
SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
  Schema * p;
  if( pBt ){
    p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
  }else{
    p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));
  }
  if( !p ){
    sqlite3OomFault(db);
  }else if ( 0==p->file_format ){
    sqlite3HashInit(&p->tblHash);
    sqlite3HashInit(&p->idxHash);
    sqlite3HashInit(&p->trigHash);
    sqlite3HashInit(&p->fkeyHash);
    p->enc = SQLITE_UTF8;
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4642b2
movq -0x10(%rbp), %rdi
movl $0x78, %esi
leaq -0x66a17(%rip), %rdx    # 0x3fd890
callq 0x3dba70
movq %rax, -0x18(%rbp)
jmp 0x4642c4
xorl %eax, %eax
movl %eax, %edi
movl $0x78, %esi
callq 0x3c9520
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4642d6
movq -0x8(%rbp), %rdi
callq 0x3c8ba0
jmp 0x464322
movq -0x18(%rbp), %rax
movzbl 0x70(%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x464320
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x40a9e0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x40a9e0
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x40a9e0
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x40a9e0
movq -0x18(%rbp), %rax
movb $0x1, 0x71(%rax)
jmp 0x464322
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: resolveAttachExpr
static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
{
  int rc = SQLITE_OK;
  if( pExpr ){
    if( pExpr->op!=TK_ID ){
      rc = sqlite3ResolveExprNames(pName, pExpr);
    }else{
      pExpr->op = TK_STRING;
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x464375
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x3b, %eax
je 0x46436c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x435380
movl %eax, -0x14(%rbp)
jmp 0x464373
movq -0x10(%rbp), %rax
movb $0x73, (%rax)
jmp 0x464375
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x1473ff(%rip), %rsi    # 0x5acc6d
movl $0x7, %edx
callq 0x3c3ef0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x4658a2
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x4658c4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x433d30
cmpl $0x0, %eax
je 0x4658c4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x149557(%rip), %rsi    # 0x5aee0b
movb $0x0, %al
callq 0x3cb660
movl $0x1, -0x4(%rbp)
jmp 0x4658cb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x465940
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x434f00
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x434f60
cmpl $0x1, -0xc(%rbp)
je 0x46593e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x434f60
jmp 0x465940
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq 0x1494ad(%rip), %rsi    # 0x5aee27
movb $0x0, %al
callq 0x434d60
cmpl $0x0, -0x14(%rbp)
jne 0x46599d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x149538(%rip), %rsi    # 0x5aeece
movb $0x0, %al
callq 0x434d60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: isRealTable
static int isRealTable(Parse *pParse, Table *pTab){
  const char *zType = 0;
#ifndef SQLITE_OMIT_VIEW
  if( pTab->pSelect ){
    zType = "view";
  }
#endif
#ifndef SQLITE_OMIT_VIRTUALTABLE
  if( IsVirtual(pTab) ){
    zType = "virtual table";
  }
#endif
  if( zType ){
    sqlite3ErrorMsg(
        pParse, "cannot rename columns of %s \"%s\"", zType, pTab->zName
    );
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x465a1e
leaq 0x14890e(%rip), %rax    # 0x5ae328
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x54(%rax)
je 0x465a33
leaq 0x149887(%rip), %rax    # 0x5af2b6
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x465a60
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x149874(%rip), %rsi    # 0x5af2c4
movb $0x0, %al
callq 0x3cb660
movl $0x1, -0x4(%rbp)
jmp 0x465a67
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x168(%rax)
je 0x465af7
movq -0x8(%rbp), %rax
cmpq $0x0, 0x148(%rax)
je 0x465af7
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x170(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x40bb40
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x4117a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x422b80
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x465b69
movq -0x8(%rbp), %rax
movzbl 0x11c(%rax), %eax
cmpl $0x2, %eax
jl 0x465b3e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43c7b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40c670
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x77, %esi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x41d660
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7880
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3c9230
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
andq $0x20000, %rax          # imm = 0x20000
cmpq $0x0, %rax
jne 0x465c23
movq -0x8(%rbp), %rdi
leaq 0x146b62(%rip), %rsi    # 0x5ac779
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3c8120
jmp 0x465c80
cmpl $0x2, -0xc(%rbp)
jne 0x465c3c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3c7880
movq %rax, -0x28(%rbp)
jmp 0x465c44
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x465c80
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x3cd4b0
cmpl $0x0, %eax
je 0x465c80
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3c8120
movq -0x38(%rbp), %rdi
callq 0x3c0800
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7cc0
movl %eax, %ecx
movl %ecx, %eax
decl %eax
movl %ecx, -0x30(%rbp)
subl $0x2, %eax
jb 0x466367
jmp 0x46634f
movl -0x30(%rbp), %eax
subl $0x3, %eax
je 0x46638b
jmp 0x466359
movl -0x30(%rbp), %eax
subl $0x4, %eax
jne 0x466422
jmp 0x466367
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c78a0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x3c8480
jmp 0x46642b
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7880
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4663a7
jmp 0x46642b
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x29(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
je 0x46640a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0xc0, %eax
jl 0x466408
jmp 0x4663d9
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
jne 0x466406
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4663d9
jmp 0x466408
jmp 0x4663af
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, %esi
callq 0x3c8480
jmp 0x46642b
movq -0x8(%rbp), %rdi
callq 0x3c8530
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3c9230
movq %rax, -0x60(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x46675b
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7880
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x46675b
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x60(%rbp), %rsi
movq -0x60(%rbp), %rax
movl 0x7c(%rax), %r8d
leaq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x3c36a0
movb $0x2, -0x2b(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rdx
movb $0x0, %al
callq 0x3c3ac0
movl -0x30(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3c3490
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movl -0x54(%rbp), %edx
leaq -0x9dbb6(%rip), %rcx    # 0x3c8ba0
callq 0x3c86c0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7cc0
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
subl $0x1, %eax
je 0x466a55
jmp 0x466a4b
movl -0x2c(%rbp), %eax
subl $0x5, %eax
je 0x466aac
jmp 0x466ab7
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7af0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x466a9d
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x20(%rbp)
jne 0x466a93
movq -0x8(%rbp), %rdi
leaq 0x148aab(%rip), %rsi    # 0x5af532
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3c8120
jmp 0x466b01
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c8500
jmp 0x466b01
movq -0x8(%rbp), %rdi
callq 0x3c8530
jmp 0x466b01
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c79a0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x466af3
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x3c80a0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x466b79
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3c7cc0
movl %eax, %ecx
movl $0x5, %eax
cmpl %ecx, %eax
jne 0x466b4d
jmp 0x466c7d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3c7a40
movl %eax, -0x1c(%rbp)
cmpl $0x1e, -0x1c(%rbp)
jle 0x466b6a
movl $0x1e, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x466b77
movl $0x0, -0x1c(%rbp)
jmp 0x466b79
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7cc0
cmpl $0x5, %eax
jne 0x466b8f
jmp 0x466c7d
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c79a0
movsd %xmm0, -0x28(%rbp)
movsd 0x1440e0(%rip), %xmm0   # 0x5aac88
ucomisd -0x28(%rbp), %xmm0
ja 0x466bc2
movsd -0x28(%rbp), %xmm0
movsd 0x1440d4(%rip), %xmm1   # 0x5aac90
ucomisd %xmm1, %xmm0
jbe 0x466bc7
jmp 0x466c6f
cmpl $0x0, -0x1c(%rbp)
jne 0x466c13
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd 0xd6851(%rip), %xmm4    # 0x53d430
movsd 0xc0321(%rip), %xmm3    # 0x526f08
xorps %xmm2, %xmm2
cmpltsd %xmm2, %xmm1
movaps %xmm1, %xmm2
andpd %xmm4, %xmm2
andnpd %xmm3, %xmm1
orpd %xmm2, %xmm1
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x466c6d
movl -0x1c(%rbp), %esi
movsd -0x28(%rbp), %xmm0
leaq 0xdd04b(%rip), %rdi     # 0x543c6d
movb $0x1, %al
callq 0x3c3780
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x466c3f
movq -0x8(%rbp), %rdi
callq 0x3c8b60
jmp 0x466c7d
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3c3400
movq -0x38(%rbp), %rdi
movl %eax, %edx
leaq -0x28(%rbp), %rsi
movl $0x1, %ecx
callq 0x3ef260
movq -0x30(%rbp), %rdi
callq 0x3c0800
jmp 0x466c6f
movq -0x8(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x3c80a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7af0
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jge 0x466fb2
movq $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x468500
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x466ff3
movq -0x20(%rbp), %rax
movl %eax, %edi
movq -0x28(%rbp), %rsi
callq 0x3c3b60
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq -0xa67ee(%rip), %rcx    # 0x3c0800
callq 0x3c7f50
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7af0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x467882
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c89a0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x4678a4
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x3c8a00
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x3c9270
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3caca0
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x467e74
cmpl $0x5, -0x24(%rbp)
je 0x467e74
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
cmpl $0x1, -0x24(%rbp)
jne 0x467e53
movq -0x20(%rbp), %rax
movzbl 0x19(%rax), %eax
cmpl $0x0, %eax
jne 0x467e53
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7af0
movq %rax, -0x30(%rbp)
cvtsi2sdq -0x30(%rbp), %xmm1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0x467e72
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c79a0
movaps %xmm0, %xmm1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
jmp 0x467e74
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x3c9270
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x468042
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7cc0
movl %eax, %ecx
movl $0x5, %eax
cmpl %ecx, %eax
je 0x468057
cmpq $0x0, -0x20(%rbp)
je 0x468057
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7cc0
cmpl $0x5, %eax
jne 0x468089
jmp 0x468166
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x3c9270
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x468166
movq -0x8(%rbp), %rdi
callq 0x3c9230
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x14(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movl 0x7c(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x14(%rax)
cmpl $0x0, -0x44(%rbp)
jne 0x46812e
cmpl $0x2, -0xc(%rbp)
jne 0x468103
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3c7880
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3c78a0
movl %eax, -0x38(%rbp)
jmp 0x468115
leaq 0x10b5e9(%rip), %rax    # 0x5736f3
movq %rax, -0x30(%rbp)
movl $0x1, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x46812c
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x38(%rbp), %edx
callq 0x3c2d40
jmp 0x46812e
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7880
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c78a0
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x468164
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x3c2d40
jmp 0x468166
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3c9270
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4681ef
movq -0x10(%rbp), %rax
movzbl 0x1c(%rax), %eax
cmpl $0x12, %eax
jne 0x4681aa
movq -0x8(%rbp), %rdi
callq 0x3c8b20
jmp 0x4681ed
movq -0x10(%rbp), %rax
movzbl 0x1c(%rax), %eax
cmpl $0x7, %eax
jne 0x4681c2
movq -0x8(%rbp), %rdi
callq 0x3c8b60
jmp 0x4681eb
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3490
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq -0xa79e6(%rip), %rcx    # 0x3c0800
callq 0x3c86c0
jmp 0x4681ed
jmp 0x4681ef
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3c9270
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x46827c
movq -0x10(%rbp), %rax
movzbl 0x1c(%rax), %eax
cmpl $0x12, %eax
jne 0x46823a
movq -0x8(%rbp), %rdi
callq 0x3c8b20
jmp 0x46827a
movq -0x10(%rbp), %rax
movzbl 0x1c(%rax), %eax
cmpl $0x7, %eax
jne 0x468252
movq -0x8(%rbp), %rdi
callq 0x3c8b60
jmp 0x468278
movq -0x10(%rbp), %rdi
callq 0x3c3560
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq $-0x1, %rcx
callq 0x3c86c0
jmp 0x46827a
jmp 0x46827c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c7cc0
cmpl $0x5, %eax
jne 0x4682b9
jmp 0x46836d
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x3c9270
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x46836d
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3c78a0
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x468300
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3c78a0
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x468309
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x468322
movq -0x28(%rbp), %rax
movl $0x0, 0x18(%rax)
jmp 0x468356
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rax
movl 0x18(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %edx
callq 0x19bf0
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x46836b
movq -0x28(%rbp), %rax
movl $0x0, 0x14(%rax)
jmp 0x46836d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)