#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*/ *);
char fgetc(int /*<<< orphan*/);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fread(float *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, ...);
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];
  char ch;
  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++) {
    fscanf(f, "%s%c", &vocab[b * 50], &ch);
    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    $0x478f0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    11dd <main+0x3d>
lea    0xe36(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1e06 <main+0xc66>
lea    -0x14840(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
call   1030 <strcpy@plt>
lea    -0x14840(%rbp),%rdi
lea    0xe59(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    122d <main+0x8d>
lea    0xe41(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e06 <main+0xc66>
mov    -0x18(%rbp),%rdi
lea    0xe39(%rip),%rsi
lea    -0x47578(%rbp),%rdx
mov    $0x0,%al
call   1070 <fscanf@plt>
mov    -0x18(%rbp),%rdi
lea    0xe20(%rip),%rsi
lea    -0x47580(%rbp),%rdx
mov    $0x0,%al
call   1070 <fscanf@plt>
imul   $0x32,-0x47578(%rbp),%rdi
32
shl    $0x0,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x478e8(%rbp)
mov    -0x47578(%rbp),%rdi
imul   -0x47580(%rbp),%rdi
ff
shl    $0x2,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x478e0(%rbp)
cmpq   $0x0,-0x478e0(%rbp)
jne    12e3 <main+0x143>
mov    -0x47578(%rbp),%rsi
imul   -0x47580(%rbp),%rsi
ff
shl    $0x2,%rsi
shr    $0x14,%rsi
mov    -0x47578(%rbp),%rdx
mov    -0x47580(%rbp),%rcx
lea    0xda6(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e06 <main+0xc66>
movq   $0x0,-0x47590(%rbp)
mov    -0x47590(%rbp),%rax
cmp    -0x47578(%rbp),%rax
jge    14dd <main+0x33d>
mov    -0x18(%rbp),%rdi
mov    -0x478e8(%rbp),%rdx
imul   $0x32,-0x47590(%rbp),%rax
32
add    %rax,%rdx
lea    0xd86(%rip),%rsi
lea    -0x478d1(%rbp),%rcx
mov    $0x0,%al
call   1070 <fscanf@plt>
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    139d <main+0x1fd>
mov    -0x478e0(%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    1338 <main+0x198>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x45588(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    1440 <main+0x2a0>
mov    -0x478e0(%rbp),%rax
mov    -0x47588(%rbp),%rcx
mov    -0x47590(%rbp),%rdx
imul   -0x47580(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x478e0(%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    13b3 <main+0x213>
movss  -0x45588(%rbp),%xmm0
ff
call   10c0 <sqrt@plt>
movss  %xmm0,-0x45588(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    14c1 <main+0x321>
movss  -0x45588(%rbp),%xmm1
ff
mov    -0x478e0(%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    1460 <main+0x2c0>
jmp    14c6 <main+0x326>
mov    -0x47590(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47590(%rbp)
jmp    12ee <main+0x14e>
mov    -0x18(%rbp),%rdi
call   1050 <fclose@plt>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1529 <main+0x389>
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    14f1 <main+0x351>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1571 <main+0x3d1>
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    1534 <main+0x394>
lea    0xb32(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movq   $0x0,-0x47588(%rbp)
mov    0x2a57(%rip),%rax
mov    (%rax),%edi
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     15d1 <main+0x431>
cmpq   $0x7cf,-0x47588(%rbp)
jl     15e5 <main+0x445>
mov    -0x47588(%rbp),%rax
movb   $0x0,-0x7f0(%rbp,%rax,1)
jmp    15fc <main+0x45c>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    158a <main+0x3ea>
lea    -0x7f0(%rbp),%rdi
lea    0xac4(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%eax
jne    161d <main+0x47d>
jmp    1dff <main+0xc5f>
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    16cc <main+0x52c>
jmp    1718 <main+0x578>
mov    -0x47598(%rbp),%rax
movsbl -0x7f0(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
jne    1713 <main+0x573>
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    163e <main+0x49e>
mov    -0x475a8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x475a8(%rbp)
cmpq   $0x3,-0x475a8(%rbp)
03
jge    1752 <main+0x5b2>
mov    -0x475a8(%rbp),%rsi
lea    0x98d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    14e6 <main+0x346>
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x475a8(%rbp),%rax
jge    188a <main+0x6ea>
movq   $0x0,-0x47590(%rbp)
mov    -0x47590(%rbp),%rax
cmp    -0x47578(%rbp),%rax
jge    17e6 <main+0x646>
mov    -0x478e8(%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    17ca <main+0x62a>
jmp    17e6 <main+0x646>
jmp    17cf <main+0x62f>
mov    -0x47590(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47590(%rbp)
jmp    177c <main+0x5dc>
mov    -0x47590(%rbp),%rax
cmp    -0x47578(%rbp),%rax
jne    1805 <main+0x665>
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    0x8ec(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
cmpq   $0x0,-0x47590(%rbp)
jne    186e <main+0x6ce>
lea    0x8f9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    188a <main+0x6ea>
jmp    1873 <main+0x6d3>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    175d <main+0x5bd>
cmpq   $0x0,-0x47590(%rbp)
jne    189d <main+0x6fd>
jmp    14e6 <main+0x346>
lea    0x8d0(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    1960 <main+0x7c0>
mov    -0x478e0(%rbp),%rax
mov    -0x47588(%rbp),%rcx
mov    -0x478c8(%rbp),%rdx
imul   -0x47580(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x478e0(%rbp),%rax
mov    -0x47588(%rbp),%rcx
mov    -0x478d0(%rbp),%rdx
imul   -0x47580(%rbp),%rdx
ff
add    %rdx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x478e0(%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    18b6 <main+0x716>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x45588(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    19d9 <main+0x839>
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    1976 <main+0x7d6>
movss  -0x45588(%rbp),%xmm0
ff
call   10c0 <sqrt@plt>
movss  %xmm0,-0x45588(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    1a49 <main+0x8a9>
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    19f9 <main+0x859>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1a8c <main+0x8ec>
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    1a54 <main+0x8b4>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1ad4 <main+0x934>
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    1a97 <main+0x8f7>
movq   $0x0,-0x47598(%rbp)
mov    -0x47598(%rbp),%rax
cmp    -0x47578(%rbp),%rax
jge    1d93 <main+0xbf3>
mov    -0x47598(%rbp),%rax
cmp    -0x478d0(%rbp),%rax
jne    1b0c <main+0x96c>
jmp    1d7c <main+0xbdc>
mov    -0x47598(%rbp),%rax
cmp    -0x478c8(%rbp),%rax
jne    1b25 <main+0x985>
jmp    1d7c <main+0xbdc>
mov    -0x47598(%rbp),%rax
cmp    -0x478c0(%rbp),%rax
jne    1b3e <main+0x99e>
jmp    1d7c <main+0xbdc>
movq   $0x0,-0x47588(%rbp)
movq   $0x0,-0x47590(%rbp)
mov    -0x47590(%rbp),%rax
cmp    -0x475a8(%rbp),%rax
jge    1bab <main+0xa0b>
mov    -0x47590(%rbp),%rax
mov    -0x478d0(%rbp,%rax,8),%rax
ff
cmp    -0x47598(%rbp),%rax
jne    1b8f <main+0x9ef>
movq   $0x1,-0x47588(%rbp)
jmp    1b94 <main+0x9f4>
mov    -0x47590(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47590(%rbp)
jmp    1b54 <main+0x9b4>
cmpq   $0x1,-0x47588(%rbp)
01
jne    1bbe <main+0xa1e>
jmp    1d7c <main+0xbdc>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x45584(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    1c4c <main+0xaac>
mov    -0x47588(%rbp),%rax
movss  -0x47570(%rbp,%rax,4),%xmm0
fb ff
mov    -0x478e0(%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    1bd4 <main+0xa34>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1d77 <main+0xbd7>
movss  -0x45584(%rbp),%xmm0
ff
mov    -0x47588(%rbp),%rax
ucomiss -0x45630(%rbp,%rax,4),%xmm0
ff
jbe    1d5b <main+0xbbb>
movq   $0x27,-0x475a0(%rbp)
mov    -0x475a0(%rbp),%rax
cmp    -0x47588(%rbp),%rax
jle    1d12 <main+0xb72>
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    1c8d <main+0xaed>
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    -0x478e8(%rbp),%rsi
imul   $0x32,-0x47598(%rbp),%rax
32
add    %rax,%rsi
call   1030 <strcpy@plt>
jmp    1d77 <main+0xbd7>
jmp    1d60 <main+0xbc0>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1c57 <main+0xab7>
jmp    1d7c <main+0xbdc>
mov    -0x47598(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47598(%rbp)
jmp    1adf <main+0x93f>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1dfa <main+0xc5a>
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    0x42c(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1d9e <main+0xbfe>
jmp    14e6 <main+0x346>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x478f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x478e8,%rsp
cmp    $0x1,%edi
jg     11d9 <main+0x29>
lea    0xfee(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
jmp    1ea2 <main+0xcf2>
mov    0x8(%rsi),%rsi
lea    0x2b50(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xe10(%rip),%rsi
mov    %rbx,%rdi
call   10c0 <fopen@plt>
test   %rax,%rax
je     1e64 <main+0xcb4>
mov    %rax,%rbp
lea    0xdf8(%rip),%rbx
lea    0x28(%rsp),%rdx
mov    %rax,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1080 <fscanf@plt>
lea    0x20(%rsp),%rdx
mov    %rbp,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1080 <fscanf@plt>
imul   $0x32,0x28(%rsp),%rdi
call   10b0 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    0x28(%rsp),%rdi
imul   0x20(%rsp),%rdi
shl    $0x2,%rdi
call   10b0 <malloc@plt>
mov    0x28(%rsp),%rdx
test   %rax,%rax
je     1e72 <main+0xcc2>
mov    %rax,0x10(%rsp)
test   %rdx,%rdx
jle    14e5 <main+0x335>
mov    0x10(%rsp),%rax
lea    0xc(%rax),%rcx
mov    %rcx,0x40(%rsp)
add    $0x10,%rax
mov    %rax,0x18(%rsp)
lea    0x37(%rsp),%r12
xor    %r13d,%r13d
xor    %r14d,%r14d
mov    0x10(%rsp),%r15
jmp    12b3 <main+0x103>
nopl   0x0(%rax)
add    $0x1,%r14
add    $0x4,%r13
cmp    0x28(%rsp),%r14
jge    14e5 <main+0x335>
imul   $0x32,%r14,%rdx
add    0x48(%rsp),%rdx
mov    %rbp,%rdi
lea    0xd75(%rip),%rsi
mov    %r12,%rcx
xor    %eax,%eax
call   1080 <fscanf@plt>
mov    0x20(%rsp),%rax
xorps  %xmm0,%xmm0
test   %rax,%rax
jle    13d6 <main+0x226>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
imul   %r14,%rax
add    %rbx,%rax
lea    (%r15,%rax,4),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbp,%rcx
call   1050 <fread@plt>
add    $0x1,%rbx
mov    0x20(%rsp),%rax
cmp    %rax,%rbx
jl     12f0 <main+0x140>
xorps  %xmm0,%xmm0
test   %rax,%rax
jle    13d6 <main+0x226>
lea    -0x1(%rax),%rdx
mov    %eax,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    133d <main+0x18d>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    13a0 <main+0x1f0>
mov    %rax,%rsi
and    $0xfffffffffffffffc,%rsi
mov    %r13,%rdi
imul   %rax,%rdi
add    0x40(%rsp),%rdi
xorps  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0xc(%rdi,%rdx,4),%xmm1
movss  -0x8(%rdi,%rdx,4),%xmm2
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rdi,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movss  (%rdi,%rdx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1360 <main+0x1b0>
test   %rcx,%rcx
je     13d6 <main+0x226>
mov    0x10(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
imul   %r13,%rax
add    %rdx,%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    13c0 <main+0x210>
ucomiss 0xc23(%rip),%xmm0
jb     13f0 <main+0x240>
sqrtss %xmm0,%xmm0
jmp    13f5 <main+0x245>
cs nopw 0x0(%rax,%rax,1)
nop
call   10d0 <sqrt@plt>
mov    0x20(%rsp),%rbx
test   %rbx,%rbx
jle    12a0 <main+0xf0>
cmp    $0x4,%rbx
jae    1410 <main+0x260>
xor    %ecx,%ecx
jmp    14aa <main+0x2fa>
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     14dc <main+0x32c>
mov    %rdx,%rdi
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdi
mov    %rbx,%rax
imul   %r13,%rax
add    0x18(%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    1460 <main+0x2b0>
test   $0x1,%dl
je     14a1 <main+0x2f1>
mov    %rbx,%rax
imul   %r14,%rax
add    %rsi,%rax
mov    0x10(%rsp),%rdx
movups (%rdx,%rax,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rdx,%rax,4)
cmp    %rcx,%rbx
je     12a0 <main+0xf0>
mov    %rbx,%rax
imul   %r13,%rax
add    0x10(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    14c0 <main+0x310>
jmp    12a0 <main+0xf0>
xor    %esi,%esi
test   $0x1,%dl
jne    1487 <main+0x2d7>
jmp    14a1 <main+0x2f1>
mov    %rbp,%rdi
call   1060 <fclose@plt>
lea    0x16ba1(%rsp),%r15
mov    0x10(%rsp),%rax
lea    0x10(%rax),%rcx
mov    %rcx,0x58(%rsp)
add    $0xc,%rax
mov    %rax,0x60(%rsp)
lea    0xb2d(%rip),%r12
mov    $0x1,%r14d
jmp    1532 <main+0x382>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
lea    0xb3e(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x110(%rsp)
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)
mov    $0x1f40,%eax
nopw   0x0(%rax,%rax,1)
movb   $0x0,0x13e0(%rsp,%rax,1)
movb   $0x0,0x1bb0(%rsp,%rax,1)
movb   $0x0,0x2380(%rsp,%rax,1)
movb   $0x0,0x2b50(%rsp,%rax,1)
movb   $0x0,0x3320(%rsp,%rax,1)
add    $0x2710,%rax
cmp    $0x157c0,%rax
jne    1590 <main+0x3e0>
mov    %r12,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
xor    %ebx,%ebx
mov    0x2a0f(%rip),%rbp
nopl   0x0(%rax)
mov    0x0(%rbp),%edi
call   1090 <fgetc@plt>
mov    %al,0x440(%rsp,%rbx,1)
lea    0x1(%rbx),%rcx
cmp    $0xa,%al
je     1603 <main+0x453>
cmp    $0x7cf,%rbx
mov    %rcx,%rbx
jb     15e0 <main+0x430>
movb   $0x0,0x43f(%rsp,%rcx,1)
mov    0x440(%rsp),%eax
mov    $0x54495845,%ecx
xor    %ecx,%eax
movzbl 0x444(%rsp),%ecx
or     %eax,%ecx
je     1e60 <main+0xcb0>
mov    $0x1,%eax
mov    %rax,0x18(%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)
xchg   %ax,%ax
movzbl 0x43f(%rsp,%rcx,1),%ebx
mov    %bl,-0x1(%rdx)
movb   $0x0,(%rdx)
movzbl 0x440(%rsp,%rcx,1),%ebx
test   %bl,%bl
je     1690 <main+0x4e0>
add    $0x1,%rdx
add    $0x1,%rcx
cmp    $0x20,%bl
jne    1650 <main+0x4a0>
add    $0x1,%rsi
add    $0x7d0,%rax
addq   $0x1,0x18(%rsp)
add    $0x1,%dil
jmp    163d <main+0x48d>
nopl   (%rax)
cmp    $0x2,%rsi
jb     1520 <main+0x370>
mov    %dil,0x38(%rsp)
xor    %r12d,%r12d
mov    %rsi,0x40(%rsp)
nopw   0x0(%rax,%rax,1)
mov    0x28(%rsp),%r13
test   %r13,%r13
jle    1710 <main+0x560>
imul   $0x7d0,%r12,%rax
lea    (%rsp,%rax,1),%r15
add    $0x16ba0,%r15
mov    0x48(%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     1712 <main+0x562>
add    $0x1,%rbx
add    $0x32,%rbp
cmp    %rbx,%r13
jne    16e0 <main+0x530>
mov    %r13,%rbx
jmp    1712 <main+0x562>
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,0x120(%rsp,%r12,8)
imul   $0x7d0,%r12,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x16ba0,%rsi
lea    0x989(%rip),%rdi
mov    %rbp,%rdx
xor    %eax,%eax
call   1070 <printf@plt>
test   %rbp,%rbp
je     17c0 <main+0x610>
lea    0x1(%r12),%rax
cmp    0x40(%rsp),%r12
mov    %rax,%r12
jne    16b0 <main+0x500>
lea    0x993(%rip),%rdi
call   1040 <puts@plt>
mov    0x20(%rsp),%rax
xorps  %xmm0,%xmm0
test   %rax,%rax
mov    0x18(%rsp),%rbx
jle    17e0 <main+0x630>
mov    0x128(%rsp),%r8
imul   %rax,%r8
mov    0x120(%rsp),%r9
imul   %rax,%r9
mov    0x130(%rsp),%rdi
imul   %rax,%rdi
cmp    $0x8,%rax
lea    0x943(%rip),%r13
jae    17ec <main+0x63c>
xor    %ecx,%ecx
jmp    185b <main+0x6ab>
nopw   0x0(%rax,%rax,1)
lea    0x9c7(%rip),%rdi
call   1040 <puts@plt>
lea    0x16ba1(%rsp),%r15
lea    0x865(%rip),%r12
jmp    1532 <main+0x382>
lea    0x90a(%rip),%r13
jmp    1956 <main+0x7a6>
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
mov    0x58(%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,0xc10(%rsp,%rsi,4)
movaps %xmm1,0xc20(%rsp,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rcx
jne    1810 <main+0x660>
cmp    %rcx,%rax
mov    0x18(%rsp),%rbx
je     18b1 <main+0x701>
mov    0x10(%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,0xc10(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1890 <main+0x6e0>
test   %rax,%rax
jle    1956 <main+0x7a6>
lea    -0x1(%rax),%rdx
mov    %eax,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    18d0 <main+0x720>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    192d <main+0x77d>
and    $0xfffffffffffffffc,%rax
xorps  %xmm0,%xmm0
xor    %edx,%edx
nopl   0x0(%rax)
movss  0xc10(%rsp,%rdx,4),%xmm1
movss  0xc14(%rsp,%rdx,4),%xmm2
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  0xc18(%rsp,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movss  0xc1c(%rsp,%rdx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rdx
cmp    %rdx,%rax
jne    18e0 <main+0x730>
test   %rcx,%rcx
je     1956 <main+0x7a6>
lea    (%rsp,%rdx,4),%rax
add    $0xc10,%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    1940 <main+0x790>
ucomiss 0x6a3(%rip),%xmm0
jb     1965 <main+0x7b5>
sqrtss %xmm0,%xmm0
jmp    196a <main+0x7ba>
call   10d0 <sqrt@plt>
mov    0x40(%rsp),%r8
mov    0x20(%rsp),%rax
test   %rax,%rax
jle    1a3f <main+0x88f>
cmp    $0x4,%rax
jae    198a <main+0x7da>
xor    %ecx,%ecx
jmp    1a20 <main+0x870>
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     19f7 <main+0x847>
mov    %rdx,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
xchg   %ax,%ax
movaps 0xc10(%rsp,%rsi,4),%xmm2
movaps 0xc20(%rsp,%rsi,4),%xmm3
divps  %xmm1,%xmm2
movaps %xmm2,0xc10(%rsp,%rsi,4)
divps  %xmm1,%xmm3
movaps %xmm3,0xc20(%rsp,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    19c0 <main+0x810>
test   $0x1,%dl
jne    19fe <main+0x84e>
jmp    1a3a <main+0x88a>
xor    %esi,%esi
test   $0x1,%dl
je     1a3a <main+0x88a>
movaps 0xc10(%rsp,%rsi,4),%xmm2
divps  %xmm1,%xmm2
movaps %xmm2,0xc10(%rsp,%rsi,4)
jmp    1a3a <main+0x88a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0xc10(%rsp,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xc10(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1a20 <main+0x870>
xorps  %xmm0,%xmm0
movaps %xmm0,0x110(%rsp)
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)
mov    $0x1f40,%eax
nopw   0x0(%rax,%rax,1)
movb   $0x0,0x13e0(%rsp,%rax,1)
movb   $0x0,0x1bb0(%rsp,%rax,1)
movb   $0x0,0x2380(%rsp,%rax,1)
movb   $0x0,0x2b50(%rsp,%rax,1)
movb   $0x0,0x3320(%rsp,%rax,1)
add    $0x2710,%rax
cmp    $0x157c0,%rax
jne    1aa0 <main+0x8f0>
mov    0x28(%rsp),%r9
test   %r9,%r9
jle    1e10 <main+0xc60>
mov    0x120(%rsp),%rax
mov    0x128(%rsp),%r10
mov    0x130(%rsp),%r11
lea    0x1(%r8),%rdi
and    $0xfffffffffffffffc,%rbx
movzbl 0x38(%rsp),%r15d
and    $0x3,%r15d
xor    %ebp,%ebp
xor    %r12d,%r12d
mov    %rbx,0x18(%rsp)
mov    %rdi,0x50(%rsp)
mov    %rax,0x78(%rsp)
mov    %r10,0x70(%rsp)
mov    %r11,0x68(%rsp)
jmp    1b9f <main+0x9ef>
xchg   %ax,%ax
movss  0xc(%rsp),%xmm0
movss  %xmm0,0x80(%rsp,%rbx,4)
imul   $0x7d0,%rbx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x3320,%rdi
imul   $0x32,%r12,%rsi
add    0x48(%rsp),%rsi
call   1030 <strcpy@plt>
mov    0x28(%rsp),%r9
lea    0x586(%rip),%r13
mov    0x18(%rsp),%rbx
mov    0x40(%rsp),%r8
mov    0x78(%rsp),%rax
mov    0x70(%rsp),%r10
mov    0x68(%rsp),%r11
mov    0x50(%rsp),%rdi
mov    0x38(%rsp),%rbp
add    $0x1,%r12
add    $0x4,%rbp
cmp    %r9,%r12
jge    1e10 <main+0xc60>
cmp    %rax,%r12
je     1b8e <main+0x9de>
cmp    %r10,%r12
je     1b8e <main+0x9de>
cmp    %r11,%r12
je     1b8e <main+0x9de>
xor    %edx,%edx
xor    %ecx,%ecx
cmp    $0x3,%r8
jb     1bf9 <main+0xa49>
nopl   0x0(%rax,%rax,1)
cmp    %r12,0x120(%rsp,%rdx,8)
cmove  %r14,%rcx
cmp    %r12,0x128(%rsp,%rdx,8)
cmove  %r14,%rcx
cmp    %r12,0x130(%rsp,%rdx,8)
cmove  %r14,%rcx
cmp    %r12,0x138(%rsp,%rdx,8)
cmove  %r14,%rcx
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1bc0 <main+0xa10>
test   $0x3,%dil
je     1c21 <main+0xa71>
lea    (%rsp,%rdx,8),%rdx
add    $0x120,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
cmp    %r12,(%rdx,%rsi,8)
cmove  %r14,%rcx
add    $0x1,%rsi
cmp    %rsi,%r15
jne    1c10 <main+0xa60>
cmp    $0x1,%rcx
je     1b8e <main+0x9de>
mov    0x20(%rsp),%rdx
test   %rdx,%rdx
mov    %rbp,0x38(%rsp)
jle    1c53 <main+0xaa3>
lea    -0x1(%rdx),%rcx
mov    %edx,%ebp
and    $0x3,%ebp
cmp    $0x3,%rcx
jae    1c5b <main+0xaab>
xorps  %xmm3,%xmm3
xor    %esi,%esi
jmp    1cd4 <main+0xb24>
xorps  %xmm3,%xmm3
jmp    1d17 <main+0xb67>
mov    %rdx,%rdi
and    $0xfffffffffffffffc,%rdi
mov    %rdx,%rcx
imul   0x38(%rsp),%rcx
add    0x60(%rsp),%rcx
xorps  %xmm3,%xmm3
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movss  0xc10(%rsp,%rsi,4),%xmm0
movss  0xc14(%rsp,%rsi,4),%xmm1
mulss  -0xc(%rcx,%rsi,4),%xmm0
mulss  -0x8(%rcx,%rsi,4),%xmm1
addss  %xmm3,%xmm0
movss  0xc18(%rsp,%rsi,4),%xmm2
mulss  -0x4(%rcx,%rsi,4),%xmm2
addss  %xmm0,%xmm1
movss  0xc1c(%rsp,%rsi,4),%xmm3
mulss  (%rcx,%rsi,4),%xmm3
addss  %xmm1,%xmm2
addss  %xmm2,%xmm3
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1c80 <main+0xad0>
test   %rbp,%rbp
je     1d17 <main+0xb67>
mov    0x10(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
imul   0x38(%rsp),%rdx
add    %rcx,%rdx
lea    (%rsp,%rsi,4),%rcx
add    $0xc10,%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    1d00 <main+0xb50>
mov    $0x4,%ebx
nopl   0x0(%rax)
ucomiss 0x70(%rsp,%rbx,4),%xmm3
ja     1d5a <main+0xbaa>
ucomiss 0x74(%rsp,%rbx,4),%xmm3
ja     1d70 <main+0xbc0>
ucomiss 0x78(%rsp,%rbx,4),%xmm3
ja     1d86 <main+0xbd6>
ucomiss 0x7c(%rsp,%rbx,4),%xmm3
ja     1d9c <main+0xbec>
ucomiss 0x80(%rsp,%rbx,4),%xmm3
ja     1db2 <main+0xc02>
add    $0x5,%rbx
cmp    $0x2c,%rbx
jne    1d20 <main+0xb70>
mov    0x18(%rsp),%rbx
jmp    1b84 <main+0x9d4>
movss  %xmm3,0xc(%rsp)
add    $0xfffffffffffffffc,%rbx
cmp    $0x26,%rbx
ja     1b30 <main+0x980>
jmp    1dc2 <main+0xc12>
movss  %xmm3,0xc(%rsp)
add    $0xfffffffffffffffd,%rbx
cmp    $0x26,%rbx
ja     1b30 <main+0x980>
jmp    1dc2 <main+0xc12>
movss  %xmm3,0xc(%rsp)
add    $0xfffffffffffffffe,%rbx
cmp    $0x26,%rbx
ja     1b30 <main+0x980>
jmp    1dc2 <main+0xc12>
movss  %xmm3,0xc(%rsp)
add    $0xffffffffffffffff,%rbx
cmp    $0x26,%rbx
ja     1b30 <main+0x980>
jmp    1dc2 <main+0xc12>
movss  %xmm3,0xc(%rsp)
cmp    $0x26,%rbx
ja     1b30 <main+0x980>
mov    $0x27,%eax
lea    0x15c00(%rsp),%rbp
nop
lea    -0x1(%rax),%r13
movss  0x7c(%rsp,%rax,4),%xmm0
movss  %xmm0,0x80(%rsp,%rax,4)
lea    0x7d0(%rbp),%rdi
mov    %rbp,%rsi
call   1030 <strcpy@plt>
add    $0xfffffffffffff830,%rbp
mov    %r13,%rax
cmp    %rbx,%r13
ja     1dd0 <main+0xc20>
jmp    1b30 <main+0x980>
cs nopw 0x0(%rax,%rax,1)
lea    0x3320(%rsp),%rbp
xor    %ebx,%ebx
lea    0x16ba1(%rsp),%r15
lea    0x217(%rip),%r12
nopl   0x0(%rax)
movss  0x80(%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    1e30 <main+0xc80>
jmp    1532 <main+0x382>
xor    %eax,%eax
jmp    1ea2 <main+0xcf2>
lea    0x33b(%rip),%rdi
call   1040 <puts@plt>
jmp    1e9d <main+0xced>
mov    0x20(%rsp),%rcx
mov    %rcx,%rax
imul   %rdx,%rax
shr    $0x12,%rax
movabs $0xfffffffffff,%rsi
and    %rax,%rsi
lea    0x176(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    $0xffffffff,%eax
add    $0x478e8,%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 = [5 x i8] c"%s%c\00"
@.str.6 = [36 x i8] c"Enter three words (EXIT to break): \00"
@stdin = global i32 0
@.str.7 = [5 x i8] c"EXIT\00"
@.str.8 = [95 x i8] c"Only %lld words were entered.. three words are needed at the input to perform the calculation\0A\00"
@.str.9 = [41 x i8] c"\0AWord: %s Position in vocabulary: %lld\0A\00"
@.str.10 = [25 x i8] c"Out of dictionary word!\0A\00"
@.str.11 = [148 x i8] c"\0A Word Distance\0A------------------------------------------------------------------------\0A\00"
@.str.12 = [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 i8
%24 = alloca float*
%25 = alloca i8*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%26 = load i32, i32* %4
%27 = icmp slt i32 %26, 2
br i1 %27, label %28, label %30
28: ; preds = %2
%29 = 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 %527
30: ; preds = %2
%31 = getelementptr inbounds [2000 x i8], [2000 x i8]* %9, i64 0, i64 0
%32 = load i8**, i8*** %5
%33 = getelementptr inbounds i8*, i8** %32, i64 1
%34 = load i8*, i8** %33
%35 = call i32 @strcpy(i8* %31, i8* %34)
%36 = getelementptr inbounds [2000 x i8], [2000 x i8]* %9, i64 0, i64 0
%37 = call i32* @fopen(i8* %36, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i32* %37, i32** %6
%38 = load i32*, i32** %6
%39 = icmp eq i32* %38, null
br i1 %39, label %40, label %42
40: ; preds = %30
%41 = 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 %527
42: ; preds = %30
%43 = load i32*, i32** %6
%44 = call i32 (i32*, i8*, ...) @fscanf(i32* %43, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i64* %15)
%45 = load i32*, i32** %6
%46 = call i32 (i32*, i8*, ...) @fscanf(i32* %45, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i64* %16)
%47 = load i64, i64* %15
%48 = mul nsw i64 %47, 50
%49 = mul i64 %48, 1
%50 = call i64 @malloc(i64 %49)
%51 = inttoptr i64 %50 to i8*
store i8* %51, i8** %25
%52 = load i64, i64* %15
%53 = load i64, i64* %16
%54 = mul nsw i64 %52, %53
%55 = mul i64 %54, 4
%56 = call i64 @malloc(i64 %55)
%57 = inttoptr i64 %56 to float*
store float* %57, float** %24
%58 = load float*, float** %24
%59 = icmp eq float* %58, null
br i1 %59, label %60, label %69
60: ; preds = %42
%61 = load i64, i64* %15
%62 = load i64, i64* %16
%63 = mul nsw i64 %61, %62
%64 = mul i64 %63, 4
%65 = udiv i64 %64, 1048576
%66 = load i64, i64* %15
%67 = load i64, i64* %16
%68 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.4, i64 0, i64 0), i64 %65, i64 %66, i64 %67)
store i32 -1, i32* %3
br label %527
69: ; preds = %42
store i64 0, i64* %18
br label %70
70: ; preds = %147, %69
%71 = load i64, i64* %18
%72 = load i64, i64* %15
%73 = icmp slt i64 %71, %72
br i1 %73, label %74, label %150
74: ; preds = %70
%75 = load i32*, i32** %6
%76 = load i8*, i8** %25
%77 = load i64, i64* %18
%78 = mul nsw i64 %77, 50
%79 = getelementptr inbounds i8, i8* %76, i64 %78
%80 = call i32 (i32*, i8*, ...) @fscanf(i32* %75, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i8* %79, i8* %23)
store i64 0, i64* %17
br label %81
81: ; preds = %95, %74
%82 = load i64, i64* %17
%83 = load i64, i64* %16
%84 = icmp slt i64 %82, %83
br i1 %84, label %85, label %98
85: ; preds = %81
%86 = load float*, float** %24
%87 = load i64, i64* %17
%88 = load i64, i64* %18
%89 = load i64, i64* %16
%90 = mul nsw i64 %88, %89
%91 = add nsw i64 %87, %90
%92 = getelementptr inbounds float, float* %86, i64 %91
%93 = load i32*, i32** %6
%94 = call i32 @fread(float* %92, i32 4, i32 1, i32* %93)
br label %95
95: ; preds = %85
%96 = load i64, i64* %17
%97 = add nsw i64 %96, 1
store i64 %97, i64* %17
br label %81
98: ; preds = %81
store float 0.000000e+00, float* %12
store i64 0, i64* %17
br label %99
99: ; preds = %122, %98
%100 = load i64, i64* %17
%101 = load i64, i64* %16
%102 = icmp slt i64 %100, %101
br i1 %102, label %103, label %125
103: ; preds = %99
%104 = load float*, float** %24
%105 = load i64, i64* %17
%106 = load i64, i64* %18
%107 = load i64, i64* %16
%108 = mul nsw i64 %106, %107
%109 = add nsw i64 %105, %108
%110 = getelementptr inbounds float, float* %104, i64 %109
%111 = load float, float* %110
%112 = load float*, float** %24
%113 = load i64, i64* %17
%114 = load i64, i64* %18
%115 = load i64, i64* %16
%116 = mul nsw i64 %114, %115
%117 = add nsw i64 %113, %116
%118 = getelementptr inbounds float, float* %112, i64 %117
%119 = load float, float* %118
%120 = load float, float* %12
%121 = call float @llvm.fmuladd.f32(float %111, float %119, float %120)
store float %121, float* %12
br label %122
122: ; preds = %103
%123 = load i64, i64* %17
%124 = add nsw i64 %123, 1
store i64 %124, i64* %17
br label %99
125: ; preds = %99
%126 = load float, float* %12
%127 = call float @sqrt(float %126)
store float %127, float* %12
store i64 0, i64* %17
br label %128
128: ; preds = %143, %125
%129 = load i64, i64* %17
%130 = load i64, i64* %16
%131 = icmp slt i64 %129, %130
br i1 %131, label %132, label %146
132: ; preds = %128
%133 = load float, float* %12
%134 = load float*, float** %24
%135 = load i64, i64* %17
%136 = load i64, i64* %18
%137 = load i64, i64* %16
%138 = mul nsw i64 %136, %137
%139 = add nsw i64 %135, %138
%140 = getelementptr inbounds float, float* %134, i64 %139
%141 = load float, float* %140
%142 = fdiv float %141, %133
store float %142, float* %140
br label %143
143: ; preds = %132
%144 = load i64, i64* %17
%145 = add nsw i64 %144, 1
store i64 %145, i64* %17
br label %128
146: ; preds = %128
br label %147
147: ; preds = %146
%148 = load i64, i64* %18
%149 = add nsw i64 %148, 1
store i64 %149, i64* %18
br label %70
150: ; preds = %70
%151 = load i32*, i32** %6
%152 = call i32 @fclose(i32* %151)
br label %153
153: ; preds = %150, %240, %295, %525
store i64 0, i64* %17
br label %154
154: ; preds = %160, %153
%155 = load i64, i64* %17
%156 = icmp slt i64 %155, 40
br i1 %156, label %157, label %163
157: ; preds = %154
%158 = load i64, i64* %17
%159 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %158
store float 0.000000e+00, float* %159
br label %160
160: ; preds = %157
%161 = load i64, i64* %17
%162 = add nsw i64 %161, 1
store i64 %162, i64* %17
br label %154
163: ; preds = %154
store i64 0, i64* %17
br label %164
164: ; preds = %171, %163
%165 = load i64, i64* %17
%166 = icmp slt i64 %165, 40
br i1 %166, label %167, label %174
167: ; preds = %164
%168 = load i64, i64* %17
%169 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %8, i64 0, i64 %168
%170 = getelementptr inbounds [2000 x i8], [2000 x i8]* %169, i64 0, i64 0
store i8 0, i8* %170
br label %171
171: ; preds = %167
%172 = load i64, i64* %17
%173 = add nsw i64 %172, 1
store i64 %173, i64* %17
br label %164
174: ; preds = %164
%175 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.6, i64 0, i64 0))
store i64 0, i64* %17
br label %176
176: ; preds = %174, %192
%177 = load i32, i32* @stdin
%178 = call signext i8 @fgetc(i32 %177)
%179 = load i64, i64* %17
%180 = getelementptr inbounds [2000 x i8], [2000 x i8]* %7, i64 0, i64 %179
store i8 %178, i8* %180
%181 = load i64, i64* %17
%182 = getelementptr inbounds [2000 x i8], [2000 x i8]* %7, i64 0, i64 %181
%183 = load i8, i8* %182
%184 = sext i8 %183 to i32
%185 = icmp eq i32 %184, 10
br i1 %185, label %189, label %186
186: ; preds = %176
%187 = load i64, i64* %17
%188 = icmp sge i64 %187, 1999
br i1 %188, label %189, label %192
189: ; preds = %186, %176
%190 = load i64, i64* %17
%191 = getelementptr inbounds [2000 x i8], [2000 x i8]* %7, i64 0, i64 %190
store i8 0, i8* %191
br label %195
192: ; preds = %186
%193 = load i64, i64* %17
%194 = add nsw i64 %193, 1
store i64 %194, i64* %17
br label %176
195: ; preds = %189
%196 = getelementptr inbounds [2000 x i8], [2000 x i8]* %7, i64 0, i64 0
%197 = call i32 @strcmp(i8* %196, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%198 = icmp ne i32 %197, 0
br i1 %198, label %200, label %199
199: ; preds = %195
br label %526
200: ; preds = %195
store i64 0, i64* %21
store i64 0, i64* %18
store i64 0, i64* %19
br label %201
201: ; preds = %200, %234
%202 = load i64, i64* %19
%203 = getelementptr inbounds [2000 x i8], [2000 x i8]* %7, i64 0, i64 %202
%204 = load i8, i8* %203
%205 = load i64, i64* %21
%206 = getelementptr inbounds [100 x [2000 x i8]], [100 x [2000 x i8]]* %10, i64 0, i64 %205
%207 = load i64, i64* %18
%208 = getelementptr inbounds [2000 x i8], [2000 x i8]* %206, i64 0, i64 %207
store i8 %204, i8* %208
%209 = load i64, i64* %18
%210 = add nsw i64 %209, 1
store i64 %210, i64* %18
%211 = load i64, i64* %19
%212 = add nsw i64 %211, 1
store i64 %212, i64* %19
%213 = load i64, i64* %21
%214 = getelementptr inbounds [100 x [2000 x i8]], [100 x [2000 x i8]]* %10, i64 0, i64 %213
%215 = load i64, i64* %18
%216 = getelementptr inbounds [2000 x i8], [2000 x i8]* %214, i64 0, i64 %215
store i8 0, i8* %216
%217 = load i64, i64* %19
%218 = getelementptr inbounds [2000 x i8], [2000 x i8]* %7, i64 0, i64 %217
%219 = load i8, i8* %218
%220 = sext i8 %219 to i32
%221 = icmp eq i32 %220, 0
br i1 %221, label %222, label %223
222: ; preds = %201
br label %235
223: ; preds = %201
%224 = load i64, i64* %19
%225 = getelementptr inbounds [2000 x i8], [2000 x i8]* %7, i64 0, i64 %224
%226 = load i8, i8* %225
%227 = sext i8 %226 to i32
%228 = icmp eq i32 %227, 32
br i1 %228, label %229, label %234
229: ; preds = %223
%230 = load i64, i64* %21
%231 = add nsw i64 %230, 1
store i64 %231, i64* %21
store i64 0, i64* %18
%232 = load i64, i64* %19
%233 = add nsw i64 %232, 1
store i64 %233, i64* %19
br label %234
234: ; preds = %229, %223
br label %201
235: ; preds = %222
%236 = load i64, i64* %21
%237 = add nsw i64 %236, 1
store i64 %237, i64* %21
%238 = load i64, i64* %21
%239 = icmp slt i64 %238, 3
br i1 %239, label %240, label %243
240: ; preds = %235
%241 = load i64, i64* %21
%242 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.8, i64 0, i64 0), i64 %241)
br label %153
243: ; preds = %235
store i64 0, i64* %17
br label %244
244: ; preds = %289, %243
%245 = load i64, i64* %17
%246 = load i64, i64* %21
%247 = icmp slt i64 %245, %246
br i1 %247, label %248, label %292
248: ; preds = %244
store i64 0, i64* %18
br label %249
249: ; preds = %265, %248
%250 = load i64, i64* %18
%251 = load i64, i64* %15
%252 = icmp slt i64 %250, %251
br i1 %252, label %253, label %268
253: ; preds = %249
%254 = load i8*, i8** %25
%255 = load i64, i64* %18
%256 = mul nsw i64 %255, 50
%257 = getelementptr inbounds i8, i8* %254, i64 %256
%258 = load i64, i64* %17
%259 = getelementptr inbounds [100 x [2000 x i8]], [100 x [2000 x i8]]* %10, i64 0, i64 %258
%260 = getelementptr inbounds [2000 x i8], [2000 x i8]* %259, i64 0, i64 0
%261 = call i32 @strcmp(i8* %257, i8* %260)
%262 = icmp ne i32 %261, 0
br i1 %262, label %264, label %263
263: ; preds = %253
br label %268
264: ; preds = %253
br label %265
265: ; preds = %264
%266 = load i64, i64* %18
%267 = add nsw i64 %266, 1
store i64 %267, i64* %18
br label %249
268: ; preds = %263, %249
%269 = load i64, i64* %18
%270 = load i64, i64* %15
%271 = icmp eq i64 %269, %270
br i1 %271, label %272, label %273
272: ; preds = %268
store i64 0, i64* %18
br label %273
273: ; preds = %272, %268
%274 = load i64, i64* %18
%275 = load i64, i64* %17
%276 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 %275
store i64 %274, i64* %276
%277 = load i64, i64* %17
%278 = getelementptr inbounds [100 x [2000 x i8]], [100 x [2000 x i8]]* %10, i64 0, i64 %277
%279 = getelementptr inbounds [2000 x i8], [2000 x i8]* %278, i64 0, i64 0
%280 = load i64, i64* %17
%281 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 %280
%282 = load i64, i64* %281
%283 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.9, i64 0, i64 0), i8* %279, i64 %282)
%284 = load i64, i64* %18
%285 = icmp eq i64 %284, 0
br i1 %285, label %286, label %288
286: ; preds = %273
%287 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.10, i64 0, i64 0))
br label %292
288: ; preds = %273
br label %289
289: ; preds = %288
%290 = load i64, i64* %17
%291 = add nsw i64 %290, 1
store i64 %291, i64* %17
br label %244
292: ; preds = %286, %244
%293 = load i64, i64* %18
%294 = icmp eq i64 %293, 0
br i1 %294, label %295, label %296
295: ; preds = %292
br label %153
296: ; preds = %292
%297 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([148 x i8], [148 x i8]* @.str.11, i64 0, i64 0))
store i64 0, i64* %17
br label %298
298: ; preds = %334, %296
%299 = load i64, i64* %17
%300 = load i64, i64* %16
%301 = icmp slt i64 %299, %300
br i1 %301, label %302, label %337
302: ; preds = %298
%303 = load float*, float** %24
%304 = load i64, i64* %17
%305 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 1
%306 = load i64, i64* %305
%307 = load i64, i64* %16
%308 = mul nsw i64 %306, %307
%309 = add nsw i64 %304, %308
%310 = getelementptr inbounds float, float* %303, i64 %309
%311 = load float, float* %310
%312 = load float*, float** %24
%313 = load i64, i64* %17
%314 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 0
%315 = load i64, i64* %314
%316 = load i64, i64* %16
%317 = mul nsw i64 %315, %316
%318 = add nsw i64 %313, %317
%319 = getelementptr inbounds float, float* %312, i64 %318
%320 = load float, float* %319
%321 = fsub float %311, %320
%322 = load float*, float** %24
%323 = load i64, i64* %17
%324 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 2
%325 = load i64, i64* %324
%326 = load i64, i64* %16
%327 = mul nsw i64 %325, %326
%328 = add nsw i64 %323, %327
%329 = getelementptr inbounds float, float* %322, i64 %328
%330 = load float, float* %329
%331 = fadd float %321, %330
%332 = load i64, i64* %17
%333 = getelementptr inbounds [2000 x float], [2000 x float]* %14, i64 0, i64 %332
store float %331, float* %333
br label %334
334: ; preds = %302
%335 = load i64, i64* %17
%336 = add nsw i64 %335, 1
store i64 %336, i64* %17
br label %298
337: ; preds = %298
store float 0.000000e+00, float* %12
store i64 0, i64* %17
br label %338
338: ; preds = %351, %337
%339 = load i64, i64* %17
%340 = load i64, i64* %16
%341 = icmp slt i64 %339, %340
br i1 %341, label %342, label %354
342: ; preds = %338
%343 = load i64, i64* %17
%344 = getelementptr inbounds [2000 x float], [2000 x float]* %14, i64 0, i64 %343
%345 = load float, float* %344
%346 = load i64, i64* %17
%347 = getelementptr inbounds [2000 x float], [2000 x float]* %14, i64 0, i64 %346
%348 = load float, float* %347
%349 = load float, float* %12
%350 = call float @llvm.fmuladd.f32(float %345, float %348, float %349)
store float %350, float* %12
br label %351
351: ; preds = %342
%352 = load i64, i64* %17
%353 = add nsw i64 %352, 1
store i64 %353, i64* %17
br label %338
354: ; preds = %338
%355 = load float, float* %12
%356 = call float @sqrt(float %355)
store float %356, float* %12
store i64 0, i64* %17
br label %357
357: ; preds = %367, %354
%358 = load i64, i64* %17
%359 = load i64, i64* %16
%360 = icmp slt i64 %358, %359
br i1 %360, label %361, label %370
361: ; preds = %357
%362 = load float, float* %12
%363 = load i64, i64* %17
%364 = getelementptr inbounds [2000 x float], [2000 x float]* %14, i64 0, i64 %363
%365 = load float, float* %364
%366 = fdiv float %365, %362
store float %366, float* %364
br label %367
367: ; preds = %361
%368 = load i64, i64* %17
%369 = add nsw i64 %368, 1
store i64 %369, i64* %17
br label %357
370: ; preds = %357
store i64 0, i64* %17
br label %371
371: ; preds = %377, %370
%372 = load i64, i64* %17
%373 = icmp slt i64 %372, 40
br i1 %373, label %374, label %380
374: ; preds = %371
%375 = load i64, i64* %17
%376 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %375
store float 0.000000e+00, float* %376
br label %377
377: ; preds = %374
%378 = load i64, i64* %17
%379 = add nsw i64 %378, 1
store i64 %379, i64* %17
br label %371
380: ; preds = %371
store i64 0, i64* %17
br label %381
381: ; preds = %388, %380
%382 = load i64, i64* %17
%383 = icmp slt i64 %382, 40
br i1 %383, label %384, label %391
384: ; preds = %381
%385 = load i64, i64* %17
%386 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %8, i64 0, i64 %385
%387 = getelementptr inbounds [2000 x i8], [2000 x i8]* %386, i64 0, i64 0
store i8 0, i8* %387
br label %388
388: ; preds = %384
%389 = load i64, i64* %17
%390 = add nsw i64 %389, 1
store i64 %390, i64* %17
br label %381
391: ; preds = %381
store i64 0, i64* %19
br label %392
392: ; preds = %506, %391
%393 = load i64, i64* %19
%394 = load i64, i64* %15
%395 = icmp slt i64 %393, %394
br i1 %395, label %396, label %509
396: ; preds = %392
%397 = load i64, i64* %19
%398 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 0
%399 = load i64, i64* %398
%400 = icmp eq i64 %397, %399
br i1 %400, label %401, label %402
401: ; preds = %396
br label %506
402: ; preds = %396
%403 = load i64, i64* %19
%404 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 1
%405 = load i64, i64* %404
%406 = icmp eq i64 %403, %405
br i1 %406, label %407, label %408
407: ; preds = %402
br label %506
408: ; preds = %402
%409 = load i64, i64* %19
%410 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 2
%411 = load i64, i64* %410
%412 = icmp eq i64 %409, %411
br i1 %412, label %413, label %414
413: ; preds = %408
br label %506
414: ; preds = %408
store i64 0, i64* %17
store i64 0, i64* %18
br label %415
415: ; preds = %427, %414
%416 = load i64, i64* %18
%417 = load i64, i64* %21
%418 = icmp slt i64 %416, %417
br i1 %418, label %419, label %430
419: ; preds = %415
%420 = load i64, i64* %18
%421 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 %420
%422 = load i64, i64* %421
%423 = load i64, i64* %19
%424 = icmp eq i64 %422, %423
br i1 %424, label %425, label %426
425: ; preds = %419
store i64 1, i64* %17
br label %426
426: ; preds = %425, %419
br label %427
427: ; preds = %426
%428 = load i64, i64* %18
%429 = add nsw i64 %428, 1
store i64 %429, i64* %18
br label %415
430: ; preds = %415
%431 = load i64, i64* %17
%432 = icmp eq i64 %431, 1
br i1 %432, label %433, label %434
433: ; preds = %430
br label %506
434: ; preds = %430
store float 0.000000e+00, float* %11
store i64 0, i64* %17
br label %435
435: ; preds = %453, %434
%436 = load i64, i64* %17
%437 = load i64, i64* %16
%438 = icmp slt i64 %436, %437
br i1 %438, label %439, label %456
439: ; preds = %435
%440 = load i64, i64* %17
%441 = getelementptr inbounds [2000 x float], [2000 x float]* %14, i64 0, i64 %440
%442 = load float, float* %441
%443 = load float*, float** %24
%444 = load i64, i64* %17
%445 = load i64, i64* %19
%446 = load i64, i64* %16
%447 = mul nsw i64 %445, %446
%448 = add nsw i64 %444, %447
%449 = getelementptr inbounds float, float* %443, i64 %448
%450 = load float, float* %449
%451 = load float, float* %11
%452 = call float @llvm.fmuladd.f32(float %442, float %450, float %451)
store float %452, float* %11
br label %453
453: ; preds = %439
%454 = load i64, i64* %17
%455 = add nsw i64 %454, 1
store i64 %455, i64* %17
br label %435
456: ; preds = %435
store i64 0, i64* %17
br label %457
457: ; preds = %502, %456
%458 = load i64, i64* %17
%459 = icmp slt i64 %458, 40
br i1 %459, label %460, label %505
460: ; preds = %457
%461 = load float, float* %11
%462 = load i64, i64* %17
%463 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %462
%464 = load float, float* %463
%465 = fcmp ogt float %461, %464
br i1 %465, label %466, label %501
466: ; preds = %460
store i64 39, i64* %20
br label %467
467: ; preds = %486, %466
%468 = load i64, i64* %20
%469 = load i64, i64* %17
%470 = icmp sgt i64 %468, %469
br i1 %470, label %471, label %489
471: ; preds = %467
%472 = load i64, i64* %20
%473 = sub nsw i64 %472, 1
%474 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %473
%475 = load float, float* %474
%476 = load i64, i64* %20
%477 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %476
store float %475, float* %477
%478 = load i64, i64* %20
%479 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %8, i64 0, i64 %478
%480 = getelementptr inbounds [2000 x i8], [2000 x i8]* %479, i64 0, i64 0
%481 = load i64, i64* %20
%482 = sub nsw i64 %481, 1
%483 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %8, i64 0, i64 %482
%484 = getelementptr inbounds [2000 x i8], [2000 x i8]* %483, i64 0, i64 0
%485 = call i32 @strcpy(i8* %480, i8* %484)
br label %486
486: ; preds = %471
%487 = load i64, i64* %20
%488 = add nsw i64 %487, -1
store i64 %488, i64* %20
br label %467
489: ; preds = %467
%490 = load float, float* %11
%491 = load i64, i64* %17
%492 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %491
store float %490, float* %492
%493 = load i64, i64* %17
%494 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %8, i64 0, i64 %493
%495 = getelementptr inbounds [2000 x i8], [2000 x i8]* %494, i64 0, i64 0
%496 = load i8*, i8** %25
%497 = load i64, i64* %19
%498 = mul nsw i64 %497, 50
%499 = getelementptr inbounds i8, i8* %496, i64 %498
%500 = call i32 @strcpy(i8* %495, i8* %499)
br label %505
501: ; preds = %460
br label %502
502: ; preds = %501
%503 = load i64, i64* %17
%504 = add nsw i64 %503, 1
store i64 %504, i64* %17
br label %457
505: ; preds = %489, %457
br label %506
506: ; preds = %505, %433, %413, %407, %401
%507 = load i64, i64* %19
%508 = add nsw i64 %507, 1
store i64 %508, i64* %19
br label %392
509: ; preds = %392
store i64 0, i64* %17
br label %510
510: ; preds = %522, %509
%511 = load i64, i64* %17
%512 = icmp slt i64 %511, 40
br i1 %512, label %513, label %525
513: ; preds = %510
%514 = load i64, i64* %17
%515 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %8, i64 0, i64 %514
%516 = getelementptr inbounds [2000 x i8], [2000 x i8]* %515, i64 0, i64 0
%517 = load i64, i64* %17
%518 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %517
%519 = load float, float* %518
%520 = fpext float %519 to double
%521 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0), i8* %516, double %520)
br label %522
522: ; preds = %513
%523 = load i64, i64* %17
%524 = add nsw i64 %523, 1
store i64 %524, i64* %17
br label %510
525: ; preds = %510
br label %153
526: ; preds = %199
store i32 0, i32* %3
br label %527
527: ; preds = %526, %60, %40, %28
%528 = load i32, i32* %3
ret i32 %528
}

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