LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x52d65
testl %eax, %eax
jne 0x66792
movq %rbx, %rdi
callq 0x528f5
movb %al, 0x1(%rbx)
movb $-0x5e, (%rbx)
movl 0xc(%r15), %eax
movl %eax, 0x2c(%rbx)
movzwl 0x10(%r15), %eax
movw %ax, 0x30(%rbx)
andq $0x0, 0x40(%rbx)
pushq $0x1
popq %r14
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xdc37(%rip), %rsi      # 0x7c01c
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0xc87e
testl %eax, %eax
je 0x6e40f
xorl %eax, %eax
testb $0x4, 0x41(%r15)
je 0x6e426
movq (%r14), %rcx
testb $0x10, 0x33(%rcx)
je 0x6e426
cmpl $0x0, 0xcc(%rcx)
jne 0x6e426
leaq 0xfc2d(%rip), %rsi      # 0x7e043
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x12276
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfbdf(%rip), %rsi      # 0x7e05f
leaq 0xc8c3(%rip), %rcx      # 0x7ad4a
movq %rbx, %rdx
movq %rbx, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x552b6
testl %ebp, %ebp
je 0x6e4a0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xfc54(%rip), %rsi      # 0x7e0fb
leaq 0xc89c(%rip), %rdx      # 0x7ad4a
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x552b6
// File: /workspace/github_c_makefile_star2_O2/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 0x713b4
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %r13
leaq 0x8(%rsp), %rbp
xorl %r15d, %r15d
movslq (%rax), %rcx
cmpq %rcx, %r15
jge 0x713a6
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 0x5769b
movq %r14, %rdi
movq %r12, %rsi
callq 0x52b54
incq %r15
movq 0x68(%rbx), %rax
addq $0x20, %r13
jmp 0x71361
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jkbenaim[P]psfrag/sqlite3.c
// Function: renameTableSelectCb
static int renameTableSelectCb(Walker *pWalker, Select *pSelect){
  int i;
  RenameCtx *p = pWalker->u.pRename;
  SrcList *pSrc = pSelect->pSrc;
  if( pSrc==0 ){
    assert( pWalker->pParse->db->mallocFailed );
    return WRC_Abort;
  }
  for(i=0; i<pSrc->nSrc; i++){
    struct SrcList_item *pItem = &pSrc->a[i];
    if( pItem->pTab==p->pTab ){
      renameTokenFind(pWalker->pParse, p, pItem->zName);
    }
  }
  renameWalkWith(pWalker, pSelect);

  return WRC_Continue;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rsi), %r12
