// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3FindInIndex
SQLITE_PRIVATE int sqlite3FindInIndex(
  Parse *pParse,             /* Parsing context */
  Expr *pX,                  /* The IN expression */
  u32 inFlags,               /* IN_INDEX_LOOP, _MEMBERSHIP, and/or _NOOP_OK */
  int *prRhsHasNull,         /* Register holding NULL status.  See notes */
  int *aiMap,                /* Mapping from Index fields to RHS fields */
  int *piTab                 /* OUT: index to use */
){
  Select *p;                            /* SELECT to the right of IN operator */
  int eType = 0;                        /* Type of RHS table. IN_INDEX_* */
  int iTab = pParse->nTab++;            /* Cursor of the RHS table */
  int mustBeUnique;                     /* True if RHS must be unique */
  Vdbe *v = sqlite3GetVdbe(pParse);     /* Virtual machine being coded */

  assert( pX->op==TK_IN );
  mustBeUnique = (inFlags & IN_INDEX_LOOP)!=0;

  /* If the RHS of this IN(...) operator is a SELECT, and if it matters
  ** whether or not the SELECT result contains NULL values, check whether
  ** or not NULL is actually possible (it may not be, for example, due
  ** to NOT NULL constraints in the schema). If no NULL values are possible,
  ** set prRhsHasNull to 0 before continuing.  */
  if( prRhsHasNull && (pX->flags & EP_xIsSelect) ){
    int i;
    ExprList *pEList = pX->x.pSelect->pEList;
    for(i=0; i<pEList->nExpr; i++){
      if( sqlite3ExprCanBeNull(pEList->a[i].pExpr) ) break;
    }
    if( i==pEList->nExpr ){
      prRhsHasNull = 0;
    }
  }

  /* Check to see if an existing table or index can be used to
  ** satisfy the query.  This is preferable to generating a new
  ** ephemeral table.  */
  if( pParse->nErr==0 && (p = isCandidateForInOpt(pX))!=0 ){
    sqlite3 *db = pParse->db;              /* Database connection */
    Table *pTab;                           /* Table <table>. */
    int iDb;                               /* Database idx for pTab */
    ExprList *pEList = p->pEList;
    int nExpr = pEList->nExpr;

    assert( p->pEList!=0 );             /* Because of isCandidateForInOpt(p) */
    assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
    assert( p->pSrc!=0 );               /* Because of isCandidateForInOpt(p) */
    pTab = p->pSrc->a[0].pTab;

    /* Code an OP_Transaction and OP_TableLock for <table>. */
    iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
    assert( iDb>=0 && iDb<SQLITE_MAX_ATTACHED );
    sqlite3CodeVerifySchema(pParse, iDb);
    sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);

    assert(v);  /* sqlite3GetVdbe() has always been previously called */
    if( nExpr==1 && pEList->a[0].pExpr->iColumn<0 ){
      /* The "x IN (SELECT rowid FROM table)" case */
      int iAddr = sqlite3VdbeAddOp0(v, OP_Once);
      VdbeCoverage(v);

      sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
      eType = IN_INDEX_ROWID;
      ExplainQueryPlan((pParse, 0,
            "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName));
      sqlite3VdbeJumpHere(v, iAddr);
    }else{
      Index *pIdx;                         /* Iterator variable */
      int affinity_ok = 1;
      int i;

      /* Check that the affinity that will be used to perform each
      ** comparison is the same as the affinity of each column in table
      ** on the RHS of the IN operator.  If it not, it is not possible to
      ** use any index of the RHS table.  */
      for(i=0; i<nExpr && affinity_ok; i++){
        Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, i);
        int iCol = pEList->a[i].pExpr->iColumn;
        char idxaff = sqlite3TableColumnAffinity(pTab,iCol); /* RHS table */
        char cmpaff = sqlite3CompareAffinity(pLhs, idxaff);
        testcase( cmpaff==SQLITE_AFF_BLOB );
        testcase( cmpaff==SQLITE_AFF_TEXT );
        switch( cmpaff ){
          case SQLITE_AFF_BLOB:
            break;
          case SQLITE_AFF_TEXT:
            /* sqlite3CompareAffinity() only returns TEXT if one side or the
            ** other has no affinity and the other side is TEXT.  Hence,
            ** the only way for cmpaff to be TEXT is for idxaff to be TEXT
            ** and for the term on the LHS of the IN to have no affinity. */
            assert( idxaff==SQLITE_AFF_TEXT );
            break;
          default:
            affinity_ok = sqlite3IsNumericAffinity(idxaff);
        }
      }

      if( affinity_ok ){
        /* Search for an existing index that will work for this IN operator */
        for(pIdx=pTab->pIndex; pIdx && eType==0; pIdx=pIdx->pNext){
          Bitmask colUsed;      /* Columns of the index used */
          Bitmask mCol;         /* Mask for the current column */
          if( pIdx->nColumn<nExpr ) continue;
          if( pIdx->pPartIdxWhere!=0 ) continue;
          /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
          ** BITMASK(nExpr) without overflowing */
          testcase( pIdx->nColumn==BMS-2 );
          testcase( pIdx->nColumn==BMS-1 );
          if( pIdx->nColumn>=BMS-1 ) continue;
          if( mustBeUnique ){
            if( pIdx->nKeyCol>nExpr
             ||(pIdx->nColumn>nExpr && !IsUniqueIndex(pIdx))
            ){
              continue;  /* This index is not unique over the IN RHS columns */
            }
          }

          colUsed = 0;   /* Columns of index used so far */
          for(i=0; i<nExpr; i++){
            Expr *pLhs = sqlite3VectorFieldSubexpr(pX->pLeft, i);
            Expr *pRhs = pEList->a[i].pExpr;
            CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs);
            int j;

            assert( pReq!=0 || pRhs->iColumn==XN_ROWID || pParse->nErr );
            for(j=0; j<nExpr; j++){
              if( pIdx->aiColumn[j]!=pRhs->iColumn ) continue;
              assert( pIdx->azColl[j] );
              if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){
                continue;
              }
              break;
            }
            if( j==nExpr ) break;
            mCol = MASKBIT(j);
            if( mCol & colUsed ) break; /* Each column used only once */
            colUsed |= mCol;
            if( aiMap ) aiMap[i] = j;
          }

          assert( i==nExpr || colUsed!=(MASKBIT(nExpr)-1) );
          if( colUsed==(MASKBIT(nExpr)-1) ){
            /* If we reach this point, that means the index pIdx is usable */
            int iAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
            ExplainQueryPlan((pParse, 0,
                              "USING INDEX %s FOR IN-OPERATOR",pIdx->zName));
            sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
            sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
            VdbeComment((v, "%s", pIdx->zName));
            assert( IN_INDEX_INDEX_DESC == IN_INDEX_INDEX_ASC+1 );
            eType = IN_INDEX_INDEX_ASC + pIdx->aSortOrder[0];

            if( prRhsHasNull ){
#ifdef SQLITE_ENABLE_COLUMN_USED_MASK
              i64 mask = (1<<nExpr)-1;
              sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed,
                  iTab, 0, 0, (u8*)&mask, P4_INT64);
#endif
              *prRhsHasNull = ++pParse->nMem;
              if( nExpr==1 ){
                sqlite3SetHasNullFlag(v, iTab, *prRhsHasNull);
              }
            }
            sqlite3VdbeJumpHere(v, iAddr);
          }
        } /* End loop over indexes */
      } /* End if( affinity_ok ) */
    } /* End if not an rowid index */
  } /* End attempt to optimize using an index */

  /* If no preexisting index is available for the IN clause
  ** and IN_INDEX_NOOP is an allowed reply
  ** and the RHS of the IN operator is a list, not a subquery
  ** and the RHS is not constant or has two or fewer terms,
  ** then it is not worth creating an ephemeral table to evaluate
  ** the IN operator so return IN_INDEX_NOOP.
  */
  if( eType==0
   && (inFlags & IN_INDEX_NOOP_OK)
   && !ExprHasProperty(pX, EP_xIsSelect)
   && (!sqlite3InRhsIsConstant(pX) || pX->x.pList->nExpr<=2)
  ){
    eType = IN_INDEX_NOOP;
  }

  if( eType==0 ){
    /* Could not find an existing table or index to use as the RHS b-tree.
    ** We will have to generate an ephemeral table to do the job.
    */
    u32 savedNQueryLoop = pParse->nQueryLoop;
    int rMayHaveNull = 0;
    eType = IN_INDEX_EPH;
    if( inFlags & IN_INDEX_LOOP ){
      pParse->nQueryLoop = 0;
    }else if( prRhsHasNull ){
      *prRhsHasNull = rMayHaveNull = ++pParse->nMem;
    }
    assert( pX->op==TK_IN );
    sqlite3CodeRhsOfIN(pParse, pX, iTab);
    if( rMayHaveNull ){
      sqlite3SetHasNullFlag(v, iTab, rMayHaveNull);
    }
    pParse->nQueryLoop = savedNQueryLoop;
  }

  if( aiMap && eType!=IN_INDEX_INDEX_ASC && eType!=IN_INDEX_INDEX_DESC ){
    int i, n;
    n = sqlite3ExprVectorSize(pX->pLeft);
    for(i=0; i<n; i++) aiMap[i] = i;
  }
  *piTab = iTab;
  return eType;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rcx
