long long int calculate(int i, int j, int n,
                        long long int memoTable[][20 + 1]) {
  int k;
  long long int maxVal, val, maxValOne, maxValTwo, valOne, valTwo;
  if (memoTable[i][j] != -1)
    return memoTable[i][j];
  if (i >= j) {
    if (i < n) {
      maxValOne =
          calculate(i + 1, 1, n, memoTable) + calculate(i + 1, j, n, memoTable);
      for (k = i + 2; k <= n; k++) {
        valOne = calculate(k, 1, n, memoTable) + calculate(k, j, n, memoTable);
        if (valOne > maxValOne)
          maxValOne = valOne;
      }
    } else
      maxValOne = 0;
    if (j > 1) {
      maxValTwo = calculate(i, 1, n, memoTable) + calculate(n, 1, n, memoTable);
      for (k = 2; k < j; k++) {
        valTwo = calculate(i, k, n, memoTable) + calculate(n, k, n, memoTable);
        if (valTwo > maxValTwo)
          maxValTwo = valTwo;
      }
    } else
      maxValTwo = 0;
    maxVal = maxValOne + maxValTwo;
  } else {
    maxVal = calculate(i, i, n, memoTable) + calculate(i + 1, j, n, memoTable);
    for (k = i + 1; k < j; k++) {
      val = calculate(i, k, n, memoTable) + calculate(k + 1, j, n, memoTable);
      if (maxVal < val)
        maxVal = val;
    }
  }
  memoTable[i][j] = maxVal;
  return maxVal;
}


