import java.io.*;
import java.util.*;

public class P219D
{
    static int[] s, t, eval;
    static ArrayList<Integer>[] list, rlist;

    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        s = new int[n-1];
        t = new int[n-1];
        eval = new int[n];
        list = new ArrayList[n];
        rlist = new ArrayList[n];
        for (int i = 0; i < n; i++)
        {
            list[i] = new ArrayList<Integer>(2);
            rlist[i] = new ArrayList<Integer>(2);
        }
        for (int i = 0; i < n-1; i++)
        {
            s[i] = sc.nextInt() - 1;
            t[i] = sc.nextInt() - 1;
            list[s[i]].add(i);
            rlist[t[i]].add(i);
        }
        int[] d = new int[n-1];
        int[] d2 = new int[n-1];
        Arrays.fill(d, -1);
        Arrays.fill(d2, -1);
        Arrays.fill(eval, -1);

        for (int i = 0; i < n-1; i++)
        {
            d[i] = markfwd(d, d2, i);
            d2[i] = markback(d, d2, i);
        }
        int[] sum = new int[n];
        int best = n + 1;
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < list[i].size(); j++)
            {
                int x = list[i].get(j);
                sum[i] += d[x];
            }
            for (int j = 0; j < rlist[i].size(); j++)
            {
                int x = rlist[i].get(j);
                sum[i] += d2[x] + 1;
            }
            if (sum[i] < best)
            {
                best = sum[i];
                sb.delete(0, sb.length());
                sb.append((i+1));
            }
            else if (sum[i] == best)
            {
                sb.append(" ");
                sb.append((i+1));
            }
        }
        System.out.println(best);
        System.out.println(sb.toString());
    }

    private static int markfwd(int[] d, int[] d2, int edge)
    {
        if (d[edge] != -1)
        {
            return d[edge];
        }
        int ep = t[edge];
        int sum = 0;
        if (eval[ep] != -1)
        {
            if (t[eval[ep]] == ep)
            {
                sum = d[eval[ep]] + markback(d, d2, eval[ep]) - markback(d, d2, edge);
            }
            else
            {
                sum = d2[eval[ep]] + markfwd(d, d2, eval[ep]) - markback(d, d2, edge)
                    - 1;
            }
            d[edge] = sum;
            return sum;
        }
        for (int i = 0; i < list[ep].size(); i++)
        {
            int x = list[ep].get(i);
            sum += markfwd(d, d2, x);
        }
        for (int i = 0; i < rlist[ep].size(); i++)
        {
            int x = rlist[ep].get(i);
            if (x == edge) continue;
            sum += markback(d, d2, x) + 1;
        }
        eval[ep] = edge;
        d[edge] = sum;
        return sum;
    }

    private static int markback(int[] d, int[] d2, int edge)
    {
        if (d2[edge] != -1)
        {
            return d2[edge];
        }
        int ep = s[edge];
        int sum = 0;
        if (eval[ep] != -1)
        {
            if (t[eval[ep]] == ep)
            {
                sum = d[eval[ep]] + markback(d, d2, eval[ep]) - markfwd(d, d2, edge)
                    + 1;
            }
            else
            {
                sum = d2[eval[ep]] + markfwd(d, d2, eval[ep]) - markfwd(d, d2, edge);
            }
            d2[edge] = sum;
            return sum;
        }
        for (int i = 0; i < list[ep].size(); i++)
        {
            int x = list[ep].get(i);
            if (x == edge) continue;
            sum += markfwd(d, d2, x);
        }
        for (int i = 0; i < rlist[ep].size(); i++)
        {
            int x = rlist[ep].get(i);
            sum += markback(d, d2, x) + 1;
        }
        eval[ep] = edge;
        d2[edge] = sum;
        return sum;
    }
}


import java.util.*;
import static java.lang.Math.*;
public class ProblemD {
	int[][] neighbours;
	int[][] neighbour_dirs;
	int N;

	int[] subsols;
	int[] sols;

    void run() {
        Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		int[] u = new int[N];
		int[] v = new int[N];
		int[] nc = new int[N];

		neighbours = new int[N][];
		neighbour_dirs = new int[N][];
		subsols = new int[N];
		sols = new int[N];

		for (int i = 0; i < N-1; ++i) {
			u[i] = sc.nextInt()-1;
			v[i] = sc.nextInt()-1;
			++nc[u[i]];
			++nc[v[i]];
		}

		for (int i = 0; i < N; ++i) {
			neighbours[i] = new int[nc[i]];
			neighbour_dirs[i] = new int[nc[i]];
		}

		int[] ni = new int[N];

		for (int i = 0; i < N-1; ++i) {
			int a = u[i];
			int b = v[i];
			neighbours[a][ni[a]] = b;
			neighbour_dirs[a][ni[a]] = 1;
			++ni[a];

			neighbours[b][ni[b]] = a;
			neighbour_dirs[b][ni[b]] = -1;
			++ni[b];
		}

		solve();
    }

	void solve() {
		int root = 0;
		countSubSols(root, -1);
		d(subsols);
		countSols(root, -1, subsols[root]);
		d(sols);
		int best = Integer.MAX_VALUE;
		for (int i = 0; i < N; ++i) {
			best = min(best, sols[i]);
		}
		p("%s\n", best);
		boolean printed = false;
		for (int i = 0; i < N; ++i) {
			if (sols[i] == best) {
				if (printed) {
					p(" ");
				}
				else {
					printed = true;
				}
				p("%d", i+1);
			}
		}
		p("\n");
	}

	void countSubSols(int node, int parent) {
		d("countingSubSols", node, parent);
		int res = 0;
		int k = neighbours[node].length;
		for (int i = 0; i < k; ++i) {
			int n = neighbours[node][i];
			if (n == parent) {
				continue;
			}
			countSubSols(n, node);
			res += subsols[n];
			if (neighbour_dirs[node][i] < 0) {
				++res;
			}
		}
		subsols[node] = res;
	}

	void countSols(int node, int parent, int inherited) {
		d("countSols", node, parent, inherited);
		sols[node] = inherited;
		int k = neighbours[node].length;
		for (int i = 0; i < k; ++i) {
			int n = neighbours[node][i];
			if (n == parent) {
				continue;
			}
			int dir = neighbour_dirs[node][i];
			countSols(n, node, inherited + dir);
		}
	}

    boolean debug = false;
    void p(String f, Object...params) {
        System.out.printf(f, params);
    }
    void d(Object...params) {
        if (debug) {
            p("DEBUG: %s\n", Arrays.deepToString(params));
        }
    }
    void die() {
        throw new RuntimeException();
    }
    public ProblemD(String[] args) {
        if (args.length > 0 && args[0].equals("debug")) {
            debug = true;
        }
    }
    public static void main(String[] args) {
        new ProblemD(args).run();
    }
}


import java.util.*;
import static java.lang.Math.*;
public class ProblemD {
	int[][] forwards;
	int[][] backwards;
	int N;

	int[] subsols;
	int[] sols;

    void run() {
        Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		int[] u = new int[N];
		int[] v = new int[N];
		int[] fc = new int[N];
		int[] bc = new int[N];

		forwards = new int[N][];
		backwards = new int[N][];
		subsols = new int[N];
		sols = new int[N];

		for (int i = 0; i < N-1; ++i) {
			u[i] = sc.nextInt()-1;
			v[i] = sc.nextInt()-1;
			++fc[u[i]];
			++bc[v[i]];
		}

		for (int i = 0; i < N; ++i) {
			forwards[i] = new int[fc[i]];
			backwards[i] = new int[bc[i]];
		}

		int[] fi = new int[N];
		int[] bi = new int[N];

		for (int i = 0; i < N-1; ++i) {
			d("edge", u[i], v[i]);
			forwards[u[i]][fi[u[i]]] = v[i];
			++fi[u[i]];
			backwards[v[i]][bi[v[i]]] = u[i];
			++bi[v[i]];
		}

		d("fi", fi);
		d("bi", bi);

		solve();
    }

	void solve() {
		d("forwards", forwards);
		d("backwards", backwards);
		int root = 0;
		countSubSols(root, -1);
		d(subsols);
		countSols(root, -1, subsols[root]);
		d(sols);
		int best = Integer.MAX_VALUE;
		for (int i = 0; i < N; ++i) {
			best = min(best, sols[i]);
		}
		p("%s\n", best);
		boolean printed = false;
		for (int i = 0; i < N; ++i) {
			if (sols[i] == best) {
				if (printed) {
					p(" ");
				}
				else {
					printed = true;
				}
				p("%d", i+1);
			}
		}
		p("\n");
	}

	void countSubSols(int node, int parent) {
		d("countingSubSols", node, parent);
		int res = 0;
		for (int f : forwards[node]) {
			if (f == parent) {
				continue;
			}
			countSubSols(f, node);
			res += subsols[f];
		}
		for (int b : backwards[node]) {
			if (b == parent) {
				continue;
			}
			countSubSols(b, node);
			res += subsols[b] + 1;
		}
		subsols[node] = res;
	}

	void countSols(int node, int parent, int inherited) {
		sols[node] = inherited;
		for (int f : forwards[node]) {
			if (f == parent) {
				continue;
			}
			countSols(f, node, inherited + 1);
		}
		for (int b : backwards[node]) {
			if (b == parent) {
				continue;
			}
			countSols(b, node, inherited - 1);
		}

	}

    boolean debug = false;
    void p(String f, Object...params) {
        System.out.printf(f, params);
    }
    void d(Object...params) {
        if (debug) {
            p("DEBUG: %s\n", Arrays.deepToString(params));
        }
    }
    void die() {
        throw new RuntimeException();
    }
    public ProblemD(String[] args) {
        if (args.length > 0 && args[0].equals("debug")) {
            debug = true;
        }
    }
    public static void main(String[] args) {
        new ProblemD(args).run();
    }
}


import static java.lang.Math.*;

import java.io.*;
import java.util.*;

public class Template {
	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;

	String next() {
		while (st==null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(in.readLine());
			} catch (Exception e) {}
		}
		return st.nextToken();
	}

	int nextInt() {
		return Integer.parseInt(next());
	}

	long nextLong() {
		return Long.parseLong(next());
	}

	double nextDouble() {
		return Double.parseDouble(next());
	}

	int n;

	class Edge {
		int a, b;
		boolean f;
		public Edge(int a, int b, boolean f) {
			this.a=a;
			this.b=b;
			this.f=f;
		}
	}

	ArrayList<Edge>[] g;
	boolean[] u;
	int[] up, down;

	void dfs(int v) {
		u[v] = true;
		up[v] = 0;
		down[v] = 0;
		for (Edge e : g[v]) {
			if (u[e.b]) continue;
			if (e.f) down[v]++; else up[v]++;
			dfs(e.b);
			down[v] += down[e.b];
			up[v] += up[e.b];
		}
	}

	ArrayList<Integer> ans;
	int res = Integer.MAX_VALUE;

	void dfs2(int v, int f, int r) {
		u[v]= true;
		if (res>r) {
			res = r;
			ans.clear();
		}
		if (res==r) ans.add(v + 1);

		for (Edge e : g[v]) {
			if (u[e.b]) continue;
			if (e.f) {
				dfs2(e.b, f-1 , r+1);
			} else {
				dfs2(e.b, f+1 , r-1);
			}
		}
	}

	public void run() throws Exception {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		Long start = System.currentTimeMillis();

		n = nextInt();
		g = new ArrayList[n];
		for (int i=0; i<n; i++) g[i] = new ArrayList<Edge>();

		for (int i=0; i<n-1; i++) {
			int a = nextInt() - 1;
			int b = nextInt() - 1;
			g[a].add(new Edge(a, b, true));
			g[b].add(new Edge(b, a, false));
		}

		u = new boolean[n];
		up = new int[n];
		down = new int[n];
		dfs(0);

		u = new boolean[n];
		ans = new ArrayList<Integer>();
		dfs2(0, down[0], up[0]);

		out.println(res);
		Collections.sort(ans);
		for (int x : ans) out.print(x + " ");
		Long end = System.currentTimeMillis();
		out.close();
	}

	public static void main(String[] args) throws Exception {
		new Template().run();
	}
}


import static java.lang.Math.*;

import java.io.*;
import java.util.*;

public class Template {
	BufferedReader in;
	PrintWriter out;
	StringTokenizer st;

	String next() {
		while (st==null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(in.readLine());
			} catch (Exception e) {}
		}
		return st.nextToken();
	}

	int nextInt() {
		return Integer.parseInt(next());
	}

	long nextLong() {
		return Long.parseLong(next());
	}

	double nextDouble() {
		return Double.parseDouble(next());
	}

	int n;

	class Edge {
		int a, b;
		boolean f;
		public Edge(int a, int b, boolean f) {
			this.a=a;
			this.b=b;
			this.f=f;
		}
	}

	ArrayList<Edge>[] g;
	boolean[] u;
	int[] up, down;

	void dfs(int v) {
		u[v] = true;
		up[v] = 0;
		down[v] = 0;
		for (Edge e : g[v]) {
			if (u[e.b]) continue;
			if (e.f) down[v]++; else up[v]++;
			dfs(e.b);
			down[v] += down[e.b];
			up[v] += up[e.b];
		}
	}

	ArrayList<Integer> ans;
	int res = Integer.MAX_VALUE;

	void dfs2(int v, int f, int r) {
		u[v]= true;
		if (res>r) {
			res = r;
			ans.clear();
		}
		if (res==r) ans.add(v + 1);

		for (Edge e : g[v]) {
			if (u[e.b]) continue;
			if (e.f) {
				dfs2(e.b, f-1 , r+1);
			} else {
				dfs2(e.b, f+1 , r-1);
			}
		}
	}

	public void run() throws Exception {
		in = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		Long start = System.currentTimeMillis();

		n = nextInt();
		g = new ArrayList[n];
		for (int i=0; i<n; i++) g[i] = new ArrayList<Edge>();

		for (int i=0; i<n-1; i++) {
			int a = nextInt() - 1;
			int b = nextInt() - 1;
			g[a].add(new Edge(a, b, true));
			g[b].add(new Edge(b, a, false));
		}

		u = new boolean[n];
		up = new int[n];
		down = new int[n];
		dfs(0);

		u = new boolean[n];
		ans = new ArrayList<Integer>();
		dfs2(0, down[0], up[0]);

		out.println(res);
		for (int x : ans) out.print(x + " ");
		Long end = System.currentTimeMillis();
		out.close();
	}

	public static void main(String[] args) throws Exception {
		new Template().run();
	}
}


