int **mult_vec_i_2(int **res, int **vec1, int **vec2, int lo1, int hi1, int lo2,
                   int hi2) {
  int i, j;
  int sum = 0;
  for (i = 0; i <= hi1 - lo1; i++) {
    for (j = 0; j <= hi2 - lo2; j++) {
      res[i][j] = vec1[i][j] * vec2[i][j];
      sum += res[i][j];
    }
    res[i][hi2 - lo2 + 1] = sum;
    sum = 0;
  }
  return res;
}


x86 assembly (clang, -O0):
<mult_vec_i_2>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jg     11e9 <mult_vec_i_2+0xe9>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jg     11b6 <mult_vec_i_2+0xb6>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
imul   (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1144 <mult_vec_i_2+0x44>
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%ecx
sub    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    112c <mult_vec_i_2+0x2c>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<mult_vec_i_2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,%rax
sub    %ecx,%r8d
jge    111d <mult_vec_i_2+0x1d>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x38(%rsp),%r12d
sub    %r9d,%r12d
lea    0x1(%r12),%r9d
movslq %r9d,%rcx
mov    %rcx,-0x8(%rsp)
add    $0x1,%r8d
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,-0x10(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x18(%rsp)
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %rdi,%rcx
mov    %rdi,-0x20(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,-0x28(%rsp)
mov    %r9,%r13
neg    %r13
xor    %r15d,%r15d
mov    %rsi,-0x30(%rsp)
mov    %r12,-0x38(%rsp)
mov    %r8,-0x40(%rsp)
jmp    119c <mult_vec_i_2+0x9c>
mov    (%rax,%r15,8),%r10
xor    %ecx,%ecx
mov    -0x8(%rsp),%rdi
mov    %ecx,(%r10,%rdi,4)
add    $0x1,%r15
cmp    %r8,%r15
je     1112 <mult_vec_i_2+0x12>
test   %r12d,%r12d
js     1180 <mult_vec_i_2+0x80>
mov    (%rsi,%r15,8),%rbp
mov    (%rdx,%r15,8),%r14
mov    (%rax,%r15,8),%r10
cmp    $0x8,%r9d
jae    11d0 <mult_vec_i_2+0xd0>
xor    %r11d,%r11d
xor    %ecx,%ecx
test   $0x1,%r9b
je     1406 <mult_vec_i_2+0x306>
jmp    1430 <mult_vec_i_2+0x330>
nopw   0x0(%rax,%rax,1)
mov    %rax,%r8
mov    %rdx,%rax
lea    (%r10,%r9,4),%rcx
lea    0x0(,%r9,4),%rdi
add    %rbp,%rdi
mov    %r9,%rbx
lea    (%r14,%r9,4),%rdx
cmp    %rdi,%r10
setb   %sil
cmp    %rcx,%rbp
setb   %r12b
cmp    %rdx,%r10
setb   %dil
cmp    %rcx,%r14
setb   %r9b
xor    %r11d,%r11d
test   %r12b,%sil
jne    140b <mult_vec_i_2+0x30b>
mov    $0x0,%ecx
and    %r9b,%dil
mov    %rax,%rdx
mov    %r8,%rax
mov    -0x40(%rsp),%r8
mov    -0x30(%rsp),%rsi
mov    -0x38(%rsp),%r12
mov    %rbx,%r9
jne    1400 <mult_vec_i_2+0x300>
cmpq   $0x0,-0x18(%rsp)
je     1497 <mult_vec_i_2+0x397>
pxor   %xmm0,%xmm0
mov    -0x28(%rsp),%rcx
xor    %r11d,%r11d
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqu 0x0(%rbp,%r11,4),%xmm3
movdqu 0x10(%rbp,%r11,4),%xmm4
movdqu (%r14,%r11,4),%xmm2
movdqu 0x10(%r14,%r11,4),%xmm5
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm2
pshufd $0xf5,%xmm5,%xmm6
pmuludq %xmm4,%xmm5
pshufd $0xe8,%xmm5,%xmm3
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm6,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm3
movdqu %xmm2,(%r10,%r11,4)
movdqu %xmm3,0x10(%r10,%r11,4)
paddd  %xmm0,%xmm2
paddd  %xmm1,%xmm3
movdqu 0x20(%rbp,%r11,4),%xmm1
movdqu 0x30(%rbp,%r11,4),%xmm4
movdqu 0x20(%r14,%r11,4),%xmm0
movdqu 0x30(%r14,%r11,4),%xmm5
pshufd $0xf5,%xmm0,%xmm6
pmuludq %xmm1,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm6,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pshufd $0xf5,%xmm5,%xmm6
pmuludq %xmm4,%xmm5
pshufd $0xe8,%xmm5,%xmm1
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm6,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm1
movdqu %xmm0,0x20(%r10,%r11,4)
movdqu %xmm1,0x30(%r10,%r11,4)
paddd  %xmm2,%xmm0
paddd  %xmm3,%xmm1
add    $0x10,%r11
add    $0xfffffffffffffffe,%rcx
jne    1260 <mult_vec_i_2+0x160>
testb  $0x1,-0x20(%rsp)
je     13c7 <mult_vec_i_2+0x2c7>
movdqu 0x0(%rbp,%r11,4),%xmm2
movdqu 0x10(%rbp,%r11,4),%xmm3
movdqu (%r14,%r11,4),%xmm4
movdqu 0x10(%r14,%r11,4),%xmm5
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm2,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm6,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm4
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm3,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm2,%xmm3
pshufd $0xe8,%xmm3,%xmm2
punpckldq %xmm2,%xmm5
movdqu %xmm4,(%r10,%r11,4)
movdqu %xmm5,0x10(%r10,%r11,4)
paddd  %xmm4,%xmm0
paddd  %xmm5,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
mov    -0x10(%rsp),%rdi
mov    %rdi,%r11
cmp    %r9,%rdi
je     1186 <mult_vec_i_2+0x86>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   $0x1,%r9b
jne    1430 <mult_vec_i_2+0x330>
mov    %r11,%rdi
jmp    1447 <mult_vec_i_2+0x347>
xor    %ecx,%ecx
mov    %rax,%rdx
mov    %r8,%rax
mov    -0x40(%rsp),%r8
mov    -0x30(%rsp),%rsi
mov    -0x38(%rsp),%r12
mov    %rbx,%r9
test   $0x1,%r9b
je     1406 <mult_vec_i_2+0x306>
nopl   0x0(%rax,%rax,1)
mov    (%r14,%r11,4),%edi
imul   0x0(%rbp,%r11,4),%edi
mov    %edi,(%r10,%r11,4)
add    %edi,%ecx
mov    %r11,%rdi
or     $0x1,%rdi
not    %r11
cmp    %r13,%r11
je     1186 <mult_vec_i_2+0x86>
add    $0x1,%rdi
nopw   0x0(%rax,%rax,1)
mov    -0x4(%r14,%rdi,4),%ebx
imul   -0x4(%rbp,%rdi,4),%ebx
mov    %ebx,-0x4(%r10,%rdi,4)
add    %ecx,%ebx
mov    (%r14,%rdi,4),%ecx
imul   0x0(%rbp,%rdi,4),%ecx
mov    %ecx,(%r10,%rdi,4)
add    %ebx,%ecx
lea    (%rdi,%r13,1),%rbx
add    $0x2,%rbx
add    $0x2,%rdi
cmp    $0x1,%rbx
jne    1460 <mult_vec_i_2+0x360>
jmp    1186 <mult_vec_i_2+0x86>
pxor   %xmm0,%xmm0
xor    %r11d,%r11d
pxor   %xmm1,%xmm1
testb  $0x1,-0x20(%rsp)
jne    1357 <mult_vec_i_2+0x257>
jmp    13c7 <mult_vec_i_2+0x2c7>

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

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