#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 log(double);
double *malloc(int);
double *calcMI(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'};
  int resnum = sizeof(reslist) / sizeof(char);
  double p[l][resnum];
  double *mi;
  mi = malloc(l * l * sizeof(double));
  for (i = 0; i < l; i++)
    for (j = 0; j < resnum; j++)
      p[i][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][k]++;
          count++;
          break;
        }
    for (k = 0; k < resnum; k++)
      p[i][k] = p[i][k] / n;
  }
  for (i = 0; i < l; i++) {
    mi[i * l + i] = 0;
    for (j = i + 1; j < l; j++) {
      double add = 0;
      for (k1 = 0; k1 < resnum; k1++)
        for (k2 = 0; k2 < resnum; k2++) {
          if ((p[i][k1] != 0.0) && (p[j][k2] != 0.0)) {
            double count = 0;
            for (k = 0; k < n; k++) {
              if ((m[k * l + i] == reslist[k1]) &&
                  (m[k * l + j] == reslist[k2]))
                count++;
            }
            if (count != 0.0) {
              count = count / n;
              add += count * log(count / p[i][k1] / p[j][k2]);
            }
          }
        }
      mi[i * l + j] = add;
      mi[j * l + i] = add;
    }
  }
  return mi;
}


x86 assembly (clang, -O0):
<calcMI>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movabs $0x5957565453525150,%rax
56 57 59
mov    %rax,-0x33(%rbp)
movaps 0xec6(%rip),%xmm0
movaps %xmm0,-0x40(%rbp)
movl   $0x15,-0x44(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
mov    %rax,-0x90(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x50(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x88(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x58(%rbp)
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%eax
imul   -0x10(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    121e <calcMI+0xfe>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    120b <calcMI+0xeb>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movslq -0x14(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%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    11c8 <calcMI+0xa8>
jmp    1210 <calcMI+0xf0>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11b5 <calcMI+0x95>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1373 <calcMI+0x253>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12f5 <calcMI+0x1d5>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    12e2 <calcMI+0x1c2>
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    12cf <calcMI+0x1af>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movslq -0x14(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  0xd52(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xd40(%rip),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    12e2 <calcMI+0x1c2>
jmp    12d4 <calcMI+0x1b4>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1253 <calcMI+0x133>
jmp    12e7 <calcMI+0x1c7>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1240 <calcMI+0x120>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1360 <calcMI+0x240>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movslq -0x14(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x1c(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
movslq -0x14(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12fc <calcMI+0x1dc>
jmp    1365 <calcMI+0x245>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1225 <calcMI+0x105>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1611 <calcMI+0x4f1>
mov    -0x68(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%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    -0x10(%rbp),%eax
jge    15fe <calcMI+0x4de>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    15ba <calcMI+0x49a>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    15a7 <calcMI+0x487>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movslq -0x14(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1420 <calcMI+0x300>
jp     1420 <calcMI+0x300>
jmp    1594 <calcMI+0x474>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    145e <calcMI+0x33e>
jp     145e <calcMI+0x33e>
jmp    1594 <calcMI+0x474>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14ea <calcMI+0x3ca>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movslq -0x20(%rbp),%rcx
movsbl -0x40(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    14d7 <calcMI+0x3b7>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movslq -0x24(%rbp),%rcx
movsbl -0x40(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    14d7 <calcMI+0x3b7>
movsd  0xb33(%rip),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    14dc <calcMI+0x3bc>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    146d <calcMI+0x34d>
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1507 <calcMI+0x3e7>
jp     1507 <calcMI+0x3e7>
jmp    158f <calcMI+0x46f>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movsd  -0x80(%rbp),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movslq -0x14(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x20(%rbp),%rsi
divsd  (%rcx,%rsi,8),%xmm0
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
call   1040 <log@plt>
movaps %xmm0,%xmm2
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1594 <calcMI+0x474>
jmp    1599 <calcMI+0x479>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13d6 <calcMI+0x2b6>
jmp    15ac <calcMI+0x48c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13c3 <calcMI+0x2a3>
movsd  -0x78(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x68(%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    13a8 <calcMI+0x288>
jmp    1603 <calcMI+0x4e3>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    137a <calcMI+0x25a>
mov    -0x68(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    %rcx,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calcMI>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %edx,%ebx
mov    %esi,%r14d
mov    %rdi,%r15
mov    %edx,%r12d
mov    %rsp,%rcx
imul   $0xa8,%r12,%r13
lea    0xf(%r13),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x30(%rbp)
mov    %rcx,%rsp
mov    %edx,%edi
imul   %edx,%edi
shl    $0x3,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    %ebx,-0x34(%rbp)
test   %ebx,%ebx
jle    15b4 <calcMI+0x484>
mov    %r14d,%ecx
xor    %r14d,%r14d
mov    -0x30(%rbp),%rdi
xor    %esi,%esi
mov    %r13,%rdx
mov    %ecx,-0x38(%rbp)
call   1030 <memset@plt>
mov    -0x38(%rbp),%r9d
cvtsi2sd %r9d,%xmm0
mov    %r9d,%eax
mov    %rax,-0x48(%rbp)
movapd %xmm0,-0xd0(%rbp)
ff
unpcklpd %xmm0,%xmm0
movabs $0x16fbdfd00001,%rdi
lea    0xe5d(%rip),%r8
movsd  0xe2d(%rip),%xmm5
mov    %r15,-0x68(%rbp)
jmp    12b5 <calcMI+0x185>
nopl   0x0(%rax)
mov    -0x30(%rbp),%rax
movupd (%rax,%rsi,8),%xmm1
movupd 0x10(%rax,%rsi,8),%xmm2
movupd 0x20(%rax,%rsi,8),%xmm3
movupd 0x30(%rax,%rsi,8),%xmm4
divpd  %xmm0,%xmm1
movupd %xmm1,(%rax,%rsi,8)
divpd  %xmm0,%xmm2
movupd %xmm2,0x10(%rax,%rsi,8)
divpd  %xmm0,%xmm3
movupd %xmm3,0x20(%rax,%rsi,8)
divpd  %xmm0,%xmm4
movupd %xmm4,0x30(%rax,%rsi,8)
movupd 0x40(%rax,%rsi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x40(%rax,%rsi,8)
movupd 0x50(%rax,%rsi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x50(%rax,%rsi,8)
movupd 0x60(%rax,%rsi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x60(%rax,%rsi,8)
movupd 0x70(%rax,%rsi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x70(%rax,%rsi,8)
movupd 0x80(%rax,%rsi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x80(%rax,%rsi,8)
movupd 0x90(%rax,%rsi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,0x90(%rax,%rsi,8)
movsd  0xa0(%rax,%rsi,8),%xmm1
divsd  -0xd0(%rbp),%xmm1
ff
movsd  %xmm1,0xa0(%rax,%rsi,8)
add    $0x1,%r14
add    $0x1,%r15
cmp    %r12,%r14
je     1319 <calcMI+0x1e9>
lea    (%r14,%r14,4),%rax
lea    (%r14,%rax,4),%rsi
test   %r9d,%r9d
jle    11e0 <calcMI+0xb0>
mov    -0x30(%rbp),%rax
lea    (%rax,%rsi,8),%r11
mov    -0x48(%rbp),%rcx
mov    %r15,%rdx
jmp    12ed <calcMI+0x1bd>
nopw   0x0(%rax,%rax,1)
add    %r12,%rdx
add    $0xffffffffffffffff,%rcx
je     11e0 <calcMI+0xb0>
movzbl (%rdx),%eax
add    $0xd3,%al
cmp    $0x2c,%al
ja     12e0 <calcMI+0x1b0>
movzbl %al,%ebx
bt     %rbx,%rdi
jae    12e0 <calcMI+0x1b0>
movsbq %al,%rax
mov    (%r8,%rax,8),%rax
movsd  (%r11,%rax,8),%xmm1
addsd  %xmm5,%xmm1
movsd  %xmm1,(%r11,%rax,8)
jmp    12e0 <calcMI+0x1b0>
cmpl   $0x0,-0x34(%rbp)
mov    -0x68(%rbp),%r8
jle    15b4 <calcMI+0x484>
mov    -0x48(%rbp),%rax
mov    %eax,%esi
and    $0xfffffffe,%esi
lea    0x1(%r12),%rax
mov    %rax,-0x58(%rbp)
lea    (%r12,%r12,1),%r14
mov    $0x1,%eax
mov    %rax,-0x50(%rbp)
xor    %r13d,%r13d
xorpd  %xmm2,%xmm2
lea    0xcbc(%rip),%rdi
mov    %r12,%r15
mov    %r12,-0x60(%rbp)
jmp    137b <calcMI+0x24b>
nopl   (%rax)
addq   $0x1,-0x50(%rbp)
addq   $0x1,-0x58(%rbp)
add    $0x1,%r15
mov    -0x80(%rbp),%r13
cmp    %r12,%r13
je     15b4 <calcMI+0x484>
mov    %r13d,%eax
imul   -0x34(%rbp),%eax
cltq
add    %r13,%rax
mov    -0x40(%rbp),%rcx
movq   $0x0,(%rcx,%rax,8)
lea    0x1(%r13),%rax
mov    %rax,-0x80(%rbp)
cmp    %r12,%rax
jae    1360 <calcMI+0x230>
mov    %r13,%rax
imul   %r12,%rax
mov    %rax,-0x88(%rbp)
imul   $0xa8,%r13,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x58(%rbp),%r10
mov    -0x50(%rbp),%r11
jmp    1407 <calcMI+0x2d7>
nopw   0x0(%rax,%rax,1)
mov    -0x88(%rbp),%rax
add    %r11,%rax
mov    -0x40(%rbp),%rcx
movsd  %xmm3,(%rcx,%rax,8)
mov    %r11,%rax
mov    -0x60(%rbp),%r12
imul   %r12,%rax
add    %r13,%rax
movsd  %xmm3,(%rcx,%rax,8)
add    $0x1,%r11
add    $0x1,%r10
cmp    %r12,%r11
je     1360 <calcMI+0x230>
imul   $0xa8,%r11,%rcx
add    -0x30(%rbp),%rcx
xorpd  %xmm3,%xmm3
xor    %edx,%edx
mov    %rcx,-0x70(%rbp)
mov    %r10,-0xa0(%rbp)
mov    %r11,-0x98(%rbp)
jmp    143a <calcMI+0x30a>
nopl   0x0(%rax)
add    $0x1,%rdx
cmp    $0x15,%rdx
je     13d0 <calcMI+0x2a0>
mov    -0x90(%rbp),%rax
movsd  (%rax,%rdx,8),%xmm4
xor    %r12d,%r12d
mov    %rdx,-0x78(%rbp)
movsd  %xmm4,-0xa8(%rbp)
ff
jmp    1472 <calcMI+0x342>
nopw   0x0(%rax,%rax,1)
mov    -0x70(%rbp),%rcx
mov    -0x78(%rbp),%rdx
add    $0x1,%r12
cmp    $0x15,%r12
je     1430 <calcMI+0x300>
ucomisd %xmm2,%xmm4
jne    147a <calcMI+0x34a>
jnp    1468 <calcMI+0x338>
movsd  (%rcx,%r12,8),%xmm1
ucomisd %xmm2,%xmm1
jne    1488 <calcMI+0x358>
jnp    1468 <calcMI+0x338>
test   %r9d,%r9d
jle    1468 <calcMI+0x338>
mov    (%rdx,%rdi,1),%al
xorpd  %xmm6,%xmm6
cmp    $0x1,%r9d
jne    1553 <calcMI+0x423>
xor    %ecx,%ecx
testb  $0x1,-0x48(%rbp)
je     14d2 <calcMI+0x3a2>
imul   -0x60(%rbp),%rcx
lea    (%rcx,%r13,1),%rdx
cmp    %al,(%r8,%rdx,1)
jne    14d2 <calcMI+0x3a2>
add    %r11,%rcx
mov    (%r8,%rcx,1),%al
movapd %xmm6,%xmm0
addsd  %xmm5,%xmm0
cmp    (%r12,%rdi,1),%al
je     14ce <calcMI+0x39e>
movapd %xmm6,%xmm0
movapd %xmm0,%xmm6
ucomisd %xmm2,%xmm6
jne    14da <calcMI+0x3aa>
jnp    1460 <calcMI+0x330>
divsd  -0xd0(%rbp),%xmm6
ff
movsd  %xmm6,-0xb0(%rbp)
ff
movapd %xmm6,%xmm0
divsd  %xmm4,%xmm0
divsd  %xmm1,%xmm0
mov    %rsi,%rbx
movsd  %xmm3,-0xb8(%rbp)
call   1050 <log@plt>
movsd  -0xa8(%rbp),%xmm4
ff
movsd  -0xb8(%rbp),%xmm3
ff
mov    -0x98(%rbp),%r11
mov    -0xa0(%rbp),%r10
lea    0xae5(%rip),%rdi
xorpd  %xmm2,%xmm2
mov    %rbx,%rsi
movsd  0xac6(%rip),%xmm5
mov    -0x68(%rbp),%r8
mov    -0x38(%rbp),%r9d
mulsd  -0xb0(%rbp),%xmm0
ff
addsd  %xmm0,%xmm3
jmp    1460 <calcMI+0x330>
mov    %r8,%rdx
xor    %ecx,%ecx
jmp    1574 <calcMI+0x444>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm6
add    $0x2,%rcx
add    %r14,%rdx
cmp    %rcx,%rsi
je     14a0 <calcMI+0x370>
cmp    %al,(%rdx,%r13,1)
jne    1595 <calcMI+0x465>
movzbl (%rdx,%r11,1),%ebx
movapd %xmm6,%xmm0
addsd  %xmm5,%xmm0
cmp    (%r12,%rdi,1),%bl
je     1591 <calcMI+0x461>
movapd %xmm6,%xmm0
movapd %xmm0,%xmm6
cmp    %al,(%rdx,%r15,1)
jne    1564 <calcMI+0x434>
movzbl (%rdx,%r10,1),%ebx
movapd %xmm6,%xmm0
addsd  %xmm5,%xmm0
cmp    (%r12,%rdi,1),%bl
je     1560 <calcMI+0x430>
movapd %xmm6,%xmm0
jmp    1560 <calcMI+0x430>
mov    -0x40(%rbp),%rax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@__const.calcMI.reslist = [21 x i8] c"-ACDEFGHIKLMNPQRSTVWY"
@switch.table.calcMI = [45 x i64] [i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 1, i64 0, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, i64 0, i64 9, i64 10, i64 11, i64 12, i64 0, i64 13, i64 14, i64 15, i64 16, i64 17, i64 0, i64 18, i64 19, i64 0, i64 20]
define noalias double* @calcMI(i8* nocapture %0, i32 %1, i32 %2) {
%4 = zext i32 %2 to i64
%5 = mul nuw nsw i64 %4, 21
%6 = alloca double, i64 %5
%7 = shl i32 %2, 3
%8 = mul i32 %7, %2
%9 = tail call double* @malloc(i32 %8)
%10 = icmp sgt i32 %2, 0
br i1 %10, label %11, label %232
11: ; preds = %3
%12 = bitcast double* %6 to i8*
%13 = mul nuw nsw i64 %4, 168
%14 = icmp sgt i32 %1, 0
%15 = sitofp i32 %1 to double
%16 = zext i32 %2 to i64
%17 = zext i32 %1 to i64
%18 = insertelement <2 x double> poison, double %15, i64 0
%19 = shufflevector <2 x double> %18, <2 x double> poison, <2 x i32> zeroinitializer
br label %20
20: ; preds = %11, %34
%21 = phi i64 [ 0, %11 ], [ %88, %34 ]
%22 = mul nuw nsw i64 %21, 21
br i1 %14, label %23, label %34
23: ; preds = %20
%24 = getelementptr inbounds double, double* %6, i64 %22
br label %90
25: ; preds = %34
br i1 %10, label %26, label %232
26: ; preds = %25
%27 = icmp slt i32 %1, 1
%28 = sitofp i32 %1 to double
%29 = zext i32 %2 to i64
%30 = and i64 %17, 1
%31 = icmp eq i32 %1, 1
%32 = and i64 %17, 4294967294
%33 = icmp eq i64 %30, 0
br label %116
34: ; preds = %110, %20
%35 = getelementptr inbounds double, double* %6, i64 %22
%36 = bitcast double* %35 to <2 x double>*
%37 = load <2 x double>, <2 x double>* %36
%38 = fdiv <2 x double> %37, %19
%39 = bitcast double* %35 to <2 x double>*
store <2 x double> %38, <2 x double>* %39
%40 = getelementptr inbounds double, double* %35, i64 2
%41 = bitcast double* %40 to <2 x double>*
%42 = load <2 x double>, <2 x double>* %41
%43 = fdiv <2 x double> %42, %19
%44 = bitcast double* %40 to <2 x double>*
store <2 x double> %43, <2 x double>* %44
%45 = getelementptr inbounds double, double* %35, i64 4
%46 = bitcast double* %45 to <2 x double>*
%47 = load <2 x double>, <2 x double>* %46
%48 = fdiv <2 x double> %47, %19
%49 = bitcast double* %45 to <2 x double>*
store <2 x double> %48, <2 x double>* %49
%50 = getelementptr inbounds double, double* %35, i64 6
%51 = bitcast double* %50 to <2 x double>*
%52 = load <2 x double>, <2 x double>* %51
%53 = fdiv <2 x double> %52, %19
%54 = bitcast double* %50 to <2 x double>*
store <2 x double> %53, <2 x double>* %54
%55 = getelementptr inbounds double, double* %35, i64 8
%56 = bitcast double* %55 to <2 x double>*
%57 = load <2 x double>, <2 x double>* %56
%58 = fdiv <2 x double> %57, %19
%59 = bitcast double* %55 to <2 x double>*
store <2 x double> %58, <2 x double>* %59
%60 = getelementptr inbounds double, double* %35, i64 10
%61 = bitcast double* %60 to <2 x double>*
%62 = load <2 x double>, <2 x double>* %61
%63 = fdiv <2 x double> %62, %19
%64 = bitcast double* %60 to <2 x double>*
store <2 x double> %63, <2 x double>* %64
%65 = getelementptr inbounds double, double* %35, i64 12
%66 = bitcast double* %65 to <2 x double>*
%67 = load <2 x double>, <2 x double>* %66
%68 = fdiv <2 x double> %67, %19
%69 = bitcast double* %65 to <2 x double>*
store <2 x double> %68, <2 x double>* %69
%70 = getelementptr inbounds double, double* %35, i64 14
%71 = bitcast double* %70 to <2 x double>*
%72 = load <2 x double>, <2 x double>* %71
%73 = fdiv <2 x double> %72, %19
%74 = bitcast double* %70 to <2 x double>*
store <2 x double> %73, <2 x double>* %74
%75 = getelementptr inbounds double, double* %35, i64 16
%76 = bitcast double* %75 to <2 x double>*
%77 = load <2 x double>, <2 x double>* %76
%78 = fdiv <2 x double> %77, %19
%79 = bitcast double* %75 to <2 x double>*
store <2 x double> %78, <2 x double>* %79
%80 = getelementptr inbounds double, double* %35, i64 18
%81 = bitcast double* %80 to <2 x double>*
%82 = load <2 x double>, <2 x double>* %81
%83 = fdiv <2 x double> %82, %19
%84 = bitcast double* %80 to <2 x double>*
store <2 x double> %83, <2 x double>* %84
%85 = getelementptr inbounds double, double* %35, i64 20
%86 = load double, double* %85
%87 = fdiv double %86, %15
store double %87, double* %85
%88 = add nuw nsw i64 %21, 1
%89 = icmp eq i64 %88, %4
br i1 %89, label %25, label %20
90: ; preds = %23, %110
%91 = phi i64 [ 0, %23 ], [ %111, %110 ]
%92 = mul nsw i64 %91, %16
%93 = add nuw nsw i64 %92, %21
%94 = getelementptr inbounds i8, i8* %0, i64 %93
%95 = load i8, i8* %94
%96 = add i8 %95, -45
%97 = icmp ult i8 %96, 45
br i1 %97, label %98, label %110
98: ; preds = %90
%99 = zext i8 %96 to i64
%100 = lshr i64 25271047553025, %99
%101 = and i64 %100, 1
%102 = icmp eq i64 %101, 0
br i1 %102, label %110, label %103
103: ; preds = %98
%104 = sext i8 %96 to i64
%105 = getelementptr inbounds [45 x i64], [45 x i64]* @switch.table.calcMI, i64 0, i64 %104
%106 = load i64, i64* %105
%107 = getelementptr inbounds double, double* %24, i64 %106
%108 = load double, double* %107
%109 = fadd double %108, 1.000000e+00
store double %109, double* %107
br label %110
110: ; preds = %98, %90, %103
%111 = add nuw nsw i64 %91, 1
%112 = icmp eq i64 %111, %17
br i1 %112, label %34, label %90
113: ; preds = %224, %116
%114 = add nuw nsw i64 %118, 1
%115 = icmp eq i64 %125, %4
br i1 %115, label %232, label %116
116: ; preds = %26, %113
%117 = phi i64 [ 0, %26 ], [ %125, %113 ]
%118 = phi i64 [ 1, %26 ], [ %114, %113 ]
%119 = trunc i64 %117 to i32
%120 = mul nsw i64 %117, %29
%121 = mul nsw i32 %119, %2
%122 = sext i32 %121 to i64
%123 = add nsw i64 %117, %122
%124 = getelementptr inbounds double, double* %9, i64 %123
store double 0.000000e+00, double* %124
%125 = add nuw nsw i64 %117, 1
%126 = icmp ult i64 %125, %29
br i1 %126, label %127, label %113
127: ; preds = %116
%128 = mul nuw nsw i64 %117, 21
%129 = getelementptr inbounds double, double* %6, i64 %128
br label %130
130: ; preds = %127, %224
%131 = phi i64 [ %118, %127 ], [ %230, %224 ]
%132 = mul nuw nsw i64 %131, 21
%133 = getelementptr inbounds double, double* %6, i64 %132
br label %134
134: ; preds = %130, %221
%135 = phi i64 [ 0, %130 ], [ %222, %221 ]
%136 = phi double [ 0.000000e+00, %130 ], [ %218, %221 ]
%137 = getelementptr inbounds double, double* %129, i64 %135
%138 = load double, double* %137
%139 = fcmp une double %138, 0.000000e+00
%140 = getelementptr inbounds [21 x i8], [21 x i8]* @__const.calcMI.reslist, i64 0, i64 %135
br label %141
141: ; preds = %134, %217
%142 = phi i64 [ 0, %134 ], [ %219, %217 ]
%143 = phi double [ %136, %134 ], [ %218, %217 ]
br i1 %139, label %144, label %217
144: ; preds = %141
%145 = getelementptr inbounds double, double* %133, i64 %142
%146 = load double, double* %145
%147 = fcmp oeq double %146, 0.000000e+00
%148 = or i1 %147, %27
br i1 %148, label %217, label %149
149: ; preds = %144
%150 = load i8, i8* %140
%151 = getelementptr inbounds [21 x i8], [21 x i8]* @__const.calcMI.reslist, i64 0, i64 %142
br i1 %31, label %190, label %152
152: ; preds = %149, %185
%153 = phi i64 [ %187, %185 ], [ 0, %149 ]
%154 = phi double [ %186, %185 ], [ 0.000000e+00, %149 ]
%155 = phi i64 [ %188, %185 ], [ 0, %149 ]
%156 = mul nsw i64 %153, %29
%157 = add nuw nsw i64 %156, %117
%158 = getelementptr inbounds i8, i8* %0, i64 %157
%159 = load i8, i8* %158
%160 = icmp eq i8 %159, %150
br i1 %160, label %161, label %169
161: ; preds = %152
%162 = add nuw nsw i64 %156, %131
%163 = getelementptr inbounds i8, i8* %0, i64 %162
%164 = load i8, i8* %163
%165 = load i8, i8* %151
%166 = icmp eq i8 %164, %165
%167 = fadd double %154, 1.000000e+00
%168 = select i1 %166, double %167, double %154
br label %169
169: ; preds = %161, %152
%170 = phi double [ %154, %152 ], [ %168, %161 ]
%171 = or i64 %153, 1
%172 = mul nsw i64 %171, %29
%173 = add nuw nsw i64 %172, %117
%174 = getelementptr inbounds i8, i8* %0, i64 %173
%175 = load i8, i8* %174
%176 = icmp eq i8 %175, %150
br i1 %176, label %177, label %185
177: ; preds = %169
%178 = add nuw nsw i64 %172, %131
%179 = getelementptr inbounds i8, i8* %0, i64 %178
%180 = load i8, i8* %179
%181 = load i8, i8* %151
%182 = icmp eq i8 %180, %181
%183 = fadd double %170, 1.000000e+00
%184 = select i1 %182, double %183, double %170
br label %185
185: ; preds = %177, %169
%186 = phi double [ %170, %169 ], [ %184, %177 ]
%187 = add nuw nsw i64 %153, 2
%188 = add i64 %155, 2
%189 = icmp eq i64 %188, %32
br i1 %189, label %190, label %152
190: ; preds = %185, %149
%191 = phi double [ undef, %149 ], [ %186, %185 ]
%192 = phi i64 [ 0, %149 ], [ %187, %185 ]
%193 = phi double [ 0.000000e+00, %149 ], [ %186, %185 ]
br i1 %33, label %208, label %194
194: ; preds = %190
%195 = mul nsw i64 %192, %29
%196 = add nuw nsw i64 %195, %117
%197 = getelementptr inbounds i8, i8* %0, i64 %196
%198 = load i8, i8* %197
%199 = icmp eq i8 %198, %150
br i1 %199, label %200, label %208
200: ; preds = %194
%201 = add nuw nsw i64 %195, %131
%202 = getelementptr inbounds i8, i8* %0, i64 %201
%203 = load i8, i8* %202
%204 = load i8, i8* %151
%205 = icmp eq i8 %203, %204
%206 = fadd double %193, 1.000000e+00
%207 = select i1 %205, double %206, double %193
br label %208
208: ; preds = %194, %200, %190
%209 = phi double [ %191, %190 ], [ %193, %194 ], [ %207, %200 ]
%210 = fcmp une double %209, 0.000000e+00
br i1 %210, label %211, label %217
211: ; preds = %208
%212 = fdiv double %209, %28
%213 = fdiv double %212, %138
%214 = fdiv double %213, %146
%215 = tail call double @log(double %214)
%216 = tail call double @llvm.fmuladd.f64(double %212, double %215, double %143)
br label %217
217: ; preds = %144, %208, %211, %141
%218 = phi double [ %143, %144 ], [ %143, %141 ], [ %216, %211 ], [ %143, %208 ]
%219 = add nuw nsw i64 %142, 1
%220 = icmp eq i64 %219, 21
br i1 %220, label %221, label %141
221: ; preds = %217
%222 = add nuw nsw i64 %135, 1
%223 = icmp eq i64 %222, 21
br i1 %223, label %224, label %134
224: ; preds = %221
%225 = add nuw nsw i64 %131, %120
%226 = getelementptr inbounds double, double* %9, i64 %225
store double %218, double* %226
%227 = mul nsw i64 %131, %29
%228 = add nuw nsw i64 %227, %117
%229 = getelementptr inbounds double, double* %9, i64 %228
store double %218, double* %229
%230 = add nuw nsw i64 %131, 1
%231 = icmp eq i64 %230, %4
br i1 %231, label %113, label %130
232: ; preds = %113, %3, %25
ret double* %9
}