LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x14(%rbp), %eax
cltd
idivl -0x18(%rbp)
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x6828
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x58(%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x14(%rbp), %eax
cltd
idivl -0x18(%rbp)
movq -0x58(%rbp), %rdx
movl %eax, %esi
movq -0x40(%rbp), %rax
addl -0x34(%rbp), %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x10(%rbp), %rcx
movq 0x58(%rax), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
cltd
idivl -0x18(%rbp)
movq -0x50(%rbp), %rdx
movl %eax, %esi
movq -0x40(%rbp), %rax
addl -0x34(%rbp), %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movsd (%rcx,%rdx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq 0x58(%rax), %rcx
movl -0x14(%rbp), %eax
cltd
idivl -0x18(%rbp)
movl %eax, %edx
movq -0x48(%rbp), %rax
addl -0x34(%rbp), %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
movsd 0xc862(%rip), %xmm0     # 0x13068
mulsd (%rax,%rcx,8), %xmm0
callq 0x3350
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6763
movsd -0x20(%rbp), %xmm0
movl -0x14(%rbp), %eax
cltd
idivl -0x18(%rbp)
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
callq 0x3160
movaps %xmm0, %xmm1
movsd 0xc83c(%rip), %xmm0     # 0x13088
mulsd %xmm1, %xmm0
callq 0x3330
movsd %xmm0, -0x60(%rbp)
movsd -0x28(%rbp), %xmm0
movl -0x14(%rbp), %eax
cltd
idivl -0x18(%rbp)
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
callq 0x3330
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0xc7e6(%rip), %xmm2     # 0x13080
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xc7ce(%rip), %xmm1     # 0x13078
addsd %xmm1, %xmm0
movsd 0xc7ba(%rip), %xmm1     # 0x13070
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x6993
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x6986
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
imull -0x24(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6938
jmp 0x6988
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6919
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq 0x60(%rdi), %rdx
movl -0x14(%rbp), %ecx
callq 0x68d0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x6350
movsd %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x6a03
movq -0x30(%rbp), %rdi
callq 0x3230
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x6adc
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rax
movslq -0x24(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x6acc
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x58(%rax), %rdx
movl -0x18(%rbp), %esi
subl $0x1, %esi
imull -0x14(%rbp), %esi
addl -0x28(%rbp), %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x60(%rax), %rcx
movl -0x14(%rbp), %edx
imull -0x28(%rbp), %edx
addl -0x24(%rbp), %edx
movslq %edx, %rdx
movsd (%rcx,%rdx,8), %xmm2
movq 0x78(%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6a66
jmp 0x6ace
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6a3f
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x6b8d
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rcx
movslq -0x24(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movq 0x78(%rax), %rcx
movslq -0x24(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq 0x78(%rax), %rax
movslq -0x24(%rbp), %rcx
movsd 0xc541(%rip), %xmm0     # 0x13068
mulsd (%rax,%rcx,8), %xmm0
callq 0x3350
movsd -0x40(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x38(%rbp), %xmm0
movsd 0xc4fa(%rip), %xmm1     # 0x13040
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0xc4cf(%rip), %xmm1     # 0x13040
addsd %xmm1, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6ae5
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq 0x60(%rdi), %rdx
movl -0x14(%rbp), %ecx
callq 0x68d0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x65b0
movsd %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x6c03
movq -0x30(%rbp), %rdi
callq 0x3230
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x6e46
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movl $0x2, %edi
callq 0x75b0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6e14
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x14(%rbp), %eax
cltd
idivl -0x18(%rbp)
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x6f0a
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x58(%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
cltd
idivl -0x18(%rbp)
movq -0x40(%rbp), %rdx
movl %eax, %esi
movq -0x30(%rbp), %rax
addl -0x24(%rbp), %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x10(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq 0x58(%rax), %rcx
movl -0x14(%rbp), %eax
cltd
idivl -0x18(%rbp)
movl %eax, %edx
movq -0x38(%rbp), %rax
addl -0x24(%rbp), %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6e8f
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x4610
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movsd 0xc0f6(%rip), %xmm0     # 0x13060
callq 0x4880
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6fbc
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6f76
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x705f
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x58(%rcx), %rcx
movl -0x18(%rbp), %edx
subl $0x1, %edx
imull -0x14(%rbp), %edx
addl -0x2c(%rbp), %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7001
movsd -0x28(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x7169
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0xbf8b(%rip), %xmm0     # 0x13090
mulsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0xbee2(%rip), %xmm1     # 0x13018
subsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7099
movsd -0x30(%rbp), %xmm0
popq %rbp
retq
// File: 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 %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x72c6
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x58(%rcx), %rdx
movl -0x18(%rbp), %esi
subl $0x1, %esi
imull -0x14(%rbp), %esi
addl -0x1c(%rbp), %esi
addl $0x1, %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rcx), %rdx
movl -0x18(%rbp), %esi
subl $0x1, %esi
imull -0x14(%rbp), %esi
addl -0x1c(%rbp), %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movsd (%rax,%rdx,8), %xmm0
movq -0x10(%rbp), %rax
movq 0x58(%rcx), %rdx
movl -0x18(%rbp), %esi
subl $0x1, %esi
imull -0x14(%rbp), %esi
addl -0x1c(%rbp), %esi
movslq %esi, %rsi
movslq (%rdx,%rsi,4), %rdx
movsd (%rax,%rdx,8), %xmm2
movsd -0x28(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0xbe42(%rip), %xmm0     # 0x13090
mulsd -0x30(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rcx), %rcx
movl -0x18(%rbp), %edx
subl $0x1, %edx
imull -0x14(%rbp), %edx
addl -0x1c(%rbp), %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0xbd85(%rip), %xmm1     # 0x13018
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x71a4
movsd -0x38(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0xb8(%rax), %ecx
movl %ecx, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl 0xd0(%rax), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xc8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x743f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x7432
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %esi
movq 0xc8(%rax), %rcx
movl -0x10(%rbp), %edx
movl %esi, (%rcx,%rdx,8)
movl -0x18(%rbp), %edx
movq 0xc8(%rax), %rax
movl -0x10(%rbp), %ecx
movl %edx, 0x4(%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x73f1
jmp 0x7434
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x73e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0xd0(%rcx), %eax
jae 0x74cd
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,8), %eax
cmpl -0xc(%rbp), %eax
jne 0x74c0
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rax
movl -0x1c(%rbp), %ecx
movl 0x4(%rax,%rcx,8), %eax
cmpl -0x10(%rbp), %eax
jne 0x74c0
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
jmp 0x74c2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7475
leaq 0xbc96(%rip), %rdi      # 0x1316a
movb $0x0, %al
callq 0x3050
movl $0x1, %edi
callq 0x3210
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0x10dc4(%rip), %rcx     # 0x19978
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xffffff9c, 0xb0(%rax) # imm = 0xFFFFFF9C
movl $0x64, 0xb4(%rax)
movl $0x1, 0x8(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0x8c02
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x8d13
movq -0x28(%rbp), %rdi
callq 0x3e10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
movl 0xb8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x8d5f
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x48(%rax), %rcx
movslq -0x1c(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movq 0x70(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8d23
movq -0x28(%rbp), %rdi
movq 0x70(%rdi), %rsi
movl 0xb8(%rdi), %edx
callq 0x6290
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0x10c0c(%rip), %rcx     # 0x199c0
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xfffffffb, 0xb0(%rax) # imm = 0xFFFFFFFB
movl $0x5, 0xb4(%rax)
movl $0xa, 0x8(%rax)
movl $0x14, 0x3c(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0x8e09
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x10b52(%rip), %rcx     # 0x199b0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8e7c
movq -0x20(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8e97
movq -0x30(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x8eb2
movq -0x38(%rbp), %rdi
callq 0x3230
movl $0x0, -0xc(%rbp)
cmpl $0x19, -0xc(%rbp)
jge 0x8ef2
movq -0x28(%rbp), %rax
movq 0xd8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x8ee5
movq -0x40(%rbp), %rdi
callq 0x3230
jmp 0x8ee7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8eb9
movl $0x0, -0x10(%rbp)
cmpl $0x32, -0x10(%rbp)
jge 0x8f32
movq -0x28(%rbp), %rax
movq 0xe0(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x8f25
movq -0x48(%rbp), %rdi
callq 0x3230
jmp 0x8f27
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8ef9
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0x8f72
movq -0x28(%rbp), %rax
movq 0xe8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x8f65
movq -0x50(%rbp), %rdi
callq 0x3230
jmp 0x8f67
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8f39
movq -0x28(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x8f90
movq -0x58(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x8fae
movq -0x60(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x8fcc
movq -0x68(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x8fea
movq -0x70(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x9008
movq -0x78(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rdi
callq 0x3a10
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x9101
movq -0x30(%rbp), %rdi
callq 0x3e10
movq -0x30(%rbp), %rdi
movq %rax, 0x48(%rdi)
callq 0x4ad0
movq -0x30(%rbp), %rdi
movq %rax, 0x58(%rdi)
movl $0x19, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xd8(%rdi)
movl $0x32, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xe0(%rdi)
movl $0x64, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xe8(%rdi)
movl 0x3c(%rdi), %esi
callq 0x5640
movq -0x30(%rbp), %rdi
movq %rax, 0xf0(%rdi)
movl 0x3c(%rdi), %esi
callq 0x58e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0xf8(%rax)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xb8(%rcx), %eax
jge 0x914d
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x48(%rax), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movq 0x70(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9108
movl $0x0, -0x24(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x3c(%rcx), %eax
jge 0x91f4
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x24(%rbp), %rdx
callq 0x5b80
movq -0x30(%rbp), %rdi
movq %rax, 0x78(%rdi)
movq 0xf8(%rdi), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq 0x78(%rdi), %rsi
movq 0xf0(%rdi), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x65b0
movq -0x30(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x78(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x91e4
movq -0x38(%rbp), %rdi
callq 0x3230
jmp 0x91e6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x915b
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0x107e4(%rip), %rcx     # 0x19a08
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xffffffe0, 0xb0(%rax) # imm = 0xFFFFFFE0
movl $0x20, 0xb4(%rax)
movl $0xb, 0x8(%rax)
movl $0x14, 0x3c(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0x9279
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1072a(%rip), %rcx     # 0x199f8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x92ec
movq -0x20(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x9307
movq -0x30(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x9322
movq -0x38(%rbp), %rdi
callq 0x3230
movl $0x0, -0xc(%rbp)
cmpl $0x19, -0xc(%rbp)
jge 0x9362
movq -0x28(%rbp), %rax
movq 0xd8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x9355
movq -0x40(%rbp), %rdi
callq 0x3230
jmp 0x9357
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9329
movl $0x0, -0x10(%rbp)
cmpl $0x32, -0x10(%rbp)
jge 0x93a2
movq -0x28(%rbp), %rax
movq 0xe0(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x9395
movq -0x48(%rbp), %rdi
callq 0x3230
jmp 0x9397
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9369
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0x93e2
movq -0x28(%rbp), %rax
movq 0xe8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x93d5
movq -0x50(%rbp), %rdi
callq 0x3230
jmp 0x93d7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x93a9
movq -0x28(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x9400
movq -0x58(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x941e
movq -0x60(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x943c
movq -0x68(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x945a
movq -0x70(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x9478
movq -0x78(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rdi
callq 0x3a10
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0x103bc(%rip), %rcx     # 0x19a50
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xffffff9c, 0xb0(%rax) # imm = 0xFFFFFF9C
movl $0x64, 0xb4(%rax)
movl $0xc, 0x8(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0x96e2
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x97fb
movq -0x28(%rbp), %rdi
callq 0x3e10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xb8(%rcx), %eax
jge 0x9847
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x48(%rax), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movq 0x70(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9802
movq -0x28(%rbp), %rdi
movq 0x70(%rdi), %rsi
movl 0xb8(%rdi), %edx
callq 0x7070
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0x10204(%rip), %rcx     # 0x19a98
movq %rcx, (%rax)
movb $0x0, 0x38(%rax)
movq $0x0, 0x48(%rax)
movl $0xffffff9c, 0xb0(%rax) # imm = 0xFFFFFF9C
movl $0x64, 0xb4(%rax)
movl $0xd, 0x8(%rax)
movl $0x14, 0x3c(%rax)
movl $0x389, 0xb8(%rax)      # imm = 0x389
movl $0x5, 0x40(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0x98fe
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0x9bf1
movq -0x30(%rbp), %rdi
callq 0x3e10
movq -0x30(%rbp), %rdi
movq %rax, 0x48(%rdi)
callq 0x4ad0
movq -0x30(%rbp), %rdi
movq %rax, 0x58(%rdi)
movl $0x19, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xd8(%rdi)
movl $0x32, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xe0(%rdi)
movl $0x64, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xe8(%rdi)
movl 0x3c(%rdi), %esi
callq 0x5640
movq -0x30(%rbp), %rdi
movq %rax, 0xf0(%rdi)
movl 0x3c(%rdi), %esi
callq 0x58e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0xf8(%rax)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xb8(%rcx), %eax
jge 0x9c3d
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x48(%rax), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movq 0x70(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9bf8
movl $0x0, -0x24(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x3c(%rcx), %eax
jge 0x9ce4
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x24(%rbp), %rdx
callq 0x5e40
movq -0x30(%rbp), %rdi
movq %rax, 0x78(%rdi)
movq 0xf8(%rdi), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq 0x78(%rdi), %rsi
movq 0xf0(%rdi), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x6f20
movq -0x30(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x78(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x9cd4
movq -0x38(%rbp), %rdi
callq 0x3230
jmp 0x9cd6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9c4b
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x38a0
movq -0x10(%rbp), %rax
leaq 0xfdbc(%rip), %rcx      # 0x19ad0
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x50(%rax)
movl $0xffffff9c, 0xb0(%rax) # imm = 0xFFFFFF9C
movl $0x64, 0xb4(%rax)
movl $0xe, 0x8(%rax)
movl $0x14, 0x3c(%rax)
movl $0x389, 0xb8(%rax)      # imm = 0x389
movl $0x5, 0x40(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xfd55(%rip), %rcx      # 0x19ad0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x3c(%rcx), %eax
jge 0x9db5
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3200
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9d89
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3200
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x9ddd
movq -0x28(%rbp), %rdi
callq 0x3230
movl $0x0, -0x10(%rbp)
cmpl $0x19, -0x10(%rbp)
jge 0x9e1d
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x9e10
movq -0x30(%rbp), %rdi
callq 0x3230
jmp 0x9e12
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9de4
movl $0x0, -0x14(%rbp)
cmpl $0x32, -0x14(%rbp)
jge 0x9e5d
movq -0x20(%rbp), %rax
movq 0xe0(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x9e50
movq -0x38(%rbp), %rdi
callq 0x3230
jmp 0x9e52
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9e24
movl $0x0, -0x18(%rbp)
cmpl $0x64, -0x18(%rbp)
jge 0x9e9d
movq -0x20(%rbp), %rax
movq 0xe8(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x9e90
movq -0x40(%rbp), %rdi
callq 0x3230
jmp 0x9e92
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9e64
movq -0x20(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x9ebb
movq -0x48(%rbp), %rdi
callq 0x3230
movq -0x20(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x9ed9
movq -0x50(%rbp), %rdi
callq 0x3230
movq -0x20(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x9ef7
movq -0x58(%rbp), %rdi
callq 0x3230
movq -0x20(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x9f15
movq -0x60(%rbp), %rdi
callq 0x3230
movq -0x20(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x9f33
movq -0x68(%rbp), %rdi
callq 0x3230
movq -0x20(%rbp), %rdi
callq 0x3a10
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, 0x50(%rax)
jne 0xa031
movq -0x30(%rbp), %rdi
movl 0x3c(%rdi), %esi
callq 0x5640
movq -0x30(%rbp), %rdi
movq %rax, 0xf0(%rdi)
callq 0x41c0
movq -0x30(%rbp), %rdi
movq %rax, 0x50(%rdi)
callq 0x4ad0
movq -0x30(%rbp), %rdi
movq %rax, 0x58(%rdi)
movl $0x19, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xd8(%rdi)
movl $0x32, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xe0(%rdi)
movl $0x64, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xe8(%rdi)
movl 0x3c(%rdi), %esi
callq 0x58e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0xf8(%rax)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x3c(%rcx), %eax
jge 0xa0dc
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rcx
leaq -0x24(%rbp), %rdx
callq 0x6050
movq -0x30(%rbp), %rdi
movq %rax, 0x78(%rdi)
movq 0xf8(%rdi), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq 0x78(%rdi), %rsi
movq 0xf0(%rdi), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x6f20
movq -0x30(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x78(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xa0cc
movq -0x38(%rbp), %rdi
callq 0x3230
jmp 0xa0ce
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa03f
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0xfa14(%rip), %rcx      # 0x19b28
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xffffff9c, 0xb0(%rax) # imm = 0xFFFFFF9C
movl $0x64, 0xb4(%rax)
movl $0xf, 0x8(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0xa162
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: mateuz[P]MTS-LS1/source/F15.cpp
// Function: F15::compute(double*)
double F15::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=schwefel(anotherz, dimension);

  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0xa27b
movq -0x28(%rbp), %rdi
callq 0x3e10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xb8(%rcx), %eax
jge 0xa2c7
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x48(%rax), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movq 0x70(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa282
movq -0x28(%rbp), %rdi
movq 0x70(%rdi), %rsi
movl 0xb8(%rdi), %edx
callq 0x6f20
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0xf85c(%rip), %rcx      # 0x19b70
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xfffffffb, 0xb0(%rax) # imm = 0xFFFFFFFB
movl $0x5, 0xb4(%rax)
movl $0x2, 0x8(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0xa362
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)