#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 /*<<< orphan*/ swap(int *, int *);
int main() {
  int a[50][50];
  int r1[50], r2[50], r3[50], r4[50];
  int n = 4;
  printf("Dati un numar n natural ");
  scanf("%d", &n);
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      printf("a[%d][%d]= ", i, j);
      scanf("%d", &a[i][j]);
    }
  }
  printf("Citirea matricei a fost realizata! \n");
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      printf("%d ", a[i][j]);
    }
    printf("\n");
  }
  int k1 = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      if (i + j >= n && i > j) {
        r1[k1] = a[i][j];
        ++k1;
      }
    }
  }
  int k2 = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      if (i + j < n - 1 && i > j) {
        r2[k2] = a[i][j];
        ++k2;
      }
    }
  }
  int k3 = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      if (i + j < n - 1 && i < j) {
        r3[k3] = a[i][j];
        ++k3;
      }
    }
  }
  int k4 = 0;
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      if (i + j >= n && i < j) {
        r4[k4] = a[i][j];
        ++k4;
      }
    }
  }
  int max = r1[0];
  for (int i = 1; i < k1; ++i) {
    if (r1[i] > max) {
      max = r1[i];
    }
  }
  printf("Maximul din regiunea 1 este %d\n", max);
  int min = r2[0];
  for (int i = 0; i < k2; ++i) {
    if (r2[i] < min) {
      min = r2[i];
    }
  }
  printf("Minimul din regiunea 2 este %d\n", min);
  int suma = 0;
  for (int i = 0; i < k3; ++i) {
    suma += r3[i];
  }
  printf("Suma elementelor din regiunea 3 este %d\n", suma);
  int produs = 1;
  for (int i = 0; i < k4; ++i) {
    produs *= r4[i];
  }
  printf("Produsul elementelor din regiunea 4 este %d\n", produs);
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      if (i + j >= n && i > j) {
        swap(&a[i][j], &a[n - i - 1][j]);
      }
    }
  }
  printf("Interschimbare intre regiunea 1 si regiunea 3\n");
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      printf("%d ", a[i][j]);
    }
    printf("\n");
  }
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      if (i + j < n - 1 && i > j) {
        swap(&a[i][j], &a[i][n - j - 1]);
      }
    }
  }
  printf("Interschimbare intre regiunea 1 si regiunea 3\n");
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      printf("%d ", a[i][j]);
    }
    printf("\n");
  }
  printf("Exit...\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2af0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x4,-0x2a64(%rbp)
lea    0xead(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeb8(%rip),%rdi
lea    -0x2a64(%rbp),%rsi
call   1040 <scanf@plt>
movl   $0x0,-0x2a68(%rbp)
mov    -0x2a68(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    121e <main+0xee>
movl   $0x0,-0x2a6c(%rbp)
mov    -0x2a6c(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    1205 <main+0xd5>
mov    -0x2a68(%rbp),%esi
mov    -0x2a6c(%rbp),%edx
lea    0xe64(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movslq -0x2a68(%rbp),%rax
lea    -0x2720(%rbp),%rsi
imul   $0xc8,%rax,%rax
add    %rax,%rsi
movslq -0x2a6c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe2d(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x2a6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a6c(%rbp)
jmp    1193 <main+0x63>
jmp    120a <main+0xda>
mov    -0x2a68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a68(%rbp)
jmp    1177 <main+0x47>
lea    0xe03(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2a70(%rbp)
mov    -0x2a70(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    12ca <main+0x19a>
movl   $0x0,-0x2a74(%rbp)
mov    -0x2a74(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    12a8 <main+0x178>
movslq -0x2a70(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a74(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xdc0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x2a74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a74(%rbp)
jmp    1252 <main+0x122>
lea    0xd9c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x2a70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a70(%rbp)
jmp    1236 <main+0x106>
movl   $0x0,-0x2a78(%rbp)
movl   $0x0,-0x2a7c(%rbp)
mov    -0x2a7c(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    13a7 <main+0x277>
movl   $0x0,-0x2a80(%rbp)
mov    -0x2a80(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    138e <main+0x25e>
mov    -0x2a7c(%rbp),%eax
add    -0x2a80(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jl     1375 <main+0x245>
mov    -0x2a7c(%rbp),%eax
cmp    -0x2a80(%rbp),%eax
jle    1375 <main+0x245>
movslq -0x2a7c(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a80(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x2a78(%rbp),%rax
mov    %ecx,-0x27f0(%rbp,%rax,4)
mov    -0x2a78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a78(%rbp)
jmp    137a <main+0x24a>
mov    -0x2a80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a80(%rbp)
jmp    12fa <main+0x1ca>
jmp    1393 <main+0x263>
mov    -0x2a7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a7c(%rbp)
jmp    12de <main+0x1ae>
movl   $0x0,-0x2a84(%rbp)
movl   $0x0,-0x2a88(%rbp)
mov    -0x2a88(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    1489 <main+0x359>
movl   $0x0,-0x2a8c(%rbp)
mov    -0x2a8c(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    1470 <main+0x340>
mov    -0x2a88(%rbp),%eax
add    -0x2a8c(%rbp),%eax
mov    -0x2a64(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1457 <main+0x327>
mov    -0x2a88(%rbp),%eax
cmp    -0x2a8c(%rbp),%eax
jle    1457 <main+0x327>
movslq -0x2a88(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a8c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x2a84(%rbp),%rax
mov    %ecx,-0x28c0(%rbp,%rax,4)
mov    -0x2a84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a84(%rbp)
jmp    145c <main+0x32c>
mov    -0x2a8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a8c(%rbp)
jmp    13d7 <main+0x2a7>
jmp    1475 <main+0x345>
mov    -0x2a88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a88(%rbp)
jmp    13bb <main+0x28b>
movl   $0x0,-0x2a90(%rbp)
movl   $0x0,-0x2a94(%rbp)
mov    -0x2a94(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    156b <main+0x43b>
movl   $0x0,-0x2a98(%rbp)
mov    -0x2a98(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    1552 <main+0x422>
mov    -0x2a94(%rbp),%eax
add    -0x2a98(%rbp),%eax
mov    -0x2a64(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1539 <main+0x409>
mov    -0x2a94(%rbp),%eax
cmp    -0x2a98(%rbp),%eax
jge    1539 <main+0x409>
movslq -0x2a94(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2a98(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x2a90(%rbp),%rax
mov    %ecx,-0x2990(%rbp,%rax,4)
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    153e <main+0x40e>
mov    -0x2a98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a98(%rbp)
jmp    14b9 <main+0x389>
jmp    1557 <main+0x427>
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    149d <main+0x36d>
movl   $0x0,-0x2a9c(%rbp)
movl   $0x0,-0x2aa0(%rbp)
mov    -0x2aa0(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    1648 <main+0x518>
movl   $0x0,-0x2aa4(%rbp)
mov    -0x2aa4(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    162f <main+0x4ff>
mov    -0x2aa0(%rbp),%eax
add    -0x2aa4(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jl     1616 <main+0x4e6>
mov    -0x2aa0(%rbp),%eax
cmp    -0x2aa4(%rbp),%eax
jge    1616 <main+0x4e6>
movslq -0x2aa0(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2aa4(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x2a9c(%rbp),%rax
mov    %ecx,-0x2a60(%rbp,%rax,4)
mov    -0x2a9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a9c(%rbp)
jmp    161b <main+0x4eb>
mov    -0x2aa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2aa4(%rbp)
jmp    159b <main+0x46b>
jmp    1634 <main+0x504>
mov    -0x2aa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2aa0(%rbp)
jmp    157f <main+0x44f>
mov    -0x27f0(%rbp),%eax
mov    %eax,-0x2aa8(%rbp)
movl   $0x1,-0x2aac(%rbp)
mov    -0x2aac(%rbp),%eax
cmp    -0x2a78(%rbp),%eax
jge    16b7 <main+0x587>
movslq -0x2aac(%rbp),%rax
mov    -0x27f0(%rbp,%rax,4),%eax
cmp    -0x2aa8(%rbp),%eax
jle    169e <main+0x56e>
movslq -0x2aac(%rbp),%rax
mov    -0x27f0(%rbp,%rax,4),%eax
mov    %eax,-0x2aa8(%rbp)
jmp    16a3 <main+0x573>
mov    -0x2aac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2aac(%rbp)
jmp    165e <main+0x52e>
mov    -0x2aa8(%rbp),%esi
lea    0x98d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x28c0(%rbp),%eax
mov    %eax,-0x2ab0(%rbp)
movl   $0x0,-0x2ab4(%rbp)
mov    -0x2ab4(%rbp),%eax
cmp    -0x2a84(%rbp),%eax
jge    173a <main+0x60a>
movslq -0x2ab4(%rbp),%rax
mov    -0x28c0(%rbp,%rax,4),%eax
cmp    -0x2ab0(%rbp),%eax
jge    1721 <main+0x5f1>
movslq -0x2ab4(%rbp),%rax
mov    -0x28c0(%rbp,%rax,4),%eax
mov    %eax,-0x2ab0(%rbp)
jmp    1726 <main+0x5f6>
mov    -0x2ab4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ab4(%rbp)
jmp    16e1 <main+0x5b1>
mov    -0x2ab0(%rbp),%esi
lea    0x92a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2ab8(%rbp)
movl   $0x0,-0x2abc(%rbp)
mov    -0x2abc(%rbp),%eax
cmp    -0x2a90(%rbp),%eax
jge    17a2 <main+0x672>
movslq -0x2abc(%rbp),%rax
mov    -0x2990(%rbp,%rax,4),%eax
add    -0x2ab8(%rbp),%eax
mov    %eax,-0x2ab8(%rbp)
mov    -0x2abc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2abc(%rbp)
jmp    1762 <main+0x632>
mov    -0x2ab8(%rbp),%esi
lea    0x8e2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x2ac0(%rbp)
movl   $0x0,-0x2ac4(%rbp)
mov    -0x2ac4(%rbp),%eax
cmp    -0x2a9c(%rbp),%eax
jge    180b <main+0x6db>
movslq -0x2ac4(%rbp),%rax
mov    -0x2a60(%rbp,%rax,4),%eax
imul   -0x2ac0(%rbp),%eax
mov    %eax,-0x2ac0(%rbp)
mov    -0x2ac4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ac4(%rbp)
jmp    17ca <main+0x69a>
mov    -0x2ac0(%rbp),%esi
lea    0x8a2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2ac8(%rbp)
mov    -0x2ac8(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    190e <main+0x7de>
movl   $0x0,-0x2acc(%rbp)
mov    -0x2acc(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    18f5 <main+0x7c5>
mov    -0x2ac8(%rbp),%eax
add    -0x2acc(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jl     18dc <main+0x7ac>
mov    -0x2ac8(%rbp),%eax
cmp    -0x2acc(%rbp),%eax
jle    18dc <main+0x7ac>
movslq -0x2ac8(%rbp),%rax
lea    -0x2720(%rbp),%rdi
imul   $0xc8,%rax,%rax
add    %rax,%rdi
movslq -0x2acc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x2a64(%rbp),%eax
sub    -0x2ac8(%rbp),%eax
sub    $0x1,%eax
cltq
lea    -0x2720(%rbp),%rsi
imul   $0xc8,%rax,%rax
add    %rax,%rsi
movslq -0x2acc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
call   1050 <swap@plt>
jmp    18e1 <main+0x7b1>
mov    -0x2acc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2acc(%rbp)
jmp    1845 <main+0x715>
jmp    18fa <main+0x7ca>
mov    -0x2ac8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ac8(%rbp)
jmp    1829 <main+0x6f9>
lea    0x7d2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2ad0(%rbp)
mov    -0x2ad0(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    19ba <main+0x88a>
movl   $0x0,-0x2ad4(%rbp)
mov    -0x2ad4(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    1998 <main+0x868>
movslq -0x2ad0(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2ad4(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x6d0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x2ad4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ad4(%rbp)
jmp    1942 <main+0x812>
lea    0x6ac(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x2ad0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ad0(%rbp)
jmp    1926 <main+0x7f6>
movl   $0x0,-0x2ad8(%rbp)
mov    -0x2ad8(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    1aae <main+0x97e>
movl   $0x0,-0x2adc(%rbp)
mov    -0x2adc(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    1a95 <main+0x965>
mov    -0x2ad8(%rbp),%eax
add    -0x2adc(%rbp),%eax
mov    -0x2a64(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1a7c <main+0x94c>
mov    -0x2ad8(%rbp),%eax
cmp    -0x2adc(%rbp),%eax
jle    1a7c <main+0x94c>
movslq -0x2ad8(%rbp),%rax
lea    -0x2720(%rbp),%rdi
imul   $0xc8,%rax,%rax
add    %rax,%rdi
movslq -0x2adc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x2ad8(%rbp),%rax
lea    -0x2720(%rbp),%rsi
imul   $0xc8,%rax,%rax
add    %rax,%rsi
mov    -0x2a64(%rbp),%eax
sub    -0x2adc(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
call   1050 <swap@plt>
jmp    1a81 <main+0x951>
mov    -0x2adc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2adc(%rbp)
jmp    19e0 <main+0x8b0>
jmp    1a9a <main+0x96a>
mov    -0x2ad8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ad8(%rbp)
jmp    19c4 <main+0x894>
lea    0x632(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2ae0(%rbp)
mov    -0x2ae0(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    1b5a <main+0xa2a>
movl   $0x0,-0x2ae4(%rbp)
mov    -0x2ae4(%rbp),%eax
cmp    -0x2a64(%rbp),%eax
jge    1b38 <main+0xa08>
movslq -0x2ae0(%rbp),%rcx
lea    -0x2720(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x2ae4(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x530(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x2ae4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ae4(%rbp)
jmp    1ae2 <main+0x9b2>
lea    0x50c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x2ae0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ae0(%rbp)
jmp    1ac6 <main+0x996>
lea    0x5b5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x2af0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2a68,%rsp
movl   $0x4,0xc(%rsp)
lea    0xea0(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xeab(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1060 <scanf@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    11fe <main+0xae>
lea    0x350(%rsp),%rbp
lea    0xe8d(%rip),%r14
lea    0xe83(%rip),%r15
xor    %r12d,%r12d
jmp    11c3 <main+0x73>
nopl   0x0(%rax,%rax,1)
movslq %eax,%rcx
add    $0x1,%r12
add    $0xc8,%rbp
cmp    %rcx,%r12
jge    11fe <main+0xae>
test   %eax,%eax
jle    11b0 <main+0x60>
mov    %rbp,%r13
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %r14,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r15,%rdi
mov    %r13,%rsi
call   1060 <scanf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
add    $0x4,%r13
cmp    %rax,%rbx
jl     11d0 <main+0x80>
jmp    11b0 <main+0x60>
lea    0xecd(%rip),%rdi
call   1040 <puts@plt>
mov    0xc(%rsp),%r13d
test   %r13d,%r13d
jle    1387 <main+0x237>
lea    0x350(%rsp),%rbp
lea    0xe11(%rip),%r15
xor    %r14d,%r14d
jmp    124f <main+0xff>
nopl   0x0(%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
movslq 0xc(%rsp),%r13
add    $0xc8,%rbp
cmp    %r13,%r14
jge    127e <main+0x12e>
test   %r13d,%r13d
jle    1230 <main+0xe0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp,%rbx,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1260 <main+0x110>
jmp    1230 <main+0xe0>
test   %r13d,%r13d
jle    1387 <main+0x237>
mov    %r13d,%r9d
lea    -0x1(%r9),%r8
mov    %r9d,%r10d
and    $0xfffffffe,%r10d
lea    0x354(%rsp),%rdx
xor    %ebp,%ebp
mov    $0x1,%esi
xor    %ecx,%ecx
jmp    12c8 <main+0x178>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    $0x1,%rsi
add    $0xc8,%rdx
cmp    %r9,%rbp
je     161e <main+0x4ce>
test   %r8,%r8
je     1340 <main+0x1f0>
xor    %ebx,%ebx
jmp    12e9 <main+0x199>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %r10,%rbx
je     1330 <main+0x1e0>
mov    %rbx,%rax
cmp    %rbx,%rbp
jbe    130a <main+0x1ba>
lea    (%rax,%rbp,1),%ebx
cmp    %ebx,%r13d
jg     130a <main+0x1ba>
mov    -0x4(%rdx,%rax,4),%ebx
movslq %ecx,%rcx
mov    %ebx,0x280(%rsp,%rcx,4)
add    $0x1,%ecx
lea    0x1(%rax),%rbx
cmp    %rbx,%rbp
jbe    12e0 <main+0x190>
lea    (%rsi,%rax,1),%edi
cmp    %edi,%r13d
jg     12e0 <main+0x190>
mov    (%rdx,%rax,4),%edi
movslq %ecx,%rcx
mov    %edi,0x280(%rsp,%rcx,4)
add    $0x1,%ecx
jmp    12e0 <main+0x190>
nopl   (%rax)
add    $0x2,%rax
test   $0x1,%r9b
je     12b0 <main+0x160>
jmp    134c <main+0x1fc>
xor    %eax,%eax
test   $0x1,%r9b
je     12b0 <main+0x160>
cmp    %rax,%rbp
jbe    12b0 <main+0x160>
lea    (%rax,%rbp,1),%ebx
cmp    %ebx,%r13d
jg     12b0 <main+0x160>
imul   $0xc8,%rbp,%rbx
add    %rsp,%rbx
add    $0x350,%rbx
mov    (%rbx,%rax,4),%eax
movslq %ecx,%rcx
mov    %eax,0x280(%rsp,%rcx,4)
add    $0x1,%ecx
jmp    12b0 <main+0x160>
mov    0x280(%rsp),%esi
lea    0xca7(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1b0(%rsp),%esi
lea    0xcb2(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xcc4(%rip),%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x1,%esi
lea    0xcd8(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    146b <main+0x31b>
mov    $0xffffffff,%r15d
xor    %r12d,%r12d
lea    0x350(%rsp),%r14
xor    %r13d,%r13d
jmp    1417 <main+0x2c7>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
movslq %eax,%rcx
add    $0xc8,%r12
add    $0xffffffff,%r15d
cmp    %rcx,%r13
jge    146b <main+0x31b>
test   %eax,%eax
jle    1400 <main+0x2b0>
mov    %r14,%rbp
xor    %ebx,%ebx
jmp    1440 <main+0x2f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbx
movslq %eax,%rcx
add    $0x4,%rbp
cmp    %rcx,%rbx
jge    1400 <main+0x2b0>
cmp    %rbx,%r13
jbe    1430 <main+0x2e0>
lea    (%rbx,%r13,1),%ecx
cmp    %ecx,%eax
jg     1430 <main+0x2e0>
lea    (%r12,%rbp,1),%rdi
add    %r15d,%eax
cltq
imul   $0xc8,%rax,%rsi
add    %rbp,%rsi
call   1070 <swap@plt>
mov    0xc(%rsp),%eax
jmp    1430 <main+0x2e0>
lea    0xc84(%rip),%rdi
call   1040 <puts@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    1588 <main+0x438>
lea    0x350(%rsp),%rbp
lea    0xba6(%rip),%r15
xor    %r14d,%r14d
jmp    14bf <main+0x36f>
nopw   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
movslq 0xc(%rsp),%rax
add    $0xc8,%rbp
cmp    %rax,%r14
jge    14ee <main+0x39e>
test   %eax,%eax
jle    14a0 <main+0x350>
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 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     14d0 <main+0x380>
jmp    14a0 <main+0x350>
test   %eax,%eax
jle    1588 <main+0x438>
lea    0x350(%rsp),%r14
xor    %r15d,%r15d
jmp    1523 <main+0x3d3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r15
movslq %eax,%rcx
add    $0xc8,%r14
cmp    %rcx,%r15
jge    1588 <main+0x438>
test   %eax,%eax
jle    1510 <main+0x3c0>
mov    $0xffffffff,%r12d
mov    %r14,%rbx
xor    %ebp,%ebp
jmp    1550 <main+0x400>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
add    $0x4,%rbx
add    $0xffffffff,%r12d
cmp    %ebp,%eax
jle    1510 <main+0x3c0>
cmp    %rbp,%r15
jbe    1540 <main+0x3f0>
lea    -0x1(%rax),%ecx
lea    (%r15,%rbp,1),%edx
cmp    %edx,%ecx
jle    1540 <main+0x3f0>
add    %r12d,%eax
cltq
imul   $0xc8,%r15,%rcx
add    %rsp,%rcx
add    $0x350,%rcx
lea    (%rcx,%rax,4),%rsi
mov    %rbx,%rdi
call   1070 <swap@plt>
mov    0xc(%rsp),%eax
jmp    1540 <main+0x3f0>
lea    0xb67(%rip),%rdi
call   1040 <puts@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    15fe <main+0x4ae>
lea    0x350(%rsp),%rbp
lea    0xa8d(%rip),%r15
xor    %r14d,%r14d
jmp    15cf <main+0x47f>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
movslq 0xc(%rsp),%rax
add    $0xc8,%rbp
cmp    %rax,%r14
jge    15fe <main+0x4ae>
test   %eax,%eax
jle    15b0 <main+0x460>
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 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     15e0 <main+0x490>
jmp    15b0 <main+0x460>
lea    0xb1f(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
add    $0x2a68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r13d,%r13d
jle    18d4 <main+0x784>
lea    -0x1(%r13),%edi
mov    %r9d,%r10d
and    $0xfffffffe,%r10d
lea    0x354(%rsp),%rbp
xor    %esi,%esi
mov    $0x1,%r11d
xor    %r14d,%r14d
jmp    1668 <main+0x518>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
add    $0x1,%r11
add    $0xc8,%rbp
cmp    %r9,%rsi
je     1737 <main+0x5e7>
test   %r8,%r8
je     16f0 <main+0x5a0>
xor    %eax,%eax
jmp    1689 <main+0x539>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
cmp    %r10,%rax
je     16e0 <main+0x590>
mov    %rax,%rdx
cmp    %rax,%rsi
jbe    16ab <main+0x55b>
lea    (%rsi,%rdx,1),%eax
cmp    %eax,%edi
jle    16ab <main+0x55b>
mov    -0x4(%rbp,%rdx,4),%eax
movslq %r14d,%r14
mov    %eax,0x1b0(%rsp,%r14,4)
add    $0x1,%r14d
lea    0x1(%rdx),%rax
cmp    %rax,%rsi
jbe    1680 <main+0x530>
lea    (%r11,%rdx,1),%ebx
cmp    %ebx,%edi
jle    1680 <main+0x530>
mov    0x0(%rbp,%rdx,4),%ebx
movslq %r14d,%r14
mov    %ebx,0x1b0(%rsp,%r14,4)
add    $0x1,%r14d
jmp    1680 <main+0x530>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rdx
test   $0x1,%r9b
je     1650 <main+0x500>
jmp    16fc <main+0x5ac>
xor    %edx,%edx
test   $0x1,%r9b
je     1650 <main+0x500>
cmp    %rdx,%rsi
jbe    1650 <main+0x500>
lea    (%rdx,%rsi,1),%eax
cmp    %eax,%edi
jle    1650 <main+0x500>
imul   $0xc8,%rsi,%rax
add    %rsp,%rax
add    $0x350,%rax
mov    (%rax,%rdx,4),%eax
movslq %r14d,%r14
mov    %eax,0x1b0(%rsp,%r14,4)
add    $0x1,%r14d
jmp    1650 <main+0x500>
mov    %r9d,%r10d
and    $0xfffffffe,%r10d
lea    0x354(%rsp),%rsi
xor    %edx,%edx
mov    $0x1,%r11d
xor    %r12d,%r12d
jmp    1778 <main+0x628>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
add    $0x1,%r11
add    $0xc8,%rsi
cmp    %r9,%rdx
je     1809 <main+0x6b9>
xor    %ebp,%ebp
test   %r8,%r8
jne    17c9 <main+0x679>
test   $0x1,%r9b
je     1760 <main+0x610>
cmp    %rbp,%rdx
jae    1760 <main+0x610>
lea    (%rdx,%rbp,1),%eax
cmp    %eax,%edi
jle    1760 <main+0x610>
imul   $0xc8,%rdx,%rax
add    %rsp,%rax
add    $0x350,%rax
mov    (%rax,%rbp,4),%eax
movslq %r12d,%r12
mov    %eax,0xe0(%rsp,%r12,4)
add    $0x1,%r12d
jmp    1760 <main+0x610>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x2,%rbp
cmp    %rbp,%r10
je     177f <main+0x62f>
cmp    %rbp,%rdx
jae    17e8 <main+0x698>
lea    (%rdx,%rbp,1),%eax
cmp    %eax,%edi
jle    17e8 <main+0x698>
mov    -0x4(%rsi,%rbp,4),%eax
movslq %r12d,%r12
mov    %eax,0xe0(%rsp,%r12,4)
add    $0x1,%r12d
cmp    %rbp,%rdx
ja     17c0 <main+0x670>
lea    (%r11,%rbp,1),%eax
cmp    %eax,%edi
jle    17c0 <main+0x670>
mov    (%rsi,%rbp,4),%eax
movslq %r12d,%r12
mov    %eax,0xe0(%rsp,%r12,4)
add    $0x1,%r12d
jmp    17c0 <main+0x670>
mov    %r9d,%r10d
and    $0xfffffffe,%r10d
lea    0x354(%rsp),%rsi
xor    %edi,%edi
mov    $0x1,%edx
xor    %r15d,%r15d
jmp    1848 <main+0x6f8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdi
add    $0x1,%rdx
add    $0xc8,%rsi
cmp    %r9,%rdi
je     18dd <main+0x78d>
xor    %ebp,%ebp
test   %r8,%r8
jne    1899 <main+0x749>
test   $0x1,%r9b
je     1830 <main+0x6e0>
cmp    %rbp,%rdi
jae    1830 <main+0x6e0>
lea    (%rdi,%rbp,1),%eax
cmp    %eax,%r13d
jg     1830 <main+0x6e0>
imul   $0xc8,%rdi,%rax
add    %rsp,%rax
add    $0x350,%rax
mov    (%rax,%rbp,4),%eax
movslq %r15d,%r15
mov    %eax,0x10(%rsp,%r15,4)
add    $0x1,%r15d
jmp    1830 <main+0x6e0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x2,%rbp
cmp    %rbp,%r10
je     184f <main+0x6ff>
cmp    %rbp,%rdi
jae    18b6 <main+0x766>
lea    (%rdi,%rbp,1),%eax
cmp    %eax,%r13d
jg     18b6 <main+0x766>
mov    -0x4(%rsi,%rbp,4),%eax
movslq %r15d,%r15
mov    %eax,0x10(%rsp,%r15,4)
add    $0x1,%r15d
cmp    %rbp,%rdi
ja     1890 <main+0x740>
lea    (%rdx,%rbp,1),%eax
cmp    %eax,%r13d
jg     1890 <main+0x740>
mov    (%rsi,%rbp,4),%eax
movslq %r15d,%r15
mov    %eax,0x10(%rsp,%r15,4)
add    $0x1,%r15d
jmp    1890 <main+0x740>
xor    %r12d,%r12d
xor    %r14d,%r14d
xor    %r15d,%r15d
mov    0x280(%rsp),%esi
cmp    $0x2,%ecx
jl     1a95 <main+0x945>
mov    %ecx,%eax
lea    -0x1(%rax),%rdx
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     1a80 <main+0x930>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdi,%rdi
je     1fb3 <main+0xe63>
movabs $0x3ffffffffffffffc,%rbp
ff ff 3f
or     $0x2,%rbp
and    %rsi,%rbp
xor    %edi,%edi
movdqa %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu 0x284(%rsp,%rdi,4),%xmm2
movdqu 0x294(%rsp,%rdi,4),%xmm3
movdqu 0x2a4(%rsp,%rdi,4),%xmm4
movdqu 0x2b4(%rsp,%rdi,4),%xmm5
movdqa %xmm2,%xmm6
pcmpgtd %xmm0,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm0,%xmm6
por    %xmm2,%xmm6
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
pcmpgtd %xmm6,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm6,%xmm0
por    %xmm4,%xmm0
movdqa %xmm5,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm2,%xmm1
por    %xmm5,%xmm1
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1950 <main+0x800>
test   $0x1,%sil
je     1a1e <main+0x8ce>
shl    $0x2,%rdi
or     $0x4,%rdi
movdqu 0x280(%rsp,%rdi,1),%xmm2
movdqu 0x290(%rsp,%rdi,1),%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rcx,%rdx
je     1a95 <main+0x945>
or     $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x280(%rsp,%rcx,4),%edx
cmp    %esi,%edx
cmovg  %edx,%esi
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1a80 <main+0x930>
lea    0x5a0(%rip),%rdi
xor    %ebx,%ebx
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x1b0(%rsp),%esi
test   %r14d,%r14d
jle    1c65 <main+0xb15>
cmp    $0x1,%r14d
je     1c65 <main+0xb15>
mov    %r14d,%eax
lea    -0x1(%rax),%rdx
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     1c50 <main+0xb00>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdi,%rdi
je     1fc8 <main+0xe78>
movabs $0x3ffffffffffffffc,%rbp
ff ff 3f
or     $0x2,%rbp
and    %rsi,%rbp
xor    %edi,%edi
movdqa %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu 0x1b4(%rsp,%rdi,4),%xmm2
movdqu 0x1c4(%rsp,%rdi,4),%xmm3
movdqu 0x1d4(%rsp,%rdi,4),%xmm4
movdqu 0x1e4(%rsp,%rdi,4),%xmm5
movdqa %xmm0,%xmm6
pcmpgtd %xmm2,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm0,%xmm6
por    %xmm2,%xmm6
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm6,%xmm0
pcmpgtd %xmm4,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm6,%xmm0
por    %xmm4,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm2,%xmm1
por    %xmm5,%xmm1
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1b20 <main+0x9d0>
test   $0x1,%sil
je     1bee <main+0xa9e>
shl    $0x2,%rdi
or     $0x4,%rdi
movdqu 0x1b0(%rsp,%rdi,1),%xmm2
movdqu 0x1c0(%rsp,%rdi,1),%xmm3
movdqa %xmm0,%xmm4
pcmpgtd %xmm2,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm2,%xmm1
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rcx,%rdx
je     1c65 <main+0xb15>
or     $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x1b0(%rsp,%rcx,4),%edx
cmp    %esi,%edx
cmovl  %edx,%esi
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1c50 <main+0xb00>
lea    0x3f0(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
test   %r12d,%r12d
jle    1d90 <main+0xc40>
mov    %r12d,%eax
cmp    $0x8,%r12d
jae    1c8e <main+0xb3e>
xor    %ecx,%ecx
xor    %ebx,%ebx
jmp    1d80 <main+0xc30>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    1cb9 <main+0xb69>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
jmp    1d22 <main+0xbd2>
and    $0xfffffffffffffffc,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
paddd  0xe0(%rsp,%rsi,4),%xmm0
paddd  0xf0(%rsp,%rsi,4),%xmm1
paddd  0x100(%rsp,%rsi,4),%xmm0
paddd  0x110(%rsp,%rsi,4),%xmm1
paddd  0x120(%rsp,%rsi,4),%xmm0
paddd  0x130(%rsp,%rsi,4),%xmm1
paddd  0x140(%rsp,%rsi,4),%xmm0
paddd  0x150(%rsp,%rsi,4),%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1cd0 <main+0xb80>
test   %rdx,%rdx
je     1d54 <main+0xc04>
lea    (%rsp,%rsi,4),%rsi
add    $0xf0,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
paddd  -0x10(%rsi,%rdi,1),%xmm0
paddd  (%rsi,%rdi,1),%xmm1
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1d40 <main+0xbf0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebx
cmp    %rax,%rcx
je     1d90 <main+0xc40>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    0xe0(%rsp,%rcx,4),%ebx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1d80 <main+0xc30>
lea    0x2e5(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
test   %r15d,%r15d
jle    13c1 <main+0x271>
mov    %r15d,%eax
cmp    $0x8,%r15d
jae    1dbe <main+0xc6e>
mov    $0x1,%esi
xor    %ecx,%ecx
jmp    1fa0 <main+0xe50>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    1df0 <main+0xca0>
movdqa 0x21b(%rip),%xmm0
xor    %esi,%esi
movdqa %xmm0,%xmm1
jmp    1edf <main+0xd8f>
and    $0xfffffffffffffffc,%rdi
movdqa 0x204(%rip),%xmm0
xor    %esi,%esi
movdqa %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
pshufd $0xf5,%xmm0,%xmm4
movdqa 0x10(%rsp,%rsi,4),%xmm3
movdqa 0x20(%rsp,%rsi,4),%xmm2
movdqa 0x30(%rsp,%rsi,4),%xmm5
movdqa 0x40(%rsp,%rsi,4),%xmm6
pshufd $0xf5,%xmm3,%xmm7
pmuludq %xmm4,%xmm7
pmuludq %xmm0,%xmm3
pshufd $0xf5,%xmm1,%xmm0
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm0,%xmm4
pmuludq %xmm1,%xmm2
pmuludq %xmm5,%xmm3
pshufd $0xf5,%xmm5,%xmm0
pmuludq %xmm7,%xmm0
pmuludq %xmm6,%xmm2
pshufd $0xf5,%xmm6,%xmm1
pmuludq %xmm4,%xmm1
movdqa 0x50(%rsp,%rsi,4),%xmm4
movdqa 0x60(%rsp,%rsi,4),%xmm5
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm0,%xmm6
pmuludq %xmm4,%xmm3
pshufd $0xf5,%xmm5,%xmm4
pmuludq %xmm1,%xmm4
pmuludq %xmm5,%xmm2
movdqa 0x70(%rsp,%rsi,4),%xmm1
movdqa 0x80(%rsp,%rsi,4),%xmm5
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm0
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm6,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm4,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1e10 <main+0xcc0>
movdqa %xmm0,%xmm2
movdqa %xmm1,%xmm3
test   %rdx,%rdx
je     1f5c <main+0xe0c>
lea    (%rsp,%rsi,4),%rsi
add    $0x20,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movdqa -0x10(%rsi,%rdi,1),%xmm2
movdqa (%rsi,%rdi,1),%xmm3
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm4,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
pshufd $0xf5,%xmm3,%xmm0
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm0
punpckldq %xmm0,%xmm3
add    $0x20,%rdi
movdqa %xmm2,%xmm0
movdqa %xmm3,%xmm1
cmp    %rdi,%rdx
jne    1f00 <main+0xdb0>
pshufd $0xf5,%xmm2,%xmm0
pshufd $0xf5,%xmm3,%xmm1
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm3
pshufd $0xee,%xmm3,%xmm0
pmuludq %xmm3,%xmm0
pshufd $0xaa,%xmm1,%xmm2
pmuludq %xmm1,%xmm2
pmuludq %xmm0,%xmm2
movd   %xmm2,%esi
cmp    %rax,%rcx
je     13c6 <main+0x276>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
imul   0x10(%rsp,%rcx,4),%esi
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1fa0 <main+0xe50>
jmp    13c6 <main+0x276>
xor    %edi,%edi
movdqa %xmm0,%xmm1
test   $0x1,%sil
jne    19d4 <main+0x884>
jmp    1a1e <main+0x8ce>
xor    %edi,%edi
movdqa %xmm0,%xmm1
test   $0x1,%sil
jne    1ba4 <main+0xa54>
jmp    1bee <main+0xa9e>

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

LLVM IR (-O2):
@.str = [25 x i8] c"Dati un numar n natural \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [12 x i8] c"a[%d][%d]= \00"
@.str.4 = [4 x i8] c"%d \00"
@.str.6 = [32 x i8] c"Maximul din regiunea 1 este %d\0A\00"
@.str.7 = [32 x i8] c"Minimul din regiunea 2 este %d\0A\00"
@.str.8 = [41 x i8] c"Suma elementelor din regiunea 3 este %d\0A\00"
@.str.9 = [45 x i8] c"Produsul elementelor din regiunea 4 este %d\0A\00"
@str = [36 x i8] c"Citirea matricei a fost realizata! \00"
@str.13 = [46 x i8] c"Interschimbare intre regiunea 1 si regiunea 3\00"
@str.14 = [8 x i8] c"Exit...\00"
define i32 @main() {
%1 = alloca [50 x [50 x i32]]
%2 = alloca [50 x i32]
%3 = alloca [50 x i32]
%4 = alloca [50 x i32]
%5 = alloca [50 x i32]
%6 = alloca i32
%7 = bitcast [50 x [50 x i32]]* %1 to i8*
%8 = bitcast [50 x i32]* %2 to i8*
%9 = bitcast [50 x i32]* %3 to i8*
%10 = bitcast [50 x i32]* %4 to i8*
%11 = bitcast [50 x i32]* %5 to i8*
%12 = bitcast i32* %6 to i8*
store i32 4, i32* %6
%13 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str, i64 0, i64 0))
%14 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %6)
%15 = load i32, i32* %6
%16 = icmp sgt i32 %15, 0
br i1 %16, label %17, label %23
17: ; preds = %0, %27
%18 = phi i32 [ %28, %27 ], [ %15, %0 ]
%19 = phi i64 [ %30, %27 ], [ 0, %0 ]
%20 = icmp sgt i32 %18, 0
br i1 %20, label %21, label %27
21: ; preds = %17
%22 = trunc i64 %19 to i32
br label %32
23: ; preds = %27, %0
%24 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @str, i64 0, i64 0))
%25 = load i32, i32* %6
%26 = icmp sgt i32 %25, 0
br i1 %26, label %42, label %265
27: ; preds = %32, %17
%28 = phi i32 [ %18, %17 ], [ %39, %32 ]
%29 = sext i32 %28 to i64
%30 = add nuw nsw i64 %19, 1
%31 = icmp slt i64 %30, %29
br i1 %31, label %17, label %23
32: ; preds = %21, %32
%33 = phi i64 [ 0, %21 ], [ %38, %32 ]
%34 = trunc i64 %33 to i32
%35 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0), i32 %22, i32 %34)
%36 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %19, i64 %33
%37 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %36)
%38 = add nuw nsw i64 %33, 1
%39 = load i32, i32* %6
%40 = sext i32 %39 to i64
%41 = icmp slt i64 %38, %40
br i1 %41, label %32, label %27
42: ; preds = %23, %55
%43 = phi i32 [ %58, %55 ], [ %25, %23 ]
%44 = phi i64 [ %57, %55 ], [ 0, %23 ]
%45 = icmp sgt i32 %43, 0
br i1 %45, label %61, label %55
46: ; preds = %55
%47 = icmp sgt i32 %58, 0
br i1 %47, label %48, label %265
48: ; preds = %46
%49 = zext i32 %58 to i64
%50 = add nsw i64 %49, -1
%51 = and i64 %49, 1
%52 = icmp eq i64 %50, 0
%53 = and i64 %49, 4294967294
%54 = icmp eq i64 %51, 0
br label %70
55: ; preds = %61, %42
%56 = call i32 @putchar(i32 10)
%57 = add nuw nsw i64 %44, 1
%58 = load i32, i32* %6
%59 = sext i32 %58 to i64
%60 = icmp slt i64 %57, %59
br i1 %60, label %42, label %46
61: ; preds = %42, %61
%62 = phi i64 [ %66, %61 ], [ 0, %42 ]
%63 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %44, i64 %62
%64 = load i32, i32* %63
%65 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i32 %64)
%66 = add nuw nsw i64 %62, 1
%67 = load i32, i32* %6
%68 = sext i32 %67 to i64
%69 = icmp slt i64 %66, %68
br i1 %69, label %61, label %55
70: ; preds = %97, %48
%71 = phi i64 [ 0, %48 ], [ %99, %97 ]
%72 = phi i32 [ 0, %48 ], [ %98, %97 ]
br i1 %52, label %81, label %101
73: ; preds = %97
br i1 %47, label %74, label %273
74: ; preds = %73
%75 = add nsw i32 %58, -1
%76 = zext i32 %58 to i64
%77 = and i64 %49, 1
%78 = icmp eq i64 %50, 0
%79 = and i64 %49, 4294967294
%80 = icmp eq i64 %77, 0
br label %135
81: ; preds = %130, %70
%82 = phi i32 [ undef, %70 ], [ %131, %130 ]
%83 = phi i64 [ 0, %70 ], [ %132, %130 ]
%84 = phi i32 [ %72, %70 ], [ %131, %130 ]
br i1 %54, label %97, label %85
85: ; preds = %81
%86 = add nuw nsw i64 %83, %71
%87 = trunc i64 %86 to i32
%88 = icmp sle i32 %58, %87
%89 = icmp ugt i64 %71, %83
%90 = and i1 %89, %88
br i1 %90, label %91, label %97
91: ; preds = %85
%92 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %71, i64 %83
%93 = load i32, i32* %92
%94 = sext i32 %84 to i64
%95 = getelementptr inbounds [50 x i32], [50 x i32]* %2, i64 0, i64 %94
store i32 %93, i32* %95
%96 = add nsw i32 %84, 1
br label %97
97: ; preds = %85, %91, %81
%98 = phi i32 [ %82, %81 ], [ %96, %91 ], [ %84, %85 ]
%99 = add nuw nsw i64 %71, 1
%100 = icmp eq i64 %99, %49
br i1 %100, label %73, label %70
101: ; preds = %70, %130
%102 = phi i64 [ %132, %130 ], [ 0, %70 ]
%103 = phi i32 [ %131, %130 ], [ %72, %70 ]
%104 = phi i64 [ %133, %130 ], [ 0, %70 ]
%105 = add nuw nsw i64 %102, %71
%106 = trunc i64 %105 to i32
%107 = icmp sle i32 %58, %106
%108 = icmp ugt i64 %71, %102
%109 = and i1 %108, %107
br i1 %109, label %110, label %116
110: ; preds = %101
%111 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %71, i64 %102
%112 = load i32, i32* %111
%113 = sext i32 %103 to i64
%114 = getelementptr inbounds [50 x i32], [50 x i32]* %2, i64 0, i64 %113
store i32 %112, i32* %114
%115 = add nsw i32 %103, 1
br label %116
116: ; preds = %101, %110
%117 = phi i32 [ %115, %110 ], [ %103, %101 ]
%118 = or i64 %102, 1
%119 = add nuw nsw i64 %118, %71
%120 = trunc i64 %119 to i32
%121 = icmp sle i32 %58, %120
%122 = icmp ugt i64 %71, %118
%123 = and i1 %122, %121
br i1 %123, label %124, label %130
124: ; preds = %116
%125 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %71, i64 %118
%126 = load i32, i32* %125
%127 = sext i32 %117 to i64
%128 = getelementptr inbounds [50 x i32], [50 x i32]* %2, i64 0, i64 %127
store i32 %126, i32* %128
%129 = add nsw i32 %117, 1
br label %130
130: ; preds = %124, %116
%131 = phi i32 [ %129, %124 ], [ %117, %116 ]
%132 = add nuw nsw i64 %102, 2
%133 = add i64 %104, 2
%134 = icmp eq i64 %133, %53
br i1 %134, label %81, label %101
135: ; preds = %161, %74
%136 = phi i64 [ 0, %74 ], [ %163, %161 ]
%137 = phi i32 [ 0, %74 ], [ %162, %161 ]
br i1 %78, label %145, label %165
138: ; preds = %161
%139 = add nsw i32 %58, -1
%140 = zext i32 %58 to i64
%141 = and i64 %49, 1
%142 = icmp eq i64 %50, 0
%143 = and i64 %49, 4294967294
%144 = icmp eq i64 %141, 0
br label %199
145: ; preds = %194, %135
%146 = phi i32 [ undef, %135 ], [ %195, %194 ]
%147 = phi i64 [ 0, %135 ], [ %196, %194 ]
%148 = phi i32 [ %137, %135 ], [ %195, %194 ]
br i1 %80, label %161, label %149
149: ; preds = %145
%150 = add nuw nsw i64 %147, %136
%151 = trunc i64 %150 to i32
%152 = icmp sgt i32 %75, %151
%153 = icmp ugt i64 %136, %147
%154 = and i1 %153, %152
br i1 %154, label %155, label %161
155: ; preds = %149
%156 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %136, i64 %147
%157 = load i32, i32* %156
%158 = sext i32 %148 to i64
%159 = getelementptr inbounds [50 x i32], [50 x i32]* %3, i64 0, i64 %158
store i32 %157, i32* %159
%160 = add nsw i32 %148, 1
br label %161
161: ; preds = %149, %155, %145
%162 = phi i32 [ %146, %145 ], [ %160, %155 ], [ %148, %149 ]
%163 = add nuw nsw i64 %136, 1
%164 = icmp eq i64 %163, %76
br i1 %164, label %138, label %135
165: ; preds = %135, %194
%166 = phi i64 [ %196, %194 ], [ 0, %135 ]
%167 = phi i32 [ %195, %194 ], [ %137, %135 ]
%168 = phi i64 [ %197, %194 ], [ 0, %135 ]
%169 = add nuw nsw i64 %166, %136
%170 = trunc i64 %169 to i32
%171 = icmp sgt i32 %75, %170
%172 = icmp ugt i64 %136, %166
%173 = and i1 %172, %171
br i1 %173, label %174, label %180
174: ; preds = %165
%175 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %136, i64 %166
%176 = load i32, i32* %175
%177 = sext i32 %167 to i64
%178 = getelementptr inbounds [50 x i32], [50 x i32]* %3, i64 0, i64 %177
store i32 %176, i32* %178
%179 = add nsw i32 %167, 1
br label %180
180: ; preds = %165, %174
%181 = phi i32 [ %179, %174 ], [ %167, %165 ]
%182 = or i64 %166, 1
%183 = add nuw nsw i64 %182, %136
%184 = trunc i64 %183 to i32
%185 = icmp sgt i32 %75, %184
%186 = icmp ugt i64 %136, %182
%187 = and i1 %186, %185
br i1 %187, label %188, label %194
188: ; preds = %180
%189 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %136, i64 %182
%190 = load i32, i32* %189
%191 = sext i32 %181 to i64
%192 = getelementptr inbounds [50 x i32], [50 x i32]* %3, i64 0, i64 %191
store i32 %190, i32* %192
%193 = add nsw i32 %181, 1
br label %194
194: ; preds = %188, %180
%195 = phi i32 [ %193, %188 ], [ %181, %180 ]
%196 = add nuw nsw i64 %166, 2
%197 = add i64 %168, 2
%198 = icmp eq i64 %197, %79
br i1 %198, label %145, label %165
199: ; preds = %224, %138
%200 = phi i64 [ 0, %138 ], [ %226, %224 ]
%201 = phi i32 [ 0, %138 ], [ %225, %224 ]
br i1 %142, label %208, label %228
202: ; preds = %224
%203 = zext i32 %58 to i64
%204 = and i64 %49, 1
%205 = icmp eq i64 %50, 0
%206 = and i64 %49, 4294967294
%207 = icmp eq i64 %204, 0
br label %262
208: ; preds = %257, %199
%209 = phi i32 [ undef, %199 ], [ %258, %257 ]
%210 = phi i64 [ 0, %199 ], [ %259, %257 ]
%211 = phi i32 [ %201, %199 ], [ %258, %257 ]
br i1 %144, label %224, label %212
212: ; preds = %208
%213 = add nuw nsw i64 %210, %200
%214 = trunc i64 %213 to i32
%215 = icmp sgt i32 %139, %214
%216 = icmp ult i64 %200, %210
%217 = and i1 %216, %215
br i1 %217, label %218, label %224
218: ; preds = %212
%219 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %200, i64 %210
%220 = load i32, i32* %219
%221 = sext i32 %211 to i64
%222 = getelementptr inbounds [50 x i32], [50 x i32]* %4, i64 0, i64 %221
store i32 %220, i32* %222
%223 = add nsw i32 %211, 1
br label %224
224: ; preds = %212, %218, %208
%225 = phi i32 [ %209, %208 ], [ %223, %218 ], [ %211, %212 ]
%226 = add nuw nsw i64 %200, 1
%227 = icmp eq i64 %226, %140
br i1 %227, label %202, label %199
228: ; preds = %199, %257
%229 = phi i64 [ %259, %257 ], [ 0, %199 ]
%230 = phi i32 [ %258, %257 ], [ %201, %199 ]
%231 = phi i64 [ %260, %257 ], [ 0, %199 ]
%232 = add nuw nsw i64 %229, %200
%233 = trunc i64 %232 to i32
%234 = icmp sgt i32 %139, %233
%235 = icmp ult i64 %200, %229
%236 = and i1 %235, %234
br i1 %236, label %237, label %243
237: ; preds = %228
%238 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %200, i64 %229
%239 = load i32, i32* %238
%240 = sext i32 %230 to i64
%241 = getelementptr inbounds [50 x i32], [50 x i32]* %4, i64 0, i64 %240
store i32 %239, i32* %241
%242 = add nsw i32 %230, 1
br label %243
243: ; preds = %228, %237
%244 = phi i32 [ %242, %237 ], [ %230, %228 ]
%245 = or i64 %229, 1
%246 = add nuw nsw i64 %245, %200
%247 = trunc i64 %246 to i32
%248 = icmp sgt i32 %139, %247
%249 = icmp ule i64 %200, %229
%250 = and i1 %249, %248
br i1 %250, label %251, label %257
251: ; preds = %243
%252 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %200, i64 %245
%253 = load i32, i32* %252
%254 = sext i32 %244 to i64
%255 = getelementptr inbounds [50 x i32], [50 x i32]* %4, i64 0, i64 %254
store i32 %253, i32* %255
%256 = add nsw i32 %244, 1
br label %257
257: ; preds = %251, %243
%258 = phi i32 [ %256, %251 ], [ %244, %243 ]
%259 = add nuw nsw i64 %229, 2
%260 = add i64 %231, 2
%261 = icmp eq i64 %260, %143
br i1 %261, label %208, label %228
262: ; preds = %371, %202
%263 = phi i64 [ 0, %202 ], [ %373, %371 ]
%264 = phi i32 [ 0, %202 ], [ %372, %371 ]
br i1 %205, label %355, label %375
265: ; preds = %46, %23
%266 = getelementptr inbounds [50 x i32], [50 x i32]* %2, i64 0, i64 0
%267 = load i32, i32* %266
%268 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.6, i64 0, i64 0), i32 %267)
%269 = getelementptr inbounds [50 x i32], [50 x i32]* %3, i64 0, i64 0
%270 = load i32, i32* %269
%271 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.7, i64 0, i64 0), i32 %270)
%272 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.8, i64 0, i64 0), i32 0)
br label %700
273: ; preds = %371, %73
%274 = phi i32 [ 0, %73 ], [ %225, %371 ]
%275 = phi i32 [ 0, %73 ], [ %162, %371 ]
%276 = phi i32 [ 0, %73 ], [ %372, %371 ]
%277 = getelementptr inbounds [50 x i32], [50 x i32]* %2, i64 0, i64 0
%278 = load i32, i32* %277
%279 = icmp sgt i32 %98, 1
br i1 %279, label %280, label %409
280: ; preds = %273
%281 = zext i32 %98 to i64
%282 = add nsw i64 %281, -1
%283 = icmp ult i64 %282, 8
br i1 %283, label %352, label %284
284: ; preds = %280
%285 = and i64 %282, -8
%286 = or i64 %285, 1
%287 = insertelement <4 x i32> poison, i32 %278, i64 0
%288 = shufflevector <4 x i32> %287, <4 x i32> poison, <4 x i32> zeroinitializer
%289 = add nsw i64 %285, -8
%290 = lshr exact i64 %289, 3
%291 = add nuw nsw i64 %290, 1
%292 = and i64 %291, 1
%293 = icmp eq i64 %289, 0
br i1 %293, label %326, label %294
294: ; preds = %284
%295 = and i64 %291, 4611686018427387902
br label %296
296: ; preds = %296, %294
%297 = phi i64 [ 0, %294 ], [ %323, %296 ]
%298 = phi <4 x i32> [ %288, %294 ], [ %321, %296 ]
%299 = phi <4 x i32> [ %288, %294 ], [ %322, %296 ]
%300 = phi i64 [ 0, %294 ], [ %324, %296 ]
%301 = or i64 %297, 1
%302 = getelementptr inbounds [50 x i32], [50 x i32]* %2, i64 0, i64 %301
%303 = bitcast i32* %302 to <4 x i32>*
%304 = load <4 x i32>, <4 x i32>* %303
%305 = getelementptr inbounds i32, i32* %302, i64 4
%306 = bitcast i32* %305 to <4 x i32>*
%307 = load <4 x i32>, <4 x i32>* %306
%308 = icmp sgt <4 x i32> %304, %298
%309 = icmp sgt <4 x i32> %307, %299
%310 = select <4 x i1> %308, <4 x i32> %304, <4 x i32> %298
%311 = select <4 x i1> %309, <4 x i32> %307, <4 x i32> %299
%312 = or i64 %297, 9
%313 = getelementptr inbounds [50 x i32], [50 x i32]* %2, i64 0, i64 %312
%314 = bitcast i32* %313 to <4 x i32>*
%315 = load <4 x i32>, <4 x i32>* %314
%316 = getelementptr inbounds i32, i32* %313, i64 4
%317 = bitcast i32* %316 to <4 x i32>*
%318 = load <4 x i32>, <4 x i32>* %317
%319 = icmp sgt <4 x i32> %315, %310
%320 = icmp sgt <4 x i32> %318, %311
%321 = select <4 x i1> %319, <4 x i32> %315, <4 x i32> %310
%322 = select <4 x i1> %320, <4 x i32> %318, <4 x i32> %311
%323 = add nuw i64 %297, 16
%324 = add i64 %300, 2
%325 = icmp eq i64 %324, %295
br i1 %325, label %326, label %296
326: ; preds = %296, %284
%327 = phi <4 x i32> [ undef, %284 ], [ %321, %296 ]
%328 = phi <4 x i32> [ undef, %284 ], [ %322, %296 ]
%329 = phi i64 [ 0, %284 ], [ %323, %296 ]
%330 = phi <4 x i32> [ %288, %284 ], [ %321, %296 ]
%331 = phi <4 x i32> [ %288, %284 ], [ %322, %296 ]
%332 = icmp eq i64 %292, 0
br i1 %332, label %345, label %333
333: ; preds = %326
%334 = or i64 %329, 1
%335 = getelementptr inbounds [50 x i32], [50 x i32]* %2, i64 0, i64 %334
%336 = bitcast i32* %335 to <4 x i32>*
%337 = load <4 x i32>, <4 x i32>* %336
%338 = getelementptr inbounds i32, i32* %335, i64 4
%339 = bitcast i32* %338 to <4 x i32>*
%340 = load <4 x i32>, <4 x i32>* %339
%341 = icmp sgt <4 x i32> %337, %330
%342 = icmp sgt <4 x i32> %340, %331
%343 = select <4 x i1> %341, <4 x i32> %337, <4 x i32> %330
%344 = select <4 x i1> %342, <4 x i32> %340, <4 x i32> %331
br label %345
345: ; preds = %326, %333
%346 = phi <4 x i32> [ %327, %326 ], [ %343, %333 ]
%347 = phi <4 x i32> [ %328, %326 ], [ %344, %333 ]
%348 = icmp sgt <4 x i32> %346, %347
%349 = select <4 x i1> %348, <4 x i32> %346, <4 x i32> %347
%350 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %349)
%351 = icmp eq i64 %282, %285
br i1 %351, label %409, label %352
352: ; preds = %280, %345
%353 = phi i64 [ 1, %280 ], [ %286, %345 ]
%354 = phi i32 [ %278, %280 ], [ %350, %345 ]
br label %492
355: ; preds = %404, %262
%356 = phi i32 [ undef, %262 ], [ %405, %404 ]
%357 = phi i64 [ 0, %262 ], [ %406, %404 ]
%358 = phi i32 [ %264, %262 ], [ %405, %404 ]
br i1 %207, label %371, label %359
359: ; preds = %355
%360 = add nuw nsw i64 %357, %263
%361 = trunc i64 %360 to i32
%362 = icmp sle i32 %58, %361
%363 = icmp ult i64 %263, %357
%364 = and i1 %363, %362
br i1 %364, label %365, label %371
365: ; preds = %359
%366 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %263, i64 %357
%367 = load i32, i32* %366
%368 = sext i32 %358 to i64
%369 = getelementptr inbounds [50 x i32], [50 x i32]* %5, i64 0, i64 %368
store i32 %367, i32* %369
%370 = add nsw i32 %358, 1
br label %371
371: ; preds = %359, %365, %355
%372 = phi i32 [ %356, %355 ], [ %370, %365 ], [ %358, %359 ]
%373 = add nuw nsw i64 %263, 1
%374 = icmp eq i64 %373, %203
br i1 %374, label %273, label %262
375: ; preds = %262, %404
%376 = phi i64 [ %406, %404 ], [ 0, %262 ]
%377 = phi i32 [ %405, %404 ], [ %264, %262 ]
%378 = phi i64 [ %407, %404 ], [ 0, %262 ]
%379 = add nuw nsw i64 %376, %263
%380 = trunc i64 %379 to i32
%381 = icmp sle i32 %58, %380
%382 = icmp ult i64 %263, %376
%383 = and i1 %382, %381
br i1 %383, label %384, label %390
384: ; preds = %375
%385 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %263, i64 %376
%386 = load i32, i32* %385
%387 = sext i32 %377 to i64
%388 = getelementptr inbounds [50 x i32], [50 x i32]* %5, i64 0, i64 %387
store i32 %386, i32* %388
%389 = add nsw i32 %377, 1
br label %390
390: ; preds = %375, %384
%391 = phi i32 [ %389, %384 ], [ %377, %375 ]
%392 = or i64 %376, 1
%393 = add nuw nsw i64 %392, %263
%394 = trunc i64 %393 to i32
%395 = icmp sle i32 %58, %394
%396 = icmp ule i64 %263, %376
%397 = and i1 %396, %395
br i1 %397, label %398, label %404
398: ; preds = %390
%399 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %263, i64 %392
%400 = load i32, i32* %399
%401 = sext i32 %391 to i64
%402 = getelementptr inbounds [50 x i32], [50 x i32]* %5, i64 0, i64 %401
store i32 %400, i32* %402
%403 = add nsw i32 %391, 1
br label %404
404: ; preds = %398, %390
%405 = phi i32 [ %403, %398 ], [ %391, %390 ]
%406 = add nuw nsw i64 %376, 2
%407 = add i64 %378, 2
%408 = icmp eq i64 %407, %206
br i1 %408, label %355, label %375
409: ; preds = %492, %345, %273
%410 = phi i32 [ %278, %273 ], [ %350, %345 ], [ %498, %492 ]
%411 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.6, i64 0, i64 0), i32 %410)
%412 = getelementptr inbounds [50 x i32], [50 x i32]* %3, i64 0, i64 0
%413 = load i32, i32* %412
%414 = icmp sgt i32 %275, 0
br i1 %414, label %415, label %501
415: ; preds = %409
%416 = zext i32 %275 to i64
%417 = icmp eq i32 %275, 1
br i1 %417, label %501, label %418
418: ; preds = %415
%419 = add nsw i64 %416, -1
%420 = icmp ult i64 %419, 8
br i1 %420, label %489, label %421
421: ; preds = %418
%422 = and i64 %419, -8
%423 = or i64 %422, 1
%424 = insertelement <4 x i32> poison, i32 %413, i64 0
%425 = shufflevector <4 x i32> %424, <4 x i32> poison, <4 x i32> zeroinitializer
%426 = add nsw i64 %422, -8
%427 = lshr exact i64 %426, 3
%428 = add nuw nsw i64 %427, 1
%429 = and i64 %428, 1
%430 = icmp eq i64 %426, 0
br i1 %430, label %463, label %431
431: ; preds = %421
%432 = and i64 %428, 4611686018427387902
br label %433
433: ; preds = %433, %431
%434 = phi i64 [ 0, %431 ], [ %460, %433 ]
%435 = phi <4 x i32> [ %425, %431 ], [ %458, %433 ]
%436 = phi <4 x i32> [ %425, %431 ], [ %459, %433 ]
%437 = phi i64 [ 0, %431 ], [ %461, %433 ]
%438 = or i64 %434, 1
%439 = getelementptr inbounds [50 x i32], [50 x i32]* %3, i64 0, i64 %438
%440 = bitcast i32* %439 to <4 x i32>*
%441 = load <4 x i32>, <4 x i32>* %440
%442 = getelementptr inbounds i32, i32* %439, i64 4
%443 = bitcast i32* %442 to <4 x i32>*
%444 = load <4 x i32>, <4 x i32>* %443
%445 = icmp slt <4 x i32> %441, %435
%446 = icmp slt <4 x i32> %444, %436
%447 = select <4 x i1> %445, <4 x i32> %441, <4 x i32> %435
%448 = select <4 x i1> %446, <4 x i32> %444, <4 x i32> %436
%449 = or i64 %434, 9
%450 = getelementptr inbounds [50 x i32], [50 x i32]* %3, i64 0, i64 %449
%451 = bitcast i32* %450 to <4 x i32>*
%452 = load <4 x i32>, <4 x i32>* %451
%453 = getelementptr inbounds i32, i32* %450, i64 4
%454 = bitcast i32* %453 to <4 x i32>*
%455 = load <4 x i32>, <4 x i32>* %454
%456 = icmp slt <4 x i32> %452, %447
%457 = icmp slt <4 x i32> %455, %448
%458 = select <4 x i1> %456, <4 x i32> %452, <4 x i32> %447
%459 = select <4 x i1> %457, <4 x i32> %455, <4 x i32> %448
%460 = add nuw i64 %434, 16
%461 = add i64 %437, 2
%462 = icmp eq i64 %461, %432
br i1 %462, label %463, label %433
463: ; preds = %433, %421
%464 = phi <4 x i32> [ undef, %421 ], [ %458, %433 ]
%465 = phi <4 x i32> [ undef, %421 ], [ %459, %433 ]
%466 = phi i64 [ 0, %421 ], [ %460, %433 ]
%467 = phi <4 x i32> [ %425, %421 ], [ %458, %433 ]
%468 = phi <4 x i32> [ %425, %421 ], [ %459, %433 ]
%469 = icmp eq i64 %429, 0
br i1 %469, label %482, label %470
470: ; preds = %463
%471 = or i64 %466, 1
%472 = getelementptr inbounds [50 x i32], [50 x i32]* %3, i64 0, i64 %471
%473 = bitcast i32* %472 to <4 x i32>*
%474 = load <4 x i32>, <4 x i32>* %473
%475 = getelementptr inbounds i32, i32* %472, i64 4
%476 = bitcast i32* %475 to <4 x i32>*
%477 = load <4 x i32>, <4 x i32>* %476
%478 = icmp slt <4 x i32> %474, %467
%479 = icmp slt <4 x i32> %477, %468
%480 = select <4 x i1> %478, <4 x i32> %474, <4 x i32> %467
%481 = select <4 x i1> %479, <4 x i32> %477, <4 x i32> %468
br label %482
482: ; preds = %463, %470
%483 = phi <4 x i32> [ %464, %463 ], [ %480, %470 ]
%484 = phi <4 x i32> [ %465, %463 ], [ %481, %470 ]
%485 = icmp slt <4 x i32> %483, %484
%486 = select <4 x i1> %485, <4 x i32> %483, <4 x i32> %484
%487 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %486)
%488 = icmp eq i64 %419, %422
br i1 %488, label %501, label %489
489: ; preds = %418, %482
%490 = phi i64 [ 1, %418 ], [ %423, %482 ]
%491 = phi i32 [ %413, %418 ], [ %487, %482 ]
br label %592
492: ; preds = %352, %492
%493 = phi i64 [ %499, %492 ], [ %353, %352 ]
%494 = phi i32 [ %498, %492 ], [ %354, %352 ]
%495 = getelementptr inbounds [50 x i32], [50 x i32]* %2, i64 0, i64 %493
%496 = load i32, i32* %495
%497 = icmp sgt i32 %496, %494
%498 = select i1 %497, i32 %496, i32 %494
%499 = add nuw nsw i64 %493, 1
%500 = icmp eq i64 %499, %281
br i1 %500, label %409, label %492
501: ; preds = %592, %415, %482, %409
%502 = phi i32 [ %413, %409 ], [ %413, %415 ], [ %487, %482 ], [ %598, %592 ]
%503 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.7, i64 0, i64 0), i32 %502)
%504 = icmp sgt i32 %274, 0
br i1 %504, label %505, label %601
505: ; preds = %501
%506 = zext i32 %274 to i64
%507 = icmp ult i32 %274, 8
br i1 %507, label %589, label %508
508: ; preds = %505
%509 = and i64 %506, 4294967288
%510 = add nsw i64 %509, -8
%511 = lshr exact i64 %510, 3
%512 = add nuw nsw i64 %511, 1
%513 = and i64 %512, 3
%514 = icmp ult i64 %510, 24
br i1 %514, label %560, label %515
515: ; preds = %508
%516 = and i64 %512, 4611686018427387900
br label %517
517: ; preds = %517, %515
%518 = phi i64 [ 0, %515 ], [ %557, %517 ]
%519 = phi <4 x i32> [ zeroinitializer, %515 ], [ %555, %517 ]
%520 = phi <4 x i32> [ zeroinitializer, %515 ], [ %556, %517 ]
%521 = phi i64 [ 0, %515 ], [ %558, %517 ]
%522 = getelementptr inbounds [50 x i32], [50 x i32]* %4, i64 0, i64 %518
%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 <4 x i32> %524, %519
%529 = add <4 x i32> %527, %520
%530 = or i64 %518, 8
%531 = getelementptr inbounds [50 x i32], [50 x i32]* %4, i64 0, i64 %530
%532 = bitcast i32* %531 to <4 x i32>*
%533 = load <4 x i32>, <4 x i32>* %532
%534 = getelementptr inbounds i32, i32* %531, i64 4
%535 = bitcast i32* %534 to <4 x i32>*
%536 = load <4 x i32>, <4 x i32>* %535
%537 = add <4 x i32> %533, %528
%538 = add <4 x i32> %536, %529
%539 = or i64 %518, 16
%540 = getelementptr inbounds [50 x i32], [50 x i32]* %4, i64 0, i64 %539
%541 = bitcast i32* %540 to <4 x i32>*
%542 = load <4 x i32>, <4 x i32>* %541
%543 = getelementptr inbounds i32, i32* %540, i64 4
%544 = bitcast i32* %543 to <4 x i32>*
%545 = load <4 x i32>, <4 x i32>* %544
%546 = add <4 x i32> %542, %537
%547 = add <4 x i32> %545, %538
%548 = or i64 %518, 24
%549 = getelementptr inbounds [50 x i32], [50 x i32]* %4, i64 0, i64 %548
%550 = bitcast i32* %549 to <4 x i32>*
%551 = load <4 x i32>, <4 x i32>* %550
%552 = getelementptr inbounds i32, i32* %549, i64 4
%553 = bitcast i32* %552 to <4 x i32>*
%554 = load <4 x i32>, <4 x i32>* %553
%555 = add <4 x i32> %551, %546
%556 = add <4 x i32> %554, %547
%557 = add nuw i64 %518, 32
%558 = add i64 %521, 4
%559 = icmp eq i64 %558, %516
br i1 %559, label %560, label %517
560: ; preds = %517, %508
%561 = phi <4 x i32> [ undef, %508 ], [ %555, %517 ]
%562 = phi <4 x i32> [ undef, %508 ], [ %556, %517 ]
%563 = phi i64 [ 0, %508 ], [ %557, %517 ]
%564 = phi <4 x i32> [ zeroinitializer, %508 ], [ %555, %517 ]
%565 = phi <4 x i32> [ zeroinitializer, %508 ], [ %556, %517 ]
%566 = icmp eq i64 %513, 0
br i1 %566, label %583, label %567
567: ; preds = %560, %567
%568 = phi i64 [ %580, %567 ], [ %563, %560 ]
%569 = phi <4 x i32> [ %578, %567 ], [ %564, %560 ]
%570 = phi <4 x i32> [ %579, %567 ], [ %565, %560 ]
%571 = phi i64 [ %581, %567 ], [ 0, %560 ]
%572 = getelementptr inbounds [50 x i32], [50 x i32]* %4, i64 0, i64 %568
%573 = bitcast i32* %572 to <4 x i32>*
%574 = load <4 x i32>, <4 x i32>* %573
%575 = getelementptr inbounds i32, i32* %572, i64 4
%576 = bitcast i32* %575 to <4 x i32>*
%577 = load <4 x i32>, <4 x i32>* %576
%578 = add <4 x i32> %574, %569
%579 = add <4 x i32> %577, %570
%580 = add nuw i64 %568, 8
%581 = add i64 %571, 1
%582 = icmp eq i64 %581, %513
br i1 %582, label %583, label %567
583: ; preds = %567, %560
%584 = phi <4 x i32> [ %561, %560 ], [ %578, %567 ]
%585 = phi <4 x i32> [ %562, %560 ], [ %579, %567 ]
%586 = add <4 x i32> %585, %584
%587 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %586)
%588 = icmp eq i64 %509, %506
br i1 %588, label %601, label %589
589: ; preds = %505, %583
%590 = phi i64 [ 0, %505 ], [ %509, %583 ]
%591 = phi i32 [ 0, %505 ], [ %587, %583 ]
br label %692
592: ; preds = %489, %592
%593 = phi i64 [ %599, %592 ], [ %490, %489 ]
%594 = phi i32 [ %598, %592 ], [ %491, %489 ]
%595 = getelementptr inbounds [50 x i32], [50 x i32]* %3, i64 0, i64 %593
%596 = load i32, i32* %595
%597 = icmp slt i32 %596, %594
%598 = select i1 %597, i32 %596, i32 %594
%599 = add nuw nsw i64 %593, 1
%600 = icmp eq i64 %599, %416
br i1 %600, label %501, label %592
601: ; preds = %692, %583, %501
%602 = phi i32 [ 0, %501 ], [ %587, %583 ], [ %697, %692 ]
%603 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.8, i64 0, i64 0), i32 %602)
%604 = icmp sgt i32 %276, 0
br i1 %604, label %605, label %700
605: ; preds = %601
%606 = zext i32 %276 to i64
%607 = icmp ult i32 %276, 8
br i1 %607, label %689, label %608
608: ; preds = %605
%609 = and i64 %606, 4294967288
%610 = add nsw i64 %609, -8
%611 = lshr exact i64 %610, 3
%612 = add nuw nsw i64 %611, 1
%613 = and i64 %612, 3
%614 = icmp ult i64 %610, 24
br i1 %614, label %660, label %615
615: ; preds = %608
%616 = and i64 %612, 4611686018427387900
br label %617
617: ; preds = %617, %615
%618 = phi i64 [ 0, %615 ], [ %657, %617 ]
%619 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %615 ], [ %655, %617 ]
%620 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %615 ], [ %656, %617 ]
%621 = phi i64 [ 0, %615 ], [ %658, %617 ]
%622 = getelementptr inbounds [50 x i32], [50 x i32]* %5, i64 0, i64 %618
%623 = bitcast i32* %622 to <4 x i32>*
%624 = load <4 x i32>, <4 x i32>* %623
%625 = getelementptr inbounds i32, i32* %622, i64 4
%626 = bitcast i32* %625 to <4 x i32>*
%627 = load <4 x i32>, <4 x i32>* %626
%628 = mul <4 x i32> %624, %619
%629 = mul <4 x i32> %627, %620
%630 = or i64 %618, 8
%631 = getelementptr inbounds [50 x i32], [50 x i32]* %5, i64 0, i64 %630
%632 = bitcast i32* %631 to <4 x i32>*
%633 = load <4 x i32>, <4 x i32>* %632
%634 = getelementptr inbounds i32, i32* %631, i64 4
%635 = bitcast i32* %634 to <4 x i32>*
%636 = load <4 x i32>, <4 x i32>* %635
%637 = mul <4 x i32> %633, %628
%638 = mul <4 x i32> %636, %629
%639 = or i64 %618, 16
%640 = getelementptr inbounds [50 x i32], [50 x i32]* %5, i64 0, i64 %639
%641 = bitcast i32* %640 to <4 x i32>*
%642 = load <4 x i32>, <4 x i32>* %641
%643 = getelementptr inbounds i32, i32* %640, i64 4
%644 = bitcast i32* %643 to <4 x i32>*
%645 = load <4 x i32>, <4 x i32>* %644
%646 = mul <4 x i32> %642, %637
%647 = mul <4 x i32> %645, %638
%648 = or i64 %618, 24
%649 = getelementptr inbounds [50 x i32], [50 x i32]* %5, i64 0, i64 %648
%650 = bitcast i32* %649 to <4 x i32>*
%651 = load <4 x i32>, <4 x i32>* %650
%652 = getelementptr inbounds i32, i32* %649, i64 4
%653 = bitcast i32* %652 to <4 x i32>*
%654 = load <4 x i32>, <4 x i32>* %653
%655 = mul <4 x i32> %651, %646
%656 = mul <4 x i32> %654, %647
%657 = add nuw i64 %618, 32
%658 = add i64 %621, 4
%659 = icmp eq i64 %658, %616
br i1 %659, label %660, label %617
660: ; preds = %617, %608
%661 = phi <4 x i32> [ undef, %608 ], [ %655, %617 ]
%662 = phi <4 x i32> [ undef, %608 ], [ %656, %617 ]
%663 = phi i64 [ 0, %608 ], [ %657, %617 ]
%664 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %608 ], [ %655, %617 ]
%665 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %608 ], [ %656, %617 ]
%666 = icmp eq i64 %613, 0
br i1 %666, label %683, label %667
667: ; preds = %660, %667
%668 = phi i64 [ %680, %667 ], [ %663, %660 ]
%669 = phi <4 x i32> [ %678, %667 ], [ %664, %660 ]
%670 = phi <4 x i32> [ %679, %667 ], [ %665, %660 ]
%671 = phi i64 [ %681, %667 ], [ 0, %660 ]
%672 = getelementptr inbounds [50 x i32], [50 x i32]* %5, i64 0, i64 %668
%673 = bitcast i32* %672 to <4 x i32>*
%674 = load <4 x i32>, <4 x i32>* %673
%675 = getelementptr inbounds i32, i32* %672, i64 4
%676 = bitcast i32* %675 to <4 x i32>*
%677 = load <4 x i32>, <4 x i32>* %676
%678 = mul <4 x i32> %674, %669
%679 = mul <4 x i32> %677, %670
%680 = add nuw i64 %668, 8
%681 = add i64 %671, 1
%682 = icmp eq i64 %681, %613
br i1 %682, label %683, label %667
683: ; preds = %667, %660
%684 = phi <4 x i32> [ %661, %660 ], [ %678, %667 ]
%685 = phi <4 x i32> [ %662, %660 ], [ %679, %667 ]
%686 = mul <4 x i32> %685, %684
%687 = call i32 @llvm.vector.reduce.mul.v4i32(<4 x i32> %686)
%688 = icmp eq i64 %609, %606
br i1 %688, label %700, label %689
689: ; preds = %605, %683
%690 = phi i64 [ 0, %605 ], [ %609, %683 ]
%691 = phi i32 [ 1, %605 ], [ %687, %683 ]
br label %705
692: ; preds = %589, %692
%693 = phi i64 [ %698, %692 ], [ %590, %589 ]
%694 = phi i32 [ %697, %692 ], [ %591, %589 ]
%695 = getelementptr inbounds [50 x i32], [50 x i32]* %4, i64 0, i64 %693
%696 = load i32, i32* %695
%697 = add nsw i32 %696, %694
%698 = add nuw nsw i64 %693, 1
%699 = icmp eq i64 %698, %506
br i1 %699, label %601, label %692
700: ; preds = %705, %683, %265, %601
%701 = phi i32 [ 1, %601 ], [ 1, %265 ], [ %687, %683 ], [ %710, %705 ]
%702 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @.str.9, i64 0, i64 0), i32 %701)
%703 = load i32, i32* %6
%704 = icmp sgt i32 %703, 0
br i1 %704, label %713, label %720
705: ; preds = %689, %705
%706 = phi i64 [ %711, %705 ], [ %690, %689 ]
%707 = phi i32 [ %710, %705 ], [ %691, %689 ]
%708 = getelementptr inbounds [50 x i32], [50 x i32]* %5, i64 0, i64 %706
%709 = load i32, i32* %708
%710 = mul nsw i32 %709, %707
%711 = add nuw nsw i64 %706, 1
%712 = icmp eq i64 %711, %606
br i1 %712, label %700, label %705
713: ; preds = %700, %724
%714 = phi i32 [ %725, %724 ], [ %703, %700 ]
%715 = phi i64 [ %726, %724 ], [ 0, %700 ]
%716 = icmp sgt i32 %714, 0
br i1 %716, label %717, label %724
717: ; preds = %713
%718 = trunc i64 %715 to i32
%719 = xor i32 %718, -1
br label %729
720: ; preds = %724, %700
%721 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @str.13, i64 0, i64 0))
%722 = load i32, i32* %6
%723 = icmp sgt i32 %722, 0
br i1 %723, label %751, label %776
724: ; preds = %745, %713
%725 = phi i32 [ %714, %713 ], [ %746, %745 ]
%726 = add nuw nsw i64 %715, 1
%727 = sext i32 %725 to i64
%728 = icmp slt i64 %726, %727
br i1 %728, label %713, label %720
729: ; preds = %717, %745
%730 = phi i32 [ %714, %717 ], [ %746, %745 ]
%731 = phi i32 [ %714, %717 ], [ %747, %745 ]
%732 = phi i64 [ 0, %717 ], [ %748, %745 ]
%733 = add nuw nsw i64 %732, %715
%734 = trunc i64 %733 to i32
%735 = icmp sle i32 %731, %734
%736 = icmp ugt i64 %715, %732
%737 = and i1 %736, %735
br i1 %737, label %738, label %745
738: ; preds = %729
%739 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %715, i64 %732
%740 = add i32 %731, %719
%741 = sext i32 %740 to i64
%742 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %741, i64 %732
%743 = call i32 @swap(i32* %739, i32* %742)
%744 = load i32, i32* %6
br label %745
745: ; preds = %729, %738
%746 = phi i32 [ %730, %729 ], [ %744, %738 ]
%747 = phi i32 [ %731, %729 ], [ %744, %738 ]
%748 = add nuw nsw i64 %732, 1
%749 = sext i32 %747 to i64
%750 = icmp slt i64 %748, %749
br i1 %750, label %729, label %724
751: ; preds = %720, %757
%752 = phi i32 [ %760, %757 ], [ %722, %720 ]
%753 = phi i64 [ %759, %757 ], [ 0, %720 ]
%754 = icmp sgt i32 %752, 0
br i1 %754, label %763, label %757
755: ; preds = %757
%756 = icmp sgt i32 %760, 0
br i1 %756, label %772, label %776
757: ; preds = %763, %751
%758 = call i32 @putchar(i32 10)
%759 = add nuw nsw i64 %753, 1
%760 = load i32, i32* %6
%761 = sext i32 %760 to i64
%762 = icmp slt i64 %759, %761
br i1 %762, label %751, label %755
763: ; preds = %751, %763
%764 = phi i64 [ %768, %763 ], [ 0, %751 ]
%765 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %753, i64 %764
%766 = load i32, i32* %765
%767 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i32 %766)
%768 = add nuw nsw i64 %764, 1
%769 = load i32, i32* %6
%770 = sext i32 %769 to i64
%771 = icmp slt i64 %768, %770
br i1 %771, label %763, label %757
772: ; preds = %755, %780
%773 = phi i32 [ %781, %780 ], [ %760, %755 ]
%774 = phi i64 [ %782, %780 ], [ 0, %755 ]
%775 = icmp sgt i32 %773, 0
br i1 %775, label %785, label %780
776: ; preds = %780, %720, %755
%777 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @str.13, i64 0, i64 0))
%778 = load i32, i32* %6
%779 = icmp sgt i32 %778, 0
br i1 %779, label %810, label %814
780: ; preds = %804, %772
%781 = phi i32 [ %773, %772 ], [ %805, %804 ]
%782 = add nuw nsw i64 %774, 1
%783 = sext i32 %781 to i64
%784 = icmp slt i64 %782, %783
br i1 %784, label %772, label %776
785: ; preds = %772, %804
%786 = phi i32 [ %805, %804 ], [ %773, %772 ]
%787 = phi i32 [ %806, %804 ], [ %773, %772 ]
%788 = phi i64 [ %807, %804 ], [ 0, %772 ]
%789 = add nuw nsw i64 %788, %774
%790 = add nsw i32 %787, -1
%791 = trunc i64 %789 to i32
%792 = icmp sgt i32 %790, %791
%793 = icmp ugt i64 %774, %788
%794 = and i1 %793, %792
br i1 %794, label %795, label %804
795: ; preds = %785
%796 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %774, i64 %788
%797 = trunc i64 %788 to i32
%798 = xor i32 %797, -1
%799 = add i32 %787, %798
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %774, i64 %800
%802 = call i32 @swap(i32* %796, i32* %801)
%803 = load i32, i32* %6
br label %804
804: ; preds = %785, %795
%805 = phi i32 [ %786, %785 ], [ %803, %795 ]
%806 = phi i32 [ %787, %785 ], [ %803, %795 ]
%807 = add nuw i64 %788, 1
%808 = trunc i64 %807 to i32
%809 = icmp sgt i32 %806, %808
br i1 %809, label %785, label %780
810: ; preds = %776, %816
%811 = phi i32 [ %819, %816 ], [ %778, %776 ]
%812 = phi i64 [ %818, %816 ], [ 0, %776 ]
%813 = icmp sgt i32 %811, 0
br i1 %813, label %822, label %816
814: ; preds = %816, %776
%815 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.14, i64 0, i64 0))
ret i32 0
816: ; preds = %822, %810
%817 = call i32 @putchar(i32 10)
%818 = add nuw nsw i64 %812, 1
%819 = load i32, i32* %6
%820 = sext i32 %819 to i64
%821 = icmp slt i64 %818, %820
br i1 %821, label %810, label %814
822: ; preds = %810, %822
%823 = phi i64 [ %827, %822 ], [ 0, %810 ]
%824 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %1, i64 0, i64 %812, i64 %823
%825 = load i32, i32* %824
%826 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i32 %825)
%827 = add nuw nsw i64 %823, 1
%828 = load i32, i32* %6
%829 = sext i32 %828 to i64
%830 = icmp slt i64 %827, %829
br i1 %830, label %822, label %816
}