testq %r12, %r12
je 0x7143e
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %r15
leaq 0x28(%r12), %r13
xorl %ebp, %ebp
movslq (%r12), %rax
cmpq %rax, %rbp
jge 0x7142f
movq (%r13), %rax
cmpq 0x10(%r15), %rax
jne 0x71426
movq (%r14), %rdi
movq -0x10(%r13), %rdx
movq %r15, %rsi
callq 0x70c5e
incq %rbp
addq $0x70, %r13
jmp 0x71404
movq %r14, %rdi
movq %rbx, %rsi
callq 0x71338
xorl %eax, %eax
jmp 0x71441
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1bd1(%rip), %rdi      # 0x30b9
leaq -0xdb(%rip), %rsi       # 0x1414
callq 0x11dc
leaq 0x1bbc(%rip), %rdi      # 0x30b7
leaq -0xe5(%rip), %rsi       # 0x141d
callq 0x11dc
leaq 0x1baf(%rip), %rdi      # 0x30bd
leaq -0xe7(%rip), %rsi       # 0x142e
callq 0x11dc
leaq 0x1ba5(%rip), %rdi      # 0x30c6
leaq -0xd3(%rip), %rsi       # 0x1455
callq 0x11dc
leaq 0x1ba4(%rip), %rdi      # 0x30d8
leaq -0xef(%rip), %rsi       # 0x144c
callq 0x11dc
leaq 0x1b99(%rip), %rdi      # 0x30e0
leaq -0x10f(%rip), %rsi      # 0x143f
callq 0x11dc
leaq 0x1b8e(%rip), %rdi      # 0x30e8
leaq -0xba(%rip), %rsi       # 0x14a7
callq 0x11dc
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x8490
movq %rax, (%rbx)
testq %rax, %rax
je 0x8850
movq $0x1000, 0x8(%rbx)      # imm = 0x1000
andq $0x0, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
xorl %eax, %eax
jmp 0x8895
leaq 0xdc7ad(%rip), %rsi     # 0xe5004
leaq 0xdc7c9(%rip), %rdx     # 0xe5027
movq %rsp, %r14
movq %r14, %rdi
movl $0x1000, %ecx           # imm = 0x1000
xorl %eax, %eax
callq 0x2e014
addq $0x1c, %rbx
leaq 0xdc7b9(%rip), %rsi     # 0xe5034
leaq 0xdc7bf(%rip), %rdx     # 0xe5041
pushq $0x11
popq %rcx
movq %rbx, %rdi
movq %r14, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8b13
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 0x8b6a
leaq 0xdc6a2(%rip), %rsi     # 0xe516c
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0xdc59f(%rip), %rsi     # 0xe5082
leaq 0xdc69f(%rip), %rdx     # 0xe5189
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x1c, %rbx
leaq 0xdc52f(%rip), %rsi     # 0xe5034
leaq 0xdc654(%rip), %rdx     # 0xe5160
pushq $0x5d
jmp 0x8bcb
leaq 0xdc623(%rip), %rsi     # 0xe513d
leaq 0x800(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2e014
leaq 0xdc54c(%rip), %rsi     # 0xe5082
leaq 0xdc5a2(%rip), %rdx     # 0xe50df
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x1c, %rbx
leaq 0xdc4dc(%rip), %rsi     # 0xe5034
leaq 0xdc601(%rip), %rdx     # 0xe5160
pushq $0x59
popq %rcx
movq %rbx, %rdi
movq %r14, %r8
jmp 0x8bd2
movq (%rbx), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x82f0
addq (%rbx), %r14
cmpq %r15, %r14
je 0x8be9
leaq 0xdc628(%rip), %rsi     # 0xe51af
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0xdc4e2(%rip), %rsi     # 0xe5082
leaq 0xdc630(%rip), %rdx     # 0xe51d7
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x1c, %rbx
leaq 0xdc472(%rip), %rsi     # 0xe5034
leaq 0xdc597(%rip), %rdx     # 0xe5160
pushq $0x62
popq %rcx
movq %rbx, %rdi
movq %r15, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x8bdc
// File: /workspace/github_c_makefile_star2_O2/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 0x8c0a
movq %rax, (%rsi)
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
leaq 0xdc5cd(%rip), %rsi     # 0xe51ed
leaq 0x800(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0xdc449(%rip), %rsi     # 0xe5082
leaq 0xdc5cb(%rip), %rdx     # 0xe520b
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2e014
addq $0x1c, %rbx
leaq 0xdc3d9(%rip), %rsi     # 0xe5034
leaq 0xdc5b5(%rip), %rdx     # 0xe5217
pushq $0x7e
popq %rcx
movq %rbx, %rdi
movq %r15, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8430
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rbx)
andl $0x0, 0x18(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x8430
movq 0x10(%rbx), %rdi
callq 0x8430
movq 0x18(%rbx), %rdi
callq 0x8430
movq 0x20(%rbx), %rdi
callq 0x8430
movq 0x28(%rbx), %rdi
callq 0x8430
movq 0x30(%rbx), %rdi
callq 0x8430
movq 0x38(%rbx), %rdi
callq 0x8430
movq 0x40(%rbx), %rdi
callq 0x8430
movq 0x48(%rbx), %rdi
callq 0x8430
movq 0x50(%rbx), %rdi
callq 0x8430
movq 0x58(%rbx), %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x28
popq %rdi
callq 0x8490
movq %rax, (%rbx)
testq %rax, %rax
je 0x9c58
movq %rax, %r12
movq %r13, 0x8(%rsp)
movslq %ebp, %r13
leaq (,%r13,8), %rbx
movq %rbx, %rdi
callq 0x8490
movq %rax, 0x20(%r12)
testq %rax, %rax
je 0x9c91
shlq $0x2, %r13
movq %r13, %rdi
callq 0x8490
movq %rax, 0x18(%r12)
testq %rax, %rax
je 0x9ccb
leal 0x1(%r15), %eax
movslq %eax, %r13
shlq $0x2, %r13
movq %r13, %rdi
callq 0x8490
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x9cfd
movl %r15d, (%r12)
movl %r14d, 0x4(%r12)
movl %ebp, 0x8(%r12)
xorl %eax, %eax
jmp 0x9d40
leaq 0xdb3a5(%rip), %rsi     # 0xe5004
leaq 0xdbb9a(%rip), %rdx     # 0xe5800
leaq 0x10(%rsp), %rbx
pushq $0x28
popq %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e014
leaq 0xdb3b5(%rip), %rsi     # 0xe5034
leaq 0xdbb7f(%rip), %rdx     # 0xe5805
pushq $0x13
popq %rcx
movq %r13, %rdi
jmp 0x9d33
leaq 0xdb36c(%rip), %rsi     # 0xe5004
leaq 0xdbb73(%rip), %rdx     # 0xe5812
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xdb37d(%rip), %rsi     # 0xe5034
leaq 0xdbb47(%rip), %rdx     # 0xe5805
pushq $0x14
popq %rcx
movq 0x8(%rsp), %rdi
movq %r14, %r8
jmp 0x9d36
leaq 0xdb332(%rip), %rsi     # 0xe5004
leaq 0xdbb42(%rip), %rdx     # 0xe581b
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xdb342(%rip), %rsi     # 0xe5034
leaq 0xdbb0c(%rip), %rdx     # 0xe5805
pushq $0x15
jmp 0x9d2d
leaq 0xdb300(%rip), %rsi     # 0xe5004
leaq 0xdbb19(%rip), %rdx     # 0xe5824
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x2e014
leaq 0xdb310(%rip), %rsi     # 0xe5034
leaq 0xdbada(%rip), %rdx     # 0xe5805
pushq $0x16
popq %rcx
movq 0x8(%rsp), %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x2e014
pushq $0x1
popq %rax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8430
movq 0x18(%rbx), %rdi
callq 0x8430
movq 0x10(%rbx), %rdi
callq 0x8430
movq %rbx, %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9d52
movq 0x10(%rbx), %rdi
callq 0x9d52
movq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x8430
movq 0x18(%rbx), %rdi
callq 0x8430
movq 0x20(%rbx), %rdi
callq 0x8430
movq 0x28(%rbx), %rdi
callq 0x8430
movq 0x30(%rbx), %rdi
callq 0x8430
movq 0x38(%rbx), %rdi
callq 0x8430
movq 0x48(%rbx), %rdi
callq 0x8430
movq 0x40(%rbx), %rdi
callq 0x8430
movq %rbx, %rdi
callq 0x8430
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0xc(%rsp), %rcx
movq %rax, 0x10(%rsp)
movl %eax, (%rcx)
movslq %edx, %r15
movslq (%r12,%r15,4), %r13
movslq 0x4(%r12,%r15,4), %rax
cmpq %rax, %r13
jge 0xa261
movslq (%r14,%r13,4), %rdi
cmpl $0x0, (%rbp,%rdi,4)
js 0xa25c
movq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %rbx, %rcx
movq 0x20(%rsp), %r8
callq 0xa298
incq %r13
jmp 0xa230
movslq 0xc(%rsp), %rax
pushq $-0x2
popq %rcx
movq %rax, %rdx
movq 0x10(%rsp), %r8
cmpq %r8, %rdx
jge 0xa289
movslq (%rbx,%rdx,4), %rsi
movl %ecx, %edi
subl (%rbp,%rsi,4), %edi
movl %edi, (%rbp,%rsi,4)
incq %rdx
jmp 0xa271
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rbp
movl %edi, 0x4(%rsp)
movslq %edi, %rdx
movq %r8, 0x10(%rsp)
movslq (%r8,%rdx,4), %rcx
pushq $-0x2
popq %rax
movl %eax, %esi
subl (%r13,%rdx,4), %esi
movl %esi, (%r13,%rdx,4)
testq %rcx, %rcx
js 0xa329
movl (%r13,%rcx,4), %edx
movl 0x4(%r13,%rcx,4), %ecx
movl %eax, %esi
subl %edx, %esi
testl %edx, %edx
cmovnsl %edx, %esi
subl %ecx, %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
movslq %esi, %rbx
movslq %eax, %r15
cmpq %r15, %rbx
jge 0xa329
movslq (%rbp,%rbx,4), %rdi
cmpl $0x0, (%r13,%rdi,4)
js 0xa324
movq %r12, %rsi
movq %r14, %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0xa298
incq %rbx
jmp 0xa2fd
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_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x30(%rsp), %rax
movq 0x10(%rdi), %r10
movq 0x18(%rdi), %r11
movq 0x20(%rdi), %rbx
movq 0x10(%rsi), %r12
movq 0x18(%rsi), %r14
movq 0x20(%rsi), %r15
movslq (%rdi), %rsi
movslq %r8d, %rdi
movq %rdi, %r8
cmpq %rsi, %r8
jge 0xa391
movslq (%rcx,%r8,4), %r13
andq $0x0, (%r9,%r13,8)
incq %r8
jmp 0xa37e
movslq %edx, %r8
movslq (%r12,%r8,4), %rdx
movslq 0x4(%r12,%r8,4), %r8
cmpq %r8, %rdx
jge 0xa40c
movsd (%r15,%rdx,8), %xmm0
movslq (%r14,%rdx,4), %r12
movsd %xmm0, (%r9,%r12,8)
incq %rdx
jmp 0xa39d
movslq (%rcx,%rdi,4), %rdx
movslq (%rax,%rdx,4), %r14
testq %r14, %r14
js 0xa409
movslq (%r10,%r14,4), %r8
movsd (%r9,%rdx,8), %xmm0
divsd (%rbx,%r8,8), %xmm0
movsd %xmm0, (%r9,%rdx,8)
movslq 0x4(%r10,%r14,4), %r14
incq %r8
cmpq %r14, %r8
jge 0xa409
movsd (%rbx,%r8,8), %xmm0
movslq (%r11,%r8,4), %r15
mulsd (%r9,%rdx,8), %xmm0
movsd (%r9,%r15,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%r9,%r15,8)
jmp 0xa3df
incq %rdi
cmpq %rsi, %rdi
jl 0xa3b7
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl (%rdi), %ecx
xorl %r8d, %r8d
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
cmpq %r8, %rax
je 0xa720
movsd (%rsi,%r8,8), %xmm0
movq 0x28(%rdi), %r9
movslq (%r9,%r8,4), %r9
movsd %xmm0, (%rdx,%r9,8)
incq %r8
jmp 0xa702
movq 0x8(%rdi), %r9
movq 0x10(%r9), %rsi
movq 0x18(%r9), %r8
movq 0x20(%r9), %r9
xorl %r10d, %r10d
cmpq %rax, %r10
je 0xa786
movslq (%rsi,%r10,4), %r11
movsd (%rdx,%r10,8), %xmm0
divsd (%r9,%r11,8), %xmm0
movsd %xmm0, (%rdx,%r10,8)
leaq 0x1(%r10), %rbx
movslq 0x4(%rsi,%r10,4), %r14
incq %r11
cmpq %r14, %r11
jge 0xa781
movsd (%r9,%r11,8), %xmm0
movslq (%r8,%r11,4), %r15
mulsd (%rdx,%r10,8), %xmm0
movsd (%rdx,%r15,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%r15,8)
jmp 0xa757
movq %rbx, %r10
jmp 0xa733
movq 0x10(%rdi), %r9
movq 0x10(%r9), %rsi
movq 0x18(%r9), %r8
movq 0x20(%r9), %r9
testl %ecx, %ecx
jle 0xa7e0
movslq (%rsi,%rcx,4), %r10
decq %rcx
movsd (%rdx,%rcx,8), %xmm0
divsd -0x8(%r9,%r10,8), %xmm0
movsd %xmm0, (%rdx,%rcx,8)
movslq (%rsi,%rcx,4), %r11
decq %r10
cmpq %r10, %r11
jge 0xa796
movsd (%r9,%r11,8), %xmm0
movslq (%r8,%r11,4), %rbx
mulsd (%rdx,%rcx,8), %xmm0
movsd (%rdx,%rbx,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rbx,8)
incq %r11
jmp 0xa7b9
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0xa81e
movq 0x48(%rdi), %rsi
xorl %edi, %edi
cmpq %rdi, %rax
je 0xa803
movsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rdi
jmp 0xa7ef
xorl %edi, %edi
cmpq %rdi, %rax
je 0xa81e
movsd (%rsi,%rdi,8), %xmm0
movslq (%rcx,%rdi,4), %r8
movsd %xmm0, (%rdx,%r8,8)
incq %rdi
jmp 0xa805
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl (%rdi), %ecx
movq 0x18(%rdi), %r8
movq 0x10(%rdi), %rdi
xorl %r9d, %r9d
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
cmpq %r9, %rax
je 0xaa59
orl $-0x1, (%rsi,%r9,4)
incq %r9
jmp 0xaa4a
xorl %r9d, %r9d
movl $0x1, %r10d
cmpl %eax, %r9d
je 0xaade
xorl %r11d, %r11d
cmpq %r11, %rcx
je 0xaa79
andl $0x0, (%rdx,%r11,4)
incq %r11
jmp 0xaa6a
xorl %r11d, %r11d
movl %r10d, %ebx
cmpq %rax, %r11
je 0xaad1
cmpl $-0x1, (%rsi,%r11,4)
jne 0xaaa9
movslq (%rdi,%r11,4), %rbx
movslq 0x4(%rdi,%r11,4), %r14
cmpq %r14, %rbx
jge 0xaaae
movslq (%r8,%rbx,4), %r15
incq %rbx
cmpl $0x0, (%rdx,%r15,4)
je 0xaa94
xorl %ebx, %ebx
incq %r11
jmp 0xaa7f
movl %r9d, (%rsi,%r11,4)
movslq (%rdi,%r11,4), %rbx
movslq 0x4(%rdi,%r11,4), %r14
cmpq %r14, %rbx
jge 0xaaa7
movslq (%r8,%rbx,4), %r14
movl $0x1, (%rdx,%r14,4)
incq %rbx
jmp 0xaab6
cmpl $0x1, %ebx
je 0xaadb
incl %r9d
jmp 0xaa62
movl %r9d, %eax
decl %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb70e
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
pushq $0x2
popq %rax
cmpq %rsi, %rcx
je 0xb70e
cmpl $0x0, (%rdx,%rsi,4)
je 0xb709
movl $0x1, (%rdx,%rsi,4)
incq %rsi
jmp 0xb6f7
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/sparse.c
// Function: sp_tdfs
int sp_tdfs(int j, int k, int *head, const int *next, int *post, int *stack){
	int i, p, top =0;
	stack[0] = j;
	while(top>=0){
		p = stack[top];
		i = head[p];
		if (i==-1){
			top--;
			post[k++] = p;
		}
		else{
			head[p] = next[i];
			stack[++top] = i;
		}
	}
	return (k);
}

// Assembly:
movl %esi, %eax
movl %edi, (%r9)
xorl %esi, %esi
movl %esi, %esi
testl %esi, %esi
js 0xb74d
movl (%r9,%rsi,4), %edi
movslq %edi, %r11
movslq (%rdx,%r11,4), %r10
cmpq $-0x1, %r10
je 0xb740
movl (%rcx,%r10,4), %edi
movl %edi, (%rdx,%r11,4)
incq %rsi
movl %esi, %edi
movl %r10d, (%r9,%rdi,4)
jmp 0xb718
decl %esi
movslq %eax, %r10
incl %eax
movl %edi, (%r8,%r10,4)
jmp 0xb716
retq
nop
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/evolver_ndf15.c
// Function: lubksb
int lubksb(double **a, int n, int *indx, double b[]){
  int i,ii=0,ip,j;
  double sum;
  for (i=1;i<=n;i++) {
    ip=indx[i];
    sum=b[ip];
    b[ip]=b[i];
    if (ii) for (j=ii;j<=i-1;j++) sum -= a[i][j]*b[j];
    else if (sum) ii=i;
    b[i]=sum;
  }
  for (i=n;i>=1;i--) {
    sum=b[i];
    for (j=i+1;j<=n;j++) sum -= a[i][j]*b[j];
    b[i]=sum/a[i][i];
  }
  return _SUCCESS_;
}

// Assembly:
xorl %r8d, %r8d
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
incl %eax
pushq $0x1
popq %r9
xorpd %xmm0, %xmm0
cmpq %rax, %r9
je 0xfc1c
movslq (%rdx,%r9,4), %r10
movsd (%rcx,%r10,8), %xmm1
movsd (%rcx,%r9,8), %xmm2
movsd %xmm2, (%rcx,%r10,8)
testl %r8d, %r8d
je 0xfc01
movslq %r8d, %r10
cmpq %r9, %r10
jge 0xfc11
movq (%rdi,%r9,8), %r11
movsd (%r11,%r10,8), %xmm2
mulsd (%rcx,%r10,8), %xmm2
subsd %xmm2, %xmm1
incq %r10
jmp 0xfbe3
ucomisd %xmm0, %xmm1
jne 0xfc09
jnp 0xfc0e
movl %r9d, %r8d
jmp 0xfc11
xorl %r8d, %r8d
movsd %xmm1, (%rcx,%r9,8)
incq %r9
jmp 0xfbc0
movl %esi, %eax
leaq 0x1(%rax), %rdx
testl %eax, %eax
jle 0xfc69
movsd (%rcx,%rax,8), %xmm0
movq %rdx, %r8
movl %eax, %r9d
cmpl %esi, %r9d
jge 0xfc52
movq (%rdi,%rax,8), %r10
movsd (%r10,%r8,8), %xmm1
mulsd (%rcx,%r8,8), %xmm1
subsd %xmm1, %xmm0
incl %r9d
incq %r8
jmp 0xfc31
movq (%rdi,%rax,8), %r8
divsd (%r8,%rax,8), %xmm0
movsd %xmm0, (%rcx,%rax,8)
decq %rax
decq %rdx
jmp 0xfc22
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/evolver_ndf15.c
// Function: interp_from_dif
int interp_from_dif(double tinterp,
                    double tnew,
                    double *ynew,
                    double h,
                    double **dif,
                    int k,
                    double *yinterp,
                    double *ypinterp,
                    double *yppinterp,
                    int* mask,
                    int neq,
                    int output){
  /* Output=1: only y_vector. Output=2: y and y prime. Output=3: y, yp and ypp*/
  double fact,prod,sumfrac;
  double vecy[5]={0.,0.,0.,0.,0.};
  double vecdy[5]={0.,0.,0.,0.,0.};
  int j, index_x;
  double s, sumtmp, sumtmp2;

  s = (tinterp - tnew)/h;

  prod = 1.0;
  sumfrac = 0.;
  fact = 1.0;
  for (j=0; j<k; j++){
    prod *= (s+j);
    fact *= (j+1);
    sumfrac += 1.0/(s+j);
    vecy[j] = prod/fact;
    vecdy[j] = prod*sumfrac/(h*fact);
  }

  for (index_x=1; index_x<=neq; index_x++){
    if (mask[index_x]==_TRUE_){
      sumtmp = 0;
      sumtmp2 = 0;
      for (j=0; j<k; j++){
        sumtmp += vecy[j]*dif[index_x][j+1];
        sumtmp2 += vecdy[j]*dif[index_x][j+1];
      }
      yinterp[index_x] = ynew[index_x] + sumtmp;
      ypinterp[index_x] = sumtmp2;
    }
  }
  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movl 0x18(%rsp), %eax
movq 0x10(%rsp), %r9
xorps %xmm3, %xmm3
movaps %xmm3, -0x20(%rsp)
andq $0x0, -0x10(%rsp)
movaps %xmm3, -0x30(%rsp)
andq $0x0, -0x40(%rsp)
movaps %xmm3, -0x50(%rsp)
movaps %xmm3, -0x60(%rsp)
subsd %xmm1, %xmm0
divsd %xmm2, %xmm0
xorl %r10d, %r10d
testl %edx, %edx
cmovlel %r10d, %edx
xorpd %xmm1, %xmm1
movsd 0xd55aa(%rip), %xmm3    # 0xe5260
movapd %xmm3, %xmm4
movapd %xmm3, %xmm5
cmpq %r10, %rdx
je 0xfd18
cvtsi2sd %r10d, %xmm6
addsd %xmm0, %xmm6
mulsd %xmm6, %xmm4
leaq 0x1(%r10), %r11
cvtsi2sd %r11d, %xmm7
mulsd %xmm7, %xmm5
movapd %xmm3, %xmm7
divsd %xmm6, %xmm7
addsd %xmm7, %xmm1
movapd %xmm4, %xmm6
divsd %xmm5, %xmm6
movsd %xmm6, -0x30(%rsp,%r10,8)
movapd %xmm4, %xmm6
mulsd %xmm1, %xmm6
movapd %xmm5, %xmm7
mulsd %xmm2, %xmm7
divsd %xmm7, %xmm6
movsd %xmm6, -0x60(%rsp,%r10,8)
movq %r11, %r10
jmp 0xfcbe
xorl %r10d, %r10d
testl %eax, %eax
cmovlel %r10d, %eax
incl %eax
movabsq $0x1, %r10
cmpq %rax, %r10
je 0xfd8a
cmpl $0x1, (%r9,%r10,4)
jne 0xfd85
xorpd %xmm0, %xmm0
xorl %r11d, %r11d
cmpq %r11, %rdx
je 0xfd6f
movq (%rsi,%r10,8), %rbx
movsd -0x30(%rsp,%r11,8), %xmm1
movhpd -0x60(%rsp,%r11,8), %xmm1 # xmm1 = xmm1[0],mem[0]
movsd 0x8(%rbx,%r11,8), %xmm2
incq %r11
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm1, %xmm2
addpd %xmm2, %xmm0
jmp 0xfd40
movsd (%rdi,%r10,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%r10,8)
movhpd %xmm0, (%r8,%r10,8)
incq %r10
jmp 0xfd2d
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/evolver_ndf15.c
// Function: uninitialize_jacobian
int uninitialize_jacobian(struct jacobian *jac){
  free(jac->dfdy[1]);
  free(jac->dfdy);
  free(jac->LU[1]);
  free(jac->LU);

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

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

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

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

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

  int i;

  double h;

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

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

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

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

  }

  return _SUCCESS_;
}

// Assembly:
pushq %r14
pushq %rbx
movslq 0x18(%rsp), %rax
andq $0x0, (%rdx,%rax,8)
movslq %ecx, %rbx
movslq %r8d, %rcx
cmpl $0x2, %esi
movl $0x1, %r8d
cmovgel %esi, %r8d
movslq %r9d, %rsi
decl %r8d
shlq $0x3, %rsi
leaq (,%rbx,8), %r9
shlq $0x3, %rcx
shlq $0x3, %rax
leaq (%rsi,%rbx,8), %r10
leaq (%rcx,%rbx,8), %r11
leaq (%rax,%rbx,8), %rbx
xorl %r14d, %r14d
movsd 0xd4461(%rip), %xmm0    # 0xe5cb0
movsd 0xd4e01(%rip), %xmm1    # 0xe6658
cmpq %r14, %r8
je 0x118ad
movsd 0x8(%rdi,%r14,8), %xmm2
subsd (%rdi,%r14,8), %xmm2
movsd (%rdx,%rcx), %xmm3
addsd (%rdx,%r11), %xmm3
mulsd %xmm2, %xmm3
mulsd %xmm0, %xmm3
addsd (%rdx,%rax), %xmm3
incq %r14
movsd (%rdx,%rsi), %xmm4
addsd (%rdx,%r10), %xmm4
mulsd %xmm2, %xmm4
mulsd %xmm2, %xmm4
mulsd %xmm2, %xmm4
divsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%rdx,%rbx)
addq %r9, %rdx
jmp 0x11857
xorl %eax, %eax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate_all_spline
int array_integrate_all_spline(
		   double * array,
		   int n_columns,
		   int n_lines,
		   int index_x,   /** from 0 to (n_columns-1) */
		   int index_y,
		   int index_ddy,
		   double * result,
		   ErrorMsg errmsg) {

  int i;
  double h;

  *result = 0;

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

    h = (array[(i+1)*n_columns+index_x]-array[i*n_columns+index_x]);

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

  }

  return _SUCCESS_;
}

