#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 *, ...);
int main(void) {
  int x, y, z, n;
  int xy[2][101] = {{0}};
  int xym[2];
  scanf("%d %d %d %d", &x, &y, &z, &n);
  xym[0] = x;
  xym[1] = y;
  while (n--) {
    int d, a, i;
    scanf("%d %d", &d, &a);
    xy[d][0]++;
    xym[d] = ((xym[d]) > (((xy[d][xy[d][0]] = a) > ((d ? y : x) - a)
                               ? ((d ? y : x) - a)
                               : (xy[d][xy[d][0]] = a)))
                  ? (((xy[d][xy[d][0]] = a) > ((d ? y : x) - a)
                          ? ((d ? y : x) - a)
                          : (xy[d][xy[d][0]] = a)))
                  : (xym[d]));
    for (i = 1; i < xy[d][0]; i++) {
      xym[d] =
          (((0 > (xy[d][i] - a) ? (-(xy[d][i] - a)) : xy[d][i] - a)) > (xym[d])
               ? (xym[d])
               : ((0 > (xy[d][i] - a) ? (-(xy[d][i] - a)) : xy[d][i] - a)));
    }
  }
  printf("%d\n", z * xym[0] * xym[1]);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x390,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x340(%rbp),%rdi
xor    %esi,%esi
mov    $0x328,%edx
call   1040 <memset@plt>
lea    0xea4(%rip),%rdi
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
lea    -0x10(%rbp),%rcx
lea    -0x14(%rbp),%r8
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x348(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x344(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     15f9 <main+0x4c9>
lea    0xe66(%rip),%rdi
lea    -0x34c(%rbp),%rsi
lea    -0x350(%rbp),%rdx
mov    $0x0,%al
call   1050 <scanf@plt>
movslq -0x34c(%rbp),%rcx
lea    -0x340(%rbp),%rax
imul   $0x194,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
movslq -0x34c(%rbp),%rax
mov    -0x348(%rbp,%rax,4),%eax
mov    %eax,-0x35c(%rbp)
mov    -0x350(%rbp),%edx
mov    %edx,-0x358(%rbp)
movslq -0x34c(%rbp),%rcx
lea    -0x340(%rbp),%rax
imul   $0x194,%rcx,%rcx
add    %rcx,%rax
movslq -0x34c(%rbp),%rsi
lea    -0x340(%rbp),%rcx
imul   $0x194,%rsi,%rsi
add    %rsi,%rcx
movslq (%rcx),%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x34c(%rbp)
je     1245 <main+0x115>
mov    -0xc(%rbp),%eax
mov    %eax,-0x360(%rbp)
jmp    124e <main+0x11e>
mov    -0x8(%rbp),%eax
mov    %eax,-0x360(%rbp)
mov    -0x358(%rbp),%eax
mov    -0x360(%rbp),%ecx
sub    -0x350(%rbp),%ecx
cmp    %ecx,%eax
jle    12a3 <main+0x173>
cmpl   $0x0,-0x34c(%rbp)
je     1283 <main+0x153>
mov    -0xc(%rbp),%eax
mov    %eax,-0x364(%rbp)
jmp    128c <main+0x15c>
mov    -0x8(%rbp),%eax
mov    %eax,-0x364(%rbp)
mov    -0x364(%rbp),%eax
sub    -0x350(%rbp),%eax
mov    %eax,-0x368(%rbp)
jmp    12e5 <main+0x1b5>
mov    -0x350(%rbp),%eax
movslq -0x34c(%rbp),%rdx
lea    -0x340(%rbp),%rcx
imul   $0x194,%rdx,%rdx
add    %rdx,%rcx
movslq -0x34c(%rbp),%rsi
lea    -0x340(%rbp),%rdx
imul   $0x194,%rsi,%rsi
add    %rsi,%rdx
movslq (%rdx),%rdx
mov    %eax,(%rcx,%rdx,4)
mov    %eax,-0x368(%rbp)
mov    -0x35c(%rbp),%eax
mov    -0x368(%rbp),%ecx
cmp    %ecx,%eax
jle    1407 <main+0x2d7>
mov    -0x350(%rbp),%edx
mov    %edx,-0x36c(%rbp)
movslq -0x34c(%rbp),%rcx
lea    -0x340(%rbp),%rax
imul   $0x194,%rcx,%rcx
add    %rcx,%rax
movslq -0x34c(%rbp),%rsi
lea    -0x340(%rbp),%rcx
imul   $0x194,%rsi,%rsi
add    %rsi,%rcx
movslq (%rcx),%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x34c(%rbp)
je     1356 <main+0x226>
mov    -0xc(%rbp),%eax
mov    %eax,-0x370(%rbp)
jmp    135f <main+0x22f>
mov    -0x8(%rbp),%eax
mov    %eax,-0x370(%rbp)
mov    -0x36c(%rbp),%eax
mov    -0x370(%rbp),%ecx
sub    -0x350(%rbp),%ecx
cmp    %ecx,%eax
jle    13b4 <main+0x284>
cmpl   $0x0,-0x34c(%rbp)
je     1394 <main+0x264>
mov    -0xc(%rbp),%eax
mov    %eax,-0x374(%rbp)
jmp    139d <main+0x26d>
mov    -0x8(%rbp),%eax
mov    %eax,-0x374(%rbp)
mov    -0x374(%rbp),%eax
sub    -0x350(%rbp),%eax
mov    %eax,-0x378(%rbp)
jmp    13f6 <main+0x2c6>
mov    -0x350(%rbp),%eax
movslq -0x34c(%rbp),%rdx
lea    -0x340(%rbp),%rcx
imul   $0x194,%rdx,%rdx
add    %rdx,%rcx
movslq -0x34c(%rbp),%rsi
lea    -0x340(%rbp),%rdx
imul   $0x194,%rsi,%rsi
add    %rsi,%rdx
movslq (%rdx),%rdx
mov    %eax,(%rcx,%rdx,4)
mov    %eax,-0x378(%rbp)
mov    -0x378(%rbp),%eax
mov    %eax,-0x37c(%rbp)
jmp    141b <main+0x2eb>
movslq -0x34c(%rbp),%rax
mov    -0x348(%rbp,%rax,4),%eax
mov    %eax,-0x37c(%rbp)
mov    -0x37c(%rbp),%ecx
movslq -0x34c(%rbp),%rax
mov    %ecx,-0x348(%rbp,%rax,4)
movl   $0x1,-0x354(%rbp)
mov    -0x354(%rbp),%eax
movslq -0x34c(%rbp),%rdx
lea    -0x340(%rbp),%rcx
imul   $0x194,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
jge    15f4 <main+0x4c4>
movslq -0x34c(%rbp),%rcx
lea    -0x340(%rbp),%rax
imul   $0x194,%rcx,%rcx
add    %rcx,%rax
movslq -0x354(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
sub    -0x350(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    14c8 <main+0x398>
movslq -0x34c(%rbp),%rcx
lea    -0x340(%rbp),%rax
imul   $0x194,%rcx,%rcx
add    %rcx,%rax
movslq -0x354(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
sub    -0x350(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x380(%rbp)
jmp    14f6 <main+0x3c6>
movslq -0x34c(%rbp),%rcx
lea    -0x340(%rbp),%rax
imul   $0x194,%rcx,%rcx
add    %rcx,%rax
movslq -0x354(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    -0x350(%rbp),%eax
mov    %eax,-0x380(%rbp)
mov    -0x380(%rbp),%eax
movslq -0x34c(%rbp),%rcx
cmp    -0x348(%rbp,%rcx,4),%eax
jle    1529 <main+0x3f9>
movslq -0x34c(%rbp),%rax
mov    -0x348(%rbp,%rax,4),%eax
mov    %eax,-0x384(%rbp)
jmp    15cc <main+0x49c>
movslq -0x34c(%rbp),%rcx
lea    -0x340(%rbp),%rax
imul   $0x194,%rcx,%rcx
add    %rcx,%rax
movslq -0x354(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
sub    -0x350(%rbp),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jle    1592 <main+0x462>
movslq -0x34c(%rbp),%rcx
lea    -0x340(%rbp),%rax
imul   $0x194,%rcx,%rcx
add    %rcx,%rax
movslq -0x354(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
sub    -0x350(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x388(%rbp)
jmp    15c0 <main+0x490>
movslq -0x34c(%rbp),%rcx
lea    -0x340(%rbp),%rax
imul   $0x194,%rcx,%rcx
add    %rcx,%rax
movslq -0x354(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    -0x350(%rbp),%eax
mov    %eax,-0x388(%rbp)
mov    -0x388(%rbp),%eax
mov    %eax,-0x384(%rbp)
mov    -0x384(%rbp),%ecx
movslq -0x34c(%rbp),%rax
mov    %ecx,-0x348(%rbp,%rax,4)
mov    -0x354(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x354(%rbp)
jmp    1439 <main+0x309>
jmp    1185 <main+0x55>
mov    -0x10(%rbp),%esi
imul   -0x348(%rbp),%esi
imul   -0x344(%rbp),%esi
lea    0x9fb(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x390,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x348,%rsp
lea    0x20(%rsp),%rdi
mov    $0x328,%edx
xor    %esi,%esi
call   1040 <memset@plt>
lea    0xea7(%rip),%rdi
lea    0xc(%rsp),%rbx
lea    0x1c(%rsp),%r15
lea    0x18(%rsp),%rcx
lea    0x8(%rsp),%r8
mov    %rbx,%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0xc(%rsp),%esi
mov    %esi,(%rsp)
mov    0x1c(%rsp),%eax
mov    %eax,0x4(%rsp)
subl   $0x1,0x8(%rsp)
jb     1386 <main+0x256>
lea    0xe6b(%rip),%r12
lea    0x14(%rsp),%r13
lea    0x10(%rsp),%r14
jmp    11c4 <main+0x94>
nopw   0x0(%rax,%rax,1)
mov    %eax,(%rsp,%r9,4)
lea    0xc(%rsp),%rbx
subl   $0x1,0x8(%rsp)
jb     137f <main+0x24f>
mov    %r12,%rdi
mov    %r13,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
movslq 0x14(%rsp),%r9
imul   $0x194,%r9,%rbp
movslq 0x20(%rsp,%rbp,1),%rax
lea    0x1(%rax),%rdx
test   %r9,%r9
lea    0x20(%rsp,%rbp,1),%rcx
mov    %edx,0x20(%rsp,%rbp,1)
mov    0x10(%rsp),%edx
mov    %edx,0x4(%rcx,%rax,4)
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    (%rsp,%r9,4),%eax
mov    (%rsi),%esi
sub    %edx,%esi
cmp    %esi,%edx
jle    1220 <main+0xf0>
cmp    %esi,%eax
jg     1232 <main+0x102>
jmp    123a <main+0x10a>
cs nopw 0x0(%rax,%rax,1)
movslq (%rcx),%rsi
mov    %edx,(%rcx,%rsi,4)
cmp    %edx,%eax
jle    123a <main+0x10a>
movslq (%rcx),%rax
mov    %edx,(%rcx,%rax,4)
mov    %edx,%esi
movslq (%rcx),%rax
mov    %edx,(%rcx,%rax,4)
mov    %esi,%eax
mov    %eax,(%rsp,%r9,4)
mov    (%rcx),%esi
cmp    $0x2,%esi
jl     11b9 <main+0x89>
lea    -0x1(%rsi),%r8
mov    $0x1,%edi
cmp    $0x8,%r8
jb     1360 <main+0x230>
mov    %r8,%rbx
and    $0xfffffffffffffff8,%rbx
lea    0x1(%rbx),%rdi
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
movd   %edx,%xmm1
pshufd $0x0,%xmm1,%xmm1
lea    0x34(%rsp),%rax
add    %rax,%rbp
xor    %eax,%eax
movdqa %xmm0,%xmm2
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rbp,%rax,4),%xmm3
movdqu 0x0(%rbp,%rax,4),%xmm4
psubd  %xmm1,%xmm3
psubd  %xmm1,%xmm4
movdqa %xmm3,%xmm5
psrad  $0x1f,%xmm5
paddd  %xmm5,%xmm3
pxor   %xmm5,%xmm3
movdqa %xmm4,%xmm5
psrad  $0x1f,%xmm5
paddd  %xmm5,%xmm4
pxor   %xmm5,%xmm4
movdqa %xmm0,%xmm5
pcmpgtd %xmm3,%xmm5
pand   %xmm5,%xmm3
pandn  %xmm0,%xmm5
movdqa %xmm5,%xmm0
por    %xmm3,%xmm0
movdqa %xmm2,%xmm3
pcmpgtd %xmm4,%xmm3
pand   %xmm3,%xmm4
pandn  %xmm2,%xmm3
movdqa %xmm3,%xmm2
por    %xmm4,%xmm2
add    $0x8,%rax
cmp    %rax,%rbx
jne    1290 <main+0x160>
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm0
pandn  %xmm2,%xmm1
por    %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
movd   %xmm1,%eax
cmp    %rbx,%r8
je     11b0 <main+0x80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rcx,%rdi,4),%ebx
sub    %edx,%ebx
mov    %ebx,%ebp
neg    %ebp
cmovs  %ebx,%ebp
cmp    %eax,%ebp
cmovle %ebp,%eax
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1360 <main+0x230>
jmp    11b0 <main+0x80>
mov    (%rsp),%esi
mov    0x4(%rsp),%eax
imul   0x18(%rsp),%esi
imul   %eax,%esi
lea    0xc77(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x348,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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