#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 pow(double, double);
void grid_log(double x[], double xa, double xb, int ia, int ib, int n) {
  double fac = pow(xb / xa, 1.0 / (ib - ia));
  int i;
  x[ia] = xa;
  for (i = ia - 1; i >= 0; i--)
    x[i] = x[i + 1] / fac;
  for (i = ia + 1; i < ib; i++)
    x[i] = x[i - 1] * fac;
  x[ib] = xb;
  for (i = ib + 1; i <= n; i++)
    x[i] = x[i - 1] * fac;
}


x86 assembly (clang, -O0):
<grid_log>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
mov    %esi,-0x1c(%rbp)
mov    %edx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
divsd  -0x10(%rbp),%xmm0
mov    -0x20(%rbp),%eax
sub    -0x1c(%rbp),%eax
cvtsi2sd %eax,%xmm2
movsd  0xeb5(%rip),%xmm1
divsd  %xmm2,%xmm1
call   1030 <pow@plt>
movsd  %xmm0,-0x30(%rbp)
movsd  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     11b0 <grid_log+0xa0>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1174 <grid_log+0x64>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11f7 <grid_log+0xe7>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11b9 <grid_log+0xa9>
movsd  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1250 <grid_log+0x140>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1212 <grid_log+0x102>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<grid_log>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,%r14d
mov    %edx,%r15d
mov    %esi,%r12d
movapd %xmm0,%xmm2
movsd  %xmm0,0x8(%rsp)
mov    %rdi,%rbx
movsd  %xmm1,0x10(%rsp)
movapd %xmm1,%xmm0
divsd  %xmm2,%xmm0
mov    %edx,%r13d
sub    %esi,%r13d
xorps  %xmm2,%xmm2
cvtsi2sd %r13d,%xmm2
movsd  0xea8(%rip),%xmm1
divsd  %xmm2,%xmm1
call   1030 <pow@plt>
movslq %r12d,%r9
movsd  0x8(%rsp),%xmm1
movsd  %xmm1,(%rbx,%r9,8)
test   %r9d,%r9d
jle    11ac <grid_log+0x9c>
mov    %r12d,%edi
cmp    $0x1,%r12d
jne    1336 <grid_log+0x226>
add    $0x1,%rdi
cs nopw 0x0(%rax,%rax,1)
lea    -0x2(%rdi),%eax
movsd  -0x8(%rbx,%rdi,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0xffffffffffffffff,%rdi
cmp    $0x1,%rdi
ja     1190 <grid_log+0x80>
lea    0x1(%r12),%eax
cmp    %r15d,%eax
jge    1522 <grid_log+0x412>
movslq %eax,%r10
lea    -0x2(%r15),%eax
mov    %eax,%r11d
sub    %r12d,%r11d
cmp    $0x3,%r11d
jb     12e0 <grid_log+0x1d0>
cmp    %r12d,%eax
jl     12e0 <grid_log+0x1d0>
lea    (%rbx,%r10,8),%rax
add    $0xfffffffe,%r13d
lea    (%r9,%r13,1),%rcx
lea    (%rbx,%rcx,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%rax
jae    120b <grid_log+0xfb>
add    %r10,%r13
lea    (%rbx,%r13,8),%rax
add    $0x8,%rax
lea    (%rbx,%r9,8),%rcx
cmp    %rax,%rcx
jb     12e0 <grid_log+0x1d0>
add    $0x1,%r11
mov    %r11,%r8
and    $0xfffffffffffffffc,%r8
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r8),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     15b0 <grid_log+0x4a0>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rbx,%r10,8),%rdx
add    $0x30,%rdx
lea    0x4(%r12),%eax
mov    %r12d,%ecx
xor    %edi,%edi
nop
lea    (%rcx,%rdi,1),%ebp
movslq %ebp,%rbp
movupd (%rbx,%rbp,8),%xmm2
movupd 0x10(%rbx,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rdx,%rdi,8)
movupd %xmm3,-0x20(%rdx,%rdi,8)
lea    (%rax,%rdi,1),%ebp
movslq %ebp,%rbp
movupd (%rbx,%rbp,8),%xmm2
movupd 0x10(%rbx,%rbp,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rdx,%rdi,8)
movupd %xmm3,(%rdx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1250 <grid_log+0x140>
test   $0x1,%r9b
je     12d1 <grid_log+0x1c1>
lea    (%rdi,%r10,1),%rax
add    %r12d,%edi
movslq %edi,%rcx
movupd (%rbx,%rcx,8),%xmm2
movupd 0x10(%rbx,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rbx,%rax,8)
movupd %xmm3,0x10(%rbx,%rax,8)
cmp    %r8,%r11
je     1522 <grid_log+0x412>
add    %r8,%r10
add    %r8d,%r12d
mov    %r15d,%eax
sub    %r10d,%eax
mov    %r10d,%edx
not    %edx
add    %r15d,%edx
and    $0x3,%eax
je     1477 <grid_log+0x367>
neg    %eax
xor    %esi,%esi
mov    %r10,%rcx
xchg   %ax,%ax
movslq %r12d,%rdi
movsd  (%rbx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
mov    %ecx,%r12d
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
cmp    %esi,%eax
jne    1300 <grid_log+0x1f0>
not    %esi
add    %r10d,%esi
mov    %esi,%r12d
cmp    $0x3,%edx
jae    1483 <grid_log+0x373>
jmp    1522 <grid_log+0x412>
lea    -0x1(%rdi),%r8
lea    -0x1(%r12),%esi
mov    $0x8,%edx
mov    %r8,%rax
mul    %rdx
seto   %dl
cmp    %r8d,%esi
jb     1182 <grid_log+0x72>
mov    %r8,%rcx
shr    $0x20,%rcx
jne    1182 <grid_log+0x72>
lea    (%rbx,%rsi,8),%rbp
mov    %rbp,%rcx
sub    %rax,%rcx
cmp    %rbp,%rcx
ja     1182 <grid_log+0x72>
test   %dl,%dl
jne    1182 <grid_log+0x72>
lea    (%rbx,%rdi,8),%rbp
mov    %rbp,%rcx
sub    %rax,%rcx
cmp    %rbp,%rcx
ja     1182 <grid_log+0x72>
test   %dl,%dl
jne    1182 <grid_log+0x72>
lea    0x1(%rsi),%rax
sub    %rdi,%rax
lea    (%rbx,%rax,8),%rax
lea    (%rbx,%rdi,8),%rcx
add    $0x8,%rcx
cmp    %rcx,%rax
jae    13c6 <grid_log+0x2b6>
lea    (%rbx,%rsi,8),%rax
add    $0x8,%rax
lea    0x8(%rbx),%rcx
cmp    %rax,%rcx
jb     1182 <grid_log+0x72>
mov    $0xffffffff,%edx
mov    %edi,%r10d
and    $0xfffffffe,%r10d
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%r10),%rax
mov    %rax,%r11
shr    %r11
add    $0x1,%r11
shufpd $0x1,%xmm1,%xmm1
test   %rax,%rax
je     15c1 <grid_log+0x4b1>
mov    %r11,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rbx,%r8,8),%rax
lea    (%rdi,%rdx,1),%r8
add    $0xfffffffffffffffe,%r8
lea    (%rdi,%rdx,1),%rbp
xor    %ecx,%ecx
nop
lea    (%rcx,%rbp,1),%edx
movupd (%rax,%rcx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,-0x8(%rbx,%rdx,8)
lea    (%r8,%rcx,1),%edx
movupd -0x10(%rax,%rcx,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,-0x8(%rbx,%rdx,8)
add    $0xfffffffffffffffc,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1410 <grid_log+0x300>
neg    %rcx
mov    $0xffffffff,%edx
test   $0x1,%r11b
je     1466 <grid_log+0x356>
mov    %rdi,%rax
sub    %rcx,%rax
add    %eax,%edx
movupd -0x8(%rbx,%rax,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,-0x8(%rbx,%rdx,8)
cmp    %rdi,%r10
je     11ac <grid_log+0x9c>
and    $0x1,%edi
jmp    1182 <grid_log+0x72>
mov    %r10,%rcx
cmp    $0x3,%edx
jb     1522 <grid_log+0x412>
movabs $0x1fffffffc,%r8
mov    $0xffffffff,%r9d
mov    %r15d,%esi
mov    %rcx,%rdx
shl    $0x20,%rdx
movabs $0x400000000,%rax
nopw   0x0(%rax,%rax,1)
movslq %r12d,%rbp
movsd  (%rbx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
mov    %rdx,%rdi
sar    $0x1d,%rdi
movsd  (%rbx,%rdi,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
lea    (%r9,%rdx,1),%rdi
add    $0x1,%rdi
sar    $0x1d,%rdi
movsd  (%rbx,%rdi,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rbx,%rcx,8)
lea    (%r8,%rdx,1),%rdi
add    $0x4,%rdi
sar    $0x1d,%rdi
movsd  (%rbx,%rdi,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rbx,%rcx,8)
mov    %ecx,%r12d
lea    0x4(%rcx),%rdi
add    $0x3,%r12d
add    %rax,%rdx
mov    %rdi,%rcx
cmp    %edi,%esi
jne    14b0 <grid_log+0x3a0>
movslq %r15d,%rax
movsd  0x10(%rsp),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
cmp    %r14d,%r15d
jge    15a1 <grid_log+0x491>
movslq %r14d,%rcx
sub    %r15d,%r14d
mov    %rax,%rdx
not    %rdx
add    %rcx,%rdx
and    $0x3,%r14
je     1564 <grid_log+0x454>
nopw   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%r14
jne    1550 <grid_log+0x440>
cmp    $0x3,%rdx
jb     15a1 <grid_log+0x491>
nopw   0x0(%rax,%rax,1)
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rbx,%rax,8)
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rbx,%rax,8)
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1570 <grid_log+0x460>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
test   $0x1,%r9b
jne    12a9 <grid_log+0x199>
jmp    12d1 <grid_log+0x1c1>
xor    %ecx,%ecx
test   $0x1,%r11b
jne    144e <grid_log+0x33e>
jmp    1466 <grid_log+0x356>

LLVM IR (-O0):
define void @grid_log(double* %0, double %1, double %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca double*
%8 = alloca double
%9 = alloca double
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca double
%14 = alloca i32
store double* %0, double** %7
store double %1, double* %8
store double %2, double* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%15 = load double, double* %9
%16 = load double, double* %8
%17 = fdiv double %15, %16
%18 = load i32, i32* %11
%19 = load i32, i32* %10
%20 = sub nsw i32 %18, %19
%21 = sitofp i32 %20 to double
%22 = fdiv double 1.000000e+00, %21
%23 = call double @pow(double %17, double %22)
store double %23, double* %13
%24 = load double, double* %8
%25 = load double*, double** %7
%26 = load i32, i32* %10
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds double, double* %25, i64 %27
store double %24, double* %28
%29 = load i32, i32* %10
%30 = sub nsw i32 %29, 1
store i32 %30, i32* %14
br label %31
31: ; preds = %47, %6
%32 = load i32, i32* %14
%33 = icmp sge i32 %32, 0
br i1 %33, label %34, label %50
34: ; preds = %31
%35 = load double*, double** %7
%36 = load i32, i32* %14
%37 = add nsw i32 %36, 1
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds double, double* %35, i64 %38
%40 = load double, double* %39
%41 = load double, double* %13
%42 = fdiv double %40, %41
%43 = load double*, double** %7
%44 = load i32, i32* %14
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double, double* %43, i64 %45
store double %42, double* %46
br label %47
47: ; preds = %34
%48 = load i32, i32* %14
%49 = add nsw i32 %48, -1
store i32 %49, i32* %14
br label %31
50: ; preds = %31
%51 = load i32, i32* %10
%52 = add nsw i32 %51, 1
store i32 %52, i32* %14
br label %53
53: ; preds = %70, %50
%54 = load i32, i32* %14
%55 = load i32, i32* %11
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %73
57: ; preds = %53
%58 = load double*, double** %7
%59 = load i32, i32* %14
%60 = sub nsw i32 %59, 1
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %58, i64 %61
%63 = load double, double* %62
%64 = load double, double* %13
%65 = fmul double %63, %64
%66 = load double*, double** %7
%67 = load i32, i32* %14
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %66, i64 %68
store double %65, double* %69
br label %70
70: ; preds = %57
%71 = load i32, i32* %14
%72 = add nsw i32 %71, 1
store i32 %72, i32* %14
br label %53
73: ; preds = %53
%74 = load double, double* %9
%75 = load double*, double** %7
%76 = load i32, i32* %11
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %75, i64 %77
store double %74, double* %78
%79 = load i32, i32* %11
%80 = add nsw i32 %79, 1
store i32 %80, i32* %14
br label %81
81: ; preds = %98, %73
%82 = load i32, i32* %14
%83 = load i32, i32* %12
%84 = icmp sle i32 %82, %83
br i1 %84, label %85, label %101
85: ; preds = %81
%86 = load double*, double** %7
%87 = load i32, i32* %14
%88 = sub nsw i32 %87, 1
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %86, i64 %89
%91 = load double, double* %90
%92 = load double, double* %13
%93 = fmul double %91, %92
%94 = load double*, double** %7
%95 = load i32, i32* %14
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double, double* %94, i64 %96
store double %93, double* %97
br label %98
98: ; preds = %85
%99 = load i32, i32* %14
%100 = add nsw i32 %99, 1
store i32 %100, i32* %14
br label %81
101: ; preds = %81
ret void
}

LLVM IR (-O2):
define void @grid_log(double* nocapture %0, double %1, double %2, i32 %3, i32 %4, i32 %5) {
%7 = fdiv double %2, %1
%8 = sub nsw i32 %4, %3
%9 = sitofp i32 %8 to double
%10 = fdiv double 1.000000e+00, %9
%11 = tail call double @pow(double %7, double %10)
%12 = sext i32 %3 to i64
%13 = getelementptr inbounds double, double* %0, i64 %12
store double %1, double* %13
%14 = icmp sgt i32 %3, 0
br i1 %14, label %15, label %126
15: ; preds = %6
%16 = zext i32 %3 to i64
%17 = icmp eq i32 %3, 1
br i1 %17, label %124, label %18
18: ; preds = %15
%19 = add nsw i64 %16, -1
%20 = add i32 %3, -1
%21 = trunc i64 %19 to i32
%22 = icmp ult i32 %20, %21
%23 = icmp ugt i64 %19, 4294967295
%24 = or i1 %22, %23
%25 = zext i32 %20 to i64
%26 = getelementptr double, double* %0, i64 %25
%27 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %19, i64 8)
%28 = extractvalue { i64, i1 } %27, 0
%29 = extractvalue { i64, i1 } %27, 1
%30 = bitcast double* %26 to i8*
%31 = sub i64 0, %28
%32 = getelementptr i8, i8* %30, i64 %31
%33 = icmp ugt i8* %32, %30
%34 = or i1 %33, %29
%35 = getelementptr double, double* %0, i64 %16
%36 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %19, i64 8)
%37 = extractvalue { i64, i1 } %36, 0
%38 = extractvalue { i64, i1 } %36, 1
%39 = bitcast double* %35 to i8*
%40 = sub i64 0, %37
%41 = getelementptr i8, i8* %39, i64 %40
%42 = icmp ugt i8* %41, %39
%43 = or i1 %42, %38
%44 = or i1 %24, %34
%45 = or i1 %44, %43
br i1 %45, label %124, label %46
46: ; preds = %18
%47 = add i32 %3, -1
%48 = zext i32 %47 to i64
%49 = add nuw nsw i64 %48, 1
%50 = sub nsw i64 %49, %16
%51 = getelementptr double, double* %0, i64 %50
%52 = add nuw nsw i64 %48, 1
%53 = getelementptr double, double* %0, i64 %52
%54 = getelementptr double, double* %0, i64 1
%55 = add nuw nsw i64 %16, 1
%56 = getelementptr double, double* %0, i64 %55
%57 = icmp ult double* %51, %56
%58 = icmp ult double* %54, %53
%59 = and i1 %57, %58
br i1 %59, label %124, label %60
60: ; preds = %46
%61 = and i64 %16, 4294967294
%62 = and i64 %16, 1
%63 = insertelement <2 x double> poison, double %11, i64 0
%64 = shufflevector <2 x double> %63, <2 x double> poison, <2 x i32> zeroinitializer
%65 = add nsw i64 %61, -2
%66 = lshr exact i64 %65, 1
%67 = add nuw i64 %66, 1
%68 = and i64 %67, 1
%69 = icmp eq i64 %65, 0
br i1 %69, label %105, label %70
70: ; preds = %60
%71 = and i64 %67, -2
%72 = getelementptr inbounds double, double* %0, i64 -1
%73 = getelementptr inbounds double, double* %0, i64 -1
%74 = getelementptr inbounds double, double* %0, i64 -1
%75 = getelementptr inbounds double, double* %0, i64 -1
br label %76
76: ; preds = %76, %70
%77 = phi i64 [ 0, %70 ], [ %102, %76 ]
%78 = phi i64 [ 0, %70 ], [ %103, %76 ]
%79 = sub i64 %16, %77
%80 = add i64 %79, 4294967295
%81 = getelementptr inbounds double, double* %72, i64 %79
%82 = bitcast double* %81 to <2 x double>*
%83 = load <2 x double>, <2 x double>* %82
%84 = shufflevector <2 x double> %83, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%85 = fdiv <2 x double> %84, %64
%86 = and i64 %80, 4294967295
%87 = shufflevector <2 x double> %85, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%88 = getelementptr inbounds double, double* %73, i64 %86
%89 = bitcast double* %88 to <2 x double>*
store <2 x double> %87, <2 x double>* %89
%90 = or i64 %77, 2
%91 = sub i64 %16, %90
%92 = add i64 %91, 4294967295
%93 = getelementptr inbounds double, double* %74, i64 %91
%94 = bitcast double* %93 to <2 x double>*
%95 = load <2 x double>, <2 x double>* %94
%96 = shufflevector <2 x double> %95, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%97 = fdiv <2 x double> %96, %64
%98 = and i64 %92, 4294967295
%99 = shufflevector <2 x double> %97, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%100 = getelementptr inbounds double, double* %75, i64 %98
%101 = bitcast double* %100 to <2 x double>*
store <2 x double> %99, <2 x double>* %101
%102 = add nuw i64 %77, 4
%103 = add nuw i64 %78, 2
%104 = icmp eq i64 %103, %71
br i1 %104, label %105, label %76
105: ; preds = %76, %60
%106 = phi i64 [ 0, %60 ], [ %102, %76 ]
%107 = icmp eq i64 %68, 0
br i1 %107, label %122, label %108
108: ; preds = %105
%109 = sub i64 %16, %106
%110 = add i64 %109, 4294967295
%111 = getelementptr inbounds double, double* %0, i64 -1
%112 = getelementptr inbounds double, double* %111, i64 %109
%113 = bitcast double* %112 to <2 x double>*
%114 = load <2 x double>, <2 x double>* %113
%115 = shufflevector <2 x double> %114, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%116 = fdiv <2 x double> %115, %64
%117 = and i64 %110, 4294967295
%118 = getelementptr inbounds double, double* %0, i64 -1
%119 = shufflevector <2 x double> %116, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%120 = getelementptr inbounds double, double* %118, i64 %117
%121 = bitcast double* %120 to <2 x double>*
store <2 x double> %119, <2 x double>* %121
br label %122
122: ; preds = %105, %108
%123 = icmp eq i64 %61, %16
br i1 %123, label %126, label %124
124: ; preds = %46, %18, %15, %122
%125 = phi i64 [ %16, %46 ], [ %16, %18 ], [ %16, %15 ], [ %62, %122 ]
br label %260
126: ; preds = %260, %122, %6
%127 = add i32 %3, 1
%128 = icmp slt i32 %127, %4
br i1 %128, label %129, label %302
129: ; preds = %126
%130 = sext i32 %127 to i64
%131 = add i32 %4, -2
%132 = sub i32 %131, %3
%133 = zext i32 %132 to i64
%134 = add nuw nsw i64 %133, 1
%135 = icmp ult i32 %132, 3
%136 = add i32 %4, -2
%137 = icmp slt i32 %136, %3
%138 = or i1 %135, %137
br i1 %138, label %232, label %139
139: ; preds = %129
%140 = getelementptr double, double* %0, i64 %130
%141 = add i32 %4, -2
%142 = sub i32 %141, %3
%143 = zext i32 %142 to i64
%144 = add nsw i64 %130, %143
%145 = add nsw i64 %144, 1
%146 = getelementptr double, double* %0, i64 %145
%147 = sext i32 %3 to i64
%148 = getelementptr double, double* %0, i64 %147
%149 = add nsw i64 %147, %143
%150 = add nsw i64 %149, 1
%151 = getelementptr double, double* %0, i64 %150
%152 = icmp ult double* %140, %151
%153 = icmp ult double* %148, %146
%154 = and i1 %152, %153
br i1 %154, label %232, label %155
155: ; preds = %139
%156 = and i64 %134, 8589934588
%157 = add nsw i64 %156, %130
%158 = trunc i64 %156 to i32
%159 = add i32 %158, %3
%160 = insertelement <2 x double> poison, double %11, i64 0
%161 = shufflevector <2 x double> %160, <2 x double> poison, <2 x i32> zeroinitializer
%162 = insertelement <2 x double> poison, double %11, i64 0
%163 = shufflevector <2 x double> %162, <2 x double> poison, <2 x i32> zeroinitializer
%164 = add nsw i64 %156, -4
%165 = lshr exact i64 %164, 2
%166 = add nuw nsw i64 %165, 1
%167 = and i64 %166, 1
%168 = icmp eq i64 %164, 0
br i1 %168, label %210, label %169
169: ; preds = %155
%170 = and i64 %166, 9223372036854775806
br label %171
171: ; preds = %171, %169
%172 = phi i64 [ 0, %169 ], [ %207, %171 ]
%173 = phi i64 [ 0, %169 ], [ %208, %171 ]
%174 = add i64 %172, %130
%175 = trunc i64 %172 to i32
%176 = add i32 %175, %3
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds double, double* %0, i64 %177
%179 = bitcast double* %178 to <2 x double>*
%180 = load <2 x double>, <2 x double>* %179
%181 = getelementptr inbounds double, double* %178, i64 2
%182 = bitcast double* %181 to <2 x double>*
%183 = load <2 x double>, <2 x double>* %182
%184 = fmul <2 x double> %161, %180
%185 = fmul <2 x double> %163, %183
%186 = getelementptr inbounds double, double* %0, i64 %174
%187 = bitcast double* %186 to <2 x double>*
store <2 x double> %184, <2 x double>* %187
%188 = getelementptr inbounds double, double* %186, i64 2
%189 = bitcast double* %188 to <2 x double>*
store <2 x double> %185, <2 x double>* %189
%190 = or i64 %172, 4
%191 = add i64 %190, %130
%192 = trunc i64 %190 to i32
%193 = add i32 %192, %3
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %0, i64 %194
%196 = bitcast double* %195 to <2 x double>*
%197 = load <2 x double>, <2 x double>* %196
%198 = getelementptr inbounds double, double* %195, i64 2
%199 = bitcast double* %198 to <2 x double>*
%200 = load <2 x double>, <2 x double>* %199
%201 = fmul <2 x double> %161, %197
%202 = fmul <2 x double> %163, %200
%203 = getelementptr inbounds double, double* %0, i64 %191
%204 = bitcast double* %203 to <2 x double>*
store <2 x double> %201, <2 x double>* %204
%205 = getelementptr inbounds double, double* %203, i64 2
%206 = bitcast double* %205 to <2 x double>*
store <2 x double> %202, <2 x double>* %206
%207 = add nuw i64 %172, 8
%208 = add i64 %173, 2
%209 = icmp eq i64 %208, %170
br i1 %209, label %210, label %171
210: ; preds = %171, %155
%211 = phi i64 [ 0, %155 ], [ %207, %171 ]
%212 = icmp eq i64 %167, 0
br i1 %212, label %230, label %213
213: ; preds = %210
%214 = add i64 %211, %130
%215 = trunc i64 %211 to i32
%216 = add i32 %215, %3
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds double, double* %0, i64 %217
%219 = bitcast double* %218 to <2 x double>*
%220 = load <2 x double>, <2 x double>* %219
%221 = getelementptr inbounds double, double* %218, i64 2
%222 = bitcast double* %221 to <2 x double>*
%223 = load <2 x double>, <2 x double>* %222
%224 = fmul <2 x double> %161, %220
%225 = fmul <2 x double> %163, %223
%226 = getelementptr inbounds double, double* %0, i64 %214
%227 = bitcast double* %226 to <2 x double>*
store <2 x double> %224, <2 x double>* %227
%228 = getelementptr inbounds double, double* %226, i64 2
%229 = bitcast double* %228 to <2 x double>*
store <2 x double> %225, <2 x double>* %229
br label %230
230: ; preds = %210, %213
%231 = icmp eq i64 %134, %156
br i1 %231, label %302, label %232
232: ; preds = %139, %129, %230
%233 = phi i64 [ %130, %139 ], [ %130, %129 ], [ %157, %230 ]
%234 = phi i32 [ %3, %139 ], [ %3, %129 ], [ %159, %230 ]
%235 = trunc i64 %233 to i32
%236 = sub i32 %4, %235
%237 = xor i32 %235, -1
%238 = add i32 %237, %4
%239 = and i32 %236, 3
%240 = icmp eq i32 %239, 0
br i1 %240, label %256, label %241
241: ; preds = %232, %241
%242 = phi i64 [ %250, %241 ], [ %233, %232 ]
%243 = phi i32 [ %251, %241 ], [ %234, %232 ]
%244 = phi i32 [ %252, %241 ], [ 0, %232 ]
%245 = sext i32 %243 to i64
%246 = getelementptr inbounds double, double* %0, i64 %245
%247 = load double, double* %246
%248 = fmul double %11, %247
%249 = getelementptr inbounds double, double* %0, i64 %242
store double %248, double* %249
%250 = add nsw i64 %242, 1
%251 = trunc i64 %242 to i32
%252 = add i32 %244, 1
%253 = icmp eq i32 %252, %239
br i1 %253, label %254, label %241
254: ; preds = %241
%255 = trunc i64 %242 to i32
br label %256
256: ; preds = %254, %232
%257 = phi i64 [ %233, %232 ], [ %250, %254 ]
%258 = phi i32 [ %234, %232 ], [ %255, %254 ]
%259 = icmp ult i32 %238, 3
br i1 %259, label %302, label %269
260: ; preds = %124, %260
%261 = phi i64 [ %262, %260 ], [ %125, %124 ]
%262 = add nsw i64 %261, -1
%263 = getelementptr inbounds double, double* %0, i64 %261
%264 = load double, double* %263
%265 = fdiv double %264, %11
%266 = and i64 %262, 4294967295
%267 = getelementptr inbounds double, double* %0, i64 %266
store double %265, double* %267
%268 = icmp ugt i64 %261, 1
br i1 %268, label %260, label %126
269: ; preds = %256, %269
%270 = phi i64 [ %298, %269 ], [ %257, %256 ]
%271 = phi i32 [ %299, %269 ], [ %258, %256 ]
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %0, i64 %272
%274 = load double, double* %273
%275 = fmul double %11, %274
%276 = getelementptr inbounds double, double* %0, i64 %270
store double %275, double* %276
%277 = add nsw i64 %270, 1
%278 = shl i64 %270, 32
%279 = ashr exact i64 %278, 32
%280 = getelementptr inbounds double, double* %0, i64 %279
%281 = load double, double* %280
%282 = fmul double %11, %281
%283 = getelementptr inbounds double, double* %0, i64 %277
store double %282, double* %283
%284 = add nsw i64 %270, 2
%285 = shl i64 %277, 32
%286 = ashr exact i64 %285, 32
%287 = getelementptr inbounds double, double* %0, i64 %286
%288 = load double, double* %287
%289 = fmul double %11, %288
%290 = getelementptr inbounds double, double* %0, i64 %284
store double %289, double* %290
%291 = add nsw i64 %270, 3
%292 = shl i64 %284, 32
%293 = ashr exact i64 %292, 32
%294 = getelementptr inbounds double, double* %0, i64 %293
%295 = load double, double* %294
%296 = fmul double %11, %295
%297 = getelementptr inbounds double, double* %0, i64 %291
store double %296, double* %297
%298 = add nsw i64 %270, 4
%299 = trunc i64 %291 to i32
%300 = trunc i64 %298 to i32
%301 = icmp eq i32 %300, %4
br i1 %301, label %302, label %269
302: ; preds = %256, %269, %230, %126
%303 = sext i32 %4 to i64
%304 = getelementptr inbounds double, double* %0, i64 %303
store double %2, double* %304
%305 = icmp slt i32 %4, %5
br i1 %305, label %306, label %342
306: ; preds = %302
%307 = sext i32 %5 to i64
%308 = sub nsw i64 %307, %303
%309 = xor i64 %303, -1
%310 = add nsw i64 %309, %307
%311 = and i64 %308, 3
%312 = icmp eq i64 %311, 0
br i1 %312, label %322, label %313
313: ; preds = %306, %313
%314 = phi double [ %318, %313 ], [ %2, %306 ]
%315 = phi i64 [ %317, %313 ], [ %303, %306 ]
%316 = phi i64 [ %320, %313 ], [ 0, %306 ]
%317 = add nsw i64 %315, 1
%318 = fmul double %11, %314
%319 = getelementptr inbounds double, double* %0, i64 %317
store double %318, double* %319
%320 = add i64 %316, 1
%321 = icmp eq i64 %320, %311
br i1 %321, label %322, label %313
322: ; preds = %313, %306
%323 = phi double [ %2, %306 ], [ %318, %313 ]
%324 = phi i64 [ %303, %306 ], [ %317, %313 ]
%325 = icmp ult i64 %310, 3
br i1 %325, label %342, label %326
326: ; preds = %322, %326
%327 = phi double [ %339, %326 ], [ %323, %322 ]
%328 = phi i64 [ %338, %326 ], [ %324, %322 ]
%329 = add nsw i64 %328, 1
%330 = fmul double %11, %327
%331 = getelementptr inbounds double, double* %0, i64 %329
store double %330, double* %331
%332 = add nsw i64 %328, 2
%333 = fmul double %11, %330
%334 = getelementptr inbounds double, double* %0, i64 %332
store double %333, double* %334
%335 = add nsw i64 %328, 3
%336 = fmul double %11, %333
%337 = getelementptr inbounds double, double* %0, i64 %335
store double %336, double* %337
%338 = add nsw i64 %328, 4
%339 = fmul double %11, %336
%340 = getelementptr inbounds double, double* %0, i64 %338
store double %339, double* %340
%341 = icmp eq i64 %338, %307
br i1 %341, label %342, label %326
342: ; preds = %322, %326, %302
ret void
}