import java.util.Scanner;

public class Test {
	static int res[][];
	static int[][] matrix ;
	/**
	 * @param args
	 * @return
	 */
	public static void go(int i,int n){
		res[i][1]=1;
                int index=res[i][2];
                while(index!=-1){
                    int j=matrix[index][0];
                    if(matrix[index][2]==-1 && res[j][1]==0){
				res[i][0]++;
				go(j,n);
			}
			if(matrix[index][2]==1 && res[j][1]==0){
				go(j,n);
                        }
                        index=matrix[index][1];

                }

	}
	public static void go2(int i,int n){
            int index=res[i][2];
                while(index!=-1){
                    int j=matrix[index][0];
                    if(matrix[index][2]==-1 && res[j][1]==0){

				res[j][0]=res[i][0]-1;
				res[j][1]=1;
				go2(j,n);
			}
			if(matrix[index][2]==1 && res[j][1]==0){
				res[j][0]=res[i][0]+1;
				res[j][1]=1;
				go2(j,n);
                        }
                        index=matrix[index][1];

                }

	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		res=new int[n][3];
		matrix = new int[2*(n-1)][3];
                for(int i=0;i<n;i++){
                    res[i][2]=-1;
                }
                int index=0;
		for(int i=0;i<n-1;i++){
			int start=scan.nextInt()-1;
			int end=scan.nextInt()-1;
                        int prev=res[start][2];
			res[start][2]=index;
                        matrix[index][0]=end;
                        matrix[index][1]=prev;
                        matrix[index][2]=1;
                        index++;
                        prev=res[end][2];
                        res[end][2]=index;
                       matrix[index][0]=start;
                       matrix[index][1]=prev;
                       matrix[index][2]=-1;
                       index++;

		}
		go(0,n);

		for(int j=1;j<n;j++){
			res[0][0]+=res[j][0];
			res[j][0]=0;
			res[j][1]=0;
		}

		go2(0,n);
		int min=res[0][0];
		for(int j=1;j<n;j++){
		 if(min>res[j][0]){
			 min=res[j][0];
		 }
		}
		System.out.println(min);
		for(int j=0;j<n;j++){
			if(min==res[j][0]){
				System.out.print(j+1+" ");
			}
		}
	}

}


import java.util.Scanner;

public class test {
	static int res[][];
	static int[][] matrix ;
	/**
	 * @param args
	 * @return
	 */
	public static void go(int i,int n){
		res[i][1]=1;
		for(int j=0;j<n;j++){
			if(matrix[j][i]==1 && res[j][1]==0){
				res[i][0]++;
				go(j,n);
			}
			if(matrix[i][j]==1 && res[j][1]==0)
				go(j,n);

		}

	}
	public static void go2(int i,int n){
		for(int j=0;j<n;j++){
			if(matrix[j][i]==1 && res[j][1]==0){
				res[j][0]=res[i][0]-1;
				res[j][1]=1;
				go2(j,n);
			}
			if(matrix[i][j]==1 && res[j][1]==0){
				res[j][0]=res[i][0]+1;
				res[j][1]=1;
				go2(j,n);
			}

		}

	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		res=new int[n][2];
		matrix = new int[n][n];
		for(int i=0;i<n-1;i++){
			int start=scan.nextInt()-1;
			int end=scan.nextInt()-1;
			matrix[start][end]=1;
		}
		go(0,n);

		for(int j=1;j<n;j++){
			res[0][0]+=res[j][0];
			res[j][0]=0;
			res[j][1]=0;
		}
		go2(0,n);
		int min=res[0][0];
		for(int j=1;j<n;j++){
		 if(min>res[j][0]){
			 min=res[j][0];
		 }
		}
		System.out.println(min);
		for(int j=0;j<n;j++){
			if(min==res[j][0]){
				System.out.print(j+1+" ");
			}
		}
	}

}


import java.awt.Point;
import java.io.*;
import java.util.*;

public class R135_D2_D {
    public static LinkedList<edge>[] edges;
    public static int downs[];
    public static int ups[];

    public static int dfs(int up, int down, int node, int prev) {
        int uups = 0;
        downs[node] = down;
        ups[node] = up;
        for (edge e : edges[node]) {
            if (e.x == prev)
                continue;
            if (e.yes) {
                uups += dfs(up, down + 1, e.x, node);
            } else {
                uups += 1 + dfs(up + 1, down, e.x, node);
            }
        }
        return uups;
    }

    public static void main(String[] args) throws Exception {
        InputReader in = new InputReader(System.in);
        int n = in.readInt();
        edges = new LinkedList[n];
        for (int i = 0; i < n; i++) {
            edges[i] = new LinkedList<R135_D2_D.edge>();
        }
        for (int i = 0; i < n - 1; i++) {
            int a = in.readInt() - 1;
            int b = in.readInt() - 1;
            edges[a].add(new edge(b, true));
            edges[b].add(new edge(a, false));
        }
        downs = new int [n];
        ups = new int [n];
        int all = dfs(0, 0, 0, -1);
        ArrayList<Integer> best = new ArrayList<Integer>();
        int min = 1000000;
        for (int i = 0; i < n; i++) {
            //System.out.println(all+" "+ups[i]+" "+downs[i]);
            int curr = all - ups[i] + downs[i];
            if (curr < min) {
                min = curr;
                best = new ArrayList<Integer>();
                best.add(i + 1);
            } else if (curr == min) {
                best.add(i + 1);
            }
        }
        System.out.println(min);
        for (int i : best) {
            System.out.println(i);
        }
    }

    static class edge {
        int x;
        boolean yes;

        public edge(int xx, boolean ee) {
            x = xx;
            yes = ee;
        }
    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1000];
        private int curChar, numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        private int read() {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public long readLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuffer res = new StringBuffer();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private String readLine0() {
            StringBuffer buf = new StringBuffer();
            int c = read();
            while (c != '\n' && c != -1) {
                buf.appendCodePoint(c);
                c = read();
            }
            return buf.toString();
        }

        public String readLine() {
            String s = readLine0();
            while (s.trim().length() == 0)
                s = readLine0();
            return s;
        }

        public String readLine(boolean ignoreEmptyLines) {
            if (ignoreEmptyLines)
                return readLine();
            else
                return readLine0();
        }

        public char readCharacter() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            return (char) c;
        }

        public double readDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, readInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, readInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }
    }
}


#include <iostream>
#include <fstream>

#include <string>
#include <vector>

#include <utility>

#include <algorithm>

using namespace std;

int n;
vector< pair<int,int> > a;

int main()
{

#if 0
	ifstream ifile("input.txt");
	if(ifile) freopen("input.txt","rt",stdin);
#ifdef ONLINE_JUDGE
	if(ifile) freopen("output.txt","wt",stdout);
#endif
#endif

	cin >> n;
	for( int i=0; i<n; ++i )
	{
		int t;
		cin >> t;
		a.push_back( make_pair( t, i+1 ) );
	}

	sort( a.begin(), a.end() );

	if ( a.size() == 1 )
		cout << "Exemplary pages.";
	else if ( a.size() == 2 )
	{
		if ( ( a[1].first-a[0].first ) % 2 )
			cout << "Unrecoverable configuration.";
		else
			cout << (a[1].first-a[0].first)/2 << " ml. from cup #"<<a[0].second<< "to cup #"<<a[1].second<<".";
	}
	else
	{
		if ( a[0].first == a[a.size()-1].first )
			cout << "Exemplary pages.";
		else if ( ( a[a.size()-1].first-a[0].first ) %2 )
			cout << "Unrecoverable configuration.";
		else if ( ( a[a.size()-1].first+a[0].first )/2 == a[1].first && ( a[a.size()-1].first+a[0].first )/2 == a[a.size()-2].first )
			cout << (a[a.size()-1].first-a[0].first)/2 << " ml. from cup #"<<a[0].second<< "to cup #"<<a[a.size()-1].second<<".";
		else
			cout << "Unrecoverable configuration.";
	}

	return 0;
}


#include <stdio.h>
#include <math.h>

int num[1100];

int main()
{
    int n,i,sum,avg,ans,a,b;
    while(scanf("%d",&n)!=EOF)
    {
        sum = 0;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&num[i]);
            sum += num[i];
        }
        avg = sum/n;
        ans = 0;
        for(i=1;i<=n;i++)
        {
            if(num[i]!=avg)
                ans++;
        }
        if(ans==0)
            printf("Exemplary pages.\n");
        else if(ans==2)
        {
            i = 1;
            while(num[i]==avg)
            {
                i++;
            }
            a = i;
            i++;
            while(num[i]==avg)
            {
                i++;
            }
            b = i;
            if(abs(num[a]-num[b])%2==0)
            {
                if(num[a]>num[b])
                    printf("%d ml. from cup #%d to cup #%d.\n",abs(num[a]-num[b])/2,b,a);
                else
                    printf("%d ml. from cup #%d to cup #%d.\n",abs(num[a]-num[b])/2,a,b);
            }
            else
                printf("Unrecoverable configuration.\n");
        }
        else
            printf("Unrecoverable configuration.\n");
    }
    return 0;
}


#include <stdio.h>
#include <math.h>

int num[1100];

int main()
{
    int n,i,sum,avg,ans,a,b;
    while(scanf("%d",&n)!=EOF)
    {
        sum = 0;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&num[i]);
            sum += num[i];
        }
        if(sum%n==0)
        {
            avg = sum/n;
            ans = 0;
            for(i=1;i<=n;i++)
            {
                if(num[i]!=avg)
                    ans++;
            }
            if(ans==0)
                printf("Exemplary pages.\n");
            else if(ans==2)
            {
                i = 1;
                while(num[i]==avg)
                {
                    i++;
                }
                a = i;
                i++;
                while(num[i]==avg)
                {
                    i++;
                }
                b = i;
                if(abs(num[a]-num[b])%2==0)
                {
                    if(num[a]>num[b])
                        printf("%d ml. from cup #%d to cup #%d.\n",abs(num[a]-num[b])/2,b,a);
                    else
                        printf("%d ml. from cup #%d to cup #%d.\n",abs(num[a]-num[b])/2,a,b);
                }
                else
                    printf("Unrecoverable configuration.\n");
            }
            else
                printf("Unrecoverable configuration.\n");
        }
        else
            printf("Unrecoverable configuration.\n");
    }
    return 0;
}


#include <stdio.h>
#include <string.h>
#include <math.h>

int num[1100];

int main()
{
    int sum,n,i,ave,ans,a,b;
    while(scanf("%d",&n)!=EOF)
    {
        sum = 0;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&num[i]);
            sum += num[i];
        }
        ave = sum / n;
        ans = 0;
        for(i=1;i<=n;i++)
        {
            if(num[i]!=ave)
                ans++;
        }
        if(ans==0)
            printf("Exemplary pages.\n");
        else if(ans==2)
        {
            for(i=1;i<=n;i++)
            {
                if(num[i]!=ave)
                {
                    a = i;
                    break;
                }
            }
            for(i+=1;i<=n;i++)
            {
                if(num[i]!=ave)
                {
                    b = i;
                    break;
                }
            }
            if(abs(num[a]-num[b])%2!=0)
                printf("Unrecoverable configuration.\n");
            else
            {
                if(num[a]>num[b])
                    printf("%d ml. from cup #%d to cup #%d.\n",(num[a]-num[b])/2,b,a);
                else
                    printf("%d ml. from cup #%d to cup #%d.\n",(num[b]-num[a])/2,a,b);
            }
        }
        else
            printf("Unrecoverable configuration.\n");
    }
    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <string>
#include <math.h>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
const int max_size = 1003;