// Assembly:
movq 0x8(%rsp), %rax
movslq %esi, %rsi
movslq %ecx, %r10
movslq %r8d, %r11
movslq %r9d, %r9
cmpl $0x2, %edx
pushq $0x1
popq %rcx
cmovgel %edx, %ecx
decl %ecx
leaq (%rdi,%r10,8), %r8
leaq (%rdi,%r11,8), %rdx
leaq (%rdi,%r9,8), %rdi
shlq $0x3, %rsi
xorpd %xmm0, %xmm0
movsd 0xd0693(%rip), %xmm1    # 0xe5cb0
movsd 0xd1033(%rip), %xmm2    # 0xe6658
movsd %xmm0, (%rax)
subq $0x1, %rcx
jb 0x15677
movsd (%r8,%rsi), %xmm3
subsd (%r8), %xmm3
addq %rsi, %r8
movsd (%rdx), %xmm4
addsd (%rdx,%rsi), %xmm4
addq %rsi, %rdx
mulsd %xmm3, %xmm4
mulsd %xmm1, %xmm4
movsd (%rdi), %xmm5
addsd (%rdi,%rsi), %xmm5
addq %rsi, %rdi
mulsd %xmm3, %xmm5
mulsd %xmm3, %xmm5
mulsd %xmm3, %xmm5
divsd %xmm2, %xmm5
addsd %xmm4, %xmm5
addsd %xmm5, %xmm0
jmp 0x15625
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate_all_spline_table_line_to_line
int array_integrate_all_spline_table_line_to_line(
                  double * x_array,
                  int n_lines,
                  double * array,
                  int n_columns,
                  int index_y,
                  int index_ddy,
                  double * result,
                  ErrorMsg errmsg){

  int i;
  double h;

  *result = 0;

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

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

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

  }

  return _SUCCESS_;
}

