#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  int a[20], b[20];
  int n;
  printf("Introduceti un n: ");
  scanf("%d", &n);
  printf("Prima multime de numere\n");
  for (int i = 0; i < n; i++) {
    printf("a[%d]= ", i);
    scanf("%d", &a[i]);
  }
  printf("A doua multime de numere\n");
  for (int i = 0; i < n; i++) {
    printf("b[%d]= ", i);
    scanf("%d", &b[i]);
  }
  printf("Reuniunea: ");
  for (int i = 0; i < n; i++) {
    printf("%d ", a[i]);
  }
  for (int i = 0; i < n; i++) {
    int diff = 1;
    for (int j = 0; j < n; j++) {
      if (b[i] == a[j]) {
        diff = 0;
      }
    }
    if (diff == 1) {
      printf("%d ", b[i]);
    }
  }
  printf("\nIntersectia: ");
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      if (a[i] == b[j]) {
        printf("%d ", a[i]);
      }
    }
  }
  printf("\nDiferenta: ");
  for (int i = 0; i < n; i++) {
    int diff = 1;
    for (int j = 0; j < n; j++) {
      if (a[i] == b[j]) {
        diff = 0;
      }
    }
    if (diff == 1) {
      printf("%d ", a[i]);
    }
  }
  printf("\nProdusul cartezian: ");
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      printf("(%d %d) ", a[i], b[j]);
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xec7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xecc(%rip),%rdi
lea    -0xb4(%rbp),%rsi
call   1040 <scanf@plt>
lea    0xebc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    11c3 <main+0xa3>
mov    -0xb8(%rbp),%esi
lea    0xea5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movslq -0xb8(%rbp),%rax
lea    -0x60(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe69(%rip),%rdi
call   1040 <scanf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    116b <main+0x4b>
lea    0xe6d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    1236 <main+0x116>
mov    -0xbc(%rbp),%esi
lea    0xe57(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movslq -0xbc(%rbp),%rax
lea    -0xb0(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xdf6(%rip),%rdi
call   1040 <scanf@plt>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    11db <main+0xbb>
lea    0xe1c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    128d <main+0x16d>
movslq -0xc0(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%esi
lea    0xdf3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    124e <main+0x12e>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    1353 <main+0x233>
movl   $0x1,-0xc8(%rbp)
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    1311 <main+0x1f1>
movslq -0xc4(%rbp),%rax
mov    -0xb0(%rbp,%rax,4),%eax
movslq -0xcc(%rbp),%rcx
cmp    -0x60(%rbp,%rcx,4),%eax
jne    12f8 <main+0x1d8>
movl   $0x0,-0xc8(%rbp)
jmp    12fd <main+0x1dd>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    12bd <main+0x19d>
cmpl   $0x1,-0xc8(%rbp)
jne    133a <main+0x21a>
movslq -0xc4(%rbp),%rax
mov    -0xb0(%rbp,%rax,4),%esi
lea    0xd32(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    133f <main+0x21f>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1297 <main+0x177>
lea    0xd0f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    1403 <main+0x2e3>
movl   $0x0,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    13ea <main+0x2ca>
movslq -0xd0(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%eax
movslq -0xd4(%rbp),%rcx
cmp    -0xb0(%rbp,%rcx,4),%eax
jne    13d1 <main+0x2b1>
movslq -0xd0(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%esi
lea    0xc9b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13d6 <main+0x2b6>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1387 <main+0x267>
jmp    13ef <main+0x2cf>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    136b <main+0x24b>
lea    0xc6e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    14d4 <main+0x3b4>
movl   $0x1,-0xdc(%rbp)
movl   $0x0,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    1495 <main+0x375>
movslq -0xd8(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%eax
movslq -0xe0(%rbp),%rcx
cmp    -0xb0(%rbp,%rcx,4),%eax
jne    147c <main+0x35c>
movl   $0x0,-0xdc(%rbp)
jmp    1481 <main+0x361>
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    1441 <main+0x321>
cmpl   $0x1,-0xdc(%rbp)
jne    14bb <main+0x39b>
movslq -0xd8(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%esi
lea    0xbb1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    14c0 <main+0x3a0>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    141b <main+0x2fb>
lea    0xbaa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    156e <main+0x44e>
movl   $0x0,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    1555 <main+0x435>
movslq -0xe4(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%esi
movslq -0xe8(%rbp),%rax
mov    -0xb0(%rbp,%rax,4),%edx
lea    0xb61(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
jmp    1508 <main+0x3e8>
jmp    155a <main+0x43a>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    14ec <main+0x3cc>
xor    %eax,%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb0,%rsp
lea    0xec9(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xece(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1050 <scanf@plt>
lea    0xf1b(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,0xc(%rsp)
jle    11b9 <main+0x89>
lea    0x10(%rsp),%r12
lea    0xea8(%rip),%r14
lea    0xe9e(%rip),%r15
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <scanf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
add    $0x4,%r12
cmp    %rax,%rbx
jl     1190 <main+0x60>
lea    0xed9(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,0xc(%rsp)
jle    1219 <main+0xe9>
lea    0x60(%rsp),%r12
lea    0xe56(%rip),%r14
lea    0xe44(%rip),%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <scanf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
add    $0x4,%r12
cmp    %rax,%rbx
jl     11f0 <main+0xc0>
movabs $0x3ffffffffffffffe,%r14
ff ff 3f
lea    0xe0c(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cmpl   $0x0,0xc(%rsp)
jle    13f9 <main+0x2c9>
lea    0xdff(%rip),%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x10(%rsp,%rbx,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1250 <main+0x120>
test   %eax,%eax
jle    13f9 <main+0x2c9>
xor    %r12d,%r12d
lea    0xdc4(%rip),%r15
xor    %r13d,%r13d
jmp    12b3 <main+0x183>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x60(%rsp,%r13,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%eax
add    $0x1,%r13
movslq %eax,%rcx
cmp    %rcx,%r13
jge    13f9 <main+0x2c9>
test   %eax,%eax
jle    1290 <main+0x160>
mov    0x60(%rsp,%r13,4),%ecx
mov    %eax,%edx
cmp    $0x8,%eax
jae    12d0 <main+0x1a0>
mov    $0x1,%edi
xor    %esi,%esi
jmp    13c0 <main+0x290>
nop
mov    %edx,%esi
and    $0xfffffff8,%esi
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rsi),%rdi
mov    %rdi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdi,%rdi
je     13df <main+0x2af>
mov    %r8,%rbx
and    %r14,%rbx
xor    %edi,%edi
movdqa 0xcfa(%rip),%xmm3
movdqa %xmm3,%xmm4
nopw   0x0(%rax,%rax,1)
movdqa 0x10(%rsp,%rdi,4),%xmm2
pcmpeqd %xmm0,%xmm2
movdqa 0x20(%rsp,%rdi,4),%xmm5
pcmpeqd %xmm0,%xmm5
movdqa 0x30(%rsp,%rdi,4),%xmm1
pcmpeqd %xmm0,%xmm1
por    %xmm2,%xmm1
pandn  %xmm4,%xmm1
movdqa 0x40(%rsp,%rdi,4),%xmm2
pcmpeqd %xmm0,%xmm2
por    %xmm5,%xmm2
pandn  %xmm3,%xmm2
add    $0x10,%rdi
movdqa %xmm1,%xmm4
movdqa %xmm2,%xmm3
add    $0xfffffffffffffffe,%rbx
jne    1310 <main+0x1e0>
test   $0x1,%r8b
je     1384 <main+0x254>
movdqa %xmm0,%xmm3
pcmpeqd 0x10(%rsp,%rdi,4),%xmm3
pandn  %xmm1,%xmm3
movdqa 0x20(%rsp,%rdi,4),%xmm4
pcmpeqd %xmm0,%xmm4
pandn  %xmm2,%xmm4
movdqa %xmm3,%xmm1
movdqa %xmm4,%xmm2
movdqa %xmm1,%xmm0
movdqa 0xc70(%rip),%xmm3
pcmpeqd %xmm3,%xmm0
pand   %xmm0,%xmm2
pandn  %xmm1,%xmm0
por    %xmm2,%xmm0
pcmpeqd %xmm3,%xmm0
movmskps %xmm0,%ebx
xor    %edi,%edi
cmp    $0xf,%ebx
sete   %dil
cmp    %rdx,%rsi
je     13d1 <main+0x2a1>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    0x10(%rsp,%rsi,4),%ecx
cmove  %r12d,%edi
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    13c0 <main+0x290>
cmp    $0x1,%edi
je     1290 <main+0x160>
jmp    12a3 <main+0x173>
xor    %edi,%edi
movdqa 0xc17(%rip),%xmm2
movdqa %xmm2,%xmm1
test   $0x1,%r8b
jne    1360 <main+0x230>
jmp    1384 <main+0x254>
lea    0xc46(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    1467 <main+0x337>
lea    0xc2c(%rip),%r15
xor    %r12d,%r12d
jmp    142c <main+0x2fc>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
movslq %eax,%rcx
cmp    %rcx,%r12
jge    1467 <main+0x337>
test   %eax,%eax
jle    1420 <main+0x2f0>
xor    %ebx,%ebx
jmp    144c <main+0x31c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
movslq %eax,%rcx
cmp    %rcx,%rbx
jge    1420 <main+0x2f0>
mov    0x10(%rsp,%r12,4),%esi
cmp    0x60(%rsp,%rbx,4),%esi
jne    1440 <main+0x310>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%eax
jmp    1440 <main+0x310>
lea    0xbe7(%rip),%rdi
xor    %r12d,%r12d
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%r8d
test   %r8d,%r8d
jle    1619 <main+0x4e9>
lea    0xbb5(%rip),%r15
xor    %ebx,%ebx
jmp    14c3 <main+0x393>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp,%rbx,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%r8d
add    $0x1,%rbx
movslq %r8d,%rax
cmp    %rax,%rbx
jge    1619 <main+0x4e9>
test   %r8d,%r8d
jle    14a0 <main+0x370>
mov    0x10(%rsp,%rbx,4),%ecx
mov    %r8d,%edx
cmp    $0x8,%r8d
jae    14f0 <main+0x3c0>
mov    $0x1,%eax
xor    %esi,%esi
jmp    15e0 <main+0x4b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edx,%esi
and    $0xfffffff8,%esi
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rsi),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     15ff <main+0x4cf>
mov    %r9,%rdi
and    %r14,%rdi
xor    %eax,%eax
movdqa 0xada(%rip),%xmm3
movdqa %xmm3,%xmm4
nopw   0x0(%rax,%rax,1)
movdqa 0x60(%rsp,%rax,4),%xmm2
pcmpeqd %xmm0,%xmm2
movdqa 0x70(%rsp,%rax,4),%xmm5
pcmpeqd %xmm0,%xmm5
movdqa 0x80(%rsp,%rax,4),%xmm1
pcmpeqd %xmm0,%xmm1
por    %xmm2,%xmm1
pandn  %xmm4,%xmm1
movdqa 0x90(%rsp,%rax,4),%xmm2
pcmpeqd %xmm0,%xmm2
por    %xmm5,%xmm2
pandn  %xmm3,%xmm2
add    $0x10,%rax
movdqa %xmm1,%xmm4
movdqa %xmm2,%xmm3
add    $0xfffffffffffffffe,%rdi
jne    1530 <main+0x400>
test   $0x1,%r9b
je     15aa <main+0x47a>
movdqa %xmm0,%xmm3
pcmpeqd 0x60(%rsp,%rax,4),%xmm3
pandn  %xmm1,%xmm3
movdqa 0x70(%rsp,%rax,4),%xmm4
pcmpeqd %xmm0,%xmm4
pandn  %xmm2,%xmm4
movdqa %xmm3,%xmm1
movdqa %xmm4,%xmm2
movdqa %xmm1,%xmm0
movdqa 0xa4a(%rip),%xmm3
pcmpeqd %xmm3,%xmm0
pand   %xmm0,%xmm2
pandn  %xmm1,%xmm0
por    %xmm2,%xmm0
pcmpeqd %xmm3,%xmm0
movmskps %xmm0,%edi
xor    %eax,%eax
cmp    $0xf,%edi
sete   %al
cmp    %rdx,%rsi
je     15f1 <main+0x4c1>
nopw   0x0(%rax,%rax,1)
cmp    0x60(%rsp,%rsi,4),%ecx
cmove  %r12d,%eax
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    15e0 <main+0x4b0>
cmp    $0x1,%eax
je     14a0 <main+0x370>
jmp    14b3 <main+0x383>
xor    %eax,%eax
movdqa 0x9f7(%rip),%xmm2
movdqa %xmm2,%xmm1
test   $0x1,%r9b
jne    1586 <main+0x456>
jmp    15aa <main+0x47a>
lea    0xa42(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    1683 <main+0x553>
lea    0xa42(%rip),%r14
xor    %r15d,%r15d
jmp    164c <main+0x51c>
nopl   0x0(%rax,%rax,1)
movslq %eax,%rcx
add    $0x1,%r15
cmp    %rcx,%r15
jge    1683 <main+0x553>
test   %eax,%eax
jle    1640 <main+0x510>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp,%r15,4),%esi
mov    0x60(%rsp,%rbx,4),%edx
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1660 <main+0x530>
jmp    1640 <main+0x510>
xor    %eax,%eax
add    $0xb0,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [19 x i8] c"Introduceti un n: \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [25 x i8] c"Prima multime de numere\0A\00"
@.str.3 = [8 x i8] c"a[%d]= \00"
@.str.4 = [26 x i8] c"A doua multime de numere\0A\00"
@.str.5 = [8 x i8] c"b[%d]= \00"
@.str.6 = [12 x i8] c"Reuniunea: \00"
@.str.7 = [4 x i8] c"%d \00"
@.str.8 = [15 x i8] c"\0AIntersectia: \00"
@.str.9 = [13 x i8] c"\0ADiferenta: \00"
@.str.10 = [22 x i8] c"\0AProdusul cartezian: \00"
@.str.11 = [9 x i8] c"(%d %d) \00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [20 x i32]
%3 = alloca [20 x 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 i32
%16 = alloca i32
%17 = alloca i32
store i32 0, i32* %1
%18 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
%19 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %4)
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %5
br label %21
21: ; preds = %32, %0
%22 = load i32, i32* %5
%23 = load i32, i32* %4
%24 = icmp slt i32 %22, %23
br i1 %24, label %25, label %35
25: ; preds = %21
%26 = load i32, i32* %5
%27 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 %26)
%28 = load i32, i32* %5
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %29
%31 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %30)
br label %32
32: ; preds = %25
%33 = load i32, i32* %5
%34 = add nsw i32 %33, 1
store i32 %34, i32* %5
br label %21
35: ; preds = %21
%36 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %6
br label %37
37: ; preds = %48, %35
%38 = load i32, i32* %6
%39 = load i32, i32* %4
%40 = icmp slt i32 %38, %39
br i1 %40, label %41, label %51
41: ; preds = %37
%42 = load i32, i32* %6
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i64 0, i64 0), i32 %42)
%44 = load i32, i32* %6
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %45
%47 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %46)
br label %48
48: ; preds = %41
%49 = load i32, i32* %6
%50 = add nsw i32 %49, 1
store i32 %50, i32* %6
br label %37
51: ; preds = %37
%52 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0))
store i32 0, i32* %7
br label %53
53: ; preds = %63, %51
%54 = load i32, i32* %7
%55 = load i32, i32* %4
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %66
57: ; preds = %53
%58 = load i32, i32* %7
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %59
%61 = load i32, i32* %60
%62 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32 %61)
br label %63
63: ; preds = %57
%64 = load i32, i32* %7
%65 = add nsw i32 %64, 1
store i32 %65, i32* %7
br label %53
66: ; preds = %53
store i32 0, i32* %8
br label %67
67: ; preds = %101, %66
%68 = load i32, i32* %8
%69 = load i32, i32* %4
%70 = icmp slt i32 %68, %69
br i1 %70, label %71, label %104
71: ; preds = %67
store i32 1, i32* %9
store i32 0, i32* %10
br label %72
72: ; preds = %88, %71
%73 = load i32, i32* %10
%74 = load i32, i32* %4
%75 = icmp slt i32 %73, %74
br i1 %75, label %76, label %91
76: ; preds = %72
%77 = load i32, i32* %8
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %78
%80 = load i32, i32* %79
%81 = load i32, i32* %10
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %82
%84 = load i32, i32* %83
%85 = icmp eq i32 %80, %84
br i1 %85, label %86, label %87
86: ; preds = %76
store i32 0, i32* %9
br label %87
87: ; preds = %86, %76
br label %88
88: ; preds = %87
%89 = load i32, i32* %10
%90 = add nsw i32 %89, 1
store i32 %90, i32* %10
br label %72
91: ; preds = %72
%92 = load i32, i32* %9
%93 = icmp eq i32 %92, 1
br i1 %93, label %94, label %100
94: ; preds = %91
%95 = load i32, i32* %8
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %96
%98 = load i32, i32* %97
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32 %98)
br label %100
100: ; preds = %94, %91
br label %101
101: ; preds = %100
%102 = load i32, i32* %8
%103 = add nsw i32 %102, 1
store i32 %103, i32* %8
br label %67
104: ; preds = %67
%105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.8, i64 0, i64 0))
store i32 0, i32* %11
br label %106
106: ; preds = %136, %104
%107 = load i32, i32* %11
%108 = load i32, i32* %4
%109 = icmp slt i32 %107, %108
br i1 %109, label %110, label %139
110: ; preds = %106
store i32 0, i32* %12
br label %111
111: ; preds = %132, %110
%112 = load i32, i32* %12
%113 = load i32, i32* %4
%114 = icmp slt i32 %112, %113
br i1 %114, label %115, label %135
115: ; preds = %111
%116 = load i32, i32* %11
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %117
%119 = load i32, i32* %118
%120 = load i32, i32* %12
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %121
%123 = load i32, i32* %122
%124 = icmp eq i32 %119, %123
br i1 %124, label %125, label %131
125: ; preds = %115
%126 = load i32, i32* %11
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %127
%129 = load i32, i32* %128
%130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32 %129)
br label %131
131: ; preds = %125, %115
br label %132
132: ; preds = %131
%133 = load i32, i32* %12
%134 = add nsw i32 %133, 1
store i32 %134, i32* %12
br label %111
135: ; preds = %111
br label %136
136: ; preds = %135
%137 = load i32, i32* %11
%138 = add nsw i32 %137, 1
store i32 %138, i32* %11
br label %106
139: ; preds = %106
%140 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.9, i64 0, i64 0))
store i32 0, i32* %13
br label %141
141: ; preds = %175, %139
%142 = load i32, i32* %13
%143 = load i32, i32* %4
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %178
145: ; preds = %141
store i32 1, i32* %14
store i32 0, i32* %15
br label %146
146: ; preds = %162, %145
%147 = load i32, i32* %15
%148 = load i32, i32* %4
%149 = icmp slt i32 %147, %148
br i1 %149, label %150, label %165
150: ; preds = %146
%151 = load i32, i32* %13
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %152
%154 = load i32, i32* %153
%155 = load i32, i32* %15
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %156
%158 = load i32, i32* %157
%159 = icmp eq i32 %154, %158
br i1 %159, label %160, label %161
160: ; preds = %150
store i32 0, i32* %14
br label %161
161: ; preds = %160, %150
br label %162
162: ; preds = %161
%163 = load i32, i32* %15
%164 = add nsw i32 %163, 1
store i32 %164, i32* %15
br label %146
165: ; preds = %146
%166 = load i32, i32* %14
%167 = icmp eq i32 %166, 1
br i1 %167, label %168, label %174
168: ; preds = %165
%169 = load i32, i32* %13
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %170
%172 = load i32, i32* %171
%173 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i32 %172)
br label %174
174: ; preds = %168, %165
br label %175
175: ; preds = %174
%176 = load i32, i32* %13
%177 = add nsw i32 %176, 1
store i32 %177, i32* %13
br label %141
178: ; preds = %141
%179 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0))
store i32 0, i32* %16
br label %180
180: ; preds = %203, %178
%181 = load i32, i32* %16
%182 = load i32, i32* %4
%183 = icmp slt i32 %181, %182
br i1 %183, label %184, label %206
184: ; preds = %180
store i32 0, i32* %17
br label %185
185: ; preds = %199, %184
%186 = load i32, i32* %17
%187 = load i32, i32* %4
%188 = icmp slt i32 %186, %187
br i1 %188, label %189, label %202
189: ; preds = %185
%190 = load i32, i32* %16
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %191
%193 = load i32, i32* %192
%194 = load i32, i32* %17
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [20 x i32], [20 x i32]* %3, i64 0, i64 %195
%197 = load i32, i32* %196
%198 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.11, i64 0, i64 0), i32 %193, i32 %197)
br label %199
199: ; preds = %189
%200 = load i32, i32* %17
%201 = add nsw i32 %200, 1
store i32 %201, i32* %17
br label %185
202: ; preds = %185
br label %203
203: ; preds = %202
%204 = load i32, i32* %16
%205 = add nsw i32 %204, 1
store i32 %205, i32* %16
br label %180
206: ; preds = %180
ret i32 0
}

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