int main() {
  double a, x, G, F, Y, from_x, to_x, i, j, from_a, to_a, x_step, a_step;
  long int steps, arrayc = 0, counter = 0, coincidences = 0, string_index = 0;
  char b, string_value[100], sample[100], string_array[100], one_string[1000];
  for (;;) {
    printf("%s\n", "Хотите ли вы запустить программу? yes/no");
    char yes1[4] = "yes";
    char yes2[4];
    scanf("%s", yes2);
    if (strcmp(yes2, yes1) == 0) {
      printf("Введите значение переменной a от: ");
      scanf("%s", string_value);
      from_a = atof(string_value);
      printf("До: ");
      scanf("%s", string_value);
      to_a = atof(string_value);
      printf("Введите значение переменной x от:  ");
      scanf("%s", string_value);
      from_x = atof(string_value);
      printf("До: ");
      scanf("%s", string_value);
      to_x = atof(string_value);
      printf("Количество шагов: ");
      scanf("%s", string_value);
      steps = atoi(string_value);
      printf("Введите шаблон: ");
      scanf("%s", sample);
      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;
          }
        }
        for (counter = 0; counter < arrayc; counter++) {
          sprintf(string_array, "%lf", G_array[counter]);
          strcat(one_string, string_array);
        }
        while (string_index < strlen(one_string)) {
          if (strstr(one_string, sample) - one_string + 1 <
              strlen(one_string)) {
            coincidences++;
            string_index = strstr(one_string, sample) - one_string + 1;
            while (counter != string_index) {
              one_string[counter] = '_';
              counter++;
            }
            counter = 0;
          }
          if (strstr(one_string, sample) == 0)
            break;
        }
        printf("Количество найденых совпадений: %li\n", coincidences);
        coincidences = 0;
        string_index = strlen(one_string);
        while (string_index != 0) {
          for (counter = 0; counter < string_index; counter++) {
            one_string[counter] = one_string[counter + 1];
          }
          string_index--;
        }
        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;
          }
        }
        for (counter = 0; counter < arrayc; counter++) {
          sprintf(string_array, "%lf", F_array[counter]);
          strcat(one_string, string_array);
        }
        while (string_index < strlen(one_string)) {
          if (strstr(one_string, sample) - one_string + 1 <
              strlen(one_string)) {
            coincidences++;
            string_index = strstr(one_string, sample) - one_string + 1;
            while (counter != string_index) {
              one_string[counter] = '_';
              counter++;
            }
            counter = 0;
          }
          if (strstr(one_string, sample) == 0)
            break;
        }
        printf("Количество найденых совпадений: %li\n", coincidences);
        coincidences = 0;
        string_index = strlen(one_string);
        while (string_index != 0) {
          for (counter = 0; counter < string_index; counter++) {
            one_string[counter] = one_string[counter + 1];
          }
          string_index--;
        }
        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;
          }
        }
        for (counter = 0; counter < arrayc; counter++) {
          sprintf(string_array, "%lf", Y_array[counter]);
          strcat(one_string, string_array);
        }
        while (string_index < strlen(one_string)) {
          if (strstr(one_string, sample) - one_string + 1 <
              strlen(one_string)) {
            coincidences++;
            string_index = strstr(one_string, sample) - one_string + 1;
            while (counter != string_index) {
              one_string[counter] = '_';
              counter++;
            }
            counter = 0;
          }
          if (strstr(one_string, sample) == 0)
            break;
        }
        printf("Количество найденых совпадений: %li\n", coincidences);
        coincidences = 0;
        string_index = strlen(one_string);
        while (string_index != 0) {
          for (counter = 0; counter < string_index; counter++) {
            one_string[counter] = one_string[counter + 1];
          }
          string_index--;
        }
        break;
      default:
        printf("%s\n", "Ошибка");
      }
    } else
      break;
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x660,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0x0,-0x80(%rbp)
movq   $0x0,-0x88(%rbp)
movq   $0x0,-0x90(%rbp)
movq   $0x0,-0x98(%rbp)
lea    0x1e7e(%rip),%rdi
lea    0x1e7b(%rip),%rsi
mov    $0x0,%al
call   1050 <printf@plt>
mov    0x1eb3(%rip),%eax
mov    %eax,-0x5d4(%rbp)
lea    -0x5d8(%rbp),%rsi
lea    0x1ea3(%rip),%rdi
mov    $0x0,%al
call   1080 <scanf@plt>
lea    -0x5d8(%rbp),%rdi
lea    -0x5d4(%rbp),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    2132 <main+0xf82>
lea    0x1e7c(%rip),%rdi
xor    %eax,%eax
mov    %al,-0x5fd(%rbp)
call   1050 <printf@plt>
mov    -0x5fd(%rbp),%al
lea    0x1e5f(%rip),%rdi
mov    %rdi,-0x608(%rbp)
lea    -0x100(%rbp),%rsi
mov    %rsi,-0x628(%rbp)
call   1080 <scanf@plt>
mov    -0x628(%rbp),%rdi
mov    -0x5fd(%rbp),%al
call   1030 <atof@plt>
mov    %eax,%ecx
mov    -0x5fd(%rbp),%al
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,-0x58(%rbp)
lea    0x1e5c(%rip),%rdi
mov    %rdi,-0x630(%rbp)
call   1050 <printf@plt>
mov    -0x628(%rbp),%rsi
mov    -0x608(%rbp),%rdi
mov    -0x5fd(%rbp),%al
call   1080 <scanf@plt>
mov    -0x628(%rbp),%rdi
mov    -0x5fd(%rbp),%al
call   1030 <atof@plt>
mov    %eax,%ecx
mov    -0x5fd(%rbp),%al
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,-0x60(%rbp)
lea    0x1e14(%rip),%rdi
call   1050 <printf@plt>
mov    -0x628(%rbp),%rsi
mov    -0x608(%rbp),%rdi
mov    -0x5fd(%rbp),%al
call   1080 <scanf@plt>
mov    -0x628(%rbp),%rdi
mov    -0x5fd(%rbp),%al
call   1030 <atof@plt>
mov    -0x630(%rbp),%rdi
mov    %eax,%ecx
mov    -0x5fd(%rbp),%al
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,-0x38(%rbp)
call   1050 <printf@plt>
mov    -0x628(%rbp),%rsi
mov    -0x608(%rbp),%rdi
mov    -0x5fd(%rbp),%al
call   1080 <scanf@plt>
mov    -0x628(%rbp),%rdi
mov    -0x5fd(%rbp),%al
call   1030 <atof@plt>
mov    %eax,%ecx
mov    -0x5fd(%rbp),%al
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,-0x40(%rbp)
lea    0x1dc3(%rip),%rdi
call   1050 <printf@plt>
mov    -0x628(%rbp),%rsi
mov    -0x608(%rbp),%rdi
mov    -0x5fd(%rbp),%al
call   1080 <scanf@plt>
mov    -0x628(%rbp),%rdi
mov    -0x5fd(%rbp),%al
call   10a0 <atoi@plt>
mov    %eax,%ecx
mov    -0x5fd(%rbp),%al
movslq %ecx,%rcx
mov    %rcx,-0x78(%rbp)
lea    0x1d9f(%rip),%rdi
call   1050 <printf@plt>
mov    -0x608(%rbp),%rdi
mov    -0x5fd(%rbp),%al
lea    -0x170(%rbp),%rsi
call   1080 <scanf@plt>
mov    -0x5fd(%rbp),%al
movsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
subsd  %xmm1,%xmm0
cvtsi2sdq -0x78(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
subsd  %xmm1,%xmm0
cvtsi2sdq -0x78(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x78(%rbp),%rcx
mov    %rsp,%rdx
mov    %rdx,-0x5e0(%rbp)
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x620(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x5e8(%rbp)
mov    -0x78(%rbp),%rcx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x618(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x5f0(%rbp)
mov    -0x78(%rbp),%rcx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x610(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x5f8(%rbp)
lea    0x1bc5(%rip),%rdi
lea    0x1cd2(%rip),%rsi
call   1050 <printf@plt>
mov    -0x608(%rbp),%rdi
mov    -0x5fd(%rbp),%al
lea    0x1ce3(%rip),%rsi
call   1050 <printf@plt>
mov    -0x608(%rbp),%rdi
mov    -0x5fd(%rbp),%al
lea    -0x99(%rbp),%rsi
call   1080 <scanf@plt>
movsbl -0x99(%rbp),%eax
mov    %eax,-0x5fc(%rbp)
sub    $0x46,%eax
je     1945 <main+0x795>
jmp    1504 <main+0x354>
mov    -0x5fc(%rbp),%eax
sub    $0x47,%eax
je     152c <main+0x37c>
jmp    1518 <main+0x368>
mov    -0x5fc(%rbp),%eax
sub    $0x59,%eax
je     1d7a <main+0xbca>
jmp    210e <main+0xf5e>
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    1709 <main+0x559>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  0x1ae8(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0x1ace(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1aac(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1a6a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     162b <main+0x47b>
movsd  0x1a90(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm2
movsd  0x1a76(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1a54(%rip),%xmm1
mulsd  -0x18(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1a32(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     162b <main+0x47b>
lea    0x1bb1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1709 <main+0x559>
mov    -0x620(%rbp),%rax
movsd  0x1a2e(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0x19dc(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x19fa(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x19d8(%rip),%xmm2
mulsd  -0x10(%rbp),%xmm2
movsd  -0x10(%rbp),%xmm3
movsd  0x19be(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x199c(%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
mov    -0x80(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    16e6 <main+0x536>
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    1540 <main+0x390>
movq   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x80(%rbp),%rax
jge    1777 <main+0x5c7>
mov    -0x620(%rbp),%rax
lea    -0x1e0(%rbp),%rdi
mov    -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x1af1(%rip),%rsi
mov    $0x1,%al
call   10c0 <sprintf@plt>
lea    -0x5d0(%rbp),%rdi
lea    -0x1e0(%rbp),%rsi
call   10b0 <strcat@plt>
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    1714 <main+0x564>
jmp    177c <main+0x5cc>
mov    -0x98(%rbp),%rax
mov    %rax,-0x638(%rbp)
lea    -0x5d0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,%rcx
mov    -0x638(%rbp),%rax
cmp    %rcx,%rax
jae    1896 <main+0x6e6>
lea    -0x5d0(%rbp),%rdi
lea    -0x170(%rbp),%rsi
call   10d0 <strstr@plt>
lea    -0x5d0(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x640(%rbp)
lea    -0x5d0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,%rcx
mov    -0x640(%rbp),%rax
cmp    %rcx,%rax
jae    186f <main+0x6bf>
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
lea    -0x5d0(%rbp),%rdi
lea    -0x170(%rbp),%rsi
call   10d0 <strstr@plt>
lea    -0x5d0(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x98(%rbp),%rax
je     1864 <main+0x6b4>
mov    -0x88(%rbp),%rax
movb   $0x5f,-0x5d0(%rbp,%rax,1)
5f
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    182a <main+0x67a>
movq   $0x0,-0x88(%rbp)
lea    -0x5d0(%rbp),%rdi
lea    -0x170(%rbp),%rsi
call   10d0 <strstr@plt>
cmp    $0x0,%rax
jne    1891 <main+0x6e1>
jmp    1896 <main+0x6e6>
jmp    177c <main+0x5cc>
mov    -0x90(%rbp),%rsi
lea    0x1997(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movq   $0x0,-0x90(%rbp)
lea    -0x5d0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x98(%rbp)
cmpq   $0x0,-0x98(%rbp)
je     1940 <main+0x790>
movq   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x98(%rbp),%rax
jge    1929 <main+0x779>
mov    -0x88(%rbp),%rax
mov    -0x5cf(%rbp,%rax,1),%cl
mov    -0x88(%rbp),%rax
mov    %cl,-0x5d0(%rbp,%rax,1)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    18e2 <main+0x732>
mov    -0x98(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x98(%rbp)
jmp    18c9 <main+0x719>
jmp    2123 <main+0xf73>
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    1b3e <main+0x98e>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  0x16af(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0x1695(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1673(%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   1090 <cos@plt>
movsd  0x1635(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1a7f <main+0x8cf>
movsd  0x163b(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0x1621(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x15ff(%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   1090 <cos@plt>
movaps %xmm0,%xmm1
movsd  0x15de(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1a7f <main+0x8cf>
lea    0x175d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1b3e <main+0x98e>
movsd  0x15b1(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0x1597(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1575(%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   1090 <cos@plt>
mov    -0x618(%rbp),%rax
movaps %xmm0,%xmm1
movsd  0x150d(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
mov    -0x80(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    1b1b <main+0x96b>
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    1959 <main+0x7a9>
movq   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x80(%rbp),%rax
jge    1bac <main+0x9fc>
mov    -0x618(%rbp),%rax
lea    -0x1e0(%rbp),%rdi
mov    -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x16bc(%rip),%rsi
mov    $0x1,%al
call   10c0 <sprintf@plt>
lea    -0x5d0(%rbp),%rdi
lea    -0x1e0(%rbp),%rsi
call   10b0 <strcat@plt>
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    1b49 <main+0x999>
jmp    1bb1 <main+0xa01>
mov    -0x98(%rbp),%rax
mov    %rax,-0x648(%rbp)
lea    -0x5d0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,%rcx
mov    -0x648(%rbp),%rax
cmp    %rcx,%rax
jae    1ccb <main+0xb1b>
lea    -0x5d0(%rbp),%rdi
lea    -0x170(%rbp),%rsi
call   10d0 <strstr@plt>
lea    -0x5d0(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x650(%rbp)
lea    -0x5d0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,%rcx
mov    -0x650(%rbp),%rax
cmp    %rcx,%rax
jae    1ca4 <main+0xaf4>
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
lea    -0x5d0(%rbp),%rdi
lea    -0x170(%rbp),%rsi
call   10d0 <strstr@plt>
lea    -0x5d0(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x98(%rbp),%rax
je     1c99 <main+0xae9>
mov    -0x88(%rbp),%rax
movb   $0x5f,-0x5d0(%rbp,%rax,1)
5f
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    1c5f <main+0xaaf>
movq   $0x0,-0x88(%rbp)
lea    -0x5d0(%rbp),%rdi
lea    -0x170(%rbp),%rsi
call   10d0 <strstr@plt>
cmp    $0x0,%rax
jne    1cc6 <main+0xb16>
jmp    1ccb <main+0xb1b>
jmp    1bb1 <main+0xa01>
mov    -0x90(%rbp),%rsi
lea    0x1562(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movq   $0x0,-0x90(%rbp)
lea    -0x5d0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x98(%rbp)
cmpq   $0x0,-0x98(%rbp)
je     1d75 <main+0xbc5>
movq   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x98(%rbp),%rax
jge    1d5e <main+0xbae>
mov    -0x88(%rbp),%rax
mov    -0x5cf(%rbp,%rax,1),%cl
mov    -0x88(%rbp),%rax
mov    %cl,-0x5d0(%rbp,%rax,1)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    1d17 <main+0xb67>
mov    -0x98(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x98(%rbp)
jmp    1cfe <main+0xb4e>
jmp    2123 <main+0xf73>
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    1ed2 <main+0xd22>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x10(%rbp)
movsd  0x125a(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm2
movsd  0x1240(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x121e(%rip),%xmm1
mulsd  -0x18(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x11fc(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0x11f0(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1e2d <main+0xc7d>
lea    0x13af(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1ed2 <main+0xd22>
movsd  0x11e3(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
movsd  0x11c9(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x11a7(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1185(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1060 <acosh@plt>
mov    -0x610(%rbp),%rax
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
mov    -0x80(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    1eaf <main+0xcff>
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    1d8e <main+0xbde>
movq   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x80(%rbp),%rax
jge    1f40 <main+0xd90>
mov    -0x610(%rbp),%rax
lea    -0x1e0(%rbp),%rdi
mov    -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x1328(%rip),%rsi
mov    $0x1,%al
call   10c0 <sprintf@plt>
lea    -0x5d0(%rbp),%rdi
lea    -0x1e0(%rbp),%rsi
call   10b0 <strcat@plt>
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    1edd <main+0xd2d>
jmp    1f45 <main+0xd95>
mov    -0x98(%rbp),%rax
mov    %rax,-0x658(%rbp)
lea    -0x5d0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,%rcx
mov    -0x658(%rbp),%rax
cmp    %rcx,%rax
jae    205f <main+0xeaf>
lea    -0x5d0(%rbp),%rdi
lea    -0x170(%rbp),%rsi
call   10d0 <strstr@plt>
lea    -0x5d0(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x660(%rbp)
lea    -0x5d0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,%rcx
mov    -0x660(%rbp),%rax
cmp    %rcx,%rax
jae    2038 <main+0xe88>
mov    -0x90(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x90(%rbp)
lea    -0x5d0(%rbp),%rdi
lea    -0x170(%rbp),%rsi
call   10d0 <strstr@plt>
lea    -0x5d0(%rbp),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x98(%rbp),%rax
je     202d <main+0xe7d>
mov    -0x88(%rbp),%rax
movb   $0x5f,-0x5d0(%rbp,%rax,1)
5f
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    1ff3 <main+0xe43>
movq   $0x0,-0x88(%rbp)
lea    -0x5d0(%rbp),%rdi
lea    -0x170(%rbp),%rsi
call   10d0 <strstr@plt>
cmp    $0x0,%rax
jne    205a <main+0xeaa>
jmp    205f <main+0xeaf>
jmp    1f45 <main+0xd95>
mov    -0x90(%rbp),%rsi
lea    0x11ce(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movq   $0x0,-0x90(%rbp)
lea    -0x5d0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x98(%rbp)
cmpq   $0x0,-0x98(%rbp)
je     2109 <main+0xf59>
movq   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x98(%rbp),%rax
jge    20f2 <main+0xf42>
mov    -0x88(%rbp),%rax
mov    -0x5cf(%rbp,%rax,1),%cl
mov    -0x88(%rbp),%rax
mov    %cl,-0x5d0(%rbp,%rax,1)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
jmp    20ab <main+0xefb>
mov    -0x98(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x98(%rbp)
jmp    2092 <main+0xee2>
jmp    2123 <main+0xf73>
lea    0xf5b(%rip),%rdi
lea    0x1160(%rip),%rsi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x5e0(%rbp),%rax
mov    %rax,%rsp
jmp    2137 <main+0xf87>
jmp    213c <main+0xf8c>
jmp    11eb <main+0x3b>
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    $0x5a8,%rsp
lea    0xe8d(%rip),%rdi
call   1030 <puts@plt>
lea    0xeca(%rip),%rdi
lea    -0x4c(%rbp),%rsi
xor    %eax,%eax
call   1090 <scanf@plt>
cmpl   $0x736579,-0x4c(%rbp)
je     121c <main+0x4c>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x560(%rbp),%rdi
mov    $0x1,%eax
sub    %rdi,%rax
mov    %rax,-0x78(%rbp)
lea    0xe8b(%rip),%r13
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    %rbx,-0x30(%rbp)
lea    0xe79(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r13,%rdi
lea    -0x5d0(%rbp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1090 <scanf@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <atof@plt>
mov    %eax,%r14d
lea    0xe88(%rip),%r15
mov    %r15,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r13,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1090 <scanf@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <atof@plt>
mov    %eax,%r12d
lea    0xe64(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r13,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1090 <scanf@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <atof@plt>
movd   %r14d,%xmm0
movd   %eax,%xmm1
punpckldq %xmm0,%xmm1
cvtdq2pd %xmm1,%xmm0
movaps %xmm0,-0x60(%rbp)
mov    %r15,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r13,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1090 <scanf@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <atof@plt>
movd   %r12d,%xmm0
movd   %eax,%xmm1
punpckldq %xmm0,%xmm1
cvtdq2pd %xmm1,%xmm0
movaps %xmm0,-0x70(%rbp)
lea    0xe33(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r13,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1090 <scanf@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   10c0 <atoi@plt>
movslq %eax,%rbx
lea    0xe2d(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r13,%rdi
lea    -0x100(%rbp),%rsi
xor    %eax,%eax
call   1090 <scanf@plt>
mov    %rsp,%r12
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movapd -0x70(%rbp),%xmm1
subpd  -0x60(%rbp),%xmm1
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm1
movapd %xmm1,-0x90(%rbp)
ff
lea    0xf(,%rbx,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
mov    %rsp,%r14
sub    %rax,%r14
mov    %r14,%rsp
mov    %r13,%rbx
mov    %rsp,%r13
sub    %rax,%r13
mov    %r13,%rsp
lea    0xdda(%rip),%rdi
call   1030 <puts@plt>
mov    %rbx,%rdi
lea    0xdf5(%rip),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %rbx,%rdi
lea    -0x31(%rbp),%rsi
xor    %eax,%eax
call   1090 <scanf@plt>
movsbl -0x31(%rbp),%eax
cmp    $0x46,%eax
mov    %r12,-0x40(%rbp)
je     1600 <main+0x430>
cmp    $0x47,%eax
je     14b0 <main+0x2e0>
cmp    $0x59,%eax
mov    -0x30(%rbp),%rbx
movapd -0x60(%rbp),%xmm2
jne    1770 <main+0x5a0>
movapd -0x70(%rbp),%xmm1
unpckhpd %xmm1,%xmm1
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
movapd %xmm1,-0x70(%rbp)
ucomisd %xmm0,%xmm1
jbe    1b4a <main+0x97a>
xchg   %ax,%ax
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
movapd %xmm0,%xmm1
mulsd  0xbcc(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0xbc8(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
movapd %xmm2,%xmm0
mulsd  0xbbc(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xbb4(%rip),%xmm1
addsd  %xmm1,%xmm0
ucomisd %xmm0,%xmm1
jae    1b3c <main+0x96c>
movapd %xmm2,-0x60(%rbp)
call   1070 <acosh@plt>
movapd -0x60(%rbp),%xmm2
movsd  %xmm0,0x0(%r13,%rbx,8)
add    $0x1,%rbx
addpd  -0x90(%rbp),%xmm2
ff
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
movapd -0x70(%rbp),%xmm1
ucomisd %xmm0,%xmm1
ja     1420 <main+0x250>
jmp    1b4a <main+0x97a>
movapd -0x70(%rbp),%xmm1
unpckhpd %xmm1,%xmm1
movapd -0x60(%rbp),%xmm10
movapd %xmm10,%xmm0
unpckhpd %xmm10,%xmm0
ucomisd %xmm0,%xmm1
movsd  0xb72(%rip),%xmm9
movsd  0xb72(%rip),%xmm5
movsd  0xb72(%rip),%xmm6
movsd  0xb71(%rip),%xmm8
movsd  0xb71(%rip),%xmm7
movsd  0xb71(%rip),%xmm4
lea    0xd35(%rip),%r12
mov    -0x30(%rbp),%r15
jbe    1788 <main+0x5b8>
movapd %xmm1,%xmm11
lea    -0x560(%rbp),%r13
mov    -0x48(%rbp),%rax
jmp    158c <main+0x3bc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm0,%xmm2
mulsd  %xmm8,%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm7,%xmm3
mulsd  %xmm10,%xmm3
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
movapd %xmm10,%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%r15,8)
add    $0x1,%r15
addpd  -0x90(%rbp),%xmm10
ff ff
movapd %xmm10,%xmm0
unpckhpd %xmm10,%xmm0
ucomisd %xmm0,%xmm11
jbe    1793 <main+0x5c3>
movapd %xmm10,%xmm0
unpckhpd %xmm10,%xmm0
movapd %xmm0,%xmm2
mulsd  %xmm9,%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm5,%xmm1
mulsd  %xmm10,%xmm1
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm10,%xmm1
mulsd  %xmm6,%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm2,%xmm1
ucomisd 0xa6a(%rip),%xmm1
jb     1530 <main+0x360>
movsd  0xa64(%rip),%xmm2
ucomisd %xmm1,%xmm2
jb     1530 <main+0x360>
lea    0xbe7(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    178f <main+0x5bf>
nopl   0x0(%rax)
movapd -0x70(%rbp),%xmm1
unpckhpd %xmm1,%xmm1
movapd -0x60(%rbp),%xmm2
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
movapd %xmm1,-0x70(%rbp)
ucomisd %xmm0,%xmm1
lea    -0x560(%rbp),%r13
mov    -0x30(%rbp),%r15
mov    %r14,%rbx
ja     1684 <main+0x4b4>
jmp    1710 <main+0x540>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x48(%rbp),%xmm0
call   10b0 <cos@plt>
movsd  0x9c6(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%r15,8)
add    $0x1,%r15
movapd -0x60(%rbp),%xmm2
addpd  -0x90(%rbp),%xmm2
ff
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
movapd -0x70(%rbp),%xmm1
ucomisd %xmm0,%xmm1
jbe    1710 <main+0x540>
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
movapd %xmm0,%xmm1
mulsd  0x988(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0x984(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
movapd %xmm2,%xmm0
mulsd  0x978(%rip),%xmm0
movapd %xmm2,-0x60(%rbp)
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
call   10b0 <cos@plt>
ucomisd 0x961(%rip),%xmm0
jb     1640 <main+0x470>
movsd  -0x48(%rbp),%xmm0
call   10b0 <cos@plt>
movsd  0x951(%rip),%xmm1
ucomisd %xmm0,%xmm1
jb     1640 <main+0x470>
lea    0xad4(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
nopw   0x0(%rax,%rax,1)
test   %r15,%r15
mov    %r15,-0x30(%rbp)
jle    198e <main+0x7be>
mov    %r15,%r14
mov    %rbx,-0x60(%rbp)
xor    %ebx,%ebx
lea    0xb0e(%rip),%r12
lea    -0x170(%rbp),%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x60(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    %r15,%rdi
mov    %r12,%rsi
mov    $0x1,%al
call   10e0 <sprintf@plt>
mov    %r13,%rdi
mov    %r15,%rsi
call   10d0 <strcat@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1740 <main+0x570>
jmp    1991 <main+0x7c1>
nop
lea    0xb09(%rip),%rdi
call   1030 <puts@plt>
lea    0x93e(%rip),%r13
jmp    1cab <main+0xadb>
lea    -0x560(%rbp),%r13
mov    -0x48(%rbp),%rax
test   %r15,%r15
mov    %r15,-0x30(%rbp)
jle    17df <main+0x60f>
xor    %ebx,%ebx
lea    -0x170(%rbp),%r14
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rax,%rbx,8),%xmm0
mov    %r14,%rdi
mov    %r12,%rsi
mov    $0x1,%al
call   10e0 <sprintf@plt>
mov    %r13,%rdi
mov    %r14,%rsi
call   10d0 <strcat@plt>
mov    -0x48(%rbp),%rax
add    $0x1,%rbx
cmp    %rbx,%r15
jne    17b0 <main+0x5e0>
mov    %r15,%r14
jmp    17e2 <main+0x612>
xor    %r14d,%r14d
xor    %r15d,%r15d
xor    %r12d,%r12d
jmp    1817 <main+0x647>
nopw   0x0(%rax,%rax,1)
mov    %r14,%rbx
mov    %r12,%r14
lea    -0x560(%rbp),%r13
mov    %r14,%r12
mov    %r13,%rdi
lea    -0x100(%rbp),%rsi
call   10f0 <strstr@plt>
mov    %rbx,%r14
test   %rax,%rax
je     1890 <main+0x6c0>
mov    %r13,%rdi
call   1050 <strlen@plt>
cmp    %rax,%r12
jae    1890 <main+0x6c0>
mov    %rax,%rbx
mov    %r13,%rdi
lea    -0x100(%rbp),%rsi
call   10f0 <strstr@plt>
mov    %r13,%rdi
mov    %rax,%r13
sub    %rdi,%r13
add    $0x1,%r13
cmp    %rbx,%r13
jae    17f0 <main+0x620>
add    $0x1,%r15
cmp    %r13,%r14
jne    1860 <main+0x690>
xor    %ebx,%ebx
jmp    17f6 <main+0x626>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r14,%rbp,1),%rdi
add    $0xfffffffffffffaa0,%rdi
add    -0x78(%rbp),%rax
sub    %r14,%rax
mov    $0x5f,%esi
mov    %rax,%rdx
call   1080 <memset@plt>
xor    %ebx,%ebx
mov    %r13,%r14
jmp    17f6 <main+0x626>
nopl   0x0(%rax)
lea    0x9a8(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r13,%rdi
call   1050 <strlen@plt>
test   %rax,%rax
je     1ca0 <main+0xad0>
mov    %rax,%r12
lea    -0x1(%rax),%r14
mov    %rax,%rbx
and    $0x3,%rbx
jne    18ea <main+0x71a>
cmp    $0x3,%r14
jb     1ca0 <main+0xad0>
lea    -0x55f(%rbp),%rbx
mov    -0x40(%rbp),%r14
jmp    191a <main+0x74a>
nopl   0x0(%rax)
add    $0xffffffffffffffff,%r12
add    $0xffffffffffffffff,%rbx
je     18c2 <main+0x6f2>
test   %r12,%r12
jle    18e0 <main+0x710>
mov    %r13,%rdi
lea    -0x55f(%rbp),%rsi
mov    %r12,%rdx
call   10a0 <memmove@plt>
jmp    18e0 <main+0x710>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xfffffffffffffffc,%r12
je     1b2c <main+0x95c>
test   %r12,%r12
jle    192d <main+0x75d>
mov    %r13,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   10a0 <memmove@plt>
cmp    $0x2,%r12
jl     1960 <main+0x790>
lea    -0x1(%r12),%rdx
mov    %r13,%rdi
mov    %rbx,%rsi
call   10a0 <memmove@plt>
cmp    $0x3,%r12
jge    1966 <main+0x796>
cmp    $0x4,%r12
jl     1910 <main+0x740>
jmp    197c <main+0x7ac>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x3,%r12
jl     1949 <main+0x779>
lea    -0x2(%r12),%rdx
mov    %r13,%rdi
mov    %rbx,%rsi
call   10a0 <memmove@plt>
cmp    $0x4,%r12
jl     1910 <main+0x740>
lea    -0x3(%r12),%rdx
mov    %r13,%rdi
mov    %rbx,%rsi
call   10a0 <memmove@plt>
jmp    1910 <main+0x740>
xor    %r14d,%r14d
xor    %r15d,%r15d
xor    %r12d,%r12d
jmp    19c7 <main+0x7f7>
nopl   0x0(%rax)
mov    %r14,%rbx
mov    %r12,%r14
lea    -0x560(%rbp),%r13
mov    %r14,%r12
mov    %r13,%rdi
lea    -0x100(%rbp),%rsi
call   10f0 <strstr@plt>
mov    %rbx,%r14
test   %rax,%rax
je     1a40 <main+0x870>
mov    %r13,%rdi
call   1050 <strlen@plt>
cmp    %rax,%r12
jae    1a40 <main+0x870>
mov    %rax,%rbx
mov    %r13,%rdi
lea    -0x100(%rbp),%rsi
call   10f0 <strstr@plt>
mov    %r13,%rdi
mov    %rax,%r13
sub    %rdi,%r13
add    $0x1,%r13
cmp    %rbx,%r13
jae    19a0 <main+0x7d0>
add    $0x1,%r15
cmp    %r13,%r14
jne    1a10 <main+0x840>
xor    %ebx,%ebx
jmp    19a6 <main+0x7d6>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r14,%rbp,1),%rdi
add    $0xfffffffffffffaa0,%rdi
add    -0x78(%rbp),%rax
sub    %r14,%rax
mov    $0x5f,%esi
mov    %rax,%rdx
call   1080 <memset@plt>
xor    %ebx,%ebx
mov    %r13,%r14
jmp    19a6 <main+0x7d6>
nopl   0x0(%rax)
lea    0x7f8(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r13,%rdi
call   1050 <strlen@plt>
test   %rax,%rax
je     1ca0 <main+0xad0>
mov    %rax,%rbx
lea    -0x1(%rax),%r14
mov    %rax,%r12
and    $0x3,%r12
jne    1a9a <main+0x8ca>
cmp    $0x3,%r14
jb     1ca0 <main+0xad0>
lea    -0x55f(%rbp),%r14
jmp    1aca <main+0x8fa>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0xffffffffffffffff,%rbx
add    $0xffffffffffffffff,%r12
je     1a72 <main+0x8a2>
test   %rbx,%rbx
jle    1a90 <main+0x8c0>
mov    %r13,%rdi
lea    -0x55f(%rbp),%rsi
mov    %rbx,%rdx
call   10a0 <memmove@plt>
jmp    1a90 <main+0x8c0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xfffffffffffffffc,%rbx
je     1ca0 <main+0xad0>
test   %rbx,%rbx
jle    1add <main+0x90d>
mov    %r13,%rdi
mov    %r14,%rsi
mov    %rbx,%rdx
call   10a0 <memmove@plt>
cmp    $0x2,%rbx
jl     1b00 <main+0x930>
lea    -0x1(%rbx),%rdx
mov    %r13,%rdi
mov    %r14,%rsi
call   10a0 <memmove@plt>
cmp    $0x3,%rbx
jge    1b06 <main+0x936>
cmp    $0x4,%rbx
jl     1ac0 <main+0x8f0>
jmp    1b1b <main+0x94b>
cmp    $0x3,%rbx
jl     1af8 <main+0x928>
lea    -0x2(%rbx),%rdx
mov    %r13,%rdi
mov    %r14,%rsi
call   10a0 <memmove@plt>
cmp    $0x4,%rbx
jl     1ac0 <main+0x8f0>
lea    -0x3(%rbx),%rdx
mov    %r13,%rdi
mov    %r14,%rsi
call   10a0 <memmove@plt>
jmp    1ac0 <main+0x8f0>
lea    0x58e(%rip),%r13
mov    -0x30(%rbp),%rbx
jmp    1caf <main+0xadf>
lea    0x691(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
test   %rbx,%rbx
mov    %rbx,-0x30(%rbp)
jle    1ba1 <main+0x9d1>
mov    %rbx,%r14
xor    %ebx,%ebx
lea    -0x560(%rbp),%r12
lea    -0x170(%rbp),%r15
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbx,8),%xmm0
mov    %r15,%rdi
lea    0x6ba(%rip),%rsi
mov    $0x1,%al
call   10e0 <sprintf@plt>
mov    %r12,%rdi
mov    %r15,%rsi
call   10d0 <strcat@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1b70 <main+0x9a0>
mov    %r12,%r13
jmp    1bab <main+0x9db>
xor    %r14d,%r14d
lea    -0x560(%rbp),%r13
xor    %r15d,%r15d
xor    %r12d,%r12d
jmp    1be7 <main+0xa17>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r14,%rbx
mov    %r12,%r14
lea    -0x560(%rbp),%r13
mov    %r14,%r12
mov    %r13,%rdi
lea    -0x100(%rbp),%rsi
call   10f0 <strstr@plt>
mov    %rbx,%r14
test   %rax,%rax
je     1c60 <main+0xa90>
mov    %r13,%rdi
call   1050 <strlen@plt>
cmp    %rax,%r12
jae    1c60 <main+0xa90>
mov    %rax,%rbx
mov    %r13,%rdi
lea    -0x100(%rbp),%rsi
call   10f0 <strstr@plt>
mov    %r13,%rdi
mov    %rax,%r13
sub    %rdi,%r13
add    $0x1,%r13
cmp    %rbx,%r13
jae    1bc0 <main+0x9f0>
add    $0x1,%r15
cmp    %r13,%r14
jne    1c30 <main+0xa60>
xor    %ebx,%ebx
jmp    1bc6 <main+0x9f6>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r14,%rbp,1),%rdi
add    $0xfffffffffffffaa0,%rdi
add    -0x78(%rbp),%rax
sub    %r14,%rax
mov    $0x5f,%esi
mov    %rax,%rdx
call   1080 <memset@plt>
xor    %ebx,%ebx
mov    %r13,%r14
jmp    1bc6 <main+0x9f6>
nopl   0x0(%rax)
lea    0x5d8(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r13,%rdi
call   1050 <strlen@plt>
test   %rax,%rax
je     1ca0 <main+0xad0>
mov    %rax,%rbx
lea    -0x1(%rax),%r14
mov    %rax,%r12
and    $0x3,%r12
jne    1cea <main+0xb1a>
cmp    $0x3,%r14
jae    1d03 <main+0xb33>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x41a(%rip),%r13
mov    -0x30(%rbp),%rbx
mov    -0x40(%rbp),%r14
mov    %r14,%rsp
lea    0x3bf(%rip),%rdi
call   1030 <puts@plt>
mov    %r13,%rdi
lea    -0x4c(%rbp),%rsi
xor    %eax,%eax
call   1090 <scanf@plt>
cmpl   $0x736579,-0x4c(%rbp)
je     1240 <main+0x70>
jmp    120b <main+0x3b>
xchg   %ax,%ax
add    $0xffffffffffffffff,%rbx
add    $0xffffffffffffffff,%r12
je     1c8e <main+0xabe>
test   %rbx,%rbx
jle    1ce0 <main+0xb10>
mov    %r13,%rdi
lea    -0x55f(%rbp),%rsi
mov    %rbx,%rdx
call   10a0 <memmove@plt>
jmp    1ce0 <main+0xb10>
lea    -0x55f(%rbp),%r14
jmp    1d16 <main+0xb46>
nopl   0x0(%rax)
add    $0xfffffffffffffffc,%rbx
je     1ca0 <main+0xad0>
test   %rbx,%rbx
jle    1d29 <main+0xb59>
mov    %r13,%rdi
mov    %r14,%rsi
mov    %rbx,%rdx
call   10a0 <memmove@plt>
cmp    $0x2,%rbx
jl     1d50 <main+0xb80>
lea    -0x1(%rbx),%rdx
mov    %r13,%rdi
mov    %r14,%rsi
call   10a0 <memmove@plt>
cmp    $0x3,%rbx
jge    1d56 <main+0xb86>
cmp    $0x4,%rbx
jl     1d10 <main+0xb40>
jmp    1d6b <main+0xb9b>
nopl   0x0(%rax)
cmp    $0x3,%rbx
jl     1d44 <main+0xb74>
lea    -0x2(%rbx),%rdx
mov    %r13,%rdi
mov    %r14,%rsi
call   10a0 <memmove@plt>
cmp    $0x4,%rbx
jl     1d10 <main+0xb40>
lea    -0x3(%rbx),%rdx
mov    %r13,%rdi
mov    %r14,%rsi
call   10a0 <memmove@plt>
jmp    1d10 <main+0xb40>

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