#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 */
double dot(double *, double *, int);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
void getHes(double **Hes, double *x, int **A, int numSS, int numTotal) {
  int m, n, j;
  double *Avec;
  Avec = (double *)malloc(numTotal * sizeof(double));
  for (n = 0; n < numSS; n++) {
    for (m = 0; m <= n; m++) {
      for (j = 0; j < numTotal; j++) {
        Avec[j] = ((double)A[m][j]) * ((double)A[n][j]);
      }
      Hes[m][n] = dot(x, Avec, numTotal);
    }
  }
  for (m = 1; m < numSS; m++) {
    for (n = 0; n < m; n++) {
      Hes[m][n] = Hes[n][m];
    }
  }
  free(Avec);
}


x86 assembly (clang, -O0):
<getHes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movslq -0x20(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1226 <getHes+0xf6>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1213 <getHes+0xe3>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11e0 <getHes+0xb0>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    118b <getHes+0x5b>
mov    -0x10(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x20(%rbp),%edx
call   1030 <dot@plt>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1178 <getHes+0x48>
jmp    1218 <getHes+0xe8>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1165 <getHes+0x35>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1297 <getHes+0x167>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1284 <getHes+0x154>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1240 <getHes+0x110>
jmp    1289 <getHes+0x159>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    122d <getHes+0xfd>
mov    -0x38(%rbp),%rdi
call   1040 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getHes>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8d,%ebp
mov    %ecx,%r15d
mov    %rdx,0x38(%rsp)
mov    %rsi,0x40(%rsp)
mov    %rdi,%r14
lea    0x0(,%rbp,8),%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
test   %r15d,%r15d
jle    140c <getHes+0x2dc>
mov    %r15d,0x4(%rsp)
mov    %r15d,%eax
mov    %rax,0x8(%rsp)
mov    %ebp,%r15d
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x30(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x18(%rsp)
mov    $0x1,%eax
mov    %rax,0x10(%rsp)
xor    %r12d,%r12d
jmp    11d5 <getHes+0xa5>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
addq   $0x1,0x10(%rsp)
cmp    0x8(%rsp),%r12
je     1322 <getHes+0x1f2>
xor    %r13d,%r13d
jmp    1204 <getHes+0xd4>
nopw   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rdi
mov    %rbx,%rsi
mov    %ebp,%edx
call   1030 <dot@plt>
mov    (%r14,%r13,8),%rax
movsd  %xmm0,(%rax,%r12,8)
add    $0x1,%r13
cmp    0x10(%rsp),%r13
je     11c0 <getHes+0x90>
test   %ebp,%ebp
jle    11e0 <getHes+0xb0>
mov    0x38(%rsp),%rcx
mov    (%rcx,%r13,8),%rax
mov    (%rcx,%r12,8),%rcx
cmp    $0x4,%ebp
jae    1230 <getHes+0x100>
xor    %edx,%edx
jmp    12f0 <getHes+0x1c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0x28(%rsp)
je     1317 <getHes+0x1e7>
mov    0x18(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cvtdq2pd (%rax,%rdx,4),%xmm0
cvtdq2pd 0x8(%rax,%rdx,4),%xmm1
cvtdq2pd (%rcx,%rdx,4),%xmm2
cvtdq2pd 0x8(%rcx,%rdx,4),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rbx,%rdx,8)
movupd %xmm3,0x10(%rbx,%rdx,8)
cvtdq2pd 0x10(%rax,%rdx,4),%xmm0
cvtdq2pd 0x18(%rax,%rdx,4),%xmm1
cvtdq2pd 0x10(%rcx,%rdx,4),%xmm2
mulpd  %xmm0,%xmm2
cvtdq2pd 0x18(%rcx,%rdx,4),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbx,%rdx,8)
movupd %xmm0,0x30(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1250 <getHes+0x120>
testb  $0x1,0x20(%rsp)
je     12df <getHes+0x1af>
cvtdq2pd (%rax,%rdx,4),%xmm0
cvtdq2pd 0x8(%rax,%rdx,4),%xmm1
cvtdq2pd (%rcx,%rdx,4),%xmm2
cvtdq2pd 0x8(%rcx,%rdx,4),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rbx,%rdx,8)
movupd %xmm3,0x10(%rbx,%rdx,8)
mov    0x30(%rsp),%rsi
mov    %rsi,%rdx
cmp    %r15,%rsi
je     11e0 <getHes+0xb0>
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax,%rdx,4),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdl (%rcx,%rdx,4),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r15
jne    12f0 <getHes+0x1c0>
jmp    11e0 <getHes+0xb0>
xor    %edx,%edx
testb  $0x1,0x20(%rsp)
jne    12b6 <getHes+0x186>
jmp    12df <getHes+0x1af>
cmpl   $0x2,0x4(%rsp)
jl     140c <getHes+0x2dc>
mov    $0x1,%eax
xor    %r8d,%r8d
jmp    1353 <getHes+0x223>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x1,%r8
cmp    0x8(%rsp),%rax
je     140c <getHes+0x2dc>
mov    (%r14,%rax,8),%rdx
cmp    $0x3,%r8
jae    1370 <getHes+0x240>
xor    %esi,%esi
jmp    13cb <getHes+0x29b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,%rdi
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
mov    (%r14,%rsi,8),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
mov    0x8(%r14,%rsi,8),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rsi,8)
mov    0x10(%r14,%rsi,8),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x10(%rdx,%rsi,8)
mov    0x18(%r14,%rsi,8),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x18(%rdx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1380 <getHes+0x250>
test   $0x3,%al
je     1340 <getHes+0x210>
mov    %eax,%edi
and    $0x3,%edi
lea    (%rdx,%rsi,8),%rdx
lea    (%r14,%rsi,8),%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%rbp,8),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    13f0 <getHes+0x2c0>
jmp    1340 <getHes+0x210>
mov    %rbx,%rdi
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free@plt>

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

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