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

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
scalar_t__ feof(int /*<<< orphan*/ *);
char fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fread(float *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, long long *);
scalar_t__ malloc(long long);
int /*<<< orphan*/ printf(char *, ...);
float sqrt(float);
int /*<<< orphan*/ *stdin;
int /*<<< orphan*/ strcmp(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
int main(int argc, char **argv) {
  FILE *f;
  char st1[2000];
  char *bestw[40];
  char file_name[2000], st[100][2000];
  float dist, len, bestd[40], vec[2000];
  long long words, size, a, b, c, d, cn, bi[100];
  float *M;
  char *vocab;
  if (argc < 2) {
    printf(
        "Usage: ./distance <FILE>\nwhere FILE contains word projections in the "
        "BINARY FORMAT\n");
    return 0;
  }
  strcpy(file_name, argv[1]);
  f = fopen(file_name, "rb");
  if (f == NULL) {
    printf("Input file not found\n");
    return -1;
  }
  fscanf(f, "%lld", &words);
  fscanf(f, "%lld", &size);
  vocab = (char *)malloc((long long)words * 50 * sizeof(char));
  for (a = 0; a < 40; a++)
    bestw[a] = (char *)malloc(2000 * sizeof(char));
  M = (float *)malloc((long long)words * (long long)size * sizeof(float));
  if (M == NULL) {
    printf("Cannot allocate memory: %lld MB    %lld  %lld\n",
           (long long)words * size * sizeof(float) / 1048576, words, size);
    return -1;
  }
  for (b = 0; b < words; b++) {
    a = 0;
    while (1) {
      vocab[b * 50 + a] = fgetc(f);
      if (feof(f) || (vocab[b * 50 + a] == ' '))
        break;
      if ((a < 50) && (vocab[b * 50 + a] != '\n'))
        a++;
    }
    vocab[b * 50 + a] = 0;
    for (a = 0; a < size; a++)
      fread(&M[a + b * size], sizeof(float), 1, f);
    len = 0;
    for (a = 0; a < size; a++)
      len += M[a + b * size] * M[a + b * size];
    len = sqrt(len);
    for (a = 0; a < size; a++)
      M[a + b * size] /= len;
  }
  fclose(f);
  while (1) {
    for (a = 0; a < 40; a++)
      bestd[a] = 0;
    for (a = 0; a < 40; a++)
      bestw[a][0] = 0;
    printf("Enter word or sentence (EXIT to break): ");
    a = 0;
    while (1) {
      st1[a] = fgetc(stdin);
      if ((st1[a] == '\n') || (a >= 2000 - 1)) {
        st1[a] = 0;
        break;
      }
      a++;
    }
    if (!strcmp(st1, "EXIT"))
      break;
    cn = 0;
    b = 0;
    c = 0;
    while (1) {
      st[cn][b] = st1[c];
      b++;
      c++;
      st[cn][b] = 0;
      if (st1[c] == 0)
        break;
      if (st1[c] == ' ') {
        cn++;
        b = 0;
        c++;
      }
    }
    cn++;
    for (a = 0; a < cn; a++) {
      for (b = 0; b < words; b++)
        if (!strcmp(&vocab[b * 50], st[a]))
          break;
      if (b == words)
        b = -1;
      bi[a] = b;
      printf("\nWord: %s  Position in vocabulary: %lld\n", st[a], bi[a]);
      if (b == -1) {
        printf("Out of dictionary word!\n");
        break;
      }
    }
    if (b == -1)
      continue;
    printf(
        "\n                                              Word       Cosine "
        "distance\n------------------------------------------------------------"
        "------------\n");
    for (a = 0; a < size; a++)
      vec[a] = 0;
    for (b = 0; b < cn; b++) {
      if (bi[b] == -1)
        continue;
      for (a = 0; a < size; a++)
        vec[a] += M[a + bi[b] * size];
    }
    len = 0;
    for (a = 0; a < size; a++)
      len += vec[a] * vec[a];
    len = sqrt(len);
    for (a = 0; a < size; a++)
      vec[a] /= len;
    for (a = 0; a < 40; a++)
      bestd[a] = -1;
    for (a = 0; a < 40; a++)
      bestw[a][0] = 0;
    for (c = 0; c < words; c++) {
      a = 0;
      for (b = 0; b < cn; b++)
        if (bi[b] == c)
          a = 1;
      if (a == 1)
        continue;
      dist = 0;
      for (a = 0; a < size; a++)
        dist += vec[a] * M[a + c * size];
      for (a = 0; a < 40; a++) {
        if (dist > bestd[a]) {
          for (d = 40 - 1; d > a; d--) {
            bestd[d] = bestd[d - 1];
            strcpy(bestw[d], bestw[d - 1]);
          }
          bestd[a] = dist;
          strcpy(bestw[a], &vocab[c * 50]);
          break;
        }
      }
    }
    for (a = 0; a < 40; a++)
      printf("%50s\t\t%f\n", bestw[a], bestd[a]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x341a0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    11ed <main+0x3d>
lea    0xe2a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1ed1 <main+0xd21>
lea    -0x1100(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
call   1030 <strcpy@plt>
lea    -0x1100(%rbp),%rdi
lea    0xe49(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    123d <main+0x8d>
lea    0xe31(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1ed1 <main+0xd21>
mov    -0x18(%rbp),%rdi
lea    0xe29(%rip),%rsi
lea    -0x33e38(%rbp),%rdx
call   1070 <fscanf@plt>
mov    -0x18(%rbp),%rdi
lea    0xe12(%rip),%rsi
lea    -0x33e40(%rbp),%rdx
call   1070 <fscanf@plt>
imul   $0x32,-0x33e38(%rbp),%rdi
32
shl    $0x0,%rdi
call   10b0 <malloc@plt>
mov    %rax,-0x341a0(%rbp)
movq   $0x0,-0x33e48(%rbp)
cmpq   $0x28,-0x33e48(%rbp)
28
jge    12cf <main+0x11f>
mov    $0x7d0,%edi
call   10b0 <malloc@plt>
mov    %rax,%rcx
mov    -0x33e48(%rbp),%rax
mov    %rcx,-0x930(%rbp,%rax,8)
ff
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    128e <main+0xde>
mov    -0x33e38(%rbp),%rdi
imul   -0x33e40(%rbp),%rdi
ff
shl    $0x2,%rdi
call   10b0 <malloc@plt>
mov    %rax,-0x34198(%rbp)
cmpq   $0x0,-0x34198(%rbp)
jne    133b <main+0x18b>
mov    -0x33e38(%rbp),%rsi
imul   -0x33e40(%rbp),%rsi
ff
shl    $0x2,%rsi
shr    $0x14,%rsi
mov    -0x33e38(%rbp),%rdx
mov    -0x33e40(%rbp),%rcx
lea    0xd4e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1ed1 <main+0xd21>
movq   $0x0,-0x33e50(%rbp)
mov    -0x33e50(%rbp),%rax
cmp    -0x33e38(%rbp),%rax
jge    15d6 <main+0x426>
movq   $0x0,-0x33e48(%rbp)
mov    -0x18(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %al,%dl
mov    -0x341a0(%rbp),%rax
imul   $0x32,-0x33e50(%rbp),%rcx
32
add    -0x33e48(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rdi
call   10a0 <feof@plt>
cmp    $0x0,%rax
jne    13bf <main+0x20f>
mov    -0x341a0(%rbp),%rax
imul   $0x32,-0x33e50(%rbp),%rcx
32
add    -0x33e48(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    13c4 <main+0x214>
jmp    140c <main+0x25c>
cmpq   $0x32,-0x33e48(%rbp)
32
jge    1407 <main+0x257>
mov    -0x341a0(%rbp),%rax
imul   $0x32,-0x33e50(%rbp),%rcx
32
add    -0x33e48(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
je     1407 <main+0x257>
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1365 <main+0x1b5>
mov    -0x341a0(%rbp),%rax
imul   $0x32,-0x33e50(%rbp),%rcx
32
add    -0x33e48(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movq   $0x0,-0x33e48(%rbp)
mov    -0x33e48(%rbp),%rax
cmp    -0x33e40(%rbp),%rax
jge    1496 <main+0x2e6>
mov    -0x34198(%rbp),%rdi
mov    -0x33e48(%rbp),%rax
mov    -0x33e50(%rbp),%rcx
imul   -0x33e40(%rbp),%rcx
ff
add    %rcx,%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rcx
mov    $0x4,%esi
mov    $0x1,%edx
call   1040 <fread@plt>
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1431 <main+0x281>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x31e48(%rbp)
ff
movq   $0x0,-0x33e48(%rbp)
mov    -0x33e48(%rbp),%rax
cmp    -0x33e40(%rbp),%rax
jge    1539 <main+0x389>
mov    -0x34198(%rbp),%rax
mov    -0x33e48(%rbp),%rcx
mov    -0x33e50(%rbp),%rdx
imul   -0x33e40(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x34198(%rbp),%rax
mov    -0x33e48(%rbp),%rcx
mov    -0x33e50(%rbp),%rdx
imul   -0x33e40(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x31e48(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x31e48(%rbp)
ff
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    14ac <main+0x2fc>
movss  -0x31e48(%rbp),%xmm0
ff
call   10d0 <sqrt@plt>
movss  %xmm0,-0x31e48(%rbp)
ff
movq   $0x0,-0x33e48(%rbp)
mov    -0x33e48(%rbp),%rax
cmp    -0x33e40(%rbp),%rax
jge    15ba <main+0x40a>
movss  -0x31e48(%rbp),%xmm1
ff
mov    -0x34198(%rbp),%rax
mov    -0x33e48(%rbp),%rcx
mov    -0x33e50(%rbp),%rdx
imul   -0x33e40(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1559 <main+0x3a9>
jmp    15bf <main+0x40f>
mov    -0x33e50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e50(%rbp)
jmp    1346 <main+0x196>
mov    -0x18(%rbp),%rdi
call   1050 <fclose@plt>
movq   $0x0,-0x33e48(%rbp)
cmpq   $0x28,-0x33e48(%rbp)
28
jge    1622 <main+0x472>
mov    -0x33e48(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x31ef0(%rbp,%rax,4)
fc ff
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    15ea <main+0x43a>
movq   $0x0,-0x33e48(%rbp)
cmpq   $0x28,-0x33e48(%rbp)
28
jge    1664 <main+0x4b4>
mov    -0x33e48(%rbp),%rax
mov    -0x930(%rbp,%rax,8),%rax
ff
movb   $0x0,(%rax)
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    162d <main+0x47d>
lea    0xa3a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movq   $0x0,-0x33e48(%rbp)
mov    0x2964(%rip),%rax
mov    (%rax),%rdi
call   1080 <fgetc@plt>
mov    %al,%cl
mov    -0x33e48(%rbp),%rax
mov    %cl,-0x7f0(%rbp,%rax,1)
mov    -0x33e48(%rbp),%rax
movsbl -0x7f0(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
je     16c5 <main+0x515>
cmpq   $0x7cf,-0x33e48(%rbp)
jl     16d9 <main+0x529>
mov    -0x33e48(%rbp),%rax
movb   $0x0,-0x7f0(%rbp,%rax,1)
jmp    16f0 <main+0x540>
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    167d <main+0x4cd>
lea    -0x7f0(%rbp),%rdi
lea    0x9d0(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%eax
jne    1711 <main+0x561>
jmp    1eca <main+0xd1a>
movq   $0x0,-0x33e68(%rbp)
movq   $0x0,-0x33e50(%rbp)
movq   $0x0,-0x33e58(%rbp)
mov    -0x33e58(%rbp),%rax
mov    -0x7f0(%rbp,%rax,1),%dl
lea    -0x31e40(%rbp),%rax
imul   $0x7d0,-0x33e68(%rbp),%rcx
add    %rcx,%rax
mov    -0x33e50(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x33e50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e50(%rbp)
mov    -0x33e58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e58(%rbp)
lea    -0x31e40(%rbp),%rax
imul   $0x7d0,-0x33e68(%rbp),%rcx
add    %rcx,%rax
mov    -0x33e50(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x33e58(%rbp),%rax
movsbl -0x7f0(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
jne    17c0 <main+0x610>
jmp    180c <main+0x65c>
mov    -0x33e58(%rbp),%rax
movsbl -0x7f0(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
jne    1807 <main+0x657>
mov    -0x33e68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e68(%rbp)
movq   $0x0,-0x33e50(%rbp)
mov    -0x33e58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e58(%rbp)
jmp    1732 <main+0x582>
mov    -0x33e68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e68(%rbp)
movq   $0x0,-0x33e48(%rbp)
mov    -0x33e48(%rbp),%rax
cmp    -0x33e68(%rbp),%rax
jge    1956 <main+0x7a6>
movq   $0x0,-0x33e50(%rbp)
mov    -0x33e50(%rbp),%rax
cmp    -0x33e38(%rbp),%rax
jge    18b2 <main+0x702>
mov    -0x341a0(%rbp),%rdi
imul   $0x32,-0x33e50(%rbp),%rax
32
add    %rax,%rdi
lea    -0x31e40(%rbp),%rsi
imul   $0x7d0,-0x33e48(%rbp),%rax
add    %rax,%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%eax
jne    1896 <main+0x6e6>
jmp    18b2 <main+0x702>
jmp    189b <main+0x6eb>
mov    -0x33e50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e50(%rbp)
jmp    1848 <main+0x698>
mov    -0x33e50(%rbp),%rax
cmp    -0x33e38(%rbp),%rax
jne    18d1 <main+0x721>
movq   $0xffffffffffffffff,-0x33e50(%rbp)
ff ff ff ff
mov    -0x33e50(%rbp),%rcx
mov    -0x33e48(%rbp),%rax
mov    %rcx,-0x34190(%rbp,%rax,8)
ff
lea    -0x31e40(%rbp),%rsi
imul   $0x7d0,-0x33e48(%rbp),%rax
add    %rax,%rsi
mov    -0x33e48(%rbp),%rax
mov    -0x34190(%rbp,%rax,8),%rdx
ff
lea    0x7c1(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
cmpq   $0xffffffffffffffff,-0x33e50(%rbp)
ff
jne    193a <main+0x78a>
lea    0x7ce(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1956 <main+0x7a6>
jmp    193f <main+0x78f>
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1829 <main+0x679>
cmpq   $0xffffffffffffffff,-0x33e50(%rbp)
ff
jne    1969 <main+0x7b9>
jmp    15df <main+0x42f>
lea    0x7a5(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movq   $0x0,-0x33e48(%rbp)
mov    -0x33e48(%rbp),%rax
cmp    -0x33e40(%rbp),%rax
jge    19c0 <main+0x810>
mov    -0x33e48(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x33e30(%rbp,%rax,4)
fc ff
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1982 <main+0x7d2>
movq   $0x0,-0x33e50(%rbp)
mov    -0x33e50(%rbp),%rax
cmp    -0x33e68(%rbp),%rax
jge    1a92 <main+0x8e2>
mov    -0x33e50(%rbp),%rax
cmpq   $0xffffffffffffffff,-0x34190(%rbp,%rax,8)
ff ff
jne    19fa <main+0x84a>
jmp    1a7b <main+0x8cb>
movq   $0x0,-0x33e48(%rbp)
mov    -0x33e48(%rbp),%rax
cmp    -0x33e40(%rbp),%rax
jge    1a76 <main+0x8c6>
mov    -0x34198(%rbp),%rax
mov    -0x33e48(%rbp),%rcx
mov    -0x33e50(%rbp),%rdx
mov    -0x34190(%rbp,%rdx,8),%rdx
ff
imul   -0x33e40(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x33e48(%rbp),%rax
addss  -0x33e30(%rbp,%rax,4),%xmm0
fc ff
movss  %xmm0,-0x33e30(%rbp,%rax,4)
fc ff
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1a05 <main+0x855>
jmp    1a7b <main+0x8cb>
mov    -0x33e50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e50(%rbp)
jmp    19cb <main+0x81b>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x31e48(%rbp)
ff
movq   $0x0,-0x33e48(%rbp)
mov    -0x33e48(%rbp),%rax
cmp    -0x33e40(%rbp),%rax
jge    1b0b <main+0x95b>
mov    -0x33e48(%rbp),%rax
movss  -0x33e30(%rbp,%rax,4),%xmm0
fc ff
mov    -0x33e48(%rbp),%rax
movss  -0x33e30(%rbp,%rax,4),%xmm2
fc ff
movss  -0x31e48(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x31e48(%rbp)
ff
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1aa8 <main+0x8f8>
movss  -0x31e48(%rbp),%xmm0
ff
call   10d0 <sqrt@plt>
movss  %xmm0,-0x31e48(%rbp)
ff
movq   $0x0,-0x33e48(%rbp)
mov    -0x33e48(%rbp),%rax
cmp    -0x33e40(%rbp),%rax
jge    1b7b <main+0x9cb>
movss  -0x31e48(%rbp),%xmm1
ff
mov    -0x33e48(%rbp),%rax
movss  -0x33e30(%rbp,%rax,4),%xmm0
fc ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x33e30(%rbp,%rax,4)
fc ff
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1b2b <main+0x97b>
movq   $0x0,-0x33e48(%rbp)
cmpq   $0x28,-0x33e48(%rbp)
28
jge    1bc3 <main+0xa13>
mov    -0x33e48(%rbp),%rax
movss  0x45d(%rip),%xmm0
movss  %xmm0,-0x31ef0(%rbp,%rax,4)
fc ff
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1b86 <main+0x9d6>
movq   $0x0,-0x33e48(%rbp)
cmpq   $0x28,-0x33e48(%rbp)
28
jge    1c05 <main+0xa55>
mov    -0x33e48(%rbp),%rax
mov    -0x930(%rbp,%rax,8),%rax
ff
movb   $0x0,(%rax)
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1bce <main+0xa1e>
movq   $0x0,-0x33e58(%rbp)
mov    -0x33e58(%rbp),%rax
cmp    -0x33e38(%rbp),%rax
jge    1e64 <main+0xcb4>
movq   $0x0,-0x33e48(%rbp)
movq   $0x0,-0x33e50(%rbp)
mov    -0x33e50(%rbp),%rax
cmp    -0x33e68(%rbp),%rax
jge    1c91 <main+0xae1>
mov    -0x33e50(%rbp),%rax
mov    -0x34190(%rbp,%rax,8),%rax
ff
cmp    -0x33e58(%rbp),%rax
jne    1c75 <main+0xac5>
movq   $0x1,-0x33e48(%rbp)
jmp    1c7a <main+0xaca>
mov    -0x33e50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e50(%rbp)
jmp    1c3a <main+0xa8a>
cmpq   $0x1,-0x33e48(%rbp)
01
jne    1ca4 <main+0xaf4>
jmp    1e4d <main+0xc9d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x31e44(%rbp)
ff
movq   $0x0,-0x33e48(%rbp)
mov    -0x33e48(%rbp),%rax
cmp    -0x33e40(%rbp),%rax
jge    1d32 <main+0xb82>
mov    -0x33e48(%rbp),%rax
movss  -0x33e30(%rbp,%rax,4),%xmm0
fc ff
mov    -0x34198(%rbp),%rax
mov    -0x33e48(%rbp),%rcx
mov    -0x33e58(%rbp),%rdx
imul   -0x33e40(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x31e44(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x31e44(%rbp)
ff
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1cba <main+0xb0a>
movq   $0x0,-0x33e48(%rbp)
cmpq   $0x28,-0x33e48(%rbp)
28
jge    1e48 <main+0xc98>
movss  -0x31e44(%rbp),%xmm0
ff
mov    -0x33e48(%rbp),%rax
ucomiss -0x31ef0(%rbp,%rax,4),%xmm0
ff
jbe    1e2c <main+0xc7c>
movq   $0x27,-0x33e60(%rbp)
mov    -0x33e60(%rbp),%rax
cmp    -0x33e48(%rbp),%rax
jle    1de9 <main+0xc39>
mov    -0x33e60(%rbp),%rax
sub    $0x1,%rax
movss  -0x31ef0(%rbp,%rax,4),%xmm0
fc ff
mov    -0x33e60(%rbp),%rax
movss  %xmm0,-0x31ef0(%rbp,%rax,4)
fc ff
mov    -0x33e60(%rbp),%rax
mov    -0x930(%rbp,%rax,8),%rdi
ff
mov    -0x33e60(%rbp),%rax
sub    $0x1,%rax
mov    -0x930(%rbp,%rax,8),%rsi
ff
call   1030 <strcpy@plt>
mov    -0x33e60(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x33e60(%rbp)
jmp    1d73 <main+0xbc3>
movss  -0x31e44(%rbp),%xmm0
ff
mov    -0x33e48(%rbp),%rax
movss  %xmm0,-0x31ef0(%rbp,%rax,4)
fc ff
mov    -0x33e48(%rbp),%rax
mov    -0x930(%rbp,%rax,8),%rdi
ff
mov    -0x341a0(%rbp),%rsi
imul   $0x32,-0x33e58(%rbp),%rax
32
add    %rax,%rsi
call   1030 <strcpy@plt>
jmp    1e48 <main+0xc98>
jmp    1e31 <main+0xc81>
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1d3d <main+0xb8d>
jmp    1e4d <main+0xc9d>
mov    -0x33e58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e58(%rbp)
jmp    1c10 <main+0xa60>
movq   $0x0,-0x33e48(%rbp)
cmpq   $0x28,-0x33e48(%rbp)
28
jge    1ec5 <main+0xd15>
mov    -0x33e48(%rbp),%rax
mov    -0x930(%rbp,%rax,8),%rsi
ff
mov    -0x33e48(%rbp),%rax
movss  -0x31ef0(%rbp,%rax,4),%xmm0
fc ff
cvtss2sd %xmm0,%xmm0
lea    0x302(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x33e48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x33e48(%rbp)
jmp    1e6f <main+0xcbf>
jmp    15df <main+0x42f>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x341a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x34178,%rsp
cmp    $0x1,%edi
jg     11f9 <main+0x29>
lea    0x1f7f(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
jmp    21ed <main+0x101d>
mov    0x8(%rsi),%rsi
lea    0x2c60(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0x1e00(%rip),%rsi
mov    %rbx,%rdi
call   10e0 <fopen@plt>
test   %rax,%rax
je     21af <main+0xfdf>
mov    %rax,%rbp
lea    0x1de8(%rip),%rbx
lea    0x18(%rsp),%rdx
mov    %rax,%rdi
mov    %rbx,%rsi
call   1090 <fscanf@plt>
lea    0x10(%rsp),%rdx
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1090 <fscanf@plt>
imul   $0x32,0x18(%rsp),%rdi
call   10d0 <malloc@plt>
mov    %rax,0x30(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x7d0,%edi
call   10d0 <malloc@plt>
mov    %rax,0x40(%rsp,%rbx,8)
add    $0x1,%rbx
cmp    $0x28,%rbx
jne    1270 <main+0xa0>
mov    0x18(%rsp),%rdi
imul   0x10(%rsp),%rdi
shl    $0x2,%rdi
call   10d0 <malloc@plt>
mov    0x18(%rsp),%rdx
test   %rax,%rax
je     21bd <main+0xfed>
mov    %rax,%r14
test   %rdx,%rdx
mov    %rax,0x38(%rsp)
jle    1585 <main+0x3b5>
lea    0xc(%r14),%rax
mov    %rax,0x28(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0x8(%rsp)
xor    %r12d,%r12d
xor    %r13d,%r13d
jmp    12f3 <main+0x123>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x4,%r12
cmp    0x18(%rsp),%r13
jge    1585 <main+0x3b5>
mov    %rbp,%rdi
call   10a0 <fgetc@plt>
imul   $0x32,%r13,%rbx
mov    0x30(%rsp),%rcx
lea    (%rcx,%rbx,1),%r15
mov    %al,(%rcx,%rbx,1)
mov    %rbp,%rdi
call   10c0 <feof@plt>
test   %rax,%rax
jne    1370 <main+0x1a0>
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
movzbl (%r15),%eax
cmp    $0x20,%al
je     1370 <main+0x1a0>
cmp    $0x32,%r14
setb   %cl
cmp    $0xa,%al
setne  %al
and    %cl,%al
movzbl %al,%eax
add    %rax,%r14
mov    %rbp,%rdi
call   10a0 <fgetc@plt>
lea    (%r14,%rbx,1),%rcx
mov    0x30(%rsp),%rdx
lea    (%rdx,%rcx,1),%r15
mov    %al,(%rdx,%rcx,1)
mov    %rbp,%rdi
call   10c0 <feof@plt>
test   %rax,%rax
je     1320 <main+0x150>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movb   $0x0,(%r15)
mov    0x10(%rsp),%rax
xorps  %xmm0,%xmm0
test   %rax,%rax
mov    0x38(%rsp),%r14
jle    1476 <main+0x2a6>
xor    %ebx,%ebx
nopl   0x0(%rax)
imul   %r13,%rax
add    %rbx,%rax
lea    (%r14,%rax,4),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbp,%rcx
call   1050 <fread@plt>
add    $0x1,%rbx
mov    0x10(%rsp),%rax
cmp    %rax,%rbx
jl     1390 <main+0x1c0>
test   %rax,%rax
xorps  %xmm0,%xmm0
jle    1476 <main+0x2a6>
lea    -0x1(%rax),%rdx
mov    %eax,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    13dd <main+0x20d>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    1440 <main+0x270>
mov    %rax,%rsi
and    $0xfffffffffffffffc,%rsi
mov    %r12,%rdi
imul   %rax,%rdi
add    0x28(%rsp),%rdi
xorps  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0xc(%rdi,%rdx,4),%xmm2
movss  -0x8(%rdi,%rdx,4),%xmm1
mulss  %xmm2,%xmm2
addss  %xmm0,%xmm2
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movss  -0x4(%rdi,%rdx,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  (%rdi,%rdx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1400 <main+0x230>
test   %rcx,%rcx
je     1476 <main+0x2a6>
lea    (%r14,%rdx,4),%rdx
imul   %r12,%rax
add    %rdx,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rax,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1460 <main+0x290>
ucomiss 0x1b93(%rip),%xmm0
jb     1490 <main+0x2c0>
sqrtss %xmm0,%xmm0
jmp    1495 <main+0x2c5>
cs nopw 0x0(%rax,%rax,1)
nop
call   10f0 <sqrt@plt>
mov    0x10(%rsp),%rbx
test   %rbx,%rbx
jle    12e0 <main+0x110>
cmp    $0x4,%rbx
jae    14b0 <main+0x2e0>
xor    %ecx,%ecx
jmp    1547 <main+0x377>
mov    %rbx,%rcx
and    $0xfffffffffffffffc,%rcx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rcx),%rax
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rax,%rax
je     157c <main+0x3ac>
mov    %rdx,%rdi
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdi
mov    %rbx,%rax
imul   %r12,%rax
add    0x8(%rsp),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rax,%rsi,4),%xmm2
movups (%rax,%rsi,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,-0x10(%rax,%rsi,4)
divps  %xmm1,%xmm3
movups %xmm3,(%rax,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1500 <main+0x330>
test   $0x1,%dl
je     153e <main+0x36e>
mov    %rbx,%rax
imul   %r13,%rax
add    %rsi,%rax
movups (%r14,%rax,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%r14,%rax,4)
cmp    %rcx,%rbx
je     12e0 <main+0x110>
mov    %rbx,%rax
imul   %r12,%rax
add    %r14,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    1560 <main+0x390>
jmp    12e0 <main+0x110>
xor    %esi,%esi
test   $0x1,%dl
jne    1527 <main+0x357>
jmp    153e <main+0x36e>
mov    %rbp,%rdi
call   1060 <fclose@plt>
lea    0x30(%r14),%rax
mov    %rax,0x180(%rsp)
lea    0xc(%r14),%rax
mov    %rax,0x188(%rsp)
jmp    15bc <main+0x3ec>
nopw   0x0(%rax,%rax,1)
lea    0x1b88(%rip),%rdi
call   1040 <puts@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x220(%rsp)
movaps %xmm0,0x210(%rsp)
movaps %xmm0,0x200(%rsp)
movaps %xmm0,0x1f0(%rsp)
movaps %xmm0,0x1e0(%rsp)
movaps %xmm0,0x1d0(%rsp)
movaps %xmm0,0x1c0(%rsp)
movaps %xmm0,0x1b0(%rsp)
movaps %xmm0,0x1a0(%rsp)
movaps %xmm0,0x190(%rsp)
mov    0x40(%rsp),%rax
movb   $0x0,(%rax)
mov    0x48(%rsp),%rax
movb   $0x0,(%rax)
mov    0x50(%rsp),%rax
movb   $0x0,(%rax)
mov    0x58(%rsp),%rax
movb   $0x0,(%rax)
mov    0x60(%rsp),%rax
movb   $0x0,(%rax)
mov    0x68(%rsp),%rax
movb   $0x0,(%rax)
mov    0x70(%rsp),%rax
movb   $0x0,(%rax)
mov    0x78(%rsp),%rax
movb   $0x0,(%rax)
mov    0x80(%rsp),%rax
movb   $0x0,(%rax)
mov    0x88(%rsp),%rax
movb   $0x0,(%rax)
mov    0x90(%rsp),%rax
movb   $0x0,(%rax)
mov    0x98(%rsp),%rax
movb   $0x0,(%rax)
mov    0xa0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xa8(%rsp),%rax
movb   $0x0,(%rax)
mov    0xb0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xb8(%rsp),%rax
movb   $0x0,(%rax)
mov    0xc0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xc8(%rsp),%rax
movb   $0x0,(%rax)
mov    0xd0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xd8(%rsp),%rax
movb   $0x0,(%rax)
mov    0xe0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xe8(%rsp),%rax
movb   $0x0,(%rax)
mov    0xf0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xf8(%rsp),%rax
movb   $0x0,(%rax)
mov    0x100(%rsp),%rax
movb   $0x0,(%rax)
mov    0x108(%rsp),%rax
movb   $0x0,(%rax)
mov    0x110(%rsp),%rax
movb   $0x0,(%rax)
mov    0x118(%rsp),%rax
movb   $0x0,(%rax)
mov    0x120(%rsp),%rax
movb   $0x0,(%rax)
mov    0x128(%rsp),%rax
movb   $0x0,(%rax)
mov    0x130(%rsp),%rax
movb   $0x0,(%rax)
mov    0x138(%rsp),%rax
movb   $0x0,(%rax)
mov    0x140(%rsp),%rax
movb   $0x0,(%rax)
mov    0x148(%rsp),%rax
movb   $0x0,(%rax)
mov    0x150(%rsp),%rax
movb   $0x0,(%rax)
mov    0x158(%rsp),%rax
movb   $0x0,(%rax)
mov    0x160(%rsp),%rax
movb   $0x0,(%rax)
mov    0x168(%rsp),%rax
movb   $0x0,(%rax)
mov    0x170(%rsp),%rax
movb   $0x0,(%rax)
mov    0x178(%rsp),%rax
movb   $0x0,(%rax)
lea    0x1895(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
xor    %ebx,%ebx
mov    0x3822(%rip),%rbp
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp),%rdi
call   10a0 <fgetc@plt>
mov    %al,0x2490(%rsp,%rbx,1)
lea    0x1(%rbx),%rcx
cmp    $0xa,%al
je     17f4 <main+0x624>
cmp    $0x7cf,%rbx
mov    %rcx,%rbx
jb     17d0 <main+0x600>
movb   $0x0,0x248f(%rsp,%rcx,1)
mov    0x2490(%rsp),%eax
mov    $0x54495845,%ecx
xor    %ecx,%eax
movzbl 0x2494(%rsp),%ecx
or     %eax,%ecx
je     21ab <main+0xfdb>
mov    $0x1,%esi
mov    $0x1,%dil
lea    0x3431(%rsp),%rax
xor    %ecx,%ecx
xor    %r12d,%r12d
add    $0x1,%rcx
mov    %rax,%rdx
cs nopw 0x0(%rax,%rax,1)
movzbl 0x248f(%rsp,%rcx,1),%ebx
mov    %bl,-0x1(%rdx)
movb   $0x0,(%rdx)
movzbl 0x2490(%rsp,%rcx,1),%ebx
test   %bl,%bl
je     1880 <main+0x6b0>
add    $0x1,%rdx
add    $0x1,%rcx
cmp    $0x20,%bl
jne    1840 <main+0x670>
add    $0x1,%r12
add    $0x7d0,%rax
add    $0x1,%rsi
add    $0x1,%dil
jmp    182f <main+0x65f>
nopl   0x0(%rax,%rax,1)
mov    %dil,0x8(%rsp)
mov    %rsi,0x20(%rsp)
xor    %r15d,%r15d
nopl   (%rax)
mov    0x18(%rsp),%r14
test   %r14,%r14
jle    18f0 <main+0x720>
imul   $0x7d0,%r15,%rax
lea    (%rsp,%rax,1),%r13
add    $0x3430,%r13
mov    0x30(%rsp),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbx,%rdi
mov    %r13,%rsi
call   10b0 <strcmp@plt>
test   %eax,%eax
je     18f2 <main+0x722>
add    $0x1,%rbp
add    $0x32,%rbx
cmp    %rbp,%r14
jne    18c0 <main+0x6f0>
mov    %r14,%rbp
jmp    18f2 <main+0x722>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %ebp,%ebp
cmp    %r14,%rbp
mov    %rbp,%rdx
mov    $0xffffffffffffffff,%rax
cmove  %rax,%rdx
mov    %rdx,0x230(%rsp,%r15,8)
imul   $0x7d0,%r15,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x3430,%rsi
lea    0x1755(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
cmp    %r14,%rbp
je     15b0 <main+0x3e0>
lea    0x1(%r15),%rax
cmp    %r12,%r15
mov    %rax,%r15
jne    1890 <main+0x6c0>
cmp    $0xffffffffffffffff,%rbp
mov    0x38(%rsp),%r14
je     15bc <main+0x3ec>
lea    0x1752(%rip),%rdi
call   1040 <puts@plt>
mov    0x10(%rsp),%rbx
test   %rbx,%rbx
jle    1980 <main+0x7b0>
lea    0x0(,%rbx,4),%rdx
lea    0x550(%rsp),%rdi
xor    %esi,%esi
call   1080 <memset@plt>
lea    -0x8(%rbx),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %rbx,%rdx
and    $0xfffffffffffffff8,%rdx
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
xor    %edi,%edi
mov    0x180(%rsp),%r11
mov    0x20(%rsp),%r15
jmp    19c0 <main+0x7f0>
xchg   %ax,%ax
lea    0x1(%rdi),%rax
cmp    %r12,%rdi
mov    %rax,%rdi
je     1af0 <main+0x920>
mov    0x230(%rsp,%rdi,8),%rbp
cmp    $0xffffffffffffffff,%rbp
je     19b0 <main+0x7e0>
test   %rbx,%rbx
jle    19b0 <main+0x7e0>
imul   %rbx,%rbp
cmp    $0x8,%rbx
jae    19f0 <main+0x820>
xor    %eax,%eax
jmp    1aae <main+0x8de>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x8,%r9
jae    19fa <main+0x82a>
xor    %esi,%esi
jmp    1a6d <main+0x89d>
lea    (%r11,%rbp,4),%rax
mov    %r8,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rax,%rsi,4),%xmm0
movups -0x20(%rax,%rsi,4),%xmm1
addps  0x550(%rsp,%rsi,4),%xmm0
addps  0x560(%rsp,%rsi,4),%xmm1
movaps %xmm0,0x550(%rsp,%rsi,4)
movaps %xmm1,0x560(%rsp,%rsi,4)
movups -0x10(%rax,%rsi,4),%xmm0
movups (%rax,%rsi,4),%xmm1
addps  0x570(%rsp,%rsi,4),%xmm0
addps  0x580(%rsp,%rsi,4),%xmm1
movaps %xmm0,0x570(%rsp,%rsi,4)
movaps %xmm1,0x580(%rsp,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1a10 <main+0x840>
test   $0x1,%r10b
je     1aa2 <main+0x8d2>
lea    (%rsi,%rbp,1),%rax
movups (%r14,%rax,4),%xmm0
movups 0x10(%r14,%rax,4),%xmm1
addps  0x550(%rsp,%rsi,4),%xmm0
addps  0x560(%rsp,%rsi,4),%xmm1
movaps %xmm0,0x550(%rsp,%rsi,4)
movaps %xmm1,0x560(%rsp,%rsi,4)
mov    %rdx,%rax
cmp    %rdx,%rbx
je     19b0 <main+0x7e0>
lea    (%r14,%rbp,4),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rcx,%rax,4),%xmm0
addss  0x550(%rsp,%rax,4),%xmm0
movss  %xmm0,0x550(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1ac0 <main+0x8f0>
jmp    19b0 <main+0x7e0>
cs nopw 0x0(%rax,%rax,1)
nop
test   %rbx,%rbx
jle    1b0b <main+0x93b>
lea    -0x1(%rbx),%rcx
mov    %ebx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1b13 <main+0x943>
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1b6d <main+0x99d>
xorps  %xmm0,%xmm0
jmp    1b96 <main+0x9c6>
and    $0xfffffffffffffffc,%rbx
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  0x550(%rsp,%rcx,4),%xmm1
movss  0x554(%rsp,%rcx,4),%xmm2
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  0x558(%rsp,%rcx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movss  0x55c(%rsp,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    1b20 <main+0x950>
test   %rax,%rax
je     1b96 <main+0x9c6>
lea    (%rsp,%rcx,4),%rcx
add    $0x550,%rcx
xor    %edx,%edx
nop
movss  (%rcx,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1b80 <main+0x9b0>
ucomiss 0x1473(%rip),%xmm0
jb     1ba5 <main+0x9d5>
sqrtss %xmm0,%xmm0
jmp    1baa <main+0x9da>
call   10f0 <sqrt@plt>
mov    0x10(%rsp),%rax
test   %rax,%rax
jle    1c7f <main+0xaaf>
cmp    $0x4,%rax
jae    1bc5 <main+0x9f5>
xor    %ecx,%ecx
jmp    1c60 <main+0xa90>
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1c37 <main+0xa67>
mov    %rdx,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movaps 0x550(%rsp,%rsi,4),%xmm2
movaps 0x560(%rsp,%rsi,4),%xmm3
divps  %xmm1,%xmm2
movaps %xmm2,0x550(%rsp,%rsi,4)
divps  %xmm1,%xmm3
movaps %xmm3,0x560(%rsp,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1c00 <main+0xa30>
test   $0x1,%dl
jne    1c3e <main+0xa6e>
jmp    1c7a <main+0xaaa>
xor    %esi,%esi
test   $0x1,%dl
je     1c7a <main+0xaaa>
movaps 0x550(%rsp,%rsi,4),%xmm2
divps  %xmm1,%xmm2
movaps %xmm2,0x550(%rsp,%rsi,4)
jmp    1c7a <main+0xaaa>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x550(%rsp,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x550(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1c60 <main+0xa90>
mov    %r12,0x28(%rsp)
movaps 0x1375(%rip),%xmm0
movaps %xmm0,0x190(%rsp)
movaps %xmm0,0x1a0(%rsp)
movaps %xmm0,0x1b0(%rsp)
movaps %xmm0,0x1c0(%rsp)
movaps %xmm0,0x1d0(%rsp)
movaps %xmm0,0x1e0(%rsp)
movaps %xmm0,0x1f0(%rsp)
movaps %xmm0,0x200(%rsp)
movaps %xmm0,0x210(%rsp)
movaps %xmm0,0x220(%rsp)
mov    0x40(%rsp),%rax
movb   $0x0,(%rax)
mov    0x48(%rsp),%rax
movb   $0x0,(%rax)
mov    0x50(%rsp),%rax
movb   $0x0,(%rax)
mov    0x58(%rsp),%rax
movb   $0x0,(%rax)
mov    0x60(%rsp),%rax
movb   $0x0,(%rax)
mov    0x68(%rsp),%rax
movb   $0x0,(%rax)
mov    0x70(%rsp),%rax
movb   $0x0,(%rax)
mov    0x78(%rsp),%rax
movb   $0x0,(%rax)
mov    0x80(%rsp),%rax
movb   $0x0,(%rax)
mov    0x88(%rsp),%rax
movb   $0x0,(%rax)
mov    0x90(%rsp),%rax
movb   $0x0,(%rax)
mov    0x98(%rsp),%rax
movb   $0x0,(%rax)
mov    0xa0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xa8(%rsp),%rax
movb   $0x0,(%rax)
mov    0xb0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xb8(%rsp),%rax
movb   $0x0,(%rax)
mov    0xc0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xc8(%rsp),%rax
movb   $0x0,(%rax)
mov    0xd0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xd8(%rsp),%rax
movb   $0x0,(%rax)
mov    0xe0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xe8(%rsp),%rax
movb   $0x0,(%rax)
mov    0xf0(%rsp),%rax
movb   $0x0,(%rax)
mov    0xf8(%rsp),%rax
movb   $0x0,(%rax)
mov    0x100(%rsp),%rax
movb   $0x0,(%rax)
mov    0x108(%rsp),%rax
movb   $0x0,(%rax)
mov    0x110(%rsp),%rax
movb   $0x0,(%rax)
mov    0x118(%rsp),%rax
movb   $0x0,(%rax)
mov    0x120(%rsp),%rax
movb   $0x0,(%rax)
mov    0x128(%rsp),%rax
movb   $0x0,(%rax)
mov    0x130(%rsp),%rax
movb   $0x0,(%rax)
mov    0x138(%rsp),%rax
movb   $0x0,(%rax)
mov    0x140(%rsp),%rax
movb   $0x0,(%rax)
mov    0x148(%rsp),%rax
movb   $0x0,(%rax)
mov    0x150(%rsp),%rax
movb   $0x0,(%rax)
mov    0x158(%rsp),%rax
movb   $0x0,(%rax)
mov    0x160(%rsp),%rax
movb   $0x0,(%rax)
mov    0x168(%rsp),%rax
movb   $0x0,(%rax)
mov    0x170(%rsp),%rax
movb   $0x0,(%rax)
mov    0x178(%rsp),%rax
movb   $0x0,(%rax)
mov    0x18(%rsp),%r8
test   %r8,%r8
jle    2170 <main+0xfa0>
mov    0x28(%rsp),%rax
lea    0x1(%rax),%r12
and    $0xfffffffffffffffc,%r15
movzbl 0x8(%rsp),%ebp
and    $0x3,%ebp
xor    %r14d,%r14d
xor    %r13d,%r13d
mov    %r15,0x20(%rsp)
jmp    1eee <main+0xd1e>
nopl   0x0(%rax,%rax,1)
movss  0x8(%rsp),%xmm0
movss  %xmm0,0x190(%rsp,%r15,4)
mov    0x40(%rsp,%r15,8),%rdi
imul   $0x32,%r13,%rsi
add    0x30(%rsp),%rsi
call   1030 <strcpy@plt>
mov    0x18(%rsp),%r8
mov    0x20(%rsp),%r15
add    $0x1,%r13
add    $0x4,%r14
cmp    %r8,%r13
jge    2170 <main+0xfa0>
cmpq   $0x3,0x28(%rsp)
jae    1f10 <main+0xd40>
xor    %eax,%eax
xor    %ecx,%ecx
mov    $0x1,%esi
jmp    1f59 <main+0xd89>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
xor    %ecx,%ecx
mov    $0x1,%esi
nopl   0x0(%rax)
cmp    %r13,0x230(%rsp,%rax,8)
cmove  %rsi,%rcx
cmp    %r13,0x238(%rsp,%rax,8)
cmove  %rsi,%rcx
cmp    %r13,0x240(%rsp,%rax,8)
cmove  %rsi,%rcx
cmp    %r13,0x248(%rsp,%rax,8)
cmove  %rsi,%rcx
add    $0x4,%rax
cmp    %rax,%r15
jne    1f20 <main+0xd50>
test   $0x3,%r12b
je     1f81 <main+0xdb1>
lea    (%rsp,%rax,8),%rax
add    $0x230,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
cmp    %r13,(%rax,%rdx,8)
cmove  %rsi,%rcx
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1f70 <main+0xda0>
cmp    $0x1,%rcx
je     1edd <main+0xd0d>
mov    0x10(%rsp),%rdx
test   %rdx,%rdx
jle    1fab <main+0xddb>
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1fb3 <main+0xde3>
xorps  %xmm3,%xmm3
xor    %esi,%esi
jmp    2024 <main+0xe54>
xorps  %xmm3,%xmm3
jmp    2067 <main+0xe97>
mov    %rdx,%rdi
and    $0xfffffffffffffffc,%rdi
mov    %rdx,%rcx
imul   %r14,%rcx
add    0x188(%rsp),%rcx
xorps  %xmm3,%xmm3
xor    %esi,%esi
xchg   %ax,%ax
movss  0x550(%rsp,%rsi,4),%xmm0
movss  0x554(%rsp,%rsi,4),%xmm1
mulss  -0xc(%rcx,%rsi,4),%xmm0
mulss  -0x8(%rcx,%rsi,4),%xmm1
addss  %xmm3,%xmm0
movss  0x558(%rsp,%rsi,4),%xmm2
mulss  -0x4(%rcx,%rsi,4),%xmm2
addss  %xmm0,%xmm1
movss  0x55c(%rsp,%rsi,4),%xmm3
mulss  (%rcx,%rsi,4),%xmm3
addss  %xmm1,%xmm2
addss  %xmm2,%xmm3
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1fd0 <main+0xe00>
test   %rax,%rax
je     2067 <main+0xe97>
mov    0x38(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
imul   %r14,%rdx
add    %rcx,%rdx
lea    (%rsp,%rsi,4),%rcx
add    $0x550,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
mulss  (%rdx,%rsi,4),%xmm0
addss  %xmm0,%xmm3
add    $0x1,%rsi
cmp    %rsi,%rax
jne    2050 <main+0xe80>
mov    $0x4,%r15d
nopl   (%rax)
ucomiss 0x180(%rsp,%r15,4),%xmm3
ja     20b6 <main+0xee6>
ucomiss 0x184(%rsp,%r15,4),%xmm3
ja     20cc <main+0xefc>
ucomiss 0x188(%rsp,%r15,4),%xmm3
ja     20e2 <main+0xf12>
ucomiss 0x18c(%rsp,%r15,4),%xmm3
ja     20f8 <main+0xf28>
ucomiss 0x190(%rsp,%r15,4),%xmm3
ja     210e <main+0xf3e>
add    $0x5,%r15
cmp    $0x2c,%r15
jne    2070 <main+0xea0>
jmp    1ed8 <main+0xd08>
movss  %xmm3,0x8(%rsp)
add    $0xfffffffffffffffc,%r15
cmp    $0x26,%r15
ja     1eb0 <main+0xce0>
jmp    2120 <main+0xf50>
movss  %xmm3,0x8(%rsp)
add    $0xfffffffffffffffd,%r15
cmp    $0x26,%r15
ja     1eb0 <main+0xce0>
jmp    2120 <main+0xf50>
movss  %xmm3,0x8(%rsp)
add    $0xfffffffffffffffe,%r15
cmp    $0x26,%r15
ja     1eb0 <main+0xce0>
jmp    2120 <main+0xf50>
movss  %xmm3,0x8(%rsp)
add    $0xffffffffffffffff,%r15
cmp    $0x26,%r15
ja     1eb0 <main+0xce0>
jmp    2120 <main+0xf50>
movss  %xmm3,0x8(%rsp)
cmp    $0x26,%r15
ja     1eb0 <main+0xce0>
xchg   %ax,%ax
mov    $0x27,%eax
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x1(%rax),%rbx
movss  0x18c(%rsp,%rax,4),%xmm0
movss  %xmm0,0x190(%rsp,%rax,4)
mov    0x38(%rsp,%rax,8),%rsi
mov    0x40(%rsp,%rax,8),%rdi
call   1030 <strcpy@plt>
mov    %rbx,%rax
cmp    %r15,%rbx
ja     2130 <main+0xf60>
jmp    1eb0 <main+0xce0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebx,%ebx
lea    0xf29(%rip),%rbp
nopl   0x0(%rax)
mov    0x40(%rsp,%rbx,8),%rsi
movss  0x190(%rsp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbp,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
add    $0x1,%rbx
cmp    $0x28,%rbx
jne    2180 <main+0xfb0>
jmp    15bc <main+0x3ec>
xor    %eax,%eax
jmp    21ed <main+0x101d>
lea    0xfa1(%rip),%rdi
call   1040 <puts@plt>
jmp    21e8 <main+0x1018>
mov    0x10(%rsp),%rcx
mov    %rcx,%rax
imul   %rdx,%rax
shr    $0x12,%rax
movabs $0xfffffffffff,%rsi
and    %rax,%rsi
lea    0xe3b(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    $0xffffffff,%eax
add    $0x34178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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