import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        DMagicGems solver = new DMagicGems();
        solver.solve(1, in, out);
        out.close();
    }

    static class DMagicGems {
        private int MOD = (int) 1e9 + 7;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();
            int m = in.nextInt();

            long[][] M = new long[m][m];
            M[0][0] = 1;
            M[0][m - 1] = 1;
            for (int i = 1; i < m; i++) {
                M[i][i - 1] = 1;
            }
            Matrix MM = new Matrix(M);
            Matrix.MM.mod = MOD;
            MM = MM.fastPower(n - m + 1);
            long x_n = MM.data[0][0] + MM.data[0][1] % MOD;
            out.println(x_n);
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

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

    }

    static class Matrix {
        public static long mod = Long.MAX_VALUE;
        public final long[][] data;
        public final int rowCount;
        public final int columnCount;

        public Matrix(int rowCount, int columnCount) {
            this.rowCount = rowCount;
            this.columnCount = columnCount;
            this.data = new long[rowCount][columnCount];
        }

        public Matrix(long[][] data) {
            this.rowCount = data.length;
            this.columnCount = data[0].length;
            this.data = data;
        }

        public static Matrix multiply(Matrix first, Matrix second) {
            Matrix result = new Matrix(first.rowCount, second.columnCount);
            for (int i = 0; i < first.rowCount; i++) {
                for (int j = 0; j < second.rowCount; j++) {
                    for (int k = 0; k < second.columnCount; k++) {
                        result.data[i][k] = (result.data[i][k] + first.data[i][j] * second.data[j][k]) % mod;
                    }
                }
            }
            return result;
        }

        public static Matrix fastMultiply(Matrix first, Matrix second) {
            Matrix result = new Matrix(first.rowCount, second.columnCount);
            for (int i = 0; i < first.rowCount; i++) {
                for (int j = 0; j < second.rowCount; j++) {
                    for (int k = 0; k < second.columnCount; k++) {
                        result.data[i][k] += first.data[i][j] * second.data[j][k];
                    }
                }
            }
            for (int i = 0; i < first.rowCount; i++) {
                for (int j = 0; j < second.columnCount; j++) {
                    result.data[i][j] %= mod;
                }
            }
            return result;
        }

        public static Matrix identityMatrix(int size) {
            Matrix result = new Matrix(size, size);
            for (int i = 0; i < size; i++) {
                result.data[i][i] = 1;
            }
            return result;
        }

        public Matrix power(long exponent) {
            if (exponent == 0) {
                return identityMatrix(rowCount);
            }
            if (exponent == 1) {
                return this;
            }
            Matrix result = power(exponent >> 1);
            result = multiply(result, result);
            if ((exponent & 1) == 1) {
                result = multiply(result, this);
            }
            return result;
        }

        public Matrix fastPower(long exponent) {
            if (exponent == 0) {
                return identityMatrix(rowCount);
            }
            if (exponent == 1) {
                return this;
            }
            Matrix result = power(exponent >> 1);
            result = fastMultiply(result, result);
            if ((exponent & 1) == 1) {
                result = fastMultiply(result, this);
            }
            return result;
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        ACuttingBanner solver = new ACuttingBanner();
        solver.solve(1, in, out);
        out.close();
    }

    static class ACuttingBanner {
        public void solve(int testNumber, InputReader in, OutputWriter out) throws IOException {
            String S = in.nextString();
            if (S.length()=>10&&(S.substring(0, 10).equals("CODEFORCES") ||
                    (S.substring(0, 9).equals("CODEFORCE") && S.substring(S.length() - 1).equals("S")) ||
                    (S.substring(0, 8).equals("CODEFORC") && S.substring(S.length() - 2).equals("ES")) ||
                    (S.substring(0, 7).equals("CODEFOR") && S.substring(S.length() - 3).equals("CES")) ||
                    (S.substring(0, 6).equals("CODEFO") && S.substring(S.length() - 4).equals("RCES")) ||
                    (S.substring(0, 5).equals("CODEF") && S.substring(S.length() - 5).equals("ORCES")) ||
                    (S.substring(0, 4).equals("CODE") && S.substring(S.length() - 6).equals("FORCES")) ||
                    (S.substring(0, 3).equals("COD") && S.substring(S.length() - 7).equals("EFORCES")) ||
                    (S.substring(0, 2).equals("CO") && S.substring(S.length() - 8).equals("DEFORCES")) ||
                    (S.substring(0, 1).equals("C") && S.substring(S.length() - 9).equals("ODEFORCES")) ||
                    S.substring(S.length() - 10).equals("CODEFORCES")))
                out.printLine("YES");
            else
                out.printLine("NO");
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0)
                    writer.print(' ');
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class InputReader {
        private static final int DEFAULT_BUFFER_SIZE = 1 << 16;
        private static final InputStream DEFAULT_STREAM = System.in;
        private byte[] buf;
        private int bufferSize;
        private int bufIndex;
        private int numBytesRead;
        private InputStream stream;
        private static final byte EOF = -1;
        private static final byte SPACE = 32;
        private char[] charBuffer;
        private static byte[] bytes = new byte[58];
        private static int[] ints = new int[58];
        private static char[] chars = new char[128];

        static {
            char ch = ' ';
            int value = 0;
            byte _byte = 0;
            for (int i = 48; i < 58; i++) bytes[i] = _byte++;
            for (int i = 48; i < 58; i++) ints[i] = value++;
            for (int i = 32; i < 128; i++) chars[i] = ch++;
        }

        public InputReader() {
            this(DEFAULT_STREAM, DEFAULT_BUFFER_SIZE);
        }

        public InputReader(int bufferSize) {
            this(DEFAULT_STREAM, bufferSize);
        }

        public InputReader(InputStream stream) {
            this(stream, DEFAULT_BUFFER_SIZE);
        }

        public InputReader(InputStream stream, int bufferSize) {
            if (stream == null || bufferSize <= 0)
                throw new IllegalArgumentException();
            buf = new byte[bufferSize];
            charBuffer = new char[128];
            this.bufferSize = bufferSize;
            this.stream = stream;
        }

        private int readJunk(int token) throws IOException {

            if (numBytesRead == EOF) return EOF;

            // Seek to the first valid position index
            do {

                while (bufIndex < numBytesRead) {
                    if (buf[bufIndex] > token) return 0;
                    bufIndex++;
                }

                // reload buffer
                numBytesRead = stream.read(buf);
                if (numBytesRead == EOF) return EOF;
                bufIndex = 0;

            } while (true);

        }

        private void doubleCharBufferSize() {
            char[] newBuffer = new char[charBuffer.length << 1];
            for (int i = 0; i < charBuffer.length; i++) newBuffer[i] = charBuffer[i];
            charBuffer = newBuffer;
        }

        public String nextString() throws IOException {
            if (numBytesRead == EOF) return null;
            if (readJunk(SPACE) == EOF) return null;

            for (int i = 0; ; ) {
                while (bufIndex < numBytesRead) {
                    if (buf[bufIndex] > SPACE) {
                        if (i == charBuffer.length) doubleCharBufferSize();
                        charBuffer[i++] = (char) buf[bufIndex++];
                    } else {
                        bufIndex++;
                        return new String(charBuffer, 0, i);
                    }
                }

                // Reload buffer
                numBytesRead = stream.read(buf);
                if (numBytesRead == EOF) return new String(charBuffer, 0, i);
                bufIndex = 0;
            }
        }

    }
}


import java.io.IOException;
import java.util.Arrays;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Mahmoud Aladdin <aladdin3>
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskD {
    int[][] t = new int[3][3];
    long[][][] hanoi = new long[40][3][3];

    public void solve(int testNumber, InputReader jin, PrintWriter jout) {
        for(long[][] grid: hanoi)
            for(long[] row: grid)
                Arrays.fill(row, -1);

        for(int i = 0; i < 3; i++)
            for(int j = 0; j < 3; j++)
                t[i][j] = jin.int32();

        jout.println(dp(jin.int32(), 0, 2));
    }

    private long dp(int n, int i, int j) {
        if(n == 0) return 0;
        if(hanoi[n][i][j] == -1) {
            int other = 3 - i - j;
            long sol1 = dp(n - 1, i, other) + t[i][j] + dp(n - 1, other, j);
            long sol2 = dp(n - 1, i, j) + t[i][other] + dp(n - 1, j, i) + t[other][j] + dp(n - 1, i, j);
            hanoi[n][i][j] = Math.min(sol1, sol2);
        }
        return hanoi[n][i][j];
    }
}

class InputReader {
    private static final int bufferMaxLength = 1024;
    private InputStream in;
    private byte[] buffer;
    private int currentBufferSize;
    private int currentBufferTop;
    private static final String tokenizers = " \t\r\f\n";

    public InputReader(InputStream stream) {
        this.in = stream;
        buffer = new byte[bufferMaxLength];
        currentBufferSize = 0;
        currentBufferTop = 0;
    }

    private boolean refill() {
        try {
            this.currentBufferSize = this.in.read(this.buffer);
            this.currentBufferTop = 0;
        } catch(Exception e) {}
        return this.currentBufferSize > 0;
    }

    private Byte readChar() {
        if(currentBufferTop < currentBufferSize) {
            return this.buffer[this.currentBufferTop++];
        } else {
            if(!this.refill()) {
                return null;
            } else {
                return readChar();
            }
        }
    }

    public String token()  {
        StringBuffer tok = new StringBuffer();
        Byte first;
        while((first = readChar()) != null && (tokenizers.indexOf((char) first.byteValue()) != -1));
        if(first == null) return null;
        tok.append((char)first.byteValue());
        while((first = readChar()) != null && (tokenizers.indexOf((char) first.byteValue()) == -1)) {
            tok.append((char)first.byteValue());
        }
        return tok.toString();
    }

    public Integer int32() throws NumberFormatException {
        String tok = token();
        return tok == null? null : Integer.parseInt(tok);
    }

    }


import java.util.Scanner;

public class Main {

	/**
	 * @param args
	 */
	 public boolean isPrime(int num) {
		 if ( num < 2 ){
			 return false;
		 }
		 for (int i = 2; i <= Math.sqrt(num); i++) {
			 if ( num % i == 0 ) {
			 		return false;
			 }
		 }
		 return true;
	 }
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MAin m=new  Main();
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();
		long product=1;
		int count=0;
		int[] arr=new int[n+1];
		for(int r=2,k=n;;r++){
			if(r<=k){
				if(k%r==0){
					arr[r]=arr[r]+1;
					k=k/r;
					r--;
					count++;
			    }
			}
			else{
				count--;
				break;
			}
		}
		if(count>=2){
			int flag=0;
			if(arr[2]>=3){
				for(int u=3;u<=n;u++){
					if(arr[u]!=0)
						flag=1;
				}
				if(flag==0){
				int h=arr[2]/3;
				arr[2]=arr[2]-(2*h);
				arr[4]=h;
				}
			}
			if(arr[2]>3){
				int h=arr[2]/3;
				arr[2]=arr[2]-(2*h);
				arr[4]=h;
			}
		}
		int q=2;
		for(int j=n;j>=2;j--){
			while(arr[j]!=0){
					if(m.isPrime(q)){
						product=product*(long)Math.pow((long)q,(long)(j-1));
						//System.out.print("check:"+product);
						q++;
						arr[j]--;
					}
					else
						q++;
			}
		}
		System.out.println(product);

	}

}


