#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*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, double, double);
double log(int);
int pow(double, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, ...);
double sin(int);
int main() {
  int n, i, restart, j, adaptive_step;
  double G, F, Y, x, a, x1, step, y_values[200], x_values[200], max_x, min_x,
      max_y, min_y;
  j = 0;
  restart = 1;
  do {
    if (restart == 1) {
      printf("%s", "Введите начальную границу X = ");
      scanf("%lf", &x);
      printf("%s", "Введите A = ");
      scanf("%lf", &a);
      printf("%s", "Введите конечную границу Х1 = ");
      scanf("%lf", &x1);
      printf("%s", "Введите размер шага= ");
      scanf("%lf", &step);
      printf("%s", "Введите: \n N = 1 для нахождения значения переменной G. \n "
                   "N = 2 для нахождения значения переменной F. \n N = 3 для "
                   "нахождения значения переменной Y. \n");
      scanf("%i", &n);
      printf("%s", "Включить адаптивный шаг? 1 если да, 0 если нет");
      scanf("%i", &adaptive_step);
      FILE *file;
      file = fopen("text.txt", "w+");
      switch (n) {
      case 1:
        while (x <= x1) {
          if ((5 * pow(a, 2) - 9 * a * x + 4 * pow(x, 4)) != 0) {
            G = (5 * (-10 * pow(a, 2) + 27 * a * x + 28 * pow(x, 2))) /
                (5 * pow(a, 2) - 9 * a * x + 4 * pow(x, 4));
            fprintf(file, "%.2lf\n%.2lf\n", x, G);
            if (j == 0) {
              printf("┌───────────────────┬───────────────────┐\n");
              printf("│         X         │         Y         │\n");
              printf("├───────────────────┼───────────────────┤\n");
            }
            if (adaptive_step == 1) {
              x_values[j] = x;
              y_values[j] = G;
              printf("│%19.3lf│%19.3lf│\n", x, G);
              if (j > 0) {
                if (((y_values[j - 1] / y_values[j]) > 2) ||
                    ((y_values[j] / y_values[j - 1]) > 2)) {
                  x += step / 2;
                } else {
                  if (((y_values[j - 1] / y_values[j]) < 0.5) ||
                      ((y_values[j] / y_values[j - 1]) < 0.5)) {
                    x += step * 2;
                  } else
                    x += step;
                }
              }
            } else {
              x_values[j] = x;
              y_values[j] = G;
              printf("│%19.3lf│%19.3lf│\n", x, G);
              x += step;
            }
            j += 1;
            continue;
          } else
            printf("%s\n", "G не может быть результатом деления на 0. Введите "
                           "другие значения переменных.");
          break;
        }
        if (j != 0) {
          for (i = 0; i < j; i++) {
            if (i == 0) {
              max_x = x_values[i];
              min_x = x_values[i];
              max_y = y_values[i];
              min_y = y_values[i];
            }
            if (max_x < x_values[i])
              max_x = x_values[i];
            if (min_x > x_values[i])
              min_x = x_values[i];
            if (max_y < y_values[i])
              max_y = y_values[i];
            if (min_y > y_values[i])
              min_y = y_values[i];
          }
          printf("├───────────────────┴────┬──────────────┤\n");
          printf("│Максимальное значение Х:│%14.4lf│\n", max_x);
          printf("├────────────────────────┼──────────────┤\n");
          printf("│Минимальное значение Х: │%14.4lf│\n", min_x);
          printf("├────────────────────────┼──────────────┤\n");
          printf("│Максимальное значение Y:│%14.4lf│\n", max_y);
          printf("├────────────────────────┼──────────────┤\n");
          printf("│Минимальное значение Y: │%14.4lf│\n", min_y);
          printf("└────────────────────────┴──────────────┘\n");
        }
        break;
      case 2:
        while (x <= x1) {
          F = sin(28 * pow(a, 2) - 57 * a * x + 14 * pow(x, 2));
          if ((F >= -1) && (F <= 1)) {
            fprintf(file, "%.2lf\n%.2lf\n", x, F);
            if (j == 0) {
              printf("┌───────────────────┬───────────────────┐\n");
              printf("│         X         │         Y         │\n");
              printf("├───────────────────┼───────────────────┤\n");
            }
            if (adaptive_step == 1) {
              x_values[j] = x;
              y_values[j] = F;
              printf("│%11.3lf│%11.3lf│\n", x, F);
              if (j > 0) {
                if (((y_values[j - 1] / y_values[j]) > 2) ||
                    ((y_values[j] / y_values[j - 1]) > 2)) {
                  x += step / 2;
                } else {
                  if (((y_values[j - 1] / y_values[j]) < 0.5) ||
                      ((y_values[j] / y_values[j - 1]) < 0.5)) {
                    x += step * 2;
                  } else
                    x += step;
                }
              }
            } else {
              x_values[j] = x;
              y_values[j] = G;
              printf("│%19.3lf│%19.3lf│\n", x, F);
              x += step;
            }
            j += 1;
            continue;
          }
          printf("%s\n", "Переменная F не принадлежит отрезку синуса от -1 до "
                         "1. Введите другие значения");
          break;
        }
        if (j != 0) {
          for (i = 0; i < j; i++) {
            if (i == 0) {
              max_x = x_values[i];
              min_x = x_values[i];
              max_y = y_values[i];
              min_y = y_values[i];
            }
            if (max_x < x_values[i])
              max_x = x_values[i];
            if (min_x > x_values[i])
              min_x = x_values[i];
            if (max_y < y_values[i])
              max_y = y_values[i];
            if (min_y > y_values[i])
              min_y = y_values[i];
          }
          printf("├───────────────────┴────┬──────────────┤\n");
          printf("│Максимальное значение Х:│%14.4lf│\n", max_x);
          printf("├────────────────────────┼──────────────┤\n");
          printf("│Минимальное значение Х: │%14.4lf│\n", min_x);
          printf("├────────────────────────┼──────────────┤\n");
          printf("│Максимальное значение Y:│%14.4lf│\n", max_y);
          printf("├────────────────────────┼──────────────┤\n");
          printf("│Минимальное значение Y: │%14.4lf│\n", min_y);
          printf("└────────────────────────┴──────────────┘\n");
        }
        break;
      case 3:
        while (x <= x1) {
          Y = log(-27 * pow(a, 2) + 24 * a * x + 35 * pow(x, 2) + 1);
          if (Y > 0) {
            fprintf(file, "%.2lf\n%.2lf\n", x, Y);
            if (j == 0) {
              printf("┌───────────────────┬───────────────────┐\n");
              printf("│         X         │         Y         │\n");
              printf("├───────────────────┼───────────────────┤\n");
            }
            if (adaptive_step == 1) {
              x_values[j] = x;
              y_values[j] = Y;
              printf("│%11.3lf│%11.3lf│\n", x, Y);
              if (j > 0) {
                if (((y_values[j - 1] / y_values[j]) > 2) ||
                    ((y_values[j] / y_values[j - 1]) > 2)) {
                  x += step / 2;
                } else {
                  if (((y_values[j - 1] / y_values[j]) < 0.5) ||
                      ((y_values[j] / y_values[j - 1]) < 0.5)) {
                    x += step * 2;
                  } else
                    x += step;
                }
              }
            } else {
              x_values[j] = x;
              y_values[j] = Y;
              printf("│%19.3lf│%19.3lf│\n", x, Y);
              x += step;
            }
            j += 1;
            continue;
          } else
            printf("%s\n", "Логарифм не может быть найден при таких значениях "
                           "переменных. Введите другие значения переменных.");
          break;
        }
        if (j != 0) {
          for (i = 0; i < j; i++) {
            if (i == 0) {
              max_x = x_values[i];
              min_x = x_values[i];
              max_y = y_values[i];
              min_y = y_values[i];
            }
            if (max_x < x_values[i])
              max_x = x_values[i];
            if (min_x > x_values[i])
              min_x = x_values[i];
            if (max_y < y_values[i])
              max_y = y_values[i];
            if (min_y > y_values[i])
              min_y = y_values[i];
          }
          printf("├───────────────────┴────┬──────────────┤\n");
          printf("│Максимальное значение Х:│%14.4lf│\n", max_x);
          printf("├────────────────────────┼──────────────┤\n");
          printf("│Минимальное значение Х: │%14.4lf│\n", min_x);
          printf("├────────────────────────┼──────────────┤\n");
          printf("│Максимальное значение Y:│%14.4lf│\n", max_y);
          printf("├────────────────────────┼──────────────┤\n");
          printf("│Минимальное значение Y: │%14.4lf│\n", min_y);
          printf("└────────────────────────┴──────────────┘\n");
        }
        break;
      default:
        printf("%s\n", "Ошибка, попросите вывод результата одной из переменных "
                       "G,F или Y.");
      }
    }
    printf("%s", "Хотите ли ещё раз просчитать функцию? \n Введите 1 если "
                 "хотите просчитать заново. \n Введите 0 для отмены.");
    scanf("%i", &restart);
    if (restart == 0)
      break;
    else
      continue;
  } while (1);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd50,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x1,-0x10(%rbp)
cmpl   $0x1,-0x10(%rbp)
jne    22a7 <main+0x1137>
lea    0x1ea7(%rip),%rdi
mov    %rdi,-0xd10(%rbp)
lea    0x1e9c(%rip),%rsi
xor    %eax,%eax
mov    %al,-0xcfd(%rbp)
call   1030 <printf@plt>
mov    -0xcfd(%rbp),%al
lea    0x1eb8(%rip),%rdi
mov    %rdi,-0xd18(%rbp)
lea    -0x38(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0xd10(%rbp),%rdi
mov    -0xcfd(%rbp),%al
lea    0x1e98(%rip),%rsi
call   1030 <printf@plt>
mov    -0xd18(%rbp),%rdi
mov    -0xcfd(%rbp),%al
lea    -0x40(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0xd10(%rbp),%rdi
mov    -0xcfd(%rbp),%al
lea    0x1e7d(%rip),%rsi
call   1030 <printf@plt>
mov    -0xd18(%rbp),%rdi
mov    -0xcfd(%rbp),%al
lea    -0x48(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0xd10(%rbp),%rdi
mov    -0xcfd(%rbp),%al
lea    0x1e84(%rip),%rsi
call   1030 <printf@plt>
mov    -0xd18(%rbp),%rdi
mov    -0xcfd(%rbp),%al
lea    -0x50(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0xd10(%rbp),%rdi
mov    -0xcfd(%rbp),%al
lea    0x1e7c(%rip),%rsi
call   1030 <printf@plt>
mov    -0xcfd(%rbp),%al
lea    0x1f63(%rip),%rdi
mov    %rdi,-0xd08(%rbp)
lea    -0x8(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0xd10(%rbp),%rdi
mov    -0xcfd(%rbp),%al
lea    0x1f42(%rip),%rsi
call   1030 <printf@plt>
mov    -0xd08(%rbp),%rdi
mov    -0xcfd(%rbp),%al
lea    -0x18(%rbp),%rsi
call   1060 <scanf@plt>
lea    0x1f71(%rip),%rdi
lea    0x1f73(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0xcf8(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xcfc(%rbp)
sub    $0x1,%eax
je     1324 <main+0x1b4>
jmp    12fc <main+0x18c>
mov    -0xcfc(%rbp),%eax
sub    $0x2,%eax
je     18e0 <main+0x770>
jmp    1310 <main+0x1a0>
mov    -0xcfc(%rbp),%eax
sub    $0x3,%eax
je     1dc4 <main+0xc54>
jmp    228d <main+0x111d>
jmp    1329 <main+0x1b9>
movsd  -0x38(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     16e7 <main+0x577>
movsd  -0x40(%rbp),%xmm0
mov    $0x2,%edi
call   1090 <pow@plt>
imul   $0x5,%eax,%eax
cvtsi2sd %eax,%xmm1
movsd  0x1cd5(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd20(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mov    $0x4,%edi
call   1090 <pow@plt>
movsd  -0xd20(%rbp),%xmm0
ff
shl    $0x2,%eax
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13c6 <main+0x256>
jp     13c6 <main+0x256>
jmp    16cd <main+0x55d>
movsd  -0x40(%rbp),%xmm0
mov    $0x2,%edi
call   1090 <pow@plt>
imul   $0xfffffff6,%eax,%eax
cvtsi2sd %eax,%xmm1
movsd  0x1c59(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    $0x2,%edi
call   1090 <pow@plt>
movsd  -0xd38(%rbp),%xmm1
ff
imul   $0x1c,%eax,%eax
cvtsi2sd %eax,%xmm0
addsd  %xmm0,%xmm1
movsd  0x1c0d(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd28(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
mov    $0x2,%edi
call   1090 <pow@plt>
imul   $0x5,%eax,%eax
cvtsi2sd %eax,%xmm1
movsd  0x1bdb(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd30(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mov    $0x4,%edi
call   1090 <pow@plt>
movsd  -0xd30(%rbp),%xmm1
ff
movsd  -0xd28(%rbp),%xmm0
ff
shl    $0x2,%eax
cvtsi2sd %eax,%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0xcf8(%rbp),%rdi
movsd  -0x38(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
lea    0x1d7e(%rip),%rsi
call   1040 <fprintf@plt>
cmpl   $0x0,-0x14(%rbp)
jne    150a <main+0x39a>
lea    0x1d75(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1de4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1e07(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0x1,-0x18(%rbp)
jne    1674 <main+0x504>
movsd  -0x38(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0xcd0(%rbp,%rax,8)
ff ff
movsd  -0x20(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0x690(%rbp,%rax,8)
ff ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
lea    0x1e3e(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
cmpl   $0x0,-0x14(%rbp)
jle    166f <main+0x4ff>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movslq -0x14(%rbp),%rax
divsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1a90(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     15ba <main+0x44a>
movslq -0x14(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
divsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1a60(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    15da <main+0x46a>
movsd  -0x50(%rbp),%xmm0
movsd  0x1a49(%rip),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    166a <main+0x4fa>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
movslq -0x14(%rbp),%rax
divsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1a18(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     163a <main+0x4ca>
movslq -0x14(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
divsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
movsd  0x19e8(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1656 <main+0x4e6>
movsd  -0x50(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    1665 <main+0x4f5>
movsd  -0x50(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    166a <main+0x4fa>
jmp    166f <main+0x4ff>
jmp    16bf <main+0x54f>
movsd  -0x38(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0xcd0(%rbp,%rax,8)
ff ff
movsd  -0x20(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0x690(%rbp,%rax,8)
ff ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
lea    0x1cde(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  -0x50(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1329 <main+0x1b9>
lea    0x1ccc(%rip),%rdi
lea    0x1cc9(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    16e7 <main+0x577>
cmpl   $0x0,-0x14(%rbp)
je     18db <main+0x76b>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    183d <main+0x6cd>
cmpl   $0x0,-0xc(%rbp)
jne    1762 <main+0x5f2>
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcd8(%rbp)
ff
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce0(%rbp)
ff
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce8(%rbp)
ff
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcf0(%rbp)
ff
movsd  -0xcd8(%rbp),%xmm1
ff
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
ucomisd %xmm1,%xmm0
jbe    1796 <main+0x626>
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcd8(%rbp)
ff
movsd  -0xce0(%rbp),%xmm0
ff
movslq -0xc(%rbp),%rax
ucomisd -0xcd0(%rbp,%rax,8),%xmm0
ff ff
jbe    17c6 <main+0x656>
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce0(%rbp)
ff
movsd  -0xce8(%rbp),%xmm1
ff
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
ucomisd %xmm1,%xmm0
jbe    17fa <main+0x68a>
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce8(%rbp)
ff
movsd  -0xcf0(%rbp),%xmm0
ff
movslq -0xc(%rbp),%rax
ucomisd -0x690(%rbp,%rax,8),%xmm0
ff ff
jbe    182a <main+0x6ba>
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcf0(%rbp)
ff
jmp    182f <main+0x6bf>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    16f8 <main+0x588>
lea    0x1bec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xcd8(%rbp),%xmm0
ff
lea    0x1c53(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x1c84(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xce0(%rbp),%xmm0
ff
lea    0x1ceb(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x1c60(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xce8(%rbp),%xmm0
ff
lea    0x1d05(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x1c3c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xcf0(%rbp),%xmm0
ff
lea    0x1d1f(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x1d4e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    22a2 <main+0x1132>
jmp    18e5 <main+0x775>
movsd  -0x38(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1bcb <main+0xa5b>
movsd  -0x40(%rbp),%xmm0
mov    $0x2,%edi
call   1090 <pow@plt>
imul   $0x1c,%eax,%eax
cvtsi2sd %eax,%xmm1
movsd  0x1711(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd40(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mov    $0x2,%edi
call   1090 <pow@plt>
movsd  -0xd40(%rbp),%xmm0
ff
imul   $0xe,%eax,%eax
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <sin@plt>
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  0x169b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1bb6 <main+0xa46>
movsd  0x1669(%rip),%xmm0
ucomisd -0x28(%rbp),%xmm0
jb     1bb6 <main+0xa46>
mov    -0xcf8(%rbp),%rdi
movsd  -0x38(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
lea    0x1895(%rip),%rsi
call   1040 <fprintf@plt>
cmpl   $0x0,-0x14(%rbp)
jne    19f3 <main+0x883>
lea    0x188c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x18fb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x191e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0x1,-0x18(%rbp)
jne    1b5d <main+0x9ed>
movsd  -0x38(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0xcd0(%rbp,%rax,8)
ff ff
movsd  -0x28(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0x690(%rbp,%rax,8)
ff ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
lea    0x1c6d(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
cmpl   $0x0,-0x14(%rbp)
jle    1b58 <main+0x9e8>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movslq -0x14(%rbp),%rax
divsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  0x15a7(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1aa3 <main+0x933>
movslq -0x14(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
divsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  0x1577(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1ac3 <main+0x953>
movsd  -0x50(%rbp),%xmm0
movsd  0x1560(%rip),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    1b53 <main+0x9e3>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
movslq -0x14(%rbp),%rax
divsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
movsd  0x152f(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     1b23 <main+0x9b3>
movslq -0x14(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
divsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
movsd  0x14ff(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1b3f <main+0x9cf>
movsd  -0x50(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    1b4e <main+0x9de>
movsd  -0x50(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    1b53 <main+0x9e3>
jmp    1b58 <main+0x9e8>
jmp    1ba8 <main+0xa38>
movsd  -0x38(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0xcd0(%rbp,%rax,8)
ff ff
movsd  -0x20(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0x690(%rbp,%rax,8)
ff ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm1
lea    0x17f5(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  -0x50(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    18e5 <main+0x775>
lea    0x17e3(%rip),%rdi
lea    0x1af4(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0x0,-0x14(%rbp)
je     1dbf <main+0xc4f>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d21 <main+0xbb1>
cmpl   $0x0,-0xc(%rbp)
jne    1c46 <main+0xad6>
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcd8(%rbp)
ff
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce0(%rbp)
ff
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce8(%rbp)
ff
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcf0(%rbp)
ff
movsd  -0xcd8(%rbp),%xmm1
ff
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
ucomisd %xmm1,%xmm0
jbe    1c7a <main+0xb0a>
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcd8(%rbp)
ff
movsd  -0xce0(%rbp),%xmm0
ff
movslq -0xc(%rbp),%rax
ucomisd -0xcd0(%rbp,%rax,8),%xmm0
ff ff
jbe    1caa <main+0xb3a>
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce0(%rbp)
ff
movsd  -0xce8(%rbp),%xmm1
ff
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
ucomisd %xmm1,%xmm0
jbe    1cde <main+0xb6e>
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce8(%rbp)
ff
movsd  -0xcf0(%rbp),%xmm0
ff
movslq -0xc(%rbp),%rax
ucomisd -0x690(%rbp,%rax,8),%xmm0
ff ff
jbe    1d0e <main+0xb9e>
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcf0(%rbp)
ff
jmp    1d13 <main+0xba3>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1bdc <main+0xa6c>
lea    0x1708(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xcd8(%rbp),%xmm0
ff
lea    0x176f(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x17a0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xce0(%rbp),%xmm0
ff
lea    0x1807(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x177c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xce8(%rbp),%xmm0
ff
lea    0x1821(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x1758(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xcf0(%rbp),%xmm0
ff
lea    0x183b(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x186a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    22a2 <main+0x1132>
jmp    1dc9 <main+0xc59>
movsd  -0x38(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     2094 <main+0xf24>
movsd  -0x40(%rbp),%xmm0
mov    $0x2,%edi
call   1090 <pow@plt>
imul   $0xffffffe5,%eax,%eax
cvtsi2sd %eax,%xmm1
movsd  0x120a(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd48(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mov    $0x2,%edi
call   1090 <pow@plt>
movsd  -0xd48(%rbp),%xmm0
ff
imul   $0x23,%eax,%eax
cvtsi2sd %eax,%xmm1
addsd  %xmm1,%xmm0
movsd  0x11be(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1070 <log@plt>
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    207a <main+0xf0a>
mov    -0xcf8(%rbp),%rdi
movsd  -0x38(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
lea    0x13d1(%rip),%rsi
call   1040 <fprintf@plt>
cmpl   $0x0,-0x14(%rbp)
jne    1eb7 <main+0xd47>
lea    0x13c8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1437(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x145a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0x1,-0x18(%rbp)
jne    2021 <main+0xeb1>
movsd  -0x38(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0xcd0(%rbp,%rax,8)
ff ff
movsd  -0x30(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0x690(%rbp,%rax,8)
ff ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
lea    0x17a9(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
cmpl   $0x0,-0x14(%rbp)
jle    201c <main+0xeac>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movslq -0x14(%rbp),%rax
divsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  0x10e3(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1f67 <main+0xdf7>
movslq -0x14(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
divsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  0x10b3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1f87 <main+0xe17>
movsd  -0x50(%rbp),%xmm0
movsd  0x109c(%rip),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    2017 <main+0xea7>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
movslq -0x14(%rbp),%rax
divsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
movsd  0x106b(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     1fe7 <main+0xe77>
movslq -0x14(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
divsd  -0x690(%rbp,%rax,8),%xmm1
ff ff
movsd  0x103b(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    2003 <main+0xe93>
movsd  -0x50(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    2012 <main+0xea2>
movsd  -0x50(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    2017 <main+0xea7>
jmp    201c <main+0xeac>
jmp    206c <main+0xefc>
movsd  -0x38(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0xcd0(%rbp,%rax,8)
ff ff
movsd  -0x30(%rbp),%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0x690(%rbp,%rax,8)
ff ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm1
lea    0x1331(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  -0x50(%rbp),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1dc9 <main+0xc59>
lea    0x131f(%rip),%rdi
lea    0x16bc(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    2094 <main+0xf24>
cmpl   $0x0,-0x14(%rbp)
je     2288 <main+0x1118>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    21ea <main+0x107a>
cmpl   $0x0,-0xc(%rbp)
jne    210f <main+0xf9f>
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcd8(%rbp)
ff
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce0(%rbp)
ff
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce8(%rbp)
ff
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcf0(%rbp)
ff
movsd  -0xcd8(%rbp),%xmm1
ff
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
ucomisd %xmm1,%xmm0
jbe    2143 <main+0xfd3>
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcd8(%rbp)
ff
movsd  -0xce0(%rbp),%xmm0
ff
movslq -0xc(%rbp),%rax
ucomisd -0xcd0(%rbp,%rax,8),%xmm0
ff ff
jbe    2173 <main+0x1003>
movslq -0xc(%rbp),%rax
movsd  -0xcd0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce0(%rbp)
ff
movsd  -0xce8(%rbp),%xmm1
ff
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
ucomisd %xmm1,%xmm0
jbe    21a7 <main+0x1037>
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xce8(%rbp)
ff
movsd  -0xcf0(%rbp),%xmm0
ff
movslq -0xc(%rbp),%rax
ucomisd -0x690(%rbp,%rax,8),%xmm0
ff ff
jbe    21d7 <main+0x1067>
movslq -0xc(%rbp),%rax
movsd  -0x690(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0xcf0(%rbp)
ff
jmp    21dc <main+0x106c>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    20a5 <main+0xf35>
lea    0x123f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xcd8(%rbp),%xmm0
ff
lea    0x12a6(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x12d7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xce0(%rbp),%xmm0
ff
lea    0x133e(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x12b3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xce8(%rbp),%xmm0
ff
lea    0x1358(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x128f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0xcf0(%rbp),%xmm0
ff
lea    0x1372(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0x13a1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    22a2 <main+0x1132>
lea    0x110c(%rip),%rdi
lea    0x155e(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    22a7 <main+0x1137>
lea    0xd9a(%rip),%rdi
lea    0x15b8(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf2c(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x0,%al
call   1060 <scanf@plt>
cmpl   $0x0,-0x10(%rbp)
jne    22dd <main+0x116d>
jmp    22f1 <main+0x1181>
jmp    22e2 <main+0x1172>
mov    $0x1,%al
test   $0x1,%al
jne    1190 <main+0x20>
jmp    22f1 <main+0x1181>
xor    %eax,%eax
add    $0xd50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xce8,%rsp
mov    $0xffffffff,%r12d
movl   $0x1,0x58(%rsp)
mov    $0x1,%eax
lea    0xea5(%rip),%rbx
lea    0xf4c(%rip),%r13
lea    0x131d(%rip),%r14
xor    %r15d,%r15d
jmp    11f8 <main+0x78>
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r13,%rdi
lea    0x58(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
mov    0x58(%rsp),%eax
test   %eax,%eax
je     1dfc <main+0xc7c>
cmp    $0x1,%eax
jne    11d0 <main+0x50>
mov    %rbx,%rdi
lea    0xe4c(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe74(%rip),%rbp
mov    %rbp,%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
mov    %rbx,%rdi
lea    0xe61(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbp,%rdi
lea    0x18(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
mov    %rbx,%rdi
lea    0xe55(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbp,%rdi
lea    0x50(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
mov    %rbx,%rdi
lea    0xe6b(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbp,%rdi
lea    0x40(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
lea    0x1306(%rip),%rdi
call   1030 <puts@plt>
mov    %r13,%rdi
lea    0x5c(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
mov    %rbx,%rdi
lea    0xe5a(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r13,%r14
mov    %r13,%rdi
lea    0x4c(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
lea    0xe8b(%rip),%rdi
lea    0xe8d(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,%r13
mov    0x5c(%rsp),%eax
cmp    $0x1,%eax
je     14bc <main+0x33c>
cmp    $0x2,%eax
je     17b8 <main+0x638>
cmp    $0x3,%eax
jne    199f <main+0x81f>
movsd  0x50(%rsp),%xmm0
ucomisd (%rsp),%xmm0
jb     1a3b <main+0x8bb>
movslq %r15d,%r15
lea    0xe4e(%rip),%rbx
jmp    1334 <main+0x1b4>
movsd  (%rsp),%xmm0
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15
movsd  0x50(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jb     1a3b <main+0x8bb>
movsd  0x18(%rsp),%xmm0
mov    $0x2,%edi
call   10a0 <pow@plt>
imul   $0xffffffe5,%eax,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  0x18(%rsp),%xmm2
mulsd  0xca4(%rip),%xmm2
movsd  (%rsp),%xmm0
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rsp)
mov    $0x2,%edi
call   10a0 <pow@plt>
imul   $0x23,%eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x8(%rsp),%xmm0
addsd  0xc77(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1080 <log@plt>
ucomisd 0xca6(%rip),%xmm0
jbe    1a2f <main+0x8af>
movapd %xmm0,%xmm1
movsd  (%rsp),%xmm0
mov    %r13,%rdi
mov    %rbx,%rsi
movsd  %xmm1,0x8(%rsp)
call   1050 <fprintf@plt>
test   %r15,%r15
jne    13eb <main+0x26b>
lea    0x142d(%rip),%rdi
call   1030 <puts@plt>
lea    0x149d(%rip),%rdi
call   1030 <puts@plt>
lea    0x14c1(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x1,0x4c(%rsp)
movsd  (%rsp),%xmm0
movsd  %xmm0,0x6a0(%rsp,%r15,8)
movsd  0x8(%rsp),%xmm1
movsd  %xmm1,0x60(%rsp,%r15,8)
jne    1470 <main+0x2f0>
lea    0xef3(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
test   %r15,%r15
jle    1312 <main+0x192>
lea    (%r15,%r12,1),%eax
movsd  0x60(%rsp,%rax,8),%xmm1
movapd %xmm1,%xmm0
movsd  0x8(%rsp),%xmm3
divsd  %xmm3,%xmm0
ucomisd 0xbcb(%rip),%xmm0
ja     1455 <main+0x2d5>
divsd  %xmm1,%xmm3
ucomisd 0xbbd(%rip),%xmm3
jbe    1493 <main+0x313>
movsd  0x40(%rsp),%xmm0
mulsd  0xbb5(%rip),%xmm0
jmp    1484 <main+0x304>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0xcf4(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x40(%rsp),%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
jmp    1320 <main+0x1a0>
movsd  0xb7d(%rip),%xmm2
ucomisd %xmm0,%xmm2
movsd  0x40(%rsp),%xmm0
movsd  (%rsp),%xmm1
ja     14b2 <main+0x332>
ucomisd %xmm3,%xmm2
jbe    14b6 <main+0x336>
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
jmp    1489 <main+0x309>
movsd  0x50(%rsp),%xmm0
ucomisd (%rsp),%xmm0
jb     19d1 <main+0x851>
movslq %r15d,%rbp
movsd  0x18(%rsp),%xmm0
mov    $0x2,%edi
call   10a0 <pow@plt>
lea    (%rax,%rax,4),%eax
cvtsi2sd %eax,%xmm1
movsd  (%rsp),%xmm0
movsd  0x18(%rsp),%xmm2
mulsd  0xb36(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rsp)
mov    $0x4,%edi
call   10a0 <pow@plt>
shl    $0x2,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x8(%rsp),%xmm0
ucomisd 0xb1e(%rip),%xmm0
lea    0xc2d(%rip),%rbx
jne    1539 <main+0x3b9>
jnp    19bc <main+0x83c>
add    $0x1,%r15d
nopl   (%rax)
movsd  0x18(%rsp),%xmm0
mov    $0x2,%edi
call   10a0 <pow@plt>
add    %eax,%eax
lea    (%rax,%rax,4),%eax
neg    %eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  0x18(%rsp),%xmm2
mulsd  0xacc(%rip),%xmm2
movsd  (%rsp),%xmm0
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x10(%rsp)
mov    $0x2,%edi
call   10a0 <pow@plt>
lea    (%rax,%rax,8),%ecx
lea    (%rcx,%rcx,2),%ecx
add    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
addsd  0x10(%rsp),%xmm0
mulsd  0xa9a(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x18(%rsp),%xmm0
mov    $0x2,%edi
call   10a0 <pow@plt>
lea    (%rax,%rax,4),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  (%rsp),%xmm0
movsd  0x18(%rsp),%xmm2
mulsd  0xa57(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rsp)
mov    $0x4,%edi
call   10a0 <pow@plt>
shl    $0x2,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  (%rsp),%xmm0
mov    %r13,%rdi
mov    %rbx,%rsi
movsd  %xmm1,0x10(%rsp)
call   1050 <fprintf@plt>
test   %rbp,%rbp
jne    164a <main+0x4ca>
lea    0x11ce(%rip),%rdi
call   1030 <puts@plt>
lea    0x123e(%rip),%rdi
call   1030 <puts@plt>
lea    0x1262(%rip),%rdi
call   1030 <puts@plt>
mov    0x4c(%rsp),%r12d
movsd  (%rsp),%xmm0
movsd  %xmm0,0x6a0(%rsp,%rbp,8)
movsd  0x10(%rsp),%xmm1
movsd  %xmm1,0x60(%rsp,%rbp,8)
lea    0xafb(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
cmp    $0x1,%r12d
jne    16e0 <main+0x560>
test   %rbp,%rbp
jle    16f2 <main+0x572>
mov    $0xffffffff,%eax
add    %ebp,%eax
movsd  0x60(%rsp,%rax,8),%xmm1
movapd %xmm1,%xmm0
movsd  0x10(%rsp),%xmm4
divsd  %xmm4,%xmm0
movsd  0x96b(%rip),%xmm3
ucomisd %xmm3,%xmm0
ja     16bd <main+0x53d>
movapd %xmm4,%xmm2
divsd  %xmm1,%xmm2
ucomisd %xmm3,%xmm2
jbe    1787 <main+0x607>
movsd  0x40(%rsp),%xmm0
mulsd  0x94d(%rip),%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
jmp    16fd <main+0x57d>
nopw   0x0(%rax,%rax,1)
movsd  0x40(%rsp),%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
jmp    16f7 <main+0x577>
movsd  (%rsp),%xmm0
movsd  0x10(%rsp),%xmm4
movsd  0x50(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jb     1bd6 <main+0xa56>
movsd  0x18(%rsp),%xmm0
mov    $0x2,%edi
call   10a0 <pow@plt>
lea    (%rax,%rax,4),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  (%rsp),%xmm0
movsd  0x18(%rsp),%xmm3
movsd  0x8f6(%rip),%xmm2
mulsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,0x8(%rsp)
mov    $0x4,%edi
call   10a0 <pow@plt>
shl    $0x2,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x8(%rsp),%xmm0
add    $0x1,%r15d
add    $0x1,%rbp
ucomisd 0x8d2(%rip),%xmm0
jne    1540 <main+0x3c0>
jp     1540 <main+0x3c0>
jmp    19bc <main+0x83c>
movsd  0x889(%rip),%xmm3
ucomisd %xmm0,%xmm3
movsd  0x40(%rsp),%xmm0
movsd  (%rsp),%xmm1
ja     17a6 <main+0x626>
ucomisd %xmm2,%xmm3
jbe    17aa <main+0x62a>
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsp)
jmp    16fd <main+0x57d>
movsd  0x50(%rsp),%xmm0
ucomisd (%rsp),%xmm0
jb     1b2b <main+0x9ab>
movslq %r15d,%r15
lea    0x98b(%rip),%rbx
jmp    17f4 <main+0x674>
movsd  (%rsp),%xmm0
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15
movsd  0x50(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jb     1b2b <main+0x9ab>
movsd  0x18(%rsp),%xmm0
mov    $0x2,%edi
call   10a0 <pow@plt>
lea    (%rax,%rax,8),%ecx
lea    (%rcx,%rcx,2),%ecx
add    %eax,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
movsd  (%rsp),%xmm0
movsd  0x18(%rsp),%xmm2
mulsd  0x7fa(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rsp)
mov    $0x2,%edi
call   10a0 <pow@plt>
mov    %eax,%ecx
shl    $0x4,%ecx
sub    %eax,%ecx
sub    %eax,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
addsd  0x8(%rsp),%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sin@plt>
ucomisd 0x7c3(%rip),%xmm0
jb     1b1f <main+0x99f>
movapd %xmm0,%xmm1
movsd  0x791(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1b1f <main+0x99f>
movsd  (%rsp),%xmm0
mov    %r13,%rdi
mov    %rbx,%rsi
movsd  %xmm1,0x8(%rsp)
call   1050 <fprintf@plt>
test   %r15,%r15
jne    18c0 <main+0x740>
lea    0xf58(%rip),%rdi
call   1030 <puts@plt>
lea    0xfc8(%rip),%rdi
call   1030 <puts@plt>
lea    0xfec(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x1,0x4c(%rsp)
movsd  (%rsp),%xmm0
movsd  %xmm0,0x6a0(%rsp,%r15,8)
jne    1940 <main+0x7c0>
movsd  0x8(%rsp),%xmm1
movsd  %xmm1,0x60(%rsp,%r15,8)
lea    0xa1e(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
test   %r15,%r15
jle    17d5 <main+0x655>
lea    (%r15,%r12,1),%eax
movsd  0x60(%rsp,%rax,8),%xmm1
movapd %xmm1,%xmm0
movsd  0x8(%rsp),%xmm3
divsd  %xmm3,%xmm0
ucomisd 0x6f6(%rip),%xmm0
ja     192a <main+0x7aa>
divsd  %xmm1,%xmm3
ucomisd 0x6e8(%rip),%xmm3
jbe    1976 <main+0x7f6>
movsd  0x40(%rsp),%xmm0
mulsd  0x6e0(%rip),%xmm0
jmp    1967 <main+0x7e7>
nopw   0x0(%rax,%rax,1)
movsd  0x10(%rsp),%xmm1
movsd  %xmm1,0x60(%rsp,%r15,8)
lea    0x817(%rip),%rdi
movsd  0x8(%rsp),%xmm1
mov    $0x2,%al
call   1040 <printf@plt>
movsd  0x40(%rsp),%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
jmp    17e0 <main+0x660>
movsd  0x69a(%rip),%xmm2
ucomisd %xmm0,%xmm2
movsd  0x40(%rsp),%xmm0
movsd  (%rsp),%xmm1
ja     1995 <main+0x815>
ucomisd %xmm3,%xmm2
jbe    1999 <main+0x819>
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
jmp    196c <main+0x7ec>
lea    0xabc(%rip),%rdi
mov    %r14,%r13
lea    0x6a0(%rip),%rbx
lea    0xb1f(%rip),%r14
jmp    1df2 <main+0xc72>
lea    0x7c1(%rip),%rdi
call   1030 <puts@plt>
mov    %ebp,%r15d
mov    $0xffffffff,%r12d
mov    %r14,%r13
lea    0x675(%rip),%rbx
lea    0xaf4(%rip),%r14
movsd  0x10(%rsp),%xmm4
test   %r15d,%r15d
movsd  %xmm4,0x10(%rsp)
je     11be <main+0x3e>
jle    1d70 <main+0xbf0>
movsd  0x6a0(%rsp),%xmm5
movsd  0x60(%rsp),%xmm8
cmp    $0x1,%r15d
jne    1b80 <main+0xa00>
movsd  %xmm5,0x28(%rsp)
movsd  %xmm8,0x20(%rsp)
movsd  %xmm5,0x38(%rsp)
jmp    1b74 <main+0x9f4>
lea    0x977(%rip),%rdi
call   1030 <puts@plt>
mov    %r14,%r13
lea    0x60b(%rip),%rbx
lea    0xa8a(%rip),%r14
test   %r15d,%r15d
je     11be <main+0x3e>
jle    1d70 <main+0xbf0>
movsd  0x6a0(%rsp),%xmm4
movsd  0x60(%rsp),%xmm8
cmp    $0x1,%r15d
je     1b61 <main+0x9e1>
mov    %r15d,%eax
add    $0xffffffffffffffff,%rax
mov    $0x1,%ecx
cmp    $0x2,%r15d
je     1bbf <main+0xa3f>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
movapd %xmm8,%xmm0
movapd %xmm4,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x6a0(%rsp,%rcx,8),%xmm2
movsd  0x6a8(%rsp,%rcx,8),%xmm7
movapd %xmm2,%xmm3
maxsd  %xmm1,%xmm3
minsd  %xmm4,%xmm2
movsd  0x60(%rsp,%rcx,8),%xmm4
movsd  0x68(%rsp,%rcx,8),%xmm6
movapd %xmm4,%xmm5
maxsd  %xmm0,%xmm5
minsd  %xmm8,%xmm4
movapd %xmm7,%xmm1
maxsd  %xmm3,%xmm1
minsd  %xmm2,%xmm7
movapd %xmm6,%xmm0
maxsd  %xmm5,%xmm0
minsd  %xmm4,%xmm6
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
movapd %xmm6,%xmm8
movapd %xmm7,%xmm4
cmp    $0x1,%rsi
jne    1ab0 <main+0x930>
jmp    1d0a <main+0xb8a>
lea    0x7fb(%rip),%rdi
call   1030 <puts@plt>
mov    %r14,%r13
lea    0x51b(%rip),%rbx
lea    0x99a(%rip),%r14
test   %r15d,%r15d
je     11be <main+0x3e>
jle    1d70 <main+0xbf0>
movsd  0x6a0(%rsp),%xmm4
movsd  0x60(%rsp),%xmm8
cmp    $0x1,%r15d
jne    1ba9 <main+0xa29>
movsd  %xmm4,0x28(%rsp)
movsd  %xmm8,0x20(%rsp)
movsd  %xmm4,0x38(%rsp)
movsd  %xmm8,0x30(%rsp)
jmp    1d70 <main+0xbf0>
mov    %r15d,%eax
add    $0xffffffffffffffff,%rax
mov    $0x1,%ecx
cmp    $0x2,%r15d
jne    1bf2 <main+0xa72>
movapd %xmm8,%xmm6
movapd %xmm8,%xmm0
movapd %xmm5,%xmm7
movapd %xmm5,%xmm1
jmp    1d0a <main+0xb8a>
mov    %r15d,%eax
add    $0xffffffffffffffff,%rax
mov    $0x1,%ecx
cmp    $0x2,%r15d
jne    1c7f <main+0xaff>
movapd %xmm8,%xmm6
movapd %xmm8,%xmm0
movapd %xmm4,%xmm7
movapd %xmm4,%xmm1
jmp    1d0a <main+0xb8a>
mov    $0xffffffff,%r12d
mov    %r14,%r13
lea    0x46a(%rip),%rbx
lea    0x8e9(%rip),%r14
jmp    19e8 <main+0x868>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
movapd %xmm8,%xmm0
movapd %xmm5,%xmm1
nopw   0x0(%rax,%rax,1)
movsd  0x6a0(%rsp,%rcx,8),%xmm2
movsd  0x6a8(%rsp,%rcx,8),%xmm7
movapd %xmm2,%xmm3
maxsd  %xmm1,%xmm3
minsd  %xmm5,%xmm2
movsd  0x60(%rsp,%rcx,8),%xmm4
movsd  0x68(%rsp,%rcx,8),%xmm6
movapd %xmm4,%xmm5
maxsd  %xmm0,%xmm5
minsd  %xmm8,%xmm4
movapd %xmm7,%xmm1
maxsd  %xmm3,%xmm1
minsd  %xmm2,%xmm7
movapd %xmm6,%xmm0
maxsd  %xmm5,%xmm0
minsd  %xmm4,%xmm6
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
movapd %xmm6,%xmm8
movapd %xmm7,%xmm5
cmp    $0x1,%rsi
jne    1c10 <main+0xa90>
jmp    1d0a <main+0xb8a>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
movapd %xmm8,%xmm0
movapd %xmm4,%xmm1
nopw   0x0(%rax,%rax,1)
movsd  0x6a0(%rsp,%rcx,8),%xmm2
movsd  0x6a8(%rsp,%rcx,8),%xmm7
movapd %xmm2,%xmm3
maxsd  %xmm1,%xmm3
minsd  %xmm4,%xmm2
movsd  0x60(%rsp,%rcx,8),%xmm4
movsd  0x68(%rsp,%rcx,8),%xmm6
movapd %xmm4,%xmm5
maxsd  %xmm0,%xmm5
minsd  %xmm8,%xmm4
movapd %xmm7,%xmm1
maxsd  %xmm3,%xmm1
minsd  %xmm2,%xmm7
movapd %xmm6,%xmm0
maxsd  %xmm5,%xmm0
minsd  %xmm4,%xmm6
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
movapd %xmm6,%xmm8
movapd %xmm7,%xmm4
cmp    $0x1,%rsi
jne    1ca0 <main+0xb20>
test   $0x1,%al
jne    1d28 <main+0xba8>
movsd  %xmm1,0x38(%rsp)
movsd  %xmm0,0x30(%rsp)
movsd  %xmm7,0x28(%rsp)
movsd  %xmm6,0x20(%rsp)
jmp    1d70 <main+0xbf0>
movsd  0x6a0(%rsp,%rcx,8),%xmm2
movapd %xmm2,%xmm3
maxsd  %xmm1,%xmm3
movsd  %xmm3,0x38(%rsp)
minsd  %xmm7,%xmm2
movsd  0x60(%rsp,%rcx,8),%xmm1
movapd %xmm1,%xmm3
maxsd  %xmm0,%xmm3
movsd  %xmm3,0x30(%rsp)
minsd  %xmm6,%xmm1
movsd  %xmm2,0x28(%rsp)
movsd  %xmm1,0x20(%rsp)
nopw   0x0(%rax,%rax,1)
lea    0x910(%rip),%rdi
call   1030 <puts@plt>
lea    0x48d(%rip),%rdi
movsd  0x38(%rsp),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
lea    0x96c(%rip),%rbp
mov    %rbp,%rdi
call   1030 <puts@plt>
lea    0x4a9(%rip),%rdi
movsd  0x28(%rsp),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
mov    %rbp,%rdi
call   1030 <puts@plt>
lea    0x4cb(%rip),%rdi
movsd  0x30(%rsp),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
mov    %rbp,%rdi
call   1030 <puts@plt>
lea    0x4ed(%rip),%rdi
movsd  0x20(%rsp),%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
lea    0x98d(%rip),%rdi
call   1030 <puts@plt>
jmp    11d0 <main+0x50>
xor    %eax,%eax
add    $0xce8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [3 x i8] c"%s\00"
@.str.1 = [54 x i8] c"\D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 \D0\BD\D0\B0\D1\87\D0\B0\D0\BB\D1\8C\D0\BD\D1\83\D1\8E \D0\B3\D1\80\D0\B0\D0\BD\D0\B8\D1\86\D1\83 X = \00"
@.str.2 = [4 x i8] c"%lf\00"
@.str.3 = [20 x i8] c"\D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 A = \00"
@.str.4 = [54 x i8] c"\D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 \D0\BA\D0\BE\D0\BD\D0\B5\D1\87\D0\BD\D1\83\D1\8E \D0\B3\D1\80\D0\B0\D0\BD\D0\B8\D1\86\D1\83 \D0\A51 = \00"
@.str.5 = [39 x i8] c"\D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 \D1\80\D0\B0\D0\B7\D0\BC\D0\B5\D1\80 \D1\88\D0\B0\D0\B3\D0\B0= \00"
@.str.7 = [3 x i8] c"%i\00"
@.str.8 = [81 x i8] c"\D0\92\D0\BA\D0\BB\D1\8E\D1\87\D0\B8\D1\82\D1\8C \D0\B0\D0\B4\D0\B0\D0\BF\D1\82\D0\B8\D0\B2\D0\BD\D1\8B\D0\B9 \D1\88\D0\B0\D0\B3? 1 \D0\B5\D1\81\D0\BB\D0\B8 \D0\B4\D0\B0, 0 \D0\B5\D1\81\D0\BB\D0\B8 \D0\BD\D0\B5\D1\82\00"
@.str.9 = [9 x i8] c"text.txt\00"
@.str.10 = [3 x i8] c"w+\00"
@.str.11 = [13 x i8] c"%.2lf\0A%.2lf\0A\00"
@.str.15 = [25 x i8] c"\E2\94\82%19.3lf\E2\94\82%19.3lf\E2\94\82\0A\00"
@.str.17 = [140 x i8] c"G \D0\BD\D0\B5 \D0\BC\D0\BE\D0\B6\D0\B5\D1\82 \D0\B1\D1\8B\D1\82\D1\8C \D1\80\D0\B5\D0\B7\D1\83\D0\BB\D1\8C\D1\82\D0\B0\D1\82\D0\BE\D0\BC \D0\B4\D0\B5\D0\BB\D0\B5\D0\BD\D0\B8\D1\8F \D0\BD\D0\B0 0. \D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 \D0\B4\D1\80\D1\83\D0\B3\D0\B8\D0\B5 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D1\8F \D0\BF\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D1\8B\D1\85.\00"
@.str.19 = [63 x i8] c"\E2\94\82\D0\9C\D0\B0\D0\BA\D1\81\D0\B8\D0\BC\D0\B0\D0\BB\D1\8C\D0\BD\D0\BE\D0\B5 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D0\B5 \D0\A5:\E2\94\82%14.4lf\E2\94\82\0A\00"
@.str.21 = [62 x i8] c"\E2\94\82\D0\9C\D0\B8\D0\BD\D0\B8\D0\BC\D0\B0\D0\BB\D1\8C\D0\BD\D0\BE\D0\B5 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D0\B5 \D0\A5: \E2\94\82%14.4lf\E2\94\82\0A\00"
@.str.22 = [62 x i8] c"\E2\94\82\D0\9C\D0\B0\D0\BA\D1\81\D0\B8\D0\BC\D0\B0\D0\BB\D1\8C\D0\BD\D0\BE\D0\B5 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D0\B5 Y:\E2\94\82%14.4lf\E2\94\82\0A\00"
@.str.23 = [61 x i8] c"\E2\94\82\D0\9C\D0\B8\D0\BD\D0\B8\D0\BC\D0\B0\D0\BB\D1\8C\D0\BD\D0\BE\D0\B5 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D0\B5 Y: \E2\94\82%14.4lf\E2\94\82\0A\00"
@.str.25 = [25 x i8] c"\E2\94\82%11.3lf\E2\94\82%11.3lf\E2\94\82\0A\00"
@.str.26 = [140 x i8] c"\D0\9F\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D0\B0\D1\8F F \D0\BD\D0\B5 \D0\BF\D1\80\D0\B8\D0\BD\D0\B0\D0\B4\D0\BB\D0\B5\D0\B6\D0\B8\D1\82 \D0\BE\D1\82\D1\80\D0\B5\D0\B7\D0\BA\D1\83 \D1\81\D0\B8\D0\BD\D1\83\D1\81\D0\B0 \D0\BE\D1\82 -1 \D0\B4\D0\BE 1. \D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 \D0\B4\D1\80\D1\83\D0\B3\D0\B8\D0\B5 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D1\8F\00"
@.str.27 = [181 x i8] c"\D0\9B\D0\BE\D0\B3\D0\B0\D1\80\D0\B8\D1\84\D0\BC \D0\BD\D0\B5 \D0\BC\D0\BE\D0\B6\D0\B5\D1\82 \D0\B1\D1\8B\D1\82\D1\8C \D0\BD\D0\B0\D0\B9\D0\B4\D0\B5\D0\BD \D0\BF\D1\80\D0\B8 \D1\82\D0\B0\D0\BA\D0\B8\D1\85 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D1\8F\D1\85 \D0\BF\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D1\8B\D1\85. \D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 \D0\B4\D1\80\D1\83\D0\B3\D0\B8\D0\B5 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D1\8F \D0\BF\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D1\8B\D1\85.\00"
@.str.28 = [116 x i8] c"\D0\9E\D1\88\D0\B8\D0\B1\D0\BA\D0\B0, \D0\BF\D0\BE\D0\BF\D1\80\D0\BE\D1\81\D0\B8\D1\82\D0\B5 \D0\B2\D1\8B\D0\B2\D0\BE\D0\B4 \D1\80\D0\B5\D0\B7\D1\83\D0\BB\D1\8C\D1\82\D0\B0\D1\82\D0\B0 \D0\BE\D0\B4\D0\BD\D0\BE\D0\B9 \D0\B8\D0\B7 \D0\BF\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D1\8B\D1\85 G,F \D0\B8\D0\BB\D0\B8 Y.\00"
@.str.29 = [185 x i8] c"\D0\A5\D0\BE\D1\82\D0\B8\D1\82\D0\B5 \D0\BB\D0\B8 \D0\B5\D1\89\D1\91 \D1\80\D0\B0\D0\B7 \D0\BF\D1\80\D0\BE\D1\81\D1\87\D0\B8\D1\82\D0\B0\D1\82\D1\8C \D1\84\D1\83\D0\BD\D0\BA\D1\86\D0\B8\D1\8E? \0A \D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 1 \D0\B5\D1\81\D0\BB\D0\B8 \D1\85\D0\BE\D1\82\D0\B8\D1\82\D0\B5 \D0\BF\D1\80\D0\BE\D1\81\D1\87\D0\B8\D1\82\D0\B0\D1\82\D1\8C \D0\B7\D0\B0\D0\BD\D0\BE\D0\B2\D0\BE. \0A \D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 0 \D0\B4\D0\BB\D1\8F \D0\BE\D1\82\D0\BC\D0\B5\D0\BD\D1\8B.\00"
@str = [248 x i8] c"\D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5: \0A N = 1 \D0\B4\D0\BB\D1\8F \D0\BD\D0\B0\D1\85\D0\BE\D0\B6\D0\B4\D0\B5\D0\BD\D0\B8\D1\8F \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D1\8F \D0\BF\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D0\BE\D0\B9 G. \0A N = 2 \D0\B4\D0\BB\D1\8F \D0\BD\D0\B0\D1\85\D0\BE\D0\B6\D0\B4\D0\B5\D0\BD\D0\B8\D1\8F \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D1\8F \D0\BF\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D0\BE\D0\B9 F. \0A N = 3 \D0\B4\D0\BB\D1\8F \D0\BD\D0\B0\D1\85\D0\BE\D0\B6\D0\B4\D0\B5\D0\BD\D0\B8\D1\8F \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D1\8F \D0\BF\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D0\BE\D0\B9 Y. \00"
@str.46 = [124 x i8] c"\E2\94\9C\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\B4\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\AC\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\A4\00"
@str.49 = [124 x i8] c"\E2\94\9C\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\BC\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\A4\00"
@str.50 = [124 x i8] c"\E2\94\94\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\B4\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\98\00"
@str.51 = [124 x i8] c"\E2\94\8C\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\AC\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\90\00"
@str.52 = [48 x i8] c"\E2\94\82 X \E2\94\82 Y \E2\94\82\00"
@str.53 = [124 x i8] c"\E2\94\9C\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\BC\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\80\E2\94\A4\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca [200 x double]
%9 = alloca [200 x double]
%10 = bitcast i32* %1 to i8*
%11 = bitcast i32* %2 to i8*
%12 = bitcast i32* %3 to i8*
%13 = bitcast double* %4 to i8*
%14 = bitcast double* %5 to i8*
%15 = bitcast double* %6 to i8*
%16 = bitcast double* %7 to i8*
%17 = bitcast [200 x double]* %8 to i8*
%18 = bitcast [200 x double]* %9 to i8*
store i32 1, i32* %2
%19 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 0
%20 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 0
br label %21
21: ; preds = %587, %0
%22 = phi i32 [ %596, %587 ], [ 1, %0 ]
%23 = phi double [ %588, %587 ], [ undef, %0 ]
%24 = phi i32 [ %589, %587 ], [ 0, %0 ]
%25 = phi double [ %590, %587 ], [ undef, %0 ]
%26 = phi double [ %591, %587 ], [ undef, %0 ]
%27 = phi double [ %592, %587 ], [ undef, %0 ]
%28 = phi double [ %593, %587 ], [ undef, %0 ]
%29 = icmp eq i32 %22, 1
br i1 %29, label %30, label %587
30: ; preds = %21
%31 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.1, i64 0, i64 0))
%32 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double* %4)
%33 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.3, i64 0, i64 0))
%34 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double* %5)
%35 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.4, i64 0, i64 0))
%36 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double* %6)
%37 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.5, i64 0, i64 0))
%38 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), double* %7)
%39 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([248 x i8], [248 x i8]* @str, i64 0, i64 0))
%40 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i32* %1)
%41 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.8, i64 0, i64 0))
%42 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i32* %3)
%43 = call i32* @fopen(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0))
%44 = load i32, i32* %1
switch i32 %44, label %578 [
i32 1, label %57
i32 2, label %51
i32 3, label %45
]
45: ; preds = %30
%46 = load double, double* %4
%47 = load double, double* %6
%48 = fcmp ugt double %46, %47
br i1 %48, label %435, label %49
49: ; preds = %45
%50 = sext i32 %24 to i64
br label %358
51: ; preds = %30
%52 = load double, double* %4
%53 = load double, double* %6
%54 = fcmp ugt double %52, %53
br i1 %54, label %307, label %55
55: ; preds = %51
%56 = sext i32 %24 to i64
br label %229
57: ; preds = %30
%58 = load double, double* %4
%59 = load double, double* %6
%60 = fcmp ugt double %58, %59
br i1 %60, label %177, label %61
61: ; preds = %57
%62 = sext i32 %24 to i64
%63 = load double, double* %5
%64 = call i32 @pow(double %63, i32 2)
%65 = mul nsw i32 %64, 5
%66 = sitofp i32 %65 to double
%67 = load double, double* %5
%68 = load double, double* %4
%69 = fmul double %67, -9.000000e+00
%70 = call double @llvm.fmuladd.f64(double %69, double %68, double %66)
%71 = call i32 @pow(double %68, i32 4)
%72 = shl nsw i32 %71, 2
%73 = sitofp i32 %72 to double
%74 = fadd double %70, %73
%75 = fcmp une double %74, 0.000000e+00
br i1 %75, label %90, label %170
76: ; preds = %165
%77 = load double, double* %5
%78 = call i32 @pow(double %77, i32 2)
%79 = mul nsw i32 %78, 5
%80 = sitofp i32 %79 to double
%81 = load double, double* %5
%82 = load double, double* %4
%83 = fmul double %81, -9.000000e+00
%84 = call double @llvm.fmuladd.f64(double %83, double %82, double %80)
%85 = call i32 @pow(double %82, i32 4)
%86 = shl nsw i32 %85, 2
%87 = sitofp i32 %86 to double
%88 = fadd double %84, %87
%89 = fcmp une double %88, 0.000000e+00
br i1 %89, label %90, label %170
90: ; preds = %61, %76
%91 = phi i64 [ %167, %76 ], [ %62, %61 ]
%92 = load double, double* %5
%93 = call i32 @pow(double %92, i32 2)
%94 = mul nsw i32 %93, -10
%95 = sitofp i32 %94 to double
%96 = load double, double* %5
%97 = fmul double %96, 2.700000e+01
%98 = load double, double* %4
%99 = call double @llvm.fmuladd.f64(double %97, double %98, double %95)
%100 = call i32 @pow(double %98, i32 2)
%101 = mul nsw i32 %100, 28
%102 = sitofp i32 %101 to double
%103 = fadd double %99, %102
%104 = fmul double %103, 5.000000e+00
%105 = load double, double* %5
%106 = call i32 @pow(double %105, i32 2)
%107 = mul nsw i32 %106, 5
%108 = sitofp i32 %107 to double
%109 = load double, double* %5
%110 = load double, double* %4
%111 = fmul double %109, -9.000000e+00
%112 = call double @llvm.fmuladd.f64(double %111, double %110, double %108)
%113 = call i32 @pow(double %110, i32 4)
%114 = shl nsw i32 %113, 2
%115 = sitofp i32 %114 to double
%116 = fadd double %112, %115
%117 = fdiv double %104, %116
%118 = load double, double* %4
%119 = call i32 @fprintf(i32* %43, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.11, i64 0, i64 0), double %118, double %117)
%120 = icmp eq i64 %91, 0
br i1 %120, label %121, label %125
121: ; preds = %90
%122 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([124 x i8], [124 x i8]* @str.51, i64 0, i64 0))
%123 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.52, i64 0, i64 0))
%124 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([124 x i8], [124 x i8]* @str.53, i64 0, i64 0))
br label %125
125: ; preds = %121, %90
%126 = load i32, i32* %3
%127 = icmp eq i32 %126, 1
%128 = load double, double* %4
%129 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %91
store double %128, double* %129
%130 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %91
store double %117, double* %130
%131 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.15, i64 0, i64 0), double %128, double %117)
br i1 %127, label %132, label %161
132: ; preds = %125
%133 = icmp sgt i64 %91, 0
br i1 %133, label %136, label %134
134: ; preds = %132
%135 = load double, double* %4
br label %165
136: ; preds = %132
%137 = add nuw i64 %91, 4294967295
%138 = and i64 %137, 4294967295
%139 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %138
%140 = load double, double* %139
%141 = fdiv double %140, %117
%142 = fcmp ogt double %141, 2.000000e+00
br i1 %142, label %146, label %143
143: ; preds = %136
%144 = fdiv double %117, %140
%145 = fcmp ogt double %144, 2.000000e+00
br i1 %145, label %146, label %151
146: ; preds = %143, %136
%147 = load double, double* %7
%148 = fmul double %147, 5.000000e-01
%149 = load double, double* %4
%150 = fadd double %149, %148
store double %150, double* %4
br label %165
151: ; preds = %143
%152 = fcmp olt double %141, 5.000000e-01
%153 = fcmp olt double %144, 5.000000e-01
%154 = or i1 %152, %153
%155 = load double, double* %7
%156 = load double, double* %4
br i1 %154, label %157, label %159
157: ; preds = %151
%158 = call double @llvm.fmuladd.f64(double %155, double 2.000000e+00, double %156)
store double %158, double* %4
br label %165
159: ; preds = %151
%160 = fadd double %155, %156
store double %160, double* %4
br label %165
161: ; preds = %125
%162 = load double, double* %7
%163 = load double, double* %4
%164 = fadd double %162, %163
store double %164, double* %4
br label %165
165: ; preds = %134, %157, %159, %146, %161
%166 = phi double [ %135, %134 ], [ %158, %157 ], [ %160, %159 ], [ %150, %146 ], [ %164, %161 ]
%167 = add i64 %91, 1
%168 = load double, double* %6
%169 = fcmp ugt double %166, %168
br i1 %169, label %175, label %76
170: ; preds = %76, %61
%171 = phi i64 [ %62, %61 ], [ %167, %76 ]
%172 = phi double [ %23, %61 ], [ %117, %76 ]
%173 = trunc i64 %171 to i32
%174 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([140 x i8], [140 x i8]* @.str.17, i64 0, i64 0))
br label %177
175: ; preds = %165
%176 = trunc i64 %167 to i32
br label %177
177: ; preds = %175, %57, %170
%178 = phi double [ %172, %170 ], [ %23, %57 ], [ %117, %175 ]
%179 = phi i32 [ %173, %170 ], [ %24, %57 ], [ %176, %175 ]
%180 = icmp eq i32 %179, 0
br i1 %180, label %587, label %181
181: ; preds = %177
%182 = icmp sgt i32 %179, 0
br i1 %182, label %183, label %558
183: ; preds = %181
%184 = load double, double* %19
%185 = load double, double* %20
%186 = icmp eq i32 %179, 1
br i1 %186, label %558, label %187
187: ; preds = %183
%188 = zext i32 %179 to i64
%189 = add nsw i64 %188, -1
%190 = and i64 %189, 1
%191 = icmp eq i32 %179, 2
br i1 %191, label %486, label %192
192: ; preds = %187
%193 = and i64 %189, -2
br label %194
194: ; preds = %194, %192
%195 = phi i64 [ 1, %192 ], [ %226, %194 ]
%196 = phi double [ %185, %192 ], [ %225, %194 ]
%197 = phi double [ %185, %192 ], [ %223, %194 ]
%198 = phi double [ %184, %192 ], [ %219, %194 ]
%199 = phi double [ %184, %192 ], [ %217, %194 ]
%200 = phi i64 [ 0, %192 ], [ %227, %194 ]
%201 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %195
%202 = load double, double* %201
%203 = fcmp olt double %199, %202
%204 = select i1 %203, double %202, double %199
%205 = fcmp ogt double %198, %202
%206 = select i1 %205, double %202, double %198
%207 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %195
%208 = load double, double* %207
%209 = fcmp olt double %197, %208
%210 = select i1 %209, double %208, double %197
%211 = fcmp ogt double %196, %208
%212 = select i1 %211, double %208, double %196
%213 = add nuw nsw i64 %195, 1
%214 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %213
%215 = load double, double* %214
%216 = fcmp olt double %204, %215
%217 = select i1 %216, double %215, double %204
%218 = fcmp ogt double %206, %215
%219 = select i1 %218, double %215, double %206
%220 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %213
%221 = load double, double* %220
%222 = fcmp olt double %210, %221
%223 = select i1 %222, double %221, double %210
%224 = fcmp ogt double %212, %221
%225 = select i1 %224, double %221, double %212
%226 = add nuw nsw i64 %195, 2
%227 = add i64 %200, 2
%228 = icmp eq i64 %227, %193
br i1 %228, label %486, label %194
229: ; preds = %55, %297
%230 = phi i64 [ %56, %55 ], [ %299, %297 ]
%231 = load double, double* %5
%232 = call i32 @pow(double %231, i32 2)
%233 = mul nsw i32 %232, 28
%234 = sitofp i32 %233 to double
%235 = load double, double* %5
%236 = load double, double* %4
%237 = fmul double %235, -5.700000e+01
%238 = call double @llvm.fmuladd.f64(double %237, double %236, double %234)
%239 = call i32 @pow(double %236, i32 2)
%240 = mul nsw i32 %239, 14
%241 = sitofp i32 %240 to double
%242 = fadd double %238, %241
%243 = fptosi double %242 to i32
%244 = call double @sin(i32 %243)
%245 = fcmp oge double %244, -1.000000e+00
%246 = fcmp ole double %244, 1.000000e+00
%247 = and i1 %245, %246
br i1 %247, label %248, label %302
248: ; preds = %229
%249 = load double, double* %4
%250 = call i32 @fprintf(i32* %43, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.11, i64 0, i64 0), double %249, double %244)
%251 = icmp eq i64 %230, 0
br i1 %251, label %252, label %256
252: ; preds = %248
%253 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([124 x i8], [124 x i8]* @str.51, i64 0, i64 0))
%254 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.52, i64 0, i64 0))
%255 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([124 x i8], [124 x i8]* @str.53, i64 0, i64 0))
br label %256
256: ; preds = %252, %248
%257 = load i32, i32* %3
%258 = icmp eq i32 %257, 1
%259 = load double, double* %4
%260 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %230
store double %259, double* %260
%261 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %230
br i1 %258, label %262, label %292
262: ; preds = %256
store double %244, double* %261
%263 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.25, i64 0, i64 0), double %259, double %244)
%264 = icmp sgt i64 %230, 0
br i1 %264, label %267, label %265
265: ; preds = %262
%266 = load double, double* %4
br label %297
267: ; preds = %262
%268 = add nuw i64 %230, 4294967295
%269 = and i64 %268, 4294967295
%270 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %269
%271 = load double, double* %270
%272 = fdiv double %271, %244
%273 = fcmp ogt double %272, 2.000000e+00
br i1 %273, label %277, label %274
274: ; preds = %267
%275 = fdiv double %244, %271
%276 = fcmp ogt double %275, 2.000000e+00
br i1 %276, label %277, label %282
277: ; preds = %274, %267
%278 = load double, double* %7
%279 = fmul double %278, 5.000000e-01
%280 = load double, double* %4
%281 = fadd double %280, %279
store double %281, double* %4
br label %297
282: ; preds = %274
%283 = fcmp olt double %272, 5.000000e-01
%284 = fcmp olt double %275, 5.000000e-01
%285 = or i1 %283, %284
%286 = load double, double* %7
%287 = load double, double* %4
br i1 %285, label %288, label %290
288: ; preds = %282
%289 = call double @llvm.fmuladd.f64(double %286, double 2.000000e+00, double %287)
store double %289, double* %4
br label %297
290: ; preds = %282
%291 = fadd double %286, %287
store double %291, double* %4
br label %297
292: ; preds = %256
store double %23, double* %261
%293 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.15, i64 0, i64 0), double %259, double %244)
%294 = load double, double* %7
%295 = load double, double* %4
%296 = fadd double %294, %295
store double %296, double* %4
br label %297
297: ; preds = %265, %288, %290, %277, %292
%298 = phi double [ %266, %265 ], [ %289, %288 ], [ %291, %290 ], [ %281, %277 ], [ %296, %292 ]
%299 = add i64 %230, 1
%300 = load double, double* %6
%301 = fcmp ugt double %298, %300
br i1 %301, label %305, label %229
302: ; preds = %229
%303 = trunc i64 %230 to i32
%304 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([140 x i8], [140 x i8]* @.str.26, i64 0, i64 0))
br label %307
305: ; preds = %297
%306 = trunc i64 %299 to i32
br label %307
307: ; preds = %305, %51, %302
%308 = phi i32 [ %303, %302 ], [ %24, %51 ], [ %306, %305 ]
%309 = icmp eq i32 %308, 0
br i1 %309, label %587, label %310
310: ; preds = %307
%311 = icmp sgt i32 %308, 0
br i1 %311, label %312, label %558
312: ; preds = %310
%313 = load double, double* %19
%314 = load double, double* %20
%315 = icmp eq i32 %308, 1
br i1 %315, label %558, label %316
316: ; preds = %312
%317 = zext i32 %308 to i64
%318 = add nsw i64 %317, -1
%319 = and i64 %318, 1
%320 = icmp eq i32 %308, 2
br i1 %320, label %510, label %321
321: ; preds = %316
%322 = and i64 %318, -2
br label %323
323: ; preds = %323, %321
%324 = phi i64 [ 1, %321 ], [ %355, %323 ]
%325 = phi double [ %314, %321 ], [ %354, %323 ]
%326 = phi double [ %314, %321 ], [ %352, %323 ]
%327 = phi double [ %313, %321 ], [ %348, %323 ]
%328 = phi double [ %313, %321 ], [ %346, %323 ]
%329 = phi i64 [ 0, %321 ], [ %356, %323 ]
%330 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %324
%331 = load double, double* %330
%332 = fcmp olt double %328, %331
%333 = select i1 %332, double %331, double %328
%334 = fcmp ogt double %327, %331
%335 = select i1 %334, double %331, double %327
%336 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %324
%337 = load double, double* %336
%338 = fcmp olt double %326, %337
%339 = select i1 %338, double %337, double %326
%340 = fcmp ogt double %325, %337
%341 = select i1 %340, double %337, double %325
%342 = add nuw nsw i64 %324, 1
%343 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %342
%344 = load double, double* %343
%345 = fcmp olt double %333, %344
%346 = select i1 %345, double %344, double %333
%347 = fcmp ogt double %335, %344
%348 = select i1 %347, double %344, double %335
%349 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %342
%350 = load double, double* %349
%351 = fcmp olt double %339, %350
%352 = select i1 %351, double %350, double %339
%353 = fcmp ogt double %341, %350
%354 = select i1 %353, double %350, double %341
%355 = add nuw nsw i64 %324, 2
%356 = add i64 %329, 2
%357 = icmp eq i64 %356, %322
br i1 %357, label %510, label %323
358: ; preds = %49, %425
%359 = phi i64 [ %50, %49 ], [ %427, %425 ]
%360 = load double, double* %5
%361 = call i32 @pow(double %360, i32 2)
%362 = mul nsw i32 %361, -27
%363 = sitofp i32 %362 to double
%364 = load double, double* %5
%365 = fmul double %364, 2.400000e+01
%366 = load double, double* %4
%367 = call double @llvm.fmuladd.f64(double %365, double %366, double %363)
%368 = call i32 @pow(double %366, i32 2)
%369 = mul nsw i32 %368, 35
%370 = sitofp i32 %369 to double
%371 = fadd double %367, %370
%372 = fadd double %371, 1.000000e+00
%373 = fptosi double %372 to i32
%374 = call double @log(i32 %373)
%375 = fcmp ogt double %374, 0.000000e+00
br i1 %375, label %376, label %430
376: ; preds = %358
%377 = load double, double* %4
%378 = call i32 @fprintf(i32* %43, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.11, i64 0, i64 0), double %377, double %374)
%379 = icmp eq i64 %359, 0
br i1 %379, label %380, label %384
380: ; preds = %376
%381 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([124 x i8], [124 x i8]* @str.51, i64 0, i64 0))
%382 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.52, i64 0, i64 0))
%383 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([124 x i8], [124 x i8]* @str.53, i64 0, i64 0))
br label %384
384: ; preds = %380, %376
%385 = load i32, i32* %3
%386 = icmp eq i32 %385, 1
%387 = load double, double* %4
%388 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %359
store double %387, double* %388
%389 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %359
store double %374, double* %389
br i1 %386, label %390, label %420
390: ; preds = %384
%391 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.25, i64 0, i64 0), double %387, double %374)
%392 = icmp sgt i64 %359, 0
br i1 %392, label %395, label %393
393: ; preds = %390
%394 = load double, double* %4
br label %425
395: ; preds = %390
%396 = add nuw i64 %359, 4294967295
%397 = and i64 %396, 4294967295
%398 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %397
%399 = load double, double* %398
%400 = fdiv double %399, %374
%401 = fcmp ogt double %400, 2.000000e+00
br i1 %401, label %405, label %402
402: ; preds = %395
%403 = fdiv double %374, %399
%404 = fcmp ogt double %403, 2.000000e+00
br i1 %404, label %405, label %410
405: ; preds = %402, %395
%406 = load double, double* %7
%407 = fmul double %406, 5.000000e-01
%408 = load double, double* %4
%409 = fadd double %408, %407
store double %409, double* %4
br label %425
410: ; preds = %402
%411 = fcmp olt double %400, 5.000000e-01
%412 = fcmp olt double %403, 5.000000e-01
%413 = or i1 %411, %412
%414 = load double, double* %7
%415 = load double, double* %4
br i1 %413, label %416, label %418
416: ; preds = %410
%417 = call double @llvm.fmuladd.f64(double %414, double 2.000000e+00, double %415)
store double %417, double* %4
br label %425
418: ; preds = %410
%419 = fadd double %414, %415
store double %419, double* %4
br label %425
420: ; preds = %384
%421 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.15, i64 0, i64 0), double %387, double %374)
%422 = load double, double* %7
%423 = load double, double* %4
%424 = fadd double %422, %423
store double %424, double* %4
br label %425
425: ; preds = %393, %416, %418, %405, %420
%426 = phi double [ %394, %393 ], [ %417, %416 ], [ %419, %418 ], [ %409, %405 ], [ %424, %420 ]
%427 = add i64 %359, 1
%428 = load double, double* %6
%429 = fcmp ugt double %426, %428
br i1 %429, label %433, label %358
430: ; preds = %358
%431 = trunc i64 %359 to i32
%432 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([181 x i8], [181 x i8]* @.str.27, i64 0, i64 0))
br label %435
433: ; preds = %425
%434 = trunc i64 %427 to i32
br label %435
435: ; preds = %433, %45, %430
%436 = phi i32 [ %431, %430 ], [ %24, %45 ], [ %434, %433 ]
%437 = icmp eq i32 %436, 0
br i1 %437, label %587, label %438
438: ; preds = %435
%439 = icmp sgt i32 %436, 0
br i1 %439, label %440, label %558
440: ; preds = %438
%441 = load double, double* %19
%442 = load double, double* %20
%443 = icmp eq i32 %436, 1
br i1 %443, label %558, label %444
444: ; preds = %440
%445 = zext i32 %436 to i64
%446 = add nsw i64 %445, -1
%447 = and i64 %446, 1
%448 = icmp eq i32 %436, 2
br i1 %448, label %534, label %449
449: ; preds = %444
%450 = and i64 %446, -2
br label %451
451: ; preds = %451, %449
%452 = phi i64 [ 1, %449 ], [ %483, %451 ]
%453 = phi double [ %442, %449 ], [ %482, %451 ]
%454 = phi double [ %442, %449 ], [ %480, %451 ]
%455 = phi double [ %441, %449 ], [ %476, %451 ]
%456 = phi double [ %441, %449 ], [ %474, %451 ]
%457 = phi i64 [ 0, %449 ], [ %484, %451 ]
%458 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %452
%459 = load double, double* %458
%460 = fcmp olt double %456, %459
%461 = select i1 %460, double %459, double %456
%462 = fcmp ogt double %455, %459
%463 = select i1 %462, double %459, double %455
%464 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %452
%465 = load double, double* %464
%466 = fcmp olt double %454, %465
%467 = select i1 %466, double %465, double %454
%468 = fcmp ogt double %453, %465
%469 = select i1 %468, double %465, double %453
%470 = add nuw nsw i64 %452, 1
%471 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %470
%472 = load double, double* %471
%473 = fcmp olt double %461, %472
%474 = select i1 %473, double %472, double %461
%475 = fcmp ogt double %463, %472
%476 = select i1 %475, double %472, double %463
%477 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %470
%478 = load double, double* %477
%479 = fcmp olt double %467, %478
%480 = select i1 %479, double %478, double %467
%481 = fcmp ogt double %469, %478
%482 = select i1 %481, double %478, double %469
%483 = add nuw nsw i64 %452, 2
%484 = add i64 %457, 2
%485 = icmp eq i64 %484, %450
br i1 %485, label %534, label %451
486: ; preds = %194, %187
%487 = phi double [ undef, %187 ], [ %217, %194 ]
%488 = phi double [ undef, %187 ], [ %219, %194 ]
%489 = phi double [ undef, %187 ], [ %223, %194 ]
%490 = phi double [ undef, %187 ], [ %225, %194 ]
%491 = phi i64 [ 1, %187 ], [ %226, %194 ]
%492 = phi double [ %185, %187 ], [ %225, %194 ]
%493 = phi double [ %185, %187 ], [ %223, %194 ]
%494 = phi double [ %184, %187 ], [ %219, %194 ]
%495 = phi double [ %184, %187 ], [ %217, %194 ]
%496 = icmp eq i64 %190, 0
br i1 %496, label %558, label %497
497: ; preds = %486
%498 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %491
%499 = load double, double* %498
%500 = fcmp olt double %495, %499
%501 = select i1 %500, double %499, double %495
%502 = fcmp ogt double %494, %499
%503 = select i1 %502, double %499, double %494
%504 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %491
%505 = load double, double* %504
%506 = fcmp olt double %493, %505
%507 = select i1 %506, double %505, double %493
%508 = fcmp ogt double %492, %505
%509 = select i1 %508, double %505, double %492
br label %558
510: ; preds = %323, %316
%511 = phi double [ undef, %316 ], [ %346, %323 ]
%512 = phi double [ undef, %316 ], [ %348, %323 ]
%513 = phi double [ undef, %316 ], [ %352, %323 ]
%514 = phi double [ undef, %316 ], [ %354, %323 ]
%515 = phi i64 [ 1, %316 ], [ %355, %323 ]
%516 = phi double [ %314, %316 ], [ %354, %323 ]
%517 = phi double [ %314, %316 ], [ %352, %323 ]
%518 = phi double [ %313, %316 ], [ %348, %323 ]
%519 = phi double [ %313, %316 ], [ %346, %323 ]
%520 = icmp eq i64 %319, 0
br i1 %520, label %558, label %521
521: ; preds = %510
%522 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %515
%523 = load double, double* %522
%524 = fcmp olt double %519, %523
%525 = select i1 %524, double %523, double %519
%526 = fcmp ogt double %518, %523
%527 = select i1 %526, double %523, double %518
%528 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %515
%529 = load double, double* %528
%530 = fcmp olt double %517, %529
%531 = select i1 %530, double %529, double %517
%532 = fcmp ogt double %516, %529
%533 = select i1 %532, double %529, double %516
br label %558
534: ; preds = %451, %444
%535 = phi double [ undef, %444 ], [ %474, %451 ]
%536 = phi double [ undef, %444 ], [ %476, %451 ]
%537 = phi double [ undef, %444 ], [ %480, %451 ]
%538 = phi double [ undef, %444 ], [ %482, %451 ]
%539 = phi i64 [ 1, %444 ], [ %483, %451 ]
%540 = phi double [ %442, %444 ], [ %482, %451 ]
%541 = phi double [ %442, %444 ], [ %480, %451 ]
%542 = phi double [ %441, %444 ], [ %476, %451 ]
%543 = phi double [ %441, %444 ], [ %474, %451 ]
%544 = icmp eq i64 %447, 0
br i1 %544, label %558, label %545
545: ; preds = %534
%546 = getelementptr inbounds [200 x double], [200 x double]* %9, i64 0, i64 %539
%547 = load double, double* %546
%548 = fcmp olt double %543, %547
%549 = select i1 %548, double %547, double %543
%550 = fcmp ogt double %542, %547
%551 = select i1 %550, double %547, double %542
%552 = getelementptr inbounds [200 x double], [200 x double]* %8, i64 0, i64 %539
%553 = load double, double* %552
%554 = fcmp olt double %541, %553
%555 = select i1 %554, double %553, double %541
%556 = fcmp ogt double %540, %553
%557 = select i1 %556, double %553, double %540
br label %558
558: ; preds = %545, %534, %521, %510, %497, %486, %438, %440, %310, %312, %181, %183
%559 = phi i8* [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %183 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %181 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %312 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %310 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %440 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %438 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %486 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %497 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %510 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %521 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %534 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.46, i64 0, i64 0), %545 ]
%560 = phi double [ %184, %183 ], [ %25, %181 ], [ %313, %312 ], [ %25, %310 ], [ %441, %440 ], [ %25, %438 ], [ %487, %486 ], [ %501, %497 ], [ %511, %510 ], [ %525, %521 ], [ %535, %534 ], [ %549, %545 ]
%561 = phi i8* [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %183 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %181 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %312 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %310 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %440 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %438 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %486 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %497 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %510 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %521 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %534 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %545 ]
%562 = phi double [ %184, %183 ], [ %26, %181 ], [ %313, %312 ], [ %26, %310 ], [ %441, %440 ], [ %26, %438 ], [ %488, %486 ], [ %503, %497 ], [ %512, %510 ], [ %527, %521 ], [ %536, %534 ], [ %551, %545 ]
%563 = phi i8* [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %183 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %181 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %312 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %310 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %440 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %438 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %486 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %497 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %510 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %521 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %534 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %545 ]
%564 = phi double [ %185, %183 ], [ %27, %181 ], [ %314, %312 ], [ %27, %310 ], [ %442, %440 ], [ %27, %438 ], [ %489, %486 ], [ %507, %497 ], [ %513, %510 ], [ %531, %521 ], [ %537, %534 ], [ %555, %545 ]
%565 = phi i8* [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %183 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %181 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %312 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %310 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %440 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %438 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %486 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %497 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %510 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %521 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %534 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.49, i64 0, i64 0), %545 ]
%566 = phi double [ %185, %183 ], [ %28, %181 ], [ %314, %312 ], [ %28, %310 ], [ %442, %440 ], [ %28, %438 ], [ %490, %486 ], [ %509, %497 ], [ %514, %510 ], [ %533, %521 ], [ %538, %534 ], [ %557, %545 ]
%567 = phi i8* [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %183 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %181 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %312 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %310 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %440 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %438 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %486 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %497 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %510 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %521 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %534 ], [ getelementptr inbounds ([124 x i8], [124 x i8]* @str.50, i64 0, i64 0), %545 ]
%568 = phi double [ %178, %183 ], [ %178, %181 ], [ %23, %312 ], [ %23, %310 ], [ %23, %440 ], [ %23, %438 ], [ %178, %486 ], [ %178, %497 ], [ %23, %510 ], [ %23, %521 ], [ %23, %534 ], [ %23, %545 ]
%569 = phi i32 [ %179, %183 ], [ %179, %181 ], [ %308, %312 ], [ %308, %310 ], [ %436, %440 ], [ %436, %438 ], [ %179, %486 ], [ %179, %497 ], [ %308, %510 ], [ %308, %521 ], [ %436, %534 ], [ %436, %545 ]
%570 = call i32 @puts(i8* dereferenceable(1) %559)
%571 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @.str.19, i64 0, i64 0), double %560)
%572 = call i32 @puts(i8* dereferenceable(1) %561)
%573 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @.str.21, i64 0, i64 0), double %562)
%574 = call i32 @puts(i8* dereferenceable(1) %563)
%575 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @.str.22, i64 0, i64 0), double %564)
%576 = call i32 @puts(i8* dereferenceable(1) %565)
%577 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([61 x i8], [61 x i8]* @.str.23, i64 0, i64 0), double %566)
br label %578
578: ; preds = %558, %30
%579 = phi i8* [ getelementptr inbounds ([116 x i8], [116 x i8]* @.str.28, i64 0, i64 0), %30 ], [ %567, %558 ]
%580 = phi double [ %23, %30 ], [ %568, %558 ]
%581 = phi i32 [ %24, %30 ], [ %569, %558 ]
%582 = phi double [ %25, %30 ], [ %560, %558 ]
%583 = phi double [ %26, %30 ], [ %562, %558 ]
%584 = phi double [ %27, %30 ], [ %564, %558 ]
%585 = phi double [ %28, %30 ], [ %566, %558 ]
%586 = call i32 @puts(i8* dereferenceable(1) %579)
br label %587
587: ; preds = %578, %177, %307, %435, %21
%588 = phi double [ %23, %21 ], [ %23, %435 ], [ %23, %307 ], [ %178, %177 ], [ %580, %578 ]
%589 = phi i32 [ %24, %21 ], [ 0, %435 ], [ 0, %307 ], [ 0, %177 ], [ %581, %578 ]
%590 = phi double [ %25, %21 ], [ %25, %435 ], [ %25, %307 ], [ %25, %177 ], [ %582, %578 ]
%591 = phi double [ %26, %21 ], [ %26, %435 ], [ %26, %307 ], [ %26, %177 ], [ %583, %578 ]
%592 = phi double [ %27, %21 ], [ %27, %435 ], [ %27, %307 ], [ %27, %177 ], [ %584, %578 ]
%593 = phi double [ %28, %21 ], [ %28, %435 ], [ %28, %307 ], [ %28, %177 ], [ %585, %578 ]
%594 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([185 x i8], [185 x i8]* @.str.29, i64 0, i64 0))
%595 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i32* %2)
%596 = load i32, i32* %2
%597 = icmp eq i32 %596, 0
br i1 %597, label %598, label %21
598: ; preds = %587
ret i32 0
}