void initializeArray(double X[6][6], unsigned long int x, unsigned long int y) {
  unsigned long int i, j;
  for (i = 1; i < x; i++) {
    for (j = 1; j < y; j++) {
      X[i][j] = (double)1000 + (i * (x - i - 1) * j * (y - j - 1));
    }
  }
  for (i = 0; i < x; i++) {
    X[i][0] = 0;
    X[i][y - 1] = 0;
  }
  for (j = 1; j < y; j++) {
    X[0][j] = 0;
    X[x - 1][j] = 0;
  }
}


x86 assembly (clang, -O0):
<initializeArray>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11d6 <initializeArray+0xd6>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    11c0 <initializeArray+0xc0>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rdx
mov    %rax,%rcx
not    %rcx
add    %rdx,%rcx
imul   %rcx,%rax
mov    -0x28(%rbp),%rcx
imul   %rcx,%rax
mov    -0x18(%rbp),%rdx
not    %rcx
add    %rdx,%rcx
imul   %rcx,%rax
movq   %rax,%xmm1
movaps 0xe9d(%rip),%xmm0
punpckldq %xmm0,%xmm1
movapd 0xea1(%rip),%xmm0
subpd  %xmm0,%xmm1
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe6a(%rip),%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
imul   $0x30,-0x20(%rbp),%rcx
add    %rcx,%rax
mov    -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    112e <initializeArray+0x2e>
jmp    11c5 <initializeArray+0xc5>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1118 <initializeArray+0x18>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    122c <initializeArray+0x12c>
mov    -0x8(%rbp),%rax
imul   $0x30,-0x20(%rbp),%rcx
add    %rcx,%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
imul   $0x30,-0x20(%rbp),%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%rcx
sub    $0x1,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    11de <initializeArray+0xde>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1282 <initializeArray+0x182>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
imul   $0x30,%rcx,%rcx
add    %rcx,%rax
mov    -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1234 <initializeArray+0x134>
pop    %rbp
ret

