#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*/ free_matrix2(double **);
int /*<<< orphan*/ memcpy(double *, double *, int);
double **new_matrix2(int, int);
void blur_matrix(double **dst, double **src, int n, int m) {
  double G[3] = {.6193, .0838, .0113};
  double **I = (dst == src ? new_matrix2(n, m) : dst);
  memcpy(I[0], src[0], n * m * sizeof(double));
  int i, j;
  for (i = 1; i < n - 1; i++)
    for (j = 1; j < m - 1; j++)
      I[i][j] = G[0] * src[i][j] +
                G[1] * (src[i + 1][j] + src[i - 1][j] + src[i][j + 1] +
                        src[i][j - 1]) +
                G[2] * (src[i + 1][j + 1] + src[i + 1][j - 1] +
                        src[i - 1][j + 1] + src[i - 1][j - 1]);
  if (dst == src) {
    memcpy(dst[0], I[0], n * m * sizeof(double));
    free_matrix2(I);
  }
}


x86 assembly (clang, -O0):
<blur_matrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    0xeb3(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    0xeb0(%rip),%rax
mov    %rax,-0x28(%rbp)
mov    0xead(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
jne    1189 <blur_matrix+0x59>
mov    -0x14(%rbp),%edi
mov    -0x18(%rbp),%esi
call   1050 <new_matrix2@plt>
mov    %rax,-0x48(%rbp)
jmp    1191 <blur_matrix+0x61>
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    133d <blur_matrix+0x20d>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    132a <blur_matrix+0x1fa>
movsd  -0x30(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11da <blur_matrix+0xaa>
jmp    132f <blur_matrix+0x1ff>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11c2 <blur_matrix+0x92>
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
jne    1376 <blur_matrix+0x246>
mov    -0x8(%rbp),%rax
mov    (%rax),%rdi
mov    -0x38(%rbp),%rax
mov    (%rax),%rsi
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
mov    -0x38(%rbp),%rdi
call   1040 <free_matrix2@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<blur_matrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %ecx,%r12d
mov    %rsi,%r14
mov    %rdi,%rax
mov    %rdi,0x40(%rsp)
cmp    %rsi,%rdi
mov    %rdx,%rbx
jne    1161 <blur_matrix+0x31>
mov    %edx,%edi
mov    %r12d,%esi
call   1050 <new_matrix2@plt>
mov    %rbx,%rdx
mov    %rax,0x38(%rsp)
mov    (%rax),%rdi
mov    (%r14),%rsi
imul   %r12d,%edx
shl    $0x3,%edx
mov    %edx,0x34(%rsp)
call   1030 <memcpy@plt>
mov    %rbx,%r9
cmp    $0x3,%r9d
jl     1403 <blur_matrix+0x2d3>
add    $0xffffffff,%r9d
lea    -0x1(%r12),%r10d
lea    0x1(%r10),%rax
mov    %rax,0x50(%rsp)
lea    -0x1(%r10),%r11
mov    %r11,%r13
and    $0xfffffffffffffffe,%r13
mov    %r11,%rax
or     $0x1,%rax
mov    %rax,0x48(%rsp)
mov    $0x1,%ecx
movsd  0xe71(%rip),%xmm0
movsd  0xe71(%rip),%xmm1
movsd  0xe71(%rip),%xmm2
movapd 0xe28(%rip),%xmm8
movapd 0xe2f(%rip),%xmm9
movapd 0xe36(%rip),%xmm10
mov    %r12,0x28(%rsp)
mov    %r14,0x20(%rsp)
mov    %r9,0x18(%rsp)
mov    %r10,0x10(%rsp)
mov    %r11,0x8(%rsp)
jmp    1223 <blur_matrix+0xf3>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rcx
mov    %rcx,%r15
mov    %r15,%rcx
cmp    %r9,%r15
je     1403 <blur_matrix+0x2d3>
cmp    $0x2,%r12d
jle    1210 <blur_matrix+0xe0>
lea    0x1(%rcx),%r15
mov    -0x8(%r14,%rcx,8),%rdx
mov    (%r14,%rcx,8),%rbp
mov    0x8(%r14,%rcx,8),%rax
mov    0x38(%rsp),%rsi
mov    (%rsi,%rcx,8),%rcx
mov    $0x1,%r8d
cmp    $0x2,%r11
jae    12e0 <blur_matrix+0x1b0>
lea    (%rcx,%r8,8),%rcx
lea    (%rdx,%r8,8),%rdx
lea    (%rax,%r8,8),%rax
lea    0x0(,%r8,8),%rbx
add    %rbp,%rbx
mov    %r10,%rbp
sub    %r8,%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rdi,8),%xmm3
addsd  (%rdx,%rdi,8),%xmm3
addsd  0x8(%rbx,%rdi,8),%xmm3
addsd  -0x8(%rbx,%rdi,8),%xmm3
movsd  0x8(%rax,%rdi,8),%xmm4
mulsd  %xmm0,%xmm3
movsd  (%rbx,%rdi,8),%xmm5
mulsd  %xmm1,%xmm5
addsd  -0x8(%rax,%rdi,8),%xmm4
addsd  0x8(%rdx,%rdi,8),%xmm4
addsd  %xmm3,%xmm5
addsd  -0x8(%rdx,%rdi,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
movsd  %xmm4,(%rcx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rbp
jne    1280 <blur_matrix+0x150>
jmp    1217 <blur_matrix+0xe7>
nopw   0x0(%rax,%rax,1)
lea    0x8(%rcx),%rdi
lea    (%rcx,%r10,8),%rbx
mov    0x50(%rsp),%rsi
lea    0x0(,%rsi,8),%r9
add    %rbp,%r9
lea    (%rax,%rsi,8),%r10
lea    (%rdx,%rsi,8),%r12
cmp    %r9,%rdi
setb   %sil
cmp    %rbx,%rbp
setb   %r14b
cmp    %r10,%rdi
setb   %r11b
cmp    %rbx,%rax
setb   %r9b
cmp    %r12,%rdi
setb   %dil
cmp    %rbx,%rdx
setb   %r10b
test   %r14b,%sil
jne    13e5 <blur_matrix+0x2b5>
and    %r9b,%r11b
jne    13e5 <blur_matrix+0x2b5>
and    %r10b,%dil
mov    0x28(%rsp),%r12
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%r11
jne    1254 <blur_matrix+0x124>
xor    %ebx,%ebx
movupd (%rax,%rbx,8),%xmm6
movupd 0x8(%rax,%rbx,8),%xmm7
movupd 0x10(%rax,%rbx,8),%xmm3
addpd  %xmm6,%xmm3
movupd (%rdx,%rbx,8),%xmm6
movupd 0x8(%rdx,%rbx,8),%xmm4
addpd  %xmm7,%xmm4
movupd 0x10(%rdx,%rbx,8),%xmm7
addpd  %xmm3,%xmm7
addpd  %xmm6,%xmm7
movupd 0x0(%rbp,%rbx,8),%xmm3
movupd 0x8(%rbp,%rbx,8),%xmm6
movupd 0x10(%rbp,%rbx,8),%xmm5
addpd  %xmm4,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm8,%xmm5
mulpd  %xmm9,%xmm6
addpd  %xmm5,%xmm6
mulpd  %xmm10,%xmm7
addpd  %xmm6,%xmm7
movupd %xmm7,0x8(%rcx,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r13
jne    1360 <blur_matrix+0x230>
mov    0x48(%rsp),%r8
cmp    %r13,%r11
je     1217 <blur_matrix+0xe7>
jmp    1254 <blur_matrix+0x124>
mov    0x28(%rsp),%r12
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%r11
jmp    1254 <blur_matrix+0x124>
mov    0x40(%rsp),%rax
cmp    %r14,%rax
je     141c <blur_matrix+0x2ec>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    (%rax),%rdi
mov    0x38(%rsp),%rbx
mov    (%rbx),%rsi
mov    0x34(%rsp),%edx
call   1030 <memcpy@plt>
mov    %rbx,%rdi
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_matrix2@plt>

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

LLVM IR (-O2):
define void @blur_matrix(double** %0, double** %1, i32 %2, i32 %3) {
%5 = icmp eq double** %0, %1
br i1 %5, label %6, label %8
6: ; preds = %4
%7 = tail call double** @new_matrix2(i32 %2, i32 %3)
br label %8
8: ; preds = %4, %6
%9 = phi double** [ %7, %6 ], [ %0, %4 ]
%10 = load double*, double** %9
%11 = load double*, double** %1
%12 = shl i32 %2, 3
%13 = mul i32 %12, %3
%14 = tail call i32 @memcpy(double* %10, double* %11, i32 %13)
%15 = icmp sgt i32 %2, 2
br i1 %15, label %16, label %143
16: ; preds = %8
%17 = add nsw i32 %2, -1
%18 = add i32 %3, -1
%19 = icmp sgt i32 %3, 2
%20 = zext i32 %17 to i64
%21 = zext i32 %18 to i64
%22 = add nuw nsw i64 %21, 1
%23 = add nsw i64 %21, -1
%24 = icmp ult i64 %23, 2
%25 = and i64 %23, -2
%26 = or i64 %23, 1
%27 = icmp eq i64 %23, %25
br label %28
28: ; preds = %16, %140
%29 = phi i64 [ 1, %16 ], [ %141, %140 ]
br i1 %19, label %32, label %30
30: ; preds = %28
%31 = add nuw nsw i64 %29, 1
br label %140
32: ; preds = %28
%33 = getelementptr inbounds double*, double** %1, i64 %29
%34 = load double*, double** %33
%35 = add nuw nsw i64 %29, 1
%36 = getelementptr inbounds double*, double** %1, i64 %35
%37 = load double*, double** %36
%38 = add nsw i64 %29, -1
%39 = getelementptr inbounds double*, double** %1, i64 %38
%40 = load double*, double** %39
%41 = getelementptr inbounds double*, double** %9, i64 %29
%42 = load double*, double** %41
br i1 %24, label %105, label %43
43: ; preds = %32
%44 = getelementptr double, double* %42, i64 1
%45 = getelementptr double, double* %42, i64 %21
%46 = getelementptr double, double* %34, i64 %22
%47 = getelementptr double, double* %37, i64 %22
%48 = getelementptr double, double* %40, i64 %22
%49 = icmp ult double* %44, %46
%50 = icmp ult double* %34, %45
%51 = and i1 %49, %50
%52 = icmp ult double* %44, %47
%53 = icmp ult double* %37, %45
%54 = and i1 %52, %53
%55 = or i1 %51, %54
%56 = icmp ult double* %44, %48
%57 = icmp ult double* %40, %45
%58 = and i1 %56, %57
%59 = or i1 %55, %58
br i1 %59, label %105, label %60
60: ; preds = %43, %60
%61 = phi i64 [ %102, %60 ], [ 0, %43 ]
%62 = or i64 %61, 1
%63 = getelementptr inbounds double, double* %34, i64 %62
%64 = bitcast double* %63 to <2 x double>*
%65 = load <2 x double>, <2 x double>* %64
%66 = getelementptr inbounds double, double* %37, i64 %62
%67 = bitcast double* %66 to <2 x double>*
%68 = load <2 x double>, <2 x double>* %67
%69 = getelementptr inbounds double, double* %40, i64 %62
%70 = bitcast double* %69 to <2 x double>*
%71 = load <2 x double>, <2 x double>* %70
%72 = fadd <2 x double> %68, %71
%73 = add i64 %61, 2
%74 = getelementptr inbounds double, double* %34, i64 %73
%75 = bitcast double* %74 to <2 x double>*
%76 = load <2 x double>, <2 x double>* %75
%77 = fadd <2 x double> %72, %76
%78 = getelementptr inbounds double, double* %34, i64 %61
%79 = bitcast double* %78 to <2 x double>*
%80 = load <2 x double>, <2 x double>* %79
%81 = fadd <2 x double> %77, %80
%82 = fmul <2 x double> %81, <double 0x3FB573EAB367A0F9, double 0x3FB573EAB367A0F9>
%83 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %65, <2 x double> <double 6.193000e-01, double 6.193000e-01>, <2 x double> %82)
%84 = getelementptr inbounds double, double* %37, i64 %73
%85 = bitcast double* %84 to <2 x double>*
%86 = load <2 x double>, <2 x double>* %85
%87 = getelementptr inbounds double, double* %37, i64 %61
%88 = bitcast double* %87 to <2 x double>*
%89 = load <2 x double>, <2 x double>* %88
%90 = fadd <2 x double> %86, %89
%91 = getelementptr inbounds double, double* %40, i64 %73
%92 = bitcast double* %91 to <2 x double>*
%93 = load <2 x double>, <2 x double>* %92
%94 = fadd <2 x double> %90, %93
%95 = getelementptr inbounds double, double* %40, i64 %61
%96 = bitcast double* %95 to <2 x double>*
%97 = load <2 x double>, <2 x double>* %96
%98 = fadd <2 x double> %94, %97
%99 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %98, <2 x double> <double 1.130000e-02, double 1.130000e-02>, <2 x double> %83)
%100 = getelementptr inbounds double, double* %42, i64 %62
%101 = bitcast double* %100 to <2 x double>*
store <2 x double> %99, <2 x double>* %101
%102 = add nuw i64 %61, 2
%103 = icmp eq i64 %102, %25
br i1 %103, label %104, label %60
104: ; preds = %60
br i1 %27, label %140, label %105
105: ; preds = %43, %32, %104
%106 = phi i64 [ 1, %43 ], [ 1, %32 ], [ %26, %104 ]
br label %107
107: ; preds = %105, %107
%108 = phi i64 [ %116, %107 ], [ %106, %105 ]
%109 = getelementptr inbounds double, double* %34, i64 %108
%110 = load double, double* %109
%111 = getelementptr inbounds double, double* %37, i64 %108
%112 = load double, double* %111
%113 = getelementptr inbounds double, double* %40, i64 %108
%114 = load double, double* %113
%115 = fadd double %112, %114
%116 = add nuw nsw i64 %108, 1
%117 = getelementptr inbounds double, double* %34, i64 %116
%118 = load double, double* %117
%119 = fadd double %115, %118
%120 = add nsw i64 %108, -1
%121 = getelementptr inbounds double, double* %34, i64 %120
%122 = load double, double* %121
%123 = fadd double %119, %122
%124 = fmul double %123, 0x3FB573EAB367A0F9
%125 = tail call double @llvm.fmuladd.f64(double %110, double 6.193000e-01, double %124)
%126 = getelementptr inbounds double, double* %37, i64 %116
%127 = load double, double* %126
%128 = getelementptr inbounds double, double* %37, i64 %120
%129 = load double, double* %128
%130 = fadd double %127, %129
%131 = getelementptr inbounds double, double* %40, i64 %116
%132 = load double, double* %131
%133 = fadd double %130, %132
%134 = getelementptr inbounds double, double* %40, i64 %120
%135 = load double, double* %134
%136 = fadd double %133, %135
%137 = tail call double @llvm.fmuladd.f64(double %136, double 1.130000e-02, double %125)
%138 = getelementptr inbounds double, double* %42, i64 %108
store double %137, double* %138
%139 = icmp eq i64 %116, %21
br i1 %139, label %140, label %107
140: ; preds = %107, %104, %30
%141 = phi i64 [ %31, %30 ], [ %35, %104 ], [ %35, %107 ]
%142 = icmp eq i64 %141, %20
br i1 %142, label %143, label %28
143: ; preds = %140, %8
br i1 %5, label %144, label %149
144: ; preds = %143
%145 = load double*, double** %0
%146 = load double*, double** %9
%147 = tail call i32 @memcpy(double* %145, double* %146, i32 %13)
%148 = tail call i32 @free_matrix2(double** %9)
br label %149
149: ; preds = %144, %143
ret void
}