LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/cdalitz[P]kdtree-cpp/kdtree.cpp
// Function: Kdtree::KdTree::ball_within_bounds(std::vector<double, std::allocator<double>> const&, double, Kdtree::kdtree_node*)
bool KdTree::ball_within_bounds(const CoordPoint& point, double dist,
                                kdtree_node* node) {
  size_t i;
  for (i = 0; i < dimension; i++)
    if (distance->coordinate_distance(point[i], node->lobound[i], i) <= dist ||
        distance->coordinate_distance(point[i], node->upbound[i], i) <= dist)
      return false;
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movb $0x1, %bl
cmpq $0x0, 0x60(%rdi)
je 0x45ce
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movsd %xmm0, 0x8(%rsp)
movq 0x38(%r12), %rdi
movq (%r15), %rax
movsd (%rax,%r13,8), %xmm0
movq 0x38(%r14), %rax
movsd (%rax,%r13,8), %xmm1
movq (%rdi), %rax
movq %r13, %rsi
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jae 0x45cc
movq 0x38(%r12), %rdi
movq (%r15), %rax
movsd (%rax,%r13,8), %xmm0
movq 0x50(%r14), %rax
movsd (%rax,%r13,8), %xmm1
movq (%rdi), %rax
movq %r13, %rsi
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jae 0x45cc
incq %r13
cmpq 0x60(%r12), %r13
jb 0x4566
jmp 0x45ce
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/cdalitz[P]kdtree-cpp/kdtree.cpp
// Function: Kdtree::DistanceL0::DistanceL0(std::vector<double, std::allocator<double>> const*)
DistanceL0(const DoubleVector* weights = NULL) {
    if (weights)
      w = new DoubleVector(*weights);
    else
      w = (DoubleVector*)NULL;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x53ed(%rip), %rax      # 0x9c30
movq %rax, (%rdi)
testq %rsi, %rsi
je 0x4868
movq %rsi, %r15
movl $0x18, %edi
callq 0x2110
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x324c
jmp 0x486b
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cdalitz[P]kdtree-cpp/kdtree.cpp
// Function: Kdtree::DistanceL0::distance(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double distance(const CoordPoint& p, const CoordPoint& q) {
    size_t i;
    double dist, test;
    if (w) {
      dist = (*w)[0] * fabs(p[0] - q[0]);
      for (i = 1; i < p.size(); i++) {
        test = (*w)[i] * fabs(p[i] - q[i]);
        if (test > dist) dist = test;
      }
    } else {
      dist = fabs(p[0] - q[0]);
      for (i = 1; i < p.size(); i++) {
        test = fabs(p[i] - q[i]);
        if (test > dist) dist = test;
      }
    }
    return dist;
  }

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4b01
movq (%rax), %rax
movq (%rsi), %rcx
movsd (%rcx), %xmm1
movq (%rdx), %rdx
subsd (%rdx), %xmm1
andpd 0x285a(%rip), %xmm1     # 0x7310
mulsd (%rax), %xmm1
movq 0x8(%rsi), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
cmpq $0x2, %rsi
jb 0x4b54
movl $0x1, %edi
movapd 0x2834(%rip), %xmm2     # 0x7310
movsd (%rcx,%rdi,8), %xmm0
subsd (%rdx,%rdi,8), %xmm0
andpd %xmm2, %xmm0
mulsd (%rax,%rdi,8), %xmm0
maxsd %xmm1, %xmm0
incq %rdi
movapd %xmm0, %xmm1
cmpq %rdi, %rsi
jne 0x4adc
jmp 0x4b53
movq (%rsi), %rax
movsd (%rax), %xmm1
movq (%rdx), %rcx
subsd (%rcx), %xmm1
andpd 0x27f9(%rip), %xmm1     # 0x7310
movq 0x8(%rsi), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq $0x2, %rdx
jb 0x4b54
movl $0x1, %esi
movapd 0x27db(%rip), %xmm2     # 0x7310
movsd (%rax,%rsi,8), %xmm0
subsd (%rcx,%rsi,8), %xmm0
andpd %xmm2, %xmm0
maxsd %xmm1, %xmm0
incq %rsi
movapd %xmm0, %xmm1
cmpq %rsi, %rdx
jne 0x4b35
retq
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cdalitz[P]kdtree-cpp/kdtree.cpp
// Function: Kdtree::DistanceL0::coordinate_distance(double, double, unsigned long)
double coordinate_distance(double x, double y, size_t dim) {
    if (w)
      return (*w)[dim] * fabs(x - y);
    else
      return fabs(x - y);
  }

// Assembly:
movq 0x8(%rdi), %rax
subsd %xmm1, %xmm0
andpd 0x27a6(%rip), %xmm0     # 0x7310
testq %rax, %rax
je 0x4b77
movq (%rax), %rax
mulsd (%rax,%rsi,8), %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/cdalitz[P]kdtree-cpp/kdtree.cpp
// Function: Kdtree::DistanceL1::distance(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double distance(const CoordPoint& p, const CoordPoint& q) {
    size_t i;
    double dist = 0.0;
    if (w) {
      for (i = 0; i < p.size(); i++) dist += (*w)[i] * fabs(p[i] - q[i]);
    } else {
      for (i = 0; i < p.size(); i++) dist += fabs(p[i] - q[i]);
    }
    return dist;
  }

