#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 */
float *malloc(int);
float pow(int, int);
int /*<<< orphan*/ printf(char *, ...);
int strlen(char *);
void frequencyAnalysis(char *ciphertext, int N, float **out) {
  float letterFrequency[] = {
      0.0817, 0.0149, 0.0278, 0.0425, 0.127,  0.0223, 0.0202, 0.0609, 0.0697,
      0.0015, 0.0077, 0.0402, 0.0241, 0.0675, 0.0751, 0.0193, 0.0009, 0.0599,
      0.0633, 0.0906, 0.0276, 0.0098, 0.0236, 0.0015, 0.0197, 0.0007};
  int len = strlen(ciphertext);
  float expectedCounts[26];
  for (int i = 0; i < 26; i++) {
    expectedCounts[i] = letterFrequency[i] * len;
  }
  int permutation[N], letters[26], cipherSliceArray[N], letter;
  float chiSquared;
  float *results = malloc((int)pow(26, N) * sizeof(float));
  for (int p = 0; p < pow(26, N); p++) {
    for (int n = 0; n < N; n++)
      permutation[n] = (int)(p / pow(26, N - (n + 1))) % 26;
    for (int i = 0; i < 26; i++)
      letters[i] = 0;
    if (p == 406) {
      for (int i = 0; i < 2; i++)
        printf("%d ", permutation[i]);
      printf("\n");
    }
    for (int l = 0; l < len / N; l++) {
      for (int i = 0; i < N; i++) {
        cipherSliceArray[i] = ciphertext[N * l + i] - 65;
      }
      letter = 0;
      for (int i = 0; i < N; i++) {
        letter += permutation[i] * cipherSliceArray[i];
      }
      letter = letter % 26;
      letters[letter]++;
      chiSquared = 0;
      for (int i = 0; i < 26; i++) {
        chiSquared +=
            pow(letters[i] - expectedCounts[i], 2) / expectedCounts[i];
      }
    }
    results[p] = chiSquared;
  }
  *out = results;
}