/*
 * Hello! You are trying to hack my solution, are you? =)
 * Don't be afraid of the size, it's just a dump of useful methods like gcd, or n-th Fib number.
 * And I'm just too lazy to create a new .java for every task.
 * And if you were successful to hack my solution, please, send me this test as a message or to Abrackadabraa@gmail.com.
 * It can help me improve my skills and i'd be very grateful for that.
 * Sorry for time you spent reading this message. =)
 * Good luck, unknown rival. =)
 * */

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

public class Abra {
	// double d = 2.2250738585072012e-308;
	void solve() throws IOException {
		int n = nextInt();
		for (int i = 1; i < n; i++) {
			for (int j = 1; j < n; j++) {
				out.print(i * j + " ");
			}
			out.println();
		}
	}

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

	StreamTokenizer in;
	PrintWriter out;
	boolean oj;
	BufferedReader br;

	void init() throws IOException {
		oj = System.getProperty("ONLINE_JUDGE") != null;
		Reader reader = oj ? new InputStreamReader(System.in) : new FileReader("input.txt");
		Writer writer = oj ? new OutputStreamWriter(System.out) : new FileWriter("output.txt");
		br = new BufferedReader(reader);
		in = new StreamTokenizer(br);
		out = new PrintWriter(writer);
	}

	long beginTime;

	void run() throws IOException {
		beginTime = System.currentTimeMillis();
		long beginMem = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
		init();
		solve();
		long endMem = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
		long endTime = System.currentTimeMillis();
		if (!oj) {
			System.out.println("Memory used = " + (endMem - beginMem));
			System.out.println("Total memory = " + (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()));
			System.out.println("Running time = " + (endTime - beginTime));
		}
		out.flush();
	}

	int nextInt() throws IOException {
		in.nextToken();
		return (int) in.nval;
	}

	long nextLong() throws IOException {
		in.nextToken();
		return (long) in.nval;
	}

	String nextString() throws IOException {
		in.nextToken();
		return in.sval;
	}

	double nextDouble() throws IOException {
		in.nextToken();
		return in.nval;
	}

	myLib lib = new myLib();

	void time() {
		System.out.print("It's ");
		System.out.println(System.currentTimeMillis() - beginTime);
	}

	static class myLib {
		long fact(long x) {
			long a = 1;
			for (long i = 2; i <= x; i++) {
				a *= i;
			}
			return a;
		}

		long digitSum(String x) {
			long a = 0;
			for (int i = 0; i < x.length(); i++) {
				a += x.charAt(i) - '0';
			}
			return a;
		}

		long digitSum(long x) {
			long a = 0;
			while (x > 0) {
				a += x % 10;
				x /= 10;
			}
			return a;
		}

		long digitMul(long x) {
			long a = 1;
			while (x > 0) {
				a *= x % 10;
				x /= 10;
			}
			return a;
		}

		int digitCubesSum(int x) {
			int a = 0;
			while (x > 0) {
				a += (x % 10) * (x % 10) * (x % 10);
				x /= 10;
			}
			return a;
		}

		double pif(double ax, double ay, double bx, double by) {
			return Math.sqrt((ax - bx) * (ax - bx) + (ay - by) * (ay - by));
		}

		double pif3D(double ax, double ay, double az, double bx, double by, double bz) {
			return Math.sqrt((ax - bx) * (ax - bx) + (ay - by) * (ay - by) + (az - bz) * (az - bz));
		}

		double pif3D(double[] a, double[] b) {
			return Math.sqrt((a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]) + (a[2] - b[2]) * (a[2] - b[2]));
		}

		long gcd(long a, long b) {
			if (a == 0 || b == 0) return 1;
			if (a < b) {
				long c = b;
				b = a;
				a = c;
			}
			while (a % b != 0) {
				a = a % b;
				if (a < b) {
					long c = b;
					b = a;
					a = c;
				}
			}
			return b;
		}

		int gcd(int a, int b) {
			if (a == 0 || b == 0) return 1;
			if (a < b) {
				int c = b;
				b = a;
				a = c;
			}
			while (a % b != 0) {
				a = a % b;
				if (a < b) {
					int c = b;
					b = a;
					a = c;
				}
			}
			return b;
		}

		long lcm(long a, long b) {
			return a * b / gcd(a, b);
		}

		int lcm(int a, int b) {
			return a * b / gcd(a, b);
		}

		int countOccurences(String x, String y) {
			int a = 0, i = 0;
			while (true) {
				i = y.indexOf(x);
				if (i == -1) break;
				a++;
				y = y.substring(i + 1);
			}
			return a;
		}

		int[] findPrimes(int x) {
			boolean[] forErato = new boolean[x - 1];
			List<Integer> t = new Vector<Integer>();
			int l = 0, j = 0;
			for (int i = 2; i < x; i++) {
				if (forErato[i - 2]) continue;
				t.add(i);
				l++;
				j = i * 2;
				while (j < x) {
					forErato[j - 2] = true;
					j += i;
				}
			}
			int[] primes = new int[l];
			Iterator<Integer> iterator = t.iterator();
			for (int i = 0; iterator.hasNext(); i++) {
				primes[i] = iterator.next().intValue();
			}
			return primes;
		}

		int rev(int x) {
			int a = 0;
			while (x > 0) {
				a = a * 10 + x % 10;
				x /= 10;
			}
			return a;
		}

		class myDate {
			int d, m, y;

			int[] ml = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

			public myDate(int da, int ma, int ya) {
				d = da;
				m = ma;
				y = ya;
				if ((ma > 12 || ma < 1 || da > ml[ma - 1] || da < 1) && !(d == 29 && m == 2 && y % 4 == 0)) {
					d = 1;
					m = 1;
					y = 9999999;
				}
			}

