#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 *malloc(int);
double *calcOMES(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 *om;
  om = 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++) {
    om[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 += n * (count - p[i][k1] * p[j][k2]) *
                     (count - p[i][k1] * p[j][k2]) / (p[i][k1] * p[j][k2]);
            }
          }
        }
      om[i * l + j] = add;
      om[j * l + i] = add;
    }
  }
  return om;
}


x86 assembly (clang, -O0):
<calcOMES>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movabs $0x5957565453525150,%rax
56 57 59
mov    %rax,-0x33(%rbp)
movaps 0xed6(%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    120e <calcOMES+0xfe>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    11fb <calcOMES+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    11b8 <calcOMES+0xa8>
jmp    1200 <calcOMES+0xf0>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11a5 <calcOMES+0x95>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1363 <calcOMES+0x253>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12e5 <calcOMES+0x1d5>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    12d2 <calcOMES+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    12bf <calcOMES+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  0xd62(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xd50(%rip),%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    12d2 <calcOMES+0x1c2>
jmp    12c4 <calcOMES+0x1b4>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1243 <calcOMES+0x133>
jmp    12d7 <calcOMES+0x1c7>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1230 <calcOMES+0x120>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1350 <calcOMES+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    12ec <calcOMES+0x1dc>
jmp    1355 <calcOMES+0x245>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1215 <calcOMES+0x105>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    169c <calcOMES+0x58c>
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    1689 <calcOMES+0x579>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1645 <calcOMES+0x535>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1632 <calcOMES+0x522>
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    1410 <calcOMES+0x300>
jp     1410 <calcOMES+0x300>
jmp    161f <calcOMES+0x50f>
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    144e <calcOMES+0x33e>
jp     144e <calcOMES+0x33e>
jmp    161f <calcOMES+0x50f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14da <calcOMES+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    14c7 <calcOMES+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    14c7 <calcOMES+0x3b7>
movsd  0xb43(%rip),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    14cc <calcOMES+0x3bc>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    145d <calcOMES+0x34d>
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14f7 <calcOMES+0x3e7>
jp     14f7 <calcOMES+0x3e7>
jmp    161a <calcOMES+0x50a>
mov    -0x88(%rbp),%rax
mov    -0x90(%rbp),%rdx
movsd  -0x80(%rbp),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movslq -0x14(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x20(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm1
movslq -0x18(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x24(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm3
movq   %xmm1,%rcx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rcx
movq   %rcx,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x80(%rbp),%xmm2
movslq -0x14(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x20(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm1
movslq -0x18(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x24(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm3
movq   %xmm1,%rcx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rcx
movq   %rcx,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movslq -0x14(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x20(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm1
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    161f <calcOMES+0x50f>
jmp    1624 <calcOMES+0x514>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13c6 <calcOMES+0x2b6>
jmp    1637 <calcOMES+0x527>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13b3 <calcOMES+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    1398 <calcOMES+0x288>
jmp    168e <calcOMES+0x57e>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    136a <calcOMES+0x25a>
mov    -0x68(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    %rcx,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calcOMES>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %edx,%ebx
mov    %esi,%r15d
mov    %rdi,-0x50(%rbp)
mov    %edx,%r14d
mov    %rsp,%rcx
imul   $0xa8,%r14,%r13
lea    0xf(%r13),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rcx,%rsp
mov    %edx,%edi
imul   %edx,%edi
shl    $0x3,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    %ebx,-0x3c(%rbp)
test   %ebx,%ebx
jle    1564 <calcOMES+0x444>
xor    %r12d,%r12d
mov    -0x38(%rbp),%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1030 <memset@plt>
cvtsi2sd %r15d,%xmm9
mov    %r15d,%eax
mov    %rax,-0x58(%rbp)
movapd %xmm9,%xmm2
unpcklpd %xmm9,%xmm2
movabs $0x16fbdfd00001,%r9
lea    0xe8b(%rip),%r8
movsd  0xe4b(%rip),%xmm1
mov    -0x50(%rbp),%r10
jmp    1292 <calcOMES+0x172>
xchg   %ax,%ax
mov    -0x38(%rbp),%rax
movupd (%rax,%rsi,8),%xmm0
movupd 0x10(%rax,%rsi,8),%xmm3
movupd 0x20(%rax,%rsi,8),%xmm4
movupd 0x30(%rax,%rsi,8),%xmm5
divpd  %xmm2,%xmm0
movupd %xmm0,(%rax,%rsi,8)
divpd  %xmm2,%xmm3
movupd %xmm3,0x10(%rax,%rsi,8)
divpd  %xmm2,%xmm4
movupd %xmm4,0x20(%rax,%rsi,8)
divpd  %xmm2,%xmm5
movupd %xmm5,0x30(%rax,%rsi,8)
movupd 0x40(%rax,%rsi,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x40(%rax,%rsi,8)
movupd 0x50(%rax,%rsi,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x50(%rax,%rsi,8)
movupd 0x60(%rax,%rsi,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x60(%rax,%rsi,8)
movupd 0x70(%rax,%rsi,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x70(%rax,%rsi,8)
movupd 0x80(%rax,%rsi,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x80(%rax,%rsi,8)
movupd 0x90(%rax,%rsi,8),%xmm0
divpd  %xmm2,%xmm0
movupd %xmm0,0x90(%rax,%rsi,8)
movsd  0xa0(%rax,%rsi,8),%xmm0
divsd  %xmm9,%xmm0
movsd  %xmm0,0xa0(%rax,%rsi,8)
add    $0x1,%r12
add    $0x1,%r10
cmp    %r14,%r12
je     12f9 <calcOMES+0x1d9>
lea    (%r12,%r12,4),%rax
lea    (%r12,%rax,4),%rsi
test   %r15d,%r15d
jle    11c0 <calcOMES+0xa0>
mov    -0x38(%rbp),%rax
lea    (%rax,%rsi,8),%r11
mov    -0x58(%rbp),%rcx
mov    %r10,%rdx
jmp    12cd <calcOMES+0x1ad>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %r14,%rdx
add    $0xffffffffffffffff,%rcx
je     11c0 <calcOMES+0xa0>
movzbl (%rdx),%eax
add    $0xd3,%al
cmp    $0x2c,%al
ja     12c0 <calcOMES+0x1a0>
movzbl %al,%edi
bt     %rdi,%r9
jae    12c0 <calcOMES+0x1a0>
movsbq %al,%rax
mov    (%r8,%rax,8),%rax
movsd  (%r11,%rax,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r11,%rax,8)
jmp    12c0 <calcOMES+0x1a0>
cmpl   $0x0,-0x3c(%rbp)
jle    1564 <calcOMES+0x444>
mov    -0x58(%rbp),%rcx
and    $0xfffffffe,%ecx
lea    0x1(%r14),%rax
mov    %rax,-0x68(%rbp)
lea    (%r14,%r14,1),%rsi
mov    $0x1,%eax
mov    %rax,-0x60(%rbp)
xor    %eax,%eax
movapd 0xce6(%rip),%xmm8
xorpd  %xmm3,%xmm3
lea    0xceb(%rip),%r13
mov    %r14,%rdi
mov    %r15d,-0x2c(%rbp)
mov    %r14,-0x70(%rbp)
jmp    136b <calcOMES+0x24b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addq   $0x1,-0x60(%rbp)
addq   $0x1,-0x68(%rbp)
add    $0x1,%rdi
mov    -0x78(%rbp),%rax
cmp    %r14,%rax
je     1564 <calcOMES+0x444>
mov    %eax,%ebx
imul   -0x3c(%rbp),%ebx
movslq %ebx,%rbx
add    %rax,%rbx
mov    -0x48(%rbp),%rdx
movq   $0x0,(%rdx,%rbx,8)
lea    0x1(%rax),%rdx
mov    %rdx,-0x78(%rbp)
cmp    %r14,%rdx
jae    1350 <calcOMES+0x230>
mov    %rax,%rdx
imul   %r14,%rdx
mov    %rdx,-0x80(%rbp)
imul   $0xa8,%rax,%rdx
add    -0x38(%rbp),%rdx
mov    %rdx,-0x88(%rbp)
mov    -0x68(%rbp),%r9
mov    -0x60(%rbp),%r10
jmp    13f5 <calcOMES+0x2d5>
nopw   0x0(%rax,%rax,1)
mov    -0x80(%rbp),%rdx
lea    (%r10,%rdx,1),%rbx
mov    -0x48(%rbp),%rdx
movsd  %xmm4,(%rdx,%rbx,8)
mov    %r10,%rbx
mov    -0x70(%rbp),%r14
imul   %r14,%rbx
add    %rax,%rbx
movsd  %xmm4,(%rdx,%rbx,8)
add    $0x1,%r10
add    $0x1,%r9
cmp    %r14,%r10
je     1350 <calcOMES+0x230>
imul   $0xa8,%r10,%r12
add    -0x38(%rbp),%r12
xorpd  %xmm4,%xmm4
xor    %edx,%edx
jmp    141a <calcOMES+0x2fa>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    $0x15,%rdx
je     13c0 <calcOMES+0x2a0>
mov    -0x88(%rbp),%rbx
movsd  (%rbx,%rdx,8),%xmm5
movapd %xmm5,%xmm6
xorpd  %xmm8,%xmm6
xor    %r8d,%r8d
jmp    144a <calcOMES+0x32a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8
cmp    $0x15,%r8
je     1410 <calcOMES+0x2f0>
ucomisd %xmm3,%xmm5
jne    1452 <calcOMES+0x332>
jnp    1440 <calcOMES+0x320>
movsd  (%r12,%r8,8),%xmm7
ucomisd %xmm3,%xmm7
jne    1460 <calcOMES+0x340>
jnp    1440 <calcOMES+0x320>
test   %r15d,%r15d
jle    1440 <calcOMES+0x320>
mov    (%rdx,%r13,1),%r14b
xorpd  %xmm0,%xmm0
cmp    $0x1,%r15d
jne    14f9 <calcOMES+0x3d9>
xor    %r11d,%r11d
testb  $0x1,-0x58(%rbp)
mov    -0x2c(%rbp),%r15d
je     14be <calcOMES+0x39e>
mov    %r12,%r15
imul   -0x70(%rbp),%r11
lea    (%r11,%rax,1),%rbx
mov    -0x50(%rbp),%r12
cmp    %r14b,(%r12,%rbx,1)
jne    14b7 <calcOMES+0x397>
add    %r10,%r11
mov    (%r12,%r11,1),%bl
movapd %xmm0,%xmm2
addsd  %xmm1,%xmm2
cmp    (%r8,%r13,1),%bl
je     14b3 <calcOMES+0x393>
movapd %xmm0,%xmm2
movapd %xmm2,%xmm0
mov    %r15,%r12
mov    -0x2c(%rbp),%r15d
ucomisd %xmm3,%xmm0
jne    14ca <calcOMES+0x3aa>
jnp    1440 <calcOMES+0x320>
divsd  %xmm9,%xmm0
movapd %xmm6,%xmm2
mulsd  %xmm7,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm9,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm5,%xmm7
divsd  %xmm7,%xmm0
addsd  %xmm0,%xmm4
jmp    1440 <calcOMES+0x320>
mov    -0x50(%rbp),%r15
xor    %r11d,%r11d
jmp    1524 <calcOMES+0x404>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm2,%xmm0
add    $0x2,%r11
add    %rsi,%r15
cmp    %r11,%rcx
je     147a <calcOMES+0x35a>
cmp    %r14b,(%r15,%rax,1)
jne    1545 <calcOMES+0x425>
movzbl (%r15,%r10,1),%ebx
movapd %xmm0,%xmm2
addsd  %xmm1,%xmm2
cmp    (%r8,%r13,1),%bl
je     1541 <calcOMES+0x421>
movapd %xmm0,%xmm2
movapd %xmm2,%xmm0
cmp    %r14b,(%r15,%rdi,1)
jne    1514 <calcOMES+0x3f4>
movzbl (%r15,%r9,1),%ebx
movapd %xmm0,%xmm2
addsd  %xmm1,%xmm2
cmp    (%r8,%r13,1),%bl
je     1510 <calcOMES+0x3f0>
movapd %xmm0,%xmm2
jmp    1510 <calcOMES+0x3f0>
mov    -0x48(%rbp),%rax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.calcOMES.reslist = [21 x i8] c"-ACDEFGHIKLMNPQRSTVWY"
define double* @calcOMES(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 = %341, %143
%145 = load i32, i32* %7
%146 = load i32, i32* %6
%147 = icmp slt i32 %145, %146
br i1 %147, label %148, label %344
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 = %337, %148
%160 = load i32, i32* %8
%161 = load i32, i32* %6
%162 = icmp slt i32 %160, %161
br i1 %162, label %163, label %340
163: ; preds = %159
store double 0.000000e+00, double* %19
store i32 0, i32* %10
br label %164
164: ; preds = %315, %163
%165 = load i32, i32* %10
%166 = load i32, i32* %13
%167 = icmp slt i32 %165, %166
br i1 %167, label %168, label %318
168: ; preds = %164
store i32 0, i32* %11
br label %169
169: ; preds = %311, %168
%170 = load i32, i32* %11
%171 = load i32, i32* %13
%172 = icmp slt i32 %170, %171
br i1 %172, label %173, label %314
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 %310
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 %310
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 %309
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 i32, i32* %5
%248 = sitofp i32 %247 to double
%249 = load double, double* %20
%250 = load i32, i32* %7
%251 = sext i32 %250 to i64
%252 = mul nsw i64 %251, %25
%253 = getelementptr inbounds double, double* %28, i64 %252
%254 = load i32, i32* %10
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds double, double* %253, i64 %255
%257 = load double, double* %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 = fneg double %257
%267 = call double @llvm.fmuladd.f64(double %266, double %265, double %249)
%268 = fmul double %248, %267
%269 = load double, double* %20
%270 = load i32, i32* %7
%271 = sext i32 %270 to i64
%272 = mul nsw i64 %271, %25
%273 = getelementptr inbounds double, double* %28, i64 %272
%274 = load i32, i32* %10
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %273, i64 %275
%277 = load double, double* %276
%278 = load i32, i32* %8
%279 = sext i32 %278 to i64
%280 = mul nsw i64 %279, %25
%281 = getelementptr inbounds double, double* %28, i64 %280
%282 = load i32, i32* %11
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %281, i64 %283
%285 = load double, double* %284
%286 = fneg double %277
%287 = call double @llvm.fmuladd.f64(double %286, double %285, double %269)
%288 = fmul double %268, %287
%289 = load i32, i32* %7
%290 = sext i32 %289 to i64
%291 = mul nsw i64 %290, %25
%292 = getelementptr inbounds double, double* %28, i64 %291
%293 = load i32, i32* %10
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %292, i64 %294
%296 = load double, double* %295
%297 = load i32, i32* %8
%298 = sext i32 %297 to i64
%299 = mul nsw i64 %298, %25
%300 = getelementptr inbounds double, double* %28, i64 %299
%301 = load i32, i32* %11
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds double, double* %300, i64 %302
%304 = load double, double* %303
%305 = fmul double %296, %304
%306 = fdiv double %288, %305
%307 = load double, double* %19
%308 = fadd double %307, %306
store double %308, double* %19
br label %309
309: ; preds = %242, %239
br label %310
310: ; preds = %309, %183, %173
br label %311
311: ; preds = %310
%312 = load i32, i32* %11
%313 = add nsw i32 %312, 1
store i32 %313, i32* %11
br label %169
314: ; preds = %169
br label %315
315: ; preds = %314
%316 = load i32, i32* %10
%317 = add nsw i32 %316, 1
store i32 %317, i32* %10
br label %164
318: ; preds = %164
%319 = load double, double* %19
%320 = load double*, double** %17
%321 = load i32, i32* %7
%322 = load i32, i32* %6
%323 = mul nsw i32 %321, %322
%324 = load i32, i32* %8
%325 = add nsw i32 %323, %324
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds double, double* %320, i64 %326
store double %319, double* %327
%328 = load double, double* %19
%329 = load double*, double** %17
%330 = load i32, i32* %8
%331 = load i32, i32* %6
%332 = mul nsw i32 %330, %331
%333 = load i32, i32* %7
%334 = add nsw i32 %332, %333
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds double, double* %329, i64 %335
store double %328, double* %336
br label %337
337: ; preds = %318
%338 = load i32, i32* %8
%339 = add nsw i32 %338, 1
store i32 %339, i32* %8
br label %159
340: ; preds = %159
br label %341
341: ; preds = %340
%342 = load i32, i32* %7
%343 = add nsw i32 %342, 1
store i32 %343, i32* %7
br label %144
344: ; preds = %144
%345 = load double*, double** %17
%346 = load i8*, i8** %14
ret double* %345
}

LLVM IR (-O2):
@__const.calcOMES.reslist = [21 x i8] c"-ACDEFGHIKLMNPQRSTVWY"
@switch.table.calcOMES = [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* @calcOMES(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 %235
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 %235
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.calcOMES, 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 = %227, %116
%114 = add nuw nsw i64 %118, 1
%115 = icmp eq i64 %125, %4
br i1 %115, label %235, 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, %227
%131 = phi i64 [ %118, %127 ], [ %233, %227 ]
%132 = mul nuw nsw i64 %131, 21
%133 = getelementptr inbounds double, double* %6, i64 %132
br label %134
134: ; preds = %130, %224
%135 = phi i64 [ 0, %130 ], [ %225, %224 ]
%136 = phi double [ 0.000000e+00, %130 ], [ %221, %224 ]
%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.calcOMES.reslist, i64 0, i64 %135
%141 = fneg double %138
br label %142
142: ; preds = %134, %220
%143 = phi i64 [ 0, %134 ], [ %222, %220 ]
%144 = phi double [ %136, %134 ], [ %221, %220 ]
br i1 %139, label %145, label %220
145: ; preds = %142
%146 = getelementptr inbounds double, double* %133, i64 %143
%147 = load double, double* %146
%148 = fcmp oeq double %147, 0.000000e+00
%149 = or i1 %148, %27
br i1 %149, label %220, label %150
150: ; preds = %145
%151 = load i8, i8* %140
%152 = getelementptr inbounds [21 x i8], [21 x i8]* @__const.calcOMES.reslist, i64 0, i64 %143
br i1 %31, label %191, label %153
153: ; preds = %150, %186
%154 = phi i64 [ %188, %186 ], [ 0, %150 ]
%155 = phi double [ %187, %186 ], [ 0.000000e+00, %150 ]
%156 = phi i64 [ %189, %186 ], [ 0, %150 ]
%157 = mul nsw i64 %154, %29
%158 = add nuw nsw i64 %157, %117
%159 = getelementptr inbounds i8, i8* %0, i64 %158
%160 = load i8, i8* %159
%161 = icmp eq i8 %160, %151
br i1 %161, label %162, label %170
162: ; preds = %153
%163 = add nuw nsw i64 %157, %131
%164 = getelementptr inbounds i8, i8* %0, i64 %163
%165 = load i8, i8* %164
%166 = load i8, i8* %152
%167 = icmp eq i8 %165, %166
%168 = fadd double %155, 1.000000e+00
%169 = select i1 %167, double %168, double %155
br label %170
170: ; preds = %162, %153
%171 = phi double [ %155, %153 ], [ %169, %162 ]
%172 = or i64 %154, 1
%173 = mul nsw i64 %172, %29
%174 = add nuw nsw i64 %173, %117
%175 = getelementptr inbounds i8, i8* %0, i64 %174
%176 = load i8, i8* %175
%177 = icmp eq i8 %176, %151
br i1 %177, label %178, label %186
178: ; preds = %170
%179 = add nuw nsw i64 %173, %131
%180 = getelementptr inbounds i8, i8* %0, i64 %179
%181 = load i8, i8* %180
%182 = load i8, i8* %152
%183 = icmp eq i8 %181, %182
%184 = fadd double %171, 1.000000e+00
%185 = select i1 %183, double %184, double %171
br label %186
186: ; preds = %178, %170
%187 = phi double [ %171, %170 ], [ %185, %178 ]
%188 = add nuw nsw i64 %154, 2
%189 = add i64 %156, 2
%190 = icmp eq i64 %189, %32
br i1 %190, label %191, label %153
191: ; preds = %186, %150
%192 = phi double [ undef, %150 ], [ %187, %186 ]
%193 = phi i64 [ 0, %150 ], [ %188, %186 ]
%194 = phi double [ 0.000000e+00, %150 ], [ %187, %186 ]
br i1 %33, label %209, label %195
195: ; preds = %191
%196 = mul nsw i64 %193, %29
%197 = add nuw nsw i64 %196, %117
%198 = getelementptr inbounds i8, i8* %0, i64 %197
%199 = load i8, i8* %198
%200 = icmp eq i8 %199, %151
br i1 %200, label %201, label %209
201: ; preds = %195
%202 = add nuw nsw i64 %196, %131
%203 = getelementptr inbounds i8, i8* %0, i64 %202
%204 = load i8, i8* %203
%205 = load i8, i8* %152
%206 = icmp eq i8 %204, %205
%207 = fadd double %194, 1.000000e+00
%208 = select i1 %206, double %207, double %194
br label %209
209: ; preds = %195, %201, %191
%210 = phi double [ %192, %191 ], [ %194, %195 ], [ %208, %201 ]
%211 = fcmp une double %210, 0.000000e+00
br i1 %211, label %212, label %220
212: ; preds = %209
%213 = fdiv double %210, %28
%214 = tail call double @llvm.fmuladd.f64(double %141, double %147, double %213)
%215 = fmul double %214, %28
%216 = fmul double %214, %215
%217 = fmul double %138, %147
%218 = fdiv double %216, %217
%219 = fadd double %144, %218
br label %220
220: ; preds = %145, %209, %212, %142
%221 = phi double [ %144, %145 ], [ %144, %142 ], [ %219, %212 ], [ %144, %209 ]
%222 = add nuw nsw i64 %143, 1
%223 = icmp eq i64 %222, 21
br i1 %223, label %224, label %142
224: ; preds = %220
%225 = add nuw nsw i64 %135, 1
%226 = icmp eq i64 %225, 21
br i1 %226, label %227, label %134
227: ; preds = %224
%228 = add nuw nsw i64 %131, %120
%229 = getelementptr inbounds double, double* %9, i64 %228
store double %221, double* %229
%230 = mul nsw i64 %131, %29
%231 = add nuw nsw i64 %230, %117
%232 = getelementptr inbounds double, double* %9, i64 %231
store double %221, double* %232
%233 = add nuw nsw i64 %131, 1
%234 = icmp eq i64 %233, %4
br i1 %234, label %113, label %130
235: ; preds = %113, %3, %25
ret double* %9
}