// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: fkActionTrigger
static Trigger *fkActionTrigger(
  Parse *pParse,                  /* Parse context */
  Table *pTab,                    /* Table being updated or deleted from */
  FKey *pFKey,                    /* Foreign key to get action for */
  ExprList *pChanges              /* Change-list for UPDATE, NULL for DELETE */
){
  sqlite3 *db = pParse->db;       /* Database handle */
  int action;                     /* One of OE_None, OE_Cascade etc. */
  Trigger *pTrigger;              /* Trigger definition to return */
  int iAction = (pChanges!=0);    /* 1 for UPDATE, 0 for DELETE */

  action = pFKey->aAction[iAction];
  pTrigger = pFKey->apTrigger[iAction];

  if( action!=OE_None && !pTrigger ){
    u8 enableLookaside;           /* Copy of db->lookaside.bEnabled */
    char const *zFrom;            /* Name of child table */
    int nFrom;                    /* Length in bytes of zFrom */
    Index *pIdx = 0;              /* Parent key index for this FK */
    int *aiCol = 0;               /* child table cols -> parent key cols */
    TriggerStep *pStep = 0;        /* First (only) step of trigger program */
    Expr *pWhere = 0;             /* WHERE clause of trigger step */
    ExprList *pList = 0;          /* Changes list if ON UPDATE CASCADE */
    Select *pSelect = 0;          /* If RESTRICT, "SELECT RAISE(...)" */
    int i;                        /* Iterator variable */
    Expr *pWhen = 0;              /* WHEN clause for the trigger */

    if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
    assert( aiCol || pFKey->nCol==1 );

    for(i=0; i<pFKey->nCol; i++){
      Token tOld = { "old", 3 };  /* Literal "old" token */
      Token tNew = { "new", 3 };  /* Literal "new" token */
      Token tFromCol;             /* Name of column in child table */
      Token tToCol;               /* Name of column in parent table */
      int iFromCol;               /* Idx of column in child table */
      Expr *pEq;                  /* tFromCol = OLD.tToCol */

      iFromCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
      assert( iFromCol>=0 );
      tToCol.z = pIdx ? pTab->aCol[pIdx->aiColumn[i]].zName : "oid";
      tFromCol.z = pFKey->pFrom->aCol[iFromCol].zName;

      tToCol.n = sqlite3Strlen30(tToCol.z);
      tFromCol.n = sqlite3Strlen30(tFromCol.z);

      /* Create the expression "OLD.zToCol = zFromCol". It is important
      ** that the "OLD.zToCol" term is on the LHS of the = operator, so
      ** that the affinity and collation sequence associated with the
      ** parent table are used for the comparison. */
      pEq = sqlite3PExpr(pParse, TK_EQ,
          sqlite3PExpr(pParse, TK_DOT, 
            sqlite3PExpr(pParse, TK_ID, 0, 0, &tOld),
            sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol)
          , 0),
          sqlite3PExpr(pParse, TK_ID, 0, 0, &tFromCol)
      , 0);
      pWhere = sqlite3ExprAnd(db, pWhere, pEq);

      /* For ON UPDATE, construct the next term of the WHEN clause.
      ** The final WHEN clause will be like this:
      **
      **    WHEN NOT(old.col1 IS new.col1 AND ... AND old.colN IS new.colN)
      */
      if( pChanges ){
        pEq = sqlite3PExpr(pParse, TK_IS,
            sqlite3PExpr(pParse, TK_DOT, 
              sqlite3PExpr(pParse, TK_ID, 0, 0, &tOld),
              sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol),
              0),
            sqlite3PExpr(pParse, TK_DOT, 
              sqlite3PExpr(pParse, TK_ID, 0, 0, &tNew),
              sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol),
              0),
            0);
        pWhen = sqlite3ExprAnd(db, pWhen, pEq);
      }
  
      if( action!=OE_Restrict && (action!=OE_Cascade || pChanges) ){
        Expr *pNew;
        if( action==OE_Cascade ){
          pNew = sqlite3PExpr(pParse, TK_DOT, 
            sqlite3PExpr(pParse, TK_ID, 0, 0, &tNew),
            sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol)
          , 0);
        }else if( action==OE_SetDflt ){
          Expr *pDflt = pFKey->pFrom->aCol[iFromCol].pDflt;
          if( pDflt ){
            pNew = sqlite3ExprDup(db, pDflt, 0);
          }else{
            pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
          }
        }else{
          pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
        }
        pList = sqlite3ExprListAppend(pParse, pList, pNew);
        sqlite3ExprListSetName(pParse, pList, &tFromCol, 0);
      }
    }
    sqlite3DbFree(db, aiCol);

    zFrom = pFKey->pFrom->zName;
    nFrom = sqlite3Strlen30(zFrom);

    if( action==OE_Restrict ){
      Token tFrom;
      Expr *pRaise; 

      tFrom.z = zFrom;
      tFrom.n = nFrom;
      pRaise = sqlite3Expr(db, TK_RAISE, "foreign key constraint failed");
      if( pRaise ){
        pRaise->affinity = OE_Abort;
      }
      pSelect = sqlite3SelectNew(pParse, 
          sqlite3ExprListAppend(pParse, 0, pRaise),
          sqlite3SrcListAppend(db, 0, &tFrom, 0),
          pWhere,
          0, 0, 0, 0, 0, 0
      );
      pWhere = 0;
    }

    /* Disable lookaside memory allocation */
    enableLookaside = db->lookaside.bEnabled;
    db->lookaside.bEnabled = 0;

    pTrigger = (Trigger *)sqlite3DbMallocZero(db, 
        sizeof(Trigger) +         /* struct Trigger */
        sizeof(TriggerStep) +     /* Single step in trigger program */
        nFrom + 1                 /* Space for pStep->target.z */
    );
    if( pTrigger ){
      pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1];
      pStep->target.z = (char *)&pStep[1];
      pStep->target.n = nFrom;
      memcpy((char *)pStep->target.z, zFrom, nFrom);
  
      pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
      pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE);
      pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
      if( pWhen ){
        pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0, 0);
        pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
      }
    }

    /* Re-enable the lookaside buffer, if it was disabled earlier. */
    db->lookaside.bEnabled = enableLookaside;

    sqlite3ExprDelete(db, pWhere);
    sqlite3ExprDelete(db, pWhen);
    sqlite3ExprListDelete(db, pList);
    sqlite3SelectDelete(db, pSelect);
    if( db->mallocFailed==1 ){
      fkTriggerDelete(db, pTrigger);
      return 0;
    }
    assert( pStep!=0 );

    switch( action ){
      case OE_Restrict:
        pStep->op = TK_SELECT; 
        break;
      case OE_Cascade: 
        if( !pChanges ){ 
          pStep->op = TK_DELETE; 
          break; 
        }
      default:
        pStep->op = TK_UPDATE;
    }
    pStep->pTrig = pTrigger;
    pTrigger->pSchema = pTab->pSchema;
    pTrigger->pTabSchema = pTab->pSchema;
    pFKey->apTrigger[iAction] = pTrigger;
    pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE);
  }

  return pTrigger;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
