#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 fabs(double);
double getSign(double);
size_t ind(int, int);
double sqrt(int);
void computeFractionalPixel(double *points, int numberOfPoints, double de1,
                            int nextP1I, int p1I, double *p1) {
  double dp1[2];
  const double SQRT2 = 1.414213562373095;
  int j = 0;
  for (j = 0; j < 2; j++) {
    dp1[j] = points[ind(nextP1I, j)] - points[ind(p1I, j)];
  }
  if ((dp1[0] == 0) || (dp1[1] == 0)) {
    for (j = 0; j < 2; j++)
      p1[j] = de1 * getSign(dp1[j]) + points[ind(p1I, j)];
  } else {
    if ((fabs(dp1[0]) == 1) && (fabs(dp1[1]) == 1)) {
      for (j = 0; j < 2; j++)
        p1[j] = points[ind(p1I, j)] + (dp1[j] * de1 / SQRT2);
    } else {
      double r;
      r = (dp1[1] / dp1[0]);
      double dy1 = de1 / sqrt(1 + r * r);
      r = (dp1[0] / dp1[1]);
      double dx1 = de1 / sqrt(1 + r * r);
      p1[0] = dy1 * getSign(dp1[0]) + points[ind(p1I, 0)];
      p1[1] = dx1 * getSign(dp1[1]) + points[ind(p1I, 1)];
    }
  }
}


