#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 */
double fabs(double);
unsigned char compute_ref_coefs(double *autoc, unsigned char max_order,
                                double *ref) {
  int i, j;
  double error;
  double gen[2][60];
  unsigned char order_est;
  for (i = 0; i < max_order; i++)
    gen[0][i] = gen[1][i] = autoc[i + 1];
  error = autoc[0];
  ref[0] = -gen[1][0] / error;
  error += gen[1][0] * ref[0];
  for (i = 1; i < max_order; i++) {
    for (j = 0; j < max_order - i; j++) {
      gen[1][j] = gen[1][j + 1] + ref[i - 1] * gen[0][j];
      gen[0][j] = gen[1][j + 1] * ref[i - 1] + gen[0][j];
    }
    ref[i] = -gen[1][0] / error;
    error += gen[1][0] * ref[i];
  }
  order_est = 1;
  for (i = max_order - 1; i >= 0; i--) {
    if (fabs(ref[i]) > 0.10) {
      order_est = i + 1;
      break;
    }
  }
  return (order_est);
}


x86 assembly (clang, -O0):
<compute_ref_coefs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x380,%rsp
mov    %sil,%al
mov    %rdi,-0x8(%rbp)
mov    %al,-0x9(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
movzbl -0x9(%rbp),%ecx
cmp    %ecx,%eax
jge    1169 <compute_ref_coefs+0x69>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x1c(%rbp),%rax
movsd  %xmm0,-0x210(%rbp,%rax,8)
ff ff
movslq -0x1c(%rbp),%rax
movsd  %xmm0,-0x3f0(%rbp,%rax,8)
ff ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1120 <compute_ref_coefs+0x20>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x210(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x210(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
movzbl -0x9(%rbp),%ecx
cmp    %ecx,%eax
jge    12f1 <compute_ref_coefs+0x1f1>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
movzbl -0x9(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    128b <compute_ref_coefs+0x18b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x210(%rbp,%rax,8),%xmm1
ff ff
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x20(%rbp),%rax
movsd  -0x3f0(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x20(%rbp),%rax
movsd  %xmm0,-0x210(%rbp,%rax,8)
ff ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0x210(%rbp,%rax,8),%xmm0
ff ff
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x20(%rbp),%rax
movsd  -0x3f0(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x20(%rbp),%rax
movsd  %xmm0,-0x3f0(%rbp,%rax,8)
ff ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11e1 <compute_ref_coefs+0xe1>
movsd  -0x210(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x210(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x28(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11cb <compute_ref_coefs+0xcb>
movb   $0x1,-0x3f1(%rbp)
movzbl -0x9(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     135a <compute_ref_coefs+0x25a>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xcf0(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xcd4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1347 <compute_ref_coefs+0x247>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x3f1(%rbp)
jmp    135a <compute_ref_coefs+0x25a>
jmp    134c <compute_ref_coefs+0x24c>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1302 <compute_ref_coefs+0x202>
movzbl -0x3f1(%rbp),%eax
add    $0x380,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_ref_coefs>:
push   %r14
push   %rbx
sub    $0x348,%rsp
movzbl %sil,%eax
test   %esi,%esi
je     111e <compute_ref_coefs+0x1e>
cmp    $0x4,%al
jae    1130 <compute_ref_coefs+0x30>
xor    %r10d,%r10d
jmp    11f0 <compute_ref_coefs+0xf0>
movabs $0x7ff8000000000000,%rcx
mov    %rcx,(%rdx)
jmp    1413 <compute_ref_coefs+0x313>
mov    %eax,%r10d
and    $0xfffffffc,%r10d
lea    -0x4(%r10),%rbx
mov    %rbx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rbx,%rbx
je     145b <compute_ref_coefs+0x35b>
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups 0x8(%rdi,%rbx,8),%xmm0
movups 0x18(%rdi,%rbx,8),%xmm1
movaps %xmm0,0x160(%rsp,%rbx,8)
movaps %xmm1,0x170(%rsp,%rbx,8)
movaps %xmm0,-0x80(%rsp,%rbx,8)
movaps %xmm1,-0x70(%rsp,%rbx,8)
movups 0x28(%rdi,%rbx,8),%xmm0
movups 0x38(%rdi,%rbx,8),%xmm1
movaps %xmm0,0x180(%rsp,%rbx,8)
movaps %xmm1,0x190(%rsp,%rbx,8)
movaps %xmm0,-0x60(%rsp,%rbx,8)
movaps %xmm1,-0x50(%rsp,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%r9
jne    1160 <compute_ref_coefs+0x60>
test   $0x1,%r8b
je     11e9 <compute_ref_coefs+0xe9>
lea    0x0(,%rbx,8),%r8
or     $0x8,%r8
movups (%rdi,%r8,1),%xmm0
movups 0x10(%rdi,%r8,1),%xmm1
movaps %xmm0,0x160(%rsp,%rbx,8)
movaps %xmm1,0x170(%rsp,%rbx,8)
movaps %xmm0,-0x80(%rsp,%rbx,8)
movaps %xmm1,-0x70(%rsp,%rbx,8)
cmp    %rax,%r10
je     1214 <compute_ref_coefs+0x114>
xchg   %ax,%ax
movsd  0x8(%rdi,%r10,8),%xmm0
movsd  %xmm0,0x160(%rsp,%r10,8)
movsd  %xmm0,-0x80(%rsp,%r10,8)
lea    0x1(%r10),%rcx
mov    %rcx,%r10
cmp    %rcx,%rax
jne    11f0 <compute_ref_coefs+0xf0>
movsd  0x160(%rsp),%xmm0
movsd  (%rdi),%xmm2
movapd 0xdd7(%rip),%xmm1
xorpd  %xmm0,%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm1,(%rdx)
cmp    $0x2,%sil
jb     1413 <compute_ref_coefs+0x313>
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
lea    -0x1(%rsi),%r14d
mov    $0x1,%r11d
xor    %r8d,%r8d
movapd 0xda4(%rip),%xmm2
jmp    1298 <compute_ref_coefs+0x198>
xchg   %ax,%ax
movsd  0x160(%rsp),%xmm3
movapd %xmm3,%xmm1
xorpd  %xmm2,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%r11,8)
mulsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
add    $0x1,%r11
add    $0x1,%r8d
add    $0xffffffff,%r14d
cmp    %rax,%r11
je     1413 <compute_ref_coefs+0x313>
mov    %r14d,%r14d
cmp    %rax,%r11
jae    1260 <compute_ref_coefs+0x160>
mov    %r8d,%r9d
not    %r9d
add    %esi,%r9d
cmp    $0x2,%r9d
jae    12c0 <compute_ref_coefs+0x1c0>
xor    %ebx,%ebx
jmp    13d0 <compute_ref_coefs+0x2d0>
cs nopw 0x0(%rax,%rax,1)
mov    %r9d,%edi
and    $0xfffffffe,%edi
add    $0xfffffffffffffffe,%rdi
mov    %rdi,%r10
shr    %r10
add    $0x1,%r10
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
test   %rdi,%rdi
je     1370 <compute_ref_coefs+0x270>
mov    %r14d,%ebx
and    $0xfffffffe,%ebx
add    $0xfffffffffffffffe,%rbx
shr    %rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %edi,%edi
nopl   0x0(%rax)
movupd 0x168(%rsp,%rdi,8),%xmm4
movapd -0x80(%rsp,%rdi,8),%xmm5
movapd -0x70(%rsp,%rdi,8),%xmm6
movapd %xmm3,%xmm7
mulpd  %xmm5,%xmm7
addpd  %xmm4,%xmm7
movapd %xmm7,0x160(%rsp,%rdi,8)
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movapd %xmm4,-0x80(%rsp,%rdi,8)
movupd 0x178(%rsp,%rdi,8),%xmm4
movapd %xmm3,%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm4,%xmm5
movapd %xmm5,0x170(%rsp,%rdi,8)
mulpd  %xmm3,%xmm4
addpd  %xmm6,%xmm4
movapd %xmm4,-0x70(%rsp,%rdi,8)
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1300 <compute_ref_coefs+0x200>
jmp    1372 <compute_ref_coefs+0x272>
xor    %edi,%edi
mov    %r9d,%ebx
and    $0xfffffffe,%ebx
test   $0x1,%r10b
je     13bc <compute_ref_coefs+0x2bc>
lea    0x0(,%rdi,8),%rcx
or     $0x8,%rcx
movupd 0x160(%rsp,%rcx,1),%xmm4
movapd -0x80(%rsp,%rdi,8),%xmm5
movapd %xmm3,%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm4,%xmm6
movapd %xmm6,0x160(%rsp,%rdi,8)
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movapd %xmm4,-0x80(%rsp,%rdi,8)
cmp    %r9,%rbx
je     1260 <compute_ref_coefs+0x160>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x80(%rsp,%rbx,8),%xmm3
movsd  0x168(%rsp,%rbx,8),%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,0x160(%rsp,%rbx,8)
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,-0x80(%rsp,%rbx,8)
lea    0x1(%rbx),%rcx
mov    %rcx,%rbx
cmp    %rcx,%r14
jne    13d0 <compute_ref_coefs+0x2d0>
jmp    1260 <compute_ref_coefs+0x160>
movapd 0xbf5(%rip),%xmm0
movsd  0xbfd(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %rax,%rax
jle    144e <compute_ref_coefs+0x34e>
add    $0xffffffffffffffff,%rax
mov    %eax,%ecx
movsd  (%rdx,%rcx,8),%xmm2
andpd  %xmm0,%xmm2
ucomisd %xmm1,%xmm2
jbe    1430 <compute_ref_coefs+0x330>
add    $0x1,%al
jmp    1450 <compute_ref_coefs+0x350>
mov    $0x1,%al
add    $0x348,%rsp
pop    %rbx
pop    %r14
ret
xor    %ebx,%ebx
test   $0x1,%r8b
jne    11b8 <compute_ref_coefs+0xb8>
jmp    11e9 <compute_ref_coefs+0xe9>

LLVM IR (-O0):
define zeroext i8 @compute_ref_coefs(double* %0, i8 zeroext %1, double* %2) {
%4 = alloca double*
%5 = alloca i8
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca double
%10 = alloca [2 x [60 x double]]
%11 = alloca i8
store double* %0, double** %4
store i8 %1, i8* %5
store double* %2, double** %6
store i32 0, i32* %7
br label %12
12: ; preds = %32, %3
%13 = load i32, i32* %7
%14 = load i8, i8* %5
%15 = zext i8 %14 to i32
%16 = icmp slt i32 %13, %15
br i1 %16, label %17, label %35
17: ; preds = %12
%18 = load double*, double** %4
%19 = load i32, i32* %7
%20 = add nsw i32 %19, 1
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds double, double* %18, i64 %21
%23 = load double, double* %22
%24 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 1
%25 = load i32, i32* %7
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [60 x double], [60 x double]* %24, i64 0, i64 %26
store double %23, double* %27
%28 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 0
%29 = load i32, i32* %7
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [60 x double], [60 x double]* %28, i64 0, i64 %30
store double %23, double* %31
br label %32
32: ; preds = %17
%33 = load i32, i32* %7
%34 = add nsw i32 %33, 1
store i32 %34, i32* %7
br label %12
35: ; preds = %12
%36 = load double*, double** %4
%37 = getelementptr inbounds double, double* %36, i64 0
%38 = load double, double* %37
store double %38, double* %9
%39 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 1
%40 = getelementptr inbounds [60 x double], [60 x double]* %39, i64 0, i64 0
%41 = load double, double* %40
%42 = fneg double %41
%43 = load double, double* %9
%44 = fdiv double %42, %43
%45 = load double*, double** %6
%46 = getelementptr inbounds double, double* %45, i64 0
store double %44, double* %46
%47 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 1
%48 = getelementptr inbounds [60 x double], [60 x double]* %47, i64 0, i64 0
%49 = load double, double* %48
%50 = load double*, double** %6
%51 = getelementptr inbounds double, double* %50, i64 0
%52 = load double, double* %51
%53 = load double, double* %9
%54 = call double @llvm.fmuladd.f64(double %49, double %52, double %53)
store double %54, double* %9
store i32 1, i32* %7
br label %55
55: ; preds = %137, %35
%56 = load i32, i32* %7
%57 = load i8, i8* %5
%58 = zext i8 %57 to i32
%59 = icmp slt i32 %56, %58
br i1 %59, label %60, label %140
60: ; preds = %55
store i32 0, i32* %8
br label %61
61: ; preds = %113, %60
%62 = load i32, i32* %8
%63 = load i8, i8* %5
%64 = zext i8 %63 to i32
%65 = load i32, i32* %7
%66 = sub nsw i32 %64, %65
%67 = icmp slt i32 %62, %66
br i1 %67, label %68, label %116
68: ; preds = %61
%69 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 1
%70 = load i32, i32* %8
%71 = add nsw i32 %70, 1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [60 x double], [60 x double]* %69, i64 0, i64 %72
%74 = load double, double* %73
%75 = load double*, double** %6
%76 = load i32, i32* %7
%77 = sub nsw i32 %76, 1
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds double, double* %75, i64 %78
%80 = load double, double* %79
%81 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 0
%82 = load i32, i32* %8
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [60 x double], [60 x double]* %81, i64 0, i64 %83
%85 = load double, double* %84
%86 = call double @llvm.fmuladd.f64(double %80, double %85, double %74)
%87 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 1
%88 = load i32, i32* %8
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [60 x double], [60 x double]* %87, i64 0, i64 %89
store double %86, double* %90
%91 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 1
%92 = load i32, i32* %8
%93 = add nsw i32 %92, 1
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [60 x double], [60 x double]* %91, i64 0, i64 %94
%96 = load double, double* %95
%97 = load double*, double** %6
%98 = load i32, i32* %7
%99 = sub nsw i32 %98, 1
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %97, i64 %100
%102 = load double, double* %101
%103 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 0
%104 = load i32, i32* %8
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [60 x double], [60 x double]* %103, i64 0, i64 %105
%107 = load double, double* %106
%108 = call double @llvm.fmuladd.f64(double %96, double %102, double %107)
%109 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 0
%110 = load i32, i32* %8
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [60 x double], [60 x double]* %109, i64 0, i64 %111
store double %108, double* %112
br label %113
113: ; preds = %68
%114 = load i32, i32* %8
%115 = add nsw i32 %114, 1
store i32 %115, i32* %8
br label %61
116: ; preds = %61
%117 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 1
%118 = getelementptr inbounds [60 x double], [60 x double]* %117, i64 0, i64 0
%119 = load double, double* %118
%120 = fneg double %119
%121 = load double, double* %9
%122 = fdiv double %120, %121
%123 = load double*, double** %6
%124 = load i32, i32* %7
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds double, double* %123, i64 %125
store double %122, double* %126
%127 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %10, i64 0, i64 1
%128 = getelementptr inbounds [60 x double], [60 x double]* %127, i64 0, i64 0
%129 = load double, double* %128
%130 = load double*, double** %6
%131 = load i32, i32* %7
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double, double* %130, i64 %132
%134 = load double, double* %133
%135 = load double, double* %9
%136 = call double @llvm.fmuladd.f64(double %129, double %134, double %135)
store double %136, double* %9
br label %137
137: ; preds = %116
%138 = load i32, i32* %7
%139 = add nsw i32 %138, 1
store i32 %139, i32* %7
br label %55
140: ; preds = %55
store i8 1, i8* %11
%141 = load i8, i8* %5
%142 = zext i8 %141 to i32
%143 = sub nsw i32 %142, 1
store i32 %143, i32* %7
br label %144
144: ; preds = %160, %140
%145 = load i32, i32* %7
%146 = icmp sge i32 %145, 0
br i1 %146, label %147, label %163
147: ; preds = %144
%148 = load double*, double** %6
%149 = load i32, i32* %7
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %148, i64 %150
%152 = load double, double* %151
%153 = call double @llvm.fabs.f64(double %152)
%154 = fcmp ogt double %153, 1.000000e-01
br i1 %154, label %155, label %159
155: ; preds = %147
%156 = load i32, i32* %7
%157 = add nsw i32 %156, 1
%158 = trunc i32 %157 to i8
store i8 %158, i8* %11
br label %163
159: ; preds = %147
br label %160
160: ; preds = %159
%161 = load i32, i32* %7
%162 = add nsw i32 %161, -1
store i32 %162, i32* %7
br label %144
163: ; preds = %155, %144
%164 = load i8, i8* %11
ret i8 %164
}

LLVM IR (-O2):
define zeroext i8 @compute_ref_coefs(double* nocapture %0, i8 zeroext %1, double* nocapture %2) {
%4 = alloca [2 x [60 x double]]
%5 = bitcast [2 x [60 x double]]* %4 to i8*
%6 = zext i8 %1 to i32
%7 = icmp eq i8 %1, 0
br i1 %7, label %8, label %9
8: ; preds = %3
store double 0x7FF8000000000000, double* %2
br label %181
9: ; preds = %3
%10 = zext i8 %1 to i64
%11 = icmp ult i8 %1, 4
br i1 %11, label %79, label %12
12: ; preds = %9
%13 = and i64 %10, 252
%14 = add nsw i64 %13, -4
%15 = lshr exact i64 %14, 2
%16 = add nuw nsw i64 %15, 1
%17 = and i64 %16, 1
%18 = icmp eq i64 %14, 0
br i1 %18, label %58, label %19
19: ; preds = %12
%20 = and i64 %16, 9223372036854775806
br label %21
21: ; preds = %21, %19
%22 = phi i64 [ 0, %19 ], [ %55, %21 ]
%23 = phi i64 [ 0, %19 ], [ %56, %21 ]
%24 = or i64 %22, 1
%25 = getelementptr inbounds double, double* %0, i64 %24
%26 = bitcast double* %25 to <2 x double>*
%27 = load <2 x double>, <2 x double>* %26
%28 = getelementptr inbounds double, double* %25, i64 2
%29 = bitcast double* %28 to <2 x double>*
%30 = load <2 x double>, <2 x double>* %29
%31 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %22
%32 = bitcast double* %31 to <2 x double>*
store <2 x double> %27, <2 x double>* %32
%33 = getelementptr inbounds double, double* %31, i64 2
%34 = bitcast double* %33 to <2 x double>*
store <2 x double> %30, <2 x double>* %34
%35 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 0, i64 %22
%36 = bitcast double* %35 to <2 x double>*
store <2 x double> %27, <2 x double>* %36
%37 = getelementptr inbounds double, double* %35, i64 2
%38 = bitcast double* %37 to <2 x double>*
store <2 x double> %30, <2 x double>* %38
%39 = or i64 %22, 4
%40 = or i64 %22, 5
%41 = getelementptr inbounds double, double* %0, i64 %40
%42 = bitcast double* %41 to <2 x double>*
%43 = load <2 x double>, <2 x double>* %42
%44 = getelementptr inbounds double, double* %41, i64 2
%45 = bitcast double* %44 to <2 x double>*
%46 = load <2 x double>, <2 x double>* %45
%47 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %39
%48 = bitcast double* %47 to <2 x double>*
store <2 x double> %43, <2 x double>* %48
%49 = getelementptr inbounds double, double* %47, i64 2
%50 = bitcast double* %49 to <2 x double>*
store <2 x double> %46, <2 x double>* %50
%51 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 0, i64 %39
%52 = bitcast double* %51 to <2 x double>*
store <2 x double> %43, <2 x double>* %52
%53 = getelementptr inbounds double, double* %51, i64 2
%54 = bitcast double* %53 to <2 x double>*
store <2 x double> %46, <2 x double>* %54
%55 = add nuw i64 %22, 8
%56 = add i64 %23, 2
%57 = icmp eq i64 %56, %20
br i1 %57, label %58, label %21
58: ; preds = %21, %12
%59 = phi i64 [ 0, %12 ], [ %55, %21 ]
%60 = icmp eq i64 %17, 0
br i1 %60, label %77, label %61
61: ; preds = %58
%62 = or i64 %59, 1
%63 = getelementptr inbounds double, double* %0, i64 %62
%64 = bitcast double* %63 to <2 x double>*
%65 = load <2 x double>, <2 x double>* %64
%66 = getelementptr inbounds double, double* %63, i64 2
%67 = bitcast double* %66 to <2 x double>*
%68 = load <2 x double>, <2 x double>* %67
%69 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %59
%70 = bitcast double* %69 to <2 x double>*
store <2 x double> %65, <2 x double>* %70
%71 = getelementptr inbounds double, double* %69, i64 2
%72 = bitcast double* %71 to <2 x double>*
store <2 x double> %68, <2 x double>* %72
%73 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 0, i64 %59
%74 = bitcast double* %73 to <2 x double>*
store <2 x double> %65, <2 x double>* %74
%75 = getelementptr inbounds double, double* %73, i64 2
%76 = bitcast double* %75 to <2 x double>*
store <2 x double> %68, <2 x double>* %76
br label %77
77: ; preds = %58, %61
%78 = icmp eq i64 %13, %10
br i1 %78, label %89, label %79
79: ; preds = %9, %77
%80 = phi i64 [ 0, %9 ], [ %13, %77 ]
br label %81
81: ; preds = %79, %81
%82 = phi i64 [ %83, %81 ], [ %80, %79 ]
%83 = add nuw nsw i64 %82, 1
%84 = getelementptr inbounds double, double* %0, i64 %83
%85 = load double, double* %84
%86 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %82
store double %85, double* %86
%87 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 0, i64 %82
store double %85, double* %87
%88 = icmp eq i64 %83, %10
br i1 %88, label %89, label %81
89: ; preds = %81, %77
%90 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 0
%91 = load double, double* %90
%92 = load double, double* %0
%93 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 0
%94 = fneg double %91
%95 = fdiv double %94, %92
store double %95, double* %2
%96 = icmp ugt i8 %1, 1
br i1 %96, label %97, label %181
97: ; preds = %89
%98 = tail call double @llvm.fmuladd.f64(double %91, double %95, double %92)
%99 = zext i8 %1 to i64
%100 = zext i8 %1 to i64
br label %101
101: ; preds = %97, %194
%102 = phi i32 [ 0, %97 ], [ %202, %194 ]
%103 = phi double [ %95, %97 ], [ %197, %194 ]
%104 = phi i64 [ 1, %97 ], [ %200, %194 ]
%105 = phi i32 [ %6, %97 ], [ %117, %194 ]
%106 = phi double [ %98, %97 ], [ %199, %194 ]
%107 = xor i32 %102, -1
%108 = add i32 %107, %6
%109 = and i32 %108, -2
%110 = zext i32 %109 to i64
%111 = add nsw i64 %110, -2
%112 = lshr exact i64 %111, 1
%113 = add nuw i64 %112, 1
%114 = xor i32 %102, -1
%115 = add i32 %114, %6
%116 = zext i32 %115 to i64
%117 = add nsw i32 %105, -1
%118 = icmp ult i64 %104, %99
br i1 %118, label %119, label %194
119: ; preds = %101
%120 = zext i32 %117 to i64
%121 = icmp ult i32 %115, 2
br i1 %121, label %179, label %122
122: ; preds = %119
%123 = and i64 %116, 4294967294
%124 = insertelement <2 x double> poison, double %103, i64 0
%125 = shufflevector <2 x double> %124, <2 x double> poison, <2 x i32> zeroinitializer
%126 = and i64 %113, 1
%127 = icmp eq i64 %111, 0
br i1 %127, label %161, label %128
128: ; preds = %122
%129 = and i64 %113, -2
br label %130
130: ; preds = %130, %128
%131 = phi i64 [ 0, %128 ], [ %158, %130 ]
%132 = phi i64 [ 0, %128 ], [ %159, %130 ]
%133 = or i64 %131, 1
%134 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %133
%135 = bitcast double* %134 to <2 x double>*
%136 = load <2 x double>, <2 x double>* %135
%137 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 0, i64 %131
%138 = bitcast double* %137 to <2 x double>*
%139 = load <2 x double>, <2 x double>* %138
%140 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %125, <2 x double> %139, <2 x double> %136)
%141 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %131
%142 = bitcast double* %141 to <2 x double>*
store <2 x double> %140, <2 x double>* %142
%143 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %136, <2 x double> %125, <2 x double> %139)
%144 = bitcast double* %137 to <2 x double>*
store <2 x double> %143, <2 x double>* %144
%145 = or i64 %131, 2
%146 = or i64 %131, 3
%147 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %146
%148 = bitcast double* %147 to <2 x double>*
%149 = load <2 x double>, <2 x double>* %148
%150 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 0, i64 %145
%151 = bitcast double* %150 to <2 x double>*
%152 = load <2 x double>, <2 x double>* %151
%153 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %125, <2 x double> %152, <2 x double> %149)
%154 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %145
%155 = bitcast double* %154 to <2 x double>*
store <2 x double> %153, <2 x double>* %155
%156 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %149, <2 x double> %125, <2 x double> %152)
%157 = bitcast double* %150 to <2 x double>*
store <2 x double> %156, <2 x double>* %157
%158 = add nuw i64 %131, 4
%159 = add nuw i64 %132, 2
%160 = icmp eq i64 %159, %129
br i1 %160, label %161, label %130
161: ; preds = %130, %122
%162 = phi i64 [ 0, %122 ], [ %158, %130 ]
%163 = icmp eq i64 %126, 0
br i1 %163, label %177, label %164
164: ; preds = %161
%165 = or i64 %162, 1
%166 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %165
%167 = bitcast double* %166 to <2 x double>*
%168 = load <2 x double>, <2 x double>* %167
%169 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 0, i64 %162
%170 = bitcast double* %169 to <2 x double>*
%171 = load <2 x double>, <2 x double>* %170
%172 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %125, <2 x double> %171, <2 x double> %168)
%173 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %162
%174 = bitcast double* %173 to <2 x double>*
store <2 x double> %172, <2 x double>* %174
%175 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %168, <2 x double> %125, <2 x double> %171)
%176 = bitcast double* %169 to <2 x double>*
store <2 x double> %175, <2 x double>* %176
br label %177
177: ; preds = %161, %164
%178 = icmp eq i64 %123, %116
br i1 %178, label %194, label %179
179: ; preds = %119, %177
%180 = phi i64 [ 0, %119 ], [ %123, %177 ]
br label %183
181: ; preds = %194, %8, %89
%182 = zext i8 %1 to i64
br label %203
183: ; preds = %179, %183
%184 = phi i64 [ %185, %183 ], [ %180, %179 ]
%185 = add nuw nsw i64 %184, 1
%186 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %185
%187 = load double, double* %186
%188 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 0, i64 %184
%189 = load double, double* %188
%190 = tail call double @llvm.fmuladd.f64(double %103, double %189, double %187)
%191 = getelementptr inbounds [2 x [60 x double]], [2 x [60 x double]]* %4, i64 0, i64 1, i64 %184
store double %190, double* %191
%192 = tail call double @llvm.fmuladd.f64(double %187, double %103, double %189)
store double %192, double* %188
%193 = icmp eq i64 %185, %120
br i1 %193, label %194, label %183
194: ; preds = %183, %177, %101
%195 = load double, double* %93
%196 = fneg double %195
%197 = fdiv double %196, %106
%198 = getelementptr inbounds double, double* %2, i64 %104
store double %197, double* %198
%199 = tail call double @llvm.fmuladd.f64(double %195, double %197, double %106)
%200 = add nuw nsw i64 %104, 1
%201 = icmp eq i64 %200, %100
%202 = add i32 %102, 1
br i1 %201, label %181, label %101
203: ; preds = %181, %207
%204 = phi i64 [ %182, %181 ], [ %205, %207 ]
%205 = add nsw i64 %204, -1
%206 = icmp sgt i64 %204, 0
br i1 %206, label %207, label %215
207: ; preds = %203
%208 = and i64 %205, 4294967295
%209 = getelementptr inbounds double, double* %2, i64 %208
%210 = load double, double* %209
%211 = tail call double @llvm.fabs.f64(double %210)
%212 = fcmp ogt double %211, 1.000000e-01
br i1 %212, label %213, label %203
213: ; preds = %207
%214 = trunc i64 %204 to i8
br label %215
215: ; preds = %203, %213
%216 = phi i8 [ %214, %213 ], [ 1, %203 ]
ret i8 %216
}