#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*/ exit(int /*<<< orphan*/);
float fabs(float);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ quicksort(float *, int /*<<< orphan*/, int);
int /*<<< orphan*/ sprintf(char *, char *, int);
float sqrt(float);
int strtol(char *, int /*<<< orphan*/ *, int);
int main(int argc, char *argv[]) {
  int thread_count;
  thread_count = strtol(argv[1], NULL, 10);
  int step;
#pragma omp parallel for num_threads(thread_count)
  for (step = 100000; step <= 500000; step = step + 100000) {
    int a, b, d;
    int e[6] = {0, 0, 0, 0, 0, 0};
    float esum;
    float f0, f1, f2;
    float x, y, z;
    float rx, ry, rz;
    float x_cut, y_cut, z_cut;
    float c[200];
    float xx, yy, zz, xy, yz, xz;
    char buf1[256], buf2[256];
    float Ni[13500 * 3];
    float Ti[13500 * 3];
    FILE *fin;
    FILE *pin;
    sprintf(buf1, "%d.cfg", step);
    if ((fin = fopen(buf1, "r")) == NULL)
      exit(0);
    fscanf(fin, "%*[^\n]%*c");
    fscanf(fin, "%*[^\n]%*c");
    fscanf(fin, "%*7c\n%*c%f%*[^\n]%*c", &xx);
    fscanf(fin, "%*[^\n]%*c");
    fscanf(fin, "%*[^\n]%*c");
    fscanf(fin, "%*7c\n%*c%f%*[^\n]%*c", &xy);
    fscanf(fin, "%*7c\n%*c%f%*[^\n]%*c", &yy);
    fscanf(fin, "%*[^\n]%*c");
    fscanf(fin, "%*7c\n%*c%f%*[^\n]%*c", &xz);
    fscanf(fin, "%*7c\n%*c%f%*[^\n]%*c", &yz);
    fscanf(fin, "%*7c\n%*c%f%*[^\n]%*c", &zz);
    for (a = 0; a < 4; a++)
      fscanf(fin, "%*[^\n]%*c");
    for (a = 0; a < 13500; a++) {
      fscanf(fin, "%f\n%f\n%f%*[^\n]%*c", &Ni[a * 3], &Ni[a * 3 + 1],
             &Ni[a * 3 + 2]);
    }
    for (a = 0; a < 2; a++)
      fscanf(fin, "%*c%*[^\n]%*c");
    for (a = 0; a < 13500; a++) {
      fscanf(fin, "%f\n%f\n%f%*[^\n]%*c", &Ti[a * 3], &Ti[a * 3 + 1],
             &Ti[a * 3 + 2]);
    }
    fclose(fin);
    x_cut = xx - 4.5;
    y_cut = yy - 4.5;
    z_cut = zz - 4.5;
    sprintf(buf2, "op_%d.txt", step);
    if ((pin = fopen(buf2, "w")) == NULL)
      exit(0);
    for (a = 0; a < 13500; a++) {
      d = 0;
      for (b = 0; b < 13500; b++) {
        rx = (Ti[b * 3] - Ni[a * 3]);
        ry = (Ti[b * 3 + 1] - Ni[a * 3 + 1]);
        rz = (Ti[b * 3 + 2] - Ni[a * 3 + 2]);
        x = fabs(rx * xx + ry * xy + rz * xz);
        if (x >= x_cut)
          x = xx - x;
        else if (x <= 4.5)
          x = x;
        else
          continue;
        y = fabs(ry * yy + rz * yz);
        if (y >= y_cut)
          y = yy - y;
        else if (y <= 4.5)
          y = y;
        else
          continue;
        z = fabs(rz * zz);
        if (z >= z_cut)
          z = zz - z;
        else if (z <= 4.5)
          z = z;
        else
          continue;
        c[d] = sqrt(x * x + y * y + z * z);
        d++;
      }
      quicksort(c, 0, d - 1);
      f0 = (c[0] + c[1] + c[6] + c[7]) / 2.0;
      f1 = (c[2] + c[5] + c[3] + c[4]) / 2.0;
      f2 = (f1 * (5.22 + 5.37) - f0 * (5.22 + 5.02)) / (5.22 * (5.02 - 5.37));
      if (f2 < -1.5) {
        f2 = -2.0;
        e[0]++;
      } else if (f2 >= -1.5 && f2 < -0.2) {
        f2 = -1.0;
        e[1]++;
      } else if (f2 >= -0.2 && f2 < 0.1) {
        f2 = 0.2;
        e[2]++;
      } else if (f2 >= 0.1 && f2 < 1.8115) {
        f2 = 1.0;
        e[3]++;
      } else if (f2 >= 1.8115 && f2 < 2.9) {
        f2 = 2.6133;
        e[4]++;
      } else {
        f2 = 3.5;
        e[5]++;
      }
      fprintf(pin, "%.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.4f\n", c[0], c[1],
              c[2], c[3], c[4], c[5], c[6], c[7], f2);
    }
    fprintf(pin, "\n");
    fprintf(pin, "\n");
    for (a = 0; a < 13500; a++) {
      d = 0;
      for (b = 0; b < 13500; b++) {
        rx = (Ni[b * 3] - Ti[a * 3]);
        ry = (Ni[b * 3 + 1] - Ti[a * 3 + 1]);
        rz = (Ni[b * 3 + 2] - Ti[a * 3 + 2]);
        if (x >= x_cut)
          x = xx - x;
        else if (x <= 4.5)
          x = x;
        else
          continue;
        y = fabs(ry * yy + rz * yz);
        if (y >= y_cut)
          y = yy - y;
        else if (y <= 4.5)
          y = y;
        else
          continue;
        z = fabs(rz * zz);
        if (z >= z_cut)
          z = zz - z;
        else if (z <= 4.5)
          z = z;
        else
          continue;
        c[d] = sqrt(x * x + y * y + z * z);
        d++;
      }
      quicksort(c, 0, d - 1);
      f0 = (c[0] + c[7] + c[1] + c[6]) / 2.0;
      f1 = (c[2] + c[5] + c[3] + c[4]) / 2.0;
      f2 = (f1 * (5.22 + 5.37) - f0 * (5.22 + 5.02)) / (5.22 * (5.02 - 5.37));
      if (f2 < -1.5) {
        f2 = -2.0;
        e[0]++;
      } else if (f2 >= -1.5 && f2 < -0.2) {
        f2 = -1.0;
        e[1]++;
      } else if (f2 >= -0.2 && f2 < 0.1) {
        f2 = 0.2;
        e[2]++;
      } else if (f2 >= 0.1 && f2 < 1.8115) {
        f2 = 1.0;
        e[3]++;
      } else if (f2 >= 1.8115 && f2 < 2.9) {
        f2 = 2.6133;
        e[4]++;
      } else {
        f2 = 3.5;
        e[5]++;
      }
      fprintf(pin, "%.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.4f\n", c[0], c[1],
              c[2], c[3], c[4], c[5], c[6], c[7], f2);
    }
    esum = (e[0] + e[1] + e[2] + e[3] + e[4] + e[5]) * 1.0;
    fprintf(pin, "B2: %.4f B19: %.4f B19': %.4f BCO: %.4f defect: %.4f\n",
            e[1] / esum, e[2] / esum, e[3] / esum, e[4] / esum,
            (e[0] + e[5]) / esum);
    fclose(pin);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4f780,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0xa,%edx
call   1090 <strtol@plt>
mov    %eax,-0x14(%rbp)
movl   $0x186a0,-0x18(%rbp)
cmpl   $0x7a120,-0x18(%rbp)
jg     213c <main+0xf8c>
lea    -0x40(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1050 <memset@plt>
lea    -0x4c0(%rbp),%rdi
mov    -0x18(%rbp),%edx
lea    0x1e59(%rip),%rsi
call   10c0 <sprintf@plt>
lea    -0x4c0(%rbp),%rdi
lea    0x1e4d(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x4f768(%rbp)
cmp    $0x0,%rax
jne    1247 <main+0x97>
xor    %edi,%edi
call   10d0 <exit@plt>
mov    -0x4f768(%rbp),%rdi
lea    0x1e4d(%rip),%rsi
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x4f768(%rbp),%rdi
lea    0x1e38(%rip),%rsi
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x4f768(%rbp),%rdi
lea    0x1dfa(%rip),%rsi
lea    -0x3a4(%rbp),%rdx
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x4f768(%rbp),%rdi
lea    0x1e07(%rip),%rsi
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x4f768(%rbp),%rdi
lea    0x1df2(%rip),%rsi
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x4f768(%rbp),%rdi
lea    0x1db4(%rip),%rsi
lea    -0x3b0(%rbp),%rdx
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x4f768(%rbp),%rdi
lea    0x1d98(%rip),%rsi
lea    -0x3a8(%rbp),%rdx
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x4f768(%rbp),%rdi
lea    0x1da5(%rip),%rsi
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x4f768(%rbp),%rdi
lea    0x1d67(%rip),%rsi
lea    -0x3b8(%rbp),%rdx
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x4f768(%rbp),%rdi
lea    0x1d4b(%rip),%rsi
lea    -0x3b4(%rbp),%rdx
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x4f768(%rbp),%rdi
lea    0x1d2f(%rip),%rsi
lea    -0x3ac(%rbp),%rdx
mov    $0x0,%al
call   1060 <fscanf@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x4,-0x1c(%rbp)
jge    138c <main+0x1dc>
mov    -0x4f768(%rbp),%rdi
lea    0x1d2b(%rip),%rsi
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    135f <main+0x1af>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x34bc,-0x1c(%rbp)
jge    1405 <main+0x255>
mov    -0x4f768(%rbp),%rdi
imul   $0x3,-0x1c(%rbp),%eax
cltq
lea    -0x27e90(%rbp),%rdx
shl    $0x2,%rax
add    %rax,%rdx
imul   $0x3,-0x1c(%rbp),%eax
add    $0x1,%eax
cltq
lea    -0x27e90(%rbp),%rcx
shl    $0x2,%rax
add    %rax,%rcx
imul   $0x3,-0x1c(%rbp),%eax
add    $0x2,%eax
cltq
lea    -0x27e90(%rbp),%r8
shl    $0x2,%rax
add    %rax,%r8
lea    0x1c9d(%rip),%rsi
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1393 <main+0x1e3>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jge    1439 <main+0x289>
mov    -0x4f768(%rbp),%rdi
lea    0x1c7b(%rip),%rsi
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    140c <main+0x25c>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x34bc,-0x1c(%rbp)
jge    14b2 <main+0x302>
mov    -0x4f768(%rbp),%rdi
imul   $0x3,-0x1c(%rbp),%eax
cltq
lea    -0x4f760(%rbp),%rdx
shl    $0x2,%rax
add    %rax,%rdx
imul   $0x3,-0x1c(%rbp),%eax
add    $0x1,%eax
cltq
lea    -0x4f760(%rbp),%rcx
shl    $0x2,%rax
add    %rax,%rcx
imul   $0x3,-0x1c(%rbp),%eax
add    $0x2,%eax
cltq
lea    -0x4f760(%rbp),%r8
shl    $0x2,%rax
add    %rax,%r8
lea    0x1bf0(%rip),%rsi
mov    $0x0,%al
call   1060 <fscanf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1440 <main+0x290>
mov    -0x4f768(%rbp),%rdi
call   1030 <fclose@plt>
movss  -0x3a4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1b2e(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x3a8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1b0d(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x3ac(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1aec(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
lea    -0x5c0(%rbp),%rdi
mov    -0x18(%rbp),%edx
lea    0x1b7a(%rip),%rsi
call   10c0 <sprintf@plt>
lea    -0x5c0(%rbp),%rdi
lea    0x1b71(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x4f770(%rbp)
cmp    $0x0,%rax
jne    1562 <main+0x3b2>
xor    %edi,%edi
call   10d0 <exit@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x34bc,-0x1c(%rbp)
jge    1b07 <main+0x957>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x34bc,-0x20(%rbp)
jge    17ef <main+0x63f>
imul   $0x3,-0x20(%rbp),%eax
cltq
movss  -0x4f760(%rbp,%rax,4),%xmm0
fb ff
imul   $0x3,-0x1c(%rbp),%eax
cltq
subss  -0x27e90(%rbp,%rax,4),%xmm0
fd ff
movss  %xmm0,-0x60(%rbp)
imul   $0x3,-0x20(%rbp),%eax
add    $0x1,%eax
cltq
movss  -0x4f760(%rbp,%rax,4),%xmm0
fb ff
imul   $0x3,-0x1c(%rbp),%eax
add    $0x1,%eax
cltq
subss  -0x27e90(%rbp,%rax,4),%xmm0
fd ff
movss  %xmm0,-0x64(%rbp)
imul   $0x3,-0x20(%rbp),%eax
add    $0x2,%eax
cltq
movss  -0x4f760(%rbp,%rax,4),%xmm0
fb ff
imul   $0x3,-0x1c(%rbp),%eax
add    $0x2,%eax
cltq
subss  -0x27e90(%rbp,%rax,4),%xmm0
fd ff
movss  %xmm0,-0x68(%rbp)
movss  -0x60(%rbp),%xmm1
movss  -0x3a4(%rbp),%xmm2
ff
movss  -0x64(%rbp),%xmm0
mulss  -0x3b0(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x68(%rbp),%xmm0
movss  -0x3b8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1070 <fabs@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x6c(%rbp),%xmm0
jb     166d <main+0x4bd>
movss  -0x3a4(%rbp),%xmm0
ff
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    16a1 <main+0x4f1>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1982(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1697 <main+0x4e7>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    169c <main+0x4ec>
jmp    17e1 <main+0x631>
jmp    16a1 <main+0x4f1>
movss  -0x64(%rbp),%xmm0
movss  -0x3a8(%rbp),%xmm2
ff
movss  -0x68(%rbp),%xmm1
mulss  -0x3b4(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1070 <fabs@plt>
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm0
ucomiss -0x70(%rbp),%xmm0
jb     16f3 <main+0x543>
movss  -0x3a8(%rbp),%xmm0
ff
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    1727 <main+0x577>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x18fc(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     171d <main+0x56d>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    1722 <main+0x572>
jmp    17e1 <main+0x631>
jmp    1727 <main+0x577>
movss  -0x68(%rbp),%xmm0
mulss  -0x3ac(%rbp),%xmm0
ff
call   1070 <fabs@plt>
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
ucomiss -0x74(%rbp),%xmm0
jb     1764 <main+0x5b4>
movss  -0x3ac(%rbp),%xmm0
ff
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    1798 <main+0x5e8>
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x188b(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     178e <main+0x5de>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    1793 <main+0x5e3>
jmp    17e1 <main+0x631>
jmp    1798 <main+0x5e8>
movss  -0x54(%rbp),%xmm1
movss  -0x54(%rbp),%xmm2
movss  -0x58(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10b0 <sqrt@plt>
movslq -0x24(%rbp),%rax
movss  %xmm0,-0x3a0(%rbp,%rax,4)
ff ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1584 <main+0x3d4>
lea    -0x3a0(%rbp),%rdi
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1040 <quicksort@plt>
movss  -0x3a0(%rbp),%xmm0
ff
addss  -0x39c(%rbp),%xmm0
ff
addss  -0x388(%rbp),%xmm0
ff
addss  -0x384(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1801(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x398(%rbp),%xmm0
ff
addss  -0x38c(%rbp),%xmm0
ff
addss  -0x394(%rbp),%xmm0
ff
addss  -0x390(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x17c8(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x1799(%rip),%xmm2
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x176e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1756(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1730(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1905 <main+0x755>
movss  0x177a(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1a73 <main+0x8c3>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x16fa(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1956 <main+0x7a6>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1707(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1956 <main+0x7a6>
movss  0x1725(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a6e <main+0x8be>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x16d1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     19a7 <main+0x7f7>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x16be(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    19a7 <main+0x7f7>
movss  0x16d0(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a69 <main+0x8b9>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1688(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     19f8 <main+0x848>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1675(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    19f8 <main+0x848>
movss  0x167b(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a64 <main+0x8b4>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x163f(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1a49 <main+0x899>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x162c(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a49 <main+0x899>
movss  0x1626(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a5f <main+0x8af>
movss  0x1607(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a64 <main+0x8b4>
jmp    1a69 <main+0x8b9>
jmp    1a6e <main+0x8be>
jmp    1a73 <main+0x8c3>
mov    -0x4f770(%rbp),%rdi
movss  -0x3a0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x39c(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0x398(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
movss  -0x394(%rbp),%xmm3
ff
cvtss2sd %xmm3,%xmm3
movss  -0x390(%rbp),%xmm4
ff
cvtss2sd %xmm4,%xmm4
movss  -0x38c(%rbp),%xmm5
ff
cvtss2sd %xmm5,%xmm5
movss  -0x388(%rbp),%xmm6
ff
cvtss2sd %xmm6,%xmm6
movss  -0x384(%rbp),%xmm7
ff
cvtss2sd %xmm7,%xmm7
movss  -0x50(%rbp),%xmm8
cvtss2sd %xmm8,%xmm8
lea    0x15cc(%rip),%rsi
movsd  %xmm8,(%rsp)
mov    $0x8,%al
call   1080 <fprintf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1569 <main+0x3b9>
mov    -0x4f770(%rbp),%rdi
lea    0x1605(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x4f770(%rbp),%rdi
lea    0x15f0(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x34bc,-0x1c(%rbp)
jge    2095 <main+0xee5>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x34bc,-0x20(%rbp)
jge    1d7d <main+0xbcd>
imul   $0x3,-0x20(%rbp),%eax
cltq
movss  -0x27e90(%rbp,%rax,4),%xmm0
fd ff
imul   $0x3,-0x1c(%rbp),%eax
cltq
subss  -0x4f760(%rbp,%rax,4),%xmm0
fb ff
movss  %xmm0,-0x60(%rbp)
imul   $0x3,-0x20(%rbp),%eax
add    $0x1,%eax
cltq
movss  -0x27e90(%rbp,%rax,4),%xmm0
fd ff
imul   $0x3,-0x1c(%rbp),%eax
add    $0x1,%eax
cltq
subss  -0x4f760(%rbp,%rax,4),%xmm0
fb ff
movss  %xmm0,-0x64(%rbp)
imul   $0x3,-0x20(%rbp),%eax
add    $0x2,%eax
cltq
movss  -0x27e90(%rbp,%rax,4),%xmm0
fd ff
imul   $0x3,-0x1c(%rbp),%eax
add    $0x2,%eax
cltq
subss  -0x4f760(%rbp,%rax,4),%xmm0
fb ff
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
ucomiss -0x6c(%rbp),%xmm0
jb     1bfb <main+0xa4b>
movss  -0x3a4(%rbp),%xmm0
ff
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    1c2f <main+0xa7f>
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x13f4(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1c25 <main+0xa75>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    1c2a <main+0xa7a>
jmp    1d6f <main+0xbbf>
jmp    1c2f <main+0xa7f>
movss  -0x64(%rbp),%xmm0
movss  -0x3a8(%rbp),%xmm2
ff
movss  -0x68(%rbp),%xmm1
mulss  -0x3b4(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1070 <fabs@plt>
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm0
ucomiss -0x70(%rbp),%xmm0
jb     1c81 <main+0xad1>
movss  -0x3a8(%rbp),%xmm0
ff
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    1cb5 <main+0xb05>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x136e(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1cab <main+0xafb>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    1cb0 <main+0xb00>
jmp    1d6f <main+0xbbf>
jmp    1cb5 <main+0xb05>
movss  -0x68(%rbp),%xmm0
mulss  -0x3ac(%rbp),%xmm0
ff
call   1070 <fabs@plt>
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
ucomiss -0x74(%rbp),%xmm0
jb     1cf2 <main+0xb42>
movss  -0x3ac(%rbp),%xmm0
ff
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    1d26 <main+0xb76>
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x12fd(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1d1c <main+0xb6c>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    1d21 <main+0xb71>
jmp    1d6f <main+0xbbf>
jmp    1d26 <main+0xb76>
movss  -0x54(%rbp),%xmm1
movss  -0x54(%rbp),%xmm2
movss  -0x58(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10b0 <sqrt@plt>
movslq -0x24(%rbp),%rax
movss  %xmm0,-0x3a0(%rbp,%rax,4)
ff ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1b53 <main+0x9a3>
lea    -0x3a0(%rbp),%rdi
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1040 <quicksort@plt>
movss  -0x3a0(%rbp),%xmm0
ff
addss  -0x384(%rbp),%xmm0
ff
addss  -0x39c(%rbp),%xmm0
ff
addss  -0x388(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1273(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x398(%rbp),%xmm0
ff
addss  -0x38c(%rbp),%xmm0
ff
addss  -0x394(%rbp),%xmm0
ff
addss  -0x390(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x123a(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x120b(%rip),%xmm2
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x11e0(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x11c8(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x11a2(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1e93 <main+0xce3>
movss  0x11ec(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    2001 <main+0xe51>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x116c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1ee4 <main+0xd34>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1179(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1ee4 <main+0xd34>
movss  0x1197(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1ffc <main+0xe4c>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1143(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1f35 <main+0xd85>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1130(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1f35 <main+0xd85>
movss  0x1142(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1ff7 <main+0xe47>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x10fa(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1f86 <main+0xdd6>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x10e7(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1f86 <main+0xdd6>
movss  0x10ed(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ff2 <main+0xe42>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x10b1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1fd7 <main+0xe27>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x109e(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1fd7 <main+0xe27>
movss  0x1098(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1fed <main+0xe3d>
movss  0x1079(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ff2 <main+0xe42>
jmp    1ff7 <main+0xe47>
jmp    1ffc <main+0xe4c>
jmp    2001 <main+0xe51>
mov    -0x4f770(%rbp),%rdi
movss  -0x3a0(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x39c(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0x398(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
movss  -0x394(%rbp),%xmm3
ff
cvtss2sd %xmm3,%xmm3
movss  -0x390(%rbp),%xmm4
ff
cvtss2sd %xmm4,%xmm4
movss  -0x38c(%rbp),%xmm5
ff
cvtss2sd %xmm5,%xmm5
movss  -0x388(%rbp),%xmm6
ff
cvtss2sd %xmm6,%xmm6
movss  -0x384(%rbp),%xmm7
ff
cvtss2sd %xmm7,%xmm7
movss  -0x50(%rbp),%xmm8
cvtss2sd %xmm8,%xmm8
lea    0x103e(%rip),%rsi
movsd  %xmm8,(%rsp)
mov    $0x8,%al
call   1080 <fprintf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1b38 <main+0x988>
mov    -0x40(%rbp),%eax
add    -0x3c(%rbp),%eax
add    -0x38(%rbp),%eax
add    -0x34(%rbp),%eax
add    -0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  0xf55(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x4f770(%rbp),%rdi
cvtsi2ssl -0x3c(%rbp),%xmm0
divss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2ssl -0x38(%rbp),%xmm1
divss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
cvtsi2ssl -0x34(%rbp),%xmm2
divss  -0x44(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
cvtsi2ssl -0x30(%rbp),%xmm3
divss  -0x44(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mov    -0x40(%rbp),%eax
add    -0x2c(%rbp),%eax
cvtsi2ss %eax,%xmm4
divss  -0x44(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
lea    0xfcd(%rip),%rsi
mov    $0x5,%al
call   1080 <fprintf@plt>
mov    -0x4f770(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0x18(%rbp),%eax
add    $0x186a0,%eax
mov    %eax,-0x18(%rbp)
jmp    11e9 <main+0x39>
xor    %eax,%eax
add    $0x4f780,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4f738,%rsp
mov    0x8(%rsi),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1080 <strtol@plt>
mov    $0x186a0,%r12d
lea    0xee7(%rip),%r15
jmp    1290 <main+0xf0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    0x1c(%rsp),%r14d
mov    0x38(%rsp),%rdi
lea    (%r14,%rdi,1),%eax
mov    0x24(%rsp),%edx
add    %edx,%eax
mov    0x20(%rsp),%ecx
add    %ecx,%eax
mov    0x28(%rsp),%esi
add    %esi,%eax
xorps  %xmm4,%xmm4
cvtsi2ss %eax,%xmm4
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
divss  %xmm4,%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
divss  %xmm4,%xmm1
cvtss2sd %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtsi2ss %edx,%xmm2
divss  %xmm4,%xmm2
xorps  %xmm3,%xmm3
cvtsi2ss %ecx,%xmm3
cvtss2sd %xmm2,%xmm2
xorps  %xmm5,%xmm5
cvtsi2ss %r14d,%xmm5
divss  %xmm4,%xmm3
cvtss2sd %xmm3,%xmm3
divss  %xmm4,%xmm5
xorps  %xmm4,%xmm4
cvtss2sd %xmm5,%xmm4
mov    %r15,%rdi
lea    0xeae(%rip),%rsi
mov    $0x5,%al
call   1070 <fprintf@plt>
mov    %r15,%rdi
call   1030 <fclose@plt>
mov    0x68(%rsp),%rcx
lea    0x186a0(%rcx),%eax
cmp    $0x61a81,%ecx
mov    %eax,%r12d
lea    0xe2b(%rip),%r15
jae    1c2c <main+0xa8c>
lea    0x490(%rsp),%rbx
mov    %rbx,%rdi
lea    0xdf6(%rip),%rsi
mov    %r12d,%edx
call   10b0 <sprintf@plt>
mov    %rbx,%rdi
lea    0xdeb(%rip),%rsi
call   1090 <fopen@plt>
test   %rax,%rax
je     1c40 <main+0xaa0>
mov    %rax,%r14
mov    %rax,%rdi
lea    0xdfb(%rip),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
lea    0xdb1(%rip),%rbp
mov    %rbp,%rsi
lea    0x34(%rsp),%rdx
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbp,%rsi
lea    0x4c(%rsp),%rdx
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbp,%rsi
lea    0x30(%rsp),%rdx
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbp,%rsi
lea    0x48(%rsp),%rdx
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbp,%rsi
lea    0x44(%rsp),%rdx
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbp,%rsi
lea    0x2c(%rsp),%rdx
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    $0x34bc,%ebp
lea    0x27e60(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x4(%rbx),%rcx
lea    0x8(%rbx),%r8
mov    %r14,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1050 <fscanf@plt>
add    $0xc,%rbx
add    $0xffffffffffffffff,%rbp
jne    13d0 <main+0x230>
mov    %r14,%rdi
lea    0xccb(%rip),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <fscanf@plt>
mov    $0x34bc,%ebp
lea    0x590(%rsp),%rbx
lea    0x4(%rbx),%rcx
lea    0x8(%rbx),%r8
mov    %r14,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1050 <fscanf@plt>
add    $0xc,%rbx
add    $0xffffffffffffffff,%rbp
jne    1420 <main+0x280>
mov    %r14,%rdi
call   1030 <fclose@plt>
movss  0x34(%rsp),%xmm1
movss  0xba8(%rip),%xmm0
addss  %xmm0,%xmm1
movss  %xmm1,0x18(%rsp)
movss  0x30(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x14(%rsp)
movss  0x2c(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x10(%rsp)
lea    0x390(%rsp),%rbx
mov    %rbx,%rdi
lea    0xc40(%rip),%rsi
mov    %r12d,%edx
call   10b0 <sprintf@plt>
mov    %rbx,%rdi
lea    0xc38(%rip),%rsi
call   1090 <fopen@plt>
test   %rax,%rax
je     1c40 <main+0xaa0>
mov    %rax,%r15
mov    %r12,0x68(%rsp)
xor    %ebx,%ebx
xor    %r14d,%r14d
movl   $0x0,0x28(%rsp)
movl   $0x0,0x1c(%rsp)
movl   $0x0,0x20(%rsp)
movl   $0x0,0x24(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
jmp    1551 <main+0x3b1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14d
movsd  0xb93(%rip),%xmm8
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm10,%xmm1
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm3,%xmm3
cvtss2sd %xmm4,%xmm4
cvtss2sd %xmm5,%xmm5
xorps  %xmm6,%xmm6
cvtss2sd %xmm9,%xmm6
xorps  %xmm7,%xmm7
cvtss2sd %xmm11,%xmm7
movsd  %xmm8,(%rsp)
mov    %r15,%rdi
lea    0xba7(%rip),%rsi
mov    $0x8,%al
call   1070 <fprintf@plt>
add    $0x1,%rbx
cmp    $0x34bc,%rbx
je     18a0 <main+0x700>
lea    (%rbx,%rbx,2),%rbp
mov    $0x8,%r12d
xor    %r13d,%r13d
movaps 0xabb(%rip),%xmm5
movss  0xa97(%rip),%xmm6
movss  0x18(%rsp),%xmm7
movss  0x14(%rsp),%xmm8
movss  0x10(%rsp),%xmm9
jmp    15e1 <main+0x441>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps %xmm4,0x50(%rsp)
call   10a0 <sqrt@plt>
movaps 0x50(%rsp),%xmm4
movss  0x10(%rsp),%xmm9
movss  0x14(%rsp),%xmm8
movss  0x18(%rsp),%xmm7
movss  0xa49(%rip),%xmm6
movaps 0xa5e(%rip),%xmm5
movslq %r13d,%r13
movss  %xmm0,0x70(%rsp,%r13,4)
add    $0x1,%r13d
add    $0xc,%r12
cmp    $0x278d8,%r12
je     1700 <main+0x560>
movss  0x588(%rsp,%r12,1),%xmm3
movss  0x58c(%rsp,%r12,1),%xmm1
subss  0x27e60(%rsp,%rbp,4),%xmm3
subss  0x27e64(%rsp,%rbp,4),%xmm1
movss  0x590(%rsp,%r12,1),%xmm0
subss  0x27e68(%rsp,%rbp,4),%xmm0
movss  0x34(%rsp),%xmm2
movss  0x4c(%rsp),%xmm4
mulss  %xmm1,%xmm4
mulss  %xmm2,%xmm3
addss  %xmm4,%xmm3
movss  0x48(%rsp),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm3,%xmm4
andps  %xmm5,%xmm4
ucomiss %xmm7,%xmm4
jae    1650 <main+0x4b0>
ucomiss %xmm4,%xmm6
jb     15d0 <main+0x430>
jmp    1657 <main+0x4b7>
nop
subss  %xmm4,%xmm2
movaps %xmm2,%xmm4
movss  0x30(%rsp),%xmm2
movss  0x44(%rsp),%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm2,%xmm1
addss  %xmm3,%xmm1
andps  %xmm5,%xmm1
ucomiss %xmm8,%xmm1
jae    1690 <main+0x4f0>
ucomiss %xmm1,%xmm6
jb     15d0 <main+0x430>
jmp    1697 <main+0x4f7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
subss  %xmm1,%xmm2
movaps %xmm2,%xmm1
movss  0x2c(%rsp),%xmm2
mulss  %xmm2,%xmm0
andps  %xmm5,%xmm0
ucomiss %xmm9,%xmm0
jae    16c0 <main+0x520>
ucomiss %xmm0,%xmm6
jb     15d0 <main+0x430>
jmp    16c7 <main+0x527>
cs nopw 0x0(%rax,%rax,1)
nop
subss  %xmm0,%xmm2
movaps %xmm2,%xmm0
mulss  %xmm1,%xmm1
movaps %xmm4,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm1,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
ucomiss 0x92b(%rip),%xmm0
jb     1590 <main+0x3f0>
sqrtss %xmm0,%xmm0
jmp    15c2 <main+0x422>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm4,0x50(%rsp)
add    $0xffffffff,%r13d
lea    0x70(%rsp),%rdi
xor    %esi,%esi
mov    %r13d,%edx
call   1040 <quicksort@plt>
movss  0x70(%rsp),%xmm0
movss  0x74(%rsp),%xmm10
movaps %xmm0,%xmm1
addss  %xmm10,%xmm1
movss  0x88(%rsp),%xmm9
addss  %xmm9,%xmm1
movss  0x8c(%rsp),%xmm11
addss  %xmm11,%xmm1
movss  0x8b5(%rip),%xmm7
mulss  %xmm7,%xmm1
movss  0x78(%rsp),%xmm2
movss  0x84(%rsp),%xmm5
movaps %xmm2,%xmm6
addss  %xmm5,%xmm6
movss  0x7c(%rsp),%xmm3
addss  %xmm3,%xmm6
movss  0x80(%rsp),%xmm4
addss  %xmm4,%xmm6
mulss  %xmm7,%xmm6
cvtss2sd %xmm6,%xmm6
cvtss2sd %xmm1,%xmm1
mulsd  0x898(%rip),%xmm1
mulsd  0x898(%rip),%xmm6
addsd  %xmm1,%xmm6
divsd  0x894(%rip),%xmm6
xorps  %xmm1,%xmm1
cvtsd2ss %xmm6,%xmm1
movss  0x851(%rip),%xmm7
ucomiss %xmm1,%xmm7
ja     14f0 <main+0x350>
xorps  %xmm6,%xmm6
cvtss2sd %xmm1,%xmm6
ucomiss %xmm7,%xmm1
jb     1800 <main+0x660>
movsd  0x870(%rip),%xmm1
ucomisd %xmm6,%xmm1
jbe    1800 <main+0x660>
addl   $0x1,0x28(%rsp)
movsd  0x89c(%rip),%xmm8
jmp    14fd <main+0x35d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd 0x840(%rip),%xmm6
jb     1833 <main+0x693>
movsd  0x83e(%rip),%xmm1
ucomisd %xmm6,%xmm1
jbe    1833 <main+0x693>
mov    0x38(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x38(%rsp)
movsd  0x852(%rip),%xmm8
jmp    14fd <main+0x35d>
ucomisd 0x815(%rip),%xmm6
jb     185e <main+0x6be>
movsd  0x813(%rip),%xmm1
ucomisd %xmm6,%xmm1
jbe    185e <main+0x6be>
addl   $0x1,0x24(%rsp)
movsd  0x81f(%rip),%xmm8
jmp    14fd <main+0x35d>
ucomisd 0x7f2(%rip),%xmm6
jb     1889 <main+0x6e9>
movsd  0x7f0(%rip),%xmm1
ucomisd %xmm6,%xmm1
jbe    1889 <main+0x6e9>
addl   $0x1,0x20(%rsp)
movsd  0x7ec(%rip),%xmm8
jmp    14fd <main+0x35d>
addl   $0x1,0x1c(%rsp)
movsd  0x7d1(%rip),%xmm8
jmp    14fd <main+0x35d>
nopl   0x0(%rax)
mov    $0xa,%edi
mov    %r15,%rsi
call   1060 <fputc@plt>
mov    $0xa,%edi
mov    %r15,%rsi
call   1060 <fputc@plt>
xor    %r12d,%r12d
jmp    1921 <main+0x781>
nop
add    $0x1,%r14d
movsd  0x7c3(%rip),%xmm8
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm10,%xmm1
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm3,%xmm3
cvtss2sd %xmm4,%xmm4
cvtss2sd %xmm5,%xmm5
xorps  %xmm6,%xmm6
cvtss2sd %xmm11,%xmm6
xorps  %xmm7,%xmm7
cvtss2sd %xmm9,%xmm7
movsd  %xmm8,(%rsp)
mov    %r15,%rdi
lea    0x7d7(%rip),%rsi
mov    $0x8,%al
call   1070 <fprintf@plt>
add    $0x1,%r12
cmp    $0x34bc,%r12
je     11e0 <main+0x40>
lea    (%r12,%r12,2),%r13
xor    %ebx,%ebx
mov    $0x8,%ebp
movaps 0x6ed(%rip),%xmm4
movss  0x6c9(%rip),%xmm5
movss  0x18(%rsp),%xmm6
movss  0x14(%rsp),%xmm9
movss  0x10(%rsp),%xmm8
movaps 0x50(%rsp),%xmm7
jmp    19af <main+0x80f>
cs nopw 0x0(%rax,%rax,1)
movaps %xmm7,0x50(%rsp)
call   10a0 <sqrt@plt>
movaps 0x50(%rsp),%xmm7
movss  0x10(%rsp),%xmm8
movss  0x14(%rsp),%xmm9
movss  0x18(%rsp),%xmm6
movss  0x679(%rip),%xmm5
movaps 0x68e(%rip),%xmm4
movslq %ebx,%rbx
movss  %xmm0,0x70(%rsp,%rbx,4)
add    $0x1,%ebx
add    $0xc,%rbp
cmp    $0x278d8,%rbp
je     1aa0 <main+0x900>
movss  0x27e5c(%rsp,%rbp,1),%xmm1
movss  0x27e60(%rsp,%rbp,1),%xmm0
subss  0x594(%rsp,%r13,4),%xmm1
subss  0x598(%rsp,%r13,4),%xmm0
ucomiss %xmm6,%xmm7
jae    19f0 <main+0x850>
ucomiss %xmm7,%xmm5
jb     199e <main+0x7fe>
jmp    19fd <main+0x85d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x34(%rsp),%xmm2
subss  %xmm7,%xmm2
movaps %xmm2,%xmm7
movss  0x30(%rsp),%xmm2
movss  0x44(%rsp),%xmm3
mulss  %xmm0,%xmm3
mulss  %xmm2,%xmm1
addss  %xmm3,%xmm1
andps  %xmm4,%xmm1
ucomiss %xmm9,%xmm1
jae    1a30 <main+0x890>
ucomiss %xmm1,%xmm5
jb     199e <main+0x7fe>
jmp    1a37 <main+0x897>
nopl   0x0(%rax)
subss  %xmm1,%xmm2
movaps %xmm2,%xmm1
movss  0x2c(%rsp),%xmm2
mulss  %xmm2,%xmm0
andps  %xmm4,%xmm0
ucomiss %xmm8,%xmm0
jae    1a60 <main+0x8c0>
ucomiss %xmm0,%xmm5
jb     199e <main+0x7fe>
jmp    1a67 <main+0x8c7>
cs nopw 0x0(%rax,%rax,1)
nop
subss  %xmm0,%xmm2
movaps %xmm2,%xmm0
mulss  %xmm1,%xmm1
movaps %xmm7,%xmm2
mulss  %xmm7,%xmm2
addss  %xmm1,%xmm2
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
ucomiss 0x58b(%rip),%xmm0
jb     1960 <main+0x7c0>
sqrtss %xmm0,%xmm0
jmp    1992 <main+0x7f2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm7,0x50(%rsp)
add    $0xffffffff,%ebx
lea    0x70(%rsp),%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1040 <quicksort@plt>
movss  0x70(%rsp),%xmm0
movss  0x74(%rsp),%xmm10
movss  0x8c(%rsp),%xmm9
movaps %xmm0,%xmm1
addss  %xmm9,%xmm1
addss  %xmm10,%xmm1
movss  0x88(%rsp),%xmm11
addss  %xmm11,%xmm1
movss  0x517(%rip),%xmm6
mulss  %xmm6,%xmm1
movss  0x78(%rsp),%xmm2
movss  0x84(%rsp),%xmm5
movaps %xmm2,%xmm7
addss  %xmm5,%xmm7
movss  0x7c(%rsp),%xmm3
addss  %xmm3,%xmm7
movss  0x80(%rsp),%xmm4
addss  %xmm4,%xmm7
mulss  %xmm6,%xmm7
cvtss2sd %xmm7,%xmm7
cvtss2sd %xmm1,%xmm1
mulsd  0x4fa(%rip),%xmm1
mulsd  0x4fa(%rip),%xmm7
addsd  %xmm1,%xmm7
divsd  0x4f6(%rip),%xmm7
xorps  %xmm1,%xmm1
cvtsd2ss %xmm7,%xmm1
movss  0x4b3(%rip),%xmm6
ucomiss %xmm1,%xmm6
ja     18c0 <main+0x720>
xorps  %xmm7,%xmm7
cvtss2sd %xmm1,%xmm7
ucomiss %xmm6,%xmm1
jb     1b90 <main+0x9f0>
movsd  0x4d2(%rip),%xmm1
ucomisd %xmm7,%xmm1
jbe    1b90 <main+0x9f0>
addl   $0x1,0x28(%rsp)
movsd  0x4fe(%rip),%xmm8
jmp    18cd <main+0x72d>
nop
ucomisd 0x4b0(%rip),%xmm7
jb     1bc3 <main+0xa23>
movsd  0x4ae(%rip),%xmm1
ucomisd %xmm7,%xmm1
jbe    1bc3 <main+0xa23>
mov    0x38(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x38(%rsp)
movsd  0x4c2(%rip),%xmm8
jmp    18cd <main+0x72d>
ucomisd 0x485(%rip),%xmm7
jb     1bee <main+0xa4e>
movsd  0x483(%rip),%xmm1
ucomisd %xmm7,%xmm1
jbe    1bee <main+0xa4e>
addl   $0x1,0x24(%rsp)
movsd  0x48f(%rip),%xmm8
jmp    18cd <main+0x72d>
ucomisd 0x462(%rip),%xmm7
jb     1c19 <main+0xa79>
movsd  0x460(%rip),%xmm1
ucomisd %xmm7,%xmm1
jbe    1c19 <main+0xa79>
addl   $0x1,0x20(%rsp)
movsd  0x45c(%rip),%xmm8
jmp    18cd <main+0x72d>
addl   $0x1,0x1c(%rsp)
movsd  0x441(%rip),%xmm8
jmp    18cd <main+0x72d>
xor    %eax,%eax
add    $0x4f738,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
call   10c0 <exit@plt>

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

LLVM IR (-O2):
@.str = [7 x i8] c"%d.cfg\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [10 x i8] c"%*[^\0A]%*c\00"
@.str.3 = [20 x i8] c"%*7c\0A%*c%f%*[^\0A]%*c\00"
@.str.4 = [18 x i8] c"%f\0A%f\0A%f%*[^\0A]%*c\00"
@.str.5 = [13 x i8] c"%*c%*[^\0A]%*c\00"
@.str.6 = [10 x i8] c"op_%d.txt\00"
@.str.7 = [2 x i8] c"w\00"
@.str.8 = [46 x i8] c"%.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.4f\0A\00"
@.str.10 = [54 x i8] c"B2: %.4f B19: %.4f B19': %.4f BCO: %.4f defect: %.4f\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [200 x float]
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca [256 x i8]
%11 = alloca [256 x i8]
%12 = alloca [40500 x float]
%13 = alloca [40500 x float]
%14 = getelementptr inbounds i8*, i8** %1, i64 1
%15 = load i8*, i8** %14
%16 = tail call i32 @strtol(i8* nocapture %15, i32* null, i32 10)
%17 = bitcast [200 x float]* %3 to i8*
%18 = bitcast float* %4 to i8*
%19 = bitcast float* %5 to i8*
%20 = bitcast float* %6 to i8*
%21 = bitcast float* %7 to i8*
%22 = bitcast float* %8 to i8*
%23 = bitcast float* %9 to i8*
%24 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 0
%25 = getelementptr inbounds [256 x i8], [256 x i8]* %11, i64 0, i64 0
%26 = bitcast [40500 x float]* %12 to i8*
%27 = bitcast [40500 x float]* %13 to i8*
%28 = getelementptr inbounds [200 x float], [200 x float]* %3, i64 0, i64 0
%29 = getelementptr inbounds [200 x float], [200 x float]* %3, i64 0, i64 1
%30 = getelementptr inbounds [200 x float], [200 x float]* %3, i64 0, i64 6
%31 = getelementptr inbounds [200 x float], [200 x float]* %3, i64 0, i64 7
%32 = getelementptr inbounds [200 x float], [200 x float]* %3, i64 0, i64 2
%33 = getelementptr inbounds [200 x float], [200 x float]* %3, i64 0, i64 5
%34 = getelementptr inbounds [200 x float], [200 x float]* %3, i64 0, i64 3
%35 = getelementptr inbounds [200 x float], [200 x float]* %3, i64 0, i64 4
br label %36
36: ; preds = %2, %399
%37 = phi i32 [ 100000, %2 ], [ %423, %399 ]
%38 = call i32 @sprintf(i8* %24, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32 %37)
%39 = call i32* @fopen(i8* %24, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%40 = icmp eq i32* %39, null
br i1 %40, label %41, label %43
41: ; preds = %36
%42 = call i32 @exit(i32 0)
unreachable
43: ; preds = %36
%44 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
%45 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
%46 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.3, i64 0, i64 0), float* %4)
%47 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
%48 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
%49 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.3, i64 0, i64 0), float* %7)
%50 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.3, i64 0, i64 0), float* %5)
%51 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
%52 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.3, i64 0, i64 0), float* %9)
%53 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.3, i64 0, i64 0), float* %8)
%54 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.3, i64 0, i64 0), float* %6)
%55 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
%56 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
%57 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
%58 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0))
br label %59
59: ; preds = %43, %59
%60 = phi i64 [ 0, %43 ], [ %68, %59 ]
%61 = mul nuw nsw i64 %60, 3
%62 = getelementptr inbounds [40500 x float], [40500 x float]* %12, i64 0, i64 %61
%63 = add nuw nsw i64 %61, 1
%64 = getelementptr inbounds [40500 x float], [40500 x float]* %12, i64 0, i64 %63
%65 = add nuw nsw i64 %61, 2
%66 = getelementptr inbounds [40500 x float], [40500 x float]* %12, i64 0, i64 %65
%67 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.4, i64 0, i64 0), float* %62, float* %64, float* %66)
%68 = add nuw nsw i64 %60, 1
%69 = icmp eq i64 %68, 13500
br i1 %69, label %70, label %59
70: ; preds = %59
%71 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.5, i64 0, i64 0))
%72 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.5, i64 0, i64 0))
br label %73
73: ; preds = %70, %73
%74 = phi i64 [ 0, %70 ], [ %82, %73 ]
%75 = mul nuw nsw i64 %74, 3
%76 = getelementptr inbounds [40500 x float], [40500 x float]* %13, i64 0, i64 %75
%77 = add nuw nsw i64 %75, 1
%78 = getelementptr inbounds [40500 x float], [40500 x float]* %13, i64 0, i64 %77
%79 = add nuw nsw i64 %75, 2
%80 = getelementptr inbounds [40500 x float], [40500 x float]* %13, i64 0, i64 %79
%81 = call i32 (i32*, i8*, ...) @fscanf(i32* %39, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.4, i64 0, i64 0), float* %76, float* %78, float* %80)
%82 = add nuw nsw i64 %74, 1
%83 = icmp eq i64 %82, 13500
br i1 %83, label %84, label %73
84: ; preds = %73
%85 = call i32 @fclose(i32* %39)
%86 = load float, float* %4
%87 = fadd float %86, -4.500000e+00
%88 = load float, float* %5
%89 = fadd float %88, -4.500000e+00
%90 = load float, float* %6
%91 = fadd float %90, -4.500000e+00
%92 = call i32 @sprintf(i8* %25, i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0), i32 %37)
%93 = call i32* @fopen(i8* %25, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
%94 = icmp eq i32* %93, null
br i1 %94, label %95, label %97
95: ; preds = %84
%96 = call i32 @exit(i32 0)
unreachable
97: ; preds = %84, %232
%98 = phi i64 [ %249, %232 ], [ 0, %84 ]
%99 = phi i32 [ %239, %232 ], [ 0, %84 ]
%100 = phi i32 [ %237, %232 ], [ 0, %84 ]
%101 = phi i32 [ %236, %232 ], [ 0, %84 ]
%102 = phi i32 [ %235, %232 ], [ 0, %84 ]
%103 = phi i32 [ %234, %232 ], [ 0, %84 ]
%104 = phi i32 [ %233, %232 ], [ 0, %84 ]
%105 = mul nuw nsw i64 %98, 3
%106 = getelementptr inbounds [40500 x float], [40500 x float]* %12, i64 0, i64 %105
%107 = add nuw nsw i64 %105, 1
%108 = getelementptr inbounds [40500 x float], [40500 x float]* %12, i64 0, i64 %107
%109 = add nuw nsw i64 %105, 2
%110 = getelementptr inbounds [40500 x float], [40500 x float]* %12, i64 0, i64 %109
br label %111
111: ; preds = %97, %172
%112 = phi i64 [ 0, %97 ], [ %175, %172 ]
%113 = phi i32 [ 0, %97 ], [ %174, %172 ]
%114 = mul nuw nsw i64 %112, 3
%115 = getelementptr inbounds [40500 x float], [40500 x float]* %13, i64 0, i64 %114
%116 = load float, float* %115
%117 = load float, float* %106
%118 = fsub float %116, %117
%119 = add nuw nsw i64 %114, 1
%120 = getelementptr inbounds [40500 x float], [40500 x float]* %13, i64 0, i64 %119
%121 = load float, float* %120
%122 = load float, float* %108
%123 = fsub float %121, %122
%124 = add nuw nsw i64 %114, 2
%125 = getelementptr inbounds [40500 x float], [40500 x float]* %13, i64 0, i64 %124
%126 = load float, float* %125
%127 = load float, float* %110
%128 = fsub float %126, %127
%129 = load float, float* %4
%130 = load float, float* %7
%131 = fmul float %123, %130
%132 = call float @llvm.fmuladd.f32(float %118, float %129, float %131)
%133 = load float, float* %9
%134 = call float @llvm.fmuladd.f32(float %128, float %133, float %132)
%135 = call float @llvm.fabs.f32(float %134)
%136 = fcmp ult float %135, %87
br i1 %136, label %139, label %137
137: ; preds = %111
%138 = fsub float %129, %135
br label %141
139: ; preds = %111
%140 = fcmp ugt float %135, 4.500000e+00
br i1 %140, label %172, label %141
141: ; preds = %139, %137
%142 = phi float [ %138, %137 ], [ %135, %139 ]
%143 = load float, float* %5
%144 = load float, float* %8
%145 = fmul float %128, %144
%146 = call float @llvm.fmuladd.f32(float %123, float %143, float %145)
%147 = call float @llvm.fabs.f32(float %146)
%148 = fcmp ult float %147, %89
br i1 %148, label %151, label %149
149: ; preds = %141
%150 = fsub float %143, %147
br label %153
151: ; preds = %141
%152 = fcmp ugt float %147, 4.500000e+00
br i1 %152, label %172, label %153
153: ; preds = %151, %149
%154 = phi float [ %150, %149 ], [ %147, %151 ]
%155 = load float, float* %6
%156 = fmul float %128, %155
%157 = call float @llvm.fabs.f32(float %156)
%158 = fcmp ult float %157, %91
br i1 %158, label %161, label %159
159: ; preds = %153
%160 = fsub float %155, %157
br label %163
161: ; preds = %153
%162 = fcmp ugt float %157, 4.500000e+00
br i1 %162, label %172, label %163
163: ; preds = %161, %159
%164 = phi float [ %160, %159 ], [ %157, %161 ]
%165 = fmul float %154, %154
%166 = call float @llvm.fmuladd.f32(float %142, float %142, float %165)
%167 = call float @llvm.fmuladd.f32(float %164, float %164, float %166)
%168 = call float @sqrt(float %167)
%169 = sext i32 %113 to i64
%170 = getelementptr inbounds [200 x float], [200 x float]* %3, i64 0, i64 %169
store float %168, float* %170
%171 = add nsw i32 %113, 1
br label %172
172: ; preds = %161, %151, %139, %163
%173 = phi float [ %142, %163 ], [ %142, %161 ], [ %142, %151 ], [ %135, %139 ]
%174 = phi i32 [ %171, %163 ], [ %113, %161 ], [ %113, %151 ], [ %113, %139 ]
%175 = add nuw nsw i64 %112, 1
%176 = icmp eq i64 %175, 13500
br i1 %176, label %177, label %111
177: ; preds = %172
%178 = add nsw i32 %174, -1
%179 = call i32 @quicksort(float* %28, i32 0, i32 %178)
%180 = load float, float* %28
%181 = load float, float* %29
%182 = fadd float %180, %181
%183 = load float, float* %30
%184 = fadd float %182, %183
%185 = load float, float* %31
%186 = fadd float %184, %185
%187 = fmul float %186, 5.000000e-01
%188 = load float, float* %32
%189 = load float, float* %33
%190 = fadd float %188, %189
%191 = load float, float* %34
%192 = fadd float %190, %191
%193 = load float, float* %35
%194 = fadd float %192, %193
%195 = fmul float %194, 5.000000e-01
%196 = fpext float %195 to double
%197 = fpext float %187 to double
%198 = fmul double %197, 0xC0247AE147AE147A
%199 = call double @llvm.fmuladd.f64(double %196, double 1.059000e+01, double %198)
%200 = fdiv double %199, 0xBFFD3B645A1CAC14
%201 = fptrunc double %200 to float
%202 = fpext float %201 to double
%203 = fcmp olt float %201, -1.500000e+00
br i1 %203, label %204, label %206
204: ; preds = %177
%205 = add nsw i32 %99, 1
br label %232
206: ; preds = %177
%207 = fcmp oge float %201, -1.500000e+00
%208 = fcmp olt double %202, -2.000000e-01
%209 = and i1 %207, %208
br i1 %209, label %210, label %212
210: ; preds = %206
%211 = add nsw i32 %100, 1
br label %232
212: ; preds = %206
%213 = fcmp oge double %202, -2.000000e-01
%214 = fcmp olt double %202, 1.000000e-01
%215 = and i1 %213, %214
br i1 %215, label %216, label %218
216: ; preds = %212
%217 = add nsw i32 %104, 1
br label %232
218: ; preds = %212
%219 = fcmp oge double %202, 1.000000e-01
%220 = fcmp olt double %202, 1.811500e+00
%221 = and i1 %219, %220
br i1 %221, label %222, label %224
222: ; preds = %218
%223 = add nsw i32 %103, 1
br label %232
224: ; preds = %218
%225 = fcmp oge double %202, 1.811500e+00
%226 = fcmp olt double %202, 2.900000e+00
%227 = and i1 %225, %226
br i1 %227, label %228, label %230
228: ; preds = %224
%229 = add nsw i32 %102, 1
br label %232
230: ; preds = %224
%231 = add nsw i32 %101, 1
br label %232
232: ; preds = %210, %222, %230, %228, %216, %204
%233 = phi i32 [ %104, %204 ], [ %104, %210 ], [ %217, %216 ], [ %104, %222 ], [ %104, %228 ], [ %104, %230 ]
%234 = phi i32 [ %103, %204 ], [ %103, %210 ], [ %103, %216 ], [ %223, %222 ], [ %103, %228 ], [ %103, %230 ]
%235 = phi i32 [ %102, %204 ], [ %102, %210 ], [ %102, %216 ], [ %102, %222 ], [ %229, %228 ], [ %102, %230 ]
%236 = phi i32 [ %101, %204 ], [ %101, %210 ], [ %101, %216 ], [ %101, %222 ], [ %101, %228 ], [ %231, %230 ]
%237 = phi i32 [ %100, %204 ], [ %211, %210 ], [ %100, %216 ], [ %100, %222 ], [ %100, %228 ], [ %100, %230 ]
%238 = phi double [ -2.000000e+00, %204 ], [ -1.000000e+00, %210 ], [ 0x3FC99999A0000000, %216 ], [ 1.000000e+00, %222 ], [ 0x4004E809E0000000, %228 ], [ 3.500000e+00, %230 ]
%239 = phi i32 [ %205, %204 ], [ %99, %210 ], [ %99, %216 ], [ %99, %222 ], [ %99, %228 ], [ %99, %230 ]
%240 = fpext float %180 to double
%241 = fpext float %181 to double
%242 = fpext float %188 to double
%243 = fpext float %191 to double
%244 = fpext float %193 to double
%245 = fpext float %189 to double
%246 = fpext float %183 to double
%247 = fpext float %185 to double
%248 = call i32 (i32*, i8*, ...) @fprintf(i32* %93, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.8, i64 0, i64 0), double %240, double %241, double %242, double %243, double %244, double %245, double %246, double %247, double %238)
%249 = add nuw nsw i64 %98, 1
%250 = icmp eq i64 %249, 13500
br i1 %250, label %251, label %97
251: ; preds = %232
%252 = call i32 @fputc(i32 10, i32* %93)
%253 = call i32 @fputc(i32 10, i32* %93)
br label %254
254: ; preds = %251, %380
%255 = phi i64 [ 0, %251 ], [ %397, %380 ]
%256 = phi i32 [ %239, %251 ], [ %387, %380 ]
%257 = phi float [ %173, %251 ], [ %321, %380 ]
%258 = phi i32 [ %237, %251 ], [ %385, %380 ]
%259 = phi i32 [ %236, %251 ], [ %384, %380 ]
%260 = phi i32 [ %235, %251 ], [ %383, %380 ]
%261 = phi i32 [ %234, %251 ], [ %382, %380 ]
%262 = phi i32 [ %233, %251 ], [ %381, %380 ]
%263 = mul nuw nsw i64 %255, 3
%264 = add nuw nsw i64 %263, 1
%265 = getelementptr inbounds [40500 x float], [40500 x float]* %13, i64 0, i64 %264
%266 = add nuw nsw i64 %263, 2
%267 = getelementptr inbounds [40500 x float], [40500 x float]* %13, i64 0, i64 %266
br label %268
268: ; preds = %254, %320
%269 = phi i64 [ 0, %254 ], [ %323, %320 ]
%270 = phi i32 [ 0, %254 ], [ %322, %320 ]
%271 = phi float [ %257, %254 ], [ %321, %320 ]
%272 = mul nuw nsw i64 %269, 3
%273 = add nuw nsw i64 %272, 1
%274 = getelementptr inbounds [40500 x float], [40500 x float]* %12, i64 0, i64 %273
%275 = load float, float* %274
%276 = load float, float* %265
%277 = fsub float %275, %276
%278 = add nuw nsw i64 %272, 2
%279 = getelementptr inbounds [40500 x float], [40500 x float]* %12, i64 0, i64 %278
%280 = load float, float* %279
%281 = load float, float* %267
%282 = fsub float %280, %281
%283 = fcmp ult float %271, %87
br i1 %283, label %287, label %284
284: ; preds = %268
%285 = load float, float* %4
%286 = fsub float %285, %271
br label %289
287: ; preds = %268
%288 = fcmp ugt float %271, 4.500000e+00
br i1 %288, label %320, label %289
289: ; preds = %287, %284
%290 = phi float [ %286, %284 ], [ %271, %287 ]
%291 = load float, float* %5
%292 = load float, float* %8
%293 = fmul float %282, %292
%294 = call float @llvm.fmuladd.f32(float %277, float %291, float %293)
%295 = call float @llvm.fabs.f32(float %294)
%296 = fcmp ult float %295, %89
br i1 %296, label %299, label %297
297: ; preds = %289
%298 = fsub float %291, %295
br label %301
299: ; preds = %289
%300 = fcmp ugt float %295, 4.500000e+00
br i1 %300, label %320, label %301
301: ; preds = %299, %297
%302 = phi float [ %298, %297 ], [ %295, %299 ]
%303 = load float, float* %6
%304 = fmul float %282, %303
%305 = call float @llvm.fabs.f32(float %304)
%306 = fcmp ult float %305, %91
br i1 %306, label %309, label %307
307: ; preds = %301
%308 = fsub float %303, %305
br label %311
309: ; preds = %301
%310 = fcmp ugt float %305, 4.500000e+00
br i1 %310, label %320, label %311
311: ; preds = %309, %307
%312 = phi float [ %308, %307 ], [ %305, %309 ]
%313 = fmul float %302, %302
%314 = call float @llvm.fmuladd.f32(float %290, float %290, float %313)
%315 = call float @llvm.fmuladd.f32(float %312, float %312, float %314)
%316 = call float @sqrt(float %315)
%317 = sext i32 %270 to i64
%318 = getelementptr inbounds [200 x float], [200 x float]* %3, i64 0, i64 %317
store float %316, float* %318
%319 = add nsw i32 %270, 1
br label %320
320: ; preds = %309, %299, %287, %311
%321 = phi float [ %290, %311 ], [ %290, %309 ], [ %290, %299 ], [ %271, %287 ]
%322 = phi i32 [ %319, %311 ], [ %270, %309 ], [ %270, %299 ], [ %270, %287 ]
%323 = add nuw nsw i64 %269, 1
%324 = icmp eq i64 %323, 13500
br i1 %324, label %325, label %268
325: ; preds = %320
%326 = add nsw i32 %322, -1
%327 = call i32 @quicksort(float* %28, i32 0, i32 %326)
%328 = load float, float* %28
%329 = load float, float* %31
%330 = fadd float %328, %329
%331 = load float, float* %29
%332 = fadd float %330, %331
%333 = load float, float* %30
%334 = fadd float %332, %333
%335 = fmul float %334, 5.000000e-01
%336 = load float, float* %32
%337 = load float, float* %33
%338 = fadd float %336, %337
%339 = load float, float* %34
%340 = fadd float %338, %339
%341 = load float, float* %35
%342 = fadd float %340, %341
%343 = fmul float %342, 5.000000e-01
%344 = fpext float %343 to double
%345 = fpext float %335 to double
%346 = fmul double %345, 0xC0247AE147AE147A
%347 = call double @llvm.fmuladd.f64(double %344, double 1.059000e+01, double %346)
%348 = fdiv double %347, 0xBFFD3B645A1CAC14
%349 = fptrunc double %348 to float
%350 = fpext float %349 to double
%351 = fcmp olt float %349, -1.500000e+00
br i1 %351, label %352, label %354
352: ; preds = %325
%353 = add nsw i32 %256, 1
br label %380
354: ; preds = %325
%355 = fcmp oge float %349, -1.500000e+00
%356 = fcmp olt double %350, -2.000000e-01
%357 = and i1 %355, %356
br i1 %357, label %358, label %360
358: ; preds = %354
%359 = add nsw i32 %258, 1
br label %380
360: ; preds = %354
%361 = fcmp oge double %350, -2.000000e-01
%362 = fcmp olt double %350, 1.000000e-01
%363 = and i1 %361, %362
br i1 %363, label %364, label %366
364: ; preds = %360
%365 = add nsw i32 %262, 1
br label %380
366: ; preds = %360
%367 = fcmp oge double %350, 1.000000e-01
%368 = fcmp olt double %350, 1.811500e+00
%369 = and i1 %367, %368
br i1 %369, label %370, label %372
370: ; preds = %366
%371 = add nsw i32 %261, 1
br label %380
372: ; preds = %366
%373 = fcmp oge double %350, 1.811500e+00
%374 = fcmp olt double %350, 2.900000e+00
%375 = and i1 %373, %374
br i1 %375, label %376, label %378
376: ; preds = %372
%377 = add nsw i32 %260, 1
br label %380
378: ; preds = %372
%379 = add nsw i32 %259, 1
br label %380
380: ; preds = %358, %370, %378, %376, %364, %352
%381 = phi i32 [ %262, %352 ], [ %262, %358 ], [ %365, %364 ], [ %262, %370 ], [ %262, %376 ], [ %262, %378 ]
%382 = phi i32 [ %261, %352 ], [ %261, %358 ], [ %261, %364 ], [ %371, %370 ], [ %261, %376 ], [ %261, %378 ]
%383 = phi i32 [ %260, %352 ], [ %260, %358 ], [ %260, %364 ], [ %260, %370 ], [ %377, %376 ], [ %260, %378 ]
%384 = phi i32 [ %259, %352 ], [ %259, %358 ], [ %259, %364 ], [ %259, %370 ], [ %259, %376 ], [ %379, %378 ]
%385 = phi i32 [ %258, %352 ], [ %359, %358 ], [ %258, %364 ], [ %258, %370 ], [ %258, %376 ], [ %258, %378 ]
%386 = phi double [ -2.000000e+00, %352 ], [ -1.000000e+00, %358 ], [ 0x3FC99999A0000000, %364 ], [ 1.000000e+00, %370 ], [ 0x4004E809E0000000, %376 ], [ 3.500000e+00, %378 ]
%387 = phi i32 [ %353, %352 ], [ %256, %358 ], [ %256, %364 ], [ %256, %370 ], [ %256, %376 ], [ %256, %378 ]
%388 = fpext float %328 to double
%389 = fpext float %331 to double
%390 = fpext float %336 to double
%391 = fpext float %339 to double
%392 = fpext float %341 to double
%393 = fpext float %337 to double
%394 = fpext float %333 to double
%395 = fpext float %329 to double
%396 = call i32 (i32*, i8*, ...) @fprintf(i32* %93, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.8, i64 0, i64 0), double %388, double %389, double %390, double %391, double %392, double %393, double %394, double %395, double %386)
%397 = add nuw nsw i64 %255, 1
%398 = icmp eq i64 %397, 13500
br i1 %398, label %399, label %254
399: ; preds = %380
%400 = add i32 %387, %384
%401 = add i32 %400, %381
%402 = add i32 %401, %382
%403 = add i32 %402, %383
%404 = add i32 %403, %385
%405 = sitofp i32 %404 to float
%406 = sitofp i32 %385 to float
%407 = fdiv float %406, %405
%408 = fpext float %407 to double
%409 = sitofp i32 %381 to float
%410 = fdiv float %409, %405
%411 = fpext float %410 to double
%412 = sitofp i32 %382 to float
%413 = fdiv float %412, %405
%414 = fpext float %413 to double
%415 = sitofp i32 %383 to float
%416 = fdiv float %415, %405
%417 = fpext float %416 to double
%418 = sitofp i32 %400 to float
%419 = fdiv float %418, %405
%420 = fpext float %419 to double
%421 = call i32 (i32*, i8*, ...) @fprintf(i32* %93, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.10, i64 0, i64 0), double %408, double %411, double %414, double %417, double %420)
%422 = call i32 @fclose(i32* %93)
%423 = add nuw nsw i32 %37, 100000
%424 = icmp ult i32 %37, 400001
br i1 %424, label %36, label %425
425: ; preds = %399
ret i32 0
}