#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*/ dgemm(char *, char *, int *, int *, int *, double *,
                         double *, int *, double *, int *, double *, double *,
                         int *);
void pairdist_squared_rows(double *vectsX, double *normsqrX, double *vectsY,
                           double *normsqrY, double *dists, int M, int N,
                           int D) {
  int m, n;
  char chn = 'N', cht = 'T';
  double minus2 = -2.0, one = 1.0;
  for (n = 0; n < N; n++) {
    for (m = 0; m < M; m++) {
      dists[m + n * M] = normsqrX[m] + normsqrY[n];
    }
  }
  dgemm(&chn, &cht, &M, &N, &D, &minus2, vectsX, &M, vectsY, &N, &one, dists,
        &M);
  if ((vectsX == vectsY) && (M == N)) {
    for (n = 0; n < N; n++) {
      dists[n + n * N] = 0;
    }
  }
}


x86 assembly (clang, -O0):
<pairdist_squared_rows>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0x88,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9d,-0x44(%rbp)
movb   $0x4e,-0x4d(%rbp)
movb   $0x54,-0x4e(%rbp)
movsd  0xeba(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xea5(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    11d9 <pairdist_squared_rows+0xc9>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    11c6 <pairdist_squared_rows+0xb6>
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    117a <pairdist_squared_rows+0x6a>
jmp    11cb <pairdist_squared_rows+0xbb>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1167 <pairdist_squared_rows+0x57>
mov    -0x20(%rbp),%r15
mov    -0x30(%rbp),%r14
mov    -0x40(%rbp),%r10
lea    -0x4d(%rbp),%rdi
lea    -0x4e(%rbp),%rsi
lea    -0x44(%rbp),%rax
lea    0x10(%rbp),%rbx
lea    0x18(%rbp),%r8
lea    -0x58(%rbp),%r9
lea    -0x60(%rbp),%r11
mov    %rax,%rdx
mov    %rbx,%rcx
mov    %r15,(%rsp)
mov    %rax,0x8(%rsp)
mov    %r14,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
call   1030 <dgemm@plt>
mov    -0x20(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    1289 <pairdist_squared_rows+0x179>
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jne    1289 <pairdist_squared_rows+0x179>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1284 <pairdist_squared_rows+0x174>
mov    -0x40(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    124f <pairdist_squared_rows+0x13f>
jmp    1289 <pairdist_squared_rows+0x179>
add    $0x88,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<pairdist_squared_rows>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r8,%r12
mov    %rdx,0x30(%rsp)
mov    %rdi,0x28(%rsp)
mov    0xb0(%rsp),%eax
mov    %r9d,0xc(%rsp)
movb   $0x4e,0xb(%rsp)
movb   $0x54,0xa(%rsp)
movabs $0xc000000000000000,%rdx
mov    %rdx,0x70(%rsp)
movabs $0x3ff0000000000000,%rdx
mov    %rdx,0x68(%rsp)
test   %eax,%eax
jle    13c5 <pairdist_squared_rows+0x2b5>
movslq %r9d,%r15
mov    %eax,%ebp
mov    %r9d,%edi
lea    (%rsi,%rdi,8),%rax
mov    %rax,0x58(%rsp)
mov    %edi,%eax
and    $0xfffffffc,%eax
mov    %rax,0x50(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x48(%rsp)
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rbx,%rax
mov    %rbx,0x40(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0x38(%rsp)
mov    %rdi,%rax
neg    %rax
mov    %rax,0x60(%rsp)
lea    0x30(%r12),%r14
lea    0x0(,%r15,8),%rdx
lea    0x8(%r12),%r13
xor    %r11d,%r11d
mov    %r15,0x20(%rsp)
mov    %rbp,0x18(%rsp)
mov    %rdx,0x10(%rsp)
jmp    11f3 <pairdist_squared_rows+0xe3>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
add    %rdx,%r14
add    %rdx,%r13
cmp    %rbp,%r11
je     13c5 <pairdist_squared_rows+0x2b5>
test   %r9d,%r9d
jle    11e0 <pairdist_squared_rows+0xd0>
mov    %r11,%r8
imul   %r15,%r8
cmp    $0x4,%r9d
jae    1210 <pairdist_squared_rows+0x100>
xor    %r10d,%r10d
jmp    1340 <pairdist_squared_rows+0x230>
nopl   (%rax)
lea    (%r8,%rdi,1),%rax
lea    (%r12,%r8,8),%rbx
mov    %r12,%r15
lea    (%r12,%rax,8),%rbp
lea    (%rcx,%r11,8),%rdx
lea    (%rcx,%r11,8),%rax
add    $0x8,%rax
cmp    0x58(%rsp),%rbx
setb   %r10b
cmp    %rsi,%rbp
seta   %r12b
cmp    %rax,%rbx
setb   %al
cmp    %rbp,%rdx
setb   %bl
test   %r12b,%r10b
jne    1323 <pairdist_squared_rows+0x213>
mov    $0x0,%r10d
and    %bl,%al
mov    %r15,%r12
mov    0x20(%rsp),%r15
mov    0x18(%rsp),%rbp
mov    0x10(%rsp),%rdx
jne    1340 <pairdist_squared_rows+0x230>
cmpq   $0x0,0x48(%rsp)
je     13b3 <pairdist_squared_rows+0x2a3>
movsd  (%rcx,%r11,8),%xmm0
unpcklpd %xmm0,%xmm0
mov    0x38(%rsp),%rax
xor    %ebx,%ebx
nopl   (%rax)
movupd (%rsi,%rbx,8),%xmm1
movupd 0x10(%rsi,%rbx,8),%xmm2
addpd  %xmm0,%xmm1
addpd  %xmm0,%xmm2
movupd %xmm1,-0x30(%r14,%rbx,8)
movupd %xmm2,-0x20(%r14,%rbx,8)
movupd 0x20(%rsi,%rbx,8),%xmm1
movupd 0x30(%rsi,%rbx,8),%xmm2
addpd  %xmm0,%xmm1
addpd  %xmm0,%xmm2
movupd %xmm1,-0x10(%r14,%rbx,8)
movupd %xmm2,(%r14,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    1290 <pairdist_squared_rows+0x180>
testb  $0x1,0x40(%rsp)
je     1310 <pairdist_squared_rows+0x200>
movupd (%rsi,%rbx,8),%xmm0
movupd 0x10(%rsi,%rbx,8),%xmm1
movsd  (%rcx,%r11,8),%xmm2
unpcklpd %xmm2,%xmm2
addpd  %xmm2,%xmm0
addpd  %xmm1,%xmm2
add    %r8,%rbx
movupd %xmm0,(%r12,%rbx,8)
movupd %xmm2,0x10(%r12,%rbx,8)
mov    0x50(%rsp),%rax
mov    %rax,%r10
cmp    %rdi,%rax
je     11e0 <pairdist_squared_rows+0xd0>
jmp    1340 <pairdist_squared_rows+0x230>
xor    %r10d,%r10d
mov    %r15,%r12
mov    0x20(%rsp),%r15
mov    0x18(%rsp),%rbp
mov    0x10(%rsp),%rdx
nopl   0x0(%rax,%rax,1)
mov    %r10,%rbx
test   $0x1,%dil
je     1365 <pairdist_squared_rows+0x255>
movsd  (%rsi,%r10,8),%xmm0
addsd  (%rcx,%r11,8),%xmm0
add    %r10,%r8
movsd  %xmm0,(%r12,%r8,8)
mov    %r10,%rbx
or     $0x1,%rbx
not    %r10
cmp    0x60(%rsp),%r10
je     11e0 <pairdist_squared_rows+0xd0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rbx,8),%xmm0
addsd  (%rcx,%r11,8),%xmm0
movsd  %xmm0,-0x8(%r13,%rbx,8)
movsd  0x8(%rsi,%rbx,8),%xmm0
addsd  (%rcx,%r11,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rdi
jne    1380 <pairdist_squared_rows+0x270>
jmp    11e0 <pairdist_squared_rows+0xd0>
xor    %ebx,%ebx
testb  $0x1,0x40(%rsp)
jne    12e3 <pairdist_squared_rows+0x1d3>
jmp    1310 <pairdist_squared_rows+0x200>
sub    $0x8,%rsp
lea    0x14(%rsp),%rdx
lea    0x70(%rsp),%rax
lea    0xb8(%rsp),%rcx
lea    0x13(%rsp),%rdi
lea    0x12(%rsp),%rsi
lea    0xc0(%rsp),%r8
lea    0x78(%rsp),%r9
push   %rdx
push   %r12
push   %rax
push   %rcx
mov    0x58(%rsp),%rbx
push   %rbx
push   %rdx
mov    0x60(%rsp),%rbp
push   %rbp
call   1030 <dgemm@plt>
add    $0x40,%rsp
cmp    %rbx,%rbp
je     1421 <pairdist_squared_rows+0x311>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0xc(%rsp),%r8d
mov    0xb0(%rsp),%eax
cmp    %eax,%r8d
jne    1412 <pairdist_squared_rows+0x302>
test   %eax,%eax
jle    1412 <pairdist_squared_rows+0x302>
lea    -0x1(%r8),%rax
mov    %r8d,%r11d
and    $0x3,%r11d
xor    %edx,%edx
cmp    $0x3,%rax
jb     14fd <pairdist_squared_rows+0x3ed>
lea    (%r8,%r8,1),%esi
lea    0x0(,%r8,4),%r10d
lea    (%r8,%r8,2),%ebp
mov    %r8d,%r9d
and    $0xfffffffc,%r9d
neg    %r9
mov    $0x2,%r14d
mov    $0x1,%r15d
mov    %r12,%r13
mov    $0x3,%r12d
xor    %ebx,%ebx
mov    %r8d,%eax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %esi,%rsi
cltq
movslq %edx,%rdx
lea    (%rdi,%rdx,1),%rcx
movq   $0x0,0x0(%r13,%rcx,8)
lea    (%r15,%rax,1),%rcx
movq   $0x0,0x0(%r13,%rcx,8)
lea    (%r14,%rsi,1),%rcx
movslq %ebp,%rbp
movq   $0x0,0x0(%r13,%rcx,8)
lea    (%r12,%rbp,1),%rcx
movq   $0x0,0x0(%r13,%rcx,8)
add    $0x4,%rdi
add    %r10d,%edx
add    $0x4,%r14
add    %r10d,%esi
add    $0x4,%r15
add    %r10d,%eax
add    $0x4,%r12
add    %r10d,%ebp
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%r9
jne    1490 <pairdist_squared_rows+0x380>
neg    %rbx
mov    %rbx,%rdx
mov    %r13,%r12
test   %r11,%r11
je     1412 <pairdist_squared_rows+0x302>
mov    %r8d,%eax
imul   %edx,%eax
nopl   0x0(%rax)
cltq
lea    (%rdx,%rax,1),%rcx
movq   $0x0,(%r12,%rcx,8)
add    $0x1,%rdx
add    %r8d,%eax
add    $0xffffffffffffffff,%r11
jne    1510 <pairdist_squared_rows+0x400>
jmp    1412 <pairdist_squared_rows+0x302>

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

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