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: vdbeRecordCompareString
static int vdbeRecordCompareString(
  int nKey1, const void *pKey1, /* Left key */
  UnpackedRecord *pPKey2        /* Right key */
){
  const u8 *aKey1 = (const u8*)pKey1;
  int serial_type;
  int res;

  assert( pPKey2->aMem[0].flags & MEM_Str );
  vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
  serial_type = (u8)(aKey1[1]);
  if( serial_type >= 0x80 ){
    sqlite3GetVarint32(&aKey1[1], (u32*)&serial_type);
  }
  if( serial_type<12 ){
    res = pPKey2->r1;      /* (pKey1/nKey1) is a number or a null */
  }else if( !(serial_type & 0x01) ){
    res = pPKey2->r2;      /* (pKey1/nKey1) is a blob */
  }else{
    int nCmp;
    int nStr;
    int szHdr = aKey1[0];

    nStr = (serial_type-12) / 2;
    if( (szHdr + nStr) > nKey1 ){
      pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
      return 0;    /* Corruption */
    }
    nCmp = MIN( pPKey2->aMem[0].n, nStr );
    res = memcmp(&aKey1[szHdr], pPKey2->aMem[0].z, nCmp);

    if( res>0 ){
      res = pPKey2->r2;
    }else if( res<0 ){
      res = pPKey2->r1;
    }else{
      res = nStr - pPKey2->aMem[0].n;
      if( res==0 ){
        if( pPKey2->nField>1 ){
          res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1);
        }else{
          res = pPKey2->default_rc;
          pPKey2->eqSeen = 1;
        }
      }else if( res>0 ){
        res = pPKey2->r2;
      }else{
        res = pPKey2->r1;
      }
    }
  }

  assert( vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, res)
       || CORRUPT_DB
       || pPKey2->pKeyInfo->db->mallocFailed
  );
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movzbl 0x1(%rsi), %eax
movl %eax, 0xc(%rsp)
testb %al, %al
jns 0x2a9753
leaq 0x1(%r14), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2a470c
movl 0xc(%rsp), %r15d
cmpl $0xb, %r15d
jg 0x2a9764
movsbl 0x14(%rbx), %ebp
jmp 0x2a97af
testb $0x1, %r15b
jne 0x2a9770
movsbl 0x15(%rbx), %ebp
jmp 0x2a97af
movzbl (%r14), %edi
addl $-0xc, %r15d
shrl %r15d
leal (%r15,%rdi), %eax
cmpl %ebp, %eax
jle 0x2a97be
leaq 0x135b95(%rip), %rsi    # 0x3df31f
leaq 0x135c9f(%rip), %rdx    # 0x3df430
leaq 0x1359ed(%rip), %r8     # 0x3df185
xorl %ebp, %ebp
movl $0xb, %edi
movl $0x14275, %ecx          # imm = 0x14275
xorl %eax, %eax
callq 0x27e637
movb $0xb, 0x13(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rax
movl 0xc(%rax), %r12d
cmpl %r15d, %r12d
movl %r15d, %ecx
cmovll %r12d, %ecx
addq %r14, %rdi
movq 0x10(%rax), %rsi
movslq %ecx, %rdx
callq 0x17300
testl %eax, %eax
jg 0x2a976a
js 0x2a975e
cmpl %r12d, %r15d
jne 0x2a9810
cmpw $0x2, 0x10(%rbx)
jb 0x2a981b
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x1, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a9825
jle 0x2a975e
jmp 0x2a976a
movsbl 0x12(%rbx), %ebp
movb $0x1, 0x16(%rbx)
jmp 0x2a97af
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: moveToLeftmost
static int moveToLeftmost(BtCursor *pCur){
  Pgno pgno;
  int rc = SQLITE_OK;
  MemPage *pPage;

  assert( cursorOwnsBtShared(pCur) );
  assert( pCur->eState==CURSOR_VALID );
  while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){
    assert( pCur->ix<pPage->nCell );
    pgno = get4byte(findCell(pPage, pCur->ix));
    rc = moveToChild(pCur, pgno);
  }
  return rc;
}

// Assembly:
pushq %rbx
movq 0x88(%rdi), %rcx
xorl %eax, %eax
cmpb $0x0, 0x8(%rcx)
jne 0x2aa0eb
movq %rdi, %rbx
movzwl 0x1a(%rcx), %eax
movq 0x50(%rcx), %rdx
movq 0x60(%rcx), %rcx
movzwl 0x56(%rbx), %esi
movzbl (%rcx,%rsi,2), %edi
shll $0x8, %edi
movzbl 0x1(%rcx,%rsi,2), %ecx
orl %edi, %ecx
andl %eax, %ecx
movl (%rdx,%rcx), %esi
bswapl %esi
movq %rbx, %rdi
callq 0x2a8b64
testl %eax, %eax
jne 0x2aa0eb
movq 0x88(%rbx), %rcx
cmpb $0x0, 0x8(%rcx)
je 0x2aa0ad
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: btreePrevious
static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){
  int rc;
  MemPage *pPage;

  assert( cursorOwnsBtShared(pCur) );
  assert( (pCur->curFlags & (BTCF_AtLast|BTCF_ValidOvfl|BTCF_ValidNKey))==0 );
  assert( pCur->info.nSize==0 );
  if( pCur->eState!=CURSOR_VALID ){
    rc = restoreCursorPosition(pCur);
    if( rc!=SQLITE_OK ){
      return rc;
    }
    if( CURSOR_INVALID==pCur->eState ){
      return SQLITE_DONE;
    }
    if( CURSOR_SKIPNEXT==pCur->eState ){
      pCur->eState = CURSOR_VALID;
      if( pCur->skipNext<0 ) return SQLITE_OK;
    }
  }

  pPage = pCur->pPage;
  assert( pPage->isInit );
  if( !pPage->leaf ){
    int idx = pCur->ix;
    rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
    if( rc ) return rc;
    rc = moveToRightmost(pCur);
  }else{
    while( pCur->ix==0 ){
      if( pCur->iPage==0 ){
        pCur->eState = CURSOR_INVALID;
        return SQLITE_DONE;
      }
      moveToParent(pCur);
    }
    assert( pCur->info.nSize==0 );
    assert( (pCur->curFlags & (BTCF_ValidOvfl))==0 );

    pCur->ix--;
    pPage = pCur->pPage;
    if( pPage->intKey && !pPage->leaf ){
      rc = sqlite3BtreePrevious(pCur, 0);
    }else{
      rc = SQLITE_OK;
    }
  }
  return rc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %cl
testb %cl, %cl
je 0x2aa12c
xorl %eax, %eax
cmpb $0x3, %cl
jb 0x2aa106
movq %rbx, %rdi
callq 0x2a87bf
testl %eax, %eax
jne 0x2aa1bb
movzbl (%rbx), %eax
cmpl $0x1, %eax
je 0x2aa1b6
cmpl $0x2, %eax
jne 0x2aa12c
movb $0x0, (%rbx)
cmpl $0x0, 0x4(%rbx)
js 0x2aa1bd
movq 0x88(%rbx), %rcx
cmpb $0x0, 0x8(%rcx)
movzwl 0x56(%rbx), %eax
je 0x2aa17a
testw %ax, %ax
jne 0x2aa156
cmpb $0x0, 0x54(%rbx)
je 0x2aa1b3
movq %rbx, %rdi
callq 0x2a8b24
movzwl 0x56(%rbx), %eax
jmp 0x2aa13d
decl %eax
movw %ax, 0x56(%rbx)
movq 0x88(%rbx), %rcx
xorl %eax, %eax
cmpb $0x0, 0x2(%rcx)
je 0x2aa1bb
cmpb $0x0, 0x8(%rcx)
jne 0x2aa1bb
movq %rbx, %rdi
popq %rbx
jmp 0x2a5a00
movzwl %ax, %eax
movzwl 0x1a(%rcx), %edx
movq 0x50(%rcx), %rsi
movq 0x60(%rcx), %rcx
movzbl (%rcx,%rax,2), %edi
shll $0x8, %edi
movzbl 0x1(%rcx,%rax,2), %eax
orl %edi, %eax
andl %edx, %eax
movl (%rsi,%rax), %esi
bswapl %esi
movq %rbx, %rdi
callq 0x2a8b64
testl %eax, %eax
jne 0x2aa1bb
movq %rbx, %rdi
popq %rbx
jmp 0x2a95f2
movb $0x1, (%rbx)
movl $0x65, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0x2aa1bb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: dropCell
static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){
  u32 pc;         /* Offset to cell content of cell being deleted */
  u8 *data;       /* pPage->aData */
  u8 *ptr;        /* Used to move bytes around within data[] */
  int rc;         /* The return code */
  int hdr;        /* Beginning of the header.  0 most pages.  100 page 1 */

  if( *pRC ) return;
  assert( idx>=0 && idx<pPage->nCell );
  assert( CORRUPT_DB || sz==cellSize(pPage, idx) );
  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
  assert( pPage->nFree>=0 );
  data = pPage->aData;
  ptr = &pPage->aCellIdx[2*idx];
  pc = get2byte(ptr);
  hdr = pPage->hdrOffset;
  testcase( pc==get2byte(&data[hdr+5]) );
  testcase( pc+sz==pPage->pBt->usableSize );
  if( pc+sz > pPage->pBt->usableSize ){
    *pRC = SQLITE_CORRUPT_BKPT;
    return;
  }
  rc = freeSpace(pPage, pc, sz);
  if( rc ){
    *pRC = rc;
    return;
  }
  pPage->nCell--;
  if( pPage->nCell==0 ){
    memset(&data[hdr+1], 0, 4);
    data[hdr+7] = 0;
    put2byte(&data[hdr+5], pPage->pBt->usableSize);
    pPage->nFree = pPage->pBt->usableSize - pPage->hdrOffset
                       - pPage->childPtrSize - 8;
  }else{
    memmove(ptr, ptr+2, 2*(pPage->nCell - idx));
    put2byte(&data[hdr+3], pPage->nCell);
    pPage->nFree += 2;
  }
}

