Language: C++

#include <queue>//priority_queue
#include <stack>
#include <algorithm>
#include <cstdlib>
#include <array>
#include <map>
#include <list>
#include <set>
#include <utility>
#include <vector>
#include <cmath>
#include <bitset>
#include <iostream>

#pragma warning(disable: 4996)

/*-------マクロ定義---------*/

#define REP(i , n) for(L i = 0 ; i < n ; i++)
#define TIMES(n) REP(i , n)


/*---------Typedef------------*/

//long
typedef long L;
typedef std::pair<L, L>				IntPair;
typedef std::vector<L>				IntVector;
typedef std::priority_queue<L>		IntPriority;
typedef std::queue<L>				IntQueue;
typedef std::stack<L>				IntStack;

//unsigned long
typedef unsigned long ul;
typedef std::pair<ul, ul>			UIntPair;
typedef std::vector<ul>				UIntVector;
typedef std::priority_queue<ul>		UIntPriority;
typedef std::queue<ul>				UIntQueue;
typedef std::stack<ul>				UIntStack;

//double
typedef double D;
typedef std::pair<D, D>				DoublePair;
typedef std::vector<D>				DoubleVector;
typedef std::priority_queue<D>		DoublePriority;
typedef std::queue<D>				DoubleQueue;
typedef std::stack<D>				DoubleStack;

//char
typedef char Ch;
typedef std::pair<Ch, Ch>			CharPair;
typedef std::vector<Ch>				CharVector;
typedef std::priority_queue<Ch>		CharPriority;
typedef std::queue<Ch>				CharQueue;
typedef std::stack<Ch>				CharStack;

//
/*  VectorArray	Dp(1000,IntVector(1000)); */
typedef std::vector<std::vector<L>>		VectorArray;
typedef std::vector<std::vector<ul>>	UVectorArray;
typedef std::vector<std::vector<D>>		DVectorArray;


/*--------ScanOverLoad----------*/

//type long//

void Scan(L& output)
{
	scanf("%ld", &output);
}

void Scan(IntVector& vector)
{
	L scan = 0;
	scanf("%ld", &scan);
	vector.push_back(scan);
}

void Scan(IntPriority& pri_que)
{
	L scan = 0;
	scanf("%ld", &scan);
	pri_que.push(scan);
}

void Scan(IntQueue& que)
{
	L scan = 0;
	scanf("%ld", &scan);
	que.push(scan);
}

void Scan(IntStack& stack)
{
	L scan = 0;
	scanf("%ld",&scan);
	stack.push(scan);
}

//type unsigned long//

void Scan(ul& output)
{
	scanf("%lu", &output);
}

void Scan(UIntVector& vector)
{
	ul scan = 0;
	scanf("%lu", &scan);
	vector.push_back(scan);
}

void Scan(UIntPriority& pri_que)
{
	ul scan = 0;
	scanf("%lu", &scan);
	pri_que.push(scan);
}

void Scan(UIntQueue& que)
{
	ul scan = 0;
	scanf("%lu", &scan);
	que.push(scan);
}

void Scan(UIntStack& stack)
{
	ul scan = 0;
	scanf("%lu", &scan);
	stack.push(scan);
}

//type double//

void Scan(D& output)
{
	scanf("%lf", &output);
}

void Scan(DoubleVector& vector)
{
	D scan = 0;
	scanf("lf", &scan);
	vector.push_back(scan);
}

void Scan(DoublePriority& pri_que)
{
	D scan = 0;
	scanf("%lf", &scan);
	pri_que.push(scan);
}

void Scan(DoubleQueue& que)
{
	D scan = 0;
	scanf("%lf", &scan);
	que.push(scan);
}

void Scan(DoubleStack& stack)
{
	D scan = 0;
	scanf("%lf", &scan);
	stack.push(scan);
}

//type char//

void Scan(Ch& output)
{
	scanf("%c", &output);
}

void Scan(CharVector& vector)
{
	Ch scan = 0;
	scanf("%c", &scan);
	vector.push_back(scan);
}

void Scan(CharPriority& pri_que)
{
	Ch scan = 0;
	scanf("%c", &scan);
	pri_que.push(scan);
}

void Scan(CharQueue& que)
{
	Ch scan = 0;
	scanf("%c", &scan);
	que.push(scan);
}

void Scan(CharStack& stack)
{
	Ch scan = 0;
	scanf("%c", &scan);
	stack.push(scan);
}

/*----------Print----------*/

struct OPrint{
	void operator()(L& value)		{ printf("%ld", value); }
	void operator()(ul& value)		{ printf("%lu", value); }
	void operator()(D& value)		{ printf("%lf", value); }
	void operator()(Ch& value)		{ printf("%c", value); }
};

template<class T>
void Print(T& value){ std::for_each(value.begin(), value.end(), OPrint()); }

void Print(L value){ printf("%ld", value); }

void Print(ul value){ printf("%lu", value); }

void Print(D value){ printf("%lf", value); }

void Print(Ch value){ printf("%c", value); }

/*----------Init---------*/

