#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 sqrt(double);
void kernel_correlation(int m, int n, double float_n,
                        double data[1400 + 0][1200 + 0],
                        double corr[1200 + 0][1200 + 0], double mean[1200 + 0],
                        double stddev[1200 + 0]) {
  int i, j, k;
  double eps = 0.1;
#pragma scop
  for (j = 0; j < m; j++) {
    mean[j] = 0.0;
    for (i = 0; i < n; i++)
      mean[j] += data[i][j];
    mean[j] /= float_n;
  }
  for (j = 0; j < m; j++) {
    stddev[j] = 0.0;
    for (i = 0; i < n; i++)
      stddev[j] += (data[i][j] - mean[j]) * (data[i][j] - mean[j]);
    stddev[j] /= float_n;
    stddev[j] = sqrt(stddev[j]);
    stddev[j] = stddev[j] <= eps ? 1.0 : stddev[j];
  }
  for (i = 0; i < n; i++)
    for (j = 0; j < m; j++) {
      data[i][j] -= mean[j];
      data[i][j] /= sqrt(float_n) * stddev[j];
    }
  for (i = 0; i < m - 1; i++) {
    corr[i][i] = 1.0;
    for (j = i + 1; j < m; j++) {
      corr[i][j] = 0.0;
      for (k = 0; k < n; k++)
        corr[i][j] += (data[k][i] * data[k][j]);
      corr[j][i] = corr[i][j];
    }
  }
  corr[m - 1][m - 1] = 1.0;
#pragma endscop
}