x86 assembly (clang, -O0):
<frequencyAnalysis>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0x80(%rbp),%rdi
lea    0xe8f(%rip),%rsi
mov    $0x68,%edx
call   1050 <memcpy@plt>
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x84(%rbp)
movl   $0x0,-0xf4(%rbp)
cmpl   $0x1a,-0xf4(%rbp)
jge    11de <frequencyAnalysis+0x8e>
movslq -0xf4(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm0
cvtsi2ssl -0x84(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movslq -0xf4(%rbp),%rax
movss  %xmm0,-0xf0(%rbp,%rax,4)
ff ff
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    1194 <frequencyAnalysis+0x44>
mov    -0xc(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x100(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1b8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x108(%rbp)
mov    -0xc(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1b0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x178(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1a,%edi
call   1070 <pow@plt>
cvttss2si %xmm0,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x188(%rbp)
movl   $0x0,-0x18c(%rbp)
cvtsi2ssl -0x18c(%rbp),%xmm0
ff
movss  %xmm0,-0x1bc(%rbp)
ff
mov    -0xc(%rbp),%esi
mov    $0x1a,%edi
call   1070 <pow@plt>
movss  -0x1bc(%rbp),%xmm1
ff
ucomiss %xmm1,%xmm0
jbe    15a1 <frequencyAnalysis+0x451>
movl   $0x0,-0x190(%rbp)
mov    -0x190(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1312 <frequencyAnalysis+0x1c2>
cvtsi2ssl -0x18c(%rbp),%xmm0
ff
movss  %xmm0,-0x1c0(%rbp)
ff
mov    -0xc(%rbp),%esi
mov    -0x190(%rbp),%eax
add    $0x1,%eax
sub    %eax,%esi
mov    $0x1a,%edi
call   1070 <pow@plt>
movaps %xmm0,%xmm1
movss  -0x1c0(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    -0x1b8(%rbp),%rax
movslq -0x190(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x190(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x190(%rbp)
jmp    129b <frequencyAnalysis+0x14b>
movl   $0x0,-0x194(%rbp)
cmpl   $0x1a,-0x194(%rbp)
jge    134f <frequencyAnalysis+0x1ff>
movslq -0x194(%rbp),%rax
movl   $0x0,-0x170(%rbp,%rax,4)
mov    -0x194(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x194(%rbp)
jmp    131c <frequencyAnalysis+0x1cc>
cmpl   $0x196,-0x18c(%rbp)
jne    13b7 <frequencyAnalysis+0x267>
movl   $0x0,-0x198(%rbp)
cmpl   $0x2,-0x198(%rbp)
jge    13a9 <frequencyAnalysis+0x259>
mov    -0x1b8(%rbp),%rax
movslq -0x198(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xcda(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x198(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x198(%rbp)
jmp    1369 <frequencyAnalysis+0x219>
lea    0xcbc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x19c(%rbp)
mov    -0x19c(%rbp),%eax
mov    %eax,-0x1c4(%rbp)
mov    -0x84(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    %eax,%ecx
mov    -0x1c4(%rbp),%eax
cmp    %ecx,%eax
jge    1572 <frequencyAnalysis+0x422>
movl   $0x0,-0x1a0(%rbp)
mov    -0x1a0(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1443 <frequencyAnalysis+0x2f3>
mov    -0x1b0(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
imul   -0x19c(%rbp),%edx
add    -0x1a0(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%edx
sub    $0x41,%edx
movslq -0x1a0(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a0(%rbp)
jmp    13f1 <frequencyAnalysis+0x2a1>
movl   $0x0,-0x17c(%rbp)
movl   $0x0,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14a9 <frequencyAnalysis+0x359>
mov    -0x1b0(%rbp),%rcx
mov    -0x1b8(%rbp),%rax
movslq -0x1a4(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
movslq -0x1a4(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
add    -0x17c(%rbp),%eax
mov    %eax,-0x17c(%rbp)
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    1457 <frequencyAnalysis+0x307>
mov    -0x17c(%rbp),%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    %edx,-0x17c(%rbp)
movslq -0x17c(%rbp),%rax
mov    -0x170(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x170(%rbp,%rax,4)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x180(%rbp)
ff
movl   $0x0,-0x1a8(%rbp)
cmpl   $0x1a,-0x1a8(%rbp)
jge    1559 <frequencyAnalysis+0x409>
movslq -0x1a8(%rbp),%rax
cvtsi2ssl -0x170(%rbp,%rax,4),%xmm0
ff ff
movslq -0x1a8(%rbp),%rax
subss  -0xf0(%rbp,%rax,4),%xmm0
ff ff
cvttss2si %xmm0,%edi
mov    $0x2,%esi
call   1070 <pow@plt>
movslq -0x1a8(%rbp),%rax
divss  -0xf0(%rbp,%rax,4),%xmm0
ff ff
addss  -0x180(%rbp),%xmm0
ff
movss  %xmm0,-0x180(%rbp)
ff
mov    -0x1a8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a8(%rbp)
jmp    14ea <frequencyAnalysis+0x39a>
jmp    155e <frequencyAnalysis+0x40e>
mov    -0x19c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x19c(%rbp)
jmp    13c1 <frequencyAnalysis+0x271>
movss  -0x180(%rbp),%xmm0
ff
mov    -0x188(%rbp),%rax
movslq -0x18c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18c(%rbp)
jmp    1263 <frequencyAnalysis+0x113>
mov    -0x188(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x100(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<frequencyAnalysis>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %rdx,-0x90(%rbp)
mov    %esi,%r12d
mov    %rdi,-0x40(%rbp)
call   1040 <strlen@plt>
mov    %eax,-0x48(%rbp)
cvtsi2ss %eax,%xmm0
mov    %rsp,-0x88(%rbp)
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
movaps 0xe6d(%rip),%xmm2
mulps  %xmm1,%xmm2
movaps %xmm2,-0x190(%rbp)
movaps 0xe6c(%rip),%xmm2
mulps  %xmm1,%xmm2
movaps %xmm2,-0x180(%rbp)
movaps 0xe6b(%rip),%xmm2
mulps  %xmm1,%xmm2
movaps %xmm2,-0x170(%rbp)
movaps 0xe6a(%rip),%xmm2
mulps  %xmm1,%xmm2
movaps %xmm2,-0x160(%rbp)
movaps 0xe69(%rip),%xmm2
mulps  %xmm1,%xmm2
movaps %xmm2,-0x150(%rbp)
mulps  0xe68(%rip),%xmm1
movaps %xmm1,-0x140(%rbp)
movss  0xe79(%rip),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x130(%rbp)
ff
mulss  0xe69(%rip),%xmm0
movss  %xmm0,-0x12c(%rbp)
ff
mov    %r12d,%eax
mov    %rsp,%r13
mov    %rax,-0x78(%rbp)
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r13
mov    %r13,%rsp
mov    %rsp,%r15
sub    %rax,%r15
mov    %r15,%rsp
mov    $0x1a,%edi
mov    %r12d,%esi
call   1070 <pow@plt>
cvttss2si %xmm0,%edi
shl    $0x2,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    $0x1a,%edi
mov    %r12d,%esi
call   1070 <pow@plt>
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm0
jbe    1858 <frequencyAnalysis+0x708>
movslq %r12d,%rax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,-0x70(%rbp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,-0x60(%rbp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x58(%rbp)
lea    0x0(,%rax,4),%rax
mov    %rax,-0xa0(%rbp)
lea    -0x1(%r12),%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x98(%rbp)
xor    %eax,%eax
mov    %rax,-0x38(%rbp)
mov    %r12,-0xa8(%rbp)
jmp    1321 <frequencyAnalysis+0x1d1>
nopl   0x0(%rax)
mov    -0x50(%rbp),%rax
mov    -0x38(%rbp),%rcx
movd   %xmm0,-0x30(%rbp)
movd   %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    $0x1a,%edi
mov    %r12d,%esi
call   1070 <pow@plt>
movss  -0x2c(%rbp),%xmm2
ucomiss %xmm2,%xmm0
jbe    1858 <frequencyAnalysis+0x708>
test   %r12d,%r12d
jle    1390 <frequencyAnalysis+0x240>
mov    -0x44(%rbp),%r14d
xor    %ebx,%ebx
movss  %xmm2,-0x2c(%rbp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x1a,%edi
mov    %r14d,%esi
call   1070 <pow@plt>
movss  -0x2c(%rbp),%xmm1
divss  %xmm0,%xmm1
cvttss2si %xmm1,%eax
cltq
imul   $0x4ec4ec4f,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x23,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rdx,%rdx,4),%edx
add    %ecx,%edx
sub    %edx,%eax
mov    %eax,0x0(%r13,%rbx,1)
add    $0x4,%rbx
add    $0xffffffff,%r14d
cmp    %rbx,-0xa0(%rbp)
jne    1340 <frequencyAnalysis+0x1f0>
xorps  %xmm0,%xmm0
movaps %xmm0,-0xd0(%rbp)
movaps %xmm0,-0xe0(%rbp)
movaps %xmm0,-0xf0(%rbp)
movaps %xmm0,-0x100(%rbp)
movaps %xmm0,-0x110(%rbp)
movaps %xmm0,-0x120(%rbp)
movq   $0x0,-0xc0(%rbp)
cmpq   $0x196,-0x38(%rbp)
jne    13ff <frequencyAnalysis+0x2af>
mov    0x0(%r13),%esi
lea    0xc9b(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x4(%r13),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    -0x48(%rbp),%eax
cltd
idiv   %r12d
test   %eax,%eax
movd   -0x30(%rbp),%xmm0
jle    12e0 <frequencyAnalysis+0x190>
mov    %eax,%eax
mov    %rax,-0xb0(%rbp)
mov    -0x40(%rbp),%r14
mov    -0x98(%rbp),%rbx
xor    %esi,%esi
nopl   0x0(%rax)
xor    %eax,%eax
test   %r12d,%r12d
mov    -0x78(%rbp),%rdi
mov    %rsi,-0xb8(%rbp)
jle    1735 <frequencyAnalysis+0x5e5>
cmp    $0x8,%r12d
jae    1460 <frequencyAnalysis+0x310>
xor    %ecx,%ecx
jmp    1560 <frequencyAnalysis+0x410>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpq   $0x0,-0x68(%rbp)
je     1826 <frequencyAnalysis+0x6d6>
mov    -0x58(%rbp),%rdx
xor    %ecx,%ecx
movdqa 0xbe7(%rip),%xmm2
nopl   0x0(%rax)
movd   -0xc(%rbx,%rcx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   -0x8(%rbx,%rcx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
paddd  %xmm2,%xmm0
paddd  %xmm2,%xmm1
movdqa %xmm0,(%r15,%rcx,4)
movdqa %xmm1,0x10(%r15,%rcx,4)
movd   -0x4(%rbx,%rcx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   (%rbx,%rcx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
paddd  %xmm2,%xmm0
paddd  %xmm2,%xmm1
movdqa %xmm0,0x20(%r15,%rcx,4)
movdqa %xmm1,0x30(%r15,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1480 <frequencyAnalysis+0x330>
testb  $0x1,-0x60(%rbp)
je     1551 <frequencyAnalysis+0x401>
mov    %rsi,%rdx
imul   -0x80(%rbp),%rdx
add    %rcx,%rdx
mov    -0x40(%rbp),%r8
movd   (%r8,%rdx,1),%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0x4(%r8,%rdx,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm0
psrad  $0x18,%xmm1
paddd  %xmm2,%xmm0
paddd  %xmm2,%xmm1
movdqa %xmm0,(%r15,%rcx,4)
movdqa %xmm1,0x10(%r15,%rcx,4)
mov    -0x70(%rbp),%rdx
mov    %rdx,%rcx
cmp    %rdi,%rdx
je     1575 <frequencyAnalysis+0x425>
nopl   (%rax)
movsbl (%r14,%rcx,1),%edx
add    $0xffffffbf,%edx
mov    %edx,(%r15,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1560 <frequencyAnalysis+0x410>
test   %r12d,%r12d
jle    1735 <frequencyAnalysis+0x5e5>
cmp    $0x8,%r12d
jae    158d <frequencyAnalysis+0x43d>
xor    %ecx,%ecx
xor    %eax,%eax
jmp    1720 <frequencyAnalysis+0x5d0>
cmpq   $0x0,-0x68(%rbp)
je     183f <frequencyAnalysis+0x6ef>
pxor   %xmm0,%xmm0
mov    -0x58(%rbp),%rcx
xor    %eax,%eax
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqa 0x0(%r13,%rax,4),%xmm5
movdqa 0x10(%r13,%rax,4),%xmm10
movdqa 0x20(%r13,%rax,4),%xmm9
movdqa 0x30(%r13,%rax,4),%xmm8
movdqa (%r15,%rax,4),%xmm7
movdqa 0x10(%r15,%rax,4),%xmm2
movdqa 0x20(%r15,%rax,4),%xmm4
movdqa 0x30(%r15,%rax,4),%xmm3
pshufd $0xf5,%xmm7,%xmm6
pmuludq %xmm5,%xmm7
pshufd $0xe8,%xmm7,%xmm7
pshufd $0xf5,%xmm5,%xmm5
pmuludq %xmm6,%xmm5
pshufd $0xe8,%xmm5,%xmm5
punpckldq %xmm5,%xmm7
paddd  %xmm0,%xmm7
pshufd $0xf5,%xmm2,%xmm0
pmuludq %xmm10,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm10,%xmm5
pmuludq %xmm0,%xmm5
pshufd $0xe8,%xmm5,%xmm0
punpckldq %xmm0,%xmm2
paddd  %xmm1,%xmm2
pshufd $0xf5,%xmm4,%xmm1
pmuludq %xmm9,%xmm4
pshufd $0xe8,%xmm4,%xmm0
pshufd $0xf5,%xmm9,%xmm4
pmuludq %xmm1,%xmm4
pshufd $0xe8,%xmm4,%xmm1
punpckldq %xmm1,%xmm0
paddd  %xmm7,%xmm0
pshufd $0xf5,%xmm3,%xmm4
pmuludq %xmm8,%xmm3
pshufd $0xe8,%xmm3,%xmm1
pshufd $0xf5,%xmm8,%xmm3
pmuludq %xmm4,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
paddd  %xmm2,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    15b0 <frequencyAnalysis+0x460>
testb  $0x1,-0x60(%rbp)
je     16f4 <frequencyAnalysis+0x5a4>
movdqa 0x0(%r13,%rax,4),%xmm2
movdqa 0x10(%r13,%rax,4),%xmm3
movdqa (%r15,%rax,4),%xmm4
movdqa 0x10(%r15,%rax,4),%xmm5
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm2,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm6,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm4
paddd  %xmm4,%xmm0
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm3,%xmm5
pshufd $0xe8,%xmm5,%xmm4
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm2,%xmm3
pshufd $0xe8,%xmm3,%xmm2
punpckldq %xmm2,%xmm4
paddd  %xmm4,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
mov    -0x70(%rbp),%rdx
mov    %rdx,%rcx
cmp    %rdi,%rdx
je     1735 <frequencyAnalysis+0x5e5>
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rcx,4),%edx
imul   0x0(%r13,%rcx,4),%edx
add    %edx,%eax
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1720 <frequencyAnalysis+0x5d0>
cltq
imul   $0x4ec4ec4f,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x23,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rdx,%rdx,4),%edx
add    %ecx,%edx
sub    %edx,%eax
cltq
addl   $0x1,-0x120(%rbp,%rax,4)
01
pxor   %xmm0,%xmm0
mov    $0x1,%r12d
nopl   0x0(%rax)
movd   %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
cvtsi2ssl -0x124(%rbp,%r12,4),%xmm0
fe ff ff
movss  -0x194(%rbp,%r12,4),%xmm1
fe ff ff
movss  %xmm1,-0x2c(%rbp)
subss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
mov    $0x2,%esi
call   1070 <pow@plt>
divss  -0x2c(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
cvtsi2ssl -0x120(%rbp,%r12,4),%xmm0
fe ff ff
movss  -0x190(%rbp,%r12,4),%xmm1
fe ff ff
movss  %xmm1,-0x2c(%rbp)
subss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
mov    $0x2,%esi
call   1070 <pow@plt>
divss  -0x2c(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
add    $0x2,%r12
cmp    $0x1b,%r12
jne    1770 <frequencyAnalysis+0x620>
mov    -0xb8(%rbp),%rsi
add    $0x1,%rsi
mov    -0x80(%rbp),%rax
add    %rax,%rbx
add    %rax,%r14
cmp    -0xb0(%rbp),%rsi
mov    -0xa8(%rbp),%r12
jne    1430 <frequencyAnalysis+0x2e0>
jmp    12e0 <frequencyAnalysis+0x190>
xor    %ecx,%ecx
movdqa 0x830(%rip),%xmm2
testb  $0x1,-0x60(%rbp)
jne    1506 <frequencyAnalysis+0x3b6>
jmp    1551 <frequencyAnalysis+0x401>
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
testb  $0x1,-0x60(%rbp)
jne    1691 <frequencyAnalysis+0x541>
jmp    16f4 <frequencyAnalysis+0x5a4>
mov    -0x90(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    %rcx,(%rax)
mov    -0x88(%rbp),%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.frequencyAnalysis.letterFrequency = [26 x float] [float 0x3FB4EA4A80000000, float 0x3F8E83E420000000, float 0x3F9C779A60000000, float 0x3FA5C28F60000000, float 0x3FC0418940000000, float 0x3F96D5CFA0000000, float 0x3F94AF4F00000000, float 0x3FAF2E48E0000000, float 0x3FB1D7DC00000000, float 0x3F589374C0000000, float 0x3F7F8A0900000000, float 0x3FA4951820000000, float 0x3F98ADABA0000000, float 0x3FB147AE20000000, float 0x3FB339C0E0000000, float 0x3F93C36120000000, float 0x3F4D7DBF40000000, float 0x3FAEAB3680000000, float 0x3FB0346DC0000000, float 0x3FB7318FC0000000, float 0x3F9C432CA0000000, float 0x3F841205C0000000, float 0x3F982A9940000000, float 0x3F589374C0000000, float 0x3F942C3CA0000000, float 0x3F46F00680000000]
@.str = [4 x i8] c"%d \00"
@.str.1 = [2 x i8] c"\0A\00"
define void @frequencyAnalysis(i8* %0, i32 %1, float** %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca float**
%7 = alloca [26 x float]
%8 = alloca i32
%9 = alloca [26 x float]
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i64
%13 = alloca [26 x i32]
%14 = alloca i64
%15 = alloca i32
%16 = alloca float
%17 = alloca float*
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store float** %2, float*** %6
%26 = bitcast [26 x float]* %7 to i8*
%27 = load i8*, i8** %4
%28 = call i32 @strlen(i8* %27)
store i32 %28, i32* %8
store i32 0, i32* %10
br label %29
29: ; preds = %43, %3
%30 = load i32, i32* %10
%31 = icmp slt i32 %30, 26
br i1 %31, label %32, label %46
32: ; preds = %29
%33 = load i32, i32* %10
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [26 x float], [26 x float]* %7, i64 0, i64 %34
%36 = load float, float* %35
%37 = load i32, i32* %8
%38 = sitofp i32 %37 to float
%39 = fmul float %36, %38
%40 = load i32, i32* %10
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [26 x float], [26 x float]* %9, i64 0, i64 %41
store float %39, float* %42
br label %43
43: ; preds = %32
%44 = load i32, i32* %10
%45 = add nsw i32 %44, 1
store i32 %45, i32* %10
br label %29
46: ; preds = %29
%47 = load i32, i32* %5
%48 = zext i32 %47 to i64
%49 = call i8* @llvm.stacksave()
store i8* %49, i8** %11
%50 = alloca i32, i64 %48
store i64 %48, i64* %12
%51 = load i32, i32* %5
%52 = zext i32 %51 to i64
%53 = alloca i32, i64 %52
store i64 %52, i64* %14
%54 = load i32, i32* %5
%55 = call float @pow(i32 26, i32 %54)
%56 = fptosi float %55 to i32
%57 = sext i32 %56 to i64
%58 = mul i64 %57, 4
%59 = trunc i64 %58 to i32
%60 = call float* @malloc(i32 %59)
store float* %60, float** %17
store i32 0, i32* %18
br label %61
61: ; preds = %212, %46
%62 = load i32, i32* %18
%63 = sitofp i32 %62 to float
%64 = load i32, i32* %5
%65 = call float @pow(i32 26, i32 %64)
%66 = fcmp olt float %63, %65
br i1 %66, label %67, label %215
67: ; preds = %61
store i32 0, i32* %19
br label %68
68: ; preds = %86, %67
%69 = load i32, i32* %19
%70 = load i32, i32* %5
%71 = icmp slt i32 %69, %70
br i1 %71, label %72, label %89
72: ; preds = %68
%73 = load i32, i32* %18
%74 = sitofp i32 %73 to float
%75 = load i32, i32* %5
%76 = load i32, i32* %19
%77 = add nsw i32 %76, 1
%78 = sub nsw i32 %75, %77
%79 = call float @pow(i32 26, i32 %78)
%80 = fdiv float %74, %79
%81 = fptosi float %80 to i32
%82 = srem i32 %81, 26
%83 = load i32, i32* %19
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %50, i64 %84
store i32 %82, i32* %85
br label %86
86: ; preds = %72
%87 = load i32, i32* %19
%88 = add nsw i32 %87, 1
store i32 %88, i32* %19
br label %68
89: ; preds = %68
store i32 0, i32* %20
br label %90
90: ; preds = %97, %89
%91 = load i32, i32* %20
%92 = icmp slt i32 %91, 26
br i1 %92, label %93, label %100
93: ; preds = %90
%94 = load i32, i32* %20
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [26 x i32], [26 x i32]* %13, i64 0, i64 %95
store i32 0, i32* %96
br label %97
97: ; preds = %93
%98 = load i32, i32* %20
%99 = add nsw i32 %98, 1
store i32 %99, i32* %20
br label %90
100: ; preds = %90
%101 = load i32, i32* %18
%102 = icmp eq i32 %101, 406
br i1 %102, label %103, label %118
103: ; preds = %100
store i32 0, i32* %21
br label %104
104: ; preds = %113, %103
%105 = load i32, i32* %21
%106 = icmp slt i32 %105, 2
br i1 %106, label %107, label %116
107: ; preds = %104
%108 = load i32, i32* %21
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %50, i64 %109
%111 = load i32, i32* %110
%112 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %111)
br label %113
113: ; preds = %107
%114 = load i32, i32* %21
%115 = add nsw i32 %114, 1
store i32 %115, i32* %21
br label %104
116: ; preds = %104
%117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %118
118: ; preds = %116, %100
store i32 0, i32* %22
br label %119
119: ; preds = %203, %118
%120 = load i32, i32* %22
%121 = load i32, i32* %8
%122 = load i32, i32* %5
%123 = sdiv i32 %121, %122
%124 = icmp slt i32 %120, %123
br i1 %124, label %125, label %206
125: ; preds = %119
store i32 0, i32* %23
br label %126
126: ; preds = %145, %125
%127 = load i32, i32* %23
%128 = load i32, i32* %5
%129 = icmp slt i32 %127, %128
br i1 %129, label %130, label %148
130: ; preds = %126
%131 = load i8*, i8** %4
%132 = load i32, i32* %5
%133 = load i32, i32* %22
%134 = mul nsw i32 %132, %133
%135 = load i32, i32* %23
%136 = add nsw i32 %134, %135
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds i8, i8* %131, i64 %137
%139 = load i8, i8* %138
%140 = sext i8 %139 to i32
%141 = sub nsw i32 %140, 65
%142 = load i32, i32* %23
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i32, i32* %53, i64 %143
store i32 %141, i32* %144
br label %145
145: ; preds = %130
%146 = load i32, i32* %23
%147 = add nsw i32 %146, 1
store i32 %147, i32* %23
br label %126
148: ; preds = %126
store i32 0, i32* %15
store i32 0, i32* %24
br label %149
149: ; preds = %165, %148
%150 = load i32, i32* %24
%151 = load i32, i32* %5
%152 = icmp slt i32 %150, %151
br i1 %152, label %153, label %168
153: ; preds = %149
%154 = load i32, i32* %24
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %50, i64 %155
%157 = load i32, i32* %156
%158 = load i32, i32* %24
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i32, i32* %53, i64 %159
%161 = load i32, i32* %160
%162 = mul nsw i32 %157, %161
%163 = load i32, i32* %15
%164 = add nsw i32 %163, %162
store i32 %164, i32* %15
br label %165
165: ; preds = %153
%166 = load i32, i32* %24
%167 = add nsw i32 %166, 1
store i32 %167, i32* %24
br label %149
168: ; preds = %149
%169 = load i32, i32* %15
%170 = srem i32 %169, 26
store i32 %170, i32* %15
%171 = load i32, i32* %15
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds [26 x i32], [26 x i32]* %13, i64 0, i64 %172
%174 = load i32, i32* %173
%175 = add nsw i32 %174, 1
store i32 %175, i32* %173
store float 0.000000e+00, float* %16
store i32 0, i32* %25
br label %176
176: ; preds = %199, %168
%177 = load i32, i32* %25
%178 = icmp slt i32 %177, 26
br i1 %178, label %179, label %202
179: ; preds = %176
%180 = load i32, i32* %25
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [26 x i32], [26 x i32]* %13, i64 0, i64 %181
%183 = load i32, i32* %182
%184 = sitofp i32 %183 to float
%185 = load i32, i32* %25
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds [26 x float], [26 x float]* %9, i64 0, i64 %186
%188 = load float, float* %187
%189 = fsub float %184, %188
%190 = fptosi float %189 to i32
%191 = call float @pow(i32 %190, i32 2)
%192 = load i32, i32* %25
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [26 x float], [26 x float]* %9, i64 0, i64 %193
%195 = load float, float* %194
%196 = fdiv float %191, %195
%197 = load float, float* %16
%198 = fadd float %197, %196
store float %198, float* %16
br label %199
199: ; preds = %179
%200 = load i32, i32* %25
%201 = add nsw i32 %200, 1
store i32 %201, i32* %25
br label %176
202: ; preds = %176
br label %203
203: ; preds = %202
%204 = load i32, i32* %22
%205 = add nsw i32 %204, 1
store i32 %205, i32* %22
br label %119
206: ; preds = %119
%207 = load float, float* %16
%208 = load float*, float** %17
%209 = load i32, i32* %18
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds float, float* %208, i64 %210
store float %207, float* %211
br label %212
212: ; preds = %206
%213 = load i32, i32* %18
%214 = add nsw i32 %213, 1
store i32 %214, i32* %18
br label %61
215: ; preds = %61
%216 = load float*, float** %17
%217 = load float**, float*** %6
store float* %216, float** %217
%218 = load i8*, i8** %11
ret void
}

LLVM IR (-O2):
@.str = [4 x i8] c"%d \00"
define void @frequencyAnalysis(i8* %0, i32 %1, float** nocapture writeonly %2) {
%4 = alloca [26 x float]
%5 = alloca [26 x i32]
%6 = bitcast [26 x i32]* %5 to i8*
%7 = tail call i32 @strlen(i8* %0)
%8 = bitcast [26 x float]* %4 to i8*
%9 = sitofp i32 %7 to float
%10 = insertelement <4 x float> poison, float %9, i64 0
%11 = shufflevector <4 x float> %10, <4 x float> poison, <4 x i32> zeroinitializer
%12 = fmul <4 x float> %11, <float 0x3FB4EA4A80000000, float 0x3F8E83E420000000, float 0x3F9C779A60000000, float 0x3FA5C28F60000000>
%13 = bitcast [26 x float]* %4 to <4 x float>*
store <4 x float> %12, <4 x float>* %13
%14 = fmul <4 x float> %11, <float 0x3FC0418940000000, float 0x3F96D5CFA0000000, float 0x3F94AF4F00000000, float 0x3FAF2E48E0000000>
%15 = getelementptr inbounds [26 x float], [26 x float]* %4, i64 0, i64 4
%16 = bitcast float* %15 to <4 x float>*
store <4 x float> %14, <4 x float>* %16
%17 = fmul <4 x float> %11, <float 0x3FB1D7DC00000000, float 0x3F589374C0000000, float 0x3F7F8A0900000000, float 0x3FA4951820000000>
%18 = getelementptr inbounds [26 x float], [26 x float]* %4, i64 0, i64 8
%19 = bitcast float* %18 to <4 x float>*
store <4 x float> %17, <4 x float>* %19
%20 = fmul <4 x float> %11, <float 0x3F98ADABA0000000, float 0x3FB147AE20000000, float 0x3FB339C0E0000000, float 0x3F93C36120000000>
%21 = getelementptr inbounds [26 x float], [26 x float]* %4, i64 0, i64 12
%22 = bitcast float* %21 to <4 x float>*
store <4 x float> %20, <4 x float>* %22
%23 = fmul <4 x float> %11, <float 0x3F4D7DBF40000000, float 0x3FAEAB3680000000, float 0x3FB0346DC0000000, float 0x3FB7318FC0000000>
%24 = getelementptr inbounds [26 x float], [26 x float]* %4, i64 0, i64 16
%25 = bitcast float* %24 to <4 x float>*
store <4 x float> %23, <4 x float>* %25
%26 = fmul <4 x float> %11, <float 0x3F9C432CA0000000, float 0x3F841205C0000000, float 0x3F982A9940000000, float 0x3F589374C0000000>
%27 = getelementptr inbounds [26 x float], [26 x float]* %4, i64 0, i64 20
%28 = bitcast float* %27 to <4 x float>*
store <4 x float> %26, <4 x float>* %28
%29 = fmul float %9, 0x3F942C3CA0000000
%30 = getelementptr inbounds [26 x float], [26 x float]* %4, i64 0, i64 24
store float %29, float* %30
%31 = fmul float %9, 0x3F46F00680000000
%32 = getelementptr inbounds [26 x float], [26 x float]* %4, i64 0, i64 25
store float %31, float* %32
%33 = zext i32 %1 to i64
%34 = tail call i8* @llvm.stacksave()
%35 = alloca i32, i64 %33
%36 = alloca i32, i64 %33
%37 = tail call float @pow(i32 26, i32 %1)
%38 = fptosi float %37 to i32
%39 = shl i32 %38, 2
%40 = tail call float* @malloc(i32 %39)
%41 = tail call float @pow(i32 26, i32 %1)
%42 = fcmp ogt float %41, 0.000000e+00
br i1 %42, label %43, label %69
43: ; preds = %3
%44 = icmp sgt i32 %1, 0
%45 = sext i32 %1 to i64
%46 = getelementptr inbounds i32, i32* %35, i64 1
%47 = and i64 %33, 4294967288
%48 = add nsw i64 %47, -8
%49 = lshr exact i64 %48, 3
%50 = add nuw nsw i64 %49, 1
%51 = icmp ult i32 %1, 8
%52 = and i64 %33, 4294967288
%53 = and i64 %50, 1
%54 = icmp eq i64 %48, 0
%55 = and i64 %50, 4611686018427387902
%56 = icmp eq i64 %53, 0
%57 = icmp eq i64 %52, %33
%58 = icmp ult i32 %1, 8
%59 = and i64 %33, 4294967288
%60 = and i64 %50, 1
%61 = icmp eq i64 %48, 0
%62 = and i64 %50, 4611686018427387902
%63 = icmp eq i64 %60, 0
%64 = icmp eq i64 %59, %33
br label %65
65: ; preds = %43, %157
%66 = phi i64 [ 0, %43 ], [ %160, %157 ]
%67 = phi float [ 0.000000e+00, %43 ], [ %162, %157 ]
%68 = phi float [ undef, %43 ], [ %158, %157 ]
br i1 %44, label %72, label %70
69: ; preds = %157, %3
store float* %40, float** %2
tail call void @llvm.stackrestore(i8* %34)
ret void
70: ; preds = %72, %65
%71 = icmp eq i64 %66, 406
br i1 %71, label %83, label %89
72: ; preds = %65, %72
%73 = phi i64 [ %74, %72 ], [ 0, %65 ]
%74 = add nuw nsw i64 %73, 1
%75 = trunc i64 %74 to i32
%76 = sub nsw i32 %1, %75
%77 = tail call float @pow(i32 26, i32 %76)
%78 = fdiv float %67, %77
%79 = fptosi float %78 to i32
%80 = srem i32 %79, 26
%81 = getelementptr inbounds i32, i32* %35, i64 %73
store i32 %80, i32* %81
%82 = icmp eq i64 %74, %33
br i1 %82, label %70, label %72
83: ; preds = %70
%84 = load i32, i32* %35
%85 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %84)
%86 = load i32, i32* %46
%87 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %86)
%88 = tail call i32 @putchar(i32 10)
br label %89
89: ; preds = %83, %70
%90 = sdiv i32 %7, %1
%91 = icmp sgt i32 %90, 0
br i1 %91, label %92, label %157
92: ; preds = %89
%93 = zext i32 %90 to i64
br label %94
94: ; preds = %92, %268
%95 = phi i64 [ 0, %92 ], [ %269, %268 ]
br i1 %44, label %96, label %250
96: ; preds = %94
%97 = mul nsw i64 %95, %45
br i1 %51, label %155, label %98
98: ; preds = %96
br i1 %54, label %136, label %99
99: ; preds = %98, %99
%100 = phi i64 [ %133, %99 ], [ 0, %98 ]
%101 = phi i64 [ %134, %99 ], [ 0, %98 ]
%102 = add nsw i64 %100, %97
%103 = getelementptr inbounds i8, i8* %0, i64 %102
%104 = bitcast i8* %103 to <4 x i8>*
%105 = load <4 x i8>, <4 x i8>* %104
%106 = getelementptr inbounds i8, i8* %103, i64 4
%107 = bitcast i8* %106 to <4 x i8>*
%108 = load <4 x i8>, <4 x i8>* %107
%109 = sext <4 x i8> %105 to <4 x i32>
%110 = sext <4 x i8> %108 to <4 x i32>
%111 = add nsw <4 x i32> %109, <i32 -65, i32 -65, i32 -65, i32 -65>
%112 = add nsw <4 x i32> %110, <i32 -65, i32 -65, i32 -65, i32 -65>
%113 = getelementptr inbounds i32, i32* %36, i64 %100
%114 = bitcast i32* %113 to <4 x i32>*
store <4 x i32> %111, <4 x i32>* %114
%115 = getelementptr inbounds i32, i32* %113, i64 4
%116 = bitcast i32* %115 to <4 x i32>*
store <4 x i32> %112, <4 x i32>* %116
%117 = or i64 %100, 8
%118 = add nsw i64 %117, %97
%119 = getelementptr inbounds i8, i8* %0, i64 %118
%120 = bitcast i8* %119 to <4 x i8>*
%121 = load <4 x i8>, <4 x i8>* %120
%122 = getelementptr inbounds i8, i8* %119, i64 4
%123 = bitcast i8* %122 to <4 x i8>*
%124 = load <4 x i8>, <4 x i8>* %123
%125 = sext <4 x i8> %121 to <4 x i32>
%126 = sext <4 x i8> %124 to <4 x i32>
%127 = add nsw <4 x i32> %125, <i32 -65, i32 -65, i32 -65, i32 -65>
%128 = add nsw <4 x i32> %126, <i32 -65, i32 -65, i32 -65, i32 -65>
%129 = getelementptr inbounds i32, i32* %36, i64 %117
%130 = bitcast i32* %129 to <4 x i32>*
store <4 x i32> %127, <4 x i32>* %130
%131 = getelementptr inbounds i32, i32* %129, i64 4
%132 = bitcast i32* %131 to <4 x i32>*
store <4 x i32> %128, <4 x i32>* %132
%133 = add nuw i64 %100, 16
%134 = add i64 %101, 2
%135 = icmp eq i64 %134, %55
br i1 %135, label %136, label %99
136: ; preds = %99, %98
%137 = phi i64 [ 0, %98 ], [ %133, %99 ]
br i1 %56, label %154, label %138
138: ; preds = %136
%139 = add nsw i64 %137, %97
%140 = getelementptr inbounds i8, i8* %0, i64 %139
%141 = bitcast i8* %140 to <4 x i8>*
%142 = load <4 x i8>, <4 x i8>* %141
%143 = getelementptr inbounds i8, i8* %140, i64 4
%144 = bitcast i8* %143 to <4 x i8>*
%145 = load <4 x i8>, <4 x i8>* %144
%146 = sext <4 x i8> %142 to <4 x i32>
%147 = sext <4 x i8> %145 to <4 x i32>
%148 = add nsw <4 x i32> %146, <i32 -65, i32 -65, i32 -65, i32 -65>
%149 = add nsw <4 x i32> %147, <i32 -65, i32 -65, i32 -65, i32 -65>
%150 = getelementptr inbounds i32, i32* %36, i64 %137
%151 = bitcast i32* %150 to <4 x i32>*
store <4 x i32> %148, <4 x i32>* %151
%152 = getelementptr inbounds i32, i32* %150, i64 4
%153 = bitcast i32* %152 to <4 x i32>*
store <4 x i32> %149, <4 x i32>* %153
br label %154
154: ; preds = %136, %138
br i1 %57, label %165, label %155
155: ; preds = %96, %154
%156 = phi i64 [ 0, %96 ], [ %52, %154 ]
br label %240
157: ; preds = %268, %89
%158 = phi float [ %68, %89 ], [ %294, %268 ]
%159 = getelementptr inbounds float, float* %40, i64 %66
store float %158, float* %159
%160 = add nuw i64 %66, 1
%161 = trunc i64 %160 to i32
%162 = sitofp i32 %161 to float
%163 = tail call float @pow(i32 26, i32 %1)
%164 = fcmp ogt float %163, %162
br i1 %164, label %65, label %69
165: ; preds = %240, %154
br i1 %44, label %166, label %250
166: ; preds = %165
br i1 %58, label %237, label %167
167: ; preds = %166
br i1 %61, label %209, label %168
168: ; preds = %167, %168
%169 = phi i64 [ %206, %168 ], [ 0, %167 ]
%170 = phi <4 x i32> [ %204, %168 ], [ zeroinitializer, %167 ]
%171 = phi <4 x i32> [ %205, %168 ], [ zeroinitializer, %167 ]
%172 = phi i64 [ %207, %168 ], [ 0, %167 ]
%173 = getelementptr inbounds i32, i32* %35, i64 %169
%174 = bitcast i32* %173 to <4 x i32>*
%175 = load <4 x i32>, <4 x i32>* %174
%176 = getelementptr inbounds i32, i32* %173, i64 4
%177 = bitcast i32* %176 to <4 x i32>*
%178 = load <4 x i32>, <4 x i32>* %177
%179 = getelementptr inbounds i32, i32* %36, i64 %169
%180 = bitcast i32* %179 to <4 x i32>*
%181 = load <4 x i32>, <4 x i32>* %180
%182 = getelementptr inbounds i32, i32* %179, i64 4
%183 = bitcast i32* %182 to <4 x i32>*
%184 = load <4 x i32>, <4 x i32>* %183
%185 = mul nsw <4 x i32> %181, %175
%186 = mul nsw <4 x i32> %184, %178
%187 = add <4 x i32> %185, %170
%188 = add <4 x i32> %186, %171
%189 = or i64 %169, 8
%190 = getelementptr inbounds i32, i32* %35, i64 %189
%191 = bitcast i32* %190 to <4 x i32>*
%192 = load <4 x i32>, <4 x i32>* %191
%193 = getelementptr inbounds i32, i32* %190, i64 4
%194 = bitcast i32* %193 to <4 x i32>*
%195 = load <4 x i32>, <4 x i32>* %194
%196 = getelementptr inbounds i32, i32* %36, i64 %189
%197 = bitcast i32* %196 to <4 x i32>*
%198 = load <4 x i32>, <4 x i32>* %197
%199 = getelementptr inbounds i32, i32* %196, i64 4
%200 = bitcast i32* %199 to <4 x i32>*
%201 = load <4 x i32>, <4 x i32>* %200
%202 = mul nsw <4 x i32> %198, %192
%203 = mul nsw <4 x i32> %201, %195
%204 = add <4 x i32> %202, %187
%205 = add <4 x i32> %203, %188
%206 = add nuw i64 %169, 16
%207 = add i64 %172, 2
%208 = icmp eq i64 %207, %62
br i1 %208, label %209, label %168
209: ; preds = %168, %167
%210 = phi <4 x i32> [ undef, %167 ], [ %204, %168 ]
%211 = phi <4 x i32> [ undef, %167 ], [ %205, %168 ]
%212 = phi i64 [ 0, %167 ], [ %206, %168 ]
%213 = phi <4 x i32> [ zeroinitializer, %167 ], [ %204, %168 ]
%214 = phi <4 x i32> [ zeroinitializer, %167 ], [ %205, %168 ]
br i1 %63, label %232, label %215
215: ; preds = %209
%216 = getelementptr inbounds i32, i32* %35, i64 %212
%217 = bitcast i32* %216 to <4 x i32>*
%218 = load <4 x i32>, <4 x i32>* %217
%219 = getelementptr inbounds i32, i32* %216, i64 4
%220 = bitcast i32* %219 to <4 x i32>*
%221 = load <4 x i32>, <4 x i32>* %220
%222 = getelementptr inbounds i32, i32* %36, i64 %212
%223 = bitcast i32* %222 to <4 x i32>*
%224 = load <4 x i32>, <4 x i32>* %223
%225 = getelementptr inbounds i32, i32* %222, i64 4
%226 = bitcast i32* %225 to <4 x i32>*
%227 = load <4 x i32>, <4 x i32>* %226
%228 = mul nsw <4 x i32> %224, %218
%229 = mul nsw <4 x i32> %227, %221
%230 = add <4 x i32> %228, %213
%231 = add <4 x i32> %229, %214
br label %232
232: ; preds = %209, %215
%233 = phi <4 x i32> [ %210, %209 ], [ %230, %215 ]
%234 = phi <4 x i32> [ %211, %209 ], [ %231, %215 ]
%235 = add <4 x i32> %234, %233
%236 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %235)
br i1 %64, label %250, label %237
237: ; preds = %166, %232
%238 = phi i64 [ 0, %166 ], [ %59, %232 ]
%239 = phi i32 [ 0, %166 ], [ %236, %232 ]
br label %257
240: ; preds = %155, %240
%241 = phi i64 [ %248, %240 ], [ %156, %155 ]
%242 = add nsw i64 %241, %97
%243 = getelementptr inbounds i8, i8* %0, i64 %242
%244 = load i8, i8* %243
%245 = sext i8 %244 to i32
%246 = add nsw i32 %245, -65
%247 = getelementptr inbounds i32, i32* %36, i64 %241
store i32 %246, i32* %247
%248 = add nuw nsw i64 %241, 1
%249 = icmp eq i64 %248, %33
br i1 %249, label %165, label %240
250: ; preds = %257, %232, %94, %165
%251 = phi i32 [ 0, %165 ], [ 0, %94 ], [ %236, %232 ], [ %265, %257 ]
%252 = srem i32 %251, 26
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds [26 x i32], [26 x i32]* %5, i64 0, i64 %253
%255 = load i32, i32* %254
%256 = add nsw i32 %255, 1
store i32 %256, i32* %254
br label %271
257: ; preds = %237, %257
%258 = phi i64 [ %266, %257 ], [ %238, %237 ]
%259 = phi i32 [ %265, %257 ], [ %239, %237 ]
%260 = getelementptr inbounds i32, i32* %35, i64 %258
%261 = load i32, i32* %260
%262 = getelementptr inbounds i32, i32* %36, i64 %258
%263 = load i32, i32* %262
%264 = mul nsw i32 %263, %261
%265 = add nsw i32 %264, %259
%266 = add nuw nsw i64 %258, 1
%267 = icmp eq i64 %266, %33
br i1 %267, label %250, label %257
268: ; preds = %271
%269 = add nuw nsw i64 %95, 1
%270 = icmp eq i64 %269, %93
br i1 %270, label %157, label %94
271: ; preds = %271, %250
%272 = phi i64 [ 0, %250 ], [ %295, %271 ]
%273 = phi float [ 0.000000e+00, %250 ], [ %294, %271 ]
%274 = getelementptr inbounds [26 x i32], [26 x i32]* %5, i64 0, i64 %272
%275 = load i32, i32* %274
%276 = sitofp i32 %275 to float
%277 = getelementptr inbounds [26 x float], [26 x float]* %4, i64 0, i64 %272
%278 = load float, float* %277
%279 = fsub float %276, %278
%280 = fptosi float %279 to i32
%281 = tail call float @pow(i32 %280, i32 2)
%282 = fdiv float %281, %278
%283 = fadd float %273, %282
%284 = or i64 %272, 1
%285 = getelementptr inbounds [26 x i32], [26 x i32]* %5, i64 0, i64 %284
%286 = load i32, i32* %285
%287 = sitofp i32 %286 to float
%288 = getelementptr inbounds [26 x float], [26 x float]* %4, i64 0, i64 %284
%289 = load float, float* %288
%290 = fsub float %287, %289
%291 = fptosi float %290 to i32
%292 = tail call float @pow(i32 %291, i32 2)
%293 = fdiv float %292, %289
%294 = fadd float %283, %293
%295 = add nuw nsw i64 %272, 2
%296 = icmp eq i64 %295, 26
br i1 %296, label %268, label %271
}