			void incYear(int x) {
				for (int i = 0; i < x; i++) {
					y++;
					if (m == 2 && d == 29) {
						m = 3;
						d = 1;
						return;
					}
					if (m == 3 && d == 1) {
						if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0)) {
							m = 2;
							d = 29;
						}
						return;
					}
				}
			}

			boolean less(myDate x) {
				if (y < x.y) return true;
				if (y > x.y) return false;
				if (m < x.m) return true;
				if (m > x.m) return false;
				if (d < x.d) return true;
				if (d > x.d) return false;
				return true;
			}

			void inc() {
				if ((d == 31) && (m == 12)) {
					y++;
					d = 1;
					m = 1;
				} else {
					if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0)) {
						ml[1] = 29;
					}
					if (d == ml[m - 1]) {
						m++;
						d = 1;
					} else
						d++;
				}
			}
		}

		int partition(int n, int l, int m) {// n - sum, l - length, m - every
											// part
			// <= m
			if (n < l) return 0;
			if (n < l + 2) return 1;
			if (l == 1) return 1;
			int c = 0;
			for (int i = Math.min(n - l + 1, m); i >= (n + l - 1) / l; i--) {
				c += partition(n - i, l - 1, i);
			}
			return c;
		}

		int rifmQuality(String a, String b) {
			if (a.length() > b.length()) {
				String c = a;
				a = b;
				b = c;
			}
			int c = 0, d = b.length() - a.length();
			for (int i = a.length() - 1; i >= 0; i--) {
				if (a.charAt(i) == b.charAt(i + d)) c++;
				else
					break;
			}
			return c;
		}

		String numSym = "0123456789ABCDEF";

		String ZFromXToYNotation(int x, int y, String z) {
			if (z.equals("0")) return "0";
			String a = "";
			// long q = 0, t = 1;
			BigInteger q = BigInteger.ZERO, t = BigInteger.ONE;
			for (int i = z.length() - 1; i >= 0; i--) {
				q = q.add(t.multiply(BigInteger.valueOf(z.charAt(i) - 48)));
				t = t.multiply(BigInteger.valueOf(x));
			}
			while (q.compareTo(BigInteger.ZERO) == 1) {
				a = numSym.charAt((int) (q.mod(BigInteger.valueOf(y)).intValue())) + a;
				q = q.divide(BigInteger.valueOf(y));
			}
			return a;
		}

		double angleFromXY(int x, int y) {
			if ((x == 0) && (y > 0)) return Math.PI / 2;
			if ((x == 0) && (y < 0)) return -Math.PI / 2;
			if ((y == 0) && (x > 0)) return 0;
			if ((y == 0) && (x < 0)) return Math.PI;
			if (x > 0) return Math.atan((double) y / x);
			else {
				if (y > 0) return Math.atan((double) y / x) + Math.PI;
				else
					return Math.atan((double) y / x) - Math.PI;
			}
		}

		static boolean isNumber(String x) {
			try {
				Integer.parseInt(x);
			} catch (NumberFormatException ex) {
				return false;
			}
			return true;
		}

		static boolean stringContainsOf(String x, String c) {
			for (int i = 0; i < x.length(); i++) {
				if (c.indexOf(x.charAt(i)) == -1) return false;
			}
			return true;
		}

		long pow(long a, long n) { // b > 0
			if (n == 0) return 1;
			long k = n, b = 1, c = a;
			while (k != 0) {
				if (k % 2 == 0) {
					k /= 2;
					c *= c;
				} else {
					k--;
					b *= c;
				}
			}
			return b;
		}

		int pow(int a, int n) { // b > 0
			if (n == 0) return 1;
			int k = n, b = 1, c = a;
			while (k != 0) {
				if (k % 2 == 0) {
					k /= 2;
					c *= c;
				} else {
					k--;
					b *= c;
				}
			}
			return b;
		}

		double pow(double a, int n) { // b > 0
			if (n == 0) return 1;
			double k = n, b = 1, c = a;
			while (k != 0) {
				if (k % 2 == 0) {
					k /= 2;
					c *= c;
				} else {
					k--;
					b *= c;
				}
			}
			return b;
		}

		double log2(double x) {
			return Math.log(x) / Math.log(2);
		}

		int lpd(int[] primes, int x) {// least prime divisor
			int i;
			for (i = 0; primes[i] <= x / 2; i++) {
				if (x % primes[i] == 0) {
					return primes[i];
				}
			}
			;
			return x;
		}

		int np(int[] primes, int x) {// number of prime number
			for (int i = 0; true; i++) {
				if (primes[i] == x) return i;
			}
		}

		int[] dijkstra(int[][] map, int n, int s) {
			int[] p = new int[n];
			boolean[] b = new boolean[n];
			Arrays.fill(p, Integer.MAX_VALUE);
			p[s] = 0;
			b[s] = true;
			for (int i = 0; i < n; i++) {
				if (i != s) p[i] = map[s][i];
			}
			while (true) {
				int m = Integer.MAX_VALUE, mi = -1;
				for (int i = 0; i < n; i++) {
					if (!b[i] && (p[i] < m)) {
						mi = i;
						m = p[i];
					}
				}
				if (mi == -1) break;
				b[mi] = true;
				for (int i = 0; i < n; i++)
					if (p[mi] + map[mi][i] < p[i]) p[i] = p[mi] + map[mi][i];
			}
			return p;
		}

		boolean isLatinChar(char x) {
			if (((x >= 'a') && (x <= 'z')) || ((x >= 'A') && (x <= 'Z'))) return true;
			else
				return false;
		}

		boolean isBigLatinChar(char x) {
			if (x >= 'A' && x <= 'Z') return true;
			else
				return false;
		}

		boolean isSmallLatinChar(char x) {
			if (x >= 'a' && x <= 'z') return true;
			else
				return false;
		}

		boolean isDigitChar(char x) {
			if (x >= '0' && x <= '9') return true;
			else
				return false;
		}

		class NotANumberException extends Exception {
			private static final long serialVersionUID = 1L;
			String mistake;

			NotANumberException() {
				mistake = "Unknown.";
			}

			NotANumberException(String message) {
				mistake = message;
			}
		}

		class Real {
			String num = "0";
			long exp = 0;
			boolean pos = true;

			long length() {
				return num.length();
			}

			void check(String x) throws NotANumberException {
				if (!stringContainsOf(x, "0123456789+-.eE")) throw new NotANumberException("Illegal character.");
				long j = 0;
				for (long i = 0; i < x.length(); i++) {
					if ((x.charAt((int) i) == '-') || (x.charAt((int) i) == '+')) {
						if (j == 0) j = 1;
						else
							if (j == 5) j = 6;
							else
								throw new NotANumberException("Unexpected sign.");
					} else
						if ("0123456789".indexOf(x.charAt((int) i)) != -1) {
							if (j == 0) j = 2;
							else
								if (j == 1) j = 2;
								else
									if (j == 2)
									;
									else
										if (j == 3) j = 4;
										else
											if (j == 4)
											;
											else
												if (j == 5) j = 6;
												else
													if (j == 6)
													;
													else
														throw new NotANumberException("Unexpected digit.");
						} else
							if (x.charAt((int) i) == '.') {
								if (j == 0) j = 3;
								else
									if (j == 1) j = 3;
									else
										if (j == 2) j = 3;
										else
											throw new NotANumberException("Unexpected dot.");
							} else
								if ((x.charAt((int) i) == 'e') || (x.charAt((int) i) == 'E')) {
									if (j == 2) j = 5;
									else
										if (j == 4) j = 5;
										else
											throw new NotANumberException("Unexpected exponent.");
								} else
									throw new NotANumberException("O_o.");
				}
				if ((j == 0) || (j == 1) || (j == 3) || (j == 5)) throw new NotANumberException("Unexpected end.");
			}

			public Real(String x) throws NotANumberException {
				check(x);
				if (x.charAt(0) == '-') pos = false;
				long j = 0;
				String e = "";
				boolean epos = true;
				for (long i = 0; i < x.length(); i++) {
					if ("0123456789".indexOf(x.charAt((int) i)) != -1) {
						if (j == 0) num += x.charAt((int) i);
						if (j == 1) {
							num += x.charAt((int) i);
							exp--;
						}
						if (j == 2) e += x.charAt((int) i);
					}
					if (x.charAt((int) i) == '.') {
						if (j == 0) j = 1;
					}
					if ((x.charAt((int) i) == 'e') || (x.charAt((int) i) == 'E')) {
						j = 2;
						if (x.charAt((int) (i + 1)) == '-') epos = false;
					}
				}
				while ((num.length() > 1) && (num.charAt(0) == '0'))
					num = num.substring(1);
				while ((num.length() > 1) && (num.charAt(num.length() - 1) == '0')) {
					num = num.substring(0, num.length() - 1);
					exp++;
				}
				if (num.equals("0")) {
					exp = 0;
					pos = true;
					return;
				}
				while ((e.length() > 1) && (e.charAt(0) == '0'))
					e = e.substring(1);
				try {
					if (e != "") if (epos) exp += Long.parseLong(e);
					else
						exp -= Long.parseLong(e);
				} catch (NumberFormatException exc) {
					if (!epos) {
						num = "0";
						exp = 0;
						pos = true;
					} else {
						throw new NotANumberException("Too long exponent");
					}
				}
			}

			public Real() {
			}

			String toString(long mantissa) {
				String a = "", b = "";
				if (exp >= 0) {
					a = num;
					if (!pos) a = '-' + a;
					for (long i = 0; i < exp; i++)
						a += '0';
					for (long i = 0; i < mantissa; i++)
						b += '0';
					if (mantissa == 0) return a;
					else
						return a + "." + b;
				} else {
					if (exp + length() <= 0) {
						a = "0";
						if (mantissa == 0) {
							return a;
						}
						if (mantissa < -(exp + length() - 1)) {
							for (long i = 0; i < mantissa; i++)
								b += '0';
							return a + "." + b;
						} else {
							if (!pos) a = '-' + a;
							for (long i = 0; i < mantissa; i++)
								if (i < -(exp + length())) b += '0';
								else
									if (i + exp >= 0) b += '0';
									else
										b += num.charAt((int) (i + exp + length()));
							return a + "." + b;
						}
					} else {
						if (!pos) a = "-";
						for (long i = 0; i < exp + length(); i++)
							a += num.charAt((int) i);
						if (mantissa == 0) return a;
						for (long i = exp + length(); i < exp + length() + mantissa; i++)
							if (i < length()) b += num.charAt((int) i);
							else
								b += '0';
						return a + "." + b;
					}
				}
			}
		}

		boolean containsRepeats(int... num) {
			Set<Integer> s = new TreeSet<Integer>();
			for (int d : num)
				if (!s.contains(d)) s.add(d);
				else
					return true;
			return false;
		}

		int[] rotateDice(int[] a, int n) {
			int[] c = new int[6];
			if (n == 0) {
				c[0] = a[1];
				c[1] = a[5];
				c[2] = a[2];
				c[3] = a[0];
				c[4] = a[4];
				c[5] = a[3];
			}
			if (n == 1) {
				c[0] = a[2];
				c[1] = a[1];
				c[2] = a[5];
				c[3] = a[3];
				c[4] = a[0];
				c[5] = a[4];
			}
			if (n == 2) {
				c[0] = a[3];
				c[1] = a[0];
				c[2] = a[2];
				c[3] = a[5];
				c[4] = a[4];
				c[5] = a[1];
			}
			if (n == 3) {
				c[0] = a[4];
				c[1] = a[1];
				c[2] = a[0];
				c[3] = a[3];
				c[4] = a[5];
				c[5] = a[2];
			}
			if (n == 4) {
				c[0] = a[0];
				c[1] = a[2];
				c[2] = a[3];
				c[3] = a[4];
				c[4] = a[1];
				c[5] = a[5];
			}
			if (n == 5) {
				c[0] = a[0];
				c[1] = a[4];
				c[2] = a[1];
				c[3] = a[2];
				c[4] = a[3];
				c[5] = a[5];
			}
			return c;
		}

		int min(int... a) {
			int c = Integer.MAX_VALUE;
			for (int d : a)
				if (d < c) c = d;
			return c;
		}

		int max(int... a) {
			int c = Integer.MIN_VALUE;
			for (int d : a)
				if (d > c) c = d;
			return c;
		}

		int pos(int x) {
			if (x > 0) return x;
			else
				return 0;
		}

		long pos(long x) {
			if (x > 0) return x;
			else
				return 0;
		}

		double maxD(double... a) {
			double c = Double.MIN_VALUE;
			for (double d : a)
				if (d > c) c = d;
			return c;
		}

		double minD(double... a) {
			double c = Double.MAX_VALUE;
			for (double d : a)
				if (d < c) c = d;
			return c;
		}

		int[] normalizeDice(int[] a) {
			int[] c = a.clone();
			if (c[0] != 0) if (c[1] == 0) c = rotateDice(c, 0);
			else
				if (c[2] == 0) c = rotateDice(c, 1);
				else
					if (c[3] == 0) c = rotateDice(c, 2);
					else
						if (c[4] == 0) c = rotateDice(c, 3);
						else
							if (c[5] == 0) c = rotateDice(rotateDice(c, 0), 0);
			while (c[1] != min(c[1], c[2], c[3], c[4]))
				c = rotateDice(c, 4);
			return c;
		}

		boolean sameDice(int[] a, int[] b) {
			for (int i = 0; i < 6; i++)
				if (a[i] != b[i]) return false;
			return true;
		}

		final double goldenRatio = (1 + Math.sqrt(5)) / 2;
		final double aGoldenRatio = (1 - Math.sqrt(5)) / 2;

		long Fib(int n) {
			if (n < 0) if (n % 2 == 0) return -Math.round((pow(goldenRatio, -n) - pow(aGoldenRatio, -n)) / Math.sqrt(5));
			else
				return -Math.round((pow(goldenRatio, -n) - pow(aGoldenRatio, -n)) / Math.sqrt(5));
			return Math.round((pow(goldenRatio, n) - pow(aGoldenRatio, n)) / Math.sqrt(5));
		}

		class japaneeseComparator implements Comparator<String> {
			@Override
			public int compare(String a, String b) {
				int ai = 0, bi = 0;
				boolean m = false, ns = false;
				if (a.charAt(ai) <= '9' && a.charAt(ai) >= '0') {
					if (b.charAt(bi) <= '9' && b.charAt(bi) >= '0') m = true;
					else
						return -1;
				}
				if (b.charAt(bi) <= '9' && b.charAt(bi) >= '0') {
					if (a.charAt(ai) <= '9' && a.charAt(ai) >= '0') m = true;
					else
						return 1;
				}
				a += "!";
				b += "!";
				int na = 0, nb = 0;
				while (true) {
					if (a.charAt(ai) == '!') {
						if (b.charAt(bi) == '!') break;
						return -1;
					}
					if (b.charAt(bi) == '!') {
						return 1;
					}
					if (m) {
						int ab = -1, bb = -1;
						while (a.charAt(ai) <= '9' && a.charAt(ai) >= '0') {
							if (ab == -1) ab = ai;
							ai++;
						}
						while (b.charAt(bi) <= '9' && b.charAt(bi) >= '0') {
							if (bb == -1) bb = bi;
							bi++;
						}
						m = !m;
						if (ab == -1) {
							if (bb == -1) continue;
							else
								return 1;
						}
						if (bb == -1) return -1;
						while (a.charAt(ab) == '0' && ab + 1 != ai) {
							ab++;
							if (!ns) na++;
						}
						while (b.charAt(bb) == '0' && bb + 1 != bi) {
							bb++;
							if (!ns) nb++;
						}
						if (na != nb) ns = true;
						if (ai - ab < bi - bb) return -1;
						if (ai - ab > bi - bb) return 1;
						for (int i = 0; i < ai - ab; i++) {
							if (a.charAt(ab + i) < b.charAt(bb + i)) return -1;
							if (a.charAt(ab + i) > b.charAt(bb + i)) return 1;
						}
					} else {
						m = !m;
						while (true) {
							if (a.charAt(ai) <= 'z' && a.charAt(ai) >= 'a' && b.charAt(bi) <= 'z' && b.charAt(bi) >= 'a') {
								if (a.charAt(ai) < b.charAt(bi)) return -1;
								if (a.charAt(ai) > b.charAt(bi)) return 1;
								ai++;
								bi++;
							} else
								if (a.charAt(ai) <= 'z' && a.charAt(ai) >= 'a') return 1;
								else
									if (b.charAt(bi) <= 'z' && b.charAt(bi) >= 'a') return -1;
									else
										break;
						}
					}
				}
				if (na < nb) return 1;
				if (na > nb) return -1;
				return 0;
			}
		}

		Random random = new Random();
	}

	void readIntArray(int[] a) throws IOException {
		for (int i = 0; i < a.length; i++)
			a[i] = nextInt();
	}

	String readChars(int l) throws IOException {
		String r = "";
		for (int i = 0; i < l; i++)
			r += (char) br.read();
		return r;
	}

	class myFraction {
		long num = 0, den = 1;

		void reduce() {
			long d = lib.gcd(num, den);
			num /= d;
			den /= d;
		}

		myFraction(long ch, long zn) {
			num = ch;
			den = zn;
			reduce();
		}

		myFraction add(myFraction t) {
			long nd = lib.lcm(den, t.den);
			myFraction r = new myFraction(nd / den * num + nd / t.den * t.num, nd);
			r.reduce();
			return r;
		}

		public String toString() {
			return num + "/" + den;
		}

		int lev(String s1, String s2) {
			int[][] distance = new int[s1.length() + 1][s2.length() + 1];
			for (int i = 0; i <= s1.length(); i++)
	            distance[i][0] = i;
			for (int j = 0; j <= s2.length(); j++)
	            distance[0][j] = j;
			for (int i = 1; i <= s1.length(); i++)
	            for (int j = 1; j <= s2.length(); j++)
	                    distance[i][j] = Math.min(Math.min(distance[i - 1][j] + 1, distance[i][j - 1] + 1), distance[i - 1][j - 1] + ((s1.charAt(i - 1) == s2.charAt(j - 1)) ? 0 : 1));
			return distance[s1.length()][s2.length()];
		}
	}

	class myPoint {
		myPoint(int a, int b) {
			x = a;
			y = b;
		}

		int x, y;

		boolean equals(myPoint a) {
			if (x == a.x && y == a.y) return true;
			else
				return false;
		}

		public String toString() {
			return x + ":" + y;
		}
	}
}


