#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 /*<<< orphan*/ printf(char *, long long);
int /*<<< orphan*/ scanf(char *, ...);
int main() {
  int t, n, i, j, k;
  long long tmp, a[400][400], p[400][400] = {};
  for (scanf("%d", &t); t--; printf("%lld\n", tmp)) {
    scanf("%d", &n);
    for (i = 0; i < n; ++i)
      scanf("%lld", *a + i);
    for (i = 1; i < n; ++i)
      for (j = 0; j < n; ++j) {
        p[i][j] = p[i - 1][j];
        for (k = 1; k < i; ++k) {
          tmp = p[k - 1][j] + p[i - k][(j + k) % n];
          if (tmp < p[i][j])
            p[i][j] = tmp;
        }
        p[i][j] += a[i][j] = a[i - 1][j] + a[0][(i + j) % n];
      }
    long long *m = p[n - 1];
    tmp = *m;
    for (i = 1; i < n; ++i)
      if (m[i] < tmp)
        tmp = m[i];
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x271040,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x271020(%rbp),%rdi
xor    %esi,%esi
mov    $0x138800,%edx
call   1040 <memset@plt>
lea    0xea4(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x8(%rbp)
cmp    $0x0,%eax
je     143f <main+0x30f>
lea    0xe7e(%rip),%rdi
lea    -0xc(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11ce <main+0x9e>
lea    -0x138820(%rbp),%rsi
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
lea    0xe4a(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1194 <main+0x64>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13a4 <main+0x274>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1391 <main+0x261>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x271020(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
movslq -0x10(%rbp),%rcx
lea    -0x271020(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12ff <main+0x1cf>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x271020(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x271030(%rbp)
mov    -0x10(%rbp),%eax
sub    -0x18(%rbp),%eax
cltq
lea    -0x271020(%rbp),%rcx
imul   $0xc80,%rax,%rax
add    %rax,%rcx
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    -0x271030(%rbp),%rax
movslq %edx,%rdx
add    (%rcx,%rdx,8),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rdx
lea    -0x271020(%rbp),%rcx
imul   $0xc80,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jge    12ec <main+0x1bc>
mov    -0x20(%rbp),%rdx
movslq -0x10(%rbp),%rcx
lea    -0x271020(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    12f1 <main+0x1c1>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    123a <main+0x10a>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x138820(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x271038(%rbp)
mov    -0x10(%rbp),%eax
add    -0x14(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    %edx,%eax
mov    -0x271038(%rbp),%rdx
cltq
add    -0x138820(%rbp,%rax,8),%rdx
ff
movslq -0x10(%rbp),%rcx
lea    -0x138820(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0x10(%rbp),%rcx
lea    -0x271020(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
add    (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11e8 <main+0xb8>
jmp    1396 <main+0x266>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11d5 <main+0xa5>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x271020(%rbp),%rax
imul   $0xc80,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x271028(%rbp)
mov    -0x271028(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1425 <main+0x2f5>
mov    -0x271028(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmp    -0x20(%rbp),%rax
jge    1412 <main+0x2e2>
mov    -0x271028(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x20(%rbp)
jmp    1417 <main+0x2e7>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13da <main+0x2aa>
jmp    142a <main+0x2fa>
mov    -0x20(%rbp),%rsi
lea    0xbd3(%rip),%rdi
call   1030 <printf@plt>
jmp    1167 <main+0x37>
xor    %eax,%eax
add    $0x271040,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x271028,%rsp
lea    0x20(%rsp),%rdi
mov    $0x138800,%edx
xor    %esi,%esi
call   1040 <memset@plt>
lea    0xea7(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
subl   $0x1,0x4(%rsp)
jae    1180 <main+0x50>
xor    %eax,%eax
add    $0x271028,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xe79(%rip),%r14
mov    %rsp,%r15
lea    0x138820(%rsp),%r12
lea    0xe6a(%rip),%r13
jmp    11c5 <main+0x95>
nopl   0x0(%rax,%rax,1)
add    $0xffffffff,%edi
movslq %edi,%rax
imul   $0xc80,%rax,%rax
mov    0x20(%rsp,%rax,1),%rsi
lea    0xe4f(%rip),%rdi
call   1030 <printf@plt>
subl   $0x1,0x4(%rsp)
jb     116c <main+0x3c>
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
mov    (%rsp),%edi
test   %edi,%edi
jle    11a0 <main+0x70>
mov    %r12,%rbp
xor    %ebx,%ebx
xchg   %ax,%ax
mov    %r13,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
add    $0x1,%rbx
mov    (%rsp),%edi
movslq %edi,%rax
add    $0x8,%rbp
cmp    %rax,%rbx
jl     11e0 <main+0xb0>
cmp    $0x2,%edi
jl     11a0 <main+0x70>
mov    %rax,0x10(%rsp)
mov    $0x1,%r11d
xor    %ebx,%ebx
lea    0x20(%rsp),%rax
mov    %rax,0x8(%rsp)
jmp    123d <main+0x10d>
xchg   %ax,%ax
add    $0x1,%r11
addq   $0xc80,0x8(%rsp)
add    $0xc80,%rbx
cmp    %rdi,%r11
je     1330 <main+0x200>
lea    -0x1(%r11),%rax
mov    %rax,0x18(%rsp)
mov    $0x1,%esi
lea    0x20(%rsp),%rbp
xor    %r15d,%r15d
jmp    12a7 <main+0x177>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rsp,%r8,1),%rcx
add    $0x138820,%rcx
lea    (%r15,%r11,1),%eax
cltd
idiv   %edi
mov    0x138820(%rsp,%rdx,8),%rax
add    (%rcx,%r15,8),%rax
lea    (%rsp,%r13,1),%rcx
add    $0x138820,%rcx
mov    %rax,(%rcx,%r15,8)
add    %r12,%rax
mov    %rax,(%r14)
add    $0x1,%r15
add    $0x1,%esi
add    $0x8,%rbp
cmp    %rdi,%r15
je     1220 <main+0xf0>
imul   $0xc80,0x18(%rsp),%r8
imul   $0xc80,%r11,%r13
lea    (%rsp,%r8,1),%rax
add    $0x20,%rax
mov    (%rax,%r15,8),%r12
lea    (%rsp,%r13,1),%rax
add    $0x20,%rax
lea    (%rax,%r15,8),%r14
mov    %r12,(%rax,%r15,8)
cmp    $0x2,%r11
jb     1260 <main+0x130>
xor    %r9d,%r9d
mov    0x8(%rsp),%r10
mov    %esi,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,%eax
cltd
idiv   %edi
mov    (%r10,%rdx,8),%rax
add    0x0(%rbp,%r9,1),%rax
cmp    %r12,%rax
cmovl  %rax,%r12
mov    %r12,(%r14)
add    $0x1,%ecx
add    $0xfffffffffffff380,%r10
add    $0xc80,%r9
cmp    %r9,%rbx
jne    12f0 <main+0x1c0>
jmp    1260 <main+0x130>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x10(%rsp),%rax
add    $0xffffffffffffffff,%rax
imul   $0xc80,%rax,%r8
mov    0x20(%rsp,%r8,1),%rsi
cmp    $0x2,%edi
jl     1389 <main+0x259>
lea    -0x1(%rdi),%rax
lea    -0x2(%rdi),%rcx
mov    %eax,%edi
and    $0x3,%edi
mov    $0x1,%edx
cmp    $0x3,%rcx
jae    13a7 <main+0x277>
lea    0xc97(%rip),%r14
mov    %rsp,%r15
lea    0x138820(%rsp),%r12
lea    0xc88(%rip),%r13
test   %rdi,%rdi
jne    142b <main+0x2fb>
jmp    11b2 <main+0x82>
lea    0xc70(%rip),%r14
mov    %rsp,%r15
lea    0x138820(%rsp),%r12
lea    0xc61(%rip),%r13
jmp    11b2 <main+0x82>
and    $0xfffffffffffffffc,%rax
lea    0x40(%rsp),%rcx
lea    (%rcx,%r8,1),%rbp
xor    %edx,%edx
lea    0xc43(%rip),%r14
mov    %rsp,%r15
lea    0x138820(%rsp),%r12
lea    0xc34(%rip),%r13
jmp    13e9 <main+0x2b9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    %rdx,%rax
je     141e <main+0x2ee>
mov    -0x18(%rbp,%rdx,8),%rbx
mov    -0x10(%rbp,%rdx,8),%rcx
cmp    %rsi,%rbx
cmovl  %rbx,%rsi
cmp    %rsi,%rcx
jl     1402 <main+0x2d2>
mov    %rsi,%rcx
mov    -0x8(%rbp,%rdx,8),%rbx
cmp    %rcx,%rbx
jl     140f <main+0x2df>
mov    %rcx,%rbx
mov    0x0(%rbp,%rdx,8),%rsi
cmp    %rbx,%rsi
jl     13e0 <main+0x2b0>
mov    %rbx,%rsi
jmp    13e0 <main+0x2b0>
add    $0x1,%rdx
test   %rdi,%rdi
je     11b2 <main+0x82>
lea    (%rsp,%rdx,8),%rax
add    $0x20,%rax
add    %r8,%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rcx,8),%rdx
cmp    %rsi,%rdx
cmovl  %rdx,%rsi
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1440 <main+0x310>
jmp    11b2 <main+0x82>

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

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