// Assembly:
pushq %rbx
movq 0x10(%rsp), %rax
movslq %ecx, %r11
movslq %r8d, %rcx
movslq %r9d, %r8
cmpl $0x2, %esi
movl $0x1, %r9d
cmovgel %esi, %r9d
decl %r9d
shlq $0x3, %r8
leaq (,%r11,8), %rsi
shlq $0x3, %rcx
leaq (%r8,%r11,8), %r10
leaq (%rcx,%r11,8), %r11
xorpd %xmm0, %xmm0
xorl %ebx, %ebx
movsd 0xd05f1(%rip), %xmm1    # 0xe5cb0
movsd 0xd0f91(%rip), %xmm2    # 0xe6658
movsd %xmm0, (%rax)
cmpq %rbx, %r9
je 0x1571a
movsd 0x8(%rdi,%rbx,8), %xmm3
subsd (%rdi,%rbx,8), %xmm3
incq %rbx
movsd (%rdx,%rcx), %xmm4
addsd (%rdx,%r11), %xmm4
mulsd %xmm3, %xmm4
mulsd %xmm1, %xmm4
movsd (%rdx,%r8), %xmm5
addsd (%rdx,%r10), %xmm5
mulsd %xmm3, %xmm5
mulsd %xmm3, %xmm5
mulsd %xmm3, %xmm5
divsd %xmm2, %xmm5
addsd %xmm4, %xmm5
addsd %xmm5, %xmm0
addq %rsi, %rdx
jmp 0x156c7
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate
int array_integrate(
		   double * array,
		   int n_columns,
		   int n_lines,
		   int index_x,   /** from 0 to (n_columns-1) */
		   int index_y,
		   int index_int_y_dx,
		   ErrorMsg errmsg) {

  int i;
  double sum;

  if ((index_int_y_dx == index_x) || (index_int_y_dx == index_y)) {
    class_sprintf(errmsg,"%s(L:%d) : Output column %d must differ from input columns %d and %d",__func__,__LINE__,index_int_y_dx,index_x,index_y);
    return _FAILURE_;
  }

  sum=0.;
  *(array+0*n_columns+index_int_y_dx)=sum;

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

    sum += 0.5 * (*(array+i*n_columns+index_y) + *(array+(i-1)*n_columns+index_y))
               * (*(array+i*n_columns+index_x) - *(array+(i-1)*n_columns+index_x));

    *(array+i*n_columns+index_int_y_dx)=sum;
  }


  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %ebx
