#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 INT_MAX;
int MCM(int *dims, int n) {
  int table[n][n];
  int i, j, k, L, q;
  for (i = 1; i < n; i++)
    table[i][i] = 0;
  for (L = 2; L < n; L++) {
    for (i = 1; i < n - L + 1; i++) {
      j = i + L - 1;
      table[i][j] = INT_MAX;
      for (k = i; k <= j - 1; k++) {
        q = table[i][k] + table[k + 1][j] + dims[i - 1] * dims[k] * dims[j];
        if (q < table[i][j])
          table[i][j] = q;
      }
    }
  }
  return table[1][n - 1];
}


x86 assembly (clang, -O0):
<MCM>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
mov    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x18(%rbp)
mov    %rcx,%rdx
imul   %rdx,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x48(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x20(%rbp)
mov    %rax,-0x28(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    118d <MCM+0x8d>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1151 <MCM+0x51>
movl   $0x2,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ec <MCM+0x1ec>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x38(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    12d9 <MCM+0x1d9>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rsi
mov    -0x2c(%rbp),%ecx
add    -0x38(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,-0x30(%rbp)
mov    0x2e12(%rip),%rcx
mov    (%rcx),%edx
movslq -0x2c(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     12c6 <MCM+0x1c6>
mov    -0x48(%rbp),%rcx
mov    -0x50(%rbp),%rsi
movslq -0x2c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rcx,%rax
add    %rdx,%rax
movslq -0x34(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdi
imul   %rsi,%rdi
shl    $0x2,%rdi
mov    %rcx,%rdx
add    %rdi,%rdx
movslq -0x30(%rbp),%rdi
add    (%rdx,%rdi,4),%eax
mov    -0x8(%rbp),%rdx
mov    -0x2c(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
mov    (%rdx,%rdi,4),%edx
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%r8
imul   (%rdi,%r8,4),%edx
mov    -0x8(%rbp),%rdi
movslq -0x30(%rbp),%r8
imul   (%rdi,%r8,4),%edx
add    %edx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
movslq -0x2c(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    12b3 <MCM+0x1b3>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rsi
mov    -0x3c(%rbp),%edx
movslq -0x2c(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12b8 <MCM+0x1b8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f4 <MCM+0xf4>
jmp    12cb <MCM+0x1cb>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a7 <MCM+0xa7>
jmp    12de <MCM+0x1de>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1194 <MCM+0x94>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x0,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    %rcx,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MCM>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rdi,-0x38(%rbp)
mov    %esi,%r12d
mov    %r12,%rax
imul   %r12,%rax
mov    %rsp,%r15
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    %esi,-0x2c(%rbp)
cmp    $0x2,%esi
jl     1416 <MCM+0x316>
lea    -0x1(%r12),%r8
lea    -0x2(%r12),%rdx
mov    %r8d,%r11d
and    $0x3,%r11d
mov    $0x1,%ecx
cmp    $0x3,%rdx
jb     11de <MCM+0xde>
mov    %r12,%r9
shl    $0x4,%r9
add    $0x10,%r9
lea    (%r12,%r12,2),%rcx
lea    0xc(,%rcx,4),%rdi
lea    0x4(,%r12,4),%rax
lea    0x8(,%r12,8),%rdx
and    $0xfffffffffffffffc,%r8
neg    %r8
mov    $0x1,%ecx
mov    %r9,%rsi
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,(%r15,%rax,1)
movl   $0x0,(%r15,%rdx,1)
movl   $0x0,(%r15,%rdi,1)
movl   $0x0,(%r15,%rsi,1)
add    %r9,%rsi
add    %r9,%rdi
add    %r9,%rax
add    %r9,%rdx
lea    (%r8,%rcx,1),%r10
add    $0x4,%r10
add    $0x4,%rcx
cmp    $0x1,%r10
jne    11a0 <MCM+0xa0>
test   %r11,%r11
je     120f <MCM+0x10f>
lea    0x4(,%r12,4),%rdx
imul   %rdx,%rcx
add    %r15,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rcx)
add    %rdx,%rcx
add    $0xffffffffffffffff,%r11
jne    1200 <MCM+0x100>
cmpl   $0x3,-0x2c(%rbp)
jl     1416 <MCM+0x316>
mov    0x2dc8(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x30(%rbp)
lea    0x0(,%r12,4),%rax
mov    %rax,-0x58(%rbp)
lea    0x8(%r15),%rax
mov    %rax,-0x50(%rbp)
lea    0x0(,%r12,8),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rbp)
lea    (%r15,%r12,4),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
mov    $0x2,%eax
xor    %r9d,%r9d
mov    %r12,-0x80(%rbp)
mov    %r15,-0x78(%rbp)
jmp    1296 <MCM+0x196>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
add    $0x1,%r9
addq   $0x4,-0x50(%rbp)
cmp    %r12,%rax
je     1416 <MCM+0x316>
cmp    %r12,%rax
jae    1280 <MCM+0x180>
mov    $0x1,%ebx
mov    -0x68(%rbp),%rcx
mov    %rcx,-0x48(%rbp)
mov    -0x50(%rbp),%rcx
mov    %rcx,-0x60(%rbp)
mov    %rax,-0x40(%rbp)
mov    %rax,-0x90(%rbp)
mov    %r9,-0x88(%rbp)
jmp    1317 <MCM+0x217>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x98(%rbp),%rbx
add    $0x1,%rbx
mov    -0x40(%rbp),%rcx
add    $0x1,%rcx
addq   $0x4,-0x60(%rbp)
mov    -0x48(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x80(%rbp),%r12
mov    %rcx,-0x40(%rbp)
cmp    %r12,%rcx
mov    -0x78(%rbp),%r15
mov    -0x90(%rbp),%rax
mov    -0x88(%rbp),%r9
je     1280 <MCM+0x180>
lea    (%rbx,%rax,1),%r14
mov    %rbx,%rcx
imul   %r12,%rcx
lea    (%r15,%rcx,4),%r11
mov    -0x30(%rbp),%edx
mov    %edx,-0x4(%r11,%r14,4)
mov    -0x38(%rbp),%rax
mov    -0x4(%rax,%rbx,4),%r8d
mov    -0x4(%rax,%r14,4),%esi
mov    %rbx,%rcx
test   $0x1,%r9b
jne    137c <MCM+0x27c>
lea    (%r15,%r14,4),%rdx
add    $0xfffffffffffffffc,%rdx
lea    0x1(%rbx),%rcx
mov    %rcx,%rdi
imul   %r12,%rdi
mov    (%rdx,%rdi,4),%edi
add    (%r11,%rbx,4),%edi
mov    -0x38(%rbp),%rax
mov    (%rax,%rbx,4),%edx
imul   %r8d,%edx
imul   %esi,%edx
add    %edi,%edx
mov    -0x30(%rbp),%eax
cmp    %eax,%edx
cmovge %eax,%edx
mov    %edx,-0x4(%r11,%r14,4)
mov    %rbx,-0x98(%rbp)
test   %r9,%r9
je     12d0 <MCM+0x1d0>
mov    -0x40(%rbp),%r15
sub    %rcx,%r15
lea    0x2(%rcx),%r12
mov    -0x58(%rbp),%rax
imul   %rax,%r12
mov    -0x70(%rbp),%rdi
lea    (%rdi,%rcx,4),%r13
lea    0x1(%rcx),%rdi
imul   %rax,%rdi
mov    -0x48(%rbp),%rax
lea    (%rax,%rcx,4),%rbx
mov    -0x60(%rbp),%r9
xor    %r10d,%r10d
xchg   %ax,%ax
mov    (%r9,%rdi,1),%ecx
add    -0x4(%rbx,%r10,4),%ecx
mov    -0x4(%r13,%r10,4),%eax
imul   %r8d,%eax
imul   %esi,%eax
add    %ecx,%eax
cmp    %edx,%eax
cmovge %edx,%eax
mov    %eax,-0x4(%r11,%r14,4)
mov    (%r9,%r12,1),%ecx
add    (%rbx,%r10,4),%ecx
mov    0x0(%r13,%r10,4),%edx
imul   %r8d,%edx
imul   %esi,%edx
add    %ecx,%edx
cmp    %eax,%edx
cmovge %eax,%edx
mov    %edx,-0x4(%r11,%r14,4)
add    $0x2,%r10
add    -0xa0(%rbp),%r9
cmp    %r10,%r15
jne    13c0 <MCM+0x2c0>
jmp    12d0 <MCM+0x1d0>
lea    (%r15,%r12,4),%rax
movslq -0x2c(%rbp),%rcx
mov    -0x4(%rax,%rcx,4),%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@INT_MAX = global i32 0
define i32 @MCM(i32* %0, i32 %1) {
%3 = alloca i32*
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i64
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i32* %0, i32** %3
store i32 %1, i32* %4
%13 = load i32, i32* %4
%14 = zext i32 %13 to i64
%15 = load i32, i32* %4
%16 = zext i32 %15 to i64
%17 = call i8* @llvm.stacksave()
store i8* %17, i8** %5
%18 = mul nuw i64 %14, %16
%19 = alloca i32, i64 %18
store i64 %14, i64* %6
store i64 %16, i64* %7
store i32 1, i32* %8
br label %20
20: ; preds = %32, %2
%21 = load i32, i32* %8
%22 = load i32, i32* %4
%23 = icmp slt i32 %21, %22
br i1 %23, label %24, label %35
24: ; preds = %20
%25 = load i32, i32* %8
%26 = sext i32 %25 to i64
%27 = mul nsw i64 %26, %16
%28 = getelementptr inbounds i32, i32* %19, i64 %27
%29 = load i32, i32* %8
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i32, i32* %28, i64 %30
store i32 0, i32* %31
br label %32
32: ; preds = %24
%33 = load i32, i32* %8
%34 = add nsw i32 %33, 1
store i32 %34, i32* %8
br label %20
35: ; preds = %20
store i32 2, i32* %11
br label %36
36: ; preds = %133, %35
%37 = load i32, i32* %11
%38 = load i32, i32* %4
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %136
40: ; preds = %36
store i32 1, i32* %8
br label %41
41: ; preds = %129, %40
%42 = load i32, i32* %8
%43 = load i32, i32* %4
%44 = load i32, i32* %11
%45 = sub nsw i32 %43, %44
%46 = add nsw i32 %45, 1
%47 = icmp slt i32 %42, %46
br i1 %47, label %48, label %132
48: ; preds = %41
%49 = load i32, i32* %8
%50 = load i32, i32* %11
%51 = add nsw i32 %49, %50
%52 = sub nsw i32 %51, 1
store i32 %52, i32* %9
%53 = load i32, i32* @INT_MAX
%54 = load i32, i32* %8
%55 = sext i32 %54 to i64
%56 = mul nsw i64 %55, %16
%57 = getelementptr inbounds i32, i32* %19, i64 %56
%58 = load i32, i32* %9
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i32, i32* %57, i64 %59
store i32 %53, i32* %60
%61 = load i32, i32* %8
store i32 %61, i32* %10
br label %62
62: ; preds = %125, %48
%63 = load i32, i32* %10
%64 = load i32, i32* %9
%65 = sub nsw i32 %64, 1
%66 = icmp sle i32 %63, %65
br i1 %66, label %67, label %128
67: ; preds = %62
%68 = load i32, i32* %8
%69 = sext i32 %68 to i64
%70 = mul nsw i64 %69, %16
%71 = getelementptr inbounds i32, i32* %19, i64 %70
%72 = load i32, i32* %10
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %71, i64 %73
%75 = load i32, i32* %74
%76 = load i32, i32* %10
%77 = add nsw i32 %76, 1
%78 = sext i32 %77 to i64
%79 = mul nsw i64 %78, %16
%80 = getelementptr inbounds i32, i32* %19, i64 %79
%81 = load i32, i32* %9
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i32, i32* %80, i64 %82
%84 = load i32, i32* %83
%85 = add nsw i32 %75, %84
%86 = load i32*, i32** %3
%87 = load i32, i32* %8
%88 = sub nsw i32 %87, 1
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i32, i32* %86, i64 %89
%91 = load i32, i32* %90
%92 = load i32*, i32** %3
%93 = load i32, i32* %10
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %92, i64 %94
%96 = load i32, i32* %95
%97 = mul nsw i32 %91, %96
%98 = load i32*, i32** %3
%99 = load i32, i32* %9
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i32, i32* %98, i64 %100
%102 = load i32, i32* %101
%103 = mul nsw i32 %97, %102
%104 = add nsw i32 %85, %103
store i32 %104, i32* %12
%105 = load i32, i32* %12
%106 = load i32, i32* %8
%107 = sext i32 %106 to i64
%108 = mul nsw i64 %107, %16
%109 = getelementptr inbounds i32, i32* %19, i64 %108
%110 = load i32, i32* %9
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i32, i32* %109, i64 %111
%113 = load i32, i32* %112
%114 = icmp slt i32 %105, %113
br i1 %114, label %115, label %124
115: ; preds = %67
%116 = load i32, i32* %12
%117 = load i32, i32* %8
%118 = sext i32 %117 to i64
%119 = mul nsw i64 %118, %16
%120 = getelementptr inbounds i32, i32* %19, i64 %119
%121 = load i32, i32* %9
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %120, i64 %122
store i32 %116, i32* %123
br label %124
124: ; preds = %115, %67
br label %125
125: ; preds = %124
%126 = load i32, i32* %10
%127 = add nsw i32 %126, 1
store i32 %127, i32* %10
br label %62
128: ; preds = %62
br label %129
129: ; preds = %128
%130 = load i32, i32* %8
%131 = add nsw i32 %130, 1
store i32 %131, i32* %8
br label %41
132: ; preds = %41
br label %133
133: ; preds = %132
%134 = load i32, i32* %11
%135 = add nsw i32 %134, 1
store i32 %135, i32* %11
br label %36
136: ; preds = %36
%137 = mul nsw i64 1, %16
%138 = getelementptr inbounds i32, i32* %19, i64 %137
%139 = load i32, i32* %4
%140 = sub nsw i32 %139, 1
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %138, i64 %141
%143 = load i32, i32* %142
%144 = load i8*, i8** %5
ret i32 %143
}

LLVM IR (-O2):
@INT_MAX = global i32 0
define i32 @MCM(i32* nocapture %0, i32 %1) {
%3 = zext i32 %1 to i64
%4 = mul nuw i64 %3, %3
%5 = alloca i32, i64 %4
%6 = icmp sgt i32 %1, 1
br i1 %6, label %7, label %132
7: ; preds = %2
%8 = add nsw i64 %3, -1
%9 = add nsw i64 %3, -2
%10 = and i64 %8, 3
%11 = icmp ult i64 %9, 3
br i1 %11, label %14, label %12
12: ; preds = %7
%13 = and i64 %8, -4
br label %31
14: ; preds = %31, %7
%15 = phi i64 [ 1, %7 ], [ %49, %31 ]
%16 = icmp eq i64 %10, 0
br i1 %16, label %26, label %17
17: ; preds = %14, %17
%18 = phi i64 [ %23, %17 ], [ %15, %14 ]
%19 = phi i64 [ %24, %17 ], [ 0, %14 ]
%20 = mul nuw nsw i64 %18, %3
%21 = getelementptr inbounds i32, i32* %5, i64 %20
%22 = getelementptr inbounds i32, i32* %21, i64 %18
store i32 0, i32* %22
%23 = add nuw nsw i64 %18, 1
%24 = add i64 %19, 1
%25 = icmp eq i64 %24, %10
br i1 %25, label %26, label %17
26: ; preds = %17, %14
%27 = icmp sgt i32 %1, 2
br i1 %27, label %28, label %132
28: ; preds = %26
%29 = load i32, i32* @INT_MAX
%30 = zext i32 %1 to i64
br label %52
31: ; preds = %31, %12
%32 = phi i64 [ 1, %12 ], [ %49, %31 ]
%33 = phi i64 [ 0, %12 ], [ %50, %31 ]
%34 = mul nuw nsw i64 %32, %3
%35 = getelementptr inbounds i32, i32* %5, i64 %34
%36 = getelementptr inbounds i32, i32* %35, i64 %32
store i32 0, i32* %36
%37 = add nuw nsw i64 %32, 1
%38 = mul nuw nsw i64 %37, %3
%39 = getelementptr inbounds i32, i32* %5, i64 %38
%40 = getelementptr inbounds i32, i32* %39, i64 %37
store i32 0, i32* %40
%41 = add nuw nsw i64 %32, 2
%42 = mul nuw nsw i64 %41, %3
%43 = getelementptr inbounds i32, i32* %5, i64 %42
%44 = getelementptr inbounds i32, i32* %43, i64 %41
store i32 0, i32* %44
%45 = add nuw nsw i64 %32, 3
%46 = mul nuw nsw i64 %45, %3
%47 = getelementptr inbounds i32, i32* %5, i64 %46
%48 = getelementptr inbounds i32, i32* %47, i64 %45
store i32 0, i32* %48
%49 = add nuw nsw i64 %32, 4
%50 = add i64 %33, 4
%51 = icmp eq i64 %50, %13
br i1 %51, label %14, label %31
52: ; preds = %28, %128
%53 = phi i64 [ 0, %28 ], [ %131, %128 ]
%54 = phi i64 [ 2, %28 ], [ %129, %128 ]
%55 = icmp ult i64 %54, %30
br i1 %55, label %56, label %128
56: ; preds = %52
%57 = and i64 %53, 1
%58 = icmp eq i64 %57, 0
%59 = icmp eq i64 %53, 0
br label %60
60: ; preds = %56, %124
%61 = phi i64 [ %126, %124 ], [ %54, %56 ]
%62 = phi i64 [ %125, %124 ], [ 1, %56 ]
%63 = add nuw nsw i64 %62, %54
%64 = add nsw i64 %63, -1
%65 = mul nuw nsw i64 %62, %3
%66 = getelementptr inbounds i32, i32* %5, i64 %65
%67 = getelementptr inbounds i32, i32* %66, i64 %64
store i32 %29, i32* %67
%68 = add nsw i64 %62, -1
%69 = getelementptr inbounds i32, i32* %0, i64 %68
%70 = load i32, i32* %69
%71 = getelementptr inbounds i32, i32* %0, i64 %64
%72 = load i32, i32* %71
%73 = getelementptr inbounds i32, i32* %5, i64 %64
br i1 %58, label %74, label %89
74: ; preds = %60
%75 = getelementptr inbounds i32, i32* %66, i64 %62
%76 = load i32, i32* %75
%77 = add nuw nsw i64 %62, 1
%78 = mul nuw nsw i64 %77, %3
%79 = getelementptr inbounds i32, i32* %73, i64 %78
%80 = load i32, i32* %79
%81 = add nsw i32 %80, %76
%82 = getelementptr inbounds i32, i32* %0, i64 %62
%83 = load i32, i32* %82
%84 = mul nsw i32 %83, %70
%85 = mul nsw i32 %84, %72
%86 = add nsw i32 %81, %85
%87 = icmp slt i32 %86, %29
%88 = select i1 %87, i32 %86, i32 %29
store i32 %88, i32* %67
br label %89
89: ; preds = %74, %60
%90 = phi i32 [ %29, %60 ], [ %88, %74 ]
%91 = phi i64 [ %62, %60 ], [ %77, %74 ]
br i1 %59, label %124, label %92
92: ; preds = %89, %92
%93 = phi i32 [ %122, %92 ], [ %90, %89 ]
%94 = phi i64 [ %111, %92 ], [ %91, %89 ]
%95 = getelementptr inbounds i32, i32* %66, i64 %94
%96 = load i32, i32* %95
%97 = add nuw nsw i64 %94, 1
%98 = mul nuw nsw i64 %97, %3
%99 = getelementptr inbounds i32, i32* %73, i64 %98
%100 = load i32, i32* %99
%101 = add nsw i32 %100, %96
%102 = getelementptr inbounds i32, i32* %0, i64 %94
%103 = load i32, i32* %102
%104 = mul nsw i32 %103, %70
%105 = mul nsw i32 %104, %72
%106 = add nsw i32 %101, %105
%107 = icmp slt i32 %106, %93
%108 = select i1 %107, i32 %106, i32 %93
store i32 %108, i32* %67
%109 = getelementptr inbounds i32, i32* %66, i64 %97
%110 = load i32, i32* %109
%111 = add nuw nsw i64 %94, 2
%112 = mul nuw nsw i64 %111, %3
%113 = getelementptr inbounds i32, i32* %73, i64 %112
%114 = load i32, i32* %113
%115 = add nsw i32 %114, %110
%116 = getelementptr inbounds i32, i32* %0, i64 %97
%117 = load i32, i32* %116
%118 = mul nsw i32 %117, %70
%119 = mul nsw i32 %118, %72
%120 = add nsw i32 %115, %119
%121 = icmp slt i32 %120, %108
%122 = select i1 %121, i32 %120, i32 %108
store i32 %122, i32* %67
%123 = icmp eq i64 %111, %61
br i1 %123, label %124, label %92
124: ; preds = %92, %89
%125 = add nuw nsw i64 %62, 1
%126 = add nuw nsw i64 %61, 1
%127 = icmp eq i64 %126, %3
br i1 %127, label %128, label %60
128: ; preds = %124, %52
%129 = add nuw nsw i64 %54, 1
%130 = icmp eq i64 %129, %3
%131 = add i64 %53, 1
br i1 %130, label %132, label %52
132: ; preds = %128, %2, %26
%133 = getelementptr inbounds i32, i32* %5, i64 %3
%134 = add nsw i32 %1, -1
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %133, i64 %135
%137 = load i32, i32* %136
ret i32 %137
}