void dyadup_2D_feed_odd_col(double *matrixIn, int matrixInRow, int matrixInCol,
                            double *matrixOut, int matrixOutRow,
                            int matrixOutCol) {
  int row, col;
  for (col = 0; col < matrixInCol - 1; col++) {
    for (row = 0; row < matrixInRow; row++) {
      matrixOut[row + 2 * col * matrixInRow] =
          matrixIn[row + col * matrixInRow];
      matrixOut[row + (2 * col + 1) * matrixInRow] = 0;
    }
  }
  for (row = 0; row < matrixInRow; row++)
    matrixOut[row + (matrixOutCol - 1) * matrixInRow] =
        matrixIn[row + (matrixInCol - 1) * matrixInRow];
  return;
}


x86 assembly (clang, -O0):
<dyadup_2D_feed_odd_col>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11ba <dyadup_2D_feed_odd_col+0xba>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11a7 <dyadup_2D_feed_odd_col+0xa7>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1139 <dyadup_2D_feed_odd_col+0x39>
jmp    11ac <dyadup_2D_feed_odd_col+0xac>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1121 <dyadup_2D_feed_odd_col+0x21>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1211 <dyadup_2D_feed_odd_col+0x111>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11c1 <dyadup_2D_feed_odd_col+0xc1>
pop    %rbp
ret