cmpl %ecx, %r9d
setne %al
cmpl %r8d, %r9d
setne %cl
testb %cl, %al
jne 0x1590e
movq 0x40(%rsp), %r15
leaq 0xd1486(%rip), %r12     # 0xe6d44
leaq 0xd17ab(%rip), %r13     # 0xe7070
xorl %edi, %edi
xorl %esi, %esi
movq %r12, %rdx
movq %r13, %rcx
movl $0x62f, %r8d            # imm = 0x62F
movl %ebp, %r9d
xorl %eax, %eax
pushq %r14
pushq %rbx
callq 0x8580
addq $0x10, %rsp
incl %eax
movslq %eax, %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
movl $0x62f, %r8d            # imm = 0x62F
movl %ebp, %r9d
xorl %eax, %eax
pushq %r14
pushq %rbx
callq 0x8580
popq %rcx
popq %rdx
pushq $0x1
popq %rax
jmp 0x1597f
movslq %ebp, %r10
andq $0x0, (%rdi,%r10,8)
movslq %r14d, %r9
movslq %ebx, %r8
movslq %edx, %rax
movslq %esi, %rcx
leaq (%rdi,%r8,8), %r8
shlq $0x3, %rcx
leaq (%rdi,%r9,8), %r9
leaq (%rcx,%r10,8), %rdx
addq %rdi, %rdx
xorpd %xmm0, %xmm0
pushq $0x1
popq %rsi
movsd 0xd036c(%rip), %xmm1    # 0xe5cb0
cmpq %rax, %rsi
jge 0x1597d
movsd (%r9,%rcx), %xmm2
addsd (%r9), %xmm2
addq %rcx, %r9
mulsd %xmm1, %xmm2
movsd (%r8,%rcx), %xmm3
subsd (%r8), %xmm3
addq %rcx, %r8
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
movsd %xmm0, (%rdx)
incq %rsi
addq %rcx, %rdx
jmp 0x15944
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate_ratio
int array_integrate_ratio(
		   double * array,
		   int n_columns,
		   int n_lines,
		   int index_x,   /** from 0 to (n_columns-1) */
		   int index_y1,
		   int index_y2,
		   int index_int_y1_over_y2_dx,
		   ErrorMsg errmsg) {

  int i;
  double sum;

  if ((index_int_y1_over_y2_dx == index_x) || (index_int_y1_over_y2_dx == index_y1) || (index_int_y1_over_y2_dx == index_y2)) {
    class_sprintf(errmsg,"%s(L:%d) : Output column %d must differ from input columns %d, %d and %d",__func__,__LINE__,index_int_y1_over_y2_dx,index_x,index_y1,index_y2);
    return _FAILURE_;
  }

  sum=0.;

  *(array+0*n_columns+index_int_y1_over_y2_dx)=sum;

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

    sum += 0.5 * (*(array+i*n_columns+index_y1) / *(array+i*n_columns+index_y2)
		  + *(array+(i-1)*n_columns+index_y1) / *(array+(i-1)*n_columns+index_y2))
      * (*(array+i*n_columns+index_x) - *(array+(i-1)*n_columns+index_x));

    *(array+i*n_columns+index_int_y1_over_y2_dx)=sum;
  }


  return _SUCCESS_;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movl %r8d, %r14d
movl %ecx, %ebx
movl 0x40(%rsp), %ebp
cmpl %r9d, %ebp
je 0x15a62
cmpl %ebx, %ebp
je 0x15a62
cmpl %r14d, %ebp
je 0x15a62
movslq %ebp, %r9
andq $0x0, (%rdi,%r9,8)
movslq %r14d, %rax
movslq %r15d, %rcx
movslq %ebx, %r8
movslq %edx, %rdx
movslq %esi, %rbx
shlq $0x3, %r8
leaq (,%rbx,8), %rsi
shlq $0x3, %rcx
shlq $0x3, %rax
shlq $0x3, %r9
leaq (%r9,%rbx,8), %r9
leaq (%r8,%rbx,8), %r10
leaq (%rcx,%rbx,8), %r11
leaq (%rax,%rbx,8), %rbx
xorpd %xmm0, %xmm0
pushq $0x1
popq %r14
movsd 0xd02a2(%rip), %xmm1    # 0xe5cb0
cmpq %rdx, %r14
jge 0x15a5e
movsd (%rdi,%rbx), %xmm2
movhpd (%rdi,%rax), %xmm2      # xmm2 = xmm2[0],mem[0]
movsd (%rdi,%r11), %xmm3
movhpd (%rdi,%rcx), %xmm3      # xmm3 = xmm3[0],mem[0]
divpd %xmm3, %xmm2
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
mulsd %xmm1, %xmm3
movsd (%rdi,%r10), %xmm2
subsd (%rdi,%r8), %xmm2
mulsd %xmm3, %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, (%rdi,%r9)
incq %r14
addq %rsi, %rdi
jmp 0x15a0e
xorl %eax, %eax
jmp 0x15ac7
subq $0x8, %rsp
leaq 0xd1613(%rip), %r13     # 0xe7080
leaq 0xd1655(%rip), %r12     # 0xe70c9
xorl %edi, %edi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movl $0x653, %r8d            # imm = 0x653
movl %ebp, %r9d
xorl %eax, %eax
pushq %r15
pushq %r14
pushq %rbx
callq 0x8580
addq $0x20, %rsp
incl %eax
movslq %eax, %rsi
subq $0x8, %rsp
movq 0x50(%rsp), %rdi
movq %r13, %rdx
movq %r12, %rcx
movl $0x653, %r8d            # imm = 0x653
movl %ebp, %r9d
xorl %eax, %eax
pushq %r15
pushq %r14
pushq %rbx
callq 0x8580
addq $0x20, %rsp
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_interpolate_equal
int array_interpolate_equal(
			    double * array,
			    int n_columns,
			    int n_lines,
			    double x,
			    double x_min,
			    double x_max,
			    double * result,
			    ErrorMsg errmsg) {

  int index_minus,i;
  double x_step,x_minus,weight;

  if (x < x_min) {
    class_sprintf(errmsg,"%s(L:%d) : x out of bounds: x=%e,x_min=%e",__func__,__LINE__,x,x_min);
    return _FAILURE_;
  }

  if (x > x_max) {
    class_sprintf(errmsg,"%s(L:%d) : x out of bounds: x=%e,x_max=%e",__func__,__LINE__,x,x_max);
    return _FAILURE_;
  }

  x_step = (x_max-x_min)/(n_lines-1);
  index_minus = (int)((x-x_min)/x_step);
  x_minus = index_minus * x_step;
  weight = (x-x_minus) / x_step;

  for (i=0; i<n_columns; i++)
    result[i] = *(array+n_columns*index_minus+i)*(1.-weight)
      + *(array+n_columns*(index_minus+1)+i)*weight;

  return _SUCCESS_;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
ucomisd %xmm0, %xmm1
jbe 0x187c4
leaq 0xcecb1(%rip), %r14     # 0xe7436
leaq 0xcecd4(%rip), %r15     # 0xe7460
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
movl $0xbb6, %r8d            # imm = 0xBB6
movb $0x2, %al
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
callq 0x8580
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl $0xbb6, %r8d            # imm = 0xBB6
jmp 0x18812
ucomisd %xmm2, %xmm0
jbe 0x18831
leaq 0xceca7(%rip), %r14     # 0xe7478
leaq 0xcec88(%rip), %r15     # 0xe7460
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
movl $0xbbb, %r8d            # imm = 0xBBB
movapd %xmm2, %xmm1
movb $0x2, %al
movsd %xmm0, 0x8(%rsp)
movsd %xmm2, (%rsp)
callq 0x8580
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl $0xbbb, %r8d            # imm = 0xBBB
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
movb $0x2, %al
callq 0x8580
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
subsd %xmm1, %xmm2
decl %edx
cvtsi2sd %edx, %xmm3
divsd %xmm3, %xmm2
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
divsd %xmm2, %xmm3
cvttsd2si %xmm3, %eax
cvttpd2dq %xmm3, %xmm1
cvtdq2pd %xmm1, %xmm1
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
divsd %xmm2, %xmm0
movl %eax, %edx
imull %esi, %edx
movslq %edx, %rdx
leaq (%rdi,%rdx,8), %rdx
movsd 0xcc9e9(%rip), %xmm3    # 0xe5260
subsd %xmm0, %xmm3
incl %eax
imull %esi, %eax
cltq
leaq (%rdi,%rax,8), %rdi
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x18827
movsd (%rdi,%r8,8), %xmm1
mulsd %xmm0, %xmm1
movsd (%rdx,%r8,8), %xmm2
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rcx,%r8,8)
incq %r8
jmp 0x18890
// File: /workspace/github_c_makefile_star2_O2/PoulinV[P]AxiCLASS/build/../tools/arrays.c
// Function: array_integrate_all
int array_integrate_all(
		   double * array,
		   int n_columns,
		   int n_lines,
		   int index_x,   /** from 0 to (n_columns-1) */
		   int index_y,
		   double *result) {

  int i;
  double sum;

  sum=0.;

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

    sum += 0.5 * (*(array+i*n_columns+index_y) + *(array+(i-1)*n_columns+index_y))
               * (*(array+i*n_columns+index_x) - *(array+(i-1)*n_columns+index_x));

  }

  *result = sum;

  return _SUCCESS_;

}

// Assembly:
movslq %r8d, %r8
movslq %ecx, %r10
movslq %edx, %rax
movslq %esi, %rcx
leaq (%rdi,%r10,8), %rsi
shlq $0x3, %rcx
leaq (%rdi,%r8,8), %rdi
xorpd %xmm0, %xmm0
pushq $0x1
popq %rdx
movsd 0xcd0c7(%rip), %xmm1    # 0xe5cb0
cmpq %rax, %rdx
jge 0x18c17
movsd (%rdi,%rcx), %xmm2
addsd (%rdi), %xmm2
addq %rcx, %rdi
mulsd %xmm1, %xmm2
movsd (%rsi,%rcx), %xmm3
subsd (%rsi), %xmm3
addq %rcx, %rsi
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
incq %rdx
jmp 0x18be9
movsd %xmm0, (%r9)
xorl %eax, %eax
retq