#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 count = 0, m, n, process, temp, resource;
  int allocation_table[5] = {0, 0, 0, 0, 0};
  int available[5], current[5][5], maximum_claim[5][5];
  int maximum_resources[5], running[5], safe_state = 0;
  printf("\nEnter The Total Number Of Processes:\t");
  scanf("%d", &process);
  for (m = 0; m < process; m++) {
    running[m] = 1;
    count++;
  }
  printf("\nEnter The Total Number Of Resources To Allocate:\t");
  scanf("%d", &resource);
  printf("\nEnter The Claim Vector:\t");
  for (m = 0; m < resource; m++) {
    scanf("%d", &maximum_resources[m]);
  }
  printf("\nEnter Allocated Resource Table:\n");
  for (m = 0; m < process; m++) {
    for (n = 0; n < resource; n++) {
      scanf("%d", &current[m][n]);
    }
  }
  printf("\nEnter The Maximum Claim Table:\n");
  for (m = 0; m < process; m++) {
    for (n = 0; n < resource; n++) {
      scanf("%d", &maximum_claim[m][n]);
    }
  }
  printf("\nThe Claim Vector \n");
  for (m = 0; m < resource; m++) {
    printf("\t%d ", maximum_resources[m]);
  }
  printf("\n The Allocated Resource Table\n");
  for (m = 0; m < process; m++) {
    for (n = 0; n < resource; n++) {
      printf("\t%d", current[m][n]);
    }
    printf("\n");
  }
  printf("\nThe Maximum Claim Table \n");
  for (m = 0; m < process; m++) {
    for (n = 0; n < resource; n++) {
      printf("\t%d", maximum_claim[m][n]);
    }
    printf("\n");
  }
  for (m = 0; m < process; m++) {
    for (n = 0; n < resource; n++) {
      allocation_table[n] = allocation_table[n] + current[m][n];
    }
  }
  printf("\nAllocated Resources \n");
  for (m = 0; m < resource; m++) {
    printf("\t%d", allocation_table[m]);
  }
  for (m = 0; m < resource; m++) {
    available[m] = maximum_resources[m] - allocation_table[m];
  }
  printf("\nAvailable Resources:");
  for (m = 0; m < resource; m++) {
    printf("\t%d", available[m]);
  }
  printf("\n");
  while (count != 0) {
    safe_state = 0;
    for (m = 0; m < process; m++) {
      if (running[m]) {
        temp = 1;
        for (n = 0; n < resource; n++) {
          if (maximum_claim[m][n] - current[m][n] > available[n]) {
            temp = 0;
            break;
          }
        }
        if (temp) {
          printf("\nProcess %d Is In Execution \n", m + 1);
          running[m] = 0;
          count--;
          safe_state = 1;
          for (n = 0; n < resource; n++) {
            available[n] = available[n] + current[m][n];
          }
          break;
        }
      }
    }
    if (!safe_state) {
      printf("\nThe Processes Are In An Unsafe State \n");
      break;
    } else {
      printf("\nThe Process Is In A Safe State \n");
      printf("\nAvailable Vector\n");
      for (m = 0; m < resource; m++) {
        printf("\t%d", available[m]);
      }
      printf("\n");
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
lea    -0x30(%rbp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   1040 <memset@plt>
movl   $0x0,-0x174(%rbp)
lea    0xe96(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf79(%rip),%rdi
lea    -0x14(%rbp),%rsi
call   1050 <scanf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11ba <main+0x8a>
movslq -0xc(%rbp),%rax
movl   $0x1,-0x170(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1188 <main+0x58>
lea    0xe66(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf22(%rip),%rdi
lea    -0x1c(%rbp),%rsi
call   1050 <scanf@plt>
lea    0xe7b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1225 <main+0xf5>
movslq -0xc(%rbp),%rax
lea    -0x150(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xedf(%rip),%rdi
call   1050 <scanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11ed <main+0xbd>
lea    0xe48(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a3 <main+0x173>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1290 <main+0x160>
movslq -0xc(%rbp),%rax
lea    -0xc0(%rbp),%rsi
imul   $0x14,%rax,%rax
add    %rax,%rsi
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe74(%rip),%rdi
call   1050 <scanf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    124d <main+0x11d>
jmp    1295 <main+0x165>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    123a <main+0x10a>
lea    0xdec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1321 <main+0x1f1>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    130e <main+0x1de>
movslq -0xc(%rbp),%rax
lea    -0x130(%rbp),%rsi
imul   $0x14,%rax,%rax
add    %rax,%rsi
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xdf6(%rip),%rdi
call   1050 <scanf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12cb <main+0x19b>
jmp    1313 <main+0x1e3>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12b8 <main+0x188>
lea    0xd8f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1369 <main+0x239>
movslq -0xc(%rbp),%rax
mov    -0x150(%rbp,%rax,4),%esi
lea    0xd77(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1336 <main+0x206>
lea    0xd60(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13ee <main+0x2be>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13d2 <main+0x2a2>
movslq -0xc(%rbp),%rcx
lea    -0xc0(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xd33(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1391 <main+0x261>
lea    0xd34(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    137e <main+0x24e>
lea    0xcff(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1473 <main+0x343>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1457 <main+0x327>
movslq -0xc(%rbp),%rcx
lea    -0x130(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xcae(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1416 <main+0x2e6>
lea    0xcaf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1403 <main+0x2d3>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14e3 <main+0x3b3>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14d0 <main+0x3a0>
movslq -0x10(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%ecx
movslq -0xc(%rbp),%rdx
lea    -0xc0(%rbp),%rax
imul   $0x14,%rdx,%rdx
add    %rdx,%rax
movslq -0x10(%rbp),%rdx
add    (%rax,%rdx,4),%ecx
movslq -0x10(%rbp),%rax
mov    %ecx,-0x30(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    148d <main+0x35d>
jmp    14d5 <main+0x3a5>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    147a <main+0x34a>
lea    0xc25(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1528 <main+0x3f8>
movslq -0xc(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%esi
lea    0xbdd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14f8 <main+0x3c8>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1564 <main+0x434>
movslq -0xc(%rbp),%rax
mov    -0x150(%rbp,%rax,4),%ecx
movslq -0xc(%rbp),%rax
sub    -0x30(%rbp,%rax,4),%ecx
movslq -0xc(%rbp),%rax
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    152f <main+0x3ff>
lea    0xbbb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15a9 <main+0x479>
movslq -0xc(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%esi
lea    0xb5c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1579 <main+0x449>
lea    0xb5d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0x0,-0x8(%rbp)
je     1796 <main+0x666>
movl   $0x0,-0x174(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1710 <main+0x5e0>
movslq -0xc(%rbp),%rax
cmpl   $0x0,-0x170(%rbp,%rax,4)
je     16fd <main+0x5cd>
movl   $0x1,-0x18(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1669 <main+0x539>
movslq -0xc(%rbp),%rcx
lea    -0x130(%rbp),%rax
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
movslq -0xc(%rbp),%rdx
lea    -0xc0(%rbp),%rcx
imul   $0x14,%rdx,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
movslq -0x10(%rbp),%rcx
cmp    -0x50(%rbp,%rcx,4),%eax
jle    1656 <main+0x526>
movl   $0x0,-0x18(%rbp)
jmp    1669 <main+0x539>
jmp    165b <main+0x52b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    15fe <main+0x4ce>
cmpl   $0x0,-0x18(%rbp)
je     16f8 <main+0x5c8>
mov    -0xc(%rbp),%esi
add    $0x1,%esi
lea    0xabc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movslq -0xc(%rbp),%rax
movl   $0x0,-0x170(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
movl   $0x1,-0x174(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16f3 <main+0x5c3>
movslq -0x10(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%ecx
movslq -0xc(%rbp),%rdx
lea    -0xc0(%rbp),%rax
imul   $0x14,%rdx,%rdx
add    %rdx,%rax
movslq -0x10(%rbp),%rdx
add    (%rax,%rdx,4),%ecx
movslq -0x10(%rbp),%rax
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    16b0 <main+0x580>
jmp    1710 <main+0x5e0>
jmp    16fd <main+0x5cd>
jmp    1702 <main+0x5d2>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    15d2 <main+0x4a2>
cmpl   $0x0,-0x174(%rbp)
jne    1730 <main+0x600>
lea    0xa36(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1796 <main+0x666>
lea    0xa4b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xa5f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1783 <main+0x653>
movslq -0xc(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%esi
lea    0x982(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1753 <main+0x623>
lea    0x983(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    15b7 <main+0x487>
xor    %eax,%eax
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
pxor   %xmm0,%xmm0
movdqa %xmm0,0x30(%rsp)
movl   $0x0,0x40(%rsp)
lea    0xea6(%rip),%rdi
xor    %r13d,%r13d
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xf0f(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1060 <scanf@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    12c4 <main+0x184>
cmp    $0x8,%eax
jae    119d <main+0x5d>
xor    %ecx,%ecx
jmp    12b0 <main+0x170>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x7,%edx
cmp    $0x38,%rdi
jae    11c3 <main+0x83>
xor    %edi,%edi
jmp    1275 <main+0x135>
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
add    $0xfffffffffffffffa,%rdi
and    %rdi,%rsi
xor    %edi,%edi
movdqa 0xe22(%rip),%xmm0
xchg   %ax,%ax
movdqa %xmm0,0x50(%rsp,%rdi,4)
movdqa %xmm0,0x60(%rsp,%rdi,4)
movdqa %xmm0,0x70(%rsp,%rdi,4)
movdqa %xmm0,0x80(%rsp,%rdi,4)
movdqa %xmm0,0x90(%rsp,%rdi,4)
movdqa %xmm0,0xa0(%rsp,%rdi,4)
movdqa %xmm0,0xb0(%rsp,%rdi,4)
movdqa %xmm0,0xc0(%rsp,%rdi,4)
movdqa %xmm0,0xd0(%rsp,%rdi,4)
movdqa %xmm0,0xe0(%rsp,%rdi,4)
movdqa %xmm0,0xf0(%rsp,%rdi,4)
movdqa %xmm0,0x100(%rsp,%rdi,4)
movdqa %xmm0,0x110(%rsp,%rdi,4)
movdqa %xmm0,0x120(%rsp,%rdi,4)
movdqa %xmm0,0x130(%rsp,%rdi,4)
movdqa %xmm0,0x140(%rsp,%rdi,4)
add    $0x40,%rdi
add    $0xfffffffffffffff8,%rsi
jne    11e0 <main+0xa0>
test   %rdx,%rdx
je     12a4 <main+0x164>
lea    (%rsp,%rdi,4),%rsi
add    $0x60,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xd70(%rip),%xmm0
movdqa %xmm0,-0x10(%rsi,%rdi,1)
movdqa %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1290 <main+0x150>
cmp    %rax,%rcx
je     12c1 <main+0x181>
nopl   0x0(%rax)
movl   $0x1,0x50(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12b0 <main+0x170>
mov    %eax,%r13d
lea    0xd6c(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xdb1(%rip),%rdi
lea    0x8(%rsp),%rsi
call   1060 <scanf@plt>
lea    0xd80(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,0x8(%rsp)
jle    132d <main+0x1ed>
lea    0x70(%rsp),%rbx
xor    %ebp,%ebp
lea    0xd84(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %rbx,%rsi
call   1060 <scanf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
add    $0x4,%rbx
cmp    %rax,%rbp
jl     1310 <main+0x1d0>
lea    0xd8d(%rip),%rdi
call   1040 <puts@plt>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jle    13a3 <main+0x263>
lea    0x90(%rsp),%r15
mov    0x8(%rsp),%eax
xor    %r12d,%r12d
lea    0xd33(%rip),%r14
jmp    1370 <main+0x230>
nopl   0x0(%rax)
add    $0x1,%r12
movslq %ecx,%rdx
add    $0x14,%r15
cmp    %rdx,%r12
jge    13a3 <main+0x263>
test   %eax,%eax
jle    1360 <main+0x220>
mov    %r15,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %r14,%rdi
mov    %rbx,%rsi
call   1060 <scanf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
add    $0x4,%rbx
cmp    %rax,%rbp
jl     1380 <main+0x240>
mov    0xc(%rsp),%ecx
jmp    1360 <main+0x220>
lea    0xd38(%rip),%rdi
call   1040 <puts@plt>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jle    1413 <main+0x2d3>
lea    0x100(%rsp),%r15
mov    0x8(%rsp),%eax
xor    %r12d,%r12d
lea    0xcbd(%rip),%r14
jmp    13e0 <main+0x2a0>
nop
add    $0x1,%r12
movslq %ecx,%rdx
add    $0x14,%r15
cmp    %rdx,%r12
jge    1413 <main+0x2d3>
test   %eax,%eax
jle    13d0 <main+0x290>
mov    %r15,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %r14,%rdi
mov    %rbx,%rsi
call   1060 <scanf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
add    $0x4,%rbx
cmp    %rax,%rbp
jl     13f0 <main+0x2b0>
mov    0xc(%rsp),%ecx
jmp    13d0 <main+0x290>
lea    0xce8(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x8(%rsp)
jle    144c <main+0x30c>
lea    0xc57(%rip),%rbx
xor    %ebp,%ebp
nop
mov    0x70(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
cmp    %rax,%rbp
jl     1430 <main+0x2f0>
lea    0xcc2(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0xc(%rsp)
jle    14ce <main+0x38e>
lea    0x90(%rsp),%rbp
lea    0xc1b(%rip),%r15
xor    %r14d,%r14d
jmp    149c <main+0x35c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
movslq 0xc(%rsp),%rax
add    $0x14,%rbp
cmp    %rax,%r14
jge    14ce <main+0x38e>
cmpl   $0x0,0x8(%rsp)
jle    1480 <main+0x340>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%rbp,%rbx,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbx
movslq 0x8(%rsp),%rax
cmp    %rax,%rbx
jl     14b0 <main+0x370>
jmp    1480 <main+0x340>
lea    0xc5f(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0xc(%rsp)
jle    169f <main+0x55f>
lea    0x100(%rsp),%rbp
lea    0xb95(%rip),%r15
xor    %r14d,%r14d
jmp    151c <main+0x3dc>
nopl   0x0(%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
movslq 0xc(%rsp),%rax
add    $0x14,%rbp
cmp    %rax,%r14
jge    154e <main+0x40e>
cmpl   $0x0,0x8(%rsp)
jle    1500 <main+0x3c0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%rbp,%rbx,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbx
movslq 0x8(%rsp),%rax
cmp    %rax,%rbx
jl     1530 <main+0x3f0>
jmp    1500 <main+0x3c0>
mov    %eax,%eax
test   %eax,%eax
jle    169f <main+0x55f>
mov    0x8(%rsp),%ecx
mov    %ecx,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10,%r8
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
and    %rdx,%r8
lea    0xc0(%rsp),%rbp
lea    0x90(%rsp),%rbx
xor    %esi,%esi
jmp    15b5 <main+0x475>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rsi
add    $0x14,%rbp
add    $0x14,%rbx
cmp    %rax,%rsi
je     169f <main+0x55f>
test   %ecx,%ecx
jle    15a0 <main+0x460>
cmp    $0x8,%ecx
jae    15d0 <main+0x490>
xor    %edx,%edx
jmp    1680 <main+0x540>
cs nopw 0x0(%rax,%rax,1)
nop
test   %r9,%r9
je     1695 <main+0x555>
mov    %r8,%rdx
xor    %edi,%edi
xchg   %ax,%ax
movdqu -0x30(%rbp,%rdi,4),%xmm0
movdqu -0x20(%rbp,%rdi,4),%xmm1
paddd  0x30(%rsp,%rdi,4),%xmm0
paddd  0x40(%rsp,%rdi,4),%xmm1
movdqa %xmm0,0x30(%rsp,%rdi,4)
movdqa %xmm1,0x40(%rsp,%rdi,4)
movdqu -0x10(%rbp,%rdi,4),%xmm0
movdqu 0x0(%rbp,%rdi,4),%xmm1
paddd  0x50(%rsp,%rdi,4),%xmm0
paddd  0x60(%rsp,%rdi,4),%xmm1
movdqa %xmm0,0x50(%rsp,%rdi,4)
movdqa %xmm1,0x60(%rsp,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rdx
jne    15e0 <main+0x4a0>
test   $0x1,%r10b
je     166a <main+0x52a>
lea    (%rsi,%rsi,4),%rdx
lea    (%rsp,%rdx,4),%rdx
add    $0x90,%rdx
movdqu (%rdx,%rdi,4),%xmm0
movdqu 0x10(%rdx,%rdi,4),%xmm1
paddd  0x30(%rsp,%rdi,4),%xmm0
paddd  0x40(%rsp,%rdi,4),%xmm1
movdqa %xmm0,0x30(%rsp,%rdi,4)
movdqa %xmm1,0x40(%rsp,%rdi,4)
mov    %r11,%rdx
cmp    %rcx,%r11
je     15a0 <main+0x460>
cs nopw 0x0(%rax,%rax,1)
mov    (%rbx,%rdx,4),%edi
add    %edi,0x30(%rsp,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1680 <main+0x540>
jmp    15a0 <main+0x460>
xor    %edi,%edi
test   $0x1,%r10b
jne    1638 <main+0x4f8>
jmp    166a <main+0x52a>
lea    0xaa8(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x8(%rsp)
jle    17d5 <main+0x695>
lea    0x9cc(%rip),%rbx
xor    %ebp,%ebp
nop
mov    0x30(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
cmp    %rax,%rbp
jl     16c0 <main+0x580>
mov    %eax,%eax
test   %eax,%eax
jle    17d5 <main+0x695>
cmp    $0x8,%eax
jae    16f2 <main+0x5b2>
xor    %ecx,%ecx
jmp    17c0 <main+0x680>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1a5e <main+0x91e>
mov    %rsi,%rdi
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
and    %rdx,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa 0x70(%rsp,%rdx,4),%xmm0
movdqa 0x80(%rsp,%rdx,4),%xmm1
movdqa 0x90(%rsp,%rdx,4),%xmm2
movdqa 0xa0(%rsp,%rdx,4),%xmm3
psubd  0x30(%rsp,%rdx,4),%xmm0
psubd  0x40(%rsp,%rdx,4),%xmm1
movdqa %xmm0,0x10(%rsp,%rdx,4)
movdqa %xmm1,0x20(%rsp,%rdx,4)
psubd  0x50(%rsp,%rdx,4),%xmm2
psubd  0x60(%rsp,%rdx,4),%xmm3
movdqa %xmm2,0x30(%rsp,%rdx,4)
movdqa %xmm3,0x40(%rsp,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1730 <main+0x5f0>
test   $0x1,%sil
je     17b8 <main+0x678>
movdqa 0x70(%rsp,%rdx,4),%xmm0
movdqa 0x80(%rsp,%rdx,4),%xmm1
psubd  0x30(%rsp,%rdx,4),%xmm0
psubd  0x40(%rsp,%rdx,4),%xmm1
movdqa %xmm0,0x10(%rsp,%rdx,4)
movdqa %xmm1,0x20(%rsp,%rdx,4)
cmp    %rax,%rcx
je     17d5 <main+0x695>
nopl   (%rax)
mov    0x70(%rsp,%rcx,4),%edx
sub    0x30(%rsp,%rcx,4),%edx
mov    %edx,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    17c0 <main+0x680>
lea    0x8b1(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,0x8(%rsp)
jle    181c <main+0x6dc>
lea    0x898(%rip),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x10(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
cmp    %rax,%rbp
jl     1800 <main+0x6c0>
mov    $0xa,%edi
call   1030 <putchar@plt>
test   %r13d,%r13d
je     1a4a <main+0x90a>
lea    0x90(%rsp),%r15
lea    0x84b(%rip),%rbx
jmp    1853 <main+0x713>
mov    $0xa,%edi
call   1030 <putchar@plt>
test   %r13d,%r13d
je     1a4a <main+0x90a>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    1a3e <main+0x8fe>
mov    0x8(%rsp),%ecx
mov    $0x1,%r12b
mov    %r15,%r14
lea    0x100(%rsp),%rdx
xor    %esi,%esi
jmp    189c <main+0x75c>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
cmp    %rax,%rsi
setb   %r12b
add    $0x14,%rdx
add    $0x14,%r14
cmp    %rax,%rsi
je     1a3e <main+0x8fe>
cmpl   $0x0,0x50(%rsp,%rsi,4)
je     1880 <main+0x740>
test   %ecx,%ecx
jle    18c6 <main+0x786>
xor    %edi,%edi
nopl   0x0(%rax)
mov    (%rdx,%rdi,4),%ebp
sub    (%r14,%rdi,4),%ebp
cmp    0x10(%rsp,%rdi,4),%ebp
jg     1880 <main+0x740>
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    18b0 <main+0x770>
mov    %esi,%ebp
add    $0x1,%esi
lea    0x7d1(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
movl   $0x0,0x50(%rsp,%rbp,4)
mov    0x8(%rsp),%eax
test   %eax,%eax
jle    19e1 <main+0x8a1>
cmp    $0x8,%eax
jae    1900 <main+0x7c0>
xor    %ecx,%ecx
jmp    19d0 <main+0x890>
nopl   0x0(%rax)
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1a31 <main+0x8f1>
mov    %rdx,%rdi
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
and    %rsi,%rdi
xor    %esi,%esi
nop
movdqu (%r14,%rsi,4),%xmm0
movdqu 0x10(%r14,%rsi,4),%xmm1
paddd  0x10(%rsp,%rsi,4),%xmm0
paddd  0x20(%rsp,%rsi,4),%xmm1
movdqa %xmm0,0x10(%rsp,%rsi,4)
movdqa %xmm1,0x20(%rsp,%rsi,4)
movdqu 0x20(%r14,%rsi,4),%xmm0
movdqu 0x30(%r14,%rsi,4),%xmm1
paddd  0x30(%rsp,%rsi,4),%xmm0
paddd  0x40(%rsp,%rsi,4),%xmm1
movdqa %xmm0,0x30(%rsp,%rsi,4)
movdqa %xmm1,0x40(%rsp,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1930 <main+0x7f0>
test   $0x1,%dl
je     19c0 <main+0x880>
lea    0x0(,%rbp,4),%rdx
add    %rbp,%rdx
lea    0x90(%rsp,%rdx,4),%rdx
movdqu (%rdx,%rsi,4),%xmm0
movdqu 0x10(%rdx,%rsi,4),%xmm1
paddd  0x10(%rsp,%rsi,4),%xmm0
paddd  0x20(%rsp,%rsi,4),%xmm1
movdqa %xmm0,0x10(%rsp,%rsi,4)
movdqa %xmm1,0x20(%rsp,%rsi,4)
cmp    %rax,%rcx
je     19e1 <main+0x8a1>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r14,%rcx,4),%edx
add    %edx,0x10(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    19d0 <main+0x890>
test   $0x1,%r12b
je     1a3e <main+0x8fe>
add    $0xffffffff,%r13d
lea    0x799(%rip),%rdi
call   1040 <puts@plt>
lea    0x7ae(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x8(%rsp)
jle    1840 <main+0x700>
xor    %ebp,%ebp
mov    0x10(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
cmp    %rax,%rbp
jl     1a10 <main+0x8d0>
jmp    1840 <main+0x700>
xor    %esi,%esi
test   $0x1,%dl
jne    198a <main+0x84a>
jmp    19c0 <main+0x880>
lea    0x71f(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    1791 <main+0x651>
jmp    17b8 <main+0x678>

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

LLVM IR (-O2):
@.str = [39 x i8] c"\0AEnter The Total Number Of Processes:\09\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [51 x i8] c"\0AEnter The Total Number Of Resources To Allocate:\09\00"
@.str.3 = [26 x i8] c"\0AEnter The Claim Vector:\09\00"
@.str.7 = [5 x i8] c"\09%d \00"
@.str.9 = [4 x i8] c"\09%d\00"
@.str.13 = [22 x i8] c"\0AAvailable Resources:\00"
@.str.14 = [30 x i8] c"\0AProcess %d Is In Execution \0A\00"
@str = [33 x i8] c"\0AEnter Allocated Resource Table:\00"
@str.18 = [32 x i8] c"\0AEnter The Maximum Claim Table:\00"
@str.19 = [19 x i8] c"\0AThe Claim Vector \00"
@str.20 = [31 x i8] c"\0A The Allocated Resource Table\00"
@str.21 = [26 x i8] c"\0AThe Maximum Claim Table \00"
@str.22 = [22 x i8] c"\0AAllocated Resources \00"
@str.23 = [39 x i8] c"\0AThe Processes Are In An Unsafe State \00"
@str.24 = [33 x i8] c"\0AThe Process Is In A Safe State \00"
@str.25 = [18 x i8] c"\0AAvailable Vector\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca [5 x i32]
%4 = alloca [5 x i32]
%5 = alloca [5 x [5 x i32]]
%6 = alloca [5 x [5 x i32]]
%7 = alloca [5 x i32]
%8 = alloca [5 x i32]
%9 = bitcast i32* %1 to i8*
%10 = bitcast i32* %2 to i8*
%11 = bitcast [5 x i32]* %3 to i8*
%12 = bitcast [5 x i32]* %4 to i8*
%13 = bitcast [5 x [5 x i32]]* %5 to i8*
%14 = bitcast [5 x [5 x i32]]* %6 to i8*
%15 = bitcast [5 x i32]* %7 to i8*
%16 = bitcast [5 x i32]* %8 to i8*
%17 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0))
%18 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%19 = load i32, i32* %1
%20 = icmp sgt i32 %19, 0
br i1 %20, label %21, label %100
21: ; preds = %0
%22 = zext i32 %19 to i64
%23 = icmp ult i32 %19, 8
br i1 %23, label %93, label %24
24: ; preds = %21
%25 = and i64 %22, 4294967288
%26 = add nsw i64 %25, -8
%27 = lshr exact i64 %26, 3
%28 = add nuw nsw i64 %27, 1
%29 = and i64 %28, 7
%30 = icmp ult i64 %26, 56
br i1 %30, label %78, label %31
31: ; preds = %24
%32 = and i64 %28, 4611686018427387896
br label %33
33: ; preds = %33, %31
%34 = phi i64 [ 0, %31 ], [ %75, %33 ]
%35 = phi i64 [ 0, %31 ], [ %76, %33 ]
%36 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %34
%37 = bitcast i32* %36 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %37
%38 = getelementptr inbounds i32, i32* %36, i64 4
%39 = bitcast i32* %38 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %39
%40 = or i64 %34, 8
%41 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %40
%42 = bitcast i32* %41 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %42
%43 = getelementptr inbounds i32, i32* %41, i64 4
%44 = bitcast i32* %43 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %44
%45 = or i64 %34, 16
%46 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %45
%47 = bitcast i32* %46 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %47
%48 = getelementptr inbounds i32, i32* %46, i64 4
%49 = bitcast i32* %48 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %49
%50 = or i64 %34, 24
%51 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %50
%52 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %52
%53 = getelementptr inbounds i32, i32* %51, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %54
%55 = or i64 %34, 32
%56 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %55
%57 = bitcast i32* %56 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %57
%58 = getelementptr inbounds i32, i32* %56, i64 4
%59 = bitcast i32* %58 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %59
%60 = or i64 %34, 40
%61 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %60
%62 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %62
%63 = getelementptr inbounds i32, i32* %61, i64 4
%64 = bitcast i32* %63 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %64
%65 = or i64 %34, 48
%66 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %65
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %67
%68 = getelementptr inbounds i32, i32* %66, i64 4
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %69
%70 = or i64 %34, 56
%71 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %70
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %72
%73 = getelementptr inbounds i32, i32* %71, i64 4
%74 = bitcast i32* %73 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %74
%75 = add nuw i64 %34, 64
%76 = add nuw i64 %35, 8
%77 = icmp eq i64 %76, %32
br i1 %77, label %78, label %33
78: ; preds = %33, %24
%79 = phi i64 [ 0, %24 ], [ %75, %33 ]
%80 = icmp eq i64 %29, 0
br i1 %80, label %91, label %81
81: ; preds = %78, %81
%82 = phi i64 [ %88, %81 ], [ %79, %78 ]
%83 = phi i64 [ %89, %81 ], [ 0, %78 ]
%84 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %82
%85 = bitcast i32* %84 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %85
%86 = getelementptr inbounds i32, i32* %84, i64 4
%87 = bitcast i32* %86 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %87
%88 = add nuw i64 %82, 8
%89 = add i64 %83, 1
%90 = icmp eq i64 %89, %29
br i1 %90, label %91, label %81
91: ; preds = %81, %78
%92 = icmp eq i64 %25, %22
br i1 %92, label %100, label %93
93: ; preds = %21, %91
%94 = phi i64 [ 0, %21 ], [ %25, %91 ]
br label %95
95: ; preds = %93, %95
%96 = phi i64 [ %98, %95 ], [ %94, %93 ]
%97 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %96
store i32 1, i32* %97
%98 = add nuw nsw i64 %96, 1
%99 = icmp eq i64 %98, %22
br i1 %99, label %100, label %95
100: ; preds = %95, %91, %0
%101 = phi i32 [ 0, %0 ], [ %19, %91 ], [ %19, %95 ]
%102 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.2, i64 0, i64 0))
%103 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %2)
%104 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.3, i64 0, i64 0))
%105 = load i32, i32* %2
%106 = icmp sgt i32 %105, 0
br i1 %106, label %107, label %115
107: ; preds = %100, %107
%108 = phi i64 [ %111, %107 ], [ 0, %100 ]
%109 = getelementptr inbounds [5 x i32], [5 x i32]* %7, i64 0, i64 %108
%110 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %109)
%111 = add nuw nsw i64 %108, 1
%112 = load i32, i32* %2
%113 = sext i32 %112 to i64
%114 = icmp slt i64 %111, %113
br i1 %114, label %107, label %115
115: ; preds = %107, %100
%116 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str, i64 0, i64 0))
%117 = load i32, i32* %1
%118 = icmp sgt i32 %117, 0
br i1 %118, label %119, label %142
119: ; preds = %115
%120 = load i32, i32* %2
br label %121
121: ; preds = %119, %136
%122 = phi i32 [ %117, %119 ], [ %137, %136 ]
%123 = phi i32 [ %120, %119 ], [ %138, %136 ]
%124 = phi i64 [ 0, %119 ], [ %139, %136 ]
%125 = icmp sgt i32 %123, 0
br i1 %125, label %126, label %136
126: ; preds = %121, %126
%127 = phi i64 [ %130, %126 ], [ 0, %121 ]
%128 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %5, i64 0, i64 %124, i64 %127
%129 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %128)
%130 = add nuw nsw i64 %127, 1
%131 = load i32, i32* %2
%132 = sext i32 %131 to i64
%133 = icmp slt i64 %130, %132
br i1 %133, label %126, label %134
134: ; preds = %126
%135 = load i32, i32* %1
br label %136
136: ; preds = %134, %121
%137 = phi i32 [ %135, %134 ], [ %122, %121 ]
%138 = phi i32 [ %131, %134 ], [ %123, %121 ]
%139 = add nuw nsw i64 %124, 1
%140 = sext i32 %137 to i64
%141 = icmp slt i64 %139, %140
br i1 %141, label %121, label %142
142: ; preds = %136, %115
%143 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.18, i64 0, i64 0))
%144 = load i32, i32* %1
%145 = icmp sgt i32 %144, 0
br i1 %145, label %146, label %169
146: ; preds = %142
%147 = load i32, i32* %2
br label %148
148: ; preds = %146, %163
%149 = phi i32 [ %144, %146 ], [ %164, %163 ]
%150 = phi i32 [ %147, %146 ], [ %165, %163 ]
%151 = phi i64 [ 0, %146 ], [ %166, %163 ]
%152 = icmp sgt i32 %150, 0
br i1 %152, label %153, label %163
153: ; preds = %148, %153
%154 = phi i64 [ %157, %153 ], [ 0, %148 ]
%155 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %6, i64 0, i64 %151, i64 %154
%156 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %155)
%157 = add nuw nsw i64 %154, 1
%158 = load i32, i32* %2
%159 = sext i32 %158 to i64
%160 = icmp slt i64 %157, %159
br i1 %160, label %153, label %161
161: ; preds = %153
%162 = load i32, i32* %1
br label %163
163: ; preds = %161, %148
%164 = phi i32 [ %162, %161 ], [ %149, %148 ]
%165 = phi i32 [ %158, %161 ], [ %150, %148 ]
%166 = add nuw nsw i64 %151, 1
%167 = sext i32 %164 to i64
%168 = icmp slt i64 %166, %167
br i1 %168, label %148, label %169
169: ; preds = %163, %142
%170 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.19, i64 0, i64 0))
%171 = load i32, i32* %2
%172 = icmp sgt i32 %171, 0
br i1 %172, label %173, label %182
173: ; preds = %169, %173
%174 = phi i64 [ %178, %173 ], [ 0, %169 ]
%175 = getelementptr inbounds [5 x i32], [5 x i32]* %7, i64 0, i64 %174
%176 = load i32, i32* %175
%177 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0), i32 %176)
%178 = add nuw nsw i64 %174, 1
%179 = load i32, i32* %2
%180 = sext i32 %179 to i64
%181 = icmp slt i64 %178, %180
br i1 %181, label %173, label %182
182: ; preds = %173, %169
%183 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.20, i64 0, i64 0))
%184 = load i32, i32* %1
%185 = icmp sgt i32 %184, 0
br i1 %185, label %186, label %205
186: ; preds = %182, %199
%187 = phi i64 [ %201, %199 ], [ 0, %182 ]
%188 = load i32, i32* %2
%189 = icmp sgt i32 %188, 0
br i1 %189, label %190, label %199
190: ; preds = %186, %190
%191 = phi i64 [ %195, %190 ], [ 0, %186 ]
%192 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %5, i64 0, i64 %187, i64 %191
%193 = load i32, i32* %192
%194 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i32 %193)
%195 = add nuw nsw i64 %191, 1
%196 = load i32, i32* %2
%197 = sext i32 %196 to i64
%198 = icmp slt i64 %195, %197
br i1 %198, label %190, label %199
199: ; preds = %190, %186
%200 = call i32 @putchar(i32 10)
%201 = add nuw nsw i64 %187, 1
%202 = load i32, i32* %1
%203 = sext i32 %202 to i64
%204 = icmp slt i64 %201, %203
br i1 %204, label %186, label %205
205: ; preds = %199, %182
%206 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.21, i64 0, i64 0))
%207 = load i32, i32* %1
%208 = icmp sgt i32 %207, 0
br i1 %208, label %209, label %323
209: ; preds = %205, %240
%210 = phi i64 [ %242, %240 ], [ 0, %205 ]
%211 = load i32, i32* %2
%212 = icmp sgt i32 %211, 0
br i1 %212, label %231, label %240
213: ; preds = %240
%214 = icmp sgt i32 %243, 0
br i1 %214, label %215, label %323
215: ; preds = %213
%216 = load i32, i32* %2
%217 = icmp sgt i32 %216, 0
%218 = zext i32 %243 to i64
%219 = zext i32 %216 to i64
%220 = and i64 %219, 4294967288
%221 = add nsw i64 %220, -8
%222 = lshr exact i64 %221, 3
%223 = add nuw nsw i64 %222, 1
%224 = icmp ult i32 %216, 8
%225 = and i64 %219, 4294967288
%226 = and i64 %223, 1
%227 = icmp eq i64 %221, 0
%228 = and i64 %223, 4611686018427387902
%229 = icmp eq i64 %226, 0
%230 = icmp eq i64 %225, %219
br label %246
231: ; preds = %209, %231
%232 = phi i64 [ %236, %231 ], [ 0, %209 ]
%233 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %6, i64 0, i64 %210, i64 %232
%234 = load i32, i32* %233
%235 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i32 %234)
%236 = add nuw nsw i64 %232, 1
%237 = load i32, i32* %2
%238 = sext i32 %237 to i64
%239 = icmp slt i64 %236, %238
br i1 %239, label %231, label %240
240: ; preds = %231, %209
%241 = call i32 @putchar(i32 10)
%242 = add nuw nsw i64 %210, 1
%243 = load i32, i32* %1
%244 = sext i32 %243 to i64
%245 = icmp slt i64 %242, %244
br i1 %245, label %209, label %213
246: ; preds = %215, %320
%247 = phi i64 [ 0, %215 ], [ %321, %320 ]
br i1 %217, label %248, label %320
248: ; preds = %246
br i1 %224, label %309, label %249
249: ; preds = %248
br i1 %227, label %289, label %250
250: ; preds = %249, %250
%251 = phi i64 [ %286, %250 ], [ 0, %249 ]
%252 = phi i64 [ %287, %250 ], [ 0, %249 ]
%253 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %251
%254 = bitcast i32* %253 to <4 x i32>*
%255 = load <4 x i32>, <4 x i32>* %254
%256 = getelementptr inbounds i32, i32* %253, i64 4
%257 = bitcast i32* %256 to <4 x i32>*
%258 = load <4 x i32>, <4 x i32>* %257
%259 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %5, i64 0, i64 %247, i64 %251
%260 = bitcast i32* %259 to <4 x i32>*
%261 = load <4 x i32>, <4 x i32>* %260
%262 = getelementptr inbounds i32, i32* %259, i64 4
%263 = bitcast i32* %262 to <4 x i32>*
%264 = load <4 x i32>, <4 x i32>* %263
%265 = add nsw <4 x i32> %261, %255
%266 = add nsw <4 x i32> %264, %258
%267 = bitcast i32* %253 to <4 x i32>*
store <4 x i32> %265, <4 x i32>* %267
%268 = bitcast i32* %256 to <4 x i32>*
store <4 x i32> %266, <4 x i32>* %268
%269 = or i64 %251, 8
%270 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %269
%271 = bitcast i32* %270 to <4 x i32>*
%272 = load <4 x i32>, <4 x i32>* %271
%273 = getelementptr inbounds i32, i32* %270, i64 4
%274 = bitcast i32* %273 to <4 x i32>*
%275 = load <4 x i32>, <4 x i32>* %274
%276 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %5, i64 0, i64 %247, i64 %269
%277 = bitcast i32* %276 to <4 x i32>*
%278 = load <4 x i32>, <4 x i32>* %277
%279 = getelementptr inbounds i32, i32* %276, i64 4
%280 = bitcast i32* %279 to <4 x i32>*
%281 = load <4 x i32>, <4 x i32>* %280
%282 = add nsw <4 x i32> %278, %272
%283 = add nsw <4 x i32> %281, %275
%284 = bitcast i32* %270 to <4 x i32>*
store <4 x i32> %282, <4 x i32>* %284
%285 = bitcast i32* %273 to <4 x i32>*
store <4 x i32> %283, <4 x i32>* %285
%286 = add nuw i64 %251, 16
%287 = add i64 %252, 2
%288 = icmp eq i64 %287, %228
br i1 %288, label %289, label %250
289: ; preds = %250, %249
%290 = phi i64 [ 0, %249 ], [ %286, %250 ]
br i1 %229, label %308, label %291
291: ; preds = %289
%292 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %290
%293 = bitcast i32* %292 to <4 x i32>*
%294 = load <4 x i32>, <4 x i32>* %293
%295 = getelementptr inbounds i32, i32* %292, i64 4
%296 = bitcast i32* %295 to <4 x i32>*
%297 = load <4 x i32>, <4 x i32>* %296
%298 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %5, i64 0, i64 %247, i64 %290
%299 = bitcast i32* %298 to <4 x i32>*
%300 = load <4 x i32>, <4 x i32>* %299
%301 = getelementptr inbounds i32, i32* %298, i64 4
%302 = bitcast i32* %301 to <4 x i32>*
%303 = load <4 x i32>, <4 x i32>* %302
%304 = add nsw <4 x i32> %300, %294
%305 = add nsw <4 x i32> %303, %297
%306 = bitcast i32* %292 to <4 x i32>*
store <4 x i32> %304, <4 x i32>* %306
%307 = bitcast i32* %295 to <4 x i32>*
store <4 x i32> %305, <4 x i32>* %307
br label %308
308: ; preds = %289, %291
br i1 %230, label %320, label %309
309: ; preds = %248, %308
%310 = phi i64 [ 0, %248 ], [ %225, %308 ]
br label %311
311: ; preds = %309, %311
%312 = phi i64 [ %318, %311 ], [ %310, %309 ]
%313 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %312
%314 = load i32, i32* %313
%315 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %5, i64 0, i64 %247, i64 %312
%316 = load i32, i32* %315
%317 = add nsw i32 %316, %314
store i32 %317, i32* %313
%318 = add nuw nsw i64 %312, 1
%319 = icmp eq i64 %318, %219
br i1 %319, label %320, label %311
320: ; preds = %311, %308, %246
%321 = add nuw nsw i64 %247, 1
%322 = icmp eq i64 %321, %218
br i1 %322, label %323, label %246
323: ; preds = %320, %205, %213
%324 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.22, i64 0, i64 0))
%325 = load i32, i32* %2
%326 = icmp sgt i32 %325, 0
br i1 %326, label %410, label %429
327: ; preds = %410
%328 = icmp sgt i32 %416, 0
br i1 %328, label %329, label %429
329: ; preds = %327
%330 = zext i32 %416 to i64
%331 = icmp ult i32 %416, 8
br i1 %331, label %408, label %332
332: ; preds = %329
%333 = and i64 %330, 4294967288
%334 = add nsw i64 %333, -8
%335 = lshr exact i64 %334, 3
%336 = add nuw nsw i64 %335, 1
%337 = and i64 %336, 1
%338 = icmp eq i64 %334, 0
br i1 %338, label %384, label %339
339: ; preds = %332
%340 = and i64 %336, 4611686018427387902
br label %341
341: ; preds = %341, %339
%342 = phi i64 [ 0, %339 ], [ %381, %341 ]
%343 = phi i64 [ 0, %339 ], [ %382, %341 ]
%344 = getelementptr inbounds [5 x i32], [5 x i32]* %7, i64 0, i64 %342
%345 = bitcast i32* %344 to <4 x i32>*
%346 = load <4 x i32>, <4 x i32>* %345
%347 = getelementptr inbounds i32, i32* %344, i64 4
%348 = bitcast i32* %347 to <4 x i32>*
%349 = load <4 x i32>, <4 x i32>* %348
%350 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %342
%351 = bitcast i32* %350 to <4 x i32>*
%352 = load <4 x i32>, <4 x i32>* %351
%353 = getelementptr inbounds i32, i32* %350, i64 4
%354 = bitcast i32* %353 to <4 x i32>*
%355 = load <4 x i32>, <4 x i32>* %354
%356 = sub nsw <4 x i32> %346, %352
%357 = sub nsw <4 x i32> %349, %355
%358 = getelementptr inbounds [5 x i32], [5 x i32]* %4, i64 0, i64 %342
%359 = bitcast i32* %358 to <4 x i32>*
store <4 x i32> %356, <4 x i32>* %359
%360 = getelementptr inbounds i32, i32* %358, i64 4
%361 = bitcast i32* %360 to <4 x i32>*
store <4 x i32> %357, <4 x i32>* %361
%362 = or i64 %342, 8
%363 = getelementptr inbounds [5 x i32], [5 x i32]* %7, i64 0, i64 %362
%364 = bitcast i32* %363 to <4 x i32>*
%365 = load <4 x i32>, <4 x i32>* %364
%366 = getelementptr inbounds i32, i32* %363, i64 4
%367 = bitcast i32* %366 to <4 x i32>*
%368 = load <4 x i32>, <4 x i32>* %367
%369 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %362
%370 = bitcast i32* %369 to <4 x i32>*
%371 = load <4 x i32>, <4 x i32>* %370
%372 = getelementptr inbounds i32, i32* %369, i64 4
%373 = bitcast i32* %372 to <4 x i32>*
%374 = load <4 x i32>, <4 x i32>* %373
%375 = sub nsw <4 x i32> %365, %371
%376 = sub nsw <4 x i32> %368, %374
%377 = getelementptr inbounds [5 x i32], [5 x i32]* %4, i64 0, i64 %362
%378 = bitcast i32* %377 to <4 x i32>*
store <4 x i32> %375, <4 x i32>* %378
%379 = getelementptr inbounds i32, i32* %377, i64 4
%380 = bitcast i32* %379 to <4 x i32>*
store <4 x i32> %376, <4 x i32>* %380
%381 = add nuw i64 %342, 16
%382 = add i64 %343, 2
%383 = icmp eq i64 %382, %340
br i1 %383, label %384, label %341
384: ; preds = %341, %332
%385 = phi i64 [ 0, %332 ], [ %381, %341 ]
%386 = icmp eq i64 %337, 0
br i1 %386, label %406, label %387
387: ; preds = %384
%388 = getelementptr inbounds [5 x i32], [5 x i32]* %7, i64 0, i64 %385
%389 = bitcast i32* %388 to <4 x i32>*
%390 = load <4 x i32>, <4 x i32>* %389
%391 = getelementptr inbounds i32, i32* %388, i64 4
%392 = bitcast i32* %391 to <4 x i32>*
%393 = load <4 x i32>, <4 x i32>* %392
%394 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %385
%395 = bitcast i32* %394 to <4 x i32>*
%396 = load <4 x i32>, <4 x i32>* %395
%397 = getelementptr inbounds i32, i32* %394, i64 4
%398 = bitcast i32* %397 to <4 x i32>*
%399 = load <4 x i32>, <4 x i32>* %398
%400 = sub nsw <4 x i32> %390, %396
%401 = sub nsw <4 x i32> %393, %399
%402 = getelementptr inbounds [5 x i32], [5 x i32]* %4, i64 0, i64 %385
%403 = bitcast i32* %402 to <4 x i32>*
store <4 x i32> %400, <4 x i32>* %403
%404 = getelementptr inbounds i32, i32* %402, i64 4
%405 = bitcast i32* %404 to <4 x i32>*
store <4 x i32> %401, <4 x i32>* %405
br label %406
406: ; preds = %384, %387
%407 = icmp eq i64 %333, %330
br i1 %407, label %429, label %408
408: ; preds = %329, %406
%409 = phi i64 [ 0, %329 ], [ %333, %406 ]
br label %419
410: ; preds = %323, %410
%411 = phi i64 [ %415, %410 ], [ 0, %323 ]
%412 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %411
%413 = load i32, i32* %412
%414 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i32 %413)
%415 = add nuw nsw i64 %411, 1
%416 = load i32, i32* %2
%417 = sext i32 %416 to i64
%418 = icmp slt i64 %415, %417
br i1 %418, label %410, label %327
419: ; preds = %408, %419
%420 = phi i64 [ %427, %419 ], [ %409, %408 ]
%421 = getelementptr inbounds [5 x i32], [5 x i32]* %7, i64 0, i64 %420
%422 = load i32, i32* %421
%423 = getelementptr inbounds [5 x i32], [5 x i32]* %3, i64 0, i64 %420
%424 = load i32, i32* %423
%425 = sub nsw i32 %422, %424
%426 = getelementptr inbounds [5 x i32], [5 x i32]* %4, i64 0, i64 %420
store i32 %425, i32* %426
%427 = add nuw nsw i64 %420, 1
%428 = icmp eq i64 %427, %330
br i1 %428, label %429, label %419
429: ; preds = %419, %406, %323, %327
%430 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.13, i64 0, i64 0))
%431 = load i32, i32* %2
%432 = icmp sgt i32 %431, 0
br i1 %432, label %433, label %442
433: ; preds = %429, %433
%434 = phi i64 [ %438, %433 ], [ 0, %429 ]
%435 = getelementptr inbounds [5 x i32], [5 x i32]* %4, i64 0, i64 %434
%436 = load i32, i32* %435
%437 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i32 %436)
%438 = add nuw nsw i64 %434, 1
%439 = load i32, i32* %2
%440 = sext i32 %439 to i64
%441 = icmp slt i64 %438, %440
br i1 %441, label %433, label %442
442: ; preds = %433, %429
%443 = call i32 @putchar(i32 10)
%444 = icmp eq i32 %101, 0
br i1 %444, label %592, label %445
445: ; preds = %442, %589
%446 = phi i32 [ %481, %589 ], [ %101, %442 ]
%447 = load i32, i32* %1
%448 = icmp sgt i32 %447, 0
br i1 %448, label %449, label %573
449: ; preds = %445
%450 = load i32, i32* %2
%451 = icmp sgt i32 %450, 0
%452 = zext i32 %447 to i64
%453 = zext i32 %447 to i64
%454 = zext i32 %450 to i64
br label %455
455: ; preds = %449, %568
%456 = phi i64 [ 0, %449 ], [ %569, %568 ]
%457 = phi i1 [ true, %449 ], [ %570, %568 ]
%458 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %456
%459 = load i32, i32* %458
%460 = icmp eq i32 %459, 0
br i1 %460, label %568, label %461
461: ; preds = %455
br i1 %451, label %464, label %475
462: ; preds = %464
%463 = icmp eq i64 %474, %454
br i1 %463, label %475, label %464
464: ; preds = %461, %462
%465 = phi i64 [ %474, %462 ], [ 0, %461 ]
%466 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %6, i64 0, i64 %456, i64 %465
%467 = load i32, i32* %466
%468 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %5, i64 0, i64 %456, i64 %465
%469 = load i32, i32* %468
%470 = sub nsw i32 %467, %469
%471 = getelementptr inbounds [5 x i32], [5 x i32]* %4, i64 0, i64 %465
%472 = load i32, i32* %471
%473 = icmp sgt i32 %470, %472
%474 = add nuw nsw i64 %465, 1
br i1 %473, label %568, label %462
475: ; preds = %461, %462
%476 = trunc i64 %456 to i32
%477 = and i64 %456, 4294967295
%478 = getelementptr inbounds [5 x i32], [5 x i32]* %8, i64 0, i64 %477
%479 = add nuw nsw i32 %476, 1
%480 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.14, i64 0, i64 0), i32 %479)
store i32 0, i32* %478
%481 = add nsw i32 %446, -1
%482 = load i32, i32* %2
%483 = icmp sgt i32 %482, 0
br i1 %483, label %484, label %572
484: ; preds = %475
%485 = zext i32 %482 to i64
%486 = icmp ult i32 %482, 8
br i1 %486, label %557, label %487
487: ; preds = %484
%488 = and i64 %485, 4294967288
%489 = add nsw i64 %488, -8
%490 = lshr exact i64 %489, 3
%491 = add nuw nsw i64 %490, 1
%492 = and i64 %491, 1
%493 = icmp eq i64 %489, 0
br i1 %493, label %535, label %494
494: ; preds = %487
%495 = and i64 %491, 4611686018427387902
br label %496
496: ; preds = %496, %494
%497 = phi i64 [ 0, %494 ], [ %532, %496 ]
%498 = phi i64 [ 0, %494 ], [ %533, %496 ]
%499 = getelementptr inbounds [5 x i32], [5 x i32]* %4, i64 0, i64 %497
%500 = bitcast i32* %499 to <4 x i32>*
%501 = load <4 x i32>, <4 x i32>* %500
%502 = getelementptr inbounds i32, i32* %499, i64 4
%503 = bitcast i32* %502 to <4 x i32>*
%504 = load <4 x i32>, <4 x i32>* %503
%505 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %5, i64 0, i64 %477, i64 %497
%506 = bitcast i32* %505 to <4 x i32>*
%507 = load <4 x i32>, <4 x i32>* %506
%508 = getelementptr inbounds i32, i32* %505, i64 4
%509 = bitcast i32* %508 to <4 x i32>*
%510 = load <4 x i32>, <4 x i32>* %509
%511 = add nsw <4 x i32> %507, %501
%512 = add nsw <4 x i32> %510, %504
%513 = bitcast i32* %499 to <4 x i32>*
store <4 x i32> %511, <4 x i32>* %513
%514 = bitcast i32* %502 to <4 x i32>*
store <4 x i32> %512, <4 x i32>* %514
%515 = or i64 %497, 8
%516 = getelementptr inbounds [5 x i32], [5 x i32]* %4, i64 0, i64 %515
%517 = bitcast i32* %516 to <4 x i32>*
%518 = load <4 x i32>, <4 x i32>* %517
%519 = getelementptr inbounds i32, i32* %516, i64 4
%520 = bitcast i32* %519 to <4 x i32>*
%521 = load <4 x i32>, <4 x i32>* %520
%522 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %5, i64 0, i64 %477, i64 %515
%523 = bitcast i32* %522 to <4 x i32>*
%524 = load <4 x i32>, <4 x i32>* %523
%525 = getelementptr inbounds i32, i32* %522, i64 4
%526 = bitcast i32* %525 to <4 x i32>*
%527 = load <4 x i32>, <4 x i32>* %526
%528 = add nsw <4 x i32> %524, %518
%529 = add nsw <4 x i32> %527, %521
%530 = bitcast i32* %516 to <4 x i32>*
store <4 x i32> %528, <4 x i32>* %530
%531 = bitcast i32* %519 to <4 x i32>*
store <4 x i32> %529, <4 x i32>* %531
%532 = add nuw i64 %497, 16
%533 = add i64 %498, 2
%534 = icmp eq i64 %533, %495
br i1 %534, label %535, label %496
535: ; preds = %496, %487
%536 = phi i64 [ 0, %487 ], [ %532, %496 ]
%537 = icmp eq i64 %492, 0
br i1 %537, label %555, label %538
538: ; preds = %535
%539 = getelementptr inbounds [5 x i32], [5 x i32]* %4, i64 0, i64 %536
%540 = bitcast i32* %539 to <4 x i32>*
%541 = load <4 x i32>, <4 x i32>* %540
%542 = getelementptr inbounds i32, i32* %539, i64 4
%543 = bitcast i32* %542 to <4 x i32>*
%544 = load <4 x i32>, <4 x i32>* %543
%545 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %5, i64 0, i64 %477, i64 %536
%546 = bitcast i32* %545 to <4 x i32>*
%547 = load <4 x i32>, <4 x i32>* %546
%548 = getelementptr inbounds i32, i32* %545, i64 4
%549 = bitcast i32* %548 to <4 x i32>*
%550 = load <4 x i32>, <4 x i32>* %549
%551 = add nsw <4 x i32> %547, %541
%552 = add nsw <4 x i32> %550, %544
%553 = bitcast i32* %539 to <4 x i32>*
store <4 x i32> %551, <4 x i32>* %553
%554 = bitcast i32* %542 to <4 x i32>*
store <4 x i32> %552, <4 x i32>* %554
br label %555
555: ; preds = %535, %538
%556 = icmp eq i64 %488, %485
br i1 %556, label %572, label %557
557: ; preds = %484, %555
%558 = phi i64 [ 0, %484 ], [ %488, %555 ]
br label %559
559: ; preds = %557, %559
%560 = phi i64 [ %566, %559 ], [ %558, %557 ]
%561 = getelementptr inbounds [5 x i32], [5 x i32]* %4, i64 0, i64 %560
%562 = load i32, i32* %561
%563 = getelementptr inbounds [5 x [5 x i32]], [5 x [5 x i32]]* %5, i64 0, i64 %477, i64 %560
%564 = load i32, i32* %563
%565 = add nsw i32 %564, %562
store i32 %565, i32* %561
%566 = add nuw nsw i64 %560, 1
%567 = icmp eq i64 %566, %485
br i1 %567, label %572, label %559
568: ; preds = %464, %455
%569 = add nuw nsw i64 %456, 1
%570 = icmp ult i64 %569, %452
%571 = icmp eq i64 %569, %453
br i1 %571, label %573, label %455
572: ; preds = %559, %555, %475
br i1 %457, label %575, label %573
573: ; preds = %572, %445, %568
%574 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @str.23, i64 0, i64 0))
br label %592
575: ; preds = %572
%576 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str.24, i64 0, i64 0))
%577 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.25, i64 0, i64 0))
%578 = load i32, i32* %2
%579 = icmp sgt i32 %578, 0
br i1 %579, label %580, label %589
580: ; preds = %575, %580
%581 = phi i64 [ %585, %580 ], [ 0, %575 ]
%582 = getelementptr inbounds [5 x i32], [5 x i32]* %4, i64 0, i64 %581
%583 = load i32, i32* %582
%584 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i32 %583)
%585 = add nuw nsw i64 %581, 1
%586 = load i32, i32* %2
%587 = sext i32 %586 to i64
%588 = icmp slt i64 %585, %587
br i1 %588, label %580, label %589
589: ; preds = %580, %575
%590 = call i32 @putchar(i32 10)
%591 = icmp eq i32 %481, 0
br i1 %591, label %592, label %445
592: ; preds = %589, %442, %573
ret i32 0
}