public class Main{
    public static void main(String [] args){

        byte i,k,j=0;
        int p,ka;
        byte n;
        Scanner sc=new Scanner(System.in);
        n=sc.nextByte();
        Byte vec[]=new Byte[n];

        for(i=0;i<vec.length;i++){
            vec[i]=sc.nextByte();
            j+=vec[i];
        }

        p=n/2;

        j/=p;

        for(i=0;i<vec.length-1;i++){
            ka=i+1;
            for(k=(byte)ka; k<vec.length; k++){
                if(vec[i]+vec[k]==j && vec[k]!=-1){
                    System.out.println((i+1)+" "+(k+1));
                    vec[k]=-1;
                    break;
                }
            }
        }

    }
}


// package Quarantine;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class WorldIsJustAProgRammingTask {
    public static void main(String[] args)throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        int n=Integer.parseInt(br.readLine());
        char c[]=br.readLine().toCharArray();
        int max=0;
        int l=1,r=1;
        for(int i=0;i<n;i++){
            for(int j=i;j<n;j++){
                char d[]=new char[n];
                for(int k=0;k<n;k++){
                    d[k]=c[k];
                }
                char temp=d[j];
                d[j]=d[i];
                d[i]=temp;
//                System.out.println(i+" "+j);
                int small=solve(d,n);
                if(small>max){
                    max=small;
                    l=i+1;
                    r=j+1;
                }
            }
        }
        System.out.println(max);
        System.out.println(l+" "+r);
    }
    public static int solve(char c[],int n){
        int dp[]=new int[n];
        dp[0]=c[0]=='('?1:-1;
//        System.out.print(dp[0]+" ");
        for(int i=1;i<n;i++){
            if(c[i]=='('){
                dp[i]=dp[i-1]+1;
            }
            else{
                dp[i]=dp[i-1]-1;
            }
//            System.out.print(dp[i]+" ");
        }
//        System.out.println();
        int min[]=new int[n];
        int min2[]=new int[n];
        min2[0]=dp[0];
        for(int i=1;i<n;i++){
            min2[i]=Math.min(min2[i-1],dp[i]);
        }
        min[n-1]=dp[n-1];
        for(int i=n-2;i>=0;i--){
            min[i]=Math.min(dp[i],min[i+1]);
        }
        int ans=0;
        if(dp[0]==1&&dp[n-1]==0&&min[0]==0){
            ans++;
        }
        for(int i=0;i<n-1;i++){
            if(dp[i]+1==dp[i+1]&&min[i+1]>=dp[i]&&min2[i]>=dp[i]&&dp[n-1]==0){
                ans++;
            }
        }
//        System.out.println(ans);
        return ans;
    }
}


import java.util.Scanner;

public class D {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int r = sc.nextInt();
        int v = sc.nextInt();
        for (int i = 0; i < n; i++) {
            int s = sc.nextInt();
            int f = sc.nextInt();
            double d = f - s;
            double p = 2 * Math.PI * r;
            d %= p;
            double min = 0, max = 2 * Math.PI;
            for (int j = 0; j < 100; j++) {
                double mid = (min + max) / 2;
                double dis = (mid + Math.sin(mid)) * r * 2;
                if (dis < d)
                    min = mid;
                else
                    max = mid;
            }
            double t1 = (f - s - d) / v;
            double t2 = (min + max) * r / v;
            if ((min + max) / 2 > Math.PI)
                System.out.println(" = " + (min + max) / 2);
            System.out.println(t1 + t2);
        }
        sc.close();
    }
}


import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class Test {
  static PrintWriter writer =
      new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  int n, k;
  int N = 1 << 16;
  int[][] f = new int[5][N];
  int idx = 0;

  public static void main(String[] args) {
    Test te = new Test();
    te.start();
    writer.flush();
  }

  static int readInt() {
    int ans = 0;
    boolean neg = false;
    try {
      boolean start = false;
      for (int c = 0; (c = System.in.read()) != -1; ) {
        if (c == '-') {
          start = true;
          neg = true;
          continue;
        } else if (c >= '0' && c <= '9') {
          start = true;
          ans = ans * 10 + c - '0';
        } else if (start) break;
      }
    } catch (IOException e) {
    }
    return neg ? -ans : ans;
  }

  static long readLong() {
    long ans = 0;
    boolean neg = false;
    try {
      boolean start = false;
      for (int c = 0; (c = System.in.read()) != -1; ) {
        if (c == '-') {
          start = true;
          neg = true;
          continue;
        } else if (c >= '0' && c <= '9') {
          start = true;
          ans = ans * 10 + c - '0';
        } else if (start) break;
      }
    } catch (IOException e) {
    }
    return neg ? -ans : ans;
  }

  static String readString() {
    StringBuilder b = new StringBuilder();
    try {
      boolean start = false;
      for (int c = 0; (c = System.in.read()) != -1; ) {
        if (Character.isLetterOrDigit(c)) {
          start = true;
          b.append((char) c);
        } else if (start) break;
      }
    } catch (IOException e) {
    }
    return b.toString();
  }

  static int readChars(char[] a, int off) {
    int cnt = 0;
    try {
      boolean start = false;
      for (int c = 0; (c = System.in.read()) != -1; ) {
        if (Character.isLetterOrDigit(c)) {
          start = true;
          a[off + cnt++] = (char) c;
        } else if (start) break;
      }
    } catch (IOException e) {
    }
    return cnt;
  }

  void solve(int n) {
    if (n == 1) {
      f[0][0] = 1;
      f[0][1] = 0;
      f[1][0] = 1;
      f[1][1] = 1;
      idx = 1;
      return;
    }
    if (n == 2) {
      f[1][0] = 1;
      f[1][1] = 1;
      f[2][0] = 1;
      f[2][1] = 3;
      f[2][2] = 1;
      idx = 2;
      return;
    }
    if (n % 2 == 1) {
      solve(n - 1);
      int nidx = (idx + 1) % 3, pidx = (idx + 3 - 1) % 3;
      f[nidx][0] = 1;
      for (int i = 1; i < N; i++)
        f[nidx][i] = Ntt.add(Ntt.add(f[idx][i], f[idx][i - 1]), f[pidx][i - 1]);
      idx = nidx;
      return;
    }

    solve(n / 2);
    int nidx = (idx + 1) % 3, pidx = (idx + 3 - 1) % 3, ppidx = 3;
    for (int i = 0; i + 1 < N; i++)
      f[ppidx][i] = Ntt.add(f[idx][i + 1], Ntt.M - Ntt.add(f[pidx][i], f[pidx][i + 1]));

    Ntt.fft(f[idx], 0, N);
    Ntt.fft(f[pidx], 0, N);
    Ntt.fft(f[ppidx], 0, N);

    for (int i = 0; i < N; i++) f[nidx][i] = Ntt.mul(f[idx][i], f[idx][i]);
    Ntt.ifft(f[nidx], 0, N);

    for (int i = 0; i < N; i++) f[4][i] = Ntt.mul(f[pidx][i], f[pidx][i]);
    Ntt.ifft(f[4], 0, N);
    for (int i = 1; i < N; i++) f[nidx][i] = Ntt.add(f[nidx][i], f[4][i - 1]);

    for (int i = 0; i < N; i++) f[idx][i] = Ntt.mul(f[idx][i], f[pidx][i]);
    Ntt.ifft(f[idx], 0, N);

    for (int i = 0; i < N; i++) f[pidx][i] = Ntt.mul(f[pidx][i], f[ppidx][i]);
    Ntt.ifft(f[pidx], 0, N);
    for (int i = 1; i < N; i++) f[idx][i] = Ntt.add(f[idx][i], f[pidx][i - 1]);

    idx = nidx;
  }

  void start() {
    n = readInt();
    k = readInt();
    solve(n);
    for (int i = 1; i <= k; i++) writer.print(f[idx][i] + " ");
  }

  static class Ntt {
    static final int pri = 3;
    static final int M = 998_244_353;
    static int[] xy = new int[2];

    static int pmod(int b, int e) {
      int i = 1 << 31;
      int r = 1;
      while (i != 0) {
        r = mul(r, r);
        if ((e & i) != 0) r = mul(r, b);
        i >>>= 1;
      }
      return r;
    }

    static void fft(int[] a, int off, int len) {
      for (int i = 0; i < len; i++) {
        int j = i, x = 0, y = len - 1;
        while (y > 0) {
          x = (x << 1) + (j & 1);
          j >>>= 1;
          y >>>= 1;
        }
        if (i < x) {
          int t = a[off + i];
          a[off + i] = a[off + x];
          a[off + x] = t;
        }
      }
      for (int i = 1; i < len; i *= 2) {
        int s = pmod(pri, (M - 1) / 2 / i);
        for (int j = 0; j < len; j += 2 * i) {
          int w = 1;
          for (int k = 0; k < i; k++) {
            int u = a[off + j + k], v = mul(a[off + j + k + i], w);
            a[off + j + k] = add(u, v);
            a[off + j + k + i] = add(u, M - v);
            w = mul(w, s);
          }
        }
      }
    }

    static void ifft(int[] a, int off, int len) {
      int ll = 1, rr = len - 1;
      while (ll < rr) {
        int t = a[off + ll];
        a[off + (ll++)] = a[off + rr];
        a[off + (rr--)] = t;
      }
      fft(a, off, len);
      int inv = pmod(len, M - 2);
      for (int i = 0; i < len; i++) a[off + i] = mul(inv, a[off + i]);
    }

    static int add(int a, int b) {
      return (a + b) % M;
    }

    static int mul(int a, int b) {
      return (int) ((a * (long) b) % M);
    }

    static int inverse(int a, int b) {
      if (b == 0) {
        xy[0] = 1;
        xy[1] = 0;
        return a;
      }
      int d = inverse(b, a % b);
      swap(xy, 0, 1);
      xy[1] -= a / b * xy[0];
      return d;
    }

    static void swap(int[] a, int i, int j) {
      int t = a[i];
      a[i] = a[j];
      a[j] = t;
    }
  }
}


