#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 r1, c1, r2, c2, i, j, s1 = 0, s2 = 0;
  printf("Enter no. of rows for first matrix = ");
  scanf("%d", &r1);
  printf("Enter no. of columns for first matrix = ");
  scanf("%d", &c1);
  int A[r1][c1];
  for (i = 0; i < r1; i++) {
    for (j = 0; j < c1; j++) {
      scanf("%d", &A[i][j]);
    }
  }
  printf("Enter no. of rows for second matrix = ");
  scanf("%d", &r2);
  printf("Enter no. of columns for second matrix = ");
  scanf("%d", &c2);
  int B[r2][c2];
  for (i = 0; i < r2; i++) {
    for (j = 0; j < c2; j++) {
      scanf("%d", &B[i][j]);
    }
  }
  for (i = 0; i < r1; i++) {
    for (j = 0; j < c1; j++) {
      if (A[i][j] != 0)
        s1++;
    }
  }
  for (i = 0; i < r2; i++) {
    for (j = 0; j < c2; j++) {
      if (B[i][j] != 0) {
        s2++;
      }
    }
  }
  int SP1[s1 + 1][3];
  int SP2[s2 + 1][3];
  int e1 = 1, e2 = 1;
  SP1[0][0] = r1, SP1[0][1] = c1, SP1[0][2] = s1;
  SP2[0][0] = r2, SP2[0][1] = c2, SP2[0][2] = s2;
  for (i = 0; i < r1; i++) {
    for (j = 0; j < c1; j++) {
      if (A[i][j] != 0) {
        SP1[e1][0] = i;
        SP1[e1][1] = j;
        SP1[e1][2] = A[i][j];
        e1++;
      }
    }
  }
  for (i = 0; i < r2; i++) {
    for (j = 0; j < c2; j++) {
      if (B[i][j] != 0) {
        SP2[e2][0] = i;
        SP2[e2][1] = j;
        SP2[e2][2] = B[i][j];
        e2++;
      }
    }
  }
  printf("values of 1st sparse matix are:-\n");
  for (i = 0; i < s1 + 1; i++) {
    for (j = 0; j < 3; j++) {
      printf("%d ", SP1[i][j]);
    }
    printf("\n");
  }
  printf("values of 2nd sparse matix are:-\n");
  for (i = 0; i < s2 + 1; i++) {
    for (j = 0; j < 3; j++) {
      printf("%d ", SP2[i][j]);
    }
    printf("\n");
  }
  int RES[s1 + 1][3];
  RES[0][0] = r2, RES[0][1] = c2, RES[0][2] = s2;
  for (i = 1; i < s1 + 1; i++) {
    for (j = 0; j < 3; j++) {
      if (j != 2) {
        RES[i][j] = SP1[i][j];
      } else {
        RES[i][j] = SP1[i][j] + SP2[i][j];
      }
    }
  }
  int c = 1;
  printf("Final matrix=\n");
  for (i = 0; i < RES[0][0]; i++) {
    for (int z = 0; z < RES[0][1]; z++) {
      if (i == RES[c][0] && z == RES[c][1] && c <= RES[0][2]) {
        printf("%d\t", RES[c][2]);
        c++;
      } else
        printf("0\t");
    }
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
lea    0xeb9(%rip),%rdi
xor    %eax,%eax
mov    %al,-0x91(%rbp)
call   1030 <printf@plt>
lea    0xecb(%rip),%rdi
mov    %rdi,-0x90(%rbp)
lea    -0x8(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x91(%rbp),%al
lea    0xeb1(%rip),%rdi
call   1030 <printf@plt>
mov    -0x90(%rbp),%rdi
lea    -0xc(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
mov    -0xc(%rbp),%eax
mov    %rax,-0x88(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x80(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1243 <main+0x123>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1230 <main+0x110>
mov    -0x80(%rbp),%rsi
mov    -0x88(%rbp),%rcx
movslq -0x18(%rbp),%rax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rsi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe09(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11e5 <main+0xc5>
jmp    1235 <main+0x115>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11d2 <main+0xb2>
lea    0xe08(%rip),%rdi
xor    %eax,%eax
mov    %al,-0xb1(%rbp)
call   1030 <printf@plt>
lea    0xdc8(%rip),%rdi
mov    %rdi,-0xb0(%rbp)
lea    -0x10(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0xb1(%rbp),%al
lea    0xdfe(%rip),%rdi
call   1030 <printf@plt>
mov    -0xb0(%rbp),%rdi
lea    -0x14(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x10(%rbp),%eax
mov    %eax,%ecx
mov    -0x14(%rbp),%eax
mov    %rax,-0xa8(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xa0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x48(%rbp)
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1345 <main+0x225>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1332 <main+0x212>
mov    -0xa0(%rbp),%rsi
mov    -0xa8(%rbp),%rcx
movslq -0x18(%rbp),%rax
imul   %rcx,%rax
shl    $0x2,%rax
add    %rax,%rsi
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xd07(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12e4 <main+0x1c4>
jmp    1337 <main+0x217>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12d1 <main+0x1b1>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13c2 <main+0x2a2>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13af <main+0x28f>
mov    -0x80(%rbp),%rax
mov    -0x88(%rbp),%rdx
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     139c <main+0x27c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13a1 <main+0x281>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    135f <main+0x23f>
jmp    13b4 <main+0x294>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    134c <main+0x22c>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1442 <main+0x322>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    142f <main+0x30f>
mov    -0xa0(%rbp),%rax
mov    -0xa8(%rbp),%rdx
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     141c <main+0x2fc>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1421 <main+0x301>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13dc <main+0x2bc>
jmp    1434 <main+0x314>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13c9 <main+0x2a9>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,%edx
lea    (%rdx,%rdx,2),%rax
lea    0xf(,%rax,4),%rsi
movabs $0x1ffffffff0,%rax
and    %rax,%rsi
mov    %rsp,%rcx
sub    %rsi,%rcx
mov    %rcx,-0xc8(%rbp)
mov    %rcx,%rsp
mov    %rdx,-0x58(%rbp)
mov    -0x24(%rbp),%edx
add    $0x1,%edx
lea    (%rdx,%rdx,2),%rsi
lea    0xf(,%rsi,4),%rsi
and    %rax,%rsi
mov    %rsp,%rax
sub    %rsi,%rax
mov    %rax,-0xc0(%rbp)
mov    %rax,%rsp
mov    %rdx,-0x60(%rbp)
movl   $0x1,-0x64(%rbp)
movl   $0x1,-0x68(%rbp)
mov    -0x8(%rbp),%edx
mov    %edx,(%rcx)
mov    -0xc(%rbp),%edx
mov    %edx,0x4(%rcx)
mov    -0x20(%rbp),%edx
mov    %edx,0x8(%rcx)
mov    -0x10(%rbp),%ecx
mov    %ecx,(%rax)
mov    -0x14(%rbp),%ecx
mov    %ecx,0x4(%rax)
mov    -0x24(%rbp),%ecx
mov    %ecx,0x8(%rax)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15aa <main+0x48a>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1597 <main+0x477>
mov    -0x80(%rbp),%rax
mov    -0x88(%rbp),%rdx
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1584 <main+0x464>
mov    -0xc8(%rbp),%rax
mov    -0x80(%rbp),%rcx
mov    -0x88(%rbp),%rsi
mov    -0x18(%rbp),%edi
movslq -0x64(%rbp),%rdx
imul   $0xc,%rdx,%r8
mov    %rax,%rdx
add    %r8,%rdx
mov    %edi,(%rdx)
mov    -0x1c(%rbp),%edi
movslq -0x64(%rbp),%rdx
imul   $0xc,%rdx,%r8
mov    %rax,%rdx
add    %r8,%rdx
mov    %edi,0x4(%rdx)
movslq -0x18(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
movslq -0x64(%rbp),%rdx
imul   $0xc,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1589 <main+0x469>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14ea <main+0x3ca>
jmp    159c <main+0x47c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14d7 <main+0x3b7>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    168a <main+0x56a>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1677 <main+0x557>
mov    -0xa0(%rbp),%rax
mov    -0xa8(%rbp),%rdx
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1664 <main+0x544>
mov    -0xc0(%rbp),%rax
mov    -0xa0(%rbp),%rcx
mov    -0xa8(%rbp),%rsi
mov    -0x18(%rbp),%edi
movslq -0x68(%rbp),%rdx
imul   $0xc,%rdx,%r8
mov    %rax,%rdx
add    %r8,%rdx
mov    %edi,(%rdx)
mov    -0x1c(%rbp),%edi
movslq -0x68(%rbp),%rdx
imul   $0xc,%rdx,%r8
mov    %rax,%rdx
add    %r8,%rdx
mov    %edi,0x4(%rdx)
movslq -0x18(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
movslq -0x68(%rbp),%rdx
imul   $0xc,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1669 <main+0x549>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    15c4 <main+0x4a4>
jmp    167c <main+0x55c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    15b1 <main+0x491>
lea    0xa12(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1712 <main+0x5f2>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    16f6 <main+0x5d6>
mov    -0xc8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x9e4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    16b7 <main+0x597>
lea    0x9ec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    169f <main+0x57f>
lea    0x9b0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    179a <main+0x67a>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    177e <main+0x65e>
mov    -0xc0(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x95c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    173f <main+0x61f>
lea    0x964(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1727 <main+0x607>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,%ecx
lea    (%rcx,%rcx,2),%rax
lea    0xf(,%rax,4),%rdx
movabs $0x1ffffffff0,%rax
and    %rax,%rdx
mov    %rsp,%rax
sub    %rdx,%rax
mov    %rax,-0xd0(%rbp)
mov    %rax,%rsp
mov    %rcx,-0x70(%rbp)
mov    -0x10(%rbp),%ecx
mov    %ecx,(%rax)
mov    -0x14(%rbp),%ecx
mov    %ecx,0x4(%rax)
mov    -0x24(%rbp),%ecx
mov    %ecx,0x8(%rax)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    18bb <main+0x79b>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    18a8 <main+0x788>
cmpl   $0x2,-0x1c(%rbp)
je     184a <main+0x72a>
mov    -0xd0(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movslq -0x18(%rbp),%rdx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x18(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1895 <main+0x775>
mov    -0xd0(%rbp),%rax
mov    -0xc0(%rbp),%rcx
mov    -0xc8(%rbp),%rdx
movslq -0x18(%rbp),%rsi
imul   $0xc,%rsi,%rsi
add    %rsi,%rdx
movslq -0x1c(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
movslq -0x18(%rbp),%rsi
imul   $0xc,%rsi,%rsi
add    %rsi,%rcx
movslq -0x1c(%rbp),%rsi
add    (%rcx,%rsi,4),%edx
movslq -0x18(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    189a <main+0x77a>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    17ff <main+0x6df>
jmp    18ad <main+0x78d>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    17e7 <main+0x6c7>
movl   $0x1,-0x74(%rbp)
lea    0x822(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x18(%rbp)
mov    -0xd0(%rbp),%rcx
mov    -0x18(%rbp),%eax
cmp    (%rcx),%eax
jge    19bf <main+0x89f>
movl   $0x0,-0x78(%rbp)
mov    -0xd0(%rbp),%rcx
mov    -0x78(%rbp),%eax
cmp    0x4(%rcx),%eax
jge    19a3 <main+0x883>
mov    -0xd0(%rbp),%rcx
mov    -0x18(%rbp),%eax
movslq -0x74(%rbp),%rdx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
jne    1982 <main+0x862>
mov    -0xd0(%rbp),%rcx
mov    -0x78(%rbp),%eax
movslq -0x74(%rbp),%rdx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
cmp    0x4(%rcx),%eax
jne    1982 <main+0x862>
mov    -0xd0(%rbp),%rcx
mov    -0x74(%rbp),%eax
cmp    0x8(%rcx),%eax
jg     1982 <main+0x862>
mov    -0xd0(%rbp),%rax
movslq -0x74(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%esi
lea    0x78d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1990 <main+0x870>
lea    0x775(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1995 <main+0x875>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    18f0 <main+0x7d0>
lea    0x73f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    18d7 <main+0x7b7>
movl   $0x0,-0x4(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
lea    0xeb8(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xed0(%rip),%rbx
lea    -0x44(%rbp),%rsi
mov    %rbx,%rdi
call   1060 <scanf@plt>
lea    0xec0(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    -0x34(%rbp),%rsi
mov    %rbx,%rdi
call   1060 <scanf@plt>
mov    %rsp,-0x98(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x34(%rbp),%edx
mov    %rdx,%rcx
mov    %rdx,-0x50(%rbp)
imul   %rdx,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x30(%rbp)
mov    %rcx,%rsp
mov    -0x44(%rbp),%ecx
test   %ecx,%ecx
jle    1231 <main+0xf1>
mov    -0x34(%rbp),%eax
mov    -0x50(%rbp),%rdx
lea    0x0(,%rdx,4),%rdx
mov    %rdx,-0x40(%rbp)
xor    %r12d,%r12d
lea    0xe55(%rip),%r14
mov    -0x30(%rbp),%r13
jmp    1200 <main+0xc0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
movslq %ecx,%rdx
add    -0x40(%rbp),%r13
cmp    %rdx,%r12
jge    1231 <main+0xf1>
test   %eax,%eax
jle    11f0 <main+0xb0>
mov    %r13,%rbx
xor    %r15d,%r15d
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %rbx,%rsi
call   1060 <scanf@plt>
add    $0x1,%r15
movslq -0x34(%rbp),%rax
add    $0x4,%rbx
cmp    %rax,%r15
jl     1210 <main+0xd0>
mov    -0x44(%rbp),%ecx
jmp    11f0 <main+0xb0>
lea    0xe2a(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xdf0(%rip),%rbx
lea    -0x58(%rbp),%rsi
mov    %rbx,%rdi
call   1060 <scanf@plt>
lea    0xe30(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    -0x54(%rbp),%rsi
mov    %rbx,%rdi
call   1060 <scanf@plt>
mov    -0x58(%rbp),%r8d
mov    -0x54(%rbp),%r10d
mov    %r8,%rax
imul   %r10,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r13
sub    %rax,%r13
mov    %r13,%rsp
test   %r8d,%r8d
mov    %r13,-0x78(%rbp)
mov    %r10,-0x70(%rbp)
jle    1304 <main+0x1c4>
lea    0x0(,%r10,4),%rax
mov    %rax,-0x40(%rbp)
xor    %r12d,%r12d
lea    0xd83(%rip),%r14
xor    %eax,%eax
jmp    12d0 <main+0x190>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
movslq %r8d,%rcx
add    -0x40(%rbp),%r13
cmp    %rcx,%r12
jge    1306 <main+0x1c6>
test   %r10d,%r10d
jle    12c0 <main+0x180>
mov    %r13,%rbx
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %rbx,%rsi
call   1060 <scanf@plt>
add    $0x1,%r15
movslq -0x54(%rbp),%r10
add    $0x4,%rbx
cmp    %r10,%r15
jl     12e0 <main+0x1a0>
mov    -0x58(%rbp),%r8d
xor    %eax,%eax
jmp    12c0 <main+0x180>
xor    %eax,%eax
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
mov    %rcx,-0x60(%rbp)
mov    -0x44(%rbp),%r9d
test   %r9d,%r9d
jle    14b7 <main+0x377>
mov    -0x34(%rbp),%edi
mov    %edi,%r14d
and    $0xfffffff8,%r14d
lea    -0x8(%r14),%r13
mov    %r13,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11,%rcx
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,-0x40(%rbp)
mov    -0x30(%rbp),%rdx
lea    0x30(%rdx),%rsi
mov    -0x50(%rbp),%rcx
lea    0x0(,%rcx,4),%r15
xor    %r12d,%r12d
pxor   %xmm0,%xmm0
pcmpeqd %xmm8,%xmm8
movdqa 0xc8a(%rip),%xmm2
xor    %eax,%eax
jmp    1393 <main+0x253>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
add    %r15,%rsi
add    %r15,%rdx
cmp    %r9,%r12
je     14b7 <main+0x377>
test   %edi,%edi
jle    1380 <main+0x240>
cmp    $0x8,%edi
jae    13b0 <main+0x270>
xor    %ecx,%ecx
jmp    1490 <main+0x350>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movd   %eax,%xmm3
test   %r13,%r13
je     14a5 <main+0x365>
pxor   %xmm5,%xmm5
mov    -0x40(%rbp),%rbx
xor    %ecx,%ecx
movdqa %xmm3,%xmm6
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rsi,%rcx,4),%xmm7
movdqu -0x20(%rsi,%rcx,4),%xmm1
movdqu -0x10(%rsi,%rcx,4),%xmm3
movdqu (%rsi,%rcx,4),%xmm4
pcmpeqd %xmm0,%xmm7
paddd  %xmm6,%xmm7
pcmpeqd %xmm0,%xmm1
paddd  %xmm5,%xmm1
pcmpeqd %xmm0,%xmm3
pcmpeqd %xmm0,%xmm4
paddd  %xmm2,%xmm3
paddd  %xmm7,%xmm3
paddd  %xmm2,%xmm4
paddd  %xmm1,%xmm4
add    $0x10,%rcx
movdqa %xmm3,%xmm6
movdqa %xmm4,%xmm5
add    $0xfffffffffffffffe,%rbx
jne    13d0 <main+0x290>
test   $0x1,%r11b
je     145c <main+0x31c>
mov    %r12,%rbx
imul   -0x50(%rbp),%rbx
mov    -0x30(%rbp),%rax
lea    (%rax,%rbx,4),%rbx
movdqu (%rbx,%rcx,4),%xmm1
movdqu 0x10(%rbx,%rcx,4),%xmm5
pcmpeqd %xmm0,%xmm1
paddd  %xmm1,%xmm3
pcmpeqd %xmm0,%xmm5
paddd  %xmm5,%xmm4
psubd  %xmm8,%xmm3
psubd  %xmm8,%xmm4
paddd  %xmm4,%xmm3
pshufd $0xee,%xmm3,%xmm1
paddd  %xmm3,%xmm1
pshufd $0x55,%xmm1,%xmm3
paddd  %xmm1,%xmm3
movd   %xmm3,%eax
mov    %r14,%rcx
cmp    %rdi,%r14
je     1380 <main+0x240>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpl   $0x1,(%rdx,%rcx,4)
sbb    $0xffffffff,%eax
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    1490 <main+0x350>
jmp    1380 <main+0x240>
pxor   %xmm4,%xmm4
xor    %ecx,%ecx
test   $0x1,%r11b
jne    1427 <main+0x2e7>
jmp    145c <main+0x31c>
mov    %rax,-0x68(%rbp)
mov    %r8d,%r15d
mov    %r10d,%r11d
test   %r8d,%r8d
jle    1645 <main+0x505>
mov    %r11d,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%rax
mov    %rax,-0x40(%rbp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,%rcx
mov    %rax,-0x80(%rbp)
and    %rax,-0x60(%rbp)
mov    -0x78(%rbp),%r12
lea    0x30(%r12),%rcx
mov    -0x70(%rbp),%rax
lea    0x0(,%rax,4),%r13
xor    %edx,%edx
pxor   %xmm0,%xmm0
pcmpeqd %xmm8,%xmm8
movdqa 0xaed(%rip),%xmm2
xor    %r14d,%r14d
mov    -0x78(%rbp),%rax
jmp    1533 <main+0x3f3>
nopl   0x0(%rax)
add    $0x1,%rdx
add    %r13,%rcx
add    %r13,%r12
cmp    %r15,%rdx
je     1648 <main+0x508>
test   %r10d,%r10d
jle    1520 <main+0x3e0>
cmp    $0x8,%r10d
jae    1550 <main+0x410>
xor    %esi,%esi
jmp    1620 <main+0x4e0>
cs nopw 0x0(%rax,%rax,1)
nop
movd   %r14d,%xmm3
cmpq   $0x0,-0x40(%rbp)
je     1637 <main+0x4f7>
pxor   %xmm5,%xmm5
mov    -0x60(%rbp),%rsi
xor    %edi,%edi
movdqa %xmm3,%xmm6
xchg   %ax,%ax
movdqu -0x30(%rcx,%rdi,4),%xmm7
movdqu -0x20(%rcx,%rdi,4),%xmm1
movdqu -0x10(%rcx,%rdi,4),%xmm3
movdqu (%rcx,%rdi,4),%xmm4
pcmpeqd %xmm0,%xmm7
paddd  %xmm6,%xmm7
pcmpeqd %xmm0,%xmm1
paddd  %xmm5,%xmm1
pcmpeqd %xmm0,%xmm3
pcmpeqd %xmm0,%xmm4
paddd  %xmm2,%xmm3
paddd  %xmm7,%xmm3
paddd  %xmm2,%xmm4
paddd  %xmm1,%xmm4
add    $0x10,%rdi
movdqa %xmm3,%xmm6
movdqa %xmm4,%xmm5
add    $0xfffffffffffffffe,%rsi
jne    1570 <main+0x430>
testb  $0x1,-0x80(%rbp)
je     15f8 <main+0x4b8>
mov    %rdx,%rsi
imul   -0x70(%rbp),%rsi
lea    (%rax,%rsi,4),%rsi
movdqu (%rsi,%rdi,4),%xmm1
movdqu 0x10(%rsi,%rdi,4),%xmm5
pcmpeqd %xmm0,%xmm1
paddd  %xmm1,%xmm3
pcmpeqd %xmm0,%xmm5
paddd  %xmm5,%xmm4
psubd  %xmm8,%xmm3
psubd  %xmm8,%xmm4
paddd  %xmm4,%xmm3
pshufd $0xee,%xmm3,%xmm1
paddd  %xmm3,%xmm1
pshufd $0x55,%xmm1,%xmm3
paddd  %xmm1,%xmm3
movd   %xmm3,%r14d
mov    %rbx,%rsi
cmp    %r11,%rbx
je     1520 <main+0x3e0>
nop
cmpl   $0x1,(%r12,%rsi,4)
sbb    $0xffffffff,%r14d
add    $0x1,%rsi
cmp    %rsi,%r11
jne    1620 <main+0x4e0>
jmp    1520 <main+0x3e0>
pxor   %xmm4,%xmm4
xor    %edi,%edi
testb  $0x1,-0x80(%rbp)
jne    15c7 <main+0x487>
jmp    15f8 <main+0x4b8>
xor    %r14d,%r14d
mov    -0x68(%rbp),%rax
lea    0x1(%rax),%ecx
mov    %rcx,-0x88(%rbp)
lea    (%rcx,%rcx,2),%rcx
mov    %rcx,-0x60(%rbp)
lea    0xf(,%rcx,4),%rbx
movabs $0x1ffffffff0,%rcx
and    %rcx,%rbx
mov    %rsp,%rdx
mov    %rdx,%r13
sub    %rbx,%r13
mov    %r13,%rsp
lea    0x1(%r14),%esi
mov    %rsi,-0x90(%rbp)
lea    (%rsi,%rsi,2),%rsi
lea    0xf(,%rsi,4),%rsi
and    %rcx,%rsi
mov    %rsp,%rdi
mov    %rdi,%r12
sub    %rsi,%r12
mov    %r12,%rsp
mov    %rbx,-0x40(%rbp)
neg    %rbx
neg    %rsi
mov    %r9d,0x0(%r13)
mov    -0x34(%rbp),%ecx
mov    %rbx,-0x80(%rbp)
mov    %ecx,0x4(%rdx,%rbx,1)
mov    %eax,0x8(%r13)
mov    %r8d,(%r12)
mov    %r10d,0x4(%r12)
mov    %r14d,0x8(%rdi,%rsi,1)
test   %r9d,%r9d
jle    173f <main+0x5ff>
shlq   $0x2,-0x50(%rbp)
mov    $0x1,%edx
xor    %esi,%esi
jmp    1705 <main+0x5c5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rsi
mov    -0x30(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x30(%rbp)
cmp    %r9,%rsi
je     173f <main+0x5ff>
test   %ecx,%ecx
jle    16f0 <main+0x5b0>
xor    %edi,%edi
jmp    1719 <main+0x5d9>
nopl   (%rax)
add    $0x1,%rdi
cmp    %rdi,%rcx
je     16f0 <main+0x5b0>
mov    -0x30(%rbp),%rax
mov    (%rax,%rdi,4),%ebx
test   %ebx,%ebx
je     1710 <main+0x5d0>
movslq %edx,%rdx
lea    (%rdx,%rdx,2),%rax
mov    %esi,0x0(%r13,%rax,4)
mov    %edi,0x4(%r13,%rax,4)
mov    %ebx,0x8(%r13,%rax,4)
add    $0x1,%edx
jmp    1710 <main+0x5d0>
test   %r8d,%r8d
mov    -0x78(%rbp),%rcx
jle    17aa <main+0x66a>
mov    -0x70(%rbp),%rax
lea    0x0(,%rax,4),%r8
mov    $0x1,%edx
xor    %esi,%esi
jmp    176c <main+0x62c>
nopl   (%rax)
add    $0x1,%rsi
add    %r8,%rcx
cmp    %r15,%rsi
je     17aa <main+0x66a>
test   %r10d,%r10d
jle    1760 <main+0x620>
xor    %edi,%edi
jmp    1789 <main+0x649>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdi
cmp    %rdi,%r11
je     1760 <main+0x620>
mov    (%rcx,%rdi,4),%ebx
test   %ebx,%ebx
je     1780 <main+0x640>
movslq %edx,%rdx
lea    (%rdx,%rdx,2),%rax
mov    %esi,(%r12,%rax,4)
mov    %edi,0x4(%r12,%rax,4)
mov    %ebx,0x8(%r12,%rax,4)
add    $0x1,%edx
jmp    1780 <main+0x640>
lea    0x90d(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,-0x68(%rbp)
js     1821 <main+0x6e1>
mov    -0x88(%rbp),%rax
shl    $0x2,%rax
lea    (%rax,%rax,2),%rax
mov    %rax,-0x30(%rbp)
lea    0x8dd(%rip),%rbx
xor    %r15d,%r15d
nopl   0x0(%rax)
mov    0x0(%r13,%r15,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x4(%r13,%r15,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x8(%r13,%r15,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0xc,%r15
cmp    %r15,-0x30(%rbp)
jne    17e0 <main+0x6a0>
lea    0x8b7(%rip),%rdi
call   1040 <puts@plt>
test   %r14d,%r14d
js     1890 <main+0x750>
mov    -0x90(%rbp),%rax
shl    $0x2,%rax
lea    (%rax,%rax,2),%rax
mov    %rax,-0x30(%rbp)
lea    0x867(%rip),%rbx
xor    %r15d,%r15d
nop
mov    (%r12,%r15,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x4(%r12,%r15,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x8(%r12,%r15,1),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0xc,%r15
cmp    %r15,-0x30(%rbp)
jne    1850 <main+0x710>
mov    %rsp,%rax
mov    %rax,%rbx
sub    -0x40(%rbp),%rbx
mov    %rbx,%rsp
mov    -0x58(%rbp),%ecx
mov    %ecx,-0x50(%rbp)
mov    %ecx,(%rbx)
mov    -0x54(%rbp),%edx
mov    -0x80(%rbp),%rcx
mov    %edx,-0x30(%rbp)
mov    %edx,0x4(%rax,%rcx,1)
mov    %r14d,0x8(%rbx)
cmpl   $0x0,-0x68(%rbp)
jle    18f9 <main+0x7b9>
mov    -0x60(%rbp),%rax
lea    -0xc(,%rax,4),%rax
ff
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    0xc(%r13,%rcx,1),%edx
mov    %edx,0xc(%rbx,%rcx,1)
mov    0x10(%r13,%rcx,1),%edx
mov    0x14(%r12,%rcx,1),%esi
add    0x14(%r13,%rcx,1),%esi
mov    %edx,0x10(%rbx,%rcx,1)
mov    %esi,0x14(%rbx,%rcx,1)
add    $0xc,%rcx
cmp    %rcx,%rax
jne    18d0 <main+0x790>
lea    0x800(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,-0x50(%rbp)
jle    1989 <main+0x849>
mov    $0x1,%r13d
xor    %r12d,%r12d
jmp    1934 <main+0x7f4>
cs nopw 0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r12d
cmp    -0x50(%rbp),%r12d
je     1989 <main+0x849>
cmpl   $0x0,-0x30(%rbp)
jle    1920 <main+0x7e0>
xor    %r15d,%r15d
jmp    1958 <main+0x818>
nop
lea    0x774(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%r15d
cmp    %r15d,-0x30(%rbp)
je     1920 <main+0x7e0>
movslq %r13d,%rax
lea    (%rax,%rax,2),%rax
cmp    (%rbx,%rax,4),%r12d
jne    1940 <main+0x800>
cmp    0x4(%rbx,%rax,4),%r15d
jne    1940 <main+0x800>
cmp    %r14d,%r13d
jg     1940 <main+0x800>
mov    0x8(%rbx,%rax,4),%esi
lea    0x73b(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%r13d
jmp    194e <main+0x80e>
mov    -0x98(%rbp),%rsp
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [38 x i8] c"Enter no. of rows for first matrix = \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [41 x i8] c"Enter no. of columns for first matrix = \00"
@.str.3 = [39 x i8] c"Enter no. of rows for second matrix = \00"
@.str.4 = [42 x i8] c"Enter no. of columns for second matrix = \00"
@.str.5 = [34 x i8] c"values of 1st sparse matix are:-\0A\00"
@.str.6 = [4 x i8] c"%d \00"
@.str.7 = [2 x i8] c"\0A\00"
@.str.8 = [34 x i8] c"values of 2nd sparse matix are:-\0A\00"
@.str.9 = [15 x i8] c"Final matrix=\0A\00"
@.str.10 = [4 x i8] c"%d\09\00"
@.str.11 = [3 x i8] c"0\09\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 i32
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i32
%18 = alloca i32
%19 = alloca i64
%20 = alloca i32
%21 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %8
store i32 0, i32* %9
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0))
%23 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %2)
%24 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.2, i64 0, i64 0))
%25 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %3)
%26 = load i32, i32* %2
%27 = zext i32 %26 to i64
%28 = load i32, i32* %3
%29 = zext i32 %28 to i64
%30 = call i8* @llvm.stacksave()
store i8* %30, i8** %10
%31 = mul nuw i64 %27, %29
%32 = alloca i32, i64 %31
store i64 %27, i64* %11
store i64 %29, i64* %12
store i32 0, i32* %6
br label %33
33: ; preds = %55, %0
%34 = load i32, i32* %6
%35 = load i32, i32* %2
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %58
37: ; preds = %33
store i32 0, i32* %7
br label %38
38: ; preds = %51, %37
%39 = load i32, i32* %7
%40 = load i32, i32* %3
%41 = icmp slt i32 %39, %40
br i1 %41, label %42, label %54
42: ; preds = %38
%43 = load i32, i32* %6
%44 = sext i32 %43 to i64
%45 = mul nsw i64 %44, %29
%46 = getelementptr inbounds i32, i32* %32, i64 %45
%47 = load i32, i32* %7
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i32, i32* %46, i64 %48
%50 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %49)
br label %51
51: ; preds = %42
%52 = load i32, i32* %7
%53 = add nsw i32 %52, 1
store i32 %53, i32* %7
br label %38
54: ; preds = %38
br label %55
55: ; preds = %54
%56 = load i32, i32* %6
%57 = add nsw i32 %56, 1
store i32 %57, i32* %6
br label %33
58: ; preds = %33
%59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.3, i64 0, i64 0))
%60 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %4)
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.4, i64 0, i64 0))
%62 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %5)
%63 = load i32, i32* %4
%64 = zext i32 %63 to i64
%65 = load i32, i32* %5
%66 = zext i32 %65 to i64
%67 = mul nuw i64 %64, %66
%68 = alloca i32, i64 %67
store i64 %64, i64* %13
store i64 %66, i64* %14
store i32 0, i32* %6
br label %69
69: ; preds = %91, %58
%70 = load i32, i32* %6
%71 = load i32, i32* %4
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %94
73: ; preds = %69
store i32 0, i32* %7
br label %74
74: ; preds = %87, %73
%75 = load i32, i32* %7
%76 = load i32, i32* %5
%77 = icmp slt i32 %75, %76
br i1 %77, label %78, label %90
78: ; preds = %74
%79 = load i32, i32* %6
%80 = sext i32 %79 to i64
%81 = mul nsw i64 %80, %66
%82 = getelementptr inbounds i32, i32* %68, i64 %81
%83 = load i32, i32* %7
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %82, i64 %84
%86 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %85)
br label %87
87: ; preds = %78
%88 = load i32, i32* %7
%89 = add nsw i32 %88, 1
store i32 %89, i32* %7
br label %74
90: ; preds = %74
br label %91
91: ; preds = %90
%92 = load i32, i32* %6
%93 = add nsw i32 %92, 1
store i32 %93, i32* %6
br label %69
94: ; preds = %69
store i32 0, i32* %6
br label %95
95: ; preds = %122, %94
%96 = load i32, i32* %6
%97 = load i32, i32* %2
%98 = icmp slt i32 %96, %97
br i1 %98, label %99, label %125
99: ; preds = %95
store i32 0, i32* %7
br label %100
100: ; preds = %118, %99
%101 = load i32, i32* %7
%102 = load i32, i32* %3
%103 = icmp slt i32 %101, %102
br i1 %103, label %104, label %121
104: ; preds = %100
%105 = load i32, i32* %6
%106 = sext i32 %105 to i64
%107 = mul nsw i64 %106, %29
%108 = getelementptr inbounds i32, i32* %32, i64 %107
%109 = load i32, i32* %7
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i32, i32* %108, i64 %110
%112 = load i32, i32* %111
%113 = icmp ne i32 %112, 0
br i1 %113, label %114, label %117
114: ; preds = %104
%115 = load i32, i32* %8
%116 = add nsw i32 %115, 1
store i32 %116, i32* %8
br label %117
117: ; preds = %114, %104
br label %118
118: ; preds = %117
%119 = load i32, i32* %7
%120 = add nsw i32 %119, 1
store i32 %120, i32* %7
br label %100
121: ; preds = %100
br label %122
122: ; preds = %121
%123 = load i32, i32* %6
%124 = add nsw i32 %123, 1
store i32 %124, i32* %6
br label %95
125: ; preds = %95
store i32 0, i32* %6
br label %126
126: ; preds = %153, %125
%127 = load i32, i32* %6
%128 = load i32, i32* %4
%129 = icmp slt i32 %127, %128
br i1 %129, label %130, label %156
130: ; preds = %126
store i32 0, i32* %7
br label %131
131: ; preds = %149, %130
%132 = load i32, i32* %7
%133 = load i32, i32* %5
%134 = icmp slt i32 %132, %133
br i1 %134, label %135, label %152
135: ; preds = %131
%136 = load i32, i32* %6
%137 = sext i32 %136 to i64
%138 = mul nsw i64 %137, %66
%139 = getelementptr inbounds i32, i32* %68, i64 %138
%140 = load i32, i32* %7
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %139, i64 %141
%143 = load i32, i32* %142
%144 = icmp ne i32 %143, 0
br i1 %144, label %145, label %148
145: ; preds = %135
%146 = load i32, i32* %9
%147 = add nsw i32 %146, 1
store i32 %147, i32* %9
br label %148
148: ; preds = %145, %135
br label %149
149: ; preds = %148
%150 = load i32, i32* %7
%151 = add nsw i32 %150, 1
store i32 %151, i32* %7
br label %131
152: ; preds = %131
br label %153
153: ; preds = %152
%154 = load i32, i32* %6
%155 = add nsw i32 %154, 1
store i32 %155, i32* %6
br label %126
156: ; preds = %126
%157 = load i32, i32* %8
%158 = add nsw i32 %157, 1
%159 = zext i32 %158 to i64
%160 = alloca [3 x i32], i64 %159
store i64 %159, i64* %15
%161 = load i32, i32* %9
%162 = add nsw i32 %161, 1
%163 = zext i32 %162 to i64
%164 = alloca [3 x i32], i64 %163
store i64 %163, i64* %16
store i32 1, i32* %17
store i32 1, i32* %18
%165 = load i32, i32* %2
%166 = getelementptr inbounds [3 x i32], [3 x i32]* %160, i64 0
%167 = getelementptr inbounds [3 x i32], [3 x i32]* %166, i64 0, i64 0
store i32 %165, i32* %167
%168 = load i32, i32* %3
%169 = getelementptr inbounds [3 x i32], [3 x i32]* %160, i64 0
%170 = getelementptr inbounds [3 x i32], [3 x i32]* %169, i64 0, i64 1
store i32 %168, i32* %170
%171 = load i32, i32* %8
%172 = getelementptr inbounds [3 x i32], [3 x i32]* %160, i64 0
%173 = getelementptr inbounds [3 x i32], [3 x i32]* %172, i64 0, i64 2
store i32 %171, i32* %173
%174 = load i32, i32* %4
%175 = getelementptr inbounds [3 x i32], [3 x i32]* %164, i64 0
%176 = getelementptr inbounds [3 x i32], [3 x i32]* %175, i64 0, i64 0
store i32 %174, i32* %176
%177 = load i32, i32* %5
%178 = getelementptr inbounds [3 x i32], [3 x i32]* %164, i64 0
%179 = getelementptr inbounds [3 x i32], [3 x i32]* %178, i64 0, i64 1
store i32 %177, i32* %179
%180 = load i32, i32* %9
%181 = getelementptr inbounds [3 x i32], [3 x i32]* %164, i64 0
%182 = getelementptr inbounds [3 x i32], [3 x i32]* %181, i64 0, i64 2
store i32 %180, i32* %182
store i32 0, i32* %6
br label %183
183: ; preds = %232, %156
%184 = load i32, i32* %6
%185 = load i32, i32* %2
%186 = icmp slt i32 %184, %185
br i1 %186, label %187, label %235
187: ; preds = %183
store i32 0, i32* %7
br label %188
188: ; preds = %228, %187
%189 = load i32, i32* %7
%190 = load i32, i32* %3
%191 = icmp slt i32 %189, %190
br i1 %191, label %192, label %231
192: ; preds = %188
%193 = load i32, i32* %6
%194 = sext i32 %193 to i64
%195 = mul nsw i64 %194, %29
%196 = getelementptr inbounds i32, i32* %32, i64 %195
%197 = load i32, i32* %7
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i32, i32* %196, i64 %198
%200 = load i32, i32* %199
%201 = icmp ne i32 %200, 0
br i1 %201, label %202, label %227
202: ; preds = %192
%203 = load i32, i32* %6
%204 = load i32, i32* %17
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [3 x i32], [3 x i32]* %160, i64 %205
%207 = getelementptr inbounds [3 x i32], [3 x i32]* %206, i64 0, i64 0
store i32 %203, i32* %207
%208 = load i32, i32* %7
%209 = load i32, i32* %17
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds [3 x i32], [3 x i32]* %160, i64 %210
%212 = getelementptr inbounds [3 x i32], [3 x i32]* %211, i64 0, i64 1
store i32 %208, i32* %212
%213 = load i32, i32* %6
%214 = sext i32 %213 to i64
%215 = mul nsw i64 %214, %29
%216 = getelementptr inbounds i32, i32* %32, i64 %215
%217 = load i32, i32* %7
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds i32, i32* %216, i64 %218
%220 = load i32, i32* %219
%221 = load i32, i32* %17
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds [3 x i32], [3 x i32]* %160, i64 %222
%224 = getelementptr inbounds [3 x i32], [3 x i32]* %223, i64 0, i64 2
store i32 %220, i32* %224
%225 = load i32, i32* %17
%226 = add nsw i32 %225, 1
store i32 %226, i32* %17
br label %227
227: ; preds = %202, %192
br label %228
228: ; preds = %227
%229 = load i32, i32* %7
%230 = add nsw i32 %229, 1
store i32 %230, i32* %7
br label %188
231: ; preds = %188
br label %232
232: ; preds = %231
%233 = load i32, i32* %6
%234 = add nsw i32 %233, 1
store i32 %234, i32* %6
br label %183
235: ; preds = %183
store i32 0, i32* %6
br label %236
236: ; preds = %285, %235
%237 = load i32, i32* %6
%238 = load i32, i32* %4
%239 = icmp slt i32 %237, %238
br i1 %239, label %240, label %288
240: ; preds = %236
store i32 0, i32* %7
br label %241
241: ; preds = %281, %240
%242 = load i32, i32* %7
%243 = load i32, i32* %5
%244 = icmp slt i32 %242, %243
br i1 %244, label %245, label %284
245: ; preds = %241
%246 = load i32, i32* %6
%247 = sext i32 %246 to i64
%248 = mul nsw i64 %247, %66
%249 = getelementptr inbounds i32, i32* %68, i64 %248
%250 = load i32, i32* %7
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i32, i32* %249, i64 %251
%253 = load i32, i32* %252
%254 = icmp ne i32 %253, 0
br i1 %254, label %255, label %280
255: ; preds = %245
%256 = load i32, i32* %6
%257 = load i32, i32* %18
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [3 x i32], [3 x i32]* %164, i64 %258
%260 = getelementptr inbounds [3 x i32], [3 x i32]* %259, i64 0, i64 0
store i32 %256, i32* %260
%261 = load i32, i32* %7
%262 = load i32, i32* %18
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds [3 x i32], [3 x i32]* %164, i64 %263
%265 = getelementptr inbounds [3 x i32], [3 x i32]* %264, i64 0, i64 1
store i32 %261, i32* %265
%266 = load i32, i32* %6
%267 = sext i32 %266 to i64
%268 = mul nsw i64 %267, %66
%269 = getelementptr inbounds i32, i32* %68, i64 %268
%270 = load i32, i32* %7
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i32, i32* %269, i64 %271
%273 = load i32, i32* %272
%274 = load i32, i32* %18
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [3 x i32], [3 x i32]* %164, i64 %275
%277 = getelementptr inbounds [3 x i32], [3 x i32]* %276, i64 0, i64 2
store i32 %273, i32* %277
%278 = load i32, i32* %18
%279 = add nsw i32 %278, 1
store i32 %279, i32* %18
br label %280
280: ; preds = %255, %245
br label %281
281: ; preds = %280
%282 = load i32, i32* %7
%283 = add nsw i32 %282, 1
store i32 %283, i32* %7
br label %241
284: ; preds = %241
br label %285
285: ; preds = %284
%286 = load i32, i32* %6
%287 = add nsw i32 %286, 1
store i32 %287, i32* %6
br label %236
288: ; preds = %236
%289 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.5, i64 0, i64 0))
store i32 0, i32* %6
br label %290
290: ; preds = %313, %288
%291 = load i32, i32* %6
%292 = load i32, i32* %8
%293 = add nsw i32 %292, 1
%294 = icmp slt i32 %291, %293
br i1 %294, label %295, label %316
295: ; preds = %290
store i32 0, i32* %7
br label %296
296: ; preds = %308, %295
%297 = load i32, i32* %7
%298 = icmp slt i32 %297, 3
br i1 %298, label %299, label %311
299: ; preds = %296
%300 = load i32, i32* %6
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds [3 x i32], [3 x i32]* %160, i64 %301
%303 = load i32, i32* %7
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [3 x i32], [3 x i32]* %302, i64 0, i64 %304
%306 = load i32, i32* %305
%307 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %306)
br label %308
308: ; preds = %299
%309 = load i32, i32* %7
%310 = add nsw i32 %309, 1
store i32 %310, i32* %7
br label %296
311: ; preds = %296
%312 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %313
313: ; preds = %311
%314 = load i32, i32* %6
%315 = add nsw i32 %314, 1
store i32 %315, i32* %6
br label %290
316: ; preds = %290
%317 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.8, i64 0, i64 0))
store i32 0, i32* %6
br label %318
318: ; preds = %341, %316
%319 = load i32, i32* %6
%320 = load i32, i32* %9
%321 = add nsw i32 %320, 1
%322 = icmp slt i32 %319, %321
br i1 %322, label %323, label %344
323: ; preds = %318
store i32 0, i32* %7
br label %324
324: ; preds = %336, %323
%325 = load i32, i32* %7
%326 = icmp slt i32 %325, 3
br i1 %326, label %327, label %339
327: ; preds = %324
%328 = load i32, i32* %6
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds [3 x i32], [3 x i32]* %164, i64 %329
%331 = load i32, i32* %7
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds [3 x i32], [3 x i32]* %330, i64 0, i64 %332
%334 = load i32, i32* %333
%335 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %334)
br label %336
336: ; preds = %327
%337 = load i32, i32* %7
%338 = add nsw i32 %337, 1
store i32 %338, i32* %7
br label %324
339: ; preds = %324
%340 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %341
341: ; preds = %339
%342 = load i32, i32* %6
%343 = add nsw i32 %342, 1
store i32 %343, i32* %6
br label %318
344: ; preds = %318
%345 = load i32, i32* %8
%346 = add nsw i32 %345, 1
%347 = zext i32 %346 to i64
%348 = alloca [3 x i32], i64 %347
store i64 %347, i64* %19
%349 = load i32, i32* %4
%350 = getelementptr inbounds [3 x i32], [3 x i32]* %348, i64 0
%351 = getelementptr inbounds [3 x i32], [3 x i32]* %350, i64 0, i64 0
store i32 %349, i32* %351
%352 = load i32, i32* %5
%353 = getelementptr inbounds [3 x i32], [3 x i32]* %348, i64 0
%354 = getelementptr inbounds [3 x i32], [3 x i32]* %353, i64 0, i64 1
store i32 %352, i32* %354
%355 = load i32, i32* %9
%356 = getelementptr inbounds [3 x i32], [3 x i32]* %348, i64 0
%357 = getelementptr inbounds [3 x i32], [3 x i32]* %356, i64 0, i64 2
store i32 %355, i32* %357
store i32 1, i32* %6
br label %358
358: ; preds = %411, %344
%359 = load i32, i32* %6
%360 = load i32, i32* %8
%361 = add nsw i32 %360, 1
%362 = icmp slt i32 %359, %361
br i1 %362, label %363, label %414
363: ; preds = %358
store i32 0, i32* %7
br label %364
364: ; preds = %407, %363
%365 = load i32, i32* %7
%366 = icmp slt i32 %365, 3
br i1 %366, label %367, label %410
367: ; preds = %364
%368 = load i32, i32* %7
%369 = icmp ne i32 %368, 2
br i1 %369, label %370, label %384
370: ; preds = %367
%371 = load i32, i32* %6
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds [3 x i32], [3 x i32]* %160, i64 %372
%374 = load i32, i32* %7
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds [3 x i32], [3 x i32]* %373, i64 0, i64 %375
%377 = load i32, i32* %376
%378 = load i32, i32* %6
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds [3 x i32], [3 x i32]* %348, i64 %379
%381 = load i32, i32* %7
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds [3 x i32], [3 x i32]* %380, i64 0, i64 %382
store i32 %377, i32* %383
br label %406
384: ; preds = %367
%385 = load i32, i32* %6
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds [3 x i32], [3 x i32]* %160, i64 %386
%388 = load i32, i32* %7
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds [3 x i32], [3 x i32]* %387, i64 0, i64 %389
%391 = load i32, i32* %390
%392 = load i32, i32* %6
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds [3 x i32], [3 x i32]* %164, i64 %393
%395 = load i32, i32* %7
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds [3 x i32], [3 x i32]* %394, i64 0, i64 %396
%398 = load i32, i32* %397
%399 = add nsw i32 %391, %398
%400 = load i32, i32* %6
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds [3 x i32], [3 x i32]* %348, i64 %401
%403 = load i32, i32* %7
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds [3 x i32], [3 x i32]* %402, i64 0, i64 %404
store i32 %399, i32* %405
br label %406
406: ; preds = %384, %370
br label %407
407: ; preds = %406
%408 = load i32, i32* %7
%409 = add nsw i32 %408, 1
store i32 %409, i32* %7
br label %364
410: ; preds = %364
br label %411
411: ; preds = %410
%412 = load i32, i32* %6
%413 = add nsw i32 %412, 1
store i32 %413, i32* %6
br label %358
414: ; preds = %358
store i32 1, i32* %20
%415 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.9, i64 0, i64 0))
store i32 0, i32* %6
br label %416
416: ; preds = %468, %414
%417 = load i32, i32* %6
%418 = getelementptr inbounds [3 x i32], [3 x i32]* %348, i64 0
%419 = getelementptr inbounds [3 x i32], [3 x i32]* %418, i64 0, i64 0
%420 = load i32, i32* %419
%421 = icmp slt i32 %417, %420
br i1 %421, label %422, label %471
422: ; preds = %416
store i32 0, i32* %21
br label %423
423: ; preds = %463, %422
%424 = load i32, i32* %21
%425 = getelementptr inbounds [3 x i32], [3 x i32]* %348, i64 0
%426 = getelementptr inbounds [3 x i32], [3 x i32]* %425, i64 0, i64 1
%427 = load i32, i32* %426
%428 = icmp slt i32 %424, %427
br i1 %428, label %429, label %466
429: ; preds = %423
%430 = load i32, i32* %6
%431 = load i32, i32* %20
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds [3 x i32], [3 x i32]* %348, i64 %432
%434 = getelementptr inbounds [3 x i32], [3 x i32]* %433, i64 0, i64 0
%435 = load i32, i32* %434
%436 = icmp eq i32 %430, %435
br i1 %436, label %437, label %460
437: ; preds = %429
%438 = load i32, i32* %21
%439 = load i32, i32* %20
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds [3 x i32], [3 x i32]* %348, i64 %440
%442 = getelementptr inbounds [3 x i32], [3 x i32]* %441, i64 0, i64 1
%443 = load i32, i32* %442
%444 = icmp eq i32 %438, %443
br i1 %444, label %445, label %460
445: ; preds = %437
%446 = load i32, i32* %20
%447 = getelementptr inbounds [3 x i32], [3 x i32]* %348, i64 0
%448 = getelementptr inbounds [3 x i32], [3 x i32]* %447, i64 0, i64 2
%449 = load i32, i32* %448
%450 = icmp sle i32 %446, %449
br i1 %450, label %451, label %460
451: ; preds = %445
%452 = load i32, i32* %20
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds [3 x i32], [3 x i32]* %348, i64 %453
%455 = getelementptr inbounds [3 x i32], [3 x i32]* %454, i64 0, i64 2
%456 = load i32, i32* %455
%457 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), i32 %456)
%458 = load i32, i32* %20
%459 = add nsw i32 %458, 1
store i32 %459, i32* %20
br label %462
460: ; preds = %445, %437, %429
%461 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0))
br label %462
462: ; preds = %460, %451
br label %463
463: ; preds = %462
%464 = load i32, i32* %21
%465 = add nsw i32 %464, 1
store i32 %465, i32* %21
br label %423
466: ; preds = %423
%467 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %468
468: ; preds = %466
%469 = load i32, i32* %6
%470 = add nsw i32 %469, 1
store i32 %470, i32* %6
br label %416
471: ; preds = %416
store i32 0, i32* %1
%472 = load i8*, i8** %10
%473 = load i32, i32* %1
ret i32 %473
}

LLVM IR (-O2):
@.str = [38 x i8] c"Enter no. of rows for first matrix = \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [41 x i8] c"Enter no. of columns for first matrix = \00"
@.str.3 = [39 x i8] c"Enter no. of rows for second matrix = \00"
@.str.4 = [42 x i8] c"Enter no. of columns for second matrix = \00"
@.str.6 = [4 x i8] c"%d \00"
@.str.10 = [4 x i8] c"%d\09\00"
@.str.11 = [3 x i8] c"0\09\00"
@str = [33 x i8] c"values of 1st sparse matix are:-\00"
@str.12 = [33 x i8] c"values of 2nd sparse matix are:-\00"
@str.13 = [14 x i8] c"Final matrix=\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = bitcast i32* %1 to i8*
%6 = bitcast i32* %2 to i8*
%7 = bitcast i32* %3 to i8*
%8 = bitcast i32* %4 to i8*
%9 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0))
%10 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %1)
%11 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.2, i64 0, i64 0))
%12 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %2)
%13 = load i32, i32* %1
%14 = zext i32 %13 to i64
%15 = load i32, i32* %2
%16 = zext i32 %15 to i64
%17 = call i8* @llvm.stacksave()
%18 = mul nuw i64 %16, %14
%19 = alloca i32, i64 %18
%20 = load i32, i32* %1
%21 = icmp sgt i32 %20, 0
br i1 %21, label %22, label %48
22: ; preds = %0
%23 = load i32, i32* %2
br label %24
24: ; preds = %22, %42
%25 = phi i32 [ %20, %22 ], [ %43, %42 ]
%26 = phi i32 [ %23, %22 ], [ %44, %42 ]
%27 = phi i64 [ 0, %22 ], [ %45, %42 ]
%28 = icmp sgt i32 %26, 0
br i1 %28, label %29, label %42
29: ; preds = %24
%30 = mul nuw nsw i64 %27, %16
%31 = getelementptr inbounds i32, i32* %19, i64 %30
br label %32
32: ; preds = %29, %32
%33 = phi i64 [ 0, %29 ], [ %36, %32 ]
%34 = getelementptr inbounds i32, i32* %31, i64 %33
%35 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %34)
%36 = add nuw nsw i64 %33, 1
%37 = load i32, i32* %2
%38 = sext i32 %37 to i64
%39 = icmp slt i64 %36, %38
br i1 %39, label %32, label %40
40: ; preds = %32
%41 = load i32, i32* %1
br label %42
42: ; preds = %40, %24
%43 = phi i32 [ %41, %40 ], [ %25, %24 ]
%44 = phi i32 [ %37, %40 ], [ %26, %24 ]
%45 = add nuw nsw i64 %27, 1
%46 = sext i32 %43 to i64
%47 = icmp slt i64 %45, %46
br i1 %47, label %24, label %48
48: ; preds = %42, %0
%49 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.3, i64 0, i64 0))
%50 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %3)
%51 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.4, i64 0, i64 0))
%52 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %4)
%53 = load i32, i32* %3
%54 = zext i32 %53 to i64
%55 = load i32, i32* %4
%56 = zext i32 %55 to i64
%57 = mul nuw i64 %56, %54
%58 = alloca i32, i64 %57
%59 = icmp sgt i32 %53, 0
br i1 %59, label %60, label %68
60: ; preds = %48, %99
%61 = phi i32 [ %100, %99 ], [ %53, %48 ]
%62 = phi i32 [ %101, %99 ], [ %55, %48 ]
%63 = phi i64 [ %102, %99 ], [ 0, %48 ]
%64 = icmp sgt i32 %62, 0
br i1 %64, label %65, label %99
65: ; preds = %60
%66 = mul nuw nsw i64 %63, %56
%67 = getelementptr inbounds i32, i32* %58, i64 %66
br label %89
68: ; preds = %99, %48
%69 = phi i32 [ %55, %48 ], [ %101, %99 ]
%70 = phi i32 [ %53, %48 ], [ %100, %99 ]
%71 = load i32, i32* %1
%72 = icmp sgt i32 %71, 0
br i1 %72, label %73, label %173
73: ; preds = %68
%74 = load i32, i32* %2
%75 = icmp sgt i32 %74, 0
%76 = zext i32 %71 to i64
%77 = zext i32 %74 to i64
%78 = and i64 %77, 4294967288
%79 = add nsw i64 %78, -8
%80 = lshr exact i64 %79, 3
%81 = add nuw nsw i64 %80, 1
%82 = icmp ult i32 %74, 8
%83 = and i64 %77, 4294967288
%84 = and i64 %81, 1
%85 = icmp eq i64 %79, 0
%86 = and i64 %81, 4611686018427387902
%87 = icmp eq i64 %84, 0
%88 = icmp eq i64 %83, %77
br label %105
89: ; preds = %65, %89
%90 = phi i64 [ 0, %65 ], [ %93, %89 ]
%91 = getelementptr inbounds i32, i32* %67, i64 %90
%92 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %91)
%93 = add nuw nsw i64 %90, 1
%94 = load i32, i32* %4
%95 = sext i32 %94 to i64
%96 = icmp slt i64 %93, %95
br i1 %96, label %89, label %97
97: ; preds = %89
%98 = load i32, i32* %3
br label %99
99: ; preds = %97, %60
%100 = phi i32 [ %98, %97 ], [ %61, %60 ]
%101 = phi i32 [ %94, %97 ], [ %62, %60 ]
%102 = add nuw nsw i64 %63, 1
%103 = sext i32 %100 to i64
%104 = icmp slt i64 %102, %103
br i1 %104, label %60, label %68
105: ; preds = %73, %201
%106 = phi i64 [ 0, %73 ], [ %203, %201 ]
%107 = phi i32 [ 0, %73 ], [ %202, %201 ]
br i1 %75, label %108, label %201
108: ; preds = %105
%109 = mul nuw nsw i64 %106, %16
%110 = getelementptr inbounds i32, i32* %19, i64 %109
br i1 %82, label %170, label %111
111: ; preds = %108
%112 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %107, i64 0
br i1 %85, label %146, label %113
113: ; preds = %111, %113
%114 = phi i64 [ %143, %113 ], [ 0, %111 ]
%115 = phi <4 x i32> [ %141, %113 ], [ %112, %111 ]
%116 = phi <4 x i32> [ %142, %113 ], [ zeroinitializer, %111 ]
%117 = phi i64 [ %144, %113 ], [ 0, %111 ]
%118 = getelementptr inbounds i32, i32* %110, i64 %114
%119 = bitcast i32* %118 to <4 x i32>*
%120 = load <4 x i32>, <4 x i32>* %119
%121 = getelementptr inbounds i32, i32* %118, i64 4
%122 = bitcast i32* %121 to <4 x i32>*
%123 = load <4 x i32>, <4 x i32>* %122
%124 = icmp ne <4 x i32> %120, zeroinitializer
%125 = icmp ne <4 x i32> %123, zeroinitializer
%126 = zext <4 x i1> %124 to <4 x i32>
%127 = zext <4 x i1> %125 to <4 x i32>
%128 = add <4 x i32> %115, %126
%129 = add <4 x i32> %116, %127
%130 = or i64 %114, 8
%131 = getelementptr inbounds i32, i32* %110, i64 %130
%132 = bitcast i32* %131 to <4 x i32>*
%133 = load <4 x i32>, <4 x i32>* %132
%134 = getelementptr inbounds i32, i32* %131, i64 4
%135 = bitcast i32* %134 to <4 x i32>*
%136 = load <4 x i32>, <4 x i32>* %135
%137 = icmp ne <4 x i32> %133, zeroinitializer
%138 = icmp ne <4 x i32> %136, zeroinitializer
%139 = zext <4 x i1> %137 to <4 x i32>
%140 = zext <4 x i1> %138 to <4 x i32>
%141 = add <4 x i32> %128, %139
%142 = add <4 x i32> %129, %140
%143 = add nuw i64 %114, 16
%144 = add i64 %117, 2
%145 = icmp eq i64 %144, %86
br i1 %145, label %146, label %113
146: ; preds = %113, %111
%147 = phi <4 x i32> [ undef, %111 ], [ %141, %113 ]
%148 = phi <4 x i32> [ undef, %111 ], [ %142, %113 ]
%149 = phi i64 [ 0, %111 ], [ %143, %113 ]
%150 = phi <4 x i32> [ %112, %111 ], [ %141, %113 ]
%151 = phi <4 x i32> [ zeroinitializer, %111 ], [ %142, %113 ]
br i1 %87, label %165, label %152
152: ; preds = %146
%153 = getelementptr inbounds i32, i32* %110, i64 %149
%154 = bitcast i32* %153 to <4 x i32>*
%155 = load <4 x i32>, <4 x i32>* %154
%156 = getelementptr inbounds i32, i32* %153, i64 4
%157 = bitcast i32* %156 to <4 x i32>*
%158 = load <4 x i32>, <4 x i32>* %157
%159 = icmp ne <4 x i32> %155, zeroinitializer
%160 = icmp ne <4 x i32> %158, zeroinitializer
%161 = zext <4 x i1> %159 to <4 x i32>
%162 = zext <4 x i1> %160 to <4 x i32>
%163 = add <4 x i32> %150, %161
%164 = add <4 x i32> %151, %162
br label %165
165: ; preds = %146, %152
%166 = phi <4 x i32> [ %147, %146 ], [ %163, %152 ]
%167 = phi <4 x i32> [ %148, %146 ], [ %164, %152 ]
%168 = add <4 x i32> %167, %166
%169 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %168)
br i1 %88, label %201, label %170
170: ; preds = %108, %165
%171 = phi i64 [ 0, %108 ], [ %83, %165 ]
%172 = phi i32 [ %107, %108 ], [ %169, %165 ]
br label %191
173: ; preds = %201, %68
%174 = phi i32 [ 0, %68 ], [ %202, %201 ]
%175 = icmp sgt i32 %70, 0
br i1 %175, label %176, label %287
176: ; preds = %173
%177 = icmp sgt i32 %69, 0
%178 = zext i32 %70 to i64
%179 = zext i32 %69 to i64
%180 = and i64 %179, 4294967288
%181 = add nsw i64 %180, -8
%182 = lshr exact i64 %181, 3
%183 = add nuw nsw i64 %182, 1
%184 = icmp ult i32 %69, 8
%185 = and i64 %179, 4294967288
%186 = and i64 %183, 1
%187 = icmp eq i64 %181, 0
%188 = and i64 %183, 4611686018427387902
%189 = icmp eq i64 %186, 0
%190 = icmp eq i64 %185, %179
br label %205
191: ; preds = %170, %191
%192 = phi i64 [ %199, %191 ], [ %171, %170 ]
%193 = phi i32 [ %198, %191 ], [ %172, %170 ]
%194 = getelementptr inbounds i32, i32* %110, i64 %192
%195 = load i32, i32* %194
%196 = icmp ne i32 %195, 0
%197 = zext i1 %196 to i32
%198 = add nsw i32 %193, %197
%199 = add nuw nsw i64 %192, 1
%200 = icmp eq i64 %199, %77
br i1 %200, label %201, label %191
201: ; preds = %191, %165, %105
%202 = phi i32 [ %107, %105 ], [ %169, %165 ], [ %198, %191 ]
%203 = add nuw nsw i64 %106, 1
%204 = icmp eq i64 %203, %76
br i1 %204, label %173, label %105
205: ; preds = %176, %283
%206 = phi i64 [ 0, %176 ], [ %285, %283 ]
%207 = phi i32 [ 0, %176 ], [ %284, %283 ]
br i1 %177, label %208, label %283
208: ; preds = %205
%209 = mul nuw nsw i64 %206, %56
%210 = getelementptr inbounds i32, i32* %58, i64 %209
br i1 %184, label %270, label %211
211: ; preds = %208
%212 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %207, i64 0
br i1 %187, label %246, label %213
213: ; preds = %211, %213
%214 = phi i64 [ %243, %213 ], [ 0, %211 ]
%215 = phi <4 x i32> [ %241, %213 ], [ %212, %211 ]
%216 = phi <4 x i32> [ %242, %213 ], [ zeroinitializer, %211 ]
%217 = phi i64 [ %244, %213 ], [ 0, %211 ]
%218 = getelementptr inbounds i32, i32* %210, i64 %214
%219 = bitcast i32* %218 to <4 x i32>*
%220 = load <4 x i32>, <4 x i32>* %219
%221 = getelementptr inbounds i32, i32* %218, i64 4
%222 = bitcast i32* %221 to <4 x i32>*
%223 = load <4 x i32>, <4 x i32>* %222
%224 = icmp ne <4 x i32> %220, zeroinitializer
%225 = icmp ne <4 x i32> %223, zeroinitializer
%226 = zext <4 x i1> %224 to <4 x i32>
%227 = zext <4 x i1> %225 to <4 x i32>
%228 = add <4 x i32> %215, %226
%229 = add <4 x i32> %216, %227
%230 = or i64 %214, 8
%231 = getelementptr inbounds i32, i32* %210, i64 %230
%232 = bitcast i32* %231 to <4 x i32>*
%233 = load <4 x i32>, <4 x i32>* %232
%234 = getelementptr inbounds i32, i32* %231, i64 4
%235 = bitcast i32* %234 to <4 x i32>*
%236 = load <4 x i32>, <4 x i32>* %235
%237 = icmp ne <4 x i32> %233, zeroinitializer
%238 = icmp ne <4 x i32> %236, zeroinitializer
%239 = zext <4 x i1> %237 to <4 x i32>
%240 = zext <4 x i1> %238 to <4 x i32>
%241 = add <4 x i32> %228, %239
%242 = add <4 x i32> %229, %240
%243 = add nuw i64 %214, 16
%244 = add i64 %217, 2
%245 = icmp eq i64 %244, %188
br i1 %245, label %246, label %213
246: ; preds = %213, %211
%247 = phi <4 x i32> [ undef, %211 ], [ %241, %213 ]
%248 = phi <4 x i32> [ undef, %211 ], [ %242, %213 ]
%249 = phi i64 [ 0, %211 ], [ %243, %213 ]
%250 = phi <4 x i32> [ %212, %211 ], [ %241, %213 ]
%251 = phi <4 x i32> [ zeroinitializer, %211 ], [ %242, %213 ]
br i1 %189, label %265, label %252
252: ; preds = %246
%253 = getelementptr inbounds i32, i32* %210, i64 %249
%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 = icmp ne <4 x i32> %255, zeroinitializer
%260 = icmp ne <4 x i32> %258, zeroinitializer
%261 = zext <4 x i1> %259 to <4 x i32>
%262 = zext <4 x i1> %260 to <4 x i32>
%263 = add <4 x i32> %250, %261
%264 = add <4 x i32> %251, %262
br label %265
265: ; preds = %246, %252
%266 = phi <4 x i32> [ %247, %246 ], [ %263, %252 ]
%267 = phi <4 x i32> [ %248, %246 ], [ %264, %252 ]
%268 = add <4 x i32> %267, %266
%269 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %268)
br i1 %190, label %283, label %270
270: ; preds = %208, %265
%271 = phi i64 [ 0, %208 ], [ %185, %265 ]
%272 = phi i32 [ %207, %208 ], [ %269, %265 ]
br label %273
273: ; preds = %270, %273
%274 = phi i64 [ %281, %273 ], [ %271, %270 ]
%275 = phi i32 [ %280, %273 ], [ %272, %270 ]
%276 = getelementptr inbounds i32, i32* %210, i64 %274
%277 = load i32, i32* %276
%278 = icmp ne i32 %277, 0
%279 = zext i1 %278 to i32
%280 = add nsw i32 %275, %279
%281 = add nuw nsw i64 %274, 1
%282 = icmp eq i64 %281, %179
br i1 %282, label %283, label %273
283: ; preds = %273, %265, %205
%284 = phi i32 [ %207, %205 ], [ %269, %265 ], [ %280, %273 ]
%285 = add nuw nsw i64 %206, 1
%286 = icmp eq i64 %285, %178
br i1 %286, label %287, label %205
287: ; preds = %283, %173
%288 = phi i32 [ 0, %173 ], [ %284, %283 ]
%289 = add i32 %174, 1
%290 = zext i32 %289 to i64
%291 = alloca [3 x i32], i64 %290
%292 = add i32 %288, 1
%293 = zext i32 %292 to i64
%294 = alloca [3 x i32], i64 %293
%295 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 0, i64 0
store i32 %71, i32* %295
%296 = load i32, i32* %2
%297 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 0, i64 1
store i32 %296, i32* %297
%298 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 0, i64 2
store i32 %174, i32* %298
%299 = getelementptr inbounds [3 x i32], [3 x i32]* %294, i64 0, i64 0
store i32 %70, i32* %299
%300 = getelementptr inbounds [3 x i32], [3 x i32]* %294, i64 0, i64 1
store i32 %69, i32* %300
%301 = getelementptr inbounds [3 x i32], [3 x i32]* %294, i64 0, i64 2
store i32 %288, i32* %301
br i1 %72, label %302, label %313
302: ; preds = %287
%303 = icmp sgt i32 %296, 0
%304 = zext i32 %71 to i64
%305 = zext i32 %296 to i64
br label %306
306: ; preds = %302, %335
%307 = phi i64 [ 0, %302 ], [ %337, %335 ]
%308 = phi i32 [ 1, %302 ], [ %336, %335 ]
br i1 %303, label %309, label %335
309: ; preds = %306
%310 = mul nuw nsw i64 %307, %16
%311 = getelementptr inbounds i32, i32* %19, i64 %310
%312 = trunc i64 %307 to i32
br label %318
313: ; preds = %335, %287
br i1 %175, label %314, label %367
314: ; preds = %313
%315 = icmp sgt i32 %69, 0
%316 = zext i32 %70 to i64
%317 = zext i32 %69 to i64
br label %339
318: ; preds = %309, %331
%319 = phi i64 [ 0, %309 ], [ %333, %331 ]
%320 = phi i32 [ %308, %309 ], [ %332, %331 ]
%321 = getelementptr inbounds i32, i32* %311, i64 %319
%322 = load i32, i32* %321
%323 = icmp eq i32 %322, 0
br i1 %323, label %331, label %324
324: ; preds = %318
%325 = sext i32 %320 to i64
%326 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 %325, i64 0
store i32 %312, i32* %326
%327 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 %325, i64 1
%328 = trunc i64 %319 to i32
store i32 %328, i32* %327
%329 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 %325, i64 2
store i32 %322, i32* %329
%330 = add nsw i32 %320, 1
br label %331
331: ; preds = %318, %324
%332 = phi i32 [ %330, %324 ], [ %320, %318 ]
%333 = add nuw nsw i64 %319, 1
%334 = icmp eq i64 %333, %305
br i1 %334, label %335, label %318
335: ; preds = %331, %306
%336 = phi i32 [ %308, %306 ], [ %332, %331 ]
%337 = add nuw nsw i64 %307, 1
%338 = icmp eq i64 %337, %304
br i1 %338, label %313, label %306
339: ; preds = %314, %363
%340 = phi i64 [ 0, %314 ], [ %365, %363 ]
%341 = phi i32 [ 1, %314 ], [ %364, %363 ]
br i1 %315, label %342, label %363
342: ; preds = %339
%343 = mul nuw nsw i64 %340, %56
%344 = getelementptr inbounds i32, i32* %58, i64 %343
%345 = trunc i64 %340 to i32
br label %346
346: ; preds = %342, %359
%347 = phi i64 [ 0, %342 ], [ %361, %359 ]
%348 = phi i32 [ %341, %342 ], [ %360, %359 ]
%349 = getelementptr inbounds i32, i32* %344, i64 %347
%350 = load i32, i32* %349
%351 = icmp eq i32 %350, 0
br i1 %351, label %359, label %352
352: ; preds = %346
%353 = sext i32 %348 to i64
%354 = getelementptr inbounds [3 x i32], [3 x i32]* %294, i64 %353, i64 0
store i32 %345, i32* %354
%355 = getelementptr inbounds [3 x i32], [3 x i32]* %294, i64 %353, i64 1
%356 = trunc i64 %347 to i32
store i32 %356, i32* %355
%357 = getelementptr inbounds [3 x i32], [3 x i32]* %294, i64 %353, i64 2
store i32 %350, i32* %357
%358 = add nsw i32 %348, 1
br label %359
359: ; preds = %346, %352
%360 = phi i32 [ %358, %352 ], [ %348, %346 ]
%361 = add nuw nsw i64 %347, 1
%362 = icmp eq i64 %361, %317
br i1 %362, label %363, label %346
363: ; preds = %359, %339
%364 = phi i32 [ %341, %339 ], [ %360, %359 ]
%365 = add nuw nsw i64 %340, 1
%366 = icmp eq i64 %365, %316
br i1 %366, label %367, label %339
367: ; preds = %363, %313
%368 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str, i64 0, i64 0))
%369 = icmp slt i32 %174, 0
br i1 %369, label %384, label %370
370: ; preds = %367, %370
%371 = phi i64 [ %382, %370 ], [ 0, %367 ]
%372 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 %371, i64 0
%373 = load i32, i32* %372
%374 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %373)
%375 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 %371, i64 1
%376 = load i32, i32* %375
%377 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %376)
%378 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 %371, i64 2
%379 = load i32, i32* %378
%380 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %379)
%381 = call i32 @putchar(i32 10)
%382 = add nuw nsw i64 %371, 1
%383 = icmp eq i64 %382, %290
br i1 %383, label %384, label %370
384: ; preds = %370, %367
%385 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str.12, i64 0, i64 0))
%386 = icmp slt i32 %288, 0
br i1 %386, label %401, label %387
387: ; preds = %384, %387
%388 = phi i64 [ %399, %387 ], [ 0, %384 ]
%389 = getelementptr inbounds [3 x i32], [3 x i32]* %294, i64 %388, i64 0
%390 = load i32, i32* %389
%391 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %390)
%392 = getelementptr inbounds [3 x i32], [3 x i32]* %294, i64 %388, i64 1
%393 = load i32, i32* %392
%394 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %393)
%395 = getelementptr inbounds [3 x i32], [3 x i32]* %294, i64 %388, i64 2
%396 = load i32, i32* %395
%397 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %396)
%398 = call i32 @putchar(i32 10)
%399 = add nuw nsw i64 %388, 1
%400 = icmp eq i64 %399, %293
br i1 %400, label %401, label %387
401: ; preds = %387, %384
%402 = alloca [3 x i32], i64 %290
%403 = load i32, i32* %3
%404 = getelementptr inbounds [3 x i32], [3 x i32]* %402, i64 0, i64 0
store i32 %403, i32* %404
%405 = load i32, i32* %4
%406 = getelementptr inbounds [3 x i32], [3 x i32]* %402, i64 0, i64 1
store i32 %405, i32* %406
%407 = getelementptr inbounds [3 x i32], [3 x i32]* %402, i64 0, i64 2
store i32 %288, i32* %407
%408 = icmp slt i32 %174, 1
br i1 %408, label %425, label %409
409: ; preds = %401, %409
%410 = phi i64 [ %423, %409 ], [ 1, %401 ]
%411 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 %410, i64 2
%412 = getelementptr inbounds [3 x i32], [3 x i32]* %294, i64 %410, i64 2
%413 = getelementptr inbounds [3 x i32], [3 x i32]* %402, i64 %410, i64 2
%414 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 %410, i64 0
%415 = load i32, i32* %414
%416 = getelementptr inbounds [3 x i32], [3 x i32]* %402, i64 %410, i64 0
store i32 %415, i32* %416
%417 = getelementptr inbounds [3 x i32], [3 x i32]* %291, i64 %410, i64 1
%418 = load i32, i32* %417
%419 = getelementptr inbounds [3 x i32], [3 x i32]* %402, i64 %410, i64 1
store i32 %418, i32* %419
%420 = load i32, i32* %411
%421 = load i32, i32* %412
%422 = add nsw i32 %421, %420
store i32 %422, i32* %413
%423 = add nuw nsw i64 %410, 1
%424 = icmp eq i64 %423, %290
br i1 %424, label %425, label %409
425: ; preds = %409, %401
%426 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @str.13, i64 0, i64 0))
%427 = icmp sgt i32 %403, 0
br i1 %427, label %428, label %462
428: ; preds = %425
%429 = icmp sgt i32 %405, 0
br label %430
430: ; preds = %428, %433
%431 = phi i32 [ 1, %428 ], [ %434, %433 ]
%432 = phi i32 [ 0, %428 ], [ %436, %433 ]
br i1 %429, label %438, label %433
433: ; preds = %458, %430
%434 = phi i32 [ %431, %430 ], [ %459, %458 ]
%435 = call i32 @putchar(i32 10)
%436 = add nuw nsw i32 %432, 1
%437 = icmp eq i32 %436, %403
br i1 %437, label %462, label %430
438: ; preds = %430, %458
%439 = phi i32 [ %460, %458 ], [ 0, %430 ]
%440 = phi i32 [ %459, %458 ], [ %431, %430 ]
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds [3 x i32], [3 x i32]* %402, i64 %441, i64 0
%443 = load i32, i32* %442
%444 = icmp eq i32 %432, %443
br i1 %444, label %445, label %456
445: ; preds = %438
%446 = getelementptr inbounds [3 x i32], [3 x i32]* %402, i64 %441, i64 1
%447 = load i32, i32* %446
%448 = icmp ne i32 %439, %447
%449 = icmp sgt i32 %440, %288
%450 = select i1 %448, i1 true, i1 %449
br i1 %450, label %456, label %451
451: ; preds = %445
%452 = getelementptr inbounds [3 x i32], [3 x i32]* %402, i64 %441, i64 2
%453 = load i32, i32* %452
%454 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), i32 %453)
%455 = add nsw i32 %440, 1
br label %458
456: ; preds = %445, %438
%457 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0))
br label %458
458: ; preds = %451, %456
%459 = phi i32 [ %455, %451 ], [ %440, %456 ]
%460 = add nuw nsw i32 %439, 1
%461 = icmp eq i32 %460, %405
br i1 %461, label %433, label %438
462: ; preds = %433, %425
ret i32 0
}