LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
jle 0x6a1f4
movq 0x10(%r14), %rcx
movl 0x2c(%r15), %edx
movq %rax, %rsi
shlq $0x4, %rsi
xorl %edi, %edi
movq (%rcx,%rdi), %r8
cmpl %edx, 0x2c(%r8)
jne 0x6a1eb
movzwl 0x30(%r8), %r8d
cmpw 0x30(%r15), %r8w
je 0x6a24b
addq $0x10, %rdi
cmpq %rdi, %rsi
jne 0x6a1d5
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%r14)
movq (%r14), %rcx
movq 0x10(%r14), %rsi
movq (%rcx), %rdi
leal 0x2(,%rax,2), %eax
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x2acfc
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x6a243
testb $0x8, 0x4(%rbx)
je 0x6a22b
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 0x6a24b
movl $0x0, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x58a2c
movq 0x18(%r14), %rdi
testq %rdi, %rdi
jne 0x70419
testb $0x8, 0x5(%r14)
jne 0x7040e
testb %al, %al
movzbl %al, %ecx
movl $0x41, %eax
cmovnel %ecx, %eax
jmp 0x70421
movq 0x20(%r14), %rcx
movq (%rcx), %rcx
movq 0x8(%rcx), %rdi
movsbl %al, %esi
callq 0x58ad4
movb $0x1, %cl
cmpb $0x42, %al
jl 0x70437
jne 0x70431
cmpb $0x42, %bl
sete %cl
jmp 0x70437
cmpb $0x43, %bl
setge %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x58ef8
testl %eax, %eax
jne 0x74533
movq %rbx, %rdi
callq 0x58a2c
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_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rbx
leaq 0xfcca(%rip), %rsi      # 0x8f000
movq %rbx, %rdi
movl $0x7, %edx
callq 0xcfa1
testl %eax, %eax
je 0x7f362
xorl %eax, %eax
testb $0x4, 0x41(%r15)
je 0x7f37b
movq (%r14), %rcx
testb $0x10, 0x33(%rcx)
je 0x7f37b
cmpl $0x0, 0xcc(%rcx)
jne 0x7f37b
leaq 0x11cbe(%rip), %rsi     # 0x91027
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x139b7
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11c3e(%rip), %rsi     # 0x91043
leaq 0xe91a(%rip), %rcx      # 0x8dd26
movq %rbx, %rdx
movq %rbx, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x5bc1d
testl %ebp, %ebp
je 0x7f425
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x11cb3(%rip), %rsi     # 0x910df
leaq 0xe8f3(%rip), %rdx      # 0x8dd26
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x5bc1d
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0x68(%rsi)
je 0x83034
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq 0x68(%rsi), %rax
cmpl $0x0, (%rax)
jle 0x83026
movq %rdi, %r14
movl $0x20, %r13d
xorl %ebp, %ebp
movq %rsp, %r15
movq (%rax,%r13), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x30(%rsp)
movq (%r14), %rdi
movq %rdi, (%rsp)
movq %r12, %rsi
movq %r15, %rdx
callq 0x5e072
movq %r14, %rdi
movq %r12, %rsi
callq 0x58caa
incq %rbp
movq 0x68(%rbx), %rax
movslq (%rax), %rcx
addq $0x20, %r13
cmpq %rcx, %rbp
jl 0x82fd8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x83126
pushq %rax
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x8311a
movq 0x28(%rdi), %rdx
addq $0x8, %rax
xorl %r8d, %r8d
imulq $0x70, %r8, %r11
movq 0x20(%rax,%r11), %r9
cmpq 0x10(%rdx), %r9
jne 0x83112
movq (%rdi), %r10
movq 0x198(%r10), %r9
testq %r9, %r9
je 0x83112
addq %rax, %r11
movq 0x10(%r11), %r11
cmpq %r11, (%r9)
je 0x830f7
movq %r9, %r10
movq 0x18(%r9), %r9
testq %r9, %r9
je 0x83112
cmpq %r11, (%r9)
jne 0x830e0
addq $0x18, %r10
jmp 0x830fe
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 0x830b6
callq 0x82fa5
xorl %eax, %eax
addq $0x8, %rsp
retq
movl $0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1b89(%rip), %rdi      # 0x30b9
leaq -0xdb(%rip), %rsi       # 0x145c
callq 0x11ec
leaq 0x1b74(%rip), %rdi      # 0x30b7
leaq -0xe5(%rip), %rsi       # 0x1465
callq 0x11ec
leaq 0x1b67(%rip), %rdi      # 0x30bd
leaq -0xe7(%rip), %rsi       # 0x1476
callq 0x11ec
leaq 0x1b5d(%rip), %rdi      # 0x30c6
leaq -0xd3(%rip), %rsi       # 0x149d
callq 0x11ec
leaq 0x1b5c(%rip), %rdi      # 0x30d8
leaq -0xef(%rip), %rsi       # 0x1494
callq 0x11ec
leaq 0x1b51(%rip), %rdi      # 0x30e0
leaq -0x10f(%rip), %rsi      # 0x1487
callq 0x11ec
leaq 0x1b46(%rip), %rdi      # 0x30e8
leaq -0xba(%rip), %rsi       # 0x14ef
callq 0x11ec
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1430ca(%rip), %rax    # 0x14bfb8
movq (%rax), %rcx
leaq 0x11bd87(%rip), %rdi    # 0x124c7f
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 0xa0b2b
popq %rcx
popq %rdx
cmpl $0x1, %eax
jne 0x8f8b
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe84a5(%rip), %rsi     # 0xf13f0
leaq 0x11bdc5(%rip), %rdx    # 0x124d17
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0xe80c5(%rip), %rsi     # 0xf1034
leaq 0x11be0b(%rip), %rdx    # 0x124d81
movq %rbx, %rdi
movl $0x571, %ecx            # imm = 0x571
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
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_O1/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 0x142fe1(%rip), %rax    # 0x14bfb8
movq (%rax), %rcx
leaq 0x11bdb1(%rip), %rdi    # 0x124d92
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 0xa16ca
popq %rcx
popq %rdx
cmpl $0x1, %eax
jne 0x907b
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe83b5(%rip), %rsi     # 0xf13f0
leaq 0x11bdfb(%rip), %rdx    # 0x124e3d
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0xe7fd5(%rip), %rsi     # 0xf1034
leaq 0x11be37(%rip), %rdx    # 0x124e9d
movq %rbx, %rdi
movl $0x5a2, %ecx            # imm = 0x5A2
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
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_O1/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 0x142efc(%rip), %rax    # 0x14bfb8
movq (%rax), %rcx
leaq 0x11bdee(%rip), %rdi    # 0x124eb4
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 0xa0b2b
cmpl $0x1, %eax
jne 0x915b
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe82d5(%rip), %rsi     # 0xf13f0
leaq 0x11be2d(%rip), %rdx    # 0x124f4f
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0xe7ef5(%rip), %rsi     # 0xf1034
leaq 0x11be6c(%rip), %rdx    # 0x124fb2
movq %rbx, %rdi
movl $0x5cb, %ecx            # imm = 0x5CB
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
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_O1/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 0x142e15(%rip), %rax    # 0x14bfb8
movq (%rax), %rcx
leaq 0x11be19(%rip), %rdi    # 0x124fc6
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 0xa16ca
cmpl $0x1, %eax
jne 0x9248
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe81e8(%rip), %rsi     # 0xf13f0
leaq 0x11be5e(%rip), %rdx    # 0x12506d
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0xe7e08(%rip), %rsi     # 0xf1034
leaq 0x11be9d(%rip), %rdx    # 0x1250d0
movq %rbx, %rdi
movl $0x5f8, %ecx            # imm = 0x5F8
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
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_O1/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 0x142d32(%rip), %rax    # 0x14bfb8
movq (%rax), %rcx
leaq 0x11be5a(%rip), %rdi    # 0x1250ea
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 0xa1814
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x932f
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe8101(%rip), %rsi     # 0xf13f0
leaq 0x11beaa(%rip), %rdx    # 0x1251a0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0xe7d21(%rip), %rsi     # 0xf1034
leaq 0x11befb(%rip), %rdx    # 0x125215
movq %rbx, %rdi
movl $0x632, %ecx            # imm = 0x632
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
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_O1/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 0x142c4f(%rip), %rax    # 0x14bfb8
movq (%rax), %rcx
leaq 0x11bec4(%rip), %rdi    # 0x125237
pushq $0x1
popq %rdx
movl $0x99, %esi
callq 0x86d0
movq 0xe0(%rbx), %rsi
xorl %ebp, %ebp
cmpw $0x0, 0x50(%rsi)
je 0x9409
movl 0x54(%rsi), %edx
movsd 0x11b095(%rip), %xmm2   # 0x124430
movq %r15, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rcx
callq 0xa6a9a
cmpl $0x1, %eax
jne 0x9409
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe8027(%rip), %rsi     # 0xf13f0
leaq 0x11bf01(%rip), %rdx    # 0x1252d1
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0xe7c47(%rip), %rsi     # 0xf1034
leaq 0x11bf27(%rip), %rdx    # 0x12531b
movq %rbx, %rdi
movl $0x65b, %ecx            # imm = 0x65B
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
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_O1/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 0x142b77(%rip), %rax    # 0x14bfb8
movq (%rax), %rcx
leaq 0x11bedf(%rip), %rdi    # 0x12532a
pushq $0x1
popq %rdx
movl $0x9c, %esi
callq 0x86d0
movq 0xe0(%rbx), %rsi
xorl %ebp, %ebp
cmpw $0x0, 0x52(%rsi)
je 0x94e1
movl 0x58(%rsi), %edx
movsd 0x11afbd(%rip), %xmm2   # 0x124430
movq %r15, %rdi
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rcx
callq 0xa6a9a
cmpl $0x1, %eax
jne 0x94e1
movl $0x192, %ecx            # imm = 0x192
addq 0xe0(%rbx), %rcx
leaq 0xe7f4f(%rip), %rsi     # 0xf13f0
leaq 0x11bf1f(%rip), %rdx    # 0x1253c7
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
addq $0xea, %rbx
leaq 0xe7b6f(%rip), %rsi     # 0xf1034
leaq 0x11bf49(%rip), %rdx    # 0x125415
movq %rbx, %rdi
movl $0x686, %ecx            # imm = 0x686
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
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_O1/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 0x9cd6
movq $0x1000, 0x8(%rbx)      # imm = 0x1000
movq $0x0, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
xorl %eax, %eax
jmp 0x9d1f
leaq 0xe7327(%rip), %rsi     # 0xf1004
leaq 0xe7343(%rip), %rdx     # 0xf1027
movq %rsp, %r14
movq %r14, %rdi
movl $0x1000, %ecx           # imm = 0x1000
xorl %eax, %eax
callq 0x30c2c
addq $0x1c, %rbx
leaq 0xe7333(%rip), %rsi     # 0xf1034
leaq 0xe7339(%rip), %rdx     # 0xf1041
movq %rbx, %rdi
movl $0x11, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9fb2
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 0xa00b
leaq 0xe7209(%rip), %rsi     # 0xf116c
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0xe7106(%rip), %rsi     # 0xf1082
leaq 0xe7206(%rip), %rdx     # 0xf1189
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x1c, %rbx
leaq 0xe7096(%rip), %rsi     # 0xf1034
leaq 0xe71bb(%rip), %rdx     # 0xf1160
movq %rbx, %rdi
movl $0x5d, %ecx
jmp 0xa072
leaq 0xe7184(%rip), %rsi     # 0xf113d
leaq 0x800(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x30c2c
leaq 0xe70ad(%rip), %rsi     # 0xf1082
leaq 0xe7103(%rip), %rdx     # 0xf10df
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x1c, %rbx
leaq 0xe703d(%rip), %rsi     # 0xf1034
leaq 0xe7162(%rip), %rdx     # 0xf1160
movq %rbx, %rdi
movl $0x59, %ecx
movq %r14, %r8
jmp 0xa075
movq (%rbx), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x82d0
addq (%rbx), %r14
cmpq %r15, %r14
je 0xa08e
leaq 0xe7187(%rip), %rsi     # 0xf11af
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0xe7041(%rip), %rsi     # 0xf1082
leaq 0xe718f(%rip), %rdx     # 0xf11d7
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x1c, %rbx
leaq 0xe6fd1(%rip), %rsi     # 0xf1034
leaq 0xe70f6(%rip), %rdx     # 0xf1160
movq %rbx, %rdi
movl $0x62, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0xa081
// File: /workspace/github_c_makefile_star2_O1/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 0xa0af
movq %rax, (%rsi)
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
leaq 0xe7128(%rip), %rsi     # 0xf11ed
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30c2c
leaq 0xe6fa4(%rip), %rsi     # 0xf1082
leaq 0xe7126(%rip), %rdx     # 0xf120b
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x30c2c
addq $0x1c, %rbx
leaq 0xe6f34(%rip), %rsi     # 0xf1034
leaq 0xe7110(%rip), %rdx     # 0xf1217
movq %rbx, %rdi
movl $0x7e, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x30c2c
movl $0x1, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8410
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rbx)
movl $0x0, 0x18(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x8410
movq 0x10(%rbx), %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 0x40(%rbx), %rdi
callq 0x8410
movq 0x48(%rbx), %rdi
callq 0x8410
movq 0x50(%rbx), %rdi
callq 0x8410
movq 0x58(%rbx), %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb18e
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 0xb1cb
shlq $0x2, %r13
movq %r13, %rdi
callq 0x8460
movq %rax, 0x18(%r12)
testq %rax, %rax
je 0xb207
leal 0x1(%r15), %eax
movslq %eax, %r13
shlq $0x2, %r13
movq %r13, %rdi
callq 0x8460
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0xb241
movl %r15d, (%r12)
movl %r14d, 0x4(%r12)
movl %ebp, 0x8(%r12)
xorl %eax, %eax
jmp 0xb288
leaq 0xe5e6f(%rip), %rsi     # 0xf1004
leaq 0xe6664(%rip), %rdx     # 0xf1800
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x28, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0xe5e7d(%rip), %rsi     # 0xf1034
leaq 0xe6647(%rip), %rdx     # 0xf1805
movq %r13, %rdi
movl $0x13, %ecx
jmp 0xb279
leaq 0xe5e32(%rip), %rsi     # 0xf1004
leaq 0xe6639(%rip), %rdx     # 0xf1812
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0xe5e43(%rip), %rsi     # 0xf1034
leaq 0xe660d(%rip), %rdx     # 0xf1805
movq 0x8(%rsp), %rdi
movl $0x14, %ecx
movq %r14, %r8
jmp 0xb27c
leaq 0xe5df6(%rip), %rsi     # 0xf1004
leaq 0xe6606(%rip), %rdx     # 0xf181b
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0xe5e06(%rip), %rsi     # 0xf1034
leaq 0xe65d0(%rip), %rdx     # 0xf1805
movq 0x8(%rsp), %rdi
movl $0x15, %ecx
jmp 0xb279
leaq 0xe5dbc(%rip), %rsi     # 0xf1004
leaq 0xe65d5(%rip), %rdx     # 0xf1824
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x30c2c
leaq 0xe5dcc(%rip), %rsi     # 0xf1034
leaq 0xe6596(%rip), %rdx     # 0xf1805
movq 0x8(%rsp), %rdi
movl $0x16, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x30c2c
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_O1/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 %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x8410
movq 0x18(%rbx), %rdi
callq 0x8410
movq 0x10(%rbx), %rdi
callq 0x8410
movq %rbx, %rdi
callq 0x8410
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb29a
movq 0x10(%rbx), %rdi
callq 0xb29a
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
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, %rbx
movslq (%rdi), %rax
movq 0x10(%rsi), %r12
movq 0x18(%rsi), %r14
movq %rdi, 0x18(%rsp)
movq 0x10(%rdi), %rbp
movq %rax, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movslq %edx, %r15
movslq (%r12,%r15,4), %r13
cmpl 0x4(%r12,%r15,4), %r13d
jge 0xb811
movslq (%r14,%r13,4), %rdi
cmpl $0x0, (%rbp,%rdi,4)
js 0xb804
movq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rcx
movq 0x20(%rsp), %r8
callq 0xb84a
incq %r13
movslq 0x4(%r12,%r15,4), %rax
cmpq %rax, %r13
jl 0xb7e2
movslq 0xc(%rsp), %rax
movq 0x10(%rsp), %rdi
cmpl %edi, %eax
jge 0xb83b
movq %rax, %rcx
movslq (%rbx,%rcx,4), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
subl (%rbp,%rdx,4), %esi
movl %esi, (%rbp,%rdx,4)
incq %rcx
cmpq %rcx, %rdi
jne 0xb822
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq 0x10(%rsi), %r13
movq 0x18(%rsi), %rax
movl %edi, 0x4(%rsp)
movslq %edi, %rdx
movq %r8, 0x10(%rsp)
movslq (%r8,%rdx,4), %rcx
movl $0xfffffffe, %ebp       # imm = 0xFFFFFFFE
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
subl (%r13,%rdx,4), %esi
movl %esi, (%r13,%rdx,4)
testq %rcx, %rcx
js 0xb8e8
movl (%r13,%rcx,4), %edx
movl 0x4(%r13,%rcx,4), %esi
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
subl %edx, %ecx
testl %edx, %edx
cmovnsl %edx, %ecx
subl %esi, %ebp
testl %esi, %esi
cmovnsl %esi, %ebp
subl %ecx, %ebp
jle 0xb8e8
movslq %ecx, %rcx
leaq (%rax,%rcx,4), %rbx
xorl %r15d, %r15d
movslq (%rbx,%r15,4), %rdi
cmpl $0x0, (%r13,%rdi,4)
js 0xb8e0
movq %r12, %rsi
movq %r14, %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0xb84a
incq %r15
cmpl %r15d, %ebp
jne 0xb8bf
movslq (%r14), %rax
leaq -0x1(%rax), %rcx
movl %ecx, (%r14)
movq 0x8(%rsp), %rcx
movl 0x4(%rsp), %edx
movl %edx, -0x4(%rcx,%rax,4)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_splsolve
int sp_splsolve(sp_mat *G, sp_mat *B, int k, int*xik, int top, double *x, int *pinv){
	int j, J, p, q, px, n, *Gp, *Gi, *Bp, *Bi;
	double *Gx, *Bx;
	Gp = G->Ap; Gi = G->Ai; Gx = G->Ax;
	Bp = B->Ap; Bi = B->Ai; Bx = B->Ax;
	n = G->ncols;

	for (p=top; p<n; p++) x[xik[p]] = 0;
	for (p=Bp[k];p<Bp[k+1];p++) x[Bi[p]] = Bx[p];
	for (px=top; px<n; px++){
		j=xik[px];
		J = pinv[j];
		if (J<0) continue;
		x[j] /= Gx[Gp[J]];
		p = Gp[J]+1;
		q = Gp[J+1];
		for( ;p<q; p++){
			x[Gi[p]] -=Gx[p] * x[j];
		}
	}
	return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %r10
movq 0x20(%rdi), %r11
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %rbx
movq 0x20(%rsi), %r14
movslq (%rdi), %rsi
cmpl %r8d, %esi
jle 0xb94d
movslq %r8d, %rdi
movslq (%rcx,%rdi,4), %r12
movq $0x0, (%r9,%r12,8)
incq %rdi
cmpq %rdi, %rsi
jne 0xb939
movslq %edx, %rdi
movslq (%r15,%rdi,4), %rdx
movslq 0x4(%r15,%rdi,4), %rdi
cmpl %edi, %edx
jge 0xb975
movsd (%r14,%rdx,8), %xmm0
movslq (%rbx,%rdx,4), %r15
movsd %xmm0, (%r9,%r15,8)
incq %rdx
cmpq %rdx, %rdi
jne 0xb95d
cmpl %r8d, %esi
jle 0xb9e7
movq 0x30(%rsp), %rdx
movslq %r8d, %rdi
movslq (%rcx,%rdi,4), %r8
movslq (%rdx,%r8,4), %r14
testq %r14, %r14
js 0xb9df
movslq (%rax,%r14,4), %rbx
movsd (%r9,%r8,8), %xmm0
divsd (%r11,%rbx,8), %xmm0
movsd %xmm0, (%r9,%r8,8)
movl 0x4(%rax,%r14,4), %r14d
leal 0x1(%rbx), %ebp
cmpl %r14d, %ebp
jge 0xb9df
decl %r14d
movsd 0x8(%r11,%rbx,8), %xmm0
movslq 0x4(%r10,%rbx,4), %r15
movsd (%r9,%r15,8), %xmm1
mulsd (%r9,%r8,8), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r15,8)
incq %rbx
cmpl %ebx, %r14d
jne 0xb9b5
incq %rdi
cmpq %rsi, %rdi
jne 0xb982
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_lusolve
int sp_lusolve(sp_num *N, double *b, double *x){
	int p, j, n, *Ap, *Ai;
	double *Ax, *w;
	n=N->n;
	/* permute b and initialize x:*/
	for (j=0; j<n; j++) x[N->pinv[j]] = b[j];
	/* lower solve: */
	Ap = N->L->Ap; Ai = N->L->Ai; Ax = N->L->Ax;
	for (j=0; j<n; j++){
		x[j] /=Ax[Ap[j]];
		for (p=Ap[j]+1; p<Ap[j+1]; p++){
			x[Ai[p]] -=Ax[p]*x[j];
		}
	}
	/* upper solve: */
	Ap = N->U->Ap; Ai = N->U->Ai; Ax = N->U->Ax;
	for (j=n-1; j>=0; j--){
		x[j] /=Ax[Ap[j+1]-1];
		for (p=Ap[j];p<Ap[j+1]-1; p++){
			x[Ai[p]] -= Ax[p]*x[j];
		}
	}
	if (N->q!=NULL){
		/* We must permute once more..*/
		w = N->w;
		for(j=0;j<n;j++) w[j] = x[j];
		for(j=0; j<n; j++) x[N->q[j]] = w[j];
	}
	return _SUCCESS_;
}

// Assembly:
pushq %r14
pushq %rbx
movslq (%rdi), %rax
testq %rax, %rax
jle 0xbdb8
movq 0x28(%rdi), %rcx
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm0
movslq (%rcx,%r8,4), %r9
movsd %xmm0, (%rdx,%r9,8)
incq %r8
cmpq %r8, %rax
jne 0xbda0
testl %eax, %eax
jle 0xbe26
movq 0x8(%rdi), %r8
movq 0x10(%r8), %rcx
movq 0x18(%r8), %rsi
movq 0x20(%r8), %r8
xorl %r9d, %r9d
movslq (%rcx,%r9,4), %r10
movsd (%rdx,%r9,8), %xmm0
divsd (%r8,%r10,8), %xmm0
movsd %xmm0, (%rdx,%r9,8)
movl 0x4(%rcx,%r9,4), %r11d
leal 0x1(%r10), %ebx
cmpl %r11d, %ebx
jge 0xbe1e
decl %r11d
movsd 0x8(%r8,%r10,8), %xmm0
movslq 0x4(%rsi,%r10,4), %rbx
movsd (%rdx,%rbx,8), %xmm1
mulsd (%rdx,%r9,8), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rbx,8)
incq %r10
cmpl %r10d, %r11d
jne 0xbdf6
incq %r9
cmpq %rax, %r9
jne 0xbdcf
testl %eax, %eax
jle 0xbe97
movq 0x10(%rdi), %r8
movq 0x10(%r8), %rcx
movq 0x18(%r8), %rsi
movq 0x20(%r8), %r8
movq %rax, %r9
movq %r9, %r10
decq %r9
movslq (%rcx,%r10,4), %r11
movsd -0x8(%rdx,%r10,8), %xmm0
divsd -0x8(%r8,%r11,8), %xmm0
movsd %xmm0, -0x8(%rdx,%r10,8)
movslq -0x4(%rcx,%r10,4), %rbx
decq %r11
cmpl %r11d, %ebx
jge 0xbe91
movsd (%r8,%rbx,8), %xmm0
movslq (%rsi,%rbx,4), %r14
movsd (%rdx,%r14,8), %xmm1
mulsd (%rdx,%r9,8), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%r14,8)
incq %rbx
cmpq %rbx, %r11
jne 0xbe69
cmpq $0x2, %r10
jge 0xbe3d
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0xbed9
movq 0x48(%rdi), %rsi
testl %eax, %eax
jle 0xbebc
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0xbeaa
testl %eax, %eax
jle 0xbed9
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm0
movslq (%rcx,%rdi,4), %r8
movsd %xmm0, (%rdx,%r8,8)
incq %rdi
cmpq %rdi, %rax
jne 0xbec2
xorl %eax, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: column_grouping
int column_grouping(sp_mat *G, int *col_g, int *filled){
  int testcol,groupnum,fitted,neq;
  int i, *Ap, *Ai,done;

  neq = G->ncols;
  Ai = G->Ai; Ap = G->Ap;
  for(i=0;i<neq;i++)
    col_g[i]=-1;

  for(groupnum=0; groupnum<neq; groupnum++){
    //Reset filled vector:
    for (i=0; i<neq; i++){
      filled[i] = 0;
    }
    //Try to assign remaining columns to current group:
    done = _TRUE_;
    for (testcol=0; testcol<neq; testcol++){
      if (col_g[testcol]!=-1){
	continue;
      }
      done = _FALSE_;
      //Is current testcol in conflict with the groups filling vector?
      fitted = _TRUE_;
      for (i=Ap[testcol]; i<Ap[testcol+1]; i++){
	if (filled[Ai[i]] != 0){
	  fitted = _FALSE_;
	  break;
	}
      }
      if (fitted == _TRUE_){
	//Test succesfull
	col_g[testcol] = groupnum;
	for (i=Ap[testcol]; i<Ap[testcol+1]; i++){
	  filled[Ai[i]] = 1;
	}
      }
    }
    if (done == _TRUE_){
      //No columns remaining.
      //No column belongs to current groupnum.
      break;
    }
  }
  return (groupnum-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movslq (%rdi), %r13
movq 0x10(%rdi), %rbp
movq 0x18(%rdi), %r12
testq %r13, %r13
jle 0xc166
leaq (,%r13,4), %rdx
movq %r14, %rdi
movl $0xff, %esi
callq 0x8200
testl %r13d, %r13d
jle 0xc212
leaq (,%r13,4), %rax
movq %rax, (%rsp)
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
movq (%rsp), %rdx
callq 0x8200
movl $0x1, %ecx
xorl %eax, %eax
cmpl $-0x1, (%r14,%rax,4)
je 0xc1a4
incq %rax
cmpq %r13, %rax
jne 0xc193
jmp 0xc1f9
movslq (%rbp,%rax,4), %rsi
movl 0x4(%rbp,%rax,4), %ecx
cmpl %esi, %ecx
jle 0xc1ca
leaq (%r12,%rsi,4), %rdx
subl %esi, %ecx
xorl %esi, %esi
movslq (%rdx,%rsi,4), %rdi
cmpl $0x0, (%rbx,%rdi,4)
jne 0xc1f5
incq %rsi
cmpl %esi, %ecx
jne 0xc1b9
movl %r15d, (%r14,%rax,4)
movslq (%rbp,%rax,4), %rdx
xorl %ecx, %ecx
cmpl 0x4(%rbp,%rax,4), %edx
jge 0xc19a
movslq (%r12,%rdx,4), %rsi
movl $0x1, (%rbx,%rsi,4)
incq %rdx
movslq 0x4(%rbp,%rax,4), %rsi
cmpq %rsi, %rdx
jl 0xc1db
jmp 0xc19a
xorl %ecx, %ecx
jmp 0xc19a
cmpl $0x1, %ecx
je 0xc20d
incl %r15d
cmpl %r13d, %r15d
jne 0xc17e
movl %r13d, %r15d
decl %r15d
jmp 0xc218
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %eax
cmpl $0x2, %edi
setl %dil
addl %eax, %esi
sets %sil
orb %dil, %sil
cmpb $0x1, %sil
jne 0xcf0d
movl $0x2, %eax
testl %ecx, %ecx
jle 0xcf0d
movl %ecx, %ecx
xorl %esi, %esi
cmpl $0x0, (%rdx,%rsi,4)
je 0xcf05
movl $0x1, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0xcef8
retq