template<class T>
struct OInit{
	T x;

	OInit(T _x) :x(_x){}

	void operator()(L& value)	{ value = x; }
	void operator()(ul& value)	{ value = x; }
	void operator()(D& value)	{ value = x; }
	void operator()(Ch& value)	{ value = x; }
};

template<class T1 , class T2>
void Init(T1& value,T2 x){ std::for_each(value.begin(), value.end(), OInit<T2>(x)); }

void Init(L& value, L x){ value = x; }

void Init(ul& value, ul x){ value = x; }

void Init(D& value, D x){ value = x; }

void Init(Ch& value, Ch x){ value = x; }


template<class T>
struct Edge;

/*****************************************
*				Node
******************************************/

template<class T,class V,class E>
struct Node{
	T sig;		//識別
	V cost;		//ノードが持つコスト
	std::vector<Edge<E>&> edge;	//繋がってるエッジ（辺）

	//汎用フラグ
	bool flag;

	Node(T s) :sig(s),cost(0),flag(false){}
	Node(T s, V c) :sig(s), cost(c),flag(false){}

	void operator=(Node& l);
};

template<class E>
struct Edge{
	static long int sig;			//識別

	E cost;							//辺が持つコスト
	Node& first;					//前のノード
	Node& second;					//後のノード

	//汎用フラグ
	bool flag;

	Edge(Node& f, Node& af, double c = 0) :first(f), after(af), cost(c),flag(false){ ++sig; }
};

template<class E>
long int Edge<E>::sig = 0;

template<class T,class V, class E>
class Graph{
	std::vector<Node<T,V,E>> m_Node;

public:

};










template<class T, class V, class E>
void Node<T, V, E>::operator=(Node& l){ r.sig = l.sig; r.cost = l.cost; r.edge = l.edge; }





int main()
{
	for (;;){
		IntVector Point;
		L n; Scan(n);
		if (!n) return 0;

		TIMES(n)
			Scan(Point);
		std::sort(Point.begin() , Point.end());
		
		L souwa = 0;

		std::for_each(Point.begin() + 1, Point.end() - 1, [&souwa](L x){
			souwa += x;
		});
			Print(souwa / (Point.size()-2));
			puts("");
			puts("");
	}

	return 0;
}

Compiler output:
a.cc:279:9: error: missing template argument list after 'Node'; for deduction, template placeholder must be followed by a simple declarator-id
  279 |         Node& first;                                    //前のノード
      |         ^~~~
      |             <>
a.cc:260:8: note: 'template<class T, class V, class E> struct Node' declared here
  260 | struct Node{
      |        ^~~~
a.cc:280:9: error: missing template argument list after 'Node'; for deduction, template placeholder must be followed by a simple declarator-id
  280 |         Node& second;                                   //後のノード
      |         ^~~~
      |             <>
a.cc:260:8: note: 'template<class T, class V, class E> struct Node' declared here
  260 | struct Node{
      |        ^~~~
a.cc:285:14: error: missing template argument list after 'Node'; template placeholder not permitted in parameter
  285 |         Edge(Node& f, Node& af, double c = 0) :first(f), after(af), cost(c),flag(false){ ++sig; }
      |              ^~~~
      |                  <>
a.cc:260:8: note: 'template<class T, class V, class E> struct Node' declared here
  260 | struct Node{
      |        ^~~~
a.cc:285:23: error: missing template argument list after 'Node'; template placeholder not permitted in parameter
  285 |         Edge(Node& f, Node& af, double c = 0) :first(f), after(af), cost(c),flag(false){ ++sig; }
      |                       ^~~~
      |                           <>
a.cc:260:8: note: 'template<class T, class V, class E> struct Node' declared here
  260 | struct Node{
      |        ^~~~
a.cc: In constructor 'Edge<T>::Edge(...)':
a.cc:285:48: error: class 'Edge<T>' does not have any field named 'first'
  285 |         Edge(Node& f, Node& af, double c = 0) :first(f), after(af), cost(c),flag(false){ ++sig; }
      |                                                ^~~~~
a.cc:285:54: error: 'f' was not declared in this scope
  285 |         Edge(Node& f, Node& af, double c = 0) :first(f), after(af), cost(c),flag(false){ ++sig; }
      |                                                      ^
a.cc:285:58: error: class 'Edge<T>' does not have any field named 'after'
  285 |         Edge(Node& f, Node& af, double c = 0) :first(f), after(af), cost(c),flag(false){ ++sig; }
      |                                                          ^~~~~
a.cc:285:64: error: 'af' was not declared in this scope
  285 |         Edge(Node& f, Node& af, double c = 0) :first(f), after(af), cost(c),flag(false){ ++sig; }
      |                                                                ^~
a.cc: In member function 'void Node<T, V, E>::operator=(Node<T, V, E>&)':
a.cc:309:41: error: 'r' was not declared in this scope
  309 | void Node<T, V, E>::operator=(Node& l){ r.sig = l.sig; r.cost = l.cost; r.edge = l.edge; }
      |                                         ^