#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 fixedMaximalRectangle(int *, int *, int);
scalar_t__ malloc(int);
int maximalRectangle(char **matrix, int rowSize, int colSize) {
  colSize++;
  int *heights = (int *)malloc(sizeof(int) * colSize);
  int *stack = (int *)malloc(sizeof(int) * colSize);
  int i = 0, j = 0;
  int max = 0, current = 0;
  for (j = 0; j < colSize; j++) {
    heights[j] = 0;
    stack[j] = 0;
  }
  for (i = 0; i < rowSize; i++) {
    for (j = 0; j < colSize - 1; j++) {
      matrix[i][j] == '0' ? heights[j] = 0 : heights[j]++;
    }
    current = fixedMaximalRectangle(heights, stack, colSize);
    if (current > max)
      max = current;
  }
  return max;
}


x86 assembly (clang, -O0):
<maximalRectangle>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x18(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11bc <maximalRectangle+0x9c>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1184 <maximalRectangle+0x64>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    126f <maximalRectangle+0x14f>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1237 <maximalRectangle+0x117>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jne    1218 <maximalRectangle+0xf8>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    1229 <maximalRectangle+0x109>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11d6 <maximalRectangle+0xb6>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x10(%rbp),%edx
call   1040 <fixedMaximalRectangle@plt>
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jle    125c <maximalRectangle+0x13c>
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1261 <maximalRectangle+0x141>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11c3 <maximalRectangle+0xa3>
mov    -0x2c(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<maximalRectangle>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %edx,%r12d
mov    %esi,%r14d
mov    %rdi,0x38(%rsp)
lea    0x1(%r12),%eax
mov    %eax,0x4(%rsp)
lea    0x4(,%r12,4),%ebx
mov    %ebx,%edi
call   1030 <malloc@plt>
mov    %rax,%rbp
mov    %ebx,%edi
call   1030 <malloc@plt>
mov    %rax,%r13
test   %r12d,%r12d
js     1338 <maximalRectangle+0x218>
mov    0x4(%rsp),%ecx
mov    %ecx,%eax
cmp    $0x8,%ecx
jb     119a <maximalRectangle+0x7a>
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
cmp    %rcx,%rbp
jae    1232 <maximalRectangle+0x112>
lea    0x0(,%rax,4),%rcx
add    %rbp,%rcx
cmp    %rcx,%r13
jae    1232 <maximalRectangle+0x112>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     11cb <maximalRectangle+0xab>
xchg   %ax,%ax
movl   $0x0,0x0(%rbp,%rcx,4)
movl   $0x0,0x0(%r13,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11b0 <maximalRectangle+0x90>
cmp    $0x3,%rdx
jb     1338 <maximalRectangle+0x218>
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,0x0(%rbp,%rcx,4)
movl   $0x0,0x0(%r13,%rcx,4)
movl   $0x0,0x4(%rbp,%rcx,4)
movl   $0x0,0x4(%r13,%rcx,4)
movl   $0x0,0x8(%rbp,%rcx,4)
movl   $0x0,0x8(%r13,%rcx,4)
movl   $0x0,0xc(%rbp,%rcx,4)
movl   $0x0,0xc(%r13,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    11e0 <maximalRectangle+0xc0>
jmp    1338 <maximalRectangle+0x218>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1258 <maximalRectangle+0x138>
xor    %edi,%edi
jmp    12e2 <maximalRectangle+0x1c2>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu %xmm0,0x0(%rbp,%rdi,4)
movdqu %xmm0,0x10(%rbp,%rdi,4)
movdqu %xmm0,0x0(%r13,%rdi,4)
movdqu %xmm0,0x10(%r13,%rdi,4)
movdqu %xmm0,0x20(%rbp,%rdi,4)
movdqu %xmm0,0x30(%rbp,%rdi,4)
movdqu %xmm0,0x20(%r13,%rdi,4)
movdqu %xmm0,0x30(%r13,%rdi,4)
movdqu %xmm0,0x40(%rbp,%rdi,4)
movdqu %xmm0,0x50(%rbp,%rdi,4)
movdqu %xmm0,0x40(%r13,%rdi,4)
movdqu %xmm0,0x50(%r13,%rdi,4)
movdqu %xmm0,0x60(%rbp,%rdi,4)
movdqu %xmm0,0x70(%rbp,%rdi,4)
movdqu %xmm0,0x60(%r13,%rdi,4)
movdqu %xmm0,0x70(%r13,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1270 <maximalRectangle+0x150>
test   %rdx,%rdx
je     132f <maximalRectangle+0x20f>
lea    0x10(,%rdi,4),%rsi
add    %r13,%rsi
lea    0x10(,%rdi,4),%rdi
add    %rbp,%rdi
shl    $0x5,%rdx
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rdi,%rbx,1)
movdqu %xmm0,(%rdi,%rbx,1)
movdqu %xmm0,-0x10(%rsi,%rbx,1)
movdqu %xmm0,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rdx
jne    1310 <maximalRectangle+0x1f0>
cmp    %rax,%rcx
jne    119c <maximalRectangle+0x7c>
test   %r14d,%r14d
jle    15d6 <maximalRectangle+0x4b6>
mov    %r14d,%eax
mov    %rax,0x40(%rsp)
mov    %r12d,%r15d
lea    0x0(,%r15,4),%rax
add    %rbp,%rax
mov    %rax,0x28(%rsp)
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x20(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x18(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
or     $0x2,%rdx
mov    %rax,%rcx
mov    %rax,0x10(%rsp)
and    %rax,%rdx
mov    %rdx,0x8(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x30(%rsp)
xor    %r14d,%r14d
movdqa 0xc54(%rip),%xmm6
pcmpeqd %xmm7,%xmm7
xor    %ebx,%ebx
jmp    13ef <maximalRectangle+0x2cf>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbp,%rdi
mov    %r13,%rsi
mov    0x4(%rsp),%edx
call   1040 <fixedMaximalRectangle@plt>
pcmpeqd %xmm7,%xmm7
movdqa 0xc25(%rip),%xmm6
cmp    %ebx,%eax
cmovg  %eax,%ebx
add    $0x1,%r14
cmp    0x40(%rsp),%r14
je     15d8 <maximalRectangle+0x4b8>
test   %r12d,%r12d
jle    13c0 <maximalRectangle+0x2a0>
mov    0x38(%rsp),%rax
mov    (%rax,%r14,8),%rax
cmp    $0x8,%r12d
jb     1413 <maximalRectangle+0x2f3>
lea    (%rax,%r15,1),%rcx
cmp    %rbp,%rcx
jbe    1489 <maximalRectangle+0x369>
cmp    0x28(%rsp),%rax
jae    1489 <maximalRectangle+0x369>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r15b
je     1438 <maximalRectangle+0x318>
xor    %ecx,%ecx
cmpb   $0x30,(%rax,%rdx,1)
je     142d <maximalRectangle+0x30d>
mov    0x0(%rbp,%rdx,4),%ecx
add    $0x1,%ecx
mov    %ecx,0x0(%rbp,%rdx,4)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x30(%rsp),%rdx
jne    1461 <maximalRectangle+0x341>
jmp    13c0 <maximalRectangle+0x2a0>
nopw   0x0(%rax,%rax,1)
mov    %edx,0x4(%rbp,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r15
je     13c0 <maximalRectangle+0x2a0>
xor    %edx,%edx
cmpb   $0x30,(%rax,%rcx,1)
mov    $0x0,%esi
je     1475 <maximalRectangle+0x355>
mov    0x0(%rbp,%rcx,4),%esi
add    $0x1,%esi
mov    %esi,0x0(%rbp,%rcx,4)
cmpb   $0x30,0x1(%rax,%rcx,1)
je     1450 <maximalRectangle+0x330>
mov    0x4(%rbp,%rcx,4),%edx
add    $0x1,%edx
jmp    1450 <maximalRectangle+0x330>
cmpq   $0x0,0x18(%rsp)
je     15cb <maximalRectangle+0x4ab>
mov    0x8(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movd   (%rax,%rcx,1),%xmm0
movd   0x4(%rax,%rcx,1),%xmm1
pcmpeqb %xmm6,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
pcmpeqb %xmm6,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
movdqu 0x0(%rbp,%rcx,4),%xmm2
movdqu 0x10(%rbp,%rcx,4),%xmm3
movdqu 0x20(%rbp,%rcx,4),%xmm4
movdqu 0x30(%rbp,%rcx,4),%xmm5
psubd  %xmm7,%xmm2
pandn  %xmm2,%xmm0
psubd  %xmm7,%xmm3
pandn  %xmm3,%xmm1
movdqu %xmm0,0x0(%rbp,%rcx,4)
movdqu %xmm1,0x10(%rbp,%rcx,4)
movd   0x8(%rax,%rcx,1),%xmm0
movd   0xc(%rax,%rcx,1),%xmm1
pcmpeqb %xmm6,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
pcmpeqb %xmm6,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
psubd  %xmm7,%xmm4
pandn  %xmm4,%xmm0
psubd  %xmm7,%xmm5
pandn  %xmm5,%xmm1
movdqu %xmm0,0x20(%rbp,%rcx,4)
movdqu %xmm1,0x30(%rbp,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    14a0 <maximalRectangle+0x380>
testb  $0x1,0x10(%rsp)
je     15b5 <maximalRectangle+0x495>
movd   (%rax,%rcx,1),%xmm0
movd   0x4(%rax,%rcx,1),%xmm1
pcmpeqb %xmm6,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
psrad  $0x18,%xmm0
pcmpeqb %xmm6,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
psrad  $0x18,%xmm1
movdqu 0x0(%rbp,%rcx,4),%xmm2
movdqu 0x10(%rbp,%rcx,4),%xmm3
psubd  %xmm7,%xmm2
pandn  %xmm2,%xmm0
psubd  %xmm7,%xmm3
pandn  %xmm3,%xmm1
movdqu %xmm0,0x0(%rbp,%rcx,4)
movdqu %xmm1,0x10(%rbp,%rcx,4)
mov    0x20(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r15,%rcx
je     13c0 <maximalRectangle+0x2a0>
jmp    1415 <maximalRectangle+0x2f5>
xor    %ecx,%ecx
testb  $0x1,0x10(%rsp)
jne    1560 <maximalRectangle+0x440>
jmp    15b5 <maximalRectangle+0x495>
xor    %ebx,%ebx
mov    %ebx,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @maximalRectangle(i8** %0, i32 %1, i32 %2) {
%4 = alloca i8**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i8** %0, i8*** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%13 = load i32, i32* %6
%14 = add nsw i32 %13, 1
store i32 %14, i32* %6
%15 = load i32, i32* %6
%16 = sext i32 %15 to i64
%17 = mul i64 4, %16
%18 = trunc i64 %17 to i32
%19 = call i64 @malloc(i32 %18)
%20 = inttoptr i64 %19 to i32*
store i32* %20, i32** %7
%21 = load i32, i32* %6
%22 = sext i32 %21 to i64
%23 = mul i64 4, %22
%24 = trunc i64 %23 to i32
%25 = call i64 @malloc(i32 %24)
%26 = inttoptr i64 %25 to i32*
store i32* %26, i32** %8
store i32 0, i32* %9
store i32 0, i32* %10
store i32 0, i32* %11
store i32 0, i32* %12
store i32 0, i32* %10
br label %27
27: ; preds = %40, %3
%28 = load i32, i32* %10
%29 = load i32, i32* %6
%30 = icmp slt i32 %28, %29
br i1 %30, label %31, label %43
31: ; preds = %27
%32 = load i32*, i32** %7
%33 = load i32, i32* %10
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %32, i64 %34
store i32 0, i32* %35
%36 = load i32*, i32** %8
%37 = load i32, i32* %10
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i32, i32* %36, i64 %38
store i32 0, i32* %39
br label %40
40: ; preds = %31
%41 = load i32, i32* %10
%42 = add nsw i32 %41, 1
store i32 %42, i32* %10
br label %27
43: ; preds = %27
store i32 0, i32* %9
br label %44
44: ; preds = %94, %43
%45 = load i32, i32* %9
%46 = load i32, i32* %5
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %97
48: ; preds = %44
store i32 0, i32* %10
br label %49
49: ; preds = %80, %48
%50 = load i32, i32* %10
%51 = load i32, i32* %6
%52 = sub nsw i32 %51, 1
%53 = icmp slt i32 %50, %52
br i1 %53, label %54, label %83
54: ; preds = %49
%55 = load i8**, i8*** %4
%56 = load i32, i32* %9
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i8*, i8** %55, i64 %57
%59 = load i8*, i8** %58
%60 = load i32, i32* %10
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %59, i64 %61
%63 = load i8, i8* %62
%64 = sext i8 %63 to i32
%65 = icmp eq i32 %64, 48
br i1 %65, label %66, label %71
66: ; preds = %54
%67 = load i32*, i32** %7
%68 = load i32, i32* %10
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i32, i32* %67, i64 %69
store i32 0, i32* %70
br label %78
71: ; preds = %54
%72 = load i32*, i32** %7
%73 = load i32, i32* %10
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i32, i32* %72, i64 %74
%76 = load i32, i32* %75
%77 = add nsw i32 %76, 1
store i32 %77, i32* %75
br label %78
78: ; preds = %71, %66
%79 = phi i32 [ 0, %66 ], [ %76, %71 ]
br label %80
80: ; preds = %78
%81 = load i32, i32* %10
%82 = add nsw i32 %81, 1
store i32 %82, i32* %10
br label %49
83: ; preds = %49
%84 = load i32*, i32** %7
%85 = load i32*, i32** %8
%86 = load i32, i32* %6
%87 = call i32 @fixedMaximalRectangle(i32* %84, i32* %85, i32 %86)
store i32 %87, i32* %12
%88 = load i32, i32* %12
%89 = load i32, i32* %11
%90 = icmp sgt i32 %88, %89
br i1 %90, label %91, label %93
91: ; preds = %83
%92 = load i32, i32* %12
store i32 %92, i32* %11
br label %93
93: ; preds = %91, %83
br label %94
94: ; preds = %93
%95 = load i32, i32* %9
%96 = add nsw i32 %95, 1
store i32 %96, i32* %9
br label %44
97: ; preds = %44
%98 = load i32, i32* %11
ret i32 %98
}

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