// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BtreeMovetoUnpacked
SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
  BtCursor *pCur,          /* The cursor to be moved */
  UnpackedRecord *pIdxKey, /* Unpacked index key */
  i64 intKey,              /* The table key */
  int biasRight,           /* If true, bias the search to the high end */
  int *pRes                /* Write search results here */
){
  int rc;
  RecordCompare xRecordCompare;

  assert( cursorOwnsBtShared(pCur) );
  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
  assert( pRes );
  assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
  assert( pCur->eState!=CURSOR_VALID || (pIdxKey==0)==(pCur->curIntKey!=0) );

  /* If the cursor is already positioned at the point we are trying
  ** to move to, then just return without doing any work */
  if( pIdxKey==0
   && pCur->eState==CURSOR_VALID && (pCur->curFlags & BTCF_ValidNKey)!=0
  ){
    if( pCur->info.nKey==intKey ){
      *pRes = 0;
      return SQLITE_OK;
    }
    if( pCur->info.nKey<intKey ){
      if( (pCur->curFlags & BTCF_AtLast)!=0 ){
        *pRes = -1;
        return SQLITE_OK;
      }
      /* If the requested key is one more than the previous key, then
      ** try to get there using sqlite3BtreeNext() rather than a full
      ** binary search.  This is an optimization only.  The correct answer
      ** is still obtained without this case, only a little more slowely */
      if( pCur->info.nKey+1==intKey ){
        *pRes = 0;
        rc = sqlite3BtreeNext(pCur, 0);
        if( rc==SQLITE_OK ){
          getCellInfo(pCur);
          if( pCur->info.nKey==intKey ){
            return SQLITE_OK;
          }
        }else if( rc==SQLITE_DONE ){
          rc = SQLITE_OK;
        }else{
          return rc;
        }
      }
    }
  }

  if( pIdxKey ){
    xRecordCompare = sqlite3VdbeFindCompare(pIdxKey);
    pIdxKey->errCode = 0;
    assert( pIdxKey->default_rc==1
         || pIdxKey->default_rc==0
         || pIdxKey->default_rc==-1
    );
  }else{
    xRecordCompare = 0; /* All keys are integers */
  }

  rc = moveToRoot(pCur);
  if( rc ){
    if( rc==SQLITE_EMPTY ){
      assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );
      *pRes = -1;
      return SQLITE_OK;
    }
    return rc;
  }
  assert( pCur->pPage );
  assert( pCur->pPage->isInit );
  assert( pCur->eState==CURSOR_VALID );
  assert( pCur->pPage->nCell > 0 );
  assert( pCur->iPage==0 || pCur->apPage[0]->intKey==pCur->curIntKey );
  assert( pCur->curIntKey || pIdxKey );
  for(;;){
    int lwr, upr, idx, c;
    Pgno chldPg;
    MemPage *pPage = pCur->pPage;
    u8 *pCell;                          /* Pointer to current cell in pPage */

    /* pPage->nCell must be greater than zero. If this is the root-page
    ** the cursor would have been INVALID above and this for(;;) loop
    ** not run. If this is not the root-page, then the moveToChild() routine
    ** would have already detected db corruption. Similarly, pPage must
    ** be the right kind (index or table) of b-tree page. Otherwise
    ** a moveToChild() or moveToRoot() call would have detected corruption.  */
    assert( pPage->nCell>0 );
    assert( pPage->intKey==(pIdxKey==0) );
    lwr = 0;
    upr = pPage->nCell-1;
    assert( biasRight==0 || biasRight==1 );
    idx = upr>>(1-biasRight); /* idx = biasRight ? upr : (lwr+upr)/2; */
    pCur->ix = (u16)idx;
    if( xRecordCompare==0 ){
      for(;;){
        i64 nCellKey;
        pCell = findCellPastPtr(pPage, idx);
        if( pPage->intKeyLeaf ){
          while( 0x80 <= *(pCell++) ){
            if( pCell>=pPage->aDataEnd ){
              return SQLITE_CORRUPT_PAGE(pPage);
            }
          }
        }
        getVarint(pCell, (u64*)&nCellKey);
        if( nCellKey<intKey ){
          lwr = idx+1;
          if( lwr>upr ){ c = -1; break; }
        }else if( nCellKey>intKey ){
          upr = idx-1;
          if( lwr>upr ){ c = +1; break; }
        }else{
          assert( nCellKey==intKey );
          pCur->ix = (u16)idx;
          if( !pPage->leaf ){
            lwr = idx;
            goto moveto_next_layer;
          }else{
            pCur->curFlags |= BTCF_ValidNKey;
            pCur->info.nKey = nCellKey;
            pCur->info.nSize = 0;
            *pRes = 0;
            return SQLITE_OK;
          }
        }
        assert( lwr+upr>=0 );
        idx = (lwr+upr)>>1;  /* idx = (lwr+upr)/2; */
      }
    }else{
      for(;;){
        int nCell;  /* Size of the pCell cell in bytes */
        pCell = findCellPastPtr(pPage, idx);

        /* The maximum supported page-size is 65536 bytes. This means that
        ** the maximum number of record bytes stored on an index B-Tree
        ** page is less than 16384 bytes and may be stored as a 2-byte
        ** varint. This information is used to attempt to avoid parsing
        ** the entire cell by checking for the cases where the record is
        ** stored entirely within the b-tree page by inspecting the first
        ** 2 bytes of the cell.
        */
        nCell = pCell[0];
        if( nCell<=pPage->max1bytePayload ){
          /* This branch runs if the record-size field of the cell is a
          ** single byte varint and the record fits entirely on the main
          ** b-tree page.  */
          testcase( pCell+nCell+1==pPage->aDataEnd );
          c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
        }else if( !(pCell[1] & 0x80)
          && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
        ){
          /* The record-size field is a 2 byte varint and the record
          ** fits entirely on the main b-tree page.  */
          testcase( pCell+nCell+2==pPage->aDataEnd );
          c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
        }else{
          /* The record flows over onto one or more overflow pages. In
          ** this case the whole cell needs to be parsed, a buffer allocated
          ** and accessPayload() used to retrieve the record into the
          ** buffer before VdbeRecordCompare() can be called.
          **
          ** If the record is corrupt, the xRecordCompare routine may read
          ** up to two varints past the end of the buffer. An extra 18
          ** bytes of padding is allocated at the end of the buffer in
          ** case this happens.  */
          void *pCellKey;
          u8 * const pCellBody = pCell - pPage->childPtrSize;
          const int nOverrun = 18;  /* Size of the overrun padding */
          pPage->xParseCell(pPage, pCellBody, &pCur->info);
          nCell = (int)pCur->info.nKey;
          testcase( nCell<0 );   /* True if key size is 2^32 or more */
          testcase( nCell==0 );  /* Invalid key size:  0x80 0x80 0x00 */
          testcase( nCell==1 );  /* Invalid key size:  0x80 0x80 0x01 */
          testcase( nCell==2 );  /* Minimum legal index key size */
          if( nCell<2 || nCell/pCur->pBt->usableSize>pCur->pBt->nPage ){
            rc = SQLITE_CORRUPT_PAGE(pPage);
            goto moveto_finish;
          }
          pCellKey = sqlite3Malloc( nCell+nOverrun );
          if( pCellKey==0 ){
            rc = SQLITE_NOMEM_BKPT;
            goto moveto_finish;
          }
          pCur->ix = (u16)idx;
          rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
          memset(((u8*)pCellKey)+nCell,0,nOverrun); /* Fix uninit warnings */
          pCur->curFlags &= ~BTCF_ValidOvfl;
          if( rc ){
            sqlite3_free(pCellKey);
            goto moveto_finish;
          }
          c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey);
          sqlite3_free(pCellKey);
        }
        assert(
            (pIdxKey->errCode!=SQLITE_CORRUPT || c==0)
         && (pIdxKey->errCode!=SQLITE_NOMEM || pCur->pBtree->db->mallocFailed)
        );
        if( c<0 ){
          lwr = idx+1;
        }else if( c>0 ){
          upr = idx-1;
        }else{
          assert( c==0 );
          *pRes = 0;
          rc = SQLITE_OK;
          pCur->ix = (u16)idx;
          if( pIdxKey->errCode ) rc = SQLITE_CORRUPT_BKPT;
          goto moveto_finish;
        }
        if( lwr>upr ) break;
        assert( lwr+upr>=0 );
        idx = (lwr+upr)>>1;  /* idx = (lwr+upr)/2 */
      }
    }
    assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
    assert( pPage->isInit );
    if( pPage->leaf ){
      assert( pCur->ix<pCur->pPage->nCell );
      pCur->ix = (u16)idx;
      *pRes = c;
      rc = SQLITE_OK;
      goto moveto_finish;
    }