// Assembly:
movq 0x8(%rdi), %rdi
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
testq %rdi, %rdi
je 0x4c38
subq %rax, %rcx
je 0x4c75
sarq $0x3, %rcx
movq (%rdi), %rsi
cmpq $0x1, %rcx
adcq $0x0, %rcx
movq (%rdx), %rdx
xorpd %xmm0, %xmm0
xorl %edi, %edi
movapd 0x26f9(%rip), %xmm1     # 0x7310
movsd (%rax,%rdi,8), %xmm2
subsd (%rdx,%rdi,8), %xmm2
andpd %xmm1, %xmm2
mulsd (%rsi,%rdi,8), %xmm2
addsd %xmm2, %xmm0
incq %rdi
cmpq %rdi, %rcx
jne 0x4c17
jmp 0x4c74
subq %rax, %rcx
je 0x4c75
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movq (%rdx), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movapd 0x26b6(%rip), %xmm1     # 0x7310
movsd (%rax,%rsi,8), %xmm2
subsd (%rdx,%rsi,8), %xmm2
andpd %xmm1, %xmm2
addsd %xmm2, %xmm0
incq %rsi
cmpq %rsi, %rcx
jne 0x4c5a
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cdalitz[P]kdtree-cpp/kdtree.cpp
// Function: Kdtree::DistanceL2::coordinate_distance(double, double, unsigned long)
double coordinate_distance(double x, double y, size_t dim) {
    if (w)
      return (*w)[dim] * (x - y) * (x - y);
    else
      return (x - y) * (x - y);
  }

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4dad
movq (%rax), %rax
subsd %xmm1, %xmm0
movsd (%rax,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
jmp 0x4db9
subsd %xmm1, %xmm0
mulsd %xmm0, %xmm0
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl %esi, %r12d
leaq (,%r12,8), %rax
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r14
testl %r15d, %r15d
jle 0x3bac
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm0, %xmm1
mulsd 0x74cc(%rip), %xmm1     # 0xb028
movsd %xmm1, -0x40(%rbp)
addsd %xmm0, %xmm1
movsd %xmm1, -0x38(%rbp)
xorpd %xmm0, %xmm0
cmpb $0x0, 0x39(%rbx)
jne 0x3b98
movq %rbx, %rdi
callq 0x39a0
mulsd -0x40(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x3b74
ucomisd -0x28(%rbp), %xmm0
ja 0x3b74
leaq -0x1(%r12), %rax
movsd %xmm0, (%r14,%rax,8)
cmpq $0x1, %r12
movq %rax, %r12
jg 0x3b6a
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl %esi, %r12d
leaq (,%r12,4), %rax
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r15
testl %ebx, %ebx
jle 0x46cc
leaq -0x1(%r12), %rax
movl %eax, -0x4(%r15,%r12,4)
cmpq $0x1, %r12
movq %rax, %r12
ja 0x46b9
leal (,%rbx,8), %r13d
testl %r13d, %r13d
js 0x4716
movq %r14, %rdi
movl %ebx, %esi
callq 0x38e0
movl %eax, %r12d
movq %r14, %rdi
movl %ebx, %esi
callq 0x38e0
cmpl %r12d, %eax
je 0x46e6
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 0x46d9
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_O3/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, -0x30(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x3160
leaq -0x1d0(%rbp), %r15
leaq 0x6951(%rip), %rsi      # 0xb0d0
movl $0xb, %edx
movq %r15, %rdi
callq 0x3230
leaq 0x6949(%rip), %rsi      # 0xb0dc
movl $0x1, %edx
movq %r15, %rdi
callq 0x3230
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x3140
leaq 0x694b(%rip), %rsi      # 0xb0fe
movl $0x6, %edx
movq %rax, %rdi
callq 0x3230
leaq -0x1c8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x32b0
leaq -0x3e8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x8, %edx
callq 0x32c0
leaq -0x40(%rbp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x47f7
callq 0x31f0
movq %rbx, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
leaq -0x370(%rbp), %rdi
callq 0x3090
testb %al, %al
je 0x48a5
leaq -0x50(%rbp), %r15
movq -0x30(%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)
movq -0x50(%rbp), %rbx
jne 0x4894
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 0x48e6
movl (%r13), %eax
testl %eax, %eax
je 0x487b
cmpl $0x22, %eax
jne 0x487f
jmp 0x48f2
movl %r12d, (%r13)
addsd 0x6789(%rip), %xmm0     # 0xb010
cvttsd2si %xmm0, %eax
movl %eax, (%r14)
addq $0x4, %r14
jmp 0x4823
leaq -0x40(%rbp), %rax
cmpq %rax, %rbx
je 0x48a5
movq %rbx, %rdi
callq 0x31f0
leaq -0x3e8(%rbp), %rdi
callq 0x30a0
movq 0xa700(%rip), %rsi      # 0xefb8
leaq -0x1e0(%rbp), %rdi
callq 0x3180
leaq -0x160(%rbp), %rdi
callq 0x30c0
movq -0x30(%rbp), %rax
addq $0x3c8, %rsp            # imm = 0x3C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x684e(%rip), %rdi      # 0xb13b
callq 0x3130
leaq 0x6842(%rip), %rdi      # 0xb13b
callq 0x3280
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x494d
callq 0x31f0
jmp 0x494d
jmp 0x4917
movq %rax, %rbx
jmp 0x494d
movq %rax, %rbx
jmp 0x492f
movq %rax, %rbx
cmpl $0x0, (%r13)
jne 0x492f
movl %r12d, (%r13)
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x4941
callq 0x31f0
leaq -0x3e8(%rbp), %rdi
callq 0x30a0
movq 0xa664(%rip), %rsi      # 0xefb8
leaq -0x1e0(%rbp), %rdi
callq 0x3180
leaq -0x160(%rbp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3320
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14d
callq 0x4974
movq %rax, %rbx
movl %r14d, %edi
imull %edi, %edi
shlq $0x3, %rdi
callq 0x3030
movq %rax, %r15
testl %r14d, %r14d
jle 0x4bbf
movl %r14d, -0x2c(%rbp)
movl %r14d, %r13d
leaq (,%r13,8), %r12
movq %rbx, -0x38(%rbp)
movq %r15, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
movq -0x38(%rbp), %rax
movq (%rax,%r15,8), %rsi
movslq %r14d, %r14
leaq (%rbx,%r14,8), %rdi
movq %r12, %rdx
callq 0x31d0
addq %r13, %r14
incq %r15
cmpq %r15, %r13
jne 0x4b77
cmpl $0x0, -0x2c(%rbp)
movq %rbx, %r15
movq -0x38(%rbp), %rbx
jle 0x4bbf
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4bb7
callq 0x3260
incq %r14
cmpq %r14, %r13
jne 0x4ba9
movq %rbx, %rdi
callq 0x3260
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl %edx, %r13d
leaq (,%r13,8), %rax
testl %edx, %edx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r15
testl %r12d, %r12d
jle 0x4c2e
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebx, %esi
callq 0x4b28
movq %rax, (%r15,%r12,8)
incq %r12
cmpq %r12, %r13
jne 0x4c18
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_O3/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), %rax
movslq %esi, %r13
movslq (%rax,%r13,4), %r12
leaq (,%r12,8), %rax
testq %r12, %r12
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r15
testq %r12, %r12
jle 0x55af
movslq (%rbx), %rax
leaq (%r12,%rax), %rcx
movq 0x58(%r14), %rdx
movq 0x70(%r14), %rsi
movq %r15, %rdi
movslq (%rdx,%rax,4), %r8
movsd (%rsi,%r8,8), %xmm0
movsd %xmm0, (%rdi)
incq %rax
addq $0x8, %rdi
cmpq %rcx, %rax
jl 0x5595
cmpl $0x19, %r12d
je 0x5656
cmpl $0x32, %r12d
je 0x5611
cmpl $0x64, %r12d
jne 0x569f
movq 0xe8(%r14), %r12
movl $0x320, %edi            # imm = 0x320
callq 0x3030
movl $0x63, %ecx
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 0x55ec
movsd %xmm0, (%rax,%rcx,8)
subq $0x1, %rcx
jae 0x55df
jmp 0x5699
movq 0xe0(%r14), %r12
movl $0x190, %edi            # imm = 0x190
callq 0x3030
movl $0x31, %ecx
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 0x5634
movsd %xmm0, (%rax,%rcx,8)
subq $0x1, %rcx
jae 0x5627
jmp 0x5699
movq 0xd8(%r14), %r12
movl $0xc8, %edi
callq 0x3030
movl $0x18, %ecx
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 0x5679
movsd %xmm0, (%rax,%rcx,8)
subq $0x1, %rcx
jae 0x566c
movq %rax, 0x78(%r14)
jmp 0x56e2
movq 0x992a(%rip), %r12      # 0xefd0
leaq 0x5a69(%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_O3/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 %rbx
pushq %rax
movl %ecx, %r14d
movq %rdx, %rbx
movq %rsi, %r15
movl %ecx, %eax
shlq $0x3, %rax
testl %ecx, %ecx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
testl %r14d, %r14d
jle 0x5774
decl %r14d
leaq 0x1(%r14), %rcx
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 0x574c
movsd %xmm0, (%rax,%r14,8)
leaq -0x1(%r14), %rdx
testq %r14, %r14
movq %rdx, %r14
jg 0x5741
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mateuz[P]MTS-LS1/source/Benchmarks.cpp
// Function: Benchmarks::rotateVectorConform(int, int&)
double* Benchmarks::rotateVectorConform(int i, int &c)
{
  double* z = new double[s[i]];
  // printf("i=%d\tc=%d\tl=%d\tu=%d\n", i, c, c - (i)*overlap, c +s[i] - (i)*overlap);
  
  // copy values into the new vector
  for (int j = c - i*overlap; j < c +s[i] - i*overlap; ++j)
    {
      // cout<<"j-c "<<j-c<<" p "<<Pvector[j]<<endl;
      z[j-(c - i*overlap)] = anotherz[Pvector[j]];
    }
  // cout<<"copy done"<<endl;
  if (s[i]==25)
    {
      anotherz1 = multiply( z, r25, s[i]);
    }
  else if (s[i] == 50)
    {    
      anotherz1 = multiply( z, r50, s[i]);
    }
  else if (s[i] == 100) 
    {
      anotherz1 = multiply( z, r100, s[i]);
    }
  else
    {
      cout<< "size of rotation matrix out of range" <<endl;
    }
  delete []z;
  c = c + s[i];
  return anotherz1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, -0x30(%rbp)
movq %rdi, %r14
movq 0xf0(%rdi), %rax
movslq %esi, %r13
movslq (%rax,%r13,4), %rbx
leaq (,%rbx,8), %rax
testq %rbx, %rbx
movl %ebx, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r15
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movl 0x40(%r14), %eax
imull %r13d, %eax
subl %eax, %ecx
leal (%rcx,%rbx), %eax
cmpl %eax, %ecx
jge 0x5806
movq 0x70(%r14), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq 0x58(%r14), %rcx
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
movsd (%rax,%rsi,8), %xmm0
movslq %edx, %rsi
movsd %xmm0, (%r15,%rsi,8)
incq %rdx
cmpl %edx, %r12d
jne 0x57ec
cmpq $0x19, %r12
je 0x58ad
cmpl $0x32, %r12d
je 0x5868
cmpl $0x64, %r12d
jne 0x58f6
movq 0xe8(%r14), %r12
movl $0x320, %edi            # imm = 0x320
callq 0x3030
movl $0x63, %ecx
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 0x5843
movsd %xmm0, (%rax,%rcx,8)
subq $0x1, %rcx
jae 0x5836
jmp 0x58f0
movq 0xe0(%r14), %r12
movl $0x190, %edi            # imm = 0x190
callq 0x3030
movl $0x31, %ecx
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 0x588b
movsd %xmm0, (%rax,%rcx,8)
subq $0x1, %rcx
jae 0x587e
jmp 0x58f0
movq 0xd8(%r14), %r12
movl $0xc8, %edi
callq 0x3030
movl $0x18, %ecx
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 0x58d0
movsd %xmm0, (%rax,%rcx,8)
subq $0x1, %rcx
jae 0x58c3
movq %rax, 0x78(%r14)
jmp 0x5939
movq 0x96d3(%rip), %r12      # 0xefd0
leaq 0x5812(%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
movq -0x30(%rbp), %rcx
addl %eax, (%rcx)
movq 0x78(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4388
testl %r14d, %r14d
jle 0x5bf4
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 0x5474(%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 0x5baa
jmp 0x5bf8
xorpd %xmm0, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4388
testl %r14d, %r14d
jle 0x5d67
leal -0x1(%r14), %eax
cvtsi2sd %eax, %xmm2
movl %r14d, %r15d
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movsd %xmm2, -0x28(%rbp)
movsd (%rbx,%r12,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0x5cbd
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd 0x53dc(%rip), %xmm1     # 0xb040
ucomisd %xmm0, %xmm3
jb 0x5c73
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x5c95
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 0x5373(%rip), %xmm1     # 0xb018
movapd %xmm3, %xmm0
callq 0x3310
movsd -0x28(%rbp), %xmm2
movsd %xmm0, (%rbx,%r12,8)
xorpd %xmm0, %xmm0
incq %r12
cmpq %r12, %r15
jne 0x5c48
xorl %r12d, %r12d
movsd (%rbx,%r12,8), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd 0x5345(%rip), %xmm1     # 0xb028
divsd %xmm2, %xmm1
movsd 0x5359(%rip), %xmm0     # 0xb048
callq 0x3310
movsd -0x28(%rbp), %xmm2
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rbx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x5cc8
testl %r14d, %r14d
jle 0x5d67
incq %r15
xorpd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbx,%r15,8), %xmm0
movsd %xmm0, -0x28(%rbp)
mulsd 0x531f(%rip), %xmm0     # 0xb050
callq 0x3350
mulsd 0x531a(%rip), %xmm0     # 0xb058
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd 0x52f0(%rip), %xmm1     # 0xb048
addsd %xmm1, %xmm0
decq %r15
cmpq $0x1, %r15
ja 0x5d18
jmp 0x5d6b
xorpd %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5e0e
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 0x5287(%rip), %xmm0     # 0xb050
callq 0x3350
mulsd 0x5282(%rip), %xmm0     # 0xb058
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd 0x5258(%rip), %xmm1     # 0xb048
addsd %xmm1, %xmm0
decq %r12
addq $-0x4, %r15
cmpq $0x1, %r12
ja 0x5da9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4388
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
testl %ebx, %ebx
jle 0x5f78
leal -0x1(%rbx), %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
movl %ebx, %r15d
xorl %r12d, %r12d
movsd %xmm2, -0x30(%rbp)
movsd (%r14,%r12,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0x5ec5
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd 0x51d4(%rip), %xmm1     # 0xb040
ucomisd %xmm0, %xmm3
jb 0x5e7b
xorps %xmm0, %xmm0
sqrtsd %xmm3, %xmm0
jmp 0x5e9d
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 0x516b(%rip), %xmm1     # 0xb018
movapd %xmm3, %xmm0
callq 0x3310
movsd -0x30(%rbp), %xmm2
movsd %xmm0, (%r14,%r12,8)
xorpd %xmm0, %xmm0
incq %r12
cmpq %r12, %r15
jne 0x5e50
xorl %r12d, %r12d
movsd (%r14,%r12,8), %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd 0x513d(%rip), %xmm1     # 0xb028
divsd %xmm2, %xmm1
movsd 0x5151(%rip), %xmm0     # 0xb048
callq 0x3310
movsd -0x30(%rbp), %xmm2
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, (%r14,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x5ed0
testl %ebx, %ebx
jle 0x5f70
incq %r15
xorpd %xmm2, %xmm2
xorpd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%r14,%r15,8), %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm1, %xmm2
movsd %xmm2, -0x30(%rbp)
mulsd 0x5108(%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
ja 0x5f23
jmp 0x5f78
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd %xmm0, -0x30(%rbp)
divsd %xmm0, %xmm2
ucomisd 0x50eb(%rip), %xmm2     # 0xb080
jb 0x5fa0
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x5fa9
movapd %xmm2, %xmm0
callq 0x31b0
mulsd 0x50af(%rip), %xmm0     # 0xb060
callq 0x3330
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
callq 0x3330
movsd -0x38(%rbp), %xmm1
mulsd 0x5091(%rip), %xmm1     # 0xb068
subsd %xmm0, %xmm1
addsd 0x508d(%rip), %xmm1     # 0xb070
addsd 0x508d(%rip), %xmm1     # 0xb078
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6088
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 0x4ff2(%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
ja 0x6032
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd %xmm0, -0x38(%rbp)
divsd %xmm0, %xmm2
ucomisd 0x4fda(%rip), %xmm2     # 0xb080
jb 0x60b1
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x60ba
movapd %xmm2, %xmm0
callq 0x31b0
mulsd 0x4f9e(%rip), %xmm0     # 0xb060
callq 0x3330
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
divsd -0x38(%rbp), %xmm0
callq 0x3330
movsd -0x40(%rbp), %xmm1
mulsd 0x4f80(%rip), %xmm1     # 0xb068
subsd %xmm0, %xmm1
addsd 0x4f7c(%rip), %xmm1     # 0xb070
addsd 0x4f7c(%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_O3/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
movl %ecx, %r12d
leaq (,%r12,8), %rax
testl %ecx, %ecx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
testl %r15d, %r15d
jle 0x619b
leaq -0x1(%r12), %rcx
movq %r12, %rdx
imulq %r12, %rdx
leaq (%r14,%rdx,8), %rdx
addq $-0x8, %rdx
leaq (,%r12,8), %rsi
negq %rsi
xorpd %xmm0, %xmm0
movq %rdx, %rdi
movq %r12, %r8
movsd -0x8(%rbx,%r8,8), %xmm1
mulsd (%rdi), %xmm1
addsd %xmm1, %xmm0
addq %rsi, %rdi
decq %r8
jg 0x616f
movsd %xmm0, (%rax,%rcx,8)
leaq -0x1(%rcx), %rdi
addq $-0x8, %rdx
testq %rcx, %rcx
movq %rdi, %rcx
jg 0x6165
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6110
movq %rax, %r14
movq %rax, %rsi
movl %ebx, %edx
callq 0x5c0e
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_O3/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:
testl %edx, %edx
jle 0x62db
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leal -0x1(%rdx), %eax
movq 0x78(%rdi), %rdi
decl %ecx
imull %edx, %ecx
movq 0x58(%rbx), %r10
movq 0x60(%rbx), %r11
movl %edx, %r8d
leaq -0x1(%r8), %r9
movslq %ecx, %rcx
leaq (%r10,%rcx,4), %rcx
addq $-0x4, %rcx
movq %r8, %r10
imulq %r8, %r10
leaq (%r11,%r10,8), %r10
addq $-0x8, %r10
leaq (,%r8,8), %r11
negq %r11
movq $0x0, (%rdi,%r9,8)
xorpd %xmm0, %xmm0
movq %r10, %r14
movq %r8, %r15
movslq (%rcx,%r15,4), %r12
movsd (%rsi,%r12,8), %xmm1
mulsd (%r14), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdi,%r9,8)
addq %r11, %r14
decq %r15
jg 0x6250
leaq -0x1(%r9), %r14
addq $-0x8, %r10
testq %r9, %r9
movq %r14, %r9
jg 0x623e
testl %edx, %edx
jle 0x62df
movl %eax, %r14d
xorpd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x78(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movsd %xmm0, -0x28(%rbp)
mulsd 0x4da8(%rip), %xmm0     # 0xb050
callq 0x3350
mulsd 0x4da3(%rip), %xmm0     # 0xb058
movsd -0x28(%rbp), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd 0x4d79(%rip), %xmm1     # 0xb048
addsd %xmm1, %xmm0
addq $-0x1, %r14
jb 0x628c
jmp 0x62e3
xorps %xmm0, %xmm0
retq
xorpd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6110
movq %rax, %r14
movq %rax, %rsi
movl %ebx, %edx
callq 0x5e12
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_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
xorpd %xmm2, %xmm2
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x643a
movq %rdi, %r14
leal -0x1(%rbx), %eax
movq 0x78(%rdi), %rdx
decl %ecx
imull %ebx, %ecx
movq 0x58(%rdi), %r9
movq 0x60(%rdi), %r10
movl %ebx, %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, (%rdx,%r8,8)
xorpd %xmm0, %xmm0
movq %r9, %r11
movq %rdi, %r15
movslq (%rcx,%r15,4), %r12
movsd (%rsi,%r12,8), %xmm1
mulsd (%r11), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%r8,8)
addq %r10, %r11
decq %r15
jg 0x63a5
leaq -0x1(%r8), %r11
addq $-0x8, %r9
testq %r8, %r8
movq %r11, %r8
jg 0x6393
testl %ebx, %ebx
jle 0x6432
movl %eax, %r15d
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
movsd %xmm0, -0x28(%rbp)
movq 0x78(%r14), %rax
movsd (%rax,%r15,8), %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm1, %xmm2
movsd %xmm2, -0x30(%rbp)
mulsd 0x4c43(%rip), %xmm0     # 0xb050
callq 0x3350
movsd -0x30(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $-0x1, %r15
jb 0x63e5
jmp 0x643a
xorpd %xmm2, %xmm2
xorpd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
movsd %xmm0, -0x30(%rbp)
divsd %xmm0, %xmm2
ucomisd 0x4c29(%rip), %xmm2     # 0xb080
jb 0x6462
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x646b
movapd %xmm2, %xmm0
callq 0x31b0
mulsd 0x4bed(%rip), %xmm0     # 0xb060
callq 0x3330
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
callq 0x3330
movsd -0x38(%rbp), %xmm1
mulsd 0x4bcf(%rip), %xmm1     # 0xb068
subsd %xmm0, %xmm1
addsd 0x4bcb(%rip), %xmm1     # 0xb070
addsd 0x4bcb(%rip), %xmm1     # 0xb078
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x64e8
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
ja 0x64cf
jmp 0x64ec
xorpd %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x652f
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
ja 0x6510
popq %rbp
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4388
testl %r14d, %r14d
jle 0x660c
leal -0x1(%r14), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x38(%rbp)
movl %r14d, %r15d
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movsd (%rbx,%r12,8), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x65da
xorps %xmm1, %xmm1
cvtsi2sd %r12d, %xmm1
mulsd 0x4ab6(%rip), %xmm1     # 0xb040
ucomisd %xmm0, %xmm2
jb 0x6599
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x65b6
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 0x4a51(%rip), %xmm1     # 0xb018
movapd %xmm2, %xmm0
callq 0x3310
movsd %xmm0, (%rbx,%r12,8)
xorpd %xmm0, %xmm0
incq %r12
cmpq %r12, %r15
jne 0x656e
testl %r14d, %r14d
jle 0x660c
xorpd %xmm0, %xmm0
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 0x65f1
jmp 0x6610
xorpd %xmm0, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6661
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 0x6642
popq %rbp
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x66c6
pushq %rbp
movq %rsp, %rbp
addl $-0x2, %edx
incq %rdx
xorpd %xmm3, %xmm3
movsd 0x4a03(%rip), %xmm1     # 0xb088
movsd 0x4983(%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
jne 0x668d
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6740
pushq %rbp
movq %rsp, %rbp
decl %ecx
imull %edx, %ecx
addl $-0x2, %edx
movslq %ecx, %rax
shlq $0x2, %rax
addq 0x58(%rdi), %rax
incq %rdx
xorpd %xmm3, %xmm3
movsd 0x4991(%rip), %xmm1     # 0xb088
movsd 0x4911(%rip), %xmm2     # 0xb010
movslq (%rax,%rdx,4), %rcx
movslq -0x4(%rax,%rdx,4), %rdi
movsd (%rsi,%rdi,8), %xmm0
movapd %xmm0, %xmm4
mulsd %xmm0, %xmm4
subsd (%rsi,%rcx,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
jne 0x66ff
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x67ec
xorl %edx, %edx
xorl %ecx, %ecx
movl %edx, %esi
leal 0x1(%rsi), %edx
cmpl %r14d, %edx
jae 0x67e7
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 0x67d2
cmpl %r14d, %edx
jne 0x67c6
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
je 0x681f
movq 0xc8(%rdi), %r8
xorl %edi, %edi
cmpl %esi, (%r8,%rdi,8)
jne 0x6817
cmpl %edx, 0x4(%r8,%rdi,8)
je 0x6835
incq %rdi
cmpq %rdi, %rax
jne 0x680a
leaq 0x491a(%rip), %rdi      # 0xb140
callq 0x32a0
movl $0x1, %edi
callq 0x3250
movl %edi, (%rcx)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mateuz[P]MTS-LS1/source/F1.cpp
// Function: F1::compute(double*)
double F1::compute(double* x) {
  double result;
  int    i;

  if(Ovector == NULL) {
    // Ovector = createShiftVector(dimension,minX,maxX);
    Ovector = readOvector();
  }

  for(i = dimension - 1; i >= 0; i--) {
    anotherz[i] = x[i] - Ovector[i];
  }

  // T_{OSZ}
  // transform_osz(anotherz,dimension);
  
  // result = elliptic(anotherz,dimension);
  result = elliptic(anotherz,dimension);
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
testq %rax, %rax
jne 0x6b70
movq %rbx, %rdi
callq 0x3bbc
movq %rax, 0x48(%rbx)
movslq 0xb8(%rbx), %rdx
movq 0x70(%rbx), %rsi
testq %rdx, %rdx
jle 0x6ba0
leaq 0x1(%rdx), %rcx
movsd -0x10(%r14,%rcx,8), %xmm0
subsd -0x10(%rax,%rcx,8), %xmm0
movsd %xmm0, -0x10(%rsi,%rcx,8)
decq %rcx
cmpq $0x1, %rcx
ja 0x6b84
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5b76
// File: /workspace/github_cpp_makefile_star2_O3/mateuz[P]MTS-LS1/source/F10.cpp
// Function: F10::~F10()
F10::~F10(){
  delete[] Ovector;
  delete[] Pvector;

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x7d8d(%rip), %rax      # 0xe9c8
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x6c4c
callq 0x3260
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x6c5a
callq 0x3260
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x6c68
callq 0x3260
xorl %r14d, %r14d
movq 0xd8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6c80
callq 0x3260
incq %r14
cmpq $0x19, %r14
jne 0x6c6b
xorl %r14d, %r14d
movq 0xe0(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6ca1
callq 0x3260
incq %r14
cmpq $0x32, %r14
jne 0x6c8c
xorl %r14d, %r14d
movq 0xe8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x6cc2
callq 0x3260
incq %r14
cmpq $0x64, %r14
jne 0x6cad
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x6cdc
callq 0x3260
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0x6ced
callq 0x3260
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x6cfe
callq 0x3260
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x6d0f
callq 0x3260
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x6d20
callq 0x3260
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3862