#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 */
scalar_t__ EOF;
int /*<<< orphan*/ printf(char *, double);
scalar_t__ scanf(char *, int *);
int main() {
  int n, i, S, max, min, ar[9999];
  while (scanf("%d", &n) != EOF) {
    S = 0;
    max = 0;
    min = 100;
    for (i = 0; i < n; i++) {
      scanf("%d", &ar[i]);
      max = (max > ar[i]) ? max : ar[i];
      min = (min < ar[i]) ? min : ar[i];
    }
    for (i = 0; i < n; i++)
      S += ar[i];
    printf("%.2lf\n", (double)((S - max - min)) / (n - 2));
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x9c70,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xec7(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1040 <scanf@plt>
mov    0x2e9f(%rip),%rcx
cmp    (%rcx),%rax
je     127c <main+0x15c>
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x64,-0x18(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    121e <main+0xfe>
movslq -0xc(%rbp),%rax
lea    -0x9c60(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe6d(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x14(%rbp),%eax
movslq -0xc(%rbp),%rcx
cmp    -0x9c60(%rbp,%rcx,4),%eax
jle    11ba <main+0x9a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x9c64(%rbp)
jmp    11cb <main+0xab>
movslq -0xc(%rbp),%rax
mov    -0x9c60(%rbp,%rax,4),%eax
mov    %eax,-0x9c64(%rbp)
mov    -0x9c64(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
movslq -0xc(%rbp),%rcx
cmp    -0x9c60(%rbp,%rcx,4),%eax
jge    11f6 <main+0xd6>
mov    -0x18(%rbp),%eax
mov    %eax,-0x9c68(%rbp)
jmp    1207 <main+0xe7>
movslq -0xc(%rbp),%rax
mov    -0x9c60(%rbp,%rax,4),%eax
mov    %eax,-0x9c68(%rbp)
mov    -0x9c68(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    116e <main+0x4e>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1250 <main+0x130>
movslq -0xc(%rbp),%rax
mov    -0x9c60(%rbp,%rax,4),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1225 <main+0x105>
mov    -0x10(%rbp),%eax
sub    -0x14(%rbp),%eax
sub    -0x18(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%eax
sub    $0x2,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
lea    0xd91(%rip),%rdi
call   1030 <printf@plt>
jmp    1132 <main+0x12>
xor    %eax,%eax
add    $0x9c70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x9c58,%rsp
lea    0xec8(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1040 <scanf@plt>
mov    0x2e9f(%rip),%r13
cmp    0x0(%r13),%rax
jne    1163 <main+0x43>
xor    %eax,%eax
add    $0x9c58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xe96(%rip),%r12
jmp    11b1 <main+0x91>
nopl   0x0(%rax)
mov    $0x64,%eax
xor    %ebp,%ebp
xor    %edi,%edi
add    %ebp,%eax
sub    %eax,%edi
xorps  %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
add    $0xfffffffe,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
divsd  %xmm1,%xmm0
lea    0xe6a(%rip),%rdi
call   1030 <printf@plt>
mov    %r12,%rdi
lea    0xc(%rsp),%rsi
call   1040 <scanf@plt>
cmp    0x0(%r13),%rax
je     114f <main+0x2f>
mov    0xc(%rsp),%ecx
test   %ecx,%ecx
jle    1170 <main+0x50>
xor    %r14d,%r14d
mov    $0x64,%eax
lea    0x10(%rsp),%rbx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    %eax,%r15d
mov    %r12,%rdi
mov    %rbx,%rsi
call   1040 <scanf@plt>
mov    (%rbx),%eax
cmp    %eax,%ebp
cmovle %eax,%ebp
cmp    %eax,%r15d
cmovl  %r15d,%eax
add    $0x1,%r14
movslq 0xc(%rsp),%rcx
add    $0x4,%rbx
cmp    %rcx,%r14
jl     11d0 <main+0xb0>
test   %ecx,%ecx
jle    1177 <main+0x57>
mov    %ecx,%edx
cmp    $0x8,%ecx
jae    1216 <main+0xf6>
xor    %esi,%esi
xor    %edi,%edi
jmp    1300 <main+0x1e0>
mov    %edx,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rbx
mov    %rbx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rbx
jae    1243 <main+0x123>
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
jmp    129d <main+0x17d>
and    $0xfffffffffffffffc,%rdi
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
paddd  0x10(%rsp,%rbx,4),%xmm0
paddd  0x20(%rsp,%rbx,4),%xmm1
paddd  0x30(%rsp,%rbx,4),%xmm0
paddd  0x40(%rsp,%rbx,4),%xmm1
paddd  0x50(%rsp,%rbx,4),%xmm0
paddd  0x60(%rsp,%rbx,4),%xmm1
paddd  0x70(%rsp,%rbx,4),%xmm0
paddd  0x80(%rsp,%rbx,4),%xmm1
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1260 <main+0x140>
test   %r8,%r8
je     12d4 <main+0x1b4>
lea    0x20(%rsp),%rdi
lea    (%rdi,%rbx,4),%rdi
shl    $0x5,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
paddd  -0x10(%rdi,%rbx,1),%xmm0
paddd  (%rdi,%rbx,1),%xmm1
add    $0x20,%rbx
cmp    %rbx,%r8
jne    12c0 <main+0x1a0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edi
cmp    %rdx,%rsi
je     1179 <main+0x59>
nopw   0x0(%rax,%rax,1)
add    0x10(%rsp,%rsi,4),%edi
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1300 <main+0x1e0>
jmp    1179 <main+0x59>

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
@EOF = global i64 0
@.str.1 = [7 x i8] c"%.2lf\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 [9999 x i32]
store i32 0, i32* %1
br label %8
8: ; preds = %70, %0
%9 = call i64 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %2)
%10 = load i64, i64* @EOF
%11 = icmp ne i64 %9, %10
br i1 %11, label %12, label %82
12: ; preds = %8
store i32 0, i32* %4
store i32 0, i32* %5
store i32 100, i32* %6
store i32 0, i32* %3
br label %13
13: ; preds = %52, %12
%14 = load i32, i32* %3
%15 = load i32, i32* %2
%16 = icmp slt i32 %14, %15
br i1 %16, label %17, label %55
17: ; preds = %13
%18 = load i32, i32* %3
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds [9999 x i32], [9999 x i32]* %7, i64 0, i64 %19
%21 = call i64 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %20)
%22 = load i32, i32* %5
%23 = load i32, i32* %3
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [9999 x i32], [9999 x i32]* %7, i64 0, i64 %24
%26 = load i32, i32* %25
%27 = icmp sgt i32 %22, %26
br i1 %27, label %28, label %30
28: ; preds = %17
%29 = load i32, i32* %5
br label %35
30: ; preds = %17
%31 = load i32, i32* %3
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [9999 x i32], [9999 x i32]* %7, i64 0, i64 %32
%34 = load i32, i32* %33
br label %35
35: ; preds = %30, %28
%36 = phi i32 [ %29, %28 ], [ %34, %30 ]
store i32 %36, i32* %5
%37 = load i32, i32* %6
%38 = load i32, i32* %3
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [9999 x i32], [9999 x i32]* %7, i64 0, i64 %39
%41 = load i32, i32* %40
%42 = icmp slt i32 %37, %41
br i1 %42, label %43, label %45
43: ; preds = %35
%44 = load i32, i32* %6
br label %50
45: ; preds = %35
%46 = load i32, i32* %3
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [9999 x i32], [9999 x i32]* %7, i64 0, i64 %47
%49 = load i32, i32* %48
br label %50
50: ; preds = %45, %43
%51 = phi i32 [ %44, %43 ], [ %49, %45 ]
store i32 %51, i32* %6
br label %52
52: ; preds = %50
%53 = load i32, i32* %3
%54 = add nsw i32 %53, 1
store i32 %54, i32* %3
br label %13
55: ; preds = %13
store i32 0, i32* %3
br label %56
56: ; preds = %67, %55
%57 = load i32, i32* %3
%58 = load i32, i32* %2
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %70
60: ; preds = %56
%61 = load i32, i32* %3
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [9999 x i32], [9999 x i32]* %7, i64 0, i64 %62
%64 = load i32, i32* %63
%65 = load i32, i32* %4
%66 = add nsw i32 %65, %64
store i32 %66, i32* %4
br label %67
67: ; preds = %60
%68 = load i32, i32* %3
%69 = add nsw i32 %68, 1
store i32 %69, i32* %3
br label %56
70: ; preds = %56
%71 = load i32, i32* %4
%72 = load i32, i32* %5
%73 = sub nsw i32 %71, %72
%74 = load i32, i32* %6
%75 = sub nsw i32 %73, %74
%76 = sitofp i32 %75 to double
%77 = load i32, i32* %2
%78 = sub nsw i32 %77, 2
%79 = sitofp i32 %78 to double
%80 = fdiv double %76, %79
%81 = call i32 @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %80)
br label %8
82: ; preds = %8
ret i32 0
}

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@EOF = global i64 0
@.str.1 = [7 x i8] c"%.2lf\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [9999 x i32]
%3 = bitcast i32* %1 to i8*
%4 = bitcast [9999 x i32]* %2 to i8*
%5 = call i64 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%6 = load i64, i64* @EOF
%7 = icmp eq i64 %5, %6
br i1 %7, label %138, label %8
8: ; preds = %0, %123
%9 = load i32, i32* %1
%10 = icmp sgt i32 %9, 0
br i1 %10, label %100, label %123
11: ; preds = %100
%12 = icmp sgt i32 %112, 0
br i1 %12, label %13, label %123
13: ; preds = %11
%14 = zext i32 %112 to i64
%15 = icmp ult i32 %112, 8
br i1 %15, label %97, label %16
16: ; preds = %13
%17 = and i64 %14, 4294967288
%18 = add nsw i64 %17, -8
%19 = lshr exact i64 %18, 3
%20 = add nuw nsw i64 %19, 1
%21 = and i64 %20, 3
%22 = icmp ult i64 %18, 24
br i1 %22, label %68, label %23
23: ; preds = %16
%24 = and i64 %20, 4611686018427387900
br label %25
25: ; preds = %25, %23
%26 = phi i64 [ 0, %23 ], [ %65, %25 ]
%27 = phi <4 x i32> [ zeroinitializer, %23 ], [ %63, %25 ]
%28 = phi <4 x i32> [ zeroinitializer, %23 ], [ %64, %25 ]
%29 = phi i64 [ 0, %23 ], [ %66, %25 ]
%30 = getelementptr inbounds [9999 x i32], [9999 x i32]* %2, i64 0, i64 %26
%31 = bitcast i32* %30 to <4 x i32>*
%32 = load <4 x i32>, <4 x i32>* %31
%33 = getelementptr inbounds i32, i32* %30, i64 4
%34 = bitcast i32* %33 to <4 x i32>*
%35 = load <4 x i32>, <4 x i32>* %34
%36 = add <4 x i32> %32, %27
%37 = add <4 x i32> %35, %28
%38 = or i64 %26, 8
%39 = getelementptr inbounds [9999 x i32], [9999 x i32]* %2, i64 0, i64 %38
%40 = bitcast i32* %39 to <4 x i32>*
%41 = load <4 x i32>, <4 x i32>* %40
%42 = getelementptr inbounds i32, i32* %39, i64 4
%43 = bitcast i32* %42 to <4 x i32>*
%44 = load <4 x i32>, <4 x i32>* %43
%45 = add <4 x i32> %41, %36
%46 = add <4 x i32> %44, %37
%47 = or i64 %26, 16
%48 = getelementptr inbounds [9999 x i32], [9999 x i32]* %2, i64 0, i64 %47
%49 = bitcast i32* %48 to <4 x i32>*
%50 = load <4 x i32>, <4 x i32>* %49
%51 = getelementptr inbounds i32, i32* %48, i64 4
%52 = bitcast i32* %51 to <4 x i32>*
%53 = load <4 x i32>, <4 x i32>* %52
%54 = add <4 x i32> %50, %45
%55 = add <4 x i32> %53, %46
%56 = or i64 %26, 24
%57 = getelementptr inbounds [9999 x i32], [9999 x i32]* %2, i64 0, i64 %56
%58 = bitcast i32* %57 to <4 x i32>*
%59 = load <4 x i32>, <4 x i32>* %58
%60 = getelementptr inbounds i32, i32* %57, i64 4
%61 = bitcast i32* %60 to <4 x i32>*
%62 = load <4 x i32>, <4 x i32>* %61
%63 = add <4 x i32> %59, %54
%64 = add <4 x i32> %62, %55
%65 = add nuw i64 %26, 32
%66 = add i64 %29, 4
%67 = icmp eq i64 %66, %24
br i1 %67, label %68, label %25
68: ; preds = %25, %16
%69 = phi <4 x i32> [ undef, %16 ], [ %63, %25 ]
%70 = phi <4 x i32> [ undef, %16 ], [ %64, %25 ]
%71 = phi i64 [ 0, %16 ], [ %65, %25 ]
%72 = phi <4 x i32> [ zeroinitializer, %16 ], [ %63, %25 ]
%73 = phi <4 x i32> [ zeroinitializer, %16 ], [ %64, %25 ]
%74 = icmp eq i64 %21, 0
br i1 %74, label %91, label %75
75: ; preds = %68, %75
%76 = phi i64 [ %88, %75 ], [ %71, %68 ]
%77 = phi <4 x i32> [ %86, %75 ], [ %72, %68 ]
%78 = phi <4 x i32> [ %87, %75 ], [ %73, %68 ]
%79 = phi i64 [ %89, %75 ], [ 0, %68 ]
%80 = getelementptr inbounds [9999 x i32], [9999 x i32]* %2, i64 0, i64 %76
%81 = bitcast i32* %80 to <4 x i32>*
%82 = load <4 x i32>, <4 x i32>* %81
%83 = getelementptr inbounds i32, i32* %80, i64 4
%84 = bitcast i32* %83 to <4 x i32>*
%85 = load <4 x i32>, <4 x i32>* %84
%86 = add <4 x i32> %82, %77
%87 = add <4 x i32> %85, %78
%88 = add nuw i64 %76, 8
%89 = add i64 %79, 1
%90 = icmp eq i64 %89, %21
br i1 %90, label %91, label %75
91: ; preds = %75, %68
%92 = phi <4 x i32> [ %69, %68 ], [ %86, %75 ]
%93 = phi <4 x i32> [ %70, %68 ], [ %87, %75 ]
%94 = add <4 x i32> %93, %92
%95 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %94)
%96 = icmp eq i64 %17, %14
br i1 %96, label %123, label %97
97: ; preds = %13, %91
%98 = phi i64 [ 0, %13 ], [ %17, %91 ]
%99 = phi i32 [ 0, %13 ], [ %95, %91 ]
br label %115
100: ; preds = %8, %100
%101 = phi i64 [ %111, %100 ], [ 0, %8 ]
%102 = phi i32 [ %110, %100 ], [ 100, %8 ]
%103 = phi i32 [ %108, %100 ], [ 0, %8 ]
%104 = getelementptr inbounds [9999 x i32], [9999 x i32]* %2, i64 0, i64 %101
%105 = call i64 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %104)
%106 = load i32, i32* %104
%107 = icmp sgt i32 %103, %106
%108 = select i1 %107, i32 %103, i32 %106
%109 = icmp slt i32 %102, %106
%110 = select i1 %109, i32 %102, i32 %106
%111 = add nuw nsw i64 %101, 1
%112 = load i32, i32* %1
%113 = sext i32 %112 to i64
%114 = icmp slt i64 %111, %113
br i1 %114, label %100, label %11
115: ; preds = %97, %115
%116 = phi i64 [ %121, %115 ], [ %98, %97 ]
%117 = phi i32 [ %120, %115 ], [ %99, %97 ]
%118 = getelementptr inbounds [9999 x i32], [9999 x i32]* %2, i64 0, i64 %116
%119 = load i32, i32* %118
%120 = add nsw i32 %119, %117
%121 = add nuw nsw i64 %116, 1
%122 = icmp eq i64 %121, %14
br i1 %122, label %123, label %115
123: ; preds = %115, %91, %8, %11
%124 = phi i32 [ %112, %11 ], [ %9, %8 ], [ %112, %91 ], [ %112, %115 ]
%125 = phi i32 [ %110, %11 ], [ 100, %8 ], [ %110, %91 ], [ %110, %115 ]
%126 = phi i32 [ %108, %11 ], [ 0, %8 ], [ %108, %91 ], [ %108, %115 ]
%127 = phi i32 [ 0, %11 ], [ 0, %8 ], [ %95, %91 ], [ %120, %115 ]
%128 = add i32 %125, %126
%129 = sub i32 %127, %128
%130 = sitofp i32 %129 to double
%131 = add nsw i32 %124, -2
%132 = sitofp i32 %131 to double
%133 = fdiv double %130, %132
%134 = call i32 @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %133)
%135 = call i64 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%136 = load i64, i64* @EOF
%137 = icmp eq i64 %135, %136
br i1 %137, label %138, label %8
138: ; preds = %123, %0
ret i32 0
}