double *calcMy(char m[], int n, int l) {
  int i, j, k, k1, k2, k3, k4;
  char reslist[] = {'A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L',
                    'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y'};
  int resnum = sizeof(reslist) / sizeof(char);
  double *simi;
  simi = malloc(n * n * sizeof(double));
  for (i = 0; i < n; i++) {
    simi[i * n + i] = 0.0;
    for (j = i + 1; j < n; j++) {
      double allcount = 0, same = 0;
      for (k = 0; k < l; k++) {
        if (m[i * l + k] != '-' || m[j * l + k] != '-') {
          allcount++;
          if (m[i * l + k] == m[j * l + k])
            same++;
        }
      }
      simi[i * n + j] = same / allcount;
      simi[j * n + i] = simi[i * n + j];
    }
  }
  int *edge, edgenow = 0;
  edge = malloc(5 * n * 2 * sizeof(int));
  for (i = 0; i < 5 * n * 2; i++) {
    edge[i] = -1;
  }
  for (i = 0; i < n; i++) {
    int has = 0, now = 0, maxn[5], max5 = -1;
    while (has < 5) {
      if (now != i) {
        maxn[has] = now;
        has++;
      }
      now++;
    }
    for (j = 0; j < 5; j++)
      if (max5 == -1 || simi[i * n + maxn[max5]] > simi[i * n + maxn[j]])
        max5 = j;
    for (j = now; j < n; j++) {
      if (simi[i * n + j] > simi[i * n + maxn[max5]]) {
        maxn[max5] = j;
        max5 = -1;
        for (k = 0; k < 5; k++)
          if (max5 == -1 || simi[i * n + maxn[max5]] > simi[i * n + maxn[k]])
            max5 = k;
      }
    }
    for (j = 0; j < 5; j++) {
      edge[edgenow * 2 + 0] = i;
      edge[edgenow * 2 + 1] = maxn[j];
      edgenow++;
    }
  }
  free(simi);
  double *my;
  int n1 = 0, n2 = 0;
  my = malloc(l * l * sizeof(double));
  for (i = 0; i < l * l; i++)
    my[i] = 0.0;
  for (i = 0; i < l; i++) {
    for (j = i + 1; j < l; j++) {
      double *prop, *pro1, *pro2, allnumber = 0, add = 0;
      prop = malloc(20 * 20 * 20 * 20 * sizeof(double));
      pro1 = malloc(20 * 20 * sizeof(double));
      pro2 = malloc(20 * 20 * sizeof(double));
      int count1 = 0, count2 = 0, count3 = 0, count4 = 0;
      for (k = 0; k < 160000; k++)
        prop[k] = 0.0;
      for (k = 0; k < 400; k++) {
        pro1[k] = 0;
        pro2[k] = 0;
      }
      for (k = 0; k < 5 * n; k++) {
        n1 = edge[k * 2];
        n2 = edge[k * 2 + 1];
        if (m[n1 * l + i] != '-' && m[n1 * l + j] != '-' &&
            m[n2 * l + i] != '-' && m[n2 * l + j] != '-') {
          count1 = 0;
          count2 = 0;
          count3 = 0;
          count4 = 0;
          for (k1 = 0; k1 < 20; k1++) {
            if (reslist[k1] == m[n1 * l + i]) {
              count1 = k1;
              break;
            }
          }
          for (k1 = 0; k1 < 20; k1++) {
            if (reslist[k1] == m[n2 * l + i]) {
              count2 = k1;
              break;
            }
          }
          for (k1 = 0; k1 < 20; k1++) {
            if (reslist[k1] == m[n1 * l + j]) {
              count3 = k1;
              break;
            }
          }
          for (k1 = 0; k1 < 20; k1++) {
            if (reslist[k1] == m[n2 * l + j]) {
              count4 = k1;
              break;
            }
          }
          prop[(count1 * 20 + count3) * 400 + (count2 * 20 + count4)] += 1;
          prop[(count2 * 20 + count4) * 400 + (count1 * 20 + count3)] += 1;
          pro1[count1 * 20 + count2] += 1;
          pro1[count2 * 20 + count1] += 1;
          pro2[count3 * 20 + count4] += 1;
          pro2[count4 * 20 + count3] += 1;
          allnumber += 2;
        }
      }
      if (allnumber != 0) {
        for (k = 0; k < 160000; k++)
          prop[k] = prop[k] / allnumber;
        for (k = 0; k < 400; k++) {
          pro1[k] = pro1[k] / allnumber;
          pro2[k] = pro2[k] / allnumber;
        }
      }
      allnumber = 0.0;
      for (k1 = 0; k1 < 20; k1++)
        for (k2 = 0; k2 < 20; k2++) {
          if (pro1[k1 * 20 + k2] == 0) {
            continue;
          } else {
            for (k3 = 0; k3 < 20; k3++)
              for (k4 = 0; k4 < 20; k4++) {
                if (pro2[k3 * 20 + k4] == 0 ||
                    prop[(k1 * 20 + k3) * 400 + (k2 * 20 + k4)] == 0) {
                  continue;
                } else {
                  allnumber += prop[(k1 * 20 + k3) * 400 + (k2 * 20 + k4)] *
                               log(prop[(k1 * 20 + k3) * 400 + (k2 * 20 + k4)] /
                                   pro1[k1 * 20 + k2] / pro2[k3 * 20 + k4]);
                }
              }
          }
        }
      my[i * l + j] = allnumber;
      my[j * l + i] = allnumber;
      free(prop);
      free(pro1);
      free(pro2);
    }
  }
  free(edge);
  return my;
}


