#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 /*<<< orphan*/ memcpy(double *, double const *, int const);
int /*<<< orphan*/ memset(double *, int /*<<< orphan*/, int const);
double sqrt(double);
void disRotatingPulseVelEvaluate(const int nPoints, const int nSpace,
                                 const double self_a, const double *x,
                                 const double *u, double *m, double *dm,
                                 double *f, double *df, double *a, double *da,
                                 double *phi, double *dphi) {
  double X, Y, vx, vy;
  int k, I;
  const int nSpace2 = nSpace * nSpace;
  memcpy(m, u, nPoints * sizeof(double));
  memcpy(phi, u, nPoints * sizeof(double));
  memset(da, 0, nPoints * nSpace2 * sizeof(double));
  for (k = 0; k < nPoints; k++) {
    dm[k] = dphi[k] = 1.0;
    X = x[k * 3 + 1] - 0.5;
    Y = x[k * 3] - 0.5;
    vx = -4.0 * X;
    vy = 4.0 * Y;
    f[k * nSpace] = vx * u[k];
    f[k * nSpace + 1] = vy * u[k];
    df[k * nSpace] = vx;
    df[k * nSpace + 1] = vy;
    if (sqrt(X * X + Y * Y) < 0.25) {
      f[k * nSpace] *= 0.001;
      f[k * nSpace + 1] *= 0.001;
      df[k * nSpace] *= 0.001;
      df[k * nSpace + 1] *= 0.001;
    }
    for (I = 0; I < nSpace; I++) {
      a[k * nSpace2 + I * nSpace + I] = self_a;
    }
  }
}