x86 assembly (clang, -O0):
<calculate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
cmpq   $0xffffffffffffffff,(%rax,%rcx,8)
je     116c <calculate+0x5c>
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x8(%rbp)
jmp    13fa <calculate+0x2ea>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     1319 <calculate+0x209>
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    123d <calculate+0x12d>
mov    -0xc(%rbp),%edi
add    $0x1,%edi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    $0x1,%esi
call   1030 <calculate@plt>
mov    %rax,-0x60(%rbp)
mov    -0xc(%rbp),%edi
add    $0x1,%edi
mov    -0x10(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1030 <calculate@plt>
mov    %rax,%rcx
mov    -0x60(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1238 <calculate+0x128>
mov    -0x24(%rbp),%edi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    $0x1,%esi
call   1030 <calculate@plt>
mov    %rax,-0x68(%rbp)
mov    -0x24(%rbp),%edi
mov    -0x10(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1030 <calculate@plt>
mov    %rax,%rcx
mov    -0x68(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x40(%rbp),%rax
jle    1225 <calculate+0x115>
mov    -0x50(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    122a <calculate+0x11a>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11cb <calculate+0xbb>
jmp    1245 <calculate+0x135>
movq   $0x0,-0x40(%rbp)
cmpl   $0x1,-0x10(%rbp)
jle    1300 <calculate+0x1f0>
mov    -0xc(%rbp),%edi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    $0x1,%esi
call   1030 <calculate@plt>
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    $0x1,%esi
call   1030 <calculate@plt>
mov    %rax,%rcx
mov    -0x70(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x2,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12fb <calculate+0x1eb>
mov    -0xc(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1030 <calculate@plt>
mov    %rax,-0x78(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1030 <calculate@plt>
mov    %rax,%rcx
mov    -0x78(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x48(%rbp),%rax
jle    12e8 <calculate+0x1d8>
mov    -0x58(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    12ed <calculate+0x1dd>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1290 <calculate+0x180>
jmp    1308 <calculate+0x1f8>
movq   $0x0,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    13d4 <calculate+0x2c4>
mov    -0xc(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1030 <calculate@plt>
mov    %rax,-0x80(%rbp)
mov    -0xc(%rbp),%edi
add    $0x1,%edi
mov    -0x10(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1030 <calculate@plt>
mov    %rax,%rcx
mov    -0x80(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13cf <calculate+0x2bf>
mov    -0xc(%rbp),%edi
mov    -0x24(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1030 <calculate@plt>
mov    %rax,-0x88(%rbp)
mov    -0x24(%rbp),%edi
add    $0x1,%edi
mov    -0x10(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1030 <calculate@plt>
mov    %rax,%rcx
mov    -0x88(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x38(%rbp),%rax
jge    13bc <calculate+0x2ac>
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    13c1 <calculate+0x2b1>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    135b <calculate+0x24b>
jmp    13d4 <calculate+0x2c4>
mov    -0x30(%rbp),%rdx
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0xa8,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calculate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rcx,%r12
movslq %edi,%rcx
movslq %esi,%rax
imul   $0xa8,%rcx,%rcx
add    %r12,%rcx
mov    (%rcx,%rax,8),%rbp
cmp    $0xffffffffffffffff,%rbp
jne    131b <calculate+0x20b>
mov    %edx,%r13d
mov    %edi,%r15d
mov    %esi,0xc(%rsp)
lea    (%rcx,%rax,8),%rcx
cmp    %eax,%edi
mov    %rcx,0x18(%rsp)
mov    %r15,0x10(%rsp)
jge    11dc <calculate+0xcc>
mov    %r15d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
mov    %rax,%r14
lea    0x1(%r15),%ebx
mov    %ebx,%edi
mov    0xc(%rsp),%r15d
mov    %r15d,%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
mov    %rax,%rbp
add    %r14,%rbp
cmp    %r15d,%ebx
jge    1313 <calculate+0x203>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdi
mov    %ebx,%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
mov    %rax,%r14
add    $0x1,%ebx
mov    %ebx,%edi
mov    %r15d,%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
add    %r14,%rax
cmp    %rax,%rbp
cmovl  %rax,%rbp
cmp    %ebx,%r15d
jne    11a0 <calculate+0x90>
jmp    1313 <calculate+0x203>
cmp    %r13d,%r15d
jge    1221 <calculate+0x111>
lea    0x1(%r15),%ebx
mov    %ebx,%edi
mov    $0x1,%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
mov    %rax,%rbp
mov    %ebx,%edi
mov    0xc(%rsp),%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
mov    %rax,%r14
add    %rbp,%r14
lea    0x2(%r15),%ebp
cmp    %r13d,%ebp
jle    122b <calculate+0x11b>
mov    0xc(%rsp),%r15d
jmp    1285 <calculate+0x175>
xor    %r14d,%r14d
mov    0xc(%rsp),%r15d
jmp    1285 <calculate+0x175>
mov    %r13d,%eax
neg    %eax
mov    %rax,0x20(%rsp)
mov    0xc(%rsp),%r15d
nopw   0x0(%rax,%rax,1)
mov    %ebp,%edi
mov    $0x1,%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
mov    %rax,%rbx
mov    %ebp,%edi
mov    %r15d,%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
add    %rbx,%rax
cmp    %r14,%rax
cmovg  %rax,%r14
mov    0x20(%rsp),%rax
add    %ebp,%eax
add    $0x1,%eax
mov    %ebp,%ecx
add    $0x1,%ecx
mov    %ecx,%ebp
cmp    $0x1,%eax
jne    1240 <calculate+0x130>
cmp    $0x2,%r15d
jl     130e <calculate+0x1fe>
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
mov    %rax,%rbx
mov    %r13d,%edi
mov    $0x1,%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
mov    %rax,%rbp
add    %rbx,%rbp
cmp    $0x2,%r15d
je     1310 <calculate+0x200>
mov    $0x2,%r15d
nopl   0x0(%rax)
mov    0x10(%rsp),%rdi
mov    %r15d,%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
mov    %rax,%rbx
mov    %r13d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
mov    %r12,%rcx
call   1030 <calculate@plt>
add    %rbx,%rax
cmp    %rbp,%rax
cmovg  %rax,%rbp
add    $0x1,%r15d
cmp    %r15d,0xc(%rsp)
jne    12d0 <calculate+0x1c0>
jmp    1310 <calculate+0x200>
xor    %ebp,%ebp
add    %r14,%rbp
mov    0x18(%rsp),%rax
mov    %rbp,(%rax)
mov    %rbp,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i64 @calculate(i32 %0, i32 %1, i32 %2, [21 x i64]* %3) {
%5 = sext i32 %0 to i64
%6 = sext i32 %1 to i64
%7 = getelementptr inbounds [21 x i64], [21 x i64]* %3, i64 %5, i64 %6
%8 = load i64, i64* %7
%9 = icmp eq i64 %8, -1
br i1 %9, label %10, label %70
10: ; preds = %4
%11 = icmp slt i32 %0, %1
br i1 %11, label %52, label %12
12: ; preds = %10
%13 = icmp slt i32 %0, %2
br i1 %13, label %14, label %31
14: ; preds = %12
%15 = add nsw i32 %0, 1
%16 = tail call i64 @calculate(i32 %15, i32 1, i32 %2, [21 x i64]* %3)
%17 = tail call i64 @calculate(i32 %15, i32 %1, i32 %2, [21 x i64]* %3)
%18 = add nsw i64 %17, %16
%19 = add nsw i32 %0, 2
%20 = icmp sgt i32 %19, %2
br i1 %20, label %31, label %21
21: ; preds = %14, %21
%22 = phi i32 [ %29, %21 ], [ %19, %14 ]
%23 = phi i64 [ %28, %21 ], [ %18, %14 ]
%24 = tail call i64 @calculate(i32 %22, i32 1, i32 %2, [21 x i64]* %3)
%25 = tail call i64 @calculate(i32 %22, i32 %1, i32 %2, [21 x i64]* %3)
%26 = add nsw i64 %25, %24
%27 = icmp sgt i64 %26, %23
%28 = select i1 %27, i64 %26, i64 %23
%29 = add i32 %22, 1
%30 = icmp eq i32 %22, %2
br i1 %30, label %31, label %21
31: ; preds = %21, %14, %12
%32 = phi i64 [ 0, %12 ], [ %18, %14 ], [ %28, %21 ]
%33 = icmp sgt i32 %1, 1
br i1 %33, label %34, label %49
34: ; preds = %31
%35 = tail call i64 @calculate(i32 %0, i32 1, i32 %2, [21 x i64]* %3)
%36 = tail call i64 @calculate(i32 %2, i32 1, i32 %2, [21 x i64]* %3)
%37 = add nsw i64 %36, %35
%38 = icmp eq i32 %1, 2
br i1 %38, label %49, label %39
39: ; preds = %34, %39
%40 = phi i32 [ %47, %39 ], [ 2, %34 ]
%41 = phi i64 [ %46, %39 ], [ %37, %34 ]
%42 = tail call i64 @calculate(i32 %0, i32 %40, i32 %2, [21 x i64]* %3)
%43 = tail call i64 @calculate(i32 %2, i32 %40, i32 %2, [21 x i64]* %3)
%44 = add nsw i64 %43, %42
%45 = icmp sgt i64 %44, %41
%46 = select i1 %45, i64 %44, i64 %41
%47 = add nuw nsw i32 %40, 1
%48 = icmp eq i32 %47, %1
br i1 %48, label %49, label %39
49: ; preds = %39, %34, %31
%50 = phi i64 [ 0, %31 ], [ %37, %34 ], [ %46, %39 ]
%51 = add nsw i64 %50, %32
br label %68
52: ; preds = %10
%53 = tail call i64 @calculate(i32 %0, i32 %0, i32 %2, [21 x i64]* %3)
%54 = add nsw i32 %0, 1
%55 = tail call i64 @calculate(i32 %54, i32 %1, i32 %2, [21 x i64]* %3)
%56 = add nsw i64 %55, %53
%57 = icmp slt i32 %54, %1
br i1 %57, label %58, label %68
58: ; preds = %52, %58
%59 = phi i32 [ %62, %58 ], [ %54, %52 ]
%60 = phi i64 [ %66, %58 ], [ %56, %52 ]
%61 = tail call i64 @calculate(i32 %0, i32 %59, i32 %2, [21 x i64]* %3)
%62 = add nsw i32 %59, 1
%63 = tail call i64 @calculate(i32 %62, i32 %1, i32 %2, [21 x i64]* %3)
%64 = add nsw i64 %63, %61
%65 = icmp slt i64 %60, %64
%66 = select i1 %65, i64 %64, i64 %60
%67 = icmp eq i32 %62, %1
br i1 %67, label %68, label %58
68: ; preds = %58, %52, %49
%69 = phi i64 [ %51, %49 ], [ %56, %52 ], [ %66, %58 ]
store i64 %69, i64* %7
br label %70
70: ; preds = %4, %68
%71 = phi i64 [ %69, %68 ], [ %8, %4 ]
ret i64 %71
}