int uniquePaths(int m, int n) {
  if (m <= 0 || n <= 0)
    return 0;
  int f[100][100];
  for (int i = 0; i < m; ++i)
    f[i][0] = 1;
  for (int j = 0; j < n; ++j)
    f[0][j] = 1;
  for (int i = 1; i < m; ++i)
    for (int j = 1; j < n; ++j)
      f[i][j] = f[i - 1][j] + f[i][j - 1];
  return f[m - 1][n - 1];
}


x86 assembly (clang, -O0):
<uniquePaths>:
push   %rbp
mov    %rsp,%rbp
sub    $0x9be0,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x0,-0x8(%rbp)
jle    1125 <uniquePaths+0x25>
cmpl   $0x0,-0xc(%rbp)
jg     1131 <uniquePaths+0x31>
movl   $0x0,-0x4(%rbp)
jmp    12b3 <uniquePaths+0x1b3>
movl   $0x0,-0x9c54(%rbp)
mov    -0x9c54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    117c <uniquePaths+0x7c>
movslq -0x9c54(%rbp),%rcx
lea    -0x9c50(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movl   $0x1,(%rax)
mov    -0x9c54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c54(%rbp)
jmp    113b <uniquePaths+0x3b>
movl   $0x0,-0x9c58(%rbp)
mov    -0x9c58(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11bb <uniquePaths+0xbb>
movslq -0x9c58(%rbp),%rax
movl   $0x1,-0x9c50(%rbp,%rax,4)
mov    -0x9c58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c58(%rbp)
jmp    1186 <uniquePaths+0x86>
movl   $0x1,-0x9c5c(%rbp)
mov    -0x9c5c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    128a <uniquePaths+0x18a>
movl   $0x1,-0x9c60(%rbp)
mov    -0x9c60(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1271 <uniquePaths+0x171>
mov    -0x9c5c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x9c50(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x9c60(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x9c5c(%rbp),%rcx
lea    -0x9c50(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
mov    -0x9c60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
movslq -0x9c5c(%rbp),%rcx
lea    -0x9c50(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x9c60(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x9c60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c60(%rbp)
jmp    11de <uniquePaths+0xde>
jmp    1276 <uniquePaths+0x176>
mov    -0x9c5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c5c(%rbp)
jmp    11c5 <uniquePaths+0xc5>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x9c50(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x9be0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<uniquePaths>:
xor    %eax,%eax
test   %edi,%edi
jle    136b <uniquePaths+0x26b>
test   %esi,%esi
jle    136b <uniquePaths+0x26b>
push   %r14
push   %rbx
sub    $0x9bc8,%rsp
mov    %edi,%r8d
lea    -0x1(%r8),%rcx
mov    %r8d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1133 <uniquePaths+0x33>
xor    %ecx,%ecx
jmp    1174 <uniquePaths+0x74>
mov    %r8d,%edx
and    $0xfffffffc,%edx
lea    -0x80(%rsp),%rbx
xor    %ecx,%ecx
movl   $0x1,(%rbx)
movl   $0x1,0x190(%rbx)
movl   $0x1,0x320(%rbx)
movl   $0x1,0x4b0(%rbx)
add    $0x4,%rcx
add    $0x640,%rbx
cmp    %rcx,%rdx
jne    1140 <uniquePaths+0x40>
test   %rax,%rax
je     11a3 <uniquePaths+0xa3>
imul   $0x190,%rcx,%rcx
add    %rsp,%rcx
add    $0xffffffffffffff80,%rcx
imul   $0x190,%rax,%rax
xor    %edx,%edx
movl   $0x1,(%rcx,%rdx,1)
add    $0x190,%rdx
cmp    %rdx,%rax
jne    1190 <uniquePaths+0x90>
mov    %esi,%r9d
test   %esi,%esi
jle    12a1 <uniquePaths+0x1a1>
cmp    $0x8,%esi
jae    11ba <uniquePaths+0xba>
xor    %edx,%edx
jmp    1290 <uniquePaths+0x190>
mov    %r9d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rax
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x7,%r10d
cmp    $0x38,%rax
jae    11e0 <uniquePaths+0xe0>
xor    %eax,%eax
jmp    1249 <uniquePaths+0x149>
and    $0xfffffffffffffff8,%rcx
xor    %eax,%eax
movaps 0xe13(%rip),%xmm0
nopl   (%rax)
movaps %xmm0,-0x80(%rsp,%rax,4)
movaps %xmm0,-0x70(%rsp,%rax,4)
movaps %xmm0,-0x60(%rsp,%rax,4)
movaps %xmm0,-0x50(%rsp,%rax,4)
movaps %xmm0,-0x40(%rsp,%rax,4)
movaps %xmm0,-0x30(%rsp,%rax,4)
movaps %xmm0,-0x20(%rsp,%rax,4)
movaps %xmm0,-0x10(%rsp,%rax,4)
movaps %xmm0,(%rsp,%rax,4)
movaps %xmm0,0x10(%rsp,%rax,4)
movaps %xmm0,0x20(%rsp,%rax,4)
movaps %xmm0,0x30(%rsp,%rax,4)
movaps %xmm0,0x40(%rsp,%rax,4)
movaps %xmm0,0x50(%rsp,%rax,4)
movaps %xmm0,0x60(%rsp,%rax,4)
movaps %xmm0,0x70(%rsp,%rax,4)
add    $0x40,%rax
add    $0xfffffffffffffff8,%rcx
jne    11f0 <uniquePaths+0xf0>
test   %r10,%r10
je     1282 <uniquePaths+0x182>
lea    (%rsp,%rax,4),%rax
add    $0xffffffffffffff90,%rax
shl    $0x5,%r10
xor    %ecx,%ecx
movaps 0xd9d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps %xmm0,-0x10(%rax,%rcx,1)
movaps %xmm0,(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r10
jne    1270 <uniquePaths+0x170>
cmp    %r9,%rdx
je     12a1 <uniquePaths+0x1a1>
nopw   0x0(%rax,%rax,1)
movl   $0x1,-0x80(%rsp,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r9
jne    1290 <uniquePaths+0x190>
cmp    $0x2,%edi
jl     134a <uniquePaths+0x24a>
add    $0xffffffffffffffff,%r9
mov    %r9,%r14
and    $0xfffffffffffffffe,%r14
lea    0x118(%rsp),%rax
mov    $0x1,%r11d
jmp    12df <uniquePaths+0x1df>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r11
add    $0x190,%rax
cmp    %r8,%r11
je     134a <uniquePaths+0x24a>
cmp    $0x2,%esi
jl     12d0 <uniquePaths+0x1d0>
imul   $0x190,%r11,%r10
mov    -0x80(%rsp,%r10,1),%ecx
mov    $0x1,%ebx
cmp    $0x2,%esi
je     1322 <uniquePaths+0x222>
xor    %ebx,%ebx
nopl   0x0(%rax)
add    -0x194(%rax,%rbx,4),%ecx
mov    %ecx,-0x4(%rax,%rbx,4)
add    -0x190(%rax,%rbx,4),%ecx
mov    %ecx,(%rax,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%r14
jne    1300 <uniquePaths+0x200>
add    $0x1,%rbx
test   $0x1,%r9b
je     12d0 <uniquePaths+0x1d0>
lea    -0x1(%r11),%rdx
imul   $0x190,%rdx,%rdx
add    %rsp,%rdx
add    $0xffffffffffffff80,%rdx
add    (%rdx,%rbx,4),%ecx
lea    (%rsp,%r10,1),%rdx
add    $0xffffffffffffff80,%rdx
mov    %ecx,(%rdx,%rbx,4)
jmp    12d0 <uniquePaths+0x1d0>
add    $0xffffffff,%edi
add    $0xffffffff,%esi
imul   $0x190,%rdi,%rax
add    %rsp,%rax
add    $0xffffffffffffff80,%rax
mov    (%rax,%rsi,4),%eax
add    $0x9bc8,%rsp
pop    %rbx
pop    %r14
ret

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

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