#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 abs(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *, ...);
int main() {
  int br_studenata, i, j, k, max1, suma1_mjeseci = 0, suma11_mjeseci = 0,
                                   suma1_dani = 0, suma1_konacna = 0;
  int suma2_mjeseci = 0, suma22_mjeseci = 0, suma2_dani = 0, suma2_konacna = 0;
  int niz_datuma[1000][3];
  do {
    printf("Unesite broj studenata: ");
    scanf("%d", &br_studenata);
    if (br_studenata < 1 || br_studenata > 1000)
      printf("Neispravan broj studenata\n");
  } while (br_studenata < 1 || br_studenata > 1000);
  for (i = 0; i < br_studenata; i++) {
    printf("Unesite datum rodjenja %d. studenta: ", i + 1);
    scanf("%d,%d,%d", &niz_datuma[i][0], &niz_datuma[i][1], &niz_datuma[i][2]);
    if ((niz_datuma[i][2] % 4 == 0 && !(niz_datuma[i][2] % 100 == 0)) ||
        niz_datuma[i][2] % 400 == 0) {
      int niz_godina[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
      if (niz_datuma[i][1] == 2 &&
          (niz_datuma[i][0] > 29 || niz_datuma[i][0] <= 0)) {
        printf("Neispravan datum\n");
        i--;
      }
      for (j = 0; j < 12; j++)
        if (niz_datuma[i][1] == j + 1)
          max1 = niz_godina[j];
      if ((max1 % 31 == 0 &&
           (niz_datuma[i][0] > 31 || niz_datuma[i][0] <= 0)) ||
          (max1 % 30 == 0 &&
           (niz_datuma[i][0] > 30 || niz_datuma[i][0] <= 0))) {
        printf("Neispravan datum\n");
        i--;
      }
    } else {
      int niz_godina[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
      if (niz_datuma[i][1] == 2 &&
          (niz_datuma[i][0] > 28 || niz_datuma[i][0] <= 0)) {
        printf("Neispravan datum\n");
        i--;
      }
      for (j = 0; j < 12; j++)
        if (niz_datuma[i][1] == j + 1)
          max1 = niz_godina[j];
      if ((max1 % 31 == 0 &&
           (niz_datuma[i][0] > 31 || niz_datuma[i][0] <= 0)) ||
          (max1 % 30 == 0 &&
           (niz_datuma[i][0] > 30 || niz_datuma[i][0] <= 0))) {
        printf("Neispravan datum\n");
        i--;
      }
    }
  }
  for (i = 0; i < br_studenata; i++) {
    for (k = i + 1; k < br_studenata; k++) {
      if ((niz_datuma[i][2] % 4 == 0 && !(niz_datuma[i][2] % 100 == 0)) ||
          niz_datuma[i][2] % 400 == 0) {
        int niz_godina[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        if (niz_datuma[i][2] == niz_datuma[k][2]) {
          suma1_dani = abs(niz_datuma[i][0] - niz_datuma[k][0]);
          for (j = 0; j < niz_datuma[i][1] - 1; j++)
            suma1_mjeseci += niz_godina[j];
          for (j = 0; j < niz_datuma[k][1] - 1; j++)
            suma11_mjeseci += niz_godina[j];
          suma1_konacna = suma1_dani + abs(suma1_mjeseci - suma11_mjeseci);
          if (suma1_konacna == 100) {
            printf("Student %d. je rodjen tacno 100 dana prije studenta %d.\n",
                   i + 1, k + 1);
            suma1_dani = 0;
            suma11_mjeseci = 0;
            suma1_mjeseci = 0;
            suma1_konacna = 0;
          }
        }
      } else {
        if (niz_datuma[i][2] == niz_datuma[k][2]) {
          int niz_godina[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
          suma2_dani = abs(niz_datuma[i][0] - niz_datuma[k][0]);
          for (j = 0; j < niz_datuma[i][1] - 1; j++)
            suma2_mjeseci += niz_godina[j];
          for (j = 0; j < niz_datuma[k][1] - 1; j++)
            suma22_mjeseci += niz_godina[j];
          suma2_konacna = suma2_dani + abs(suma2_mjeseci - suma22_mjeseci);
          if (suma2_konacna == 100) {
            printf("Student %d. je rodjen tacno 100 dana prije studenta %d.\n",
                   i + 1, k + 1);
            suma2_dani = 0;
            suma22_mjeseci = 0;
            suma2_mjeseci = 0;
            suma2_konacna = 0;
          }
        }
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2ff0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
lea    0xe6f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xec1(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1060 <scanf@plt>
cmpl   $0x1,-0x8(%rbp)
jl     11c1 <main+0x81>
cmpl   $0x3e8,-0x8(%rbp)
jle    11cf <main+0x8f>
lea    0xe51(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    11d4 <main+0x94>
mov    $0x1,%al
cmpl   $0x1,-0x8(%rbp)
mov    %al,-0x2fe1(%rbp)
jl     11f6 <main+0xb6>
cmpl   $0x3e8,-0x8(%rbp)
setg   %al
mov    %al,-0x2fe1(%rbp)
mov    -0x2fe1(%rbp),%al
test   $0x1,%al
jne    118a <main+0x4a>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1608 <main+0x4c8>
mov    -0xc(%rbp),%esi
add    $0x1,%esi
lea    0xe10(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movslq -0xc(%rbp),%rax
lea    -0x2f20(%rbp),%rsi
imul   $0xc,%rax,%rax
add    %rax,%rsi
movslq -0xc(%rbp),%rax
lea    -0x2f20(%rbp),%rdx
imul   $0xc,%rax,%rax
add    %rax,%rdx
add    $0x4,%rdx
movslq -0xc(%rbp),%rax
lea    -0x2f20(%rbp),%rcx
imul   $0xc,%rax,%rax
add    %rax,%rcx
add    $0x8,%rcx
lea    0xdea(%rip),%rdi
mov    $0x0,%al
call   1060 <scanf@plt>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    12c3 <main+0x183>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    12e9 <main+0x1a9>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%eax
mov    $0x190,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    146f <main+0x32f>
lea    -0x2f50(%rbp),%rdi
lea    0xdb9(%rip),%rsi
mov    $0x30,%edx
call   1050 <memcpy@plt>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x2,0x4(%rax)
jne    136a <main+0x22a>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1d,(%rax)
jg     1353 <main+0x213>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x0,(%rax)
jg     136a <main+0x22a>
lea    0xd09(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
cmpl   $0xc,-0x10(%rbp)
jge    13bf <main+0x27f>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    13ac <main+0x26c>
movslq -0x10(%rbp),%rax
mov    -0x2f50(%rbp,%rax,4),%eax
mov    %eax,-0x18(%rbp)
jmp    13b1 <main+0x271>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1371 <main+0x231>
mov    -0x18(%rbp),%eax
mov    $0x1f,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1409 <main+0x2c9>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1f,(%rax)
jg     1453 <main+0x313>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x0,(%rax)
jle    1453 <main+0x313>
mov    -0x18(%rbp),%eax
mov    $0x1e,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    146a <main+0x32a>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1e,(%rax)
jg     1453 <main+0x313>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x0,(%rax)
jg     146a <main+0x32a>
lea    0xc09(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    15f5 <main+0x4b5>
lea    -0x2f80(%rbp),%rdi
lea    0xc63(%rip),%rsi
mov    $0x30,%edx
call   1050 <memcpy@plt>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x2,0x4(%rax)
jne    14f0 <main+0x3b0>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1c,(%rax)
jg     14d9 <main+0x399>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x0,(%rax)
jg     14f0 <main+0x3b0>
lea    0xb83(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
cmpl   $0xc,-0x10(%rbp)
jge    1545 <main+0x405>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1532 <main+0x3f2>
movslq -0x10(%rbp),%rax
mov    -0x2f80(%rbp,%rax,4),%eax
mov    %eax,-0x18(%rbp)
jmp    1537 <main+0x3f7>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14f7 <main+0x3b7>
mov    -0x18(%rbp),%eax
mov    $0x1f,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    158f <main+0x44f>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1f,(%rax)
jg     15d9 <main+0x499>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x0,(%rax)
jle    15d9 <main+0x499>
mov    -0x18(%rbp),%eax
mov    $0x1e,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    15f0 <main+0x4b0>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1e,(%rax)
jg     15d9 <main+0x499>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x0,(%rax)
jg     15f0 <main+0x4b0>
lea    0xa83(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    15f5 <main+0x4b5>
jmp    15fa <main+0x4ba>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    120b <main+0xcb>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    19b2 <main+0x872>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    199f <main+0x85f>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    167c <main+0x53c>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    16a2 <main+0x562>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%eax
mov    $0x190,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1817 <main+0x6d7>
lea    -0x2fb0(%rbp),%rdi
lea    0xa60(%rip),%rsi
mov    $0x30,%edx
call   1050 <memcpy@plt>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%eax
movslq -0x14(%rbp),%rdx
lea    -0x2f20(%rbp),%rcx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
cmp    0x8(%rcx),%eax
jne    1812 <main+0x6d2>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%edi
movslq -0x14(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
sub    (%rax),%edi
call   1030 <abs@plt>
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
movslq -0xc(%rbp),%rdx
lea    -0x2f20(%rbp),%rcx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1763 <main+0x623>
movslq -0x10(%rbp),%rax
mov    -0x2fb0(%rbp,%rax,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1721 <main+0x5e1>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
movslq -0x14(%rbp),%rdx
lea    -0x2f20(%rbp),%rcx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    17ac <main+0x66c>
movslq -0x10(%rbp),%rax
mov    -0x2fb0(%rbp,%rax,4),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    176a <main+0x62a>
mov    -0x24(%rbp),%eax
mov    %eax,-0x2fe8(%rbp)
mov    -0x1c(%rbp),%edi
sub    -0x20(%rbp),%edi
call   1030 <abs@plt>
mov    %eax,%ecx
mov    -0x2fe8(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x64,-0x28(%rbp)
jne    180d <main+0x6cd>
mov    -0xc(%rbp),%esi
add    $0x1,%esi
mov    -0x14(%rbp),%edx
add    $0x1,%edx
lea    0x88b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
jmp    1812 <main+0x6d2>
jmp    198c <main+0x84c>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%eax
movslq -0x14(%rbp),%rdx
lea    -0x2f20(%rbp),%rcx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
cmp    0x8(%rcx),%eax
jne    1987 <main+0x847>
lea    -0x2fe0(%rbp),%rdi
lea    0x8eb(%rip),%rsi
mov    $0x30,%edx
call   1050 <memcpy@plt>
movslq -0xc(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%edi
movslq -0x14(%rbp),%rcx
lea    -0x2f20(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
sub    (%rax),%edi
call   1030 <abs@plt>
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
movslq -0xc(%rbp),%rdx
lea    -0x2f20(%rbp),%rcx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    18d8 <main+0x798>
movslq -0x10(%rbp),%rax
mov    -0x2fe0(%rbp,%rax,4),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1896 <main+0x756>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
movslq -0x14(%rbp),%rdx
lea    -0x2f20(%rbp),%rcx
imul   $0xc,%rdx,%rdx
add    %rdx,%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1921 <main+0x7e1>
movslq -0x10(%rbp),%rax
mov    -0x2fe0(%rbp,%rax,4),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    18df <main+0x79f>
mov    -0x34(%rbp),%eax
mov    %eax,-0x2fec(%rbp)
mov    -0x2c(%rbp),%edi
sub    -0x30(%rbp),%edi
call   1030 <abs@plt>
mov    %eax,%ecx
mov    -0x2fec(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x64,-0x38(%rbp)
jne    1982 <main+0x842>
mov    -0xc(%rbp),%esi
add    $0x1,%esi
mov    -0x14(%rbp),%edx
add    $0x1,%edx
lea    0x716(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x38(%rbp)
jmp    1987 <main+0x847>
jmp    198c <main+0x84c>
jmp    1991 <main+0x851>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1624 <main+0x4e4>
jmp    19a4 <main+0x864>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    160f <main+0x4cf>
xor    %eax,%eax
add    $0x2ff0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2f18,%rsp
lea    0xeb8(%rip),%r14
lea    0xef6(%rip),%r15
lea    0xc(%rsp),%r12
mov    $0xfffffc17,%ebp
lea    0xf32(%rip),%rbx
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0xc(%rsp),%eax
add    %ebp,%eax
cmp    $0xfffffc17,%eax
ja     1199 <main+0x69>
mov    %rbx,%rdi
call   1030 <puts@plt>
mov    0xc(%rsp),%eax
add    %ebp,%eax
cmp    $0xfffffc18,%eax
jb     1160 <main+0x30>
xor    %r13d,%r13d
jmp    11c4 <main+0x94>
xchg   %ax,%ax
lea    0xeda(%rip),%rdi
call   1030 <puts@plt>
add    $0xffffffff,%r13d
add    $0x1,%r13d
mov    0xc(%rsp),%ecx
mov    %ebx,%r15d
cmp    %ecx,%r13d
jge    143a <main+0x30a>
lea    0x1(%r13),%esi
lea    0xe4a(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movslq %r13d,%rbp
lea    0x0(,%rbp,2),%r14
add    %rbp,%r14
lea    0x30(%rsp,%r14,4),%r12
lea    0x34(%rsp,%r14,4),%rdx
lea    (%rsp,%r14,4),%rcx
add    $0x38,%rcx
lea    0xe42(%rip),%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
movslq 0x38(%rsp,%r14,4),%rcx
test   $0x3,%cl
sete   %dl
imul   $0xc28f5c29,%ecx,%eax
add    $0x51eb850,%eax
ror    $0x2,%eax
cmp    $0x28f5c29,%eax
setae  %bl
mov    0x34(%rsp,%r14,4),%eax
test   %bl,%dl
jne    12f0 <main+0x1c0>
imul   $0x51eb851f,%rcx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x27,%rdx
add    %esi,%edx
imul   $0x190,%edx,%edx
sub    %edx,%ecx
je     12f0 <main+0x1c0>
cmp    $0x2,%eax
jne    1293 <main+0x163>
mov    (%r12),%eax
add    $0xffffffe3,%eax
mov    $0x1c,%ebx
cmp    $0xffffffe3,%eax
ja     11b0 <main+0x80>
lea    0xe09(%rip),%rdi
call   1030 <puts@plt>
add    $0xffffffff,%r13d
movslq %r13d,%rbp
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
mov    0x34(%rsp,%rax,4),%eax
cmp    $0xc,%eax
ja     13ee <main+0x2be>
mov    $0x1f,%ebx
mov    $0x15aa,%ecx
bt     %eax,%ecx
jae    1382 <main+0x252>
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
mov    0x30(%rsp,%rax,4),%eax
add    $0xffffffe0,%eax
mov    %ebx,%r15d
cmp    $0xffffffe1,%eax
jb     11a0 <main+0x70>
imul   $0xeeeeeeef,%r15d,%eax
add    $0x8888888,%eax
ror    %eax
mov    %r15d,%ebx
cmp    $0x8888888,%eax
ja     137a <main+0x24a>
jmp    1391 <main+0x261>
xchg   %ax,%ax
cmp    $0x2,%eax
jne    132c <main+0x1fc>
mov    (%r12),%eax
add    $0xffffffe2,%eax
mov    $0x1d,%ebx
cmp    $0xffffffe2,%eax
ja     11b0 <main+0x80>
lea    0xd70(%rip),%rdi
call   1030 <puts@plt>
add    $0xffffffff,%r13d
movslq %r13d,%rbp
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
mov    0x34(%rsp,%rax,4),%eax
cmp    $0xc,%eax
ja     141b <main+0x2eb>
mov    $0x1f,%ebx
mov    $0x15aa,%ecx
bt     %eax,%ecx
jae    13b1 <main+0x281>
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
mov    0x30(%rsp,%rax,4),%eax
add    $0xffffffe0,%eax
mov    %ebx,%r15d
cmp    $0xffffffe1,%eax
jb     11a0 <main+0x70>
imul   $0xeeeeeeef,%r15d,%eax
add    $0x8888888,%eax
ror    %eax
mov    %r15d,%ebx
cmp    $0x8888888,%eax
jbe    13c0 <main+0x290>
mov    %r15d,%ebx
jmp    11b0 <main+0x80>
mov    $0x1e,%ebx
mov    $0xa50,%ecx
bt     %eax,%ecx
jae    13e0 <main+0x2b0>
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
mov    0x30(%rsp,%rax,4),%eax
add    $0xffffffe1,%eax
cmp    $0xffffffe1,%eax
jbe    11a0 <main+0x70>
jmp    11b0 <main+0x80>
mov    $0x1e,%ebx
mov    $0xa50,%ecx
bt     %eax,%ecx
jae    140d <main+0x2dd>
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
mov    0x30(%rsp,%rax,4),%eax
add    $0xffffffe1,%eax
cmp    $0xffffffe2,%eax
jb     11a0 <main+0x70>
jmp    11b0 <main+0x80>
mov    $0x1c,%ebx
cmp    $0x2,%eax
je     11b0 <main+0x80>
imul   $0xbdef7bdf,%r15d,%eax
add    $0x4210842,%eax
mov    %r15d,%ebx
cmp    $0x8421084,%eax
ja     12cd <main+0x19d>
jmp    12af <main+0x17f>
mov    $0x1d,%ebx
cmp    $0x2,%eax
je     11b0 <main+0x80>
imul   $0xbdef7bdf,%r15d,%eax
add    $0x4210842,%eax
mov    %r15d,%ebx
cmp    $0x8421084,%eax
ja     1362 <main+0x232>
jmp    1344 <main+0x214>
test   %ecx,%ecx
jle    1a33 <main+0x903>
mov    $0x1,%r15d
lea    0xc91(%rip),%r12
xor    %r11d,%r11d
xor    %ebx,%ebx
xor    %esi,%esi
xor    %eax,%eax
xor    %edx,%edx
jmp    1475 <main+0x345>
nopl   0x0(%rax)
movslq %ecx,%r8
mov    0x20(%rsp),%r15
add    $0x1,%r15
cmp    %r8,%r11
jge    1a33 <main+0x903>
mov    %r11,%r9
add    $0x1,%r11
movslq %ecx,%r8
cmp    %r8,%r11
jge    1468 <main+0x338>
lea    (%r9,%r9,2),%rcx
lea    (%rsp,%rcx,4),%rbp
add    $0x38,%rbp
mov    %r15,0x20(%rsp)
mov    %rbp,0x10(%rsp)
jmp    14b8 <main+0x388>
nopl   0x0(%rax)
mov    %edi,%edx
mov    %r13d,%eax
mov    %r8d,%esi
mov    %r14d,%ebx
add    $0x1,%r15
mov    0xc(%rsp),%ecx
cmp    %r15d,%ecx
jle    1460 <main+0x330>
mov    %edx,%edi
mov    %eax,%r13d
mov    %esi,%r8d
mov    %ebx,%r14d
movslq 0x0(%rbp),%rcx
test   $0x3,%cl
sete   %al
imul   $0xc28f5c29,%ecx,%edx
add    $0x51eb850,%edx
ror    $0x2,%edx
cmp    $0x28f5c29,%edx
setae  %bl
lea    (%r15,%r15,2),%r10
mov    0x38(%rsp,%r10,4),%edx
test   %bl,%al
jne    1550 <main+0x420>
imul   $0x51eb851f,%rcx,%rax
mov    %rax,%rsi
shr    $0x3f,%rsi
sar    $0x27,%rax
add    %esi,%eax
imul   $0x190,%eax,%eax
mov    %ecx,%esi
sub    %eax,%esi
je     1550 <main+0x420>
cmp    %edx,%ecx
jne    14a0 <main+0x370>
mov    -0x8(%rbp),%eax
sub    0x30(%rsp,%r10,4),%eax
mov    %eax,%r9d
neg    %r9d
cmovs  %eax,%r9d
mov    -0x4(%rbp),%edx
cmp    $0x2,%edx
jl     159c <main+0x46c>
add    $0xffffffff,%edx
mov    %edi,%ebp
cmp    $0x8,%edx
jae    15d6 <main+0x4a6>
mov    %r8d,%eax
xor    %r8d,%r8d
jmp    1895 <main+0x765>
nopl   0x0(%rax)
cmp    %edx,%ecx
jne    14a0 <main+0x370>
mov    -0x8(%rbp),%eax
sub    0x30(%rsp,%r10,4),%eax
mov    %eax,%r9d
neg    %r9d
cmovs  %eax,%r9d
mov    -0x4(%rbp),%esi
mov    %r8d,%ebp
cmp    $0x2,%esi
jl     158e <main+0x45e>
add    $0xffffffff,%esi
cmp    $0x8,%esi
lea    0xb2e(%rip),%rbx
jae    15a6 <main+0x476>
xor    %r8d,%r8d
mov    %edi,%eax
jmp    16a5 <main+0x575>
mov    %edi,%edx
lea    0xb19(%rip),%rbx
jmp    16bc <main+0x58c>
mov    %edi,%ebp
mov    %r8d,%esi
jmp    18ac <main+0x77c>
mov    %esi,%r8d
and    $0xfffffff8,%r8d
movd   %edi,%xmm0
lea    -0x8(%r8),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rax
jae    160d <main+0x4dd>
pxor   %xmm1,%xmm1
xor    %edi,%edi
jmp    1659 <main+0x529>
mov    %r8d,%edi
mov    %edx,%r8d
and    $0xfffffff8,%r8d
movd   %edi,%xmm0
lea    -0x8(%r8),%rax
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x18,%rax
jae    17e4 <main+0x6b4>
pxor   %xmm1,%xmm1
xor    %edi,%edi
jmp    1841 <main+0x711>
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rdx
pxor   %xmm1,%xmm1
xor    %edi,%edi
paddd  (%rbx,%rdi,4),%xmm0
paddd  0x10(%rbx,%rdi,4),%xmm1
paddd  0x20(%rbx,%rdi,4),%xmm0
paddd  0x30(%rbx,%rdi,4),%xmm1
paddd  0x40(%rbx,%rdi,4),%xmm0
paddd  0x50(%rbx,%rdi,4),%xmm1
paddd  0x60(%rbx,%rdi,4),%xmm0
paddd  0x70(%rbx,%rdi,4),%xmm1
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rdx
jne    1620 <main+0x4f0>
test   %rcx,%rcx
je     1684 <main+0x554>
lea    (%rbx,%rdi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %edi,%edi
nopl   0x0(%rax)
paddd  -0x10(%rdx,%rdi,1),%xmm0
paddd  (%rdx,%rdi,1),%xmm1
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1670 <main+0x540>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
mov    %eax,%edx
cmp    %rsi,%r8
je     16bc <main+0x58c>
lea    (%rbx,%r8,4),%rcx
sub    %r8,%rsi
xor    %edi,%edi
mov    %eax,%edx
add    (%rcx,%rdi,4),%edx
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    16b0 <main+0x580>
mov    0x34(%rsp,%r10,4),%eax
cmp    $0x2,%eax
jl     17bd <main+0x68d>
add    $0xffffffff,%eax
cmp    $0x8,%eax
jae    16da <main+0x5aa>
xor    %r8d,%r8d
jmp    17a4 <main+0x674>
mov    %eax,%r8d
and    $0xfffffff8,%r8d
movd   %r13d,%xmm0
lea    -0x8(%r8),%rsi
mov    %rsi,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%edi
and    $0x3,%edi
cmp    $0x18,%rsi
jae    1708 <main+0x5d8>
pxor   %xmm1,%xmm1
xor    %esi,%esi
jmp    1759 <main+0x629>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
and    %rsi,%rcx
pxor   %xmm1,%xmm1
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
paddd  (%rbx,%rsi,4),%xmm0
paddd  0x10(%rbx,%rsi,4),%xmm1
paddd  0x20(%rbx,%rsi,4),%xmm0
paddd  0x30(%rbx,%rsi,4),%xmm1
paddd  0x40(%rbx,%rsi,4),%xmm0
paddd  0x50(%rbx,%rsi,4),%xmm1
paddd  0x60(%rbx,%rsi,4),%xmm0
paddd  0x70(%rbx,%rsi,4),%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rcx
jne    1720 <main+0x5f0>
test   %rdi,%rdi
je     1784 <main+0x654>
lea    (%rbx,%rsi,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
paddd  -0x10(%rcx,%rsi,1),%xmm0
paddd  (%rcx,%rsi,1),%xmm1
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    1770 <main+0x640>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%r13d
cmp    %rax,%r8
je     17bd <main+0x68d>
lea    (%rbx,%r8,4),%rcx
sub    %r8,%rax
xor    %esi,%esi
nopl   (%rax)
add    (%rcx,%rsi,4),%r13d
add    $0x1,%rsi
cmp    %rsi,%rax
jne    17b0 <main+0x680>
mov    %r13d,%eax
mov    %edx,%esi
sub    %r13d,%esi
mov    %esi,%ecx
neg    %ecx
cmovs  %esi,%ecx
add    %r9d,%ecx
xor    %edi,%edi
mov    $0x0,%r13d
mov    %ebp,%r8d
mov    %ebp,%esi
mov    %r14d,%ebx
jmp    19df <main+0x8af>
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rsi
pxor   %xmm1,%xmm1
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
paddd  (%r12,%rdi,4),%xmm0
paddd  0x10(%r12,%rdi,4),%xmm1
paddd  0x20(%r12,%rdi,4),%xmm0
paddd  0x30(%r12,%rdi,4),%xmm1
paddd  0x40(%r12,%rdi,4),%xmm0
paddd  0x50(%r12,%rdi,4),%xmm1
paddd  0x60(%r12,%rdi,4),%xmm0
paddd  0x70(%r12,%rdi,4),%xmm1
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1800 <main+0x6d0>
test   %rcx,%rcx
je     1874 <main+0x744>
lea    (%r12,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
paddd  -0x10(%rsi,%rdi,1),%xmm0
paddd  (%rsi,%rdi,1),%xmm1
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1860 <main+0x730>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
mov    %eax,%esi
cmp    %rdx,%r8
je     18ac <main+0x77c>
lea    (%r12,%r8,4),%rcx
sub    %r8,%rdx
xor    %edi,%edi
mov    %eax,%esi
add    (%rcx,%rdi,4),%esi
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    18a0 <main+0x770>
mov    0x34(%rsp,%r10,4),%eax
cmp    $0x2,%eax
jl     19bd <main+0x88d>
add    $0xffffffff,%eax
cmp    $0x8,%eax
jae    18ca <main+0x79a>
xor    %r8d,%r8d
jmp    19a4 <main+0x874>
mov    %eax,%r8d
and    $0xfffffff8,%r8d
movd   %r14d,%xmm0
lea    -0x8(%r8),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%edi
and    $0x3,%edi
cmp    $0x18,%rdx
jae    18f8 <main+0x7c8>
pxor   %xmm1,%xmm1
xor    %edx,%edx
jmp    1951 <main+0x821>
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
and    %rdx,%rcx
pxor   %xmm1,%xmm1
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
paddd  (%r12,%rdx,4),%xmm0
paddd  0x10(%r12,%rdx,4),%xmm1
paddd  0x20(%r12,%rdx,4),%xmm0
paddd  0x30(%r12,%rdx,4),%xmm1
paddd  0x40(%r12,%rdx,4),%xmm0
paddd  0x50(%r12,%rdx,4),%xmm1
paddd  0x60(%r12,%rdx,4),%xmm0
paddd  0x70(%r12,%rdx,4),%xmm1
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1910 <main+0x7e0>
test   %rdi,%rdi
je     1984 <main+0x854>
lea    (%r12,%rdx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
paddd  -0x10(%rcx,%rdx,1),%xmm0
paddd  (%rcx,%rdx,1),%xmm1
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    1970 <main+0x840>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%r14d
cmp    %rax,%r8
je     19bd <main+0x88d>
lea    (%r12,%r8,4),%rcx
sub    %r8,%rax
xor    %edx,%edx
nopl   (%rax)
add    (%rcx,%rdx,4),%r14d
add    $0x1,%rdx
cmp    %rdx,%rax
jne    19b0 <main+0x880>
mov    %r14d,%ebx
mov    %esi,%eax
sub    %r14d,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
add    %r9d,%ecx
xor    %r8d,%r8d
mov    $0x0,%r14d
mov    %ebp,%edi
mov    %ebp,%edx
mov    %r13d,%eax
cmp    $0x64,%ecx
mov    0x10(%rsp),%rbp
jne    14ab <main+0x37b>
mov    %edi,0x1c(%rsp)
lea    0x1(%r15),%edx
lea    0x64c(%rip),%rdi
mov    %r11d,%esi
xor    %eax,%eax
mov    %r11,%rbx
mov    %r15,0x28(%rsp)
mov    %r12,%r15
mov    %r8d,%r12d
call   1040 <printf@plt>
mov    0x10(%rsp),%rbp
mov    %rbx,%r11
mov    0x1c(%rsp),%edx
mov    %r13d,%eax
mov    %r12d,%esi
mov    %r15,%r12
mov    0x28(%rsp),%r15
jmp    14a8 <main+0x378>
xor    %eax,%eax
add    $0x2f18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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