LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::nextInt(int)
int Benchmarks::nextInt(int n) {
  int bits, val;

  if ((n & (-n)) == n) {
    return((int) ((n * L(next(31))) >> L(31)));
  }

  do {
    bits = next(31);
    val  = bits % n;
  } while (bits - val + (n - 1) < 0);

  return(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x1(%rsi), %eax
testl %eax, %esi
jne 0x3914
movq 0x10(%rdi), %rax
imulq 0x20(%rdi), %rax
addq 0x18(%rdi), %rax
movslq %esi, %rcx
andq 0x28(%rdi), %rax
movq %rax, 0x20(%rdi)
shrq $0x11, %rax
movslq %eax, %rdx
imulq %rcx, %rdx
shrq $0x1f, %rdx
jmp 0x3944
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %r10
movq 0x28(%rdi), %r11
movq 0x20(%rdi), %r9
imulq %r8, %r9
addq %r10, %r9
andq %r11, %r9
movq %r9, %rcx
shrq $0x11, %rcx
movl %ecx, %eax
cltd
idivl %esi
addl %esi, %ecx
cmpl %ecx, %edx
jns 0x3924
movq %r9, 0x20(%rdi)
movl %edx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::nextGaussian()
double Benchmarks::nextGaussian(){
  double multiplier, v1, v2, s;

  if (m_havenextGaussian) {
    m_havenextGaussian = false;
    return(m_nextGaussian) ;
  }

  do {
    v1 = ((D(2.0) * nextDouble()) - D(1.0));
    v2 = ((D(2.0) * nextDouble()) - D(1.0));
    s  = ((v1 * v1) + (v2 * v2));
  } while ((s >= D(1.0)) || (s <= D(0.0)));

  multiplier = sqrt(D(-2.0) * log(s) / s);
  m_nextGaussian    = (v2 * multiplier);
  m_havenextGaussian = true;
  return (v1 * multiplier);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x38(%rdi)
je 0x39c0
movb $0x0, 0x38(%rbx)
movsd 0x30(%rbx), %xmm1
jmp 0x3af6
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x28(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq $-0x8000000, %rdi       # imm = 0xF8000000
movsd 0x7629(%rip), %xmm7     # 0xb008
movsd 0x7629(%rip), %xmm1     # 0xb010
movsd 0x7629(%rip), %xmm2     # 0xb018
xorpd %xmm3, %xmm3
imulq %rax, %rdx
addq %rcx, %rdx
andq %rsi, %rdx
movq %rdx, %r8
shlq $0xa, %r8
sarq $0x5, %r8
andq %rdi, %r8
imulq %rax, %rdx
addq %rcx, %rdx
andq %rsi, %rdx
movq %rdx, %r9
shrq $0x15, %r9
movslq %r9d, %r9
addq %r8, %r9
xorps %xmm5, %xmm5
cvtsi2sd %r9, %xmm5
mulsd %xmm7, %xmm5
addsd %xmm5, %xmm5
addsd %xmm1, %xmm5
imulq %rax, %rdx
addq %rcx, %rdx
andq %rsi, %rdx
movq %rdx, %r8
shlq $0xa, %r8
sarq $0x5, %r8
andq %rdi, %r8
imulq %rax, %rdx
addq %rcx, %rdx
andq %rsi, %rdx
movq %rdx, %r9
shrq $0x15, %r9
movslq %r9d, %r9
addq %r8, %r9
xorps %xmm6, %xmm6
cvtsi2sd %r9, %xmm6
mulsd %xmm7, %xmm6
addsd %xmm6, %xmm6
addsd %xmm1, %xmm6
movapd %xmm6, %xmm4
mulsd %xmm6, %xmm4
movapd %xmm5, %xmm0
mulsd %xmm5, %xmm0
addsd %xmm4, %xmm0
ucomisd %xmm2, %xmm0
jae 0x39f3
ucomisd %xmm0, %xmm3
jae 0x39f3
movsd %xmm6, -0x18(%rbp)
movsd %xmm5, -0x20(%rbp)
movq %rdx, 0x20(%rbx)
movsd %xmm0, -0x10(%rbp)
callq 0x31c0
mulsd 0x755f(%rip), %xmm0     # 0xb020
divsd -0x10(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3ad6
sqrtsd %xmm0, %xmm0
jmp 0x3adb
callq 0x31b0
movsd -0x18(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x30(%rbx)
movb $0x1, 0x38(%rbx)
movsd -0x20(%rbp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::createShiftVector(int, double, double)
double* Benchmarks::createShiftVector(int dim, double min,double max) {

  double* d;
  double  hw, middle;
  double  s;
  int     i;
  hw     = (D(0.5) * (max - min));
  middle = (min + hw);
  //d      = (double*)malloc(sizeof(double) * dim);
  d      = new double[dim];

  //	printf("middle = %1.20E\n",middle);
  //	printf("hw = %1.20E\n",hw);

  for (i = (dim - 1); i >= 0; i--) {
    if (setOvectorToZero == true){
      d[i] = 0;
    }else{
      do {
        double tempGauss = nextGaussian();
        s = (middle + (tempGauss * hw));
      } while ((s < min) || (s > max));
      d[i] = s;
      //			printf("shift vector = %1.20E\n", d[i]);
    }
  }
  return(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movl %esi, %r15d
movq %rdi, %rbx
movslq %esi, %r12
leaq (,%r12,8), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r14
testl %r12d, %r12d
jle 0x3baf
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm0, %xmm1
mulsd 0x74cb(%rip), %xmm1     # 0xb028
movsd %xmm1, -0x40(%rbp)
addsd %xmm0, %xmm1
movsd %xmm1, -0x38(%rbp)
movl %r15d, %r15d
xorpd %xmm0, %xmm0
cmpb $0x0, 0x39(%rbx)
jne 0x3b9c
movq %rbx, %rdi
callq 0x39a0
mulsd -0x40(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x3b78
ucomisd -0x28(%rbp), %xmm0
ja 0x3b78
leaq -0x1(%r15), %rax
movsd %xmm0, (%r14,%rax,8)
cmpq $0x1, %r15
movq %rax, %r15
jg 0x3b6e
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::createPermVector(int)
int* Benchmarks::createPermVector(int dim){
  int* d;
  int  i, j, k, t;
  //d = (int*)malloc(sizeof(int) * dim);
  d = new int[dim];

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

  for (i = (dim << 3); i >= 0; i--) {
    j = nextInt(dim);

    do {
      k = nextInt(dim);
    } while (k == j);

    t    = d[j];
    d[j] = d[k];
    d[k] = t;
  }

  return(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %r12
leaq (,%r12,4), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r15
testl %r12d, %r12d
jle 0x46d5
movl %ebx, %eax
leaq -0x1(%rax), %rcx
movl %ecx, -0x4(%r15,%rax,4)
cmpq $0x1, %rax
movq %rcx, %rax
jg 0x46c3
leal (,%rbx,8), %r13d
testl %r13d, %r13d
js 0x471f
movq %r14, %rdi
movl %ebx, %esi
callq 0x38e0
movl %eax, %r12d
movq %r14, %rdi
movl %ebx, %esi
callq 0x38e0
cmpl %r12d, %eax
je 0x46ef
movslq %r12d, %rcx
movl (%r15,%rcx,4), %edx
cltq
movl (%r15,%rax,4), %esi
movl %esi, (%r15,%rcx,4)
movl %edx, (%r15,%rax,4)
leal -0x1(%r13), %eax
testl %r13d, %r13d
movl %eax, %r13d
jg 0x46e2
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::readPermVector()
int* Benchmarks::readPermVector(){
  int* d;

  d = new int[dimension];

  stringstream ss;
  ss<< "cdatafiles/" << "F" << ID << "-p.txt";
  ifstream file (ss.str());
  int c=0;
  string value;

  if (file.is_open())
    {
      while (getline(file,value,','))
        {
          d[c++] = stod(value) - 1;
        }
    }

  // for (int i = 0; i < dimension; ++i)
  //   {
  //     printf("%d\n", d[i]);
  //   }

  return(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3c8, %rsp            # imm = 0x3C8
movq %rdi, %r14
movslq 0xb8(%rdi), %rax
leaq (,%rax,4), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, -0x50(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x3160
leaq -0x1d0(%rbp), %r15
leaq 0x6947(%rip), %rsi      # 0xb0d0
movl $0xb, %edx
movq %r15, %rdi
callq 0x3230
leaq 0x693f(%rip), %rsi      # 0xb0dc
movl $0x1, %edx
movq %r15, %rdi
callq 0x3230
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x3140
leaq 0x6941(%rip), %rsi      # 0xb0fe
movl $0x6, %edx
movq %rax, %rdi
callq 0x3230
leaq -0x1c8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x32b0
leaq -0x3e8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x8, %edx
callq 0x32c0
leaq -0x38(%rbp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x4801
callq 0x31f0
movq %rbx, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
leaq -0x370(%rbp), %rdi
callq 0x3090
testb %al, %al
je 0x489a
leaq -0x48(%rbp), %r15
movq -0x50(%rbp), %r14
leaq -0x3e8(%rbp), %rdi
movq %r15, %rsi
movl $0x2c, %edx
callq 0x3340
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x489a
movq -0x48(%rbp), %rbx
callq 0x3050
movq %rax, %r13
movl (%rax), %r12d
movl $0x0, (%rax)
movq %rbx, %rdi
leaq -0x58(%rbp), %rsi
callq 0x3190
cmpq %rbx, -0x58(%rbp)
je 0x48ed
movl (%r13), %eax
testl %eax, %eax
je 0x4881
cmpl $0x22, %eax
jne 0x4885
jmp 0x48f9
movl %r12d, (%r13)
addsd 0x6783(%rip), %xmm0     # 0xb010
cvttsd2si %xmm0, %eax
movl %eax, (%r14)
addq $0x4, %r14
jmp 0x4829
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x48ac
callq 0x31f0
leaq -0x3e8(%rbp), %rdi
callq 0x30a0
movq 0xa6f9(%rip), %rsi      # 0xefb8
leaq -0x1e0(%rbp), %rdi
callq 0x3180
leaq -0x160(%rbp), %rdi
callq 0x30c0
movq -0x50(%rbp), %rax
addq $0x3c8, %rsp            # imm = 0x3C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6847(%rip), %rdi      # 0xb13b
callq 0x3130
leaq 0x683b(%rip), %rdi      # 0xb13b
callq 0x3280
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4954
callq 0x31f0
jmp 0x4954
jmp 0x491e
movq %rax, %rbx
jmp 0x4954
movq %rax, %rbx
jmp 0x4936
movq %rax, %rbx
cmpl $0x0, (%r13)
jne 0x4936
movl %r12d, (%r13)
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4948
callq 0x31f0
leaq -0x3e8(%rbp), %rdi
callq 0x30a0
movq 0xa65d(%rip), %rsi      # 0xefb8
leaq -0x1e0(%rbp), %rdi
callq 0x3180
leaq -0x160(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::createRotMatrix1D(int)
double* Benchmarks::createRotMatrix1D(int dim){
  double** a;
  double*  b;
  int      i, j, k;
  a = createRotMatrix(dim);
  //b = (double*)malloc(sizeof(double) * (dim * dim));
  b = new double[dim*dim];
  k = 0;

  for (i = 0; i < dim; i++) {
    for (j = 0; j < dim; j++) {
      b[k++] = a[i][j];
    }
  }

  // release the memory that previously allocated for storing a 2D array
  for(i=0;i<dim;i++){
    delete []a[i];
  }
  delete[] a;

  return(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r12d
callq 0x497c
movq %rax, %rbx
movl %r12d, %edi
imull %edi, %edi
shlq $0x3, %rdi
callq 0x3030
movl %r12d, %r13d
testl %r12d, %r12d
movq %rax, -0x30(%rbp)
jle 0x4b92
leaq (,%r13,8), %rdx
movq %rdx, -0x38(%rbp)
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx,%r14,8), %rsi
movslq %r15d, %r15
leaq (%rax,%r15,8), %rdi
movq -0x38(%rbp), %rdx
callq 0x31d0
movq -0x30(%rbp), %rax
addl %r12d, %r15d
incq %r14
cmpq %r14, %r13
jne 0x4b6f
testl %r12d, %r12d
jle 0x4bb0
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4ba8
callq 0x3260
incq %r14
cmpq %r14, %r13
jne 0x4b9a
movq %rbx, %rdi
callq 0x3260
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::createMultiRotateMatrix1D(int, int)
double** Benchmarks::createMultiRotateMatrix1D(int dim, int num){
  double** a;
  int i;

  /*  allocate storage for an array of pointers */
  //a =(double **) malloc(num * sizeof(double *));
  a = new double*[num];

  /* for each pointer, allocate storage for an array of ints */
  for (i = 0; i < num; i++) {
    a[i] = createRotMatrix1D(dim);
  }

  return (a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movl %esi, %ebx
movq %rdi, %r14
movslq %edx, %r13
leaq (,%r13,8), %rax
testl %r13d, %r13d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r15
testl %r13d, %r13d
jle 0x4c24
movl %r12d, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
movl %ebx, %esi
callq 0x4b26
movq %rax, (%r15,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x4c0e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::readS(int)
int* Benchmarks::readS(int num)
{
  s = new int[num];

  stringstream ss;
  ss<< "cdatafiles/" << "F" << ID << "-s.txt";
  ifstream file (ss.str());
  int c=0;
  string value;
  if (file.is_open())
    {
      while (getline(file,value))
        {
          // cout<<stod(value)<<endl;
          s[c++] = stod(value);
        }
    }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3c8, %rsp            # imm = 0x3C8
movq %rdi, %rbx
movslq %esi, %rax
leaq (,%rax,4), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rbx, -0x30(%rbp)
movq %rax, 0xf0(%rbx)
leaq -0x1e0(%rbp), %rdi
callq 0x3160
leaq -0x1d0(%rbp), %r14
leaq 0x6041(%rip), %rsi      # 0xb0d0
movl $0xb, %edx
movq %r14, %rdi
callq 0x3230
leaq 0x6039(%rip), %rsi      # 0xb0dc
movl $0x1, %edx
movq %r14, %rdi
callq 0x3230
movq -0x30(%rbp), %rax
movl 0x8(%rax), %esi
movq %r14, %rdi
callq 0x3140
leaq 0x6042(%rip), %rsi      # 0xb108
movl $0x6, %edx
movq %rax, %rdi
callq 0x3230
leaq -0x1c8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x32b0
leaq -0x3e8(%rbp), %r14
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x32c0
leaq -0x40(%rbp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x510d
callq 0x31f0
movq %rbx, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
leaq -0x370(%rbp), %rdi
callq 0x3090
testb %al, %al
je 0x51c5
xorl %r15d, %r15d
movq -0x3e8(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %edx
movq %r14, %rdi
leaq -0x50(%rbp), %rsi
callq 0x3340
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x51c5
movq -0x50(%rbp), %r12
callq 0x3050
movq %rax, %r13
movl (%rax), %ebx
movl $0x0, (%rax)
movq %r12, %rdi
leaq -0x58(%rbp), %rsi
callq 0x3190
cmpq %r12, -0x58(%rbp)
je 0x5222
movl (%r13), %eax
testl %eax, %eax
je 0x51a5
cmpl $0x22, %eax
jne 0x51a9
jmp 0x522e
movl %ebx, (%r13)
cvttsd2si %xmm0, %eax
movq -0x30(%rbp), %rcx
movq 0xf0(%rcx), %rcx
movl %eax, (%rcx,%r15)
addq $0x4, %r15
jmp 0x5134
movq -0x30(%rbp), %rax
movq 0xf0(%rax), %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x51e2
callq 0x31f0
leaq -0x3e8(%rbp), %rdi
callq 0x30a0
movq 0x9dc3(%rip), %rsi      # 0xefb8
leaq -0x1e0(%rbp), %rdi
callq 0x3180
leaq -0x160(%rbp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x3c8, %rsp            # imm = 0x3C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f12(%rip), %rdi      # 0xb13b
callq 0x3130
leaq 0x5f06(%rip), %rdi      # 0xb13b
callq 0x3280
movq %rax, %r14
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5289
callq 0x31f0
jmp 0x5289
jmp 0x5253
movq %rax, %r14
jmp 0x5289
movq %rax, %r14
cmpl $0x0, (%r13)
jne 0x526b
movl %ebx, (%r13)
jmp 0x526b
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x527d
callq 0x31f0
leaq -0x3e8(%rbp), %rdi
callq 0x30a0
movq 0x9d28(%rip), %rsi      # 0xefb8
leaq -0x1e0(%rbp), %rdi
callq 0x3180
leaq -0x160(%rbp), %rdi
callq 0x30c0
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::readW(int)
double* Benchmarks::readW(int num)
{
  w = new double[num];

  stringstream ss;
  ss<< "cdatafiles/" << "F" << ID << "-w.txt";
  ifstream file (ss.str());
  int c=0;
  string value;
  if (file.is_open())
    {
      while (getline(file,value))
        {
          // cout<<stod(value)<<endl;
          w[c++] = stod(value);
        }
    }

  return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3c8, %rsp            # imm = 0x3C8
movq %rdi, %rbx
movslq %esi, %rax
leaq (,%rax,8), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rbx, -0x30(%rbp)
movq %rax, 0xf8(%rbx)
leaq -0x1e0(%rbp), %rdi
callq 0x3160
leaq -0x1d0(%rbp), %r14
leaq 0x5dc7(%rip), %rsi      # 0xb0d0
movl $0xb, %edx
movq %r14, %rdi
callq 0x3230
leaq 0x5dbf(%rip), %rsi      # 0xb0dc
movl $0x1, %edx
movq %r14, %rdi
callq 0x3230
movq -0x30(%rbp), %rax
movl 0x8(%rax), %esi
movq %r14, %rdi
callq 0x3140
leaq 0x5dcf(%rip), %rsi      # 0xb10f
movl $0x6, %edx
movq %rax, %rdi
callq 0x3230
leaq -0x1c8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x32b0
leaq -0x3e8(%rbp), %r14
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x32c0
leaq -0x40(%rbp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x5387
callq 0x31f0
movq %rbx, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
leaq -0x370(%rbp), %rdi
callq 0x3090
testb %al, %al
je 0x543d
xorl %r15d, %r15d
movq -0x3e8(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %edx
movq %r14, %rdi
leaq -0x50(%rbp), %rsi
callq 0x3340
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x543d
movq -0x50(%rbp), %r12
callq 0x3050
movq %rax, %r13
movl (%rax), %ebx
movl $0x0, (%rax)
movq %r12, %rdi
leaq -0x58(%rbp), %rsi
callq 0x3190
cmpq %r12, -0x58(%rbp)
je 0x549a
movl (%r13), %eax
testl %eax, %eax
je 0x541f
cmpl $0x22, %eax
jne 0x5423
jmp 0x54a6
movl %ebx, (%r13)
movq -0x30(%rbp), %rax
movq 0xf8(%rax), %rax
movsd %xmm0, (%rax,%r15)
addq $0x8, %r15
jmp 0x53ae
movq -0x30(%rbp), %rax
movq 0xf8(%rax), %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x545a
callq 0x31f0
leaq -0x3e8(%rbp), %rdi
callq 0x30a0
movq 0x9b4b(%rip), %rsi      # 0xefb8
leaq -0x1e0(%rbp), %rdi
callq 0x3180
leaq -0x160(%rbp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x3c8, %rsp            # imm = 0x3C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5c9a(%rip), %rdi      # 0xb13b
callq 0x3130
leaq 0x5c8e(%rip), %rdi      # 0xb13b
callq 0x3280
movq %rax, %r14
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5501
callq 0x31f0
jmp 0x5501
jmp 0x54cb
movq %rax, %r14
jmp 0x5501
movq %rax, %r14
cmpl $0x0, (%r13)
jne 0x54e3
movl %ebx, (%r13)
jmp 0x54e3
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x54f5
callq 0x31f0
leaq -0x3e8(%rbp), %rdi
callq 0x30a0
movq 0x9ab0(%rip), %rsi      # 0xefb8
leaq -0x1e0(%rbp), %rdi
callq 0x3180
leaq -0x160(%rbp), %rdi
callq 0x30c0
movq %r14, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O1/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rotateVector(int, int&)
double* Benchmarks::rotateVector(int i, int &c)
{
  double* z = new double[s[i]];
  // cout<<"s "<<s[i]<<endl;

  // copy values into the new vector
  for (int j = c; j < c+s[i]; ++j)
    {
      // cout<<"j-c "<<j-c<<" p "<<Pvector[j]<<endl;
      z[j-c] = 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), %r12
movslq %esi, %r13
movslq (%r12,%r13,4), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, %r15
movslq (%r12,%r13,4), %rax
testq %rax, %rax
jle 0x559e
movslq (%rbx), %rcx
leaq (%rax,%rcx), %rdx
movq 0x58(%r14), %rsi
movq 0x70(%r14), %rdi
movq %r15, %r8
movslq (%rsi,%rcx,4), %r9
movsd (%rdi,%r9,8), %xmm0
movsd %xmm0, (%r8)
incq %rcx
addq $0x8, %r8
cmpq %rdx, %rcx
jl 0x5583
cmpl $0x19, %eax
je 0x5652
cmpl $0x32, %eax
je 0x5605
cmpl $0x64, %eax
jne 0x56a3
movq 0xe8(%r14), %r12
movl $0x320, %edi            # imm = 0x320
callq 0x3030
movl $0x63, %ecx
movq $0x0, (%rax,%rcx,8)
movq (%r12,%rcx,8), %rdx
xorpd %xmm0, %xmm0
movl $0x63, %esi
movsd (%r15,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
addq $-0x1, %rsi
jb 0x55e0
movsd %xmm0, (%rax,%rcx,8)
subq $0x1, %rcx
jae 0x55cb
jmp 0x569d
movq 0xe0(%r14), %r12
movl $0x190, %edi            # imm = 0x190
callq 0x3030
movl $0x31, %ecx
movq $0x0, (%rax,%rcx,8)
movq (%r12,%rcx,8), %rdx
xorpd %xmm0, %xmm0
movl $0x31, %esi
movsd (%r15,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
addq $-0x1, %rsi
jb 0x5630
movsd %xmm0, (%rax,%rcx,8)
subq $0x1, %rcx
jae 0x561b
jmp 0x569d
movq 0xd8(%r14), %r12
movl $0xc8, %edi
callq 0x3030
movl $0x18, %ecx
movq $0x0, (%rax,%rcx,8)
movq (%r12,%rcx,8), %rdx
xorpd %xmm0, %xmm0
movl $0x18, %esi
movsd (%r15,%rsi,8), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
addq $-0x1, %rsi
jb 0x567d
movsd %xmm0, (%rax,%rcx,8)
subq $0x1, %rcx
jae 0x5668
movq %rax, 0x78(%r14)
jmp 0x56e6
movq 0x9926(%rip), %r12      # 0xefd0
leaq 0x5a65(%rip), %rsi      # 0xb116
movl $0x24, %edx
movq %r12, %rdi
callq 0x3230
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3200
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3150
movq %r15, %rdi
callq 0x3260
movq 0xf0(%r14), %rax
movl (%rax,%r13,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
// File: /workspace/github_cpp_makefile_star2_O1/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[i][j];
    }
  }

  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rdx, %rbx
movq %rsi, %r15
movslq %ecx, %r12
leaq (,%r12,8), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
testl %r12d, %r12d
jle 0x5787
decl %r14d
leaq 0x1(%r14), %rcx
movq $0x0, (%rax,%r14,8)
movq (%rbx,%r14,8), %rdx
xorpd %xmm0, %xmm0
movq %rcx, %rsi
movsd -0x8(%r15,%rsi,8), %xmm1
mulsd -0x8(%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
decq %rsi
jg 0x575f
movsd %xmm0, (%rax,%r14,8)
leaq -0x1(%r14), %rdx
testq %r14, %r14
movq %rdx, %r14
jg 0x574c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14d
movq %rsi, %rbx
callq 0x438e
testl %r14d, %r14d
jle 0x5c20
leal -0x1(%r14), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
movl %r14d, %r14d
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movsd %xmm0, -0x20(%rbp)
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
divsd -0x28(%rbp), %xmm1
movsd 0x5448(%rip), %xmm0     # 0xb038
callq 0x3310
movsd (%rbx,%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
cmpq %r15, %r14
jne 0x5bd6
jmp 0x5c24
xorpd %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %rbx
callq 0x438e
movl %r14d, %r15d
testl %r14d, %r14d
jle 0x5d3d
leal -0x1(%r14), %eax
cvtsi2sd %eax, %xmm2
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movsd %xmm2, -0x30(%rbp)
movsd (%rbx,%r12,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0x5ce9
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd 0x53b0(%rip), %xmm1     # 0xb040
ucomisd %xmm0, %xmm3
jb 0x5c9f
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x5cc1
movapd %xmm3, %xmm0
movsd %xmm3, -0x28(%rbp)
movsd %xmm1, -0x38(%rbp)
callq 0x31b0
movsd -0x38(%rbp), %xmm1
movsd -0x28(%rbp), %xmm3
movsd -0x30(%rbp), %xmm2
divsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd 0x5347(%rip), %xmm1     # 0xb018
movapd %xmm3, %xmm0
callq 0x3310
movsd -0x30(%rbp), %xmm2
movsd %xmm0, (%rbx,%r12,8)
xorpd %xmm0, %xmm0
incq %r12
cmpq %r12, %r15
jne 0x5c74
testl %r14d, %r14d
jle 0x5d3d
xorl %r12d, %r12d
movsd (%rbx,%r12,8), %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd 0x5314(%rip), %xmm1     # 0xb028
divsd %xmm2, %xmm1
movsd 0x5328(%rip), %xmm0     # 0xb048
callq 0x3310
movsd -0x30(%rbp), %xmm2
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rbx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x5cf9
testl %r14d, %r14d
jle 0x5d98
incq %r15
xorpd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbx,%r15,8), %xmm0
movsd %xmm0, -0x28(%rbp)
mulsd 0x52ee(%rip), %xmm0     # 0xb050
callq 0x3350
mulsd 0x52e9(%rip), %xmm0     # 0xb058
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd 0x52bf(%rip), %xmm1     # 0xb048
addsd %xmm1, %xmm0
decq %r15
cmpq $0x1, %r15
jg 0x5d49
jmp 0x5d9c
xorpd %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %edx, %eax
cltd
idivl %ecx
testl %eax, %eax
jle 0x5e40
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl %eax, %r15d
leaq 0x1(%r15), %r12
shlq $0x3, %r15
xorpd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x58(%r14), %rax
movslq -0x4(%rax,%r15), %rax
movsd (%rbx,%rax,8), %xmm0
movsd %xmm0, -0x28(%rbp)
mulsd 0x5255(%rip), %xmm0     # 0xb050
callq 0x3350
mulsd 0x5250(%rip), %xmm0     # 0xb058
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd 0x5226(%rip), %xmm1     # 0xb048
addsd %xmm1, %xmm0
decq %r12
addq $-0x4, %r15
cmpq $0x1, %r12
jg 0x5ddb
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rsi, %r14
callq 0x438e
movl %ebx, %r15d
testl %ebx, %ebx
jle 0x5f43
leal -0x1(%rbx), %eax
cvtsi2sd %eax, %xmm2
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movsd %xmm2, -0x28(%rbp)
movsd (%r14,%r12,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0x5ef0
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd 0x51a9(%rip), %xmm1     # 0xb040
ucomisd %xmm0, %xmm3
jb 0x5ea6
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x5ec8
movapd %xmm3, %xmm0
movsd %xmm3, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
callq 0x31b0
movsd -0x38(%rbp), %xmm1
movsd -0x30(%rbp), %xmm3
movsd -0x28(%rbp), %xmm2
divsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd 0x5140(%rip), %xmm1     # 0xb018
movapd %xmm3, %xmm0
callq 0x3310
movsd -0x28(%rbp), %xmm2
movsd %xmm0, (%r14,%r12,8)
xorpd %xmm0, %xmm0
incq %r12
cmpq %r12, %r15
jne 0x5e7b
testl %ebx, %ebx
jle 0x5f43
xorl %r12d, %r12d
movsd (%r14,%r12,8), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd 0x510e(%rip), %xmm1     # 0xb028
divsd %xmm2, %xmm1
movsd 0x5122(%rip), %xmm0     # 0xb048
callq 0x3310
movsd -0x28(%rbp), %xmm2
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, (%r14,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x5eff
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
testl %ebx, %ebx
jle 0x5f9d
incq %r15
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%r14,%r15,8), %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm1, %xmm2
movsd %xmm2, -0x30(%rbp)
mulsd 0x50d9(%rip), %xmm0     # 0xb050
callq 0x3350
movsd -0x30(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
decq %r15
cmpq $0x1, %r15
jg 0x5f52
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd %xmm0, -0x30(%rbp)
divsd %xmm0, %xmm2
ucomisd 0x50c6(%rip), %xmm2     # 0xb080
jb 0x5fc5
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x5fce
movapd %xmm2, %xmm0
callq 0x31b0
mulsd 0x508a(%rip), %xmm0     # 0xb060
callq 0x3330
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
callq 0x3330
movsd -0x38(%rbp), %xmm1
mulsd 0x506c(%rip), %xmm1     # 0xb068
subsd %xmm0, %xmm1
addsd 0x5068(%rip), %xmm1     # 0xb070
addsd 0x5068(%rip), %xmm1     # 0xb078
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cltd
idivl %ecx
movl %eax, %r15d
xorpd %xmm2, %xmm2
xorps %xmm0, %xmm0
testl %eax, %eax
jle 0x60ae
movq %rsi, %rbx
movq %rdi, %r14
movl %r15d, %r12d
leaq 0x1(%r12), %r13
shlq $0x3, %r12
movsd %xmm0, -0x30(%rbp)
movq 0x58(%r14), %rax
movslq -0x4(%rax,%r12), %rax
movsd (%rbx,%rax,8), %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm1, %xmm2
movsd %xmm2, -0x38(%rbp)
mulsd 0x4fcc(%rip), %xmm0     # 0xb050
callq 0x3350
movsd -0x38(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
decq %r13
addq $-0x4, %r12
cmpq $0x1, %r13
jg 0x6058
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd %xmm0, -0x38(%rbp)
divsd %xmm0, %xmm2
ucomisd 0x4fb4(%rip), %xmm2     # 0xb080
jb 0x60d7
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x60e0
movapd %xmm2, %xmm0
callq 0x31b0
mulsd 0x4f78(%rip), %xmm0     # 0xb060
callq 0x3330
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
callq 0x3330
movsd -0x40(%rbp), %xmm1
mulsd 0x4f5a(%rip), %xmm1     # 0xb068
subsd %xmm0, %xmm1
addsd 0x4f56(%rip), %xmm1     # 0xb070
addsd 0x4f56(%rip), %xmm1     # 0xb078
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %ecx, %r15d
movq %rdx, %r14
movq %rsi, %rbx
movslq %ecx, %r12
leaq (,%r12,8), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
testl %r12d, %r12d
jle 0x61cd
movl %r15d, %ecx
leaq -0x1(%rcx), %rdx
movq %rcx, %rsi
imulq %rcx, %rsi
leaq (%r14,%rsi,8), %rsi
addq $-0x8, %rsi
leaq (,%rcx,8), %rdi
negq %rdi
movq $0x0, (%rax,%rdx,8)
xorpd %xmm0, %xmm0
movq %rsi, %r8
movq %rcx, %r9
movsd -0x8(%rbx,%r9,8), %xmm1
mulsd (%r8), %xmm1
addsd %xmm1, %xmm0
addq %rdi, %r8
decq %r9
jg 0x61a0
movsd %xmm0, (%rax,%rdx,8)
leaq -0x1(%rdx), %r8
addq $-0x8, %rsi
testq %rdx, %rdx
movq %r8, %rdx
jg 0x618e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq 0x60(%rdi), %rdx
movl %ebx, %ecx
callq 0x6136
movq %rax, %r14
movq %rax, %rsi
movl %ebx, %edx
callq 0x5c3a
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
callq 0x3260
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %edx, %edx
jle 0x62a9
movq 0x78(%rbx), %rax
decl %ecx
imull %edx, %ecx
movq 0x58(%rbx), %r9
movq 0x60(%rbx), %r10
movl %edx, %edi
leaq -0x1(%rdi), %r8
movslq %ecx, %rcx
leaq (%r9,%rcx,4), %rcx
addq $-0x4, %rcx
movq %rdi, %r9
imulq %rdi, %r9
leaq (%r10,%r9,8), %r9
addq $-0x8, %r9
leaq (,%rdi,8), %r10
negq %r10
movq $0x0, (%rax,%r8,8)
xorpd %xmm0, %xmm0
movq %r9, %r11
movq %rdi, %r14
movslq (%rcx,%r14,4), %r15
movsd (%rsi,%r15,8), %xmm1
mulsd (%r11), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r8,8)
addq %r10, %r11
decq %r14
jg 0x6278
leaq -0x1(%r8), %r11
addq $-0x8, %r9
testq %r8, %r8
movq %r11, %r8
jg 0x6266
testl %edx, %edx
jle 0x6308
decl %edx
movl %edx, %r14d
incq %r14
xorpd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq 0x78(%rbx), %rax
movsd -0x8(%rax,%r14,8), %xmm0
movsd %xmm0, -0x20(%rbp)
mulsd 0x4d7a(%rip), %xmm0     # 0xb050
callq 0x3350
mulsd 0x4d75(%rip), %xmm0     # 0xb058
movsd -0x20(%rbp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
addsd 0x4d4b(%rip), %xmm1     # 0xb048
addsd %xmm1, %xmm0
decq %r14
jg 0x62b9
jmp 0x630c
xorpd %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq 0x60(%rdi), %rdx
movl %ebx, %ecx
callq 0x6136
movq %rax, %r14
movq %rax, %rsi
movl %ebx, %edx
callq 0x5e44
movsd %xmm0, -0x18(%rbp)
movq %r14, %rdi
callq 0x3260
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rdi, %r14
testl %edx, %edx
jle 0x63ec
movq 0x78(%r14), %rax
decl %ecx
imull %ebx, %ecx
movq 0x58(%r14), %r8
movq 0x60(%r14), %r9
movl %ebx, %edx
leaq -0x1(%rdx), %rdi
movslq %ecx, %rcx
leaq (%r8,%rcx,4), %rcx
addq $-0x4, %rcx
movq %rdx, %r8
imulq %rdx, %r8
leaq (%r9,%r8,8), %r8
addq $-0x8, %r8
leaq (,%rdx,8), %r9
negq %r9
movq $0x0, (%rax,%rdi,8)
xorpd %xmm0, %xmm0
movq %r8, %r10
movq %rdx, %r11
movslq (%rcx,%r11,4), %r15
movsd (%rsi,%r15,8), %xmm1
mulsd (%r10), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rdi,8)
addq %r9, %r10
decq %r11
jg 0x63bc
leaq -0x1(%rdi), %r10
addq $-0x8, %r8
testq %rdi, %rdi
movq %r10, %rdi
jg 0x63aa
xorpd %xmm2, %xmm2
xorpd %xmm0, %xmm0
testl %ebx, %ebx
jle 0x644c
leal -0x1(%rbx), %eax
movl %eax, %r15d
incq %r15
movsd %xmm0, -0x20(%rbp)
movq 0x78(%r14), %rax
movsd -0x8(%rax,%r15,8), %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm1, %xmm2
movsd %xmm2, -0x28(%rbp)
mulsd 0x4c26(%rip), %xmm0     # 0xb050
callq 0x3350
movsd -0x28(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
decq %r15
jg 0x6401
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd %xmm0, -0x28(%rbp)
divsd %xmm0, %xmm2
ucomisd 0x4c17(%rip), %xmm2     # 0xb080
jb 0x6474
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x647d
movapd %xmm2, %xmm0
callq 0x31b0
mulsd 0x4bdb(%rip), %xmm0     # 0xb060
callq 0x3330
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
callq 0x3330
movsd -0x30(%rbp), %xmm1
mulsd 0x4bbd(%rip), %xmm1     # 0xb068
subsd %xmm0, %xmm1
addsd 0x4bb9(%rip), %xmm1     # 0xb070
addsd 0x4bb9(%rip), %xmm1     # 0xb078
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testl %edx, %edx
jle 0x64f8
movl %edx, %eax
incq %rax
xorpd %xmm0, %xmm0
movsd -0x10(%rsi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
decq %rax
cmpq $0x1, %rax
jg 0x64df
jmp 0x64fc
xorpd %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %edx, %eax
cltd
idivl %ecx
testl %eax, %eax
jle 0x653f
pushq %rbp
movq %rsp, %rbp
movq 0x58(%rdi), %rcx
movl %eax, %eax
leaq (%rcx,%rax,8), %rcx
addq $-0x4, %rcx
incq %rax
xorpd %xmm0, %xmm0
movslq (%rcx), %rdx
movsd (%rsi,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
decq %rax
addq $-0x4, %rcx
cmpq $0x1, %rax
jg 0x6520
popq %rbp
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %rbx
callq 0x438e
movl %r14d, %r15d
testl %r14d, %r14d
jle 0x65f2
leal -0x1(%r14), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x38(%rbp)
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movsd (%rbx,%r12,8), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x65ea
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd 0x4aa6(%rip), %xmm1     # 0xb040
ucomisd %xmm0, %xmm2
jb 0x65a9
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x65c6
movapd %xmm2, %xmm0
movsd %xmm2, -0x30(%rbp)
movsd %xmm1, -0x28(%rbp)
callq 0x31b0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
divsd -0x38(%rbp), %xmm1
mulsd %xmm0, %xmm1
addsd 0x4a41(%rip), %xmm1     # 0xb018
movapd %xmm2, %xmm0
callq 0x3310
movsd %xmm0, (%rbx,%r12,8)
xorpd %xmm0, %xmm0
incq %r12
cmpq %r12, %r15
jne 0x657e
xorpd %xmm0, %xmm0
testl %r14d, %r14d
jle 0x661a
xorl %eax, %eax
xorpd %xmm1, %xmm1
addsd (%rbx,%rax,8), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %r15
jne 0x6601
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %edx, %edx
jle 0x666b
pushq %rbp
movq %rsp, %rbp
decl %ecx
imull %edx, %ecx
movslq %ecx, %rax
shlq $0x2, %rax
addq 0x58(%rdi), %rax
movl %edx, %ecx
xorpd %xmm0, %xmm0
xorl %edx, %edx
xorpd %xmm1, %xmm1
movslq (%rax,%rdx,4), %rdi
addsd (%rsi,%rdi,8), %xmm1
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x664c
popq %rbp
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorpd %xmm0, %xmm0
cmpl $0x2, %edx
jl 0x66d0
pushq %rbp
movq %rsp, %rbp
addl $-0x2, %edx
incq %rdx
xorpd %xmm3, %xmm3
movsd 0x49f9(%rip), %xmm1     # 0xb088
movsd 0x4979(%rip), %xmm2     # 0xb010
movsd -0x8(%rsi,%rdx,8), %xmm0
movapd %xmm0, %xmm4
mulsd %xmm0, %xmm4
subsd (%rsi,%rdx,8), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm1, %xmm5
mulsd %xmm4, %xmm5
addsd %xmm3, %xmm5
addsd %xmm2, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm5, %xmm0
movapd %xmm0, %xmm3
decq %rdx
jg 0x6697
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorpd %xmm0, %xmm0
cmpl $0x2, %edx
jl 0x674a
pushq %rbp
movq %rsp, %rbp
decl %ecx
imull %edx, %ecx
movslq %edx, %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq 0x58(%rdi), %rcx
decq %rax
xorpd %xmm3, %xmm3
movsd 0x4987(%rip), %xmm1     # 0xb088
movsd 0x4907(%rip), %xmm2     # 0xb010
movslq (%rcx,%rax,4), %rdx
movslq -0x4(%rcx,%rax,4), %rdi
movsd (%rsi,%rdi,8), %xmm0
movapd %xmm0, %xmm4
mulsd %xmm0, %xmm4
subsd (%rsi,%rdx,8), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm1, %xmm5
mulsd %xmm4, %xmm5
addsd %xmm3, %xmm5
addsd %xmm2, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm5, %xmm0
movapd %xmm0, %xmm3
decq %rax
jg 0x6709
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
testl %r14d, %r14d
je 0x67f6
xorl %edx, %edx
xorl %ecx, %ecx
movl %edx, %esi
leal 0x1(%rsi), %edx
cmpl %r14d, %edx
jae 0x67f1
movl %edx, %edi
movl %ecx, %r8d
movl %esi, (%rax,%r8,8)
movl %edi, 0x4(%rax,%r8,8)
incl %ecx
incl %edi
cmpl %edi, %r14d
jne 0x67dc
cmpl %r14d, %edx
jne 0x67d0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rax, %rax
setne %r8b
je 0x6831
movq 0xc8(%rdi), %r9
xorl %edi, %edi
cmpl %esi, (%r9,%rdi,8)
jne 0x6825
cmpl %edx, 0x4(%r9,%rdi,8)
je 0x6847
incq %rdi
cmpq %rax, %rdi
setb %r8b
jne 0x6818
leaq 0x4908(%rip), %rdi      # 0xb140
callq 0x32a0
movl $0x1, %edi
callq 0x3250
movl %edi, (%rcx)
testb $0x1, %r8b
je 0x6831
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37cc
leaq 0x7ed6(%rip), %rax      # 0xe980
movq %rax, (%rbx)
movq $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
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3862
movq %r14, %rdi
callq 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x48(%rdi)
jne 0x6b86
movq %rbx, %rdi
callq 0x3bc0
movq %rax, 0x48(%rbx)
movslq 0xb8(%rbx), %rdx
testq %rdx, %rdx
jle 0x6bba
movq 0x48(%rbx), %rax
movq 0x70(%rbx), %rcx
leaq 0x1(%rdx), %rsi
movsd -0x10(%r14,%rsi,8), %xmm0
subsd -0x10(%rax,%rsi,8), %xmm0
movsd %xmm0, -0x10(%rcx,%rsi,8)
decq %rsi
cmpq $0x1, %rsi
jg 0x6b9e
movq 0x70(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5ba2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37cc
leaq 0x7de6(%rip), %rax      # 0xe9c8
movq %rax, (%rbx)
movq $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
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3862
movq %r14, %rdi
callq 0x3320