import java.util.*

public class Solution {

public static boolean checkTeams(int[] scores) {
        int sum = 0;
        for (int score:scores){
            sum += score;
        }
        if (sum == 0) {
            return true;
        }
        int teamScore = sum >> 1;
        if (sum % 2 == 1) {
            return false;
        }

        for (int i = 0; i < scores.length; i++) {
            if (scores[i] >= teamScore) {
                return false;
            }
        }

        int tempSum = scores[0];
        int count = 1;
        for (int j = 1; j < scores.length; j++) {
            tempSum += scores[j];
            count++;
            if((count<3 && tempSum >= teamScore) || (count == 3 && tempSum != teamScore))
            {
                tempSum -= scores[j];
                count--;
            }

            if(tempSum == teamScore && count == 3)
            {
                return true;
            }
        }
        return false;

    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[] scores = new int[6];
        for (int i = 0; i < 6; i++) {
            scores[i] = in.nextInt();
        }
        System.out.println(checkTeams(scores)?"Yes":"NO");
        in.close();
    }
}


import java.util.Scanner;
public class code
{
    public static void main(String arg[])
    {
        Scanner ob=new Scanner(System.in);
        String t=ob.nextInt();
        String s="";
        int mid=(t.length()-1)/2;
        s=t.charAt(mid);
        int x=1;
        while((mid+x)<t.length())
        {
            s=s+t.charAt(mid+x)+t.charAt(mid-x);
            x++;
        }
        if(t.length()%2==0)
        s=s+t.charAt(t.length()-1);
        System.out.println(s);
    }
}


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

/*
 * To execute Java, please define "static void main" on a class
 * named Solution.
 *
 * If you need more classes, simply define them inline.
 */

public class Solution {

  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    int p = scanner.nextInt();
    long long sum = 0;
    for (int i = 1; i <= n; ++i) {
      int x = i;
      long long y = i;
      long long r = 0;
      while (x > 0) {
        r = (r * 10) + (x % 10);
        x /= 10;
        y = (y * 10) % p;
      }
      y = (y + r) % p;
      sum = (sum + y) % p;
    }
    System.out.println(sum);
  }
}


import java.util.Scanner;

public class hack {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n  = sc.nextInt();
		int a = sc.nextInt();
		int b = sc.nextInt();
		int[] arr = new int[n];
		for(int i = 0;i<n;i++)
			arr[i] = sc.nextInt();
		int i = 0;
		int j = n-1;
		int flag = 0;
		int ans = 0;
		for(i = 0;i<n/2;i++){
			if(arr[i] == 0 && arr[j] == 0){
				j--;
				continue;
			}
			if(arr[i] == 1 && arr[j] == 1){
				j--;
				continue;
			}
			if(arr[i] == 1 && arr[j] == 0){
				flag = 1;
				break;
			}
			if(arr[i] == 0 && arr[j] == 1){
				flag = 1;
				break;
			}
			if(arr[i] == 0&& arr[j] == 2){
				j--;
				ans = ans + a;
				continue;
			}
			if(arr[i] == 1 && arr[j] == 2){
				j--;
				ans = ans + b;
				continue;
			}
			if(arr[i] == 2 && arr[j] == 0){
				j--;
				ans = ans + a;
				continue;
			}
			if(arr[i] == 2 && arr[j] == 1){
				j--;
				ans = ans + b;
				continue;
			}
			if(arr[i] == 2 && arr[i] == 2){
				j--;
				ans = ans + 2*Math.min(a, b);
				continue;
			}

		}
		if(n%2 == 0){
			if(flag == 1)
				System.out.println(-1);
			else
				System.out.println(ans);
		}
		else{
			if(flag == 1)
				System.out.println(-1);
			else{
				if(arr[n/2] == 2){
					ans = ans + Math.min(a, b);
				}
				System.out.println(ans);
			}
		}

	}
}
close


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

public class D539 {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
        int n = sc.nextInt(); int m = sc.nextInt(); int a = sc.nextInt(); int b = sc.nextInt();
        int max = Math.max(n, m);
        fac = new long[max + 10];
        initFac(max + 6);
        long ans = 0;
        for (int k = 0; k <= n - 2; k++) {
            long middle = (nck(n - 2, k) * fac[k]) % mod;
            long sum = nck(m - 1, k);
            long cayley;
            if (n - k - 3 >= 0) cayley = ((k + 2) * pow(n, n - k - 3)) % mod; else cayley = 1;
            long total = (((middle * sum) % mod) * cayley) % mod;
            total = (total * pow(m, n - k - 2));
            ans = (ans + total) % mod;
        }
        out.println(ans);
        out.close();
    }

    static long[] fac;
    static long mod = (int) 1e9 + 7;

    static void initFac(long n) {
        fac[0] = 1;
        for (int i = 1; i <= n; i++) {
            fac[i] = (fac[i - 1]  * i) % mod;
        }
    }

    static long exponentiation(long base, long exp)
    {
        long t = 1L;
        while (exp > 0) {

            // for cases where exponent
            // is not an even value
            if (exp % 2 != 0)
                t = (t * base) % mod;

            base = (base * base) % mod;
            exp /= 2;
        }
        return t % mod;
    }

    static long nck(int n, int k) {
        if (n < k)
            return 0;
        long den = inv((int) (fac[k] * fac[n - k] % mod));
        return fac[n] * den % mod;
    }

    static long pow(long b, long e) {
        long ans = 1;
        while (e > 0) {
            if (e % 2 == 1)
                ans = ans * b % mod;
            e >>= 1;
            b = b * b % mod;
        }
        return ans;
    }

    static long inv(int x) {
        return pow(x, mod - 2);
    }

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }

}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Roy
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        ProblemBMancala solver = new ProblemBMancala();
        solver.solve(1, in, out);
        out.close();
    }

    static class ProblemBMancala {
        public static final int HOLES = 14;

        public void solve(int testNumber, InputReader reader, OutputWriter writer) {

            long tmpHoles[];
            long holes[] = new long[HOLES];
            for (int i = 0; i < HOLES; i++) {
                holes[i] = reader.readLong();
            }
            long max = 0;
            for (int i = 0; i < HOLES; i++) {
                //-> checking array copy... :D
//            tmpHoles = holes.clone();
//            tmpHoles = Arrays.copyOf(holes, holes.length);
                tmpHoles = Arrays.copyOfRange(holes, 0, holes.length);

                tmpHoles[i] = 0;//-> WA cz: I didn't add this stupid line...
                for (int j = 0; j < HOLES; j++) {
                    tmpHoles[j] += holes[i] / HOLES;
                }
                long stones = holes[i] % HOLES;
                int indx = i + 1;
                while (stones-- > 0) {
                    if (indx == HOLES) {
                        indx = 0;
                    }
                    ++tmpHoles[indx++];
                }
                long sum = 0;
                for (int j = 0; j < HOLES; j++) {
                    if ((tmpHoles[j] & 1) == 0) {
                        sum += tmpHoles[j];
                    }
                }
                if (sum > max) max = sum;
            }
            writer.print(max);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void close() {
            writer.flush();
            writer.close();
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

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

        public 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 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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}


import java.util.Scanner;

public class Bishwock {

	public static void main(String[] args) {

		Scanner s = new Scanner(System.in);
		String s1 = s.nextLine();
		String s2 =  s.nextLine();
		Integer n = s1.length()-1;
		Integer n1=0,n2 =0;
		Integer no = 0;
		while(n1<n||n2<n) {
			if(n1>n2) {
				if(s1.charAt(n1)=='0') {
					if(s2.charAt(n1)=='0') {
						if(n2<n1&&s2.charAt(n2)=='0') {
							no++;
							n2=++n1;
						}else if(s2.charAt(n1+1)=='0') {
							no++;
							n2=++n1+1;
						}else if(s1.charAt(n1+1)=='0'){
							no++;
							n2=n1+1;
							n1=n1+2;
						}else {
							n1=n1+2;
							n2=n1;
						}
					}else {
						n2=n1+1;
					}
				}else {
					n1++;
				}
			}else {
				if(s2.charAt(n2)=='0') {
					if(s1.charAt(n2)=='0') {
						if(n1<n2 && s1.charAt(n1)=='0') {
							no++;
							n1=++n2;
						}else if(s1.charAt(n1+1)=='0') {
							no++;
							n1=++n2+1;
						}else if(s2.charAt(n2+1)=='0'){
							no++;
							n1=n2+1;
							n2=n2+2;
						}else {
							n2=n2+2;
							n1=n2;
						}
					}else {
						n1=n2+1;
					}
				}else {
					n2++;
				}
			}
		}
		System.out.println(no);
	}

}


//package B;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.*;

public class solver implements Runnable {

	private void solve() throws IOException {
		int m=nextInt();
		int[][] g=new int[5][5];
		for(int i=0;i<5;i++) Arrays.fill(g[i],0);
		int a,b;
		for(int i=0;i<m;i++)
		{
			a=nextInt(); a--;
			b=nextInt(); b--;
			g[a][b]=g[b][a]=1;

		}
		for(int i=0;i<5;i++)
			for(int j=0;j<5;j++)
				for(int k=0;k<5;k++)
					if(i!=j && j!=k && i!=j && g[i][j]==1 && g[i][k]==1 && g[i][j]==1 && g[k][j]==1) {out.write("WIN"); return;}
		for(int i=0;i<5;i++)
			for(int j=0;j<5;j++)
				for(int k=0;k<5;k++)
					if(i!=j && j!=k && i!=k && g[i][j]==0 && g[i][k]==0 && g[k][j]==0) {out.write("WIN"); return;}
		out.write("FAIL");
	}

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

	BufferedReader in;
	StringTokenizer tokenizer;
	PrintWriter out;

	public void run() {
		try {
			//reader = new BufferedReader(new InputStreamReader(System.in));
			in = new BufferedReader(new FileReader("in.txt"));
			tokenizer = null;
			out = new PrintWriter(System.out);
			solve();
			in.close();
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(in.readLine());
		}
		return tokenizer.nextToken();
	}
}


import java.util.*;
import java.lang.*;
public class TaskA
{
	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);
		Long n = in.nextLong();
		Long m = in.nextLong();
		int a = in.nextInt();
		int b = in.nextInt();
		Long ans = 0;
		Long rem = n % m;
		if((m - rem) * a < rem * b) ans = (m - rem) * a;
		else ans = rem * b;
		System.out.println(ans);
	}
}


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

import static java.lang.Math.*;
import static java.util.Arrays.*;

public class cf479e {
    static int n, a, b, k, dp[][];

