int main() {
  double a, x, G, F, Y, from_x, to_x, i, j, from_a, to_a, x_step, a_step, max,
      min;
  int steps, arrayc = 0, counter;
  char b;
  for (;;) {
    printf("%s\n", "Хотите ли вы запустить программу? yes/no");
    char yes1[4] = "yes";
    char yes2[4];
    scanf("%s", yes2);
    if (strcmp(yes2, yes1) == 0) {
      printf("Введите значение переменной a от: ");
      scanf("%lf", &from_a);
      printf("До: ");
      scanf("%lf", &to_a);
      printf("Введите значение переменной x от:  ");
      scanf("%lf", &from_x);
      printf("До: ");
      scanf("%lf", &to_x);
      printf("Количество шагов: ");
      scanf("%i", &steps);
      x_step = (to_x - from_x) / steps;
      a_step = (to_a - from_a) / steps;
      double G_array[steps], F_array[steps], Y_array[steps];
      printf("%s\n", "Вычислить функцию G, F, Y");
      printf("%s", "Выберите функцию: ");
      scanf("%s", &b);
      switch (b) {
      case 'G':
        for (i = from_x, j = from_a; i < to_x, j < to_a;
             i += x_step, j += a_step) {
          x = i;
          a = j;
          if (((15 * a * a + 29 * a * x + 12 * x * x) >= -0.00001 &&
               (15 * a * a + 29 * a * x + 12 * x * x) <= 0.00001)) {
            printf("Входные данные не подлежат области определения функции");
            break;
          } else {
            G = (4 * a * a + 3 * a * x + 10 * x * x) /
                (15 * a * a + 29 * a * x + 12 * x * x);
            G_array[arrayc] = G;
            arrayc += 1;
          }
        }
        min = G_array[0];
        max = G_array[0];
        for (counter = 0; counter < arrayc; counter++) {
          if (G_array[counter] < min)
            min = G_array[counter];
          if (G_array[counter] > max)
            max = G_array[counter];
        }
        printf("____________________\n");
        printf("|    X    |    Y    |\n");
        printf("--------------------\n");
        for (i = from_x, counter = 0; i < to_x, counter < arrayc;
             i += x_step, counter++)
          printf("|%lf|%lf|\n", i, G_array[counter]);
        break;
      case 'F':
        for (i = from_x, j = from_a; i < to_x, j < to_a;
             i += x_step, j += a_step) {
          x = i;
          a = j;
          if ((cos(5 * a * a + 14 * a * x - 3 * x * x)) >= -0.00001 &&
              (cos(5 * a * a + 14 * a * x - 3 * x * x)) <= 0.00001) {
            printf("Входные данные не подлежат области определения функции");
            break;
          } else {
            F = 1 / (cos(5 * a * a + 14 * a * x - 3 * x * x));
            F_array[arrayc] = F;
            arrayc += 1;
          }
        }
        min = F_array[0];
        max = F_array[0];
        for (counter = 0; counter < arrayc; counter++) {
          if (F_array[counter] < min)
            min = F_array[counter];
          if (F_array[counter] > max)
            max = F_array[counter];
        }
        printf("____________________\n");
        printf("|    X    |    Y    |\n");
        printf("--------------------\n");
        for (i = from_x, counter = 0; i < to_x, counter < arrayc;
             i += x_step, counter++)
          printf("|%lf|%lf|\n", i, F_array[counter]);
        break;
      case 'Y':
        for (i = from_x, j = from_a; i < to_x, j < to_a;
             i += x_step, j += a_step) {
          x = i;
          a = j;
          if ((9 * a * a + 42 * a * x + 40 * x * x + 1) <= 1) {
            printf("Входные данные не подлежат области определения функции");
            break;
          } else {
            Y = acosh(9 * a * a + 42 * a * x + 40 * x * x + 1);
            Y_array[arrayc] = Y;
            arrayc += 1;
          }
        }
        min = Y_array[0];
        max = Y_array[0];
        for (counter = 0; counter < arrayc; counter++) {
          if (Y_array[counter] < min)
            min = Y_array[counter];
          if (Y_array[counter] > max)
            max = Y_array[counter];
        }
        printf("____________________\n");
        printf("|    X    |    Y    |\n");
        printf("--------------------\n");
        for (i = from_x, counter = 0; i < to_x, counter < arrayc;
             i += x_step, counter++)
          printf("|%lf|%lf|\n", i, Y_array[counter]);
        break;
      default:
        printf("%s\n", "Ошибка");
      }
      printf("%s%lf\n", "Максимальный элемент массива = ", max);
      printf("%s%lf\n", "Минимальный элемент массива = ", min);
    } else
      break;
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x88(%rbp)
lea    0xefd(%rip),%rdi
lea    0xefa(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
mov    0xf32(%rip),%eax
mov    %eax,-0x91(%rbp)
lea    -0x95(%rbp),%rsi
lea    0xf22(%rip),%rdi
mov    $0x0,%al
call   1060 <scanf@plt>
lea    -0x95(%rbp),%rdi
lea    -0x91(%rbp),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%eax
jne    1d9d <main+0xc4d>
lea    0xefb(%rip),%rdi
xor    %eax,%eax
mov    %al,-0xbd(%rbp)
call   1030 <printf@plt>
mov    -0xbd(%rbp),%al
lea    0xf1f(%rip),%rdi
mov    %rdi,-0xe8(%rbp)
lea    -0x58(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0xbd(%rbp),%al
lea    0xf06(%rip),%rdi
mov    %rdi,-0xf0(%rbp)
call   1030 <printf@plt>
mov    -0xe8(%rbp),%rdi
mov    -0xbd(%rbp),%al
lea    -0x60(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0xbd(%rbp),%al
lea    0xede(%rip),%rdi
call   1030 <printf@plt>
mov    -0xe8(%rbp),%rdi
mov    -0xbd(%rbp),%al
lea    -0x38(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0xf0(%rbp),%rdi
mov    -0xbd(%rbp),%al
call   1030 <printf@plt>
mov    -0xe8(%rbp),%rdi
mov    -0xbd(%rbp),%al
lea    -0x40(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0xbd(%rbp),%al
lea    0xecd(%rip),%rdi
call   1030 <printf@plt>
mov    -0xbd(%rbp),%al
lea    0xedd(%rip),%rdi
lea    -0x84(%rbp),%rsi
call   1060 <scanf@plt>
mov    -0xbd(%rbp),%al
movsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
subsd  %xmm1,%xmm0
cvtsi2sdl -0x84(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
subsd  %xmm1,%xmm0
cvtsi2sdl -0x84(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x84(%rbp),%ecx
mov    %rsp,%rdx
mov    %rdx,-0xa0(%rbp)
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xe0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0xa8(%rbp)
mov    -0x84(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xd8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0xb0(%rbp)
mov    -0x84(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xd0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0xb8(%rbp)
lea    0xd07(%rip),%rdi
lea    0xdfd(%rip),%rsi
call   1030 <printf@plt>
mov    -0xbd(%rbp),%al
lea    0xd3b(%rip),%rdi
mov    %rdi,-0xc8(%rbp)
lea    0xe07(%rip),%rsi
call   1030 <printf@plt>
mov    -0xc8(%rbp),%rdi
mov    -0xbd(%rbp),%al
lea    -0x8d(%rbp),%rsi
call   1060 <scanf@plt>
movsbl -0x8d(%rbp),%eax
mov    %eax,-0xbc(%rbp)
sub    $0x46,%eax
je     1730 <main+0x5e0>
jmp    13c9 <main+0x279>
mov    -0xbc(%rbp),%eax
sub    $0x47,%eax
je     13f1 <main+0x2a1>
jmp    13dd <main+0x28d>
mov    -0xbc(%rbp),%eax
sub    $0x59,%eax
je     1a8b <main+0x93b>
jmp    1d45 <main+0xbf5>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    15d4 <main+0x484>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  0xc23(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0xc09(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xbe7(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xba5(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     14f0 <main+0x3a0>
movsd  0xbcb(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm2
movsd  0xbb1(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xb8f(%rip),%xmm1
mulsd  -0x18(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xb6d(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     14f0 <main+0x3a0>
lea    0xcd5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    15d4 <main+0x484>
mov    -0xe0(%rbp),%rax
movsd  0xb69(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0xb17(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xb35(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xb13(%rip),%xmm2
mulsd  -0x10(%rbp),%xmm2
movsd  -0x10(%rbp),%xmm3
movsd  0xaf9(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0xad7(%rip),%xmm1
mulsd  -0x18(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    15b1 <main+0x461>
movsd  -0x68(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x70(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1405 <main+0x2b5>
mov    -0xe0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    1692 <main+0x542>
mov    -0xe0(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1643 <main+0x4f3>
mov    -0xe0(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0xe0(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    1679 <main+0x529>
mov    -0xe0(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    167e <main+0x52e>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    15f7 <main+0x4a7>
lea    0xb87(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xb8f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xb98(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    172b <main+0x5db>
mov    -0xe0(%rbp),%rax
movsd  -0x48(%rbp),%xmm0
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0xb62(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  -0x68(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    16d0 <main+0x580>
jmp    1d5a <main+0xc0a>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    192f <main+0x7df>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  0x8c4(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0x8aa(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x888(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1070 <cos@plt>
movsd  0x84a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     186a <main+0x71a>
movsd  0x850(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0x836(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x814(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1070 <cos@plt>
movaps %xmm0,%xmm1
movsd  0x7f3(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     186a <main+0x71a>
lea    0x95b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    192f <main+0x7df>
movsd  0x7c6(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0x7ac(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x78a(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1070 <cos@plt>
mov    -0xd8(%rbp),%rax
movaps %xmm0,%xmm1
movsd  0x722(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    190c <main+0x7bc>
movsd  -0x68(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x70(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1744 <main+0x5f4>
mov    -0xd8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    19ed <main+0x89d>
mov    -0xd8(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    199e <main+0x84e>
mov    -0xd8(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0xd8(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    19d4 <main+0x884>
mov    -0xd8(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    19d9 <main+0x889>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1952 <main+0x802>
lea    0x82c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x834(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x83d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    1a86 <main+0x936>
mov    -0xd8(%rbp),%rax
movsd  -0x48(%rbp),%xmm0
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x807(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  -0x68(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1a2b <main+0x8db>
jmp    1d5a <main+0xc0a>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1be9 <main+0xa99>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  0x549(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm2
movsd  0x52f(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x50d(%rip),%xmm1
mulsd  -0x18(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x4eb(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x4df(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1b3e <main+0x9ee>
lea    0x687(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1be9 <main+0xa99>
movsd  0x4d2(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0x4b8(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x496(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x474(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1040 <acosh@plt>
mov    -0xd0(%rbp),%rax
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
movslq -0x88(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1bc6 <main+0xa76>
movsd  -0x68(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x70(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1a9f <main+0x94f>
mov    -0xd0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    1ca7 <main+0xb57>
mov    -0xd0(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c58 <main+0xb08>
mov    -0xd0(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0xd0(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    1c8e <main+0xb3e>
mov    -0xd0(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1c93 <main+0xb43>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1c0c <main+0xabc>
lea    0x572(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x57a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x583(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    1d40 <main+0xbf0>
mov    -0xd0(%rbp),%rax
movsd  -0x48(%rbp),%xmm0
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0x54d(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  -0x68(%rbp),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1ce5 <main+0xb95>
jmp    1d5a <main+0xc0a>
lea    0x324(%rip),%rdi
lea    0x51b(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0x78(%rbp),%xmm0
lea    0x515(%rip),%rdi
lea    0x515(%rip),%rsi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  -0x80(%rbp),%xmm0
lea    0x4fb(%rip),%rdi
lea    0x535(%rip),%rsi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0xa0(%rbp),%rax
mov    %rax,%rsp
jmp    1da2 <main+0xc52>
jmp    1da7 <main+0xc57>
jmp    116c <main+0x1c>
xor    %eax,%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
lea    0xf0d(%rip),%rdi
call   1030 <puts@plt>
lea    0xf4a(%rip),%rdi
lea    -0x5c(%rbp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
cmpl   $0x736579,-0x5c(%rbp)
je     119c <main+0x4c>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %r12d,%r12d
jmp    122c <main+0xdc>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1078(%rip),%rdi
call   1030 <puts@plt>
mov    -0x38(%rbp),%r14
lea    0xefa(%rip),%r15
movsd  -0x50(%rbp),%xmm0
lea    0x1069(%rip),%rbx
mov    %rbx,%rdi
lea    0x1066(%rip),%rsi
movsd  %xmm0,-0x50(%rbp)
mov    $0x1,%al
call   1040 <printf@plt>
mov    %rbx,%rdi
lea    0x108a(%rip),%rsi
movsd  -0xb0(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <printf@plt>
mov    %r14,%rsp
lea    0xe6c(%rip),%rdi
call   1030 <puts@plt>
mov    %r15,%rdi
lea    -0x5c(%rbp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
cmpl   $0x736579,-0x5c(%rbp)
jne    118b <main+0x3b>
lea    0xe91(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xec1(%rip),%rbx
mov    %rbx,%rdi
lea    -0xa8(%rbp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0xead(%rip),%r14
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
lea    -0x78(%rbp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0xe95(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
lea    -0x58(%rbp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
lea    0xe20(%rip),%rbx
lea    -0xb8(%rbp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
lea    0xe96(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeaa(%rip),%rdi
lea    -0x9c(%rbp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    -0x9c(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  -0x78(%rbp),%xmm2
movhpd -0xb8(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
movhpd -0x58(%rbp),%xmm1
mov    %rsp,-0x38(%rbp)
subpd  %xmm1,%xmm2
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm2
movapd %xmm2,-0x90(%rbp)
ff
mov    %rsp,%r15
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    -0x9c(%rbp),%eax
mov    %rsp,%r13
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r13
mov    %r13,%rsp
mov    %rsp,%r14
sub    %rax,%r14
mov    %r14,%rsp
lea    0xe20(%rip),%rdi
call   1030 <puts@plt>
mov    %rbx,%rdi
lea    0xe3b(%rip),%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rbx,%rdi
lea    -0x29(%rbp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movsbl -0x29(%rbp),%eax
cmp    $0x46,%eax
je     1740 <main+0x5f0>
cmp    $0x59,%eax
je     1680 <main+0x530>
cmp    $0x47,%eax
lea    0xe8f(%rip),%r13
movapd -0x90(%rbp),%xmm12
ff ff
jne    11b0 <main+0x60>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
ucomisd %xmm0,%xmm1
movsd  0xc8a(%rip),%xmm8
movsd  0xc89(%rip),%xmm10
movsd  0xc88(%rip),%xmm11
movsd  0xc87(%rip),%xmm9
movsd  0xc87(%rip),%xmm7
movsd  0xc87(%rip),%xmm6
jbe    14ad <main+0x35d>
movslq %r12d,%rax
movhpd -0x58(%rbp),%xmm0
lea    (%r15,%rax,8),%rax
jmp    1448 <main+0x2f8>
nopl   (%rax)
movapd %xmm0,%xmm4
mulsd  %xmm9,%xmm4
movapd %xmm0,%xmm5
mulsd  %xmm7,%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm0,%xmm4
addsd  %xmm5,%xmm4
movapd %xmm2,%xmm5
mulsd  %xmm6,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
divsd  %xmm3,%xmm5
movsd  %xmm5,(%rax)
addpd  %xmm12,%xmm0
add    $0x1,%r12d
add    $0x8,%rax
ucomisd %xmm0,%xmm1
jbe    14ad <main+0x35d>
movapd %xmm0,%xmm4
mulsd  %xmm8,%xmm4
movapd %xmm0,%xmm3
mulsd  %xmm10,%xmm3
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
mulsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm2,%xmm3
mulsd  %xmm11,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
ucomisd 0xbb1(%rip),%xmm3
jb     1400 <main+0x2b0>
movsd  0xbab(%rip),%xmm4
ucomisd %xmm3,%xmm4
jb     1400 <main+0x2b0>
lea    0xd17(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movsd  (%r15),%xmm5
mov    %r12d,%r14d
movapd %xmm5,%xmm2
movapd %xmm5,%xmm3
test   %r12d,%r12d
jle    15b0 <main+0x460>
movapd %xmm5,%xmm2
movapd %xmm5,%xmm3
cmp    $0x1,%r12d
je     15b0 <main+0x460>
lea    -0x1(%r14),%rdx
lea    -0x2(%r14),%rsi
mov    %edx,%eax
and    $0x3,%eax
mov    $0x1,%ecx
movapd %xmm5,%xmm0
movapd %xmm5,%xmm1
cmp    $0x3,%rsi
jb     1569 <main+0x419>
and    $0xfffffffffffffffc,%rdx
movapd %xmm5,%xmm0
movapd %xmm5,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  0x8(%r15,%rcx,8),%xmm2
movsd  0x10(%r15,%rcx,8),%xmm3
movapd %xmm2,%xmm4
minsd  %xmm1,%xmm4
maxsd  %xmm0,%xmm2
movapd %xmm3,%xmm0
minsd  %xmm4,%xmm0
maxsd  %xmm2,%xmm3
movsd  0x18(%r15,%rcx,8),%xmm2
movapd %xmm2,%xmm4
minsd  %xmm0,%xmm4
maxsd  %xmm3,%xmm2
movsd  0x20(%r15,%rcx,8),%xmm0
movapd %xmm0,%xmm1
minsd  %xmm4,%xmm1
maxsd  %xmm2,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1510 <main+0x3c0>
add    $0x1,%rcx
movapd %xmm0,%xmm2
movapd %xmm1,%xmm3
test   %rax,%rax
je     15b0 <main+0x460>
lea    (%r15,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movsd  (%rcx,%rdx,8),%xmm2
movapd %xmm2,%xmm3
minsd  %xmm1,%xmm3
maxsd  %xmm0,%xmm2
add    $0x1,%rdx
movapd %xmm2,%xmm0
movapd %xmm3,%xmm1
cmp    %rdx,%rax
jne    1580 <main+0x430>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm5,-0x98(%rbp)
ff
movsd  %xmm3,-0xb0(%rbp)
ff
movsd  %xmm2,-0x50(%rbp)
lea    0xce9(%rip),%rdi
call   1030 <puts@plt>
lea    0xcf2(%rip),%rdi
call   1030 <puts@plt>
lea    0xcfc(%rip),%rdi
call   1030 <puts@plt>
test   %r12d,%r12d
jle    11bc <main+0x6c>
movsd  -0x58(%rbp),%xmm0
mov    %r13,%rdi
movsd  %xmm0,-0x70(%rbp)
movsd  -0x98(%rbp),%xmm1
ff
mov    $0x2,%al
call   1040 <printf@plt>
cmp    $0x1,%r12d
je     11bc <main+0x6c>
movapd -0x90(%rbp),%xmm1
ff
unpckhpd %xmm1,%xmm1
mov    $0x1,%ebx
movapd %xmm1,-0x90(%rbp)
ff
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x70(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  (%r15,%rbx,8),%xmm1
mov    %r13,%rdi
movsd  %xmm0,-0x70(%rbp)
mov    $0x2,%al
call   1040 <printf@plt>
movapd -0x90(%rbp),%xmm1
ff
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1640 <main+0x4f0>
jmp    1bff <main+0xaaf>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm3,%xmm0
lea    0xb8c(%rip),%r13
jbe    1a33 <main+0x8e3>
movslq %r12d,%rax
movhpd -0x58(%rbp),%xmm3
lea    (%r14,%rax,8),%rbx
nopw   0x0(%rax,%rax,1)
movapd %xmm3,%xmm1
mulsd  0x944(%rip),%xmm1
movapd %xmm3,%xmm0
mulsd  0x940(%rip),%xmm0
movapd %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
mulsd  %xmm2,%xmm0
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm2,%xmm0
mulsd  0x928(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x920(%rip),%xmm1
addsd  %xmm1,%xmm0
ucomisd %xmm0,%xmm1
jae    1a25 <main+0x8d5>
movapd %xmm3,-0x70(%rbp)
call   1050 <acosh@plt>
movapd -0x70(%rbp),%xmm3
movsd  %xmm0,(%rbx)
addpd  -0x90(%rbp),%xmm3
ff
movsd  -0x78(%rbp),%xmm0
add    $0x1,%r12d
add    $0x8,%rbx
ucomisd %xmm3,%xmm0
ja     16b0 <main+0x560>
jmp    1a33 <main+0x8e3>
nopl   (%rax)
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0x78(%rbp),%xmm0
ucomisd %xmm3,%xmm0
jbe    1840 <main+0x6f0>
movslq %r12d,%rax
movhpd -0x58(%rbp),%xmm3
lea    0x0(,%rax,8),%rbx
add    %r13,%rbx
jmp    17ae <main+0x65e>
nopl   0x0(%rax)
movsd  -0x70(%rbp),%xmm0
call   1070 <cos@plt>
movsd  0x896(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx)
movapd -0x50(%rbp),%xmm3
addpd  -0x90(%rbp),%xmm3
ff
movsd  -0x78(%rbp),%xmm0
add    $0x1,%r12d
add    $0x8,%rbx
ucomisd %xmm3,%xmm0
jbe    1840 <main+0x6f0>
movapd %xmm3,%xmm4
mulsd  0x866(%rip),%xmm4
movapd %xmm3,%xmm1
mulsd  0x862(%rip),%xmm1
movapd %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
mulsd  %xmm2,%xmm1
movapd %xmm3,-0x50(%rbp)
mulsd  %xmm3,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm2,%xmm0
mulsd  0x845(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm4,%xmm0
movsd  %xmm0,-0x70(%rbp)
call   1070 <cos@plt>
ucomisd 0x833(%rip),%xmm0
jb     1770 <main+0x620>
movsd  -0x70(%rbp),%xmm0
call   1070 <cos@plt>
movsd  0x823(%rip),%xmm1
ucomisd %xmm0,%xmm1
jb     1770 <main+0x620>
lea    0x98f(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%r13),%xmm5
mov    %r12d,%r14d
movapd %xmm5,%xmm2
movapd %xmm5,%xmm3
test   %r12d,%r12d
lea    0x866(%rip),%r15
jle    1960 <main+0x810>
movapd %xmm5,%xmm2
movapd %xmm5,%xmm3
cmp    $0x1,%r12d
je     1960 <main+0x810>
lea    -0x1(%r14),%rdx
lea    -0x2(%r14),%rsi
mov    %edx,%eax
and    $0x3,%eax
mov    $0x1,%ecx
movapd %xmm5,%xmm0
movapd %xmm5,%xmm1
cmp    $0x3,%rsi
jb     1909 <main+0x7b9>
and    $0xfffffffffffffffc,%rdx
movapd %xmm5,%xmm0
movapd %xmm5,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x8(%r13,%rcx,8),%xmm2
movsd  0x10(%r13,%rcx,8),%xmm3
movapd %xmm2,%xmm4
minsd  %xmm1,%xmm4
maxsd  %xmm0,%xmm2
movapd %xmm3,%xmm0
minsd  %xmm4,%xmm0
maxsd  %xmm2,%xmm3
movsd  0x18(%r13,%rcx,8),%xmm2
movapd %xmm2,%xmm4
minsd  %xmm0,%xmm4
maxsd  %xmm3,%xmm2
movsd  0x20(%r13,%rcx,8),%xmm0
movapd %xmm0,%xmm1
minsd  %xmm4,%xmm1
maxsd  %xmm2,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    18b0 <main+0x760>
add    $0x1,%rcx
movapd %xmm0,%xmm2
movapd %xmm1,%xmm3
test   %rax,%rax
je     1960 <main+0x810>
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rdx,8),%xmm2
movapd %xmm2,%xmm3
minsd  %xmm1,%xmm3
maxsd  %xmm0,%xmm2
add    $0x1,%rdx
movapd %xmm2,%xmm0
movapd %xmm3,%xmm1
cmp    %rdx,%rax
jne    1930 <main+0x7e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm5,-0x98(%rbp)
ff
movsd  %xmm3,-0xb0(%rbp)
ff
movsd  %xmm2,-0x50(%rbp)
lea    0x939(%rip),%rdi
call   1030 <puts@plt>
lea    0x942(%rip),%rdi
call   1030 <puts@plt>
lea    0x94c(%rip),%rdi
call   1030 <puts@plt>
test   %r12d,%r12d
jle    19c4 <main+0x874>
movsd  -0x58(%rbp),%xmm0
lea    0x87a(%rip),%rdi
movsd  %xmm0,-0x70(%rbp)
movsd  -0x98(%rbp),%xmm1
ff
mov    $0x2,%al
call   1040 <printf@plt>
cmp    $0x1,%r12d
jne    19cd <main+0x87d>
mov    -0x38(%rbp),%r14
jmp    11c7 <main+0x77>
movapd -0x90(%rbp),%xmm1
ff
unpckhpd %xmm1,%xmm1
mov    $0x1,%ebx
lea    0x83f(%rip),%r15
movapd %xmm1,-0x90(%rbp)
ff
nopl   (%rax)
movsd  -0x70(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  0x0(%r13,%rbx,8),%xmm1
mov    %r15,%rdi
movsd  %xmm0,-0x70(%rbp)
mov    $0x2,%al
call   1040 <printf@plt>
movapd -0x90(%rbp),%xmm1
ff
add    $0x1,%rbx
cmp    %rbx,%r14
jne    19f0 <main+0x8a0>
jmp    1bff <main+0xaaf>
lea    0x791(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movsd  (%r14),%xmm5
mov    %r12d,%r15d
movapd %xmm5,%xmm2
movapd %xmm5,%xmm3
test   %r12d,%r12d
lea    0x674(%rip),%rbx
jle    1b40 <main+0x9f0>
movapd %xmm5,%xmm2
movapd %xmm5,%xmm3
cmp    $0x1,%r12d
je     1b40 <main+0x9f0>
lea    -0x1(%r15),%rdx
lea    -0x2(%r15),%rsi
mov    %edx,%eax
and    $0x3,%eax
mov    $0x1,%ecx
movapd %xmm5,%xmm0
movapd %xmm5,%xmm1
cmp    $0x3,%rsi
jb     1af9 <main+0x9a9>
and    $0xfffffffffffffffc,%rdx
movapd %xmm5,%xmm0
movapd %xmm5,%xmm1
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x8(%r14,%rcx,8),%xmm2
movsd  0x10(%r14,%rcx,8),%xmm3
movapd %xmm2,%xmm4
minsd  %xmm1,%xmm4
maxsd  %xmm0,%xmm2
movapd %xmm3,%xmm0
minsd  %xmm4,%xmm0
maxsd  %xmm2,%xmm3
movsd  0x18(%r14,%rcx,8),%xmm2
movapd %xmm2,%xmm4
minsd  %xmm0,%xmm4
maxsd  %xmm3,%xmm2
movsd  0x20(%r14,%rcx,8),%xmm0
movapd %xmm0,%xmm1
minsd  %xmm4,%xmm1
maxsd  %xmm2,%xmm0
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1aa0 <main+0x950>
add    $0x1,%rcx
movapd %xmm0,%xmm2
movapd %xmm1,%xmm3
test   %rax,%rax
je     1b40 <main+0x9f0>
lea    (%r14,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movsd  (%rcx,%rdx,8),%xmm2
movapd %xmm2,%xmm3
minsd  %xmm1,%xmm3
maxsd  %xmm0,%xmm2
add    $0x1,%rdx
movapd %xmm2,%xmm0
movapd %xmm3,%xmm1
cmp    %rdx,%rax
jne    1b10 <main+0x9c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm5,-0x98(%rbp)
ff
movsd  %xmm3,-0xb0(%rbp)
ff
movsd  %xmm2,-0x50(%rbp)
lea    0x759(%rip),%rdi
call   1030 <puts@plt>
lea    0x762(%rip),%rdi
call   1030 <puts@plt>
lea    0x76c(%rip),%rdi
call   1030 <puts@plt>
test   %r12d,%r12d
jle    1ba0 <main+0xa50>
movsd  -0x58(%rbp),%xmm0
mov    %r13,%rdi
movsd  %xmm0,-0x70(%rbp)
movsd  -0x98(%rbp),%xmm1
ff
mov    $0x2,%al
call   1040 <printf@plt>
cmp    $0x1,%r12d
jne    1bac <main+0xa5c>
mov    -0x38(%rbp),%r14
mov    %rbx,%r15
jmp    11c7 <main+0x77>
movapd -0x90(%rbp),%xmm1
ff
unpckhpd %xmm1,%xmm1
mov    $0x1,%ebx
movsd  -0x70(%rbp),%xmm0
movapd %xmm1,-0x90(%rbp)
ff
nopw   0x0(%rax,%rax,1)
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  (%r14,%rbx,8),%xmm1
mov    %r13,%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x70(%rbp),%xmm0
movapd -0x90(%rbp),%xmm1
ff
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1bd0 <main+0xa80>
lea    0x4bb(%rip),%r15
mov    -0x38(%rbp),%r14
jmp    11c7 <main+0x77>

LLVM IR (-O0):
@.str = [4 x i8] c"%s\0A\00"
@.str.1 = [69 x i8] c"\D0\A5\D0\BE\D1\82\D0\B8\D1\82\D0\B5 \D0\BB\D0\B8 \D0\B2\D1\8B \D0\B7\D0\B0\D0\BF\D1\83\D1\81\D1\82\D0\B8\D1\82\D1\8C \D0\BF\D1\80\D0\BE\D0\B3\D1\80\D0\B0\D0\BC\D0\BC\D1\83? yes/no\00"
@__const.main.yes1 = [4 x i8] c"yes\00"
@.str.2 = [3 x i8] c"%s\00"
@.str.3 = [62 x i8] c"\D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D0\B5 \D0\BF\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D0\BE\D0\B9 a \D0\BE\D1\82: \00"
@.str.4 = [4 x i8] c"%lf\00"
@.str.5 = [7 x i8] c"\D0\94\D0\BE: \00"
@.str.6 = [63 x i8] c"\D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D0\B5 \D0\BF\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D0\BE\D0\B9 x \D0\BE\D1\82: \00"
@.str.7 = [34 x i8] c"\D0\9A\D0\BE\D0\BB\D0\B8\D1\87\D0\B5\D1\81\D1\82\D0\B2\D0\BE \D1\88\D0\B0\D0\B3\D0\BE\D0\B2: \00"
@.str.8 = [3 x i8] c"%i\00"
@.str.9 = [42 x i8] c"\D0\92\D1\8B\D1\87\D0\B8\D1\81\D0\BB\D0\B8\D1\82\D1\8C \D1\84\D1\83\D0\BD\D0\BA\D1\86\D0\B8\D1\8E G, F, Y\00"
@.str.10 = [34 x i8] c"\D0\92\D1\8B\D0\B1\D0\B5\D1\80\D0\B8\D1\82\D0\B5 \D1\84\D1\83\D0\BD\D0\BA\D1\86\D0\B8\D1\8E: \00"
@.str.11 = [103 x i8] c"\D0\92\D1\85\D0\BE\D0\B4\D0\BD\D1\8B\D0\B5 \D0\B4\D0\B0\D0\BD\D0\BD\D1\8B\D0\B5 \D0\BD\D0\B5 \D0\BF\D0\BE\D0\B4\D0\BB\D0\B5\D0\B6\D0\B0\D1\82 \D0\BE\D0\B1\D0\BB\D0\B0\D1\81\D1\82\D0\B8 \D0\BE\D0\BF\D1\80\D0\B5\D0\B4\D0\B5\D0\BB\D0\B5\D0\BD\D0\B8\D1\8F \D1\84\D1\83\D0\BD\D0\BA\D1\86\D0\B8\D0\B8\00"
@.str.12 = [22 x i8] c"____________________\0A\00"
@.str.13 = [23 x i8] c"| X | Y |\0A\00"
@.str.14 = [22 x i8] c"--------------------\0A\00"
@.str.15 = [11 x i8] c"|%lf|%lf|\0A\00"
@.str.16 = [13 x i8] c"\D0\9E\D1\88\D0\B8\D0\B1\D0\BA\D0\B0\00"
@.str.17 = [7 x i8] c"%s%lf\0A\00"
@.str.18 = [58 x i8] c"\D0\9C\D0\B0\D0\BA\D1\81\D0\B8\D0\BC\D0\B0\D0\BB\D1\8C\D0\BD\D1\8B\D0\B9 \D1\8D\D0\BB\D0\B5\D0\BC\D0\B5\D0\BD\D1\82 \D0\BC\D0\B0\D1\81\D1\81\D0\B8\D0\B2\D0\B0 = \00"
@.str.19 = [56 x i8] c"\D0\9C\D0\B8\D0\BD\D0\B8\D0\BC\D0\B0\D0\BB\D1\8C\D0\BD\D1\8B\D0\B9 \D1\8D\D0\BB\D0\B5\D0\BC\D0\B5\D0\BD\D1\82 \D0\BC\D0\B0\D1\81\D1\81\D0\B8\D0\B2\D0\B0 = \00"
define i32 @main() {
%1 = alloca i32
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i8
%21 = alloca [4 x i8]
%22 = alloca [4 x i8]
%23 = alloca i8*
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
store i32 0, i32* %1
store i32 0, i32* %18
br label %27
27: ; preds = %494, %0
%28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.1, i64 0, i64 0))
%29 = bitcast [4 x i8]* %21 to i8*
%30 = getelementptr inbounds [4 x i8], [4 x i8]* %22, i64 0, i64 0
%31 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* %30)
%32 = getelementptr inbounds [4 x i8], [4 x i8]* %22, i64 0, i64 0
%33 = getelementptr inbounds [4 x i8], [4 x i8]* %21, i64 0, i64 0
%34 = call i32 @strcmp(i8* %32, i8* %33)
%35 = icmp eq i32 %34, 0
br i1 %35, label %36, label %493
36: ; preds = %27
%37 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.3, i64 0, i64 0))
%38 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double* %11)
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0))
%40 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double* %12)
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.6, i64 0, i64 0))
%42 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double* %7)
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0))
%44 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double* %8)
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.7, i64 0, i64 0))
%46 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i32* %17)
%47 = load double, double* %8
%48 = load double, double* %7
%49 = fsub double %47, %48
%50 = load i32, i32* %17
%51 = sitofp i32 %50 to double
%52 = fdiv double %49, %51
store double %52, double* %13
%53 = load double, double* %12
%54 = load double, double* %11
%55 = fsub double %53, %54
%56 = load i32, i32* %17
%57 = sitofp i32 %56 to double
%58 = fdiv double %55, %57
store double %58, double* %14
%59 = load i32, i32* %17
%60 = zext i32 %59 to i64
%61 = call i8* @llvm.stacksave()
store i8* %61, i8** %23
%62 = alloca double, i64 %60
store i64 %60, i64* %24
%63 = load i32, i32* %17
%64 = zext i32 %63 to i64
%65 = alloca double, i64 %64
store i64 %64, i64* %25
%66 = load i32, i32* %17
%67 = zext i32 %66 to i64
%68 = alloca double, i64 %67
store i64 %67, i64* %26
%69 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.9, i64 0, i64 0))
%70 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.10, i64 0, i64 0))
%71 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* %20)
%72 = load i8, i8* %20
%73 = sext i8 %72 to i32
switch i32 %73, label %485 [
i32 71, label %74
i32 70, label %221
i32 89, label %362
]
74: ; preds = %36
%75 = load double, double* %7
store double %75, double* %9
%76 = load double, double* %11
store double %76, double* %10
br label %77
77: ; preds = %150, %74
%78 = load double, double* %9
%79 = load double, double* %8
%80 = fcmp olt double %78, %79
%81 = zext i1 %80 to i32
%82 = load double, double* %10
%83 = load double, double* %12
%84 = fcmp olt double %82, %83
br i1 %84, label %85, label %157
85: ; preds = %77
%86 = load double, double* %9
store double %86, double* %3
%87 = load double, double* %10
store double %87, double* %2
%88 = load double, double* %2
%89 = fmul double 1.500000e+01, %88
%90 = load double, double* %2
%91 = load double, double* %2
%92 = fmul double 2.900000e+01, %91
%93 = load double, double* %3
%94 = fmul double %92, %93
%95 = call double @llvm.fmuladd.f64(double %89, double %90, double %94)
%96 = load double, double* %3
%97 = fmul double 1.200000e+01, %96
%98 = load double, double* %3
%99 = call double @llvm.fmuladd.f64(double %97, double %98, double %95)
%100 = fcmp oge double %99, -1.000000e-05
br i1 %100, label %101, label %117
101: ; preds = %85
%102 = load double, double* %2
%103 = fmul double 1.500000e+01, %102
%104 = load double, double* %2
%105 = load double, double* %2
%106 = fmul double 2.900000e+01, %105
%107 = load double, double* %3
%108 = fmul double %106, %107
%109 = call double @llvm.fmuladd.f64(double %103, double %104, double %108)
%110 = load double, double* %3
%111 = fmul double 1.200000e+01, %110
%112 = load double, double* %3
%113 = call double @llvm.fmuladd.f64(double %111, double %112, double %109)
%114 = fcmp ole double %113, 1.000000e-05
br i1 %114, label %115, label %117
115: ; preds = %101
%116 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.11, i64 0, i64 0))
br label %157
117: ; preds = %101, %85
%118 = load double, double* %2
%119 = fmul double 4.000000e+00, %118
%120 = load double, double* %2
%121 = load double, double* %2
%122 = fmul double 3.000000e+00, %121
%123 = load double, double* %3
%124 = fmul double %122, %123
%125 = call double @llvm.fmuladd.f64(double %119, double %120, double %124)
%126 = load double, double* %3
%127 = fmul double 1.000000e+01, %126
%128 = load double, double* %3
%129 = call double @llvm.fmuladd.f64(double %127, double %128, double %125)
%130 = load double, double* %2
%131 = fmul double 1.500000e+01, %130
%132 = load double, double* %2
%133 = load double, double* %2
%134 = fmul double 2.900000e+01, %133
%135 = load double, double* %3
%136 = fmul double %134, %135
%137 = call double @llvm.fmuladd.f64(double %131, double %132, double %136)
%138 = load double, double* %3
%139 = fmul double 1.200000e+01, %138
%140 = load double, double* %3
%141 = call double @llvm.fmuladd.f64(double %139, double %140, double %137)
%142 = fdiv double %129, %141
store double %142, double* %4
%143 = load double, double* %4
%144 = load i32, i32* %18
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds double, double* %62, i64 %145
store double %143, double* %146
%147 = load i32, i32* %18
%148 = add nsw i32 %147, 1
store i32 %148, i32* %18
br label %149
149: ; preds = %117
br label %150
150: ; preds = %149
%151 = load double, double* %13
%152 = load double, double* %9
%153 = fadd double %152, %151
store double %153, double* %9
%154 = load double, double* %14
%155 = load double, double* %10
%156 = fadd double %155, %154
store double %156, double* %10
br label %77
157: ; preds = %115, %77
%158 = getelementptr inbounds double, double* %62, i64 0
%159 = load double, double* %158
store double %159, double* %16
%160 = getelementptr inbounds double, double* %62, i64 0
%161 = load double, double* %160
store double %161, double* %15
store i32 0, i32* %19
br label %162
162: ; preds = %191, %157
%163 = load i32, i32* %19
%164 = load i32, i32* %18
%165 = icmp slt i32 %163, %164
br i1 %165, label %166, label %194
166: ; preds = %162
%167 = load i32, i32* %19
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds double, double* %62, i64 %168
%170 = load double, double* %169
%171 = load double, double* %16
%172 = fcmp olt double %170, %171
br i1 %172, label %173, label %178
173: ; preds = %166
%174 = load i32, i32* %19
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds double, double* %62, i64 %175
%177 = load double, double* %176
store double %177, double* %16
br label %178
178: ; preds = %173, %166
%179 = load i32, i32* %19
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %62, i64 %180
%182 = load double, double* %181
%183 = load double, double* %15
%184 = fcmp ogt double %182, %183
br i1 %184, label %185, label %190
185: ; preds = %178
%186 = load i32, i32* %19
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double, double* %62, i64 %187
%189 = load double, double* %188
store double %189, double* %15
br label %190
190: ; preds = %185, %178
br label %191
191: ; preds = %190
%192 = load i32, i32* %19
%193 = add nsw i32 %192, 1
store i32 %193, i32* %19
br label %162
194: ; preds = %162
%195 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.12, i64 0, i64 0))
%196 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.13, i64 0, i64 0))
%197 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0))
%198 = load double, double* %7
store double %198, double* %9
store i32 0, i32* %19
br label %199
199: ; preds = %214, %194
%200 = load double, double* %9
%201 = load double, double* %8
%202 = fcmp olt double %200, %201
%203 = zext i1 %202 to i32
%204 = load i32, i32* %19
%205 = load i32, i32* %18
%206 = icmp slt i32 %204, %205
br i1 %206, label %207, label %220
207: ; preds = %199
%208 = load double, double* %9
%209 = load i32, i32* %19
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds double, double* %62, i64 %210
%212 = load double, double* %211
%213 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0), double %208, double %212)
br label %214
214: ; preds = %207
%215 = load double, double* %13
%216 = load double, double* %9
%217 = fadd double %216, %215
store double %217, double* %9
%218 = load i32, i32* %19
%219 = add nsw i32 %218, 1
store i32 %219, i32* %19
br label %199
220: ; preds = %199
br label %487
221: ; preds = %36
%222 = load double, double* %7
store double %222, double* %9
%223 = load double, double* %11
store double %223, double* %10
br label %224
224: ; preds = %291, %221
%225 = load double, double* %9
%226 = load double, double* %8
%227 = fcmp olt double %225, %226
%228 = zext i1 %227 to i32
%229 = load double, double* %10
%230 = load double, double* %12
%231 = fcmp olt double %229, %230
br i1 %231, label %232, label %298
232: ; preds = %224
%233 = load double, double* %9
store double %233, double* %3
%234 = load double, double* %10
store double %234, double* %2
%235 = load double, double* %2
%236 = fmul double 5.000000e+00, %235
%237 = load double, double* %2
%238 = load double, double* %2
%239 = fmul double 1.400000e+01, %238
%240 = load double, double* %3
%241 = fmul double %239, %240
%242 = call double @llvm.fmuladd.f64(double %236, double %237, double %241)
%243 = load double, double* %3
%244 = fmul double 3.000000e+00, %243
%245 = load double, double* %3
%246 = fneg double %244
%247 = call double @llvm.fmuladd.f64(double %246, double %245, double %242)
%248 = call double @cos(double %247)
%249 = fcmp oge double %248, -1.000000e-05
br i1 %249, label %250, label %268
250: ; preds = %232
%251 = load double, double* %2
%252 = fmul double 5.000000e+00, %251
%253 = load double, double* %2
%254 = load double, double* %2
%255 = fmul double 1.400000e+01, %254
%256 = load double, double* %3
%257 = fmul double %255, %256
%258 = call double @llvm.fmuladd.f64(double %252, double %253, double %257)
%259 = load double, double* %3
%260 = fmul double 3.000000e+00, %259
%261 = load double, double* %3
%262 = fneg double %260
%263 = call double @llvm.fmuladd.f64(double %262, double %261, double %258)
%264 = call double @cos(double %263)
%265 = fcmp ole double %264, 1.000000e-05
br i1 %265, label %266, label %268
266: ; preds = %250
%267 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.11, i64 0, i64 0))
br label %298
268: ; preds = %250, %232
%269 = load double, double* %2
%270 = fmul double 5.000000e+00, %269
%271 = load double, double* %2
%272 = load double, double* %2
%273 = fmul double 1.400000e+01, %272
%274 = load double, double* %3
%275 = fmul double %273, %274
%276 = call double @llvm.fmuladd.f64(double %270, double %271, double %275)
%277 = load double, double* %3
%278 = fmul double 3.000000e+00, %277
%279 = load double, double* %3
%280 = fneg double %278
%281 = call double @llvm.fmuladd.f64(double %280, double %279, double %276)
%282 = call double @cos(double %281)
%283 = fdiv double 1.000000e+00, %282
store double %283, double* %5
%284 = load double, double* %5
%285 = load i32, i32* %18
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds double, double* %65, i64 %286
store double %284, double* %287
%288 = load i32, i32* %18
%289 = add nsw i32 %288, 1
store i32 %289, i32* %18
br label %290
290: ; preds = %268
br label %291
291: ; preds = %290
%292 = load double, double* %13
%293 = load double, double* %9
%294 = fadd double %293, %292
store double %294, double* %9
%295 = load double, double* %14
%296 = load double, double* %10
%297 = fadd double %296, %295
store double %297, double* %10
br label %224
298: ; preds = %266, %224
%299 = getelementptr inbounds double, double* %65, i64 0
%300 = load double, double* %299
store double %300, double* %16
%301 = getelementptr inbounds double, double* %65, i64 0
%302 = load double, double* %301
store double %302, double* %15
store i32 0, i32* %19
br label %303
303: ; preds = %332, %298
%304 = load i32, i32* %19
%305 = load i32, i32* %18
%306 = icmp slt i32 %304, %305
br i1 %306, label %307, label %335
307: ; preds = %303
%308 = load i32, i32* %19
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds double, double* %65, i64 %309
%311 = load double, double* %310
%312 = load double, double* %16
%313 = fcmp olt double %311, %312
br i1 %313, label %314, label %319
314: ; preds = %307
%315 = load i32, i32* %19
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds double, double* %65, i64 %316
%318 = load double, double* %317
store double %318, double* %16
br label %319
319: ; preds = %314, %307
%320 = load i32, i32* %19
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds double, double* %65, i64 %321
%323 = load double, double* %322
%324 = load double, double* %15
%325 = fcmp ogt double %323, %324
br i1 %325, label %326, label %331
326: ; preds = %319
%327 = load i32, i32* %19
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds double, double* %65, i64 %328
%330 = load double, double* %329
store double %330, double* %15
br label %331
331: ; preds = %326, %319
br label %332
332: ; preds = %331
%333 = load i32, i32* %19
%334 = add nsw i32 %333, 1
store i32 %334, i32* %19
br label %303
335: ; preds = %303
%336 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.12, i64 0, i64 0))
%337 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.13, i64 0, i64 0))
%338 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0))
%339 = load double, double* %7
store double %339, double* %9
store i32 0, i32* %19
br label %340
340: ; preds = %355, %335
%341 = load double, double* %9
%342 = load double, double* %8
%343 = fcmp olt double %341, %342
%344 = zext i1 %343 to i32
%345 = load i32, i32* %19
%346 = load i32, i32* %18
%347 = icmp slt i32 %345, %346
br i1 %347, label %348, label %361
348: ; preds = %340
%349 = load double, double* %9
%350 = load i32, i32* %19
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double, double* %65, i64 %351
%353 = load double, double* %352
%354 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0), double %349, double %353)
br label %355
355: ; preds = %348
%356 = load double, double* %13
%357 = load double, double* %9
%358 = fadd double %357, %356
store double %358, double* %9
%359 = load i32, i32* %19
%360 = add nsw i32 %359, 1
store i32 %360, i32* %19
br label %340
361: ; preds = %340
br label %487
362: ; preds = %36
%363 = load double, double* %7
store double %363, double* %9
%364 = load double, double* %11
store double %364, double* %10
br label %365
365: ; preds = %414, %362
%366 = load double, double* %9
%367 = load double, double* %8
%368 = fcmp olt double %366, %367
%369 = zext i1 %368 to i32
%370 = load double, double* %10
%371 = load double, double* %12
%372 = fcmp olt double %370, %371
br i1 %372, label %373, label %421
373: ; preds = %365
%374 = load double, double* %9
store double %374, double* %3
%375 = load double, double* %10
store double %375, double* %2
%376 = load double, double* %2
%377 = fmul double 9.000000e+00, %376
%378 = load double, double* %2
%379 = load double, double* %2
%380 = fmul double 4.200000e+01, %379
%381 = load double, double* %3
%382 = fmul double %380, %381
%383 = call double @llvm.fmuladd.f64(double %377, double %378, double %382)
%384 = load double, double* %3
%385 = fmul double 4.000000e+01, %384
%386 = load double, double* %3
%387 = call double @llvm.fmuladd.f64(double %385, double %386, double %383)
%388 = fadd double %387, 1.000000e+00
%389 = fcmp ole double %388, 1.000000e+00
br i1 %389, label %390, label %392
390: ; preds = %373
%391 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.11, i64 0, i64 0))
br label %421
392: ; preds = %373
%393 = load double, double* %2
%394 = fmul double 9.000000e+00, %393
%395 = load double, double* %2
%396 = load double, double* %2
%397 = fmul double 4.200000e+01, %396
%398 = load double, double* %3
%399 = fmul double %397, %398
%400 = call double @llvm.fmuladd.f64(double %394, double %395, double %399)
%401 = load double, double* %3
%402 = fmul double 4.000000e+01, %401
%403 = load double, double* %3
%404 = call double @llvm.fmuladd.f64(double %402, double %403, double %400)
%405 = fadd double %404, 1.000000e+00
%406 = call double @acosh(double %405)
store double %406, double* %6
%407 = load double, double* %6
%408 = load i32, i32* %18
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds double, double* %68, i64 %409
store double %407, double* %410
%411 = load i32, i32* %18
%412 = add nsw i32 %411, 1
store i32 %412, i32* %18
br label %413
413: ; preds = %392
br label %414
414: ; preds = %413
%415 = load double, double* %13
%416 = load double, double* %9
%417 = fadd double %416, %415
store double %417, double* %9
%418 = load double, double* %14
%419 = load double, double* %10
%420 = fadd double %419, %418
store double %420, double* %10
br label %365
421: ; preds = %390, %365
%422 = getelementptr inbounds double, double* %68, i64 0
%423 = load double, double* %422
store double %423, double* %16
%424 = getelementptr inbounds double, double* %68, i64 0
%425 = load double, double* %424
store double %425, double* %15
store i32 0, i32* %19
br label %426
426: ; preds = %455, %421
%427 = load i32, i32* %19
%428 = load i32, i32* %18
%429 = icmp slt i32 %427, %428
br i1 %429, label %430, label %458
430: ; preds = %426
%431 = load i32, i32* %19
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds double, double* %68, i64 %432
%434 = load double, double* %433
%435 = load double, double* %16
%436 = fcmp olt double %434, %435
br i1 %436, label %437, label %442
437: ; preds = %430
%438 = load i32, i32* %19
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double, double* %68, i64 %439
%441 = load double, double* %440
store double %441, double* %16
br label %442
442: ; preds = %437, %430
%443 = load i32, i32* %19
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds double, double* %68, i64 %444
%446 = load double, double* %445
%447 = load double, double* %15
%448 = fcmp ogt double %446, %447
br i1 %448, label %449, label %454
449: ; preds = %442
%450 = load i32, i32* %19
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds double, double* %68, i64 %451
%453 = load double, double* %452
store double %453, double* %15
br label %454
454: ; preds = %449, %442
br label %455
455: ; preds = %454
%456 = load i32, i32* %19
%457 = add nsw i32 %456, 1
store i32 %457, i32* %19
br label %426
458: ; preds = %426
%459 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.12, i64 0, i64 0))
%460 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.13, i64 0, i64 0))
%461 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0))
%462 = load double, double* %7
store double %462, double* %9
store i32 0, i32* %19
br label %463
463: ; preds = %478, %458
%464 = load double, double* %9
%465 = load double, double* %8
%466 = fcmp olt double %464, %465
%467 = zext i1 %466 to i32
%468 = load i32, i32* %19
%469 = load i32, i32* %18
%470 = icmp slt i32 %468, %469
br i1 %470, label %471, label %484
471: ; preds = %463
%472 = load double, double* %9
%473 = load i32, i32* %19
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds double, double* %68, i64 %474
%476 = load double, double* %475
%477 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0), double %472, double %476)
br label %478
478: ; preds = %471
%479 = load double, double* %13
%480 = load double, double* %9
%481 = fadd double %480, %479
store double %481, double* %9
%482 = load i32, i32* %19
%483 = add nsw i32 %482, 1
store i32 %483, i32* %19
br label %463
484: ; preds = %463
br label %487
485: ; preds = %36
%486 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.16, i64 0, i64 0))
br label %487
487: ; preds = %485, %484, %361, %220
%488 = load double, double* %15
%489 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.18, i64 0, i64 0), double %488)
%490 = load double, double* %16
%491 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.19, i64 0, i64 0), double %490)
%492 = load i8*, i8** %23
br label %494
493: ; preds = %27
br label %495
494: ; preds = %487
br label %27
495: ; preds = %493
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [69 x i8] c"\D0\A5\D0\BE\D1\82\D0\B8\D1\82\D0\B5 \D0\BB\D0\B8 \D0\B2\D1\8B \D0\B7\D0\B0\D0\BF\D1\83\D1\81\D1\82\D0\B8\D1\82\D1\8C \D0\BF\D1\80\D0\BE\D0\B3\D1\80\D0\B0\D0\BC\D0\BC\D1\83? yes/no\00"
@__const.main.yes1 = [4 x i8] c"yes\00"
@.str.2 = [3 x i8] c"%s\00"
@.str.3 = [62 x i8] c"\D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D0\B5 \D0\BF\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D0\BE\D0\B9 a \D0\BE\D1\82: \00"
@.str.4 = [4 x i8] c"%lf\00"
@.str.5 = [7 x i8] c"\D0\94\D0\BE: \00"
@.str.6 = [63 x i8] c"\D0\92\D0\B2\D0\B5\D0\B4\D0\B8\D1\82\D0\B5 \D0\B7\D0\BD\D0\B0\D1\87\D0\B5\D0\BD\D0\B8\D0\B5 \D0\BF\D0\B5\D1\80\D0\B5\D0\BC\D0\B5\D0\BD\D0\BD\D0\BE\D0\B9 x \D0\BE\D1\82: \00"
@.str.7 = [34 x i8] c"\D0\9A\D0\BE\D0\BB\D0\B8\D1\87\D0\B5\D1\81\D1\82\D0\B2\D0\BE \D1\88\D0\B0\D0\B3\D0\BE\D0\B2: \00"
@.str.8 = [3 x i8] c"%i\00"
@.str.9 = [42 x i8] c"\D0\92\D1\8B\D1\87\D0\B8\D1\81\D0\BB\D0\B8\D1\82\D1\8C \D1\84\D1\83\D0\BD\D0\BA\D1\86\D0\B8\D1\8E G, F, Y\00"
@.str.10 = [34 x i8] c"\D0\92\D1\8B\D0\B1\D0\B5\D1\80\D0\B8\D1\82\D0\B5 \D1\84\D1\83\D0\BD\D0\BA\D1\86\D0\B8\D1\8E: \00"
@.str.11 = [103 x i8] c"\D0\92\D1\85\D0\BE\D0\B4\D0\BD\D1\8B\D0\B5 \D0\B4\D0\B0\D0\BD\D0\BD\D1\8B\D0\B5 \D0\BD\D0\B5 \D0\BF\D0\BE\D0\B4\D0\BB\D0\B5\D0\B6\D0\B0\D1\82 \D0\BE\D0\B1\D0\BB\D0\B0\D1\81\D1\82\D0\B8 \D0\BE\D0\BF\D1\80\D0\B5\D0\B4\D0\B5\D0\BB\D0\B5\D0\BD\D0\B8\D1\8F \D1\84\D1\83\D0\BD\D0\BA\D1\86\D0\B8\D0\B8\00"
@.str.15 = [11 x i8] c"|%lf|%lf|\0A\00"
@.str.16 = [13 x i8] c"\D0\9E\D1\88\D0\B8\D0\B1\D0\BA\D0\B0\00"
@.str.17 = [7 x i8] c"%s%lf\0A\00"
@.str.18 = [58 x i8] c"\D0\9C\D0\B0\D0\BA\D1\81\D0\B8\D0\BC\D0\B0\D0\BB\D1\8C\D0\BD\D1\8B\D0\B9 \D1\8D\D0\BB\D0\B5\D0\BC\D0\B5\D0\BD\D1\82 \D0\BC\D0\B0\D1\81\D1\81\D0\B8\D0\B2\D0\B0 = \00"
@.str.19 = [56 x i8] c"\D0\9C\D0\B8\D0\BD\D0\B8\D0\BC\D0\B0\D0\BB\D1\8C\D0\BD\D1\8B\D0\B9 \D1\8D\D0\BB\D0\B5\D0\BC\D0\B5\D0\BD\D1\82 \D0\BC\D0\B0\D1\81\D1\81\D0\B8\D0\B2\D0\B0 = \00"
@str.25 = [21 x i8] c"____________________\00"
@str.26 = [22 x i8] c"| X | Y |\00"
@str.27 = [21 x i8] c"--------------------\00"
define i32 @main() {
%1 = alloca double
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca i32
%6 = alloca i8
%7 = alloca [4 x i8]
%8 = bitcast double* %1 to i8*
%9 = bitcast double* %2 to i8*
%10 = bitcast double* %3 to i8*
%11 = bitcast double* %4 to i8*
%12 = bitcast i32* %5 to i8*
%13 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.1, i64 0, i64 0))
%14 = getelementptr inbounds [4 x i8], [4 x i8]* %7, i64 0, i64 0
%15 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* %14)
%16 = call i32 @bcmp(i8* dereferenceable(4) %14, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @__const.main.yes1, i64 0, i64 0), i64 4)
%17 = icmp eq i32 %16, 0
br i1 %17, label %18, label %461
18: ; preds = %0, %451
%19 = phi i32 [ %454, %451 ], [ 0, %0 ]
%20 = phi double [ %453, %451 ], [ undef, %0 ]
%21 = phi double [ %452, %451 ], [ undef, %0 ]
%22 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @.str.3, i64 0, i64 0))
%23 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double* %3)
%24 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0))
%25 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double* %4)
%26 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @.str.6, i64 0, i64 0))
%27 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double* %1)
%28 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0))
%29 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), double* %2)
%30 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.7, i64 0, i64 0))
%31 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0), i32* %5)
%32 = load double, double* %2
%33 = load double, double* %1
%34 = load i32, i32* %5
%35 = sitofp i32 %34 to double
%36 = load double, double* %4
%37 = load double, double* %3
%38 = insertelement <2 x double> poison, double %36, i64 0
%39 = insertelement <2 x double> %38, double %32, i64 1
%40 = insertelement <2 x double> poison, double %37, i64 0
%41 = insertelement <2 x double> %40, double %33, i64 1
%42 = fsub <2 x double> %39, %41
%43 = insertelement <2 x double> poison, double %35, i64 0
%44 = shufflevector <2 x double> %43, <2 x double> poison, <2 x i32> zeroinitializer
%45 = fdiv <2 x double> %42, %44
%46 = zext i32 %34 to i64
%47 = call i8* @llvm.stacksave()
%48 = alloca double, i64 %46
%49 = load i32, i32* %5
%50 = zext i32 %49 to i64
%51 = alloca double, i64 %50
%52 = alloca double, i64 %50
%53 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.9, i64 0, i64 0))
%54 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.10, i64 0, i64 0))
%55 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* %6)
%56 = load i8, i8* %6
%57 = sext i8 %56 to i32
switch i32 %57, label %449 [
i32 71, label %58
i32 70, label %191
i32 89, label %322
]
58: ; preds = %18
%59 = load double, double* %3
%60 = load double, double* %4
%61 = fcmp olt double %59, %60
br i1 %61, label %62, label %99
62: ; preds = %58
%63 = load double, double* %1
%64 = sext i32 %19 to i64
%65 = insertelement <2 x double> poison, double %59, i64 0
%66 = insertelement <2 x double> %65, double %63, i64 1
br label %67
67: ; preds = %62, %84
%68 = phi i64 [ %64, %62 ], [ %93, %84 ]
%69 = phi <2 x double> [ %66, %62 ], [ %94, %84 ]
%70 = extractelement <2 x double> %69, i64 0
%71 = fmul double %70, 1.500000e+01
%72 = fmul double %70, 2.900000e+01
%73 = extractelement <2 x double> %69, i64 1
%74 = fmul double %72, %73
%75 = call double @llvm.fmuladd.f64(double %71, double %70, double %74)
%76 = fmul double %73, 1.200000e+01
%77 = call double @llvm.fmuladd.f64(double %76, double %73, double %75)
%78 = fcmp ult double %77, -1.000000e-05
%79 = fcmp ugt double %77, 1.000000e-05
%80 = or i1 %78, %79
br i1 %80, label %84, label %81
81: ; preds = %67
%82 = trunc i64 %68 to i32
%83 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([103 x i8], [103 x i8]* @.str.11, i64 0, i64 0))
br label %99
84: ; preds = %67
%85 = fmul double %70, 4.000000e+00
%86 = fmul double %70, 3.000000e+00
%87 = fmul double %86, %73
%88 = call double @llvm.fmuladd.f64(double %85, double %70, double %87)
%89 = fmul double %73, 1.000000e+01
%90 = call double @llvm.fmuladd.f64(double %89, double %73, double %88)
%91 = fdiv double %90, %77
%92 = getelementptr inbounds double, double* %48, i64 %68
store double %91, double* %92
%93 = add i64 %68, 1
%94 = fadd <2 x double> %45, %69
%95 = extractelement <2 x double> %94, i64 0
%96 = fcmp olt double %95, %60
br i1 %96, label %67, label %97
97: ; preds = %84
%98 = trunc i64 %93 to i32
br label %99
99: ; preds = %97, %58, %81
%100 = phi i32 [ %82, %81 ], [ %19, %58 ], [ %98, %97 ]
%101 = load double, double* %48
%102 = icmp sgt i32 %100, 0
br i1 %102, label %103, label %169
103: ; preds = %99
%104 = zext i32 %100 to i64
%105 = icmp eq i32 %100, 1
br i1 %105, label %169, label %106
106: ; preds = %103
%107 = add nsw i64 %104, -1
%108 = add nsw i64 %104, -2
%109 = and i64 %107, 3
%110 = icmp ult i64 %108, 3
br i1 %110, label %148, label %111
111: ; preds = %106
%112 = and i64 %107, -4
br label %113
113: ; preds = %113, %111
%114 = phi i64 [ 1, %111 ], [ %145, %113 ]
%115 = phi double [ %101, %111 ], [ %144, %113 ]
%116 = phi double [ %101, %111 ], [ %142, %113 ]
%117 = phi i64 [ 0, %111 ], [ %146, %113 ]
%118 = getelementptr inbounds double, double* %48, i64 %114
%119 = load double, double* %118
%120 = fcmp olt double %119, %116
%121 = select i1 %120, double %119, double %116
%122 = fcmp ogt double %119, %115
%123 = select i1 %122, double %119, double %115
%124 = add nuw nsw i64 %114, 1
%125 = getelementptr inbounds double, double* %48, i64 %124
%126 = load double, double* %125
%127 = fcmp olt double %126, %121
%128 = select i1 %127, double %126, double %121
%129 = fcmp ogt double %126, %123
%130 = select i1 %129, double %126, double %123
%131 = add nuw nsw i64 %114, 2
%132 = getelementptr inbounds double, double* %48, i64 %131
%133 = load double, double* %132
%134 = fcmp olt double %133, %128
%135 = select i1 %134, double %133, double %128
%136 = fcmp ogt double %133, %130
%137 = select i1 %136, double %133, double %130
%138 = add nuw nsw i64 %114, 3
%139 = getelementptr inbounds double, double* %48, i64 %138
%140 = load double, double* %139
%141 = fcmp olt double %140, %135
%142 = select i1 %141, double %140, double %135
%143 = fcmp ogt double %140, %137
%144 = select i1 %143, double %140, double %137
%145 = add nuw nsw i64 %114, 4
%146 = add i64 %117, 4
%147 = icmp eq i64 %146, %112
br i1 %147, label %148, label %113
148: ; preds = %113, %106
%149 = phi double [ undef, %106 ], [ %142, %113 ]
%150 = phi double [ undef, %106 ], [ %144, %113 ]
%151 = phi i64 [ 1, %106 ], [ %145, %113 ]
%152 = phi double [ %101, %106 ], [ %144, %113 ]
%153 = phi double [ %101, %106 ], [ %142, %113 ]
%154 = icmp eq i64 %109, 0
br i1 %154, label %169, label %155
155: ; preds = %148, %155
%156 = phi i64 [ %166, %155 ], [ %151, %148 ]
%157 = phi double [ %165, %155 ], [ %152, %148 ]
%158 = phi double [ %163, %155 ], [ %153, %148 ]
%159 = phi i64 [ %167, %155 ], [ 0, %148 ]
%160 = getelementptr inbounds double, double* %48, i64 %156
%161 = load double, double* %160
%162 = fcmp olt double %161, %158
%163 = select i1 %162, double %161, double %158
%164 = fcmp ogt double %161, %157
%165 = select i1 %164, double %161, double %157
%166 = add nuw nsw i64 %156, 1
%167 = add i64 %159, 1
%168 = icmp eq i64 %167, %109
br i1 %168, label %169, label %155
169: ; preds = %148, %155, %103, %99
%170 = phi double [ %101, %99 ], [ %101, %103 ], [ %150, %148 ], [ %165, %155 ]
%171 = phi double [ %101, %99 ], [ %101, %103 ], [ %149, %148 ], [ %163, %155 ]
%172 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.25, i64 0, i64 0))
%173 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.26, i64 0, i64 0))
%174 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.27, i64 0, i64 0))
br i1 %102, label %175, label %451
175: ; preds = %169
%176 = load double, double* %1
%177 = zext i32 %100 to i64
%178 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0), double %176, double %101)
%179 = icmp eq i32 %100, 1
br i1 %179, label %451, label %180
180: ; preds = %175
%181 = extractelement <2 x double> %45, i64 1
br label %182
182: ; preds = %180, %182
%183 = phi i64 [ %189, %182 ], [ 1, %180 ]
%184 = phi double [ %185, %182 ], [ %176, %180 ]
%185 = fadd double %181, %184
%186 = getelementptr inbounds double, double* %48, i64 %183
%187 = load double, double* %186
%188 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0), double %185, double %187)
%189 = add nuw nsw i64 %183, 1
%190 = icmp eq i64 %189, %177
br i1 %190, label %451, label %182
191: ; preds = %18
%192 = load double, double* %3
%193 = load double, double* %4
%194 = fcmp olt double %192, %193
br i1 %194, label %195, label %230
195: ; preds = %191
%196 = load double, double* %1
%197 = sext i32 %19 to i64
%198 = insertelement <2 x double> poison, double %192, i64 0
%199 = insertelement <2 x double> %198, double %196, i64 1
br label %200
200: ; preds = %195, %219
%201 = phi i64 [ %197, %195 ], [ %223, %219 ]
%202 = phi <2 x double> [ %199, %195 ], [ %224, %219 ]
%203 = extractelement <2 x double> %202, i64 0
%204 = fmul double %203, 5.000000e+00
%205 = fmul double %203, 1.400000e+01
%206 = extractelement <2 x double> %202, i64 1
%207 = fmul double %205, %206
%208 = call double @llvm.fmuladd.f64(double %204, double %203, double %207)
%209 = fmul double %206, -3.000000e+00
%210 = call double @llvm.fmuladd.f64(double %209, double %206, double %208)
%211 = call double @cos(double %210)
%212 = fcmp ult double %211, -1.000000e-05
br i1 %212, label %219, label %213
213: ; preds = %200
%214 = call double @cos(double %210)
%215 = fcmp ugt double %214, 1.000000e-05
br i1 %215, label %219, label %216
216: ; preds = %213
%217 = trunc i64 %201 to i32
%218 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([103 x i8], [103 x i8]* @.str.11, i64 0, i64 0))
br label %230
219: ; preds = %213, %200
%220 = call double @cos(double %210)
%221 = fdiv double 1.000000e+00, %220
%222 = getelementptr inbounds double, double* %51, i64 %201
store double %221, double* %222
%223 = add i64 %201, 1
%224 = fadd <2 x double> %45, %202
%225 = load double, double* %4
%226 = extractelement <2 x double> %224, i64 0
%227 = fcmp olt double %226, %225
br i1 %227, label %200, label %228
228: ; preds = %219
%229 = trunc i64 %223 to i32
br label %230
230: ; preds = %228, %191, %216
%231 = phi i32 [ %217, %216 ], [ %19, %191 ], [ %229, %228 ]
%232 = load double, double* %51
%233 = icmp sgt i32 %231, 0
br i1 %233, label %234, label %300
234: ; preds = %230
%235 = zext i32 %231 to i64
%236 = icmp eq i32 %231, 1
br i1 %236, label %300, label %237
237: ; preds = %234
%238 = add nsw i64 %235, -1
%239 = add nsw i64 %235, -2
%240 = and i64 %238, 3
%241 = icmp ult i64 %239, 3
br i1 %241, label %279, label %242
242: ; preds = %237
%243 = and i64 %238, -4
br label %244
244: ; preds = %244, %242
%245 = phi i64 [ 1, %242 ], [ %276, %244 ]
%246 = phi double [ %232, %242 ], [ %275, %244 ]
%247 = phi double [ %232, %242 ], [ %273, %244 ]
%248 = phi i64 [ 0, %242 ], [ %277, %244 ]
%249 = getelementptr inbounds double, double* %51, i64 %245
%250 = load double, double* %249
%251 = fcmp olt double %250, %247
%252 = select i1 %251, double %250, double %247
%253 = fcmp ogt double %250, %246
%254 = select i1 %253, double %250, double %246
%255 = add nuw nsw i64 %245, 1
%256 = getelementptr inbounds double, double* %51, i64 %255
%257 = load double, double* %256
%258 = fcmp olt double %257, %252
%259 = select i1 %258, double %257, double %252
%260 = fcmp ogt double %257, %254
%261 = select i1 %260, double %257, double %254
%262 = add nuw nsw i64 %245, 2
%263 = getelementptr inbounds double, double* %51, i64 %262
%264 = load double, double* %263
%265 = fcmp olt double %264, %259
%266 = select i1 %265, double %264, double %259
%267 = fcmp ogt double %264, %261
%268 = select i1 %267, double %264, double %261
%269 = add nuw nsw i64 %245, 3
%270 = getelementptr inbounds double, double* %51, i64 %269
%271 = load double, double* %270
%272 = fcmp olt double %271, %266
%273 = select i1 %272, double %271, double %266
%274 = fcmp ogt double %271, %268
%275 = select i1 %274, double %271, double %268
%276 = add nuw nsw i64 %245, 4
%277 = add i64 %248, 4
%278 = icmp eq i64 %277, %243
br i1 %278, label %279, label %244
279: ; preds = %244, %237
%280 = phi double [ undef, %237 ], [ %273, %244 ]
%281 = phi double [ undef, %237 ], [ %275, %244 ]
%282 = phi i64 [ 1, %237 ], [ %276, %244 ]
%283 = phi double [ %232, %237 ], [ %275, %244 ]
%284 = phi double [ %232, %237 ], [ %273, %244 ]
%285 = icmp eq i64 %240, 0
br i1 %285, label %300, label %286
286: ; preds = %279, %286
%287 = phi i64 [ %297, %286 ], [ %282, %279 ]
%288 = phi double [ %296, %286 ], [ %283, %279 ]
%289 = phi double [ %294, %286 ], [ %284, %279 ]
%290 = phi i64 [ %298, %286 ], [ 0, %279 ]
%291 = getelementptr inbounds double, double* %51, i64 %287
%292 = load double, double* %291
%293 = fcmp olt double %292, %289
%294 = select i1 %293, double %292, double %289
%295 = fcmp ogt double %292, %288
%296 = select i1 %295, double %292, double %288
%297 = add nuw nsw i64 %287, 1
%298 = add i64 %290, 1
%299 = icmp eq i64 %298, %240
br i1 %299, label %300, label %286
300: ; preds = %279, %286, %234, %230
%301 = phi double [ %232, %230 ], [ %232, %234 ], [ %281, %279 ], [ %296, %286 ]
%302 = phi double [ %232, %230 ], [ %232, %234 ], [ %280, %279 ], [ %294, %286 ]
%303 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.25, i64 0, i64 0))
%304 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.26, i64 0, i64 0))
%305 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.27, i64 0, i64 0))
br i1 %233, label %306, label %451
306: ; preds = %300
%307 = load double, double* %1
%308 = zext i32 %231 to i64
%309 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0), double %307, double %232)
%310 = icmp eq i32 %231, 1
br i1 %310, label %451, label %311
311: ; preds = %306
%312 = extractelement <2 x double> %45, i64 1
br label %313
313: ; preds = %311, %313
%314 = phi i64 [ %320, %313 ], [ 1, %311 ]
%315 = phi double [ %316, %313 ], [ %307, %311 ]
%316 = fadd double %312, %315
%317 = getelementptr inbounds double, double* %51, i64 %314
%318 = load double, double* %317
%319 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0), double %316, double %318)
%320 = add nuw nsw i64 %314, 1
%321 = icmp eq i64 %320, %308
br i1 %321, label %451, label %313
322: ; preds = %18
%323 = load double, double* %3
%324 = load double, double* %4
%325 = fcmp olt double %323, %324
br i1 %325, label %326, label %357
326: ; preds = %322
%327 = load double, double* %1
%328 = sext i32 %19 to i64
%329 = insertelement <2 x double> poison, double %323, i64 0
%330 = insertelement <2 x double> %329, double %327, i64 1
br label %331
331: ; preds = %326, %347
%332 = phi i64 [ %328, %326 ], [ %350, %347 ]
%333 = phi <2 x double> [ %330, %326 ], [ %351, %347 ]
%334 = extractelement <2 x double> %333, i64 0
%335 = fmul double %334, 9.000000e+00
%336 = fmul double %334, 4.200000e+01
%337 = extractelement <2 x double> %333, i64 1
%338 = fmul double %336, %337
%339 = call double @llvm.fmuladd.f64(double %335, double %334, double %338)
%340 = fmul double %337, 4.000000e+01
%341 = call double @llvm.fmuladd.f64(double %340, double %337, double %339)
%342 = fadd double %341, 1.000000e+00
%343 = fcmp ugt double %342, 1.000000e+00
br i1 %343, label %347, label %344
344: ; preds = %331
%345 = trunc i64 %332 to i32
%346 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([103 x i8], [103 x i8]* @.str.11, i64 0, i64 0))
br label %357
347: ; preds = %331
%348 = call double @acosh(double %342)
%349 = getelementptr inbounds double, double* %52, i64 %332
store double %348, double* %349
%350 = add i64 %332, 1
%351 = fadd <2 x double> %45, %333
%352 = load double, double* %4
%353 = extractelement <2 x double> %351, i64 0
%354 = fcmp olt double %353, %352
br i1 %354, label %331, label %355
355: ; preds = %347
%356 = trunc i64 %350 to i32
br label %357
357: ; preds = %355, %322, %344
%358 = phi i32 [ %345, %344 ], [ %19, %322 ], [ %356, %355 ]
%359 = load double, double* %52
%360 = icmp sgt i32 %358, 0
br i1 %360, label %361, label %427
361: ; preds = %357
%362 = zext i32 %358 to i64
%363 = icmp eq i32 %358, 1
br i1 %363, label %427, label %364
364: ; preds = %361
%365 = add nsw i64 %362, -1
%366 = add nsw i64 %362, -2
%367 = and i64 %365, 3
%368 = icmp ult i64 %366, 3
br i1 %368, label %406, label %369
369: ; preds = %364
%370 = and i64 %365, -4
br label %371
371: ; preds = %371, %369
%372 = phi i64 [ 1, %369 ], [ %403, %371 ]
%373 = phi double [ %359, %369 ], [ %402, %371 ]
%374 = phi double [ %359, %369 ], [ %400, %371 ]
%375 = phi i64 [ 0, %369 ], [ %404, %371 ]
%376 = getelementptr inbounds double, double* %52, i64 %372
%377 = load double, double* %376
%378 = fcmp olt double %377, %374
%379 = select i1 %378, double %377, double %374
%380 = fcmp ogt double %377, %373
%381 = select i1 %380, double %377, double %373
%382 = add nuw nsw i64 %372, 1
%383 = getelementptr inbounds double, double* %52, i64 %382
%384 = load double, double* %383
%385 = fcmp olt double %384, %379
%386 = select i1 %385, double %384, double %379
%387 = fcmp ogt double %384, %381
%388 = select i1 %387, double %384, double %381
%389 = add nuw nsw i64 %372, 2
%390 = getelementptr inbounds double, double* %52, i64 %389
%391 = load double, double* %390
%392 = fcmp olt double %391, %386
%393 = select i1 %392, double %391, double %386
%394 = fcmp ogt double %391, %388
%395 = select i1 %394, double %391, double %388
%396 = add nuw nsw i64 %372, 3
%397 = getelementptr inbounds double, double* %52, i64 %396
%398 = load double, double* %397
%399 = fcmp olt double %398, %393
%400 = select i1 %399, double %398, double %393
%401 = fcmp ogt double %398, %395
%402 = select i1 %401, double %398, double %395
%403 = add nuw nsw i64 %372, 4
%404 = add i64 %375, 4
%405 = icmp eq i64 %404, %370
br i1 %405, label %406, label %371
406: ; preds = %371, %364
%407 = phi double [ undef, %364 ], [ %400, %371 ]
%408 = phi double [ undef, %364 ], [ %402, %371 ]
%409 = phi i64 [ 1, %364 ], [ %403, %371 ]
%410 = phi double [ %359, %364 ], [ %402, %371 ]
%411 = phi double [ %359, %364 ], [ %400, %371 ]
%412 = icmp eq i64 %367, 0
br i1 %412, label %427, label %413
413: ; preds = %406, %413
%414 = phi i64 [ %424, %413 ], [ %409, %406 ]
%415 = phi double [ %423, %413 ], [ %410, %406 ]
%416 = phi double [ %421, %413 ], [ %411, %406 ]
%417 = phi i64 [ %425, %413 ], [ 0, %406 ]
%418 = getelementptr inbounds double, double* %52, i64 %414
%419 = load double, double* %418
%420 = fcmp olt double %419, %416
%421 = select i1 %420, double %419, double %416
%422 = fcmp ogt double %419, %415
%423 = select i1 %422, double %419, double %415
%424 = add nuw nsw i64 %414, 1
%425 = add i64 %417, 1
%426 = icmp eq i64 %425, %367
br i1 %426, label %427, label %413
427: ; preds = %406, %413, %361, %357
%428 = phi double [ %359, %357 ], [ %359, %361 ], [ %408, %406 ], [ %423, %413 ]
%429 = phi double [ %359, %357 ], [ %359, %361 ], [ %407, %406 ], [ %421, %413 ]
%430 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.25, i64 0, i64 0))
%431 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.26, i64 0, i64 0))
%432 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.27, i64 0, i64 0))
br i1 %360, label %433, label %451
433: ; preds = %427
%434 = load double, double* %1
%435 = zext i32 %358 to i64
%436 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0), double %434, double %359)
%437 = icmp eq i32 %358, 1
br i1 %437, label %451, label %438
438: ; preds = %433
%439 = extractelement <2 x double> %45, i64 1
br label %440
440: ; preds = %438, %440
%441 = phi i64 [ %447, %440 ], [ 1, %438 ]
%442 = phi double [ %443, %440 ], [ %434, %438 ]
%443 = fadd double %439, %442
%444 = getelementptr inbounds double, double* %52, i64 %441
%445 = load double, double* %444
%446 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.15, i64 0, i64 0), double %443, double %445)
%447 = add nuw nsw i64 %441, 1
%448 = icmp eq i64 %447, %435
br i1 %448, label %451, label %440
449: ; preds = %18
%450 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.16, i64 0, i64 0))
br label %451
451: ; preds = %440, %313, %182, %433, %306, %175, %427, %300, %169, %449
%452 = phi double [ %21, %449 ], [ %170, %169 ], [ %301, %300 ], [ %428, %427 ], [ %170, %175 ], [ %301, %306 ], [ %428, %433 ], [ %170, %182 ], [ %301, %313 ], [ %428, %440 ]
%453 = phi double [ %20, %449 ], [ %171, %169 ], [ %302, %300 ], [ %429, %427 ], [ %171, %175 ], [ %302, %306 ], [ %429, %433 ], [ %171, %182 ], [ %302, %313 ], [ %429, %440 ]
%454 = phi i32 [ %19, %449 ], [ %100, %169 ], [ %231, %300 ], [ %358, %427 ], [ %100, %175 ], [ %231, %306 ], [ %358, %433 ], [ %100, %182 ], [ %231, %313 ], [ %358, %440 ]
%455 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.18, i64 0, i64 0), double %452)
%456 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.19, i64 0, i64 0), double %453)
%457 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.1, i64 0, i64 0))
%458 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* %14)
%459 = call i32 @bcmp(i8* dereferenceable(4) %14, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @__const.main.yes1, i64 0, i64 0), i64 4)
%460 = icmp eq i32 %459, 0
br i1 %460, label %18, label %461
461: ; preds = %451, %0
ret i32 0
}