#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);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int);
scalar_t__ space(int);
int /*<<< orphan*/ stderr;
double *Newton_Conc(double KAB, double KAA, double KBB, double concA,
                    double concB, double *ConcVec) {
  double TOL, EPS, xn, yn, det, cA, cB;
  int i = 0;
  cA = concA;
  cB = concB;
  TOL = 1e-6;
  ConcVec = (double *)space(5 * sizeof(double));
  do {
    det =
        (4.0 * KAA * cA + KAB * cB + 1.0) * (4.0 * KBB * cB + KAB * cA + 1.0) -
        (KAB * cB) * (KAB * cA);
    xn = ((2.0 * KBB * cB * cB + KAB * cA * cB + cB - concB) * (KAB * cA) -
          (2.0 * KAA * cA * cA + KAB * cA * cB + cA - concA) *
              (4.0 * KBB * cB + KAB * cA + 1.0)) /
         det;
    yn = ((2.0 * KAA * cA * cA + KAB * cA * cB + cA - concA) * (KAB * cB) -
          (2.0 * KBB * cB * cB + KAB * cA * cB + cB - concB) *
              (4.0 * KAA * cA + KAB * cB + 1.0)) /
         det;
    EPS = fabs(xn / cA) + fabs(yn / cB);
    cA += xn;
    cB += yn;
    i++;
    if (i > 10000) {
      fprintf(stderr, "Newton did not converge after %d steps!!\n", i);
      break;
    }
  } while (EPS > TOL);
  ConcVec[0] = cA * cB * KAB;
  ConcVec[1] = cA * cA * KAA;
  ConcVec[2] = cB * cB * KBB;
  ConcVec[3] = cA;
  ConcVec[4] = cB;
  return ConcVec;
}