    public static void main(String[] args) throws IOException {
        n = rni();
        a = ni() - 1;
        b = ni() - 1;
        k = ni();
        dp = new int[k][n];
        // prln(solve(a, k - 1));
        BIT bit =;
        for(int i = 0; i < n; ++i) {
            int dist = abs(i - b) - 1;
            dp[0][i] = min(n - 1, i + dist) - max(0, i - dist);
        }
        for(int i = 1; i < k; ++i) {
            bit = new BIT(dp[i - 1], (x, y) -> (x + y) % IBIG);
            for(int j = 0; j < n; ++j) {
                int dist = abs(j - b) - 1;
                dp[i][j] = (bit.qry(min(n, j + dist + 1)) - bit.qry(max(0, j - dist)) - dp[i - 1][j] + IBIG) % IBIG;
            }
        }
        prln(dp[k - 1][a]);
        close();
    }

    static int solve(int x, int q) {
        if(dp[q][x] > 0) {
            return dp[q][x];
        } else if(q == 0) {
            int dist = abs(x - b) - 1;
            return dp[q][x] = min(n - 1, x + dist) - max(0, x - dist);
        } else {
            int dist = abs(x - b) - 1;
            for(int i = max(0, x - dist); i <= min(n - 1, x + dist); ++i) {
                if(i != x) {
                    dp[q][x] = (dp[q][x] + solve(i, q - 1)) % IBIG;
                }
            }
            return dp[q][x];
        }
    }

    @FunctionalInterface
    interface IntOperator {
        int merge(int a, int b);
    }

    static class BIT {
        IntOperator op;
        int n, bit[];

        BIT(int size, IntOperator operator) {
            bit = new int[n = size + 1];
            op = operator;
        }

        BIT(int[] arr, IntOperator operator) {
            bit = new int[(n = arr.length) + 1];
            op = operator;
            for(int i = 0; i < n; ++i) upd(i, arr[i]);
            ++n;
        }

        void upd(int i, int x) {
            ++i;
            while(i < n) {
                bit[i] = op.merge(bit[i], x);
                i += i & (-i);
            }
        }

        int qry(int i) {
            int ans = 0;
            while(i > 0) {
                ans = op.merge(ans, bit[i]);
                i -= i & (-i);
            }
            return ans;
        }
    }

    static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
    static StringTokenizer input;
    static Random rand = new Random();