x86 assembly (clang, -O2):
<initializeArray>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    $0x2,%rsi
jb     151a <initializeArray+0x41a>
lea    -0x1(%rdx),%r15
lea    -0x3(%rdx),%r14
mov    %r14,-0x20(%rsp)
shr    %r14
add    $0x1,%r14
mov    %r15,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x28(%rsp)
mov    %r15,%rax
or     $0x1,%rax
mov    %rax,-0x30(%rsp)
movq   %rdx,%xmm0
pshufd $0x44,%xmm0,%xmm9
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x38(%rsp)
lea    0x48(%rdi),%r9
lea    0x30(%rdi),%r12
lea    -0x2(%rsi),%r10
lea    -0x4(%rsi),%r13
mov    $0x1,%r8d
movdqa 0xf1b(%rip),%xmm3
movdqa 0xf23(%rip),%xmm6
movsd  0xf2b(%rip),%xmm7
pcmpeqd %xmm11,%xmm11
movdqa 0xe7d(%rip),%xmm14
movdqa 0xe85(%rip),%xmm4
movdqa 0xe8d(%rip),%xmm2
movapd 0xe95(%rip),%xmm1
movapd 0xe9c(%rip),%xmm10
movdqa 0xea3(%rip),%xmm8
movdqa 0xeaa(%rip),%xmm12
movdqa %xmm9,-0x18(%rsp)
movdqa -0x18(%rsp),%xmm15
jmp    11fc <initializeArray+0xfc>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r8
add    $0x30,%r9
add    $0x30,%r12
add    %r13,%r10
add    $0xfffffffffffffffe,%r13
cmp    %rsi,%r8
je     151a <initializeArray+0x41a>
cmp    $0x2,%rdx
jb     11e0 <initializeArray+0xe0>
mov    $0x1,%eax
cmp    $0x2,%r15
jb     14cb <initializeArray+0x3cb>
mov    %r8,%rcx
not    %rcx
add    %rsi,%rcx
imul   %r8,%rcx
movq   %rcx,%xmm0
pshufd $0x44,%xmm0,%xmm9
movdqa %xmm9,%xmm7
psrlq  $0x20,%xmm7
cmpq   $0x2,-0x20(%rsp)
jae    124b <initializeArray+0x14b>
xor    %ebp,%ebp
movdqa 0xdba(%rip),%xmm13
jmp    13eb <initializeArray+0x2eb>
mov    -0x38(%rsp),%r11
xor    %ebp,%ebp
movdqa 0xda5(%rip),%xmm13
nopl   0x0(%rax,%rax,1)
movdqa %xmm7,%xmm0
pmuludq %xmm13,%xmm0
movdqa %xmm13,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm9,%xmm5
paddq  %xmm0,%xmm5
psllq  $0x20,%xmm5
movapd %xmm10,%xmm3
movdqa %xmm9,%xmm10
pmuludq %xmm13,%xmm10
paddq  %xmm5,%xmm10
movdqa %xmm12,%xmm6
movdqa %xmm8,%xmm12
movdqa %xmm13,%xmm8
pxor   %xmm11,%xmm8
paddq  %xmm15,%xmm8
movdqa %xmm8,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm10,%xmm5
movdqa %xmm10,%xmm0
psrlq  $0x20,%xmm0
pmuludq %xmm8,%xmm0
paddq  %xmm5,%xmm0
psllq  $0x20,%xmm0
pmuludq %xmm10,%xmm8
movapd %xmm3,%xmm10
paddq  %xmm0,%xmm8
movdqa %xmm8,%xmm0
pand   %xmm14,%xmm0
por    %xmm4,%xmm0
psrlq  $0x20,%xmm8
por    %xmm2,%xmm8
subpd  %xmm1,%xmm8
addpd  %xmm0,%xmm8
addpd  %xmm3,%xmm8
movupd %xmm8,-0x10(%r9,%rbp,8)
movdqa %xmm12,%xmm8
movdqa %xmm6,%xmm12
movdqa %xmm13,%xmm5
paddq  %xmm8,%xmm5
movdqa %xmm7,%xmm0
pmuludq %xmm5,%xmm0
movdqa %xmm2,%xmm11
movapd %xmm1,%xmm2
movdqa %xmm4,%xmm1
movdqa %xmm7,%xmm3
movdqa %xmm9,%xmm7
pmuludq %xmm5,%xmm7
psrlq  $0x20,%xmm5
pmuludq %xmm9,%xmm5
paddq  %xmm0,%xmm5
psllq  $0x20,%xmm5
paddq  %xmm7,%xmm5
movdqa %xmm15,%xmm0
psubq  %xmm13,%xmm0
paddq  %xmm6,%xmm0
movdqa %xmm0,%xmm7
psrlq  $0x20,%xmm7
pmuludq %xmm5,%xmm7
movdqa %xmm5,%xmm6
psrlq  $0x20,%xmm6
pmuludq %xmm0,%xmm6
paddq  %xmm7,%xmm6
movdqa %xmm3,%xmm7
movapd %xmm2,%xmm1
movdqa %xmm11,%xmm2
pmuludq %xmm5,%xmm0
psllq  $0x20,%xmm6
paddq  %xmm6,%xmm0
pcmpeqd %xmm11,%xmm11
movdqa %xmm0,%xmm5
pand   %xmm14,%xmm5
por    %xmm4,%xmm5
psrlq  $0x20,%xmm0
por    %xmm2,%xmm0
subpd  %xmm1,%xmm0
addpd  %xmm5,%xmm0
addpd  %xmm10,%xmm0
movupd %xmm0,(%r9,%rbp,8)
add    $0x4,%rbp
paddq  0xc9f(%rip),%xmm13
add    $0xfffffffffffffffe,%r11
jne    1260 <initializeArray+0x160>
test   $0x1,%r14b
je     14a3 <initializeArray+0x3a3>
shl    $0x3,%rbp
pmuludq %xmm13,%xmm7
movdqa %xmm13,%xmm0
psrlq  $0x20,%xmm0
pmuludq %xmm9,%xmm0
paddq  %xmm7,%xmm0
psllq  $0x20,%xmm0
pmuludq %xmm13,%xmm9
paddq  %xmm0,%xmm9
pxor   %xmm11,%xmm13
paddq  -0x18(%rsp),%xmm13
movdqa %xmm13,%xmm0
psrlq  $0x20,%xmm0
pmuludq %xmm9,%xmm0
movdqa %xmm9,%xmm5
psrlq  $0x20,%xmm5
pmuludq %xmm13,%xmm5
paddq  %xmm0,%xmm5
psllq  $0x20,%xmm5
pmuludq %xmm9,%xmm13
paddq  %xmm5,%xmm13
movdqa %xmm13,%xmm0
pand   %xmm14,%xmm0
por    %xmm4,%xmm0
psrlq  $0x20,%xmm13
por    %xmm2,%xmm13
subpd  0xbc1(%rip),%xmm13
addpd  %xmm0,%xmm13
addpd  0xbc3(%rip),%xmm13
lea    (%r8,%r8,2),%rcx
shl    $0x4,%rcx
add    %rdi,%rcx
or     $0x8,%rbp
movupd %xmm13,0x0(%rbp,%rcx,1)
mov    -0x30(%rsp),%rax
cmp    -0x28(%rsp),%r15
movdqa 0xbdb(%rip),%xmm3
movdqa 0xbe3(%rip),%xmm6
movsd  0xbeb(%rip),%xmm7
je     11e0 <initializeArray+0xe0>
mov    %r15,%rcx
sub    %rax,%rcx
lea    (%r12,%rax,8),%rbx
imul   %r10,%rax
nopl   0x0(%rax)
mov    %rax,%rbp
imul   %rcx,%rbp
movq   %rbp,%xmm0
punpckldq %xmm3,%xmm0
subpd  %xmm6,%xmm0
movapd %xmm0,%xmm5
unpckhpd %xmm0,%xmm5
addsd  %xmm0,%xmm5
addsd  %xmm7,%xmm5
movsd  %xmm5,(%rbx)
add    $0x8,%rbx
add    %r10,%rax
add    $0xffffffffffffffff,%rcx
jb     14e0 <initializeArray+0x3e0>
jmp    11e0 <initializeArray+0xe0>
test   %rsi,%rsi
je     1596 <initializeArray+0x496>
cmp    $0x1,%rsi
jne    1529 <initializeArray+0x429>
xor    %eax,%eax
jmp    156f <initializeArray+0x46f>
mov    %rsi,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
mov    %rdi,%rbp
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,0x0(%rbp)
movq   $0x0,-0x8(%rbp,%rdx,8)
movq   $0x0,0x30(%rbp)
movq   $0x0,0x28(%rbp,%rdx,8)
add    $0x2,%rax
add    $0x60,%rbp
cmp    %rax,%rcx
jne    1540 <initializeArray+0x440>
test   $0x1,%sil
je     1596 <initializeArray+0x496>
lea    -0x1(%rdx),%rcx
lea    (%rax,%rax,2),%rax
shl    $0x4,%rax
lea    (%rdi,%rax,1),%rbp
movq   $0x0,(%rdi,%rax,1)
movq   $0x0,0x0(%rbp,%rcx,8)
cmp    $0x2,%rdx
jb     172f <initializeArray+0x62f>
lea    -0x1(%rsi),%r8
lea    -0x1(%rdx),%r9
mov    $0x1,%eax
cmp    $0x4,%r9
jb     1687 <initializeArray+0x587>
lea    0x8(%rdi),%rbp
lea    (%rsi,%rsi,2),%rcx
shl    $0x4,%rcx
lea    (%r8,%r8,2),%r11
shl    $0x4,%r11
add    %rdi,%r11
lea    (%r11,%rdx,8),%rbx
cmp    %rbx,%rbp
jae    15ec <initializeArray+0x4ec>
lea    (%rdi,%rdx,8),%rbp
lea    (%rdi,%rcx,1),%rbx
add    $0xffffffffffffffd8,%rbx
cmp    %rbp,%rbx
jb     1687 <initializeArray+0x587>
mov    %r9,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rbx
mov    %rbx,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rbx,%rbx
je     173a <initializeArray+0x63a>
mov    %r10,%rbx
and    $0xfffffffffffffffe,%rbx
add    %rdi,%rcx
mov    $0x1,%ebp
pxor   %xmm0,%xmm0
xchg   %ax,%ax
movdqu %xmm0,(%rdi,%rbp,8)
movdqu %xmm0,0x10(%rdi,%rbp,8)
movdqu %xmm0,-0x30(%rcx,%rbp,8)
movdqu %xmm0,-0x20(%rcx,%rbp,8)
movdqu %xmm0,0x20(%rdi,%rbp,8)
movdqu %xmm0,0x30(%rdi,%rbp,8)
movdqu %xmm0,-0x10(%rcx,%rbp,8)
movdqu %xmm0,(%rcx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1620 <initializeArray+0x520>
test   $0x1,%r10b
je     167a <initializeArray+0x57a>
pxor   %xmm0,%xmm0
movdqu %xmm0,(%rdi,%rbp,8)
movdqu %xmm0,0x10(%rdi,%rbp,8)
movdqu %xmm0,(%r11,%rbp,8)
movdqu %xmm0,0x10(%r11,%rbp,8)
cmp    %rax,%r9
je     172f <initializeArray+0x62f>
or     $0x1,%rax
mov    %edx,%ebp
sub    %eax,%ebp
mov    %rax,%rcx
not    %rcx
add    %rdx,%rcx
and    $0x3,%rbp
je     16ca <initializeArray+0x5ca>
lea    (%r8,%r8,2),%rbx
shl    $0x4,%rbx
add    %rdi,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,(%rdi,%rax,8)
movq   $0x0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbp
jne    16b0 <initializeArray+0x5b0>
cmp    $0x3,%rcx
jb     172f <initializeArray+0x62f>
lea    (%rsi,%rsi,2),%rcx
shl    $0x4,%rcx
add    %rdi,%rcx
add    $0xffffffffffffffe8,%rcx
nop
movq   $0x0,(%rdi,%rax,8)
movq   $0x0,-0x18(%rcx,%rax,8)
movq   $0x0,0x8(%rdi,%rax,8)
movq   $0x0,-0x10(%rcx,%rax,8)
movq   $0x0,0x10(%rdi,%rax,8)
movq   $0x0,-0x8(%rcx,%rax,8)
movq   $0x0,0x18(%rdi,%rax,8)
movq   $0x0,(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    16e0 <initializeArray+0x5e0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%ebp
test   $0x1,%r10b
jne    165e <initializeArray+0x55e>
jmp    167a <initializeArray+0x57a>

LLVM IR (-O0):
define void @initializeArray([6 x double]* %0, i64 %1, i64 %2) {
%4 = alloca [6 x double]*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
store [6 x double]* %0, [6 x double]** %4
store i64 %1, i64* %5
store i64 %2, i64* %6
store i64 1, i64* %7
br label %9
9: ; preds = %43, %3
%10 = load i64, i64* %7
%11 = load i64, i64* %5
%12 = icmp ult i64 %10, %11
br i1 %12, label %13, label %46
13: ; preds = %9
store i64 1, i64* %8
br label %14
14: ; preds = %39, %13
%15 = load i64, i64* %8
%16 = load i64, i64* %6
%17 = icmp ult i64 %15, %16
br i1 %17, label %18, label %42
18: ; preds = %14
%19 = load i64, i64* %7
%20 = load i64, i64* %5
%21 = load i64, i64* %7
%22 = sub i64 %20, %21
%23 = sub i64 %22, 1
%24 = mul i64 %19, %23
%25 = load i64, i64* %8
%26 = mul i64 %24, %25
%27 = load i64, i64* %6
%28 = load i64, i64* %8
%29 = sub i64 %27, %28
%30 = sub i64 %29, 1
%31 = mul i64 %26, %30
%32 = uitofp i64 %31 to double
%33 = fadd double 1.000000e+03, %32
%34 = load [6 x double]*, [6 x double]** %4
%35 = load i64, i64* %7
%36 = getelementptr inbounds [6 x double], [6 x double]* %34, i64 %35
%37 = load i64, i64* %8
%38 = getelementptr inbounds [6 x double], [6 x double]* %36, i64 0, i64 %37
store double %33, double* %38
br label %39
39: ; preds = %18
%40 = load i64, i64* %8
%41 = add i64 %40, 1
store i64 %41, i64* %8
br label %14
42: ; preds = %14
br label %43
43: ; preds = %42
%44 = load i64, i64* %7
%45 = add i64 %44, 1
store i64 %45, i64* %7
br label %9
46: ; preds = %9
store i64 0, i64* %7
br label %47
47: ; preds = %62, %46
%48 = load i64, i64* %7
%49 = load i64, i64* %5
%50 = icmp ult i64 %48, %49
br i1 %50, label %51, label %65
51: ; preds = %47
%52 = load [6 x double]*, [6 x double]** %4
%53 = load i64, i64* %7
%54 = getelementptr inbounds [6 x double], [6 x double]* %52, i64 %53
%55 = getelementptr inbounds [6 x double], [6 x double]* %54, i64 0, i64 0
store double 0.000000e+00, double* %55
%56 = load [6 x double]*, [6 x double]** %4
%57 = load i64, i64* %7
%58 = getelementptr inbounds [6 x double], [6 x double]* %56, i64 %57
%59 = load i64, i64* %6
%60 = sub i64 %59, 1
%61 = getelementptr inbounds [6 x double], [6 x double]* %58, i64 0, i64 %60
store double 0.000000e+00, double* %61
br label %62
62: ; preds = %51
%63 = load i64, i64* %7
%64 = add i64 %63, 1
store i64 %64, i64* %7
br label %47
65: ; preds = %47
store i64 1, i64* %8
br label %66
66: ; preds = %81, %65
%67 = load i64, i64* %8
%68 = load i64, i64* %6
%69 = icmp ult i64 %67, %68
br i1 %69, label %70, label %84
70: ; preds = %66
%71 = load [6 x double]*, [6 x double]** %4
%72 = getelementptr inbounds [6 x double], [6 x double]* %71, i64 0
%73 = load i64, i64* %8
%74 = getelementptr inbounds [6 x double], [6 x double]* %72, i64 0, i64 %73
store double 0.000000e+00, double* %74
%75 = load [6 x double]*, [6 x double]** %4
%76 = load i64, i64* %5
%77 = sub i64 %76, 1
%78 = getelementptr inbounds [6 x double], [6 x double]* %75, i64 %77
%79 = load i64, i64* %8
%80 = getelementptr inbounds [6 x double], [6 x double]* %78, i64 0, i64 %79
store double 0.000000e+00, double* %80
br label %81
81: ; preds = %70
%82 = load i64, i64* %8
%83 = add i64 %82, 1
store i64 %83, i64* %8
br label %66
84: ; preds = %66
ret void
}

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