LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rotateVectorConform(int, int&)
double* Benchmarks::rotateVectorConform(int i, int &c)
{
  double* z = new double[s[i]];
  // printf("i=%d\tc=%d\tl=%d\tu=%d\n", i, c, c - (i)*overlap, c +s[i] - (i)*overlap);
  
  // copy values into the new vector
  for (int j = c - i*overlap; j < c +s[i] - i*overlap; ++j)
    {
      // cout<<"j-c "<<j-c<<" p "<<Pvector[j]<<endl;
      z[j-(c - i*overlap)] = anotherz[Pvector[j]];
    }
  // cout<<"copy done"<<endl;
  if (s[i]==25)
    {
      anotherz1 = multiply( z, r25, s[i]);
    }
  else if (s[i] == 50)
    {    
      anotherz1 = multiply( z, r50, s[i]);
    }
  else if (s[i] == 100) 
    {
      anotherz1 = multiply( z, r100, s[i]);
    }
  else
    {
      cout<< "size of rotation matrix out of range" <<endl;
    }
  delete []z;
  c = c + s[i];
  return anotherz1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0xf0(%rdi), %rax
movslq %esi, %r12
movslq (%rax,%r12,4), %r13
leaq (,%r13,8), %rax
testq %r13, %r13
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r15
movl (%rbx), %edx
movl 0x40(%r14), %eax
imull %r12d, %eax
subl %eax, %edx
movq 0x70(%r14), %rax
movslq %edx, %rcx
addl %r13d, %edx
movslq %edx, %rdx
leaq (,%rcx,4), %rsi
addq 0x58(%r14), %rsi
xorl %edi, %edi
leaq (%rcx,%rdi), %r8
cmpq %rdx, %r8
jge 0x4e6c
movslq (%rsi,%rdi,4), %r8
movsd (%rax,%r8,8), %xmm0
movslq %edi, %r8
movsd %xmm0, (%r15,%r8,8)
incq %rdi
jmp 0x4e4b
cmpl $0x19, %r13d
je 0x4e94
cmpl $0x32, %r13d
je 0x4e89
cmpl $0x64, %r13d
jne 0x4eac
movq 0xe8(%r14), %rdx
pushq $0x64
jmp 0x4e9d
movq 0xe0(%r14), %rdx
pushq $0x32
jmp 0x4e9d
movq 0xd8(%r14), %rdx
pushq $0x19
popq %rcx
movq %r15, %rsi
callq 0x4d7a
movq %rax, 0x78(%r14)
jmp 0x4ec7
movq 0xa11d(%rip), %rdi      # 0xefd0
leaq 0x525c(%rip), %rsi      # 0xa116
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
movq %r15, %rdi
callq 0x3210
movq 0xf0(%r14), %rax
movl (%rax,%r12,4), %eax
addl %eax, (%rbx)
movq 0x78(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rotateVectorConflict(int, int&, double*)
double* Benchmarks::rotateVectorConflict(int i, int &c, double* x)
{
  double* z = new double[s[i]];
  // printf("i=%d\tc=%d\tl=%d\tu=%d\n", i, c, c - (i)*overlap, c +s[i] - (i)*overlap);
  
  // copy values into the new vector
  for (int j = c - i*overlap; j < c +s[i] - i*overlap; ++j)
    {
      // cout<<"j-c "<<j-c<<" p "<<Pvector[j]<<endl;
      z[j-(c - i*overlap)] = x[Pvector[j]] - OvectorVec[i][j-(c - i*overlap)];  
    }

  // cout<<"copy done"<<endl;
  if (s[i]==25)
    {
      anotherz1 = multiply( z, r25, s[i]);
    }
  else if (s[i] == 50)
    {    
      anotherz1 = multiply( z, r50, s[i]);
    }
  else if (s[i] == 100) 
    {
      anotherz1 = multiply( z, r100, s[i]);
    }
  else
    {
      cout<< "size of rotation matrix out of range" <<endl;
    }
  delete []z;
  c = c + s[i];
  return anotherz1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, -0x30(%rbp)
movq %rdi, %r14
movq 0xf0(%rdi), %rax
movslq %esi, %r13
movslq (%rax,%r13,4), %rbx
leaq (,%rbx,8), %rax
testq %rbx, %rbx
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r15
movq -0x30(%rbp), %rax
movl (%rax), %edx
movl 0x40(%r14), %eax
imull %r13d, %eax
subl %eax, %edx
movq 0x50(%r14), %rax
movslq %edx, %rcx
addl %ebx, %edx
movslq %edx, %rdx
leaq (,%rcx,4), %rsi
addq 0x58(%r14), %rsi
xorl %edi, %edi
leaq (%rcx,%rdi), %r8
cmpq %rdx, %r8
jge 0x4f85
movslq (%rsi,%rdi,4), %r8
movsd (%r12,%r8,8), %xmm0
movq (%rax,%r13,8), %r8
movslq %edi, %r9
subsd (%r8,%r9,8), %xmm0
movsd %xmm0, (%r15,%r9,8)
incq %rdi
jmp 0x4f5a
cmpl $0x19, %ebx
je 0x4faa
cmpl $0x32, %ebx
je 0x4f9f
cmpl $0x64, %ebx
jne 0x4fc2
movq 0xe8(%r14), %rdx
pushq $0x64
jmp 0x4fb3
movq 0xe0(%r14), %rdx
pushq $0x32
jmp 0x4fb3
movq 0xd8(%r14), %rdx
pushq $0x19
popq %rcx
movq %r15, %rsi
callq 0x4d7a
movq %rax, 0x78(%r14)
jmp 0x4fdd
movq 0xa007(%rip), %rdi      # 0xefd0
leaq 0x5146(%rip), %rsi      # 0xa116
callq 0x31d0
movq %rax, %rdi
callq 0x30f0
movq %r15, %rdi
callq 0x3210
movq 0xf0(%r14), %rax
movl (%rax,%r13,4), %eax
movq -0x30(%rbp), %rcx
addl %eax, (%rcx)
movq 0x78(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::elliptic(double*, int)
double Benchmarks::elliptic(double*x,int dim) {
  double result = 0.0;
  int    i;
  
  transform_osz(x, dim);

  // for(i = dim - 1; i >= 0; i--) {
  for(i=0; i<dim; i++)
    {
      // printf("%f\n", pow(1.0e6,  i/((double)(dim - 1)) ));
      result += pow(1.0e6,  i/((double)(dim - 1)) ) * x[i] * x[i];
    }
  
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
callq 0x3f6c
leal -0x1(%rbx), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
xorl %r15d, %r15d
testl %ebx, %ebx
cmovlel %r15d, %ebx
xorpd %xmm0, %xmm0
cmpq %r15, %rbx
je 0x5081
cvtsi2sd %r15d, %xmm1
divsd -0x28(%rbp), %xmm1
movsd %xmm0, -0x20(%rbp)
movsd 0x4fea(%rip), %xmm0     # 0xa040
callq 0x32c0
movsd (%r14,%r15,8), %xmm1
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
incq %r15
jmp 0x503a
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rastrigin(double*, int)
double Benchmarks::rastrigin(double*x,int dim){
  double sum = 0;
  int    i;
  
  // T_{osz}
  transform_osz(x, dim);
  
  // T_{asy}^{0.2}
  transform_asy(x, 0.2, dim);

  // lambda
  Lambda(x, 10, dim);

  for(i = dim - 1; i >= 0; i--) {
    sum += x[i] * x[i] - 10.0 * cos(2 * PI * x[i]) + 10.0;
  }
  
  return(sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %rbx
callq 0x3f6c
movsd 0x4f94(%rip), %xmm0     # 0xa048
movq %rbx, %rsi
movl %r14d, %edx
callq 0x4100
movsd 0x4f89(%rip), %xmm0     # 0xa050
movq %rbx, %rsi
movl %r14d, %edx
callq 0x419e
movl %r14d, %r14d
xorpd %xmm0, %xmm0
testl %r14d, %r14d
jle 0x512b
movsd -0x8(%rbx,%r14,8), %xmm1
movsd %xmm1, -0x18(%rbp)
decq %r14
movsd %xmm0, -0x20(%rbp)
movapd %xmm1, %xmm0
mulsd 0x4f5a(%rip), %xmm0     # 0xa058
callq 0x3300
mulsd 0x4f55(%rip), %xmm0     # 0xa060
movsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
addsd 0x4f2b(%rip), %xmm1     # 0xa050
addsd %xmm1, %xmm0
jmp 0x50d9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rastrigin(double*, int, int)
double Benchmarks::rastrigin(double *x, int dim, int k)
{
  double result=0.0;
  int i;
  for(i=dim/k-1;i>=0;i--)
    {
      result+=x[Pvector[dim/k+i]]*x[Pvector[dim/k+i]]-10.0*cos(2*PI*x[Pvector[dim/k+i]])+10.0;
    }
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %eax
movq %rsi, %rbx
movq %rdi, %r14
cltd
idivl %ecx
movslq %eax, %r15
leaq (,%r15,8), %r12
xorpd %xmm0, %xmm0
testq %r15, %r15
jle 0x51ba
decq %r15
movq 0x58(%r14), %rax
movslq -0x4(%rax,%r12), %rax
movsd (%rbx,%rax,8), %xmm1
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movapd %xmm1, %xmm0
mulsd 0x4ecf(%rip), %xmm0     # 0xa058
callq 0x3300
mulsd 0x4eca(%rip), %xmm0     # 0xa060
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd 0x4ea0(%rip), %xmm1     # 0xa050
addsd %xmm1, %xmm0
addq $-0x4, %r12
jmp 0x515d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::ackley(double*, int)
double Benchmarks::ackley(double*x,int dim){
  double sum1 = 0.0;
  double sum2 = 0.0;
  double sum;
  int    i;

  // T_{osz}
  transform_osz(x,dim);
  
  // T_{asy}^{0.2}
  transform_asy(x, 0.2, dim);

  // lambda
  Lambda(x, 10, dim);

  for(i = dim - 1; i >= 0; i--) {
    sum1 += (x[i] * x[i]);
    sum2 += cos(2.0 * PI * x[i]);
  }

  sum = -20.0 * exp(-0.2 * sqrt(sum1 / dim)) - exp(sum2 / dim) + 20.0 + E;
  return(sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
callq 0x3f6c
movsd 0x4e61(%rip), %xmm0     # 0xa048
movq %r14, %rsi
movl %ebx, %edx
callq 0x4100
movsd 0x4e57(%rip), %xmm0     # 0xa050
movq %r14, %rsi
movl %ebx, %edx
callq 0x419e
movl %ebx, %r15d
xorpd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd %xmm0, -0x20(%rbp)
testl %r15d, %r15d
jle 0x5256
movsd -0x8(%r14,%r15,8), %xmm0
decq %r15
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, -0x20(%rbp)
mulsd 0x4e17(%rip), %xmm0     # 0xa058
callq 0x3300
movsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
jmp 0x5214
cvtsi2sd %ebx, %xmm1
movsd -0x20(%rbp), %xmm0
movsd %xmm1, -0x30(%rbp)
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x5278
sqrtsd %xmm0, %xmm0
jmp 0x527d
callq 0x3180
mulsd 0x4de3(%rip), %xmm0     # 0xa068
callq 0x32e0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
callq 0x32e0
movsd -0x20(%rbp), %xmm1
mulsd 0x4dc5(%rip), %xmm1     # 0xa070
subsd %xmm0, %xmm1
addsd 0x4dc1(%rip), %xmm1     # 0xa078
addsd 0x4dc1(%rip), %xmm1     # 0xa080
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::ackley(double*, int, int)
double Benchmarks::ackley(double *x, int dim, int k)
{
  double sum1=0.0;
  double sum2=0.0;
  double result=0.0;
  int i;

  for(i=dim/k-1;i>=0;i--)
    {
      sum1+=x[Pvector[dim/k+i]]*x[Pvector[dim/k+i]];
      sum2+=cos(2.0*PI*x[Pvector[dim/k+i]]);
    }

  result=-20.0*exp(-0.2*sqrt(sum1/(dim/k)))-exp(sum2/(dim/k))+20.0+E;

  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %eax
movq %rsi, %rbx
movq %rdi, %r14
cltd
idivl %ecx
movl %eax, %r15d
movslq %eax, %r12
leaq (,%r12,8), %r13
xorpd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
testq %r12, %r12
jle 0x5353
decq %r12
movq 0x58(%r14), %rax
movslq -0x4(%rax,%r13), %rax
movsd (%rbx,%rax,8), %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, -0x30(%rbp)
mulsd 0x4d1e(%rip), %xmm0     # 0xa058
callq 0x3300
movsd -0x38(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x38(%rbp)
addq $-0x4, %r13
jmp 0x5306
cvtsi2sd %r15d, %xmm1
movsd -0x30(%rbp), %xmm0
movsd %xmm1, -0x40(%rbp)
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x5376
sqrtsd %xmm0, %xmm0
jmp 0x537b
callq 0x3180
mulsd 0x4ce5(%rip), %xmm0     # 0xa068
callq 0x32e0
movsd %xmm0, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
divsd -0x40(%rbp), %xmm0
callq 0x32e0
movsd -0x30(%rbp), %xmm1
mulsd 0x4cc7(%rip), %xmm1     # 0xa070
subsd %xmm0, %xmm1
addsd 0x4cc3(%rip), %xmm1     # 0xa078
addsd 0x4cc3(%rip), %xmm1     # 0xa080
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::multiply(double*, double*, int)
double* Benchmarks::multiply(double*vector, double*matrix,int dim){
  int    i,j;
  //double*result = (double*)malloc(sizeof(double) * dim);
  double*result = new double[dim];

  for(i = dim - 1; i >= 0; i--) {
    result[i] = 0;

    for(j = dim - 1; j >= 0; j--) {
      result[i] += vector[j] * matrix[dim * j + i];
    }
  }

  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %rbx
movl %ecx, %eax
shlq $0x3, %rax
testl %ecx, %ecx
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x3030
leal -0x1(%r14), %ecx
movslq %ecx, %rcx
movslq %r14d, %rdx
leaq 0x8(,%rdx,8), %rsi
shlq $0x3, %rdx
imulq %rcx, %rsi
addq %r15, %rsi
negq %rdx
movq %rcx, %rdi
testq %rdi, %rdi
js 0x5458
andq $0x0, (%rax,%rdi,8)
xorpd %xmm0, %xmm0
movq %rsi, %r8
movq %rcx, %r9
testq %r9, %r9
js 0x544f
movsd (%rbx,%r9,8), %xmm1
mulsd (%r8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rdi,8)
decq %r9
addq %rdx, %r8
jmp 0x542e
decq %rdi
addq $-0x8, %rsi
jmp 0x541a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rot_rastrigin(double*, int)
double Benchmarks::rot_rastrigin(double*x,int dim){
  double result = 0.0;
  double*z      = multiply(x,RotMatrix,dim);
  result = rastrigin(z,dim);

  delete[] z;
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq 0x60(%rdi), %rdx
movl %ebx, %ecx
callq 0x53d0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x5096
movsd %xmm0, -0x20(%rbp)
movq %r15, %rdi
callq 0x3210
movsd -0x20(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rot_rastrigin(double*, int, int)
double Benchmarks::rot_rastrigin(double *x,int dim,int k)
{
  double result=0.0;

  int i,j;
  for(i=dim-1;i>=0;i--)
    {
      anotherz1[i]=0;
      for(j=dim-1;j>=0;j--)
        {
          anotherz1[i]+=x[Pvector[(k-1)*dim+j]]*RotMatrix[dim*j+i];
        }
    }

  for(i=dim-1;i>=0;i--)
    {
      result+=anotherz1[i]*anotherz1[i]-10.0*cos(2*PI*anotherz1[i])+10.0;
    }
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leal -0x1(%rdx), %r14d
movq 0x78(%rdi), %rax
decl %ecx
imull %edx, %ecx
movslq %r14d, %rdi
movslq %edx, %rdx
movslq %ecx, %rcx
leaq 0x8(,%rdx,8), %r8
shlq $0x3, %rdx
imulq %rdi, %r8
negq %rdx
shlq $0x2, %rcx
movq %rdi, %r9
testq %r9, %r9
js 0x553c
andq $0x0, (%rax,%r9,8)
movq 0x58(%rbx), %r10
addq %rcx, %r10
movq 0x60(%rbx), %r11
addq %r8, %r11
xorpd %xmm0, %xmm0
movq %rdi, %r15
testq %r15, %r15
js 0x5533
movslq (%r10,%r15,4), %r12
movsd (%rsi,%r12,8), %xmm1
mulsd (%r11), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r9,8)
decq %r15
addq %rdx, %r11
jmp 0x550d
decq %r9
addq $-0x8, %r8
jmp 0x54ee
xorps %xmm0, %xmm0
testl %r14d, %r14d
js 0x5596
movq 0x78(%rbx), %rax
movl %r14d, %ecx
movsd (%rax,%rcx,8), %xmm1
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movapd %xmm1, %xmm0
mulsd 0x4af2(%rip), %xmm0     # 0xa058
callq 0x3300
mulsd 0x4aed(%rip), %xmm0     # 0xa060
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd 0x4ac3(%rip), %xmm1     # 0xa050
addsd %xmm1, %xmm0
decl %r14d
jmp 0x553f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rot_ackley(double*, int)
double Benchmarks::rot_ackley(double*x,int dim){
  double result = 0.0;
  double*z      = multiply(x,RotMatrix,dim);
  result = ackley(z,dim);
  delete[] z;
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq 0x60(%rdi), %rdx
movl %ebx, %ecx
callq 0x53d0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x51c8
movsd %xmm0, -0x20(%rbp)
movq %r15, %rdi
callq 0x3210
movsd -0x20(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rot_ackley(double*, int, int)
double Benchmarks::rot_ackley(double *x,int dim,int k)
{
  double result=0.0;
  double sum1=0.0;
  double sum2=0.0;

  int i,j;
  for(i=dim-1;i>=0;i--)
    {
      anotherz1[i]=0;
      for(j=dim-1;j>=0;j--)
        {
          anotherz1[i]+=x[Pvector[(k-1)*dim+j]]*RotMatrix[dim*j+i];
        }
    }
  for(i=dim-1;i>=0;i--)
    {
      sum1+=anotherz1[i]*anotherz1[i];
      sum2+=cos(2.0*PI*anotherz1[i]);
    }
  result=-20.0*exp(-0.2*sqrt(sum1/dim))-exp(sum2/dim)+20.0+E;
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rdi, %r14
leal -0x1(%rbx), %r15d
movq 0x78(%rdi), %rax
decl %ecx
imull %edx, %ecx
movslq %r15d, %rdx
movslq %ebx, %rdi
movslq %ecx, %rcx
leaq 0x8(,%rdi,8), %r8
shlq $0x3, %rdi
imulq %rdx, %r8
negq %rdi
shlq $0x2, %rcx
movq %rdx, %r9
testq %r9, %r9
js 0x5680
andq $0x0, (%rax,%r9,8)
movq 0x58(%r14), %r10
addq %rcx, %r10
movq 0x60(%r14), %r11
addq %r8, %r11
xorpd %xmm0, %xmm0
movq %rdx, %r12
testq %r12, %r12
js 0x5677
movslq (%r10,%r12,4), %r13
movsd (%rsi,%r13,8), %xmm1
mulsd (%r11), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r9,8)
decq %r12
addq %rdi, %r11
jmp 0x5651
decq %r9
addq $-0x8, %r8
jmp 0x5632
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd %xmm0, -0x38(%rbp)
testl %r15d, %r15d
js 0x56d4
movq 0x78(%r14), %rax
movl %r15d, %ecx
movsd (%rax,%rcx,8), %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, -0x30(%rbp)
mulsd 0x499c(%rip), %xmm0     # 0xa058
callq 0x3300
movsd -0x38(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x38(%rbp)
decl %r15d
jmp 0x568d
cvtsi2sd %ebx, %xmm1
movsd -0x30(%rbp), %xmm0
movsd %xmm1, -0x40(%rbp)
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x56f6
sqrtsd %xmm0, %xmm0
jmp 0x56fb
callq 0x3180
mulsd 0x4965(%rip), %xmm0     # 0xa068
callq 0x32e0
movsd %xmm0, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
divsd -0x40(%rbp), %xmm0
callq 0x32e0
movsd -0x30(%rbp), %xmm1
mulsd 0x4947(%rip), %xmm1     # 0xa070
subsd %xmm0, %xmm1
addsd 0x4943(%rip), %xmm1     # 0xa078
addsd 0x4943(%rip), %xmm1     # 0xa080
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::sphere(double*, int)
double Benchmarks::sphere(double*x,int dim){
  double sum = 0;
  int    i;

  for(i = dim - 1; i >= 0; i--) {
    sum += pow(x[i],2);
  }

  return(sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
xorpd %xmm0, %xmm0
testl %eax, %eax
jle 0x5771
movsd -0x8(%rsi,%rax,8), %xmm1
decq %rax
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
jmp 0x575a
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::sphere(double*, int, int)
double Benchmarks::sphere(double*x,int dim, int k){
  double result=0.0;
  int i;

  //	cout<<"partial sum of sphere function ="<<endl;
  for(i=dim/k-1;i>=0;i--)
    {
      result+=x[Pvector[dim/k+i]]*x[Pvector[dim/k+i]];
      //		printf("x = %1.16E\t", x[Pvector[dim/k+i]]);
      //		printf("partial sum = %1.16E\t", result);
    }

  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
cltd
idivl %ecx
movq 0x58(%rdi), %rcx
cltq
leaq (%rcx,%rax,8), %rcx
addq $-0x4, %rcx
xorpd %xmm0, %xmm0
testq %rax, %rax
jle 0x57ad
decq %rax
movslq (%rcx), %rdx
movsd (%rsi,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
addq $-0x4, %rcx
jmp 0x578f
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::schwefel(double*, int)
double Benchmarks::schwefel(double*x,int dim){
  int    j;
  double s1 = 0;
  double s2 = 0;
  
  // T_{osz}
  transform_osz(x,dim);
  
  // T_{asy}^{0.2}
  transform_asy(x, 0.2, dim);

  for (j = 0; j < dim; j++) {
    s1 += x[j];
    s2 += (s1 * s1);
  }

  return(s2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
callq 0x3f6c
movsd 0x487f(%rip), %xmm0     # 0xa048
movq %r14, %rsi
movl %ebx, %edx
callq 0x4100
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rax, %rbx
je 0x57fe
addsd (%r14,%rax,8), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
incq %rax
jmp 0x57e2
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::schwefel(double*, int, int)
double Benchmarks::schwefel(double*x,int dim, int k){
  double sum1=0.0;
  double sum2=0.0;
  int i;
  for(i=0;i<dim;i++)
    {
      sum1+=x[Pvector[(k-1)*dim+i]];
      sum2+=sum1*sum1;
    }
  return(sum2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
decl %ecx
imull %edx, %ecx
movslq %ecx, %rax
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
shlq $0x2, %rax
addq 0x58(%rdi), %rax
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
je 0x5846
movslq (%rax,%rcx,4), %rdi
addsd (%rsi,%rdi,8), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
incq %rcx
jmp 0x5827
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rosenbrock(double*, int)
double Benchmarks::rosenbrock(double*x,int dim){
  int    j;
  double oz,t;
  double s = 0.0;
  j = dim - 1;

  for (--j; j >= 0; j--) {
    oz = x[j + 1];
    t  = ((x[j] * x[j]) - oz);
    s += (100.0 * t * t);
    t  = (x[j] - 1.0);
    s += (t * t);
  }
  return(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addl $-0x2, %edx
xorpd %xmm0, %xmm0
movsd 0x482d(%rip), %xmm1     # 0xa088
movsd 0x47ad(%rip), %xmm2     # 0xa010
testl %edx, %edx
js 0x58a0
movl %edx, %eax
movsd (%rsi,%rax,8), %xmm3
movapd %xmm3, %xmm4
mulsd %xmm3, %xmm4
subsd 0x8(%rsi,%rax,8), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm1, %xmm5
mulsd %xmm4, %xmm5
addsd %xmm0, %xmm5
addsd %xmm2, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm5, %xmm3
decl %edx
movapd %xmm3, %xmm0
jmp 0x5863
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rosenbrock(double*, int, int)
double Benchmarks::rosenbrock(double*x,int dim, int k){
  int j;
  double oz,t;
  double result=0.0;
  j=dim-1;
  for (--j; j >= 0; j--) {
    oz = x[Pvector[(k-1)*dim+j+1]];
    t = ((x[Pvector[(k-1)*dim+j]] * x[Pvector[(k-1)*dim+j]]) - oz);
    result += (100.0 * t * t);
    t = (x[Pvector[(k-1)*dim+j]] - 1.0);
    result += (t * t);
  }
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x58(%rdi), %rdi
decl %ecx
imull %edx, %ecx
addl $-0x2, %edx
movslq %edx, %rax
movslq %ecx, %rcx
leaq (%rdi,%rcx,4), %rcx
addq $0x4, %rcx
xorpd %xmm0, %xmm0
movsd 0x47bc(%rip), %xmm1     # 0xa088
movsd 0x473c(%rip), %xmm2     # 0xa010
testq %rax, %rax
js 0x5919
movslq (%rcx,%rax,4), %rdx
movslq -0x4(%rcx,%rax,4), %rdi
movsd (%rsi,%rdi,8), %xmm3
movapd %xmm3, %xmm4
mulsd %xmm3, %xmm4
subsd (%rsi,%rdx,8), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm1, %xmm5
mulsd %xmm4, %xmm5
addsd %xmm0, %xmm5
addsd %xmm2, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm5, %xmm3
decq %rax
movapd %xmm3, %xmm0
jmp 0x58d4
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::createIndexMapping()
void
Benchmarks::createIndexMapping (  )
{
  unsigned N = dimension, indexCounter = 0;

  indexMap = new struct IndexMap[arrSize];

  for (unsigned i=0; i<N; i++){
    for (unsigned j=i+1; j<N; j++){
      indexMap[indexCounter].arrIndex1 = i;
      indexMap[indexCounter].arrIndex2 = j;
      indexCounter++;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0xb8(%rdi), %r14d
movl 0xd0(%rdi), %edi
shlq $0x3, %rdi
callq 0x3030
movq %rax, 0xc8(%rbx)
xorl %ecx, %ecx
xorl %edx, %edx
cmpl %r14d, %edx
je 0x59c0
leal 0x1(%rdx), %esi
movl %esi, %edi
cmpl %r14d, %edi
jae 0x59bc
movl %ecx, %r8d
movl %edx, (%rax,%r8,8)
movl %edi, 0x4(%rax,%r8,8)
incl %ecx
incl %edi
jmp 0x59a5
movl %esi, %edx
jmp 0x599b
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::ArrToMat(unsigned int, unsigned int, unsigned int&)
void
Benchmarks::ArrToMat ( unsigned I1, unsigned I2, unsigned &matIndex )
{
  for (unsigned i=0; i<arrSize; i++){
    if (indexMap[i].arrIndex1 == I1 && indexMap[i].arrIndex2 == I2){
      matIndex = i;
      return ;
    }
  }
	
  printf ( "Cannot locate the matrix index from given array indices\n" );
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xd0(%rdi), %eax
movq 0xc8(%rdi), %r8
xorl %edi, %edi
cmpq %rdi, %rax
je 0x59f4
cmpl %esi, (%r8,%rdi,8)
jne 0x59eb
cmpl %edx, 0x4(%r8,%rdi,8)
je 0x59f0
incq %rdi
jmp 0x59d9
movl %edi, (%rcx)
popq %rbp
retq
leaq 0x4745(%rip), %rdi      # 0xa140
callq 0x3250
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F1.cpp
// Function: F1::F1()
F1::F1():Benchmarks(){
  Ovector = NULL;
  minX = -100;
  maxX = 100;
  ID = 1;
  anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x375c
leaq 0x8bfa(%rip), %rax      # 0xe980
movq %rax, (%rbx)
andq $0x0, 0x48(%rbx)
movabsq $0x64ffffff9c, %rax     # imm = 0x64FFFFFF9C
movq %rax, 0xb0(%rbx)
movl $0x1, 0x8(%rbx)
movslq 0xb8(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x37f4
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F1.cpp
// Function: F1::compute(double*)
double F1::compute(double* x) {
  double result;
  int    i;

  if(Ovector == NULL) {
    // Ovector = createShiftVector(dimension,minX,maxX);
    Ovector = readOvector();
  }

  for(i = dimension - 1; i >= 0; i--) {
    anotherz[i] = x[i] - Ovector[i];
  }

  // T_{OSZ}
  // transform_osz(anotherz,dimension);
  
  // result = elliptic(anotherz,dimension);
  result = elliptic(anotherz,dimension);
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
jne 0x5e5c
movq %rbx, %rdi
callq 0x3a5e
movq %rax, 0x48(%rbx)
movl 0xb8(%rbx), %edx
movq 0x70(%rbx), %rsi
movq %rdx, %rcx
testl %ecx, %ecx
jle 0x5e85
movsd -0x8(%r14,%rcx,8), %xmm0
subsd -0x8(%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rsi,%rcx,8)
decq %rcx
jmp 0x5e69
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x500a
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F10.cpp
// Function: F10::F10()
F10::F10():Benchmarks(){
  Ovector = NULL;
  minX = -5;
  maxX = 5;
  ID = 10;
  s_size = 20;
  anotherz = new double[dimension];  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x375c
leaq 0x8b1e(%rip), %rax      # 0xe9c8
movq %rax, (%rbx)
andq $0x0, 0x48(%rbx)
movabsq $0x5fffffffb, %rax      # imm = 0x5FFFFFFFB
movq %rax, 0xb0(%rbx)
movl $0xa, 0x8(%rbx)
movl $0x14, 0x3c(%rbx)
movslq 0xb8(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x37f4
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F10.cpp
// Function: F10::~F10()
F10::~F10(){
  delete[] Ovector;
  delete[] Pvector;

        delete[] anotherz;
        for (int i = 0; i < 25; ++i)
          {
            delete[] r25[i];
          }
        for (int i = 0; i < 50; ++i)
          {
            delete[] r50[i];
          }
        for (int i = 0; i < 100; ++i)
          {
            delete[] r100[i];
          }
        delete[] r25;
        delete[] r50;
        delete[] r100;
        delete[] s;
        delete[] w;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8aab(%rip), %rax      # 0xe9c8
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x5f2e
callq 0x3210
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x5f3c
callq 0x3210
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x5f4a
callq 0x3210
xorl %r14d, %r14d
cmpq $0x19, %r14
je 0x5f6d
movq 0xd8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5f68
callq 0x3210
incq %r14
jmp 0x5f4d
xorl %r14d, %r14d
cmpq $0x32, %r14
je 0x5f90
movq 0xe0(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5f8b
callq 0x3210
incq %r14
jmp 0x5f70
xorl %r14d, %r14d
cmpq $0x64, %r14
je 0x5fb3
movq 0xe8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5fae
callq 0x3210
incq %r14
jmp 0x5f93
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x5fc4
callq 0x3210
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0x5fd5
callq 0x3210
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x5fe6
callq 0x3210
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x5ff7
callq 0x3210
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x6008
callq 0x3210
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x37f4
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F10.cpp
// Function: F10::compute(double*)
double F10::compute(double*x){
  int i;
  double result=0.0;

  if(Ovector==NULL)
    {
      Ovector = readOvector();
      Pvector = readPermVector();
      r25 = readR(25);
      r50 = readR(50);
      r100 = readR(100);
      s = readS(s_size);
      w = readW(s_size);
    }
  for(i=0;i<dimension;i++)
    {
      anotherz[i]=x[i]-Ovector[i];
    }
  
  // s_size non-separable part with rotation
  int c = 0;
  for (i = 0; i < s_size; i++)
    {
      // cout<<"c="<<c<<", i="<<i<<endl;
      anotherz1 = rotateVector(i, c);
      // cout<<"done rot"<<endl;
      result += w[i] * ackley(anotherz1, s[i]);
      delete []anotherz1;
      // cout<<result<<endl;
    }
  
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
jne 0x60c2
movq %rbx, %rdi
callq 0x3a5e
movq %rax, 0x48(%rbx)
movq %rbx, %rdi
callq 0x42a8
movq %rax, 0x58(%rbx)
pushq $0x19
popq %rsi
movq %rbx, %rdi
callq 0x46d2
movq %rax, 0xd8(%rbx)
pushq $0x32
popq %rsi
movq %rbx, %rdi
callq 0x46d2
movq %rax, 0xe0(%rbx)
pushq $0x64
popq %rsi
movq %rbx, %rdi
callq 0x46d2
movq %rax, 0xe8(%rbx)
movl 0x3c(%rbx), %esi
movq %rbx, %rdi
callq 0x4978
movq %rax, 0xf0(%rbx)
movl 0x3c(%rbx), %esi
movq %rbx, %rdi
callq 0x4afe
movq %rax, 0xf8(%rbx)
movq 0x48(%rbx), %rax
movl 0xb8(%rbx), %ecx
movq 0x70(%rbx), %rdx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
cmpq %rsi, %rcx
je 0x60ed
movsd (%r14,%rsi,8), %xmm0
subsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x60d3
leaq -0x34(%rbp), %r14
andl $0x0, (%r14)
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movslq 0x3c(%rbx), %rax
cmpq %rax, %r15
jge 0x6173
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x4c82
movq %rax, 0x78(%rbx)
movq 0xf0(%rbx), %rcx
movq 0xf8(%rbx), %rdx
movsd (%rdx,%r15,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movl (%rcx,%r15,4), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x51c8
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x615c
movsd %xmm0, -0x20(%rbp)
callq 0x3210
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
incq %r15
jmp 0x60fc
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F11.cpp
// Function: F11::F11()
F11::F11():Benchmarks(){
  Ovector = NULL;
  minX = -32;
  maxX = 32;
  ID = 11;
  s_size=20;
  anotherz = new double[dimension];  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x375c
leaq 0x887a(%rip), %rax      # 0xea10
movq %rax, (%rbx)
andq $0x0, 0x48(%rbx)
movabsq $0x20ffffffe0, %rax     # imm = 0x20FFFFFFE0
movq %rax, 0xb0(%rbx)
movl $0xb, 0x8(%rbx)
movl $0x14, 0x3c(%rbx)
movslq 0xb8(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x37f4
movq %r14, %rdi
callq 0x32d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F11.cpp
// Function: F11::~F11()
F11::~F11(){
  delete[] Ovector;
  delete[] Pvector;

  delete[] anotherz;
  for (int i = 0; i < 25; ++i)
    {
      delete[] r25[i];
    }
  for (int i = 0; i < 50; ++i)
    {
      delete[] r50[i];
    }
  for (int i = 0; i < 100; ++i)
    {
      delete[] r100[i];
    }
  delete[] r25;
  delete[] r50;
  delete[] r100;
  delete[] s;
  delete[] w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8807(%rip), %rax      # 0xea10
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x621a
callq 0x3210
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x6228
callq 0x3210
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x6236
callq 0x3210
xorl %r14d, %r14d
cmpq $0x19, %r14
je 0x6259
movq 0xd8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6254
callq 0x3210
incq %r14
jmp 0x6239
xorl %r14d, %r14d
cmpq $0x32, %r14
je 0x627c
movq 0xe0(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6277
callq 0x3210
incq %r14
jmp 0x625c
xorl %r14d, %r14d
cmpq $0x64, %r14
je 0x629f
movq 0xe8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x629a
callq 0x3210
incq %r14
jmp 0x627f
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x62b0
callq 0x3210
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0x62c1
callq 0x3210
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x62d2
callq 0x3210
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x62e3
callq 0x3210
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x62f4
callq 0x3210
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x37f4
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F12.cpp
// Function: F12::F12()
F12::F12():Benchmarks(){
  Ovector = NULL;
  minX = -100;
  maxX = 100;
  ID = 12;
  anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x375c
leaq 0x85d6(%rip), %rax      # 0xea58
movq %rax, (%rbx)
andq $0x0, 0x48(%rbx)
movabsq $0x64ffffff9c, %rax     # imm = 0x64FFFFFF9C
movq %rax, 0xb0(%rbx)
movl $0xc, 0x8(%rbx)
movslq 0xb8(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x37f4
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F12.cpp
// Function: F12::compute(double*)
double F12::compute(double*x){
  int i;
  double result=0.0;

  if(Ovector==NULL)
    {
      Ovector = readOvector();
    }

  for(i=0;i<dimension;i++)
    {
      anotherz[i]=x[i]-Ovector[i];
    }

  result=rosenbrock(anotherz, dimension);
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
jne 0x6558
movq %rbx, %rdi
callq 0x3a5e
movq %rax, 0x48(%rbx)
movl 0xb8(%rbx), %edx
movq 0x70(%rbx), %rsi
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %edi
cmovgl %edx, %edi
cmpq %rcx, %rdi
je 0x6588
movsd (%r14,%rcx,8), %xmm0
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsi,%rcx,8)
incq %rcx
jmp 0x656e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5848
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F13.cpp
// Function: F13::F13()
F13::F13():Benchmarks(){
  m_havenextGaussian=0;
  Ovector = NULL;
  minX = -100;
  maxX = 100;
  ID = 13;
  s_size = 20;
  dimension = 905;        // because of overlapping
  overlap = 5;
  anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x375c
leaq 0x84f6(%rip), %rax      # 0xeaa0
movq %rax, (%rbx)
movb $0x0, 0x38(%rbx)
andq $0x0, 0x48(%rbx)
movabsq $0x64ffffff9c, %rax     # imm = 0x64FFFFFF9C
movq %rax, 0xb0(%rbx)
movl $0xd, 0x8(%rbx)
movabsq $0x500000014, %rax      # imm = 0x500000014
movq %rax, 0x3c(%rbx)
movl $0x389, 0xb8(%rbx)      # imm = 0x389
movl $0x1c48, %edi           # imm = 0x1C48
callq 0x3030
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x37f4
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F13.cpp
// Function: F13::compute(double*)
double F13::compute(double*x){
  int i;
  double result=0.0;
        
  if(Ovector==NULL)
    {
      Ovector = readOvector();
      Pvector = readPermVector();
      r25 = readR(25);
      r50 = readR(50);
      r100 = readR(100);
      s = readS(s_size);
      w = readW(s_size);
    }
  
  for(i=0;i<dimension;i++)
    {
      anotherz[i]=x[i]-Ovector[i];
    }
  // cout<<"o"<<endl;

  // s_size non-separable part with rotation
  int c = 0;
  for (i = 0; i < s_size; i++)
    {
      // cout<<"c="<<c<<", i="<<i<<endl;
      anotherz1 = rotateVectorConform(i, c);
      // cout<<"done rot"<<endl;
      result += w[i] * schwefel(anotherz1, s[i]);
      delete []anotherz1;
      // cout<<result<<endl;
    }
  
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
jne 0x67c2
movq %rbx, %rdi
callq 0x3a5e
movq %rax, 0x48(%rbx)
movq %rbx, %rdi
callq 0x42a8
movq %rax, 0x58(%rbx)
pushq $0x19
popq %rsi
movq %rbx, %rdi
callq 0x46d2
movq %rax, 0xd8(%rbx)
pushq $0x32
popq %rsi
movq %rbx, %rdi
callq 0x46d2
movq %rax, 0xe0(%rbx)
pushq $0x64
popq %rsi
movq %rbx, %rdi
callq 0x46d2
movq %rax, 0xe8(%rbx)
movl 0x3c(%rbx), %esi
movq %rbx, %rdi
callq 0x4978
movq %rax, 0xf0(%rbx)
movl 0x3c(%rbx), %esi
movq %rbx, %rdi
callq 0x4afe
movq %rax, 0xf8(%rbx)
movq 0x48(%rbx), %rax
movl 0xb8(%rbx), %ecx
movq 0x70(%rbx), %rdx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
cmpq %rsi, %rcx
je 0x67ed
movsd (%r14,%rsi,8), %xmm0
subsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x67d3
leaq -0x34(%rbp), %r14
andl $0x0, (%r14)
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movslq 0x3c(%rbx), %rax
cmpq %rax, %r15
jge 0x6873
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x4de8
movq %rax, 0x78(%rbx)
movq 0xf0(%rbx), %rcx
movq 0xf8(%rbx), %rdx
movsd (%rdx,%r15,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movl (%rcx,%r15,4), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x57b0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x685c
movsd %xmm0, -0x20(%rbp)
callq 0x3210
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
incq %r15
jmp 0x67fc
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F14.cpp
// Function: F14::F14()
F14::F14():Benchmarks(){
  OvectorVec = NULL;
  minX = -100;
  maxX = 100;
  ID = 14;
  s_size = 20;
  dimension = 905;        // because of overlapping
  overlap = 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x375c
leaq 0x8253(%rip), %rax      # 0xeae8
movq %rax, (%rbx)
andq $0x0, 0x50(%rbx)
movabsq $0x64ffffff9c, %rax     # imm = 0x64FFFFFF9C
movq %rax, 0xb0(%rbx)
movl $0xe, 0x8(%rbx)
movabsq $0x500000014, %rax      # imm = 0x500000014
movq %rax, 0x3c(%rbx)
movl $0x389, 0xb8(%rbx)      # imm = 0x389
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F14.cpp
// Function: F14::~F14()
F14::~F14(){
  for (int i = 0; i < s_size; i++)
    {
      free(OvectorVec[i]);
    }
  free(OvectorVec);
  
  delete[] Pvector;
    for (int i = 0; i < 25; ++i)
    {
      delete[] r25[i];
    }
  for (int i = 0; i < 50; ++i)
    {
      delete[] r50[i];
    }
  for (int i = 0; i < 100; ++i)
    {
      delete[] r100[i];
    }
  delete[] r25;
  delete[] r50;
  delete[] r100;
  delete[] s;
  delete[] w;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8203(%rip), %rax      # 0xeae8
movq %rax, (%rdi)
xorl %r14d, %r14d
movslq 0x3c(%rbx), %rax
movq 0x50(%rbx), %rdi
cmpq %rax, %r14
jge 0x6906
movq (%rdi,%r14,8), %rdi
callq 0x31f0
incq %r14
jmp 0x68eb
callq 0x31f0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x6919
callq 0x3210
xorl %r14d, %r14d
cmpq $0x19, %r14
je 0x693c
movq 0xd8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6937
callq 0x3210
incq %r14
jmp 0x691c
xorl %r14d, %r14d
cmpq $0x32, %r14
je 0x695f
movq 0xe0(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x695a
callq 0x3210
incq %r14
jmp 0x693f
xorl %r14d, %r14d
cmpq $0x64, %r14
je 0x6982
movq 0xe8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x697d
callq 0x3210
incq %r14
jmp 0x6962
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x6993
callq 0x3210
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0x69a4
callq 0x3210
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x69b5
callq 0x3210
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x69c6
callq 0x3210
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x69d7
callq 0x3210
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x37f4
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F14.cpp
// Function: F14::compute(double*)
double F14::compute(double*x){
  int i;
  double result=0.0;
  
  if(OvectorVec == NULL)
    {
      s = readS(s_size);
      OvectorVec = readOvectorVec();
      // // inspect OvectorVec
      // for (int i = 0; i < s_size; ++i)
      //   {
      //     for (int j=0; j< s[i]; j++)
      //       {
      //         printf("%.1f\t",OvectorVec[i][j]);
      //       }
      //     printf("\n");
      //   }
      Pvector = readPermVector();
      r25 = readR(25);
      r50 = readR(50);
      r100 = readR(100);
      w = readW(s_size);
    }

  // s_size non-separable part with rotation
  int c = 0;
  for (i = 0; i < s_size; i++)
    {
      // cout<<"c="<<c<<", i="<<i<<endl;
      anotherz1 = rotateVectorConflict(i, c, x);
      // cout<<"done rot"<<endl;
      result += w[i] * schwefel(anotherz1, s[i]);
      delete []anotherz1;
      // cout<<result<<endl;
    }
  
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x50(%rdi)
jne 0x6a90
movl 0x3c(%r14), %esi
movq %r14, %rdi
callq 0x4978
movq %rax, 0xf0(%r14)
movq %r14, %rdi
callq 0x3cb4
movq %rax, 0x50(%r14)
movq %r14, %rdi
callq 0x42a8
movq %rax, 0x58(%r14)
pushq $0x19
popq %rsi
movq %r14, %rdi
callq 0x46d2
movq %rax, 0xd8(%r14)
pushq $0x32
popq %rsi
movq %r14, %rdi
callq 0x46d2
movq %rax, 0xe0(%r14)
pushq $0x64
popq %rsi
movq %r14, %rdi
callq 0x46d2
movq %rax, 0xe8(%r14)
movl 0x3c(%r14), %esi
movq %r14, %rdi
callq 0x4afe
movq %rax, 0xf8(%r14)
leaq -0x3c(%rbp), %r15
andl $0x0, (%r15)
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
movslq 0x3c(%r14), %rax
cmpq %rax, %r12
jge 0x6b19
movsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
movl %r12d, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x4ef0
movq %rax, 0x78(%r14)
movq 0xf0(%r14), %rcx
movq 0xf8(%r14), %rdx
movsd (%rdx,%r12,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movl (%rcx,%r12,4), %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x57b0
movq 0x78(%r14), %rdi
testq %rdi, %rdi
je 0x6b02
movsd %xmm0, -0x28(%rbp)
callq 0x3210
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
addsd %xmm1, %xmm0
incq %r12
jmp 0x6a9f
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F15.cpp
// Function: F15::F15()
F15::F15():Benchmarks(){
  Ovector = NULL;
  minX = -100;
  maxX = 100;
  ID = 15;
  anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x375c
leaq 0x7ff2(%rip), %rax      # 0xeb30
movq %rax, (%rbx)
andq $0x0, 0x48(%rbx)
movabsq $0x64ffffff9c, %rax     # imm = 0x64FFFFFF9C
movq %rax, 0xb0(%rbx)
movl $0xf, 0x8(%rbx)
movslq 0xb8(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x37f4
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F2.cpp
// Function: F2::F2()
F2::F2():Benchmarks(){
  Ovector = NULL;
  minX = -5;
  maxX = 5;
  ID = 2;
  anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x375c
leaq 0x7f12(%rip), %rax      # 0xeb78
movq %rax, (%rbx)
andq $0x0, 0x48(%rbx)
movabsq $0x5fffffffb, %rax      # imm = 0x5FFFFFFFB
movq %rax, 0xb0(%rbx)
movl $0x2, 0x8(%rbx)
movslq 0xb8(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x37f4
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F2.cpp
// Function: F2::compute(double*)
double F2::compute(double* x){
  int    i;
  double result;

  if(Ovector == NULL) {
    // Ovector = createShiftVector(dimension,minX,maxX);
    Ovector = readOvector();
  }

  for(i = 0; i < dimension; i++) {
    anotherz[i] = x[i] - Ovector[i];
  }
  
  // // T_{osz}
  // transform_osz(anotherz, dimension);
  
  // // T_{asy}^{0.2}
  // transform_asy(anotherz, 0.2);

  // // lambda
  // Lambda(anotherz, 10);

  result = rastrigin(anotherz,dimension);
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
jne 0x6d3c
movq %rbx, %rdi
callq 0x3a5e
movq %rax, 0x48(%rbx)
movl 0xb8(%rbx), %edx
movq 0x70(%rbx), %rsi
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %edi
cmovgl %edx, %edi
cmpq %rcx, %rdi
je 0x6d6c
movsd (%r14,%rcx,8), %xmm0
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsi,%rcx,8)
incq %rcx
jmp 0x6d52
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5096
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F3.cpp
// Function: F3::F3()
F3::F3():Benchmarks(){
  Ovector = NULL;
  minX = -32;
  maxX = 32;
  ID = 3;
  anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x375c
leaq 0x7e32(%rip), %rax      # 0xebc0
movq %rax, (%rbx)
andq $0x0, 0x48(%rbx)
movabsq $0x20ffffffe0, %rax     # imm = 0x20FFFFFFE0
movq %rax, 0xb0(%rbx)
movl $0x3, 0x8(%rbx)
movslq 0xb8(%rbx), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x37f4
movq %r14, %rdi
callq 0x32d0
// File: /workspace/github_cpp_makefile_star2_O2/mateuz[P]MTS-LS1/source/F3.cpp
// Function: F3::compute(double*)
double F3::compute(double*x){
  int    i;
  double result;

  if(Ovector == NULL) {
    // Ovector = createShiftVector(dimension,minX,maxX);
    Ovector = readOvector();
  }

  for(i = dimension - 1; i >= 0; i--) {
    anotherz[i] = x[i] - Ovector[i];
  }
  
  result = ackley(anotherz,dimension);

  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
jne 0x6e64
movq %rbx, %rdi
callq 0x3a5e
movq %rax, 0x48(%rbx)
movl 0xb8(%rbx), %edx
movq 0x70(%rbx), %rsi
movq %rdx, %rcx
testl %ecx, %ecx
jle 0x6e8d
movsd -0x8(%r14,%rcx,8), %xmm0
subsd -0x8(%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rsi,%rcx,8)
decq %rcx
jmp 0x6e71
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x51c8
nopl (%rax)