x86 assembly (clang, -O0):
<kernel_correlation>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
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)
movsd  0xec5(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11da <kernel_correlation+0xca>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11b1 <kernel_correlation+0xa1>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    116a <kernel_correlation+0x5a>
movsd  -0x10(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1147 <kernel_correlation+0x37>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1322 <kernel_correlation+0x212>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1288 <kernel_correlation+0x178>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1204 <kernel_correlation+0xf4>
movsd  -0x10(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <sqrt@plt>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     12f0 <kernel_correlation+0x1e0>
movsd  0xd22(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1302 <kernel_correlation+0x1f2>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11e1 <kernel_correlation+0xd1>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13d8 <kernel_correlation+0x2c8>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13c5 <kernel_correlation+0x2b5>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x10(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    133c <kernel_correlation+0x22c>
jmp    13ca <kernel_correlation+0x2ba>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1329 <kernel_correlation+0x219>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    151c <kernel_correlation+0x40c>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  0xbfa(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1509 <kernel_correlation+0x3f9>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14c5 <kernel_correlation+0x3b5>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    144d <kernel_correlation+0x33d>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    141c <kernel_correlation+0x30c>
jmp    150e <kernel_correlation+0x3fe>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13df <kernel_correlation+0x2cf>
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x2580,%rcx,%rcx
add    %rcx,%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xac4(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_correlation>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,%r12
mov    %r8,%r13
mov    %rcx,0x38(%rsp)
mov    %rdx,0x10(%rsp)
movapd %xmm0,%xmm2
mov    %edi,%eax
mov    %rax,0x28(%rsp)
mov    %esi,%eax
mov    %rax,0x18(%rsp)
mov    %rdi,0x30(%rsp)
test   %edi,%edi
mov    %esi,0xc(%rsp)
movsd  %xmm0,0x20(%rsp)
jle    13ab <kernel_correlation+0x29b>
mov    0x18(%rsp),%rcx
lea    -0x1(%rcx),%r9
mov    %ecx,%r8d
and    $0x3,%r8d
and    $0xfffffffc,%ecx
imul   $0x2580,%r8,%rdx
xor    %esi,%esi
mov    0x10(%rsp),%rbp
mov    0x28(%rsp),%rax
jmp    11a0 <kernel_correlation+0x90>
nop
xorpd  %xmm0,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
add    $0x1,%rsi
add    $0x8,%rbp
cmp    %rax,%rsi
je     124d <kernel_correlation+0x13d>
movq   $0x0,0x0(%r13,%rsi,8)
cmpl   $0x0,0xc(%rsp)
jle    1180 <kernel_correlation+0x70>
xorpd  %xmm0,%xmm0
cmp    $0x3,%r9
jae    11c0 <kernel_correlation+0xb0>
xor    %ebx,%ebx
jmp    1218 <kernel_correlation+0x108>
xchg   %ax,%ax
mov    %rbp,%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
addsd  (%rdi),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
addsd  0x2580(%rdi),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
addsd  0x4b00(%rdi),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
addsd  0x7080(%rdi),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
add    $0x4,%rbx
add    $0x9600,%rdi
cmp    %rbx,%rcx
jne    11d0 <kernel_correlation+0xc0>
test   %r8,%r8
je     1184 <kernel_correlation+0x74>
imul   $0x2580,%rbx,%rdi
add    %rbp,%rdi
xor    %ebx,%ebx
nopl   (%rax)
addsd  (%rdi,%rbx,1),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
add    $0x2580,%rbx
cmp    %rbx,%rdx
jne    1230 <kernel_correlation+0x120>
jmp    1184 <kernel_correlation+0x74>
cmpl   $0x0,0x30(%rsp)
mov    0xc(%rsp),%esi
jle    13ab <kernel_correlation+0x29b>
mov    0x18(%rsp),%r14
and    $0xfffffffe,%r14d
xor    %r15d,%r15d
xorpd  %xmm3,%xmm3
movsd  0xd8c(%rip),%xmm4
movsd  0xd8c(%rip),%xmm5
mov    0x10(%rsp),%rbp
jmp    12e7 <kernel_correlation+0x1d7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r9,%rbx
call   1030 <sqrt@plt>
movsd  0xd68(%rip),%xmm5
movsd  0xd58(%rip),%xmm4
xorpd  %xmm3,%xmm3
mov    %rbx,%r9
movsd  0x20(%rsp),%xmm2
mov    0xc(%rsp),%esi
movapd %xmm0,%xmm1
cmpnlesd %xmm4,%xmm1
andpd  %xmm1,%xmm0
andnpd %xmm5,%xmm1
orpd   %xmm0,%xmm1
movlpd %xmm1,(%r12,%r15,8)
add    $0x1,%r15
add    $0x8,%rbp
cmp    0x28(%rsp),%r15
je     13ab <kernel_correlation+0x29b>
movq   $0x0,(%r12,%r15,8)
xorpd  %xmm0,%xmm0
test   %esi,%esi
jle    1384 <kernel_correlation+0x274>
xorpd  %xmm0,%xmm0
test   %r9,%r9
je     13a0 <kernel_correlation+0x290>
mov    %rbp,%rcx
xor    %eax,%eax
nopl   (%rax)
movsd  (%rcx),%xmm1
subsd  0x0(%r13,%r15,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%r15,8)
movsd  0x2580(%rcx),%xmm0
subsd  0x0(%r13,%r15,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%r15,8)
add    $0x2,%rax
add    $0x4b00,%rcx
cmp    %rax,%r14
jne    1310 <kernel_correlation+0x200>
testb  $0x1,0x18(%rsp)
je     1384 <kernel_correlation+0x274>
imul   $0x2580,%rax,%rax
add    0x10(%rsp),%rax
movsd  (%rax,%r15,8),%xmm1
subsd  0x0(%r13,%r15,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r12,%r15,8)
divsd  %xmm2,%xmm0
ucomisd %xmm3,%xmm0
jb     1290 <kernel_correlation+0x180>
sqrtsd %xmm0,%xmm0
jmp    12b9 <kernel_correlation+0x1a9>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
testb  $0x1,0x18(%rsp)
jne    135d <kernel_correlation+0x24d>
jmp    1384 <kernel_correlation+0x274>
test   %esi,%esi
mov    0x28(%rsp),%r15
jle    1457 <kernel_correlation+0x347>
xor    %r14d,%r14d
xorps  %xmm3,%xmm3
sqrtsd %xmm2,%xmm3
xorpd  %xmm4,%xmm4
mov    0x10(%rsp),%rbx
movsd  %xmm3,0x40(%rsp)
jmp    13f2 <kernel_correlation+0x2e2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
add    $0x2580,%rbx
cmp    0x18(%rsp),%r14
je     1457 <kernel_correlation+0x347>
cmpl   $0x0,0x30(%rsp)
jle    13e0 <kernel_correlation+0x2d0>
xor    %ebp,%ebp
jmp    141d <kernel_correlation+0x30d>
nopl   (%rax)
mulsd  (%r12,%rbp,8),%xmm0
movsd  (%rbx,%rbp,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r15
je     13e0 <kernel_correlation+0x2d0>
movsd  (%rbx,%rbp,8),%xmm0
subsd  0x0(%r13,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
ucomisd %xmm4,%xmm2
movapd %xmm3,%xmm0
jae    1400 <kernel_correlation+0x2f0>
movapd %xmm2,%xmm0
call   1030 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  0x40(%rsp),%xmm3
movsd  0x20(%rsp),%xmm2
mov    0xc(%rsp),%esi
jmp    1400 <kernel_correlation+0x2f0>
mov    0x30(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    %ecx,0x20(%rsp)
movabs $0x3ff0000000000000,%r9
cmp    $0x2,%eax
jl     15af <kernel_correlation+0x49f>
mov    0x20(%rsp),%r10d
mov    0x18(%rsp),%r8
and    $0xfffffffe,%r8d
mov    $0x1,%r14d
mov    $0x2588,%r15d
xor    %ebx,%ebx
xor    %r11d,%r11d
jmp    14b5 <kernel_correlation+0x3a5>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
add    $0x8,%rbx
add    $0x8,%r15
cmp    %r10,%r11
je     15af <kernel_correlation+0x49f>
mov    %r11,%r12
imul   $0x2580,%r11,%r13
add    0x38(%rsp),%r13
mov    %r9,0x0(%r13,%r11,8)
add    $0x1,%r11
cmp    0x28(%rsp),%r11
jae    14a0 <kernel_correlation+0x390>
mov    %r15,%rbp
mov    %r14,%rdi
jmp    1505 <kernel_correlation+0x3f5>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
imul   $0x2580,%rdi,%rax
add    0x38(%rsp),%rax
movsd  %xmm0,(%rax,%r12,8)
add    $0x1,%rdi
add    $0x8,%rbp
cmp    0x28(%rsp),%rdi
je     14a0 <kernel_correlation+0x390>
movq   $0x0,0x0(%r13,%rdi,8)
test   %esi,%esi
jle    14e0 <kernel_correlation+0x3d0>
lea    0x0(,%rdi,8),%rax
add    %r13,%rax
xorpd  %xmm0,%xmm0
cmp    $0x1,%esi
jne    1530 <kernel_correlation+0x420>
xor    %ecx,%ecx
jmp    157c <kernel_correlation+0x46c>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rbx,1),%xmm1
mulsd  -0x2580(%rdx,%rbp,1),%xmm1
ff ff
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax)
movsd  0x2580(%rdx,%rbx,1),%xmm0
mulsd  (%rdx,%rbp,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
add    $0x2,%rcx
add    $0x4b00,%rdx
cmp    %rcx,%r8
jne    1540 <kernel_correlation+0x430>
testb  $0x1,0x18(%rsp)
mov    0xc(%rsp),%esi
je     14e4 <kernel_correlation+0x3d4>
imul   $0x2580,%rcx,%rcx
add    0x10(%rsp),%rcx
movsd  (%rcx,%r12,8),%xmm1
mulsd  (%rcx,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
jmp    14e4 <kernel_correlation+0x3d4>
movslq 0x20(%rsp),%rax
imul   $0x2580,%rax,%rcx
mov    0x38(%rsp),%rdx
add    %rcx,%rdx
mov    %r9,(%rdx,%rax,8)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @kernel_correlation(i32 %0, i32 %1, double %2, [1200 x double]* %3, [1200 x double]* %4, double* %5, double* %6) {
%8 = alloca i32
%9 = alloca i32
%10 = alloca double
%11 = alloca [1200 x double]*
%12 = alloca [1200 x double]*
%13 = alloca double*
%14 = alloca double*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca double
store i32 %0, i32* %8
store i32 %1, i32* %9
store double %2, double* %10
store [1200 x double]* %3, [1200 x double]** %11
store [1200 x double]* %4, [1200 x double]** %12
store double* %5, double** %13
store double* %6, double** %14
store double 1.000000e-01, double* %18
store i32 0, i32* %16
br label %19
19: ; preds = %58, %7
%20 = load i32, i32* %16
%21 = load i32, i32* %8
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %61
23: ; preds = %19
%24 = load double*, double** %13
%25 = load i32, i32* %16
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds double, double* %24, i64 %26
store double 0.000000e+00, double* %27
store i32 0, i32* %15
br label %28
28: ; preds = %47, %23
%29 = load i32, i32* %15
%30 = load i32, i32* %9
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %50
32: ; preds = %28
%33 = load [1200 x double]*, [1200 x double]** %11
%34 = load i32, i32* %15
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [1200 x double], [1200 x double]* %33, i64 %35
%37 = load i32, i32* %16
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [1200 x double], [1200 x double]* %36, i64 0, i64 %38
%40 = load double, double* %39
%41 = load double*, double** %13
%42 = load i32, i32* %16
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %41, i64 %43
%45 = load double, double* %44
%46 = fadd double %45, %40
store double %46, double* %44
br label %47
47: ; preds = %32
%48 = load i32, i32* %15
%49 = add nsw i32 %48, 1
store i32 %49, i32* %15
br label %28
50: ; preds = %28
%51 = load double, double* %10
%52 = load double*, double** %13
%53 = load i32, i32* %16
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %52, i64 %54
%56 = load double, double* %55
%57 = fdiv double %56, %51
store double %57, double* %55
br label %58
58: ; preds = %50
%59 = load i32, i32* %16
%60 = add nsw i32 %59, 1
store i32 %60, i32* %16
br label %19
61: ; preds = %19
store i32 0, i32* %16
br label %62
62: ; preds = %151, %61
%63 = load i32, i32* %16
%64 = load i32, i32* %8
%65 = icmp slt i32 %63, %64
br i1 %65, label %66, label %154
66: ; preds = %62
%67 = load double*, double** %14
%68 = load i32, i32* %16
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %67, i64 %69
store double 0.000000e+00, double* %70
store i32 0, i32* %15
br label %71
71: ; preds = %110, %66
%72 = load i32, i32* %15
%73 = load i32, i32* %9
%74 = icmp slt i32 %72, %73
br i1 %74, label %75, label %113
75: ; preds = %71
%76 = load [1200 x double]*, [1200 x double]** %11
%77 = load i32, i32* %15
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [1200 x double], [1200 x double]* %76, i64 %78
%80 = load i32, i32* %16
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [1200 x double], [1200 x double]* %79, i64 0, i64 %81
%83 = load double, double* %82
%84 = load double*, double** %13
%85 = load i32, i32* %16
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds double, double* %84, i64 %86
%88 = load double, double* %87
%89 = fsub double %83, %88
%90 = load [1200 x double]*, [1200 x double]** %11
%91 = load i32, i32* %15
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [1200 x double], [1200 x double]* %90, i64 %92
%94 = load i32, i32* %16
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [1200 x double], [1200 x double]* %93, i64 0, i64 %95
%97 = load double, double* %96
%98 = load double*, double** %13
%99 = load i32, i32* %16
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %98, i64 %100
%102 = load double, double* %101
%103 = fsub double %97, %102
%104 = load double*, double** %14
%105 = load i32, i32* %16
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double, double* %104, i64 %106
%108 = load double, double* %107
%109 = call double @llvm.fmuladd.f64(double %89, double %103, double %108)
store double %109, double* %107
br label %110
110: ; preds = %75
%111 = load i32, i32* %15
%112 = add nsw i32 %111, 1
store i32 %112, i32* %15
br label %71
113: ; preds = %71
%114 = load double, double* %10
%115 = load double*, double** %14
%116 = load i32, i32* %16
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double, double* %115, i64 %117
%119 = load double, double* %118
%120 = fdiv double %119, %114
store double %120, double* %118
%121 = load double*, double** %14
%122 = load i32, i32* %16
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %121, i64 %123
%125 = load double, double* %124
%126 = call double @sqrt(double %125)
%127 = load double*, double** %14
%128 = load i32, i32* %16
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %127, i64 %129
store double %126, double* %130
%131 = load double*, double** %14
%132 = load i32, i32* %16
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds double, double* %131, i64 %133
%135 = load double, double* %134
%136 = load double, double* %18
%137 = fcmp ole double %135, %136
br i1 %137, label %138, label %139
138: ; preds = %113
br label %145
139: ; preds = %113
%140 = load double*, double** %14
%141 = load i32, i32* %16
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds double, double* %140, i64 %142
%144 = load double, double* %143
br label %145
145: ; preds = %139, %138
%146 = phi double [ 1.000000e+00, %138 ], [ %144, %139 ]
%147 = load double*, double** %14
%148 = load i32, i32* %16
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds double, double* %147, i64 %149
store double %146, double* %150
br label %151
151: ; preds = %145
%152 = load i32, i32* %16
%153 = add nsw i32 %152, 1
store i32 %153, i32* %16
br label %62
154: ; preds = %62
store i32 0, i32* %15
br label %155
155: ; preds = %200, %154
%156 = load i32, i32* %15
%157 = load i32, i32* %9
%158 = icmp slt i32 %156, %157
br i1 %158, label %159, label %203
159: ; preds = %155
store i32 0, i32* %16
br label %160
160: ; preds = %196, %159
%161 = load i32, i32* %16
%162 = load i32, i32* %8
%163 = icmp slt i32 %161, %162
br i1 %163, label %164, label %199
164: ; preds = %160
%165 = load double*, double** %13
%166 = load i32, i32* %16
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds double, double* %165, i64 %167
%169 = load double, double* %168
%170 = load [1200 x double]*, [1200 x double]** %11
%171 = load i32, i32* %15
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds [1200 x double], [1200 x double]* %170, i64 %172
%174 = load i32, i32* %16
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds [1200 x double], [1200 x double]* %173, i64 0, i64 %175
%177 = load double, double* %176
%178 = fsub double %177, %169
store double %178, double* %176
%179 = load double, double* %10
%180 = call double @sqrt(double %179)
%181 = load double*, double** %14
%182 = load i32, i32* %16
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %181, i64 %183
%185 = load double, double* %184
%186 = fmul double %180, %185
%187 = load [1200 x double]*, [1200 x double]** %11
%188 = load i32, i32* %15
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [1200 x double], [1200 x double]* %187, i64 %189
%191 = load i32, i32* %16
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds [1200 x double], [1200 x double]* %190, i64 0, i64 %192
%194 = load double, double* %193
%195 = fdiv double %194, %186
store double %195, double* %193
br label %196
196: ; preds = %164
%197 = load i32, i32* %16
%198 = add nsw i32 %197, 1
store i32 %198, i32* %16
br label %160
199: ; preds = %160
br label %200
200: ; preds = %199
%201 = load i32, i32* %15
%202 = add nsw i32 %201, 1
store i32 %202, i32* %15
br label %155
203: ; preds = %155
store i32 0, i32* %15
br label %204
204: ; preds = %284, %203
%205 = load i32, i32* %15
%206 = load i32, i32* %8
%207 = sub nsw i32 %206, 1
%208 = icmp slt i32 %205, %207
br i1 %208, label %209, label %287
209: ; preds = %204
%210 = load [1200 x double]*, [1200 x double]** %12
%211 = load i32, i32* %15
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds [1200 x double], [1200 x double]* %210, i64 %212
%214 = load i32, i32* %15
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds [1200 x double], [1200 x double]* %213, i64 0, i64 %215
store double 1.000000e+00, double* %216
%217 = load i32, i32* %15
%218 = add nsw i32 %217, 1
store i32 %218, i32* %16
br label %219
219: ; preds = %280, %209
%220 = load i32, i32* %16
%221 = load i32, i32* %8
%222 = icmp slt i32 %220, %221
br i1 %222, label %223, label %283
223: ; preds = %219
%224 = load [1200 x double]*, [1200 x double]** %12
%225 = load i32, i32* %15
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds [1200 x double], [1200 x double]* %224, i64 %226
%228 = load i32, i32* %16
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds [1200 x double], [1200 x double]* %227, i64 0, i64 %229
store double 0.000000e+00, double* %230
store i32 0, i32* %17
br label %231
231: ; preds = %261, %223
%232 = load i32, i32* %17
%233 = load i32, i32* %9
%234 = icmp slt i32 %232, %233
br i1 %234, label %235, label %264
235: ; preds = %231
%236 = load [1200 x double]*, [1200 x double]** %11
%237 = load i32, i32* %17
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds [1200 x double], [1200 x double]* %236, i64 %238
%240 = load i32, i32* %15
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds [1200 x double], [1200 x double]* %239, i64 0, i64 %241
%243 = load double, double* %242
%244 = load [1200 x double]*, [1200 x double]** %11
%245 = load i32, i32* %17
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds [1200 x double], [1200 x double]* %244, i64 %246
%248 = load i32, i32* %16
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds [1200 x double], [1200 x double]* %247, i64 0, i64 %249
%251 = load double, double* %250
%252 = load [1200 x double]*, [1200 x double]** %12
%253 = load i32, i32* %15
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds [1200 x double], [1200 x double]* %252, i64 %254
%256 = load i32, i32* %16
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds [1200 x double], [1200 x double]* %255, i64 0, i64 %257
%259 = load double, double* %258
%260 = call double @llvm.fmuladd.f64(double %243, double %251, double %259)
store double %260, double* %258
br label %261
261: ; preds = %235
%262 = load i32, i32* %17
%263 = add nsw i32 %262, 1
store i32 %263, i32* %17
br label %231
264: ; preds = %231
%265 = load [1200 x double]*, [1200 x double]** %12
%266 = load i32, i32* %15
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds [1200 x double], [1200 x double]* %265, i64 %267
%269 = load i32, i32* %16
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds [1200 x double], [1200 x double]* %268, i64 0, i64 %270
%272 = load double, double* %271
%273 = load [1200 x double]*, [1200 x double]** %12
%274 = load i32, i32* %16
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [1200 x double], [1200 x double]* %273, i64 %275
%277 = load i32, i32* %15
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds [1200 x double], [1200 x double]* %276, i64 0, i64 %278
store double %272, double* %279
br label %280
280: ; preds = %264
%281 = load i32, i32* %16
%282 = add nsw i32 %281, 1
store i32 %282, i32* %16
br label %219
283: ; preds = %219
br label %284
284: ; preds = %283
%285 = load i32, i32* %15
%286 = add nsw i32 %285, 1
store i32 %286, i32* %15
br label %204
287: ; preds = %204
%288 = load [1200 x double]*, [1200 x double]** %12
%289 = load i32, i32* %8
%290 = sub nsw i32 %289, 1
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds [1200 x double], [1200 x double]* %288, i64 %291
%293 = load i32, i32* %8
%294 = sub nsw i32 %293, 1
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds [1200 x double], [1200 x double]* %292, i64 0, i64 %295
store double 1.000000e+00, double* %296
ret void
}

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