int matrix_chain(const int *p, int n) {
  int **c;
  int **s;
  c = malloc(sizeof(int *) * n);
  if (!c)
    return -1;
  int i, j;
  for (i = 0; i < n; ++i) {
    c[i] = malloc(sizeof(int) * n);
    if (!c[i]) {
      for (j = 0; j < i; ++j) {
        free(c[j]);
      }
      free(c);
      return -1;
    }
    c[i][i] = 0;
  }
  s = malloc(sizeof(int *) * n);
  if (!s) {
    for (i = 0; j < n; ++i) {
      free(c[i]);
    }
    free(c);
    return -1;
  }
  for (i = 0; i < n; ++i) {
    s[i] = malloc(sizeof(int) * n);
    if (!s[i]) {
      for (j = 0; j < n; ++j) {
        free(c[j]);
      }
      free(c);
      for (j = 0; j < i; ++j) {
        free(s[j]);
      }
      free(s);
      return -1;
    }
    s[i][i] = -1;
  }
  int len;
  for (len = 2; len <= n; ++len) {
    int start;
    for (start = 0; start <= n - len; ++start) {
      int end;
      int sep;
      end = start + len;
      c[start][end - 1] =
          c[start + 1][end - 1] + p[start] * p[start + 1] * p[end];
      s[start][end - 1] = start + 1;
      for (sep = start + 2; sep < end; ++sep) {
        int temp;
        temp = c[start][sep - 1] + c[sep][end - 1] + p[start] * p[sep] * p[end];
        if (temp < c[start][end - 1]) {
          c[start][end - 1] = temp;
          s[start][end - 1] = sep;
        }
      }
    }
  }
  print_s(s, n);
  print_s(c, n);
  print_solution(s, 0, n - 1);
  int cost;
  cost = c[0][n - 1];
  for (i = 0; i < n; ++i) {
    free(c[i]);
    free(s[i]);
  }
  free(s);
  free(c);
  return cost;
}