x86 assembly (clang, -O0):
<Newton_Conc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
movsd  %xmm3,-0x20(%rbp)
movsd  %xmm4,-0x28(%rbp)
mov    %rdi,-0x30(%rbp)
movl   $0x0,-0x6c(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0xe98(%rip),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    $0x28,%edi
call   1030 <space@plt>
mov    %rax,-0x30(%rbp)
movsd  0xe8d(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x8(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xe61(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  0xe5d(%rip),%xmm2
mulsd  -0x18(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm3
movsd  -0x8(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0xe31(%rip),%xmm1
addsd  %xmm1,%xmm2
movsd  -0x8(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movsd  -0x8(%rbp),%xmm3
mulsd  -0x60(%rbp),%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xdf9(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x8(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x68(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm2
mulsd  -0x60(%rbp),%xmm2
movsd  0xdb7(%rip),%xmm1
mulsd  -0x10(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm4
movsd  -0x8(%rbp),%xmm3
mulsd  -0x60(%rbp),%xmm3
mulsd  -0x68(%rbp),%xmm3
mulsd  %xmm4,%xmm1
addsd  %xmm3,%xmm1
addsd  -0x60(%rbp),%xmm1
subsd  -0x20(%rbp),%xmm1
movsd  0xd77(%rip),%xmm3
mulsd  -0x18(%rbp),%xmm3
movsd  -0x68(%rbp),%xmm5
movsd  -0x8(%rbp),%xmm4
mulsd  -0x60(%rbp),%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
movsd  0xd4b(%rip),%xmm4
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xd22(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x8(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x60(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm2
mulsd  -0x68(%rbp),%xmm2
movsd  0xce0(%rip),%xmm1
mulsd  -0x18(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm4
movsd  -0x8(%rbp),%xmm3
mulsd  -0x60(%rbp),%xmm3
mulsd  -0x68(%rbp),%xmm3
mulsd  %xmm4,%xmm1
addsd  %xmm3,%xmm1
addsd  -0x68(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
movsd  0xca0(%rip),%xmm3
mulsd  -0x10(%rbp),%xmm3
movsd  -0x60(%rbp),%xmm5
movsd  -0x8(%rbp),%xmm4
mulsd  -0x68(%rbp),%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
movsd  0xc74(%rip),%xmm4
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
divsd  -0x60(%rbp),%xmm0
movaps 0xc4a(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm1
divsd  -0x68(%rbp),%xmm1
movaps 0xc35(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x2710,-0x6c(%rbp)
jle    1449 <Newton_Conc+0x329>
mov    0x2bad(%rip),%rax
mov    (%rax),%edi
mov    -0x6c(%rbp),%edx
lea    0xbf1(%rip),%rsi
call   1040 <fprintf@plt>
jmp    145e <Newton_Conc+0x33e>
jmp    144e <Newton_Conc+0x32e>
movsd  -0x40(%rbp),%xmm0
ucomisd -0x38(%rbp),%xmm0
ja     117b <Newton_Conc+0x5b>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x8(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x10(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x68(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    -0x30(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Newton_Conc>:
push   %rbx
sub    $0x50,%rsp
movaps %xmm4,0x40(%rsp)
movapd %xmm3,(%rsp)
movapd %xmm2,0x30(%rsp)
movapd %xmm1,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
mov    $0x28,%edi
call   1030 <space@plt>
movapd 0x40(%rsp),%xmm14
mov    %rax,%rbx
movapd 0x30(%rsp),%xmm13
unpcklpd 0x10(%rsp),%xmm13
movapd 0xe95(%rip),%xmm11
mulpd  %xmm13,%xmm11
addpd  %xmm13,%xmm13
movapd (%rsp),%xmm0
movapd %xmm0,%xmm6
unpcklpd %xmm14,%xmm6
unpcklpd %xmm0,%xmm14
movapd 0x20(%rsp),%xmm12
unpcklpd %xmm12,%xmm12
mov    $0x2711,%eax
movapd 0xe6e(%rip),%xmm10
movapd 0xe75(%rip),%xmm8
movsd  0xe7c(%rip),%xmm9
movapd %xmm6,%xmm4
nopl   0x0(%rax,%rax,1)
movapd %xmm6,%xmm7
mulpd  %xmm12,%xmm7
movapd %xmm6,%xmm5
unpckhpd %xmm6,%xmm5
movapd %xmm6,%xmm3
shufpd $0x1,%xmm6,%xmm3
movapd %xmm11,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm7,%xmm2
addpd  %xmm10,%xmm2
movapd %xmm7,%xmm0
unpckhpd %xmm7,%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm7,%xmm5
movapd %xmm13,%xmm0
mulpd  %xmm3,%xmm0
unpcklpd %xmm5,%xmm5
mulpd  %xmm3,%xmm0
addpd  %xmm5,%xmm0
addpd  %xmm3,%xmm0
subpd  %xmm14,%xmm0
movapd %xmm0,%xmm3
shufpd $0x1,%xmm0,%xmm3
mulpd  %xmm2,%xmm3
mulpd  %xmm7,%xmm0
subpd  %xmm3,%xmm0
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm0
addpd  %xmm0,%xmm4
add    $0xffffffff,%eax
je     1273 <Newton_Conc+0x153>
divpd  %xmm6,%xmm0
andpd  %xmm8,%xmm0
pshufd $0xee,%xmm0,%xmm1
addsd  %xmm0,%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm4,%xmm6
ja     11c0 <Newton_Conc+0xa0>
jmp    1297 <Newton_Conc+0x177>
mov    0x2d66(%rip),%rax
mov    (%rax),%edi
lea    0xdb5(%rip),%rsi
mov    $0x2711,%edx
movapd %xmm4,(%rsp)
call   1040 <fprintf@plt>
movapd (%rsp),%xmm4
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
movapd 0x20(%rsp),%xmm2
unpcklpd 0x10(%rsp),%xmm2
movapd %xmm4,%xmm1
shufpd $0x1,%xmm4,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm2,%xmm1
movupd %xmm1,(%rbx)
movapd %xmm4,%xmm0
mulpd  %xmm4,%xmm0
unpckhpd %xmm0,%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x10(%rbx)
movupd %xmm4,0x18(%rbx)
mov    %rbx,%rax
add    $0x50,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@stderr = global i32 0
@.str = [42 x i8] c"Newton did not converge after %d steps!!\0A\00"
define double* @Newton_Conc(double %0, double %1, double %2, double %3, double %4, double* %5) {
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double*
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca i32
store double %0, double* %7
store double %1, double* %8
store double %2, double* %9
store double %3, double* %10
store double %4, double* %11
store double* %5, double** %12
store i32 0, i32* %20
%21 = load double, double* %10
store double %21, double* %18
%22 = load double, double* %11
store double %22, double* %19
store double 0x3EB0C6F7A0B5ED8D, double* %13
%23 = call i64 @space(i32 40)
%24 = inttoptr i64 %23 to double*
store double* %24, double** %12
br label %25
25: ; preds = %167, %6
%26 = load double, double* %8
%27 = fmul double 4.000000e+00, %26
%28 = load double, double* %18
%29 = load double, double* %7
%30 = load double, double* %19
%31 = fmul double %29, %30
%32 = call double @llvm.fmuladd.f64(double %27, double %28, double %31)
%33 = fadd double %32, 1.000000e+00
%34 = load double, double* %9
%35 = fmul double 4.000000e+00, %34
%36 = load double, double* %19
%37 = load double, double* %7
%38 = load double, double* %18
%39 = fmul double %37, %38
%40 = call double @llvm.fmuladd.f64(double %35, double %36, double %39)
%41 = fadd double %40, 1.000000e+00
%42 = load double, double* %7
%43 = load double, double* %19
%44 = fmul double %42, %43
%45 = load double, double* %7
%46 = load double, double* %18
%47 = fmul double %45, %46
%48 = fmul double %44, %47
%49 = fneg double %48
%50 = call double @llvm.fmuladd.f64(double %33, double %41, double %49)
store double %50, double* %17
%51 = load double, double* %9
%52 = fmul double 2.000000e+00, %51
%53 = load double, double* %19
%54 = fmul double %52, %53
%55 = load double, double* %19
%56 = load double, double* %7
%57 = load double, double* %18
%58 = fmul double %56, %57
%59 = load double, double* %19
%60 = fmul double %58, %59
%61 = call double @llvm.fmuladd.f64(double %54, double %55, double %60)
%62 = load double, double* %19
%63 = fadd double %61, %62
%64 = load double, double* %11
%65 = fsub double %63, %64
%66 = load double, double* %7
%67 = load double, double* %18
%68 = fmul double %66, %67
%69 = load double, double* %8
%70 = fmul double 2.000000e+00, %69
%71 = load double, double* %18
%72 = fmul double %70, %71
%73 = load double, double* %18
%74 = load double, double* %7
%75 = load double, double* %18
%76 = fmul double %74, %75
%77 = load double, double* %19
%78 = fmul double %76, %77
%79 = call double @llvm.fmuladd.f64(double %72, double %73, double %78)
%80 = load double, double* %18
%81 = fadd double %79, %80
%82 = load double, double* %10
%83 = fsub double %81, %82
%84 = load double, double* %9
%85 = fmul double 4.000000e+00, %84
%86 = load double, double* %19
%87 = load double, double* %7
%88 = load double, double* %18
%89 = fmul double %87, %88
%90 = call double @llvm.fmuladd.f64(double %85, double %86, double %89)
%91 = fadd double %90, 1.000000e+00
%92 = fmul double %83, %91
%93 = fneg double %92
%94 = call double @llvm.fmuladd.f64(double %65, double %68, double %93)
%95 = load double, double* %17
%96 = fdiv double %94, %95
store double %96, double* %15
%97 = load double, double* %8
%98 = fmul double 2.000000e+00, %97
%99 = load double, double* %18
%100 = fmul double %98, %99
%101 = load double, double* %18
%102 = load double, double* %7
%103 = load double, double* %18
%104 = fmul double %102, %103
%105 = load double, double* %19
%106 = fmul double %104, %105
%107 = call double @llvm.fmuladd.f64(double %100, double %101, double %106)
%108 = load double, double* %18
%109 = fadd double %107, %108
%110 = load double, double* %10
%111 = fsub double %109, %110
%112 = load double, double* %7
%113 = load double, double* %19
%114 = fmul double %112, %113
%115 = load double, double* %9
%116 = fmul double 2.000000e+00, %115
%117 = load double, double* %19
%118 = fmul double %116, %117
%119 = load double, double* %19
%120 = load double, double* %7
%121 = load double, double* %18
%122 = fmul double %120, %121
%123 = load double, double* %19
%124 = fmul double %122, %123
%125 = call double @llvm.fmuladd.f64(double %118, double %119, double %124)
%126 = load double, double* %19
%127 = fadd double %125, %126
%128 = load double, double* %11
%129 = fsub double %127, %128
%130 = load double, double* %8
%131 = fmul double 4.000000e+00, %130
%132 = load double, double* %18
%133 = load double, double* %7
%134 = load double, double* %19
%135 = fmul double %133, %134
%136 = call double @llvm.fmuladd.f64(double %131, double %132, double %135)
%137 = fadd double %136, 1.000000e+00
%138 = fmul double %129, %137
%139 = fneg double %138
%140 = call double @llvm.fmuladd.f64(double %111, double %114, double %139)
%141 = load double, double* %17
%142 = fdiv double %140, %141
store double %142, double* %16
%143 = load double, double* %15
%144 = load double, double* %18
%145 = fdiv double %143, %144
%146 = call double @llvm.fabs.f64(double %145)
%147 = load double, double* %16
%148 = load double, double* %19
%149 = fdiv double %147, %148
%150 = call double @llvm.fabs.f64(double %149)
%151 = fadd double %146, %150
store double %151, double* %14
%152 = load double, double* %15
%153 = load double, double* %18
%154 = fadd double %153, %152
store double %154, double* %18
%155 = load double, double* %16
%156 = load double, double* %19
%157 = fadd double %156, %155
store double %157, double* %19
%158 = load i32, i32* %20
%159 = add nsw i32 %158, 1
store i32 %159, i32* %20
%160 = load i32, i32* %20
%161 = icmp sgt i32 %160, 10000
br i1 %161, label %162, label %166
162: ; preds = %25
%163 = load i32, i32* @stderr
%164 = load i32, i32* %20
%165 = call i32 @fprintf(i32 %163, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0), i32 %164)
br label %171
166: ; preds = %25
br label %167
167: ; preds = %166
%168 = load double, double* %14
%169 = load double, double* %13
%170 = fcmp ogt double %168, %169
br i1 %170, label %25, label %171
171: ; preds = %167, %162
%172 = load double, double* %18
%173 = load double, double* %19
%174 = fmul double %172, %173
%175 = load double, double* %7
%176 = fmul double %174, %175
%177 = load double*, double** %12
%178 = getelementptr inbounds double, double* %177, i64 0
store double %176, double* %178
%179 = load double, double* %18
%180 = load double, double* %18
%181 = fmul double %179, %180
%182 = load double, double* %8
%183 = fmul double %181, %182
%184 = load double*, double** %12
%185 = getelementptr inbounds double, double* %184, i64 1
store double %183, double* %185
%186 = load double, double* %19
%187 = load double, double* %19
%188 = fmul double %186, %187
%189 = load double, double* %9
%190 = fmul double %188, %189
%191 = load double*, double** %12
%192 = getelementptr inbounds double, double* %191, i64 2
store double %190, double* %192
%193 = load double, double* %18
%194 = load double*, double** %12
%195 = getelementptr inbounds double, double* %194, i64 3
store double %193, double* %195
%196 = load double, double* %19
%197 = load double*, double** %12
%198 = getelementptr inbounds double, double* %197, i64 4
store double %196, double* %198
%199 = load double*, double** %12
ret double* %199
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [42 x i8] c"Newton did not converge after %d steps!!\0A\00"
define double* @Newton_Conc(double %0, double %1, double %2, double %3, double %4, double* nocapture readnone %5) {
%7 = tail call i64 @space(i32 40)
%8 = inttoptr i64 %7 to double*
%9 = insertelement <2 x double> poison, double %2, i64 0
%10 = insertelement <2 x double> %9, double %1, i64 1
%11 = fmul <2 x double> %10, <double 4.000000e+00, double 4.000000e+00>
%12 = fmul <2 x double> %10, <double 2.000000e+00, double 2.000000e+00>
%13 = insertelement <2 x double> poison, double %3, i64 0
%14 = insertelement <2 x double> %13, double %4, i64 1
%15 = insertelement <2 x double> poison, double %4, i64 0
%16 = insertelement <2 x double> %15, double %3, i64 1
%17 = insertelement <2 x double> poison, double %0, i64 0
%18 = shufflevector <2 x double> %17, <2 x double> poison, <2 x i32> zeroinitializer
br label %19
19: ; preds = %53, %6
%20 = phi i32 [ 0, %6 ], [ %54, %53 ]
%21 = phi <2 x double> [ %14, %6 ], [ %48, %53 ]
%22 = fmul <2 x double> %21, %18
%23 = extractelement <2 x double> %21, i64 1
%24 = shufflevector <2 x double> %21, <2 x double> undef, <2 x i32> <i32 1, i32 0>
%25 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %11, <2 x double> %24, <2 x double> %22)
%26 = fadd <2 x double> %25, <double 1.000000e+00, double 1.000000e+00>
%27 = extractelement <2 x double> %22, i64 1
%28 = fneg double %27
%29 = extractelement <2 x double> %22, i64 0
%30 = fmul double %29, %28
%31 = extractelement <2 x double> %26, i64 0
%32 = extractelement <2 x double> %26, i64 1
%33 = tail call double @llvm.fmuladd.f64(double %32, double %31, double %30)
%34 = fmul double %29, %23
%35 = fmul <2 x double> %12, %24
%36 = insertelement <2 x double> poison, double %34, i64 0
%37 = shufflevector <2 x double> %36, <2 x double> poison, <2 x i32> zeroinitializer
%38 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %35, <2 x double> %24, <2 x double> %37)
%39 = fadd <2 x double> %24, %38
%40 = fsub <2 x double> %39, %16
%41 = shufflevector <2 x double> %40, <2 x double> undef, <2 x i32> <i32 1, i32 0>
%42 = fneg <2 x double> %41
%43 = fmul <2 x double> %26, %42
%44 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %40, <2 x double> %22, <2 x double> %43)
%45 = insertelement <2 x double> poison, double %33, i64 0
%46 = shufflevector <2 x double> %45, <2 x double> poison, <2 x i32> zeroinitializer
%47 = fdiv <2 x double> %44, %46
%48 = fadd <2 x double> %21, %47
%49 = icmp eq i32 %20, 10000
br i1 %49, label %50, label %53
50: ; preds = %19
%51 = load i32, i32* @stderr
%52 = tail call i32 @fprintf(i32 %51, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0), i32 10001)
br label %61
53: ; preds = %19
%54 = add nuw nsw i32 %20, 1
%55 = fdiv <2 x double> %47, %21
%56 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %55)
%57 = shufflevector <2 x double> %56, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%58 = fadd <2 x double> %56, %57
%59 = extractelement <2 x double> %58, i64 0
%60 = fcmp ogt double %59, 0x3EB0C6F7A0B5ED8D
br i1 %60, label %19, label %61
61: ; preds = %53, %50
%62 = shufflevector <2 x double> %48, <2 x double> undef, <2 x i32> zeroinitializer
%63 = fmul <2 x double> %62, %48
%64 = insertelement <2 x double> poison, double %1, i64 0
%65 = insertelement <2 x double> %64, double %0, i64 1
%66 = fmul <2 x double> %63, %65
%67 = shufflevector <2 x double> %66, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%68 = inttoptr i64 %7 to <2 x double>*
store <2 x double> %67, <2 x double>* %68
%69 = fmul <2 x double> %48, %48
%70 = extractelement <2 x double> %69, i64 1
%71 = fmul double %70, %2
%72 = getelementptr inbounds double, double* %8, i64 2
store double %71, double* %72
%73 = getelementptr inbounds double, double* %8, i64 3
%74 = bitcast double* %73 to <2 x double>*
store <2 x double> %48, <2 x double>* %74
ret double* %8
}