#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 *, int);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  int t, i, j;
  short int agnes[2100], tom[2100];
  int len_agnes, len_tom, ans;
  scanf("%d", &t);
  while (t--) {
    ans = 0;
    len_agnes = 0;
    len_tom = 0;
    int n;
    while (1) {
      scanf("%d", &n);
      if (n == 0)
        break;
      agnes[++len_agnes] = n;
    }
    while (1) {
      len_tom = 0;
      while (1) {
        scanf("%d", &n);
        if (n == 0)
          break;
        tom[++len_tom] = n;
      }
      if (len_tom == 0)
        break;
      int a[len_agnes + 1][len_tom + 1];
      for (i = 0; i <= len_agnes; i++)
        a[i][0] = 0;
      for (j = 0; j <= len_tom; j++)
        a[0][j] = 0;
      for (i = 1; i <= len_agnes; i++) {
        for (j = 1; j <= len_tom; j++) {
          if (agnes[i] == tom[j])
            a[i][j] = a[i - 1][j - 1] + 1;
          else if (a[i - 1][j] >= a[i][j - 1])
            a[i][j] = a[i - 1][j];
          else
            a[i][j] = a[i][j - 1];
        }
      }
      if (a[len_agnes][len_tom] >= ans) {
        ans = a[len_agnes][len_tom];
      }
    }
    printf("%d\n", ans);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2130,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xec7(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x8(%rbp)
cmp    $0x0,%eax
je     1534 <main+0x414>
movl   $0x0,-0x20fc(%rbp)
movl   $0x0,-0x20f4(%rbp)
movl   $0x0,-0x20f8(%rbp)
lea    0xe85(%rip),%rdi
lea    -0x2100(%rbp),%rsi
call   1040 <scanf@plt>
cmpl   $0x0,-0x2100(%rbp)
jne    1199 <main+0x79>
jmp    11c0 <main+0xa0>
mov    -0x2100(%rbp),%eax
mov    %ax,%cx
mov    -0x20f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20f4(%rbp)
cltq
mov    %cx,-0x1080(%rbp,%rax,2)
ff
jmp    1174 <main+0x54>
jmp    11c5 <main+0xa5>
movl   $0x0,-0x20f8(%rbp)
lea    0xe2a(%rip),%rdi
lea    -0x2100(%rbp),%rsi
call   1040 <scanf@plt>
cmpl   $0x0,-0x2100(%rbp)
jne    11f4 <main+0xd4>
jmp    121b <main+0xfb>
mov    -0x2100(%rbp),%eax
mov    %ax,%cx
mov    -0x20f8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20f8(%rbp)
cltq
mov    %cx,-0x20f0(%rbp,%rax,2)
ff
jmp    11cf <main+0xaf>
cmpl   $0x0,-0x20f8(%rbp)
jne    122d <main+0x10d>
jmp    151d <main+0x3fd>
mov    -0x20f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,%ecx
mov    -0x20f8(%rbp),%eax
add    $0x1,%eax
mov    %rax,-0x2128(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x2108(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x2120(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x2110(%rbp)
mov    %rax,-0x2118(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x20f4(%rbp),%eax
jg     12c4 <main+0x1a4>
mov    -0x2120(%rbp),%rax
mov    -0x2128(%rbp),%rdx
movslq -0xc(%rbp),%rcx
imul   %rdx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    128a <main+0x16a>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x20f8(%rbp),%eax
jg     130c <main+0x1ec>
mov    -0x2120(%rbp),%rax
mov    -0x2128(%rbp),%rcx
imul   $0x0,%rcx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12cb <main+0x1ab>
movl   $0x1,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x20f4(%rbp),%eax
jg     14a8 <main+0x388>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x20f8(%rbp),%eax
jg     1495 <main+0x375>
movslq -0xc(%rbp),%rax
movswl -0x1080(%rbp,%rax,2),%eax
ff
movslq -0x10(%rbp),%rcx
movswl -0x20f0(%rbp,%rcx,2),%ecx
ff
cmp    %ecx,%eax
jne    13a7 <main+0x287>
mov    -0x2120(%rbp),%rax
mov    -0x2128(%rbp),%rsi
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%edx
add    $0x1,%edx
movslq -0xc(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1482 <main+0x362>
mov    -0x2120(%rbp),%rcx
mov    -0x2128(%rbp),%rsi
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rcx,%rax
add    %rdx,%rax
movslq -0x10(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
movslq -0xc(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jl     143b <main+0x31b>
mov    -0x2120(%rbp),%rax
mov    -0x2128(%rbp),%rsi
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0xc(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    147d <main+0x35d>
mov    -0x2120(%rbp),%rax
mov    -0x2128(%rbp),%rsi
movslq -0xc(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
mov    -0x10(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0xc(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1482 <main+0x362>
jmp    1487 <main+0x367>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1329 <main+0x209>
jmp    149a <main+0x37a>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1313 <main+0x1f3>
mov    -0x2120(%rbp),%rax
mov    -0x2128(%rbp),%rdx
movslq -0x20f4(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20f8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x20fc(%rbp),%eax
jl     150e <main+0x3ee>
mov    -0x2120(%rbp),%rax
mov    -0x2128(%rbp),%rdx
movslq -0x20f4(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20f8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x20fc(%rbp)
mov    -0x2108(%rbp),%rax
mov    %rax,%rsp
jmp    11c5 <main+0xa5>
mov    -0x20fc(%rbp),%esi
lea    0xad9(%rip),%rdi
call   1030 <printf@plt>
jmp    1142 <main+0x22>
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    $0x2128,%rsp
lea    0xeb5(%rip),%rdi
lea    -0x34(%rbp),%rsi
call   1050 <scanf@plt>
subl   $0x1,-0x34(%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),%r14
lea    -0x2c(%rbp),%r15
jmp    1196 <main+0x66>
nopl   0x0(%rax,%rax,1)
xor    %ebx,%ebx
lea    0xe7a(%rip),%rdi
mov    %ebx,%esi
call   1030 <printf@plt>
subl   $0x1,-0x34(%rbp)
jb     115a <main+0x2a>
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <scanf@plt>
mov    -0x2c(%rbp),%eax
mov    $0x0,%ebx
test   %eax,%eax
je     11ce <main+0x9e>
xor    %ebx,%ebx
nop
mov    %ax,-0x214e(%rbp,%rbx,2)
ff
add    $0x1,%rbx
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <scanf@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
jne    11b0 <main+0x80>
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <scanf@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
je     1180 <main+0x50>
lea    0x1(%rbx),%ecx
mov    %ebx,%edx
mov    %rdx,-0x48(%rbp)
lea    -0x1(%rcx),%rdx
mov    %rdx,-0x60(%rbp)
mov    %ecx,%edx
and    $0x3,%edx
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x50(%rbp)
and    $0xfffffffc,%ecx
mov    %rcx,-0x58(%rbp)
xor    %ebx,%ebx
jmp    1246 <main+0x116>
nopl   0x0(%rax)
mov    -0x68(%rbp),%rsp
mov    -0x70(%rbp),%rax
imul   -0x48(%rbp),%rax
lea    (%r11,%rax,4),%rax
mov    (%rax,%r13,4),%eax
mov    -0x30(%rbp),%ebx
cmp    %ebx,%eax
cmovge %eax,%ebx
mov    %r12,%r14
mov    %r12,%rdi
mov    %r15,%rsi
call   1050 <scanf@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
je     1182 <main+0x52>
mov    %ebx,-0x30(%rbp)
mov    $0x1,%ebx
mov    $0x2,%ecx
xor    %r13d,%r13d
mov    %r14,%r12
nopl   0x0(%rax)
mov    %ecx,%r14d
mov    %ax,-0x10de(%rbp,%r13,2)
ff ff
add    $0x1,%r13
mov    %r12,%rdi
mov    %r15,%rsi
call   1050 <scanf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%ebx
lea    0x1(%r14),%ecx
test   %eax,%eax
jne    1260 <main+0x130>
test   %r13d,%r13d
je     13f0 <main+0x2c0>
mov    %rsp,%rdx
lea    0x1(%r13),%ecx
mov    %rcx,%rax
imul   -0x50(%rbp),%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rdi
sub    %rax,%rdi
mov    %rdi,%rsp
cmpq   $0x3,-0x60(%rbp)
mov    %rcx,-0x70(%rbp)
mov    %rdx,-0x68(%rbp)
jae    12d0 <main+0x1a0>
xor    %eax,%eax
jmp    1318 <main+0x1e8>
nopl   0x0(%rax)
mov    %ebx,%ecx
mov    %rcx,%rdx
shl    $0x4,%rdx
lea    0x0(,%rcx,4),%rax
lea    (%rax,%rax,2),%r8
mov    %rdi,%rsi
xor    %eax,%eax
mov    -0x58(%rbp),%rbx
xchg   %ax,%ax
movl   $0x0,(%rsi)
movl   $0x0,(%rsi,%rcx,4)
movl   $0x0,(%rsi,%rcx,8)
movl   $0x0,(%rsi,%r8,1)
add    $0x4,%rax
add    %rdx,%rsi
cmp    %rax,%rbx
jne    12f0 <main+0x1c0>
mov    %r14d,%r14d
cmpq   $0x0,-0x40(%rbp)
je     134f <main+0x21f>
imul   %r14,%rax
lea    (%rdi,%rax,4),%rax
lea    0x0(,%r14,4),%rcx
mov    -0x40(%rbp),%rdx
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,(%rax)
add    %rcx,%rax
add    $0xffffffffffffffff,%rdx
jne    1340 <main+0x210>
mov    %r13d,%r13d
lea    0x4(,%r13,4),%rdx
xor    %esi,%esi
mov    %rdi,%rbx
call   1040 <memset@plt>
mov    %rbx,%r11
cmpq   $0x0,-0x48(%rbp)
mov    -0x50(%rbp),%r10
je     1210 <main+0xe0>
lea    (%r11,%r14,4),%rax
lea    0x0(,%r14,4),%r8
mov    $0x1,%r9d
mov    %r11,%rsi
jmp    13a3 <main+0x273>
nopl   (%rax)
add    $0x1,%r9
add    %r8,%rax
add    %r8,%rsi
cmp    %r10,%r9
je     1210 <main+0xe0>
movzwl -0x2150(%rbp,%r9,2),%edi
ff ff
mov    $0x1,%ebx
jmp    13d3 <main+0x2a3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x4(%rsi,%rbx,4),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r14
je     1390 <main+0x260>
cmp    -0x10e0(%rbp,%rbx,2),%di
ff
je     13c0 <main+0x290>
mov    (%rsi,%rbx,4),%ecx
mov    -0x4(%rax,%rbx,4),%edx
cmp    %edx,%ecx
jge    13c7 <main+0x297>
mov    %edx,(%rax,%rbx,4)
jmp    13ca <main+0x29a>
nopl   (%rax)
mov    %r12,%r14
mov    -0x30(%rbp),%ebx
jmp    1182 <main+0x52>

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

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