void optimal_bst(float *p, float *q, int n, float (*e)[5 + 1],
                 int (*root)[5 + 1]) {
  int i, j, l, r;
  float t;
  float w[5 + 2][5 + 1] = {0};
  for (i = 1; i <= n + 1; i++) {
    e[i][i - 1] = q[i - 1];
    w[i][i - 1] = q[i - 1];
  }
  for (l = 1; l <= n; l++) {
    for (i = 1; i <= n - l + 1; i++) {
      j = i + l - 1;
      e[i][j] = 65535;
      w[i][j] = w[i][j - 1] + p[j] + q[j];
      for (r = i; r <= j; r++) {
        t = e[i][r - 1] + e[r + 1][j] + w[i][j];
        if (t < e[i][j]) {
          e[i][j] = t;
          root[i][j] = r;
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<optimal_bst>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0xa8,%edx
call   1030 <memset@plt>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     11c8 <optimal_bst+0xb8>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0xf0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1148 <optimal_bst+0x38>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1378 <optimal_bst+0x268>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1365 <optimal_bst+0x255>
mov    -0x2c(%rbp),%eax
add    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  0xde3(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq -0x2c(%rbp),%rcx
lea    -0xf0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0xf0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1352 <optimal_bst+0x242>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movslq -0x2c(%rbp),%rcx
lea    -0xf0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    133f <optimal_bst+0x22f>
movss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1344 <optimal_bst+0x234>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    127d <optimal_bst+0x16d>
jmp    1357 <optimal_bst+0x247>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11e2 <optimal_bst+0xd2>
jmp    136a <optimal_bst+0x25a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11cf <optimal_bst+0xbf>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<optimal_bst>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
xorps  %xmm0,%xmm0
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,(%rsp)
movaps %xmm0,-0x10(%rsp)
movaps %xmm0,-0x20(%rsp)
movaps %xmm0,-0x30(%rsp)
movaps %xmm0,-0x40(%rsp)
movaps %xmm0,-0x50(%rsp)
movaps %xmm0,-0x60(%rsp)
movq   $0x0,0x40(%rsp)
test   %edx,%edx
js     1336 <optimal_bst+0x236>
lea    0x1(%rdx),%r10d
test   %edx,%edx
je     1345 <optimal_bst+0x245>
mov    %r10d,%r9d
and    $0xfffffffe,%r9d
neg    %r9
mov    $0x1,%eax
mov    $0x6,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x4(%rsi,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rbx,4)
movss  -0x4(%rsi,%rax,4),%xmm0
movss  %xmm0,-0x60(%rsp,%rbx,4)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,0x1c(%rcx,%rbx,4)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,-0x44(%rsp,%rbx,4)
add    $0xe,%rbx
lea    (%r9,%rax,1),%rbp
add    $0x2,%rbp
add    $0x2,%rax
cmp    $0x1,%rbp
jne    1180 <optimal_bst+0x80>
test   $0x1,%r10b
je     11f9 <optimal_bst+0xf9>
movss  -0x4(%rsi,%rax,4),%xmm0
lea    0x0(,%rax,8),%rbp
lea    0x0(%rbp,%rbp,2),%rbp
lea    (%rcx,%rbp,1),%rbx
movss  %xmm0,-0x4(%rbx,%rax,4)
movss  -0x4(%rsi,%rax,4),%xmm0
add    %rsp,%rbp
add    $0xffffffffffffffa0,%rbp
movss  %xmm0,-0x4(%rbp,%rax,4)
test   %edx,%edx
jle    1336 <optimal_bst+0x236>
add    $0x2,%edx
lea    0x18(%rcx),%rax
mov    %rax,-0x70(%rsp)
lea    0x34(%rcx),%rax
mov    %rax,-0x78(%rsp)
mov    $0x2,%eax
mov    %rax,-0x80(%rsp)
mov    $0x1,%ebx
movss  0xdd3(%rip),%xmm0
mov    %r10,-0x68(%rsp)
jmp    125e <optimal_bst+0x15e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
addq   $0x1,-0x80(%rsp)
addq   $0x4,-0x78(%rsp)
mov    -0x68(%rsp),%r10
cmp    %r10,%rbx
je     1336 <optimal_bst+0x236>
mov    %r10d,%eax
sub    %ebx,%eax
test   %eax,%eax
jle    1240 <optimal_bst+0x140>
mov    $0x1,%r12d
mov    -0x78(%rsp),%r11
mov    -0x70(%rsp),%rax
mov    -0x80(%rsp),%r13
jmp    1295 <optimal_bst+0x195>
xchg   %ax,%ax
add    $0x1,%r12
add    $0x1,%r13
add    $0x1c,%rax
add    $0x1c,%r11
cmp    %rdx,%r13
je     1240 <optimal_bst+0x140>
lea    (%r12,%rbx,1),%r9
lea    0x0(,%r12,8),%rbp
lea    0x0(,%rbp,2),%r10
add    %rbp,%r10
lea    (%rcx,%r10,1),%r15
lea    -0x4(%r15,%r9,4),%rbp
movl   $0x477fff00,-0x4(%r15,%r9,4)
7f 47
lea    -0x60(%rsp,%r10,1),%r15
movss  -0x8(%r15,%r9,4),%xmm1
addss  -0x4(%rdi,%r9,4),%xmm1
addss  -0x4(%rsi,%r9,4),%xmm1
movss  %xmm1,-0x4(%r15,%r9,4)
add    %r8,%r10
lea    (%r10,%r9,4),%r9
add    $0xfffffffffffffffc,%r9
mov    %r11,%r15
xor    %r10d,%r10d
movaps %xmm0,%xmm2
jmp    1311 <optimal_bst+0x211>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r10
add    $0x18,%r15
cmp    %r10,%rbx
je     1280 <optimal_bst+0x180>
movss  (%rax,%r10,4),%xmm3
addss  (%r15),%xmm3
addss  %xmm1,%xmm3
ucomiss %xmm3,%xmm2
jbe    1300 <optimal_bst+0x200>
movss  %xmm3,0x0(%rbp)
lea    (%r12,%r10,1),%r14d
mov    %r14d,(%r9)
movaps %xmm3,%xmm2
jmp    1300 <optimal_bst+0x200>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%eax
test   $0x1,%r10b
jne    11c9 <optimal_bst+0xc9>
jmp    11f9 <optimal_bst+0xf9>

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

LLVM IR (-O2):
define void @optimal_bst(float* nocapture %0, float* nocapture %1, i32 %2, [6 x float]* nocapture %3, [6 x i32]* nocapture writeonly %4) {
%6 = alloca [7 x [6 x float]]
%7 = bitcast [7 x [6 x float]]* %6 to i8*
%8 = icmp slt i32 %2, 0
br i1 %8, label %99, label %9
9: ; preds = %5
%10 = add nuw i32 %2, 1
%11 = zext i32 %10 to i64
%12 = and i64 %11, 1
%13 = icmp eq i32 %2, 0
br i1 %13, label %16, label %14
14: ; preds = %9
%15 = and i64 %11, 4294967294
br label %33
16: ; preds = %33, %9
%17 = phi i64 [ 1, %9 ], [ %48, %33 ]
%18 = icmp eq i64 %12, 0
br i1 %18, label %26, label %19
19: ; preds = %16
%20 = add nsw i64 %17, -1
%21 = getelementptr inbounds float, float* %1, i64 %20
%22 = load float, float* %21
%23 = getelementptr inbounds [6 x float], [6 x float]* %3, i64 %17, i64 %20
store float %22, float* %23
%24 = load float, float* %21
%25 = getelementptr inbounds [7 x [6 x float]], [7 x [6 x float]]* %6, i64 0, i64 %17, i64 %20
store float %24, float* %25
br label %26
26: ; preds = %16, %19
%27 = icmp slt i32 %2, 1
br i1 %27, label %99, label %28
28: ; preds = %26
%29 = add nuw i32 %2, 1
%30 = add nuw i32 %2, 2
%31 = zext i32 %29 to i64
%32 = zext i32 %30 to i64
br label %51
33: ; preds = %33, %14
%34 = phi i64 [ 1, %14 ], [ %48, %33 ]
%35 = phi i64 [ 0, %14 ], [ %49, %33 ]
%36 = add nsw i64 %34, -1
%37 = getelementptr inbounds float, float* %1, i64 %36
%38 = load float, float* %37
%39 = getelementptr inbounds [6 x float], [6 x float]* %3, i64 %34, i64 %36
store float %38, float* %39
%40 = load float, float* %37
%41 = getelementptr inbounds [7 x [6 x float]], [7 x [6 x float]]* %6, i64 0, i64 %34, i64 %36
store float %40, float* %41
%42 = add nuw nsw i64 %34, 1
%43 = getelementptr inbounds float, float* %1, i64 %34
%44 = load float, float* %43
%45 = getelementptr inbounds [6 x float], [6 x float]* %3, i64 %42, i64 %34
store float %44, float* %45
%46 = load float, float* %43
%47 = getelementptr inbounds [7 x [6 x float]], [7 x [6 x float]]* %6, i64 0, i64 %42, i64 %34
store float %46, float* %47
%48 = add nuw nsw i64 %34, 2
%49 = add i64 %35, 2
%50 = icmp eq i64 %49, %15
br i1 %50, label %16, label %33
51: ; preds = %28, %95
%52 = phi i64 [ 1, %28 ], [ %96, %95 ]
%53 = phi i64 [ 2, %28 ], [ %97, %95 ]
%54 = trunc i64 %52 to i32
%55 = sub i32 %29, %54
%56 = icmp slt i32 %55, 1
br i1 %56, label %95, label %57
57: ; preds = %51, %91
%58 = phi i64 [ %93, %91 ], [ %53, %51 ]
%59 = phi i64 [ %92, %91 ], [ 1, %51 ]
%60 = add nuw nsw i64 %59, %52
%61 = add nsw i64 %60, -1
%62 = getelementptr inbounds [6 x float], [6 x float]* %3, i64 %59, i64 %61
store float 6.553500e+04, float* %62
%63 = add nsw i64 %60, -2
%64 = getelementptr inbounds [7 x [6 x float]], [7 x [6 x float]]* %6, i64 0, i64 %59, i64 %63
%65 = load float, float* %64
%66 = getelementptr inbounds float, float* %0, i64 %61
%67 = load float, float* %66
%68 = fadd float %65, %67
%69 = getelementptr inbounds float, float* %1, i64 %61
%70 = load float, float* %69
%71 = fadd float %68, %70
%72 = getelementptr inbounds [7 x [6 x float]], [7 x [6 x float]]* %6, i64 0, i64 %59, i64 %61
store float %71, float* %72
%73 = getelementptr inbounds [6 x i32], [6 x i32]* %4, i64 %59, i64 %61
br label %74
74: ; preds = %57, %88
%75 = phi float [ 6.553500e+04, %57 ], [ %89, %88 ]
%76 = phi i64 [ %59, %57 ], [ %80, %88 ]
%77 = add nsw i64 %76, -1
%78 = getelementptr inbounds [6 x float], [6 x float]* %3, i64 %59, i64 %77
%79 = load float, float* %78
%80 = add nuw nsw i64 %76, 1
%81 = getelementptr inbounds [6 x float], [6 x float]* %3, i64 %80, i64 %61
%82 = load float, float* %81
%83 = fadd float %79, %82
%84 = fadd float %71, %83
%85 = fcmp olt float %84, %75
br i1 %85, label %86, label %88
86: ; preds = %74
store float %84, float* %62
%87 = trunc i64 %76 to i32
store i32 %87, i32* %73
br label %88
88: ; preds = %74, %86
%89 = phi float [ %75, %74 ], [ %84, %86 ]
%90 = icmp eq i64 %80, %58
br i1 %90, label %91, label %74
91: ; preds = %88
%92 = add nuw nsw i64 %59, 1
%93 = add nuw nsw i64 %58, 1
%94 = icmp eq i64 %93, %32
br i1 %94, label %95, label %57
95: ; preds = %91, %51
%96 = add nuw nsw i64 %52, 1
%97 = add nuw nsw i64 %53, 1
%98 = icmp eq i64 %96, %31
br i1 %98, label %99, label %51
99: ; preds = %95, %5, %26
ret void
}