struct botle{
    int ml,c;
    bool operator <(botle a )const{
        return ml<a.ml;
    }
};
int main(){
#ifdef  xDx
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
#endif
    int n,A[max_size],ml[5] = {0,0,0,0,0};
    vector <botle> V;
    scanf("%d",&n);
    for(int i =0 ; i<n ; i++)
    {
        scanf("%d",&A[i]);
        bool fi = false;
        int t = 0;
        for(;t<(int)V.size() && !fi ;){
            if(A[i]==V[t].ml)
                fi = true;
            else
                t++;
        }
        if(fi)
            V[t].c++;
        else
        {
            botle tmp;
            tmp.ml = A[i];
            tmp.c = 1;
            V.push_back(tmp);
            if(t>=3){
                printf("Unrecoverable configuration.");
                return 0;
            }
        }
    }
    if((int)V.size()==1)
        printf("Exemplary pages.");
    if((int)V.size()==2)
        printf("Unrecoverable configuration.");
    if((int)V.size()==3)
    {
        sort(V.begin(),V.end());
        if(V[0].c ==1 && V[2].c==1 && V[0].ml+V[2].ml == 2 * V[1].ml)
        {
            int v = V[2].ml - V[0].ml;
            int a =0;
            for( ; a<n && A[a]!=V[0].ml; a++);
            int b =0;
            for( ; b<n && A[b]!=V[2].ml; b++);
            printf("%d ml. from cup #%d to cup #%d.",v/2,++a,++b);
        }
        else printf("Unrecoverable configuration.");

    }
    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <string>
#include <math.h>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
const int max_size = 1003;

struct botle{
    int ml,c;
    bool operator <(botle a )const{
        return ml<a.ml;
    }
};
int main(){
#ifdef  xDx
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
#endif
    int n,A[max_size];
    vector <botle> V;
    scanf("%d",&n);
    for(int i =0 ; i<n ; i++)
    {
        scanf("%d",&A[i]);
        bool fi = false;
        int t = 0;
        for(;t<(int)V.size() && !fi ;){
            if(A[i]==V[t].ml)
                fi = true;
            else
                t++;
        }
        if(fi)
            V[t].c++;
        else
        {
            botle tmp;
            tmp.ml = A[i];
            tmp.c = 1;
            V.push_back(tmp);
            if((int)V.size()>3){
                printf("Unrecoverable configuration.");
                return 0;
            }
        }
    }
    if((int)V.size()==1)
        printf("Exemplary pages.");
    if((int)V.size()==2)
    {
        if(n>2)
            printf("Unrecoverable configuration.");
        else
        {
            sort(V.begin(),V.end());
            if((A[0]+A[1])%2)
                printf("Unrecoverable configuration.");
            else
            {
                int v = V[1].ml - V[0].ml;
                int a =0;
                for( ; a<n && A[a]!=V[0].ml; a++);
                int b =0;
                for( ; b<n && A[b]!=V[1].ml; b++);
                printf("%d ml. from cup #%d to cup #%d.",v/2,++a,++b);
            }
        }
    }
    if((int)V.size()==3)
    {
        sort(V.begin(),V.end());
        if(V[0].c ==1 && V[2].c==1 && V[0].ml+V[2].ml == 2 * V[1].ml)
        {
            int v = V[2].ml - V[0].ml;
            int a =0;
            for( ; a<n && A[a]!=V[0].ml; a++);
            int b =0;
            for( ; b<n && A[b]!=V[2].ml; b++);
            printf("%d ml. from cup #%d to cup #%d.",v/2,++a,++b);
        }
        else printf("Unrecoverable configuration.");

    }
    return 0;
}


#pragma comment(linker,"/stack:67108864")
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <sstream>
#include <fstream>
#include <climits>
#include <cfloat>
#include <functional>
#include <ctime>
#include <numeric>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <utility>
#include <bitset>
#include <string>
#include <list>
#include <stack>
#include <vector>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <typeinfo>
#include <cassert>
#include <ctime>

using namespace std;

#define forn(i,n) for(int i=0;i<int(n);++i)
#define forn1(i,n) for(int i=1;i<=int(n);++i)
#define ford(i,n) for(int i=int(n)-1;i>=0;--i)
#define ford1(i,n) for(int i=int(n);i>0;--i)
#define foran(i,l,r) for(int i=int(l);i<=int(r);++i)

#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define sqr(x) (x)*(x)
#define all(v) (v).begin(),(v).end()

typedef long double ld;
typedef long long ll;
typedef pair <ld ,ld > pt;

const ld EPS=1e-9;
const ld PI=3.1415926535897932384626433832795;

const ll INF=1e15;

int main()
{
    ifstream ifile("input.txt");
    if (ifile) freopen("input.txt", "rt", stdin);
#ifdef ONLINE_JUDGE
    if (ifile) freopen("output.txt", "wt", stdout);
#endif
    int n;
    while(cin >>n)
    {
        vector<pair<int,int> > a(n);
        forn(i,n)
        {
            scanf("%d",&a[i].first);
            a[i].second=i;
        }
        sort(all(a));
        int d=a[0].first+a.back().first;
        if((d&1)==1)
        {
            cout <<"Unrecoverable configuration."<<endl;
            continue;
        }
        else
        {
            int p1=a[0].second+1;
            int p2=a.back().second+1;
            int v=d/2-a[0].first;
            if(a[0].first==d/2&&a.back().first==d/2)
            {
                cout <<"Exemplary pages."<<endl;
                continue;
            }
            a[0].first=d/2;
            a.back().first=d/2;
            sort(all(a));
            if(a[0].first!=a.back().first)
            {
                cout <<"Unrecoverable configuration."<<endl;
                continue;
            }
            cout <<v<<" ml. from cup #"<<p1<<" to cup #"<<p2<<".\n";
        }
    }
    return 0;
}


#pragma comment(linker,"/stack:67108864")
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <sstream>
#include <fstream>
#include <climits>
#include <cfloat>
#include <functional>
#include <ctime>
#include <numeric>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <utility>
#include <bitset>
#include <string>
#include <list>
#include <stack>
#include <vector>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <typeinfo>
#include <cassert>
#include <ctime>

using namespace std;

#define forn(i,n) for(int i=0;i<int(n);++i)
#define forn1(i,n) for(int i=1;i<=int(n);++i)
#define ford(i,n) for(int i=int(n)-1;i>=0;--i)
#define ford1(i,n) for(int i=int(n);i>0;--i)
#define foran(i,l,r) for(int i=int(l);i<=int(r);++i)

#define X first
#define Y second
#define mp make_pair
#define pb push_back
#define sqr(x) (x)*(x)
#define all(v) (v).begin(),(v).end()

typedef long double ld;
typedef long long ll;
typedef pair <ld ,ld > pt;

const ld EPS=1e-9;
const ld PI=3.1415926535897932384626433832795;

const ll INF=1e15;

int main()
{
    ifstream ifile("input.txt");
    if (ifile) freopen("input.txt", "rt", stdin);
#ifdef ONLINE_JUDGE
    if (ifile) freopen("output.txt", "wt", stdout);
#endif
    int n;
    while(cin >>n)
    {
        vector<pair<int,int> > a(n);
        forn(i,n)
        {
            scanf("%d",&a[i].first);
            a[i].second=i;
        }
        sort(all(a));
        int d=a[0].first+a.back().first;
        if((d&1)==1)
        {
            cout <<"Unrecoverable configuration."<<endl;
            continue;
        }
        else
        {
            int p1=a[0].second+1;
            int p2=a.back().second+1;
            int v=d/2-a[0].first;
            if(a[0].first==d/2&&a.back().first==d/2)
            {
                cout <<"Exemplary pages."<<endl;
                continue;
            }
            a[0].first=d/2;
            a.back().first=d/2;
            sort(all(a));
            if(a[0].first!=a.back().first)
            {
                cout <<"Unrecoverable configuration."<<endl;
                continue;
            }
            cout <<v<<" ml. from cup #"<<p2<<" to cup #"<<p1<<".\n";
        }
    }
    return 0;
}


//#pragma warning(disable:4786)
#include<iostream>
#include<algorithm>
#include<cmath>
#include<stdio.h>
#include<queue>
#include<map>
#include<vector>
#include<string>
#include<string.h>
using namespace std;

#define pi acos(-1.0)
#define inf 0x7fffffff
#define eps 1e-8
const int maxn=0;

int main()
{
    int n,i,a[1001],min,max,mm,ma;
    while(scanf("%d",&n)!=-1)
    {
        int sum=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        double p=double (sum)/n;
        int count=0;
        for(i=1;i<=n;i++)
        {
            if(a[i]==p)
                count++;
            if(a[i]>p)
            {
                max=a[i];
                ma=i;
            }
            if(a[i]<p)
            {
                min=a[i];
                mm=i;
            }
        }
        if(count==n-2)
        {
            printf("%d ml. from cup #%d to cup #%d.\n",int(max-p),ma,mm);
        }
        else
        {
            if(count==n)
                printf("Exemplary pages.\n");
            else
                printf("Unrecoverable configuration.\n");
        }
    }
    return 0;
}


//#pragma warning(disable:4786)
#include<iostream>
#include<algorithm>
#include<cmath>
#include<stdio.h>
#include<queue>
#include<map>
#include<vector>
#include<string>
#include<string.h>
using namespace std;

#define pi acos(-1.0)
#define inf 0x7fffffff
#define eps 1e-8
const int maxn=0;

int main()
{
    int n,i,a[1001],min,max,mm,ma;
    while(scanf("%d",&n)!=-1)
    {
        int sum=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        if(n==2)
        {
            if(a[1]==a[2]){cout<<"Exemplary pages."<<endl;continue;}
            if((a[2]+a[1])%2==1){cout<<"Unrecoverable configuration."<<endl;continue;}
            if(a[1]<a[2])
            {
                printf("%d ml. from cup #1 to cup #2.\n",(a[2]-a[1])/2);
            }
            else printf("%d ml. from cup #2 to cup #1.\n",(a[1]-a[2])/2);
            continue;
        }
        double p=double (sum)/n;
        int count=0;
        for(i=1;i<=n;i++)
        {
            if(a[i]==p)
                count++;
            if(a[i]>p)
            {
                max=a[i];
                ma=i;
            }
            if(a[i]<p)
            {
                min=a[i];
                mm=i;
            }
        }
        if(count==n-2)
        {
            printf("%d ml. from cup #%d to cup #%d.\n",int(max-p),mm,ma);
        }
        else
        {
            if(count==n)
                printf("Exemplary pages.\n");
            else
                printf("Unrecoverable configuration.\n");
        }
    }
    return 0;
}


//#pragma warning(disable:4786)
#include<iostream>
#include<algorithm>
#include<cmath>
#include<stdio.h>
#include<queue>
#include<map>
#include<vector>
#include<string>
#include<string.h>
using namespace std;

#define pi acos(-1.0)
#define inf 0x7fffffff
#define eps 1e-8
const int maxn=0;

int main()
{
    int n,i,a[1001],min,max,mm,ma;
    while(scanf("%d",&n)!=-1)
    {
        int sum=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        double p=double (sum)/n;
        int count=0;
        for(i=1;i<=n;i++)
        {
            if(a[i]==p)
                count++;
            if(a[i]>p)
            {
                max=a[i];
                ma=i;
            }
            if(a[i]<p)
            {
                min=a[i];
                mm=i;
            }
        }
        if(count==n-2)
        {
            printf("%d ml. from cup #%d to cup #%d.\n",int(max-p),mm,ma);
        }
        else
        {
            if(count==n)
                printf("Exemplary pages.\n");
            else
                printf("Unrecoverable configuration.\n");
        }
    }
    return 0;
}


//#pragma warning(disable:4786)
#include<iostream>
#include<algorithm>
#include<cmath>
#include<stdio.h>
#include<queue>
#include<map>
#include<vector>
#include<string>
#include<string.h>
using namespace std;

#define pi acos(-1.0)
#define inf 0x7fffffff
#define eps 1e-8
const int maxn=0;

int main()
{
    int n,i,a[1001],min,max,mm,ma;
    while(scanf("%d",&n)!=-1)
    {
        int sum=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        if(n==2)
        {
            if(a[1]==a[2]){cout<<"Exemplary pages."<<endl;continue;}
            if((a[2]+a[0])%2==1){cout<<"Unrecoverable configuration."<<endl;continue;}
            if(a[1]<a[2])
            {
                printf("%d ml. from cup #1 to cup #2.\n",(a[2]-a[1])/2);
            }
            else printf("%d ml. from cup #2 to cup #1.\n",(a[2]-a[1])/2);
            continue;
        }
        double p=double (sum)/n;
        int count=0;
        for(i=1;i<=n;i++)
        {
            if(a[i]==p)
                count++;
            if(a[i]>p)
            {
                max=a[i];
                ma=i;
            }
            if(a[i]<p)
            {
                min=a[i];
                mm=i;
            }
        }
        if(count==n-2)
        {
            printf("%d ml. from cup #%d to cup #%d.\n",int(max-p),mm,ma);
        }
        else
        {
            if(count==n)
                printf("Exemplary pages.\n");
            else
                printf("Unrecoverable configuration.\n");
        }
    }
    return 0;
}


#include <iostream>
#include <map>
#include <set>
using namespace std;

int main()
{
	int n; cin >> n;

	map<int, set<int> > a;
	for (int i = 0; i < n; ++i)
	{
		int val; cin >> val;
		a[val].insert(i + 1);
	}

	if (a.size() == 1)
	{
		puts("Exemplary pages.");
		return 0;
	}

	if (a.size() <= 3)
	{
		int mn = a.begin() -> first;
		int mx = (--a.end()) -> first;
		int md = a.size() == 3 ? md = (--(--a.end())) -> first : -1;
		if (a[mn].size() == 1 && a[mx].size() == 1 && (mx + mn) % 2 == 0 && (md == -1 && (mx + mn) / 2 == md || md != -1))
		{
			printf("%d ml. from cup #%d to cup #%d.\n", (mx - mn) / 2, *a[mn].begin(), *a[mx].begin());
			return 0;
		}
	}

	puts("Unrecoverable configuration.");

	return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <map>
#include <set>
using namespace std;

int main()
{
	int n; cin >> n;

	// value, numbers
	map<int, set<int> > a;
	for (int i = 0; i < n; ++i)
	{
		int val; cin >> val;
		a[val].insert(i + 1);
	}

	if (a.size() == 1)
		cout << "Exemplary pages." << endl;
	else if (a.size() <= 3)
	{
		int min = a.begin() -> first;
		int max = (--a.end()) -> first;
		bool ussigned_mid = false;
		int mid;
		if (a.size() == 3)
		{
			mid = (--(--a.end())) -> first;
			ussigned_mid = true;
		}
		if (a[min].size() == 1 && a[max].size() == 1 && (max + min) % 2 == 0 && (ussigned_mid && (max + min) / 2 == mid || !ussigned_mid))
		{
			int from = *a[min].begin();
			int to = *a[max].begin();
			int v = (max - min) / 2;
			printf("%d ml. from cup #%d to cup #%d.\n", v, from, to);
		}
		else
			cout << "Unrecoverable configuration." << endl;

	}
	else
		cout << "Unrecoverable configuration." << endl;

	return 0;
}


#include <iostream>
#include <map>
#include <set>
using namespace std;

int main()
{
	int n; cin >> n;

	map<int, set<int> > a;
	for (int i = 0; i < n; ++i)
	{
		int val; cin >> val;
		a[val].insert(i + 1);
	}

	if (a.size() == 1)
		puts("Exemplary pages.");
	else if (a.size() <= 3)
	{
		int mn = a.begin() -> first;
		int mx = (--a.end()) -> first;
		int md = a.size() == 3 ? md = (--(--a.end())) -> first : -1;
		if (a[mn].size() == 1 && a[mx].size() == 1 && (mx + mn) % 2 == 0 && (md == -1 && (mx + mn) / 2 == md || md != -1))
			printf("%d ml. from cup #%d to cup #%d.\n", (mx - mn) / 2, *a[mn].begin(), *a[mx].begin());
		else
			puts("Unrecoverable configuration.");
	}
	else
		puts("Unrecoverable configuration.");

	return 0;
}


#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <map>
#include <set>
using namespace std;

int main()
{
	//freopen("D:\\inp.txt", "r", stdin);
	set<int> tps;
	int n; cin >> n;
	vector<int> a(n);
	for (int i = 0; i < n; ++i)
	{
		scanf("%d", &a[i]);
		tps.insert(a[i]);
	}

	if (tps.size() == 1)
		cout << "Exemplary pages." << endl;
	else if (n == 2 && tps.size() == 2)
	{
		int x1 = a[0], x2 = a[1];
		bool f = true;
		if (x1 > x2)
			swap(x1, x2), f = false;
		int v = (x2 - x1) / 2;
		printf("%d ml. from cup #%d to cup #%d.\n", v, (f ? 1 : 2), (f ? 2 : 1));
	}
	else if (tps.size() == 3)
	{
		int t[3];
		int j = 0;
		for (set<int>::const_iterator it = tps.begin(); it != tps.end(); ++it)
			t[j++] = (*it);

		int c0 = 0, c1 = 0, c2 = 0;
		for (int i = 0; i < n; ++i)
		{
			if (a[i] == t[0])
				c0++;
			else if (a[i] == t[1])
				c1++;
			else
				c2++;
		}
		if (c0 == 1 && c2 == 1)
		{
			int v = (t[2] - t[0]) / 2;
			if (t[0] + v == t[1])
			{
				int xfrom = -1; int xto = -1;
				for (int i = 0; i < n; ++i)
				{
					if (a[i] == t[0])
						xfrom = i + 1;
					if (a[i] == t[2])
						xto = i + 1;
					if (xfrom != -1 && xto != -1)
						break;
				}
				printf("%d ml. from cup #%d to cup #%d.\n", v, xfrom, xto);
			}
			else
				cout << "Unrecoverable configuration." << endl;
		}
	}
	else
		cout << "Unrecoverable configuration." << endl;
	return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <algorithm>
#include <cmath>
#include <map>
#define LL long long
#define DB double

using namespace std;
const int N = 1009;
int s,n;
struct nod{
    int v,val;
    bool operator<(const nod t)const
    {
        return val<t.val;
    }
}re[N];
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    #endif
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&re[i].val);re[i].v = i;
        s+=re[i].val;
    }sort(re+1,re+n+1);
    if(s%n)
    {
        printf("Unrecoverable configuration.\n");
        return 0;
    }
    int k = s/n;
    int t = 0;
    for(int i=1;i<=(n>>1);i++)
    if(re[i].val+re[n-i+1].val!=(k<<1))
    {
        printf("Unrecoverable configuration.\n");
        return 0;
    }else if(re[i].val!=k) t = 1;
    if(t==0)
    {
        printf("Exemplary pages.\n");
        return 0;
    }
    for(int i=1;i<=(n>>1);i++)
    if(re[i].val!=k)
    {
        printf("%d ml. from cup #%d to cup #%d.\n",k-re[i].val,re[i].v,re[n-i+1].v);
    }
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <algorithm>
#include <cmath>
#include <map>
#define LL long long
#define DB double

using namespace std;
const int N = 1009;
int s,n;
struct nod{
    int v,val;
    bool operator<(const nod t)const
    {
        return val<t.val;
    }
}re[N];
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    #endif
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&re[i].val);re[i].v = i;
        s+=re[i].val;
    }sort(re+1,re+n+1);
    if(s%n)
    {
        printf("Unrecoverable configuration.\n");
        return 0;
    }
    int k = s/n;
    int t = 0;
    for(int i=1;i<=(n>>1);i++)
    if(re[i].val+re[n-i+1].val!=(k<<1))
    {
        printf("Unrecoverable configuration.\n");
        return 0;
    }else if(re[i].val!=k) t ++;
    if(t>1)
    {
        printf("Unrecoverable configuration.\n");
        return 0;
    }
    if(t==0)
    {
        printf("Exemplary pages.\n");
        return 0;
    }
    for(int i=1;i<=(n>>1);i++)
    if(re[i].val!=k)
    {
        printf("%d ml. from cup #%d to cup #%d.\n",k-re[i].val,re[i].v,re[n-i+1].v);
    }
    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <queue>
