#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 */
typedef scalar_t__ z;

/* Variables and functions */
int /*<<< orphan*/ _mm_load_sd(double *);
int /*<<< orphan*/ _mm_loadh_pd(int /*<<< orphan*/, double *);
int /*<<< orphan*/ _mm_store_pd(double *, int /*<<< orphan*/);
int /*<<< orphan*/ _mm_storeu_pd(double *, int /*<<< orphan*/);
int /*<<< orphan*/ assert(int);
void matprod_fill_lower(double *restrict z, int n) {
  assert(((uintptr_t)(z) & (1 - 1)) == 0);
  z = (z);
  {
    double *restrict zr = z;
    double *restrict zc = z;
    int i = 0;
    while (i <= n - 2) {
      double *zp = zr;
      int j = 0;
      while (j <= i - 2) {
        {
          (1 >= 16
               ? _mm_store_pd(zp, _mm_loadh_pd(_mm_load_sd(zc + j), zc + j + n))
               : _mm_storeu_pd(zp,
                               _mm_loadh_pd(_mm_load_sd(zc + j), zc + j + n)));
          _mm_storeu_pd(zp + n,
                        _mm_loadh_pd(_mm_load_sd(zc + j + 1), zc + j + n + 1));
        }
        zp += n;
        zp += n;
        j += 2;
      }
      if (j < i) {
        {
          (1 >= 16
               ? _mm_store_pd(zp, _mm_loadh_pd(_mm_load_sd(zc + j), zc + j + n))
               : _mm_storeu_pd(zp,
                               _mm_loadh_pd(_mm_load_sd(zc + j), zc + j + n)));
        }
        zp += n;
      }
      zp[1] = (zc + n)[i];
      zc += n;
      zc += n;
      zr += 2;
      i += 2;
    }
    if (i < n) {
      double *zp = zr;
      int j = 0;
      while (j < i) {
        zp[0] = zc[j];
        zp += n;
        j += 1;
      }
    }
  }
}


