#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*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int const, int const,
                           int const, int const);
int /*<<< orphan*/ stderr;
void mm(double x[], const int xx, const int xy, double y[], const int yx,
        const int yy, double a[]) {
  int i, j, k;
  double *wx, *wy;
  if (xx == 1 && xy == 1) {
    for (i = yx * yy - 1; i >= 0; i--)
      a[i] = x[0] * y[i];
    return;
  }
  if (xx != yy) {
    fprintf(stderr, "Invalid matrix size x= %d*%d,y= %d*%d\n", xx, xy, yx, yy);
    exit(1);
  }
  wx = x;
  for (i = 0; i < xy; i++) {
    for (j = 0; j < yx; j++) {
      wy = &y[j];
      *a = 0;
      for (k = 0; k < xx; k++) {
        *a += *wx * *wy;
        wx++;
        wy += yx;
      }
      wx -= xx;
      a++;
    }
    wx += xx;
  }
  return;
}


x86 assembly (clang, -O0):
<mm>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
cmpl   $0x1,-0xc(%rbp)
jne    11a2 <mm+0x82>
cmpl   $0x1,-0x10(%rbp)
jne    11a2 <mm+0x82>
mov    -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     119d <mm+0x7d>
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1163 <mm+0x43>
jmp    12e9 <mm+0x1c9>
mov    -0xc(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     11db <mm+0xbb>
mov    0x2e2b(%rip),%rax
mov    (%rax),%edi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x20(%rbp),%r9d
lea    0xe34(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12e4 <mm+0x1c4>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12c1 <mm+0x1a1>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    128d <mm+0x16d>
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm2
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    122e <mm+0x10e>
mov    -0xc(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,0x10(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11fd <mm+0xdd>
mov    -0xc(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ea <mm+0xca>
jmp    12e9 <mm+0x1c9>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8d,0xc(%rsp)
mov    %edx,%r10d
mov    %esi,%r15d
mov    0x60(%rsp),%rsi
cmp    $0x1,%r15d
jne    123e <mm+0x11e>
cmp    $0x1,%r10d
jne    123e <mm+0x11e>
imul   0xc(%rsp),%r9d
test   %r9d,%r9d
jle    13fb <mm+0x2db>
mov    %r9d,%r14d
cmp    $0x4,%r9d
jb     13d2 <mm+0x2b2>
lea    -0x1(%r14),%rbx
add    $0xffffffff,%r9d
cmp    %ebx,%r9d
jb     13d2 <mm+0x2b2>
mov    %rbx,%rdx
shr    $0x20,%rdx
jne    13d2 <mm+0x2b2>
lea    0x8(%rdi),%r8
mov    %r14,%rax
neg    %rax
add    %r9,%rax
add    $0x1,%rax
lea    (%rsi,%rax,8),%rbp
lea    (%rsi,%r9,8),%rdx
add    $0x8,%rdx
lea    (%rcx,%rax,8),%r10
cmp    %rdi,%rdx
seta   %r11b
lea    (%rcx,%r9,8),%rax
add    $0x8,%rax
cmp    %r8,%rbp
setb   %r8b
cmp    %rax,%rbp
setb   %al
cmp    %rdx,%r10
setb   %dl
test   %r8b,%r11b
jne    13d2 <mm+0x2b2>
and    %dl,%al
jne    13d2 <mm+0x2b2>
mov    %r14d,%r8d
and    $0xfffffffc,%r8d
mov    %r14d,%edx
and    $0x3,%edx
movsd  (%rdi),%xmm0
unpcklpd %xmm0,%xmm0
shufpd $0x1,%xmm0,%xmm0
mov    %r8,%rbp
nopl   (%rax)
mov    %ebx,%eax
shl    $0x3,%rax
movupd -0x18(%rcx,%rax,1),%xmm1
movupd -0x8(%rcx,%rax,1),%xmm2
mulpd  %xmm0,%xmm2
movupd %xmm2,-0x8(%rsi,%rax,1)
mulpd  %xmm0,%xmm1
movupd %xmm1,-0x18(%rsi,%rax,1)
add    $0xfffffffffffffffc,%rbx
add    $0xfffffffffffffffc,%rbp
jne    1200 <mm+0xe0>
cmp    %r14,%r8
jne    13d5 <mm+0x2b5>
jmp    13fb <mm+0x2db>
cmp    %r9d,%r15d
jne    140a <mm+0x2ea>
test   %r10d,%r10d
jle    13fb <mm+0x2db>
mov    0xc(%rsp),%r8d
movslq %r8d,%r14
movslq %r15d,%rdx
mov    %rdx,%rbx
mov    %rdx,0x18(%rsp)
neg    %rdx
mov    %r8d,%r11d
lea    -0x1(%r15),%ebx
mov    %r15d,%r12d
and    $0x3,%r12d
mov    %r15d,%ebp
and    $0xfffffffc,%ebp
mov    %ebp,0x14(%rsp)
mov    %r14,%rax
shl    $0x5,%rax
shl    $0x3,%r14
xor    %ebp,%ebp
mov    %r10d,0x10(%rsp)
jmp    12bf <mm+0x19f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x18(%rsp),%rbp
lea    (%rdi,%rbp,8),%rdi
mov    0x20(%rsp),%rbp
add    $0x1,%ebp
mov    0x10(%rsp),%r10d
cmp    %r10d,%ebp
je     13fb <mm+0x2db>
cmpl   $0x0,0xc(%rsp)
mov    %rbp,0x20(%rsp)
jle    12a0 <mm+0x180>
mov    %rcx,%r13
xor    %r9d,%r9d
jmp    12f5 <mm+0x1d5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdi,%rdx,8),%rdi
add    $0x8,%rsi
add    $0x1,%r9
add    $0x8,%r13
cmp    %r11,%r9
je     12a0 <mm+0x180>
movq   $0x0,(%rsi)
test   %r15d,%r15d
jle    12e0 <mm+0x1c0>
cmp    $0x3,%ebx
jae    1320 <mm+0x200>
lea    (%rcx,%r9,8),%r10
xorpd  %xmm0,%xmm0
test   %r12d,%r12d
jne    13a2 <mm+0x282>
jmp    12e0 <mm+0x1c0>
nopl   0x0(%rax)
mov    %r15,%rbp
xorpd  %xmm0,%xmm0
mov    0x14(%rsp),%r15d
mov    %r13,%r8
nop
mov    %r8,%r10
movsd  (%rdi),%xmm1
mulsd  (%r8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi)
movsd  0x8(%rdi),%xmm0
add    %r14,%r8
mulsd  (%r10,%r14,1),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsi)
movsd  0x10(%rdi),%xmm1
mulsd  (%r14,%r8,1),%xmm1
add    %r14,%r8
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi)
movsd  0x18(%rdi),%xmm0
mulsd  (%r14,%r8,1),%xmm0
add    %r14,%r8
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsi)
add    $0x20,%rdi
add    %r14,%r8
add    $0xfffffffc,%r15d
jne    1330 <mm+0x210>
add    %rax,%r10
mov    %rbp,%r15
test   %r12d,%r12d
je     12e0 <mm+0x1c0>
mov    %r12d,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi),%xmm1
mulsd  (%r10),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rsi)
add    $0x8,%rdi
add    %r14,%r10
add    $0xffffffff,%ebp
jne    13b0 <mm+0x290>
jmp    12e0 <mm+0x1c0>
mov    %r14,%rdx
add    $0x1,%rdx
nopl   0x0(%rax)
lea    -0x2(%rdx),%eax
movsd  (%rdi),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0xffffffffffffffff,%rdx
cmp    $0x1,%rdx
ja     13e0 <mm+0x2c0>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2bcf(%rip),%rax
mov    (%rax),%edi
lea    0xbe6(%rip),%rsi
mov    %r15d,%edx
mov    %r10d,%ecx
mov    0xc(%rsp),%r8d
call   1030 <fprintf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>

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

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