#include <iterator>
#include <functional>
#include <cmath>
#include <cstdio>
#include <cctype>
#include <sstream>
#include <cstdlib>
#include <iomanip>
#include <limits.h>

using namespace std;

template<typename T> T gcd(T a, T b)
{
    return b ? gcd(b, a % b) : a;
}

template<typename T> T sqr(T x)
{
    return x*x;
}

template<typename T> T cube(T x)
{
    return x * x*x;
}

#define forn(i,n) for(int i = 0; i < (int)(n); i++)
#define forr(i,n) for(int i = (int)(n)-1; i >= 0; i--)
#define forn1(i,n) for(int i = 1; i <= (int)(n); i++)
#define forr1(i,n) for(int i = (int)(n); i >= 1; i--)
#define forit(it,x) for(it = (x).begin(); it != (x).end(); it++)

#define mp make_pair
#define pb push_back
#define fr first
#define sc second
#define sz size()
#define all(x) x.begin(), x.end()

typedef long long int64;
typedef vector<int> vi;
typedef vector<int64> vi64;
typedef pair<int, int> pii;
typedef pair<int64, int64> pii64;
typedef vector< vi > vvi;
typedef vector< bool > vbool;
typedef vector< vbool > vvb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector< vc > vvc;
typedef map<string, int> msi;
typedef map<int, string> mis;
typedef pair< pii, int> ppi;
typedef pair< int, pii > pip;
typedef set<int> si;
typedef map<int, vi > miv;

