#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int GetIndex(double, double *, int, int);
int /*<<< orphan*/ abort();
int /*<<< orphan*/ printf(char *);
void LinterpData(void *data, char type, int npts, double *lx, double *ly,
                 int n_ln) {
  int i, idx = 0;
  double x;
  for (i = 0; i < npts; i++) {
    switch (type) {
    case 'n':
      return;
      break;
    case 'c':
      x = ((unsigned char *)data)[i];
      idx = GetIndex(x, lx, idx, n_ln);
      ((unsigned char *)data)[i] =
          (unsigned char)(ly[idx] + (ly[idx + 1] - ly[idx]) /
                                        (lx[idx + 1] - lx[idx]) *
                                        (x - lx[idx]));
      break;
    case 's':
      x = ((short *)data)[i];
      idx = GetIndex(x, lx, idx, n_ln);
      ((short *)data)[i] =
          (short)(ly[idx] + (ly[idx + 1] - ly[idx]) / (lx[idx + 1] - lx[idx]) *
                                (x - lx[idx]));
      break;
    case 'u':
      x = ((unsigned short *)data)[i];
      idx = GetIndex(x, lx, idx, n_ln);
      ((unsigned short *)data)[i] =
          (unsigned short)(ly[idx] + (ly[idx + 1] - ly[idx]) /
                                         (lx[idx + 1] - lx[idx]) *
                                         (x - lx[idx]));
      break;
    case 'S':
    case 'i':
      x = ((int *)data)[i];
      idx = GetIndex(x, lx, idx, n_ln);
      ((int *)data)[i] =
          (int)(ly[idx] + (ly[idx + 1] - ly[idx]) / (lx[idx + 1] - lx[idx]) *
                              (x - lx[idx]));
      break;
    case 'U':
      x = ((unsigned *)data)[i];
      idx = GetIndex(x, lx, idx, n_ln);
      ((unsigned *)data)[i] =
          (unsigned)(ly[idx] + (ly[idx + 1] - ly[idx]) /
                                   (lx[idx + 1] - lx[idx]) * (x - lx[idx]));
      break;
    case 'f':
      x = ((float *)data)[i];
      idx = GetIndex(x, lx, idx, n_ln);
      ((float *)data)[i] =
          (float)(ly[idx] + (ly[idx + 1] - ly[idx]) / (lx[idx + 1] - lx[idx]) *
                                (x - lx[idx]));
      break;
    case 'd':
      x = ((double *)data)[i];
      idx = GetIndex(x, lx, idx, n_ln);
      ((double *)data)[i] =
          (double)(ly[idx] + (ly[idx + 1] - ly[idx]) / (lx[idx + 1] - lx[idx]) *
                                 (x - lx[idx]));
      break;
    default:
      printf("Another impossible error\n");
      abort();
      break;
    }
  }
}


