#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 */
scalar_t__ calloc(long long, int);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ scanf(char *, long long *, ...);
int main() {
  long long int i, j, k, l, R, C, r, c, t, x, y, count = 0, **a, **b;
  int ab[6];
  scanf("%lld", &t);
  while (t--) {
    scanf("%lld %lld", &R, &C);
    count = 0;
    a = (long long int **)calloc(R, sizeof(long long int *));
    for (i = 0; i < R; i++) {
      a[i] = (long long int *)calloc(C, sizeof(long long int));
    }
    for (i = 0; i < R; i++) {
      for (j = 0; j < C; j++) {
        scanf("%1ld", &a[i][j]);
      }
    }
    scanf("%lld %lld", &r, &c);
    b = (long long int **)calloc(r, sizeof(long long int *));
    for (i = 0; i < r; i++) {
      b[i] = (long long int *)calloc(c, sizeof(long long int));
    }
    for (i = 0; i < r; i++) {
      for (j = 0; j < c; j++) {
        scanf("%1lld", &b[i][j]);
      }
    }
    for (i = 0; i <= R - r; i++) {
      for (j = 0; j <= C - c; j++) {
        if (a[i][j] == b[0][0]) {
          for (x = 0; x < r; x++) {
            for (y = 0; y < c; y++) {
              if (a[i + x][j + y] == b[x][y]) {
                count++;
                if (count == r * c) {
                  printf("YES\n");
                  ab[t] = 1;
                  x = r;
                  y = c;
                  i = R;
                  j = C;
                }
              } else {
                y = c;
                x = r;
                count = 0;
              }
            }
          }
        }
      }
    }
    if (count != r * c) {
      printf("NO\n");
      ab[t] = 0;
      count = 0;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0x0,-0x68(%rbp)
lea    0xeb4(%rip),%rdi
lea    -0x50(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x50(%rbp)
cmp    $0x0,%rax
je     151a <main+0x3ea>
lea    0xe84(%rip),%rdi
lea    -0x30(%rbp),%rsi
lea    -0x38(%rbp),%rdx
mov    $0x0,%al
call   1050 <scanf@plt>
movq   $0x0,-0x68(%rbp)
mov    -0x30(%rbp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x70(%rbp)
movq   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    11e9 <main+0xb9>
mov    -0x38(%rbp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%rdx
mov    -0x70(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11ad <main+0x7d>
movq   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    1261 <main+0x131>
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x38(%rbp),%rax
jge    124b <main+0x11b>
mov    -0x70(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x18(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
lea    0xdd7(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1207 <main+0xd7>
jmp    1250 <main+0x120>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    11f1 <main+0xc1>
lea    0xd98(%rip),%rdi
lea    -0x40(%rbp),%rsi
lea    -0x48(%rbp),%rdx
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x40(%rbp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x78(%rbp)
movq   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    12cd <main+0x19d>
mov    -0x48(%rbp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%rdx
mov    -0x78(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1291 <main+0x161>
movq   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    1345 <main+0x215>
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    132f <main+0x1ff>
mov    -0x78(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x18(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
lea    0xcf8(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    12eb <main+0x1bb>
jmp    1334 <main+0x204>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    12d5 <main+0x1a5>
movq   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    -0x40(%rbp),%rcx
cmp    %rcx,%rax
jg     14dc <main+0x3ac>
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    -0x48(%rbp),%rcx
cmp    %rcx,%rax
jg     14c6 <main+0x396>
mov    -0x70(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x78(%rbp),%rcx
mov    (%rcx),%rcx
cmp    (%rcx),%rax
jne    14b0 <main+0x380>
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x40(%rbp),%rax
jge    14ab <main+0x37b>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    1495 <main+0x365>
mov    -0x70(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
add    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x78(%rbp),%rcx
mov    -0x58(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x60(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jne    1467 <main+0x337>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x48(%rbp),%rcx
cmp    %rcx,%rax
jne    1462 <main+0x332>
lea    0xbe7(%rip),%rdi
call   1030 <printf@plt>
mov    -0x50(%rbp),%rax
movl   $0x1,-0x90(%rbp,%rax,4)
mov    -0x40(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    147f <main+0x34f>
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x58(%rbp)
movq   $0x0,-0x68(%rbp)
jmp    1484 <main+0x354>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    13c1 <main+0x291>
jmp    149a <main+0x36a>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    13ab <main+0x27b>
jmp    14b0 <main+0x380>
jmp    14b5 <main+0x385>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    136a <main+0x23a>
jmp    14cb <main+0x39b>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    134d <main+0x21d>
mov    -0x68(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x48(%rbp),%rcx
cmp    %rcx,%rax
je     1515 <main+0x3e5>
lea    0xb21(%rip),%rdi
call   1030 <printf@plt>
mov    -0x50(%rbp),%rax
movl   $0x0,-0x90(%rbp,%rax,4)
movq   $0x0,-0x68(%rbp)
jmp    115c <main+0x2c>
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
lea    0xec0(%rip),%rdi
lea    0x20(%rsp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
subq   $0x1,0x20(%rsp)
jae    116a <main+0x3a>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xe8f(%rip),%rax
lea    0xe92(%rip),%r12
lea    0xe99(%rip),%r15
jmp    11a6 <main+0x76>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
subq   $0x1,0x20(%rsp)
lea    0xe63(%rip),%rax
lea    0xe66(%rip),%r12
jb     1159 <main+0x29>
mov    %rax,%rdi
lea    0x8(%rsp),%rsi
lea    0x18(%rsp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0x8(%rsp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%r13
cmpq   $0x0,0x8(%rsp)
jle    1270 <main+0x140>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,0x0(%r13,%rbx,8)
add    $0x1,%rbx
mov    0x8(%rsp),%rax
cmp    %rax,%rbx
jl     11e0 <main+0xb0>
test   %rax,%rax
jle    1270 <main+0x140>
mov    0x18(%rsp),%rcx
xor    %r14d,%r14d
jmp    1229 <main+0xf9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    %rax,%r14
jge    1270 <main+0x140>
test   %rcx,%rcx
jle    1220 <main+0xf0>
xor    %ebp,%ebp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%r13,%r14,8),%rsi
add    %rbp,%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   1050 <scanf@plt>
add    $0x1,%rbx
mov    0x18(%rsp),%rcx
add    $0x8,%rbp
cmp    %rcx,%rbx
jl     1240 <main+0x110>
mov    0x8(%rsp),%rax
jmp    1220 <main+0xf0>
nopl   0x0(%rax,%rax,1)
lea    0xd89(%rip),%rdi
lea    0x10(%rsp),%rsi
mov    %rsp,%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0x10(%rsp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%r14
mov    0x10(%rsp),%r10
test   %r10,%r10
jle    1330 <main+0x200>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
mov    0x10(%rsp),%r10
cmp    %r10,%rbx
jl     12b0 <main+0x180>
test   %r10,%r10
jle    1330 <main+0x200>
mov    (%rsp),%rax
xor    %r12d,%r12d
jmp    12e9 <main+0x1b9>
xchg   %ax,%ax
add    $0x1,%r12
cmp    %r10,%r12
jge    1330 <main+0x200>
test   %rax,%rax
jle    12e0 <main+0x1b0>
xor    %ebp,%ebp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r14,%r12,8),%rsi
add    %rbp,%rsi
lea    0xd01(%rip),%rdi
xor    %eax,%eax
call   1050 <scanf@plt>
add    $0x1,%rbx
mov    (%rsp),%rax
add    $0x8,%rbp
cmp    %rax,%rbx
jl     1300 <main+0x1d0>
mov    0x10(%rsp),%r10
jmp    12e0 <main+0x1b0>
nopl   (%rax)
mov    0x8(%rsp),%r8
cmp    %r10,%r8
jge    1360 <main+0x230>
mov    (%rsp),%rbp
xor    %r12d,%r12d
imul   %r10,%rbp
cmp    %rbp,%r12
je     1190 <main+0x60>
lea    0xcc0(%rip),%rdi
call   1030 <puts@plt>
jmp    1190 <main+0x60>
nop
mov    0x18(%rsp),%r9
mov    (%rsp),%rbp
xor    %r11d,%r11d
xor    %r12d,%r12d
jmp    1392 <main+0x262>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%r11),%rax
mov    %r8,%rcx
sub    %r10,%rcx
cmp    %rcx,%r11
mov    %rax,%r11
jge    1341 <main+0x211>
cmp    %rbp,%r9
jl     1380 <main+0x250>
xor    %esi,%esi
jmp    13b2 <main+0x282>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rsi),%rax
mov    %r9,%rcx
sub    %rbp,%rcx
cmp    %rcx,%rsi
mov    %rax,%rsi
jge    1380 <main+0x250>
mov    0x0(%r13,%r11,8),%rax
mov    (%rax,%rsi,8),%rax
mov    (%r14),%rcx
cmp    (%rcx),%rax
jne    13a0 <main+0x270>
test   %r10,%r10
jle    13a0 <main+0x270>
mov    %rbp,%rbx
xor    %eax,%eax
jmp    13d9 <main+0x2a9>
nop
add    $0x1,%rax
cmp    %r10,%rax
jge    13a0 <main+0x270>
test   %rbx,%rbx
jle    13d0 <main+0x2a0>
xor    %ecx,%ecx
jmp    1405 <main+0x2d5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r10,%rax
xor    %r12d,%r12d
mov    %rbx,%rcx
add    $0x1,%rcx
mov    %rbp,%rbx
cmp    %rbp,%rcx
jge    13d0 <main+0x2a0>
lea    (%r11,%rax,1),%rdx
mov    0x0(%r13,%rdx,8),%rdx
lea    (%rsi,%rcx,1),%rdi
mov    (%rdx,%rdi,8),%rdx
mov    (%r14,%rax,8),%rdi
cmp    (%rdi,%rcx,8),%rdx
jne    13f0 <main+0x2c0>
add    $0x1,%r12
imul   %r10,%rbx
cmp    %rbx,%r12
jne    1460 <main+0x330>
mov    %r15,%rdi
call   1030 <puts@plt>
mov    0x10(%rsp),%r10
mov    (%rsp),%rbp
mov    0x8(%rsp),%r8
mov    0x18(%rsp),%r9
mov    %r10,%rax
mov    %rbp,%rbx
mov    %r9,%rsi
mov    %r8,%r11
jmp    13f6 <main+0x2c6>
cs nopw 0x0(%rax,%rax,1)
mov    %rcx,%rbx
jmp    13f6 <main+0x2c6>

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

LLVM IR (-O2):
@.str = [5 x i8] c"%lld\00"
@.str.1 = [10 x i8] c"%lld %lld\00"
@.str.2 = [5 x i8] c"%1ld\00"
@.str.3 = [6 x i8] c"%1lld\00"
@str = [3 x i8] c"NO\00"
@str.6 = [4 x i8] c"YES\00"
define i32 @main() {
%1 = alloca i64
%2 = alloca i64
%3 = alloca i64
%4 = alloca i64
%5 = alloca i64
%6 = bitcast i64* %1 to i8*
%7 = bitcast i64* %2 to i8*
%8 = bitcast i64* %3 to i8*
%9 = bitcast i64* %4 to i8*
%10 = bitcast i64* %5 to i8*
%11 = call i32 (i8*, i64*, ...) @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i64* %5)
%12 = load i64, i64* %5
%13 = add nsw i64 %12, -1
store i64 %13, i64* %5
%14 = icmp eq i64 %12, 0
br i1 %14, label %255, label %15
15: ; preds = %0, %251
%16 = call i32 (i8*, i64*, ...) @scanf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i64* %1, i64* %2)
%17 = load i64, i64* %1
%18 = call i64 @calloc(i64 %17, i32 8)
%19 = inttoptr i64 %18 to i64**
%20 = load i64, i64* %1
%21 = icmp sgt i64 %20, 0
br i1 %21, label %26, label %57
22: ; preds = %26
%23 = icmp sgt i64 %33, 0
br i1 %23, label %24, label %57
24: ; preds = %22
%25 = load i64, i64* %2
br label %35
26: ; preds = %15, %26
%27 = phi i64 [ %32, %26 ], [ 0, %15 ]
%28 = load i64, i64* %2
%29 = call i64 @calloc(i64 %28, i32 8)
%30 = inttoptr i64 %29 to i64*
%31 = getelementptr inbounds i64*, i64** %19, i64 %27
store i64* %30, i64** %31
%32 = add nuw nsw i64 %27, 1
%33 = load i64, i64* %1
%34 = icmp slt i64 %32, %33
br i1 %34, label %26, label %22
35: ; preds = %24, %52
%36 = phi i64 [ %53, %52 ], [ %33, %24 ]
%37 = phi i64 [ %54, %52 ], [ %25, %24 ]
%38 = phi i64 [ %55, %52 ], [ 0, %24 ]
%39 = icmp sgt i64 %37, 0
br i1 %39, label %40, label %52
40: ; preds = %35
%41 = getelementptr inbounds i64*, i64** %19, i64 %38
br label %42
42: ; preds = %40, %42
%43 = phi i64 [ 0, %40 ], [ %47, %42 ]
%44 = load i64*, i64** %41
%45 = getelementptr inbounds i64, i64* %44, i64 %43
%46 = call i32 (i8*, i64*, ...) @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i64* %45)
%47 = add nuw nsw i64 %43, 1
%48 = load i64, i64* %2
%49 = icmp slt i64 %47, %48
br i1 %49, label %42, label %50
50: ; preds = %42
%51 = load i64, i64* %1
br label %52
52: ; preds = %50, %35
%53 = phi i64 [ %51, %50 ], [ %36, %35 ]
%54 = phi i64 [ %48, %50 ], [ %37, %35 ]
%55 = add nuw nsw i64 %38, 1
%56 = icmp slt i64 %55, %53
br i1 %56, label %35, label %57
57: ; preds = %52, %15, %22
%58 = call i32 (i8*, i64*, ...) @scanf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i64* %3, i64* %4)
%59 = load i64, i64* %3
%60 = call i64 @calloc(i64 %59, i32 8)
%61 = inttoptr i64 %60 to i64**
%62 = load i64, i64* %3
%63 = icmp sgt i64 %62, 0
br i1 %63, label %68, label %77
64: ; preds = %68
%65 = icmp sgt i64 %75, 0
br i1 %65, label %66, label %77
66: ; preds = %64
%67 = load i64, i64* %4
br label %86
68: ; preds = %57, %68
%69 = phi i64 [ %74, %68 ], [ 0, %57 ]
%70 = load i64, i64* %4
%71 = call i64 @calloc(i64 %70, i32 8)
%72 = inttoptr i64 %71 to i64*
%73 = getelementptr inbounds i64*, i64** %61, i64 %69
store i64* %72, i64** %73
%74 = add nuw nsw i64 %69, 1
%75 = load i64, i64* %3
%76 = icmp slt i64 %74, %75
br i1 %76, label %68, label %64
77: ; preds = %103, %57, %64
%78 = phi i64 [ %75, %64 ], [ %62, %57 ], [ %104, %103 ]
%79 = load i64, i64* %1
%80 = icmp slt i64 %79, %78
br i1 %80, label %81, label %83
81: ; preds = %77
%82 = load i64, i64* %4
br label %243
83: ; preds = %77
%84 = load i64, i64* %2
%85 = load i64, i64* %4
br label %108
86: ; preds = %66, %103
%87 = phi i64 [ %104, %103 ], [ %75, %66 ]
%88 = phi i64 [ %105, %103 ], [ %67, %66 ]
%89 = phi i64 [ %106, %103 ], [ 0, %66 ]
%90 = icmp sgt i64 %88, 0
br i1 %90, label %91, label %103
91: ; preds = %86
%92 = getelementptr inbounds i64*, i64** %61, i64 %89
br label %93
93: ; preds = %91, %93
%94 = phi i64 [ 0, %91 ], [ %98, %93 ]
%95 = load i64*, i64** %92
%96 = getelementptr inbounds i64, i64* %95, i64 %94
%97 = call i32 (i8*, i64*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i64* %96)
%98 = add nuw nsw i64 %94, 1
%99 = load i64, i64* %4
%100 = icmp slt i64 %98, %99
br i1 %100, label %93, label %101
101: ; preds = %93
%102 = load i64, i64* %3
br label %103
103: ; preds = %101, %86
%104 = phi i64 [ %102, %101 ], [ %87, %86 ]
%105 = phi i64 [ %99, %101 ], [ %88, %86 ]
%106 = add nuw nsw i64 %89, 1
%107 = icmp slt i64 %106, %104
br i1 %107, label %86, label %77
108: ; preds = %83, %231
%109 = phi i64 [ %232, %231 ], [ %78, %83 ]
%110 = phi i64 [ %233, %231 ], [ %79, %83 ]
%111 = phi i64 [ %234, %231 ], [ %85, %83 ]
%112 = phi i64 [ %235, %231 ], [ %84, %83 ]
%113 = phi i64 [ %236, %231 ], [ %85, %83 ]
%114 = phi i64 [ %237, %231 ], [ %84, %83 ]
%115 = phi i64 [ %240, %231 ], [ 0, %83 ]
%116 = phi i64 [ %238, %231 ], [ 0, %83 ]
%117 = icmp slt i64 %114, %113
br i1 %117, label %231, label %118
118: ; preds = %108, %218
%119 = phi i64 [ %219, %218 ], [ %109, %108 ]
%120 = phi i64 [ %220, %218 ], [ %110, %108 ]
%121 = phi i64 [ %221, %218 ], [ %111, %108 ]
%122 = phi i64 [ %222, %218 ], [ %112, %108 ]
%123 = phi i64 [ %223, %218 ], [ %109, %108 ]
%124 = phi i64 [ %221, %218 ], [ %113, %108 ]
%125 = phi i64 [ %224, %218 ], [ %109, %108 ]
%126 = phi i64 [ %227, %218 ], [ %115, %108 ]
%127 = phi i64 [ %228, %218 ], [ 0, %108 ]
%128 = phi i64 [ %225, %218 ], [ %116, %108 ]
%129 = getelementptr inbounds i64*, i64** %19, i64 %126
%130 = load i64*, i64** %129
%131 = getelementptr inbounds i64, i64* %130, i64 %127
%132 = load i64, i64* %131
%133 = load i64*, i64** %61
%134 = load i64, i64* %133
%135 = icmp eq i64 %132, %134
%136 = icmp sgt i64 %125, 0
%137 = select i1 %135, i1 %136, i1 false
br i1 %137, label %138, label %218
138: ; preds = %118, %204
%139 = phi i64 [ %205, %204 ], [ %119, %118 ]
%140 = phi i64 [ %206, %204 ], [ %120, %118 ]
%141 = phi i64 [ %207, %204 ], [ %121, %118 ]
%142 = phi i64 [ %208, %204 ], [ %122, %118 ]
%143 = phi i64 [ %209, %204 ], [ %123, %118 ]
%144 = phi i64 [ %210, %204 ], [ %124, %118 ]
%145 = phi i64 [ %209, %204 ], [ %125, %118 ]
%146 = phi i64 [ %211, %204 ], [ %124, %118 ]
%147 = phi i64 [ %215, %204 ], [ %126, %118 ]
%148 = phi i64 [ %214, %204 ], [ %127, %118 ]
%149 = phi i64 [ %213, %204 ], [ %128, %118 ]
%150 = phi i64 [ %216, %204 ], [ 0, %118 ]
%151 = icmp sgt i64 %146, 0
br i1 %151, label %152, label %204
152: ; preds = %138, %188
%153 = phi i64 [ %189, %188 ], [ %139, %138 ]
%154 = phi i64 [ %190, %188 ], [ %140, %138 ]
%155 = phi i64 [ %191, %188 ], [ %141, %138 ]
%156 = phi i64 [ %192, %188 ], [ %142, %138 ]
%157 = phi i64 [ %193, %188 ], [ %143, %138 ]
%158 = phi i64 [ %194, %188 ], [ %144, %138 ]
%159 = phi i64 [ %195, %188 ], [ %145, %138 ]
%160 = phi i64 [ %196, %188 ], [ %145, %138 ]
%161 = phi i64 [ %194, %188 ], [ %146, %138 ]
%162 = phi i64 [ %201, %188 ], [ %147, %138 ]
%163 = phi i64 [ %200, %188 ], [ %148, %138 ]
%164 = phi i64 [ %199, %188 ], [ %149, %138 ]
%165 = phi i64 [ %202, %188 ], [ 0, %138 ]
%166 = phi i64 [ %197, %188 ], [ %150, %138 ]
%167 = add nsw i64 %162, %166
%168 = getelementptr inbounds i64*, i64** %19, i64 %167
%169 = load i64*, i64** %168
%170 = add nsw i64 %163, %165
%171 = getelementptr inbounds i64, i64* %169, i64 %170
%172 = load i64, i64* %171
%173 = getelementptr inbounds i64*, i64** %61, i64 %166
%174 = load i64*, i64** %173
%175 = getelementptr inbounds i64, i64* %174, i64 %165
%176 = load i64, i64* %175
%177 = icmp eq i64 %172, %176
br i1 %177, label %178, label %188
178: ; preds = %152
%179 = add nsw i64 %164, 1
%180 = mul nsw i64 %159, %161
%181 = icmp eq i64 %179, %180
br i1 %181, label %182, label %188
182: ; preds = %178
%183 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.6, i64 0, i64 0))
%184 = load i64, i64* %3
%185 = load i64, i64* %4
%186 = load i64, i64* %1
%187 = load i64, i64* %2
br label %188
188: ; preds = %152, %182, %178
%189 = phi i64 [ %184, %182 ], [ %153, %178 ], [ %153, %152 ]
%190 = phi i64 [ %186, %182 ], [ %154, %178 ], [ %154, %152 ]
%191 = phi i64 [ %185, %182 ], [ %155, %178 ], [ %155, %152 ]
%192 = phi i64 [ %187, %182 ], [ %156, %178 ], [ %156, %152 ]
%193 = phi i64 [ %184, %182 ], [ %157, %178 ], [ %157, %152 ]
%194 = phi i64 [ %185, %182 ], [ %158, %178 ], [ %158, %152 ]
%195 = phi i64 [ %184, %182 ], [ %159, %178 ], [ %159, %152 ]
%196 = phi i64 [ %184, %182 ], [ %159, %178 ], [ %160, %152 ]
%197 = phi i64 [ %184, %182 ], [ %166, %178 ], [ %160, %152 ]
%198 = phi i64 [ %185, %182 ], [ %165, %178 ], [ %161, %152 ]
%199 = phi i64 [ %179, %182 ], [ %179, %178 ], [ 0, %152 ]
%200 = phi i64 [ %187, %182 ], [ %163, %178 ], [ %163, %152 ]
%201 = phi i64 [ %186, %182 ], [ %162, %178 ], [ %162, %152 ]
%202 = add nsw i64 %198, 1
%203 = icmp slt i64 %202, %194
br i1 %203, label %152, label %204
204: ; preds = %188, %138
%205 = phi i64 [ %139, %138 ], [ %189, %188 ]
%206 = phi i64 [ %140, %138 ], [ %190, %188 ]
%207 = phi i64 [ %141, %138 ], [ %191, %188 ]
%208 = phi i64 [ %142, %138 ], [ %192, %188 ]
%209 = phi i64 [ %143, %138 ], [ %193, %188 ]
%210 = phi i64 [ %144, %138 ], [ %194, %188 ]
%211 = phi i64 [ %146, %138 ], [ %194, %188 ]
%212 = phi i64 [ %150, %138 ], [ %197, %188 ]
%213 = phi i64 [ %149, %138 ], [ %199, %188 ]
%214 = phi i64 [ %148, %138 ], [ %200, %188 ]
%215 = phi i64 [ %147, %138 ], [ %201, %188 ]
%216 = add nsw i64 %212, 1
%217 = icmp slt i64 %216, %209
br i1 %217, label %138, label %218
218: ; preds = %204, %118
%219 = phi i64 [ %119, %118 ], [ %205, %204 ]
%220 = phi i64 [ %120, %118 ], [ %206, %204 ]
%221 = phi i64 [ %121, %118 ], [ %207, %204 ]
%222 = phi i64 [ %122, %118 ], [ %208, %204 ]
%223 = phi i64 [ %123, %118 ], [ %209, %204 ]
%224 = phi i64 [ %125, %118 ], [ %209, %204 ]
%225 = phi i64 [ %128, %118 ], [ %213, %204 ]
%226 = phi i64 [ %127, %118 ], [ %214, %204 ]
%227 = phi i64 [ %126, %118 ], [ %215, %204 ]
%228 = add nsw i64 %226, 1
%229 = sub nsw i64 %222, %221
%230 = icmp slt i64 %226, %229
br i1 %230, label %118, label %231
231: ; preds = %218, %108
%232 = phi i64 [ %109, %108 ], [ %219, %218 ]
%233 = phi i64 [ %110, %108 ], [ %220, %218 ]
%234 = phi i64 [ %111, %108 ], [ %221, %218 ]
%235 = phi i64 [ %112, %108 ], [ %222, %218 ]
%236 = phi i64 [ %113, %108 ], [ %221, %218 ]
%237 = phi i64 [ %114, %108 ], [ %222, %218 ]
%238 = phi i64 [ %116, %108 ], [ %225, %218 ]
%239 = phi i64 [ %115, %108 ], [ %227, %218 ]
%240 = add nsw i64 %239, 1
%241 = sub nsw i64 %233, %232
%242 = icmp slt i64 %239, %241
br i1 %242, label %108, label %243
243: ; preds = %231, %81
%244 = phi i64 [ %82, %81 ], [ %234, %231 ]
%245 = phi i64 [ 0, %81 ], [ %238, %231 ]
%246 = phi i64 [ %78, %81 ], [ %232, %231 ]
%247 = mul nsw i64 %244, %246
%248 = icmp eq i64 %245, %247
br i1 %248, label %251, label %249
249: ; preds = %243
%250 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str, i64 0, i64 0))
br label %251
251: ; preds = %249, %243
%252 = load i64, i64* %5
%253 = add nsw i64 %252, -1
store i64 %253, i64* %5
%254 = icmp eq i64 %252, 0
br i1 %254, label %255, label %15
255: ; preds = %251, %0
ret i32 0
}