// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3CodeSubselect
SQLITE_PRIVATE int sqlite3CodeSubselect(
  Parse *pParse,          /* Parsing context */
  Expr *pExpr,            /* The IN, SELECT, or EXISTS operator */
  int rHasNullFlag,       /* Register that records whether NULLs exist in RHS */
  int isRowid             /* If true, LHS of IN operator is a rowid */
){
  int jmpIfDynamic = -1;                      /* One-time test address */
  int rReg = 0;                           /* Register storing resulting */
  Vdbe *v = sqlite3GetVdbe(pParse);
  if( NEVER(v==0) ) return 0;

  /* The evaluation of the IN/EXISTS/SELECT must be repeated every time it
  ** is encountered if any of the following is true:
  **
  **    *  The right-hand side is a correlated subquery
  **    *  The right-hand side is an expression list containing variables
  **    *  We are inside a trigger
  **
  ** If all of the above are false, then we can run this code just once
  ** save the results, and reuse the same result on subsequent invocations.
  */
  if( !ExprHasProperty(pExpr, EP_VarSelect) ){
    jmpIfDynamic = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
  }

  switch( pExpr->op ){
    case TK_IN: {
      int addr;                   /* Address of OP_OpenEphemeral instruction */
      Expr *pLeft = pExpr->pLeft; /* the LHS of the IN operator */
      KeyInfo *pKeyInfo = 0;      /* Key information */
      int nVal;                   /* Size of vector pLeft */
      
      nVal = sqlite3ExprVectorSize(pLeft);
      assert( !isRowid || nVal==1 );

      /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
      ** expression it is handled the same way.  An ephemeral table is 
      ** filled with index keys representing the results from the 
      ** SELECT or the <exprlist>.
      **
      ** If the 'x' expression is a column value, or the SELECT...
      ** statement returns a column value, then the affinity of that
      ** column is used to build the index keys. If both 'x' and the
      ** SELECT... statement are columns, then numeric affinity is used
      ** if either column has NUMERIC or INTEGER affinity. If neither
      ** 'x' nor the SELECT... statement are columns, then numeric affinity
      ** is used.
      */
      pExpr->iTable = pParse->nTab++;
      addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, 
          pExpr->iTable, (isRowid?0:nVal));
      pKeyInfo = isRowid ? 0 : sqlite3KeyInfoAlloc(pParse->db, nVal, 1);

      if( ExprHasProperty(pExpr, EP_xIsSelect) ){
        /* Case 1:     expr IN (SELECT ...)
        **
        ** Generate code to write the results of the select into the temporary
        ** table allocated and opened above.
        */
        Select *pSelect = pExpr->x.pSelect;
        ExprList *pEList = pSelect->pEList;

        ExplainQueryPlan((pParse, 1, "%sLIST SUBQUERY",
            jmpIfDynamic>=0?"":"CORRELATED "
        ));
        assert( !isRowid );
        /* If the LHS and RHS of the IN operator do not match, that
        ** error will have been caught long before we reach this point. */
        if( ALWAYS(pEList->nExpr==nVal) ){
          SelectDest dest;
          int i;
          sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
          dest.zAffSdst = exprINAffinity(pParse, pExpr);
          pSelect->iLimit = 0;
          testcase( pSelect->selFlags & SF_Distinct );
          testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
          if( sqlite3Select(pParse, pSelect, &dest) ){
            sqlite3DbFree(pParse->db, dest.zAffSdst);
            sqlite3KeyInfoUnref(pKeyInfo);
            return 0;
          }
          sqlite3DbFree(pParse->db, dest.zAffSdst);
          assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
          assert( pEList!=0 );
          assert( pEList->nExpr>0 );
          assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
          for(i=0; i<nVal; i++){
            Expr *p = sqlite3VectorFieldSubexpr(pLeft, i);
            pKeyInfo->aColl[i] = sqlite3BinaryCompareCollSeq(
                pParse, p, pEList->a[i].pExpr
            );
          }
        }
      }else if( ALWAYS(pExpr->x.pList!=0) ){
        /* Case 2:     expr IN (exprlist)
        **
        ** For each expression, build an index key from the evaluation and
        ** store it in the temporary table. If <expr> is a column, then use
        ** that columns affinity when building index keys. If <expr> is not
        ** a column, use numeric affinity.
        */
        char affinity;            /* Affinity of the LHS of the IN */
        int i;
        ExprList *pList = pExpr->x.pList;
        struct ExprList_item *pItem;
        int r1, r2, r3;
        affinity = sqlite3ExprAffinity(pLeft);
        if( !affinity ){
          affinity = SQLITE_AFF_BLOB;
        }
        if( pKeyInfo ){
          assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
          pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
        }

        /* Loop through each expression in <exprlist>. */
        r1 = sqlite3GetTempReg(pParse);
        r2 = sqlite3GetTempReg(pParse);
        if( isRowid ) sqlite3VdbeAddOp4(v, OP_Blob, 0, r2, 0, "", P4_STATIC);
        for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
          Expr *pE2 = pItem->pExpr;
          int iValToIns;

          /* If the expression is not constant then we will need to
          ** disable the test that was generated above that makes sure
          ** this code only executes once.  Because for a non-constant
          ** expression we need to rerun this code each time.
          */
          if( jmpIfDynamic>=0 && !sqlite3ExprIsConstant(pE2) ){
            sqlite3VdbeChangeToNoop(v, jmpIfDynamic);
            jmpIfDynamic = -1;
          }

          /* Evaluate the expression and insert it into the temp table */
          if( isRowid && sqlite3ExprIsInteger(pE2, &iValToIns) ){
            sqlite3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns);
          }else{
            r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
            if( isRowid ){
              sqlite3VdbeAddOp2(v, OP_MustBeInt, r3,
                                sqlite3VdbeCurrentAddr(v)+2);
              VdbeCoverage(v);
              sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
            }else{
              sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
              sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pExpr->iTable, r2, r3, 1);
            }
          }
        }
        sqlite3ReleaseTempReg(pParse, r1);
        sqlite3ReleaseTempReg(pParse, r2);
      }
      if( pKeyInfo ){
        sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO);
      }
      break;
    }

    case TK_EXISTS:
    case TK_SELECT:
    default: {
      /* Case 3:    (SELECT ... FROM ...)
      **     or:    EXISTS(SELECT ... FROM ...)
      **
      ** For a SELECT, generate code to put the values for all columns of
      ** the first row into an array of registers and return the index of
      ** the first register.
      **
      ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
      ** into a register and return that register number.
      **
      ** In both cases, the query is augmented with "LIMIT 1".  Any 
      ** preexisting limit is discarded in place of the new LIMIT 1.
      */
      Select *pSel;                         /* SELECT statement to encode */
      SelectDest dest;                      /* How to deal with SELECT result */
      int nReg;                             /* Registers to allocate */
      Expr *pLimit;                         /* New limit expression */

      testcase( pExpr->op==TK_EXISTS );
      testcase( pExpr->op==TK_SELECT );
      assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
      assert( ExprHasProperty(pExpr, EP_xIsSelect) );

      pSel = pExpr->x.pSelect;
      ExplainQueryPlan((pParse, 1, "%sSCALAR SUBQUERY",
            jmpIfDynamic>=0?"":"CORRELATED "));
      nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
      sqlite3SelectDestInit(&dest, 0, pParse->nMem+1);
      pParse->nMem += nReg;
      if( pExpr->op==TK_SELECT ){
        dest.eDest = SRT_Mem;
        dest.iSdst = dest.iSDParm;
        dest.nSdst = nReg;
        sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1);
        VdbeComment((v, "Init subquery result"));
      }else{
        dest.eDest = SRT_Exists;
        sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm);
        VdbeComment((v, "Init EXISTS result"));
      }
      pLimit = sqlite3ExprAlloc(pParse->db, TK_INTEGER,&sqlite3IntTokens[1], 0);
      if( pSel->pLimit ){
        sqlite3ExprDelete(pParse->db, pSel->pLimit->pLeft);
        pSel->pLimit->pLeft = pLimit;
      }else{
        pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0);
      }
      pSel->iLimit = 0;
      if( sqlite3Select(pParse, pSel, &dest) ){
        return 0;
      }
      rReg = dest.iSDParm;
      ExprSetVVAProperty(pExpr, EP_NoReduce);
      break;
    }
  }

  if( rHasNullFlag ){
    sqlite3SetHasNullFlag(v, pExpr->iTable, rHasNullFlag);
  }

  if( jmpIfDynamic>=0 ){
    sqlite3VdbeJumpHere(v, jmpIfDynamic);
  }

  return rReg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46bb00
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x46eae7
movl $0x0, -0x4(%rbp)
jmp 0x46f20d
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x46eb07
movq -0x30(%rbp), %rdi
movl $0x11, %esi
callq 0x46bb70
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x104(%rbp)
subl $0x14, %eax
je 0x46f000
jmp 0x46eb1f
movl -0x104(%rbp), %eax
subl $0x31, %eax
je 0x46eb40
jmp 0x46eb2c
movl -0x104(%rbp), %eax
subl $0x7f, %eax
je 0x46f000
jmp 0x46f002
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x46f220
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x34(%rax)
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x108(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x46eb9e
xorl %eax, %eax
movl %eax, -0x114(%rbp)
jmp 0x46eba7
movl -0x4c(%rbp), %eax
movl %eax, -0x114(%rbp)
movl -0x108(%rbp), %edx
movq -0x110(%rbp), %rdi
movl -0x114(%rbp), %ecx
movl $0x71, %esi
callq 0x453790
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x46ebd8
xorl %eax, %eax
movq %rax, -0x120(%rbp)
jmp 0x46ebf3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x4c(%rbp), %esi
movl $0x1, %edx
callq 0x46c4c0
movq %rax, -0x120(%rbp)
movq -0x120(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x46ed63
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x1113c1(%rip), %rcx    # 0x57fff9
leaq 0x1312ce(%rip), %rax    # 0x59ff0d
cmpl $0x0, %edx
cmovgeq %rax, %rcx
movl $0x1, %esi
leaq 0x111397(%rip), %rdx    # 0x57ffe9
movb $0x0, %al
callq 0x472ca0
movq -0x60(%rbp), %rax
movl (%rax), %eax
cmpl -0x4c(%rbp), %eax
jne 0x46ed5e
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %edx
leaq -0x80(%rbp), %rdi
movl $0xb, %esi
callq 0x472dc0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x472e10
movq %rax, -0x70(%rbp)
movq -0x58(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x45e5a0
cmpl $0x0, %eax
je 0x46ecd4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x70(%rbp), %rsi
callq 0x4058a0
movq -0x48(%rbp), %rdi
callq 0x430590
movl $0x0, -0x4(%rbp)
jmp 0x46f20d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x70(%rbp), %rsi
callq 0x4058a0
movl $0x0, -0x84(%rbp)
movl -0x84(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jge 0x46ed5c
movq -0x40(%rbp), %rdi
movl -0x84(%rbp), %esi
callq 0x4709d0
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x60(%rbp), %rax
addq $0x8, %rax
movslq -0x84(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdx
callq 0x414b40
movq %rax, %rdx
movq -0x48(%rbp), %rax
movslq -0x84(%rbp), %rcx
movq %rdx, 0x20(%rax,%rcx,8)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x46ecee
jmp 0x46ed5e
jmp 0x46efdf
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x46efdd
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x40(%rbp), %rdi
callq 0x470b70
movb %al, -0x91(%rbp)
cmpb $0x0, -0x91(%rbp)
jne 0x46eda0
movb $0x41, -0x91(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x46edc3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x456110
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x470ad0
movl %eax, -0xac(%rbp)
movq -0x10(%rbp), %rdi
callq 0x470ad0
movl %eax, -0xb0(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x46ee0f
movq -0x30(%rbp), %rdi
movl -0xb0(%rbp), %ecx
movl $0x4b, %esi
xorl %r8d, %r8d
leaq 0x13110d(%rip), %r9     # 0x59ff0d
movl %r8d, %edx
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
callq 0x46bbd0
movq -0xa0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x98(%rbp)
movq -0xa0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xa8(%rbp)
cmpl $0x0, -0x98(%rbp)
jle 0x46efbf
movq -0xa8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x46ee78
movq -0xc0(%rbp), %rdi
callq 0x46e580
cmpl $0x0, %eax
jne 0x46ee78
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x472f20
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
cmpl $0x0, -0x20(%rbp)
je 0x46eebd
movq -0xc0(%rbp), %rdi
leaq -0xc4(%rbp), %rsi
callq 0x472fb0
cmpl $0x0, %eax
je 0x46eebd
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %edx
movl -0xb0(%rbp), %ecx
movl -0xc4(%rbp), %r8d
movl $0x7b, %esi
callq 0x4537c0
jmp 0x46ef97
movq -0x10(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movl -0xac(%rbp), %edx
callq 0x46c620
movl %eax, -0xb4(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x46ef3f
movq -0x30(%rbp), %rax
movq %rax, -0x130(%rbp)
movl -0xb4(%rbp), %eax
movl %eax, -0x124(%rbp)
movq -0x30(%rbp), %rdi
callq 0x473080
movq -0x130(%rbp), %rdi
movl -0x124(%rbp), %edx
movl %eax, %ecx
addl $0x2, %ecx
movl $0xf, %esi
callq 0x453790
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %edx
movl -0xb0(%rbp), %ecx
movl -0xb4(%rbp), %r8d
movl $0x7a, %esi
callq 0x4537c0
jmp 0x46ef95
movq -0x30(%rbp), %rdi
movl -0xb4(%rbp), %edx
movl -0xb0(%rbp), %r8d
movl $0x66, %esi
movl $0x1, %ecx
leaq -0x91(%rbp), %r9
movl $0x1, (%rsp)
callq 0x46bbd0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %edx
movl -0xb0(%rbp), %ecx
movl -0xb4(%rbp), %r8d
movl $0x85, %esi
movl $0x1, %r9d
callq 0x4113b0
jmp 0x46ef97
jmp 0x46ef99
movl -0x98(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x98(%rbp)
movq -0xa8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xa8(%rbp)
jmp 0x46ee30
movq -0x10(%rbp), %rdi
movl -0xac(%rbp), %esi
callq 0x470060
movq -0x10(%rbp), %rdi
movl -0xb0(%rbp), %esi
callq 0x470060
jmp 0x46efdf
cmpq $0x0, -0x48(%rbp)
je 0x46effb
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x48(%rbp), %rdx
movl $0xfffffff7, %ecx       # imm = 0xFFFFFFF7
callq 0x411670
jmp 0x46f1dc
jmp 0x46f002
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x110fda(%rip), %rcx    # 0x57fff9
leaq 0x130ee7(%rip), %rax    # 0x59ff0d
cmpl $0x0, %edx
cmovgeq %rax, %rcx
movl $0x1, %esi
leaq 0x110fcc(%rip), %rdx    # 0x580005
movb $0x0, %al
callq 0x472ca0
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7f, %eax
jne 0x46f060
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x134(%rbp)
jmp 0x46f06d
movl $0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0x46f06d
movl -0x134(%rbp), %eax
movl %eax, -0xf4(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edx
addl $0x1, %edx
leaq -0xf0(%rbp), %rdi
xorl %esi, %esi
callq 0x472dc0
movl -0xf4(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x38(%rax), %ecx
movl %ecx, 0x38(%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x7f, %eax
jne 0x46f0f6
movb $0xa, -0xf0(%rbp)
movl -0xec(%rbp), %eax
movl %eax, -0xe8(%rbp)
movl -0xf4(%rbp), %eax
movl %eax, -0xe4(%rbp)
movq -0x30(%rbp), %rdi
movl -0xec(%rbp), %ecx
movl -0xec(%rbp), %r8d
addl -0xf4(%rbp), %r8d
subl $0x1, %r8d
movl $0x49, %esi
xorl %edx, %edx
callq 0x4537c0
jmp 0x46f113
movb $0x3, -0xf0(%rbp)
movq -0x30(%rbp), %rdi
movl -0xec(%rbp), %ecx
movl $0x46, %esi
xorl %edx, %edx
callq 0x453790
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x8f, %esi
leaq 0x15d2fa(%rip), %rdx    # 0x5cc420
addq $0x10, %rdx
xorl %ecx, %ecx
callq 0x460aa0
movq %rax, -0x100(%rbp)
movq -0xd0(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x46f179
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0xd0(%rbp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x44fdb0
movq -0x100(%rbp), %rcx
movq -0xd0(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x10(%rax)
jmp 0x46f1a0
movq -0x10(%rbp), %rdi
movq -0x100(%rbp), %rdx
movl $0x89, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x45be90
movq %rax, %rcx
movq -0xd0(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0xd0(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0xd0(%rbp), %rsi
leaq -0xf0(%rbp), %rdx
callq 0x45e5a0
cmpl $0x0, %eax
je 0x46f1d3
movl $0x0, -0x4(%rbp)
jmp 0x46f20d
movl -0xec(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x46f1f5
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %esi
movl -0x1c(%rbp), %edx
callq 0x4730a0
cmpl $0x0, -0x24(%rbp)
jl 0x46f207
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x46bba0
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)