#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 /*<<< orphan*/ scanf(char *, int *);
int main() {
  int a[5][5], i, j, k, even = 0, odd = 0, big = 0, small = 0, row, column;
  printf("Enter the array elements");
  for (i = 0; i < 5; i++) {
    for (j = 0; j < 5; j++) {
      scanf("%d", &a[i][j]);
      if (a[i][j] % 2 == 0) {
        even++;
      } else {
        odd++;
      }
    }
  }
  for (i = 0; i < 5; i++) {
    for (j = 0; j < 5; j++) {
      if (a[i][j] > big) {
        big = a[i][j];
      }
      if (a[i][j] < small) {
        small = a[i][j];
      }
    }
  }
  for (i = 0; i < 5; i++) {
    row = 0;
    printf("\n\n");
    for (j = 0; j < 5; j++) {
      row += a[i][j];
      printf("%d\t", a[i][j]);
    }
    printf("\tSum:%d\n", row);
  }
  printf("-------------------------------------\n");
  for (j = 0; j < 5; j++) {
    column = 0;
    for (i = 0; i < 5; i++) {
      column += a[i][j];
    }
    printf("Sum:%d\t", column);
  }
  printf(
      "\n\nThere are %d even nos and  %d odd nos.\n%d is big and %d is small\n",
      even, odd, big, small);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x80(%rbp)
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
lea    0xea2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x74(%rbp)
cmpl   $0x5,-0x74(%rbp)
jge    1217 <main+0xf7>
movl   $0x0,-0x78(%rbp)
cmpl   $0x5,-0x78(%rbp)
jge    1204 <main+0xe4>
movslq -0x74(%rbp),%rax
lea    -0x70(%rbp),%rsi
imul   $0x14,%rax,%rax
add    %rax,%rsi
movslq -0x78(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe71(%rip),%rdi
call   1040 <scanf@plt>
movslq -0x74(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    11e2 <main+0xc2>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    11f1 <main+0xd1>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    11f6 <main+0xd6>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    117d <main+0x5d>
jmp    1209 <main+0xe9>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    116c <main+0x4c>
movl   $0x0,-0x74(%rbp)
cmpl   $0x5,-0x74(%rbp)
jge    12db <main+0x1bb>
movl   $0x0,-0x78(%rbp)
cmpl   $0x5,-0x78(%rbp)
jge    12c8 <main+0x1a8>
movslq -0x74(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x88(%rbp),%eax
jle    1277 <main+0x157>
movslq -0x74(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
movslq -0x74(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x8c(%rbp),%eax
jge    12b5 <main+0x195>
movslq -0x74(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
jmp    12ba <main+0x19a>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    122f <main+0x10f>
jmp    12cd <main+0x1ad>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    121e <main+0xfe>
movl   $0x0,-0x74(%rbp)
cmpl   $0x5,-0x74(%rbp)
jge    138b <main+0x26b>
movl   $0x0,-0x90(%rbp)
lea    0xd1f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x78(%rbp)
cmpl   $0x5,-0x78(%rbp)
jge    1369 <main+0x249>
movslq -0x74(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x90(%rbp)
movslq -0x74(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xcff(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    130b <main+0x1eb>
mov    -0x90(%rbp),%esi
lea    0xca9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12e2 <main+0x1c2>
lea    0xc96(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x78(%rbp)
cmpl   $0x5,-0x78(%rbp)
jge    1417 <main+0x2f7>
movl   $0x0,-0x94(%rbp)
movl   $0x0,-0x74(%rbp)
cmpl   $0x5,-0x74(%rbp)
jge    13f5 <main+0x2d5>
movslq -0x74(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    13bb <main+0x29b>
mov    -0x94(%rbp),%esi
lea    0xc4d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    13a0 <main+0x280>
mov    -0x80(%rbp),%esi
mov    -0x84(%rbp),%edx
mov    -0x88(%rbp),%ecx
mov    -0x8c(%rbp),%r8d
lea    0xc23(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
lea    0xebb(%rip),%rdi
xor    %r13d,%r13d
xor    %eax,%eax
call   1040 <printf@plt>
xor    %ebp,%ebp
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rsp,%r13,1),%rsi
lea    0xeae(%rip),%r12
mov    %r12,%rdi
call   1050 <scanf@plt>
mov    (%rsp,%r13,1),%ebx
and    $0x1,%ebx
mov    %ebx,%r14d
xor    $0x1,%r14d
add    %r15d,%r14d
add    %ebp,%ebx
lea    (%rsp,%r13,1),%rsi
add    $0x4,%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
mov    0x4(%rsp,%r13,1),%ebp
and    $0x1,%ebp
mov    %ebp,%r15d
xor    $0x1,%r15d
add    %r14d,%r15d
add    %ebx,%ebp
lea    (%rsp,%r13,1),%rsi
add    $0x8,%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
mov    0x8(%rsp,%r13,1),%ebx
and    $0x1,%ebx
mov    %ebx,%r14d
xor    $0x1,%r14d
add    %r15d,%r14d
add    %ebp,%ebx
lea    (%rsp,%r13,1),%rsi
add    $0xc,%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
mov    0xc(%rsp,%r13,1),%ebp
and    $0x1,%ebp
mov    %ebp,%r15d
xor    $0x1,%r15d
add    %r14d,%r15d
add    %ebx,%ebp
lea    (%rsp,%r13,1),%rsi
add    $0x10,%rsi
mov    %r12,%rdi
call   1050 <scanf@plt>
mov    0x10(%rsp,%r13,1),%ecx
and    $0x1,%ecx
mov    %ecx,%eax
xor    $0x1,%eax
add    %r15d,%eax
mov    %eax,%r15d
add    %ebp,%ecx
mov    %ecx,%ebp
add    $0x14,%r13
cmp    $0x64,%r13
jne    1160 <main+0x30>
mov    (%rsp),%eax
mov    0x4(%rsp),%ecx
test   %eax,%eax
mov    $0x0,%r14d
cmovns %eax,%r14d
mov    %eax,%ebx
sar    $0x1f,%ebx
and    %eax,%ebx
cmp    %r14d,%ecx
cmovg  %ecx,%r14d
cmp    %ebx,%ecx
cmovl  %ecx,%ebx
mov    0x8(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0xc(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x10(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x14(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x18(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x1c(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x20(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x24(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x28(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x2c(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x30(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x34(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x38(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x3c(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x40(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x44(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x48(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x4c(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x50(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x54(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x58(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x5c(%rsp),%eax
cmp    %r14d,%eax
cmovg  %eax,%r14d
cmp    %ebx,%eax
cmovl  %eax,%ebx
mov    0x60(%rsp),%eax
mov    %eax,0x74(%rsp)
lea    0xc67(%rip),%rdi
call   1030 <puts@plt>
mov    (%rsp),%r13d
mov    %ebp,0x70(%rsp)
lea    0xc59(%rip),%rbp
mov    %rbp,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xbf4(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xbea(%rip),%rdi
call   1030 <puts@plt>
mov    0x14(%rsp),%r13d
mov    %rbp,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xb81(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xb77(%rip),%r12
mov    %r12,%rdi
call   1030 <puts@plt>
mov    0x28(%rsp),%r13d
mov    %rbp,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x34(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xb0b(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
call   1030 <puts@plt>
mov    0x3c(%rsp),%r13d
mov    %rbp,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x40(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x44(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x48(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4c(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xa9c(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
call   1030 <puts@plt>
mov    0x50(%rsp),%r13d
mov    %rbp,%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x54(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x58(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x5c(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x60(%rsp),%esi
add    %esi,%r13d
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xa2d(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x74(%rsp),%r13d
cmp    %r14d,%r13d
cmovg  %r13d,%r14d
lea    0xa65(%rip),%rdi
call   1030 <puts@plt>
mov    0x14(%rsp),%esi
add    (%rsp),%esi
add    0x28(%rsp),%esi
add    0x3c(%rsp),%esi
add    0x50(%rsp),%esi
lea    0x9fa(%rip),%rbp
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%esi
add    0x4(%rsp),%esi
add    0x2c(%rsp),%esi
add    0x40(%rsp),%esi
add    0x54(%rsp),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp),%esi
add    0x8(%rsp),%esi
add    0x30(%rsp),%esi
add    0x44(%rsp),%esi
add    0x58(%rsp),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%esi
add    0xc(%rsp),%esi
add    0x34(%rsp),%esi
add    0x48(%rsp),%esi
add    0x5c(%rsp),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%esi
add    0x10(%rsp),%esi
add    0x38(%rsp),%esi
add    0x4c(%rsp),%esi
add    0x60(%rsp),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cmp    %ebx,%r13d
cmovl  %r13d,%ebx
lea    0x972(%rip),%rdi
mov    %r15d,%esi
mov    0x70(%rsp),%edx
mov    %r14d,%ecx
mov    %ebx,%r8d
xor    %eax,%eax
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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