#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ reslist;

/* Variables and functions */
double fabs(int /*<<< orphan*/);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ log(int);
double *malloc(int);
double sqrt(double);
double *calcSCA(char m[], int n, int l) {
  int i, j, k, k1, k2;
  char reslist[] = {'A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L',
                    'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y'};
  double q[] = {.073, .025, .050, .061, .042, .072, .023, .053, .064, .089,
                .023, .043, .052, .040, .052, .073, .056, .063, .013, .033};
  int resnum = sizeof(reslist) / sizeof(char);
  double *p;
  p = malloc(l * resnum * sizeof(double));
  double *sca;
  sca = malloc(l * l * sizeof(double));
  for (i = 0; i < l; i++)
    for (j = 0; j < resnum; j++)
      p[i * resnum + j] = 0;
  for (i = 0; i < l; i++) {
    double count = 0;
    for (j = 0; j < n; j++)
      for (k = 0; k < resnum; k++)
        if (m[j * l + i] == reslist[k]) {
          p[i * resnum + k]++;
          count++;
          break;
        }
    double sumall = 0.0, temp = 0.0;
    sumall = 0;
    for (k = 0; k < resnum; k++) {
      p[i * resnum + k] = p[i * resnum + k] * 1.0 / n;
      if (p[i * resnum + k] >= 1.0 - 1e-10 || p[i * resnum + k] <= 1e-10) {
        p[i * resnum + k] = 0.0;
        temp = 0;
      } else {
        temp = fabs(log((1 - q[k]) / q[k] * p[i * resnum + k] /
                        (1 - p[i * resnum + k]))) *
               p[i * resnum + k];
        p[i * resnum + k] =
            temp * fabs(log((1 - q[k]) / q[k] * p[i * resnum + k] /
                            (1 - p[i * resnum + k])));
      }
      sumall = sumall + temp * temp;
    }
    sumall = sqrt(sumall);
    if (sumall < 1e-10)
      for (k = 0; k < resnum; k++)
        p[i * resnum + k] = 0;
    else
      for (k = 0; k < resnum; k++) {
        p[i * resnum + k] = p[i * resnum + k] / sumall;
      }
  }
  double *x;
  x = malloc(n * l * sizeof(double));
  double *sumx;
  sumx = malloc(l * sizeof(double));
  for (j = 0; j < l; j++)
    sumx[j] = 0.0;
  for (j = 0; j < n * l; j++)
    x[j] = 0.0;
  for (i = 0; i < n; i++) {
    for (j = 0; j < l; j++) {
      for (k = 0; k < resnum; k++) {
        if (reslist[k] == m[i * l + j]) {
          x[i * l + j] = p[j * resnum + k];
          sumx[j] += x[i * l + j];
        }
      }
    }
  }
  for (i = 0; i < l; i++) {
    for (j = i; j < l; j++) {
      double add = 0;
      for (k = 0; k < n; k++) {
        add += x[k * l + i] * x[k * l + j];
      }
      add = (add / n - sumx[i] * sumx[j] / n / n);
      if (add < 0)
        add = -add;
      sca[i * l + j] = add;
      sca[j * l + i] = add;
    }
  }
  free(p);
  free(x);
  free(sumx);
  return sca;
}