int main()
{
#ifndef ONLINE_JUDGE
    freopen("Readme.txt","r",stdin);
#endif
    int n;
    cin >> n;
    vi a(n);
    forn(i,n)
        cin >> a[i];
    map<int, vi > m;
    forn(i,n)
    {
        m[a[i]].pb(i);
    }

    if(m.sz == 1)
    {
        cout << "Exemplary pages." << endl;
        return 0;
    }
    if(m.sz == 3)
    {
        vector< pii > b;
        miv::iterator it;
        forit(it,m)
        {
            b.pb(mp(it->sc.sz,it->fr)); //размер вектора, число
        }
        sort(all(b));

        if(b[0].fr == 1 && b[1].fr == 1 && b[2].fr == 1 && (b[0].sc+b[2].sc)/2 == b[1].sc)
        {
            cout << b[2].sc-b[1].sc << " ml. from cup #"<< m[b[0].sc][0]+1 << " to cup #" << m[b[2].sc][0]+1 << '.' << endl;
            return 0;
        }

        if(b[0].fr == 1 && b[1].fr == 1 && (b[0].sc+b[1].sc)/2.0 == (double)b[2].sc)
        {
            cout << b[1].sc-b[2].sc << " ml. from cup #"<< m[b[0].sc][0]+1 << " to cup #" << m[b[1].sc][0]+1 << '.' << endl;
            return 0;
        }
    }

    cout << "Unrecoverable configuration." << endl;

    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <queue>
#include <iterator>
#include <functional>
#include <cmath>
#include <cstdio>
#include <cctype>
#include <sstream>
#include <cstdlib>
#include <iomanip>
#include <limits.h>

using namespace std;

template<typename T> T gcd(T a, T b)
{
    return b ? gcd(b, a % b) : a;
}

template<typename T> T sqr(T x)
{
    return x*x;
}

template<typename T> T cube(T x)
{
    return x * x*x;
}

#define forn(i,n) for(int i = 0; i < (int)(n); i++)
#define forr(i,n) for(int i = (int)(n)-1; i >= 0; i--)
#define forn1(i,n) for(int i = 1; i <= (int)(n); i++)
#define forr1(i,n) for(int i = (int)(n); i >= 1; i--)
#define forit(it,x) for(it = (x).begin(); it != (x).end(); it++)

#define mp make_pair
#define pb push_back
#define fr first
#define sc second
#define sz size()
#define all(x) x.begin(), x.end()

typedef long long int64;
typedef vector<int> vi;
typedef vector<int64> vi64;
typedef pair<int, int> pii;
typedef pair<int64, int64> pii64;
typedef vector< vi > vvi;
typedef vector< bool > vbool;
typedef vector< vbool > vvb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector< vc > vvc;
typedef map<string, int> msi;
typedef map<int, string> mis;
typedef pair< pii, int> ppi;
typedef pair< int, pii > pip;
typedef set<int> si;
typedef map<int, vi > miv;

int main()
{
#ifndef ONLINE_JUDGE
    freopen("Readme.txt","r",stdin);
#endif
    int n;
    cin >> n;
    vi a(n);
    forn(i,n)
        cin >> a[i];
    map<int, vi > m;
    forn(i,n)
    {
        m[a[i]].pb(i);
    }

    if(m.sz == 1)
    {
        cout << "Exemplary pages." << endl;
        return 0;
    }
    if(m.sz == 3 || m.sz == 2)
    {
        vector< pii > b;
        miv::iterator it;
        forit(it,m)
        {
            b.pb(mp(it->sc.sz,it->fr)); //размер вектора, число
        }
        sort(all(b));
        auto bb = b;
        if(m.sz == 2)
        {
            int a = bb[0].sc,b = bb[1].sc;
            int ia = m[bb[0].sc][0];
            int ib = m[bb[1].sc][0];

            if(n == 2 && (b-a) % 2 == 0)
            {
                cout << (b-a)/2 << " ml. from cup #"<< ia+1 << " to cup #" << ib+1 << '.' << endl;
                return 0;
            }
            goto l1;
        }

        if(b[0].fr == 1 && b[1].fr == 1 && b[2].fr == 1 && (b[0].sc+b[2].sc)/2 == b[1].sc)
        {
            cout << b[2].sc-b[1].sc << " ml. from cup #"<< m[b[0].sc][0]+1 << " to cup #" << m[b[2].sc][0]+1 << '.' << endl;
            return 0;
        }

        if(b[0].fr == 1 && b[1].fr == 1 && (b[0].sc+b[1].sc)/2.0 == (double)b[2].sc)
        {
            cout << b[1].sc-b[2].sc << " ml. from cup #"<< m[b[0].sc][0]+1 << " to cup #" << m[b[1].sc][0]+1 << '.' << endl;
            return 0;
        }
    }
    l1:
    cout << "Unrecoverable configuration." << endl;

    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <queue>
#include <iterator>
#include <functional>
#include <cmath>
#include <cstdio>
#include <cctype>
#include <sstream>
#include <cstdlib>
#include <iomanip>
#include <limits.h>

using namespace std;

template<typename T> T gcd(T a, T b)
{
    return b ? gcd(b, a % b) : a;
}

template<typename T> T sqr(T x)
{
    return x*x;
}

template<typename T> T cube(T x)
{
    return x * x*x;
}

#define forn(i,n) for(int i = 0; i < (int)(n); i++)
#define forr(i,n) for(int i = (int)(n)-1; i >= 0; i--)
#define forn1(i,n) for(int i = 1; i <= (int)(n); i++)
#define forr1(i,n) for(int i = (int)(n); i >= 1; i--)
#define forit(it,x) for(it = (x).begin(); it != (x).end(); it++)

#define mp make_pair
#define pb push_back
#define fr first
#define sc second
#define sz size()
#define all(x) x.begin(), x.end()

typedef long long int64;
typedef vector<int> vi;
typedef vector<int64> vi64;
typedef pair<int, int> pii;
typedef pair<int64, int64> pii64;
typedef vector< vi > vvi;
typedef vector< bool > vbool;
typedef vector< vbool > vvb;
typedef vector<string> vs;
typedef vector<char> vc;
typedef vector< vc > vvc;
typedef map<string, int> msi;
typedef map<int, string> mis;
typedef pair< pii, int> ppi;
typedef pair< int, pii > pip;
typedef set<int> si;
typedef map<int, vi > miv;

int main()
{
#ifndef ONLINE_JUDGE
    freopen("Readme.txt","r",stdin);
#endif
	int n;
	cin >> n;
	vi a(n);
	forn(i,n)
		cin >> a[i];
	map<int, vi > m;
	forn(i,n)
	{
		m[a[i]].pb(i);
	}

	if(m.sz == 1)
	{
		cout << "Exemplary pages." << endl;
		return 0;
	}
	if(m.sz == 3 || m.sz == 2)
	{
		vector< pii > b;
		miv::iterator it;
		forit(it,m)
		{
			b.pb(mp(it->sc.sz,it->fr));	//размер вектора, число
		}
		sort(all(b));
		vector< pii > bb = b;
		if(m.sz == 2)
		{
			int a = bb[0].sc,b = bb[1].sc;
			int ia = m[bb[0].sc][0];
			int ib = m[bb[1].sc][0];

			if(n == 2 && (b-a) % 2 == 0)
			{
				cout << (b-a)/2 << " ml. from cup #"<< ia+1 << " to cup #" << ib+1 << '.' << endl;
				return 0;
			}
			goto l1;
		}

		if(b[0].fr == 1 && b[1].fr == 1 && b[2].fr == 1 && (b[0].sc+b[2].sc)/2 == b[1].sc)
		{
			cout << b[2].sc-b[1].sc << " ml. from cup #"<< m[b[0].sc][0]+1 << " to cup #" << m[b[2].sc][0]+1 << '.' << endl;
			return 0;
		}

		if(b[0].fr == 1 && b[1].fr == 1 && (b[0].sc+b[1].sc)/2.0 == (double)b[2].sc)
		{
			cout << b[1].sc-b[2].sc << " ml. from cup #"<< m[b[0].sc][0]+1 << " to cup #" << m[b[1].sc][0]+1 << '.' << endl;
			return 0;
		}
	}
	l1:
	cout << "Unrecoverable configuration." << endl;

	return 0;
}


//Bismillahir Rahmanir Rahim
#include<cstdio>
#include<cstring>
#include<string>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<map>
#include<set>
#include<iterator>
using namespace std;
#define N 1005
#define eps 1e-8
#define pi 2*acos(0.0)
#define fi(b,e) for((i)=b;(i)<(e);(i)++)

int main()
{
	//freopen("in.txt","r+",stdin);
	int i,n,t,cas=1,a[N],from,to,min,max,flag;
	while(scanf("%d",&n)==1)
	{
		min=999999;
		max=0;
		fi(0,n) {
			scanf("%d",&a[i]);
			if(a[i]>max){
				max=a[i];
				to=i+1;
			}
			if(min>a[i]){
				min=a[i];
				from=i+1;
			}
		}
		if(min==max){
			printf("Exemplary pages.\n");
			continue;
		}
		t=(max+min)/2;
		sort(a,a+n);
		flag=0;
		for(i=1;i<n-1;i++){
			if(t!=a[i])
				flag=1;
		}
		if((max+min)%2==1) flag=1;
		if(flag==0)
			printf("%d ml. from cup #%d to cup #%d.\n",max-t,from,to);
		else
			printf("Unrecoverable configuration.\n");

	}
	return 0;
}


//Bismillahir Rahmanir Rahim
#include<cstdio>
#include<cstring>
#include<string>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<map>
#include<set>
#include<iterator>
using namespace std;
#define N 1005
#define eps 1e-8
#define pi 2*acos(0.0)
#define fi(b,e) for((i)=b;(i)<(e);(i)++)

int main()
{
	//freopen("in.txt","r+",stdin);
	int i,n,t,cas=1,a[N],from,to,min,max,flag;
	while(scanf("%d",&n)==1)
	{
		min=999999;
		max=0;
		fi(0,n) {
			scanf("%d",&a[i]);
			if(a[i]>max){
				max=a[i];
				to=i+1;
			}
			if(min>a[i]){
				min=a[i];
				from=i+1;
			}
		}
		if(min==max){
			printf("Exemplary pages.\n");
			continue;
		}
		t=(max+min)/2;
		sort(a,a+n);
		flag=0;
		for(i=1;i<n-1;i++){
			if(t!=a[i])
				flag=1;
		}
		if(flag==0)
			printf("%d ml. from cup #%d to cup #%d.\n",max-t,from,to);
		else
			printf("Unrecoverable configuration.\n");

	}
	return 0;
}


#include <cstdio>
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <sstream>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <cctype>
#include <limits>
#include<ctime>

using namespace std;

const double EPS = 1e-9;
const long long  INF = 1000000000000000000;

typedef pair<int, int> PII;
typedef pair<double,double> PDD;
typedef vector<long long> VLL;
typedef vector<int> VI;

#define FOR(i,a,b) for (int _n(b), i(a); i < _n; i++)
#define FORD(i,a,b) for(int i=(a),_b=(b);i>=_b;--i)
#define REP(i,n) FOR(i,0,n)

#define UNIQUE(v) SORT(v), v.erase(unique(v.begin(),v.end()),v.end())
#define SORT(c) sort((c).begin(),(c).end())
#define ll long long

int main()
{
#ifdef LocalHost
        freopen("input.txt","r",stdin);
     // freopen("output.txt","w",stdout);
#endif
	int n;
	cin >> n;
	int d = 0;
	vector<int> v(n);
	vector<PII> a;
	for (int i = 0; i < n; i++)
	{
		cin >> v[i];
		d+= v[i];
	}
	for (int i = 0; i < n; i++)
		if (v[i] != d/n)
			a.push_back(make_pair<int,int>(v[i]-d/n,i+1));
	if ( a.size() == 0)
	{
		cout << "Exemplary pages." << endl;
		return 0;
	}

	if ( a.size() != 2)
		cout << "Unrecoverable configuration." << endl;
	else
	{
		if ( a[0].first+a[1].first == 0)
		{
			if (a[0].first < 0)
				cout << a[1].first <<" ml. from cup #" <<a[0].second<<" to cup #" <<a[1].second<< '.' << endl;
			else
				cout << a[0].first <<" ml. from cup #" <<a[1].second<<" to cup #" <<a[0].second <<'.' << endl;
		}
		else
			cout << "Unrecoverable configuration." << endl;
	}

#ifdef LocalHost
        cout<<endl<<endl<<"TIME: "<<clock()<<endl;
#endif

}


#include <cstdio>
#include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <sstream>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <cctype>
#include <limits>
#include<ctime>

using namespace std;

const double EPS = 1e-9;
const long long  INF = 1000000000000000000;

typedef pair<int, int> PII;
typedef pair<double,double> PDD;
typedef vector<long long> VLL;
typedef vector<int> VI;

#define FOR(i,a,b) for (int _n(b), i(a); i < _n; i++)
#define FORD(i,a,b) for(int i=(a),_b=(b);i>=_b;--i)
#define REP(i,n) FOR(i,0,n)

#define UNIQUE(v) SORT(v), v.erase(unique(v.begin(),v.end()),v.end())
#define SORT(c) sort((c).begin(),(c).end())
#define ll long long

int main()
{
#ifdef LocalHost
        freopen("input.txt","r",stdin);
     // freopen("output.txt","w",stdout);
#endif
	int n;
	cin >> n;
	int d = 0;
	vector<int> v(n);
	vector<PII> a;
	for (int i = 0; i < n; i++)
	{
		cin >> v[i];
		d+= v[i];
	}
	for (int i = 0; i < n; i++)
		if (v[i] != d/n)
			a.push_back(make_pair<int,int>(v[i]-d/n,i+1));
	if ( a.size() == 0)
	{
		cout << "Exemplary pages." << endl;
		return 0;
	}

	if ( a.size() != 2)
		cout << "Unrecoverable configuration." << endl;
	else
	{
		if ( a[0].first+a[1].first == 0)
		{
			if (a[0].first < 0)
				cout << a[1].first <<"ml. from cup #" <<a[0].second<<" to cup #" <<a[1].second<< '.' << endl;
			else
				cout << a[0].first <<"ml. from cup #" <<a[1].second<<" to cup #" <<a[0].second <<'.' << endl;
		}
		else
			cout << "Unrecoverable configuration." << endl;
	}

#ifdef LocalHost
        cout<<endl<<endl<<"TIME: "<<clock()<<endl;
#endif

}


#include <functional>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <bitset>
#include <string>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <set>
#include <map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

const int INF=1000*1000*1000;

int main()
{
	#ifndef ONLINE_JUDGE
		freopen ("input.txt","r",stdin);
		freopen ("output.txt","w",stdout);
	#endif
	int n;
	scanf("%d",&n);
	map<int,int> m;
	for (int i=0;i<n;++i)
	{
		int cur;
		scanf("%d",&cur);
		m.insert(make_pair(cur,i+1));
	}
	if (m.size()==1)
		printf("Exemplary pages.");
	else
		if (m.size()>3 || ((m.rbegin()->first-m.begin()->first) & 1))
			printf("Unrecoverable configuration.");
		else
			printf("%d ml. from cup #%d to cup #%d.",(m.rbegin()->first-m.begin()->first)>>1,m.begin()->second,m.rbegin()->second);
	return 0;
}


#include <functional>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <bitset>
#include <string>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <set>
#include <map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

const int INF=1000*1000*1000;

int main()
{
	#ifndef ONLINE_JUDGE
		freopen ("input.txt","r",stdin);
		freopen ("output.txt","w",stdout);
	#endif
	int n;
	scanf("%d",&n);
	map<int,int> m;
	for (int i=0;i<n;++i)
	{
		int cur;
		scanf("%d",&cur);
		m.insert(make_pair(cur,i+1));
	}
	if (m.size()==1)
		printf("Exemplary pages.");
	else
		if (m.size()==2 || m.size()>3 || ((m.rbegin()->first-m.begin()->first) & 1))
			printf("Unrecoverable configuration.");
		else
			printf("%d ml. from cup #%d to cup #%d.",(m.rbegin()->first-m.begin()->first)>>1,m.begin()->second,m.rbegin()->second);
	return 0;
}


#include <functional>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <bitset>
#include <string>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <set>
#include <map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

const int INF=1000*1000*1000;

int a[1000+1];

int main()
{
	#ifndef ONLINE_JUDGE
		freopen ("input.txt","r",stdin);
		freopen ("output.txt","w",stdout);
	#endif
	int n;
	scanf("%d",&n);
	int mn=INF,mnind,mx=-INF,mxind;
	for (int i=0;i<n;++i)
	{
		scanf("%d",&a[i]);
		if (a[i]<mn)
		{
			mn=a[i];
			mnind=i+1;
		}
		if (a[i]>mx)
		{
			mx=a[i];
			mxind=i+1;
		}
	}
	sort(a,a+n);
	if (a[0]==a[n-1])
		printf("Exemplary pages.");
	else
		if ((a[n-1]-a[0]) & 1)
			printf("Unrecoverable configuration.");
		else
		{
			int cur=(a[n-1]-a[0])>>1;
			a[0]+=cur;
			a[n-1]-=cur;
			sort(a,a+n);
			for (int i=1;i<n;++i)
				if (a[i]!=a[i-1])
				{
					printf("Unrecoverable configuration.");
					return 0;
				}
			printf("%d ml. from cup #%d to cup #%d.",cur,mnind,mxind);
		}
	return 0;
}


#include <iostream>
using namespace std;
int main(){
  int q,w,e,r,t=0,c=0,a[1000];
  cin>>q;
  for(w=0;w<q;w++){
   cin>>a[w];
   t+=a[w];}
  if(t%q)
   cout<<"Unrecoverable configuration.";
  else{
   t/=q;
   e=r=0;
   for(w=0;w<q;w++)
    if(a[w]!=t){
     c++;
     if(a[e]>a[w])
      e=w;
     if(a[r]<a[w])
      r=w;}
   if(c==0)
    cout<<"Exemplary pages.";
   else
    if((c==2)&&(t-a[e]==a[r]-t))
     cout<<t-a[e]<<" ml. from cup #"<<e+1<<" to cup #"<<r+1<<".";
    else
     cout<<"Unrecoverable configuration.";}
  return 0;}


//#pragma warning(disable:4786)
#include<iostream>
#include<algorithm>
#include<cmath>
#include<stdio.h>
#include<queue>
#include<map>
#include<vector>
#include<string>
#include<string.h>
using namespace std;

#define pi acos(-1.0)
#define inf 0x7fffffff
#define eps 1e-8
const int maxn=0;

int main()
{
    int n,i,a[1001],min,max,mm,ma;
    while(scanf("%d",&n)!=-1)
    {
        int sum=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        if(n==2)
        {
            if(a[1]==a[2]){cout<<"Exemplary pages."<<endl;continue;}
            if((a[2]+a[0])%2==1){cout<<"Unrecoverable configuration."<<endl;continue;}
            if(a[1]<a[2])
            {
                printf("%d ml. from cup #1 to cup #2.\n",(a[2]-a[1])/2);
            }
            else printf("%d ml. from cup #2 to cup #1.\n",(a[2]-a[1])/2);
            continue;
        }
        double p=double (sum)/n;
        int count=0;
        for(i=1;i<=n;i++)
        {
            if(a[i]==p)
                count++;
            if(a[i]>p)
            {
                max=a[i];
                ma=i;
            }
            if(a[i]<p)
            {
                min=a[i];
                mm=i;
            }
        }
        if(count==n-2)
        {
            printf("%d ml. from cup #%d to cup #%d.\n",int(max-p),mm,ma);
        }
        else
        {
            if(count==n)
                printf("Exemplary pages.\n");
            else
                printf("Unrecoverable configuration.\n");
        }
    }
    return 0;
}


//#pragma warning(disable:4786)
#include<iostream>
#include<algorithm>
#include<cmath>
#include<stdio.h>
#include<queue>
#include<map>
#include<vector>
#include<string>
#include<string.h>
using namespace std;

#define pi acos(-1.0)
#define inf 0x7fffffff
#define eps 1e-8
const int maxn=0;

int main()
{
    int n,i,a[1001],min,max,mm,ma;
    while(scanf("%d",&n)!=-1)
    {
        int sum=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        if(n==2)
        {
            if(a[1]==a[2]){cout<<"Exemplary pages."<<endl;continue;}
            if((a[2]+a[0])%2==1||(a[0]+a[1])%2){cout<<"Unrecoverable configuration."<<endl;continue;}
            if(a[1]<a[2])
            {
                printf("%d ml. from cup #1 to cup #2.\n",(a[2]-a[1])/2);
            }
            else printf("%d ml. from cup #2 to cup #1.\n",(a[1]-a[2])/2);
            continue;
        }
        double p=double (sum)/n;
        int count=0;
        for(i=1;i<=n;i++)
        {
            if(a[i]==p)
                count++;
            if(a[i]>p)
            {
                max=a[i];
                ma=i;
            }
            if(a[i]<p)
            {
                min=a[i];
                mm=i;
            }
        }
        if(count==n-2)
        {
            printf("%d ml. from cup #%d to cup #%d.\n",int(max-p),mm,ma);
        }
        else
        {
            if(count==n)
                printf("Exemplary pages.\n");
            else
                printf("Unrecoverable configuration.\n");
        }
    }
    return 0;
}


#include<iostream>
#include<algorithm>
#include<cmath>
#include<stdio.h>
#include<queue>
#include<map>
#include<vector>
#include<string>
#include<string.h>
using namespace std;

#define pi acos(-1.0)
#define inf 0x7fffffff
#define eps 1e-8
const int maxn=0;

int main()
{
    int n,i,a[1001],min,max,mm,ma;
    while(scanf("%d",&n)!=-1)
    {
        int sum=0;
        for(i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        if(n==2)
        {
            if(a[1]==a[2]){cout<<"Exemplary pages."<<endl;continue;}
            if((a[2]+a[0])%2==1||(a[0]+a[1])%2){cout<<"Unrecoverable configuration."<<endl;continue;}
            if(a[1]<a[2])
            {
                printf("%d ml. from cup #1 to cup #2.\n",(a[2]-a[1])/2);
            }
            else printf("%d ml. from cup #2 to cup #1.\n",(a[2]-a[1])/2);
            continue;
        }
        double p=double (sum)/n;
        int count=0;
        for(i=1;i<=n;i++)
        {
            if(a[i]==p)
                count++;
            if(a[i]>p)
            {
                max=a[i];
                ma=i;
            }
            if(a[i]<p)
            {
                min=a[i];
                mm=i;
            }
        }
        if(count==n-2)
        {
            printf("%d ml. from cup #%d to cup #%d.\n",int(max-p),mm,ma);
        }
        else
        {
            if(count==n)
                printf("Exemplary pages.\n");
            else
                printf("Unrecoverable configuration.\n");
        }
    }
    return 0;
}


n=int(input())
arr=[]
for i in range(n):
	arr.append(int(input()))
s=sum(arr)
if s%n:
	print("Unrecoverable configuration.")
	exit()
avg=s//n
if len(set(arr))==1:
	print("Exemplary pages.")
	exit()
idx=[i+1 for i in range(n)]
idx.sort(key=lambda i:arr[i-1])
arr.sort()
if len(arr)==2:
	print(arr[-1]-avg,"ml. from cup #"+str(idx[0])+" to cup #"+str(idx[-1])+'.')
	exit()
if arr[0]+arr[-1]==2*avg and arr[1]==arr[-2]:
	print(arr[-1]-avg,"ml. from cup #"+str(idx[0])+" to cup #"+str(idx[-1])+'.')
else:
	print("Unrecoverable configuration.")


n=int(input())
arr=[]
for i in range(n):
	arr.append(int(input()))
s=sum(arr)
if s%n:
	print("Unrecoverable configuration.")
	exit()
avg=s//n
if len(set(arr))==1:
	print("Exemplary pages.")
	exit()
idx=[i+1 for i in range(n)]
idx.sort(key=lambda i:arr[i-1])
arr.sort()
if arr[0]+arr[-1]==2*avg:
	print(arr[-1]-avg,"ml. from cup #"+str(idx[0])+" to cup #"+str(idx[-1])+'.')
else:
	print("Unrecoverable configuration.")


n=int(input())
arr=[]
for i in range(n):
	arr.append(int(input()))
s=sum(arr)
if s%n:
	print("Unrecoverable configuration.")
	exit()
avg=s//n
if len(set(arr))==1:
	print("Exemplary pages.")
	exit()
idx=[i+1 for i in range(n)]
idx.sort(key=lambda i:arr[i-1])
arr.sort()
if arr[0]+arr[-1]==2*avg and arr[1]==arr[-2]:
	print(arr[-1]-avg,"ml. from cup #"+str(idx[0])+" to cup #"+str(idx[-1])+'.')
else:
	print("Unrecoverable configuration.")


n=int(input())
arr=[]
for i in range(n):
	arr.append(int(input()))
s=sum(arr)
if s%n:
	print("Unrecoverable configuration.")
	exit()
avg=s//n
if len(set(arr))==1:
	print("Exemplary pages.")
	exit()
idx=[i+1 for i in range(n)]
idx.sort(key=lambda i:arr[i-1])
arr.sort()
if arr[0]+arr[-1]==2*avg:
	print(arr[-1]-avg,"ml. from cup #"+str(idx[0])+" to cup #"+str(idx[-1]))
else:
	print("Unrecoverable configuration.")


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
# v = l.copy()

sum = 0
for i in range(n):
    sum+=l[i]

avg = sum/n
if int(avg) == avg:
    avg = int(avg)
    ba = set()
    for i in range(n):
      if abs(avg - l[i])!=0:
        ba.add(abs(avg - l[i]))
        x = avg - l[i]
        if x>0:
          a = i+1
        else:
          b = i+1

    if len(ba) == 1:
        print(str(abs(x))+ "ml. from cup #"+ str(a) +" to cup #"+str(b)+".")
    elif len(ba) == 0:
        print('Exemplary pages.')
    else:
        print("Unrecoverable configuration.")
else:
    print('Unrecoverable configuration.')


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
v = l.copy()
l.sort()
if len(set(l)) == 1:
    print('Exemplary pages.')

elif len(set(l)) >3:
    print('Unrecoverable configuration.')
elif len(set(l)) ==3:
   k =  sorted(list((set(l))))[-1] - sorted(list((set(l))))[1]
   x,y = sorted(list((set(l))))[-1],sorted(list((set(l))))[0]
   for i in range(n):
       if v[i] == y:
           a = i+1
       if v[i] == x:
           b = i+1

   ans = str(k)+' ml.' + ' from ' + 'cup #' + str(a) + ' to ' + 'cup #' + str(b)
   print(ans+'.')
elif len(set(l)) ==2:

    x,y = sorted(list((set(l))))[0],sorted(list((set(l))))[1]
    z = (x+y)/2
    if int(z) == z:
        k = abs(int(z)-x)
        ans = str(k)+' ml.' + ' from ' + 'cup #' + str(min(x,y)) + ' to ' + 'cup #' + str(max(x,y))
        print(ans+'.')
    else:
        print('Unrecoverable configuration.')


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
v = l.copy()
l.sort()
if len(set(l)) == 1:
    print('Exemplary pages.')

elif len(set(l)) >3:
    print('Unrecoverable configuration.')
else:
   k =  sorted(list((set(l))))[-1] - sorted(list((set(l))))[1]
   x,y = sorted(list((set(l))))[-1],sorted(list((set(l))))[0]
   for i in range(n):
       if v[i] == y:
           a = i+1
       if v[i] == x:
           b = i+1

   ans = str(k)+' ml.' + ' from ' + 'cup #' + str(a) + ' to ' + 'cup #' + str(b)
   print(ans+'.')


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
v = l.copy()
l.sort()
if len(set(l)) == 1:
    print('Exemplary pages.')

elif len(set(l)) >3:
    print('Unrecoverable configuration.')
elif len(set(l)) ==3:
   k =  sorted(list((set(l))))[-1] - sorted(list((set(l))))[1]
   x,y = sorted(list((set(l))))[-1],sorted(list((set(l))))[0]
   for i in range(n):
       if v[i] == y:
           a = i+1
       if v[i] == x:
           b = i+1

   ans = str(k)+' ml.' + ' from ' + 'cup #' + str(a) + ' to ' + 'cup #' + str(b)
   print(ans+'.')
elif len(set(l)) ==2:

    x,y = sorted(list((set(l))))[0],sorted(list((set(l))))[1]
    z = (x+y)/2
    if int(z) == z:
        k = abs(int(z)-x)
        for i in range(n):
          if v[i] == y:
            a = i+1
          if v[i] == x:
            b = i+1
        ans = str(k)+' ml.' + ' from ' + 'cup #' + str(b) + ' to ' + 'cup #' + str(a)
        print(ans+'.')
    else:
        print('Unrecoverable configuration.')


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
# v = l.copy()

sum = 0
for i in range(n):
    sum+=l[i]

avg = sum/n
if int(avg) == avg:
    avg = int(avg)
    ba = set()
    count = 0
    for i in range(n):
      if abs(avg - l[i])!=0:
        ba.add(abs(avg - l[i]))
        x = avg - l[i]
        if x>0:
          a = i+1
        else:
          b = i+1
        count+=1

    if len(ba) == 1 and count == 2:
        print(str(abs(x))+ " ml. from cup #"+ str(a) +" to cup #"+str(b)+".")
    elif len(ba) == 0:
        print('Exemplary pages.')
    else:
        print("Unrecoverable configuration.")
else:
    print('Unrecoverable configuration.')


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
v = l.copy()
l.sort()
if len(set(l)) == 1:
    print('Exemplary pages.')

elif len(set(l)) >3:
    print('Unrecoverable configuration.')
else:
   k =  sorted(list((set(l))))[-1] - sorted(list((set(l))))[0]
   x,y = sorted(list((set(l))))[-1],sorted(list((set(l))))[0]
   for i in range(n):
       if v[i] == y:
           a = i+1
       if v[i] == x:
           b = i+1

   ans = str(k)+' ml.' + ' from ' + '#' + str(a) + ' to ' + '#' + str(b)
   print(ans)


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
v = l.copy()
l.sort()
if len(set(l)) == 1:
    print('Exemplary pages.')

elif len(set(l)) >3:
    print('Unrecoverable configuration.')
else:
   k =  sorted(list((set(l))))[-1] - sorted(list((set(l))))[1]
   x,y = sorted(list((set(l))))[-1],sorted(list((set(l))))[0]
   for i in range(n):
       if v[i] == y:
           a = i+1
       if v[i] == x:
           b = i+1

   ans = str(k)+' ml.' + ' from ' + '#' + str(a) + ' to ' + '#' + str(b)
   print(ans)


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
v = l.copy()
l.sort()
if len(set(l)) == 1:
    print('Exemplary pages.')

elif len(set(l)) >3:
    print('Unrecoverable configuration.')
elif len(set(l)) ==3:

   x,y = sorted(list((set(l))))[-1],sorted(list((set(l))))[0]
   for i in range(n):
       if v[i] == y:
           a = i+1
       if v[i] == x:
           b = i+1
   z = (x+y)/2
   k = abs(int(z)-x)
   if int(z) == z and z == sorted(list((set(l))))[1] and z!=0:

    ans = str(k)+' ml.' + ' from ' + 'cup #' + str(a) + ' to ' + 'cup #' + str(b)
    print(ans+'.')
   else:
       print('Unrecoverable configuration.')
elif len(set(l)) ==2:

    x,y = sorted(list((set(l))))[0],sorted(list((set(l))))[1]
    z = (x+y)/2
    if int(z) == z and z!=0:
        k = abs(int(z)-x)
        for i in range(n):
          if v[i] == y:
            a = i+1
          if v[i] == x:
            b = i+1
        ans = str(k)+' ml.' + ' from ' + 'cup #' + str(b) + ' to ' + 'cup #' + str(a)
        print(ans+'.')
    else:
        print('Unrecoverable configuration.')


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
# v = l.copy()

sum = 0
for i in range(n):
    sum+=l[i]

avg = sum/n
if int(avg) == avg:
    avg = int(avg)
    ba = set()
    for i in range(n):
      if abs(avg - l[i])!=0:
        ba.add(abs(avg - l[i]))
        x = avg - l[i]
        if x>0:
          a = i+1
        else:
          b = i+1

    if len(ba) == 1:
        print(str(abs(x))+ " ml. from cup #"+ str(a) +" to cup #"+str(b)+".")
    elif len(ba) == 0:
        print('Exemplary pages.')
    else:
        print("Unrecoverable configuration.")
else:
    print('Unrecoverable configuration.')


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
v = l.copy()
l.sort()
if len(set(l)) == 1:
    print('Exemplary pages.')

elif len(set(l)) >3:
    print('Unrecoverable configuration.')
else:
   k =  sorted(list((set(l))))[-1] - sorted(list((set(l))))[1]
   x,y = sorted(list((set(l))))[-1],sorted(list((set(l))))[0]
   for i in range(n):
       if v[i] == y:
           a = i+1
       if v[i] == x:
           b = i+1

   ans = str(k)+' ml.' + ' from ' + 'cup #' + str(a) + ' to ' + 'cup #' + str(b)
   print(ans)


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
v = l.copy()
l.sort()
if len(set(l)) == 1:
    print('Exemplary pages.')

elif len(set(l)) >3:
    print('Unrecoverable configuration.')
elif len(set(l)) ==3:
   k =  sorted(list((set(l))))[-1] - sorted(list((set(l))))[1]
   x,y = sorted(list((set(l))))[-1],sorted(list((set(l))))[0]
   for i in range(n):
       if v[i] == y:
           a = i+1
       if v[i] == x:
           b = i+1
   z = (x+y)/2
   if int(z) == z:

    ans = str(k)+' ml.' + ' from ' + 'cup #' + str(a) + ' to ' + 'cup #' + str(b)
    print(ans+'.')
   else:
       print('Unrecoverable configuration.')
elif len(set(l)) ==2:

    x,y = sorted(list((set(l))))[0],sorted(list((set(l))))[1]
    z = (x+y)/2
    if int(z) == z:
        k = abs(int(z)-x)
        for i in range(n):
          if v[i] == y:
            a = i+1
          if v[i] == x:
            b = i+1
        ans = str(k)+' ml.' + ' from ' + 'cup #' + str(b) + ' to ' + 'cup #' + str(a)
        print(ans+'.')
    else:
        print('Unrecoverable configuration.')


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
v = l.copy()
l.sort()
if len(set(l)) == 1:
    print('Exemplary pages.')

elif len(set(l)) >3:
    print('Unrecoverable configuration.')
elif len(set(l)) ==3:
   k =  sorted(list((set(l))))[-1] - sorted(list((set(l))))[1]
   x,y = sorted(list((set(l))))[-1],sorted(list((set(l))))[0]
   for i in range(n):
       if v[i] == y:
           a = i+1
       if v[i] == x:
           b = i+1
   z = (x+y)/2
   if int(z) == z and z == sorted(list((set(l))))[1]:

    ans = str(k)+' ml.' + ' from ' + 'cup #' + str(a) + ' to ' + 'cup #' + str(b)
    print(ans+'.')
   else:
       print('Unrecoverable configuration.')
elif len(set(l)) ==2:

    x,y = sorted(list((set(l))))[0],sorted(list((set(l))))[1]
    z = (x+y)/2
    if int(z) == z:
        k = abs(int(z)-x)
        for i in range(n):
          if v[i] == y:
            a = i+1
          if v[i] == x:
            b = i+1
        ans = str(k)+' ml.' + ' from ' + 'cup #' + str(b) + ' to ' + 'cup #' + str(a)
        print(ans+'.')
    else:
        print('Unrecoverable configuration.')


n = int(input())
l = []

for i in range(n):
    a = int(input())
    l.append(a)
v = l.copy()
l.sort()
if len(set(l)) == 1:
    print('Exemplary pages.')

elif len(set(l)) >3:
    print('Unrecoverable configuration.')
elif len(set(l)) ==3:
   k =  sorted(list((set(l))))[-1] - sorted(list((set(l))))[1]
   x,y = sorted(list((set(l))))[-1],sorted(list((set(l))))[0]
   for i in range(n):
       if v[i] == y:
           a = i+1
       if v[i] == x:
           b = i+1

   ans = str(k)+' ml.' + ' from ' + 'cup #' + str(a) + ' to ' + 'cup #' + str(b)
   print(ans+'.')
else:
    print('Unrecoverable configuration.')


n=int(input())
d={}
a=[]
for i in range(n):
    x=int(input())
    a.append(x)
    if x not in d:
        d[x]=1
    else:
        d[x]+=1

if len(d)>3:
    print("Unrecoverable configuration.")
elif len(d)==1:
    print("Exemplary pages.")
else:
    mini=min(d.keys())
    maxi=max(d.keys())
    x=int((maxi+mini)/2)
    rem=x-mini
    ind1=a.index(mini)
    ind2=a.index(maxi)

    if len(d)==3:
        if d[mini]==1 and d[maxi]==1 and x in d:
            print(str(rem)+" ml. from cup #"+str(ind1+1)+" to cup #"+str(ind2+1)+".")
        else:
            print("Unrecoverable configuration.")
    else:
        if n!=2:
            print("Unrecoverable configuration.")
        else:
            x=(a[0]+a[1])/2
            if x!=int(x):
                print("Unrecoverable configuration.")
            elif a[0]>a[1]:
                rem=x-a[1]
                print(str(rem)+" ml. from cup #"+str(2)+" to cup #"+str(1)+".")
            else:
                rem=x-a[0]
                print(str(rem)+" ml. from cup #"+str(1)+" to cup #"+str(2)+".")


n=int(input())
d={}
a=[]
for i in range(n):
    x=int(input())
    a.append(x)
    if x not in d:
        d[x]=1
    else:
        d[x]+=1

if len(d)>3:
    print("Unrecoverable configuration.")
elif len(d)==1:
    print("Exemplary pages.")

else:
    mini=min(d.keys())
    maxi=max(d.keys())
    x=int((maxi+mini)/2)
    rem=x-mini
    ind1=a.index(mini)
    ind2=a.index(maxi)
    if a[0]==7593:
        print(d,x)
    if len(d)==3:
        if d[mini]==1 and d[maxi]==1 and x in d:
            print(str(rem)+" ml. from cup #"+str(ind1+1)+" to cup #"+str(ind2+1)+".")
        else:
            print("Unrecoverable configuration.")

    else:
        if n!=2:
            print("Unrecoverable configuration.")
        else:
            x=(a[0]+a[1])/2
            if x!=int(x):
                print("Unrecoverable configuration.")
            elif a[0]>a[1]:
                x=int(x)
                rem=x-a[1]
                print(str(rem)+" ml. from cup #"+str(2)+" to cup #"+str(1)+".")
            else:
                x=int(x)
                rem=x-a[0]
                print(str(rem)+" ml. from cup #"+str(1)+" to cup #"+str(2)+".")


n=int(input())
d={}
a=[]
for i in range(n):
    x=int(input())
    a.append(x)
    if x not in d:
        d[x]=1
    else:
        d[x]+=1

if len(d)>3:
    print("Unrecoverable configuration.")
elif len(d)==1:
    print("Exemplary pages.")
else:
    mini=min(d.keys())
    maxi=max(d.keys())
    x=int((maxi+mini)/2)
    rem=x-mini
    ind1=a.index(mini)
    ind2=a.index(maxi)

    if len(d)==3:
        if d[mini]==1 and d[maxi]==1 and x in d:
            print(str(rem)+" ml. from cup #"+str(ind1+1)+" to cup #"+str(ind2+1)+".")
        else:
            print("Unrecoverable configuration.")
    else:
        if n!=2:
            print("Unrecoverable configuration.")
        else:
            x=int((a[0]+a[1])/2)
            if a[0]>a[1]:
                rem=x-a[1]
                print(str(rem)+" ml. from cup #"+str(2)+" to cup #"+str(1)+".")
            else:
                rem=x-a[0]
                print(str(rem)+" ml. from cup #"+str(1)+" to cup #"+str(2)+".")


n=int(input())
d={}
a=[]
for i in range(n):
    x=int(input())
    a.append(x)
    if x not in d:
        d[x]=1
    else:
        d[x]+=1

if len(d)>3:
    print("Unrecoverable configuration.")
elif len(d)==1:
    print("Exemplary pages.")

else:
    mini=min(d.keys())
    maxi=max(d.keys())
    x=(maxi+mini)/2
    if x!=int(x):
        print("Unrecoverable configuration.")
    else:
        x=int(x)
        rem=x-mini
        ind1=a.index(mini)
        ind2=a.index(maxi)
        if len(d)==3:
            if d[mini]==1 and d[maxi]==1 and x in d:
                print(str(rem)+" ml. from cup #"+str(ind1+1)+" to cup #"+str(ind2+1)+".")
            else:
                print("Unrecoverable configuration.")

        else:
            if n!=2:
                print("Unrecoverable configuration.")
            else:
                x=(a[0]+a[1])/2
                if x!=int(x):
                    print("Unrecoverable configuration.")
                elif a[0]>a[1]:
                    x=int(x)
                    rem=x-a[1]
                    print(str(rem)+" ml. from cup #"+str(2)+" to cup #"+str(1)+".")
                else:
                    x=int(x)
                    rem=x-a[0]
                    print(str(rem)+" ml. from cup #"+str(1)+" to cup #"+str(2)+".")


n=int(input())
d={}
a=[]
for i in range(n):
    x=int(input())
    a.append(x)
    if x not in d:
        d[x]=1
    else:
        d[x]+=1

if len(d)>3:
    print("Unrecoverable configuration.")
elif len(d)==1:
    print("Exemplary pages.")
else:
    mini=min(d.keys())
    maxi=max(d.keys())
    x=int((maxi+mini)/2)
    rem=x-mini
    ind1=a.index(mini)
    ind2=a.index(maxi)

    if len(d)==3:
        if d[mini]==1 and d[maxi]==1 and x in d:
            print(str(rem)+" ml. from cup #"+str(ind1+1)+" to cup #"+str(ind2+1)+".")
        else:
            print("Unrecoverable configuration.")
    else:
        if n!=2:
            print("Unrecoverable configuration.")
        else:
            x=(a[0]+a[1])/2
            if x!=int(x):
                print("Unrecoverable configuration.")
            elif a[0]>a[1]:
                x=int(x)
                rem=x-a[1]
                print(str(rem)+" ml. from cup #"+str(2)+" to cup #"+str(1)+".")
            else:
                x=int(x)
                rem=x-a[0]
                print(str(rem)+" ml. from cup #"+str(1)+" to cup #"+str(2)+".")


c = sorted((int(input()), i + 1) for i in range(int(input())))
if c[0][0] == c[-1][0]:
    print('Exemplary pages.')
elif (c[0][0] + c[-1][0]) % 2:
    print('Unrecoverable configuration.')
else:
    a = (c[0][0] + c[-1][0]) // 2
    if len(c) > 2 and (a != c[1][0] or a != c[-2][0]):
        print('Unrecoverable configuration.')
    else:
        print(a - c[0][0], ' ml. from cup #', c[0][1], ' to cup #', c[-1][1], sep='')


c = sorted((int(input()), i + 1) for i in range(int(input())))
if c[0][0] == c[-1][0]:
    print('Exemplary pages.')
elif (c[0][0] + c[-1][0]) % 2:
    print('Unrecoverable configuration.')
else:
    a = (c[0][0] + c[-1][0]) // 2
    if len(c) > 2 and (a != c[1][0] or a != c[-2][0]):
        print('Unrecoverable configuration.')
    else:
        print(a - c[0][0], ' ml. from cup #', c[0][1], ' to cup #', c[-1][1], '.', sep='')


n=int(input())
c=[]
for i in range(n):
    c.append(int(input()))
if len(set(c))>3 or (len(set(c))==2 and n!=2):
    print("Unrecoverable configuration.")
elif len(set(c))==1:
    print("Exemplary pages.")
else:
    i=c.index(max(c))
    j=c.index(min(c))
    if c.count(l[j])==1:
        m=(c[i]-c[j])//2
        if (c[i]-c[j])%2==1:
            print("Unrecoverable configuration.")
        else:
            print(str(m)+" ml. from cup #"+str(j+1)+" to cup #"+str(i+1)+".")
    else:
        print("Unrecoverable configuration.")


n=int(input())
c=[]
for i in range(n):
    c.append(int(input()))
if len(set(c))>3 or len(set(c))==2:
    print("Unrecoverable configuration.")
elif len(set(c))==1:
    print("Exemplary pages.")
else:
    i=c.index(max(c))
    j=c.index(min(c))
    m=(c[i]-c[j])//2
    print(str(m)+" ml. from cup #"+str(j+1)+" to cup #"+str(i+1)+".")


n=int(input())
c=[]
for i in range(n):
    c.append(int(input()))
if len(set(c))>3 or (len(set(c))==2 and n!=2):
    print("Unrecoverable configuration.")
elif len(set(c))==1:
    print("Exemplary pages.")
else:
    i=c.index(max(c))
    j=c.index(min(c))
    m=(c[i]-c[j])//2
    if (c[i]-c[j])%2==1:
        print("Unrecoverable configuration.")
    else:
        print(str(m)+" ml. from cup #"+str(j+1)+" to cup #"+str(i+1)+".")


n=int(input())
c=[]
for i in range(n):
    c.append(int(input()))
if len(set(c))>3 or (len(set(c))==2 and n!=2):
    print("Unrecoverable configuration.")
elif len(set(c))==1:
    print("Exemplary pages.")
else:
    i=c.index(max(c))
    j=c.index(min(c))
    if c.count(c[j])==1:
        m=(c[i]-c[j])//2
        if (c[i]-c[j])%2==1:
            print("Unrecoverable configuration.")
        else:
            print(str(m)+" ml. from cup #"+str(j+1)+" to cup #"+str(i+1)+".")
    else:
        print("Unrecoverable configuration.")


n=int(input())
c=[]
for i in range(n):
    c.append(int(input()))
if len(set(c))>3 or (len(set(c))==2 and n!=2):
    print("Unrecoverable configuration.")
elif len(set(c))==1:
    print("Exemplary pages.")
else:
    i=c.index(max(c))
    j=c.index(min(c))
    m=(c[i]-c[j])//2
    print(str(m)+" ml. from cup #"+str(j+1)+" to cup #"+str(i+1)+".")


while True:
	try:
		def soln(n, a, s):
			a.sort()
			#print(a)
			if a[-1][0] == a[0][0]:
				print("Exemplary pages.")
			elif s%n == 0:
				mn, cng, cun  = a[0][0], 0, 0
				for i in range(1, n-1, 1):
					if a[i][0] != a[i-1][0] :
						cng += 1
					if mn == a[i][0]:
						cun += 1
				#print(mn, cng)
				if cun == 0 and cng <= 1 :
					 print(a[-1][0]-(s//n),"ml.", "from cup","#"+str(a[0][1]),"to cup","#"+str(a[-1][1])+".")
				else:print("Unrecoverable configuration.")
			else:print("Unrecoverable configuration.")

		def read():
			n = int(input())
			a = list()
			sum = 0
			for i in range(n):
				a.append([int(input()),i+1])
				sum += a[i][0]
			#print(a)
			soln(n, a, sum)
		if __name__ == "__main__":
			read()

			"""def soln(n, a, s):
			a.sort()
			if a[-1][0] == a[0][0]:print("Exemplary pages.")
			elif s%n == 0 and a[-1][0]-(s//n) ==a[-1][0]-(s/n) :
				print(a[-1][0]-(s//n),"ml.", "from cup","#"+str(a[0][1]),"to cup","#"+str(a[-1][1])+".")
			else:print("Unrecoverable configuration.")
			"""

	except EOFError:
		break


n=int(input())
a=[]
for i in range(1,n+1): a.append(int(input()))
mina,maxa=min(a),max(a)
minai,maxai=a.index(mina),a.index(maxa)
if (maxa-mina)%2!=0:
    print("Unrecoverable configuration.")
elif mina==maxa:
    print("Exemplary pages.")
else:
    mid=(maxa-mina)//2
    a[maxai]-=mid
    a[minai]+=mid
    if len(set(a))==1:
        print(str(mid)+' ml. from cup #'+str(minai+1)+' to cup #'+str(maxai+1)+'.')
    else:
        print("Unrecoverable configuration.")


n=int(input())
a=[]
for i in range(1,n+1): a.append([int(input()),i])
a.sort()
if n==1 or a[0][0]==a[1][0]:
    print("Exemplary pages.")
elif n==2:
    if (a[1][0]-a[0][0]) %2==0:
        print (str((a[1][0]-a[0][0])//2)+" ml. from cup #"+str(a[0][1])+" to cup #"+str(a[1][1])+".")
    else:
        print("Unrecoverable configuration.")
elif a[1][0]-a[0][0]!=a[-1][0]-a[1][0]:
    print("Unrecoverable configuration.")
else:
    print (str(a[1][0]-a[0][0])+" ml. from cup #"+str(a[0][1])+" to cup #"+str(a[-1][1])+".")


n = int(input())
l = []
k = 0
for i in range(n):
	t = int(input())
	l.append([t,i])
	k+=t
l.sort()
if k/n != int(k/n) :
	print('Unrecoverable configuration.')
else:
	t = k/n-l[0][0]
	if t == 0:
		print('Exemplary pages.')
	else:
		l[0][0] = k/n
		l[-1][0]-=t
		f = True
		k = l[0][0]
		for i in range(1,n):
			if l[i][0] != k :
				f = False
				break
		if f == False:
			print(('Unrecoverable configuration.'))
		else:
			print(int(t),'ml.','from cup #'+str(l[0][1]+1),'to cup #'+str(l[-1][1]+1)+'.')


n = int(input())
l = []
k = 0
for i in range(n):
	t = int(input())
	l.append([t,i])
	k+=t
l.sort()
if k/n != int(k/n) :
	print('Unrecoverable configuration.')
else:
	t = k/n-l[0][0]
	if t == 0:
		print('Exemplary pages.')
	else:
		l[0][0] = k/n
		l[-1][0]-=t
		f = True
		k = l[0][0]
		for i in range(1,n):
			if l[i][0] != k :
				f = False
				break
		if f == False:
			print(('Unrecoverable configuration.'))
		else:
			print(int(t),'ml.','from cup #'+str(l[0][1]+1),'to cup #'+str(l[-1][1]+1))


# from dust i have come dust i will be

n=int(input())
a=[0]*n

for i in range(n):
    a[i]=int(input())

avg=sum(a)

if avg%n!=0:
    print('Unrecoverable configuration.')

avg=avg//n

x=[]
for i in range(n):
    if a[i]!=avg:
        x.append(i)

if len(x)==0:
    print('Exemplary pages.')

elif len(x)==2:
    if (a[x[0]]+a[x[1]])//2==avg:
        d=abs(a[x[0]]-a[x[1]])//2

        if a[x[0]]>a[x[1]]:
            print(str(d)+' ml. from cup #'+str(x[1]+1)+' to cup #'+str(x[0]+1)+'.')

        else:
            print(str(d)+' ml. from cup #'+str(x[0]+1)+' to cup #'+str(x[1]+1)+'.')
    else:
        print('Unrecoverable configuration.')

else:
    print('Unrecoverable configuration.')


# from dust i have come dust i will be

n=int(input())
a=[0]*n

for i in range(n):
    a[i]=int(input())

avg=sum(a)//n

x=[]
for i in range(n):
    if a[i]!=avg:
        x.append(i)

if len(x)==0:
    print('Exemplary pages.')

elif len(x)==2:
    if (a[x[0]]+a[x[1]])//2==avg:
        d=abs(a[x[0]]-a[x[1]])//2

        if a[x[0]]>a[x[1]]:
            print(str(d)+' ml. from cup #'+str(x[1]+1)+' to cup #'+str(x[0]+1)+'.')

        else:
            print(str(d)+' ml. from cup #'+str(x[0]+1)+' to cup #'+str(x[1]+1)+'.')
    else:
        print('Unrecoverable configuration.')

else:
    print('Unrecoverable configuration.')


# from dust i have come dust i will be

n=int(input())
a=[0]*n

for i in range(n):
    a[i]=int(input())

avg=sum(a)

if avg%n!=0:
    print('Unrecoverable configuration.')
    exit(0)

avg=avg//n

x=[]
for i in range(n):
    if a[i]!=avg:
        x.append(i)

if len(x)==0:
    print('Exemplary pages.')

elif len(x)==2:
    if (a[x[0]]+a[x[1]])//2==avg:
        d=abs(a[x[0]]-a[x[1]])//2

        if a[x[0]]>a[x[1]]:
            print(str(d)+' ml. from cup #'+str(x[1]+1)+' to cup #'+str(x[0]+1)+'.')

        else:
            print(str(d)+' ml. from cup #'+str(x[0]+1)+' to cup #'+str(x[1]+1)+'.')
    else:
        print('Unrecoverable configuration.')

else:
    print('Unrecoverable configuration.')


n = int(input())
a = [int(input()) for _ in range(n)]
s = sorted(a)
d = {a[q]: q+1 for q in range(n)}
if s[0] == s[-1]:
    print('Exemplary pages.')
elif len(set(s)) > 3 or len(set(s)) == 1:
    print('Unrecoverable configuration.')
elif len(a) == 2:
    if a[0] > a[1] and (a[0]-a[1]) % 2 == 0:
        print(f'{(a[0]-a[1]) // 2} ml. from cup #2 to cup #1.')
    elif a[0] < a[1] and (a[1]-a[0]) % 2 == 0:
        print(f'{(a[1] - a[0]) // 2} ml. from cup #1 to cup #2.')
    else:
        print('Unrecoverable configuration.')
elif len(a) == 3:
    if s[2]-s[1] == s[1]-s[0]:
        print(f'{s[1] - s[0]} ml. from cup #{d[s[0]]} to cup #{d[s[2]]}.')
    else:
        print('Unrecoverable configuration.')
else:
    s = sorted(list(set(s)))
    x, y, z = a.count(s[0]), a.count(s[1]), a.count(s[2])
    if x == 1 and z == 1 and s[2]-s[1] == s[1]-s[0]:
        print(f'{s[1] - s[0]} ml. from cup #{d[s[0]]} to cup #{d[s[2]]}.')
    else:
        print('Unrecoverable configuration.')


n = int(input())
a = [int(input()) for _ in range(n)]
s = sorted(a)
d = {a[q]: q+1 for q in range(n)}
if s[0] == s[-1]:
    print('Exemplary pages.')
elif len(a) == 2:
    if a[0] > a[1] and (a[0]-a[1]) % 2 == 0:
        print(f'{(a[0]-a[1]) // 2} ml. from cup #2 to cup #1.')
    elif a[0] < a[1] and (a[1]-a[0]) % 2 == 0:
        print(f'{(a[1] - a[0]) // 2} ml. from cup #1 to cup #2.')
    else:
        print('Unrecoverable configuration.')
elif len(a) == 3:
    if s[2]-s[1] == s[1]-s[0]:
        print(f'{s[1] - s[0]} ml. from cup #{d[s[0]]} to cup #{d[s[2]]}.')
    else:
        print('Unrecoverable configuration.')
elif len(set(s)) > 3 or len(set(s)) == 2:
    print('Unrecoverable configuration.')
else:
    s = sorted(list(set(s)))
    x, y, z = a.count(s[0]), a.count(s[1]), a.count(s[2])
    if x == 1 and z == 1 and s[2]-s[1] == s[1]-s[0]:
        print(f'{s[1] - s[0]} ml. from cup #{d[s[0]]} to cup #{d[s[2]]}.')
    else:
        print('Unrecoverable configuration.')


n = int(input())
a = [int(input()) for _ in range(n)]
s = sorted(a)
d = {a[q]: q+1 for q in range(n)}
if s[0] == s[-1]:
    print('Exemplary pages.')
elif len(set(s)) > 3 or len(set(s)) == 1:
    print('Unrecoverable configuration.')
elif len(a) == 2:
    if a[0] > a[1] and (a[0]-a[1]) % 2 == 0:
        print(f'{(a[1]-a[0]) // 2} ml. from cup #2 to cup #1.')
    elif a[0] < a[1] and (a[1]-a[0]) % 2 == 0:
        print(f'{(a[0] - a[1]) // 2} ml. from cup #1 to cup #2.')
    else:
        print('Unrecoverable configuration.')
elif len(a) == 3:
    if s[2]-s[1] == s[1]-s[0]:
        print(f'{s[1] - s[0]} ml. from cup #{d[s[0]]} to cup #{d[s[2]]}.')
    else:
        print('Unrecoverable configuration.')
else:
    s = sorted(list(set(s)))
    x, y, z = a.count(s[0]), a.count(s[1]), a.count(s[2])
    if x == 1 and z == 1 and s[2]-s[1] == s[1]-s[0]:
        print(f'{s[1] - s[0]} ml. from cup #{d[s[0]]} to cup #{d[s[2]]}.')
    else:
        print('Unrecoverable configuration.')


n = int(input())
a = [int(input()) for _ in range(n)]
s = sorted(a)
d = {a[q]: q+1 for q in range(n)}
if s[0] == s[-1]:
    print('Exemplary pages.')
elif len(set(s)) > 3 or len(set(s)) == 2:
    print('Unrecoverable configuration.')
elif len(a) == 2:
    if a[0] > a[1] and (a[0]-a[1]) % 2 == 0:
        print(f'{(a[0]-a[1]) // 2} ml. from cup #2 to cup #1.')
    elif a[0] < a[1] and (a[1]-a[0]) % 2 == 0:
        print(f'{(a[1] - a[0]) // 2} ml. from cup #1 to cup #2.')
    else:
        print('Unrecoverable configuration.')
elif len(a) == 3:
    if s[2]-s[1] == s[1]-s[0]:
        print(f'{s[1] - s[0]} ml. from cup #{d[s[0]]} to cup #{d[s[2]]}.')
    else:
        print('Unrecoverable configuration.')
else:
    s = sorted(list(set(s)))
    x, y, z = a.count(s[0]), a.count(s[1]), a.count(s[2])
    if x == 1 and z == 1 and s[2]-s[1] == s[1]-s[0]:
        print(f'{s[1] - s[0]} ml. from cup #{d[s[0]]} to cup #{d[s[2]]}.')
    else:
        print('Unrecoverable configuration.')


n=int(input())
ar=[int(input()) for i in range(n)]
if(len(set(ar))==1):
    print("Exemplary pages.")
    quit()
mn=min(ar)
mx=max(ar)
mni=ar.index(mn)
mxi=ar.index(mx)
vl=(mx-mn)//2
ar[mni]+=vl
ar[mxi]-=vl
if(len(set(ar))==1):
    print(str(vl)+" ml. from cup #"+str(mni+1)+" to cup #"+str(mxi+1)+".")
    quit()
else:
    print("Unrecoverable configuration.")
    quit()