x86 assembly (clang, -O0):
<matrix_chain>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    1177 <matrix_chain+0x37>
movl   $0xffffffff,-0x4(%rbp)
jmp    15bf <matrix_chain+0x47f>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1225 <matrix_chain+0xe5>
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    1200 <matrix_chain+0xc0>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    11eb <matrix_chain+0xab>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11c0 <matrix_chain+0x80>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    15bf <matrix_chain+0x47f>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    117e <matrix_chain+0x3e>
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    1288 <matrix_chain+0x148>
movl   $0x0,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1273 <matrix_chain+0x133>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1248 <matrix_chain+0x108>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    15bf <matrix_chain+0x47f>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1371 <matrix_chain+0x231>
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    134c <matrix_chain+0x20c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12fc <matrix_chain+0x1bc>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12d1 <matrix_chain+0x191>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1337 <matrix_chain+0x1f7>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    130c <matrix_chain+0x1cc>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    15bf <matrix_chain+0x47f>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    128f <matrix_chain+0x14f>
movl   $0x2,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     151f <matrix_chain+0x3df>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jg     150c <matrix_chain+0x3cc>
mov    -0x38(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x38(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
imul   (%rcx,%rsi,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x3c(%rbp),%rsi
imul   (%rcx,%rsi,4),%eax
add    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%edx
add    $0x1,%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    14f9 <matrix_chain+0x3b9>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    -0x10(%rbp),%rdx
movslq -0x40(%rbp),%rsi
imul   (%rdx,%rsi,4),%ecx
mov    -0x10(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
imul   (%rdx,%rsi,4),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    14e6 <matrix_chain+0x3a6>
mov    -0x44(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    14eb <matrix_chain+0x3ab>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    142b <matrix_chain+0x2eb>
jmp    14fe <matrix_chain+0x3be>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    138b <matrix_chain+0x24b>
jmp    1511 <matrix_chain+0x3d1>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1378 <matrix_chain+0x238>
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1040 <print_s@plt>
mov    -0x20(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1040 <print_s@plt>
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
mov    $0x0,%al
call   1060 <print_solution@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15a7 <matrix_chain+0x467>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    156b <matrix_chain+0x42b>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matrix_chain>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %esi,%ebx
mov    %rdi,%rbp
movslq %esi,%rax
mov    %rax,0x20(%rsp)
lea    0x0(,%rax,8),%r14
mov    %r14,%rdi
call   1050 <malloc@plt>
mov    $0xffffffff,%r13d
test   %rax,%rax
je     13d0 <matrix_chain+0x290>
mov    %rax,%r12
mov    %ebx,%r15d
test   %ebx,%ebx
jle    1313 <matrix_chain+0x1d3>
mov    %rbx,0x18(%rsp)
mov    0x20(%rsp),%rax
lea    0x0(,%rax,4),%r13
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %r13,%rdi
call   1050 <malloc@plt>
mov    %rax,(%r12,%rbx,8)
test   %rax,%rax
je     139d <matrix_chain+0x25d>
movl   $0x0,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    11a0 <matrix_chain+0x60>
mov    %r14,%rdi
call   1050 <malloc@plt>
test   %rax,%rax
mov    0x18(%rsp),%rbx
je     13c2 <matrix_chain+0x282>
mov    %rax,%r14
test   %ebx,%ebx
jle    1327 <matrix_chain+0x1e7>
mov    %r15,0x8(%rsp)
xor    %r15d,%r15d
xchg   %ax,%ax
mov    %r13,%rdi
call   1050 <malloc@plt>
mov    %rax,(%r14,%r15,8)
test   %rax,%rax
je     13e2 <matrix_chain+0x2a2>
movl   $0xffffffff,(%rax,%r15,4)
ff
add    $0x1,%r15
cmp    %r15,0x8(%rsp)
jne    11f0 <matrix_chain+0xb0>
mov    0x8(%rsp),%r15
cmp    $0x1,%r15d
jle    1327 <matrix_chain+0x1e7>
mov    %r14,0x28(%rsp)
lea    -0x1(%rbx),%eax
lea    0x1(%rbx),%ecx
mov    %rcx,0x30(%rsp)
mov    $0x2,%r11d
mov    %eax,0x14(%rsp)
mov    %eax,0x4(%rsp)
jmp    1264 <matrix_chain+0x124>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
addl   $0xffffffff,0x4(%rsp)
cmp    0x30(%rsp),%r11
je     143a <matrix_chain+0x2fa>
cmp    0x20(%rsp),%r11
jg     1250 <matrix_chain+0x110>
mov    0x4(%rsp),%r10d
mov    (%r12),%r15
mov    $0x2,%r14d
xor    %r9d,%r9d
jmp    1289 <matrix_chain+0x149>
nop
add    $0x1,%r14d
cmp    %r10,%r9
je     1250 <matrix_chain+0x110>
mov    %r9,%rdx
mov    %r15,%rax
lea    (%r9,%r11,1),%rcx
add    $0x1,%r9
mov    0x8(%r12,%rdx,8),%r15
mov    0x4(%rbp,%rdx,4),%ebx
imul   0x0(%rbp,%rdx,4),%ebx
imul   0x0(%rbp,%rcx,4),%ebx
add    -0x4(%r15,%rcx,4),%ebx
mov    %ebx,-0x4(%rax,%rcx,4)
mov    0x28(%rsp),%rsi
mov    (%rsi,%rdx,8),%rbx
mov    %r9d,-0x4(%rbx,%rcx,4)
cmp    $0x3,%r11
jb     1280 <matrix_chain+0x140>
movslq %r14d,%r13
jmp    12dc <matrix_chain+0x19c>
nopl   0x0(%rax)
add    $0x1,%r13
mov    %r13d,%esi
cmp    %rcx,%rsi
jae    1280 <matrix_chain+0x140>
mov    %r13d,%esi
mov    (%r12,%rsi,8),%rdi
mov    -0x4(%rdi,%rcx,4),%edi
add    -0x4(%rax,%r13,4),%edi
mov    0x0(%rbp,%rsi,4),%r8d
imul   0x0(%rbp,%rdx,4),%r8d
imul   0x0(%rbp,%rcx,4),%r8d
add    %edi,%r8d
cmp    -0x4(%rax,%rcx,4),%r8d
jge    12d0 <matrix_chain+0x190>
mov    %r8d,-0x4(%rax,%rcx,4)
mov    %r13d,-0x4(%rbx,%rcx,4)
jmp    12d0 <matrix_chain+0x190>
mov    %r14,%rdi
call   1050 <malloc@plt>
test   %rax,%rax
je     13c2 <matrix_chain+0x282>
mov    %rax,%r14
lea    -0x1(%rbx),%ebp
mov    %r14,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <print_s@plt>
mov    %r12,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <print_s@plt>
mov    %r14,%rdi
xor    %esi,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1060 <print_solution@plt>
mov    (%r12),%rax
movslq %ebp,%rcx
mov    (%rax,%rcx,4),%r13d
test   %ebx,%ebx
jle    138b <matrix_chain+0x24b>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
mov    (%r14,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1370 <matrix_chain+0x230>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
jmp    13d0 <matrix_chain+0x290>
test   %ebx,%ebx
je     13c2 <matrix_chain+0x282>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r12,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    13b0 <matrix_chain+0x270>
mov    %r12,%rdi
call   1030 <free@plt>
mov    $0xffffffff,%r13d
mov    %r13d,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebx,%ebx
mov    0x8(%rsp),%rbp
nopl   0x0(%rax)
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    13f0 <matrix_chain+0x2b0>
mov    %r12,%rdi
call   1030 <free@plt>
test   %r15d,%r15d
mov    $0xffffffff,%r13d
je     1432 <matrix_chain+0x2f2>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1420 <matrix_chain+0x2e0>
mov    %r14,%rdi
jmp    1396 <matrix_chain+0x256>
mov    0x8(%rsp),%r15
mov    0x28(%rsp),%r14
mov    0x18(%rsp),%rbx
mov    0x14(%rsp),%ebp
jmp    132a <matrix_chain+0x1ea>

LLVM IR (-O0):
define i32 @matrix_chain(i32* %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32**
%7 = alloca i32**
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
%16 = load i32, i32* %5
%17 = sext i32 %16 to i64
%18 = mul i64 8, %17
%19 = call i8* @malloc(i64 %18)
%20 = bitcast i8* %19 to i32**
store i32** %20, i32*** %6
%21 = load i32**, i32*** %6
%22 = icmp ne i32** %21, null
br i1 %22, label %24, label %23
23: ; preds = %2
store i32 -1, i32* %3
br label %371
24: ; preds = %2
store i32 0, i32* %8
br label %25
25: ; preds = %72, %24
%26 = load i32, i32* %8
%27 = load i32, i32* %5
%28 = icmp slt i32 %26, %27
br i1 %28, label %29, label %75
29: ; preds = %25
%30 = load i32, i32* %5
%31 = sext i32 %30 to i64
%32 = mul i64 4, %31
%33 = call i8* @malloc(i64 %32)
%34 = bitcast i8* %33 to i32*
%35 = load i32**, i32*** %6
%36 = load i32, i32* %8
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i32*, i32** %35, i64 %37
store i32* %34, i32** %38
%39 = load i32**, i32*** %6
%40 = load i32, i32* %8
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i32*, i32** %39, i64 %41
%43 = load i32*, i32** %42
%44 = icmp ne i32* %43, null
br i1 %44, label %63, label %45
45: ; preds = %29
store i32 0, i32* %9
br label %46
46: ; preds = %57, %45
%47 = load i32, i32* %9
%48 = load i32, i32* %8
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %60
50: ; preds = %46
%51 = load i32**, i32*** %6
%52 = load i32, i32* %9
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32*, i32** %51, i64 %53
%55 = load i32*, i32** %54
%56 = bitcast i32* %55 to i8*
br label %57
57: ; preds = %50
%58 = load i32, i32* %9
%59 = add nsw i32 %58, 1
store i32 %59, i32* %9
br label %46
60: ; preds = %46
%61 = load i32**, i32*** %6
%62 = bitcast i32** %61 to i8*
store i32 -1, i32* %3
br label %371
63: ; preds = %29
%64 = load i32**, i32*** %6
%65 = load i32, i32* %8
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i32*, i32** %64, i64 %66
%68 = load i32*, i32** %67
%69 = load i32, i32* %8
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i32, i32* %68, i64 %70
store i32 0, i32* %71
br label %72
72: ; preds = %63
%73 = load i32, i32* %8
%74 = add nsw i32 %73, 1
store i32 %74, i32* %8
br label %25
75: ; preds = %25
%76 = load i32, i32* %5
%77 = sext i32 %76 to i64
%78 = mul i64 8, %77
%79 = call i8* @malloc(i64 %78)
%80 = bitcast i8* %79 to i32**
store i32** %80, i32*** %7
%81 = load i32**, i32*** %7
%82 = icmp ne i32** %81, null
br i1 %82, label %101, label %83
83: ; preds = %75
store i32 0, i32* %8
br label %84
84: ; preds = %95, %83
%85 = load i32, i32* %9
%86 = load i32, i32* %5
%87 = icmp slt i32 %85, %86
br i1 %87, label %88, label %98
88: ; preds = %84
%89 = load i32**, i32*** %6
%90 = load i32, i32* %8
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i32*, i32** %89, i64 %91
%93 = load i32*, i32** %92
%94 = bitcast i32* %93 to i8*
br label %95
95: ; preds = %88
%96 = load i32, i32* %8
%97 = add nsw i32 %96, 1
store i32 %97, i32* %8
br label %84
98: ; preds = %84
%99 = load i32**, i32*** %6
%100 = bitcast i32** %99 to i8*
store i32 -1, i32* %3
br label %371
101: ; preds = %75
store i32 0, i32* %8
br label %102
102: ; preds = %166, %101
%103 = load i32, i32* %8
%104 = load i32, i32* %5
%105 = icmp slt i32 %103, %104
br i1 %105, label %106, label %169
106: ; preds = %102
%107 = load i32, i32* %5
%108 = sext i32 %107 to i64
%109 = mul i64 4, %108
%110 = call i8* @malloc(i64 %109)
%111 = bitcast i8* %110 to i32*
%112 = load i32**, i32*** %7
%113 = load i32, i32* %8
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i32*, i32** %112, i64 %114
store i32* %111, i32** %115
%116 = load i32**, i32*** %7
%117 = load i32, i32* %8
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32*, i32** %116, i64 %118
%120 = load i32*, i32** %119
%121 = icmp ne i32* %120, null
br i1 %121, label %157, label %122
122: ; preds = %106
store i32 0, i32* %9
br label %123
123: ; preds = %134, %122
%124 = load i32, i32* %9
%125 = load i32, i32* %5
%126 = icmp slt i32 %124, %125
br i1 %126, label %127, label %137
127: ; preds = %123
%128 = load i32**, i32*** %6
%129 = load i32, i32* %9
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds i32*, i32** %128, i64 %130
%132 = load i32*, i32** %131
%133 = bitcast i32* %132 to i8*
br label %134
134: ; preds = %127
%135 = load i32, i32* %9
%136 = add nsw i32 %135, 1
store i32 %136, i32* %9
br label %123
137: ; preds = %123
%138 = load i32**, i32*** %6
%139 = bitcast i32** %138 to i8*
store i32 0, i32* %9
br label %140
140: ; preds = %151, %137
%141 = load i32, i32* %9
%142 = load i32, i32* %8
%143 = icmp slt i32 %141, %142
br i1 %143, label %144, label %154
144: ; preds = %140
%145 = load i32**, i32*** %7
%146 = load i32, i32* %9
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32*, i32** %145, i64 %147
%149 = load i32*, i32** %148
%150 = bitcast i32* %149 to i8*
br label %151
151: ; preds = %144
%152 = load i32, i32* %9
%153 = add nsw i32 %152, 1
store i32 %153, i32* %9
br label %140
154: ; preds = %140
%155 = load i32**, i32*** %7
%156 = bitcast i32** %155 to i8*
store i32 -1, i32* %3
br label %371
157: ; preds = %106
%158 = load i32**, i32*** %7
%159 = load i32, i32* %8
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32*, i32** %158, i64 %160
%162 = load i32*, i32** %161
%163 = load i32, i32* %8
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i32, i32* %162, i64 %164
store i32 -1, i32* %165
br label %166
166: ; preds = %157
%167 = load i32, i32* %8
%168 = add nsw i32 %167, 1
store i32 %168, i32* %8
br label %102
169: ; preds = %102
store i32 2, i32* %10
br label %170
170: ; preds = %323, %169
%171 = load i32, i32* %10
%172 = load i32, i32* %5
%173 = icmp sle i32 %171, %172
br i1 %173, label %174, label %326
174: ; preds = %170
store i32 0, i32* %11
br label %175
175: ; preds = %319, %174
%176 = load i32, i32* %11
%177 = load i32, i32* %5
%178 = load i32, i32* %10
%179 = sub nsw i32 %177, %178
%180 = icmp sle i32 %176, %179
br i1 %180, label %181, label %322
181: ; preds = %175
%182 = load i32, i32* %11
%183 = load i32, i32* %10
%184 = add nsw i32 %182, %183
store i32 %184, i32* %12
%185 = load i32**, i32*** %6
%186 = load i32, i32* %11
%187 = add nsw i32 %186, 1
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i32*, i32** %185, i64 %188
%190 = load i32*, i32** %189
%191 = load i32, i32* %12
%192 = sub nsw i32 %191, 1
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i32, i32* %190, i64 %193
%195 = load i32, i32* %194
%196 = load i32*, i32** %4
%197 = load i32, i32* %11
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i32, i32* %196, i64 %198
%200 = load i32, i32* %199
%201 = load i32*, i32** %4
%202 = load i32, i32* %11
%203 = add nsw i32 %202, 1
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i32, i32* %201, i64 %204
%206 = load i32, i32* %205
%207 = mul nsw i32 %200, %206
%208 = load i32*, i32** %4
%209 = load i32, i32* %12
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i32, i32* %208, i64 %210
%212 = load i32, i32* %211
%213 = mul nsw i32 %207, %212
%214 = add nsw i32 %195, %213
%215 = load i32**, i32*** %6
%216 = load i32, i32* %11
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i32*, i32** %215, i64 %217
%219 = load i32*, i32** %218
%220 = load i32, i32* %12
%221 = sub nsw i32 %220, 1
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i32, i32* %219, i64 %222
store i32 %214, i32* %223
%224 = load i32, i32* %11
%225 = add nsw i32 %224, 1
%226 = load i32**, i32*** %7
%227 = load i32, i32* %11
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i32*, i32** %226, i64 %228
%230 = load i32*, i32** %229
%231 = load i32, i32* %12
%232 = sub nsw i32 %231, 1
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds i32, i32* %230, i64 %233
store i32 %225, i32* %234
%235 = load i32, i32* %11
%236 = add nsw i32 %235, 2
store i32 %236, i32* %13
br label %237
237: ; preds = %315, %181
%238 = load i32, i32* %13
%239 = load i32, i32* %12
%240 = icmp slt i32 %238, %239
br i1 %240, label %241, label %318
241: ; preds = %237
%242 = load i32**, i32*** %6
%243 = load i32, i32* %11
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds i32*, i32** %242, i64 %244
%246 = load i32*, i32** %245
%247 = load i32, i32* %13
%248 = sub nsw i32 %247, 1
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %246, i64 %249
%251 = load i32, i32* %250
%252 = load i32**, i32*** %6
%253 = load i32, i32* %13
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i32*, i32** %252, i64 %254
%256 = load i32*, i32** %255
%257 = load i32, i32* %12
%258 = sub nsw i32 %257, 1
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i32, i32* %256, i64 %259
%261 = load i32, i32* %260
%262 = add nsw i32 %251, %261
%263 = load i32*, i32** %4
%264 = load i32, i32* %11
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i32, i32* %263, i64 %265
%267 = load i32, i32* %266
%268 = load i32*, i32** %4
%269 = load i32, i32* %13
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i32, i32* %268, i64 %270
%272 = load i32, i32* %271
%273 = mul nsw i32 %267, %272
%274 = load i32*, i32** %4
%275 = load i32, i32* %12
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds i32, i32* %274, i64 %276
%278 = load i32, i32* %277
%279 = mul nsw i32 %273, %278
%280 = add nsw i32 %262, %279
store i32 %280, i32* %14
%281 = load i32, i32* %14
%282 = load i32**, i32*** %6
%283 = load i32, i32* %11
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i32*, i32** %282, i64 %284
%286 = load i32*, i32** %285
%287 = load i32, i32* %12
%288 = sub nsw i32 %287, 1
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i32, i32* %286, i64 %289
%291 = load i32, i32* %290
%292 = icmp slt i32 %281, %291
br i1 %292, label %293, label %314
293: ; preds = %241
%294 = load i32, i32* %14
%295 = load i32**, i32*** %6
%296 = load i32, i32* %11
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds i32*, i32** %295, i64 %297
%299 = load i32*, i32** %298
%300 = load i32, i32* %12
%301 = sub nsw i32 %300, 1
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds i32, i32* %299, i64 %302
store i32 %294, i32* %303
%304 = load i32, i32* %13
%305 = load i32**, i32*** %7
%306 = load i32, i32* %11
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds i32*, i32** %305, i64 %307
%309 = load i32*, i32** %308
%310 = load i32, i32* %12
%311 = sub nsw i32 %310, 1
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds i32, i32* %309, i64 %312
store i32 %304, i32* %313
br label %314
314: ; preds = %293, %241
br label %315
315: ; preds = %314
%316 = load i32, i32* %13
%317 = add nsw i32 %316, 1
store i32 %317, i32* %13
br label %237
318: ; preds = %237
br label %319
319: ; preds = %318
%320 = load i32, i32* %11
%321 = add nsw i32 %320, 1
store i32 %321, i32* %11
br label %175
322: ; preds = %175
br label %323
323: ; preds = %322
%324 = load i32, i32* %10
%325 = add nsw i32 %324, 1
store i32 %325, i32* %10
br label %170
326: ; preds = %170
%327 = load i32**, i32*** %7
%328 = load i32, i32* %5
%329 = call i32 (i32**, i32, ...) bitcast (i32 (...)* @print_s to i32 (i32**, i32, ...)*)(i32** %327, i32 %328)
%330 = load i32**, i32*** %6
%331 = load i32, i32* %5
%332 = call i32 (i32**, i32, ...) bitcast (i32 (...)* @print_s to i32 (i32**, i32, ...)*)(i32** %330, i32 %331)
%333 = load i32**, i32*** %7
%334 = load i32, i32* %5
%335 = sub nsw i32 %334, 1
%336 = call i32 (i32**, i32, i32, ...) bitcast (i32 (...)* @print_solution to i32 (i32**, i32, i32, ...)*)(i32** %333, i32 0, i32 %335)
%337 = load i32**, i32*** %6
%338 = getelementptr inbounds i32*, i32** %337, i64 0
%339 = load i32*, i32** %338
%340 = load i32, i32* %5
%341 = sub nsw i32 %340, 1
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds i32, i32* %339, i64 %342
%344 = load i32, i32* %343
store i32 %344, i32* %15
store i32 0, i32* %8
br label %345
345: ; preds = %362, %326
%346 = load i32, i32* %8
%347 = load i32, i32* %5
%348 = icmp slt i32 %346, %347
br i1 %348, label %349, label %365
349: ; preds = %345
%350 = load i32**, i32*** %6
%351 = load i32, i32* %8
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds i32*, i32** %350, i64 %352
%354 = load i32*, i32** %353
%355 = bitcast i32* %354 to i8*
%356 = load i32**, i32*** %7
%357 = load i32, i32* %8
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds i32*, i32** %356, i64 %358
%360 = load i32*, i32** %359
%361 = bitcast i32* %360 to i8*
br label %362
362: ; preds = %349
%363 = load i32, i32* %8
%364 = add nsw i32 %363, 1
store i32 %364, i32* %8
br label %345
365: ; preds = %345
%366 = load i32**, i32*** %7
%367 = bitcast i32** %366 to i8*
%368 = load i32**, i32*** %6
%369 = bitcast i32** %368 to i8*
%370 = load i32, i32* %15
store i32 %370, i32* %3
br label %371
371: ; preds = %365, %154, %98, %60, %23
%372 = load i32, i32* %3
ret i32 %372
}

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