#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 */

/* Variables and functions */
int /*<<< orphan*/ Die(char *, char *, int);
int SymbolIndex(char);
double log(float);
scalar_t__ malloc(int);
void mixy(char **aseq, int nseq, int alen, int ***ret_mxy) {
  int **mxy;
  float fx[4];
  float fy[4];
  float fxy[4][4];
  int idx;
  int i, j;
  int symi, symj;
  int pairs;
  long test;
  if ((mxy = (int **)malloc(alen * sizeof(int *))) == NULL)
    Die("Memory allocation failure at %s line %d",
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/fredericokremer/genix/refs/heads/master/bin/"
        "tRNAscan-SE/fastmodelmaker.c",
        193);
  for (j = 1; j < alen; j++)
    if ((mxy[j] = (int *)malloc(j * sizeof(int))) == NULL)
      Die("Memory allocation failure at %s line %d",
          "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
          "2022-01-22/02-19-57/repos/fredericokremer/genix/refs/heads/master/"
          "bin/tRNAscan-SE/fastmodelmaker.c",
          196);
  test = (long)mxy[20];
  for (j = 1; j < alen; j++)
    for (i = 0; i < j; i++) {
      for (symj = 0; symj < 4; symj++) {
        fx[symj] = fy[symj] = 0.0;
        for (symi = 0; symi < 4; symi++)
          fxy[symj][symi] = 0.0;
      }
      pairs = 0;
      for (idx = 0; idx < nseq; idx++) {
        if (((aseq[idx][i]) == ' ' || (aseq[idx][i]) == '.' ||
             (aseq[idx][i]) == '_' || (aseq[idx][i]) == '-') ||
            ((aseq[idx][j]) == ' ' || (aseq[idx][j]) == '.' ||
             (aseq[idx][j]) == '_' || (aseq[idx][j]) == '-'))
          continue;
        symi = SymbolIndex(aseq[idx][i]);
        symj = SymbolIndex(aseq[idx][j]);
        fx[symi] += 1.0;
        fy[symj] += 1.0;
        fxy[symi][symj] += 1.0;
        pairs++;
      }
      if (pairs > 0)
        for (symi = 0; symi < 4; symi++) {
          fx[symi] /= (float)pairs;
          fy[symi] /= (float)pairs;
          for (symj = 0; symj < 4; symj++)
            fxy[symi][symj] /= (float)pairs;
        }
      mxy[j][i] = 0;
      for (symi = 0; symi < 4; symi++)
        for (symj = 0; symj < 4; symj++) {
          if (fxy[symi][symj] > 0.0)
            mxy[j][i] += (int)(144.269504 * fxy[symi][symj] *
                               log((fxy[symi][symj] / (fx[symi] * fy[symj]))));
        }
      mxy[j][i] = (mxy[j][i] * pairs) / nseq;
    }
  *ret_mxy = mxy;
}