// Assembly:
cmpl $0x0, (%rcx)
je 0x2aa498
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x60(%rdi), %rbp
movslq %esi, %r13
movzwl (%rbp,%r13,2), %ecx
rolw $0x8, %cx
movzwl %cx, %esi
leal (%rsi,%rdx), %ecx
cmpl 0x38(%rax), %ecx
jbe 0x2aa4fb
leaq 0x134e4f(%rip), %rsi    # 0x3df31f
leaq 0x134f59(%rip), %rdx    # 0x3df430
leaq 0x134ca7(%rip), %r8     # 0x3df185
movl $0xb, %edi
movl $0x115f2, %ecx          # imm = 0x115F2
xorl %eax, %eax
callq 0x27e637
movl $0xb, (%r14)
jmp 0x2aa59f
movq 0x50(%rbx), %r15
movzbl 0x9(%rbx), %r12d
movzwl %dx, %edx
movq %rbx, %rdi
callq 0x2ac5da
testl %eax, %eax
je 0x2aa51b
movl %eax, (%r14)
jmp 0x2aa59f
movzwl 0x18(%rbx), %eax
decw %ax
movw %ax, 0x18(%rbx)
je 0x2aa55d
leaq (,%r13,2), %rdi
addq %rbp, %rdi
movzwl %ax, %eax
leaq 0x2(%rdi), %rsi
subl %r13d, %eax
addl %eax, %eax
movslq %eax, %rdx
callq 0x17cd0
movb 0x19(%rbx), %al
movb %al, 0x3(%r15,%r12)
movb 0x18(%rbx), %al
movb %al, 0x4(%r15,%r12)
addl $0x2, 0x14(%rbx)
jmp 0x2aa59f
movl $0x0, 0x1(%r15,%r12)
movb $0x0, 0x7(%r15,%r12)
movq 0x48(%rbx), %rax
movb 0x39(%rax), %al
movb %al, 0x5(%r15,%r12)
movq 0x48(%rbx), %rax
movb 0x38(%rax), %al
movb %al, 0x6(%r15,%r12)
movq 0x48(%rbx), %rax
movl 0x38(%rax), %eax
movzbl 0x9(%rbx), %ecx
movzbl 0xa(%rbx), %edx
addl %ecx, %edx
negl %edx
addl %edx, %eax
addl $-0x8, %eax
movl %eax, 0x14(%rbx)
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: btreeOverwriteContent
static int btreeOverwriteContent(
  MemPage *pPage,           /* MemPage on which writing will occur */
  u8 *pDest,                /* Pointer to the place to start writing */
  const BtreePayload *pX,   /* Source of data to write */
  int iOffset,              /* Offset of first byte to write */
  int iAmt                  /* Number of bytes to be written */
){
  int nData = pX->nData - iOffset;
  if( nData<=0 ){
    /* Overwritting with zeros */
    int i;
    for(i=0; i<iAmt && pDest[i]==0; i++){}
    if( i<iAmt ){
      int rc = sqlite3PagerWrite(pPage->pDbPage);
      if( rc ) return rc;
      memset(pDest + i, 0, iAmt - i);
    }
  }else{
    if( nData<iAmt ){
      /* Mixed read data and zeros at the end.  Make a recursive call
      ** to write the zeros then fall through to write the real data */
      int rc = btreeOverwriteContent(pPage, pDest+nData, pX, iOffset+nData,
                                 iAmt-nData);
      if( rc ) return rc;
      iAmt = nData;
    }
    if( memcmp(pDest, ((u8*)pX->pData) + iOffset, iAmt)!=0 ){
      int rc = sqlite3PagerWrite(pPage->pDbPage);
      if( rc ) return rc;
      /* In a corrupt database, it is possible for the source and destination
      ** buffers to overlap.  This is harmless since the database is already
      ** corrupt but it does cause valgrind and ASAN warnings.  So use
      ** memmove(). */
      memmove(pDest, ((u8*)pX->pData) + iOffset, iAmt);
    }
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r13d
movq %rsi, %rbx
movl 0x24(%rdx), %ecx
movl %ecx, %r14d
subl %r13d, %r14d
jle 0x2ac529
movq %rdx, %r15
movl %ebp, %r8d
subl %r14d, %r8d
movq %rdi, 0x10(%rsp)
jle 0x2ac546
movl %r14d, %esi
addq %rbx, %rsi
movq %r15, %rdx
callq 0x2ac4d4
movl %eax, %r12d
movl %eax, 0xc(%rsp)
testl %eax, %eax
cmovel %r14d, %ebp
jne 0x2ac5c8
jmp 0x2ac546
movb $0x1, %r15b
testl %ebp, %ebp
jle 0x2ac544
movl %ebp, %eax
xorl %r14d, %r14d
cmpb $0x0, (%rbx,%r14)
jne 0x2ac598
incq %r14
cmpq %r14, %rax
jne 0x2ac535
jmp 0x2ac5c0
movslq %r13d, %r13
movq 0x10(%r15), %rsi
addq %r13, %rsi
movslq %ebp, %rbp
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x17830
testl %eax, %eax
je 0x2ac5c5
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x280e3a
movl %eax, %r14d
movl %eax, %r12d
testl %eax, %eax
jne 0x2ac591
addq 0x10(%r15), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x17cd0
movl 0xc(%rsp), %r12d
testl %r14d, %r14d
jne 0x2ac5c8
jmp 0x2ac5c5
movq 0x70(%rdi), %rdi
callq 0x280e3a
movl %eax, %r12d
testl %eax, %eax
je 0x2ac5ad
xorl %r15d, %r15d
jmp 0x2ac5c0
addq %r14, %rbx
movslq %ebp, %rdx
subq %r14, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x173a0
testb %r15b, %r15b
je 0x2ac5c8
xorl %r12d, %r12d
movl %r12d, %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: pageFreeArray
static int pageFreeArray(
  MemPage *pPg,                   /* Page to edit */
  int iFirst,                     /* First cell to delete */
  int nCell,                      /* Cells to delete */
  CellArray *pCArray              /* Array of cells */
){
  u8 * const aData = pPg->aData;
  u8 * const pEnd = &aData[pPg->pBt->usableSize];
  u8 * const pStart = &aData[pPg->hdrOffset + 8 + pPg->childPtrSize];
  int nRet = 0;
  int i;
  int iEnd = iFirst + nCell;
  u8 *pFree = 0;
  int szFree = 0;

  for(i=iFirst; i<iEnd; i++){
    u8 *pCell = pCArray->apCell[i];
    if( SQLITE_WITHIN(pCell, pStart, pEnd) ){
      int sz;
      /* No need to use cachedCellSize() here.  The sizes of all cells that
      ** are to be freed have already been computing while deciding which
      ** cells need freeing */
      sz = pCArray->szCell[i];  assert( sz>0 );
      if( pFree!=(pCell + sz) ){
        if( pFree ){
          assert( pFree>aData && (pFree - aData)<65536 );
          freeSpace(pPg, (u16)(pFree - aData), szFree);
        }
        pFree = pCell;
        szFree = sz;
        if( pFree+sz>pEnd ) return 0;
      }else{
        pFree = pCell;
        szFree += sz;
      }
      nRet++;
    }
  }
  if( pFree ){
    assert( pFree>aData && (pFree - aData)<65536 );
    freeSpace(pPg, (u16)(pFree - aData), szFree);
  }
  return nRet;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x50(%rdi), %r8
testl %edx, %edx
jle 0x2ad61c
movq 0x48(%rdi), %rax
movl 0x38(%rax), %r10d
addq %r8, %r10
movzbl 0x9(%rdi), %eax
movzbl 0xa(%rdi), %r9d
addq %r8, %rax
addq %rax, %r9
addq $0x8, %r9
addl %esi, %edx
movslq %esi, %r12
movslq %edx, %r11
xorl %r15d, %r15d
xorl %edx, %edx
xorl %esi, %esi
movq %r8, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r10, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq %r11, 0x8(%rsp)
movq 0x10(%rcx), %rax
movq (%rax,%r12,8), %rbx
movb $0x1, %r14b
cmpq %r9, %rbx
jb 0x2ad609
cmpq %r10, %rbx
jae 0x2ad609
movq 0x18(%rcx), %rax
movzwl (%rax,%r12,2), %r13d
movq %r13, %rbp
addq %rbx, %rbp
cmpq %rbp, %rsi
je 0x2ad5fa
testq %rsi, %rsi
je 0x2ad5f0
subl %r8d, %esi
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %edx
andl %eax, %esi
movq %r15, 0x30(%rsp)
movq %rdi, %r15
callq 0x2ac5da
movq 0x8(%rsp), %r11
movq 0x10(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq %r15, %rdi
movq 0x30(%rsp), %r15
cmpq %r10, %rbp
jbe 0x2ad600
xorl %r14d, %r14d
jmp 0x2ad603
addl %r13d, %edx
movl %edx, %r13d
incl %r15d
movq %rbx, %rsi
movl %r13d, %edx
testb %r14b, %r14b
je 0x2ad638
incq %r12
cmpq %r11, %r12
jl 0x2ad588
jmp 0x2ad623
xorl %esi, %esi
xorl %edx, %edx
xorl %r15d, %r15d
testq %rsi, %rsi
je 0x2ad63b
subl %r8d, %esi
movzwl %si, %esi
movzwl %dx, %edx
callq 0x2ac5da
jmp 0x2ad63b
xorl %r15d, %r15d
movl %r15d, %eax
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: vdbeSorterSort
static int vdbeSorterSort(SortSubtask *pTask, SorterList *pList){
  int i;
  SorterRecord *p;
  int rc;
  SorterRecord *aSlot[64];

  rc = vdbeSortAllocUnpacked(pTask);
  if( rc!=SQLITE_OK ) return rc;

  p = pList->pList;
  pTask->xCompare = vdbeSorterGetCompare(pTask->pSorter);
  memset(aSlot, 0, sizeof(aSlot));

  while( p ){
    SorterRecord *pNext;
    if( pList->aMemory ){
      if( (u8*)p==pList->aMemory ){
        pNext = 0;
      }else{
        assert( p->u.iNext<sqlite3MallocSize(pList->aMemory) );
        pNext = (SorterRecord*)&pList->aMemory[p->u.iNext];
      }
    }else{
      pNext = p->u.pNext;
    }

    p->u.pNext = 0;
    for(i=0; aSlot[i]; i++){
      p = vdbeSorterMerge(pTask, p, aSlot[i]);
      aSlot[i] = 0;
    }
    aSlot[i] = p;
    p = pNext;
  }

  p = 0;
  for(i=0; i<ArraySize(aSlot); i++){
    if( aSlot[i]==0 ) continue;
    p = p ? vdbeSorterMerge(pTask, p, aSlot[i]) : aSlot[i];
  }
  pList->pList = p;

  assert( pTask->pUnpacked->errCode==SQLITE_OK
       || pTask->pUnpacked->errCode==SQLITE_NOMEM
  );
  return pTask->pUnpacked->errCode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movb $0x1, %bpl
cmpq $0x0, 0x18(%rdi)
jne 0x2ad83c
movq 0x10(%rbx), %rax
movq 0x28(%rax), %rdi
callq 0x2a5a3a
movq %rax, %rcx
movq %rax, 0x18(%rbx)
xorl %eax, %eax
testq %rcx, %rcx
je 0x2ad835
movq 0x10(%rbx), %rdx
movq 0x28(%rdx), %rdx
movzwl 0x6(%rdx), %edx
movw %dx, 0x10(%rcx)
movb $0x0, 0x13(%rcx)
jmp 0x2ad83c
movl $0x7, %eax
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x2ad922
movq (%r14), %r15
movq 0x10(%rbx), %rax
movb 0x5c(%rax), %al
cmpb $0x2, %al
leaq 0x432(%rip), %rcx       # 0x2adc8a
leaq 0x520(%rip), %rdx       # 0x2add7f
cmoveq %rcx, %rdx
cmpb $0x1, %al
leaq 0x31a(%rip), %rax       # 0x2adb86
cmovneq %rdx, %rax
movq %rax, 0x40(%rbx)
movq %rsp, %r12
movl $0x200, %edx            # imm = 0x200
movq %r12, %rdi
xorl %esi, %esi
callq 0x173a0
testq %r15, %r15
je 0x2ad8eb
movq 0x8(%r14), %r13
testq %r13, %r13
je 0x2ad8a2
cmpq %r13, %r15
je 0x2ad8a8
movslq 0x8(%r15), %rax
addq %rax, %r13
jmp 0x2ad8ab
movq 0x8(%r15), %r13
jmp 0x2ad8ab
xorl %r13d, %r13d
movq $0x0, 0x8(%r15)
movq (%rsp), %rdx
movq %r12, %rbp
testq %rdx, %rdx
je 0x2ad8df
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2adace
movq %rax, %r15
movq $0x0, (%rbp)
movq 0x8(%rbp), %rdx
addq $0x8, %rbp
jmp 0x2ad8ba
movq %r15, (%rbp)
movq %r13, %r15
testq %r13, %r13
jne 0x2ad88b
xorl %r15d, %r15d
xorl %eax, %eax
movq (%rsp,%r15,8), %rdx
testq %rdx, %rdx
je 0x2ad90e
testq %rax, %rax
je 0x2ad90b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2adace
jmp 0x2ad90e
movq %rdx, %rax
incq %r15
cmpq $0x40, %r15
jne 0x2ad8f0
movq %rax, (%r14)
movq 0x18(%rbx), %rax
movzbl 0x13(%rax), %eax
addq $0x208, %rsp            # imm = 0x208
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: vdbeSorterMerge
static SorterRecord *vdbeSorterMerge(
  SortSubtask *pTask,             /* Calling thread context */
  SorterRecord *p1,               /* First list to merge */
  SorterRecord *p2                /* Second list to merge */
){
  SorterRecord *pFinal = 0;
  SorterRecord **pp = &pFinal;
  int bCached = 0;

  assert( p1!=0 && p2!=0 );
  for(;;){
    int res;
    res = pTask->xCompare(
        pTask, &bCached, SRVAL(p1), p1->nVal, SRVAL(p2), p2->nVal
    );

    if( res<=0 ){
      *pp = p1;
      pp = &p1->u.pNext;
      p1 = p1->u.pNext;
      if( p1==0 ){
        *pp = p2;
        break;
      }
    }else{
      *pp = p2;
      pp = &p2->u.pNext;
      p2 = p2->u.pNext;
      bCached = 0;
      if( p2==0 ){
        *pp = p1;
        break;
      }
    }
  }
  return pFinal;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq $0x0, (%r13)
leaq 0x4(%rsp), %r12
movl $0x0, (%r12)
leaq 0x10(%r14), %rdx
movl (%r14), %ecx
leaq 0x10(%r15), %r8
movl (%r15), %r9d
movq %rbx, %rdi
movq %r12, %rsi
callq *0x40(%rbx)
testl %eax, %eax
jle 0x2adb3d
movq %r15, (%r13)
movq 0x8(%r15), %rax
addq $0x8, %r15
movl $0x0, 0x4(%rsp)
movb $0x1, %cl
testq %rax, %rax
jne 0x2adb69
movq %r14, (%r15)
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x2adb69
movq %r14, (%r13)
movq 0x8(%r14), %rdx
addq $0x8, %r14
movb $0x1, %cl
testq %rdx, %rdx
je 0x2adb5b
movq %r15, %rax
movq %r14, %r15
movq %rdx, %r14
jmp 0x2adb69
movq %r15, (%r14)
xorl %ecx, %ecx
movq %r15, %rax
movq %r14, %r15
xorl %r14d, %r14d
movq %r15, %r13
movq %rax, %r15
testb %cl, %cl
jne 0x2adafe
movq 0x8(%rsp), %rax
addq $0x10, %rsp
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: vdbeSorterCompareText
static int vdbeSorterCompareText(
  SortSubtask *pTask,             /* Subtask context (for pKeyInfo) */
  int *pbKey2Cached,              /* True if pTask->pUnpacked is pKey2 */
  const void *pKey1, int nKey1,   /* Left side of comparison */
  const void *pKey2, int nKey2    /* Right side of comparison */
){
  const u8 * const p1 = (const u8 * const)pKey1;
  const u8 * const p2 = (const u8 * const)pKey2;
  const u8 * const v1 = &p1[ p1[0] ];   /* Pointer to value 1 */
  const u8 * const v2 = &p2[ p2[0] ];   /* Pointer to value 2 */

  int n1;
  int n2;
  int res;

  getVarint32NR(&p1[1], n1);
  getVarint32NR(&p2[1], n2);
  res = memcmp(v1, v2, (MIN(n1, n2) - 13)/2);
  if( res==0 ){
    res = n1 - n2;
  }

  if( res==0 ){
    if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
      res = vdbeSorterCompareTail(
          pTask, pbKey2Cached, pKey1, nKey1, pKey2, nKey2
      );
    }
  }else{
    assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
    if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){
      res = res * -1;
    }
  }

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %r14
movl %ecx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movzbl (%rdx), %ebx
movzbl (%r8), %ebp
movzbl 0x1(%rdx), %eax
movl %eax, 0x4(%rsp)
testb %al, %al
jns 0x2adcd0
leaq 0x1(%r15), %rdi
leaq 0x4(%rsp), %rsi
callq 0x2a470c
addq %r15, %rbx
addq %r14, %rbp
movzbl 0x1(%r14), %eax
movl %eax, (%rsp)
testb %al, %al
jns 0x2adcee
leaq 0x1(%r14), %rdi
movq %rsp, %rsi
callq 0x2a470c
movl 0x4(%rsp), %eax
movl (%rsp), %ecx
movl %eax, %r12d
subl %ecx, %r12d
cmovll %eax, %ecx
movl %ecx, %eax
addl $-0xd, %eax
shrl $0x1f, %eax
addl %ecx, %eax
addl $-0xd, %eax
sarl %eax
movslq %eax, %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x17300
testl %eax, %eax
cmovnel %eax, %r12d
movq 0x10(%r13), %rax
movq 0x28(%rax), %rcx
testl %r12d, %r12d
je 0x2add40
movq 0x18(%rcx), %rcx
movl %r12d, %eax
negl %eax
cmpb $0x0, (%rcx)
cmovel %r12d, %eax
jmp 0x2add70
xorl %eax, %eax
cmpw $0x2, 0x6(%rcx)
jb 0x2add70
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r15, %rdx
movl 0x8(%rsp), %ecx
movq %r14, %r8
movl 0xc(%rsp), %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2addcd
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: vdbeSorterCompare
static int vdbeSorterCompare(
  SortSubtask *pTask,             /* Subtask context (for pKeyInfo) */
  int *pbKey2Cached,              /* True if pTask->pUnpacked is pKey2 */
  const void *pKey1, int nKey1,   /* Left side of comparison */
  const void *pKey2, int nKey2    /* Right side of comparison */
){
  UnpackedRecord *r2 = pTask->pUnpacked;
  if( !*pbKey2Cached ){
    sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
    *pbKey2Cached = 1;
  }
  return sqlite3VdbeRecordCompare(nKey1, pKey1, r2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq 0x18(%rdi), %r14
cmpl $0x0, (%rsi)
jne 0x2addb4
movq %rsi, %r15
movq 0x10(%rdi), %rax
movq 0x28(%rax), %rdi
movl %r9d, %esi
movq %r8, %rdx
movq %r14, %rcx
callq 0x2a5a82
movl $0x1, (%r15)
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a9825
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeSorterCompareTail
static int vdbeSorterCompareTail(
  SortSubtask *pTask,             /* Subtask context (for pKeyInfo) */
  int *pbKey2Cached,              /* True if pTask->pUnpacked is pKey2 */
  const void *pKey1, int nKey1,   /* Left side of comparison */
  const void *pKey2, int nKey2    /* Right side of comparison */
){
  UnpackedRecord *r2 = pTask->pUnpacked;
  if( *pbKey2Cached==0 ){
    sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
    *pbKey2Cached = 1;
  }
  return sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, r2, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq 0x18(%rdi), %r14
cmpl $0x0, (%rsi)
jne 0x2ade02
movq %rsi, %r15
movq 0x10(%rdi), %rax
movq 0x28(%rax), %rdi
movl %r9d, %esi
movq %r8, %rdx
movq %r14, %rcx
callq 0x2a5a82
movl $0x1, (%r15)
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a9825
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeSorterOpenTempFile
static int vdbeSorterOpenTempFile(
  sqlite3 *db,                    /* Database handle doing sort */
  i64 nExtend,                    /* Attempt to extend file to this size */
  sqlite3_file **ppFd
){
  int rc;
  if( sqlite3FaultSim(202) ) return SQLITE_IOERR_ACCESS;
  rc = sqlite3OsOpenMalloc(db->pVfs, 0, ppFd,
      SQLITE_OPEN_TEMP_JOURNAL |
      SQLITE_OPEN_READWRITE    | SQLITE_OPEN_CREATE |
      SQLITE_OPEN_EXCLUSIVE    | SQLITE_OPEN_DELETEONCLOSE, &rc
  );
  if( rc==SQLITE_OK ){
    i64 max = SQLITE_MAX_MMAP_SIZE;
    sqlite3OsFileControlHint(*ppFd, SQLITE_FCNTL_MMAP_SIZE, (void*)&max);
    if( nExtend>0 ){
      vdbeSorterExtendFile(db, *ppFd, nExtend);
    }
  }
  return rc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2189af(%rip), %rax    # 0x4c67e8
testq %rax, %rax
je 0x2ade50
movl $0xca, %edi
callq *%rax
movl %eax, %ecx
movl $0xd0a, %eax            # imm = 0xD0A
testl %ecx, %ecx
jne 0x2adeaa
movq (%r14), %rdi
leaq 0xc(%rsp), %r12
xorl %esi, %esi
movq %r15, %rdx
movl $0x101e, %ecx           # imm = 0x101E
movq %r12, %r8
callq 0x29b113
movl %eax, (%r12)
testl %eax, %eax
jne 0x2adea6
movq $0x7fff0000, 0x10(%rsp) # imm = 0x7FFF0000
movq (%r15), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x2ade93
leaq 0x10(%rsp), %rdx
movl $0x12, %esi
callq *0x50(%rax)
testq %rbx, %rbx
jle 0x2adea6
movq (%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2adeb6
movl 0xc(%rsp), %eax
addq $0x18, %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: vdbeSorterExtendFile
static void vdbeSorterExtendFile(sqlite3 *db, sqlite3_file *pFd, i64 nByte){
  if( nByte<=(i64)(db->nMaxSorterMmap) && pFd->pMethods->iVersion>=3 ){
    void *p = 0;
    int chunksize = 4*1024;
    sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_CHUNK_SIZE, &chunksize);
    sqlite3OsFileControlHint(pFd, SQLITE_FCNTL_SIZE_HINT, &nByte);
    sqlite3OsFetch(pFd, 0, (int)nByte, &p);
    sqlite3OsUnfetch(pFd, 0, p);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
movslq 0xac(%rdi), %rax
cmpq %rdx, %rax
jl 0x2adf37
movq %rsi, %rbx
movq (%rsi), %rax
cmpl $0x3, (%rax)
jl 0x2adf37
movq $0x0, 0x8(%rsp)
leaq 0x14(%rsp), %rdx
movl $0x1000, (%rdx)         # imm = 0x1000
movq %rbx, %rdi
movl $0x6, %esi
callq *0x50(%rax)
movq (%rbx), %rax
testq %rax, %rax
je 0x2adf0d
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq *0x50(%rax)
movl (%rsp), %edx
movq (%rbx), %rax
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq *0x88(%rax)
movq (%r14), %rdx
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x90(%rax)
addq $0x18, %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: vdbePmaWriteBlob
static void vdbePmaWriteBlob(PmaWriter *p, u8 *pData, int nData){
  int nRem = nData;
  while( nRem>0 && p->eFWErr==0 ){
    int nCopy = nRem;
    if( nCopy>(p->nBuffer - p->iBufEnd) ){
      nCopy = p->nBuffer - p->iBufEnd;
    }

    memcpy(&p->aBuffer[p->iBufEnd], &pData[nData-nRem], nCopy);
    p->iBufEnd += nCopy;
    if( p->iBufEnd==p->nBuffer ){
      p->eFWErr = sqlite3OsWrite(p->pFd,
          &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart,
          p->iWriteOff + p->iBufStart
      );
      p->iBufStart = p->iBufEnd = 0;
      p->iWriteOff += p->nBuffer;
    }
    assert( p->iBufEnd<p->nBuffer );

    nRem -= nCopy;
  }
}

// Assembly:
testl %edx, %edx
jle 0x2adfe0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %ebp
cmpl $0x0, (%r15)
jne 0x2adfd2
movl 0x10(%r15), %r13d
movslq 0x18(%r15), %rdi
subl %edi, %r13d
cmpl %r13d, %ebp
cmovll %ebp, %r13d
addq 0x8(%r15), %rdi
movl %ebx, %eax
subl %ebp, %eax
movslq %eax, %rsi
addq %r14, %rsi
movslq %r13d, %r12
movq %r12, %rdx
callq 0x17660
addl 0x18(%r15), %r12d
movl %r12d, 0x18(%r15)
cmpl 0x10(%r15), %r12d
jne 0x2adfcd
movq 0x28(%r15), %rdi
movslq 0x14(%r15), %rcx
movq 0x8(%r15), %rsi
addq %rcx, %rsi
subl %ecx, %r12d
addq 0x20(%r15), %rcx
movq (%rdi), %rax
movl %r12d, %edx
callq *0x18(%rax)
movl %eax, (%r15)
movq $0x0, 0x14(%r15)
movslq 0x10(%r15), %rax
addq %rax, 0x20(%r15)
subl %r13d, %ebp
jg 0x2adf5c
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: vdbePmaWriterFinish
static int vdbePmaWriterFinish(PmaWriter *p, i64 *piEof){
  int rc;
  if( p->eFWErr==0 && ALWAYS(p->aBuffer) && p->iBufEnd>p->iBufStart ){
    p->eFWErr = sqlite3OsWrite(p->pFd,
        &p->aBuffer[p->iBufStart], p->iBufEnd - p->iBufStart,
        p->iWriteOff + p->iBufStart
    );
  }
  *piEof = (p->iWriteOff + p->iBufEnd);
  sqlite3_free(p->aBuffer);
  rc = p->eFWErr;
  memset(p, 0, sizeof(PmaWriter));
  return rc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x2ae01c
movslq 0x18(%rbx), %rax
addq 0x20(%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rdi
callq 0x27c490
movl (%rbx), %eax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2adff0
movl 0x18(%rbx), %edx
movslq 0x14(%rbx), %rcx
cmpl %ecx, %edx
jle 0x2adff0
movq 0x28(%rbx), %rdi
addq %rcx, %rsi
subl %ecx, %edx
addq 0x20(%rbx), %rcx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, (%rbx)
jmp 0x2adff0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeMergeEngineLevel0
static int vdbeMergeEngineLevel0(
  SortSubtask *pTask,             /* Sorter task to read from */
  int nPMA,                       /* Number of PMAs to read */
  i64 *piOffset,                  /* IN/OUT: Readr offset in pTask->file */
  MergeEngine **ppOut             /* OUT: New merge-engine */
){
  MergeEngine *pNew;              /* Merge engine to return */
  i64 iOff = *piOffset;
  int i;
  int rc = SQLITE_OK;

  *ppOut = pNew = vdbeMergeEngineNew(nPMA);
  if( pNew==0 ) rc = SQLITE_NOMEM_BKPT;

  for(i=0; i<nPMA && rc==SQLITE_OK; i++){
    i64 nDummy = 0;
    PmaReader *pReadr = &pNew->aReadr[i];
    rc = vdbePmaReaderInit(pTask, &pTask->file, iOff, pReadr, &nDummy);
    iOff = pReadr->iEof;
  }

  if( rc!=SQLITE_OK ){
    vdbeMergeEngineFree(pNew);
    *ppOut = 0;
  }
  *piOffset = iOff;
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movl %esi, %ebx
movq %rdi, %r15
movq %rdx, 0x18(%rsp)
movq (%rdx), %r13
movl %esi, %edi
callq 0x2ae324
movq %r14, 0x10(%rsp)
movq %rax, (%r14)
xorl %ecx, %ecx
movq %rax, (%rsp)
testq %rax, %rax
setne %al
movl $0x7, %r14d
cmovnel %ecx, %r14d
testl %ebx, %ebx
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2ae2f1
movq %r15, 0x30(%rsp)
leaq 0x48(%r15), %rax
movq %rax, 0x28(%rsp)
movl %ebx, %eax
movq %rax, 0x20(%rsp)
movl $0x1, %r15d
xorl %r12d, %r12d
movq (%rsp), %rax
movq 0x18(%rax), %rbp
leaq (%r12,%rbp), %rbx
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
movq 0x28(%rsp), %rdx
movq %r13, %rcx
callq 0x2ae3b3
movl %eax, %r14d
testl %eax, %eax
jne 0x2ae2c3
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x2ae4fc
movl %eax, %r14d
movq 0x8(%rsp), %rax
addq (%rbp,%r12), %rax
movq %rax, 0x8(%rbp,%r12)
testl %r14d, %r14d
jne 0x2ae2d3
movq %rbx, %rdi
callq 0x2ae5a6
movl %eax, %r14d
movq 0x8(%rbp,%r12), %r13
testl %r14d, %r14d
sete %al
cmpq 0x20(%rsp), %r15
jae 0x2ae2f1
addq $0x50, %r12
incq %r15
testl %r14d, %r14d
je 0x2ae273
testb %al, %al
jne 0x2ae30a
movq (%rsp), %rdi
callq 0x29af28
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
movq %r13, (%rax)
movl %r14d, %eax
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: vdbeMergeEngineNew
static MergeEngine *vdbeMergeEngineNew(int nReader){
  int N = 2;                      /* Smallest power of two >= nReader */
  int nByte;                      /* Total bytes of space to allocate */
  MergeEngine *pNew;              /* Pointer to allocated object to return */

  assert( nReader<=SORTER_MAX_MERGE_COUNT );

  while( N<nReader ) N += N;
  nByte = sizeof(MergeEngine) + N * (sizeof(int) + sizeof(PmaReader));

  pNew = sqlite3FaultSim(100) ? 0 : (MergeEngine*)sqlite3MallocZero(nByte);
  if( pNew ){
    pNew->nTree = N;
    pNew->pTask = 0;
    pNew->aReadr = (PmaReader*)&pNew[1];
    pNew->aTree = (int*)&pNew->aReadr[N];
  }
  return pNew;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x2, %eax
movl %eax, %r15d
leal (%r15,%r15), %eax
cmpl %edi, %r15d
jl 0x2ae32e
movq 0x2184a7(%rip), %rax    # 0x4c67e8
testq %rax, %rax
je 0x2ae355
movl $0x64, %edi
callq *%rax
testl %eax, %eax
je 0x2ae355
xorl %ebx, %ebx
jmp 0x2ae37c
imull $0x54, %r15d, %eax
addl $0x20, %eax
movslq %eax, %r14
movq %r14, %rdi
callq 0x27c381
movq %rax, %rbx
testq %rax, %rax
je 0x2ae37c
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x173a0
testq %rbx, %rbx
je 0x2ae3aa
movslq %r15d, %rax
movl %r15d, (%rbx)
movq $0x0, 0x8(%rbx)
leaq 0x20(%rbx), %rcx
movq %rcx, 0x18(%rbx)
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rbx, %rax
addq $0x20, %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbePmaReaderSeek
static int vdbePmaReaderSeek(
  SortSubtask *pTask,             /* Task context */
  PmaReader *pReadr,              /* Reader whose cursor is to be moved */
  SorterFile *pFile,              /* Sorter file to read from */
  i64 iOff                        /* Offset in pFile */
){
  int rc = SQLITE_OK;

  assert( pReadr->pIncr==0 || pReadr->pIncr->bEof==0 );

  if( sqlite3FaultSim(201) ) return SQLITE_IOERR_READ;
  if( pReadr->aMap ){
    sqlite3OsUnfetch(pReadr->pFd, 0, pReadr->aMap);
    pReadr->aMap = 0;
  }
  pReadr->iReadOff = iOff;
  pReadr->iEof = pFile->iEof;
  pReadr->pFd = pFile->pFd;

  rc = vdbeSorterMapFile(pTask, pFile, &pReadr->aMap);
  if( rc==SQLITE_OK && pReadr->aMap==0 ){
    int pgsz = pTask->pSorter->pgsz;
    int iBuf = pReadr->iReadOff % pgsz;
    if( pReadr->aBuffer==0 ){
      pReadr->aBuffer = (u8*)sqlite3Malloc(pgsz);
      if( pReadr->aBuffer==0 ) rc = SQLITE_NOMEM_BKPT;
      pReadr->nBuffer = pgsz;
    }
    if( rc==SQLITE_OK && iBuf ){
      int nRead = pgsz - iBuf;
      if( (pReadr->iReadOff + nRead) > pReadr->iEof ){
        nRead = (int)(pReadr->iEof - pReadr->iReadOff);
      }
      rc = sqlite3OsRead(
          pReadr->pFd, &pReadr->aBuffer[iBuf], nRead, pReadr->iReadOff
      );
      testcase( rc!=SQLITE_OK );
    }
  }

  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x218417(%rip), %rax    # 0x4c67e8
testq %rax, %rax
je 0x2ae3ec
movl $0xc9, %edi
callq *%rax
movl %eax, %ecx
movl $0x10a, %eax            # imm = 0x10A
testl %ecx, %ecx
jne 0x2ae4ed
movq 0x40(%rbx), %rdx
testq %rdx, %rdx
je 0x2ae40c
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x90(%rax)
movq $0x0, 0x40(%rbx)
leaq 0x40(%rbx), %r15
movq %r13, (%rbx)
movq 0x8(%r12), %rdx
movq %rdx, 0x8(%rbx)
movq (%r12), %rdi
movq %rdi, 0x18(%rbx)
movq 0x10(%r14), %rax
movq 0x20(%rax), %rax
movslq 0xac(%rax), %rcx
xorl %eax, %eax
cmpq %rcx, %rdx
jg 0x2ae44f
movq (%rdi), %r8
cmpl $0x3, (%r8)
jl 0x2ae44f
xorl %esi, %esi
movq %r15, %rcx
callq *0x88(%r8)
testl %eax, %eax
jne 0x2ae4ed
xorl %eax, %eax
cmpq $0x0, (%r15)
jne 0x2ae4ed
movq 0x10(%r14), %rax
movl 0xc(%rax), %ebp
movq (%rbx), %rax
movslq %ebp, %r15
cqto
idivq %r15
movq %rdx, %r14
xorl %eax, %eax
cmpq $0x0, 0x30(%rbx)
jne 0x2ae49e
movq %r15, %rdi
callq 0x27c381
movq %rax, 0x30(%rbx)
xorl %ecx, %ecx
testq %rax, %rax
movl $0x7, %eax
cmovnel %ecx, %eax
movl %r15d, 0x38(%rbx)
testl %eax, %eax
sete %cl
testq %r14, %r14
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x2ae4ed
subl %r14d, %ebp
movslq %ebp, %rdx
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
leaq (%rcx,%rdx), %rsi
movl %eax, %edi
subl %ecx, %edi
cmpq %rax, %rsi
cmovgl %edi, %edx
movq 0x18(%rbx), %rdi
movq 0x30(%rbx), %rsi
addq %r14, %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%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: vdbePmaReadVarint
static int vdbePmaReadVarint(PmaReader *p, u64 *pnOut){
  int iBuf;

  if( p->aMap ){
    p->iReadOff += sqlite3GetVarint(&p->aMap[p->iReadOff], pnOut);
  }else{
    iBuf = p->iReadOff % p->nBuffer;
    if( iBuf && (p->nBuffer-iBuf)>=9 ){
      p->iReadOff += sqlite3GetVarint(&p->aBuffer[iBuf], pnOut);
    }else{
      u8 aVarint[16], *a;
      int i = 0, rc;
      do{
        rc = vdbePmaReadBlob(p, 1, &a);
        if( rc ) return rc;
        aVarint[(i++)&0xf] = a[0];
      }while( (a[0]&0x80)!=0 );
      sqlite3GetVarint(aVarint, pnOut);
    }
  }

  return SQLITE_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x2ae51e
addq %rax, %rdi
jmp 0x2ae543
movslq 0x38(%rbx), %rcx
cqto
idivq %rcx
testq %rdx, %rdx
setne %al
subl %edx, %ecx
cmpl $0x9, %ecx
setge %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2ae55f
addq 0x30(%rbx), %rdx
movq %rdx, %rdi
movq %r14, %rsi
callq 0x295365
movzbl %al, %eax
addq %rax, (%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x2ae7f4
testl %eax, %eax
jne 0x2ae553
movq 0x8(%rsp), %rax
movb (%rax), %al
leal 0x1(%r12), %ecx
andl $0xf, %r12d
movb %al, 0x10(%rsp,%r12)
movl %ecx, %r12d
testb %al, %al
js 0x2ae567
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x295365
jmp 0x2ae551
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vdbeIncrMergerNew
static int vdbeIncrMergerNew(
  SortSubtask *pTask,     /* The thread that will be using the new IncrMerger */
  MergeEngine *pMerger,   /* The MergeEngine that the IncrMerger will control */
  IncrMerger **ppOut      /* Write the new IncrMerger here */
){
  int rc = SQLITE_OK;
  IncrMerger *pIncr = *ppOut = (IncrMerger*)
       (sqlite3FaultSim(100) ? 0 : sqlite3MallocZero(sizeof(*pIncr)));
  if( pIncr ){
    pIncr->pMerger = pMerger;
    pIncr->pTask = pTask;
    pIncr->mxSz = MAX(pTask->pSorter->mxKeysize+9,pTask->pSorter->mxPmaSize/2);
    pTask->file2.iEof += pIncr->mxSz;
  }else{
    vdbeMergeEngineFree(pMerger);
    rc = SQLITE_NOMEM_BKPT;
  }
  return rc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x217cc5(%rip), %rax    # 0x4c67e8
testq %rax, %rax
je 0x2aeb37
movl $0x64, %edi
callq *%rax
testl %eax, %eax
je 0x2aeb37
xorl %eax, %eax
jmp 0x2aeb60
movl $0x48, %edi
callq 0x27c381
testq %rax, %rax
je 0x2aeb60
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x40(%rax)
movq %rax, (%r15)
testq %rax, %rax
je 0x2aeb98
movq %r14, 0x8(%rax)
movq %rbx, (%rax)
movq 0x10(%rbx), %rcx
movl 0x4(%rcx), %edx
movl 0x8(%rcx), %ecx
addl $0x9, %ecx
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
cmpl %esi, %ecx
cmovgl %ecx, %esi
movl %esi, 0x18(%rax)
movslq %esi, %rax
addq %rax, 0x60(%rbx)
xorl %eax, %eax
jmp 0x2aeba5
movq %r14, %rdi
callq 0x29af28
movl $0x7, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3FindCollSeq
SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(
  sqlite3 *db,          /* Database connection to search */
  u8 enc,               /* Desired text encoding */
  const char *zName,    /* Name of the collating sequence.  Might be NULL */
  int create            /* True to create CollSeq if doesn't already exist */
){
  CollSeq *pColl;
  assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
  assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE );
  if( zName ){
    pColl = findCollSeqEntry(db, zName, create);
    if( pColl ) pColl += enc-1;
  }else{
    pColl = db->pDfltColl;
  }
  return pColl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rdx, %rdx
je 0x2aed81
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
leaq 0x238(%r14), %r12
movq %r12, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x2aefdf
movq 0x10(%rax), %r13
testq %r13, %r13
setne %al
testl %ebp, %ebp
sete %cl
orb %al, %cl
jne 0x2aed68
movq %r15, %rdi
callq 0x172f0
movq %rax, %rbp
andl $0x3fffffff, %ebp       # imm = 0x3FFFFFFF
leaq 0x79(%rbp), %rsi
movq %r14, %rdi
callq 0x283569
testq %rax, %rax
je 0x2aed65
movq %rax, %r13
incq %rbp
movl %ebx, 0x4(%rsp)
movq %rax, %rbx
addq $0x78, %rbx
movq %rbx, (%rax)
movb $0x1, 0x8(%rax)
movq %rbx, 0x28(%rax)
movb $0x2, 0x30(%rax)
movq %rbx, 0x50(%rax)
movb $0x3, 0x58(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x17660
movq %r12, %rdi
movq %rbx, %rsi
movl 0x4(%rsp), %ebx
movq %r13, %rdx
callq 0x2aed98
testq %rax, %rax
je 0x2aed68
movq %rax, %r15
movq %r14, %rdi
callq 0x2824bb
movq %r14, %rdi
movq %r15, %rsi
callq 0x28c3e7
xorl %r13d, %r13d
testq %r13, %r13
je 0x2aed87
movzbl %bl, %eax
leaq (%rax,%rax,4), %rax
leaq -0x28(,%rax,8), %rax
addq %r13, %rax
jmp 0x2aed89
movq 0x10(%r14), %rax
jmp 0x2aed89
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: findElementWithHash
static HashElem *findElementWithHash(
  const Hash *pH,     /* The pH to be searched */
  const char *pKey,   /* The key we are searching for */
  unsigned int *pHash /* Write the hash value here */
){
  HashElem *elem;                /* Used to loop thru the element list */
  unsigned int count;            /* Number of elements left to test */
  unsigned int h;                /* The computed hash */
  static HashElem nullElement = { 0, 0, 0, 0 };

  if( pH->ht ){   /*OPTIMIZATION-IF-TRUE*/
    struct _ht *pEntry;
    h = strHash(pKey) % pH->htsize;
    pEntry = &pH->ht[h];
    elem = pEntry->chain;
    count = pEntry->count;
  }else{
    h = 0;
    elem = pH->first;
    count = pH->count;
  }
  if( pHash ) *pHash = h;
  while( count-- ){
    assert( elem!=0 );
    if( sqlite3StrICmp(elem->pKey,pKey)==0 ){
      return elem;
    }
    elem = elem->next;
  }
  return &nullElement;
}

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq 0x10(%rdi), %r8
testq %r8, %r8
je 0x2af021
movb (%rsi), %r10b
testb %r10b, %r10b
je 0x2af029
leaq 0x1(%rsi), %rdx
xorl %eax, %eax
leaq 0x12ba5f(%rip), %r9     # 0x3daa60
movzbl %r10b, %r10d
movzbl (%r10,%r9), %r10d
addl %eax, %r10d
imull $0x9e3779b1, %r10d, %eax # imm = 0x9E3779B1
movb (%rdx), %r10b
incq %rdx
testb %r10b, %r10b
jne 0x2af001
jmp 0x2af02b
leaq 0x4(%rdi), %r8
xorl %edx, %edx
jmp 0x2af03c
xorl %eax, %eax
xorl %edx, %edx
divl (%rdi)
movq %rdx, %rax
shlq $0x4, %rax
addq %rax, %r8
movq %r8, %rdi
movl (%r8), %r8d
movq 0x8(%rdi), %rdi
testq %rcx, %rcx
je 0x2af04a
movl %edx, (%rcx)
leaq 0x21ae17(%rip), %rax    # 0x4c9e68
testl %r8d, %r8d
je 0x2af09e
leaq 0x12ba03(%rip), %rcx    # 0x3daa60
decl %r8d
movq 0x18(%rdi), %rdx
xorl %r9d, %r9d
movzbl (%rdx,%r9), %r10d
movzbl (%rsi,%r9), %r11d
cmpb %r11b, %r10b
jne 0x2af07d
testq %r10, %r10
jne 0x2af087
jmp 0x2af08c
movb (%r10,%rcx), %bl
cmpb (%r11,%rcx), %bl
jne 0x2af08c
incq %r9
jmp 0x2af067
cmpb %r11b, %r10b
je 0x2af09b
movq (%rdi), %rdi
testl %r8d, %r8d
jne 0x2af05d
jmp 0x2af09e
movq %rdi, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: corruptSchema
static void corruptSchema(
  InitData *pData,     /* Initialization context */
  const char *zObj,    /* Object being parsed at the point of error */
  const char *zExtra   /* Error information */
){
  sqlite3 *db = pData->db;
  if( db->mallocFailed ){
    pData->rc = SQLITE_NOMEM_BKPT;
  }else if( pData->pzErrMsg[0]!=0 ){
    /* A error message has already been generated.  Do not overwrite it */
  }else if( pData->mInitFlags & INITFLAG_AlterTable ){
    *pData->pzErrMsg = sqlite3DbStrDup(db, zExtra);
    pData->rc = SQLITE_ERROR;
  }else if( db->flags & SQLITE_WriteSchema ){
    pData->rc = SQLITE_CORRUPT_BKPT;
  }else{
    char *z;
    if( zObj==0 ) zObj = "?";
    z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj);
    if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra);
    *pData->pzErrMsg = z;
    pData->rc = SQLITE_CORRUPT_BKPT;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movl $0x7, %ebp
cmpb $0x0, 0x61(%r15)
je 0x2af128
movl %ebp, 0x14(%rbx)
jmp 0x2af132
movq 0x8(%rbx), %rax
cmpq $0x0, (%rax)
je 0x2af13d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
testb $0x1, 0x18(%rbx)
jne 0x2af1bf
testb $0x1, 0x30(%r15)
jne 0x2af1db
testq %rsi, %rsi
leaq 0xd0c74(%rip), %rdx     # 0x37fdcf
cmovneq %rsi, %rdx
leaq 0x130cfa(%rip), %rsi    # 0x3dfe60
movq %r15, %rdi
xorl %eax, %eax
callq 0x284f95
testq %r14, %r14
je 0x2af192
cmpb $0x0, (%r14)
je 0x2af192
leaq 0x130cfd(%rip), %rsi    # 0x3dfe7f
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x284f95
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
leaq 0x13017f(%rip), %rsi    # 0x3df31f
leaq 0x130289(%rip), %rdx    # 0x3df430
leaq 0x12ffd7(%rip), %r8     # 0x3df185
movl $0xb, %ebp
movl $0xb, %edi
movl $0x1f57e, %ecx          # imm = 0x1F57E
jmp 0x2af1ff
movq %r15, %rdi
movq %r14, %rsi
callq 0x283365
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movl $0x1, %ebp
jmp 0x2af123
leaq 0x13013d(%rip), %rsi    # 0x3df31f
leaq 0x130247(%rip), %rdx    # 0x3df430
leaq 0x12ff95(%rip), %r8     # 0x3df185
movl $0xb, %ebp
movl $0xb, %edi
movl $0x1f577, %ecx          # imm = 0x1F577
xorl %eax, %eax
callq 0x27e637
jmp 0x2af123
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3GetUInt32
SQLITE_PRIVATE int sqlite3GetUInt32(const char *z, u32 *pI){
  u64 v = 0;
  int i;
  for(i=0; sqlite3Isdigit(z[i]); i++){
    v = v*10 + z[i] - '0';
    if( v>4294967296LL ){ *pI = 0; return 0; }
  }
  if( i==0 || z[i]!=0 ){ *pI = 0; return 0; }
  *pI = (u32)v;
  return 1;
}

// Assembly:
movzbl (%rdi), %edx
movq %rdx, %rax
addq $-0x30, %rax
xorl %ecx, %ecx
cmpq $0x9, %rax
ja 0x2af25a
incq %rdi
xorl %r9d, %r9d
movabsq $0x100000000, %r10      # imm = 0x100000000
xorl %r8d, %r8d
leaq (%r8,%r8,4), %r8
movsbq %dl, %rdx
leaq (%rdx,%r8,2), %r8
addq $-0x30, %r8
cmpq %r10, %r8
ja 0x2af277
movzbl (%rdi), %edx
movq %rdx, %r11
addq $-0x3a, %r11
incq %rdi
cmpq $-0xb, %r11
ja 0x2af230
jmp 0x2af25d
xorl %r8d, %r8d
cmpq $0xa, %rax
setb %al
testb %dl, %dl
sete %dl
andb %al, %dl
cmovnel %r8d, %ecx
movzbl %dl, %eax
movl %ecx, %r9d
jmp 0x2af279
xorl %eax, %eax
movl %r9d, (%rsi)
retq