#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__ EOF;
int /*<<< orphan*/ printf(char *, int, int);
int /*<<< orphan*/ putchar(char);
char read();
scalar_t__ scanf(char *, int *, int *, int *);
int main() {
  int row = 0, col = 0, num = 0;
  char arr[100] = {0};
  char tmp[100] = {0};
  char ops[10] = {0};
  while (scanf("%d %d %d", &row, &col, &num) != EOF) {
    for (int i = 0; i < (row * col); ++i) {
      arr[i] = read();
    }
    for (int i = 0; i < num; ++i) {
      ops[i] = read();
    }
    while (num--) {
      if (ops[num] == '1') {
        for (int r = 0; r < (row >> 1); ++r) {
          for (int c = 0; c < col; ++c) {
            int idx1 = r * col + c;
            int idx2 = (row - r - 1) * col + c;
            char t = arr[idx1];
            arr[idx1] = arr[idx2];
            arr[idx2] = t;
          }
        }
      } else {
        for (int c = col - 1, i = 0; c >= 0; --c) {
          for (int r = 0; r < row; ++r) {
            tmp[i++] = arr[r * col + c];
          }
        }
        int t = row;
        row = col;
        col = t;
        for (int i = 0; i < row * col; ++i) {
          arr[i] = tmp[i];
        }
      }
    }
    printf("%d %d\n", row, col);
    for (int r = 0; r < row; ++r) {
      putchar(arr[r * col]);
      for (int c = 1; c < col; ++c) {
        putchar(' ');
        putchar(arr[r * col + c]);
      }
      putchar('\n');
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
lea    -0x80(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1050 <memset@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1050 <memset@plt>
lea    -0xfa(%rbp),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1050 <memset@plt>
lea    0xe4c(%rip),%rdi
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
lea    -0x10(%rbp),%rcx
call   1070 <scanf@plt>
mov    0x2e1c(%rip),%rcx
cmp    (%rcx),%rax
je     151f <main+0x3cf>
movl   $0x0,-0x100(%rbp)
mov    -0x100(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    121c <main+0xcc>
mov    $0x0,%al
call   1060 <read@plt>
mov    %al,%cl
movslq -0x100(%rbp),%rax
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    11df <main+0x8f>
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1260 <main+0x110>
mov    $0x0,%al
call   1060 <read@plt>
mov    %al,%cl
movslq -0x104(%rbp),%rax
mov    %cl,-0xfa(%rbp,%rax,1)
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    1226 <main+0xd6>
jmp    1265 <main+0x115>
mov    -0x10(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x10(%rbp)
cmp    $0x0,%eax
je     1468 <main+0x318>
movslq -0x10(%rbp),%rax
movsbl -0xfa(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    1361 <main+0x211>
movl   $0x0,-0x108(%rbp)
mov    -0x108(%rbp),%eax
mov    -0x8(%rbp),%ecx
sar    $0x1,%ecx
cmp    %ecx,%eax
jge    135c <main+0x20c>
movl   $0x0,-0x10c(%rbp)
mov    -0x10c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1343 <main+0x1f3>
mov    -0x108(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0x10c(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0x8(%rbp),%eax
sub    -0x108(%rbp),%eax
sub    $0x1,%eax
imul   -0xc(%rbp),%eax
add    -0x10c(%rbp),%eax
mov    %eax,-0x114(%rbp)
movslq -0x110(%rbp),%rax
mov    -0x80(%rbp,%rax,1),%al
mov    %al,-0x115(%rbp)
movslq -0x114(%rbp),%rax
mov    -0x80(%rbp,%rax,1),%cl
movslq -0x110(%rbp),%rax
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0x115(%rbp),%cl
movslq -0x114(%rbp),%rax
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0x10c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10c(%rbp)
jmp    12b6 <main+0x166>
jmp    1348 <main+0x1f8>
mov    -0x108(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x108(%rbp)
jmp    1298 <main+0x148>
jmp    1463 <main+0x313>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x11c(%rbp)
movl   $0x0,-0x120(%rbp)
cmpl   $0x0,-0x11c(%rbp)
jl     13fa <main+0x2aa>
movl   $0x0,-0x124(%rbp)
mov    -0x124(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13e1 <main+0x291>
mov    -0x124(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0x11c(%rbp),%eax
cltq
mov    -0x80(%rbp,%rax,1),%cl
mov    -0x120(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x120(%rbp)
cltq
mov    %cl,-0xf0(%rbp,%rax,1)
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
jmp    138e <main+0x23e>
jmp    13e6 <main+0x296>
mov    -0x11c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x11c(%rbp)
jmp    1377 <main+0x227>
mov    -0x8(%rbp),%eax
mov    %eax,-0x128(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x128(%rbp),%eax
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    145e <main+0x30e>
movslq -0x12c(%rbp),%rax
mov    -0xf0(%rbp,%rax,1),%cl
movslq -0x12c(%rbp),%rax
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
jmp    141c <main+0x2cc>
jmp    1463 <main+0x313>
jmp    1265 <main+0x115>
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
lea    0xb94(%rip),%rdi
call   1040 <printf@plt>
movl   $0x0,-0x130(%rbp)
mov    -0x130(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    151a <main+0x3ca>
mov    -0x130(%rbp),%eax
imul   -0xc(%rbp),%eax
cltq
movsbl -0x80(%rbp,%rax,1),%edi
call   1030 <putchar@plt>
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14fc <main+0x3ac>
mov    $0x20,%edi
call   1030 <putchar@plt>
mov    -0x130(%rbp),%eax
imul   -0xc(%rbp),%eax
add    -0x134(%rbp),%eax
cltq
movsbl -0x80(%rbp,%rax,1),%edi
call   1030 <putchar@plt>
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    14b3 <main+0x363>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    -0x130(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x130(%rbp)
jmp    1484 <main+0x334>
jmp    11ad <main+0x5d>
xor    %eax,%eax
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
movl   $0x0,0x8(%rsp)
movl   $0x0,0x4(%rsp)
movl   $0x0,0xc(%rsp)
xorps  %xmm0,%xmm0
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movl   $0x0,0xa0(%rsp)
movaps %xmm0,0x130(%rsp)
movaps %xmm0,0x120(%rsp)
movaps %xmm0,0x110(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0xe0(%rsp)
movl   $0x0,0x140(%rsp)
movw   $0x0,0x28(%rsp)
movq   $0x0,0x20(%rsp)
lea    0xe03(%rip),%rdi
lea    0x8(%rsp),%rsi
lea    0x4(%rsp),%rdx
lea    0xc(%rsp),%rcx
call   1070 <scanf@plt>
mov    0x2dd0(%rip),%rcx
cmp    (%rcx),%rax
jne    1231 <main+0xe1>
xor    %eax,%eax
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xe1(%rsp),%r12
lea    0x3f(%rsp),%r13
jmp    1267 <main+0x117>
lea    0xdb9(%rip),%rdi
lea    0x8(%rsp),%rsi
lea    0x4(%rsp),%rdx
lea    0xc(%rsp),%rcx
call   1070 <scanf@plt>
mov    0x2d86(%rip),%rcx
cmp    (%rcx),%rax
je     121d <main+0xcd>
mov    0x8(%rsp),%edx
mov    0x4(%rsp),%r15d
mov    %r15d,%eax
imul   %edx,%eax
test   %eax,%eax
jle    12a5 <main+0x155>
xor    %ebx,%ebx
nopl   0x0(%rax)
xor    %eax,%eax
call   1050 <read@plt>
mov    %al,0x40(%rsp,%rbx,1)
add    $0x1,%rbx
mov    0x8(%rsp),%edx
mov    0x4(%rsp),%r15d
mov    %r15d,%eax
imul   %edx,%eax
cltq
cmp    %rax,%rbx
jl     1280 <main+0x130>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    12d2 <main+0x182>
xor    %ebx,%ebx
nop
xor    %eax,%eax
call   1050 <read@plt>
mov    %al,0x20(%rsp,%rbx,1)
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     12b0 <main+0x160>
mov    0x4(%rsp),%r15d
mov    0x8(%rsp),%edx
test   %eax,%eax
je     1720 <main+0x5d0>
add    $0xffffffff,%eax
cltq
jmp    131b <main+0x1cb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rax
mov    %eax,%esi
mov    %r15d,%edx
lea    0xe1(%rsp),%r12
lea    0x3f(%rsp),%r13
mov    0x10(%rsp),%rax
mov    %edx,%r15d
mov    %esi,%edx
sub    $0x1,%rax
jb     1722 <main+0x5d2>
cmpb   $0x31,0x20(%rsp,%rax,1)
mov    %rdx,0x18(%rsp)
jne    1620 <main+0x4d0>
cmp    $0x2,%edx
jl     1710 <main+0x5c0>
mov    %rax,0x10(%rsp)
mov    %edx,%eax
shr    %eax
mov    %rax,0xd8(%rsp)
movslq %r15d,%rax
mov    %rax,0x38(%rsp)
mov    %rdx,%rax
mov    %r15d,%edx
lea    (%rsp,%rdx,1),%rcx
add    $0x40,%rcx
mov    %rcx,0xc8(%rsp)
mov    %edx,%ecx
and    $0xffffffe0,%ecx
mov    %rcx,0x30(%rsp)
add    $0xffffffffffffffe0,%rcx
mov    %rcx,0xc0(%rsp)
mov    %rcx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %rsi,%rcx
mov    %rsi,0xb8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xb0(%rsp)
mov    %edx,%edi
and    $0xfffffff8,%edi
mov    %rdx,%rcx
neg    %rcx
mov    %rcx,0xd0(%rsp)
lea    -0x1(%rax),%r13d
imul   %r15d,%r13d
lea    0x40(%rsp),%r14
lea    0x70(%rsp),%r8
xor    %r9d,%r9d
lea    0x41(%rsp),%r12
jmp    13f0 <main+0x2a0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
mov    0x38(%rsp),%rax
add    %rax,%r8
sub    %r15d,%r13d
add    %rax,%r14
cmp    0xd8(%rsp),%r9
je     12f0 <main+0x1a0>
test   %r15d,%r15d
jle    13d0 <main+0x280>
movslq %r13d,%r10
mov    %r9,%r11
imul   0x38(%rsp),%r11
mov    %r9d,%esi
not    %esi
mov    0x18(%rsp),%rax
add    %eax,%esi
imul   %r15d,%esi
movslq %esi,%rsi
cmp    $0x8,%r15d
jb     145c <main+0x30c>
mov    %r9d,%ebx
not    %ebx
add    %eax,%ebx
imul   %r15d,%ebx
movslq %ebx,%rbx
mov    0xc8(%rsp),%rax
lea    (%rax,%rbx,1),%rbp
lea    (%rsp,%r11,1),%rax
add    $0x40,%rax
cmp    %rbp,%rax
jae    14d6 <main+0x386>
lea    (%r11,%rdx,1),%rax
add    %rsp,%rax
add    $0x40,%rax
add    %rsp,%rbx
add    $0x40,%rbx
cmp    %rax,%rbx
jae    14d6 <main+0x386>
xor    %ebx,%ebx
mov    %rbx,%rbp
test   $0x1,%dl
je     1485 <main+0x335>
add    %rbx,%r11
add    %rbx,%rsi
mov    0x40(%rsp,%r11,1),%al
mov    0x40(%rsp,%rsi,1),%cl
mov    %cl,0x40(%rsp,%r11,1)
mov    %al,0x40(%rsp,%rsi,1)
mov    %rbx,%rbp
or     $0x1,%rbp
not    %rbx
cmp    0xd0(%rsp),%rbx
je     13d0 <main+0x280>
add    %r12,%r10
nopl   0x0(%rax)
movzbl (%r14,%rbp,1),%eax
movzbl -0x1(%r10,%rbp,1),%ecx
mov    %cl,(%r14,%rbp,1)
mov    %al,-0x1(%r10,%rbp,1)
movzbl 0x1(%r14,%rbp,1),%eax
movzbl (%r10,%rbp,1),%ecx
mov    %cl,0x1(%r14,%rbp,1)
mov    %al,(%r10,%rbp,1)
add    $0x2,%rbp
cmp    %rbp,%rdx
jne    14a0 <main+0x350>
jmp    13d0 <main+0x280>
cmp    $0x20,%r15d
jae    14e3 <main+0x393>
xor    %ebp,%ebp
jmp    15d4 <main+0x484>
cmpq   $0x0,0xc0(%rsp)
je     160a <main+0x4ba>
lea    0x70(%rsp),%rax
lea    (%rax,%r10,1),%rbx
mov    0xb0(%rsp),%rbp
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%r8,%r12,1),%xmm0
movups -0x20(%r8,%r12,1),%xmm1
movups -0x30(%rbx,%r12,1),%xmm2
movups -0x20(%rbx,%r12,1),%xmm3
movups %xmm2,-0x30(%r8,%r12,1)
movups %xmm3,-0x20(%r8,%r12,1)
movups %xmm0,-0x30(%rbx,%r12,1)
movups %xmm1,-0x20(%rbx,%r12,1)
movups -0x10(%r8,%r12,1),%xmm0
movups (%r8,%r12,1),%xmm1
movups -0x10(%rbx,%r12,1),%xmm2
movups (%rbx,%r12,1),%xmm3
movups %xmm2,-0x10(%r8,%r12,1)
movups %xmm3,(%r8,%r12,1)
movups %xmm0,-0x10(%rbx,%r12,1)
movups %xmm1,(%rbx,%r12,1)
add    $0x40,%r12
add    $0xfffffffffffffffe,%rbp
jne    1510 <main+0x3c0>
testb  $0x1,0xb8(%rsp)
01
je     15b3 <main+0x463>
lea    (%r11,%r12,1),%rax
add    %rsi,%r12
movups 0x40(%rsp,%rax,1),%xmm0
movups 0x50(%rsp,%rax,1),%xmm1
movups 0x40(%rsp,%r12,1),%xmm2
movups 0x50(%rsp,%r12,1),%xmm3
movups %xmm2,0x40(%rsp,%rax,1)
movups %xmm3,0x50(%rsp,%rax,1)
movups %xmm0,0x40(%rsp,%r12,1)
movups %xmm1,0x50(%rsp,%r12,1)
cmp    %rdx,0x30(%rsp)
lea    0x41(%rsp),%r12
je     13d0 <main+0x280>
mov    0x30(%rsp),%rbx
mov    %rbx,%rbp
test   $0x18,%dl
je     145e <main+0x30e>
lea    (%rsp,%r10,1),%rbx
add    $0x40,%rbx
nopl   0x0(%rax)
mov    (%r14,%rbp,1),%rax
mov    (%rbx,%rbp,1),%rcx
mov    %rcx,(%r14,%rbp,1)
mov    %rax,(%rbx,%rbp,1)
add    $0x8,%rbp
cmp    %rbp,%rdi
jne    15e0 <main+0x490>
mov    %rdi,%rbx
cmp    %rdx,%rdi
je     13d0 <main+0x280>
jmp    145e <main+0x30e>
xor    %r12d,%r12d
testb  $0x1,0xb8(%rsp)
01
jne    1580 <main+0x430>
jmp    15b3 <main+0x463>
nopl   (%rax)
mov    %rax,0x10(%rsp)
test   %r15d,%r15d
jle    16d0 <main+0x580>
mov    %r15d,%r8d
mov    %edx,%r9d
mov    %r9d,%r14d
and    $0xfffffffe,%r14d
lea    (%r8,%r8,1),%rbx
xor    %r11d,%r11d
mov    %rbx,%rsi
mov    %r8,%r10
jmp    1671 <main+0x521>
nopw   0x0(%rax,%rax,1)
imul   %r8,%rbp
add    %r10,%rbp
mov    0x40(%rsp,%rbp,1),%cl
mov    %cl,0xe0(%rsp,%r11,1)
add    $0x1,%r11
add    $0xffffffffffffffff,%rsi
cmp    $0x2,%rax
jl     16d0 <main+0x580>
mov    %r10,%rax
add    $0xffffffffffffffff,%r10
test   %edx,%edx
jle    1667 <main+0x517>
movslq %r11d,%r11
cmp    $0x1,%edx
jne    1690 <main+0x540>
xor    %ebp,%ebp
test   $0x1,%r9b
je     1667 <main+0x517>
jmp    1650 <main+0x500>
xchg   %ax,%ax
lea    (%r12,%r11,1),%rcx
mov    %r13,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
movzbl (%rdi,%rax,1),%edx
mov    %dl,-0x1(%rcx,%rbp,1)
movzbl (%rdi,%rsi,1),%edx
mov    %dl,(%rcx,%rbp,1)
add    $0x2,%rbp
add    %rbx,%rdi
cmp    %rbp,%r14
jne    16a0 <main+0x550>
add    %rbp,%r11
mov    0x18(%rsp),%rdx
test   $0x1,%r9b
je     1667 <main+0x517>
jmp    1650 <main+0x500>
nopl   0x0(%rax,%rax,1)
mov    %r15d,0x8(%rsp)
mov    %edx,0x4(%rsp)
mov    %edx,%eax
imul   %r15d,%eax
test   %eax,%eax
jle    16fc <main+0x5ac>
mov    %eax,%edx
lea    0x40(%rsp),%rdi
lea    0xe0(%rsp),%rsi
call   1060 <memcpy@plt>
mov    0x18(%rsp),%rdx
mov    %r15d,%esi
jmp    1307 <main+0x1b7>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %edx,%esi
mov    %r15d,%edx
jmp    130c <main+0x1bc>
nopw   0x0(%rax,%rax,1)
mov    %edx,%esi
movl   $0xffffffff,0xc(%rsp)
ff
lea    0x8d8(%rip),%rdi
mov    %r15d,%edx
call   1040 <printf@plt>
cmpl   $0x0,0x8(%rsp)
jle    1240 <main+0xf0>
xor    %r14d,%r14d
jmp    1769 <main+0x619>
nopl   0x0(%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14d
cmp    0x8(%rsp),%r14d
jge    1240 <main+0xf0>
movslq 0x4(%rsp),%rax
movslq %r14d,%rbp
imul   %rbp,%rax
movsbl 0x40(%rsp,%rax,1),%edi
call   1030 <putchar@plt>
cmpl   $0x2,0x4(%rsp)
jl     1750 <main+0x600>
mov    $0x1,%ebx
nopl   0x0(%rax,%rax,1)
mov    $0x20,%edi
call   1030 <putchar@plt>
movslq 0x4(%rsp),%rax
imul   %rbp,%rax
add    %rsp,%rax
add    $0x40,%rax
movsbl (%rbx,%rax,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbx
cmp    0x4(%rsp),%ebx
jl     1790 <main+0x640>
jmp    1750 <main+0x600>

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

LLVM IR (-O2):
@.str = [9 x i8] c"%d %d %d\00"
@EOF = global i64 0
@.str.1 = [7 x i8] c"%d %d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca [100 x i8]
%5 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%6 = alloca [100 x i8]
%7 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 0
%8 = alloca [10 x i8]
%9 = bitcast i32* %1 to i8*
store i32 0, i32* %1
%10 = bitcast i32* %2 to i8*
store i32 0, i32* %2
%11 = bitcast i32* %3 to i8*
store i32 0, i32* %3
%12 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%13 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 0
%14 = getelementptr inbounds [10 x i8], [10 x i8]* %8, i64 0, i64 0
%15 = call i64 @scanf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i32* %1, i32* %2, i32* %3)
%16 = load i64, i64* @EOF
%17 = icmp eq i64 %15, %16
br i1 %17, label %337, label %22
18: ; preds = %319, %303
%19 = call i64 @scanf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i32* %1, i32* %2, i32* %3)
%20 = load i64, i64* @EOF
%21 = icmp eq i64 %19, %20
br i1 %21, label %337, label %22
22: ; preds = %0, %18
%23 = load i32, i32* %1
%24 = load i32, i32* %2
%25 = mul nsw i32 %24, %23
%26 = icmp sgt i32 %25, 0
br i1 %26, label %32, label %27
27: ; preds = %32, %22
%28 = phi i32 [ %23, %22 ], [ %37, %32 ]
%29 = phi i32 [ %24, %22 ], [ %38, %32 ]
%30 = load i32, i32* %3
%31 = icmp sgt i32 %30, 0
br i1 %31, label %53, label %45
32: ; preds = %22, %32
%33 = phi i64 [ %36, %32 ], [ 0, %22 ]
%34 = call signext i8 (...) @read()
%35 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %33
store i8 %34, i8* %35
%36 = add nuw nsw i64 %33, 1
%37 = load i32, i32* %1
%38 = load i32, i32* %2
%39 = mul nsw i32 %38, %37
%40 = sext i32 %39 to i64
%41 = icmp slt i64 %36, %40
br i1 %41, label %32, label %27
42: ; preds = %53
%43 = load i32, i32* %2
%44 = load i32, i32* %1
br label %45
45: ; preds = %42, %27
%46 = phi i32 [ %28, %27 ], [ %44, %42 ]
%47 = phi i32 [ %29, %27 ], [ %43, %42 ]
%48 = phi i32 [ %30, %27 ], [ %58, %42 ]
%49 = icmp eq i32 %48, 0
br i1 %49, label %303, label %50
50: ; preds = %45
%51 = add i32 %48, -1
%52 = sext i32 %51 to i64
br label %61
53: ; preds = %27, %53
%54 = phi i64 [ %57, %53 ], [ 0, %27 ]
%55 = call signext i8 (...) @read()
%56 = getelementptr inbounds [10 x i8], [10 x i8]* %8, i64 0, i64 %54
store i8 %55, i8* %56
%57 = add nuw nsw i64 %54, 1
%58 = load i32, i32* %3
%59 = sext i32 %58 to i64
%60 = icmp slt i64 %57, %59
br i1 %60, label %53, label %42
61: ; preds = %50, %298
%62 = phi i64 [ %52, %50 ], [ %301, %298 ]
%63 = phi i32 [ %47, %50 ], [ %300, %298 ]
%64 = phi i32 [ %46, %50 ], [ %299, %298 ]
%65 = getelementptr inbounds [10 x i8], [10 x i8]* %8, i64 0, i64 %62
%66 = load i8, i8* %65
%67 = icmp eq i8 %66, 49
br i1 %67, label %68, label %240
68: ; preds = %61
%69 = icmp sgt i32 %64, 1
br i1 %69, label %70, label %298
70: ; preds = %68
%71 = lshr i32 %64, 1
%72 = icmp sgt i32 %63, 0
%73 = sext i32 %63 to i64
%74 = zext i32 %71 to i64
%75 = zext i32 %63 to i64
%76 = getelementptr [100 x i8], [100 x i8]* %4, i64 0, i64 %75
%77 = zext i32 %63 to i64
%78 = and i64 %75, 4294967264
%79 = add nsw i64 %78, -32
%80 = lshr exact i64 %79, 5
%81 = add nuw nsw i64 %80, 1
%82 = icmp ult i32 %63, 8
%83 = icmp ult i32 %63, 32
%84 = and i64 %75, 4294967264
%85 = and i64 %81, 1
%86 = icmp eq i64 %79, 0
%87 = and i64 %81, 1152921504606846974
%88 = icmp eq i64 %85, 0
%89 = icmp eq i64 %84, %75
%90 = and i64 %75, 24
%91 = icmp eq i64 %90, 0
%92 = and i64 %77, 4294967288
%93 = icmp eq i64 %92, %77
%94 = and i64 %75, 1
%95 = icmp eq i64 %94, 0
%96 = sub nsw i64 0, %75
br label %97
97: ; preds = %70, %220
%98 = phi i64 [ 0, %70 ], [ %221, %220 ]
%99 = mul i64 %98, %73
%100 = getelementptr [100 x i8], [100 x i8]* %4, i64 0, i64 %99
%101 = add i64 %99, %75
%102 = getelementptr [100 x i8], [100 x i8]* %4, i64 0, i64 %101
%103 = trunc i64 %98 to i32
%104 = xor i32 %103, -1
%105 = add i32 %64, %104
%106 = mul i32 %63, %105
%107 = sext i32 %106 to i64
%108 = getelementptr [100 x i8], [100 x i8]* %4, i64 0, i64 %107
%109 = getelementptr i8, i8* %76, i64 %107
br i1 %72, label %110, label %220
110: ; preds = %97
%111 = mul nsw i64 %98, %73
%112 = trunc i64 %98 to i32
%113 = xor i32 %112, -1
%114 = add i32 %64, %113
%115 = mul nsw i32 %63, %114
%116 = sext i32 %115 to i64
br i1 %82, label %206, label %117
117: ; preds = %110
%118 = icmp ult i8* %100, %109
%119 = icmp ult i8* %108, %102
%120 = and i1 %118, %119
br i1 %120, label %206, label %121
121: ; preds = %117
br i1 %83, label %189, label %122
122: ; preds = %121
br i1 %86, label %166, label %123
123: ; preds = %122, %123
%124 = phi i64 [ %163, %123 ], [ 0, %122 ]
%125 = phi i64 [ %164, %123 ], [ 0, %122 ]
%126 = add nsw i64 %111, %124
%127 = add nsw i64 %124, %116
%128 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %126
%129 = bitcast i8* %128 to <16 x i8>*
%130 = load <16 x i8>, <16 x i8>* %129
%131 = getelementptr inbounds i8, i8* %128, i64 16
%132 = bitcast i8* %131 to <16 x i8>*
%133 = load <16 x i8>, <16 x i8>* %132
%134 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %127
%135 = bitcast i8* %134 to <16 x i8>*
%136 = load <16 x i8>, <16 x i8>* %135
%137 = getelementptr inbounds i8, i8* %134, i64 16
%138 = bitcast i8* %137 to <16 x i8>*
%139 = load <16 x i8>, <16 x i8>* %138
%140 = bitcast i8* %128 to <16 x i8>*
store <16 x i8> %136, <16 x i8>* %140
%141 = bitcast i8* %131 to <16 x i8>*
store <16 x i8> %139, <16 x i8>* %141
%142 = bitcast i8* %134 to <16 x i8>*
store <16 x i8> %130, <16 x i8>* %142
%143 = bitcast i8* %137 to <16 x i8>*
store <16 x i8> %133, <16 x i8>* %143
%144 = or i64 %124, 32
%145 = add nsw i64 %111, %144
%146 = add nsw i64 %144, %116
%147 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %145
%148 = bitcast i8* %147 to <16 x i8>*
%149 = load <16 x i8>, <16 x i8>* %148
%150 = getelementptr inbounds i8, i8* %147, i64 16
%151 = bitcast i8* %150 to <16 x i8>*
%152 = load <16 x i8>, <16 x i8>* %151
%153 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %146
%154 = bitcast i8* %153 to <16 x i8>*
%155 = load <16 x i8>, <16 x i8>* %154
%156 = getelementptr inbounds i8, i8* %153, i64 16
%157 = bitcast i8* %156 to <16 x i8>*
%158 = load <16 x i8>, <16 x i8>* %157
%159 = bitcast i8* %147 to <16 x i8>*
store <16 x i8> %155, <16 x i8>* %159
%160 = bitcast i8* %150 to <16 x i8>*
store <16 x i8> %158, <16 x i8>* %160
%161 = bitcast i8* %153 to <16 x i8>*
store <16 x i8> %149, <16 x i8>* %161
%162 = bitcast i8* %156 to <16 x i8>*
store <16 x i8> %152, <16 x i8>* %162
%163 = add nuw i64 %124, 64
%164 = add i64 %125, 2
%165 = icmp eq i64 %164, %87
br i1 %165, label %166, label %123
166: ; preds = %123, %122
%167 = phi i64 [ 0, %122 ], [ %163, %123 ]
br i1 %88, label %187, label %168
168: ; preds = %166
%169 = add nsw i64 %111, %167
%170 = add nsw i64 %167, %116
%171 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %169
%172 = bitcast i8* %171 to <16 x i8>*
%173 = load <16 x i8>, <16 x i8>* %172
%174 = getelementptr inbounds i8, i8* %171, i64 16
%175 = bitcast i8* %174 to <16 x i8>*
%176 = load <16 x i8>, <16 x i8>* %175
%177 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %170
%178 = bitcast i8* %177 to <16 x i8>*
%179 = load <16 x i8>, <16 x i8>* %178
%180 = getelementptr inbounds i8, i8* %177, i64 16
%181 = bitcast i8* %180 to <16 x i8>*
%182 = load <16 x i8>, <16 x i8>* %181
%183 = bitcast i8* %171 to <16 x i8>*
store <16 x i8> %179, <16 x i8>* %183
%184 = bitcast i8* %174 to <16 x i8>*
store <16 x i8> %182, <16 x i8>* %184
%185 = bitcast i8* %177 to <16 x i8>*
store <16 x i8> %173, <16 x i8>* %185
%186 = bitcast i8* %180 to <16 x i8>*
store <16 x i8> %176, <16 x i8>* %186
br label %187
187: ; preds = %166, %168
br i1 %89, label %220, label %188
188: ; preds = %187
br i1 %91, label %206, label %189
189: ; preds = %121, %188
%190 = phi i64 [ %84, %188 ], [ 0, %121 ]
br label %191
191: ; preds = %191, %189
%192 = phi i64 [ %190, %189 ], [ %203, %191 ]
%193 = add nsw i64 %111, %192
%194 = add nsw i64 %192, %116
%195 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %193
%196 = bitcast i8* %195 to <8 x i8>*
%197 = load <8 x i8>, <8 x i8>* %196
%198 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %194
%199 = bitcast i8* %198 to <8 x i8>*
%200 = load <8 x i8>, <8 x i8>* %199
%201 = bitcast i8* %195 to <8 x i8>*
store <8 x i8> %200, <8 x i8>* %201
%202 = bitcast i8* %198 to <8 x i8>*
store <8 x i8> %197, <8 x i8>* %202
%203 = add nuw i64 %192, 8
%204 = icmp eq i64 %203, %92
br i1 %204, label %205, label %191
205: ; preds = %191
br i1 %93, label %220, label %206
206: ; preds = %117, %110, %188, %205
%207 = phi i64 [ 0, %110 ], [ 0, %117 ], [ %84, %188 ], [ %92, %205 ]
%208 = xor i64 %207, -1
br i1 %95, label %217, label %209
209: ; preds = %206
%210 = add nsw i64 %111, %207
%211 = add nsw i64 %207, %116
%212 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %210
%213 = load i8, i8* %212
%214 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %211
%215 = load i8, i8* %214
store i8 %215, i8* %212
store i8 %213, i8* %214
%216 = or i64 %207, 1
br label %217
217: ; preds = %209, %206
%218 = phi i64 [ %207, %206 ], [ %216, %209 ]
%219 = icmp eq i64 %208, %96
br i1 %219, label %220, label %223
220: ; preds = %217, %223, %187, %205, %97
%221 = add nuw nsw i64 %98, 1
%222 = icmp eq i64 %221, %74
br i1 %222, label %298, label %97
223: ; preds = %217, %223
%224 = phi i64 [ %238, %223 ], [ %218, %217 ]
%225 = add nsw i64 %111, %224
%226 = add nsw i64 %224, %116
%227 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %225
%228 = load i8, i8* %227
%229 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %226
%230 = load i8, i8* %229
store i8 %230, i8* %227
store i8 %228, i8* %229
%231 = add nuw nsw i64 %224, 1
%232 = add nsw i64 %111, %231
%233 = add nsw i64 %231, %116
%234 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %232
%235 = load i8, i8* %234
%236 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %233
%237 = load i8, i8* %236
store i8 %237, i8* %234
store i8 %235, i8* %236
%238 = add nuw nsw i64 %224, 2
%239 = icmp eq i64 %238, %75
br i1 %239, label %220, label %223
240: ; preds = %61
%241 = icmp sgt i32 %63, 0
br i1 %241, label %242, label %273
242: ; preds = %240
%243 = icmp sgt i32 %64, 0
%244 = zext i32 %63 to i64
%245 = zext i32 %64 to i64
%246 = and i64 %245, 1
%247 = icmp eq i32 %64, 1
%248 = and i64 %245, 4294967294
%249 = icmp eq i64 %246, 0
br label %267
250: ; preds = %278, %271
%251 = phi i64 [ undef, %271 ], [ %293, %278 ]
%252 = phi i64 [ %272, %271 ], [ %293, %278 ]
%253 = phi i64 [ 0, %271 ], [ %295, %278 ]
br i1 %249, label %261, label %254
254: ; preds = %250
%255 = mul nsw i64 %253, %244
%256 = add nsw i64 %255, %270
%257 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %256
%258 = load i8, i8* %257
%259 = add nsw i64 %252, 1
%260 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 %252
store i8 %258, i8* %260
br label %261
261: ; preds = %250, %254
%262 = phi i64 [ %251, %250 ], [ %259, %254 ]
%263 = trunc i64 %262 to i32
br label %264
264: ; preds = %261, %267
%265 = phi i32 [ %269, %267 ], [ %263, %261 ]
%266 = icmp sgt i64 %268, 1
br i1 %266, label %267, label %273
267: ; preds = %242, %264
%268 = phi i64 [ %244, %242 ], [ %270, %264 ]
%269 = phi i32 [ 0, %242 ], [ %265, %264 ]
%270 = add nsw i64 %268, -1
br i1 %243, label %271, label %264
271: ; preds = %267
%272 = sext i32 %269 to i64
br i1 %247, label %250, label %278
273: ; preds = %264, %240
store i32 %63, i32* %1
store i32 %64, i32* %2
%274 = mul i32 %64, %63
%275 = icmp sgt i32 %274, 0
br i1 %275, label %276, label %298
276: ; preds = %273
%277 = zext i32 %274 to i64
br label %298
278: ; preds = %271, %278
%279 = phi i64 [ %293, %278 ], [ %272, %271 ]
%280 = phi i64 [ %295, %278 ], [ 0, %271 ]
%281 = phi i64 [ %296, %278 ], [ 0, %271 ]
%282 = mul nsw i64 %280, %244
%283 = add nsw i64 %282, %270
%284 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %283
%285 = load i8, i8* %284
%286 = add nsw i64 %279, 1
%287 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 %279
store i8 %285, i8* %287
%288 = or i64 %280, 1
%289 = mul nsw i64 %288, %244
%290 = add nsw i64 %289, %270
%291 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %290
%292 = load i8, i8* %291
%293 = add nsw i64 %279, 2
%294 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 %286
store i8 %292, i8* %294
%295 = add nuw nsw i64 %280, 2
%296 = add i64 %281, 2
%297 = icmp eq i64 %296, %248
br i1 %297, label %250, label %278
298: ; preds = %220, %276, %273, %68
%299 = phi i32 [ %64, %68 ], [ %63, %273 ], [ %63, %276 ], [ %64, %220 ]
%300 = phi i32 [ %63, %68 ], [ %64, %273 ], [ %64, %276 ], [ %63, %220 ]
%301 = add nsw i64 %62, -1
%302 = icmp eq i64 %62, 0
br i1 %302, label %303, label %61
303: ; preds = %298, %45
%304 = phi i32 [ %47, %45 ], [ %300, %298 ]
%305 = phi i32 [ %46, %45 ], [ %299, %298 ]
store i32 -1, i32* %3
%306 = call i32 @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 %305, i32 %304)
%307 = load i32, i32* %1
%308 = icmp sgt i32 %307, 0
br i1 %308, label %309, label %18
309: ; preds = %303, %319
%310 = phi i32 [ %321, %319 ], [ 0, %303 ]
%311 = load i32, i32* %2
%312 = mul nsw i32 %311, %310
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %313
%315 = load i8, i8* %314
%316 = call i32 @putchar(i8 signext %315)
%317 = load i32, i32* %2
%318 = icmp sgt i32 %317, 1
br i1 %318, label %324, label %319
319: ; preds = %324, %309
%320 = call i32 @putchar(i8 signext 10)
%321 = add nuw nsw i32 %310, 1
%322 = load i32, i32* %1
%323 = icmp slt i32 %321, %322
br i1 %323, label %309, label %18
324: ; preds = %309, %324
%325 = phi i32 [ %334, %324 ], [ 1, %309 ]
%326 = call i32 @putchar(i8 signext 32)
%327 = load i32, i32* %2
%328 = mul nsw i32 %327, %310
%329 = add nsw i32 %328, %325
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %330
%332 = load i8, i8* %331
%333 = call i32 @putchar(i8 signext %332)
%334 = add nuw nsw i32 %325, 1
%335 = load i32, i32* %2
%336 = icmp slt i32 %334, %335
br i1 %336, label %324, label %319
337: ; preds = %18, %0
ret i32 0
}