#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 rand();
int /*<<< orphan*/ scanf(char *, int *, ...);
int main(void) {
  int big, small;
  int i, j;
  int sum = 0;
  int square = 0;
  printf("Please enter 2 numbers:\nThe Second number must be smaller than the "
         "first number\n");
  scanf("%d %d", &big, &small);
  printf("You entered: %d, %d\n", big, small);
  while (big < small) {
    printf("The second number is not smaller than the first number, please "
           "enter a number smaller than %d",
           big);
    scanf("%d", &small);
  }
  for (i = 1; i <= big; i++) {
    sum = sum + i;
  }
  printf("Total of all integers between 1 and the big number is: %d\n", sum);
  sum = 0;
  for (i = 1; i <= big; i++) {
    if (i % 2 == 0)
      square = i * i;
    if (i % 2 != 0)
      square = 0;
    sum = sum + square;
  }
  printf("Total sum of the squares of all the even numbers between 1 and the "
         "big number is: %d\n",
         sum);
  int bigArray[big];
  int product = 1;
  for (i = 0; i <= big; i++) {
    bigArray[i] = 1 + rand() % 100;
  }
  for (i = 0; i < big; i++) {
    if ((bigArray[i] % 5 == 0 || bigArray[i] % 11 == 0)) {
      product = product * bigArray[i];
    }
  }
  printf("The product of all the multiples of either 5 or 11 is: %d\n",
         product);
  printf("Original Array:\n");
  for (i = 0; i < big; i++) {
    printf("%d, ", bigArray[i]);
  }
  int tempStorage;
  for (i = 1; i < big; i++) {
    for (j = 0; j < big - 1; j++) {
      if (bigArray[j] > bigArray[j + 1]) {
        tempStorage = bigArray[j];
        bigArray[j] = bigArray[j + 1];
        bigArray[j + 1] = tempStorage;
      }
    }
  }
  printf("\nSorted Array:\n");
  for (i = 0; i < big; i++) {
    printf("%d, ", bigArray[i]);
  }
  printf("\nThe %d largest element in the bigArray is: %d\n", small,
         bigArray[big - small]);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
lea    0xeac(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeef(%rip),%rdi
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
lea    0xed9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11b9 <main+0x89>
mov    -0x8(%rbp),%esi
lea    0xed1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeab(%rip),%rdi
lea    -0xc(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
jmp    1185 <main+0x55>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     11e3 <main+0xb3>
mov    -0x18(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11c0 <main+0x90>
mov    -0x18(%rbp),%esi
lea    0xedd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x18(%rbp)
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     125e <main+0x12e>
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    122c <main+0xfc>
mov    -0x10(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     1247 <main+0x117>
movl   $0x0,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1202 <main+0xd2>
mov    -0x18(%rbp),%esi
lea    0xe9d(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x28(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x40(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
movl   $0x1,-0x34(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     12db <main+0x1ab>
mov    $0x0,%al
call   1050 <rand@plt>
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    -0x40(%rbp),%rax
add    $0x1,%edx
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12a4 <main+0x174>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    134b <main+0x21b>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     1326 <main+0x1f6>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xb,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1338 <main+0x208>
mov    -0x40(%rbp),%rcx
mov    -0x34(%rbp),%eax
movslq -0x10(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    %eax,-0x34(%rbp)
jmp    133d <main+0x20d>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12e2 <main+0x1b2>
mov    -0x34(%rbp),%esi
lea    0xe06(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xe33(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13a4 <main+0x274>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xe18(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1371 <main+0x241>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1442 <main+0x312>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    142f <main+0x2ff>
mov    -0x40(%rbp),%rcx
movslq -0x14(%rbp),%rax
mov    (%rcx,%rax,4),%eax
mov    -0x14(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jle    141c <main+0x2ec>
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    %ecx,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%edx
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1421 <main+0x2f1>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13be <main+0x28e>
jmp    1434 <main+0x304>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13ab <main+0x27b>
lea    0xd63(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    148a <main+0x35a>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xd32(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1457 <main+0x327>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%esi
mov    -0x8(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
lea    0xd18(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
lea    0x10f4(%rip),%rdi
call   1030 <puts@plt>
lea    0xf6e(%rip),%rdi
xor    %r14d,%r14d
lea    -0x24(%rbp),%rsi
lea    -0x28(%rbp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
lea    0xf55(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    -0x24(%rbp),%esi
cmp    -0x28(%rbp),%esi
jge    11cf <main+0x8f>
lea    0xf54(%rip),%r15
lea    0xf35(%rip),%r12
lea    -0x28(%rbp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r12,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
mov    -0x24(%rbp),%esi
cmp    -0x28(%rbp),%esi
jl     11b0 <main+0x70>
test   %esi,%esi
jle    11e8 <main+0xa8>
lea    -0x1(%rsi),%eax
lea    -0x2(%rsi),%ecx
imul   %rax,%rcx
shr    %rcx
lea    (%rcx,%rsi,2),%r14d
add    $0xffffffff,%r14d
lea    0xf5a(%rip),%rdi
xor    %ebx,%ebx
mov    %r14d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    -0x24(%rbp),%eax
test   %eax,%eax
jle    13f4 <main+0x2b4>
xor    %ecx,%ecx
mov    $0x1,%edx
mov    $0x0,%ebx
cmp    $0x8,%eax
jb     13d3 <main+0x293>
mov    %eax,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%edi
mov    %edi,%esi
shr    $0x3,%esi
add    $0x1,%esi
test   %edi,%edi
je     1856 <main+0x716>
mov    %esi,%edi
and    $0xfffffffe,%edi
pxor   %xmm8,%xmm8
movdqa 0xdbb(%rip),%xmm4
movdqa 0xdc2(%rip),%xmm9
movdqa 0xdc9(%rip),%xmm10
movdqa 0xdd0(%rip),%xmm11
movdqa 0xdd7(%rip),%xmm12
movdqa 0xddf(%rip),%xmm3
pxor   %xmm0,%xmm0
pxor   %xmm2,%xmm2
nopl   0x0(%rax)
movdqa %xmm4,%xmm6
paddd  %xmm9,%xmm6
movdqa %xmm4,%xmm1
pand   %xmm10,%xmm1
pcmpeqd %xmm8,%xmm1
movdqa %xmm4,%xmm5
pmuludq %xmm4,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pshufd $0xf5,%xmm4,%xmm7
pmuludq %xmm7,%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm5
pshufd $0xf5,%xmm6,%xmm7
pmuludq %xmm6,%xmm6
pshufd $0xe8,%xmm6,%xmm6
pmuludq %xmm7,%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm6
pand   %xmm1,%xmm5
paddd  %xmm0,%xmm5
pand   %xmm1,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm4,%xmm0
paddd  %xmm11,%xmm0
movdqa %xmm4,%xmm2
paddd  %xmm12,%xmm2
pshufd $0xf5,%xmm0,%xmm7
pmuludq %xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm7,%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm0
pshufd $0xf5,%xmm2,%xmm7
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm7,%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm2
pand   %xmm1,%xmm0
paddd  %xmm5,%xmm0
pand   %xmm1,%xmm2
paddd  %xmm6,%xmm2
paddd  %xmm3,%xmm4
add    $0xfffffffe,%edi
jne    1280 <main+0x140>
test   $0x1,%sil
je     13b2 <main+0x272>
movdqa 0xcbc(%rip),%xmm1
paddd  %xmm4,%xmm1
movdqa 0xcc0(%rip),%xmm3
pand   %xmm4,%xmm3
pxor   %xmm5,%xmm5
pcmpeqd %xmm3,%xmm5
pshufd $0xf5,%xmm4,%xmm3
pmuludq %xmm4,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pmuludq %xmm3,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm4
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm3,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
pand   %xmm5,%xmm4
paddd  %xmm4,%xmm0
pand   %xmm5,%xmm1
paddd  %xmm1,%xmm2
paddd  %xmm2,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebx
cmp    %edx,%eax
je     13f4 <main+0x2b4>
or     $0x1,%edx
add    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
mov    %edx,%esi
imul   %edx,%esi
test   $0x1,%dl
cmovne %ecx,%esi
add    %esi,%ebx
add    $0x1,%edx
cmp    %edx,%eax
jne    13e0 <main+0x2a0>
lea    0xd89(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %rsp,%r14
mov    -0x24(%rbp),%eax
mov    %rsp,%r12
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r12
mov    %r12,%rsp
mov    $0x1,%r15d
cmpl   $0x0,-0x24(%rbp)
js     168a <main+0x54a>
mov    $0xffffffffffffffff,%rbx
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
call   1060 <rand@plt>
cltq
imul   $0x51eb851f,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x25,%rcx
add    %edx,%ecx
imul   $0x64,%ecx,%ecx
neg    %ecx
add    %ecx,%eax
add    $0x1,%eax
mov    %eax,0x4(%r12,%rbx,4)
movslq -0x24(%rbp),%rax
add    $0x1,%rbx
cmp    %rax,%rbx
jl     1440 <main+0x300>
mov    %eax,%eax
test   %eax,%eax
jle    168a <main+0x54a>
cmp    $0x8,%eax
jae    1495 <main+0x355>
mov    $0x1,%r15d
xor    %ecx,%ecx
jmp    17ba <main+0x67a>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    0x0(,%rax,4),%rdx
and    $0xffffffffffffffe0,%rdx
movdqa 0xb71(%rip),%xmm9
xor    %esi,%esi
movdqa 0xbc6(%rip),%xmm13
pcmpeqd %xmm15,%xmm15
movdqa 0xbd8(%rip),%xmm14
movdqa %xmm9,%xmm6
movdqa 0xbba(%rip),%xmm10
movdqa 0xbd1(%rip),%xmm11
movdqa 0xbd8(%rip),%xmm12
nopl   0x0(%rax,%rax,1)
movdqa (%r12,%rsi,1),%xmm4
movdqa 0x10(%r12,%rsi,1),%xmm2
movdqa %xmm4,%xmm1
movdqa 0xb57(%rip),%xmm0
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm3
pshufd $0xf5,%xmm4,%xmm8
movdqa %xmm8,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm3
movdqa %xmm2,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm2,%xmm5
movdqa %xmm5,%xmm7
pmuludq %xmm0,%xmm7
pshufd $0xe8,%xmm7,%xmm7
punpckldq %xmm7,%xmm1
movdqa %xmm4,%xmm7
pmuludq %xmm14,%xmm7
pshufd $0xe8,%xmm7,%xmm7
pmuludq %xmm14,%xmm8
pshufd $0xe8,%xmm8,%xmm0
punpckldq %xmm0,%xmm7
movdqa 0xafd(%rip),%xmm8
paddd  %xmm8,%xmm3
pxor   %xmm13,%xmm3
pcmpgtd %xmm10,%xmm3
pxor   %xmm15,%xmm3
paddd  %xmm11,%xmm7
pxor   %xmm13,%xmm7
pcmpgtd %xmm12,%xmm7
pxor   %xmm15,%xmm7
por    %xmm3,%xmm7
movdqa %xmm2,%xmm0
pmuludq %xmm14,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm14,%xmm5
pshufd $0xe8,%xmm5,%xmm3
punpckldq %xmm3,%xmm0
paddd  %xmm8,%xmm1
pxor   %xmm13,%xmm1
pcmpgtd %xmm10,%xmm1
pxor   %xmm15,%xmm1
paddd  %xmm11,%xmm0
pxor   %xmm13,%xmm0
pcmpgtd %xmm12,%xmm0
pxor   %xmm15,%xmm0
por    %xmm1,%xmm0
pand   %xmm7,%xmm4
paddd  %xmm7,%xmm4
psubd  %xmm15,%xmm4
pand   %xmm0,%xmm2
paddd  %xmm0,%xmm2
pshufd $0xf5,%xmm4,%xmm0
pmuludq %xmm9,%xmm4
pshufd $0xf5,%xmm9,%xmm1
pmuludq %xmm0,%xmm1
psubd  %xmm15,%xmm2
pshufd $0xe8,%xmm4,%xmm9
pshufd $0xe8,%xmm1,%xmm0
punpckldq %xmm0,%xmm9
pshufd $0xf5,%xmm2,%xmm0
pmuludq %xmm6,%xmm2
pshufd $0xf5,%xmm6,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm2,%xmm6
pshufd $0xe8,%xmm1,%xmm0
punpckldq %xmm0,%xmm6
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    14f0 <main+0x3b0>
pshufd $0xf5,%xmm9,%xmm0
pshufd $0xf5,%xmm6,%xmm1
pmuludq %xmm0,%xmm1
pmuludq %xmm9,%xmm6
pshufd $0xee,%xmm6,%xmm0
pmuludq %xmm6,%xmm0
pshufd $0xaa,%xmm1,%xmm2
pmuludq %xmm1,%xmm2
pmuludq %xmm0,%xmm2
movd   %xmm2,%r15d
cmp    %rax,%rcx
jne    17ba <main+0x67a>
lea    0xb49(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xbf8(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,-0x24(%rbp)
jle    17e7 <main+0x6a7>
lea    0xb5d(%rip),%r15
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rbx,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
movslq -0x24(%rbp),%rax
cmp    %rax,%rbx
jl     16c0 <main+0x580>
cmp    $0x2,%eax
jl     17e7 <main+0x6a7>
lea    -0x1(%rax),%r8d
mov    %r8d,%edx
and    $0xfffffffe,%edx
mov    $0x1,%r9d
jmp    170d <main+0x5cd>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r9d
cmp    %eax,%r9d
je     17e7 <main+0x6a7>
mov    (%r12),%esi
cmp    $0x1,%r8d
jne    1740 <main+0x600>
xor    %ecx,%ecx
test   $0x1,%r8b
je     1700 <main+0x5c0>
mov    0x4(%r12,%rcx,4),%edi
cmp    %edi,%esi
jle    1700 <main+0x5c0>
mov    %edi,(%r12,%rcx,4)
mov    %esi,0x4(%r12,%rcx,4)
jmp    1700 <main+0x5c0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ebx,%ebx
jmp    1762 <main+0x622>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %edi,0x4(%r12,%rbx,4)
mov    %esi,0x8(%r12,%rbx,4)
mov    %rcx,%rbx
cmp    %rcx,%rdx
je     1719 <main+0x5d9>
mov    0x4(%r12,%rbx,4),%ecx
cmp    %ecx,%esi
jle    1780 <main+0x640>
mov    %ecx,(%r12,%rbx,4)
mov    %esi,0x4(%r12,%rbx,4)
jmp    1782 <main+0x642>
cs nopw 0x0(%rax,%rax,1)
mov    %ecx,%esi
lea    0x2(%rbx),%rcx
mov    0x8(%r12,%rbx,4),%edi
cmp    %edi,%esi
jg     1750 <main+0x610>
mov    %edi,%esi
jmp    175a <main+0x61a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x33333333,%esi
cmovb  %edx,%edi
imul   %edi,%r15d
add    $0x1,%rcx
cmp    %rcx,%rax
je     168a <main+0x54a>
mov    (%r12,%rcx,4),%edx
imul   $0xcccccccd,%edx,%esi
add    $0x19999999,%esi
imul   $0xba2e8ba3,%edx,%ebx
add    $0xba2e8ba,%ebx
mov    %edx,%edi
cmp    $0x1745d175,%ebx
jb     17a0 <main+0x660>
mov    $0x1,%edi
jmp    17a0 <main+0x660>
lea    0xabc(%rip),%rdi
call   1030 <puts@plt>
mov    -0x24(%rbp),%eax
test   %eax,%eax
jle    182b <main+0x6eb>
lea    0xa14(%rip),%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r12,%rbx,4),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
movslq -0x24(%rbp),%rax
cmp    %rax,%rbx
jl     1810 <main+0x6d0>
mov    -0x28(%rbp),%esi
sub    %esi,%eax
cltq
mov    (%r12,%rax,4),%edx
lea    0x9dd(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r14,%rsp
xor    %eax,%eax
lea    -0x20(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm0,%xmm0
movdqa 0x79e(%rip),%xmm4
pxor   %xmm2,%xmm2
test   $0x1,%sil
jne    134c <main+0x20c>
jmp    13b2 <main+0x272>

LLVM IR (-O0):
@.str = [81 x i8] c"Please enter 2 numbers:\0AThe Second number must be smaller than the first number\0A\00"
@.str.1 = [6 x i8] c"%d %d\00"
@.str.2 = [21 x i8] c"You entered: %d, %d\0A\00"
@.str.3 = [94 x i8] c"The second number is not smaller than the first number, please enter a number smaller than %d\00"
@.str.4 = [3 x i8] c"%d\00"
@.str.5 = [59 x i8] c"Total of all integers between 1 and the big number is: %d\0A\00"
@.str.6 = [86 x i8] c"Total sum of the squares of all the even numbers between 1 and the big number is: %d\0A\00"
@.str.7 = [59 x i8] c"The product of all the multiples of either 5 or 11 is: %d\0A\00"
@.str.8 = [17 x i8] c"Original Array:\0A\00"
@.str.9 = [5 x i8] c"%d, \00"
@.str.10 = [16 x i8] c"\0ASorted Array:\0A\00"
@.str.11 = [48 x i8] c"\0AThe %d largest element in the bigArray is: %d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i32
%11 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %6
store i32 0, i32* %7
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str, i64 0, i64 0))
%13 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i32* %2, i32* %3)
%14 = load i32, i32* %2
%15 = load i32, i32* %3
%16 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.2, i64 0, i64 0), i32 %14, i32 %15)
br label %17
17: ; preds = %21, %0
%18 = load i32, i32* %2
%19 = load i32, i32* %3
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %25
21: ; preds = %17
%22 = load i32, i32* %2
%23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([94 x i8], [94 x i8]* @.str.3, i64 0, i64 0), i32 %22)
%24 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %3)
br label %17
25: ; preds = %17
store i32 1, i32* %4
br label %26
26: ; preds = %34, %25
%27 = load i32, i32* %4
%28 = load i32, i32* %2
%29 = icmp sle i32 %27, %28
br i1 %29, label %30, label %37
30: ; preds = %26
%31 = load i32, i32* %6
%32 = load i32, i32* %4
%33 = add nsw i32 %31, %32
store i32 %33, i32* %6
br label %34
34: ; preds = %30
%35 = load i32, i32* %4
%36 = add nsw i32 %35, 1
store i32 %36, i32* %4
br label %26
37: ; preds = %26
%38 = load i32, i32* %6
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.5, i64 0, i64 0), i32 %38)
store i32 0, i32* %6
store i32 1, i32* %4
br label %40
40: ; preds = %61, %37
%41 = load i32, i32* %4
%42 = load i32, i32* %2
%43 = icmp sle i32 %41, %42
br i1 %43, label %44, label %64
44: ; preds = %40
%45 = load i32, i32* %4
%46 = srem i32 %45, 2
%47 = icmp eq i32 %46, 0
br i1 %47, label %48, label %52
48: ; preds = %44
%49 = load i32, i32* %4
%50 = load i32, i32* %4
%51 = mul nsw i32 %49, %50
store i32 %51, i32* %7
br label %52
52: ; preds = %48, %44
%53 = load i32, i32* %4
%54 = srem i32 %53, 2
%55 = icmp ne i32 %54, 0
br i1 %55, label %56, label %57
56: ; preds = %52
store i32 0, i32* %7
br label %57
57: ; preds = %56, %52
%58 = load i32, i32* %6
%59 = load i32, i32* %7
%60 = add nsw i32 %58, %59
store i32 %60, i32* %6
br label %61
61: ; preds = %57
%62 = load i32, i32* %4
%63 = add nsw i32 %62, 1
store i32 %63, i32* %4
br label %40
64: ; preds = %40
%65 = load i32, i32* %6
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.6, i64 0, i64 0), i32 %65)
%67 = load i32, i32* %2
%68 = zext i32 %67 to i64
%69 = call i8* @llvm.stacksave()
store i8* %69, i8** %8
%70 = alloca i32, i64 %68
store i64 %68, i64* %9
store i32 1, i32* %10
store i32 0, i32* %4
br label %71
71: ; preds = %82, %64
%72 = load i32, i32* %4
%73 = load i32, i32* %2
%74 = icmp sle i32 %72, %73
br i1 %74, label %75, label %85
75: ; preds = %71
%76 = call i32 (...) @rand()
%77 = srem i32 %76, 100
%78 = add nsw i32 1, %77
%79 = load i32, i32* %4
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %70, i64 %80
store i32 %78, i32* %81
br label %82
82: ; preds = %75
%83 = load i32, i32* %4
%84 = add nsw i32 %83, 1
store i32 %84, i32* %4
br label %71
85: ; preds = %71
store i32 0, i32* %4
br label %86
86: ; preds = %112, %85
%87 = load i32, i32* %4
%88 = load i32, i32* %2
%89 = icmp slt i32 %87, %88
br i1 %89, label %90, label %115
90: ; preds = %86
%91 = load i32, i32* %4
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i32, i32* %70, i64 %92
%94 = load i32, i32* %93
%95 = srem i32 %94, 5
%96 = icmp eq i32 %95, 0
br i1 %96, label %104, label %97
97: ; preds = %90
%98 = load i32, i32* %4
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %70, i64 %99
%101 = load i32, i32* %100
%102 = srem i32 %101, 11
%103 = icmp eq i32 %102, 0
br i1 %103, label %104, label %111
104: ; preds = %97, %90
%105 = load i32, i32* %10
%106 = load i32, i32* %4
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds i32, i32* %70, i64 %107
%109 = load i32, i32* %108
%110 = mul nsw i32 %105, %109
store i32 %110, i32* %10
br label %111
111: ; preds = %104, %97
br label %112
112: ; preds = %111
%113 = load i32, i32* %4
%114 = add nsw i32 %113, 1
store i32 %114, i32* %4
br label %86
115: ; preds = %86
%116 = load i32, i32* %10
%117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.7, i64 0, i64 0), i32 %116)
%118 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.8, i64 0, i64 0))
store i32 0, i32* %4
br label %119
119: ; preds = %129, %115
%120 = load i32, i32* %4
%121 = load i32, i32* %2
%122 = icmp slt i32 %120, %121
br i1 %122, label %123, label %132
123: ; preds = %119
%124 = load i32, i32* %4
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i32, i32* %70, i64 %125
%127 = load i32, i32* %126
%128 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i32 %127)
br label %129
129: ; preds = %123
%130 = load i32, i32* %4
%131 = add nsw i32 %130, 1
store i32 %131, i32* %4
br label %119
132: ; preds = %119
store i32 1, i32* %4
br label %133
133: ; preds = %177, %132
%134 = load i32, i32* %4
%135 = load i32, i32* %2
%136 = icmp slt i32 %134, %135
br i1 %136, label %137, label %180
137: ; preds = %133
store i32 0, i32* %5
br label %138
138: ; preds = %173, %137
%139 = load i32, i32* %5
%140 = load i32, i32* %2
%141 = sub nsw i32 %140, 1
%142 = icmp slt i32 %139, %141
br i1 %142, label %143, label %176
143: ; preds = %138
%144 = load i32, i32* %5
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i32, i32* %70, i64 %145
%147 = load i32, i32* %146
%148 = load i32, i32* %5
%149 = add nsw i32 %148, 1
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %70, i64 %150
%152 = load i32, i32* %151
%153 = icmp sgt i32 %147, %152
br i1 %153, label %154, label %172
154: ; preds = %143
%155 = load i32, i32* %5
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i32, i32* %70, i64 %156
%158 = load i32, i32* %157
store i32 %158, i32* %11
%159 = load i32, i32* %5
%160 = add nsw i32 %159, 1
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32, i32* %70, i64 %161
%163 = load i32, i32* %162
%164 = load i32, i32* %5
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i32, i32* %70, i64 %165
store i32 %163, i32* %166
%167 = load i32, i32* %11
%168 = load i32, i32* %5
%169 = add nsw i32 %168, 1
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i32, i32* %70, i64 %170
store i32 %167, i32* %171
br label %172
172: ; preds = %154, %143
br label %173
173: ; preds = %172
%174 = load i32, i32* %5
%175 = add nsw i32 %174, 1
store i32 %175, i32* %5
br label %138
176: ; preds = %138
br label %177
177: ; preds = %176
%178 = load i32, i32* %4
%179 = add nsw i32 %178, 1
store i32 %179, i32* %4
br label %133
180: ; preds = %133
%181 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.10, i64 0, i64 0))
store i32 0, i32* %4
br label %182
182: ; preds = %192, %180
%183 = load i32, i32* %4
%184 = load i32, i32* %2
%185 = icmp slt i32 %183, %184
br i1 %185, label %186, label %195
186: ; preds = %182
%187 = load i32, i32* %4
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %70, i64 %188
%190 = load i32, i32* %189
%191 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i32 %190)
br label %192
192: ; preds = %186
%193 = load i32, i32* %4
%194 = add nsw i32 %193, 1
store i32 %194, i32* %4
br label %182
195: ; preds = %182
%196 = load i32, i32* %3
%197 = load i32, i32* %2
%198 = load i32, i32* %3
%199 = sub nsw i32 %197, %198
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i32, i32* %70, i64 %200
%202 = load i32, i32* %201
%203 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.11, i64 0, i64 0), i32 %196, i32 %202)
store i32 0, i32* %1
%204 = load i8*, i8** %8
%205 = load i32, i32* %1
ret i32 %205
}

LLVM IR (-O2):
@.str.1 = [6 x i8] c"%d %d\00"
@.str.2 = [21 x i8] c"You entered: %d, %d\0A\00"
@.str.3 = [94 x i8] c"The second number is not smaller than the first number, please enter a number smaller than %d\00"
@.str.4 = [3 x i8] c"%d\00"
@.str.5 = [59 x i8] c"Total of all integers between 1 and the big number is: %d\0A\00"
@.str.6 = [86 x i8] c"Total sum of the squares of all the even numbers between 1 and the big number is: %d\0A\00"
@.str.7 = [59 x i8] c"The product of all the multiples of either 5 or 11 is: %d\0A\00"
@.str.9 = [5 x i8] c"%d, \00"
@.str.11 = [48 x i8] c"\0AThe %d largest element in the bigArray is: %d\0A\00"
@str = [80 x i8] c"Please enter 2 numbers:\0AThe Second number must be smaller than the first number\00"
@str.12 = [16 x i8] c"Original Array:\00"
@str.13 = [15 x i8] c"\0ASorted Array:\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = bitcast i32* %1 to i8*
%4 = bitcast i32* %2 to i8*
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([80 x i8], [80 x i8]* @str, i64 0, i64 0))
%6 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i32* %1, i32* %2)
%7 = load i32, i32* %1
%8 = load i32, i32* %2
%9 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.2, i64 0, i64 0), i32 %7, i32 %8)
%10 = load i32, i32* %1
%11 = load i32, i32* %2
%12 = icmp slt i32 %10, %11
br i1 %12, label %27, label %13
13: ; preds = %27, %0
%14 = phi i32 [ %10, %0 ], [ %31, %27 ]
%15 = icmp slt i32 %14, 1
br i1 %15, label %34, label %16
16: ; preds = %13
%17 = shl nuw i32 %14, 1
%18 = add nsw i32 %14, -1
%19 = zext i32 %18 to i33
%20 = add nsw i32 %14, -2
%21 = zext i32 %20 to i33
%22 = mul i33 %19, %21
%23 = lshr i33 %22, 1
%24 = trunc i33 %23 to i32
%25 = add i32 %17, %24
%26 = add i32 %25, -1
br label %34
27: ; preds = %0, %27
%28 = phi i32 [ %31, %27 ], [ %10, %0 ]
%29 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @.str.3, i64 0, i64 0), i32 %28)
%30 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %2)
%31 = load i32, i32* %1
%32 = load i32, i32* %2
%33 = icmp slt i32 %31, %32
br i1 %33, label %27, label %13
34: ; preds = %16, %13
%35 = phi i32 [ 0, %13 ], [ %26, %16 ]
%36 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str.5, i64 0, i64 0), i32 %35)
%37 = load i32, i32* %1
%38 = icmp slt i32 %37, 1
br i1 %38, label %120, label %39
39: ; preds = %34
%40 = icmp ult i32 %37, 8
br i1 %40, label %107, label %41
41: ; preds = %39
%42 = and i32 %37, -8
%43 = or i32 %42, 1
%44 = add i32 %42, -8
%45 = lshr exact i32 %44, 3
%46 = add nuw nsw i32 %45, 1
%47 = and i32 %46, 1
%48 = icmp eq i32 %44, 0
br i1 %48, label %82, label %49
49: ; preds = %41
%50 = and i32 %46, 1073741822
br label %51
51: ; preds = %51, %49
%52 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %49 ], [ %79, %51 ]
%53 = phi <4 x i32> [ zeroinitializer, %49 ], [ %77, %51 ]
%54 = phi <4 x i32> [ zeroinitializer, %49 ], [ %78, %51 ]
%55 = phi i32 [ 0, %49 ], [ %80, %51 ]
%56 = add <4 x i32> %52, <i32 4, i32 4, i32 4, i32 4>
%57 = and <4 x i32> %52, <i32 1, i32 1, i32 1, i32 1>
%58 = and <4 x i32> %52, <i32 1, i32 1, i32 1, i32 1>
%59 = icmp eq <4 x i32> %57, zeroinitializer
%60 = icmp eq <4 x i32> %58, zeroinitializer
%61 = mul nsw <4 x i32> %52, %52
%62 = mul nsw <4 x i32> %56, %56
%63 = select <4 x i1> %59, <4 x i32> %61, <4 x i32> zeroinitializer
%64 = select <4 x i1> %60, <4 x i32> %62, <4 x i32> zeroinitializer
%65 = add <4 x i32> %63, %53
%66 = add <4 x i32> %64, %54
%67 = add <4 x i32> %52, <i32 8, i32 8, i32 8, i32 8>
%68 = add <4 x i32> %52, <i32 12, i32 12, i32 12, i32 12>
%69 = and <4 x i32> %52, <i32 1, i32 1, i32 1, i32 1>
%70 = and <4 x i32> %52, <i32 1, i32 1, i32 1, i32 1>
%71 = icmp eq <4 x i32> %69, zeroinitializer
%72 = icmp eq <4 x i32> %70, zeroinitializer
%73 = mul nsw <4 x i32> %67, %67
%74 = mul nsw <4 x i32> %68, %68
%75 = select <4 x i1> %71, <4 x i32> %73, <4 x i32> zeroinitializer
%76 = select <4 x i1> %72, <4 x i32> %74, <4 x i32> zeroinitializer
%77 = add <4 x i32> %75, %65
%78 = add <4 x i32> %76, %66
%79 = add <4 x i32> %52, <i32 16, i32 16, i32 16, i32 16>
%80 = add i32 %55, 2
%81 = icmp eq i32 %80, %50
br i1 %81, label %82, label %51
82: ; preds = %51, %41
%83 = phi <4 x i32> [ undef, %41 ], [ %77, %51 ]
%84 = phi <4 x i32> [ undef, %41 ], [ %78, %51 ]
%85 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %41 ], [ %79, %51 ]
%86 = phi <4 x i32> [ zeroinitializer, %41 ], [ %77, %51 ]
%87 = phi <4 x i32> [ zeroinitializer, %41 ], [ %78, %51 ]
%88 = icmp eq i32 %47, 0
br i1 %88, label %101, label %89
89: ; preds = %82
%90 = add <4 x i32> %85, <i32 4, i32 4, i32 4, i32 4>
%91 = and <4 x i32> %85, <i32 1, i32 1, i32 1, i32 1>
%92 = and <4 x i32> %85, <i32 1, i32 1, i32 1, i32 1>
%93 = icmp eq <4 x i32> %91, zeroinitializer
%94 = icmp eq <4 x i32> %92, zeroinitializer
%95 = mul nsw <4 x i32> %85, %85
%96 = mul nsw <4 x i32> %90, %90
%97 = select <4 x i1> %93, <4 x i32> %95, <4 x i32> zeroinitializer
%98 = select <4 x i1> %94, <4 x i32> %96, <4 x i32> zeroinitializer
%99 = add <4 x i32> %97, %86
%100 = add <4 x i32> %98, %87
br label %101
101: ; preds = %82, %89
%102 = phi <4 x i32> [ %83, %82 ], [ %99, %89 ]
%103 = phi <4 x i32> [ %84, %82 ], [ %100, %89 ]
%104 = add <4 x i32> %103, %102
%105 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %104)
%106 = icmp eq i32 %37, %42
br i1 %106, label %120, label %107
107: ; preds = %39, %101
%108 = phi i32 [ 1, %39 ], [ %43, %101 ]
%109 = phi i32 [ 0, %39 ], [ %105, %101 ]
br label %110
110: ; preds = %107, %110
%111 = phi i32 [ %118, %110 ], [ %108, %107 ]
%112 = phi i32 [ %117, %110 ], [ %109, %107 ]
%113 = and i32 %111, 1
%114 = icmp eq i32 %113, 0
%115 = mul nsw i32 %111, %111
%116 = select i1 %114, i32 %115, i32 0
%117 = add nuw nsw i32 %116, %112
%118 = add nuw i32 %111, 1
%119 = icmp eq i32 %111, %37
br i1 %119, label %120, label %110
120: ; preds = %110, %101, %34
%121 = phi i32 [ 0, %34 ], [ %105, %101 ], [ %117, %110 ]
%122 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([86 x i8], [86 x i8]* @.str.6, i64 0, i64 0), i32 %121)
%123 = load i32, i32* %1
%124 = zext i32 %123 to i64
%125 = call i8* @llvm.stacksave()
%126 = alloca i32, i64 %124
%127 = load i32, i32* %1
%128 = icmp slt i32 %127, 0
br i1 %128, label %193, label %169
129: ; preds = %169
%130 = icmp sgt i32 %176, 0
br i1 %130, label %131, label %193
131: ; preds = %129
%132 = zext i32 %176 to i64
%133 = icmp ult i32 %176, 8
br i1 %133, label %166, label %134
134: ; preds = %131
%135 = and i64 %132, 4294967288
br label %136
136: ; preds = %136, %134
%137 = phi i64 [ 0, %134 ], [ %160, %136 ]
%138 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %134 ], [ %158, %136 ]
%139 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %134 ], [ %159, %136 ]
%140 = getelementptr inbounds i32, i32* %126, i64 %137
%141 = bitcast i32* %140 to <4 x i32>*
%142 = load <4 x i32>, <4 x i32>* %141
%143 = getelementptr inbounds i32, i32* %140, i64 4
%144 = bitcast i32* %143 to <4 x i32>*
%145 = load <4 x i32>, <4 x i32>* %144
%146 = srem <4 x i32> %142, <i32 5, i32 5, i32 5, i32 5>
%147 = srem <4 x i32> %145, <i32 5, i32 5, i32 5, i32 5>
%148 = icmp eq <4 x i32> %146, zeroinitializer
%149 = icmp eq <4 x i32> %147, zeroinitializer
%150 = srem <4 x i32> %142, <i32 11, i32 11, i32 11, i32 11>
%151 = srem <4 x i32> %145, <i32 11, i32 11, i32 11, i32 11>
%152 = icmp eq <4 x i32> %150, zeroinitializer
%153 = icmp eq <4 x i32> %151, zeroinitializer
%154 = or <4 x i1> %148, %152
%155 = or <4 x i1> %149, %153
%156 = select <4 x i1> %154, <4 x i32> %142, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
%157 = select <4 x i1> %155, <4 x i32> %145, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
%158 = mul <4 x i32> %156, %138
%159 = mul <4 x i32> %157, %139
%160 = add nuw i64 %137, 8
%161 = icmp eq i64 %160, %135
br i1 %161, label %162, label %136
162: ; preds = %136
%163 = mul <4 x i32> %159, %158
%164 = call i32 @llvm.vector.reduce.mul.v4i32(<4 x i32> %163)
%165 = icmp eq i64 %135, %132
br i1 %165, label %193, label %166
166: ; preds = %131, %162
%167 = phi i64 [ 0, %131 ], [ %135, %162 ]
%168 = phi i32 [ 1, %131 ], [ %164, %162 ]
br label %179
169: ; preds = %120, %169
%170 = phi i64 [ %175, %169 ], [ 0, %120 ]
%171 = call i32 (...) @rand()
%172 = srem i32 %171, 100
%173 = add nsw i32 %172, 1
%174 = getelementptr inbounds i32, i32* %126, i64 %170
store i32 %173, i32* %174
%175 = add nuw nsw i64 %170, 1
%176 = load i32, i32* %1
%177 = sext i32 %176 to i64
%178 = icmp slt i64 %170, %177
br i1 %178, label %169, label %129
179: ; preds = %166, %179
%180 = phi i64 [ %191, %179 ], [ %167, %166 ]
%181 = phi i32 [ %190, %179 ], [ %168, %166 ]
%182 = getelementptr inbounds i32, i32* %126, i64 %180
%183 = load i32, i32* %182
%184 = srem i32 %183, 5
%185 = icmp eq i32 %184, 0
%186 = srem i32 %183, 11
%187 = icmp eq i32 %186, 0
%188 = or i1 %185, %187
%189 = select i1 %188, i32 %183, i32 1
%190 = mul nsw i32 %189, %181
%191 = add nuw nsw i64 %180, 1
%192 = icmp eq i64 %191, %132
br i1 %192, label %193, label %179
193: ; preds = %179, %162, %120, %129
%194 = phi i32 [ 1, %129 ], [ 1, %120 ], [ %164, %162 ], [ %190, %179 ]
%195 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str.7, i64 0, i64 0), i32 %194)
%196 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @str.12, i64 0, i64 0))
%197 = load i32, i32* %1
%198 = icmp sgt i32 %197, 0
br i1 %198, label %208, label %255
199: ; preds = %208
%200 = icmp sgt i32 %214, 1
br i1 %200, label %201, label %255
201: ; preds = %199
%202 = add nsw i32 %214, -1
%203 = zext i32 %202 to i64
%204 = and i64 %203, 1
%205 = icmp eq i32 %202, 1
%206 = and i64 %203, 4294967294
%207 = icmp eq i64 %204, 0
br label %217
208: ; preds = %193, %208
%209 = phi i64 [ %213, %208 ], [ 0, %193 ]
%210 = getelementptr inbounds i32, i32* %126, i64 %209
%211 = load i32, i32* %210
%212 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i32 %211)
%213 = add nuw nsw i64 %209, 1
%214 = load i32, i32* %1
%215 = sext i32 %214 to i64
%216 = icmp slt i64 %213, %215
br i1 %216, label %208, label %199
217: ; preds = %252, %201
%218 = phi i32 [ 1, %201 ], [ %253, %252 ]
%219 = load i32, i32* %126
br i1 %205, label %242, label %220
220: ; preds = %217, %238
%221 = phi i32 [ %239, %238 ], [ %219, %217 ]
%222 = phi i64 [ %232, %238 ], [ 0, %217 ]
%223 = phi i64 [ %240, %238 ], [ 0, %217 ]
%224 = or i64 %222, 1
%225 = getelementptr inbounds i32, i32* %126, i64 %224
%226 = load i32, i32* %225
%227 = icmp sgt i32 %221, %226
br i1 %227, label %228, label %230
228: ; preds = %220
%229 = getelementptr inbounds i32, i32* %126, i64 %222
store i32 %226, i32* %229
store i32 %221, i32* %225
br label %230
230: ; preds = %220, %228
%231 = phi i32 [ %226, %220 ], [ %221, %228 ]
%232 = add nuw nsw i64 %222, 2
%233 = getelementptr inbounds i32, i32* %126, i64 %232
%234 = load i32, i32* %233
%235 = icmp sgt i32 %231, %234
br i1 %235, label %236, label %238
236: ; preds = %230
%237 = getelementptr inbounds i32, i32* %126, i64 %224
store i32 %234, i32* %237
store i32 %231, i32* %233
br label %238
238: ; preds = %236, %230
%239 = phi i32 [ %234, %230 ], [ %231, %236 ]
%240 = add i64 %223, 2
%241 = icmp eq i64 %240, %206
br i1 %241, label %242, label %220
242: ; preds = %238, %217
%243 = phi i32 [ %219, %217 ], [ %239, %238 ]
%244 = phi i64 [ 0, %217 ], [ %232, %238 ]
br i1 %207, label %252, label %245
245: ; preds = %242
%246 = add nuw nsw i64 %244, 1
%247 = getelementptr inbounds i32, i32* %126, i64 %246
%248 = load i32, i32* %247
%249 = icmp sgt i32 %243, %248
br i1 %249, label %250, label %252
250: ; preds = %245
%251 = getelementptr inbounds i32, i32* %126, i64 %244
store i32 %248, i32* %251
store i32 %243, i32* %247
br label %252
252: ; preds = %245, %250, %242
%253 = add nuw nsw i32 %218, 1
%254 = icmp eq i32 %253, %214
br i1 %254, label %255, label %217
255: ; preds = %252, %193, %199
%256 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str.13, i64 0, i64 0))
%257 = load i32, i32* %1
%258 = icmp sgt i32 %257, 0
br i1 %258, label %259, label %268
259: ; preds = %255, %259
%260 = phi i64 [ %264, %259 ], [ 0, %255 ]
%261 = getelementptr inbounds i32, i32* %126, i64 %260
%262 = load i32, i32* %261
%263 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i32 %262)
%264 = add nuw nsw i64 %260, 1
%265 = load i32, i32* %1
%266 = sext i32 %265 to i64
%267 = icmp slt i64 %264, %266
br i1 %267, label %259, label %268
268: ; preds = %259, %255
%269 = phi i32 [ %257, %255 ], [ %265, %259 ]
%270 = load i32, i32* %2
%271 = sub nsw i32 %269, %270
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds i32, i32* %126, i64 %272
%274 = load i32, i32* %273
%275 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.11, i64 0, i64 0), i32 %270, i32 %274)
ret i32 0
}