x86 assembly (clang, -O0):
<calcSCA>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    0xea4(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xea1(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0xe9f(%rip),%eax
mov    %eax,-0x30(%rbp)
lea    -0xe0(%rbp),%rdi
lea    0xe9e(%rip),%rsi
mov    $0xa0,%edx
call   1050 <memcpy@plt>
movl   $0x14,-0xe4(%rbp)
mov    -0x10(%rbp),%eax
imul   -0xe4(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0xf0(%rbp)
mov    -0x10(%rbp),%eax
imul   -0x10(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0xf8(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1258 <calcSCA+0xf8>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xe4(%rbp),%eax
jge    1245 <calcSCA+0xe5>
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1209 <calcSCA+0xa9>
jmp    124a <calcSCA+0xea>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11f6 <calcSCA+0x96>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16a8 <calcSCA+0x548>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1331 <calcSCA+0x1d1>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xe4(%rbp),%eax
jge    131e <calcSCA+0x1be>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movslq -0x1c(%rbp),%rcx
movsbl -0x40(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    130b <calcSCA+0x1ab>
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xd2c(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xd1a(%rip),%xmm0
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
jmp    131e <calcSCA+0x1be>
jmp    1310 <calcSCA+0x1b0>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1290 <calcSCA+0x130>
jmp    1323 <calcSCA+0x1c3>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    127d <calcSCA+0x11d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xe4(%rbp),%eax
jge    15b9 <calcSCA+0x459>
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xc89(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xc33(%rip),%xmm1
ucomisd %xmm1,%xmm0
jae    1409 <calcSCA+0x2a9>
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xc02(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jb     1438 <calcSCA+0x2d8>
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
jmp    1583 <calcSCA+0x423>
movslq -0x1c(%rbp),%rax
movsd  0xbcc(%rip),%xmm0
subsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1c(%rbp),%rax
divsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xb7b(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1070 <log@plt>
mov    %eax,%edi
call   1040 <fabs@plt>
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movslq -0x1c(%rbp),%rax
movsd  0xb22(%rip),%xmm0
subsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x1c(%rbp),%rax
divsd  -0xe0(%rbp,%rax,8),%xmm0
ff ff
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xad1(%rip),%xmm1
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1070 <log@plt>
mov    %eax,%edi
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movsd  -0x130(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm1
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1359 <calcSCA+0x1f9>
movsd  -0x108(%rbp),%xmm0
ff
call   1080 <sqrt@plt>
movsd  %xmm0,-0x108(%rbp)
ff
movsd  0xa2a(%rip),%xmm0
ucomisd -0x108(%rbp),%xmm0
ff
jbe    162c <calcSCA+0x4cc>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xe4(%rbp),%eax
jge    1627 <calcSCA+0x4c7>
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    15eb <calcSCA+0x48b>
jmp    1695 <calcSCA+0x535>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xe4(%rbp),%eax
jge    1690 <calcSCA+0x530>
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x108(%rbp),%xmm0
ff
mov    -0xf0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1633 <calcSCA+0x4d3>
jmp    1695 <calcSCA+0x535>
jmp    169a <calcSCA+0x53a>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    125f <calcSCA+0xff>
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x118(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x120(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    170d <calcSCA+0x5ad>
mov    -0x120(%rbp),%rax
movslq -0x18(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    16e0 <calcSCA+0x580>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1747 <calcSCA+0x5e7>
mov    -0x118(%rbp),%rax
movslq -0x18(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1714 <calcSCA+0x5b4>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1845 <calcSCA+0x6e5>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1832 <calcSCA+0x6d2>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xe4(%rbp),%eax
jge    181f <calcSCA+0x6bf>
movslq -0x1c(%rbp),%rax
movsbl -0x40(%rbp,%rax,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
imul   -0x10(%rbp),%edx
add    -0x18(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    180c <calcSCA+0x6ac>
mov    -0xf0(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x118(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x118(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x120(%rbp),%rax
movslq -0x18(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1811 <calcSCA+0x6b1>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1774 <calcSCA+0x614>
jmp    1824 <calcSCA+0x6c4>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1761 <calcSCA+0x601>
jmp    1837 <calcSCA+0x6d7>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    174e <calcSCA+0x5ee>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    19ca <calcSCA+0x86a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    19b7 <calcSCA+0x857>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18e0 <calcSCA+0x780>
mov    -0x118(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x118(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    187c <calcSCA+0x71c>
movsd  -0x128(%rbp),%xmm0
ff
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x120(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x120(%rbp),%rax
movslq -0x18(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
cvtsi2sdl -0xc(%rbp),%xmm2
divsd  %xmm2,%xmm1
cvtsi2sdl -0xc(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x128(%rbp),%xmm0
ff
jbe    1967 <calcSCA+0x807>
movsd  -0x128(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mov    -0xf8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x128(%rbp),%xmm0
ff
mov    -0xf8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    185e <calcSCA+0x6fe>
jmp    19bc <calcSCA+0x85c>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    184c <calcSCA+0x6ec>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x118(%rbp),%rdi
call   1030 <free@plt>
mov    -0x120(%rbp),%rdi
call   1030 <free@plt>
mov    -0xf8(%rbp),%rax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calcSCA>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %edx,%ebp
mov    %esi,%ebx
mov    %rdi,0x48(%rsp)
mov    %edx,%eax
shl    $0x5,%eax
lea    (%rax,%rax,4),%edi
call   1060 <malloc@plt>
mov    %rax,%r14
lea    0x0(,%rbp,8),%edi
mov    %edi,0x2c(%rsp)
imul   %ebp,%edi
call   1060 <malloc@plt>
mov    %ebx,%edx
mov    %rax,%r13
mov    %ebp,%r12d
cvtsi2sd %ebx,%xmm0
movapd %xmm0,0x50(%rsp)
mov    %ebx,%eax
mov    %rax,0x18(%rsp)
mov    %rbp,0x8(%rsp)
test   %ebp,%ebp
mov    %ebx,0x4(%rsp)
mov    %r14,0x10(%rsp)
jle    1505 <calcSCA+0x3a5>
mov    %r12,%rax
shl    $0x5,%rax
lea    (%rax,%rax,4),%rdx
xor    %ebx,%ebx
mov    %r14,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
movapd 0x50(%rsp),%xmm5
mov    0x4(%rsp),%edx
mov    0x48(%rsp),%rcx
xor    %eax,%eax
jmp    1259 <calcSCA+0xf9>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm0,%xmm0
mov    0x68(%rsp),%rax
movupd %xmm0,0x90(%rax)
movupd %xmm0,0x80(%rax)
movupd %xmm0,0x70(%rax)
movupd %xmm0,0x60(%rax)
movupd %xmm0,0x50(%rax)
movupd %xmm0,0x40(%rax)
movupd %xmm0,0x30(%rax)
movupd %xmm0,0x20(%rax)
movupd %xmm0,0x10(%rax)
movupd %xmm0,(%rax)
mov    0x30(%rsp),%rax
add    $0x1,%rax
add    $0x1,%rcx
add    $0x5,%ebx
cmp    %r12,%rax
je     1505 <calcSCA+0x3a5>
mov    %ebx,%r14d
and    $0x3fffffff,%r14d
shl    $0x5,%r14
mov    %rax,0x30(%rsp)
lea    0x0(,%rax,4),%rax
lea    (%rax,%rax,4),%r15
mov    0x18(%rsp),%rax
mov    %rcx,0x38(%rsp)
test   %edx,%edx
jg     139d <calcSCA+0x23d>
mov    %rbx,0x40(%rsp)
mov    0x10(%rsp),%rcx
add    %rcx,%r14
mov    %r15d,%eax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x68(%rsp)
and    $0xfffffffc,%r15d
xorpd  %xmm1,%xmm1
xor    %ebx,%ebx
jmp    12cf <calcSCA+0x16f>
nop
movsd  %xmm0,(%r14,%rbx,1)
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm1
add    $0x8,%rbx
cmp    $0xa0,%rbx
je     13e0 <calcSCA+0x280>
movsd  (%r14,%rbx,1),%xmm3
divsd  %xmm5,%xmm3
ucomisd 0xd27(%rip),%xmm3
xorpd  %xmm0,%xmm0
xorpd  %xmm2,%xmm2
jae    12b0 <calcSCA+0x150>
movsd  0xd1d(%rip),%xmm0
ucomisd %xmm3,%xmm0
xorpd  %xmm0,%xmm0
xorpd  %xmm2,%xmm2
jae    12b0 <calcSCA+0x150>
lea    0xd48(%rip),%rax
movsd  (%rbx,%rax,1),%xmm0
movsd  0xceb(%rip),%xmm2
movsd  %xmm1,0x70(%rsp)
movapd %xmm2,%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm2,%xmm0
subsd  %xmm3,%xmm0
divsd  %xmm0,%xmm1
cvttsd2si %xmm1,%ebp
mov    %ebp,%edi
movsd  %xmm3,0x20(%rsp)
call   1070 <log@plt>
mov    %eax,%edi
call   1050 <fabs@plt>
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    %ebp,%edi
call   1070 <log@plt>
mov    %eax,%edi
call   1050 <fabs@plt>
movsd  0x20(%rsp),%xmm2
movsd  0x70(%rsp),%xmm1
movapd 0x50(%rsp),%xmm5
mulsd  %xmm2,%xmm0
jmp    12b0 <calcSCA+0x150>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %r12,%rcx
add    $0xffffffffffffffff,%rax
je     128a <calcSCA+0x12a>
movzbl (%rcx),%edx
add    $0xbf,%dl
cmp    $0x18,%dl
ja     1390 <calcSCA+0x230>
movzbl %dl,%esi
mov    $0x16fbdfd,%edi
bt     %esi,%edi
jae    1390 <calcSCA+0x230>
movsbq %dl,%rdx
lea    0xd30(%rip),%rsi
mov    (%rsi,%rdx,8),%edx
add    %r15d,%edx
mov    0x10(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm0
addsd  0xc28(%rip),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
jmp    1390 <calcSCA+0x230>
nop
ucomisd 0xc30(%rip),%xmm1
jb     1400 <calcSCA+0x2a0>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    140f <calcSCA+0x2af>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm1,%xmm0
call   1080 <sqrt@plt>
movapd 0x50(%rsp),%xmm5
mov    0x4(%rsp),%edx
mov    0x10(%rsp),%r14
mov    0x40(%rsp),%rbx
mov    0x38(%rsp),%rcx
movsd  0xbe6(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     1200 <calcSCA+0xa0>
unpcklpd %xmm0,%xmm0
lea    0x0(,%r15,8),%rax
movupd (%r14,%r15,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r14,%r15,8)
or     $0x10,%rax
movupd (%r14,%rax,1),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r14,%rax,1)
movupd 0x20(%r14,%r15,8),%xmm1
movupd 0x30(%r14,%r15,8),%xmm2
movupd 0x40(%r14,%r15,8),%xmm3
movupd 0x50(%r14,%r15,8),%xmm4
divpd  %xmm0,%xmm1
movupd %xmm1,0x20(%r14,%r15,8)
divpd  %xmm0,%xmm2
movupd %xmm2,0x30(%r14,%r15,8)
divpd  %xmm0,%xmm3
movupd %xmm3,0x40(%r14,%r15,8)
divpd  %xmm0,%xmm4
movupd %xmm4,0x50(%r14,%r15,8)
movupd 0x60(%r14,%r15,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x60(%r14,%r15,8)
movupd 0x70(%r14,%r15,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x70(%r14,%r15,8)
movupd 0x80(%r14,%r15,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x80(%r14,%r15,8)
movupd 0x90(%r14,%r15,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x90(%r14,%r15,8)
jmp    1240 <calcSCA+0xe0>
mov    0x8(%rsp),%rbx
imul   %edx,%ebx
lea    0x0(,%rbx,8),%edi
call   1060 <malloc@plt>
mov    %rax,%rbp
mov    0x2c(%rsp),%edi
call   1060 <malloc@plt>
mov    %rax,%r15
cmpl   $0x0,0x8(%rsp)
jle    1541 <calcSCA+0x3e1>
lea    0x0(,%r12,8),%rdx
mov    %r15,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
test   %ebx,%ebx
jle    1555 <calcSCA+0x3f5>
mov    %ebx,%edx
shl    $0x3,%rdx
mov    %rbp,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
cmpl   $0x0,0x4(%rsp)
movapd 0x50(%rsp),%xmm7
jle    1626 <calcSCA+0x4c6>
movslq 0x8(%rsp),%r8
xor    %r9d,%r9d
lea    0xabb(%rip),%rdx
jmp    158f <calcSCA+0x42f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
cmp    0x18(%rsp),%r9
je     1626 <calcSCA+0x4c6>
cmpl   $0x0,0x8(%rsp)
jle    1580 <calcSCA+0x420>
mov    %r9,%r10
imul   %r8,%r10
xor    %r11d,%r11d
xor    %ebx,%ebx
jmp    15bd <calcSCA+0x45d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
add    $0x5,%r11d
cmp    %r12,%rbx
je     1580 <calcSCA+0x420>
mov    %r11d,%edi
and    $0x3fffffff,%edi
shl    $0x5,%rdi
add    %r14,%rdi
lea    (%rbx,%r10,1),%rcx
mov    0x48(%rsp),%rax
mov    (%rax,%rcx,1),%al
mov    $0x1,%esi
jmp    15ea <calcSCA+0x48a>
add    $0x2,%rsi
cmp    $0x15,%rsi
je     15b0 <calcSCA+0x450>
cmp    %al,-0x1(%rsi,%rdx,1)
jne    1608 <calcSCA+0x4a8>
movsd  -0x8(%rdi,%rsi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
addsd  (%r15,%rbx,8),%xmm0
movsd  %xmm0,(%r15,%rbx,8)
cmp    %al,(%rsi,%rdx,1)
jne    15e0 <calcSCA+0x480>
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
addsd  (%r15,%rbx,8),%xmm0
movsd  %xmm0,(%r15,%rbx,8)
jmp    15e0 <calcSCA+0x480>
cmpl   $0x0,0x8(%rsp)
mov    0x4(%rsp),%edx
jle    1794 <calcSCA+0x634>
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
mov    0x18(%rsp),%r10
and    $0xfffffffe,%r10d
lea    0x0(,%r12,8),%r14
add    %rbp,%r14
mov    %r12,%r11
shl    $0x4,%r11
xor    %r9d,%r9d
movapd 0x9bd(%rip),%xmm1
xorpd  %xmm2,%xmm2
mov    %rbp,%rbx
jmp    1685 <calcSCA+0x525>
nopl   0x0(%rax)
add    $0x1,%r9
add    $0x8,%r14
add    $0x8,%rbx
cmp    %r12,%r9
je     1794 <calcSCA+0x634>
movsd  (%r15,%r9,8),%xmm3
mov    %r9,%r8
imul   %r12,%r8
mov    %rbx,%rdi
mov    %r14,%rcx
mov    %r9,%rax
jmp    1714 <calcSCA+0x5b4>
nopl   (%rax)
movsd  (%r15,%rax,8),%xmm5
mulsd  %xmm3,%xmm5
divsd  %xmm7,%xmm5
unpcklpd %xmm5,%xmm4
divpd  %xmm0,%xmm4
movapd %xmm4,%xmm5
unpckhpd %xmm4,%xmm5
subsd  %xmm5,%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm1,%xmm5
movapd %xmm4,%xmm6
cmpltsd %xmm2,%xmm6
andpd  %xmm6,%xmm5
andnpd %xmm4,%xmm6
orpd   %xmm5,%xmm6
lea    (%rax,%r8,1),%rdx
movlpd %xmm6,0x0(%r13,%rdx,8)
mov    %rax,%rdx
imul   %r12,%rdx
add    %r9,%rdx
movlpd %xmm6,0x0(%r13,%rdx,8)
add    $0x1,%rax
add    $0x8,%rcx
add    $0x8,%rdi
cmp    %r12,%rax
mov    0x4(%rsp),%edx
je     1670 <calcSCA+0x510>
xorpd  %xmm4,%xmm4
test   %edx,%edx
jle    16a0 <calcSCA+0x540>
cmp    $0x1,%edx
jne    1730 <calcSCA+0x5d0>
xor    %edx,%edx
jmp    1769 <calcSCA+0x609>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %esi,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%rsi,1),%xmm5
mulsd  (%rdi,%rsi,1),%xmm5
addsd  %xmm4,%xmm5
movsd  (%r14,%rsi,1),%xmm4
mulsd  (%rcx,%rsi,1),%xmm4
addsd  %xmm5,%xmm4
add    $0x2,%rdx
add    %r11,%rsi
cmp    %rdx,%r10
jne    1740 <calcSCA+0x5e0>
testb  $0x1,0x18(%rsp)
je     16a0 <calcSCA+0x540>
imul   %r12,%rdx
lea    (%rdx,%r9,1),%rsi
movsd  0x0(%rbp,%rsi,8),%xmm5
add    %rax,%rdx
mulsd  0x0(%rbp,%rdx,8),%xmm5
addsd  %xmm5,%xmm4
jmp    16a0 <calcSCA+0x540>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r13,%rax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.calcSCA.reslist = [20 x i8] c"ACDEFGHIKLMNPQRSTVWY"
@__const.calcSCA.q = [20 x double] [double 0x3FB2B020C49BA5E3, double 2.500000e-02, double 5.000000e-02, double 6.100000e-02, double 4.200000e-02, double 0x3FB26E978D4FDF3B, double 2.300000e-02, double 5.300000e-02, double 6.400000e-02, double 0x3FB6C8B439581062, double 2.300000e-02, double 4.300000e-02, double 5.200000e-02, double 4.000000e-02, double 5.200000e-02, double 0x3FB2B020C49BA5E3, double 5.600000e-02, double 6.300000e-02, double 1.300000e-02, double 3.300000e-02]
define double* @calcSCA(i8* %0, i32 %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca [20 x i8]
%13 = alloca [20 x double]
%14 = alloca i32
%15 = alloca double*
%16 = alloca double*
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double*
%21 = alloca double*
%22 = alloca double
store i8* %0, i8** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%23 = bitcast [20 x i8]* %12 to i8*
%24 = bitcast [20 x double]* %13 to i8*
store i32 20, i32* %14
%25 = load i32, i32* %6
%26 = load i32, i32* %14
%27 = mul nsw i32 %25, %26
%28 = sext i32 %27 to i64
%29 = mul i64 %28, 8
%30 = trunc i64 %29 to i32
%31 = call double* @malloc(i32 %30)
store double* %31, double** %15
%32 = load i32, i32* %6
%33 = load i32, i32* %6
%34 = mul nsw i32 %32, %33
%35 = sext i32 %34 to i64
%36 = mul i64 %35, 8
%37 = trunc i64 %36 to i32
%38 = call double* @malloc(i32 %37)
store double* %38, double** %16
store i32 0, i32* %7
br label %39
39: ; preds = %61, %3
%40 = load i32, i32* %7
%41 = load i32, i32* %6
%42 = icmp slt i32 %40, %41
br i1 %42, label %43, label %64
43: ; preds = %39
store i32 0, i32* %8
br label %44
44: ; preds = %57, %43
%45 = load i32, i32* %8
%46 = load i32, i32* %14
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %60
48: ; preds = %44
%49 = load double*, double** %15
%50 = load i32, i32* %7
%51 = load i32, i32* %14
%52 = mul nsw i32 %50, %51
%53 = load i32, i32* %8
%54 = add nsw i32 %52, %53
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %49, i64 %55
store double 0.000000e+00, double* %56
br label %57
57: ; preds = %48
%58 = load i32, i32* %8
%59 = add nsw i32 %58, 1
store i32 %59, i32* %8
br label %44
60: ; preds = %44
br label %61
61: ; preds = %60
%62 = load i32, i32* %7
%63 = add nsw i32 %62, 1
store i32 %63, i32* %7
br label %39
64: ; preds = %39
store i32 0, i32* %7
br label %65
65: ; preds = %324, %64
%66 = load i32, i32* %7
%67 = load i32, i32* %6
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %327
69: ; preds = %65
store double 0.000000e+00, double* %17
store i32 0, i32* %8
br label %70
70: ; preds = %114, %69
%71 = load i32, i32* %8
%72 = load i32, i32* %5
%73 = icmp slt i32 %71, %72
br i1 %73, label %74, label %117
74: ; preds = %70
store i32 0, i32* %9
br label %75
75: ; preds = %110, %74
%76 = load i32, i32* %9
%77 = load i32, i32* %14
%78 = icmp slt i32 %76, %77
br i1 %78, label %79, label %113
79: ; preds = %75
%80 = load i8*, i8** %4
%81 = load i32, i32* %8
%82 = load i32, i32* %6
%83 = mul nsw i32 %81, %82
%84 = load i32, i32* %7
%85 = add nsw i32 %83, %84
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i8, i8* %80, i64 %86
%88 = load i8, i8* %87
%89 = sext i8 %88 to i32
%90 = load i32, i32* %9
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [20 x i8], [20 x i8]* %12, i64 0, i64 %91
%93 = load i8, i8* %92
%94 = sext i8 %93 to i32
%95 = icmp eq i32 %89, %94
br i1 %95, label %96, label %109
96: ; preds = %79
%97 = load double*, double** %15
%98 = load i32, i32* %7
%99 = load i32, i32* %14
%100 = mul nsw i32 %98, %99
%101 = load i32, i32* %9
%102 = add nsw i32 %100, %101
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds double, double* %97, i64 %103
%105 = load double, double* %104
%106 = fadd double %105, 1.000000e+00
store double %106, double* %104
%107 = load double, double* %17
%108 = fadd double %107, 1.000000e+00
store double %108, double* %17
br label %113
109: ; preds = %79
br label %110
110: ; preds = %109
%111 = load i32, i32* %9
%112 = add nsw i32 %111, 1
store i32 %112, i32* %9
br label %75
113: ; preds = %96, %75
br label %114
114: ; preds = %113
%115 = load i32, i32* %8
%116 = add nsw i32 %115, 1
store i32 %116, i32* %8
br label %70
117: ; preds = %70
store double 0.000000e+00, double* %18
store double 0.000000e+00, double* %19
store double 0.000000e+00, double* %18
store i32 0, i32* %9
br label %118
118: ; preds = %268, %117
%119 = load i32, i32* %9
%120 = load i32, i32* %14
%121 = icmp slt i32 %119, %120
br i1 %121, label %122, label %271
122: ; preds = %118
%123 = load double*, double** %15
%124 = load i32, i32* %7
%125 = load i32, i32* %14
%126 = mul nsw i32 %124, %125
%127 = load i32, i32* %9
%128 = add nsw i32 %126, %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %123, i64 %129
%131 = load double, double* %130
%132 = fmul double %131, 1.000000e+00
%133 = load i32, i32* %5
%134 = sitofp i32 %133 to double
%135 = fdiv double %132, %134
%136 = load double*, double** %15
%137 = load i32, i32* %7
%138 = load i32, i32* %14
%139 = mul nsw i32 %137, %138
%140 = load i32, i32* %9
%141 = add nsw i32 %139, %140
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds double, double* %136, i64 %142
store double %135, double* %143
%144 = load double*, double** %15
%145 = load i32, i32* %7
%146 = load i32, i32* %14
%147 = mul nsw i32 %145, %146
%148 = load i32, i32* %9
%149 = add nsw i32 %147, %148
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %144, i64 %150
%152 = load double, double* %151
%153 = fcmp oge double %152, 0x3FEFFFFFFFF24190
br i1 %153, label %165, label %154
154: ; preds = %122
%155 = load double*, double** %15
%156 = load i32, i32* %7
%157 = load i32, i32* %14
%158 = mul nsw i32 %156, %157
%159 = load i32, i32* %9
%160 = add nsw i32 %158, %159
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double, double* %155, i64 %161
%163 = load double, double* %162
%164 = fcmp ole double %163, 1.000000e-10
br i1 %164, label %165, label %174
165: ; preds = %154, %122
%166 = load double*, double** %15
%167 = load i32, i32* %7
%168 = load i32, i32* %14
%169 = mul nsw i32 %167, %168
%170 = load i32, i32* %9
%171 = add nsw i32 %169, %170
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double, double* %166, i64 %172
store double 0.000000e+00, double* %173
store double 0.000000e+00, double* %19
br label %263
174: ; preds = %154
%175 = load i32, i32* %9
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds [20 x double], [20 x double]* %13, i64 0, i64 %176
%178 = load double, double* %177
%179 = fsub double 1.000000e+00, %178
%180 = load i32, i32* %9
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [20 x double], [20 x double]* %13, i64 0, i64 %181
%183 = load double, double* %182
%184 = fdiv double %179, %183
%185 = load double*, double** %15
%186 = load i32, i32* %7
%187 = load i32, i32* %14
%188 = mul nsw i32 %186, %187
%189 = load i32, i32* %9
%190 = add nsw i32 %188, %189
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds double, double* %185, i64 %191
%193 = load double, double* %192
%194 = fmul double %184, %193
%195 = load double*, double** %15
%196 = load i32, i32* %7
%197 = load i32, i32* %14
%198 = mul nsw i32 %196, %197
%199 = load i32, i32* %9
%200 = add nsw i32 %198, %199
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds double, double* %195, i64 %201
%203 = load double, double* %202
%204 = fsub double 1.000000e+00, %203
%205 = fdiv double %194, %204
%206 = fptosi double %205 to i32
%207 = call i32 @log(i32 %206)
%208 = call double @fabs(i32 %207)
%209 = load double*, double** %15
%210 = load i32, i32* %7
%211 = load i32, i32* %14
%212 = mul nsw i32 %210, %211
%213 = load i32, i32* %9
%214 = add nsw i32 %212, %213
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds double, double* %209, i64 %215
%217 = load double, double* %216
%218 = fmul double %208, %217
store double %218, double* %19
%219 = load double, double* %19
%220 = load i32, i32* %9
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [20 x double], [20 x double]* %13, i64 0, i64 %221
%223 = load double, double* %222
%224 = fsub double 1.000000e+00, %223
%225 = load i32, i32* %9
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds [20 x double], [20 x double]* %13, i64 0, i64 %226
%228 = load double, double* %227
%229 = fdiv double %224, %228
%230 = load double*, double** %15
%231 = load i32, i32* %7
%232 = load i32, i32* %14
%233 = mul nsw i32 %231, %232
%234 = load i32, i32* %9
%235 = add nsw i32 %233, %234
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds double, double* %230, i64 %236
%238 = load double, double* %237
%239 = fmul double %229, %238
%240 = load double*, double** %15
%241 = load i32, i32* %7
%242 = load i32, i32* %14
%243 = mul nsw i32 %241, %242
%244 = load i32, i32* %9
%245 = add nsw i32 %243, %244
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double, double* %240, i64 %246
%248 = load double, double* %247
%249 = fsub double 1.000000e+00, %248
%250 = fdiv double %239, %249
%251 = fptosi double %250 to i32
%252 = call i32 @log(i32 %251)
%253 = call double @fabs(i32 %252)
%254 = fmul double %219, %253
%255 = load double*, double** %15
%256 = load i32, i32* %7
%257 = load i32, i32* %14
%258 = mul nsw i32 %256, %257
%259 = load i32, i32* %9
%260 = add nsw i32 %258, %259
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double, double* %255, i64 %261
store double %254, double* %262
br label %263
263: ; preds = %174, %165
%264 = load double, double* %18
%265 = load double, double* %19
%266 = load double, double* %19
%267 = call double @llvm.fmuladd.f64(double %265, double %266, double %264)
store double %267, double* %18
br label %268
268: ; preds = %263
%269 = load i32, i32* %9
%270 = add nsw i32 %269, 1
store i32 %270, i32* %9
br label %118
271: ; preds = %118
%272 = load double, double* %18
%273 = call double @sqrt(double %272)
store double %273, double* %18
%274 = load double, double* %18
%275 = fcmp olt double %274, 1.000000e-10
br i1 %275, label %276, label %294
276: ; preds = %271
store i32 0, i32* %9
br label %277
277: ; preds = %290, %276
%278 = load i32, i32* %9
%279 = load i32, i32* %14
%280 = icmp slt i32 %278, %279
br i1 %280, label %281, label %293
281: ; preds = %277
%282 = load double*, double** %15
%283 = load i32, i32* %7
%284 = load i32, i32* %14
%285 = mul nsw i32 %283, %284
%286 = load i32, i32* %9
%287 = add nsw i32 %285, %286
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds double, double* %282, i64 %288
store double 0.000000e+00, double* %289
br label %290
290: ; preds = %281
%291 = load i32, i32* %9
%292 = add nsw i32 %291, 1
store i32 %292, i32* %9
br label %277
293: ; preds = %277
br label %323
294: ; preds = %271
store i32 0, i32* %9
br label %295
295: ; preds = %319, %294
%296 = load i32, i32* %9
%297 = load i32, i32* %14
%298 = icmp slt i32 %296, %297
br i1 %298, label %299, label %322
299: ; preds = %295
%300 = load double*, double** %15
%301 = load i32, i32* %7
%302 = load i32, i32* %14
%303 = mul nsw i32 %301, %302
%304 = load i32, i32* %9
%305 = add nsw i32 %303, %304
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds double, double* %300, i64 %306
%308 = load double, double* %307
%309 = load double, double* %18
%310 = fdiv double %308, %309
%311 = load double*, double** %15
%312 = load i32, i32* %7
%313 = load i32, i32* %14
%314 = mul nsw i32 %312, %313
%315 = load i32, i32* %9
%316 = add nsw i32 %314, %315
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds double, double* %311, i64 %317
store double %310, double* %318
br label %319
319: ; preds = %299
%320 = load i32, i32* %9
%321 = add nsw i32 %320, 1
store i32 %321, i32* %9
br label %295
322: ; preds = %295
br label %323
323: ; preds = %322, %293
br label %324
324: ; preds = %323
%325 = load i32, i32* %7
%326 = add nsw i32 %325, 1
store i32 %326, i32* %7
br label %65
327: ; preds = %65
%328 = load i32, i32* %5
%329 = load i32, i32* %6
%330 = mul nsw i32 %328, %329
%331 = sext i32 %330 to i64
%332 = mul i64 %331, 8
%333 = trunc i64 %332 to i32
%334 = call double* @malloc(i32 %333)
store double* %334, double** %20
%335 = load i32, i32* %6
%336 = sext i32 %335 to i64
%337 = mul i64 %336, 8
%338 = trunc i64 %337 to i32
%339 = call double* @malloc(i32 %338)
store double* %339, double** %21
store i32 0, i32* %8
br label %340
340: ; preds = %349, %327
%341 = load i32, i32* %8
%342 = load i32, i32* %6
%343 = icmp slt i32 %341, %342
br i1 %343, label %344, label %352
344: ; preds = %340
%345 = load double*, double** %21
%346 = load i32, i32* %8
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds double, double* %345, i64 %347
store double 0.000000e+00, double* %348
br label %349
349: ; preds = %344
%350 = load i32, i32* %8
%351 = add nsw i32 %350, 1
store i32 %351, i32* %8
br label %340
352: ; preds = %340
store i32 0, i32* %8
br label %353
353: ; preds = %364, %352
%354 = load i32, i32* %8
%355 = load i32, i32* %5
%356 = load i32, i32* %6
%357 = mul nsw i32 %355, %356
%358 = icmp slt i32 %354, %357
br i1 %358, label %359, label %367
359: ; preds = %353
%360 = load double*, double** %20
%361 = load i32, i32* %8
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds double, double* %360, i64 %362
store double 0.000000e+00, double* %363
br label %364
364: ; preds = %359
%365 = load i32, i32* %8
%366 = add nsw i32 %365, 1
store i32 %366, i32* %8
br label %353
367: ; preds = %353
store i32 0, i32* %7
br label %368
368: ; preds = %441, %367
%369 = load i32, i32* %7
%370 = load i32, i32* %5
%371 = icmp slt i32 %369, %370
br i1 %371, label %372, label %444
372: ; preds = %368
store i32 0, i32* %8
br label %373
373: ; preds = %437, %372
%374 = load i32, i32* %8
%375 = load i32, i32* %6
%376 = icmp slt i32 %374, %375
br i1 %376, label %377, label %440
377: ; preds = %373
store i32 0, i32* %9
br label %378
378: ; preds = %433, %377
%379 = load i32, i32* %9
%380 = load i32, i32* %14
%381 = icmp slt i32 %379, %380
br i1 %381, label %382, label %436
382: ; preds = %378
%383 = load i32, i32* %9
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds [20 x i8], [20 x i8]* %12, i64 0, i64 %384
%386 = load i8, i8* %385
%387 = sext i8 %386 to i32
%388 = load i8*, i8** %4
%389 = load i32, i32* %7
%390 = load i32, i32* %6
%391 = mul nsw i32 %389, %390
%392 = load i32, i32* %8
%393 = add nsw i32 %391, %392
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds i8, i8* %388, i64 %394
%396 = load i8, i8* %395
%397 = sext i8 %396 to i32
%398 = icmp eq i32 %387, %397
br i1 %398, label %399, label %432
399: ; preds = %382
%400 = load double*, double** %15
%401 = load i32, i32* %8
%402 = load i32, i32* %14
%403 = mul nsw i32 %401, %402
%404 = load i32, i32* %9
%405 = add nsw i32 %403, %404
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds double, double* %400, i64 %406
%408 = load double, double* %407
%409 = load double*, double** %20
%410 = load i32, i32* %7
%411 = load i32, i32* %6
%412 = mul nsw i32 %410, %411
%413 = load i32, i32* %8
%414 = add nsw i32 %412, %413
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds double, double* %409, i64 %415
store double %408, double* %416
%417 = load double*, double** %20
%418 = load i32, i32* %7
%419 = load i32, i32* %6
%420 = mul nsw i32 %418, %419
%421 = load i32, i32* %8
%422 = add nsw i32 %420, %421
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds double, double* %417, i64 %423
%425 = load double, double* %424
%426 = load double*, double** %21
%427 = load i32, i32* %8
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds double, double* %426, i64 %428
%430 = load double, double* %429
%431 = fadd double %430, %425
store double %431, double* %429
br label %432
432: ; preds = %399, %382
br label %433
433: ; preds = %432
%434 = load i32, i32* %9
%435 = add nsw i32 %434, 1
store i32 %435, i32* %9
br label %378
436: ; preds = %378
br label %437
437: ; preds = %436
%438 = load i32, i32* %8
%439 = add nsw i32 %438, 1
store i32 %439, i32* %8
br label %373
440: ; preds = %373
br label %441
441: ; preds = %440
%442 = load i32, i32* %7
%443 = add nsw i32 %442, 1
store i32 %443, i32* %7
br label %368
444: ; preds = %368
store i32 0, i32* %7
br label %445
445: ; preds = %535, %444
%446 = load i32, i32* %7
%447 = load i32, i32* %6
%448 = icmp slt i32 %446, %447
br i1 %448, label %449, label %538
449: ; preds = %445
%450 = load i32, i32* %7
store i32 %450, i32* %8
br label %451
451: ; preds = %531, %449
%452 = load i32, i32* %8
%453 = load i32, i32* %6
%454 = icmp slt i32 %452, %453
br i1 %454, label %455, label %534
455: ; preds = %451
store double 0.000000e+00, double* %22
store i32 0, i32* %9
br label %456
456: ; preds = %481, %455
%457 = load i32, i32* %9
%458 = load i32, i32* %5
%459 = icmp slt i32 %457, %458
br i1 %459, label %460, label %484
460: ; preds = %456
%461 = load double*, double** %20
%462 = load i32, i32* %9
%463 = load i32, i32* %6
%464 = mul nsw i32 %462, %463
%465 = load i32, i32* %7
%466 = add nsw i32 %464, %465
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds double, double* %461, i64 %467
%469 = load double, double* %468
%470 = load double*, double** %20
%471 = load i32, i32* %9
%472 = load i32, i32* %6
%473 = mul nsw i32 %471, %472
%474 = load i32, i32* %8
%475 = add nsw i32 %473, %474
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds double, double* %470, i64 %476
%478 = load double, double* %477
%479 = load double, double* %22
%480 = call double @llvm.fmuladd.f64(double %469, double %478, double %479)
store double %480, double* %22
br label %481
481: ; preds = %460
%482 = load i32, i32* %9
%483 = add nsw i32 %482, 1
store i32 %483, i32* %9
br label %456
484: ; preds = %456
%485 = load double, double* %22
%486 = load i32, i32* %5
%487 = sitofp i32 %486 to double
%488 = fdiv double %485, %487
%489 = load double*, double** %21
%490 = load i32, i32* %7
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds double, double* %489, i64 %491
%493 = load double, double* %492
%494 = load double*, double** %21
%495 = load i32, i32* %8
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds double, double* %494, i64 %496
%498 = load double, double* %497
%499 = fmul double %493, %498
%500 = load i32, i32* %5
%501 = sitofp i32 %500 to double
%502 = fdiv double %499, %501
%503 = load i32, i32* %5
%504 = sitofp i32 %503 to double
%505 = fdiv double %502, %504
%506 = fsub double %488, %505
store double %506, double* %22
%507 = load double, double* %22
%508 = fcmp olt double %507, 0.000000e+00
br i1 %508, label %509, label %512
509: ; preds = %484
%510 = load double, double* %22
%511 = fneg double %510
store double %511, double* %22
br label %512
512: ; preds = %509, %484
%513 = load double, double* %22
%514 = load double*, double** %16
%515 = load i32, i32* %7
%516 = load i32, i32* %6
%517 = mul nsw i32 %515, %516
%518 = load i32, i32* %8
%519 = add nsw i32 %517, %518
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds double, double* %514, i64 %520
store double %513, double* %521
%522 = load double, double* %22
%523 = load double*, double** %16
%524 = load i32, i32* %8
%525 = load i32, i32* %6
%526 = mul nsw i32 %524, %525
%527 = load i32, i32* %7
%528 = add nsw i32 %526, %527
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds double, double* %523, i64 %529
store double %522, double* %530
br label %531
531: ; preds = %512
%532 = load i32, i32* %8
%533 = add nsw i32 %532, 1
store i32 %533, i32* %8
br label %451
534: ; preds = %451
br label %535
535: ; preds = %534
%536 = load i32, i32* %7
%537 = add nsw i32 %536, 1
store i32 %537, i32* %7
br label %445
538: ; preds = %445
%539 = load double*, double** %15
%540 = call i32 @free(double* %539)
%541 = load double*, double** %20
%542 = call i32 @free(double* %541)
%543 = load double*, double** %21
%544 = call i32 @free(double* %543)
%545 = load double*, double** %16
ret double* %545
}

LLVM IR (-O2):
@__const.calcSCA.reslist = [20 x i8] c"ACDEFGHIKLMNPQRSTVWY"
@__const.calcSCA.q = [20 x double] [double 0x3FB2B020C49BA5E3, double 2.500000e-02, double 5.000000e-02, double 6.100000e-02, double 4.200000e-02, double 0x3FB26E978D4FDF3B, double 2.300000e-02, double 5.300000e-02, double 6.400000e-02, double 0x3FB6C8B439581062, double 2.300000e-02, double 4.300000e-02, double 5.200000e-02, double 4.000000e-02, double 5.200000e-02, double 0x3FB2B020C49BA5E3, double 5.600000e-02, double 6.300000e-02, double 1.300000e-02, double 3.300000e-02]
@switch.table.calcSCA = [25 x i64] [i64 0, i64 0, i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 0, i64 8, i64 9, i64 10, i64 11, i64 0, i64 12, i64 13, i64 14, i64 15, i64 16, i64 0, i64 17, i64 18, i64 0, i64 19]
define noalias double* @calcSCA(i8* nocapture %0, i32 %1, i32 %2) {
%4 = mul i32 %2, 160
%5 = tail call double* @malloc(i32 %4)
%6 = shl i32 %2, 3
%7 = mul i32 %6, %2
%8 = tail call double* @malloc(i32 %7)
%9 = icmp sgt i32 %2, 0
br i1 %9, label %10, label %153
10: ; preds = %3
%11 = bitcast double* %5 to i8*
%12 = zext i32 %2 to i64
%13 = mul nuw nsw i64 %12, 160
%14 = icmp sgt i32 %1, 0
%15 = sitofp i32 %1 to double
%16 = zext i32 %2 to i64
%17 = zext i32 %2 to i64
%18 = zext i32 %1 to i64
br label %19
19: ; preds = %10, %150
%20 = phi i64 [ 0, %10 ], [ %151, %150 ]
%21 = mul i64 %20, 20
%22 = and i64 %21, 4294967292
%23 = getelementptr double, double* %5, i64 %22
%24 = bitcast double* %23 to i8*
%25 = mul nuw nsw i64 %20, 20
br i1 %14, label %28, label %26
26: ; preds = %50, %19
%27 = and i64 %25, 4294967292
br label %53
28: ; preds = %19, %50
%29 = phi i64 [ %51, %50 ], [ 0, %19 ]
%30 = mul nsw i64 %29, %16
%31 = add nuw nsw i64 %30, %20
%32 = getelementptr inbounds i8, i8* %0, i64 %31
%33 = load i8, i8* %32
%34 = add i8 %33, -65
%35 = icmp ult i8 %34, 25
br i1 %35, label %36, label %50
36: ; preds = %28
%37 = zext i8 %34 to i32
%38 = lshr i32 24100349, %37
%39 = and i32 %38, 1
%40 = icmp eq i32 %39, 0
br i1 %40, label %50, label %41
41: ; preds = %36
%42 = sext i8 %34 to i64
%43 = getelementptr inbounds [25 x i64], [25 x i64]* @switch.table.calcSCA, i64 0, i64 %42
%44 = load i64, i64* %43
%45 = add nuw i64 %44, %25
%46 = and i64 %45, 4294967295
%47 = getelementptr inbounds double, double* %5, i64 %46
%48 = load double, double* %47
%49 = fadd double %48, 1.000000e+00
store double %49, double* %47
br label %50
50: ; preds = %36, %28, %41
%51 = add nuw nsw i64 %29, 1
%52 = icmp eq i64 %51, %18
br i1 %52, label %26, label %28
53: ; preds = %26, %78
%54 = phi i64 [ 0, %26 ], [ %82, %78 ]
%55 = phi double [ 0.000000e+00, %26 ], [ %81, %78 ]
%56 = add nuw nsw i64 %54, %27
%57 = getelementptr inbounds double, double* %5, i64 %56
%58 = load double, double* %57
%59 = fdiv double %58, %15
%60 = fcmp ult double %59, 0x3FEFFFFFFFF24190
%61 = fcmp ugt double %59, 1.000000e-10
%62 = and i1 %60, %61
br i1 %62, label %63, label %78
63: ; preds = %53
%64 = getelementptr inbounds [20 x double], [20 x double]* @__const.calcSCA.q, i64 0, i64 %54
%65 = load double, double* %64
%66 = fsub double 1.000000e+00, %65
%67 = fdiv double %66, %65
%68 = fmul double %59, %67
%69 = fsub double 1.000000e+00, %59
%70 = fdiv double %68, %69
%71 = fptosi double %70 to i32
%72 = tail call i32 @log(i32 %71)
%73 = tail call double @fabs(i32 %72)
%74 = fmul double %59, %73
%75 = tail call i32 @log(i32 %71)
%76 = tail call double @fabs(i32 %75)
%77 = fmul double %74, %76
br label %78
78: ; preds = %53, %63
%79 = phi double [ %77, %63 ], [ 0.000000e+00, %53 ]
%80 = phi double [ %74, %63 ], [ 0.000000e+00, %53 ]
store double %79, double* %57
%81 = tail call double @llvm.fmuladd.f64(double %80, double %80, double %55)
%82 = add nuw nsw i64 %54, 1
%83 = icmp eq i64 %82, 20
br i1 %83, label %84, label %53
84: ; preds = %78
%85 = tail call double @sqrt(double %81)
%86 = fcmp olt double %85, 1.000000e-10
br i1 %86, label %149, label %87
87: ; preds = %84
%88 = insertelement <2 x double> poison, double %85, i64 0
%89 = shufflevector <2 x double> %88, <2 x double> poison, <2 x i32> zeroinitializer
%90 = getelementptr inbounds double, double* %5, i64 %27
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = fdiv <2 x double> %92, %89
%94 = bitcast double* %90 to <2 x double>*
store <2 x double> %93, <2 x double>* %94
%95 = or i64 %27, 2
%96 = getelementptr inbounds double, double* %5, i64 %95
%97 = bitcast double* %96 to <2 x double>*
%98 = load <2 x double>, <2 x double>* %97
%99 = fdiv <2 x double> %98, %89
%100 = bitcast double* %96 to <2 x double>*
store <2 x double> %99, <2 x double>* %100
%101 = add nuw nsw i64 %27, 4
%102 = getelementptr inbounds double, double* %5, i64 %101
%103 = bitcast double* %102 to <2 x double>*
%104 = load <2 x double>, <2 x double>* %103
%105 = fdiv <2 x double> %104, %89
%106 = bitcast double* %102 to <2 x double>*
store <2 x double> %105, <2 x double>* %106
%107 = add nuw nsw i64 %27, 6
%108 = getelementptr inbounds double, double* %5, i64 %107
%109 = bitcast double* %108 to <2 x double>*
%110 = load <2 x double>, <2 x double>* %109
%111 = fdiv <2 x double> %110, %89
%112 = bitcast double* %108 to <2 x double>*
store <2 x double> %111, <2 x double>* %112
%113 = add nuw nsw i64 %27, 8
%114 = getelementptr inbounds double, double* %5, i64 %113
%115 = bitcast double* %114 to <2 x double>*
%116 = load <2 x double>, <2 x double>* %115
%117 = fdiv <2 x double> %116, %89
%118 = bitcast double* %114 to <2 x double>*
store <2 x double> %117, <2 x double>* %118
%119 = add nuw nsw i64 %27, 10
%120 = getelementptr inbounds double, double* %5, i64 %119
%121 = bitcast double* %120 to <2 x double>*
%122 = load <2 x double>, <2 x double>* %121
%123 = fdiv <2 x double> %122, %89
%124 = bitcast double* %120 to <2 x double>*
store <2 x double> %123, <2 x double>* %124
%125 = add nuw nsw i64 %27, 12
%126 = getelementptr inbounds double, double* %5, i64 %125
%127 = bitcast double* %126 to <2 x double>*
%128 = load <2 x double>, <2 x double>* %127
%129 = fdiv <2 x double> %128, %89
%130 = bitcast double* %126 to <2 x double>*
store <2 x double> %129, <2 x double>* %130
%131 = add nuw nsw i64 %27, 14
%132 = getelementptr inbounds double, double* %5, i64 %131
%133 = bitcast double* %132 to <2 x double>*
%134 = load <2 x double>, <2 x double>* %133
%135 = fdiv <2 x double> %134, %89
%136 = bitcast double* %132 to <2 x double>*
store <2 x double> %135, <2 x double>* %136
%137 = add nuw nsw i64 %27, 16
%138 = getelementptr inbounds double, double* %5, i64 %137
%139 = bitcast double* %138 to <2 x double>*
%140 = load <2 x double>, <2 x double>* %139
%141 = fdiv <2 x double> %140, %89
%142 = bitcast double* %138 to <2 x double>*
store <2 x double> %141, <2 x double>* %142
%143 = add nuw nsw i64 %27, 18
%144 = getelementptr inbounds double, double* %5, i64 %143
%145 = bitcast double* %144 to <2 x double>*
%146 = load <2 x double>, <2 x double>* %145
%147 = fdiv <2 x double> %146, %89
%148 = bitcast double* %144 to <2 x double>*
store <2 x double> %147, <2 x double>* %148
br label %150
149: ; preds = %84
br label %150
150: ; preds = %87, %149
%151 = add nuw nsw i64 %20, 1
%152 = icmp eq i64 %151, %17
br i1 %152, label %153, label %19
153: ; preds = %150, %3
%154 = mul nsw i32 %2, %1
%155 = shl i32 %154, 3
%156 = tail call double* @malloc(i32 %155)
%157 = bitcast double* %156 to i8*
%158 = tail call double* @malloc(i32 %6)
br i1 %9, label %159, label %163
159: ; preds = %153
%160 = bitcast double* %158 to i8*
%161 = zext i32 %2 to i64
%162 = shl nuw nsw i64 %161, 3
br label %163
163: ; preds = %159, %153
%164 = icmp sgt i32 %154, 0
br i1 %164, label %165, label %168
165: ; preds = %163
%166 = zext i32 %154 to i64
%167 = shl nuw nsw i64 %166, 3
br label %168
168: ; preds = %165, %163
%169 = icmp sgt i32 %1, 0
br i1 %169, label %170, label %178
170: ; preds = %168
%171 = sext i32 %2 to i64
%172 = zext i32 %1 to i64
%173 = zext i32 %2 to i64
br label %174
174: ; preds = %170, %227
%175 = phi i64 [ 0, %170 ], [ %228, %227 ]
br i1 %9, label %176, label %227
176: ; preds = %174
%177 = mul nsw i64 %175, %171
br label %190
178: ; preds = %227, %168
br i1 %9, label %179, label %300
179: ; preds = %178
%180 = sitofp i32 %1 to double
%181 = zext i32 %2 to i64
%182 = zext i32 %2 to i64
%183 = zext i32 %1 to i64
%184 = insertelement <2 x double> poison, double %180, i64 0
%185 = shufflevector <2 x double> %184, <2 x double> poison, <2 x i32> zeroinitializer
%186 = and i64 %183, 1
%187 = icmp eq i32 %1, 1
%188 = and i64 %183, 4294967294
%189 = icmp eq i64 %186, 0
br label %230
190: ; preds = %176, %224
%191 = phi i64 [ 0, %176 ], [ %225, %224 ]
%192 = add nsw i64 %191, %177
%193 = getelementptr inbounds i8, i8* %0, i64 %192
%194 = load i8, i8* %193
%195 = getelementptr inbounds double, double* %156, i64 %192
%196 = getelementptr inbounds double, double* %158, i64 %191
%197 = mul i64 %191, 20
%198 = and i64 %197, 4294967292
br label %199
199: ; preds = %221, %190
%200 = phi i64 [ 0, %190 ], [ %222, %221 ]
%201 = getelementptr inbounds [20 x i8], [20 x i8]* @__const.calcSCA.reslist, i64 0, i64 %200
%202 = load i8, i8* %201
%203 = icmp eq i8 %202, %194
br i1 %203, label %204, label %210
204: ; preds = %199
%205 = add nuw nsw i64 %200, %198
%206 = getelementptr inbounds double, double* %5, i64 %205
%207 = load double, double* %206
store double %207, double* %195
%208 = load double, double* %196
%209 = fadd double %207, %208
store double %209, double* %196
br label %210
210: ; preds = %199, %204
%211 = or i64 %200, 1
%212 = getelementptr inbounds [20 x i8], [20 x i8]* @__const.calcSCA.reslist, i64 0, i64 %211
%213 = load i8, i8* %212
%214 = icmp eq i8 %213, %194
br i1 %214, label %215, label %221
215: ; preds = %210
%216 = add nuw nsw i64 %211, %198
%217 = getelementptr inbounds double, double* %5, i64 %216
%218 = load double, double* %217
store double %218, double* %195
%219 = load double, double* %196
%220 = fadd double %218, %219
store double %220, double* %196
br label %221
221: ; preds = %215, %210
%222 = add nuw nsw i64 %200, 2
%223 = icmp eq i64 %222, 20
br i1 %223, label %224, label %199
224: ; preds = %221
%225 = add nuw nsw i64 %191, 1
%226 = icmp eq i64 %225, %173
br i1 %226, label %227, label %190
227: ; preds = %224, %174
%228 = add nuw nsw i64 %175, 1
%229 = icmp eq i64 %228, %172
br i1 %229, label %178, label %174
230: ; preds = %297, %179
%231 = phi i64 [ 0, %179 ], [ %298, %297 ]
%232 = getelementptr inbounds double, double* %158, i64 %231
%233 = load double, double* %232
%234 = mul nsw i64 %231, %181
br label %235
235: ; preds = %230, %275
%236 = phi i64 [ %231, %230 ], [ %295, %275 ]
br i1 %169, label %237, label %275
237: ; preds = %235
br i1 %187, label %262, label %238
238: ; preds = %237, %238
%239 = phi i64 [ %259, %238 ], [ 0, %237 ]
%240 = phi double [ %258, %238 ], [ 0.000000e+00, %237 ]
%241 = phi i64 [ %260, %238 ], [ 0, %237 ]
%242 = mul nsw i64 %239, %181
%243 = add nuw nsw i64 %242, %231
%244 = getelementptr inbounds double, double* %156, i64 %243
%245 = load double, double* %244
%246 = add nuw nsw i64 %242, %236
%247 = getelementptr inbounds double, double* %156, i64 %246
%248 = load double, double* %247
%249 = tail call double @llvm.fmuladd.f64(double %245, double %248, double %240)
%250 = or i64 %239, 1
%251 = mul nsw i64 %250, %181
%252 = add nuw nsw i64 %251, %231
%253 = getelementptr inbounds double, double* %156, i64 %252
%254 = load double, double* %253
%255 = add nuw nsw i64 %251, %236
%256 = getelementptr inbounds double, double* %156, i64 %255
%257 = load double, double* %256
%258 = tail call double @llvm.fmuladd.f64(double %254, double %257, double %249)
%259 = add nuw nsw i64 %239, 2
%260 = add i64 %241, 2
%261 = icmp eq i64 %260, %188
br i1 %261, label %262, label %238
262: ; preds = %238, %237
%263 = phi double [ undef, %237 ], [ %258, %238 ]
%264 = phi i64 [ 0, %237 ], [ %259, %238 ]
%265 = phi double [ 0.000000e+00, %237 ], [ %258, %238 ]
br i1 %189, label %275, label %266
266: ; preds = %262
%267 = mul nsw i64 %264, %181
%268 = add nuw nsw i64 %267, %231
%269 = getelementptr inbounds double, double* %156, i64 %268
%270 = load double, double* %269
%271 = add nuw nsw i64 %267, %236
%272 = getelementptr inbounds double, double* %156, i64 %271
%273 = load double, double* %272
%274 = tail call double @llvm.fmuladd.f64(double %270, double %273, double %265)
br label %275
275: ; preds = %266, %262, %235
%276 = phi double [ 0.000000e+00, %235 ], [ %263, %262 ], [ %274, %266 ]
%277 = getelementptr inbounds double, double* %158, i64 %236
%278 = load double, double* %277
%279 = fmul double %233, %278
%280 = fdiv double %279, %180
%281 = insertelement <2 x double> poison, double %276, i64 0
%282 = insertelement <2 x double> %281, double %280, i64 1
%283 = fdiv <2 x double> %282, %185
%284 = shufflevector <2 x double> %283, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%285 = fsub <2 x double> %283, %284
%286 = extractelement <2 x double> %285, i64 0
%287 = fcmp olt double %286, 0.000000e+00
%288 = fneg double %286
%289 = select i1 %287, double %288, double %286
%290 = add nuw nsw i64 %236, %234
%291 = getelementptr inbounds double, double* %8, i64 %290
store double %289, double* %291
%292 = mul nsw i64 %236, %181
%293 = add nuw nsw i64 %292, %231
%294 = getelementptr inbounds double, double* %8, i64 %293
store double %289, double* %294
%295 = add nuw nsw i64 %236, 1
%296 = icmp eq i64 %295, %182
br i1 %296, label %297, label %235
297: ; preds = %275
%298 = add nuw nsw i64 %231, 1
%299 = icmp eq i64 %298, %182
br i1 %299, label %300, label %230
300: ; preds = %297, %178
%301 = tail call i32 @free(double* %5)
%302 = tail call i32 @free(double* %156)
%303 = tail call i32 @free(double* %158)
ret double* %8
}