x86 assembly (clang, -O0):
<calcMy>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    0xec4(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xec1(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0xebf(%rip),%eax
mov    %eax,-0x30(%rbp)
movl   $0x14,-0x44(%rbp)
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12fd <calcMy+0x1cd>
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ea <calcMy+0x1ba>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1290 <calcMy+0x160>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1222 <calcMy+0xf2>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
je     127d <calcMy+0x14d>
movsd  0xdde(%rip),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x18(%rbp),%edx
imul   -0x10(%rbp),%edx
add    -0x1c(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1278 <calcMy+0x148>
movsd  0xd9a(%rip),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    127d <calcMy+0x14d>
jmp    1282 <calcMy+0x152>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11da <calcMy+0xaa>
movsd  -0x60(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0xc(%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    11b7 <calcMy+0x87>
jmp    12ef <calcMy+0x1bf>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1189 <calcMy+0x59>
movl   $0x0,-0x6c(%rbp)
imul   $0x5,-0xc(%rbp),%eax
shl    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
imul   $0x5,-0xc(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    1351 <calcMy+0x221>
mov    -0x68(%rbp),%rax
movslq -0x14(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1322 <calcMy+0x1f2>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15a6 <calcMy+0x476>
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
movl   $0xffffffff,-0x94(%rbp)
ff ff ff
cmpl   $0x5,-0x70(%rbp)
jge    13b7 <calcMy+0x287>
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     13a9 <calcMy+0x279>
mov    -0x74(%rbp),%ecx
movslq -0x70(%rbp),%rax
mov    %ecx,-0x90(%rbp,%rax,4)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    137c <calcMy+0x24c>
movl   $0x0,-0x18(%rbp)
cmpl   $0x5,-0x18(%rbp)
jge    1436 <calcMy+0x306>
cmpl   $0xffffffff,-0x94(%rbp)
je     141a <calcMy+0x2ea>
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq -0x94(%rbp),%rdx
add    -0x90(%rbp,%rdx,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq -0x18(%rbp),%rdx
add    -0x90(%rbp,%rdx,4),%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1423 <calcMy+0x2f3>
mov    -0x18(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    1428 <calcMy+0x2f8>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13be <calcMy+0x28e>
mov    -0x74(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1537 <calcMy+0x407>
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq -0x94(%rbp),%rdx
add    -0x90(%rbp,%rdx,4),%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1524 <calcMy+0x3f4>
mov    -0x18(%rbp),%ecx
movslq -0x94(%rbp),%rax
mov    %ecx,-0x90(%rbp,%rax,4)
movl   $0xffffffff,-0x94(%rbp)
ff ff ff
movl   $0x0,-0x1c(%rbp)
cmpl   $0x5,-0x1c(%rbp)
jge    151f <calcMy+0x3ef>
cmpl   $0xffffffff,-0x94(%rbp)
je     1503 <calcMy+0x3d3>
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq -0x94(%rbp),%rdx
add    -0x90(%rbp,%rdx,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq -0x1c(%rbp),%rdx
add    -0x90(%rbp,%rdx,4),%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    150c <calcMy+0x3dc>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    1511 <calcMy+0x3e1>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14a7 <calcMy+0x377>
jmp    1524 <calcMy+0x3f4>
jmp    1529 <calcMy+0x3f9>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    143c <calcMy+0x30c>
movl   $0x0,-0x18(%rbp)
cmpl   $0x5,-0x18(%rbp)
jge    1593 <calcMy+0x463>
mov    -0x14(%rbp),%edx
mov    -0x68(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movslq -0x18(%rbp),%rax
mov    -0x90(%rbp,%rax,4),%edx
mov    -0x68(%rbp),%rax
mov    -0x6c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    153e <calcMy+0x40e>
jmp    1598 <calcMy+0x468>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1358 <calcMy+0x228>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0xa4(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0x10(%rbp),%eax
imul   -0x10(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x10(%rbp),%ecx
imul   -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1617 <calcMy+0x4e7>
mov    -0xa0(%rbp),%rax
movslq -0x14(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    15e4 <calcMy+0x4b4>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1e1c <calcMy+0xcec>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1e09 <calcMy+0xcd9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    $0x138800,%edi
call   1040 <malloc@plt>
mov    %rax,-0xb0(%rbp)
mov    $0xc80,%edi
call   1040 <malloc@plt>
mov    %rax,-0xb8(%rbp)
mov    $0xc80,%edi
call   1040 <malloc@plt>
mov    %rax,-0xc0(%rbp)
movl   $0x0,-0xd4(%rbp)
movl   $0x0,-0xd8(%rbp)
movl   $0x0,-0xdc(%rbp)
movl   $0x0,-0xe0(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x27100,-0x1c(%rbp)
jge    16e5 <calcMy+0x5b5>
mov    -0xb0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    16b7 <calcMy+0x587>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x190,-0x1c(%rbp)
jge    172d <calcMy+0x5fd>
mov    -0xb8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    16ec <calcMy+0x5bc>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
imul   $0x5,-0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    1ad5 <calcMy+0x9a5>
mov    -0x68(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
je     1ac2 <calcMy+0x992>
mov    -0x8(%rbp),%rax
mov    -0xa4(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
je     1ac2 <calcMy+0x992>
mov    -0x8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
je     1ac2 <calcMy+0x992>
mov    -0x8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
je     1ac2 <calcMy+0x992>
movl   $0x0,-0xd4(%rbp)
movl   $0x0,-0xd8(%rbp)
movl   $0x0,-0xdc(%rbp)
movl   $0x0,-0xe0(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x14,-0x20(%rbp)
jge    1879 <calcMy+0x749>
movslq -0x20(%rbp),%rax
movsbl -0x40(%rbp,%rax,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0xa4(%rbp),%edx
imul   -0x10(%rbp),%edx
add    -0x14(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1866 <calcMy+0x736>
mov    -0x20(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    1879 <calcMy+0x749>
jmp    186b <calcMy+0x73b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1825 <calcMy+0x6f5>
movl   $0x0,-0x20(%rbp)
cmpl   $0x14,-0x20(%rbp)
jge    18d4 <calcMy+0x7a4>
movslq -0x20(%rbp),%rax
movsbl -0x40(%rbp,%rax,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0xa8(%rbp),%edx
imul   -0x10(%rbp),%edx
add    -0x14(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    18c1 <calcMy+0x791>
mov    -0x20(%rbp),%eax
mov    %eax,-0xd8(%rbp)
jmp    18d4 <calcMy+0x7a4>
jmp    18c6 <calcMy+0x796>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1880 <calcMy+0x750>
movl   $0x0,-0x20(%rbp)
cmpl   $0x14,-0x20(%rbp)
jge    192f <calcMy+0x7ff>
movslq -0x20(%rbp),%rax
movsbl -0x40(%rbp,%rax,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0xa4(%rbp),%edx
imul   -0x10(%rbp),%edx
add    -0x18(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    191c <calcMy+0x7ec>
mov    -0x20(%rbp),%eax
mov    %eax,-0xdc(%rbp)
jmp    192f <calcMy+0x7ff>
jmp    1921 <calcMy+0x7f1>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    18db <calcMy+0x7ab>
movl   $0x0,-0x20(%rbp)
cmpl   $0x14,-0x20(%rbp)
jge    198a <calcMy+0x85a>
movslq -0x20(%rbp),%rax
movsbl -0x40(%rbp,%rax,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0xa8(%rbp),%edx
imul   -0x10(%rbp),%edx
add    -0x18(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1977 <calcMy+0x847>
mov    -0x20(%rbp),%eax
mov    %eax,-0xe0(%rbp)
jmp    198a <calcMy+0x85a>
jmp    197c <calcMy+0x84c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1936 <calcMy+0x806>
mov    -0xb0(%rbp),%rax
imul   $0x14,-0xd4(%rbp),%ecx
add    -0xdc(%rbp),%ecx
imul   $0x190,%ecx,%ecx
imul   $0x14,-0xd8(%rbp),%edx
add    -0xe0(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0x64a(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%rax
imul   $0x14,-0xd8(%rbp),%ecx
add    -0xe0(%rbp),%ecx
imul   $0x190,%ecx,%ecx
imul   $0x14,-0xd4(%rbp),%edx
add    -0xdc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0x60c(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rax
imul   $0x14,-0xd4(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x5e3(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rax
imul   $0x14,-0xd8(%rbp),%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x5ba(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
imul   $0x14,-0xdc(%rbp),%ecx
add    -0xe0(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x591(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
imul   $0x14,-0xe0(%rbp),%ecx
add    -0xdc(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x568(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x54e(%rip),%xmm0
addsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1ac7 <calcMy+0x997>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1734 <calcMy+0x604>
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1af5 <calcMy+0x9c5>
jp     1af5 <calcMy+0x9c5>
jmp    1bb6 <calcMy+0xa86>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x27100,-0x1c(%rbp)
jge    1b3f <calcMy+0xa0f>
mov    -0xb0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xc8(%rbp),%xmm0
ff
mov    -0xb0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1afc <calcMy+0x9cc>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x190,-0x1c(%rbp)
jge    1bb1 <calcMy+0xa81>
mov    -0xb8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xc8(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xc8(%rbp),%xmm0
ff
mov    -0xc0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1b46 <calcMy+0xa16>
jmp    1bb6 <calcMy+0xa86>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x20(%rbp)
cmpl   $0x14,-0x20(%rbp)
jge    1d95 <calcMy+0xc65>
movl   $0x0,-0x24(%rbp)
cmpl   $0x14,-0x24(%rbp)
jge    1d82 <calcMy+0xc52>
mov    -0xb8(%rbp),%rax
imul   $0x14,-0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c11 <calcMy+0xae1>
jp     1c11 <calcMy+0xae1>
jmp    1d74 <calcMy+0xc44>
movl   $0x0,-0x28(%rbp)
cmpl   $0x14,-0x28(%rbp)
jge    1d6a <calcMy+0xc3a>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x14,-0x2c(%rbp)
jge    1d57 <calcMy+0xc27>
mov    -0xc0(%rbp),%rax
imul   $0x14,-0x28(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c61 <calcMy+0xb31>
jp     1c61 <calcMy+0xb31>
jmp    1c99 <calcMy+0xb69>
mov    -0xb0(%rbp),%rax
imul   $0x14,-0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
imul   $0x190,%ecx,%ecx
imul   $0x14,-0x24(%rbp),%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c9e <calcMy+0xb6e>
jp     1c9e <calcMy+0xb6e>
jmp    1d49 <calcMy+0xc19>
mov    -0xb0(%rbp),%rax
imul   $0x14,-0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
imul   $0x190,%ecx,%ecx
imul   $0x14,-0x24(%rbp),%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0xb0(%rbp),%rax
imul   $0x14,-0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
imul   $0x190,%ecx,%ecx
imul   $0x14,-0x24(%rbp),%edx
add    -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xb8(%rbp),%rax
imul   $0x14,-0x20(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0xc0(%rbp),%rax
imul   $0x14,-0x28(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
call   1050 <log@plt>
movaps %xmm0,%xmm2
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1d49 <calcMy+0xc19>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1c29 <calcMy+0xaf9>
jmp    1d5c <calcMy+0xc2c>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1c18 <calcMy+0xae8>
jmp    1d6f <calcMy+0xc3f>
jmp    1d74 <calcMy+0xc44>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1bd9 <calcMy+0xaa9>
jmp    1d87 <calcMy+0xc57>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1bc8 <calcMy+0xa98>
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0xa0(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0xa0(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1633 <calcMy+0x503>
jmp    1e0e <calcMy+0xcde>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    161e <calcMy+0x4ee>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calcMy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %edx,%r13d
mov    %esi,%ebx
mov    %rdi,0x50(%rsp)
mov    %esi,%edi
imul   %edi,%edi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,%rbp
movslq %r13d,%rax
mov    %rax,0x30(%rsp)
mov    %ebx,%r12d
mov    %r13d,%eax
mov    %rax,0x60(%rsp)
mov    %rbx,%rax
mov    %rbx,0x20(%rsp)
test   %ebx,%ebx
jle    1299 <calcMy+0x149>
mov    0x50(%rsp),%rdx
mov    0x30(%rsp),%rax
lea    (%rdx,%rax,1),%r9
mov    $0x1,%r10d
xor    %r8d,%r8d
movsd  0xe42(%rip),%xmm0
movsd  0xe42(%rip),%xmm1
jmp    11e8 <calcMy+0x98>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
mov    0x30(%rsp),%rax
add    %rax,%r9
add    %rax,%rdx
cmp    %r12,%r8
je     1299 <calcMy+0x149>
mov    %r8,%rdi
mov    %edi,%eax
imul   0x20(%rsp),%eax
cltq
add    %r8,%rax
movq   $0x0,0x0(%rbp,%rax,8)
add    $0x1,%r8
cmp    %r12,%r8
jae    11d0 <calcMy+0x80>
mov    %rdi,%r11
imul   %r12,%r11
mov    %r9,%rax
mov    %r10,%rsi
jmp    124c <calcMy+0xfc>
nopl   0x0(%rax,%rax,1)
divsd  %xmm3,%xmm2
lea    (%rsi,%r11,1),%rcx
movsd  %xmm2,0x0(%rbp,%rcx,8)
mov    %rsi,%rcx
imul   %r12,%rcx
add    %rdi,%rcx
movsd  %xmm2,0x0(%rbp,%rcx,8)
add    $0x1,%rsi
add    0x30(%rsp),%rax
cmp    %r12,%rsi
je     11d0 <calcMy+0x80>
movapd %xmm0,%xmm2
test   %r13d,%r13d
jle    1224 <calcMy+0xd4>
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
xorpd  %xmm3,%xmm3
jmp    127f <calcMy+0x12f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addsd  %xmm1,%xmm3
add    $0x1,%rbx
cmp    %rbx,0x60(%rsp)
je     1220 <calcMy+0xd0>
movzbl (%rdx,%rbx,1),%ecx
cmp    $0x2d,%cl
jne    128e <calcMy+0x13e>
cmpb   $0x2d,(%rax,%rbx,1)
je     1274 <calcMy+0x124>
cmp    (%rax,%rbx,1),%cl
jne    1270 <calcMy+0x120>
addsd  %xmm1,%xmm2
jmp    1270 <calcMy+0x120>
mov    0x20(%rsp),%rax
add    %eax,%eax
lea    (%rax,%rax,4),%r14d
movslq %r14d,%rbx
lea    0x0(,%rbx,4),%rdi
call   1060 <malloc@plt>
mov    %rax,%r15
test   %ebx,%ebx
jle    12cf <calcMy+0x17f>
mov    %r14d,%edx
shl    $0x2,%rdx
mov    %r15,%rdi
mov    $0xff,%esi
call   1040 <memset@plt>
mov    %r15,0x58(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    1533 <calcMy+0x3e3>
mov    %rbp,%r14
add    $0x8,%r14
lea    0x0(,%r12,8),%r9
xor    %eax,%eax
mov    $0x2,%r10d
mov    $0x3,%r11d
xor    %r15d,%r15d
jmp    13ab <calcMy+0x25b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r15,%r15,1),%ecx
movslq %ecx,%rcx
mov    0x58(%rsp),%rsi
mov    %eax,(%rsi,%rcx,4)
mov    (%rsp),%ecx
lea    0x1(%r15,%r15,1),%edx
movslq %edx,%rdx
mov    %ecx,(%rsi,%rdx,4)
lea    0x2(%r15,%r15,1),%ecx
movslq %ecx,%rcx
mov    %eax,(%rsi,%rcx,4)
mov    0x4(%rsp),%ecx
lea    0x3(%r15,%r15,1),%edx
movslq %edx,%rdx
mov    %ecx,(%rsi,%rdx,4)
lea    0x4(%r15,%r15,1),%ecx
movslq %ecx,%rcx
mov    %eax,(%rsi,%rcx,4)
mov    0x8(%rsp),%ecx
lea    0x5(%r15,%r15,1),%edx
movslq %edx,%rdx
mov    %ecx,(%rsi,%rdx,4)
lea    0x6(%r15,%r15,1),%ecx
movslq %ecx,%rcx
mov    %eax,(%rsi,%rcx,4)
mov    0xc(%rsp),%ecx
lea    0x7(%r15,%r15,1),%edx
movslq %edx,%rdx
mov    %ecx,(%rsi,%rdx,4)
lea    0x8(%r15,%r15,1),%ecx
movslq %ecx,%rcx
mov    %eax,(%rsi,%rcx,4)
mov    0x10(%rsp),%ecx
lea    (%r15,%r15,1),%edx
add    $0x9,%edx
movslq %edx,%rdx
mov    %ecx,(%rsi,%rdx,4)
add    $0x5,%r15d
add    $0x1,%rax
add    %r9,%r14
cmp    %r12,%rax
je     1533 <calcMy+0x3e3>
mov    %r14,%rdx
xor    %esi,%esi
xor    %ecx,%ecx
jmp    13cd <calcMy+0x27d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rsi
lea    0x8(%rdi),%rdx
cmp    $0x5,%ecx
jge    13e0 <calcMy+0x290>
mov    %rdx,%rdi
cmp    %rsi,%rax
je     13c0 <calcMy+0x270>
movslq %ecx,%rcx
mov    %esi,(%rsp,%rcx,4)
add    $0x1,%ecx
jmp    13c0 <calcMy+0x270>
mov    %rax,%rdx
imul   %r12,%rdx
movslq (%rsp),%rcx
add    %rdx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm0
movslq 0x4(%rsp),%rbx
add    %rdx,%rbx
xor    %ecx,%ecx
ucomisd 0x0(%rbp,%rbx,8),%xmm0
seta   %cl
movslq (%rsp,%rcx,4),%rbx
add    %rdx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movslq 0x8(%rsp),%rbx
add    %rdx,%rbx
ucomisd 0x0(%rbp,%rbx,8),%xmm0
cmova  %r10d,%ecx
movslq (%rsp,%rcx,4),%rbx
add    %rdx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movslq 0xc(%rsp),%rbx
add    %rdx,%rbx
ucomisd 0x0(%rbp,%rbx,8),%xmm0
cmova  %r11d,%ecx
cmp    0x20(%rsp),%esi
jge    1310 <calcMy+0x1c0>
mov    %ecx,%ebx
movslq (%rsp,%rbx,4),%rbx
add    %rdx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movslq 0x10(%rsp),%rbx
add    %rdx,%rbx
ucomisd 0x0(%rbp,%rbx,8),%xmm0
mov    $0x4,%ebx
cmova  %ebx,%ecx
jmp    1491 <calcMy+0x341>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rsi
add    $0x8,%rdi
cmp    %rsi,%r12
je     1310 <calcMy+0x1c0>
movsd  (%rdi),%xmm0
mov    %ecx,%ebx
movslq (%rsp,%rbx,4),%r8
add    %rdx,%r8
ucomisd 0x0(%rbp,%r8,8),%xmm0
jbe    1480 <calcMy+0x330>
mov    %esi,(%rsp,%rbx,4)
movslq (%rsp),%rcx
add    %rdx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm0
movslq 0x4(%rsp),%rbx
add    %rdx,%rbx
xor    %ecx,%ecx
ucomisd 0x0(%rbp,%rbx,8),%xmm0
seta   %cl
movslq (%rsp,%rcx,4),%rbx
add    %rdx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movslq 0x8(%rsp),%rbx
add    %rdx,%rbx
ucomisd 0x0(%rbp,%rbx,8),%xmm0
cmova  %r10d,%ecx
movslq (%rsp,%rcx,4),%rbx
add    %rdx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movslq 0xc(%rsp),%rbx
add    %rdx,%rbx
ucomisd 0x0(%rbp,%rbx,8),%xmm0
cmova  %r11d,%ecx
movslq (%rsp,%rcx,4),%rbx
add    %rdx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movslq 0x10(%rsp),%rbx
add    %rdx,%rbx
ucomisd 0x0(%rbp,%rbx,8),%xmm0
jbe    1480 <calcMy+0x330>
mov    $0x4,%ecx
jmp    1480 <calcMy+0x330>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r13d,%ebp
imul   %ebp,%ebp
lea    0x0(,%rbp,8),%r14
mov    %r14,%rdi
call   1060 <malloc@plt>
mov    %rax,%rbx
test   %ebp,%ebp
je     1565 <calcMy+0x415>
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1040 <memset@plt>
mov    %rbx,0x78(%rsp)
test   %r13d,%r13d
mov    0x50(%rsp),%r14
mov    0x30(%rsp),%r15
mov    0x60(%rsp),%rbx
mov    0x58(%rsp),%r12
jle    1a65 <calcMy+0x915>
mov    0x20(%rsp),%rax
lea    (%rax,%rax,4),%eax
cmp    $0x2,%eax
mov    $0x1,%ebp
cmovge %eax,%ebp
mov    $0x1,%eax
mov    %rax,0x70(%rsp)
xor    %eax,%eax
mov    %rbp,0x80(%rsp)
jmp    15c7 <calcMy+0x477>
addq   $0x1,0x70(%rsp)
mov    0x90(%rsp),%rax
cmp    %rbx,%rax
je     1a65 <calcMy+0x915>
mov    %rax,0x48(%rsp)
add    $0x1,%rax
mov    %rax,0x90(%rsp)
cmp    %rbx,%rax
jae    15b0 <calcMy+0x460>
mov    0x48(%rsp),%rax
imul   %rbx,%rax
mov    %rax,0x98(%rsp)
mov    0x70(%rsp),%rax
mov    %rax,0x40(%rsp)
jmp    1675 <calcMy+0x525>
nopw   0x0(%rax,%rax,1)
mov    0x98(%rsp),%rax
mov    0x40(%rsp),%rbp
add    %rbp,%rax
mov    0x78(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
mov    %rbp,%rax
mov    0x60(%rsp),%rbx
imul   %rbx,%rax
add    0x48(%rsp),%rax
movsd  %xmm0,(%rcx,%rax,8)
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
mov    %rbp,0x40(%rsp)
cmp    %rbx,%rbp
mov    0x50(%rsp),%r14
mov    0x30(%rsp),%r15
mov    0x58(%rsp),%r12
mov    0x80(%rsp),%rbp
je     15b0 <calcMy+0x460>
mov    $0x1,%edi
mov    $0x138800,%esi
call   1050 <calloc@plt>
mov    %rax,0x38(%rsp)
mov    $0x1,%edi
mov    $0xc80,%esi
call   1050 <calloc@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    $0xc80,%esi
call   1050 <calloc@plt>
cmpl   $0x0,0x20(%rsp)
xorpd  %xmm3,%xmm3
mov    %r13,0x88(%rsp)
mov    %rax,0x28(%rsp)
jle    191f <calcMy+0x7cf>
xorpd  %xmm0,%xmm0
xor    %r8d,%r8d
movsd  0x933(%rip),%xmm2
jmp    16f2 <calcMy+0x5a2>
nopw   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rax
add    $0x1,%r8
cmp    %r8,%rbp
je     1880 <calcMy+0x730>
movslq (%r12,%r8,8),%rcx
imul   %r15,%rcx
mov    0x48(%rsp),%rdx
add    %rcx,%rdx
movzbl (%r14,%rdx,1),%edx
cmp    $0x2d,%dl
je     16e5 <calcMy+0x595>
add    0x40(%rsp),%rcx
movzbl (%r14,%rcx,1),%ebx
cmp    $0x2d,%bl
je     16e0 <calcMy+0x590>
movslq 0x4(%r12,%r8,8),%rsi
imul   %r15,%rsi
mov    0x48(%rsp),%rcx
add    %rsi,%rcx
movzbl (%r14,%rcx,1),%ecx
cmp    $0x2d,%cl
je     16e0 <calcMy+0x590>
add    0x40(%rsp),%rsi
movzbl (%r14,%rsi,1),%r9d
cmp    $0x2d,%r9b
je     16e0 <calcMy+0x590>
add    $0xbd,%dl
xor    %r10d,%r10d
mov    $0x0,%eax
cmp    $0x16,%dl
ja     1764 <calcMy+0x614>
movsbq %dl,%rdx
lea    0x8b7(%rip),%rsi
mov    (%rsi,%rdx,4),%eax
add    $0xbd,%cl
cmp    $0x16,%cl
ja     177b <calcMy+0x62b>
movsbq %cl,%rcx
lea    0x8a1(%rip),%rdx
mov    (%rdx,%rcx,4),%r10d
add    $0xbd,%bl
xor    %r13d,%r13d
mov    $0x0,%r11d
cmp    $0x16,%bl
ja     179b <calcMy+0x64b>
movsbq %bl,%rcx
lea    0x881(%rip),%rdx
mov    (%rdx,%rcx,4),%r11d
add    $0xbd,%r9b
cmp    $0x16,%r9b
ja     17b4 <calcMy+0x664>
movsbq %r9b,%rcx
lea    0x868(%rip),%rdx
mov    (%rdx,%rcx,4),%r13d
lea    0x0(,%rax,4),%ecx
lea    (%rcx,%rcx,4),%ecx
lea    (%r11,%rcx,1),%ebx
imul   $0x190,%ebx,%ebp
lea    0x0(,%r10,4),%edx
lea    (%rdx,%rdx,4),%edx
lea    (%rdx,%r13,1),%esi
add    %esi,%ebp
mov    0x38(%rsp),%rdi
movsd  (%rdi,%rbp,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
imul   $0x190,%esi,%esi
add    %ebx,%esi
movsd  (%rdi,%rsi,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
add    %r10d,%ecx
mov    0x88(%rsp),%rsi
movsd  (%rsi,%rcx,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
add    %eax,%edx
movsd  (%rsi,%rdx,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
lea    (%r11,%r11,4),%ecx
lea    0x0(%r13,%rcx,4),%ecx
mov    0x28(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
lea    0x0(%r13,%r13,4),%ecx
mov    %rsi,%r13
lea    (%r11,%rcx,4),%ecx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
addsd  0x7a7(%rip),%xmm0
mov    0x80(%rsp),%rbp
jmp    16e5 <calcMy+0x595>
cs nopw 0x0(%rax,%rax,1)
ucomisd %xmm3,%xmm0
jne    188c <calcMy+0x73c>
jnp    191f <calcMy+0x7cf>
unpcklpd %xmm0,%xmm0
mov    $0x2,%edx
mov    0x38(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rdx,8),%xmm1
movupd (%rcx,%rdx,8),%xmm2
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rcx,%rdx,8)
divpd  %xmm0,%xmm2
movupd %xmm2,(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    $0x27102,%rdx
jne    18a0 <calcMy+0x750>
mov    $0x2,%ecx
movupd -0x10(%r13,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%r13,%rcx,8)
movupd -0x10(%rax,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rax,%rcx,8)
movupd 0x0(%r13,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x0(%r13,%rcx,8)
movupd (%rax,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rcx,8)
add    $0x4,%rcx
cmp    $0x192,%rcx
jne    18d0 <calcMy+0x780>
xorpd  %xmm0,%xmm0
mov    0x38(%rsp),%r12
xor    %eax,%eax
jmp    1955 <calcMy+0x805>
nopl   0x0(%rax)
mov    0xa0(%rsp),%rax
add    $0x1,%rax
mov    0xa8(%rsp),%r12
add    $0xfa00,%r12
cmp    $0x14,%rax
je     1600 <calcMy+0x4b0>
mov    %rax,0xa0(%rsp)
lea    0x0(,%rax,4),%rax
lea    (%rax,%rax,4),%rax
mov    %rax,0xb0(%rsp)
mov    %r12,0xa8(%rsp)
xor    %ebp,%ebp
jmp    1999 <calcMy+0x849>
nopl   (%rax)
add    $0x1,%rbp
add    $0xa0,%r12
cmp    $0x14,%rbp
mov    0x88(%rsp),%r13
je     1930 <calcMy+0x7e0>
mov    0xb0(%rsp),%rax
add    %rbp,%rax
movsd  0x0(%r13,%rax,8),%xmm2
ucomisd %xmm3,%xmm2
jne    19b3 <calcMy+0x863>
jnp    1980 <calcMy+0x830>
mov    %r12,%r13
mov    0x28(%rsp),%r14
xor    %ebx,%ebx
movsd  %xmm2,0xb8(%rsp)
jmp    19e8 <calcMy+0x898>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0xa0,%r14
add    $0xc80,%r13
cmp    $0x14,%rbx
je     1980 <calcMy+0x830>
xor    %r15d,%r15d
jmp    19fa <calcMy+0x8aa>
nopl   (%rax)
add    $0x1,%r15
cmp    $0x14,%r15
je     19d0 <calcMy+0x880>
movsd  (%r14,%r15,8),%xmm1
ucomisd %xmm3,%xmm1
jne    1a08 <calcMy+0x8b8>
jnp    19f0 <calcMy+0x8a0>
movsd  0x0(%r13,%r15,8),%xmm4
ucomisd %xmm3,%xmm4
jne    1a17 <calcMy+0x8c7>
jnp    19f0 <calcMy+0x8a0>
movsd  %xmm0,0x68(%rsp)
movapd %xmm4,%xmm0
divsd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm4,0xc0(%rsp)
call   1070 <log@plt>
movsd  0xb8(%rsp),%xmm2
xorpd  %xmm3,%xmm3
mulsd  0xc0(%rsp),%xmm0
movsd  0x68(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x68(%rsp)
movsd  0x68(%rsp),%xmm0
jmp    19f0 <calcMy+0x8a0>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rax
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.calcMy.reslist = [20 x i8] c"ACDEFGHIKLMNPQRSTVWY"
define double* @calcMy(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 i32
%13 = alloca i32
%14 = alloca [20 x i8]
%15 = alloca i32
%16 = alloca double*
%17 = alloca double
%18 = alloca double
%19 = alloca i32*
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca [5 x i32]
%24 = alloca i32
%25 = alloca double*
%26 = alloca i32
%27 = alloca i32
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double
%32 = alloca double
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%37 = bitcast [20 x i8]* %14 to i8*
store i32 20, i32* %15
%38 = load i32, i32* %5
%39 = load i32, i32* %5
%40 = mul nsw i32 %38, %39
%41 = sext i32 %40 to i64
%42 = mul i64 %41, 8
%43 = call i8* @malloc(i64 %42)
%44 = bitcast i8* %43 to double*
store double* %44, double** %16
store i32 0, i32* %7
br label %45
45: ; preds = %158, %3
%46 = load i32, i32* %7
%47 = load i32, i32* %5
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %161
49: ; preds = %45
%50 = load double*, double** %16
%51 = load i32, i32* %7
%52 = load i32, i32* %5
%53 = mul nsw i32 %51, %52
%54 = load i32, i32* %7
%55 = add nsw i32 %53, %54
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds double, double* %50, i64 %56
store double 0.000000e+00, double* %57
%58 = load i32, i32* %7
%59 = add nsw i32 %58, 1
store i32 %59, i32* %8
br label %60
60: ; preds = %154, %49
%61 = load i32, i32* %8
%62 = load i32, i32* %5
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %157
64: ; preds = %60
store double 0.000000e+00, double* %17
store double 0.000000e+00, double* %18
store i32 0, i32* %9
br label %65
65: ; preds = %122, %64
%66 = load i32, i32* %9
%67 = load i32, i32* %6
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %125
69: ; preds = %65
%70 = load i8*, i8** %4
%71 = load i32, i32* %7
%72 = load i32, i32* %6
%73 = mul nsw i32 %71, %72
%74 = load i32, i32* %9
%75 = add nsw i32 %73, %74
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i8, i8* %70, i64 %76
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = icmp ne i32 %79, 45
br i1 %80, label %93, label %81
81: ; preds = %69
%82 = load i8*, i8** %4
%83 = load i32, i32* %8
%84 = load i32, i32* %6
%85 = mul nsw i32 %83, %84
%86 = load i32, i32* %9
%87 = add nsw i32 %85, %86
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i8, i8* %82, i64 %88
%90 = load i8, i8* %89
%91 = sext i8 %90 to i32
%92 = icmp ne i32 %91, 45
br i1 %92, label %93, label %121
93: ; preds = %81, %69
%94 = load double, double* %17
%95 = fadd double %94, 1.000000e+00
store double %95, double* %17
%96 = load i8*, i8** %4
%97 = load i32, i32* %7
%98 = load i32, i32* %6
%99 = mul nsw i32 %97, %98
%100 = load i32, i32* %9
%101 = add nsw i32 %99, %100
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i8, i8* %96, i64 %102
%104 = load i8, i8* %103
%105 = sext i8 %104 to i32
%106 = load i8*, i8** %4
%107 = load i32, i32* %8
%108 = load i32, i32* %6
%109 = mul nsw i32 %107, %108
%110 = load i32, i32* %9
%111 = add nsw i32 %109, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i8, i8* %106, i64 %112
%114 = load i8, i8* %113
%115 = sext i8 %114 to i32
%116 = icmp eq i32 %105, %115
br i1 %116, label %117, label %120
117: ; preds = %93
%118 = load double, double* %18
%119 = fadd double %118, 1.000000e+00
store double %119, double* %18
br label %120
120: ; preds = %117, %93
br label %121
121: ; preds = %120, %81
br label %122
122: ; preds = %121
%123 = load i32, i32* %9
%124 = add nsw i32 %123, 1
store i32 %124, i32* %9
br label %65
125: ; preds = %65
%126 = load double, double* %18
%127 = load double, double* %17
%128 = fdiv double %126, %127
%129 = load double*, double** %16
%130 = load i32, i32* %7
%131 = load i32, i32* %5
%132 = mul nsw i32 %130, %131
%133 = load i32, i32* %8
%134 = add nsw i32 %132, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %129, i64 %135
store double %128, double* %136
%137 = load double*, double** %16
%138 = load i32, i32* %7
%139 = load i32, i32* %5
%140 = mul nsw i32 %138, %139
%141 = load i32, i32* %8
%142 = add nsw i32 %140, %141
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %137, i64 %143
%145 = load double, double* %144
%146 = load double*, double** %16
%147 = load i32, i32* %8
%148 = load i32, i32* %5
%149 = mul nsw i32 %147, %148
%150 = load i32, i32* %7
%151 = add nsw i32 %149, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double, double* %146, i64 %152
store double %145, double* %153
br label %154
154: ; preds = %125
%155 = load i32, i32* %8
%156 = add nsw i32 %155, 1
store i32 %156, i32* %8
br label %60
157: ; preds = %60
br label %158
158: ; preds = %157
%159 = load i32, i32* %7
%160 = add nsw i32 %159, 1
store i32 %160, i32* %7
br label %45
161: ; preds = %45
store i32 0, i32* %20
%162 = load i32, i32* %5
%163 = mul nsw i32 5, %162
%164 = mul nsw i32 %163, 2
%165 = sext i32 %164 to i64
%166 = mul i64 %165, 4
%167 = call i8* @malloc(i64 %166)
%168 = bitcast i8* %167 to i32*
store i32* %168, i32** %19
store i32 0, i32* %7
br label %169
169: ; preds = %180, %161
%170 = load i32, i32* %7
%171 = load i32, i32* %5
%172 = mul nsw i32 5, %171
%173 = mul nsw i32 %172, 2
%174 = icmp slt i32 %170, %173
br i1 %174, label %175, label %183
175: ; preds = %169
%176 = load i32*, i32** %19
%177 = load i32, i32* %7
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds i32, i32* %176, i64 %178
store i32 -1, i32* %179
br label %180
180: ; preds = %175
%181 = load i32, i32* %7
%182 = add nsw i32 %181, 1
store i32 %182, i32* %7
br label %169
183: ; preds = %169
store i32 0, i32* %7
br label %184
184: ; preds = %350, %183
%185 = load i32, i32* %7
%186 = load i32, i32* %5
%187 = icmp slt i32 %185, %186
br i1 %187, label %188, label %353
188: ; preds = %184
store i32 0, i32* %21
store i32 0, i32* %22
store i32 -1, i32* %24
br label %189
189: ; preds = %203, %188
%190 = load i32, i32* %21
%191 = icmp slt i32 %190, 5
br i1 %191, label %192, label %206
192: ; preds = %189
%193 = load i32, i32* %22
%194 = load i32, i32* %7
%195 = icmp ne i32 %193, %194
br i1 %195, label %196, label %203
196: ; preds = %192
%197 = load i32, i32* %22
%198 = load i32, i32* %21
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [5 x i32], [5 x i32]* %23, i64 0, i64 %199
store i32 %197, i32* %200
%201 = load i32, i32* %21
%202 = add nsw i32 %201, 1
store i32 %202, i32* %21
br label %203
203: ; preds = %196, %192
%204 = load i32, i32* %22
%205 = add nsw i32 %204, 1
store i32 %205, i32* %22
br label %189
206: ; preds = %189
store i32 0, i32* %8
br label %207
207: ; preds = %242, %206
%208 = load i32, i32* %8
%209 = icmp slt i32 %208, 5
br i1 %209, label %210, label %245
210: ; preds = %207
%211 = load i32, i32* %24
%212 = icmp eq i32 %211, -1
br i1 %212, label %239, label %213
213: ; preds = %210
%214 = load double*, double** %16
%215 = load i32, i32* %7
%216 = load i32, i32* %5
%217 = mul nsw i32 %215, %216
%218 = load i32, i32* %24
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds [5 x i32], [5 x i32]* %23, i64 0, i64 %219
%221 = load i32, i32* %220
%222 = add nsw i32 %217, %221
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds double, double* %214, i64 %223
%225 = load double, double* %224
%226 = load double*, double** %16
%227 = load i32, i32* %7
%228 = load i32, i32* %5
%229 = mul nsw i32 %227, %228
%230 = load i32, i32* %8
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds [5 x i32], [5 x i32]* %23, i64 0, i64 %231
%233 = load i32, i32* %232
%234 = add nsw i32 %229, %233
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %226, i64 %235
%237 = load double, double* %236
%238 = fcmp ogt double %225, %237
br i1 %238, label %239, label %241
239: ; preds = %213, %210
%240 = load i32, i32* %8
store i32 %240, i32* %24
br label %241
241: ; preds = %239, %213
br label %242
242: ; preds = %241
%243 = load i32, i32* %8
%244 = add nsw i32 %243, 1
store i32 %244, i32* %8
br label %207
245: ; preds = %207
%246 = load i32, i32* %22
store i32 %246, i32* %8
br label %247
247: ; preds = %319, %245
%248 = load i32, i32* %8
%249 = load i32, i32* %5
%250 = icmp slt i32 %248, %249
br i1 %250, label %251, label %322
251: ; preds = %247
%252 = load double*, double** %16
%253 = load i32, i32* %7
%254 = load i32, i32* %5
%255 = mul nsw i32 %253, %254
%256 = load i32, i32* %8
%257 = add nsw i32 %255, %256
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds double, double* %252, i64 %258
%260 = load double, double* %259
%261 = load double*, double** %16
%262 = load i32, i32* %7
%263 = load i32, i32* %5
%264 = mul nsw i32 %262, %263
%265 = load i32, i32* %24
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds [5 x i32], [5 x i32]* %23, i64 0, i64 %266
%268 = load i32, i32* %267
%269 = add nsw i32 %264, %268
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %261, i64 %270
%272 = load double, double* %271
%273 = fcmp ogt double %260, %272
br i1 %273, label %274, label %318
274: ; preds = %251
%275 = load i32, i32* %8
%276 = load i32, i32* %24
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds [5 x i32], [5 x i32]* %23, i64 0, i64 %277
store i32 %275, i32* %278
store i32 -1, i32* %24
store i32 0, i32* %9
br label %279
279: ; preds = %314, %274
%280 = load i32, i32* %9
%281 = icmp slt i32 %280, 5
br i1 %281, label %282, label %317
282: ; preds = %279
%283 = load i32, i32* %24
%284 = icmp eq i32 %283, -1
br i1 %284, label %311, label %285
285: ; preds = %282
%286 = load double*, double** %16
%287 = load i32, i32* %7
%288 = load i32, i32* %5
%289 = mul nsw i32 %287, %288
%290 = load i32, i32* %24
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds [5 x i32], [5 x i32]* %23, i64 0, i64 %291
%293 = load i32, i32* %292
%294 = add nsw i32 %289, %293
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds double, double* %286, i64 %295
%297 = load double, double* %296
%298 = load double*, double** %16
%299 = load i32, i32* %7
%300 = load i32, i32* %5
%301 = mul nsw i32 %299, %300
%302 = load i32, i32* %9
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds [5 x i32], [5 x i32]* %23, i64 0, i64 %303
%305 = load i32, i32* %304
%306 = add nsw i32 %301, %305
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds double, double* %298, i64 %307
%309 = load double, double* %308
%310 = fcmp ogt double %297, %309
br i1 %310, label %311, label %313
311: ; preds = %285, %282
%312 = load i32, i32* %9
store i32 %312, i32* %24
br label %313
313: ; preds = %311, %285
br label %314
314: ; preds = %313
%315 = load i32, i32* %9
%316 = add nsw i32 %315, 1
store i32 %316, i32* %9
br label %279
317: ; preds = %279
br label %318
318: ; preds = %317, %251
br label %319
319: ; preds = %318
%320 = load i32, i32* %8
%321 = add nsw i32 %320, 1
store i32 %321, i32* %8
br label %247
322: ; preds = %247
store i32 0, i32* %8
br label %323
323: ; preds = %346, %322
%324 = load i32, i32* %8
%325 = icmp slt i32 %324, 5
br i1 %325, label %326, label %349
326: ; preds = %323
%327 = load i32, i32* %7
%328 = load i32*, i32** %19
%329 = load i32, i32* %20
%330 = mul nsw i32 %329, 2
%331 = add nsw i32 %330, 0
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds i32, i32* %328, i64 %332
store i32 %327, i32* %333
%334 = load i32, i32* %8
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds [5 x i32], [5 x i32]* %23, i64 0, i64 %335
%337 = load i32, i32* %336
%338 = load i32*, i32** %19
%339 = load i32, i32* %20
%340 = mul nsw i32 %339, 2
%341 = add nsw i32 %340, 1
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds i32, i32* %338, i64 %342
store i32 %337, i32* %343
%344 = load i32, i32* %20
%345 = add nsw i32 %344, 1
store i32 %345, i32* %20
br label %346
346: ; preds = %326
%347 = load i32, i32* %8
%348 = add nsw i32 %347, 1
store i32 %348, i32* %8
br label %323
349: ; preds = %323
br label %350
350: ; preds = %349
%351 = load i32, i32* %7
%352 = add nsw i32 %351, 1
store i32 %352, i32* %7
br label %184
353: ; preds = %184
%354 = load double*, double** %16
%355 = bitcast double* %354 to i8*
store i32 0, i32* %26
store i32 0, i32* %27
%356 = load i32, i32* %6
%357 = load i32, i32* %6
%358 = mul nsw i32 %356, %357
%359 = sext i32 %358 to i64
%360 = mul i64 %359, 8
%361 = call i8* @malloc(i64 %360)
%362 = bitcast i8* %361 to double*
store double* %362, double** %25
store i32 0, i32* %7
br label %363
363: ; preds = %374, %353
%364 = load i32, i32* %7
%365 = load i32, i32* %6
%366 = load i32, i32* %6
%367 = mul nsw i32 %365, %366
%368 = icmp slt i32 %364, %367
br i1 %368, label %369, label %377
369: ; preds = %363
%370 = load double*, double** %25
%371 = load i32, i32* %7
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds double, double* %370, i64 %372
store double 0.000000e+00, double* %373
br label %374
374: ; preds = %369
%375 = load i32, i32* %7
%376 = add nsw i32 %375, 1
store i32 %376, i32* %7
br label %363
377: ; preds = %363
store i32 0, i32* %7
br label %378
378: ; preds = %874, %377
%379 = load i32, i32* %7
%380 = load i32, i32* %6
%381 = icmp slt i32 %379, %380
br i1 %381, label %382, label %877
382: ; preds = %378
%383 = load i32, i32* %7
%384 = add nsw i32 %383, 1
store i32 %384, i32* %8
br label %385
385: ; preds = %870, %382
%386 = load i32, i32* %8
%387 = load i32, i32* %6
%388 = icmp slt i32 %386, %387
br i1 %388, label %389, label %873
389: ; preds = %385
store double 0.000000e+00, double* %31
store double 0.000000e+00, double* %32
%390 = call i8* @malloc(i64 1280000)
%391 = bitcast i8* %390 to double*
store double* %391, double** %28
%392 = call i8* @malloc(i64 3200)
%393 = bitcast i8* %392 to double*
store double* %393, double** %29
%394 = call i8* @malloc(i64 3200)
%395 = bitcast i8* %394 to double*
store double* %395, double** %30
store i32 0, i32* %33
store i32 0, i32* %34
store i32 0, i32* %35
store i32 0, i32* %36
store i32 0, i32* %9
br label %396
396: ; preds = %404, %389
%397 = load i32, i32* %9
%398 = icmp slt i32 %397, 160000
br i1 %398, label %399, label %407
399: ; preds = %396
%400 = load double*, double** %28
%401 = load i32, i32* %9
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds double, double* %400, i64 %402
store double 0.000000e+00, double* %403
br label %404
404: ; preds = %399
%405 = load i32, i32* %9
%406 = add nsw i32 %405, 1
store i32 %406, i32* %9
br label %396
407: ; preds = %396
store i32 0, i32* %9
br label %408
408: ; preds = %420, %407
%409 = load i32, i32* %9
%410 = icmp slt i32 %409, 400
br i1 %410, label %411, label %423
411: ; preds = %408
%412 = load double*, double** %29
%413 = load i32, i32* %9
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds double, double* %412, i64 %414
store double 0.000000e+00, double* %415
%416 = load double*, double** %30
%417 = load i32, i32* %9
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds double, double* %416, i64 %418
store double 0.000000e+00, double* %419
br label %420
420: ; preds = %411
%421 = load i32, i32* %9
%422 = add nsw i32 %421, 1
store i32 %422, i32* %9
br label %408
423: ; preds = %408
store i32 0, i32* %9
br label %424
424: ; preds = %668, %423
%425 = load i32, i32* %9
%426 = load i32, i32* %5
%427 = mul nsw i32 5, %426
%428 = icmp slt i32 %425, %427
br i1 %428, label %429, label %671
429: ; preds = %424
%430 = load i32*, i32** %19
%431 = load i32, i32* %9
%432 = mul nsw i32 %431, 2
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds i32, i32* %430, i64 %433
%435 = load i32, i32* %434
store i32 %435, i32* %26
%436 = load i32*, i32** %19
%437 = load i32, i32* %9
%438 = mul nsw i32 %437, 2
%439 = add nsw i32 %438, 1
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds i32, i32* %436, i64 %440
%442 = load i32, i32* %441
store i32 %442, i32* %27
%443 = load i8*, i8** %4
%444 = load i32, i32* %26
%445 = load i32, i32* %6
%446 = mul nsw i32 %444, %445
%447 = load i32, i32* %7
%448 = add nsw i32 %446, %447
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds i8, i8* %443, i64 %449
%451 = load i8, i8* %450
%452 = sext i8 %451 to i32
%453 = icmp ne i32 %452, 45
br i1 %453, label %454, label %667
454: ; preds = %429
%455 = load i8*, i8** %4
%456 = load i32, i32* %26
%457 = load i32, i32* %6
%458 = mul nsw i32 %456, %457
%459 = load i32, i32* %8
%460 = add nsw i32 %458, %459
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds i8, i8* %455, i64 %461
%463 = load i8, i8* %462
%464 = sext i8 %463 to i32
%465 = icmp ne i32 %464, 45
br i1 %465, label %466, label %667
466: ; preds = %454
%467 = load i8*, i8** %4
%468 = load i32, i32* %27
%469 = load i32, i32* %6
%470 = mul nsw i32 %468, %469
%471 = load i32, i32* %7
%472 = add nsw i32 %470, %471
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds i8, i8* %467, i64 %473
%475 = load i8, i8* %474
%476 = sext i8 %475 to i32
%477 = icmp ne i32 %476, 45
br i1 %477, label %478, label %667
478: ; preds = %466
%479 = load i8*, i8** %4
%480 = load i32, i32* %27
%481 = load i32, i32* %6
%482 = mul nsw i32 %480, %481
%483 = load i32, i32* %8
%484 = add nsw i32 %482, %483
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds i8, i8* %479, i64 %485
%487 = load i8, i8* %486
%488 = sext i8 %487 to i32
%489 = icmp ne i32 %488, 45
br i1 %489, label %490, label %667
490: ; preds = %478
store i32 0, i32* %33
store i32 0, i32* %34
store i32 0, i32* %35
store i32 0, i32* %36
store i32 0, i32* %10
br label %491
491: ; preds = %514, %490
%492 = load i32, i32* %10
%493 = icmp slt i32 %492, 20
br i1 %493, label %494, label %517
494: ; preds = %491
%495 = load i32, i32* %10
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds [20 x i8], [20 x i8]* %14, i64 0, i64 %496
%498 = load i8, i8* %497
%499 = sext i8 %498 to i32
%500 = load i8*, i8** %4
%501 = load i32, i32* %26
%502 = load i32, i32* %6
%503 = mul nsw i32 %501, %502
%504 = load i32, i32* %7
%505 = add nsw i32 %503, %504
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds i8, i8* %500, i64 %506
%508 = load i8, i8* %507
%509 = sext i8 %508 to i32
%510 = icmp eq i32 %499, %509
br i1 %510, label %511, label %513
511: ; preds = %494
%512 = load i32, i32* %10
store i32 %512, i32* %33
br label %517
513: ; preds = %494
br label %514
514: ; preds = %513
%515 = load i32, i32* %10
%516 = add nsw i32 %515, 1
store i32 %516, i32* %10
br label %491
517: ; preds = %511, %491
store i32 0, i32* %10
br label %518
518: ; preds = %541, %517
%519 = load i32, i32* %10
%520 = icmp slt i32 %519, 20
br i1 %520, label %521, label %544
521: ; preds = %518
%522 = load i32, i32* %10
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds [20 x i8], [20 x i8]* %14, i64 0, i64 %523
%525 = load i8, i8* %524
%526 = sext i8 %525 to i32
%527 = load i8*, i8** %4
%528 = load i32, i32* %27
%529 = load i32, i32* %6
%530 = mul nsw i32 %528, %529
%531 = load i32, i32* %7
%532 = add nsw i32 %530, %531
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds i8, i8* %527, i64 %533
%535 = load i8, i8* %534
%536 = sext i8 %535 to i32
%537 = icmp eq i32 %526, %536
br i1 %537, label %538, label %540
538: ; preds = %521
%539 = load i32, i32* %10
store i32 %539, i32* %34
br label %544
540: ; preds = %521
br label %541
541: ; preds = %540
%542 = load i32, i32* %10
%543 = add nsw i32 %542, 1
store i32 %543, i32* %10
br label %518
544: ; preds = %538, %518
store i32 0, i32* %10
br label %545
545: ; preds = %568, %544
%546 = load i32, i32* %10
%547 = icmp slt i32 %546, 20
br i1 %547, label %548, label %571
548: ; preds = %545
%549 = load i32, i32* %10
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds [20 x i8], [20 x i8]* %14, i64 0, i64 %550
%552 = load i8, i8* %551
%553 = sext i8 %552 to i32
%554 = load i8*, i8** %4
%555 = load i32, i32* %26
%556 = load i32, i32* %6
%557 = mul nsw i32 %555, %556
%558 = load i32, i32* %8
%559 = add nsw i32 %557, %558
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds i8, i8* %554, i64 %560
%562 = load i8, i8* %561
%563 = sext i8 %562 to i32
%564 = icmp eq i32 %553, %563
br i1 %564, label %565, label %567
565: ; preds = %548
%566 = load i32, i32* %10
store i32 %566, i32* %35
br label %571
567: ; preds = %548
br label %568
568: ; preds = %567
%569 = load i32, i32* %10
%570 = add nsw i32 %569, 1
store i32 %570, i32* %10
br label %545
571: ; preds = %565, %545
store i32 0, i32* %10
br label %572
572: ; preds = %595, %571
%573 = load i32, i32* %10
%574 = icmp slt i32 %573, 20
br i1 %574, label %575, label %598
575: ; preds = %572
%576 = load i32, i32* %10
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds [20 x i8], [20 x i8]* %14, i64 0, i64 %577
%579 = load i8, i8* %578
%580 = sext i8 %579 to i32
%581 = load i8*, i8** %4
%582 = load i32, i32* %27
%583 = load i32, i32* %6
%584 = mul nsw i32 %582, %583
%585 = load i32, i32* %8
%586 = add nsw i32 %584, %585
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds i8, i8* %581, i64 %587
%589 = load i8, i8* %588
%590 = sext i8 %589 to i32
%591 = icmp eq i32 %580, %590
br i1 %591, label %592, label %594
592: ; preds = %575
%593 = load i32, i32* %10
store i32 %593, i32* %36
br label %598
594: ; preds = %575
br label %595
595: ; preds = %594
%596 = load i32, i32* %10
%597 = add nsw i32 %596, 1
store i32 %597, i32* %10
br label %572
598: ; preds = %592, %572
%599 = load double*, double** %28
%600 = load i32, i32* %33
%601 = mul nsw i32 %600, 20
%602 = load i32, i32* %35
%603 = add nsw i32 %601, %602
%604 = mul nsw i32 %603, 400
%605 = load i32, i32* %34
%606 = mul nsw i32 %605, 20
%607 = load i32, i32* %36
%608 = add nsw i32 %606, %607
%609 = add nsw i32 %604, %608
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds double, double* %599, i64 %610
%612 = load double, double* %611
%613 = fadd double %612, 1.000000e+00
store double %613, double* %611
%614 = load double*, double** %28
%615 = load i32, i32* %34
%616 = mul nsw i32 %615, 20
%617 = load i32, i32* %36
%618 = add nsw i32 %616, %617
%619 = mul nsw i32 %618, 400
%620 = load i32, i32* %33
%621 = mul nsw i32 %620, 20
%622 = load i32, i32* %35
%623 = add nsw i32 %621, %622
%624 = add nsw i32 %619, %623
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds double, double* %614, i64 %625
%627 = load double, double* %626
%628 = fadd double %627, 1.000000e+00
store double %628, double* %626
%629 = load double*, double** %29
%630 = load i32, i32* %33
%631 = mul nsw i32 %630, 20
%632 = load i32, i32* %34
%633 = add nsw i32 %631, %632
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds double, double* %629, i64 %634
%636 = load double, double* %635
%637 = fadd double %636, 1.000000e+00
store double %637, double* %635
%638 = load double*, double** %29
%639 = load i32, i32* %34
%640 = mul nsw i32 %639, 20
%641 = load i32, i32* %33
%642 = add nsw i32 %640, %641
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds double, double* %638, i64 %643
%645 = load double, double* %644
%646 = fadd double %645, 1.000000e+00
store double %646, double* %644
%647 = load double*, double** %30
%648 = load i32, i32* %35
%649 = mul nsw i32 %648, 20
%650 = load i32, i32* %36
%651 = add nsw i32 %649, %650
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds double, double* %647, i64 %652
%654 = load double, double* %653
%655 = fadd double %654, 1.000000e+00
store double %655, double* %653
%656 = load double*, double** %30
%657 = load i32, i32* %36
%658 = mul nsw i32 %657, 20
%659 = load i32, i32* %35
%660 = add nsw i32 %658, %659
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds double, double* %656, i64 %661
%663 = load double, double* %662
%664 = fadd double %663, 1.000000e+00
store double %664, double* %662
%665 = load double, double* %31
%666 = fadd double %665, 2.000000e+00
store double %666, double* %31
br label %667
667: ; preds = %598, %478, %466, %454, %429
br label %668
668: ; preds = %667
%669 = load i32, i32* %9
%670 = add nsw i32 %669, 1
store i32 %670, i32* %9
br label %424
671: ; preds = %424
%672 = load double, double* %31
%673 = fcmp une double %672, 0.000000e+00
br i1 %673, label %674, label %724
674: ; preds = %671
store i32 0, i32* %9
br label %675
675: ; preds = %690, %674
%676 = load i32, i32* %9
%677 = icmp slt i32 %676, 160000
br i1 %677, label %678, label %693
678: ; preds = %675
%679 = load double*, double** %28
%680 = load i32, i32* %9
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds double, double* %679, i64 %681
%683 = load double, double* %682
%684 = load double, double* %31
%685 = fdiv double %683, %684
%686 = load double*, double** %28
%687 = load i32, i32* %9
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds double, double* %686, i64 %688
store double %685, double* %689
br label %690
690: ; preds = %678
%691 = load i32, i32* %9
%692 = add nsw i32 %691, 1
store i32 %692, i32* %9
br label %675
693: ; preds = %675
store i32 0, i32* %9
br label %694
694: ; preds = %720, %693
%695 = load i32, i32* %9
%696 = icmp slt i32 %695, 400
br i1 %696, label %697, label %723
697: ; preds = %694
%698 = load double*, double** %29
%699 = load i32, i32* %9
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds double, double* %698, i64 %700
%702 = load double, double* %701
%703 = load double, double* %31
%704 = fdiv double %702, %703
%705 = load double*, double** %29
%706 = load i32, i32* %9
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds double, double* %705, i64 %707
store double %704, double* %708
%709 = load double*, double** %30
%710 = load i32, i32* %9
%711 = sext i32 %710 to i64
%712 = getelementptr inbounds double, double* %709, i64 %711
%713 = load double, double* %712
%714 = load double, double* %31
%715 = fdiv double %713, %714
%716 = load double*, double** %30
%717 = load i32, i32* %9
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds double, double* %716, i64 %718
store double %715, double* %719
br label %720
720: ; preds = %697
%721 = load i32, i32* %9
%722 = add nsw i32 %721, 1
store i32 %722, i32* %9
br label %694
723: ; preds = %694
br label %724
724: ; preds = %723, %671
store double 0.000000e+00, double* %31
store i32 0, i32* %10
br label %725
725: ; preds = %842, %724
%726 = load i32, i32* %10
%727 = icmp slt i32 %726, 20
br i1 %727, label %728, label %845
728: ; preds = %725
store i32 0, i32* %11
br label %729
729: ; preds = %838, %728
%730 = load i32, i32* %11
%731 = icmp slt i32 %730, 20
br i1 %731, label %732, label %841
732: ; preds = %729
%733 = load double*, double** %29
%734 = load i32, i32* %10
%735 = mul nsw i32 %734, 20
%736 = load i32, i32* %11
%737 = add nsw i32 %735, %736
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds double, double* %733, i64 %738
%740 = load double, double* %739
%741 = fcmp oeq double %740, 0.000000e+00
br i1 %741, label %742, label %743
742: ; preds = %732
br label %838
743: ; preds = %732
store i32 0, i32* %12
br label %744
744: ; preds = %833, %743
%745 = load i32, i32* %12
%746 = icmp slt i32 %745, 20
br i1 %746, label %747, label %836
747: ; preds = %744
store i32 0, i32* %13
br label %748
748: ; preds = %829, %747
%749 = load i32, i32* %13
%750 = icmp slt i32 %749, 20
br i1 %750, label %751, label %832
751: ; preds = %748
%752 = load double*, double** %30
%753 = load i32, i32* %12
%754 = mul nsw i32 %753, 20
%755 = load i32, i32* %13
%756 = add nsw i32 %754, %755
%757 = sext i32 %756 to i64
%758 = getelementptr inbounds double, double* %752, i64 %757
%759 = load double, double* %758
%760 = fcmp oeq double %759, 0.000000e+00
br i1 %760, label %777, label %761
761: ; preds = %751
%762 = load double*, double** %28
%763 = load i32, i32* %10
%764 = mul nsw i32 %763, 20
%765 = load i32, i32* %12
%766 = add nsw i32 %764, %765
%767 = mul nsw i32 %766, 400
%768 = load i32, i32* %11
%769 = mul nsw i32 %768, 20
%770 = load i32, i32* %13
%771 = add nsw i32 %769, %770
%772 = add nsw i32 %767, %771
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds double, double* %762, i64 %773
%775 = load double, double* %774
%776 = fcmp oeq double %775, 0.000000e+00
br i1 %776, label %777, label %778
777: ; preds = %761, %751
br label %829
778: ; preds = %761
%779 = load double*, double** %28
%780 = load i32, i32* %10
%781 = mul nsw i32 %780, 20
%782 = load i32, i32* %12
%783 = add nsw i32 %781, %782
%784 = mul nsw i32 %783, 400
%785 = load i32, i32* %11
%786 = mul nsw i32 %785, 20
%787 = load i32, i32* %13
%788 = add nsw i32 %786, %787
%789 = add nsw i32 %784, %788
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds double, double* %779, i64 %790
%792 = load double, double* %791
%793 = load double*, double** %28
%794 = load i32, i32* %10
%795 = mul nsw i32 %794, 20
%796 = load i32, i32* %12
%797 = add nsw i32 %795, %796
%798 = mul nsw i32 %797, 400
%799 = load i32, i32* %11
%800 = mul nsw i32 %799, 20
%801 = load i32, i32* %13
%802 = add nsw i32 %800, %801
%803 = add nsw i32 %798, %802
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds double, double* %793, i64 %804
%806 = load double, double* %805
%807 = load double*, double** %29
%808 = load i32, i32* %10
%809 = mul nsw i32 %808, 20
%810 = load i32, i32* %11
%811 = add nsw i32 %809, %810
%812 = sext i32 %811 to i64
%813 = getelementptr inbounds double, double* %807, i64 %812
%814 = load double, double* %813
%815 = fdiv double %806, %814
%816 = load double*, double** %30
%817 = load i32, i32* %12
%818 = mul nsw i32 %817, 20
%819 = load i32, i32* %13
%820 = add nsw i32 %818, %819
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds double, double* %816, i64 %821
%823 = load double, double* %822
%824 = fdiv double %815, %823
%825 = call double @log(double %824)
%826 = load double, double* %31
%827 = call double @llvm.fmuladd.f64(double %792, double %825, double %826)
store double %827, double* %31
br label %828
828: ; preds = %778
br label %829
829: ; preds = %828, %777
%830 = load i32, i32* %13
%831 = add nsw i32 %830, 1
store i32 %831, i32* %13
br label %748
832: ; preds = %748
br label %833
833: ; preds = %832
%834 = load i32, i32* %12
%835 = add nsw i32 %834, 1
store i32 %835, i32* %12
br label %744
836: ; preds = %744
br label %837
837: ; preds = %836
br label %838
838: ; preds = %837, %742
%839 = load i32, i32* %11
%840 = add nsw i32 %839, 1
store i32 %840, i32* %11
br label %729
841: ; preds = %729
br label %842
842: ; preds = %841
%843 = load i32, i32* %10
%844 = add nsw i32 %843, 1
store i32 %844, i32* %10
br label %725
845: ; preds = %725
%846 = load double, double* %31
%847 = load double*, double** %25
%848 = load i32, i32* %7
%849 = load i32, i32* %6
%850 = mul nsw i32 %848, %849
%851 = load i32, i32* %8
%852 = add nsw i32 %850, %851
%853 = sext i32 %852 to i64
%854 = getelementptr inbounds double, double* %847, i64 %853
store double %846, double* %854
%855 = load double, double* %31
%856 = load double*, double** %25
%857 = load i32, i32* %8
%858 = load i32, i32* %6
%859 = mul nsw i32 %857, %858
%860 = load i32, i32* %7
%861 = add nsw i32 %859, %860
%862 = sext i32 %861 to i64
%863 = getelementptr inbounds double, double* %856, i64 %862
store double %855, double* %863
%864 = load double*, double** %28
%865 = bitcast double* %864 to i8*
%866 = load double*, double** %29
%867 = bitcast double* %866 to i8*
%868 = load double*, double** %30
%869 = bitcast double* %868 to i8*
br label %870
870: ; preds = %845
%871 = load i32, i32* %8
%872 = add nsw i32 %871, 1
store i32 %872, i32* %8
br label %385
873: ; preds = %385
br label %874
874: ; preds = %873
%875 = load i32, i32* %7
%876 = add nsw i32 %875, 1
store i32 %876, i32* %7
br label %378
877: ; preds = %378
%878 = load i32*, i32** %19
%879 = bitcast i32* %878 to i8*
%880 = load double*, double** %25
ret double* %880
}

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