x86 assembly (clang, -O0):
<matprod_fill_lower>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rax
and    $0x0,%rax
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1361 <matprod_fill_lower+0x221>
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1293 <matprod_fill_lower+0x153>
mov    -0x30(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rdi
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
call   1030 <_mm_load_sd@plt>
mov    %eax,%edi
mov    -0x20(%rbp),%rsi
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
call   1050 <_mm_loadh_pd@plt>
mov    -0x58(%rbp),%rdi
mov    %eax,%esi
call   1060 <_mm_storeu_pd@plt>
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%rdi
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
add    $0x8,%rdi
call   1030 <_mm_load_sd@plt>
mov    %eax,%edi
mov    -0x20(%rbp),%rsi
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
add    $0x8,%rsi
call   1050 <_mm_loadh_pd@plt>
mov    -0x50(%rbp),%rdi
mov    %eax,%esi
call   1060 <_mm_storeu_pd@plt>
mov    -0xc(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    11a7 <matprod_fill_lower+0x67>
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12fc <matprod_fill_lower+0x1bc>
mov    -0x30(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rdi
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
call   1030 <_mm_load_sd@plt>
mov    %eax,%edi
mov    -0x20(%rbp),%rsi
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
call   1050 <_mm_loadh_pd@plt>
mov    -0x60(%rbp),%rdi
mov    %eax,%esi
call   1060 <_mm_storeu_pd@plt>
mov    -0xc(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0xc(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    1187 <matprod_fill_lower+0x47>
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13c5 <matprod_fill_lower+0x285>
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13c0 <matprod_fill_lower+0x280>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0xc(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    137c <matprod_fill_lower+0x23c>
jmp    13c5 <matprod_fill_lower+0x285>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matprod_fill_lower>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %esi,%ebx
mov    %rdi,%r15
mov    $0x1,%edi
call   1040 <assert@plt>
cmp    $0x2,%ebx
jl     14b6 <matprod_fill_lower+0x376>
lea    -0x2(%rbx),%eax
mov    %eax,0xc(%rsp)
movabs $0x200000000,%rdx
mov    %rbx,0x40(%rsp)
mov    %ebx,%ecx
mov    %rcx,%rdi
shl    $0x4,%rdi
lea    0x10(%r15),%r8
mov    %rcx,0x50(%rsp)
lea    0x0(,%rcx,8),%r10
mov    $0x2,%eax
xor    %esi,%esi
mov    %r10,%rcx
xor    %r12d,%r12d
mov    %r15,%r13
xor    %r14d,%r14d
mov    %r15,0x48(%rsp)
mov    %rdi,0x38(%rsp)
jmp    121b <matprod_fill_lower+0xdb>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%r10
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%r12
lea    0x0(,%rbx,8),%rax
add    %r13,%rax
movsd  (%rax,%r14,8),%xmm0
movsd  %xmm0,0x8(%rbp)
add    %rdi,%r13
add    $0x10,%r15
add    $0x2,%r14
lea    0x2(%r9),%rax
mov    0x68(%rsp),%rbx
lea    0x10(%rbx),%r8
add    %rdi,%r12
add    %rdi,%rcx
add    $0x10,%rsi
add    $0x10,%r10
cmp    %r14d,0xc(%rsp)
jl     1393 <matprod_fill_lower+0x253>
mov    %r8,0x68(%rsp)
test   %r14,%r14
mov    %rax,0x30(%rsp)
mov    %r14,0x70(%rsp)
mov    %r10,0x28(%rsp)
mov    %rsi,0x20(%rsp)
mov    %rcx,0x18(%rsp)
mov    %r12,0x10(%rsp)
je     1330 <matprod_fill_lower+0x1f0>
mov    %r13,0x58(%rsp)
mov    %r15,0x60(%rsp)
lea    -0x2(%r14),%rax
mov    %rax,0x78(%rsp)
mov    %r10,%r14
mov    %rsi,%rbp
mov    %rdx,%r13
mov    %rcx,%r15
xor    %ecx,%ecx
mov    0x48(%rsp),%rbx
nopl   (%rax)
mov    %rbp,0x80(%rsp)
lea    (%rbx,%rbp,1),%rax
mov    %rax,(%rsp)
lea    (%rbx,%r12,1),%rdi
mov    %rcx,%rbp
call   1030 <_mm_load_sd@plt>
lea    (%rbx,%r15,1),%rsi
mov    %eax,%edi
call   1050 <_mm_loadh_pd@plt>
mov    (%rsp),%rdi
mov    %eax,%esi
call   1060 <_mm_storeu_pd@plt>
lea    (%rbx,%r14,1),%rax
mov    %rax,(%rsp)
lea    (%rbx,%r12,1),%rdi
add    $0x8,%rdi
call   1030 <_mm_load_sd@plt>
lea    (%rbx,%r15,1),%rsi
add    $0x8,%rsi
mov    %eax,%edi
call   1050 <_mm_loadh_pd@plt>
mov    (%rsp),%rdi
mov    %eax,%esi
call   1060 <_mm_storeu_pd@plt>
mov    %rbp,%rcx
mov    0x80(%rsp),%rbp
mov    0x38(%rsp),%rdi
movabs $0x200000000,%rdx
add    $0x2,%rcx
mov    %r13,%rax
sar    $0x20,%rax
add    $0x10,%r12
add    $0x10,%r15
add    %rdx,%r13
add    %rdi,%rbp
add    %rdi,%r14
cmp    0x78(%rsp),%rax
jle    1270 <matprod_fill_lower+0x130>
add    %rbx,%rbp
mov    0x30(%rsp),%r9
mov    0x60(%rsp),%r15
mov    0x58(%rsp),%r13
jmp    1338 <matprod_fill_lower+0x1f8>
cs nopw 0x0(%rax,%rax,1)
mov    %rax,%r9
mov    %r15,%rbp
xor    %ecx,%ecx
mov    %ecx,%eax
mov    0x70(%rsp),%r14
cmp    %r14,%rax
mov    0x50(%rsp),%rbx
jae    11c0 <matprod_fill_lower+0x80>
lea    0x0(,%rax,8),%r12
add    %r13,%r12
mov    %r12,%rdi
call   1030 <_mm_load_sd@plt>
lea    (%r12,%rbx,8),%rsi
mov    %eax,%edi
call   1050 <_mm_loadh_pd@plt>
mov    %rbp,%rdi
mov    %eax,%esi
call   1060 <_mm_storeu_pd@plt>
mov    0x38(%rsp),%rdi
movabs $0x200000000,%rdx
mov    0x30(%rsp),%r9
lea    0x0(%rbp,%rbx,8),%rbp
jmp    11c0 <matprod_fill_lower+0x80>
mov    0x40(%rsp),%rax
cmp    %eax,%r14d
jge    14b6 <matprod_fill_lower+0x376>
test   %r14d,%r14d
je     14b6 <matprod_fill_lower+0x376>
cltq
mov    %r14d,%ecx
and    $0xfffffffe,%ecx
add    $0xffffffffffffffff,%rcx
cmp    $0x7,%rcx
jae    13cd <matprod_fill_lower+0x28d>
xor    %ecx,%ecx
test   $0x6,%r14b
jne    1481 <matprod_fill_lower+0x341>
jmp    14b6 <matprod_fill_lower+0x376>
mov    %rax,%r8
shl    $0x6,%r8
mov    %r9d,%edx
and    $0xfffffffe,%edx
mov    %r9d,%ecx
and    $0x6,%ecx
sub    %rcx,%rdx
lea    0x0(,%rax,8),%rdi
xor    %ecx,%ecx
nopl   (%rax)
mov    %rbx,%r15
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rbx)
movsd  0x8(%r13,%rcx,8),%xmm0
add    %rdi,%rbx
movsd  %xmm0,(%r15,%rdi,1)
movsd  0x10(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,1)
add    %rdi,%rbx
movsd  0x18(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,1)
add    %rdi,%rbx
movsd  0x20(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,1)
add    %rdi,%rbx
movsd  0x28(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,1)
add    %rdi,%rbx
movsd  0x30(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,1)
add    %rdi,%rbx
movsd  0x38(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,1)
add    %rdi,%rbx
add    $0x8,%rcx
add    %rdi,%rbx
cmp    %rcx,%rdx
jne    13f0 <matprod_fill_lower+0x2b0>
add    %r8,%r15
test   $0x6,%r14b
je     14b6 <matprod_fill_lower+0x376>
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
shl    $0x3,%rax
and    $0x6,%r9d
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%r15)
add    $0x1,%rdx
add    %rax,%r15
cmp    %rdx,%r9
jne    14a0 <matprod_fill_lower+0x360>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @matprod_fill_lower(double* noalias %0, i32 %1) {
%3 = alloca double*
%4 = alloca i32
%5 = alloca double*
%6 = alloca double*
%7 = alloca i32
%8 = alloca double*
%9 = alloca i32
%10 = alloca double*
%11 = alloca i32
store double* %0, double** %3
store i32 %1, i32* %4
%12 = load double*, double** %3
%13 = ptrtoint double* %12 to i64
%14 = and i64 %13, 0
%15 = icmp eq i64 %14, 0
%16 = zext i1 %15 to i32
%17 = call i32 @assert(i32 %16)
%18 = load double*, double** %3
store double* %18, double** %3
%19 = load double*, double** %3
store double* %19, double** %5
%20 = load double*, double** %3
store double* %20, double** %6
store i32 0, i32* %7
br label %21
21: ; preds = %103, %2
%22 = load i32, i32* %7
%23 = load i32, i32* %4
%24 = sub nsw i32 %23, 2
%25 = icmp sle i32 %22, %24
br i1 %25, label %26, label %126
26: ; preds = %21
%27 = load double*, double** %5
store double* %27, double** %8
store i32 0, i32* %9
br label %28
28: ; preds = %33, %26
%29 = load i32, i32* %9
%30 = load i32, i32* %7
%31 = sub nsw i32 %30, 2
%32 = icmp sle i32 %29, %31
br i1 %32, label %33, label %79
33: ; preds = %28
%34 = load double*, double** %8
%35 = load double*, double** %6
%36 = load i32, i32* %9
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds double, double* %35, i64 %37
%39 = call i32 @_mm_load_sd(double* %38)
%40 = load double*, double** %6
%41 = load i32, i32* %9
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds double, double* %40, i64 %42
%44 = load i32, i32* %4
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double, double* %43, i64 %45
%47 = call i32 @_mm_loadh_pd(i32 %39, double* %46)
%48 = call i32 @_mm_storeu_pd(double* %34, i32 %47)
%49 = load double*, double** %8
%50 = load i32, i32* %4
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %49, i64 %51
%53 = load double*, double** %6
%54 = load i32, i32* %9
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %53, i64 %55
%57 = getelementptr inbounds double, double* %56, i64 1
%58 = call i32 @_mm_load_sd(double* %57)
%59 = load double*, double** %6
%60 = load i32, i32* %9
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %59, i64 %61
%63 = load i32, i32* %4
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %62, i64 %64
%66 = getelementptr inbounds double, double* %65, i64 1
%67 = call i32 @_mm_loadh_pd(i32 %58, double* %66)
%68 = call i32 @_mm_storeu_pd(double* %52, i32 %67)
%69 = load i32, i32* %4
%70 = load double*, double** %8
%71 = sext i32 %69 to i64
%72 = getelementptr inbounds double, double* %70, i64 %71
store double* %72, double** %8
%73 = load i32, i32* %4
%74 = load double*, double** %8
%75 = sext i32 %73 to i64
%76 = getelementptr inbounds double, double* %74, i64 %75
store double* %76, double** %8
%77 = load i32, i32* %9
%78 = add nsw i32 %77, 2
store i32 %78, i32* %9
br label %28
79: ; preds = %28
%80 = load i32, i32* %9
%81 = load i32, i32* %7
%82 = icmp slt i32 %80, %81
br i1 %82, label %83, label %103
83: ; preds = %79
%84 = load double*, double** %8
%85 = load double*, double** %6
%86 = load i32, i32* %9
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds double, double* %85, i64 %87
%89 = call i32 @_mm_load_sd(double* %88)
%90 = load double*, double** %6
%91 = load i32, i32* %9
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds double, double* %90, i64 %92
%94 = load i32, i32* %4
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %93, i64 %95
%97 = call i32 @_mm_loadh_pd(i32 %89, double* %96)
%98 = call i32 @_mm_storeu_pd(double* %84, i32 %97)
%99 = load i32, i32* %4
%100 = load double*, double** %8
%101 = sext i32 %99 to i64
%102 = getelementptr inbounds double, double* %100, i64 %101
store double* %102, double** %8
br label %103
103: ; preds = %83, %79
%104 = load double*, double** %6
%105 = load i32, i32* %4
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double, double* %104, i64 %106
%108 = load i32, i32* %7
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %107, i64 %109
%111 = load double, double* %110
%112 = load double*, double** %8
%113 = getelementptr inbounds double, double* %112, i64 1
store double %111, double* %113
%114 = load i32, i32* %4
%115 = load double*, double** %6
%116 = sext i32 %114 to i64
%117 = getelementptr inbounds double, double* %115, i64 %116
store double* %117, double** %6
%118 = load i32, i32* %4
%119 = load double*, double** %6
%120 = sext i32 %118 to i64
%121 = getelementptr inbounds double, double* %119, i64 %120
store double* %121, double** %6
%122 = load double*, double** %5
%123 = getelementptr inbounds double, double* %122, i64 2
store double* %123, double** %5
%124 = load i32, i32* %7
%125 = add nsw i32 %124, 2
store i32 %125, i32* %7
br label %21
126: ; preds = %21
%127 = load i32, i32* %7
%128 = load i32, i32* %4
%129 = icmp slt i32 %127, %128
br i1 %129, label %130, label %151
130: ; preds = %126
%131 = load double*, double** %5
store double* %131, double** %10
store i32 0, i32* %11
br label %132
132: ; preds = %136, %130
%133 = load i32, i32* %11
%134 = load i32, i32* %7
%135 = icmp slt i32 %133, %134
br i1 %135, label %136, label %150
136: ; preds = %132
%137 = load double*, double** %6
%138 = load i32, i32* %11
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds double, double* %137, i64 %139
%141 = load double, double* %140
%142 = load double*, double** %10
%143 = getelementptr inbounds double, double* %142, i64 0
store double %141, double* %143
%144 = load i32, i32* %4
%145 = load double*, double** %10
%146 = sext i32 %144 to i64
%147 = getelementptr inbounds double, double* %145, i64 %146
store double* %147, double** %10
%148 = load i32, i32* %11
%149 = add nsw i32 %148, 1
store i32 %149, i32* %11
br label %132
150: ; preds = %132
br label %151
151: ; preds = %150, %126
ret void
}

LLVM IR (-O2):
define void @matprod_fill_lower(double* noalias %0, i32 %1) {
%3 = tail call i32 @assert(i32 1)
%4 = add nsw i32 %1, -2
%5 = icmp slt i32 %1, 2
br i1 %5, label %121, label %6
6: ; preds = %2
%7 = zext i32 %1 to i64
br label %8
8: ; preds = %6, %45
%9 = phi i64 [ 0, %6 ], [ %53, %45 ]
%10 = phi double* [ %0, %6 ], [ %51, %45 ]
%11 = phi double* [ %0, %6 ], [ %52, %45 ]
%12 = add nsw i64 %9, -2
%13 = icmp eq i64 %9, 0
br i1 %13, label %33, label %14
14: ; preds = %8, %14
%15 = phi i64 [ %29, %14 ], [ 0, %8 ]
%16 = phi double* [ %28, %14 ], [ %11, %8 ]
%17 = getelementptr inbounds double, double* %10, i64 %15
%18 = tail call i32 @_mm_load_sd(double* %17)
%19 = getelementptr inbounds double, double* %17, i64 %7
%20 = tail call i32 @_mm_loadh_pd(i32 %18, double* %19)
%21 = tail call i32 @_mm_storeu_pd(double* %16, i32 %20)
%22 = getelementptr inbounds double, double* %16, i64 %7
%23 = getelementptr inbounds double, double* %17, i64 1
%24 = tail call i32 @_mm_load_sd(double* %23)
%25 = getelementptr inbounds double, double* %19, i64 1
%26 = tail call i32 @_mm_loadh_pd(i32 %24, double* %25)
%27 = tail call i32 @_mm_storeu_pd(double* %22, i32 %26)
%28 = getelementptr inbounds double, double* %22, i64 %7
%29 = add nuw i64 %15, 2
%30 = shl i64 %29, 32
%31 = ashr exact i64 %30, 32
%32 = icmp sgt i64 %31, %12
br i1 %32, label %33, label %14
33: ; preds = %14, %8
%34 = phi double* [ %11, %8 ], [ %28, %14 ]
%35 = phi i64 [ 0, %8 ], [ %29, %14 ]
%36 = and i64 %35, 4294967295
%37 = icmp ult i64 %36, %9
br i1 %37, label %38, label %45
38: ; preds = %33
%39 = getelementptr inbounds double, double* %10, i64 %36
%40 = tail call i32 @_mm_load_sd(double* %39)
%41 = getelementptr inbounds double, double* %39, i64 %7
%42 = tail call i32 @_mm_loadh_pd(i32 %40, double* %41)
%43 = tail call i32 @_mm_storeu_pd(double* %34, i32 %42)
%44 = getelementptr inbounds double, double* %34, i64 %7
br label %45
45: ; preds = %38, %33
%46 = phi double* [ %44, %38 ], [ %34, %33 ]
%47 = getelementptr inbounds double, double* %10, i64 %7
%48 = getelementptr inbounds double, double* %47, i64 %9
%49 = load double, double* %48
%50 = getelementptr inbounds double, double* %46, i64 1
store double %49, double* %50
%51 = getelementptr inbounds double, double* %47, i64 %7
%52 = getelementptr inbounds double, double* %11, i64 2
%53 = add nuw i64 %9, 2
%54 = trunc i64 %53 to i32
%55 = icmp slt i32 %4, %54
br i1 %55, label %56, label %8
56: ; preds = %45
%57 = trunc i64 %53 to i32
%58 = icmp slt i32 %57, %1
%59 = icmp ne i32 %57, 0
%60 = and i1 %58, %59
br i1 %60, label %61, label %121
61: ; preds = %56
%62 = sext i32 %1 to i64
%63 = and i64 %53, 4294967294
%64 = add nsw i64 %63, -1
%65 = and i64 %53, 6
%66 = icmp ult i64 %64, 7
br i1 %66, label %107, label %67
67: ; preds = %61
%68 = sub nsw i64 %63, %65
br label %69
69: ; preds = %69, %67
%70 = phi i64 [ 0, %67 ], [ %104, %69 ]
%71 = phi double* [ %52, %67 ], [ %103, %69 ]
%72 = phi i64 [ 0, %67 ], [ %105, %69 ]
%73 = getelementptr inbounds double, double* %51, i64 %70
%74 = load double, double* %73
store double %74, double* %71
%75 = getelementptr inbounds double, double* %71, i64 %62
%76 = or i64 %70, 1
%77 = getelementptr inbounds double, double* %51, i64 %76
%78 = load double, double* %77
store double %78, double* %75
%79 = getelementptr inbounds double, double* %75, i64 %62
%80 = or i64 %70, 2
%81 = getelementptr inbounds double, double* %51, i64 %80
%82 = load double, double* %81
store double %82, double* %79
%83 = getelementptr inbounds double, double* %79, i64 %62
%84 = or i64 %70, 3
%85 = getelementptr inbounds double, double* %51, i64 %84
%86 = load double, double* %85
store double %86, double* %83
%87 = getelementptr inbounds double, double* %83, i64 %62
%88 = or i64 %70, 4
%89 = getelementptr inbounds double, double* %51, i64 %88
%90 = load double, double* %89
store double %90, double* %87
%91 = getelementptr inbounds double, double* %87, i64 %62
%92 = or i64 %70, 5
%93 = getelementptr inbounds double, double* %51, i64 %92
%94 = load double, double* %93
store double %94, double* %91
%95 = getelementptr inbounds double, double* %91, i64 %62
%96 = or i64 %70, 6
%97 = getelementptr inbounds double, double* %51, i64 %96
%98 = load double, double* %97
store double %98, double* %95
%99 = getelementptr inbounds double, double* %95, i64 %62
%100 = or i64 %70, 7
%101 = getelementptr inbounds double, double* %51, i64 %100
%102 = load double, double* %101
store double %102, double* %99
%103 = getelementptr inbounds double, double* %99, i64 %62
%104 = add nuw nsw i64 %70, 8
%105 = add i64 %72, 8
%106 = icmp eq i64 %105, %68
br i1 %106, label %107, label %69
107: ; preds = %69, %61
%108 = phi i64 [ 0, %61 ], [ %104, %69 ]
%109 = phi double* [ %52, %61 ], [ %103, %69 ]
%110 = icmp eq i64 %65, 0
br i1 %110, label %121, label %111
111: ; preds = %107, %111
%112 = phi i64 [ %118, %111 ], [ %108, %107 ]
%113 = phi double* [ %117, %111 ], [ %109, %107 ]
%114 = phi i64 [ %119, %111 ], [ 0, %107 ]
%115 = getelementptr inbounds double, double* %51, i64 %112
%116 = load double, double* %115
store double %116, double* %113
%117 = getelementptr inbounds double, double* %113, i64 %62
%118 = add nuw nsw i64 %112, 1
%119 = add i64 %114, 1
%120 = icmp eq i64 %119, %65
br i1 %120, label %121, label %111
121: ; preds = %107, %111, %2, %56
ret void
}