x86 assembly (clang, -O0):
<computeFractionalPixel>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movsd  0xe97(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x4c(%rbp)
cmpl   $0x2,-0x4c(%rbp)
jge    11e6 <computeFractionalPixel+0xa6>
mov    -0x8(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x1c(%rbp),%edi
mov    -0x4c(%rbp),%esi
call   1050 <ind@plt>
mov    %rax,%rcx
mov    -0x80(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%edi
mov    -0x4c(%rbp),%esi
call   1050 <ind@plt>
movsd  -0x78(%rbp),%xmm0
mov    %rax,%rcx
mov    -0x70(%rbp),%rax
subsd  (%rax,%rcx,8),%xmm0
movslq -0x4c(%rbp),%rax
movsd  %xmm0,-0x40(%rbp,%rax,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    117c <computeFractionalPixel+0x3c>
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1203 <computeFractionalPixel+0xc3>
jp     1203 <computeFractionalPixel+0xc3>
jmp    121b <computeFractionalPixel+0xdb>
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12ad <computeFractionalPixel+0x16d>
jp     12ad <computeFractionalPixel+0x16d>
movl   $0x0,-0x4c(%rbp)
cmpl   $0x2,-0x4c(%rbp)
jge    12a8 <computeFractionalPixel+0x168>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x40(%rbp,%rax,8),%xmm0
call   1030 <getSign@plt>
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x20(%rbp),%edi
mov    -0x4c(%rbp),%esi
call   1050 <ind@plt>
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0x88(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1222 <computeFractionalPixel+0xe2>
jmp    14bd <computeFractionalPixel+0x37d>
movsd  -0x40(%rbp),%xmm0
call   1040 <fabs@plt>
cmp    $0x1,%eax
jne    1348 <computeFractionalPixel+0x208>
movsd  -0x38(%rbp),%xmm0
call   1040 <fabs@plt>
cmp    $0x1,%eax
jne    1348 <computeFractionalPixel+0x208>
movl   $0x0,-0x4c(%rbp)
cmpl   $0x2,-0x4c(%rbp)
jge    1343 <computeFractionalPixel+0x203>
mov    -0x8(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x20(%rbp),%edi
mov    -0x4c(%rbp),%esi
call   1050 <ind@plt>
mov    %rax,%rcx
mov    -0xa0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movslq -0x4c(%rbp),%rax
movsd  -0x40(%rbp,%rax,8),%xmm1
mulsd  -0x18(%rbp),%xmm1
movsd  0xce0(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12da <computeFractionalPixel+0x19a>
jmp    14b8 <computeFractionalPixel+0x378>
movsd  -0x38(%rbp),%xmm0
divsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc8e(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x40(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc3b(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
call   1030 <getSign@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x20(%rbp),%edi
xor    %esi,%esi
call   1050 <ind@plt>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0xc0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
call   1030 <getSign@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x20(%rbp),%edi
mov    $0x1,%esi
call   1050 <ind@plt>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
mov    %rax,%rcx
mov    -0xa8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    14bd <computeFractionalPixel+0x37d>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeFractionalPixel>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x28,%rsp
mov    %r8,%r14
mov    %ecx,%r15d
mov    %edx,%ebp
movsd  %xmm0,0x18(%rsp)
mov    %rdi,%rbx
mov    %edx,%edi
xor    %esi,%esi
call   1050 <ind@plt>
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %r15d,%edi
xor    %esi,%esi
call   1050 <ind@plt>
movsd  0x10(%rsp),%xmm0
subsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %ebp,%edi
mov    $0x1,%esi
call   1050 <ind@plt>
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r15d,%edi
mov    $0x1,%esi
call   1050 <ind@plt>
movsd  0x10(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
subsd  (%rbx,%rax,8),%xmm1
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
movsd  %xmm1,0x8(%rsp)
jne    11d1 <computeFractionalPixel+0x91>
jnp    1245 <computeFractionalPixel+0x105>
ucomisd %xmm2,%xmm1
jne    11d9 <computeFractionalPixel+0x99>
jnp    1245 <computeFractionalPixel+0x105>
call   1040 <fabs@plt>
cmp    $0x1,%eax
jne    126b <computeFractionalPixel+0x12b>
movsd  0x8(%rsp),%xmm0
call   1040 <fabs@plt>
cmp    $0x1,%eax
jne    126b <computeFractionalPixel+0x12b>
mov    %r15d,%edi
xor    %esi,%esi
call   1050 <ind@plt>
movsd  0x10(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
divsd  0xdf3(%rip),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r14)
mov    %r15d,%edi
mov    $0x1,%esi
call   1050 <ind@plt>
movsd  0x8(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
divsd  0xdc8(%rip),%xmm0
jmp    1328 <computeFractionalPixel+0x1e8>
call   1030 <getSign@plt>
movsd  %xmm0,0x10(%rsp)
mov    %r15d,%edi
xor    %esi,%esi
call   1050 <ind@plt>
movsd  0x10(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
jmp    12f4 <computeFractionalPixel+0x1b4>
movsd  0x8(%rsp),%xmm0
divsd  0x10(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  0xd7d(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sqrt@plt>
movsd  0x18(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
movsd  0x10(%rsp),%xmm0
divsd  0x8(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  0xd4c(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1060 <sqrt@plt>
movsd  0x18(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0x10(%rsp),%xmm0
call   1030 <getSign@plt>
movsd  %xmm0,0x10(%rsp)
mov    %r15d,%edi
xor    %esi,%esi
call   1050 <ind@plt>
movsd  0x10(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r14)
movsd  0x8(%rsp),%xmm0
call   1030 <getSign@plt>
movsd  %xmm0,0x8(%rsp)
mov    %r15d,%edi
mov    $0x1,%esi
call   1050 <ind@plt>
movsd  0x8(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14)
add    $0x28,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @computeFractionalPixel(double* nocapture %0, i32 %1, double %2, i32 %3, i32 %4, double* nocapture writeonly %5) {
%7 = tail call i64 @ind(i32 %3, i32 0)
%8 = getelementptr inbounds double, double* %0, i64 %7
%9 = load double, double* %8
%10 = tail call i64 @ind(i32 %4, i32 0)
%11 = getelementptr inbounds double, double* %0, i64 %10
%12 = load double, double* %11
%13 = fsub double %9, %12
%14 = tail call i64 @ind(i32 %3, i32 1)
%15 = getelementptr inbounds double, double* %0, i64 %14
%16 = load double, double* %15
%17 = tail call i64 @ind(i32 %4, i32 1)
%18 = getelementptr inbounds double, double* %0, i64 %17
%19 = load double, double* %18
%20 = fsub double %16, %19
%21 = fcmp oeq double %13, 0.000000e+00
%22 = fcmp oeq double %20, 0.000000e+00
%23 = select i1 %21, i1 true, i1 %22
br i1 %23, label %24, label %35
24: ; preds = %6
%25 = tail call double @getSign(double %13)
%26 = tail call i64 @ind(i32 %4, i32 0)
%27 = getelementptr inbounds double, double* %0, i64 %26
%28 = load double, double* %27
%29 = tail call double @llvm.fmuladd.f64(double %2, double %25, double %28)
store double %29, double* %5
%30 = tail call double @getSign(double %20)
%31 = tail call i64 @ind(i32 %4, i32 1)
%32 = getelementptr inbounds double, double* %0, i64 %31
%33 = load double, double* %32
%34 = tail call double @llvm.fmuladd.f64(double %2, double %30, double %33)
br label %75
35: ; preds = %6
%36 = tail call i32 @fabs(double %13)
%37 = icmp eq i32 %36, 1
br i1 %37, label %38, label %54
38: ; preds = %35
%39 = tail call i32 @fabs(double %20)
%40 = icmp eq i32 %39, 1
br i1 %40, label %41, label %54
41: ; preds = %38
%42 = tail call i64 @ind(i32 %4, i32 0)
%43 = getelementptr inbounds double, double* %0, i64 %42
%44 = load double, double* %43
%45 = fmul double %13, %2
%46 = fdiv double %45, 0x3FF6A09E667F3BCC
%47 = fadd double %44, %46
store double %47, double* %5
%48 = tail call i64 @ind(i32 %4, i32 1)
%49 = getelementptr inbounds double, double* %0, i64 %48
%50 = load double, double* %49
%51 = fmul double %20, %2
%52 = fdiv double %51, 0x3FF6A09E667F3BCC
%53 = fadd double %50, %52
br label %75
54: ; preds = %38, %35
%55 = fdiv double %20, %13
%56 = tail call double @llvm.fmuladd.f64(double %55, double %55, double 1.000000e+00)
%57 = fptosi double %56 to i32
%58 = tail call double @sqrt(i32 %57)
%59 = fdiv double %2, %58
%60 = fdiv double %13, %20
%61 = tail call double @llvm.fmuladd.f64(double %60, double %60, double 1.000000e+00)
%62 = fptosi double %61 to i32
%63 = tail call double @sqrt(i32 %62)
%64 = fdiv double %2, %63
%65 = tail call double @getSign(double %13)
%66 = tail call i64 @ind(i32 %4, i32 0)
%67 = getelementptr inbounds double, double* %0, i64 %66
%68 = load double, double* %67
%69 = tail call double @llvm.fmuladd.f64(double %59, double %65, double %68)
store double %69, double* %5
%70 = tail call double @getSign(double %20)
%71 = tail call i64 @ind(i32 %4, i32 1)
%72 = getelementptr inbounds double, double* %0, i64 %71
%73 = load double, double* %72
%74 = tail call double @llvm.fmuladd.f64(double %64, double %70, double %73)
br label %75
75: ; preds = %41, %24, %54
%76 = phi double [ %53, %41 ], [ %34, %24 ], [ %74, %54 ]
%77 = getelementptr inbounds double, double* %5, i64 1
store double %76, double* %77
ret void
}