#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 */
int /*<<< orphan*/ memset(double *, int /*<<< orphan*/, long);
void sp2fc(const double *sa, double *fa, const double *poli, long nlev,
           long nlat, long nfc, long nt) {
  long lev, jmm, jfc, lat, nsp2;
  double sar, sai;
  double *fal;
  double *restrict far, *restrict fai;
  const double *restrict pol;
  const double *restrict sal;
  nsp2 = (nt + 1) * (nt + 2);
  for (lev = 0; lev < nlev; lev++) {
    pol = poli;
    fal = fa + lev * nfc * nlat;
    sal = sa + lev * nsp2;
    memset(fal, 0, nfc * nlat * sizeof(double));
    for (jmm = 0; jmm <= nt; jmm++) {
      for (jfc = jmm; jfc <= nt; jfc++) {
        sar = *sal++;
        sai = *sal++;
        far = fal;
        fai = fal + nlat;
        for (lat = 0; lat < nlat; lat++) {
          far[lat] += pol[lat] * sar;
          fai[lat] += pol[lat] * sai;
        }
        pol += nlat;
      }
      fal += 2 * nlat;
    }
  }
}


x86 assembly (clang, -O0):
<sp2fc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x10(%rbp),%rax
add    $0x1,%rax
mov    0x10(%rbp),%rcx
add    $0x2,%rcx
imul   %rcx,%rax
mov    %rax,-0x58(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    132a <sp2fc+0x21a>
mov    -0x18(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x30(%rbp),%rcx
imul   -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x58(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x30(%rbp),%rdx
imul   -0x28(%rbp),%rdx
shl    $0x3,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    0x10(%rbp),%rax
jg     1314 <sp2fc+0x204>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    0x10(%rbp),%rax
jg     12ef <sp2fc+0x1df>
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x90(%rbp)
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    12c8 <sp2fc+0x1b8>
mov    -0x88(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x88(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    -0x80(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    124b <sp2fc+0x13b>
mov    -0x28(%rbp),%rax
shl    $0x3,%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    11de <sp2fc+0xce>
mov    -0x28(%rbp),%rax
shl    $0x1,%rax
shl    $0x3,%rax
add    -0x70(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11c8 <sp2fc+0xb8>
jmp    1319 <sp2fc+0x209>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1157 <sp2fc+0x47>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sp2fc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %rdx,0x68(%rsp)
mov    %rsi,0x8(%rsp)
mov    %rdi,0x60(%rsp)
mov    %rcx,0x80(%rsp)
test   %rcx,%rcx
jle    15d0 <sp2fc+0x4c0>
mov    %r8,%rbx
mov    0x120(%rsp),%r15
lea    0x1(%r15),%rcx
lea    0x2(%r15),%rax
imul   %rax,%rcx
mov    %rcx,0x58(%rsp)
imul   %r8,%r9
mov    %r9,0x78(%rsp)
lea    0x0(,%r9,8),%rdx
lea    (%r8,%r8,1),%rax
mov    %rax,0x40(%rsp)
lea    -0x2(%r8),%rax
mov    %rax,0xc8(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0xb8(%rsp)
mov    %rcx,%rax
mov    %rcx,0xc0(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xa8(%rsp)
mov    %r8,%r13
neg    %r13
lea    0x0(,%r8,8),%r14
mov    0x8(%rsp),%rax
lea    0x10(%rax),%rcx
mov    %rcx,0x30(%rsp)
mov    %r8,%rcx
shl    $0x4,%rcx
mov    %rcx,0x88(%rsp)
lea    (%rax,%r8,8),%rcx
add    $0x10,%rcx
mov    %rcx,0x28(%rsp)
lea    (%rax,%r8,8),%rcx
mov    %rcx,0x20(%rsp)
xor    %ecx,%ecx
mov    %rax,0x18(%rsp)
mov    %r13,0xb0(%rsp)
mov    %rdx,0x70(%rsp)
mov    %r14,0x10(%rsp)
jmp    1240 <sp2fc+0x130>
nop
mov    0x38(%rsp),%rcx
add    $0x1,%rcx
mov    0x70(%rsp),%rdx
add    %rdx,0x30(%rsp)
add    %rdx,0x28(%rsp)
add    %rdx,0x20(%rsp)
add    %rdx,0x18(%rsp)
cmp    0x80(%rsp),%rcx
je     15d0 <sp2fc+0x4c0>
mov    0x78(%rsp),%rsi
mov    %rcx,0x38(%rsp)
imul   %rcx,%rsi
mov    0x8(%rsp),%rax
mov    %rsi,%rbp
lea    (%rax,%rsi,8),%rdi
xor    %esi,%esi
call   1030 <memset@plt>
test   %r15,%r15
js     1210 <sp2fc+0x100>
mov    0x40(%rsp),%rax
add    %rbp,%rax
mov    %rax,0x90(%rsp)
add    %rbx,%rbp
mov    %rbp,0x98(%rsp)
mov    0x58(%rsp),%rax
imul   0x38(%rsp),%rax
mov    0x60(%rsp),%rcx
lea    (%rcx,%rax,8),%r9
mov    0x18(%rsp),%rdx
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0x68(%rsp),%r10
xor    %r8d,%r8d
mov    %r10,%rax
jmp    12ee <sp2fc+0x1de>
nopl   0x0(%rax,%rax,1)
mov    0x88(%rsp),%rbp
add    %rbp,%rdx
mov    0xa0(%rsp),%rcx
lea    0x1(%rcx),%r8
add    %rbp,0x48(%rsp)
add    %rbp,%rdi
add    %rbp,%rsi
mov    %rax,%r10
cmp    %r15,%rcx
je     1210 <sp2fc+0x100>
mov    0x40(%rsp),%rcx
imul   %r8,%rcx
mov    0x98(%rsp),%rbp
add    %rcx,%rbp
mov    %r8,%r11
mov    0x8(%rsp),%r8
lea    (%r8,%rbp,8),%rbp
mov    %rbp,0xd8(%rsp)
add    0x90(%rsp),%rcx
lea    (%r8,%rcx,8),%rcx
mov    %rcx,0xd0(%rsp)
lea    (%rdx,%rbx,8),%rcx
mov    %rcx,0x50(%rsp)
mov    %r10,0xe0(%rsp)
lea    0x10(%r10),%r12
xor    %r10d,%r10d
mov    %r11,0xa0(%rsp)
mov    %r11,%r8
jmp    136e <sp2fc+0x25e>
nop
add    $0x10,%r9
add    %r14,%rax
lea    0x1(%r8),%rcx
add    $0x1,%r10
add    %r14,%r12
cmp    %r15,%r8
mov    %rcx,%r8
jge    12c0 <sp2fc+0x1b0>
test   %rbx,%rbx
jle    1350 <sp2fc+0x240>
movsd  (%r9),%xmm0
movsd  0x8(%r9),%xmm1
cmp    $0x1,%rbx
jne    1390 <sp2fc+0x280>
xor    %ebp,%ebp
jmp    1520 <sp2fc+0x410>
nopl   0x0(%rax,%rax,1)
mov    %r10,%rcx
imul   %rbx,%rcx
add    %rbx,%rcx
mov    0xe0(%rsp),%rbp
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
mov    0xd8(%rsp),%r11
cmp    %rcx,%r11
setb   %bpl
cmp    0xd0(%rsp),%rax
setb   %r14b
cmp    %rcx,%rdx
setb   %cl
cmp    %r11,%rax
setb   %r11b
test   %r14b,%bpl
jne    1410 <sp2fc+0x300>
mov    $0x0,%ebp
and    %r11b,%cl
mov    0x10(%rsp),%r14
jne    1520 <sp2fc+0x410>
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
cmpq   $0x2,0xc8(%rsp)
jae    141c <sp2fc+0x30c>
xor    %r14d,%r14d
jmp    14a8 <sp2fc+0x398>
xor    %ebp,%ebp
mov    0x10(%rsp),%r14
jmp    1520 <sp2fc+0x410>
mov    0xa8(%rsp),%r13
mov    0x48(%rsp),%r11
mov    %r12,%r15
xor    %r14d,%r14d
nop
movupd -0x10(%r15),%xmm4
movupd -0x10(%r11),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,-0x10(%r11)
movupd -0x10(%r15),%xmm4
movupd -0x10(%rdi,%r14,8),%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,-0x10(%rdi,%r14,8)
movupd (%r15),%xmm4
movupd (%r11),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%r11)
movupd (%r15),%xmm4
movupd (%rdi,%r14,8),%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%rdi,%r14,8)
add    $0x4,%r14
add    $0x20,%r15
add    $0x20,%r11
add    $0xfffffffffffffffe,%r13
jne    1430 <sp2fc+0x320>
testb  $0x1,0xc0(%rsp)
01
mov    0x120(%rsp),%r15
mov    0xb0(%rsp),%r13
je     14fb <sp2fc+0x3eb>
movupd (%rax,%r14,8),%xmm4
movupd (%rdx,%r14,8),%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%rdx,%r14,8)
movupd (%rax,%r14,8),%xmm3
mov    0x50(%rsp),%rcx
movupd (%rcx,%r14,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm4,%xmm3
movupd %xmm3,(%rcx,%r14,8)
mov    0xb8(%rsp),%rcx
mov    %rcx,%rbp
cmp    %rbx,%rcx
mov    0x10(%rsp),%r14
je     1350 <sp2fc+0x240>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbp,%rcx
test   $0x1,%bl
je     155a <sp2fc+0x44a>
movsd  (%rax,%rbp,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdx,%rbp,8),%xmm2
movsd  %xmm2,(%rdx,%rbp,8)
movsd  (%rax,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
mov    0x50(%rsp),%rcx
addsd  (%rcx,%rbp,8),%xmm2
movsd  %xmm2,(%rcx,%rbp,8)
mov    %rbp,%rcx
or     $0x1,%rcx
not    %rbp
cmp    %r13,%rbp
je     1350 <sp2fc+0x240>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdx,%rcx,8),%xmm2
movsd  %xmm2,(%rdx,%rcx,8)
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rsi,%rcx,8),%xmm2
movsd  %xmm2,(%rsi,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  0x8(%rdx,%rcx,8),%xmm2
movsd  %xmm2,0x8(%rdx,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x8(%rsi,%rcx,8),%xmm2
movsd  %xmm2,0x8(%rsi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    1570 <sp2fc+0x460>
jmp    1350 <sp2fc+0x240>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @sp2fc(double* %0, double* %1, double* %2, i64 %3, i64 %4, i64 %5, i64 %6) {
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca double
%21 = alloca double
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
store double* %0, double** %8
store double* %1, double** %9
store double* %2, double** %10
store i64 %3, i64* %11
store i64 %4, i64* %12
store i64 %5, i64* %13
store i64 %6, i64* %14
%27 = load i64, i64* %14
%28 = add nsw i64 %27, 1
%29 = load i64, i64* %14
%30 = add nsw i64 %29, 2
%31 = mul nsw i64 %28, %30
store i64 %31, i64* %19
store i64 0, i64* %15
br label %32
32: ; preds = %121, %7
%33 = load i64, i64* %15
%34 = load i64, i64* %11
%35 = icmp slt i64 %33, %34
br i1 %35, label %36, label %124
36: ; preds = %32
%37 = load double*, double** %10
store double* %37, double** %25
%38 = load double*, double** %9
%39 = load i64, i64* %15
%40 = load i64, i64* %13
%41 = mul nsw i64 %39, %40
%42 = load i64, i64* %12
%43 = mul nsw i64 %41, %42
%44 = getelementptr inbounds double, double* %38, i64 %43
store double* %44, double** %22
%45 = load double*, double** %8
%46 = load i64, i64* %15
%47 = load i64, i64* %19
%48 = mul nsw i64 %46, %47
%49 = getelementptr inbounds double, double* %45, i64 %48
store double* %49, double** %26
%50 = load double*, double** %22
%51 = load i64, i64* %13
%52 = load i64, i64* %12
%53 = mul nsw i64 %51, %52
%54 = mul i64 %53, 8
%55 = call i32 @memset(double* %50, i32 0, i64 %54)
store i64 0, i64* %16
br label %56
56: ; preds = %117, %36
%57 = load i64, i64* %16
%58 = load i64, i64* %14
%59 = icmp sle i64 %57, %58
br i1 %59, label %60, label %120
60: ; preds = %56
%61 = load i64, i64* %16
store i64 %61, i64* %17
br label %62
62: ; preds = %109, %60
%63 = load i64, i64* %17
%64 = load i64, i64* %14
%65 = icmp sle i64 %63, %64
br i1 %65, label %66, label %112
66: ; preds = %62
%67 = load double*, double** %26
%68 = getelementptr inbounds double, double* %67, i32 1
store double* %68, double** %26
%69 = load double, double* %67
store double %69, double* %20
%70 = load double*, double** %26
%71 = getelementptr inbounds double, double* %70, i32 1
store double* %71, double** %26
%72 = load double, double* %70
store double %72, double* %21
%73 = load double*, double** %22
store double* %73, double** %23
%74 = load double*, double** %22
%75 = load i64, i64* %12
%76 = getelementptr inbounds double, double* %74, i64 %75
store double* %76, double** %24
store i64 0, i64* %18
br label %77
77: ; preds = %102, %66
%78 = load i64, i64* %18
%79 = load i64, i64* %12
%80 = icmp slt i64 %78, %79
br i1 %80, label %81, label %105
81: ; preds = %77
%82 = load double*, double** %25
%83 = load i64, i64* %18
%84 = getelementptr inbounds double, double* %82, i64 %83
%85 = load double, double* %84
%86 = load double, double* %20
%87 = load double*, double** %23
%88 = load i64, i64* %18
%89 = getelementptr inbounds double, double* %87, i64 %88
%90 = load double, double* %89
%91 = call double @llvm.fmuladd.f64(double %85, double %86, double %90)
store double %91, double* %89
%92 = load double*, double** %25
%93 = load i64, i64* %18
%94 = getelementptr inbounds double, double* %92, i64 %93
%95 = load double, double* %94
%96 = load double, double* %21
%97 = load double*, double** %24
%98 = load i64, i64* %18
%99 = getelementptr inbounds double, double* %97, i64 %98
%100 = load double, double* %99
%101 = call double @llvm.fmuladd.f64(double %95, double %96, double %100)
store double %101, double* %99
br label %102
102: ; preds = %81
%103 = load i64, i64* %18
%104 = add nsw i64 %103, 1
store i64 %104, i64* %18
br label %77
105: ; preds = %77
%106 = load i64, i64* %12
%107 = load double*, double** %25
%108 = getelementptr inbounds double, double* %107, i64 %106
store double* %108, double** %25
br label %109
109: ; preds = %105
%110 = load i64, i64* %17
%111 = add nsw i64 %110, 1
store i64 %111, i64* %17
br label %62
112: ; preds = %62
%113 = load i64, i64* %12
%114 = mul nsw i64 2, %113
%115 = load double*, double** %22
%116 = getelementptr inbounds double, double* %115, i64 %114
store double* %116, double** %22
br label %117
117: ; preds = %112
%118 = load i64, i64* %16
%119 = add nsw i64 %118, 1
store i64 %119, i64* %16
br label %56
120: ; preds = %56
br label %121
121: ; preds = %120
%122 = load i64, i64* %15
%123 = add nsw i64 %122, 1
store i64 %123, i64* %15
br label %32
124: ; preds = %32
ret void
}

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