#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: ./distance <FILE>\nwhere FILE contains word projections in "
           "the BINARY FORMAT\n");
    return 0;
  }
  strcpy(file_name, argv[1]);
  f = fopen(file_name, "rb");
  if (f == NULL) {
    printf("Input file not found\n");
    return -1;
  }
  fscanf(f, "%lld", &words);
  fscanf(f, "%lld", &size);
  vocab = (char *)malloc((long long)words * 50 * sizeof(char));
  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 word or sentence (EXIT to break): ");
    a = 0;
    while (1) {
      st1[a] = fgetc(stdin);
      if ((st1[a] == '\n') || (a >= 2000 - 1)) {
        st1[a] = 0;
        break;
      }
      a++;
    }
    if (!strcmp(st1, "EXIT"))
      break;
    cn = 0;
    b = 0;
    c = 0;
    while (1) {
      st[cn][b] = st1[c];
      b++;
      c++;
      st[cn][b] = 0;
      if (st1[c] == 0)
        break;
      if (st1[c] == ' ') {
        cn++;
        b = 0;
        c++;
      }
    }
    cn++;
    for (a = 0; a < cn; a++) {
      for (b = 0; b < words; b++)
        if (!strcmp(&vocab[b * 50], st[a]))
          break;
      if (b == words)
        b = -1;
      bi[a] = b;
      printf("\nWord: %s  Position in vocabulary: %lld\n", st[a], bi[a]);
      if (b == -1) {
        printf("Out of dictionary word!\n");
        break;
      }
    }
    if (b == -1)
      continue;
    printf("\n                                              Word       Cosine "
           "distance\n---------------------------------------------------------"
           "---------------\n");
    for (a = 0; a < size; a++)
      vec[a] = 0;
    for (b = 0; b < cn; b++) {
      if (bi[b] == -1)
        continue;
      for (a = 0; a < size; a++)
        vec[a] += M[a + bi[b] * size];
    }
    len = 0;
    for (a = 0; a < size; a++)
      len += vec[a] * vec[a];
    len = sqrt(len);
    for (a = 0; a < size; a++)
      vec[a] /= len;
    for (a = 0; a < 40; a++)
      bestd[a] = 0;
    for (a = 0; a < 40; a++)
      bestw[a][0] = 0;
    for (c = 0; c < words; c++) {
      a = 0;
      for (b = 0; b < cn; b++)
        if (bi[b] == c)
          a = 1;
      if (a == 1)
        continue;
      dist = 0;
      for (a = 0; a < size; a++)
        dist += vec[a] * M[a + c * size];
      for (a = 0; a < 40; a++) {
        if (dist > bestd[a]) {
          for (d = 40 - 1; d > a; d--) {
            bestd[d] = bestd[d - 1];
            strcpy(bestw[d], bestw[d - 1]);
          }
          bestd[a] = dist;
          strcpy(bestw[a], &vocab[c * 50]);
          break;
        }
      }
    }
    for (a = 0; a < 40; a++)
      printf("%50s\t\t%f\n", bestw[a], bestd[a]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $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    1df9 <main+0xc59>
lea    -0x14840(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
call   1030 <strcpy@plt>
lea    -0x14840(%rbp),%rdi
lea    0xe55(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    122d <main+0x8d>
lea    0xe3d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1df9 <main+0xc59>
mov    -0x18(%rbp),%rdi
lea    0xe35(%rip),%rsi
lea    -0x47578(%rbp),%rdx
mov    $0x0,%al
call   1070 <fscanf@plt>
mov    -0x18(%rbp),%rdi
lea    0xe1c(%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    0xda2(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1df9 <main+0xc59>
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    0xd82(%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    0xb2e(%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    0xac5(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%eax
jne    161d <main+0x47d>
jmp    1df2 <main+0xc52>
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)
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x475a8(%rbp),%rax
jge    1862 <main+0x6c2>
movq   $0x0,-0x47590(%rbp)
mov    -0x47590(%rbp),%rax
cmp    -0x47578(%rbp),%rax
jge    17be <main+0x61e>
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    17a2 <main+0x602>
jmp    17be <main+0x61e>
jmp    17a7 <main+0x607>
mov    -0x47590(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47590(%rbp)
jmp    1754 <main+0x5b4>
mov    -0x47590(%rbp),%rax
cmp    -0x47578(%rbp),%rax
jne    17dd <main+0x63d>
movq   $0xffffffffffffffff,-0x47590(%rbp)
ff ff ff ff
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    0x8b6(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
cmpq   $0xffffffffffffffff,-0x47590(%rbp)
ff
jne    1846 <main+0x6a6>
lea    0x8c3(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1862 <main+0x6c2>
jmp    184b <main+0x6ab>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1735 <main+0x595>
cmpq   $0xffffffffffffffff,-0x47590(%rbp)
ff
jne    1875 <main+0x6d5>
jmp    14e6 <main+0x346>
lea    0x89a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    18cc <main+0x72c>
mov    -0x47588(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x47570(%rbp,%rax,4)
fb ff
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    188e <main+0x6ee>
movq   $0x0,-0x47590(%rbp)
mov    -0x47590(%rbp),%rax
cmp    -0x475a8(%rbp),%rax
jge    199e <main+0x7fe>
mov    -0x47590(%rbp),%rax
cmpq   $0xffffffffffffffff,-0x478d0(%rbp,%rax,8)
ff ff
jne    1906 <main+0x766>
jmp    1987 <main+0x7e7>
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    1982 <main+0x7e2>
mov    -0x478e0(%rbp),%rax
mov    -0x47588(%rbp),%rcx
mov    -0x47590(%rbp),%rdx
mov    -0x478d0(%rbp,%rdx,8),%rdx
ff
imul   -0x47580(%rbp),%rdx
ff
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x47588(%rbp),%rax
addss  -0x47570(%rbp,%rax,4),%xmm0
fb ff
movss  %xmm0,-0x47570(%rbp,%rax,4)
fb ff
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1911 <main+0x771>
jmp    1987 <main+0x7e7>
mov    -0x47590(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47590(%rbp)
jmp    18d7 <main+0x737>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x45588(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    1a17 <main+0x877>
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    19b4 <main+0x814>
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    1a87 <main+0x8e7>
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    1a37 <main+0x897>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1aca <main+0x92a>
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    1a92 <main+0x8f2>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1b12 <main+0x972>
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    1ad5 <main+0x935>
movq   $0x0,-0x47598(%rbp)
mov    -0x47598(%rbp),%rax
cmp    -0x47578(%rbp),%rax
jge    1d86 <main+0xbe6>
movq   $0x0,-0x47588(%rbp)
movq   $0x0,-0x47590(%rbp)
mov    -0x47590(%rbp),%rax
cmp    -0x475a8(%rbp),%rax
jge    1b9e <main+0x9fe>
mov    -0x47590(%rbp),%rax
mov    -0x478d0(%rbp,%rax,8),%rax
ff
cmp    -0x47598(%rbp),%rax
jne    1b82 <main+0x9e2>
movq   $0x1,-0x47588(%rbp)
jmp    1b87 <main+0x9e7>
mov    -0x47590(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47590(%rbp)
jmp    1b47 <main+0x9a7>
cmpq   $0x1,-0x47588(%rbp)
01
jne    1bb1 <main+0xa11>
jmp    1d6f <main+0xbcf>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x45584(%rbp)
ff
movq   $0x0,-0x47588(%rbp)
mov    -0x47588(%rbp),%rax
cmp    -0x47580(%rbp),%rax
jge    1c3f <main+0xa9f>
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    1bc7 <main+0xa27>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1d6a <main+0xbca>
movss  -0x45584(%rbp),%xmm0
ff
mov    -0x47588(%rbp),%rax
ucomiss -0x45630(%rbp,%rax,4),%xmm0
ff
jbe    1d4e <main+0xbae>
movq   $0x27,-0x475a0(%rbp)
mov    -0x475a0(%rbp),%rax
cmp    -0x47588(%rbp),%rax
jle    1d05 <main+0xb65>
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    1c80 <main+0xae0>
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    1d6a <main+0xbca>
jmp    1d53 <main+0xbb3>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1c4a <main+0xaaa>
jmp    1d6f <main+0xbcf>
mov    -0x47598(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47598(%rbp)
jmp    1b1d <main+0x97d>
movq   $0x0,-0x47588(%rbp)
cmpq   $0x28,-0x47588(%rbp)
28
jge    1ded <main+0xc4d>
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    0x3db(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x47588(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x47588(%rbp)
jmp    1d91 <main+0xbf1>
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    $0x478c8,%rsp
cmp    $0x1,%edi
jg     11e9 <main+0x29>
lea    0xf84(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
jmp    1e9f <main+0xcdf>
mov    0x8(%rsi),%rsi
lea    0x2b30(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xe00(%rip),%rsi
mov    %rbx,%rdi
call   10d0 <fopen@plt>
test   %rax,%rax
je     1e61 <main+0xca1>
mov    %rax,%rbp
lea    0xde8(%rip),%rbx
lea    0x28(%rsp),%rdx
mov    %rax,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1090 <fscanf@plt>
lea    0x18(%rsp),%rdx
mov    %rbp,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1090 <fscanf@plt>
imul   $0x32,0x28(%rsp),%rdi
call   10c0 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    0x28(%rsp),%rdi
imul   0x18(%rsp),%rdi
shl    $0x2,%rdi
call   10c0 <malloc@plt>
mov    0x28(%rsp),%rdx
test   %rax,%rax
je     1e6f <main+0xcaf>
mov    %rax,0x10(%rsp)
test   %rdx,%rdx
jle    14f5 <main+0x335>
mov    0x10(%rsp),%rax
lea    0xc(%rax),%rcx
mov    %rcx,0x38(%rsp)
add    $0x10,%rax
mov    %rax,0x20(%rsp)
lea    0x37(%rsp),%r12
xor    %r13d,%r13d
xor    %r14d,%r14d
mov    0x10(%rsp),%r15
jmp    12c3 <main+0x103>
nopl   0x0(%rax)
add    $0x1,%r14
add    $0x4,%r13
cmp    0x28(%rsp),%r14
jge    14f5 <main+0x335>
imul   $0x32,%r14,%rdx
add    0x40(%rsp),%rdx
mov    %rbp,%rdi
lea    0xd65(%rip),%rsi
mov    %r12,%rcx
xor    %eax,%eax
call   1090 <fscanf@plt>
mov    0x18(%rsp),%rax
xorps  %xmm0,%xmm0
test   %rax,%rax
jle    13e6 <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    0x18(%rsp),%rax
cmp    %rax,%rbx
jl     1300 <main+0x140>
xorps  %xmm0,%xmm0
test   %rax,%rax
jle    13e6 <main+0x226>
lea    -0x1(%rax),%rdx
mov    %eax,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    134d <main+0x18d>
xorps  %xmm0,%xmm0
xor    %edx,%edx
jmp    13b0 <main+0x1f0>
mov    %rax,%rsi
and    $0xfffffffffffffffc,%rsi
mov    %r13,%rdi
imul   %rax,%rdi
add    0x38(%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    1370 <main+0x1b0>
test   %rcx,%rcx
je     13e6 <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    13d0 <main+0x210>
ucomiss 0xc13(%rip),%xmm0
jb     1400 <main+0x240>
sqrtss %xmm0,%xmm0
jmp    1405 <main+0x245>
cs nopw 0x0(%rax,%rax,1)
nop
call   10e0 <sqrt@plt>
mov    0x18(%rsp),%rbx
test   %rbx,%rbx
jle    12b0 <main+0xf0>
cmp    $0x4,%rbx
jae    1420 <main+0x260>
xor    %ecx,%ecx
jmp    14ba <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     14ec <main+0x32c>
mov    %rdx,%rdi
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdi
mov    %rbx,%rax
imul   %r13,%rax
add    0x20(%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    1470 <main+0x2b0>
test   $0x1,%dl
je     14b1 <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     12b0 <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    14d0 <main+0x310>
jmp    12b0 <main+0xf0>
xor    %esi,%esi
test   $0x1,%dl
jne    1497 <main+0x2d7>
jmp    14b1 <main+0x2f1>
mov    %rbp,%rdi
call   1060 <fclose@plt>
mov    0x10(%rsp),%rax
lea    0x30(%rax),%rcx
mov    %rcx,0x50(%rsp)
add    $0xc,%rax
mov    %rax,0x58(%rsp)
jmp    152c <main+0x36c>
cs nopw 0x0(%rax,%rax,1)
lea    0xc0d(%rip),%rdi
call   1040 <puts@plt>
xorps  %xmm0,%xmm0
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)
movaps %xmm0,0x60(%rsp)
mov    $0x1f40,%eax
xchg   %ax,%ax
movb   $0x0,0x13c0(%rsp,%rax,1)
movb   $0x0,0x1b90(%rsp,%rax,1)
movb   $0x0,0x2360(%rsp,%rax,1)
movb   $0x0,0x2b30(%rsp,%rax,1)
movb   $0x0,0x3300(%rsp,%rax,1)
add    $0x2710,%rax
cmp    $0x157c0,%rax
jne    1580 <main+0x3c0>
lea    0xa83(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
xor    %ebx,%ebx
mov    0x2a1b(%rip),%rbp
nopl   (%rax)
mov    0x0(%rbp),%edi
call   10a0 <fgetc@plt>
mov    %al,0x2360(%rsp,%rbx,1)
lea    0x1(%rbx),%rcx
cmp    $0xa,%al
je     15f3 <main+0x433>
cmp    $0x7cf,%rbx
mov    %rcx,%rbx
jb     15d0 <main+0x410>
movb   $0x0,0x235f(%rsp,%rcx,1)
mov    0x2360(%rsp),%eax
mov    $0x54495845,%ecx
xor    %ecx,%eax
movzbl 0x2364(%rsp),%ecx
or     %eax,%ecx
je     1e5d <main+0xc9d>
mov    $0x1,%r13d
mov    $0x1,%sil
lea    0x16b81(%rsp),%rax
xor    %ecx,%ecx
xor    %r12d,%r12d
add    $0x1,%rcx
mov    %rax,%rdx
cs nopw 0x0(%rax,%rax,1)
movzbl 0x235f(%rsp,%rcx,1),%ebx
mov    %bl,-0x1(%rdx)
movb   $0x0,(%rdx)
movzbl 0x2360(%rsp,%rcx,1),%ebx
test   %bl,%bl
je     1680 <main+0x4c0>
add    $0x1,%rdx
add    $0x1,%rcx
cmp    $0x20,%bl
jne    1640 <main+0x480>
add    $0x1,%r12
add    $0x7d0,%rax
add    $0x1,%r13
add    $0x1,%sil
jmp    162f <main+0x46f>
nopl   0x0(%rax,%rax,1)
mov    %sil,0x20(%rsp)
xor    %r15d,%r15d
mov    %r12,0x38(%rsp)
nopl   (%rax)
mov    0x28(%rsp),%r14
test   %r14,%r14
jle    16f0 <main+0x530>
mov    %r13,%r12
imul   $0x7d0,%r15,%rax
lea    (%rsp,%rax,1),%r13
add    $0x16b80,%r13
mov    0x40(%rsp),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    %rbp,%rdi
mov    %r13,%rsi
call   10b0 <strcmp@plt>
test   %eax,%eax
je     16df <main+0x51f>
add    $0x1,%rbx
add    $0x32,%rbp
cmp    %rbx,%r14
jne    16c0 <main+0x500>
mov    %r14,%rbx
mov    %r12,%r13
mov    0x38(%rsp),%r12
jmp    16f2 <main+0x532>
nopl   0x0(%rax)
xor    %ebx,%ebx
cmp    %r14,%rbx
mov    %rbx,%rdx
mov    $0xffffffffffffffff,%rax
cmove  %rax,%rdx
mov    %rdx,0x100(%rsp,%r15,8)
imul   $0x7d0,%r15,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x16b80,%rsi
lea    0x94a(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
cmp    %r14,%rbx
je     1520 <main+0x360>
lea    0x1(%r15),%rax
cmp    %r12,%r15
mov    %rax,%r15
jne    1690 <main+0x4d0>
cmp    $0xffffffffffffffff,%rbx
mov    0x10(%rsp),%r14
je     152c <main+0x36c>
lea    0x947(%rip),%rdi
call   1040 <puts@plt>
mov    0x18(%rsp),%rbx
test   %rbx,%rbx
jle    1780 <main+0x5c0>
lea    0x0(,%rbx,4),%rdx
lea    0x420(%rsp),%rdi
xor    %esi,%esi
call   1080 <memset@plt>
lea    -0x8(%rbx),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %rbx,%rdx
and    $0xfffffffffffffff8,%rdx
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
xor    %edi,%edi
mov    0x50(%rsp),%r11
jmp    17c0 <main+0x600>
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%rdi),%rax
cmp    %r12,%rdi
mov    %rax,%rdi
je     18f0 <main+0x730>
mov    0x100(%rsp,%rdi,8),%rbp
cmp    $0xffffffffffffffff,%rbp
je     17b0 <main+0x5f0>
test   %rbx,%rbx
jle    17b0 <main+0x5f0>
imul   %rbx,%rbp
cmp    $0x8,%rbx
jae    17f0 <main+0x630>
xor    %eax,%eax
jmp    18ae <main+0x6ee>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x8,%r9
jae    17fa <main+0x63a>
xor    %esi,%esi
jmp    186d <main+0x6ad>
lea    (%r11,%rbp,4),%rax
mov    %r8,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rax,%rsi,4),%xmm0
movups -0x20(%rax,%rsi,4),%xmm1
addps  0x420(%rsp,%rsi,4),%xmm0
addps  0x430(%rsp,%rsi,4),%xmm1
movaps %xmm0,0x420(%rsp,%rsi,4)
movaps %xmm1,0x430(%rsp,%rsi,4)
movups -0x10(%rax,%rsi,4),%xmm0
movups (%rax,%rsi,4),%xmm1
addps  0x440(%rsp,%rsi,4),%xmm0
addps  0x450(%rsp,%rsi,4),%xmm1
movaps %xmm0,0x440(%rsp,%rsi,4)
movaps %xmm1,0x450(%rsp,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1810 <main+0x650>
test   $0x1,%r10b
je     18a2 <main+0x6e2>
lea    (%rsi,%rbp,1),%rax
movups (%r14,%rax,4),%xmm0
movups 0x10(%r14,%rax,4),%xmm1
addps  0x420(%rsp,%rsi,4),%xmm0
addps  0x430(%rsp,%rsi,4),%xmm1
movaps %xmm0,0x420(%rsp,%rsi,4)
movaps %xmm1,0x430(%rsp,%rsi,4)
mov    %rdx,%rax
cmp    %rdx,%rbx
je     17b0 <main+0x5f0>
lea    (%r14,%rbp,4),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rcx,%rax,4),%xmm0
addss  0x420(%rsp,%rax,4),%xmm0
movss  %xmm0,0x420(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbx
jne    18c0 <main+0x700>
jmp    17b0 <main+0x5f0>
cs nopw 0x0(%rax,%rax,1)
nop
test   %rbx,%rbx
jle    1915 <main+0x755>
lea    -0x1(%rbx),%rcx
mov    %ebx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1927 <main+0x767>
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
mov    $0x1,%ebp
mov    0x20(%rsp),%r14b
jmp    198d <main+0x7cd>
xorps  %xmm0,%xmm0
mov    $0x1,%ebp
mov    0x20(%rsp),%r14b
jmp    19b6 <main+0x7f6>
and    $0xfffffffffffffffc,%rbx
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
mov    $0x1,%ebp
mov    0x20(%rsp),%r14b
nopw   0x0(%rax,%rax,1)
movss  0x420(%rsp,%rcx,4),%xmm1
movss  0x424(%rsp,%rcx,4),%xmm2
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  0x428(%rsp,%rcx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movss  0x42c(%rsp,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    1940 <main+0x780>
test   %rax,%rax
je     19b6 <main+0x7f6>
lea    (%rsp,%rcx,4),%rcx
add    $0x420,%rcx
xor    %edx,%edx
nop
movss  (%rcx,%rdx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    19a0 <main+0x7e0>
ucomiss 0x643(%rip),%xmm0
jb     19c5 <main+0x805>
sqrtss %xmm0,%xmm0
jmp    19ca <main+0x80a>
call   10e0 <sqrt@plt>
mov    0x18(%rsp),%rax
test   %rax,%rax
jle    1a9f <main+0x8df>
cmp    $0x4,%rax
jae    19e5 <main+0x825>
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
nopl   0x0(%rax)
movaps 0x420(%rsp,%rsi,4),%xmm2
movaps 0x430(%rsp,%rsi,4),%xmm3
divps  %xmm1,%xmm2
movaps %xmm2,0x420(%rsp,%rsi,4)
divps  %xmm1,%xmm3
movaps %xmm3,0x430(%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 0x420(%rsp,%rsi,4),%xmm2
divps  %xmm1,%xmm2
movaps %xmm2,0x420(%rsp,%rsi,4)
jmp    1a9a <main+0x8da>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x420(%rsp,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x420(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1a80 <main+0x8c0>
xorps  %xmm0,%xmm0
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)
movaps %xmm0,0x60(%rsp)
mov    $0x1f40,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movb   $0x0,0x13c0(%rsp,%rax,1)
movb   $0x0,0x1b90(%rsp,%rax,1)
movb   $0x0,0x2360(%rsp,%rax,1)
movb   $0x0,0x2b30(%rsp,%rax,1)
movb   $0x0,0x3300(%rsp,%rax,1)
add    $0x2710,%rax
cmp    $0x157c0,%rax
jne    1b00 <main+0x940>
mov    0x28(%rsp),%r8
test   %r8,%r8
jle    1e10 <main+0xc50>
lea    0x1(%r12),%rbx
and    $0xfffffffffffffffc,%r13
movzbl %r14b,%r15d
and    $0x3,%r15d
xor    %eax,%eax
xor    %r14d,%r14d
mov    %r13,0x48(%rsp)
jmp    1bca <main+0xa0a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0xc(%rsp),%xmm0
movss  %xmm0,0x60(%rsp,%r13,4)
imul   $0x7d0,%r13,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x3300,%rdi
imul   $0x32,%r14,%rsi
add    0x40(%rsp),%rsi
call   1030 <strcpy@plt>
mov    0x28(%rsp),%r8
mov    0x48(%rsp),%r13
mov    $0x1,%ebp
mov    %r12,%rbx
mov    0x38(%rsp),%r12
mov    0x20(%rsp),%rax
add    $0x1,%r14
add    $0x4,%rax
cmp    %r8,%r14
jge    1e10 <main+0xc50>
xor    %edx,%edx
xor    %ecx,%ecx
cmp    $0x3,%r12
jb     1c19 <main+0xa59>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %r14,0x100(%rsp,%rdx,8)
cmove  %rbp,%rcx
cmp    %r14,0x108(%rsp,%rdx,8)
cmove  %rbp,%rcx
cmp    %r14,0x110(%rsp,%rdx,8)
cmove  %rbp,%rcx
cmp    %r14,0x118(%rsp,%rdx,8)
cmove  %rbp,%rcx
add    $0x4,%rdx
cmp    %rdx,%r13
jne    1be0 <main+0xa20>
test   $0x3,%bl
je     1c41 <main+0xa81>
lea    (%rsp,%rdx,8),%rdx
add    $0x100,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
cmp    %r14,(%rdx,%rsi,8)
cmove  %rbp,%rcx
add    $0x1,%rsi
cmp    %rsi,%r15
jne    1c30 <main+0xa70>
cmp    $0x1,%rcx
je     1bb9 <main+0x9f9>
mov    0x18(%rsp),%rdx
test   %rdx,%rdx
jle    1c6b <main+0xaab>
lea    -0x1(%rdx),%rcx
mov    %edx,%ebp
and    $0x3,%ebp
cmp    $0x3,%rcx
jae    1c73 <main+0xab3>
xorps  %xmm3,%xmm3
xor    %esi,%esi
jmp    1ce4 <main+0xb24>
xorps  %xmm3,%xmm3
jmp    1d27 <main+0xb67>
mov    %rdx,%rdi
and    $0xfffffffffffffffc,%rdi
mov    %rdx,%rcx
imul   %rax,%rcx
add    0x58(%rsp),%rcx
xorps  %xmm3,%xmm3
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movss  0x420(%rsp,%rsi,4),%xmm0
movss  0x424(%rsp,%rsi,4),%xmm1
mulss  -0xc(%rcx,%rsi,4),%xmm0
mulss  -0x8(%rcx,%rsi,4),%xmm1
addss  %xmm3,%xmm0
movss  0x428(%rsp,%rsi,4),%xmm2
mulss  -0x4(%rcx,%rsi,4),%xmm2
addss  %xmm0,%xmm1
movss  0x42c(%rsp,%rsi,4),%xmm3
mulss  (%rcx,%rsi,4),%xmm3
addss  %xmm1,%xmm2
addss  %xmm2,%xmm3
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1c90 <main+0xad0>
test   %rbp,%rbp
je     1d27 <main+0xb67>
mov    0x10(%rsp),%rcx
lea    (%rcx,%rsi,4),%rcx
imul   %rax,%rdx
add    %rcx,%rdx
lea    (%rsp,%rsi,4),%rcx
add    $0x420,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
mulss  (%rdx,%rsi,4),%xmm0
addss  %xmm0,%xmm3
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1d10 <main+0xb50>
mov    $0x4,%r13d
nopl   (%rax)
ucomiss 0x50(%rsp,%r13,4),%xmm3
ja     1d71 <main+0xbb1>
ucomiss 0x54(%rsp,%r13,4),%xmm3
ja     1d7d <main+0xbbd>
ucomiss 0x58(%rsp,%r13,4),%xmm3
ja     1d89 <main+0xbc9>
ucomiss 0x5c(%rsp,%r13,4),%xmm3
ja     1d95 <main+0xbd5>
ucomiss 0x60(%rsp,%r13,4),%xmm3
ja     1da1 <main+0xbe1>
add    $0x5,%r13
cmp    $0x2c,%r13
jne    1d30 <main+0xb70>
mov    0x48(%rsp),%r13
mov    $0x1,%ebp
jmp    1bb9 <main+0x9f9>
movss  %xmm3,0xc(%rsp)
add    $0xfffffffffffffffc,%r13
jmp    1db0 <main+0xbf0>
movss  %xmm3,0xc(%rsp)
add    $0xfffffffffffffffd,%r13
jmp    1db0 <main+0xbf0>
movss  %xmm3,0xc(%rsp)
add    $0xfffffffffffffffe,%r13
jmp    1db0 <main+0xbf0>
movss  %xmm3,0xc(%rsp)
add    $0xffffffffffffffff,%r13
jmp    1db0 <main+0xbf0>
movss  %xmm3,0xc(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %rax,0x20(%rsp)
mov    %rbx,%r12
cmp    $0x26,%r13
ja     1b70 <main+0x9b0>
mov    $0x27,%eax
lea    0x15be0(%rsp),%rbp
nop
lea    -0x1(%rax),%rbx
movss  0x5c(%rsp,%rax,4),%xmm0
movss  %xmm0,0x60(%rsp,%rax,4)
lea    0x7d0(%rbp),%rdi
mov    %rbp,%rsi
call   1030 <strcpy@plt>
add    $0xfffffffffffff830,%rbp
mov    %rbx,%rax
cmp    %r13,%rbx
ja     1dd0 <main+0xc10>
jmp    1b70 <main+0x9b0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x3300(%rsp),%rbp
xor    %ebx,%ebx
lea    0x276(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x60(%rsp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    %rbp,%rsi
mov    $0x1,%al
call   1070 <printf@plt>
add    $0x1,%rbx
add    $0x7d0,%rbp
cmp    $0x28,%rbx
jne    1e30 <main+0xc70>
jmp    152c <main+0x36c>
xor    %eax,%eax
jmp    1e9f <main+0xcdf>
lea    0x2e4(%rip),%rdi
call   1040 <puts@plt>
jmp    1e9a <main+0xcda>
mov    0x18(%rsp),%rcx
mov    %rcx,%rax
imul   %rdx,%rax
shr    $0x12,%rax
movabs $0xfffffffffff,%rsi
and    %rax,%rsi
lea    0x179(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    $0xffffffff,%eax
add    $0x478c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [84 x i8] c"Usage: ./distance <FILE>\0Awhere FILE contains word projections in the BINARY FORMAT\0A\00"
@.str.1 = [3 x i8] c"rb\00"
@.str.2 = [22 x i8] c"Input file not found\0A\00"
@.str.3 = [5 x i8] c"%lld\00"
@.str.4 = [47 x i8] c"Cannot allocate memory: %lld MB %lld %lld\0A\00"
@.str.5 = [5 x i8] c"%s%c\00"
@.str.6 = [41 x i8] c"Enter word or sentence (EXIT to break): \00"
@stdin = global i32 0
@.str.7 = [5 x i8] c"EXIT\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 Cosine 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 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 ([84 x i8], [84 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %3
br label %512
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 %512
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 %512
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, %289, %510
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 ([41 x i8], [41 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 %511
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
store i64 0, i64* %17
br label %238
238: ; preds = %283, %235
%239 = load i64, i64* %17
%240 = load i64, i64* %21
%241 = icmp slt i64 %239, %240
br i1 %241, label %242, label %286
242: ; preds = %238
store i64 0, i64* %18
br label %243
243: ; preds = %259, %242
%244 = load i64, i64* %18
%245 = load i64, i64* %15
%246 = icmp slt i64 %244, %245
br i1 %246, label %247, label %262
247: ; preds = %243
%248 = load i8*, i8** %25
%249 = load i64, i64* %18
%250 = mul nsw i64 %249, 50
%251 = getelementptr inbounds i8, i8* %248, i64 %250
%252 = load i64, i64* %17
%253 = getelementptr inbounds [100 x [2000 x i8]], [100 x [2000 x i8]]* %10, i64 0, i64 %252
%254 = getelementptr inbounds [2000 x i8], [2000 x i8]* %253, i64 0, i64 0
%255 = call i32 @strcmp(i8* %251, i8* %254)
%256 = icmp ne i32 %255, 0
br i1 %256, label %258, label %257
257: ; preds = %247
br label %262
258: ; preds = %247
br label %259
259: ; preds = %258
%260 = load i64, i64* %18
%261 = add nsw i64 %260, 1
store i64 %261, i64* %18
br label %243
262: ; preds = %257, %243
%263 = load i64, i64* %18
%264 = load i64, i64* %15
%265 = icmp eq i64 %263, %264
br i1 %265, label %266, label %267
266: ; preds = %262
store i64 -1, i64* %18
br label %267
267: ; preds = %266, %262
%268 = load i64, i64* %18
%269 = load i64, i64* %17
%270 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 %269
store i64 %268, i64* %270
%271 = load i64, i64* %17
%272 = getelementptr inbounds [100 x [2000 x i8]], [100 x [2000 x i8]]* %10, i64 0, i64 %271
%273 = getelementptr inbounds [2000 x i8], [2000 x i8]* %272, i64 0, i64 0
%274 = load i64, i64* %17
%275 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 %274
%276 = load i64, i64* %275
%277 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.8, i64 0, i64 0), i8* %273, i64 %276)
%278 = load i64, i64* %18
%279 = icmp eq i64 %278, -1
br i1 %279, label %280, label %282
280: ; preds = %267
%281 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.9, i64 0, i64 0))
br label %286
282: ; preds = %267
br label %283
283: ; preds = %282
%284 = load i64, i64* %17
%285 = add nsw i64 %284, 1
store i64 %285, i64* %17
br label %238
286: ; preds = %280, %238
%287 = load i64, i64* %18
%288 = icmp eq i64 %287, -1
br i1 %288, label %289, label %290
289: ; preds = %286
br label %153
290: ; preds = %286
%291 = 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 %292
292: ; preds = %299, %290
%293 = load i64, i64* %17
%294 = load i64, i64* %16
%295 = icmp slt i64 %293, %294
br i1 %295, label %296, label %302
296: ; preds = %292
%297 = load i64, i64* %17
%298 = getelementptr inbounds [2000 x float], [2000 x float]* %14, i64 0, i64 %297
store float 0.000000e+00, float* %298
br label %299
299: ; preds = %296
%300 = load i64, i64* %17
%301 = add nsw i64 %300, 1
store i64 %301, i64* %17
br label %292
302: ; preds = %292
store i64 0, i64* %18
br label %303
303: ; preds = %337, %302
%304 = load i64, i64* %18
%305 = load i64, i64* %21
%306 = icmp slt i64 %304, %305
br i1 %306, label %307, label %340
307: ; preds = %303
%308 = load i64, i64* %18
%309 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 %308
%310 = load i64, i64* %309
%311 = icmp eq i64 %310, -1
br i1 %311, label %312, label %313
312: ; preds = %307
br label %337
313: ; preds = %307
store i64 0, i64* %17
br label %314
314: ; preds = %333, %313
%315 = load i64, i64* %17
%316 = load i64, i64* %16
%317 = icmp slt i64 %315, %316
br i1 %317, label %318, label %336
318: ; preds = %314
%319 = load float*, float** %24
%320 = load i64, i64* %17
%321 = load i64, i64* %18
%322 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 %321
%323 = load i64, i64* %322
%324 = load i64, i64* %16
%325 = mul nsw i64 %323, %324
%326 = add nsw i64 %320, %325
%327 = getelementptr inbounds float, float* %319, i64 %326
%328 = load float, float* %327
%329 = load i64, i64* %17
%330 = getelementptr inbounds [2000 x float], [2000 x float]* %14, i64 0, i64 %329
%331 = load float, float* %330
%332 = fadd float %331, %328
store float %332, float* %330
br label %333
333: ; preds = %318
%334 = load i64, i64* %17
%335 = add nsw i64 %334, 1
store i64 %335, i64* %17
br label %314
336: ; preds = %314
br label %337
337: ; preds = %336, %312
%338 = load i64, i64* %18
%339 = add nsw i64 %338, 1
store i64 %339, i64* %18
br label %303
340: ; preds = %303
store float 0.000000e+00, float* %12
store i64 0, i64* %17
br label %341
341: ; preds = %354, %340
%342 = load i64, i64* %17
%343 = load i64, i64* %16
%344 = icmp slt i64 %342, %343
br i1 %344, label %345, label %357
345: ; preds = %341
%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 i64, i64* %17
%350 = getelementptr inbounds [2000 x float], [2000 x float]* %14, i64 0, i64 %349
%351 = load float, float* %350
%352 = load float, float* %12
%353 = call float @llvm.fmuladd.f32(float %348, float %351, float %352)
store float %353, float* %12
br label %354
354: ; preds = %345
%355 = load i64, i64* %17
%356 = add nsw i64 %355, 1
store i64 %356, i64* %17
br label %341
357: ; preds = %341
%358 = load float, float* %12
%359 = call float @sqrt(float %358)
store float %359, float* %12
store i64 0, i64* %17
br label %360
360: ; preds = %370, %357
%361 = load i64, i64* %17
%362 = load i64, i64* %16
%363 = icmp slt i64 %361, %362
br i1 %363, label %364, label %373
364: ; preds = %360
%365 = load float, float* %12
%366 = load i64, i64* %17
%367 = getelementptr inbounds [2000 x float], [2000 x float]* %14, i64 0, i64 %366
%368 = load float, float* %367
%369 = fdiv float %368, %365
store float %369, float* %367
br label %370
370: ; preds = %364
%371 = load i64, i64* %17
%372 = add nsw i64 %371, 1
store i64 %372, i64* %17
br label %360
373: ; preds = %360
store i64 0, i64* %17
br label %374
374: ; preds = %380, %373
%375 = load i64, i64* %17
%376 = icmp slt i64 %375, 40
br i1 %376, label %377, label %383
377: ; preds = %374
%378 = load i64, i64* %17
%379 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %378
store float 0.000000e+00, float* %379
br label %380
380: ; preds = %377
%381 = load i64, i64* %17
%382 = add nsw i64 %381, 1
store i64 %382, i64* %17
br label %374
383: ; preds = %374
store i64 0, i64* %17
br label %384
384: ; preds = %391, %383
%385 = load i64, i64* %17
%386 = icmp slt i64 %385, 40
br i1 %386, label %387, label %394
387: ; preds = %384
%388 = load i64, i64* %17
%389 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %8, i64 0, i64 %388
%390 = getelementptr inbounds [2000 x i8], [2000 x i8]* %389, i64 0, i64 0
store i8 0, i8* %390
br label %391
391: ; preds = %387
%392 = load i64, i64* %17
%393 = add nsw i64 %392, 1
store i64 %393, i64* %17
br label %384
394: ; preds = %384
store i64 0, i64* %19
br label %395
395: ; preds = %491, %394
%396 = load i64, i64* %19
%397 = load i64, i64* %15
%398 = icmp slt i64 %396, %397
br i1 %398, label %399, label %494
399: ; preds = %395
store i64 0, i64* %17
store i64 0, i64* %18
br label %400
400: ; preds = %412, %399
%401 = load i64, i64* %18
%402 = load i64, i64* %21
%403 = icmp slt i64 %401, %402
br i1 %403, label %404, label %415
404: ; preds = %400
%405 = load i64, i64* %18
%406 = getelementptr inbounds [100 x i64], [100 x i64]* %22, i64 0, i64 %405
%407 = load i64, i64* %406
%408 = load i64, i64* %19
%409 = icmp eq i64 %407, %408
br i1 %409, label %410, label %411
410: ; preds = %404
store i64 1, i64* %17
br label %411
411: ; preds = %410, %404
br label %412
412: ; preds = %411
%413 = load i64, i64* %18
%414 = add nsw i64 %413, 1
store i64 %414, i64* %18
br label %400
415: ; preds = %400
%416 = load i64, i64* %17
%417 = icmp eq i64 %416, 1
br i1 %417, label %418, label %419
418: ; preds = %415
br label %491
419: ; preds = %415
store float 0.000000e+00, float* %11
store i64 0, i64* %17
br label %420
420: ; preds = %438, %419
%421 = load i64, i64* %17
%422 = load i64, i64* %16
%423 = icmp slt i64 %421, %422
br i1 %423, label %424, label %441
424: ; preds = %420
%425 = load i64, i64* %17
%426 = getelementptr inbounds [2000 x float], [2000 x float]* %14, i64 0, i64 %425
%427 = load float, float* %426
%428 = load float*, float** %24
%429 = load i64, i64* %17
%430 = load i64, i64* %19
%431 = load i64, i64* %16
%432 = mul nsw i64 %430, %431
%433 = add nsw i64 %429, %432
%434 = getelementptr inbounds float, float* %428, i64 %433
%435 = load float, float* %434
%436 = load float, float* %11
%437 = call float @llvm.fmuladd.f32(float %427, float %435, float %436)
store float %437, float* %11
br label %438
438: ; preds = %424
%439 = load i64, i64* %17
%440 = add nsw i64 %439, 1
store i64 %440, i64* %17
br label %420
441: ; preds = %420
store i64 0, i64* %17
br label %442
442: ; preds = %487, %441
%443 = load i64, i64* %17
%444 = icmp slt i64 %443, 40
br i1 %444, label %445, label %490
445: ; preds = %442
%446 = load float, float* %11
%447 = load i64, i64* %17
%448 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %447
%449 = load float, float* %448
%450 = fcmp ogt float %446, %449
br i1 %450, label %451, label %486
451: ; preds = %445
store i64 39, i64* %20
br label %452
452: ; preds = %471, %451
%453 = load i64, i64* %20
%454 = load i64, i64* %17
%455 = icmp sgt i64 %453, %454
br i1 %455, label %456, label %474
456: ; preds = %452
%457 = load i64, i64* %20
%458 = sub nsw i64 %457, 1
%459 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %458
%460 = load float, float* %459
%461 = load i64, i64* %20
%462 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %461
store float %460, float* %462
%463 = load i64, i64* %20
%464 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %8, i64 0, i64 %463
%465 = getelementptr inbounds [2000 x i8], [2000 x i8]* %464, i64 0, i64 0
%466 = load i64, i64* %20
%467 = sub nsw i64 %466, 1
%468 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %8, i64 0, i64 %467
%469 = getelementptr inbounds [2000 x i8], [2000 x i8]* %468, i64 0, i64 0
%470 = call i32 @strcpy(i8* %465, i8* %469)
br label %471
471: ; preds = %456
%472 = load i64, i64* %20
%473 = add nsw i64 %472, -1
store i64 %473, i64* %20
br label %452
474: ; preds = %452
%475 = load float, float* %11
%476 = load i64, i64* %17
%477 = getelementptr inbounds [40 x float], [40 x float]* %13, i64 0, i64 %476
store float %475, float* %477
%478 = load i64, i64* %17
%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 i8*, i8** %25
%482 = load i64, i64* %19
%483 = mul nsw i64 %482, 50
%484 = getelementptr inbounds i8, i8* %481, i64 %483
%485 = call i32 @strcpy(i8* %480, i8* %484)
br label %490
486: ; preds = %445
br label %487
487: ; preds = %486
%488 = load i64, i64* %17
%489 = add nsw i64 %488, 1
store i64 %489, i64* %17
br label %442
490: ; preds = %474, %442
br label %491
491: ; preds = %490, %418
%492 = load i64, i64* %19
%493 = add nsw i64 %492, 1
store i64 %493, i64* %19
br label %395
494: ; preds = %395
store i64 0, i64* %17
br label %495
495: ; preds = %507, %494
%496 = load i64, i64* %17
%497 = icmp slt i64 %496, 40
br i1 %497, label %498, label %510
498: ; preds = %495
%499 = load i64, i64* %17
%500 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %8, i64 0, i64 %499
%501 = getelementptr inbounds [2000 x i8], [2000 x i8]* %500, i64 0, i64 0
%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 = fpext float %504 to double
%506 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0), i8* %501, double %505)
br label %507
507: ; preds = %498
%508 = load i64, i64* %17
%509 = add nsw i64 %508, 1
store i64 %509, i64* %17
br label %495
510: ; preds = %495
br label %153
511: ; preds = %199
store i32 0, i32* %3
br label %512
512: ; preds = %511, %60, %40, %28
%513 = load i32, i32* %3
ret i32 %513
}

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 = [41 x i8] c"Enter word or sentence (EXIT to break): \00"
@stdin = global i32 0
@.str.7 = [5 x i8] c"EXIT\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 Cosine 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 = [83 x i8] c"Usage: ./distance <FILE>\0Awhere FILE contains word projections in the BINARY FORMAT\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [2000 x i8]
%4 = alloca [40 x [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 = bitcast [2000 x float]* %9 to i8*
%11 = alloca i64
%12 = alloca i64
%13 = alloca [100 x i64]
%14 = alloca i8
%15 = getelementptr inbounds [2000 x i8], [2000 x i8]* %3, i64 0, i64 0
%16 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 0, i64 0
%17 = getelementptr inbounds [2000 x i8], [2000 x i8]* %5, i64 0, i64 0
%18 = getelementptr inbounds [100 x [2000 x i8]], [100 x [2000 x i8]]* %6, i64 0, i64 0, i64 0
%19 = bitcast i64* %11 to i8*
%20 = bitcast i64* %12 to i8*
%21 = bitcast [100 x i64]* %13 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 ([83 x i8], [83 x i8]* @str.14, i64 0, i64 0))
br label %665
25: ; preds = %2
%26 = getelementptr inbounds i8*, i8** %1, i64 1
%27 = load i8*, i8** %26
%28 = call i32 @strcpy(i8* %17, i8* %27)
%29 = call i32* @fopen(i8* %17, 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.13, i64 0, i64 0))
br label %665
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* %11)
%35 = call i32 (i32*, i8*, ...) @fscanf(i32* %29, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i64* %12)
%36 = load i64, i64* %11
%37 = mul nsw i64 %36, 50
%38 = call i64 @malloc(i64 %37)
%39 = inttoptr i64 %38 to i8*
%40 = load i64, i64* %11
%41 = load i64, i64* %12
%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* %11
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* %12
%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 %665
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* %14)
%61 = load i64, i64* %12
%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* %12
%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* %12
%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* %11
%187 = icmp slt i64 %185, %186
br i1 %187, label %56, label %188
188: ; preds = %184, %48
%189 = call i32 @fclose(i32* %29)
br label %190
190: ; preds = %263, %188
br label %191
191: ; preds = %191, %190
%192 = phi i64 [ 0, %190 ], [ %202, %191 ]
%193 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %192, i64 0
store i8 0, i8* %193
%194 = add nuw nsw i64 %192, 1
%195 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %194, i64 0
store i8 0, i8* %195
%196 = add nuw nsw i64 %192, 2
%197 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %196, i64 0
store i8 0, i8* %197
%198 = add nuw nsw i64 %192, 3
%199 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %198, i64 0
store i8 0, i8* %199
%200 = add nuw nsw i64 %192, 4
%201 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %200, i64 0
store i8 0, i8* %201
%202 = add nuw nsw i64 %192, 5
%203 = icmp eq i64 %202, 40
br i1 %203, label %204, label %191
204: ; preds = %191
%205 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.6, i64 0, i64 0))
br label %206
206: ; preds = %206, %204
%207 = phi i64 [ 0, %204 ], [ %214, %206 ]
%208 = load i32, i32* @stdin
%209 = call signext i8 @fgetc(i32 %208)
%210 = getelementptr inbounds [2000 x i8], [2000 x i8]* %3, i64 0, i64 %207
store i8 %209, i8* %210
%211 = icmp eq i8 %209, 10
%212 = icmp ugt i64 %207, 1998
%213 = select i1 %211, i1 true, i1 %212
%214 = add nuw nsw i64 %207, 1
br i1 %213, label %215, label %206
215: ; preds = %206
%216 = getelementptr inbounds [2000 x i8], [2000 x i8]* %3, i64 0, i64 %207
store i8 0, i8* %216
%217 = call i32 @bcmp(i8* dereferenceable(5) %15, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0), i64 5)
%218 = icmp eq i32 %217, 0
br i1 %218, label %665, label %219
219: ; preds = %215, %233
%220 = phi i64 [ %235, %233 ], [ 0, %215 ]
%221 = phi i64 [ %234, %233 ], [ 0, %215 ]
br label %222
222: ; preds = %219, %222
%223 = phi i64 [ %228, %222 ], [ 0, %219 ]
%224 = phi i64 [ %229, %222 ], [ %220, %219 ]
%225 = getelementptr inbounds [2000 x i8], [2000 x i8]* %3, i64 0, i64 %224
%226 = load i8, i8* %225
%227 = getelementptr inbounds [100 x [2000 x i8]], [100 x [2000 x i8]]* %6, i64 0, i64 %221, i64 %223
store i8 %226, i8* %227
%228 = add nuw nsw i64 %223, 1
%229 = add nsw i64 %224, 1
%230 = getelementptr inbounds [100 x [2000 x i8]], [100 x [2000 x i8]]* %6, i64 0, i64 %221, i64 %228
store i8 0, i8* %230
%231 = getelementptr inbounds [2000 x i8], [2000 x i8]* %3, i64 0, i64 %229
%232 = load i8, i8* %231
switch i8 %232, label %222 [
i8 0, label %239
i8 32, label %233
]
233: ; preds = %222
%234 = add nuw nsw i64 %221, 1
%235 = add nsw i64 %224, 2
br label %219
236: ; preds = %254
%237 = add nuw i64 %240, 1
%238 = icmp eq i64 %240, %221
br i1 %238, label %264, label %239
239: ; preds = %222, %236
%240 = phi i64 [ %237, %236 ], [ 0, %222 ]
%241 = load i64, i64* %11
%242 = icmp sgt i64 %241, 0
br i1 %242, label %243, label %254
243: ; preds = %239
%244 = getelementptr inbounds [100 x [2000 x i8]], [100 x [2000 x i8]]* %6, i64 0, i64 %240, i64 0
br label %245
245: ; preds = %243, %251
%246 = phi i64 [ 0, %243 ], [ %252, %251 ]
%247 = mul nuw nsw i64 %246, 50
%248 = getelementptr inbounds i8, i8* %39, i64 %247
%249 = call i32 @strcmp(i8* dereferenceable(1) %248, i8* %244)
%250 = icmp eq i32 %249, 0
br i1 %250, label %254, label %251
251: ; preds = %245
%252 = add nuw nsw i64 %246, 1
%253 = icmp eq i64 %252, %241
br i1 %253, label %254, label %245
254: ; preds = %251, %245, %239
%255 = phi i64 [ 0, %239 ], [ %246, %245 ], [ %241, %251 ]
%256 = icmp eq i64 %255, %241
%257 = select i1 %256, i64 -1, i64 %255
%258 = getelementptr inbounds [100 x i64], [100 x i64]* %13, i64 0, i64 %240
store i64 %257, i64* %258
%259 = getelementptr inbounds [100 x [2000 x i8]], [100 x [2000 x i8]]* %6, i64 0, i64 %240, i64 0
%260 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.8, i64 0, i64 0), i8* %259, i64 %257)
br i1 %256, label %261, label %236
261: ; preds = %254
%262 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str.12, i64 0, i64 0))
br label %263
263: ; preds = %656, %261, %264
br label %190
264: ; preds = %236
%265 = icmp eq i64 %255, -1
br i1 %265, label %263, label %266
266: ; preds = %264
%267 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([147 x i8], [147 x i8]* @str, i64 0, i64 0))
%268 = load i64, i64* %12
%269 = icmp sgt i64 %268, 0
br i1 %269, label %270, label %272
270: ; preds = %266
%271 = shl nuw i64 %268, 2
br label %272
272: ; preds = %266, %270
%273 = icmp slt i64 %268, 1
%274 = add i64 %268, -8
%275 = lshr i64 %274, 3
%276 = add nuw nsw i64 %275, 1
%277 = icmp ult i64 %268, 8
%278 = and i64 %268, -8
%279 = and i64 %276, 1
%280 = icmp ult i64 %274, 8
%281 = and i64 %276, 4611686018427387902
%282 = icmp eq i64 %279, 0
%283 = icmp eq i64 %268, %278
br label %291
284: ; preds = %374
br i1 %269, label %285, label %414
285: ; preds = %284
%286 = add i64 %268, -1
%287 = and i64 %268, 3
%288 = icmp ult i64 %286, 3
br i1 %288, label %399, label %289
289: ; preds = %285
%290 = and i64 %268, -4
br label %377
291: ; preds = %272, %374
%292 = phi i64 [ 0, %272 ], [ %375, %374 ]
%293 = getelementptr inbounds [100 x i64], [100 x i64]* %13, i64 0, i64 %292
%294 = load i64, i64* %293
%295 = icmp eq i64 %294, -1
%296 = select i1 %295, i1 true, i1 %273
br i1 %296, label %374, label %297
297: ; preds = %291
%298 = mul nsw i64 %294, %268
br i1 %277, label %362, label %299
299: ; preds = %297
br i1 %280, label %341, label %300
300: ; preds = %299, %300
%301 = phi i64 [ %338, %300 ], [ 0, %299 ]
%302 = phi i64 [ %339, %300 ], [ 0, %299 ]
%303 = add nsw i64 %301, %298
%304 = getelementptr inbounds float, float* %45, i64 %303
%305 = bitcast float* %304 to <4 x float>*
%306 = load <4 x float>, <4 x float>* %305
%307 = getelementptr inbounds float, float* %304, i64 4
%308 = bitcast float* %307 to <4 x float>*
%309 = load <4 x float>, <4 x float>* %308
%310 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %301
%311 = bitcast float* %310 to <4 x float>*
%312 = load <4 x float>, <4 x float>* %311
%313 = getelementptr inbounds float, float* %310, i64 4
%314 = bitcast float* %313 to <4 x float>*
%315 = load <4 x float>, <4 x float>* %314
%316 = fadd <4 x float> %306, %312
%317 = fadd <4 x float> %309, %315
%318 = bitcast float* %310 to <4 x float>*
store <4 x float> %316, <4 x float>* %318
%319 = bitcast float* %313 to <4 x float>*
store <4 x float> %317, <4 x float>* %319
%320 = or i64 %301, 8
%321 = add nsw i64 %320, %298
%322 = getelementptr inbounds float, float* %45, i64 %321
%323 = bitcast float* %322 to <4 x float>*
%324 = load <4 x float>, <4 x float>* %323
%325 = getelementptr inbounds float, float* %322, i64 4
%326 = bitcast float* %325 to <4 x float>*
%327 = load <4 x float>, <4 x float>* %326
%328 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %320
%329 = bitcast float* %328 to <4 x float>*
%330 = load <4 x float>, <4 x float>* %329
%331 = getelementptr inbounds float, float* %328, i64 4
%332 = bitcast float* %331 to <4 x float>*
%333 = load <4 x float>, <4 x float>* %332
%334 = fadd <4 x float> %324, %330
%335 = fadd <4 x float> %327, %333
%336 = bitcast float* %328 to <4 x float>*
store <4 x float> %334, <4 x float>* %336
%337 = bitcast float* %331 to <4 x float>*
store <4 x float> %335, <4 x float>* %337
%338 = add nuw i64 %301, 16
%339 = add i64 %302, 2
%340 = icmp eq i64 %339, %281
br i1 %340, label %341, label %300
341: ; preds = %300, %299
%342 = phi i64 [ 0, %299 ], [ %338, %300 ]
br i1 %282, label %361, label %343
343: ; preds = %341
%344 = add nsw i64 %342, %298
%345 = getelementptr inbounds float, float* %45, i64 %344
%346 = bitcast float* %345 to <4 x float>*
%347 = load <4 x float>, <4 x float>* %346
%348 = getelementptr inbounds float, float* %345, i64 4
%349 = bitcast float* %348 to <4 x float>*
%350 = load <4 x float>, <4 x float>* %349
%351 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %342
%352 = bitcast float* %351 to <4 x float>*
%353 = load <4 x float>, <4 x float>* %352
%354 = getelementptr inbounds float, float* %351, i64 4
%355 = bitcast float* %354 to <4 x float>*
%356 = load <4 x float>, <4 x float>* %355
%357 = fadd <4 x float> %347, %353
%358 = fadd <4 x float> %350, %356
%359 = bitcast float* %351 to <4 x float>*
store <4 x float> %357, <4 x float>* %359
%360 = bitcast float* %354 to <4 x float>*
store <4 x float> %358, <4 x float>* %360
br label %361
361: ; preds = %341, %343
br i1 %283, label %374, label %362
362: ; preds = %297, %361
%363 = phi i64 [ 0, %297 ], [ %278, %361 ]
br label %364
364: ; preds = %362, %364
%365 = phi i64 [ %372, %364 ], [ %363, %362 ]
%366 = add nsw i64 %365, %298
%367 = getelementptr inbounds float, float* %45, i64 %366
%368 = load float, float* %367
%369 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %365
%370 = load float, float* %369
%371 = fadd float %368, %370
store float %371, float* %369
%372 = add nuw nsw i64 %365, 1
%373 = icmp eq i64 %372, %268
br i1 %373, label %374, label %364
374: ; preds = %364, %361, %291
%375 = add nuw i64 %292, 1
%376 = icmp eq i64 %292, %221
br i1 %376, label %284, label %291
377: ; preds = %377, %289
%378 = phi i64 [ 0, %289 ], [ %396, %377 ]
%379 = phi float [ 0.000000e+00, %289 ], [ %395, %377 ]
%380 = phi i64 [ 0, %289 ], [ %397, %377 ]
%381 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %378
%382 = load float, float* %381
%383 = call float @llvm.fmuladd.f32(float %382, float %382, float %379)
%384 = or i64 %378, 1
%385 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %384
%386 = load float, float* %385
%387 = call float @llvm.fmuladd.f32(float %386, float %386, float %383)
%388 = or i64 %378, 2
%389 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %388
%390 = load float, float* %389
%391 = call float @llvm.fmuladd.f32(float %390, float %390, float %387)
%392 = or i64 %378, 3
%393 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %392
%394 = load float, float* %393
%395 = call float @llvm.fmuladd.f32(float %394, float %394, float %391)
%396 = add nuw nsw i64 %378, 4
%397 = add i64 %380, 4
%398 = icmp eq i64 %397, %290
br i1 %398, label %399, label %377
399: ; preds = %377, %285
%400 = phi float [ undef, %285 ], [ %395, %377 ]
%401 = phi i64 [ 0, %285 ], [ %396, %377 ]
%402 = phi float [ 0.000000e+00, %285 ], [ %395, %377 ]
%403 = icmp eq i64 %287, 0
br i1 %403, label %414, label %404
404: ; preds = %399, %404
%405 = phi i64 [ %411, %404 ], [ %401, %399 ]
%406 = phi float [ %410, %404 ], [ %402, %399 ]
%407 = phi i64 [ %412, %404 ], [ 0, %399 ]
%408 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %405
%409 = load float, float* %408
%410 = call float @llvm.fmuladd.f32(float %409, float %409, float %406)
%411 = add nuw nsw i64 %405, 1
%412 = add i64 %407, 1
%413 = icmp eq i64 %412, %287
br i1 %413, label %414, label %404
414: ; preds = %399, %404, %284
%415 = phi float [ 0.000000e+00, %284 ], [ %400, %399 ], [ %410, %404 ]
%416 = call float @sqrt(float %415)
%417 = load i64, i64* %12
%418 = icmp sgt i64 %417, 0
br i1 %418, label %419, label %462
419: ; preds = %414
%420 = icmp ult i64 %417, 4
br i1 %420, label %460, label %421
421: ; preds = %419
%422 = and i64 %417, -4
%423 = insertelement <4 x float> poison, float %416, i64 0
%424 = shufflevector <4 x float> %423, <4 x float> poison, <4 x i32> zeroinitializer
%425 = add i64 %422, -4
%426 = lshr exact i64 %425, 2
%427 = add nuw nsw i64 %426, 1
%428 = and i64 %427, 1
%429 = icmp eq i64 %425, 0
br i1 %429, label %449, label %430
430: ; preds = %421
%431 = and i64 %427, 9223372036854775806
br label %432
432: ; preds = %432, %430
%433 = phi i64 [ 0, %430 ], [ %446, %432 ]
%434 = phi i64 [ 0, %430 ], [ %447, %432 ]
%435 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %433
%436 = bitcast float* %435 to <4 x float>*
%437 = load <4 x float>, <4 x float>* %436
%438 = fdiv <4 x float> %437, %424
%439 = bitcast float* %435 to <4 x float>*
store <4 x float> %438, <4 x float>* %439
%440 = or i64 %433, 4
%441 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %440
%442 = bitcast float* %441 to <4 x float>*
%443 = load <4 x float>, <4 x float>* %442
%444 = fdiv <4 x float> %443, %424
%445 = bitcast float* %441 to <4 x float>*
store <4 x float> %444, <4 x float>* %445
%446 = add nuw i64 %433, 8
%447 = add i64 %434, 2
%448 = icmp eq i64 %447, %431
br i1 %448, label %449, label %432
449: ; preds = %432, %421
%450 = phi i64 [ 0, %421 ], [ %446, %432 ]
%451 = icmp eq i64 %428, 0
br i1 %451, label %458, label %452
452: ; preds = %449
%453 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %450
%454 = bitcast float* %453 to <4 x float>*
%455 = load <4 x float>, <4 x float>* %454
%456 = fdiv <4 x float> %455, %424
%457 = bitcast float* %453 to <4 x float>*
store <4 x float> %456, <4 x float>* %457
br label %458
458: ; preds = %449, %452
%459 = icmp eq i64 %417, %422
br i1 %459, label %462, label %460
460: ; preds = %419, %458
%461 = phi i64 [ 0, %419 ], [ %422, %458 ]
br label %463
462: ; preds = %463, %458, %414
br label %479
463: ; preds = %460, %463
%464 = phi i64 [ %468, %463 ], [ %461, %460 ]
%465 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %464
%466 = load float, float* %465
%467 = fdiv float %466, %416
store float %467, float* %465
%468 = add nuw nsw i64 %464, 1
%469 = icmp eq i64 %468, %417
br i1 %469, label %462, label %463
470: ; preds = %479
%471 = load i64, i64* %11
%472 = icmp sgt i64 %471, 0
br i1 %472, label %473, label %655
473: ; preds = %470
%474 = add nuw i64 %221, 1
%475 = and i64 %474, 3
%476 = icmp ult i64 %221, 3
%477 = and i64 %474, -4
%478 = icmp eq i64 %475, 0
br label %492
479: ; preds = %479, %462
%480 = phi i64 [ 0, %462 ], [ %490, %479 ]
%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 %480, 1
%483 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %482, i64 0
store i8 0, i8* %483
%484 = add nuw nsw i64 %480, 2
%485 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %484, i64 0
store i8 0, i8* %485
%486 = add nuw nsw i64 %480, 3
%487 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %486, i64 0
store i8 0, i8* %487
%488 = add nuw nsw i64 %480, 4
%489 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %488, i64 0
store i8 0, i8* %489
%490 = add nuw nsw i64 %480, 5
%491 = icmp eq i64 %490, 40
br i1 %491, label %470, label %479
492: ; preds = %473, %651
%493 = phi i64 [ %652, %651 ], [ %471, %473 ]
%494 = phi i64 [ %653, %651 ], [ 0, %473 ]
br i1 %476, label %521, label %495
495: ; preds = %492, %495
%496 = phi i64 [ %518, %495 ], [ 0, %492 ]
%497 = phi i64 [ %517, %495 ], [ 0, %492 ]
%498 = phi i64 [ %519, %495 ], [ 0, %492 ]
%499 = getelementptr inbounds [100 x i64], [100 x i64]* %13, i64 0, i64 %496
%500 = load i64, i64* %499
%501 = icmp eq i64 %500, %494
%502 = or i64 %496, 1
%503 = getelementptr inbounds [100 x i64], [100 x i64]* %13, i64 0, i64 %502
%504 = load i64, i64* %503
%505 = icmp eq i64 %504, %494
%506 = or i64 %496, 2
%507 = getelementptr inbounds [100 x i64], [100 x i64]* %13, i64 0, i64 %506
%508 = load i64, i64* %507
%509 = icmp eq i64 %508, %494
%510 = or i64 %496, 3
%511 = getelementptr inbounds [100 x i64], [100 x i64]* %13, i64 0, i64 %510
%512 = load i64, i64* %511
%513 = icmp eq i64 %512, %494
%514 = select i1 %513, i1 true, i1 %509
%515 = select i1 %514, i1 true, i1 %505
%516 = select i1 %515, i1 true, i1 %501
%517 = select i1 %516, i64 1, i64 %497
%518 = add nuw i64 %496, 4
%519 = add i64 %498, 4
%520 = icmp eq i64 %519, %477
br i1 %520, label %521, label %495
521: ; preds = %495, %492
%522 = phi i64 [ undef, %492 ], [ %517, %495 ]
%523 = phi i64 [ 0, %492 ], [ %518, %495 ]
%524 = phi i64 [ 0, %492 ], [ %517, %495 ]
br i1 %478, label %536, label %525
525: ; preds = %521, %525
%526 = phi i64 [ %533, %525 ], [ %523, %521 ]
%527 = phi i64 [ %532, %525 ], [ %524, %521 ]
%528 = phi i64 [ %534, %525 ], [ 0, %521 ]
%529 = getelementptr inbounds [100 x i64], [100 x i64]* %13, i64 0, i64 %526
%530 = load i64, i64* %529
%531 = icmp eq i64 %530, %494
%532 = select i1 %531, i64 1, i64 %527
%533 = add nuw i64 %526, 1
%534 = add i64 %528, 1
%535 = icmp eq i64 %534, %475
br i1 %535, label %536, label %525
536: ; preds = %525, %521
%537 = phi i64 [ %522, %521 ], [ %532, %525 ]
%538 = icmp eq i64 %537, 1
br i1 %538, label %651, label %539
539: ; preds = %536
%540 = load i64, i64* %12
%541 = icmp sgt i64 %540, 0
br i1 %541, label %542, label %567
542: ; preds = %539
%543 = mul nsw i64 %540, %494
%544 = add i64 %540, -1
%545 = and i64 %540, 3
%546 = icmp ult i64 %544, 3
br i1 %546, label %549, label %547
547: ; preds = %542
%548 = and i64 %540, -4
br label %569
549: ; preds = %569, %542
%550 = phi float [ undef, %542 ], [ %599, %569 ]
%551 = phi float [ 0.000000e+00, %542 ], [ %599, %569 ]
%552 = phi i64 [ 0, %542 ], [ %600, %569 ]
%553 = icmp eq i64 %545, 0
br i1 %553, label %567, label %554
554: ; preds = %549, %554
%555 = phi float [ %563, %554 ], [ %551, %549 ]
%556 = phi i64 [ %564, %554 ], [ %552, %549 ]
%557 = phi i64 [ %565, %554 ], [ 0, %549 ]
%558 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %556
%559 = load float, float* %558
%560 = add nsw i64 %543, %556
%561 = getelementptr inbounds float, float* %45, i64 %560
%562 = load float, float* %561
%563 = call float @llvm.fmuladd.f32(float %559, float %562, float %555)
%564 = add nuw nsw i64 %556, 1
%565 = add i64 %557, 1
%566 = icmp eq i64 %565, %545
br i1 %566, label %567, label %554
567: ; preds = %549, %554, %539
%568 = phi float [ 0.000000e+00, %539 ], [ %550, %549 ], [ %563, %554 ]
br label %603
569: ; preds = %569, %547
%570 = phi float [ 0.000000e+00, %547 ], [ %599, %569 ]
%571 = phi i64 [ 0, %547 ], [ %600, %569 ]
%572 = phi i64 [ 0, %547 ], [ %601, %569 ]
%573 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %571
%574 = load float, float* %573
%575 = add nsw i64 %543, %571
%576 = getelementptr inbounds float, float* %45, i64 %575
%577 = load float, float* %576
%578 = call float @llvm.fmuladd.f32(float %574, float %577, float %570)
%579 = or i64 %571, 1
%580 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %579
%581 = load float, float* %580
%582 = add nsw i64 %543, %579
%583 = getelementptr inbounds float, float* %45, i64 %582
%584 = load float, float* %583
%585 = call float @llvm.fmuladd.f32(float %581, float %584, float %578)
%586 = or i64 %571, 2
%587 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %586
%588 = load float, float* %587
%589 = add nsw i64 %543, %586
%590 = getelementptr inbounds float, float* %45, i64 %589
%591 = load float, float* %590
%592 = call float @llvm.fmuladd.f32(float %588, float %591, float %585)
%593 = or i64 %571, 3
%594 = getelementptr inbounds [2000 x float], [2000 x float]* %9, i64 0, i64 %593
%595 = load float, float* %594
%596 = add nsw i64 %543, %593
%597 = getelementptr inbounds float, float* %45, i64 %596
%598 = load float, float* %597
%599 = call float @llvm.fmuladd.f32(float %595, float %598, float %592)
%600 = add nuw nsw i64 %571, 4
%601 = add i64 %572, 4
%602 = icmp eq i64 %601, %548
br i1 %602, label %549, label %569
603: ; preds = %648, %567
%604 = phi i64 [ 0, %567 ], [ %649, %648 ]
%605 = getelementptr inbounds [40 x float], [40 x float]* %7, i64 0, i64 %604
%606 = load float, float* %605
%607 = fcmp ogt float %568, %606
br i1 %607, label %608, label %628
608: ; preds = %643, %638, %633, %628, %603
%609 = phi i64 [ %604, %603 ], [ %629, %628 ], [ %634, %633 ], [ %639, %638 ], [ %644, %643 ]
%610 = getelementptr inbounds [40 x float], [40 x float]* %7, i64 0, i64 %609
%611 = icmp ult i64 %609, 39
br i1 %611, label %612, label %622
612: ; preds = %608, %612
%613 = phi i64 [ %614, %612 ], [ 39, %608 ]
%614 = add nsw i64 %613, -1
%615 = getelementptr inbounds [40 x float], [40 x float]* %7, i64 0, i64 %614
%616 = load float, float* %615
%617 = getelementptr inbounds [40 x float], [40 x float]* %7, i64 0, i64 %613
store float %616, float* %617
%618 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %613, i64 0
%619 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %614, i64 0
%620 = call i32 @strcpy(i8* %618, i8* %619)
%621 = icmp ugt i64 %614, %609
br i1 %621, label %612, label %622
622: ; preds = %612, %608
store float %568, float* %610
%623 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %609, i64 0
%624 = mul nsw i64 %494, 50
%625 = getelementptr inbounds i8, i8* %39, i64 %624
%626 = call i32 @strcpy(i8* %623, i8* %625)
%627 = load i64, i64* %11
br label %651
628: ; preds = %603
%629 = add nuw nsw i64 %604, 1
%630 = getelementptr inbounds [40 x float], [40 x float]* %7, i64 0, i64 %629
%631 = load float, float* %630
%632 = fcmp ogt float %568, %631
br i1 %632, label %608, label %633
633: ; preds = %628
%634 = add nuw nsw i64 %604, 2
%635 = getelementptr inbounds [40 x float], [40 x float]* %7, i64 0, i64 %634
%636 = load float, float* %635
%637 = fcmp ogt float %568, %636
br i1 %637, label %608, label %638
638: ; preds = %633
%639 = add nuw nsw i64 %604, 3
%640 = getelementptr inbounds [40 x float], [40 x float]* %7, i64 0, i64 %639
%641 = load float, float* %640
%642 = fcmp ogt float %568, %641
br i1 %642, label %608, label %643
643: ; preds = %638
%644 = add nuw nsw i64 %604, 4
%645 = getelementptr inbounds [40 x float], [40 x float]* %7, i64 0, i64 %644
%646 = load float, float* %645
%647 = fcmp ogt float %568, %646
br i1 %647, label %608, label %648
648: ; preds = %643
%649 = add nuw nsw i64 %604, 5
%650 = icmp eq i64 %649, 40
br i1 %650, label %651, label %603
651: ; preds = %648, %622, %536
%652 = phi i64 [ %627, %622 ], [ %493, %536 ], [ %493, %648 ]
%653 = add nuw nsw i64 %494, 1
%654 = icmp slt i64 %653, %652
br i1 %654, label %492, label %655
655: ; preds = %651, %470
br label %656
656: ; preds = %655, %656
%657 = phi i64 [ %663, %656 ], [ 0, %655 ]
%658 = getelementptr inbounds [40 x [2000 x i8]], [40 x [2000 x i8]]* %4, i64 0, i64 %657, i64 0
%659 = getelementptr inbounds [40 x float], [40 x float]* %7, i64 0, i64 %657
%660 = load float, float* %659
%661 = fpext float %660 to double
%662 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0), i8* %658, double %661)
%663 = add nuw nsw i64 %657, 1
%664 = icmp eq i64 %663, 40
br i1 %664, label %263, label %656
665: ; preds = %215, %50, %31, %23
%666 = phi i32 [ 0, %23 ], [ -1, %31 ], [ -1, %50 ], [ 0, %215 ]
ret i32 %666
}