#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 *alloca(int);
int Newton_Raphson(float *a, int ord, float *r) {
  int i, k, count = 0;
  double error = 1.f;
  double *root = alloca(ord * sizeof(*root));
  for (i = 0; i < ord; i++)
    root[i] = r[i];
  while (error > 1e-20) {
    error = 0;
    for (i = 0; i < ord; i++) {
      double pp = 0., delta;
      double rooti = root[i];
      double p = a[ord];
      for (k = ord - 1; k >= 0; k--) {
        pp = pp * rooti + p;
        p = p * rooti + a[k];
      }
      delta = p / pp;
      root[i] -= delta;
      error += delta * delta;
    }
    if (count > 40)
      return (-1);
    count++;
  }
  for (i = 0; i < ord; i++)
    r[i] = root[i];
  return (0);
}


x86 assembly (clang, -O0):
<Newton_Raphson>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
movsd  0xece(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <alloca@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1189 <Newton_Raphson+0x79>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1151 <Newton_Raphson+0x41>
jmp    118e <Newton_Raphson+0x7e>
movsd  -0x38(%rbp),%xmm0
movsd  0xe6d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    12cd <Newton_Raphson+0x1bd>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a9 <Newton_Raphson+0x199>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1255 <Newton_Raphson+0x145>
movsd  -0x48(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    11f9 <Newton_Raphson+0xe9>
movsd  -0x60(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm1
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b4 <Newton_Raphson+0xa4>
cmpl   $0x28,-0x2c(%rbp)
jle    12bf <Newton_Raphson+0x1af>
movl   $0xffffffff,-0x4(%rbp)
jmp    1313 <Newton_Raphson+0x203>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    118e <Newton_Raphson+0x7e>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    130c <Newton_Raphson+0x1fc>
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12d4 <Newton_Raphson+0x1c4>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Newton_Raphson>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r14
mov    %esi,%r15d
mov    %rdi,%rbx
lea    0x0(,%r15,8),%edi
call   1030 <alloca@plt>
mov    %r15d,%r12d
test   %r15d,%r15d
jle    11e8 <Newton_Raphson+0xd8>
cmp    $0x4,%r15d
jae    1147 <Newton_Raphson+0x37>
xor    %edx,%edx
jmp    11d0 <Newton_Raphson+0xc0>
mov    %r12d,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1330 <Newton_Raphson+0x220>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
xchg   %ax,%ax
cvtps2pd (%r14,%rdi,4),%xmm0
cvtps2pd 0x8(%r14,%rdi,4),%xmm1
movups %xmm0,(%rax,%rdi,8)
movups %xmm1,0x10(%rax,%rdi,8)
cvtps2pd 0x10(%r14,%rdi,4),%xmm0
cvtps2pd 0x18(%r14,%rdi,4),%xmm1
movups %xmm0,0x20(%rax,%rdi,8)
movupd %xmm1,0x30(%rax,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1170 <Newton_Raphson+0x60>
test   $0x1,%r8b
je     11c0 <Newton_Raphson+0xb0>
cvtps2pd (%r14,%rdi,4),%xmm0
cvtps2pd 0x8(%r14,%rdi,4),%xmm1
movups %xmm0,(%rax,%rdi,8)
movupd %xmm1,0x10(%rax,%rdi,8)
cmp    %r12,%rdx
je     11e8 <Newton_Raphson+0xd8>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r14,%rdx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    11d0 <Newton_Raphson+0xc0>
movslq %r15d,%r8
lea    -0x1(%r12),%r11
mov    %r11d,%r10d
xor    %r9d,%r9d
movsd  0xe02(%rip),%xmm0
xorpd  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %r15d,%r15d
jle    131a <Newton_Raphson+0x20a>
movss  (%rbx,%r8,4),%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm2,%xmm3
xorps  %xmm2,%xmm2
xor    %edi,%edi
jmp    1252 <Newton_Raphson+0x142>
nopl   (%rax)
divsd  %xmm6,%xmm5
subsd  %xmm5,%xmm4
movsd  %xmm4,(%rax,%rdi,8)
mulsd  %xmm5,%xmm5
addsd  %xmm5,%xmm2
add    $0x1,%rdi
cmp    %r12,%rdi
je     12f0 <Newton_Raphson+0x1e0>
movsd  (%rax,%rdi,8),%xmm4
mov    %r12,%rdx
movaps %xmm3,%xmm5
xorpd  %xmm6,%xmm6
test   $0x1,%r12b
je     128f <Newton_Raphson+0x17f>
movapd %xmm4,%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm3,%xmm6
movss  (%rbx,%r10,4),%xmm5
xorps  %xmm7,%xmm7
cvtss2sd %xmm5,%xmm7
movapd %xmm3,%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm7,%xmm5
mov    %r11,%rdx
cmp    $0x1,%r15d
je     1230 <Newton_Raphson+0x120>
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x1(%rdx),%esi
mulsd  %xmm4,%xmm6
addsd  %xmm5,%xmm6
movss  (%rbx,%rsi,4),%xmm7
cvtss2sd %xmm7,%xmm7
mulsd  %xmm4,%xmm5
addsd  %xmm7,%xmm5
lea    -0x2(%rdx),%rsi
mulsd  %xmm4,%xmm6
addsd  %xmm5,%xmm6
mov    %esi,%ecx
movss  (%rbx,%rcx,4),%xmm7
cvtss2sd %xmm7,%xmm7
mulsd  %xmm4,%xmm5
addsd  %xmm7,%xmm5
cmp    $0x2,%rdx
mov    %rsi,%rdx
jg     12a0 <Newton_Raphson+0x190>
jmp    1230 <Newton_Raphson+0x120>
nopl   0x0(%rax)
cmp    $0x29,%r9d
je     1326 <Newton_Raphson+0x216>
add    $0x1,%r9d
ucomisd %xmm0,%xmm2
ja     1210 <Newton_Raphson+0x100>
test   %r15d,%r15d
jle    13f8 <Newton_Raphson+0x2e8>
cmp    $0x4,%r15d
jae    1341 <Newton_Raphson+0x231>
xor    %esi,%esi
jmp    13e0 <Newton_Raphson+0x2d0>
xor    %edx,%edx
cmp    $0x29,%r9d
jne    13fa <Newton_Raphson+0x2ea>
mov    $0xffffffff,%edx
jmp    13fa <Newton_Raphson+0x2ea>
xor    %edi,%edi
test   $0x1,%r8b
jne    11ab <Newton_Raphson+0x9b>
jmp    11c0 <Newton_Raphson+0xb0>
mov    %r12d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rdx
mov    %rdx,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rdx,%rdx
je     1408 <Newton_Raphson+0x2f8>
mov    %rbx,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd (%rax,%rdi,8),%xmm0
movupd 0x10(%rax,%rdi,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%r14,%rdi,4)
movupd 0x20(%rax,%rdi,8),%xmm0
movupd 0x30(%rax,%rdi,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,0x10(%r14,%rdi,4)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rdx
jne    1370 <Newton_Raphson+0x260>
test   $0x1,%bl
je     13d8 <Newton_Raphson+0x2c8>
movupd (%rax,%rdi,8),%xmm0
movupd 0x10(%rax,%rdi,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%r14,%rdi,4)
xor    %edx,%edx
cmp    %r12,%rsi
je     13fa <Newton_Raphson+0x2ea>
nop
movsd  (%rax,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r14,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r12
jne    13e0 <Newton_Raphson+0x2d0>
xor    %edx,%edx
mov    %edx,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
xor    %edi,%edi
test   $0x1,%bl
jne    13bb <Newton_Raphson+0x2ab>
jmp    13d8 <Newton_Raphson+0x2c8>

LLVM IR (-O0):
define i32 @Newton_Raphson(float* %0, i32 %1, float* %2) {
%4 = alloca i32
%5 = alloca float*
%6 = alloca i32
%7 = alloca float*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca double
%12 = alloca double*
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
store float* %0, float** %5
store i32 %1, i32* %6
store float* %2, float** %7
store i32 0, i32* %10
store double 1.000000e+00, double* %11
%17 = load i32, i32* %6
%18 = sext i32 %17 to i64
%19 = mul i64 %18, 8
%20 = trunc i64 %19 to i32
%21 = call double* @alloca(i32 %20)
store double* %21, double** %12
store i32 0, i32* %8
br label %22
22: ; preds = %37, %3
%23 = load i32, i32* %8
%24 = load i32, i32* %6
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %40
26: ; preds = %22
%27 = load float*, float** %7
%28 = load i32, i32* %8
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds float, float* %27, i64 %29
%31 = load float, float* %30
%32 = fpext float %31 to double
%33 = load double*, double** %12
%34 = load i32, i32* %8
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds double, double* %33, i64 %35
store double %32, double* %36
br label %37
37: ; preds = %26
%38 = load i32, i32* %8
%39 = add nsw i32 %38, 1
store i32 %39, i32* %8
br label %22
40: ; preds = %22
br label %41
41: ; preds = %105, %40
%42 = load double, double* %11
%43 = fcmp ogt double %42, 0x3BC79CA10C924223
br i1 %43, label %44, label %108
44: ; preds = %41
store double 0.000000e+00, double* %11
store i32 0, i32* %8
br label %45
45: ; preds = %98, %44
%46 = load i32, i32* %8
%47 = load i32, i32* %6
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %101
49: ; preds = %45
store double 0.000000e+00, double* %13
%50 = load double*, double** %12
%51 = load i32, i32* %8
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %50, i64 %52
%54 = load double, double* %53
store double %54, double* %15
%55 = load float*, float** %5
%56 = load i32, i32* %6
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds float, float* %55, i64 %57
%59 = load float, float* %58
%60 = fpext float %59 to double
store double %60, double* %16
%61 = load i32, i32* %6
%62 = sub nsw i32 %61, 1
store i32 %62, i32* %9
br label %63
63: ; preds = %80, %49
%64 = load i32, i32* %9
%65 = icmp sge i32 %64, 0
br i1 %65, label %66, label %83
66: ; preds = %63
%67 = load double, double* %13
%68 = load double, double* %15
%69 = load double, double* %16
%70 = call double @llvm.fmuladd.f64(double %67, double %68, double %69)
store double %70, double* %13
%71 = load double, double* %16
%72 = load double, double* %15
%73 = load float*, float** %5
%74 = load i32, i32* %9
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds float, float* %73, i64 %75
%77 = load float, float* %76
%78 = fpext float %77 to double
%79 = call double @llvm.fmuladd.f64(double %71, double %72, double %78)
store double %79, double* %16
br label %80
80: ; preds = %66
%81 = load i32, i32* %9
%82 = add nsw i32 %81, -1
store i32 %82, i32* %9
br label %63
83: ; preds = %63
%84 = load double, double* %16
%85 = load double, double* %13
%86 = fdiv double %84, %85
store double %86, double* %14
%87 = load double, double* %14
%88 = load double*, double** %12
%89 = load i32, i32* %8
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %88, i64 %90
%92 = load double, double* %91
%93 = fsub double %92, %87
store double %93, double* %91
%94 = load double, double* %14
%95 = load double, double* %14
%96 = load double, double* %11
%97 = call double @llvm.fmuladd.f64(double %94, double %95, double %96)
store double %97, double* %11
br label %98
98: ; preds = %83
%99 = load i32, i32* %8
%100 = add nsw i32 %99, 1
store i32 %100, i32* %8
br label %45
101: ; preds = %45
%102 = load i32, i32* %10
%103 = icmp sgt i32 %102, 40
br i1 %103, label %104, label %105
104: ; preds = %101
store i32 -1, i32* %4
br label %128
105: ; preds = %101
%106 = load i32, i32* %10
%107 = add nsw i32 %106, 1
store i32 %107, i32* %10
br label %41
108: ; preds = %41
store i32 0, i32* %8
br label %109
109: ; preds = %124, %108
%110 = load i32, i32* %8
%111 = load i32, i32* %6
%112 = icmp slt i32 %110, %111
br i1 %112, label %113, label %127
113: ; preds = %109
%114 = load double*, double** %12
%115 = load i32, i32* %8
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double, double* %114, i64 %116
%118 = load double, double* %117
%119 = fptrunc double %118 to float
%120 = load float*, float** %7
%121 = load i32, i32* %8
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds float, float* %120, i64 %122
store float %119, float* %123
br label %124
124: ; preds = %113
%125 = load i32, i32* %8
%126 = add nsw i32 %125, 1
store i32 %126, i32* %8
br label %109
127: ; preds = %109
store i32 0, i32* %4
br label %128
128: ; preds = %127, %104
%129 = load i32, i32* %4
ret i32 %129
}

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