#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][2000];
  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: ./word-analogy <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));
  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 three words (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++;
    if (cn < 3) {
      printf(
          "Only %lld words were entered.. three words are needed at the input "
          "to perform the calculation\n",
          cn);
      continue;
    }
    for (a = 0; a < cn; a++) {
      for (b = 0; b < words; b++)
        if (!strcmp(&vocab[b * 50], st[a]))
          break;
      if (b == words)
        b = 0;
      bi[a] = b;
      printf("\nWord: %s  Position in vocabulary: %lld\n", st[a], bi[a]);
      if (b == 0) {
        printf("Out of dictionary word!\n");
        break;
      }
    }
    if (b == 0)
      continue;
    printf(
        "\n                                              Word              "
        "Distance\n------------------------------------------------------------"
        "------------\n");
    for (a = 0; a < size; a++)
      vec[a] = M[a + bi[1] * size] - M[a + bi[0] * size] + M[a + bi[2] * 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] = 0;
    for (a = 0; a < 40; a++)
      bestw[a][0] = 0;
    for (c = 0; c < words; c++) {
      if (c == bi[0])
        continue;
      if (c == bi[1])
        continue;
      if (c == bi[2])
        continue;
      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    $0x478e0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    11ed <main+0x3d>
lea    0xe26(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1eb4 <main+0xd04>
lea    -0x14840(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
call   1030 <strcpy@plt>
lea    -0x14840(%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    1eb4 <main+0xd04>
mov    -0x18(%rbp),%rdi
lea    0xe29(%rip),%rsi
lea    -0x47578(%rbp),%rdx
call   1070 <fscanf@plt>
mov    -0x18(%rbp),%rdi
lea    0xe12(%rip),%rsi
lea    -0x47580(%rbp),%rdx
call   1070 <fscanf@plt>
imul   $0x32,-0x47578(%rbp),%rdi
32
shl    $0x0,%rdi
call   10b0 <malloc@plt>
mov    %rax,-0x478e0(%rbp)
mov    -0x47578(%rbp),%rdi
imul   -0x47580(%rbp),%rdi
ff
shl    $0x2,%rdi
call   10b0 <malloc@plt>
mov    %rax,-0x478d8(%rbp)
cmpq   $0x0,-0x478d8(%rbp)
jne    12ef <main+0x13f>
mov    -0x47578(%rbp),%rsi
imul   -0x47580(%rbp),%rsi
ff
shl    $0x2,%rsi
shr    $0x14,%rsi
mov    -0x47578(%rbp),%rdx
mov    -0x47580(%rbp),%rcx
lea    0xd9a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1eb4 <main+0xd04>
movq   $0x0,-0x47590(%rbp)
mov    -0x47590(%rbp),%rax
cmp    -0x47578(%rbp),%rax
jge    158a <main+0x3da>
movq   $0x0,-0x47588(%rbp)
mov    -0x18(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %al,%dl
mov    -0x478e0(%rbp),%rax
imul   $0x32,-0x47590(%rbp),%rcx
32
add    -0x47588(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rdi
call   10a0 <feof@plt>
cmp    $0x0,%rax
jne    1373 <main+0x1c3>
mov    -0x478e0(%rbp),%rax
imul   $0x32,-0x47590(%rbp),%rcx
32
add    -0x47588(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    1378 <main+0x1c8>
jmp    13c0 <main+0x210>
cmpq   $0x32,-0x47588(%rbp)
32
jge    13bb <main+0x20b>
mov    -0x478e0(%rbp),%rax
imul   $0x32,-0x47590(%rbp),%rcx
32
add    -0x47588(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
je     13bb <main+0x20b>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1319 <main+0x169>
mov    -0x478e0(%rbp),%rax
imul   $0x32,-0x47590(%rbp),%rcx
32
add    -0x47588(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    144a <main+0x29a>
mov    -0x478d8(%rbp),%rdi
mov    -0x47588(%rbp),%rax
mov    -0x47590(%rbp),%rcx
imul   -0x47580(%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    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    13e5 <main+0x235>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x45588(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    14ed <main+0x33d>
mov    -0x478d8(%rbp),%rax
mov    -0x47588(%rbp),%rcx
mov    -0x47590(%rbp),%rdx
imul   -0x47580(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x478d8(%rbp),%rax
mov    -0x47588(%rbp),%rcx
mov    -0x47590(%rbp),%rdx
imul   -0x47580(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x45588(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x45588(%rbp)
ff
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1460 <main+0x2b0>
movss  -0x45588(%rbp),%xmm0
ff
call   10d0 <sqrt@plt>
movss  %xmm0,-0x45588(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    156e <main+0x3be>
movss  -0x45588(%rbp),%xmm1
ff
mov    -0x478d8(%rbp),%rax
mov    -0x47588(%rbp),%rcx
mov    -0x47590(%rbp),%rdx
imul   -0x47580(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    150d <main+0x35d>
jmp    1573 <main+0x3c3>
mov    -0x47590(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47590(%rbp)
jmp    12fa <main+0x14a>
mov    -0x18(%rbp),%rdi
call   1050 <fclose@plt>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    15d6 <main+0x426>
mov    -0x47588(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x45630(%rbp,%rax,4)
fb ff
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    159e <main+0x3ee>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    161e <main+0x46e>
lea    -0x14070(%rbp),%rax
imul   $0x7d0,-0x47588(%rbp),%rcx
add    %rcx,%rax
movb   $0x0,(%rax)
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    15e1 <main+0x431>
lea    0xa80(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movq   $0x0,-0x47588(%rbp)
mov    0x29aa(%rip),%rax
mov    (%rax),%rdi
call   1080 <fgetc@plt>
mov    %al,%cl
mov    -0x47588(%rbp),%rax
mov    %cl,-0x7f0(%rbp,%rax,1)
mov    -0x47588(%rbp),%rax
movsbl -0x7f0(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
je     167f <main+0x4cf>
cmpq   $0x7cf,-0x47588(%rbp)
jl     1693 <main+0x4e3>
mov    -0x47588(%rbp),%rax
movb   $0x0,-0x7f0(%rbp,%rax,1)
jmp    16aa <main+0x4fa>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1637 <main+0x487>
lea    -0x7f0(%rbp),%rdi
lea    0xa11(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%eax
jne    16cb <main+0x51b>
jmp    1ead <main+0xcfd>
movq   $0x0,-0x475a8(%rbp)
movq   $0x0,-0x47590(%rbp)
movq   $0x0,-0x47598(%rbp)
mov    -0x47598(%rbp),%rax
mov    -0x7f0(%rbp,%rax,1),%dl
lea    -0x45580(%rbp),%rax
imul   $0x7d0,-0x475a8(%rbp),%rcx
add    %rcx,%rax
mov    -0x47590(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x47590(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47590(%rbp)
mov    -0x47598(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47598(%rbp)
lea    -0x45580(%rbp),%rax
imul   $0x7d0,-0x475a8(%rbp),%rcx
add    %rcx,%rax
mov    -0x47590(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x47598(%rbp),%rax
movsbl -0x7f0(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
jne    177a <main+0x5ca>
jmp    17c6 <main+0x616>
mov    -0x47598(%rbp),%rax
movsbl -0x7f0(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
jne    17c1 <main+0x611>
mov    -0x475a8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x475a8(%rbp)
movq   $0x0,-0x47590(%rbp)
mov    -0x47598(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47598(%rbp)
jmp    16ec <main+0x53c>
mov    -0x475a8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x475a8(%rbp)
cmpq   $0x3,-0x475a8(%rbp)
03
jge    1800 <main+0x650>
mov    -0x475a8(%rbp),%rsi
lea    0x8da(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1593 <main+0x3e3>
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x475a8(%rbp),%rax
jge    1938 <main+0x788>
movq   $0x0,-0x47590(%rbp)
mov    -0x47590(%rbp),%rax
cmp    -0x47578(%rbp),%rax
jge    1894 <main+0x6e4>
mov    -0x478e0(%rbp),%rdi
imul   $0x32,-0x47590(%rbp),%rax
32
add    %rax,%rdi
lea    -0x45580(%rbp),%rsi
imul   $0x7d0,-0x47588(%rbp),%rax
add    %rax,%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%eax
jne    1878 <main+0x6c8>
jmp    1894 <main+0x6e4>
jmp    187d <main+0x6cd>
mov    -0x47590(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47590(%rbp)
jmp    182a <main+0x67a>
mov    -0x47590(%rbp),%rax
cmp    -0x47578(%rbp),%rax
jne    18b3 <main+0x703>
movq   $0x0,-0x47590(%rbp)
mov    -0x47590(%rbp),%rcx
mov    -0x47588(%rbp),%rax
mov    %rcx,-0x478d0(%rbp,%rax,8)
ff
lea    -0x45580(%rbp),%rsi
imul   $0x7d0,-0x47588(%rbp),%rax
add    %rax,%rsi
mov    -0x47588(%rbp),%rax
mov    -0x478d0(%rbp,%rax,8),%rdx
ff
lea    0x839(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
cmpq   $0x0,-0x47590(%rbp)
jne    191c <main+0x76c>
lea    0x846(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1938 <main+0x788>
jmp    1921 <main+0x771>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    180b <main+0x65b>
cmpq   $0x0,-0x47590(%rbp)
jne    194b <main+0x79b>
jmp    1593 <main+0x3e3>
lea    0x81d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    1a0e <main+0x85e>
mov    -0x478d8(%rbp),%rax
mov    -0x47588(%rbp),%rcx
mov    -0x478c8(%rbp),%rdx
imul   -0x47580(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x478d8(%rbp),%rax
mov    -0x47588(%rbp),%rcx
mov    -0x478d0(%rbp),%rdx
imul   -0x47580(%rbp),%rdx
ff
add    %rdx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x478d8(%rbp),%rax
mov    -0x47588(%rbp),%rcx
mov    -0x478c0(%rbp),%rdx
imul   -0x47580(%rbp),%rdx
ff
add    %rdx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x47588(%rbp),%rax
movss  %xmm0,-0x47570(%rbp,%rax,4)
fb ff
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1964 <main+0x7b4>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x45588(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    1a87 <main+0x8d7>
mov    -0x47588(%rbp),%rax
movss  -0x47570(%rbp,%rax,4),%xmm0
fb ff
mov    -0x47588(%rbp),%rax
movss  -0x47570(%rbp,%rax,4),%xmm2
fb ff
movss  -0x45588(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x45588(%rbp)
ff
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1a24 <main+0x874>
movss  -0x45588(%rbp),%xmm0
ff
call   10d0 <sqrt@plt>
movss  %xmm0,-0x45588(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    1af7 <main+0x947>
movss  -0x45588(%rbp),%xmm1
ff
mov    -0x47588(%rbp),%rax
movss  -0x47570(%rbp,%rax,4),%xmm0
fb ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x47570(%rbp,%rax,4)
fb ff
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1aa7 <main+0x8f7>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1b3a <main+0x98a>
mov    -0x47588(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x45630(%rbp,%rax,4)
fb ff
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1b02 <main+0x952>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1b82 <main+0x9d2>
lea    -0x14070(%rbp),%rax
imul   $0x7d0,-0x47588(%rbp),%rcx
add    %rcx,%rax
movb   $0x0,(%rax)
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1b45 <main+0x995>
movq   $0x0,-0x47598(%rbp)
mov    -0x47598(%rbp),%rax
cmp    -0x47578(%rbp),%rax
jge    1e41 <main+0xc91>
mov    -0x47598(%rbp),%rax
cmp    -0x478d0(%rbp),%rax
jne    1bba <main+0xa0a>
jmp    1e2a <main+0xc7a>
mov    -0x47598(%rbp),%rax
cmp    -0x478c8(%rbp),%rax
jne    1bd3 <main+0xa23>
jmp    1e2a <main+0xc7a>
mov    -0x47598(%rbp),%rax
cmp    -0x478c0(%rbp),%rax
jne    1bec <main+0xa3c>
jmp    1e2a <main+0xc7a>
movq   $0x0,-0x47588(%rbp)
movq   $0x0,-0x47590(%rbp)
mov    -0x47590(%rbp),%rax
cmp    -0x475a8(%rbp),%rax
jge    1c59 <main+0xaa9>
mov    -0x47590(%rbp),%rax
mov    -0x478d0(%rbp,%rax,8),%rax
ff
cmp    -0x47598(%rbp),%rax
jne    1c3d <main+0xa8d>
movq   $0x1,-0x47588(%rbp)
jmp    1c42 <main+0xa92>
mov    -0x47590(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47590(%rbp)
jmp    1c02 <main+0xa52>
cmpq   $0x1,-0x47588(%rbp)
01
jne    1c6c <main+0xabc>
jmp    1e2a <main+0xc7a>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x45584(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    1cfa <main+0xb4a>
mov    -0x47588(%rbp),%rax
movss  -0x47570(%rbp,%rax,4),%xmm0
fb ff
mov    -0x478d8(%rbp),%rax
mov    -0x47588(%rbp),%rcx
mov    -0x47598(%rbp),%rdx
imul   -0x47580(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x45584(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x45584(%rbp)
ff
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1c82 <main+0xad2>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1e25 <main+0xc75>
movss  -0x45584(%rbp),%xmm0
ff
mov    -0x47588(%rbp),%rax
ucomiss -0x45630(%rbp,%rax,4),%xmm0
ff
jbe    1e09 <main+0xc59>
movq   $0x27,-0x475a0(%rbp)
mov    -0x475a0(%rbp),%rax
cmp    -0x47588(%rbp),%rax
jle    1dc0 <main+0xc10>
mov    -0x475a0(%rbp),%rax
sub    $0x1,%rax
movss  -0x45630(%rbp,%rax,4),%xmm0
fb ff
mov    -0x475a0(%rbp),%rax
movss  %xmm0,-0x45630(%rbp,%rax,4)
fb ff
lea    -0x14070(%rbp),%rdi
imul   $0x7d0,-0x475a0(%rbp),%rax
add    %rax,%rdi
mov    -0x475a0(%rbp),%rax
sub    $0x1,%rax
lea    -0x14070(%rbp),%rsi
imul   $0x7d0,%rax,%rax
add    %rax,%rsi
call   1030 <strcpy@plt>
mov    -0x475a0(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x475a0(%rbp)
jmp    1d3b <main+0xb8b>
movss  -0x45584(%rbp),%xmm0
ff
mov    -0x47588(%rbp),%rax
movss  %xmm0,-0x45630(%rbp,%rax,4)
fb ff
lea    -0x14070(%rbp),%rdi
imul   $0x7d0,-0x47588(%rbp),%rax
add    %rax,%rdi
mov    -0x478e0(%rbp),%rsi
imul   $0x32,-0x47598(%rbp),%rax
32
add    %rax,%rsi
call   1030 <strcpy@plt>
jmp    1e25 <main+0xc75>
jmp    1e0e <main+0xc5e>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1d05 <main+0xb55>
jmp    1e2a <main+0xc7a>
mov    -0x47598(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47598(%rbp)
jmp    1b8d <main+0x9dd>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1ea8 <main+0xcf8>
lea    -0x14070(%rbp),%rsi
imul   $0x7d0,-0x47588(%rbp),%rax
add    %rax,%rsi
mov    -0x47588(%rbp),%rax
movss  -0x45630(%rbp,%rax,4),%xmm0
fb ff
cvtss2sd %xmm0,%xmm0
lea    0x379(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1e4c <main+0xc9c>
jmp    1593 <main+0x3e3>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x478e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x478d8,%rsp
cmp    $0x1,%edi
jg     11e9 <main+0x29>
lea    0xfd9(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
jmp    1eff <main+0xd3f>
mov    0x8(%rsi),%rsi
lea    0x2b40(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xe00(%rip),%rsi
mov    %rbx,%rdi
call   10d0 <fopen@plt>
test   %rax,%rax
je     1ec1 <main+0xd01>
mov    %rax,%rbp
lea    0xde8(%rip),%rbx
lea    0x18(%rsp),%rdx
mov    %rax,%rdi
mov    %rbx,%rsi
call   1080 <fscanf@plt>
lea    0x10(%rsp),%rdx
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1080 <fscanf@plt>
imul   $0x32,0x18(%rsp),%rdi
call   10c0 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    0x18(%rsp),%rdi
imul   0x10(%rsp),%rdi
shl    $0x2,%rdi
call   10c0 <malloc@plt>
mov    0x18(%rsp),%rdx
test   %rax,%rax
je     1ecf <main+0xd0f>
mov    %rax,%r14
test   %rdx,%rdx
mov    %rax,0x38(%rsp)
jle    1545 <main+0x385>
lea    0xc(%r14),%rax
mov    %rax,0x28(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0x8(%rsp)
xor    %r12d,%r12d
xor    %r13d,%r13d
jmp    12b3 <main+0xf3>
nopl   0x0(%rax)
add    $0x1,%r13
add    $0x4,%r12
cmp    0x18(%rsp),%r13
jge    1545 <main+0x385>
mov    %rbp,%rdi
call   1090 <fgetc@plt>
imul   $0x32,%r13,%rbx
mov    0x30(%rsp),%rcx
lea    (%rcx,%rbx,1),%r15
mov    %al,(%rcx,%rbx,1)
mov    %rbp,%rdi
call   10b0 <feof@plt>
test   %rax,%rax
jne    1330 <main+0x170>
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
movzbl (%r15),%eax
cmp    $0x20,%al
je     1330 <main+0x170>
cmp    $0x32,%r14
setb   %cl
cmp    $0xa,%al
setne  %al
and    %cl,%al
movzbl %al,%eax
add    %rax,%r14
mov    %rbp,%rdi
call   1090 <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   10b0 <feof@plt>
test   %rax,%rax
je     12e0 <main+0x120>
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    1436 <main+0x276>
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     1350 <main+0x190>
test   %rax,%rax
xorps  %xmm0,%xmm0
jle    1436 <main+0x276>
lea    -0x1(%rax),%rdx
mov    %eax,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    139d <main+0x1dd>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    1400 <main+0x240>
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    13c0 <main+0x200>
test   %rcx,%rcx
je     1436 <main+0x276>
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    1420 <main+0x260>
ucomiss 0xbc3(%rip),%xmm0
jb     1450 <main+0x290>
sqrtss %xmm0,%xmm0
jmp    1455 <main+0x295>
cs nopw 0x0(%rax,%rax,1)
nop
call   10e0 <sqrt@plt>
mov    0x10(%rsp),%rbx
test   %rbx,%rbx
jle    12a0 <main+0xe0>
cmp    $0x4,%rbx
jae    1470 <main+0x2b0>
xor    %ecx,%ecx
jmp    1507 <main+0x347>
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     153c <main+0x37c>
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    14c0 <main+0x300>
test   $0x1,%dl
je     14fe <main+0x33e>
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     12a0 <main+0xe0>
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    1520 <main+0x360>
jmp    12a0 <main+0xe0>
xor    %esi,%esi
test   $0x1,%dl
jne    14e7 <main+0x327>
jmp    14fe <main+0x33e>
mov    %rbp,%rdi
call   1060 <fclose@plt>
lea    0x16b91(%rsp),%r15
lea    0x10(%r14),%rax
mov    %rax,0x48(%rsp)
lea    0xc(%r14),%rax
mov    %rax,0x50(%rsp)
lea    0xacd(%rip),%r12
mov    $0x1,%r14d
jmp    1592 <main+0x3d2>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rsi
lea    0xad9(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x70(%rsp)
mov    $0x1f40,%eax
nopw   0x0(%rax,%rax,1)
movb   $0x0,0x13d0(%rsp,%rax,1)
movb   $0x0,0x1ba0(%rsp,%rax,1)
movb   $0x0,0x2370(%rsp,%rax,1)
movb   $0x0,0x2b40(%rsp,%rax,1)
movb   $0x0,0x3310(%rsp,%rax,1)
add    $0x2710,%rax
cmp    $0x157c0,%rax
jne    15f0 <main+0x430>
mov    %r12,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
xor    %ebx,%ebx
mov    0x29af(%rip),%rbp
nopl   0x0(%rax)
mov    0x0(%rbp),%rdi
call   1090 <fgetc@plt>
mov    %al,0x430(%rsp,%rbx,1)
lea    0x1(%rbx),%rcx
cmp    $0xa,%al
je     1664 <main+0x4a4>
cmp    $0x7cf,%rbx
mov    %rcx,%rbx
jb     1640 <main+0x480>
movb   $0x0,0x42f(%rsp,%rcx,1)
mov    0x430(%rsp),%eax
mov    $0x54495845,%ecx
xor    %ecx,%eax
movzbl 0x434(%rsp),%ecx
or     %eax,%ecx
je     1ebd <main+0xcfd>
mov    $0x1,%eax
mov    %rax,0x8(%rsp)
mov    $0x1,%dil
mov    %r15,%rax
xor    %ecx,%ecx
xor    %esi,%esi
add    $0x1,%rcx
mov    %rax,%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x42f(%rsp,%rcx,1),%ebx
mov    %bl,-0x1(%rdx)
movb   $0x0,(%rdx)
movzbl 0x430(%rsp,%rcx,1),%ebx
test   %bl,%bl
je     16f0 <main+0x530>
add    $0x1,%rdx
add    $0x1,%rcx
cmp    $0x20,%bl
jne    16b0 <main+0x4f0>
add    $0x1,%rsi
add    $0x7d0,%rax
addq   $0x1,0x8(%rsp)
add    $0x1,%dil
jmp    169e <main+0x4de>
nopl   (%rax)
cmp    $0x2,%rsi
jb     1580 <main+0x3c0>
mov    %dil,0x20(%rsp)
xor    %r12d,%r12d
mov    %rsi,0x28(%rsp)
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%r13
test   %r13,%r13
jle    1770 <main+0x5b0>
imul   $0x7d0,%r12,%rax
lea    (%rsp,%rax,1),%r15
add    $0x16b90,%r15
mov    0x30(%rsp),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbp,%rdi
mov    %r15,%rsi
call   10a0 <strcmp@plt>
test   %eax,%eax
je     1772 <main+0x5b2>
add    $0x1,%rbx
add    $0x32,%rbp
cmp    %rbx,%r13
jne    1740 <main+0x580>
mov    %r13,%rbx
jmp    1772 <main+0x5b2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %ebx,%ebx
cmp    %r13,%rbx
mov    $0x0,%ebp
cmovne %rbx,%rbp
mov    %rbp,0x110(%rsp,%r12,8)
imul   $0x7d0,%r12,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x16b90,%rsi
lea    0x924(%rip),%rdi
mov    %rbp,%rdx
xor    %eax,%eax
call   1070 <printf@plt>
test   %rbp,%rbp
je     1820 <main+0x660>
lea    0x1(%r12),%rax
cmp    0x28(%rsp),%r12
mov    %rax,%r12
jne    1710 <main+0x550>
lea    0x92e(%rip),%rdi
call   1040 <puts@plt>
mov    0x10(%rsp),%rax
xorps  %xmm0,%xmm0
test   %rax,%rax
mov    0x8(%rsp),%rbx
jle    1840 <main+0x680>
mov    0x118(%rsp),%r8
imul   %rax,%r8
mov    0x110(%rsp),%r9
imul   %rax,%r9
mov    0x120(%rsp),%rdi
imul   %rax,%rdi
cmp    $0x8,%rax
lea    0x8de(%rip),%r13
jae    184c <main+0x68c>
xor    %ecx,%ecx
jmp    18bb <main+0x6fb>
nopw   0x0(%rax,%rax,1)
lea    0x962(%rip),%rdi
call   1040 <puts@plt>
lea    0x16b91(%rsp),%r15
lea    0x800(%rip),%r12
jmp    1592 <main+0x3d2>
lea    0x8a5(%rip),%r13
jmp    19b6 <main+0x7f6>
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
mov    0x48(%rsp),%rdx
lea    (%rdx,%r8,4),%rbp
lea    (%rdx,%r9,4),%rbx
lea    (%rdx,%rdi,4),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rbp,%rsi,4),%xmm1
movups 0x0(%rbp,%rsi,4),%xmm2
movups -0x10(%rbx,%rsi,4),%xmm3
subps  %xmm3,%xmm1
movups (%rbx,%rsi,4),%xmm3
subps  %xmm3,%xmm2
movups -0x10(%rdx,%rsi,4),%xmm3
addps  %xmm1,%xmm3
movups (%rdx,%rsi,4),%xmm1
addps  %xmm2,%xmm1
movaps %xmm3,0xc00(%rsp,%rsi,4)
movaps %xmm1,0xc10(%rsp,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rcx
jne    1870 <main+0x6b0>
cmp    %rcx,%rax
mov    0x8(%rsp),%rbx
je     1911 <main+0x751>
mov    0x38(%rsp),%rbp
lea    0x0(,%rdi,4),%rdx
add    %rbp,%rdx
lea    0x0(,%r9,4),%rsi
add    %rbp,%rsi
lea    0x0(,%r8,4),%rdi
add    %rbp,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rcx,4),%xmm1
subss  (%rsi,%rcx,4),%xmm1
addss  (%rdx,%rcx,4),%xmm1
movss  %xmm1,0xc00(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    18f0 <main+0x730>
test   %rax,%rax
jle    19b6 <main+0x7f6>
lea    -0x1(%rax),%rdx
mov    %eax,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    1930 <main+0x770>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    198d <main+0x7cd>
and    $0xfffffffffffffffc,%rax
xorps  %xmm0,%xmm0
xor    %edx,%edx
nopl   0x0(%rax)
movss  0xc00(%rsp,%rdx,4),%xmm1
movss  0xc04(%rsp,%rdx,4),%xmm2
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  0xc08(%rsp,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movss  0xc0c(%rsp,%rdx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rax
jne    1940 <main+0x780>
test   %rcx,%rcx
je     19b6 <main+0x7f6>
lea    (%rsp,%rdx,4),%rax
add    $0xc00,%rax
xor    %edx,%edx
xchg   %ax,%ax
movss  (%rax,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    19a0 <main+0x7e0>
ucomiss 0x643(%rip),%xmm0
jb     19c5 <main+0x805>
sqrtss %xmm0,%xmm0
jmp    19ca <main+0x80a>
call   10e0 <sqrt@plt>
mov    0x28(%rsp),%r8
mov    0x10(%rsp),%rax
test   %rax,%rax
jle    1a9f <main+0x8df>
cmp    $0x4,%rax
jae    19ea <main+0x82a>
xor    %ecx,%ecx
jmp    1a80 <main+0x8c0>
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     1a57 <main+0x897>
mov    %rdx,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
xchg   %ax,%ax
movaps 0xc00(%rsp,%rsi,4),%xmm2
movaps 0xc10(%rsp,%rsi,4),%xmm3
divps  %xmm1,%xmm2
movaps %xmm2,0xc00(%rsp,%rsi,4)
divps  %xmm1,%xmm3
movaps %xmm3,0xc10(%rsp,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1a20 <main+0x860>
test   $0x1,%dl
jne    1a5e <main+0x89e>
jmp    1a9a <main+0x8da>
xor    %esi,%esi
test   $0x1,%dl
je     1a9a <main+0x8da>
movaps 0xc00(%rsp,%rsi,4),%xmm2
divps  %xmm1,%xmm2
movaps %xmm2,0xc00(%rsp,%rsi,4)
jmp    1a9a <main+0x8da>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0xc00(%rsp,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xc00(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1a80 <main+0x8c0>
xorps  %xmm0,%xmm0
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x70(%rsp)
mov    $0x1f40,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movb   $0x0,0x13d0(%rsp,%rax,1)
movb   $0x0,0x1ba0(%rsp,%rax,1)
movb   $0x0,0x2370(%rsp,%rax,1)
movb   $0x0,0x2b40(%rsp,%rax,1)
movb   $0x0,0x3310(%rsp,%rax,1)
add    $0x2710,%rax
cmp    $0x157c0,%rax
jne    1b00 <main+0x940>
mov    0x18(%rsp),%r9
test   %r9,%r9
jle    1e70 <main+0xcb0>
mov    0x110(%rsp),%rax
mov    0x118(%rsp),%r10
mov    0x120(%rsp),%r11
lea    0x1(%r8),%rdi
and    $0xfffffffffffffffc,%rbx
movzbl 0x20(%rsp),%r15d
and    $0x3,%r15d
xor    %ebp,%ebp
xor    %r12d,%r12d
mov    %rbx,0x8(%rsp)
mov    %rdi,0x40(%rsp)
mov    %rax,0x68(%rsp)
mov    %r10,0x60(%rsp)
mov    %r11,0x58(%rsp)
jmp    1bfc <main+0xa3c>
xchg   %ax,%ax
movss  0x4(%rsp),%xmm0
movss  %xmm0,0x70(%rsp,%rbx,4)
imul   $0x7d0,%rbx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x3310,%rdi
imul   $0x32,%r12,%rsi
add    0x30(%rsp),%rsi
call   1030 <strcpy@plt>
mov    0x18(%rsp),%r9
lea    0x524(%rip),%r13
mov    0x8(%rsp),%rbx
mov    0x28(%rsp),%r8
mov    0x68(%rsp),%rax
mov    0x60(%rsp),%r10
mov    0x58(%rsp),%r11
mov    0x40(%rsp),%rdi
mov    0x20(%rsp),%rbp
add    $0x1,%r12
add    $0x4,%rbp
cmp    %r9,%r12
jge    1e70 <main+0xcb0>
cmp    %rax,%r12
je     1beb <main+0xa2b>
cmp    %r10,%r12
je     1beb <main+0xa2b>
cmp    %r11,%r12
je     1beb <main+0xa2b>
xor    %edx,%edx
xor    %ecx,%ecx
cmp    $0x3,%r8
jb     1c59 <main+0xa99>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %r12,0x110(%rsp,%rdx,8)
cmove  %r14,%rcx
cmp    %r12,0x118(%rsp,%rdx,8)
cmove  %r14,%rcx
cmp    %r12,0x120(%rsp,%rdx,8)
cmove  %r14,%rcx
cmp    %r12,0x128(%rsp,%rdx,8)
cmove  %r14,%rcx
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1c20 <main+0xa60>
test   $0x3,%dil
je     1c81 <main+0xac1>
lea    (%rsp,%rdx,8),%rdx
add    $0x110,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
cmp    %r12,(%rdx,%rsi,8)
cmove  %r14,%rcx
add    $0x1,%rsi
cmp    %rsi,%r15
jne    1c70 <main+0xab0>
cmp    $0x1,%rcx
je     1beb <main+0xa2b>
mov    0x10(%rsp),%rdx
test   %rdx,%rdx
mov    %rbp,0x20(%rsp)
jle    1cb3 <main+0xaf3>
lea    -0x1(%rdx),%rcx
mov    %edx,%ebp
and    $0x3,%ebp
cmp    $0x3,%rcx
jae    1cbb <main+0xafb>
xorps  %xmm3,%xmm3
xor    %esi,%esi
jmp    1d34 <main+0xb74>
xorps  %xmm3,%xmm3
jmp    1d77 <main+0xbb7>
mov    %rdx,%rdi
and    $0xfffffffffffffffc,%rdi
mov    %rdx,%rcx
imul   0x20(%rsp),%rcx
add    0x50(%rsp),%rcx
xorps  %xmm3,%xmm3
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movss  0xc00(%rsp,%rsi,4),%xmm0
movss  0xc04(%rsp,%rsi,4),%xmm1
mulss  -0xc(%rcx,%rsi,4),%xmm0
mulss  -0x8(%rcx,%rsi,4),%xmm1
addss  %xmm3,%xmm0
movss  0xc08(%rsp,%rsi,4),%xmm2
mulss  -0x4(%rcx,%rsi,4),%xmm2
addss  %xmm0,%xmm1
movss  0xc0c(%rsp,%rsi,4),%xmm3
mulss  (%rcx,%rsi,4),%xmm3
addss  %xmm1,%xmm2
addss  %xmm2,%xmm3
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1ce0 <main+0xb20>
test   %rbp,%rbp
je     1d77 <main+0xbb7>
mov    0x38(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
imul   0x20(%rsp),%rdx
add    %rcx,%rdx
lea    (%rsp,%rsi,4),%rcx
add    $0xc00,%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
mulss  (%rdx,%rsi,4),%xmm0
addss  %xmm0,%xmm3
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1d60 <main+0xba0>
mov    $0x4,%ebx
nopl   0x0(%rax)
ucomiss 0x60(%rsp,%rbx,4),%xmm3
ja     1db7 <main+0xbf7>
ucomiss 0x64(%rsp,%rbx,4),%xmm3
ja     1dcd <main+0xc0d>
ucomiss 0x68(%rsp,%rbx,4),%xmm3
ja     1de3 <main+0xc23>
ucomiss 0x6c(%rsp,%rbx,4),%xmm3
ja     1df9 <main+0xc39>
ucomiss 0x70(%rsp,%rbx,4),%xmm3
ja     1e0f <main+0xc4f>
add    $0x5,%rbx
cmp    $0x2c,%rbx
jne    1d80 <main+0xbc0>
mov    0x8(%rsp),%rbx
jmp    1be1 <main+0xa21>
movss  %xmm3,0x4(%rsp)
add    $0xfffffffffffffffc,%rbx
cmp    $0x26,%rbx
ja     1b90 <main+0x9d0>
jmp    1e1f <main+0xc5f>
movss  %xmm3,0x4(%rsp)
add    $0xfffffffffffffffd,%rbx
cmp    $0x26,%rbx
ja     1b90 <main+0x9d0>
jmp    1e1f <main+0xc5f>
movss  %xmm3,0x4(%rsp)
add    $0xfffffffffffffffe,%rbx
cmp    $0x26,%rbx
ja     1b90 <main+0x9d0>
jmp    1e1f <main+0xc5f>
movss  %xmm3,0x4(%rsp)
add    $0xffffffffffffffff,%rbx
cmp    $0x26,%rbx
ja     1b90 <main+0x9d0>
jmp    1e1f <main+0xc5f>
movss  %xmm3,0x4(%rsp)
cmp    $0x26,%rbx
ja     1b90 <main+0x9d0>
mov    $0x27,%eax
lea    0x15bf0(%rsp),%rbp
nopl   0x0(%rax)
lea    -0x1(%rax),%r13
movss  0x6c(%rsp,%rax,4),%xmm0
movss  %xmm0,0x70(%rsp,%rax,4)
lea    0x7d0(%rbp),%rdi
mov    %rbp,%rsi
call   1030 <strcpy@plt>
add    $0xfffffffffffff830,%rbp
mov    %r13,%rax
cmp    %rbx,%r13
ja     1e30 <main+0xc70>
jmp    1b90 <main+0x9d0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x3310(%rsp),%rbp
xor    %ebx,%ebx
lea    0x16b91(%rsp),%r15
lea    0x1b2(%rip),%r12
nopl   0x0(%rax)
movss  0x70(%rsp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    %rbp,%rsi
mov    $0x1,%al
call   1070 <printf@plt>
add    $0x1,%rbx
add    $0x7d0,%rbp
cmp    $0x28,%rbx
jne    1e90 <main+0xcd0>
jmp    1592 <main+0x3d2>
xor    %eax,%eax
jmp    1eff <main+0xd3f>
lea    0x2d9(%rip),%rdi
call   1040 <puts@plt>
jmp    1efa <main+0xd3a>
mov    0x10(%rsp),%rcx
mov    %rcx,%rax
imul   %rdx,%rax
shr    $0x12,%rax
movabs $0xfffffffffff,%rsi
and    %rax,%rsi
lea    0x119(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    $0xffffffff,%eax
add    $0x478d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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