x86 assembly (clang, -O0):
<LinterpData>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %sil,%al
mov    %rdi,-0x8(%rbp)
mov    %al,-0x9(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15bf <LinterpData+0x48f>
movsbl -0x9(%rbp),%eax
add    $0xffffffad,%eax
mov    %eax,%ecx
mov    %rcx,-0x40(%rbp)
sub    $0x22,%eax
ja     1599 <LinterpData+0x469>
mov    -0x40(%rbp),%rax
lea    0xe74(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    15bf <LinterpData+0x48f>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x24(%rbp),%edx
call   1050 <GetIndex@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x8(%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm3
movsd  0x8(%rax,%rcx,8),%xmm2
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm0
movsd  -0x38(%rbp),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    15ac <LinterpData+0x47c>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x24(%rbp),%edx
call   1050 <GetIndex@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x8(%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm3
movsd  0x8(%rax,%rcx,8),%xmm2
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm0
movsd  -0x38(%rbp),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    15ac <LinterpData+0x47c>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movzwl (%rax,%rcx,2),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x24(%rbp),%edx
call   1050 <GetIndex@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x8(%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm3
movsd  0x8(%rax,%rcx,8),%xmm2
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm0
movsd  -0x38(%rbp),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    15ac <LinterpData+0x47c>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x24(%rbp),%edx
call   1050 <GetIndex@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
divsd  %xmm2,%xmm0
movsd  -0x38(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    15ac <LinterpData+0x47c>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cvtsi2sd %rax,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x24(%rbp),%edx
call   1050 <GetIndex@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x8(%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm3
movsd  0x8(%rax,%rcx,8),%xmm2
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm0
movsd  -0x38(%rbp),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
mov    %eax,%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    15ac <LinterpData+0x47c>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x24(%rbp),%edx
call   1050 <GetIndex@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
divsd  %xmm2,%xmm0
movsd  -0x38(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    15ac <LinterpData+0x47c>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x24(%rbp),%edx
call   1050 <GetIndex@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
divsd  %xmm2,%xmm0
movsd  -0x38(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    15ac <LinterpData+0x47c>
lea    0xaec(%rip),%rdi
call   1040 <printf@plt>
mov    $0x0,%al
call   1030 <abort@plt>
jmp    15b1 <LinterpData+0x481>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    115f <LinterpData+0x2f>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LinterpData>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r9d,0xc(%rsp)
test   %edx,%edx
jle    141c <LinterpData+0x2ec>
movsbl %sil,%ebx
add    $0xffffffad,%ebx
cmp    $0x22,%ebx
ja     142b <LinterpData+0x2fb>
movabs $0x5004b0005,%rax
bt     %rbx,%rax
jae    1416 <LinterpData+0x2e6>
mov    %r8,%r15
mov    %rcx,%rbp
mov    %rdi,%r12
mov    %edx,%r13d
xor    %r14d,%r14d
xor    %eax,%eax
jmp    11fd <LinterpData+0xcd>
movss  (%r12,%r14,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rbp,%rdi
mov    %eax,%esi
mov    0xc(%rsp),%edx
call   1050 <GetIndex@plt>
movslq %eax,%rcx
movsd  (%r15,%rcx,8),%xmm0
movsd  0x8(%r15,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rcx,8),%xmm2
movsd  0x8(%rbp,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
divsd  %xmm3,%xmm1
movsd  0x10(%rsp),%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
xorps  %xmm0,%xmm0
cvtsd2ss %xmm3,%xmm0
movss  %xmm0,(%r12,%r14,4)
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    %r14,%r13
je     141c <LinterpData+0x2ec>
cmp    $0x22,%ebx
ja     1182 <LinterpData+0x52>
lea    0xdf7(%rip),%rdx
movslq (%rdx,%rbx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
xorps  %xmm0,%xmm0
cvtsi2sdl (%r12,%r14,4),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rbp,%rdi
mov    %eax,%esi
mov    0xc(%rsp),%edx
call   1050 <GetIndex@plt>
movslq %eax,%rcx
movsd  (%r15,%rcx,8),%xmm0
movsd  0x8(%r15,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rcx,8),%xmm2
movsd  0x8(%rbp,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
divsd  %xmm3,%xmm1
movsd  0x10(%rsp),%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
cvttsd2si %xmm3,%ecx
mov    %ecx,(%r12,%r14,4)
jmp    11f0 <LinterpData+0xc0>
movswl (%r12,%r14,2),%ecx
jmp    13b3 <LinterpData+0x283>
mov    (%r12,%r14,4),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %rcx,%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rbp,%rdi
mov    %eax,%esi
mov    0xc(%rsp),%edx
call   1050 <GetIndex@plt>
movslq %eax,%rcx
movsd  (%r15,%rcx,8),%xmm0
movsd  0x8(%r15,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rcx,8),%xmm2
movsd  0x8(%rbp,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
divsd  %xmm3,%xmm1
movsd  0x10(%rsp),%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
cvttsd2si %xmm3,%rcx
mov    %ecx,(%r12,%r14,4)
jmp    11f0 <LinterpData+0xc0>
movzbl (%r12,%r14,1),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rbp,%rdi
mov    %eax,%esi
mov    0xc(%rsp),%edx
call   1050 <GetIndex@plt>
movslq %eax,%rcx
movsd  (%r15,%rcx,8),%xmm0
movsd  0x8(%r15,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rcx,8),%xmm2
movsd  0x8(%rbp,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
divsd  %xmm3,%xmm1
movsd  0x10(%rsp),%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
cvttsd2si %xmm3,%ecx
mov    %cl,(%r12,%r14,1)
jmp    11f0 <LinterpData+0xc0>
movsd  (%r12,%r14,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rbp,%rdi
mov    %eax,%esi
mov    0xc(%rsp),%edx
call   1050 <GetIndex@plt>
movslq %eax,%rcx
movsd  (%r15,%rcx,8),%xmm0
movsd  0x8(%r15,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rcx,8),%xmm2
movsd  0x8(%rbp,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
divsd  %xmm3,%xmm1
movsd  0x10(%rsp),%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,(%r12,%r14,8)
jmp    11f0 <LinterpData+0xc0>
movzwl (%r12,%r14,2),%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %rbp,%rdi
mov    %eax,%esi
mov    0xc(%rsp),%edx
call   1050 <GetIndex@plt>
movslq %eax,%rcx
movsd  (%r15,%rcx,8),%xmm0
movsd  0x8(%r15,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rcx,8),%xmm2
movsd  0x8(%rbp,%rcx,8),%xmm3
subsd  %xmm2,%xmm3
divsd  %xmm3,%xmm1
movsd  0x10(%rsp),%xmm3
subsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
cvttsd2si %xmm3,%ecx
mov    %cx,(%r12,%r14,2)
jmp    11f0 <LinterpData+0xc0>
cmp    $0x1b,%rbx
jne    142b <LinterpData+0x2fb>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xc5a(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   1030 <abort@plt>

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

LLVM IR (-O2):
@str = [25 x i8] c"Another impossible error\00"
define void @LinterpData(i8* nocapture %0, i8 signext %1, i32 %2, double* %3, double* nocapture %4, i32 %5) {
%7 = icmp sgt i32 %2, 0
br i1 %7, label %8, label %178
8: ; preds = %6
%9 = sext i8 %1 to i32
%10 = bitcast i8* %0 to double*
%11 = bitcast i8* %0 to float*
%12 = bitcast i8* %0 to i32*
%13 = bitcast i8* %0 to i16*
switch i32 %9, label %171 [
i32 110, label %178
i32 100, label %14
i32 99, label %14
i32 115, label %14
i32 117, label %14
i32 83, label %14
i32 105, label %14
i32 85, label %14
i32 102, label %14
]
14: ; preds = %8, %8, %8, %8, %8, %8, %8, %8
%15 = zext i32 %2 to i64
br label %16
16: ; preds = %14, %174
%17 = phi i64 [ 0, %14 ], [ %176, %174 ]
%18 = phi i32 [ 0, %14 ], [ %175, %174 ]
switch i32 %9, label %129 [
i32 100, label %151
i32 99, label %19
i32 115, label %41
i32 117, label %63
i32 83, label %85
i32 105, label %85
i32 85, label %107
]
19: ; preds = %16
%20 = getelementptr inbounds i8, i8* %0, i64 %17
%21 = load i8, i8* %20
%22 = uitofp i8 %21 to double
%23 = tail call i32 @GetIndex(double %22, double* %3, i32 %18, i32 %5)
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds double, double* %4, i64 %24
%26 = load double, double* %25
%27 = add nsw i32 %23, 1
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds double, double* %4, i64 %28
%30 = load double, double* %29
%31 = fsub double %30, %26
%32 = getelementptr inbounds double, double* %3, i64 %28
%33 = load double, double* %32
%34 = getelementptr inbounds double, double* %3, i64 %24
%35 = load double, double* %34
%36 = fsub double %33, %35
%37 = fdiv double %31, %36
%38 = fsub double %22, %35
%39 = tail call double @llvm.fmuladd.f64(double %37, double %38, double %26)
%40 = fptoui double %39 to i8
store i8 %40, i8* %20
br label %174
41: ; preds = %16
%42 = getelementptr inbounds i16, i16* %13, i64 %17
%43 = load i16, i16* %42
%44 = sitofp i16 %43 to double
%45 = tail call i32 @GetIndex(double %44, double* %3, i32 %18, i32 %5)
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds double, double* %4, i64 %46
%48 = load double, double* %47
%49 = add nsw i32 %45, 1
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double, double* %4, i64 %50
%52 = load double, double* %51
%53 = fsub double %52, %48
%54 = getelementptr inbounds double, double* %3, i64 %50
%55 = load double, double* %54
%56 = getelementptr inbounds double, double* %3, i64 %46
%57 = load double, double* %56
%58 = fsub double %55, %57
%59 = fdiv double %53, %58
%60 = fsub double %44, %57
%61 = tail call double @llvm.fmuladd.f64(double %59, double %60, double %48)
%62 = fptosi double %61 to i16
store i16 %62, i16* %42
br label %174
63: ; preds = %16
%64 = getelementptr inbounds i16, i16* %13, i64 %17
%65 = load i16, i16* %64
%66 = uitofp i16 %65 to double
%67 = tail call i32 @GetIndex(double %66, double* %3, i32 %18, i32 %5)
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %4, i64 %68
%70 = load double, double* %69
%71 = add nsw i32 %67, 1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double, double* %4, i64 %72
%74 = load double, double* %73
%75 = fsub double %74, %70
%76 = getelementptr inbounds double, double* %3, i64 %72
%77 = load double, double* %76
%78 = getelementptr inbounds double, double* %3, i64 %68
%79 = load double, double* %78
%80 = fsub double %77, %79
%81 = fdiv double %75, %80
%82 = fsub double %66, %79
%83 = tail call double @llvm.fmuladd.f64(double %81, double %82, double %70)
%84 = fptoui double %83 to i16
store i16 %84, i16* %64
br label %174
85: ; preds = %16, %16
%86 = getelementptr inbounds i32, i32* %12, i64 %17
%87 = load i32, i32* %86
%88 = sitofp i32 %87 to double
%89 = tail call i32 @GetIndex(double %88, double* %3, i32 %18, i32 %5)
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %4, i64 %90
%92 = load double, double* %91
%93 = add nsw i32 %89, 1
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds double, double* %4, i64 %94
%96 = load double, double* %95
%97 = fsub double %96, %92
%98 = getelementptr inbounds double, double* %3, i64 %94
%99 = load double, double* %98
%100 = getelementptr inbounds double, double* %3, i64 %90
%101 = load double, double* %100
%102 = fsub double %99, %101
%103 = fdiv double %97, %102
%104 = fsub double %88, %101
%105 = tail call double @llvm.fmuladd.f64(double %103, double %104, double %92)
%106 = fptosi double %105 to i32
store i32 %106, i32* %86
br label %174
107: ; preds = %16
%108 = getelementptr inbounds i32, i32* %12, i64 %17
%109 = load i32, i32* %108
%110 = uitofp i32 %109 to double
%111 = tail call i32 @GetIndex(double %110, double* %3, i32 %18, i32 %5)
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %4, i64 %112
%114 = load double, double* %113
%115 = add nsw i32 %111, 1
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double, double* %4, i64 %116
%118 = load double, double* %117
%119 = fsub double %118, %114
%120 = getelementptr inbounds double, double* %3, i64 %116
%121 = load double, double* %120
%122 = getelementptr inbounds double, double* %3, i64 %112
%123 = load double, double* %122
%124 = fsub double %121, %123
%125 = fdiv double %119, %124
%126 = fsub double %110, %123
%127 = tail call double @llvm.fmuladd.f64(double %125, double %126, double %114)
%128 = fptoui double %127 to i32
store i32 %128, i32* %108
br label %174
129: ; preds = %16
%130 = getelementptr inbounds float, float* %11, i64 %17
%131 = load float, float* %130
%132 = fpext float %131 to double
%133 = tail call i32 @GetIndex(double %132, double* %3, i32 %18, i32 %5)
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %4, i64 %134
%136 = load double, double* %135
%137 = add nsw i32 %133, 1
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %4, i64 %138
%140 = load double, double* %139
%141 = fsub double %140, %136
%142 = getelementptr inbounds double, double* %3, i64 %138
%143 = load double, double* %142
%144 = getelementptr inbounds double, double* %3, i64 %134
%145 = load double, double* %144
%146 = fsub double %143, %145
%147 = fdiv double %141, %146
%148 = fsub double %132, %145
%149 = tail call double @llvm.fmuladd.f64(double %147, double %148, double %136)
%150 = fptrunc double %149 to float
store float %150, float* %130
br label %174
151: ; preds = %16
%152 = getelementptr inbounds double, double* %10, i64 %17
%153 = load double, double* %152
%154 = tail call i32 @GetIndex(double %153, double* %3, i32 %18, i32 %5)
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %4, i64 %155
%157 = load double, double* %156
%158 = add nsw i32 %154, 1
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double, double* %4, i64 %159
%161 = load double, double* %160
%162 = fsub double %161, %157
%163 = getelementptr inbounds double, double* %3, i64 %159
%164 = load double, double* %163
%165 = getelementptr inbounds double, double* %3, i64 %155
%166 = load double, double* %165
%167 = fsub double %164, %166
%168 = fdiv double %162, %167
%169 = fsub double %153, %166
%170 = tail call double @llvm.fmuladd.f64(double %168, double %169, double %157)
store double %170, double* %152
br label %174
171: ; preds = %8
%172 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str, i64 0, i64 0))
%173 = tail call i32 (...) @abort()
unreachable
174: ; preds = %19, %41, %63, %85, %107, %129, %151
%175 = phi i32 [ %154, %151 ], [ %133, %129 ], [ %111, %107 ], [ %89, %85 ], [ %67, %63 ], [ %45, %41 ], [ %23, %19 ]
%176 = add nuw nsw i64 %17, 1
%177 = icmp eq i64 %176, %15
br i1 %177, label %178, label %16
178: ; preds = %174, %8, %6
ret void
}