main() {
  short int i, n, m, k, l, x, s = 0, y, z = 0;
  scanf("%sd", &n);
  while (n--) {
    scanf("%sd", &m);
    short int a[m][m];
    short int b[m];
    for (k = 0; k < m; k++) {
      for (l = 0; l <= k; k++) {
        scanf("%sd", &a[k][l]);
      }
    }
    for (k = 0; k < m; k++) {
      for (l = k; l < m; l++) {
        if (l != k && a[l][k] < a[l][k + 1])
          x = a[l][k + 1];
        else
          x = a[l][k];
        s = s + x;
      }
      if (k == 0) {
        b[z] = s;
        y = b[z];
        z++;
      }
      if (k != 0 && s > b[z - 1]) {
        b[z] = s;
        y = b[z];
        z++;
      }
      s = 0;
    }
    printf("\n");
    printf("%sd", y);
    z = 0;
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
movw   $0x0,-0x12(%rbp)
movw   $0x0,-0x16(%rbp)
lea    0xebe(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x8(%rbp),%ax
mov    %ax,%cx
add    $0xffff,%cx
mov    %cx,-0x8(%rbp)
cmp    $0x0,%ax
je     1425 <main+0x305>
lea    0xe93(%rip),%rdi
xor    %eax,%eax
lea    -0xa(%rbp),%rsi
call   1040 <scanf@plt>
movzwl -0xa(%rbp),%eax
mov    %rax,-0x50(%rbp)
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
mov    %rax,%rcx
imul   %rcx,%rcx
lea    0xf(%rcx,%rcx,1),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
mov    %rax,-0x30(%rbp)
movzwl -0xa(%rbp),%edx
mov    %edx,%eax
mov    %edx,%ecx
lea    0xf(%rcx,%rcx,1),%edx
mov    %edx,%ecx
and    $0xfffffff0,%ecx
mov    %ecx,%edx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x40(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
movw   $0x0,-0xc(%rbp)
movswl -0xc(%rbp),%eax
movswl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jge    1255 <main+0x135>
movw   $0x0,-0xe(%rbp)
movswl -0xe(%rbp),%eax
movswl -0xc(%rbp),%ecx
cmp    %ecx,%eax
jg     123f <main+0x11f>
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rcx
movswq -0xc(%rbp),%rax
imul   %rcx,%rax
shl    $0x1,%rax
add    %rax,%rsi
movswq -0xe(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
lea    0xdd9(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0xc(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xc(%rbp)
jmp    11ec <main+0xcc>
jmp    1244 <main+0x124>
mov    -0xc(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xc(%rbp)
jmp    11d6 <main+0xb6>
movw   $0x0,-0xc(%rbp)
movswl -0xc(%rbp),%eax
movswl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jge    13f3 <main+0x2d3>
mov    -0xc(%rbp),%ax
mov    %ax,-0xe(%rbp)
movswl -0xe(%rbp),%eax
movswl -0xa(%rbp),%ecx
cmp    %ecx,%eax
jge    1350 <main+0x230>
movswl -0xe(%rbp),%eax
movswl -0xc(%rbp),%ecx
cmp    %ecx,%eax
je     130c <main+0x1ec>
mov    -0x48(%rbp),%rcx
mov    -0x50(%rbp),%rsi
movswq -0xe(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x1,%rdx
mov    %rcx,%rax
add    %rdx,%rax
movswq -0xc(%rbp),%rdx
movswl (%rax,%rdx,2),%eax
movswq -0xe(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movswl -0xc(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jge    130c <main+0x1ec>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rdx
movswq -0xe(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
movswl -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%ax
mov    %ax,-0x10(%rbp)
jmp    1331 <main+0x211>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rdx
movswq -0xe(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x1,%rcx
add    %rcx,%rax
movswq -0xc(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
mov    %ax,-0x10(%rbp)
movswl -0x12(%rbp),%eax
movswl -0x10(%rbp),%ecx
add    %ecx,%eax
mov    %ax,-0x12(%rbp)
mov    -0xe(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xe(%rbp)
jmp    1273 <main+0x153>
movswl -0xc(%rbp),%eax
cmp    $0x0,%eax
jne    1387 <main+0x267>
mov    -0x40(%rbp),%rax
mov    -0x12(%rbp),%dx
movswq -0x16(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movswq -0x16(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
mov    %ax,-0x14(%rbp)
mov    -0x16(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x16(%rbp)
movswl -0xc(%rbp),%eax
cmp    $0x0,%eax
je     13dc <main+0x2bc>
mov    -0x40(%rbp),%rcx
movswl -0x12(%rbp),%eax
movswl -0x16(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jle    13dc <main+0x2bc>
mov    -0x40(%rbp),%rax
mov    -0x12(%rbp),%dx
movswq -0x16(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movswq -0x16(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
mov    %ax,-0x14(%rbp)
mov    -0x16(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x16(%rbp)
movw   $0x0,-0x12(%rbp)
mov    -0xc(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xc(%rbp)
jmp    125b <main+0x13b>
lea    0xc0a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movswl -0x14(%rbp),%esi
lea    0xbf4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movw   $0x0,-0x16(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
jmp    114d <main+0x2d>
xor    %eax,%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
lea    0xeb8(%rip),%rdi
lea    -0x2c(%rbp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
subw   $0x1,-0x2c(%rbp)
jae    116b <main+0x3b>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xe8e(%rip),%r15
jmp    11a3 <main+0x73>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0xa,%edi
call   1030 <putchar@plt>
movswl -0x2e(%rbp),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    -0x48(%rbp),%rsp
subw   $0x1,-0x2c(%rbp)
jb     115a <main+0x2a>
mov    %r15,%rdi
lea    -0x2a(%rbp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
mov    %rsp,%rdx
movzwl -0x2a(%rbp),%edi
mov    %rdi,%rax
imul   %rdi,%rax
mov    %rsp,%r13
add    %rax,%rax
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r13
mov    %r13,%rsp
movzwl -0x2a(%rbp),%eax
lea    (%rax,%rax,1),%ecx
add    $0xf,%ecx
and    $0xfffffff0,%ecx
mov    %rsp,%rsi
sub    %rcx,%rsi
mov    %rsi,-0x38(%rbp)
mov    %rsi,%rsp
test   %ax,%ax
mov    %rdx,-0x48(%rbp)
jle    1180 <main+0x50>
lea    (%rdi,%rdi,1),%r12
xor    %r14d,%r14d
mov    %rdi,-0x40(%rbp)
jmp    121a <main+0xea>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14d
cmp    %ax,%r14w
jge    1270 <main+0x140>
test   %r14w,%r14w
js     1210 <main+0xe0>
movzwl %r14w,%r14d
mov    %rdi,%rax
imul   %r14,%rax
lea    0x0(,%rax,2),%rbx
add    %r13,%rbx
cs nopw 0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
add    $0x1,%r14
add    %r12,%rbx
test   $0x8000,%r14d
je     1240 <main+0x110>
movzwl -0x2a(%rbp),%eax
mov    -0x40(%rbp),%rdi
jmp    1210 <main+0xe0>
nopw   0x0(%rax,%rax,1)
test   %ax,%ax
jle    1180 <main+0x50>
movzwl %ax,%r10d
lea    0x0(,%rdi,2),%r14
add    %r13,%r14
lea    0x2(%r12),%r8
mov    %r10,%rsi
neg    %rsi
xor    %ebx,%ebx
xor    %r9d,%r9d
jmp    12cb <main+0x19b>
nopw   0x0(%rax,%rax,1)
mov    -0x38(%rbp),%rcx
mov    %di,(%rcx,%rax,2)
add    $0x1,%eax
mov    %edi,%ecx
mov    %di,-0x2e(%rbp)
mov    %eax,%r9d
add    %r8,%r14
add    $0x1,%rsi
mov    %r11,%rbx
cmp    %r10,%r11
mov    -0x40(%rbp),%rdi
je     1180 <main+0x50>
lea    0x1(%rbx),%r11
mov    %rbx,%rax
imul   %rdi,%rax
lea    0x0(,%rax,2),%rax
add    %r13,%rax
movzwl (%rax,%rbx,2),%edx
cmp    %r10,%r11
jne    1310 <main+0x1e0>
mov    %edx,%edi
movswq %r9w,%rax
test   %rbx,%rbx
je     12a0 <main+0x170>
mov    -0x38(%rbp),%rcx
cmp    -0x2(%rcx,%rax,2),%di
jg     12a0 <main+0x170>
jmp    12b4 <main+0x184>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xffffffffffffffff,%rax
mov    %r14,%rcx
jmp    132f <main+0x1ff>
nopl   0x0(%rax)
movzwl (%rcx),%edi
add    %edx,%edi
add    %r12,%rcx
mov    %edi,%edx
cmp    %rax,%rsi
je     12ec <main+0x1bc>
sub    $0x1,%rax
jb     1320 <main+0x1f0>
movzwl 0x2(%rcx),%edi
cmp    %di,(%rcx)
jge    1320 <main+0x1f0>
jmp    1323 <main+0x1f3>

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

LLVM IR (-O2):
@.str = [4 x i8] c"%sd\00"
define i32 @main() {
%1 = alloca i16
%2 = alloca i16
%3 = bitcast i16* %1 to i8*
%4 = bitcast i16* %2 to i8*
%5 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i16* %1)
%6 = load i16, i16* %1
%7 = add i16 %6, -1
store i16 %7, i16* %1
%8 = icmp eq i16 %6, 0
br i1 %8, label %104, label %9
9: ; preds = %0, %96
%10 = phi i16 [ %97, %96 ], [ undef, %0 ]
%11 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i16* %2)
%12 = load i16, i16* %2
%13 = zext i16 %12 to i64
%14 = call i8* @llvm.stacksave()
%15 = mul nuw nsw i64 %13, %13
%16 = alloca i16, i64 %15
%17 = load i16, i16* %2
%18 = zext i16 %17 to i64
%19 = alloca i16, i64 %18
%20 = icmp sgt i16 %17, 0
br i1 %20, label %25, label %96
21: ; preds = %42
%22 = icmp sgt i16 %43, 0
br i1 %22, label %23, label %96
23: ; preds = %21
%24 = zext i16 %43 to i64
br label %47
25: ; preds = %9, %42
%26 = phi i16 [ %43, %42 ], [ %17, %9 ]
%27 = phi i16 [ %45, %42 ], [ 0, %9 ]
%28 = icmp sgt i16 %27, -1
br i1 %28, label %29, label %42
29: ; preds = %25
%30 = zext i16 %27 to i64
br label %31
31: ; preds = %29, %31
%32 = phi i64 [ %30, %29 ], [ %36, %31 ]
%33 = mul nuw nsw i64 %32, %13
%34 = getelementptr inbounds i16, i16* %16, i64 %33
%35 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i16* %34)
%36 = add i64 %32, 1
%37 = and i64 %36, 32768
%38 = icmp eq i64 %37, 0
br i1 %38, label %31, label %39
39: ; preds = %31
%40 = trunc i64 %36 to i16
%41 = load i16, i16* %2
br label %42
42: ; preds = %39, %25
%43 = phi i16 [ %26, %25 ], [ %41, %39 ]
%44 = phi i16 [ %27, %25 ], [ %40, %39 ]
%45 = add nsw i16 %44, 1
%46 = icmp slt i16 %45, %43
br i1 %46, label %25, label %21
47: ; preds = %23, %91
%48 = phi i64 [ 0, %23 ], [ %94, %91 ]
%49 = phi i16 [ 0, %23 ], [ %93, %91 ]
%50 = phi i16 [ %10, %23 ], [ %92, %91 ]
%51 = add nuw nsw i64 %48, 1
%52 = mul nuw nsw i64 %48, %13
%53 = getelementptr inbounds i16, i16* %16, i64 %52
%54 = getelementptr inbounds i16, i16* %53, i64 %48
%55 = load i16, i16* %54
%56 = icmp eq i64 %51, %24
br i1 %56, label %79, label %57
57: ; preds = %47
%58 = getelementptr inbounds i16, i16* %16, i64 %48
br label %59
59: ; preds = %57, %74
%60 = phi i64 [ %51, %57 ], [ %77, %74 ]
%61 = phi i16 [ %55, %57 ], [ %76, %74 ]
%62 = icmp eq i64 %60, %48
%63 = mul nuw nsw i64 %60, %13
br i1 %62, label %71, label %64
64: ; preds = %59
%65 = getelementptr inbounds i16, i16* %16, i64 %63
%66 = getelementptr inbounds i16, i16* %65, i64 %48
%67 = load i16, i16* %66
%68 = getelementptr inbounds i16, i16* %65, i64 %51
%69 = load i16, i16* %68
%70 = icmp slt i16 %67, %69
br i1 %70, label %74, label %71
71: ; preds = %59, %64
%72 = getelementptr inbounds i16, i16* %58, i64 %63
%73 = load i16, i16* %72
br label %74
74: ; preds = %64, %71
%75 = phi i16 [ %73, %71 ], [ %69, %64 ]
%76 = add i16 %75, %61
%77 = add nuw nsw i64 %60, 1
%78 = icmp eq i64 %77, %24
br i1 %78, label %79, label %59
79: ; preds = %74, %47
%80 = phi i16 [ %55, %47 ], [ %76, %74 ]
%81 = icmp eq i64 %48, 0
%82 = sext i16 %49 to i64
br i1 %81, label %88, label %83
83: ; preds = %79
%84 = add nsw i64 %82, -1
%85 = getelementptr inbounds i16, i16* %19, i64 %84
%86 = load i16, i16* %85
%87 = icmp sgt i16 %80, %86
br i1 %87, label %88, label %91
88: ; preds = %83, %79
%89 = getelementptr inbounds i16, i16* %19, i64 %82
store i16 %80, i16* %89
%90 = add i16 %49, 1
br label %91
91: ; preds = %88, %83
%92 = phi i16 [ %50, %83 ], [ %80, %88 ]
%93 = phi i16 [ %49, %83 ], [ %90, %88 ]
%94 = add nuw nsw i64 %48, 1
%95 = icmp eq i64 %94, %24
br i1 %95, label %96, label %47
96: ; preds = %91, %9, %21
%97 = phi i16 [ %10, %21 ], [ %10, %9 ], [ %92, %91 ]
%98 = call i32 @putchar(i32 10)
%99 = sext i16 %97 to i32
%100 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %99)
%101 = load i16, i16* %1
%102 = add i16 %101, -1
store i16 %102, i16* %1
%103 = icmp eq i16 %101, 0
br i1 %103, label %104, label %9
104: ; preds = %96, %0
ret i32 0
}