    // references
    // IBIG = 1e9 + 7
    // IRAND ~= 3e8
    // IMAX ~= 2e10
    // LMAX ~= 9e18
    // constants
    static final int IBIG = 1000000007;
    static final int IRAND = 327859546;
    static final int IMAX = 2147483647;
    static final int IMIN = -2147483648;
    static final long LMAX = 9223372036854775807L;
    static final long LMIN = -9223372036854775808L;
    // util
    static int minof(int a, int b, int c) {return min(a, min(b, c));}
    static int minof(int... x) {return x.length == 1 ? x[0] : x.length == 2 ? min(x[0], x[1]) : min(x[0], minstarting(1, x));}
    static int minstarting(int offset, int... x) {assert x.length > 2; return offset == x.length - 2 ? min(x[offset], x[offset + 1]) : min(x[offset], minstarting(offset + 1, x));}
    static long minof(long a, long b, long c) {return min(a, min(b, c));}
    static long minof(long... x) {return x.length == 1 ? x[0] : x.length == 2 ? min(x[0], x[1]) : min(x[0], minstarting(1, x));}
    static long minstarting(int offset, long... x) {assert x.length > 2; return offset == x.length - 2 ? min(x[offset], x[offset + 1]) : min(x[offset], minstarting(offset + 1, x));}
    static int maxof(int a, int b, int c) {return max(a, max(b, c));}
    static int maxof(int... x) {return x.length == 1 ? x[0] : x.length == 2 ? max(x[0], x[1]) : max(x[0], maxstarting(1, x));}
    static int maxstarting(int offset, int... x) {assert x.length > 2; return offset == x.length - 2 ? max(x[offset], x[offset + 1]) : max(x[offset], maxstarting(offset + 1, x));}
    static long maxof(long a, long b, long c) {return max(a, max(b, c));}
    static long maxof(long... x) {return x.length == 1 ? x[0] : x.length == 2 ? max(x[0], x[1]) : max(x[0], maxstarting(1, x));}
    static long maxstarting(int offset, long... x) {assert x.length > 2; return offset == x.length - 2 ? max(x[offset], x[offset + 1]) : max(x[offset], maxstarting(offset + 1, x));}
    static int powi(int a, int b) {if(a == 0) return 0; int ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static long powl(long a, int b) {if(a == 0) return 0; long ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
    static int floori(double d) {return (int)d;}
    static int ceili(double d) {return (int)ceil(d);}
    static long floorl(double d) {return (long)d;}
    static long ceill(double d) {return (long)ceil(d);}
    static void shuffle(int[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); int swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(long[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); long swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void shuffle(double[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); double swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static <T> void shuffle(T[] a) {int n = a.length - 1; for(int i = 0; i < n; ++i) {int ind = randInt(i, n); T swap = a[i]; a[i] = a[ind]; a[ind] = swap;}}
    static void sort(int[] a) {shuffle(a); Arrays.sort(a);}
    static void sort(long[] a) {shuffle(a); Arrays.sort(a);}
    static void sort(double[] a) {shuffle(a); Arrays.sort(a);}
    static void qsort(int[] a) {Arrays.sort(a);}
    static void qsort(long[] a) {Arrays.sort(a);}
    static void qsort(double[] a) {Arrays.sort(a);}
    static int randInt(int min, int max) {return rand.nextInt(max - min + 1) + min;}
    // input
    static void r() throws IOException {input = new StringTokenizer(__in.readLine());}
    static int ri() throws IOException {return Integer.parseInt(__in.readLine());}
    static long rl() throws IOException {return Long.parseLong(__in.readLine());}
    static int[] ria(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()); return a;}
    static long[] rla(int n) throws IOException {long[] a = new long[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Long.parseLong(input.nextToken()); return a;}
    static char[] rcha() throws IOException {return __in.readLine().toCharArray();}
    static String rline() throws IOException {return __in.readLine();}
    static int rni() throws IOException {input = new StringTokenizer(__in.readLine()); return Integer.parseInt(input.nextToken());}
    static int ni() {return Integer.parseInt(input.nextToken());}
    static long rnl() throws IOException {input = new StringTokenizer(__in.readLine()); return Long.parseLong(input.nextToken());}
    static long nl() {return Long.parseLong(input.nextToken());}
    // output
    static void pr(int i) {__out.print(i);}
    static void prln(int i) {__out.println(i);}
    static void pr(long l) {__out.print(l);}
    static void prln(long l) {__out.println(l);}
    static void pr(double d) {__out.print(d);}
    static void prln(double d) {__out.println(d);}
    static void pr(char c) {__out.print(c);}
    static void prln(char c) {__out.println(c);}
    static void pr(char[] s) {__out.print(new String(s));}
    static void prln(char[] s) {__out.println(new String(s));}
    static void pr(String s) {__out.print(s);}
    static void prln(String s) {__out.println(s);}
    static void pr(Object o) {__out.print(o);}
    static void prln(Object o) {__out.println(o);}
    static void prln() {__out.println();}
    static void pryes() {__out.println("yes");}
    static void pry() {__out.println("Yes");}
    static void prY() {__out.println("YES");}
    static void prno() {__out.println("no");}
    static void prn() {__out.println("No");}
    static void prN() {__out.println("NO");}
    static void pryesno(boolean b) {__out.println(b ? "yes" : "no");};
    static void pryn(boolean b) {__out.println(b ? "Yes" : "No");}
    static void prYN(boolean b) {__out.println(b ? "YES" : "NO");}
    static void prln(int... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static void prln(long... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
    static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for(int i = 0; i < n; __out.print(iter.next()), __out.print(' '), ++i); if(n >= 0) __out.println(iter.next());}
    static void h() {__out.println("hlfd");}
    static void flush() {__out.flush();}
    static void close() {__out.close();}
}


/*
 * Author: Abhi Sapariya
 */
import java.util.*;
import java.io.*;
import java.math.*;
import java.text.DecimalFormat;

public class Solution{

	static long mod =(long)Math.pow(10,9)+7;
	static int INF = Integer.MAX_VALUE;
	static InputReader in;
    static PrintWriter out;

	public static void main(String[] args) {

		in = new InputReader(System.in);
		out = new PrintWriter(System.out);

		//CODE
		System.out.println("Testing");

	    out.close();
	}

	static long[] generate(int n, int[] arr, long p, long k, long q, int m){
		long[] x = new long[1000000];
		x[0] = 0;
		for(int i=1; i<n; i++){
			x[i] = x[i-1] + arr[(int)k];
			k = (p*k + q)%m;
		}
		return x;
	}

	static double area(long x1, long y1, long x2, long y2, long x3, long y3){
		return Math.abs(((x2-x1)*1d*(y3-y1) - (x3-x1)*1d*(y2-y1)))/2d;
	}

	static int max(int a, int b){
		return Math.max(a, b);
	}

	static long max(long a, long b){
		return Math.max(a, b);
	}
	static int min(int a, int b){
		return Math.min(a, b);
	}

	static long min(long a, long b){
		return Math.min(a,b);
	}

	static int abs(int a, int b){
		return Math.abs(a-b);
	}

	static long abs(long a, long b){
		return Math.abs(a-b);
	}

	static int sqrt(int a){
		return (int) Math.sqrt(a);
	}

	static long sqrt(long a){
		return (long) Math.sqrt(a);
	}

	static int gcd(int a, int b) {
		if (a == 0 || b == 0)
			return a + b;
		return gcd(b, a % b);
	}

	static long gcd(long a, long b) {
		if (a == 0 || b == 0)
			return a + b;
		return gcd(b, a % b);
	}

    static int power(int base, int exponent, int modulus){
	    int result = 1;
	    while (exponent > 0) {
	        if (exponent % 2 == 1)
	            result = (result * base) % modulus;
	        exponent = exponent >> 1;
	        base = (base * base) % modulus;
	    }
	    return result;
	}

    static long power(long base, long exponent, long modulus){
	    long result = 1L;
	    while (exponent > 0) {
	        if (exponent % 2L == 1L)
	            result = (result * base) % modulus;
	        exponent = exponent >> 1;
	        base = (base * base) % modulus;
	    }
	    return result;
	}

    static class Pair implements Comparable<Pair>{

    	int x;
    	int y;

    	public Pair(int x, int y){
    		this.x = x;
    		this.y = y;
    	}

    	// Ascending First X then Y
		@Override
		public int compareTo(Pair p) {
			if( x == p.x )
				return y-p.y;
			return x-p.x;
		}

		@Override
		public String toString(){
			return "(" + x + "," + y + ")";
		}
    }

    // This class represents a directed graph using adjacency list
	// representation
	class Graph {
		private int V; // No. of vertices

		// Array  of lists for Adjacency List Representation
		private LinkedList<Integer> adj[];

		// Constructor
		Graph(int v) {
			V = v;
			adj = new LinkedList[v];
			for (int i = 0; i < v; ++i)
				adj[i] = new LinkedList<Integer>();
		}

		//Function to add an edge into the graph
		void addEdge(int v, int w) {
			adj[v].add(w); // Add w to v's list.
		}

		// A function used by DFS
		void DFSUtil(int v, boolean visited[]) {
			// Mark the current node as visited and print it
			visited[v] = true;
			System.out.print(v + " ");

			// Recur for all the vertices adjacent to this vertex
			Iterator<Integer> i = adj[v].listIterator();
			while (i.hasNext()) {
				int n = i.next();
				if (!visited[n])
					DFSUtil(n, visited);
			}
		}

		// The function to do DFS traversal. It uses recursive DFSUtil()
		void DFS(int v) {
			// Mark all the vertices as not visited(set as
			// false by default in java)
			boolean visited[] = new boolean[V];

			// Call the recursive helper function to print DFS traversal
			DFSUtil(v, visited);
		}
	}

	// Class for primes utilities
	static class Primes{

	    //for marking all prime numbers greater than 1 and less than equal to N
	    boolean[] sieveOfEratosthenes(int n) {

			boolean prime[] = new boolean[n];
			// Create a boolean array "prime[0..n]" and initialize
			// all entries it as true. A value in prime[i] will
			// finally be false if i is Not a prime, else true.
			for (int i = 0; i < n; i++)
				prime[i] = true;

			for (int p = 2; p * p <= n; p++) {
				// If prime[p] is not changed, then it is a prime
				if (prime[p] == true) {
					// Update all multiples of p
					for (int i = p * 2; i <= n; i += p)
						prime[i] = false;
				}
			}

			return prime;
		}

	    ArrayList<Long> primeFactors(long n){
	    	ArrayList<Long> ans = new ArrayList<Long>();
	    	// Print the number of 2s that divide n
	        while (n%2L==0L)
	        {
	            ans.add(2L);
	            n /= 2L;
	        }

	        // n must be odd at this point.  So we can
	        // skip one element (Note i = i +2)
	        for (long i = 3; i <= Math.sqrt(n); i+= 2L)
	        {
	            // While i divides n, print i and divide n
	            while (n%i == 0)
	            {
	            	ans.add(i);
	                n /= i;
	            }
	        }

	        // This condition is to handle the case whien
	        // n is a prime number greater than 2
	        if (n > 2)
	            ans.add(n);
	        return ans;
	    }

	    //Minimum prime factors of number till n
		int[] minimumPrimeFactors(int n){
			int[] minPrime = new int[n+1];
			minPrime[1]=1;
	        for (int i = 2; i * i <= n; ++i) {
	            if (minPrime[i] == 0) {         //If i is prime
	                for (int j = i * i; j <= n; j += i) {
	                    if (minPrime[j] == 0) {
	                        minPrime[j] = i;
	                    }
	                }
	            }
	        }
	        for (int i = 2; i <= n; ++i) {
	            if (minPrime[i] == 0) {
	                minPrime[i] = i;
	            }
	        }
	        return minPrime;
		}

	    // isPrime
		boolean isPrime(long n) {
			if(n < 2L) return false;
			if(n == 2L || n == 3L) return true;
			if(n%2L == 0 || n%3L == 0) return false;
			long sqrtN = (long)Math.sqrt(n)+1L;
			for(long i = 6L; i <= sqrtN; i += 6L) {
				if(n%(i-1) == 0 || n%(i+1) == 0) return false;
			}
			return true;
		}
	}

    // Binary indexed Tree parameters (arr,arr.length)
    static class BITree {

		int[] tree;

		public BITree(int arr[], int n) {
			tree = new int[n + 1];
			for (int i = 0; i < n; i++) {
				update(i, arr[i]);
			}
		}

		public void update(int x, int val) {
			x++;
			while (x < tree.length) {
				tree[x] += val;
				x = next(x);
			}
		}

		public int sum(int x) {
			x++;
			int ans = 0;
			while (x > 0) {
				ans += tree[x];
				x = parent(x);
			}
			return ans;
		}

		public int parent(int x) {
			return x - (x & -x);
		}

		public int next(int x) {
			return x + (x & -x);
		}

	}

    // Range minimum query Segment Tree parameters - (arr,arr.length)
    static class SegmentTree {

		static int[] segT;

		public SegmentTree(int arr[], int n) {
			int nearPow = (int) (Math.ceil(Math.log(n) / Math.log(2)));
			int len = 2 * ((int) Math.pow(2, nearPow)) - 1;
			segT = new int[len];
			constructTree(arr, 0, n - 1, 0);
		}

		public void constructTree(int arr[], int low, int high, int pos) {
			if (low == high) {
				segT[pos] = arr[low];
				return;
			}

			int mid = (low + high) / 2;
			constructTree(arr, low, mid, 2 * pos + 1);
			constructTree(arr, mid + 1, high, 2 * pos + 2);
			segT[pos] = Math.min(segT[2 * pos + 1], segT[2 * pos + 2]);
		}

		public int rmq(int low, int high, int n) {
			return rmq(0, n - 1, low, high, 0);
		}

		public int rmq(int low, int high, int qlow, int qhigh, int pos) {

			if (qlow <= low && qhigh >= high) {
				return segT[pos];
			}
			if (high < qlow || qhigh < low) {
				return Integer.MAX_VALUE;
			}
			int mid = (low + high) / 2;
			return Math.min(rmq(low, mid, qlow, qhigh, 2 * pos + 1),
					rmq(mid + 1, high, qlow, qhigh, 2 * pos + 2));
		}

	}

    // Disjoint Union Set with Path Compression
    static class DUS{
    	int p;
    	int r;
    	DUS set[];

    	public DUS(int pr, int rk){
    		p = pr;
    		r = rk;
    	}

    	public DUS(int n){
    		set = new DUS[n+1];
    		for(int i=0; i<n; i++){
    			set[i] = new DUS(i,0);
    		}
    	}

    	public int find(int key){
    		if(set[key].p!=key){
    			set[key].p = find(set[key].p);
    		}
    		return set[key].p;
    	}

    	public void union(int x, int y){
    		int px = find(x);
    		int py = find(y);

    		if(set[px].r > set[py].r){
    			set[py].p = px;
    		}
    		else if(set[py].r > set[px].r){
    			set[px].p = py;
    		}
    		else{
    			set[py].p = px;
    			set[px].r++;
    		}
    	}
    }

	//Class for fibonacci utilities
	static class fibonacci {

		//Nth fibonacci number in log(n)
		public static long fib(long n, long mod) {
			long F[][] = new long[][] { { 1, 1 }, { 1, 0 } };
			if (n == 0l)
				return 0l;
			power(F, n - 1, mod);

			return F[0][0] % mod;
		}

		public static void multiply(long F[][], long M[][], long mod) {
			long x = (((F[0][0]) * (M[0][0])) % mod + ((F[0][1]) * (M[1][0]))
					% mod)
					% mod;
			long y = (((F[0][0]) * (M[0][1])) % mod + ((F[0][1]) * (M[1][1]))
					% mod)
					% mod;
			long z = (((F[1][0]) * (M[0][0])) % mod + ((F[1][1]) * (M[1][0]))
					% mod)
					% mod;
			long w = (((F[1][0]) * (M[0][1])) % mod + ((F[1][1]) * (M[1][1]))
					% mod)
					% mod;

			F[0][0] = x;
			F[0][1] = y;
			F[1][0] = z;
			F[1][1] = w;
		}

		/* Optimized version of power() in method 4 */
		public static void power(long F[][], long n, long mod) {
			if (n == 0l || n == 1l)
				return;
			long M[][] = new long[][] { { 1l, 1l }, { 1l, 0l } };

			power(F, n / 2l, mod);
			multiply(F, F, mod);
			if (n % 2l != 0l)
				multiply(F, M, mod);
		}

		static boolean isPerfectSquare(int x)
		{
		    int s = sqrt(x);
		    return (s*s == x);
		}

		// Returns true if n is a Fibinacci Number, else false
		static boolean isFibonacci(int n)
		{
		    // n is Fibinacci if one of 5*n*n + 4 or 5*n*n - 4 or both
		    // is a perferct square
		    return isPerfectSquare(5*n*n + 4) ||
		           isPerfectSquare(5*n*n - 4);
		}
	}

	static long modInverse(long A, long M)
	{
		long x=extendedEuclid(A,M)[0];
		return (x%M+M)%M;    //x may be negative
	}

	static long[] extendedEuclid(long A, long B) {
		if(B == 0) {
			long d = A;
			long x = 1;
			long y = 0;
			return new long[]{x,y,d};
		}
		else {
			long arr[]=extendedEuclid(B, A%B);
			long temp = arr[0];
			arr[0] = arr[1];
			arr[1] = temp - (A/B)*arr[1];
			return arr;
		}
	}

	public void printArr(int[] arr){
		for(int i = 0; i < arr.length; i++){
			out.print(arr[i] + " ");
		}
		out.println();
	}

	public void print2DArr(int[][] arr){
		for( int i = 0; i < arr.length; i++){
			for ( int j = 0; j < arr[0].length; j++){
				out.print(arr[i][j] + " ");
			}
			out.println();
		}
	}

	static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, numChars;
        private SpaceCharFilter filter;

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

        public 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 String nextLine() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }

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

        public long nextLong() {
            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 int nextInt() {
            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 int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

        public int[][] nextInt2DArray(int n, int m){
        	int[][] arr = new int[n][m];
        	for (int i = 0; i < n; i++){
        		for(int j = 0; j < m; j++){
        			arr[i][j] = nextInt();
        		}
        	}
        	return arr;
        }

        public long[][] nextLong2DArray(int n, int m){
        	long[][] arr = new long[n][m];
        	for (int i = 0; i < n; i++){
        		for(int j = 0; j < m; j++){
        			arr[i][j] = nextLong();
        		}
        	}
        	return arr;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
	}
}harFilter {
            public boolean isSpaceChar(int ch);
        }
	}
}/*
 * Author: Abhi Sapariya
 */
import java.util.*;
import java.io.*;
import java.math.*;
import java.text.DecimalFormat;

public class Solution{

	static long mod =(long)Math.pow(10,9)+7;
	static int INF = Integer.MAX_VALUE;
	static InputReader in;
    static PrintWriter out;

	public static void main(String[] args) {

		in = new InputReader(System.in);
		out = new PrintWriter(System.out);

		//CODE
		System.out.println("Testing");

	    out.close();
	}

	static long[] generate(int n, int[] arr, long p, long k, long q, int m){
		long[] x = new long[1000000];
		x[0] = 0;
		for(int i=1; i<n; i++){
			x[i] = x[i-1] + arr[(int)k];
			k = (p*k + q)%m;
		}
		return x;
	}

	static double area(long x1, long y1, long x2, long y2, long x3, long y3){
		return Math.abs(((x2-x1)*1d*(y3-y1) - (x3-x1)*1d*(y2-y1)))/2d;
	}

	static int max(int a, int b){
		return Math.max(a, b);
	}

	static long max(long a, long b){
		return Math.max(a, b);
	}
	static int min(int a, int b){
		return Math.min(a, b);
	}

	static long min(long a, long b){
		return Math.min(a,b);
	}

	static int abs(int a, int b){
		return Math.abs(a-b);
	}

	static long abs(long a, long b){
		return Math.abs(a-b);
	}

	static int sqrt(int a){
		return (int) Math.sqrt(a);
	}

	static long sqrt(long a){
		return (long) Math.sqrt(a);
	}

	static int gcd(int a, int b) {
		if (a == 0 || b == 0)
			return a + b;
		return gcd(b, a % b);
	}

	static long gcd(long a, long b) {
		if (a == 0 || b == 0)
			return a + b;
		return gcd(b, a % b);
	}

    static int power(int base, int exponent, int modulus){
	    int result = 1;
	    while (exponent > 0) {
	        if (exponent % 2 == 1)
	            result = (result * base) % modulus;
	        exponent = exponent >> 1;
	        base = (base * base) % modulus;
	    }
	    return result;
	}

    static long power(long base, long exponent, long modulus){
	    long result = 1L;
	    while (exponent > 0) {
	        if (exponent % 2L == 1L)
	            result = (result * base) % modulus;
	        exponent = exponent >> 1;
	        base = (base * base) % modulus;
	    }
	    return result;
	}

    static class Pair implements Comparable<Pair>{

    	int x;
    	int y;

    	public Pair(int x, int y){
    		this.x = x;
    		this.y = y;
    	}

    	// Ascending First X then Y
		@Override
		public int compareTo(Pair p) {
			if( x == p.x )
				return y-p.y;
			return x-p.x;
		}

		@Override
		public String toString(){
			return "(" + x + "," + y + ")";
		}
    }

    // This class represents a directed graph using adjacency list
	// representation
	class Graph {
		private int V; // No. of vertices

		// Array  of lists for Adjacency List Representation
		private LinkedList<Integer> adj[];

		// Constructor
		Graph(int v) {
			V = v;
			adj = new LinkedList[v];
			for (int i = 0; i < v; ++i)
				adj[i] = new LinkedList<Integer>();
		}

		//Function to add an edge into the graph
		void addEdge(int v, int w) {
			adj[v].add(w); // Add w to v's list.
		}

		// A function used by DFS
		void DFSUtil(int v, boolean visited[]) {
			// Mark the current node as visited and print it
			visited[v] = true;
			System.out.print(v + " ");

			// Recur for all the vertices adjacent to this vertex
			Iterator<Integer> i = adj[v].listIterator();
			while (i.hasNext()) {
				int n = i.next();
				if (!visited[n])
					DFSUtil(n, visited);
			}
		}

		// The function to do DFS traversal. It uses recursive DFSUtil()
		void DFS(int v) {
			// Mark all the vertices as not visited(set as
			// false by default in java)
			boolean visited[] = new boolean[V];

			// Call the recursive helper function to print DFS traversal
			DFSUtil(v, visited);
		}
	}

	// Class for primes utilities
	static class Primes{

	    //for marking all prime numbers greater than 1 and less than equal to N
	    boolean[] sieveOfEratosthenes(int n) {

			boolean prime[] = new boolean[n];
			// Create a boolean array "prime[0..n]" and initialize
			// all entries it as true. A value in prime[i] will
			// finally be false if i is Not a prime, else true.
			for (int i = 0; i < n; i++)
				prime[i] = true;

			for (int p = 2; p * p <= n; p++) {
				// If prime[p] is not changed, then it is a prime
				if (prime[p] == true) {
					// Update all multiples of p
					for (int i = p * 2; i <= n; i += p)
						prime[i] = false;
				}
			}

			return prime;
		}

	    ArrayList<Long> primeFactors(long n){
	    	ArrayList<Long> ans = new ArrayList<Long>();
	    	// Print the number of 2s that divide n
	        while (n%2L==0L)
	        {
	            ans.add(2L);
	            n /= 2L;
	        }

	        // n must be odd at this point.  So we can
	        // skip one element (Note i = i +2)
	        for (long i = 3; i <= Math.sqrt(n); i+= 2L)
	        {
	            // While i divides n, print i and divide n
	            while (n%i == 0)
	            {
	            	ans.add(i);
	                n /= i;
	            }
	        }

	        // This condition is to handle the case whien
	        // n is a prime number greater than 2
	        if (n > 2)
	            ans.add(n);
	        return ans;
	    }

	    //Minimum prime factors of number till n
		int[] minimumPrimeFactors(int n){
			int[] minPrime = new int[n+1];
			minPrime[1]=1;
	        for (int i = 2; i * i <= n; ++i) {
	            if (minPrime[i] == 0) {         //If i is prime
	                for (int j = i * i; j <= n; j += i) {
	                    if (minPrime[j] == 0) {
	                        minPrime[j] = i;
	                    }
	                }
	            }
	        }
	        for (int i = 2; i <= n; ++i) {
	            if (minPrime[i] == 0) {
	                minPrime[i] = i;
	            }
	        }
	        return minPrime;
		}

	    // isPrime
		boolean isPrime(long n) {
			if(n < 2L) return false;
			if(n == 2L || n == 3L) return true;
			if(n%2L == 0 || n%3L == 0) return false;
			long sqrtN = (long)Math.sqrt(n)+1L;
			for(long i = 6L; i <= sqrtN; i += 6L) {
				if(n%(i-1) == 0 || n%(i+1) == 0) return false;
			}
			return true;
		}
	}

    // Binary indexed Tree parameters (arr,arr.length)
    static class BITree {

		int[] tree;

		public BITree(int arr[], int n) {
			tree = new int[n + 1];
			for (int i = 0; i < n; i++) {
				update(i, arr[i]);
			}
		}

		public void update(int x, int val) {
			x++;
			while (x < tree.length) {
				tree[x] += val;
				x = next(x);
			}
		}

		public int sum(int x) {
			x++;
			int ans = 0;
			while (x > 0) {
				ans += tree[x];
				x = parent(x);
			}
			return ans;
		}

		public int parent(int x) {
			return x - (x & -x);
		}

		public int next(int x) {
			return x + (x & -x);
		}

	}

    // Range minimum query Segment Tree parameters - (arr,arr.length)
    static class SegmentTree {

		static int[] segT;

		public SegmentTree(int arr[], int n) {
			int nearPow = (int) (Math.ceil(Math.log(n) / Math.log(2)));
			int len = 2 * ((int) Math.pow(2, nearPow)) - 1;
			segT = new int[len];
			constructTree(arr, 0, n - 1, 0);
		}

		public void constructTree(int arr[], int low, int high, int pos) {
			if (low == high) {
				segT[pos] = arr[low];
				return;
			}

			int mid = (low + high) / 2;
			constructTree(arr, low, mid, 2 * pos + 1);
			constructTree(arr, mid + 1, high, 2 * pos + 2);
			segT[pos] = Math.min(segT[2 * pos + 1], segT[2 * pos + 2]);
		}

		public int rmq(int low, int high, int n) {
			return rmq(0, n - 1, low, high, 0);
		}

		public int rmq(int low, int high, int qlow, int qhigh, int pos) {

			if (qlow <= low && qhigh >= high) {
				return segT[pos];
			}
			if (high < qlow || qhigh < low) {
				return Integer.MAX_VALUE;
			}
			int mid = (low + high) / 2;
			return Math.min(rmq(low, mid, qlow, qhigh, 2 * pos + 1),
					rmq(mid + 1, high, qlow, qhigh, 2 * pos + 2));
		}

	}

    // Disjoint Union Set with Path Compression
    static class DUS{
    	int p;
    	int r;
    	DUS set[];

    	public DUS(int pr, int rk){
    		p = pr;
    		r = rk;
    	}

    	public DUS(int n){
    		set = new DUS[n+1];
    		for(int i=0; i<n; i++){
    			set[i] = new DUS(i,0);
    		}
    	}

    	public int find(int key){
    		if(set[key].p!=key){
    			set[key].p = find(set[key].p);
    		}
    		return set[key].p;
    	}

    	public void union(int x, int y){
    		int px = find(x);
    		int py = find(y);

    		if(set[px].r > set[py].r){
    			set[py].p = px;
    		}
    		else if(set[py].r > set[px].r){
    			set[px].p = py;
    		}
    		else{
    			set[py].p = px;
    			set[px].r++;
    		}
    	}
    }

	//Class for fibonacci utilities
	static class fibonacci {

		//Nth fibonacci number in log(n)
		public static long fib(long n, long mod) {
			long F[][] = new long[][] { { 1, 1 }, { 1, 0 } };
			if (n == 0l)
				return 0l;
			power(F, n - 1, mod);

			return F[0][0] % mod;
		}

		public static void multiply(long F[][], long M[][], long mod) {
			long x = (((F[0][0]) * (M[0][0])) % mod + ((F[0][1]) * (M[1][0]))
					% mod)
					% mod;
			long y = (((F[0][0]) * (M[0][1])) % mod + ((F[0][1]) * (M[1][1]))
					% mod)
					% mod;
			long z = (((F[1][0]) * (M[0][0])) % mod + ((F[1][1]) * (M[1][0]))
					% mod)
					% mod;
			long w = (((F[1][0]) * (M[0][1])) % mod + ((F[1][1]) * (M[1][1]))
					% mod)
					% mod;

			F[0][0] = x;
			F[0][1] = y;
			F[1][0] = z;
			F[1][1] = w;
		}

		/* Optimized version of power() in method 4 */
		public static void power(long F[][], long n, long mod) {
			if (n == 0l || n == 1l)
				return;
			long M[][] = new long[][] { { 1l, 1l }, { 1l, 0l } };

			power(F, n / 2l, mod);
			multiply(F, F, mod);
			if (n % 2l != 0l)
				multiply(F, M, mod);
		}

		static boolean isPerfectSquare(int x)
		{
		    int s = sqrt(x);
		    return (s*s == x);
		}

		// Returns true if n is a Fibinacci Number, else false
		static boolean isFibonacci(int n)
		{
		    // n is Fibinacci if one of 5*n*n + 4 or 5*n*n - 4 or both
		    // is a perferct square
		    return isPerfectSquare(5*n*n + 4) ||
		           isPerfectSquare(5*n*n - 4);
		}
	}

	static long modInverse(long A, long M)
	{
		long x=extendedEuclid(A,M)[0];
		return (x%M+M)%M;    //x may be negative
	}

	static long[] extendedEuclid(long A, long B) {
		if(B == 0) {
			long d = A;
			long x = 1;
			long y = 0;
			return new long[]{x,y,d};
		}
		else {
			long arr[]=extendedEuclid(B, A%B);
			long temp = arr[0];
			arr[0] = arr[1];
			arr[1] = temp - (A/B)*arr[1];
			return arr;
		}
	}

	public void printArr(int[] arr){
		for(int i = 0; i < arr.length; i++){
			out.print(arr[i] + " ");
		}
		out.println();
	}

	public void print2DArr(int[][] arr){
		for( int i = 0; i < arr.length; i++){
			for ( int j = 0; j < arr[0].length; j++){
				out.print(arr[i][j] + " ");
			}
			out.println();
		}
	}

	static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, numChars;
        private SpaceCharFilter filter;

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

        public 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 String nextLine() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }

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

        public long nextLong() {
            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 int nextInt() {
            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 int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

        public int[][] nextInt2DArray(int n, int m){
        	int[][] arr = new int[n][m];
        	for (int i = 0; i < n; i++){
        		for(int j = 0; j < m; j++){
        			arr[i][j] = nextInt();
        		}
        	}
        	return arr;
        }

        public long[][] nextLong2DArray(int n, int m){
        	long[][] arr = new long[n][m];
        	for (int i = 0; i < n; i++){
        		for(int j = 0; j < m; j++){
        			arr[i][j] = nextLong();
        		}
        	}
        	return arr;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
	}
}


import java.util.*;
public class a
{
    pubic static void main(String args[])

    {
        Scanner s=new Scanner(System.in);
        int n=s.nextInt();
        int m=s.nextInt();
        int k=s.nextInt();
        if(m>==n && k>==n)
            System.out.print("Yes");
        else
            System.out.print("No");
    }
}