LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: resolveAsName
static int resolveAsName(
  Parse *pParse,     /* Parsing context for error messages */
  ExprList *pEList,  /* List of expressions to scan */
  Expr *pE           /* Expression we are trying to match */
){
  int i;             /* Loop counter */

  UNUSED_PARAMETER(pParse);

  if( pE->op==TK_ID ){
    char *zCol = pE->u.zToken;
    for(i=0; i<pEList->nExpr; i++){
      if( pEList->a[i].eEName==ENAME_NAME
       && sqlite3_stricmp(pEList->a[i].zEName, zCol)==0
      ){
        return i+1;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbx
cmpb $0x3b, (%rsi)
jne 0x2d2e55
movslq (%rdi), %rdx
testq %rdx, %rdx
setg %cl
jle 0x2d2e50
movq 0x8(%rsi), %rsi
addq $0x8, %rdi
xorl %eax, %eax
leaq 0x107c6c(%rip), %r8     # 0x3daa60
leaq (%rax,%rax,2), %r9
testb $0x3, 0x11(%rdi,%r9,8)
je 0x2d2e0d
incq %rax
cmpq %rdx, %rax
setb %cl
jne 0x2d2df4
jmp 0x2d2e50
leaq (%rdi,%r9,8), %r9
movq 0x8(%r9), %r9
testq %r9, %r9
je 0x2d2e47
testq %rsi, %rsi
je 0x2d2e00
xorl %r10d, %r10d
movzbl (%r9,%r10), %r11d
movzbl (%rsi,%r10), %ebx
cmpb %bl, %r11b
jne 0x2d2e38
testq %r11, %r11
jne 0x2d2e42
jmp 0x2d2e4c
movb (%r11,%r8), %r11b
cmpb (%rbx,%r8), %r11b
jne 0x2d2e00
incq %r10
jmp 0x2d2e22
testq %rsi, %rsi
jne 0x2d2e00
incl %eax
jmp 0x2d2e50
testb $0x1, %cl
jne 0x2d2e57
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: resolveRemoveWindowsCb
static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
  UNUSED_PARAMETER(pWalker);
  if( ExprHasProperty(pExpr, EP_WinFunc) ){
    Window *pWin = pExpr->y.pWin;
    sqlite3WindowUnlinkFromSelect(pWin);
  }
  return WRC_Continue;
}

// Assembly:
testb $0x1, 0x7(%rsi)
je 0x2d2fba
movq 0x40(%rsi), %rax
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x2d2fba
movq 0x40(%rax), %rdx
movq %rdx, (%rcx)
movq 0x40(%rax), %rcx
testq %rcx, %rcx
je 0x2d2fb2
movq 0x38(%rax), %rdx
movq %rdx, 0x38(%rcx)
movq $0x0, 0x38(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3Dequote
SQLITE_PRIVATE void sqlite3Dequote(char *z){
  char quote;
  int i, j;
  if( z==0 ) return;
  quote = z[0];
  if( !sqlite3Isquote(quote) ) return;
  if( quote=='[' ) quote = ']';
  for(i=1, j=0;; i++){
    assert( z[i] );
    if( z[i]==quote ){
      if( z[i+1]==quote ){
        z[j++] = quote;
        i++;
      }else{
        break;
      }
    }else{
      z[j++] = z[i];
    }
  }
  z[j] = 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2d30dc
movzbl (%rdi), %eax
leaq 0x107aea(%rip), %rcx    # 0x3dabc0
cmpb $0x0, (%rax,%rcx)
js 0x2d30dd
retq
cmpb $0x5b, %al
movzbl %al, %ecx
movl $0x5d, %eax
cmovnel %ecx, %eax
movl $0x1, %edx
xorl %ecx, %ecx
movslq %edx, %rsi
movb (%rdi,%rsi), %r8b
cmpb %al, %r8b
jne 0x2d310b
cmpb %al, 0x1(%rdi,%rsi)
jne 0x2d3116
incq %rsi
movl %eax, %r8d
movl %esi, %edx
movb %r8b, (%rdi,%rcx)
incq %rcx
incl %edx
jmp 0x2d30f1
movl %ecx, %eax
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DbSpanDup
SQLITE_PRIVATE char *sqlite3DbSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){
  int n;
  while( sqlite3Isspace(zStart[0]) ) zStart++;
  n = (int)(zEnd - zStart);
  while( ALWAYS(n>0) && sqlite3Isspace(zStart[n-1]) ) n--;
  return sqlite3DbStrNDup(db, zStart, n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subl %esi, %edx
leaq 0x107a95(%rip), %rax    # 0x3dabc0
movq %rsi, %rbx
movl %edx, %r8d
movzbl (%rsi), %ecx
incq %rsi
leal -0x1(%r8), %edx
testb $0x1, (%rcx,%rax)
jne 0x2d312b
movl %r8d, %ecx
movslq %r8d, %rdx
movq %rdx, %r14
testl %ecx, %ecx
jle 0x2d3162
movzbl -0x2(%rsi,%rcx), %r8d
decq %rcx
leaq -0x1(%r14), %rdx
testb $0x1, (%r8,%rax)
jne 0x2d3147
leaq 0x1(%r14), %rsi
callq 0x28c518
movq %rax, %r15
testq %rax, %rax
je 0x2d3186
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x17660
movb $0x0, (%r15,%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RenameExprUnmap
SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){
  u8 eMode = pParse->eParseMode;
  Walker sWalker;
  memset(&sWalker, 0, sizeof(Walker));
  sWalker.pParse = pParse;
  sWalker.xExprCallback = renameUnmapExprCb;
  sWalker.xSelectCallback = renameUnmapSelectCb;
  pParse->eParseMode = PARSE_MODE_UNMAP;
  sqlite3WalkExpr(&sWalker, pExpr);
  pParse->eParseMode = eMode;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movb 0x11c(%rdi), %bpl
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %rdi, (%rsp)
leaq 0x33(%rip), %rax        # 0x2d31ee
movq %rax, 0x8(%rsp)
leaq 0x4b(%rip), %rax        # 0x2d3212
movq %rax, 0x10(%rsp)
movb $0x3, 0x11c(%rdi)
testq %rsi, %rsi
je 0x2d31e0
movq %rsp, %rdi
callq 0x2ca211
movb %bpl, 0x11c(%rbx)
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameUnmapSelectCb
static int renameUnmapSelectCb(Walker *pWalker, Select *p){
  Parse *pParse = pWalker->pParse;
  int i;
  if( pParse->nErr ) return WRC_Abort;
  if( NEVER(p->selFlags & SF_View) ) return WRC_Prune;
  if( ALWAYS(p->pEList) ){
    ExprList *pList = p->pEList;
    for(i=0; i<pList->nExpr; i++){
      if( pList->a[i].zEName && pList->a[i].eEName==ENAME_NAME ){
        sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zEName);
      }
    }
  }
  if( ALWAYS(p->pSrc) ){  /* Every Select as a SrcList, even if it is empty */
    SrcList *pSrc = p->pSrc;
    for(i=0; i<pSrc->nSrc; i++){
      sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
      if( sqlite3WalkExpr(pWalker, pSrc->a[i].pOn) ) return WRC_Abort;
      unmapColumnIdlistNames(pParse, pSrc->a[i].pUsing);
    }
  }

  renameWalkWith(pWalker, p);
  return WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
cmpl $0x0, 0x30(%r15)
je 0x2d3231
movl $0x2, %eax
jmp 0x2d3372
movl $0x1, %eax
testb $0x20, 0x6(%rsi)
jne 0x2d3372
movq %rdi, %r14
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x2d329c
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x2d329c
addq $0x8, %rax
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rdi
movq 0x8(%rax,%rdi,8), %r8
testq %r8, %r8
je 0x2d3272
leaq (%rax,%rdi,8), %rdi
testb $0x3, 0x11(%rdi)
je 0x2d327c
incq %rdx
cmpq %rcx, %rdx
jne 0x2d325a
jmp 0x2d329c
movq 0x1a0(%r15), %rdi
testq %rdi, %rdi
je 0x2d3272
cmpq %r8, (%rdi)
je 0x2d3293
movq 0x18(%rdi), %rdi
jmp 0x2d3283
movq $0x0, (%rdi)
jmp 0x2d3272
movq %rsi, (%rsp)
movq 0x28(%rsi), %r12
testq %r12, %r12
je 0x2d3364
cmpl $0x0, (%r12)
jle 0x2d3364
leaq 0x8(%r12), %r13
xorl %ebp, %ebp
imulq $0x70, %rbp, %rbx
movq 0x1a0(%r15), %rax
testq %rax, %rax
je 0x2d32eb
movq 0x10(%r13,%rbx), %rcx
cmpq %rcx, (%rax)
je 0x2d32e4
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x2d32d4
jmp 0x2d32eb
movq $0x0, (%rax)
addq %r13, %rbx
movq 0x48(%rbx), %rsi
testq %rsi, %rsi
je 0x2d3307
movq %r14, %rdi
callq 0x2ca211
testl %eax, %eax
jne 0x2d3227
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
je 0x2d3354
movslq 0x8(%rcx), %rax
testq %rax, %rax
jle 0x2d3354
movq (%rcx), %rcx
xorl %edx, %edx
movq 0x1a0(%r15), %rsi
testq %rsi, %rsi
je 0x2d334c
movq %rdx, %rdi
shlq $0x4, %rdi
movq (%rcx,%rdi), %rdi
cmpq %rdi, (%rsi)
je 0x2d3345
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
jne 0x2d3335
jmp 0x2d334c
movq $0x0, (%rsi)
incq %rdx
cmpq %rax, %rdx
jne 0x2d331e
incq %rbp
movslq (%r12), %rax
cmpq %rax, %rbp
jl 0x2d32bf
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x2d3381
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: renameWalkWith
static void renameWalkWith(Walker *pWalker, Select *pSelect){
  With *pWith = pSelect->pWith;
  if( pWith ){
    int i;
    for(i=0; i<pWith->nCte; i++){
      Select *p = pWith->a[i].pSelect;
      NameContext sNC;
      memset(&sNC, 0, sizeof(sNC));
      sNC.pParse = pWalker->pParse;
      sqlite3SelectPrep(sNC.pParse, p, &sNC);
      sqlite3WalkSelect(pWalker, p);
      sqlite3RenameExprlistUnmap(pWalker->pParse, pWith->a[i].pCols);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x68(%rsi), %r12
testq %r12, %r12
je 0x2d3403
cmpl $0x0, (%r12)
jle 0x2d3403
movq %rdi, %rbx
leaq 0x20(%r12), %r13
xorl %ebp, %ebp
movq %rsp, %r14
movq (%r13), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x30(%rsp)
movq (%rbx), %rdi
movq %rdi, (%rsp)
movq %r15, %rsi
movq %r14, %rdx
callq 0x2d0563
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2ca2ea
movq (%rbx), %rdi
movq -0x8(%r13), %rsi
callq 0x2d3412
incq %rbp
movslq (%r12), %rax
addq $0x20, %r13
cmpq %rax, %rbp
jl 0x2d33ac
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3RenameExprlistUnmap
SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse *pParse, ExprList *pEList){
  if( pEList ){
    int i;
    Walker sWalker;
    memset(&sWalker, 0, sizeof(Walker));
    sWalker.pParse = pParse;
    sWalker.xExprCallback = renameUnmapExprCb;
    sqlite3WalkExprList(&sWalker, pEList);
    for(i=0; i<pEList->nExpr; i++){
      if( ALWAYS(pEList->a[i].eEName==ENAME_NAME) ){
        sqlite3RenameTokenRemap(pParse, 0, (void*)pEList->a[i].zEName);
      }
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0x2d34a3
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movq %r14, (%rdi)
leaq -0x255(%rip), %rax      # 0x2d31ee
movq %rax, 0x8(%rdi)
callq 0x2ca44f
movslq (%rbx), %rax
testq %rax, %rax
jle 0x2d349c
addq $0x8, %rbx
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rsi
testb $0x3, 0x11(%rbx,%rsi,8)
je 0x2d346f
incq %rcx
cmpq %rax, %rcx
jne 0x2d345a
jmp 0x2d349c
movq 0x1a0(%r14), %rdx
testq %rdx, %rdx
je 0x2d3465
leaq (%rbx,%rsi,8), %rsi
movq 0x8(%rsi), %rsi
cmpq %rsi, (%rdx)
je 0x2d3493
movq 0x18(%rdx), %rdx
testq %rdx, %rdx
jne 0x2d3483
jmp 0x2d3465
movq $0x0, (%rdx)
jmp 0x2d3465
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3HasExplicitNulls
SQLITE_PRIVATE int sqlite3HasExplicitNulls(Parse *pParse, ExprList *pList){
  if( pList ){
    int i;
    for(i=0; i<pList->nExpr; i++){
      if( pList->a[i].bNulls ){
        u8 sf = pList->a[i].sortFlags;
        sqlite3ErrorMsg(pParse, "unsupported use of NULLS %s",
            (sf==0 || sf==3) ? "FIRST" : "LAST"
        );
        return 1;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbx
testq %rsi, %rsi
je 0x2d3520
movslq (%rsi), %rax
testq %rax, %rax
setg %bl
jle 0x2d3520
testb $0x20, 0x19(%rsi)
jne 0x2d34e8
addq $0x31, %rsi
leaq -0x1(%rax), %rdx
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x2d3520
leaq 0x18(%rsi), %r8
incq %rcx
testb $0x20, (%rsi)
movq %r8, %rsi
je 0x2d34c5
cmpq %rax, %rcx
setb %bl
addq $-0x29, %r8
movq %r8, %rsi
jmp 0x2d34ec
addq $0x8, %rsi
movb 0x10(%rsi), %al
cmpb $0x3, %al
leaq 0x10e484(%rip), %rcx    # 0x3e197c
leaq 0x860e8(%rip), %rdx     # 0x3595e7
cmoveq %rcx, %rdx
testb %al, %al
cmoveq %rcx, %rdx
leaq 0x10e450(%rip), %rsi    # 0x3e1960
xorl %eax, %eax
callq 0x284eb8
movl $0x1, %eax
testb %bl, %bl
jne 0x2d3522
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3SrcListLookup
SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
  struct SrcList_item *pItem = pSrc->a;
  Table *pTab;
  assert( pItem && pSrc->nSrc>=1 );
  pTab = sqlite3LocateTableItem(pParse, 0, pItem);
  sqlite3DeleteTable(pParse->db, pItem->pTab);
  pItem->pTab = pTab;
  if( pTab ){
    pTab->nTabRef++;
  }
  if( sqlite3IndexedByLookup(pParse, pItem) ){
    pTab = 0;
  }
  return pTab;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
leaq 0x8(%rsi), %r14
xorl %esi, %esi
movq %r14, %rdx
callq 0x2d1ce5
movq %rax, %rbx
movq (%r15), %rdi
movq 0x28(%r12), %rsi
callq 0x27bd74
movq %rbx, 0x28(%r12)
testq %rbx, %rbx
je 0x2d355d
incl 0x3c(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d1fff
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %rbx, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3FixSrcList
SQLITE_PRIVATE int sqlite3FixSrcList(
  DbFixer *pFix,       /* Context of the fixation */
  SrcList *pList       /* The Source list to check and modify */
){
  int i;
  struct SrcList_item *pItem;
  sqlite3 *db = pFix->pParse->db;
  int iDb = sqlite3FindDbName(db, pFix->zDb);

  if( NEVER(pList==0) ) return 0;

  for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
    if( pFix->bTemp==0 ){
      if( pItem->zDatabase && iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
        sqlite3ErrorMsg(pFix->pParse,
            "%s %T cannot reference objects in database %s",
            pFix->zType, pFix->pName, pItem->zDatabase);
        return 1;
      }
      sqlite3DbFree(db, pItem->zDatabase);
      pItem->zDatabase = 0;
      pItem->pSchema = pFix->pSchema;
      pItem->fg.fromDDL = 1;
    }
#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
    if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
    if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
#endif
    if( pItem->fg.isTabFunc && sqlite3FixExprList(pFix, pItem->u1.pFuncArg) ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x18(%rdi), %rsi
movq (%rax), %rdi
movq %rdi, 0x8(%rsp)
callq 0x289cd9
xorl %r15d, %r15d
testq %r14, %r14
je 0x2d36b6
cmpl $0x0, (%r14)
jle 0x2d36b6
movl %eax, 0x4(%rsp)
leaq 0x8(%r14), %r13
xorl %ebp, %ebp
movq %r14, 0x10(%rsp)
cmpb $0x0, 0x10(%rbx)
jne 0x2d3619
movq 0x8(%r13), %r12
testq %r12, %r12
je 0x2d3604
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x289cd9
cmpl %eax, 0x4(%rsp)
jne 0x2d3694
testq %r12, %r12
je 0x2d3604
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x28c3e7
movq $0x0, 0x8(%r13)
movq 0x8(%rbx), %rax
movq %rax, (%r13)
orb $0x40, 0x3d(%r13)
movq 0x28(%r13), %rsi
movq %rbx, %rdi
callq 0x2d3c19
movl $0x1, %r15d
testl %eax, %eax
jne 0x2d36b6
movq 0x48(%r13), %rsi
movq %rbx, %rdi
callq 0x2d3da4
testl %eax, %eax
jne 0x2d36b6
testb $0x4, 0x3d(%r13)
je 0x2d367b
movq 0x60(%r13), %r15
testq %r15, %r15
je 0x2d367b
cmpl $0x0, (%r15)
jle 0x2d367b
leaq 0x8(%r15), %r14
xorl %r12d, %r12d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2d3da4
testl %eax, %eax
jne 0x2d36b0
incl %r12d
addq $0x18, %r14
cmpl (%r15), %r12d
jl 0x2d3660
incl %ebp
addq $0x70, %r13
movq 0x10(%rsp), %r14
cmpl (%r14), %ebp
jl 0x2d35cc
xorl %r15d, %r15d
jmp 0x2d36b6
movq (%rbx), %rdi
movq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rcx
leaq 0x10e48f(%rip), %rsi    # 0x3e1b35
movq %r12, %r8
xorl %eax, %eax
callq 0x284eb8
movl $0x1, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3AllocateIndexObject
SQLITE_PRIVATE Index *sqlite3AllocateIndexObject(
  sqlite3 *db,         /* Database connection */
  i16 nCol,            /* Total number of columns in the index */
  int nExtra,          /* Number of bytes of extra space to alloc */
  char **ppExtra       /* Pointer to the "extra" space */
){
  Index *p;            /* Allocated index object */
  int nByte;           /* Bytes of space for Index object + arrays */

  nByte = ROUND8(sizeof(Index)) +              /* Index structure  */
          ROUND8(sizeof(char*)*nCol) +         /* Index.azColl     */
          ROUND8(sizeof(LogEst)*(nCol+1) +     /* Index.aiRowLogEst   */
                 sizeof(i16)*nCol +            /* Index.aiColumn   */
                 sizeof(u8)*nCol);             /* Index.aSortOrder */
  p = sqlite3DbMallocZero(db, nByte + nExtra);
  if( p ){
    char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
    p->azColl = (const char**)pExtra; pExtra += ROUND8(sizeof(char*)*nCol);
    p->aiRowLogEst = (LogEst*)pExtra; pExtra += sizeof(LogEst)*(nCol+1);
    p->aiColumn = (i16*)pExtra;       pExtra += sizeof(i16)*nCol;
    p->aSortOrder = (u8*)pExtra;
    p->nColumn = nCol;
    p->nKeyCol = nCol - 1;
    *ppExtra = ((char*)p) + nByte;
  }
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movslq %esi, %r14
leaq (%r14,%r14), %r12
leaq 0x2(,%r14,2), %r15
leal (%r14,%r12), %eax
addl %r15d, %eax
addl $0x7, %eax
andl $-0x8, %eax
leaq (%rax,%r14,8), %r13
addq $0x70, %r13
addl %r13d, %edx
movslq %edx, %rsi
callq 0x283569
testq %rax, %rax
je 0x2d3746
movq %r14, %rcx
shlq $0x3, %rcx
leaq 0x70(%rax), %rdx
movq %rdx, 0x40(%rax)
addq %rax, %rcx
addq $0x70, %rcx
movq %rcx, 0x10(%rax)
addq %rcx, %r15
movq %r15, 0x8(%rax)
addq %r12, %r15
movq %r15, 0x38(%rax)
movw %r14w, 0x60(%rax)
leal -0x1(%r14), %ecx
movw %cx, 0x5e(%rax)
movslq %r13d, %rcx
addq %rax, %rcx
movq %rcx, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3FixSelect
SQLITE_PRIVATE int sqlite3FixSelect(
  DbFixer *pFix,       /* Context of the fixation */
  Select *pSelect      /* The SELECT statement to be fixed to one database */
){
  while( pSelect ){
    if( sqlite3FixExprList(pFix, pSelect->pEList) ){
      return 1;
    }
    if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
      return 1;
    }
    if( sqlite3FixExprList(pFix, pSelect->pGroupBy) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
      return 1;
    }
    if( sqlite3FixExprList(pFix, pSelect->pOrderBy) ){
      return 1;
    }
    if( sqlite3FixExpr(pFix, pSelect->pLimit) ){
      return 1;
    }
    if( pSelect->pWith ){
      int i;
      for(i=0; i<pSelect->pWith->nCte; i++){
        if( sqlite3FixSelect(pFix, pSelect->pWith->a[i].pSelect) ){
          return 1;
        }
      }
    }
    pSelect = pSelect->pPrior;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x2d3d8a
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rbx), %r15
testq %r15, %r15
je 0x2d3c67
cmpl $0x0, (%r15)
jle 0x2d3c67
leaq 0x8(%r15), %r12
xorl %ebp, %ebp
movq (%r12), %rsi
movq %r14, %rdi
callq 0x2d3da4
testl %eax, %eax
jne 0x2d3d8e
incl %ebp
addq $0x18, %r12
cmpl (%r15), %ebp
jl 0x2d3c48
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x2d357f
movl $0x1, %ebp
testl %eax, %eax
jne 0x2d3d93
movq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x2d3da4
testl %eax, %eax
jne 0x2d3d93
movq 0x38(%rbx), %r15
testq %r15, %r15
je 0x2d3cca
cmpl $0x0, (%r15)
jle 0x2d3cca
leaq 0x8(%r15), %r12
xorl %r13d, %r13d
movq (%r12), %rsi
movq %r14, %rdi
callq 0x2d3da4
testl %eax, %eax
jne 0x2d3d93
incl %r13d
addq $0x18, %r12
cmpl (%r15), %r13d
jl 0x2d3caa
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x2d3da4
testl %eax, %eax
jne 0x2d3d93
movq 0x48(%rbx), %r15
testq %r15, %r15
je 0x2d3d14
cmpl $0x0, (%r15)
jle 0x2d3d14
leaq 0x8(%r15), %r12
xorl %r13d, %r13d
movq (%r12), %rsi
movq %r14, %rdi
callq 0x2d3da4
testl %eax, %eax
jne 0x2d3d93
incl %r13d
addq $0x18, %r12
cmpl (%r15), %r13d
jl 0x2d3cf4
movq 0x60(%rbx), %rsi
movq %r14, %rdi
callq 0x2d3da4
testl %eax, %eax
jne 0x2d3d93
cmpq $0x0, 0x68(%rbx)
je 0x2d3d7d
movq 0x68(%rbx), %rax
cmpl $0x0, (%rax)
setg %r15b
jle 0x2d3d7d
movq 0x20(%rax), %rsi
movq %r14, %rdi
callq 0x2d3c19
testl %eax, %eax
jne 0x2d3d78
movl $0x40, %r12d
xorl %r13d, %r13d
incq %r13
movq 0x68(%rbx), %rax
movslq (%rax), %rcx
cmpq %rcx, %r13
setl %r15b
jge 0x2d3d7d
movq (%rax,%r12), %rsi
addq $0x20, %r12
movq %r14, %rdi
callq 0x2d3c19
testl %eax, %eax
je 0x2d3d51
testb %r15b, %r15b
jne 0x2d3d93
movq 0x50(%rbx), %rbx
testq %rbx, %rbx
jne 0x2d3c33
xorl %ebp, %ebp
jmp 0x2d3d93
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3UniqueConstraint
SQLITE_PRIVATE void sqlite3UniqueConstraint(
  Parse *pParse,    /* Parsing context */
  int onError,      /* Constraint type */
  Index *pIdx       /* The index that triggers the constraint */
){
  char *zErr;
  int j;
  StrAccum errMsg;
  Table *pTab = pIdx->pTable;

  sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0,
                      pParse->db->aLimit[SQLITE_LIMIT_LENGTH]);
  if( pIdx->aColExpr ){
    sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
  }else{
    for(j=0; j<pIdx->nKeyCol; j++){
      char *zCol;
      assert( pIdx->aiColumn[j]>=0 );
      zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
      if( j ) sqlite3_str_append(&errMsg, ", ", 2);
      sqlite3_str_appendall(&errMsg, pTab->zName);
      sqlite3_str_append(&errMsg, ".", 1);
      sqlite3_str_appendall(&errMsg, zCol);
    }
  }
  zErr = sqlite3StrAccumFinish(&errMsg);
  sqlite3HaltConstraint(pParse,
    IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY
                            : SQLITE_CONSTRAINT_UNIQUE,
    onError, zErr, P4_DYNAMIC, P5_ConstraintUnique);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movl %esi, 0x2c(%rsp)
movq 0x18(%rdx), %rbp
movq %rdi, 0x30(%rsp)
movq (%rdi), %rax
movl 0x7c(%rax), %ecx
movq $0x0, 0x10(%rsp)
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, 0x18(%rsp)
movl %ecx, 0x1c(%rsp)
movl %eax, 0x20(%rsp)
movw $0x0, 0x24(%rsp)
cmpq $0x0, 0x50(%rdx)
je 0x2d415e
movq (%r15), %rdx
leaq 0x10da2e(%rip), %rsi    # 0x3e1b7b
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x27e729
jmp 0x2d4219
cmpw $0x0, 0x5e(%r15)
je 0x2d4219
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
leaq 0xf9755(%rip), %r13     # 0x3cd8ce
movq 0x8(%rbp), %rax
movq 0x8(%r15), %rcx
movswq (%rcx,%r14,2), %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rbx
testq %r14, %r14
je 0x2d41c5
movl 0x20(%rsp), %eax
leal 0x2(%rax), %ecx
cmpl 0x18(%rsp), %ecx
jae 0x2d41b1
movl %ecx, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movw $0x202c, (%rcx,%rax)    # imm = 0x202C
jmp 0x2d41c5
movq %r12, %rdi
leaq 0xda9e8(%rip), %rsi     # 0x3aeba3
movl $0x2, %edx
callq 0x27e2ca
movq (%rbp), %rsi
movq %r12, %rdi
callq 0x27e15a
movl 0x20(%rsp), %eax
leal 0x1(%rax), %ecx
cmpl 0x18(%rsp), %ecx
jae 0x2d41ed
movl %ecx, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movb $0x2e, (%rcx,%rax)
jmp 0x2d41fd
movq %r12, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x27e2ca
movq %r12, %rdi
movq %rbx, %rsi
callq 0x27e15a
incq %r14
movzwl 0x5e(%r15), %eax
cmpq %rax, %r14
jb 0x2d4179
leaq 0x8(%rsp), %rdi
callq 0x27e336
movzwl 0x63(%r15), %ecx
andl $0x3, %ecx
xorl %esi, %esi
cmpw $0x2, %cx
setne %sil
shll $0x9, %esi
addl $0x613, %esi            # imm = 0x613
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %edx
movq %rax, %rcx
movl $0xfffffff9, %r8d       # imm = 0xFFFFFFF9
movl $0x2, %r9d
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2c9791
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprIfFalseDup
SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){
  sqlite3 *db = pParse->db;
  Expr *pCopy = sqlite3ExprDup(db, pExpr, 0);
  if( db->mallocFailed==0 ){
    sqlite3ExprIfFalse(pParse, pCopy, dest, jumpIfNull);
  }
  sqlite3ExprDelete(db, pCopy);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %r14
movq (%rdi), %rbx
testq %rsi, %rsi
je 0x2d428e
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2cbf97
movq %rax, %r15
jmp 0x2d4291
xorl %r15d, %r15d
cmpb $0x0, 0x61(%rbx)
jne 0x2d42a9
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl $0x10, %ecx
callq 0x2c9460
testq %r15, %r15
je 0x2d42c3
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2afd54
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3IndexAffinityStr
SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){
  if( !pIdx->zColAff ){
    /* The first time a column affinity string for a particular index is
    ** required, it is allocated and populated here. It is then stored as
    ** a member of the Index structure for subsequent use.
    **
    ** The column affinity string will eventually be deleted by
    ** sqliteDeleteIndex() when the Index structure itself is cleaned
    ** up.
    */
    int n;
    Table *pTab = pIdx->pTable;
    pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
    if( !pIdx->zColAff ){
      sqlite3OomFault(db);
      return 0;
    }
    for(n=0; n<pIdx->nColumn; n++){
      i16 x = pIdx->aiColumn[n];
      char aff;
      if( x>=0 ){
        aff = pTab->aCol[x].affinity;
      }else if( x==XN_ROWID ){
        aff = SQLITE_AFF_INTEGER;
      }else{
        assert( x==XN_EXPR );
        assert( pIdx->aColExpr!=0 );
        aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
      }
      if( aff<SQLITE_AFF_BLOB ) aff = SQLITE_AFF_BLOB;
      if( aff>SQLITE_AFF_NUMERIC) aff = SQLITE_AFF_NUMERIC;
      pIdx->zColAff[n] = aff;
    }
    pIdx->zColAff[n] = 0;
  }

  return pIdx->zColAff;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, 0x20(%rsi)
jne 0x2d4394
movq %rdi, %r15
movq 0x18(%rbx), %r12
movzwl 0x60(%rbx), %edi
incq %rdi
callq 0x27c381
movq %rax, %r14
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x2d4379
cmpw $0x0, 0x60(%rbx)
je 0x2d4383
movl $0x4, %r13d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movswq (%rax,%r15,2), %rax
testq %rax, %rax
js 0x2d4331
movq 0x8(%r12), %rcx
shlq $0x5, %rax
movb 0x19(%rcx,%rax), %al
jmp 0x2d4348
cmpw $-0x1, %ax
je 0x2d4346
movq 0x50(%rbx), %rax
movq (%rax,%r13,2), %rdi
callq 0x2ca042
jmp 0x2d4348
movb $0x44, %al
cmpb $0x42, %al
jge 0x2d4353
movl $0x41, %eax
jmp 0x2d4356
movzbl %al, %eax
cmpb $0x43, %al
jl 0x2d435f
movl $0x43, %eax
movq 0x20(%rbx), %rcx
movb %al, (%rcx,%r15)
incq %r15
movzwl 0x60(%rbx), %eax
addq $0xc, %r13
cmpq %rax, %r15
jb 0x2d4314
jmp 0x2d4386
movq %r15, %rdi
callq 0x2824bb
jmp 0x2d438f
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movb $0x0, (%rax,%r15)
testq %r14, %r14
je 0x2d43a2
movq 0x20(%rbx), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x2d4398
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DropTriggerPtr
SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
  Table   *pTable;
  Vdbe *v;
  sqlite3 *db = pParse->db;
  int iDb;

  iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
  assert( iDb>=0 && iDb<db->nDb );
  pTable = tableOfTrigger(pTrigger);
  assert( (pTable && pTable->pSchema==pTrigger->pSchema) || iDb==1 );
#ifndef SQLITE_OMIT_AUTHORIZATION
  if( pTable ){
    int code = SQLITE_DROP_TRIGGER;
    const char *zDb = db->aDb[iDb].zDbSName;
    const char *zTab = SCHEMA_TABLE(iDb);
    if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
    if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
      sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
      return;
    }
  }
#endif

  /* Generate code to destroy the database record of the trigger.
  */
  if( (v = sqlite3GetVdbe(pParse))!=0 ){
    sqlite3NestedParse(pParse,
       "DELETE FROM %Q." DFLT_SCHEMA_TABLE " WHERE name=%Q AND type='trigger'",
       db->aDb[iDb].zDbSName, pTrigger->zName
    );
    sqlite3ChangeCookie(pParse, iDb);
    sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r12
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x2d4960
movq 0x20(%r12), %rcx
addq $0x18, %rcx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
incl %ebp
leaq 0x20(%rcx), %rdx
cmpq %rax, (%rcx)
movq %rdx, %rcx
jne 0x2d4950
jmp 0x2d4965
movl $0xffff8000, %ebp       # imm = 0xFFFF8000
movq 0x8(%rbx), %rsi
movq 0x30(%rbx), %rdi
addq $0x8, %rdi
xorl %edx, %edx
callq 0x2aefdf
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2d49eb
movq 0x20(%r12), %rcx
movslq %ebp, %rdx
movq %rdx, %rsi
shlq $0x5, %rsi
movq (%rcx,%rsi), %r15
xorl %ecx, %ecx
cmpl $0x1, %edx
setne %cl
leal 0xe(,%rcx,2), %esi
movq (%rbx), %rdx
movq (%rax), %rcx
movq %r14, %rdi
movq %r15, %r8
callq 0x2cceea
testl %eax, %eax
jne 0x2d4a74
cmpl $0x1, %ebp
leaq 0x10b39b(%rip), %rax    # 0x3dfd61
leaq 0x10b2b3(%rip), %rdx    # 0x3dfc80
cmoveq %rax, %rdx
movq %r14, %rdi
movl $0x9, %esi
xorl %ecx, %ecx
movq %r15, %r8
callq 0x2cceea
testl %eax, %eax
jne 0x2d4a74
movq %r14, %rdi
callq 0x2c5ddf
testq %rax, %rax
je 0x2d4a74
movq %rax, %r15
movq 0x20(%r12), %rax
movslq %ebp, %r12
shlq $0x5, %r12
movq (%rax,%r12), %rdx
movq (%rbx), %rcx
leaq 0x10d388(%rip), %rsi    # 0x3e1d9d
movq %r14, %rdi
xorl %eax, %eax
callq 0x2cdd65
movq (%r14), %rax
movq 0x10(%r14), %rdi
movq 0x20(%rax), %rax
movq 0x18(%rax,%r12), %rax
movl (%rax), %r8d
incl %r8d
movl $0x5e, %esi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x2b200c
movq (%rbx), %rbx
movq %r15, %rdi
movl $0x91, %esi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movq %r15, %rdi
movl %eax, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x285198
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: destroyRootPage
static void destroyRootPage(Parse *pParse, int iTable, int iDb){
  Vdbe *v = sqlite3GetVdbe(pParse);
  int r1 = sqlite3GetTempReg(pParse);
  if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
  sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
  sqlite3MayAbort(pParse);
#ifndef SQLITE_OMIT_AUTOVACUUM
  /* OP_Destroy stores an in integer r1. If this integer
  ** is non-zero, then it is the root page number of a table moved to
  ** location iTable. The following code modifies the sqlite_schema table to
  ** reflect this.
  **
  ** The "#NNN" in the SQL is a special constant that means whatever value
  ** is in register NNN.  See grammar rules associated with the TK_REGISTER
  ** token for additional information.
  */
  sqlite3NestedParse(pParse,
     "UPDATE %Q." DFLT_SCHEMA_TABLE
     " SET rootpage=%d WHERE #%d AND rootpage=#%d",
     pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
#endif
  sqlite3ReleaseTempReg(pParse, r1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
callq 0x2c5ddf
movq %rax, %r12
movb 0x1f(%rbx), %al
testb %al, %al
je 0x2d4aae
decb %al
movb %al, 0x1f(%rbx)
movzbl %al, %eax
movl 0xd4(%rbx,%rax,4), %ebp
jmp 0x2d4ab6
movl 0x38(%rbx), %ebp
incl %ebp
movl %ebp, 0x38(%rbx)
cmpl $0x1, %r14d
jg 0x2d4acd
leaq 0x10d318(%rip), %rsi    # 0x3e1ddb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x284eb8
movq %r12, %rdi
movl $0x88, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %r15d, %r8d
callq 0x2b200c
movq 0xa0(%rbx), %rax
testq %rax, %rax
cmoveq %rbx, %rax
movb $0x1, 0x21(%rax)
movq (%rbx), %rax
movq 0x20(%rax), %rax
movslq %r15d, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rdx
leaq 0x10d2dd(%rip), %rsi    # 0x3e1dea
movq %rbx, %rdi
movl %r14d, %ecx
movl %ebp, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x2cdd65
testl %ebp, %ebp
je 0x2d4b3b
movzbl 0x1f(%rbx), %eax
cmpq $0x7, %rax
ja 0x2d4b3b
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rbx)
movl %ebp, 0xd4(%rbx,%rax,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: unsetJoinExpr
static void unsetJoinExpr(Expr *p, int iTable){
  while( p ){
    if( ExprHasProperty(p, EP_FromJoin)
     && (iTable<0 || p->iRightJoinTable==iTable) ){
      ExprClearProperty(p, EP_FromJoin);
    }
    if( p->op==TK_FUNCTION && p->x.pList ){
      int i;
      for(i=0; i<p->x.pList->nExpr; i++){
        unsetJoinExpr(p->x.pList->a[i].pExpr, iTable);
      }
    }
    unsetJoinExpr(p->pLeft, iTable);
    p = p->pRight;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2d53b1
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x4(%r14), %eax
testb $0x1, %al
je 0x2d5355
testl %ebx, %ebx
js 0x2d534e
movswl 0x34(%r14), %ecx
cmpl %ebx, %ecx
jne 0x2d5355
andl $-0x2, %eax
movl %eax, 0x4(%r14)
cmpb $-0x57, (%r14)
jne 0x2d5392
cmpq $0x0, 0x20(%r14)
je 0x2d5392
movq 0x20(%r14), %rax
cmpl $0x0, (%rax)
jle 0x2d5392
movl $0x8, %r15d
xorl %r12d, %r12d
movq (%rax,%r15), %rdi
movl %ebx, %esi
callq 0x2d5323
incq %r12
movq 0x20(%r14), %rax
movslq (%rax), %rcx
addq $0x18, %r15
cmpq %rcx, %r12
jl 0x2d5374
movq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x2d5323
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x2d5339
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeExplainPop
SQLITE_PRIVATE int sqlite3VdbeExplainParent(Parse *pParse){
  VdbeOp *pOp;
  if( pParse->addrExplain==0 ) return 0;
  pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain);
  return pOp->p2;
}

// Assembly:
movl 0x128(%rdi), %ecx
testl %ecx, %ecx
je 0x2d72c0
movq 0x10(%rdi), %rax
jns 0x2d72ae
movl 0x90(%rax), %ecx
decl %ecx
movq (%rax), %rdx
cmpb $0x0, 0x61(%rdx)
je 0x2d72c4
leaq 0x1f2bca(%rip), %rcx    # 0x4c9e88
jmp 0x2d72d6
xorl %eax, %eax
jmp 0x2d72d9
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x88(%rax), %rcx
movl 0x8(%rcx), %eax
movl %eax, 0x128(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: propagateConstants
static int propagateConstants(
  Parse *pParse,   /* The parsing context */
  Select *p        /* The query in which to propagate constants */
){
  WhereConst x;
  Walker w;
  int nChng = 0;
  x.pParse = pParse;
  do{
    x.nConst = 0;
    x.nChng = 0;
    x.apExpr = 0;
    findConstInWhere(&x, p->pWhere);
    if( x.nConst ){
      memset(&w, 0, sizeof(w));
      w.pParse = pParse;
      w.xExprCallback = propagateConstantExprRewrite;
      w.xSelectCallback = sqlite3SelectWalkNoop;
      w.xSelectCallback2 = 0;
      w.walkerDepth = 0;
      w.u.pConst = &x;
      sqlite3WalkExpr(&w, p->pWhere);
      sqlite3DbFree(x.pParse->db, x.apExpr);
      nChng += x.nChng;
    }
  }while( x.nChng );
  return nChng;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r13
movq %rdi, -0x8(%r13)
xorl %ebp, %ebp
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %r15
leaq -0x45aa(%rip), %r12     # 0x2d2d64
movups %xmm0, (%r13)
movq 0x30(%rbx), %rsi
movq %r15, %rdi
callq 0x2dcee0
cmpl $0x0, 0x10(%rsp)
je 0x2d739a
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movq %r14, 0x20(%rsp)
leaq 0x5c9f(%rip), %rax      # 0x2dcfe3
movq %rax, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movl $0x0, 0x40(%rsp)
movq %r15, 0x48(%rsp)
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x2d737a
leaq 0x20(%rsp), %rdi
callq 0x2ca211
xorps %xmm0, %xmm0
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x2d7394
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x28c3e7
xorps %xmm0, %xmm0
addl 0x14(%rsp), %ebp
jmp 0x2d739d
xorps %xmm0, %xmm0
cmpl $0x0, 0x14(%rsp)
jne 0x2d730e
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: isSelfJoinView
static struct SrcList_item *isSelfJoinView(
  SrcList *pTabList,           /* Search for self-joins in this FROM clause */
  struct SrcList_item *pThis   /* Search for prior reference to this subquery */
){
  struct SrcList_item *pItem;
  for(pItem = pTabList->a; pItem<pThis; pItem++){
    Select *pS1;
    if( pItem->pSelect==0 ) continue;
    if( pItem->fg.viaCoroutine ) continue;
    if( pItem->zName==0 ) continue;
    assert( pItem->pTab!=0 );
    assert( pThis->pTab!=0 );
    if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue;
    if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
    pS1 = pItem->pSelect;
    if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){
      /* The query flattener left two different CTE tables with identical
      ** names in the same FROM clause. */
      continue;
    }
    if( sqlite3ExprCompare(0, pThis->pSelect->pWhere, pS1->pWhere, -1)
     || sqlite3ExprCompare(0, pThis->pSelect->pHaving, pS1->pHaving, -1)
    ){
      /* The view was modified by some other optimization such as
      ** pushDownWhereTerms() */
      continue;
    }
    return pItem;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
addq $0x8, %r15
cmpq %rsi, %r15
jae 0x2d7604
movq %rsi, %rbx
leaq 0x103525(%rip), %r12    # 0x3daa60
movq 0x28(%r15), %r13
movb $0x1, %bpl
testq %r13, %r13
je 0x2d7569
testb $0x10, 0x3d(%r15)
jne 0x2d7569
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x2d7569
movq 0x20(%r15), %rcx
movq 0x70(%rcx), %rcx
movq 0x20(%rbx), %rdx
cmpq 0x70(%rdx), %rcx
je 0x2d7580
testb %bpl, %bpl
je 0x2d7607
addq $0x70, %r15
cmpq %rbx, %r15
jb 0x2d753b
jmp 0x2d7604
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x2d7569
xorl %esi, %esi
movzbl (%rax,%rsi), %edi
movzbl (%rdx,%rsi), %r8d
cmpb %r8b, %dil
jne 0x2d75a0
testq %rdi, %rdi
jne 0x2d75aa
jmp 0x2d75af
movb (%rdi,%r12), %dil
cmpb (%r8,%r12), %dil
jne 0x2d7569
incq %rsi
jmp 0x2d758b
testq %rcx, %rcx
jne 0x2d75c1
movq 0x28(%rbx), %rax
movl 0x10(%rax), %eax
cmpl 0x10(%r13), %eax
jne 0x2d7569
movq 0x28(%rbx), %rax
movq 0x30(%rax), %rsi
movq 0x30(%r13), %rdx
xorl %edi, %edi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2ca527
testl %eax, %eax
jne 0x2d7569
movq 0x28(%rbx), %rax
movq 0x40(%rax), %rsi
movq 0x40(%r13), %rdx
xorl %edi, %edi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2ca527
testl %eax, %eax
setne %bpl
cmoveq %r15, %r14
jmp 0x2d7569
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3KeyInfoFromExprList
SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList(
  Parse *pParse,       /* Parsing context */
  ExprList *pList,     /* Form the KeyInfo object from this ExprList */
  int iStart,          /* Begin with this column of pList */
  int nExtra           /* Add this many extra columns to the end */
){
  int nExpr;
  KeyInfo *pInfo;
  struct ExprList_item *pItem;
  sqlite3 *db = pParse->db;
  int i;

  nExpr = pList->nExpr;
  pInfo = sqlite3KeyInfoAlloc(db, nExpr-iStart, nExtra+1);
  if( pInfo ){
    assert( sqlite3KeyInfoIsWriteable(pInfo) );
    for(i=iStart, pItem=pList->a+iStart; i<nExpr; i++, pItem++){
      pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
      pInfo->aSortFlags[i-iStart] = pItem->sortFlags;
    }
  }
  return pInfo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
movl (%rsi), %r14d
leal 0x1(%rcx), %edx
subl %ebp, %r14d
setle %r13b
movl %r14d, %esi
callq 0x2c6339
movq %rax, %r15
testq %rax, %rax
sete %al
orb %r13b, %al
jne 0x2d7699
movl %ebp, %eax
leaq (%rax,%rax,2), %rax
leaq (%r12,%rax,8), %r12
addq $0x8, %r12
xorl %r13d, %r13d
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x2b32a0
testq %rax, %rax
jne 0x2d767b
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%r15,%r13,8)
movb 0x10(%r12), %al
movq 0x18(%r15), %rcx
movb %al, (%rcx,%r13)
addq $0x18, %r12
incq %r13
cmpl %r13d, %r14d
jne 0x2d7663
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ExprAnalyzeAggregates
SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
  Walker w;
  w.xExprCallback = analyzeAggregate;
  w.xSelectCallback = sqlite3WalkerDepthIncrease;
  w.xSelectCallback2 = sqlite3WalkerDepthDecrease;
  w.walkerDepth = 0;
  w.u.pNC = pNC;
  w.pParse = 0;
  assert( pNC->pSrcList!=0 );
  sqlite3WalkExpr(&w, pExpr);
}

// Assembly:
subq $0x38, %rsp
leaq 0xe574(%rip), %rax      # 0x2e979a
movq %rax, 0x10(%rsp)
leaq 0xe59(%rip), %rax       # 0x2dc08b
movq %rax, 0x18(%rsp)
leaq 0xe53(%rip), %rax       # 0x2dc091
movq %rax, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq $0x0, 0x8(%rsp)
testq %rsi, %rsi
je 0x2db268
leaq 0x8(%rsp), %rdi
callq 0x2ca211
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: minMaxQuery
static u8 minMaxQuery(sqlite3 *db, Expr *pFunc, ExprList **ppMinMax){
  int eRet = WHERE_ORDERBY_NORMAL;      /* Return value */
  ExprList *pEList = pFunc->x.pList;    /* Arguments to agg function */
  const char *zFunc;                    /* Name of aggregate function pFunc */
  ExprList *pOrderBy;
  u8 sortFlags = 0;

  assert( *ppMinMax==0 );
  assert( pFunc->op==TK_AGG_FUNCTION );
  assert( !IsWindowFunc(pFunc) );
  if( pEList==0 || pEList->nExpr!=1 || ExprHasProperty(pFunc, EP_WinFunc) ){
    return eRet;
  }
  zFunc = pFunc->u.zToken;
  if( sqlite3StrICmp(zFunc, "min")==0 ){
    eRet = WHERE_ORDERBY_MIN;
    if( sqlite3ExprCanBeNull(pEList->a[0].pExpr) ){
      sortFlags = KEYINFO_ORDER_BIGNULL;
    }
  }else if( sqlite3StrICmp(zFunc, "max")==0 ){
    eRet = WHERE_ORDERBY_MAX;
    sortFlags = KEYINFO_ORDER_DESC;
  }else{
    return eRet;
  }
  *ppMinMax = pOrderBy = sqlite3ExprListDup(db, pEList, 0);
  assert( pOrderBy!=0 || db->mallocFailed );
  if( pOrderBy ) pOrderBy->a[0].sortFlags = sortFlags;
  return eRet;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x20(%rsi), %r14
testq %r14, %r14
je 0x2db343
cmpl $0x1, (%r14)
jne 0x2db343
testb $0x1, 0x7(%rsi)
jne 0x2db343
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rax
xorl %edx, %edx
leaq 0xbc379(%rip), %rsi     # 0x397622
leaq 0xff7b0(%rip), %rcx     # 0x3daa60
movzbl (%rax,%rdx), %edi
movzbl (%rdx,%rsi), %r8d
cmpb %r8b, %dil
jne 0x2db2c5
testq %rdi, %rdi
jne 0x2db2cf
jmp 0x2db2d4
movb (%rdi,%rcx), %r9b
cmpb (%r8,%rcx), %r9b
jne 0x2db2d4
incq %rdx
jmp 0x2db2b0
cmpb %r8b, %dil
jne 0x2db2f0
movq 0x8(%r14), %rdi
callq 0x2cbd61
testl %eax, %eax
setne %r12b
addb %r12b, %r12b
movb $0x1, %bpl
jmp 0x2db328
xorl %edx, %edx
leaq 0xf02da(%rip), %rsi     # 0x3cb5d3
movzbl (%rax,%rdx), %edi
movzbl (%rdx,%rsi), %r8d
cmpb %r8b, %dil
jne 0x2db30e
testq %rdi, %rdi
jne 0x2db318
jmp 0x2db31d
movb (%rdi,%rcx), %r9b
cmpb (%r8,%rcx), %r9b
jne 0x2db31d
incq %rdx
jmp 0x2db2f9
cmpb %r8b, %dil
jne 0x2db343
movb $0x1, %r12b
movb $0x2, %bpl
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2cc525
movq %rax, (%rbx)
testq %rax, %rax
je 0x2db345
movb %r12b, 0x18(%rax)
jmp 0x2db345
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: finalizeAggFunctions
static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
  Vdbe *v = pParse->pVdbe;
  int i;
  struct AggInfo_func *pF;
  for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
    ExprList *pList = pF->pFExpr->x.pList;
    assert( !ExprHasProperty(pF->pFExpr, EP_xIsSelect) );
    sqlite3VdbeAddOp2(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0);
    sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
  }
}

// Assembly:
cmpl $0x0, 0x38(%rsi)
jle 0x2db76d
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x30(%rsi), %r15
xorl %ebp, %ebp
movq (%r15), %rax
movq 0x20(%rax), %rax
movl $0x0, %ecx
testq %rax, %rax
je 0x2db70e
movl (%rax), %ecx
movl 0x10(%r15), %edx
movq %r14, %rdi
movl $0x9d, %esi
xorl %r8d, %r8d
callq 0x2b200c
movq 0x8(%r15), %rsi
movq (%r14), %rdi
cmpb $0x0, 0x61(%rdi)
je 0x2db73c
testb $0x10, 0x4(%rsi)
je 0x2db758
callq 0x28c3e7
jmp 0x2db758
movq 0x88(%r14), %rax
movslq 0x90(%r14), %rcx
leaq (%rcx,%rcx,2), %rcx
movb $-0x8, -0x17(%rax,%rcx,8)
movq %rsi, -0x8(%rax,%rcx,8)
incl %ebp
addq $0x18, %r15
cmpl 0x38(%rbx), %ebp
jl 0x2db6fb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: resetAccumulator
static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
  Vdbe *v = pParse->pVdbe;
  int i;
  struct AggInfo_func *pFunc;
  int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
  if( nReg==0 ) return;
  if( pParse->nErr || pParse->db->mallocFailed ) return;
#ifdef SQLITE_DEBUG
  /* Verify that all AggInfo registers are within the range specified by
  ** AggInfo.mnReg..AggInfo.mxReg */
  assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 );
  for(i=0; i<pAggInfo->nColumn; i++){
    assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg
         && pAggInfo->aCol[i].iMem<=pAggInfo->mxReg );
  }
  for(i=0; i<pAggInfo->nFunc; i++){
    assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg
         && pAggInfo->aFunc[i].iMem<=pAggInfo->mxReg );
  }
#endif
  sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->mnReg, pAggInfo->mxReg);
  for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
    if( pFunc->iDistinct>=0 ){
      Expr *pE = pFunc->pFExpr;
      assert( !ExprHasProperty(pE, EP_xIsSelect) );
      if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){
        sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
           "argument");
        pFunc->iDistinct = -1;
      }else{
        KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
        sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
                          (char*)pKeyInfo, P4_KEYINFO);
      }
    }
  }
}

// Assembly:
movl 0x38(%rsi), %eax
addl 0x28(%rsi), %eax
je 0x2db863
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x0, 0x30(%rdi)
jne 0x2db855
movq (%r14), %rax
cmpb $0x0, 0x61(%rax)
jne 0x2db855
movq %rsi, %rbx
movq 0x10(%r14), %rdi
movl 0x10(%rsi), %ecx
movl 0x14(%rsi), %r8d
movq %rdi, (%rsp)
movl $0x48, %esi
xorl %edx, %edx
callq 0x2b200c
cmpl $0x0, 0x38(%rbx)
jle 0x2db855
movq 0x30(%rbx), %rbp
addq $0x14, %rbp
leaq 0x106b58(%rip), %r15    # 0x3e232e
xorl %r12d, %r12d
cmpl $0x0, (%rbp)
js 0x2db848
movq -0x14(%rbp), %rax
movq 0x20(%rax), %rsi
testq %rsi, %rsi
je 0x2db834
cmpl $0x1, (%rsi)
jne 0x2db834
movq %r14, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2d7619
movq %rax, %r13
movl (%rbp), %edx
movq (%rsp), %r15
movq %r15, %rdi
movl $0x64, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2b200c
movq %r15, %rdi
movl %eax, %esi
movq %r13, %rdx
leaq 0x106b06(%rip), %r15    # 0x3e232e
movl $0xfffffff7, %ecx       # imm = 0xFFFFFFF7
callq 0x285198
jmp 0x2db848
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x284eb8
movl $0xffffffff, (%rbp)     # imm = 0xFFFFFFFF
incl %r12d
addq $0x18, %rbp
cmpl 0x38(%rbx), %r12d
jl 0x2db7d9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq