LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: coef1
double coef1(double z){
  const double A[5] = {1.1282427601,-0.6803534e-4,0.16687e-6,-0.128e-8,0.2e-10};
  const double B[5] = {0.7822108673e-1,-0.6895649e-4,0.32857e-6,-0.37e-8,0.7e-10};
  double x,y,t,Ai,zeta,theta,sintheta,costheta,FA,FB;

  x = -z;
  zeta = _TWO_OVER_THREE_*x*sqrt(x);
  theta = zeta+0.25*_PI_;
  sintheta = sin(theta);
  costheta = cos(theta);

  y = pow(7.0/x,3);//y = (7.0/x)*(7.0/x)*(7.0/x);
  FA = cheb(y,5,A);
  FB = cheb(y,5,B)/zeta;

  t = pow(x,-0.25);
  Ai = t*(sintheta*FA-costheta*FB);
  //Bi = t*(costheta*FA+sintheta*FB);
  return Ai;
}

// Assembly:
subq $0xc8, %rsp
movsd %xmm0, 0xc0(%rsp)
leaq 0x90(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x8210
movsd 0x1915b4(%rip), %xmm0   # 0x1d5590
movsd %xmm0, 0x90(%rsp)
movsd 0x19159b(%rip), %xmm0   # 0x1d5588
movsd %xmm0, 0x98(%rsp)
movsd 0x191582(%rip), %xmm0   # 0x1d5580
movsd %xmm0, 0xa0(%rsp)
movsd 0x191569(%rip), %xmm0   # 0x1d5578
movsd %xmm0, 0xa8(%rsp)
movsd 0x191550(%rip), %xmm0   # 0x1d5570
movsd %xmm0, 0xb0(%rsp)
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x8210
movsd 0x191526(%rip), %xmm0   # 0x1d5568
movsd %xmm0, 0x60(%rsp)
movsd 0x191510(%rip), %xmm0   # 0x1d5560
movsd %xmm0, 0x68(%rsp)
movsd 0x1914fa(%rip), %xmm0   # 0x1d5558
movsd %xmm0, 0x70(%rsp)
movsd 0x1914e4(%rip), %xmm0   # 0x1d5550
movsd %xmm0, 0x78(%rsp)
movsd 0x1914ce(%rip), %xmm0   # 0x1d5548
movsd %xmm0, 0x80(%rsp)
movsd 0xc0(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x191487(%rip), %xmm0   # 0x1d5538
mulsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x58(%rsp), %xmm0
callq 0x82e0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x19145d(%rip), %xmm0   # 0x1d5540
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x80a0
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x86a0
movsd %xmm0, 0x20(%rsp)
movsd 0x18f66f(%rip), %xmm0   # 0x1d3788
divsd 0x58(%rsp), %xmm0
movl $0x3, %edi
callq 0x5b970
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
leaq 0x90(%rsp), %rsi
movl $0x5, %edi
callq 0x44520
movsd %xmm0, 0x18(%rsp)
movsd 0x50(%rsp), %xmm0
leaq 0x60(%rsp), %rsi
movl $0x5, %edi
callq 0x44520
divsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x58(%rsp), %xmm0
movsd 0x18e0d4(%rip), %xmm1   # 0x1d2250
callq 0x8610
movsd %xmm0, 0x48(%rsp)
movsd 0x48(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0x18(%rsp), %xmm3
movsd 0x20(%rsp), %xmm2
mulsd 0x10(%rsp), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0xc8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: coef2
double coef2(double z){
  const double A[17] = {0.11535880704,0.6542816649e-1,0.26091774326,0.21959346500,
              0.12476382168,-0.43476292594,0.28357718605,-0.9751797082e-1,
              0.2182551823e-1,-0.350454097e-2,0.42778312e-3,
              -0.4127564e-4,0.323880e-5,-0.21123e-6,0.1165e-7,
              -0.55e-9,0.2e-10};
  const double B[16] = {0.10888288487,-0.17511655051,0.13887871101,-0.11469998998,
             0.22377807641,-0.18546243714,0.8063565186e-1,
             -0.2208847864e-1,0.422444527e-2,-0.60131028e-3,
             0.6653890e-4,-0.590842e-5,0.43131e-6,-0.2638e-7,
             0.137e-8,-0.6e-10};
  //Ej = 3^(-j/3)/Gamma(j/3);
  double E1 = 0.355028053887817, E2 = 0.258819403792807;
  double x,FA,FB,Ai;
  x = -(z/7.0)*(z/7.0)*(z/7.0);
  FA = E1*cheb(x,17,A);
  FB = E2*z*cheb(x,16,B);
  Ai = FA-FB;
  //Bi = sqrt(3)*(FA+FB);
  return Ai;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movsd %xmm0, 0x150(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x191851(%rip), %rsi    # 0x1d5a50
movl $0x88, %edx
callq 0x8300
leaq 0x40(%rsp), %rdi
leaq 0x1918cb(%rip), %rsi    # 0x1d5ae0
movl $0x80, %edx
callq 0x8300
movsd 0x191379(%rip), %xmm0   # 0x1d55a0
movsd %xmm0, 0x38(%rsp)
movsd 0x191363(%rip), %xmm0   # 0x1d5598
movsd %xmm0, 0x30(%rsp)
movsd 0x150(%rsp), %xmm0
movsd 0x18f53c(%rip), %xmm1   # 0x1d3788
divsd %xmm1, %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x150(%rsp), %xmm1
movsd 0x18f510(%rip), %xmm2   # 0x1d3788
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0x150(%rsp), %xmm1
movsd 0x18f4f7(%rip), %xmm2   # 0x1d3788
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x28(%rsp), %xmm0
leaq 0xc0(%rsp), %rsi
movl $0x11, %edi
callq 0x44520
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x30(%rsp), %xmm0
mulsd 0x150(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
leaq 0x40(%rsp), %rsi
movl $0x10, %edi
callq 0x44520
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x158, %rsp            # imm = 0x158
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: coef3
double coef3(double z){
  const double A[20] = {1.2974695794,-0.20230907821,
              -0.45786169516,0.12953331987,0.6983827954e-1,
              -0.3005148746e-1,-0.493036334e-2,0.390425474e-2,
              -0.1546539e-4,-0.32193999e-3,0.3812734e-4,0.1714935e-4,
              -0.416096e-5,-0.50623e-6,0.26346e-6,-0.281e-8,
              -0.1122e-7,0.120e-8,0.31e-9,-0.7e-10};
  /**
double B[25]={0.47839902387,-0.6881732880e-1,0.20938146768,
            -0.3988095886e-1,0.4758441683e-1,-0.812296149e-2,
            0.462845913e-2,0.70010098e-3,-0.75611274e-3,
            0.68958657e-3,-0.33621865e-3,0.14501668e-3,-0.4766359e-4,
            0.1251965e-4,-0.193012e-5,-0.19032e-6,0.29390e-6,
            -0.13436e-6,0.4231e-7,-0.967e-8,0.135e-8,0.7e-10,
            -0.12e-9,0.4e-10,-0.1e-10};
  */
  double x,EX,EY,Ai;
  x = z/7.0;
  EX = exp(1.75*z);
  EY = 1.0/EX;

  Ai = EY*cheb(x,20,A);
  //Bi = EX*cheb(x,25,&(B[0]));
  return Ai;
}

// Assembly:
subq $0xd8, %rsp
movsd %xmm0, 0xd0(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x191804(%rip), %rsi    # 0x1d5b60
movl $0xa0, %edx
callq 0x8300
movsd 0xd0(%rsp), %xmm0
movsd 0x18f411(%rip), %xmm1   # 0x1d3788
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x19121f(%rip), %xmm0   # 0x1d55a8
mulsd 0xd0(%rsp), %xmm0
callq 0x8670
movsd %xmm0, 0x20(%rsp)
movsd 0x18dea3(%rip), %xmm0   # 0x1d2248
divsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
leaq 0x30(%rsp), %rsi
movl $0x14, %edi
callq 0x44520
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: coef4
double coef4(double z){
  const double A[7]={0.56265126169,-0.76136219e-3,0.765252e-5,-0.14228e-6,
            0.380e-8,-0.13e-9,0.1e-10};
  /**  double B[7]={1.1316635302,0.166141673e-02,0.1968882e-04,0.47047e-06,
            0.1769e-7,0.94e-9,0.6e-10};
  */
  double x,Y,t,zeta,EX,EY,Ai;

  Y = z*sqrt(z);
  zeta = 2.0/3.0*Y;
  EX = exp(zeta);
  EY = 1.0/EX;
  x = 7*sqrt(7)/Y;
  t = pow(z,-0.25);

  Ai = t*EY*cheb(x, 7, A);
  //Bi = t*EX*cheb(x, 7, &(B[0]));
  return Ai;
}

// Assembly:
subq $0x98, %rsp
movsd %xmm0, 0x90(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x1917e4(%rip), %rsi    # 0x1d5c00
movl $0x38, %edx
callq 0x8300
movsd 0x90(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x90(%rsp), %xmm0
callq 0x82e0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x1910da(%rip), %xmm0   # 0x1d5538
mulsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x8670
movsd %xmm0, 0x28(%rsp)
movsd 0x18ddc5(%rip), %xmm0   # 0x1d2248
divsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x7, %edi
callq 0x5b9a0
movaps %xmm0, %xmm1
movsd 0x18f2e4(%rip), %xmm0   # 0x1d3788
mulsd %xmm1, %xmm0
divsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd 0x90(%rsp), %xmm0
movsd 0x18dd8b(%rip), %xmm1   # 0x1d2250
callq 0x8610
movsd %xmm0, 0x38(%rsp)
movsd 0x38(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x48(%rsp), %xmm0
leaq 0x50(%rsp), %rsi
movl $0x7, %edi
callq 0x44520
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: cheb
double cheb(double x, int n, const double A[]){
  double b,d,u,y,c,F;
  int j;
  b = 0.0;
  d = A[n-1];
  u = 2*x-1.0;
  y = 2*u;

  for (j=(n-1);j>1;j--){
    c=b;
    b=d;
    d=y*b-c+A[j-1];
  }
  F = u*d-b+0.5*A[0];
  return F;
}

// Assembly:
movsd %xmm0, -0x8(%rsp)
movl %edi, -0xc(%rsp)
movq %rsi, -0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rsp)
movq -0x18(%rsp), %rax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x8(%rsp), %xmm0
addsd %xmm0, %xmm0
movsd 0x18e26c(%rip), %xmm1   # 0x1d27d0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rsp)
movsd 0x18e70a(%rip), %xmm0   # 0x1d2c80
mulsd -0x30(%rsp), %xmm0
movsd %xmm0, -0x38(%rsp)
movl -0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x4c(%rsp)
cmpl $0x1, -0x4c(%rsp)
jle 0x44604
movsd -0x20(%rsp), %xmm0
movsd %xmm0, -0x40(%rsp)
movsd -0x28(%rsp), %xmm0
movsd %xmm0, -0x20(%rsp)
movsd -0x38(%rsp), %xmm0
movsd -0x20(%rsp), %xmm2
movsd -0x40(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rsp), %rax
movl -0x4c(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rsp)
movl -0x4c(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x4c(%rsp)
jmp 0x4458d
movsd -0x30(%rsp), %xmm1
movsd -0x28(%rsp), %xmm2
movsd -0x20(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd 0x18e642(%rip), %xmm2   # 0x1d2c88
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rsp)
movsd -0x48(%rsp), %xmm0
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: get_value_at_small_phi
double get_value_at_small_phi(int K,int l,double beta,double Phi){
  double nu, lhs, alpha, xval;

  nu = l+0.5;
  lhs = 1.0/nu*log(2*Phi*nu);
  alpha = -2*lhs/5.0*(1.0+2.0*cosh(1.0/3.0*acosh(1.0+375/(16.0*lhs*lhs))));
  xval = nu/cosh(alpha)/beta;
  //Correct for geometry:
  if (K==1)
    xval *= asin(l/beta)/(l/beta);
  else if(K==-1)
    xval *= asinh(l/beta)/(l/beta);
  return xval;
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movl %esi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movsd %xmm1, 0x40(%rsp)
cvtsi2sdl 0x50(%rsp), %xmm0
movsd 0x18e602(%rip), %xmm1   # 0x1d2c88
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x18dbb0(%rip), %xmm0   # 0x1d2248
divsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18e5d4(%rip), %xmm0   # 0x1d2c80
mulsd 0x40(%rsp), %xmm0
mulsd 0x38(%rsp), %xmm0
callq 0x82f0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x18f0a8(%rip), %xmm0   # 0x1d3780
mulsd 0x30(%rsp), %xmm0
movsd 0x18db8a(%rip), %xmm1   # 0x1d2270
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18e0e0(%rip), %xmm0   # 0x1d27d8
mulsd 0x30(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
movsd 0x190d94(%rip), %xmm1   # 0x1d54a0
divsd %xmm0, %xmm1
movsd 0x18db30(%rip), %xmm0   # 0x1d2248
addsd %xmm1, %xmm0
callq 0x8620
movaps %xmm0, %xmm1
movsd 0x190d6c(%rip), %xmm0   # 0x1d5498
mulsd %xmm1, %xmm0
callq 0x84a0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm1
movsd 0x18dafe(%rip), %xmm2   # 0x1d2248
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x84a0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
divsd %xmm1, %xmm0
divsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
cmpl $0x1, 0x54(%rsp)
jne 0x447be
cvtsi2sdl 0x50(%rsp), %xmm0
divsd 0x48(%rsp), %xmm0
callq 0x8590
cvtsi2sdl 0x50(%rsp), %xmm1
divsd 0x48(%rsp), %xmm1
divsd %xmm1, %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x447f4
cmpl $-0x1, 0x54(%rsp)
jne 0x447f2
cvtsi2sdl 0x50(%rsp), %xmm0
divsd 0x48(%rsp), %xmm0
callq 0x8480
cvtsi2sdl 0x50(%rsp), %xmm1
divsd 0x48(%rsp), %xmm1
divsd %xmm1, %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x447f4
movsd 0x20(%rsp), %xmm0
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/hyperspherical.c
// Function: PhiWKB_minus_phiminabs
double PhiWKB_minus_phiminabs(double x, void *param){
   double phiwkb;
   struct WKB_parameters *wkbparam = (struct WKB_parameters *)param;
   hyperspherical_WKB(wkbparam->K,wkbparam->l,wkbparam->beta,x, &phiwkb);
   return(fabs(phiwkb)-wkbparam->phiminabs);
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %edi
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x20(%rsp), %xmm1
leaq 0x10(%rsp), %rdx
callq 0x43790
movsd 0x10(%rsp), %xmm0
movaps 0x18d301(%rip), %xmm1   # 0x1d2230
pand %xmm1, %xmm0
movq 0x8(%rsp), %rax
subsd 0x10(%rax), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/common.c
// Function: class_protect_fprintf
void class_protect_fprintf(FILE* stream, char* tpl,...) {
  va_list args;
  char dest[6000];
  va_start(args,tpl);
  vsnprintf(dest, 2048,tpl,args);
  va_end(args);
  fprintf(stream,"%s",dest);
}

// Assembly:
subq $0x1858, %rsp           # imm = 0x1858
testb %al, %al
je 0x5babf
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0x1850(%rsp)
movq %rsi, 0x1848(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x1840(%rsp)
leaq 0x1860(%rsp), %rax
movq %rax, 0x1838(%rsp)
movl $0x30, 0x1834(%rsp)
movl $0x10, 0x1830(%rsp)
movq 0x1848(%rsp), %rdx
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x800, %esi            # imm = 0x800
leaq 0x1830(%rsp), %rcx
callq 0x8270
movq 0x8(%rsp), %rdx
movq 0x1850(%rsp), %rdi
leaq 0x19356e(%rip), %rsi    # 0x1ef0bf
xorl %eax, %eax
callq 0x84e0
addq $0x1858, %rsp           # imm = 0x1858
retq
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/common.c
// Function: get_number_of_titles
int get_number_of_titles(char * titlestring){
  int i;
  int number_of_titles=0;

  for (i=0; i<strlen(titlestring); i++){
    if (titlestring[i] == '\t')
      number_of_titles++;
  }
  return number_of_titles;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x8190
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x5bc05
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x5bbf6
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5bbf8
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5bbb9
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/common.c
// Function: file_exists
int file_exists(const char *fname){
  FILE *file = fopen(fname, "r");
  if (file != NULL){
    fclose(file);
    return _TRUE_;
  }

  return _FALSE_;

}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x195012(%rip), %rsi    # 0x1f0c37
callq 0x8410
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x5bc48
movq (%rsp), %rdi
callq 0x83c0
movl $0x1, 0x14(%rsp)
jmp 0x5bc50
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/common.c
// Function: compare_doubles
int compare_doubles(const void *a,
                    const void *b){
  double *x = (double *) a;
  double *y = (double *) b;
  if (*x < *y)
    return -1;
  else if
    (*x > *y) return 1;
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movsd (%rax), %xmm1
movq -0x28(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5bca0
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x5bcc8
movq -0x20(%rsp), %rax
movsd (%rax), %xmm0
movq -0x28(%rsp), %rax
ucomisd (%rax), %xmm0
jbe 0x5bcbe
movl $0x1, -0x4(%rsp)
jmp 0x5bcc8
jmp 0x5bcc0
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../tools/common.c
// Function: string_begins_with
int string_begins_with(char* thestring, char beginchar){

  /** Define temporary variables */
  int int_temp=0;
  int strlength = strlen((thestring));
  int result = _FALSE_;

  /** Check through the beginning of the string to see if the beginchar is met */
  for(int_temp=0;int_temp<strlength;++int_temp){
    /* Skip over whitespaces (very important) */
    if(thestring[int_temp]==' ' || thestring[int_temp]=='\t'){continue;}
    /* If the beginchar is met, everything is good */
    else if(thestring[int_temp]==beginchar){result=_TRUE_;}
    /* If something else is met, cancel */
    else{break;}
  }

  return result;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8190
movl %eax, 0x4(%rsp)
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x5bd6a
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x5bd35
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x5bd37
jmp 0x5bd5d
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0xf(%rsp), %ecx
cmpl %ecx, %eax
jne 0x5bd57
movl $0x1, (%rsp)
jmp 0x5bd59
jmp 0x5bd6a
jmp 0x5bd5b
jmp 0x5bd5d
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5bd05
movl (%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: background_at_tau
int background_at_tau(
                      struct background *pba,
                      double tau,
                      enum vecback_format return_format,
                      enum interpolation_method inter_mode,
                      int * last_index,
                      double * pvecback /* vector with argument pvecback[index_bg] (must be already allocated with a size compatible with return_format) */
                      ) {

  /** Summary: */

  /** - define local variables */
  double z;

  /** - Get current redshift */
  class_call(background_z_of_tau(pba,tau,&z),
             pba->error_message,
             pba->error_message);

  /** - Get background at corresponding redshift */
  class_call(background_at_z(pba,z,return_format,inter_mode,last_index,pvecback),
             pba->error_message,
             pba->error_message);

  return _SUCCESS_;
}

// Assembly:
subq $0x1038, %rsp           # imm = 0x1038
movq %rdi, 0x1028(%rsp)
movsd %xmm0, 0x1020(%rsp)
movl %esi, 0x101c(%rsp)
movl %edx, 0x1018(%rsp)
movq %rcx, 0x1010(%rsp)
movq %r8, 0x1008(%rsp)
movq 0x1028(%rsp), %rdi
movsd 0x1020(%rsp), %xmm0
leaq 0x1000(%rsp), %rsi
callq 0x9eb30
cmpl $0x1, %eax
jne 0x9ea76
leaq 0x800(%rsp), %rdi
movq 0x1028(%rsp), %rcx
addq $0xd1c, %rcx            # imm = 0xD1C
leaq 0x1339b1(%rip), %rsi    # 0x1d23d8
leaq 0x14ffcb(%rip), %rdx    # 0x1ee9f9
movb $0x0, %al
callq 0x5b9c0
movq 0x1028(%rsp), %rdi
addq $0xd1c, %rdi            # imm = 0xD1C
leaq 0x800(%rsp), %r8
leaq 0x1335e1(%rip), %rsi    # 0x1d2034
leaq 0x14ffbf(%rip), %rdx    # 0x1eea19
movl $0xfa, %ecx
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x1034(%rsp)
jmp 0x9eb1a
movq 0x1028(%rsp), %rdi
movsd 0x1000(%rsp), %xmm0
movl 0x101c(%rsp), %esi
movl 0x1018(%rsp), %edx
movq 0x1010(%rsp), %rcx
movq 0x1008(%rsp), %r8
callq 0x9e4b0
cmpl $0x1, %eax
jne 0x9eb0f
movq %rsp, %rdi
movq 0x1028(%rsp), %rcx
addq $0xd1c, %rcx            # imm = 0xD1C
leaq 0x133910(%rip), %rsi    # 0x1d23d8
leaq 0x14ff5c(%rip), %rdx    # 0x1eea2b
movb $0x0, %al
callq 0x5b9c0
movq 0x1028(%rsp), %rdi
addq $0xd1c, %rdi            # imm = 0xD1C
movq %rsp, %r8
leaq 0x133545(%rip), %rsi    # 0x1d2034
leaq 0x14ff23(%rip), %rdx    # 0x1eea19
movl $0xff, %ecx
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x1034(%rsp)
jmp 0x9eb1a
movl $0x0, 0x1034(%rsp)
movl 0x1034(%rsp), %eax
addq $0x1038, %rsp           # imm = 0x1038
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: V_scf
double V_scf(
             struct background *pba,
             double phi) {
  /** we check first which potential should be considered */
  double result = 0.;
  if(pba->scf_potential == pol_times_exp){
    result =  V_e_scf(pba,phi)*V_p_scf(pba,phi);
  }
  else if(pba->scf_potential == double_exp){
    result = V_double_exp_scf(pba,phi);
  }
  else if(pba->scf_potential == axion){
    result = V_axion_scf(pba,phi);
  }
  else if(pba->scf_potential == phi_2n){
    result = V_phi_2n_scf(pba,phi);
  }
  else if(pba->scf_potential == axionquad){
    result = V_axionquad_scf(pba,phi);
  }
    // printf("result Vf %e\n", result);

  return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x160(%rax)
jne 0xa1224
movq 0x20(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0xaf680
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0xaf7c0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0xa12c2
movq 0x20(%rsp), %rax
cmpl $0x1, 0x160(%rax)
jne 0xa124a
movq 0x20(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0xaf960
movsd %xmm0, 0x10(%rsp)
jmp 0xa12c0
movq 0x20(%rsp), %rax
cmpl $0x2, 0x160(%rax)
jne 0xa1270
movq 0x20(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0xafd00
movsd %xmm0, 0x10(%rsp)
jmp 0xa12be
movq 0x20(%rsp), %rax
cmpl $0x3, 0x160(%rax)
jne 0xa1296
movq 0x20(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0xb0300
movsd %xmm0, 0x10(%rsp)
jmp 0xa12bc
movq 0x20(%rsp), %rax
cmpl $0x4, 0x160(%rax)
jne 0xa12ba
movq 0x20(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0xb04c0
movsd %xmm0, 0x10(%rsp)
jmp 0xa12bc
jmp 0xa12be
jmp 0xa12c0
jmp 0xa12c2
movsd 0x10(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: dV_scf
double dV_scf(
              struct background *pba,
	      double phi) {
  /** we check first which potential should be considered */
  double result = 0.;
  if(pba->scf_potential == pol_times_exp){
    result =  dV_e_scf(pba,phi)*V_p_scf(pba,phi) + V_e_scf(pba,phi)*dV_p_scf(pba,phi);
  }
  else if(pba->scf_potential == double_exp){
    result =  dV_double_exp_scf(pba,phi);
  }
  else if(pba->scf_potential == axion){
    result = dV_axion_scf(pba,phi);
  }
  else if(pba->scf_potential == phi_2n){
    result = dV_phi_2n_scf(pba,phi);
  }
  else if(pba->scf_potential == axionquad){
    result = dV_axionquad_scf(pba,phi);
  }

  // printf("result dVf %e\n", result);

  return result;

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rax
cmpl $0x0, 0x160(%rax)
jne 0xa1374
movq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0xaf6d0
movsd %xmm0, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0xaf7c0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0xaf680
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0xaf840
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x18(%rsp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0xa1412
movq 0x30(%rsp), %rax
cmpl $0x1, 0x160(%rax)
jne 0xa139a
movq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0xafa50
movsd %xmm0, 0x20(%rsp)
jmp 0xa1410
movq 0x30(%rsp), %rax
cmpl $0x2, 0x160(%rax)
jne 0xa13c0
movq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0xafe60
movsd %xmm0, 0x20(%rsp)
jmp 0xa140e
movq 0x30(%rsp), %rax
cmpl $0x3, 0x160(%rax)
jne 0xa13e6
movq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0xb0370
movsd %xmm0, 0x20(%rsp)
jmp 0xa140c
movq 0x30(%rsp), %rax
cmpl $0x4, 0x160(%rax)
jne 0xa140a
movq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0xb0530
movsd %xmm0, 0x20(%rsp)
jmp 0xa140c
jmp 0xa140e
jmp 0xa1410
jmp 0xa1412
movsd 0x20(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: ddV_scf
double ddV_scf(
               struct background *pba,
               double phi) {
  /** we check first which potential should be considered */
  double result = 0.;

  if(pba->scf_potential == pol_times_exp){
    result =  ddV_e_scf(pba,phi)*V_p_scf(pba,phi) + 2*dV_e_scf(pba,phi)*dV_p_scf(pba,phi) + V_e_scf(pba,phi)*ddV_p_scf(pba,phi);
  }

  else if(pba->scf_potential == double_exp){
    result =  ddV_double_exp_scf(pba,phi);
  }
  else if(pba->scf_potential == axion){
    result = ddV_axion_scf(pba,phi);
  }
  else if(pba->scf_potential == phi_2n){
    result = ddV_phi_2n_scf(pba,phi);
  }
  else if(pba->scf_potential == axionquad){
    result = ddV_axionquad_scf(pba,phi);
  }


  // printf("result ddVf %e\n", result);
  return result;

}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rax
cmpl $0x0, 0x160(%rax)
jne 0xa151a
movq 0x40(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
callq 0xaf740
movsd %xmm0, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
callq 0xaf7c0
movsd %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
callq 0xaf6d0
movaps %xmm0, %xmm1
movsd 0x1317ef(%rip), %xmm0   # 0x1d2c80
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
callq 0xaf840
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x18(%rsp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
callq 0xaf680
movsd %xmm0, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
callq 0xaf8c0
movsd 0x20(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x28(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0xa15b8
movq 0x40(%rsp), %rax
cmpl $0x1, 0x160(%rax)
jne 0xa1540
movq 0x40(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
callq 0xafbb0
movsd %xmm0, 0x30(%rsp)
jmp 0xa15b6
movq 0x40(%rsp), %rax
cmpl $0x2, 0x160(%rax)
jne 0xa1566
movq 0x40(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
callq 0xaffc0
movsd %xmm0, 0x30(%rsp)
jmp 0xa15b4
movq 0x40(%rsp), %rax
cmpl $0x3, 0x160(%rax)
jne 0xa158c
movq 0x40(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
callq 0xb03f0
movsd %xmm0, 0x30(%rsp)
jmp 0xa15b2
movq 0x40(%rsp), %rax
cmpl $0x4, 0x160(%rax)
jne 0xa15b0
movq 0x40(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
callq 0xb0570
movsd %xmm0, 0x30(%rsp)
jmp 0xa15b2
jmp 0xa15b4
jmp 0xa15b6
jmp 0xa15b8
movsd 0x30(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: background_varconst_of_z
int background_varconst_of_z(
                             struct background* pba,
                             double z,
                             double* alpha,
                             double* me
                             ){

  switch(pba->varconst_dep){

  case varconst_none:
    *alpha = 1.;
    *me = 1.;
    break;

  case varconst_instant:
    if (z>pba->varconst_transition_redshift){
      *alpha = pba->varconst_alpha;
      *me = pba->varconst_me;
    }
    else{
      *alpha = 1.;
      *me = 1.;
    }
    break;

    /* Implement here your arbitrary model of varying fundamental constants! */
  }
  return _SUCCESS_;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movl 0x2f8(%rax), %eax
movl %eax, -0x24(%rsp)
testl %eax, %eax
je 0xa28a8
jmp 0xa289a
movl -0x24(%rsp), %eax
subl $0x1, %eax
je 0xa28cc
jmp 0xa2933
movq -0x18(%rsp), %rax
movsd 0x12f993(%rip), %xmm0   # 0x1d2248
movsd %xmm0, (%rax)
movq -0x20(%rsp), %rax
movsd 0x12f982(%rip), %xmm0   # 0x1d2248
movsd %xmm0, (%rax)
jmp 0xa2933
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
ucomisd 0x300(%rax), %xmm0
jbe 0xa290f
movq -0x8(%rsp), %rax
movsd 0x2e8(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movsd 0x2f0(%rax), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0xa2931
movq -0x18(%rsp), %rax
movsd 0x12f92c(%rip), %xmm0   # 0x1d2248
movsd %xmm0, (%rax)
movq -0x20(%rsp), %rax
movsd 0x12f91b(%rip), %xmm0   # 0x1d2248
movsd %xmm0, (%rax)
jmp 0xa2933
xorl %eax, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../include/background.h
// Function: gsl_sf_gamma
static double gsl_sf_gamma(double z) {
    /* Lanczos coefficients for g = 7 */
    static double p[] = {
        0.99999999999980993227684700473478,
        676.520368121885098567009190444019,
       -1259.13921672240287047156078755283,
        771.3234287776530788486528258894,
       -176.61502916214059906584551354,
        12.507343278686904814458936853,
       -0.13857109526572011689554707,
        9.984369578019570859563e-6,
        1.50563273514931155834e-7
    };

    // if(creal(z) < 0.5)
    //     return M_PI / (sin(M_PI*z)*gsl_sf_gamma(1. - z));

    z -= 1;
    // double complex x = p[0];
    double x = p[0];
    int n;
    for(n = 1; n < 9; n++)
        x += p[n] / (z + 1.*n);
    // double complex t = z + 7.5;
    double t = z + 7.5;
    return sqrt(2*_PI_) * pow(t, z+0.5) * exp(-t) * x;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x12d1a0(%rip), %xmm1   # 0x1d2248
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x19f2e6(%rip), %xmm0   # 0x2443a0
movsd %xmm0, 0x28(%rsp)
movl $0x1, 0x24(%rsp)
cmpl $0x9, 0x24(%rsp)
jge 0xa510d
movslq 0x24(%rsp), %rcx
leaq 0x19f2c5(%rip), %rax    # 0x2443a0
movsd (%rax,%rcx,8), %xmm0
movsd 0x30(%rsp), %xmm2
cvtsi2sdl 0x24(%rsp), %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xa50c8
movsd 0x14961b(%rip), %xmm0   # 0x1ee730
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x13035f(%rip), %xmm0   # 0x1d5488
callq 0x82e0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x12db46(%rip), %xmm1   # 0x1d2c88
addsd 0x30(%rsp), %xmm1
callq 0x8610
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x8670
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x28(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: background_free
int background_free(
                    struct background *pba
                    ) {


  class_call(background_free_noinput(pba),
             pba->error_message,
             pba->error_message);

  class_call(background_free_input(pba),
             pba->error_message,
             pba->error_message);

  pba->is_allocated = _FALSE_;

  return _SUCCESS_;
}

// Assembly:
subq $0x1018, %rsp           # imm = 0x1018
movq %rdi, 0x1008(%rsp)
movq 0x1008(%rsp), %rdi
callq 0xa8ff0
cmpl $0x1, %eax
jne 0xa8f4e
leaq 0x800(%rsp), %rdi
movq 0x1008(%rsp), %rcx
addq $0xd1c, %rcx            # imm = 0xD1C
leaq 0x1294d9(%rip), %rsi    # 0x1d23d8
leaq 0x13ec55(%rip), %rdx    # 0x1e7b5b
movb $0x0, %al
callq 0x5b9c0
movq 0x1008(%rsp), %rdi
addq $0xd1c, %rdi            # imm = 0xD1C
leaq 0x800(%rsp), %r8
leaq 0x129109(%rip), %rsi    # 0x1d2034
leaq 0x1463f3(%rip), %rdx    # 0x1ef325
movl $0x4bf, %ecx            # imm = 0x4BF
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x1014(%rsp)
jmp 0xa8fdc
movq 0x1008(%rsp), %rdi
callq 0xa9070
cmpl $0x1, %eax
jne 0xa8fc0
movq %rsp, %rdi
movq 0x1008(%rsp), %rcx
addq $0xd1c, %rcx            # imm = 0xD1C
leaq 0x12945f(%rip), %rsi    # 0x1d23d8
leaq 0x1463b5(%rip), %rdx    # 0x1ef335
movb $0x0, %al
callq 0x5b9c0
movq 0x1008(%rsp), %rdi
addq $0xd1c, %rdi            # imm = 0xD1C
movq %rsp, %r8
leaq 0x129094(%rip), %rsi    # 0x1d2034
leaq 0x14637e(%rip), %rdx    # 0x1ef325
movl $0x4c3, %ecx            # imm = 0x4C3
movb $0x0, %al
callq 0x5b9c0
movl $0x1, 0x1014(%rsp)
jmp 0xa8fdc
movq 0x1008(%rsp), %rax
movw $0x0, 0x151c(%rax)
movl $0x0, 0x1014(%rsp)
movl 0x1014(%rsp), %eax
addq $0x1018, %rsp           # imm = 0x1018
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: background_free_noinput
int background_free_noinput(
                            struct background *pba
                            ) {

  free(pba->tau_table);
  free(pba->z_table);
  free(pba->loga_table);
  free(pba->d2tau_dz2_table);
  free(pba->d2z_dtau2_table);
  free(pba->background_table);
  free(pba->d2background_dloga2_table);


  return _SUCCESS_;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x450(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x458(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x448(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x468(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x470(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x460(%rax), %rdi
callq 0x8420
movq (%rsp), %rax
movq 0x478(%rax), %rdi
callq 0x8420
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: background_ncdm_test_function
int background_ncdm_test_function(
                                  void * pbadist,
                                  double q,
                                  double * test
                                  ) {

  double c = 2.0/(3.0*_zeta3_);
  double d = 120.0/(7.0*pow(_PI_,4));
  double e = 2.0/(45.0*_zeta5_);

  /** Using a + bq creates problems for otherwise acceptable distributions
      which diverges as \f$ 1/r \f$ or \f$ 1/r^2 \f$ for \f$ r\to 0 \f$*/
  *test = pow(2.0*_PI_,3)/6.0*(c*q*q-d*q*q*q-e*q*q*q*q);

  return _SUCCESS_;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movsd 0x144fac(%rip), %xmm0   # 0x1ee758
movsd %xmm0, 0x18(%rsp)
movsd 0x12b826(%rip), %xmm0   # 0x1d4fe0
movsd 0x12bd06(%rip), %xmm1   # 0x1d54c8
callq 0x8610
movsd 0x129fb9(%rip), %xmm1   # 0x1d3788
mulsd %xmm0, %xmm1
movsd 0x12c165(%rip), %xmm0   # 0x1d5940
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x144f63(%rip), %xmm0   # 0x1ee750
movsd %xmm0, 0x8(%rsp)
movsd 0x12bc8d(%rip), %xmm0   # 0x1d5488
movsd 0x129e95(%rip), %xmm1   # 0x1d3698
callq 0x8610
movsd 0x129e78(%rip), %xmm1   # 0x1d3688
divsd %xmm1, %xmm0
movsd 0x18(%rsp), %xmm2
mulsd 0x28(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
movsd 0x10(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
movsd 0x28(%rsp), %xmm3
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: V_p_scf
double V_p_scf(
               struct background *pba,
               double phi) {
  //  double scf_lambda = pba->scf_parameters[0];
  double scf_alpha  = pba->scf_parameters[1];
  double scf_A      = pba->scf_parameters[2];
  double scf_B      = pba->scf_parameters[3];

  return  pow(phi - scf_B,  scf_alpha) +  scf_A;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x168(%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x168(%rax), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x168(%rax), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
subsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x8610
addsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: dV_p_scf
double dV_p_scf(
                struct background *pba,
                double phi) {

  //  double scf_lambda = pba->scf_parameters[0];
  double scf_alpha  = pba->scf_parameters[1];
  //  double scf_A      = pba->scf_parameters[2];
  double scf_B      = pba->scf_parameters[3];

  return   scf_alpha*pow(phi -  scf_B,  scf_alpha - 1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x168(%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x168(%rax), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x1229a6(%rip), %xmm2   # 0x1d2248
subsd %xmm2, %xmm1
callq 0x8610
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: ddV_p_scf
double ddV_p_scf(
                 struct background *pba,
                 double phi) {
  //  double scf_lambda = pba->scf_parameters[0];
  double scf_alpha  = pba->scf_parameters[1];
  //  double scf_A      = pba->scf_parameters[2];
  double scf_B      = pba->scf_parameters[3];

  return  scf_alpha*(scf_alpha - 1.)*pow(phi -  scf_B,  scf_alpha - 2);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x168(%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x168(%rax), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x122937(%rip), %xmm2   # 0x1d2248
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x123348(%rip), %xmm2   # 0x1d2c80
subsd %xmm2, %xmm1
callq 0x8610
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: V_axion_scf
double V_axion_scf(
                  struct background *pba,
                  double phi){
    // int n = pba->scf_parameters[0];
    double n = pba->n_axion;
    // double fa = pba->scf_parameters[2];
    double fa = pba->f_axion;
    double m = pba->m_scf*pba->H0;
    double result;
    // printf("n %d fa %e V %e phi/fa %e \n",n,fa,m*m/pow(2,n),phi/fa);
    if(n>1)result = pow(m,2)*pow(fa,2)*pow(1 - cos(phi/fa),n);
    else result = pow(m,2)*pow(fa,2)*(1 - cos(phi/fa));
    // printf("result %e phi %e m^2 %e\n",result,phi,m*m);
    return result;

}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rax
movsd 0x210(%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rax
movsd 0x190(%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x50(%rsp), %rax
movsd 0x188(%rax), %xmm0
movq 0x50(%rsp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x1224e9(%rip), %xmm1   # 0x1d2248
ucomisd %xmm1, %xmm0
jbe 0xafde4
movsd 0x30(%rsp), %xmm0
movsd 0x122f0d(%rip), %xmm1   # 0x1d2c80
callq 0x8610
movsd %xmm0, 0x18(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x122ef4(%rip), %xmm1   # 0x1d2c80
callq 0x8610
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x48(%rsp), %xmm0
divsd 0x38(%rsp), %xmm0
callq 0x86a0
movaps %xmm0, %xmm1
movsd 0x122488(%rip), %xmm0   # 0x1d2248
subsd %xmm1, %xmm0
movsd 0x40(%rsp), %xmm1
callq 0x8610
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0xafe53
movsd 0x30(%rsp), %xmm0
movsd 0x122e8e(%rip), %xmm1   # 0x1d2c80
callq 0x8610
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x122e75(%rip), %xmm1   # 0x1d2c80
callq 0x8610
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x48(%rsp), %xmm0
divsd 0x38(%rsp), %xmm0
callq 0x86a0
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x122403(%rip), %xmm1   # 0x1d2248
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: dV_axion_scf
double dV_axion_scf(
                  struct background *pba,
                  double phi){
    // int n = pba->scf_parameters[0];
    double n = pba->n_axion;
    // double fa = pba->scf_parameters[2];
    double fa = pba->f_axion;
    double m = pba->m_scf*pba->H0;
    double result;
    if(n>1)result = n*pow(m,2)*fa*pow(1-cos(phi/fa),n-1)*sin(phi/fa);
    else result = pow(m,2)*fa*sin(phi/fa);

    return result;

}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rax
movsd 0x210(%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rax
movsd 0x190(%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x50(%rsp), %rax
movsd 0x188(%rax), %xmm0
movq 0x50(%rsp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x122389(%rip), %xmm1   # 0x1d2248
ucomisd %xmm1, %xmm0
jbe 0xaff71
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x122d9d(%rip), %xmm1   # 0x1d2c80
callq 0x8610
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x48(%rsp), %xmm0
divsd 0x38(%rsp), %xmm0
callq 0x86a0
movaps %xmm0, %xmm1
movsd 0x12232b(%rip), %xmm0   # 0x1d2248
subsd %xmm1, %xmm0
movsd 0x40(%rsp), %xmm1
movsd 0x122319(%rip), %xmm2   # 0x1d2248
subsd %xmm2, %xmm1
callq 0x8610
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x48(%rsp), %xmm0
divsd 0x38(%rsp), %xmm0
callq 0x80a0
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0xaffb4
movsd 0x30(%rsp), %xmm0
movsd 0x122d01(%rip), %xmm1   # 0x1d2c80
callq 0x8610
mulsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x48(%rsp), %xmm0
divsd 0x38(%rsp), %xmm0
callq 0x80a0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: V_phi_2n_scf
double V_phi_2n_scf(
                  struct background *pba,
                  double phi){
    // int n = pba->scf_parameters[0];
    double n = pba->n_axion;
    double result;

    result = pba->V0_phi2n*pow((phi),2*n);

    return result;

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movsd 0x210(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movsd 0x1c0(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x12293e(%rip), %xmm1   # 0x1d2c80
mulsd 0x10(%rsp), %xmm1
callq 0x8610
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: dV_phi_2n_scf
double dV_phi_2n_scf(
                  struct background *pba,
                  double phi){
    // int n = pba->scf_parameters[0];
    double n = pba->n_axion;
    double result;

    result = pba->V0_phi2n*2*n*pow((phi),2*n-1);

    return result;

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movsd 0x210(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movsd 0x1228e1(%rip), %xmm0   # 0x1d2c80
mulsd 0x1c0(%rax), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm1
movsd 0x122406(%rip), %xmm2   # 0x1d27d0
addsd %xmm2, %xmm1
callq 0x8610
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/PoulinV[P]AxiCLASS/build/../source/background.c
// Function: ddV_phi_2n_scf
double ddV_phi_2n_scf(
                  struct background *pba,
                  double phi){

     // int n = pba->scf_parameters[0];
     double n = pba->n_axion;
     double result;
     if(n==1) result=pba->V0_phi2n*2;
     else result = pba->V0_phi2n*2*n*(2*n-1)*pow((phi),2*n-2);
     return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movsd 0x210(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x121e28(%rip), %xmm1   # 0x1d2248
ucomisd %xmm1, %xmm0
jne 0xb0445
jp 0xb0445
movq 0x20(%rsp), %rax
movsd 0x12284b(%rip), %xmm0   # 0x1d2c80
mulsd 0x1c0(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0xb04b2
movq 0x20(%rsp), %rax
movsd 0x12282e(%rip), %xmm0   # 0x1d2c80
mulsd 0x1c0(%rax), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm1
movsd 0x12235e(%rip), %xmm2   # 0x1d27d0
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm1
movsd 0x1232e9(%rip), %xmm2   # 0x1d3780
addsd %xmm2, %xmm1
callq 0x8610
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)