x86 assembly (clang, -O0):
<disRotatingPulseVelEvaluate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x20(%rbp),%rsi
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1040 <memcpy@plt>
mov    0x30(%rbp),%rdi
mov    -0x20(%rbp),%rsi
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1040 <memcpy@plt>
mov    0x28(%rbp),%rdi
mov    -0x4(%rbp),%eax
imul   -0x5c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13f7 <disRotatingPulseVelEvaluate+0x2c7>
mov    0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0xe40(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  0xe2b(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
imul   $0x3,-0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xe03(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
imul   $0x3,-0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xde2(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xdc9(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xdaf(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x38(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xcf1(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    139f <disRotatingPulseVelEvaluate+0x26f>
mov    0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xcf9(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xcd6(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x8(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xcb6(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xc93(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13e4 <disRotatingPulseVelEvaluate+0x2b4>
movsd  -0x10(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x5c(%rbp),%ecx
mov    -0x58(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    13a6 <disRotatingPulseVelEvaluate+0x276>
jmp    13e9 <disRotatingPulseVelEvaluate+0x2b9>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11c4 <disRotatingPulseVelEvaluate+0x94>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<disRotatingPulseVelEvaluate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,0x50(%rsp)
mov    %rcx,%r15
mov    %rdx,0x40(%rsp)
movsd  %xmm0,0x10(%rsp)
mov    %esi,%r14d
mov    %edi,%r12d
mov    0xa8(%rsp),%r13
mov    %esi,%ebx
imul   %esi,%ebx
lea    0x0(,%r12,8),%ebp
mov    %r8,%rdi
mov    %rcx,%rsi
mov    %ebp,%edx
call   1040 <memcpy@plt>
mov    0xb0(%rsp),%rdi
mov    %r15,0x48(%rsp)
mov    %r15,%rsi
mov    %ebp,%edx
call   1040 <memcpy@plt>
imul   %ebx,%ebp
mov    %r13,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1030 <memset@plt>
xor    %edi,%edi
movsd  0x10(%rsp),%xmm3
test   %r12d,%r12d
jle    13d9 <disRotatingPulseVelEvaluate+0x2a9>
mov    %ebx,%r8d
mov    %r14,%r10
mov    0xb8(%rsp),%r9
mov    0xa0(%rsp),%rbp
mov    0x98(%rsp),%rsi
mov    0x90(%rsp),%r11
movslq %r10d,%rax
mov    %rax,0x38(%rsp)
mov    %r12d,%eax
mov    %rax,0x30(%rsp)
mov    %r10d,%r13d
mov    %r13,0x20(%rsp)
and    $0xfffffffe,%r13d
lea    0x1(%r14),%r15d
lea    (%r14,%r14,1),%r12d
add    $0x2,%r12d
movapd 0xdfa(%rip),%xmm4
movapd 0xe02(%rip),%xmm5
xorpd  %xmm6,%xmm6
movsd  0xe16(%rip),%xmm7
xor    %r14d,%r14d
mov    %r10,0x18(%rsp)
mov    %ebx,0xc(%rsp)
jmp    1242 <disRotatingPulseVelEvaluate+0x112>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
add    %r8d,%edi
cmp    0x30(%rsp),%r14
je     13d9 <disRotatingPulseVelEvaluate+0x2a9>
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%r9,%r14,8)
mov    0x50(%rsp),%rax
mov    %rcx,(%rax,%r14,8)
lea    (%r14,%r14,2),%rax
mov    0x40(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
addpd  %xmm4,%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm5,%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
mov    0x48(%rsp),%rax
mulsd  (%rax,%r14,8),%xmm2
mov    %r14,%rbx
imul   0x38(%rsp),%rbx
movsd  %xmm2,(%r11,%rbx,8)
movsd  (%rax,%r14,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%r11,%rbx,8)
shufpd $0x1,%xmm1,%xmm1
movupd %xmm1,(%rsi,%rbx,8)
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm6,%xmm0
jb     12e0 <disRotatingPulseVelEvaluate+0x1b0>
sqrtsd %xmm0,%xmm0
ucomisd %xmm0,%xmm7
ja     1339 <disRotatingPulseVelEvaluate+0x209>
jmp    135f <disRotatingPulseVelEvaluate+0x22f>
nopl   0x0(%rax)
mov    %rdi,0x28(%rsp)
call   1050 <sqrt@plt>
movsd  0xd3e(%rip),%xmm7
xorpd  %xmm6,%xmm6
movapd 0xd12(%rip),%xmm5
movapd 0xcfa(%rip),%xmm4
mov    0x90(%rsp),%r11
mov    0x98(%rsp),%rsi
mov    0xb8(%rsp),%r9
mov    0x28(%rsp),%rdi
mov    0xc(%rsp),%r8d
mov    0x18(%rsp),%r10
movsd  0x10(%rsp),%xmm3
ucomisd %xmm0,%xmm7
jbe    135f <disRotatingPulseVelEvaluate+0x22f>
movupd (%r11,%rbx,8),%xmm0
movapd 0xcd9(%rip),%xmm1
mulpd  %xmm1,%xmm0
movupd %xmm0,(%r11,%rbx,8)
movupd (%rsi,%rbx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm0,(%rsi,%rbx,8)
test   %r10d,%r10d
jle    1230 <disRotatingPulseVelEvaluate+0x100>
cmp    $0x1,%r10d
jne    1380 <disRotatingPulseVelEvaluate+0x250>
xor    %eax,%eax
jmp    13b2 <disRotatingPulseVelEvaluate+0x282>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %edi,%ecx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %ecx,%rcx
movsd  %xmm3,0x0(%rbp,%rcx,8)
lea    (%r15,%rcx,1),%edx
movslq %edx,%rdx
movsd  %xmm3,0x0(%rbp,%rdx,8)
add    $0x2,%rax
add    %r12d,%ecx
cmp    %rax,%r13
jne    1390 <disRotatingPulseVelEvaluate+0x260>
testb  $0x1,0x20(%rsp)
je     1230 <disRotatingPulseVelEvaluate+0x100>
mov    %r8d,%ecx
imul   %r14d,%ecx
add    %eax,%ecx
imul   %r10d,%eax
add    %ecx,%eax
cltq
movsd  %xmm3,0x0(%rbp,%rax,8)
jmp    1230 <disRotatingPulseVelEvaluate+0x100>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @disRotatingPulseVelEvaluate(i32 %0, i32 %1, double %2, double* nocapture %3, double* %4, double* %5, double* nocapture writeonly %6, double* nocapture %7, double* nocapture %8, double* nocapture writeonly %9, double* %10, double* %11, double* nocapture writeonly %12) {
%14 = mul nsw i32 %1, %1
%15 = shl i32 %0, 3
%16 = tail call i32 @memcpy(double* %5, double* %4, i32 %15)
%17 = tail call i32 @memcpy(double* %11, double* %4, i32 %15)
%18 = mul i32 %15, %14
%19 = tail call i32 @memset(double* %10, i32 0, i32 %18)
%20 = icmp sgt i32 %0, 0
br i1 %20, label %21, label %107
21: ; preds = %13
%22 = icmp sgt i32 %1, 0
%23 = sext i32 %1 to i64
%24 = zext i32 %0 to i64
%25 = zext i32 %1 to i64
%26 = and i64 %25, 1
%27 = icmp eq i32 %1, 1
%28 = and i64 %25, 4294967294
%29 = icmp eq i64 %26, 0
br label %30
30: ; preds = %21, %104
%31 = phi i64 [ 0, %21 ], [ %105, %104 ]
%32 = getelementptr inbounds double, double* %12, i64 %31
store double 1.000000e+00, double* %32
%33 = getelementptr inbounds double, double* %6, i64 %31
store double 1.000000e+00, double* %33
%34 = mul nuw nsw i64 %31, 3
%35 = getelementptr inbounds double, double* %3, i64 %34
%36 = bitcast double* %35 to <2 x double>*
%37 = load <2 x double>, <2 x double>* %36
%38 = fadd <2 x double> %37, <double -5.000000e-01, double -5.000000e-01>
%39 = fmul <2 x double> %38, <double 4.000000e+00, double -4.000000e+00>
%40 = getelementptr inbounds double, double* %4, i64 %31
%41 = load double, double* %40
%42 = extractelement <2 x double> %39, i64 1
%43 = fmul double %42, %41
%44 = mul nsw i64 %31, %23
%45 = getelementptr inbounds double, double* %7, i64 %44
store double %43, double* %45
%46 = load double, double* %40
%47 = extractelement <2 x double> %39, i64 0
%48 = fmul double %47, %46
%49 = add nsw i64 %44, 1
%50 = getelementptr inbounds double, double* %7, i64 %49
store double %48, double* %50
%51 = getelementptr inbounds double, double* %8, i64 %44
%52 = shufflevector <2 x double> %39, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%53 = bitcast double* %51 to <2 x double>*
store <2 x double> %52, <2 x double>* %53
%54 = fmul <2 x double> %38, %38
%55 = extractelement <2 x double> %54, i64 0
%56 = extractelement <2 x double> %38, i64 1
%57 = tail call double @llvm.fmuladd.f64(double %56, double %56, double %55)
%58 = tail call double @sqrt(double %57)
%59 = fcmp olt double %58, 2.500000e-01
br i1 %59, label %60, label %69
60: ; preds = %30
%61 = bitcast double* %45 to <2 x double>*
%62 = load <2 x double>, <2 x double>* %61
%63 = fmul <2 x double> %62, <double 1.000000e-03, double 1.000000e-03>
%64 = bitcast double* %45 to <2 x double>*
store <2 x double> %63, <2 x double>* %64
%65 = bitcast double* %51 to <2 x double>*
%66 = load <2 x double>, <2 x double>* %65
%67 = fmul <2 x double> %66, <double 1.000000e-03, double 1.000000e-03>
%68 = bitcast double* %51 to <2 x double>*
store <2 x double> %67, <2 x double>* %68
br label %69
69: ; preds = %60, %30
br i1 %22, label %70, label %104
70: ; preds = %69
%71 = trunc i64 %31 to i32
%72 = mul i32 %14, %71
br i1 %27, label %94, label %73
73: ; preds = %70, %73
%74 = phi i64 [ %91, %73 ], [ 0, %70 ]
%75 = phi i64 [ %92, %73 ], [ 0, %70 ]
%76 = trunc i64 %74 to i32
%77 = mul nsw i32 %76, %1
%78 = trunc i64 %74 to i32
%79 = add i32 %72, %78
%80 = add i32 %79, %77
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %9, i64 %81
store double %2, double* %82
%83 = or i64 %74, 1
%84 = trunc i64 %83 to i32
%85 = mul nsw i32 %84, %1
%86 = trunc i64 %83 to i32
%87 = add i32 %72, %86
%88 = add i32 %87, %85
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %9, i64 %89
store double %2, double* %90
%91 = add nuw nsw i64 %74, 2
%92 = add i64 %75, 2
%93 = icmp eq i64 %92, %28
br i1 %93, label %94, label %73
94: ; preds = %73, %70
%95 = phi i64 [ 0, %70 ], [ %91, %73 ]
br i1 %29, label %104, label %96
96: ; preds = %94
%97 = trunc i64 %95 to i32
%98 = mul nsw i32 %97, %1
%99 = trunc i64 %95 to i32
%100 = add i32 %72, %99
%101 = add i32 %100, %98
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %9, i64 %102
store double %2, double* %103
br label %104
104: ; preds = %96, %94, %69
%105 = add nuw nsw i64 %31, 1
%106 = icmp eq i64 %105, %24
br i1 %106, label %107, label %30
107: ; preds = %104, %13
ret void
}