x86 assembly (clang, -O0):
<mixy>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    118e <mixy+0x4e>
lea    0xe93(%rip),%rdi
lea    0xeb4(%rip),%rsi
mov    $0xc1,%edx
call   1050 <Die@plt>
movl   $0x1,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1203 <mixy+0xc3>
movslq -0x8c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    -0x20(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
mov    %rax,(%rcx,%rdx,8)
cmp    $0x0,%rax
jne    11ea <mixy+0xaa>
lea    0xe37(%rip),%rdi
lea    0xe58(%rip),%rsi
mov    $0xc4,%edx
call   1050 <Die@plt>
jmp    11ef <mixy+0xaf>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1198 <mixy+0x58>
mov    -0x20(%rbp),%rax
mov    0xa0(%rax),%rax
mov    %rax,-0xa0(%rbp)
movl   $0x1,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    17b0 <mixy+0x670>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    1797 <mixy+0x657>
movl   $0x0,-0x94(%rbp)
cmpl   $0x4,-0x94(%rbp)
jge    12e6 <mixy+0x1a6>
movslq -0x94(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
movslq -0x94(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp,%rax,4)
movl   $0x0,-0x90(%rbp)
cmpl   $0x4,-0x90(%rbp)
jge    12cd <mixy+0x18d>
movslq -0x94(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x90(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    128b <mixy+0x14b>
jmp    12d2 <mixy+0x192>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1254 <mixy+0x114>
movl   $0x0,-0x98(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1518 <mixy+0x3d8>
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1421 <mixy+0x2e1>
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
je     1421 <mixy+0x2e1>
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5f,%eax
je     1421 <mixy+0x2e1>
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
je     1421 <mixy+0x2e1>
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1421 <mixy+0x2e1>
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
je     1421 <mixy+0x2e1>
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5f,%eax
je     1421 <mixy+0x2e1>
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1426 <mixy+0x2e6>
jmp    1504 <mixy+0x3c4>
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <SymbolIndex@plt>
mov    %eax,-0x90(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1040 <SymbolIndex@plt>
mov    %eax,-0x94(%rbp)
movslq -0x90(%rbp),%rax
movss  -0x30(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb7f(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp,%rax,4)
movslq -0x94(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb58(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
movslq -0x90(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb20(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    12fa <mixy+0x1ba>
cmpl   $0x0,-0x98(%rbp)
jle    15f2 <mixy+0x4b2>
movl   $0x0,-0x90(%rbp)
cmpl   $0x4,-0x90(%rbp)
jge    15ed <mixy+0x4ad>
cvtsi2ssl -0x98(%rbp),%xmm1
ff
movslq -0x90(%rbp),%rax
movss  -0x30(%rbp,%rax,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp,%rax,4)
cvtsi2ssl -0x98(%rbp),%xmm1
ff
movslq -0x90(%rbp),%rax
movss  -0x40(%rbp,%rax,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp,%rax,4)
movl   $0x0,-0x94(%rbp)
cmpl   $0x4,-0x94(%rbp)
jge    15d4 <mixy+0x494>
cvtsi2ssl -0x98(%rbp),%xmm1
ff
movslq -0x90(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1584 <mixy+0x444>
jmp    15d9 <mixy+0x499>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    152f <mixy+0x3ef>
jmp    15f2 <mixy+0x4b2>
mov    -0x20(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,-0x90(%rbp)
cmpl   $0x4,-0x90(%rbp)
jge    1744 <mixy+0x604>
movl   $0x0,-0x94(%rbp)
cmpl   $0x4,-0x94(%rbp)
jge    172b <mixy+0x5eb>
movslq -0x90(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1712 <mixy+0x5d2>
movslq -0x90(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x96a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movslq -0x90(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x90(%rbp),%rax
movss  -0x30(%rbp,%rax,4),%xmm1
movslq -0x94(%rbp),%rax
mulss  -0x40(%rbp,%rax,4),%xmm1
divss  %xmm1,%xmm0
call   1060 <log@plt>
movaps %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edx
mov    -0x20(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1717 <mixy+0x5d7>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1630 <mixy+0x4f0>
jmp    1730 <mixy+0x5f0>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1619 <mixy+0x4d9>
mov    -0x20(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x98(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1238 <mixy+0xf8>
jmp    179c <mixy+0x65c>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    121f <mixy+0xdf>
mov    -0x20(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mixy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %rcx,0x98(%rsp)
mov    %edx,%r15d
mov    %esi,%ebx
mov    %rdi,0x90(%rsp)
lea    0x0(,%r15,8),%edi
call   1030 <malloc@plt>
mov    %rax,%rbp
test   %rax,%rax
je     1186 <mixy+0x46>
cmp    $0x2,%r15d
jge    11a8 <mixy+0x68>
jmp    1643 <mixy+0x503>
lea    0xe83(%rip),%rdi
lea    0xea4(%rip),%rsi
mov    $0xc1,%edx
call   1050 <Die@plt>
cmp    $0x2,%r15d
jl     1643 <mixy+0x503>
mov    %ebx,0x1c(%rsp)
mov    %r15d,%eax
mov    %rax,0xa0(%rsp)
lea    0x0(,%rax,4),%rbx
mov    $0x4,%r13d
lea    0xe44(%rip),%r14
lea    0xe65(%rip),%r12
jmp    11e9 <mixy+0xa9>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x4,%r13
cmp    %r13,%rbx
je     120d <mixy+0xcd>
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,0x0(%rbp,%r13,2)
test   %rax,%rax
jne    11e0 <mixy+0xa0>
mov    %r14,%rdi
mov    %r12,%rsi
mov    $0xc4,%edx
call   1050 <Die@plt>
jmp    11e0 <mixy+0xa0>
cmp    $0x2,%r15d
mov    0x1c(%rsp),%r13d
jl     1643 <mixy+0x503>
mov    %r13d,%r14d
mov    $0x1,%r15d
xorps  %xmm3,%xmm3
jmp    1242 <mixy+0x102>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    0xa0(%rsp),%r15
je     1643 <mixy+0x503>
xor    %r12d,%r12d
jmp    126a <mixy+0x12a>
nopw   0x0(%rax,%rax,1)
mov    0xc(%rsp),%eax
imul   (%rcx,%r12,4),%eax
cltd
idiv   %r13d
mov    %eax,(%rcx,%r12,4)
add    $0x1,%r12
cmp    %r15,%r12
je     1230 <mixy+0xf0>
xorps  %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
test   %r13d,%r13d
jle    14b0 <mixy+0x370>
xor    %ebx,%ebx
movl   $0x0,0xc(%rsp)
jmp    1329 <mixy+0x1e9>
movsbl %al,%edi
call   1040 <SymbolIndex@plt>
mov    %eax,%r13d
mov    0x90(%rsp),%rax
mov    (%rax,%rbx,8),%rax
movsbl (%rax,%r15,1),%edi
call   1040 <SymbolIndex@plt>
xorps  %xmm3,%xmm3
movslq %r13d,%rcx
mov    0x1c(%rsp),%r13d
movss  0x30(%rsp,%rcx,4),%xmm0
movss  0xd20(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,0x30(%rsp,%rcx,4)
cltq
movss  0x20(%rsp,%rax,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rsp,%rax,4)
shl    $0x4,%rcx
add    %rsp,%rcx
add    $0x50,%rcx
movss  (%rcx,%rax,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rcx,%rax,4)
addl   $0x1,0xc(%rsp)
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rbx,%r14
je     1380 <mixy+0x240>
mov    0x90(%rsp),%rax
mov    (%rax,%rbx,8),%rcx
movzbl (%rcx,%r12,1),%eax
lea    -0x20(%rax),%edx
cmp    $0x3f,%dl
ja     1355 <mixy+0x215>
movzbl %dl,%edx
movabs $0x8000000000006001,%rsi
bt     %rdx,%rsi
jb     1320 <mixy+0x1e0>
movzbl (%rcx,%r15,1),%ecx
add    $0xe0,%cl
cmp    $0x3f,%cl
ja     12a6 <mixy+0x166>
movzbl %cl,%ecx
movabs $0x8000000000006001,%rdx
bt     %rcx,%rdx
jb     1320 <mixy+0x1e0>
jmp    12a6 <mixy+0x166>
xchg   %ax,%ax
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    14b8 <mixy+0x378>
cvtsi2ss %eax,%xmm7
shufps $0x0,%xmm7,%xmm7
movaps 0x30(%rsp),%xmm0
divps  %xmm7,%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0x20(%rsp),%xmm0
divps  %xmm7,%xmm0
movaps %xmm0,0x20(%rsp)
movss  0x80(%rsp),%xmm0
movss  0x70(%rsp),%xmm1
unpcklps %xmm0,%xmm1
movss  0x60(%rsp),%xmm2
movss  0x50(%rsp),%xmm0
unpcklps %xmm2,%xmm0
movlhps %xmm1,%xmm0
movss  0x54(%rsp),%xmm1
movss  0x58(%rsp),%xmm2
movss  0x5c(%rsp),%xmm4
divps  %xmm7,%xmm0
movss  0x84(%rsp),%xmm5
movss  0x74(%rsp),%xmm6
unpcklps %xmm5,%xmm6
movss  0x64(%rsp),%xmm5
unpcklps %xmm5,%xmm1
movlhps %xmm6,%xmm1
divps  %xmm7,%xmm1
movss  0x88(%rsp),%xmm5
movss  0x78(%rsp),%xmm6
unpcklps %xmm5,%xmm6
movss  0x68(%rsp),%xmm5
unpcklps %xmm5,%xmm2
movlhps %xmm6,%xmm2
divps  %xmm7,%xmm2
movss  0x8c(%rsp),%xmm5
movss  0x7c(%rsp),%xmm6
unpcklps %xmm5,%xmm6
movss  0x6c(%rsp),%xmm5
unpcklps %xmm5,%xmm4
movlhps %xmm6,%xmm4
divps  %xmm7,%xmm4
movaps %xmm4,%xmm6
movlhps %xmm2,%xmm6
movaps %xmm0,%xmm8
unpcklps %xmm1,%xmm8
shufps $0x24,%xmm6,%xmm8
movaps %xmm2,%xmm7
unpcklps %xmm4,%xmm7
movaps %xmm1,%xmm6
shufps $0x11,%xmm0,%xmm6
shufps $0xe2,%xmm7,%xmm6
movaps %xmm4,%xmm5
unpckhpd %xmm2,%xmm5
movaps %xmm0,%xmm7
unpckhps %xmm1,%xmm7
shufps $0x24,%xmm5,%xmm7
unpckhps %xmm4,%xmm2
shufps $0x33,%xmm0,%xmm1
shufps $0xe2,%xmm2,%xmm1
movaps %xmm1,0x80(%rsp)
movaps %xmm7,0x70(%rsp)
movaps %xmm6,0x60(%rsp)
movaps %xmm8,0x50(%rsp)
jmp    14b8 <mixy+0x378>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x0,0xc(%rsp)
mov    0x0(%rbp,%r15,8),%rcx
movl   $0x0,(%rcx,%r12,4)
movss  0x20(%rsp),%xmm0
movss  %xmm0,0x4c(%rsp)
movss  0x24(%rsp),%xmm0
movss  %xmm0,0x48(%rsp)
movss  0x28(%rsp),%xmm0
movss  %xmm0,0x44(%rsp)
movss  0x2c(%rsp),%xmm0
movss  %xmm0,0x40(%rsp)
xor    %ebx,%ebx
jmp    150e <mixy+0x3ce>
nopl   0x0(%rax)
add    $0x4,%rbx
cmp    $0x10,%rbx
je     1250 <mixy+0x110>
movss  0x50(%rsp,%rbx,4),%xmm0
ucomiss %xmm3,%xmm0
jbe    1559 <mixy+0x419>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulsd  0xae0(%rip),%xmm1
movsd  %xmm1,0x10(%rsp)
movss  0x30(%rsp,%rbx,1),%xmm1
mulss  0x4c(%rsp),%xmm1
divss  %xmm1,%xmm0
call   1060 <log@plt>
xorps  %xmm3,%xmm3
mulsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%eax
mov    0x0(%rbp,%r15,8),%rcx
add    %eax,(%rcx,%r12,4)
movss  0x54(%rsp,%rbx,4),%xmm0
ucomiss %xmm3,%xmm0
jbe    15a4 <mixy+0x464>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulsd  0xa95(%rip),%xmm1
movsd  %xmm1,0x10(%rsp)
movss  0x30(%rsp,%rbx,1),%xmm1
mulss  0x48(%rsp),%xmm1
divss  %xmm1,%xmm0
call   1060 <log@plt>
xorps  %xmm3,%xmm3
mulsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%eax
mov    0x0(%rbp,%r15,8),%rcx
add    %eax,(%rcx,%r12,4)
movss  0x58(%rsp,%rbx,4),%xmm0
ucomiss %xmm3,%xmm0
jbe    15ef <mixy+0x4af>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulsd  0xa4a(%rip),%xmm1
movsd  %xmm1,0x10(%rsp)
movss  0x30(%rsp,%rbx,1),%xmm1
mulss  0x44(%rsp),%xmm1
divss  %xmm1,%xmm0
call   1060 <log@plt>
xorps  %xmm3,%xmm3
mulsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%eax
mov    0x0(%rbp,%r15,8),%rcx
add    %eax,(%rcx,%r12,4)
movss  0x5c(%rsp,%rbx,4),%xmm0
ucomiss %xmm3,%xmm0
jbe    1500 <mixy+0x3c0>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulsd  0x9fb(%rip),%xmm1
movsd  %xmm1,0x10(%rsp)
movss  0x30(%rsp,%rbx,1),%xmm1
mulss  0x40(%rsp),%xmm1
divss  %xmm1,%xmm0
call   1060 <log@plt>
xorps  %xmm3,%xmm3
mulsd  0x10(%rsp),%xmm0
cvttsd2si %xmm0,%eax
mov    0x0(%rbp,%r15,8),%rcx
add    %eax,(%rcx,%r12,4)
jmp    1500 <mixy+0x3c0>
mov    0x98(%rsp),%rax
mov    %rbp,(%rax)
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [40 x i8] c"Memory allocation failure at %s line %d\00"
@.str.1 = [163 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/fredericokremer/genix/refs/heads/master/bin/tRNAscan-SE/fastmodelmaker.c\00"
define void @mixy(i8** %0, i32 %1, i32 %2, i32*** %3) {
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32***
%9 = alloca i32**
%10 = alloca [4 x float]
%11 = alloca [4 x float]
%12 = alloca [4 x [4 x float]]
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i64
store i8** %0, i8*** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32*** %3, i32**** %8
%20 = load i32, i32* %7
%21 = sext i32 %20 to i64
%22 = mul i64 %21, 8
%23 = trunc i64 %22 to i32
%24 = call i64 @malloc(i32 %23)
%25 = inttoptr i64 %24 to i32**
store i32** %25, i32*** %9
%26 = icmp eq i32** %25, null
br i1 %26, label %27, label %29
27: ; preds = %4
%28 = call i32 @Die(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.1, i64 0, i64 0), i32 193)
br label %29
29: ; preds = %27, %4
store i32 1, i32* %15
br label %30
30: ; preds = %49, %29
%31 = load i32, i32* %15
%32 = load i32, i32* %7
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %52
34: ; preds = %30
%35 = load i32, i32* %15
%36 = sext i32 %35 to i64
%37 = mul i64 %36, 4
%38 = trunc i64 %37 to i32
%39 = call i64 @malloc(i32 %38)
%40 = inttoptr i64 %39 to i32*
%41 = load i32**, i32*** %9
%42 = load i32, i32* %15
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i32*, i32** %41, i64 %43
store i32* %40, i32** %44
%45 = icmp eq i32* %40, null
br i1 %45, label %46, label %48
46: ; preds = %34
%47 = call i32 @Die(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.1, i64 0, i64 0), i32 196)
br label %48
48: ; preds = %46, %34
br label %49
49: ; preds = %48
%50 = load i32, i32* %15
%51 = add nsw i32 %50, 1
store i32 %51, i32* %15
br label %30
52: ; preds = %30
%53 = load i32**, i32*** %9
%54 = getelementptr inbounds i32*, i32** %53, i64 20
%55 = load i32*, i32** %54
%56 = ptrtoint i32* %55 to i64
store i64 %56, i64* %19
store i32 1, i32* %15
br label %57
57: ; preds = %390, %52
%58 = load i32, i32* %15
%59 = load i32, i32* %7
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %393
61: ; preds = %57
store i32 0, i32* %14
br label %62
62: ; preds = %386, %61
%63 = load i32, i32* %14
%64 = load i32, i32* %15
%65 = icmp slt i32 %63, %64
br i1 %65, label %66, label %389
66: ; preds = %62
store i32 0, i32* %17
br label %67
67: ; preds = %91, %66
%68 = load i32, i32* %17
%69 = icmp slt i32 %68, 4
br i1 %69, label %70, label %94
70: ; preds = %67
%71 = load i32, i32* %17
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 %72
store float 0.000000e+00, float* %73
%74 = load i32, i32* %17
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 %75
store float 0.000000e+00, float* %76
store i32 0, i32* %16
br label %77
77: ; preds = %87, %70
%78 = load i32, i32* %16
%79 = icmp slt i32 %78, 4
br i1 %79, label %80, label %90
80: ; preds = %77
%81 = load i32, i32* %17
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %12, i64 0, i64 %82
%84 = load i32, i32* %16
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [4 x float], [4 x float]* %83, i64 0, i64 %85
store float 0.000000e+00, float* %86
br label %87
87: ; preds = %80
%88 = load i32, i32* %16
%89 = add nsw i32 %88, 1
store i32 %89, i32* %16
br label %77
90: ; preds = %77
br label %91
91: ; preds = %90
%92 = load i32, i32* %17
%93 = add nsw i32 %92, 1
store i32 %93, i32* %17
br label %67
94: ; preds = %67
store i32 0, i32* %18
store i32 0, i32* %13
br label %95
95: ; preds = %243, %94
%96 = load i32, i32* %13
%97 = load i32, i32* %6
%98 = icmp slt i32 %96, %97
br i1 %98, label %99, label %246
99: ; preds = %95
%100 = load i8**, i8*** %5
%101 = load i32, i32* %13
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i8*, i8** %100, i64 %102
%104 = load i8*, i8** %103
%105 = load i32, i32* %14
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %104, i64 %106
%108 = load i8, i8* %107
%109 = sext i8 %108 to i32
%110 = icmp eq i32 %109, 32
br i1 %110, label %195, label %111
111: ; preds = %99
%112 = load i8**, i8*** %5
%113 = load i32, i32* %13
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8*, i8** %112, i64 %114
%116 = load i8*, i8** %115
%117 = load i32, i32* %14
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i8, i8* %116, i64 %118
%120 = load i8, i8* %119
%121 = sext i8 %120 to i32
%122 = icmp eq i32 %121, 46
br i1 %122, label %195, label %123
123: ; preds = %111
%124 = load i8**, i8*** %5
%125 = load i32, i32* %13
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i8*, i8** %124, i64 %126
%128 = load i8*, i8** %127
%129 = load i32, i32* %14
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds i8, i8* %128, i64 %130
%132 = load i8, i8* %131
%133 = sext i8 %132 to i32
%134 = icmp eq i32 %133, 95
br i1 %134, label %195, label %135
135: ; preds = %123
%136 = load i8**, i8*** %5
%137 = load i32, i32* %13
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds i8*, i8** %136, i64 %138
%140 = load i8*, i8** %139
%141 = load i32, i32* %14
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %140, i64 %142
%144 = load i8, i8* %143
%145 = sext i8 %144 to i32
%146 = icmp eq i32 %145, 45
br i1 %146, label %195, label %147
147: ; preds = %135
%148 = load i8**, i8*** %5
%149 = load i32, i32* %13
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i8*, i8** %148, i64 %150
%152 = load i8*, i8** %151
%153 = load i32, i32* %15
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds i8, i8* %152, i64 %154
%156 = load i8, i8* %155
%157 = sext i8 %156 to i32
%158 = icmp eq i32 %157, 32
br i1 %158, label %195, label %159
159: ; preds = %147
%160 = load i8**, i8*** %5
%161 = load i32, i32* %13
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i8*, i8** %160, i64 %162
%164 = load i8*, i8** %163
%165 = load i32, i32* %15
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds i8, i8* %164, i64 %166
%168 = load i8, i8* %167
%169 = sext i8 %168 to i32
%170 = icmp eq i32 %169, 46
br i1 %170, label %195, label %171
171: ; preds = %159
%172 = load i8**, i8*** %5
%173 = load i32, i32* %13
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i8*, i8** %172, i64 %174
%176 = load i8*, i8** %175
%177 = load i32, i32* %15
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds i8, i8* %176, i64 %178
%180 = load i8, i8* %179
%181 = sext i8 %180 to i32
%182 = icmp eq i32 %181, 95
br i1 %182, label %195, label %183
183: ; preds = %171
%184 = load i8**, i8*** %5
%185 = load i32, i32* %13
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i8*, i8** %184, i64 %186
%188 = load i8*, i8** %187
%189 = load i32, i32* %15
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i8, i8* %188, i64 %190
%192 = load i8, i8* %191
%193 = sext i8 %192 to i32
%194 = icmp eq i32 %193, 45
br i1 %194, label %195, label %196
195: ; preds = %183, %171, %159, %147, %135, %123, %111, %99
br label %243
196: ; preds = %183
%197 = load i8**, i8*** %5
%198 = load i32, i32* %13
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i8*, i8** %197, i64 %199
%201 = load i8*, i8** %200
%202 = load i32, i32* %14
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i8, i8* %201, i64 %203
%205 = load i8, i8* %204
%206 = call i32 @SymbolIndex(i8 signext %205)
store i32 %206, i32* %16
%207 = load i8**, i8*** %5
%208 = load i32, i32* %13
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds i8*, i8** %207, i64 %209
%211 = load i8*, i8** %210
%212 = load i32, i32* %15
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds i8, i8* %211, i64 %213
%215 = load i8, i8* %214
%216 = call i32 @SymbolIndex(i8 signext %215)
store i32 %216, i32* %17
%217 = load i32, i32* %16
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 %218
%220 = load float, float* %219
%221 = fpext float %220 to double
%222 = fadd double %221, 1.000000e+00
%223 = fptrunc double %222 to float
store float %223, float* %219
%224 = load i32, i32* %17
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 %225
%227 = load float, float* %226
%228 = fpext float %227 to double
%229 = fadd double %228, 1.000000e+00
%230 = fptrunc double %229 to float
store float %230, float* %226
%231 = load i32, i32* %16
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %12, i64 0, i64 %232
%234 = load i32, i32* %17
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds [4 x float], [4 x float]* %233, i64 0, i64 %235
%237 = load float, float* %236
%238 = fpext float %237 to double
%239 = fadd double %238, 1.000000e+00
%240 = fptrunc double %239 to float
store float %240, float* %236
%241 = load i32, i32* %18
%242 = add nsw i32 %241, 1
store i32 %242, i32* %18
br label %243
243: ; preds = %196, %195
%244 = load i32, i32* %13
%245 = add nsw i32 %244, 1
store i32 %245, i32* %13
br label %95
246: ; preds = %95
%247 = load i32, i32* %18
%248 = icmp sgt i32 %247, 0
br i1 %248, label %249, label %290
249: ; preds = %246
store i32 0, i32* %16
br label %250
250: ; preds = %286, %249
%251 = load i32, i32* %16
%252 = icmp slt i32 %251, 4
br i1 %252, label %253, label %289
253: ; preds = %250
%254 = load i32, i32* %18
%255 = sitofp i32 %254 to float
%256 = load i32, i32* %16
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 %257
%259 = load float, float* %258
%260 = fdiv float %259, %255
store float %260, float* %258
%261 = load i32, i32* %18
%262 = sitofp i32 %261 to float
%263 = load i32, i32* %16
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 %264
%266 = load float, float* %265
%267 = fdiv float %266, %262
store float %267, float* %265
store i32 0, i32* %17
br label %268
268: ; preds = %282, %253
%269 = load i32, i32* %17
%270 = icmp slt i32 %269, 4
br i1 %270, label %271, label %285
271: ; preds = %268
%272 = load i32, i32* %18
%273 = sitofp i32 %272 to float
%274 = load i32, i32* %16
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %12, i64 0, i64 %275
%277 = load i32, i32* %17
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds [4 x float], [4 x float]* %276, i64 0, i64 %278
%280 = load float, float* %279
%281 = fdiv float %280, %273
store float %281, float* %279
br label %282
282: ; preds = %271
%283 = load i32, i32* %17
%284 = add nsw i32 %283, 1
store i32 %284, i32* %17
br label %268
285: ; preds = %268
br label %286
286: ; preds = %285
%287 = load i32, i32* %16
%288 = add nsw i32 %287, 1
store i32 %288, i32* %16
br label %250
289: ; preds = %250
br label %290
290: ; preds = %289, %246
%291 = load i32**, i32*** %9
%292 = load i32, i32* %15
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds i32*, i32** %291, i64 %293
%295 = load i32*, i32** %294
%296 = load i32, i32* %14
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds i32, i32* %295, i64 %297
store i32 0, i32* %298
store i32 0, i32* %16
br label %299
299: ; preds = %361, %290
%300 = load i32, i32* %16
%301 = icmp slt i32 %300, 4
br i1 %301, label %302, label %364
302: ; preds = %299
store i32 0, i32* %17
br label %303
303: ; preds = %357, %302
%304 = load i32, i32* %17
%305 = icmp slt i32 %304, 4
br i1 %305, label %306, label %360
306: ; preds = %303
%307 = load i32, i32* %16
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %12, i64 0, i64 %308
%310 = load i32, i32* %17
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds [4 x float], [4 x float]* %309, i64 0, i64 %311
%313 = load float, float* %312
%314 = fpext float %313 to double
%315 = fcmp ogt double %314, 0.000000e+00
br i1 %315, label %316, label %356
316: ; preds = %306
%317 = load i32, i32* %16
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %12, i64 0, i64 %318
%320 = load i32, i32* %17
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds [4 x float], [4 x float]* %319, i64 0, i64 %321
%323 = load float, float* %322
%324 = fpext float %323 to double
%325 = fmul double 0x4062089FC6DA4485, %324
%326 = load i32, i32* %16
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %12, i64 0, i64 %327
%329 = load i32, i32* %17
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds [4 x float], [4 x float]* %328, i64 0, i64 %330
%332 = load float, float* %331
%333 = load i32, i32* %16
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 %334
%336 = load float, float* %335
%337 = load i32, i32* %17
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 %338
%340 = load float, float* %339
%341 = fmul float %336, %340
%342 = fdiv float %332, %341
%343 = call double @log(float %342)
%344 = fmul double %325, %343
%345 = fptosi double %344 to i32
%346 = load i32**, i32*** %9
%347 = load i32, i32* %15
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds i32*, i32** %346, i64 %348
%350 = load i32*, i32** %349
%351 = load i32, i32* %14
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds i32, i32* %350, i64 %352
%354 = load i32, i32* %353
%355 = add nsw i32 %354, %345
store i32 %355, i32* %353
br label %356
356: ; preds = %316, %306
br label %357
357: ; preds = %356
%358 = load i32, i32* %17
%359 = add nsw i32 %358, 1
store i32 %359, i32* %17
br label %303
360: ; preds = %303
br label %361
361: ; preds = %360
%362 = load i32, i32* %16
%363 = add nsw i32 %362, 1
store i32 %363, i32* %16
br label %299
364: ; preds = %299
%365 = load i32**, i32*** %9
%366 = load i32, i32* %15
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds i32*, i32** %365, i64 %367
%369 = load i32*, i32** %368
%370 = load i32, i32* %14
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds i32, i32* %369, i64 %371
%373 = load i32, i32* %372
%374 = load i32, i32* %18
%375 = mul nsw i32 %373, %374
%376 = load i32, i32* %6
%377 = sdiv i32 %375, %376
%378 = load i32**, i32*** %9
%379 = load i32, i32* %15
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds i32*, i32** %378, i64 %380
%382 = load i32*, i32** %381
%383 = load i32, i32* %14
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds i32, i32* %382, i64 %384
store i32 %377, i32* %385
br label %386
386: ; preds = %364
%387 = load i32, i32* %14
%388 = add nsw i32 %387, 1
store i32 %388, i32* %14
br label %62
389: ; preds = %62
br label %390
390: ; preds = %389
%391 = load i32, i32* %15
%392 = add nsw i32 %391, 1
store i32 %392, i32* %15
br label %57
393: ; preds = %57
%394 = load i32**, i32*** %9
%395 = load i32***, i32**** %8
store i32** %394, i32*** %395
ret void
}

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