moveto_next_layer:
    if( lwr>=pPage->nCell ){
      chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
    }else{
      chldPg = get4byte(findCell(pPage, lwr));
    }
    pCur->ix = (u16)lwr;
    rc = moveToChild(pCur, chldPg);
    if( rc ) break;
  }
moveto_finish:
  pCur->info.nSize = 0;
  assert( (pCur->curFlags & BTCF_ValidOvfl)==0 );
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3fb7a0
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3fb7a0
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x3fb7a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x3fb6f1
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3fbd1a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x20(%rbp), %rax
jge 0x3fb79e
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x3fb729
movq -0x30(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, -0x4(%rbp)
jmp 0x3fbd1a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jne 0x3fb79c
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3fbd60
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x3fb77e
movq -0x10(%rbp), %rdi
callq 0x3e9390
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x3fb77c
movl $0x0, -0x4(%rbp)
jmp 0x3fbd1a
jmp 0x3fb79a
cmpl $0x65, -0x34(%rbp)
jne 0x3fb78d
movl $0x0, -0x34(%rbp)
jmp 0x3fb798
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3fbd1a
jmp 0x3fb79a
jmp 0x3fb79c
jmp 0x3fb79e
jmp 0x3fb7a0
cmpq $0x0, -0x18(%rbp)
je 0x3fb7be
movq -0x18(%rbp), %rdi
callq 0x402290
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0x13(%rax)
jmp 0x3fb7c6
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x400d30
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x3fb7ff
cmpl $0x10, -0x34(%rbp)
jne 0x3fb7f4
movq -0x30(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, -0x4(%rbp)
jmp 0x3fbd1a
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3fbd1a
jmp 0x3fb801
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x60(%rbp), %rax
movzwl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl $0x1, %ecx
subl -0x24(%rbp), %ecx
sarl %cl, %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x56(%rax)
cmpq $0x0, -0x40(%rbp)
jne 0x3fb9b8
jmp 0x3fb850
movq -0x60(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x60(%rbp), %rcx
movzwl 0x1a(%rcx), %ecx
movq -0x60(%rbp), %rdx
movq 0x60(%rdx), %rdx
movl -0x4c(%rbp), %esi
shll %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
movq -0x60(%rbp), %rsi
movq 0x60(%rsi), %rsi
movl -0x4c(%rbp), %edi
shll %edi
movslq %edi, %rdi
movzbl 0x1(%rsi,%rdi), %esi
orl %esi, %edx
andl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
cmpb $0x0, 0x3(%rax)
je 0x3fb8e5
jmp 0x3fb8a6
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x68(%rbp)
movzbl (%rax), %ecx
movl $0x80, %eax
cmpl %ecx, %eax
jg 0x3fb8e3
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jb 0x3fb8e1
movl $0x1116d, %edi          # imm = 0x1116D
callq 0x3dff80
movl %eax, -0x4(%rbp)
jmp 0x3fbd1a
jmp 0x3fb8a6
jmp 0x3fb8e5
movq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3e4b70
movq -0x70(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x3fb91e
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x48(%rbp), %eax
jle 0x3fb919
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
jmp 0x3fb9b3
jmp 0x3fb9a3
movq -0x70(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x3fb944
movl -0x4c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x48(%rbp), %eax
jle 0x3fb942
movl $0x1, -0x50(%rbp)
jmp 0x3fb9b3
jmp 0x3fb9a1
movl -0x4c(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x56(%rax)
movq -0x60(%rbp), %rax
cmpb $0x0, 0x8(%rax)
jne 0x3fb967
movl -0x4c(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x3fbc60
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x1(%rax)
movq -0x70(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x46(%rax)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3fbd1a
jmp 0x3fb9a3
movl -0x44(%rbp), %eax
addl -0x48(%rbp), %eax
sarl %eax
movl %eax, -0x4c(%rbp)
jmp 0x3fb850
jmp 0x3fbc31
jmp 0x3fb9ba
movq -0x60(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x60(%rbp), %rcx
movzwl 0x1a(%rcx), %ecx
movq -0x60(%rbp), %rdx
movq 0x60(%rdx), %rdx
movl -0x4c(%rbp), %esi
shll %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
movq -0x60(%rbp), %rsi
movq 0x60(%rsi), %rsi
movl -0x4c(%rbp), %edi
shll %edi
movslq %edi, %rdi
movzbl 0x1(%rsi,%rdi), %esi
orl %esi, %edx
andl %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movq -0x60(%rbp), %rcx
movzbl 0xb(%rcx), %ecx
cmpl %ecx, %eax
jg 0x3fba3a
movq -0x40(%rbp), %rax
movl -0x74(%rbp), %edi
movq -0x68(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x50(%rbp)
jmp 0x3fbbb6
movq -0x68(%rbp), %rax
movzbl 0x1(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x3fba8b
movl -0x74(%rbp), %eax
andl $0x7f, %eax
shll $0x7, %eax
movq -0x68(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x74(%rbp)
movq -0x60(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
cmpl %ecx, %eax
jg 0x3fba8b
movq -0x40(%rbp), %rax
movl -0x74(%rbp), %edi
movq -0x68(%rbp), %rsi
addq $0x2, %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x50(%rbp)
jmp 0x3fbbb4
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
movzbl 0xa(%rcx), %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movl $0x12, -0x8c(%rbp)
movq -0x60(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x60(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x30, %rdx
callq *%rax
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl %eax, -0x74(%rbp)
cmpl $0x2, -0x74(%rbp)
jl 0x3fbb01
movl -0x74(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
xorl %edx, %edx
divl 0x38(%rcx)
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpl 0x40(%rcx), %eax
jbe 0x3fbb13
movl $0x111b8, %edi          # imm = 0x111B8
callq 0x3dff80
movl %eax, -0x34(%rbp)
jmp 0x3fbd0a
movl -0x74(%rbp), %eax
addl $0x12, %eax
movslq %eax, %rdi
callq 0x3c0760
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0x3fbb38
movl $0x7, -0x34(%rbp)
jmp 0x3fbd0a
movl -0x4c(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x56(%rax)
movq -0x10(%rbp), %rdi
movl -0x74(%rbp), %edx
movq -0x80(%rbp), %rcx
xorl %r8d, %r8d
movl %r8d, %esi
callq 0x3e9470
movl %eax, -0x34(%rbp)
movq -0x80(%rbp), %rdi
movslq -0x74(%rbp), %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x12, %edx
callq 0x19360
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
andl $-0x5, %ecx
movb %cl, 0x1(%rax)
cmpl $0x0, -0x34(%rbp)
je 0x3fbb98
movq -0x80(%rbp), %rdi
callq 0x3c0800
jmp 0x3fbd0a
movl -0x74(%rbp), %edi
movq -0x80(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x402370
movl %eax, -0x50(%rbp)
movq -0x80(%rbp), %rdi
callq 0x3c0800
jmp 0x3fbbb6
cmpl $0x0, -0x50(%rbp)
jge 0x3fbbc7
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x3fbc15
cmpl $0x0, -0x50(%rbp)
jle 0x3fbbd8
movl -0x4c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x3fbc13
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x34(%rbp)
movl -0x4c(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x56(%rax)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x13(%rax)
je 0x3fbc0e
movl $0x111d8, %edi          # imm = 0x111D8
callq 0x3dff80
movl %eax, -0x34(%rbp)
jmp 0x3fbd0a
jmp 0x3fbc15
movl -0x44(%rbp), %eax
cmpl -0x48(%rbp), %eax
jle 0x3fbc1f
jmp 0x3fbc2f
movl -0x44(%rbp), %eax
addl -0x48(%rbp), %eax
sarl %eax
movl %eax, -0x4c(%rbp)
jmp 0x3fb9ba
jmp 0x3fbc31
movq -0x60(%rbp), %rax
cmpb $0x0, 0x8(%rax)
je 0x3fbc5e
movl -0x4c(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x56(%rax)
movl -0x50(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x34(%rbp)
jmp 0x3fbd0a
jmp 0x3fbc60
movl -0x44(%rbp), %eax
movq -0x60(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jl 0x3fbc91
movq -0x60(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x60(%rbp), %rax
movzbl 0x9(%rax), %eax
addl $0x8, %eax
cltq
addq %rax, %rdi
callq 0x3db720
movl %eax, -0x54(%rbp)
jmp 0x3fbcde
movq -0x60(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x60(%rbp), %rax
movzwl 0x1a(%rax), %eax
movq -0x60(%rbp), %rcx
movq 0x60(%rcx), %rcx
movl -0x44(%rbp), %edx
shll %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
movq -0x60(%rbp), %rdx
movq 0x60(%rdx), %rdx
movl -0x44(%rbp), %esi
shll %esi
movslq %esi, %rsi
movzbl 0x1(%rdx,%rsi), %edx
orl %edx, %ecx
andl %ecx, %eax
cltq
addq %rax, %rdi
callq 0x3db720
movl %eax, -0x54(%rbp)
movl -0x44(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x56(%rax)
movq -0x10(%rbp), %rdi
movl -0x54(%rbp), %esi
callq 0x401010
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x3fbd03
jmp 0x3fbd08
jmp 0x3fb801
jmp 0x3fbd0a
movq -0x10(%rbp), %rax
movw $0x0, 0x46(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)