#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[100], i, num, sum, min, max;
  double avg = 0;
  printf("Enter n: ");
  scanf("%d", &num);
  for (i = 0; i < num; i++) {
    scanf("%d", &a[i]);
  }
  min = a[0];
  max = a[0];
  sum = 0;
  avg = 0;
  for (i = 0; i < num; i++) {
    if (a[i] < min) {
      min = a[i];
    }
  }
  for (i = 0; i < num; i++) {
    if (a[i] > max) {
      max = a[i];
    }
  }
  for (i = 0; i < num; i++) {
    sum = sum + a[i];
  }
  avg = sum / num;
  printf("Min = %d\n", min);
  printf("Max = %d\n", max);
  printf("Sum = %d\n", sum);
  printf("Avg = %.2lf\n", avg);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
movl   $0x0,-0x4(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
lea    0xebc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeb8(%rip),%rdi
lea    -0x1a8(%rbp),%rsi
call   1040 <scanf@plt>
movl   $0x0,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
cmp    -0x1a8(%rbp),%eax
jge    11af <main+0x8f>
movslq -0x1a4(%rbp),%rax
lea    -0x1a0(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe74(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    1168 <main+0x48>
mov    -0x1a0(%rbp),%eax
mov    %eax,-0x1b0(%rbp)
mov    -0x1a0(%rbp),%eax
mov    %eax,-0x1b4(%rbp)
movl   $0x0,-0x1ac(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movl   $0x0,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
cmp    -0x1a8(%rbp),%eax
jge    123f <main+0x11f>
movslq -0x1a4(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%eax
cmp    -0x1b0(%rbp),%eax
jge    1226 <main+0x106>
movslq -0x1a4(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%eax
mov    %eax,-0x1b0(%rbp)
jmp    122b <main+0x10b>
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    11e6 <main+0xc6>
movl   $0x0,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
cmp    -0x1a8(%rbp),%eax
jge    12a2 <main+0x182>
movslq -0x1a4(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%eax
cmp    -0x1b4(%rbp),%eax
jle    1289 <main+0x169>
movslq -0x1a4(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%eax
mov    %eax,-0x1b4(%rbp)
jmp    128e <main+0x16e>
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    1249 <main+0x129>
movl   $0x0,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
cmp    -0x1a8(%rbp),%eax
jge    12ec <main+0x1cc>
mov    -0x1ac(%rbp),%eax
movslq -0x1a4(%rbp),%rcx
add    -0x1a0(%rbp,%rcx,4),%eax
mov    %eax,-0x1ac(%rbp)
mov    -0x1a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a4(%rbp)
jmp    12ac <main+0x18c>
mov    -0x1ac(%rbp),%eax
cltd
idivl  -0x1a8(%rbp)
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x1b0(%rbp),%esi
lea    0xcfb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1b4(%rbp),%esi
lea    0xcf1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1ac(%rbp),%esi
lea    0xce7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movsd  -0x1c0(%rbp),%xmm0
ff
lea    0xcdb(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r14
push   %rbx
sub    $0x1a0,%rsp
lea    0xece(%rip),%rdi
xor    %ebx,%ebx
xor    %eax,%eax
call   1030 <printf@plt>
lea    0xec8(%rip),%r14
lea    0x4(%rsp),%rsi
mov    %r14,%rdi
call   1040 <scanf@plt>
lea    0x10(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14,%rdi
mov    %rbp,%rsi
call   1040 <scanf@plt>
add    $0x1,%rbx
movslq 0x4(%rsp),%rax
add    $0x4,%rbp
cmp    %rax,%rbx
jl     1160 <main+0x40>
mov    %eax,%ecx
mov    0x10(%rsp),%eax
xor    %ebx,%ebx
test   %ecx,%ecx
jle    14ae <main+0x38e>
mov    %eax,%esi
cmp    $0x1,%ecx
je     1312 <main+0x1f2>
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
mov    %eax,%esi
cmp    $0x8,%r8
jb     1300 <main+0x1e0>
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
test   %rsi,%rsi
je     1501 <main+0x3e1>
mov    %rdi,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %esi,%esi
movdqa %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu 0x14(%rsp,%rsi,4),%xmm2
movdqu 0x24(%rsp,%rsi,4),%xmm3
movdqu 0x34(%rsp,%rsi,4),%xmm4
movdqu 0x44(%rsp,%rsi,4),%xmm5
movdqa %xmm0,%xmm6
pcmpgtd %xmm2,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm0,%xmm6
por    %xmm2,%xmm6
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm6,%xmm0
pcmpgtd %xmm4,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm6,%xmm0
por    %xmm4,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm2,%xmm1
por    %xmm5,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rbp
jne    11f0 <main+0xd0>
test   $0x1,%dil
je     12ac <main+0x18c>
shl    $0x2,%rsi
or     $0x4,%rsi
movdqu 0x10(%rsp,%rsi,1),%xmm2
movdqu 0x20(%rsp,%rsi,1),%xmm3
movdqa %xmm0,%xmm4
pcmpgtd %xmm2,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm2,%xmm1
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rdx,%r8
je     1312 <main+0x1f2>
or     $0x1,%rdx
nop
mov    0x10(%rsp,%rdx,4),%edi
cmp    %esi,%edi
cmovl  %edi,%esi
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1300 <main+0x1e0>
test   %ecx,%ecx
jle    14b7 <main+0x397>
mov    %eax,%ebp
cmp    $0x1,%ecx
je     14a2 <main+0x382>
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
mov    %eax,%ebp
cmp    $0x8,%r8
jb     1490 <main+0x370>
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rdi
mov    %rdi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdi,%rdi
je     166f <main+0x54f>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
mov    $0x1,%ebx
movdqa %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu 0x10(%rsp,%rbx,4),%xmm2
movdqu 0x20(%rsp,%rbx,4),%xmm3
movdqu 0x30(%rsp,%rbx,4),%xmm4
movdqu 0x40(%rsp,%rbx,4),%xmm5
movdqa %xmm2,%xmm6
pcmpgtd %xmm0,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm0,%xmm6
por    %xmm2,%xmm6
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
pcmpgtd %xmm6,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm6,%xmm0
por    %xmm4,%xmm0
movdqa %xmm5,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm2,%xmm1
por    %xmm5,%xmm1
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1380 <main+0x260>
test   $0x1,%r9b
je     1434 <main+0x314>
movdqu 0x10(%rsp,%rbx,4),%xmm2
movdqu 0x20(%rsp,%rbx,4),%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%ebp
cmp    %rdx,%r8
je     14a2 <main+0x382>
or     $0x1,%rdx
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp,%rdx,4),%edi
cmp    %ebp,%edi
cmovg  %edi,%ebp
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1490 <main+0x370>
cmp    $0x1,%ecx
jne    14be <main+0x39e>
mov    %eax,%ebx
jmp    160d <main+0x4ed>
mov    %eax,%ebp
mov    %eax,%esi
jmp    160d <main+0x4ed>
mov    %eax,%ebp
jmp    160d <main+0x4ed>
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
cmp    $0x8,%r8
jb     15f1 <main+0x4d1>
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
movd   %eax,%xmm0
lea    -0x8(%rdx),%rbx
mov    %rbx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%edi
and    $0x3,%edi
cmp    $0x18,%rbx
jae    1516 <main+0x3f6>
pxor   %xmm1,%xmm1
xor    %ebx,%ebx
jmp    158d <main+0x46d>
xor    %esi,%esi
movdqa %xmm0,%xmm1
test   $0x1,%dil
jne    1268 <main+0x148>
jmp    12ac <main+0x18c>
movabs $0x3ffffffffffffffe,%rbx
ff ff 3f
add    $0xfffffffffffffffe,%rbx
and    %rbx,%rax
pxor   %xmm1,%xmm1
xor    %ebx,%ebx
nopl   (%rax)
movdqu 0x14(%rsp,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x24(%rsp,%rbx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x34(%rsp,%rbx,4),%xmm1
movdqu 0x44(%rsp,%rbx,4),%xmm3
movdqu 0x54(%rsp,%rbx,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x64(%rsp,%rbx,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x74(%rsp,%rbx,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x84(%rsp,%rbx,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rax
jne    1530 <main+0x410>
test   %rdi,%rdi
je     15ca <main+0x4aa>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x0(,%rbx,4),%rax
or     $0x4,%rax
movdqu 0x10(%rsp,%rax,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x20(%rsp,%rax,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x8,%rbx
add    $0xffffffffffffffff,%rdi
jne    15a0 <main+0x480>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %rdx,%r8
je     14a7 <main+0x387>
or     $0x1,%rdx
mov    %eax,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    0x10(%rsp,%rdx,4),%ebx
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1600 <main+0x4e0>
mov    %ebx,%eax
cltd
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x9e7(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
lea    0x9e3(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1030 <printf@plt>
lea    0x9dd(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1030 <printf@plt>
lea    0x9d7(%rip),%rdi
movsd  0x8(%rsp),%xmm0
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x1a0,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
mov    $0x1,%ebx
movdqa %xmm0,%xmm1
test   $0x1,%r9b
jne    13f8 <main+0x2d8>
jmp    1434 <main+0x314>

LLVM IR (-O0):
@.str = [10 x i8] c"Enter n: \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [10 x i8] c"Min = %d\0A\00"
@.str.3 = [10 x i8] c"Max = %d\0A\00"
@.str.4 = [10 x i8] c"Sum = %d\0A\00"
@.str.5 = [13 x i8] c"Avg = %.2lf\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [100 x i32]
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca double
store i32 0, i32* %1
store double 0.000000e+00, double* %8
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0))
%10 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %4)
store i32 0, i32* %3
br label %11
11: ; preds = %20, %0
%12 = load i32, i32* %3
%13 = load i32, i32* %4
%14 = icmp slt i32 %12, %13
br i1 %14, label %15, label %23
15: ; preds = %11
%16 = load i32, i32* %3
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %17
%19 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %18)
br label %20
20: ; preds = %15
%21 = load i32, i32* %3
%22 = add nsw i32 %21, 1
store i32 %22, i32* %3
br label %11
23: ; preds = %11
%24 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 0
%25 = load i32, i32* %24
store i32 %25, i32* %6
%26 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 0
%27 = load i32, i32* %26
store i32 %27, i32* %7
store i32 0, i32* %5
store double 0.000000e+00, double* %8
store i32 0, i32* %3
br label %28
28: ; preds = %45, %23
%29 = load i32, i32* %3
%30 = load i32, i32* %4
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %48
32: ; preds = %28
%33 = load i32, i32* %3
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %34
%36 = load i32, i32* %35
%37 = load i32, i32* %6
%38 = icmp slt i32 %36, %37
br i1 %38, label %39, label %44
39: ; preds = %32
%40 = load i32, i32* %3
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %41
%43 = load i32, i32* %42
store i32 %43, i32* %6
br label %44
44: ; preds = %39, %32
br label %45
45: ; preds = %44
%46 = load i32, i32* %3
%47 = add nsw i32 %46, 1
store i32 %47, i32* %3
br label %28
48: ; preds = %28
store i32 0, i32* %3
br label %49
49: ; preds = %66, %48
%50 = load i32, i32* %3
%51 = load i32, i32* %4
%52 = icmp slt i32 %50, %51
br i1 %52, label %53, label %69
53: ; preds = %49
%54 = load i32, i32* %3
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %55
%57 = load i32, i32* %56
%58 = load i32, i32* %7
%59 = icmp sgt i32 %57, %58
br i1 %59, label %60, label %65
60: ; preds = %53
%61 = load i32, i32* %3
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %62
%64 = load i32, i32* %63
store i32 %64, i32* %7
br label %65
65: ; preds = %60, %53
br label %66
66: ; preds = %65
%67 = load i32, i32* %3
%68 = add nsw i32 %67, 1
store i32 %68, i32* %3
br label %49
69: ; preds = %49
store i32 0, i32* %3
br label %70
70: ; preds = %81, %69
%71 = load i32, i32* %3
%72 = load i32, i32* %4
%73 = icmp slt i32 %71, %72
br i1 %73, label %74, label %84
74: ; preds = %70
%75 = load i32, i32* %5
%76 = load i32, i32* %3
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %77
%79 = load i32, i32* %78
%80 = add nsw i32 %75, %79
store i32 %80, i32* %5
br label %81
81: ; preds = %74
%82 = load i32, i32* %3
%83 = add nsw i32 %82, 1
store i32 %83, i32* %3
br label %70
84: ; preds = %70
%85 = load i32, i32* %5
%86 = load i32, i32* %4
%87 = sdiv i32 %85, %86
%88 = sitofp i32 %87 to double
store double %88, double* %8
%89 = load i32, i32* %6
%90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0), i32 %89)
%91 = load i32, i32* %7
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), i32 %91)
%93 = load i32, i32* %5
%94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i64 0, i64 0), i32 %93)
%95 = load double, double* %8
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.5, i64 0, i64 0), double %95)
ret i32 0
}

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