LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3TableAffinity
SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
  int i;
  char *zColAff = pTab->zColAff;
  if( zColAff==0 ){
    sqlite3 *db = sqlite3VdbeDb(v);
    zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
    if( !zColAff ){
      sqlite3OomFault(db);
      return;
    }

    for(i=0; i<pTab->nCol; i++){
      assert( pTab->aCol[i].affinity!=0 );
      zColAff[i] = pTab->aCol[i].affinity;
    }
    do{
      zColAff[i--] = 0;
    }while( i>=0 && zColAff[i]<=SQLITE_AFF_BLOB );
    pTab->zColAff = zColAff;
  }
  assert( zColAff!=0 );
  i = sqlite3Strlen30NN(zColAff);
  if( i ){
    if( iReg ){
      sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);
    }else{
      sqlite3VdbeChangeP4(v, -1, zColAff, i);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
movq 0x28(%rsi), %r14
testq %r14, %r14
jne 0x5b434
movq %rsi, %r15
movq (%rbx), %r12
movswq 0x46(%rsi), %rdi
incq %rdi
callq 0xa93b
testq %rax, %rax
je 0x5b408
movq %rax, %r14
cmpw $0x0, 0x46(%r15)
jle 0x5b418
movl $0x19, %ecx
xorl %eax, %eax
movq 0x8(%r15), %rdx
movb (%rdx,%rcx), %dl
movb %dl, (%r14,%rax)
incq %rax
movswq 0x46(%r15), %rdx
addq $0x20, %rcx
cmpq %rdx, %rax
jl 0x5b3ea
jmp 0x5b41a
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10d8c
xorl %eax, %eax
movb $0x0, (%r14,%rax)
testq %rax, %rax
jle 0x5b430
cmpb $0x42, -0x1(%r14,%rax)
leaq -0x1(%rax), %rax
jl 0x5b41a
movq %r14, 0x28(%r15)
movq %r14, %rdi
callq 0x80b0
movq %rax, %r15
andl $0x3fffffff, %r15d      # imm = 0x3FFFFFFF
je 0x5b468
testl %ebp, %ebp
je 0x5b471
movq %rbx, %rdi
movl $0x5b, %esi
movl %ebp, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x40bac
movq %rbx, %rdi
movl %eax, %esi
jmp 0x5b479
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
movl %r15d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x13c12
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: exprSrcCount
static int exprSrcCount(Walker *pWalker, Expr *pExpr){
  /* The NEVER() on the second term is because sqlite3FunctionUsesThisSrc()
  ** is always called before sqlite3ExprAnalyzeAggregates() and so the
  ** TK_COLUMNs have not yet been converted into TK_AGG_COLUMN.  If
  ** sqlite3FunctionUsesThisSrc() is used differently in the future, the
  ** NEVER() will need to be removed. */
  if( pExpr->op==TK_COLUMN || NEVER(pExpr->op==TK_AGG_COLUMN) ){
    int i;
    struct SrcCount *p = pWalker->u.pSrcCount;
    SrcList *pSrc = p->pSrc;
    int nSrc = pSrc ? pSrc->nSrc : 0;
    for(i=0; i<nSrc; i++){
      if( pExpr->iTable==pSrc->a[i].iCursor ) break;
    }
    if( i<nSrc ){
      p->nThis++;
    }else if( nSrc==0 || pExpr->iTable<pSrc->a[0].iCursor ){
      /* In a well-formed parse tree (no name resolution errors),
      ** TK_COLUMN nodes with smaller Expr.iTable values are in an
      ** outer context.  Those are the only ones to count as "other" */
      p->nOther++;
    }
  }
  return WRC_Continue;
}

// Assembly:
movzbl (%rsi), %eax
cmpl $0xa4, %eax
je 0x5db60
cmpl $0xa2, %eax
jne 0x5dba2
movq 0x28(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x5db9a
movslq (%rcx), %rdx
testq %rdx, %rdx
jle 0x5db8e
movl 0x2c(%rsi), %edi
imulq $0x70, %rdx, %r8
xorl %r9d, %r9d
cmpl 0x48(%rcx,%r9), %edi
je 0x5db9f
addq $0x70, %r9
cmpq %r9, %r8
jne 0x5db7e
testl %edx, %edx
je 0x5db9a
movl 0x2c(%rsi), %edx
cmpl 0x48(%rcx), %edx
jge 0x5dba2
incl 0xc(%rax)
jmp 0x5dba2
incl 0x8(%rax)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: renameUnmapSelectCb
static int renameUnmapSelectCb(Walker *pWalker, Select *p){
  Parse *pParse = pWalker->pParse;
  int i;
  if( ALWAYS(p->pEList) ){
    ExprList *pList = p->pEList;
    for(i=0; i<pList->nExpr; i++){
      if( pList->a[i].zName ){
        sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zName);
      }
    }
  }
  if( ALWAYS(p->pSrc) ){  /* Every Select as a SrcList, even if it is empty */
    SrcList *pSrc = p->pSrc;
    for(i=0; i<pSrc->nSrc; i++){
      sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
    }
  }
  return WRC_Continue;
}

// Assembly:
movq (%rdi), %rax
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x60366
movslq (%rcx), %rdx
testq %rdx, %rdx
jle 0x60366
addq $0x8, %rcx
xorl %edi, %edi
movq %rdi, %r8
shlq $0x5, %r8
movq 0x8(%rcx,%r8), %r8
testq %r8, %r8
je 0x6035e
movq 0x198(%rax), %r9
testq %r9, %r9
je 0x6035e
cmpq %r8, (%r9)
je 0x60357
movq 0x18(%r9), %r9
jmp 0x60347
movq $0x0, (%r9)
incq %rdi
cmpq %rdx, %rdi
jne 0x6032f
movq 0x28(%rsi), %rcx
testq %rcx, %rcx
je 0x603b1
movslq (%rcx), %rdx
testq %rdx, %rdx
jle 0x603b1
addq $0x8, %rcx
xorl %esi, %esi
movq 0x198(%rax), %rdi
testq %rdi, %rdi
je 0x603a9
imulq $0x70, %rsi, %r8
movq 0x10(%rcx,%r8), %r8
cmpq %r8, (%rdi)
je 0x603a2
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x60392
jmp 0x603a9
movq $0x0, (%rdi)
incq %rsi
cmpq %rdx, %rsi
jne 0x6037d
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: destroyRootPage
static void destroyRootPage(Parse *pParse, int iTable, int iDb){
  Vdbe *v = sqlite3GetVdbe(pParse);
  int r1 = sqlite3GetTempReg(pParse);
  if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
  sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
  sqlite3MayAbort(pParse);
#ifndef SQLITE_OMIT_AUTOVACUUM
  /* OP_Destroy stores an in integer r1. If this integer
  ** is non-zero, then it is the root page number of a table moved to
  ** location iTable. The following code modifies the sqlite_master table to
  ** reflect this.
  **
  ** The "#NNN" in the SQL is a special constant that means whatever value
  ** is in register NNN.  See grammar rules associated with the TK_REGISTER
  ** token for additional information.
  */
  sqlite3NestedParse(pParse, 
     "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d",
     pParse->db->aDb[iDb].zDbSName, MASTER_NAME, iTable, r1, r1);
#endif
  sqlite3ReleaseTempReg(pParse, r1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
callq 0x54856
movq %rax, %r12
movb 0x1f(%rbx), %al
testb %al, %al
je 0x619df
decb %al
movb %al, 0x1f(%rbx)
movzbl %al, %eax
movl 0xcc(%rbx,%rax,4), %ebp
jmp 0x619e7
movl 0x38(%rbx), %ebp
incl %ebp
movl %ebp, 0x38(%rbx)
cmpl $0x1, %r14d
jg 0x619fe
leaq 0x2d469(%rip), %rsi     # 0x8ee5d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x13932
movq %r12, %rdi
movl $0x88, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %r15d, %r8d
callq 0x40bac
movq 0xa0(%rbx), %rax
testq %rax, %rax
cmoveq %rbx, %rax
movb $0x1, 0x21(%rax)
movq (%rbx), %rax
movq 0x20(%rax), %rax
movslq %r15d, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rdx
movl %ebp, (%rsp)
leaq 0x2d42b(%rip), %rsi     # 0x8ee6c
leaq 0x2b372(%rip), %rcx     # 0x8cdba
movq %rbx, %rdi
movl %r14d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x5b6b1
testl %ebp, %ebp
je 0x61a73
movzbl 0x1f(%rbx), %eax
cmpq $0x7, %rax
ja 0x61a73
leal 0x1(%rax), %ecx
movb %cl, 0x1f(%rbx)
movl %ebp, 0xcc(%rbx,%rax,4)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprImpliesNonNullRow
SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr *p, int iTab){
  Walker w;
  p = sqlite3ExprSkipCollateAndLikely(p);
  while( p ){
    if( p->op==TK_NOTNULL ){
      p = p->pLeft;
    }else if( p->op==TK_AND ){
      if( sqlite3ExprImpliesNonNullRow(p->pLeft, iTab) ) return 1;
      p = p->pRight;
    }else{
      break;
    }
  }
  w.xExprCallback = impliesNotNullRow;
  w.xSelectCallback = 0;
  w.xSelectCallback2 = 0;
  w.eCode = 0;
  w.u.iCur = iTab;
  sqlite3WalkExpr(&w, p);
  return w.eCode;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x6222a
movl %esi, %ebp
movq %rdi, %r14
movl 0x4(%r14), %eax
testl $0x41000, %eax          # imm = 0x41000
je 0x621c6
btl $0x12, %eax
jb 0x621b4
addq $0x10, %r14
jmp 0x621bc
movq 0x20(%r14), %r14
addq $0x8, %r14
movq (%r14), %r14
testq %r14, %r14
jne 0x6219d
jmp 0x6222a
movzbl (%r14), %eax
movl $0x10, %ecx
cmpl $0x33, %eax
je 0x621ed
cmpl $0x2c, %eax
jne 0x621f8
movq 0x10(%r14), %rdi
movl %ebp, %esi
callq 0x62185
movl $0x18, %ecx
testl %eax, %eax
jne 0x62225
movq (%r14,%rcx), %r14
testq %r14, %r14
jne 0x621c6
jmp 0x6222a
leaq 0x6c51(%rip), %rax      # 0x68e50
movq %rsp, %rbx
movq %rax, 0x8(%rbx)
movb $0x0, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movl %ebp, 0x28(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x585aa
movzbl 0x24(%rbx), %ebx
jmp 0x6222a
movl $0x1, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jkbenaim[P]psfrag/sqlite3.c
// Function: sqlite3ExprAnalyzeAggregates
SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
  Walker w;
  w.xExprCallback = analyzeAggregate;
  w.xSelectCallback = analyzeAggregatesInSelect;
  w.xSelectCallback2 = analyzeAggregatesInSelectEnd;
  w.walkerDepth = 0;
  w.u.pNC = pNC;
  w.pParse = 0;
  assert( pNC->pSrcList!=0 );
  sqlite3WalkExpr(&w, pExpr);
}

// Assembly:
subq $0x38, %rsp
leaq 0xe645(%rip), %rax      # 0x76642
movq %rax, 0x10(%rsp)
leaq 0xe8af(%rip), %rax      # 0x768b8
movq %rax, 0x18(%rsp)
leaq 0xe8a9(%rip), %rax      # 0x768be
movq %rax, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq $0x0, 0x8(%rsp)
testq %rsi, %rsi
je 0x6803f
leaq 0x8(%rsp), %rdi
callq 0x585aa
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, 0x4(%rsp)
movq %rsi, %rbx
testq %rdx, %rdx
je 0x68ce0
movq %rdx, %r14
movq %rdi, %r15
testq %rbx, %rbx
je 0x68c64
movslq (%rbx), %r12
jmp 0x68c67
xorl %r12d, %r12d
cmpl $0x0, (%r14)
jle 0x68ce0
shlq $0x5, %r12
movl $0x20, %r13d
xorl %ebp, %ebp
movq -0x18(%r14,%r13), %rsi
testq %rsi, %rsi
je 0x68caf
movq (%r15), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x59f79
movq %rax, %rdx
cmpl $0x0, 0x4(%rsp)
je 0x68cb1
testq %rdx, %rdx
je 0x68cb1
cmpb $-0x6a, (%rdx)
jne 0x68cb1
movb $0x75, (%rdx)
andl $0xcffffbff, 0x4(%rdx)  # imm = 0xCFFFFBFF
jmp 0x68cb1
xorl %edx, %edx
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x4a6a3
movq %rax, %rbx
testq %rax, %rax
je 0x68cd1
movb (%r14,%r13), %al
leaq (%rbx,%r12), %rcx
movb %al, (%r13,%rcx)
incq %rbp
movslq (%r14), %rax
addq $0x20, %r13
cmpq %rax, %rbp
jl 0x68c79
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq 0x8(%rdi), %rax
movq 0x10(%rdi), %rsi
testq %rax, %rax
jle 0x69d8d
movl 0x2c(%r15), %ecx
movq %rax, %rdx
shlq $0x4, %rdx
xorl %edi, %edi
movq (%rsi,%rdi), %r8
cmpl %ecx, 0x2c(%r8)
jne 0x69d84
movzwl 0x30(%r8), %r8d
cmpw 0x30(%r15), %r8w
je 0x69de0
addq $0x10, %rdi
cmpq %rdi, %rdx
jne 0x69d6e
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%r14)
movq (%r14), %rcx
movq (%rcx), %rdi
leal 0x2(,%rax,2), %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x2a832
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x69dd8
testb $0x8, 0x4(%rbx)
je 0x69dc0
movq 0x10(%rbx), %rbx
movslq 0x8(%r14), %rcx
shlq $0x4, %rcx
movq %r15, -0x10(%rax,%rcx)
movq 0x10(%r14), %rax
movq %rbx, -0x8(%rax,%rcx)
jmp 0x69de0
movl $0x0, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x5840e
movq 0x18(%r14), %rdi
testq %rdi, %rdi
jne 0x700cc
testb $0x8, 0x5(%r14)
jne 0x700c1
testb %al, %al
jne 0x700d4
movb $0x1, %cl
jmp 0x700ea
movq 0x20(%r14), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rdi
movsbl %al, %esi
callq 0x584a7
movb $0x1, %cl
cmpb $0x42, %al
jl 0x700ea
jne 0x700e4
cmpb $0x42, %bl
sete %cl
jmp 0x700ea
cmpb $0x43, %bl
setge %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x28(%rdi), %r15
movq (%r15), %rdx
movl 0x8(%r15), %ecx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x588b0
testl %eax, %eax
jne 0x743d5
movq %rbx, %rdi
callq 0x5840e
movb %al, 0x1(%rbx)
movb $-0x5e, (%rbx)
movl 0xc(%r15), %eax
movl %eax, 0x2c(%rbx)
movzwl 0x10(%r15), %eax
movw %ax, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x7f0eb
xorl %ecx, %ecx
leaq 0x8da9(%rip), %rax      # 0x87e50
leaq 0xefde(%rip), %r8       # 0x8e08c
movzbl (%rdx,%rcx), %r9d
testq %r9, %r9
je 0x7f0d6
movzbl (%r9,%rax), %r9d
movzbl (%rcx,%r8), %r10d
movb (%r10,%rax), %r10b
cmpb %r10b, %r9b
jne 0x7f0e2
incq %rcx
cmpq $0x7, %rcx
jne 0x7f0ae
jmp 0x7f105
movzbl (%rcx,%r8), %ecx
movb (%rcx,%rax), %r10b
xorl %r9d, %r9d
movzbl %r10b, %eax
cmpl %eax, %r9d
je 0x7f105
xorl %eax, %eax
testb $0x4, 0x41(%rsi)
je 0x7f118
movq (%rdi), %rcx
testb $0x10, 0x33(%rcx)
je 0x7f118
cmpl $0x0, 0xcc(%rcx)
jne 0x7f118
leaq 0x10fa7(%rip), %rsi     # 0x900b3
xorl %eax, %eax
callq 0x13932
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10f31(%rip), %rsi     # 0x900cf
leaq 0xdc15(%rip), %rcx      # 0x8cdba
movq %rbx, %rdx
movq %rbx, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x5b6b1
testl %ebp, %ebp
je 0x7f1be
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10fa6(%rip), %rsi     # 0x9016b
leaq 0xdbee(%rip), %rdx      # 0x8cdba
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x5b6b1
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x68(%rsi), %rax
testq %rax, %rax
je 0x82cb9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x0, (%rax)
jle 0x82cab
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20, %r13d
leaq 0x8(%rsp), %rbp
xorl %r15d, %r15d
movq (%rax,%r13), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbp)
movups %xmm0, 0x10(%rbp)
movups %xmm0, (%rbp)
movq (%r14), %rdi
movq %rdi, (%rsp)
movq %r12, %rsi
movq %rsp, %rdx
callq 0x5dba8
movq %r14, %rdi
movq %r12, %rsi
callq 0x58679
incq %r15
movq 0x68(%rbx), %rax
movslq (%rax), %rcx
addq $0x20, %r13
cmpq %rcx, %r15
jl 0x82c68
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x82dab
pushq %rax
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x82d9f
movq 0x28(%rdi), %rdx
addq $0x8, %rax
xorl %r8d, %r8d
imulq $0x70, %r8, %r11
movq 0x20(%rax,%r11), %r9
cmpq 0x10(%rdx), %r9
jne 0x82d97
movq (%rdi), %r10
movq 0x198(%r10), %r9
testq %r9, %r9
je 0x82d97
addq %rax, %r11
movq 0x10(%r11), %r11
cmpq %r11, (%r9)
je 0x82d7c
movq %r9, %r10
movq 0x18(%r9), %r9
testq %r9, %r9
je 0x82d97
cmpq %r11, (%r9)
jne 0x82d65
addq $0x18, %r10
jmp 0x82d83
addq $0x198, %r10            # imm = 0x198
movq 0x18(%r9), %r11
movq %r11, (%r10)
movq (%rdx), %r10
movq %r10, 0x18(%r9)
movq %r9, (%rdx)
incl 0x8(%rdx)
incq %r8
cmpq %rcx, %r8
jne 0x82d3b
callq 0x82c38
xorl %eax, %eax
addq $0x8, %rsp
retq
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
leaq 0x1b99(%rip), %rdi      # 0x30b9
leaq -0xdb(%rip), %rsi       # 0x144c
callq 0x11dc
leaq 0x1b84(%rip), %rdi      # 0x30b7
leaq -0xe5(%rip), %rsi       # 0x1455
callq 0x11dc
leaq 0x1b77(%rip), %rdi      # 0x30bd
leaq -0xe7(%rip), %rsi       # 0x1466
callq 0x11dc
leaq 0x1b6d(%rip), %rdi      # 0x30c6
leaq -0xd3(%rip), %rsi       # 0x148d
callq 0x11dc
leaq 0x1b6c(%rip), %rdi      # 0x30d8
leaq -0xef(%rip), %rsi       # 0x1484
callq 0x11dc
leaq 0x1b61(%rip), %rdi      # 0x30e0
leaq -0x10f(%rip), %rsi      # 0x1477
callq 0x11dc
leaq 0x1b56(%rip), %rdi      # 0x30e8
leaq -0xba(%rip), %rsi       # 0x14df
callq 0x11dc
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_at_z
int harmonic_pk_at_z(
                     struct background * pba,
                     struct harmonic * phr,
                     enum linear_or_logarithmic mode,
                     double z,
                     double * output_tot,    /* array with argument output_tot[index_k] (must be already allocated) */
                     double * output_ic,     /* array with argument output_tot[index_k * phr->ic_ic_size[index_md] + index_ic1_ic2] (must be already allocated only if more than one initial condition) */
                     double * output_cb_tot, /* same as output_tot for the baryon+CDM only */
                     double * output_cb_ic   /* same as output_ic  for the baryon+CDM only */
                     ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_pk_at_z() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_at_z() instead.\n");

  class_call(fourier_pks_at_z(
                              pba,
                              phr->pfo,
                              mode,
                              pk_linear,
                              z,
                              output_tot,
                              output_ic,
                              output_cb_tot,
                              output_cb_ic
                              ),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %r9, 0x8(%rsp)
movq %r8, %r15
movq %rcx, %r12
movsd %xmm0, (%rsp)
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1400e4(%rip), %rax    # 0x148fb8
movq (%rax), %rcx
leaq 0x118dc9(%rip), %rdi    # 0x121ca7
pushq $0x1
popq %rdx
movl $0x97, %esi
callq 0x86d0
movq 0xe0(%rbx), %rsi
xorl %ebp, %ebp
movq %r14, %rdi
movl %r13d, %edx
xorl %ecx, %ecx
movsd (%rsp), %xmm0
movq %r12, %r8
movq %r15, %r9
pushq 0x850(%rsp)
pushq 0x10(%rsp)
callq 0x9dc3f
popq %rcx
popq %rdx
cmpl $0x1, %eax
jne 0x8f71
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe54bf(%rip), %rsi     # 0xee3f0
leaq 0x118e07(%rip), %rdx    # 0x121d3f
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0xe50df(%rip), %rsi     # 0xee034
leaq 0x118e4d(%rip), %rdx    # 0x121da9
movq %rbx, %rdi
movl $0x571, %ecx            # imm = 0x571
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_at_k_and_z
int harmonic_pk_at_k_and_z(
                           struct background * pba,
                           struct primordial * ppm,
                           struct harmonic * phr,
                           double k,
                           double z,
                           double * pk_tot,    /* pointer to a single number (must be already allocated) */
                           double * pk_ic,     /* array of argument pk_ic[index_ic1_ic2]
                                                  (must be already allocated only if several initial conditions) */
                           double * pk_cb_tot, /* same as pk_tot for baryon+CDM part only */
                           double * pk_cb_ic   /* same as pk_ic  for baryon+CDM part only */
                           ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_pk_at_k_and_z() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_linear_at_k_and_z() instead.\n");

  class_call(fourier_pks_at_k_and_z(pba,
                                    ppm,
                                    phr->pfo,
                                    pk_linear,
                                    k,
                                    z,
                                    pk_tot,
                                    pk_ic,
                                    pk_cb_tot,
                                    pk_cb_ic),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %r9, 0x18(%rsp)
movq %r8, %r15
movq %rcx, %r12
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq 0x13fffb(%rip), %rax    # 0x148fb8
movq (%rax), %rcx
leaq 0x118df3(%rip), %rdi    # 0x121dba
pushq $0x1
popq %rdx
movl $0xaa, %esi
callq 0x86d0
movq 0xe0(%rbx), %rdx
xorl %ebp, %ebp
movq %r14, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r12, %r8
movq %r15, %r9
pushq 0x860(%rsp)
pushq 0x20(%rsp)
callq 0x9e7de
popq %rcx
popq %rdx
cmpl $0x1, %eax
jne 0x9061
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe53cf(%rip), %rsi     # 0xee3f0
leaq 0x118e3d(%rip), %rdx    # 0x121e65
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0xe4fef(%rip), %rsi     # 0xee034
leaq 0x118e79(%rip), %rdx    # 0x121ec5
movq %rbx, %rdi
movl $0x5a2, %ecx            # imm = 0x5A2
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_nl_at_z
int harmonic_pk_nl_at_z(
                        struct background * pba,
                        struct harmonic * phr,
                        enum linear_or_logarithmic mode,
                        double z,
                        double * output_tot,   /* array with argument output_tot[index_k] (must be already allocated) */
                        double * output_cb_tot
                        ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_pk_nl_at_z() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_at_z() instead.\n");

  class_call(fourier_pks_at_z(pba,
                              phr->pfo,
                              mode,
                              pk_nonlinear,
                              z,
                              output_tot,
                              NULL,
                              output_cb_tot,
                              NULL
                              ),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %r8, %r14
movq %rcx, %r15
movsd %xmm0, 0x18(%rsp)
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r13
movq 0x13ff16(%rip), %rax    # 0x148fb8
movq (%rax), %rcx
leaq 0x118e30(%rip), %rdi    # 0x121edc
pushq $0x1
popq %rdx
movl $0x9a, %esi
callq 0x86d0
movq 0xe0(%rbx), %rsi
movq %r14, (%rsp)
andq $0x0, 0x8(%rsp)
xorl %r14d, %r14d
pushq $0x1
popq %rbp
movq %r13, %rdi
movl %r12d, %edx
movl %ebp, %ecx
movsd 0x18(%rsp), %xmm0
movq %r15, %r8
xorl %r9d, %r9d
callq 0x9dc3f
cmpl $0x1, %eax
jne 0x9141
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe52ef(%rip), %rsi     # 0xee3f0
leaq 0x118e6f(%rip), %rdx    # 0x121f77
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0xe4f0f(%rip), %rsi     # 0xee034
leaq 0x118eae(%rip), %rdx    # 0x121fda
movq %rbx, %rdi
movl $0x5cb, %ecx            # imm = 0x5CB
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl %ebp, %r14d
movl %r14d, %eax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_pk_nl_at_k_and_z
int harmonic_pk_nl_at_k_and_z(
                              struct background * pba,
                              struct primordial * ppm,
                              struct harmonic * phr,
                              double k,
                              double z,
                              double * pk_tot,   /* pointer to a single number (must be already allocated) */
                              double * pk_cb_tot /* same as pk_tot for baryon+CDM only */
                              ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_pk_nl_at_k_and_z() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_at_k_and_z() instead.\n");

  class_call(fourier_pks_at_k_and_z(pba,
                                    ppm,
                                    phr->pfo,
                                    pk_nonlinear,
                                    k,
                                    z,
                                    pk_tot,
                                    NULL,
                                    pk_cb_tot,
                                    NULL
                                    ),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movq %r8, %r15
movq %rcx, %r14
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movq 0x13fe2f(%rip), %rax    # 0x148fb8
movq (%rax), %rcx
leaq 0x118e5b(%rip), %rdi    # 0x121fee
pushq $0x1
popq %rdx
movl $0xa6, %esi
callq 0x86d0
movq 0xe0(%rbx), %rdx
andq $0x0, 0x8(%rsp)
movq %r15, (%rsp)
xorl %r15d, %r15d
pushq $0x1
popq %rbp
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %ecx
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq %r14, %r8
xorl %r9d, %r9d
callq 0x9e7de
cmpl $0x1, %eax
jne 0x922e
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe5202(%rip), %rsi     # 0xee3f0
leaq 0x118ea0(%rip), %rdx    # 0x122095
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0xe4e22(%rip), %rsi     # 0xee034
leaq 0x118edf(%rip), %rdx    # 0x1220f8
movq %rbx, %rdi
movl $0x5f8, %ecx            # imm = 0x5F8
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl %ebp, %r15d
movl %r15d, %eax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_fast_pk_at_kvec_and_zvec
int harmonic_fast_pk_at_kvec_and_zvec(
                                      struct background * pba,
                                      struct harmonic * phr,
                                      double * kvec,
                                      int kvec_size,
                                      double * zvec,
                                      int zvec_size,
                                      double * pk_tot_out, // pk_tot_out[index_zvec*kvec_size+index_kvec],
                                                           // already allocated
                                                           //(or NULL if user knows there is no _m output)
                                      double * pk_cb_tot_out, // idem
                                      int nonlinear
                                      ) {
  enum pk_outputs pk_output;

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_fast_pks_at_kvec_and_zvec() which is deprecated since v2.8. It will soon be removed. Use fourier_pk_at_kvec_and_zvec() instead.\n");

  if (nonlinear == _TRUE_)
    pk_output = pk_nonlinear;
  else
    pk_output = pk_linear;

  class_call(fourier_pks_at_kvec_and_zvec(
                                          pba,
                                          phr->pfo,
                                          pk_output,
                                          kvec,
                                          kvec_size,
                                          zvec,
                                          zvec_size,
                                          pk_tot_out,
                                          pk_cb_tot_out),
             phr->pfo->error_message,
             phr->error_message);

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x828, %rsp            # imm = 0x828
movl %r9d, %r15d
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movq 0x13fd4c(%rip), %rax    # 0x148fb8
movq (%rax), %rcx
leaq 0x118e9c(%rip), %rdi    # 0x122112
pushq $0x1
popq %rdx
movl $0xb5, %esi
callq 0x86d0
xorl %edx, %edx
cmpl $0x1, 0x870(%rsp)
sete %dl
movq 0xe0(%rbx), %rsi
movaps 0x860(%rsp), %xmm0
movups %xmm0, 0x8(%rsp)
movl %r15d, (%rsp)
movq %r13, %rdi
movq %r12, %rcx
movl %ebp, %r8d
movq %r14, %r9
callq 0x9e928
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x9315
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe511b(%rip), %rsi     # 0xee3f0
leaq 0x118eec(%rip), %rdx    # 0x1221c8
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0xe4d3b(%rip), %rsi     # 0xee034
leaq 0x118f3d(%rip), %rdx    # 0x12223d
movq %rbx, %rdi
movl $0x632, %ecx            # imm = 0x632
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
pushq $0x1
popq %rax
addq $0x828, %rsp            # imm = 0x828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_sigma
int harmonic_sigma(
                   struct background * pba,
                   struct primordial * ppm,
                   struct harmonic * phr,
                   double R,
                   double z,
                   double * sigma
                   ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_sigma() which is deprecated since v2.8. It will soon be removed. Use fourier_sigmas_at_z() instead.\n");

  if (phr->pfo->has_pk_m) {

    class_call(fourier_sigma_at_z(pba,
                                  phr->pfo,
                                  R,
                                  z,
                                  phr->pfo->index_pk_m,
                                  80., // hardcoded, yes, but the function is deprecated...
                                  sigma),
               phr->pfo->error_message,
               phr->error_message);

  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %rcx, %r14
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rdi, %r15
movq 0x13fc69(%rip), %rax    # 0x148fb8
movq (%rax), %rcx
leaq 0x118f06(%rip), %rdi    # 0x12225f
pushq $0x1
popq %rdx
movl $0x99, %esi
callq 0x86d0
movq 0xe0(%rbx), %rsi
xorl %ebp, %ebp
cmpw $0x0, 0x50(%rsi)
je 0x93ef
movl 0x54(%rsi), %edx
movsd 0x1180d7(%rip), %xmm2   # 0x121458
movq %r15, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rcx
callq 0xa3bfd
cmpl $0x1, %eax
jne 0x93ef
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe5041(%rip), %rsi     # 0xee3f0
leaq 0x118f43(%rip), %rdx    # 0x1222f9
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0xe4c61(%rip), %rsi     # 0xee034
leaq 0x118f69(%rip), %rdx    # 0x122343
movq %rbx, %rdi
movl $0x65b, %ecx            # imm = 0x65B
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../source/harmonic.c
// Function: harmonic_sigma_cb
int harmonic_sigma_cb(
                      struct background * pba,
                      struct primordial * ppm,
                      struct harmonic * phr,
                      double R,
                      double z,
                      double * sigma_cb
                      ) {

  fprintf(stderr," -> [WARNING:] You are calling the function harmonic_sigma_cb() which is deprecated since v2.8. It will soon be removed. Use fourier_sigmas_at_z() instead.\n");

  if (phr->pfo->has_pk_cb) {

    class_call(fourier_sigma_at_z(pba,
                                  phr->pfo,
                                  R,
                                  z,
                                  phr->pfo->index_pk_cb,
                                  80., // hardcoded, yes, but the function is deprecated...
                                  sigma_cb),
               phr->pfo->error_message,
               phr->error_message);
  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %rcx, %r14
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rdi, %r15
movq 0x13fb91(%rip), %rax    # 0x148fb8
movq (%rax), %rcx
leaq 0x118f21(%rip), %rdi    # 0x122352
pushq $0x1
popq %rdx
movl $0x9c, %esi
callq 0x86d0
movq 0xe0(%rbx), %rsi
xorl %ebp, %ebp
cmpw $0x0, 0x52(%rsi)
je 0x94c7
movl 0x58(%rsi), %edx
movsd 0x117fff(%rip), %xmm2   # 0x121458
movq %r15, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rcx
callq 0xa3bfd
cmpl $0x1, %eax
jne 0x94c7
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe4f69(%rip), %rsi     # 0xee3f0
leaq 0x118f61(%rip), %rdx    # 0x1223ef
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
addq $0xea, %rbx
leaq 0xe4b89(%rip), %rsi     # 0xee034
leaq 0x118f8b(%rip), %rdx    # 0x12243d
movq %rbx, %rdi
movl $0x686, %ecx            # imm = 0x686
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rdi, %rbx
movl $0x1000, %edi           # imm = 0x1000
callq 0x8460
movq %rax, (%rbx)
testq %rax, %rax
je 0x9cb6
movq $0x1000, 0x8(%rbx)      # imm = 0x1000
movq $0x0, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
xorl %eax, %eax
jmp 0x9cff
leaq 0xe4347(%rip), %rsi     # 0xee004
leaq 0xe4363(%rip), %rdx     # 0xee027
movq %rsp, %r14
movq %r14, %rdi
movl $0x1000, %ecx           # imm = 0x1000
xorl %eax, %eax
callq 0x30af0
addq $0x1c, %rbx
leaq 0xe4353(%rip), %rsi     # 0xee034
leaq 0xe4359(%rip), %rdx     # 0xee041
movq %rbx, %rdi
movl $0x11, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
js 0x9f95
movq %rcx, %r15
movq 0x10(%rbx), %rax
cmpq %r14, %rax
setl %cl
leaq (%rdx,%r14), %rsi
cmpq %rax, %rsi
setg %al
orb %cl, %al
cmpb $0x1, %al
jne 0x9fee
leaq 0xe4226(%rip), %rsi     # 0xee16c
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0xe4123(%rip), %rsi     # 0xee082
leaq 0xe4223(%rip), %rdx     # 0xee189
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x1c, %rbx
leaq 0xe40b3(%rip), %rsi     # 0xee034
leaq 0xe41d8(%rip), %rdx     # 0xee160
movq %rbx, %rdi
movl $0x5d, %ecx
jmp 0xa055
leaq 0xe41a1(%rip), %rsi     # 0xee13d
leaq 0x800(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x30af0
leaq 0xe40ca(%rip), %rsi     # 0xee082
leaq 0xe4120(%rip), %rdx     # 0xee0df
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x1c, %rbx
leaq 0xe405a(%rip), %rsi     # 0xee034
leaq 0xe417f(%rip), %rdx     # 0xee160
movq %rbx, %rdi
movl $0x59, %ecx
movq %r14, %r8
jmp 0xa058
movq (%rbx), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x82d0
addq (%rbx), %r14
cmpq %r15, %r14
je 0xa071
leaq 0xe41a4(%rip), %rsi     # 0xee1af
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0xe405e(%rip), %rsi     # 0xee082
leaq 0xe41ac(%rip), %rdx     # 0xee1d7
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x1c, %rbx
leaq 0xe3fee(%rip), %rsi     # 0xee034
leaq 0xe4113(%rip), %rdx     # 0xee160
movq %rbx, %rdi
movl $0x62, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0xa064
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x10(%rdi), %rax
testq %rax, %rax
js 0xa092
movq %rax, (%rsi)
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
leaq 0xe4145(%rip), %rsi     # 0xee1ed
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30af0
leaq 0xe3fc1(%rip), %rsi     # 0xee082
leaq 0xe4143(%rip), %rdx     # 0xee20b
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30af0
addq $0x1c, %rbx
leaq 0xe3f51(%rip), %rsi     # 0xee034
leaq 0xe412d(%rip), %rdx     # 0xee217
movq %rbx, %rdi
movl $0x7e, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_mat_alloc
int sp_mat_alloc(sp_mat** A, int ncols, int nrows, int maxnz, ErrorMsg error_message){
	int ncp =  ncols+1;
	class_alloc((*A),sizeof(sp_mat),error_message);
	class_alloc((*A)->Ax,maxnz*sizeof(double),error_message);
	class_alloc((*A)->Ai,maxnz*sizeof(int),error_message);
	class_alloc((*A)->Ap,(ncp*sizeof(int)),error_message);
	(*A)->ncols = ncols;
	(*A)->nrows = nrows;
	(*A)->maxnz = maxnz;
	return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %r8, %r13
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0x28, %edi
callq 0x8460
movq %rax, (%rbx)
testq %rax, %rax
je 0xb16e
movq %rax, %r12
movq %r13, 0x8(%rsp)
movslq %ebp, %r13
leaq (,%r13,8), %rbx
movq %rbx, %rdi
callq 0x8460
movq %rax, 0x20(%r12)
testq %rax, %rax
je 0xb1ab
shlq $0x2, %r13
movq %r13, %rdi
callq 0x8460
movq %rax, 0x18(%r12)
testq %rax, %rax
je 0xb1e7
leal 0x1(%r15), %eax
movslq %eax, %r13
shlq $0x2, %r13
movq %r13, %rdi
callq 0x8460
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0xb221
movl %r15d, (%r12)
movl %r14d, 0x4(%r12)
movl %ebp, 0x8(%r12)
xorl %eax, %eax
jmp 0xb268
leaq 0xe2e8f(%rip), %rsi     # 0xee004
leaq 0xe3684(%rip), %rdx     # 0xee800
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x28, %ecx
xorl %eax, %eax
callq 0x30af0
leaq 0xe2e9d(%rip), %rsi     # 0xee034
leaq 0xe3667(%rip), %rdx     # 0xee805
movq %r13, %rdi
movl $0x13, %ecx
jmp 0xb259
leaq 0xe2e52(%rip), %rsi     # 0xee004
leaq 0xe3659(%rip), %rdx     # 0xee812
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x30af0
leaq 0xe2e63(%rip), %rsi     # 0xee034
leaq 0xe362d(%rip), %rdx     # 0xee805
movq 0x8(%rsp), %rdi
movl $0x14, %ecx
movq %r14, %r8
jmp 0xb25c
leaq 0xe2e16(%rip), %rsi     # 0xee004
leaq 0xe3626(%rip), %rdx     # 0xee81b
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30af0
leaq 0xe2e26(%rip), %rsi     # 0xee034
leaq 0xe35f0(%rip), %rdx     # 0xee805
movq 0x8(%rsp), %rdi
movl $0x15, %ecx
jmp 0xb259
leaq 0xe2ddc(%rip), %rsi     # 0xee004
leaq 0xe35f5(%rip), %rdx     # 0xee824
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30af0
leaq 0xe2dec(%rip), %rsi     # 0xee034
leaq 0xe35b6(%rip), %rdx     # 0xee805
movq 0x8(%rsp), %rdi
movl $0x16, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x30af0
movl $0x1, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xb27a
movq 0x10(%rbx), %rdi
callq 0xb27a
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x8410
movq 0x18(%rbx), %rdi
callq 0x8410
movq 0x20(%rbx), %rdi
callq 0x8410
movq 0x28(%rbx), %rdi
callq 0x8410
movq 0x30(%rbx), %rdi
callq 0x8410
movq 0x38(%rbx), %rdi
callq 0x8410
movq 0x48(%rbx), %rdi
callq 0x8410
movq 0x40(%rbx), %rdi
callq 0x8410
movq %rbx, %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
retq