LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: exprListAppendList
static ExprList *exprListAppendList(
  Parse *pParse,          /* Parsing context */
  ExprList *pList,        /* List to which to append. Might be NULL */
  ExprList *pAppend,      /* List of values to append. Might be NULL */
  int bIntToNull
){
  if( pAppend ){
    int i;
    int nInit = pList ? pList->nExpr : 0;
    for(i=0; i<pAppend->nExpr; i++){
      Expr *pDup = sqlite3ExprDup(pParse->db, pAppend->a[i].pExpr, 0);
      if( bIntToNull && pDup && pDup->op==TK_INTEGER ){
        pDup->op = TK_NULL;
        pDup->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse);
      }
      pList = sqlite3ExprListAppend(pParse, pList, pDup);
      if( pList ) pList->a[nInit+i].sortFlags = pAppend->a[i].sortFlags;
    }
  }
  return pList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8dc90
cmpq $0x0, -0x10(%rbp)
je 0x8dbb4
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x8dbbb
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x8dbbb
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x8dc8e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
addq $0x8, %rax
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x77a40
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8dc31
cmpq $0x0, -0x30(%rbp)
je 0x8dc31
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x96, %eax
jne 0x8dc31
movq -0x30(%rbp), %rax
movb $0x75, (%rax)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0xcffffbff, %ecx       # imm = 0xCFFFFBFF
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x681a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8dc7e
movq -0x18(%rbp), %rax
addq $0x8, %rax
movslq -0x20(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movb 0x18(%rax), %cl
movq -0x10(%rbp), %rax
addq $0x8, %rax
movl -0x24(%rbp), %edx
addl -0x20(%rbp), %edx
movslq %edx, %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movb %cl, 0x18(%rax)
jmp 0x8dc80
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8dbc8
jmp 0x8dc90
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: constInsert
static void constInsert(
  WhereConst *pConst,      /* The WhereConst into which we are inserting */
  Expr *pColumn,           /* The COLUMN part of the constraint */
  Expr *pValue             /* The VALUE part of the constraint */
){
  int i;
  assert( pColumn->op==TK_COLUMN );

  /* 2018-10-25 ticket [cf5ed20f]
  ** Make sure the same pColumn is not inserted more than once */
  for(i=0; i<pConst->nConst; i++){
    const Expr *pExpr = pConst->apExpr[i*2];
    assert( pExpr->op==TK_COLUMN );
    if( pExpr->iTable==pColumn->iTable
     && pExpr->iColumn==pColumn->iColumn
    ){
      return;  /* Already present.  Return without doing anything. */
    }
  }

  pConst->nConst++;
  pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
                         pConst->nConst*2*sizeof(Expr*));
  if( pConst->apExpr==0 ){
    pConst->nConst = 0;
  }else{
    if( ExprHasProperty(pValue, EP_FixedCol) ) pValue = pValue->pLeft;
    pConst->apExpr[pConst->nConst*2-2] = pColumn;
    pConst->apExpr[pConst->nConst*2-1] = pValue;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x90345
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jne 0x90338
movq -0x28(%rbp), %rax
movswl 0x30(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x30(%rcx), %ecx
cmpl %ecx, %eax
jne 0x90338
jmp 0x903f5
jmp 0x9033a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x902eb
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shll %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x393b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x9039c
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x903f5
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x903b7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
shll %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
shll %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: exprCommute
static u16 exprCommute(Parse *pParse, Expr *pExpr){
  u16 expRight = (pExpr->pRight->flags & EP_Collate);
  u16 expLeft = (pExpr->pLeft->flags & EP_Collate);
  u16 wtFlags = 0;
  assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN );
  if( expRight==expLeft ){
    /* Either X and Y both have COLLATE operator or neither do */
    if( expRight ){
      /* Both X and Y have COLLATE operators.  Make sure X is always
      ** used by clearing the EP_Collate flag from Y. */
      pExpr->pRight->flags &= ~EP_Collate;
      wtFlags |= TERM_NOPARTIDX;
    }else if( sqlite3ExprCollSeq(pParse, pExpr->pLeft)!=0 ){
      /* Neither X nor Y have COLLATE operators, but X has a non-default
      ** collating sequence.  So add the EP_Collate marker on X to cause
      ** it to be searched first. */
      pExpr->pLeft->flags |= EP_Collate;
      wtFlags |= TERM_NOPARTIDX;
    }
  }
  SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
  if( pExpr->op>=TK_GT ){
    assert( TK_LT==TK_GT+2 );
    assert( TK_GE==TK_LE+2 );
    assert( TK_GT>TK_EQ );
    assert( TK_GT<TK_LE );
    assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
    pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
  }
  return wtFlags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x4(%rax), %eax
andl $0x100, %eax            # imm = 0x100
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
andl $0x100, %eax            # imm = 0x100
movw %ax, -0x14(%rbp)
movw $0x0, -0x16(%rbp)
movzwl -0x12(%rbp), %eax
movzwl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jne 0x969b0
cmpw $0x0, -0x12(%rbp)
je 0x96974
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x4(%rax), %ecx
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
movl %ecx, 0x4(%rax)
movzwl -0x16(%rbp), %eax
orl $0x2000, %eax           # imm = 0x2000
movw %ax, -0x16(%rbp)
jmp 0x969ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5d7b0
cmpq $0x0, %rax
je 0x969ac
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x4(%rax)
movzwl -0x16(%rbp), %eax
orl $0x2000, %eax           # imm = 0x2000
movw %ax, -0x16(%rbp)
jmp 0x969ae
jmp 0x969b0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x36, %eax
jl 0x969fc
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
subl $0x36, %eax
xorl $0x2, %eax
addl $0x36, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movw -0x16(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3IndexAffinityOk
SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
  char aff = comparisonAffinity(pExpr);
  if( aff<SQLITE_AFF_TEXT ){
    return 1;
  }
  if( aff==SQLITE_AFF_TEXT ){
    return idx_affinity==SQLITE_AFF_TEXT;
  }
  return sqlite3IsNumericAffinity(idx_affinity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x989c0
movb %al, -0x12(%rbp)
movsbl -0x12(%rbp), %eax
cmpl $0x42, %eax
jge 0x98980
movl $0x1, -0x4(%rbp)
jmp 0x989af
movsbl -0x12(%rbp), %eax
cmpl $0x42, %eax
jne 0x9899d
movsbl -0x11(%rbp), %eax
cmpl $0x42, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x989af
movsbl -0x11(%rbp), %eax
cmpl $0x43, %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: vtabBestIndex
static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
  sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
  int rc;

  TRACE_IDX_INPUTS(p);
  rc = pVtab->pModule->xBestIndex(pVtab, p);
  TRACE_IDX_OUTPUTS(p);

  if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){
    if( rc==SQLITE_NOMEM ){
      sqlite3OomFault(pParse->db);
    }else if( !pVtab->zErrMsg ){
      sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
    }else{
      sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg);
    }
  }
  sqlite3_free(pVtab->zErrMsg);
  pVtab->zErrMsg = 0;
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x59dd0
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x9aab4
cmpl $0x13, -0x24(%rbp)
je 0x9aab4
cmpl $0x7, -0x24(%rbp)
jne 0x9aa64
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x13fa0
jmp 0x9aab2
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x9aa96
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0x13e80
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x22980(%rip), %rsi     # 0xbd40d
movb $0x0, %al
callq 0x16bd0
jmp 0x9aab0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x22964(%rip), %rsi     # 0xbd40d
movb $0x0, %al
callq 0x16bd0
jmp 0x9aab2
jmp 0x9aab4
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xbad0
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: whereIndexExprTransNode
static int whereIndexExprTransNode(Walker *p, Expr *pExpr){
  IdxExprTrans *pX = p->u.pIdxTrans;
  if( sqlite3ExprCompare(0, pExpr, pX->pIdxExpr, pX->iTabCur)==0 ){
    pExpr->affExpr = sqlite3ExprAffinity(pExpr);
    pExpr->op = TK_COLUMN;
    pExpr->iTable = pX->iIdxCur;
    pExpr->iColumn = pX->iIdxCol;
    pExpr->y.pTab = 0;
    return WRC_Prune;
  }else{
    return WRC_Continue;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
xorl %eax, %eax
movl %eax, %edi
callq 0x79550
cmpl $0x0, %eax
jne 0x9f21a
movq -0x18(%rbp), %rdi
callq 0x78bd0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
movb $-0x5e, (%rax)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9f221
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: tabIsReadOnly
static int tabIsReadOnly(Parse *pParse, Table *pTab){
  sqlite3 *db;
  if( IsVirtual(pTab) ){
    return sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0;
  }
  if( (pTab->tabFlags & (TF_Readonly|TF_Shadow))==0 ) return 0;
  db = pParse->db;
  if( (pTab->tabFlags & TF_Readonly)!=0 ){
    return sqlite3WritableSchema(db)==0 && pParse->nested==0;
  }
  assert( pTab->tabFlags & TF_Shadow );
  return (db->flags & SQLITE_Defensive)!=0 
#ifndef SQLITE_OMIT_VIRTUALTABLE
          && db->pVtabCtx==0
#endif
          && db->nVdbeExec==0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x54(%rax)
je 0xa2ba6
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x59dd0
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpq $0x0, 0x68(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xa2c59
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x401, %eax            # imm = 0x401
cmpl $0x0, %eax
jne 0xa2bc3
movl $0x0, -0x4(%rbp)
jmp 0xa2c59
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa2c10
movq -0x20(%rbp), %rdi
callq 0x321b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jne 0xa2c03
movq -0x10(%rbp), %rax
movzbl 0x1e(%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xa2c59
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
andq $0x10000000, %rcx       # imm = 0x10000000
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x22(%rbp)
je 0xa2c4e
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x1e8(%rcx)
movb %al, -0x22(%rbp)
jne 0xa2c4e
movq -0x20(%rbp), %rax
cmpl $0x0, 0xcc(%rax)
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: isAlterableTable
static int isAlterableTable(Parse *pParse, Table *pTab){
  if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) 
#ifndef SQLITE_OMIT_VIRTUALTABLE
   || ( (pTab->tabFlags & TF_Shadow) 
     && (pParse->db->flags & SQLITE_Defensive)
     && pParse->db->nVdbeExec==0
   )
#endif
  ){
    sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x12e0d(%rip), %rsi     # 0xbf06b
movl $0x7, %edx
callq 0xf210
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0xac2a8
movq -0x18(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0xac2ca
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
andq $0x10000000, %rax       # imm = 0x10000000
cmpq $0x0, %rax
je 0xac2ca
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0xcc(%rax)
jne 0xac2ca
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x14dd8(%rip), %rsi     # 0xc1092
movb $0x0, %al
callq 0x16bd0
movl $0x1, -0x4(%rbp)
jmp 0xac2d1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: renameTestSchema
static void renameTestSchema(Parse *pParse, const char *zDb, int bTemp){
  sqlite3NestedParse(pParse, 
      "SELECT 1 "
      "FROM \"%w\".%s "
      "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
      " AND sql NOT LIKE 'create virtual%%'"
      " AND sqlite_rename_test(%Q, sql, type, name, %d)=NULL ",
      zDb, MASTER_NAME, 
      zDb, bTemp
  );

  if( bTemp==0 ){
    sqlite3NestedParse(pParse, 
        "SELECT 1 "
        "FROM temp.%s "
        "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
        " AND sql NOT LIKE 'create virtual%%'"
        " AND sqlite_rename_test(%Q, sql, type, name, 1)=NULL ",
        MASTER_NAME, zDb 
    );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %r8
movl -0x14(%rbp), %r9d
leaq 0x14d34(%rip), %rsi     # 0xc10ae
leaq 0x11a07(%rip), %rcx     # 0xbdd88
movb $0x0, %al
callq 0x7de90
cmpl $0x0, -0x14(%rbp)
jne 0xac3ab
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq 0x14dad(%rip), %rsi     # 0xc114a
leaq 0x119e4(%rip), %rdx     # 0xbdd88
movb $0x0, %al
callq 0x7de90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: renameWalkWith
static void renameWalkWith(Walker *pWalker, Select *pSelect){
  if( pSelect->pWith ){
    int i;
    for(i=0; i<pSelect->pWith->nCte; i++){
      Select *p = pSelect->pWith->a[i].pSelect;
      NameContext sNC;
      memset(&sNC, 0, sizeof(sNC));
      sNC.pParse = pWalker->pParse;
      sqlite3SelectPrep(sNC.pParse, p, &sNC);
      sqlite3WalkSelect(pWalker, p);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0xb0b76
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x68(%rcx), %rcx
cmpl (%rcx), %eax
jge 0xb0b74
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
addq $0x10, %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x8130
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x812e0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x79100
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb0b02
jmp 0xb0b76
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jkbenaim[P]psfrag/sqlite3.c
// Function: renameTableSelectCb
static int renameTableSelectCb(Walker *pWalker, Select *pSelect){
  int i;
  RenameCtx *p = pWalker->u.pRename;
  SrcList *pSrc = pSelect->pSrc;
  if( pSrc==0 ){
    assert( pWalker->pParse->db->mallocFailed );
    return WRC_Abort;
  }
  for(i=0; i<pSrc->nSrc; i++){
    struct SrcList_item *pItem = &pSrc->a[i];
    if( pItem->pTab==p->pTab ){
      renameTokenFind(pWalker->pParse, p, pItem->zName);
    }
  }
  renameWalkWith(pWalker, pSelect);

  return WRC_Continue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xb0ca8
movl $0x2, -0x4(%rbp)
jmp 0xb0d1c
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xb0d08
movq -0x30(%rbp), %rax
addq $0x8, %rax
movslq -0x1c(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xb0cfb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0xb0120
jmp 0xb0cfd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb0caf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb0ae0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_09/isupper.c
// Function: main
int main(int argc, char *argv[])
{
  if (is_upper_v1('c'))
  {
    puts("is_upper_v1: This letter is uppercase.");
  }
  else
  {
    puts("is_upper_v1: This letter is lowercase.");
  }

  if (is_upper_v2('c'))
  {
    puts("is_upper_v2: This letter is uppercase.");
  }
  else
  {
    puts("is_upper_v2: This letter is lowercase.");
  }

  exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x63, %edi
callq 0x11d0
cmpl $0x0, %eax
je 0x1193
leaq 0xe78(%rip), %rdi       # 0x2004
callq 0x1030
jmp 0x119f
leaq 0xe91(%rip), %rdi       # 0x202b
callq 0x1030
movl $0x63, %edi
callq 0x1200
cmpl $0x0, %eax
je 0x11bc
leaq 0xe9d(%rip), %rdi       # 0x2052
callq 0x1030
jmp 0x11c8
leaq 0xeb6(%rip), %rdi       # 0x2079
callq 0x1030
xorl %edi, %edi
callq 0x1050
nop
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/benchmark.c
// Function: main
int main(int argc, char *argv[])
{

    bench("a+5", a5);
    bench("5+a+5", a55);
    bench("abs(a+5)", a5abs);

    bench("sqrt(a^1.5+a^2.5)", as);
    bench("a+(5*2)", a10);
    bench("(a+5)*2", a52);
    bench("(1/(a+1)+2/(a+2)+3/(a+3))", al);

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x2aa3(%rip), %rdi      # 0x40af
leaq -0x193(%rip), %rsi      # 0x1480
callq 0x11d0
leaq 0x2a8e(%rip), %rdi      # 0x40ad
leaq -0x186(%rip), %rsi      # 0x14a0
callq 0x11d0
leaq 0x2a81(%rip), %rdi      # 0x40b3
leaq -0x169(%rip), %rsi      # 0x14d0
callq 0x11d0
leaq 0x2a77(%rip), %rdi      # 0x40bc
leaq -0x10c(%rip), %rsi      # 0x1540
callq 0x11d0
leaq 0x2a76(%rip), %rdi      # 0x40ce
leaq -0x13f(%rip), %rsi      # 0x1520
callq 0x11d0
leaq 0x2a6b(%rip), %rdi      # 0x40d6
leaq -0x182(%rip), %rsi      # 0x14f0
callq 0x11d0
leaq 0x2a60(%rip), %rdi      # 0x40de
leaq -0xf5(%rip), %rsi       # 0x1590
callq 0x11d0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/growTable.c
// Function: gt_init
int gt_init(
  growTable* self /***< a pointer on an empty growTable */
  ) {

  class_alloc(self->buffer,_GT_INITSIZE_,self->error_message);
  self->sz=_GT_INITSIZE_;
  self->csz=0;
  self->freeze=_FALSE_;  /**< This line added by JL */
  return _SUCCESS_;
}

// Assembly:
subq $0x818, %rsp            # imm = 0x818
movq %rdi, 0x808(%rsp)
movl $0x1000, %edi           # imm = 0x1000
callq 0x8460
movq %rax, %rcx
movq 0x808(%rsp), %rax
movq %rcx, (%rax)
movq 0x808(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x8875
movl $0x1000, 0x804(%rsp) # imm = 0x1000
movq %rsp, %rdi
movl 0x804(%rsp), %ecx
leaq 0x1c97d3(%rip), %rsi    # 0x1d2004
leaq 0x1c97ef(%rip), %rdx    # 0x1d2027
movb $0x0, %al
callq 0x5b9c0
movq 0x808(%rsp), %rdi
addq $0x1c, %rdi
movq %rsp, %r8
leaq 0x1c97df(%rip), %rsi    # 0x1d2034
leaq 0x1c97e5(%rip), %rdx    # 0x1d2041
movl $0x11, %ecx
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x814(%rsp)
jmp 0x88af
movq 0x808(%rsp), %rax
movq $0x1000, 0x8(%rax)      # imm = 0x1000
movq 0x808(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x808(%rsp), %rax
movl $0x0, 0x18(%rax)
movl $0x0, 0x814(%rsp)
movl 0x814(%rsp), %eax
addq $0x818, %rsp            # imm = 0x818
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/growTable.c
// Function: gt_retrieve
int gt_retrieve(
  growTable *self, /**< a growTable*/
  long idx,        /**< index at wich to retrieve the data (in bytes).*/
  long sz,         /**< size of the data (in bytes)*/
  void* data       /**< OUTPUT : data must be allocated to ::sz bytes*/
  ) {
  void *res;

  class_test(idx<0,
	     self->error_message,
	     "don't know what to do with idx=%ld",idx);

  class_test((idx>self->csz) || (idx+sz>self->csz),
	     self->error_message,
	     "not enough data in growTable");

  res=memcpy(data,self->buffer+idx,sz);
  class_test(res!=self->buffer+idx,
	     self->error_message,
	     "cannot retrieve data from the growTable");

  return _SUCCESS_;
}

// Assembly:
subq $0x3048, %rsp           # imm = 0x3048
movq %rdi, 0x3038(%rsp)
movq %rsi, 0x3030(%rsp)
movq %rdx, 0x3028(%rsp)
movq %rcx, 0x3020(%rsp)
cmpq $0x0, 0x3030(%rsp)
jge 0x8ce7
leaq 0x2810(%rsp), %rdi
movq 0x3030(%rsp), %rdx
leaq 0x1c94c0(%rip), %rsi    # 0x1d213d
movb $0x0, %al
callq 0x5b9c0
leaq 0x2010(%rsp), %rdi
leaq 0x2810(%rsp), %rcx
leaq 0x1c93e7(%rip), %rsi    # 0x1d2082
leaq 0x1c943d(%rip), %rdx    # 0x1d20df
movb $0x0, %al
callq 0x5b9c0
movq 0x3038(%rsp), %rdi
addq $0x1c, %rdi
leaq 0x2010(%rsp), %r8
leaq 0x1c9370(%rip), %rsi    # 0x1d2034
leaq 0x1c9495(%rip), %rdx    # 0x1d2160
movl $0x59, %ecx
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x3044(%rsp)
jmp 0x8e69
movq 0x3030(%rsp), %rax
movq 0x3038(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jg 0x8d1b
movq 0x3030(%rsp), %rax
addq 0x3028(%rsp), %rax
movq 0x3038(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jle 0x8d94
leaq 0x1810(%rsp), %rdi
leaq 0x1c9442(%rip), %rsi    # 0x1d216c
movb $0x0, %al
callq 0x5b9c0
leaq 0x1010(%rsp), %rdi
leaq 0x1810(%rsp), %rcx
leaq 0x1c933a(%rip), %rsi    # 0x1d2082
leaq 0x1c943a(%rip), %rdx    # 0x1d2189
movb $0x0, %al
callq 0x5b9c0
movq 0x3038(%rsp), %rdi
addq $0x1c, %rdi
leaq 0x1010(%rsp), %r8
leaq 0x1c92c3(%rip), %rsi    # 0x1d2034
leaq 0x1c93e8(%rip), %rdx    # 0x1d2160
movl $0x5d, %ecx
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x3044(%rsp)
jmp 0x8e69
movq 0x3020(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x3038(%rsp), %rax
movq (%rax), %rsi
addq 0x3030(%rsp), %rsi
movq 0x3028(%rsp), %rdx
callq 0x8300
movq 0x8(%rsp), %rax
movq %rax, 0x3018(%rsp)
movq 0x3018(%rsp), %rax
movq 0x3038(%rsp), %rcx
movq (%rcx), %rcx
addq 0x3030(%rsp), %rcx
cmpq %rcx, %rax
je 0x8e5e
leaq 0x810(%rsp), %rdi
leaq 0x1c93b2(%rip), %rsi    # 0x1d21af
movb $0x0, %al
callq 0x5b9c0
leaq 0x10(%rsp), %rdi
leaq 0x810(%rsp), %rcx
leaq 0x1c926a(%rip), %rsi    # 0x1d2082
leaq 0x1c93b8(%rip), %rdx    # 0x1d21d7
movb $0x0, %al
callq 0x5b9c0
movq 0x3038(%rsp), %rdi
addq $0x1c, %rdi
leaq 0x10(%rsp), %r8
leaq 0x1c91f6(%rip), %rsi    # 0x1d2034
leaq 0x1c931b(%rip), %rdx    # 0x1d2160
movl $0x62, %ecx
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x3044(%rsp)
jmp 0x8e69
movl $0x0, 0x3044(%rsp)
movl 0x3044(%rsp), %eax
addq $0x3048, %rsp           # imm = 0x3048
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/growTable.c
// Function: gt_getSize
int gt_getSize(
  growTable* self,/**< a growTable*/
  long *idx /**< OUTPUT : the size of the growTable ::self*/
  ) {
  class_test(self->csz<0,
	     self->error_message,
	     "growTable does not make sense");
  *idx=self->csz;
  return _SUCCESS_;
}

// Assembly:
subq $0x1018, %rsp           # imm = 0x1018
movq %rdi, 0x1008(%rsp)
movq %rsi, 0x1000(%rsp)
movq 0x1008(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jge 0x8f42
leaq 0x800(%rsp), %rdi
leaq 0x1c9308(%rip), %rsi    # 0x1d21ed
movb $0x0, %al
callq 0x5b9c0
movq %rsp, %rdi
leaq 0x800(%rsp), %rcx
leaq 0x1c9184(%rip), %rsi    # 0x1d2082
leaq 0x1c9306(%rip), %rdx    # 0x1d220b
movb $0x0, %al
callq 0x5b9c0
movq 0x1008(%rsp), %rdi
addq $0x1c, %rdi
movq %rsp, %r8
leaq 0x1c9112(%rip), %rsi    # 0x1d2034
leaq 0x1c92ee(%rip), %rdx    # 0x1d2217
movl $0x7e, %ecx
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x1014(%rsp)
jmp 0x8f64
movq 0x1008(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x1000(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x1014(%rsp)
movl 0x1014(%rsp), %eax
addq $0x1018, %rsp           # imm = 0x1018
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/growTable.c
// Function: gt_free
int gt_free(growTable* self) {
  free(self->buffer);
  self->csz=-1;
  self->sz=-1;
  self->freeze=_FALSE_;  /**< This line added by JL */

  return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq $-0x1, 0x10(%rax)
movq (%rsp), %rax
movq $-0x1, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, 0x18(%rax)
xorl %eax, %eax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/dei_rkck.c
// Function: cleanup_generic_integrator
int cleanup_generic_integrator(struct generic_integrator_workspace * pgi){

  free(pgi->yscal);
  free(pgi->y);
  free(pgi->dydx);

  free(pgi->yerr);
  free(pgi->ytempo);

  free(pgi->ak2);
  free(pgi->ak3);
  free(pgi->ak4);
  free(pgi->ak5);
  free(pgi->ak6);
  free(pgi->ytemp);

  return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x8420
xorl %eax, %eax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_mat_free
int sp_mat_free(sp_mat *A){
	free(A->Ax);
	free(A->Ai);
	free(A->Ap);
	free(A);
	return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x8420
movq (%rsp), %rdi
callq 0x8420
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_num_free
int sp_num_free(sp_num *N){
	sp_mat_free(N->L);
	sp_mat_free(N->U);
	free(N->xi[0]);
	free(N->xi);
	free(N->topvec);
	free(N->pinv);
	free(N->p);
	free(N->q);
	free(N->w);
	free(N->wamd);
	free(N);
	return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xb0e0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xb0e0
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x8420
movq (%rsp), %rdi
callq 0x8420
xorl %eax, %eax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: reachr
int reachr(sp_mat *G, sp_mat *B,int k, int *xik,int *pinv){
	int p, n, top, *Bp, *Bi, *Gp;
	n=G->ncols; Bp = B->Ap; Bi = B->Ai;Gp = G->Ap;
	top = n;
	for (p=Bp[k];p<Bp[k+1];p++){ /* For each entry in the k'th column of B */
		if (!SPMARKED(Gp,Bi[p])){ /* If node is not marked... */
			dfsr(Bi[p],G,&top,xik,pinv); /* ...start a depth first search at this entry.*/
		}
	}
	for (p=top; p<n; p++) SPMARK(Gp, xik[p]);
	return top;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x18(%rsp), %rax
movslq 0x44(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x18(%rsp), %rcx
movl 0x44(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xbaa0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movslq 0x2c(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0xba91
movq 0x10(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %edi
movq 0x50(%rsp), %rsi
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
leaq 0x24(%rsp), %rdx
callq 0xbb00
jmp 0xba93
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xba3a
movl 0x24(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0xbaf0
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
movslq 0x2c(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
xorl %edx, %edx
subl (%rax,%rcx,4), %edx
subl $0x2, %edx
movq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
movslq 0x2c(%rsp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xbaa8
movl 0x24(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: dfsr
void dfsr(int j, sp_mat *G, int *top, int *xik, int *pinv){
	int i, p, p1, p2, jnew, *Gp = G->Ap, *Gi=G->Ai;
	jnew = pinv[j];
	SPMARK(Gp,j);
	if (jnew>=0){	/*We should consider the jnew column.*/
		p1 = SPUNFLIP(Gp[jnew]); /*Get true column pointers of neighbours:*/
		p2 = SPUNFLIP(Gp[jnew+1]);
		for(p=p1; p<p2; p++){ /* Iterate over neighboors */
			i = Gi[p];
			if (!SPMARKED(Gp,i)){ /* If any unmarked neighboors are found... */
				dfsr(i,G,top,xik,pinv); /*... do depth first search from that node. */
			}
		}
	}
	xik[--(*top)] = j; /*Put column value on stack. */
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movslq 0x54(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movslq 0x54(%rsp), %rcx
xorl %edx, %edx
subl (%rax,%rcx,4), %edx
subl $0x2, %edx
movq 0x10(%rsp), %rax
movslq 0x54(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
cmpl $0x0, 0x1c(%rsp)
jl 0xbc62
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0xbb9b
movq 0x10(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
xorl %eax, %eax
subl (%rcx,%rdx,4), %eax
subl $0x2, %eax
movl %eax, 0x4(%rsp)
jmp 0xbbac
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0xbbe5
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
xorl %eax, %eax
subl (%rcx,%rdx,4), %eax
subl $0x2, %eax
movl %eax, (%rsp)
jmp 0xbbfa
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0xbc60
movq 0x8(%rsp), %rax
movslq 0x28(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x2c(%rsp)
movq 0x10(%rsp), %rax
movslq 0x2c(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0xbc51
movl 0x2c(%rsp), %edi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0xbb00
jmp 0xbc53
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xbc09
jmp 0xbc62
movl 0x54(%rsp), %edx
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rsi
movl (%rsi), %ecx
addl $-0x1, %ecx
movl %ecx, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_wclear
int sp_wclear(int mark, int lemax, int *w, int n){
	int k;
	if (mark<2 || (mark+lemax<0)){
		for(k=0; k<n; k++) if(w[k]!=0) w[k] = 1;
		mark = 2;
	}
	return (mark);
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
cmpl $0x2, -0x4(%rsp)
jl 0xe995
movl -0x4(%rsp), %eax
addl -0x8(%rsp), %eax
cmpl $0x0, %eax
jge 0xe9df
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0xe9d7
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0xe9c8
movq -0x10(%rsp), %rax
movslq -0x18(%rsp), %rcx
movl $0x1, (%rax,%rcx,4)
jmp 0xe9ca
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0xe99d
movl $0x2, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_tdfs
int sp_tdfs(int j, int k, int *head, const int *next, int *post, int *stack){
	int i, p, top =0;
	stack[0] = j;
	while(top>=0){
		p = stack[top];
		i = head[p];
		if (i==-1){
			top--;
			post[k++] = p;
		}
		else{
			head[p] = next[i];
			stack[++top] = i;
		}
	}
	return (k);
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
movq %r9, -0x28(%rsp)
movl $0x0, -0x34(%rsp)
movl -0x4(%rsp), %ecx
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x34(%rsp)
jl 0xeab5
movq -0x28(%rsp), %rax
movslq -0x34(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x30(%rsp)
movq -0x10(%rsp), %rax
movslq -0x30(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rsp)
cmpl $-0x1, -0x2c(%rsp)
jne 0xea7c
movl -0x34(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rsp)
movl -0x30(%rsp), %edx
movq -0x20(%rsp), %rax
movl -0x8(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x8(%rsp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xeab0
movq -0x18(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rsp), %rax
movslq -0x30(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rsp), %edx
movq -0x28(%rsp), %rax
movl -0x34(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, -0x34(%rsp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xea1f
movl -0x8(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/evolver_ndf15.c
// Function: lubksb
int lubksb(double **a, int n, int *indx, double b[]){
  int i,ii=0,ip,j;
  double sum;
  for (i=1;i<=n;i++) {
    ip=indx[i];
    sum=b[ip];
    b[ip]=b[i];
    if (ii) for (j=ii;j<=i-1;j++) sum -= a[i][j]*b[j];
    else if (sum) ii=i;
    b[i]=sum;
  }
  for (i=n;i>=1;i--) {
    sum=b[i];
    for (j=i+1;j<=n;j++) sum -= a[i][j]*b[j];
    b[i]=sum/a[i][i];
  }
  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl $0x0, -0x28(%rsp)
movl $0x1, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0xc(%rsp), %eax
jg 0x17216
movq -0x18(%rsp), %rax
movslq -0x24(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rsp)
movq -0x20(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rsp)
movq -0x20(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
cmpl $0x0, -0x28(%rsp)
je 0x171d4
movl -0x28(%rsp), %eax
movl %eax, -0x30(%rsp)
movl -0x30(%rsp), %eax
movl -0x24(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x171d2
movq -0x8(%rsp), %rax
movslq -0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rsp), %rax
movslq -0x30(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rsp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rsp)
movl -0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rsp)
jmp 0x17164
jmp 0x171f1
movsd -0x38(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x171e7
jp 0x171e7
jmp 0x171ef
movl -0x24(%rsp), %eax
movl %eax, -0x28(%rsp)
jmp 0x171f1
movsd -0x38(%rsp), %xmm0
movq -0x20(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x17103
movl -0xc(%rsp), %eax
movl %eax, -0x24(%rsp)
cmpl $0x1, -0x24(%rsp)
jl 0x172ef
movq -0x20(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rsp)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rsp)
movl -0x30(%rsp), %eax
cmpl -0xc(%rsp), %eax
jg 0x172b2
movq -0x8(%rsp), %rax
movslq -0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rsp), %rax
movslq -0x30(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rsp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rsp)
movl -0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rsp)
jmp 0x17249
movsd -0x38(%rsp), %xmm0
movq -0x8(%rsp), %rax
movslq -0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rsp), %rcx
divsd (%rax,%rcx,8), %xmm0
movq -0x20(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x1721e
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/evolver_ndf15.c
// Function: uninitialize_jacobian
int uninitialize_jacobian(struct jacobian *jac){
  free(jac->dfdy[1]);
  free(jac->dfdy);
  free(jac->LU[1]);
  free(jac->LU);

  free(jac->luidx);
  free(jac->LUw);
  free(jac->jacvec);

  if(jac->sparse_stuff_initialized){
    free(jac->xjac);
    free(jac->col_wi);
    free(jac->col_group);
    free(jac->Cp);
    free(jac->Ci);
    sp_mat_free(jac->spJ);
    sp_num_free(jac->Numerical);
  }
  return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x176d1
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x80(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0xb0e0
movq (%rsp), %rax
movq 0x78(%rax), %rdi
callq 0xb930
xorl %eax, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/evolver_ndf15.c
// Function: uninitialize_numjac_workspace
int uninitialize_numjac_workspace(struct numjac_workspace * nj_ws){
  /* Deallocate vectors and matrices: */
  free(nj_ws->yscale);
  free(nj_ws->del);
  free(nj_ws->Difmax);
  free(nj_ws->absFdelRm);
  free(nj_ws->absFvalue);
  free(nj_ws->absFvalueRm);
  free(nj_ws->Fscale);
  free(nj_ws->ffdel);
  free(nj_ws->yydel);
  free(nj_ws->tmp);

  free(nj_ws->ydel_Fdel[1]);
  free(nj_ws->ydel_Fdel);
  free(nj_ws->logj);
  free(nj_ws->Rowmax);
  return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x50(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x8420
xorl %eax, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate_spline_table_line_to_line
int array_integrate_spline_table_line_to_line(
					      double * x_array,
					      int n_lines,
					      double * array,
					      int n_columns,
					      int index_y,
					      int index_ddy,
					      int index_inty,
					      ErrorMsg errmsg) {

  int i;

  double h;

  *(array+0*n_columns+index_inty)  = 0.;

  for (i=0; i < n_lines-1; i++) {

    h = (x_array[i+1]-x_array[i]);

    // the second line ended with an incorrect + sign until v3.2 included (Credits: C. Radermacher)
    *(array+(i+1)*n_columns+index_inty) = *(array+i*n_columns+index_inty) +
      (array[i*n_columns+index_y]+array[(i+1)*n_columns+index_y])*h/2. -
      (array[i*n_columns+index_ddy]+array[(i+1)*n_columns+index_ddy])*h*h*h/24.;

  }

  return _SUCCESS_;
}

// Assembly:
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %eax
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl %r8d, -0x20(%rsp)
movl %r9d, -0x24(%rsp)
movq -0x18(%rsp), %rax
imull $0x0, -0x1c(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq 0x8(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1ade7
movq -0x8(%rsp), %rax
movl -0x28(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movslq -0x28(%rsp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rsp)
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
imull -0x1c(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
imull -0x1c(%rsp), %ecx
addl -0x20(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
addl $0x1, %ecx
imull -0x1c(%rsp), %ecx
addl -0x20(%rsp), %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm1
mulsd -0x30(%rsp), %xmm1
movsd 0x1b7f2f(%rip), %xmm2   # 0x1d2c80
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
imull -0x1c(%rsp), %ecx
addl -0x24(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
addl $0x1, %ecx
imull -0x1c(%rsp), %ecx
addl -0x24(%rsp), %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm1
mulsd -0x30(%rsp), %xmm1
mulsd -0x30(%rsp), %xmm1
mulsd -0x30(%rsp), %xmm1
movsd 0x1b88e6(%rip), %xmm2   # 0x1d3690
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movl -0x28(%rsp), %ecx
addl $0x1, %ecx
imull -0x1c(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x1acae
xorl %eax, %eax
retq
nopw (%rax,%rax)