movl 0x34(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x34(%rcx)
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4299d0
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x430f5a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x430f5a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x60(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x430f45
movq -0x60(%rbp), %rax
addq $0x8, %rax
movslq -0x54(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x431630
cmpl $0x0, %eax
je 0x430f38
jmp 0x430f45
jmp 0x430f3a
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x430f0b
movl -0x54(%rbp), %eax
movq -0x60(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x430f58
movq $0x0, -0x20(%rbp)
jmp 0x430f5a
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x4314c3
movq -0x10(%rbp), %rdi
callq 0x4317c0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x4314c3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x84(%rbp)
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rax
movq 0x70(%rax), %rsi
callq 0x3cb770
movl %eax, -0x74(%rbp)
movq -0x8(%rbp), %rdi
movl -0x74(%rbp), %esi
callq 0x431940
movq -0x8(%rbp), %rdi
movl -0x74(%rbp), %esi
movq -0x70(%rbp), %rax
movl 0x38(%rax), %edx
movq -0x70(%rbp), %rax
movq (%rax), %r8
xorl %ecx, %ecx
callq 0x429f80
cmpl $0x1, -0x84(%rbp)
jne 0x43106b
movq -0x80(%rbp), %rax
movq 0x8(%rax), %rax
movswl 0x30(%rax), %eax
cmpl $0x0, %eax
jge 0x43106b
movq -0x50(%rbp), %rdi
movl $0x11, %esi
callq 0x429a40
movl %eax, -0x88(%rbp)
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x74(%rbp), %edx
movq -0x70(%rbp), %rcx
movl $0x60, %r8d
callq 0x429e70
movl $0x1, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x70(%rbp), %rax
movq (%rax), %rcx
xorl %esi, %esi
leaq 0x17bae6(%rip), %rdx    # 0x5acb36
movb $0x0, %al
callq 0x430b00
movq -0x50(%rbp), %rdi
movl -0x88(%rbp), %esi
callq 0x429a70
jmp 0x4314c1
movl $0x1, -0x94(%rbp)
movl $0x0, -0x98(%rbp)
movl -0x98(%rbp), %ecx
xorl %eax, %eax
cmpl -0x84(%rbp), %ecx
movb %al, -0xe9(%rbp)
jge 0x4310a5
cmpl $0x0, -0x94(%rbp)
setne %al
movb %al, -0xe9(%rbp)
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0x4310b4
jmp 0x43116d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x98(%rbp), %esi
callq 0x42f090
movq %rax, -0xa0(%rbp)
movq -0x80(%rbp), %rax
movslq -0x98(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x8(%rax,%rcx,8), %rax
movswl 0x30(%rax), %eax
movl %eax, -0xa4(%rbp)
movq -0x70(%rbp), %rdi
movl -0xa4(%rbp), %esi
callq 0x42baa0
movb %al, -0xa5(%rbp)
movq -0xa0(%rbp), %rdi
movsbl -0xa5(%rbp), %esi
callq 0x42f370
movb %al, -0xa6(%rbp)
movsbl -0xa6(%rbp), %eax
movl %eax, -0xf0(%rbp)
subl $0x41, %eax
je 0x43113b
jmp 0x43112e
movl -0xf0(%rbp), %eax
subl $0x42, %eax
je 0x43113d
jmp 0x43113f
jmp 0x431157
jmp 0x431157
movsbl -0xa5(%rbp), %eax
cmpl $0x43, %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x94(%rbp)
jmp 0x431159
movl -0x98(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x98(%rbp)
jmp 0x43107f
cmpl $0x0, -0x94(%rbp)
je 0x4314bf
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x90(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x90(%rbp)
movb %al, -0xf1(%rbp)
je 0x4311a8
cmpl $0x0, -0x3c(%rbp)
sete %al
movb %al, -0xf1(%rbp)
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x4311b7
jmp 0x4314bd
movq -0x90(%rbp), %rax
movzwl 0x60(%rax), %eax
cmpl -0x84(%rbp), %eax
jge 0x4311cf
jmp 0x4314a6
movq -0x90(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x4311e2
jmp 0x4314a6
movq -0x90(%rbp), %rax
movzwl 0x60(%rax), %eax
cmpl $0x3f, %eax
jl 0x4311f7
jmp 0x4314a6
cmpl $0x0, -0x44(%rbp)
je 0x43123a
movq -0x90(%rbp), %rax
movzwl 0x5e(%rax), %eax
cmpl -0x84(%rbp), %eax
jg 0x431233
movq -0x90(%rbp), %rax
movzwl 0x60(%rax), %eax
cmpl -0x84(%rbp), %eax
jle 0x431238
movq -0x90(%rbp), %rax
movzbl 0x62(%rax), %eax
cmpl $0x0, %eax
jne 0x431238
jmp 0x4314a6
jmp 0x43123a
movq $0x0, -0xb0(%rbp)
movl $0x0, -0x98(%rbp)
movl -0x98(%rbp), %eax
cmpl -0x84(%rbp), %eax
jge 0x4313c4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x98(%rbp), %esi
callq 0x42f090
movq %rax, -0xc0(%rbp)
movq -0x80(%rbp), %rax
addq $0x8, %rax
movslq -0x98(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x412420
movq %rax, -0xd0(%rbp)
movl $0x0, -0xd4(%rbp)
movl -0xd4(%rbp), %eax
cmpl -0x84(%rbp), %eax
jge 0x431341
movq -0x90(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xd4(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
movq -0xc8(%rbp), %rcx
movswl 0x30(%rcx), %ecx
cmpl %ecx, %eax
je 0x4312f8
jmp 0x431330
cmpq $0x0, -0xd0(%rbp)
je 0x43132e
movq -0xd0(%rbp), %rax
movq (%rax), %rdi
movq -0x90(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xd4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3c3e60
cmpl $0x0, %eax
je 0x43132e
jmp 0x431330
jmp 0x431341
movl -0xd4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd4(%rbp)
jmp 0x4312c3
movl -0xd4(%rbp), %eax
cmpl -0x84(%rbp), %eax
jne 0x431351
jmp 0x4313c4
movl -0xd4(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
andq -0xb0(%rbp), %rax
cmpq $0x0, %rax
je 0x43137e
jmp 0x4313c4
movq -0xb8(%rbp), %rax
orq -0xb0(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4313ae
movl -0xd4(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x98(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x4313b0
movl -0x98(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x98(%rbp)
jmp 0x43124f
movq -0xb0(%rbp), %rax
movl -0x84(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x4314a4
movq -0x50(%rbp), %rdi
movl $0x11, %esi
callq 0x429a40
movl %eax, -0xd8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x90(%rbp), %rax
movq (%rax), %rcx
xorl %esi, %esi
leaq 0x17b751(%rip), %rdx    # 0x5acb65
movb $0x0, %al
callq 0x430b00
movq -0x50(%rbp), %rdi
movl -0x40(%rbp), %edx
movq -0x90(%rbp), %rax
movl 0x58(%rax), %ecx
movl -0x74(%rbp), %r8d
movl $0x60, %esi
callq 0x410130
movq -0x8(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x42a150
movq -0x90(%rbp), %rax
movq 0x38(%rax), %rax
movzbl (%rax), %eax
addl $0x3, %eax
movl %eax, -0x3c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x431495
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x1, -0x84(%rbp)
jne 0x431493
movq -0x50(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
callq 0x4319d0
jmp 0x431495
movq -0x50(%rbp), %rdi
movl -0xd8(%rbp), %esi
callq 0x429a70
jmp 0x4314a6
movq -0x90(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x90(%rbp)
jmp 0x431189
jmp 0x4314bf
jmp 0x4314c1
jmp 0x4314c3
cmpl $0x0, -0x3c(%rbp)
jne 0x431507
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x431507
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x431507
movq -0x10(%rbp), %rdi
callq 0x431a40
cmpl $0x0, %eax
je 0x431500
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x2, (%rax)
jg 0x431507
movl $0x5, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x4315aa
movq -0x8(%rbp), %rax
movl 0xc4(%rax), %eax
movl %eax, -0xdc(%rbp)
movl $0x0, -0xe0(%rbp)
movl $0x2, -0x3c(%rbp)
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x43154d
movq -0x8(%rbp), %rax
movl $0x0, 0xc4(%rax)
jmp 0x43156f
cmpq $0x0, -0x20(%rbp)
je 0x43156d
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movl %ecx, -0xe0(%rbp)
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x43156f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x40(%rbp), %edx
callq 0x431a90
cmpl $0x0, -0xe0(%rbp)
je 0x43159a
movq -0x50(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0xe0(%rbp), %edx
callq 0x4319d0
movl -0xdc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc4(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x43160f
cmpl $0x3, -0x3c(%rbp)
je 0x43160f
cmpl $0x4, -0x3c(%rbp)
je 0x43160f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x42d4d0
movl %eax, -0xe8(%rbp)
movl $0x0, -0xe4(%rbp)
movl -0xe4(%rbp), %eax
cmpl -0xe8(%rbp), %eax
jge 0x43160d
movl -0xe4(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0xe4(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0xe4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xe4(%rbp)
jmp 0x4315da
jmp 0x43160f
movl -0x40(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0x3c(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)