x86 assembly (clang, -O2):
<dyadup_2D_feed_odd_col>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9d,-0x4c(%rsp)
lea    -0x1(%rdx),%eax
mov    %eax,-0x7c(%rsp)
mov    %esi,%r11d
cmp    $0x2,%edx
mov    %rcx,%rdx
jl     149a <dyadup_2D_feed_odd_col+0x39a>
movslq %esi,%r10
mov    -0x7c(%rsp),%r13d
lea    (%r10,%r10,1),%eax
mov    %rax,-0x28(%rsp)
lea    (%rdx,%r11,8),%rax
mov    %rax,0x10(%rsp)
mov    %r11d,%eax
and    $0xfffffffc,%eax
mov    %rax,(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x8(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,-0x10(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x18(%rsp)
mov    %r11,%rax
neg    %rax
mov    %rax,0x18(%rsp)
lea    0x30(%rdi),%r8
lea    0x0(,%r10,8),%rax
mov    %rax,0x20(%rsp)
lea    0x30(%rdx),%rax
mov    %rax,-0x20(%rsp)
lea    0x8(%rdx),%rax
mov    %rax,0x8(%rsp)
lea    0x8(%rdi),%r9
xor    %r12d,%r12d
xorps  %xmm0,%xmm0
mov    %esi,%r14d
xor    %r15d,%r15d
mov    %rdx,-0x60(%rsp)
mov    %rdi,-0x78(%rsp)
mov    %esi,-0x80(%rsp)
mov    %r10,-0x68(%rsp)
mov    %r13,-0x58(%rsp)
jmp    11f3 <dyadup_2D_feed_odd_col+0xf3>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r15
mov    0x20(%rsp),%rcx
add    %rcx,%r8
mov    -0x28(%rsp),%rax
add    %eax,%r12d
add    %eax,%r14d
add    %rcx,%r9
cmp    %r13,%r15
je     149a <dyadup_2D_feed_odd_col+0x39a>
test   %esi,%esi
jle    11d0 <dyadup_2D_feed_odd_col+0xd0>
mov    %r15,%rbp
imul   %r10,%rbp
movslq %r14d,%rax
mov    %rax,-0x30(%rsp)
movslq %r12d,%rax
mov    %rax,-0x38(%rsp)
lea    (%r15,%r15,1),%eax
imul   %esi,%eax
lea    (%r15,%r15,1),%ecx
add    $0x1,%ecx
imul   %esi,%ecx
cltq
mov    %rax,-0x48(%rsp)
movslq %ecx,%rax
mov    %rax,-0x40(%rsp)
cmp    $0x4,%esi
jae    12e0 <dyadup_2D_feed_odd_col+0x1e0>
xor    %ecx,%ecx
mov    %rcx,%rbx
test   $0x1,%r11b
je     126e <dyadup_2D_feed_odd_col+0x16e>
add    %rcx,%rbp
movsd  (%rdi,%rbp,8),%xmm1
mov    -0x48(%rsp),%rax
add    %rcx,%rax
movsd  %xmm1,(%rdx,%rax,8)
mov    -0x40(%rsp),%rax
add    %rcx,%rax
movq   $0x0,(%rdx,%rax,8)
mov    %rcx,%rbx
or     $0x1,%rbx
not    %rcx
cmp    0x18(%rsp),%rcx
je     11d0 <dyadup_2D_feed_odd_col+0xd0>
mov    0x8(%rsp),%rcx
mov    -0x30(%rsp),%rax
lea    (%rcx,%rax,8),%rax
mov    %rdx,%rbp
mov    -0x38(%rsp),%rdx
lea    (%rcx,%rdx,8),%rcx
mov    %rbp,%rdx
nopl   0x0(%rax)
movsd  -0x8(%r9,%rbx,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rbx,8)
movq   $0x0,-0x8(%rax,%rbx,8)
movsd  (%r9,%rbx,8),%xmm1
movsd  %xmm1,(%rcx,%rbx,8)
movq   $0x0,(%rax,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r11
jne    12a0 <dyadup_2D_feed_odd_col+0x1a0>
jmp    11d0 <dyadup_2D_feed_odd_col+0xd0>
nopw   0x0(%rax,%rax,1)
mov    %r15,%rax
imul   -0x28(%rsp),%rax
lea    (%r11,%rbp,1),%r13
mov    %rbp,%rcx
mov    %rdx,%rbp
movslq %eax,%rdx
add    %esi,%eax
lea    0x0(,%rdx,8),%rbx
add    %rbp,%rbx
mov    0x10(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
cltq
lea    0x0(%rbp,%rax,8),%rbp
lea    (%rsi,%rax,8),%r10
mov    %rcx,-0x70(%rsp)
lea    (%rdi,%rcx,8),%rax
lea    (%rdi,%r13,8),%rcx
cmp    %r10,%rbx
setb   %sil
cmp    %rdx,%rbp
setb   %r13b
cmp    %rcx,%rbx
setb   %bl
cmp    %rdx,%rax
setb   %dil
cmp    %rcx,%rbp
setb   %dl
cmp    %r10,%rax
setb   %al
test   %r13b,%sil
jne    1457 <dyadup_2D_feed_odd_col+0x357>
and    %dil,%bl
mov    -0x58(%rsp),%r13
jne    147b <dyadup_2D_feed_odd_col+0x37b>
mov    $0x0,%ecx
and    %al,%dl
mov    -0x60(%rsp),%rdx
mov    -0x78(%rsp),%rdi
mov    -0x80(%rsp),%esi
mov    -0x68(%rsp),%r10
mov    -0x70(%rsp),%rbp
jne    1239 <dyadup_2D_feed_odd_col+0x139>
cmpq   $0x0,-0x8(%rsp)
je     13fa <dyadup_2D_feed_odd_col+0x2fa>
mov    -0x20(%rsp),%rax
mov    -0x38(%rsp),%rcx
lea    (%rax,%rcx,8),%rcx
mov    -0x30(%rsp),%rsi
lea    (%rax,%rsi,8),%rbp
mov    -0x18(%rsp),%r13
xor    %ebx,%ebx
nopl   (%rax)
movups -0x30(%r8,%rbx,8),%xmm1
movups -0x20(%r8,%rbx,8),%xmm2
movups %xmm1,-0x30(%rcx,%rbx,8)
movups %xmm2,-0x20(%rcx,%rbx,8)
movups %xmm0,-0x30(%rbp,%rbx,8)
movups %xmm0,-0x20(%rbp,%rbx,8)
movups -0x10(%r8,%rbx,8),%xmm1
movups (%r8,%rbx,8),%xmm2
movups %xmm1,-0x10(%rcx,%rbx,8)
movups %xmm2,(%rcx,%rbx,8)
movups %xmm0,-0x10(%rbp,%rbx,8)
movups %xmm0,0x0(%rbp,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%r13
jne    13b0 <dyadup_2D_feed_odd_col+0x2b0>
jmp    13fc <dyadup_2D_feed_odd_col+0x2fc>
xor    %ebx,%ebx
testb  $0x1,-0x10(%rsp)
mov    -0x78(%rsp),%rdi
mov    -0x80(%rsp),%esi
mov    -0x58(%rsp),%r13
mov    -0x70(%rsp),%rbp
je     1442 <dyadup_2D_feed_odd_col+0x342>
lea    (%rbx,%rbp,1),%rax
movups (%rdi,%rax,8),%xmm1
movups 0x10(%rdi,%rax,8),%xmm2
mov    -0x48(%rsp),%rax
add    %rbx,%rax
movups %xmm1,(%rdx,%rax,8)
movups %xmm2,0x10(%rdx,%rax,8)
add    -0x40(%rsp),%rbx
movups %xmm0,(%rdx,%rbx,8)
movups %xmm0,0x10(%rdx,%rbx,8)
mov    (%rsp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
je     11d0 <dyadup_2D_feed_odd_col+0xd0>
jmp    1239 <dyadup_2D_feed_odd_col+0x139>
xor    %ecx,%ecx
mov    -0x60(%rsp),%rdx
mov    -0x78(%rsp),%rdi
mov    -0x80(%rsp),%esi
mov    -0x68(%rsp),%r10
mov    -0x58(%rsp),%r13
mov    -0x70(%rsp),%rbp
jmp    1239 <dyadup_2D_feed_odd_col+0x139>
xor    %ecx,%ecx
mov    -0x60(%rsp),%rdx
mov    -0x78(%rsp),%rdi
mov    -0x80(%rsp),%esi
mov    -0x68(%rsp),%r10
mov    -0x70(%rsp),%rbp
jmp    1239 <dyadup_2D_feed_odd_col+0x139>
test   %esi,%esi
jle    162d <dyadup_2D_feed_odd_col+0x52d>
mov    -0x7c(%rsp),%ecx
imul   %esi,%ecx
mov    -0x4c(%rsp),%eax
add    $0xffffffff,%eax
imul   %esi,%eax
movslq %ecx,%r8
movslq %eax,%r9
cmp    $0x4,%esi
mov    %rdx,%r10
jb     14eb <dyadup_2D_feed_odd_col+0x3eb>
lea    (%rdx,%r9,8),%rax
lea    (%r8,%r11,1),%rcx
lea    (%rdi,%rcx,8),%rcx
cmp    %rcx,%rax
jae    158c <dyadup_2D_feed_odd_col+0x48c>
lea    (%r9,%r11,1),%rax
lea    (%rdx,%rax,8),%rax
lea    (%rdi,%r8,8),%rcx
cmp    %rax,%rcx
jae    158c <dyadup_2D_feed_odd_col+0x48c>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     1530 <dyadup_2D_feed_odd_col+0x430>
lea    (%r10,%r9,8),%rsi
mov    %rdi,%rbx
lea    (%rdi,%r8,8),%rbp
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1510 <dyadup_2D_feed_odd_col+0x410>
cmp    $0x3,%rcx
jae    153d <dyadup_2D_feed_odd_col+0x43d>
jmp    162d <dyadup_2D_feed_odd_col+0x52d>
mov    %rdi,%rbx
cmp    $0x3,%rcx
jb     162d <dyadup_2D_feed_odd_col+0x52d>
mov    %r10,%rdi
lea    (%r10,%r9,8),%rcx
add    $0x18,%rcx
lea    (%rbx,%r8,8),%rdx
add    $0x18,%rdx
movsd  -0x18(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x18(%rcx,%rax,8)
movsd  -0x10(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%rax,8)
movsd  -0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r11
jne    1550 <dyadup_2D_feed_odd_col+0x450>
jmp    162d <dyadup_2D_feed_odd_col+0x52d>
mov    %r11d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rcx,%rcx
je     163c <dyadup_2D_feed_odd_col+0x53c>
mov    %rdi,%rcx
mov    %rsi,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rdi,%r8,8),%rbx
add    $0x30,%rbx
lea    (%rdx,%r9,8),%rdx
add    $0x30,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%rbx,%rcx,8),%xmm0
movups -0x20(%rbx,%rcx,8),%xmm1
movups %xmm0,-0x30(%rdx,%rcx,8)
movups %xmm1,-0x20(%rdx,%rcx,8)
movups -0x10(%rbx,%rcx,8),%xmm0
movups (%rbx,%rcx,8),%xmm1
movups %xmm0,-0x10(%rdx,%rcx,8)
movups %xmm1,(%rdx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rbp
jne    15d0 <dyadup_2D_feed_odd_col+0x4d0>
test   $0x1,%sil
je     1624 <dyadup_2D_feed_odd_col+0x524>
lea    (%rcx,%r8,1),%rdx
movups (%rdi,%rdx,8),%xmm0
movups 0x10(%rdi,%rdx,8),%xmm1
add    %r9,%rcx
mov    %r10,%rdx
movups %xmm0,(%r10,%rcx,8)
movups %xmm1,0x10(%r10,%rcx,8)
cmp    %r11,%rax
jne    14ed <dyadup_2D_feed_odd_col+0x3ed>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%sil
jne    1606 <dyadup_2D_feed_odd_col+0x506>
jmp    1624 <dyadup_2D_feed_odd_col+0x524>

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

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