movslq -0x44(%rbp), %rcx
movzbl 0x2d(%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x7fa22
cmpq $0x0, -0x40(%rbp)
jne 0x7fa22
movq $0x0, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x78(%rbp)
movq $0x0, -0x80(%rbp)
movq $0x0, -0x88(%rbp)
movq $0x0, -0x98(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x60(%rbp), %rcx
leaq -0x68(%rbp), %r8
callq 0x7e4a0
cmpl $0x0, %eax
je 0x7f245
movq $0x0, -0x8(%rbp)
jmp 0x7fa2a
movl $0x0, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x7f6e5
movq 0x502df(%rip), %rax     # 0xcf548
movq %rax, -0xa8(%rbp)
movq 0x502d9(%rip), %rax     # 0xcf550
movq %rax, -0xa0(%rbp)
movq 0x502d3(%rip), %rax     # 0xcf558
movq %rax, -0xb8(%rbp)
movq 0x502cd(%rip), %rax     # 0xcf560
movq %rax, -0xb0(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x7f2b7
movq -0x68(%rbp), %rax
movslq -0x8c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x114(%rbp)
jmp 0x7f2c4
movq -0x20(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x114(%rbp)
movl -0x114(%rbp), %eax
movl %eax, -0xdc(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x7f305
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x60(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x8c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x120(%rbp)
jmp 0x7f315
leaq 0x315a7(%rip), %rax     # 0xb08b3
movq %rax, -0x120(%rbp)
jmp 0x7f315
movq -0x120(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0xdc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0xd8(%rbp), %rdi
callq 0x92f0
movl %eax, -0xd0(%rbp)
movq -0xc8(%rbp), %rdi
callq 0x92f0
movl %eax, -0xc0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xa8(%rbp), %r8
movq %rcx, %rdx
callq 0x508b0
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xd8(%rbp), %r8
movq %rcx, %rdx
callq 0x508b0
movq -0x140(%rbp), %rdi
movq -0x138(%rbp), %rdx
movq %rax, %rcx
movl $0x76, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x508b0
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xc8(%rbp), %r8
movq %rcx, %rdx
callq 0x508b0
movq -0x130(%rbp), %rdi
movq -0x128(%rbp), %rdx
movq %rax, %rcx
movl $0x4c, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x508b0
movq %rax, -0xe8(%rbp)
movq -0x30(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0xe8(%rbp), %rdx
callq 0x64b70
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7f577
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xa8(%rbp), %r8
movq %rcx, %rdx
callq 0x508b0
movq %rax, -0x168(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xd8(%rbp), %r8
movq %rcx, %rdx
callq 0x508b0
movq -0x170(%rbp), %rdi
movq -0x168(%rbp), %rdx
movq %rax, %rcx
movl $0x76, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x508b0
movq %rax, -0x148(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xb8(%rbp), %r8
movq %rcx, %rdx
callq 0x508b0
movq %rax, -0x158(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xd8(%rbp), %r8
movq %rcx, %rdx
callq 0x508b0
movq -0x160(%rbp), %rdi
movq -0x158(%rbp), %rdx
movq %rax, %rcx
movl $0x76, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x508b0
movq -0x150(%rbp), %rdi
movq -0x148(%rbp), %rdx
movq %rax, %rcx
movl $0x46, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x508b0
movq %rax, -0xe8(%rbp)
movq -0x30(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0xe8(%rbp), %rdx
callq 0x64b70
movq %rax, -0x98(%rbp)
cmpl $0x6, -0x34(%rbp)
je 0x7f6cf
cmpl $0x9, -0x34(%rbp)
jne 0x7f592
cmpq $0x0, -0x28(%rbp)
je 0x7f6cf
cmpl $0x9, -0x34(%rbp)
jne 0x7f60e
movq -0x10(%rbp), %rax
movq %rax, -0x180(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xb8(%rbp), %r8
movq %rcx, %rdx
callq 0x508b0
movq %rax, -0x178(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1a, %esi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xd8(%rbp), %r8
movq %rcx, %rdx
callq 0x508b0
movq -0x180(%rbp), %rdi
movq -0x178(%rbp), %rdx
movq %rax, %rcx
movl $0x76, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x508b0
movq %rax, -0xf0(%rbp)
jmp 0x7f6a1
cmpl $0x8, -0x34(%rbp)
jne 0x7f67f
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movslq -0xdc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0xf8(%rbp)
cmpq $0x0, -0xf8(%rbp)
je 0x7f65d
movq -0x30(%rbp), %rdi
movq -0xf8(%rbp), %rsi
xorl %edx, %edx
callq 0x61690
movq %rax, -0xf0(%rbp)
jmp 0x7f67d
movq -0x10(%rbp), %rdi
movl $0x62, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x508b0
movq %rax, -0xf0(%rbp)
jmp 0x7f69f
movq -0x10(%rbp), %rdi
movl $0x62, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x508b0
movq %rax, -0xf0(%rbp)
jmp 0x7f6a1
movq -0x10(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0xf0(%rbp), %rdx
callq 0x54650
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movq -0x80(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
xorl %ecx, %ecx
callq 0x54790
jmp 0x7f6d1
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x7f24f
movq -0x30(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x9cd0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x92f0
movl %eax, -0x54(%rbp)
cmpl $0x6, -0x34(%rbp)
jne 0x7f7ed
movq -0x50(%rbp), %rax
movq %rax, -0x108(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x100(%rbp)
movq -0x30(%rbp), %rdi
movl $0x38, %esi
leaq 0x2ec47(%rip), %rdx     # 0xae381
callq 0x548b0
movq %rax, -0x110(%rbp)
cmpq $0x0, -0x110(%rbp)
je 0x7f75b
movq -0x110(%rbp), %rax
movb $0x2, 0x1(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x10(%rbp), %rdi
movq -0x110(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x54650
movq %rax, -0x188(%rbp)
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x108(%rbp), %rdx
movq %rcx, %rsi
callq 0x54b60
movq -0x190(%rbp), %rdi
movq -0x188(%rbp), %rsi
movq %rax, %rdx
movq -0x78(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x54490
movq %rax, -0x88(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x30(%rbp), %rax
movb 0x152(%rax), %al
movb %al, -0x45(%rbp)
movq -0x30(%rbp), %rax
movb $0x0, 0x152(%rax)
movq -0x30(%rbp), %rdi
movslq -0x54(%rbp), %rax
addq $0x98, %rax
addq $0x1, %rax
movl %eax, %esi
callq 0x11ca0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x7f91a
movq -0x40(%rbp), %rax
addq $0x48, %rax
movq -0x40(%rbp), %rcx
movq %rax, 0x38(%rcx)
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rcx
addq $0x50, %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x54(%rbp), %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x70(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x50(%rbp), %rsi
movslq -0x54(%rbp), %rdx
callq 0x82f0
movq -0x30(%rbp), %rdi
movq -0x78(%rbp), %rsi
movl $0x1, %edx
callq 0x61690
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl $0x1, %edx
callq 0x61da0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl $0x1, %edx
callq 0x61ba0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x98(%rbp)
je 0x7f918
movq -0x10(%rbp), %rdi
movq -0x98(%rbp), %rdx
movl $0x13, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x508b0
movq %rax, -0x98(%rbp)
movq -0x30(%rbp), %rdi
movq -0x98(%rbp), %rsi
movl $0x1, %edx
callq 0x61690
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x7f91a
movb -0x45(%rbp), %cl
movq -0x30(%rbp), %rax
movb %cl, 0x152(%rax)
movq -0x30(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x47330
movq -0x30(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x47330
movq -0x30(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x47460
movq -0x30(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x47420
movq -0x30(%rbp), %rax
movzbl 0x50(%rax), %eax
cmpl $0x1, %eax
jne 0x7f988
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x4b6c0
movq $0x0, -0x8(%rbp)
jmp 0x7fa2a
movl -0x34(%rbp), %eax
movl %eax, -0x194(%rbp)
subl $0x6, %eax
je 0x7f9a5
jmp 0x7f998
movl -0x194(%rbp), %eax
subl $0x9, %eax
je 0x7f9ae
jmp 0x7f9c0
movq -0x70(%rbp), %rax
movb $0x74, (%rax)
jmp 0x7f9c7
cmpq $0x0, -0x28(%rbp)
jne 0x7f9be
movq -0x70(%rbp), %rax
movb $0x6a, (%rax)
jmp 0x7f9c7
jmp 0x7f9c0
movq -0x70(%rbp), %rax
movb $0x6b, (%rax)
movq -0x40(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq %rdx, 0x30(%rax,%rcx,8)
movq -0x28(%rbp), %rdx
movl $0x6a, %eax
movl $0x6b, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x40(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopw (%rax,%rax)