#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*/ memset(char *, int, int);
int /*<<< orphan*/ printf(char *, int);
int /*<<< orphan*/ scanf(char *, int *, ...);
int main() {
  int num_cases;
  int N, M;
  char first_choice[64];
  int choice, num_ways;
  int i, j;
  scanf("%d\n", &num_cases);
  while (num_cases-- > 0) {
    scanf("%d %d\n", &N, &M);
    memset(first_choice, 0x0, sizeof(char) * 64);
    for (i = 1; i <= M; i++) {
      for (j = 1; j <= N; j++) {
        scanf("%d", &choice);
        if (choice == 1) {
          first_choice[j]++;
        }
      }
    }
    num_ways = 1;
    for (j = 1; j <= N; j++) {
      if (first_choice[j] > 1) {
        num_ways *= first_choice[j];
      }
    }
    printf("%d\n", num_ways);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xebd(%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
jle    1265 <main+0x135>
lea    0xe94(%rip),%rdi
lea    -0xc(%rbp),%rsi
lea    -0x10(%rbp),%rdx
mov    $0x0,%al
call   1050 <scanf@plt>
lea    -0x50(%rbp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1040 <memset@plt>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1202 <main+0xd2>
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11ef <main+0xbf>
lea    0xe4f(%rip),%rdi
lea    -0x54(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
cmpl   $0x1,-0x54(%rbp)
jne    11dc <main+0xac>
movslq -0x60(%rbp),%rax
mov    -0x50(%rbp,%rax,1),%cl
add    $0x1,%cl
mov    %cl,-0x50(%rbp,%rax,1)
jmp    11e1 <main+0xb1>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    11a5 <main+0x75>
jmp    11f4 <main+0xc4>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1192 <main+0x62>
movl   $0x1,-0x58(%rbp)
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1251 <main+0x121>
movslq -0x60(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%eax
cmp    $0x1,%eax
jle    123e <main+0x10e>
movslq -0x60(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%eax
imul   -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    1243 <main+0x113>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1210 <main+0xe0>
mov    -0x58(%rbp),%esi
lea    0xda8(%rip),%rdi
call   1030 <printf@plt>
jmp    1151 <main+0x21>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
lea    0xede(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
mov    (%rsp),%eax
lea    -0x1(%rax),%ecx
mov    %ecx,(%rsp)
test   %eax,%eax
jle    14a8 <main+0x378>
lea    0xebc(%rip),%rbx
mov    $0x1,%r15d
lea    0xeb3(%rip),%rbp
lea    0xc(%rsp),%r14
jmp    119e <main+0x6e>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    (%rsp),%eax
lea    -0x1(%rax),%ecx
mov    %ecx,(%rsp)
test   %eax,%eax
jle    14a8 <main+0x378>
lea    0xe7b(%rip),%rdi
lea    0x8(%rsp),%rsi
lea    0x4(%rsp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
lea    0x10(%rsp),%rdi
xor    %esi,%esi
mov    $0x40,%edx
call   1040 <memset@plt>
mov    0x4(%rsp),%eax
mov    0x8(%rsp),%ecx
test   %eax,%eax
jle    1230 <main+0x100>
mov    $0x1,%r12d
jmp    11f1 <main+0xc1>
nopl   0x0(%rax,%rax,1)
mov    0x4(%rsp),%eax
lea    0x1(%r12),%edx
cmp    %eax,%r12d
mov    %edx,%r12d
jge    1230 <main+0x100>
test   %ecx,%ecx
jle    11e4 <main+0xb4>
xor    %r13d,%r13d
jmp    120e <main+0xde>
nopw   0x0(%rax,%rax,1)
movslq 0x8(%rsp),%rcx
add    $0x1,%r13
cmp    %rcx,%r13
jge    11e0 <main+0xb0>
mov    %rbp,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
cmpl   $0x1,0xc(%rsp)
jne    1200 <main+0xd0>
addb   $0x1,0x11(%rsp,%r13,1)
jmp    1200 <main+0xd0>
nopw   0x0(%rax,%rax,1)
test   %ecx,%ecx
jle    1180 <main+0x50>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    1250 <main+0x120>
mov    $0x1,%esi
mov    $0x1,%ecx
jmp    1462 <main+0x332>
xchg   %ax,%ax
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
movdqa 0xda0(%rip),%xmm8
pxor   %xmm9,%xmm9
je     148f <main+0x35f>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
movdqa 0xd74(%rip),%xmm1
movdqa %xmm1,%xmm0
movd   0x11(%rsp,%rsi,1),%xmm2
movd   0x15(%rsp,%rsi,1),%xmm4
movdqa %xmm2,%xmm3
pcmpgtb %xmm8,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm8,%xmm3
por    %xmm2,%xmm3
movdqa %xmm4,%xmm2
pcmpgtb %xmm8,%xmm2
pand   %xmm2,%xmm4
pandn  %xmm8,%xmm2
por    %xmm4,%xmm2
punpcklbw %xmm9,%xmm3
punpcklwd %xmm9,%xmm3
punpcklbw %xmm9,%xmm2
punpcklwd %xmm9,%xmm2
pshufd $0xf5,%xmm3,%xmm4
pshufd $0xf5,%xmm0,%xmm5
pmuludq %xmm4,%xmm5
pmuludq %xmm0,%xmm3
pshufd $0xf5,%xmm2,%xmm0
pshufd $0xf5,%xmm1,%xmm4
pmuludq %xmm0,%xmm4
pmuludq %xmm1,%xmm2
movd   0x19(%rsp,%rsi,1),%xmm0
movd   0x1d(%rsp,%rsi,1),%xmm1
movdqa %xmm0,%xmm6
pcmpgtb %xmm8,%xmm6
pand   %xmm6,%xmm0
pandn  %xmm8,%xmm6
por    %xmm0,%xmm6
movdqa %xmm1,%xmm7
pcmpgtb %xmm8,%xmm7
pand   %xmm7,%xmm1
pandn  %xmm8,%xmm7
por    %xmm1,%xmm7
punpcklbw %xmm9,%xmm6
punpcklwd %xmm9,%xmm6
punpcklbw %xmm9,%xmm7
punpcklwd %xmm9,%xmm7
pmuludq %xmm6,%xmm3
pshufd $0xe8,%xmm3,%xmm0
pshufd $0xf5,%xmm6,%xmm1
pmuludq %xmm5,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pmuludq %xmm7,%xmm2
pshufd $0xe8,%xmm2,%xmm1
pshufd $0xf5,%xmm7,%xmm2
pmuludq %xmm4,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1290 <main+0x160>
test   $0x1,%dl
je     1429 <main+0x2f9>
or     $0x1,%rsi
movd   0x10(%rsp,%rsi,1),%xmm2
movd   0x14(%rsp,%rsi,1),%xmm3
movdqa %xmm2,%xmm4
pcmpgtb %xmm8,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm8,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtb %xmm8,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm8,%xmm2
por    %xmm3,%xmm2
punpcklbw %xmm9,%xmm4
punpcklwd %xmm9,%xmm4
punpcklbw %xmm9,%xmm2
punpcklwd %xmm9,%xmm2
pshufd $0xf5,%xmm0,%xmm3
pmuludq %xmm4,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm3
punpckldq %xmm3,%xmm0
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm2,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm3,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
pshufd $0xf5,%xmm0,%xmm2
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm2,%xmm3
pmuludq %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
pmuludq %xmm1,%xmm0
pshufd $0xaa,%xmm3,%xmm1
pmuludq %xmm3,%xmm1
pmuludq %xmm0,%xmm1
movd   %xmm1,%esi
cmp    %rcx,%rax
je     1185 <main+0x55>
or     $0x1,%rcx
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
movzbl 0x10(%rsp,%rcx,1),%edx
test   %dl,%dl
cmovle %r15d,%edx
movzbl %dl,%edx
imul   %edx,%esi
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1470 <main+0x340>
jmp    1185 <main+0x55>
xor    %esi,%esi
movdqa 0xb67(%rip),%xmm1
movdqa %xmm1,%xmm0
test   $0x1,%dl
jne    1399 <main+0x269>
jmp    1429 <main+0x2f9>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [4 x i8] c"%d\0A\00"
@.str.1 = [7 x i8] c"%d %d\0A\00"
@.str.2 = [3 x i8] c"%d\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca [64 x i8]
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i32 0, i32* %1
%10 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32* %2)
br label %11
11: ; preds = %70, %0
%12 = load i32, i32* %2
%13 = add nsw i32 %12, -1
store i32 %13, i32* %2
%14 = icmp sgt i32 %12, 0
br i1 %14, label %15, label %73
15: ; preds = %11
%16 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32* %3, i32* %4)
%17 = getelementptr inbounds [64 x i8], [64 x i8]* %5, i64 0, i64 0
%18 = call i32 @memset(i8* %17, i32 0, i32 64)
store i32 1, i32* %8
br label %19
19: ; preds = %43, %15
%20 = load i32, i32* %8
%21 = load i32, i32* %4
%22 = icmp sle i32 %20, %21
br i1 %22, label %23, label %46
23: ; preds = %19
store i32 1, i32* %9
br label %24
24: ; preds = %39, %23
%25 = load i32, i32* %9
%26 = load i32, i32* %3
%27 = icmp sle i32 %25, %26
br i1 %27, label %28, label %42
28: ; preds = %24
%29 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32* %6)
%30 = load i32, i32* %6
%31 = icmp eq i32 %30, 1
br i1 %31, label %32, label %38
32: ; preds = %28
%33 = load i32, i32* %9
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [64 x i8], [64 x i8]* %5, i64 0, i64 %34
%36 = load i8, i8* %35
%37 = add i8 %36, 1
store i8 %37, i8* %35
br label %38
38: ; preds = %32, %28
br label %39
39: ; preds = %38
%40 = load i32, i32* %9
%41 = add nsw i32 %40, 1
store i32 %41, i32* %9
br label %24
42: ; preds = %24
br label %43
43: ; preds = %42
%44 = load i32, i32* %8
%45 = add nsw i32 %44, 1
store i32 %45, i32* %8
br label %19
46: ; preds = %19
store i32 1, i32* %7
store i32 1, i32* %9
br label %47
47: ; preds = %67, %46
%48 = load i32, i32* %9
%49 = load i32, i32* %3
%50 = icmp sle i32 %48, %49
br i1 %50, label %51, label %70
51: ; preds = %47
%52 = load i32, i32* %9
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [64 x i8], [64 x i8]* %5, i64 0, i64 %53
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
%57 = icmp sgt i32 %56, 1
br i1 %57, label %58, label %66
58: ; preds = %51
%59 = load i32, i32* %9
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [64 x i8], [64 x i8]* %5, i64 0, i64 %60
%62 = load i8, i8* %61
%63 = sext i8 %62 to i32
%64 = load i32, i32* %7
%65 = mul nsw i32 %64, %63
store i32 %65, i32* %7
br label %66
66: ; preds = %58, %51
br label %67
67: ; preds = %66
%68 = load i32, i32* %9
%69 = add nsw i32 %68, 1
store i32 %69, i32* %9
br label %47
70: ; preds = %47
%71 = load i32, i32* %7
%72 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %71)
br label %11
73: ; preds = %11
ret i32 0
}

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